Upgrade lzma to 23.01
This project was upgraded with external_updater.
Usage: tools/external_updater/updater.sh update external/lzma
For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
Test: TreeHugger
Change-Id: I56f7697a4e24afe360a4a6ccaa25f8c6e6e348a3
diff --git a/Asm/arm/7zCrcOpt.asm b/Asm/arm/7zCrcOpt.asm
index f008d65..6001d8e 100644
--- a/Asm/arm/7zCrcOpt.asm
+++ b/Asm/arm/7zCrcOpt.asm
@@ -1,100 +1,100 @@
- CODE32
-
- EXPORT |CrcUpdateT4@16|
-
- AREA |.text|, CODE, ARM
-
- MACRO
- CRC32_STEP_1
-
- ldrb r4, [r1], #1
- subs r2, r2, #1
- eor r4, r4, r0
- and r4, r4, #0xFF
- ldr r4, [r3, +r4, lsl #2]
- eor r0, r4, r0, lsr #8
-
- MEND
-
-
- MACRO
- CRC32_STEP_4 $STREAM_WORD
-
- eor r7, r7, r8
- eor r7, r7, r9
- eor r0, r0, r7
- eor r0, r0, $STREAM_WORD
- ldr $STREAM_WORD, [r1], #4
-
- and r7, r0, #0xFF
- and r8, r0, #0xFF00
- and r9, r0, #0xFF0000
- and r0, r0, #0xFF000000
-
- ldr r7, [r6, +r7, lsl #2]
- ldr r8, [r5, +r8, lsr #6]
- ldr r9, [r4, +r9, lsr #14]
- ldr r0, [r3, +r0, lsr #22]
-
- MEND
-
-
-|CrcUpdateT4@16| PROC
-
- stmdb sp!, {r4-r11, lr}
- cmp r2, #0
- beq |$fin|
-
-|$v1|
- tst r1, #7
- beq |$v2|
- CRC32_STEP_1
- bne |$v1|
-
-|$v2|
- cmp r2, #16
- blo |$v3|
-
- ldr r10, [r1], #4
- ldr r11, [r1], #4
-
- add r4, r3, #0x400
- add r5, r3, #0x800
- add r6, r3, #0xC00
-
- mov r7, #0
- mov r8, #0
- mov r9, #0
-
- sub r2, r2, #16
-
-|$loop|
- ; pld [r1, #0x40]
-
- CRC32_STEP_4 r10
- CRC32_STEP_4 r11
-
- subs r2, r2, #8
- bhs |$loop|
-
- sub r1, r1, #8
- add r2, r2, #16
-
- eor r7, r7, r8
- eor r7, r7, r9
- eor r0, r0, r7
-
-|$v3|
- cmp r2, #0
- beq |$fin|
-
-|$v4|
- CRC32_STEP_1
- bne |$v4|
-
-|$fin|
- ldmia sp!, {r4-r11, pc}
-
-|CrcUpdateT4@16| ENDP
-
- END
+ CODE32
+
+ EXPORT |CrcUpdateT4@16|
+
+ AREA |.text|, CODE, ARM
+
+ MACRO
+ CRC32_STEP_1
+
+ ldrb r4, [r1], #1
+ subs r2, r2, #1
+ eor r4, r4, r0
+ and r4, r4, #0xFF
+ ldr r4, [r3, +r4, lsl #2]
+ eor r0, r4, r0, lsr #8
+
+ MEND
+
+
+ MACRO
+ CRC32_STEP_4 $STREAM_WORD
+
+ eor r7, r7, r8
+ eor r7, r7, r9
+ eor r0, r0, r7
+ eor r0, r0, $STREAM_WORD
+ ldr $STREAM_WORD, [r1], #4
+
+ and r7, r0, #0xFF
+ and r8, r0, #0xFF00
+ and r9, r0, #0xFF0000
+ and r0, r0, #0xFF000000
+
+ ldr r7, [r6, +r7, lsl #2]
+ ldr r8, [r5, +r8, lsr #6]
+ ldr r9, [r4, +r9, lsr #14]
+ ldr r0, [r3, +r0, lsr #22]
+
+ MEND
+
+
+|CrcUpdateT4@16| PROC
+
+ stmdb sp!, {r4-r11, lr}
+ cmp r2, #0
+ beq |$fin|
+
+|$v1|
+ tst r1, #7
+ beq |$v2|
+ CRC32_STEP_1
+ bne |$v1|
+
+|$v2|
+ cmp r2, #16
+ blo |$v3|
+
+ ldr r10, [r1], #4
+ ldr r11, [r1], #4
+
+ add r4, r3, #0x400
+ add r5, r3, #0x800
+ add r6, r3, #0xC00
+
+ mov r7, #0
+ mov r8, #0
+ mov r9, #0
+
+ sub r2, r2, #16
+
+|$loop|
+ ; pld [r1, #0x40]
+
+ CRC32_STEP_4 r10
+ CRC32_STEP_4 r11
+
+ subs r2, r2, #8
+ bhs |$loop|
+
+ sub r1, r1, #8
+ add r2, r2, #16
+
+ eor r7, r7, r8
+ eor r7, r7, r9
+ eor r0, r0, r7
+
+|$v3|
+ cmp r2, #0
+ beq |$fin|
+
+|$v4|
+ CRC32_STEP_1
+ bne |$v4|
+
+|$fin|
+ ldmia sp!, {r4-r11, pc}
+
+|CrcUpdateT4@16| ENDP
+
+ END
diff --git a/Asm/arm64/7zAsm.S b/Asm/arm64/7zAsm.S
new file mode 100644
index 0000000..12e950b
--- /dev/null
+++ b/Asm/arm64/7zAsm.S
@@ -0,0 +1,181 @@
+// 7zAsm.S -- ASM macros for arm64
+// 2021-04-25 : Igor Pavlov : Public domain
+
+#define r0 x0
+#define r1 x1
+#define r2 x2
+#define r3 x3
+#define r4 x4
+#define r5 x5
+#define r6 x6
+#define r7 x7
+#define r8 x8
+#define r9 x9
+#define r10 x10
+#define r11 x11
+#define r12 x12
+#define r13 x13
+#define r14 x14
+#define r15 x15
+#define r16 x16
+#define r17 x17
+#define r18 x18
+#define r19 x19
+#define r20 x20
+#define r21 x21
+#define r22 x22
+#define r23 x23
+#define r24 x24
+#define r25 x25
+#define r26 x26
+#define r27 x27
+#define r28 x28
+#define r29 x29
+#define r30 x30
+
+#define REG_ABI_PARAM_0 r0
+#define REG_ABI_PARAM_1 r1
+#define REG_ABI_PARAM_2 r2
+
+
+.macro p2_add reg:req, param:req
+ add \reg, \reg, \param
+.endm
+
+.macro p2_sub reg:req, param:req
+ sub \reg, \reg, \param
+.endm
+
+.macro p2_sub_s reg:req, param:req
+ subs \reg, \reg, \param
+.endm
+
+.macro p2_and reg:req, param:req
+ and \reg, \reg, \param
+.endm
+
+.macro xor reg:req, param:req
+ eor \reg, \reg, \param
+.endm
+
+.macro or reg:req, param:req
+ orr \reg, \reg, \param
+.endm
+
+.macro shl reg:req, param:req
+ lsl \reg, \reg, \param
+.endm
+
+.macro shr reg:req, param:req
+ lsr \reg, \reg, \param
+.endm
+
+.macro sar reg:req, param:req
+ asr \reg, \reg, \param
+.endm
+
+.macro p1_neg reg:req
+ neg \reg, \reg
+.endm
+
+.macro dec reg:req
+ sub \reg, \reg, 1
+.endm
+
+.macro dec_s reg:req
+ subs \reg, \reg, 1
+.endm
+
+.macro inc reg:req
+ add \reg, \reg, 1
+.endm
+
+.macro inc_s reg:req
+ adds \reg, \reg, 1
+.endm
+
+
+.macro imul reg:req, param:req
+ mul \reg, \reg, \param
+.endm
+
+/*
+arm64 and arm use reverted c flag after subs/cmp instructions:
+ arm64-arm : x86
+ b.lo / b.cc : jb / jc
+ b.hs / b.cs : jae / jnc
+*/
+
+.macro jmp lab:req
+ b \lab
+.endm
+
+.macro je lab:req
+ b.eq \lab
+.endm
+
+.macro jz lab:req
+ b.eq \lab
+.endm
+
+.macro jnz lab:req
+ b.ne \lab
+.endm
+
+.macro jne lab:req
+ b.ne \lab
+.endm
+
+.macro jb lab:req
+ b.lo \lab
+.endm
+
+.macro jbe lab:req
+ b.ls \lab
+.endm
+
+.macro ja lab:req
+ b.hi \lab
+.endm
+
+.macro jae lab:req
+ b.hs \lab
+.endm
+
+
+.macro cmove dest:req, srcTrue:req
+ csel \dest, \srcTrue, \dest, eq
+.endm
+
+.macro cmovne dest:req, srcTrue:req
+ csel \dest, \srcTrue, \dest, ne
+.endm
+
+.macro cmovs dest:req, srcTrue:req
+ csel \dest, \srcTrue, \dest, mi
+.endm
+
+.macro cmovns dest:req, srcTrue:req
+ csel \dest, \srcTrue, \dest, pl
+.endm
+
+.macro cmovb dest:req, srcTrue:req
+ csel \dest, \srcTrue, \dest, lo
+.endm
+
+.macro cmovae dest:req, srcTrue:req
+ csel \dest, \srcTrue, \dest, hs
+.endm
+
+
+.macro MY_ALIGN_16 macro
+ .p2align 4,, (1 << 4) - 1
+.endm
+
+.macro MY_ALIGN_32 macro
+ .p2align 5,, (1 << 5) - 1
+.endm
+
+.macro MY_ALIGN_64 macro
+ .p2align 6,, (1 << 6) - 1
+.endm
diff --git a/Asm/arm64/LzmaDecOpt.S b/Asm/arm64/LzmaDecOpt.S
new file mode 100644
index 0000000..10dc473
--- /dev/null
+++ b/Asm/arm64/LzmaDecOpt.S
@@ -0,0 +1,1487 @@
+// LzmaDecOpt.S -- ARM64-ASM version of LzmaDec_DecodeReal_3() function
+// 2021-04-25 : Igor Pavlov : Public domain
+
+/*
+; 3 - is the code compatibility version of LzmaDec_DecodeReal_*()
+; function for check at link time.
+; That code is tightly coupled with LzmaDec_TryDummy()
+; and with another functions in LzmaDec.c file.
+; CLzmaDec structure, (probs) array layout, input and output of
+; LzmaDec_DecodeReal_*() must be equal in both versions (C / ASM).
+*/
+
+
+#include "7zAsm.S"
+
+ // .arch armv8-a
+ // .file "LzmaDecOpt.c"
+ .text
+ .align 2
+ .p2align 4,,15
+#ifdef __APPLE__
+ .globl _LzmaDec_DecodeReal_3
+#else
+ .global LzmaDec_DecodeReal_3
+#endif
+ // .type LzmaDec_DecodeReal_3, %function
+
+// #define _LZMA_SIZE_OPT 1
+
+#define LZMA_USE_4BYTES_FILL 1
+// #define LZMA_USE_2BYTES_COPY 1
+// #define LZMA_USE_CMOV_LZ_WRAP 1
+// #define _LZMA_PROB32 1
+
+#define MY_ALIGN_FOR_ENTRY MY_ALIGN_32
+#define MY_ALIGN_FOR_LOOP MY_ALIGN_32
+#define MY_ALIGN_FOR_LOOP_16 MY_ALIGN_16
+
+#ifdef _LZMA_PROB32
+ .equ PSHIFT , 2
+ .macro PLOAD dest:req, mem:req
+ ldr \dest, [\mem]
+ .endm
+ .macro PLOAD_PREINDEXED dest:req, mem:req, offset:req
+ ldr \dest, [\mem, \offset]!
+ .endm
+ .macro PLOAD_2 dest:req, mem1:req, mem2:req
+ ldr \dest, [\mem1, \mem2]
+ .endm
+ .macro PLOAD_LSL dest:req, mem1:req, mem2:req
+ ldr \dest, [\mem1, \mem2, lsl #PSHIFT]
+ .endm
+ .macro PSTORE src:req, mem:req
+ str \src, [\mem]
+ .endm
+ .macro PSTORE_2 src:req, mem1:req, mem2:req
+ str \src, [\mem1, \mem2]
+ .endm
+ .macro PSTORE_LSL src:req, mem1:req, mem2:req
+ str \src, [\mem1, \mem2, lsl #PSHIFT]
+ .endm
+ .macro PSTORE_LSL_M1 src:req, mem1:req, mem2:req, temp_reg:req
+ // you must check that temp_reg is free register when macro is used
+ add \temp_reg, \mem1, \mem2
+ str \src, [\temp_reg, \mem2]
+ .endm
+#else
+ // .equ PSHIFT , 1
+ #define PSHIFT 1
+ .macro PLOAD dest:req, mem:req
+ ldrh \dest, [\mem]
+ .endm
+ .macro PLOAD_PREINDEXED dest:req, mem:req, offset:req
+ ldrh \dest, [\mem, \offset]!
+ .endm
+ .macro PLOAD_2 dest:req, mem1:req, mem2:req
+ ldrh \dest, [\mem1, \mem2]
+ .endm
+ .macro PLOAD_LSL dest:req, mem1:req, mem2:req
+ ldrh \dest, [\mem1, \mem2, lsl #PSHIFT]
+ .endm
+ .macro PSTORE src:req, mem:req
+ strh \src, [\mem]
+ .endm
+ .macro PSTORE_2 src:req, mem1:req, mem2:req
+ strh \src, [\mem1, \mem2]
+ .endm
+ .macro PSTORE_LSL src:req, mem1:req, mem2:req
+ strh \src, [\mem1, \mem2, lsl #PSHIFT]
+ .endm
+ .macro PSTORE_LSL_M1 src:req, mem1:req, mem2:req, temp_reg:req
+ strh \src, [\mem1, \mem2]
+ .endm
+#endif
+
+.equ PMULT , (1 << PSHIFT)
+.equ PMULT_2 , (2 << PSHIFT)
+
+.equ kMatchSpecLen_Error_Data , (1 << 9)
+
+# x7 t0 : NORM_CALC : prob2 (IF_BIT_1)
+# x6 t1 : NORM_CALC : probs_state
+# x8 t2 : (LITM) temp : (TREE) temp
+# x4 t3 : (LITM) bit : (TREE) temp : UPDATE_0/UPDATE_0 temp
+# x10 t4 : (LITM) offs : (TREE) probs_PMULT : numBits
+# x9 t5 : (LITM) match : sym2 (ShortDist)
+# x1 t6 : (LITM) litm_prob : (TREE) prob_reg : pbPos
+# x2 t7 : (LITM) prm : probBranch : cnt
+# x3 sym : dist
+# x12 len
+# x0 range
+# x5 cod
+
+
+#define range w0
+
+// t6
+#define pbPos w1
+#define pbPos_R r1
+#define prob_reg w1
+#define litm_prob prob_reg
+
+// t7
+#define probBranch w2
+#define cnt w2
+#define cnt_R r2
+#define prm r2
+
+#define sym w3
+#define sym_R r3
+#define dist sym
+
+#define t3 w4
+#define bit w4
+#define bit_R r4
+#define update_temp_reg r4
+
+#define cod w5
+
+#define t1 w6
+#define t1_R r6
+#define probs_state t1_R
+
+#define t0 w7
+#define t0_R r7
+#define prob2 t0
+
+#define t2 w8
+#define t2_R r8
+
+// t5
+#define match w9
+#define sym2 w9
+#define sym2_R r9
+
+#define t4 w10
+#define t4_R r10
+
+#define offs w10
+#define offs_R r10
+
+#define probs r11
+
+#define len w12
+#define len_R x12
+
+#define state w13
+#define state_R r13
+
+#define dicPos r14
+#define buf r15
+#define bufLimit r16
+#define dicBufSize r17
+
+#define limit r19
+#define rep0 w20
+#define rep0_R r20
+#define rep1 w21
+#define rep2 w22
+#define rep3 w23
+#define dic r24
+#define probs_IsMatch r25
+#define probs_Spec r26
+#define checkDicSize w27
+#define processedPos w28
+#define pbMask w29
+#define lc2_lpMask w30
+
+
+.equ kNumBitModelTotalBits , 11
+.equ kBitModelTotal , (1 << kNumBitModelTotalBits)
+.equ kNumMoveBits , 5
+.equ kBitModelOffset , (kBitModelTotal - (1 << kNumMoveBits) + 1)
+
+.macro NORM_2 macro
+ ldrb t0, [buf], 1
+ shl range, 8
+ orr cod, t0, cod, lsl 8
+ /*
+ mov t0, cod
+ ldrb cod, [buf], 1
+ shl range, 8
+ bfi cod, t0, #8, #24
+ */
+.endm
+
+.macro TEST_HIGH_BYTE_range macro
+ tst range, 0xFF000000
+.endm
+
+.macro NORM macro
+ TEST_HIGH_BYTE_range
+ jnz 1f
+ NORM_2
+1:
+.endm
+
+
+# ---------- Branch MACROS ----------
+
+.macro UPDATE_0__0
+ sub prob2, probBranch, kBitModelOffset
+.endm
+
+.macro UPDATE_0__1
+ sub probBranch, probBranch, prob2, asr #(kNumMoveBits)
+.endm
+
+.macro UPDATE_0__2 probsArray:req, probOffset:req, probDisp:req
+ .if \probDisp == 0
+ PSTORE_2 probBranch, \probsArray, \probOffset
+ .elseif \probOffset == 0
+ PSTORE_2 probBranch, \probsArray, \probDisp * PMULT
+ .else
+ .error "unsupported"
+ // add update_temp_reg, \probsArray, \probOffset
+ PSTORE_2 probBranch, update_temp_reg, \probDisp * PMULT
+ .endif
+.endm
+
+.macro UPDATE_0 probsArray:req, probOffset:req, probDisp:req
+ UPDATE_0__0
+ UPDATE_0__1
+ UPDATE_0__2 \probsArray, \probOffset, \probDisp
+.endm
+
+
+.macro UPDATE_1 probsArray:req, probOffset:req, probDisp:req
+ // sub cod, cod, prob2
+ // sub range, range, prob2
+ p2_sub cod, range
+ sub range, prob2, range
+ sub prob2, probBranch, probBranch, lsr #(kNumMoveBits)
+ .if \probDisp == 0
+ PSTORE_2 prob2, \probsArray, \probOffset
+ .elseif \probOffset == 0
+ PSTORE_2 prob2, \probsArray, \probDisp * PMULT
+ .else
+ .error "unsupported"
+ // add update_temp_reg, \probsArray, \probOffset
+ PSTORE_2 prob2, update_temp_reg, \probDisp * PMULT
+ .endif
+.endm
+
+
+.macro CMP_COD_BASE
+ NORM
+ // lsr prob2, range, kNumBitModelTotalBits
+ // imul prob2, probBranch
+ // cmp cod, prob2
+ mov prob2, range
+ shr range, kNumBitModelTotalBits
+ imul range, probBranch
+ cmp cod, range
+.endm
+
+.macro CMP_COD_1 probsArray:req
+ PLOAD probBranch, \probsArray
+ CMP_COD_BASE
+.endm
+
+.macro CMP_COD_3 probsArray:req, probOffset:req, probDisp:req
+ .if \probDisp == 0
+ PLOAD_2 probBranch, \probsArray, \probOffset
+ .elseif \probOffset == 0
+ PLOAD_2 probBranch, \probsArray, \probDisp * PMULT
+ .else
+ .error "unsupported"
+ add update_temp_reg, \probsArray, \probOffset
+ PLOAD_2 probBranch, update_temp_reg, \probDisp * PMULT
+ .endif
+ CMP_COD_BASE
+.endm
+
+
+.macro IF_BIT_1_NOUP probsArray:req, probOffset:req, probDisp:req, toLabel:req
+ CMP_COD_3 \probsArray, \probOffset, \probDisp
+ jae \toLabel
+.endm
+
+
+.macro IF_BIT_1 probsArray:req, probOffset:req, probDisp:req, toLabel:req
+ IF_BIT_1_NOUP \probsArray, \probOffset, \probDisp, \toLabel
+ UPDATE_0 \probsArray, \probOffset, \probDisp
+.endm
+
+
+.macro IF_BIT_0_NOUP probsArray:req, probOffset:req, probDisp:req, toLabel:req
+ CMP_COD_3 \probsArray, \probOffset, \probDisp
+ jb \toLabel
+.endm
+
+.macro IF_BIT_0_NOUP_1 probsArray:req, toLabel:req
+ CMP_COD_1 \probsArray
+ jb \toLabel
+.endm
+
+
+# ---------- CMOV MACROS ----------
+
+.macro NORM_LSR
+ NORM
+ lsr t0, range, #kNumBitModelTotalBits
+.endm
+
+.macro COD_RANGE_SUB
+ subs t1, cod, t0
+ p2_sub range, t0
+.endm
+
+.macro RANGE_IMUL prob:req
+ imul t0, \prob
+.endm
+
+.macro NORM_CALC prob:req
+ NORM_LSR
+ RANGE_IMUL \prob
+ COD_RANGE_SUB
+.endm
+
+.macro CMOV_range
+ cmovb range, t0
+.endm
+
+.macro CMOV_code
+ cmovae cod, t1
+.endm
+
+.macro CMOV_code_Model_Pre prob:req
+ sub t0, \prob, kBitModelOffset
+ CMOV_code
+ cmovae t0, \prob
+.endm
+
+
+.macro PUP_BASE_2 prob:req, dest_reg:req
+ # only sar works for both 16/32 bit prob modes
+ sub \dest_reg, \prob, \dest_reg, asr #(kNumMoveBits)
+.endm
+
+.macro PUP prob:req, probPtr:req, mem2:req
+ PUP_BASE_2 \prob, t0
+ PSTORE_2 t0, \probPtr, \mem2
+.endm
+
+
+
+#define probs_PMULT t4_R
+
+.macro BIT_01
+ add probs_PMULT, probs, PMULT
+.endm
+
+
+.macro BIT_0_R prob:req
+ PLOAD_2 \prob, probs, 1 * PMULT
+ NORM_LSR
+ sub t3, \prob, kBitModelOffset
+ RANGE_IMUL \prob
+ PLOAD_2 t2, probs, 1 * PMULT_2
+ COD_RANGE_SUB
+ CMOV_range
+ cmovae t3, \prob
+ PLOAD_2 t0, probs, 1 * PMULT_2 + PMULT
+ PUP_BASE_2 \prob, t3
+ csel \prob, t2, t0, lo
+ CMOV_code
+ mov sym, 2
+ PSTORE_2 t3, probs, 1 * PMULT
+ adc sym, sym, wzr
+ BIT_01
+.endm
+
+.macro BIT_1_R prob:req
+ NORM_LSR
+ p2_add sym, sym
+ sub t3, \prob, kBitModelOffset
+ RANGE_IMUL \prob
+ PLOAD_LSL t2, probs, sym_R
+ COD_RANGE_SUB
+ CMOV_range
+ cmovae t3, \prob
+ PLOAD_LSL t0, probs_PMULT, sym_R
+ PUP_BASE_2 \prob, t3
+ csel \prob, t2, t0, lo
+ CMOV_code
+ PSTORE_LSL_M1 t3, probs, sym_R, t2_R
+ adc sym, sym, wzr
+.endm
+
+
+.macro BIT_2_R prob:req
+ NORM_LSR
+ p2_add sym, sym
+ sub t3, \prob, kBitModelOffset
+ RANGE_IMUL \prob
+ COD_RANGE_SUB
+ CMOV_range
+ cmovae t3, \prob
+ CMOV_code
+ PUP_BASE_2 \prob, t3
+ PSTORE_LSL_M1 t3, probs, sym_R, t2_R
+ adc sym, sym, wzr
+.endm
+
+
+# ---------- MATCHED LITERAL ----------
+
+.macro LITM_0 macro
+ shl match, (PSHIFT + 1)
+ and bit, match, 256 * PMULT
+ add prm, probs, 256 * PMULT + 1 * PMULT
+ p2_add match, match
+ p2_add prm, bit_R
+ eor offs, bit, 256 * PMULT
+ PLOAD litm_prob, prm
+
+ NORM_LSR
+ sub t2, litm_prob, kBitModelOffset
+ RANGE_IMUL litm_prob
+ COD_RANGE_SUB
+ cmovae offs, bit
+ CMOV_range
+ and bit, match, offs
+ cmovae t2, litm_prob
+ CMOV_code
+ mov sym, 2
+ PUP_BASE_2 litm_prob, t2
+ PSTORE t2, prm
+ add prm, probs, offs_R
+ adc sym, sym, wzr
+.endm
+
+.macro LITM macro
+ p2_add prm, bit_R
+ xor offs, bit
+ PLOAD_LSL litm_prob, prm, sym_R
+
+ NORM_LSR
+ p2_add match, match
+ sub t2, litm_prob, kBitModelOffset
+ RANGE_IMUL litm_prob
+ COD_RANGE_SUB
+ cmovae offs, bit
+ CMOV_range
+ and bit, match, offs
+ cmovae t2, litm_prob
+ CMOV_code
+ PUP_BASE_2 litm_prob, t2
+ PSTORE_LSL t2, prm, sym_R
+ add prm, probs, offs_R
+ adc sym, sym, sym
+.endm
+
+
+.macro LITM_2 macro
+ p2_add prm, bit_R
+ PLOAD_LSL litm_prob, prm, sym_R
+
+ NORM_LSR
+ sub t2, litm_prob, kBitModelOffset
+ RANGE_IMUL litm_prob
+ COD_RANGE_SUB
+ CMOV_range
+ cmovae t2, litm_prob
+ CMOV_code
+ PUP_BASE_2 litm_prob, t2
+ PSTORE_LSL t2, prm, sym_R
+ adc sym, sym, sym
+.endm
+
+
+# ---------- REVERSE BITS ----------
+
+.macro REV_0 prob:req
+ NORM_CALC \prob
+ CMOV_range
+ PLOAD t2, sym2_R
+ PLOAD_2 t3, probs, 3 * PMULT
+ CMOV_code_Model_Pre \prob
+ add t1_R, probs, 3 * PMULT
+ cmovae sym2_R, t1_R
+ PUP \prob, probs, 1 * PMULT
+ csel \prob, t2, t3, lo
+.endm
+
+
+.macro REV_1 prob:req, step:req
+ NORM_LSR
+ PLOAD_PREINDEXED t2, sym2_R, (\step * PMULT)
+ RANGE_IMUL \prob
+ COD_RANGE_SUB
+ CMOV_range
+ PLOAD_2 t3, sym2_R, (\step * PMULT)
+ sub t0, \prob, kBitModelOffset
+ CMOV_code
+ add t1_R, sym2_R, \step * PMULT
+ cmovae t0, \prob
+ cmovae sym2_R, t1_R
+ PUP_BASE_2 \prob, t0
+ csel \prob, t2, t3, lo
+ PSTORE_2 t0, t1_R, 0 - \step * PMULT_2
+.endm
+
+
+.macro REV_2 prob:req, step:req
+ sub t1_R, sym2_R, probs
+ NORM_LSR
+ orr sym, sym, t1, lsr #PSHIFT
+ RANGE_IMUL \prob
+ COD_RANGE_SUB
+ sub t2, sym, \step
+ CMOV_range
+ cmovb sym, t2
+ CMOV_code_Model_Pre \prob
+ PUP \prob, sym2_R, 0
+.endm
+
+
+.macro REV_1_VAR prob:req
+ PLOAD \prob, sym_R
+ mov probs, sym_R
+ p2_add sym_R, sym2_R
+ NORM_LSR
+ add t2_R, sym_R, sym2_R
+ RANGE_IMUL \prob
+ COD_RANGE_SUB
+ cmovae sym_R, t2_R
+ CMOV_range
+ CMOV_code_Model_Pre \prob
+ p2_add sym2, sym2
+ PUP \prob, probs, 0
+.endm
+
+
+.macro add_big dest:req, src:req, param:req
+ .if (\param) < (1 << 12)
+ add \dest, \src, \param
+ .else
+ #ifndef _LZMA_PROB32
+ .error "unexpcted add_big expansion"
+ #endif
+ add \dest, \src, (\param) / 2
+ add \dest, \dest, (\param) - (\param) / 2
+ .endif
+.endm
+
+.macro sub_big dest:req, src:req, param:req
+ .if (\param) < (1 << 12)
+ sub \dest, \src, \param
+ .else
+ #ifndef _LZMA_PROB32
+ .error "unexpcted sub_big expansion"
+ #endif
+ sub \dest, \src, (\param) / 2
+ sub \dest, \dest, (\param) - (\param) / 2
+ .endif
+.endm
+
+
+.macro SET_probs offset:req
+ // add_big probs, probs_Spec, (\offset) * PMULT
+ add probs, probs_IsMatch, ((\offset) - IsMatch) * PMULT
+.endm
+
+
+.macro LIT_PROBS
+ add sym, sym, processedPos, lsl 8
+ inc processedPos
+ UPDATE_0__0
+ shl sym, lc2_lpMask
+ SET_probs Literal
+ p2_and sym, lc2_lpMask
+ // p2_add probs_state, pbPos_R
+ p2_add probs, sym_R
+ UPDATE_0__1
+ add probs, probs, sym_R, lsl 1
+ UPDATE_0__2 probs_state, pbPos_R, 0
+.endm
+
+
+
+.equ kNumPosBitsMax , 4
+.equ kNumPosStatesMax , (1 << kNumPosBitsMax)
+
+.equ kLenNumLowBits , 3
+.equ kLenNumLowSymbols , (1 << kLenNumLowBits)
+.equ kLenNumHighBits , 8
+.equ kLenNumHighSymbols , (1 << kLenNumHighBits)
+.equ kNumLenProbs , (2 * kLenNumLowSymbols * kNumPosStatesMax + kLenNumHighSymbols)
+
+.equ LenLow , 0
+.equ LenChoice , LenLow
+.equ LenChoice2 , (LenLow + kLenNumLowSymbols)
+.equ LenHigh , (LenLow + 2 * kLenNumLowSymbols * kNumPosStatesMax)
+
+.equ kNumStates , 12
+.equ kNumStates2 , 16
+.equ kNumLitStates , 7
+
+.equ kStartPosModelIndex , 4
+.equ kEndPosModelIndex , 14
+.equ kNumFullDistances , (1 << (kEndPosModelIndex >> 1))
+
+.equ kNumPosSlotBits , 6
+.equ kNumLenToPosStates , 4
+
+.equ kNumAlignBits , 4
+.equ kAlignTableSize , (1 << kNumAlignBits)
+
+.equ kMatchMinLen , 2
+.equ kMatchSpecLenStart , (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
+
+// .equ kStartOffset , 1408
+.equ kStartOffset , 0
+.equ SpecPos , (-kStartOffset)
+.equ IsRep0Long , (SpecPos + kNumFullDistances)
+.equ RepLenCoder , (IsRep0Long + (kNumStates2 << kNumPosBitsMax))
+.equ LenCoder , (RepLenCoder + kNumLenProbs)
+.equ IsMatch , (LenCoder + kNumLenProbs)
+.equ kAlign , (IsMatch + (kNumStates2 << kNumPosBitsMax))
+.equ IsRep , (kAlign + kAlignTableSize)
+.equ IsRepG0 , (IsRep + kNumStates)
+.equ IsRepG1 , (IsRepG0 + kNumStates)
+.equ IsRepG2 , (IsRepG1 + kNumStates)
+.equ PosSlot , (IsRepG2 + kNumStates)
+.equ Literal , (PosSlot + (kNumLenToPosStates << kNumPosSlotBits))
+.equ NUM_BASE_PROBS , (Literal + kStartOffset)
+
+.if kStartOffset != 0 // && IsMatch != 0
+ .error "Stop_Compiling_Bad_StartOffset"
+.endif
+
+.if NUM_BASE_PROBS != 1984
+ .error "Stop_Compiling_Bad_LZMA_PROBS"
+.endif
+
+.equ offset_lc , 0
+.equ offset_lp , 1
+.equ offset_pb , 2
+.equ offset_dicSize , 4
+.equ offset_probs , 4 + offset_dicSize
+.equ offset_probs_1664 , 8 + offset_probs
+.equ offset_dic , 8 + offset_probs_1664
+.equ offset_dicBufSize , 8 + offset_dic
+.equ offset_dicPos , 8 + offset_dicBufSize
+.equ offset_buf , 8 + offset_dicPos
+.equ offset_range , 8 + offset_buf
+.equ offset_code , 4 + offset_range
+.equ offset_processedPos , 4 + offset_code
+.equ offset_checkDicSize , 4 + offset_processedPos
+.equ offset_rep0 , 4 + offset_checkDicSize
+.equ offset_rep1 , 4 + offset_rep0
+.equ offset_rep2 , 4 + offset_rep1
+.equ offset_rep3 , 4 + offset_rep2
+.equ offset_state , 4 + offset_rep3
+.equ offset_remainLen , 4 + offset_state
+.equ offset_TOTAL_SIZE , 4 + offset_remainLen
+
+.if offset_TOTAL_SIZE != 96
+ .error "Incorrect offset_TOTAL_SIZE"
+.endif
+
+
+.macro IsMatchBranch_Pre
+ # prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
+ and pbPos, pbMask, processedPos, lsl #(kLenNumLowBits + 1 + PSHIFT)
+ add probs_state, probs_IsMatch, state_R
+.endm
+
+
+/*
+.macro IsMatchBranch
+ IsMatchBranch_Pre
+ IF_BIT_1 probs_state, pbPos_R, (IsMatch - IsMatch), IsMatch_label
+.endm
+*/
+
+.macro CheckLimits
+ cmp buf, bufLimit
+ jae fin_OK
+ cmp dicPos, limit
+ jae fin_OK
+.endm
+
+#define CheckLimits_lit CheckLimits
+/*
+.macro CheckLimits_lit
+ cmp buf, bufLimit
+ jae fin_OK_lit
+ cmp dicPos, limit
+ jae fin_OK_lit
+.endm
+*/
+
+
+#define PARAM_lzma REG_ABI_PARAM_0
+#define PARAM_limit REG_ABI_PARAM_1
+#define PARAM_bufLimit REG_ABI_PARAM_2
+
+
+.macro LOAD_LZMA_VAR reg:req, struct_offs:req
+ ldr \reg, [PARAM_lzma, \struct_offs]
+.endm
+
+.macro LOAD_LZMA_BYTE reg:req, struct_offs:req
+ ldrb \reg, [PARAM_lzma, \struct_offs]
+.endm
+
+.macro LOAD_LZMA_PAIR reg0:req, reg1:req, struct_offs:req
+ ldp \reg0, \reg1, [PARAM_lzma, \struct_offs]
+.endm
+
+
+LzmaDec_DecodeReal_3:
+_LzmaDec_DecodeReal_3:
+/*
+.LFB0:
+ .cfi_startproc
+*/
+
+ stp x19, x20, [sp, -128]!
+ stp x21, x22, [sp, 16]
+ stp x23, x24, [sp, 32]
+ stp x25, x26, [sp, 48]
+ stp x27, x28, [sp, 64]
+ stp x29, x30, [sp, 80]
+
+ str PARAM_lzma, [sp, 120]
+
+ mov bufLimit, PARAM_bufLimit
+ mov limit, PARAM_limit
+
+ LOAD_LZMA_PAIR dic, dicBufSize, offset_dic
+ LOAD_LZMA_PAIR dicPos, buf, offset_dicPos
+ LOAD_LZMA_PAIR rep0, rep1, offset_rep0
+ LOAD_LZMA_PAIR rep2, rep3, offset_rep2
+
+ mov t0, 1 << (kLenNumLowBits + 1 + PSHIFT)
+ LOAD_LZMA_BYTE pbMask, offset_pb
+ p2_add limit, dic
+ mov len, wzr // we can set it in all requiread branches instead
+ lsl pbMask, t0, pbMask
+ p2_add dicPos, dic
+ p2_sub pbMask, t0
+
+ LOAD_LZMA_BYTE lc2_lpMask, offset_lc
+ mov t0, 256 << PSHIFT
+ LOAD_LZMA_BYTE t1, offset_lp
+ p2_add t1, lc2_lpMask
+ p2_sub lc2_lpMask, (256 << PSHIFT) - PSHIFT
+ shl t0, t1
+ p2_add lc2_lpMask, t0
+
+ LOAD_LZMA_VAR probs_Spec, offset_probs
+ LOAD_LZMA_VAR checkDicSize, offset_checkDicSize
+ LOAD_LZMA_VAR processedPos, offset_processedPos
+ LOAD_LZMA_VAR state, offset_state
+ // range is r0 : this load must be last don't move
+ LOAD_LZMA_PAIR range, cod, offset_range
+ mov sym, wzr
+ shl state, PSHIFT
+
+ add_big probs_IsMatch, probs_Spec, ((IsMatch - SpecPos) << PSHIFT)
+
+ // if (processedPos != 0 || checkDicSize != 0)
+ orr t0, checkDicSize, processedPos
+ cbz t0, 1f
+ add t0_R, dicBufSize, dic
+ cmp dicPos, dic
+ cmovne t0_R, dicPos
+ ldrb sym, [t0_R, -1]
+1:
+ IsMatchBranch_Pre
+ cmp state, 4 * PMULT
+ jb lit_end
+ cmp state, kNumLitStates * PMULT
+ jb lit_matched_end
+ jmp lz_end
+
+
+
+#define BIT_0 BIT_0_R prob_reg
+#define BIT_1 BIT_1_R prob_reg
+#define BIT_2 BIT_2_R prob_reg
+
+# ---------- LITERAL ----------
+MY_ALIGN_64
+lit_start:
+ mov state, wzr
+lit_start_2:
+ LIT_PROBS
+
+ #ifdef _LZMA_SIZE_OPT
+
+ PLOAD_2 prob_reg, probs, 1 * PMULT
+ mov sym, 1
+ BIT_01
+MY_ALIGN_FOR_LOOP
+lit_loop:
+ BIT_1
+ tbz sym, 7, lit_loop
+
+ #else
+
+ BIT_0
+ BIT_1
+ BIT_1
+ BIT_1
+ BIT_1
+ BIT_1
+ BIT_1
+
+ #endif
+
+ BIT_2
+ IsMatchBranch_Pre
+ strb sym, [dicPos], 1
+ p2_and sym, 255
+
+ CheckLimits_lit
+lit_end:
+ IF_BIT_0_NOUP probs_state, pbPos_R, (IsMatch - IsMatch), lit_start
+
+ # jmp IsMatch_label
+
+
+#define FLAG_STATE_BITS (4 + PSHIFT)
+
+# ---------- MATCHES ----------
+# MY_ALIGN_FOR_ENTRY
+IsMatch_label:
+ UPDATE_1 probs_state, pbPos_R, (IsMatch - IsMatch)
+ IF_BIT_1 probs_state, 0, (IsRep - IsMatch), IsRep_label
+
+ SET_probs LenCoder
+ or state, (1 << FLAG_STATE_BITS)
+
+# ---------- LEN DECODE ----------
+len_decode:
+ mov len, 8 - kMatchMinLen
+ IF_BIT_0_NOUP_1 probs, len_mid_0
+ UPDATE_1 probs, 0, 0
+ p2_add probs, (1 << (kLenNumLowBits + PSHIFT))
+ mov len, 0 - kMatchMinLen
+ IF_BIT_0_NOUP_1 probs, len_mid_0
+ UPDATE_1 probs, 0, 0
+ p2_add probs, LenHigh * PMULT - (1 << (kLenNumLowBits + PSHIFT))
+
+ #if 0 == 1
+ BIT_0
+ BIT_1
+ BIT_1
+ BIT_1
+ BIT_1
+ BIT_1
+ #else
+ PLOAD_2 prob_reg, probs, 1 * PMULT
+ mov sym, 1
+ BIT_01
+MY_ALIGN_FOR_LOOP
+len8_loop:
+ BIT_1
+ tbz sym, 6, len8_loop
+ #endif
+
+ mov len, (kLenNumHighSymbols - kLenNumLowSymbols * 2) - kMatchMinLen
+ jmp len_mid_2
+
+MY_ALIGN_FOR_ENTRY
+len_mid_0:
+ UPDATE_0 probs, 0, 0
+ p2_add probs, pbPos_R
+ BIT_0
+len_mid_2:
+ BIT_1
+ BIT_2
+ sub len, sym, len
+ tbz state, FLAG_STATE_BITS, copy_match
+
+# ---------- DECODE DISTANCE ----------
+ // probs + PosSlot + ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
+
+ mov t0, 3 + kMatchMinLen
+ cmp len, 3 + kMatchMinLen
+ cmovb t0, len
+ SET_probs PosSlot - (kMatchMinLen << (kNumPosSlotBits))
+ add probs, probs, t0_R, lsl #(kNumPosSlotBits + PSHIFT)
+
+ #ifdef _LZMA_SIZE_OPT
+
+ PLOAD_2 prob_reg, probs, 1 * PMULT
+ mov sym, 1
+ BIT_01
+MY_ALIGN_FOR_LOOP
+slot_loop:
+ BIT_1
+ tbz sym, 5, slot_loop
+
+ #else
+
+ BIT_0
+ BIT_1
+ BIT_1
+ BIT_1
+ BIT_1
+
+ #endif
+
+ #define numBits t4
+ mov numBits, sym
+ BIT_2
+ // we need only low bits
+ p2_and sym, 3
+ cmp numBits, 32 + kEndPosModelIndex / 2
+ jb short_dist
+
+ SET_probs kAlign
+
+ # unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
+ p2_sub numBits, (32 + 1 + kNumAlignBits)
+ # distance = (2 | (distance & 1));
+ or sym, 2
+ PLOAD_2 prob_reg, probs, 1 * PMULT
+ add sym2_R, probs, 2 * PMULT
+
+# ---------- DIRECT DISTANCE ----------
+
+.macro DIRECT_1
+ shr range, 1
+ subs t0, cod, range
+ p2_add sym, sym
+ // add t1, sym, 1
+ csel cod, cod, t0, mi
+ csinc sym, sym, sym, mi
+ // csel sym, t1, sym, pl
+ // adc sym, sym, sym // not 100% compatible for "corruptued-allowed" LZMA streams
+ dec_s numBits
+ je direct_end
+.endm
+
+ #ifdef _LZMA_SIZE_OPT
+
+ jmp direct_norm
+MY_ALIGN_FOR_ENTRY
+direct_loop:
+ DIRECT_1
+direct_norm:
+ TEST_HIGH_BYTE_range
+ jnz direct_loop
+ NORM_2
+ jmp direct_loop
+
+ #else
+
+.macro DIRECT_2
+ TEST_HIGH_BYTE_range
+ jz direct_unroll
+ DIRECT_1
+.endm
+
+ DIRECT_2
+ DIRECT_2
+ DIRECT_2
+ DIRECT_2
+ DIRECT_2
+ DIRECT_2
+ DIRECT_2
+ DIRECT_2
+
+direct_unroll:
+ NORM_2
+ DIRECT_1
+ DIRECT_1
+ DIRECT_1
+ DIRECT_1
+ DIRECT_1
+ DIRECT_1
+ DIRECT_1
+ DIRECT_1
+ jmp direct_unroll
+
+ #endif
+
+MY_ALIGN_FOR_ENTRY
+direct_end:
+ shl sym, kNumAlignBits
+ REV_0 prob_reg
+ REV_1 prob_reg, 2
+ REV_1 prob_reg, 4
+ REV_2 prob_reg, 8
+
+decode_dist_end:
+
+ // if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
+
+ tst checkDicSize, checkDicSize
+ csel t0, processedPos, checkDicSize, eq
+ cmp sym, t0
+ jae end_of_payload
+ // jmp end_of_payload # for debug
+
+ mov rep3, rep2
+ mov rep2, rep1
+ mov rep1, rep0
+ add rep0, sym, 1
+
+.macro STATE_UPDATE_FOR_MATCH
+ // state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
+ // cmp state, (kNumStates + kNumLitStates) * PMULT
+ cmp state, kNumLitStates * PMULT + (1 << FLAG_STATE_BITS)
+ mov state, kNumLitStates * PMULT
+ mov t0, (kNumLitStates + 3) * PMULT
+ cmovae state, t0
+.endm
+ STATE_UPDATE_FOR_MATCH
+
+# ---------- COPY MATCH ----------
+copy_match:
+
+ // if ((rem = limit - dicPos) == 0) break // return SZ_ERROR_DATA;
+ subs cnt_R, limit, dicPos
+ // jz fin_dicPos_LIMIT
+ jz fin_OK
+
+ // curLen = ((rem < len) ? (unsigned)rem : len);
+ cmp cnt_R, len_R
+ cmovae cnt, len
+
+ sub t0_R, dicPos, dic
+ p2_add dicPos, cnt_R
+ p2_add processedPos, cnt
+ p2_sub len, cnt
+
+ // pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
+ p2_sub_s t0_R, rep0_R
+ jae 1f
+
+ cmn t0_R, cnt_R
+ p2_add t0_R, dicBufSize
+ ja copy_match_cross
+1:
+# ---------- COPY MATCH FAST ----------
+ # t0_R : src_pos
+ p2_add t0_R, dic
+ ldrb sym, [t0_R]
+ p2_add t0_R, cnt_R
+ p1_neg cnt_R
+
+copy_common:
+ dec dicPos
+
+ # dicPos : (ptr_to_last_dest_BYTE)
+ # t0_R : (src_lim)
+ # cnt_R : (-curLen)
+
+ IsMatchBranch_Pre
+
+ inc_s cnt_R
+ jz copy_end
+
+ cmp rep0, 1
+ je copy_match_0
+
+ #ifdef LZMA_USE_2BYTES_COPY
+ strb sym, [dicPos, cnt_R]
+ dec dicPos
+ # dicPos : (ptr_to_last_dest_16bitWORD)
+ p2_and cnt_R, -2
+ ldrh sym, [t0_R, cnt_R]
+ adds cnt_R, cnt_R, 2
+ jz 2f
+MY_ALIGN_FOR_LOOP
+1:
+ /*
+ strh sym, [dicPos, cnt_R]
+ ldrh sym, [t0_R, cnt_R]
+ adds cnt_R, cnt_R, 2
+ jz 2f
+ */
+
+ strh sym, [dicPos, cnt_R]
+ ldrh sym, [t0_R, cnt_R]
+ adds cnt_R, cnt_R, 2
+ jnz 1b
+2:
+
+ /*
+ // for universal little/big endian code, but slow
+ strh sym, [dicPos]
+ inc dicPos
+ ldrb sym, [t0_R, -1]
+ */
+
+ #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ // we must improve big-endian detection for another compilers
+ // for big-endian we need to revert bytes
+ rev16 sym, sym
+ #endif
+
+ // (sym) must represent as little-endian here:
+ strb sym, [dicPos], 1
+ shr sym, 8
+
+ #else
+
+MY_ALIGN_FOR_LOOP
+1:
+ strb sym, [dicPos, cnt_R]
+ ldrb sym, [t0_R, cnt_R]
+ inc_s cnt_R
+ jz copy_end
+
+ strb sym, [dicPos, cnt_R]
+ ldrb sym, [t0_R, cnt_R]
+ inc_s cnt_R
+ jnz 1b
+ #endif
+
+copy_end:
+lz_end_match:
+ strb sym, [dicPos], 1
+
+ # IsMatchBranch_Pre
+ CheckLimits
+lz_end:
+ IF_BIT_1_NOUP probs_state, pbPos_R, (IsMatch - IsMatch), IsMatch_label
+
+
+
+# ---------- LITERAL MATCHED ----------
+
+ LIT_PROBS
+
+ // matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
+
+ sub t0_R, dicPos, dic
+ p2_sub_s t0_R, rep0_R
+
+ #ifdef LZMA_USE_CMOV_LZ_WRAP
+ add t1_R, t0_R, dicBufSize
+ cmovb t0_R, t1_R
+ #else
+ jae 1f
+ p2_add t0_R, dicBufSize
+1:
+ #endif
+
+ ldrb match, [dic, t0_R]
+
+ // state -= (state < 10) ? 3 : 6;
+ sub sym, state, 6 * PMULT
+ cmp state, 10 * PMULT
+ p2_sub state, 3 * PMULT
+ cmovae state, sym
+
+ #ifdef _LZMA_SIZE_OPT
+
+ mov offs, 256 * PMULT
+ shl match, (PSHIFT + 1)
+ mov sym, 1
+ and bit, match, offs
+ add prm, probs, offs_R
+
+MY_ALIGN_FOR_LOOP
+litm_loop:
+ LITM
+ tbz sym, 8, litm_loop
+
+ #else
+
+ LITM_0
+ LITM
+ LITM
+ LITM
+ LITM
+ LITM
+ LITM
+ LITM_2
+
+ #endif
+
+ IsMatchBranch_Pre
+ strb sym, [dicPos], 1
+ p2_and sym, 255
+
+ // mov len, wzr // LITM uses same regisetr (len / offs). So we clear it
+ CheckLimits_lit
+lit_matched_end:
+ IF_BIT_1_NOUP probs_state, pbPos_R, (IsMatch - IsMatch), IsMatch_label
+ # IsMatchBranch
+ p2_sub state, 3 * PMULT
+ jmp lit_start_2
+
+
+
+# ---------- REP 0 LITERAL ----------
+MY_ALIGN_FOR_ENTRY
+IsRep0Short_label:
+ UPDATE_0 probs_state, pbPos_R, 0
+
+ // dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
+ sub t0_R, dicPos, dic
+
+ // state = state < kNumLitStates ? 9 : 11;
+ or state, 1 * PMULT
+
+ # the caller doesn't allow (dicPos >= limit) case for REP_SHORT
+ # so we don't need the following (dicPos == limit) check here:
+ # cmp dicPos, limit
+ # jae fin_dicPos_LIMIT_REP_SHORT
+ # // jmp fin_dicPos_LIMIT_REP_SHORT // for testing/debug puposes
+
+ inc processedPos
+
+ IsMatchBranch_Pre
+
+ p2_sub_s t0_R, rep0_R
+ #ifdef LZMA_USE_CMOV_LZ_WRAP
+ add sym_R, t0_R, dicBufSize
+ cmovb t0_R, sym_R
+ #else
+ jae 1f
+ p2_add t0_R, dicBufSize
+1:
+ #endif
+
+ ldrb sym, [dic, t0_R]
+ // mov len, wzr
+ jmp lz_end_match
+
+MY_ALIGN_FOR_ENTRY
+IsRep_label:
+ UPDATE_1 probs_state, 0, (IsRep - IsMatch)
+
+ # The (checkDicSize == 0 && processedPos == 0) case was checked before in LzmaDec.c with kBadRepCode.
+ # So we don't check it here.
+
+ # mov t0, processedPos
+ # or t0, checkDicSize
+ # jz fin_ERROR_2
+
+ // state = state < kNumLitStates ? 8 : 11;
+ cmp state, kNumLitStates * PMULT
+ mov state, 8 * PMULT
+ mov probBranch, 11 * PMULT
+ cmovae state, probBranch
+
+ SET_probs RepLenCoder
+
+ IF_BIT_1 probs_state, 0, (IsRepG0 - IsMatch), IsRepG0_label
+ sub_big probs_state, probs_state, (IsMatch - IsRep0Long) << PSHIFT
+ IF_BIT_0_NOUP probs_state, pbPos_R, 0, IsRep0Short_label
+ UPDATE_1 probs_state, pbPos_R, 0
+ jmp len_decode
+
+MY_ALIGN_FOR_ENTRY
+IsRepG0_label:
+ UPDATE_1 probs_state, 0, (IsRepG0 - IsMatch)
+ IF_BIT_1 probs_state, 0, (IsRepG1 - IsMatch), IsRepG1_label
+ mov dist, rep1
+ mov rep1, rep0
+ mov rep0, dist
+ jmp len_decode
+
+# MY_ALIGN_FOR_ENTRY
+IsRepG1_label:
+ UPDATE_1 probs_state, 0, (IsRepG1 - IsMatch)
+ IF_BIT_1 probs_state, 0, (IsRepG2 - IsMatch), IsRepG2_label
+ mov dist, rep2
+ mov rep2, rep1
+ mov rep1, rep0
+ mov rep0, dist
+ jmp len_decode
+
+# MY_ALIGN_FOR_ENTRY
+IsRepG2_label:
+ UPDATE_1 probs_state, 0, (IsRepG2 - IsMatch)
+ mov dist, rep3
+ mov rep3, rep2
+ mov rep2, rep1
+ mov rep1, rep0
+ mov rep0, dist
+ jmp len_decode
+
+
+
+# ---------- SPEC SHORT DISTANCE ----------
+
+MY_ALIGN_FOR_ENTRY
+short_dist:
+ p2_sub_s numBits, 32 + 1
+ jbe decode_dist_end
+ or sym, 2
+ shl sym, numBits
+ add sym_R, probs_Spec, sym_R, lsl #PSHIFT
+ p2_add sym_R, SpecPos * PMULT + 1 * PMULT
+ mov sym2, PMULT // # step
+MY_ALIGN_FOR_LOOP
+spec_loop:
+ REV_1_VAR prob_reg
+ dec_s numBits
+ jnz spec_loop
+
+ p2_add sym2_R, probs_Spec
+ .if SpecPos != 0
+ p2_add sym2_R, SpecPos * PMULT
+ .endif
+ p2_sub sym_R, sym2_R
+ shr sym, PSHIFT
+
+ jmp decode_dist_end
+
+
+
+# ---------- COPY MATCH 0 ----------
+MY_ALIGN_FOR_ENTRY
+copy_match_0:
+ #ifdef LZMA_USE_4BYTES_FILL
+ strb sym, [dicPos, cnt_R]
+ inc_s cnt_R
+ jz copy_end
+
+ strb sym, [dicPos, cnt_R]
+ inc_s cnt_R
+ jz copy_end
+
+ strb sym, [dicPos, cnt_R]
+ inc_s cnt_R
+ jz copy_end
+
+ orr t3, sym, sym, lsl 8
+ p2_and cnt_R, -4
+ orr t3, t3, t3, lsl 16
+MY_ALIGN_FOR_LOOP_16
+1:
+ /*
+ str t3, [dicPos, cnt_R]
+ adds cnt_R, cnt_R, 4
+ jz 2f
+ */
+
+ str t3, [dicPos, cnt_R]
+ adds cnt_R, cnt_R, 4
+ jnz 1b
+2:
+ // p2_and sym, 255
+ #else
+
+MY_ALIGN_FOR_LOOP
+1:
+ strb sym, [dicPos, cnt_R]
+ inc_s cnt_R
+ jz copy_end
+
+ strb sym, [dicPos, cnt_R]
+ inc_s cnt_R
+ jnz 1b
+ #endif
+
+ jmp copy_end
+
+
+# ---------- COPY MATCH CROSS ----------
+copy_match_cross:
+ # t0_R - src pos
+ # cnt_R - total copy len
+
+ p1_neg cnt_R
+1:
+ ldrb sym, [dic, t0_R]
+ inc t0_R
+ strb sym, [dicPos, cnt_R]
+ inc cnt_R
+ cmp t0_R, dicBufSize
+ jne 1b
+
+ ldrb sym, [dic]
+ sub t0_R, dic, cnt_R
+ jmp copy_common
+
+
+
+
+/*
+fin_dicPos_LIMIT_REP_SHORT:
+ mov len, 1
+ jmp fin_OK
+*/
+
+/*
+fin_dicPos_LIMIT:
+ jmp fin_OK
+ # For more strict mode we can stop decoding with error
+ # mov sym, 1
+ # jmp fin
+*/
+
+fin_ERROR_MATCH_DIST:
+ # rep0 = distance + 1;
+ p2_add len, kMatchSpecLen_Error_Data
+ mov rep3, rep2
+ mov rep2, rep1
+ mov rep1, rep0
+ mov rep0, sym
+ STATE_UPDATE_FOR_MATCH
+ # jmp fin_OK
+ mov sym, 1
+ jmp fin
+
+end_of_payload:
+ inc_s sym
+ jnz fin_ERROR_MATCH_DIST
+
+ mov len, kMatchSpecLenStart
+ xor state, (1 << FLAG_STATE_BITS)
+ jmp fin_OK
+
+/*
+fin_OK_lit:
+ mov len, wzr
+*/
+
+fin_OK:
+ mov sym, wzr
+
+fin:
+ NORM
+
+ #define fin_lzma_reg t0_R
+
+ .macro STORE_LZMA_VAR reg:req, struct_offs:req
+ str \reg, [fin_lzma_reg, \struct_offs]
+ .endm
+
+ .macro STORE_LZMA_PAIR reg0:req, reg1:req, struct_offs:req
+ stp \reg0, \reg1, [fin_lzma_reg, \struct_offs]
+ .endm
+
+ ldr fin_lzma_reg, [sp, 120]
+ p2_sub dicPos, dic
+ shr state, PSHIFT
+
+ STORE_LZMA_PAIR dicPos, buf, offset_dicPos
+ STORE_LZMA_PAIR range, cod, offset_range
+ STORE_LZMA_VAR processedPos, offset_processedPos
+ STORE_LZMA_PAIR rep0, rep1, offset_rep0
+ STORE_LZMA_PAIR rep2, rep3, offset_rep2
+ STORE_LZMA_PAIR state, len, offset_state
+
+ mov w0, sym
+
+ ldp x29, x30, [sp, 80]
+ ldp x27, x28, [sp, 64]
+ ldp x25, x26, [sp, 48]
+ ldp x23, x24, [sp, 32]
+ ldp x21, x22, [sp, 16]
+ ldp x19, x20, [sp], 128
+
+ ret
+/*
+ .cfi_endproc
+.LFE0:
+ .size LzmaDec_DecodeReal_3, .-LzmaDec_DecodeReal_3
+ .ident "TAG_LZMA"
+ .section .note.GNU-stack,"",@progbits
+*/
diff --git a/Asm/x86/7zAsm.asm b/Asm/x86/7zAsm.asm
index 8c30d7b..19c40da 100644
--- a/Asm/x86/7zAsm.asm
+++ b/Asm/x86/7zAsm.asm
@@ -1,147 +1,289 @@
-; 7zAsm.asm -- ASM macros
-; 2018-02-03 : Igor Pavlov : Public domain
-
-MY_ASM_START macro
- ifdef x64
- .code
- else
- .386
- .model flat
- _TEXT$00 SEGMENT PARA PUBLIC 'CODE'
- endif
-endm
-
-MY_PROC macro name:req, numParams:req
- align 16
- proc_numParams = numParams
- ifdef x64
- proc_name equ name
- else
- proc_name equ @CatStr(@,name,@, %numParams * 4)
- endif
- proc_name PROC
-endm
-
-MY_ENDP macro
- ifdef x64
- ret
- else
- if proc_numParams LT 3
- ret
- else
- ret (proc_numParams - 2) * 4
- endif
- endif
- proc_name ENDP
-endm
-
-ifdef x64
- REG_SIZE equ 8
- REG_LOGAR_SIZE equ 3
-else
- REG_SIZE equ 4
- REG_LOGAR_SIZE equ 2
-endif
-
- x0 equ EAX
- x1 equ ECX
- x2 equ EDX
- x3 equ EBX
- x4 equ ESP
- x5 equ EBP
- x6 equ ESI
- x7 equ EDI
-
- x0_W equ AX
- x1_W equ CX
- x2_W equ DX
- x3_W equ BX
-
- x5_W equ BP
- x6_W equ SI
- x7_W equ DI
-
- x0_L equ AL
- x1_L equ CL
- x2_L equ DL
- x3_L equ BL
-
- x0_H equ AH
- x1_H equ CH
- x2_H equ DH
- x3_H equ BH
-
-ifdef x64
- x5_L equ BPL
- x6_L equ SIL
- x7_L equ DIL
-
- r0 equ RAX
- r1 equ RCX
- r2 equ RDX
- r3 equ RBX
- r4 equ RSP
- r5 equ RBP
- r6 equ RSI
- r7 equ RDI
- x8 equ r8d
- x9 equ r9d
- x10 equ r10d
- x11 equ r11d
- x12 equ r12d
- x13 equ r13d
- x14 equ r14d
- x15 equ r15d
-else
- r0 equ x0
- r1 equ x1
- r2 equ x2
- r3 equ x3
- r4 equ x4
- r5 equ x5
- r6 equ x6
- r7 equ x7
-endif
-
-MY_PUSH_4_REGS macro
- push r3
- push r5
- push r6
- push r7
-endm
-
-MY_POP_4_REGS macro
- pop r7
- pop r6
- pop r5
- pop r3
-endm
-
-
-ifdef x64
-
-; for WIN64-x64 ABI:
-
-REG_PARAM_0 equ r1
-REG_PARAM_1 equ r2
-REG_PARAM_2 equ r8
-REG_PARAM_3 equ r9
-
-MY_PUSH_PRESERVED_REGS macro
- MY_PUSH_4_REGS
- push r12
- push r13
- push r14
- push r15
-endm
-
-
-MY_POP_PRESERVED_REGS macro
- pop r15
- pop r14
- pop r13
- pop r12
- MY_POP_4_REGS
-endm
-
-endif
+; 7zAsm.asm -- ASM macros
+; 2022-05-16 : Igor Pavlov : Public domain
+
+
+; UASM can require these changes
+; OPTION FRAMEPRESERVEFLAGS:ON
+; OPTION PROLOGUE:NONE
+; OPTION EPILOGUE:NONE
+
+ifdef @wordsize
+; @wordsize is defined only in JWASM and ASMC and is not defined in MASM
+; @wordsize eq 8 for 64-bit x64
+; @wordsize eq 2 for 32-bit x86
+if @wordsize eq 8
+ x64 equ 1
+endif
+else
+ifdef RAX
+ x64 equ 1
+endif
+endif
+
+
+ifdef x64
+ IS_X64 equ 1
+else
+ IS_X64 equ 0
+endif
+
+ifdef ABI_LINUX
+ IS_LINUX equ 1
+else
+ IS_LINUX equ 0
+endif
+
+ifndef x64
+; Use ABI_CDECL for x86 (32-bit) only
+; if ABI_CDECL is not defined, we use fastcall abi
+ifdef ABI_CDECL
+ IS_CDECL equ 1
+else
+ IS_CDECL equ 0
+endif
+endif
+
+OPTION PROLOGUE:NONE
+OPTION EPILOGUE:NONE
+
+MY_ASM_START macro
+ ifdef x64
+ .code
+ else
+ .386
+ .model flat
+ _TEXT$00 SEGMENT PARA PUBLIC 'CODE'
+ endif
+endm
+
+MY_PROC macro name:req, numParams:req
+ align 16
+ proc_numParams = numParams
+ if (IS_X64 gt 0)
+ proc_name equ name
+ elseif (IS_LINUX gt 0)
+ proc_name equ name
+ elseif (IS_CDECL gt 0)
+ proc_name equ @CatStr(_,name)
+ else
+ proc_name equ @CatStr(@,name,@, %numParams * 4)
+ endif
+ proc_name PROC
+endm
+
+MY_ENDP macro
+ if (IS_X64 gt 0)
+ ret
+ elseif (IS_CDECL gt 0)
+ ret
+ elseif (proc_numParams LT 3)
+ ret
+ else
+ ret (proc_numParams - 2) * 4
+ endif
+ proc_name ENDP
+endm
+
+
+ifdef x64
+ REG_SIZE equ 8
+ REG_LOGAR_SIZE equ 3
+else
+ REG_SIZE equ 4
+ REG_LOGAR_SIZE equ 2
+endif
+
+ x0 equ EAX
+ x1 equ ECX
+ x2 equ EDX
+ x3 equ EBX
+ x4 equ ESP
+ x5 equ EBP
+ x6 equ ESI
+ x7 equ EDI
+
+ x0_W equ AX
+ x1_W equ CX
+ x2_W equ DX
+ x3_W equ BX
+
+ x5_W equ BP
+ x6_W equ SI
+ x7_W equ DI
+
+ x0_L equ AL
+ x1_L equ CL
+ x2_L equ DL
+ x3_L equ BL
+
+ x0_H equ AH
+ x1_H equ CH
+ x2_H equ DH
+ x3_H equ BH
+
+ifdef x64
+ x5_L equ BPL
+ x6_L equ SIL
+ x7_L equ DIL
+
+ r0 equ RAX
+ r1 equ RCX
+ r2 equ RDX
+ r3 equ RBX
+ r4 equ RSP
+ r5 equ RBP
+ r6 equ RSI
+ r7 equ RDI
+ x8 equ r8d
+ x9 equ r9d
+ x10 equ r10d
+ x11 equ r11d
+ x12 equ r12d
+ x13 equ r13d
+ x14 equ r14d
+ x15 equ r15d
+else
+ r0 equ x0
+ r1 equ x1
+ r2 equ x2
+ r3 equ x3
+ r4 equ x4
+ r5 equ x5
+ r6 equ x6
+ r7 equ x7
+endif
+
+
+ifdef x64
+ifdef ABI_LINUX
+
+MY_PUSH_2_REGS macro
+ push r3
+ push r5
+endm
+
+MY_POP_2_REGS macro
+ pop r5
+ pop r3
+endm
+
+endif
+endif
+
+
+MY_PUSH_4_REGS macro
+ push r3
+ push r5
+ push r6
+ push r7
+endm
+
+MY_POP_4_REGS macro
+ pop r7
+ pop r6
+ pop r5
+ pop r3
+endm
+
+
+; for fastcall and for WIN-x64
+REG_PARAM_0_x equ x1
+REG_PARAM_0 equ r1
+REG_PARAM_1_x equ x2
+REG_PARAM_1 equ r2
+
+ifndef x64
+; for x86-fastcall
+
+REG_ABI_PARAM_0_x equ REG_PARAM_0_x
+REG_ABI_PARAM_0 equ REG_PARAM_0
+REG_ABI_PARAM_1_x equ REG_PARAM_1_x
+REG_ABI_PARAM_1 equ REG_PARAM_1
+
+else
+; x64
+
+if (IS_LINUX eq 0)
+
+; for WIN-x64:
+REG_PARAM_2_x equ x8
+REG_PARAM_2 equ r8
+REG_PARAM_3 equ r9
+
+REG_ABI_PARAM_0_x equ REG_PARAM_0_x
+REG_ABI_PARAM_0 equ REG_PARAM_0
+REG_ABI_PARAM_1_x equ REG_PARAM_1_x
+REG_ABI_PARAM_1 equ REG_PARAM_1
+REG_ABI_PARAM_2_x equ REG_PARAM_2_x
+REG_ABI_PARAM_2 equ REG_PARAM_2
+REG_ABI_PARAM_3 equ REG_PARAM_3
+
+else
+; for LINUX-x64:
+REG_LINUX_PARAM_0_x equ x7
+REG_LINUX_PARAM_0 equ r7
+REG_LINUX_PARAM_1_x equ x6
+REG_LINUX_PARAM_1 equ r6
+REG_LINUX_PARAM_2 equ r2
+REG_LINUX_PARAM_3 equ r1
+REG_LINUX_PARAM_4_x equ x8
+REG_LINUX_PARAM_4 equ r8
+REG_LINUX_PARAM_5 equ r9
+
+REG_ABI_PARAM_0_x equ REG_LINUX_PARAM_0_x
+REG_ABI_PARAM_0 equ REG_LINUX_PARAM_0
+REG_ABI_PARAM_1_x equ REG_LINUX_PARAM_1_x
+REG_ABI_PARAM_1 equ REG_LINUX_PARAM_1
+REG_ABI_PARAM_2 equ REG_LINUX_PARAM_2
+REG_ABI_PARAM_3 equ REG_LINUX_PARAM_3
+REG_ABI_PARAM_4_x equ REG_LINUX_PARAM_4_x
+REG_ABI_PARAM_4 equ REG_LINUX_PARAM_4
+REG_ABI_PARAM_5 equ REG_LINUX_PARAM_5
+
+MY_ABI_LINUX_TO_WIN_2 macro
+ mov r2, r6
+ mov r1, r7
+endm
+
+MY_ABI_LINUX_TO_WIN_3 macro
+ mov r8, r2
+ mov r2, r6
+ mov r1, r7
+endm
+
+MY_ABI_LINUX_TO_WIN_4 macro
+ mov r9, r1
+ mov r8, r2
+ mov r2, r6
+ mov r1, r7
+endm
+
+endif ; IS_LINUX
+
+
+MY_PUSH_PRESERVED_ABI_REGS macro
+ if (IS_LINUX gt 0)
+ MY_PUSH_2_REGS
+ else
+ MY_PUSH_4_REGS
+ endif
+ push r12
+ push r13
+ push r14
+ push r15
+endm
+
+
+MY_POP_PRESERVED_ABI_REGS macro
+ pop r15
+ pop r14
+ pop r13
+ pop r12
+ if (IS_LINUX gt 0)
+ MY_POP_2_REGS
+ else
+ MY_POP_4_REGS
+ endif
+endm
+
+endif ; x64
diff --git a/Asm/x86/7zCrcOpt.asm b/Asm/x86/7zCrcOpt.asm
index 2de5171..0fee206 100644
--- a/Asm/x86/7zCrcOpt.asm
+++ b/Asm/x86/7zCrcOpt.asm
@@ -1,147 +1,180 @@
-; 7zCrcOpt.asm -- CRC32 calculation : optimized version
-; 2009-12-12 : Igor Pavlov : Public domain
-
-include 7zAsm.asm
-
-MY_ASM_START
-
-rD equ r2
-rN equ r7
-
-ifdef x64
- num_VAR equ r8
- table_VAR equ r9
-else
- data_size equ (REG_SIZE * 5)
- crc_table equ (REG_SIZE + data_size)
- num_VAR equ [r4 + data_size]
- table_VAR equ [r4 + crc_table]
-endif
-
-SRCDAT equ rN + rD + 4 *
-
-CRC macro op:req, dest:req, src:req, t:req
- op dest, DWORD PTR [r5 + src * 4 + 0400h * t]
-endm
-
-CRC_XOR macro dest:req, src:req, t:req
- CRC xor, dest, src, t
-endm
-
-CRC_MOV macro dest:req, src:req, t:req
- CRC mov, dest, src, t
-endm
-
-CRC1b macro
- movzx x6, BYTE PTR [rD]
- inc rD
- movzx x3, x0_L
- xor x6, x3
- shr x0, 8
- CRC xor, x0, r6, 0
- dec rN
-endm
-
-MY_PROLOG macro crc_end:req
- MY_PUSH_4_REGS
-
- mov x0, x1
- mov rN, num_VAR
- mov r5, table_VAR
- test rN, rN
- jz crc_end
- @@:
- test rD, 7
- jz @F
- CRC1b
- jnz @B
- @@:
- cmp rN, 16
- jb crc_end
- add rN, rD
- mov num_VAR, rN
- sub rN, 8
- and rN, NOT 7
- sub rD, rN
- xor x0, [SRCDAT 0]
-endm
-
-MY_EPILOG macro crc_end:req
- xor x0, [SRCDAT 0]
- mov rD, rN
- mov rN, num_VAR
- sub rN, rD
- crc_end:
- test rN, rN
- jz @F
- CRC1b
- jmp crc_end
- @@:
- MY_POP_4_REGS
-endm
-
-MY_PROC CrcUpdateT8, 4
- MY_PROLOG crc_end_8
- mov x1, [SRCDAT 1]
- align 16
- main_loop_8:
- mov x6, [SRCDAT 2]
- movzx x3, x1_L
- CRC_XOR x6, r3, 3
- movzx x3, x1_H
- CRC_XOR x6, r3, 2
- shr x1, 16
- movzx x3, x1_L
- movzx x1, x1_H
- CRC_XOR x6, r3, 1
- movzx x3, x0_L
- CRC_XOR x6, r1, 0
-
- mov x1, [SRCDAT 3]
- CRC_XOR x6, r3, 7
- movzx x3, x0_H
- shr x0, 16
- CRC_XOR x6, r3, 6
- movzx x3, x0_L
- CRC_XOR x6, r3, 5
- movzx x3, x0_H
- CRC_MOV x0, r3, 4
- xor x0, x6
- add rD, 8
- jnz main_loop_8
-
- MY_EPILOG crc_end_8
-MY_ENDP
-
-MY_PROC CrcUpdateT4, 4
- MY_PROLOG crc_end_4
- align 16
- main_loop_4:
- movzx x1, x0_L
- movzx x3, x0_H
- shr x0, 16
- movzx x6, x0_H
- and x0, 0FFh
- CRC_MOV x1, r1, 3
- xor x1, [SRCDAT 1]
- CRC_XOR x1, r3, 2
- CRC_XOR x1, r6, 0
- CRC_XOR x1, r0, 1
-
- movzx x0, x1_L
- movzx x3, x1_H
- shr x1, 16
- movzx x6, x1_H
- and x1, 0FFh
- CRC_MOV x0, r0, 3
- xor x0, [SRCDAT 2]
- CRC_XOR x0, r3, 2
- CRC_XOR x0, r6, 0
- CRC_XOR x0, r1, 1
- add rD, 8
- jnz main_loop_4
-
- MY_EPILOG crc_end_4
-MY_ENDP
-
-end
+; 7zCrcOpt.asm -- CRC32 calculation : optimized version
+; 2021-02-07 : Igor Pavlov : Public domain
+
+include 7zAsm.asm
+
+MY_ASM_START
+
+rD equ r2
+rN equ r7
+rT equ r5
+
+ifdef x64
+ num_VAR equ r8
+ table_VAR equ r9
+else
+ if (IS_CDECL gt 0)
+ crc_OFFS equ (REG_SIZE * 5)
+ data_OFFS equ (REG_SIZE + crc_OFFS)
+ size_OFFS equ (REG_SIZE + data_OFFS)
+ else
+ size_OFFS equ (REG_SIZE * 5)
+ endif
+ table_OFFS equ (REG_SIZE + size_OFFS)
+ num_VAR equ [r4 + size_OFFS]
+ table_VAR equ [r4 + table_OFFS]
+endif
+
+SRCDAT equ rD + rN * 1 + 4 *
+
+CRC macro op:req, dest:req, src:req, t:req
+ op dest, DWORD PTR [rT + src * 4 + 0400h * t]
+endm
+
+CRC_XOR macro dest:req, src:req, t:req
+ CRC xor, dest, src, t
+endm
+
+CRC_MOV macro dest:req, src:req, t:req
+ CRC mov, dest, src, t
+endm
+
+CRC1b macro
+ movzx x6, BYTE PTR [rD]
+ inc rD
+ movzx x3, x0_L
+ xor x6, x3
+ shr x0, 8
+ CRC xor, x0, r6, 0
+ dec rN
+endm
+
+MY_PROLOG macro crc_end:req
+
+ ifdef x64
+ if (IS_LINUX gt 0)
+ MY_PUSH_2_REGS
+ mov x0, REG_ABI_PARAM_0_x ; x0 = x7
+ mov rT, REG_ABI_PARAM_3 ; r5 = r1
+ mov rN, REG_ABI_PARAM_2 ; r7 = r2
+ mov rD, REG_ABI_PARAM_1 ; r2 = r6
+ else
+ MY_PUSH_4_REGS
+ mov x0, REG_ABI_PARAM_0_x ; x0 = x1
+ mov rT, REG_ABI_PARAM_3 ; r5 = r9
+ mov rN, REG_ABI_PARAM_2 ; r7 = r8
+ ; mov rD, REG_ABI_PARAM_1 ; r2 = r2
+ endif
+ else
+ MY_PUSH_4_REGS
+ if (IS_CDECL gt 0)
+ mov x0, [r4 + crc_OFFS]
+ mov rD, [r4 + data_OFFS]
+ else
+ mov x0, REG_ABI_PARAM_0_x
+ endif
+ mov rN, num_VAR
+ mov rT, table_VAR
+ endif
+
+ test rN, rN
+ jz crc_end
+ @@:
+ test rD, 7
+ jz @F
+ CRC1b
+ jnz @B
+ @@:
+ cmp rN, 16
+ jb crc_end
+ add rN, rD
+ mov num_VAR, rN
+ sub rN, 8
+ and rN, NOT 7
+ sub rD, rN
+ xor x0, [SRCDAT 0]
+endm
+
+MY_EPILOG macro crc_end:req
+ xor x0, [SRCDAT 0]
+ mov rD, rN
+ mov rN, num_VAR
+ sub rN, rD
+ crc_end:
+ test rN, rN
+ jz @F
+ CRC1b
+ jmp crc_end
+ @@:
+ if (IS_X64 gt 0) and (IS_LINUX gt 0)
+ MY_POP_2_REGS
+ else
+ MY_POP_4_REGS
+ endif
+endm
+
+MY_PROC CrcUpdateT8, 4
+ MY_PROLOG crc_end_8
+ mov x1, [SRCDAT 1]
+ align 16
+ main_loop_8:
+ mov x6, [SRCDAT 2]
+ movzx x3, x1_L
+ CRC_XOR x6, r3, 3
+ movzx x3, x1_H
+ CRC_XOR x6, r3, 2
+ shr x1, 16
+ movzx x3, x1_L
+ movzx x1, x1_H
+ CRC_XOR x6, r3, 1
+ movzx x3, x0_L
+ CRC_XOR x6, r1, 0
+
+ mov x1, [SRCDAT 3]
+ CRC_XOR x6, r3, 7
+ movzx x3, x0_H
+ shr x0, 16
+ CRC_XOR x6, r3, 6
+ movzx x3, x0_L
+ CRC_XOR x6, r3, 5
+ movzx x3, x0_H
+ CRC_MOV x0, r3, 4
+ xor x0, x6
+ add rD, 8
+ jnz main_loop_8
+
+ MY_EPILOG crc_end_8
+MY_ENDP
+
+MY_PROC CrcUpdateT4, 4
+ MY_PROLOG crc_end_4
+ align 16
+ main_loop_4:
+ movzx x1, x0_L
+ movzx x3, x0_H
+ shr x0, 16
+ movzx x6, x0_H
+ and x0, 0FFh
+ CRC_MOV x1, r1, 3
+ xor x1, [SRCDAT 1]
+ CRC_XOR x1, r3, 2
+ CRC_XOR x1, r6, 0
+ CRC_XOR x1, r0, 1
+
+ movzx x0, x1_L
+ movzx x3, x1_H
+ shr x1, 16
+ movzx x6, x1_H
+ and x1, 0FFh
+ CRC_MOV x0, r0, 3
+ xor x0, [SRCDAT 2]
+ CRC_XOR x0, r3, 2
+ CRC_XOR x0, r6, 0
+ CRC_XOR x0, r1, 1
+ add rD, 8
+ jnz main_loop_4
+
+ MY_EPILOG crc_end_4
+MY_ENDP
+
+end
diff --git a/Asm/x86/AesOpt.asm b/Asm/x86/AesOpt.asm
index c32e48f..84bf897 100644
--- a/Asm/x86/AesOpt.asm
+++ b/Asm/x86/AesOpt.asm
@@ -1,237 +1,742 @@
-; AesOpt.asm -- Intel's AES.
-; 2009-12-12 : Igor Pavlov : Public domain
-
-include 7zAsm.asm
-
-MY_ASM_START
-
-ifndef x64
- .xmm
-endif
-
-ifdef x64
- num equ r8
-else
- num equ [r4 + REG_SIZE * 4]
-endif
-
-rD equ r2
-rN equ r0
-
-MY_PROLOG macro reg:req
- ifdef x64
- movdqa [r4 + 8], xmm6
- movdqa [r4 + 8 + 16], xmm7
- endif
-
- push r3
- push r5
- push r6
-
- mov rN, num
- mov x6, [r1 + 16]
- shl x6, 5
-
- movdqa reg, [r1]
- add r1, 32
-endm
-
-MY_EPILOG macro
- pop r6
- pop r5
- pop r3
-
- ifdef x64
- movdqa xmm6, [r4 + 8]
- movdqa xmm7, [r4 + 8 + 16]
- endif
-
- MY_ENDP
-endm
-
-ways equ 4
-ways16 equ (ways * 16)
-
-OP_W macro op, op2
- i = 0
- rept ways
- op @CatStr(xmm,%i), op2
- i = i + 1
- endm
-endm
-
-LOAD_OP macro op:req, offs:req
- op xmm0, [r1 + r3 offs]
-endm
-
-LOAD_OP_W macro op:req, offs:req
- movdqa xmm7, [r1 + r3 offs]
- OP_W op, xmm7
-endm
-
-
-; ---------- AES-CBC Decode ----------
-
-CBC_DEC_UPDATE macro reg, offs
- pxor reg, xmm6
- movdqa xmm6, [rD + offs]
- movdqa [rD + offs], reg
-endm
-
-DECODE macro op:req
- op aesdec, +16
- @@:
- op aesdec, +0
- op aesdec, -16
- sub x3, 32
- jnz @B
- op aesdeclast, +0
-endm
-
-MY_PROC AesCbc_Decode_Intel, 3
- MY_PROLOG xmm6
-
- sub x6, 32
-
- jmp check2
-
- align 16
- nextBlocks2:
- mov x3, x6
- OP_W movdqa, [rD + i * 16]
- LOAD_OP_W pxor, +32
- DECODE LOAD_OP_W
- OP_W CBC_DEC_UPDATE, i * 16
- add rD, ways16
- check2:
- sub rN, ways
- jnc nextBlocks2
-
- add rN, ways
- jmp check
-
- nextBlock:
- mov x3, x6
- movdqa xmm1, [rD]
- LOAD_OP movdqa, +32
- pxor xmm0, xmm1
- DECODE LOAD_OP
- pxor xmm0, xmm6
- movdqa [rD], xmm0
- movdqa xmm6, xmm1
- add rD, 16
- check:
- sub rN, 1
- jnc nextBlock
-
- movdqa [r1 - 32], xmm6
- MY_EPILOG
-
-
-; ---------- AES-CBC Encode ----------
-
-ENCODE macro op:req
- op aesenc, -16
- @@:
- op aesenc, +0
- op aesenc, +16
- add r3, 32
- jnz @B
- op aesenclast, +0
-endm
-
-MY_PROC AesCbc_Encode_Intel, 3
- MY_PROLOG xmm0
-
- add r1, r6
- neg r6
- add r6, 32
-
- jmp check_e
-
- align 16
- nextBlock_e:
- mov r3, r6
- pxor xmm0, [rD]
- pxor xmm0, [r1 + r3 - 32]
- ENCODE LOAD_OP
- movdqa [rD], xmm0
- add rD, 16
- check_e:
- sub rN, 1
- jnc nextBlock_e
-
- movdqa [r1 + r6 - 64], xmm0
- MY_EPILOG
-
-
-; ---------- AES-CTR ----------
-
-XOR_UPD_1 macro reg, offs
- pxor reg, [rD + offs]
-endm
-
-XOR_UPD_2 macro reg, offs
- movdqa [rD + offs], reg
-endm
-
-MY_PROC AesCtr_Code_Intel, 3
- MY_PROLOG xmm6
-
- mov r5, r4
- shr r5, 4
- dec r5
- shl r5, 4
-
- mov DWORD PTR [r5], 1
- mov DWORD PTR [r5 + 4], 0
- mov DWORD PTR [r5 + 8], 0
- mov DWORD PTR [r5 + 12], 0
-
- add r1, r6
- neg r6
- add r6, 32
-
- jmp check2_c
-
- align 16
- nextBlocks2_c:
- movdqa xmm7, [r5]
-
- i = 0
- rept ways
- paddq xmm6, xmm7
- movdqa @CatStr(xmm,%i), xmm6
- i = i + 1
- endm
-
- mov r3, r6
- LOAD_OP_W pxor, -32
- ENCODE LOAD_OP_W
- OP_W XOR_UPD_1, i * 16
- OP_W XOR_UPD_2, i * 16
- add rD, ways16
- check2_c:
- sub rN, ways
- jnc nextBlocks2_c
-
- add rN, ways
- jmp check_c
-
- nextBlock_c:
- paddq xmm6, [r5]
- mov r3, r6
- movdqa xmm0, [r1 + r3 - 32]
- pxor xmm0, xmm6
- ENCODE LOAD_OP
- XOR_UPD_1 xmm0, 0
- XOR_UPD_2 xmm0, 0
- add rD, 16
- check_c:
- sub rN, 1
- jnc nextBlock_c
-
- movdqa [r1 + r6 - 64], xmm6
- MY_EPILOG
-
-end
+; AesOpt.asm -- AES optimized code for x86 AES hardware instructions
+; 2021-12-25 : Igor Pavlov : Public domain
+
+include 7zAsm.asm
+
+ifdef __ASMC__
+ use_vaes_256 equ 1
+else
+ifdef ymm0
+ use_vaes_256 equ 1
+endif
+endif
+
+
+ifdef use_vaes_256
+ ECHO "++ VAES 256"
+else
+ ECHO "-- NO VAES 256"
+endif
+
+ifdef x64
+ ECHO "x86-64"
+else
+ ECHO "x86"
+if (IS_CDECL gt 0)
+ ECHO "ABI : CDECL"
+else
+ ECHO "ABI : no CDECL : FASTCALL"
+endif
+endif
+
+if (IS_LINUX gt 0)
+ ECHO "ABI : LINUX"
+else
+ ECHO "ABI : WINDOWS"
+endif
+
+MY_ASM_START
+
+ifndef x64
+ .686
+ .xmm
+endif
+
+
+; MY_ALIGN EQU ALIGN(64)
+MY_ALIGN EQU
+
+SEG_ALIGN EQU MY_ALIGN
+
+MY_SEG_PROC macro name:req, numParams:req
+ ; seg_name equ @CatStr(_TEXT$, name)
+ ; seg_name SEGMENT SEG_ALIGN 'CODE'
+ MY_PROC name, numParams
+endm
+
+MY_SEG_ENDP macro
+ ; seg_name ENDS
+endm
+
+
+NUM_AES_KEYS_MAX equ 15
+
+; the number of push operators in function PROLOG
+if (IS_LINUX eq 0) or (IS_X64 eq 0)
+num_regs_push equ 2
+stack_param_offset equ (REG_SIZE * (1 + num_regs_push))
+endif
+
+ifdef x64
+ num_param equ REG_ABI_PARAM_2
+else
+ if (IS_CDECL gt 0)
+ ; size_t size
+ ; void * data
+ ; UInt32 * aes
+ ; ret-ip <- (r4)
+ aes_OFFS equ (stack_param_offset)
+ data_OFFS equ (REG_SIZE + aes_OFFS)
+ size_OFFS equ (REG_SIZE + data_OFFS)
+ num_param equ [r4 + size_OFFS]
+ else
+ num_param equ [r4 + stack_param_offset]
+ endif
+endif
+
+keys equ REG_PARAM_0 ; r1
+rD equ REG_PARAM_1 ; r2
+rN equ r0
+
+koffs_x equ x7
+koffs_r equ r7
+
+ksize_x equ x6
+ksize_r equ r6
+
+keys2 equ r3
+
+state equ xmm0
+key equ xmm0
+key_ymm equ ymm0
+key_ymm_n equ 0
+
+ifdef x64
+ ways = 11
+else
+ ways = 4
+endif
+
+ways_start_reg equ 1
+
+iv equ @CatStr(xmm, %(ways_start_reg + ways))
+iv_ymm equ @CatStr(ymm, %(ways_start_reg + ways))
+
+
+WOP macro op, op2
+ i = 0
+ rept ways
+ op @CatStr(xmm, %(ways_start_reg + i)), op2
+ i = i + 1
+ endm
+endm
+
+
+ifndef ABI_LINUX
+ifdef x64
+
+; we use 32 bytes of home space in stack in WIN64-x64
+NUM_HOME_MM_REGS equ (32 / 16)
+; we preserve xmm registers starting from xmm6 in WIN64-x64
+MM_START_SAVE_REG equ 6
+
+SAVE_XMM macro num_used_mm_regs:req
+ num_save_mm_regs = num_used_mm_regs - MM_START_SAVE_REG
+ if num_save_mm_regs GT 0
+ num_save_mm_regs2 = num_save_mm_regs - NUM_HOME_MM_REGS
+ ; RSP is (16*x + 8) after entering the function in WIN64-x64
+ stack_offset = 16 * num_save_mm_regs2 + (stack_param_offset mod 16)
+
+ i = 0
+ rept num_save_mm_regs
+
+ if i eq NUM_HOME_MM_REGS
+ sub r4, stack_offset
+ endif
+
+ if i lt NUM_HOME_MM_REGS
+ movdqa [r4 + stack_param_offset + i * 16], @CatStr(xmm, %(MM_START_SAVE_REG + i))
+ else
+ movdqa [r4 + (i - NUM_HOME_MM_REGS) * 16], @CatStr(xmm, %(MM_START_SAVE_REG + i))
+ endif
+
+ i = i + 1
+ endm
+ endif
+endm
+
+RESTORE_XMM macro num_used_mm_regs:req
+ if num_save_mm_regs GT 0
+ i = 0
+ if num_save_mm_regs2 GT 0
+ rept num_save_mm_regs2
+ movdqa @CatStr(xmm, %(MM_START_SAVE_REG + NUM_HOME_MM_REGS + i)), [r4 + i * 16]
+ i = i + 1
+ endm
+ add r4, stack_offset
+ endif
+
+ num_low_regs = num_save_mm_regs - i
+ i = 0
+ rept num_low_regs
+ movdqa @CatStr(xmm, %(MM_START_SAVE_REG + i)), [r4 + stack_param_offset + i * 16]
+ i = i + 1
+ endm
+ endif
+endm
+
+endif ; x64
+endif ; ABI_LINUX
+
+
+MY_PROLOG macro num_used_mm_regs:req
+ ; num_regs_push: must be equal to the number of push operators
+ ; push r3
+ ; push r5
+ if (IS_LINUX eq 0) or (IS_X64 eq 0)
+ push r6
+ push r7
+ endif
+
+ mov rN, num_param ; don't move it; num_param can use stack pointer (r4)
+
+ if (IS_X64 eq 0)
+ if (IS_CDECL gt 0)
+ mov rD, [r4 + data_OFFS]
+ mov keys, [r4 + aes_OFFS]
+ endif
+ elseif (IS_LINUX gt 0)
+ MY_ABI_LINUX_TO_WIN_2
+ endif
+
+
+ ifndef ABI_LINUX
+ ifdef x64
+ SAVE_XMM num_used_mm_regs
+ endif
+ endif
+
+ mov ksize_x, [keys + 16]
+ shl ksize_x, 5
+endm
+
+
+MY_EPILOG macro
+ ifndef ABI_LINUX
+ ifdef x64
+ RESTORE_XMM num_save_mm_regs
+ endif
+ endif
+
+ if (IS_LINUX eq 0) or (IS_X64 eq 0)
+ pop r7
+ pop r6
+ endif
+ ; pop r5
+ ; pop r3
+ MY_ENDP
+endm
+
+
+OP_KEY macro op:req, offs:req
+ op state, [keys + offs]
+endm
+
+
+WOP_KEY macro op:req, offs:req
+ movdqa key, [keys + offs]
+ WOP op, key
+endm
+
+
+; ---------- AES-CBC Decode ----------
+
+
+XOR_WITH_DATA macro reg, _ppp_
+ pxor reg, [rD + i * 16]
+endm
+
+WRITE_TO_DATA macro reg, _ppp_
+ movdqa [rD + i * 16], reg
+endm
+
+
+; state0 equ @CatStr(xmm, %(ways_start_reg))
+
+key0 equ @CatStr(xmm, %(ways_start_reg + ways + 1))
+key0_ymm equ @CatStr(ymm, %(ways_start_reg + ways + 1))
+
+key_last equ @CatStr(xmm, %(ways_start_reg + ways + 2))
+key_last_ymm equ @CatStr(ymm, %(ways_start_reg + ways + 2))
+key_last_ymm_n equ (ways_start_reg + ways + 2)
+
+NUM_CBC_REGS equ (ways_start_reg + ways + 3)
+
+
+MY_SEG_PROC AesCbc_Decode_HW, 3
+
+ AesCbc_Decode_HW_start::
+ MY_PROLOG NUM_CBC_REGS
+
+ AesCbc_Decode_HW_start_2::
+ movdqa iv, [keys]
+ add keys, 32
+
+ movdqa key0, [keys + 1 * ksize_r]
+ movdqa key_last, [keys]
+ sub ksize_x, 16
+
+ jmp check2
+ align 16
+ nextBlocks2:
+ WOP movdqa, [rD + i * 16]
+ mov koffs_x, ksize_x
+ ; WOP_KEY pxor, ksize_r + 16
+ WOP pxor, key0
+ ; align 16
+ @@:
+ WOP_KEY aesdec, 1 * koffs_r
+ sub koffs_r, 16
+ jnz @B
+ ; WOP_KEY aesdeclast, 0
+ WOP aesdeclast, key_last
+
+ pxor @CatStr(xmm, %(ways_start_reg)), iv
+ i = 1
+ rept ways - 1
+ pxor @CatStr(xmm, %(ways_start_reg + i)), [rD + i * 16 - 16]
+ i = i + 1
+ endm
+ movdqa iv, [rD + ways * 16 - 16]
+ WOP WRITE_TO_DATA
+
+ add rD, ways * 16
+ AesCbc_Decode_HW_start_3::
+ check2:
+ sub rN, ways
+ jnc nextBlocks2
+ add rN, ways
+
+ sub ksize_x, 16
+
+ jmp check
+ nextBlock:
+ movdqa state, [rD]
+ mov koffs_x, ksize_x
+ ; OP_KEY pxor, 1 * ksize_r + 32
+ pxor state, key0
+ ; movdqa state0, [rD]
+ ; movdqa state, key0
+ ; pxor state, state0
+ @@:
+ OP_KEY aesdec, 1 * koffs_r + 16
+ OP_KEY aesdec, 1 * koffs_r
+ sub koffs_r, 32
+ jnz @B
+ OP_KEY aesdec, 16
+ ; OP_KEY aesdeclast, 0
+ aesdeclast state, key_last
+
+ pxor state, iv
+ movdqa iv, [rD]
+ ; movdqa iv, state0
+ movdqa [rD], state
+
+ add rD, 16
+ check:
+ sub rN, 1
+ jnc nextBlock
+
+ movdqa [keys - 32], iv
+MY_EPILOG
+
+
+
+
+; ---------- AVX ----------
+
+
+AVX__WOP_n macro op
+ i = 0
+ rept ways
+ op (ways_start_reg + i)
+ i = i + 1
+ endm
+endm
+
+AVX__WOP macro op
+ i = 0
+ rept ways
+ op @CatStr(ymm, %(ways_start_reg + i))
+ i = i + 1
+ endm
+endm
+
+
+AVX__WOP_KEY macro op:req, offs:req
+ vmovdqa key_ymm, ymmword ptr [keys2 + offs]
+ AVX__WOP_n op
+endm
+
+
+AVX__CBC_START macro reg
+ ; vpxor reg, key_ymm, ymmword ptr [rD + 32 * i]
+ vpxor reg, key0_ymm, ymmword ptr [rD + 32 * i]
+endm
+
+AVX__CBC_END macro reg
+ if i eq 0
+ vpxor reg, reg, iv_ymm
+ else
+ vpxor reg, reg, ymmword ptr [rD + i * 32 - 16]
+ endif
+endm
+
+
+AVX__WRITE_TO_DATA macro reg
+ vmovdqu ymmword ptr [rD + 32 * i], reg
+endm
+
+AVX__XOR_WITH_DATA macro reg
+ vpxor reg, reg, ymmword ptr [rD + 32 * i]
+endm
+
+AVX__CTR_START macro reg
+ vpaddq iv_ymm, iv_ymm, one_ymm
+ ; vpxor reg, iv_ymm, key_ymm
+ vpxor reg, iv_ymm, key0_ymm
+endm
+
+
+MY_VAES_INSTR_2 macro cmd, dest, a1, a2
+ db 0c4H
+ db 2 + 040H + 020h * (1 - (a2) / 8) + 080h * (1 - (dest) / 8)
+ db 5 + 8 * ((not (a1)) and 15)
+ db cmd
+ db 0c0H + 8 * ((dest) and 7) + ((a2) and 7)
+endm
+
+MY_VAES_INSTR macro cmd, dest, a
+ MY_VAES_INSTR_2 cmd, dest, dest, a
+endm
+
+MY_vaesenc macro dest, a
+ MY_VAES_INSTR 0dcH, dest, a
+endm
+MY_vaesenclast macro dest, a
+ MY_VAES_INSTR 0ddH, dest, a
+endm
+MY_vaesdec macro dest, a
+ MY_VAES_INSTR 0deH, dest, a
+endm
+MY_vaesdeclast macro dest, a
+ MY_VAES_INSTR 0dfH, dest, a
+endm
+
+
+AVX__VAES_DEC macro reg
+ MY_vaesdec reg, key_ymm_n
+endm
+
+AVX__VAES_DEC_LAST_key_last macro reg
+ ; MY_vaesdeclast reg, key_ymm_n
+ MY_vaesdeclast reg, key_last_ymm_n
+endm
+
+AVX__VAES_ENC macro reg
+ MY_vaesenc reg, key_ymm_n
+endm
+
+AVX__VAES_ENC_LAST macro reg
+ MY_vaesenclast reg, key_ymm_n
+endm
+
+AVX__vinserti128_TO_HIGH macro dest, src
+ vinserti128 dest, dest, src, 1
+endm
+
+
+MY_PROC AesCbc_Decode_HW_256, 3
+ ifdef use_vaes_256
+ MY_PROLOG NUM_CBC_REGS
+
+ cmp rN, ways * 2
+ jb AesCbc_Decode_HW_start_2
+
+ vmovdqa iv, xmmword ptr [keys]
+ add keys, 32
+
+ vbroadcasti128 key0_ymm, xmmword ptr [keys + 1 * ksize_r]
+ vbroadcasti128 key_last_ymm, xmmword ptr [keys]
+ sub ksize_x, 16
+ mov koffs_x, ksize_x
+ add ksize_x, ksize_x
+
+ AVX_STACK_SUB = ((NUM_AES_KEYS_MAX + 1 - 2) * 32)
+ push keys2
+ sub r4, AVX_STACK_SUB
+ ; sub r4, 32
+ ; sub r4, ksize_r
+ ; lea keys2, [r4 + 32]
+ mov keys2, r4
+ and keys2, -32
+ broad:
+ vbroadcasti128 key_ymm, xmmword ptr [keys + 1 * koffs_r]
+ vmovdqa ymmword ptr [keys2 + koffs_r * 2], key_ymm
+ sub koffs_r, 16
+ ; jnc broad
+ jnz broad
+
+ sub rN, ways * 2
+
+ align 16
+ avx_cbcdec_nextBlock2:
+ mov koffs_x, ksize_x
+ ; AVX__WOP_KEY AVX__CBC_START, 1 * koffs_r + 32
+ AVX__WOP AVX__CBC_START
+ @@:
+ AVX__WOP_KEY AVX__VAES_DEC, 1 * koffs_r
+ sub koffs_r, 32
+ jnz @B
+ ; AVX__WOP_KEY AVX__VAES_DEC_LAST, 0
+ AVX__WOP_n AVX__VAES_DEC_LAST_key_last
+
+ AVX__vinserti128_TO_HIGH iv_ymm, xmmword ptr [rD]
+ AVX__WOP AVX__CBC_END
+
+ vmovdqa iv, xmmword ptr [rD + ways * 32 - 16]
+ AVX__WOP AVX__WRITE_TO_DATA
+
+ add rD, ways * 32
+ sub rN, ways * 2
+ jnc avx_cbcdec_nextBlock2
+ add rN, ways * 2
+
+ shr ksize_x, 1
+
+ ; lea r4, [r4 + 1 * ksize_r + 32]
+ add r4, AVX_STACK_SUB
+ pop keys2
+
+ vzeroupper
+ jmp AesCbc_Decode_HW_start_3
+ else
+ jmp AesCbc_Decode_HW_start
+ endif
+MY_ENDP
+MY_SEG_ENDP
+
+
+
+
+; ---------- AES-CBC Encode ----------
+
+e0 equ xmm1
+
+CENC_START_KEY equ 2
+CENC_NUM_REG_KEYS equ (3 * 2)
+; last_key equ @CatStr(xmm, %(CENC_START_KEY + CENC_NUM_REG_KEYS))
+
+MY_SEG_PROC AesCbc_Encode_HW, 3
+ MY_PROLOG (CENC_START_KEY + CENC_NUM_REG_KEYS + 0)
+
+ movdqa state, [keys]
+ add keys, 32
+
+ i = 0
+ rept CENC_NUM_REG_KEYS
+ movdqa @CatStr(xmm, %(CENC_START_KEY + i)), [keys + i * 16]
+ i = i + 1
+ endm
+
+ add keys, ksize_r
+ neg ksize_r
+ add ksize_r, (16 * CENC_NUM_REG_KEYS)
+ ; movdqa last_key, [keys]
+ jmp check_e
+
+ align 16
+ nextBlock_e:
+ movdqa e0, [rD]
+ mov koffs_r, ksize_r
+ pxor e0, @CatStr(xmm, %(CENC_START_KEY))
+ pxor state, e0
+
+ i = 1
+ rept (CENC_NUM_REG_KEYS - 1)
+ aesenc state, @CatStr(xmm, %(CENC_START_KEY + i))
+ i = i + 1
+ endm
+
+ @@:
+ OP_KEY aesenc, 1 * koffs_r
+ OP_KEY aesenc, 1 * koffs_r + 16
+ add koffs_r, 32
+ jnz @B
+ OP_KEY aesenclast, 0
+ ; aesenclast state, last_key
+
+ movdqa [rD], state
+ add rD, 16
+ check_e:
+ sub rN, 1
+ jnc nextBlock_e
+
+ ; movdqa [keys - 32], state
+ movdqa [keys + 1 * ksize_r - (16 * CENC_NUM_REG_KEYS) - 32], state
+MY_EPILOG
+MY_SEG_ENDP
+
+
+
+; ---------- AES-CTR ----------
+
+ifdef x64
+ ; ways = 11
+endif
+
+
+one equ @CatStr(xmm, %(ways_start_reg + ways + 1))
+one_ymm equ @CatStr(ymm, %(ways_start_reg + ways + 1))
+key0 equ @CatStr(xmm, %(ways_start_reg + ways + 2))
+key0_ymm equ @CatStr(ymm, %(ways_start_reg + ways + 2))
+NUM_CTR_REGS equ (ways_start_reg + ways + 3)
+
+INIT_CTR macro reg, _ppp_
+ paddq iv, one
+ movdqa reg, iv
+endm
+
+
+MY_SEG_PROC AesCtr_Code_HW, 3
+ Ctr_start::
+ MY_PROLOG NUM_CTR_REGS
+
+ Ctr_start_2::
+ movdqa iv, [keys]
+ add keys, 32
+ movdqa key0, [keys]
+
+ add keys, ksize_r
+ neg ksize_r
+ add ksize_r, 16
+
+ Ctr_start_3::
+ mov koffs_x, 1
+ movd one, koffs_x
+ jmp check2_c
+
+ align 16
+ nextBlocks2_c:
+ WOP INIT_CTR, 0
+ mov koffs_r, ksize_r
+ ; WOP_KEY pxor, 1 * koffs_r -16
+ WOP pxor, key0
+ @@:
+ WOP_KEY aesenc, 1 * koffs_r
+ add koffs_r, 16
+ jnz @B
+ WOP_KEY aesenclast, 0
+
+ WOP XOR_WITH_DATA
+ WOP WRITE_TO_DATA
+ add rD, ways * 16
+ check2_c:
+ sub rN, ways
+ jnc nextBlocks2_c
+ add rN, ways
+
+ sub keys, 16
+ add ksize_r, 16
+
+ jmp check_c
+
+ ; align 16
+ nextBlock_c:
+ paddq iv, one
+ ; movdqa state, [keys + 1 * koffs_r - 16]
+ movdqa state, key0
+ mov koffs_r, ksize_r
+ pxor state, iv
+
+ @@:
+ OP_KEY aesenc, 1 * koffs_r
+ OP_KEY aesenc, 1 * koffs_r + 16
+ add koffs_r, 32
+ jnz @B
+ OP_KEY aesenc, 0
+ OP_KEY aesenclast, 16
+
+ pxor state, [rD]
+ movdqa [rD], state
+ add rD, 16
+ check_c:
+ sub rN, 1
+ jnc nextBlock_c
+
+ ; movdqa [keys - 32], iv
+ movdqa [keys + 1 * ksize_r - 16 - 32], iv
+MY_EPILOG
+
+
+MY_PROC AesCtr_Code_HW_256, 3
+ ifdef use_vaes_256
+ MY_PROLOG NUM_CTR_REGS
+
+ cmp rN, ways * 2
+ jb Ctr_start_2
+
+ vbroadcasti128 iv_ymm, xmmword ptr [keys]
+ add keys, 32
+ vbroadcasti128 key0_ymm, xmmword ptr [keys]
+ mov koffs_x, 1
+ vmovd one, koffs_x
+ vpsubq iv_ymm, iv_ymm, one_ymm
+ vpaddq one, one, one
+ AVX__vinserti128_TO_HIGH one_ymm, one
+
+ add keys, ksize_r
+ sub ksize_x, 16
+ neg ksize_r
+ mov koffs_r, ksize_r
+ add ksize_r, ksize_r
+
+ AVX_STACK_SUB = ((NUM_AES_KEYS_MAX + 1 - 1) * 32)
+ push keys2
+ lea keys2, [r4 - 32]
+ sub r4, AVX_STACK_SUB
+ and keys2, -32
+ vbroadcasti128 key_ymm, xmmword ptr [keys]
+ vmovdqa ymmword ptr [keys2], key_ymm
+ @@:
+ vbroadcasti128 key_ymm, xmmword ptr [keys + 1 * koffs_r]
+ vmovdqa ymmword ptr [keys2 + koffs_r * 2], key_ymm
+ add koffs_r, 16
+ jnz @B
+
+ sub rN, ways * 2
+
+ align 16
+ avx_ctr_nextBlock2:
+ mov koffs_r, ksize_r
+ AVX__WOP AVX__CTR_START
+ ; AVX__WOP_KEY AVX__CTR_START, 1 * koffs_r - 32
+ @@:
+ AVX__WOP_KEY AVX__VAES_ENC, 1 * koffs_r
+ add koffs_r, 32
+ jnz @B
+ AVX__WOP_KEY AVX__VAES_ENC_LAST, 0
+
+ AVX__WOP AVX__XOR_WITH_DATA
+ AVX__WOP AVX__WRITE_TO_DATA
+
+ add rD, ways * 32
+ sub rN, ways * 2
+ jnc avx_ctr_nextBlock2
+ add rN, ways * 2
+
+ vextracti128 iv, iv_ymm, 1
+ sar ksize_r, 1
+
+ add r4, AVX_STACK_SUB
+ pop keys2
+
+ vzeroupper
+ jmp Ctr_start_3
+ else
+ jmp Ctr_start
+ endif
+MY_ENDP
+MY_SEG_ENDP
+
+end
diff --git a/Asm/x86/LzFindOpt.asm b/Asm/x86/LzFindOpt.asm
new file mode 100644
index 0000000..42e10bd
--- /dev/null
+++ b/Asm/x86/LzFindOpt.asm
@@ -0,0 +1,513 @@
+; LzFindOpt.asm -- ASM version of GetMatchesSpecN_2() function
+; 2021-07-21: Igor Pavlov : Public domain
+;
+
+ifndef x64
+; x64=1
+; .err <x64_IS_REQUIRED>
+endif
+
+include 7zAsm.asm
+
+MY_ASM_START
+
+_TEXT$LZFINDOPT SEGMENT ALIGN(64) 'CODE'
+
+MY_ALIGN macro num:req
+ align num
+endm
+
+MY_ALIGN_32 macro
+ MY_ALIGN 32
+endm
+
+MY_ALIGN_64 macro
+ MY_ALIGN 64
+endm
+
+
+t0_L equ x0_L
+t0_x equ x0
+t0 equ r0
+t1_x equ x3
+t1 equ r3
+
+cp_x equ t1_x
+cp_r equ t1
+m equ x5
+m_r equ r5
+len_x equ x6
+len equ r6
+diff_x equ x7
+diff equ r7
+len0 equ r10
+len1_x equ x11
+len1 equ r11
+maxLen_x equ x12
+maxLen equ r12
+d equ r13
+ptr0 equ r14
+ptr1 equ r15
+
+d_lim equ m_r
+cycSize equ len_x
+hash_lim equ len0
+delta1_x equ len1_x
+delta1_r equ len1
+delta_x equ maxLen_x
+delta_r equ maxLen
+hash equ ptr0
+src equ ptr1
+
+
+
+if (IS_LINUX gt 0)
+
+; r1 r2 r8 r9 : win32
+; r7 r6 r2 r1 r8 r9 : linux
+
+lenLimit equ r8
+lenLimit_x equ x8
+; pos_r equ r2
+pos equ x2
+cur equ r1
+son equ r9
+
+else
+
+lenLimit equ REG_ABI_PARAM_2
+lenLimit_x equ REG_ABI_PARAM_2_x
+pos equ REG_ABI_PARAM_1_x
+cur equ REG_ABI_PARAM_0
+son equ REG_ABI_PARAM_3
+
+endif
+
+
+if (IS_LINUX gt 0)
+ maxLen_OFFS equ (REG_SIZE * (6 + 1))
+else
+ cutValue_OFFS equ (REG_SIZE * (8 + 1 + 4))
+ d_OFFS equ (REG_SIZE + cutValue_OFFS)
+ maxLen_OFFS equ (REG_SIZE + d_OFFS)
+endif
+ hash_OFFS equ (REG_SIZE + maxLen_OFFS)
+ limit_OFFS equ (REG_SIZE + hash_OFFS)
+ size_OFFS equ (REG_SIZE + limit_OFFS)
+ cycPos_OFFS equ (REG_SIZE + size_OFFS)
+ cycSize_OFFS equ (REG_SIZE + cycPos_OFFS)
+ posRes_OFFS equ (REG_SIZE + cycSize_OFFS)
+
+if (IS_LINUX gt 0)
+else
+ cutValue_PAR equ [r0 + cutValue_OFFS]
+ d_PAR equ [r0 + d_OFFS]
+endif
+ maxLen_PAR equ [r0 + maxLen_OFFS]
+ hash_PAR equ [r0 + hash_OFFS]
+ limit_PAR equ [r0 + limit_OFFS]
+ size_PAR equ [r0 + size_OFFS]
+ cycPos_PAR equ [r0 + cycPos_OFFS]
+ cycSize_PAR equ [r0 + cycSize_OFFS]
+ posRes_PAR equ [r0 + posRes_OFFS]
+
+
+ cutValue_VAR equ DWORD PTR [r4 + 8 * 0]
+ cutValueCur_VAR equ DWORD PTR [r4 + 8 * 0 + 4]
+ cycPos_VAR equ DWORD PTR [r4 + 8 * 1 + 0]
+ cycSize_VAR equ DWORD PTR [r4 + 8 * 1 + 4]
+ hash_VAR equ QWORD PTR [r4 + 8 * 2]
+ limit_VAR equ QWORD PTR [r4 + 8 * 3]
+ size_VAR equ QWORD PTR [r4 + 8 * 4]
+ distances equ QWORD PTR [r4 + 8 * 5]
+ maxLen_VAR equ QWORD PTR [r4 + 8 * 6]
+
+ Old_RSP equ QWORD PTR [r4 + 8 * 7]
+ LOCAL_SIZE equ 8 * 8
+
+COPY_VAR_32 macro dest_var, src_var
+ mov x3, src_var
+ mov dest_var, x3
+endm
+
+COPY_VAR_64 macro dest_var, src_var
+ mov r3, src_var
+ mov dest_var, r3
+endm
+
+
+; MY_ALIGN_64
+MY_PROC GetMatchesSpecN_2, 13
+MY_PUSH_PRESERVED_ABI_REGS
+ mov r0, RSP
+ lea r3, [r0 - LOCAL_SIZE]
+ and r3, -64
+ mov RSP, r3
+ mov Old_RSP, r0
+
+if (IS_LINUX gt 0)
+ mov d, REG_ABI_PARAM_5 ; r13 = r9
+ mov cutValue_VAR, REG_ABI_PARAM_4_x ; = r8
+ mov son, REG_ABI_PARAM_3 ; r9 = r1
+ mov r8, REG_ABI_PARAM_2 ; r8 = r2
+ mov pos, REG_ABI_PARAM_1_x ; r2 = x6
+ mov r1, REG_ABI_PARAM_0 ; r1 = r7
+else
+ COPY_VAR_32 cutValue_VAR, cutValue_PAR
+ mov d, d_PAR
+endif
+
+ COPY_VAR_64 limit_VAR, limit_PAR
+
+ mov hash_lim, size_PAR
+ mov size_VAR, hash_lim
+
+ mov cp_x, cycPos_PAR
+ mov hash, hash_PAR
+
+ mov cycSize, cycSize_PAR
+ mov cycSize_VAR, cycSize
+
+ ; we want cur in (rcx). So we change the cur and lenLimit variables
+ sub lenLimit, cur
+ neg lenLimit_x
+ inc lenLimit_x
+
+ mov t0_x, maxLen_PAR
+ sub t0, lenLimit
+ mov maxLen_VAR, t0
+
+ jmp main_loop
+
+MY_ALIGN_64
+fill_empty:
+ ; ptr0 = *ptr1 = kEmptyHashValue;
+ mov QWORD PTR [ptr1], 0
+ inc pos
+ inc cp_x
+ mov DWORD PTR [d - 4], 0
+ cmp d, limit_VAR
+ jae fin
+ cmp hash, hash_lim
+ je fin
+
+; MY_ALIGN_64
+main_loop:
+ ; UInt32 delta = *hash++;
+ mov diff_x, [hash] ; delta
+ add hash, 4
+ ; mov cycPos_VAR, cp_x
+
+ inc cur
+ add d, 4
+ mov m, pos
+ sub m, diff_x; ; matchPos
+
+ ; CLzRef *ptr1 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
+ lea ptr1, [son + 8 * cp_r]
+ ; mov cycSize, cycSize_VAR
+ cmp pos, cycSize
+ jb directMode ; if (pos < cycSize_VAR)
+
+ ; CYC MODE
+
+ cmp diff_x, cycSize
+ jae fill_empty ; if (delta >= cycSize_VAR)
+
+ xor t0_x, t0_x
+ mov cycPos_VAR, cp_x
+ sub cp_x, diff_x
+ ; jae prepare_for_tree_loop
+ ; add cp_x, cycSize
+ cmovb t0_x, cycSize
+ add cp_x, t0_x ; cp_x += (cycPos < delta ? cycSize : 0)
+ jmp prepare_for_tree_loop
+
+
+directMode:
+ cmp diff_x, pos
+ je fill_empty ; if (delta == pos)
+ jae fin_error ; if (delta >= pos)
+
+ mov cycPos_VAR, cp_x
+ mov cp_x, m
+
+prepare_for_tree_loop:
+ mov len0, lenLimit
+ mov hash_VAR, hash
+ ; CLzRef *ptr0 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2 + 1;
+ lea ptr0, [ptr1 + 4]
+ ; UInt32 *_distances = ++d;
+ mov distances, d
+
+ neg len0
+ mov len1, len0
+
+ mov t0_x, cutValue_VAR
+ mov maxLen, maxLen_VAR
+ mov cutValueCur_VAR, t0_x
+
+MY_ALIGN_32
+tree_loop:
+ neg diff
+ mov len, len0
+ cmp len1, len0
+ cmovb len, len1 ; len = (len1 < len0 ? len1 : len0);
+ add diff, cur
+
+ mov t0_x, [son + cp_r * 8] ; prefetch
+ movzx t0_x, BYTE PTR [diff + 1 * len]
+ lea cp_r, [son + cp_r * 8]
+ cmp [cur + 1 * len], t0_L
+ je matched_1
+
+ jb left_0
+
+ mov [ptr1], m
+ mov m, [cp_r + 4]
+ lea ptr1, [cp_r + 4]
+ sub diff, cur ; FIX32
+ jmp next_node
+
+MY_ALIGN_32
+left_0:
+ mov [ptr0], m
+ mov m, [cp_r]
+ mov ptr0, cp_r
+ sub diff, cur ; FIX32
+ ; jmp next_node
+
+; ------------ NEXT NODE ------------
+; MY_ALIGN_32
+next_node:
+ mov cycSize, cycSize_VAR
+ dec cutValueCur_VAR
+ je finish_tree
+
+ add diff_x, pos ; prev_match = pos + diff
+ cmp m, diff_x
+ jae fin_error ; if (new_match >= prev_match)
+
+ mov diff_x, pos
+ sub diff_x, m ; delta = pos - new_match
+ cmp pos, cycSize
+ jae cyc_mode_2 ; if (pos >= cycSize)
+
+ mov cp_x, m
+ test m, m
+ jne tree_loop ; if (m != 0)
+
+finish_tree:
+ ; ptr0 = *ptr1 = kEmptyHashValue;
+ mov DWORD PTR [ptr0], 0
+ mov DWORD PTR [ptr1], 0
+
+ inc pos
+
+ ; _distances[-1] = (UInt32)(d - _distances);
+ mov t0, distances
+ mov t1, d
+ sub t1, t0
+ shr t1_x, 2
+ mov [t0 - 4], t1_x
+
+ cmp d, limit_VAR
+ jae fin ; if (d >= limit)
+
+ mov cp_x, cycPos_VAR
+ mov hash, hash_VAR
+ mov hash_lim, size_VAR
+ inc cp_x
+ cmp hash, hash_lim
+ jne main_loop ; if (hash != size)
+ jmp fin
+
+
+MY_ALIGN_32
+cyc_mode_2:
+ cmp diff_x, cycSize
+ jae finish_tree ; if (delta >= cycSize)
+
+ mov cp_x, cycPos_VAR
+ xor t0_x, t0_x
+ sub cp_x, diff_x ; cp_x = cycPos - delta
+ cmovb t0_x, cycSize
+ add cp_x, t0_x ; cp_x += (cycPos < delta ? cycSize : 0)
+ jmp tree_loop
+
+
+MY_ALIGN_32
+matched_1:
+
+ inc len
+ ; cmp len_x, lenLimit_x
+ je short lenLimit_reach
+ movzx t0_x, BYTE PTR [diff + 1 * len]
+ cmp [cur + 1 * len], t0_L
+ jne mismatch
+
+
+MY_ALIGN_32
+match_loop:
+ ; while (++len != lenLimit) (len[diff] != len[0]) ;
+
+ inc len
+ ; cmp len_x, lenLimit_x
+ je short lenLimit_reach
+ movzx t0_x, BYTE PTR [diff + 1 * len]
+ cmp BYTE PTR [cur + 1 * len], t0_L
+ je match_loop
+
+mismatch:
+ jb left_2
+
+ mov [ptr1], m
+ mov m, [cp_r + 4]
+ lea ptr1, [cp_r + 4]
+ mov len1, len
+
+ jmp max_update
+
+MY_ALIGN_32
+left_2:
+ mov [ptr0], m
+ mov m, [cp_r]
+ mov ptr0, cp_r
+ mov len0, len
+
+max_update:
+ sub diff, cur ; restore diff
+
+ cmp maxLen, len
+ jae next_node
+
+ mov maxLen, len
+ add len, lenLimit
+ mov [d], len_x
+ mov t0_x, diff_x
+ not t0_x
+ mov [d + 4], t0_x
+ add d, 8
+
+ jmp next_node
+
+
+
+MY_ALIGN_32
+lenLimit_reach:
+
+ mov delta_r, cur
+ sub delta_r, diff
+ lea delta1_r, [delta_r - 1]
+
+ mov t0_x, [cp_r]
+ mov [ptr1], t0_x
+ mov t0_x, [cp_r + 4]
+ mov [ptr0], t0_x
+
+ mov [d], lenLimit_x
+ mov [d + 4], delta1_x
+ add d, 8
+
+ ; _distances[-1] = (UInt32)(d - _distances);
+ mov t0, distances
+ mov t1, d
+ sub t1, t0
+ shr t1_x, 2
+ mov [t0 - 4], t1_x
+
+ mov hash, hash_VAR
+ mov hash_lim, size_VAR
+
+ inc pos
+ mov cp_x, cycPos_VAR
+ inc cp_x
+
+ mov d_lim, limit_VAR
+ mov cycSize, cycSize_VAR
+ ; if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
+ ; break;
+ cmp hash, hash_lim
+ je fin
+ cmp d, d_lim
+ jae fin
+ cmp delta_x, [hash]
+ jne main_loop
+ movzx t0_x, BYTE PTR [diff]
+ cmp [cur], t0_L
+ jne main_loop
+
+ ; jmp main_loop ; bypass for debug
+
+ mov cycPos_VAR, cp_x
+ shl len, 3 ; cycSize * 8
+ sub diff, cur ; restore diff
+ xor t0_x, t0_x
+ cmp cp_x, delta_x ; cmp (cycPos_VAR, delta)
+ lea cp_r, [son + 8 * cp_r] ; dest
+ lea src, [cp_r + 8 * diff]
+ cmovb t0, len ; t0 = (cycPos_VAR < delta ? cycSize * 8 : 0)
+ add src, t0
+ add len, son ; len = son + cycSize * 8
+
+
+MY_ALIGN_32
+long_loop:
+ add hash, 4
+
+ ; *(UInt64 *)(void *)ptr = ((const UInt64 *)(const void *)ptr)[diff];
+
+ mov t0, [src]
+ add src, 8
+ mov [cp_r], t0
+ add cp_r, 8
+ cmp src, len
+ cmove src, son ; if end of (son) buffer is reached, we wrap to begin
+
+ mov DWORD PTR [d], 2
+ mov [d + 4], lenLimit_x
+ mov [d + 8], delta1_x
+ add d, 12
+
+ inc cur
+
+ cmp hash, hash_lim
+ je long_footer
+ cmp delta_x, [hash]
+ jne long_footer
+ movzx t0_x, BYTE PTR [diff + 1 * cur]
+ cmp [cur], t0_L
+ jne long_footer
+ cmp d, d_lim
+ jb long_loop
+
+long_footer:
+ sub cp_r, son
+ shr cp_r, 3
+ add pos, cp_x
+ sub pos, cycPos_VAR
+ mov cycSize, cycSize_VAR
+
+ cmp d, d_lim
+ jae fin
+ cmp hash, hash_lim
+ jne main_loop
+ jmp fin
+
+
+
+fin_error:
+ xor d, d
+
+fin:
+ mov RSP, Old_RSP
+ mov t0, [r4 + posRes_OFFS]
+ mov [t0], pos
+ mov r0, d
+
+MY_POP_PRESERVED_ABI_REGS
+MY_ENDP
+
+_TEXT$LZFINDOPT ENDS
+
+end
diff --git a/Asm/x86/LzmaDecOpt.asm b/Asm/x86/LzmaDecOpt.asm
index 0a89eb7..f2818e7 100644
--- a/Asm/x86/LzmaDecOpt.asm
+++ b/Asm/x86/LzmaDecOpt.asm
@@ -1,1258 +1,1303 @@
-; LzmaDecOpt.asm -- ASM version of LzmaDec_DecodeReal_3() function
-; 2018-02-06: Igor Pavlov : Public domain
-;
-; 3 - is the code compatibility version of LzmaDec_DecodeReal_*()
-; function for check at link time.
-; That code is tightly coupled with LzmaDec_TryDummy()
-; and with another functions in LzmaDec.c file.
-; CLzmaDec structure, (probs) array layout, input and output of
-; LzmaDec_DecodeReal_*() must be equal in both versions (C / ASM).
-
-ifndef x64
-; x64=1
-; .err <x64_IS_REQUIRED>
-endif
-
-include 7zAsm.asm
-
-MY_ASM_START
-
-_TEXT$LZMADECOPT SEGMENT ALIGN(64) 'CODE'
-
-MY_ALIGN macro num:req
- align num
-endm
-
-MY_ALIGN_16 macro
- MY_ALIGN 16
-endm
-
-MY_ALIGN_32 macro
- MY_ALIGN 32
-endm
-
-MY_ALIGN_64 macro
- MY_ALIGN 64
-endm
-
-
-; _LZMA_SIZE_OPT equ 1
-
-; _LZMA_PROB32 equ 1
-
-ifdef _LZMA_PROB32
- PSHIFT equ 2
- PLOAD macro dest, mem
- mov dest, dword ptr [mem]
- endm
- PSTORE macro src, mem
- mov dword ptr [mem], src
- endm
-else
- PSHIFT equ 1
- PLOAD macro dest, mem
- movzx dest, word ptr [mem]
- endm
- PSTORE macro src, mem
- mov word ptr [mem], @CatStr(src, _W)
- endm
-endif
-
-PMULT equ (1 SHL PSHIFT)
-PMULT_HALF equ (1 SHL (PSHIFT - 1))
-PMULT_2 equ (1 SHL (PSHIFT + 1))
-
-
-; x0 range
-; x1 pbPos / (prob) TREE
-; x2 probBranch / prm (MATCHED) / pbPos / cnt
-; x3 sym
-;====== r4 === RSP
-; x5 cod
-; x6 t1 NORM_CALC / probs_state / dist
-; x7 t0 NORM_CALC / prob2 IF_BIT_1
-; x8 state
-; x9 match (MATCHED) / sym2 / dist2 / lpMask_reg
-; x10 kBitModelTotal_reg
-; r11 probs
-; x12 offs (MATCHED) / dic / len_temp
-; x13 processedPos
-; x14 bit (MATCHED) / dicPos
-; r15 buf
-
-
-cod equ x5
-cod_L equ x5_L
-range equ x0
-state equ x8
-state_R equ r8
-buf equ r15
-processedPos equ x13
-kBitModelTotal_reg equ x10
-
-probBranch equ x2
-probBranch_R equ r2
-probBranch_W equ x2_W
-
-pbPos equ x1
-pbPos_R equ r1
-
-cnt equ x2
-cnt_R equ r2
-
-lpMask_reg equ x9
-dicPos equ r14
-
-sym equ x3
-sym_R equ r3
-sym_L equ x3_L
-
-probs equ r11
-dic equ r12
-
-t0 equ x7
-t0_W equ x7_W
-t0_R equ r7
-
-prob2 equ t0
-prob2_W equ t0_W
-
-t1 equ x6
-t1_R equ r6
-
-probs_state equ t1
-probs_state_R equ t1_R
-
-prm equ r2
-match equ x9
-match_R equ r9
-offs equ x12
-offs_R equ r12
-bit equ x14
-bit_R equ r14
-
-sym2 equ x9
-sym2_R equ r9
-
-len_temp equ x12
-
-dist equ sym
-dist2 equ x9
-
-
-
-kNumBitModelTotalBits equ 11
-kBitModelTotal equ (1 SHL kNumBitModelTotalBits)
-kNumMoveBits equ 5
-kBitModelOffset equ ((1 SHL kNumMoveBits) - 1)
-kTopValue equ (1 SHL 24)
-
-NORM_2 macro
- ; movzx t0, BYTE PTR [buf]
- shl cod, 8
- mov cod_L, BYTE PTR [buf]
- shl range, 8
- ; or cod, t0
- inc buf
-endm
-
-
-NORM macro
- cmp range, kTopValue
- jae SHORT @F
- NORM_2
-@@:
-endm
-
-
-; ---------- Branch MACROS ----------
-
-UPDATE_0 macro probsArray:req, probOffset:req, probDisp:req
- mov prob2, kBitModelTotal_reg
- sub prob2, probBranch
- shr prob2, kNumMoveBits
- add probBranch, prob2
- PSTORE probBranch, probOffset * 1 + probsArray + probDisp * PMULT
-endm
-
-
-UPDATE_1 macro probsArray:req, probOffset:req, probDisp:req
- sub prob2, range
- sub cod, range
- mov range, prob2
- mov prob2, probBranch
- shr probBranch, kNumMoveBits
- sub prob2, probBranch
- PSTORE prob2, probOffset * 1 + probsArray + probDisp * PMULT
-endm
-
-
-CMP_COD macro probsArray:req, probOffset:req, probDisp:req
- PLOAD probBranch, probOffset * 1 + probsArray + probDisp * PMULT
- NORM
- mov prob2, range
- shr range, kNumBitModelTotalBits
- imul range, probBranch
- cmp cod, range
-endm
-
-
-IF_BIT_1_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
- CMP_COD probsArray, probOffset, probDisp
- jae toLabel
-endm
-
-
-IF_BIT_1 macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
- IF_BIT_1_NOUP probsArray, probOffset, probDisp, toLabel
- UPDATE_0 probsArray, probOffset, probDisp
-endm
-
-
-IF_BIT_0_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
- CMP_COD probsArray, probOffset, probDisp
- jb toLabel
-endm
-
-
-; ---------- CMOV MACROS ----------
-
-NORM_CALC macro prob:req
- NORM
- mov t0, range
- shr range, kNumBitModelTotalBits
- imul range, prob
- sub t0, range
- mov t1, cod
- sub cod, range
-endm
-
-
-PUP macro prob:req, probPtr:req
- sub t0, prob
- ; only sar works for both 16/32 bit prob modes
- sar t0, kNumMoveBits
- add t0, prob
- PSTORE t0, probPtr
-endm
-
-
-PUP_SUB macro prob:req, probPtr:req, symSub:req
- sbb sym, symSub
- PUP prob, probPtr
-endm
-
-
-PUP_COD macro prob:req, probPtr:req, symSub:req
- mov t0, kBitModelOffset
- cmovb cod, t1
- mov t1, sym
- cmovb t0, kBitModelTotal_reg
- PUP_SUB prob, probPtr, symSub
-endm
-
-
-BIT_0 macro prob:req, probNext:req
- PLOAD prob, probs + 1 * PMULT
- PLOAD probNext, probs + 1 * PMULT_2
-
- NORM_CALC prob
-
- cmovae range, t0
- PLOAD t0, probs + 1 * PMULT_2 + PMULT
- cmovae probNext, t0
- mov t0, kBitModelOffset
- cmovb cod, t1
- cmovb t0, kBitModelTotal_reg
- mov sym, 2
- PUP_SUB prob, probs + 1 * PMULT, 0 - 1
-endm
-
-
-BIT_1 macro prob:req, probNext:req
- PLOAD probNext, probs + sym_R * PMULT_2
- add sym, sym
-
- NORM_CALC prob
-
- cmovae range, t0
- PLOAD t0, probs + sym_R * PMULT + PMULT
- cmovae probNext, t0
- PUP_COD prob, probs + t1_R * PMULT_HALF, 0 - 1
-endm
-
-
-BIT_2 macro prob:req, symSub:req
- add sym, sym
-
- NORM_CALC prob
-
- cmovae range, t0
- PUP_COD prob, probs + t1_R * PMULT_HALF, symSub
-endm
-
-
-; ---------- MATCHED LITERAL ----------
-
-LITM_0 macro
- mov offs, 256 * PMULT
- shl match, (PSHIFT + 1)
- mov bit, offs
- and bit, match
- PLOAD x1, probs + 256 * PMULT + bit_R * 1 + 1 * PMULT
- lea prm, [probs + 256 * PMULT + bit_R * 1 + 1 * PMULT]
- ; lea prm, [probs + 256 * PMULT + 1 * PMULT]
- ; add prm, bit_R
- xor offs, bit
- add match, match
-
- NORM_CALC x1
-
- cmovae offs, bit
- mov bit, match
- cmovae range, t0
- mov t0, kBitModelOffset
- cmovb cod, t1
- cmovb t0, kBitModelTotal_reg
- mov sym, 0
- PUP_SUB x1, prm, -2-1
-endm
-
-
-LITM macro
- and bit, offs
- lea prm, [probs + offs_R * 1]
- add prm, bit_R
- PLOAD x1, prm + sym_R * PMULT
- xor offs, bit
- add sym, sym
- add match, match
-
- NORM_CALC x1
-
- cmovae offs, bit
- mov bit, match
- cmovae range, t0
- PUP_COD x1, prm + t1_R * PMULT_HALF, - 1
-endm
-
-
-LITM_2 macro
- and bit, offs
- lea prm, [probs + offs_R * 1]
- add prm, bit_R
- PLOAD x1, prm + sym_R * PMULT
- add sym, sym
-
- NORM_CALC x1
-
- cmovae range, t0
- PUP_COD x1, prm + t1_R * PMULT_HALF, 256 - 1
-endm
-
-
-; ---------- REVERSE BITS ----------
-
-REV_0 macro prob:req, probNext:req
- ; PLOAD prob, probs + 1 * PMULT
- ; lea sym2_R, [probs + 2 * PMULT]
- ; PLOAD probNext, probs + 2 * PMULT
- PLOAD probNext, sym2_R
-
- NORM_CALC prob
-
- cmovae range, t0
- PLOAD t0, probs + 3 * PMULT
- cmovae probNext, t0
- cmovb cod, t1
- mov t0, kBitModelOffset
- cmovb t0, kBitModelTotal_reg
- lea t1_R, [probs + 3 * PMULT]
- cmovae sym2_R, t1_R
- PUP prob, probs + 1 * PMULT
-endm
-
-
-REV_1 macro prob:req, probNext:req, step:req
- add sym2_R, step * PMULT
- PLOAD probNext, sym2_R
-
- NORM_CALC prob
-
- cmovae range, t0
- PLOAD t0, sym2_R + step * PMULT
- cmovae probNext, t0
- cmovb cod, t1
- mov t0, kBitModelOffset
- cmovb t0, kBitModelTotal_reg
- lea t1_R, [sym2_R + step * PMULT]
- cmovae sym2_R, t1_R
- PUP prob, t1_R - step * PMULT_2
-endm
-
-
-REV_2 macro prob:req, step:req
- sub sym2_R, probs
- shr sym2, PSHIFT
- or sym, sym2
-
- NORM_CALC prob
-
- cmovae range, t0
- lea t0, [sym - step]
- cmovb sym, t0
- cmovb cod, t1
- mov t0, kBitModelOffset
- cmovb t0, kBitModelTotal_reg
- PUP prob, probs + sym2_R * PMULT
-endm
-
-
-REV_1_VAR macro prob:req
- PLOAD prob, sym_R
- mov probs, sym_R
- add sym_R, sym2_R
-
- NORM_CALC prob
-
- cmovae range, t0
- lea t0_R, [sym_R + sym2_R]
- cmovae sym_R, t0_R
- mov t0, kBitModelOffset
- cmovb cod, t1
- ; mov t1, kBitModelTotal
- ; cmovb t0, t1
- cmovb t0, kBitModelTotal_reg
- add sym2, sym2
- PUP prob, probs
-endm
-
-
-
-
-LIT_PROBS macro lpMaskParam:req
- ; prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
- mov t0, processedPos
- shl t0, 8
- add sym, t0
- and sym, lpMaskParam
- add probs_state_R, pbPos_R
- mov x1, LOC lc2
- lea sym, dword ptr[sym_R + 2 * sym_R]
- add probs, Literal * PMULT
- shl sym, x1_L
- add probs, sym_R
- UPDATE_0 probs_state_R, 0, IsMatch
- inc processedPos
-endm
-
-
-
-kNumPosBitsMax equ 4
-kNumPosStatesMax equ (1 SHL kNumPosBitsMax)
-
-kLenNumLowBits equ 3
-kLenNumLowSymbols equ (1 SHL kLenNumLowBits)
-kLenNumHighBits equ 8
-kLenNumHighSymbols equ (1 SHL kLenNumHighBits)
-kNumLenProbs equ (2 * kLenNumLowSymbols * kNumPosStatesMax + kLenNumHighSymbols)
-
-LenLow equ 0
-LenChoice equ LenLow
-LenChoice2 equ (LenLow + kLenNumLowSymbols)
-LenHigh equ (LenLow + 2 * kLenNumLowSymbols * kNumPosStatesMax)
-
-kNumStates equ 12
-kNumStates2 equ 16
-kNumLitStates equ 7
-
-kStartPosModelIndex equ 4
-kEndPosModelIndex equ 14
-kNumFullDistances equ (1 SHL (kEndPosModelIndex SHR 1))
-
-kNumPosSlotBits equ 6
-kNumLenToPosStates equ 4
-
-kNumAlignBits equ 4
-kAlignTableSize equ (1 SHL kNumAlignBits)
-
-kMatchMinLen equ 2
-kMatchSpecLenStart equ (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
-
-kStartOffset equ 1664
-SpecPos equ (-kStartOffset)
-IsRep0Long equ (SpecPos + kNumFullDistances)
-RepLenCoder equ (IsRep0Long + (kNumStates2 SHL kNumPosBitsMax))
-LenCoder equ (RepLenCoder + kNumLenProbs)
-IsMatch equ (LenCoder + kNumLenProbs)
-kAlign equ (IsMatch + (kNumStates2 SHL kNumPosBitsMax))
-IsRep equ (kAlign + kAlignTableSize)
-IsRepG0 equ (IsRep + kNumStates)
-IsRepG1 equ (IsRepG0 + kNumStates)
-IsRepG2 equ (IsRepG1 + kNumStates)
-PosSlot equ (IsRepG2 + kNumStates)
-Literal equ (PosSlot + (kNumLenToPosStates SHL kNumPosSlotBits))
-NUM_BASE_PROBS equ (Literal + kStartOffset)
-
-if kAlign ne 0
- .err <Stop_Compiling_Bad_LZMA_kAlign>
-endif
-
-if NUM_BASE_PROBS ne 1984
- .err <Stop_Compiling_Bad_LZMA_PROBS>
-endif
-
-
-PTR_FIELD equ dq ?
-
-CLzmaDec_Asm struct
- lc db ?
- lp db ?
- pb db ?
- _pad_ db ?
- dicSize dd ?
-
- probs_Spec PTR_FIELD
- probs_1664 PTR_FIELD
- dic_Spec PTR_FIELD
- dicBufSize PTR_FIELD
- dicPos_Spec PTR_FIELD
- buf_Spec PTR_FIELD
-
- range_Spec dd ?
- code_Spec dd ?
- processedPos_Spec dd ?
- checkDicSize dd ?
- rep0 dd ?
- rep1 dd ?
- rep2 dd ?
- rep3 dd ?
- state_Spec dd ?
- remainLen dd ?
-CLzmaDec_Asm ends
-
-
-CLzmaDec_Asm_Loc struct
- OLD_RSP PTR_FIELD
- lzmaPtr PTR_FIELD
- _pad0_ PTR_FIELD
- _pad1_ PTR_FIELD
- _pad2_ PTR_FIELD
- dicBufSize PTR_FIELD
- probs_Spec PTR_FIELD
- dic_Spec PTR_FIELD
-
- limit PTR_FIELD
- bufLimit PTR_FIELD
- lc2 dd ?
- lpMask dd ?
- pbMask dd ?
- checkDicSize dd ?
-
- _pad_ dd ?
- remainLen dd ?
- dicPos_Spec PTR_FIELD
- rep0 dd ?
- rep1 dd ?
- rep2 dd ?
- rep3 dd ?
-CLzmaDec_Asm_Loc ends
-
-
-GLOB_2 equ [sym_R].CLzmaDec_Asm.
-GLOB equ [r1].CLzmaDec_Asm.
-LOC_0 equ [r0].CLzmaDec_Asm_Loc.
-LOC equ [RSP].CLzmaDec_Asm_Loc.
-
-
-COPY_VAR macro name
- mov t0, GLOB_2 name
- mov LOC_0 name, t0
-endm
-
-
-RESTORE_VAR macro name
- mov t0, LOC name
- mov GLOB name, t0
-endm
-
-
-
-IsMatchBranch_Pre macro reg
- ; prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
- mov pbPos, LOC pbMask
- and pbPos, processedPos
- shl pbPos, (kLenNumLowBits + 1 + PSHIFT)
- lea probs_state_R, [probs + state_R]
-endm
-
-
-IsMatchBranch macro reg
- IsMatchBranch_Pre
- IF_BIT_1 probs_state_R, pbPos_R, IsMatch, IsMatch_label
-endm
-
-
-CheckLimits macro reg
- cmp buf, LOC bufLimit
- jae fin_OK
- cmp dicPos, LOC limit
- jae fin_OK
-endm
-
-
-
-; RSP is (16x + 8) bytes aligned in WIN64-x64
-; LocalSize equ ((((SIZEOF CLzmaDec_Asm_Loc) + 7) / 16 * 16) + 8)
-
-PARAM_lzma equ REG_PARAM_0
-PARAM_limit equ REG_PARAM_1
-PARAM_bufLimit equ REG_PARAM_2
-
-; MY_ALIGN_64
-MY_PROC LzmaDec_DecodeReal_3, 3
-MY_PUSH_PRESERVED_REGS
-
- lea r0, [RSP - (SIZEOF CLzmaDec_Asm_Loc)]
- and r0, -128
- mov r5, RSP
- mov RSP, r0
- mov LOC_0 Old_RSP, r5
- mov LOC_0 lzmaPtr, PARAM_lzma
-
- mov LOC_0 remainLen, 0 ; remainLen must be ZERO
-
- mov LOC_0 bufLimit, PARAM_bufLimit
- mov sym_R, PARAM_lzma ; CLzmaDec_Asm_Loc pointer for GLOB_2
- mov dic, GLOB_2 dic_Spec
- add PARAM_limit, dic
- mov LOC_0 limit, PARAM_limit
-
- COPY_VAR(rep0)
- COPY_VAR(rep1)
- COPY_VAR(rep2)
- COPY_VAR(rep3)
-
- mov dicPos, GLOB_2 dicPos_Spec
- add dicPos, dic
- mov LOC_0 dicPos_Spec, dicPos
- mov LOC_0 dic_Spec, dic
-
- mov x1_L, GLOB_2 pb
- mov t0, 1
- shl t0, x1_L
- dec t0
- mov LOC_0 pbMask, t0
-
- ; unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
- ; unsigned lc = p->prop.lc;
- ; unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
-
- mov x1_L, GLOB_2 lc
- mov x2, 100h
- mov t0, x2
- shr x2, x1_L
- ; inc x1
- add x1_L, PSHIFT
- mov LOC_0 lc2, x1
- mov x1_L, GLOB_2 lp
- shl t0, x1_L
- sub t0, x2
- mov LOC_0 lpMask, t0
- mov lpMask_reg, t0
-
- ; mov probs, GLOB_2 probs_Spec
- ; add probs, kStartOffset SHL PSHIFT
- mov probs, GLOB_2 probs_1664
- mov LOC_0 probs_Spec, probs
-
- mov t0_R, GLOB_2 dicBufSize
- mov LOC_0 dicBufSize, t0_R
-
- mov x1, GLOB_2 checkDicSize
- mov LOC_0 checkDicSize, x1
-
- mov processedPos, GLOB_2 processedPos_Spec
-
- mov state, GLOB_2 state_Spec
- shl state, PSHIFT
-
- mov buf, GLOB_2 buf_Spec
- mov range, GLOB_2 range_Spec
- mov cod, GLOB_2 code_Spec
- mov kBitModelTotal_reg, kBitModelTotal
- xor sym, sym
-
- ; if (processedPos != 0 || checkDicSize != 0)
- or x1, processedPos
- jz @f
-
- add t0_R, dic
- cmp dicPos, dic
- cmovnz t0_R, dicPos
- movzx sym, byte ptr[t0_R - 1]
-
-@@:
- IsMatchBranch_Pre
- cmp state, 4 * PMULT
- jb lit_end
- cmp state, kNumLitStates * PMULT
- jb lit_matched_end
- jmp lz_end
-
-
-
-
-; ---------- LITERAL ----------
-MY_ALIGN_64
-lit_start:
- xor state, state
-lit_start_2:
- LIT_PROBS lpMask_reg
-
- ifdef _LZMA_SIZE_OPT
-
- PLOAD x1, probs + 1 * PMULT
- mov sym, 1
-MY_ALIGN_16
-lit_loop:
- BIT_1 x1, x2
- mov x1, x2
- cmp sym, 127
- jbe lit_loop
-
- else
-
- BIT_0 x1, x2
- BIT_1 x2, x1
- BIT_1 x1, x2
- BIT_1 x2, x1
- BIT_1 x1, x2
- BIT_1 x2, x1
- BIT_1 x1, x2
-
- endif
-
- BIT_2 x2, 256 - 1
-
- ; mov dic, LOC dic_Spec
- mov probs, LOC probs_Spec
- IsMatchBranch_Pre
- mov byte ptr[dicPos], sym_L
- inc dicPos
-
- CheckLimits
-lit_end:
- IF_BIT_0_NOUP probs_state_R, pbPos_R, IsMatch, lit_start
-
- ; jmp IsMatch_label
-
-; ---------- MATCHES ----------
-; MY_ALIGN_32
-IsMatch_label:
- UPDATE_1 probs_state_R, pbPos_R, IsMatch
- IF_BIT_1 probs_state_R, 0, IsRep, IsRep_label
-
- add probs, LenCoder * PMULT
- add state, kNumStates * PMULT
-
-; ---------- LEN DECODE ----------
-len_decode:
- mov len_temp, 8 - 1 - kMatchMinLen
- IF_BIT_0_NOUP probs, 0, 0, len_mid_0
- UPDATE_1 probs, 0, 0
- add probs, (1 SHL (kLenNumLowBits + PSHIFT))
- mov len_temp, -1 - kMatchMinLen
- IF_BIT_0_NOUP probs, 0, 0, len_mid_0
- UPDATE_1 probs, 0, 0
- add probs, LenHigh * PMULT - (1 SHL (kLenNumLowBits + PSHIFT))
- mov sym, 1
- PLOAD x1, probs + 1 * PMULT
-
-MY_ALIGN_32
-len8_loop:
- BIT_1 x1, x2
- mov x1, x2
- cmp sym, 64
- jb len8_loop
-
- mov len_temp, (kLenNumHighSymbols - kLenNumLowSymbols * 2) - 1 - kMatchMinLen
- jmp len_mid_2
-
-MY_ALIGN_32
-len_mid_0:
- UPDATE_0 probs, 0, 0
- add probs, pbPos_R
- BIT_0 x2, x1
-len_mid_2:
- BIT_1 x1, x2
- BIT_2 x2, len_temp
- mov probs, LOC probs_Spec
- cmp state, kNumStates * PMULT
- jb copy_match
-
-
-; ---------- DECODE DISTANCE ----------
- ; probs + PosSlot + ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
-
- mov t0, 3 + kMatchMinLen
- cmp sym, 3 + kMatchMinLen
- cmovb t0, sym
- add probs, PosSlot * PMULT - (kMatchMinLen SHL (kNumPosSlotBits + PSHIFT))
- shl t0, (kNumPosSlotBits + PSHIFT)
- add probs, t0_R
-
- ; sym = Len
- ; mov LOC remainLen, sym
- mov len_temp, sym
-
- ifdef _LZMA_SIZE_OPT
-
- PLOAD x1, probs + 1 * PMULT
- mov sym, 1
-MY_ALIGN_16
-slot_loop:
- BIT_1 x1, x2
- mov x1, x2
- cmp sym, 32
- jb slot_loop
-
- else
-
- BIT_0 x1, x2
- BIT_1 x2, x1
- BIT_1 x1, x2
- BIT_1 x2, x1
- BIT_1 x1, x2
-
- endif
-
- mov x1, sym
- BIT_2 x2, 64-1
-
- and sym, 3
- mov probs, LOC probs_Spec
- cmp x1, 32 + kEndPosModelIndex / 2
- jb short_dist
-
- ; unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
- sub x1, (32 + 1 + kNumAlignBits)
- ; distance = (2 | (distance & 1));
- or sym, 2
- PLOAD x2, probs + 1 * PMULT
- shl sym, kNumAlignBits + 1
- lea sym2_R, [probs + 2 * PMULT]
-
- jmp direct_norm
- ; lea t1, [sym_R + (1 SHL kNumAlignBits)]
- ; cmp range, kTopValue
- ; jb direct_norm
-
-; ---------- DIRECT DISTANCE ----------
-MY_ALIGN_32
-direct_loop:
- shr range, 1
- mov t0, cod
- sub cod, range
- cmovs cod, t0
- cmovns sym, t1
-
- comment ~
- sub cod, range
- mov x2, cod
- sar x2, 31
- lea sym, dword ptr [r2 + sym_R * 2 + 1]
- and x2, range
- add cod, x2
- ~
- dec x1
- je direct_end
-
- add sym, sym
-direct_norm:
- lea t1, [sym_R + (1 SHL kNumAlignBits)]
- cmp range, kTopValue
- jae near ptr direct_loop
- ; we align for 32 here with "near ptr" command above
- NORM_2
- jmp direct_loop
-
-MY_ALIGN_32
-direct_end:
- ; prob = + kAlign;
- ; distance <<= kNumAlignBits;
- REV_0 x2, x1
- REV_1 x1, x2, 2
- REV_1 x2, x1, 4
- REV_2 x1, 8
-
-decode_dist_end:
-
- ; if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
-
- mov t0, LOC checkDicSize
- test t0, t0
- cmove t0, processedPos
- cmp sym, t0
- jae end_of_payload
-
- ; rep3 = rep2;
- ; rep2 = rep1;
- ; rep1 = rep0;
- ; rep0 = distance + 1;
-
- inc sym
- mov t0, LOC rep0
- mov t1, LOC rep1
- mov x1, LOC rep2
- mov LOC rep0, sym
- ; mov sym, LOC remainLen
- mov sym, len_temp
- mov LOC rep1, t0
- mov LOC rep2, t1
- mov LOC rep3, x1
-
- ; state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
- cmp state, (kNumStates + kNumLitStates) * PMULT
- mov state, kNumLitStates * PMULT
- mov t0, (kNumLitStates + 3) * PMULT
- cmovae state, t0
-
-
-; ---------- COPY MATCH ----------
-copy_match:
-
- ; len += kMatchMinLen;
- ; add sym, kMatchMinLen
-
- ; if ((rem = limit - dicPos) == 0)
- ; {
- ; p->dicPos = dicPos;
- ; return SZ_ERROR_DATA;
- ; }
- mov cnt_R, LOC limit
- sub cnt_R, dicPos
- jz fin_ERROR
-
- ; curLen = ((rem < len) ? (unsigned)rem : len);
- cmp cnt_R, sym_R
- ; cmovae cnt_R, sym_R ; 64-bit
- cmovae cnt, sym ; 32-bit
-
- mov dic, LOC dic_Spec
- mov x1, LOC rep0
-
- mov t0_R, dicPos
- add dicPos, cnt_R
- ; processedPos += curLen;
- add processedPos, cnt
- ; len -= curLen;
- sub sym, cnt
- mov LOC remainLen, sym
-
- sub t0_R, dic
-
- ; pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
- sub t0_R, r1
- jae @f
-
- mov r1, LOC dicBufSize
- add t0_R, r1
- sub r1, t0_R
- cmp cnt_R, r1
- ja copy_match_cross
-@@:
- ; if (curLen <= dicBufSize - pos)
-
-; ---------- COPY MATCH FAST ----------
- ; Byte *dest = dic + dicPos;
- ; mov r1, dic
- ; ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
- ; sub t0_R, dicPos
- ; dicPos += curLen;
-
- ; const Byte *lim = dest + curLen;
- add t0_R, dic
- movzx sym, byte ptr[t0_R]
- add t0_R, cnt_R
- neg cnt_R
- ; lea r1, [dicPos - 1]
-copy_common:
- dec dicPos
- ; cmp LOC rep0, 1
- ; je rep0Label
-
- ; t0_R - src_lim
- ; r1 - dest_lim - 1
- ; cnt_R - (-cnt)
-
- IsMatchBranch_Pre
- inc cnt_R
- jz copy_end
-MY_ALIGN_16
-@@:
- mov byte ptr[cnt_R * 1 + dicPos], sym_L
- movzx sym, byte ptr[cnt_R * 1 + t0_R]
- inc cnt_R
- jnz @b
-
-copy_end:
-lz_end_match:
- mov byte ptr[dicPos], sym_L
- inc dicPos
-
- ; IsMatchBranch_Pre
- CheckLimits
-lz_end:
- IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
-
-
-
-; ---------- LITERAL MATCHED ----------
-
- LIT_PROBS LOC lpMask
-
- ; matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
- mov x1, LOC rep0
- ; mov dic, LOC dic_Spec
- mov LOC dicPos_Spec, dicPos
-
- ; state -= (state < 10) ? 3 : 6;
- lea t0, [state_R - 6 * PMULT]
- sub state, 3 * PMULT
- cmp state, 7 * PMULT
- cmovae state, t0
-
- sub dicPos, dic
- sub dicPos, r1
- jae @f
- add dicPos, LOC dicBufSize
-@@:
- comment ~
- xor t0, t0
- sub dicPos, r1
- cmovb t0_R, LOC dicBufSize
- ~
-
- movzx match, byte ptr[dic + dicPos * 1]
-
- ifdef _LZMA_SIZE_OPT
-
- mov offs, 256 * PMULT
- shl match, (PSHIFT + 1)
- mov bit, match
- mov sym, 1
-MY_ALIGN_16
-litm_loop:
- LITM
- cmp sym, 256
- jb litm_loop
- sub sym, 256
-
- else
-
- LITM_0
- LITM
- LITM
- LITM
- LITM
- LITM
- LITM
- LITM_2
-
- endif
-
- mov probs, LOC probs_Spec
- IsMatchBranch_Pre
- ; mov dic, LOC dic_Spec
- mov dicPos, LOC dicPos_Spec
- mov byte ptr[dicPos], sym_L
- inc dicPos
-
- CheckLimits
-lit_matched_end:
- IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
- ; IsMatchBranch
- mov lpMask_reg, LOC lpMask
- sub state, 3 * PMULT
- jmp lit_start_2
-
-
-
-; ---------- REP 0 LITERAL ----------
-MY_ALIGN_32
-IsRep0Short_label:
- UPDATE_0 probs_state_R, pbPos_R, IsRep0Long
-
- ; dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
- mov dic, LOC dic_Spec
- mov t0_R, dicPos
- mov probBranch, LOC rep0
- sub t0_R, dic
-
- sub probs, RepLenCoder * PMULT
- inc processedPos
- ; state = state < kNumLitStates ? 9 : 11;
- or state, 1 * PMULT
- IsMatchBranch_Pre
-
- sub t0_R, probBranch_R
- jae @f
- add t0_R, LOC dicBufSize
-@@:
- movzx sym, byte ptr[dic + t0_R * 1]
- jmp lz_end_match
-
-
-MY_ALIGN_32
-IsRep_label:
- UPDATE_1 probs_state_R, 0, IsRep
-
- ; The (checkDicSize == 0 && processedPos == 0) case was checked before in LzmaDec.c with kBadRepCode.
- ; So we don't check it here.
-
- ; mov t0, processedPos
- ; or t0, LOC checkDicSize
- ; jz fin_ERROR_2
-
- ; state = state < kNumLitStates ? 8 : 11;
- cmp state, kNumLitStates * PMULT
- mov state, 8 * PMULT
- mov probBranch, 11 * PMULT
- cmovae state, probBranch
-
- ; prob = probs + RepLenCoder;
- add probs, RepLenCoder * PMULT
-
- IF_BIT_1 probs_state_R, 0, IsRepG0, IsRepG0_label
- IF_BIT_0_NOUP probs_state_R, pbPos_R, IsRep0Long, IsRep0Short_label
- UPDATE_1 probs_state_R, pbPos_R, IsRep0Long
- jmp len_decode
-
-MY_ALIGN_32
-IsRepG0_label:
- UPDATE_1 probs_state_R, 0, IsRepG0
- mov dist2, LOC rep0
- mov dist, LOC rep1
- mov LOC rep1, dist2
-
- IF_BIT_1 probs_state_R, 0, IsRepG1, IsRepG1_label
- mov LOC rep0, dist
- jmp len_decode
-
-; MY_ALIGN_32
-IsRepG1_label:
- UPDATE_1 probs_state_R, 0, IsRepG1
- mov dist2, LOC rep2
- mov LOC rep2, dist
-
- IF_BIT_1 probs_state_R, 0, IsRepG2, IsRepG2_label
- mov LOC rep0, dist2
- jmp len_decode
-
-; MY_ALIGN_32
-IsRepG2_label:
- UPDATE_1 probs_state_R, 0, IsRepG2
- mov dist, LOC rep3
- mov LOC rep3, dist2
- mov LOC rep0, dist
- jmp len_decode
-
-
-
-; ---------- SPEC SHORT DISTANCE ----------
-
-MY_ALIGN_32
-short_dist:
- sub x1, 32 + 1
- jbe decode_dist_end
- or sym, 2
- shl sym, x1_L
- lea sym_R, [probs + sym_R * PMULT + SpecPos * PMULT + 1 * PMULT]
- mov sym2, PMULT ; step
-MY_ALIGN_32
-spec_loop:
- REV_1_VAR x2
- dec x1
- jnz spec_loop
-
- mov probs, LOC probs_Spec
- sub sym, sym2
- sub sym, SpecPos * PMULT
- sub sym_R, probs
- shr sym, PSHIFT
-
- jmp decode_dist_end
-
-
-; ---------- COPY MATCH CROSS ----------
-copy_match_cross:
- ; t0_R - src pos
- ; r1 - len to dicBufSize
- ; cnt_R - total copy len
-
- mov t1_R, t0_R ; srcPos
- mov t0_R, dic
- mov r1, LOC dicBufSize ;
- neg cnt_R
-@@:
- movzx sym, byte ptr[t1_R * 1 + t0_R]
- inc t1_R
- mov byte ptr[cnt_R * 1 + dicPos], sym_L
- inc cnt_R
- cmp t1_R, r1
- jne @b
-
- movzx sym, byte ptr[t0_R]
- sub t0_R, cnt_R
- jmp copy_common
-
-
-
-
-fin_ERROR:
- mov LOC remainLen, len_temp
-; fin_ERROR_2:
- mov sym, 1
- jmp fin
-
-end_of_payload:
- cmp sym, 0FFFFFFFFh ; -1
- jne fin_ERROR
-
- mov LOC remainLen, kMatchSpecLenStart
- sub state, kNumStates * PMULT
-
-fin_OK:
- xor sym, sym
-
-fin:
- NORM
-
- mov r1, LOC lzmaPtr
-
- sub dicPos, LOC dic_Spec
- mov GLOB dicPos_Spec, dicPos
- mov GLOB buf_Spec, buf
- mov GLOB range_Spec, range
- mov GLOB code_Spec, cod
- shr state, PSHIFT
- mov GLOB state_Spec, state
- mov GLOB processedPos_Spec, processedPos
-
- RESTORE_VAR(remainLen)
- RESTORE_VAR(rep0)
- RESTORE_VAR(rep1)
- RESTORE_VAR(rep2)
- RESTORE_VAR(rep3)
-
- mov x0, sym
-
- mov RSP, LOC Old_RSP
-
-MY_POP_PRESERVED_REGS
-MY_ENDP
-
-_TEXT$LZMADECOPT ENDS
-
-end
+; LzmaDecOpt.asm -- ASM version of LzmaDec_DecodeReal_3() function
+; 2021-02-23: Igor Pavlov : Public domain
+;
+; 3 - is the code compatibility version of LzmaDec_DecodeReal_*()
+; function for check at link time.
+; That code is tightly coupled with LzmaDec_TryDummy()
+; and with another functions in LzmaDec.c file.
+; CLzmaDec structure, (probs) array layout, input and output of
+; LzmaDec_DecodeReal_*() must be equal in both versions (C / ASM).
+
+ifndef x64
+; x64=1
+; .err <x64_IS_REQUIRED>
+endif
+
+include 7zAsm.asm
+
+MY_ASM_START
+
+_TEXT$LZMADECOPT SEGMENT ALIGN(64) 'CODE'
+
+MY_ALIGN macro num:req
+ align num
+endm
+
+MY_ALIGN_16 macro
+ MY_ALIGN 16
+endm
+
+MY_ALIGN_32 macro
+ MY_ALIGN 32
+endm
+
+MY_ALIGN_64 macro
+ MY_ALIGN 64
+endm
+
+
+; _LZMA_SIZE_OPT equ 1
+
+; _LZMA_PROB32 equ 1
+
+ifdef _LZMA_PROB32
+ PSHIFT equ 2
+ PLOAD macro dest, mem
+ mov dest, dword ptr [mem]
+ endm
+ PSTORE macro src, mem
+ mov dword ptr [mem], src
+ endm
+else
+ PSHIFT equ 1
+ PLOAD macro dest, mem
+ movzx dest, word ptr [mem]
+ endm
+ PSTORE macro src, mem
+ mov word ptr [mem], @CatStr(src, _W)
+ endm
+endif
+
+PMULT equ (1 SHL PSHIFT)
+PMULT_HALF equ (1 SHL (PSHIFT - 1))
+PMULT_2 equ (1 SHL (PSHIFT + 1))
+
+kMatchSpecLen_Error_Data equ (1 SHL 9)
+
+; x0 range
+; x1 pbPos / (prob) TREE
+; x2 probBranch / prm (MATCHED) / pbPos / cnt
+; x3 sym
+;====== r4 === RSP
+; x5 cod
+; x6 t1 NORM_CALC / probs_state / dist
+; x7 t0 NORM_CALC / prob2 IF_BIT_1
+; x8 state
+; x9 match (MATCHED) / sym2 / dist2 / lpMask_reg
+; x10 kBitModelTotal_reg
+; r11 probs
+; x12 offs (MATCHED) / dic / len_temp
+; x13 processedPos
+; x14 bit (MATCHED) / dicPos
+; r15 buf
+
+
+cod equ x5
+cod_L equ x5_L
+range equ x0
+state equ x8
+state_R equ r8
+buf equ r15
+processedPos equ x13
+kBitModelTotal_reg equ x10
+
+probBranch equ x2
+probBranch_R equ r2
+probBranch_W equ x2_W
+
+pbPos equ x1
+pbPos_R equ r1
+
+cnt equ x2
+cnt_R equ r2
+
+lpMask_reg equ x9
+dicPos equ r14
+
+sym equ x3
+sym_R equ r3
+sym_L equ x3_L
+
+probs equ r11
+dic equ r12
+
+t0 equ x7
+t0_W equ x7_W
+t0_R equ r7
+
+prob2 equ t0
+prob2_W equ t0_W
+
+t1 equ x6
+t1_R equ r6
+
+probs_state equ t1
+probs_state_R equ t1_R
+
+prm equ r2
+match equ x9
+match_R equ r9
+offs equ x12
+offs_R equ r12
+bit equ x14
+bit_R equ r14
+
+sym2 equ x9
+sym2_R equ r9
+
+len_temp equ x12
+
+dist equ sym
+dist2 equ x9
+
+
+
+kNumBitModelTotalBits equ 11
+kBitModelTotal equ (1 SHL kNumBitModelTotalBits)
+kNumMoveBits equ 5
+kBitModelOffset equ ((1 SHL kNumMoveBits) - 1)
+kTopValue equ (1 SHL 24)
+
+NORM_2 macro
+ ; movzx t0, BYTE PTR [buf]
+ shl cod, 8
+ mov cod_L, BYTE PTR [buf]
+ shl range, 8
+ ; or cod, t0
+ inc buf
+endm
+
+
+NORM macro
+ cmp range, kTopValue
+ jae SHORT @F
+ NORM_2
+@@:
+endm
+
+
+; ---------- Branch MACROS ----------
+
+UPDATE_0 macro probsArray:req, probOffset:req, probDisp:req
+ mov prob2, kBitModelTotal_reg
+ sub prob2, probBranch
+ shr prob2, kNumMoveBits
+ add probBranch, prob2
+ PSTORE probBranch, probOffset * 1 + probsArray + probDisp * PMULT
+endm
+
+
+UPDATE_1 macro probsArray:req, probOffset:req, probDisp:req
+ sub prob2, range
+ sub cod, range
+ mov range, prob2
+ mov prob2, probBranch
+ shr probBranch, kNumMoveBits
+ sub prob2, probBranch
+ PSTORE prob2, probOffset * 1 + probsArray + probDisp * PMULT
+endm
+
+
+CMP_COD macro probsArray:req, probOffset:req, probDisp:req
+ PLOAD probBranch, probOffset * 1 + probsArray + probDisp * PMULT
+ NORM
+ mov prob2, range
+ shr range, kNumBitModelTotalBits
+ imul range, probBranch
+ cmp cod, range
+endm
+
+
+IF_BIT_1_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
+ CMP_COD probsArray, probOffset, probDisp
+ jae toLabel
+endm
+
+
+IF_BIT_1 macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
+ IF_BIT_1_NOUP probsArray, probOffset, probDisp, toLabel
+ UPDATE_0 probsArray, probOffset, probDisp
+endm
+
+
+IF_BIT_0_NOUP macro probsArray:req, probOffset:req, probDisp:req, toLabel:req
+ CMP_COD probsArray, probOffset, probDisp
+ jb toLabel
+endm
+
+
+; ---------- CMOV MACROS ----------
+
+NORM_CALC macro prob:req
+ NORM
+ mov t0, range
+ shr range, kNumBitModelTotalBits
+ imul range, prob
+ sub t0, range
+ mov t1, cod
+ sub cod, range
+endm
+
+
+PUP macro prob:req, probPtr:req
+ sub t0, prob
+ ; only sar works for both 16/32 bit prob modes
+ sar t0, kNumMoveBits
+ add t0, prob
+ PSTORE t0, probPtr
+endm
+
+
+PUP_SUB macro prob:req, probPtr:req, symSub:req
+ sbb sym, symSub
+ PUP prob, probPtr
+endm
+
+
+PUP_COD macro prob:req, probPtr:req, symSub:req
+ mov t0, kBitModelOffset
+ cmovb cod, t1
+ mov t1, sym
+ cmovb t0, kBitModelTotal_reg
+ PUP_SUB prob, probPtr, symSub
+endm
+
+
+BIT_0 macro prob:req, probNext:req
+ PLOAD prob, probs + 1 * PMULT
+ PLOAD probNext, probs + 1 * PMULT_2
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ PLOAD t0, probs + 1 * PMULT_2 + PMULT
+ cmovae probNext, t0
+ mov t0, kBitModelOffset
+ cmovb cod, t1
+ cmovb t0, kBitModelTotal_reg
+ mov sym, 2
+ PUP_SUB prob, probs + 1 * PMULT, 0 - 1
+endm
+
+
+BIT_1 macro prob:req, probNext:req
+ PLOAD probNext, probs + sym_R * PMULT_2
+ add sym, sym
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ PLOAD t0, probs + sym_R * PMULT + PMULT
+ cmovae probNext, t0
+ PUP_COD prob, probs + t1_R * PMULT_HALF, 0 - 1
+endm
+
+
+BIT_2 macro prob:req, symSub:req
+ add sym, sym
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ PUP_COD prob, probs + t1_R * PMULT_HALF, symSub
+endm
+
+
+; ---------- MATCHED LITERAL ----------
+
+LITM_0 macro
+ mov offs, 256 * PMULT
+ shl match, (PSHIFT + 1)
+ mov bit, offs
+ and bit, match
+ PLOAD x1, probs + 256 * PMULT + bit_R * 1 + 1 * PMULT
+ lea prm, [probs + 256 * PMULT + bit_R * 1 + 1 * PMULT]
+ ; lea prm, [probs + 256 * PMULT + 1 * PMULT]
+ ; add prm, bit_R
+ xor offs, bit
+ add match, match
+
+ NORM_CALC x1
+
+ cmovae offs, bit
+ mov bit, match
+ cmovae range, t0
+ mov t0, kBitModelOffset
+ cmovb cod, t1
+ cmovb t0, kBitModelTotal_reg
+ mov sym, 0
+ PUP_SUB x1, prm, -2-1
+endm
+
+
+LITM macro
+ and bit, offs
+ lea prm, [probs + offs_R * 1]
+ add prm, bit_R
+ PLOAD x1, prm + sym_R * PMULT
+ xor offs, bit
+ add sym, sym
+ add match, match
+
+ NORM_CALC x1
+
+ cmovae offs, bit
+ mov bit, match
+ cmovae range, t0
+ PUP_COD x1, prm + t1_R * PMULT_HALF, - 1
+endm
+
+
+LITM_2 macro
+ and bit, offs
+ lea prm, [probs + offs_R * 1]
+ add prm, bit_R
+ PLOAD x1, prm + sym_R * PMULT
+ add sym, sym
+
+ NORM_CALC x1
+
+ cmovae range, t0
+ PUP_COD x1, prm + t1_R * PMULT_HALF, 256 - 1
+endm
+
+
+; ---------- REVERSE BITS ----------
+
+REV_0 macro prob:req, probNext:req
+ ; PLOAD prob, probs + 1 * PMULT
+ ; lea sym2_R, [probs + 2 * PMULT]
+ ; PLOAD probNext, probs + 2 * PMULT
+ PLOAD probNext, sym2_R
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ PLOAD t0, probs + 3 * PMULT
+ cmovae probNext, t0
+ cmovb cod, t1
+ mov t0, kBitModelOffset
+ cmovb t0, kBitModelTotal_reg
+ lea t1_R, [probs + 3 * PMULT]
+ cmovae sym2_R, t1_R
+ PUP prob, probs + 1 * PMULT
+endm
+
+
+REV_1 macro prob:req, probNext:req, step:req
+ add sym2_R, step * PMULT
+ PLOAD probNext, sym2_R
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ PLOAD t0, sym2_R + step * PMULT
+ cmovae probNext, t0
+ cmovb cod, t1
+ mov t0, kBitModelOffset
+ cmovb t0, kBitModelTotal_reg
+ lea t1_R, [sym2_R + step * PMULT]
+ cmovae sym2_R, t1_R
+ PUP prob, t1_R - step * PMULT_2
+endm
+
+
+REV_2 macro prob:req, step:req
+ sub sym2_R, probs
+ shr sym2, PSHIFT
+ or sym, sym2
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ lea t0, [sym - step]
+ cmovb sym, t0
+ cmovb cod, t1
+ mov t0, kBitModelOffset
+ cmovb t0, kBitModelTotal_reg
+ PUP prob, probs + sym2_R * PMULT
+endm
+
+
+REV_1_VAR macro prob:req
+ PLOAD prob, sym_R
+ mov probs, sym_R
+ add sym_R, sym2_R
+
+ NORM_CALC prob
+
+ cmovae range, t0
+ lea t0_R, [sym_R + 1 * sym2_R]
+ cmovae sym_R, t0_R
+ mov t0, kBitModelOffset
+ cmovb cod, t1
+ ; mov t1, kBitModelTotal
+ ; cmovb t0, t1
+ cmovb t0, kBitModelTotal_reg
+ add sym2, sym2
+ PUP prob, probs
+endm
+
+
+
+
+LIT_PROBS macro lpMaskParam:req
+ ; prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
+ mov t0, processedPos
+ shl t0, 8
+ add sym, t0
+ and sym, lpMaskParam
+ add probs_state_R, pbPos_R
+ mov x1, LOC lc2
+ lea sym, dword ptr[sym_R + 2 * sym_R]
+ add probs, Literal * PMULT
+ shl sym, x1_L
+ add probs, sym_R
+ UPDATE_0 probs_state_R, 0, IsMatch
+ inc processedPos
+endm
+
+
+
+kNumPosBitsMax equ 4
+kNumPosStatesMax equ (1 SHL kNumPosBitsMax)
+
+kLenNumLowBits equ 3
+kLenNumLowSymbols equ (1 SHL kLenNumLowBits)
+kLenNumHighBits equ 8
+kLenNumHighSymbols equ (1 SHL kLenNumHighBits)
+kNumLenProbs equ (2 * kLenNumLowSymbols * kNumPosStatesMax + kLenNumHighSymbols)
+
+LenLow equ 0
+LenChoice equ LenLow
+LenChoice2 equ (LenLow + kLenNumLowSymbols)
+LenHigh equ (LenLow + 2 * kLenNumLowSymbols * kNumPosStatesMax)
+
+kNumStates equ 12
+kNumStates2 equ 16
+kNumLitStates equ 7
+
+kStartPosModelIndex equ 4
+kEndPosModelIndex equ 14
+kNumFullDistances equ (1 SHL (kEndPosModelIndex SHR 1))
+
+kNumPosSlotBits equ 6
+kNumLenToPosStates equ 4
+
+kNumAlignBits equ 4
+kAlignTableSize equ (1 SHL kNumAlignBits)
+
+kMatchMinLen equ 2
+kMatchSpecLenStart equ (kMatchMinLen + kLenNumLowSymbols * 2 + kLenNumHighSymbols)
+
+kStartOffset equ 1664
+SpecPos equ (-kStartOffset)
+IsRep0Long equ (SpecPos + kNumFullDistances)
+RepLenCoder equ (IsRep0Long + (kNumStates2 SHL kNumPosBitsMax))
+LenCoder equ (RepLenCoder + kNumLenProbs)
+IsMatch equ (LenCoder + kNumLenProbs)
+kAlign equ (IsMatch + (kNumStates2 SHL kNumPosBitsMax))
+IsRep equ (kAlign + kAlignTableSize)
+IsRepG0 equ (IsRep + kNumStates)
+IsRepG1 equ (IsRepG0 + kNumStates)
+IsRepG2 equ (IsRepG1 + kNumStates)
+PosSlot equ (IsRepG2 + kNumStates)
+Literal equ (PosSlot + (kNumLenToPosStates SHL kNumPosSlotBits))
+NUM_BASE_PROBS equ (Literal + kStartOffset)
+
+if kAlign ne 0
+ .err <Stop_Compiling_Bad_LZMA_kAlign>
+endif
+
+if NUM_BASE_PROBS ne 1984
+ .err <Stop_Compiling_Bad_LZMA_PROBS>
+endif
+
+
+PTR_FIELD equ dq ?
+
+CLzmaDec_Asm struct
+ lc db ?
+ lp db ?
+ pb db ?
+ _pad_ db ?
+ dicSize dd ?
+
+ probs_Spec PTR_FIELD
+ probs_1664 PTR_FIELD
+ dic_Spec PTR_FIELD
+ dicBufSize PTR_FIELD
+ dicPos_Spec PTR_FIELD
+ buf_Spec PTR_FIELD
+
+ range_Spec dd ?
+ code_Spec dd ?
+ processedPos_Spec dd ?
+ checkDicSize dd ?
+ rep0 dd ?
+ rep1 dd ?
+ rep2 dd ?
+ rep3 dd ?
+ state_Spec dd ?
+ remainLen dd ?
+CLzmaDec_Asm ends
+
+
+CLzmaDec_Asm_Loc struct
+ OLD_RSP PTR_FIELD
+ lzmaPtr PTR_FIELD
+ _pad0_ PTR_FIELD
+ _pad1_ PTR_FIELD
+ _pad2_ PTR_FIELD
+ dicBufSize PTR_FIELD
+ probs_Spec PTR_FIELD
+ dic_Spec PTR_FIELD
+
+ limit PTR_FIELD
+ bufLimit PTR_FIELD
+ lc2 dd ?
+ lpMask dd ?
+ pbMask dd ?
+ checkDicSize dd ?
+
+ _pad_ dd ?
+ remainLen dd ?
+ dicPos_Spec PTR_FIELD
+ rep0 dd ?
+ rep1 dd ?
+ rep2 dd ?
+ rep3 dd ?
+CLzmaDec_Asm_Loc ends
+
+
+GLOB_2 equ [sym_R].CLzmaDec_Asm.
+GLOB equ [r1].CLzmaDec_Asm.
+LOC_0 equ [r0].CLzmaDec_Asm_Loc.
+LOC equ [RSP].CLzmaDec_Asm_Loc.
+
+
+COPY_VAR macro name
+ mov t0, GLOB_2 name
+ mov LOC_0 name, t0
+endm
+
+
+RESTORE_VAR macro name
+ mov t0, LOC name
+ mov GLOB name, t0
+endm
+
+
+
+IsMatchBranch_Pre macro reg
+ ; prob = probs + IsMatch + (state << kNumPosBitsMax) + posState;
+ mov pbPos, LOC pbMask
+ and pbPos, processedPos
+ shl pbPos, (kLenNumLowBits + 1 + PSHIFT)
+ lea probs_state_R, [probs + 1 * state_R]
+endm
+
+
+IsMatchBranch macro reg
+ IsMatchBranch_Pre
+ IF_BIT_1 probs_state_R, pbPos_R, IsMatch, IsMatch_label
+endm
+
+
+CheckLimits macro reg
+ cmp buf, LOC bufLimit
+ jae fin_OK
+ cmp dicPos, LOC limit
+ jae fin_OK
+endm
+
+
+
+; RSP is (16x + 8) bytes aligned in WIN64-x64
+; LocalSize equ ((((SIZEOF CLzmaDec_Asm_Loc) + 7) / 16 * 16) + 8)
+
+PARAM_lzma equ REG_ABI_PARAM_0
+PARAM_limit equ REG_ABI_PARAM_1
+PARAM_bufLimit equ REG_ABI_PARAM_2
+
+; MY_ALIGN_64
+MY_PROC LzmaDec_DecodeReal_3, 3
+MY_PUSH_PRESERVED_ABI_REGS
+
+ lea r0, [RSP - (SIZEOF CLzmaDec_Asm_Loc)]
+ and r0, -128
+ mov r5, RSP
+ mov RSP, r0
+ mov LOC_0 Old_RSP, r5
+ mov LOC_0 lzmaPtr, PARAM_lzma
+
+ mov LOC_0 remainLen, 0 ; remainLen must be ZERO
+
+ mov LOC_0 bufLimit, PARAM_bufLimit
+ mov sym_R, PARAM_lzma ; CLzmaDec_Asm_Loc pointer for GLOB_2
+ mov dic, GLOB_2 dic_Spec
+ add PARAM_limit, dic
+ mov LOC_0 limit, PARAM_limit
+
+ COPY_VAR(rep0)
+ COPY_VAR(rep1)
+ COPY_VAR(rep2)
+ COPY_VAR(rep3)
+
+ mov dicPos, GLOB_2 dicPos_Spec
+ add dicPos, dic
+ mov LOC_0 dicPos_Spec, dicPos
+ mov LOC_0 dic_Spec, dic
+
+ mov x1_L, GLOB_2 pb
+ mov t0, 1
+ shl t0, x1_L
+ dec t0
+ mov LOC_0 pbMask, t0
+
+ ; unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
+ ; unsigned lc = p->prop.lc;
+ ; unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
+
+ mov x1_L, GLOB_2 lc
+ mov x2, 100h
+ mov t0, x2
+ shr x2, x1_L
+ ; inc x1
+ add x1_L, PSHIFT
+ mov LOC_0 lc2, x1
+ mov x1_L, GLOB_2 lp
+ shl t0, x1_L
+ sub t0, x2
+ mov LOC_0 lpMask, t0
+ mov lpMask_reg, t0
+
+ ; mov probs, GLOB_2 probs_Spec
+ ; add probs, kStartOffset SHL PSHIFT
+ mov probs, GLOB_2 probs_1664
+ mov LOC_0 probs_Spec, probs
+
+ mov t0_R, GLOB_2 dicBufSize
+ mov LOC_0 dicBufSize, t0_R
+
+ mov x1, GLOB_2 checkDicSize
+ mov LOC_0 checkDicSize, x1
+
+ mov processedPos, GLOB_2 processedPos_Spec
+
+ mov state, GLOB_2 state_Spec
+ shl state, PSHIFT
+
+ mov buf, GLOB_2 buf_Spec
+ mov range, GLOB_2 range_Spec
+ mov cod, GLOB_2 code_Spec
+ mov kBitModelTotal_reg, kBitModelTotal
+ xor sym, sym
+
+ ; if (processedPos != 0 || checkDicSize != 0)
+ or x1, processedPos
+ jz @f
+
+ add t0_R, dic
+ cmp dicPos, dic
+ cmovnz t0_R, dicPos
+ movzx sym, byte ptr[t0_R - 1]
+
+@@:
+ IsMatchBranch_Pre
+ cmp state, 4 * PMULT
+ jb lit_end
+ cmp state, kNumLitStates * PMULT
+ jb lit_matched_end
+ jmp lz_end
+
+
+
+
+; ---------- LITERAL ----------
+MY_ALIGN_64
+lit_start:
+ xor state, state
+lit_start_2:
+ LIT_PROBS lpMask_reg
+
+ ifdef _LZMA_SIZE_OPT
+
+ PLOAD x1, probs + 1 * PMULT
+ mov sym, 1
+MY_ALIGN_16
+lit_loop:
+ BIT_1 x1, x2
+ mov x1, x2
+ cmp sym, 127
+ jbe lit_loop
+
+ else
+
+ BIT_0 x1, x2
+ BIT_1 x2, x1
+ BIT_1 x1, x2
+ BIT_1 x2, x1
+ BIT_1 x1, x2
+ BIT_1 x2, x1
+ BIT_1 x1, x2
+
+ endif
+
+ BIT_2 x2, 256 - 1
+
+ ; mov dic, LOC dic_Spec
+ mov probs, LOC probs_Spec
+ IsMatchBranch_Pre
+ mov byte ptr[dicPos], sym_L
+ inc dicPos
+
+ CheckLimits
+lit_end:
+ IF_BIT_0_NOUP probs_state_R, pbPos_R, IsMatch, lit_start
+
+ ; jmp IsMatch_label
+
+; ---------- MATCHES ----------
+; MY_ALIGN_32
+IsMatch_label:
+ UPDATE_1 probs_state_R, pbPos_R, IsMatch
+ IF_BIT_1 probs_state_R, 0, IsRep, IsRep_label
+
+ add probs, LenCoder * PMULT
+ add state, kNumStates * PMULT
+
+; ---------- LEN DECODE ----------
+len_decode:
+ mov len_temp, 8 - 1 - kMatchMinLen
+ IF_BIT_0_NOUP probs, 0, 0, len_mid_0
+ UPDATE_1 probs, 0, 0
+ add probs, (1 SHL (kLenNumLowBits + PSHIFT))
+ mov len_temp, -1 - kMatchMinLen
+ IF_BIT_0_NOUP probs, 0, 0, len_mid_0
+ UPDATE_1 probs, 0, 0
+ add probs, LenHigh * PMULT - (1 SHL (kLenNumLowBits + PSHIFT))
+ mov sym, 1
+ PLOAD x1, probs + 1 * PMULT
+
+MY_ALIGN_32
+len8_loop:
+ BIT_1 x1, x2
+ mov x1, x2
+ cmp sym, 64
+ jb len8_loop
+
+ mov len_temp, (kLenNumHighSymbols - kLenNumLowSymbols * 2) - 1 - kMatchMinLen
+ jmp short len_mid_2 ; we use short here for MASM that doesn't optimize that code as another assembler programs
+
+MY_ALIGN_32
+len_mid_0:
+ UPDATE_0 probs, 0, 0
+ add probs, pbPos_R
+ BIT_0 x2, x1
+len_mid_2:
+ BIT_1 x1, x2
+ BIT_2 x2, len_temp
+ mov probs, LOC probs_Spec
+ cmp state, kNumStates * PMULT
+ jb copy_match
+
+
+; ---------- DECODE DISTANCE ----------
+ ; probs + PosSlot + ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
+
+ mov t0, 3 + kMatchMinLen
+ cmp sym, 3 + kMatchMinLen
+ cmovb t0, sym
+ add probs, PosSlot * PMULT - (kMatchMinLen SHL (kNumPosSlotBits + PSHIFT))
+ shl t0, (kNumPosSlotBits + PSHIFT)
+ add probs, t0_R
+
+ ; sym = Len
+ ; mov LOC remainLen, sym
+ mov len_temp, sym
+
+ ifdef _LZMA_SIZE_OPT
+
+ PLOAD x1, probs + 1 * PMULT
+ mov sym, 1
+MY_ALIGN_16
+slot_loop:
+ BIT_1 x1, x2
+ mov x1, x2
+ cmp sym, 32
+ jb slot_loop
+
+ else
+
+ BIT_0 x1, x2
+ BIT_1 x2, x1
+ BIT_1 x1, x2
+ BIT_1 x2, x1
+ BIT_1 x1, x2
+
+ endif
+
+ mov x1, sym
+ BIT_2 x2, 64-1
+
+ and sym, 3
+ mov probs, LOC probs_Spec
+ cmp x1, 32 + kEndPosModelIndex / 2
+ jb short_dist
+
+ ; unsigned numDirectBits = (unsigned)(((distance >> 1) - 1));
+ sub x1, (32 + 1 + kNumAlignBits)
+ ; distance = (2 | (distance & 1));
+ or sym, 2
+ PLOAD x2, probs + 1 * PMULT
+ shl sym, kNumAlignBits + 1
+ lea sym2_R, [probs + 2 * PMULT]
+
+ jmp direct_norm
+ ; lea t1, [sym_R + (1 SHL kNumAlignBits)]
+ ; cmp range, kTopValue
+ ; jb direct_norm
+
+; ---------- DIRECT DISTANCE ----------
+MY_ALIGN_32
+direct_loop:
+ shr range, 1
+ mov t0, cod
+ sub cod, range
+ cmovs cod, t0
+ cmovns sym, t1
+
+ comment ~
+ sub cod, range
+ mov x2, cod
+ sar x2, 31
+ lea sym, dword ptr [r2 + sym_R * 2 + 1]
+ and x2, range
+ add cod, x2
+ ~
+ dec x1
+ je direct_end
+
+ add sym, sym
+direct_norm:
+ lea t1, [sym_R + (1 SHL kNumAlignBits)]
+ cmp range, kTopValue
+ jae near ptr direct_loop
+ ; we align for 32 here with "near ptr" command above
+ NORM_2
+ jmp direct_loop
+
+MY_ALIGN_32
+direct_end:
+ ; prob = + kAlign;
+ ; distance <<= kNumAlignBits;
+ REV_0 x2, x1
+ REV_1 x1, x2, 2
+ REV_1 x2, x1, 4
+ REV_2 x1, 8
+
+decode_dist_end:
+
+ ; if (distance >= (checkDicSize == 0 ? processedPos: checkDicSize))
+
+ mov t1, LOC rep0
+ mov x1, LOC rep1
+ mov x2, LOC rep2
+
+ mov t0, LOC checkDicSize
+ test t0, t0
+ cmove t0, processedPos
+ cmp sym, t0
+ jae end_of_payload
+ ; jmp end_of_payload ; for debug
+
+ ; rep3 = rep2;
+ ; rep2 = rep1;
+ ; rep1 = rep0;
+ ; rep0 = distance + 1;
+
+ inc sym
+ mov LOC rep0, sym
+ ; mov sym, LOC remainLen
+ mov sym, len_temp
+ mov LOC rep1, t1
+ mov LOC rep2, x1
+ mov LOC rep3, x2
+
+ ; state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
+ cmp state, (kNumStates + kNumLitStates) * PMULT
+ mov state, kNumLitStates * PMULT
+ mov t0, (kNumLitStates + 3) * PMULT
+ cmovae state, t0
+
+
+; ---------- COPY MATCH ----------
+copy_match:
+
+ ; len += kMatchMinLen;
+ ; add sym, kMatchMinLen
+
+ ; if ((rem = limit - dicPos) == 0)
+ ; {
+ ; p->dicPos = dicPos;
+ ; return SZ_ERROR_DATA;
+ ; }
+ mov cnt_R, LOC limit
+ sub cnt_R, dicPos
+ jz fin_dicPos_LIMIT
+
+ ; curLen = ((rem < len) ? (unsigned)rem : len);
+ cmp cnt_R, sym_R
+ ; cmovae cnt_R, sym_R ; 64-bit
+ cmovae cnt, sym ; 32-bit
+
+ mov dic, LOC dic_Spec
+ mov x1, LOC rep0
+
+ mov t0_R, dicPos
+ add dicPos, cnt_R
+ ; processedPos += curLen;
+ add processedPos, cnt
+ ; len -= curLen;
+ sub sym, cnt
+ mov LOC remainLen, sym
+
+ sub t0_R, dic
+
+ ; pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
+ sub t0_R, r1
+ jae @f
+
+ mov r1, LOC dicBufSize
+ add t0_R, r1
+ sub r1, t0_R
+ cmp cnt_R, r1
+ ja copy_match_cross
+@@:
+ ; if (curLen <= dicBufSize - pos)
+
+; ---------- COPY MATCH FAST ----------
+ ; Byte *dest = dic + dicPos;
+ ; mov r1, dic
+ ; ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
+ ; sub t0_R, dicPos
+ ; dicPos += curLen;
+
+ ; const Byte *lim = dest + curLen;
+ add t0_R, dic
+ movzx sym, byte ptr[t0_R]
+ add t0_R, cnt_R
+ neg cnt_R
+ ; lea r1, [dicPos - 1]
+copy_common:
+ dec dicPos
+ ; cmp LOC rep0, 1
+ ; je rep0Label
+
+ ; t0_R - src_lim
+ ; r1 - dest_lim - 1
+ ; cnt_R - (-cnt)
+
+ IsMatchBranch_Pre
+ inc cnt_R
+ jz copy_end
+MY_ALIGN_16
+@@:
+ mov byte ptr[cnt_R * 1 + dicPos], sym_L
+ movzx sym, byte ptr[cnt_R * 1 + t0_R]
+ inc cnt_R
+ jnz @b
+
+copy_end:
+lz_end_match:
+ mov byte ptr[dicPos], sym_L
+ inc dicPos
+
+ ; IsMatchBranch_Pre
+ CheckLimits
+lz_end:
+ IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
+
+
+
+; ---------- LITERAL MATCHED ----------
+
+ LIT_PROBS LOC lpMask
+
+ ; matchByte = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
+ mov x1, LOC rep0
+ ; mov dic, LOC dic_Spec
+ mov LOC dicPos_Spec, dicPos
+
+ ; state -= (state < 10) ? 3 : 6;
+ lea t0, [state_R - 6 * PMULT]
+ sub state, 3 * PMULT
+ cmp state, 7 * PMULT
+ cmovae state, t0
+
+ sub dicPos, dic
+ sub dicPos, r1
+ jae @f
+ add dicPos, LOC dicBufSize
+@@:
+ comment ~
+ xor t0, t0
+ sub dicPos, r1
+ cmovb t0_R, LOC dicBufSize
+ ~
+
+ movzx match, byte ptr[dic + dicPos * 1]
+
+ ifdef _LZMA_SIZE_OPT
+
+ mov offs, 256 * PMULT
+ shl match, (PSHIFT + 1)
+ mov bit, match
+ mov sym, 1
+MY_ALIGN_16
+litm_loop:
+ LITM
+ cmp sym, 256
+ jb litm_loop
+ sub sym, 256
+
+ else
+
+ LITM_0
+ LITM
+ LITM
+ LITM
+ LITM
+ LITM
+ LITM
+ LITM_2
+
+ endif
+
+ mov probs, LOC probs_Spec
+ IsMatchBranch_Pre
+ ; mov dic, LOC dic_Spec
+ mov dicPos, LOC dicPos_Spec
+ mov byte ptr[dicPos], sym_L
+ inc dicPos
+
+ CheckLimits
+lit_matched_end:
+ IF_BIT_1_NOUP probs_state_R, pbPos_R, IsMatch, IsMatch_label
+ ; IsMatchBranch
+ mov lpMask_reg, LOC lpMask
+ sub state, 3 * PMULT
+ jmp lit_start_2
+
+
+
+; ---------- REP 0 LITERAL ----------
+MY_ALIGN_32
+IsRep0Short_label:
+ UPDATE_0 probs_state_R, pbPos_R, IsRep0Long
+
+ ; dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
+ mov dic, LOC dic_Spec
+ mov t0_R, dicPos
+ mov probBranch, LOC rep0
+ sub t0_R, dic
+
+ sub probs, RepLenCoder * PMULT
+
+ ; state = state < kNumLitStates ? 9 : 11;
+ or state, 1 * PMULT
+
+ ; the caller doesn't allow (dicPos >= limit) case for REP_SHORT
+ ; so we don't need the following (dicPos == limit) check here:
+ ; cmp dicPos, LOC limit
+ ; jae fin_dicPos_LIMIT_REP_SHORT
+
+ inc processedPos
+
+ IsMatchBranch_Pre
+
+; xor sym, sym
+; sub t0_R, probBranch_R
+; cmovb sym_R, LOC dicBufSize
+; add t0_R, sym_R
+ sub t0_R, probBranch_R
+ jae @f
+ add t0_R, LOC dicBufSize
+@@:
+ movzx sym, byte ptr[dic + t0_R * 1]
+ jmp lz_end_match
+
+
+MY_ALIGN_32
+IsRep_label:
+ UPDATE_1 probs_state_R, 0, IsRep
+
+ ; The (checkDicSize == 0 && processedPos == 0) case was checked before in LzmaDec.c with kBadRepCode.
+ ; So we don't check it here.
+
+ ; mov t0, processedPos
+ ; or t0, LOC checkDicSize
+ ; jz fin_ERROR_2
+
+ ; state = state < kNumLitStates ? 8 : 11;
+ cmp state, kNumLitStates * PMULT
+ mov state, 8 * PMULT
+ mov probBranch, 11 * PMULT
+ cmovae state, probBranch
+
+ ; prob = probs + RepLenCoder;
+ add probs, RepLenCoder * PMULT
+
+ IF_BIT_1 probs_state_R, 0, IsRepG0, IsRepG0_label
+ IF_BIT_0_NOUP probs_state_R, pbPos_R, IsRep0Long, IsRep0Short_label
+ UPDATE_1 probs_state_R, pbPos_R, IsRep0Long
+ jmp len_decode
+
+MY_ALIGN_32
+IsRepG0_label:
+ UPDATE_1 probs_state_R, 0, IsRepG0
+ mov dist2, LOC rep0
+ mov dist, LOC rep1
+ mov LOC rep1, dist2
+
+ IF_BIT_1 probs_state_R, 0, IsRepG1, IsRepG1_label
+ mov LOC rep0, dist
+ jmp len_decode
+
+; MY_ALIGN_32
+IsRepG1_label:
+ UPDATE_1 probs_state_R, 0, IsRepG1
+ mov dist2, LOC rep2
+ mov LOC rep2, dist
+
+ IF_BIT_1 probs_state_R, 0, IsRepG2, IsRepG2_label
+ mov LOC rep0, dist2
+ jmp len_decode
+
+; MY_ALIGN_32
+IsRepG2_label:
+ UPDATE_1 probs_state_R, 0, IsRepG2
+ mov dist, LOC rep3
+ mov LOC rep3, dist2
+ mov LOC rep0, dist
+ jmp len_decode
+
+
+
+; ---------- SPEC SHORT DISTANCE ----------
+
+MY_ALIGN_32
+short_dist:
+ sub x1, 32 + 1
+ jbe decode_dist_end
+ or sym, 2
+ shl sym, x1_L
+ lea sym_R, [probs + sym_R * PMULT + SpecPos * PMULT + 1 * PMULT]
+ mov sym2, PMULT ; step
+MY_ALIGN_32
+spec_loop:
+ REV_1_VAR x2
+ dec x1
+ jnz spec_loop
+
+ mov probs, LOC probs_Spec
+ sub sym, sym2
+ sub sym, SpecPos * PMULT
+ sub sym_R, probs
+ shr sym, PSHIFT
+
+ jmp decode_dist_end
+
+
+; ---------- COPY MATCH CROSS ----------
+copy_match_cross:
+ ; t0_R - src pos
+ ; r1 - len to dicBufSize
+ ; cnt_R - total copy len
+
+ mov t1_R, t0_R ; srcPos
+ mov t0_R, dic
+ mov r1, LOC dicBufSize ;
+ neg cnt_R
+@@:
+ movzx sym, byte ptr[t1_R * 1 + t0_R]
+ inc t1_R
+ mov byte ptr[cnt_R * 1 + dicPos], sym_L
+ inc cnt_R
+ cmp t1_R, r1
+ jne @b
+
+ movzx sym, byte ptr[t0_R]
+ sub t0_R, cnt_R
+ jmp copy_common
+
+
+
+
+; fin_dicPos_LIMIT_REP_SHORT:
+ ; mov sym, 1
+
+fin_dicPos_LIMIT:
+ mov LOC remainLen, sym
+ jmp fin_OK
+ ; For more strict mode we can stop decoding with error
+ ; mov sym, 1
+ ; jmp fin
+
+
+fin_ERROR_MATCH_DIST:
+
+ ; rep3 = rep2;
+ ; rep2 = rep1;
+ ; rep1 = rep0;
+ ; rep0 = distance + 1;
+
+ add len_temp, kMatchSpecLen_Error_Data
+ mov LOC remainLen, len_temp
+
+ mov LOC rep0, sym
+ mov LOC rep1, t1
+ mov LOC rep2, x1
+ mov LOC rep3, x2
+
+ ; state = (state < kNumStates + kNumLitStates) ? kNumLitStates : kNumLitStates + 3;
+ cmp state, (kNumStates + kNumLitStates) * PMULT
+ mov state, kNumLitStates * PMULT
+ mov t0, (kNumLitStates + 3) * PMULT
+ cmovae state, t0
+
+ ; jmp fin_OK
+ mov sym, 1
+ jmp fin
+
+end_of_payload:
+ inc sym
+ jnz fin_ERROR_MATCH_DIST
+
+ mov LOC remainLen, kMatchSpecLenStart
+ sub state, kNumStates * PMULT
+
+fin_OK:
+ xor sym, sym
+
+fin:
+ NORM
+
+ mov r1, LOC lzmaPtr
+
+ sub dicPos, LOC dic_Spec
+ mov GLOB dicPos_Spec, dicPos
+ mov GLOB buf_Spec, buf
+ mov GLOB range_Spec, range
+ mov GLOB code_Spec, cod
+ shr state, PSHIFT
+ mov GLOB state_Spec, state
+ mov GLOB processedPos_Spec, processedPos
+
+ RESTORE_VAR(remainLen)
+ RESTORE_VAR(rep0)
+ RESTORE_VAR(rep1)
+ RESTORE_VAR(rep2)
+ RESTORE_VAR(rep3)
+
+ mov x0, sym
+
+ mov RSP, LOC Old_RSP
+
+MY_POP_PRESERVED_ABI_REGS
+MY_ENDP
+
+_TEXT$LZMADECOPT ENDS
+
+end
diff --git a/Asm/x86/Sha1Opt.asm b/Asm/x86/Sha1Opt.asm
new file mode 100644
index 0000000..3495fd1
--- /dev/null
+++ b/Asm/x86/Sha1Opt.asm
@@ -0,0 +1,263 @@
+; Sha1Opt.asm -- SHA-1 optimized code for SHA-1 x86 hardware instructions
+; 2021-03-10 : Igor Pavlov : Public domain
+
+include 7zAsm.asm
+
+MY_ASM_START
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CONST SEGMENT
+
+align 16
+Reverse_Endian_Mask db 15,14,13,12, 11,10,9,8, 7,6,5,4, 3,2,1,0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CONST ENDS
+
+; _TEXT$SHA1OPT SEGMENT 'CODE'
+
+ifndef x64
+ .686
+ .xmm
+endif
+
+ifdef x64
+ rNum equ REG_ABI_PARAM_2
+ if (IS_LINUX eq 0)
+ LOCAL_SIZE equ (16 * 2)
+ endif
+else
+ rNum equ r0
+ LOCAL_SIZE equ (16 * 1)
+endif
+
+rState equ REG_ABI_PARAM_0
+rData equ REG_ABI_PARAM_1
+
+
+MY_sha1rnds4 macro a1, a2, imm
+ db 0fH, 03aH, 0ccH, (0c0H + a1 * 8 + a2), imm
+endm
+
+MY_SHA_INSTR macro cmd, a1, a2
+ db 0fH, 038H, cmd, (0c0H + a1 * 8 + a2)
+endm
+
+cmd_sha1nexte equ 0c8H
+cmd_sha1msg1 equ 0c9H
+cmd_sha1msg2 equ 0caH
+
+MY_sha1nexte macro a1, a2
+ MY_SHA_INSTR cmd_sha1nexte, a1, a2
+endm
+
+MY_sha1msg1 macro a1, a2
+ MY_SHA_INSTR cmd_sha1msg1, a1, a2
+endm
+
+MY_sha1msg2 macro a1, a2
+ MY_SHA_INSTR cmd_sha1msg2, a1, a2
+endm
+
+MY_PROLOG macro
+ ifdef x64
+ if (IS_LINUX eq 0)
+ movdqa [r4 + 8], xmm6
+ movdqa [r4 + 8 + 16], xmm7
+ sub r4, LOCAL_SIZE + 8
+ movdqa [r4 ], xmm8
+ movdqa [r4 + 16], xmm9
+ endif
+ else ; x86
+ if (IS_CDECL gt 0)
+ mov rState, [r4 + REG_SIZE * 1]
+ mov rData, [r4 + REG_SIZE * 2]
+ mov rNum, [r4 + REG_SIZE * 3]
+ else ; fastcall
+ mov rNum, [r4 + REG_SIZE * 1]
+ endif
+ push r5
+ mov r5, r4
+ and r4, -16
+ sub r4, LOCAL_SIZE
+ endif
+endm
+
+MY_EPILOG macro
+ ifdef x64
+ if (IS_LINUX eq 0)
+ movdqa xmm8, [r4]
+ movdqa xmm9, [r4 + 16]
+ add r4, LOCAL_SIZE + 8
+ movdqa xmm6, [r4 + 8]
+ movdqa xmm7, [r4 + 8 + 16]
+ endif
+ else ; x86
+ mov r4, r5
+ pop r5
+ endif
+ MY_ENDP
+endm
+
+
+e0_N equ 0
+e1_N equ 1
+abcd_N equ 2
+e0_save_N equ 3
+w_regs equ 4
+
+e0 equ @CatStr(xmm, %e0_N)
+e1 equ @CatStr(xmm, %e1_N)
+abcd equ @CatStr(xmm, %abcd_N)
+e0_save equ @CatStr(xmm, %e0_save_N)
+
+
+ifdef x64
+ abcd_save equ xmm8
+ mask2 equ xmm9
+else
+ abcd_save equ [r4]
+ mask2 equ e1
+endif
+
+LOAD_MASK macro
+ movdqa mask2, XMMWORD PTR Reverse_Endian_Mask
+endm
+
+LOAD_W macro k:req
+ movdqu @CatStr(xmm, %(w_regs + k)), [rData + (16 * (k))]
+ pshufb @CatStr(xmm, %(w_regs + k)), mask2
+endm
+
+
+; pre2 can be 2 or 3 (recommended)
+pre2 equ 3
+pre1 equ (pre2 + 1)
+
+NUM_ROUNDS4 equ 20
+
+RND4 macro k
+ movdqa @CatStr(xmm, %(e0_N + ((k + 1) mod 2))), abcd
+ MY_sha1rnds4 abcd_N, (e0_N + (k mod 2)), k / 5
+
+ nextM = (w_regs + ((k + 1) mod 4))
+
+ if (k EQ NUM_ROUNDS4 - 1)
+ nextM = e0_save_N
+ endif
+
+ MY_sha1nexte (e0_N + ((k + 1) mod 2)), nextM
+
+ if (k GE (4 - pre2)) AND (k LT (NUM_ROUNDS4 - pre2))
+ pxor @CatStr(xmm, %(w_regs + ((k + pre2) mod 4))), @CatStr(xmm, %(w_regs + ((k + pre2 - 2) mod 4)))
+ endif
+
+ if (k GE (4 - pre1)) AND (k LT (NUM_ROUNDS4 - pre1))
+ MY_sha1msg1 (w_regs + ((k + pre1) mod 4)), (w_regs + ((k + pre1 - 3) mod 4))
+ endif
+
+ if (k GE (4 - pre2)) AND (k LT (NUM_ROUNDS4 - pre2))
+ MY_sha1msg2 (w_regs + ((k + pre2) mod 4)), (w_regs + ((k + pre2 - 1) mod 4))
+ endif
+endm
+
+
+REVERSE_STATE macro
+ ; abcd ; dcba
+ ; e0 ; 000e
+ pshufd abcd, abcd, 01bH ; abcd
+ pshufd e0, e0, 01bH ; e000
+endm
+
+
+
+
+
+MY_PROC Sha1_UpdateBlocks_HW, 3
+ MY_PROLOG
+
+ cmp rNum, 0
+ je end_c
+
+ movdqu abcd, [rState] ; dcba
+ movd e0, dword ptr [rState + 16] ; 000e
+
+ REVERSE_STATE
+
+ ifdef x64
+ LOAD_MASK
+ endif
+
+ align 16
+ nextBlock:
+ movdqa abcd_save, abcd
+ movdqa e0_save, e0
+
+ ifndef x64
+ LOAD_MASK
+ endif
+
+ LOAD_W 0
+ LOAD_W 1
+ LOAD_W 2
+ LOAD_W 3
+
+ paddd e0, @CatStr(xmm, %(w_regs))
+ k = 0
+ rept NUM_ROUNDS4
+ RND4 k
+ k = k + 1
+ endm
+
+ paddd abcd, abcd_save
+
+
+ add rData, 64
+ sub rNum, 1
+ jnz nextBlock
+
+ REVERSE_STATE
+
+ movdqu [rState], abcd
+ movd dword ptr [rState + 16], e0
+
+ end_c:
+MY_EPILOG
+
+; _TEXT$SHA1OPT ENDS
+
+end
diff --git a/Asm/x86/Sha256Opt.asm b/Asm/x86/Sha256Opt.asm
new file mode 100644
index 0000000..3e9f6ed
--- /dev/null
+++ b/Asm/x86/Sha256Opt.asm
@@ -0,0 +1,275 @@
+; Sha256Opt.asm -- SHA-256 optimized code for SHA-256 x86 hardware instructions
+; 2022-04-17 : Igor Pavlov : Public domain
+
+include 7zAsm.asm
+
+MY_ASM_START
+
+; .data
+; public K
+
+; we can use external SHA256_K_ARRAY defined in Sha256.c
+; but we must guarantee that SHA256_K_ARRAY is aligned for 16-bytes
+
+COMMENT @
+ifdef x64
+K_CONST equ SHA256_K_ARRAY
+else
+K_CONST equ _SHA256_K_ARRAY
+endif
+EXTRN K_CONST:xmmword
+@
+
+CONST SEGMENT
+
+align 16
+Reverse_Endian_Mask db 3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12
+
+; COMMENT @
+align 16
+K_CONST \
+DD 0428a2f98H, 071374491H, 0b5c0fbcfH, 0e9b5dba5H
+DD 03956c25bH, 059f111f1H, 0923f82a4H, 0ab1c5ed5H
+DD 0d807aa98H, 012835b01H, 0243185beH, 0550c7dc3H
+DD 072be5d74H, 080deb1feH, 09bdc06a7H, 0c19bf174H
+DD 0e49b69c1H, 0efbe4786H, 00fc19dc6H, 0240ca1ccH
+DD 02de92c6fH, 04a7484aaH, 05cb0a9dcH, 076f988daH
+DD 0983e5152H, 0a831c66dH, 0b00327c8H, 0bf597fc7H
+DD 0c6e00bf3H, 0d5a79147H, 006ca6351H, 014292967H
+DD 027b70a85H, 02e1b2138H, 04d2c6dfcH, 053380d13H
+DD 0650a7354H, 0766a0abbH, 081c2c92eH, 092722c85H
+DD 0a2bfe8a1H, 0a81a664bH, 0c24b8b70H, 0c76c51a3H
+DD 0d192e819H, 0d6990624H, 0f40e3585H, 0106aa070H
+DD 019a4c116H, 01e376c08H, 02748774cH, 034b0bcb5H
+DD 0391c0cb3H, 04ed8aa4aH, 05b9cca4fH, 0682e6ff3H
+DD 0748f82eeH, 078a5636fH, 084c87814H, 08cc70208H
+DD 090befffaH, 0a4506cebH, 0bef9a3f7H, 0c67178f2H
+; @
+
+CONST ENDS
+
+; _TEXT$SHA256OPT SEGMENT 'CODE'
+
+ifndef x64
+ .686
+ .xmm
+endif
+
+; jwasm-based assemblers for linux and linker from new versions of binutils
+; can generate incorrect code for load [ARRAY + offset] instructions.
+; 22.00: we load K_CONST offset to (rTable) register to avoid jwasm+binutils problem
+ rTable equ r0
+ ; rTable equ K_CONST
+
+ifdef x64
+ rNum equ REG_ABI_PARAM_2
+ if (IS_LINUX eq 0)
+ LOCAL_SIZE equ (16 * 2)
+ endif
+else
+ rNum equ r3
+ LOCAL_SIZE equ (16 * 1)
+endif
+
+rState equ REG_ABI_PARAM_0
+rData equ REG_ABI_PARAM_1
+
+
+
+
+
+
+MY_SHA_INSTR macro cmd, a1, a2
+ db 0fH, 038H, cmd, (0c0H + a1 * 8 + a2)
+endm
+
+cmd_sha256rnds2 equ 0cbH
+cmd_sha256msg1 equ 0ccH
+cmd_sha256msg2 equ 0cdH
+
+MY_sha256rnds2 macro a1, a2
+ MY_SHA_INSTR cmd_sha256rnds2, a1, a2
+endm
+
+MY_sha256msg1 macro a1, a2
+ MY_SHA_INSTR cmd_sha256msg1, a1, a2
+endm
+
+MY_sha256msg2 macro a1, a2
+ MY_SHA_INSTR cmd_sha256msg2, a1, a2
+endm
+
+MY_PROLOG macro
+ ifdef x64
+ if (IS_LINUX eq 0)
+ movdqa [r4 + 8], xmm6
+ movdqa [r4 + 8 + 16], xmm7
+ sub r4, LOCAL_SIZE + 8
+ movdqa [r4 ], xmm8
+ movdqa [r4 + 16], xmm9
+ endif
+ else ; x86
+ push r3
+ push r5
+ mov r5, r4
+ NUM_PUSH_REGS equ 2
+ PARAM_OFFSET equ (REG_SIZE * (1 + NUM_PUSH_REGS))
+ if (IS_CDECL gt 0)
+ mov rState, [r4 + PARAM_OFFSET]
+ mov rData, [r4 + PARAM_OFFSET + REG_SIZE * 1]
+ mov rNum, [r4 + PARAM_OFFSET + REG_SIZE * 2]
+ else ; fastcall
+ mov rNum, [r4 + PARAM_OFFSET]
+ endif
+ and r4, -16
+ sub r4, LOCAL_SIZE
+ endif
+endm
+
+MY_EPILOG macro
+ ifdef x64
+ if (IS_LINUX eq 0)
+ movdqa xmm8, [r4]
+ movdqa xmm9, [r4 + 16]
+ add r4, LOCAL_SIZE + 8
+ movdqa xmm6, [r4 + 8]
+ movdqa xmm7, [r4 + 8 + 16]
+ endif
+ else ; x86
+ mov r4, r5
+ pop r5
+ pop r3
+ endif
+ MY_ENDP
+endm
+
+
+msg equ xmm0
+tmp equ xmm0
+state0_N equ 2
+state1_N equ 3
+w_regs equ 4
+
+
+state1_save equ xmm1
+state0 equ @CatStr(xmm, %state0_N)
+state1 equ @CatStr(xmm, %state1_N)
+
+
+ifdef x64
+ state0_save equ xmm8
+ mask2 equ xmm9
+else
+ state0_save equ [r4]
+ mask2 equ xmm0
+endif
+
+LOAD_MASK macro
+ movdqa mask2, XMMWORD PTR Reverse_Endian_Mask
+endm
+
+LOAD_W macro k:req
+ movdqu @CatStr(xmm, %(w_regs + k)), [rData + (16 * (k))]
+ pshufb @CatStr(xmm, %(w_regs + k)), mask2
+endm
+
+
+; pre1 <= 4 && pre2 >= 1 && pre1 > pre2 && (pre1 - pre2) <= 1
+pre1 equ 3
+pre2 equ 2
+
+
+
+RND4 macro k
+ movdqa msg, xmmword ptr [rTable + (k) * 16]
+ paddd msg, @CatStr(xmm, %(w_regs + ((k + 0) mod 4)))
+ MY_sha256rnds2 state0_N, state1_N
+ pshufd msg, msg, 0eH
+
+ if (k GE (4 - pre1)) AND (k LT (16 - pre1))
+ ; w4[0] = msg1(w4[-4], w4[-3])
+ MY_sha256msg1 (w_regs + ((k + pre1) mod 4)), (w_regs + ((k + pre1 - 3) mod 4))
+ endif
+
+ MY_sha256rnds2 state1_N, state0_N
+
+ if (k GE (4 - pre2)) AND (k LT (16 - pre2))
+ movdqa tmp, @CatStr(xmm, %(w_regs + ((k + pre2 - 1) mod 4)))
+ palignr tmp, @CatStr(xmm, %(w_regs + ((k + pre2 - 2) mod 4))), 4
+ paddd @CatStr(xmm, %(w_regs + ((k + pre2) mod 4))), tmp
+ ; w4[0] = msg2(w4[0], w4[-1])
+ MY_sha256msg2 %(w_regs + ((k + pre2) mod 4)), %(w_regs + ((k + pre2 - 1) mod 4))
+ endif
+endm
+
+
+
+
+
+REVERSE_STATE macro
+ ; state0 ; dcba
+ ; state1 ; hgfe
+ pshufd tmp, state0, 01bH ; abcd
+ pshufd state0, state1, 01bH ; efgh
+ movdqa state1, state0 ; efgh
+ punpcklqdq state0, tmp ; cdgh
+ punpckhqdq state1, tmp ; abef
+endm
+
+
+MY_PROC Sha256_UpdateBlocks_HW, 3
+ MY_PROLOG
+
+ lea rTable, [K_CONST]
+
+ cmp rNum, 0
+ je end_c
+
+ movdqu state0, [rState] ; dcba
+ movdqu state1, [rState + 16] ; hgfe
+
+ REVERSE_STATE
+
+ ifdef x64
+ LOAD_MASK
+ endif
+
+ align 16
+ nextBlock:
+ movdqa state0_save, state0
+ movdqa state1_save, state1
+
+ ifndef x64
+ LOAD_MASK
+ endif
+
+ LOAD_W 0
+ LOAD_W 1
+ LOAD_W 2
+ LOAD_W 3
+
+
+ k = 0
+ rept 16
+ RND4 k
+ k = k + 1
+ endm
+
+ paddd state0, state0_save
+ paddd state1, state1_save
+
+ add rData, 64
+ sub rNum, 1
+ jnz nextBlock
+
+ REVERSE_STATE
+
+ movdqu [rState], state0
+ movdqu [rState + 16], state1
+
+ end_c:
+MY_EPILOG
+
+; _TEXT$SHA256OPT ENDS
+
+end
diff --git a/Asm/x86/XzCrc64Opt.asm b/Asm/x86/XzCrc64Opt.asm
index 3e6d490..ad22cc2 100644
--- a/Asm/x86/XzCrc64Opt.asm
+++ b/Asm/x86/XzCrc64Opt.asm
@@ -1,205 +1,239 @@
-; XzCrc64Opt.asm -- CRC64 calculation : optimized version
-; 2011-06-28 : Igor Pavlov : Public domain
-
-include 7zAsm.asm
-
-MY_ASM_START
-
-ifdef x64
-
- rD equ r9
- rN equ r10
-
- num_VAR equ r8
- table_VAR equ r9
-
- SRCDAT equ rN + rD
-
-CRC_XOR macro dest:req, src:req, t:req
- xor dest, QWORD PTR [r5 + src * 8 + 0800h * t]
-endm
-
-CRC1b macro
- movzx x6, BYTE PTR [rD]
- inc rD
- movzx x3, x0_L
- xor x6, x3
- shr r0, 8
- CRC_XOR r0, r6, 0
- dec rN
-endm
-
-MY_PROLOG macro crc_end:req
- MY_PUSH_4_REGS
-
- mov r0, r1
- mov rN, num_VAR
- mov r5, table_VAR
- mov rD, r2
- test rN, rN
- jz crc_end
- @@:
- test rD, 3
- jz @F
- CRC1b
- jnz @B
- @@:
- cmp rN, 8
- jb crc_end
- add rN, rD
- mov num_VAR, rN
- sub rN, 4
- and rN, NOT 3
- sub rD, rN
- mov x1, [SRCDAT]
- xor r0, r1
- add rN, 4
-endm
-
-MY_EPILOG macro crc_end:req
- sub rN, 4
- mov x1, [SRCDAT]
- xor r0, r1
- mov rD, rN
- mov rN, num_VAR
- sub rN, rD
- crc_end:
- test rN, rN
- jz @F
- CRC1b
- jmp crc_end
- @@:
- MY_POP_4_REGS
-endm
-
-MY_PROC XzCrc64UpdateT4, 4
- MY_PROLOG crc_end_4
- align 16
- main_loop_4:
- mov x1, [SRCDAT]
- movzx x2, x0_L
- movzx x3, x0_H
- shr r0, 16
- movzx x6, x0_L
- movzx x7, x0_H
- shr r0, 16
- CRC_XOR r1, r2, 3
- CRC_XOR r0, r3, 2
- CRC_XOR r1, r6, 1
- CRC_XOR r0, r7, 0
- xor r0, r1
-
- add rD, 4
- jnz main_loop_4
-
- MY_EPILOG crc_end_4
-MY_ENDP
-
-else
-
- rD equ r1
- rN equ r7
-
- crc_val equ (REG_SIZE * 5)
- crc_table equ (8 + crc_val)
- table_VAR equ [r4 + crc_table]
- num_VAR equ table_VAR
-
-
- SRCDAT equ rN + rD
-
-CRC macro op0:req, op1:req, dest0:req, dest1:req, src:req, t:req
- op0 dest0, DWORD PTR [r5 + src * 8 + 0800h * t]
- op1 dest1, DWORD PTR [r5 + src * 8 + 0800h * t + 4]
-endm
-
-CRC_XOR macro dest0:req, dest1:req, src:req, t:req
- CRC xor, xor, dest0, dest1, src, t
-endm
-
-
-CRC1b macro
- movzx x6, BYTE PTR [rD]
- inc rD
- movzx x3, x0_L
- xor x6, x3
- shrd r0, r2, 8
- shr r2, 8
- CRC_XOR r0, r2, r6, 0
- dec rN
-endm
-
-MY_PROLOG macro crc_end:req
- MY_PUSH_4_REGS
-
- mov rN, r2
-
- mov x0, [r4 + crc_val]
- mov x2, [r4 + crc_val + 4]
- mov r5, table_VAR
- test rN, rN
- jz crc_end
- @@:
- test rD, 3
- jz @F
- CRC1b
- jnz @B
- @@:
- cmp rN, 8
- jb crc_end
- add rN, rD
-
- mov num_VAR, rN
-
- sub rN, 4
- and rN, NOT 3
- sub rD, rN
- xor r0, [SRCDAT]
- add rN, 4
-endm
-
-MY_EPILOG macro crc_end:req
- sub rN, 4
- xor r0, [SRCDAT]
-
- mov rD, rN
- mov rN, num_VAR
- sub rN, rD
- crc_end:
- test rN, rN
- jz @F
- CRC1b
- jmp crc_end
- @@:
- MY_POP_4_REGS
-endm
-
-MY_PROC XzCrc64UpdateT4, 5
- MY_PROLOG crc_end_4
- movzx x6, x0_L
- align 16
- main_loop_4:
- mov r3, [SRCDAT]
- xor r3, r2
-
- CRC xor, mov, r3, r2, r6, 3
- movzx x6, x0_H
- shr r0, 16
- CRC_XOR r3, r2, r6, 2
-
- movzx x6, x0_L
- movzx x0, x0_H
- CRC_XOR r3, r2, r6, 1
- CRC_XOR r3, r2, r0, 0
- movzx x6, x3_L
- mov r0, r3
-
- add rD, 4
- jnz main_loop_4
-
- MY_EPILOG crc_end_4
-MY_ENDP
-
-endif
-
-end
+; XzCrc64Opt.asm -- CRC64 calculation : optimized version
+; 2021-02-06 : Igor Pavlov : Public domain
+
+include 7zAsm.asm
+
+MY_ASM_START
+
+ifdef x64
+
+rD equ r9
+rN equ r10
+rT equ r5
+num_VAR equ r8
+
+SRCDAT4 equ dword ptr [rD + rN * 1]
+
+CRC_XOR macro dest:req, src:req, t:req
+ xor dest, QWORD PTR [rT + src * 8 + 0800h * t]
+endm
+
+CRC1b macro
+ movzx x6, BYTE PTR [rD]
+ inc rD
+ movzx x3, x0_L
+ xor x6, x3
+ shr r0, 8
+ CRC_XOR r0, r6, 0
+ dec rN
+endm
+
+MY_PROLOG macro crc_end:req
+ ifdef ABI_LINUX
+ MY_PUSH_2_REGS
+ else
+ MY_PUSH_4_REGS
+ endif
+ mov r0, REG_ABI_PARAM_0
+ mov rN, REG_ABI_PARAM_2
+ mov rT, REG_ABI_PARAM_3
+ mov rD, REG_ABI_PARAM_1
+ test rN, rN
+ jz crc_end
+ @@:
+ test rD, 3
+ jz @F
+ CRC1b
+ jnz @B
+ @@:
+ cmp rN, 8
+ jb crc_end
+ add rN, rD
+ mov num_VAR, rN
+ sub rN, 4
+ and rN, NOT 3
+ sub rD, rN
+ mov x1, SRCDAT4
+ xor r0, r1
+ add rN, 4
+endm
+
+MY_EPILOG macro crc_end:req
+ sub rN, 4
+ mov x1, SRCDAT4
+ xor r0, r1
+ mov rD, rN
+ mov rN, num_VAR
+ sub rN, rD
+ crc_end:
+ test rN, rN
+ jz @F
+ CRC1b
+ jmp crc_end
+ @@:
+ ifdef ABI_LINUX
+ MY_POP_2_REGS
+ else
+ MY_POP_4_REGS
+ endif
+endm
+
+MY_PROC XzCrc64UpdateT4, 4
+ MY_PROLOG crc_end_4
+ align 16
+ main_loop_4:
+ mov x1, SRCDAT4
+ movzx x2, x0_L
+ movzx x3, x0_H
+ shr r0, 16
+ movzx x6, x0_L
+ movzx x7, x0_H
+ shr r0, 16
+ CRC_XOR r1, r2, 3
+ CRC_XOR r0, r3, 2
+ CRC_XOR r1, r6, 1
+ CRC_XOR r0, r7, 0
+ xor r0, r1
+
+ add rD, 4
+ jnz main_loop_4
+
+ MY_EPILOG crc_end_4
+MY_ENDP
+
+else
+; x86 (32-bit)
+
+rD equ r1
+rN equ r7
+rT equ r5
+
+crc_OFFS equ (REG_SIZE * 5)
+
+if (IS_CDECL gt 0) or (IS_LINUX gt 0)
+ ; cdecl or (GNU fastcall) stack:
+ ; (UInt32 *) table
+ ; size_t size
+ ; void * data
+ ; (UInt64) crc
+ ; ret-ip <-(r4)
+ data_OFFS equ (8 + crc_OFFS)
+ size_OFFS equ (REG_SIZE + data_OFFS)
+ table_OFFS equ (REG_SIZE + size_OFFS)
+ num_VAR equ [r4 + size_OFFS]
+ table_VAR equ [r4 + table_OFFS]
+else
+ ; Windows fastcall:
+ ; r1 = data, r2 = size
+ ; stack:
+ ; (UInt32 *) table
+ ; (UInt64) crc
+ ; ret-ip <-(r4)
+ table_OFFS equ (8 + crc_OFFS)
+ table_VAR equ [r4 + table_OFFS]
+ num_VAR equ table_VAR
+endif
+
+SRCDAT4 equ dword ptr [rD + rN * 1]
+
+CRC macro op0:req, op1:req, dest0:req, dest1:req, src:req, t:req
+ op0 dest0, DWORD PTR [rT + src * 8 + 0800h * t]
+ op1 dest1, DWORD PTR [rT + src * 8 + 0800h * t + 4]
+endm
+
+CRC_XOR macro dest0:req, dest1:req, src:req, t:req
+ CRC xor, xor, dest0, dest1, src, t
+endm
+
+
+CRC1b macro
+ movzx x6, BYTE PTR [rD]
+ inc rD
+ movzx x3, x0_L
+ xor x6, x3
+ shrd r0, r2, 8
+ shr r2, 8
+ CRC_XOR r0, r2, r6, 0
+ dec rN
+endm
+
+MY_PROLOG macro crc_end:req
+ MY_PUSH_4_REGS
+
+ if (IS_CDECL gt 0) or (IS_LINUX gt 0)
+ proc_numParams = proc_numParams + 2 ; for ABI_LINUX
+ mov rN, [r4 + size_OFFS]
+ mov rD, [r4 + data_OFFS]
+ else
+ mov rN, r2
+ endif
+
+ mov x0, [r4 + crc_OFFS]
+ mov x2, [r4 + crc_OFFS + 4]
+ mov rT, table_VAR
+ test rN, rN
+ jz crc_end
+ @@:
+ test rD, 3
+ jz @F
+ CRC1b
+ jnz @B
+ @@:
+ cmp rN, 8
+ jb crc_end
+ add rN, rD
+
+ mov num_VAR, rN
+
+ sub rN, 4
+ and rN, NOT 3
+ sub rD, rN
+ xor r0, SRCDAT4
+ add rN, 4
+endm
+
+MY_EPILOG macro crc_end:req
+ sub rN, 4
+ xor r0, SRCDAT4
+
+ mov rD, rN
+ mov rN, num_VAR
+ sub rN, rD
+ crc_end:
+ test rN, rN
+ jz @F
+ CRC1b
+ jmp crc_end
+ @@:
+ MY_POP_4_REGS
+endm
+
+MY_PROC XzCrc64UpdateT4, 5
+ MY_PROLOG crc_end_4
+ movzx x6, x0_L
+ align 16
+ main_loop_4:
+ mov r3, SRCDAT4
+ xor r3, r2
+
+ CRC xor, mov, r3, r2, r6, 3
+ movzx x6, x0_H
+ shr r0, 16
+ CRC_XOR r3, r2, r6, 2
+
+ movzx x6, x0_L
+ movzx x0, x0_H
+ CRC_XOR r3, r2, r6, 1
+ CRC_XOR r3, r2, r0, 0
+ movzx x6, x3_L
+ mov r0, r3
+
+ add rD, 4
+ jnz main_loop_4
+
+ MY_EPILOG crc_end_4
+MY_ENDP
+
+endif ; ! x64
+
+end
diff --git a/C/7z.h b/C/7z.h
index 82813c2..9e27c01 100644
--- a/C/7z.h
+++ b/C/7z.h
@@ -1,202 +1,204 @@
-/* 7z.h -- 7z interface
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_H
-#define __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;
-} CSzAr;
-
-UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);
-
-SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
- ILookInStream *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,
- ILookInStream *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, ILookInStream *inStream,
- ISzAllocPtr allocMain, ISzAllocPtr allocTemp);
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/7zAlloc.c b/C/7zAlloc.c
index ea32809..2f0659a 100644
--- a/C/7zAlloc.c
+++ b/C/7zAlloc.c
@@ -1,80 +1,89 @@
-/* 7zAlloc.c -- Allocation functions
-2017-04-03 : 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 <windows.h>
-#endif
-
-#include <stdio.h>
-int g_allocCount = 0;
-int g_allocCountTemp = 0;
-
-#endif
-
-void *SzAlloc(ISzAllocPtr p, size_t size)
-{
- UNUSED_VAR(p);
- if (size == 0)
- return 0;
- #ifdef _SZ_ALLOC_DEBUG
- fprintf(stderr, "\nAlloc %10u bytes; count = %10d", (unsigned)size, g_allocCount);
- g_allocCount++;
- #endif
- return malloc(size);
-}
-
-void SzFree(ISzAllocPtr p, void *address)
-{
- UNUSED_VAR(p);
- #ifdef _SZ_ALLOC_DEBUG
- if (address != 0)
- {
- g_allocCount--;
- fprintf(stderr, "\nFree; count = %10d", g_allocCount);
- }
- #endif
- free(address);
-}
-
-void *SzAllocTemp(ISzAllocPtr p, size_t size)
-{
- UNUSED_VAR(p);
- if (size == 0)
- return 0;
- #ifdef _SZ_ALLOC_DEBUG
- fprintf(stderr, "\nAlloc_temp %10u bytes; count = %10d", (unsigned)size, g_allocCountTemp);
- 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 != 0)
- {
- g_allocCountTemp--;
- fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
- }
- #ifdef _WIN32
- HeapFree(GetProcessHeap(), 0, address);
- return;
- #endif
- #endif
- free(address);
-}
+/* 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);
+}
diff --git a/C/7zAlloc.h b/C/7zAlloc.h
index c0f89d7..b2b8b0c 100644
--- a/C/7zAlloc.h
+++ b/C/7zAlloc.h
@@ -1,19 +1,19 @@
-/* 7zAlloc.h -- Allocation functions
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_ALLOC_H
-#define __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
+/* 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
diff --git a/C/7zArcIn.c b/C/7zArcIn.c
index 68cc12f..43fa7c2 100644
--- a/C/7zArcIn.c
+++ b/C/7zArcIn.c
@@ -1,1771 +1,1786 @@
-/* 7zArcIn.c -- 7z Input functions
-2018-12-31 : 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;
-}
-
-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; }
-
-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;
-}
-
-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(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++;
-#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 MY_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)
- {
- 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 MY_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)
-{
- 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 MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAllocPtr alloc)
-{
- Byte allAreDefined;
- Byte *v2;
- 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);
- {
- unsigned numBits = (unsigned)numItems & 7;
- if (numBits != 0)
- v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));
- }
- return SZ_OK;
-}
-
-static MY_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)
- {
- 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;
- 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 = 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 MY_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] = 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;
- 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;
-
- {
- size_t dataSize = 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;
- 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 = 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 = 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 = 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));
- RINOK(ReadPackInfo(p, sd, alloc));
- 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(
- ILookInStream *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;
- 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 *)p != 0
- #else
- p[0] != 0 || p[1] != 0
- #endif
- ; p += 2);
- pos = p - data + 2;
- *offsets++ = (pos >> 1);
- }
- while (--numFiles);
- return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
-}
-
-static MY_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,
- ILookInStream *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);
- 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 digestsValsIndex = 0;
- UInt32 digestIndex;
- Byte allDigestsDefined = 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)
- {
- SZ_READ_BYTE_SD(&ssi.sdCRCs, allDigestsDefined);
- if (allDigestsDefined)
- digestsVals = ssi.sdCRCs.Data;
- else
- {
- size_t numBytes = (ssi.NumSubDigests + 7) >> 3;
- digestsDefs = ssi.sdCRCs.Data;
- digestsVals = digestsDefs + numBytes;
- }
- }
-
- digestIndex = 0;
-
- for (i = 0; i < numFiles; i++, mask >>= 1)
- {
- if (mask == 0)
- {
- 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;
- {
- 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)
- {
- UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
- 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, i))
- {
- p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex];
- crcMask |= mask;
- }
- else if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
- {
- p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
- digestsValsIndex++;
- crcMask |= mask;
- }
-
- folderIndex++;
- }
- else
- {
- UInt64 v;
- RINOK(ReadNumber(&ssi.sdSizes, &v));
- unpackPos += v;
- if (unpackPos < v)
- return SZ_ERROR_ARCHIVE;
- if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))
- {
- p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);
- digestsValsIndex++;
- crcMask |= mask;
- }
- }
- }
-
- if (mask != 0x80)
- {
- 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,
- ILookInStream *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,
- ILookInStream *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 = startArcPos + k7zStartHeaderSize;
-
- if (CrcCalc(header + 12, 20) != GetUi32(header + 8))
- return SZ_ERROR_CRC;
-
- 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 < startArcPos + nextHeaderOffset ||
- (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
- (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
- return SZ_ERROR_INPUT_EOF;
- }
-
- RINOK(LookInStream_SeekTo(inStream, 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);
- 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, ILookInStream *inStream,
- ISzAllocPtr allocMain, ISzAllocPtr allocTemp)
-{
- SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);
- if (res != SZ_OK)
- SzArEx_Free(p, allocMain);
- return res;
-}
-
-
-SRes SzArEx_Extract(
- const CSzArEx *p,
- ILookInStream *inStream,
- UInt32 fileIndex,
- UInt32 *blockIndex,
- Byte **tempBuf,
- size_t *outBufferSize,
- size_t *offset,
- size_t *outSizeProcessed,
- ISzAllocPtr allocMain,
- ISzAllocPtr allocTemp)
-{
- 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)
- {
- UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
- /*
- UInt64 unpackSizeSpec =
- p->UnpackPositions[p->FolderToFile[(size_t)folderIndex + 1]] -
- p->UnpackPositions[p->FolderToFile[folderIndex]];
- */
- 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)
- {
- 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)
-{
- size_t offs = p->FileNameOffsets[fileIndex];
- 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;
- }
-}
-*/
+/* 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;
+ }
+}
+*/
diff --git a/C/7zBuf.c b/C/7zBuf.c
index 438bba6..8865c32 100644
--- a/C/7zBuf.c
+++ b/C/7zBuf.c
@@ -1,36 +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;
-}
+/* 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;
+}
diff --git a/C/7zBuf.h b/C/7zBuf.h
index 5942d6e..c0ba8a7 100644
--- a/C/7zBuf.h
+++ b/C/7zBuf.h
@@ -1,35 +1,35 @@
-/* 7zBuf.h -- Byte Buffer
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_BUF_H
-#define __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
+/* 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
diff --git a/C/7zBuf2.c b/C/7zBuf2.c
index 49b4343..2083474 100644
--- a/C/7zBuf2.c
+++ b/C/7zBuf2.c
@@ -1,52 +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;
-}
+/* 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;
+}
diff --git a/C/7zCrc.c b/C/7zCrc.c
index 40ab759..c995a8b 100644
--- a/C/7zCrc.c
+++ b/C/7zCrc.c
@@ -1,128 +1,340 @@
-/* 7zCrc.c -- CRC32 init
-2017-06-06 : 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
-
- #define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
-
- UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
- UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
-#endif
-
-#ifndef MY_CPU_BE
- UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
- UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
-#endif
-
-typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-CRC_FUNC g_CrcUpdateT4;
-CRC_FUNC g_CrcUpdateT8;
-CRC_FUNC g_CrcUpdate;
-
-UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
-
-UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
-{
- return g_CrcUpdate(v, data, size, g_CrcTable);
-}
-
-UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size)
-{
- return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;
-}
-
-#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-UInt32 MY_FAST_CALL 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;
-}
-
-void MY_FAST_CALL CrcGenerateTable()
-{
- 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++)
- {
- 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;
-
- #else
-
- #ifdef MY_CPU_LE
-
- g_CrcUpdateT4 = CrcUpdateT4;
- g_CrcUpdate = CrcUpdateT4;
-
- #if 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)
- {
- g_CrcUpdateT4 = CrcUpdateT4;
- g_CrcUpdate = CrcUpdateT4;
- #if CRC_NUM_TABLES >= 8
- g_CrcUpdateT8 = CrcUpdateT8;
- g_CrcUpdate = CrcUpdateT8;
- #endif
- }
- else if (p[0] != 1 || p[1] != 2)
- g_CrcUpdate = CrcUpdateT1;
- else
- #endif
- {
- for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
- {
- UInt32 x = g_CrcTable[(size_t)i - 256];
- g_CrcTable[i] = CRC_UINT32_SWAP(x);
- }
- g_CrcUpdateT4 = CrcUpdateT1_BeT4;
- g_CrcUpdate = CrcUpdateT1_BeT4;
- #if CRC_NUM_TABLES >= 8
- g_CrcUpdateT8 = CrcUpdateT1_BeT8;
- g_CrcUpdate = CrcUpdateT1_BeT8;
- #endif
- }
- }
- #endif
-
- #endif
-}
+/* 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
diff --git a/C/7zCrc.h b/C/7zCrc.h
index 3b04594..4afaeae 100644
--- a/C/7zCrc.h
+++ b/C/7zCrc.h
@@ -1,25 +1,27 @@
-/* 7zCrc.h -- CRC32 calculation
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_CRC_H
-#define __7Z_CRC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-extern UInt32 g_CrcTable[];
-
-/* Call CrcGenerateTable one time before other CRC functions */
-void MY_FAST_CALL 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 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size);
-UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size);
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/7zCrcOpt.c b/C/7zCrcOpt.c
index 2ee0de8..9c64929 100644
--- a/C/7zCrcOpt.c
+++ b/C/7zCrcOpt.c
@@ -1,115 +1,117 @@
-/* 7zCrcOpt.c -- CRC32 calculation
-2017-04-03 : 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 MY_FAST_CALL 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 *)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 MY_FAST_CALL 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 *)p;
- v =
- (table + 0x700)[((v ) & 0xFF)]
- ^ (table + 0x600)[((v >> 8) & 0xFF)]
- ^ (table + 0x500)[((v >> 16) & 0xFF)]
- ^ (table + 0x400)[((v >> 24))];
- d = *((const UInt32 *)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) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
-
-#define CRC_UPDATE_BYTE_2_BE(crc, b) (table[(((crc) >> 24) ^ (b))] ^ ((crc) << 8))
-
-UInt32 MY_FAST_CALL 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 *)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 MY_FAST_CALL 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 *)p;
- v =
- (table + 0x400)[((v ) & 0xFF)]
- ^ (table + 0x500)[((v >> 8) & 0xFF)]
- ^ (table + 0x600)[((v >> 16) & 0xFF)]
- ^ (table + 0x700)[((v >> 24))];
- d = *((const UInt32 *)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
+/* 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
diff --git a/C/7zDec.c b/C/7zDec.c
index 2a7b090..96c6035 100644
--- a/C/7zDec.c
+++ b/C/7zDec.c
@@ -1,591 +1,648 @@
-/* 7zDec.c -- Decoding from 7z folder
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-/* #define _7ZIP_PPMD_SUPPPORT */
-
-#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 _7ZIP_PPMD_SUPPPORT
-#include "Ppmd7.h"
-#endif
-
-#define k_Copy 0
-#define k_Delta 3
-#define k_LZMA2 0x21
-#define k_LZMA 0x30101
-#define k_BCJ 0x3030103
-#define k_BCJ2 0x303011B
-#define k_PPC 0x3030205
-#define k_IA64 0x3030401
-#define k_ARM 0x3030501
-#define k_ARMT 0x3030701
-#define k_SPARC 0x3030805
-
-
-#ifdef _7ZIP_PPMD_SUPPPORT
-
-#define k_PPMD 0x30401
-
-typedef struct
-{
- IByteIn vt;
- const Byte *cur;
- const Byte *end;
- const Byte *begin;
- UInt64 processed;
- BoolInt extra;
- SRes res;
- const ILookInStream *inStream;
-} CByteInToLook;
-
-static Byte ReadByte(const IByteIn *pp)
-{
- CByteInToLook *p = CONTAINER_FROM_VTBL(pp, CByteInToLook, vt);
- if (p->cur != p->end)
- return *p->cur++;
- if (p->res == SZ_OK)
- {
- size_t size = 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, const ILookInStream *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);
- }
- {
- CPpmd7z_RangeDec rc;
- Ppmd7z_RangeDec_CreateVTable(&rc);
- rc.Stream = &s.vt;
- if (!Ppmd7z_RangeDec_Init(&rc))
- res = SZ_ERROR_DATA;
- else if (s.extra)
- res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
- else
- {
- SizeT i;
- for (i = 0; i < outSize; i++)
- {
- int sym = Ppmd7_DecodeSymbol(&ppmd, &rc.vt);
- if (s.extra || sym < 0)
- break;
- outBuffer[i] = (Byte)sym;
- }
- if (i != outSize)
- res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
- else if (s.processed + (s.cur - s.begin) != inSize || !Ppmd7z_RangeDec_IsFinishedOK(&rc))
- res = SZ_ERROR_DATA;
- }
- }
- Ppmd7_Free(&ppmd, allocMain);
- return res;
-}
-
-#endif
-
-
-static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *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 _7Z_NO_METHOD_LZMA2
-
-static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *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, ILookInStream *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 _7Z_NO_METHOD_LZMA2
- case k_LZMA2:
- #endif
- #ifdef _7ZIP_PPMD_SUPPPORT
- 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;
- }
-
-
- #ifndef _7Z_NO_METHODS_FILTERS
-
- 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)
- {
- case k_Delta:
- case k_BCJ:
- case k_PPC:
- case k_IA64:
- case k_SPARC:
- case k_ARM:
- case k_ARMT:
- 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;
-}
-
-#define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;
-
-static SRes SzFolder_Decode2(const CSzFolder *folder,
- const Byte *propsData,
- const UInt64 *unpackSizes,
- const UInt64 *packPositions,
- ILookInStream *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)
- {
- UInt32 indices[] = { 3, 2, 0 };
- 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 _7Z_NO_METHOD_LZMA2
- else if (coder->MethodID == k_LZMA2)
- {
- RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
- }
- #endif
- #ifdef _7ZIP_PPMD_SUPPPORT
- 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)
- {
- UInt64 offset = packPositions[1];
- 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 (!Bcj2Dec_IsFinished(&p))
- return SZ_ERROR_DATA;
-
- if (p.dest != p.destLim
- || p.state != BCJ2_STREAM_MAIN)
- return SZ_ERROR_DATA;
- }
- }
- }
- #ifndef _7Z_NO_METHODS_FILTERS
- else if (ci == 1)
- {
- 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);
- }
- }
- else
- {
- if (coder->PropsSize != 0)
- return SZ_ERROR_UNSUPPORTED;
- switch (coder->MethodID)
- {
- case k_BCJ:
- {
- UInt32 state;
- x86_Convert_Init(state);
- x86_Convert(outBuffer, outSize, 0, &state, 0);
- break;
- }
- CASE_BRA_CONV(PPC)
- CASE_BRA_CONV(IA64)
- CASE_BRA_CONV(SPARC)
- CASE_BRA_CONV(ARM)
- CASE_BRA_CONV(ARMT)
- default:
- return SZ_ERROR_UNSUPPORTED;
- }
- }
- }
- #endif
- else
- return SZ_ERROR_UNSUPPORTED;
- }
-
- return SZ_OK;
-}
-
-
-SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
- ILookInStream *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;
- }
-}
+/* 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;
+ }
+}
diff --git a/C/7zFile.c b/C/7zFile.c
index e486901..ba5daa1 100644
--- a/C/7zFile.c
+++ b/C/7zFile.c
@@ -1,286 +1,443 @@
-/* 7zFile.c -- File IO
-2017-04-03 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "7zFile.h"
-
-#ifndef USE_WINDOWS_FILE
-
-#ifndef UNDER_CE
-#include <errno.h>
-#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"
-*/
-
-#define kChunkSizeMax (1 << 22)
-
-#endif
-
-void File_Construct(CSzFile *p)
-{
- #ifdef USE_WINDOWS_FILE
- p->handle = INVALID_HANDLE_VALUE;
- #else
- p->file = NULL;
- #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();
- #else
- p->file = fopen(name, writeMode ? "wb+" : "rb");
- return (p->file != 0) ? 0 :
- #ifdef UNDER_CE
- 2; /* ENOENT */
- #else
- errno;
- #endif
- #endif
-}
-
-WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }
-WRes OutFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 1); }
-#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;
- }
- #else
- if (p->file != NULL)
- {
- int res = fclose(p->file);
- if (res != 0)
- return res;
- p->file = NULL;
- }
- #endif
- return 0;
-}
-
-WRes File_Read(CSzFile *p, void *data, size_t *size)
-{
- size_t originalSize = *size;
- if (originalSize == 0)
- return 0;
-
- #ifdef USE_WINDOWS_FILE
-
- *size = 0;
- do
- {
- DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
- DWORD processed = 0;
- BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);
- data = (void *)((Byte *)data + processed);
- originalSize -= processed;
- *size += processed;
- if (!res)
- return GetLastError();
- if (processed == 0)
- break;
- }
- while (originalSize > 0);
- return 0;
-
- #else
-
- *size = fread(data, 1, originalSize, p->file);
- if (*size == originalSize)
- return 0;
- return ferror(p->file);
-
- #endif
-}
-
-WRes File_Write(CSzFile *p, const void *data, size_t *size)
-{
- size_t originalSize = *size;
- if (originalSize == 0)
- return 0;
-
- #ifdef USE_WINDOWS_FILE
-
- *size = 0;
- do
- {
- DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
- DWORD processed = 0;
- BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);
- data = (void *)((Byte *)data + processed);
- originalSize -= processed;
- *size += processed;
- if (!res)
- return GetLastError();
- if (processed == 0)
- break;
- }
- while (originalSize > 0);
- return 0;
-
- #else
-
- *size = fwrite(data, 1, originalSize, p->file);
- if (*size == originalSize)
- return 0;
- return ferror(p->file);
-
- #endif
-}
-
-WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
-{
- #ifdef USE_WINDOWS_FILE
-
- LARGE_INTEGER value;
- DWORD moveMethod;
- value.LowPart = (DWORD)*pos;
- value.HighPart = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */
- switch (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;
- }
- value.LowPart = SetFilePointer(p->handle, value.LowPart, &value.HighPart, moveMethod);
- if (value.LowPart == 0xFFFFFFFF)
- {
- WRes res = GetLastError();
- if (res != NO_ERROR)
- return res;
- }
- *pos = ((Int64)value.HighPart << 32) | value.LowPart;
- return 0;
-
- #else
-
- int moveMethod;
- int res;
- switch (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 1;
- }
- res = fseek(p->file, (long)*pos, moveMethod);
- *pos = ftell(p->file);
- return res;
-
- #endif
-}
-
-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;
-
- #else
-
- 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;
-
- #endif
-}
-
-
-/* ---------- FileSeqInStream ---------- */
-
-static SRes FileSeqInStream_Read(const ISeqInStream *pp, void *buf, size_t *size)
-{
- CFileSeqInStream *p = CONTAINER_FROM_VTBL(pp, CFileSeqInStream, vt);
- return File_Read(&p->file, buf, size) == 0 ? SZ_OK : SZ_ERROR_READ;
-}
-
-void FileSeqInStream_CreateVTable(CFileSeqInStream *p)
-{
- p->vt.Read = FileSeqInStream_Read;
-}
-
-
-/* ---------- FileInStream ---------- */
-
-static SRes FileInStream_Read(const ISeekInStream *pp, void *buf, size_t *size)
-{
- CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);
- return (File_Read(&p->file, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ;
-}
-
-static SRes FileInStream_Seek(const ISeekInStream *pp, Int64 *pos, ESzSeek origin)
-{
- CFileInStream *p = CONTAINER_FROM_VTBL(pp, CFileInStream, vt);
- return File_Seek(&p->file, pos, origin);
-}
-
-void FileInStream_CreateVTable(CFileInStream *p)
-{
- p->vt.Read = FileInStream_Read;
- p->vt.Seek = FileInStream_Seek;
-}
-
-
-/* ---------- FileOutStream ---------- */
-
-static size_t FileOutStream_Write(const ISeqOutStream *pp, const void *data, size_t size)
-{
- CFileOutStream *p = CONTAINER_FROM_VTBL(pp, CFileOutStream, vt);
- File_Write(&p->file, data, &size);
- return size;
-}
-
-void FileOutStream_CreateVTable(CFileOutStream *p)
-{
- p->vt.Write = FileOutStream_Write;
-}
+/* 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;
+}
diff --git a/C/7zFile.h b/C/7zFile.h
index 7e263be..f5069cd 100644
--- a/C/7zFile.h
+++ b/C/7zFile.h
@@ -1,83 +1,92 @@
-/* 7zFile.h -- File IO
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_FILE_H
-#define __7Z_FILE_H
-
-#ifdef _WIN32
-#define USE_WINDOWS_FILE
-#endif
-
-#ifdef USE_WINDOWS_FILE
-#include <windows.h>
-#else
-#include <stdio.h>
-#endif
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/* ---------- File ---------- */
-
-typedef struct
-{
- #ifdef USE_WINDOWS_FILE
- HANDLE handle;
- #else
- FILE *file;
- #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;
-} CFileSeqInStream;
-
-void FileSeqInStream_CreateVTable(CFileSeqInStream *p);
-
-
-typedef struct
-{
- ISeekInStream vt;
- CSzFile file;
-} CFileInStream;
-
-void FileInStream_CreateVTable(CFileInStream *p);
-
-
-typedef struct
-{
- ISeqOutStream vt;
- CSzFile file;
-} CFileOutStream;
-
-void FileOutStream_CreateVTable(CFileOutStream *p);
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/7zStream.c b/C/7zStream.c
index 579741f..74e75b6 100644
--- a/C/7zStream.c
+++ b/C/7zStream.c
@@ -1,176 +1,199 @@
-/* 7zStream.c -- 7z Stream functions
-2017-04-03 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "7zTypes.h"
-
-SRes SeqInStream_Read2(const ISeqInStream *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(const ISeqInStream *stream, void *buf, size_t size)
-{
- return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
-}
-
-SRes SeqInStream_ReadByte(const ISeqInStream *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(const ILookInStream *stream, UInt64 offset)
-{
- Int64 t = offset;
- return ILookInStream_Seek(stream, &t, SZ_SEEK_SET);
-}
-
-SRes LookInStream_LookRead(const ILookInStream *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(const ILookInStream *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(const ILookInStream *stream, void *buf, size_t size)
-{
- return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
-}
-
-
-
-#define GET_LookToRead2 CLookToRead2 *p = CONTAINER_FROM_VTBL(pp, CLookToRead2, vt);
-
-static SRes LookToRead2_Look_Lookahead(const ILookInStream *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(const ILookInStream *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(const ILookInStream *pp, size_t offset)
-{
- GET_LookToRead2
- p->pos += offset;
- return SZ_OK;
-}
-
-static SRes LookToRead2_Read(const ILookInStream *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(const ILookInStream *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(const ISeqInStream *pp, void *buf, size_t *size)
-{
- CSecToLook *p = CONTAINER_FROM_VTBL(pp, CSecToLook, vt);
- return LookInStream_LookRead(p->realStream, buf, size);
-}
-
-void SecToLook_CreateVTable(CSecToLook *p)
-{
- p->vt.Read = SecToLook_Read;
-}
-
-static SRes SecToRead_Read(const ISeqInStream *pp, void *buf, size_t *size)
-{
- CSecToRead *p = CONTAINER_FROM_VTBL(pp, CSecToRead, vt);
- return ILookInStream_Read(p->realStream, buf, size);
-}
-
-void SecToRead_CreateVTable(CSecToRead *p)
-{
- p->vt.Read = SecToRead_Read;
-}
+/* 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;
+}
diff --git a/C/7zTypes.h b/C/7zTypes.h
index 593f5aa..1fcb247 100644
--- a/C/7zTypes.h
+++ b/C/7zTypes.h
@@ -1,375 +1,597 @@
-/* 7zTypes.h -- Basic types
-2018-08-04 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_TYPES_H
-#define __7Z_TYPES_H
-
-#ifdef _WIN32
-/* #include <windows.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 _WIN32
-
-/* typedef DWORD WRes; */
-typedef unsigned WRes;
-#define MY_SRes_HRESULT_FROM_WRes(x) HRESULT_FROM_WIN32(x)
-
-#else
-
-typedef int WRes;
-#define MY__FACILITY_WIN32 7
-#define MY__FACILITY__WRes MY__FACILITY_WIN32
-#define MY_SRes_HRESULT_FROM_WRes(x) ((HRESULT)(x) <= 0 ? ((HRESULT)(x)) : ((HRESULT) (((x) & 0x0000FFFF) | (MY__FACILITY__WRes << 16) | 0x80000000)))
-
-#endif
-
-
-#ifndef RINOK
-#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
-#endif
-
-typedef unsigned char Byte;
-typedef short Int16;
-typedef unsigned short UInt16;
-
-#ifdef _LZMA_UINT32_IS_ULONG
-typedef long Int32;
-typedef unsigned long UInt32;
-#else
-typedef int Int32;
-typedef unsigned int UInt32;
-#endif
-
-#ifdef _SZ_NO_INT_64
-
-/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.
- NOTES: Some code will work incorrectly in that case! */
-
-typedef long Int64;
-typedef unsigned long UInt64;
-
-#else
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
-typedef __int64 Int64;
-typedef unsigned __int64 UInt64;
-#define UINT64_CONST(n) n
-#else
-typedef long long int Int64;
-typedef unsigned long long int UInt64;
-#define UINT64_CONST(n) n ## ULL
-#endif
-
-#endif
-
-#ifdef _LZMA_NO_SYSTEM_SIZE_T
-typedef UInt32 SizeT;
-#else
-typedef size_t SizeT;
-#endif
-
-typedef int BoolInt;
-/* typedef BoolInt Bool; */
-#define True 1
-#define False 0
-
-
-#ifdef _WIN32
-#define MY_STD_CALL __stdcall
-#else
-#define MY_STD_CALL
-#endif
-
-#ifdef _MSC_VER
-
-#if _MSC_VER >= 1300
-#define MY_NO_INLINE __declspec(noinline)
-#else
-#define MY_NO_INLINE
-#endif
-
-#define MY_FORCE_INLINE __forceinline
-
-#define MY_CDECL __cdecl
-#define MY_FAST_CALL __fastcall
-
-#else
-
-#define MY_NO_INLINE
-#define MY_FORCE_INLINE
-#define MY_CDECL
-#define MY_FAST_CALL
-
-/* inline keyword : for C++ / C99 */
-
-/* GCC, clang: */
-/*
-#if defined (__GNUC__) && (__GNUC__ >= 4)
-#define MY_FORCE_INLINE __attribute__((always_inline))
-#define MY_NO_INLINE __attribute__((noinline))
-#endif
-*/
-
-#endif
-
-
-/* The following interfaces use first parameter as pointer to structure */
-
-typedef struct IByteIn IByteIn;
-struct IByteIn
-{
- Byte (*Read)(const IByteIn *p); /* reads one byte, returns 0 in case of EOF or error */
-};
-#define IByteIn_Read(p) (p)->Read(p)
-
-
-typedef struct IByteOut IByteOut;
-struct IByteOut
-{
- void (*Write)(const IByteOut *p, Byte b);
-};
-#define IByteOut_Write(p, b) (p)->Write(p, b)
-
-
-typedef struct ISeqInStream ISeqInStream;
-struct ISeqInStream
-{
- SRes (*Read)(const ISeqInStream *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)
-
-/* it can return SZ_ERROR_INPUT_EOF */
-SRes SeqInStream_Read(const ISeqInStream *stream, void *buf, size_t size);
-SRes SeqInStream_Read2(const ISeqInStream *stream, void *buf, size_t size, SRes errorType);
-SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf);
-
-
-typedef struct ISeqOutStream ISeqOutStream;
-struct ISeqOutStream
-{
- size_t (*Write)(const ISeqOutStream *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;
-
-
-typedef struct ISeekInStream ISeekInStream;
-struct ISeekInStream
-{
- SRes (*Read)(const ISeekInStream *p, void *buf, size_t *size); /* same as ISeqInStream::Read */
- SRes (*Seek)(const ISeekInStream *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)
-
-
-typedef struct ILookInStream ILookInStream;
-struct ILookInStream
-{
- SRes (*Look)(const ILookInStream *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)(const ILookInStream *p, size_t offset);
- /* offset must be <= output(*size) of Look */
-
- SRes (*Read)(const ILookInStream *p, void *buf, size_t *size);
- /* reads directly (without buffer). It's same as ISeqInStream::Read */
- SRes (*Seek)(const ILookInStream *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(const ILookInStream *stream, void *buf, size_t *size);
-SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset);
-
-/* reads via ILookInStream::Read */
-SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType);
-SRes LookInStream_Read(const ILookInStream *stream, void *buf, size_t size);
-
-
-
-typedef struct
-{
- ILookInStream vt;
- const ISeekInStream *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;
- const ILookInStream *realStream;
-} CSecToLook;
-
-void SecToLook_CreateVTable(CSecToLook *p);
-
-
-
-typedef struct
-{
- ISeqInStream vt;
- const ILookInStream *realStream;
-} CSecToRead;
-
-void SecToRead_CreateVTable(CSecToRead *p);
-
-
-typedef struct ICompressProgress ICompressProgress;
-
-struct ICompressProgress
-{
- SRes (*Progress)(const ICompressProgress *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 MY_container_of
-
-/*
-#define MY_container_of(ptr, type, m) container_of(ptr, type, m)
-#define MY_container_of(ptr, type, m) CONTAINING_RECORD(ptr, type, m)
-#define MY_container_of(ptr, type, m) ((type *)((char *)(ptr) - offsetof(type, m)))
-#define MY_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 MY_container_of(ptr, type, m) ((type *)((char *)(1 ? (ptr) : &((type *)0)->m) - MY_offsetof(type, m)))
-
-
-#endif
-
-#define CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m) ((type *)(ptr))
-
-/*
-#define CONTAINER_FROM_VTBL(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)
-*/
-#define CONTAINER_FROM_VTBL(ptr, type, m) MY_container_of(ptr, type, m)
-
-#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL_SIMPLE(ptr, type, m)
-/*
-#define CONTAINER_FROM_VTBL_CLS(ptr, type, m) CONTAINER_FROM_VTBL(ptr, type, m)
-*/
-
-
-
-#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
-
-EXTERN_C_END
-
-#endif
+/* 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
+*/
diff --git a/C/7zVersion.h b/C/7zVersion.h
index 0074c64..7549239 100644
--- a/C/7zVersion.h
+++ b/C/7zVersion.h
@@ -1,27 +1,27 @@
-#define MY_VER_MAJOR 19
-#define MY_VER_MINOR 00
-#define MY_VER_BUILD 0
-#define MY_VERSION_NUMBERS "19.00"
-#define MY_VERSION MY_VERSION_NUMBERS
-
-#ifdef MY_CPU_NAME
- #define MY_VERSION_CPU MY_VERSION " (" MY_CPU_NAME ")"
-#else
- #define MY_VERSION_CPU MY_VERSION
-#endif
-
-#define MY_DATE "2019-02-21"
-#undef MY_COPYRIGHT
-#undef MY_VERSION_COPYRIGHT_DATE
-#define MY_AUTHOR_NAME "Igor Pavlov"
-#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
-#define MY_COPYRIGHT_CR "Copyright (c) 1999-2018 Igor Pavlov"
-
-#ifdef USE_COPYRIGHT_CR
- #define MY_COPYRIGHT MY_COPYRIGHT_CR
-#else
- #define MY_COPYRIGHT MY_COPYRIGHT_PD
-#endif
-
-#define MY_COPYRIGHT_DATE MY_COPYRIGHT " : " MY_DATE
-#define MY_VERSION_COPYRIGHT_DATE MY_VERSION_CPU " : " MY_COPYRIGHT " : " MY_DATE
+#define MY_VER_MAJOR 23
+#define MY_VER_MINOR 01
+#define MY_VER_BUILD 0
+#define MY_VERSION_NUMBERS "23.01"
+#define MY_VERSION MY_VERSION_NUMBERS
+
+#ifdef MY_CPU_NAME
+ #define MY_VERSION_CPU MY_VERSION " (" MY_CPU_NAME ")"
+#else
+ #define MY_VERSION_CPU MY_VERSION
+#endif
+
+#define MY_DATE "2023-06-20"
+#undef MY_COPYRIGHT
+#undef MY_VERSION_COPYRIGHT_DATE
+#define MY_AUTHOR_NAME "Igor Pavlov"
+#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
+#define MY_COPYRIGHT_CR "Copyright (c) 1999-2023 Igor Pavlov"
+
+#ifdef USE_COPYRIGHT_CR
+ #define MY_COPYRIGHT MY_COPYRIGHT_CR
+#else
+ #define MY_COPYRIGHT MY_COPYRIGHT_PD
+#endif
+
+#define MY_COPYRIGHT_DATE MY_COPYRIGHT " : " MY_DATE
+#define MY_VERSION_COPYRIGHT_DATE MY_VERSION_CPU " : " MY_COPYRIGHT " : " MY_DATE
diff --git a/C/7zVersion.rc b/C/7zVersion.rc
index 6ed26de..e520995 100644
--- a/C/7zVersion.rc
+++ b/C/7zVersion.rc
@@ -1,55 +1,55 @@
-#define MY_VS_FFI_FILEFLAGSMASK 0x0000003FL
-#define MY_VOS_NT_WINDOWS32 0x00040004L
-#define MY_VOS_CE_WINDOWS32 0x00050004L
-
-#define MY_VFT_APP 0x00000001L
-#define MY_VFT_DLL 0x00000002L
-
-// #include <WinVer.h>
-
-#ifndef MY_VERSION
-#include "7zVersion.h"
-#endif
-
-#define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0
-
-#ifdef DEBUG
-#define DBG_FL VS_FF_DEBUG
-#else
-#define DBG_FL 0
-#endif
-
-#define MY_VERSION_INFO(fileType, descr, intName, origName) \
-LANGUAGE 9, 1 \
-1 VERSIONINFO \
- FILEVERSION MY_VER \
- PRODUCTVERSION MY_VER \
- FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \
- FILEFLAGS DBG_FL \
- FILEOS MY_VOS_NT_WINDOWS32 \
- FILETYPE fileType \
- FILESUBTYPE 0x0L \
-BEGIN \
- BLOCK "StringFileInfo" \
- BEGIN \
- BLOCK "040904b0" \
- BEGIN \
- VALUE "CompanyName", "Igor Pavlov" \
- VALUE "FileDescription", descr \
- VALUE "FileVersion", MY_VERSION \
- VALUE "InternalName", intName \
- VALUE "LegalCopyright", MY_COPYRIGHT \
- VALUE "OriginalFilename", origName \
- VALUE "ProductName", "7-Zip" \
- VALUE "ProductVersion", MY_VERSION \
- END \
- END \
- BLOCK "VarFileInfo" \
- BEGIN \
- VALUE "Translation", 0x409, 1200 \
- END \
-END
-
-#define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")
-
-#define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")
+#define MY_VS_FFI_FILEFLAGSMASK 0x0000003FL
+#define MY_VOS_NT_WINDOWS32 0x00040004L
+#define MY_VOS_CE_WINDOWS32 0x00050004L
+
+#define MY_VFT_APP 0x00000001L
+#define MY_VFT_DLL 0x00000002L
+
+// #include <WinVer.h>
+
+#ifndef MY_VERSION
+#include "7zVersion.h"
+#endif
+
+#define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0
+
+#ifdef DEBUG
+#define DBG_FL VS_FF_DEBUG
+#else
+#define DBG_FL 0
+#endif
+
+#define MY_VERSION_INFO(fileType, descr, intName, origName) \
+LANGUAGE 9, 1 \
+1 VERSIONINFO \
+ FILEVERSION MY_VER \
+ PRODUCTVERSION MY_VER \
+ FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \
+ FILEFLAGS DBG_FL \
+ FILEOS MY_VOS_NT_WINDOWS32 \
+ FILETYPE fileType \
+ FILESUBTYPE 0x0L \
+BEGIN \
+ BLOCK "StringFileInfo" \
+ BEGIN \
+ BLOCK "040904b0" \
+ BEGIN \
+ VALUE "CompanyName", "Igor Pavlov" \
+ VALUE "FileDescription", descr \
+ VALUE "FileVersion", MY_VERSION \
+ VALUE "InternalName", intName \
+ VALUE "LegalCopyright", MY_COPYRIGHT \
+ VALUE "OriginalFilename", origName \
+ VALUE "ProductName", "7-Zip" \
+ VALUE "ProductVersion", MY_VERSION \
+ END \
+ END \
+ BLOCK "VarFileInfo" \
+ BEGIN \
+ VALUE "Translation", 0x409, 1200 \
+ END \
+END
+
+#define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")
+
+#define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")
diff --git a/C/7zWindows.h b/C/7zWindows.h
new file mode 100644
index 0000000..42c6db8
--- /dev/null
+++ b/C/7zWindows.h
@@ -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
diff --git a/C/7zip_gcc_c.mak b/C/7zip_gcc_c.mak
new file mode 100644
index 0000000..f19a99b
--- /dev/null
+++ b/C/7zip_gcc_c.mak
@@ -0,0 +1,360 @@
+
+MY_ARCH_2 = $(MY_ARCH)
+
+MY_ASM = jwasm
+MY_ASM = asmc
+
+ifndef RC
+#RC=windres.exe --target=pe-x86-64
+#RC=windres.exe -F pe-i386
+RC=windres.exe
+endif
+
+PROGPATH = $(O)/$(PROG)
+PROGPATH_STATIC = $(O)/$(PROG)s
+
+ifneq ($(CC), xlc)
+CFLAGS_WARN_WALL = -Wall -Werror -Wextra
+endif
+
+# for object file
+CFLAGS_BASE_LIST = -c
+# for ASM file
+# CFLAGS_BASE_LIST = -S
+
+FLAGS_FLTO =
+FLAGS_FLTO = -flto
+
+CFLAGS_BASE = $(MY_ARCH_2) -O2 $(CFLAGS_BASE_LIST) $(CFLAGS_WARN_WALL) $(CFLAGS_WARN) \
+ -DNDEBUG -D_REENTRANT -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef IS_MINGW
+LDFLAGS_STATIC_2 = -static
+else
+ifndef DEF_FILE
+ifndef IS_NOT_STANDALONE
+ifndef MY_DYNAMIC_LINK
+ifneq ($(CC), clang)
+LDFLAGS_STATIC_2 =
+# -static
+# -static-libstdc++ -static-libgcc
+endif
+endif
+endif
+endif
+endif
+
+LDFLAGS_STATIC = -DNDEBUG $(LDFLAGS_STATIC_2)
+
+ifdef DEF_FILE
+
+
+ifdef IS_MINGW
+SHARED_EXT=.dll
+LDFLAGS = -shared -DEF $(DEF_FILE) $(LDFLAGS_STATIC)
+else
+SHARED_EXT=.so
+LDFLAGS = -shared -fPIC $(LDFLAGS_STATIC)
+CC_SHARED=-fPIC
+endif
+
+
+else
+
+LDFLAGS = $(LDFLAGS_STATIC)
+# -s is not required for clang, do we need it for GGC ???
+# -s
+
+#-static -static-libgcc -static-libstdc++
+
+ifdef IS_MINGW
+SHARED_EXT=.exe
+else
+SHARED_EXT=
+endif
+
+endif
+
+
+PROGPATH = $(O)/$(PROG)$(SHARED_EXT)
+PROGPATH_STATIC = $(O)/$(PROG)s$(SHARED_EXT)
+
+ifndef O
+O=_o
+endif
+
+ifdef IS_MINGW
+
+ifdef MSYSTEM
+RM = rm -f
+MY_MKDIR=mkdir -p
+DEL_OBJ_EXE = -$(RM) $(PROGPATH) $(PROGPATH_STATIC) $(OBJS)
+else
+RM = del
+MY_MKDIR=mkdir
+DEL_OBJ_EXE = -$(RM) $(O)\*.o $(O)\$(PROG).exe $(O)\$(PROG).dll
+endif
+
+
+LIB2 = -lOle32 -loleaut32 -luuid -ladvapi32 -lUser32 -lShell32
+
+CFLAGS_EXTRA = -DUNICODE -D_UNICODE
+# -Wno-delete-non-virtual-dtor
+
+
+else
+
+RM = rm -f
+MY_MKDIR=mkdir -p
+# CFLAGS_BASE := $(CFLAGS_BASE) -DZ7_ST
+# CFLAGS_EXTRA = -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+
+# LOCAL_LIBS=-lpthread
+# LOCAL_LIBS_DLL=$(LOCAL_LIBS) -ldl
+LIB2 = -lpthread -ldl
+
+DEL_OBJ_EXE = -$(RM) $(PROGPATH) $(PROGPATH_STATIC) $(OBJS)
+
+endif
+
+
+ifdef IS_X64
+AFLAGS_ABI = -elf64 -DABI_LINUX
+else
+AFLAGS_ABI = -elf -DABI_LINUX -DABI_CDECL
+# -DABI_CDECL
+# -DABI_LINUX
+# -DABI_CDECL
+endif
+AFLAGS = $(AFLAGS_ABI) -Fo$(O)/
+
+C_WARN_FLAGS =
+
+CFLAGS = $(LOCAL_FLAGS) $(CFLAGS_BASE2) $(CFLAGS_BASE) $(CFLAGS_EXTRA) $(C_WARN_FLAGS) $(FLAGS_FLTO) $(CC_SHARED) -o $@
+
+STATIC_TARGET=
+ifdef COMPL_STATIC
+STATIC_TARGET=$(PROGPATH_STATIC)
+endif
+
+
+all: $(O) $(PROGPATH) $(STATIC_TARGET)
+
+$(O):
+ $(MY_MKDIR) $(O)
+
+ifneq ($(CC), $(CROSS_COMPILE)clang)
+LFLAGS_STRIP = -s
+endif
+
+LFLAGS_ALL = $(LFLAGS_STRIP) $(MY_ARCH_2) $(LDFLAGS) $(FLAGS_FLTO) $(LD_arch) $(OBJS) $(MY_LIBS) $(LIB2)
+$(PROGPATH): $(OBJS)
+ $(CC) -o $(PROGPATH) $(LFLAGS_ALL)
+
+$(PROGPATH_STATIC): $(OBJS)
+ $(CC) -static -o $(PROGPATH_STATIC) $(LFLAGS_ALL)
+
+
+ifndef NO_DEFAULT_RES
+# old mingw without -FO
+# windres.exe $(RFLAGS) resource.rc $O/resource.o
+$O/resource.o: resource.rc
+ $(RC) $(RFLAGS) resource.rc $(O)/resource.o
+endif
+# windres.exe $(RFLAGS) resource.rc $(O)\resource.o
+# windres.exe $(RFLAGS) resource.rc -FO $(O)/resource.o
+# $(RC) $(RFLAGS) resource.rc -FO $(O)/resource.o
+
+
+
+$O/7zAlloc.o: ../../../C/7zAlloc.c
+ $(CC) $(CFLAGS) $<
+$O/7zArcIn.o: ../../../C/7zArcIn.c
+ $(CC) $(CFLAGS) $<
+$O/7zBuf.o: ../../../C/7zBuf.c
+ $(CC) $(CFLAGS) $<
+$O/7zBuf2.o: ../../../C/7zBuf2.c
+ $(CC) $(CFLAGS) $<
+$O/7zCrc.o: ../../../C/7zCrc.c
+ $(CC) $(CFLAGS) $<
+$O/7zDec.o: ../../../C/7zDec.c
+ $(CC) $(CFLAGS) $<
+$O/7zFile.o: ../../../C/7zFile.c
+ $(CC) $(CFLAGS) $<
+$O/7zStream.o: ../../../C/7zStream.c
+ $(CC) $(CFLAGS) $<
+$O/Aes.o: ../../../C/Aes.c
+ $(CC) $(CFLAGS) $<
+$O/Alloc.o: ../../../C/Alloc.c
+ $(CC) $(CFLAGS) $<
+$O/Bcj2.o: ../../../C/Bcj2.c
+ $(CC) $(CFLAGS) $<
+$O/Bcj2Enc.o: ../../../C/Bcj2Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Blake2s.o: ../../../C/Blake2s.c
+ $(CC) $(CFLAGS) $<
+$O/Bra.o: ../../../C/Bra.c
+ $(CC) $(CFLAGS) $<
+$O/Bra86.o: ../../../C/Bra86.c
+ $(CC) $(CFLAGS) $<
+$O/BraIA64.o: ../../../C/BraIA64.c
+ $(CC) $(CFLAGS) $<
+$O/BwtSort.o: ../../../C/BwtSort.c
+ $(CC) $(CFLAGS) $<
+
+$O/CpuArch.o: ../../../C/CpuArch.c
+ $(CC) $(CFLAGS) $<
+$O/Delta.o: ../../../C/Delta.c
+ $(CC) $(CFLAGS) $<
+$O/DllSecur.o: ../../../C/DllSecur.c
+ $(CC) $(CFLAGS) $<
+$O/HuffEnc.o: ../../../C/HuffEnc.c
+ $(CC) $(CFLAGS) $<
+$O/LzFind.o: ../../../C/LzFind.c
+ $(CC) $(CFLAGS) $<
+
+# ifdef MT_FILES
+$O/LzFindMt.o: ../../../C/LzFindMt.c
+ $(CC) $(CFLAGS) $<
+$O/LzFindOpt.o: ../../../C/LzFindOpt.c
+ $(CC) $(CFLAGS) $<
+
+$O/Threads.o: ../../../C/Threads.c
+ $(CC) $(CFLAGS) $<
+# endif
+
+$O/LzmaEnc.o: ../../../C/LzmaEnc.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma86Dec.o: ../../../C/Lzma86Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma86Enc.o: ../../../C/Lzma86Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma2Dec.o: ../../../C/Lzma2Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma2DecMt.o: ../../../C/Lzma2DecMt.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma2Enc.o: ../../../C/Lzma2Enc.c
+ $(CC) $(CFLAGS) $<
+$O/LzmaLib.o: ../../../C/LzmaLib.c
+ $(CC) $(CFLAGS) $<
+$O/MtCoder.o: ../../../C/MtCoder.c
+ $(CC) $(CFLAGS) $<
+$O/MtDec.o: ../../../C/MtDec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7.o: ../../../C/Ppmd7.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7aDec.o: ../../../C/Ppmd7aDec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7Dec.o: ../../../C/Ppmd7Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7Enc.o: ../../../C/Ppmd7Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd8.o: ../../../C/Ppmd8.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd8Dec.o: ../../../C/Ppmd8Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd8Enc.o: ../../../C/Ppmd8Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Sha1.o: ../../../C/Sha1.c
+ $(CC) $(CFLAGS) $<
+$O/Sha256.o: ../../../C/Sha256.c
+ $(CC) $(CFLAGS) $<
+$O/Sort.o: ../../../C/Sort.c
+ $(CC) $(CFLAGS) $<
+$O/SwapBytes.o: ../../../C/SwapBytes.c
+ $(CC) $(CFLAGS) $<
+$O/Xz.o: ../../../C/Xz.c
+ $(CC) $(CFLAGS) $<
+$O/XzCrc64.o: ../../../C/XzCrc64.c
+ $(CC) $(CFLAGS) $<
+$O/XzDec.o: ../../../C/XzDec.c
+ $(CC) $(CFLAGS) $<
+$O/XzEnc.o: ../../../C/XzEnc.c
+ $(CC) $(CFLAGS) $<
+$O/XzIn.o: ../../../C/XzIn.c
+ $(CC) $(CFLAGS) $<
+
+
+ifdef USE_ASM
+ifdef IS_X64
+USE_X86_ASM=1
+else
+ifdef IS_X86
+USE_X86_ASM=1
+endif
+endif
+endif
+
+ifdef USE_X86_ASM
+$O/7zCrcOpt.o: ../../../Asm/x86/7zCrcOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/XzCrc64Opt.o: ../../../Asm/x86/XzCrc64Opt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/AesOpt.o: ../../../Asm/x86/AesOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/Sha1Opt.o: ../../../Asm/x86/Sha1Opt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/Sha256Opt.o: ../../../Asm/x86/Sha256Opt.asm
+ $(MY_ASM) $(AFLAGS) $<
+else
+$O/7zCrcOpt.o: ../../7zCrcOpt.c
+ $(CC) $(CFLAGS) $<
+$O/XzCrc64Opt.o: ../../XzCrc64Opt.c
+ $(CC) $(CFLAGS) $<
+$O/Sha1Opt.o: ../../Sha1Opt.c
+ $(CC) $(CFLAGS) $<
+$O/Sha256Opt.o: ../../Sha256Opt.c
+ $(CC) $(CFLAGS) $<
+$O/AesOpt.o: ../../AesOpt.c
+ $(CC) $(CFLAGS) $<
+endif
+
+
+ifdef USE_LZMA_DEC_ASM
+
+ifdef IS_X64
+$O/LzmaDecOpt.o: ../../../Asm/x86/LzmaDecOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+endif
+
+ifdef IS_ARM64
+$O/LzmaDecOpt.o: ../../../Asm/arm64/LzmaDecOpt.S ../../../Asm/arm64/7zAsm.S
+ $(CC) $(CFLAGS) $<
+endif
+
+$O/LzmaDec.o: ../../LzmaDec.c
+ $(CC) $(CFLAGS) -DZ7_LZMA_DEC_OPT $<
+
+else
+
+$O/LzmaDec.o: ../../LzmaDec.c
+ $(CC) $(CFLAGS) $<
+
+endif
+
+
+
+$O/7zMain.o: ../../../C/Util/7z/7zMain.c
+ $(CC) $(CFLAGS) $<
+$O/7zipInstall.o: ../../../C/Util/7zipInstall/7zipInstall.c
+ $(CC) $(CFLAGS) $<
+$O/7zipUninstall.o: ../../../C/Util/7zipUninstall/7zipUninstall.c
+ $(CC) $(CFLAGS) $<
+$O/LzmaUtil.o: ../../../C/Util/Lzma/LzmaUtil.c
+ $(CC) $(CFLAGS) $<
+$O/XzUtil.o: ../../../C/Util/Xz/XzUtil.c
+ $(CC) $(CFLAGS) $<
+
+
+clean:
+ -$(DEL_OBJ_EXE)
diff --git a/C/Aes.c b/C/Aes.c
index 8f7d50e..bcaafab 100644
--- a/C/Aes.c
+++ b/C/Aes.c
@@ -1,306 +1,393 @@
-/* Aes.c -- AES encryption / decryption
-2017-01-24 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Aes.h"
-#include "CpuArch.h"
-
-static UInt32 T[256 * 4];
-static const Byte Sbox[256] = {
- 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
- 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
- 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
- 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
- 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
- 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
- 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
- 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
- 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
- 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
- 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
- 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
- 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
- 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
- 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
- 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};
-
-void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-AES_CODE_FUNC g_AesCbc_Encode;
-AES_CODE_FUNC g_AesCbc_Decode;
-AES_CODE_FUNC g_AesCtr_Code;
-
-static UInt32 D[256 * 4];
-static Byte InvS[256];
-
-static const Byte Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
-
-#define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
-
-#define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))
-
-#define gb0(x) ( (x) & 0xFF)
-#define gb1(x) (((x) >> ( 8)) & 0xFF)
-#define gb2(x) (((x) >> (16)) & 0xFF)
-#define gb3(x) (((x) >> (24)))
-
-#define gb(n, x) gb ## n(x)
-
-#define TT(x) (T + (x << 8))
-#define DD(x) (D + (x << 8))
-
-
-void AesGenTables(void)
-{
- unsigned i;
- for (i = 0; i < 256; i++)
- InvS[Sbox[i]] = (Byte)i;
-
- for (i = 0; i < 256; i++)
- {
- {
- UInt32 a1 = Sbox[i];
- UInt32 a2 = xtime(a1);
- UInt32 a3 = a2 ^ a1;
- TT(0)[i] = Ui32(a2, a1, a1, a3);
- TT(1)[i] = Ui32(a3, a2, a1, a1);
- TT(2)[i] = Ui32(a1, a3, a2, a1);
- TT(3)[i] = Ui32(a1, a1, a3, a2);
- }
- {
- UInt32 a1 = InvS[i];
- UInt32 a2 = xtime(a1);
- UInt32 a4 = xtime(a2);
- UInt32 a8 = xtime(a4);
- UInt32 a9 = a8 ^ a1;
- UInt32 aB = a8 ^ a2 ^ a1;
- UInt32 aD = a8 ^ a4 ^ a1;
- UInt32 aE = a8 ^ a4 ^ a2;
- DD(0)[i] = Ui32(aE, a9, aD, aB);
- DD(1)[i] = Ui32(aB, aE, a9, aD);
- DD(2)[i] = Ui32(aD, aB, aE, a9);
- DD(3)[i] = Ui32(a9, aD, aB, aE);
- }
- }
-
- g_AesCbc_Encode = AesCbc_Encode;
- g_AesCbc_Decode = AesCbc_Decode;
- g_AesCtr_Code = AesCtr_Code;
-
- #ifdef MY_CPU_X86_OR_AMD64
- if (CPU_Is_Aes_Supported())
- {
- g_AesCbc_Encode = AesCbc_Encode_Intel;
- g_AesCbc_Decode = AesCbc_Decode_Intel;
- g_AesCtr_Code = AesCtr_Code_Intel;
- }
- #endif
-}
-
-
-#define HT(i, x, s) TT(x)[gb(x, s[(i + x) & 3])]
-
-#define HT4(m, i, s, p) m[i] = \
- HT(i, 0, s) ^ \
- HT(i, 1, s) ^ \
- HT(i, 2, s) ^ \
- HT(i, 3, s) ^ w[p + i]
-
-#define HT16(m, s, p) \
- HT4(m, 0, s, p); \
- HT4(m, 1, s, p); \
- HT4(m, 2, s, p); \
- HT4(m, 3, s, p); \
-
-#define FT(i, x) Sbox[gb(x, m[(i + x) & 3])]
-#define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
-
-
-#define HD(i, x, s) DD(x)[gb(x, s[(i - x) & 3])]
-
-#define HD4(m, i, s, p) m[i] = \
- HD(i, 0, s) ^ \
- HD(i, 1, s) ^ \
- HD(i, 2, s) ^ \
- HD(i, 3, s) ^ w[p + i];
-
-#define HD16(m, s, p) \
- HD4(m, 0, s, p); \
- HD4(m, 1, s, p); \
- HD4(m, 2, s, p); \
- HD4(m, 3, s, p); \
-
-#define FD(i, x) InvS[gb(x, m[(i - x) & 3])]
-#define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
-
-void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)
-{
- unsigned i, wSize;
- wSize = keySize + 28;
- keySize /= 4;
- w[0] = ((UInt32)keySize / 2) + 3;
- w += 4;
-
- for (i = 0; i < keySize; i++, key += 4)
- w[i] = GetUi32(key);
-
- for (; i < wSize; i++)
- {
- UInt32 t = w[(size_t)i - 1];
- unsigned rem = i % keySize;
- if (rem == 0)
- t = Ui32(Sbox[gb1(t)] ^ Rcon[i / keySize], Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);
- else if (keySize > 6 && rem == 4)
- t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);
- w[i] = w[i - keySize] ^ t;
- }
-}
-
-void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
-{
- unsigned i, num;
- Aes_SetKey_Enc(w, key, keySize);
- num = keySize + 20;
- w += 8;
- for (i = 0; i < num; i++)
- {
- UInt32 r = w[i];
- w[i] =
- DD(0)[Sbox[gb0(r)]] ^
- DD(1)[Sbox[gb1(r)]] ^
- DD(2)[Sbox[gb2(r)]] ^
- DD(3)[Sbox[gb3(r)]];
- }
-}
-
-/* Aes_Encode and Aes_Decode functions work with little-endian words.
- src and dest are pointers to 4 UInt32 words.
- src and dest can point to same block */
-
-static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
-{
- UInt32 s[4];
- UInt32 m[4];
- UInt32 numRounds2 = w[0];
- w += 4;
- s[0] = src[0] ^ w[0];
- s[1] = src[1] ^ w[1];
- s[2] = src[2] ^ w[2];
- s[3] = src[3] ^ w[3];
- w += 4;
- for (;;)
- {
- HT16(m, s, 0);
- if (--numRounds2 == 0)
- break;
- HT16(s, m, 4);
- w += 8;
- }
- w += 4;
- FT4(0); FT4(1); FT4(2); FT4(3);
-}
-
-static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
-{
- UInt32 s[4];
- UInt32 m[4];
- UInt32 numRounds2 = w[0];
- w += 4 + numRounds2 * 8;
- s[0] = src[0] ^ w[0];
- s[1] = src[1] ^ w[1];
- s[2] = src[2] ^ w[2];
- s[3] = src[3] ^ w[3];
- for (;;)
- {
- w -= 8;
- HD16(m, s, 4);
- if (--numRounds2 == 0)
- break;
- HD16(s, m, 0);
- }
- FD4(0); FD4(1); FD4(2); FD4(3);
-}
-
-void AesCbc_Init(UInt32 *p, const Byte *iv)
-{
- unsigned i;
- for (i = 0; i < 4; i++)
- p[i] = GetUi32(iv + i * 4);
-}
-
-void MY_FAST_CALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)
-{
- for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
- {
- p[0] ^= GetUi32(data);
- p[1] ^= GetUi32(data + 4);
- p[2] ^= GetUi32(data + 8);
- p[3] ^= GetUi32(data + 12);
-
- Aes_Encode(p + 4, p, p);
-
- SetUi32(data, p[0]);
- SetUi32(data + 4, p[1]);
- SetUi32(data + 8, p[2]);
- SetUi32(data + 12, p[3]);
- }
-}
-
-void MY_FAST_CALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)
-{
- UInt32 in[4], out[4];
- for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
- {
- in[0] = GetUi32(data);
- in[1] = GetUi32(data + 4);
- in[2] = GetUi32(data + 8);
- in[3] = GetUi32(data + 12);
-
- Aes_Decode(p + 4, out, in);
-
- SetUi32(data, p[0] ^ out[0]);
- SetUi32(data + 4, p[1] ^ out[1]);
- SetUi32(data + 8, p[2] ^ out[2]);
- SetUi32(data + 12, p[3] ^ out[3]);
-
- p[0] = in[0];
- p[1] = in[1];
- p[2] = in[2];
- p[3] = in[3];
- }
-}
-
-void MY_FAST_CALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
-{
- for (; numBlocks != 0; numBlocks--)
- {
- UInt32 temp[4];
- unsigned i;
-
- if (++p[0] == 0)
- p[1]++;
-
- Aes_Encode(p + 4, temp, p);
-
- for (i = 0; i < 4; i++, data += 4)
- {
- UInt32 t = temp[i];
-
- #ifdef MY_CPU_LE_UNALIGN
- *((UInt32 *)data) ^= t;
- #else
- data[0] ^= (t & 0xFF);
- data[1] ^= ((t >> 8) & 0xFF);
- data[2] ^= ((t >> 16) & 0xFF);
- data[3] ^= ((t >> 24));
- #endif
- }
- }
-}
+/* Aes.c -- AES encryption / decryption
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "CpuArch.h"
+#include "Aes.h"
+
+AES_CODE_FUNC g_AesCbc_Decode;
+#ifndef Z7_SFX
+AES_CODE_FUNC g_AesCbc_Encode;
+AES_CODE_FUNC g_AesCtr_Code;
+UInt32 g_Aes_SupportedFunctions_Flags;
+#endif
+
+static UInt32 T[256 * 4];
+static const Byte Sbox[256] = {
+ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+ 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+ 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+ 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+ 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+ 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+ 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+ 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+ 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+ 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+ 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+ 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+ 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+ 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+ 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+ 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};
+
+
+static UInt32 D[256 * 4];
+static Byte InvS[256];
+
+#define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)
+
+#define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))
+
+#define gb0(x) ( (x) & 0xFF)
+#define gb1(x) (((x) >> ( 8)) & 0xFF)
+#define gb2(x) (((x) >> (16)) & 0xFF)
+#define gb3(x) (((x) >> (24)))
+
+#define gb(n, x) gb ## n(x)
+
+#define TT(x) (T + (x << 8))
+#define DD(x) (D + (x << 8))
+
+
+// #define Z7_SHOW_AES_STATUS
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #define USE_HW_AES
+#elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
+ #if defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define USE_HW_AES
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define USE_HW_AES
+ #endif
+ #elif defined(_MSC_VER)
+ #if _MSC_VER >= 1910
+ #define USE_HW_AES
+ #endif
+ #endif
+#endif
+
+#ifdef USE_HW_AES
+#ifdef Z7_SHOW_AES_STATUS
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+#endif
+
+
+void AesGenTables(void)
+{
+ unsigned i;
+ for (i = 0; i < 256; i++)
+ InvS[Sbox[i]] = (Byte)i;
+
+ for (i = 0; i < 256; i++)
+ {
+ {
+ const UInt32 a1 = Sbox[i];
+ const UInt32 a2 = xtime(a1);
+ const UInt32 a3 = a2 ^ a1;
+ TT(0)[i] = Ui32(a2, a1, a1, a3);
+ TT(1)[i] = Ui32(a3, a2, a1, a1);
+ TT(2)[i] = Ui32(a1, a3, a2, a1);
+ TT(3)[i] = Ui32(a1, a1, a3, a2);
+ }
+ {
+ const UInt32 a1 = InvS[i];
+ const UInt32 a2 = xtime(a1);
+ const UInt32 a4 = xtime(a2);
+ const UInt32 a8 = xtime(a4);
+ const UInt32 a9 = a8 ^ a1;
+ const UInt32 aB = a8 ^ a2 ^ a1;
+ const UInt32 aD = a8 ^ a4 ^ a1;
+ const UInt32 aE = a8 ^ a4 ^ a2;
+ DD(0)[i] = Ui32(aE, a9, aD, aB);
+ DD(1)[i] = Ui32(aB, aE, a9, aD);
+ DD(2)[i] = Ui32(aD, aB, aE, a9);
+ DD(3)[i] = Ui32(a9, aD, aB, aE);
+ }
+ }
+
+ {
+ AES_CODE_FUNC d = AesCbc_Decode;
+ #ifndef Z7_SFX
+ AES_CODE_FUNC e = AesCbc_Encode;
+ AES_CODE_FUNC c = AesCtr_Code;
+ UInt32 flags = 0;
+ #endif
+
+ #ifdef USE_HW_AES
+ if (CPU_IsSupported_AES())
+ {
+ // #pragma message ("AES HW")
+ PRF(printf("\n===AES HW\n"));
+ d = AesCbc_Decode_HW;
+
+ #ifndef Z7_SFX
+ e = AesCbc_Encode_HW;
+ c = AesCtr_Code_HW;
+ flags = k_Aes_SupportedFunctions_HW;
+ #endif
+
+ #ifdef MY_CPU_X86_OR_AMD64
+ if (CPU_IsSupported_VAES_AVX2())
+ {
+ PRF(printf("\n===vaes avx2\n"));
+ d = AesCbc_Decode_HW_256;
+ #ifndef Z7_SFX
+ c = AesCtr_Code_HW_256;
+ flags |= k_Aes_SupportedFunctions_HW_256;
+ #endif
+ }
+ #endif
+ }
+ #endif
+
+ g_AesCbc_Decode = d;
+ #ifndef Z7_SFX
+ g_AesCbc_Encode = e;
+ g_AesCtr_Code = c;
+ g_Aes_SupportedFunctions_Flags = flags;
+ #endif
+ }
+}
+
+
+#define HT(i, x, s) TT(x)[gb(x, s[(i + x) & 3])]
+
+#define HT4(m, i, s, p) m[i] = \
+ HT(i, 0, s) ^ \
+ HT(i, 1, s) ^ \
+ HT(i, 2, s) ^ \
+ HT(i, 3, s) ^ w[p + i]
+
+#define HT16(m, s, p) \
+ HT4(m, 0, s, p); \
+ HT4(m, 1, s, p); \
+ HT4(m, 2, s, p); \
+ HT4(m, 3, s, p); \
+
+#define FT(i, x) Sbox[gb(x, m[(i + x) & 3])]
+#define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];
+
+
+#define HD(i, x, s) DD(x)[gb(x, s[(i - x) & 3])]
+
+#define HD4(m, i, s, p) m[i] = \
+ HD(i, 0, s) ^ \
+ HD(i, 1, s) ^ \
+ HD(i, 2, s) ^ \
+ HD(i, 3, s) ^ w[p + i];
+
+#define HD16(m, s, p) \
+ HD4(m, 0, s, p); \
+ HD4(m, 1, s, p); \
+ HD4(m, 2, s, p); \
+ HD4(m, 3, s, p); \
+
+#define FD(i, x) InvS[gb(x, m[(i - x) & 3])]
+#define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];
+
+void Z7_FASTCALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)
+{
+ unsigned i, m;
+ const UInt32 *wLim;
+ UInt32 t;
+ UInt32 rcon = 1;
+
+ keySize /= 4;
+ w[0] = ((UInt32)keySize / 2) + 3;
+ w += 4;
+
+ for (i = 0; i < keySize; i++, key += 4)
+ w[i] = GetUi32(key);
+
+ t = w[(size_t)keySize - 1];
+ wLim = w + (size_t)keySize * 3 + 28;
+ m = 0;
+ do
+ {
+ if (m == 0)
+ {
+ t = Ui32(Sbox[gb1(t)] ^ rcon, Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);
+ rcon <<= 1;
+ if (rcon & 0x100)
+ rcon = 0x1b;
+ m = keySize;
+ }
+ else if (m == 4 && keySize > 6)
+ t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);
+ m--;
+ t ^= w[0];
+ w[keySize] = t;
+ }
+ while (++w != wLim);
+}
+
+void Z7_FASTCALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)
+{
+ unsigned i, num;
+ Aes_SetKey_Enc(w, key, keySize);
+ num = keySize + 20;
+ w += 8;
+ for (i = 0; i < num; i++)
+ {
+ UInt32 r = w[i];
+ w[i] =
+ DD(0)[Sbox[gb0(r)]] ^
+ DD(1)[Sbox[gb1(r)]] ^
+ DD(2)[Sbox[gb2(r)]] ^
+ DD(3)[Sbox[gb3(r)]];
+ }
+}
+
+/* Aes_Encode and Aes_Decode functions work with little-endian words.
+ src and dest are pointers to 4 UInt32 words.
+ src and dest can point to same block */
+
+// Z7_FORCE_INLINE
+static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
+{
+ UInt32 s[4];
+ UInt32 m[4];
+ UInt32 numRounds2 = w[0];
+ w += 4;
+ s[0] = src[0] ^ w[0];
+ s[1] = src[1] ^ w[1];
+ s[2] = src[2] ^ w[2];
+ s[3] = src[3] ^ w[3];
+ w += 4;
+ for (;;)
+ {
+ HT16(m, s, 0)
+ if (--numRounds2 == 0)
+ break;
+ HT16(s, m, 4)
+ w += 8;
+ }
+ w += 4;
+ FT4(0)
+ FT4(1)
+ FT4(2)
+ FT4(3)
+}
+
+Z7_FORCE_INLINE
+static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)
+{
+ UInt32 s[4];
+ UInt32 m[4];
+ UInt32 numRounds2 = w[0];
+ w += 4 + numRounds2 * 8;
+ s[0] = src[0] ^ w[0];
+ s[1] = src[1] ^ w[1];
+ s[2] = src[2] ^ w[2];
+ s[3] = src[3] ^ w[3];
+ for (;;)
+ {
+ w -= 8;
+ HD16(m, s, 4)
+ if (--numRounds2 == 0)
+ break;
+ HD16(s, m, 0)
+ }
+ FD4(0)
+ FD4(1)
+ FD4(2)
+ FD4(3)
+}
+
+void AesCbc_Init(UInt32 *p, const Byte *iv)
+{
+ unsigned i;
+ for (i = 0; i < 4; i++)
+ p[i] = GetUi32(iv + i * 4);
+}
+
+void Z7_FASTCALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)
+{
+ for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
+ {
+ p[0] ^= GetUi32(data);
+ p[1] ^= GetUi32(data + 4);
+ p[2] ^= GetUi32(data + 8);
+ p[3] ^= GetUi32(data + 12);
+
+ Aes_Encode(p + 4, p, p);
+
+ SetUi32(data, p[0])
+ SetUi32(data + 4, p[1])
+ SetUi32(data + 8, p[2])
+ SetUi32(data + 12, p[3])
+ }
+}
+
+void Z7_FASTCALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)
+{
+ UInt32 in[4], out[4];
+ for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)
+ {
+ in[0] = GetUi32(data);
+ in[1] = GetUi32(data + 4);
+ in[2] = GetUi32(data + 8);
+ in[3] = GetUi32(data + 12);
+
+ Aes_Decode(p + 4, out, in);
+
+ SetUi32(data, p[0] ^ out[0])
+ SetUi32(data + 4, p[1] ^ out[1])
+ SetUi32(data + 8, p[2] ^ out[2])
+ SetUi32(data + 12, p[3] ^ out[3])
+
+ p[0] = in[0];
+ p[1] = in[1];
+ p[2] = in[2];
+ p[3] = in[3];
+ }
+}
+
+void Z7_FASTCALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)
+{
+ for (; numBlocks != 0; numBlocks--)
+ {
+ UInt32 temp[4];
+ unsigned i;
+
+ if (++p[0] == 0)
+ p[1]++;
+
+ Aes_Encode(p + 4, temp, p);
+
+ for (i = 0; i < 4; i++, data += 4)
+ {
+ const UInt32 t = temp[i];
+
+ #ifdef MY_CPU_LE_UNALIGN
+ *((UInt32 *)(void *)data) ^= t;
+ #else
+ data[0] = (Byte)(data[0] ^ (t & 0xFF));
+ data[1] = (Byte)(data[1] ^ ((t >> 8) & 0xFF));
+ data[2] = (Byte)(data[2] ^ ((t >> 16) & 0xFF));
+ data[3] = (Byte)(data[3] ^ ((t >> 24)));
+ #endif
+ }
+ }
+}
+
+#undef xtime
+#undef Ui32
+#undef gb0
+#undef gb1
+#undef gb2
+#undef gb3
+#undef gb
+#undef TT
+#undef DD
+#undef USE_HW_AES
+#undef PRF
diff --git a/C/Aes.h b/C/Aes.h
index 381e979..7f0182a 100644
--- a/C/Aes.h
+++ b/C/Aes.h
@@ -1,38 +1,60 @@
-/* Aes.h -- AES encryption / decryption
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __AES_H
-#define __AES_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define AES_BLOCK_SIZE 16
-
-/* Call AesGenTables one time before other AES functions */
-void AesGenTables(void);
-
-/* UInt32 pointers must be 16-byte aligned */
-
-/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */
-#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)
-
-/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */
-/* keySize = 16 or 24 or 32 (bytes) */
-typedef void (MY_FAST_CALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);
-void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);
-void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);
-
-/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */
-void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
-/* data - 16-byte aligned pointer to data */
-/* numBlocks - the number of 16-byte blocks in data array */
-typedef void (MY_FAST_CALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);
-extern AES_CODE_FUNC g_AesCbc_Encode;
-extern AES_CODE_FUNC g_AesCbc_Decode;
-extern AES_CODE_FUNC g_AesCtr_Code;
-
-EXTERN_C_END
-
-#endif
+/* Aes.h -- AES encryption / decryption
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_AES_H
+#define ZIP7_INC_AES_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define AES_BLOCK_SIZE 16
+
+/* Call AesGenTables one time before other AES functions */
+void AesGenTables(void);
+
+/* UInt32 pointers must be 16-byte aligned */
+
+/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */
+#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)
+
+/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */
+/* keySize = 16 or 24 or 32 (bytes) */
+typedef void (Z7_FASTCALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);
+void Z7_FASTCALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);
+void Z7_FASTCALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);
+
+/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */
+void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */
+
+/* data - 16-byte aligned pointer to data */
+/* numBlocks - the number of 16-byte blocks in data array */
+typedef void (Z7_FASTCALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);
+
+extern AES_CODE_FUNC g_AesCbc_Decode;
+#ifndef Z7_SFX
+extern AES_CODE_FUNC g_AesCbc_Encode;
+extern AES_CODE_FUNC g_AesCtr_Code;
+#define k_Aes_SupportedFunctions_HW (1 << 2)
+#define k_Aes_SupportedFunctions_HW_256 (1 << 3)
+extern UInt32 g_Aes_SupportedFunctions_Flags;
+#endif
+
+
+#define Z7_DECLARE_AES_CODE_FUNC(funcName) \
+ void Z7_FASTCALL funcName(UInt32 *ivAes, Byte *data, size_t numBlocks);
+
+Z7_DECLARE_AES_CODE_FUNC (AesCbc_Encode)
+Z7_DECLARE_AES_CODE_FUNC (AesCbc_Decode)
+Z7_DECLARE_AES_CODE_FUNC (AesCtr_Code)
+
+Z7_DECLARE_AES_CODE_FUNC (AesCbc_Encode_HW)
+Z7_DECLARE_AES_CODE_FUNC (AesCbc_Decode_HW)
+Z7_DECLARE_AES_CODE_FUNC (AesCtr_Code_HW)
+
+Z7_DECLARE_AES_CODE_FUNC (AesCbc_Decode_HW_256)
+Z7_DECLARE_AES_CODE_FUNC (AesCtr_Code_HW_256)
+
+EXTERN_C_END
+
+#endif
diff --git a/C/AesOpt.c b/C/AesOpt.c
index 0e7f49a..cfa6413 100644
--- a/C/AesOpt.c
+++ b/C/AesOpt.c
@@ -1,184 +1,840 @@
-/* AesOpt.c -- Intel's AES
-2017-06-08 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-
-#ifdef MY_CPU_X86_OR_AMD64
-#if (_MSC_VER > 1500) || (_MSC_FULL_VER >= 150030729)
-#define USE_INTEL_AES
-#endif
-#endif
-
-#ifdef USE_INTEL_AES
-
-#include <wmmintrin.h>
-
-void MY_FAST_CALL AesCbc_Encode_Intel(__m128i *p, __m128i *data, size_t numBlocks)
-{
- __m128i m = *p;
- for (; numBlocks != 0; numBlocks--, data++)
- {
- UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
- const __m128i *w = p + 3;
- m = _mm_xor_si128(m, *data);
- m = _mm_xor_si128(m, p[2]);
- do
- {
- m = _mm_aesenc_si128(m, w[0]);
- m = _mm_aesenc_si128(m, w[1]);
- w += 2;
- }
- while (--numRounds2 != 0);
- m = _mm_aesenc_si128(m, w[0]);
- m = _mm_aesenclast_si128(m, w[1]);
- *data = m;
- }
- *p = m;
-}
-
-#define NUM_WAYS 3
-
-#define AES_OP_W(op, n) { \
- const __m128i t = w[n]; \
- m0 = op(m0, t); \
- m1 = op(m1, t); \
- m2 = op(m2, t); \
- }
-
-#define AES_DEC(n) AES_OP_W(_mm_aesdec_si128, n)
-#define AES_DEC_LAST(n) AES_OP_W(_mm_aesdeclast_si128, n)
-#define AES_ENC(n) AES_OP_W(_mm_aesenc_si128, n)
-#define AES_ENC_LAST(n) AES_OP_W(_mm_aesenclast_si128, n)
-
-void MY_FAST_CALL AesCbc_Decode_Intel(__m128i *p, __m128i *data, size_t numBlocks)
-{
- __m128i iv = *p;
- for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)
- {
- UInt32 numRounds2 = *(const UInt32 *)(p + 1);
- const __m128i *w = p + numRounds2 * 2;
- __m128i m0, m1, m2;
- {
- const __m128i t = w[2];
- m0 = _mm_xor_si128(t, data[0]);
- m1 = _mm_xor_si128(t, data[1]);
- m2 = _mm_xor_si128(t, data[2]);
- }
- numRounds2--;
- do
- {
- AES_DEC(1)
- AES_DEC(0)
- w -= 2;
- }
- while (--numRounds2 != 0);
- AES_DEC(1)
- AES_DEC_LAST(0)
-
- {
- __m128i t;
- t = _mm_xor_si128(m0, iv); iv = data[0]; data[0] = t;
- t = _mm_xor_si128(m1, iv); iv = data[1]; data[1] = t;
- t = _mm_xor_si128(m2, iv); iv = data[2]; data[2] = t;
- }
- }
- for (; numBlocks != 0; numBlocks--, data++)
- {
- UInt32 numRounds2 = *(const UInt32 *)(p + 1);
- const __m128i *w = p + numRounds2 * 2;
- __m128i m = _mm_xor_si128(w[2], *data);
- numRounds2--;
- do
- {
- m = _mm_aesdec_si128(m, w[1]);
- m = _mm_aesdec_si128(m, w[0]);
- w -= 2;
- }
- while (--numRounds2 != 0);
- m = _mm_aesdec_si128(m, w[1]);
- m = _mm_aesdeclast_si128(m, w[0]);
-
- m = _mm_xor_si128(m, iv);
- iv = *data;
- *data = m;
- }
- *p = iv;
-}
-
-void MY_FAST_CALL AesCtr_Code_Intel(__m128i *p, __m128i *data, size_t numBlocks)
-{
- __m128i ctr = *p;
- __m128i one;
- one.m128i_u64[0] = 1;
- one.m128i_u64[1] = 0;
- for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)
- {
- UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
- const __m128i *w = p;
- __m128i m0, m1, m2;
- {
- const __m128i t = w[2];
- ctr = _mm_add_epi64(ctr, one); m0 = _mm_xor_si128(ctr, t);
- ctr = _mm_add_epi64(ctr, one); m1 = _mm_xor_si128(ctr, t);
- ctr = _mm_add_epi64(ctr, one); m2 = _mm_xor_si128(ctr, t);
- }
- w += 3;
- do
- {
- AES_ENC(0)
- AES_ENC(1)
- w += 2;
- }
- while (--numRounds2 != 0);
- AES_ENC(0)
- AES_ENC_LAST(1)
- data[0] = _mm_xor_si128(data[0], m0);
- data[1] = _mm_xor_si128(data[1], m1);
- data[2] = _mm_xor_si128(data[2], m2);
- }
- for (; numBlocks != 0; numBlocks--, data++)
- {
- UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
- const __m128i *w = p;
- __m128i m;
- ctr = _mm_add_epi64(ctr, one);
- m = _mm_xor_si128(ctr, p[2]);
- w += 3;
- do
- {
- m = _mm_aesenc_si128(m, w[0]);
- m = _mm_aesenc_si128(m, w[1]);
- w += 2;
- }
- while (--numRounds2 != 0);
- m = _mm_aesenc_si128(m, w[0]);
- m = _mm_aesenclast_si128(m, w[1]);
- *data = _mm_xor_si128(*data, m);
- }
- *p = ctr;
-}
-
-#else
-
-void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *p, Byte *data, size_t numBlocks)
-{
- AesCbc_Encode(p, data, numBlocks);
-}
-
-void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *p, Byte *data, size_t numBlocks)
-{
- AesCbc_Decode(p, data, numBlocks);
-}
-
-void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *p, Byte *data, size_t numBlocks)
-{
- AesCtr_Code(p, data, numBlocks);
-}
-
-#endif
+/* AesOpt.c -- AES optimized code for x86 AES hardware instructions
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Aes.h"
+#include "CpuArch.h"
+
+#ifdef MY_CPU_X86_OR_AMD64
+
+ #if defined(__INTEL_COMPILER)
+ #if (__INTEL_COMPILER >= 1110)
+ #define USE_INTEL_AES
+ #if (__INTEL_COMPILER >= 1900)
+ #define USE_INTEL_VAES
+ #endif
+ #endif
+ #elif defined(__clang__) && (__clang_major__ > 3 || __clang_major__ == 3 && __clang_minor__ >= 8) \
+ || defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4)
+ #define USE_INTEL_AES
+ #if !defined(__AES__)
+ #define ATTRIB_AES __attribute__((__target__("aes")))
+ #endif
+ #if defined(__clang__) && (__clang_major__ >= 8) \
+ || defined(__GNUC__) && (__GNUC__ >= 8)
+ #define USE_INTEL_VAES
+ #if !defined(__AES__) || !defined(__VAES__) || !defined(__AVX__) || !defined(__AVX2__)
+ #define ATTRIB_VAES __attribute__((__target__("aes,vaes,avx,avx2")))
+ #endif
+ #endif
+ #elif defined(_MSC_VER)
+ #if (_MSC_VER > 1500) || (_MSC_FULL_VER >= 150030729)
+ #define USE_INTEL_AES
+ #if (_MSC_VER >= 1910)
+ #define USE_INTEL_VAES
+ #endif
+ #endif
+ #endif
+
+#ifndef ATTRIB_AES
+ #define ATTRIB_AES
+#endif
+#ifndef ATTRIB_VAES
+ #define ATTRIB_VAES
+#endif
+
+
+#ifdef USE_INTEL_AES
+
+#include <wmmintrin.h>
+
+#ifndef USE_INTEL_VAES
+#define AES_TYPE_keys UInt32
+#define AES_TYPE_data Byte
+// #define AES_TYPE_keys __m128i
+// #define AES_TYPE_data __m128i
+#endif
+
+#define AES_FUNC_START(name) \
+ void Z7_FASTCALL name(UInt32 *ivAes, Byte *data8, size_t numBlocks)
+ // void Z7_FASTCALL name(__m128i *p, __m128i *data, size_t numBlocks)
+
+#define AES_FUNC_START2(name) \
+AES_FUNC_START (name); \
+ATTRIB_AES \
+AES_FUNC_START (name)
+
+#define MM_OP(op, dest, src) dest = op(dest, src);
+#define MM_OP_m(op, src) MM_OP(op, m, src)
+
+#define MM_XOR( dest, src) MM_OP(_mm_xor_si128, dest, src)
+#define AVX_XOR(dest, src) MM_OP(_mm256_xor_si256, dest, src)
+
+
+AES_FUNC_START2 (AesCbc_Encode_HW)
+{
+ __m128i *p = (__m128i *)(void *)ivAes;
+ __m128i *data = (__m128i *)(void *)data8;
+ __m128i m = *p;
+ const __m128i k0 = p[2];
+ const __m128i k1 = p[3];
+ const UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
+ for (; numBlocks != 0; numBlocks--, data++)
+ {
+ UInt32 r = numRounds2;
+ const __m128i *w = p + 4;
+ __m128i temp = *data;
+ MM_XOR (temp, k0)
+ MM_XOR (m, temp)
+ MM_OP_m (_mm_aesenc_si128, k1)
+ do
+ {
+ MM_OP_m (_mm_aesenc_si128, w[0])
+ MM_OP_m (_mm_aesenc_si128, w[1])
+ w += 2;
+ }
+ while (--r);
+ MM_OP_m (_mm_aesenclast_si128, w[0])
+ *data = m;
+ }
+ *p = m;
+}
+
+
+#define WOP_1(op)
+#define WOP_2(op) WOP_1 (op) op (m1, 1)
+#define WOP_3(op) WOP_2 (op) op (m2, 2)
+#define WOP_4(op) WOP_3 (op) op (m3, 3)
+#ifdef MY_CPU_AMD64
+#define WOP_5(op) WOP_4 (op) op (m4, 4)
+#define WOP_6(op) WOP_5 (op) op (m5, 5)
+#define WOP_7(op) WOP_6 (op) op (m6, 6)
+#define WOP_8(op) WOP_7 (op) op (m7, 7)
+#endif
+/*
+#define WOP_9(op) WOP_8 (op) op (m8, 8);
+#define WOP_10(op) WOP_9 (op) op (m9, 9);
+#define WOP_11(op) WOP_10(op) op (m10, 10);
+#define WOP_12(op) WOP_11(op) op (m11, 11);
+#define WOP_13(op) WOP_12(op) op (m12, 12);
+#define WOP_14(op) WOP_13(op) op (m13, 13);
+*/
+
+#ifdef MY_CPU_AMD64
+ #define NUM_WAYS 8
+ #define WOP_M1 WOP_8
+#else
+ #define NUM_WAYS 4
+ #define WOP_M1 WOP_4
+#endif
+
+#define WOP(op) op (m0, 0) WOP_M1(op)
+
+
+#define DECLARE_VAR(reg, ii) __m128i reg;
+#define LOAD_data( reg, ii) reg = data[ii];
+#define STORE_data( reg, ii) data[ii] = reg;
+#if (NUM_WAYS > 1)
+#define XOR_data_M1(reg, ii) MM_XOR (reg, data[ii- 1])
+#endif
+
+#define AVX_DECLARE_VAR(reg, ii) __m256i reg;
+#define AVX_LOAD_data( reg, ii) reg = ((const __m256i *)(const void *)data)[ii];
+#define AVX_STORE_data( reg, ii) ((__m256i *)(void *)data)[ii] = reg;
+#define AVX_XOR_data_M1(reg, ii) AVX_XOR (reg, (((const __m256i *)(const void *)(data - 1))[ii]))
+
+#define MM_OP_key(op, reg) MM_OP(op, reg, key);
+
+#define AES_DEC( reg, ii) MM_OP_key (_mm_aesdec_si128, reg)
+#define AES_DEC_LAST( reg, ii) MM_OP_key (_mm_aesdeclast_si128, reg)
+#define AES_ENC( reg, ii) MM_OP_key (_mm_aesenc_si128, reg)
+#define AES_ENC_LAST( reg, ii) MM_OP_key (_mm_aesenclast_si128, reg)
+#define AES_XOR( reg, ii) MM_OP_key (_mm_xor_si128, reg)
+
+
+#define AVX_AES_DEC( reg, ii) MM_OP_key (_mm256_aesdec_epi128, reg)
+#define AVX_AES_DEC_LAST( reg, ii) MM_OP_key (_mm256_aesdeclast_epi128, reg)
+#define AVX_AES_ENC( reg, ii) MM_OP_key (_mm256_aesenc_epi128, reg)
+#define AVX_AES_ENC_LAST( reg, ii) MM_OP_key (_mm256_aesenclast_epi128, reg)
+#define AVX_AES_XOR( reg, ii) MM_OP_key (_mm256_xor_si256, reg)
+
+#define CTR_START(reg, ii) MM_OP (_mm_add_epi64, ctr, one) reg = ctr;
+#define CTR_END( reg, ii) MM_XOR (data[ii], reg)
+
+#define AVX_CTR_START(reg, ii) MM_OP (_mm256_add_epi64, ctr2, two) reg = _mm256_xor_si256(ctr2, key);
+#define AVX_CTR_END( reg, ii) AVX_XOR (((__m256i *)(void *)data)[ii], reg)
+
+#define WOP_KEY(op, n) { \
+ const __m128i key = w[n]; \
+ WOP(op); }
+
+#define AVX_WOP_KEY(op, n) { \
+ const __m256i key = w[n]; \
+ WOP(op); }
+
+
+#define WIDE_LOOP_START \
+ dataEnd = data + numBlocks; \
+ if (numBlocks >= NUM_WAYS) \
+ { dataEnd -= NUM_WAYS; do { \
+
+
+#define WIDE_LOOP_END \
+ data += NUM_WAYS; \
+ } while (data <= dataEnd); \
+ dataEnd += NUM_WAYS; } \
+
+
+#define SINGLE_LOOP \
+ for (; data < dataEnd; data++)
+
+
+#define NUM_AES_KEYS_MAX 15
+
+#define WIDE_LOOP_START_AVX(OP) \
+ dataEnd = data + numBlocks; \
+ if (numBlocks >= NUM_WAYS * 2) \
+ { __m256i keys[NUM_AES_KEYS_MAX]; \
+ UInt32 ii; \
+ OP \
+ for (ii = 0; ii < numRounds; ii++) \
+ keys[ii] = _mm256_broadcastsi128_si256(p[ii]); \
+ dataEnd -= NUM_WAYS * 2; do { \
+
+
+#define WIDE_LOOP_END_AVX(OP) \
+ data += NUM_WAYS * 2; \
+ } while (data <= dataEnd); \
+ dataEnd += NUM_WAYS * 2; \
+ OP \
+ _mm256_zeroupper(); \
+ } \
+
+/* MSVC for x86: If we don't call _mm256_zeroupper(), and -arch:IA32 is not specified,
+ MSVC still can insert vzeroupper instruction. */
+
+
+AES_FUNC_START2 (AesCbc_Decode_HW)
+{
+ __m128i *p = (__m128i *)(void *)ivAes;
+ __m128i *data = (__m128i *)(void *)data8;
+ __m128i iv = *p;
+ const __m128i *wStart = p + *(const UInt32 *)(p + 1) * 2 + 2 - 1;
+ const __m128i *dataEnd;
+ p += 2;
+
+ WIDE_LOOP_START
+ {
+ const __m128i *w = wStart;
+
+ WOP (DECLARE_VAR)
+ WOP (LOAD_data)
+ WOP_KEY (AES_XOR, 1)
+
+ do
+ {
+ WOP_KEY (AES_DEC, 0)
+ w--;
+ }
+ while (w != p);
+ WOP_KEY (AES_DEC_LAST, 0)
+
+ MM_XOR (m0, iv)
+ WOP_M1 (XOR_data_M1)
+ iv = data[NUM_WAYS - 1];
+ WOP (STORE_data)
+ }
+ WIDE_LOOP_END
+
+ SINGLE_LOOP
+ {
+ const __m128i *w = wStart - 1;
+ __m128i m = _mm_xor_si128 (w[2], *data);
+ do
+ {
+ MM_OP_m (_mm_aesdec_si128, w[1])
+ MM_OP_m (_mm_aesdec_si128, w[0])
+ w -= 2;
+ }
+ while (w != p);
+ MM_OP_m (_mm_aesdec_si128, w[1])
+ MM_OP_m (_mm_aesdeclast_si128, w[0])
+
+ MM_XOR (m, iv)
+ iv = *data;
+ *data = m;
+ }
+
+ p[-2] = iv;
+}
+
+
+AES_FUNC_START2 (AesCtr_Code_HW)
+{
+ __m128i *p = (__m128i *)(void *)ivAes;
+ __m128i *data = (__m128i *)(void *)data8;
+ __m128i ctr = *p;
+ UInt32 numRoundsMinus2 = *(const UInt32 *)(p + 1) * 2 - 1;
+ const __m128i *dataEnd;
+ __m128i one = _mm_cvtsi32_si128(1);
+
+ p += 2;
+
+ WIDE_LOOP_START
+ {
+ const __m128i *w = p;
+ UInt32 r = numRoundsMinus2;
+ WOP (DECLARE_VAR)
+ WOP (CTR_START)
+ WOP_KEY (AES_XOR, 0)
+ w += 1;
+ do
+ {
+ WOP_KEY (AES_ENC, 0)
+ w += 1;
+ }
+ while (--r);
+ WOP_KEY (AES_ENC_LAST, 0)
+
+ WOP (CTR_END)
+ }
+ WIDE_LOOP_END
+
+ SINGLE_LOOP
+ {
+ UInt32 numRounds2 = *(const UInt32 *)(p - 2 + 1) - 1;
+ const __m128i *w = p;
+ __m128i m;
+ MM_OP (_mm_add_epi64, ctr, one)
+ m = _mm_xor_si128 (ctr, p[0]);
+ w += 1;
+ do
+ {
+ MM_OP_m (_mm_aesenc_si128, w[0])
+ MM_OP_m (_mm_aesenc_si128, w[1])
+ w += 2;
+ }
+ while (--numRounds2);
+ MM_OP_m (_mm_aesenc_si128, w[0])
+ MM_OP_m (_mm_aesenclast_si128, w[1])
+ MM_XOR (*data, m)
+ }
+
+ p[-2] = ctr;
+}
+
+
+
+#ifdef USE_INTEL_VAES
+
+/*
+GCC before 2013-Jun:
+ <immintrin.h>:
+ #ifdef __AVX__
+ #include <avxintrin.h>
+ #endif
+GCC after 2013-Jun:
+ <immintrin.h>:
+ #include <avxintrin.h>
+CLANG 3.8+:
+{
+ <immintrin.h>:
+ #if !defined(_MSC_VER) || defined(__AVX__)
+ #include <avxintrin.h>
+ #endif
+
+ if (the compiler is clang for Windows and if global arch is not set for __AVX__)
+ [ if (defined(_MSC_VER) && !defined(__AVX__)) ]
+ {
+ <immintrin.h> doesn't include <avxintrin.h>
+ and we have 2 ways to fix it:
+ 1) we can define required __AVX__ before <immintrin.h>
+ or
+ 2) we can include <avxintrin.h> after <immintrin.h>
+ }
+}
+
+If we include <avxintrin.h> manually for GCC/CLANG, it's
+required that <immintrin.h> must be included before <avxintrin.h>.
+*/
+
+/*
+#if defined(__clang__) && defined(_MSC_VER)
+#define __AVX__
+#define __AVX2__
+#define __VAES__
+#endif
+*/
+
+#include <immintrin.h>
+#if defined(__clang__) && defined(_MSC_VER)
+ #if !defined(__AVX__)
+ #include <avxintrin.h>
+ #endif
+ #if !defined(__AVX2__)
+ #include <avx2intrin.h>
+ #endif
+ #if !defined(__VAES__)
+ #include <vaesintrin.h>
+ #endif
+#endif // __clang__ && _MSC_VER
+
+
+#define VAES_FUNC_START2(name) \
+AES_FUNC_START (name); \
+ATTRIB_VAES \
+AES_FUNC_START (name)
+
+VAES_FUNC_START2 (AesCbc_Decode_HW_256)
+{
+ __m128i *p = (__m128i *)(void *)ivAes;
+ __m128i *data = (__m128i *)(void *)data8;
+ __m128i iv = *p;
+ const __m128i *dataEnd;
+ UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
+ p += 2;
+
+ WIDE_LOOP_START_AVX(;)
+ {
+ const __m256i *w = keys + numRounds - 2;
+
+ WOP (AVX_DECLARE_VAR)
+ WOP (AVX_LOAD_data)
+ AVX_WOP_KEY (AVX_AES_XOR, 1)
+
+ do
+ {
+ AVX_WOP_KEY (AVX_AES_DEC, 0)
+ w--;
+ }
+ while (w != keys);
+ AVX_WOP_KEY (AVX_AES_DEC_LAST, 0)
+
+ AVX_XOR (m0, _mm256_setr_m128i(iv, data[0]))
+ WOP_M1 (AVX_XOR_data_M1)
+ iv = data[NUM_WAYS * 2 - 1];
+ WOP (AVX_STORE_data)
+ }
+ WIDE_LOOP_END_AVX(;)
+
+ SINGLE_LOOP
+ {
+ const __m128i *w = p + *(const UInt32 *)(p + 1 - 2) * 2 + 1 - 3;
+ __m128i m = _mm_xor_si128 (w[2], *data);
+ do
+ {
+ MM_OP_m (_mm_aesdec_si128, w[1])
+ MM_OP_m (_mm_aesdec_si128, w[0])
+ w -= 2;
+ }
+ while (w != p);
+ MM_OP_m (_mm_aesdec_si128, w[1])
+ MM_OP_m (_mm_aesdeclast_si128, w[0])
+
+ MM_XOR (m, iv)
+ iv = *data;
+ *data = m;
+ }
+
+ p[-2] = iv;
+}
+
+
+/*
+SSE2: _mm_cvtsi32_si128 : movd
+AVX: _mm256_setr_m128i : vinsertf128
+AVX2: _mm256_add_epi64 : vpaddq ymm, ymm, ymm
+ _mm256_extracti128_si256 : vextracti128
+ _mm256_broadcastsi128_si256 : vbroadcasti128
+*/
+
+#define AVX_CTR_LOOP_START \
+ ctr2 = _mm256_setr_m128i(_mm_sub_epi64(ctr, one), ctr); \
+ two = _mm256_setr_m128i(one, one); \
+ two = _mm256_add_epi64(two, two); \
+
+// two = _mm256_setr_epi64x(2, 0, 2, 0);
+
+#define AVX_CTR_LOOP_ENC \
+ ctr = _mm256_extracti128_si256 (ctr2, 1); \
+
+VAES_FUNC_START2 (AesCtr_Code_HW_256)
+{
+ __m128i *p = (__m128i *)(void *)ivAes;
+ __m128i *data = (__m128i *)(void *)data8;
+ __m128i ctr = *p;
+ UInt32 numRounds = *(const UInt32 *)(p + 1) * 2 + 1;
+ const __m128i *dataEnd;
+ __m128i one = _mm_cvtsi32_si128(1);
+ __m256i ctr2, two;
+ p += 2;
+
+ WIDE_LOOP_START_AVX (AVX_CTR_LOOP_START)
+ {
+ const __m256i *w = keys;
+ UInt32 r = numRounds - 2;
+ WOP (AVX_DECLARE_VAR)
+ AVX_WOP_KEY (AVX_CTR_START, 0)
+
+ w += 1;
+ do
+ {
+ AVX_WOP_KEY (AVX_AES_ENC, 0)
+ w += 1;
+ }
+ while (--r);
+ AVX_WOP_KEY (AVX_AES_ENC_LAST, 0)
+
+ WOP (AVX_CTR_END)
+ }
+ WIDE_LOOP_END_AVX (AVX_CTR_LOOP_ENC)
+
+ SINGLE_LOOP
+ {
+ UInt32 numRounds2 = *(const UInt32 *)(p - 2 + 1) - 1;
+ const __m128i *w = p;
+ __m128i m;
+ MM_OP (_mm_add_epi64, ctr, one)
+ m = _mm_xor_si128 (ctr, p[0]);
+ w += 1;
+ do
+ {
+ MM_OP_m (_mm_aesenc_si128, w[0])
+ MM_OP_m (_mm_aesenc_si128, w[1])
+ w += 2;
+ }
+ while (--numRounds2);
+ MM_OP_m (_mm_aesenc_si128, w[0])
+ MM_OP_m (_mm_aesenclast_si128, w[1])
+ MM_XOR (*data, m)
+ }
+
+ p[-2] = ctr;
+}
+
+#endif // USE_INTEL_VAES
+
+#else // USE_INTEL_AES
+
+/* no USE_INTEL_AES */
+
+#pragma message("AES HW_SW stub was used")
+
+#define AES_TYPE_keys UInt32
+#define AES_TYPE_data Byte
+
+#define AES_FUNC_START(name) \
+ void Z7_FASTCALL name(UInt32 *p, Byte *data, size_t numBlocks) \
+
+#define AES_COMPAT_STUB(name) \
+ AES_FUNC_START(name); \
+ AES_FUNC_START(name ## _HW) \
+ { name(p, data, numBlocks); }
+
+AES_COMPAT_STUB (AesCbc_Encode)
+AES_COMPAT_STUB (AesCbc_Decode)
+AES_COMPAT_STUB (AesCtr_Code)
+
+#endif // USE_INTEL_AES
+
+
+#ifndef USE_INTEL_VAES
+
+#pragma message("VAES HW_SW stub was used")
+
+#define VAES_COMPAT_STUB(name) \
+ void Z7_FASTCALL name ## _256(UInt32 *p, Byte *data, size_t numBlocks); \
+ void Z7_FASTCALL name ## _256(UInt32 *p, Byte *data, size_t numBlocks) \
+ { name((AES_TYPE_keys *)(void *)p, (AES_TYPE_data *)(void *)data, numBlocks); }
+
+VAES_COMPAT_STUB (AesCbc_Decode_HW)
+VAES_COMPAT_STUB (AesCtr_Code_HW)
+
+#endif // ! USE_INTEL_VAES
+
+
+#elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
+
+ #if defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define USE_HW_AES
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define USE_HW_AES
+ #endif
+ #elif defined(_MSC_VER)
+ #if _MSC_VER >= 1910
+ #define USE_HW_AES
+ #endif
+ #endif
+
+#ifdef USE_HW_AES
+
+// #pragma message("=== AES HW === ")
+
+#if defined(__clang__) || defined(__GNUC__)
+ #ifdef MY_CPU_ARM64
+ #define ATTRIB_AES __attribute__((__target__("+crypto")))
+ #else
+ #define ATTRIB_AES __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
+ #endif
+#else
+ // _MSC_VER
+ // for arm32
+ #define _ARM_USE_NEW_NEON_INTRINSICS
+#endif
+
+#ifndef ATTRIB_AES
+ #define ATTRIB_AES
+#endif
+
+#if defined(_MSC_VER) && defined(MY_CPU_ARM64)
+#include <arm64_neon.h>
+#else
+#include <arm_neon.h>
+#endif
+
+typedef uint8x16_t v128;
+
+#define AES_FUNC_START(name) \
+ void Z7_FASTCALL name(UInt32 *ivAes, Byte *data8, size_t numBlocks)
+ // void Z7_FASTCALL name(v128 *p, v128 *data, size_t numBlocks)
+
+#define AES_FUNC_START2(name) \
+AES_FUNC_START (name); \
+ATTRIB_AES \
+AES_FUNC_START (name)
+
+#define MM_OP(op, dest, src) dest = op(dest, src);
+#define MM_OP_m(op, src) MM_OP(op, m, src)
+#define MM_OP1_m(op) m = op(m);
+
+#define MM_XOR( dest, src) MM_OP(veorq_u8, dest, src)
+#define MM_XOR_m( src) MM_XOR(m, src)
+
+#define AES_E_m(k) MM_OP_m (vaeseq_u8, k)
+#define AES_E_MC_m(k) AES_E_m (k) MM_OP1_m(vaesmcq_u8)
+
+
+AES_FUNC_START2 (AesCbc_Encode_HW)
+{
+ v128 *p = (v128*)(void*)ivAes;
+ v128 *data = (v128*)(void*)data8;
+ v128 m = *p;
+ const v128 k0 = p[2];
+ const v128 k1 = p[3];
+ const v128 k2 = p[4];
+ const v128 k3 = p[5];
+ const v128 k4 = p[6];
+ const v128 k5 = p[7];
+ const v128 k6 = p[8];
+ const v128 k7 = p[9];
+ const v128 k8 = p[10];
+ const v128 k9 = p[11];
+ const UInt32 numRounds2 = *(const UInt32 *)(p + 1);
+ const v128 *w = p + ((size_t)numRounds2 * 2);
+ const v128 k_z1 = w[1];
+ const v128 k_z0 = w[2];
+ for (; numBlocks != 0; numBlocks--, data++)
+ {
+ MM_XOR_m (*data);
+ AES_E_MC_m (k0)
+ AES_E_MC_m (k1)
+ AES_E_MC_m (k2)
+ AES_E_MC_m (k3)
+ AES_E_MC_m (k4)
+ AES_E_MC_m (k5)
+ AES_E_MC_m (k6)
+ AES_E_MC_m (k7)
+ AES_E_MC_m (k8)
+ if (numRounds2 >= 6)
+ {
+ AES_E_MC_m (k9)
+ AES_E_MC_m (p[12])
+ if (numRounds2 != 6)
+ {
+ AES_E_MC_m (p[13])
+ AES_E_MC_m (p[14])
+ }
+ }
+ AES_E_m (k_z1)
+ MM_XOR_m (k_z0);
+ *data = m;
+ }
+ *p = m;
+}
+
+
+#define WOP_1(op)
+#define WOP_2(op) WOP_1 (op) op (m1, 1)
+#define WOP_3(op) WOP_2 (op) op (m2, 2)
+#define WOP_4(op) WOP_3 (op) op (m3, 3)
+#define WOP_5(op) WOP_4 (op) op (m4, 4)
+#define WOP_6(op) WOP_5 (op) op (m5, 5)
+#define WOP_7(op) WOP_6 (op) op (m6, 6)
+#define WOP_8(op) WOP_7 (op) op (m7, 7)
+
+ #define NUM_WAYS 8
+ #define WOP_M1 WOP_8
+
+#define WOP(op) op (m0, 0) WOP_M1(op)
+
+#define DECLARE_VAR(reg, ii) v128 reg;
+#define LOAD_data( reg, ii) reg = data[ii];
+#define STORE_data( reg, ii) data[ii] = reg;
+#if (NUM_WAYS > 1)
+#define XOR_data_M1(reg, ii) MM_XOR (reg, data[ii- 1])
+#endif
+
+#define MM_OP_key(op, reg) MM_OP (op, reg, key)
+
+#define AES_D_m(k) MM_OP_m (vaesdq_u8, k)
+#define AES_D_IMC_m(k) AES_D_m (k) MM_OP1_m (vaesimcq_u8)
+
+#define AES_XOR( reg, ii) MM_OP_key (veorq_u8, reg)
+#define AES_D( reg, ii) MM_OP_key (vaesdq_u8, reg)
+#define AES_E( reg, ii) MM_OP_key (vaeseq_u8, reg)
+
+#define AES_D_IMC( reg, ii) AES_D (reg, ii) reg = vaesimcq_u8(reg);
+#define AES_E_MC( reg, ii) AES_E (reg, ii) reg = vaesmcq_u8(reg);
+
+#define CTR_START(reg, ii) MM_OP (vaddq_u64, ctr, one) reg = vreinterpretq_u8_u64(ctr);
+#define CTR_END( reg, ii) MM_XOR (data[ii], reg)
+
+#define WOP_KEY(op, n) { \
+ const v128 key = w[n]; \
+ WOP(op) }
+
+#define WIDE_LOOP_START \
+ dataEnd = data + numBlocks; \
+ if (numBlocks >= NUM_WAYS) \
+ { dataEnd -= NUM_WAYS; do { \
+
+#define WIDE_LOOP_END \
+ data += NUM_WAYS; \
+ } while (data <= dataEnd); \
+ dataEnd += NUM_WAYS; } \
+
+#define SINGLE_LOOP \
+ for (; data < dataEnd; data++)
+
+
+AES_FUNC_START2 (AesCbc_Decode_HW)
+{
+ v128 *p = (v128*)(void*)ivAes;
+ v128 *data = (v128*)(void*)data8;
+ v128 iv = *p;
+ const v128 *wStart = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
+ const v128 *dataEnd;
+ p += 2;
+
+ WIDE_LOOP_START
+ {
+ const v128 *w = wStart;
+ WOP (DECLARE_VAR)
+ WOP (LOAD_data)
+ WOP_KEY (AES_D_IMC, 2)
+ do
+ {
+ WOP_KEY (AES_D_IMC, 1)
+ WOP_KEY (AES_D_IMC, 0)
+ w -= 2;
+ }
+ while (w != p);
+ WOP_KEY (AES_D, 1)
+ WOP_KEY (AES_XOR, 0)
+ MM_XOR (m0, iv);
+ WOP_M1 (XOR_data_M1)
+ iv = data[NUM_WAYS - 1];
+ WOP (STORE_data)
+ }
+ WIDE_LOOP_END
+
+ SINGLE_LOOP
+ {
+ const v128 *w = wStart;
+ v128 m = *data;
+ AES_D_IMC_m (w[2])
+ do
+ {
+ AES_D_IMC_m (w[1]);
+ AES_D_IMC_m (w[0]);
+ w -= 2;
+ }
+ while (w != p);
+ AES_D_m (w[1]);
+ MM_XOR_m (w[0]);
+ MM_XOR_m (iv);
+ iv = *data;
+ *data = m;
+ }
+
+ p[-2] = iv;
+}
+
+
+AES_FUNC_START2 (AesCtr_Code_HW)
+{
+ v128 *p = (v128*)(void*)ivAes;
+ v128 *data = (v128*)(void*)data8;
+ uint64x2_t ctr = vreinterpretq_u64_u8(*p);
+ const v128 *wEnd = p + ((size_t)*(const UInt32 *)(p + 1)) * 2;
+ const v128 *dataEnd;
+ uint64x2_t one = vdupq_n_u64(0);
+ one = vsetq_lane_u64(1, one, 0);
+ p += 2;
+
+ WIDE_LOOP_START
+ {
+ const v128 *w = p;
+ WOP (DECLARE_VAR)
+ WOP (CTR_START)
+ do
+ {
+ WOP_KEY (AES_E_MC, 0)
+ WOP_KEY (AES_E_MC, 1)
+ w += 2;
+ }
+ while (w != wEnd);
+ WOP_KEY (AES_E_MC, 0)
+ WOP_KEY (AES_E, 1)
+ WOP_KEY (AES_XOR, 2)
+ WOP (CTR_END)
+ }
+ WIDE_LOOP_END
+
+ SINGLE_LOOP
+ {
+ const v128 *w = p;
+ v128 m;
+ CTR_START (m, 0);
+ do
+ {
+ AES_E_MC_m (w[0]);
+ AES_E_MC_m (w[1]);
+ w += 2;
+ }
+ while (w != wEnd);
+ AES_E_MC_m (w[0])
+ AES_E_m (w[1])
+ MM_XOR_m (w[2])
+ CTR_END (m, 0)
+ }
+
+ p[-2] = vreinterpretq_u8_u64(ctr);
+}
+
+#endif // USE_HW_AES
+
+#endif // MY_CPU_ARM_OR_ARM64
+
+#undef NUM_WAYS
+#undef WOP_M1
+#undef WOP
+#undef DECLARE_VAR
+#undef LOAD_data
+#undef STORE_data
+#undef USE_INTEL_AES
+#undef USE_HW_AES
diff --git a/C/Alloc.c b/C/Alloc.c
index 30b499e..d841bf2 100644
--- a/C/Alloc.c
+++ b/C/Alloc.c
@@ -1,455 +1,535 @@
-/* Alloc.c -- Memory allocation functions
-2018-04-27 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <stdio.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-#include <stdlib.h>
-
-#include "Alloc.h"
-
-/* #define _SZ_ALLOC_DEBUG */
-
-/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
-#ifdef _SZ_ALLOC_DEBUG
-
-#include <stdio.h>
-int g_allocCount = 0;
-int g_allocCountMid = 0;
-int g_allocCountBig = 0;
-
-
-#define CONVERT_INT_TO_STR(charType, tempSize) \
- unsigned char temp[tempSize]; unsigned i = 0; \
- while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
- *s++ = (charType)('0' + (unsigned)val); \
- while (i != 0) { i--; *s++ = temp[i]; } \
- *s = 0;
-
-static void ConvertUInt64ToString(UInt64 val, char *s)
-{
- CONVERT_INT_TO_STR(char, 24);
-}
-
-#define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
-
-static void ConvertUInt64ToHex(UInt64 val, char *s)
-{
- UInt64 v = val;
- unsigned i;
- for (i = 1;; i++)
- {
- v >>= 4;
- if (v == 0)
- break;
- }
- s[i] = 0;
- do
- {
- unsigned t = (unsigned)(val & 0xF);
- val >>= 4;
- s[--i] = GET_HEX_CHAR(t);
- }
- while (i);
-}
-
-#define DEBUG_OUT_STREAM stderr
-
-static void Print(const char *s)
-{
- fputs(s, DEBUG_OUT_STREAM);
-}
-
-static void PrintAligned(const char *s, size_t align)
-{
- size_t len = strlen(s);
- for(;;)
- {
- fputc(' ', DEBUG_OUT_STREAM);
- if (len >= align)
- break;
- ++len;
- }
- Print(s);
-}
-
-static void PrintLn()
-{
- Print("\n");
-}
-
-static void PrintHex(UInt64 v, size_t align)
-{
- char s[32];
- ConvertUInt64ToHex(v, s);
- PrintAligned(s, align);
-}
-
-static void PrintDec(UInt64 v, size_t align)
-{
- char s[32];
- ConvertUInt64ToString(v, s);
- PrintAligned(s, align);
-}
-
-static void PrintAddr(void *p)
-{
- PrintHex((UInt64)(size_t)(ptrdiff_t)p, 12);
-}
-
-
-#define PRINT_ALLOC(name, cnt, size, ptr) \
- Print(name " "); \
- PrintDec(cnt++, 10); \
- PrintHex(size, 10); \
- PrintAddr(ptr); \
- PrintLn();
-
-#define PRINT_FREE(name, cnt, ptr) if (ptr) { \
- Print(name " "); \
- PrintDec(--cnt, 10); \
- PrintAddr(ptr); \
- PrintLn(); }
-
-#else
-
-#define PRINT_ALLOC(name, cnt, size, ptr)
-#define PRINT_FREE(name, cnt, ptr)
-#define Print(s)
-#define PrintLn()
-#define PrintHex(v, align)
-#define PrintDec(v, align)
-#define PrintAddr(p)
-
-#endif
-
-
-
-void *MyAlloc(size_t size)
-{
- if (size == 0)
- return NULL;
- #ifdef _SZ_ALLOC_DEBUG
- {
- void *p = malloc(size);
- PRINT_ALLOC("Alloc ", g_allocCount, size, p);
- return p;
- }
- #else
- return malloc(size);
- #endif
-}
-
-void MyFree(void *address)
-{
- PRINT_FREE("Free ", g_allocCount, address);
-
- free(address);
-}
-
-#ifdef _WIN32
-
-void *MidAlloc(size_t size)
-{
- if (size == 0)
- return NULL;
-
- PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, NULL);
-
- return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
-}
-
-void MidFree(void *address)
-{
- PRINT_FREE("Free-Mid", g_allocCountMid, address);
-
- if (!address)
- return;
- VirtualFree(address, 0, MEM_RELEASE);
-}
-
-#ifndef MEM_LARGE_PAGES
-#undef _7ZIP_LARGE_PAGES
-#endif
-
-#ifdef _7ZIP_LARGE_PAGES
-SIZE_T g_LargePageSize = 0;
-typedef SIZE_T (WINAPI *GetLargePageMinimumP)();
-#endif
-
-void SetLargePageSize()
-{
- #ifdef _7ZIP_LARGE_PAGES
- SIZE_T size;
- GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)
- GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");
- if (!largePageMinimum)
- return;
- size = largePageMinimum();
- if (size == 0 || (size & (size - 1)) != 0)
- return;
- g_LargePageSize = size;
- #endif
-}
-
-
-void *BigAlloc(size_t size)
-{
- if (size == 0)
- return NULL;
-
- PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL);
-
- #ifdef _7ZIP_LARGE_PAGES
- {
- SIZE_T ps = g_LargePageSize;
- if (ps != 0 && ps <= (1 << 30) && size > (ps / 2))
- {
- size_t size2;
- ps--;
- size2 = (size + ps) & ~ps;
- if (size2 >= size)
- {
- void *res = VirtualAlloc(NULL, size2, MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
- if (res)
- return res;
- }
- }
- }
- #endif
-
- return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
-}
-
-void BigFree(void *address)
-{
- PRINT_FREE("Free-Big", g_allocCountBig, address);
-
- if (!address)
- return;
- VirtualFree(address, 0, MEM_RELEASE);
-}
-
-#endif
-
-
-static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MyAlloc(size); }
-static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MyFree(address); }
-const ISzAlloc g_Alloc = { SzAlloc, SzFree };
-
-static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return MidAlloc(size); }
-static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); MidFree(address); }
-const ISzAlloc g_MidAlloc = { SzMidAlloc, SzMidFree };
-
-static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p); return BigAlloc(size); }
-static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p); BigFree(address); }
-const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
-
-
-/*
- uintptr_t : <stdint.h> C99 (optional)
- : unsupported in VS6
-*/
-
-#ifdef _WIN32
- typedef UINT_PTR UIntPtr;
-#else
- /*
- typedef uintptr_t UIntPtr;
- */
- typedef ptrdiff_t UIntPtr;
-#endif
-
-
-#define ADJUST_ALLOC_SIZE 0
-/*
-#define ADJUST_ALLOC_SIZE (sizeof(void *) - 1)
-*/
-/*
- Use (ADJUST_ALLOC_SIZE = (sizeof(void *) - 1)), if
- MyAlloc() can return address that is NOT multiple of sizeof(void *).
-*/
-
-
-/*
-#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((char *)(p) - ((size_t)(UIntPtr)(p) & ((align) - 1))))
-*/
-#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((((UIntPtr)(p)) & ~((UIntPtr)(align) - 1))))
-
-#define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
-
-
-#if (_POSIX_C_SOURCE >= 200112L) && !defined(_WIN32)
- #define USE_posix_memalign
-#endif
-
-/*
- This posix_memalign() is for test purposes only.
- We also need special Free() function instead of free(),
- if this posix_memalign() is used.
-*/
-
-/*
-static int posix_memalign(void **ptr, size_t align, size_t size)
-{
- size_t newSize = size + align;
- void *p;
- void *pAligned;
- *ptr = NULL;
- if (newSize < size)
- return 12; // ENOMEM
- p = MyAlloc(newSize);
- if (!p)
- return 12; // ENOMEM
- pAligned = MY_ALIGN_PTR_UP_PLUS(p, align);
- ((void **)pAligned)[-1] = p;
- *ptr = pAligned;
- return 0;
-}
-*/
-
-/*
- ALLOC_ALIGN_SIZE >= sizeof(void *)
- ALLOC_ALIGN_SIZE >= cache_line_size
-*/
-
-#define ALLOC_ALIGN_SIZE ((size_t)1 << 7)
-
-static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
-{
- #ifndef USE_posix_memalign
-
- void *p;
- void *pAligned;
- size_t newSize;
- UNUSED_VAR(pp);
-
- /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
- block to prevent cache line sharing with another allocated blocks */
-
- newSize = size + ALLOC_ALIGN_SIZE * 1 + ADJUST_ALLOC_SIZE;
- if (newSize < size)
- return NULL;
-
- p = MyAlloc(newSize);
-
- if (!p)
- return NULL;
- pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
-
- Print(" size="); PrintHex(size, 8);
- Print(" a_size="); PrintHex(newSize, 8);
- Print(" ptr="); PrintAddr(p);
- Print(" a_ptr="); PrintAddr(pAligned);
- PrintLn();
-
- ((void **)pAligned)[-1] = p;
-
- return pAligned;
-
- #else
-
- void *p;
- UNUSED_VAR(pp);
- if (posix_memalign(&p, ALLOC_ALIGN_SIZE, size))
- return NULL;
-
- Print(" posix_memalign="); PrintAddr(p);
- PrintLn();
-
- return p;
-
- #endif
-}
-
-
-static void SzAlignedFree(ISzAllocPtr pp, void *address)
-{
- UNUSED_VAR(pp);
- #ifndef USE_posix_memalign
- if (address)
- MyFree(((void **)address)[-1]);
- #else
- free(address);
- #endif
-}
-
-
-const ISzAlloc g_AlignedAlloc = { SzAlignedAlloc, SzAlignedFree };
-
-
-
-#define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))
-
-/* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
-#define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
-/*
-#define REAL_BLOCK_PTR_VAR(p) ((void **)(p))[-1]
-*/
-
-static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
-{
- CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
- void *adr;
- void *pAligned;
- size_t newSize;
- size_t extra;
- size_t alignSize = (size_t)1 << p->numAlignBits;
-
- if (alignSize < sizeof(void *))
- alignSize = sizeof(void *);
-
- if (p->offset >= alignSize)
- return NULL;
-
- /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
- block to prevent cache line sharing with another allocated blocks */
- extra = p->offset & (sizeof(void *) - 1);
- newSize = size + alignSize + extra + ADJUST_ALLOC_SIZE;
- if (newSize < size)
- return NULL;
-
- adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
-
- if (!adr)
- return NULL;
-
- pAligned = (char *)MY_ALIGN_PTR_DOWN((char *)adr +
- alignSize - p->offset + extra + ADJUST_ALLOC_SIZE, alignSize) + p->offset;
-
- PrintLn();
- Print("- Aligned: ");
- Print(" size="); PrintHex(size, 8);
- Print(" a_size="); PrintHex(newSize, 8);
- Print(" ptr="); PrintAddr(adr);
- Print(" a_ptr="); PrintAddr(pAligned);
- PrintLn();
-
- REAL_BLOCK_PTR_VAR(pAligned) = adr;
-
- return pAligned;
-}
-
-
-static void AlignOffsetAlloc_Free(ISzAllocPtr pp, void *address)
-{
- if (address)
- {
- CAlignOffsetAlloc *p = CONTAINER_FROM_VTBL(pp, CAlignOffsetAlloc, vt);
- PrintLn();
- Print("- Aligned Free: ");
- PrintLn();
- ISzAlloc_Free(p->baseAlloc, REAL_BLOCK_PTR_VAR(address));
- }
-}
-
-
-void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p)
-{
- p->vt.Alloc = AlignOffsetAlloc_Alloc;
- p->vt.Free = AlignOffsetAlloc_Free;
-}
+/* Alloc.c -- Memory allocation functions
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#ifdef _WIN32
+#include "7zWindows.h"
+#endif
+#include <stdlib.h>
+
+#include "Alloc.h"
+
+#ifdef _WIN32
+#ifdef Z7_LARGE_PAGES
+#if defined(__clang__) || defined(__GNUC__)
+typedef void (*Z7_voidFunction)(void);
+#define MY_CAST_FUNC (Z7_voidFunction)
+#elif defined(_MSC_VER) && _MSC_VER > 1920
+#define MY_CAST_FUNC (void *)
+// #pragma warning(disable : 4191) // 'type cast': unsafe conversion from 'FARPROC' to 'void (__cdecl *)()'
+#else
+#define MY_CAST_FUNC
+#endif
+#endif // Z7_LARGE_PAGES
+#endif // _WIN32
+
+// #define SZ_ALLOC_DEBUG
+/* #define SZ_ALLOC_DEBUG */
+
+/* use SZ_ALLOC_DEBUG to debug alloc/free operations */
+#ifdef SZ_ALLOC_DEBUG
+
+#include <string.h>
+#include <stdio.h>
+static int g_allocCount = 0;
+#ifdef _WIN32
+static int g_allocCountMid = 0;
+static int g_allocCountBig = 0;
+#endif
+
+
+#define CONVERT_INT_TO_STR(charType, tempSize) \
+ char temp[tempSize]; unsigned i = 0; \
+ while (val >= 10) { temp[i++] = (char)('0' + (unsigned)(val % 10)); val /= 10; } \
+ *s++ = (charType)('0' + (unsigned)val); \
+ while (i != 0) { i--; *s++ = temp[i]; } \
+ *s = 0;
+
+static void ConvertUInt64ToString(UInt64 val, char *s)
+{
+ CONVERT_INT_TO_STR(char, 24)
+}
+
+#define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
+
+static void ConvertUInt64ToHex(UInt64 val, char *s)
+{
+ UInt64 v = val;
+ unsigned i;
+ for (i = 1;; i++)
+ {
+ v >>= 4;
+ if (v == 0)
+ break;
+ }
+ s[i] = 0;
+ do
+ {
+ unsigned t = (unsigned)(val & 0xF);
+ val >>= 4;
+ s[--i] = GET_HEX_CHAR(t);
+ }
+ while (i);
+}
+
+#define DEBUG_OUT_STREAM stderr
+
+static void Print(const char *s)
+{
+ fputs(s, DEBUG_OUT_STREAM);
+}
+
+static void PrintAligned(const char *s, size_t align)
+{
+ size_t len = strlen(s);
+ for(;;)
+ {
+ fputc(' ', DEBUG_OUT_STREAM);
+ if (len >= align)
+ break;
+ ++len;
+ }
+ Print(s);
+}
+
+static void PrintLn(void)
+{
+ Print("\n");
+}
+
+static void PrintHex(UInt64 v, size_t align)
+{
+ char s[32];
+ ConvertUInt64ToHex(v, s);
+ PrintAligned(s, align);
+}
+
+static void PrintDec(int v, size_t align)
+{
+ char s[32];
+ ConvertUInt64ToString((unsigned)v, s);
+ PrintAligned(s, align);
+}
+
+static void PrintAddr(void *p)
+{
+ PrintHex((UInt64)(size_t)(ptrdiff_t)p, 12);
+}
+
+
+#define PRINT_REALLOC(name, cnt, size, ptr) { \
+ Print(name " "); \
+ if (!ptr) PrintDec(cnt++, 10); \
+ PrintHex(size, 10); \
+ PrintAddr(ptr); \
+ PrintLn(); }
+
+#define PRINT_ALLOC(name, cnt, size, ptr) { \
+ Print(name " "); \
+ PrintDec(cnt++, 10); \
+ PrintHex(size, 10); \
+ PrintAddr(ptr); \
+ PrintLn(); }
+
+#define PRINT_FREE(name, cnt, ptr) if (ptr) { \
+ Print(name " "); \
+ PrintDec(--cnt, 10); \
+ PrintAddr(ptr); \
+ PrintLn(); }
+
+#else
+
+#ifdef _WIN32
+#define PRINT_ALLOC(name, cnt, size, ptr)
+#endif
+#define PRINT_FREE(name, cnt, ptr)
+#define Print(s)
+#define PrintLn()
+#define PrintHex(v, align)
+#define PrintAddr(p)
+
+#endif
+
+
+/*
+by specification:
+ malloc(non_NULL, 0) : returns NULL or a unique pointer value that can later be successfully passed to free()
+ realloc(NULL, size) : the call is equivalent to malloc(size)
+ realloc(non_NULL, 0) : the call is equivalent to free(ptr)
+
+in main compilers:
+ malloc(0) : returns non_NULL
+ realloc(NULL, 0) : returns non_NULL
+ realloc(non_NULL, 0) : returns NULL
+*/
+
+
+void *MyAlloc(size_t size)
+{
+ if (size == 0)
+ return NULL;
+ // PRINT_ALLOC("Alloc ", g_allocCount, size, NULL)
+ #ifdef SZ_ALLOC_DEBUG
+ {
+ void *p = malloc(size);
+ if (p)
+ {
+ PRINT_ALLOC("Alloc ", g_allocCount, size, p)
+ }
+ return p;
+ }
+ #else
+ return malloc(size);
+ #endif
+}
+
+void MyFree(void *address)
+{
+ PRINT_FREE("Free ", g_allocCount, address)
+
+ free(address);
+}
+
+void *MyRealloc(void *address, size_t size)
+{
+ if (size == 0)
+ {
+ MyFree(address);
+ return NULL;
+ }
+ // PRINT_REALLOC("Realloc ", g_allocCount, size, address)
+ #ifdef SZ_ALLOC_DEBUG
+ {
+ void *p = realloc(address, size);
+ if (p)
+ {
+ PRINT_REALLOC("Realloc ", g_allocCount, size, address)
+ }
+ return p;
+ }
+ #else
+ return realloc(address, size);
+ #endif
+}
+
+
+#ifdef _WIN32
+
+void *MidAlloc(size_t size)
+{
+ if (size == 0)
+ return NULL;
+ #ifdef SZ_ALLOC_DEBUG
+ {
+ void *p = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
+ if (p)
+ {
+ PRINT_ALLOC("Alloc-Mid", g_allocCountMid, size, p)
+ }
+ return p;
+ }
+ #else
+ return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
+ #endif
+}
+
+void MidFree(void *address)
+{
+ PRINT_FREE("Free-Mid", g_allocCountMid, address)
+
+ if (!address)
+ return;
+ VirtualFree(address, 0, MEM_RELEASE);
+}
+
+#ifdef Z7_LARGE_PAGES
+
+#ifdef MEM_LARGE_PAGES
+ #define MY__MEM_LARGE_PAGES MEM_LARGE_PAGES
+#else
+ #define MY__MEM_LARGE_PAGES 0x20000000
+#endif
+
+extern
+SIZE_T g_LargePageSize;
+SIZE_T g_LargePageSize = 0;
+typedef SIZE_T (WINAPI *Func_GetLargePageMinimum)(VOID);
+
+void SetLargePageSize(void)
+{
+ #ifdef Z7_LARGE_PAGES
+ SIZE_T size;
+ const
+ Func_GetLargePageMinimum fn =
+ (Func_GetLargePageMinimum) MY_CAST_FUNC GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
+ "GetLargePageMinimum");
+ if (!fn)
+ return;
+ size = fn();
+ if (size == 0 || (size & (size - 1)) != 0)
+ return;
+ g_LargePageSize = size;
+ #endif
+}
+
+#endif // Z7_LARGE_PAGES
+
+void *BigAlloc(size_t size)
+{
+ if (size == 0)
+ return NULL;
+
+ PRINT_ALLOC("Alloc-Big", g_allocCountBig, size, NULL)
+
+ #ifdef Z7_LARGE_PAGES
+ {
+ SIZE_T ps = g_LargePageSize;
+ if (ps != 0 && ps <= (1 << 30) && size > (ps / 2))
+ {
+ size_t size2;
+ ps--;
+ size2 = (size + ps) & ~ps;
+ if (size2 >= size)
+ {
+ void *p = VirtualAlloc(NULL, size2, MEM_COMMIT | MY__MEM_LARGE_PAGES, PAGE_READWRITE);
+ if (p)
+ {
+ PRINT_ALLOC("Alloc-BM ", g_allocCountMid, size2, p)
+ return p;
+ }
+ }
+ }
+ }
+ #endif
+
+ return MidAlloc(size);
+}
+
+void BigFree(void *address)
+{
+ PRINT_FREE("Free-Big", g_allocCountBig, address)
+ MidFree(address);
+}
+
+#endif // _WIN32
+
+
+static void *SzAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p) return MyAlloc(size); }
+static void SzFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p) MyFree(address); }
+const ISzAlloc g_Alloc = { SzAlloc, SzFree };
+
+#ifdef _WIN32
+static void *SzMidAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p) return MidAlloc(size); }
+static void SzMidFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p) MidFree(address); }
+static void *SzBigAlloc(ISzAllocPtr p, size_t size) { UNUSED_VAR(p) return BigAlloc(size); }
+static void SzBigFree(ISzAllocPtr p, void *address) { UNUSED_VAR(p) BigFree(address); }
+const ISzAlloc g_MidAlloc = { SzMidAlloc, SzMidFree };
+const ISzAlloc g_BigAlloc = { SzBigAlloc, SzBigFree };
+#endif
+
+/*
+ uintptr_t : <stdint.h> C99 (optional)
+ : unsupported in VS6
+*/
+
+#ifdef _WIN32
+ typedef UINT_PTR UIntPtr;
+#else
+ /*
+ typedef uintptr_t UIntPtr;
+ */
+ typedef ptrdiff_t UIntPtr;
+#endif
+
+
+#define ADJUST_ALLOC_SIZE 0
+/*
+#define ADJUST_ALLOC_SIZE (sizeof(void *) - 1)
+*/
+/*
+ Use (ADJUST_ALLOC_SIZE = (sizeof(void *) - 1)), if
+ MyAlloc() can return address that is NOT multiple of sizeof(void *).
+*/
+
+
+/*
+#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((char *)(p) - ((size_t)(UIntPtr)(p) & ((align) - 1))))
+*/
+#define MY_ALIGN_PTR_DOWN(p, align) ((void *)((((UIntPtr)(p)) & ~((UIntPtr)(align) - 1))))
+
+
+#if !defined(_WIN32) && defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)
+ #define USE_posix_memalign
+#endif
+
+#ifndef USE_posix_memalign
+#define MY_ALIGN_PTR_UP_PLUS(p, align) MY_ALIGN_PTR_DOWN(((char *)(p) + (align) + ADJUST_ALLOC_SIZE), align)
+#endif
+
+/*
+ This posix_memalign() is for test purposes only.
+ We also need special Free() function instead of free(),
+ if this posix_memalign() is used.
+*/
+
+/*
+static int posix_memalign(void **ptr, size_t align, size_t size)
+{
+ size_t newSize = size + align;
+ void *p;
+ void *pAligned;
+ *ptr = NULL;
+ if (newSize < size)
+ return 12; // ENOMEM
+ p = MyAlloc(newSize);
+ if (!p)
+ return 12; // ENOMEM
+ pAligned = MY_ALIGN_PTR_UP_PLUS(p, align);
+ ((void **)pAligned)[-1] = p;
+ *ptr = pAligned;
+ return 0;
+}
+*/
+
+/*
+ ALLOC_ALIGN_SIZE >= sizeof(void *)
+ ALLOC_ALIGN_SIZE >= cache_line_size
+*/
+
+#define ALLOC_ALIGN_SIZE ((size_t)1 << 7)
+
+static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)
+{
+ #ifndef USE_posix_memalign
+
+ void *p;
+ void *pAligned;
+ size_t newSize;
+ UNUSED_VAR(pp)
+
+ /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
+ block to prevent cache line sharing with another allocated blocks */
+
+ newSize = size + ALLOC_ALIGN_SIZE * 1 + ADJUST_ALLOC_SIZE;
+ if (newSize < size)
+ return NULL;
+
+ p = MyAlloc(newSize);
+
+ if (!p)
+ return NULL;
+ pAligned = MY_ALIGN_PTR_UP_PLUS(p, ALLOC_ALIGN_SIZE);
+
+ Print(" size="); PrintHex(size, 8);
+ Print(" a_size="); PrintHex(newSize, 8);
+ Print(" ptr="); PrintAddr(p);
+ Print(" a_ptr="); PrintAddr(pAligned);
+ PrintLn();
+
+ ((void **)pAligned)[-1] = p;
+
+ return pAligned;
+
+ #else
+
+ void *p;
+ UNUSED_VAR(pp)
+ if (posix_memalign(&p, ALLOC_ALIGN_SIZE, size))
+ return NULL;
+
+ Print(" posix_memalign="); PrintAddr(p);
+ PrintLn();
+
+ return p;
+
+ #endif
+}
+
+
+static void SzAlignedFree(ISzAllocPtr pp, void *address)
+{
+ UNUSED_VAR(pp)
+ #ifndef USE_posix_memalign
+ if (address)
+ MyFree(((void **)address)[-1]);
+ #else
+ free(address);
+ #endif
+}
+
+
+const ISzAlloc g_AlignedAlloc = { SzAlignedAlloc, SzAlignedFree };
+
+
+
+#define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))
+
+/* we align ptr to support cases where CAlignOffsetAlloc::offset is not multiply of sizeof(void *) */
+#define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]
+/*
+#define REAL_BLOCK_PTR_VAR(p) ((void **)(p))[-1]
+*/
+
+static void *AlignOffsetAlloc_Alloc(ISzAllocPtr pp, size_t size)
+{
+ const CAlignOffsetAlloc *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CAlignOffsetAlloc, vt);
+ void *adr;
+ void *pAligned;
+ size_t newSize;
+ size_t extra;
+ size_t alignSize = (size_t)1 << p->numAlignBits;
+
+ if (alignSize < sizeof(void *))
+ alignSize = sizeof(void *);
+
+ if (p->offset >= alignSize)
+ return NULL;
+
+ /* also we can allocate additional dummy ALLOC_ALIGN_SIZE bytes after aligned
+ block to prevent cache line sharing with another allocated blocks */
+ extra = p->offset & (sizeof(void *) - 1);
+ newSize = size + alignSize + extra + ADJUST_ALLOC_SIZE;
+ if (newSize < size)
+ return NULL;
+
+ adr = ISzAlloc_Alloc(p->baseAlloc, newSize);
+
+ if (!adr)
+ return NULL;
+
+ pAligned = (char *)MY_ALIGN_PTR_DOWN((char *)adr +
+ alignSize - p->offset + extra + ADJUST_ALLOC_SIZE, alignSize) + p->offset;
+
+ PrintLn();
+ Print("- Aligned: ");
+ Print(" size="); PrintHex(size, 8);
+ Print(" a_size="); PrintHex(newSize, 8);
+ Print(" ptr="); PrintAddr(adr);
+ Print(" a_ptr="); PrintAddr(pAligned);
+ PrintLn();
+
+ REAL_BLOCK_PTR_VAR(pAligned) = adr;
+
+ return pAligned;
+}
+
+
+static void AlignOffsetAlloc_Free(ISzAllocPtr pp, void *address)
+{
+ if (address)
+ {
+ const CAlignOffsetAlloc *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CAlignOffsetAlloc, vt);
+ PrintLn();
+ Print("- Aligned Free: ");
+ PrintLn();
+ ISzAlloc_Free(p->baseAlloc, REAL_BLOCK_PTR_VAR(address));
+ }
+}
+
+
+void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p)
+{
+ p->vt.Alloc = AlignOffsetAlloc_Alloc;
+ p->vt.Free = AlignOffsetAlloc_Free;
+}
diff --git a/C/Alloc.h b/C/Alloc.h
index 3d796e5..fac5b62 100644
--- a/C/Alloc.h
+++ b/C/Alloc.h
@@ -1,51 +1,71 @@
-/* Alloc.h -- Memory allocation functions
-2018-02-19 : Igor Pavlov : Public domain */
-
-#ifndef __COMMON_ALLOC_H
-#define __COMMON_ALLOC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-void *MyAlloc(size_t size);
-void MyFree(void *address);
-
-#ifdef _WIN32
-
-void SetLargePageSize();
-
-void *MidAlloc(size_t size);
-void MidFree(void *address);
-void *BigAlloc(size_t size);
-void BigFree(void *address);
-
-#else
-
-#define MidAlloc(size) MyAlloc(size)
-#define MidFree(address) MyFree(address)
-#define BigAlloc(size) MyAlloc(size)
-#define BigFree(address) MyFree(address)
-
-#endif
-
-extern const ISzAlloc g_Alloc;
-extern const ISzAlloc g_BigAlloc;
-extern const ISzAlloc g_MidAlloc;
-extern const ISzAlloc g_AlignedAlloc;
-
-
-typedef struct
-{
- ISzAlloc vt;
- ISzAllocPtr baseAlloc;
- unsigned numAlignBits; /* ((1 << numAlignBits) >= sizeof(void *)) */
- size_t offset; /* (offset == (k * sizeof(void *)) && offset < (1 << numAlignBits) */
-} CAlignOffsetAlloc;
-
-void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p);
-
-
-EXTERN_C_END
-
-#endif
+/* Alloc.h -- Memory allocation functions
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_ALLOC_H
+#define ZIP7_INC_ALLOC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+/*
+ MyFree(NULL) : is allowed, as free(NULL)
+ MyAlloc(0) : returns NULL : but malloc(0) is allowed to return NULL or non_NULL
+ MyRealloc(NULL, 0) : returns NULL : but realloc(NULL, 0) is allowed to return NULL or non_NULL
+MyRealloc() is similar to realloc() for the following cases:
+ MyRealloc(non_NULL, 0) : returns NULL and always calls MyFree(ptr)
+ MyRealloc(NULL, non_ZERO) : returns NULL, if allocation failed
+ MyRealloc(non_NULL, non_ZERO) : returns NULL, if reallocation failed
+*/
+
+void *MyAlloc(size_t size);
+void MyFree(void *address);
+void *MyRealloc(void *address, size_t size);
+
+#ifdef _WIN32
+
+#ifdef Z7_LARGE_PAGES
+void SetLargePageSize(void);
+#endif
+
+void *MidAlloc(size_t size);
+void MidFree(void *address);
+void *BigAlloc(size_t size);
+void BigFree(void *address);
+
+#else
+
+#define MidAlloc(size) MyAlloc(size)
+#define MidFree(address) MyFree(address)
+#define BigAlloc(size) MyAlloc(size)
+#define BigFree(address) MyFree(address)
+
+#endif
+
+extern const ISzAlloc g_Alloc;
+
+#ifdef _WIN32
+extern const ISzAlloc g_BigAlloc;
+extern const ISzAlloc g_MidAlloc;
+#else
+#define g_BigAlloc g_AlignedAlloc
+#define g_MidAlloc g_AlignedAlloc
+#endif
+
+extern const ISzAlloc g_AlignedAlloc;
+
+
+typedef struct
+{
+ ISzAlloc vt;
+ ISzAllocPtr baseAlloc;
+ unsigned numAlignBits; /* ((1 << numAlignBits) >= sizeof(void *)) */
+ size_t offset; /* (offset == (k * sizeof(void *)) && offset < (1 << numAlignBits) */
+} CAlignOffsetAlloc;
+
+void AlignOffsetAlloc_CreateVTable(CAlignOffsetAlloc *p);
+
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Android.bp b/C/Android.bp
index c5d201b..071f557 100644
--- a/C/Android.bp
+++ b/C/Android.bp
@@ -24,7 +24,7 @@
stl: "none",
cflags: [
- "-D_7ZIP_ST",
+ "-DZ7_ST",
"-Wall",
"-Werror",
"-Wno-empty-body",
@@ -66,6 +66,7 @@
"Ppmd7Dec.c",
"Ppmd7Enc.c",
"Sha256.c",
+ "Sha256Opt.c",
"Sort.c",
"Xz.c",
"XzCrc64.c",
@@ -75,6 +76,15 @@
"XzIn.c",
],
+ arch: {
+ arm: {
+ cflags: ["-march=armv8-a+crypto"],
+ },
+ arm64: {
+ cflags: ["-march=armv8-a+crypto"],
+ },
+ },
+
target: {
linux_bionic: {
enabled: true,
@@ -85,6 +95,7 @@
"Bcj2Enc.c",
"DllSecur.c",
"LzFindMt.c",
+ "LzFindOpt.c",
"Lzma2DecMt.c",
"MtCoder.c",
"MtDec.c",
diff --git a/C/Bcj2.c b/C/Bcj2.c
index da93985..7cb57ad 100644
--- a/C/Bcj2.c
+++ b/C/Bcj2.c
@@ -1,257 +1,290 @@
-/* Bcj2.c -- BCJ2 Decoder (Converter for x86 code)
-2018-04-28 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Bcj2.h"
-#include "CpuArch.h"
-
-#define CProb UInt16
-
-#define kTopValue ((UInt32)1 << 24)
-#define kNumModelBits 11
-#define kBitModelTotal (1 << kNumModelBits)
-#define kNumMoveBits 5
-
-#define _IF_BIT_0 ttt = *prob; bound = (p->range >> kNumModelBits) * ttt; if (p->code < bound)
-#define _UPDATE_0 p->range = bound; *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
-#define _UPDATE_1 p->range -= bound; p->code -= bound; *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
-
-void Bcj2Dec_Init(CBcj2Dec *p)
-{
- unsigned i;
-
- p->state = BCJ2_DEC_STATE_OK;
- p->ip = 0;
- p->temp[3] = 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)
-{
- if (p->range <= 5)
- {
- p->state = BCJ2_DEC_STATE_OK;
- for (; p->range != 5; p->range++)
- {
- if (p->range == 1 && p->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;
- }
-
- p->code = (p->code << 8) | *(p->bufs[BCJ2_STREAM_RC])++;
- }
-
- if (p->code == 0xFFFFFFFF)
- return SZ_ERROR_DATA;
-
- p->range = 0xFFFFFFFF;
- }
- else if (p->state >= BCJ2_DEC_STATE_ORIG_0)
- {
- while (p->state <= BCJ2_DEC_STATE_ORIG_3)
- {
- Byte *dest = p->dest;
- if (dest == p->destLim)
- return SZ_OK;
- *dest = p->temp[(size_t)p->state - BCJ2_DEC_STATE_ORIG_0];
- p->state++;
- p->dest = dest + 1;
- }
- }
-
- /*
- if (BCJ2_IS_32BIT_STREAM(p->state))
- {
- const Byte *cur = p->bufs[p->state];
- if (cur == p->lims[p->state])
- return SZ_OK;
- p->bufs[p->state] = cur + 4;
-
- {
- UInt32 val;
- Byte *dest;
- SizeT rem;
-
- p->ip += 4;
- val = GetBe32(cur) - p->ip;
- dest = p->dest;
- rem = p->destLim - dest;
- if (rem < 4)
- {
- SizeT i;
- SetUi32(p->temp, val);
- for (i = 0; i < rem; i++)
- dest[i] = p->temp[i];
- p->dest = dest + rem;
- p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
- return SZ_OK;
- }
- SetUi32(dest, val);
- p->temp[3] = (Byte)(val >> 24);
- p->dest = dest + 4;
- p->state = BCJ2_DEC_STATE_OK;
- }
- }
- */
-
- 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;
- 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;
- SizeT num = p->lims[BCJ2_STREAM_MAIN] - src;
-
- if (num == 0)
- {
- p->state = BCJ2_STREAM_MAIN;
- return SZ_OK;
- }
-
- dest = p->dest;
- if (num > (SizeT)(p->destLim - dest))
- {
- num = p->destLim - dest;
- if (num == 0)
- {
- p->state = BCJ2_DEC_STATE_ORIG;
- return SZ_OK;
- }
- }
-
- srcLim = src + num;
-
- if (p->temp[3] == 0x0F && (src[0] & 0xF0) == 0x80)
- *dest = src[0];
- else for (;;)
- {
- Byte b = *src;
- *dest = b;
- if (b != 0x0F)
- {
- if ((b & 0xFE) == 0xE8)
- break;
- dest++;
- if (++src != srcLim)
- continue;
- break;
- }
- dest++;
- if (++src == srcLim)
- break;
- if ((*src & 0xF0) != 0x80)
- continue;
- *dest = *src;
- break;
- }
-
- num = src - p->bufs[BCJ2_STREAM_MAIN];
-
- if (src == srcLim)
- {
- p->temp[3] = src[-1];
- p->bufs[BCJ2_STREAM_MAIN] = src;
- p->ip += (UInt32)num;
- p->dest += num;
- p->state =
- p->bufs[BCJ2_STREAM_MAIN] ==
- p->lims[BCJ2_STREAM_MAIN] ?
- (unsigned)BCJ2_STREAM_MAIN :
- (unsigned)BCJ2_DEC_STATE_ORIG;
- return SZ_OK;
- }
-
- {
- UInt32 bound, ttt;
- CProb *prob;
- Byte b = src[0];
- Byte prev = (Byte)(num == 0 ? p->temp[3] : src[-1]);
-
- p->temp[3] = b;
- p->bufs[BCJ2_STREAM_MAIN] = src + 1;
- num++;
- p->ip += (UInt32)num;
- p->dest += num;
-
- prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)prev : (b == 0xE9 ? 1 : 0));
-
- _IF_BIT_0
- {
- _UPDATE_0
- continue;
- }
- _UPDATE_1
-
- }
- }
- }
-
- {
- UInt32 val;
- unsigned cj = (p->temp[3] == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
- const Byte *cur = p->bufs[cj];
- Byte *dest;
- SizeT rem;
-
- if (cur == p->lims[cj])
- {
- p->state = cj;
- break;
- }
-
- val = GetBe32(cur);
- p->bufs[cj] = cur + 4;
-
- p->ip += 4;
- val -= p->ip;
- dest = p->dest;
- rem = p->destLim - dest;
-
- if (rem < 4)
- {
- p->temp[0] = (Byte)val; if (rem > 0) dest[0] = (Byte)val; val >>= 8;
- p->temp[1] = (Byte)val; if (rem > 1) dest[1] = (Byte)val; val >>= 8;
- p->temp[2] = (Byte)val; if (rem > 2) dest[2] = (Byte)val; val >>= 8;
- p->temp[3] = (Byte)val;
- p->dest = dest + rem;
- p->state = BCJ2_DEC_STATE_ORIG_0 + (unsigned)rem;
- break;
- }
-
- SetUi32(dest, val);
- p->temp[3] = (Byte)(val >> 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;
-}
+/* 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
diff --git a/C/Bcj2.h b/C/Bcj2.h
index 68893d2..4575545 100644
--- a/C/Bcj2.h
+++ b/C/Bcj2.h
@@ -1,146 +1,332 @@
-/* Bcj2.h -- BCJ2 Converter for x86 code
-2014-11-10 : Igor Pavlov : Public domain */
-
-#ifndef __BCJ2_H
-#define __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_OK
-};
-
-enum
-{
- BCJ2_ENC_STATE_ORIG = BCJ2_NUM_STREAMS,
- BCJ2_ENC_STATE_OK
-};
-
-
-#define BCJ2_IS_32BIT_STREAM(s) ((s) == BCJ2_STREAM_CALL || (s) == BCJ2_STREAM_JUMP)
-
-/*
-CBcj2Dec / CBcj2Enc
-bufs sizes:
- BUF_SIZE(n) = lims[n] - bufs[n]
-bufs sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP must be mutliply of 4:
- (BUF_SIZE(BCJ2_STREAM_CALL) & 3) == 0
- (BUF_SIZE(BCJ2_STREAM_JUMP) & 3) == 0
-*/
-
-/*
-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 >= tempReserv +
- BUF_SIZE(BCJ2_STREAM_CALL) +
- BUF_SIZE(BCJ2_STREAM_JUMP)
- tempReserv = 0 : for first call of Bcj2Dec_Decode
- tempReserv = 4 : for any other calls of Bcj2Dec_Decode
- overlap with offset = 1 is not allowed
-*/
-
-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;
- Byte temp[4];
- UInt32 range;
- UInt32 code;
- UInt16 probs[2 + 256];
-} CBcj2Dec;
-
-void Bcj2Dec_Init(CBcj2Dec *p);
-
-/* Returns: SZ_OK or SZ_ERROR_DATA */
-SRes Bcj2Dec_Decode(CBcj2Dec *p);
-
-#define Bcj2Dec_IsFinished(_p_) ((_p_)->code == 0)
-
-
-
-typedef enum
-{
- BCJ2_ENC_FINISH_MODE_CONTINUE,
- BCJ2_ENC_FINISH_MODE_END_BLOCK,
- BCJ2_ENC_FINISH_MODE_END_STREAM
-} EBcj2Enc_FinishMode;
-
-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 prevByte;
-
- Byte cache;
- UInt32 range;
- UInt64 low;
- UInt64 cacheSize;
-
- UInt32 ip;
-
- /* 32-bit ralative offset in JUMP/CALL commands is
- - (mod 4 GB) in 32-bit mode
- - signed Int32 in 64-bit mode
- We use (mod 4 GB) check for fileSize.
- Use fileSize up to 2 GB, if you want to support 32-bit and 64-bit code conversion. */
- UInt32 fileIp;
- UInt32 fileSize; /* (fileSize <= ((UInt32)1 << 31)), 0 means no_limit */
- UInt32 relatLimit; /* (relatLimit <= ((UInt32)1 << 31)), 0 means desable_conversion */
-
- UInt32 tempTarget;
- unsigned tempPos;
- Byte temp[4 * 2];
-
- unsigned flushPos;
-
- UInt16 probs[2 + 256];
-} CBcj2Enc;
-
-void Bcj2Enc_Init(CBcj2Enc *p);
-void Bcj2Enc_Encode(CBcj2Enc *p);
-
-#define Bcj2Enc_Get_InputData_Size(p) ((SizeT)((p)->srcLim - (p)->src) + (p)->tempPos)
-#define Bcj2Enc_IsFinished(p) ((p)->flushPos == 5)
-
-
-#define BCJ2_RELAT_LIMIT_NUM_BITS 26
-#define BCJ2_RELAT_LIMIT ((UInt32)1 << BCJ2_RELAT_LIMIT_NUM_BITS)
-
-/* limit for CBcj2Enc::fileSize variable */
-#define BCJ2_FileSize_MAX ((UInt32)1 << 31)
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/Bcj2Enc.c b/C/Bcj2Enc.c
index 7a02ecd..79460bb 100644
--- a/C/Bcj2Enc.c
+++ b/C/Bcj2Enc.c
@@ -1,311 +1,506 @@
-/* Bcj2Enc.c -- BCJ2 Encoder (Converter for x86 code)
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-/* #define SHOW_STAT */
-
-#ifdef SHOW_STAT
-#include <stdio.h>
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-#include <string.h>
-
-#include "Bcj2.h"
-#include "CpuArch.h"
-
-#define CProb UInt16
-
-#define kTopValue ((UInt32)1 << 24)
-#define kNumModelBits 11
-#define kBitModelTotal (1 << kNumModelBits)
-#define kNumMoveBits 5
-
-void Bcj2Enc_Init(CBcj2Enc *p)
-{
- unsigned i;
-
- p->state = BCJ2_ENC_STATE_OK;
- p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
-
- p->prevByte = 0;
-
- p->cache = 0;
- p->range = 0xFFFFFFFF;
- p->low = 0;
- p->cacheSize = 1;
-
- p->ip = 0;
-
- p->fileIp = 0;
- p->fileSize = 0;
- p->relatLimit = BCJ2_RELAT_LIMIT;
-
- p->tempPos = 0;
-
- p->flushPos = 0;
-
- for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
- p->probs[i] = kBitModelTotal >> 1;
-}
-
-static BoolInt MY_FAST_CALL RangeEnc_ShiftLow(CBcj2Enc *p)
-{
- if ((UInt32)p->low < (UInt32)0xFF000000 || (UInt32)(p->low >> 32) != 0)
- {
- Byte *buf = p->bufs[BCJ2_STREAM_RC];
- do
- {
- if (buf == p->lims[BCJ2_STREAM_RC])
- {
- p->state = BCJ2_STREAM_RC;
- p->bufs[BCJ2_STREAM_RC] = buf;
- return True;
- }
- *buf++ = (Byte)(p->cache + (Byte)(p->low >> 32));
- p->cache = 0xFF;
- }
- while (--p->cacheSize);
- p->bufs[BCJ2_STREAM_RC] = buf;
- p->cache = (Byte)((UInt32)p->low >> 24);
- }
- p->cacheSize++;
- p->low = (UInt32)p->low << 8;
- return False;
-}
-
-static void Bcj2Enc_Encode_2(CBcj2Enc *p)
-{
- if (BCJ2_IS_32BIT_STREAM(p->state))
- {
- Byte *cur = p->bufs[p->state];
- if (cur == p->lims[p->state])
- return;
- SetBe32(cur, p->tempTarget);
- p->bufs[p->state] = cur + 4;
- }
-
- p->state = BCJ2_ENC_STATE_ORIG;
-
- for (;;)
- {
- if (p->range < kTopValue)
- {
- if (RangeEnc_ShiftLow(p))
- return;
- p->range <<= 8;
- }
-
- {
- {
- const Byte *src = p->src;
- const Byte *srcLim;
- Byte *dest;
- SizeT num = p->srcLim - src;
-
- if (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
- {
- if (num <= 4)
- return;
- num -= 4;
- }
- else if (num == 0)
- break;
-
- dest = p->bufs[BCJ2_STREAM_MAIN];
- if (num > (SizeT)(p->lims[BCJ2_STREAM_MAIN] - dest))
- {
- num = p->lims[BCJ2_STREAM_MAIN] - dest;
- if (num == 0)
- {
- p->state = BCJ2_STREAM_MAIN;
- return;
- }
- }
-
- srcLim = src + num;
-
- if (p->prevByte == 0x0F && (src[0] & 0xF0) == 0x80)
- *dest = src[0];
- else for (;;)
- {
- Byte b = *src;
- *dest = b;
- if (b != 0x0F)
- {
- if ((b & 0xFE) == 0xE8)
- break;
- dest++;
- if (++src != srcLim)
- continue;
- break;
- }
- dest++;
- if (++src == srcLim)
- break;
- if ((*src & 0xF0) != 0x80)
- continue;
- *dest = *src;
- break;
- }
-
- num = src - p->src;
-
- if (src == srcLim)
- {
- p->prevByte = src[-1];
- p->bufs[BCJ2_STREAM_MAIN] = dest;
- p->src = src;
- p->ip += (UInt32)num;
- continue;
- }
-
- {
- Byte context = (Byte)(num == 0 ? p->prevByte : src[-1]);
- BoolInt needConvert;
-
- p->bufs[BCJ2_STREAM_MAIN] = dest + 1;
- p->ip += (UInt32)num + 1;
- src++;
-
- needConvert = False;
-
- if ((SizeT)(p->srcLim - src) >= 4)
- {
- UInt32 relatVal = GetUi32(src);
- if ((p->fileSize == 0 || (UInt32)(p->ip + 4 + relatVal - p->fileIp) < p->fileSize)
- && ((relatVal + p->relatLimit) >> 1) < p->relatLimit)
- needConvert = True;
- }
-
- {
- UInt32 bound;
- unsigned ttt;
- Byte b = src[-1];
- CProb *prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)context : (b == 0xE9 ? 1 : 0));
-
- ttt = *prob;
- bound = (p->range >> kNumModelBits) * ttt;
-
- if (!needConvert)
- {
- p->range = bound;
- *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
- p->src = src;
- p->prevByte = b;
- continue;
- }
-
- p->low += bound;
- p->range -= bound;
- *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
-
- {
- UInt32 relatVal = GetUi32(src);
- UInt32 absVal;
- p->ip += 4;
- absVal = p->ip + relatVal;
- p->prevByte = src[3];
- src += 4;
- p->src = src;
- {
- unsigned cj = (b == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
- Byte *cur = p->bufs[cj];
- if (cur == p->lims[cj])
- {
- p->state = cj;
- p->tempTarget = absVal;
- return;
- }
- SetBe32(cur, absVal);
- p->bufs[cj] = cur + 4;
- }
- }
- }
- }
- }
- }
- }
-
- if (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
- return;
-
- for (; p->flushPos < 5; p->flushPos++)
- if (RangeEnc_ShiftLow(p))
- return;
- p->state = BCJ2_ENC_STATE_OK;
-}
-
-
-void Bcj2Enc_Encode(CBcj2Enc *p)
-{
- PRF(printf("\n"));
- PRF(printf("---- ip = %8d tempPos = %8d src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
-
- if (p->tempPos != 0)
- {
- unsigned extra = 0;
-
- for (;;)
- {
- const Byte *src = p->src;
- const Byte *srcLim = p->srcLim;
- EBcj2Enc_FinishMode finishMode = p->finishMode;
-
- p->src = p->temp;
- p->srcLim = p->temp + p->tempPos;
- if (src != srcLim)
- p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
-
- PRF(printf(" ip = %8d tempPos = %8d src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
-
- Bcj2Enc_Encode_2(p);
-
- {
- unsigned num = (unsigned)(p->src - p->temp);
- unsigned tempPos = p->tempPos - num;
- unsigned i;
- p->tempPos = tempPos;
- for (i = 0; i < tempPos; i++)
- p->temp[i] = p->temp[(size_t)i + num];
-
- p->src = src;
- p->srcLim = srcLim;
- p->finishMode = finishMode;
-
- if (p->state != BCJ2_ENC_STATE_ORIG || src == srcLim)
- return;
-
- if (extra >= tempPos)
- {
- p->src = src - tempPos;
- p->tempPos = 0;
- break;
- }
-
- p->temp[tempPos] = src[0];
- p->tempPos = tempPos + 1;
- p->src = src + 1;
- extra++;
- }
- }
- }
-
- PRF(printf("++++ ip = %8d tempPos = %8d src = %8d\n", p->ip, p->tempPos, p->srcLim - p->src));
-
- Bcj2Enc_Encode_2(p);
-
- if (p->state == BCJ2_ENC_STATE_ORIG)
- {
- const Byte *src = p->src;
- unsigned rem = (unsigned)(p->srcLim - src);
- unsigned i;
- for (i = 0; i < rem; i++)
- p->temp[i] = src[i];
- p->tempPos = rem;
- p->src = src + rem;
- }
-}
+/* Bcj2Enc.c -- BCJ2 Encoder converter for x86 code (Branch CALL/JUMP variant2)
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+/* #define SHOW_STAT */
+#ifdef SHOW_STAT
+#include <stdio.h>
+#define PRF2(s) printf("%s ip=%8x tempPos=%d src= %8x\n", s, (unsigned)p->ip64, p->tempPos, (unsigned)(p->srcLim - p->src));
+#else
+#define PRF2(s)
+#endif
+
+#include "Bcj2.h"
+#include "CpuArch.h"
+
+#define kTopValue ((UInt32)1 << 24)
+#define kNumBitModelTotalBits 11
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
+#define kNumMoveBits 5
+
+void Bcj2Enc_Init(CBcj2Enc *p)
+{
+ unsigned i;
+ p->state = BCJ2_ENC_STATE_ORIG;
+ p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+ p->context = 0;
+ p->flushRem = 5;
+ p->isFlushState = 0;
+ p->cache = 0;
+ p->range = 0xffffffff;
+ p->low = 0;
+ p->cacheSize = 1;
+ p->ip64 = 0;
+ p->fileIp64 = 0;
+ p->fileSize64_minus1 = BCJ2_ENC_FileSizeField_UNLIMITED;
+ p->relatLimit = BCJ2_ENC_RELAT_LIMIT_DEFAULT;
+ // p->relatExcludeBits = 0;
+ p->tempPos = 0;
+ for (i = 0; i < sizeof(p->probs) / sizeof(p->probs[0]); i++)
+ p->probs[i] = kBitModelTotal >> 1;
+}
+
+// Z7_NO_INLINE
+Z7_FORCE_INLINE
+static BoolInt Bcj2_RangeEnc_ShiftLow(CBcj2Enc *p)
+{
+ const UInt32 low = (UInt32)p->low;
+ const unsigned high = (unsigned)
+ #if defined(Z7_MSC_VER_ORIGINAL) \
+ && defined(MY_CPU_X86) \
+ && defined(MY_CPU_LE) \
+ && !defined(MY_CPU_64BIT)
+ // we try to rid of __aullshr() call in MSVS-x86
+ (((const UInt32 *)&p->low)[1]); // [1] : for little-endian only
+ #else
+ (p->low >> 32);
+ #endif
+ if (low < (UInt32)0xff000000 || high != 0)
+ {
+ Byte *buf = p->bufs[BCJ2_STREAM_RC];
+ do
+ {
+ if (buf == p->lims[BCJ2_STREAM_RC])
+ {
+ p->state = BCJ2_STREAM_RC;
+ p->bufs[BCJ2_STREAM_RC] = buf;
+ return True;
+ }
+ *buf++ = (Byte)(p->cache + high);
+ p->cache = 0xff;
+ }
+ while (--p->cacheSize);
+ p->bufs[BCJ2_STREAM_RC] = buf;
+ p->cache = (Byte)(low >> 24);
+ }
+ p->cacheSize++;
+ p->low = low << 8;
+ return False;
+}
+
+
+/*
+We can use 2 alternative versions of code:
+1) non-marker version:
+ Byte CBcj2Enc::context
+ Byte temp[8];
+ Last byte of marker (e8/e9/[0f]8x) can be written to temp[] buffer.
+ Encoder writes last byte of marker (e8/e9/[0f]8x) to dest, only in conjunction
+ with writing branch symbol to range coder in same Bcj2Enc_Encode_2() call.
+
+2) marker version:
+ UInt32 CBcj2Enc::context
+ Byte CBcj2Enc::temp[4];
+ MARKER_FLAG in CBcj2Enc::context shows that CBcj2Enc::context contains finded marker.
+ it's allowed that
+ one call of Bcj2Enc_Encode_2() writes last byte of marker (e8/e9/[0f]8x) to dest,
+ and another call of Bcj2Enc_Encode_2() does offset conversion.
+ So different values of (fileIp) and (fileSize) are possible
+ in these different Bcj2Enc_Encode_2() calls.
+
+Also marker version requires additional if((v & MARKER_FLAG) == 0) check in main loop.
+So we use non-marker version.
+*/
+
+/*
+ Corner cases with overlap in multi-block.
+ before v23: there was one corner case, where converted instruction
+ could start in one sub-stream and finish in next sub-stream.
+ If multi-block (solid) encoding is used,
+ and BCJ2_ENC_FINISH_MODE_END_BLOCK is used for each sub-stream.
+ and (0f) is last byte of previous sub-stream
+ and (8x) is first byte of current sub-stream
+ then (0f 8x) pair is treated as marker by BCJ2 encoder and decoder.
+ BCJ2 encoder can converts 32-bit offset for that (0f 8x) cortage,
+ if that offset meets limit requirements.
+ If encoder allows 32-bit offset conversion for such overlap case,
+ then the data in 3 uncompressed BCJ2 streams for some sub-stream
+ can depend from data of previous sub-stream.
+ That corner case is not big problem, and it's rare case.
+ Since v23.00 we do additional check to prevent conversions in such overlap cases.
+*/
+
+/*
+ Bcj2Enc_Encode_2() output variables at exit:
+ {
+ if (Bcj2Enc_Encode_2() exits with (p->state == BCJ2_ENC_STATE_ORIG))
+ {
+ it means that encoder needs more input data.
+ if (p->srcLim == p->src) at exit, then
+ {
+ (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
+ all input data were read and processed, and we are ready for
+ new input data.
+ }
+ else
+ {
+ (p->srcLim != p->src)
+ (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
+ The encoder have found e8/e9/0f_8x marker,
+ and p->src points to last byte of that marker,
+ Bcj2Enc_Encode_2() needs more input data to get totally
+ 5 bytes (last byte of marker and 32-bit branch offset)
+ as continuous array starting from p->src.
+ (p->srcLim - p->src < 5) requirement is met after exit.
+ So non-processed resedue from p->src to p->srcLim is always less than 5 bytes.
+ }
+ }
+ }
+*/
+
+Z7_NO_INLINE
+static void Bcj2Enc_Encode_2(CBcj2Enc *p)
+{
+ if (!p->isFlushState)
+ {
+ const Byte *src;
+ UInt32 v;
+ {
+ const unsigned state = p->state;
+ if (BCJ2_IS_32BIT_STREAM(state))
+ {
+ Byte *cur = p->bufs[state];
+ if (cur == p->lims[state])
+ return;
+ SetBe32a(cur, p->tempTarget)
+ p->bufs[state] = cur + 4;
+ }
+ }
+ p->state = BCJ2_ENC_STATE_ORIG; // for main reason of exit
+ src = p->src;
+ v = p->context;
+
+ // #define WRITE_CONTEXT p->context = v; // for marker version
+ #define WRITE_CONTEXT p->context = (Byte)v;
+ #define WRITE_CONTEXT_AND_SRC p->src = src; WRITE_CONTEXT
+
+ for (;;)
+ {
+ // const Byte *src;
+ // UInt32 v;
+ CBcj2Enc_ip_unsigned ip;
+ if (p->range < kTopValue)
+ {
+ // to reduce register pressure and code size: we save and restore local variables.
+ WRITE_CONTEXT_AND_SRC
+ if (Bcj2_RangeEnc_ShiftLow(p))
+ return;
+ p->range <<= 8;
+ src = p->src;
+ v = p->context;
+ }
+ // src = p->src;
+ // #define MARKER_FLAG ((UInt32)1 << 17)
+ // if ((v & MARKER_FLAG) == 0) // for marker version
+ {
+ const Byte *srcLim;
+ Byte *dest = p->bufs[BCJ2_STREAM_MAIN];
+ {
+ const SizeT remSrc = (SizeT)(p->srcLim - src);
+ SizeT rem = (SizeT)(p->lims[BCJ2_STREAM_MAIN] - dest);
+ if (rem >= remSrc)
+ rem = remSrc;
+ srcLim = src + rem;
+ }
+ /* p->context contains context of previous byte:
+ bits [0 : 7] : src[-1], if (src) was changed in this call
+ bits [8 : 31] : are undefined for non-marker version
+ */
+ // v = p->context;
+ #define NUM_SHIFT_BITS 24
+ #define CONV_FLAG ((UInt32)1 << 16)
+ #define ONE_ITER { \
+ b = src[0]; \
+ *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; \
+ src++; if (src == srcLim) { break; } }
+
+ if (src != srcLim)
+ for (;;)
+ {
+ /* clang can generate ineffective code with setne instead of two jcc instructions.
+ we can use 2 iterations and external (unsigned b) to avoid that ineffective code genaration. */
+ unsigned b;
+ ONE_ITER
+ ONE_ITER
+ }
+
+ ip = p->ip64 + (CBcj2Enc_ip_unsigned)(SizeT)(dest - p->bufs[BCJ2_STREAM_MAIN]);
+ p->bufs[BCJ2_STREAM_MAIN] = dest;
+ p->ip64 = ip;
+
+ if (src == srcLim)
+ {
+ WRITE_CONTEXT_AND_SRC
+ if (src != p->srcLim)
+ {
+ p->state = BCJ2_STREAM_MAIN;
+ return;
+ }
+ /* (p->src == p->srcLim)
+ (p->state == BCJ2_ENC_STATE_ORIG) */
+ if (p->finishMode != BCJ2_ENC_FINISH_MODE_END_STREAM)
+ return;
+ /* (p->finishMode == BCJ2_ENC_FINISH_MODE_END_STREAM */
+ // (p->flushRem == 5);
+ p->isFlushState = 1;
+ break;
+ }
+ src++;
+ // p->src = src;
+ }
+ // ip = p->ip; // for marker version
+ /* marker was found */
+ /* (v) contains marker that was found:
+ bits [NUM_SHIFT_BITS : NUM_SHIFT_BITS + 7]
+ : value of src[-2] : xx/xx/0f
+ bits [0 : 7] : value of src[-1] : e8/e9/8x
+ */
+ {
+ {
+ #if NUM_SHIFT_BITS != 24
+ v &= ~(UInt32)CONV_FLAG;
+ #endif
+ // UInt32 relat = 0;
+ if ((SizeT)(p->srcLim - src) >= 4)
+ {
+ /*
+ if (relat != 0 || (Byte)v != 0xe8)
+ BoolInt isBigOffset = True;
+ */
+ const UInt32 relat = GetUi32(src);
+ /*
+ #define EXCLUDE_FLAG ((UInt32)1 << 4)
+ #define NEED_CONVERT(rel) ((((rel) + EXCLUDE_FLAG) & (0 - EXCLUDE_FLAG * 2)) != 0)
+ if (p->relatExcludeBits != 0)
+ {
+ const UInt32 flag = (UInt32)1 << (p->relatExcludeBits - 1);
+ isBigOffset = (((relat + flag) & (0 - flag * 2)) != 0);
+ }
+ // isBigOffset = False; // for debug
+ */
+ ip -= p->fileIp64;
+ // Use the following if check, if (ip) is 64-bit:
+ if (ip > (((v + 0x20) >> 5) & 1)) // 23.00 : we eliminate milti-block overlap for (Of 80) and (e8/e9)
+ if ((CBcj2Enc_ip_unsigned)((CBcj2Enc_ip_signed)ip + 4 + (Int32)relat) <= p->fileSize64_minus1)
+ if (((UInt32)(relat + p->relatLimit) >> 1) < p->relatLimit)
+ v |= CONV_FLAG;
+ }
+ else if (p->finishMode == BCJ2_ENC_FINISH_MODE_CONTINUE)
+ {
+ // (p->srcLim - src < 4)
+ // /*
+ // for non-marker version
+ p->ip64--; // p->ip = ip - 1;
+ p->bufs[BCJ2_STREAM_MAIN]--;
+ src--;
+ v >>= NUM_SHIFT_BITS;
+ // (0 < p->srcLim - p->src <= 4)
+ // */
+ // v |= MARKER_FLAG; // for marker version
+ /* (p->state == BCJ2_ENC_STATE_ORIG) */
+ WRITE_CONTEXT_AND_SRC
+ return;
+ }
+ {
+ const unsigned c = ((v + 0x17) >> 6) & 1;
+ CBcj2Prob *prob = p->probs + (unsigned)
+ (((0 - c) & (Byte)(v >> NUM_SHIFT_BITS)) + c + ((v >> 5) & 1));
+ /*
+ ((Byte)v == 0xe8 ? 2 + ((Byte)(v >> 8)) :
+ ((Byte)v < 0xe8 ? 0 : 1)); // ((v >> 5) & 1));
+ */
+ const unsigned ttt = *prob;
+ const UInt32 bound = (p->range >> kNumBitModelTotalBits) * ttt;
+ if ((v & CONV_FLAG) == 0)
+ {
+ // static int yyy = 0; yyy++; printf("\n!needConvert = %d\n", yyy);
+ // v = (Byte)v; // for marker version
+ p->range = bound;
+ *prob = (CBcj2Prob)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
+ // WRITE_CONTEXT_AND_SRC
+ continue;
+ }
+ p->low += bound;
+ p->range -= bound;
+ *prob = (CBcj2Prob)(ttt - (ttt >> kNumMoveBits));
+ }
+ // p->context = src[3];
+ {
+ // const unsigned cj = ((Byte)v == 0xe8 ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP);
+ const unsigned cj = (((v + 0x57) >> 6) & 1) + BCJ2_STREAM_CALL;
+ ip = p->ip64;
+ v = GetUi32(src); // relat
+ ip += 4;
+ p->ip64 = ip;
+ src += 4;
+ // p->src = src;
+ {
+ const UInt32 absol = (UInt32)ip + v;
+ Byte *cur = p->bufs[cj];
+ v >>= 24;
+ // WRITE_CONTEXT
+ if (cur == p->lims[cj])
+ {
+ p->state = cj;
+ p->tempTarget = absol;
+ WRITE_CONTEXT_AND_SRC
+ return;
+ }
+ SetBe32a(cur, absol)
+ p->bufs[cj] = cur + 4;
+ }
+ }
+ }
+ }
+ } // end of loop
+ }
+
+ for (; p->flushRem != 0; p->flushRem--)
+ if (Bcj2_RangeEnc_ShiftLow(p))
+ return;
+ p->state = BCJ2_ENC_STATE_FINISHED;
+}
+
+
+/*
+BCJ2 encoder needs look ahead for up to 4 bytes in (src) buffer.
+So base function Bcj2Enc_Encode_2()
+ in BCJ2_ENC_FINISH_MODE_CONTINUE mode can return with
+ (p->state == BCJ2_ENC_STATE_ORIG && p->src < p->srcLim)
+Bcj2Enc_Encode() solves that look ahead problem by using p->temp[] buffer.
+ so if (p->state == BCJ2_ENC_STATE_ORIG) after Bcj2Enc_Encode(),
+ then (p->src == p->srcLim).
+ And the caller's code is simpler with Bcj2Enc_Encode().
+*/
+
+Z7_NO_INLINE
+void Bcj2Enc_Encode(CBcj2Enc *p)
+{
+ PRF2("\n----")
+ if (p->tempPos != 0)
+ {
+ /* extra: number of bytes that were copied from (src) to (temp) buffer in this call */
+ unsigned extra = 0;
+ /* We will touch only minimal required number of bytes in input (src) stream.
+ So we will add input bytes from (src) stream to temp[] with step of 1 byte.
+ We don't add new bytes to temp[] before Bcj2Enc_Encode_2() call
+ in first loop iteration because
+ - previous call of Bcj2Enc_Encode() could use another (finishMode),
+ - previous call could finish with (p->state != BCJ2_ENC_STATE_ORIG).
+ the case with full temp[] buffer (p->tempPos == 4) is possible here.
+ */
+ for (;;)
+ {
+ // (0 < p->tempPos <= 5) // in non-marker version
+ /* p->src : the current src data position including extra bytes
+ that were copied to temp[] buffer in this call */
+ const Byte *src = p->src;
+ const Byte *srcLim = p->srcLim;
+ const EBcj2Enc_FinishMode finishMode = p->finishMode;
+ if (src != srcLim)
+ {
+ /* if there are some src data after the data copied to temp[],
+ then we use MODE_CONTINUE for temp data */
+ p->finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+ }
+ p->src = p->temp;
+ p->srcLim = p->temp + p->tempPos;
+ PRF2(" ")
+ Bcj2Enc_Encode_2(p);
+ {
+ const unsigned num = (unsigned)(p->src - p->temp);
+ const unsigned tempPos = p->tempPos - num;
+ unsigned i;
+ p->tempPos = tempPos;
+ for (i = 0; i < tempPos; i++)
+ p->temp[i] = p->temp[(SizeT)i + num];
+ // tempPos : number of bytes in temp buffer
+ p->src = src;
+ p->srcLim = srcLim;
+ p->finishMode = finishMode;
+ if (p->state != BCJ2_ENC_STATE_ORIG)
+ {
+ // (p->tempPos <= 4) // in non-marker version
+ /* if (the reason of exit from Bcj2Enc_Encode_2()
+ is not BCJ2_ENC_STATE_ORIG),
+ then we exit from Bcj2Enc_Encode() with same reason */
+ // optional code begin : we rollback (src) and tempPos, if it's possible:
+ if (extra >= tempPos)
+ extra = tempPos;
+ p->src = src - extra;
+ p->tempPos = tempPos - extra;
+ // optional code end : rollback of (src) and tempPos
+ return;
+ }
+ /* (p->tempPos <= 4)
+ (p->state == BCJ2_ENC_STATE_ORIG)
+ so encoder needs more data than in temp[] */
+ if (src == srcLim)
+ return; // src buffer has no more input data.
+ /* (src != srcLim)
+ so we can provide more input data from src for Bcj2Enc_Encode_2() */
+ if (extra >= tempPos)
+ {
+ /* (extra >= tempPos) means that temp buffer contains
+ only data from src buffer of this call.
+ So now we can encode without temp buffer */
+ p->src = src - tempPos; // rollback (src)
+ p->tempPos = 0;
+ break;
+ }
+ // we append one additional extra byte from (src) to temp[] buffer:
+ p->temp[tempPos] = *src;
+ p->tempPos = tempPos + 1;
+ // (0 < p->tempPos <= 5) // in non-marker version
+ p->src = src + 1;
+ extra++;
+ }
+ }
+ }
+
+ PRF2("++++")
+ // (p->tempPos == 0)
+ Bcj2Enc_Encode_2(p);
+ PRF2("====")
+
+ if (p->state == BCJ2_ENC_STATE_ORIG)
+ {
+ const Byte *src = p->src;
+ const Byte *srcLim = p->srcLim;
+ const unsigned rem = (unsigned)(srcLim - src);
+ /* (rem <= 4) here.
+ if (p->src != p->srcLim), then
+ - we copy non-processed bytes from (p->src) to temp[] buffer,
+ - we set p->src equal to p->srcLim.
+ */
+ if (rem)
+ {
+ unsigned i = 0;
+ p->src = srcLim;
+ p->tempPos = rem;
+ // (0 < p->tempPos <= 4)
+ do
+ p->temp[i] = src[i];
+ while (++i != rem);
+ }
+ // (p->tempPos <= 4)
+ // (p->src == p->srcLim)
+ }
+}
+
+#undef PRF2
+#undef CONV_FLAG
+#undef MARKER_FLAG
+#undef WRITE_CONTEXT
+#undef WRITE_CONTEXT_AND_SRC
+#undef ONE_ITER
+#undef NUM_SHIFT_BITS
+#undef kTopValue
+#undef kNumBitModelTotalBits
+#undef kBitModelTotal
+#undef kNumMoveBits
diff --git a/C/Blake2.h b/C/Blake2.h
new file mode 100644
index 0000000..7235235
--- /dev/null
+++ b/C/Blake2.h
@@ -0,0 +1,48 @@
+/* Blake2.h -- BLAKE2 Hash
+2023-03-04 : Igor Pavlov : Public domain
+2015 : Samuel Neves : Public domain */
+
+#ifndef ZIP7_INC_BLAKE2_H
+#define ZIP7_INC_BLAKE2_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define BLAKE2S_BLOCK_SIZE 64
+#define BLAKE2S_DIGEST_SIZE 32
+#define BLAKE2SP_PARALLEL_DEGREE 8
+
+typedef struct
+{
+ UInt32 h[8];
+ UInt32 t[2];
+ UInt32 f[2];
+ Byte buf[BLAKE2S_BLOCK_SIZE];
+ UInt32 bufPos;
+ UInt32 lastNode_f1;
+ UInt32 dummy[2]; /* for sizeof(CBlake2s) alignment */
+} CBlake2s;
+
+/* You need to xor CBlake2s::h[i] with input parameter block after Blake2s_Init0() */
+/*
+void Blake2s_Init0(CBlake2s *p);
+void Blake2s_Update(CBlake2s *p, const Byte *data, size_t size);
+void Blake2s_Final(CBlake2s *p, Byte *digest);
+*/
+
+
+typedef struct
+{
+ CBlake2s S[BLAKE2SP_PARALLEL_DEGREE];
+ unsigned bufPos;
+} CBlake2sp;
+
+
+void Blake2sp_Init(CBlake2sp *p);
+void Blake2sp_Update(CBlake2sp *p, const Byte *data, size_t size);
+void Blake2sp_Final(CBlake2sp *p, Byte *digest);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Blake2s.c b/C/Blake2s.c
new file mode 100644
index 0000000..2a84b57
--- /dev/null
+++ b/C/Blake2s.c
@@ -0,0 +1,250 @@
+/* Blake2s.c -- BLAKE2s and BLAKE2sp Hash
+2023-03-04 : Igor Pavlov : Public domain
+2015 : Samuel Neves : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Blake2.h"
+#include "CpuArch.h"
+#include "RotateDefs.h"
+
+#define rotr32 rotrFixed
+
+#define BLAKE2S_NUM_ROUNDS 10
+#define BLAKE2S_FINAL_FLAG (~(UInt32)0)
+
+static const UInt32 k_Blake2s_IV[8] =
+{
+ 0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
+ 0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
+};
+
+static const Byte k_Blake2s_Sigma[BLAKE2S_NUM_ROUNDS][16] =
+{
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ,
+ { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } ,
+ { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } ,
+ { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 } ,
+ { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 } ,
+ { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } ,
+ { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 } ,
+ { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 } ,
+ { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 } ,
+ { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } ,
+};
+
+
+static void Blake2s_Init0(CBlake2s *p)
+{
+ unsigned i;
+ for (i = 0; i < 8; i++)
+ p->h[i] = k_Blake2s_IV[i];
+ p->t[0] = 0;
+ p->t[1] = 0;
+ p->f[0] = 0;
+ p->f[1] = 0;
+ p->bufPos = 0;
+ p->lastNode_f1 = 0;
+}
+
+
+static void Blake2s_Compress(CBlake2s *p)
+{
+ UInt32 m[16];
+ UInt32 v[16];
+
+ {
+ unsigned i;
+
+ for (i = 0; i < 16; i++)
+ m[i] = GetUi32(p->buf + i * sizeof(m[i]));
+
+ for (i = 0; i < 8; i++)
+ v[i] = p->h[i];
+ }
+
+ v[ 8] = k_Blake2s_IV[0];
+ v[ 9] = k_Blake2s_IV[1];
+ v[10] = k_Blake2s_IV[2];
+ v[11] = k_Blake2s_IV[3];
+
+ v[12] = p->t[0] ^ k_Blake2s_IV[4];
+ v[13] = p->t[1] ^ k_Blake2s_IV[5];
+ v[14] = p->f[0] ^ k_Blake2s_IV[6];
+ v[15] = p->f[1] ^ k_Blake2s_IV[7];
+
+ #define G(r,i,a,b,c,d) \
+ a += b + m[sigma[2*i+0]]; d ^= a; d = rotr32(d, 16); c += d; b ^= c; b = rotr32(b, 12); \
+ a += b + m[sigma[2*i+1]]; d ^= a; d = rotr32(d, 8); c += d; b ^= c; b = rotr32(b, 7); \
+
+ #define R(r) \
+ G(r,0,v[ 0],v[ 4],v[ 8],v[12]) \
+ G(r,1,v[ 1],v[ 5],v[ 9],v[13]) \
+ G(r,2,v[ 2],v[ 6],v[10],v[14]) \
+ G(r,3,v[ 3],v[ 7],v[11],v[15]) \
+ G(r,4,v[ 0],v[ 5],v[10],v[15]) \
+ G(r,5,v[ 1],v[ 6],v[11],v[12]) \
+ G(r,6,v[ 2],v[ 7],v[ 8],v[13]) \
+ G(r,7,v[ 3],v[ 4],v[ 9],v[14]) \
+
+ {
+ unsigned r;
+ for (r = 0; r < BLAKE2S_NUM_ROUNDS; r++)
+ {
+ const Byte *sigma = k_Blake2s_Sigma[r];
+ R(r)
+ }
+ /* R(0); R(1); R(2); R(3); R(4); R(5); R(6); R(7); R(8); R(9); */
+ }
+
+ #undef G
+ #undef R
+
+ {
+ unsigned i;
+ for (i = 0; i < 8; i++)
+ p->h[i] ^= v[i] ^ v[i + 8];
+ }
+}
+
+
+#define Blake2s_Increment_Counter(S, inc) \
+ { p->t[0] += (inc); p->t[1] += (p->t[0] < (inc)); }
+
+#define Blake2s_Set_LastBlock(p) \
+ { p->f[0] = BLAKE2S_FINAL_FLAG; p->f[1] = p->lastNode_f1; }
+
+
+static void Blake2s_Update(CBlake2s *p, const Byte *data, size_t size)
+{
+ while (size != 0)
+ {
+ unsigned pos = (unsigned)p->bufPos;
+ unsigned rem = BLAKE2S_BLOCK_SIZE - pos;
+
+ if (size <= rem)
+ {
+ memcpy(p->buf + pos, data, size);
+ p->bufPos += (UInt32)size;
+ return;
+ }
+
+ memcpy(p->buf + pos, data, rem);
+ Blake2s_Increment_Counter(S, BLAKE2S_BLOCK_SIZE)
+ Blake2s_Compress(p);
+ p->bufPos = 0;
+ data += rem;
+ size -= rem;
+ }
+}
+
+
+static void Blake2s_Final(CBlake2s *p, Byte *digest)
+{
+ unsigned i;
+
+ Blake2s_Increment_Counter(S, (UInt32)p->bufPos)
+ Blake2s_Set_LastBlock(p)
+ memset(p->buf + p->bufPos, 0, BLAKE2S_BLOCK_SIZE - p->bufPos);
+ Blake2s_Compress(p);
+
+ for (i = 0; i < 8; i++)
+ {
+ SetUi32(digest + sizeof(p->h[i]) * i, p->h[i])
+ }
+}
+
+
+/* ---------- BLAKE2s ---------- */
+
+/* we need to xor CBlake2s::h[i] with input parameter block after Blake2s_Init0() */
+/*
+typedef struct
+{
+ Byte digest_length;
+ Byte key_length;
+ Byte fanout;
+ Byte depth;
+ UInt32 leaf_length;
+ Byte node_offset[6];
+ Byte node_depth;
+ Byte inner_length;
+ Byte salt[BLAKE2S_SALTBYTES];
+ Byte personal[BLAKE2S_PERSONALBYTES];
+} CBlake2sParam;
+*/
+
+
+static void Blake2sp_Init_Spec(CBlake2s *p, unsigned node_offset, unsigned node_depth)
+{
+ Blake2s_Init0(p);
+
+ p->h[0] ^= (BLAKE2S_DIGEST_SIZE | ((UInt32)BLAKE2SP_PARALLEL_DEGREE << 16) | ((UInt32)2 << 24));
+ p->h[2] ^= ((UInt32)node_offset);
+ p->h[3] ^= ((UInt32)node_depth << 16) | ((UInt32)BLAKE2S_DIGEST_SIZE << 24);
+ /*
+ P->digest_length = BLAKE2S_DIGEST_SIZE;
+ P->key_length = 0;
+ P->fanout = BLAKE2SP_PARALLEL_DEGREE;
+ P->depth = 2;
+ P->leaf_length = 0;
+ store48(P->node_offset, node_offset);
+ P->node_depth = node_depth;
+ P->inner_length = BLAKE2S_DIGEST_SIZE;
+ */
+}
+
+
+void Blake2sp_Init(CBlake2sp *p)
+{
+ unsigned i;
+
+ p->bufPos = 0;
+
+ for (i = 0; i < BLAKE2SP_PARALLEL_DEGREE; i++)
+ Blake2sp_Init_Spec(&p->S[i], i, 0);
+
+ p->S[BLAKE2SP_PARALLEL_DEGREE - 1].lastNode_f1 = BLAKE2S_FINAL_FLAG;
+}
+
+
+void Blake2sp_Update(CBlake2sp *p, const Byte *data, size_t size)
+{
+ unsigned pos = p->bufPos;
+ while (size != 0)
+ {
+ unsigned index = pos / BLAKE2S_BLOCK_SIZE;
+ unsigned rem = BLAKE2S_BLOCK_SIZE - (pos & (BLAKE2S_BLOCK_SIZE - 1));
+ if (rem > size)
+ rem = (unsigned)size;
+ Blake2s_Update(&p->S[index], data, rem);
+ size -= rem;
+ data += rem;
+ pos += rem;
+ pos &= (BLAKE2S_BLOCK_SIZE * BLAKE2SP_PARALLEL_DEGREE - 1);
+ }
+ p->bufPos = pos;
+}
+
+
+void Blake2sp_Final(CBlake2sp *p, Byte *digest)
+{
+ CBlake2s R;
+ unsigned i;
+
+ Blake2sp_Init_Spec(&R, 0, 1);
+ R.lastNode_f1 = BLAKE2S_FINAL_FLAG;
+
+ for (i = 0; i < BLAKE2SP_PARALLEL_DEGREE; i++)
+ {
+ Byte hash[BLAKE2S_DIGEST_SIZE];
+ Blake2s_Final(&p->S[i], hash);
+ Blake2s_Update(&R, hash, BLAKE2S_DIGEST_SIZE);
+ }
+
+ Blake2s_Final(&R, digest);
+}
+
+#undef rotr32
diff --git a/C/Bra.c b/C/Bra.c
index cbdcb29..22e0e47 100644
--- a/C/Bra.c
+++ b/C/Bra.c
@@ -1,230 +1,420 @@
-/* Bra.c -- Converters for RISC code
-2017-04-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-#include "Bra.h"
-
-SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
- Byte *p;
- const Byte *lim;
- size &= ~(size_t)3;
- ip += 4;
- p = data;
- lim = data + size;
-
- if (encoding)
-
- for (;;)
- {
- for (;;)
- {
- if (p >= lim)
- return p - data;
- p += 4;
- if (p[-1] == 0xEB)
- break;
- }
- {
- UInt32 v = GetUi32(p - 4);
- v <<= 2;
- v += ip + (UInt32)(p - data);
- v >>= 2;
- v &= 0x00FFFFFF;
- v |= 0xEB000000;
- SetUi32(p - 4, v);
- }
- }
-
- for (;;)
- {
- for (;;)
- {
- if (p >= lim)
- return p - data;
- p += 4;
- if (p[-1] == 0xEB)
- break;
- }
- {
- UInt32 v = GetUi32(p - 4);
- v <<= 2;
- v -= ip + (UInt32)(p - data);
- v >>= 2;
- v &= 0x00FFFFFF;
- v |= 0xEB000000;
- SetUi32(p - 4, v);
- }
- }
-}
-
-
-SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
- Byte *p;
- const Byte *lim;
- size &= ~(size_t)1;
- p = data;
- lim = data + size - 4;
-
- if (encoding)
-
- for (;;)
- {
- UInt32 b1;
- for (;;)
- {
- UInt32 b3;
- if (p > lim)
- return p - data;
- b1 = p[1];
- b3 = p[3];
- p += 2;
- b1 ^= 8;
- if ((b3 & b1) >= 0xF8)
- break;
- }
- {
- UInt32 v =
- ((UInt32)b1 << 19)
- + (((UInt32)p[1] & 0x7) << 8)
- + (((UInt32)p[-2] << 11))
- + (p[0]);
-
- p += 2;
- {
- UInt32 cur = (ip + (UInt32)(p - data)) >> 1;
- v += cur;
- }
-
- p[-4] = (Byte)(v >> 11);
- p[-3] = (Byte)(0xF0 | ((v >> 19) & 0x7));
- p[-2] = (Byte)v;
- p[-1] = (Byte)(0xF8 | (v >> 8));
- }
- }
-
- for (;;)
- {
- UInt32 b1;
- for (;;)
- {
- UInt32 b3;
- if (p > lim)
- return p - data;
- b1 = p[1];
- b3 = p[3];
- p += 2;
- b1 ^= 8;
- if ((b3 & b1) >= 0xF8)
- break;
- }
- {
- UInt32 v =
- ((UInt32)b1 << 19)
- + (((UInt32)p[1] & 0x7) << 8)
- + (((UInt32)p[-2] << 11))
- + (p[0]);
-
- p += 2;
- {
- UInt32 cur = (ip + (UInt32)(p - data)) >> 1;
- v -= cur;
- }
-
- /*
- SetUi16(p - 4, (UInt16)(((v >> 11) & 0x7FF) | 0xF000));
- SetUi16(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));
- }
- }
-}
-
-
-SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
- Byte *p;
- const Byte *lim;
- size &= ~(size_t)3;
- ip -= 4;
- p = data;
- lim = data + size;
-
- for (;;)
- {
- for (;;)
- {
- if (p >= lim)
- return p - data;
- p += 4;
- /* if ((v & 0xFC000003) == 0x48000001) */
- if ((p[-4] & 0xFC) == 0x48 && (p[-1] & 3) == 1)
- break;
- }
- {
- UInt32 v = GetBe32(p - 4);
- if (encoding)
- v += ip + (UInt32)(p - data);
- else
- v -= ip + (UInt32)(p - data);
- v &= 0x03FFFFFF;
- v |= 0x48000000;
- SetBe32(p - 4, v);
- }
- }
-}
-
-
-SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
- Byte *p;
- const Byte *lim;
- size &= ~(size_t)3;
- ip -= 4;
- p = data;
- lim = data + size;
-
- for (;;)
- {
- for (;;)
- {
- if (p >= lim)
- return p - data;
- /*
- v = GetBe32(p);
- p += 4;
- m = v + ((UInt32)5 << 29);
- m ^= (UInt32)7 << 29;
- m += (UInt32)1 << 22;
- if ((m & ((UInt32)0x1FF << 23)) == 0)
- break;
- */
- p += 4;
- if ((p[-4] == 0x40 && (p[-3] & 0xC0) == 0) ||
- (p[-4] == 0x7F && (p[-3] >= 0xC0)))
- break;
- }
- {
- UInt32 v = GetBe32(p - 4);
- v <<= 2;
- if (encoding)
- v += ip + (UInt32)(p - data);
- else
- v -= ip + (UInt32)(p - data);
-
- v &= 0x01FFFFFF;
- v -= (UInt32)1 << 24;
- v ^= 0xFF000000;
- v >>= 2;
- v |= 0x40000000;
- SetBe32(p - 4, v);
- }
- }
-}
+/* 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)
diff --git a/C/Bra.h b/C/Bra.h
index aba8dce..a4ee568 100644
--- a/C/Bra.h
+++ b/C/Bra.h
@@ -1,64 +1,99 @@
-/* Bra.h -- Branch converters for executables
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __BRA_H
-#define __BRA_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/*
-These functions convert relative addresses to absolute addresses
-in CALL instructions to increase the compression ratio.
-
- In:
- data - data buffer
- size - size of data
- ip - current virtual Instruction Pinter (IP) value
- state - state variable for x86 converter
- encoding - 0 (for decoding), 1 (for encoding)
-
- Out:
- state - state variable for x86 converter
-
- Returns:
- The number of processed bytes. If you call these functions with multiple calls,
- you must start next call with first byte after block of processed bytes.
-
- Type Endian Alignment LookAhead
-
- x86 little 1 4
- ARMT little 2 2
- ARM little 4 0
- PPC big 4 0
- SPARC big 4 0
- IA64 little 16 0
-
- size must be >= Alignment + LookAhead, if it's not last block.
- If (size < Alignment + LookAhead), converter returns 0.
-
- Example:
-
- UInt32 ip = 0;
- for ()
- {
- ; size must be >= Alignment + LookAhead, if it's not last block
- SizeT processed = Convert(data, size, ip, 1);
- data += processed;
- size -= processed;
- ip += processed;
- }
-*/
-
-#define x86_Convert_Init(state) { state = 0; }
-SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding);
-SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/Bra86.c b/C/Bra86.c
index a6463c6..d81f392 100644
--- a/C/Bra86.c
+++ b/C/Bra86.c
@@ -1,82 +1,187 @@
-/* Bra86.c -- Converter for x86 code (BCJ)
-2017-04-03 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Bra.h"
-
-#define Test86MSByte(b) ((((b) + 1) & 0xFE) == 0)
-
-SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding)
-{
- SizeT pos = 0;
- UInt32 mask = *state & 7;
- if (size < 5)
- return 0;
- size -= 4;
- ip += 5;
-
- for (;;)
- {
- Byte *p = data + pos;
- const Byte *limit = data + size;
- for (; p < limit; p++)
- if ((*p & 0xFE) == 0xE8)
- break;
-
- {
- SizeT d = (SizeT)(p - data - pos);
- pos = (SizeT)(p - data);
- if (p >= limit)
- {
- *state = (d > 2 ? 0 : mask >> (unsigned)d);
- return pos;
- }
- if (d > 2)
- mask = 0;
- else
- {
- mask >>= (unsigned)d;
- if (mask != 0 && (mask > 4 || mask == 3 || Test86MSByte(p[(size_t)(mask >> 1) + 1])))
- {
- mask = (mask >> 1) | 4;
- pos++;
- continue;
- }
- }
- }
-
- if (Test86MSByte(p[4]))
- {
- UInt32 v = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]);
- UInt32 cur = ip + (UInt32)pos;
- pos += 5;
- if (encoding)
- v += cur;
- else
- v -= cur;
- if (mask != 0)
- {
- unsigned sh = (mask & 6) << 2;
- if (Test86MSByte((Byte)(v >> sh)))
- {
- v ^= (((UInt32)0x100 << sh) - 1);
- if (encoding)
- v += cur;
- else
- v -= cur;
- }
- mask = 0;
- }
- p[1] = (Byte)v;
- p[2] = (Byte)(v >> 8);
- p[3] = (Byte)(v >> 16);
- p[4] = (Byte)(0 - ((v >> 24) & 1));
- }
- else
- {
- mask = (mask >> 1) | 4;
- pos++;
- }
- }
-}
+/* 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
diff --git a/C/BraIA64.c b/C/BraIA64.c
index 2656907..9dfe3e2 100644
--- a/C/BraIA64.c
+++ b/C/BraIA64.c
@@ -1,53 +1,14 @@
-/* BraIA64.c -- Converter for IA-64 code
-2017-01-26 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-#include "Bra.h"
-
-SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
-{
- SizeT i;
- if (size < 16)
- return 0;
- size -= 16;
- i = 0;
- do
- {
- unsigned m = ((UInt32)0x334B0000 >> (data[i] & 0x1E)) & 3;
- if (m)
- {
- m++;
- do
- {
- Byte *p = data + (i + (size_t)m * 5 - 8);
- if (((p[3] >> m) & 15) == 5
- && (((p[-1] | ((UInt32)p[0] << 8)) >> m) & 0x70) == 0)
- {
- unsigned raw = GetUi32(p);
- unsigned v = raw >> m;
- v = (v & 0xFFFFF) | ((v & (1 << 23)) >> 3);
-
- v <<= 4;
- if (encoding)
- v += ip + (UInt32)i;
- else
- v -= ip + (UInt32)i;
- v >>= 4;
-
- v &= 0x1FFFFF;
- v += 0x700000;
- v &= 0x8FFFFF;
- raw &= ~((UInt32)0x8FFFFF << m);
- raw |= (v << m);
- SetUi32(p, raw);
- }
- }
- while (++m <= 4);
- }
- i += 16;
- }
- while (i <= size);
- return i;
-}
+/* 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
diff --git a/C/BwtSort.c b/C/BwtSort.c
new file mode 100644
index 0000000..05ad6de
--- /dev/null
+++ b/C/BwtSort.c
@@ -0,0 +1,516 @@
+/* BwtSort.c -- BWT block sorting
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "BwtSort.h"
+#include "Sort.h"
+
+/* #define BLOCK_SORT_USE_HEAP_SORT */
+
+/* Don't change it !!! */
+#define kNumHashBytes 2
+#define kNumHashValues (1 << (kNumHashBytes * 8))
+
+/* kNumRefBitsMax must be < (kNumHashBytes * 8) = 16 */
+#define kNumRefBitsMax 12
+
+#define BS_TEMP_SIZE kNumHashValues
+
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
+
+/* 32 Flags in UInt32 word */
+#define kNumFlagsBits 5
+#define kNumFlagsInWord (1 << kNumFlagsBits)
+#define kFlagsMask (kNumFlagsInWord - 1)
+#define kAllFlags 0xFFFFFFFF
+
+#else
+
+#define kNumBitsMax 20
+#define kIndexMask ((1 << kNumBitsMax) - 1)
+#define kNumExtraBits (32 - kNumBitsMax)
+#define kNumExtra0Bits (kNumExtraBits - 2)
+#define kNumExtra0Mask ((1 << kNumExtra0Bits) - 1)
+
+#define SetFinishedGroupSize(p, size) \
+ { *(p) |= ((((size) - 1) & kNumExtra0Mask) << kNumBitsMax); \
+ if ((size) > (1 << kNumExtra0Bits)) { \
+ *(p) |= 0x40000000; *((p) + 1) |= ((((size) - 1)>> kNumExtra0Bits) << kNumBitsMax); } } \
+
+static void SetGroupSize(UInt32 *p, UInt32 size)
+{
+ if (--size == 0)
+ return;
+ *p |= 0x80000000 | ((size & kNumExtra0Mask) << kNumBitsMax);
+ if (size >= (1 << kNumExtra0Bits))
+ {
+ *p |= 0x40000000;
+ p[1] |= ((size >> kNumExtra0Bits) << kNumBitsMax);
+ }
+}
+
+#endif
+
+/*
+SortGroup - is recursive Range-Sort function with HeapSort optimization for small blocks
+ "range" is not real range. It's only for optimization.
+returns: 1 - if there are groups, 0 - no more groups
+*/
+
+static
+UInt32
+Z7_FASTCALL
+SortGroup(UInt32 BlockSize, UInt32 NumSortedBytes, UInt32 groupOffset, UInt32 groupSize, int NumRefBits, UInt32 *Indices
+ #ifndef BLOCK_SORT_USE_HEAP_SORT
+ , UInt32 left, UInt32 range
+ #endif
+ )
+{
+ UInt32 *ind2 = Indices + groupOffset;
+ UInt32 *Groups;
+ if (groupSize <= 1)
+ {
+ /*
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ SetFinishedGroupSize(ind2, 1)
+ #endif
+ */
+ return 0;
+ }
+ Groups = Indices + BlockSize + BS_TEMP_SIZE;
+ if (groupSize <= ((UInt32)1 << NumRefBits)
+ #ifndef BLOCK_SORT_USE_HEAP_SORT
+ && groupSize <= range
+ #endif
+ )
+ {
+ UInt32 *temp = Indices + BlockSize;
+ UInt32 j;
+ UInt32 mask, thereAreGroups, group, cg;
+ {
+ UInt32 gPrev;
+ UInt32 gRes = 0;
+ {
+ UInt32 sp = ind2[0] + NumSortedBytes;
+ if (sp >= BlockSize) sp -= BlockSize;
+ gPrev = Groups[sp];
+ temp[0] = (gPrev << NumRefBits);
+ }
+
+ for (j = 1; j < groupSize; j++)
+ {
+ UInt32 sp = ind2[j] + NumSortedBytes;
+ UInt32 g;
+ if (sp >= BlockSize) sp -= BlockSize;
+ g = Groups[sp];
+ temp[j] = (g << NumRefBits) | j;
+ gRes |= (gPrev ^ g);
+ }
+ if (gRes == 0)
+ {
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ SetGroupSize(ind2, groupSize);
+ #endif
+ return 1;
+ }
+ }
+
+ HeapSort(temp, groupSize);
+ mask = (((UInt32)1 << NumRefBits) - 1);
+ thereAreGroups = 0;
+
+ group = groupOffset;
+ cg = (temp[0] >> NumRefBits);
+ temp[0] = ind2[temp[0] & mask];
+
+ {
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ UInt32 *Flags = Groups + BlockSize;
+ #else
+ UInt32 prevGroupStart = 0;
+ #endif
+
+ for (j = 1; j < groupSize; j++)
+ {
+ UInt32 val = temp[j];
+ UInt32 cgCur = (val >> NumRefBits);
+
+ if (cgCur != cg)
+ {
+ cg = cgCur;
+ group = groupOffset + j;
+
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ {
+ UInt32 t = group - 1;
+ Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
+ }
+ #else
+ SetGroupSize(temp + prevGroupStart, j - prevGroupStart);
+ prevGroupStart = j;
+ #endif
+ }
+ else
+ thereAreGroups = 1;
+ {
+ UInt32 ind = ind2[val & mask];
+ temp[j] = ind;
+ Groups[ind] = group;
+ }
+ }
+
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ SetGroupSize(temp + prevGroupStart, j - prevGroupStart);
+ #endif
+ }
+
+ for (j = 0; j < groupSize; j++)
+ ind2[j] = temp[j];
+ return thereAreGroups;
+ }
+
+ /* Check that all strings are in one group (cannot sort) */
+ {
+ UInt32 group, j;
+ UInt32 sp = ind2[0] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+ group = Groups[sp];
+ for (j = 1; j < groupSize; j++)
+ {
+ sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+ if (Groups[sp] != group)
+ break;
+ }
+ if (j == groupSize)
+ {
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ SetGroupSize(ind2, groupSize);
+ #endif
+ return 1;
+ }
+ }
+
+ #ifndef BLOCK_SORT_USE_HEAP_SORT
+ {
+ /* ---------- Range Sort ---------- */
+ UInt32 i;
+ UInt32 mid;
+ for (;;)
+ {
+ UInt32 j;
+ if (range <= 1)
+ {
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ SetGroupSize(ind2, groupSize);
+ #endif
+ return 1;
+ }
+ mid = left + ((range + 1) >> 1);
+ j = groupSize;
+ i = 0;
+ do
+ {
+ UInt32 sp = ind2[i] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+ if (Groups[sp] >= mid)
+ {
+ for (j--; j > i; j--)
+ {
+ sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+ if (Groups[sp] < mid)
+ {
+ UInt32 temp = ind2[i]; ind2[i] = ind2[j]; ind2[j] = temp;
+ break;
+ }
+ }
+ if (i >= j)
+ break;
+ }
+ }
+ while (++i < j);
+ if (i == 0)
+ {
+ range = range - (mid - left);
+ left = mid;
+ }
+ else if (i == groupSize)
+ range = (mid - left);
+ else
+ break;
+ }
+
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ {
+ UInt32 t = (groupOffset + i - 1);
+ UInt32 *Flags = Groups + BlockSize;
+ Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
+ }
+ #endif
+
+ {
+ UInt32 j;
+ for (j = i; j < groupSize; j++)
+ Groups[ind2[j]] = groupOffset + i;
+ }
+
+ {
+ UInt32 res = SortGroup(BlockSize, NumSortedBytes, groupOffset, i, NumRefBits, Indices, left, mid - left);
+ return res | SortGroup(BlockSize, NumSortedBytes, groupOffset + i, groupSize - i, NumRefBits, Indices, mid, range - (mid - left));
+ }
+
+ }
+
+ #else
+
+ /* ---------- Heap Sort ---------- */
+
+ {
+ UInt32 j;
+ for (j = 0; j < groupSize; j++)
+ {
+ UInt32 sp = ind2[j] + NumSortedBytes; if (sp >= BlockSize) sp -= BlockSize;
+ ind2[j] = sp;
+ }
+
+ HeapSortRef(ind2, Groups, groupSize);
+
+ /* Write Flags */
+ {
+ UInt32 sp = ind2[0];
+ UInt32 group = Groups[sp];
+
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ UInt32 *Flags = Groups + BlockSize;
+ #else
+ UInt32 prevGroupStart = 0;
+ #endif
+
+ for (j = 1; j < groupSize; j++)
+ {
+ sp = ind2[j];
+ if (Groups[sp] != group)
+ {
+ group = Groups[sp];
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ {
+ UInt32 t = groupOffset + j - 1;
+ Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
+ }
+ #else
+ SetGroupSize(ind2 + prevGroupStart, j - prevGroupStart);
+ prevGroupStart = j;
+ #endif
+ }
+ }
+
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ SetGroupSize(ind2 + prevGroupStart, j - prevGroupStart);
+ #endif
+ }
+ {
+ /* Write new Groups values and Check that there are groups */
+ UInt32 thereAreGroups = 0;
+ for (j = 0; j < groupSize; j++)
+ {
+ UInt32 group = groupOffset + j;
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ UInt32 subGroupSize = ((ind2[j] & ~0xC0000000) >> kNumBitsMax);
+ if ((ind2[j] & 0x40000000) != 0)
+ subGroupSize += ((ind2[(size_t)j + 1] >> kNumBitsMax) << kNumExtra0Bits);
+ subGroupSize++;
+ for (;;)
+ {
+ UInt32 original = ind2[j];
+ UInt32 sp = original & kIndexMask;
+ if (sp < NumSortedBytes) sp += BlockSize; sp -= NumSortedBytes;
+ ind2[j] = sp | (original & ~kIndexMask);
+ Groups[sp] = group;
+ if (--subGroupSize == 0)
+ break;
+ j++;
+ thereAreGroups = 1;
+ }
+ #else
+ UInt32 *Flags = Groups + BlockSize;
+ for (;;)
+ {
+ UInt32 sp = ind2[j]; if (sp < NumSortedBytes) sp += BlockSize; sp -= NumSortedBytes;
+ ind2[j] = sp;
+ Groups[sp] = group;
+ if ((Flags[(groupOffset + j) >> kNumFlagsBits] & (1 << ((groupOffset + j) & kFlagsMask))) == 0)
+ break;
+ j++;
+ thereAreGroups = 1;
+ }
+ #endif
+ }
+ return thereAreGroups;
+ }
+ }
+ #endif
+}
+
+/* conditions: blockSize > 0 */
+UInt32 BlockSort(UInt32 *Indices, const Byte *data, UInt32 blockSize)
+{
+ UInt32 *counters = Indices + blockSize;
+ UInt32 i;
+ UInt32 *Groups;
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ UInt32 *Flags;
+ #endif
+
+ /* Radix-Sort for 2 bytes */
+ for (i = 0; i < kNumHashValues; i++)
+ counters[i] = 0;
+ for (i = 0; i < blockSize - 1; i++)
+ counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]]++;
+ counters[((UInt32)data[i] << 8) | data[0]]++;
+
+ Groups = counters + BS_TEMP_SIZE;
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ Flags = Groups + blockSize;
+ {
+ UInt32 numWords = (blockSize + kFlagsMask) >> kNumFlagsBits;
+ for (i = 0; i < numWords; i++)
+ Flags[i] = kAllFlags;
+ }
+ #endif
+
+ {
+ UInt32 sum = 0;
+ for (i = 0; i < kNumHashValues; i++)
+ {
+ UInt32 groupSize = counters[i];
+ if (groupSize > 0)
+ {
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+ UInt32 t = sum + groupSize - 1;
+ Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask));
+ #endif
+ sum += groupSize;
+ }
+ counters[i] = sum - groupSize;
+ }
+
+ for (i = 0; i < blockSize - 1; i++)
+ Groups[i] = counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]];
+ Groups[i] = counters[((UInt32)data[i] << 8) | data[0]];
+
+ for (i = 0; i < blockSize - 1; i++)
+ Indices[counters[((UInt32)data[i] << 8) | data[(size_t)i + 1]]++] = i;
+ Indices[counters[((UInt32)data[i] << 8) | data[0]]++] = i;
+
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ {
+ UInt32 prev = 0;
+ for (i = 0; i < kNumHashValues; i++)
+ {
+ UInt32 prevGroupSize = counters[i] - prev;
+ if (prevGroupSize == 0)
+ continue;
+ SetGroupSize(Indices + prev, prevGroupSize);
+ prev = counters[i];
+ }
+ }
+ #endif
+ }
+
+ {
+ int NumRefBits;
+ UInt32 NumSortedBytes;
+ for (NumRefBits = 0; ((blockSize - 1) >> NumRefBits) != 0; NumRefBits++);
+ NumRefBits = 32 - NumRefBits;
+ if (NumRefBits > kNumRefBitsMax)
+ NumRefBits = kNumRefBitsMax;
+
+ for (NumSortedBytes = kNumHashBytes; ; NumSortedBytes <<= 1)
+ {
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ UInt32 finishedGroupSize = 0;
+ #endif
+ UInt32 newLimit = 0;
+ for (i = 0; i < blockSize;)
+ {
+ UInt32 groupSize;
+ #ifdef BLOCK_SORT_EXTERNAL_FLAGS
+
+ if ((Flags[i >> kNumFlagsBits] & (1 << (i & kFlagsMask))) == 0)
+ {
+ i++;
+ continue;
+ }
+ for (groupSize = 1;
+ (Flags[(i + groupSize) >> kNumFlagsBits] & (1 << ((i + groupSize) & kFlagsMask))) != 0;
+ groupSize++);
+
+ groupSize++;
+
+ #else
+
+ groupSize = ((Indices[i] & ~0xC0000000) >> kNumBitsMax);
+ {
+ BoolInt finishedGroup = ((Indices[i] & 0x80000000) == 0);
+ if ((Indices[i] & 0x40000000) != 0)
+ {
+ groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
+ Indices[(size_t)i + 1] &= kIndexMask;
+ }
+ Indices[i] &= kIndexMask;
+ groupSize++;
+ if (finishedGroup || groupSize == 1)
+ {
+ Indices[i - finishedGroupSize] &= kIndexMask;
+ if (finishedGroupSize > 1)
+ Indices[(size_t)(i - finishedGroupSize) + 1] &= kIndexMask;
+ {
+ UInt32 newGroupSize = groupSize + finishedGroupSize;
+ SetFinishedGroupSize(Indices + i - finishedGroupSize, newGroupSize)
+ finishedGroupSize = newGroupSize;
+ }
+ i += groupSize;
+ continue;
+ }
+ finishedGroupSize = 0;
+ }
+
+ #endif
+
+ if (NumSortedBytes >= blockSize)
+ {
+ UInt32 j;
+ for (j = 0; j < groupSize; j++)
+ {
+ UInt32 t = (i + j);
+ /* Flags[t >> kNumFlagsBits] &= ~(1 << (t & kFlagsMask)); */
+ Groups[Indices[t]] = t;
+ }
+ }
+ else
+ if (SortGroup(blockSize, NumSortedBytes, i, groupSize, NumRefBits, Indices
+ #ifndef BLOCK_SORT_USE_HEAP_SORT
+ , 0, blockSize
+ #endif
+ ) != 0)
+ newLimit = i + groupSize;
+ i += groupSize;
+ }
+ if (newLimit == 0)
+ break;
+ }
+ }
+ #ifndef BLOCK_SORT_EXTERNAL_FLAGS
+ for (i = 0; i < blockSize;)
+ {
+ UInt32 groupSize = ((Indices[i] & ~0xC0000000) >> kNumBitsMax);
+ if ((Indices[i] & 0x40000000) != 0)
+ {
+ groupSize += ((Indices[(size_t)i + 1] >> kNumBitsMax) << kNumExtra0Bits);
+ Indices[(size_t)i + 1] &= kIndexMask;
+ }
+ Indices[i] &= kIndexMask;
+ groupSize++;
+ i += groupSize;
+ }
+ #endif
+ return Groups[0];
+}
diff --git a/C/BwtSort.h b/C/BwtSort.h
new file mode 100644
index 0000000..a34b243
--- /dev/null
+++ b/C/BwtSort.h
@@ -0,0 +1,26 @@
+/* BwtSort.h -- BWT block sorting
+2023-03-03 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_BWT_SORT_H
+#define ZIP7_INC_BWT_SORT_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+/* use BLOCK_SORT_EXTERNAL_FLAGS if blockSize can be > 1M */
+/* #define BLOCK_SORT_EXTERNAL_FLAGS */
+
+#ifdef BLOCK_SORT_EXTERNAL_FLAGS
+#define BLOCK_SORT_EXTERNAL_SIZE(blockSize) ((((blockSize) + 31) >> 5))
+#else
+#define BLOCK_SORT_EXTERNAL_SIZE(blockSize) 0
+#endif
+
+#define BLOCK_SORT_BUF_SIZE(blockSize) ((blockSize) * 2 + BLOCK_SORT_EXTERNAL_SIZE(blockSize) + (1 << 16))
+
+UInt32 BlockSort(UInt32 *indices, const Byte *data, UInt32 blockSize);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Compiler.h b/C/Compiler.h
index c788648..185a52d 100644
--- a/C/Compiler.h
+++ b/C/Compiler.h
@@ -1,33 +1,159 @@
-/* Compiler.h
-2017-04-03 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_COMPILER_H
-#define __7Z_COMPILER_H
-
-#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 _MSC_VER >= 1300
- #pragma warning(disable : 4996) // This function or variable may be unsafe
- #else
- #pragma warning(disable : 4511) // copy constructor could not be generated
- #pragma warning(disable : 4512) // assignment operator could not be generated
- #pragma warning(disable : 4514) // unreferenced inline function has been removed
- #pragma warning(disable : 4702) // unreachable code
- #pragma warning(disable : 4710) // not inlined
- #pragma warning(disable : 4714) // function marked as __forceinline not inlined
- #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
- #endif
-
-#endif
-
-#define UNUSED_VAR(x) (void)x;
-/* #define UNUSED_VAR(x) x=x; */
-
-#endif
+/* 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
diff --git a/C/CpuArch.c b/C/CpuArch.c
index ff1890e..33f8a3a 100644
--- a/C/CpuArch.c
+++ b/C/CpuArch.c
@@ -1,218 +1,823 @@
-/* CpuArch.c -- CPU specific code
-2018-02-18: Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-#if (defined(_MSC_VER) && !defined(MY_CPU_AMD64)) || defined(__GNUC__)
-#define USE_ASM
-#endif
-
-#if !defined(USE_ASM) && _MSC_VER >= 1500
-#include <intrin.h>
-#endif
-
-#if defined(USE_ASM) && !defined(MY_CPU_AMD64)
-static UInt32 CheckFlag(UInt32 flag)
-{
- #ifdef _MSC_VER
- __asm pushfd;
- __asm pop EAX;
- __asm mov EDX, EAX;
- __asm xor EAX, flag;
- __asm push EAX;
- __asm popfd;
- __asm pushfd;
- __asm pop EAX;
- __asm xor EAX, EDX;
- __asm push EDX;
- __asm popfd;
- __asm and flag, EAX;
- #else
- __asm__ __volatile__ (
- "pushf\n\t"
- "pop %%EAX\n\t"
- "movl %%EAX,%%EDX\n\t"
- "xorl %0,%%EAX\n\t"
- "push %%EAX\n\t"
- "popf\n\t"
- "pushf\n\t"
- "pop %%EAX\n\t"
- "xorl %%EDX,%%EAX\n\t"
- "push %%EDX\n\t"
- "popf\n\t"
- "andl %%EAX, %0\n\t":
- "=c" (flag) : "c" (flag) :
- "%eax", "%edx");
- #endif
- return flag;
-}
-#define CHECK_CPUID_IS_SUPPORTED if (CheckFlag(1 << 18) == 0 || CheckFlag(1 << 21) == 0) return False;
-#else
-#define CHECK_CPUID_IS_SUPPORTED
-#endif
-
-void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)
-{
- #ifdef USE_ASM
-
- #ifdef _MSC_VER
-
- UInt32 a2, b2, c2, d2;
- __asm xor EBX, EBX;
- __asm xor ECX, ECX;
- __asm xor EDX, EDX;
- __asm mov EAX, function;
- __asm cpuid;
- __asm mov a2, EAX;
- __asm mov b2, EBX;
- __asm mov c2, ECX;
- __asm mov d2, EDX;
-
- *a = a2;
- *b = b2;
- *c = c2;
- *d = d2;
-
- #else
-
- __asm__ __volatile__ (
- #if defined(MY_CPU_AMD64) && defined(__PIC__)
- "mov %%rbx, %%rdi;"
- "cpuid;"
- "xchg %%rbx, %%rdi;"
- : "=a" (*a) ,
- "=D" (*b) ,
- #elif defined(MY_CPU_X86) && defined(__PIC__)
- "mov %%ebx, %%edi;"
- "cpuid;"
- "xchgl %%ebx, %%edi;"
- : "=a" (*a) ,
- "=D" (*b) ,
- #else
- "cpuid"
- : "=a" (*a) ,
- "=b" (*b) ,
- #endif
- "=c" (*c) ,
- "=d" (*d)
- : "0" (function)) ;
-
- #endif
-
- #else
-
- int CPUInfo[4];
- __cpuid(CPUInfo, function);
- *a = CPUInfo[0];
- *b = CPUInfo[1];
- *c = CPUInfo[2];
- *d = CPUInfo[3];
-
- #endif
-}
-
-BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p)
-{
- CHECK_CPUID_IS_SUPPORTED
- MyCPUID(0, &p->maxFunc, &p->vendor[0], &p->vendor[2], &p->vendor[1]);
- MyCPUID(1, &p->ver, &p->b, &p->c, &p->d);
- return True;
-}
-
-static const UInt32 kVendors[][3] =
-{
- { 0x756E6547, 0x49656E69, 0x6C65746E},
- { 0x68747541, 0x69746E65, 0x444D4163},
- { 0x746E6543, 0x48727561, 0x736C7561}
-};
-
-int x86cpuid_GetFirm(const Cx86cpuid *p)
-{
- unsigned i;
- for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[i]); 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;
- int firm;
- UInt32 family, model;
- if (!x86cpuid_CheckAndRead(&p))
- return True;
-
- family = x86cpuid_GetFamily(p.ver);
- model = x86cpuid_GetModel(p.ver);
-
- firm = x86cpuid_GetFirm(&p);
-
- switch (firm)
- {
- 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 True;
-}
-
-#if !defined(MY_CPU_AMD64) && defined(_WIN32)
-#include <windows.h>
-static BoolInt CPU_Sys_Is_SSE_Supported()
-{
- OSVERSIONINFO vi;
- vi.dwOSVersionInfoSize = sizeof(vi);
- if (!GetVersionEx(&vi))
- return False;
- return (vi.dwMajorVersion >= 5);
-}
-#define CHECK_SYS_SSE_SUPPORT if (!CPU_Sys_Is_SSE_Supported()) return False;
-#else
-#define CHECK_SYS_SSE_SUPPORT
-#endif
-
-BoolInt CPU_Is_Aes_Supported()
-{
- Cx86cpuid p;
- CHECK_SYS_SSE_SUPPORT
- if (!x86cpuid_CheckAndRead(&p))
- return False;
- return (p.c >> 25) & 1;
-}
-
-BoolInt CPU_IsSupported_PageGB()
-{
- Cx86cpuid cpuid;
- if (!x86cpuid_CheckAndRead(&cpuid))
- return False;
- {
- UInt32 d[4] = { 0 };
- MyCPUID(0x80000000, &d[0], &d[1], &d[2], &d[3]);
- if (d[0] < 0x80000001)
- return False;
- }
- {
- UInt32 d[4] = { 0 };
- MyCPUID(0x80000001, &d[0], &d[1], &d[2], &d[3]);
- return (d[3] >> 26) & 1;
- }
-}
-
-#endif
+/* 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
diff --git a/C/CpuArch.h b/C/CpuArch.h
index 5f74c1c..8e5d8a5 100644
--- a/C/CpuArch.h
+++ b/C/CpuArch.h
@@ -1,336 +1,523 @@
-/* CpuArch.h -- CPU specific code
-2018-02-18 : Igor Pavlov : Public domain */
-
-#ifndef __CPU_ARCH_H
-#define __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.
-*/
-
-#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"
- #else
- #define MY_CPU_NAME "x64"
- #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
-#endif
-
-
-#if defined(_M_ARM64) \
- || defined(__AARCH64EL__) \
- || defined(__AARCH64EB__) \
- || defined(__aarch64__)
- #define MY_CPU_ARM64
- #define MY_CPU_NAME "arm64"
- #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
- #define MY_CPU_NAME "arm"
- #define MY_CPU_32BIT
-#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__)
- #ifdef __ILP32__
- #define MY_CPU_NAME "ppc64-32"
- #else
- #define MY_CPU_NAME "ppc64"
- #endif
- #define MY_CPU_64BIT
-#elif defined(__ppc__) \
- || defined(__powerpc__)
- #define MY_CPU_NAME "ppc"
- #define MY_CPU_32BIT
-#endif
-
-
-#if defined(__sparc64__)
- #define MY_CPU_NAME "sparc64"
- #define MY_CPU_64BIT
-#elif defined(__sparc__)
- #define MY_CPU_NAME "sparc"
- /* #define MY_CPU_32BIT */
-#endif
-
-
-#if defined(MY_CPU_X86) || defined(MY_CPU_AMD64)
-#define MY_CPU_X86_OR_AMD64
-#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_32BIT) && defined(MY_CPU_64BIT)
- #error Stop_Compiling_Bad_32_64_BIT
-#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 MY_CPU_LE
- #if defined(MY_CPU_X86_OR_AMD64) \
- || defined(MY_CPU_ARM64) \
- || defined(__ARM_FEATURE_UNALIGNED)
- #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))
-#define GetUi64(p) (*(const UInt64 *)(const void *)(p))
-
-#define SetUi16(p, v) { *(UInt16 *)(p) = (v); }
-#define SetUi32(p, v) { *(UInt32 *)(p) = (v); }
-#define SetUi64(p, v) { *(UInt64 *)(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 GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32))
-
-#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); }
-
-#define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); UInt64 _vvv2_ = (v); \
- SetUi32(_ppp2_ , (UInt32)_vvv2_); \
- SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)); }
-
-#endif
-
-#ifdef __has_builtin
- #define MY__has_builtin(x) __has_builtin(x)
-#else
- #define MY__has_builtin(x) 0
-#endif
-
-#if defined(MY_CPU_LE_UNALIGN) && /* defined(_WIN64) && */ (_MSC_VER >= 1300)
-
-/* Note: we use bswap instruction, that is unsupported in 386 cpu */
-
-#include <stdlib.h>
-
-#pragma intrinsic(_byteswap_ushort)
-#pragma intrinsic(_byteswap_ulong)
-#pragma intrinsic(_byteswap_uint64)
-
-/* #define GetBe16(p) _byteswap_ushort(*(const UInt16 *)(const Byte *)(p)) */
-#define GetBe32(p) _byteswap_ulong(*(const UInt32 *)(const Byte *)(p))
-#define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const Byte *)(p))
-
-#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = _byteswap_ulong(v)
-
-#elif defined(MY_CPU_LE_UNALIGN) && ( \
- (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \
- || (defined(__clang__) && MY__has_builtin(__builtin_bswap16)) )
-
-/* #define GetBe16(p) __builtin_bswap16(*(const UInt16 *)(const Byte *)(p)) */
-#define GetBe32(p) __builtin_bswap32(*(const UInt32 *)(const Byte *)(p))
-#define GetBe64(p) __builtin_bswap64(*(const UInt64 *)(const Byte *)(p))
-
-#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = __builtin_bswap32(v)
-
-#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 GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))
-
-#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 GetBe16
-
-#define GetBe16(p) ( (UInt16) ( \
- ((UInt16)((const Byte *)(p))[0] << 8) | \
- ((const Byte *)(p))[1] ))
-
-#endif
-
-
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-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
-};
-
-void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d);
-
-BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p);
-int x86cpuid_GetFirm(const Cx86cpuid *p);
-
-#define x86cpuid_GetFamily(ver) (((ver >> 16) & 0xFF0) | ((ver >> 8) & 0xF))
-#define x86cpuid_GetModel(ver) (((ver >> 12) & 0xF0) | ((ver >> 4) & 0xF))
-#define x86cpuid_GetStepping(ver) (ver & 0xF)
-
-BoolInt CPU_Is_InOrder();
-BoolInt CPU_Is_Aes_Supported();
-BoolInt CPU_IsSupported_PageGB();
-
-#endif
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/Delta.c b/C/Delta.c
index 6cbbe46..c4a4499 100644
--- a/C/Delta.c
+++ b/C/Delta.c
@@ -1,64 +1,169 @@
-/* Delta.c -- Delta converter
-2009-05-26 : 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;
-}
-
-static void MyMemCpy(Byte *dest, const Byte *src, unsigned size)
-{
- unsigned i;
- for (i = 0; i < size; i++)
- dest[i] = src[i];
-}
-
-void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)
-{
- Byte buf[DELTA_STATE_SIZE];
- unsigned j = 0;
- MyMemCpy(buf, state, delta);
- {
- SizeT i;
- for (i = 0; i < size;)
- {
- for (j = 0; j < delta && i < size; i++, j++)
- {
- Byte b = data[i];
- data[i] = (Byte)(b - buf[j]);
- buf[j] = b;
- }
- }
- }
- if (j == delta)
- j = 0;
- MyMemCpy(state, buf + j, delta - j);
- MyMemCpy(state + delta - j, buf, j);
-}
-
-void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size)
-{
- Byte buf[DELTA_STATE_SIZE];
- unsigned j = 0;
- MyMemCpy(buf, state, delta);
- {
- SizeT i;
- for (i = 0; i < size;)
- {
- for (j = 0; j < delta && i < size; i++, j++)
- {
- buf[j] = data[i] = (Byte)(buf[j] + data[i]);
- }
- }
- }
- if (j == delta)
- j = 0;
- MyMemCpy(state, buf + j, delta - j);
- MyMemCpy(state + delta - j, buf, j);
-}
+/* 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);
+}
diff --git a/C/Delta.h b/C/Delta.h
index e59d5a2..7060954 100644
--- a/C/Delta.h
+++ b/C/Delta.h
@@ -1,19 +1,19 @@
-/* Delta.h -- Delta converter
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __DELTA_H
-#define __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
+/* 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
diff --git a/C/DllSecur.c b/C/DllSecur.c
index 19a22a9..02a0f97 100644
--- a/C/DllSecur.c
+++ b/C/DllSecur.c
@@ -1,108 +1,111 @@
-/* DllSecur.c -- DLL loading security
-2018-02-21 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#ifdef _WIN32
-
-#include <windows.h>
-
-#include "DllSecur.h"
-
-#ifndef UNDER_CE
-
-typedef BOOL (WINAPI *Func_SetDefaultDllDirectories)(DWORD DirectoryFlags);
-
-#define MY_LOAD_LIBRARY_SEARCH_USER_DIRS 0x400
-#define MY_LOAD_LIBRARY_SEARCH_SYSTEM32 0x800
-
-static const char * const g_Dlls =
- #ifndef _CONSOLE
- "UXTHEME\0"
- #endif
- "USERENV\0"
- "SETUPAPI\0"
- "APPHELP\0"
- "PROPSYS\0"
- "DWMAPI\0"
- "CRYPTBASE\0"
- "OLEACC\0"
- "CLBCATQ\0"
- "VERSION\0"
- ;
-
-#endif
-
-void My_SetDefaultDllDirectories()
-{
- #ifndef UNDER_CE
-
- OSVERSIONINFO vi;
- vi.dwOSVersionInfoSize = sizeof(vi);
- GetVersionEx(&vi);
- if (!GetVersionEx(&vi) || vi.dwMajorVersion != 6 || vi.dwMinorVersion != 0)
- {
- Func_SetDefaultDllDirectories setDllDirs = (Func_SetDefaultDllDirectories)
- GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "SetDefaultDllDirectories");
- if (setDllDirs)
- if (setDllDirs(MY_LOAD_LIBRARY_SEARCH_SYSTEM32 | MY_LOAD_LIBRARY_SEARCH_USER_DIRS))
- return;
- }
-
- #endif
-}
-
-
-void LoadSecurityDlls()
-{
- #ifndef UNDER_CE
-
- wchar_t buf[MAX_PATH + 100];
-
- {
- // at Vista (ver 6.0) : CoCreateInstance(CLSID_ShellLink, ...) doesn't work after SetDefaultDllDirectories() : Check it ???
- OSVERSIONINFO vi;
- vi.dwOSVersionInfoSize = sizeof(vi);
- if (!GetVersionEx(&vi) || vi.dwMajorVersion != 6 || vi.dwMinorVersion != 0)
- {
- Func_SetDefaultDllDirectories setDllDirs = (Func_SetDefaultDllDirectories)
- GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "SetDefaultDllDirectories");
- if (setDllDirs)
- if (setDllDirs(MY_LOAD_LIBRARY_SEARCH_SYSTEM32 | MY_LOAD_LIBRARY_SEARCH_USER_DIRS))
- return;
- }
- }
-
- {
- unsigned len = GetSystemDirectoryW(buf, MAX_PATH + 2);
- if (len == 0 || len > MAX_PATH)
- return;
- }
- {
- const char *dll;
- unsigned pos = (unsigned)lstrlenW(buf);
-
- if (buf[pos - 1] != '\\')
- buf[pos++] = '\\';
-
- for (dll = g_Dlls; dll[0] != 0;)
- {
- unsigned k = 0;
- for (;;)
- {
- char c = *dll++;
- buf[pos + k] = (Byte)c;
- k++;
- if (c == 0)
- break;
- }
-
- lstrcatW(buf, L".dll");
- LoadLibraryExW(buf, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
- }
- }
-
- #endif
-}
-
-#endif
+/* DllSecur.c -- DLL loading security
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#ifdef _WIN32
+
+#include "7zWindows.h"
+
+#include "DllSecur.h"
+
+#ifndef UNDER_CE
+
+#if (defined(__GNUC__) && (__GNUC__ >= 8)) || defined(__clang__)
+ // #pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
+
+#if defined(__clang__) || defined(__GNUC__)
+typedef void (*Z7_voidFunction)(void);
+#define MY_CAST_FUNC (Z7_voidFunction)
+#elif defined(_MSC_VER) && _MSC_VER > 1920
+#define MY_CAST_FUNC (void *)
+// #pragma warning(disable : 4191) // 'type cast': unsafe conversion from 'FARPROC' to 'void (__cdecl *)()'
+#else
+#define MY_CAST_FUNC
+#endif
+
+typedef BOOL (WINAPI *Func_SetDefaultDllDirectories)(DWORD DirectoryFlags);
+
+#define MY_LOAD_LIBRARY_SEARCH_USER_DIRS 0x400
+#define MY_LOAD_LIBRARY_SEARCH_SYSTEM32 0x800
+
+#define DELIM "\0"
+
+static const char * const g_Dlls =
+ "userenv"
+ DELIM "setupapi"
+ DELIM "apphelp"
+ DELIM "propsys"
+ DELIM "dwmapi"
+ DELIM "cryptbase"
+ DELIM "oleacc"
+ DELIM "clbcatq"
+ DELIM "version"
+ #ifndef _CONSOLE
+ DELIM "uxtheme"
+ #endif
+ DELIM;
+
+#endif
+
+#ifdef __clang__
+ #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#if defined (_MSC_VER) && _MSC_VER >= 1900
+// sysinfoapi.h: kit10: GetVersion was declared deprecated
+#pragma warning(disable : 4996)
+#endif
+
+#define IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN \
+ if ((UInt16)GetVersion() != 6) { \
+ const \
+ Func_SetDefaultDllDirectories setDllDirs = \
+ (Func_SetDefaultDllDirectories) MY_CAST_FUNC GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), \
+ "SetDefaultDllDirectories"); \
+ if (setDllDirs) if (setDllDirs(MY_LOAD_LIBRARY_SEARCH_SYSTEM32 | MY_LOAD_LIBRARY_SEARCH_USER_DIRS)) return; }
+
+void My_SetDefaultDllDirectories(void)
+{
+ #ifndef UNDER_CE
+ IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN
+ #endif
+}
+
+
+void LoadSecurityDlls(void)
+{
+ #ifndef UNDER_CE
+ // at Vista (ver 6.0) : CoCreateInstance(CLSID_ShellLink, ...) doesn't work after SetDefaultDllDirectories() : Check it ???
+ IF_NON_VISTA_SET_DLL_DIRS_AND_RETURN
+ {
+ wchar_t buf[MAX_PATH + 100];
+ const char *dll;
+ unsigned pos = GetSystemDirectoryW(buf, MAX_PATH + 2);
+ if (pos == 0 || pos > MAX_PATH)
+ return;
+ if (buf[pos - 1] != '\\')
+ buf[pos++] = '\\';
+ for (dll = g_Dlls; *dll != 0;)
+ {
+ wchar_t *dest = &buf[pos];
+ for (;;)
+ {
+ const char c = *dll++;
+ if (c == 0)
+ break;
+ *dest++ = (Byte)c;
+ }
+ dest[0] = '.';
+ dest[1] = 'd';
+ dest[2] = 'l';
+ dest[3] = 'l';
+ dest[4] = 0;
+ // lstrcatW(buf, L".dll");
+ LoadLibraryExW(buf, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
+ }
+ }
+ #endif
+}
+
+#endif // _WIN32
diff --git a/C/DllSecur.h b/C/DllSecur.h
index 4c11356..9fa4153 100644
--- a/C/DllSecur.h
+++ b/C/DllSecur.h
@@ -1,20 +1,20 @@
-/* DllSecur.h -- DLL loading for security
-2018-02-19 : Igor Pavlov : Public domain */
-
-#ifndef __DLL_SECUR_H
-#define __DLL_SECUR_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#ifdef _WIN32
-
-void My_SetDefaultDllDirectories();
-void LoadSecurityDlls();
-
-#endif
-
-EXTERN_C_END
-
-#endif
+/* DllSecur.h -- DLL loading for security
+2023-03-03 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_DLL_SECUR_H
+#define ZIP7_INC_DLL_SECUR_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#ifdef _WIN32
+
+void My_SetDefaultDllDirectories(void);
+void LoadSecurityDlls(void);
+
+#endif
+
+EXTERN_C_END
+
+#endif
diff --git a/C/HuffEnc.c b/C/HuffEnc.c
new file mode 100644
index 0000000..3dc1e39
--- /dev/null
+++ b/C/HuffEnc.c
@@ -0,0 +1,154 @@
+/* HuffEnc.c -- functions for Huffman encoding
+2023-03-04 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "HuffEnc.h"
+#include "Sort.h"
+
+#define kMaxLen 16
+#define NUM_BITS 10
+#define MASK (((unsigned)1 << NUM_BITS) - 1)
+
+#define NUM_COUNTERS 64
+
+#define HUFFMAN_SPEED_OPT
+
+void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 numSymbols, UInt32 maxLen)
+{
+ UInt32 num = 0;
+ /* if (maxLen > 10) maxLen = 10; */
+ {
+ UInt32 i;
+
+ #ifdef HUFFMAN_SPEED_OPT
+
+ UInt32 counters[NUM_COUNTERS];
+ for (i = 0; i < NUM_COUNTERS; i++)
+ counters[i] = 0;
+ for (i = 0; i < numSymbols; i++)
+ {
+ UInt32 freq = freqs[i];
+ counters[(freq < NUM_COUNTERS - 1) ? freq : NUM_COUNTERS - 1]++;
+ }
+
+ for (i = 1; i < NUM_COUNTERS; i++)
+ {
+ UInt32 temp = counters[i];
+ counters[i] = num;
+ num += temp;
+ }
+
+ for (i = 0; i < numSymbols; i++)
+ {
+ UInt32 freq = freqs[i];
+ if (freq == 0)
+ lens[i] = 0;
+ else
+ p[counters[((freq < NUM_COUNTERS - 1) ? freq : NUM_COUNTERS - 1)]++] = i | (freq << NUM_BITS);
+ }
+ counters[0] = 0;
+ HeapSort(p + counters[NUM_COUNTERS - 2], counters[NUM_COUNTERS - 1] - counters[NUM_COUNTERS - 2]);
+
+ #else
+
+ for (i = 0; i < numSymbols; i++)
+ {
+ UInt32 freq = freqs[i];
+ if (freq == 0)
+ lens[i] = 0;
+ else
+ p[num++] = i | (freq << NUM_BITS);
+ }
+ HeapSort(p, num);
+
+ #endif
+ }
+
+ if (num < 2)
+ {
+ unsigned minCode = 0;
+ unsigned maxCode = 1;
+ if (num == 1)
+ {
+ maxCode = (unsigned)p[0] & MASK;
+ if (maxCode == 0)
+ maxCode++;
+ }
+ p[minCode] = 0;
+ p[maxCode] = 1;
+ lens[minCode] = lens[maxCode] = 1;
+ return;
+ }
+
+ {
+ UInt32 b, e, i;
+
+ i = b = e = 0;
+ do
+ {
+ UInt32 n, m, freq;
+ n = (i != num && (b == e || (p[i] >> NUM_BITS) <= (p[b] >> NUM_BITS))) ? i++ : b++;
+ freq = (p[n] & ~MASK);
+ p[n] = (p[n] & MASK) | (e << NUM_BITS);
+ m = (i != num && (b == e || (p[i] >> NUM_BITS) <= (p[b] >> NUM_BITS))) ? i++ : b++;
+ freq += (p[m] & ~MASK);
+ p[m] = (p[m] & MASK) | (e << NUM_BITS);
+ p[e] = (p[e] & MASK) | freq;
+ e++;
+ }
+ while (num - e > 1);
+
+ {
+ UInt32 lenCounters[kMaxLen + 1];
+ for (i = 0; i <= kMaxLen; i++)
+ lenCounters[i] = 0;
+
+ p[--e] &= MASK;
+ lenCounters[1] = 2;
+ while (e != 0)
+ {
+ UInt32 len = (p[p[--e] >> NUM_BITS] >> NUM_BITS) + 1;
+ p[e] = (p[e] & MASK) | (len << NUM_BITS);
+ if (len >= maxLen)
+ for (len = maxLen - 1; lenCounters[len] == 0; len--);
+ lenCounters[len]--;
+ lenCounters[(size_t)len + 1] += 2;
+ }
+
+ {
+ UInt32 len;
+ i = 0;
+ for (len = maxLen; len != 0; len--)
+ {
+ UInt32 k;
+ for (k = lenCounters[len]; k != 0; k--)
+ lens[p[i++] & MASK] = (Byte)len;
+ }
+ }
+
+ {
+ UInt32 nextCodes[kMaxLen + 1];
+ {
+ UInt32 code = 0;
+ UInt32 len;
+ for (len = 1; len <= kMaxLen; len++)
+ nextCodes[len] = code = (code + lenCounters[(size_t)len - 1]) << 1;
+ }
+ /* if (code + lenCounters[kMaxLen] - 1 != (1 << kMaxLen) - 1) throw 1; */
+
+ {
+ UInt32 k;
+ for (k = 0; k < numSymbols; k++)
+ p[k] = nextCodes[lens[k]]++;
+ }
+ }
+ }
+ }
+}
+
+#undef kMaxLen
+#undef NUM_BITS
+#undef MASK
+#undef NUM_COUNTERS
+#undef HUFFMAN_SPEED_OPT
diff --git a/C/HuffEnc.h b/C/HuffEnc.h
new file mode 100644
index 0000000..cbc5d11
--- /dev/null
+++ b/C/HuffEnc.h
@@ -0,0 +1,23 @@
+/* HuffEnc.h -- Huffman encoding
+2023-03-05 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_HUFF_ENC_H
+#define ZIP7_INC_HUFF_ENC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+/*
+Conditions:
+ num <= 1024 = 2 ^ NUM_BITS
+ Sum(freqs) < 4M = 2 ^ (32 - NUM_BITS)
+ maxLen <= 16 = kMaxLen
+ Num_Items(p) >= HUFFMAN_TEMP_SIZE(num)
+*/
+
+void Huffman_Generate(const UInt32 *freqs, UInt32 *p, Byte *lens, UInt32 num, UInt32 maxLen);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/LzFind.c b/C/LzFind.c
index 4eefc17..0fbd5aa 100644
--- a/C/LzFind.c
+++ b/C/LzFind.c
@@ -1,1127 +1,1717 @@
-/* LzFind.c -- Match finder for LZ algorithms
-2018-07-08 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "LzFind.h"
-#include "LzHash.h"
-
-#define kEmptyHashValue 0
-#define kMaxValForNormalize ((UInt32)0xFFFFFFFF)
-#define kNormalizeStepMin (1 << 10) /* it must be power of 2 */
-#define kNormalizeMask (~(UInt32)(kNormalizeStepMin - 1))
-#define kMaxHistorySize ((UInt32)7 << 29)
-
-#define kStartMaxLen 3
-
-static void LzInWindow_Free(CMatchFinder *p, ISzAllocPtr alloc)
-{
- if (!p->directInput)
- {
- ISzAlloc_Free(alloc, p->bufferBase);
- p->bufferBase = NULL;
- }
-}
-
-/* keepSizeBefore + keepSizeAfter + keepSizeReserv must be < 4G) */
-
-static int LzInWindow_Create(CMatchFinder *p, UInt32 keepSizeReserv, ISzAllocPtr alloc)
-{
- UInt32 blockSize = p->keepSizeBefore + p->keepSizeAfter + keepSizeReserv;
- if (p->directInput)
- {
- p->blockSize = blockSize;
- return 1;
- }
- if (!p->bufferBase || p->blockSize != blockSize)
- {
- LzInWindow_Free(p, alloc);
- p->blockSize = blockSize;
- p->bufferBase = (Byte *)ISzAlloc_Alloc(alloc, (size_t)blockSize);
- }
- return (p->bufferBase != NULL);
-}
-
-Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
-
-UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
-
-void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue)
-{
- p->posLimit -= subValue;
- p->pos -= subValue;
- p->streamPos -= subValue;
-}
-
-static void MatchFinder_ReadBlock(CMatchFinder *p)
-{
- if (p->streamEndWasReached || p->result != SZ_OK)
- return;
-
- /* We use (p->streamPos - p->pos) value. (p->streamPos < p->pos) is allowed. */
-
- if (p->directInput)
- {
- UInt32 curSize = 0xFFFFFFFF - (p->streamPos - p->pos);
- if (curSize > p->directInputRem)
- curSize = (UInt32)p->directInputRem;
- p->directInputRem -= curSize;
- p->streamPos += curSize;
- if (p->directInputRem == 0)
- p->streamEndWasReached = 1;
- return;
- }
-
- for (;;)
- {
- Byte *dest = p->buffer + (p->streamPos - p->pos);
- size_t size = (p->bufferBase + p->blockSize - dest);
- if (size == 0)
- return;
-
- p->result = ISeqInStream_Read(p->stream, dest, &size);
- if (p->result != SZ_OK)
- return;
- if (size == 0)
- {
- p->streamEndWasReached = 1;
- return;
- }
- p->streamPos += (UInt32)size;
- if (p->streamPos - p->pos > p->keepSizeAfter)
- return;
- }
-}
-
-void MatchFinder_MoveBlock(CMatchFinder *p)
-{
- memmove(p->bufferBase,
- p->buffer - p->keepSizeBefore,
- (size_t)(p->streamPos - p->pos) + p->keepSizeBefore);
- p->buffer = p->bufferBase + p->keepSizeBefore;
-}
-
-int MatchFinder_NeedMove(CMatchFinder *p)
-{
- if (p->directInput)
- return 0;
- /* if (p->streamEndWasReached) return 0; */
- return ((size_t)(p->bufferBase + p->blockSize - p->buffer) <= p->keepSizeAfter);
-}
-
-void MatchFinder_ReadIfRequired(CMatchFinder *p)
-{
- if (p->streamEndWasReached)
- return;
- if (p->keepSizeAfter >= p->streamPos - p->pos)
- MatchFinder_ReadBlock(p);
-}
-
-static void MatchFinder_CheckAndMoveAndRead(CMatchFinder *p)
-{
- if (MatchFinder_NeedMove(p))
- MatchFinder_MoveBlock(p);
- MatchFinder_ReadBlock(p);
-}
-
-static void MatchFinder_SetDefaultSettings(CMatchFinder *p)
-{
- p->cutValue = 32;
- p->btMode = 1;
- p->numHashBytes = 4;
- p->bigHash = 0;
-}
-
-#define kCrcPoly 0xEDB88320
-
-void MatchFinder_Construct(CMatchFinder *p)
-{
- unsigned i;
- p->bufferBase = NULL;
- p->directInput = 0;
- p->hash = NULL;
- p->expectedDataSize = (UInt64)(Int64)-1;
- MatchFinder_SetDefaultSettings(p);
-
- for (i = 0; i < 256; i++)
- {
- UInt32 r = (UInt32)i;
- unsigned j;
- for (j = 0; j < 8; j++)
- r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
- p->crc[i] = r;
- }
-}
-
-static void MatchFinder_FreeThisClassMemory(CMatchFinder *p, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, p->hash);
- p->hash = NULL;
-}
-
-void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc)
-{
- MatchFinder_FreeThisClassMemory(p, alloc);
- LzInWindow_Free(p, alloc);
-}
-
-static CLzRef* AllocRefs(size_t num, ISzAllocPtr alloc)
-{
- size_t sizeInBytes = (size_t)num * sizeof(CLzRef);
- if (sizeInBytes / sizeof(CLzRef) != num)
- return NULL;
- return (CLzRef *)ISzAlloc_Alloc(alloc, sizeInBytes);
-}
-
-int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
- UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
- ISzAllocPtr alloc)
-{
- UInt32 sizeReserv;
-
- if (historySize > kMaxHistorySize)
- {
- MatchFinder_Free(p, alloc);
- return 0;
- }
-
- sizeReserv = historySize >> 1;
- if (historySize >= ((UInt32)3 << 30)) sizeReserv = historySize >> 3;
- else if (historySize >= ((UInt32)2 << 30)) sizeReserv = historySize >> 2;
-
- sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);
-
- p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
- p->keepSizeAfter = matchMaxLen + keepAddBufferAfter;
-
- /* we need one additional byte, since we use MoveBlock after pos++ and before dictionary using */
-
- if (LzInWindow_Create(p, sizeReserv, alloc))
- {
- UInt32 newCyclicBufferSize = historySize + 1;
- UInt32 hs;
- p->matchMaxLen = matchMaxLen;
- {
- p->fixedHashSize = 0;
- if (p->numHashBytes == 2)
- hs = (1 << 16) - 1;
- else
- {
- hs = historySize;
- if (hs > p->expectedDataSize)
- hs = (UInt32)p->expectedDataSize;
- if (hs != 0)
- hs--;
- hs |= (hs >> 1);
- hs |= (hs >> 2);
- hs |= (hs >> 4);
- hs |= (hs >> 8);
- hs >>= 1;
- hs |= 0xFFFF; /* don't change it! It's required for Deflate */
- if (hs > (1 << 24))
- {
- if (p->numHashBytes == 3)
- hs = (1 << 24) - 1;
- else
- hs >>= 1;
- /* if (bigHash) mode, GetHeads4b() in LzFindMt.c needs (hs >= ((1 << 24) - 1))) */
- }
- }
- p->hashMask = hs;
- hs++;
- if (p->numHashBytes > 2) p->fixedHashSize += kHash2Size;
- if (p->numHashBytes > 3) p->fixedHashSize += kHash3Size;
- if (p->numHashBytes > 4) p->fixedHashSize += kHash4Size;
- hs += p->fixedHashSize;
- }
-
- {
- size_t newSize;
- size_t numSons;
- p->historySize = historySize;
- p->hashSizeSum = hs;
- p->cyclicBufferSize = newCyclicBufferSize;
-
- numSons = newCyclicBufferSize;
- if (p->btMode)
- numSons <<= 1;
- newSize = hs + numSons;
-
- if (p->hash && p->numRefs == newSize)
- return 1;
-
- MatchFinder_FreeThisClassMemory(p, alloc);
- p->numRefs = newSize;
- p->hash = AllocRefs(newSize, alloc);
-
- if (p->hash)
- {
- p->son = p->hash + p->hashSizeSum;
- return 1;
- }
- }
- }
-
- MatchFinder_Free(p, alloc);
- return 0;
-}
-
-static void MatchFinder_SetLimits(CMatchFinder *p)
-{
- UInt32 limit = kMaxValForNormalize - p->pos;
- UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
-
- if (limit2 < limit)
- limit = limit2;
- limit2 = p->streamPos - p->pos;
-
- if (limit2 <= p->keepSizeAfter)
- {
- if (limit2 > 0)
- limit2 = 1;
- }
- else
- limit2 -= p->keepSizeAfter;
-
- if (limit2 < limit)
- limit = limit2;
-
- {
- UInt32 lenLimit = p->streamPos - p->pos;
- if (lenLimit > p->matchMaxLen)
- lenLimit = p->matchMaxLen;
- p->lenLimit = lenLimit;
- }
- p->posLimit = p->pos + limit;
-}
-
-
-void MatchFinder_Init_LowHash(CMatchFinder *p)
-{
- size_t i;
- CLzRef *items = p->hash;
- size_t numItems = p->fixedHashSize;
- for (i = 0; i < numItems; i++)
- items[i] = kEmptyHashValue;
-}
-
-
-void MatchFinder_Init_HighHash(CMatchFinder *p)
-{
- size_t i;
- CLzRef *items = p->hash + p->fixedHashSize;
- size_t numItems = (size_t)p->hashMask + 1;
- for (i = 0; i < numItems; i++)
- items[i] = kEmptyHashValue;
-}
-
-
-void MatchFinder_Init_3(CMatchFinder *p, int readData)
-{
- p->cyclicBufferPos = 0;
- p->buffer = p->bufferBase;
- p->pos =
- p->streamPos = p->cyclicBufferSize;
- p->result = SZ_OK;
- p->streamEndWasReached = 0;
-
- if (readData)
- MatchFinder_ReadBlock(p);
-
- MatchFinder_SetLimits(p);
-}
-
-
-void MatchFinder_Init(CMatchFinder *p)
-{
- MatchFinder_Init_HighHash(p);
- MatchFinder_Init_LowHash(p);
- MatchFinder_Init_3(p, True);
-}
-
-
-static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
-{
- return (p->pos - p->historySize - 1) & kNormalizeMask;
-}
-
-void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems)
-{
- size_t i;
- for (i = 0; i < numItems; i++)
- {
- UInt32 value = items[i];
- if (value <= subValue)
- value = kEmptyHashValue;
- else
- value -= subValue;
- items[i] = value;
- }
-}
-
-static void MatchFinder_Normalize(CMatchFinder *p)
-{
- UInt32 subValue = MatchFinder_GetSubValue(p);
- MatchFinder_Normalize3(subValue, p->hash, p->numRefs);
- MatchFinder_ReduceOffsets(p, subValue);
-}
-
-
-MY_NO_INLINE
-static void MatchFinder_CheckLimits(CMatchFinder *p)
-{
- if (p->pos == kMaxValForNormalize)
- MatchFinder_Normalize(p);
- if (!p->streamEndWasReached && p->keepSizeAfter == p->streamPos - p->pos)
- MatchFinder_CheckAndMoveAndRead(p);
- if (p->cyclicBufferPos == p->cyclicBufferSize)
- p->cyclicBufferPos = 0;
- MatchFinder_SetLimits(p);
-}
-
-
-/*
- (lenLimit > maxLen)
-*/
-MY_FORCE_INLINE
-static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
- UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
- UInt32 *distances, unsigned maxLen)
-{
- /*
- son[_cyclicBufferPos] = curMatch;
- for (;;)
- {
- UInt32 delta = pos - curMatch;
- if (cutValue-- == 0 || delta >= _cyclicBufferSize)
- return distances;
- {
- const Byte *pb = cur - delta;
- curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
- if (pb[maxLen] == cur[maxLen] && *pb == *cur)
- {
- UInt32 len = 0;
- while (++len != lenLimit)
- if (pb[len] != cur[len])
- break;
- if (maxLen < len)
- {
- maxLen = len;
- *distances++ = len;
- *distances++ = delta - 1;
- if (len == lenLimit)
- return distances;
- }
- }
- }
- }
- */
-
- const Byte *lim = cur + lenLimit;
- son[_cyclicBufferPos] = curMatch;
- do
- {
- UInt32 delta = pos - curMatch;
- if (delta >= _cyclicBufferSize)
- break;
- {
- ptrdiff_t diff;
- curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
- diff = (ptrdiff_t)0 - delta;
- if (cur[maxLen] == cur[maxLen + diff])
- {
- const Byte *c = cur;
- while (*c == c[diff])
- {
- if (++c == lim)
- {
- distances[0] = (UInt32)(lim - cur);
- distances[1] = delta - 1;
- return distances + 2;
- }
- }
- {
- unsigned len = (unsigned)(c - cur);
- if (maxLen < len)
- {
- maxLen = len;
- distances[0] = (UInt32)len;
- distances[1] = delta - 1;
- distances += 2;
- }
- }
- }
- }
- }
- while (--cutValue);
-
- return distances;
-}
-
-
-MY_FORCE_INLINE
-UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
- UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
- UInt32 *distances, UInt32 maxLen)
-{
- CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
- CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
- unsigned len0 = 0, len1 = 0;
- for (;;)
- {
- UInt32 delta = pos - curMatch;
- if (cutValue-- == 0 || delta >= _cyclicBufferSize)
- {
- *ptr0 = *ptr1 = kEmptyHashValue;
- return distances;
- }
- {
- CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
- const Byte *pb = cur - delta;
- unsigned len = (len0 < len1 ? len0 : len1);
- UInt32 pair0 = pair[0];
- if (pb[len] == cur[len])
- {
- if (++len != lenLimit && pb[len] == cur[len])
- while (++len != lenLimit)
- if (pb[len] != cur[len])
- break;
- if (maxLen < len)
- {
- maxLen = (UInt32)len;
- *distances++ = (UInt32)len;
- *distances++ = delta - 1;
- if (len == lenLimit)
- {
- *ptr1 = pair0;
- *ptr0 = pair[1];
- return distances;
- }
- }
- }
- if (pb[len] < cur[len])
- {
- *ptr1 = curMatch;
- ptr1 = pair + 1;
- curMatch = *ptr1;
- len1 = len;
- }
- else
- {
- *ptr0 = curMatch;
- ptr0 = pair;
- curMatch = *ptr0;
- len0 = len;
- }
- }
- }
-}
-
-static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
- UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue)
-{
- CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
- CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
- unsigned len0 = 0, len1 = 0;
- for (;;)
- {
- UInt32 delta = pos - curMatch;
- if (cutValue-- == 0 || delta >= _cyclicBufferSize)
- {
- *ptr0 = *ptr1 = kEmptyHashValue;
- return;
- }
- {
- CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
- const Byte *pb = cur - delta;
- unsigned len = (len0 < len1 ? len0 : len1);
- if (pb[len] == cur[len])
- {
- while (++len != lenLimit)
- if (pb[len] != cur[len])
- break;
- {
- if (len == lenLimit)
- {
- *ptr1 = pair[0];
- *ptr0 = pair[1];
- return;
- }
- }
- }
- if (pb[len] < cur[len])
- {
- *ptr1 = curMatch;
- ptr1 = pair + 1;
- curMatch = *ptr1;
- len1 = len;
- }
- else
- {
- *ptr0 = curMatch;
- ptr0 = pair;
- curMatch = *ptr0;
- len0 = len;
- }
- }
- }
-}
-
-#define MOVE_POS \
- ++p->cyclicBufferPos; \
- p->buffer++; \
- if (++p->pos == p->posLimit) MatchFinder_CheckLimits(p);
-
-#define MOVE_POS_RET MOVE_POS return (UInt32)offset;
-
-static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
-
-#define GET_MATCHES_HEADER2(minLen, ret_op) \
- unsigned lenLimit; UInt32 hv; const Byte *cur; UInt32 curMatch; \
- lenLimit = (unsigned)p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); ret_op; }} \
- cur = p->buffer;
-
-#define GET_MATCHES_HEADER(minLen) GET_MATCHES_HEADER2(minLen, return 0)
-#define SKIP_HEADER(minLen) GET_MATCHES_HEADER2(minLen, continue)
-
-#define MF_PARAMS(p) p->pos, p->buffer, p->son, p->cyclicBufferPos, p->cyclicBufferSize, p->cutValue
-
-#define GET_MATCHES_FOOTER(offset, maxLen) \
- offset = (unsigned)(GetMatchesSpec1((UInt32)lenLimit, curMatch, MF_PARAMS(p), \
- distances + offset, (UInt32)maxLen) - distances); MOVE_POS_RET;
-
-#define SKIP_FOOTER \
- SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS;
-
-#define UPDATE_maxLen { \
- ptrdiff_t diff = (ptrdiff_t)0 - d2; \
- const Byte *c = cur + maxLen; \
- const Byte *lim = cur + lenLimit; \
- for (; c != lim; c++) if (*(c + diff) != *c) break; \
- maxLen = (unsigned)(c - cur); }
-
-static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- unsigned offset;
- GET_MATCHES_HEADER(2)
- HASH2_CALC;
- curMatch = p->hash[hv];
- p->hash[hv] = p->pos;
- offset = 0;
- GET_MATCHES_FOOTER(offset, 1)
-}
-
-UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- unsigned offset;
- GET_MATCHES_HEADER(3)
- HASH_ZIP_CALC;
- curMatch = p->hash[hv];
- p->hash[hv] = p->pos;
- offset = 0;
- GET_MATCHES_FOOTER(offset, 2)
-}
-
-static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- UInt32 h2, d2, pos;
- unsigned maxLen, offset;
- UInt32 *hash;
- GET_MATCHES_HEADER(3)
-
- HASH3_CALC;
-
- hash = p->hash;
- pos = p->pos;
-
- d2 = pos - hash[h2];
-
- curMatch = (hash + kFix3HashSize)[hv];
-
- hash[h2] = pos;
- (hash + kFix3HashSize)[hv] = pos;
-
- maxLen = 2;
- offset = 0;
-
- if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
- {
- UPDATE_maxLen
- distances[0] = (UInt32)maxLen;
- distances[1] = d2 - 1;
- offset = 2;
- if (maxLen == lenLimit)
- {
- SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p));
- MOVE_POS_RET;
- }
- }
-
- GET_MATCHES_FOOTER(offset, maxLen)
-}
-
-static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- UInt32 h2, h3, d2, d3, pos;
- unsigned maxLen, offset;
- UInt32 *hash;
- GET_MATCHES_HEADER(4)
-
- HASH4_CALC;
-
- hash = p->hash;
- pos = p->pos;
-
- d2 = pos - hash [h2];
- d3 = pos - (hash + kFix3HashSize)[h3];
-
- curMatch = (hash + kFix4HashSize)[hv];
-
- hash [h2] = pos;
- (hash + kFix3HashSize)[h3] = pos;
- (hash + kFix4HashSize)[hv] = pos;
-
- maxLen = 0;
- offset = 0;
-
- if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
- {
- maxLen = 2;
- distances[0] = 2;
- distances[1] = d2 - 1;
- offset = 2;
- }
-
- if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
- {
- maxLen = 3;
- distances[(size_t)offset + 1] = d3 - 1;
- offset += 2;
- d2 = d3;
- }
-
- if (offset != 0)
- {
- UPDATE_maxLen
- distances[(size_t)offset - 2] = (UInt32)maxLen;
- if (maxLen == lenLimit)
- {
- SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p));
- MOVE_POS_RET;
- }
- }
-
- if (maxLen < 3)
- maxLen = 3;
-
- GET_MATCHES_FOOTER(offset, maxLen)
-}
-
-/*
-static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- UInt32 h2, h3, h4, d2, d3, d4, maxLen, offset, pos;
- UInt32 *hash;
- GET_MATCHES_HEADER(5)
-
- HASH5_CALC;
-
- hash = p->hash;
- pos = p->pos;
-
- d2 = pos - hash [h2];
- d3 = pos - (hash + kFix3HashSize)[h3];
- d4 = pos - (hash + kFix4HashSize)[h4];
-
- curMatch = (hash + kFix5HashSize)[hv];
-
- hash [h2] = pos;
- (hash + kFix3HashSize)[h3] = pos;
- (hash + kFix4HashSize)[h4] = pos;
- (hash + kFix5HashSize)[hv] = pos;
-
- maxLen = 0;
- offset = 0;
-
- if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
- {
- distances[0] = maxLen = 2;
- distances[1] = d2 - 1;
- offset = 2;
- if (*(cur - d2 + 2) == cur[2])
- distances[0] = maxLen = 3;
- else if (d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
- {
- distances[2] = maxLen = 3;
- distances[3] = d3 - 1;
- offset = 4;
- d2 = d3;
- }
- }
- else if (d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
- {
- distances[0] = maxLen = 3;
- distances[1] = d3 - 1;
- offset = 2;
- d2 = d3;
- }
-
- if (d2 != d4 && d4 < p->cyclicBufferSize
- && *(cur - d4) == *cur
- && *(cur - d4 + 3) == *(cur + 3))
- {
- maxLen = 4;
- distances[(size_t)offset + 1] = d4 - 1;
- offset += 2;
- d2 = d4;
- }
-
- if (offset != 0)
- {
- UPDATE_maxLen
- distances[(size_t)offset - 2] = maxLen;
- if (maxLen == lenLimit)
- {
- SkipMatchesSpec(lenLimit, curMatch, MF_PARAMS(p));
- MOVE_POS_RET;
- }
- }
-
- if (maxLen < 4)
- maxLen = 4;
-
- GET_MATCHES_FOOTER(offset, maxLen)
-}
-*/
-
-static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- UInt32 h2, h3, d2, d3, pos;
- unsigned maxLen, offset;
- UInt32 *hash;
- GET_MATCHES_HEADER(4)
-
- HASH4_CALC;
-
- hash = p->hash;
- pos = p->pos;
-
- d2 = pos - hash [h2];
- d3 = pos - (hash + kFix3HashSize)[h3];
- curMatch = (hash + kFix4HashSize)[hv];
-
- hash [h2] = pos;
- (hash + kFix3HashSize)[h3] = pos;
- (hash + kFix4HashSize)[hv] = pos;
-
- maxLen = 0;
- offset = 0;
-
- if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
- {
- maxLen = 2;
- distances[0] = 2;
- distances[1] = d2 - 1;
- offset = 2;
- }
-
- if (d2 != d3 && d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
- {
- maxLen = 3;
- distances[(size_t)offset + 1] = d3 - 1;
- offset += 2;
- d2 = d3;
- }
-
- if (offset != 0)
- {
- UPDATE_maxLen
- distances[(size_t)offset - 2] = (UInt32)maxLen;
- if (maxLen == lenLimit)
- {
- p->son[p->cyclicBufferPos] = curMatch;
- MOVE_POS_RET;
- }
- }
-
- if (maxLen < 3)
- maxLen = 3;
-
- offset = (unsigned)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
- distances + offset, maxLen) - (distances));
- MOVE_POS_RET
-}
-
-/*
-static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- UInt32 h2, h3, h4, d2, d3, d4, maxLen, offset, pos
- UInt32 *hash;
- GET_MATCHES_HEADER(5)
-
- HASH5_CALC;
-
- hash = p->hash;
- pos = p->pos;
-
- d2 = pos - hash [h2];
- d3 = pos - (hash + kFix3HashSize)[h3];
- d4 = pos - (hash + kFix4HashSize)[h4];
-
- curMatch = (hash + kFix5HashSize)[hv];
-
- hash [h2] = pos;
- (hash + kFix3HashSize)[h3] = pos;
- (hash + kFix4HashSize)[h4] = pos;
- (hash + kFix5HashSize)[hv] = pos;
-
- maxLen = 0;
- offset = 0;
-
- if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
- {
- distances[0] = maxLen = 2;
- distances[1] = d2 - 1;
- offset = 2;
- if (*(cur - d2 + 2) == cur[2])
- distances[0] = maxLen = 3;
- else if (d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
- {
- distances[2] = maxLen = 3;
- distances[3] = d3 - 1;
- offset = 4;
- d2 = d3;
- }
- }
- else if (d3 < p->cyclicBufferSize && *(cur - d3) == *cur)
- {
- distances[0] = maxLen = 3;
- distances[1] = d3 - 1;
- offset = 2;
- d2 = d3;
- }
-
- if (d2 != d4 && d4 < p->cyclicBufferSize
- && *(cur - d4) == *cur
- && *(cur - d4 + 3) == *(cur + 3))
- {
- maxLen = 4;
- distances[(size_t)offset + 1] = d4 - 1;
- offset += 2;
- d2 = d4;
- }
-
- if (offset != 0)
- {
- UPDATE_maxLen
- distances[(size_t)offset - 2] = maxLen;
- if (maxLen == lenLimit)
- {
- p->son[p->cyclicBufferPos] = curMatch;
- MOVE_POS_RET;
- }
- }
-
- if (maxLen < 4)
- maxLen = 4;
-
- offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
- distances + offset, maxLen) - (distances));
- MOVE_POS_RET
-}
-*/
-
-UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
-{
- unsigned offset;
- GET_MATCHES_HEADER(3)
- HASH_ZIP_CALC;
- curMatch = p->hash[hv];
- p->hash[hv] = p->pos;
- offset = (unsigned)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
- distances, 2) - (distances));
- MOVE_POS_RET
-}
-
-static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- SKIP_HEADER(2)
- HASH2_CALC;
- curMatch = p->hash[hv];
- p->hash[hv] = p->pos;
- SKIP_FOOTER
- }
- while (--num != 0);
-}
-
-void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- SKIP_HEADER(3)
- HASH_ZIP_CALC;
- curMatch = p->hash[hv];
- p->hash[hv] = p->pos;
- SKIP_FOOTER
- }
- while (--num != 0);
-}
-
-static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- UInt32 h2;
- UInt32 *hash;
- SKIP_HEADER(3)
- HASH3_CALC;
- hash = p->hash;
- curMatch = (hash + kFix3HashSize)[hv];
- hash[h2] =
- (hash + kFix3HashSize)[hv] = p->pos;
- SKIP_FOOTER
- }
- while (--num != 0);
-}
-
-static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- UInt32 h2, h3;
- UInt32 *hash;
- SKIP_HEADER(4)
- HASH4_CALC;
- hash = p->hash;
- curMatch = (hash + kFix4HashSize)[hv];
- hash [h2] =
- (hash + kFix3HashSize)[h3] =
- (hash + kFix4HashSize)[hv] = p->pos;
- SKIP_FOOTER
- }
- while (--num != 0);
-}
-
-/*
-static void Bt5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- UInt32 h2, h3, h4;
- UInt32 *hash;
- SKIP_HEADER(5)
- HASH5_CALC;
- hash = p->hash;
- curMatch = (hash + kFix5HashSize)[hv];
- hash [h2] =
- (hash + kFix3HashSize)[h3] =
- (hash + kFix4HashSize)[h4] =
- (hash + kFix5HashSize)[hv] = p->pos;
- SKIP_FOOTER
- }
- while (--num != 0);
-}
-*/
-
-static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- UInt32 h2, h3;
- UInt32 *hash;
- SKIP_HEADER(4)
- HASH4_CALC;
- hash = p->hash;
- curMatch = (hash + kFix4HashSize)[hv];
- hash [h2] =
- (hash + kFix3HashSize)[h3] =
- (hash + kFix4HashSize)[hv] = p->pos;
- p->son[p->cyclicBufferPos] = curMatch;
- MOVE_POS
- }
- while (--num != 0);
-}
-
-/*
-static void Hc5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- UInt32 h2, h3, h4;
- UInt32 *hash;
- SKIP_HEADER(5)
- HASH5_CALC;
- hash = p->hash;
- curMatch = hash + kFix5HashSize)[hv];
- hash [h2] =
- (hash + kFix3HashSize)[h3] =
- (hash + kFix4HashSize)[h4] =
- (hash + kFix5HashSize)[hv] = p->pos;
- p->son[p->cyclicBufferPos] = curMatch;
- MOVE_POS
- }
- while (--num != 0);
-}
-*/
-
-void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
-{
- do
- {
- SKIP_HEADER(3)
- HASH_ZIP_CALC;
- curMatch = p->hash[hv];
- p->hash[hv] = p->pos;
- p->son[p->cyclicBufferPos] = curMatch;
- MOVE_POS
- }
- while (--num != 0);
-}
-
-void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable)
-{
- vTable->Init = (Mf_Init_Func)MatchFinder_Init;
- vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinder_GetNumAvailableBytes;
- vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinder_GetPointerToCurrentPos;
- if (!p->btMode)
- {
- /* if (p->numHashBytes <= 4) */
- {
- vTable->GetMatches = (Mf_GetMatches_Func)Hc4_MatchFinder_GetMatches;
- vTable->Skip = (Mf_Skip_Func)Hc4_MatchFinder_Skip;
- }
- /*
- else
- {
- vTable->GetMatches = (Mf_GetMatches_Func)Hc5_MatchFinder_GetMatches;
- vTable->Skip = (Mf_Skip_Func)Hc5_MatchFinder_Skip;
- }
- */
- }
- else if (p->numHashBytes == 2)
- {
- vTable->GetMatches = (Mf_GetMatches_Func)Bt2_MatchFinder_GetMatches;
- vTable->Skip = (Mf_Skip_Func)Bt2_MatchFinder_Skip;
- }
- else if (p->numHashBytes == 3)
- {
- vTable->GetMatches = (Mf_GetMatches_Func)Bt3_MatchFinder_GetMatches;
- vTable->Skip = (Mf_Skip_Func)Bt3_MatchFinder_Skip;
- }
- else /* if (p->numHashBytes == 4) */
- {
- vTable->GetMatches = (Mf_GetMatches_Func)Bt4_MatchFinder_GetMatches;
- vTable->Skip = (Mf_Skip_Func)Bt4_MatchFinder_Skip;
- }
- /*
- else
- {
- vTable->GetMatches = (Mf_GetMatches_Func)Bt5_MatchFinder_GetMatches;
- vTable->Skip = (Mf_Skip_Func)Bt5_MatchFinder_Skip;
- }
- */
-}
+/* LzFind.c -- Match finder for LZ algorithms
+2023-03-14 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+// #include <stdio.h>
+
+#include "CpuArch.h"
+#include "LzFind.h"
+#include "LzHash.h"
+
+#define kBlockMoveAlign (1 << 7) // alignment for memmove()
+#define kBlockSizeAlign (1 << 16) // alignment for block allocation
+#define kBlockSizeReserveMin (1 << 24) // it's 1/256 from 4 GB dictinary
+
+#define kEmptyHashValue 0
+
+#define kMaxValForNormalize ((UInt32)0)
+// #define kMaxValForNormalize ((UInt32)(1 << 20) + 0xfff) // for debug
+
+// #define kNormalizeAlign (1 << 7) // alignment for speculated accesses
+
+#define GET_AVAIL_BYTES(p) \
+ Inline_MatchFinder_GetNumAvailableBytes(p)
+
+
+// #define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
+#define kFix5HashSize kFix4HashSize
+
+/*
+ HASH2_CALC:
+ if (hv) match, then cur[0] and cur[1] also match
+*/
+#define HASH2_CALC hv = GetUi16(cur);
+
+// (crc[0 ... 255] & 0xFF) provides one-to-one correspondence to [0 ... 255]
+
+/*
+ HASH3_CALC:
+ if (cur[0]) and (h2) match, then cur[1] also match
+ if (cur[0]) and (hv) match, then cur[1] and cur[2] also match
+*/
+#define HASH3_CALC { \
+ UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
+ h2 = temp & (kHash2Size - 1); \
+ hv = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; }
+
+#define HASH4_CALC { \
+ UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
+ h2 = temp & (kHash2Size - 1); \
+ temp ^= ((UInt32)cur[2] << 8); \
+ h3 = temp & (kHash3Size - 1); \
+ hv = (temp ^ (p->crc[cur[3]] << kLzHash_CrcShift_1)) & p->hashMask; }
+
+#define HASH5_CALC { \
+ UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
+ h2 = temp & (kHash2Size - 1); \
+ temp ^= ((UInt32)cur[2] << 8); \
+ h3 = temp & (kHash3Size - 1); \
+ temp ^= (p->crc[cur[3]] << kLzHash_CrcShift_1); \
+ /* h4 = temp & p->hash4Mask; */ /* (kHash4Size - 1); */ \
+ hv = (temp ^ (p->crc[cur[4]] << kLzHash_CrcShift_2)) & p->hashMask; }
+
+#define HASH_ZIP_CALC hv = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;
+
+
+static void LzInWindow_Free(CMatchFinder *p, ISzAllocPtr alloc)
+{
+ // if (!p->directInput)
+ {
+ ISzAlloc_Free(alloc, p->bufBase);
+ p->bufBase = NULL;
+ }
+}
+
+
+static int LzInWindow_Create2(CMatchFinder *p, UInt32 blockSize, ISzAllocPtr alloc)
+{
+ if (blockSize == 0)
+ return 0;
+ if (!p->bufBase || p->blockSize != blockSize)
+ {
+ // size_t blockSizeT;
+ LzInWindow_Free(p, alloc);
+ p->blockSize = blockSize;
+ // blockSizeT = blockSize;
+
+ // printf("\nblockSize = 0x%x\n", blockSize);
+ /*
+ #if defined _WIN64
+ // we can allocate 4GiB, but still use UInt32 for (p->blockSize)
+ // we use UInt32 type for (p->blockSize), because
+ // we don't want to wrap over 4 GiB,
+ // when we use (p->streamPos - p->pos) that is UInt32.
+ if (blockSize >= (UInt32)0 - (UInt32)kBlockSizeAlign)
+ {
+ blockSizeT = ((size_t)1 << 32);
+ printf("\nchanged to blockSizeT = 4GiB\n");
+ }
+ #endif
+ */
+
+ p->bufBase = (Byte *)ISzAlloc_Alloc(alloc, blockSize);
+ // printf("\nbufferBase = %p\n", p->bufBase);
+ // return 0; // for debug
+ }
+ return (p->bufBase != NULL);
+}
+
+static const Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
+
+static UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return GET_AVAIL_BYTES(p); }
+
+
+Z7_NO_INLINE
+static void MatchFinder_ReadBlock(CMatchFinder *p)
+{
+ if (p->streamEndWasReached || p->result != SZ_OK)
+ return;
+
+ /* We use (p->streamPos - p->pos) value.
+ (p->streamPos < p->pos) is allowed. */
+
+ if (p->directInput)
+ {
+ UInt32 curSize = 0xFFFFFFFF - GET_AVAIL_BYTES(p);
+ if (curSize > p->directInputRem)
+ curSize = (UInt32)p->directInputRem;
+ p->streamPos += curSize;
+ p->directInputRem -= curSize;
+ if (p->directInputRem == 0)
+ p->streamEndWasReached = 1;
+ return;
+ }
+
+ for (;;)
+ {
+ const Byte *dest = p->buffer + GET_AVAIL_BYTES(p);
+ size_t size = (size_t)(p->bufBase + p->blockSize - dest);
+ if (size == 0)
+ {
+ /* we call ReadBlock() after NeedMove() and MoveBlock().
+ NeedMove() and MoveBlock() povide more than (keepSizeAfter)
+ to the end of (blockSize).
+ So we don't execute this branch in normal code flow.
+ We can go here, if we will call ReadBlock() before NeedMove(), MoveBlock().
+ */
+ // p->result = SZ_ERROR_FAIL; // we can show error here
+ return;
+ }
+
+ // #define kRead 3
+ // if (size > kRead) size = kRead; // for debug
+
+ /*
+ // we need cast (Byte *)dest.
+ #ifdef __clang__
+ #pragma GCC diagnostic ignored "-Wcast-qual"
+ #endif
+ */
+ p->result = ISeqInStream_Read(p->stream,
+ p->bufBase + (dest - p->bufBase), &size);
+ if (p->result != SZ_OK)
+ return;
+ if (size == 0)
+ {
+ p->streamEndWasReached = 1;
+ return;
+ }
+ p->streamPos += (UInt32)size;
+ if (GET_AVAIL_BYTES(p) > p->keepSizeAfter)
+ return;
+ /* here and in another (p->keepSizeAfter) checks we keep on 1 byte more than was requested by Create() function
+ (GET_AVAIL_BYTES(p) >= p->keepSizeAfter) - minimal required size */
+ }
+
+ // on exit: (p->result != SZ_OK || p->streamEndWasReached || GET_AVAIL_BYTES(p) > p->keepSizeAfter)
+}
+
+
+
+Z7_NO_INLINE
+void MatchFinder_MoveBlock(CMatchFinder *p)
+{
+ const size_t offset = (size_t)(p->buffer - p->bufBase) - p->keepSizeBefore;
+ const size_t keepBefore = (offset & (kBlockMoveAlign - 1)) + p->keepSizeBefore;
+ p->buffer = p->bufBase + keepBefore;
+ memmove(p->bufBase,
+ p->bufBase + (offset & ~((size_t)kBlockMoveAlign - 1)),
+ keepBefore + (size_t)GET_AVAIL_BYTES(p));
+}
+
+/* We call MoveBlock() before ReadBlock().
+ So MoveBlock() can be wasteful operation, if the whole input data
+ can fit in current block even without calling MoveBlock().
+ in important case where (dataSize <= historySize)
+ condition (p->blockSize > dataSize + p->keepSizeAfter) is met
+ So there is no MoveBlock() in that case case.
+*/
+
+int MatchFinder_NeedMove(CMatchFinder *p)
+{
+ if (p->directInput)
+ return 0;
+ if (p->streamEndWasReached || p->result != SZ_OK)
+ return 0;
+ return ((size_t)(p->bufBase + p->blockSize - p->buffer) <= p->keepSizeAfter);
+}
+
+void MatchFinder_ReadIfRequired(CMatchFinder *p)
+{
+ if (p->keepSizeAfter >= GET_AVAIL_BYTES(p))
+ MatchFinder_ReadBlock(p);
+}
+
+
+
+static void MatchFinder_SetDefaultSettings(CMatchFinder *p)
+{
+ p->cutValue = 32;
+ p->btMode = 1;
+ p->numHashBytes = 4;
+ p->numHashBytes_Min = 2;
+ p->numHashOutBits = 0;
+ p->bigHash = 0;
+}
+
+#define kCrcPoly 0xEDB88320
+
+void MatchFinder_Construct(CMatchFinder *p)
+{
+ unsigned i;
+ p->buffer = NULL;
+ p->bufBase = NULL;
+ p->directInput = 0;
+ p->stream = NULL;
+ p->hash = NULL;
+ p->expectedDataSize = (UInt64)(Int64)-1;
+ MatchFinder_SetDefaultSettings(p);
+
+ for (i = 0; i < 256; i++)
+ {
+ UInt32 r = (UInt32)i;
+ unsigned j;
+ for (j = 0; j < 8; j++)
+ r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
+ p->crc[i] = r;
+ }
+}
+
+#undef kCrcPoly
+
+static void MatchFinder_FreeThisClassMemory(CMatchFinder *p, ISzAllocPtr alloc)
+{
+ ISzAlloc_Free(alloc, p->hash);
+ p->hash = NULL;
+}
+
+void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc)
+{
+ MatchFinder_FreeThisClassMemory(p, alloc);
+ LzInWindow_Free(p, alloc);
+}
+
+static CLzRef* AllocRefs(size_t num, ISzAllocPtr alloc)
+{
+ const size_t sizeInBytes = (size_t)num * sizeof(CLzRef);
+ if (sizeInBytes / sizeof(CLzRef) != num)
+ return NULL;
+ return (CLzRef *)ISzAlloc_Alloc(alloc, sizeInBytes);
+}
+
+#if (kBlockSizeReserveMin < kBlockSizeAlign * 2)
+ #error Stop_Compiling_Bad_Reserve
+#endif
+
+
+
+static UInt32 GetBlockSize(CMatchFinder *p, UInt32 historySize)
+{
+ UInt32 blockSize = (p->keepSizeBefore + p->keepSizeAfter);
+ /*
+ if (historySize > kMaxHistorySize)
+ return 0;
+ */
+ // printf("\nhistorySize == 0x%x\n", historySize);
+
+ if (p->keepSizeBefore < historySize || blockSize < p->keepSizeBefore) // if 32-bit overflow
+ return 0;
+
+ {
+ const UInt32 kBlockSizeMax = (UInt32)0 - (UInt32)kBlockSizeAlign;
+ const UInt32 rem = kBlockSizeMax - blockSize;
+ const UInt32 reserve = (blockSize >> (blockSize < ((UInt32)1 << 30) ? 1 : 2))
+ + (1 << 12) + kBlockMoveAlign + kBlockSizeAlign; // do not overflow 32-bit here
+ if (blockSize >= kBlockSizeMax
+ || rem < kBlockSizeReserveMin) // we reject settings that will be slow
+ return 0;
+ if (reserve >= rem)
+ blockSize = kBlockSizeMax;
+ else
+ {
+ blockSize += reserve;
+ blockSize &= ~(UInt32)(kBlockSizeAlign - 1);
+ }
+ }
+ // printf("\n LzFind_blockSize = %x\n", blockSize);
+ // printf("\n LzFind_blockSize = %d\n", blockSize >> 20);
+ return blockSize;
+}
+
+
+// input is historySize
+static UInt32 MatchFinder_GetHashMask2(CMatchFinder *p, UInt32 hs)
+{
+ if (p->numHashBytes == 2)
+ return (1 << 16) - 1;
+ if (hs != 0)
+ hs--;
+ hs |= (hs >> 1);
+ hs |= (hs >> 2);
+ hs |= (hs >> 4);
+ hs |= (hs >> 8);
+ // we propagated 16 bits in (hs). Low 16 bits must be set later
+ if (hs >= (1 << 24))
+ {
+ if (p->numHashBytes == 3)
+ hs = (1 << 24) - 1;
+ /* if (bigHash) mode, GetHeads4b() in LzFindMt.c needs (hs >= ((1 << 24) - 1))) */
+ }
+ // (hash_size >= (1 << 16)) : Required for (numHashBytes > 2)
+ hs |= (1 << 16) - 1; /* don't change it! */
+ // bt5: we adjust the size with recommended minimum size
+ if (p->numHashBytes >= 5)
+ hs |= (256 << kLzHash_CrcShift_2) - 1;
+ return hs;
+}
+
+// input is historySize
+static UInt32 MatchFinder_GetHashMask(CMatchFinder *p, UInt32 hs)
+{
+ if (p->numHashBytes == 2)
+ return (1 << 16) - 1;
+ if (hs != 0)
+ hs--;
+ hs |= (hs >> 1);
+ hs |= (hs >> 2);
+ hs |= (hs >> 4);
+ hs |= (hs >> 8);
+ // we propagated 16 bits in (hs). Low 16 bits must be set later
+ hs >>= 1;
+ if (hs >= (1 << 24))
+ {
+ if (p->numHashBytes == 3)
+ hs = (1 << 24) - 1;
+ else
+ hs >>= 1;
+ /* if (bigHash) mode, GetHeads4b() in LzFindMt.c needs (hs >= ((1 << 24) - 1))) */
+ }
+ // (hash_size >= (1 << 16)) : Required for (numHashBytes > 2)
+ hs |= (1 << 16) - 1; /* don't change it! */
+ // bt5: we adjust the size with recommended minimum size
+ if (p->numHashBytes >= 5)
+ hs |= (256 << kLzHash_CrcShift_2) - 1;
+ return hs;
+}
+
+
+int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
+ UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
+ ISzAllocPtr alloc)
+{
+ /* we need one additional byte in (p->keepSizeBefore),
+ since we use MoveBlock() after (p->pos++) and before dictionary using */
+ // keepAddBufferBefore = (UInt32)0xFFFFFFFF - (1 << 22); // for debug
+ p->keepSizeBefore = historySize + keepAddBufferBefore + 1;
+
+ keepAddBufferAfter += matchMaxLen;
+ /* we need (p->keepSizeAfter >= p->numHashBytes) */
+ if (keepAddBufferAfter < p->numHashBytes)
+ keepAddBufferAfter = p->numHashBytes;
+ // keepAddBufferAfter -= 2; // for debug
+ p->keepSizeAfter = keepAddBufferAfter;
+
+ if (p->directInput)
+ p->blockSize = 0;
+ if (p->directInput || LzInWindow_Create2(p, GetBlockSize(p, historySize), alloc))
+ {
+ size_t hashSizeSum;
+ {
+ UInt32 hs;
+ UInt32 hsCur;
+
+ if (p->numHashOutBits != 0)
+ {
+ unsigned numBits = p->numHashOutBits;
+ const unsigned nbMax =
+ (p->numHashBytes == 2 ? 16 :
+ (p->numHashBytes == 3 ? 24 : 32));
+ if (numBits > nbMax)
+ numBits = nbMax;
+ if (numBits >= 32)
+ hs = (UInt32)0 - 1;
+ else
+ hs = ((UInt32)1 << numBits) - 1;
+ // (hash_size >= (1 << 16)) : Required for (numHashBytes > 2)
+ hs |= (1 << 16) - 1; /* don't change it! */
+ if (p->numHashBytes >= 5)
+ hs |= (256 << kLzHash_CrcShift_2) - 1;
+ {
+ const UInt32 hs2 = MatchFinder_GetHashMask2(p, historySize);
+ if (hs > hs2)
+ hs = hs2;
+ }
+ hsCur = hs;
+ if (p->expectedDataSize < historySize)
+ {
+ const UInt32 hs2 = MatchFinder_GetHashMask2(p, (UInt32)p->expectedDataSize);
+ if (hsCur > hs2)
+ hsCur = hs2;
+ }
+ }
+ else
+ {
+ hs = MatchFinder_GetHashMask(p, historySize);
+ hsCur = hs;
+ if (p->expectedDataSize < historySize)
+ {
+ hsCur = MatchFinder_GetHashMask(p, (UInt32)p->expectedDataSize);
+ if (hsCur > hs) // is it possible?
+ hsCur = hs;
+ }
+ }
+
+ p->hashMask = hsCur;
+
+ hashSizeSum = hs;
+ hashSizeSum++;
+ if (hashSizeSum < hs)
+ return 0;
+ {
+ UInt32 fixedHashSize = 0;
+ if (p->numHashBytes > 2 && p->numHashBytes_Min <= 2) fixedHashSize += kHash2Size;
+ if (p->numHashBytes > 3 && p->numHashBytes_Min <= 3) fixedHashSize += kHash3Size;
+ // if (p->numHashBytes > 4) p->fixedHashSize += hs4; // kHash4Size;
+ hashSizeSum += fixedHashSize;
+ p->fixedHashSize = fixedHashSize;
+ }
+ }
+
+ p->matchMaxLen = matchMaxLen;
+
+ {
+ size_t newSize;
+ size_t numSons;
+ const UInt32 newCyclicBufferSize = historySize + 1; // do not change it
+ p->historySize = historySize;
+ p->cyclicBufferSize = newCyclicBufferSize; // it must be = (historySize + 1)
+
+ numSons = newCyclicBufferSize;
+ if (p->btMode)
+ numSons <<= 1;
+ newSize = hashSizeSum + numSons;
+
+ if (numSons < newCyclicBufferSize || newSize < numSons)
+ return 0;
+
+ // aligned size is not required here, but it can be better for some loops
+ #define NUM_REFS_ALIGN_MASK 0xF
+ newSize = (newSize + NUM_REFS_ALIGN_MASK) & ~(size_t)NUM_REFS_ALIGN_MASK;
+
+ // 22.02: we don't reallocate buffer, if old size is enough
+ if (p->hash && p->numRefs >= newSize)
+ return 1;
+
+ MatchFinder_FreeThisClassMemory(p, alloc);
+ p->numRefs = newSize;
+ p->hash = AllocRefs(newSize, alloc);
+
+ if (p->hash)
+ {
+ p->son = p->hash + hashSizeSum;
+ return 1;
+ }
+ }
+ }
+
+ MatchFinder_Free(p, alloc);
+ return 0;
+}
+
+
+static void MatchFinder_SetLimits(CMatchFinder *p)
+{
+ UInt32 k;
+ UInt32 n = kMaxValForNormalize - p->pos;
+ if (n == 0)
+ n = (UInt32)(Int32)-1; // we allow (pos == 0) at start even with (kMaxValForNormalize == 0)
+
+ k = p->cyclicBufferSize - p->cyclicBufferPos;
+ if (k < n)
+ n = k;
+
+ k = GET_AVAIL_BYTES(p);
+ {
+ const UInt32 ksa = p->keepSizeAfter;
+ UInt32 mm = p->matchMaxLen;
+ if (k > ksa)
+ k -= ksa; // we must limit exactly to keepSizeAfter for ReadBlock
+ else if (k >= mm)
+ {
+ // the limitation for (p->lenLimit) update
+ k -= mm; // optimization : to reduce the number of checks
+ k++;
+ // k = 1; // non-optimized version : for debug
+ }
+ else
+ {
+ mm = k;
+ if (k != 0)
+ k = 1;
+ }
+ p->lenLimit = mm;
+ }
+ if (k < n)
+ n = k;
+
+ p->posLimit = p->pos + n;
+}
+
+
+void MatchFinder_Init_LowHash(CMatchFinder *p)
+{
+ size_t i;
+ CLzRef *items = p->hash;
+ const size_t numItems = p->fixedHashSize;
+ for (i = 0; i < numItems; i++)
+ items[i] = kEmptyHashValue;
+}
+
+
+void MatchFinder_Init_HighHash(CMatchFinder *p)
+{
+ size_t i;
+ CLzRef *items = p->hash + p->fixedHashSize;
+ const size_t numItems = (size_t)p->hashMask + 1;
+ for (i = 0; i < numItems; i++)
+ items[i] = kEmptyHashValue;
+}
+
+
+void MatchFinder_Init_4(CMatchFinder *p)
+{
+ if (!p->directInput)
+ p->buffer = p->bufBase;
+ {
+ /* kEmptyHashValue = 0 (Zero) is used in hash tables as NO-VALUE marker.
+ the code in CMatchFinderMt expects (pos = 1) */
+ p->pos =
+ p->streamPos =
+ 1; // it's smallest optimal value. do not change it
+ // 0; // for debug
+ }
+ p->result = SZ_OK;
+ p->streamEndWasReached = 0;
+}
+
+
+// (CYC_TO_POS_OFFSET == 0) is expected by some optimized code
+#define CYC_TO_POS_OFFSET 0
+// #define CYC_TO_POS_OFFSET 1 // for debug
+
+void MatchFinder_Init(CMatchFinder *p)
+{
+ MatchFinder_Init_HighHash(p);
+ MatchFinder_Init_LowHash(p);
+ MatchFinder_Init_4(p);
+ // if (readData)
+ MatchFinder_ReadBlock(p);
+
+ /* if we init (cyclicBufferPos = pos), then we can use one variable
+ instead of both (cyclicBufferPos) and (pos) : only before (cyclicBufferPos) wrapping */
+ p->cyclicBufferPos = (p->pos - CYC_TO_POS_OFFSET); // init with relation to (pos)
+ // p->cyclicBufferPos = 0; // smallest value
+ // p->son[0] = p->son[1] = 0; // unused: we can init skipped record for speculated accesses.
+ MatchFinder_SetLimits(p);
+}
+
+
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #if defined(__clang__) && (__clang_major__ >= 4) \
+ || defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40701)
+ // || defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1900)
+
+ #define USE_LZFIND_SATUR_SUB_128
+ #define USE_LZFIND_SATUR_SUB_256
+ #define LZFIND_ATTRIB_SSE41 __attribute__((__target__("sse4.1")))
+ #define LZFIND_ATTRIB_AVX2 __attribute__((__target__("avx2")))
+ #elif defined(_MSC_VER)
+ #if (_MSC_VER >= 1600)
+ #define USE_LZFIND_SATUR_SUB_128
+ #endif
+ #if (_MSC_VER >= 1900)
+ #define USE_LZFIND_SATUR_SUB_256
+ #endif
+ #endif
+
+// #elif defined(MY_CPU_ARM_OR_ARM64)
+#elif defined(MY_CPU_ARM64)
+
+ #if defined(__clang__) && (__clang_major__ >= 8) \
+ || defined(__GNUC__) && (__GNUC__ >= 8)
+ #define USE_LZFIND_SATUR_SUB_128
+ #ifdef MY_CPU_ARM64
+ // #define LZFIND_ATTRIB_SSE41 __attribute__((__target__("")))
+ #else
+ // #define LZFIND_ATTRIB_SSE41 __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
+ #endif
+
+ #elif defined(_MSC_VER)
+ #if (_MSC_VER >= 1910)
+ #define USE_LZFIND_SATUR_SUB_128
+ #endif
+ #endif
+
+ #if defined(_MSC_VER) && defined(MY_CPU_ARM64)
+ #include <arm64_neon.h>
+ #else
+ #include <arm_neon.h>
+ #endif
+
+#endif
+
+
+#ifdef USE_LZFIND_SATUR_SUB_128
+
+// #define Z7_SHOW_HW_STATUS
+
+#ifdef Z7_SHOW_HW_STATUS
+#include <stdio.h>
+#define PRF(x) x
+PRF(;)
+#else
+#define PRF(x)
+#endif
+
+
+#ifdef MY_CPU_ARM_OR_ARM64
+
+#ifdef MY_CPU_ARM64
+// #define FORCE_LZFIND_SATUR_SUB_128
+#endif
+typedef uint32x4_t LzFind_v128;
+#define SASUB_128_V(v, s) \
+ vsubq_u32(vmaxq_u32(v, s), s)
+
+#else // MY_CPU_ARM_OR_ARM64
+
+#include <smmintrin.h> // sse4.1
+
+typedef __m128i LzFind_v128;
+// SSE 4.1
+#define SASUB_128_V(v, s) \
+ _mm_sub_epi32(_mm_max_epu32(v, s), s)
+
+#endif // MY_CPU_ARM_OR_ARM64
+
+
+#define SASUB_128(i) \
+ *( LzFind_v128 *)( void *)(items + (i) * 4) = SASUB_128_V( \
+ *(const LzFind_v128 *)(const void *)(items + (i) * 4), sub2);
+
+
+Z7_NO_INLINE
+static
+#ifdef LZFIND_ATTRIB_SSE41
+LZFIND_ATTRIB_SSE41
+#endif
+void
+Z7_FASTCALL
+LzFind_SaturSub_128(UInt32 subValue, CLzRef *items, const CLzRef *lim)
+{
+ const LzFind_v128 sub2 =
+ #ifdef MY_CPU_ARM_OR_ARM64
+ vdupq_n_u32(subValue);
+ #else
+ _mm_set_epi32((Int32)subValue, (Int32)subValue, (Int32)subValue, (Int32)subValue);
+ #endif
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SASUB_128(0) SASUB_128(1) items += 2 * 4;
+ SASUB_128(0) SASUB_128(1) items += 2 * 4;
+ }
+ while (items != lim);
+}
+
+
+
+#ifdef USE_LZFIND_SATUR_SUB_256
+
+#include <immintrin.h> // avx
+/*
+clang :immintrin.h uses
+#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+ defined(__AVX2__)
+#include <avx2intrin.h>
+#endif
+so we need <avxintrin.h> for clang-cl */
+
+#if defined(__clang__)
+#include <avxintrin.h>
+#include <avx2intrin.h>
+#endif
+
+// AVX2:
+#define SASUB_256(i) \
+ *( __m256i *)( void *)(items + (i) * 8) = \
+ _mm256_sub_epi32(_mm256_max_epu32( \
+ *(const __m256i *)(const void *)(items + (i) * 8), sub2), sub2);
+
+Z7_NO_INLINE
+static
+#ifdef LZFIND_ATTRIB_AVX2
+LZFIND_ATTRIB_AVX2
+#endif
+void
+Z7_FASTCALL
+LzFind_SaturSub_256(UInt32 subValue, CLzRef *items, const CLzRef *lim)
+{
+ const __m256i sub2 = _mm256_set_epi32(
+ (Int32)subValue, (Int32)subValue, (Int32)subValue, (Int32)subValue,
+ (Int32)subValue, (Int32)subValue, (Int32)subValue, (Int32)subValue);
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SASUB_256(0) SASUB_256(1) items += 2 * 8;
+ SASUB_256(0) SASUB_256(1) items += 2 * 8;
+ }
+ while (items != lim);
+}
+#endif // USE_LZFIND_SATUR_SUB_256
+
+#ifndef FORCE_LZFIND_SATUR_SUB_128
+typedef void (Z7_FASTCALL *LZFIND_SATUR_SUB_CODE_FUNC)(
+ UInt32 subValue, CLzRef *items, const CLzRef *lim);
+static LZFIND_SATUR_SUB_CODE_FUNC g_LzFind_SaturSub;
+#endif // FORCE_LZFIND_SATUR_SUB_128
+
+#endif // USE_LZFIND_SATUR_SUB_128
+
+
+// kEmptyHashValue must be zero
+// #define SASUB_32(i) { UInt32 v = items[i]; UInt32 m = v - subValue; if (v < subValue) m = kEmptyHashValue; items[i] = m; }
+#define SASUB_32(i) { UInt32 v = items[i]; if (v < subValue) v = subValue; items[i] = v - subValue; }
+
+#ifdef FORCE_LZFIND_SATUR_SUB_128
+
+#define DEFAULT_SaturSub LzFind_SaturSub_128
+
+#else
+
+#define DEFAULT_SaturSub LzFind_SaturSub_32
+
+Z7_NO_INLINE
+static
+void
+Z7_FASTCALL
+LzFind_SaturSub_32(UInt32 subValue, CLzRef *items, const CLzRef *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SASUB_32(0) SASUB_32(1) items += 2;
+ SASUB_32(0) SASUB_32(1) items += 2;
+ SASUB_32(0) SASUB_32(1) items += 2;
+ SASUB_32(0) SASUB_32(1) items += 2;
+ }
+ while (items != lim);
+}
+
+#endif
+
+
+Z7_NO_INLINE
+void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems)
+{
+ #define LZFIND_NORM_ALIGN_BLOCK_SIZE (1 << 7)
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ for (; numItems != 0 && ((unsigned)(ptrdiff_t)items & (LZFIND_NORM_ALIGN_BLOCK_SIZE - 1)) != 0; numItems--)
+ {
+ SASUB_32(0)
+ items++;
+ }
+ {
+ const size_t k_Align_Mask = (LZFIND_NORM_ALIGN_BLOCK_SIZE / 4 - 1);
+ CLzRef *lim = items + (numItems & ~(size_t)k_Align_Mask);
+ numItems &= k_Align_Mask;
+ if (items != lim)
+ {
+ #if defined(USE_LZFIND_SATUR_SUB_128) && !defined(FORCE_LZFIND_SATUR_SUB_128)
+ if (g_LzFind_SaturSub)
+ g_LzFind_SaturSub(subValue, items, lim);
+ else
+ #endif
+ DEFAULT_SaturSub(subValue, items, lim);
+ }
+ items = lim;
+ }
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ for (; numItems != 0; numItems--)
+ {
+ SASUB_32(0)
+ items++;
+ }
+}
+
+
+
+// call MatchFinder_CheckLimits() only after (p->pos++) update
+
+Z7_NO_INLINE
+static void MatchFinder_CheckLimits(CMatchFinder *p)
+{
+ if (// !p->streamEndWasReached && p->result == SZ_OK &&
+ p->keepSizeAfter == GET_AVAIL_BYTES(p))
+ {
+ // we try to read only in exact state (p->keepSizeAfter == GET_AVAIL_BYTES(p))
+ if (MatchFinder_NeedMove(p))
+ MatchFinder_MoveBlock(p);
+ MatchFinder_ReadBlock(p);
+ }
+
+ if (p->pos == kMaxValForNormalize)
+ if (GET_AVAIL_BYTES(p) >= p->numHashBytes) // optional optimization for last bytes of data.
+ /*
+ if we disable normalization for last bytes of data, and
+ if (data_size == 4 GiB), we don't call wastfull normalization,
+ but (pos) will be wrapped over Zero (0) in that case.
+ And we cannot resume later to normal operation
+ */
+ {
+ // MatchFinder_Normalize(p);
+ /* after normalization we need (p->pos >= p->historySize + 1); */
+ /* we can reduce subValue to aligned value, if want to keep alignment
+ of (p->pos) and (p->buffer) for speculated accesses. */
+ const UInt32 subValue = (p->pos - p->historySize - 1) /* & ~(UInt32)(kNormalizeAlign - 1) */;
+ // const UInt32 subValue = (1 << 15); // for debug
+ // printf("\nMatchFinder_Normalize() subValue == 0x%x\n", subValue);
+ MatchFinder_REDUCE_OFFSETS(p, subValue)
+ MatchFinder_Normalize3(subValue, p->hash, (size_t)p->hashMask + 1 + p->fixedHashSize);
+ {
+ size_t numSonRefs = p->cyclicBufferSize;
+ if (p->btMode)
+ numSonRefs <<= 1;
+ MatchFinder_Normalize3(subValue, p->son, numSonRefs);
+ }
+ }
+
+ if (p->cyclicBufferPos == p->cyclicBufferSize)
+ p->cyclicBufferPos = 0;
+
+ MatchFinder_SetLimits(p);
+}
+
+
+/*
+ (lenLimit > maxLen)
+*/
+Z7_FORCE_INLINE
+static UInt32 * Hc_GetMatchesSpec(size_t lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
+ UInt32 *d, unsigned maxLen)
+{
+ /*
+ son[_cyclicBufferPos] = curMatch;
+ for (;;)
+ {
+ UInt32 delta = pos - curMatch;
+ if (cutValue-- == 0 || delta >= _cyclicBufferSize)
+ return d;
+ {
+ const Byte *pb = cur - delta;
+ curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
+ if (pb[maxLen] == cur[maxLen] && *pb == *cur)
+ {
+ UInt32 len = 0;
+ while (++len != lenLimit)
+ if (pb[len] != cur[len])
+ break;
+ if (maxLen < len)
+ {
+ maxLen = len;
+ *d++ = len;
+ *d++ = delta - 1;
+ if (len == lenLimit)
+ return d;
+ }
+ }
+ }
+ }
+ */
+
+ const Byte *lim = cur + lenLimit;
+ son[_cyclicBufferPos] = curMatch;
+
+ do
+ {
+ UInt32 delta;
+
+ if (curMatch == 0)
+ break;
+ // if (curMatch2 >= curMatch) return NULL;
+ delta = pos - curMatch;
+ if (delta >= _cyclicBufferSize)
+ break;
+ {
+ ptrdiff_t diff;
+ curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
+ diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
+ if (cur[maxLen] == cur[(ptrdiff_t)maxLen + diff])
+ {
+ const Byte *c = cur;
+ while (*c == c[diff])
+ {
+ if (++c == lim)
+ {
+ d[0] = (UInt32)(lim - cur);
+ d[1] = delta - 1;
+ return d + 2;
+ }
+ }
+ {
+ const unsigned len = (unsigned)(c - cur);
+ if (maxLen < len)
+ {
+ maxLen = len;
+ d[0] = (UInt32)len;
+ d[1] = delta - 1;
+ d += 2;
+ }
+ }
+ }
+ }
+ }
+ while (--cutValue);
+
+ return d;
+}
+
+
+Z7_FORCE_INLINE
+UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
+ UInt32 *d, UInt32 maxLen)
+{
+ CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
+ CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
+ unsigned len0 = 0, len1 = 0;
+
+ UInt32 cmCheck;
+
+ // if (curMatch >= pos) { *ptr0 = *ptr1 = kEmptyHashValue; return NULL; }
+
+ cmCheck = (UInt32)(pos - _cyclicBufferSize);
+ if ((UInt32)pos <= _cyclicBufferSize)
+ cmCheck = 0;
+
+ if (cmCheck < curMatch)
+ do
+ {
+ const UInt32 delta = pos - curMatch;
+ {
+ CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
+ const Byte *pb = cur - delta;
+ unsigned len = (len0 < len1 ? len0 : len1);
+ const UInt32 pair0 = pair[0];
+ if (pb[len] == cur[len])
+ {
+ if (++len != lenLimit && pb[len] == cur[len])
+ while (++len != lenLimit)
+ if (pb[len] != cur[len])
+ break;
+ if (maxLen < len)
+ {
+ maxLen = (UInt32)len;
+ *d++ = (UInt32)len;
+ *d++ = delta - 1;
+ if (len == lenLimit)
+ {
+ *ptr1 = pair0;
+ *ptr0 = pair[1];
+ return d;
+ }
+ }
+ }
+ if (pb[len] < cur[len])
+ {
+ *ptr1 = curMatch;
+ // const UInt32 curMatch2 = pair[1];
+ // if (curMatch2 >= curMatch) { *ptr0 = *ptr1 = kEmptyHashValue; return NULL; }
+ // curMatch = curMatch2;
+ curMatch = pair[1];
+ ptr1 = pair + 1;
+ len1 = len;
+ }
+ else
+ {
+ *ptr0 = curMatch;
+ curMatch = pair[0];
+ ptr0 = pair;
+ len0 = len;
+ }
+ }
+ }
+ while(--cutValue && cmCheck < curMatch);
+
+ *ptr0 = *ptr1 = kEmptyHashValue;
+ return d;
+}
+
+
+static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue)
+{
+ CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
+ CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
+ unsigned len0 = 0, len1 = 0;
+
+ UInt32 cmCheck;
+
+ cmCheck = (UInt32)(pos - _cyclicBufferSize);
+ if ((UInt32)pos <= _cyclicBufferSize)
+ cmCheck = 0;
+
+ if (// curMatch >= pos || // failure
+ cmCheck < curMatch)
+ do
+ {
+ const UInt32 delta = pos - curMatch;
+ {
+ CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
+ const Byte *pb = cur - delta;
+ unsigned len = (len0 < len1 ? len0 : len1);
+ if (pb[len] == cur[len])
+ {
+ while (++len != lenLimit)
+ if (pb[len] != cur[len])
+ break;
+ {
+ if (len == lenLimit)
+ {
+ *ptr1 = pair[0];
+ *ptr0 = pair[1];
+ return;
+ }
+ }
+ }
+ if (pb[len] < cur[len])
+ {
+ *ptr1 = curMatch;
+ curMatch = pair[1];
+ ptr1 = pair + 1;
+ len1 = len;
+ }
+ else
+ {
+ *ptr0 = curMatch;
+ curMatch = pair[0];
+ ptr0 = pair;
+ len0 = len;
+ }
+ }
+ }
+ while(--cutValue && cmCheck < curMatch);
+
+ *ptr0 = *ptr1 = kEmptyHashValue;
+ return;
+}
+
+
+#define MOVE_POS \
+ ++p->cyclicBufferPos; \
+ p->buffer++; \
+ { const UInt32 pos1 = p->pos + 1; p->pos = pos1; if (pos1 == p->posLimit) MatchFinder_CheckLimits(p); }
+
+#define MOVE_POS_RET MOVE_POS return distances;
+
+Z7_NO_INLINE
+static void MatchFinder_MovePos(CMatchFinder *p)
+{
+ /* we go here at the end of stream data, when (avail < num_hash_bytes)
+ We don't update sons[cyclicBufferPos << btMode].
+ So (sons) record will contain junk. And we cannot resume match searching
+ to normal operation, even if we will provide more input data in buffer.
+ p->sons[p->cyclicBufferPos << p->btMode] = 0; // kEmptyHashValue
+ if (p->btMode)
+ p->sons[(p->cyclicBufferPos << p->btMode) + 1] = 0; // kEmptyHashValue
+ */
+ MOVE_POS
+}
+
+#define GET_MATCHES_HEADER2(minLen, ret_op) \
+ unsigned lenLimit; UInt32 hv; const Byte *cur; UInt32 curMatch; \
+ lenLimit = (unsigned)p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); ret_op; }} \
+ cur = p->buffer;
+
+#define GET_MATCHES_HEADER(minLen) GET_MATCHES_HEADER2(minLen, return distances)
+#define SKIP_HEADER(minLen) do { GET_MATCHES_HEADER2(minLen, continue)
+
+#define MF_PARAMS(p) lenLimit, curMatch, p->pos, p->buffer, p->son, p->cyclicBufferPos, p->cyclicBufferSize, p->cutValue
+
+#define SKIP_FOOTER SkipMatchesSpec(MF_PARAMS(p)); MOVE_POS } while (--num);
+
+#define GET_MATCHES_FOOTER_BASE(_maxLen_, func) \
+ distances = func(MF_PARAMS(p), \
+ distances, (UInt32)_maxLen_); MOVE_POS_RET
+
+#define GET_MATCHES_FOOTER_BT(_maxLen_) \
+ GET_MATCHES_FOOTER_BASE(_maxLen_, GetMatchesSpec1)
+
+#define GET_MATCHES_FOOTER_HC(_maxLen_) \
+ GET_MATCHES_FOOTER_BASE(_maxLen_, Hc_GetMatchesSpec)
+
+
+
+#define UPDATE_maxLen { \
+ const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)d2; \
+ const Byte *c = cur + maxLen; \
+ const Byte *lim = cur + lenLimit; \
+ for (; c != lim; c++) if (*(c + diff) != *c) break; \
+ maxLen = (unsigned)(c - cur); }
+
+static UInt32* Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ GET_MATCHES_HEADER(2)
+ HASH2_CALC
+ curMatch = p->hash[hv];
+ p->hash[hv] = p->pos;
+ GET_MATCHES_FOOTER_BT(1)
+}
+
+UInt32* Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ GET_MATCHES_HEADER(3)
+ HASH_ZIP_CALC
+ curMatch = p->hash[hv];
+ p->hash[hv] = p->pos;
+ GET_MATCHES_FOOTER_BT(2)
+}
+
+
+#define SET_mmm \
+ mmm = p->cyclicBufferSize; \
+ if (pos < mmm) \
+ mmm = pos;
+
+
+static UInt32* Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ UInt32 mmm;
+ UInt32 h2, d2, pos;
+ unsigned maxLen;
+ UInt32 *hash;
+ GET_MATCHES_HEADER(3)
+
+ HASH3_CALC
+
+ hash = p->hash;
+ pos = p->pos;
+
+ d2 = pos - hash[h2];
+
+ curMatch = (hash + kFix3HashSize)[hv];
+
+ hash[h2] = pos;
+ (hash + kFix3HashSize)[hv] = pos;
+
+ SET_mmm
+
+ maxLen = 2;
+
+ if (d2 < mmm && *(cur - d2) == *cur)
+ {
+ UPDATE_maxLen
+ distances[0] = (UInt32)maxLen;
+ distances[1] = d2 - 1;
+ distances += 2;
+ if (maxLen == lenLimit)
+ {
+ SkipMatchesSpec(MF_PARAMS(p));
+ MOVE_POS_RET
+ }
+ }
+
+ GET_MATCHES_FOOTER_BT(maxLen)
+}
+
+
+static UInt32* Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ UInt32 mmm;
+ UInt32 h2, h3, d2, d3, pos;
+ unsigned maxLen;
+ UInt32 *hash;
+ GET_MATCHES_HEADER(4)
+
+ HASH4_CALC
+
+ hash = p->hash;
+ pos = p->pos;
+
+ d2 = pos - hash [h2];
+ d3 = pos - (hash + kFix3HashSize)[h3];
+ curMatch = (hash + kFix4HashSize)[hv];
+
+ hash [h2] = pos;
+ (hash + kFix3HashSize)[h3] = pos;
+ (hash + kFix4HashSize)[hv] = pos;
+
+ SET_mmm
+
+ maxLen = 3;
+
+ for (;;)
+ {
+ if (d2 < mmm && *(cur - d2) == *cur)
+ {
+ distances[0] = 2;
+ distances[1] = d2 - 1;
+ distances += 2;
+ if (*(cur - d2 + 2) == cur[2])
+ {
+ // distances[-2] = 3;
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ d2 = d3;
+ distances[1] = d3 - 1;
+ distances += 2;
+ }
+ else
+ break;
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ d2 = d3;
+ distances[1] = d3 - 1;
+ distances += 2;
+ }
+ else
+ break;
+
+ UPDATE_maxLen
+ distances[-2] = (UInt32)maxLen;
+ if (maxLen == lenLimit)
+ {
+ SkipMatchesSpec(MF_PARAMS(p));
+ MOVE_POS_RET
+ }
+ break;
+ }
+
+ GET_MATCHES_FOOTER_BT(maxLen)
+}
+
+
+static UInt32* Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ UInt32 mmm;
+ UInt32 h2, h3, d2, d3, maxLen, pos;
+ UInt32 *hash;
+ GET_MATCHES_HEADER(5)
+
+ HASH5_CALC
+
+ hash = p->hash;
+ pos = p->pos;
+
+ d2 = pos - hash [h2];
+ d3 = pos - (hash + kFix3HashSize)[h3];
+ // d4 = pos - (hash + kFix4HashSize)[h4];
+
+ curMatch = (hash + kFix5HashSize)[hv];
+
+ hash [h2] = pos;
+ (hash + kFix3HashSize)[h3] = pos;
+ // (hash + kFix4HashSize)[h4] = pos;
+ (hash + kFix5HashSize)[hv] = pos;
+
+ SET_mmm
+
+ maxLen = 4;
+
+ for (;;)
+ {
+ if (d2 < mmm && *(cur - d2) == *cur)
+ {
+ distances[0] = 2;
+ distances[1] = d2 - 1;
+ distances += 2;
+ if (*(cur - d2 + 2) == cur[2])
+ {
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ distances[1] = d3 - 1;
+ distances += 2;
+ d2 = d3;
+ }
+ else
+ break;
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ distances[1] = d3 - 1;
+ distances += 2;
+ d2 = d3;
+ }
+ else
+ break;
+
+ distances[-2] = 3;
+ if (*(cur - d2 + 3) != cur[3])
+ break;
+ UPDATE_maxLen
+ distances[-2] = (UInt32)maxLen;
+ if (maxLen == lenLimit)
+ {
+ SkipMatchesSpec(MF_PARAMS(p));
+ MOVE_POS_RET
+ }
+ break;
+ }
+
+ GET_MATCHES_FOOTER_BT(maxLen)
+}
+
+
+static UInt32* Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ UInt32 mmm;
+ UInt32 h2, h3, d2, d3, pos;
+ unsigned maxLen;
+ UInt32 *hash;
+ GET_MATCHES_HEADER(4)
+
+ HASH4_CALC
+
+ hash = p->hash;
+ pos = p->pos;
+
+ d2 = pos - hash [h2];
+ d3 = pos - (hash + kFix3HashSize)[h3];
+ curMatch = (hash + kFix4HashSize)[hv];
+
+ hash [h2] = pos;
+ (hash + kFix3HashSize)[h3] = pos;
+ (hash + kFix4HashSize)[hv] = pos;
+
+ SET_mmm
+
+ maxLen = 3;
+
+ for (;;)
+ {
+ if (d2 < mmm && *(cur - d2) == *cur)
+ {
+ distances[0] = 2;
+ distances[1] = d2 - 1;
+ distances += 2;
+ if (*(cur - d2 + 2) == cur[2])
+ {
+ // distances[-2] = 3;
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ d2 = d3;
+ distances[1] = d3 - 1;
+ distances += 2;
+ }
+ else
+ break;
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ d2 = d3;
+ distances[1] = d3 - 1;
+ distances += 2;
+ }
+ else
+ break;
+
+ UPDATE_maxLen
+ distances[-2] = (UInt32)maxLen;
+ if (maxLen == lenLimit)
+ {
+ p->son[p->cyclicBufferPos] = curMatch;
+ MOVE_POS_RET
+ }
+ break;
+ }
+
+ GET_MATCHES_FOOTER_HC(maxLen)
+}
+
+
+static UInt32 * Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ UInt32 mmm;
+ UInt32 h2, h3, d2, d3, maxLen, pos;
+ UInt32 *hash;
+ GET_MATCHES_HEADER(5)
+
+ HASH5_CALC
+
+ hash = p->hash;
+ pos = p->pos;
+
+ d2 = pos - hash [h2];
+ d3 = pos - (hash + kFix3HashSize)[h3];
+ // d4 = pos - (hash + kFix4HashSize)[h4];
+
+ curMatch = (hash + kFix5HashSize)[hv];
+
+ hash [h2] = pos;
+ (hash + kFix3HashSize)[h3] = pos;
+ // (hash + kFix4HashSize)[h4] = pos;
+ (hash + kFix5HashSize)[hv] = pos;
+
+ SET_mmm
+
+ maxLen = 4;
+
+ for (;;)
+ {
+ if (d2 < mmm && *(cur - d2) == *cur)
+ {
+ distances[0] = 2;
+ distances[1] = d2 - 1;
+ distances += 2;
+ if (*(cur - d2 + 2) == cur[2])
+ {
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ distances[1] = d3 - 1;
+ distances += 2;
+ d2 = d3;
+ }
+ else
+ break;
+ }
+ else if (d3 < mmm && *(cur - d3) == *cur)
+ {
+ distances[1] = d3 - 1;
+ distances += 2;
+ d2 = d3;
+ }
+ else
+ break;
+
+ distances[-2] = 3;
+ if (*(cur - d2 + 3) != cur[3])
+ break;
+ UPDATE_maxLen
+ distances[-2] = maxLen;
+ if (maxLen == lenLimit)
+ {
+ p->son[p->cyclicBufferPos] = curMatch;
+ MOVE_POS_RET
+ }
+ break;
+ }
+
+ GET_MATCHES_FOOTER_HC(maxLen)
+}
+
+
+UInt32* Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
+{
+ GET_MATCHES_HEADER(3)
+ HASH_ZIP_CALC
+ curMatch = p->hash[hv];
+ p->hash[hv] = p->pos;
+ GET_MATCHES_FOOTER_HC(2)
+}
+
+
+static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ SKIP_HEADER(2)
+ {
+ HASH2_CALC
+ curMatch = p->hash[hv];
+ p->hash[hv] = p->pos;
+ }
+ SKIP_FOOTER
+}
+
+void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ SKIP_HEADER(3)
+ {
+ HASH_ZIP_CALC
+ curMatch = p->hash[hv];
+ p->hash[hv] = p->pos;
+ }
+ SKIP_FOOTER
+}
+
+static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ SKIP_HEADER(3)
+ {
+ UInt32 h2;
+ UInt32 *hash;
+ HASH3_CALC
+ hash = p->hash;
+ curMatch = (hash + kFix3HashSize)[hv];
+ hash[h2] =
+ (hash + kFix3HashSize)[hv] = p->pos;
+ }
+ SKIP_FOOTER
+}
+
+static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ SKIP_HEADER(4)
+ {
+ UInt32 h2, h3;
+ UInt32 *hash;
+ HASH4_CALC
+ hash = p->hash;
+ curMatch = (hash + kFix4HashSize)[hv];
+ hash [h2] =
+ (hash + kFix3HashSize)[h3] =
+ (hash + kFix4HashSize)[hv] = p->pos;
+ }
+ SKIP_FOOTER
+}
+
+static void Bt5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ SKIP_HEADER(5)
+ {
+ UInt32 h2, h3;
+ UInt32 *hash;
+ HASH5_CALC
+ hash = p->hash;
+ curMatch = (hash + kFix5HashSize)[hv];
+ hash [h2] =
+ (hash + kFix3HashSize)[h3] =
+ // (hash + kFix4HashSize)[h4] =
+ (hash + kFix5HashSize)[hv] = p->pos;
+ }
+ SKIP_FOOTER
+}
+
+
+#define HC_SKIP_HEADER(minLen) \
+ do { if (p->lenLimit < minLen) { MatchFinder_MovePos(p); num--; continue; } { \
+ const Byte *cur; \
+ UInt32 *hash; \
+ UInt32 *son; \
+ UInt32 pos = p->pos; \
+ UInt32 num2 = num; \
+ /* (p->pos == p->posLimit) is not allowed here !!! */ \
+ { const UInt32 rem = p->posLimit - pos; if (num2 > rem) num2 = rem; } \
+ num -= num2; \
+ { const UInt32 cycPos = p->cyclicBufferPos; \
+ son = p->son + cycPos; \
+ p->cyclicBufferPos = cycPos + num2; } \
+ cur = p->buffer; \
+ hash = p->hash; \
+ do { \
+ UInt32 curMatch; \
+ UInt32 hv;
+
+
+#define HC_SKIP_FOOTER \
+ cur++; pos++; *son++ = curMatch; \
+ } while (--num2); \
+ p->buffer = cur; \
+ p->pos = pos; \
+ if (pos == p->posLimit) MatchFinder_CheckLimits(p); \
+ }} while(num); \
+
+
+static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ HC_SKIP_HEADER(4)
+
+ UInt32 h2, h3;
+ HASH4_CALC
+ curMatch = (hash + kFix4HashSize)[hv];
+ hash [h2] =
+ (hash + kFix3HashSize)[h3] =
+ (hash + kFix4HashSize)[hv] = pos;
+
+ HC_SKIP_FOOTER
+}
+
+
+static void Hc5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ HC_SKIP_HEADER(5)
+
+ UInt32 h2, h3;
+ HASH5_CALC
+ curMatch = (hash + kFix5HashSize)[hv];
+ hash [h2] =
+ (hash + kFix3HashSize)[h3] =
+ // (hash + kFix4HashSize)[h4] =
+ (hash + kFix5HashSize)[hv] = pos;
+
+ HC_SKIP_FOOTER
+}
+
+
+void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
+{
+ HC_SKIP_HEADER(3)
+
+ HASH_ZIP_CALC
+ curMatch = hash[hv];
+ hash[hv] = pos;
+
+ HC_SKIP_FOOTER
+}
+
+
+void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder2 *vTable)
+{
+ vTable->Init = (Mf_Init_Func)MatchFinder_Init;
+ vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinder_GetNumAvailableBytes;
+ vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinder_GetPointerToCurrentPos;
+ if (!p->btMode)
+ {
+ if (p->numHashBytes <= 4)
+ {
+ vTable->GetMatches = (Mf_GetMatches_Func)Hc4_MatchFinder_GetMatches;
+ vTable->Skip = (Mf_Skip_Func)Hc4_MatchFinder_Skip;
+ }
+ else
+ {
+ vTable->GetMatches = (Mf_GetMatches_Func)Hc5_MatchFinder_GetMatches;
+ vTable->Skip = (Mf_Skip_Func)Hc5_MatchFinder_Skip;
+ }
+ }
+ else if (p->numHashBytes == 2)
+ {
+ vTable->GetMatches = (Mf_GetMatches_Func)Bt2_MatchFinder_GetMatches;
+ vTable->Skip = (Mf_Skip_Func)Bt2_MatchFinder_Skip;
+ }
+ else if (p->numHashBytes == 3)
+ {
+ vTable->GetMatches = (Mf_GetMatches_Func)Bt3_MatchFinder_GetMatches;
+ vTable->Skip = (Mf_Skip_Func)Bt3_MatchFinder_Skip;
+ }
+ else if (p->numHashBytes == 4)
+ {
+ vTable->GetMatches = (Mf_GetMatches_Func)Bt4_MatchFinder_GetMatches;
+ vTable->Skip = (Mf_Skip_Func)Bt4_MatchFinder_Skip;
+ }
+ else
+ {
+ vTable->GetMatches = (Mf_GetMatches_Func)Bt5_MatchFinder_GetMatches;
+ vTable->Skip = (Mf_Skip_Func)Bt5_MatchFinder_Skip;
+ }
+}
+
+
+
+void LzFindPrepare(void)
+{
+ #ifndef FORCE_LZFIND_SATUR_SUB_128
+ #ifdef USE_LZFIND_SATUR_SUB_128
+ LZFIND_SATUR_SUB_CODE_FUNC f = NULL;
+ #ifdef MY_CPU_ARM_OR_ARM64
+ {
+ if (CPU_IsSupported_NEON())
+ {
+ // #pragma message ("=== LzFind NEON")
+ PRF(printf("\n=== LzFind NEON\n"));
+ f = LzFind_SaturSub_128;
+ }
+ // f = 0; // for debug
+ }
+ #else // MY_CPU_ARM_OR_ARM64
+ if (CPU_IsSupported_SSE41())
+ {
+ // #pragma message ("=== LzFind SSE41")
+ PRF(printf("\n=== LzFind SSE41\n"));
+ f = LzFind_SaturSub_128;
+
+ #ifdef USE_LZFIND_SATUR_SUB_256
+ if (CPU_IsSupported_AVX2())
+ {
+ // #pragma message ("=== LzFind AVX2")
+ PRF(printf("\n=== LzFind AVX2\n"));
+ f = LzFind_SaturSub_256;
+ }
+ #endif
+ }
+ #endif // MY_CPU_ARM_OR_ARM64
+ g_LzFind_SaturSub = f;
+ #endif // USE_LZFIND_SATUR_SUB_128
+ #endif // FORCE_LZFIND_SATUR_SUB_128
+}
+
+
+#undef MOVE_POS
+#undef MOVE_POS_RET
+#undef PRF
diff --git a/C/LzFind.h b/C/LzFind.h
index c77adde..a3f72c9 100644
--- a/C/LzFind.h
+++ b/C/LzFind.h
@@ -1,121 +1,159 @@
-/* LzFind.h -- Match finder for LZ algorithms
-2017-06-10 : Igor Pavlov : Public domain */
-
-#ifndef __LZ_FIND_H
-#define __LZ_FIND_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-typedef UInt32 CLzRef;
-
-typedef struct _CMatchFinder
-{
- Byte *buffer;
- UInt32 pos;
- UInt32 posLimit;
- UInt32 streamPos;
- UInt32 lenLimit;
-
- UInt32 cyclicBufferPos;
- UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
-
- Byte streamEndWasReached;
- Byte btMode;
- Byte bigHash;
- Byte directInput;
-
- UInt32 matchMaxLen;
- CLzRef *hash;
- CLzRef *son;
- UInt32 hashMask;
- UInt32 cutValue;
-
- Byte *bufferBase;
- ISeqInStream *stream;
-
- UInt32 blockSize;
- UInt32 keepSizeBefore;
- UInt32 keepSizeAfter;
-
- UInt32 numHashBytes;
- size_t directInputRem;
- UInt32 historySize;
- UInt32 fixedHashSize;
- UInt32 hashSizeSum;
- SRes result;
- UInt32 crc[256];
- size_t numRefs;
-
- UInt64 expectedDataSize;
-} CMatchFinder;
-
-#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((p)->buffer)
-
-#define Inline_MatchFinder_GetNumAvailableBytes(p) ((p)->streamPos - (p)->pos)
-
-#define Inline_MatchFinder_IsFinishedOK(p) \
- ((p)->streamEndWasReached \
- && (p)->streamPos == (p)->pos \
- && (!(p)->directInput || (p)->directInputRem == 0))
-
-int MatchFinder_NeedMove(CMatchFinder *p);
-Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
-void MatchFinder_MoveBlock(CMatchFinder *p);
-void MatchFinder_ReadIfRequired(CMatchFinder *p);
-
-void MatchFinder_Construct(CMatchFinder *p);
-
-/* Conditions:
- historySize <= 3 GB
- keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB
-*/
-int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
- UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
- ISzAllocPtr alloc);
-void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc);
-void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems);
-void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
-
-UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
- UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
- UInt32 *distances, UInt32 maxLen);
-
-/*
-Conditions:
- Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
- Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
-*/
-
-typedef void (*Mf_Init_Func)(void *object);
-typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
-typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
-typedef UInt32 (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
-typedef void (*Mf_Skip_Func)(void *object, UInt32);
-
-typedef struct _IMatchFinder
-{
- Mf_Init_Func Init;
- Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
- Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
- Mf_GetMatches_Func GetMatches;
- Mf_Skip_Func Skip;
-} IMatchFinder;
-
-void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable);
-
-void MatchFinder_Init_LowHash(CMatchFinder *p);
-void MatchFinder_Init_HighHash(CMatchFinder *p);
-void MatchFinder_Init_3(CMatchFinder *p, int readData);
-void MatchFinder_Init(CMatchFinder *p);
-
-UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
-UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
-
-void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
-void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
-
-EXTERN_C_END
-
-#endif
+/* LzFind.h -- Match finder for LZ algorithms
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZ_FIND_H
+#define ZIP7_INC_LZ_FIND_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+typedef UInt32 CLzRef;
+
+typedef struct
+{
+ const Byte *buffer;
+ UInt32 pos;
+ UInt32 posLimit;
+ UInt32 streamPos; /* wrap over Zero is allowed (streamPos < pos). Use (UInt32)(streamPos - pos) */
+ UInt32 lenLimit;
+
+ UInt32 cyclicBufferPos;
+ UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
+
+ Byte streamEndWasReached;
+ Byte btMode;
+ Byte bigHash;
+ Byte directInput;
+
+ UInt32 matchMaxLen;
+ CLzRef *hash;
+ CLzRef *son;
+ UInt32 hashMask;
+ UInt32 cutValue;
+
+ Byte *bufBase;
+ ISeqInStreamPtr stream;
+
+ UInt32 blockSize;
+ UInt32 keepSizeBefore;
+ UInt32 keepSizeAfter;
+
+ UInt32 numHashBytes;
+ size_t directInputRem;
+ UInt32 historySize;
+ UInt32 fixedHashSize;
+ Byte numHashBytes_Min;
+ Byte numHashOutBits;
+ Byte _pad2_[2];
+ SRes result;
+ UInt32 crc[256];
+ size_t numRefs;
+
+ UInt64 expectedDataSize;
+} CMatchFinder;
+
+#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((const Byte *)(p)->buffer)
+
+#define Inline_MatchFinder_GetNumAvailableBytes(p) ((UInt32)((p)->streamPos - (p)->pos))
+
+/*
+#define Inline_MatchFinder_IsFinishedOK(p) \
+ ((p)->streamEndWasReached \
+ && (p)->streamPos == (p)->pos \
+ && (!(p)->directInput || (p)->directInputRem == 0))
+*/
+
+int MatchFinder_NeedMove(CMatchFinder *p);
+/* Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p); */
+void MatchFinder_MoveBlock(CMatchFinder *p);
+void MatchFinder_ReadIfRequired(CMatchFinder *p);
+
+void MatchFinder_Construct(CMatchFinder *p);
+
+/* (directInput = 0) is default value.
+ It's required to provide correct (directInput) value
+ before calling MatchFinder_Create().
+ You can set (directInput) by any of the following calls:
+ - MatchFinder_SET_DIRECT_INPUT_BUF()
+ - MatchFinder_SET_STREAM()
+ - MatchFinder_SET_STREAM_MODE()
+*/
+
+#define MatchFinder_SET_DIRECT_INPUT_BUF(p, _src_, _srcLen_) { \
+ (p)->stream = NULL; \
+ (p)->directInput = 1; \
+ (p)->buffer = (_src_); \
+ (p)->directInputRem = (_srcLen_); }
+
+/*
+#define MatchFinder_SET_STREAM_MODE(p) { \
+ (p)->directInput = 0; }
+*/
+
+#define MatchFinder_SET_STREAM(p, _stream_) { \
+ (p)->stream = _stream_; \
+ (p)->directInput = 0; }
+
+
+int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
+ UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
+ ISzAllocPtr alloc);
+void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc);
+void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems);
+
+/*
+#define MatchFinder_INIT_POS(p, val) \
+ (p)->pos = (val); \
+ (p)->streamPos = (val);
+*/
+
+// void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
+#define MatchFinder_REDUCE_OFFSETS(p, subValue) \
+ (p)->pos -= (subValue); \
+ (p)->streamPos -= (subValue);
+
+
+UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
+ UInt32 *distances, UInt32 maxLen);
+
+/*
+Conditions:
+ Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
+ Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
+*/
+
+typedef void (*Mf_Init_Func)(void *object);
+typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
+typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
+typedef UInt32 * (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
+typedef void (*Mf_Skip_Func)(void *object, UInt32);
+
+typedef struct
+{
+ Mf_Init_Func Init;
+ Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
+ Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
+ Mf_GetMatches_Func GetMatches;
+ Mf_Skip_Func Skip;
+} IMatchFinder2;
+
+void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder2 *vTable);
+
+void MatchFinder_Init_LowHash(CMatchFinder *p);
+void MatchFinder_Init_HighHash(CMatchFinder *p);
+void MatchFinder_Init_4(CMatchFinder *p);
+void MatchFinder_Init(CMatchFinder *p);
+
+UInt32* Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
+UInt32* Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
+
+void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
+void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
+
+void LzFindPrepare(void);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/LzFindMt.c b/C/LzFindMt.c
index df32146..5253e6e 100644
--- a/C/LzFindMt.c
+++ b/C/LzFindMt.c
@@ -1,853 +1,1406 @@
-/* LzFindMt.c -- multithreaded Match finder for LZ algorithms
-2018-12-29 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "LzHash.h"
-
-#include "LzFindMt.h"
-
-static void MtSync_Construct(CMtSync *p)
-{
- p->wasCreated = False;
- p->csWasInitialized = False;
- p->csWasEntered = False;
- Thread_Construct(&p->thread);
- Event_Construct(&p->canStart);
- Event_Construct(&p->wasStarted);
- Event_Construct(&p->wasStopped);
- Semaphore_Construct(&p->freeSemaphore);
- Semaphore_Construct(&p->filledSemaphore);
-}
-
-static void MtSync_GetNextBlock(CMtSync *p)
-{
- if (p->needStart)
- {
- p->numProcessedBlocks = 1;
- p->needStart = False;
- p->stopWriting = False;
- p->exit = False;
- Event_Reset(&p->wasStarted);
- Event_Reset(&p->wasStopped);
-
- Event_Set(&p->canStart);
- Event_Wait(&p->wasStarted);
-
- // if (mt) MatchFinder_Init_LowHash(mt->MatchFinder);
- }
- else
- {
- CriticalSection_Leave(&p->cs);
- p->csWasEntered = False;
- p->numProcessedBlocks++;
- Semaphore_Release1(&p->freeSemaphore);
- }
- Semaphore_Wait(&p->filledSemaphore);
- CriticalSection_Enter(&p->cs);
- p->csWasEntered = True;
-}
-
-/* MtSync_StopWriting must be called if Writing was started */
-
-static void MtSync_StopWriting(CMtSync *p)
-{
- UInt32 myNumBlocks = p->numProcessedBlocks;
- if (!Thread_WasCreated(&p->thread) || p->needStart)
- return;
- p->stopWriting = True;
- if (p->csWasEntered)
- {
- CriticalSection_Leave(&p->cs);
- p->csWasEntered = False;
- }
- Semaphore_Release1(&p->freeSemaphore);
-
- Event_Wait(&p->wasStopped);
-
- while (myNumBlocks++ != p->numProcessedBlocks)
- {
- Semaphore_Wait(&p->filledSemaphore);
- Semaphore_Release1(&p->freeSemaphore);
- }
- p->needStart = True;
-}
-
-static void MtSync_Destruct(CMtSync *p)
-{
- if (Thread_WasCreated(&p->thread))
- {
- MtSync_StopWriting(p);
- p->exit = True;
- if (p->needStart)
- Event_Set(&p->canStart);
- Thread_Wait(&p->thread);
- Thread_Close(&p->thread);
- }
- if (p->csWasInitialized)
- {
- CriticalSection_Delete(&p->cs);
- p->csWasInitialized = False;
- }
-
- Event_Close(&p->canStart);
- Event_Close(&p->wasStarted);
- Event_Close(&p->wasStopped);
- Semaphore_Close(&p->freeSemaphore);
- Semaphore_Close(&p->filledSemaphore);
-
- p->wasCreated = False;
-}
-
-#define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
-
-static SRes MtSync_Create2(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj, UInt32 numBlocks)
-{
- if (p->wasCreated)
- return SZ_OK;
-
- RINOK_THREAD(CriticalSection_Init(&p->cs));
- p->csWasInitialized = True;
-
- RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart));
- RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStarted));
- RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped));
-
- RINOK_THREAD(Semaphore_Create(&p->freeSemaphore, numBlocks, numBlocks));
- RINOK_THREAD(Semaphore_Create(&p->filledSemaphore, 0, numBlocks));
-
- p->needStart = True;
-
- RINOK_THREAD(Thread_Create(&p->thread, startAddress, obj));
- p->wasCreated = True;
- return SZ_OK;
-}
-
-static SRes MtSync_Create(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj, UInt32 numBlocks)
-{
- SRes res = MtSync_Create2(p, startAddress, obj, numBlocks);
- if (res != SZ_OK)
- MtSync_Destruct(p);
- return res;
-}
-
-void MtSync_Init(CMtSync *p) { p->needStart = True; }
-
-#define kMtMaxValForNormalize 0xFFFFFFFF
-
-#define DEF_GetHeads2(name, v, action) \
- static void GetHeads ## name(const Byte *p, UInt32 pos, \
- UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc) \
- { action; for (; numHeads != 0; numHeads--) { \
- const UInt32 value = (v); p++; *heads++ = pos - hash[value]; hash[value] = pos++; } }
-
-#define DEF_GetHeads(name, v) DEF_GetHeads2(name, v, ;)
-
-DEF_GetHeads2(2, (p[0] | ((UInt32)p[1] << 8)), UNUSED_VAR(hashMask); UNUSED_VAR(crc); )
-DEF_GetHeads(3, (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8)) & hashMask)
-DEF_GetHeads(4, (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ (crc[p[3]] << 5)) & hashMask)
-DEF_GetHeads(4b, (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ ((UInt32)p[3] << 16)) & hashMask)
-/* DEF_GetHeads(5, (crc[p[0]] ^ p[1] ^ ((UInt32)p[2] << 8) ^ (crc[p[3]] << 5) ^ (crc[p[4]] << 3)) & hashMask) */
-
-static void HashThreadFunc(CMatchFinderMt *mt)
-{
- CMtSync *p = &mt->hashSync;
- for (;;)
- {
- UInt32 numProcessedBlocks = 0;
- Event_Wait(&p->canStart);
- Event_Set(&p->wasStarted);
-
- MatchFinder_Init_HighHash(mt->MatchFinder);
-
- for (;;)
- {
- if (p->exit)
- return;
- if (p->stopWriting)
- {
- p->numProcessedBlocks = numProcessedBlocks;
- Event_Set(&p->wasStopped);
- break;
- }
-
- {
- CMatchFinder *mf = mt->MatchFinder;
- if (MatchFinder_NeedMove(mf))
- {
- CriticalSection_Enter(&mt->btSync.cs);
- CriticalSection_Enter(&mt->hashSync.cs);
- {
- const Byte *beforePtr = Inline_MatchFinder_GetPointerToCurrentPos(mf);
- ptrdiff_t offset;
- MatchFinder_MoveBlock(mf);
- offset = beforePtr - Inline_MatchFinder_GetPointerToCurrentPos(mf);
- mt->pointerToCurPos -= offset;
- mt->buffer -= offset;
- }
- CriticalSection_Leave(&mt->btSync.cs);
- CriticalSection_Leave(&mt->hashSync.cs);
- continue;
- }
-
- Semaphore_Wait(&p->freeSemaphore);
-
- MatchFinder_ReadIfRequired(mf);
- if (mf->pos > (kMtMaxValForNormalize - kMtHashBlockSize))
- {
- UInt32 subValue = (mf->pos - mf->historySize - 1);
- MatchFinder_ReduceOffsets(mf, subValue);
- MatchFinder_Normalize3(subValue, mf->hash + mf->fixedHashSize, (size_t)mf->hashMask + 1);
- }
- {
- UInt32 *heads = mt->hashBuf + ((numProcessedBlocks++) & kMtHashNumBlocksMask) * kMtHashBlockSize;
- UInt32 num = mf->streamPos - mf->pos;
- heads[0] = 2;
- heads[1] = num;
- if (num >= mf->numHashBytes)
- {
- num = num - mf->numHashBytes + 1;
- if (num > kMtHashBlockSize - 2)
- num = kMtHashBlockSize - 2;
- mt->GetHeadsFunc(mf->buffer, mf->pos, mf->hash + mf->fixedHashSize, mf->hashMask, heads + 2, num, mf->crc);
- heads[0] = 2 + num;
- }
- mf->pos += num;
- mf->buffer += num;
- }
- }
-
- Semaphore_Release1(&p->filledSemaphore);
- }
- }
-}
-
-static void MatchFinderMt_GetNextBlock_Hash(CMatchFinderMt *p)
-{
- MtSync_GetNextBlock(&p->hashSync);
- p->hashBufPosLimit = p->hashBufPos = ((p->hashSync.numProcessedBlocks - 1) & kMtHashNumBlocksMask) * kMtHashBlockSize;
- p->hashBufPosLimit += p->hashBuf[p->hashBufPos++];
- p->hashNumAvail = p->hashBuf[p->hashBufPos++];
-}
-
-#define kEmptyHashValue 0
-
-#define MFMT_GM_INLINE
-
-#ifdef MFMT_GM_INLINE
-
-/*
- we use size_t for _cyclicBufferPos instead of UInt32
- to eliminate "movsx" BUG in old MSVC x64 compiler.
-*/
-
-MY_NO_INLINE
-static UInt32 *GetMatchesSpecN(UInt32 lenLimit, UInt32 pos, const Byte *cur, CLzRef *son,
- size_t _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
- UInt32 *distances, UInt32 _maxLen, const UInt32 *hash, const UInt32 *limit, UInt32 size, UInt32 *posRes)
-{
- do
- {
- UInt32 *_distances = ++distances;
- UInt32 delta = *hash++;
-
- CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
- CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
- unsigned len0 = 0, len1 = 0;
- UInt32 cutValue = _cutValue;
- unsigned maxLen = (unsigned)_maxLen;
-
- /*
- if (size > 1)
- {
- UInt32 delta = *hash;
- if (delta < _cyclicBufferSize)
- {
- UInt32 cyc1 = _cyclicBufferPos + 1;
- CLzRef *pair = son + ((size_t)(cyc1 - delta + ((delta > cyc1) ? _cyclicBufferSize : 0)) << 1);
- Byte b = *(cur + 1 - delta);
- _distances[0] = pair[0];
- _distances[1] = b;
- }
- }
- */
- if (cutValue == 0 || delta >= _cyclicBufferSize)
- {
- *ptr0 = *ptr1 = kEmptyHashValue;
- }
- else
- for(;;)
- {
- {
- CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((_cyclicBufferPos < delta) ? _cyclicBufferSize : 0)) << 1);
- const Byte *pb = cur - delta;
- unsigned len = (len0 < len1 ? len0 : len1);
- UInt32 pair0 = *pair;
- if (pb[len] == cur[len])
- {
- if (++len != lenLimit && pb[len] == cur[len])
- while (++len != lenLimit)
- if (pb[len] != cur[len])
- break;
- if (maxLen < len)
- {
- maxLen = len;
- *distances++ = (UInt32)len;
- *distances++ = delta - 1;
- if (len == lenLimit)
- {
- UInt32 pair1 = pair[1];
- *ptr1 = pair0;
- *ptr0 = pair1;
- break;
- }
- }
- }
- {
- UInt32 curMatch = pos - delta;
- // delta = pos - *pair;
- // delta = pos - pair[((UInt32)pb[len] - (UInt32)cur[len]) >> 31];
- if (pb[len] < cur[len])
- {
- delta = pos - pair[1];
- *ptr1 = curMatch;
- ptr1 = pair + 1;
- len1 = len;
- }
- else
- {
- delta = pos - *pair;
- *ptr0 = curMatch;
- ptr0 = pair;
- len0 = len;
- }
- }
- }
- if (--cutValue == 0 || delta >= _cyclicBufferSize)
- {
- *ptr0 = *ptr1 = kEmptyHashValue;
- break;
- }
- }
- pos++;
- _cyclicBufferPos++;
- cur++;
- {
- UInt32 num = (UInt32)(distances - _distances);
- _distances[-1] = num;
- }
- }
- while (distances < limit && --size != 0);
- *posRes = pos;
- return distances;
-}
-
-#endif
-
-
-
-static void BtGetMatches(CMatchFinderMt *p, UInt32 *distances)
-{
- UInt32 numProcessed = 0;
- UInt32 curPos = 2;
- UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2); // * 2
-
- distances[1] = p->hashNumAvail;
-
- while (curPos < limit)
- {
- if (p->hashBufPos == p->hashBufPosLimit)
- {
- MatchFinderMt_GetNextBlock_Hash(p);
- distances[1] = numProcessed + p->hashNumAvail;
- if (p->hashNumAvail >= p->numHashBytes)
- continue;
- distances[0] = curPos + p->hashNumAvail;
- distances += curPos;
- for (; p->hashNumAvail != 0; p->hashNumAvail--)
- *distances++ = 0;
- return;
- }
- {
- UInt32 size = p->hashBufPosLimit - p->hashBufPos;
- UInt32 lenLimit = p->matchMaxLen;
- UInt32 pos = p->pos;
- UInt32 cyclicBufferPos = p->cyclicBufferPos;
- if (lenLimit >= p->hashNumAvail)
- lenLimit = p->hashNumAvail;
- {
- UInt32 size2 = p->hashNumAvail - lenLimit + 1;
- if (size2 < size)
- size = size2;
- size2 = p->cyclicBufferSize - cyclicBufferPos;
- if (size2 < size)
- size = size2;
- }
-
- #ifndef MFMT_GM_INLINE
- while (curPos < limit && size-- != 0)
- {
- UInt32 *startDistances = distances + curPos;
- UInt32 num = (UInt32)(GetMatchesSpec1(lenLimit, pos - p->hashBuf[p->hashBufPos++],
- pos, p->buffer, p->son, cyclicBufferPos, p->cyclicBufferSize, p->cutValue,
- startDistances + 1, p->numHashBytes - 1) - startDistances);
- *startDistances = num - 1;
- curPos += num;
- cyclicBufferPos++;
- pos++;
- p->buffer++;
- }
- #else
- {
- UInt32 posRes;
- curPos = (UInt32)(GetMatchesSpecN(lenLimit, pos, p->buffer, p->son, cyclicBufferPos, p->cyclicBufferSize, p->cutValue,
- distances + curPos, p->numHashBytes - 1, p->hashBuf + p->hashBufPos,
- distances + limit,
- size, &posRes) - distances);
- p->hashBufPos += posRes - pos;
- cyclicBufferPos += posRes - pos;
- p->buffer += posRes - pos;
- pos = posRes;
- }
- #endif
-
- numProcessed += pos - p->pos;
- p->hashNumAvail -= pos - p->pos;
- p->pos = pos;
- if (cyclicBufferPos == p->cyclicBufferSize)
- cyclicBufferPos = 0;
- p->cyclicBufferPos = cyclicBufferPos;
- }
- }
-
- distances[0] = curPos;
-}
-
-static void BtFillBlock(CMatchFinderMt *p, UInt32 globalBlockIndex)
-{
- CMtSync *sync = &p->hashSync;
- if (!sync->needStart)
- {
- CriticalSection_Enter(&sync->cs);
- sync->csWasEntered = True;
- }
-
- BtGetMatches(p, p->btBuf + (globalBlockIndex & kMtBtNumBlocksMask) * kMtBtBlockSize);
-
- if (p->pos > kMtMaxValForNormalize - kMtBtBlockSize)
- {
- UInt32 subValue = p->pos - p->cyclicBufferSize;
- MatchFinder_Normalize3(subValue, p->son, (size_t)p->cyclicBufferSize * 2);
- p->pos -= subValue;
- }
-
- if (!sync->needStart)
- {
- CriticalSection_Leave(&sync->cs);
- sync->csWasEntered = False;
- }
-}
-
-void BtThreadFunc(CMatchFinderMt *mt)
-{
- CMtSync *p = &mt->btSync;
- for (;;)
- {
- UInt32 blockIndex = 0;
- Event_Wait(&p->canStart);
- Event_Set(&p->wasStarted);
- for (;;)
- {
- if (p->exit)
- return;
- if (p->stopWriting)
- {
- p->numProcessedBlocks = blockIndex;
- MtSync_StopWriting(&mt->hashSync);
- Event_Set(&p->wasStopped);
- break;
- }
- Semaphore_Wait(&p->freeSemaphore);
- BtFillBlock(mt, blockIndex++);
- Semaphore_Release1(&p->filledSemaphore);
- }
- }
-}
-
-void MatchFinderMt_Construct(CMatchFinderMt *p)
-{
- p->hashBuf = NULL;
- MtSync_Construct(&p->hashSync);
- MtSync_Construct(&p->btSync);
-}
-
-static void MatchFinderMt_FreeMem(CMatchFinderMt *p, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, p->hashBuf);
- p->hashBuf = NULL;
-}
-
-void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc)
-{
- MtSync_Destruct(&p->hashSync);
- MtSync_Destruct(&p->btSync);
- MatchFinderMt_FreeMem(p, alloc);
-}
-
-#define kHashBufferSize (kMtHashBlockSize * kMtHashNumBlocks)
-#define kBtBufferSize (kMtBtBlockSize * kMtBtNumBlocks)
-
-static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE HashThreadFunc2(void *p) { HashThreadFunc((CMatchFinderMt *)p); return 0; }
-static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE BtThreadFunc2(void *p)
-{
- Byte allocaDummy[0x180];
- unsigned i = 0;
- for (i = 0; i < 16; i++)
- allocaDummy[i] = (Byte)0;
- if (allocaDummy[0] == 0)
- BtThreadFunc((CMatchFinderMt *)p);
- return 0;
-}
-
-SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc)
-{
- CMatchFinder *mf = p->MatchFinder;
- p->historySize = historySize;
- if (kMtBtBlockSize <= matchMaxLen * 4)
- return SZ_ERROR_PARAM;
- if (!p->hashBuf)
- {
- p->hashBuf = (UInt32 *)ISzAlloc_Alloc(alloc, (kHashBufferSize + kBtBufferSize) * sizeof(UInt32));
- if (!p->hashBuf)
- return SZ_ERROR_MEM;
- p->btBuf = p->hashBuf + kHashBufferSize;
- }
- keepAddBufferBefore += (kHashBufferSize + kBtBufferSize);
- keepAddBufferAfter += kMtHashBlockSize;
- if (!MatchFinder_Create(mf, historySize, keepAddBufferBefore, matchMaxLen, keepAddBufferAfter, alloc))
- return SZ_ERROR_MEM;
-
- RINOK(MtSync_Create(&p->hashSync, HashThreadFunc2, p, kMtHashNumBlocks));
- RINOK(MtSync_Create(&p->btSync, BtThreadFunc2, p, kMtBtNumBlocks));
- return SZ_OK;
-}
-
-/* Call it after ReleaseStream / SetStream */
-static void MatchFinderMt_Init(CMatchFinderMt *p)
-{
- CMatchFinder *mf = p->MatchFinder;
-
- p->btBufPos =
- p->btBufPosLimit = 0;
- p->hashBufPos =
- p->hashBufPosLimit = 0;
-
- /* Init without data reading. We don't want to read data in this thread */
- MatchFinder_Init_3(mf, False);
- MatchFinder_Init_LowHash(mf);
-
- p->pointerToCurPos = Inline_MatchFinder_GetPointerToCurrentPos(mf);
- p->btNumAvailBytes = 0;
- p->lzPos = p->historySize + 1;
-
- p->hash = mf->hash;
- p->fixedHashSize = mf->fixedHashSize;
- p->crc = mf->crc;
-
- p->son = mf->son;
- p->matchMaxLen = mf->matchMaxLen;
- p->numHashBytes = mf->numHashBytes;
- p->pos = mf->pos;
- p->buffer = mf->buffer;
- p->cyclicBufferPos = mf->cyclicBufferPos;
- p->cyclicBufferSize = mf->cyclicBufferSize;
- p->cutValue = mf->cutValue;
-}
-
-/* ReleaseStream is required to finish multithreading */
-void MatchFinderMt_ReleaseStream(CMatchFinderMt *p)
-{
- MtSync_StopWriting(&p->btSync);
- /* p->MatchFinder->ReleaseStream(); */
-}
-
-static void MatchFinderMt_Normalize(CMatchFinderMt *p)
-{
- MatchFinder_Normalize3(p->lzPos - p->historySize - 1, p->hash, p->fixedHashSize);
- p->lzPos = p->historySize + 1;
-}
-
-static void MatchFinderMt_GetNextBlock_Bt(CMatchFinderMt *p)
-{
- UInt32 blockIndex;
- MtSync_GetNextBlock(&p->btSync);
- blockIndex = ((p->btSync.numProcessedBlocks - 1) & kMtBtNumBlocksMask);
- p->btBufPosLimit = p->btBufPos = blockIndex * kMtBtBlockSize;
- p->btBufPosLimit += p->btBuf[p->btBufPos++];
- p->btNumAvailBytes = p->btBuf[p->btBufPos++];
- if (p->lzPos >= kMtMaxValForNormalize - kMtBtBlockSize)
- MatchFinderMt_Normalize(p);
-}
-
-static const Byte * MatchFinderMt_GetPointerToCurrentPos(CMatchFinderMt *p)
-{
- return p->pointerToCurPos;
-}
-
-#define GET_NEXT_BLOCK_IF_REQUIRED if (p->btBufPos == p->btBufPosLimit) MatchFinderMt_GetNextBlock_Bt(p);
-
-static UInt32 MatchFinderMt_GetNumAvailableBytes(CMatchFinderMt *p)
-{
- GET_NEXT_BLOCK_IF_REQUIRED;
- return p->btNumAvailBytes;
-}
-
-static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distances)
-{
- UInt32 h2, curMatch2;
- UInt32 *hash = p->hash;
- const Byte *cur = p->pointerToCurPos;
- UInt32 lzPos = p->lzPos;
- MT_HASH2_CALC
-
- curMatch2 = hash[h2];
- hash[h2] = lzPos;
-
- if (curMatch2 >= matchMinPos)
- if (cur[(ptrdiff_t)curMatch2 - lzPos] == cur[0])
- {
- *distances++ = 2;
- *distances++ = lzPos - curMatch2 - 1;
- }
-
- return distances;
-}
-
-static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distances)
-{
- UInt32 h2, h3, curMatch2, curMatch3;
- UInt32 *hash = p->hash;
- const Byte *cur = p->pointerToCurPos;
- UInt32 lzPos = p->lzPos;
- MT_HASH3_CALC
-
- curMatch2 = hash[ h2];
- curMatch3 = (hash + kFix3HashSize)[h3];
-
- hash[ h2] = lzPos;
- (hash + kFix3HashSize)[h3] = lzPos;
-
- if (curMatch2 >= matchMinPos && cur[(ptrdiff_t)curMatch2 - lzPos] == cur[0])
- {
- distances[1] = lzPos - curMatch2 - 1;
- if (cur[(ptrdiff_t)curMatch2 - lzPos + 2] == cur[2])
- {
- distances[0] = 3;
- return distances + 2;
- }
- distances[0] = 2;
- distances += 2;
- }
-
- if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0])
- {
- *distances++ = 3;
- *distances++ = lzPos - curMatch3 - 1;
- }
-
- return distances;
-}
-
-/*
-static UInt32 *MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *distances)
-{
- UInt32 h2, h3, h4, curMatch2, curMatch3, curMatch4;
- UInt32 *hash = p->hash;
- const Byte *cur = p->pointerToCurPos;
- UInt32 lzPos = p->lzPos;
- MT_HASH4_CALC
-
- curMatch2 = hash[ h2];
- curMatch3 = (hash + kFix3HashSize)[h3];
- curMatch4 = (hash + kFix4HashSize)[h4];
-
- hash[ h2] = lzPos;
- (hash + kFix3HashSize)[h3] = lzPos;
- (hash + kFix4HashSize)[h4] = lzPos;
-
- if (curMatch2 >= matchMinPos && cur[(ptrdiff_t)curMatch2 - lzPos] == cur[0])
- {
- distances[1] = lzPos - curMatch2 - 1;
- if (cur[(ptrdiff_t)curMatch2 - lzPos + 2] == cur[2])
- {
- distances[0] = (cur[(ptrdiff_t)curMatch2 - lzPos + 3] == cur[3]) ? 4 : 3;
- return distances + 2;
- }
- distances[0] = 2;
- distances += 2;
- }
-
- if (curMatch3 >= matchMinPos && cur[(ptrdiff_t)curMatch3 - lzPos] == cur[0])
- {
- distances[1] = lzPos - curMatch3 - 1;
- if (cur[(ptrdiff_t)curMatch3 - lzPos + 3] == cur[3])
- {
- distances[0] = 4;
- return distances + 2;
- }
- distances[0] = 3;
- distances += 2;
- }
-
- if (curMatch4 >= matchMinPos)
- if (
- cur[(ptrdiff_t)curMatch4 - lzPos] == cur[0] &&
- cur[(ptrdiff_t)curMatch4 - lzPos + 3] == cur[3]
- )
- {
- *distances++ = 4;
- *distances++ = lzPos - curMatch4 - 1;
- }
-
- return distances;
-}
-*/
-
-#define INCREASE_LZ_POS p->lzPos++; p->pointerToCurPos++;
-
-static UInt32 MatchFinderMt2_GetMatches(CMatchFinderMt *p, UInt32 *distances)
-{
- const UInt32 *btBuf = p->btBuf + p->btBufPos;
- UInt32 len = *btBuf++;
- p->btBufPos += 1 + len;
- p->btNumAvailBytes--;
- {
- UInt32 i;
- for (i = 0; i < len; i += 2)
- {
- UInt32 v0 = btBuf[0];
- UInt32 v1 = btBuf[1];
- btBuf += 2;
- distances[0] = v0;
- distances[1] = v1;
- distances += 2;
- }
- }
- INCREASE_LZ_POS
- return len;
-}
-
-static UInt32 MatchFinderMt_GetMatches(CMatchFinderMt *p, UInt32 *distances)
-{
- const UInt32 *btBuf = p->btBuf + p->btBufPos;
- UInt32 len = *btBuf++;
- p->btBufPos += 1 + len;
-
- if (len == 0)
- {
- /* change for bt5 ! */
- if (p->btNumAvailBytes-- >= 4)
- len = (UInt32)(p->MixMatchesFunc(p, p->lzPos - p->historySize, distances) - (distances));
- }
- else
- {
- /* Condition: there are matches in btBuf with length < p->numHashBytes */
- UInt32 *distances2;
- p->btNumAvailBytes--;
- distances2 = p->MixMatchesFunc(p, p->lzPos - btBuf[1], distances);
- do
- {
- UInt32 v0 = btBuf[0];
- UInt32 v1 = btBuf[1];
- btBuf += 2;
- distances2[0] = v0;
- distances2[1] = v1;
- distances2 += 2;
- }
- while ((len -= 2) != 0);
- len = (UInt32)(distances2 - (distances));
- }
- INCREASE_LZ_POS
- return len;
-}
-
-#define SKIP_HEADER2_MT do { GET_NEXT_BLOCK_IF_REQUIRED
-#define SKIP_HEADER_MT(n) SKIP_HEADER2_MT if (p->btNumAvailBytes-- >= (n)) { const Byte *cur = p->pointerToCurPos; UInt32 *hash = p->hash;
-#define SKIP_FOOTER_MT } INCREASE_LZ_POS p->btBufPos += p->btBuf[p->btBufPos] + 1; } while (--num != 0);
-
-static void MatchFinderMt0_Skip(CMatchFinderMt *p, UInt32 num)
-{
- SKIP_HEADER2_MT { p->btNumAvailBytes--;
- SKIP_FOOTER_MT
-}
-
-static void MatchFinderMt2_Skip(CMatchFinderMt *p, UInt32 num)
-{
- SKIP_HEADER_MT(2)
- UInt32 h2;
- MT_HASH2_CALC
- hash[h2] = p->lzPos;
- SKIP_FOOTER_MT
-}
-
-static void MatchFinderMt3_Skip(CMatchFinderMt *p, UInt32 num)
-{
- SKIP_HEADER_MT(3)
- UInt32 h2, h3;
- MT_HASH3_CALC
- (hash + kFix3HashSize)[h3] =
- hash[ h2] =
- p->lzPos;
- SKIP_FOOTER_MT
-}
-
-/*
-static void MatchFinderMt4_Skip(CMatchFinderMt *p, UInt32 num)
-{
- SKIP_HEADER_MT(4)
- UInt32 h2, h3, h4;
- MT_HASH4_CALC
- (hash + kFix4HashSize)[h4] =
- (hash + kFix3HashSize)[h3] =
- hash[ h2] =
- p->lzPos;
- SKIP_FOOTER_MT
-}
-*/
-
-void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable)
-{
- vTable->Init = (Mf_Init_Func)MatchFinderMt_Init;
- vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinderMt_GetNumAvailableBytes;
- vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinderMt_GetPointerToCurrentPos;
- vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt_GetMatches;
-
- switch (p->MatchFinder->numHashBytes)
- {
- case 2:
- p->GetHeadsFunc = GetHeads2;
- p->MixMatchesFunc = (Mf_Mix_Matches)NULL;
- vTable->Skip = (Mf_Skip_Func)MatchFinderMt0_Skip;
- vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt2_GetMatches;
- break;
- case 3:
- p->GetHeadsFunc = GetHeads3;
- p->MixMatchesFunc = (Mf_Mix_Matches)MixMatches2;
- vTable->Skip = (Mf_Skip_Func)MatchFinderMt2_Skip;
- break;
- default:
- /* case 4: */
- p->GetHeadsFunc = p->MatchFinder->bigHash ? GetHeads4b : GetHeads4;
- p->MixMatchesFunc = (Mf_Mix_Matches)MixMatches3;
- vTable->Skip = (Mf_Skip_Func)MatchFinderMt3_Skip;
- break;
- /*
- default:
- p->GetHeadsFunc = GetHeads5;
- p->MixMatchesFunc = (Mf_Mix_Matches)MixMatches4;
- vTable->Skip = (Mf_Skip_Func)MatchFinderMt4_Skip;
- break;
- */
- }
-}
+/* LzFindMt.c -- multithreaded Match finder for LZ algorithms
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+// #include <stdio.h>
+
+#include "CpuArch.h"
+
+#include "LzHash.h"
+#include "LzFindMt.h"
+
+// #define LOG_ITERS
+
+// #define LOG_THREAD
+
+#ifdef LOG_THREAD
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#ifdef LOG_ITERS
+#include <stdio.h>
+extern UInt64 g_NumIters_Tree;
+extern UInt64 g_NumIters_Loop;
+extern UInt64 g_NumIters_Bytes;
+#define LOG_ITER(x) x
+#else
+#define LOG_ITER(x)
+#endif
+
+#define kMtHashBlockSize ((UInt32)1 << 17)
+#define kMtHashNumBlocks (1 << 1)
+
+#define GET_HASH_BLOCK_OFFSET(i) (((i) & (kMtHashNumBlocks - 1)) * kMtHashBlockSize)
+
+#define kMtBtBlockSize ((UInt32)1 << 16)
+#define kMtBtNumBlocks (1 << 4)
+
+#define GET_BT_BLOCK_OFFSET(i) (((i) & (kMtBtNumBlocks - 1)) * (size_t)kMtBtBlockSize)
+
+/*
+ HASH functions:
+ We use raw 8/16 bits from a[1] and a[2],
+ xored with crc(a[0]) and crc(a[3]).
+ We check a[0], a[3] only. We don't need to compare a[1] and a[2] in matches.
+ our crc() function provides one-to-one correspondence for low 8-bit values:
+ (crc[0...0xFF] & 0xFF) <-> [0...0xFF]
+*/
+
+#define MF(mt) ((mt)->MatchFinder)
+#define MF_CRC (p->crc)
+
+// #define MF(mt) (&(mt)->MatchFinder)
+// #define MF_CRC (p->MatchFinder.crc)
+
+#define MT_HASH2_CALC \
+ h2 = (MF_CRC[cur[0]] ^ cur[1]) & (kHash2Size - 1);
+
+#define MT_HASH3_CALC { \
+ UInt32 temp = MF_CRC[cur[0]] ^ cur[1]; \
+ h2 = temp & (kHash2Size - 1); \
+ h3 = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }
+
+/*
+#define MT_HASH3_CALC__NO_2 { \
+ UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
+ h3 = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }
+
+#define MT_HASH4_CALC { \
+ UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
+ h2 = temp & (kHash2Size - 1); \
+ temp ^= ((UInt32)cur[2] << 8); \
+ h3 = temp & (kHash3Size - 1); \
+ h4 = (temp ^ (p->crc[cur[3]] << kLzHash_CrcShift_1)) & p->hash4Mask; }
+ // (kHash4Size - 1);
+*/
+
+
+Z7_NO_INLINE
+static void MtSync_Construct(CMtSync *p)
+{
+ p->affinity = 0;
+ p->wasCreated = False;
+ p->csWasInitialized = False;
+ p->csWasEntered = False;
+ Thread_CONSTRUCT(&p->thread)
+ Event_Construct(&p->canStart);
+ Event_Construct(&p->wasStopped);
+ Semaphore_Construct(&p->freeSemaphore);
+ Semaphore_Construct(&p->filledSemaphore);
+}
+
+
+#define DEBUG_BUFFER_LOCK // define it to debug lock state
+
+#ifdef DEBUG_BUFFER_LOCK
+#include <stdlib.h>
+#define BUFFER_MUST_BE_LOCKED(p) if (!(p)->csWasEntered) exit(1);
+#define BUFFER_MUST_BE_UNLOCKED(p) if ( (p)->csWasEntered) exit(1);
+#else
+#define BUFFER_MUST_BE_LOCKED(p)
+#define BUFFER_MUST_BE_UNLOCKED(p)
+#endif
+
+#define LOCK_BUFFER(p) { \
+ BUFFER_MUST_BE_UNLOCKED(p); \
+ CriticalSection_Enter(&(p)->cs); \
+ (p)->csWasEntered = True; }
+
+#define UNLOCK_BUFFER(p) { \
+ BUFFER_MUST_BE_LOCKED(p); \
+ CriticalSection_Leave(&(p)->cs); \
+ (p)->csWasEntered = False; }
+
+
+Z7_NO_INLINE
+static UInt32 MtSync_GetNextBlock(CMtSync *p)
+{
+ UInt32 numBlocks = 0;
+ if (p->needStart)
+ {
+ BUFFER_MUST_BE_UNLOCKED(p)
+ p->numProcessedBlocks = 1;
+ p->needStart = False;
+ p->stopWriting = False;
+ p->exit = False;
+ Event_Reset(&p->wasStopped);
+ Event_Set(&p->canStart);
+ }
+ else
+ {
+ UNLOCK_BUFFER(p)
+ // we free current block
+ numBlocks = p->numProcessedBlocks++;
+ Semaphore_Release1(&p->freeSemaphore);
+ }
+
+ // buffer is UNLOCKED here
+ Semaphore_Wait(&p->filledSemaphore);
+ LOCK_BUFFER(p)
+ return numBlocks;
+}
+
+
+/* if Writing (Processing) thread was started, we must call MtSync_StopWriting() */
+
+Z7_NO_INLINE
+static void MtSync_StopWriting(CMtSync *p)
+{
+ if (!Thread_WasCreated(&p->thread) || p->needStart)
+ return;
+
+ PRF(printf("\nMtSync_StopWriting %p\n", p));
+
+ if (p->csWasEntered)
+ {
+ /* we don't use buffer in this thread after StopWriting().
+ So we UNLOCK buffer.
+ And we restore default UNLOCKED state for stopped thread */
+ UNLOCK_BUFFER(p)
+ }
+
+ /* We send (p->stopWriting) message and release freeSemaphore
+ to free current block.
+ So the thread will see (p->stopWriting) at some
+ iteration after Wait(freeSemaphore).
+ The thread doesn't need to fill all avail free blocks,
+ so we can get fast thread stop.
+ */
+
+ p->stopWriting = True;
+ Semaphore_Release1(&p->freeSemaphore); // check semaphore count !!!
+
+ PRF(printf("\nMtSync_StopWriting %p : Event_Wait(&p->wasStopped)\n", p));
+ Event_Wait(&p->wasStopped);
+ PRF(printf("\nMtSync_StopWriting %p : Event_Wait() finsihed\n", p));
+
+ /* 21.03 : we don't restore samaphore counters here.
+ We will recreate and reinit samaphores in next start */
+
+ p->needStart = True;
+}
+
+
+Z7_NO_INLINE
+static void MtSync_Destruct(CMtSync *p)
+{
+ PRF(printf("\nMtSync_Destruct %p\n", p));
+
+ if (Thread_WasCreated(&p->thread))
+ {
+ /* we want thread to be in Stopped state before sending EXIT command.
+ note: stop(btSync) will stop (htSync) also */
+ MtSync_StopWriting(p);
+ /* thread in Stopped state here : (p->needStart == true) */
+ p->exit = True;
+ // if (p->needStart) // it's (true)
+ Event_Set(&p->canStart); // we send EXIT command to thread
+ Thread_Wait_Close(&p->thread); // we wait thread finishing
+ }
+
+ if (p->csWasInitialized)
+ {
+ CriticalSection_Delete(&p->cs);
+ p->csWasInitialized = False;
+ }
+ p->csWasEntered = False;
+
+ Event_Close(&p->canStart);
+ Event_Close(&p->wasStopped);
+ Semaphore_Close(&p->freeSemaphore);
+ Semaphore_Close(&p->filledSemaphore);
+
+ p->wasCreated = False;
+}
+
+
+// #define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
+// we want to get real system error codes here instead of SZ_ERROR_THREAD
+#define RINOK_THREAD(x) RINOK_WRes(x)
+
+
+// call it before each new file (when new starting is required):
+Z7_NO_INLINE
+static SRes MtSync_Init(CMtSync *p, UInt32 numBlocks)
+{
+ WRes wres;
+ // BUFFER_MUST_BE_UNLOCKED(p)
+ if (!p->needStart || p->csWasEntered)
+ return SZ_ERROR_FAIL;
+ wres = Semaphore_OptCreateInit(&p->freeSemaphore, numBlocks, numBlocks);
+ if (wres == 0)
+ wres = Semaphore_OptCreateInit(&p->filledSemaphore, 0, numBlocks);
+ return MY_SRes_HRESULT_FROM_WRes(wres);
+}
+
+
+static WRes MtSync_Create_WRes(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj)
+{
+ WRes wres;
+
+ if (p->wasCreated)
+ return SZ_OK;
+
+ RINOK_THREAD(CriticalSection_Init(&p->cs))
+ p->csWasInitialized = True;
+ p->csWasEntered = False;
+
+ RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->canStart))
+ RINOK_THREAD(AutoResetEvent_CreateNotSignaled(&p->wasStopped))
+
+ p->needStart = True;
+ p->exit = True; /* p->exit is unused before (canStart) Event.
+ But in case of some unexpected code failure we will get fast exit from thread */
+
+ // return ERROR_TOO_MANY_POSTS; // for debug
+ // return EINVAL; // for debug
+
+ if (p->affinity != 0)
+ wres = Thread_Create_With_Affinity(&p->thread, startAddress, obj, (CAffinityMask)p->affinity);
+ else
+ wres = Thread_Create(&p->thread, startAddress, obj);
+
+ RINOK_THREAD(wres)
+ p->wasCreated = True;
+ return SZ_OK;
+}
+
+
+Z7_NO_INLINE
+static SRes MtSync_Create(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj)
+{
+ const WRes wres = MtSync_Create_WRes(p, startAddress, obj);
+ if (wres == 0)
+ return 0;
+ MtSync_Destruct(p);
+ return MY_SRes_HRESULT_FROM_WRes(wres);
+}
+
+
+// ---------- HASH THREAD ----------
+
+#define kMtMaxValForNormalize 0xFFFFFFFF
+// #define kMtMaxValForNormalize ((1 << 21)) // for debug
+// #define kNormalizeAlign (1 << 7) // alignment for speculated accesses
+
+#ifdef MY_CPU_LE_UNALIGN
+ #define GetUi24hi_from32(p) ((UInt32)GetUi32(p) >> 8)
+#else
+ #define GetUi24hi_from32(p) ((p)[1] ^ ((UInt32)(p)[2] << 8) ^ ((UInt32)(p)[3] << 16))
+#endif
+
+#define GetHeads_DECL(name) \
+ static void GetHeads ## name(const Byte *p, UInt32 pos, \
+ UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc)
+
+#define GetHeads_LOOP(v) \
+ for (; numHeads != 0; numHeads--) { \
+ const UInt32 value = (v); \
+ p++; \
+ *heads++ = pos - hash[value]; \
+ hash[value] = pos++; }
+
+#define DEF_GetHeads2(name, v, action) \
+ GetHeads_DECL(name) { action \
+ GetHeads_LOOP(v) }
+
+#define DEF_GetHeads(name, v) DEF_GetHeads2(name, v, ;)
+
+DEF_GetHeads2(2, GetUi16(p), UNUSED_VAR(hashMask); UNUSED_VAR(crc); )
+DEF_GetHeads(3, (crc[p[0]] ^ GetUi16(p + 1)) & hashMask)
+DEF_GetHeads2(3b, GetUi16(p) ^ ((UInt32)(p)[2] << 16), UNUSED_VAR(hashMask); UNUSED_VAR(crc); )
+// BT3 is not good for crc collisions for big hashMask values.
+
+/*
+GetHeads_DECL(3b)
+{
+ UNUSED_VAR(hashMask);
+ UNUSED_VAR(crc);
+ {
+ const Byte *pLim = p + numHeads;
+ if (numHeads == 0)
+ return;
+ pLim--;
+ while (p < pLim)
+ {
+ UInt32 v1 = GetUi32(p);
+ UInt32 v0 = v1 & 0xFFFFFF;
+ UInt32 h0, h1;
+ p += 2;
+ v1 >>= 8;
+ h0 = hash[v0]; hash[v0] = pos; heads[0] = pos - h0; pos++;
+ h1 = hash[v1]; hash[v1] = pos; heads[1] = pos - h1; pos++;
+ heads += 2;
+ }
+ if (p == pLim)
+ {
+ UInt32 v0 = GetUi16(p) ^ ((UInt32)(p)[2] << 16);
+ *heads = pos - hash[v0];
+ hash[v0] = pos;
+ }
+ }
+}
+*/
+
+/*
+GetHeads_DECL(4)
+{
+ unsigned sh = 0;
+ UNUSED_VAR(crc)
+ while ((hashMask & 0x80000000) == 0)
+ {
+ hashMask <<= 1;
+ sh++;
+ }
+ GetHeads_LOOP((GetUi32(p) * 0xa54a1) >> sh)
+}
+#define GetHeads4b GetHeads4
+*/
+
+#define USE_GetHeads_LOCAL_CRC
+
+#ifdef USE_GetHeads_LOCAL_CRC
+
+GetHeads_DECL(4)
+{
+ UInt32 crc0[256];
+ UInt32 crc1[256];
+ {
+ unsigned i;
+ for (i = 0; i < 256; i++)
+ {
+ UInt32 v = crc[i];
+ crc0[i] = v & hashMask;
+ crc1[i] = (v << kLzHash_CrcShift_1) & hashMask;
+ // crc1[i] = rotlFixed(v, 8) & hashMask;
+ }
+ }
+ GetHeads_LOOP(crc0[p[0]] ^ crc1[p[3]] ^ (UInt32)GetUi16(p+1))
+}
+
+GetHeads_DECL(4b)
+{
+ UInt32 crc0[256];
+ {
+ unsigned i;
+ for (i = 0; i < 256; i++)
+ crc0[i] = crc[i] & hashMask;
+ }
+ GetHeads_LOOP(crc0[p[0]] ^ GetUi24hi_from32(p))
+}
+
+GetHeads_DECL(5)
+{
+ UInt32 crc0[256];
+ UInt32 crc1[256];
+ UInt32 crc2[256];
+ {
+ unsigned i;
+ for (i = 0; i < 256; i++)
+ {
+ UInt32 v = crc[i];
+ crc0[i] = v & hashMask;
+ crc1[i] = (v << kLzHash_CrcShift_1) & hashMask;
+ crc2[i] = (v << kLzHash_CrcShift_2) & hashMask;
+ }
+ }
+ GetHeads_LOOP(crc0[p[0]] ^ crc1[p[3]] ^ crc2[p[4]] ^ (UInt32)GetUi16(p+1))
+}
+
+GetHeads_DECL(5b)
+{
+ UInt32 crc0[256];
+ UInt32 crc1[256];
+ {
+ unsigned i;
+ for (i = 0; i < 256; i++)
+ {
+ UInt32 v = crc[i];
+ crc0[i] = v & hashMask;
+ crc1[i] = (v << kLzHash_CrcShift_1) & hashMask;
+ }
+ }
+ GetHeads_LOOP(crc0[p[0]] ^ crc1[p[4]] ^ GetUi24hi_from32(p))
+}
+
+#else
+
+DEF_GetHeads(4, (crc[p[0]] ^ (crc[p[3]] << kLzHash_CrcShift_1) ^ (UInt32)GetUi16(p+1)) & hashMask)
+DEF_GetHeads(4b, (crc[p[0]] ^ GetUi24hi_from32(p)) & hashMask)
+DEF_GetHeads(5, (crc[p[0]] ^ (crc[p[3]] << kLzHash_CrcShift_1) ^ (crc[p[4]] << kLzHash_CrcShift_2) ^ (UInt32)GetUi16(p + 1)) & hashMask)
+DEF_GetHeads(5b, (crc[p[0]] ^ (crc[p[4]] << kLzHash_CrcShift_1) ^ GetUi24hi_from32(p)) & hashMask)
+
+#endif
+
+
+static void HashThreadFunc(CMatchFinderMt *mt)
+{
+ CMtSync *p = &mt->hashSync;
+ PRF(printf("\nHashThreadFunc\n"));
+
+ for (;;)
+ {
+ UInt32 blockIndex = 0;
+ PRF(printf("\nHashThreadFunc : Event_Wait(&p->canStart)\n"));
+ Event_Wait(&p->canStart);
+ PRF(printf("\nHashThreadFunc : Event_Wait(&p->canStart) : after \n"));
+ if (p->exit)
+ {
+ PRF(printf("\nHashThreadFunc : exit \n"));
+ return;
+ }
+
+ MatchFinder_Init_HighHash(MF(mt));
+
+ for (;;)
+ {
+ PRF(printf("Hash thread block = %d pos = %d\n", (unsigned)blockIndex, mt->MatchFinder->pos));
+
+ {
+ CMatchFinder *mf = MF(mt);
+ if (MatchFinder_NeedMove(mf))
+ {
+ CriticalSection_Enter(&mt->btSync.cs);
+ CriticalSection_Enter(&mt->hashSync.cs);
+ {
+ const Byte *beforePtr = Inline_MatchFinder_GetPointerToCurrentPos(mf);
+ ptrdiff_t offset;
+ MatchFinder_MoveBlock(mf);
+ offset = beforePtr - Inline_MatchFinder_GetPointerToCurrentPos(mf);
+ mt->pointerToCurPos -= offset;
+ mt->buffer -= offset;
+ }
+ CriticalSection_Leave(&mt->hashSync.cs);
+ CriticalSection_Leave(&mt->btSync.cs);
+ continue;
+ }
+
+ Semaphore_Wait(&p->freeSemaphore);
+
+ if (p->exit) // exit is unexpected here. But we check it here for some failure case
+ return;
+
+ // for faster stop : we check (p->stopWriting) after Wait(freeSemaphore)
+ if (p->stopWriting)
+ break;
+
+ MatchFinder_ReadIfRequired(mf);
+ {
+ UInt32 *heads = mt->hashBuf + GET_HASH_BLOCK_OFFSET(blockIndex++);
+ UInt32 num = Inline_MatchFinder_GetNumAvailableBytes(mf);
+ heads[0] = 2;
+ heads[1] = num;
+
+ /* heads[1] contains the number of avail bytes:
+ if (avail < mf->numHashBytes) :
+ {
+ it means that stream was finished
+ HASH_THREAD and BT_TREAD must move position for heads[1] (avail) bytes.
+ HASH_THREAD doesn't stop,
+ HASH_THREAD fills only the header (2 numbers) for all next blocks:
+ {2, NumHashBytes - 1}, {2,0}, {2,0}, ... , {2,0}
+ }
+ else
+ {
+ HASH_THREAD and BT_TREAD must move position for (heads[0] - 2) bytes;
+ }
+ */
+
+ if (num >= mf->numHashBytes)
+ {
+ num = num - mf->numHashBytes + 1;
+ if (num > kMtHashBlockSize - 2)
+ num = kMtHashBlockSize - 2;
+
+ if (mf->pos > (UInt32)kMtMaxValForNormalize - num)
+ {
+ const UInt32 subValue = (mf->pos - mf->historySize - 1); // & ~(UInt32)(kNormalizeAlign - 1);
+ MatchFinder_REDUCE_OFFSETS(mf, subValue)
+ MatchFinder_Normalize3(subValue, mf->hash + mf->fixedHashSize, (size_t)mf->hashMask + 1);
+ }
+
+ heads[0] = 2 + num;
+ mt->GetHeadsFunc(mf->buffer, mf->pos, mf->hash + mf->fixedHashSize, mf->hashMask, heads + 2, num, mf->crc);
+ }
+
+ mf->pos += num; // wrap over zero is allowed at the end of stream
+ mf->buffer += num;
+ }
+ }
+
+ Semaphore_Release1(&p->filledSemaphore);
+ } // for() processing end
+
+ // p->numBlocks_Sent = blockIndex;
+ Event_Set(&p->wasStopped);
+ } // for() thread end
+}
+
+
+
+
+// ---------- BT THREAD ----------
+
+/* we use one variable instead of two (cyclicBufferPos == pos) before CyclicBuf wrap.
+ here we define fixed offset of (p->pos) from (p->cyclicBufferPos) */
+#define CYC_TO_POS_OFFSET 0
+// #define CYC_TO_POS_OFFSET 1 // for debug
+
+#define MFMT_GM_INLINE
+
+#ifdef MFMT_GM_INLINE
+
+/*
+ we use size_t for (pos) instead of UInt32
+ to eliminate "movsx" BUG in old MSVC x64 compiler.
+*/
+
+
+UInt32 * Z7_FASTCALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
+ UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
+ UInt32 *posRes);
+
+#endif
+
+
+static void BtGetMatches(CMatchFinderMt *p, UInt32 *d)
+{
+ UInt32 numProcessed = 0;
+ UInt32 curPos = 2;
+
+ /* GetMatchesSpec() functions don't create (len = 1)
+ in [len, dist] match pairs, if (p->numHashBytes >= 2)
+ Also we suppose here that (matchMaxLen >= 2).
+ So the following code for (reserve) is not required
+ UInt32 reserve = (p->matchMaxLen * 2);
+ const UInt32 kNumHashBytes_Max = 5; // BT_HASH_BYTES_MAX
+ if (reserve < kNumHashBytes_Max - 1)
+ reserve = kNumHashBytes_Max - 1;
+ const UInt32 limit = kMtBtBlockSize - (reserve);
+ */
+
+ const UInt32 limit = kMtBtBlockSize - (p->matchMaxLen * 2);
+
+ d[1] = p->hashNumAvail;
+
+ if (p->failure_BT)
+ {
+ // printf("\n == 1 BtGetMatches() p->failure_BT\n");
+ d[0] = 0;
+ // d[1] = 0;
+ return;
+ }
+
+ while (curPos < limit)
+ {
+ if (p->hashBufPos == p->hashBufPosLimit)
+ {
+ // MatchFinderMt_GetNextBlock_Hash(p);
+ UInt32 avail;
+ {
+ const UInt32 bi = MtSync_GetNextBlock(&p->hashSync);
+ const UInt32 k = GET_HASH_BLOCK_OFFSET(bi);
+ const UInt32 *h = p->hashBuf + k;
+ avail = h[1];
+ p->hashBufPosLimit = k + h[0];
+ p->hashNumAvail = avail;
+ p->hashBufPos = k + 2;
+ }
+
+ {
+ /* we must prevent UInt32 overflow for avail total value,
+ if avail was increased with new hash block */
+ UInt32 availSum = numProcessed + avail;
+ if (availSum < numProcessed)
+ availSum = (UInt32)(Int32)-1;
+ d[1] = availSum;
+ }
+
+ if (avail >= p->numHashBytes)
+ continue;
+
+ // if (p->hashBufPos != p->hashBufPosLimit) exit(1);
+
+ /* (avail < p->numHashBytes)
+ It means that stream was finished.
+ And (avail) - is a number of remaining bytes,
+ we fill (d) for (avail) bytes for LZ_THREAD (receiver).
+ but we don't update (p->pos) and (p->cyclicBufferPos) here in BT_THREAD */
+
+ /* here we suppose that we have space enough:
+ (kMtBtBlockSize - curPos >= p->hashNumAvail) */
+ p->hashNumAvail = 0;
+ d[0] = curPos + avail;
+ d += curPos;
+ for (; avail != 0; avail--)
+ *d++ = 0;
+ return;
+ }
+ {
+ UInt32 size = p->hashBufPosLimit - p->hashBufPos;
+ UInt32 pos = p->pos;
+ UInt32 cyclicBufferPos = p->cyclicBufferPos;
+ UInt32 lenLimit = p->matchMaxLen;
+ if (lenLimit >= p->hashNumAvail)
+ lenLimit = p->hashNumAvail;
+ {
+ UInt32 size2 = p->hashNumAvail - lenLimit + 1;
+ if (size2 < size)
+ size = size2;
+ size2 = p->cyclicBufferSize - cyclicBufferPos;
+ if (size2 < size)
+ size = size2;
+ }
+
+ if (pos > (UInt32)kMtMaxValForNormalize - size)
+ {
+ const UInt32 subValue = (pos - p->cyclicBufferSize); // & ~(UInt32)(kNormalizeAlign - 1);
+ pos -= subValue;
+ p->pos = pos;
+ MatchFinder_Normalize3(subValue, p->son, (size_t)p->cyclicBufferSize * 2);
+ }
+
+ #ifndef MFMT_GM_INLINE
+ while (curPos < limit && size-- != 0)
+ {
+ UInt32 *startDistances = d + curPos;
+ UInt32 num = (UInt32)(GetMatchesSpec1(lenLimit, pos - p->hashBuf[p->hashBufPos++],
+ pos, p->buffer, p->son, cyclicBufferPos, p->cyclicBufferSize, p->cutValue,
+ startDistances + 1, p->numHashBytes - 1) - startDistances);
+ *startDistances = num - 1;
+ curPos += num;
+ cyclicBufferPos++;
+ pos++;
+ p->buffer++;
+ }
+ #else
+ {
+ UInt32 posRes = pos;
+ const UInt32 *d_end;
+ {
+ d_end = GetMatchesSpecN_2(
+ p->buffer + lenLimit - 1,
+ pos, p->buffer, p->son, p->cutValue, d + curPos,
+ p->numHashBytes - 1, p->hashBuf + p->hashBufPos,
+ d + limit, p->hashBuf + p->hashBufPos + size,
+ cyclicBufferPos, p->cyclicBufferSize,
+ &posRes);
+ }
+ {
+ if (!d_end)
+ {
+ // printf("\n == 2 BtGetMatches() p->failure_BT\n");
+ // internal data failure
+ p->failure_BT = True;
+ d[0] = 0;
+ // d[1] = 0;
+ return;
+ }
+ }
+ curPos = (UInt32)(d_end - d);
+ {
+ const UInt32 processed = posRes - pos;
+ pos = posRes;
+ p->hashBufPos += processed;
+ cyclicBufferPos += processed;
+ p->buffer += processed;
+ }
+ }
+ #endif
+
+ {
+ const UInt32 processed = pos - p->pos;
+ numProcessed += processed;
+ p->hashNumAvail -= processed;
+ p->pos = pos;
+ }
+ if (cyclicBufferPos == p->cyclicBufferSize)
+ cyclicBufferPos = 0;
+ p->cyclicBufferPos = cyclicBufferPos;
+ }
+ }
+
+ d[0] = curPos;
+}
+
+
+static void BtFillBlock(CMatchFinderMt *p, UInt32 globalBlockIndex)
+{
+ CMtSync *sync = &p->hashSync;
+
+ BUFFER_MUST_BE_UNLOCKED(sync)
+
+ if (!sync->needStart)
+ {
+ LOCK_BUFFER(sync)
+ }
+
+ BtGetMatches(p, p->btBuf + GET_BT_BLOCK_OFFSET(globalBlockIndex));
+
+ /* We suppose that we have called GetNextBlock() from start.
+ So buffer is LOCKED */
+
+ UNLOCK_BUFFER(sync)
+}
+
+
+Z7_NO_INLINE
+static void BtThreadFunc(CMatchFinderMt *mt)
+{
+ CMtSync *p = &mt->btSync;
+ for (;;)
+ {
+ UInt32 blockIndex = 0;
+ Event_Wait(&p->canStart);
+
+ for (;;)
+ {
+ PRF(printf(" BT thread block = %d pos = %d\n", (unsigned)blockIndex, mt->pos));
+ /* (p->exit == true) is possible after (p->canStart) at first loop iteration
+ and is unexpected after more Wait(freeSemaphore) iterations */
+ if (p->exit)
+ return;
+
+ Semaphore_Wait(&p->freeSemaphore);
+
+ // for faster stop : we check (p->stopWriting) after Wait(freeSemaphore)
+ if (p->stopWriting)
+ break;
+
+ BtFillBlock(mt, blockIndex++);
+
+ Semaphore_Release1(&p->filledSemaphore);
+ }
+
+ // we stop HASH_THREAD here
+ MtSync_StopWriting(&mt->hashSync);
+
+ // p->numBlocks_Sent = blockIndex;
+ Event_Set(&p->wasStopped);
+ }
+}
+
+
+void MatchFinderMt_Construct(CMatchFinderMt *p)
+{
+ p->hashBuf = NULL;
+ MtSync_Construct(&p->hashSync);
+ MtSync_Construct(&p->btSync);
+}
+
+static void MatchFinderMt_FreeMem(CMatchFinderMt *p, ISzAllocPtr alloc)
+{
+ ISzAlloc_Free(alloc, p->hashBuf);
+ p->hashBuf = NULL;
+}
+
+void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc)
+{
+ /*
+ HASH_THREAD can use CriticalSection(s) btSync.cs and hashSync.cs.
+ So we must be sure that HASH_THREAD will not use CriticalSection(s)
+ after deleting CriticalSection here.
+
+ we call ReleaseStream(p)
+ that calls StopWriting(btSync)
+ that calls StopWriting(hashSync), if it's required to stop HASH_THREAD.
+ after StopWriting() it's safe to destruct MtSync(s) in any order */
+
+ MatchFinderMt_ReleaseStream(p);
+
+ MtSync_Destruct(&p->btSync);
+ MtSync_Destruct(&p->hashSync);
+
+ LOG_ITER(
+ printf("\nTree %9d * %7d iter = %9d = sum : bytes = %9d\n",
+ (UInt32)(g_NumIters_Tree / 1000),
+ (UInt32)(((UInt64)g_NumIters_Loop * 1000) / (g_NumIters_Tree + 1)),
+ (UInt32)(g_NumIters_Loop / 1000),
+ (UInt32)(g_NumIters_Bytes / 1000)
+ ));
+
+ MatchFinderMt_FreeMem(p, alloc);
+}
+
+
+#define kHashBufferSize (kMtHashBlockSize * kMtHashNumBlocks)
+#define kBtBufferSize (kMtBtBlockSize * kMtBtNumBlocks)
+
+
+static THREAD_FUNC_DECL HashThreadFunc2(void *p) { HashThreadFunc((CMatchFinderMt *)p); return 0; }
+static THREAD_FUNC_DECL BtThreadFunc2(void *p)
+{
+ Byte allocaDummy[0x180];
+ unsigned i = 0;
+ for (i = 0; i < 16; i++)
+ allocaDummy[i] = (Byte)0;
+ if (allocaDummy[0] == 0)
+ BtThreadFunc((CMatchFinderMt *)p);
+ return 0;
+}
+
+
+SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
+ UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc)
+{
+ CMatchFinder *mf = MF(p);
+ p->historySize = historySize;
+ if (kMtBtBlockSize <= matchMaxLen * 4)
+ return SZ_ERROR_PARAM;
+ if (!p->hashBuf)
+ {
+ p->hashBuf = (UInt32 *)ISzAlloc_Alloc(alloc, ((size_t)kHashBufferSize + (size_t)kBtBufferSize) * sizeof(UInt32));
+ if (!p->hashBuf)
+ return SZ_ERROR_MEM;
+ p->btBuf = p->hashBuf + kHashBufferSize;
+ }
+ keepAddBufferBefore += (kHashBufferSize + kBtBufferSize);
+ keepAddBufferAfter += kMtHashBlockSize;
+ if (!MatchFinder_Create(mf, historySize, keepAddBufferBefore, matchMaxLen, keepAddBufferAfter, alloc))
+ return SZ_ERROR_MEM;
+
+ RINOK(MtSync_Create(&p->hashSync, HashThreadFunc2, p))
+ RINOK(MtSync_Create(&p->btSync, BtThreadFunc2, p))
+ return SZ_OK;
+}
+
+
+SRes MatchFinderMt_InitMt(CMatchFinderMt *p)
+{
+ RINOK(MtSync_Init(&p->hashSync, kMtHashNumBlocks))
+ return MtSync_Init(&p->btSync, kMtBtNumBlocks);
+}
+
+
+static void MatchFinderMt_Init(CMatchFinderMt *p)
+{
+ CMatchFinder *mf = MF(p);
+
+ p->btBufPos =
+ p->btBufPosLimit = NULL;
+ p->hashBufPos =
+ p->hashBufPosLimit = 0;
+ p->hashNumAvail = 0; // 21.03
+
+ p->failure_BT = False;
+
+ /* Init without data reading. We don't want to read data in this thread */
+ MatchFinder_Init_4(mf);
+
+ MatchFinder_Init_LowHash(mf);
+
+ p->pointerToCurPos = Inline_MatchFinder_GetPointerToCurrentPos(mf);
+ p->btNumAvailBytes = 0;
+ p->failure_LZ_BT = False;
+ // p->failure_LZ_LZ = False;
+
+ p->lzPos =
+ 1; // optimal smallest value
+ // 0; // for debug: ignores match to start
+ // kNormalizeAlign; // for debug
+
+ p->hash = mf->hash;
+ p->fixedHashSize = mf->fixedHashSize;
+ // p->hash4Mask = mf->hash4Mask;
+ p->crc = mf->crc;
+ // memcpy(p->crc, mf->crc, sizeof(mf->crc));
+
+ p->son = mf->son;
+ p->matchMaxLen = mf->matchMaxLen;
+ p->numHashBytes = mf->numHashBytes;
+
+ /* (mf->pos) and (mf->streamPos) were already initialized to 1 in MatchFinder_Init_4() */
+ // mf->streamPos = mf->pos = 1; // optimal smallest value
+ // 0; // for debug: ignores match to start
+ // kNormalizeAlign; // for debug
+
+ /* we must init (p->pos = mf->pos) for BT, because
+ BT code needs (p->pos == delta_value_for_empty_hash_record == mf->pos) */
+ p->pos = mf->pos; // do not change it
+
+ p->cyclicBufferPos = (p->pos - CYC_TO_POS_OFFSET);
+ p->cyclicBufferSize = mf->cyclicBufferSize;
+ p->buffer = mf->buffer;
+ p->cutValue = mf->cutValue;
+ // p->son[0] = p->son[1] = 0; // unused: to init skipped record for speculated accesses.
+}
+
+
+/* ReleaseStream is required to finish multithreading */
+void MatchFinderMt_ReleaseStream(CMatchFinderMt *p)
+{
+ // Sleep(1); // for debug
+ MtSync_StopWriting(&p->btSync);
+ // Sleep(200); // for debug
+ /* p->MatchFinder->ReleaseStream(); */
+}
+
+
+Z7_NO_INLINE
+static UInt32 MatchFinderMt_GetNextBlock_Bt(CMatchFinderMt *p)
+{
+ if (p->failure_LZ_BT)
+ p->btBufPos = p->failureBuf;
+ else
+ {
+ const UInt32 bi = MtSync_GetNextBlock(&p->btSync);
+ const UInt32 *bt = p->btBuf + GET_BT_BLOCK_OFFSET(bi);
+ {
+ const UInt32 numItems = bt[0];
+ p->btBufPosLimit = bt + numItems;
+ p->btNumAvailBytes = bt[1];
+ p->btBufPos = bt + 2;
+ if (numItems < 2 || numItems > kMtBtBlockSize)
+ {
+ p->failureBuf[0] = 0;
+ p->btBufPos = p->failureBuf;
+ p->btBufPosLimit = p->failureBuf + 1;
+ p->failure_LZ_BT = True;
+ // p->btNumAvailBytes = 0;
+ /* we don't want to decrease AvailBytes, that was load before.
+ that can be unxepected for the code that have loaded anopther value before */
+ }
+ }
+
+ if (p->lzPos >= (UInt32)kMtMaxValForNormalize - (UInt32)kMtBtBlockSize)
+ {
+ /* we don't check (lzPos) over exact avail bytes in (btBuf).
+ (fixedHashSize) is small, so normalization is fast */
+ const UInt32 subValue = (p->lzPos - p->historySize - 1); // & ~(UInt32)(kNormalizeAlign - 1);
+ p->lzPos -= subValue;
+ MatchFinder_Normalize3(subValue, p->hash, p->fixedHashSize);
+ }
+ }
+ return p->btNumAvailBytes;
+}
+
+
+
+static const Byte * MatchFinderMt_GetPointerToCurrentPos(CMatchFinderMt *p)
+{
+ return p->pointerToCurPos;
+}
+
+
+#define GET_NEXT_BLOCK_IF_REQUIRED if (p->btBufPos == p->btBufPosLimit) MatchFinderMt_GetNextBlock_Bt(p);
+
+
+static UInt32 MatchFinderMt_GetNumAvailableBytes(CMatchFinderMt *p)
+{
+ if (p->btBufPos != p->btBufPosLimit)
+ return p->btNumAvailBytes;
+ return MatchFinderMt_GetNextBlock_Bt(p);
+}
+
+
+// #define CHECK_FAILURE_LZ(_match_, _pos_) if (_match_ >= _pos_) { p->failure_LZ_LZ = True; return d; }
+#define CHECK_FAILURE_LZ(_match_, _pos_)
+
+static UInt32 * MixMatches2(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *d)
+{
+ UInt32 h2, c2;
+ UInt32 *hash = p->hash;
+ const Byte *cur = p->pointerToCurPos;
+ const UInt32 m = p->lzPos;
+ MT_HASH2_CALC
+
+ c2 = hash[h2];
+ hash[h2] = m;
+
+ if (c2 >= matchMinPos)
+ {
+ CHECK_FAILURE_LZ(c2, m)
+ if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m] == cur[0])
+ {
+ *d++ = 2;
+ *d++ = m - c2 - 1;
+ }
+ }
+
+ return d;
+}
+
+static UInt32 * MixMatches3(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *d)
+{
+ UInt32 h2, h3, c2, c3;
+ UInt32 *hash = p->hash;
+ const Byte *cur = p->pointerToCurPos;
+ const UInt32 m = p->lzPos;
+ MT_HASH3_CALC
+
+ c2 = hash[h2];
+ c3 = (hash + kFix3HashSize)[h3];
+
+ hash[h2] = m;
+ (hash + kFix3HashSize)[h3] = m;
+
+ if (c2 >= matchMinPos)
+ {
+ CHECK_FAILURE_LZ(c2, m)
+ if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m] == cur[0])
+ {
+ d[1] = m - c2 - 1;
+ if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m + 2] == cur[2])
+ {
+ d[0] = 3;
+ return d + 2;
+ }
+ d[0] = 2;
+ d += 2;
+ }
+ }
+
+ if (c3 >= matchMinPos)
+ {
+ CHECK_FAILURE_LZ(c3, m)
+ if (cur[(ptrdiff_t)c3 - (ptrdiff_t)m] == cur[0])
+ {
+ *d++ = 3;
+ *d++ = m - c3 - 1;
+ }
+ }
+
+ return d;
+}
+
+
+#define INCREASE_LZ_POS p->lzPos++; p->pointerToCurPos++;
+
+/*
+static
+UInt32* MatchFinderMt_GetMatches_Bt4(CMatchFinderMt *p, UInt32 *d)
+{
+ const UInt32 *bt = p->btBufPos;
+ const UInt32 len = *bt++;
+ const UInt32 *btLim = bt + len;
+ UInt32 matchMinPos;
+ UInt32 avail = p->btNumAvailBytes - 1;
+ p->btBufPos = btLim;
+
+ {
+ p->btNumAvailBytes = avail;
+
+ #define BT_HASH_BYTES_MAX 5
+
+ matchMinPos = p->lzPos;
+
+ if (len != 0)
+ matchMinPos -= bt[1];
+ else if (avail < (BT_HASH_BYTES_MAX - 1) - 1)
+ {
+ INCREASE_LZ_POS
+ return d;
+ }
+ else
+ {
+ const UInt32 hs = p->historySize;
+ if (matchMinPos > hs)
+ matchMinPos -= hs;
+ else
+ matchMinPos = 1;
+ }
+ }
+
+ for (;;)
+ {
+
+ UInt32 h2, h3, c2, c3;
+ UInt32 *hash = p->hash;
+ const Byte *cur = p->pointerToCurPos;
+ UInt32 m = p->lzPos;
+ MT_HASH3_CALC
+
+ c2 = hash[h2];
+ c3 = (hash + kFix3HashSize)[h3];
+
+ hash[h2] = m;
+ (hash + kFix3HashSize)[h3] = m;
+
+ if (c2 >= matchMinPos && cur[(ptrdiff_t)c2 - (ptrdiff_t)m] == cur[0])
+ {
+ d[1] = m - c2 - 1;
+ if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m + 2] == cur[2])
+ {
+ d[0] = 3;
+ d += 2;
+ break;
+ }
+ // else
+ {
+ d[0] = 2;
+ d += 2;
+ }
+ }
+ if (c3 >= matchMinPos && cur[(ptrdiff_t)c3 - (ptrdiff_t)m] == cur[0])
+ {
+ *d++ = 3;
+ *d++ = m - c3 - 1;
+ }
+ break;
+ }
+
+ if (len != 0)
+ {
+ do
+ {
+ const UInt32 v0 = bt[0];
+ const UInt32 v1 = bt[1];
+ bt += 2;
+ d[0] = v0;
+ d[1] = v1;
+ d += 2;
+ }
+ while (bt != btLim);
+ }
+ INCREASE_LZ_POS
+ return d;
+}
+*/
+
+
+static UInt32 * MixMatches4(CMatchFinderMt *p, UInt32 matchMinPos, UInt32 *d)
+{
+ UInt32 h2, h3, /* h4, */ c2, c3 /* , c4 */;
+ UInt32 *hash = p->hash;
+ const Byte *cur = p->pointerToCurPos;
+ const UInt32 m = p->lzPos;
+ MT_HASH3_CALC
+ // MT_HASH4_CALC
+ c2 = hash[h2];
+ c3 = (hash + kFix3HashSize)[h3];
+ // c4 = (hash + kFix4HashSize)[h4];
+
+ hash[h2] = m;
+ (hash + kFix3HashSize)[h3] = m;
+ // (hash + kFix4HashSize)[h4] = m;
+
+ // #define BT5_USE_H2
+ // #ifdef BT5_USE_H2
+ if (c2 >= matchMinPos && cur[(ptrdiff_t)c2 - (ptrdiff_t)m] == cur[0])
+ {
+ d[1] = m - c2 - 1;
+ if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m + 2] == cur[2])
+ {
+ // d[0] = (cur[(ptrdiff_t)c2 - (ptrdiff_t)m + 3] == cur[3]) ? 4 : 3;
+ // return d + 2;
+
+ if (cur[(ptrdiff_t)c2 - (ptrdiff_t)m + 3] == cur[3])
+ {
+ d[0] = 4;
+ return d + 2;
+ }
+ d[0] = 3;
+ d += 2;
+
+ #ifdef BT5_USE_H4
+ if (c4 >= matchMinPos)
+ if (
+ cur[(ptrdiff_t)c4 - (ptrdiff_t)m] == cur[0] &&
+ cur[(ptrdiff_t)c4 - (ptrdiff_t)m + 3] == cur[3]
+ )
+ {
+ *d++ = 4;
+ *d++ = m - c4 - 1;
+ }
+ #endif
+ return d;
+ }
+ d[0] = 2;
+ d += 2;
+ }
+ // #endif
+
+ if (c3 >= matchMinPos && cur[(ptrdiff_t)c3 - (ptrdiff_t)m] == cur[0])
+ {
+ d[1] = m - c3 - 1;
+ if (cur[(ptrdiff_t)c3 - (ptrdiff_t)m + 3] == cur[3])
+ {
+ d[0] = 4;
+ return d + 2;
+ }
+ d[0] = 3;
+ d += 2;
+ }
+
+ #ifdef BT5_USE_H4
+ if (c4 >= matchMinPos)
+ if (
+ cur[(ptrdiff_t)c4 - (ptrdiff_t)m] == cur[0] &&
+ cur[(ptrdiff_t)c4 - (ptrdiff_t)m + 3] == cur[3]
+ )
+ {
+ *d++ = 4;
+ *d++ = m - c4 - 1;
+ }
+ #endif
+
+ return d;
+}
+
+
+static UInt32 * MatchFinderMt2_GetMatches(CMatchFinderMt *p, UInt32 *d)
+{
+ const UInt32 *bt = p->btBufPos;
+ const UInt32 len = *bt++;
+ const UInt32 *btLim = bt + len;
+ p->btBufPos = btLim;
+ p->btNumAvailBytes--;
+ INCREASE_LZ_POS
+ {
+ while (bt != btLim)
+ {
+ const UInt32 v0 = bt[0];
+ const UInt32 v1 = bt[1];
+ bt += 2;
+ d[0] = v0;
+ d[1] = v1;
+ d += 2;
+ }
+ }
+ return d;
+}
+
+
+
+static UInt32 * MatchFinderMt_GetMatches(CMatchFinderMt *p, UInt32 *d)
+{
+ const UInt32 *bt = p->btBufPos;
+ UInt32 len = *bt++;
+ const UInt32 avail = p->btNumAvailBytes - 1;
+ p->btNumAvailBytes = avail;
+ p->btBufPos = bt + len;
+ if (len == 0)
+ {
+ #define BT_HASH_BYTES_MAX 5
+ if (avail >= (BT_HASH_BYTES_MAX - 1) - 1)
+ {
+ UInt32 m = p->lzPos;
+ if (m > p->historySize)
+ m -= p->historySize;
+ else
+ m = 1;
+ d = p->MixMatchesFunc(p, m, d);
+ }
+ }
+ else
+ {
+ /*
+ first match pair from BinTree: (match_len, match_dist),
+ (match_len >= numHashBytes).
+ MixMatchesFunc() inserts only hash matches that are nearer than (match_dist)
+ */
+ d = p->MixMatchesFunc(p, p->lzPos - bt[1], d);
+ // if (d) // check for failure
+ do
+ {
+ const UInt32 v0 = bt[0];
+ const UInt32 v1 = bt[1];
+ bt += 2;
+ d[0] = v0;
+ d[1] = v1;
+ d += 2;
+ }
+ while (len -= 2);
+ }
+ INCREASE_LZ_POS
+ return d;
+}
+
+#define SKIP_HEADER2_MT do { GET_NEXT_BLOCK_IF_REQUIRED
+#define SKIP_HEADER_MT(n) SKIP_HEADER2_MT if (p->btNumAvailBytes-- >= (n)) { const Byte *cur = p->pointerToCurPos; UInt32 *hash = p->hash;
+#define SKIP_FOOTER_MT } INCREASE_LZ_POS p->btBufPos += (size_t)*p->btBufPos + 1; } while (--num != 0);
+
+static void MatchFinderMt0_Skip(CMatchFinderMt *p, UInt32 num)
+{
+ SKIP_HEADER2_MT { p->btNumAvailBytes--;
+ SKIP_FOOTER_MT
+}
+
+static void MatchFinderMt2_Skip(CMatchFinderMt *p, UInt32 num)
+{
+ SKIP_HEADER_MT(2)
+ UInt32 h2;
+ MT_HASH2_CALC
+ hash[h2] = p->lzPos;
+ SKIP_FOOTER_MT
+}
+
+static void MatchFinderMt3_Skip(CMatchFinderMt *p, UInt32 num)
+{
+ SKIP_HEADER_MT(3)
+ UInt32 h2, h3;
+ MT_HASH3_CALC
+ (hash + kFix3HashSize)[h3] =
+ hash[ h2] =
+ p->lzPos;
+ SKIP_FOOTER_MT
+}
+
+/*
+// MatchFinderMt4_Skip() is similar to MatchFinderMt3_Skip().
+// The difference is that MatchFinderMt3_Skip() updates hash for last 3 bytes of stream.
+
+static void MatchFinderMt4_Skip(CMatchFinderMt *p, UInt32 num)
+{
+ SKIP_HEADER_MT(4)
+ UInt32 h2, h3; // h4
+ MT_HASH3_CALC
+ // MT_HASH4_CALC
+ // (hash + kFix4HashSize)[h4] =
+ (hash + kFix3HashSize)[h3] =
+ hash[ h2] =
+ p->lzPos;
+ SKIP_FOOTER_MT
+}
+*/
+
+void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder2 *vTable)
+{
+ vTable->Init = (Mf_Init_Func)MatchFinderMt_Init;
+ vTable->GetNumAvailableBytes = (Mf_GetNumAvailableBytes_Func)MatchFinderMt_GetNumAvailableBytes;
+ vTable->GetPointerToCurrentPos = (Mf_GetPointerToCurrentPos_Func)MatchFinderMt_GetPointerToCurrentPos;
+ vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt_GetMatches;
+
+ switch (MF(p)->numHashBytes)
+ {
+ case 2:
+ p->GetHeadsFunc = GetHeads2;
+ p->MixMatchesFunc = (Mf_Mix_Matches)NULL;
+ vTable->Skip = (Mf_Skip_Func)MatchFinderMt0_Skip;
+ vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt2_GetMatches;
+ break;
+ case 3:
+ p->GetHeadsFunc = MF(p)->bigHash ? GetHeads3b : GetHeads3;
+ p->MixMatchesFunc = (Mf_Mix_Matches)MixMatches2;
+ vTable->Skip = (Mf_Skip_Func)MatchFinderMt2_Skip;
+ break;
+ case 4:
+ p->GetHeadsFunc = MF(p)->bigHash ? GetHeads4b : GetHeads4;
+
+ // it's fast inline version of GetMatches()
+ // vTable->GetMatches = (Mf_GetMatches_Func)MatchFinderMt_GetMatches_Bt4;
+
+ p->MixMatchesFunc = (Mf_Mix_Matches)MixMatches3;
+ vTable->Skip = (Mf_Skip_Func)MatchFinderMt3_Skip;
+ break;
+ default:
+ p->GetHeadsFunc = MF(p)->bigHash ? GetHeads5b : GetHeads5;
+ p->MixMatchesFunc = (Mf_Mix_Matches)MixMatches4;
+ vTable->Skip =
+ (Mf_Skip_Func)MatchFinderMt3_Skip;
+ // (Mf_Skip_Func)MatchFinderMt4_Skip;
+ break;
+ }
+}
+
+#undef RINOK_THREAD
+#undef PRF
+#undef MF
+#undef GetUi24hi_from32
+#undef LOCK_BUFFER
+#undef UNLOCK_BUFFER
diff --git a/C/LzFindMt.h b/C/LzFindMt.h
index fdd1700..db5923e 100644
--- a/C/LzFindMt.h
+++ b/C/LzFindMt.h
@@ -1,101 +1,109 @@
-/* LzFindMt.h -- multithreaded Match finder for LZ algorithms
-2018-07-04 : Igor Pavlov : Public domain */
-
-#ifndef __LZ_FIND_MT_H
-#define __LZ_FIND_MT_H
-
-#include "LzFind.h"
-#include "Threads.h"
-
-EXTERN_C_BEGIN
-
-#define kMtHashBlockSize (1 << 13)
-#define kMtHashNumBlocks (1 << 3)
-#define kMtHashNumBlocksMask (kMtHashNumBlocks - 1)
-
-#define kMtBtBlockSize (1 << 14)
-#define kMtBtNumBlocks (1 << 6)
-#define kMtBtNumBlocksMask (kMtBtNumBlocks - 1)
-
-typedef struct _CMtSync
-{
- BoolInt wasCreated;
- BoolInt needStart;
- BoolInt exit;
- BoolInt stopWriting;
-
- CThread thread;
- CAutoResetEvent canStart;
- CAutoResetEvent wasStarted;
- CAutoResetEvent wasStopped;
- CSemaphore freeSemaphore;
- CSemaphore filledSemaphore;
- BoolInt csWasInitialized;
- BoolInt csWasEntered;
- CCriticalSection cs;
- UInt32 numProcessedBlocks;
-} CMtSync;
-
-typedef UInt32 * (*Mf_Mix_Matches)(void *p, UInt32 matchMinPos, UInt32 *distances);
-
-/* kMtCacheLineDummy must be >= size_of_CPU_cache_line */
-#define kMtCacheLineDummy 128
-
-typedef void (*Mf_GetHeads)(const Byte *buffer, UInt32 pos,
- UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc);
-
-typedef struct _CMatchFinderMt
-{
- /* LZ */
- const Byte *pointerToCurPos;
- UInt32 *btBuf;
- UInt32 btBufPos;
- UInt32 btBufPosLimit;
- UInt32 lzPos;
- UInt32 btNumAvailBytes;
-
- UInt32 *hash;
- UInt32 fixedHashSize;
- UInt32 historySize;
- const UInt32 *crc;
-
- Mf_Mix_Matches MixMatchesFunc;
-
- /* LZ + BT */
- CMtSync btSync;
- Byte btDummy[kMtCacheLineDummy];
-
- /* BT */
- UInt32 *hashBuf;
- UInt32 hashBufPos;
- UInt32 hashBufPosLimit;
- UInt32 hashNumAvail;
-
- CLzRef *son;
- UInt32 matchMaxLen;
- UInt32 numHashBytes;
- UInt32 pos;
- const Byte *buffer;
- UInt32 cyclicBufferPos;
- UInt32 cyclicBufferSize; /* it must be historySize + 1 */
- UInt32 cutValue;
-
- /* BT + Hash */
- CMtSync hashSync;
- /* Byte hashDummy[kMtCacheLineDummy]; */
-
- /* Hash */
- Mf_GetHeads GetHeadsFunc;
- CMatchFinder *MatchFinder;
-} CMatchFinderMt;
-
-void MatchFinderMt_Construct(CMatchFinderMt *p);
-void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc);
-SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc);
-void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable);
-void MatchFinderMt_ReleaseStream(CMatchFinderMt *p);
-
-EXTERN_C_END
-
-#endif
+/* LzFindMt.h -- multithreaded Match finder for LZ algorithms
+2023-03-05 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZ_FIND_MT_H
+#define ZIP7_INC_LZ_FIND_MT_H
+
+#include "LzFind.h"
+#include "Threads.h"
+
+EXTERN_C_BEGIN
+
+typedef struct
+{
+ UInt32 numProcessedBlocks;
+ CThread thread;
+ UInt64 affinity;
+
+ BoolInt wasCreated;
+ BoolInt needStart;
+ BoolInt csWasInitialized;
+ BoolInt csWasEntered;
+
+ BoolInt exit;
+ BoolInt stopWriting;
+
+ CAutoResetEvent canStart;
+ CAutoResetEvent wasStopped;
+ CSemaphore freeSemaphore;
+ CSemaphore filledSemaphore;
+ CCriticalSection cs;
+ // UInt32 numBlocks_Sent;
+} CMtSync;
+
+typedef UInt32 * (*Mf_Mix_Matches)(void *p, UInt32 matchMinPos, UInt32 *distances);
+
+/* kMtCacheLineDummy must be >= size_of_CPU_cache_line */
+#define kMtCacheLineDummy 128
+
+typedef void (*Mf_GetHeads)(const Byte *buffer, UInt32 pos,
+ UInt32 *hash, UInt32 hashMask, UInt32 *heads, UInt32 numHeads, const UInt32 *crc);
+
+typedef struct
+{
+ /* LZ */
+ const Byte *pointerToCurPos;
+ UInt32 *btBuf;
+ const UInt32 *btBufPos;
+ const UInt32 *btBufPosLimit;
+ UInt32 lzPos;
+ UInt32 btNumAvailBytes;
+
+ UInt32 *hash;
+ UInt32 fixedHashSize;
+ // UInt32 hash4Mask;
+ UInt32 historySize;
+ const UInt32 *crc;
+
+ Mf_Mix_Matches MixMatchesFunc;
+ UInt32 failure_LZ_BT; // failure in BT transfered to LZ
+ // UInt32 failure_LZ_LZ; // failure in LZ tables
+ UInt32 failureBuf[1];
+ // UInt32 crc[256];
+
+ /* LZ + BT */
+ CMtSync btSync;
+ Byte btDummy[kMtCacheLineDummy];
+
+ /* BT */
+ UInt32 *hashBuf;
+ UInt32 hashBufPos;
+ UInt32 hashBufPosLimit;
+ UInt32 hashNumAvail;
+ UInt32 failure_BT;
+
+
+ CLzRef *son;
+ UInt32 matchMaxLen;
+ UInt32 numHashBytes;
+ UInt32 pos;
+ const Byte *buffer;
+ UInt32 cyclicBufferPos;
+ UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
+ UInt32 cutValue;
+
+ /* BT + Hash */
+ CMtSync hashSync;
+ /* Byte hashDummy[kMtCacheLineDummy]; */
+
+ /* Hash */
+ Mf_GetHeads GetHeadsFunc;
+ CMatchFinder *MatchFinder;
+ // CMatchFinder MatchFinder;
+} CMatchFinderMt;
+
+// only for Mt part
+void MatchFinderMt_Construct(CMatchFinderMt *p);
+void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAllocPtr alloc);
+
+SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddBufferBefore,
+ UInt32 matchMaxLen, UInt32 keepAddBufferAfter, ISzAllocPtr alloc);
+void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder2 *vTable);
+
+/* call MatchFinderMt_InitMt() before IMatchFinder::Init() */
+SRes MatchFinderMt_InitMt(CMatchFinderMt *p);
+void MatchFinderMt_ReleaseStream(CMatchFinderMt *p);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/LzFindOpt.c b/C/LzFindOpt.c
new file mode 100644
index 0000000..85bdc13
--- /dev/null
+++ b/C/LzFindOpt.c
@@ -0,0 +1,578 @@
+/* LzFindOpt.c -- multithreaded Match finder for LZ algorithms
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "CpuArch.h"
+#include "LzFind.h"
+
+// #include "LzFindMt.h"
+
+// #define LOG_ITERS
+
+// #define LOG_THREAD
+
+#ifdef LOG_THREAD
+#include <stdio.h>
+#define PRF(x) x
+#else
+// #define PRF(x)
+#endif
+
+#ifdef LOG_ITERS
+#include <stdio.h>
+UInt64 g_NumIters_Tree;
+UInt64 g_NumIters_Loop;
+UInt64 g_NumIters_Bytes;
+#define LOG_ITER(x) x
+#else
+#define LOG_ITER(x)
+#endif
+
+// ---------- BT THREAD ----------
+
+#define USE_SON_PREFETCH
+#define USE_LONG_MATCH_OPT
+
+#define kEmptyHashValue 0
+
+// #define CYC_TO_POS_OFFSET 0
+
+// #define CYC_TO_POS_OFFSET 1 // for debug
+
+/*
+Z7_NO_INLINE
+UInt32 * Z7_FASTCALL GetMatchesSpecN_1(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
+ UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size, UInt32 *posRes)
+{
+ do
+ {
+ UInt32 delta;
+ if (hash == size)
+ break;
+ delta = *hash++;
+
+ if (delta == 0 || delta > (UInt32)pos)
+ return NULL;
+
+ lenLimit++;
+
+ if (delta == (UInt32)pos)
+ {
+ CLzRef *ptr1 = son + ((size_t)pos << 1) - CYC_TO_POS_OFFSET * 2;
+ *d++ = 0;
+ ptr1[0] = kEmptyHashValue;
+ ptr1[1] = kEmptyHashValue;
+ }
+else
+{
+ UInt32 *_distances = ++d;
+
+ CLzRef *ptr0 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2 + 1;
+ CLzRef *ptr1 = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
+
+ const Byte *len0 = cur, *len1 = cur;
+ UInt32 cutValue = _cutValue;
+ const Byte *maxLen = cur + _maxLen;
+
+ for (LOG_ITER(g_NumIters_Tree++);;)
+ {
+ LOG_ITER(g_NumIters_Loop++);
+ {
+ const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
+ CLzRef *pair = son + ((size_t)(((ptrdiff_t)pos - CYC_TO_POS_OFFSET) + diff) << 1);
+ const Byte *len = (len0 < len1 ? len0 : len1);
+
+ #ifdef USE_SON_PREFETCH
+ const UInt32 pair0 = *pair;
+ #endif
+
+ if (len[diff] == len[0])
+ {
+ if (++len != lenLimit && len[diff] == len[0])
+ while (++len != lenLimit)
+ {
+ LOG_ITER(g_NumIters_Bytes++);
+ if (len[diff] != len[0])
+ break;
+ }
+ if (maxLen < len)
+ {
+ maxLen = len;
+ *d++ = (UInt32)(len - cur);
+ *d++ = delta - 1;
+
+ if (len == lenLimit)
+ {
+ const UInt32 pair1 = pair[1];
+ *ptr1 =
+ #ifdef USE_SON_PREFETCH
+ pair0;
+ #else
+ pair[0];
+ #endif
+ *ptr0 = pair1;
+
+ _distances[-1] = (UInt32)(d - _distances);
+
+ #ifdef USE_LONG_MATCH_OPT
+
+ if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
+ break;
+
+ {
+ for (;;)
+ {
+ hash++;
+ pos++;
+ cur++;
+ lenLimit++;
+ {
+ CLzRef *ptr = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
+ #if 0
+ *(UInt64 *)(void *)ptr = ((const UInt64 *)(const void *)ptr)[diff];
+ #else
+ const UInt32 p0 = ptr[0 + (diff * 2)];
+ const UInt32 p1 = ptr[1 + (diff * 2)];
+ ptr[0] = p0;
+ ptr[1] = p1;
+ // ptr[0] = ptr[0 + (diff * 2)];
+ // ptr[1] = ptr[1 + (diff * 2)];
+ #endif
+ }
+ // PrintSon(son + 2, pos - 1);
+ // printf("\npos = %x delta = %x\n", pos, delta);
+ len++;
+ *d++ = 2;
+ *d++ = (UInt32)(len - cur);
+ *d++ = delta - 1;
+ if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
+ break;
+ }
+ }
+ #endif
+
+ break;
+ }
+ }
+ }
+
+ {
+ const UInt32 curMatch = (UInt32)pos - delta; // (UInt32)(pos + diff);
+ if (len[diff] < len[0])
+ {
+ delta = pair[1];
+ if (delta >= curMatch)
+ return NULL;
+ *ptr1 = curMatch;
+ ptr1 = pair + 1;
+ len1 = len;
+ }
+ else
+ {
+ delta = *pair;
+ if (delta >= curMatch)
+ return NULL;
+ *ptr0 = curMatch;
+ ptr0 = pair;
+ len0 = len;
+ }
+
+ delta = (UInt32)pos - delta;
+
+ if (--cutValue == 0 || delta >= pos)
+ {
+ *ptr0 = *ptr1 = kEmptyHashValue;
+ _distances[-1] = (UInt32)(d - _distances);
+ break;
+ }
+ }
+ }
+ } // for (tree iterations)
+}
+ pos++;
+ cur++;
+ }
+ while (d < limit);
+ *posRes = (UInt32)pos;
+ return d;
+}
+*/
+
+/* define cbs if you use 2 functions.
+ GetMatchesSpecN_1() : (pos < _cyclicBufferSize)
+ GetMatchesSpecN_2() : (pos >= _cyclicBufferSize)
+
+ do not define cbs if you use 1 function:
+ GetMatchesSpecN_2()
+*/
+
+// #define cbs _cyclicBufferSize
+
+/*
+ we use size_t for (pos) and (_cyclicBufferPos_ instead of UInt32
+ to eliminate "movsx" BUG in old MSVC x64 compiler.
+*/
+
+UInt32 * Z7_FASTCALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
+ UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
+ UInt32 *posRes);
+
+Z7_NO_INLINE
+UInt32 * Z7_FASTCALL GetMatchesSpecN_2(const Byte *lenLimit, size_t pos, const Byte *cur, CLzRef *son,
+ UInt32 _cutValue, UInt32 *d, size_t _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
+ UInt32 *posRes)
+{
+ do // while (hash != size)
+ {
+ UInt32 delta;
+
+ #ifndef cbs
+ UInt32 cbs;
+ #endif
+
+ if (hash == size)
+ break;
+
+ delta = *hash++;
+
+ if (delta == 0)
+ return NULL;
+
+ lenLimit++;
+
+ #ifndef cbs
+ cbs = _cyclicBufferSize;
+ if ((UInt32)pos < cbs)
+ {
+ if (delta > (UInt32)pos)
+ return NULL;
+ cbs = (UInt32)pos;
+ }
+ #endif
+
+ if (delta >= cbs)
+ {
+ CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
+ *d++ = 0;
+ ptr1[0] = kEmptyHashValue;
+ ptr1[1] = kEmptyHashValue;
+ }
+else
+{
+ UInt32 *_distances = ++d;
+
+ CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
+ CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
+
+ UInt32 cutValue = _cutValue;
+ const Byte *len0 = cur, *len1 = cur;
+ const Byte *maxLen = cur + _maxLen;
+
+ // if (cutValue == 0) { *ptr0 = *ptr1 = kEmptyHashValue; } else
+ for (LOG_ITER(g_NumIters_Tree++);;)
+ {
+ LOG_ITER(g_NumIters_Loop++);
+ {
+ // SPEC code
+ CLzRef *pair = son + ((size_t)((ptrdiff_t)_cyclicBufferPos - (ptrdiff_t)delta
+ + (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)
+ ) << 1);
+
+ const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
+ const Byte *len = (len0 < len1 ? len0 : len1);
+
+ #ifdef USE_SON_PREFETCH
+ const UInt32 pair0 = *pair;
+ #endif
+
+ if (len[diff] == len[0])
+ {
+ if (++len != lenLimit && len[diff] == len[0])
+ while (++len != lenLimit)
+ {
+ LOG_ITER(g_NumIters_Bytes++);
+ if (len[diff] != len[0])
+ break;
+ }
+ if (maxLen < len)
+ {
+ maxLen = len;
+ *d++ = (UInt32)(len - cur);
+ *d++ = delta - 1;
+
+ if (len == lenLimit)
+ {
+ const UInt32 pair1 = pair[1];
+ *ptr1 =
+ #ifdef USE_SON_PREFETCH
+ pair0;
+ #else
+ pair[0];
+ #endif
+ *ptr0 = pair1;
+
+ _distances[-1] = (UInt32)(d - _distances);
+
+ #ifdef USE_LONG_MATCH_OPT
+
+ if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
+ break;
+
+ {
+ for (;;)
+ {
+ *d++ = 2;
+ *d++ = (UInt32)(lenLimit - cur);
+ *d++ = delta - 1;
+ cur++;
+ lenLimit++;
+ // SPEC
+ _cyclicBufferPos++;
+ {
+ // SPEC code
+ CLzRef *dest = son + ((size_t)(_cyclicBufferPos) << 1);
+ const CLzRef *src = dest + ((diff
+ + (ptrdiff_t)(UInt32)((_cyclicBufferPos < delta) ? cbs : 0)) << 1);
+ // CLzRef *ptr = son + ((size_t)(pos) << 1) - CYC_TO_POS_OFFSET * 2;
+ #if 0
+ *(UInt64 *)(void *)dest = *((const UInt64 *)(const void *)src);
+ #else
+ const UInt32 p0 = src[0];
+ const UInt32 p1 = src[1];
+ dest[0] = p0;
+ dest[1] = p1;
+ #endif
+ }
+ pos++;
+ hash++;
+ if (hash == size || *hash != delta || lenLimit[diff] != lenLimit[0] || d >= limit)
+ break;
+ } // for() end for long matches
+ }
+ #endif
+
+ break; // break from TREE iterations
+ }
+ }
+ }
+ {
+ const UInt32 curMatch = (UInt32)pos - delta; // (UInt32)(pos + diff);
+ if (len[diff] < len[0])
+ {
+ delta = pair[1];
+ *ptr1 = curMatch;
+ ptr1 = pair + 1;
+ len1 = len;
+ if (delta >= curMatch)
+ return NULL;
+ }
+ else
+ {
+ delta = *pair;
+ *ptr0 = curMatch;
+ ptr0 = pair;
+ len0 = len;
+ if (delta >= curMatch)
+ return NULL;
+ }
+ delta = (UInt32)pos - delta;
+
+ if (--cutValue == 0 || delta >= cbs)
+ {
+ *ptr0 = *ptr1 = kEmptyHashValue;
+ _distances[-1] = (UInt32)(d - _distances);
+ break;
+ }
+ }
+ }
+ } // for (tree iterations)
+}
+ pos++;
+ _cyclicBufferPos++;
+ cur++;
+ }
+ while (d < limit);
+ *posRes = (UInt32)pos;
+ return d;
+}
+
+
+
+/*
+typedef UInt32 uint32plus; // size_t
+
+UInt32 * Z7_FASTCALL GetMatchesSpecN_3(uint32plus lenLimit, size_t pos, const Byte *cur, CLzRef *son,
+ UInt32 _cutValue, UInt32 *d, uint32plus _maxLen, const UInt32 *hash, const UInt32 *limit, const UInt32 *size,
+ size_t _cyclicBufferPos, UInt32 _cyclicBufferSize,
+ UInt32 *posRes)
+{
+ do // while (hash != size)
+ {
+ UInt32 delta;
+
+ #ifndef cbs
+ UInt32 cbs;
+ #endif
+
+ if (hash == size)
+ break;
+
+ delta = *hash++;
+
+ if (delta == 0)
+ return NULL;
+
+ #ifndef cbs
+ cbs = _cyclicBufferSize;
+ if ((UInt32)pos < cbs)
+ {
+ if (delta > (UInt32)pos)
+ return NULL;
+ cbs = (UInt32)pos;
+ }
+ #endif
+
+ if (delta >= cbs)
+ {
+ CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
+ *d++ = 0;
+ ptr1[0] = kEmptyHashValue;
+ ptr1[1] = kEmptyHashValue;
+ }
+else
+{
+ CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
+ CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
+ UInt32 *_distances = ++d;
+ uint32plus len0 = 0, len1 = 0;
+ UInt32 cutValue = _cutValue;
+ uint32plus maxLen = _maxLen;
+ // lenLimit++; // const Byte *lenLimit = cur + _lenLimit;
+
+ for (LOG_ITER(g_NumIters_Tree++);;)
+ {
+ LOG_ITER(g_NumIters_Loop++);
+ {
+ // const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
+ CLzRef *pair = son + ((size_t)((ptrdiff_t)_cyclicBufferPos - delta
+ + (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)
+ ) << 1);
+ const Byte *pb = cur - delta;
+ uint32plus len = (len0 < len1 ? len0 : len1);
+
+ #ifdef USE_SON_PREFETCH
+ const UInt32 pair0 = *pair;
+ #endif
+
+ if (pb[len] == cur[len])
+ {
+ if (++len != lenLimit && pb[len] == cur[len])
+ while (++len != lenLimit)
+ if (pb[len] != cur[len])
+ break;
+ if (maxLen < len)
+ {
+ maxLen = len;
+ *d++ = (UInt32)len;
+ *d++ = delta - 1;
+ if (len == lenLimit)
+ {
+ {
+ const UInt32 pair1 = pair[1];
+ *ptr0 = pair1;
+ *ptr1 =
+ #ifdef USE_SON_PREFETCH
+ pair0;
+ #else
+ pair[0];
+ #endif
+ }
+
+ _distances[-1] = (UInt32)(d - _distances);
+
+ #ifdef USE_LONG_MATCH_OPT
+
+ if (hash == size || *hash != delta || pb[lenLimit] != cur[lenLimit] || d >= limit)
+ break;
+
+ {
+ const ptrdiff_t diff = (ptrdiff_t)0 - (ptrdiff_t)delta;
+ for (;;)
+ {
+ *d++ = 2;
+ *d++ = (UInt32)lenLimit;
+ *d++ = delta - 1;
+ _cyclicBufferPos++;
+ {
+ CLzRef *dest = son + ((size_t)_cyclicBufferPos << 1);
+ const CLzRef *src = dest + ((diff +
+ (ptrdiff_t)(UInt32)(_cyclicBufferPos < delta ? cbs : 0)) << 1);
+ #if 0
+ *(UInt64 *)(void *)dest = *((const UInt64 *)(const void *)src);
+ #else
+ const UInt32 p0 = src[0];
+ const UInt32 p1 = src[1];
+ dest[0] = p0;
+ dest[1] = p1;
+ #endif
+ }
+ hash++;
+ pos++;
+ cur++;
+ pb++;
+ if (hash == size || *hash != delta || pb[lenLimit] != cur[lenLimit] || d >= limit)
+ break;
+ }
+ }
+ #endif
+
+ break;
+ }
+ }
+ }
+ {
+ const UInt32 curMatch = (UInt32)pos - delta;
+ if (pb[len] < cur[len])
+ {
+ delta = pair[1];
+ *ptr1 = curMatch;
+ ptr1 = pair + 1;
+ len1 = len;
+ }
+ else
+ {
+ delta = *pair;
+ *ptr0 = curMatch;
+ ptr0 = pair;
+ len0 = len;
+ }
+
+ {
+ if (delta >= curMatch)
+ return NULL;
+ delta = (UInt32)pos - delta;
+ if (delta >= cbs
+ // delta >= _cyclicBufferSize || delta >= pos
+ || --cutValue == 0)
+ {
+ *ptr0 = *ptr1 = kEmptyHashValue;
+ _distances[-1] = (UInt32)(d - _distances);
+ break;
+ }
+ }
+ }
+ }
+ } // for (tree iterations)
+}
+ pos++;
+ _cyclicBufferPos++;
+ cur++;
+ }
+ while (d < limit);
+ *posRes = (UInt32)pos;
+ return d;
+}
+*/
diff --git a/C/LzHash.h b/C/LzHash.h
index 2191444..2b6290b 100644
--- a/C/LzHash.h
+++ b/C/LzHash.h
@@ -1,57 +1,34 @@
-/* LzHash.h -- HASH functions for LZ algorithms
-2015-04-12 : Igor Pavlov : Public domain */
-
-#ifndef __LZ_HASH_H
-#define __LZ_HASH_H
-
-#define kHash2Size (1 << 10)
-#define kHash3Size (1 << 16)
-#define kHash4Size (1 << 20)
-
-#define kFix3HashSize (kHash2Size)
-#define kFix4HashSize (kHash2Size + kHash3Size)
-#define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
-
-#define HASH2_CALC hv = cur[0] | ((UInt32)cur[1] << 8);
-
-#define HASH3_CALC { \
- UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
- h2 = temp & (kHash2Size - 1); \
- hv = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; }
-
-#define HASH4_CALC { \
- UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
- h2 = temp & (kHash2Size - 1); \
- temp ^= ((UInt32)cur[2] << 8); \
- h3 = temp & (kHash3Size - 1); \
- hv = (temp ^ (p->crc[cur[3]] << 5)) & p->hashMask; }
-
-#define HASH5_CALC { \
- UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
- h2 = temp & (kHash2Size - 1); \
- temp ^= ((UInt32)cur[2] << 8); \
- h3 = temp & (kHash3Size - 1); \
- temp ^= (p->crc[cur[3]] << 5); \
- h4 = temp & (kHash4Size - 1); \
- hv = (temp ^ (p->crc[cur[4]] << 3)) & p->hashMask; }
-
-/* #define HASH_ZIP_CALC hv = ((cur[0] | ((UInt32)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */
-#define HASH_ZIP_CALC hv = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;
-
-
-#define MT_HASH2_CALC \
- h2 = (p->crc[cur[0]] ^ cur[1]) & (kHash2Size - 1);
-
-#define MT_HASH3_CALC { \
- UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
- h2 = temp & (kHash2Size - 1); \
- h3 = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }
-
-#define MT_HASH4_CALC { \
- UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
- h2 = temp & (kHash2Size - 1); \
- temp ^= ((UInt32)cur[2] << 8); \
- h3 = temp & (kHash3Size - 1); \
- h4 = (temp ^ (p->crc[cur[3]] << 5)) & (kHash4Size - 1); }
-
-#endif
+/* LzHash.h -- HASH constants for LZ algorithms
+2023-03-05 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZ_HASH_H
+#define ZIP7_INC_LZ_HASH_H
+
+/*
+ (kHash2Size >= (1 << 8)) : Required
+ (kHash3Size >= (1 << 16)) : Required
+*/
+
+#define kHash2Size (1 << 10)
+#define kHash3Size (1 << 16)
+// #define kHash4Size (1 << 20)
+
+#define kFix3HashSize (kHash2Size)
+#define kFix4HashSize (kHash2Size + kHash3Size)
+// #define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
+
+/*
+ We use up to 3 crc values for hash:
+ crc0
+ crc1 << Shift_1
+ crc2 << Shift_2
+ (Shift_1 = 5) and (Shift_2 = 10) is good tradeoff.
+ Small values for Shift are not good for collision rate.
+ Big value for Shift_2 increases the minimum size
+ of hash table, that will be slow for small files.
+*/
+
+#define kLzHash_CrcShift_1 5
+#define kLzHash_CrcShift_2 10
+
+#endif
diff --git a/C/Lzma2Dec.c b/C/Lzma2Dec.c
index 2e63105..388cbc7 100644
--- a/C/Lzma2Dec.c
+++ b/C/Lzma2Dec.c
@@ -1,488 +1,491 @@
-/* Lzma2Dec.c -- LZMA2 Decoder
-2019-02-02 : 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);
-}
-
-static ELzma2State 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;
-}
+/* 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
diff --git a/C/Lzma2Dec.h b/C/Lzma2Dec.h
index da50387..1f5233a 100644
--- a/C/Lzma2Dec.h
+++ b/C/Lzma2Dec.h
@@ -1,120 +1,121 @@
-/* Lzma2Dec.h -- LZMA2 Decoder
-2018-02-19 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA2_DEC_H
-#define __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_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
+/* 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
diff --git a/C/Lzma2DecMt.c b/C/Lzma2DecMt.c
index 87d5567..4bc4dde 100644
--- a/C/Lzma2DecMt.c
+++ b/C/Lzma2DecMt.c
@@ -1,1082 +1,1095 @@
-/* Lzma2DecMt.c -- LZMA2 Decoder Multi-thread
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-// #define SHOW_DEBUG_INFO
-
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-#define PRF_STR(s) PRF(printf("\n" s "\n"))
-#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
-#define PRF_STR_INT_2(s, d1, d2) PRF(printf("\n" s " %d %d\n", (unsigned)d1, (unsigned)d2))
-
-// #define _7ZIP_ST
-
-#include "Alloc.h"
-
-#include "Lzma2Dec.h"
-#include "Lzma2DecMt.h"
-
-#ifndef _7ZIP_ST
-#include "MtDec.h"
-#endif
-
-
-#define LZMA2DECMT_OUT_BLOCK_MAX_DEFAULT (1 << 28)
-
-void Lzma2DecMtProps_Init(CLzma2DecMtProps *p)
-{
- p->inBufSize_ST = 1 << 20;
- p->outStep_ST = 1 << 20;
-
- #ifndef _7ZIP_ST
- p->numThreads = 1;
- p->inBufSize_MT = 1 << 18;
- p->outBlockMax = LZMA2DECMT_OUT_BLOCK_MAX_DEFAULT;
- p->inBlockMax = p->outBlockMax + p->outBlockMax / 16;
- #endif
-}
-
-
-
-#ifndef _7ZIP_ST
-
-/* ---------- CLzma2DecMtThread ---------- */
-
-typedef struct
-{
- CLzma2Dec dec;
- Byte dec_created;
- Byte needInit;
-
- Byte *outBuf;
- size_t outBufSize;
-
- EMtDecParseState state;
- ELzma2ParseStatus parseStatus;
-
- size_t inPreSize;
- size_t outPreSize;
-
- size_t inCodeSize;
- size_t outCodeSize;
- SRes codeRes;
-
- CAlignOffsetAlloc alloc;
-
- Byte mtPad[1 << 7];
-} CLzma2DecMtThread;
-
-#endif
-
-
-/* ---------- CLzma2DecMt ---------- */
-
-typedef struct
-{
- // ISzAllocPtr alloc;
- ISzAllocPtr allocMid;
-
- CAlignOffsetAlloc alignOffsetAlloc;
- CLzma2DecMtProps props;
- Byte prop;
-
- ISeqInStream *inStream;
- ISeqOutStream *outStream;
- ICompressProgress *progress;
-
- BoolInt finishMode;
- BoolInt outSize_Defined;
- UInt64 outSize;
-
- UInt64 outProcessed;
- UInt64 inProcessed;
- BoolInt readWasFinished;
- SRes readRes;
-
- Byte *inBuf;
- size_t inBufSize;
- Byte dec_created;
- CLzma2Dec dec;
-
- size_t inPos;
- size_t inLim;
-
- #ifndef _7ZIP_ST
- UInt64 outProcessed_Parse;
- BoolInt mtc_WasConstructed;
- CMtDec mtc;
- CLzma2DecMtThread coders[MTDEC__THREADS_MAX];
- #endif
-
-} CLzma2DecMt;
-
-
-
-CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
-{
- CLzma2DecMt *p = (CLzma2DecMt *)ISzAlloc_Alloc(alloc, sizeof(CLzma2DecMt));
- if (!p)
- return NULL;
-
- // p->alloc = alloc;
- p->allocMid = allocMid;
-
- AlignOffsetAlloc_CreateVTable(&p->alignOffsetAlloc);
- p->alignOffsetAlloc.numAlignBits = 7;
- p->alignOffsetAlloc.offset = 0;
- p->alignOffsetAlloc.baseAlloc = alloc;
-
- p->inBuf = NULL;
- p->inBufSize = 0;
- p->dec_created = False;
-
- // Lzma2DecMtProps_Init(&p->props);
-
- #ifndef _7ZIP_ST
- p->mtc_WasConstructed = False;
- {
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CLzma2DecMtThread *t = &p->coders[i];
- t->dec_created = False;
- t->outBuf = NULL;
- t->outBufSize = 0;
- }
- }
- #endif
-
- return p;
-}
-
-
-#ifndef _7ZIP_ST
-
-static void Lzma2DecMt_FreeOutBufs(CLzma2DecMt *p)
-{
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CLzma2DecMtThread *t = &p->coders[i];
- if (t->outBuf)
- {
- ISzAlloc_Free(p->allocMid, t->outBuf);
- t->outBuf = NULL;
- t->outBufSize = 0;
- }
- }
-}
-
-#endif
-
-
-static void Lzma2DecMt_FreeSt(CLzma2DecMt *p)
-{
- if (p->dec_created)
- {
- Lzma2Dec_Free(&p->dec, &p->alignOffsetAlloc.vt);
- p->dec_created = False;
- }
- if (p->inBuf)
- {
- ISzAlloc_Free(p->allocMid, p->inBuf);
- p->inBuf = NULL;
- }
- p->inBufSize = 0;
-}
-
-
-void Lzma2DecMt_Destroy(CLzma2DecMtHandle pp)
-{
- CLzma2DecMt *p = (CLzma2DecMt *)pp;
-
- Lzma2DecMt_FreeSt(p);
-
- #ifndef _7ZIP_ST
-
- if (p->mtc_WasConstructed)
- {
- MtDec_Destruct(&p->mtc);
- p->mtc_WasConstructed = False;
- }
- {
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CLzma2DecMtThread *t = &p->coders[i];
- if (t->dec_created)
- {
- // we don't need to free dict here
- Lzma2Dec_FreeProbs(&t->dec, &t->alloc.vt); // p->alloc !!!
- t->dec_created = False;
- }
- }
- }
- Lzma2DecMt_FreeOutBufs(p);
-
- #endif
-
- ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, pp);
-}
-
-
-
-#ifndef _7ZIP_ST
-
-static void Lzma2DecMt_MtCallback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
-{
- CLzma2DecMt *me = (CLzma2DecMt *)obj;
- CLzma2DecMtThread *t = &me->coders[coderIndex];
-
- PRF_STR_INT_2("Parse", coderIndex, cc->srcSize);
-
- cc->state = MTDEC_PARSE_CONTINUE;
-
- if (cc->startCall)
- {
- if (!t->dec_created)
- {
- Lzma2Dec_Construct(&t->dec);
- t->dec_created = True;
- AlignOffsetAlloc_CreateVTable(&t->alloc);
- {
- /* (1 << 12) is expected size of one way in data cache.
- We optimize alignment for cache line size of 128 bytes and smaller */
- const unsigned kNumAlignBits = 12;
- const unsigned kNumCacheLineBits = 7; /* <= kNumAlignBits */
- t->alloc.numAlignBits = kNumAlignBits;
- t->alloc.offset = ((UInt32)coderIndex * ((1 << 11) + (1 << 8) + (1 << 6))) & ((1 << kNumAlignBits) - (1 << kNumCacheLineBits));
- t->alloc.baseAlloc = me->alignOffsetAlloc.baseAlloc;
- }
- }
- Lzma2Dec_Init(&t->dec);
-
- t->inPreSize = 0;
- t->outPreSize = 0;
- // t->blockWasFinished = False;
- // t->finishedWithMark = False;
- t->parseStatus = (ELzma2ParseStatus)LZMA_STATUS_NOT_SPECIFIED;
- t->state = MTDEC_PARSE_CONTINUE;
-
- t->inCodeSize = 0;
- t->outCodeSize = 0;
- t->codeRes = SZ_OK;
-
- // (cc->srcSize == 0) is allowed
- }
-
- {
- ELzma2ParseStatus status;
- BoolInt overflow;
- UInt32 unpackRem = 0;
-
- int checkFinishBlock = True;
- size_t limit = me->props.outBlockMax;
- if (me->outSize_Defined)
- {
- UInt64 rem = me->outSize - me->outProcessed_Parse;
- if (limit >= rem)
- {
- limit = (size_t)rem;
- if (!me->finishMode)
- checkFinishBlock = False;
- }
- }
-
- // checkFinishBlock = False, if we want to decode partial data
- // that must be finished at position <= outBlockMax.
-
- {
- const SizeT srcOrig = cc->srcSize;
- SizeT srcSize_Point = 0;
- SizeT dicPos_Point = 0;
-
- cc->srcSize = 0;
- overflow = False;
-
- for (;;)
- {
- SizeT srcCur = srcOrig - cc->srcSize;
-
- status = Lzma2Dec_Parse(&t->dec,
- limit - t->dec.decoder.dicPos,
- cc->src + cc->srcSize, &srcCur,
- checkFinishBlock);
-
- cc->srcSize += srcCur;
-
- if (status == LZMA2_PARSE_STATUS_NEW_CHUNK)
- {
- if (t->dec.unpackSize > me->props.outBlockMax - t->dec.decoder.dicPos)
- {
- overflow = True;
- break;
- }
- continue;
- }
-
- if (status == LZMA2_PARSE_STATUS_NEW_BLOCK)
- {
- if (t->dec.decoder.dicPos == 0)
- continue;
- // we decode small blocks in one thread
- if (t->dec.decoder.dicPos >= (1 << 14))
- break;
- dicPos_Point = t->dec.decoder.dicPos;
- srcSize_Point = cc->srcSize;
- continue;
- }
-
- if ((int)status == LZMA_STATUS_NOT_FINISHED && checkFinishBlock
- // && limit == t->dec.decoder.dicPos
- // && limit == me->props.outBlockMax
- )
- {
- overflow = True;
- break;
- }
-
- unpackRem = Lzma2Dec_GetUnpackExtra(&t->dec);
- break;
- }
-
- if (dicPos_Point != 0
- && (int)status != LZMA2_PARSE_STATUS_NEW_BLOCK
- && (int)status != LZMA_STATUS_FINISHED_WITH_MARK
- && (int)status != LZMA_STATUS_NOT_SPECIFIED)
- {
- // we revert to latest newBlock state
- status = LZMA2_PARSE_STATUS_NEW_BLOCK;
- unpackRem = 0;
- t->dec.decoder.dicPos = dicPos_Point;
- cc->srcSize = srcSize_Point;
- overflow = False;
- }
- }
-
- t->inPreSize += cc->srcSize;
- t->parseStatus = status;
-
- if (overflow)
- cc->state = MTDEC_PARSE_OVERFLOW;
- else
- {
- size_t dicPos = t->dec.decoder.dicPos;
-
- if ((int)status != LZMA_STATUS_NEEDS_MORE_INPUT)
- {
- if (status == LZMA2_PARSE_STATUS_NEW_BLOCK)
- {
- cc->state = MTDEC_PARSE_NEW;
- cc->srcSize--; // we don't need control byte of next block
- t->inPreSize--;
- }
- else
- {
- cc->state = MTDEC_PARSE_END;
- if ((int)status != LZMA_STATUS_FINISHED_WITH_MARK)
- {
- // (status == LZMA_STATUS_NOT_SPECIFIED)
- // (status == LZMA_STATUS_NOT_FINISHED)
- if (unpackRem != 0)
- {
- /* we also reserve space for max possible number of output bytes of current LZMA chunk */
- SizeT rem = limit - dicPos;
- if (rem > unpackRem)
- rem = unpackRem;
- dicPos += rem;
- }
- }
- }
-
- me->outProcessed_Parse += dicPos;
- }
-
- cc->outPos = dicPos;
- t->outPreSize = (size_t)dicPos;
- }
-
- t->state = cc->state;
- return;
- }
-}
-
-
-static SRes Lzma2DecMt_MtCallback_PreCode(void *pp, unsigned coderIndex)
-{
- CLzma2DecMt *me = (CLzma2DecMt *)pp;
- CLzma2DecMtThread *t = &me->coders[coderIndex];
- Byte *dest = t->outBuf;
-
- if (t->inPreSize == 0)
- {
- t->codeRes = SZ_ERROR_DATA;
- return t->codeRes;
- }
-
- if (!dest || t->outBufSize < t->outPreSize)
- {
- if (dest)
- {
- ISzAlloc_Free(me->allocMid, dest);
- t->outBuf = NULL;
- t->outBufSize = 0;
- }
-
- dest = (Byte *)ISzAlloc_Alloc(me->allocMid, t->outPreSize
- // + (1 << 28)
- );
- // Sleep(200);
- if (!dest)
- return SZ_ERROR_MEM;
- t->outBuf = dest;
- t->outBufSize = t->outPreSize;
- }
-
- t->dec.decoder.dic = dest;
- t->dec.decoder.dicBufSize = t->outPreSize;
-
- t->needInit = True;
-
- return Lzma2Dec_AllocateProbs(&t->dec, me->prop, &t->alloc.vt); // alloc.vt
-}
-
-
-static SRes Lzma2DecMt_MtCallback_Code(void *pp, unsigned coderIndex,
- const Byte *src, size_t srcSize, int srcFinished,
- // int finished, int blockFinished,
- UInt64 *inCodePos, UInt64 *outCodePos, int *stop)
-{
- CLzma2DecMt *me = (CLzma2DecMt *)pp;
- CLzma2DecMtThread *t = &me->coders[coderIndex];
-
- UNUSED_VAR(srcFinished)
-
- PRF_STR_INT_2("Code", coderIndex, srcSize);
-
- *inCodePos = t->inCodeSize;
- *outCodePos = 0;
- *stop = True;
-
- if (t->needInit)
- {
- Lzma2Dec_Init(&t->dec);
- t->needInit = False;
- }
-
- {
- ELzmaStatus status;
- size_t srcProcessed = srcSize;
- BoolInt blockWasFinished =
- ((int)t->parseStatus == LZMA_STATUS_FINISHED_WITH_MARK
- || t->parseStatus == LZMA2_PARSE_STATUS_NEW_BLOCK);
-
- SRes res = Lzma2Dec_DecodeToDic(&t->dec,
- t->outPreSize,
- src, &srcProcessed,
- blockWasFinished ? LZMA_FINISH_END : LZMA_FINISH_ANY,
- &status);
-
- t->codeRes = res;
-
- t->inCodeSize += srcProcessed;
- *inCodePos = t->inCodeSize;
- t->outCodeSize = t->dec.decoder.dicPos;
- *outCodePos = t->dec.decoder.dicPos;
-
- if (res != SZ_OK)
- return res;
-
- if (srcProcessed == srcSize)
- *stop = False;
-
- if (blockWasFinished)
- {
- if (srcSize != srcProcessed)
- return SZ_ERROR_FAIL;
-
- if (t->inPreSize == t->inCodeSize)
- {
- if (t->outPreSize != t->outCodeSize)
- return SZ_ERROR_FAIL;
- *stop = True;
- }
- }
- else
- {
- if (t->outPreSize == t->outCodeSize)
- *stop = True;
- }
-
- return SZ_OK;
- }
-}
-
-
-#define LZMA2DECMT_STREAM_WRITE_STEP (1 << 24)
-
-static SRes Lzma2DecMt_MtCallback_Write(void *pp, unsigned coderIndex,
- BoolInt needWriteToStream,
- const Byte *src, size_t srcSize,
- BoolInt *needContinue, BoolInt *canRecode)
-{
- CLzma2DecMt *me = (CLzma2DecMt *)pp;
- const CLzma2DecMtThread *t = &me->coders[coderIndex];
- size_t size = t->outCodeSize;
- const Byte *data = t->outBuf;
- BoolInt needContinue2 = True;
-
- PRF_STR_INT_2("Write", coderIndex, srcSize);
-
- *needContinue = False;
- *canRecode = True;
- UNUSED_VAR(src)
- UNUSED_VAR(srcSize)
-
- if (
- // t->parseStatus == LZMA_STATUS_FINISHED_WITH_MARK
- t->state == MTDEC_PARSE_OVERFLOW
- || t->state == MTDEC_PARSE_END)
- needContinue2 = False;
-
-
- if (!needWriteToStream)
- return SZ_OK;
-
- me->mtc.inProcessed += t->inCodeSize;
-
- if (t->codeRes == SZ_OK)
- if ((int)t->parseStatus == LZMA_STATUS_FINISHED_WITH_MARK
- || t->parseStatus == LZMA2_PARSE_STATUS_NEW_BLOCK)
- if (t->outPreSize != t->outCodeSize
- || t->inPreSize != t->inCodeSize)
- return SZ_ERROR_FAIL;
-
- *canRecode = False;
-
- if (me->outStream)
- {
- for (;;)
- {
- size_t cur = size;
- size_t written;
- if (cur > LZMA2DECMT_STREAM_WRITE_STEP)
- cur = LZMA2DECMT_STREAM_WRITE_STEP;
-
- written = ISeqOutStream_Write(me->outStream, data, cur);
-
- me->outProcessed += written;
- // me->mtc.writtenTotal += written;
- if (written != cur)
- return SZ_ERROR_WRITE;
- data += cur;
- size -= cur;
- if (size == 0)
- {
- *needContinue = needContinue2;
- return SZ_OK;
- }
- RINOK(MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0));
- }
- }
-
- return SZ_ERROR_FAIL;
- /*
- if (size > me->outBufSize)
- return SZ_ERROR_OUTPUT_EOF;
- memcpy(me->outBuf, data, size);
- me->outBufSize -= size;
- me->outBuf += size;
- *needContinue = needContinue2;
- return SZ_OK;
- */
-}
-
-#endif
-
-
-static SRes Lzma2Dec_Prepare_ST(CLzma2DecMt *p)
-{
- if (!p->dec_created)
- {
- Lzma2Dec_Construct(&p->dec);
- p->dec_created = True;
- }
-
- RINOK(Lzma2Dec_Allocate(&p->dec, p->prop, &p->alignOffsetAlloc.vt));
-
- if (!p->inBuf || p->inBufSize != p->props.inBufSize_ST)
- {
- ISzAlloc_Free(p->allocMid, p->inBuf);
- p->inBufSize = 0;
- p->inBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.inBufSize_ST);
- if (!p->inBuf)
- return SZ_ERROR_MEM;
- p->inBufSize = p->props.inBufSize_ST;
- }
-
- Lzma2Dec_Init(&p->dec);
-
- return SZ_OK;
-}
-
-
-static SRes Lzma2Dec_Decode_ST(CLzma2DecMt *p
- #ifndef _7ZIP_ST
- , BoolInt tMode
- #endif
- )
-{
- SizeT wrPos;
- size_t inPos, inLim;
- const Byte *inData;
- UInt64 inPrev, outPrev;
-
- CLzma2Dec *dec;
-
- #ifndef _7ZIP_ST
- if (tMode)
- {
- Lzma2DecMt_FreeOutBufs(p);
- tMode = MtDec_PrepareRead(&p->mtc);
- }
- #endif
-
- RINOK(Lzma2Dec_Prepare_ST(p));
-
- dec = &p->dec;
-
- inPrev = p->inProcessed;
- outPrev = p->outProcessed;
-
- inPos = 0;
- inLim = 0;
- inData = NULL;
- wrPos = dec->decoder.dicPos;
-
- for (;;)
- {
- SizeT dicPos;
- SizeT size;
- ELzmaFinishMode finishMode;
- SizeT inProcessed;
- ELzmaStatus status;
- SRes res;
-
- SizeT outProcessed;
- BoolInt outFinished;
- BoolInt needStop;
-
- if (inPos == inLim)
- {
- #ifndef _7ZIP_ST
- if (tMode)
- {
- inData = MtDec_Read(&p->mtc, &inLim);
- inPos = 0;
- if (inData)
- continue;
- tMode = False;
- inLim = 0;
- }
- #endif
-
- if (!p->readWasFinished)
- {
- inPos = 0;
- inLim = p->inBufSize;
- inData = p->inBuf;
- p->readRes = ISeqInStream_Read(p->inStream, (void *)inData, &inLim);
- // p->readProcessed += inLim;
- // inLim -= 5; p->readWasFinished = True; // for test
- if (inLim == 0 || p->readRes != SZ_OK)
- p->readWasFinished = True;
- }
- }
-
- dicPos = dec->decoder.dicPos;
- {
- SizeT next = dec->decoder.dicBufSize;
- if (next - wrPos > p->props.outStep_ST)
- next = wrPos + p->props.outStep_ST;
- size = next - dicPos;
- }
-
- finishMode = LZMA_FINISH_ANY;
- if (p->outSize_Defined)
- {
- const UInt64 rem = p->outSize - p->outProcessed;
- if (size >= rem)
- {
- size = (SizeT)rem;
- if (p->finishMode)
- finishMode = LZMA_FINISH_END;
- }
- }
-
- inProcessed = inLim - inPos;
-
- res = Lzma2Dec_DecodeToDic(dec, dicPos + size, inData + inPos, &inProcessed, finishMode, &status);
-
- inPos += inProcessed;
- p->inProcessed += inProcessed;
- outProcessed = dec->decoder.dicPos - dicPos;
- p->outProcessed += outProcessed;
-
- outFinished = (p->outSize_Defined && p->outSize <= p->outProcessed);
-
- needStop = (res != SZ_OK
- || (inProcessed == 0 && outProcessed == 0)
- || status == LZMA_STATUS_FINISHED_WITH_MARK
- || (!p->finishMode && outFinished));
-
- if (needStop || outProcessed >= size)
- {
- SRes res2;
- {
- size_t writeSize = dec->decoder.dicPos - wrPos;
- size_t written = ISeqOutStream_Write(p->outStream, dec->decoder.dic + wrPos, writeSize);
- res2 = (written == writeSize) ? SZ_OK : SZ_ERROR_WRITE;
- }
-
- if (dec->decoder.dicPos == dec->decoder.dicBufSize)
- dec->decoder.dicPos = 0;
- wrPos = dec->decoder.dicPos;
-
- RINOK(res2);
-
- if (needStop)
- {
- if (res != SZ_OK)
- return res;
-
- if (status == LZMA_STATUS_FINISHED_WITH_MARK)
- {
- if (p->finishMode)
- {
- if (p->outSize_Defined && p->outSize != p->outProcessed)
- return SZ_ERROR_DATA;
- }
- return SZ_OK;
- }
-
- if (!p->finishMode && outFinished)
- return SZ_OK;
-
- if (status == LZMA_STATUS_NEEDS_MORE_INPUT)
- return SZ_ERROR_INPUT_EOF;
-
- return SZ_ERROR_DATA;
- }
- }
-
- if (p->progress)
- {
- UInt64 inDelta = p->inProcessed - inPrev;
- UInt64 outDelta = p->outProcessed - outPrev;
- if (inDelta >= (1 << 22) || outDelta >= (1 << 22))
- {
- RINOK(ICompressProgress_Progress(p->progress, p->inProcessed, p->outProcessed));
- inPrev = p->inProcessed;
- outPrev = p->outProcessed;
- }
- }
- }
-}
-
-
-
-SRes Lzma2DecMt_Decode(CLzma2DecMtHandle pp,
- Byte prop,
- const CLzma2DecMtProps *props,
- ISeqOutStream *outStream, const UInt64 *outDataSize, int finishMode,
- // Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- // const Byte *inData, size_t inDataSize,
- UInt64 *inProcessed,
- // UInt64 *outProcessed,
- int *isMT,
- ICompressProgress *progress)
-{
- CLzma2DecMt *p = (CLzma2DecMt *)pp;
- #ifndef _7ZIP_ST
- BoolInt tMode;
- #endif
-
- *inProcessed = 0;
-
- if (prop > 40)
- return SZ_ERROR_UNSUPPORTED;
-
- p->prop = prop;
- p->props = *props;
-
- p->inStream = inStream;
- p->outStream = outStream;
- p->progress = progress;
-
- p->outSize = 0;
- p->outSize_Defined = False;
- if (outDataSize)
- {
- p->outSize_Defined = True;
- p->outSize = *outDataSize;
- }
- p->finishMode = finishMode;
-
- p->outProcessed = 0;
- p->inProcessed = 0;
-
- p->readWasFinished = False;
-
- *isMT = False;
-
-
- #ifndef _7ZIP_ST
-
- tMode = False;
-
- // p->mtc.parseRes = SZ_OK;
-
- // p->mtc.numFilledThreads = 0;
- // p->mtc.crossStart = 0;
- // p->mtc.crossEnd = 0;
- // p->mtc.allocError_for_Read_BlockIndex = 0;
- // p->mtc.isAllocError = False;
-
- if (p->props.numThreads > 1)
- {
- IMtDecCallback vt;
-
- Lzma2DecMt_FreeSt(p);
-
- p->outProcessed_Parse = 0;
-
- if (!p->mtc_WasConstructed)
- {
- p->mtc_WasConstructed = True;
- MtDec_Construct(&p->mtc);
- }
-
- p->mtc.progress = progress;
- p->mtc.inStream = inStream;
-
- // p->outBuf = NULL;
- // p->outBufSize = 0;
- /*
- if (!outStream)
- {
- // p->outBuf = outBuf;
- // p->outBufSize = *outBufSize;
- // *outBufSize = 0;
- return SZ_ERROR_PARAM;
- }
- */
-
- // p->mtc.inBlockMax = p->props.inBlockMax;
- p->mtc.alloc = &p->alignOffsetAlloc.vt;
- // p->alignOffsetAlloc.baseAlloc;
- // p->mtc.inData = inData;
- // p->mtc.inDataSize = inDataSize;
- p->mtc.mtCallback = &vt;
- p->mtc.mtCallbackObject = p;
-
- p->mtc.inBufSize = p->props.inBufSize_MT;
-
- p->mtc.numThreadsMax = p->props.numThreads;
-
- *isMT = True;
-
- vt.Parse = Lzma2DecMt_MtCallback_Parse;
- vt.PreCode = Lzma2DecMt_MtCallback_PreCode;
- vt.Code = Lzma2DecMt_MtCallback_Code;
- vt.Write = Lzma2DecMt_MtCallback_Write;
-
- {
- BoolInt needContinue = False;
-
- SRes res = MtDec_Code(&p->mtc);
-
- /*
- if (!outStream)
- *outBufSize = p->outBuf - outBuf;
- */
-
- *inProcessed = p->mtc.inProcessed;
-
- needContinue = False;
-
- if (res == SZ_OK)
- {
- if (p->mtc.mtProgress.res != SZ_OK)
- res = p->mtc.mtProgress.res;
- else
- needContinue = p->mtc.needContinue;
- }
-
- if (!needContinue)
- {
- if (res == SZ_OK)
- return p->mtc.readRes;
- return res;
- }
-
- tMode = True;
- p->readRes = p->mtc.readRes;
- p->readWasFinished = p->mtc.readWasFinished;
- p->inProcessed = p->mtc.inProcessed;
-
- PRF_STR("----- decoding ST -----");
- }
- }
-
- #endif
-
-
- *isMT = False;
-
- {
- SRes res = Lzma2Dec_Decode_ST(p
- #ifndef _7ZIP_ST
- , tMode
- #endif
- );
-
- *inProcessed = p->inProcessed;
-
- // res = SZ_OK; // for test
- if (res == SZ_OK && p->readRes != SZ_OK)
- res = p->readRes;
-
- /*
- #ifndef _7ZIP_ST
- if (res == SZ_OK && tMode && p->mtc.parseRes != SZ_OK)
- res = p->mtc.parseRes;
- #endif
- */
-
- return res;
- }
-}
-
-
-/* ---------- Read from CLzma2DecMtHandle Interface ---------- */
-
-SRes Lzma2DecMt_Init(CLzma2DecMtHandle pp,
- Byte prop,
- const CLzma2DecMtProps *props,
- const UInt64 *outDataSize, int finishMode,
- ISeqInStream *inStream)
-{
- CLzma2DecMt *p = (CLzma2DecMt *)pp;
-
- if (prop > 40)
- return SZ_ERROR_UNSUPPORTED;
-
- p->prop = prop;
- p->props = *props;
-
- p->inStream = inStream;
-
- p->outSize = 0;
- p->outSize_Defined = False;
- if (outDataSize)
- {
- p->outSize_Defined = True;
- p->outSize = *outDataSize;
- }
- p->finishMode = finishMode;
-
- p->outProcessed = 0;
- p->inProcessed = 0;
-
- p->inPos = 0;
- p->inLim = 0;
-
- return Lzma2Dec_Prepare_ST(p);
-}
-
-
-SRes Lzma2DecMt_Read(CLzma2DecMtHandle pp,
- Byte *data, size_t *outSize,
- UInt64 *inStreamProcessed)
-{
- CLzma2DecMt *p = (CLzma2DecMt *)pp;
- ELzmaFinishMode finishMode;
- SRes readRes;
- size_t size = *outSize;
-
- *outSize = 0;
- *inStreamProcessed = 0;
-
- finishMode = LZMA_FINISH_ANY;
- if (p->outSize_Defined)
- {
- const UInt64 rem = p->outSize - p->outProcessed;
- if (size >= rem)
- {
- size = (size_t)rem;
- if (p->finishMode)
- finishMode = LZMA_FINISH_END;
- }
- }
-
- readRes = SZ_OK;
-
- for (;;)
- {
- SizeT inCur;
- SizeT outCur;
- ELzmaStatus status;
- SRes res;
-
- if (p->inPos == p->inLim && readRes == SZ_OK)
- {
- p->inPos = 0;
- p->inLim = p->props.inBufSize_ST;
- readRes = ISeqInStream_Read(p->inStream, p->inBuf, &p->inLim);
- }
-
- inCur = p->inLim - p->inPos;
- outCur = size;
-
- res = Lzma2Dec_DecodeToBuf(&p->dec, data, &outCur,
- p->inBuf + p->inPos, &inCur, finishMode, &status);
-
- p->inPos += inCur;
- p->inProcessed += inCur;
- *inStreamProcessed += inCur;
- p->outProcessed += outCur;
- *outSize += outCur;
- size -= outCur;
- data += outCur;
-
- if (res != 0)
- return res;
-
- /*
- if (status == LZMA_STATUS_FINISHED_WITH_MARK)
- return readRes;
-
- if (size == 0 && status != LZMA_STATUS_NEEDS_MORE_INPUT)
- {
- if (p->finishMode && p->outSize_Defined && p->outProcessed >= p->outSize)
- return SZ_ERROR_DATA;
- return readRes;
- }
- */
-
- if (inCur == 0 && outCur == 0)
- return readRes;
- }
-}
+/* Lzma2DecMt.c -- LZMA2 Decoder Multi-thread
+2023-04-13 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+// #define SHOW_DEBUG_INFO
+// #define Z7_ST
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "Alloc.h"
+
+#include "Lzma2Dec.h"
+#include "Lzma2DecMt.h"
+
+#ifndef Z7_ST
+#include "MtDec.h"
+
+#define LZMA2DECMT_OUT_BLOCK_MAX_DEFAULT (1 << 28)
+#endif
+
+
+#ifndef Z7_ST
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+#define PRF_STR(s) PRF(printf("\n" s "\n");)
+#define PRF_STR_INT_2(s, d1, d2) PRF(printf("\n" s " %d %d\n", (unsigned)d1, (unsigned)d2);)
+#endif
+
+
+void Lzma2DecMtProps_Init(CLzma2DecMtProps *p)
+{
+ p->inBufSize_ST = 1 << 20;
+ p->outStep_ST = 1 << 20;
+
+ #ifndef Z7_ST
+ p->numThreads = 1;
+ p->inBufSize_MT = 1 << 18;
+ p->outBlockMax = LZMA2DECMT_OUT_BLOCK_MAX_DEFAULT;
+ p->inBlockMax = p->outBlockMax + p->outBlockMax / 16;
+ #endif
+}
+
+
+
+#ifndef Z7_ST
+
+/* ---------- CLzma2DecMtThread ---------- */
+
+typedef struct
+{
+ CLzma2Dec dec;
+ Byte dec_created;
+ Byte needInit;
+
+ Byte *outBuf;
+ size_t outBufSize;
+
+ EMtDecParseState state;
+ ELzma2ParseStatus parseStatus;
+
+ size_t inPreSize;
+ size_t outPreSize;
+
+ size_t inCodeSize;
+ size_t outCodeSize;
+ SRes codeRes;
+
+ CAlignOffsetAlloc alloc;
+
+ Byte mtPad[1 << 7];
+} CLzma2DecMtThread;
+
+#endif
+
+
+/* ---------- CLzma2DecMt ---------- */
+
+struct CLzma2DecMt
+{
+ // ISzAllocPtr alloc;
+ ISzAllocPtr allocMid;
+
+ CAlignOffsetAlloc alignOffsetAlloc;
+ CLzma2DecMtProps props;
+ Byte prop;
+
+ ISeqInStreamPtr inStream;
+ ISeqOutStreamPtr outStream;
+ ICompressProgressPtr progress;
+
+ BoolInt finishMode;
+ BoolInt outSize_Defined;
+ UInt64 outSize;
+
+ UInt64 outProcessed;
+ UInt64 inProcessed;
+ BoolInt readWasFinished;
+ SRes readRes;
+
+ Byte *inBuf;
+ size_t inBufSize;
+ Byte dec_created;
+ CLzma2Dec dec;
+
+ size_t inPos;
+ size_t inLim;
+
+ #ifndef Z7_ST
+ UInt64 outProcessed_Parse;
+ BoolInt mtc_WasConstructed;
+ CMtDec mtc;
+ CLzma2DecMtThread coders[MTDEC_THREADS_MAX];
+ #endif
+};
+
+
+
+CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
+{
+ CLzma2DecMt *p = (CLzma2DecMt *)ISzAlloc_Alloc(alloc, sizeof(CLzma2DecMt));
+ if (!p)
+ return NULL;
+
+ // p->alloc = alloc;
+ p->allocMid = allocMid;
+
+ AlignOffsetAlloc_CreateVTable(&p->alignOffsetAlloc);
+ p->alignOffsetAlloc.numAlignBits = 7;
+ p->alignOffsetAlloc.offset = 0;
+ p->alignOffsetAlloc.baseAlloc = alloc;
+
+ p->inBuf = NULL;
+ p->inBufSize = 0;
+ p->dec_created = False;
+
+ // Lzma2DecMtProps_Init(&p->props);
+
+ #ifndef Z7_ST
+ p->mtc_WasConstructed = False;
+ {
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CLzma2DecMtThread *t = &p->coders[i];
+ t->dec_created = False;
+ t->outBuf = NULL;
+ t->outBufSize = 0;
+ }
+ }
+ #endif
+
+ return (CLzma2DecMtHandle)(void *)p;
+}
+
+
+#ifndef Z7_ST
+
+static void Lzma2DecMt_FreeOutBufs(CLzma2DecMt *p)
+{
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CLzma2DecMtThread *t = &p->coders[i];
+ if (t->outBuf)
+ {
+ ISzAlloc_Free(p->allocMid, t->outBuf);
+ t->outBuf = NULL;
+ t->outBufSize = 0;
+ }
+ }
+}
+
+#endif
+
+
+static void Lzma2DecMt_FreeSt(CLzma2DecMt *p)
+{
+ if (p->dec_created)
+ {
+ Lzma2Dec_Free(&p->dec, &p->alignOffsetAlloc.vt);
+ p->dec_created = False;
+ }
+ if (p->inBuf)
+ {
+ ISzAlloc_Free(p->allocMid, p->inBuf);
+ p->inBuf = NULL;
+ }
+ p->inBufSize = 0;
+}
+
+
+// #define GET_CLzma2DecMt_p CLzma2DecMt *p = (CLzma2DecMt *)(void *)pp;
+
+void Lzma2DecMt_Destroy(CLzma2DecMtHandle p)
+{
+ // GET_CLzma2DecMt_p
+
+ Lzma2DecMt_FreeSt(p);
+
+ #ifndef Z7_ST
+
+ if (p->mtc_WasConstructed)
+ {
+ MtDec_Destruct(&p->mtc);
+ p->mtc_WasConstructed = False;
+ }
+ {
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CLzma2DecMtThread *t = &p->coders[i];
+ if (t->dec_created)
+ {
+ // we don't need to free dict here
+ Lzma2Dec_FreeProbs(&t->dec, &t->alloc.vt); // p->alloc !!!
+ t->dec_created = False;
+ }
+ }
+ }
+ Lzma2DecMt_FreeOutBufs(p);
+
+ #endif
+
+ ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, p);
+}
+
+
+
+#ifndef Z7_ST
+
+static void Lzma2DecMt_MtCallback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
+{
+ CLzma2DecMt *me = (CLzma2DecMt *)obj;
+ CLzma2DecMtThread *t = &me->coders[coderIndex];
+
+ PRF_STR_INT_2("Parse", coderIndex, cc->srcSize)
+
+ cc->state = MTDEC_PARSE_CONTINUE;
+
+ if (cc->startCall)
+ {
+ if (!t->dec_created)
+ {
+ Lzma2Dec_CONSTRUCT(&t->dec)
+ t->dec_created = True;
+ AlignOffsetAlloc_CreateVTable(&t->alloc);
+ {
+ /* (1 << 12) is expected size of one way in data cache.
+ We optimize alignment for cache line size of 128 bytes and smaller */
+ const unsigned kNumAlignBits = 12;
+ const unsigned kNumCacheLineBits = 7; /* <= kNumAlignBits */
+ t->alloc.numAlignBits = kNumAlignBits;
+ t->alloc.offset = ((UInt32)coderIndex * (((unsigned)1 << 11) + (1 << 8) + (1 << 6))) & (((unsigned)1 << kNumAlignBits) - ((unsigned)1 << kNumCacheLineBits));
+ t->alloc.baseAlloc = me->alignOffsetAlloc.baseAlloc;
+ }
+ }
+ Lzma2Dec_Init(&t->dec);
+
+ t->inPreSize = 0;
+ t->outPreSize = 0;
+ // t->blockWasFinished = False;
+ // t->finishedWithMark = False;
+ t->parseStatus = (ELzma2ParseStatus)LZMA_STATUS_NOT_SPECIFIED;
+ t->state = MTDEC_PARSE_CONTINUE;
+
+ t->inCodeSize = 0;
+ t->outCodeSize = 0;
+ t->codeRes = SZ_OK;
+
+ // (cc->srcSize == 0) is allowed
+ }
+
+ {
+ ELzma2ParseStatus status;
+ BoolInt overflow;
+ UInt32 unpackRem = 0;
+
+ int checkFinishBlock = True;
+ size_t limit = me->props.outBlockMax;
+ if (me->outSize_Defined)
+ {
+ UInt64 rem = me->outSize - me->outProcessed_Parse;
+ if (limit >= rem)
+ {
+ limit = (size_t)rem;
+ if (!me->finishMode)
+ checkFinishBlock = False;
+ }
+ }
+
+ // checkFinishBlock = False, if we want to decode partial data
+ // that must be finished at position <= outBlockMax.
+
+ {
+ const size_t srcOrig = cc->srcSize;
+ SizeT srcSize_Point = 0;
+ SizeT dicPos_Point = 0;
+
+ cc->srcSize = 0;
+ overflow = False;
+
+ for (;;)
+ {
+ SizeT srcCur = (SizeT)(srcOrig - cc->srcSize);
+
+ status = Lzma2Dec_Parse(&t->dec,
+ (SizeT)limit - t->dec.decoder.dicPos,
+ cc->src + cc->srcSize, &srcCur,
+ checkFinishBlock);
+
+ cc->srcSize += srcCur;
+
+ if (status == LZMA2_PARSE_STATUS_NEW_CHUNK)
+ {
+ if (t->dec.unpackSize > me->props.outBlockMax - t->dec.decoder.dicPos)
+ {
+ overflow = True;
+ break;
+ }
+ continue;
+ }
+
+ if (status == LZMA2_PARSE_STATUS_NEW_BLOCK)
+ {
+ if (t->dec.decoder.dicPos == 0)
+ continue;
+ // we decode small blocks in one thread
+ if (t->dec.decoder.dicPos >= (1 << 14))
+ break;
+ dicPos_Point = t->dec.decoder.dicPos;
+ srcSize_Point = (SizeT)cc->srcSize;
+ continue;
+ }
+
+ if ((int)status == LZMA_STATUS_NOT_FINISHED && checkFinishBlock
+ // && limit == t->dec.decoder.dicPos
+ // && limit == me->props.outBlockMax
+ )
+ {
+ overflow = True;
+ break;
+ }
+
+ unpackRem = Lzma2Dec_GetUnpackExtra(&t->dec);
+ break;
+ }
+
+ if (dicPos_Point != 0
+ && (int)status != LZMA2_PARSE_STATUS_NEW_BLOCK
+ && (int)status != LZMA_STATUS_FINISHED_WITH_MARK
+ && (int)status != LZMA_STATUS_NOT_SPECIFIED)
+ {
+ // we revert to latest newBlock state
+ status = LZMA2_PARSE_STATUS_NEW_BLOCK;
+ unpackRem = 0;
+ t->dec.decoder.dicPos = dicPos_Point;
+ cc->srcSize = srcSize_Point;
+ overflow = False;
+ }
+ }
+
+ t->inPreSize += cc->srcSize;
+ t->parseStatus = status;
+
+ if (overflow)
+ cc->state = MTDEC_PARSE_OVERFLOW;
+ else
+ {
+ size_t dicPos = t->dec.decoder.dicPos;
+
+ if ((int)status != LZMA_STATUS_NEEDS_MORE_INPUT)
+ {
+ if (status == LZMA2_PARSE_STATUS_NEW_BLOCK)
+ {
+ cc->state = MTDEC_PARSE_NEW;
+ cc->srcSize--; // we don't need control byte of next block
+ t->inPreSize--;
+ }
+ else
+ {
+ cc->state = MTDEC_PARSE_END;
+ if ((int)status != LZMA_STATUS_FINISHED_WITH_MARK)
+ {
+ // (status == LZMA_STATUS_NOT_SPECIFIED)
+ // (status == LZMA_STATUS_NOT_FINISHED)
+ if (unpackRem != 0)
+ {
+ /* we also reserve space for max possible number of output bytes of current LZMA chunk */
+ size_t rem = limit - dicPos;
+ if (rem > unpackRem)
+ rem = unpackRem;
+ dicPos += rem;
+ }
+ }
+ }
+
+ me->outProcessed_Parse += dicPos;
+ }
+
+ cc->outPos = dicPos;
+ t->outPreSize = (size_t)dicPos;
+ }
+
+ t->state = cc->state;
+ return;
+ }
+}
+
+
+static SRes Lzma2DecMt_MtCallback_PreCode(void *pp, unsigned coderIndex)
+{
+ CLzma2DecMt *me = (CLzma2DecMt *)pp;
+ CLzma2DecMtThread *t = &me->coders[coderIndex];
+ Byte *dest = t->outBuf;
+
+ if (t->inPreSize == 0)
+ {
+ t->codeRes = SZ_ERROR_DATA;
+ return t->codeRes;
+ }
+
+ if (!dest || t->outBufSize < t->outPreSize)
+ {
+ if (dest)
+ {
+ ISzAlloc_Free(me->allocMid, dest);
+ t->outBuf = NULL;
+ t->outBufSize = 0;
+ }
+
+ dest = (Byte *)ISzAlloc_Alloc(me->allocMid, t->outPreSize
+ // + (1 << 28)
+ );
+ // Sleep(200);
+ if (!dest)
+ return SZ_ERROR_MEM;
+ t->outBuf = dest;
+ t->outBufSize = t->outPreSize;
+ }
+
+ t->dec.decoder.dic = dest;
+ t->dec.decoder.dicBufSize = (SizeT)t->outPreSize;
+
+ t->needInit = True;
+
+ return Lzma2Dec_AllocateProbs(&t->dec, me->prop, &t->alloc.vt); // alloc.vt
+}
+
+
+static SRes Lzma2DecMt_MtCallback_Code(void *pp, unsigned coderIndex,
+ const Byte *src, size_t srcSize, int srcFinished,
+ // int finished, int blockFinished,
+ UInt64 *inCodePos, UInt64 *outCodePos, int *stop)
+{
+ CLzma2DecMt *me = (CLzma2DecMt *)pp;
+ CLzma2DecMtThread *t = &me->coders[coderIndex];
+
+ UNUSED_VAR(srcFinished)
+
+ PRF_STR_INT_2("Code", coderIndex, srcSize)
+
+ *inCodePos = t->inCodeSize;
+ *outCodePos = 0;
+ *stop = True;
+
+ if (t->needInit)
+ {
+ Lzma2Dec_Init(&t->dec);
+ t->needInit = False;
+ }
+
+ {
+ ELzmaStatus status;
+ SizeT srcProcessed = (SizeT)srcSize;
+ BoolInt blockWasFinished =
+ ((int)t->parseStatus == LZMA_STATUS_FINISHED_WITH_MARK
+ || t->parseStatus == LZMA2_PARSE_STATUS_NEW_BLOCK);
+
+ SRes res = Lzma2Dec_DecodeToDic(&t->dec,
+ (SizeT)t->outPreSize,
+ src, &srcProcessed,
+ blockWasFinished ? LZMA_FINISH_END : LZMA_FINISH_ANY,
+ &status);
+
+ t->codeRes = res;
+
+ t->inCodeSize += srcProcessed;
+ *inCodePos = t->inCodeSize;
+ t->outCodeSize = t->dec.decoder.dicPos;
+ *outCodePos = t->dec.decoder.dicPos;
+
+ if (res != SZ_OK)
+ return res;
+
+ if (srcProcessed == srcSize)
+ *stop = False;
+
+ if (blockWasFinished)
+ {
+ if (srcSize != srcProcessed)
+ return SZ_ERROR_FAIL;
+
+ if (t->inPreSize == t->inCodeSize)
+ {
+ if (t->outPreSize != t->outCodeSize)
+ return SZ_ERROR_FAIL;
+ *stop = True;
+ }
+ }
+ else
+ {
+ if (t->outPreSize == t->outCodeSize)
+ *stop = True;
+ }
+
+ return SZ_OK;
+ }
+}
+
+
+#define LZMA2DECMT_STREAM_WRITE_STEP (1 << 24)
+
+static SRes Lzma2DecMt_MtCallback_Write(void *pp, unsigned coderIndex,
+ BoolInt needWriteToStream,
+ const Byte *src, size_t srcSize, BoolInt isCross,
+ BoolInt *needContinue, BoolInt *canRecode)
+{
+ CLzma2DecMt *me = (CLzma2DecMt *)pp;
+ const CLzma2DecMtThread *t = &me->coders[coderIndex];
+ size_t size = t->outCodeSize;
+ const Byte *data = t->outBuf;
+ BoolInt needContinue2 = True;
+
+ UNUSED_VAR(src)
+ UNUSED_VAR(srcSize)
+ UNUSED_VAR(isCross)
+
+ PRF_STR_INT_2("Write", coderIndex, srcSize)
+
+ *needContinue = False;
+ *canRecode = True;
+
+ if (
+ // t->parseStatus == LZMA_STATUS_FINISHED_WITH_MARK
+ t->state == MTDEC_PARSE_OVERFLOW
+ || t->state == MTDEC_PARSE_END)
+ needContinue2 = False;
+
+
+ if (!needWriteToStream)
+ return SZ_OK;
+
+ me->mtc.inProcessed += t->inCodeSize;
+
+ if (t->codeRes == SZ_OK)
+ if ((int)t->parseStatus == LZMA_STATUS_FINISHED_WITH_MARK
+ || t->parseStatus == LZMA2_PARSE_STATUS_NEW_BLOCK)
+ if (t->outPreSize != t->outCodeSize
+ || t->inPreSize != t->inCodeSize)
+ return SZ_ERROR_FAIL;
+
+ *canRecode = False;
+
+ if (me->outStream)
+ {
+ for (;;)
+ {
+ size_t cur = size;
+ size_t written;
+ if (cur > LZMA2DECMT_STREAM_WRITE_STEP)
+ cur = LZMA2DECMT_STREAM_WRITE_STEP;
+
+ written = ISeqOutStream_Write(me->outStream, data, cur);
+
+ me->outProcessed += written;
+ // me->mtc.writtenTotal += written;
+ if (written != cur)
+ return SZ_ERROR_WRITE;
+ data += cur;
+ size -= cur;
+ if (size == 0)
+ {
+ *needContinue = needContinue2;
+ return SZ_OK;
+ }
+ RINOK(MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0))
+ }
+ }
+
+ return SZ_ERROR_FAIL;
+ /*
+ if (size > me->outBufSize)
+ return SZ_ERROR_OUTPUT_EOF;
+ memcpy(me->outBuf, data, size);
+ me->outBufSize -= size;
+ me->outBuf += size;
+ *needContinue = needContinue2;
+ return SZ_OK;
+ */
+}
+
+#endif
+
+
+static SRes Lzma2Dec_Prepare_ST(CLzma2DecMt *p)
+{
+ if (!p->dec_created)
+ {
+ Lzma2Dec_CONSTRUCT(&p->dec)
+ p->dec_created = True;
+ }
+
+ RINOK(Lzma2Dec_Allocate(&p->dec, p->prop, &p->alignOffsetAlloc.vt))
+
+ if (!p->inBuf || p->inBufSize != p->props.inBufSize_ST)
+ {
+ ISzAlloc_Free(p->allocMid, p->inBuf);
+ p->inBufSize = 0;
+ p->inBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.inBufSize_ST);
+ if (!p->inBuf)
+ return SZ_ERROR_MEM;
+ p->inBufSize = p->props.inBufSize_ST;
+ }
+
+ Lzma2Dec_Init(&p->dec);
+
+ return SZ_OK;
+}
+
+
+static SRes Lzma2Dec_Decode_ST(CLzma2DecMt *p
+ #ifndef Z7_ST
+ , BoolInt tMode
+ #endif
+ )
+{
+ SizeT wrPos;
+ size_t inPos, inLim;
+ const Byte *inData;
+ UInt64 inPrev, outPrev;
+
+ CLzma2Dec *dec;
+
+ #ifndef Z7_ST
+ if (tMode)
+ {
+ Lzma2DecMt_FreeOutBufs(p);
+ tMode = MtDec_PrepareRead(&p->mtc);
+ }
+ #endif
+
+ RINOK(Lzma2Dec_Prepare_ST(p))
+
+ dec = &p->dec;
+
+ inPrev = p->inProcessed;
+ outPrev = p->outProcessed;
+
+ inPos = 0;
+ inLim = 0;
+ inData = NULL;
+ wrPos = dec->decoder.dicPos;
+
+ for (;;)
+ {
+ SizeT dicPos;
+ SizeT size;
+ ELzmaFinishMode finishMode;
+ SizeT inProcessed;
+ ELzmaStatus status;
+ SRes res;
+
+ SizeT outProcessed;
+ BoolInt outFinished;
+ BoolInt needStop;
+
+ if (inPos == inLim)
+ {
+ #ifndef Z7_ST
+ if (tMode)
+ {
+ inData = MtDec_Read(&p->mtc, &inLim);
+ inPos = 0;
+ if (inData)
+ continue;
+ tMode = False;
+ inLim = 0;
+ }
+ #endif
+
+ if (!p->readWasFinished)
+ {
+ inPos = 0;
+ inLim = p->inBufSize;
+ inData = p->inBuf;
+ p->readRes = ISeqInStream_Read(p->inStream, (void *)(p->inBuf), &inLim);
+ // p->readProcessed += inLim;
+ // inLim -= 5; p->readWasFinished = True; // for test
+ if (inLim == 0 || p->readRes != SZ_OK)
+ p->readWasFinished = True;
+ }
+ }
+
+ dicPos = dec->decoder.dicPos;
+ {
+ SizeT next = dec->decoder.dicBufSize;
+ if (next - wrPos > p->props.outStep_ST)
+ next = wrPos + (SizeT)p->props.outStep_ST;
+ size = next - dicPos;
+ }
+
+ finishMode = LZMA_FINISH_ANY;
+ if (p->outSize_Defined)
+ {
+ const UInt64 rem = p->outSize - p->outProcessed;
+ if (size >= rem)
+ {
+ size = (SizeT)rem;
+ if (p->finishMode)
+ finishMode = LZMA_FINISH_END;
+ }
+ }
+
+ inProcessed = (SizeT)(inLim - inPos);
+
+ res = Lzma2Dec_DecodeToDic(dec, dicPos + size, inData + inPos, &inProcessed, finishMode, &status);
+
+ inPos += inProcessed;
+ p->inProcessed += inProcessed;
+ outProcessed = dec->decoder.dicPos - dicPos;
+ p->outProcessed += outProcessed;
+
+ outFinished = (p->outSize_Defined && p->outSize <= p->outProcessed);
+
+ needStop = (res != SZ_OK
+ || (inProcessed == 0 && outProcessed == 0)
+ || status == LZMA_STATUS_FINISHED_WITH_MARK
+ || (!p->finishMode && outFinished));
+
+ if (needStop || outProcessed >= size)
+ {
+ SRes res2;
+ {
+ size_t writeSize = dec->decoder.dicPos - wrPos;
+ size_t written = ISeqOutStream_Write(p->outStream, dec->decoder.dic + wrPos, writeSize);
+ res2 = (written == writeSize) ? SZ_OK : SZ_ERROR_WRITE;
+ }
+
+ if (dec->decoder.dicPos == dec->decoder.dicBufSize)
+ dec->decoder.dicPos = 0;
+ wrPos = dec->decoder.dicPos;
+
+ RINOK(res2)
+
+ if (needStop)
+ {
+ if (res != SZ_OK)
+ return res;
+
+ if (status == LZMA_STATUS_FINISHED_WITH_MARK)
+ {
+ if (p->finishMode)
+ {
+ if (p->outSize_Defined && p->outSize != p->outProcessed)
+ return SZ_ERROR_DATA;
+ }
+ return SZ_OK;
+ }
+
+ if (!p->finishMode && outFinished)
+ return SZ_OK;
+
+ if (status == LZMA_STATUS_NEEDS_MORE_INPUT)
+ return SZ_ERROR_INPUT_EOF;
+
+ return SZ_ERROR_DATA;
+ }
+ }
+
+ if (p->progress)
+ {
+ UInt64 inDelta = p->inProcessed - inPrev;
+ UInt64 outDelta = p->outProcessed - outPrev;
+ if (inDelta >= (1 << 22) || outDelta >= (1 << 22))
+ {
+ RINOK(ICompressProgress_Progress(p->progress, p->inProcessed, p->outProcessed))
+ inPrev = p->inProcessed;
+ outPrev = p->outProcessed;
+ }
+ }
+ }
+}
+
+
+
+SRes Lzma2DecMt_Decode(CLzma2DecMtHandle p,
+ Byte prop,
+ const CLzma2DecMtProps *props,
+ ISeqOutStreamPtr outStream, const UInt64 *outDataSize, int finishMode,
+ // Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ // const Byte *inData, size_t inDataSize,
+ UInt64 *inProcessed,
+ // UInt64 *outProcessed,
+ int *isMT,
+ ICompressProgressPtr progress)
+{
+ // GET_CLzma2DecMt_p
+ #ifndef Z7_ST
+ BoolInt tMode;
+ #endif
+
+ *inProcessed = 0;
+
+ if (prop > 40)
+ return SZ_ERROR_UNSUPPORTED;
+
+ p->prop = prop;
+ p->props = *props;
+
+ p->inStream = inStream;
+ p->outStream = outStream;
+ p->progress = progress;
+
+ p->outSize = 0;
+ p->outSize_Defined = False;
+ if (outDataSize)
+ {
+ p->outSize_Defined = True;
+ p->outSize = *outDataSize;
+ }
+ p->finishMode = finishMode;
+
+ p->outProcessed = 0;
+ p->inProcessed = 0;
+
+ p->readWasFinished = False;
+ p->readRes = SZ_OK;
+
+ *isMT = False;
+
+
+ #ifndef Z7_ST
+
+ tMode = False;
+
+ // p->mtc.parseRes = SZ_OK;
+
+ // p->mtc.numFilledThreads = 0;
+ // p->mtc.crossStart = 0;
+ // p->mtc.crossEnd = 0;
+ // p->mtc.allocError_for_Read_BlockIndex = 0;
+ // p->mtc.isAllocError = False;
+
+ if (p->props.numThreads > 1)
+ {
+ IMtDecCallback2 vt;
+
+ Lzma2DecMt_FreeSt(p);
+
+ p->outProcessed_Parse = 0;
+
+ if (!p->mtc_WasConstructed)
+ {
+ p->mtc_WasConstructed = True;
+ MtDec_Construct(&p->mtc);
+ }
+
+ p->mtc.progress = progress;
+ p->mtc.inStream = inStream;
+
+ // p->outBuf = NULL;
+ // p->outBufSize = 0;
+ /*
+ if (!outStream)
+ {
+ // p->outBuf = outBuf;
+ // p->outBufSize = *outBufSize;
+ // *outBufSize = 0;
+ return SZ_ERROR_PARAM;
+ }
+ */
+
+ // p->mtc.inBlockMax = p->props.inBlockMax;
+ p->mtc.alloc = &p->alignOffsetAlloc.vt;
+ // p->alignOffsetAlloc.baseAlloc;
+ // p->mtc.inData = inData;
+ // p->mtc.inDataSize = inDataSize;
+ p->mtc.mtCallback = &vt;
+ p->mtc.mtCallbackObject = p;
+
+ p->mtc.inBufSize = p->props.inBufSize_MT;
+
+ p->mtc.numThreadsMax = p->props.numThreads;
+
+ *isMT = True;
+
+ vt.Parse = Lzma2DecMt_MtCallback_Parse;
+ vt.PreCode = Lzma2DecMt_MtCallback_PreCode;
+ vt.Code = Lzma2DecMt_MtCallback_Code;
+ vt.Write = Lzma2DecMt_MtCallback_Write;
+
+ {
+ BoolInt needContinue = False;
+
+ SRes res = MtDec_Code(&p->mtc);
+
+ /*
+ if (!outStream)
+ *outBufSize = p->outBuf - outBuf;
+ */
+
+ *inProcessed = p->mtc.inProcessed;
+
+ needContinue = False;
+
+ if (res == SZ_OK)
+ {
+ if (p->mtc.mtProgress.res != SZ_OK)
+ res = p->mtc.mtProgress.res;
+ else
+ needContinue = p->mtc.needContinue;
+ }
+
+ if (!needContinue)
+ {
+ if (res == SZ_OK)
+ return p->mtc.readRes;
+ return res;
+ }
+
+ tMode = True;
+ p->readRes = p->mtc.readRes;
+ p->readWasFinished = p->mtc.readWasFinished;
+ p->inProcessed = p->mtc.inProcessed;
+
+ PRF_STR("----- decoding ST -----")
+ }
+ }
+
+ #endif
+
+
+ *isMT = False;
+
+ {
+ SRes res = Lzma2Dec_Decode_ST(p
+ #ifndef Z7_ST
+ , tMode
+ #endif
+ );
+
+ *inProcessed = p->inProcessed;
+
+ // res = SZ_OK; // for test
+ if (res == SZ_ERROR_INPUT_EOF)
+ {
+ if (p->readRes != SZ_OK)
+ res = p->readRes;
+ }
+ else if (res == SZ_OK && p->readRes != SZ_OK)
+ res = p->readRes;
+
+ /*
+ #ifndef Z7_ST
+ if (res == SZ_OK && tMode && p->mtc.parseRes != SZ_OK)
+ res = p->mtc.parseRes;
+ #endif
+ */
+
+ return res;
+ }
+}
+
+
+/* ---------- Read from CLzma2DecMtHandle Interface ---------- */
+
+SRes Lzma2DecMt_Init(CLzma2DecMtHandle p,
+ Byte prop,
+ const CLzma2DecMtProps *props,
+ const UInt64 *outDataSize, int finishMode,
+ ISeqInStreamPtr inStream)
+{
+ // GET_CLzma2DecMt_p
+
+ if (prop > 40)
+ return SZ_ERROR_UNSUPPORTED;
+
+ p->prop = prop;
+ p->props = *props;
+
+ p->inStream = inStream;
+
+ p->outSize = 0;
+ p->outSize_Defined = False;
+ if (outDataSize)
+ {
+ p->outSize_Defined = True;
+ p->outSize = *outDataSize;
+ }
+ p->finishMode = finishMode;
+
+ p->outProcessed = 0;
+ p->inProcessed = 0;
+
+ p->inPos = 0;
+ p->inLim = 0;
+
+ return Lzma2Dec_Prepare_ST(p);
+}
+
+
+SRes Lzma2DecMt_Read(CLzma2DecMtHandle p,
+ Byte *data, size_t *outSize,
+ UInt64 *inStreamProcessed)
+{
+ // GET_CLzma2DecMt_p
+ ELzmaFinishMode finishMode;
+ SRes readRes;
+ size_t size = *outSize;
+
+ *outSize = 0;
+ *inStreamProcessed = 0;
+
+ finishMode = LZMA_FINISH_ANY;
+ if (p->outSize_Defined)
+ {
+ const UInt64 rem = p->outSize - p->outProcessed;
+ if (size >= rem)
+ {
+ size = (size_t)rem;
+ if (p->finishMode)
+ finishMode = LZMA_FINISH_END;
+ }
+ }
+
+ readRes = SZ_OK;
+
+ for (;;)
+ {
+ SizeT inCur;
+ SizeT outCur;
+ ELzmaStatus status;
+ SRes res;
+
+ if (p->inPos == p->inLim && readRes == SZ_OK)
+ {
+ p->inPos = 0;
+ p->inLim = p->props.inBufSize_ST;
+ readRes = ISeqInStream_Read(p->inStream, p->inBuf, &p->inLim);
+ }
+
+ inCur = (SizeT)(p->inLim - p->inPos);
+ outCur = (SizeT)size;
+
+ res = Lzma2Dec_DecodeToBuf(&p->dec, data, &outCur,
+ p->inBuf + p->inPos, &inCur, finishMode, &status);
+
+ p->inPos += inCur;
+ p->inProcessed += inCur;
+ *inStreamProcessed += inCur;
+ p->outProcessed += outCur;
+ *outSize += outCur;
+ size -= outCur;
+ data += outCur;
+
+ if (res != 0)
+ return res;
+
+ /*
+ if (status == LZMA_STATUS_FINISHED_WITH_MARK)
+ return readRes;
+
+ if (size == 0 && status != LZMA_STATUS_NEEDS_MORE_INPUT)
+ {
+ if (p->finishMode && p->outSize_Defined && p->outProcessed >= p->outSize)
+ return SZ_ERROR_DATA;
+ return readRes;
+ }
+ */
+
+ if (inCur == 0 && outCur == 0)
+ return readRes;
+ }
+}
+
+#undef PRF
+#undef PRF_STR
+#undef PRF_STR_INT_2
diff --git a/C/Lzma2DecMt.h b/C/Lzma2DecMt.h
index 96f89a3..93a5cd5 100644
--- a/C/Lzma2DecMt.h
+++ b/C/Lzma2DecMt.h
@@ -1,79 +1,81 @@
-/* Lzma2DecMt.h -- LZMA2 Decoder Multi-thread
-2018-02-17 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA2_DEC_MT_H
-#define __LZMA2_DEC_MT_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-typedef struct
-{
- size_t inBufSize_ST;
- size_t outStep_ST;
-
- #ifndef _7ZIP_ST
- unsigned numThreads;
- size_t inBufSize_MT;
- size_t outBlockMax;
- size_t inBlockMax;
- #endif
-} CLzma2DecMtProps;
-
-/* init to single-thread mode */
-void Lzma2DecMtProps_Init(CLzma2DecMtProps *p);
-
-
-/* ---------- CLzma2DecMtHandle Interface ---------- */
-
-/* Lzma2DecMt_ * functions can return the following exit codes:
-SRes:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_PARAM - Incorrect paramater in props
- SZ_ERROR_WRITE - ISeqOutStream write callback error
- // SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
- SZ_ERROR_PROGRESS - some break from progress callback
- SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
-*/
-
-typedef void * CLzma2DecMtHandle;
-
-CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid);
-void Lzma2DecMt_Destroy(CLzma2DecMtHandle p);
-
-SRes Lzma2DecMt_Decode(CLzma2DecMtHandle p,
- Byte prop,
- const CLzma2DecMtProps *props,
- ISeqOutStream *outStream,
- const UInt64 *outDataSize, // NULL means undefined
- int finishMode, // 0 - partial unpacking is allowed, 1 - if lzma2 stream must be finished
- // Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- // const Byte *inData, size_t inDataSize,
-
- // out variables:
- UInt64 *inProcessed,
- int *isMT, /* out: (*isMT == 0), if single thread decoding was used */
-
- // UInt64 *outProcessed,
- ICompressProgress *progress);
-
-
-/* ---------- Read from CLzma2DecMtHandle Interface ---------- */
-
-SRes Lzma2DecMt_Init(CLzma2DecMtHandle pp,
- Byte prop,
- const CLzma2DecMtProps *props,
- const UInt64 *outDataSize, int finishMode,
- ISeqInStream *inStream);
-
-SRes Lzma2DecMt_Read(CLzma2DecMtHandle pp,
- Byte *data, size_t *outSize,
- UInt64 *inStreamProcessed);
-
-
-EXTERN_C_END
-
-#endif
+/* Lzma2DecMt.h -- LZMA2 Decoder Multi-thread
+2023-04-13 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA2_DEC_MT_H
+#define ZIP7_INC_LZMA2_DEC_MT_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+typedef struct
+{
+ size_t inBufSize_ST;
+ size_t outStep_ST;
+
+ #ifndef Z7_ST
+ unsigned numThreads;
+ size_t inBufSize_MT;
+ size_t outBlockMax;
+ size_t inBlockMax;
+ #endif
+} CLzma2DecMtProps;
+
+/* init to single-thread mode */
+void Lzma2DecMtProps_Init(CLzma2DecMtProps *p);
+
+
+/* ---------- CLzma2DecMtHandle Interface ---------- */
+
+/* Lzma2DecMt_ * functions can return the following exit codes:
+SRes:
+ SZ_OK - OK
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_PARAM - Incorrect paramater in props
+ SZ_ERROR_WRITE - ISeqOutStream write callback error
+ // SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
+ SZ_ERROR_PROGRESS - some break from progress callback
+ SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
+*/
+
+typedef struct CLzma2DecMt CLzma2DecMt;
+typedef CLzma2DecMt * CLzma2DecMtHandle;
+// Z7_DECLARE_HANDLE(CLzma2DecMtHandle)
+
+CLzma2DecMtHandle Lzma2DecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid);
+void Lzma2DecMt_Destroy(CLzma2DecMtHandle p);
+
+SRes Lzma2DecMt_Decode(CLzma2DecMtHandle p,
+ Byte prop,
+ const CLzma2DecMtProps *props,
+ ISeqOutStreamPtr outStream,
+ const UInt64 *outDataSize, // NULL means undefined
+ int finishMode, // 0 - partial unpacking is allowed, 1 - if lzma2 stream must be finished
+ // Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ // const Byte *inData, size_t inDataSize,
+
+ // out variables:
+ UInt64 *inProcessed,
+ int *isMT, /* out: (*isMT == 0), if single thread decoding was used */
+
+ // UInt64 *outProcessed,
+ ICompressProgressPtr progress);
+
+
+/* ---------- Read from CLzma2DecMtHandle Interface ---------- */
+
+SRes Lzma2DecMt_Init(CLzma2DecMtHandle pp,
+ Byte prop,
+ const CLzma2DecMtProps *props,
+ const UInt64 *outDataSize, int finishMode,
+ ISeqInStreamPtr inStream);
+
+SRes Lzma2DecMt_Read(CLzma2DecMtHandle pp,
+ Byte *data, size_t *outSize,
+ UInt64 *inStreamProcessed);
+
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Lzma2Enc.c b/C/Lzma2Enc.c
index d541477..703e146 100644
--- a/C/Lzma2Enc.c
+++ b/C/Lzma2Enc.c
@@ -1,803 +1,805 @@
-/* Lzma2Enc.c -- LZMA2 Encoder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-/* #define _7ZIP_ST */
-
-#include "Lzma2Enc.h"
-
-#ifndef _7ZIP_ST
-#include "MtCoder.h"
-#else
-#define MTCODER__THREADS_MAX 1
-#endif
-
-#define LZMA2_CONTROL_LZMA (1 << 7)
-#define LZMA2_CONTROL_COPY_NO_RESET 2
-#define LZMA2_CONTROL_COPY_RESET_DIC 1
-#define LZMA2_CONTROL_EOF 0
-
-#define LZMA2_LCLP_MAX 4
-
-#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
-
-#define LZMA2_PACK_SIZE_MAX (1 << 16)
-#define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX
-#define LZMA2_UNPACK_SIZE_MAX (1 << 21)
-#define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX
-
-#define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16)
-
-
-#define PRF(x) /* x */
-
-
-/* ---------- CLimitedSeqInStream ---------- */
-
-typedef struct
-{
- ISeqInStream vt;
- ISeqInStream *realStream;
- UInt64 limit;
- UInt64 processed;
- int finished;
-} CLimitedSeqInStream;
-
-static void LimitedSeqInStream_Init(CLimitedSeqInStream *p)
-{
- p->limit = (UInt64)(Int64)-1;
- p->processed = 0;
- p->finished = 0;
-}
-
-static SRes LimitedSeqInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
-{
- CLimitedSeqInStream *p = CONTAINER_FROM_VTBL(pp, CLimitedSeqInStream, vt);
- size_t size2 = *size;
- SRes res = SZ_OK;
-
- if (p->limit != (UInt64)(Int64)-1)
- {
- UInt64 rem = p->limit - p->processed;
- if (size2 > rem)
- size2 = (size_t)rem;
- }
- if (size2 != 0)
- {
- res = ISeqInStream_Read(p->realStream, data, &size2);
- p->finished = (size2 == 0 ? 1 : 0);
- p->processed += size2;
- }
- *size = size2;
- return res;
-}
-
-
-/* ---------- CLzma2EncInt ---------- */
-
-typedef struct
-{
- CLzmaEncHandle enc;
- Byte propsAreSet;
- Byte propsByte;
- Byte needInitState;
- Byte needInitProp;
- UInt64 srcPos;
-} CLzma2EncInt;
-
-
-static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props)
-{
- if (!p->propsAreSet)
- {
- SizeT propsSize = LZMA_PROPS_SIZE;
- Byte propsEncoded[LZMA_PROPS_SIZE];
- RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps));
- RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize));
- p->propsByte = propsEncoded[0];
- p->propsAreSet = True;
- }
- return SZ_OK;
-}
-
-static void Lzma2EncInt_InitBlock(CLzma2EncInt *p)
-{
- p->srcPos = 0;
- p->needInitState = True;
- p->needInitProp = True;
-}
-
-
-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp, ISeqInStream *inStream, UInt32 keepWindowSize,
- ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
- UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,
- Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp);
-void LzmaEnc_Finish(CLzmaEncHandle pp);
-void LzmaEnc_SaveState(CLzmaEncHandle pp);
-void LzmaEnc_RestoreState(CLzmaEncHandle pp);
-
-/*
-UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp);
-*/
-
-static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
- size_t *packSizeRes, ISeqOutStream *outStream)
-{
- size_t packSizeLimit = *packSizeRes;
- size_t packSize = packSizeLimit;
- UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX;
- unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0);
- BoolInt useCopyBlock;
- SRes res;
-
- *packSizeRes = 0;
- if (packSize < lzHeaderSize)
- return SZ_ERROR_OUTPUT_EOF;
- packSize -= lzHeaderSize;
-
- LzmaEnc_SaveState(p->enc);
- res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState,
- outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize);
-
- PRF(printf("\npackSize = %7d unpackSize = %7d ", packSize, unpackSize));
-
- if (unpackSize == 0)
- return res;
-
- if (res == SZ_OK)
- useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16));
- else
- {
- if (res != SZ_ERROR_OUTPUT_EOF)
- return res;
- res = SZ_OK;
- useCopyBlock = True;
- }
-
- if (useCopyBlock)
- {
- size_t destPos = 0;
- PRF(printf("################# COPY "));
-
- while (unpackSize > 0)
- {
- UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;
- if (packSizeLimit - destPos < u + 3)
- return SZ_ERROR_OUTPUT_EOF;
- outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET);
- outBuf[destPos++] = (Byte)((u - 1) >> 8);
- outBuf[destPos++] = (Byte)(u - 1);
- memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u);
- unpackSize -= u;
- destPos += u;
- p->srcPos += u;
-
- if (outStream)
- {
- *packSizeRes += destPos;
- if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
- return SZ_ERROR_WRITE;
- destPos = 0;
- }
- else
- *packSizeRes = destPos;
- /* needInitState = True; */
- }
-
- LzmaEnc_RestoreState(p->enc);
- return SZ_OK;
- }
-
- {
- size_t destPos = 0;
- UInt32 u = unpackSize - 1;
- UInt32 pm = (UInt32)(packSize - 1);
- unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0);
-
- PRF(printf(" "));
-
- outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | ((u >> 16) & 0x1F));
- outBuf[destPos++] = (Byte)(u >> 8);
- outBuf[destPos++] = (Byte)u;
- outBuf[destPos++] = (Byte)(pm >> 8);
- outBuf[destPos++] = (Byte)pm;
-
- if (p->needInitProp)
- outBuf[destPos++] = p->propsByte;
-
- p->needInitProp = False;
- p->needInitState = False;
- destPos += packSize;
- p->srcPos += unpackSize;
-
- if (outStream)
- if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
- return SZ_ERROR_WRITE;
-
- *packSizeRes = destPos;
- return SZ_OK;
- }
-}
-
-
-/* ---------- Lzma2 Props ---------- */
-
-void Lzma2EncProps_Init(CLzma2EncProps *p)
-{
- LzmaEncProps_Init(&p->lzmaProps);
- p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO;
- p->numBlockThreads_Reduced = -1;
- p->numBlockThreads_Max = -1;
- p->numTotalThreads = -1;
-}
-
-void Lzma2EncProps_Normalize(CLzma2EncProps *p)
-{
- UInt64 fileSize;
- int t1, t1n, t2, t2r, t3;
- {
- CLzmaEncProps lzmaProps = p->lzmaProps;
- LzmaEncProps_Normalize(&lzmaProps);
- t1n = lzmaProps.numThreads;
- }
-
- t1 = p->lzmaProps.numThreads;
- t2 = p->numBlockThreads_Max;
- t3 = p->numTotalThreads;
-
- if (t2 > MTCODER__THREADS_MAX)
- t2 = MTCODER__THREADS_MAX;
-
- if (t3 <= 0)
- {
- if (t2 <= 0)
- t2 = 1;
- t3 = t1n * t2;
- }
- else if (t2 <= 0)
- {
- t2 = t3 / t1n;
- if (t2 == 0)
- {
- t1 = 1;
- t2 = t3;
- }
- if (t2 > MTCODER__THREADS_MAX)
- t2 = MTCODER__THREADS_MAX;
- }
- else if (t1 <= 0)
- {
- t1 = t3 / t2;
- if (t1 == 0)
- t1 = 1;
- }
- else
- t3 = t1n * t2;
-
- p->lzmaProps.numThreads = t1;
-
- t2r = t2;
-
- fileSize = p->lzmaProps.reduceSize;
-
- if ( p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
- && p->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO
- && (p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))
- p->lzmaProps.reduceSize = p->blockSize;
-
- LzmaEncProps_Normalize(&p->lzmaProps);
-
- p->lzmaProps.reduceSize = fileSize;
-
- t1 = p->lzmaProps.numThreads;
-
- if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
- {
- t2r = t2 = 1;
- t3 = t1;
- }
- else if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO && t2 <= 1)
- {
- /* if there is no block multi-threading, we use SOLID block */
- p->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;
- }
- else
- {
- if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
- {
- const UInt32 kMinSize = (UInt32)1 << 20;
- const UInt32 kMaxSize = (UInt32)1 << 28;
- const UInt32 dictSize = p->lzmaProps.dictSize;
- UInt64 blockSize = (UInt64)dictSize << 2;
- if (blockSize < kMinSize) blockSize = kMinSize;
- if (blockSize > kMaxSize) blockSize = kMaxSize;
- if (blockSize < dictSize) blockSize = dictSize;
- blockSize += (kMinSize - 1);
- blockSize &= ~(UInt64)(kMinSize - 1);
- p->blockSize = blockSize;
- }
-
- if (t2 > 1 && fileSize != (UInt64)(Int64)-1)
- {
- UInt64 numBlocks = fileSize / p->blockSize;
- if (numBlocks * p->blockSize != fileSize)
- numBlocks++;
- if (numBlocks < (unsigned)t2)
- {
- t2r = (unsigned)numBlocks;
- if (t2r == 0)
- t2r = 1;
- t3 = t1 * t2r;
- }
- }
- }
-
- p->numBlockThreads_Max = t2;
- p->numBlockThreads_Reduced = t2r;
- p->numTotalThreads = t3;
-}
-
-
-static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)
-{
- return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
-}
-
-
-/* ---------- Lzma2 ---------- */
-
-typedef struct
-{
- Byte propEncoded;
- CLzma2EncProps props;
- UInt64 expectedDataSize;
-
- Byte *tempBufLzma;
-
- ISzAllocPtr alloc;
- ISzAllocPtr allocBig;
-
- CLzma2EncInt coders[MTCODER__THREADS_MAX];
-
- #ifndef _7ZIP_ST
-
- ISeqOutStream *outStream;
- Byte *outBuf;
- size_t outBuf_Rem; /* remainder in outBuf */
-
- size_t outBufSize; /* size of allocated outBufs[i] */
- size_t outBufsDataSizes[MTCODER__BLOCKS_MAX];
- BoolInt mtCoder_WasConstructed;
- CMtCoder mtCoder;
- Byte *outBufs[MTCODER__BLOCKS_MAX];
-
- #endif
-
-} CLzma2Enc;
-
-
-
-CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc));
- if (!p)
- return NULL;
- Lzma2EncProps_Init(&p->props);
- Lzma2EncProps_Normalize(&p->props);
- p->expectedDataSize = (UInt64)(Int64)-1;
- p->tempBufLzma = NULL;
- p->alloc = alloc;
- p->allocBig = allocBig;
- {
- unsigned i;
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- p->coders[i].enc = NULL;
- }
-
- #ifndef _7ZIP_ST
- p->mtCoder_WasConstructed = False;
- {
- unsigned i;
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- p->outBufs[i] = NULL;
- p->outBufSize = 0;
- }
- #endif
-
- return p;
-}
-
-
-#ifndef _7ZIP_ST
-
-static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)
-{
- unsigned i;
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- if (p->outBufs[i])
- {
- ISzAlloc_Free(p->alloc, p->outBufs[i]);
- p->outBufs[i] = NULL;
- }
- p->outBufSize = 0;
-}
-
-#endif
-
-
-void Lzma2Enc_Destroy(CLzma2EncHandle pp)
-{
- CLzma2Enc *p = (CLzma2Enc *)pp;
- unsigned i;
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- {
- CLzma2EncInt *t = &p->coders[i];
- if (t->enc)
- {
- LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);
- t->enc = NULL;
- }
- }
-
-
- #ifndef _7ZIP_ST
- if (p->mtCoder_WasConstructed)
- {
- MtCoder_Destruct(&p->mtCoder);
- p->mtCoder_WasConstructed = False;
- }
- Lzma2Enc_FreeOutBufs(p);
- #endif
-
- ISzAlloc_Free(p->alloc, p->tempBufLzma);
- p->tempBufLzma = NULL;
-
- ISzAlloc_Free(p->alloc, pp);
-}
-
-
-SRes Lzma2Enc_SetProps(CLzma2EncHandle pp, const CLzma2EncProps *props)
-{
- CLzma2Enc *p = (CLzma2Enc *)pp;
- CLzmaEncProps lzmaProps = props->lzmaProps;
- LzmaEncProps_Normalize(&lzmaProps);
- if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
- return SZ_ERROR_PARAM;
- p->props = *props;
- Lzma2EncProps_Normalize(&p->props);
- return SZ_OK;
-}
-
-
-void Lzma2Enc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)
-{
- CLzma2Enc *p = (CLzma2Enc *)pp;
- p->expectedDataSize = expectedDataSiize;
-}
-
-
-Byte Lzma2Enc_WriteProperties(CLzma2EncHandle pp)
-{
- CLzma2Enc *p = (CLzma2Enc *)pp;
- unsigned i;
- UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
- for (i = 0; i < 40; i++)
- if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))
- break;
- return (Byte)i;
-}
-
-
-static SRes Lzma2Enc_EncodeMt1(
- CLzma2Enc *me,
- CLzma2EncInt *p,
- ISeqOutStream *outStream,
- Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- const Byte *inData, size_t inDataSize,
- int finished,
- ICompressProgress *progress)
-{
- UInt64 unpackTotal = 0;
- UInt64 packTotal = 0;
- size_t outLim = 0;
- CLimitedSeqInStream limitedInStream;
-
- if (outBuf)
- {
- outLim = *outBufSize;
- *outBufSize = 0;
- }
-
- if (!p->enc)
- {
- p->propsAreSet = False;
- p->enc = LzmaEnc_Create(me->alloc);
- if (!p->enc)
- return SZ_ERROR_MEM;
- }
-
- limitedInStream.realStream = inStream;
- if (inStream)
- {
- limitedInStream.vt.Read = LimitedSeqInStream_Read;
- }
-
- if (!outBuf)
- {
- // outStream version works only in one thread. So we use CLzma2Enc::tempBufLzma
- if (!me->tempBufLzma)
- {
- me->tempBufLzma = (Byte *)ISzAlloc_Alloc(me->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX);
- if (!me->tempBufLzma)
- return SZ_ERROR_MEM;
- }
- }
-
- RINOK(Lzma2EncInt_InitStream(p, &me->props));
-
- for (;;)
- {
- SRes res = SZ_OK;
- size_t inSizeCur = 0;
-
- Lzma2EncInt_InitBlock(p);
-
- LimitedSeqInStream_Init(&limitedInStream);
- limitedInStream.limit = me->props.blockSize;
-
- if (inStream)
- {
- UInt64 expected = (UInt64)(Int64)-1;
- // inStream version works only in one thread. So we use CLzma2Enc::expectedDataSize
- if (me->expectedDataSize != (UInt64)(Int64)-1
- && me->expectedDataSize >= unpackTotal)
- expected = me->expectedDataSize - unpackTotal;
- if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
- && expected > me->props.blockSize)
- expected = (size_t)me->props.blockSize;
-
- LzmaEnc_SetDataSize(p->enc, expected);
-
- RINOK(LzmaEnc_PrepareForLzma2(p->enc,
- &limitedInStream.vt,
- LZMA2_KEEP_WINDOW_SIZE,
- me->alloc,
- me->allocBig));
- }
- else
- {
- inSizeCur = inDataSize - (size_t)unpackTotal;
- if (me->props.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
- && inSizeCur > me->props.blockSize)
- inSizeCur = (size_t)me->props.blockSize;
-
- // LzmaEnc_SetDataSize(p->enc, inSizeCur);
-
- RINOK(LzmaEnc_MemPrepare(p->enc,
- inData + (size_t)unpackTotal, inSizeCur,
- LZMA2_KEEP_WINDOW_SIZE,
- me->alloc,
- me->allocBig));
- }
-
- for (;;)
- {
- size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX;
- if (outBuf)
- packSize = outLim - (size_t)packTotal;
-
- res = Lzma2EncInt_EncodeSubblock(p,
- outBuf ? outBuf + (size_t)packTotal : me->tempBufLzma, &packSize,
- outBuf ? NULL : outStream);
-
- if (res != SZ_OK)
- break;
-
- packTotal += packSize;
- if (outBuf)
- *outBufSize = (size_t)packTotal;
-
- res = Progress(progress, unpackTotal + p->srcPos, packTotal);
- if (res != SZ_OK)
- break;
-
- /*
- if (LzmaEnc_GetNumAvailableBytes(p->enc) == 0)
- break;
- */
-
- if (packSize == 0)
- break;
- }
-
- LzmaEnc_Finish(p->enc);
-
- unpackTotal += p->srcPos;
-
- RINOK(res);
-
- if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur))
- return SZ_ERROR_FAIL;
-
- if (inStream ? limitedInStream.finished : (unpackTotal == inDataSize))
- {
- if (finished)
- {
- if (outBuf)
- {
- size_t destPos = *outBufSize;
- if (destPos >= outLim)
- return SZ_ERROR_OUTPUT_EOF;
- outBuf[destPos] = 0;
- *outBufSize = destPos + 1;
- }
- else
- {
- Byte b = 0;
- if (ISeqOutStream_Write(outStream, &b, 1) != 1)
- return SZ_ERROR_WRITE;
- }
- }
- return SZ_OK;
- }
- }
-}
-
-
-
-#ifndef _7ZIP_ST
-
-static SRes Lzma2Enc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,
- const Byte *src, size_t srcSize, int finished)
-{
- CLzma2Enc *me = (CLzma2Enc *)pp;
- size_t destSize = me->outBufSize;
- SRes res;
- CMtProgressThunk progressThunk;
-
- Byte *dest = me->outBufs[outBufIndex];
-
- me->outBufsDataSizes[outBufIndex] = 0;
-
- if (!dest)
- {
- dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
- if (!dest)
- return SZ_ERROR_MEM;
- me->outBufs[outBufIndex] = dest;
- }
-
- MtProgressThunk_CreateVTable(&progressThunk);
- progressThunk.mtProgress = &me->mtCoder.mtProgress;
- progressThunk.inSize = 0;
- progressThunk.outSize = 0;
-
- res = Lzma2Enc_EncodeMt1(me,
- &me->coders[coderIndex],
- NULL, dest, &destSize,
- NULL, src, srcSize,
- finished,
- &progressThunk.vt);
-
- me->outBufsDataSizes[outBufIndex] = destSize;
-
- return res;
-}
-
-
-static SRes Lzma2Enc_MtCallback_Write(void *pp, unsigned outBufIndex)
-{
- CLzma2Enc *me = (CLzma2Enc *)pp;
- size_t size = me->outBufsDataSizes[outBufIndex];
- const Byte *data = me->outBufs[outBufIndex];
-
- if (me->outStream)
- return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE;
-
- if (size > me->outBuf_Rem)
- return SZ_ERROR_OUTPUT_EOF;
- memcpy(me->outBuf, data, size);
- me->outBuf_Rem -= size;
- me->outBuf += size;
- return SZ_OK;
-}
-
-#endif
-
-
-
-SRes Lzma2Enc_Encode2(CLzma2EncHandle pp,
- ISeqOutStream *outStream,
- Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- const Byte *inData, size_t inDataSize,
- ICompressProgress *progress)
-{
- CLzma2Enc *p = (CLzma2Enc *)pp;
-
- if (inStream && inData)
- return SZ_ERROR_PARAM;
-
- if (outStream && outBuf)
- return SZ_ERROR_PARAM;
-
- {
- unsigned i;
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- p->coders[i].propsAreSet = False;
- }
-
- #ifndef _7ZIP_ST
-
- if (p->props.numBlockThreads_Reduced > 1)
- {
- IMtCoderCallback2 vt;
-
- if (!p->mtCoder_WasConstructed)
- {
- p->mtCoder_WasConstructed = True;
- MtCoder_Construct(&p->mtCoder);
- }
-
- vt.Code = Lzma2Enc_MtCallback_Code;
- vt.Write = Lzma2Enc_MtCallback_Write;
-
- p->outStream = outStream;
- p->outBuf = NULL;
- p->outBuf_Rem = 0;
- if (!outStream)
- {
- p->outBuf = outBuf;
- p->outBuf_Rem = *outBufSize;
- *outBufSize = 0;
- }
-
- p->mtCoder.allocBig = p->allocBig;
- p->mtCoder.progress = progress;
- p->mtCoder.inStream = inStream;
- p->mtCoder.inData = inData;
- p->mtCoder.inDataSize = inDataSize;
- p->mtCoder.mtCallback = &vt;
- p->mtCoder.mtCallbackObject = p;
-
- p->mtCoder.blockSize = (size_t)p->props.blockSize;
- if (p->mtCoder.blockSize != p->props.blockSize)
- return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
-
- {
- size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;
- if (destBlockSize < p->mtCoder.blockSize)
- return SZ_ERROR_PARAM;
- if (p->outBufSize != destBlockSize)
- Lzma2Enc_FreeOutBufs(p);
- p->outBufSize = destBlockSize;
- }
-
- p->mtCoder.numThreadsMax = p->props.numBlockThreads_Max;
- p->mtCoder.expectedDataSize = p->expectedDataSize;
-
- {
- SRes res = MtCoder_Code(&p->mtCoder);
- if (!outStream)
- *outBufSize = p->outBuf - outBuf;
- return res;
- }
- }
-
- #endif
-
-
- return Lzma2Enc_EncodeMt1(p,
- &p->coders[0],
- outStream, outBuf, outBufSize,
- inStream, inData, inDataSize,
- True, /* finished */
- progress);
-}
+/* Lzma2Enc.c -- LZMA2 Encoder
+2023-04-13 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+/* #define Z7_ST */
+
+#include "Lzma2Enc.h"
+
+#ifndef Z7_ST
+#include "MtCoder.h"
+#else
+#define MTCODER_THREADS_MAX 1
+#endif
+
+#define LZMA2_CONTROL_LZMA (1 << 7)
+#define LZMA2_CONTROL_COPY_NO_RESET 2
+#define LZMA2_CONTROL_COPY_RESET_DIC 1
+#define LZMA2_CONTROL_EOF 0
+
+#define LZMA2_LCLP_MAX 4
+
+#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11))
+
+#define LZMA2_PACK_SIZE_MAX (1 << 16)
+#define LZMA2_COPY_CHUNK_SIZE LZMA2_PACK_SIZE_MAX
+#define LZMA2_UNPACK_SIZE_MAX (1 << 21)
+#define LZMA2_KEEP_WINDOW_SIZE LZMA2_UNPACK_SIZE_MAX
+
+#define LZMA2_CHUNK_SIZE_COMPRESSED_MAX ((1 << 16) + 16)
+
+
+#define PRF(x) /* x */
+
+
+/* ---------- CLimitedSeqInStream ---------- */
+
+typedef struct
+{
+ ISeqInStream vt;
+ ISeqInStreamPtr realStream;
+ UInt64 limit;
+ UInt64 processed;
+ int finished;
+} CLimitedSeqInStream;
+
+static void LimitedSeqInStream_Init(CLimitedSeqInStream *p)
+{
+ p->limit = (UInt64)(Int64)-1;
+ p->processed = 0;
+ p->finished = 0;
+}
+
+static SRes LimitedSeqInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLimitedSeqInStream)
+ size_t size2 = *size;
+ SRes res = SZ_OK;
+
+ if (p->limit != (UInt64)(Int64)-1)
+ {
+ const UInt64 rem = p->limit - p->processed;
+ if (size2 > rem)
+ size2 = (size_t)rem;
+ }
+ if (size2 != 0)
+ {
+ res = ISeqInStream_Read(p->realStream, data, &size2);
+ p->finished = (size2 == 0 ? 1 : 0);
+ p->processed += size2;
+ }
+ *size = size2;
+ return res;
+}
+
+
+/* ---------- CLzma2EncInt ---------- */
+
+typedef struct
+{
+ CLzmaEncHandle enc;
+ Byte propsAreSet;
+ Byte propsByte;
+ Byte needInitState;
+ Byte needInitProp;
+ UInt64 srcPos;
+} CLzma2EncInt;
+
+
+static SRes Lzma2EncInt_InitStream(CLzma2EncInt *p, const CLzma2EncProps *props)
+{
+ if (!p->propsAreSet)
+ {
+ SizeT propsSize = LZMA_PROPS_SIZE;
+ Byte propsEncoded[LZMA_PROPS_SIZE];
+ RINOK(LzmaEnc_SetProps(p->enc, &props->lzmaProps))
+ RINOK(LzmaEnc_WriteProperties(p->enc, propsEncoded, &propsSize))
+ p->propsByte = propsEncoded[0];
+ p->propsAreSet = True;
+ }
+ return SZ_OK;
+}
+
+static void Lzma2EncInt_InitBlock(CLzma2EncInt *p)
+{
+ p->srcPos = 0;
+ p->needInitState = True;
+ p->needInitProp = True;
+}
+
+
+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p, ISeqInStreamPtr inStream, UInt32 keepWindowSize,
+ ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_MemPrepare(CLzmaEncHandle p, const Byte *src, SizeT srcLen,
+ UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
+ Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
+const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p);
+void LzmaEnc_Finish(CLzmaEncHandle p);
+void LzmaEnc_SaveState(CLzmaEncHandle p);
+void LzmaEnc_RestoreState(CLzmaEncHandle p);
+
+/*
+UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle p);
+*/
+
+static SRes Lzma2EncInt_EncodeSubblock(CLzma2EncInt *p, Byte *outBuf,
+ size_t *packSizeRes, ISeqOutStreamPtr outStream)
+{
+ size_t packSizeLimit = *packSizeRes;
+ size_t packSize = packSizeLimit;
+ UInt32 unpackSize = LZMA2_UNPACK_SIZE_MAX;
+ unsigned lzHeaderSize = 5 + (p->needInitProp ? 1 : 0);
+ BoolInt useCopyBlock;
+ SRes res;
+
+ *packSizeRes = 0;
+ if (packSize < lzHeaderSize)
+ return SZ_ERROR_OUTPUT_EOF;
+ packSize -= lzHeaderSize;
+
+ LzmaEnc_SaveState(p->enc);
+ res = LzmaEnc_CodeOneMemBlock(p->enc, p->needInitState,
+ outBuf + lzHeaderSize, &packSize, LZMA2_PACK_SIZE_MAX, &unpackSize);
+
+ PRF(printf("\npackSize = %7d unpackSize = %7d ", packSize, unpackSize));
+
+ if (unpackSize == 0)
+ return res;
+
+ if (res == SZ_OK)
+ useCopyBlock = (packSize + 2 >= unpackSize || packSize > (1 << 16));
+ else
+ {
+ if (res != SZ_ERROR_OUTPUT_EOF)
+ return res;
+ res = SZ_OK;
+ useCopyBlock = True;
+ }
+
+ if (useCopyBlock)
+ {
+ size_t destPos = 0;
+ PRF(printf("################# COPY "));
+
+ while (unpackSize > 0)
+ {
+ const UInt32 u = (unpackSize < LZMA2_COPY_CHUNK_SIZE) ? unpackSize : LZMA2_COPY_CHUNK_SIZE;
+ if (packSizeLimit - destPos < u + 3)
+ return SZ_ERROR_OUTPUT_EOF;
+ outBuf[destPos++] = (Byte)(p->srcPos == 0 ? LZMA2_CONTROL_COPY_RESET_DIC : LZMA2_CONTROL_COPY_NO_RESET);
+ outBuf[destPos++] = (Byte)((u - 1) >> 8);
+ outBuf[destPos++] = (Byte)(u - 1);
+ memcpy(outBuf + destPos, LzmaEnc_GetCurBuf(p->enc) - unpackSize, u);
+ unpackSize -= u;
+ destPos += u;
+ p->srcPos += u;
+
+ if (outStream)
+ {
+ *packSizeRes += destPos;
+ if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
+ return SZ_ERROR_WRITE;
+ destPos = 0;
+ }
+ else
+ *packSizeRes = destPos;
+ /* needInitState = True; */
+ }
+
+ LzmaEnc_RestoreState(p->enc);
+ return SZ_OK;
+ }
+
+ {
+ size_t destPos = 0;
+ const UInt32 u = unpackSize - 1;
+ const UInt32 pm = (UInt32)(packSize - 1);
+ const unsigned mode = (p->srcPos == 0) ? 3 : (p->needInitState ? (p->needInitProp ? 2 : 1) : 0);
+
+ PRF(printf(" "));
+
+ outBuf[destPos++] = (Byte)(LZMA2_CONTROL_LZMA | (mode << 5) | ((u >> 16) & 0x1F));
+ outBuf[destPos++] = (Byte)(u >> 8);
+ outBuf[destPos++] = (Byte)u;
+ outBuf[destPos++] = (Byte)(pm >> 8);
+ outBuf[destPos++] = (Byte)pm;
+
+ if (p->needInitProp)
+ outBuf[destPos++] = p->propsByte;
+
+ p->needInitProp = False;
+ p->needInitState = False;
+ destPos += packSize;
+ p->srcPos += unpackSize;
+
+ if (outStream)
+ if (ISeqOutStream_Write(outStream, outBuf, destPos) != destPos)
+ return SZ_ERROR_WRITE;
+
+ *packSizeRes = destPos;
+ return SZ_OK;
+ }
+}
+
+
+/* ---------- Lzma2 Props ---------- */
+
+void Lzma2EncProps_Init(CLzma2EncProps *p)
+{
+ LzmaEncProps_Init(&p->lzmaProps);
+ p->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO;
+ p->numBlockThreads_Reduced = -1;
+ p->numBlockThreads_Max = -1;
+ p->numTotalThreads = -1;
+}
+
+void Lzma2EncProps_Normalize(CLzma2EncProps *p)
+{
+ UInt64 fileSize;
+ int t1, t1n, t2, t2r, t3;
+ {
+ CLzmaEncProps lzmaProps = p->lzmaProps;
+ LzmaEncProps_Normalize(&lzmaProps);
+ t1n = lzmaProps.numThreads;
+ }
+
+ t1 = p->lzmaProps.numThreads;
+ t2 = p->numBlockThreads_Max;
+ t3 = p->numTotalThreads;
+
+ if (t2 > MTCODER_THREADS_MAX)
+ t2 = MTCODER_THREADS_MAX;
+
+ if (t3 <= 0)
+ {
+ if (t2 <= 0)
+ t2 = 1;
+ t3 = t1n * t2;
+ }
+ else if (t2 <= 0)
+ {
+ t2 = t3 / t1n;
+ if (t2 == 0)
+ {
+ t1 = 1;
+ t2 = t3;
+ }
+ if (t2 > MTCODER_THREADS_MAX)
+ t2 = MTCODER_THREADS_MAX;
+ }
+ else if (t1 <= 0)
+ {
+ t1 = t3 / t2;
+ if (t1 == 0)
+ t1 = 1;
+ }
+ else
+ t3 = t1n * t2;
+
+ p->lzmaProps.numThreads = t1;
+
+ t2r = t2;
+
+ fileSize = p->lzmaProps.reduceSize;
+
+ if ( p->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+ && p->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO
+ && (p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))
+ p->lzmaProps.reduceSize = p->blockSize;
+
+ LzmaEncProps_Normalize(&p->lzmaProps);
+
+ p->lzmaProps.reduceSize = fileSize;
+
+ t1 = p->lzmaProps.numThreads;
+
+ if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+ {
+ t2r = t2 = 1;
+ t3 = t1;
+ }
+ else if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO && t2 <= 1)
+ {
+ /* if there is no block multi-threading, we use SOLID block */
+ p->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID;
+ }
+ else
+ {
+ if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
+ {
+ const UInt32 kMinSize = (UInt32)1 << 20;
+ const UInt32 kMaxSize = (UInt32)1 << 28;
+ const UInt32 dictSize = p->lzmaProps.dictSize;
+ UInt64 blockSize = (UInt64)dictSize << 2;
+ if (blockSize < kMinSize) blockSize = kMinSize;
+ if (blockSize > kMaxSize) blockSize = kMaxSize;
+ if (blockSize < dictSize) blockSize = dictSize;
+ blockSize += (kMinSize - 1);
+ blockSize &= ~(UInt64)(kMinSize - 1);
+ p->blockSize = blockSize;
+ }
+
+ if (t2 > 1 && fileSize != (UInt64)(Int64)-1)
+ {
+ UInt64 numBlocks = fileSize / p->blockSize;
+ if (numBlocks * p->blockSize != fileSize)
+ numBlocks++;
+ if (numBlocks < (unsigned)t2)
+ {
+ t2r = (int)numBlocks;
+ if (t2r == 0)
+ t2r = 1;
+ t3 = t1 * t2r;
+ }
+ }
+ }
+
+ p->numBlockThreads_Max = t2;
+ p->numBlockThreads_Reduced = t2r;
+ p->numTotalThreads = t3;
+}
+
+
+static SRes Progress(ICompressProgressPtr p, UInt64 inSize, UInt64 outSize)
+{
+ return (p && ICompressProgress_Progress(p, inSize, outSize) != SZ_OK) ? SZ_ERROR_PROGRESS : SZ_OK;
+}
+
+
+/* ---------- Lzma2 ---------- */
+
+struct CLzma2Enc
+{
+ Byte propEncoded;
+ CLzma2EncProps props;
+ UInt64 expectedDataSize;
+
+ Byte *tempBufLzma;
+
+ ISzAllocPtr alloc;
+ ISzAllocPtr allocBig;
+
+ CLzma2EncInt coders[MTCODER_THREADS_MAX];
+
+ #ifndef Z7_ST
+
+ ISeqOutStreamPtr outStream;
+ Byte *outBuf;
+ size_t outBuf_Rem; /* remainder in outBuf */
+
+ size_t outBufSize; /* size of allocated outBufs[i] */
+ size_t outBufsDataSizes[MTCODER_BLOCKS_MAX];
+ BoolInt mtCoder_WasConstructed;
+ CMtCoder mtCoder;
+ Byte *outBufs[MTCODER_BLOCKS_MAX];
+
+ #endif
+};
+
+
+
+CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ CLzma2Enc *p = (CLzma2Enc *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Enc));
+ if (!p)
+ return NULL;
+ Lzma2EncProps_Init(&p->props);
+ Lzma2EncProps_Normalize(&p->props);
+ p->expectedDataSize = (UInt64)(Int64)-1;
+ p->tempBufLzma = NULL;
+ p->alloc = alloc;
+ p->allocBig = allocBig;
+ {
+ unsigned i;
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ p->coders[i].enc = NULL;
+ }
+
+ #ifndef Z7_ST
+ p->mtCoder_WasConstructed = False;
+ {
+ unsigned i;
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ p->outBufs[i] = NULL;
+ p->outBufSize = 0;
+ }
+ #endif
+
+ return (CLzma2EncHandle)p;
+}
+
+
+#ifndef Z7_ST
+
+static void Lzma2Enc_FreeOutBufs(CLzma2Enc *p)
+{
+ unsigned i;
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ if (p->outBufs[i])
+ {
+ ISzAlloc_Free(p->alloc, p->outBufs[i]);
+ p->outBufs[i] = NULL;
+ }
+ p->outBufSize = 0;
+}
+
+#endif
+
+// #define GET_CLzma2Enc_p CLzma2Enc *p = (CLzma2Enc *)(void *)p;
+
+void Lzma2Enc_Destroy(CLzma2EncHandle p)
+{
+ // GET_CLzma2Enc_p
+ unsigned i;
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ {
+ CLzma2EncInt *t = &p->coders[i];
+ if (t->enc)
+ {
+ LzmaEnc_Destroy(t->enc, p->alloc, p->allocBig);
+ t->enc = NULL;
+ }
+ }
+
+
+ #ifndef Z7_ST
+ if (p->mtCoder_WasConstructed)
+ {
+ MtCoder_Destruct(&p->mtCoder);
+ p->mtCoder_WasConstructed = False;
+ }
+ Lzma2Enc_FreeOutBufs(p);
+ #endif
+
+ ISzAlloc_Free(p->alloc, p->tempBufLzma);
+ p->tempBufLzma = NULL;
+
+ ISzAlloc_Free(p->alloc, p);
+}
+
+
+SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props)
+{
+ // GET_CLzma2Enc_p
+ CLzmaEncProps lzmaProps = props->lzmaProps;
+ LzmaEncProps_Normalize(&lzmaProps);
+ if (lzmaProps.lc + lzmaProps.lp > LZMA2_LCLP_MAX)
+ return SZ_ERROR_PARAM;
+ p->props = *props;
+ Lzma2EncProps_Normalize(&p->props);
+ return SZ_OK;
+}
+
+
+void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize)
+{
+ // GET_CLzma2Enc_p
+ p->expectedDataSize = expectedDataSiize;
+}
+
+
+Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p)
+{
+ // GET_CLzma2Enc_p
+ unsigned i;
+ UInt32 dicSize = LzmaEncProps_GetDictSize(&p->props.lzmaProps);
+ for (i = 0; i < 40; i++)
+ if (dicSize <= LZMA2_DIC_SIZE_FROM_PROP(i))
+ break;
+ return (Byte)i;
+}
+
+
+static SRes Lzma2Enc_EncodeMt1(
+ CLzma2Enc *me,
+ CLzma2EncInt *p,
+ ISeqOutStreamPtr outStream,
+ Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ const Byte *inData, size_t inDataSize,
+ int finished,
+ ICompressProgressPtr progress)
+{
+ UInt64 unpackTotal = 0;
+ UInt64 packTotal = 0;
+ size_t outLim = 0;
+ CLimitedSeqInStream limitedInStream;
+
+ if (outBuf)
+ {
+ outLim = *outBufSize;
+ *outBufSize = 0;
+ }
+
+ if (!p->enc)
+ {
+ p->propsAreSet = False;
+ p->enc = LzmaEnc_Create(me->alloc);
+ if (!p->enc)
+ return SZ_ERROR_MEM;
+ }
+
+ limitedInStream.realStream = inStream;
+ if (inStream)
+ {
+ limitedInStream.vt.Read = LimitedSeqInStream_Read;
+ }
+
+ if (!outBuf)
+ {
+ // outStream version works only in one thread. So we use CLzma2Enc::tempBufLzma
+ if (!me->tempBufLzma)
+ {
+ me->tempBufLzma = (Byte *)ISzAlloc_Alloc(me->alloc, LZMA2_CHUNK_SIZE_COMPRESSED_MAX);
+ if (!me->tempBufLzma)
+ return SZ_ERROR_MEM;
+ }
+ }
+
+ RINOK(Lzma2EncInt_InitStream(p, &me->props))
+
+ for (;;)
+ {
+ SRes res = SZ_OK;
+ SizeT inSizeCur = 0;
+
+ Lzma2EncInt_InitBlock(p);
+
+ LimitedSeqInStream_Init(&limitedInStream);
+ limitedInStream.limit = me->props.blockSize;
+
+ if (inStream)
+ {
+ UInt64 expected = (UInt64)(Int64)-1;
+ // inStream version works only in one thread. So we use CLzma2Enc::expectedDataSize
+ if (me->expectedDataSize != (UInt64)(Int64)-1
+ && me->expectedDataSize >= unpackTotal)
+ expected = me->expectedDataSize - unpackTotal;
+ if (me->props.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+ && expected > me->props.blockSize)
+ expected = (size_t)me->props.blockSize;
+
+ LzmaEnc_SetDataSize(p->enc, expected);
+
+ RINOK(LzmaEnc_PrepareForLzma2(p->enc,
+ &limitedInStream.vt,
+ LZMA2_KEEP_WINDOW_SIZE,
+ me->alloc,
+ me->allocBig))
+ }
+ else
+ {
+ inSizeCur = (SizeT)(inDataSize - (size_t)unpackTotal);
+ if (me->props.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+ && inSizeCur > me->props.blockSize)
+ inSizeCur = (SizeT)(size_t)me->props.blockSize;
+
+ // LzmaEnc_SetDataSize(p->enc, inSizeCur);
+
+ RINOK(LzmaEnc_MemPrepare(p->enc,
+ inData + (size_t)unpackTotal, inSizeCur,
+ LZMA2_KEEP_WINDOW_SIZE,
+ me->alloc,
+ me->allocBig))
+ }
+
+ for (;;)
+ {
+ size_t packSize = LZMA2_CHUNK_SIZE_COMPRESSED_MAX;
+ if (outBuf)
+ packSize = outLim - (size_t)packTotal;
+
+ res = Lzma2EncInt_EncodeSubblock(p,
+ outBuf ? outBuf + (size_t)packTotal : me->tempBufLzma, &packSize,
+ outBuf ? NULL : outStream);
+
+ if (res != SZ_OK)
+ break;
+
+ packTotal += packSize;
+ if (outBuf)
+ *outBufSize = (size_t)packTotal;
+
+ res = Progress(progress, unpackTotal + p->srcPos, packTotal);
+ if (res != SZ_OK)
+ break;
+
+ /*
+ if (LzmaEnc_GetNumAvailableBytes(p->enc) == 0)
+ break;
+ */
+
+ if (packSize == 0)
+ break;
+ }
+
+ LzmaEnc_Finish(p->enc);
+
+ unpackTotal += p->srcPos;
+
+ RINOK(res)
+
+ if (p->srcPos != (inStream ? limitedInStream.processed : inSizeCur))
+ return SZ_ERROR_FAIL;
+
+ if (inStream ? limitedInStream.finished : (unpackTotal == inDataSize))
+ {
+ if (finished)
+ {
+ if (outBuf)
+ {
+ const size_t destPos = *outBufSize;
+ if (destPos >= outLim)
+ return SZ_ERROR_OUTPUT_EOF;
+ outBuf[destPos] = LZMA2_CONTROL_EOF; // 0
+ *outBufSize = destPos + 1;
+ }
+ else
+ {
+ const Byte b = LZMA2_CONTROL_EOF; // 0;
+ if (ISeqOutStream_Write(outStream, &b, 1) != 1)
+ return SZ_ERROR_WRITE;
+ }
+ }
+ return SZ_OK;
+ }
+ }
+}
+
+
+
+#ifndef Z7_ST
+
+static SRes Lzma2Enc_MtCallback_Code(void *p, unsigned coderIndex, unsigned outBufIndex,
+ const Byte *src, size_t srcSize, int finished)
+{
+ CLzma2Enc *me = (CLzma2Enc *)p;
+ size_t destSize = me->outBufSize;
+ SRes res;
+ CMtProgressThunk progressThunk;
+
+ Byte *dest = me->outBufs[outBufIndex];
+
+ me->outBufsDataSizes[outBufIndex] = 0;
+
+ if (!dest)
+ {
+ dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
+ if (!dest)
+ return SZ_ERROR_MEM;
+ me->outBufs[outBufIndex] = dest;
+ }
+
+ MtProgressThunk_CreateVTable(&progressThunk);
+ progressThunk.mtProgress = &me->mtCoder.mtProgress;
+ progressThunk.inSize = 0;
+ progressThunk.outSize = 0;
+
+ res = Lzma2Enc_EncodeMt1(me,
+ &me->coders[coderIndex],
+ NULL, dest, &destSize,
+ NULL, src, srcSize,
+ finished,
+ &progressThunk.vt);
+
+ me->outBufsDataSizes[outBufIndex] = destSize;
+
+ return res;
+}
+
+
+static SRes Lzma2Enc_MtCallback_Write(void *p, unsigned outBufIndex)
+{
+ CLzma2Enc *me = (CLzma2Enc *)p;
+ size_t size = me->outBufsDataSizes[outBufIndex];
+ const Byte *data = me->outBufs[outBufIndex];
+
+ if (me->outStream)
+ return ISeqOutStream_Write(me->outStream, data, size) == size ? SZ_OK : SZ_ERROR_WRITE;
+
+ if (size > me->outBuf_Rem)
+ return SZ_ERROR_OUTPUT_EOF;
+ memcpy(me->outBuf, data, size);
+ me->outBuf_Rem -= size;
+ me->outBuf += size;
+ return SZ_OK;
+}
+
+#endif
+
+
+
+SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
+ ISeqOutStreamPtr outStream,
+ Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ const Byte *inData, size_t inDataSize,
+ ICompressProgressPtr progress)
+{
+ // GET_CLzma2Enc_p
+
+ if (inStream && inData)
+ return SZ_ERROR_PARAM;
+
+ if (outStream && outBuf)
+ return SZ_ERROR_PARAM;
+
+ {
+ unsigned i;
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ p->coders[i].propsAreSet = False;
+ }
+
+ #ifndef Z7_ST
+
+ if (p->props.numBlockThreads_Reduced > 1)
+ {
+ IMtCoderCallback2 vt;
+
+ if (!p->mtCoder_WasConstructed)
+ {
+ p->mtCoder_WasConstructed = True;
+ MtCoder_Construct(&p->mtCoder);
+ }
+
+ vt.Code = Lzma2Enc_MtCallback_Code;
+ vt.Write = Lzma2Enc_MtCallback_Write;
+
+ p->outStream = outStream;
+ p->outBuf = NULL;
+ p->outBuf_Rem = 0;
+ if (!outStream)
+ {
+ p->outBuf = outBuf;
+ p->outBuf_Rem = *outBufSize;
+ *outBufSize = 0;
+ }
+
+ p->mtCoder.allocBig = p->allocBig;
+ p->mtCoder.progress = progress;
+ p->mtCoder.inStream = inStream;
+ p->mtCoder.inData = inData;
+ p->mtCoder.inDataSize = inDataSize;
+ p->mtCoder.mtCallback = &vt;
+ p->mtCoder.mtCallbackObject = p;
+
+ p->mtCoder.blockSize = (size_t)p->props.blockSize;
+ if (p->mtCoder.blockSize != p->props.blockSize)
+ return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
+
+ {
+ const size_t destBlockSize = p->mtCoder.blockSize + (p->mtCoder.blockSize >> 10) + 16;
+ if (destBlockSize < p->mtCoder.blockSize)
+ return SZ_ERROR_PARAM;
+ if (p->outBufSize != destBlockSize)
+ Lzma2Enc_FreeOutBufs(p);
+ p->outBufSize = destBlockSize;
+ }
+
+ p->mtCoder.numThreadsMax = (unsigned)p->props.numBlockThreads_Max;
+ p->mtCoder.expectedDataSize = p->expectedDataSize;
+
+ {
+ const SRes res = MtCoder_Code(&p->mtCoder);
+ if (!outStream)
+ *outBufSize = (size_t)(p->outBuf - outBuf);
+ return res;
+ }
+ }
+
+ #endif
+
+
+ return Lzma2Enc_EncodeMt1(p,
+ &p->coders[0],
+ outStream, outBuf, outBufSize,
+ inStream, inData, inDataSize,
+ True, /* finished */
+ progress);
+}
+
+#undef PRF
diff --git a/C/Lzma2Enc.h b/C/Lzma2Enc.h
index 65f2dd1..cb25275 100644
--- a/C/Lzma2Enc.h
+++ b/C/Lzma2Enc.h
@@ -1,55 +1,57 @@
-/* Lzma2Enc.h -- LZMA2 Encoder
-2017-07-27 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA2_ENC_H
-#define __LZMA2_ENC_H
-
-#include "LzmaEnc.h"
-
-EXTERN_C_BEGIN
-
-#define LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO 0
-#define LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID ((UInt64)(Int64)-1)
-
-typedef struct
-{
- CLzmaEncProps lzmaProps;
- UInt64 blockSize;
- int numBlockThreads_Reduced;
- int numBlockThreads_Max;
- int numTotalThreads;
-} CLzma2EncProps;
-
-void Lzma2EncProps_Init(CLzma2EncProps *p);
-void Lzma2EncProps_Normalize(CLzma2EncProps *p);
-
-/* ---------- CLzmaEnc2Handle Interface ---------- */
-
-/* Lzma2Enc_* functions can return the following exit codes:
-SRes:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_PARAM - Incorrect paramater in props
- SZ_ERROR_WRITE - ISeqOutStream write callback error
- SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
- SZ_ERROR_PROGRESS - some break from progress callback
- SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
-*/
-
-typedef void * CLzma2EncHandle;
-
-CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
-void Lzma2Enc_Destroy(CLzma2EncHandle p);
-SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props);
-void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize);
-Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p);
-SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
- ISeqOutStream *outStream,
- Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- const Byte *inData, size_t inDataSize,
- ICompressProgress *progress);
-
-EXTERN_C_END
-
-#endif
+/* Lzma2Enc.h -- LZMA2 Encoder
+2023-04-13 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA2_ENC_H
+#define ZIP7_INC_LZMA2_ENC_H
+
+#include "LzmaEnc.h"
+
+EXTERN_C_BEGIN
+
+#define LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO 0
+#define LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID ((UInt64)(Int64)-1)
+
+typedef struct
+{
+ CLzmaEncProps lzmaProps;
+ UInt64 blockSize;
+ int numBlockThreads_Reduced;
+ int numBlockThreads_Max;
+ int numTotalThreads;
+} CLzma2EncProps;
+
+void Lzma2EncProps_Init(CLzma2EncProps *p);
+void Lzma2EncProps_Normalize(CLzma2EncProps *p);
+
+/* ---------- CLzmaEnc2Handle Interface ---------- */
+
+/* Lzma2Enc_* functions can return the following exit codes:
+SRes:
+ SZ_OK - OK
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_PARAM - Incorrect paramater in props
+ SZ_ERROR_WRITE - ISeqOutStream write callback error
+ SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
+ SZ_ERROR_PROGRESS - some break from progress callback
+ SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
+*/
+
+typedef struct CLzma2Enc CLzma2Enc;
+typedef CLzma2Enc * CLzma2EncHandle;
+// Z7_DECLARE_HANDLE(CLzma2EncHandle)
+
+CLzma2EncHandle Lzma2Enc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
+void Lzma2Enc_Destroy(CLzma2EncHandle p);
+SRes Lzma2Enc_SetProps(CLzma2EncHandle p, const CLzma2EncProps *props);
+void Lzma2Enc_SetDataSize(CLzma2EncHandle p, UInt64 expectedDataSiize);
+Byte Lzma2Enc_WriteProperties(CLzma2EncHandle p);
+SRes Lzma2Enc_Encode2(CLzma2EncHandle p,
+ ISeqOutStreamPtr outStream,
+ Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ const Byte *inData, size_t inDataSize,
+ ICompressProgressPtr progress);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Lzma86.h b/C/Lzma86.h
index 83057e5..e7707e2 100644
--- a/C/Lzma86.h
+++ b/C/Lzma86.h
@@ -1,111 +1,111 @@
-/* Lzma86.h -- LZMA + x86 (BCJ) Filter
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA86_H
-#define __LZMA86_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define LZMA86_SIZE_OFFSET (1 + 5)
-#define LZMA86_HEADER_SIZE (LZMA86_SIZE_OFFSET + 8)
-
-/*
-It's an example for LZMA + x86 Filter use.
-You can use .lzma86 extension, if you write that stream to file.
-.lzma86 header adds one additional byte to standard .lzma header.
-.lzma86 header (14 bytes):
- Offset Size Description
- 0 1 = 0 - no filter, pure LZMA
- = 1 - x86 filter + LZMA
- 1 1 lc, lp and pb in encoded form
- 2 4 dictSize (little endian)
- 6 8 uncompressed size (little endian)
-
-
-Lzma86_Encode
--------------
-level - compression level: 0 <= level <= 9, the default value for "level" is 5.
-
-dictSize - The dictionary size in bytes. The maximum value is
- 128 MB = (1 << 27) bytes for 32-bit version
- 1 GB = (1 << 30) bytes for 64-bit version
- The default value is 16 MB = (1 << 24) bytes, for level = 5.
- It's recommended to use the dictionary that is larger than 4 KB and
- that can be calculated as (1 << N) or (3 << N) sizes.
- For better compression ratio dictSize must be >= inSize.
-
-filterMode:
- SZ_FILTER_NO - no Filter
- SZ_FILTER_YES - x86 Filter
- SZ_FILTER_AUTO - it tries both alternatives to select best.
- Encoder will use 2 or 3 passes:
- 2 passes when FILTER_NO provides better compression.
- 3 passes when FILTER_YES provides better compression.
-
-Lzma86Encode allocates Data with MyAlloc functions.
-RAM Requirements for compressing:
- RamSize = dictionarySize * 11.5 + 6MB + FilterBlockSize
- filterMode FilterBlockSize
- SZ_FILTER_NO 0
- SZ_FILTER_YES inSize
- SZ_FILTER_AUTO inSize
-
-
-Return code:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_PARAM - Incorrect paramater
- SZ_ERROR_OUTPUT_EOF - output buffer overflow
- SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
-*/
-
-enum ESzFilterMode
-{
- SZ_FILTER_NO,
- SZ_FILTER_YES,
- SZ_FILTER_AUTO
-};
-
-SRes Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
- int level, UInt32 dictSize, int filterMode);
-
-
-/*
-Lzma86_GetUnpackSize:
- In:
- src - input data
- srcLen - input data size
- Out:
- unpackSize - size of uncompressed stream
- Return code:
- SZ_OK - OK
- SZ_ERROR_INPUT_EOF - Error in headers
-*/
-
-SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize);
-
-/*
-Lzma86_Decode:
- In:
- dest - output data
- destLen - output data size
- src - input data
- srcLen - input data size
- Out:
- destLen - processed output size
- srcLen - processed input size
- Return code:
- SZ_OK - OK
- SZ_ERROR_DATA - Data error
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_UNSUPPORTED - unsupported file
- SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer
-*/
-
-SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen);
-
-EXTERN_C_END
-
-#endif
+/* Lzma86.h -- LZMA + x86 (BCJ) Filter
+2023-03-03 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA86_H
+#define ZIP7_INC_LZMA86_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define LZMA86_SIZE_OFFSET (1 + 5)
+#define LZMA86_HEADER_SIZE (LZMA86_SIZE_OFFSET + 8)
+
+/*
+It's an example for LZMA + x86 Filter use.
+You can use .lzma86 extension, if you write that stream to file.
+.lzma86 header adds one additional byte to standard .lzma header.
+.lzma86 header (14 bytes):
+ Offset Size Description
+ 0 1 = 0 - no filter, pure LZMA
+ = 1 - x86 filter + LZMA
+ 1 1 lc, lp and pb in encoded form
+ 2 4 dictSize (little endian)
+ 6 8 uncompressed size (little endian)
+
+
+Lzma86_Encode
+-------------
+level - compression level: 0 <= level <= 9, the default value for "level" is 5.
+
+dictSize - The dictionary size in bytes. The maximum value is
+ 128 MB = (1 << 27) bytes for 32-bit version
+ 1 GB = (1 << 30) bytes for 64-bit version
+ The default value is 16 MB = (1 << 24) bytes, for level = 5.
+ It's recommended to use the dictionary that is larger than 4 KB and
+ that can be calculated as (1 << N) or (3 << N) sizes.
+ For better compression ratio dictSize must be >= inSize.
+
+filterMode:
+ SZ_FILTER_NO - no Filter
+ SZ_FILTER_YES - x86 Filter
+ SZ_FILTER_AUTO - it tries both alternatives to select best.
+ Encoder will use 2 or 3 passes:
+ 2 passes when FILTER_NO provides better compression.
+ 3 passes when FILTER_YES provides better compression.
+
+Lzma86Encode allocates Data with MyAlloc functions.
+RAM Requirements for compressing:
+ RamSize = dictionarySize * 11.5 + 6MB + FilterBlockSize
+ filterMode FilterBlockSize
+ SZ_FILTER_NO 0
+ SZ_FILTER_YES inSize
+ SZ_FILTER_AUTO inSize
+
+
+Return code:
+ SZ_OK - OK
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_PARAM - Incorrect paramater
+ SZ_ERROR_OUTPUT_EOF - output buffer overflow
+ SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
+*/
+
+enum ESzFilterMode
+{
+ SZ_FILTER_NO,
+ SZ_FILTER_YES,
+ SZ_FILTER_AUTO
+};
+
+SRes Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
+ int level, UInt32 dictSize, int filterMode);
+
+
+/*
+Lzma86_GetUnpackSize:
+ In:
+ src - input data
+ srcLen - input data size
+ Out:
+ unpackSize - size of uncompressed stream
+ Return code:
+ SZ_OK - OK
+ SZ_ERROR_INPUT_EOF - Error in headers
+*/
+
+SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize);
+
+/*
+Lzma86_Decode:
+ In:
+ dest - output data
+ destLen - output data size
+ src - input data
+ srcLen - input data size
+ Out:
+ destLen - processed output size
+ srcLen - processed input size
+ Return code:
+ SZ_OK - OK
+ SZ_ERROR_DATA - Data error
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_UNSUPPORTED - unsupported file
+ SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer
+*/
+
+SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Lzma86Dec.c b/C/Lzma86Dec.c
index 20ac5e7..f094d4c 100644
--- a/C/Lzma86Dec.c
+++ b/C/Lzma86Dec.c
@@ -1,54 +1,53 @@
-/* Lzma86Dec.c -- LZMA + x86 (BCJ) Filter Decoder
-2016-05-16 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Lzma86.h"
-
-#include "Alloc.h"
-#include "Bra.h"
-#include "LzmaDec.h"
-
-SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize)
-{
- unsigned i;
- if (srcLen < LZMA86_HEADER_SIZE)
- return SZ_ERROR_INPUT_EOF;
- *unpackSize = 0;
- for (i = 0; i < sizeof(UInt64); i++)
- *unpackSize += ((UInt64)src[LZMA86_SIZE_OFFSET + i]) << (8 * i);
- return SZ_OK;
-}
-
-SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen)
-{
- SRes res;
- int useFilter;
- SizeT inSizePure;
- ELzmaStatus status;
-
- if (*srcLen < LZMA86_HEADER_SIZE)
- return SZ_ERROR_INPUT_EOF;
-
- useFilter = src[0];
-
- if (useFilter > 1)
- {
- *destLen = 0;
- return SZ_ERROR_UNSUPPORTED;
- }
-
- inSizePure = *srcLen - LZMA86_HEADER_SIZE;
- res = LzmaDecode(dest, destLen, src + LZMA86_HEADER_SIZE, &inSizePure,
- src + 1, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &g_Alloc);
- *srcLen = inSizePure + LZMA86_HEADER_SIZE;
- if (res != SZ_OK)
- return res;
- if (useFilter == 1)
- {
- UInt32 x86State;
- x86_Convert_Init(x86State);
- x86_Convert(dest, *destLen, 0, &x86State, 0);
- }
- return SZ_OK;
-}
+/* Lzma86Dec.c -- LZMA + x86 (BCJ) Filter Decoder
+2023-03-03 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Lzma86.h"
+
+#include "Alloc.h"
+#include "Bra.h"
+#include "LzmaDec.h"
+
+SRes Lzma86_GetUnpackSize(const Byte *src, SizeT srcLen, UInt64 *unpackSize)
+{
+ unsigned i;
+ if (srcLen < LZMA86_HEADER_SIZE)
+ return SZ_ERROR_INPUT_EOF;
+ *unpackSize = 0;
+ for (i = 0; i < sizeof(UInt64); i++)
+ *unpackSize += ((UInt64)src[LZMA86_SIZE_OFFSET + i]) << (8 * i);
+ return SZ_OK;
+}
+
+SRes Lzma86_Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen)
+{
+ SRes res;
+ int useFilter;
+ SizeT inSizePure;
+ ELzmaStatus status;
+
+ if (*srcLen < LZMA86_HEADER_SIZE)
+ return SZ_ERROR_INPUT_EOF;
+
+ useFilter = src[0];
+
+ if (useFilter > 1)
+ {
+ *destLen = 0;
+ return SZ_ERROR_UNSUPPORTED;
+ }
+
+ inSizePure = *srcLen - LZMA86_HEADER_SIZE;
+ res = LzmaDecode(dest, destLen, src + LZMA86_HEADER_SIZE, &inSizePure,
+ src + 1, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &g_Alloc);
+ *srcLen = inSizePure + LZMA86_HEADER_SIZE;
+ if (res != SZ_OK)
+ return res;
+ if (useFilter == 1)
+ {
+ UInt32 x86State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
+ z7_BranchConvSt_X86_Dec(dest, *destLen, 0, &x86State);
+ }
+ return SZ_OK;
+}
diff --git a/C/Lzma86Enc.c b/C/Lzma86Enc.c
index 8d35e6d..0cdde1c 100644
--- a/C/Lzma86Enc.c
+++ b/C/Lzma86Enc.c
@@ -1,106 +1,103 @@
-/* Lzma86Enc.c -- LZMA + x86 (BCJ) Filter Encoder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "Lzma86.h"
-
-#include "Alloc.h"
-#include "Bra.h"
-#include "LzmaEnc.h"
-
-#define SZE_OUT_OVERFLOW SZE_DATA_ERROR
-
-int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
- int level, UInt32 dictSize, int filterMode)
-{
- size_t outSize2 = *destLen;
- Byte *filteredStream;
- BoolInt useFilter;
- int mainResult = SZ_ERROR_OUTPUT_EOF;
- CLzmaEncProps props;
- LzmaEncProps_Init(&props);
- props.level = level;
- props.dictSize = dictSize;
-
- *destLen = 0;
- if (outSize2 < LZMA86_HEADER_SIZE)
- return SZ_ERROR_OUTPUT_EOF;
-
- {
- int i;
- UInt64 t = srcLen;
- for (i = 0; i < 8; i++, t >>= 8)
- dest[LZMA86_SIZE_OFFSET + i] = (Byte)t;
- }
-
- filteredStream = 0;
- useFilter = (filterMode != SZ_FILTER_NO);
- if (useFilter)
- {
- if (srcLen != 0)
- {
- filteredStream = (Byte *)MyAlloc(srcLen);
- if (filteredStream == 0)
- return SZ_ERROR_MEM;
- memcpy(filteredStream, src, srcLen);
- }
- {
- UInt32 x86State;
- x86_Convert_Init(x86State);
- x86_Convert(filteredStream, srcLen, 0, &x86State, 1);
- }
- }
-
- {
- size_t minSize = 0;
- BoolInt bestIsFiltered = False;
-
- /* passes for SZ_FILTER_AUTO:
- 0 - BCJ + LZMA
- 1 - LZMA
- 2 - BCJ + LZMA agaian, if pass 0 (BCJ + LZMA) is better.
- */
- int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
-
- int i;
- for (i = 0; i < numPasses; i++)
- {
- size_t outSizeProcessed = outSize2 - LZMA86_HEADER_SIZE;
- size_t outPropsSize = 5;
- SRes curRes;
- BoolInt curModeIsFiltered = (numPasses > 1 && i == numPasses - 1);
- if (curModeIsFiltered && !bestIsFiltered)
- break;
- if (useFilter && i == 0)
- curModeIsFiltered = True;
-
- curRes = LzmaEncode(dest + LZMA86_HEADER_SIZE, &outSizeProcessed,
- curModeIsFiltered ? filteredStream : src, srcLen,
- &props, dest + 1, &outPropsSize, 0,
- NULL, &g_Alloc, &g_Alloc);
-
- if (curRes != SZ_ERROR_OUTPUT_EOF)
- {
- if (curRes != SZ_OK)
- {
- mainResult = curRes;
- break;
- }
- if (outSizeProcessed <= minSize || mainResult != SZ_OK)
- {
- minSize = outSizeProcessed;
- bestIsFiltered = curModeIsFiltered;
- mainResult = SZ_OK;
- }
- }
- }
- dest[0] = (Byte)(bestIsFiltered ? 1 : 0);
- *destLen = LZMA86_HEADER_SIZE + minSize;
- }
- if (useFilter)
- MyFree(filteredStream);
- return mainResult;
-}
+/* Lzma86Enc.c -- LZMA + x86 (BCJ) Filter Encoder
+2023-03-03 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Lzma86.h"
+
+#include "Alloc.h"
+#include "Bra.h"
+#include "LzmaEnc.h"
+
+int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
+ int level, UInt32 dictSize, int filterMode)
+{
+ size_t outSize2 = *destLen;
+ Byte *filteredStream;
+ BoolInt useFilter;
+ int mainResult = SZ_ERROR_OUTPUT_EOF;
+ CLzmaEncProps props;
+ LzmaEncProps_Init(&props);
+ props.level = level;
+ props.dictSize = dictSize;
+
+ *destLen = 0;
+ if (outSize2 < LZMA86_HEADER_SIZE)
+ return SZ_ERROR_OUTPUT_EOF;
+
+ {
+ int i;
+ UInt64 t = srcLen;
+ for (i = 0; i < 8; i++, t >>= 8)
+ dest[LZMA86_SIZE_OFFSET + i] = (Byte)t;
+ }
+
+ filteredStream = 0;
+ useFilter = (filterMode != SZ_FILTER_NO);
+ if (useFilter)
+ {
+ if (srcLen != 0)
+ {
+ filteredStream = (Byte *)MyAlloc(srcLen);
+ if (filteredStream == 0)
+ return SZ_ERROR_MEM;
+ memcpy(filteredStream, src, srcLen);
+ }
+ {
+ UInt32 x86State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
+ z7_BranchConvSt_X86_Enc(filteredStream, srcLen, 0, &x86State);
+ }
+ }
+
+ {
+ size_t minSize = 0;
+ BoolInt bestIsFiltered = False;
+
+ /* passes for SZ_FILTER_AUTO:
+ 0 - BCJ + LZMA
+ 1 - LZMA
+ 2 - BCJ + LZMA agaian, if pass 0 (BCJ + LZMA) is better.
+ */
+ int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
+
+ int i;
+ for (i = 0; i < numPasses; i++)
+ {
+ size_t outSizeProcessed = outSize2 - LZMA86_HEADER_SIZE;
+ size_t outPropsSize = 5;
+ SRes curRes;
+ BoolInt curModeIsFiltered = (numPasses > 1 && i == numPasses - 1);
+ if (curModeIsFiltered && !bestIsFiltered)
+ break;
+ if (useFilter && i == 0)
+ curModeIsFiltered = True;
+
+ curRes = LzmaEncode(dest + LZMA86_HEADER_SIZE, &outSizeProcessed,
+ curModeIsFiltered ? filteredStream : src, srcLen,
+ &props, dest + 1, &outPropsSize, 0,
+ NULL, &g_Alloc, &g_Alloc);
+
+ if (curRes != SZ_ERROR_OUTPUT_EOF)
+ {
+ if (curRes != SZ_OK)
+ {
+ mainResult = curRes;
+ break;
+ }
+ if (outSizeProcessed <= minSize || mainResult != SZ_OK)
+ {
+ minSize = outSizeProcessed;
+ bestIsFiltered = curModeIsFiltered;
+ mainResult = SZ_OK;
+ }
+ }
+ }
+ dest[0] = (Byte)(bestIsFiltered ? 1 : 0);
+ *destLen = LZMA86_HEADER_SIZE + minSize;
+ }
+ if (useFilter)
+ MyFree(filteredStream);
+ return mainResult;
+}
diff --git a/C/LzmaDec.c b/C/LzmaDec.c
index 4d15764..69bb8bb 100644
--- a/C/LzmaDec.c
+++ b/C/LzmaDec.c
@@ -1,1185 +1,1363 @@
-/* LzmaDec.c -- LZMA Decoder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-/* #include "CpuArch.h" */
-#include "LzmaDec.h"
-
-#define kNumTopBits 24
-#define kTopValue ((UInt32)1 << kNumTopBits)
-
-#define kNumBitModelTotalBits 11
-#define kBitModelTotal (1 << kNumBitModelTotalBits)
-#define kNumMoveBits 5
-
-#define RC_INIT_SIZE 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 _LZMA_SIZE_OPT */
-
-#ifdef _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; , ;)
-
-
-
-#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; 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)
-
-/* 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 : normal remain
- = kMatchSpecLenStart : finished
- = kMatchSpecLenStart + 1 : need init range coder
- = kMatchSpecLenStart + 2 : need init range coder and state
-*/
-
-/* ---------- 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 function returns error code.
- }
-
-Processing:
- first LZMA symbol will be decoded in any case
- All checks for limits are at the end of main loop,
- It will decode new LZMA-symbols while (p->buf < bufLimit && dicPos < limit),
- RangeCoder is still without last normalization when (p->buf < bufLimit) is being checked.
-
-Out:
- RangeCoder is normalized
- Result:
- SZ_OK - OK
- SZ_ERROR_DATA - Error
- p->remainLen:
- < kMatchSpecLenStart : normal remain
- = kMatchSpecLenStart : finished
-*/
-
-
-#ifdef _LZMA_DEC_OPT
-
-int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit);
-
-#else
-
-static
-int MY_FAST_CALL 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 _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 _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);
- /*
- // that case was checked before with kBadRepCode
- if (checkDicSize == 0 && processedPos == 0)
- return SZ_ERROR_DATA;
- */
- prob = probs + IsRepG0 + state;
- IF_BIT_0(prob)
- {
- UPDATE_0(prob);
- prob = probs + IsRep0Long + COMBINED_PS_STATE;
- IF_BIT_0(prob)
- {
- UPDATE_0(prob);
- 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 _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))
- {
- p->dicPos = dicPos;
- return SZ_ERROR_DATA;
- }
- }
-
- len += kMatchMinLen;
-
- {
- SizeT rem;
- unsigned curLen;
- SizeT pos;
-
- if ((rem = limit - dicPos) == 0)
- {
- p->dicPos = dicPos;
- return SZ_ERROR_DATA;
- }
-
- 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;
- 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;
-
- return SZ_OK;
-}
-#endif
-
-static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
-{
- if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
- {
- Byte *dic = p->dic;
- SizeT dicPos = p->dicPos;
- SizeT dicBufSize = p->dicBufSize;
- unsigned len = (unsigned)p->remainLen;
- SizeT rep0 = p->reps[0]; /* we use SizeT to avoid the BUG of VC14 for AMD64 */
- SizeT rem = limit - dicPos;
- if (rem < len)
- len = (unsigned)(rem);
-
- if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
- p->checkDicSize = p->prop.dicSize;
-
- p->processedPos += (UInt32)len;
- p->remainLen -= (UInt32)len;
- while (len != 0)
- {
- len--;
- dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
- dicPos++;
- }
- p->dicPos = dicPos;
- }
-}
-
-
-#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
-
-static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
-{
- do
- {
- SizeT limit2 = limit;
- if (p->checkDicSize == 0)
- {
- UInt32 rem = p->prop.dicSize - p->processedPos;
- if (limit - p->dicPos > rem)
- limit2 = p->dicPos + rem;
-
- if (p->processedPos == 0)
- if (p->code >= kBadRepCode)
- return SZ_ERROR_DATA;
- }
-
- RINOK(LZMA_DECODE_REAL(p, limit2, bufLimit));
-
- if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)
- p->checkDicSize = p->prop.dicSize;
-
- LzmaDec_WriteRem(p, limit);
- }
- while (p->dicPos < limit && p->buf < bufLimit && p->remainLen < kMatchSpecLenStart);
-
- return 0;
-}
-
-typedef enum
-{
- DUMMY_ERROR, /* unexpected end of input stream */
- DUMMY_LIT,
- DUMMY_MATCH,
- DUMMY_REP
-} ELzmaDummy;
-
-static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
-{
- UInt32 range = p->range;
- UInt32 code = p->code;
- const Byte *bufLimit = buf + inSize;
- const CLzmaProb *probs = GET_PROBS;
- unsigned state = (unsigned)p->state;
- ELzmaDummy res;
-
- {
- const CLzmaProb *prob;
- UInt32 bound;
- unsigned ttt;
- unsigned posState = CALC_POS_STATE(p->processedPos, (1 << p->prop.pb) - 1);
-
- prob = probs + IsMatch + COMBINED_PS_STATE;
- IF_BIT_0_CHECK(prob)
- {
- UPDATE_0_CHECK
-
- /* if (bufLimit - buf >= 7) return DUMMY_LIT; */
-
- prob = probs + Literal;
- if (p->checkDicSize != 0 || p->processedPos != 0)
- prob += ((UInt32)LZMA_LIT_SIZE *
- ((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
- (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;
- NORMALIZE_CHECK;
- return DUMMY_REP;
- }
- 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 (bufLimit - buf >= 8) return DUMMY_MATCH; */
-
- 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);
- }
- }
- }
- }
- }
- NORMALIZE_CHECK;
- return res;
-}
-
-
-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);
-}
-
-
-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)
- {
- 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]);
- 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;
- }
-
- LzmaDec_WriteRem(p, dicLimit);
-
- while (p->remainLen != kMatchSpecLenStart)
- {
- 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)
- {
- *status = LZMA_STATUS_NOT_FINISHED;
- return SZ_ERROR_DATA;
- }
- checkEndMarkNow = 1;
- }
-
- if (p->tempBufSize == 0)
- {
- SizeT processed;
- const Byte *bufLimit;
- if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
- {
- int dummyRes = LzmaDec_TryDummy(p, src, inSize);
- if (dummyRes == DUMMY_ERROR)
- {
- memcpy(p->tempBuf, src, inSize);
- p->tempBufSize = (unsigned)inSize;
- (*srcLen) += inSize;
- *status = LZMA_STATUS_NEEDS_MORE_INPUT;
- return SZ_OK;
- }
- if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
- {
- *status = LZMA_STATUS_NOT_FINISHED;
- return SZ_ERROR_DATA;
- }
- bufLimit = src;
- }
- else
- bufLimit = src + inSize - LZMA_REQUIRED_INPUT_MAX;
- p->buf = src;
- if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
- return SZ_ERROR_DATA;
- processed = (SizeT)(p->buf - src);
- (*srcLen) += processed;
- src += processed;
- inSize -= processed;
- }
- else
- {
- unsigned rem = p->tempBufSize, lookAhead = 0;
- while (rem < LZMA_REQUIRED_INPUT_MAX && lookAhead < inSize)
- p->tempBuf[rem++] = src[lookAhead++];
- p->tempBufSize = rem;
- if (rem < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
- {
- int dummyRes = LzmaDec_TryDummy(p, p->tempBuf, (SizeT)rem);
- if (dummyRes == DUMMY_ERROR)
- {
- (*srcLen) += (SizeT)lookAhead;
- *status = LZMA_STATUS_NEEDS_MORE_INPUT;
- return SZ_OK;
- }
- if (checkEndMarkNow && dummyRes != DUMMY_MATCH)
- {
- *status = LZMA_STATUS_NOT_FINISHED;
- return SZ_ERROR_DATA;
- }
- }
- p->buf = p->tempBuf;
- if (LzmaDec_DecodeReal2(p, dicLimit, p->buf) != 0)
- return SZ_ERROR_DATA;
-
- {
- unsigned kkk = (unsigned)(p->buf - p->tempBuf);
- if (rem < kkk)
- return SZ_ERROR_FAIL; /* some internal error */
- rem -= kkk;
- if (lookAhead < rem)
- return SZ_ERROR_FAIL; /* some internal error */
- lookAhead -= rem;
- }
- (*srcLen) += (SizeT)lookAhead;
- src += lookAhead;
- inSize -= (SizeT)lookAhead;
- p->tempBufSize = 0;
- }
- }
-
- if (p->code != 0)
- return SZ_ERROR_DATA;
- *status = LZMA_STATUS_FINISHED_WITH_MARK;
- return SZ_OK;
-}
-
-
-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;
-}
+/* 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;
+}
diff --git a/C/LzmaDec.h b/C/LzmaDec.h
index 28ce60c..b0ce28f 100644
--- a/C/LzmaDec.h
+++ b/C/LzmaDec.h
@@ -1,234 +1,237 @@
-/* LzmaDec.h -- LZMA Decoder
-2018-04-21 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA_DEC_H
-#define __LZMA_DEC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-/* #define _LZMA_PROB32 */
-/* _LZMA_PROB32 can increase the speed on some CPUs,
- but memory usage for CLzmaDec::probs will be doubled in that case */
-
-typedef
-#ifdef _LZMA_PROB32
- UInt32
-#else
- UInt16
-#endif
- CLzmaProb;
-
-
-/* ---------- LZMA Properties ---------- */
-
-#define LZMA_PROPS_SIZE 5
-
-typedef struct _CLzmaProps
-{
- 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; }
-
-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
-*/
-
-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).
-*/
-
-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
+/* 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
diff --git a/C/LzmaEnc.c b/C/LzmaEnc.c
index 14086fc..6d13cac 100644
--- a/C/LzmaEnc.c
+++ b/C/LzmaEnc.c
@@ -1,2976 +1,3144 @@
-/* LzmaEnc.c -- LZMA Encoder
-2019-01-10: Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-/* #define SHOW_STAT */
-/* #define SHOW_STAT2 */
-
-#if defined(SHOW_STAT) || defined(SHOW_STAT2)
-#include <stdio.h>
-#endif
-
-#include "LzmaEnc.h"
-
-#include "LzFind.h"
-#ifndef _7ZIP_ST
-#include "LzFindMt.h"
-#endif
-
-#ifdef SHOW_STAT
-static unsigned g_STAT_OFFSET = 0;
-#endif
-
-#define kLzmaMaxHistorySize ((UInt32)3 << 29)
-/* #define kLzmaMaxHistorySize ((UInt32)7 << 29) */
-
-#define kNumTopBits 24
-#define kTopValue ((UInt32)1 << kNumTopBits)
-
-#define kNumBitModelTotalBits 11
-#define kBitModelTotal (1 << kNumBitModelTotalBits)
-#define kNumMoveBits 5
-#define kProbInitValue (kBitModelTotal >> 1)
-
-#define kNumMoveReducingBits 4
-#define kNumBitPriceShiftBits 4
-#define kBitPrice (1 << kNumBitPriceShiftBits)
-
-#define REP_LEN_COUNT 64
-
-void LzmaEncProps_Init(CLzmaEncProps *p)
-{
- p->level = 5;
- p->dictSize = p->mc = 0;
- p->reduceSize = (UInt64)(Int64)-1;
- p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
- p->writeEndMark = 0;
-}
-
-void LzmaEncProps_Normalize(CLzmaEncProps *p)
-{
- int level = p->level;
- if (level < 0) level = 5;
- p->level = level;
-
- if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level <= 7 ? (1 << 25) : (1 << 26)));
- if (p->dictSize > p->reduceSize)
- {
- unsigned i;
- UInt32 reduceSize = (UInt32)p->reduceSize;
- for (i = 11; i <= 30; i++)
- {
- if (reduceSize <= ((UInt32)2 << i)) { p->dictSize = ((UInt32)2 << i); break; }
- if (reduceSize <= ((UInt32)3 << i)) { p->dictSize = ((UInt32)3 << i); break; }
- }
- }
-
- if (p->lc < 0) p->lc = 3;
- if (p->lp < 0) p->lp = 0;
- if (p->pb < 0) p->pb = 2;
-
- if (p->algo < 0) p->algo = (level < 5 ? 0 : 1);
- if (p->fb < 0) p->fb = (level < 7 ? 32 : 64);
- if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
- if (p->numHashBytes < 0) p->numHashBytes = 4;
- if (p->mc == 0) p->mc = (16 + (p->fb >> 1)) >> (p->btMode ? 0 : 1);
-
- if (p->numThreads < 0)
- p->numThreads =
- #ifndef _7ZIP_ST
- ((p->btMode && p->algo) ? 2 : 1);
- #else
- 1;
- #endif
-}
-
-UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
-{
- CLzmaEncProps props = *props2;
- LzmaEncProps_Normalize(&props);
- return props.dictSize;
-}
-
-#if (_MSC_VER >= 1400)
-/* BSR code is fast for some new CPUs */
-/* #define LZMA_LOG_BSR */
-#endif
-
-#ifdef LZMA_LOG_BSR
-
-#define kDicLogSizeMaxCompress 32
-
-#define BSR2_RET(pos, res) { unsigned long zz; _BitScanReverse(&zz, (pos)); res = (zz + zz) + ((pos >> (zz - 1)) & 1); }
-
-static unsigned GetPosSlot1(UInt32 pos)
-{
- unsigned res;
- BSR2_RET(pos, res);
- return res;
-}
-#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
-#define GetPosSlot(pos, res) { if (pos < 2) res = pos; else BSR2_RET(pos, res); }
-
-#else
-
-#define kNumLogBits (9 + sizeof(size_t) / 2)
-/* #define kNumLogBits (11 + sizeof(size_t) / 8 * 3) */
-
-#define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)
-
-static void LzmaEnc_FastPosInit(Byte *g_FastPos)
-{
- unsigned slot;
- g_FastPos[0] = 0;
- g_FastPos[1] = 1;
- g_FastPos += 2;
-
- for (slot = 2; slot < kNumLogBits * 2; slot++)
- {
- size_t k = ((size_t)1 << ((slot >> 1) - 1));
- size_t j;
- for (j = 0; j < k; j++)
- g_FastPos[j] = (Byte)slot;
- g_FastPos += k;
- }
-}
-
-/* we can use ((limit - pos) >> 31) only if (pos < ((UInt32)1 << 31)) */
-/*
-#define BSR2_RET(pos, res) { unsigned zz = 6 + ((kNumLogBits - 1) & \
- (0 - (((((UInt32)1 << (kNumLogBits + 6)) - 1) - pos) >> 31))); \
- res = p->g_FastPos[pos >> zz] + (zz * 2); }
-*/
-
-/*
-#define BSR2_RET(pos, res) { unsigned zz = 6 + ((kNumLogBits - 1) & \
- (0 - (((((UInt32)1 << (kNumLogBits)) - 1) - (pos >> 6)) >> 31))); \
- res = p->g_FastPos[pos >> zz] + (zz * 2); }
-*/
-
-#define BSR2_RET(pos, res) { unsigned zz = (pos < (1 << (kNumLogBits + 6))) ? 6 : 6 + kNumLogBits - 1; \
- res = p->g_FastPos[pos >> zz] + (zz * 2); }
-
-/*
-#define BSR2_RET(pos, res) { res = (pos < (1 << (kNumLogBits + 6))) ? \
- p->g_FastPos[pos >> 6] + 12 : \
- p->g_FastPos[pos >> (6 + kNumLogBits - 1)] + (6 + (kNumLogBits - 1)) * 2; }
-*/
-
-#define GetPosSlot1(pos) p->g_FastPos[pos]
-#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
-#define GetPosSlot(pos, res) { if (pos < kNumFullDistances) res = p->g_FastPos[pos & (kNumFullDistances - 1)]; else BSR2_RET(pos, res); }
-
-#endif
-
-
-#define LZMA_NUM_REPS 4
-
-typedef UInt16 CState;
-typedef UInt16 CExtra;
-
-typedef struct
-{
- UInt32 price;
- CState state;
- CExtra extra;
- // 0 : normal
- // 1 : LIT : MATCH
- // > 1 : MATCH (extra-1) : LIT : REP0 (len)
- UInt32 len;
- UInt32 dist;
- UInt32 reps[LZMA_NUM_REPS];
-} COptimal;
-
-
-// 18.06
-#define kNumOpts (1 << 11)
-#define kPackReserve (kNumOpts * 8)
-// #define kNumOpts (1 << 12)
-// #define kPackReserve (1 + kNumOpts * 2)
-
-#define kNumLenToPosStates 4
-#define kNumPosSlotBits 6
-#define kDicLogSizeMin 0
-#define kDicLogSizeMax 32
-#define kDistTableSizeMax (kDicLogSizeMax * 2)
-
-#define kNumAlignBits 4
-#define kAlignTableSize (1 << kNumAlignBits)
-#define kAlignMask (kAlignTableSize - 1)
-
-#define kStartPosModelIndex 4
-#define kEndPosModelIndex 14
-#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
-
-typedef
-#ifdef _LZMA_PROB32
- UInt32
-#else
- UInt16
-#endif
- CLzmaProb;
-
-#define LZMA_PB_MAX 4
-#define LZMA_LC_MAX 8
-#define LZMA_LP_MAX 4
-
-#define LZMA_NUM_PB_STATES_MAX (1 << LZMA_PB_MAX)
-
-#define kLenNumLowBits 3
-#define kLenNumLowSymbols (1 << kLenNumLowBits)
-#define kLenNumHighBits 8
-#define kLenNumHighSymbols (1 << kLenNumHighBits)
-#define kLenNumSymbolsTotal (kLenNumLowSymbols * 2 + kLenNumHighSymbols)
-
-#define LZMA_MATCH_LEN_MIN 2
-#define LZMA_MATCH_LEN_MAX (LZMA_MATCH_LEN_MIN + kLenNumSymbolsTotal - 1)
-
-#define kNumStates 12
-
-
-typedef struct
-{
- CLzmaProb low[LZMA_NUM_PB_STATES_MAX << (kLenNumLowBits + 1)];
- CLzmaProb high[kLenNumHighSymbols];
-} CLenEnc;
-
-
-typedef struct
-{
- unsigned tableSize;
- UInt32 prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal];
- // UInt32 prices1[LZMA_NUM_PB_STATES_MAX][kLenNumLowSymbols * 2];
- // UInt32 prices2[kLenNumSymbolsTotal];
-} CLenPriceEnc;
-
-#define GET_PRICE_LEN(p, posState, len) \
- ((p)->prices[posState][(size_t)(len) - LZMA_MATCH_LEN_MIN])
-
-/*
-#define GET_PRICE_LEN(p, posState, len) \
- ((p)->prices2[(size_t)(len) - 2] + ((p)->prices1[posState][((len) - 2) & (kLenNumLowSymbols * 2 - 1)] & (((len) - 2 - kLenNumLowSymbols * 2) >> 9)))
-*/
-
-typedef struct
-{
- UInt32 range;
- unsigned cache;
- UInt64 low;
- UInt64 cacheSize;
- Byte *buf;
- Byte *bufLim;
- Byte *bufBase;
- ISeqOutStream *outStream;
- UInt64 processed;
- SRes res;
-} CRangeEnc;
-
-
-typedef struct
-{
- CLzmaProb *litProbs;
-
- unsigned state;
- UInt32 reps[LZMA_NUM_REPS];
-
- CLzmaProb posAlignEncoder[1 << kNumAlignBits];
- CLzmaProb isRep[kNumStates];
- CLzmaProb isRepG0[kNumStates];
- CLzmaProb isRepG1[kNumStates];
- CLzmaProb isRepG2[kNumStates];
- CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
- CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
-
- CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
- CLzmaProb posEncoders[kNumFullDistances];
-
- CLenEnc lenProbs;
- CLenEnc repLenProbs;
-
-} CSaveState;
-
-
-typedef UInt32 CProbPrice;
-
-
-typedef struct
-{
- void *matchFinderObj;
- IMatchFinder matchFinder;
-
- unsigned optCur;
- unsigned optEnd;
-
- unsigned longestMatchLen;
- unsigned numPairs;
- UInt32 numAvail;
-
- unsigned state;
- unsigned numFastBytes;
- unsigned additionalOffset;
- UInt32 reps[LZMA_NUM_REPS];
- unsigned lpMask, pbMask;
- CLzmaProb *litProbs;
- CRangeEnc rc;
-
- UInt32 backRes;
-
- unsigned lc, lp, pb;
- unsigned lclp;
-
- BoolInt fastMode;
- BoolInt writeEndMark;
- BoolInt finished;
- BoolInt multiThread;
- BoolInt needInit;
- // BoolInt _maxMode;
-
- UInt64 nowPos64;
-
- unsigned matchPriceCount;
- // unsigned alignPriceCount;
- int repLenEncCounter;
-
- unsigned distTableSize;
-
- UInt32 dictSize;
- SRes result;
-
- #ifndef _7ZIP_ST
- BoolInt mtMode;
- // begin of CMatchFinderMt is used in LZ thread
- CMatchFinderMt matchFinderMt;
- // end of CMatchFinderMt is used in BT and HASH threads
- #endif
-
- CMatchFinder matchFinderBase;
-
- #ifndef _7ZIP_ST
- Byte pad[128];
- #endif
-
- // LZ thread
- CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
-
- UInt32 matches[LZMA_MATCH_LEN_MAX * 2 + 2 + 1];
-
- UInt32 alignPrices[kAlignTableSize];
- UInt32 posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
- UInt32 distancesPrices[kNumLenToPosStates][kNumFullDistances];
-
- CLzmaProb posAlignEncoder[1 << kNumAlignBits];
- CLzmaProb isRep[kNumStates];
- CLzmaProb isRepG0[kNumStates];
- CLzmaProb isRepG1[kNumStates];
- CLzmaProb isRepG2[kNumStates];
- CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
- CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
- CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
- CLzmaProb posEncoders[kNumFullDistances];
-
- CLenEnc lenProbs;
- CLenEnc repLenProbs;
-
- #ifndef LZMA_LOG_BSR
- Byte g_FastPos[1 << kNumLogBits];
- #endif
-
- CLenPriceEnc lenEnc;
- CLenPriceEnc repLenEnc;
-
- COptimal opt[kNumOpts];
-
- CSaveState saveState;
-
- #ifndef _7ZIP_ST
- Byte pad2[128];
- #endif
-} CLzmaEnc;
-
-
-
-#define COPY_ARR(dest, src, arr) memcpy(dest->arr, src->arr, sizeof(src->arr));
-
-void LzmaEnc_SaveState(CLzmaEncHandle pp)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- CSaveState *dest = &p->saveState;
-
- dest->state = p->state;
-
- dest->lenProbs = p->lenProbs;
- dest->repLenProbs = p->repLenProbs;
-
- COPY_ARR(dest, p, reps);
-
- COPY_ARR(dest, p, posAlignEncoder);
- COPY_ARR(dest, p, isRep);
- COPY_ARR(dest, p, isRepG0);
- COPY_ARR(dest, p, isRepG1);
- COPY_ARR(dest, p, isRepG2);
- COPY_ARR(dest, p, isMatch);
- COPY_ARR(dest, p, isRep0Long);
- COPY_ARR(dest, p, posSlotEncoder);
- COPY_ARR(dest, p, posEncoders);
-
- memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << p->lclp) * sizeof(CLzmaProb));
-}
-
-
-void LzmaEnc_RestoreState(CLzmaEncHandle pp)
-{
- CLzmaEnc *dest = (CLzmaEnc *)pp;
- const CSaveState *p = &dest->saveState;
-
- dest->state = p->state;
-
- dest->lenProbs = p->lenProbs;
- dest->repLenProbs = p->repLenProbs;
-
- COPY_ARR(dest, p, reps);
-
- COPY_ARR(dest, p, posAlignEncoder);
- COPY_ARR(dest, p, isRep);
- COPY_ARR(dest, p, isRepG0);
- COPY_ARR(dest, p, isRepG1);
- COPY_ARR(dest, p, isRepG2);
- COPY_ARR(dest, p, isMatch);
- COPY_ARR(dest, p, isRep0Long);
- COPY_ARR(dest, p, posSlotEncoder);
- COPY_ARR(dest, p, posEncoders);
-
- memcpy(dest->litProbs, p->litProbs, ((UInt32)0x300 << dest->lclp) * sizeof(CLzmaProb));
-}
-
-
-
-SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- CLzmaEncProps props = *props2;
- LzmaEncProps_Normalize(&props);
-
- if (props.lc > LZMA_LC_MAX
- || props.lp > LZMA_LP_MAX
- || props.pb > LZMA_PB_MAX
- || props.dictSize > ((UInt64)1 << kDicLogSizeMaxCompress)
- || props.dictSize > kLzmaMaxHistorySize)
- return SZ_ERROR_PARAM;
-
- p->dictSize = props.dictSize;
- {
- unsigned fb = props.fb;
- if (fb < 5)
- fb = 5;
- if (fb > LZMA_MATCH_LEN_MAX)
- fb = LZMA_MATCH_LEN_MAX;
- p->numFastBytes = fb;
- }
- p->lc = props.lc;
- p->lp = props.lp;
- p->pb = props.pb;
- p->fastMode = (props.algo == 0);
- // p->_maxMode = True;
- p->matchFinderBase.btMode = (Byte)(props.btMode ? 1 : 0);
- {
- unsigned numHashBytes = 4;
- if (props.btMode)
- {
- if (props.numHashBytes < 2)
- numHashBytes = 2;
- else if (props.numHashBytes < 4)
- numHashBytes = props.numHashBytes;
- }
- p->matchFinderBase.numHashBytes = numHashBytes;
- }
-
- p->matchFinderBase.cutValue = props.mc;
-
- p->writeEndMark = props.writeEndMark;
-
- #ifndef _7ZIP_ST
- /*
- if (newMultiThread != _multiThread)
- {
- ReleaseMatchFinder();
- _multiThread = newMultiThread;
- }
- */
- p->multiThread = (props.numThreads > 1);
- #endif
-
- return SZ_OK;
-}
-
-
-void LzmaEnc_SetDataSize(CLzmaEncHandle pp, UInt64 expectedDataSiize)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- p->matchFinderBase.expectedDataSize = expectedDataSiize;
-}
-
-
-#define kState_Start 0
-#define kState_LitAfterMatch 4
-#define kState_LitAfterRep 5
-#define kState_MatchAfterLit 7
-#define kState_RepAfterLit 8
-
-static const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
-static const Byte kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
-static const Byte kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
-static const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
-
-#define IsLitState(s) ((s) < 7)
-#define GetLenToPosState2(len) (((len) < kNumLenToPosStates - 1) ? (len) : kNumLenToPosStates - 1)
-#define GetLenToPosState(len) (((len) < kNumLenToPosStates + 1) ? (len) - 2 : kNumLenToPosStates - 1)
-
-#define kInfinityPrice (1 << 30)
-
-static void RangeEnc_Construct(CRangeEnc *p)
-{
- p->outStream = NULL;
- p->bufBase = NULL;
-}
-
-#define RangeEnc_GetProcessed(p) ((p)->processed + ((p)->buf - (p)->bufBase) + (p)->cacheSize)
-#define RangeEnc_GetProcessed_sizet(p) ((size_t)(p)->processed + ((p)->buf - (p)->bufBase) + (size_t)(p)->cacheSize)
-
-#define RC_BUF_SIZE (1 << 16)
-
-static int RangeEnc_Alloc(CRangeEnc *p, ISzAllocPtr alloc)
-{
- if (!p->bufBase)
- {
- p->bufBase = (Byte *)ISzAlloc_Alloc(alloc, RC_BUF_SIZE);
- if (!p->bufBase)
- return 0;
- p->bufLim = p->bufBase + RC_BUF_SIZE;
- }
- return 1;
-}
-
-static void RangeEnc_Free(CRangeEnc *p, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, p->bufBase);
- p->bufBase = 0;
-}
-
-static void RangeEnc_Init(CRangeEnc *p)
-{
- /* Stream.Init(); */
- p->range = 0xFFFFFFFF;
- p->cache = 0;
- p->low = 0;
- p->cacheSize = 0;
-
- p->buf = p->bufBase;
-
- p->processed = 0;
- p->res = SZ_OK;
-}
-
-MY_NO_INLINE static void RangeEnc_FlushStream(CRangeEnc *p)
-{
- size_t num;
- if (p->res != SZ_OK)
- return;
- num = p->buf - p->bufBase;
- if (num != ISeqOutStream_Write(p->outStream, p->bufBase, num))
- p->res = SZ_ERROR_WRITE;
- p->processed += num;
- p->buf = p->bufBase;
-}
-
-MY_NO_INLINE static void MY_FAST_CALL RangeEnc_ShiftLow(CRangeEnc *p)
-{
- UInt32 low = (UInt32)p->low;
- unsigned high = (unsigned)(p->low >> 32);
- p->low = (UInt32)(low << 8);
- if (low < (UInt32)0xFF000000 || high != 0)
- {
- {
- Byte *buf = p->buf;
- *buf++ = (Byte)(p->cache + high);
- p->cache = (unsigned)(low >> 24);
- p->buf = buf;
- if (buf == p->bufLim)
- RangeEnc_FlushStream(p);
- if (p->cacheSize == 0)
- return;
- }
- high += 0xFF;
- for (;;)
- {
- Byte *buf = p->buf;
- *buf++ = (Byte)(high);
- p->buf = buf;
- if (buf == p->bufLim)
- RangeEnc_FlushStream(p);
- if (--p->cacheSize == 0)
- return;
- }
- }
- p->cacheSize++;
-}
-
-static void RangeEnc_FlushData(CRangeEnc *p)
-{
- int i;
- for (i = 0; i < 5; i++)
- RangeEnc_ShiftLow(p);
-}
-
-#define RC_NORM(p) if (range < kTopValue) { range <<= 8; RangeEnc_ShiftLow(p); }
-
-#define RC_BIT_PRE(p, prob) \
- ttt = *(prob); \
- newBound = (range >> kNumBitModelTotalBits) * ttt;
-
-// #define _LZMA_ENC_USE_BRANCH
-
-#ifdef _LZMA_ENC_USE_BRANCH
-
-#define RC_BIT(p, prob, bit) { \
- RC_BIT_PRE(p, prob) \
- if (bit == 0) { range = newBound; ttt += (kBitModelTotal - ttt) >> kNumMoveBits; } \
- else { (p)->low += newBound; range -= newBound; ttt -= ttt >> kNumMoveBits; } \
- *(prob) = (CLzmaProb)ttt; \
- RC_NORM(p) \
- }
-
-#else
-
-#define RC_BIT(p, prob, bit) { \
- UInt32 mask; \
- RC_BIT_PRE(p, prob) \
- mask = 0 - (UInt32)bit; \
- range &= mask; \
- mask &= newBound; \
- range -= mask; \
- (p)->low += mask; \
- mask = (UInt32)bit - 1; \
- range += newBound & mask; \
- mask &= (kBitModelTotal - ((1 << kNumMoveBits) - 1)); \
- mask += ((1 << kNumMoveBits) - 1); \
- ttt += (Int32)(mask - ttt) >> kNumMoveBits; \
- *(prob) = (CLzmaProb)ttt; \
- RC_NORM(p) \
- }
-
-#endif
-
-
-
-
-#define RC_BIT_0_BASE(p, prob) \
- range = newBound; *(prob) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
-
-#define RC_BIT_1_BASE(p, prob) \
- range -= newBound; (p)->low += newBound; *(prob) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits)); \
-
-#define RC_BIT_0(p, prob) \
- RC_BIT_0_BASE(p, prob) \
- RC_NORM(p)
-
-#define RC_BIT_1(p, prob) \
- RC_BIT_1_BASE(p, prob) \
- RC_NORM(p)
-
-static void RangeEnc_EncodeBit_0(CRangeEnc *p, CLzmaProb *prob)
-{
- UInt32 range, ttt, newBound;
- range = p->range;
- RC_BIT_PRE(p, prob)
- RC_BIT_0(p, prob)
- p->range = range;
-}
-
-static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym)
-{
- UInt32 range = p->range;
- sym |= 0x100;
- do
- {
- UInt32 ttt, newBound;
- // RangeEnc_EncodeBit(p, probs + (sym >> 8), (sym >> 7) & 1);
- CLzmaProb *prob = probs + (sym >> 8);
- UInt32 bit = (sym >> 7) & 1;
- sym <<= 1;
- RC_BIT(p, prob, bit);
- }
- while (sym < 0x10000);
- p->range = range;
-}
-
-static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 sym, UInt32 matchByte)
-{
- UInt32 range = p->range;
- UInt32 offs = 0x100;
- sym |= 0x100;
- do
- {
- UInt32 ttt, newBound;
- CLzmaProb *prob;
- UInt32 bit;
- matchByte <<= 1;
- // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (sym >> 8)), (sym >> 7) & 1);
- prob = probs + (offs + (matchByte & offs) + (sym >> 8));
- bit = (sym >> 7) & 1;
- sym <<= 1;
- offs &= ~(matchByte ^ sym);
- RC_BIT(p, prob, bit);
- }
- while (sym < 0x10000);
- p->range = range;
-}
-
-
-
-static void LzmaEnc_InitPriceTables(CProbPrice *ProbPrices)
-{
- UInt32 i;
- for (i = 0; i < (kBitModelTotal >> kNumMoveReducingBits); i++)
- {
- const unsigned kCyclesBits = kNumBitPriceShiftBits;
- UInt32 w = (i << kNumMoveReducingBits) + (1 << (kNumMoveReducingBits - 1));
- unsigned bitCount = 0;
- unsigned j;
- for (j = 0; j < kCyclesBits; j++)
- {
- w = w * w;
- bitCount <<= 1;
- while (w >= ((UInt32)1 << 16))
- {
- w >>= 1;
- bitCount++;
- }
- }
- ProbPrices[i] = (CProbPrice)((kNumBitModelTotalBits << kCyclesBits) - 15 - bitCount);
- // printf("\n%3d: %5d", i, ProbPrices[i]);
- }
-}
-
-
-#define GET_PRICE(prob, bit) \
- p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
-
-#define GET_PRICEa(prob, bit) \
- ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits];
-
-#define GET_PRICE_0(prob) p->ProbPrices[(prob) >> kNumMoveReducingBits]
-#define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
-
-#define GET_PRICEa_0(prob) ProbPrices[(prob) >> kNumMoveReducingBits]
-#define GET_PRICEa_1(prob) ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
-
-
-static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 sym, const CProbPrice *ProbPrices)
-{
- UInt32 price = 0;
- sym |= 0x100;
- do
- {
- unsigned bit = sym & 1;
- sym >>= 1;
- price += GET_PRICEa(probs[sym], bit);
- }
- while (sym >= 2);
- return price;
-}
-
-
-static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 sym, UInt32 matchByte, const CProbPrice *ProbPrices)
-{
- UInt32 price = 0;
- UInt32 offs = 0x100;
- sym |= 0x100;
- do
- {
- matchByte <<= 1;
- price += GET_PRICEa(probs[offs + (matchByte & offs) + (sym >> 8)], (sym >> 7) & 1);
- sym <<= 1;
- offs &= ~(matchByte ^ sym);
- }
- while (sym < 0x10000);
- return price;
-}
-
-
-static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, unsigned numBits, unsigned sym)
-{
- UInt32 range = rc->range;
- unsigned m = 1;
- do
- {
- UInt32 ttt, newBound;
- unsigned bit = sym & 1;
- // RangeEnc_EncodeBit(rc, probs + m, bit);
- sym >>= 1;
- RC_BIT(rc, probs + m, bit);
- m = (m << 1) | bit;
- }
- while (--numBits);
- rc->range = range;
-}
-
-
-
-static void LenEnc_Init(CLenEnc *p)
-{
- unsigned i;
- for (i = 0; i < (LZMA_NUM_PB_STATES_MAX << (kLenNumLowBits + 1)); i++)
- p->low[i] = kProbInitValue;
- for (i = 0; i < kLenNumHighSymbols; i++)
- p->high[i] = kProbInitValue;
-}
-
-static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned sym, unsigned posState)
-{
- UInt32 range, ttt, newBound;
- CLzmaProb *probs = p->low;
- range = rc->range;
- RC_BIT_PRE(rc, probs);
- if (sym >= kLenNumLowSymbols)
- {
- RC_BIT_1(rc, probs);
- probs += kLenNumLowSymbols;
- RC_BIT_PRE(rc, probs);
- if (sym >= kLenNumLowSymbols * 2)
- {
- RC_BIT_1(rc, probs);
- rc->range = range;
- // RcTree_Encode(rc, p->high, kLenNumHighBits, sym - kLenNumLowSymbols * 2);
- LitEnc_Encode(rc, p->high, sym - kLenNumLowSymbols * 2);
- return;
- }
- sym -= kLenNumLowSymbols;
- }
-
- // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), kLenNumLowBits, sym);
- {
- unsigned m;
- unsigned bit;
- RC_BIT_0(rc, probs);
- probs += (posState << (1 + kLenNumLowBits));
- bit = (sym >> 2) ; RC_BIT(rc, probs + 1, bit); m = (1 << 1) + bit;
- bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit); m = (m << 1) + bit;
- bit = sym & 1; RC_BIT(rc, probs + m, bit);
- rc->range = range;
- }
-}
-
-static void SetPrices_3(const CLzmaProb *probs, UInt32 startPrice, UInt32 *prices, const CProbPrice *ProbPrices)
-{
- unsigned i;
- for (i = 0; i < 8; i += 2)
- {
- UInt32 price = startPrice;
- UInt32 prob;
- price += GET_PRICEa(probs[1 ], (i >> 2));
- price += GET_PRICEa(probs[2 + (i >> 2)], (i >> 1) & 1);
- prob = probs[4 + (i >> 1)];
- prices[i ] = price + GET_PRICEa_0(prob);
- prices[i + 1] = price + GET_PRICEa_1(prob);
- }
-}
-
-
-MY_NO_INLINE static void MY_FAST_CALL LenPriceEnc_UpdateTables(
- CLenPriceEnc *p,
- unsigned numPosStates,
- const CLenEnc *enc,
- const CProbPrice *ProbPrices)
-{
- UInt32 b;
-
- {
- unsigned prob = enc->low[0];
- UInt32 a, c;
- unsigned posState;
- b = GET_PRICEa_1(prob);
- a = GET_PRICEa_0(prob);
- c = b + GET_PRICEa_0(enc->low[kLenNumLowSymbols]);
- for (posState = 0; posState < numPosStates; posState++)
- {
- UInt32 *prices = p->prices[posState];
- const CLzmaProb *probs = enc->low + (posState << (1 + kLenNumLowBits));
- SetPrices_3(probs, a, prices, ProbPrices);
- SetPrices_3(probs + kLenNumLowSymbols, c, prices + kLenNumLowSymbols, ProbPrices);
- }
- }
-
- /*
- {
- unsigned i;
- UInt32 b;
- a = GET_PRICEa_0(enc->low[0]);
- for (i = 0; i < kLenNumLowSymbols; i++)
- p->prices2[i] = a;
- a = GET_PRICEa_1(enc->low[0]);
- b = a + GET_PRICEa_0(enc->low[kLenNumLowSymbols]);
- for (i = kLenNumLowSymbols; i < kLenNumLowSymbols * 2; i++)
- p->prices2[i] = b;
- a += GET_PRICEa_1(enc->low[kLenNumLowSymbols]);
- }
- */
-
- // p->counter = numSymbols;
- // p->counter = 64;
-
- {
- unsigned i = p->tableSize;
-
- if (i > kLenNumLowSymbols * 2)
- {
- const CLzmaProb *probs = enc->high;
- UInt32 *prices = p->prices[0] + kLenNumLowSymbols * 2;
- i -= kLenNumLowSymbols * 2 - 1;
- i >>= 1;
- b += GET_PRICEa_1(enc->low[kLenNumLowSymbols]);
- do
- {
- /*
- p->prices2[i] = a +
- // RcTree_GetPrice(enc->high, kLenNumHighBits, i - kLenNumLowSymbols * 2, ProbPrices);
- LitEnc_GetPrice(probs, i - kLenNumLowSymbols * 2, ProbPrices);
- */
- // UInt32 price = a + RcTree_GetPrice(probs, kLenNumHighBits - 1, sym, ProbPrices);
- unsigned sym = --i + (1 << (kLenNumHighBits - 1));
- UInt32 price = b;
- do
- {
- unsigned bit = sym & 1;
- sym >>= 1;
- price += GET_PRICEa(probs[sym], bit);
- }
- while (sym >= 2);
-
- {
- unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))];
- prices[(size_t)i * 2 ] = price + GET_PRICEa_0(prob);
- prices[(size_t)i * 2 + 1] = price + GET_PRICEa_1(prob);
- }
- }
- while (i);
-
- {
- unsigned posState;
- size_t num = (p->tableSize - kLenNumLowSymbols * 2) * sizeof(p->prices[0][0]);
- for (posState = 1; posState < numPosStates; posState++)
- memcpy(p->prices[posState] + kLenNumLowSymbols * 2, p->prices[0] + kLenNumLowSymbols * 2, num);
- }
- }
- }
-}
-
-/*
- #ifdef SHOW_STAT
- g_STAT_OFFSET += num;
- printf("\n MovePos %u", num);
- #endif
-*/
-
-#define MOVE_POS(p, num) { \
- p->additionalOffset += (num); \
- p->matchFinder.Skip(p->matchFinderObj, (UInt32)(num)); }
-
-
-static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
-{
- unsigned numPairs;
-
- p->additionalOffset++;
- p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
- numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
- *numPairsRes = numPairs;
-
- #ifdef SHOW_STAT
- printf("\n i = %u numPairs = %u ", g_STAT_OFFSET, numPairs / 2);
- g_STAT_OFFSET++;
- {
- unsigned i;
- for (i = 0; i < numPairs; i += 2)
- printf("%2u %6u | ", p->matches[i], p->matches[i + 1]);
- }
- #endif
-
- if (numPairs == 0)
- return 0;
- {
- unsigned len = p->matches[(size_t)numPairs - 2];
- if (len != p->numFastBytes)
- return len;
- {
- UInt32 numAvail = p->numAvail;
- if (numAvail > LZMA_MATCH_LEN_MAX)
- numAvail = LZMA_MATCH_LEN_MAX;
- {
- const Byte *p1 = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
- const Byte *p2 = p1 + len;
- ptrdiff_t dif = (ptrdiff_t)-1 - p->matches[(size_t)numPairs - 1];
- const Byte *lim = p1 + numAvail;
- for (; p2 != lim && *p2 == p2[dif]; p2++)
- {}
- return (unsigned)(p2 - p1);
- }
- }
- }
-}
-
-#define MARK_LIT ((UInt32)(Int32)-1)
-
-#define MakeAs_Lit(p) { (p)->dist = MARK_LIT; (p)->extra = 0; }
-#define MakeAs_ShortRep(p) { (p)->dist = 0; (p)->extra = 0; }
-#define IsShortRep(p) ((p)->dist == 0)
-
-
-#define GetPrice_ShortRep(p, state, posState) \
- ( GET_PRICE_0(p->isRepG0[state]) + GET_PRICE_0(p->isRep0Long[state][posState]))
-
-#define GetPrice_Rep_0(p, state, posState) ( \
- GET_PRICE_1(p->isMatch[state][posState]) \
- + GET_PRICE_1(p->isRep0Long[state][posState])) \
- + GET_PRICE_1(p->isRep[state]) \
- + GET_PRICE_0(p->isRepG0[state])
-
-MY_FORCE_INLINE
-static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState)
-{
- UInt32 price;
- UInt32 prob = p->isRepG0[state];
- if (repIndex == 0)
- {
- price = GET_PRICE_0(prob);
- price += GET_PRICE_1(p->isRep0Long[state][posState]);
- }
- else
- {
- price = GET_PRICE_1(prob);
- prob = p->isRepG1[state];
- if (repIndex == 1)
- price += GET_PRICE_0(prob);
- else
- {
- price += GET_PRICE_1(prob);
- price += GET_PRICE(p->isRepG2[state], repIndex - 2);
- }
- }
- return price;
-}
-
-
-static unsigned Backward(CLzmaEnc *p, unsigned cur)
-{
- unsigned wr = cur + 1;
- p->optEnd = wr;
-
- for (;;)
- {
- UInt32 dist = p->opt[cur].dist;
- unsigned len = (unsigned)p->opt[cur].len;
- unsigned extra = (unsigned)p->opt[cur].extra;
- cur -= len;
-
- if (extra)
- {
- wr--;
- p->opt[wr].len = (UInt32)len;
- cur -= extra;
- len = extra;
- if (extra == 1)
- {
- p->opt[wr].dist = dist;
- dist = MARK_LIT;
- }
- else
- {
- p->opt[wr].dist = 0;
- len--;
- wr--;
- p->opt[wr].dist = MARK_LIT;
- p->opt[wr].len = 1;
- }
- }
-
- if (cur == 0)
- {
- p->backRes = dist;
- p->optCur = wr;
- return len;
- }
-
- wr--;
- p->opt[wr].dist = dist;
- p->opt[wr].len = (UInt32)len;
- }
-}
-
-
-
-#define LIT_PROBS(pos, prevByte) \
- (p->litProbs + (UInt32)3 * (((((pos) << 8) + (prevByte)) & p->lpMask) << p->lc))
-
-
-static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
-{
- unsigned last, cur;
- UInt32 reps[LZMA_NUM_REPS];
- unsigned repLens[LZMA_NUM_REPS];
- UInt32 *matches;
-
- {
- UInt32 numAvail;
- unsigned numPairs, mainLen, repMaxIndex, i, posState;
- UInt32 matchPrice, repMatchPrice;
- const Byte *data;
- Byte curByte, matchByte;
-
- p->optCur = p->optEnd = 0;
-
- if (p->additionalOffset == 0)
- mainLen = ReadMatchDistances(p, &numPairs);
- else
- {
- mainLen = p->longestMatchLen;
- numPairs = p->numPairs;
- }
-
- numAvail = p->numAvail;
- if (numAvail < 2)
- {
- p->backRes = MARK_LIT;
- return 1;
- }
- if (numAvail > LZMA_MATCH_LEN_MAX)
- numAvail = LZMA_MATCH_LEN_MAX;
-
- data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
- repMaxIndex = 0;
-
- for (i = 0; i < LZMA_NUM_REPS; i++)
- {
- unsigned len;
- const Byte *data2;
- reps[i] = p->reps[i];
- data2 = data - reps[i];
- if (data[0] != data2[0] || data[1] != data2[1])
- {
- repLens[i] = 0;
- continue;
- }
- for (len = 2; len < numAvail && data[len] == data2[len]; len++)
- {}
- repLens[i] = len;
- if (len > repLens[repMaxIndex])
- repMaxIndex = i;
- }
-
- if (repLens[repMaxIndex] >= p->numFastBytes)
- {
- unsigned len;
- p->backRes = (UInt32)repMaxIndex;
- len = repLens[repMaxIndex];
- MOVE_POS(p, len - 1)
- return len;
- }
-
- matches = p->matches;
-
- if (mainLen >= p->numFastBytes)
- {
- p->backRes = matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;
- MOVE_POS(p, mainLen - 1)
- return mainLen;
- }
-
- curByte = *data;
- matchByte = *(data - reps[0]);
-
- last = repLens[repMaxIndex];
- if (last <= mainLen)
- last = mainLen;
-
- if (last < 2 && curByte != matchByte)
- {
- p->backRes = MARK_LIT;
- return 1;
- }
-
- p->opt[0].state = (CState)p->state;
-
- posState = (position & p->pbMask);
-
- {
- const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
- p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +
- (!IsLitState(p->state) ?
- LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
- LitEnc_GetPrice(probs, curByte, p->ProbPrices));
- }
-
- MakeAs_Lit(&p->opt[1]);
-
- matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);
- repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);
-
- // 18.06
- if (matchByte == curByte && repLens[0] == 0)
- {
- UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, p->state, posState);
- if (shortRepPrice < p->opt[1].price)
- {
- p->opt[1].price = shortRepPrice;
- MakeAs_ShortRep(&p->opt[1]);
- }
- if (last < 2)
- {
- p->backRes = p->opt[1].dist;
- return 1;
- }
- }
-
- p->opt[1].len = 1;
-
- p->opt[0].reps[0] = reps[0];
- p->opt[0].reps[1] = reps[1];
- p->opt[0].reps[2] = reps[2];
- p->opt[0].reps[3] = reps[3];
-
- // ---------- REP ----------
-
- for (i = 0; i < LZMA_NUM_REPS; i++)
- {
- unsigned repLen = repLens[i];
- UInt32 price;
- if (repLen < 2)
- continue;
- price = repMatchPrice + GetPrice_PureRep(p, i, p->state, posState);
- do
- {
- UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, repLen);
- COptimal *opt = &p->opt[repLen];
- if (price2 < opt->price)
- {
- opt->price = price2;
- opt->len = (UInt32)repLen;
- opt->dist = (UInt32)i;
- opt->extra = 0;
- }
- }
- while (--repLen >= 2);
- }
-
-
- // ---------- MATCH ----------
- {
- unsigned len = repLens[0] + 1;
- if (len <= mainLen)
- {
- unsigned offs = 0;
- UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[p->state]);
-
- if (len < 2)
- len = 2;
- else
- while (len > matches[offs])
- offs += 2;
-
- for (; ; len++)
- {
- COptimal *opt;
- UInt32 dist = matches[(size_t)offs + 1];
- UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);
- unsigned lenToPosState = GetLenToPosState(len);
-
- if (dist < kNumFullDistances)
- price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];
- else
- {
- unsigned slot;
- GetPosSlot2(dist, slot);
- price += p->alignPrices[dist & kAlignMask];
- price += p->posSlotPrices[lenToPosState][slot];
- }
-
- opt = &p->opt[len];
-
- if (price < opt->price)
- {
- opt->price = price;
- opt->len = (UInt32)len;
- opt->dist = dist + LZMA_NUM_REPS;
- opt->extra = 0;
- }
-
- if (len == matches[offs])
- {
- offs += 2;
- if (offs == numPairs)
- break;
- }
- }
- }
- }
-
-
- cur = 0;
-
- #ifdef SHOW_STAT2
- /* if (position >= 0) */
- {
- unsigned i;
- printf("\n pos = %4X", position);
- for (i = cur; i <= last; i++)
- printf("\nprice[%4X] = %u", position - cur + i, p->opt[i].price);
- }
- #endif
- }
-
-
-
- // ---------- Optimal Parsing ----------
-
- for (;;)
- {
- unsigned numAvail;
- UInt32 numAvailFull;
- unsigned newLen, numPairs, prev, state, posState, startLen;
- UInt32 litPrice, matchPrice, repMatchPrice;
- BoolInt nextIsLit;
- Byte curByte, matchByte;
- const Byte *data;
- COptimal *curOpt, *nextOpt;
-
- if (++cur == last)
- break;
-
- // 18.06
- if (cur >= kNumOpts - 64)
- {
- unsigned j, best;
- UInt32 price = p->opt[cur].price;
- best = cur;
- for (j = cur + 1; j <= last; j++)
- {
- UInt32 price2 = p->opt[j].price;
- if (price >= price2)
- {
- price = price2;
- best = j;
- }
- }
- {
- unsigned delta = best - cur;
- if (delta != 0)
- {
- MOVE_POS(p, delta);
- }
- }
- cur = best;
- break;
- }
-
- newLen = ReadMatchDistances(p, &numPairs);
-
- if (newLen >= p->numFastBytes)
- {
- p->numPairs = numPairs;
- p->longestMatchLen = newLen;
- break;
- }
-
- curOpt = &p->opt[cur];
-
- position++;
-
- // we need that check here, if skip_items in p->opt are possible
- /*
- if (curOpt->price >= kInfinityPrice)
- continue;
- */
-
- prev = cur - curOpt->len;
-
- if (curOpt->len == 1)
- {
- state = (unsigned)p->opt[prev].state;
- if (IsShortRep(curOpt))
- state = kShortRepNextStates[state];
- else
- state = kLiteralNextStates[state];
- }
- else
- {
- const COptimal *prevOpt;
- UInt32 b0;
- UInt32 dist = curOpt->dist;
-
- if (curOpt->extra)
- {
- prev -= (unsigned)curOpt->extra;
- state = kState_RepAfterLit;
- if (curOpt->extra == 1)
- state = (dist < LZMA_NUM_REPS ? kState_RepAfterLit : kState_MatchAfterLit);
- }
- else
- {
- state = (unsigned)p->opt[prev].state;
- if (dist < LZMA_NUM_REPS)
- state = kRepNextStates[state];
- else
- state = kMatchNextStates[state];
- }
-
- prevOpt = &p->opt[prev];
- b0 = prevOpt->reps[0];
-
- if (dist < LZMA_NUM_REPS)
- {
- if (dist == 0)
- {
- reps[0] = b0;
- reps[1] = prevOpt->reps[1];
- reps[2] = prevOpt->reps[2];
- reps[3] = prevOpt->reps[3];
- }
- else
- {
- reps[1] = b0;
- b0 = prevOpt->reps[1];
- if (dist == 1)
- {
- reps[0] = b0;
- reps[2] = prevOpt->reps[2];
- reps[3] = prevOpt->reps[3];
- }
- else
- {
- reps[2] = b0;
- reps[0] = prevOpt->reps[dist];
- reps[3] = prevOpt->reps[dist ^ 1];
- }
- }
- }
- else
- {
- reps[0] = (dist - LZMA_NUM_REPS + 1);
- reps[1] = b0;
- reps[2] = prevOpt->reps[1];
- reps[3] = prevOpt->reps[2];
- }
- }
-
- curOpt->state = (CState)state;
- curOpt->reps[0] = reps[0];
- curOpt->reps[1] = reps[1];
- curOpt->reps[2] = reps[2];
- curOpt->reps[3] = reps[3];
-
- data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
- curByte = *data;
- matchByte = *(data - reps[0]);
-
- posState = (position & p->pbMask);
-
- /*
- The order of Price checks:
- < LIT
- <= SHORT_REP
- < LIT : REP_0
- < REP [ : LIT : REP_0 ]
- < MATCH [ : LIT : REP_0 ]
- */
-
- {
- UInt32 curPrice = curOpt->price;
- unsigned prob = p->isMatch[state][posState];
- matchPrice = curPrice + GET_PRICE_1(prob);
- litPrice = curPrice + GET_PRICE_0(prob);
- }
-
- nextOpt = &p->opt[(size_t)cur + 1];
- nextIsLit = False;
-
- // here we can allow skip_items in p->opt, if we don't check (nextOpt->price < kInfinityPrice)
- // 18.new.06
- if ((nextOpt->price < kInfinityPrice
- // && !IsLitState(state)
- && matchByte == curByte)
- || litPrice > nextOpt->price
- )
- litPrice = 0;
- else
- {
- const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
- litPrice += (!IsLitState(state) ?
- LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
- LitEnc_GetPrice(probs, curByte, p->ProbPrices));
-
- if (litPrice < nextOpt->price)
- {
- nextOpt->price = litPrice;
- nextOpt->len = 1;
- MakeAs_Lit(nextOpt);
- nextIsLit = True;
- }
- }
-
- repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]);
-
- numAvailFull = p->numAvail;
- {
- unsigned temp = kNumOpts - 1 - cur;
- if (numAvailFull > temp)
- numAvailFull = (UInt32)temp;
- }
-
- // 18.06
- // ---------- SHORT_REP ----------
- if (IsLitState(state)) // 18.new
- if (matchByte == curByte)
- if (repMatchPrice < nextOpt->price) // 18.new
- // if (numAvailFull < 2 || data[1] != *(data - reps[0] + 1))
- if (
- // nextOpt->price >= kInfinityPrice ||
- nextOpt->len < 2 // we can check nextOpt->len, if skip items are not allowed in p->opt
- || (nextOpt->dist != 0
- // && nextOpt->extra <= 1 // 17.old
- )
- )
- {
- UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, state, posState);
- // if (shortRepPrice <= nextOpt->price) // 17.old
- if (shortRepPrice < nextOpt->price) // 18.new
- {
- nextOpt->price = shortRepPrice;
- nextOpt->len = 1;
- MakeAs_ShortRep(nextOpt);
- nextIsLit = False;
- }
- }
-
- if (numAvailFull < 2)
- continue;
- numAvail = (numAvailFull <= p->numFastBytes ? numAvailFull : p->numFastBytes);
-
- // numAvail <= p->numFastBytes
-
- // ---------- LIT : REP_0 ----------
-
- if (!nextIsLit
- && litPrice != 0 // 18.new
- && matchByte != curByte
- && numAvailFull > 2)
- {
- const Byte *data2 = data - reps[0];
- if (data[1] == data2[1] && data[2] == data2[2])
- {
- unsigned len;
- unsigned limit = p->numFastBytes + 1;
- if (limit > numAvailFull)
- limit = numAvailFull;
- for (len = 3; len < limit && data[len] == data2[len]; len++)
- {}
-
- {
- unsigned state2 = kLiteralNextStates[state];
- unsigned posState2 = (position + 1) & p->pbMask;
- UInt32 price = litPrice + GetPrice_Rep_0(p, state2, posState2);
- {
- unsigned offset = cur + len;
-
- if (last < offset)
- last = offset;
-
- // do
- {
- UInt32 price2;
- COptimal *opt;
- len--;
- // price2 = price + GetPrice_Len_Rep_0(p, len, state2, posState2);
- price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len);
-
- opt = &p->opt[offset];
- // offset--;
- if (price2 < opt->price)
- {
- opt->price = price2;
- opt->len = (UInt32)len;
- opt->dist = 0;
- opt->extra = 1;
- }
- }
- // while (len >= 3);
- }
- }
- }
- }
-
- startLen = 2; /* speed optimization */
-
- {
- // ---------- REP ----------
- unsigned repIndex = 0; // 17.old
- // unsigned repIndex = IsLitState(state) ? 0 : 1; // 18.notused
- for (; repIndex < LZMA_NUM_REPS; repIndex++)
- {
- unsigned len;
- UInt32 price;
- const Byte *data2 = data - reps[repIndex];
- if (data[0] != data2[0] || data[1] != data2[1])
- continue;
-
- for (len = 2; len < numAvail && data[len] == data2[len]; len++)
- {}
-
- // if (len < startLen) continue; // 18.new: speed optimization
-
- {
- unsigned offset = cur + len;
- if (last < offset)
- last = offset;
- }
- {
- unsigned len2 = len;
- price = repMatchPrice + GetPrice_PureRep(p, repIndex, state, posState);
- do
- {
- UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, len2);
- COptimal *opt = &p->opt[cur + len2];
- if (price2 < opt->price)
- {
- opt->price = price2;
- opt->len = (UInt32)len2;
- opt->dist = (UInt32)repIndex;
- opt->extra = 0;
- }
- }
- while (--len2 >= 2);
- }
-
- if (repIndex == 0) startLen = len + 1; // 17.old
- // startLen = len + 1; // 18.new
-
- /* if (_maxMode) */
- {
- // ---------- REP : LIT : REP_0 ----------
- // numFastBytes + 1 + numFastBytes
-
- unsigned len2 = len + 1;
- unsigned limit = len2 + p->numFastBytes;
- if (limit > numAvailFull)
- limit = numAvailFull;
-
- len2 += 2;
- if (len2 <= limit)
- if (data[len2 - 2] == data2[len2 - 2])
- if (data[len2 - 1] == data2[len2 - 1])
- {
- unsigned state2 = kRepNextStates[state];
- unsigned posState2 = (position + len) & p->pbMask;
- price += GET_PRICE_LEN(&p->repLenEnc, posState, len)
- + GET_PRICE_0(p->isMatch[state2][posState2])
- + LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),
- data[len], data2[len], p->ProbPrices);
-
- // state2 = kLiteralNextStates[state2];
- state2 = kState_LitAfterRep;
- posState2 = (posState2 + 1) & p->pbMask;
-
-
- price += GetPrice_Rep_0(p, state2, posState2);
-
- for (; len2 < limit && data[len2] == data2[len2]; len2++)
- {}
-
- len2 -= len;
- // if (len2 >= 3)
- {
- {
- unsigned offset = cur + len + len2;
-
- if (last < offset)
- last = offset;
- // do
- {
- UInt32 price2;
- COptimal *opt;
- len2--;
- // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);
- price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);
-
- opt = &p->opt[offset];
- // offset--;
- if (price2 < opt->price)
- {
- opt->price = price2;
- opt->len = (UInt32)len2;
- opt->extra = (CExtra)(len + 1);
- opt->dist = (UInt32)repIndex;
- }
- }
- // while (len2 >= 3);
- }
- }
- }
- }
- }
- }
-
-
- // ---------- MATCH ----------
- /* for (unsigned len = 2; len <= newLen; len++) */
- if (newLen > numAvail)
- {
- newLen = numAvail;
- for (numPairs = 0; newLen > matches[numPairs]; numPairs += 2);
- matches[numPairs] = (UInt32)newLen;
- numPairs += 2;
- }
-
- // startLen = 2; /* speed optimization */
-
- if (newLen >= startLen)
- {
- UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
- UInt32 dist;
- unsigned offs, posSlot, len;
-
- {
- unsigned offset = cur + newLen;
- if (last < offset)
- last = offset;
- }
-
- offs = 0;
- while (startLen > matches[offs])
- offs += 2;
- dist = matches[(size_t)offs + 1];
-
- // if (dist >= kNumFullDistances)
- GetPosSlot2(dist, posSlot);
-
- for (len = /*2*/ startLen; ; len++)
- {
- UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);
- {
- COptimal *opt;
- unsigned lenNorm = len - 2;
- lenNorm = GetLenToPosState2(lenNorm);
- if (dist < kNumFullDistances)
- price += p->distancesPrices[lenNorm][dist & (kNumFullDistances - 1)];
- else
- price += p->posSlotPrices[lenNorm][posSlot] + p->alignPrices[dist & kAlignMask];
-
- opt = &p->opt[cur + len];
- if (price < opt->price)
- {
- opt->price = price;
- opt->len = (UInt32)len;
- opt->dist = dist + LZMA_NUM_REPS;
- opt->extra = 0;
- }
- }
-
- if (len == matches[offs])
- {
- // if (p->_maxMode) {
- // MATCH : LIT : REP_0
-
- const Byte *data2 = data - dist - 1;
- unsigned len2 = len + 1;
- unsigned limit = len2 + p->numFastBytes;
- if (limit > numAvailFull)
- limit = numAvailFull;
-
- len2 += 2;
- if (len2 <= limit)
- if (data[len2 - 2] == data2[len2 - 2])
- if (data[len2 - 1] == data2[len2 - 1])
- {
- for (; len2 < limit && data[len2] == data2[len2]; len2++)
- {}
-
- len2 -= len;
-
- // if (len2 >= 3)
- {
- unsigned state2 = kMatchNextStates[state];
- unsigned posState2 = (position + len) & p->pbMask;
- unsigned offset;
- price += GET_PRICE_0(p->isMatch[state2][posState2]);
- price += LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),
- data[len], data2[len], p->ProbPrices);
-
- // state2 = kLiteralNextStates[state2];
- state2 = kState_LitAfterMatch;
-
- posState2 = (posState2 + 1) & p->pbMask;
- price += GetPrice_Rep_0(p, state2, posState2);
-
- offset = cur + len + len2;
-
- if (last < offset)
- last = offset;
- // do
- {
- UInt32 price2;
- COptimal *opt;
- len2--;
- // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);
- price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);
- opt = &p->opt[offset];
- // offset--;
- if (price2 < opt->price)
- {
- opt->price = price2;
- opt->len = (UInt32)len2;
- opt->extra = (CExtra)(len + 1);
- opt->dist = dist + LZMA_NUM_REPS;
- }
- }
- // while (len2 >= 3);
- }
-
- }
-
- offs += 2;
- if (offs == numPairs)
- break;
- dist = matches[(size_t)offs + 1];
- // if (dist >= kNumFullDistances)
- GetPosSlot2(dist, posSlot);
- }
- }
- }
- }
-
- do
- p->opt[last].price = kInfinityPrice;
- while (--last);
-
- return Backward(p, cur);
-}
-
-
-
-#define ChangePair(smallDist, bigDist) (((bigDist) >> 7) > (smallDist))
-
-
-
-static unsigned GetOptimumFast(CLzmaEnc *p)
-{
- UInt32 numAvail, mainDist;
- unsigned mainLen, numPairs, repIndex, repLen, i;
- const Byte *data;
-
- if (p->additionalOffset == 0)
- mainLen = ReadMatchDistances(p, &numPairs);
- else
- {
- mainLen = p->longestMatchLen;
- numPairs = p->numPairs;
- }
-
- numAvail = p->numAvail;
- p->backRes = MARK_LIT;
- if (numAvail < 2)
- return 1;
- // if (mainLen < 2 && p->state == 0) return 1; // 18.06.notused
- if (numAvail > LZMA_MATCH_LEN_MAX)
- numAvail = LZMA_MATCH_LEN_MAX;
- data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
- repLen = repIndex = 0;
-
- for (i = 0; i < LZMA_NUM_REPS; i++)
- {
- unsigned len;
- const Byte *data2 = data - p->reps[i];
- if (data[0] != data2[0] || data[1] != data2[1])
- continue;
- for (len = 2; len < numAvail && data[len] == data2[len]; len++)
- {}
- if (len >= p->numFastBytes)
- {
- p->backRes = (UInt32)i;
- MOVE_POS(p, len - 1)
- return len;
- }
- if (len > repLen)
- {
- repIndex = i;
- repLen = len;
- }
- }
-
- if (mainLen >= p->numFastBytes)
- {
- p->backRes = p->matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;
- MOVE_POS(p, mainLen - 1)
- return mainLen;
- }
-
- mainDist = 0; /* for GCC */
-
- if (mainLen >= 2)
- {
- mainDist = p->matches[(size_t)numPairs - 1];
- while (numPairs > 2)
- {
- UInt32 dist2;
- if (mainLen != p->matches[(size_t)numPairs - 4] + 1)
- break;
- dist2 = p->matches[(size_t)numPairs - 3];
- if (!ChangePair(dist2, mainDist))
- break;
- numPairs -= 2;
- mainLen--;
- mainDist = dist2;
- }
- if (mainLen == 2 && mainDist >= 0x80)
- mainLen = 1;
- }
-
- if (repLen >= 2)
- if ( repLen + 1 >= mainLen
- || (repLen + 2 >= mainLen && mainDist >= (1 << 9))
- || (repLen + 3 >= mainLen && mainDist >= (1 << 15)))
- {
- p->backRes = (UInt32)repIndex;
- MOVE_POS(p, repLen - 1)
- return repLen;
- }
-
- if (mainLen < 2 || numAvail <= 2)
- return 1;
-
- {
- unsigned len1 = ReadMatchDistances(p, &p->numPairs);
- p->longestMatchLen = len1;
-
- if (len1 >= 2)
- {
- UInt32 newDist = p->matches[(size_t)p->numPairs - 1];
- if ( (len1 >= mainLen && newDist < mainDist)
- || (len1 == mainLen + 1 && !ChangePair(mainDist, newDist))
- || (len1 > mainLen + 1)
- || (len1 + 1 >= mainLen && mainLen >= 3 && ChangePair(newDist, mainDist)))
- return 1;
- }
- }
-
- data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
-
- for (i = 0; i < LZMA_NUM_REPS; i++)
- {
- unsigned len, limit;
- const Byte *data2 = data - p->reps[i];
- if (data[0] != data2[0] || data[1] != data2[1])
- continue;
- limit = mainLen - 1;
- for (len = 2;; len++)
- {
- if (len >= limit)
- return 1;
- if (data[len] != data2[len])
- break;
- }
- }
-
- p->backRes = mainDist + LZMA_NUM_REPS;
- if (mainLen != 2)
- {
- MOVE_POS(p, mainLen - 2)
- }
- return mainLen;
-}
-
-
-
-
-static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
-{
- UInt32 range;
- range = p->rc.range;
- {
- UInt32 ttt, newBound;
- CLzmaProb *prob = &p->isMatch[p->state][posState];
- RC_BIT_PRE(&p->rc, prob)
- RC_BIT_1(&p->rc, prob)
- prob = &p->isRep[p->state];
- RC_BIT_PRE(&p->rc, prob)
- RC_BIT_0(&p->rc, prob)
- }
- p->state = kMatchNextStates[p->state];
-
- p->rc.range = range;
- LenEnc_Encode(&p->lenProbs, &p->rc, 0, posState);
- range = p->rc.range;
-
- {
- // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[0], (1 << kNumPosSlotBits) - 1);
- CLzmaProb *probs = p->posSlotEncoder[0];
- unsigned m = 1;
- do
- {
- UInt32 ttt, newBound;
- RC_BIT_PRE(p, probs + m)
- RC_BIT_1(&p->rc, probs + m);
- m = (m << 1) + 1;
- }
- while (m < (1 << kNumPosSlotBits));
- }
- {
- // RangeEnc_EncodeDirectBits(&p->rc, ((UInt32)1 << (30 - kNumAlignBits)) - 1, 30 - kNumAlignBits); UInt32 range = p->range;
- unsigned numBits = 30 - kNumAlignBits;
- do
- {
- range >>= 1;
- p->rc.low += range;
- RC_NORM(&p->rc)
- }
- while (--numBits);
- }
-
- {
- // RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);
- CLzmaProb *probs = p->posAlignEncoder;
- unsigned m = 1;
- do
- {
- UInt32 ttt, newBound;
- RC_BIT_PRE(p, probs + m)
- RC_BIT_1(&p->rc, probs + m);
- m = (m << 1) + 1;
- }
- while (m < kAlignTableSize);
- }
- p->rc.range = range;
-}
-
-
-static SRes CheckErrors(CLzmaEnc *p)
-{
- if (p->result != SZ_OK)
- return p->result;
- if (p->rc.res != SZ_OK)
- p->result = SZ_ERROR_WRITE;
- if (p->matchFinderBase.result != SZ_OK)
- p->result = SZ_ERROR_READ;
- if (p->result != SZ_OK)
- p->finished = True;
- return p->result;
-}
-
-
-MY_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
-{
- /* ReleaseMFStream(); */
- p->finished = True;
- if (p->writeEndMark)
- WriteEndMarker(p, nowPos & p->pbMask);
- RangeEnc_FlushData(&p->rc);
- RangeEnc_FlushStream(&p->rc);
- return CheckErrors(p);
-}
-
-
-MY_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)
-{
- unsigned i;
- const CProbPrice *ProbPrices = p->ProbPrices;
- const CLzmaProb *probs = p->posAlignEncoder;
- // p->alignPriceCount = 0;
- for (i = 0; i < kAlignTableSize / 2; i++)
- {
- UInt32 price = 0;
- unsigned sym = i;
- unsigned m = 1;
- unsigned bit;
- UInt32 prob;
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
- prob = probs[m];
- p->alignPrices[i ] = price + GET_PRICEa_0(prob);
- p->alignPrices[i + 8] = price + GET_PRICEa_1(prob);
- // p->alignPrices[i] = RcTree_ReverseGetPrice(p->posAlignEncoder, kNumAlignBits, i, p->ProbPrices);
- }
-}
-
-
-MY_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)
-{
- // int y; for (y = 0; y < 100; y++) {
-
- UInt32 tempPrices[kNumFullDistances];
- unsigned i, lps;
-
- const CProbPrice *ProbPrices = p->ProbPrices;
- p->matchPriceCount = 0;
-
- for (i = kStartPosModelIndex / 2; i < kNumFullDistances / 2; i++)
- {
- unsigned posSlot = GetPosSlot1(i);
- unsigned footerBits = (posSlot >> 1) - 1;
- unsigned base = ((2 | (posSlot & 1)) << footerBits);
- const CLzmaProb *probs = p->posEncoders + (size_t)base * 2;
- // tempPrices[i] = RcTree_ReverseGetPrice(p->posEncoders + base, footerBits, i - base, p->ProbPrices);
- UInt32 price = 0;
- unsigned m = 1;
- unsigned sym = i;
- unsigned offset = (unsigned)1 << footerBits;
- base += i;
-
- if (footerBits)
- do
- {
- unsigned bit = sym & 1;
- sym >>= 1;
- price += GET_PRICEa(probs[m], bit);
- m = (m << 1) + bit;
- }
- while (--footerBits);
-
- {
- unsigned prob = probs[m];
- tempPrices[base ] = price + GET_PRICEa_0(prob);
- tempPrices[base + offset] = price + GET_PRICEa_1(prob);
- }
- }
-
- for (lps = 0; lps < kNumLenToPosStates; lps++)
- {
- unsigned slot;
- unsigned distTableSize2 = (p->distTableSize + 1) >> 1;
- UInt32 *posSlotPrices = p->posSlotPrices[lps];
- const CLzmaProb *probs = p->posSlotEncoder[lps];
-
- for (slot = 0; slot < distTableSize2; slot++)
- {
- // posSlotPrices[slot] = RcTree_GetPrice(encoder, kNumPosSlotBits, slot, p->ProbPrices);
- UInt32 price;
- unsigned bit;
- unsigned sym = slot + (1 << (kNumPosSlotBits - 1));
- unsigned prob;
- bit = sym & 1; sym >>= 1; price = GET_PRICEa(probs[sym], bit);
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
- bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
- prob = probs[(size_t)slot + (1 << (kNumPosSlotBits - 1))];
- posSlotPrices[(size_t)slot * 2 ] = price + GET_PRICEa_0(prob);
- posSlotPrices[(size_t)slot * 2 + 1] = price + GET_PRICEa_1(prob);
- }
-
- {
- UInt32 delta = ((UInt32)((kEndPosModelIndex / 2 - 1) - kNumAlignBits) << kNumBitPriceShiftBits);
- for (slot = kEndPosModelIndex / 2; slot < distTableSize2; slot++)
- {
- posSlotPrices[(size_t)slot * 2 ] += delta;
- posSlotPrices[(size_t)slot * 2 + 1] += delta;
- delta += ((UInt32)1 << kNumBitPriceShiftBits);
- }
- }
-
- {
- UInt32 *dp = p->distancesPrices[lps];
-
- dp[0] = posSlotPrices[0];
- dp[1] = posSlotPrices[1];
- dp[2] = posSlotPrices[2];
- dp[3] = posSlotPrices[3];
-
- for (i = 4; i < kNumFullDistances; i += 2)
- {
- UInt32 slotPrice = posSlotPrices[GetPosSlot1(i)];
- dp[i ] = slotPrice + tempPrices[i];
- dp[i + 1] = slotPrice + tempPrices[i + 1];
- }
- }
- }
- // }
-}
-
-
-
-void LzmaEnc_Construct(CLzmaEnc *p)
-{
- RangeEnc_Construct(&p->rc);
- MatchFinder_Construct(&p->matchFinderBase);
-
- #ifndef _7ZIP_ST
- MatchFinderMt_Construct(&p->matchFinderMt);
- p->matchFinderMt.MatchFinder = &p->matchFinderBase;
- #endif
-
- {
- CLzmaEncProps props;
- LzmaEncProps_Init(&props);
- LzmaEnc_SetProps(p, &props);
- }
-
- #ifndef LZMA_LOG_BSR
- LzmaEnc_FastPosInit(p->g_FastPos);
- #endif
-
- LzmaEnc_InitPriceTables(p->ProbPrices);
- p->litProbs = NULL;
- p->saveState.litProbs = NULL;
-
-}
-
-CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc)
-{
- void *p;
- p = ISzAlloc_Alloc(alloc, sizeof(CLzmaEnc));
- if (p)
- LzmaEnc_Construct((CLzmaEnc *)p);
- return p;
-}
-
-void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, p->litProbs);
- ISzAlloc_Free(alloc, p->saveState.litProbs);
- p->litProbs = NULL;
- p->saveState.litProbs = NULL;
-}
-
-void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- #ifndef _7ZIP_ST
- MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
- #endif
-
- MatchFinder_Free(&p->matchFinderBase, allocBig);
- LzmaEnc_FreeLits(p, alloc);
- RangeEnc_Free(&p->rc, alloc);
-}
-
-void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- LzmaEnc_Destruct((CLzmaEnc *)p, alloc, allocBig);
- ISzAlloc_Free(alloc, p);
-}
-
-
-static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpackSize)
-{
- UInt32 nowPos32, startPos32;
- if (p->needInit)
- {
- p->matchFinder.Init(p->matchFinderObj);
- p->needInit = 0;
- }
-
- if (p->finished)
- return p->result;
- RINOK(CheckErrors(p));
-
- nowPos32 = (UInt32)p->nowPos64;
- startPos32 = nowPos32;
-
- if (p->nowPos64 == 0)
- {
- unsigned numPairs;
- Byte curByte;
- if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
- return Flush(p, nowPos32);
- ReadMatchDistances(p, &numPairs);
- RangeEnc_EncodeBit_0(&p->rc, &p->isMatch[kState_Start][0]);
- // p->state = kLiteralNextStates[p->state];
- curByte = *(p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset);
- LitEnc_Encode(&p->rc, p->litProbs, curByte);
- p->additionalOffset--;
- nowPos32++;
- }
-
- if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)
-
- for (;;)
- {
- UInt32 dist;
- unsigned len, posState;
- UInt32 range, ttt, newBound;
- CLzmaProb *probs;
-
- if (p->fastMode)
- len = GetOptimumFast(p);
- else
- {
- unsigned oci = p->optCur;
- if (p->optEnd == oci)
- len = GetOptimum(p, nowPos32);
- else
- {
- const COptimal *opt = &p->opt[oci];
- len = opt->len;
- p->backRes = opt->dist;
- p->optCur = oci + 1;
- }
- }
-
- posState = (unsigned)nowPos32 & p->pbMask;
- range = p->rc.range;
- probs = &p->isMatch[p->state][posState];
-
- RC_BIT_PRE(&p->rc, probs)
-
- dist = p->backRes;
-
- #ifdef SHOW_STAT2
- printf("\n pos = %6X, len = %3u pos = %6u", nowPos32, len, dist);
- #endif
-
- if (dist == MARK_LIT)
- {
- Byte curByte;
- const Byte *data;
- unsigned state;
-
- RC_BIT_0(&p->rc, probs);
- p->rc.range = range;
- data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
- probs = LIT_PROBS(nowPos32, *(data - 1));
- curByte = *data;
- state = p->state;
- p->state = kLiteralNextStates[state];
- if (IsLitState(state))
- LitEnc_Encode(&p->rc, probs, curByte);
- else
- LitEnc_EncodeMatched(&p->rc, probs, curByte, *(data - p->reps[0]));
- }
- else
- {
- RC_BIT_1(&p->rc, probs);
- probs = &p->isRep[p->state];
- RC_BIT_PRE(&p->rc, probs)
-
- if (dist < LZMA_NUM_REPS)
- {
- RC_BIT_1(&p->rc, probs);
- probs = &p->isRepG0[p->state];
- RC_BIT_PRE(&p->rc, probs)
- if (dist == 0)
- {
- RC_BIT_0(&p->rc, probs);
- probs = &p->isRep0Long[p->state][posState];
- RC_BIT_PRE(&p->rc, probs)
- if (len != 1)
- {
- RC_BIT_1_BASE(&p->rc, probs);
- }
- else
- {
- RC_BIT_0_BASE(&p->rc, probs);
- p->state = kShortRepNextStates[p->state];
- }
- }
- else
- {
- RC_BIT_1(&p->rc, probs);
- probs = &p->isRepG1[p->state];
- RC_BIT_PRE(&p->rc, probs)
- if (dist == 1)
- {
- RC_BIT_0_BASE(&p->rc, probs);
- dist = p->reps[1];
- }
- else
- {
- RC_BIT_1(&p->rc, probs);
- probs = &p->isRepG2[p->state];
- RC_BIT_PRE(&p->rc, probs)
- if (dist == 2)
- {
- RC_BIT_0_BASE(&p->rc, probs);
- dist = p->reps[2];
- }
- else
- {
- RC_BIT_1_BASE(&p->rc, probs);
- dist = p->reps[3];
- p->reps[3] = p->reps[2];
- }
- p->reps[2] = p->reps[1];
- }
- p->reps[1] = p->reps[0];
- p->reps[0] = dist;
- }
-
- RC_NORM(&p->rc)
-
- p->rc.range = range;
-
- if (len != 1)
- {
- LenEnc_Encode(&p->repLenProbs, &p->rc, len - LZMA_MATCH_LEN_MIN, posState);
- --p->repLenEncCounter;
- p->state = kRepNextStates[p->state];
- }
- }
- else
- {
- unsigned posSlot;
- RC_BIT_0(&p->rc, probs);
- p->rc.range = range;
- p->state = kMatchNextStates[p->state];
-
- LenEnc_Encode(&p->lenProbs, &p->rc, len - LZMA_MATCH_LEN_MIN, posState);
- // --p->lenEnc.counter;
-
- dist -= LZMA_NUM_REPS;
- p->reps[3] = p->reps[2];
- p->reps[2] = p->reps[1];
- p->reps[1] = p->reps[0];
- p->reps[0] = dist + 1;
-
- p->matchPriceCount++;
- GetPosSlot(dist, posSlot);
- // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot);
- {
- UInt32 sym = (UInt32)posSlot + (1 << kNumPosSlotBits);
- range = p->rc.range;
- probs = p->posSlotEncoder[GetLenToPosState(len)];
- do
- {
- CLzmaProb *prob = probs + (sym >> kNumPosSlotBits);
- UInt32 bit = (sym >> (kNumPosSlotBits - 1)) & 1;
- sym <<= 1;
- RC_BIT(&p->rc, prob, bit);
- }
- while (sym < (1 << kNumPosSlotBits * 2));
- p->rc.range = range;
- }
-
- if (dist >= kStartPosModelIndex)
- {
- unsigned footerBits = ((posSlot >> 1) - 1);
-
- if (dist < kNumFullDistances)
- {
- unsigned base = ((2 | (posSlot & 1)) << footerBits);
- RcTree_ReverseEncode(&p->rc, p->posEncoders + base, footerBits, (unsigned)(dist /* - base */));
- }
- else
- {
- UInt32 pos2 = (dist | 0xF) << (32 - footerBits);
- range = p->rc.range;
- // RangeEnc_EncodeDirectBits(&p->rc, posReduced >> kNumAlignBits, footerBits - kNumAlignBits);
- /*
- do
- {
- range >>= 1;
- p->rc.low += range & (0 - ((dist >> --footerBits) & 1));
- RC_NORM(&p->rc)
- }
- while (footerBits > kNumAlignBits);
- */
- do
- {
- range >>= 1;
- p->rc.low += range & (0 - (pos2 >> 31));
- pos2 += pos2;
- RC_NORM(&p->rc)
- }
- while (pos2 != 0xF0000000);
-
-
- // RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, posReduced & kAlignMask);
-
- {
- unsigned m = 1;
- unsigned bit;
- bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;
- bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;
- bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit); m = (m << 1) + bit;
- bit = dist & 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit);
- p->rc.range = range;
- // p->alignPriceCount++;
- }
- }
- }
- }
- }
-
- nowPos32 += (UInt32)len;
- p->additionalOffset -= len;
-
- if (p->additionalOffset == 0)
- {
- UInt32 processed;
-
- if (!p->fastMode)
- {
- /*
- if (p->alignPriceCount >= 16) // kAlignTableSize
- FillAlignPrices(p);
- if (p->matchPriceCount >= 128)
- FillDistancesPrices(p);
- if (p->lenEnc.counter <= 0)
- LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);
- */
- if (p->matchPriceCount >= 64)
- {
- FillAlignPrices(p);
- // { int y; for (y = 0; y < 100; y++) {
- FillDistancesPrices(p);
- // }}
- LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);
- }
- if (p->repLenEncCounter <= 0)
- {
- p->repLenEncCounter = REP_LEN_COUNT;
- LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, p->ProbPrices);
- }
- }
-
- if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
- break;
- processed = nowPos32 - startPos32;
-
- if (maxPackSize)
- {
- if (processed + kNumOpts + 300 >= maxUnpackSize
- || RangeEnc_GetProcessed_sizet(&p->rc) + kPackReserve >= maxPackSize)
- break;
- }
- else if (processed >= (1 << 17))
- {
- p->nowPos64 += nowPos32 - startPos32;
- return CheckErrors(p);
- }
- }
- }
-
- p->nowPos64 += nowPos32 - startPos32;
- return Flush(p, nowPos32);
-}
-
-
-
-#define kBigHashDicLimit ((UInt32)1 << 24)
-
-static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- UInt32 beforeSize = kNumOpts;
- if (!RangeEnc_Alloc(&p->rc, alloc))
- return SZ_ERROR_MEM;
-
- #ifndef _7ZIP_ST
- p->mtMode = (p->multiThread && !p->fastMode && (p->matchFinderBase.btMode != 0));
- #endif
-
- {
- unsigned lclp = p->lc + p->lp;
- if (!p->litProbs || !p->saveState.litProbs || p->lclp != lclp)
- {
- LzmaEnc_FreeLits(p, alloc);
- p->litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
- p->saveState.litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
- if (!p->litProbs || !p->saveState.litProbs)
- {
- LzmaEnc_FreeLits(p, alloc);
- return SZ_ERROR_MEM;
- }
- p->lclp = lclp;
- }
- }
-
- p->matchFinderBase.bigHash = (Byte)(p->dictSize > kBigHashDicLimit ? 1 : 0);
-
- if (beforeSize + p->dictSize < keepWindowSize)
- beforeSize = keepWindowSize - p->dictSize;
-
- #ifndef _7ZIP_ST
- if (p->mtMode)
- {
- RINOK(MatchFinderMt_Create(&p->matchFinderMt, p->dictSize, beforeSize, p->numFastBytes,
- LZMA_MATCH_LEN_MAX
- + 1 /* 18.04 */
- , allocBig));
- p->matchFinderObj = &p->matchFinderMt;
- p->matchFinderBase.bigHash = (Byte)(
- (p->dictSize > kBigHashDicLimit && p->matchFinderBase.hashMask >= 0xFFFFFF) ? 1 : 0);
- MatchFinderMt_CreateVTable(&p->matchFinderMt, &p->matchFinder);
- }
- else
- #endif
- {
- if (!MatchFinder_Create(&p->matchFinderBase, p->dictSize, beforeSize, p->numFastBytes, LZMA_MATCH_LEN_MAX, allocBig))
- return SZ_ERROR_MEM;
- p->matchFinderObj = &p->matchFinderBase;
- MatchFinder_CreateVTable(&p->matchFinderBase, &p->matchFinder);
- }
-
- return SZ_OK;
-}
-
-void LzmaEnc_Init(CLzmaEnc *p)
-{
- unsigned i;
- p->state = 0;
- p->reps[0] =
- p->reps[1] =
- p->reps[2] =
- p->reps[3] = 1;
-
- RangeEnc_Init(&p->rc);
-
- for (i = 0; i < (1 << kNumAlignBits); i++)
- p->posAlignEncoder[i] = kProbInitValue;
-
- for (i = 0; i < kNumStates; i++)
- {
- unsigned j;
- for (j = 0; j < LZMA_NUM_PB_STATES_MAX; j++)
- {
- p->isMatch[i][j] = kProbInitValue;
- p->isRep0Long[i][j] = kProbInitValue;
- }
- p->isRep[i] = kProbInitValue;
- p->isRepG0[i] = kProbInitValue;
- p->isRepG1[i] = kProbInitValue;
- p->isRepG2[i] = kProbInitValue;
- }
-
- {
- for (i = 0; i < kNumLenToPosStates; i++)
- {
- CLzmaProb *probs = p->posSlotEncoder[i];
- unsigned j;
- for (j = 0; j < (1 << kNumPosSlotBits); j++)
- probs[j] = kProbInitValue;
- }
- }
- {
- for (i = 0; i < kNumFullDistances; i++)
- p->posEncoders[i] = kProbInitValue;
- }
-
- {
- UInt32 num = (UInt32)0x300 << (p->lp + p->lc);
- UInt32 k;
- CLzmaProb *probs = p->litProbs;
- for (k = 0; k < num; k++)
- probs[k] = kProbInitValue;
- }
-
-
- LenEnc_Init(&p->lenProbs);
- LenEnc_Init(&p->repLenProbs);
-
- p->optEnd = 0;
- p->optCur = 0;
-
- {
- for (i = 0; i < kNumOpts; i++)
- p->opt[i].price = kInfinityPrice;
- }
-
- p->additionalOffset = 0;
-
- p->pbMask = (1 << p->pb) - 1;
- p->lpMask = ((UInt32)0x100 << p->lp) - ((unsigned)0x100 >> p->lc);
-}
-
-
-void LzmaEnc_InitPrices(CLzmaEnc *p)
-{
- if (!p->fastMode)
- {
- FillDistancesPrices(p);
- FillAlignPrices(p);
- }
-
- p->lenEnc.tableSize =
- p->repLenEnc.tableSize =
- p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN;
-
- p->repLenEncCounter = REP_LEN_COUNT;
-
- LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);
- LenPriceEnc_UpdateTables(&p->repLenEnc, 1 << p->pb, &p->repLenProbs, p->ProbPrices);
-}
-
-static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- unsigned i;
- for (i = kEndPosModelIndex / 2; i < kDicLogSizeMax; i++)
- if (p->dictSize <= ((UInt32)1 << i))
- break;
- p->distTableSize = i * 2;
-
- p->finished = False;
- p->result = SZ_OK;
- RINOK(LzmaEnc_Alloc(p, keepWindowSize, alloc, allocBig));
- LzmaEnc_Init(p);
- LzmaEnc_InitPrices(p);
- p->nowPos64 = 0;
- return SZ_OK;
-}
-
-static SRes LzmaEnc_Prepare(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
- ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- p->matchFinderBase.stream = inStream;
- p->needInit = 1;
- p->rc.outStream = outStream;
- return LzmaEnc_AllocAndInit(p, 0, alloc, allocBig);
-}
-
-SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle pp,
- ISeqInStream *inStream, UInt32 keepWindowSize,
- ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- p->matchFinderBase.stream = inStream;
- p->needInit = 1;
- return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
-}
-
-static void LzmaEnc_SetInputBuf(CLzmaEnc *p, const Byte *src, SizeT srcLen)
-{
- p->matchFinderBase.directInput = 1;
- p->matchFinderBase.bufferBase = (Byte *)src;
- p->matchFinderBase.directInputRem = srcLen;
-}
-
-SRes LzmaEnc_MemPrepare(CLzmaEncHandle pp, const Byte *src, SizeT srcLen,
- UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- LzmaEnc_SetInputBuf(p, src, srcLen);
- p->needInit = 1;
-
- LzmaEnc_SetDataSize(pp, srcLen);
- return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
-}
-
-void LzmaEnc_Finish(CLzmaEncHandle pp)
-{
- #ifndef _7ZIP_ST
- CLzmaEnc *p = (CLzmaEnc *)pp;
- if (p->mtMode)
- MatchFinderMt_ReleaseStream(&p->matchFinderMt);
- #else
- UNUSED_VAR(pp);
- #endif
-}
-
-
-typedef struct
-{
- ISeqOutStream vt;
- Byte *data;
- SizeT rem;
- BoolInt overflow;
-} CLzmaEnc_SeqOutStreamBuf;
-
-static size_t SeqOutStreamBuf_Write(const ISeqOutStream *pp, const void *data, size_t size)
-{
- CLzmaEnc_SeqOutStreamBuf *p = CONTAINER_FROM_VTBL(pp, CLzmaEnc_SeqOutStreamBuf, vt);
- if (p->rem < size)
- {
- size = p->rem;
- p->overflow = True;
- }
- memcpy(p->data, data, size);
- p->rem -= size;
- p->data += size;
- return size;
-}
-
-
-UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle pp)
-{
- const CLzmaEnc *p = (CLzmaEnc *)pp;
- return p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
-}
-
-
-const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle pp)
-{
- const CLzmaEnc *p = (CLzmaEnc *)pp;
- return p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
-}
-
-
-SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle pp, BoolInt reInit,
- Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- UInt64 nowPos64;
- SRes res;
- CLzmaEnc_SeqOutStreamBuf outStream;
-
- outStream.vt.Write = SeqOutStreamBuf_Write;
- outStream.data = dest;
- outStream.rem = *destLen;
- outStream.overflow = False;
-
- p->writeEndMark = False;
- p->finished = False;
- p->result = SZ_OK;
-
- if (reInit)
- LzmaEnc_Init(p);
- LzmaEnc_InitPrices(p);
-
- nowPos64 = p->nowPos64;
- RangeEnc_Init(&p->rc);
- p->rc.outStream = &outStream.vt;
-
- if (desiredPackSize == 0)
- return SZ_ERROR_OUTPUT_EOF;
-
- res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);
-
- *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
- *destLen -= outStream.rem;
- if (outStream.overflow)
- return SZ_ERROR_OUTPUT_EOF;
-
- return res;
-}
-
-
-static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
-{
- SRes res = SZ_OK;
-
- #ifndef _7ZIP_ST
- Byte allocaDummy[0x300];
- allocaDummy[0] = 0;
- allocaDummy[1] = allocaDummy[0];
- #endif
-
- for (;;)
- {
- res = LzmaEnc_CodeOneBlock(p, 0, 0);
- if (res != SZ_OK || p->finished)
- break;
- if (progress)
- {
- res = ICompressProgress_Progress(progress, p->nowPos64, RangeEnc_GetProcessed(&p->rc));
- if (res != SZ_OK)
- {
- res = SZ_ERROR_PROGRESS;
- break;
- }
- }
- }
-
- LzmaEnc_Finish(p);
-
- /*
- if (res == SZ_OK && !Inline_MatchFinder_IsFinishedOK(&p->matchFinderBase))
- res = SZ_ERROR_FAIL;
- }
- */
-
- return res;
-}
-
-
-SRes LzmaEnc_Encode(CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress,
- ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- RINOK(LzmaEnc_Prepare(pp, outStream, inStream, alloc, allocBig));
- return LzmaEnc_Encode2((CLzmaEnc *)pp, progress);
-}
-
-
-SRes LzmaEnc_WriteProperties(CLzmaEncHandle pp, Byte *props, SizeT *size)
-{
- CLzmaEnc *p = (CLzmaEnc *)pp;
- unsigned i;
- UInt32 dictSize = p->dictSize;
- if (*size < LZMA_PROPS_SIZE)
- return SZ_ERROR_PARAM;
- *size = LZMA_PROPS_SIZE;
- props[0] = (Byte)((p->pb * 5 + p->lp) * 9 + p->lc);
-
- if (dictSize >= ((UInt32)1 << 22))
- {
- UInt32 kDictMask = ((UInt32)1 << 20) - 1;
- if (dictSize < (UInt32)0xFFFFFFFF - kDictMask)
- dictSize = (dictSize + kDictMask) & ~kDictMask;
- }
- else for (i = 11; i <= 30; i++)
- {
- if (dictSize <= ((UInt32)2 << i)) { dictSize = (2 << i); break; }
- if (dictSize <= ((UInt32)3 << i)) { dictSize = (3 << i); break; }
- }
-
- for (i = 0; i < 4; i++)
- props[1 + i] = (Byte)(dictSize >> (8 * i));
- return SZ_OK;
-}
-
-
-unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle pp)
-{
- return ((CLzmaEnc *)pp)->writeEndMark;
-}
-
-
-SRes LzmaEnc_MemEncode(CLzmaEncHandle pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
- int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- SRes res;
- CLzmaEnc *p = (CLzmaEnc *)pp;
-
- CLzmaEnc_SeqOutStreamBuf outStream;
-
- outStream.vt.Write = SeqOutStreamBuf_Write;
- outStream.data = dest;
- outStream.rem = *destLen;
- outStream.overflow = False;
-
- p->writeEndMark = writeEndMark;
- p->rc.outStream = &outStream.vt;
-
- res = LzmaEnc_MemPrepare(pp, src, srcLen, 0, alloc, allocBig);
-
- if (res == SZ_OK)
- {
- res = LzmaEnc_Encode2(p, progress);
- if (res == SZ_OK && p->nowPos64 != srcLen)
- res = SZ_ERROR_FAIL;
- }
-
- *destLen -= outStream.rem;
- if (outStream.overflow)
- return SZ_ERROR_OUTPUT_EOF;
- return res;
-}
-
-
-SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
- const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
- ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- CLzmaEnc *p = (CLzmaEnc *)LzmaEnc_Create(alloc);
- SRes res;
- if (!p)
- return SZ_ERROR_MEM;
-
- res = LzmaEnc_SetProps(p, props);
- if (res == SZ_OK)
- {
- res = LzmaEnc_WriteProperties(p, propsEncoded, propsSize);
- if (res == SZ_OK)
- res = LzmaEnc_MemEncode(p, dest, destLen, src, srcLen,
- writeEndMark, progress, alloc, allocBig);
- }
-
- LzmaEnc_Destroy(p, alloc, allocBig);
- return res;
-}
+/* LzmaEnc.c -- LZMA Encoder
+2023-04-13: Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+/* #define SHOW_STAT */
+/* #define SHOW_STAT2 */
+
+#if defined(SHOW_STAT) || defined(SHOW_STAT2)
+#include <stdio.h>
+#endif
+
+#include "CpuArch.h"
+#include "LzmaEnc.h"
+
+#include "LzFind.h"
+#ifndef Z7_ST
+#include "LzFindMt.h"
+#endif
+
+/* the following LzmaEnc_* declarations is internal LZMA interface for LZMA2 encoder */
+
+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p, ISeqInStreamPtr inStream, UInt32 keepWindowSize,
+ ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_MemPrepare(CLzmaEncHandle p, const Byte *src, SizeT srcLen,
+ UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
+ Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize);
+const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p);
+void LzmaEnc_Finish(CLzmaEncHandle p);
+void LzmaEnc_SaveState(CLzmaEncHandle p);
+void LzmaEnc_RestoreState(CLzmaEncHandle p);
+
+#ifdef SHOW_STAT
+static unsigned g_STAT_OFFSET = 0;
+#endif
+
+/* for good normalization speed we still reserve 256 MB before 4 GB range */
+#define kLzmaMaxHistorySize ((UInt32)15 << 28)
+
+// #define kNumTopBits 24
+#define kTopValue ((UInt32)1 << 24)
+
+#define kNumBitModelTotalBits 11
+#define kBitModelTotal (1 << kNumBitModelTotalBits)
+#define kNumMoveBits 5
+#define kProbInitValue (kBitModelTotal >> 1)
+
+#define kNumMoveReducingBits 4
+#define kNumBitPriceShiftBits 4
+// #define kBitPrice (1 << kNumBitPriceShiftBits)
+
+#define REP_LEN_COUNT 64
+
+void LzmaEncProps_Init(CLzmaEncProps *p)
+{
+ p->level = 5;
+ p->dictSize = p->mc = 0;
+ p->reduceSize = (UInt64)(Int64)-1;
+ p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;
+ p->numHashOutBits = 0;
+ p->writeEndMark = 0;
+ p->affinity = 0;
+}
+
+void LzmaEncProps_Normalize(CLzmaEncProps *p)
+{
+ int level = p->level;
+ if (level < 0) level = 5;
+ p->level = level;
+
+ if (p->dictSize == 0)
+ p->dictSize =
+ ( level <= 3 ? ((UInt32)1 << (level * 2 + 16)) :
+ ( level <= 6 ? ((UInt32)1 << (level + 19)) :
+ ( level <= 7 ? ((UInt32)1 << 25) : ((UInt32)1 << 26)
+ )));
+
+ if (p->dictSize > p->reduceSize)
+ {
+ UInt32 v = (UInt32)p->reduceSize;
+ const UInt32 kReduceMin = ((UInt32)1 << 12);
+ if (v < kReduceMin)
+ v = kReduceMin;
+ if (p->dictSize > v)
+ p->dictSize = v;
+ }
+
+ if (p->lc < 0) p->lc = 3;
+ if (p->lp < 0) p->lp = 0;
+ if (p->pb < 0) p->pb = 2;
+
+ if (p->algo < 0) p->algo = (level < 5 ? 0 : 1);
+ if (p->fb < 0) p->fb = (level < 7 ? 32 : 64);
+ if (p->btMode < 0) p->btMode = (p->algo == 0 ? 0 : 1);
+ if (p->numHashBytes < 0) p->numHashBytes = (p->btMode ? 4 : 5);
+ if (p->mc == 0) p->mc = (16 + ((unsigned)p->fb >> 1)) >> (p->btMode ? 0 : 1);
+
+ if (p->numThreads < 0)
+ p->numThreads =
+ #ifndef Z7_ST
+ ((p->btMode && p->algo) ? 2 : 1);
+ #else
+ 1;
+ #endif
+}
+
+UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2)
+{
+ CLzmaEncProps props = *props2;
+ LzmaEncProps_Normalize(&props);
+ return props.dictSize;
+}
+
+
+/*
+x86/x64:
+
+BSR:
+ IF (SRC == 0) ZF = 1, DEST is undefined;
+ AMD : DEST is unchanged;
+ IF (SRC != 0) ZF = 0; DEST is index of top non-zero bit
+ BSR is slow in some processors
+
+LZCNT:
+ IF (SRC == 0) CF = 1, DEST is size_in_bits_of_register(src) (32 or 64)
+ IF (SRC != 0) CF = 0, DEST = num_lead_zero_bits
+ IF (DEST == 0) ZF = 1;
+
+LZCNT works only in new processors starting from Haswell.
+if LZCNT is not supported by processor, then it's executed as BSR.
+LZCNT can be faster than BSR, if supported.
+*/
+
+// #define LZMA_LOG_BSR
+
+#if defined(MY_CPU_ARM_OR_ARM64) /* || defined(MY_CPU_X86_OR_AMD64) */
+
+ #if (defined(__clang__) && (__clang_major__ >= 6)) \
+ || (defined(__GNUC__) && (__GNUC__ >= 6))
+ #define LZMA_LOG_BSR
+ #elif defined(_MSC_VER) && (_MSC_VER >= 1300)
+ // #if defined(MY_CPU_ARM_OR_ARM64)
+ #define LZMA_LOG_BSR
+ // #endif
+ #endif
+#endif
+
+// #include <intrin.h>
+
+#ifdef LZMA_LOG_BSR
+
+#if defined(__clang__) \
+ || defined(__GNUC__)
+
+/*
+ C code: : (30 - __builtin_clz(x))
+ gcc9/gcc10 for x64 /x86 : 30 - (bsr(x) xor 31)
+ clang10 for x64 : 31 + (bsr(x) xor -32)
+*/
+
+ #define MY_clz(x) ((unsigned)__builtin_clz(x))
+ // __lzcnt32
+ // __builtin_ia32_lzcnt_u32
+
+#else // #if defined(_MSC_VER)
+
+ #ifdef MY_CPU_ARM_OR_ARM64
+
+ #define MY_clz _CountLeadingZeros
+
+ #else // if defined(MY_CPU_X86_OR_AMD64)
+
+ // #define MY_clz __lzcnt // we can use lzcnt (unsupported by old CPU)
+ // _BitScanReverse code is not optimal for some MSVC compilers
+ #define BSR2_RET(pos, res) { unsigned long zz; _BitScanReverse(&zz, (pos)); zz--; \
+ res = (zz + zz) + (pos >> zz); }
+
+ #endif // MY_CPU_X86_OR_AMD64
+
+#endif // _MSC_VER
+
+
+#ifndef BSR2_RET
+
+ #define BSR2_RET(pos, res) { unsigned zz = 30 - MY_clz(pos); \
+ res = (zz + zz) + (pos >> zz); }
+
+#endif
+
+
+unsigned GetPosSlot1(UInt32 pos);
+unsigned GetPosSlot1(UInt32 pos)
+{
+ unsigned res;
+ BSR2_RET(pos, res);
+ return res;
+}
+#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
+#define GetPosSlot(pos, res) { if (pos < 2) res = pos; else BSR2_RET(pos, res); }
+
+
+#else // ! LZMA_LOG_BSR
+
+#define kNumLogBits (11 + sizeof(size_t) / 8 * 3)
+
+#define kDicLogSizeMaxCompress ((kNumLogBits - 1) * 2 + 7)
+
+static void LzmaEnc_FastPosInit(Byte *g_FastPos)
+{
+ unsigned slot;
+ g_FastPos[0] = 0;
+ g_FastPos[1] = 1;
+ g_FastPos += 2;
+
+ for (slot = 2; slot < kNumLogBits * 2; slot++)
+ {
+ size_t k = ((size_t)1 << ((slot >> 1) - 1));
+ size_t j;
+ for (j = 0; j < k; j++)
+ g_FastPos[j] = (Byte)slot;
+ g_FastPos += k;
+ }
+}
+
+/* we can use ((limit - pos) >> 31) only if (pos < ((UInt32)1 << 31)) */
+/*
+#define BSR2_RET(pos, res) { unsigned zz = 6 + ((kNumLogBits - 1) & \
+ (0 - (((((UInt32)1 << (kNumLogBits + 6)) - 1) - pos) >> 31))); \
+ res = p->g_FastPos[pos >> zz] + (zz * 2); }
+*/
+
+/*
+#define BSR2_RET(pos, res) { unsigned zz = 6 + ((kNumLogBits - 1) & \
+ (0 - (((((UInt32)1 << (kNumLogBits)) - 1) - (pos >> 6)) >> 31))); \
+ res = p->g_FastPos[pos >> zz] + (zz * 2); }
+*/
+
+#define BSR2_RET(pos, res) { unsigned zz = (pos < (1 << (kNumLogBits + 6))) ? 6 : 6 + kNumLogBits - 1; \
+ res = p->g_FastPos[pos >> zz] + (zz * 2); }
+
+/*
+#define BSR2_RET(pos, res) { res = (pos < (1 << (kNumLogBits + 6))) ? \
+ p->g_FastPos[pos >> 6] + 12 : \
+ p->g_FastPos[pos >> (6 + kNumLogBits - 1)] + (6 + (kNumLogBits - 1)) * 2; }
+*/
+
+#define GetPosSlot1(pos) p->g_FastPos[pos]
+#define GetPosSlot2(pos, res) { BSR2_RET(pos, res); }
+#define GetPosSlot(pos, res) { if (pos < kNumFullDistances) res = p->g_FastPos[pos & (kNumFullDistances - 1)]; else BSR2_RET(pos, res); }
+
+#endif // LZMA_LOG_BSR
+
+
+#define LZMA_NUM_REPS 4
+
+typedef UInt16 CState;
+typedef UInt16 CExtra;
+
+typedef struct
+{
+ UInt32 price;
+ CState state;
+ CExtra extra;
+ // 0 : normal
+ // 1 : LIT : MATCH
+ // > 1 : MATCH (extra-1) : LIT : REP0 (len)
+ UInt32 len;
+ UInt32 dist;
+ UInt32 reps[LZMA_NUM_REPS];
+} COptimal;
+
+
+// 18.06
+#define kNumOpts (1 << 11)
+#define kPackReserve (kNumOpts * 8)
+// #define kNumOpts (1 << 12)
+// #define kPackReserve (1 + kNumOpts * 2)
+
+#define kNumLenToPosStates 4
+#define kNumPosSlotBits 6
+// #define kDicLogSizeMin 0
+#define kDicLogSizeMax 32
+#define kDistTableSizeMax (kDicLogSizeMax * 2)
+
+#define kNumAlignBits 4
+#define kAlignTableSize (1 << kNumAlignBits)
+#define kAlignMask (kAlignTableSize - 1)
+
+#define kStartPosModelIndex 4
+#define kEndPosModelIndex 14
+#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
+
+typedef
+#ifdef Z7_LZMA_PROB32
+ UInt32
+#else
+ UInt16
+#endif
+ CLzmaProb;
+
+#define LZMA_PB_MAX 4
+#define LZMA_LC_MAX 8
+#define LZMA_LP_MAX 4
+
+#define LZMA_NUM_PB_STATES_MAX (1 << LZMA_PB_MAX)
+
+#define kLenNumLowBits 3
+#define kLenNumLowSymbols (1 << kLenNumLowBits)
+#define kLenNumHighBits 8
+#define kLenNumHighSymbols (1 << kLenNumHighBits)
+#define kLenNumSymbolsTotal (kLenNumLowSymbols * 2 + kLenNumHighSymbols)
+
+#define LZMA_MATCH_LEN_MIN 2
+#define LZMA_MATCH_LEN_MAX (LZMA_MATCH_LEN_MIN + kLenNumSymbolsTotal - 1)
+
+#define kNumStates 12
+
+
+typedef struct
+{
+ CLzmaProb low[LZMA_NUM_PB_STATES_MAX << (kLenNumLowBits + 1)];
+ CLzmaProb high[kLenNumHighSymbols];
+} CLenEnc;
+
+
+typedef struct
+{
+ unsigned tableSize;
+ UInt32 prices[LZMA_NUM_PB_STATES_MAX][kLenNumSymbolsTotal];
+ // UInt32 prices1[LZMA_NUM_PB_STATES_MAX][kLenNumLowSymbols * 2];
+ // UInt32 prices2[kLenNumSymbolsTotal];
+} CLenPriceEnc;
+
+#define GET_PRICE_LEN(p, posState, len) \
+ ((p)->prices[posState][(size_t)(len) - LZMA_MATCH_LEN_MIN])
+
+/*
+#define GET_PRICE_LEN(p, posState, len) \
+ ((p)->prices2[(size_t)(len) - 2] + ((p)->prices1[posState][((len) - 2) & (kLenNumLowSymbols * 2 - 1)] & (((len) - 2 - kLenNumLowSymbols * 2) >> 9)))
+*/
+
+typedef struct
+{
+ UInt32 range;
+ unsigned cache;
+ UInt64 low;
+ UInt64 cacheSize;
+ Byte *buf;
+ Byte *bufLim;
+ Byte *bufBase;
+ ISeqOutStreamPtr outStream;
+ UInt64 processed;
+ SRes res;
+} CRangeEnc;
+
+
+typedef struct
+{
+ CLzmaProb *litProbs;
+
+ unsigned state;
+ UInt32 reps[LZMA_NUM_REPS];
+
+ CLzmaProb posAlignEncoder[1 << kNumAlignBits];
+ CLzmaProb isRep[kNumStates];
+ CLzmaProb isRepG0[kNumStates];
+ CLzmaProb isRepG1[kNumStates];
+ CLzmaProb isRepG2[kNumStates];
+ CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
+ CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
+
+ CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
+ CLzmaProb posEncoders[kNumFullDistances];
+
+ CLenEnc lenProbs;
+ CLenEnc repLenProbs;
+
+} CSaveState;
+
+
+typedef UInt32 CProbPrice;
+
+
+struct CLzmaEnc
+{
+ void *matchFinderObj;
+ IMatchFinder2 matchFinder;
+
+ unsigned optCur;
+ unsigned optEnd;
+
+ unsigned longestMatchLen;
+ unsigned numPairs;
+ UInt32 numAvail;
+
+ unsigned state;
+ unsigned numFastBytes;
+ unsigned additionalOffset;
+ UInt32 reps[LZMA_NUM_REPS];
+ unsigned lpMask, pbMask;
+ CLzmaProb *litProbs;
+ CRangeEnc rc;
+
+ UInt32 backRes;
+
+ unsigned lc, lp, pb;
+ unsigned lclp;
+
+ BoolInt fastMode;
+ BoolInt writeEndMark;
+ BoolInt finished;
+ BoolInt multiThread;
+ BoolInt needInit;
+ // BoolInt _maxMode;
+
+ UInt64 nowPos64;
+
+ unsigned matchPriceCount;
+ // unsigned alignPriceCount;
+ int repLenEncCounter;
+
+ unsigned distTableSize;
+
+ UInt32 dictSize;
+ SRes result;
+
+ #ifndef Z7_ST
+ BoolInt mtMode;
+ // begin of CMatchFinderMt is used in LZ thread
+ CMatchFinderMt matchFinderMt;
+ // end of CMatchFinderMt is used in BT and HASH threads
+ // #else
+ // CMatchFinder matchFinderBase;
+ #endif
+ CMatchFinder matchFinderBase;
+
+
+ // we suppose that we have 8-bytes alignment after CMatchFinder
+
+ #ifndef Z7_ST
+ Byte pad[128];
+ #endif
+
+ // LZ thread
+ CProbPrice ProbPrices[kBitModelTotal >> kNumMoveReducingBits];
+
+ // we want {len , dist} pairs to be 8-bytes aligned in matches array
+ UInt32 matches[LZMA_MATCH_LEN_MAX * 2 + 2];
+
+ // we want 8-bytes alignment here
+ UInt32 alignPrices[kAlignTableSize];
+ UInt32 posSlotPrices[kNumLenToPosStates][kDistTableSizeMax];
+ UInt32 distancesPrices[kNumLenToPosStates][kNumFullDistances];
+
+ CLzmaProb posAlignEncoder[1 << kNumAlignBits];
+ CLzmaProb isRep[kNumStates];
+ CLzmaProb isRepG0[kNumStates];
+ CLzmaProb isRepG1[kNumStates];
+ CLzmaProb isRepG2[kNumStates];
+ CLzmaProb isMatch[kNumStates][LZMA_NUM_PB_STATES_MAX];
+ CLzmaProb isRep0Long[kNumStates][LZMA_NUM_PB_STATES_MAX];
+ CLzmaProb posSlotEncoder[kNumLenToPosStates][1 << kNumPosSlotBits];
+ CLzmaProb posEncoders[kNumFullDistances];
+
+ CLenEnc lenProbs;
+ CLenEnc repLenProbs;
+
+ #ifndef LZMA_LOG_BSR
+ Byte g_FastPos[1 << kNumLogBits];
+ #endif
+
+ CLenPriceEnc lenEnc;
+ CLenPriceEnc repLenEnc;
+
+ COptimal opt[kNumOpts];
+
+ CSaveState saveState;
+
+ // BoolInt mf_Failure;
+ #ifndef Z7_ST
+ Byte pad2[128];
+ #endif
+};
+
+
+#define MFB (p->matchFinderBase)
+/*
+#ifndef Z7_ST
+#define MFB (p->matchFinderMt.MatchFinder)
+#endif
+*/
+
+// #define GET_CLzmaEnc_p CLzmaEnc *p = (CLzmaEnc*)(void *)p;
+// #define GET_const_CLzmaEnc_p const CLzmaEnc *p = (const CLzmaEnc*)(const void *)p;
+
+#define COPY_ARR(dest, src, arr) memcpy((dest)->arr, (src)->arr, sizeof((src)->arr));
+
+#define COPY_LZMA_ENC_STATE(d, s, p) \
+ (d)->state = (s)->state; \
+ COPY_ARR(d, s, reps) \
+ COPY_ARR(d, s, posAlignEncoder) \
+ COPY_ARR(d, s, isRep) \
+ COPY_ARR(d, s, isRepG0) \
+ COPY_ARR(d, s, isRepG1) \
+ COPY_ARR(d, s, isRepG2) \
+ COPY_ARR(d, s, isMatch) \
+ COPY_ARR(d, s, isRep0Long) \
+ COPY_ARR(d, s, posSlotEncoder) \
+ COPY_ARR(d, s, posEncoders) \
+ (d)->lenProbs = (s)->lenProbs; \
+ (d)->repLenProbs = (s)->repLenProbs; \
+ memcpy((d)->litProbs, (s)->litProbs, ((UInt32)0x300 << (p)->lclp) * sizeof(CLzmaProb));
+
+void LzmaEnc_SaveState(CLzmaEncHandle p)
+{
+ // GET_CLzmaEnc_p
+ CSaveState *v = &p->saveState;
+ COPY_LZMA_ENC_STATE(v, p, p)
+}
+
+void LzmaEnc_RestoreState(CLzmaEncHandle p)
+{
+ // GET_CLzmaEnc_p
+ const CSaveState *v = &p->saveState;
+ COPY_LZMA_ENC_STATE(p, v, p)
+}
+
+
+Z7_NO_INLINE
+SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props2)
+{
+ // GET_CLzmaEnc_p
+ CLzmaEncProps props = *props2;
+ LzmaEncProps_Normalize(&props);
+
+ if (props.lc > LZMA_LC_MAX
+ || props.lp > LZMA_LP_MAX
+ || props.pb > LZMA_PB_MAX)
+ return SZ_ERROR_PARAM;
+
+
+ if (props.dictSize > kLzmaMaxHistorySize)
+ props.dictSize = kLzmaMaxHistorySize;
+
+ #ifndef LZMA_LOG_BSR
+ {
+ const UInt64 dict64 = props.dictSize;
+ if (dict64 > ((UInt64)1 << kDicLogSizeMaxCompress))
+ return SZ_ERROR_PARAM;
+ }
+ #endif
+
+ p->dictSize = props.dictSize;
+ {
+ unsigned fb = (unsigned)props.fb;
+ if (fb < 5)
+ fb = 5;
+ if (fb > LZMA_MATCH_LEN_MAX)
+ fb = LZMA_MATCH_LEN_MAX;
+ p->numFastBytes = fb;
+ }
+ p->lc = (unsigned)props.lc;
+ p->lp = (unsigned)props.lp;
+ p->pb = (unsigned)props.pb;
+ p->fastMode = (props.algo == 0);
+ // p->_maxMode = True;
+ MFB.btMode = (Byte)(props.btMode ? 1 : 0);
+ // MFB.btMode = (Byte)(props.btMode);
+ {
+ unsigned numHashBytes = 4;
+ if (props.btMode)
+ {
+ if (props.numHashBytes < 2) numHashBytes = 2;
+ else if (props.numHashBytes < 4) numHashBytes = (unsigned)props.numHashBytes;
+ }
+ if (props.numHashBytes >= 5) numHashBytes = 5;
+
+ MFB.numHashBytes = numHashBytes;
+ // MFB.numHashBytes_Min = 2;
+ MFB.numHashOutBits = (Byte)props.numHashOutBits;
+ }
+
+ MFB.cutValue = props.mc;
+
+ p->writeEndMark = (BoolInt)props.writeEndMark;
+
+ #ifndef Z7_ST
+ /*
+ if (newMultiThread != _multiThread)
+ {
+ ReleaseMatchFinder();
+ _multiThread = newMultiThread;
+ }
+ */
+ p->multiThread = (props.numThreads > 1);
+ p->matchFinderMt.btSync.affinity =
+ p->matchFinderMt.hashSync.affinity = props.affinity;
+ #endif
+
+ return SZ_OK;
+}
+
+
+void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize)
+{
+ // GET_CLzmaEnc_p
+ MFB.expectedDataSize = expectedDataSiize;
+}
+
+
+#define kState_Start 0
+#define kState_LitAfterMatch 4
+#define kState_LitAfterRep 5
+#define kState_MatchAfterLit 7
+#define kState_RepAfterLit 8
+
+static const Byte kLiteralNextStates[kNumStates] = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
+static const Byte kMatchNextStates[kNumStates] = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
+static const Byte kRepNextStates[kNumStates] = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
+static const Byte kShortRepNextStates[kNumStates]= {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
+
+#define IsLitState(s) ((s) < 7)
+#define GetLenToPosState2(len) (((len) < kNumLenToPosStates - 1) ? (len) : kNumLenToPosStates - 1)
+#define GetLenToPosState(len) (((len) < kNumLenToPosStates + 1) ? (len) - 2 : kNumLenToPosStates - 1)
+
+#define kInfinityPrice (1 << 30)
+
+static void RangeEnc_Construct(CRangeEnc *p)
+{
+ p->outStream = NULL;
+ p->bufBase = NULL;
+}
+
+#define RangeEnc_GetProcessed(p) ( (p)->processed + (size_t)((p)->buf - (p)->bufBase) + (p)->cacheSize)
+#define RangeEnc_GetProcessed_sizet(p) ((size_t)(p)->processed + (size_t)((p)->buf - (p)->bufBase) + (size_t)(p)->cacheSize)
+
+#define RC_BUF_SIZE (1 << 16)
+
+static int RangeEnc_Alloc(CRangeEnc *p, ISzAllocPtr alloc)
+{
+ if (!p->bufBase)
+ {
+ p->bufBase = (Byte *)ISzAlloc_Alloc(alloc, RC_BUF_SIZE);
+ if (!p->bufBase)
+ return 0;
+ p->bufLim = p->bufBase + RC_BUF_SIZE;
+ }
+ return 1;
+}
+
+static void RangeEnc_Free(CRangeEnc *p, ISzAllocPtr alloc)
+{
+ ISzAlloc_Free(alloc, p->bufBase);
+ p->bufBase = NULL;
+}
+
+static void RangeEnc_Init(CRangeEnc *p)
+{
+ p->range = 0xFFFFFFFF;
+ p->cache = 0;
+ p->low = 0;
+ p->cacheSize = 0;
+
+ p->buf = p->bufBase;
+
+ p->processed = 0;
+ p->res = SZ_OK;
+}
+
+Z7_NO_INLINE static void RangeEnc_FlushStream(CRangeEnc *p)
+{
+ const size_t num = (size_t)(p->buf - p->bufBase);
+ if (p->res == SZ_OK)
+ {
+ if (num != ISeqOutStream_Write(p->outStream, p->bufBase, num))
+ p->res = SZ_ERROR_WRITE;
+ }
+ p->processed += num;
+ p->buf = p->bufBase;
+}
+
+Z7_NO_INLINE static void Z7_FASTCALL RangeEnc_ShiftLow(CRangeEnc *p)
+{
+ UInt32 low = (UInt32)p->low;
+ unsigned high = (unsigned)(p->low >> 32);
+ p->low = (UInt32)(low << 8);
+ if (low < (UInt32)0xFF000000 || high != 0)
+ {
+ {
+ Byte *buf = p->buf;
+ *buf++ = (Byte)(p->cache + high);
+ p->cache = (unsigned)(low >> 24);
+ p->buf = buf;
+ if (buf == p->bufLim)
+ RangeEnc_FlushStream(p);
+ if (p->cacheSize == 0)
+ return;
+ }
+ high += 0xFF;
+ for (;;)
+ {
+ Byte *buf = p->buf;
+ *buf++ = (Byte)(high);
+ p->buf = buf;
+ if (buf == p->bufLim)
+ RangeEnc_FlushStream(p);
+ if (--p->cacheSize == 0)
+ return;
+ }
+ }
+ p->cacheSize++;
+}
+
+static void RangeEnc_FlushData(CRangeEnc *p)
+{
+ int i;
+ for (i = 0; i < 5; i++)
+ RangeEnc_ShiftLow(p);
+}
+
+#define RC_NORM(p) if (range < kTopValue) { range <<= 8; RangeEnc_ShiftLow(p); }
+
+#define RC_BIT_PRE(p, prob) \
+ ttt = *(prob); \
+ newBound = (range >> kNumBitModelTotalBits) * ttt;
+
+// #define Z7_LZMA_ENC_USE_BRANCH
+
+#ifdef Z7_LZMA_ENC_USE_BRANCH
+
+#define RC_BIT(p, prob, bit) { \
+ RC_BIT_PRE(p, prob) \
+ if (bit == 0) { range = newBound; ttt += (kBitModelTotal - ttt) >> kNumMoveBits; } \
+ else { (p)->low += newBound; range -= newBound; ttt -= ttt >> kNumMoveBits; } \
+ *(prob) = (CLzmaProb)ttt; \
+ RC_NORM(p) \
+ }
+
+#else
+
+#define RC_BIT(p, prob, bit) { \
+ UInt32 mask; \
+ RC_BIT_PRE(p, prob) \
+ mask = 0 - (UInt32)bit; \
+ range &= mask; \
+ mask &= newBound; \
+ range -= mask; \
+ (p)->low += mask; \
+ mask = (UInt32)bit - 1; \
+ range += newBound & mask; \
+ mask &= (kBitModelTotal - ((1 << kNumMoveBits) - 1)); \
+ mask += ((1 << kNumMoveBits) - 1); \
+ ttt += (UInt32)((Int32)(mask - ttt) >> kNumMoveBits); \
+ *(prob) = (CLzmaProb)ttt; \
+ RC_NORM(p) \
+ }
+
+#endif
+
+
+
+
+#define RC_BIT_0_BASE(p, prob) \
+ range = newBound; *(prob) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
+
+#define RC_BIT_1_BASE(p, prob) \
+ range -= newBound; (p)->low += newBound; *(prob) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits)); \
+
+#define RC_BIT_0(p, prob) \
+ RC_BIT_0_BASE(p, prob) \
+ RC_NORM(p)
+
+#define RC_BIT_1(p, prob) \
+ RC_BIT_1_BASE(p, prob) \
+ RC_NORM(p)
+
+static void RangeEnc_EncodeBit_0(CRangeEnc *p, CLzmaProb *prob)
+{
+ UInt32 range, ttt, newBound;
+ range = p->range;
+ RC_BIT_PRE(p, prob)
+ RC_BIT_0(p, prob)
+ p->range = range;
+}
+
+static void LitEnc_Encode(CRangeEnc *p, CLzmaProb *probs, UInt32 sym)
+{
+ UInt32 range = p->range;
+ sym |= 0x100;
+ do
+ {
+ UInt32 ttt, newBound;
+ // RangeEnc_EncodeBit(p, probs + (sym >> 8), (sym >> 7) & 1);
+ CLzmaProb *prob = probs + (sym >> 8);
+ UInt32 bit = (sym >> 7) & 1;
+ sym <<= 1;
+ RC_BIT(p, prob, bit)
+ }
+ while (sym < 0x10000);
+ p->range = range;
+}
+
+static void LitEnc_EncodeMatched(CRangeEnc *p, CLzmaProb *probs, UInt32 sym, UInt32 matchByte)
+{
+ UInt32 range = p->range;
+ UInt32 offs = 0x100;
+ sym |= 0x100;
+ do
+ {
+ UInt32 ttt, newBound;
+ CLzmaProb *prob;
+ UInt32 bit;
+ matchByte <<= 1;
+ // RangeEnc_EncodeBit(p, probs + (offs + (matchByte & offs) + (sym >> 8)), (sym >> 7) & 1);
+ prob = probs + (offs + (matchByte & offs) + (sym >> 8));
+ bit = (sym >> 7) & 1;
+ sym <<= 1;
+ offs &= ~(matchByte ^ sym);
+ RC_BIT(p, prob, bit)
+ }
+ while (sym < 0x10000);
+ p->range = range;
+}
+
+
+
+static void LzmaEnc_InitPriceTables(CProbPrice *ProbPrices)
+{
+ UInt32 i;
+ for (i = 0; i < (kBitModelTotal >> kNumMoveReducingBits); i++)
+ {
+ const unsigned kCyclesBits = kNumBitPriceShiftBits;
+ UInt32 w = (i << kNumMoveReducingBits) + (1 << (kNumMoveReducingBits - 1));
+ unsigned bitCount = 0;
+ unsigned j;
+ for (j = 0; j < kCyclesBits; j++)
+ {
+ w = w * w;
+ bitCount <<= 1;
+ while (w >= ((UInt32)1 << 16))
+ {
+ w >>= 1;
+ bitCount++;
+ }
+ }
+ ProbPrices[i] = (CProbPrice)(((unsigned)kNumBitModelTotalBits << kCyclesBits) - 15 - bitCount);
+ // printf("\n%3d: %5d", i, ProbPrices[i]);
+ }
+}
+
+
+#define GET_PRICE(prob, bit) \
+ p->ProbPrices[((prob) ^ (unsigned)(((-(int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits]
+
+#define GET_PRICEa(prob, bit) \
+ ProbPrices[((prob) ^ (unsigned)((-((int)(bit))) & (kBitModelTotal - 1))) >> kNumMoveReducingBits]
+
+#define GET_PRICE_0(prob) p->ProbPrices[(prob) >> kNumMoveReducingBits]
+#define GET_PRICE_1(prob) p->ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
+
+#define GET_PRICEa_0(prob) ProbPrices[(prob) >> kNumMoveReducingBits]
+#define GET_PRICEa_1(prob) ProbPrices[((prob) ^ (kBitModelTotal - 1)) >> kNumMoveReducingBits]
+
+
+static UInt32 LitEnc_GetPrice(const CLzmaProb *probs, UInt32 sym, const CProbPrice *ProbPrices)
+{
+ UInt32 price = 0;
+ sym |= 0x100;
+ do
+ {
+ unsigned bit = sym & 1;
+ sym >>= 1;
+ price += GET_PRICEa(probs[sym], bit);
+ }
+ while (sym >= 2);
+ return price;
+}
+
+
+static UInt32 LitEnc_Matched_GetPrice(const CLzmaProb *probs, UInt32 sym, UInt32 matchByte, const CProbPrice *ProbPrices)
+{
+ UInt32 price = 0;
+ UInt32 offs = 0x100;
+ sym |= 0x100;
+ do
+ {
+ matchByte <<= 1;
+ price += GET_PRICEa(probs[offs + (matchByte & offs) + (sym >> 8)], (sym >> 7) & 1);
+ sym <<= 1;
+ offs &= ~(matchByte ^ sym);
+ }
+ while (sym < 0x10000);
+ return price;
+}
+
+
+static void RcTree_ReverseEncode(CRangeEnc *rc, CLzmaProb *probs, unsigned numBits, unsigned sym)
+{
+ UInt32 range = rc->range;
+ unsigned m = 1;
+ do
+ {
+ UInt32 ttt, newBound;
+ unsigned bit = sym & 1;
+ // RangeEnc_EncodeBit(rc, probs + m, bit);
+ sym >>= 1;
+ RC_BIT(rc, probs + m, bit)
+ m = (m << 1) | bit;
+ }
+ while (--numBits);
+ rc->range = range;
+}
+
+
+
+static void LenEnc_Init(CLenEnc *p)
+{
+ unsigned i;
+ for (i = 0; i < (LZMA_NUM_PB_STATES_MAX << (kLenNumLowBits + 1)); i++)
+ p->low[i] = kProbInitValue;
+ for (i = 0; i < kLenNumHighSymbols; i++)
+ p->high[i] = kProbInitValue;
+}
+
+static void LenEnc_Encode(CLenEnc *p, CRangeEnc *rc, unsigned sym, unsigned posState)
+{
+ UInt32 range, ttt, newBound;
+ CLzmaProb *probs = p->low;
+ range = rc->range;
+ RC_BIT_PRE(rc, probs)
+ if (sym >= kLenNumLowSymbols)
+ {
+ RC_BIT_1(rc, probs)
+ probs += kLenNumLowSymbols;
+ RC_BIT_PRE(rc, probs)
+ if (sym >= kLenNumLowSymbols * 2)
+ {
+ RC_BIT_1(rc, probs)
+ rc->range = range;
+ // RcTree_Encode(rc, p->high, kLenNumHighBits, sym - kLenNumLowSymbols * 2);
+ LitEnc_Encode(rc, p->high, sym - kLenNumLowSymbols * 2);
+ return;
+ }
+ sym -= kLenNumLowSymbols;
+ }
+
+ // RcTree_Encode(rc, probs + (posState << kLenNumLowBits), kLenNumLowBits, sym);
+ {
+ unsigned m;
+ unsigned bit;
+ RC_BIT_0(rc, probs)
+ probs += (posState << (1 + kLenNumLowBits));
+ bit = (sym >> 2) ; RC_BIT(rc, probs + 1, bit) m = (1 << 1) + bit;
+ bit = (sym >> 1) & 1; RC_BIT(rc, probs + m, bit) m = (m << 1) + bit;
+ bit = sym & 1; RC_BIT(rc, probs + m, bit)
+ rc->range = range;
+ }
+}
+
+static void SetPrices_3(const CLzmaProb *probs, UInt32 startPrice, UInt32 *prices, const CProbPrice *ProbPrices)
+{
+ unsigned i;
+ for (i = 0; i < 8; i += 2)
+ {
+ UInt32 price = startPrice;
+ UInt32 prob;
+ price += GET_PRICEa(probs[1 ], (i >> 2));
+ price += GET_PRICEa(probs[2 + (i >> 2)], (i >> 1) & 1);
+ prob = probs[4 + (i >> 1)];
+ prices[i ] = price + GET_PRICEa_0(prob);
+ prices[i + 1] = price + GET_PRICEa_1(prob);
+ }
+}
+
+
+Z7_NO_INLINE static void Z7_FASTCALL LenPriceEnc_UpdateTables(
+ CLenPriceEnc *p,
+ unsigned numPosStates,
+ const CLenEnc *enc,
+ const CProbPrice *ProbPrices)
+{
+ UInt32 b;
+
+ {
+ unsigned prob = enc->low[0];
+ UInt32 a, c;
+ unsigned posState;
+ b = GET_PRICEa_1(prob);
+ a = GET_PRICEa_0(prob);
+ c = b + GET_PRICEa_0(enc->low[kLenNumLowSymbols]);
+ for (posState = 0; posState < numPosStates; posState++)
+ {
+ UInt32 *prices = p->prices[posState];
+ const CLzmaProb *probs = enc->low + (posState << (1 + kLenNumLowBits));
+ SetPrices_3(probs, a, prices, ProbPrices);
+ SetPrices_3(probs + kLenNumLowSymbols, c, prices + kLenNumLowSymbols, ProbPrices);
+ }
+ }
+
+ /*
+ {
+ unsigned i;
+ UInt32 b;
+ a = GET_PRICEa_0(enc->low[0]);
+ for (i = 0; i < kLenNumLowSymbols; i++)
+ p->prices2[i] = a;
+ a = GET_PRICEa_1(enc->low[0]);
+ b = a + GET_PRICEa_0(enc->low[kLenNumLowSymbols]);
+ for (i = kLenNumLowSymbols; i < kLenNumLowSymbols * 2; i++)
+ p->prices2[i] = b;
+ a += GET_PRICEa_1(enc->low[kLenNumLowSymbols]);
+ }
+ */
+
+ // p->counter = numSymbols;
+ // p->counter = 64;
+
+ {
+ unsigned i = p->tableSize;
+
+ if (i > kLenNumLowSymbols * 2)
+ {
+ const CLzmaProb *probs = enc->high;
+ UInt32 *prices = p->prices[0] + kLenNumLowSymbols * 2;
+ i -= kLenNumLowSymbols * 2 - 1;
+ i >>= 1;
+ b += GET_PRICEa_1(enc->low[kLenNumLowSymbols]);
+ do
+ {
+ /*
+ p->prices2[i] = a +
+ // RcTree_GetPrice(enc->high, kLenNumHighBits, i - kLenNumLowSymbols * 2, ProbPrices);
+ LitEnc_GetPrice(probs, i - kLenNumLowSymbols * 2, ProbPrices);
+ */
+ // UInt32 price = a + RcTree_GetPrice(probs, kLenNumHighBits - 1, sym, ProbPrices);
+ unsigned sym = --i + (1 << (kLenNumHighBits - 1));
+ UInt32 price = b;
+ do
+ {
+ unsigned bit = sym & 1;
+ sym >>= 1;
+ price += GET_PRICEa(probs[sym], bit);
+ }
+ while (sym >= 2);
+
+ {
+ unsigned prob = probs[(size_t)i + (1 << (kLenNumHighBits - 1))];
+ prices[(size_t)i * 2 ] = price + GET_PRICEa_0(prob);
+ prices[(size_t)i * 2 + 1] = price + GET_PRICEa_1(prob);
+ }
+ }
+ while (i);
+
+ {
+ unsigned posState;
+ size_t num = (p->tableSize - kLenNumLowSymbols * 2) * sizeof(p->prices[0][0]);
+ for (posState = 1; posState < numPosStates; posState++)
+ memcpy(p->prices[posState] + kLenNumLowSymbols * 2, p->prices[0] + kLenNumLowSymbols * 2, num);
+ }
+ }
+ }
+}
+
+/*
+ #ifdef SHOW_STAT
+ g_STAT_OFFSET += num;
+ printf("\n MovePos %u", num);
+ #endif
+*/
+
+#define MOVE_POS(p, num) { \
+ p->additionalOffset += (num); \
+ p->matchFinder.Skip(p->matchFinderObj, (UInt32)(num)); }
+
+
+static unsigned ReadMatchDistances(CLzmaEnc *p, unsigned *numPairsRes)
+{
+ unsigned numPairs;
+
+ p->additionalOffset++;
+ p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
+ {
+ const UInt32 *d = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);
+ // if (!d) { p->mf_Failure = True; *numPairsRes = 0; return 0; }
+ numPairs = (unsigned)(d - p->matches);
+ }
+ *numPairsRes = numPairs;
+
+ #ifdef SHOW_STAT
+ printf("\n i = %u numPairs = %u ", g_STAT_OFFSET, numPairs / 2);
+ g_STAT_OFFSET++;
+ {
+ unsigned i;
+ for (i = 0; i < numPairs; i += 2)
+ printf("%2u %6u | ", p->matches[i], p->matches[i + 1]);
+ }
+ #endif
+
+ if (numPairs == 0)
+ return 0;
+ {
+ const unsigned len = p->matches[(size_t)numPairs - 2];
+ if (len != p->numFastBytes)
+ return len;
+ {
+ UInt32 numAvail = p->numAvail;
+ if (numAvail > LZMA_MATCH_LEN_MAX)
+ numAvail = LZMA_MATCH_LEN_MAX;
+ {
+ const Byte *p1 = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
+ const Byte *p2 = p1 + len;
+ const ptrdiff_t dif = (ptrdiff_t)-1 - (ptrdiff_t)p->matches[(size_t)numPairs - 1];
+ const Byte *lim = p1 + numAvail;
+ for (; p2 != lim && *p2 == p2[dif]; p2++)
+ {}
+ return (unsigned)(p2 - p1);
+ }
+ }
+ }
+}
+
+#define MARK_LIT ((UInt32)(Int32)-1)
+
+#define MakeAs_Lit(p) { (p)->dist = MARK_LIT; (p)->extra = 0; }
+#define MakeAs_ShortRep(p) { (p)->dist = 0; (p)->extra = 0; }
+#define IsShortRep(p) ((p)->dist == 0)
+
+
+#define GetPrice_ShortRep(p, state, posState) \
+ ( GET_PRICE_0(p->isRepG0[state]) + GET_PRICE_0(p->isRep0Long[state][posState]))
+
+#define GetPrice_Rep_0(p, state, posState) ( \
+ GET_PRICE_1(p->isMatch[state][posState]) \
+ + GET_PRICE_1(p->isRep0Long[state][posState])) \
+ + GET_PRICE_1(p->isRep[state]) \
+ + GET_PRICE_0(p->isRepG0[state])
+
+Z7_FORCE_INLINE
+static UInt32 GetPrice_PureRep(const CLzmaEnc *p, unsigned repIndex, size_t state, size_t posState)
+{
+ UInt32 price;
+ UInt32 prob = p->isRepG0[state];
+ if (repIndex == 0)
+ {
+ price = GET_PRICE_0(prob);
+ price += GET_PRICE_1(p->isRep0Long[state][posState]);
+ }
+ else
+ {
+ price = GET_PRICE_1(prob);
+ prob = p->isRepG1[state];
+ if (repIndex == 1)
+ price += GET_PRICE_0(prob);
+ else
+ {
+ price += GET_PRICE_1(prob);
+ price += GET_PRICE(p->isRepG2[state], repIndex - 2);
+ }
+ }
+ return price;
+}
+
+
+static unsigned Backward(CLzmaEnc *p, unsigned cur)
+{
+ unsigned wr = cur + 1;
+ p->optEnd = wr;
+
+ for (;;)
+ {
+ UInt32 dist = p->opt[cur].dist;
+ unsigned len = (unsigned)p->opt[cur].len;
+ unsigned extra = (unsigned)p->opt[cur].extra;
+ cur -= len;
+
+ if (extra)
+ {
+ wr--;
+ p->opt[wr].len = (UInt32)len;
+ cur -= extra;
+ len = extra;
+ if (extra == 1)
+ {
+ p->opt[wr].dist = dist;
+ dist = MARK_LIT;
+ }
+ else
+ {
+ p->opt[wr].dist = 0;
+ len--;
+ wr--;
+ p->opt[wr].dist = MARK_LIT;
+ p->opt[wr].len = 1;
+ }
+ }
+
+ if (cur == 0)
+ {
+ p->backRes = dist;
+ p->optCur = wr;
+ return len;
+ }
+
+ wr--;
+ p->opt[wr].dist = dist;
+ p->opt[wr].len = (UInt32)len;
+ }
+}
+
+
+
+#define LIT_PROBS(pos, prevByte) \
+ (p->litProbs + (UInt32)3 * (((((pos) << 8) + (prevByte)) & p->lpMask) << p->lc))
+
+
+static unsigned GetOptimum(CLzmaEnc *p, UInt32 position)
+{
+ unsigned last, cur;
+ UInt32 reps[LZMA_NUM_REPS];
+ unsigned repLens[LZMA_NUM_REPS];
+ UInt32 *matches;
+
+ {
+ UInt32 numAvail;
+ unsigned numPairs, mainLen, repMaxIndex, i, posState;
+ UInt32 matchPrice, repMatchPrice;
+ const Byte *data;
+ Byte curByte, matchByte;
+
+ p->optCur = p->optEnd = 0;
+
+ if (p->additionalOffset == 0)
+ mainLen = ReadMatchDistances(p, &numPairs);
+ else
+ {
+ mainLen = p->longestMatchLen;
+ numPairs = p->numPairs;
+ }
+
+ numAvail = p->numAvail;
+ if (numAvail < 2)
+ {
+ p->backRes = MARK_LIT;
+ return 1;
+ }
+ if (numAvail > LZMA_MATCH_LEN_MAX)
+ numAvail = LZMA_MATCH_LEN_MAX;
+
+ data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
+ repMaxIndex = 0;
+
+ for (i = 0; i < LZMA_NUM_REPS; i++)
+ {
+ unsigned len;
+ const Byte *data2;
+ reps[i] = p->reps[i];
+ data2 = data - reps[i];
+ if (data[0] != data2[0] || data[1] != data2[1])
+ {
+ repLens[i] = 0;
+ continue;
+ }
+ for (len = 2; len < numAvail && data[len] == data2[len]; len++)
+ {}
+ repLens[i] = len;
+ if (len > repLens[repMaxIndex])
+ repMaxIndex = i;
+ if (len == LZMA_MATCH_LEN_MAX) // 21.03 : optimization
+ break;
+ }
+
+ if (repLens[repMaxIndex] >= p->numFastBytes)
+ {
+ unsigned len;
+ p->backRes = (UInt32)repMaxIndex;
+ len = repLens[repMaxIndex];
+ MOVE_POS(p, len - 1)
+ return len;
+ }
+
+ matches = p->matches;
+ #define MATCHES matches
+ // #define MATCHES p->matches
+
+ if (mainLen >= p->numFastBytes)
+ {
+ p->backRes = MATCHES[(size_t)numPairs - 1] + LZMA_NUM_REPS;
+ MOVE_POS(p, mainLen - 1)
+ return mainLen;
+ }
+
+ curByte = *data;
+ matchByte = *(data - reps[0]);
+
+ last = repLens[repMaxIndex];
+ if (last <= mainLen)
+ last = mainLen;
+
+ if (last < 2 && curByte != matchByte)
+ {
+ p->backRes = MARK_LIT;
+ return 1;
+ }
+
+ p->opt[0].state = (CState)p->state;
+
+ posState = (position & p->pbMask);
+
+ {
+ const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
+ p->opt[1].price = GET_PRICE_0(p->isMatch[p->state][posState]) +
+ (!IsLitState(p->state) ?
+ LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
+ LitEnc_GetPrice(probs, curByte, p->ProbPrices));
+ }
+
+ MakeAs_Lit(&p->opt[1])
+
+ matchPrice = GET_PRICE_1(p->isMatch[p->state][posState]);
+ repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[p->state]);
+
+ // 18.06
+ if (matchByte == curByte && repLens[0] == 0)
+ {
+ UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, p->state, posState);
+ if (shortRepPrice < p->opt[1].price)
+ {
+ p->opt[1].price = shortRepPrice;
+ MakeAs_ShortRep(&p->opt[1])
+ }
+ if (last < 2)
+ {
+ p->backRes = p->opt[1].dist;
+ return 1;
+ }
+ }
+
+ p->opt[1].len = 1;
+
+ p->opt[0].reps[0] = reps[0];
+ p->opt[0].reps[1] = reps[1];
+ p->opt[0].reps[2] = reps[2];
+ p->opt[0].reps[3] = reps[3];
+
+ // ---------- REP ----------
+
+ for (i = 0; i < LZMA_NUM_REPS; i++)
+ {
+ unsigned repLen = repLens[i];
+ UInt32 price;
+ if (repLen < 2)
+ continue;
+ price = repMatchPrice + GetPrice_PureRep(p, i, p->state, posState);
+ do
+ {
+ UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, repLen);
+ COptimal *opt = &p->opt[repLen];
+ if (price2 < opt->price)
+ {
+ opt->price = price2;
+ opt->len = (UInt32)repLen;
+ opt->dist = (UInt32)i;
+ opt->extra = 0;
+ }
+ }
+ while (--repLen >= 2);
+ }
+
+
+ // ---------- MATCH ----------
+ {
+ unsigned len = repLens[0] + 1;
+ if (len <= mainLen)
+ {
+ unsigned offs = 0;
+ UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[p->state]);
+
+ if (len < 2)
+ len = 2;
+ else
+ while (len > MATCHES[offs])
+ offs += 2;
+
+ for (; ; len++)
+ {
+ COptimal *opt;
+ UInt32 dist = MATCHES[(size_t)offs + 1];
+ UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);
+ unsigned lenToPosState = GetLenToPosState(len);
+
+ if (dist < kNumFullDistances)
+ price += p->distancesPrices[lenToPosState][dist & (kNumFullDistances - 1)];
+ else
+ {
+ unsigned slot;
+ GetPosSlot2(dist, slot)
+ price += p->alignPrices[dist & kAlignMask];
+ price += p->posSlotPrices[lenToPosState][slot];
+ }
+
+ opt = &p->opt[len];
+
+ if (price < opt->price)
+ {
+ opt->price = price;
+ opt->len = (UInt32)len;
+ opt->dist = dist + LZMA_NUM_REPS;
+ opt->extra = 0;
+ }
+
+ if (len == MATCHES[offs])
+ {
+ offs += 2;
+ if (offs == numPairs)
+ break;
+ }
+ }
+ }
+ }
+
+
+ cur = 0;
+
+ #ifdef SHOW_STAT2
+ /* if (position >= 0) */
+ {
+ unsigned i;
+ printf("\n pos = %4X", position);
+ for (i = cur; i <= last; i++)
+ printf("\nprice[%4X] = %u", position - cur + i, p->opt[i].price);
+ }
+ #endif
+ }
+
+
+
+ // ---------- Optimal Parsing ----------
+
+ for (;;)
+ {
+ unsigned numAvail;
+ UInt32 numAvailFull;
+ unsigned newLen, numPairs, prev, state, posState, startLen;
+ UInt32 litPrice, matchPrice, repMatchPrice;
+ BoolInt nextIsLit;
+ Byte curByte, matchByte;
+ const Byte *data;
+ COptimal *curOpt, *nextOpt;
+
+ if (++cur == last)
+ break;
+
+ // 18.06
+ if (cur >= kNumOpts - 64)
+ {
+ unsigned j, best;
+ UInt32 price = p->opt[cur].price;
+ best = cur;
+ for (j = cur + 1; j <= last; j++)
+ {
+ UInt32 price2 = p->opt[j].price;
+ if (price >= price2)
+ {
+ price = price2;
+ best = j;
+ }
+ }
+ {
+ unsigned delta = best - cur;
+ if (delta != 0)
+ {
+ MOVE_POS(p, delta)
+ }
+ }
+ cur = best;
+ break;
+ }
+
+ newLen = ReadMatchDistances(p, &numPairs);
+
+ if (newLen >= p->numFastBytes)
+ {
+ p->numPairs = numPairs;
+ p->longestMatchLen = newLen;
+ break;
+ }
+
+ curOpt = &p->opt[cur];
+
+ position++;
+
+ // we need that check here, if skip_items in p->opt are possible
+ /*
+ if (curOpt->price >= kInfinityPrice)
+ continue;
+ */
+
+ prev = cur - curOpt->len;
+
+ if (curOpt->len == 1)
+ {
+ state = (unsigned)p->opt[prev].state;
+ if (IsShortRep(curOpt))
+ state = kShortRepNextStates[state];
+ else
+ state = kLiteralNextStates[state];
+ }
+ else
+ {
+ const COptimal *prevOpt;
+ UInt32 b0;
+ UInt32 dist = curOpt->dist;
+
+ if (curOpt->extra)
+ {
+ prev -= (unsigned)curOpt->extra;
+ state = kState_RepAfterLit;
+ if (curOpt->extra == 1)
+ state = (dist < LZMA_NUM_REPS ? kState_RepAfterLit : kState_MatchAfterLit);
+ }
+ else
+ {
+ state = (unsigned)p->opt[prev].state;
+ if (dist < LZMA_NUM_REPS)
+ state = kRepNextStates[state];
+ else
+ state = kMatchNextStates[state];
+ }
+
+ prevOpt = &p->opt[prev];
+ b0 = prevOpt->reps[0];
+
+ if (dist < LZMA_NUM_REPS)
+ {
+ if (dist == 0)
+ {
+ reps[0] = b0;
+ reps[1] = prevOpt->reps[1];
+ reps[2] = prevOpt->reps[2];
+ reps[3] = prevOpt->reps[3];
+ }
+ else
+ {
+ reps[1] = b0;
+ b0 = prevOpt->reps[1];
+ if (dist == 1)
+ {
+ reps[0] = b0;
+ reps[2] = prevOpt->reps[2];
+ reps[3] = prevOpt->reps[3];
+ }
+ else
+ {
+ reps[2] = b0;
+ reps[0] = prevOpt->reps[dist];
+ reps[3] = prevOpt->reps[dist ^ 1];
+ }
+ }
+ }
+ else
+ {
+ reps[0] = (dist - LZMA_NUM_REPS + 1);
+ reps[1] = b0;
+ reps[2] = prevOpt->reps[1];
+ reps[3] = prevOpt->reps[2];
+ }
+ }
+
+ curOpt->state = (CState)state;
+ curOpt->reps[0] = reps[0];
+ curOpt->reps[1] = reps[1];
+ curOpt->reps[2] = reps[2];
+ curOpt->reps[3] = reps[3];
+
+ data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
+ curByte = *data;
+ matchByte = *(data - reps[0]);
+
+ posState = (position & p->pbMask);
+
+ /*
+ The order of Price checks:
+ < LIT
+ <= SHORT_REP
+ < LIT : REP_0
+ < REP [ : LIT : REP_0 ]
+ < MATCH [ : LIT : REP_0 ]
+ */
+
+ {
+ UInt32 curPrice = curOpt->price;
+ unsigned prob = p->isMatch[state][posState];
+ matchPrice = curPrice + GET_PRICE_1(prob);
+ litPrice = curPrice + GET_PRICE_0(prob);
+ }
+
+ nextOpt = &p->opt[(size_t)cur + 1];
+ nextIsLit = False;
+
+ // here we can allow skip_items in p->opt, if we don't check (nextOpt->price < kInfinityPrice)
+ // 18.new.06
+ if ((nextOpt->price < kInfinityPrice
+ // && !IsLitState(state)
+ && matchByte == curByte)
+ || litPrice > nextOpt->price
+ )
+ litPrice = 0;
+ else
+ {
+ const CLzmaProb *probs = LIT_PROBS(position, *(data - 1));
+ litPrice += (!IsLitState(state) ?
+ LitEnc_Matched_GetPrice(probs, curByte, matchByte, p->ProbPrices) :
+ LitEnc_GetPrice(probs, curByte, p->ProbPrices));
+
+ if (litPrice < nextOpt->price)
+ {
+ nextOpt->price = litPrice;
+ nextOpt->len = 1;
+ MakeAs_Lit(nextOpt)
+ nextIsLit = True;
+ }
+ }
+
+ repMatchPrice = matchPrice + GET_PRICE_1(p->isRep[state]);
+
+ numAvailFull = p->numAvail;
+ {
+ unsigned temp = kNumOpts - 1 - cur;
+ if (numAvailFull > temp)
+ numAvailFull = (UInt32)temp;
+ }
+
+ // 18.06
+ // ---------- SHORT_REP ----------
+ if (IsLitState(state)) // 18.new
+ if (matchByte == curByte)
+ if (repMatchPrice < nextOpt->price) // 18.new
+ // if (numAvailFull < 2 || data[1] != *(data - reps[0] + 1))
+ if (
+ // nextOpt->price >= kInfinityPrice ||
+ nextOpt->len < 2 // we can check nextOpt->len, if skip items are not allowed in p->opt
+ || (nextOpt->dist != 0
+ // && nextOpt->extra <= 1 // 17.old
+ )
+ )
+ {
+ UInt32 shortRepPrice = repMatchPrice + GetPrice_ShortRep(p, state, posState);
+ // if (shortRepPrice <= nextOpt->price) // 17.old
+ if (shortRepPrice < nextOpt->price) // 18.new
+ {
+ nextOpt->price = shortRepPrice;
+ nextOpt->len = 1;
+ MakeAs_ShortRep(nextOpt)
+ nextIsLit = False;
+ }
+ }
+
+ if (numAvailFull < 2)
+ continue;
+ numAvail = (numAvailFull <= p->numFastBytes ? numAvailFull : p->numFastBytes);
+
+ // numAvail <= p->numFastBytes
+
+ // ---------- LIT : REP_0 ----------
+
+ if (!nextIsLit
+ && litPrice != 0 // 18.new
+ && matchByte != curByte
+ && numAvailFull > 2)
+ {
+ const Byte *data2 = data - reps[0];
+ if (data[1] == data2[1] && data[2] == data2[2])
+ {
+ unsigned len;
+ unsigned limit = p->numFastBytes + 1;
+ if (limit > numAvailFull)
+ limit = numAvailFull;
+ for (len = 3; len < limit && data[len] == data2[len]; len++)
+ {}
+
+ {
+ unsigned state2 = kLiteralNextStates[state];
+ unsigned posState2 = (position + 1) & p->pbMask;
+ UInt32 price = litPrice + GetPrice_Rep_0(p, state2, posState2);
+ {
+ unsigned offset = cur + len;
+
+ if (last < offset)
+ last = offset;
+
+ // do
+ {
+ UInt32 price2;
+ COptimal *opt;
+ len--;
+ // price2 = price + GetPrice_Len_Rep_0(p, len, state2, posState2);
+ price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len);
+
+ opt = &p->opt[offset];
+ // offset--;
+ if (price2 < opt->price)
+ {
+ opt->price = price2;
+ opt->len = (UInt32)len;
+ opt->dist = 0;
+ opt->extra = 1;
+ }
+ }
+ // while (len >= 3);
+ }
+ }
+ }
+ }
+
+ startLen = 2; /* speed optimization */
+
+ {
+ // ---------- REP ----------
+ unsigned repIndex = 0; // 17.old
+ // unsigned repIndex = IsLitState(state) ? 0 : 1; // 18.notused
+ for (; repIndex < LZMA_NUM_REPS; repIndex++)
+ {
+ unsigned len;
+ UInt32 price;
+ const Byte *data2 = data - reps[repIndex];
+ if (data[0] != data2[0] || data[1] != data2[1])
+ continue;
+
+ for (len = 2; len < numAvail && data[len] == data2[len]; len++)
+ {}
+
+ // if (len < startLen) continue; // 18.new: speed optimization
+
+ {
+ unsigned offset = cur + len;
+ if (last < offset)
+ last = offset;
+ }
+ {
+ unsigned len2 = len;
+ price = repMatchPrice + GetPrice_PureRep(p, repIndex, state, posState);
+ do
+ {
+ UInt32 price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState, len2);
+ COptimal *opt = &p->opt[cur + len2];
+ if (price2 < opt->price)
+ {
+ opt->price = price2;
+ opt->len = (UInt32)len2;
+ opt->dist = (UInt32)repIndex;
+ opt->extra = 0;
+ }
+ }
+ while (--len2 >= 2);
+ }
+
+ if (repIndex == 0) startLen = len + 1; // 17.old
+ // startLen = len + 1; // 18.new
+
+ /* if (_maxMode) */
+ {
+ // ---------- REP : LIT : REP_0 ----------
+ // numFastBytes + 1 + numFastBytes
+
+ unsigned len2 = len + 1;
+ unsigned limit = len2 + p->numFastBytes;
+ if (limit > numAvailFull)
+ limit = numAvailFull;
+
+ len2 += 2;
+ if (len2 <= limit)
+ if (data[len2 - 2] == data2[len2 - 2])
+ if (data[len2 - 1] == data2[len2 - 1])
+ {
+ unsigned state2 = kRepNextStates[state];
+ unsigned posState2 = (position + len) & p->pbMask;
+ price += GET_PRICE_LEN(&p->repLenEnc, posState, len)
+ + GET_PRICE_0(p->isMatch[state2][posState2])
+ + LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),
+ data[len], data2[len], p->ProbPrices);
+
+ // state2 = kLiteralNextStates[state2];
+ state2 = kState_LitAfterRep;
+ posState2 = (posState2 + 1) & p->pbMask;
+
+
+ price += GetPrice_Rep_0(p, state2, posState2);
+
+ for (; len2 < limit && data[len2] == data2[len2]; len2++)
+ {}
+
+ len2 -= len;
+ // if (len2 >= 3)
+ {
+ {
+ unsigned offset = cur + len + len2;
+
+ if (last < offset)
+ last = offset;
+ // do
+ {
+ UInt32 price2;
+ COptimal *opt;
+ len2--;
+ // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);
+ price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);
+
+ opt = &p->opt[offset];
+ // offset--;
+ if (price2 < opt->price)
+ {
+ opt->price = price2;
+ opt->len = (UInt32)len2;
+ opt->extra = (CExtra)(len + 1);
+ opt->dist = (UInt32)repIndex;
+ }
+ }
+ // while (len2 >= 3);
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+ // ---------- MATCH ----------
+ /* for (unsigned len = 2; len <= newLen; len++) */
+ if (newLen > numAvail)
+ {
+ newLen = numAvail;
+ for (numPairs = 0; newLen > MATCHES[numPairs]; numPairs += 2);
+ MATCHES[numPairs] = (UInt32)newLen;
+ numPairs += 2;
+ }
+
+ // startLen = 2; /* speed optimization */
+
+ if (newLen >= startLen)
+ {
+ UInt32 normalMatchPrice = matchPrice + GET_PRICE_0(p->isRep[state]);
+ UInt32 dist;
+ unsigned offs, posSlot, len;
+
+ {
+ unsigned offset = cur + newLen;
+ if (last < offset)
+ last = offset;
+ }
+
+ offs = 0;
+ while (startLen > MATCHES[offs])
+ offs += 2;
+ dist = MATCHES[(size_t)offs + 1];
+
+ // if (dist >= kNumFullDistances)
+ GetPosSlot2(dist, posSlot)
+
+ for (len = /*2*/ startLen; ; len++)
+ {
+ UInt32 price = normalMatchPrice + GET_PRICE_LEN(&p->lenEnc, posState, len);
+ {
+ COptimal *opt;
+ unsigned lenNorm = len - 2;
+ lenNorm = GetLenToPosState2(lenNorm);
+ if (dist < kNumFullDistances)
+ price += p->distancesPrices[lenNorm][dist & (kNumFullDistances - 1)];
+ else
+ price += p->posSlotPrices[lenNorm][posSlot] + p->alignPrices[dist & kAlignMask];
+
+ opt = &p->opt[cur + len];
+ if (price < opt->price)
+ {
+ opt->price = price;
+ opt->len = (UInt32)len;
+ opt->dist = dist + LZMA_NUM_REPS;
+ opt->extra = 0;
+ }
+ }
+
+ if (len == MATCHES[offs])
+ {
+ // if (p->_maxMode) {
+ // MATCH : LIT : REP_0
+
+ const Byte *data2 = data - dist - 1;
+ unsigned len2 = len + 1;
+ unsigned limit = len2 + p->numFastBytes;
+ if (limit > numAvailFull)
+ limit = numAvailFull;
+
+ len2 += 2;
+ if (len2 <= limit)
+ if (data[len2 - 2] == data2[len2 - 2])
+ if (data[len2 - 1] == data2[len2 - 1])
+ {
+ for (; len2 < limit && data[len2] == data2[len2]; len2++)
+ {}
+
+ len2 -= len;
+
+ // if (len2 >= 3)
+ {
+ unsigned state2 = kMatchNextStates[state];
+ unsigned posState2 = (position + len) & p->pbMask;
+ unsigned offset;
+ price += GET_PRICE_0(p->isMatch[state2][posState2]);
+ price += LitEnc_Matched_GetPrice(LIT_PROBS(position + len, data[(size_t)len - 1]),
+ data[len], data2[len], p->ProbPrices);
+
+ // state2 = kLiteralNextStates[state2];
+ state2 = kState_LitAfterMatch;
+
+ posState2 = (posState2 + 1) & p->pbMask;
+ price += GetPrice_Rep_0(p, state2, posState2);
+
+ offset = cur + len + len2;
+
+ if (last < offset)
+ last = offset;
+ // do
+ {
+ UInt32 price2;
+ COptimal *opt;
+ len2--;
+ // price2 = price + GetPrice_Len_Rep_0(p, len2, state2, posState2);
+ price2 = price + GET_PRICE_LEN(&p->repLenEnc, posState2, len2);
+ opt = &p->opt[offset];
+ // offset--;
+ if (price2 < opt->price)
+ {
+ opt->price = price2;
+ opt->len = (UInt32)len2;
+ opt->extra = (CExtra)(len + 1);
+ opt->dist = dist + LZMA_NUM_REPS;
+ }
+ }
+ // while (len2 >= 3);
+ }
+
+ }
+
+ offs += 2;
+ if (offs == numPairs)
+ break;
+ dist = MATCHES[(size_t)offs + 1];
+ // if (dist >= kNumFullDistances)
+ GetPosSlot2(dist, posSlot)
+ }
+ }
+ }
+ }
+
+ do
+ p->opt[last].price = kInfinityPrice;
+ while (--last);
+
+ return Backward(p, cur);
+}
+
+
+
+#define ChangePair(smallDist, bigDist) (((bigDist) >> 7) > (smallDist))
+
+
+
+static unsigned GetOptimumFast(CLzmaEnc *p)
+{
+ UInt32 numAvail, mainDist;
+ unsigned mainLen, numPairs, repIndex, repLen, i;
+ const Byte *data;
+
+ if (p->additionalOffset == 0)
+ mainLen = ReadMatchDistances(p, &numPairs);
+ else
+ {
+ mainLen = p->longestMatchLen;
+ numPairs = p->numPairs;
+ }
+
+ numAvail = p->numAvail;
+ p->backRes = MARK_LIT;
+ if (numAvail < 2)
+ return 1;
+ // if (mainLen < 2 && p->state == 0) return 1; // 18.06.notused
+ if (numAvail > LZMA_MATCH_LEN_MAX)
+ numAvail = LZMA_MATCH_LEN_MAX;
+ data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
+ repLen = repIndex = 0;
+
+ for (i = 0; i < LZMA_NUM_REPS; i++)
+ {
+ unsigned len;
+ const Byte *data2 = data - p->reps[i];
+ if (data[0] != data2[0] || data[1] != data2[1])
+ continue;
+ for (len = 2; len < numAvail && data[len] == data2[len]; len++)
+ {}
+ if (len >= p->numFastBytes)
+ {
+ p->backRes = (UInt32)i;
+ MOVE_POS(p, len - 1)
+ return len;
+ }
+ if (len > repLen)
+ {
+ repIndex = i;
+ repLen = len;
+ }
+ }
+
+ if (mainLen >= p->numFastBytes)
+ {
+ p->backRes = p->matches[(size_t)numPairs - 1] + LZMA_NUM_REPS;
+ MOVE_POS(p, mainLen - 1)
+ return mainLen;
+ }
+
+ mainDist = 0; /* for GCC */
+
+ if (mainLen >= 2)
+ {
+ mainDist = p->matches[(size_t)numPairs - 1];
+ while (numPairs > 2)
+ {
+ UInt32 dist2;
+ if (mainLen != p->matches[(size_t)numPairs - 4] + 1)
+ break;
+ dist2 = p->matches[(size_t)numPairs - 3];
+ if (!ChangePair(dist2, mainDist))
+ break;
+ numPairs -= 2;
+ mainLen--;
+ mainDist = dist2;
+ }
+ if (mainLen == 2 && mainDist >= 0x80)
+ mainLen = 1;
+ }
+
+ if (repLen >= 2)
+ if ( repLen + 1 >= mainLen
+ || (repLen + 2 >= mainLen && mainDist >= (1 << 9))
+ || (repLen + 3 >= mainLen && mainDist >= (1 << 15)))
+ {
+ p->backRes = (UInt32)repIndex;
+ MOVE_POS(p, repLen - 1)
+ return repLen;
+ }
+
+ if (mainLen < 2 || numAvail <= 2)
+ return 1;
+
+ {
+ unsigned len1 = ReadMatchDistances(p, &p->numPairs);
+ p->longestMatchLen = len1;
+
+ if (len1 >= 2)
+ {
+ UInt32 newDist = p->matches[(size_t)p->numPairs - 1];
+ if ( (len1 >= mainLen && newDist < mainDist)
+ || (len1 == mainLen + 1 && !ChangePair(mainDist, newDist))
+ || (len1 > mainLen + 1)
+ || (len1 + 1 >= mainLen && mainLen >= 3 && ChangePair(newDist, mainDist)))
+ return 1;
+ }
+ }
+
+ data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - 1;
+
+ for (i = 0; i < LZMA_NUM_REPS; i++)
+ {
+ unsigned len, limit;
+ const Byte *data2 = data - p->reps[i];
+ if (data[0] != data2[0] || data[1] != data2[1])
+ continue;
+ limit = mainLen - 1;
+ for (len = 2;; len++)
+ {
+ if (len >= limit)
+ return 1;
+ if (data[len] != data2[len])
+ break;
+ }
+ }
+
+ p->backRes = mainDist + LZMA_NUM_REPS;
+ if (mainLen != 2)
+ {
+ MOVE_POS(p, mainLen - 2)
+ }
+ return mainLen;
+}
+
+
+
+
+static void WriteEndMarker(CLzmaEnc *p, unsigned posState)
+{
+ UInt32 range;
+ range = p->rc.range;
+ {
+ UInt32 ttt, newBound;
+ CLzmaProb *prob = &p->isMatch[p->state][posState];
+ RC_BIT_PRE(&p->rc, prob)
+ RC_BIT_1(&p->rc, prob)
+ prob = &p->isRep[p->state];
+ RC_BIT_PRE(&p->rc, prob)
+ RC_BIT_0(&p->rc, prob)
+ }
+ p->state = kMatchNextStates[p->state];
+
+ p->rc.range = range;
+ LenEnc_Encode(&p->lenProbs, &p->rc, 0, posState);
+ range = p->rc.range;
+
+ {
+ // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[0], (1 << kNumPosSlotBits) - 1);
+ CLzmaProb *probs = p->posSlotEncoder[0];
+ unsigned m = 1;
+ do
+ {
+ UInt32 ttt, newBound;
+ RC_BIT_PRE(p, probs + m)
+ RC_BIT_1(&p->rc, probs + m)
+ m = (m << 1) + 1;
+ }
+ while (m < (1 << kNumPosSlotBits));
+ }
+ {
+ // RangeEnc_EncodeDirectBits(&p->rc, ((UInt32)1 << (30 - kNumAlignBits)) - 1, 30 - kNumAlignBits); UInt32 range = p->range;
+ unsigned numBits = 30 - kNumAlignBits;
+ do
+ {
+ range >>= 1;
+ p->rc.low += range;
+ RC_NORM(&p->rc)
+ }
+ while (--numBits);
+ }
+
+ {
+ // RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, kAlignMask);
+ CLzmaProb *probs = p->posAlignEncoder;
+ unsigned m = 1;
+ do
+ {
+ UInt32 ttt, newBound;
+ RC_BIT_PRE(p, probs + m)
+ RC_BIT_1(&p->rc, probs + m)
+ m = (m << 1) + 1;
+ }
+ while (m < kAlignTableSize);
+ }
+ p->rc.range = range;
+}
+
+
+static SRes CheckErrors(CLzmaEnc *p)
+{
+ if (p->result != SZ_OK)
+ return p->result;
+ if (p->rc.res != SZ_OK)
+ p->result = SZ_ERROR_WRITE;
+
+ #ifndef Z7_ST
+ if (
+ // p->mf_Failure ||
+ (p->mtMode &&
+ ( // p->matchFinderMt.failure_LZ_LZ ||
+ p->matchFinderMt.failure_LZ_BT))
+ )
+ {
+ p->result = MY_HRES_ERROR_INTERNAL_ERROR;
+ // printf("\nCheckErrors p->matchFinderMt.failureLZ\n");
+ }
+ #endif
+
+ if (MFB.result != SZ_OK)
+ p->result = SZ_ERROR_READ;
+
+ if (p->result != SZ_OK)
+ p->finished = True;
+ return p->result;
+}
+
+
+Z7_NO_INLINE static SRes Flush(CLzmaEnc *p, UInt32 nowPos)
+{
+ /* ReleaseMFStream(); */
+ p->finished = True;
+ if (p->writeEndMark)
+ WriteEndMarker(p, nowPos & p->pbMask);
+ RangeEnc_FlushData(&p->rc);
+ RangeEnc_FlushStream(&p->rc);
+ return CheckErrors(p);
+}
+
+
+Z7_NO_INLINE static void FillAlignPrices(CLzmaEnc *p)
+{
+ unsigned i;
+ const CProbPrice *ProbPrices = p->ProbPrices;
+ const CLzmaProb *probs = p->posAlignEncoder;
+ // p->alignPriceCount = 0;
+ for (i = 0; i < kAlignTableSize / 2; i++)
+ {
+ UInt32 price = 0;
+ unsigned sym = i;
+ unsigned m = 1;
+ unsigned bit;
+ UInt32 prob;
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[m], bit); m = (m << 1) + bit;
+ prob = probs[m];
+ p->alignPrices[i ] = price + GET_PRICEa_0(prob);
+ p->alignPrices[i + 8] = price + GET_PRICEa_1(prob);
+ // p->alignPrices[i] = RcTree_ReverseGetPrice(p->posAlignEncoder, kNumAlignBits, i, p->ProbPrices);
+ }
+}
+
+
+Z7_NO_INLINE static void FillDistancesPrices(CLzmaEnc *p)
+{
+ // int y; for (y = 0; y < 100; y++) {
+
+ UInt32 tempPrices[kNumFullDistances];
+ unsigned i, lps;
+
+ const CProbPrice *ProbPrices = p->ProbPrices;
+ p->matchPriceCount = 0;
+
+ for (i = kStartPosModelIndex / 2; i < kNumFullDistances / 2; i++)
+ {
+ unsigned posSlot = GetPosSlot1(i);
+ unsigned footerBits = (posSlot >> 1) - 1;
+ unsigned base = ((2 | (posSlot & 1)) << footerBits);
+ const CLzmaProb *probs = p->posEncoders + (size_t)base * 2;
+ // tempPrices[i] = RcTree_ReverseGetPrice(p->posEncoders + base, footerBits, i - base, p->ProbPrices);
+ UInt32 price = 0;
+ unsigned m = 1;
+ unsigned sym = i;
+ unsigned offset = (unsigned)1 << footerBits;
+ base += i;
+
+ if (footerBits)
+ do
+ {
+ unsigned bit = sym & 1;
+ sym >>= 1;
+ price += GET_PRICEa(probs[m], bit);
+ m = (m << 1) + bit;
+ }
+ while (--footerBits);
+
+ {
+ unsigned prob = probs[m];
+ tempPrices[base ] = price + GET_PRICEa_0(prob);
+ tempPrices[base + offset] = price + GET_PRICEa_1(prob);
+ }
+ }
+
+ for (lps = 0; lps < kNumLenToPosStates; lps++)
+ {
+ unsigned slot;
+ unsigned distTableSize2 = (p->distTableSize + 1) >> 1;
+ UInt32 *posSlotPrices = p->posSlotPrices[lps];
+ const CLzmaProb *probs = p->posSlotEncoder[lps];
+
+ for (slot = 0; slot < distTableSize2; slot++)
+ {
+ // posSlotPrices[slot] = RcTree_GetPrice(encoder, kNumPosSlotBits, slot, p->ProbPrices);
+ UInt32 price;
+ unsigned bit;
+ unsigned sym = slot + (1 << (kNumPosSlotBits - 1));
+ unsigned prob;
+ bit = sym & 1; sym >>= 1; price = GET_PRICEa(probs[sym], bit);
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
+ bit = sym & 1; sym >>= 1; price += GET_PRICEa(probs[sym], bit);
+ prob = probs[(size_t)slot + (1 << (kNumPosSlotBits - 1))];
+ posSlotPrices[(size_t)slot * 2 ] = price + GET_PRICEa_0(prob);
+ posSlotPrices[(size_t)slot * 2 + 1] = price + GET_PRICEa_1(prob);
+ }
+
+ {
+ UInt32 delta = ((UInt32)((kEndPosModelIndex / 2 - 1) - kNumAlignBits) << kNumBitPriceShiftBits);
+ for (slot = kEndPosModelIndex / 2; slot < distTableSize2; slot++)
+ {
+ posSlotPrices[(size_t)slot * 2 ] += delta;
+ posSlotPrices[(size_t)slot * 2 + 1] += delta;
+ delta += ((UInt32)1 << kNumBitPriceShiftBits);
+ }
+ }
+
+ {
+ UInt32 *dp = p->distancesPrices[lps];
+
+ dp[0] = posSlotPrices[0];
+ dp[1] = posSlotPrices[1];
+ dp[2] = posSlotPrices[2];
+ dp[3] = posSlotPrices[3];
+
+ for (i = 4; i < kNumFullDistances; i += 2)
+ {
+ UInt32 slotPrice = posSlotPrices[GetPosSlot1(i)];
+ dp[i ] = slotPrice + tempPrices[i];
+ dp[i + 1] = slotPrice + tempPrices[i + 1];
+ }
+ }
+ }
+ // }
+}
+
+
+
+static void LzmaEnc_Construct(CLzmaEnc *p)
+{
+ RangeEnc_Construct(&p->rc);
+ MatchFinder_Construct(&MFB);
+
+ #ifndef Z7_ST
+ p->matchFinderMt.MatchFinder = &MFB;
+ MatchFinderMt_Construct(&p->matchFinderMt);
+ #endif
+
+ {
+ CLzmaEncProps props;
+ LzmaEncProps_Init(&props);
+ LzmaEnc_SetProps((CLzmaEncHandle)(void *)p, &props);
+ }
+
+ #ifndef LZMA_LOG_BSR
+ LzmaEnc_FastPosInit(p->g_FastPos);
+ #endif
+
+ LzmaEnc_InitPriceTables(p->ProbPrices);
+ p->litProbs = NULL;
+ p->saveState.litProbs = NULL;
+}
+
+CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc)
+{
+ void *p;
+ p = ISzAlloc_Alloc(alloc, sizeof(CLzmaEnc));
+ if (p)
+ LzmaEnc_Construct((CLzmaEnc *)p);
+ return p;
+}
+
+static void LzmaEnc_FreeLits(CLzmaEnc *p, ISzAllocPtr alloc)
+{
+ ISzAlloc_Free(alloc, p->litProbs);
+ ISzAlloc_Free(alloc, p->saveState.litProbs);
+ p->litProbs = NULL;
+ p->saveState.litProbs = NULL;
+}
+
+static void LzmaEnc_Destruct(CLzmaEnc *p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ #ifndef Z7_ST
+ MatchFinderMt_Destruct(&p->matchFinderMt, allocBig);
+ #endif
+
+ MatchFinder_Free(&MFB, allocBig);
+ LzmaEnc_FreeLits(p, alloc);
+ RangeEnc_Free(&p->rc, alloc);
+}
+
+void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ // GET_CLzmaEnc_p
+ LzmaEnc_Destruct(p, alloc, allocBig);
+ ISzAlloc_Free(alloc, p);
+}
+
+
+Z7_NO_INLINE
+static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, UInt32 maxPackSize, UInt32 maxUnpackSize)
+{
+ UInt32 nowPos32, startPos32;
+ if (p->needInit)
+ {
+ #ifndef Z7_ST
+ if (p->mtMode)
+ {
+ RINOK(MatchFinderMt_InitMt(&p->matchFinderMt))
+ }
+ #endif
+ p->matchFinder.Init(p->matchFinderObj);
+ p->needInit = 0;
+ }
+
+ if (p->finished)
+ return p->result;
+ RINOK(CheckErrors(p))
+
+ nowPos32 = (UInt32)p->nowPos64;
+ startPos32 = nowPos32;
+
+ if (p->nowPos64 == 0)
+ {
+ unsigned numPairs;
+ Byte curByte;
+ if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
+ return Flush(p, nowPos32);
+ ReadMatchDistances(p, &numPairs);
+ RangeEnc_EncodeBit_0(&p->rc, &p->isMatch[kState_Start][0]);
+ // p->state = kLiteralNextStates[p->state];
+ curByte = *(p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset);
+ LitEnc_Encode(&p->rc, p->litProbs, curByte);
+ p->additionalOffset--;
+ nowPos32++;
+ }
+
+ if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) != 0)
+
+ for (;;)
+ {
+ UInt32 dist;
+ unsigned len, posState;
+ UInt32 range, ttt, newBound;
+ CLzmaProb *probs;
+
+ if (p->fastMode)
+ len = GetOptimumFast(p);
+ else
+ {
+ unsigned oci = p->optCur;
+ if (p->optEnd == oci)
+ len = GetOptimum(p, nowPos32);
+ else
+ {
+ const COptimal *opt = &p->opt[oci];
+ len = opt->len;
+ p->backRes = opt->dist;
+ p->optCur = oci + 1;
+ }
+ }
+
+ posState = (unsigned)nowPos32 & p->pbMask;
+ range = p->rc.range;
+ probs = &p->isMatch[p->state][posState];
+
+ RC_BIT_PRE(&p->rc, probs)
+
+ dist = p->backRes;
+
+ #ifdef SHOW_STAT2
+ printf("\n pos = %6X, len = %3u pos = %6u", nowPos32, len, dist);
+ #endif
+
+ if (dist == MARK_LIT)
+ {
+ Byte curByte;
+ const Byte *data;
+ unsigned state;
+
+ RC_BIT_0(&p->rc, probs)
+ p->rc.range = range;
+ data = p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
+ probs = LIT_PROBS(nowPos32, *(data - 1));
+ curByte = *data;
+ state = p->state;
+ p->state = kLiteralNextStates[state];
+ if (IsLitState(state))
+ LitEnc_Encode(&p->rc, probs, curByte);
+ else
+ LitEnc_EncodeMatched(&p->rc, probs, curByte, *(data - p->reps[0]));
+ }
+ else
+ {
+ RC_BIT_1(&p->rc, probs)
+ probs = &p->isRep[p->state];
+ RC_BIT_PRE(&p->rc, probs)
+
+ if (dist < LZMA_NUM_REPS)
+ {
+ RC_BIT_1(&p->rc, probs)
+ probs = &p->isRepG0[p->state];
+ RC_BIT_PRE(&p->rc, probs)
+ if (dist == 0)
+ {
+ RC_BIT_0(&p->rc, probs)
+ probs = &p->isRep0Long[p->state][posState];
+ RC_BIT_PRE(&p->rc, probs)
+ if (len != 1)
+ {
+ RC_BIT_1_BASE(&p->rc, probs)
+ }
+ else
+ {
+ RC_BIT_0_BASE(&p->rc, probs)
+ p->state = kShortRepNextStates[p->state];
+ }
+ }
+ else
+ {
+ RC_BIT_1(&p->rc, probs)
+ probs = &p->isRepG1[p->state];
+ RC_BIT_PRE(&p->rc, probs)
+ if (dist == 1)
+ {
+ RC_BIT_0_BASE(&p->rc, probs)
+ dist = p->reps[1];
+ }
+ else
+ {
+ RC_BIT_1(&p->rc, probs)
+ probs = &p->isRepG2[p->state];
+ RC_BIT_PRE(&p->rc, probs)
+ if (dist == 2)
+ {
+ RC_BIT_0_BASE(&p->rc, probs)
+ dist = p->reps[2];
+ }
+ else
+ {
+ RC_BIT_1_BASE(&p->rc, probs)
+ dist = p->reps[3];
+ p->reps[3] = p->reps[2];
+ }
+ p->reps[2] = p->reps[1];
+ }
+ p->reps[1] = p->reps[0];
+ p->reps[0] = dist;
+ }
+
+ RC_NORM(&p->rc)
+
+ p->rc.range = range;
+
+ if (len != 1)
+ {
+ LenEnc_Encode(&p->repLenProbs, &p->rc, len - LZMA_MATCH_LEN_MIN, posState);
+ --p->repLenEncCounter;
+ p->state = kRepNextStates[p->state];
+ }
+ }
+ else
+ {
+ unsigned posSlot;
+ RC_BIT_0(&p->rc, probs)
+ p->rc.range = range;
+ p->state = kMatchNextStates[p->state];
+
+ LenEnc_Encode(&p->lenProbs, &p->rc, len - LZMA_MATCH_LEN_MIN, posState);
+ // --p->lenEnc.counter;
+
+ dist -= LZMA_NUM_REPS;
+ p->reps[3] = p->reps[2];
+ p->reps[2] = p->reps[1];
+ p->reps[1] = p->reps[0];
+ p->reps[0] = dist + 1;
+
+ p->matchPriceCount++;
+ GetPosSlot(dist, posSlot)
+ // RcTree_Encode_PosSlot(&p->rc, p->posSlotEncoder[GetLenToPosState(len)], posSlot);
+ {
+ UInt32 sym = (UInt32)posSlot + (1 << kNumPosSlotBits);
+ range = p->rc.range;
+ probs = p->posSlotEncoder[GetLenToPosState(len)];
+ do
+ {
+ CLzmaProb *prob = probs + (sym >> kNumPosSlotBits);
+ UInt32 bit = (sym >> (kNumPosSlotBits - 1)) & 1;
+ sym <<= 1;
+ RC_BIT(&p->rc, prob, bit)
+ }
+ while (sym < (1 << kNumPosSlotBits * 2));
+ p->rc.range = range;
+ }
+
+ if (dist >= kStartPosModelIndex)
+ {
+ unsigned footerBits = ((posSlot >> 1) - 1);
+
+ if (dist < kNumFullDistances)
+ {
+ unsigned base = ((2 | (posSlot & 1)) << footerBits);
+ RcTree_ReverseEncode(&p->rc, p->posEncoders + base, footerBits, (unsigned)(dist /* - base */));
+ }
+ else
+ {
+ UInt32 pos2 = (dist | 0xF) << (32 - footerBits);
+ range = p->rc.range;
+ // RangeEnc_EncodeDirectBits(&p->rc, posReduced >> kNumAlignBits, footerBits - kNumAlignBits);
+ /*
+ do
+ {
+ range >>= 1;
+ p->rc.low += range & (0 - ((dist >> --footerBits) & 1));
+ RC_NORM(&p->rc)
+ }
+ while (footerBits > kNumAlignBits);
+ */
+ do
+ {
+ range >>= 1;
+ p->rc.low += range & (0 - (pos2 >> 31));
+ pos2 += pos2;
+ RC_NORM(&p->rc)
+ }
+ while (pos2 != 0xF0000000);
+
+
+ // RcTree_ReverseEncode(&p->rc, p->posAlignEncoder, kNumAlignBits, posReduced & kAlignMask);
+
+ {
+ unsigned m = 1;
+ unsigned bit;
+ bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit) m = (m << 1) + bit;
+ bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit) m = (m << 1) + bit;
+ bit = dist & 1; dist >>= 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit) m = (m << 1) + bit;
+ bit = dist & 1; RC_BIT(&p->rc, p->posAlignEncoder + m, bit)
+ p->rc.range = range;
+ // p->alignPriceCount++;
+ }
+ }
+ }
+ }
+ }
+
+ nowPos32 += (UInt32)len;
+ p->additionalOffset -= len;
+
+ if (p->additionalOffset == 0)
+ {
+ UInt32 processed;
+
+ if (!p->fastMode)
+ {
+ /*
+ if (p->alignPriceCount >= 16) // kAlignTableSize
+ FillAlignPrices(p);
+ if (p->matchPriceCount >= 128)
+ FillDistancesPrices(p);
+ if (p->lenEnc.counter <= 0)
+ LenPriceEnc_UpdateTables(&p->lenEnc, 1 << p->pb, &p->lenProbs, p->ProbPrices);
+ */
+ if (p->matchPriceCount >= 64)
+ {
+ FillAlignPrices(p);
+ // { int y; for (y = 0; y < 100; y++) {
+ FillDistancesPrices(p);
+ // }}
+ LenPriceEnc_UpdateTables(&p->lenEnc, (unsigned)1 << p->pb, &p->lenProbs, p->ProbPrices);
+ }
+ if (p->repLenEncCounter <= 0)
+ {
+ p->repLenEncCounter = REP_LEN_COUNT;
+ LenPriceEnc_UpdateTables(&p->repLenEnc, (unsigned)1 << p->pb, &p->repLenProbs, p->ProbPrices);
+ }
+ }
+
+ if (p->matchFinder.GetNumAvailableBytes(p->matchFinderObj) == 0)
+ break;
+ processed = nowPos32 - startPos32;
+
+ if (maxPackSize)
+ {
+ if (processed + kNumOpts + 300 >= maxUnpackSize
+ || RangeEnc_GetProcessed_sizet(&p->rc) + kPackReserve >= maxPackSize)
+ break;
+ }
+ else if (processed >= (1 << 17))
+ {
+ p->nowPos64 += nowPos32 - startPos32;
+ return CheckErrors(p);
+ }
+ }
+ }
+
+ p->nowPos64 += nowPos32 - startPos32;
+ return Flush(p, nowPos32);
+}
+
+
+
+#define kBigHashDicLimit ((UInt32)1 << 24)
+
+static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ UInt32 beforeSize = kNumOpts;
+ UInt32 dictSize;
+
+ if (!RangeEnc_Alloc(&p->rc, alloc))
+ return SZ_ERROR_MEM;
+
+ #ifndef Z7_ST
+ p->mtMode = (p->multiThread && !p->fastMode && (MFB.btMode != 0));
+ #endif
+
+ {
+ unsigned lclp = p->lc + p->lp;
+ if (!p->litProbs || !p->saveState.litProbs || p->lclp != lclp)
+ {
+ LzmaEnc_FreeLits(p, alloc);
+ p->litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
+ p->saveState.litProbs = (CLzmaProb *)ISzAlloc_Alloc(alloc, ((UInt32)0x300 << lclp) * sizeof(CLzmaProb));
+ if (!p->litProbs || !p->saveState.litProbs)
+ {
+ LzmaEnc_FreeLits(p, alloc);
+ return SZ_ERROR_MEM;
+ }
+ p->lclp = lclp;
+ }
+ }
+
+ MFB.bigHash = (Byte)(p->dictSize > kBigHashDicLimit ? 1 : 0);
+
+
+ dictSize = p->dictSize;
+ if (dictSize == ((UInt32)2 << 30) ||
+ dictSize == ((UInt32)3 << 30))
+ {
+ /* 21.03 : here we reduce the dictionary for 2 reasons:
+ 1) we don't want 32-bit back_distance matches in decoder for 2 GB dictionary.
+ 2) we want to elimate useless last MatchFinder_Normalize3() for corner cases,
+ where data size is aligned for 1 GB: 5/6/8 GB.
+ That reducing must be >= 1 for such corner cases. */
+ dictSize -= 1;
+ }
+
+ if (beforeSize + dictSize < keepWindowSize)
+ beforeSize = keepWindowSize - dictSize;
+
+ /* in worst case we can look ahead for
+ max(LZMA_MATCH_LEN_MAX, numFastBytes + 1 + numFastBytes) bytes.
+ we send larger value for (keepAfter) to MantchFinder_Create():
+ (numFastBytes + LZMA_MATCH_LEN_MAX + 1)
+ */
+
+ #ifndef Z7_ST
+ if (p->mtMode)
+ {
+ RINOK(MatchFinderMt_Create(&p->matchFinderMt, dictSize, beforeSize,
+ p->numFastBytes, LZMA_MATCH_LEN_MAX + 1 /* 18.04 */
+ , allocBig))
+ p->matchFinderObj = &p->matchFinderMt;
+ MFB.bigHash = (Byte)(MFB.hashMask >= 0xFFFFFF ? 1 : 0);
+ MatchFinderMt_CreateVTable(&p->matchFinderMt, &p->matchFinder);
+ }
+ else
+ #endif
+ {
+ if (!MatchFinder_Create(&MFB, dictSize, beforeSize,
+ p->numFastBytes, LZMA_MATCH_LEN_MAX + 1 /* 21.03 */
+ , allocBig))
+ return SZ_ERROR_MEM;
+ p->matchFinderObj = &MFB;
+ MatchFinder_CreateVTable(&MFB, &p->matchFinder);
+ }
+
+ return SZ_OK;
+}
+
+static void LzmaEnc_Init(CLzmaEnc *p)
+{
+ unsigned i;
+ p->state = 0;
+ p->reps[0] =
+ p->reps[1] =
+ p->reps[2] =
+ p->reps[3] = 1;
+
+ RangeEnc_Init(&p->rc);
+
+ for (i = 0; i < (1 << kNumAlignBits); i++)
+ p->posAlignEncoder[i] = kProbInitValue;
+
+ for (i = 0; i < kNumStates; i++)
+ {
+ unsigned j;
+ for (j = 0; j < LZMA_NUM_PB_STATES_MAX; j++)
+ {
+ p->isMatch[i][j] = kProbInitValue;
+ p->isRep0Long[i][j] = kProbInitValue;
+ }
+ p->isRep[i] = kProbInitValue;
+ p->isRepG0[i] = kProbInitValue;
+ p->isRepG1[i] = kProbInitValue;
+ p->isRepG2[i] = kProbInitValue;
+ }
+
+ {
+ for (i = 0; i < kNumLenToPosStates; i++)
+ {
+ CLzmaProb *probs = p->posSlotEncoder[i];
+ unsigned j;
+ for (j = 0; j < (1 << kNumPosSlotBits); j++)
+ probs[j] = kProbInitValue;
+ }
+ }
+ {
+ for (i = 0; i < kNumFullDistances; i++)
+ p->posEncoders[i] = kProbInitValue;
+ }
+
+ {
+ UInt32 num = (UInt32)0x300 << (p->lp + p->lc);
+ UInt32 k;
+ CLzmaProb *probs = p->litProbs;
+ for (k = 0; k < num; k++)
+ probs[k] = kProbInitValue;
+ }
+
+
+ LenEnc_Init(&p->lenProbs);
+ LenEnc_Init(&p->repLenProbs);
+
+ p->optEnd = 0;
+ p->optCur = 0;
+
+ {
+ for (i = 0; i < kNumOpts; i++)
+ p->opt[i].price = kInfinityPrice;
+ }
+
+ p->additionalOffset = 0;
+
+ p->pbMask = ((unsigned)1 << p->pb) - 1;
+ p->lpMask = ((UInt32)0x100 << p->lp) - ((unsigned)0x100 >> p->lc);
+
+ // p->mf_Failure = False;
+}
+
+
+static void LzmaEnc_InitPrices(CLzmaEnc *p)
+{
+ if (!p->fastMode)
+ {
+ FillDistancesPrices(p);
+ FillAlignPrices(p);
+ }
+
+ p->lenEnc.tableSize =
+ p->repLenEnc.tableSize =
+ p->numFastBytes + 1 - LZMA_MATCH_LEN_MIN;
+
+ p->repLenEncCounter = REP_LEN_COUNT;
+
+ LenPriceEnc_UpdateTables(&p->lenEnc, (unsigned)1 << p->pb, &p->lenProbs, p->ProbPrices);
+ LenPriceEnc_UpdateTables(&p->repLenEnc, (unsigned)1 << p->pb, &p->repLenProbs, p->ProbPrices);
+}
+
+static SRes LzmaEnc_AllocAndInit(CLzmaEnc *p, UInt32 keepWindowSize, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ unsigned i;
+ for (i = kEndPosModelIndex / 2; i < kDicLogSizeMax; i++)
+ if (p->dictSize <= ((UInt32)1 << i))
+ break;
+ p->distTableSize = i * 2;
+
+ p->finished = False;
+ p->result = SZ_OK;
+ p->nowPos64 = 0;
+ p->needInit = 1;
+ RINOK(LzmaEnc_Alloc(p, keepWindowSize, alloc, allocBig))
+ LzmaEnc_Init(p);
+ LzmaEnc_InitPrices(p);
+ return SZ_OK;
+}
+
+static SRes LzmaEnc_Prepare(CLzmaEncHandle p,
+ ISeqOutStreamPtr outStream,
+ ISeqInStreamPtr inStream,
+ ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ // GET_CLzmaEnc_p
+ MatchFinder_SET_STREAM(&MFB, inStream)
+ p->rc.outStream = outStream;
+ return LzmaEnc_AllocAndInit(p, 0, alloc, allocBig);
+}
+
+SRes LzmaEnc_PrepareForLzma2(CLzmaEncHandle p,
+ ISeqInStreamPtr inStream, UInt32 keepWindowSize,
+ ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ // GET_CLzmaEnc_p
+ MatchFinder_SET_STREAM(&MFB, inStream)
+ return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
+}
+
+SRes LzmaEnc_MemPrepare(CLzmaEncHandle p,
+ const Byte *src, SizeT srcLen,
+ UInt32 keepWindowSize,
+ ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ // GET_CLzmaEnc_p
+ MatchFinder_SET_DIRECT_INPUT_BUF(&MFB, src, srcLen)
+ LzmaEnc_SetDataSize(p, srcLen);
+ return LzmaEnc_AllocAndInit(p, keepWindowSize, alloc, allocBig);
+}
+
+void LzmaEnc_Finish(CLzmaEncHandle p)
+{
+ #ifndef Z7_ST
+ // GET_CLzmaEnc_p
+ if (p->mtMode)
+ MatchFinderMt_ReleaseStream(&p->matchFinderMt);
+ #else
+ UNUSED_VAR(p)
+ #endif
+}
+
+
+typedef struct
+{
+ ISeqOutStream vt;
+ Byte *data;
+ size_t rem;
+ BoolInt overflow;
+} CLzmaEnc_SeqOutStreamBuf;
+
+static size_t SeqOutStreamBuf_Write(ISeqOutStreamPtr pp, const void *data, size_t size)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CLzmaEnc_SeqOutStreamBuf)
+ if (p->rem < size)
+ {
+ size = p->rem;
+ p->overflow = True;
+ }
+ if (size != 0)
+ {
+ memcpy(p->data, data, size);
+ p->rem -= size;
+ p->data += size;
+ }
+ return size;
+}
+
+
+/*
+UInt32 LzmaEnc_GetNumAvailableBytes(CLzmaEncHandle p)
+{
+ GET_const_CLzmaEnc_p
+ return p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);
+}
+*/
+
+const Byte *LzmaEnc_GetCurBuf(CLzmaEncHandle p)
+{
+ // GET_const_CLzmaEnc_p
+ return p->matchFinder.GetPointerToCurrentPos(p->matchFinderObj) - p->additionalOffset;
+}
+
+
+// (desiredPackSize == 0) is not allowed
+SRes LzmaEnc_CodeOneMemBlock(CLzmaEncHandle p, BoolInt reInit,
+ Byte *dest, size_t *destLen, UInt32 desiredPackSize, UInt32 *unpackSize)
+{
+ // GET_CLzmaEnc_p
+ UInt64 nowPos64;
+ SRes res;
+ CLzmaEnc_SeqOutStreamBuf outStream;
+
+ outStream.vt.Write = SeqOutStreamBuf_Write;
+ outStream.data = dest;
+ outStream.rem = *destLen;
+ outStream.overflow = False;
+
+ p->writeEndMark = False;
+ p->finished = False;
+ p->result = SZ_OK;
+
+ if (reInit)
+ LzmaEnc_Init(p);
+ LzmaEnc_InitPrices(p);
+ RangeEnc_Init(&p->rc);
+ p->rc.outStream = &outStream.vt;
+ nowPos64 = p->nowPos64;
+
+ res = LzmaEnc_CodeOneBlock(p, desiredPackSize, *unpackSize);
+
+ *unpackSize = (UInt32)(p->nowPos64 - nowPos64);
+ *destLen -= outStream.rem;
+ if (outStream.overflow)
+ return SZ_ERROR_OUTPUT_EOF;
+
+ return res;
+}
+
+
+Z7_NO_INLINE
+static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgressPtr progress)
+{
+ SRes res = SZ_OK;
+
+ #ifndef Z7_ST
+ Byte allocaDummy[0x300];
+ allocaDummy[0] = 0;
+ allocaDummy[1] = allocaDummy[0];
+ #endif
+
+ for (;;)
+ {
+ res = LzmaEnc_CodeOneBlock(p, 0, 0);
+ if (res != SZ_OK || p->finished)
+ break;
+ if (progress)
+ {
+ res = ICompressProgress_Progress(progress, p->nowPos64, RangeEnc_GetProcessed(&p->rc));
+ if (res != SZ_OK)
+ {
+ res = SZ_ERROR_PROGRESS;
+ break;
+ }
+ }
+ }
+
+ LzmaEnc_Finish((CLzmaEncHandle)(void *)p);
+
+ /*
+ if (res == SZ_OK && !Inline_MatchFinder_IsFinishedOK(&MFB))
+ res = SZ_ERROR_FAIL;
+ }
+ */
+
+ return res;
+}
+
+
+SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress,
+ ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ // GET_CLzmaEnc_p
+ RINOK(LzmaEnc_Prepare(p, outStream, inStream, alloc, allocBig))
+ return LzmaEnc_Encode2(p, progress);
+}
+
+
+SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *props, SizeT *size)
+{
+ if (*size < LZMA_PROPS_SIZE)
+ return SZ_ERROR_PARAM;
+ *size = LZMA_PROPS_SIZE;
+ {
+ // GET_CLzmaEnc_p
+ const UInt32 dictSize = p->dictSize;
+ UInt32 v;
+ props[0] = (Byte)((p->pb * 5 + p->lp) * 9 + p->lc);
+
+ // we write aligned dictionary value to properties for lzma decoder
+ if (dictSize >= ((UInt32)1 << 21))
+ {
+ const UInt32 kDictMask = ((UInt32)1 << 20) - 1;
+ v = (dictSize + kDictMask) & ~kDictMask;
+ if (v < dictSize)
+ v = dictSize;
+ }
+ else
+ {
+ unsigned i = 11 * 2;
+ do
+ {
+ v = (UInt32)(2 + (i & 1)) << (i >> 1);
+ i++;
+ }
+ while (v < dictSize);
+ }
+
+ SetUi32(props + 1, v)
+ return SZ_OK;
+ }
+}
+
+
+unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p)
+{
+ // GET_CLzmaEnc_p
+ return (unsigned)p->writeEndMark;
+}
+
+
+SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+ int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ SRes res;
+ // GET_CLzmaEnc_p
+
+ CLzmaEnc_SeqOutStreamBuf outStream;
+
+ outStream.vt.Write = SeqOutStreamBuf_Write;
+ outStream.data = dest;
+ outStream.rem = *destLen;
+ outStream.overflow = False;
+
+ p->writeEndMark = writeEndMark;
+ p->rc.outStream = &outStream.vt;
+
+ res = LzmaEnc_MemPrepare(p, src, srcLen, 0, alloc, allocBig);
+
+ if (res == SZ_OK)
+ {
+ res = LzmaEnc_Encode2(p, progress);
+ if (res == SZ_OK && p->nowPos64 != srcLen)
+ res = SZ_ERROR_FAIL;
+ }
+
+ *destLen -= (SizeT)outStream.rem;
+ if (outStream.overflow)
+ return SZ_ERROR_OUTPUT_EOF;
+ return res;
+}
+
+
+SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+ const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
+ ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ CLzmaEncHandle p = LzmaEnc_Create(alloc);
+ SRes res;
+ if (!p)
+ return SZ_ERROR_MEM;
+
+ res = LzmaEnc_SetProps(p, props);
+ if (res == SZ_OK)
+ {
+ res = LzmaEnc_WriteProperties(p, propsEncoded, propsSize);
+ if (res == SZ_OK)
+ res = LzmaEnc_MemEncode(p, dest, destLen, src, srcLen,
+ writeEndMark, progress, alloc, allocBig);
+ }
+
+ LzmaEnc_Destroy(p, alloc, allocBig);
+ return res;
+}
+
+
+/*
+#ifndef Z7_ST
+void LzmaEnc_GetLzThreads(CLzmaEncHandle p, HANDLE lz_threads[2])
+{
+ GET_const_CLzmaEnc_p
+ lz_threads[0] = p->matchFinderMt.hashSync.thread;
+ lz_threads[1] = p->matchFinderMt.btSync.thread;
+}
+#endif
+*/
diff --git a/C/LzmaEnc.h b/C/LzmaEnc.h
index c9938f0..9f8039a 100644
--- a/C/LzmaEnc.h
+++ b/C/LzmaEnc.h
@@ -1,76 +1,83 @@
-/* LzmaEnc.h -- LZMA Encoder
-2017-07-27 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA_ENC_H
-#define __LZMA_ENC_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define LZMA_PROPS_SIZE 5
-
-typedef struct _CLzmaEncProps
-{
- int level; /* 0 <= level <= 9 */
- UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
- (1 << 12) <= dictSize <= (3 << 29) for 64-bit version
- default = (1 << 24) */
- int lc; /* 0 <= lc <= 8, default = 3 */
- int lp; /* 0 <= lp <= 4, default = 0 */
- int pb; /* 0 <= pb <= 4, default = 2 */
- int algo; /* 0 - fast, 1 - normal, default = 1 */
- int fb; /* 5 <= fb <= 273, default = 32 */
- int btMode; /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
- int numHashBytes; /* 2, 3 or 4, default = 4 */
- UInt32 mc; /* 1 <= mc <= (1 << 30), default = 32 */
- unsigned writeEndMark; /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
- int numThreads; /* 1 or 2, default = 2 */
-
- UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
- Encoder uses this value to reduce dictionary size */
-} CLzmaEncProps;
-
-void LzmaEncProps_Init(CLzmaEncProps *p);
-void LzmaEncProps_Normalize(CLzmaEncProps *p);
-UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
-
-
-/* ---------- CLzmaEncHandle Interface ---------- */
-
-/* LzmaEnc* functions can return the following exit codes:
-SRes:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_PARAM - Incorrect paramater in props
- SZ_ERROR_WRITE - ISeqOutStream write callback error
- SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
- SZ_ERROR_PROGRESS - some break from progress callback
- SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
-*/
-
-typedef void * CLzmaEncHandle;
-
-CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc);
-void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-
-SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
-void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize);
-SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
-unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p);
-
-SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,
- ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
- int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-
-
-/* ---------- One Call Interface ---------- */
-
-SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
- const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
- ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
-
-EXTERN_C_END
-
-#endif
+/* LzmaEnc.h -- LZMA Encoder
+2023-04-13 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA_ENC_H
+#define ZIP7_INC_LZMA_ENC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define LZMA_PROPS_SIZE 5
+
+typedef struct
+{
+ int level; /* 0 <= level <= 9 */
+ UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
+ (1 << 12) <= dictSize <= (3 << 29) for 64-bit version
+ default = (1 << 24) */
+ int lc; /* 0 <= lc <= 8, default = 3 */
+ int lp; /* 0 <= lp <= 4, default = 0 */
+ int pb; /* 0 <= pb <= 4, default = 2 */
+ int algo; /* 0 - fast, 1 - normal, default = 1 */
+ int fb; /* 5 <= fb <= 273, default = 32 */
+ int btMode; /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
+ int numHashBytes; /* 2, 3 or 4, default = 4 */
+ unsigned numHashOutBits; /* default = ? */
+ UInt32 mc; /* 1 <= mc <= (1 << 30), default = 32 */
+ unsigned writeEndMark; /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
+ int numThreads; /* 1 or 2, default = 2 */
+
+ // int _pad;
+
+ UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
+ Encoder uses this value to reduce dictionary size */
+
+ UInt64 affinity;
+} CLzmaEncProps;
+
+void LzmaEncProps_Init(CLzmaEncProps *p);
+void LzmaEncProps_Normalize(CLzmaEncProps *p);
+UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
+
+
+/* ---------- CLzmaEncHandle Interface ---------- */
+
+/* LzmaEnc* functions can return the following exit codes:
+SRes:
+ SZ_OK - OK
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_PARAM - Incorrect paramater in props
+ SZ_ERROR_WRITE - ISeqOutStream write callback error
+ SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
+ SZ_ERROR_PROGRESS - some break from progress callback
+ SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
+*/
+
+typedef struct CLzmaEnc CLzmaEnc;
+typedef CLzmaEnc * CLzmaEncHandle;
+// Z7_DECLARE_HANDLE(CLzmaEncHandle)
+
+CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc);
+void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+
+SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
+void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize);
+SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
+unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p);
+
+SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
+ ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+ int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+
+
+/* ---------- One Call Interface ---------- */
+
+SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+ const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
+ ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/LzmaLib.c b/C/LzmaLib.c
index c10cf1a..785e884 100644
--- a/C/LzmaLib.c
+++ b/C/LzmaLib.c
@@ -1,40 +1,42 @@
-/* LzmaLib.c -- LZMA library wrapper
-2015-06-13 : Igor Pavlov : Public domain */
-
-#include "Alloc.h"
-#include "LzmaDec.h"
-#include "LzmaEnc.h"
-#include "LzmaLib.h"
-
-MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
- unsigned char *outProps, size_t *outPropsSize,
- int level, /* 0 <= level <= 9, default = 5 */
- unsigned dictSize, /* use (1 << N) or (3 << N). 4 KB < dictSize <= 128 MB */
- int lc, /* 0 <= lc <= 8, default = 3 */
- int lp, /* 0 <= lp <= 4, default = 0 */
- int pb, /* 0 <= pb <= 4, default = 2 */
- int fb, /* 5 <= fb <= 273, default = 32 */
- int numThreads /* 1 or 2, default = 2 */
-)
-{
- CLzmaEncProps props;
- LzmaEncProps_Init(&props);
- props.level = level;
- props.dictSize = dictSize;
- props.lc = lc;
- props.lp = lp;
- props.pb = pb;
- props.fb = fb;
- props.numThreads = numThreads;
-
- return LzmaEncode(dest, destLen, src, srcLen, &props, outProps, outPropsSize, 0,
- NULL, &g_Alloc, &g_Alloc);
-}
-
-
-MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
- const unsigned char *props, size_t propsSize)
-{
- ELzmaStatus status;
- return LzmaDecode(dest, destLen, src, srcLen, props, (unsigned)propsSize, LZMA_FINISH_ANY, &status, &g_Alloc);
-}
+/* LzmaLib.c -- LZMA library wrapper
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Alloc.h"
+#include "LzmaDec.h"
+#include "LzmaEnc.h"
+#include "LzmaLib.h"
+
+Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
+ unsigned char *outProps, size_t *outPropsSize,
+ int level, /* 0 <= level <= 9, default = 5 */
+ unsigned dictSize, /* use (1 << N) or (3 << N). 4 KB < dictSize <= 128 MB */
+ int lc, /* 0 <= lc <= 8, default = 3 */
+ int lp, /* 0 <= lp <= 4, default = 0 */
+ int pb, /* 0 <= pb <= 4, default = 2 */
+ int fb, /* 5 <= fb <= 273, default = 32 */
+ int numThreads /* 1 or 2, default = 2 */
+)
+{
+ CLzmaEncProps props;
+ LzmaEncProps_Init(&props);
+ props.level = level;
+ props.dictSize = dictSize;
+ props.lc = lc;
+ props.lp = lp;
+ props.pb = pb;
+ props.fb = fb;
+ props.numThreads = numThreads;
+
+ return LzmaEncode(dest, destLen, src, srcLen, &props, outProps, outPropsSize, 0,
+ NULL, &g_Alloc, &g_Alloc);
+}
+
+
+Z7_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
+ const unsigned char *props, size_t propsSize)
+{
+ ELzmaStatus status;
+ return LzmaDecode(dest, destLen, src, srcLen, props, (unsigned)propsSize, LZMA_FINISH_ANY, &status, &g_Alloc);
+}
diff --git a/C/LzmaLib.h b/C/LzmaLib.h
index 5c35e53..d7c0724 100644
--- a/C/LzmaLib.h
+++ b/C/LzmaLib.h
@@ -1,131 +1,138 @@
-/* LzmaLib.h -- LZMA library interface
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __LZMA_LIB_H
-#define __LZMA_LIB_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define MY_STDAPI int MY_STD_CALL
-
-#define LZMA_PROPS_SIZE 5
-
-/*
-RAM requirements for LZMA:
- for compression: (dictSize * 11.5 + 6 MB) + state_size
- for decompression: dictSize + state_size
- state_size = (4 + (1.5 << (lc + lp))) KB
- by default (lc=3, lp=0), state_size = 16 KB.
-
-LZMA properties (5 bytes) format
- Offset Size Description
- 0 1 lc, lp and pb in encoded form.
- 1 4 dictSize (little endian).
-*/
-
-/*
-LzmaCompress
-------------
-
-outPropsSize -
- In: the pointer to the size of outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
- Out: the pointer to the size of written properties in outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
-
- LZMA Encoder will use defult values for any parameter, if it is
- -1 for any from: level, loc, lp, pb, fb, numThreads
- 0 for dictSize
-
-level - compression level: 0 <= level <= 9;
-
- level dictSize algo fb
- 0: 16 KB 0 32
- 1: 64 KB 0 32
- 2: 256 KB 0 32
- 3: 1 MB 0 32
- 4: 4 MB 0 32
- 5: 16 MB 1 32
- 6: 32 MB 1 32
- 7+: 64 MB 1 64
-
- The default value for "level" is 5.
-
- algo = 0 means fast method
- algo = 1 means normal method
-
-dictSize - The dictionary size in bytes. The maximum value is
- 128 MB = (1 << 27) bytes for 32-bit version
- 1 GB = (1 << 30) bytes for 64-bit version
- The default value is 16 MB = (1 << 24) bytes.
- It's recommended to use the dictionary that is larger than 4 KB and
- that can be calculated as (1 << N) or (3 << N) sizes.
-
-lc - The number of literal context bits (high bits of previous literal).
- It can be in the range from 0 to 8. The default value is 3.
- Sometimes lc=4 gives the gain for big files.
-
-lp - The number of literal pos bits (low bits of current position for literals).
- It can be in the range from 0 to 4. The default value is 0.
- The lp switch is intended for periodical data when the period is equal to 2^lp.
- For example, for 32-bit (4 bytes) periodical data you can use lp=2. Often it's
- better to set lc=0, if you change lp switch.
-
-pb - The number of pos bits (low bits of current position).
- It can be in the range from 0 to 4. The default value is 2.
- The pb switch is intended for periodical data when the period is equal 2^pb.
-
-fb - Word size (the number of fast bytes).
- It can be in the range from 5 to 273. The default value is 32.
- Usually, a big number gives a little bit better compression ratio and
- slower compression process.
-
-numThreads - The number of thereads. 1 or 2. The default value is 2.
- Fast mode (algo = 0) can use only 1 thread.
-
-Out:
- destLen - processed output size
-Returns:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_PARAM - Incorrect paramater
- SZ_ERROR_OUTPUT_EOF - output buffer overflow
- SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
-*/
-
-MY_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
- unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */
- int level, /* 0 <= level <= 9, default = 5 */
- unsigned dictSize, /* default = (1 << 24) */
- int lc, /* 0 <= lc <= 8, default = 3 */
- int lp, /* 0 <= lp <= 4, default = 0 */
- int pb, /* 0 <= pb <= 4, default = 2 */
- int fb, /* 5 <= fb <= 273, default = 32 */
- int numThreads /* 1 or 2, default = 2 */
- );
-
-/*
-LzmaUncompress
---------------
-In:
- dest - output data
- destLen - output data size
- src - input data
- srcLen - input data size
-Out:
- destLen - processed output size
- srcLen - processed input size
-Returns:
- SZ_OK - OK
- SZ_ERROR_DATA - Data error
- SZ_ERROR_MEM - Memory allocation arror
- SZ_ERROR_UNSUPPORTED - Unsupported properties
- SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer (src)
-*/
-
-MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
- const unsigned char *props, size_t propsSize);
-
-EXTERN_C_END
-
-#endif
+/* LzmaLib.h -- LZMA library interface
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA_LIB_H
+#define ZIP7_INC_LZMA_LIB_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define Z7_STDAPI int Z7_STDCALL
+
+#define LZMA_PROPS_SIZE 5
+
+/*
+RAM requirements for LZMA:
+ for compression: (dictSize * 11.5 + 6 MB) + state_size
+ for decompression: dictSize + state_size
+ state_size = (4 + (1.5 << (lc + lp))) KB
+ by default (lc=3, lp=0), state_size = 16 KB.
+
+LZMA properties (5 bytes) format
+ Offset Size Description
+ 0 1 lc, lp and pb in encoded form.
+ 1 4 dictSize (little endian).
+*/
+
+/*
+LzmaCompress
+------------
+
+outPropsSize -
+ In: the pointer to the size of outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
+ Out: the pointer to the size of written properties in outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
+
+ LZMA Encoder will use defult values for any parameter, if it is
+ -1 for any from: level, loc, lp, pb, fb, numThreads
+ 0 for dictSize
+
+level - compression level: 0 <= level <= 9;
+
+ level dictSize algo fb
+ 0: 64 KB 0 32
+ 1: 256 KB 0 32
+ 2: 1 MB 0 32
+ 3: 4 MB 0 32
+ 4: 16 MB 0 32
+ 5: 16 MB 1 32
+ 6: 32 MB 1 32
+ 7: 32 MB 1 64
+ 8: 64 MB 1 64
+ 9: 64 MB 1 64
+
+ The default value for "level" is 5.
+
+ algo = 0 means fast method
+ algo = 1 means normal method
+
+dictSize - The dictionary size in bytes. The maximum value is
+ 128 MB = (1 << 27) bytes for 32-bit version
+ 1 GB = (1 << 30) bytes for 64-bit version
+ The default value is 16 MB = (1 << 24) bytes.
+ It's recommended to use the dictionary that is larger than 4 KB and
+ that can be calculated as (1 << N) or (3 << N) sizes.
+
+lc - The number of literal context bits (high bits of previous literal).
+ It can be in the range from 0 to 8. The default value is 3.
+ Sometimes lc=4 gives the gain for big files.
+
+lp - The number of literal pos bits (low bits of current position for literals).
+ It can be in the range from 0 to 4. The default value is 0.
+ The lp switch is intended for periodical data when the period is equal to 2^lp.
+ For example, for 32-bit (4 bytes) periodical data you can use lp=2. Often it's
+ better to set lc=0, if you change lp switch.
+
+pb - The number of pos bits (low bits of current position).
+ It can be in the range from 0 to 4. The default value is 2.
+ The pb switch is intended for periodical data when the period is equal 2^pb.
+
+fb - Word size (the number of fast bytes).
+ It can be in the range from 5 to 273. The default value is 32.
+ Usually, a big number gives a little bit better compression ratio and
+ slower compression process.
+
+numThreads - The number of thereads. 1 or 2. The default value is 2.
+ Fast mode (algo = 0) can use only 1 thread.
+
+In:
+ dest - output data buffer
+ destLen - output data buffer size
+ src - input data
+ srcLen - input data size
+Out:
+ destLen - processed output size
+Returns:
+ SZ_OK - OK
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_PARAM - Incorrect paramater
+ SZ_ERROR_OUTPUT_EOF - output buffer overflow
+ SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
+*/
+
+Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
+ unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */
+ int level, /* 0 <= level <= 9, default = 5 */
+ unsigned dictSize, /* default = (1 << 24) */
+ int lc, /* 0 <= lc <= 8, default = 3 */
+ int lp, /* 0 <= lp <= 4, default = 0 */
+ int pb, /* 0 <= pb <= 4, default = 2 */
+ int fb, /* 5 <= fb <= 273, default = 32 */
+ int numThreads /* 1 or 2, default = 2 */
+ );
+
+/*
+LzmaUncompress
+--------------
+In:
+ dest - output data buffer
+ destLen - output data buffer size
+ src - input data
+ srcLen - input data size
+Out:
+ destLen - processed output size
+ srcLen - processed input size
+Returns:
+ SZ_OK - OK
+ SZ_ERROR_DATA - Data error
+ SZ_ERROR_MEM - Memory allocation arror
+ SZ_ERROR_UNSUPPORTED - Unsupported properties
+ SZ_ERROR_INPUT_EOF - it needs more bytes in input buffer (src)
+*/
+
+Z7_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
+ const unsigned char *props, size_t propsSize);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/MtCoder.c b/C/MtCoder.c
index 5667f2d..6f58abb 100644
--- a/C/MtCoder.c
+++ b/C/MtCoder.c
@@ -1,601 +1,571 @@
-/* MtCoder.c -- Multi-thread Coder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "MtCoder.h"
-
-#ifndef _7ZIP_ST
-
-SRes MtProgressThunk_Progress(const ICompressProgress *pp, UInt64 inSize, UInt64 outSize)
-{
- CMtProgressThunk *thunk = CONTAINER_FROM_VTBL(pp, CMtProgressThunk, vt);
- UInt64 inSize2 = 0;
- UInt64 outSize2 = 0;
- if (inSize != (UInt64)(Int64)-1)
- {
- inSize2 = inSize - thunk->inSize;
- thunk->inSize = inSize;
- }
- if (outSize != (UInt64)(Int64)-1)
- {
- outSize2 = outSize - thunk->outSize;
- thunk->outSize = outSize;
- }
- return MtProgress_ProgressAdd(thunk->mtProgress, inSize2, outSize2);
-}
-
-
-void MtProgressThunk_CreateVTable(CMtProgressThunk *p)
-{
- p->vt.Progress = MtProgressThunk_Progress;
-}
-
-
-
-#define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
-
-
-static WRes ArEvent_OptCreate_And_Reset(CEvent *p)
-{
- if (Event_IsCreated(p))
- return Event_Reset(p);
- return AutoResetEvent_CreateNotSignaled(p);
-}
-
-
-static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp);
-
-
-static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t)
-{
- WRes wres = ArEvent_OptCreate_And_Reset(&t->startEvent);
- if (wres == 0)
- {
- t->stop = False;
- if (!Thread_WasCreated(&t->thread))
- wres = Thread_Create(&t->thread, ThreadFunc, t);
- if (wres == 0)
- wres = Event_Set(&t->startEvent);
- }
- if (wres == 0)
- return SZ_OK;
- return MY_SRes_HRESULT_FROM_WRes(wres);
-}
-
-
-static void MtCoderThread_Destruct(CMtCoderThread *t)
-{
- if (Thread_WasCreated(&t->thread))
- {
- t->stop = 1;
- Event_Set(&t->startEvent);
- Thread_Wait(&t->thread);
- Thread_Close(&t->thread);
- }
-
- Event_Close(&t->startEvent);
-
- if (t->inBuf)
- {
- ISzAlloc_Free(t->mtCoder->allocBig, t->inBuf);
- t->inBuf = NULL;
- }
-}
-
-
-
-static SRes FullRead(ISeqInStream *stream, Byte *data, size_t *processedSize)
-{
- size_t size = *processedSize;
- *processedSize = 0;
- while (size != 0)
- {
- size_t cur = size;
- SRes res = ISeqInStream_Read(stream, data, &cur);
- *processedSize += cur;
- data += cur;
- size -= cur;
- RINOK(res);
- if (cur == 0)
- return SZ_OK;
- }
- return SZ_OK;
-}
-
-
-/*
- ThreadFunc2() returns:
- SZ_OK - in all normal cases (even for stream error or memory allocation error)
- SZ_ERROR_THREAD - in case of failure in system synch function
-*/
-
-static SRes ThreadFunc2(CMtCoderThread *t)
-{
- CMtCoder *mtc = t->mtCoder;
-
- for (;;)
- {
- unsigned bi;
- SRes res;
- SRes res2;
- BoolInt finished;
- unsigned bufIndex;
- size_t size;
- const Byte *inData;
- UInt64 readProcessed = 0;
-
- RINOK_THREAD(Event_Wait(&mtc->readEvent))
-
- /* after Event_Wait(&mtc->readEvent) we must call Event_Set(&mtc->readEvent) in any case to unlock another threads */
-
- if (mtc->stopReading)
- {
- return Event_Set(&mtc->readEvent) == 0 ? SZ_OK : SZ_ERROR_THREAD;
- }
-
- res = MtProgress_GetError(&mtc->mtProgress);
-
- size = 0;
- inData = NULL;
- finished = True;
-
- if (res == SZ_OK)
- {
- size = mtc->blockSize;
- if (mtc->inStream)
- {
- if (!t->inBuf)
- {
- t->inBuf = (Byte *)ISzAlloc_Alloc(mtc->allocBig, mtc->blockSize);
- if (!t->inBuf)
- res = SZ_ERROR_MEM;
- }
- if (res == SZ_OK)
- {
- res = FullRead(mtc->inStream, t->inBuf, &size);
- readProcessed = mtc->readProcessed + size;
- mtc->readProcessed = readProcessed;
- }
- if (res != SZ_OK)
- {
- mtc->readRes = res;
- /* after reading error - we can stop encoding of previous blocks */
- MtProgress_SetError(&mtc->mtProgress, res);
- }
- else
- finished = (size != mtc->blockSize);
- }
- else
- {
- size_t rem;
- readProcessed = mtc->readProcessed;
- rem = mtc->inDataSize - (size_t)readProcessed;
- if (size > rem)
- size = rem;
- inData = mtc->inData + (size_t)readProcessed;
- readProcessed += size;
- mtc->readProcessed = readProcessed;
- finished = (mtc->inDataSize == (size_t)readProcessed);
- }
- }
-
- /* we must get some block from blocksSemaphore before Event_Set(&mtc->readEvent) */
-
- res2 = SZ_OK;
-
- if (Semaphore_Wait(&mtc->blocksSemaphore) != 0)
- {
- res2 = SZ_ERROR_THREAD;
- if (res == SZ_OK)
- {
- res = res2;
- // MtProgress_SetError(&mtc->mtProgress, res);
- }
- }
-
- bi = mtc->blockIndex;
-
- if (++mtc->blockIndex >= mtc->numBlocksMax)
- mtc->blockIndex = 0;
-
- bufIndex = (unsigned)(int)-1;
-
- if (res == SZ_OK)
- res = MtProgress_GetError(&mtc->mtProgress);
-
- if (res != SZ_OK)
- finished = True;
-
- if (!finished)
- {
- if (mtc->numStartedThreads < mtc->numStartedThreadsLimit
- && mtc->expectedDataSize != readProcessed)
- {
- res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]);
- if (res == SZ_OK)
- mtc->numStartedThreads++;
- else
- {
- MtProgress_SetError(&mtc->mtProgress, res);
- finished = True;
- }
- }
- }
-
- if (finished)
- mtc->stopReading = True;
-
- RINOK_THREAD(Event_Set(&mtc->readEvent))
-
- if (res2 != SZ_OK)
- return res2;
-
- if (res == SZ_OK)
- {
- CriticalSection_Enter(&mtc->cs);
- bufIndex = mtc->freeBlockHead;
- mtc->freeBlockHead = mtc->freeBlockList[bufIndex];
- CriticalSection_Leave(&mtc->cs);
-
- res = mtc->mtCallback->Code(mtc->mtCallbackObject, t->index, bufIndex,
- mtc->inStream ? t->inBuf : inData, size, finished);
-
- // MtProgress_Reinit(&mtc->mtProgress, t->index);
-
- if (res != SZ_OK)
- MtProgress_SetError(&mtc->mtProgress, res);
- }
-
- {
- CMtCoderBlock *block = &mtc->blocks[bi];
- block->res = res;
- block->bufIndex = bufIndex;
- block->finished = finished;
- }
-
- #ifdef MTCODER__USE_WRITE_THREAD
- RINOK_THREAD(Event_Set(&mtc->writeEvents[bi]))
- #else
- {
- unsigned wi;
- {
- CriticalSection_Enter(&mtc->cs);
- wi = mtc->writeIndex;
- if (wi == bi)
- mtc->writeIndex = (unsigned)(int)-1;
- else
- mtc->ReadyBlocks[bi] = True;
- CriticalSection_Leave(&mtc->cs);
- }
-
- if (wi != bi)
- {
- if (res != SZ_OK || finished)
- return 0;
- continue;
- }
-
- if (mtc->writeRes != SZ_OK)
- res = mtc->writeRes;
-
- for (;;)
- {
- if (res == SZ_OK && bufIndex != (unsigned)(int)-1)
- {
- res = mtc->mtCallback->Write(mtc->mtCallbackObject, bufIndex);
- if (res != SZ_OK)
- {
- mtc->writeRes = res;
- MtProgress_SetError(&mtc->mtProgress, res);
- }
- }
-
- if (++wi >= mtc->numBlocksMax)
- wi = 0;
- {
- BoolInt isReady;
-
- CriticalSection_Enter(&mtc->cs);
-
- if (bufIndex != (unsigned)(int)-1)
- {
- mtc->freeBlockList[bufIndex] = mtc->freeBlockHead;
- mtc->freeBlockHead = bufIndex;
- }
-
- isReady = mtc->ReadyBlocks[wi];
-
- if (isReady)
- mtc->ReadyBlocks[wi] = False;
- else
- mtc->writeIndex = wi;
-
- CriticalSection_Leave(&mtc->cs);
-
- RINOK_THREAD(Semaphore_Release1(&mtc->blocksSemaphore))
-
- if (!isReady)
- break;
- }
-
- {
- CMtCoderBlock *block = &mtc->blocks[wi];
- if (res == SZ_OK && block->res != SZ_OK)
- res = block->res;
- bufIndex = block->bufIndex;
- finished = block->finished;
- }
- }
- }
- #endif
-
- if (finished || res != SZ_OK)
- return 0;
- }
-}
-
-
-static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp)
-{
- CMtCoderThread *t = (CMtCoderThread *)pp;
- for (;;)
- {
- if (Event_Wait(&t->startEvent) != 0)
- return SZ_ERROR_THREAD;
- if (t->stop)
- return 0;
- {
- SRes res = ThreadFunc2(t);
- CMtCoder *mtc = t->mtCoder;
- if (res != SZ_OK)
- {
- MtProgress_SetError(&mtc->mtProgress, res);
- }
-
- #ifndef MTCODER__USE_WRITE_THREAD
- {
- unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
- if (numFinished == mtc->numStartedThreads)
- if (Event_Set(&mtc->finishedEvent) != 0)
- return SZ_ERROR_THREAD;
- }
- #endif
- }
- }
-}
-
-
-
-void MtCoder_Construct(CMtCoder *p)
-{
- unsigned i;
-
- p->blockSize = 0;
- p->numThreadsMax = 0;
- p->expectedDataSize = (UInt64)(Int64)-1;
-
- p->inStream = NULL;
- p->inData = NULL;
- p->inDataSize = 0;
-
- p->progress = NULL;
- p->allocBig = NULL;
-
- p->mtCallback = NULL;
- p->mtCallbackObject = NULL;
-
- p->allocatedBufsSize = 0;
-
- Event_Construct(&p->readEvent);
- Semaphore_Construct(&p->blocksSemaphore);
-
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- {
- CMtCoderThread *t = &p->threads[i];
- t->mtCoder = p;
- t->index = i;
- t->inBuf = NULL;
- t->stop = False;
- Event_Construct(&t->startEvent);
- Thread_Construct(&t->thread);
- }
-
- #ifdef MTCODER__USE_WRITE_THREAD
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- Event_Construct(&p->writeEvents[i]);
- #else
- Event_Construct(&p->finishedEvent);
- #endif
-
- CriticalSection_Init(&p->cs);
- CriticalSection_Init(&p->mtProgress.cs);
-}
-
-
-
-
-static void MtCoder_Free(CMtCoder *p)
-{
- unsigned i;
-
- /*
- p->stopReading = True;
- if (Event_IsCreated(&p->readEvent))
- Event_Set(&p->readEvent);
- */
-
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- MtCoderThread_Destruct(&p->threads[i]);
-
- Event_Close(&p->readEvent);
- Semaphore_Close(&p->blocksSemaphore);
-
- #ifdef MTCODER__USE_WRITE_THREAD
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- Event_Close(&p->writeEvents[i]);
- #else
- Event_Close(&p->finishedEvent);
- #endif
-}
-
-
-void MtCoder_Destruct(CMtCoder *p)
-{
- MtCoder_Free(p);
-
- CriticalSection_Delete(&p->cs);
- CriticalSection_Delete(&p->mtProgress.cs);
-}
-
-
-SRes MtCoder_Code(CMtCoder *p)
-{
- unsigned numThreads = p->numThreadsMax;
- unsigned numBlocksMax;
- unsigned i;
- SRes res = SZ_OK;
-
- if (numThreads > MTCODER__THREADS_MAX)
- numThreads = MTCODER__THREADS_MAX;
- numBlocksMax = MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads);
-
- if (p->blockSize < ((UInt32)1 << 26)) numBlocksMax++;
- if (p->blockSize < ((UInt32)1 << 24)) numBlocksMax++;
- if (p->blockSize < ((UInt32)1 << 22)) numBlocksMax++;
-
- if (numBlocksMax > MTCODER__BLOCKS_MAX)
- numBlocksMax = MTCODER__BLOCKS_MAX;
-
- if (p->blockSize != p->allocatedBufsSize)
- {
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- {
- CMtCoderThread *t = &p->threads[i];
- if (t->inBuf)
- {
- ISzAlloc_Free(p->allocBig, t->inBuf);
- t->inBuf = NULL;
- }
- }
- p->allocatedBufsSize = p->blockSize;
- }
-
- p->readRes = SZ_OK;
-
- MtProgress_Init(&p->mtProgress, p->progress);
-
- #ifdef MTCODER__USE_WRITE_THREAD
- for (i = 0; i < numBlocksMax; i++)
- {
- RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->writeEvents[i]));
- }
- #else
- RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->finishedEvent));
- #endif
-
- {
- RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->readEvent));
-
- if (Semaphore_IsCreated(&p->blocksSemaphore))
- {
- RINOK_THREAD(Semaphore_Close(&p->blocksSemaphore));
- }
- RINOK_THREAD(Semaphore_Create(&p->blocksSemaphore, numBlocksMax, numBlocksMax));
- }
-
- for (i = 0; i < MTCODER__BLOCKS_MAX - 1; i++)
- p->freeBlockList[i] = i + 1;
- p->freeBlockList[MTCODER__BLOCKS_MAX - 1] = (unsigned)(int)-1;
- p->freeBlockHead = 0;
-
- p->readProcessed = 0;
- p->blockIndex = 0;
- p->numBlocksMax = numBlocksMax;
- p->stopReading = False;
-
- #ifndef MTCODER__USE_WRITE_THREAD
- p->writeIndex = 0;
- p->writeRes = SZ_OK;
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- p->ReadyBlocks[i] = False;
- p->numFinishedThreads = 0;
- #endif
-
- p->numStartedThreadsLimit = numThreads;
- p->numStartedThreads = 0;
-
- // for (i = 0; i < numThreads; i++)
- {
- CMtCoderThread *nextThread = &p->threads[p->numStartedThreads++];
- RINOK(MtCoderThread_CreateAndStart(nextThread));
- }
-
- RINOK_THREAD(Event_Set(&p->readEvent))
-
- #ifdef MTCODER__USE_WRITE_THREAD
- {
- unsigned bi = 0;
-
- for (;; bi++)
- {
- if (bi >= numBlocksMax)
- bi = 0;
-
- RINOK_THREAD(Event_Wait(&p->writeEvents[bi]))
-
- {
- const CMtCoderBlock *block = &p->blocks[bi];
- unsigned bufIndex = block->bufIndex;
- BoolInt finished = block->finished;
- if (res == SZ_OK && block->res != SZ_OK)
- res = block->res;
-
- if (bufIndex != (unsigned)(int)-1)
- {
- if (res == SZ_OK)
- {
- res = p->mtCallback->Write(p->mtCallbackObject, bufIndex);
- if (res != SZ_OK)
- MtProgress_SetError(&p->mtProgress, res);
- }
-
- CriticalSection_Enter(&p->cs);
- {
- p->freeBlockList[bufIndex] = p->freeBlockHead;
- p->freeBlockHead = bufIndex;
- }
- CriticalSection_Leave(&p->cs);
- }
-
- RINOK_THREAD(Semaphore_Release1(&p->blocksSemaphore))
-
- if (finished)
- break;
- }
- }
- }
- #else
- {
- WRes wres = Event_Wait(&p->finishedEvent);
- res = MY_SRes_HRESULT_FROM_WRes(wres);
- }
- #endif
-
- if (res == SZ_OK)
- res = p->readRes;
-
- if (res == SZ_OK)
- res = p->mtProgress.res;
-
- #ifndef MTCODER__USE_WRITE_THREAD
- if (res == SZ_OK)
- res = p->writeRes;
- #endif
-
- if (res != SZ_OK)
- MtCoder_Free(p);
- return res;
-}
-
-#endif
+/* MtCoder.c -- Multi-thread Coder
+2023-04-13 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "MtCoder.h"
+
+#ifndef Z7_ST
+
+static SRes MtProgressThunk_Progress(ICompressProgressPtr pp, UInt64 inSize, UInt64 outSize)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CMtProgressThunk)
+ UInt64 inSize2 = 0;
+ UInt64 outSize2 = 0;
+ if (inSize != (UInt64)(Int64)-1)
+ {
+ inSize2 = inSize - p->inSize;
+ p->inSize = inSize;
+ }
+ if (outSize != (UInt64)(Int64)-1)
+ {
+ outSize2 = outSize - p->outSize;
+ p->outSize = outSize;
+ }
+ return MtProgress_ProgressAdd(p->mtProgress, inSize2, outSize2);
+}
+
+
+void MtProgressThunk_CreateVTable(CMtProgressThunk *p)
+{
+ p->vt.Progress = MtProgressThunk_Progress;
+}
+
+
+
+#define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
+
+
+static THREAD_FUNC_DECL ThreadFunc(void *pp);
+
+
+static SRes MtCoderThread_CreateAndStart(CMtCoderThread *t)
+{
+ WRes wres = AutoResetEvent_OptCreate_And_Reset(&t->startEvent);
+ if (wres == 0)
+ {
+ t->stop = False;
+ if (!Thread_WasCreated(&t->thread))
+ wres = Thread_Create(&t->thread, ThreadFunc, t);
+ if (wres == 0)
+ wres = Event_Set(&t->startEvent);
+ }
+ if (wres == 0)
+ return SZ_OK;
+ return MY_SRes_HRESULT_FROM_WRes(wres);
+}
+
+
+static void MtCoderThread_Destruct(CMtCoderThread *t)
+{
+ if (Thread_WasCreated(&t->thread))
+ {
+ t->stop = 1;
+ Event_Set(&t->startEvent);
+ Thread_Wait_Close(&t->thread);
+ }
+
+ Event_Close(&t->startEvent);
+
+ if (t->inBuf)
+ {
+ ISzAlloc_Free(t->mtCoder->allocBig, t->inBuf);
+ t->inBuf = NULL;
+ }
+}
+
+
+
+
+/*
+ ThreadFunc2() returns:
+ SZ_OK - in all normal cases (even for stream error or memory allocation error)
+ SZ_ERROR_THREAD - in case of failure in system synch function
+*/
+
+static SRes ThreadFunc2(CMtCoderThread *t)
+{
+ CMtCoder *mtc = t->mtCoder;
+
+ for (;;)
+ {
+ unsigned bi;
+ SRes res;
+ SRes res2;
+ BoolInt finished;
+ unsigned bufIndex;
+ size_t size;
+ const Byte *inData;
+ UInt64 readProcessed = 0;
+
+ RINOK_THREAD(Event_Wait(&mtc->readEvent))
+
+ /* after Event_Wait(&mtc->readEvent) we must call Event_Set(&mtc->readEvent) in any case to unlock another threads */
+
+ if (mtc->stopReading)
+ {
+ return Event_Set(&mtc->readEvent) == 0 ? SZ_OK : SZ_ERROR_THREAD;
+ }
+
+ res = MtProgress_GetError(&mtc->mtProgress);
+
+ size = 0;
+ inData = NULL;
+ finished = True;
+
+ if (res == SZ_OK)
+ {
+ size = mtc->blockSize;
+ if (mtc->inStream)
+ {
+ if (!t->inBuf)
+ {
+ t->inBuf = (Byte *)ISzAlloc_Alloc(mtc->allocBig, mtc->blockSize);
+ if (!t->inBuf)
+ res = SZ_ERROR_MEM;
+ }
+ if (res == SZ_OK)
+ {
+ res = SeqInStream_ReadMax(mtc->inStream, t->inBuf, &size);
+ readProcessed = mtc->readProcessed + size;
+ mtc->readProcessed = readProcessed;
+ }
+ if (res != SZ_OK)
+ {
+ mtc->readRes = res;
+ /* after reading error - we can stop encoding of previous blocks */
+ MtProgress_SetError(&mtc->mtProgress, res);
+ }
+ else
+ finished = (size != mtc->blockSize);
+ }
+ else
+ {
+ size_t rem;
+ readProcessed = mtc->readProcessed;
+ rem = mtc->inDataSize - (size_t)readProcessed;
+ if (size > rem)
+ size = rem;
+ inData = mtc->inData + (size_t)readProcessed;
+ readProcessed += size;
+ mtc->readProcessed = readProcessed;
+ finished = (mtc->inDataSize == (size_t)readProcessed);
+ }
+ }
+
+ /* we must get some block from blocksSemaphore before Event_Set(&mtc->readEvent) */
+
+ res2 = SZ_OK;
+
+ if (Semaphore_Wait(&mtc->blocksSemaphore) != 0)
+ {
+ res2 = SZ_ERROR_THREAD;
+ if (res == SZ_OK)
+ {
+ res = res2;
+ // MtProgress_SetError(&mtc->mtProgress, res);
+ }
+ }
+
+ bi = mtc->blockIndex;
+
+ if (++mtc->blockIndex >= mtc->numBlocksMax)
+ mtc->blockIndex = 0;
+
+ bufIndex = (unsigned)(int)-1;
+
+ if (res == SZ_OK)
+ res = MtProgress_GetError(&mtc->mtProgress);
+
+ if (res != SZ_OK)
+ finished = True;
+
+ if (!finished)
+ {
+ if (mtc->numStartedThreads < mtc->numStartedThreadsLimit
+ && mtc->expectedDataSize != readProcessed)
+ {
+ res = MtCoderThread_CreateAndStart(&mtc->threads[mtc->numStartedThreads]);
+ if (res == SZ_OK)
+ mtc->numStartedThreads++;
+ else
+ {
+ MtProgress_SetError(&mtc->mtProgress, res);
+ finished = True;
+ }
+ }
+ }
+
+ if (finished)
+ mtc->stopReading = True;
+
+ RINOK_THREAD(Event_Set(&mtc->readEvent))
+
+ if (res2 != SZ_OK)
+ return res2;
+
+ if (res == SZ_OK)
+ {
+ CriticalSection_Enter(&mtc->cs);
+ bufIndex = mtc->freeBlockHead;
+ mtc->freeBlockHead = mtc->freeBlockList[bufIndex];
+ CriticalSection_Leave(&mtc->cs);
+
+ res = mtc->mtCallback->Code(mtc->mtCallbackObject, t->index, bufIndex,
+ mtc->inStream ? t->inBuf : inData, size, finished);
+
+ // MtProgress_Reinit(&mtc->mtProgress, t->index);
+
+ if (res != SZ_OK)
+ MtProgress_SetError(&mtc->mtProgress, res);
+ }
+
+ {
+ CMtCoderBlock *block = &mtc->blocks[bi];
+ block->res = res;
+ block->bufIndex = bufIndex;
+ block->finished = finished;
+ }
+
+ #ifdef MTCODER_USE_WRITE_THREAD
+ RINOK_THREAD(Event_Set(&mtc->writeEvents[bi]))
+ #else
+ {
+ unsigned wi;
+ {
+ CriticalSection_Enter(&mtc->cs);
+ wi = mtc->writeIndex;
+ if (wi == bi)
+ mtc->writeIndex = (unsigned)(int)-1;
+ else
+ mtc->ReadyBlocks[bi] = True;
+ CriticalSection_Leave(&mtc->cs);
+ }
+
+ if (wi != bi)
+ {
+ if (res != SZ_OK || finished)
+ return 0;
+ continue;
+ }
+
+ if (mtc->writeRes != SZ_OK)
+ res = mtc->writeRes;
+
+ for (;;)
+ {
+ if (res == SZ_OK && bufIndex != (unsigned)(int)-1)
+ {
+ res = mtc->mtCallback->Write(mtc->mtCallbackObject, bufIndex);
+ if (res != SZ_OK)
+ {
+ mtc->writeRes = res;
+ MtProgress_SetError(&mtc->mtProgress, res);
+ }
+ }
+
+ if (++wi >= mtc->numBlocksMax)
+ wi = 0;
+ {
+ BoolInt isReady;
+
+ CriticalSection_Enter(&mtc->cs);
+
+ if (bufIndex != (unsigned)(int)-1)
+ {
+ mtc->freeBlockList[bufIndex] = mtc->freeBlockHead;
+ mtc->freeBlockHead = bufIndex;
+ }
+
+ isReady = mtc->ReadyBlocks[wi];
+
+ if (isReady)
+ mtc->ReadyBlocks[wi] = False;
+ else
+ mtc->writeIndex = wi;
+
+ CriticalSection_Leave(&mtc->cs);
+
+ RINOK_THREAD(Semaphore_Release1(&mtc->blocksSemaphore))
+
+ if (!isReady)
+ break;
+ }
+
+ {
+ CMtCoderBlock *block = &mtc->blocks[wi];
+ if (res == SZ_OK && block->res != SZ_OK)
+ res = block->res;
+ bufIndex = block->bufIndex;
+ finished = block->finished;
+ }
+ }
+ }
+ #endif
+
+ if (finished || res != SZ_OK)
+ return 0;
+ }
+}
+
+
+static THREAD_FUNC_DECL ThreadFunc(void *pp)
+{
+ CMtCoderThread *t = (CMtCoderThread *)pp;
+ for (;;)
+ {
+ if (Event_Wait(&t->startEvent) != 0)
+ return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
+ if (t->stop)
+ return 0;
+ {
+ SRes res = ThreadFunc2(t);
+ CMtCoder *mtc = t->mtCoder;
+ if (res != SZ_OK)
+ {
+ MtProgress_SetError(&mtc->mtProgress, res);
+ }
+
+ #ifndef MTCODER_USE_WRITE_THREAD
+ {
+ unsigned numFinished = (unsigned)InterlockedIncrement(&mtc->numFinishedThreads);
+ if (numFinished == mtc->numStartedThreads)
+ if (Event_Set(&mtc->finishedEvent) != 0)
+ return (THREAD_FUNC_RET_TYPE)SZ_ERROR_THREAD;
+ }
+ #endif
+ }
+ }
+}
+
+
+
+void MtCoder_Construct(CMtCoder *p)
+{
+ unsigned i;
+
+ p->blockSize = 0;
+ p->numThreadsMax = 0;
+ p->expectedDataSize = (UInt64)(Int64)-1;
+
+ p->inStream = NULL;
+ p->inData = NULL;
+ p->inDataSize = 0;
+
+ p->progress = NULL;
+ p->allocBig = NULL;
+
+ p->mtCallback = NULL;
+ p->mtCallbackObject = NULL;
+
+ p->allocatedBufsSize = 0;
+
+ Event_Construct(&p->readEvent);
+ Semaphore_Construct(&p->blocksSemaphore);
+
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ {
+ CMtCoderThread *t = &p->threads[i];
+ t->mtCoder = p;
+ t->index = i;
+ t->inBuf = NULL;
+ t->stop = False;
+ Event_Construct(&t->startEvent);
+ Thread_CONSTRUCT(&t->thread)
+ }
+
+ #ifdef MTCODER_USE_WRITE_THREAD
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ Event_Construct(&p->writeEvents[i]);
+ #else
+ Event_Construct(&p->finishedEvent);
+ #endif
+
+ CriticalSection_Init(&p->cs);
+ CriticalSection_Init(&p->mtProgress.cs);
+}
+
+
+
+
+static void MtCoder_Free(CMtCoder *p)
+{
+ unsigned i;
+
+ /*
+ p->stopReading = True;
+ if (Event_IsCreated(&p->readEvent))
+ Event_Set(&p->readEvent);
+ */
+
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ MtCoderThread_Destruct(&p->threads[i]);
+
+ Event_Close(&p->readEvent);
+ Semaphore_Close(&p->blocksSemaphore);
+
+ #ifdef MTCODER_USE_WRITE_THREAD
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ Event_Close(&p->writeEvents[i]);
+ #else
+ Event_Close(&p->finishedEvent);
+ #endif
+}
+
+
+void MtCoder_Destruct(CMtCoder *p)
+{
+ MtCoder_Free(p);
+
+ CriticalSection_Delete(&p->cs);
+ CriticalSection_Delete(&p->mtProgress.cs);
+}
+
+
+SRes MtCoder_Code(CMtCoder *p)
+{
+ unsigned numThreads = p->numThreadsMax;
+ unsigned numBlocksMax;
+ unsigned i;
+ SRes res = SZ_OK;
+
+ if (numThreads > MTCODER_THREADS_MAX)
+ numThreads = MTCODER_THREADS_MAX;
+ numBlocksMax = MTCODER_GET_NUM_BLOCKS_FROM_THREADS(numThreads);
+
+ if (p->blockSize < ((UInt32)1 << 26)) numBlocksMax++;
+ if (p->blockSize < ((UInt32)1 << 24)) numBlocksMax++;
+ if (p->blockSize < ((UInt32)1 << 22)) numBlocksMax++;
+
+ if (numBlocksMax > MTCODER_BLOCKS_MAX)
+ numBlocksMax = MTCODER_BLOCKS_MAX;
+
+ if (p->blockSize != p->allocatedBufsSize)
+ {
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ {
+ CMtCoderThread *t = &p->threads[i];
+ if (t->inBuf)
+ {
+ ISzAlloc_Free(p->allocBig, t->inBuf);
+ t->inBuf = NULL;
+ }
+ }
+ p->allocatedBufsSize = p->blockSize;
+ }
+
+ p->readRes = SZ_OK;
+
+ MtProgress_Init(&p->mtProgress, p->progress);
+
+ #ifdef MTCODER_USE_WRITE_THREAD
+ for (i = 0; i < numBlocksMax; i++)
+ {
+ RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->writeEvents[i]))
+ }
+ #else
+ RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->finishedEvent))
+ #endif
+
+ {
+ RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->readEvent))
+ RINOK_THREAD(Semaphore_OptCreateInit(&p->blocksSemaphore, numBlocksMax, numBlocksMax))
+ }
+
+ for (i = 0; i < MTCODER_BLOCKS_MAX - 1; i++)
+ p->freeBlockList[i] = i + 1;
+ p->freeBlockList[MTCODER_BLOCKS_MAX - 1] = (unsigned)(int)-1;
+ p->freeBlockHead = 0;
+
+ p->readProcessed = 0;
+ p->blockIndex = 0;
+ p->numBlocksMax = numBlocksMax;
+ p->stopReading = False;
+
+ #ifndef MTCODER_USE_WRITE_THREAD
+ p->writeIndex = 0;
+ p->writeRes = SZ_OK;
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ p->ReadyBlocks[i] = False;
+ p->numFinishedThreads = 0;
+ #endif
+
+ p->numStartedThreadsLimit = numThreads;
+ p->numStartedThreads = 0;
+
+ // for (i = 0; i < numThreads; i++)
+ {
+ CMtCoderThread *nextThread = &p->threads[p->numStartedThreads++];
+ RINOK(MtCoderThread_CreateAndStart(nextThread))
+ }
+
+ RINOK_THREAD(Event_Set(&p->readEvent))
+
+ #ifdef MTCODER_USE_WRITE_THREAD
+ {
+ unsigned bi = 0;
+
+ for (;; bi++)
+ {
+ if (bi >= numBlocksMax)
+ bi = 0;
+
+ RINOK_THREAD(Event_Wait(&p->writeEvents[bi]))
+
+ {
+ const CMtCoderBlock *block = &p->blocks[bi];
+ unsigned bufIndex = block->bufIndex;
+ BoolInt finished = block->finished;
+ if (res == SZ_OK && block->res != SZ_OK)
+ res = block->res;
+
+ if (bufIndex != (unsigned)(int)-1)
+ {
+ if (res == SZ_OK)
+ {
+ res = p->mtCallback->Write(p->mtCallbackObject, bufIndex);
+ if (res != SZ_OK)
+ MtProgress_SetError(&p->mtProgress, res);
+ }
+
+ CriticalSection_Enter(&p->cs);
+ {
+ p->freeBlockList[bufIndex] = p->freeBlockHead;
+ p->freeBlockHead = bufIndex;
+ }
+ CriticalSection_Leave(&p->cs);
+ }
+
+ RINOK_THREAD(Semaphore_Release1(&p->blocksSemaphore))
+
+ if (finished)
+ break;
+ }
+ }
+ }
+ #else
+ {
+ WRes wres = Event_Wait(&p->finishedEvent);
+ res = MY_SRes_HRESULT_FROM_WRes(wres);
+ }
+ #endif
+
+ if (res == SZ_OK)
+ res = p->readRes;
+
+ if (res == SZ_OK)
+ res = p->mtProgress.res;
+
+ #ifndef MTCODER_USE_WRITE_THREAD
+ if (res == SZ_OK)
+ res = p->writeRes;
+ #endif
+
+ if (res != SZ_OK)
+ MtCoder_Free(p);
+ return res;
+}
+
+#endif
+
+#undef RINOK_THREAD
diff --git a/C/MtCoder.h b/C/MtCoder.h
index 603329d..1231d3c 100644
--- a/C/MtCoder.h
+++ b/C/MtCoder.h
@@ -1,141 +1,141 @@
-/* MtCoder.h -- Multi-thread Coder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#ifndef __MT_CODER_H
-#define __MT_CODER_H
-
-#include "MtDec.h"
-
-EXTERN_C_BEGIN
-
-/*
- if ( defined MTCODER__USE_WRITE_THREAD) : main thread writes all data blocks to output stream
- if (not defined MTCODER__USE_WRITE_THREAD) : any coder thread can write data blocks to output stream
-*/
-/* #define MTCODER__USE_WRITE_THREAD */
-
-#ifndef _7ZIP_ST
- #define MTCODER__GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1)
- #define MTCODER__THREADS_MAX 64
- #define MTCODER__BLOCKS_MAX (MTCODER__GET_NUM_BLOCKS_FROM_THREADS(MTCODER__THREADS_MAX) + 3)
-#else
- #define MTCODER__THREADS_MAX 1
- #define MTCODER__BLOCKS_MAX 1
-#endif
-
-
-#ifndef _7ZIP_ST
-
-
-typedef struct
-{
- ICompressProgress vt;
- CMtProgress *mtProgress;
- UInt64 inSize;
- UInt64 outSize;
-} CMtProgressThunk;
-
-void MtProgressThunk_CreateVTable(CMtProgressThunk *p);
-
-#define MtProgressThunk_Init(p) { (p)->inSize = 0; (p)->outSize = 0; }
-
-
-struct _CMtCoder;
-
-
-typedef struct
-{
- struct _CMtCoder *mtCoder;
- unsigned index;
- int stop;
- Byte *inBuf;
-
- CAutoResetEvent startEvent;
- CThread thread;
-} CMtCoderThread;
-
-
-typedef struct
-{
- SRes (*Code)(void *p, unsigned coderIndex, unsigned outBufIndex,
- const Byte *src, size_t srcSize, int finished);
- SRes (*Write)(void *p, unsigned outBufIndex);
-} IMtCoderCallback2;
-
-
-typedef struct
-{
- SRes res;
- unsigned bufIndex;
- BoolInt finished;
-} CMtCoderBlock;
-
-
-typedef struct _CMtCoder
-{
- /* input variables */
-
- size_t blockSize; /* size of input block */
- unsigned numThreadsMax;
- UInt64 expectedDataSize;
-
- ISeqInStream *inStream;
- const Byte *inData;
- size_t inDataSize;
-
- ICompressProgress *progress;
- ISzAllocPtr allocBig;
-
- IMtCoderCallback2 *mtCallback;
- void *mtCallbackObject;
-
-
- /* internal variables */
-
- size_t allocatedBufsSize;
-
- CAutoResetEvent readEvent;
- CSemaphore blocksSemaphore;
-
- BoolInt stopReading;
- SRes readRes;
-
- #ifdef MTCODER__USE_WRITE_THREAD
- CAutoResetEvent writeEvents[MTCODER__BLOCKS_MAX];
- #else
- CAutoResetEvent finishedEvent;
- SRes writeRes;
- unsigned writeIndex;
- Byte ReadyBlocks[MTCODER__BLOCKS_MAX];
- LONG numFinishedThreads;
- #endif
-
- unsigned numStartedThreadsLimit;
- unsigned numStartedThreads;
-
- unsigned numBlocksMax;
- unsigned blockIndex;
- UInt64 readProcessed;
-
- CCriticalSection cs;
-
- unsigned freeBlockHead;
- unsigned freeBlockList[MTCODER__BLOCKS_MAX];
-
- CMtProgress mtProgress;
- CMtCoderBlock blocks[MTCODER__BLOCKS_MAX];
- CMtCoderThread threads[MTCODER__THREADS_MAX];
-} CMtCoder;
-
-
-void MtCoder_Construct(CMtCoder *p);
-void MtCoder_Destruct(CMtCoder *p);
-SRes MtCoder_Code(CMtCoder *p);
-
-
-#endif
-
-
-EXTERN_C_END
-
-#endif
+/* MtCoder.h -- Multi-thread Coder
+2023-04-13 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_MT_CODER_H
+#define ZIP7_INC_MT_CODER_H
+
+#include "MtDec.h"
+
+EXTERN_C_BEGIN
+
+/*
+ if ( defined MTCODER_USE_WRITE_THREAD) : main thread writes all data blocks to output stream
+ if (not defined MTCODER_USE_WRITE_THREAD) : any coder thread can write data blocks to output stream
+*/
+/* #define MTCODER_USE_WRITE_THREAD */
+
+#ifndef Z7_ST
+ #define MTCODER_GET_NUM_BLOCKS_FROM_THREADS(numThreads) ((numThreads) + (numThreads) / 8 + 1)
+ #define MTCODER_THREADS_MAX 64
+ #define MTCODER_BLOCKS_MAX (MTCODER_GET_NUM_BLOCKS_FROM_THREADS(MTCODER_THREADS_MAX) + 3)
+#else
+ #define MTCODER_THREADS_MAX 1
+ #define MTCODER_BLOCKS_MAX 1
+#endif
+
+
+#ifndef Z7_ST
+
+
+typedef struct
+{
+ ICompressProgress vt;
+ CMtProgress *mtProgress;
+ UInt64 inSize;
+ UInt64 outSize;
+} CMtProgressThunk;
+
+void MtProgressThunk_CreateVTable(CMtProgressThunk *p);
+
+#define MtProgressThunk_INIT(p) { (p)->inSize = 0; (p)->outSize = 0; }
+
+
+struct CMtCoder_;
+
+
+typedef struct
+{
+ struct CMtCoder_ *mtCoder;
+ unsigned index;
+ int stop;
+ Byte *inBuf;
+
+ CAutoResetEvent startEvent;
+ CThread thread;
+} CMtCoderThread;
+
+
+typedef struct
+{
+ SRes (*Code)(void *p, unsigned coderIndex, unsigned outBufIndex,
+ const Byte *src, size_t srcSize, int finished);
+ SRes (*Write)(void *p, unsigned outBufIndex);
+} IMtCoderCallback2;
+
+
+typedef struct
+{
+ SRes res;
+ unsigned bufIndex;
+ BoolInt finished;
+} CMtCoderBlock;
+
+
+typedef struct CMtCoder_
+{
+ /* input variables */
+
+ size_t blockSize; /* size of input block */
+ unsigned numThreadsMax;
+ UInt64 expectedDataSize;
+
+ ISeqInStreamPtr inStream;
+ const Byte *inData;
+ size_t inDataSize;
+
+ ICompressProgressPtr progress;
+ ISzAllocPtr allocBig;
+
+ IMtCoderCallback2 *mtCallback;
+ void *mtCallbackObject;
+
+
+ /* internal variables */
+
+ size_t allocatedBufsSize;
+
+ CAutoResetEvent readEvent;
+ CSemaphore blocksSemaphore;
+
+ BoolInt stopReading;
+ SRes readRes;
+
+ #ifdef MTCODER_USE_WRITE_THREAD
+ CAutoResetEvent writeEvents[MTCODER_BLOCKS_MAX];
+ #else
+ CAutoResetEvent finishedEvent;
+ SRes writeRes;
+ unsigned writeIndex;
+ Byte ReadyBlocks[MTCODER_BLOCKS_MAX];
+ LONG numFinishedThreads;
+ #endif
+
+ unsigned numStartedThreadsLimit;
+ unsigned numStartedThreads;
+
+ unsigned numBlocksMax;
+ unsigned blockIndex;
+ UInt64 readProcessed;
+
+ CCriticalSection cs;
+
+ unsigned freeBlockHead;
+ unsigned freeBlockList[MTCODER_BLOCKS_MAX];
+
+ CMtProgress mtProgress;
+ CMtCoderBlock blocks[MTCODER_BLOCKS_MAX];
+ CMtCoderThread threads[MTCODER_THREADS_MAX];
+} CMtCoder;
+
+
+void MtCoder_Construct(CMtCoder *p);
+void MtCoder_Destruct(CMtCoder *p);
+SRes MtCoder_Code(CMtCoder *p);
+
+
+#endif
+
+
+EXTERN_C_END
+
+#endif
diff --git a/C/MtDec.c b/C/MtDec.c
index 25a8b04..7820699 100644
--- a/C/MtDec.c
+++ b/C/MtDec.c
@@ -1,1138 +1,1114 @@
-/* MtDec.c -- Multi-thread Decoder
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-// #define SHOW_DEBUG_INFO
-
-// #include <stdio.h>
-
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
-
-#include "MtDec.h"
-
-#ifndef _7ZIP_ST
-
-void MtProgress_Init(CMtProgress *p, ICompressProgress *progress)
-{
- p->progress = progress;
- p->res = SZ_OK;
- p->totalInSize = 0;
- p->totalOutSize = 0;
-}
-
-
-SRes MtProgress_Progress_ST(CMtProgress *p)
-{
- if (p->res == SZ_OK && p->progress)
- if (ICompressProgress_Progress(p->progress, p->totalInSize, p->totalOutSize) != SZ_OK)
- p->res = SZ_ERROR_PROGRESS;
- return p->res;
-}
-
-
-SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize)
-{
- SRes res;
- CriticalSection_Enter(&p->cs);
-
- p->totalInSize += inSize;
- p->totalOutSize += outSize;
- if (p->res == SZ_OK && p->progress)
- if (ICompressProgress_Progress(p->progress, p->totalInSize, p->totalOutSize) != SZ_OK)
- p->res = SZ_ERROR_PROGRESS;
- res = p->res;
-
- CriticalSection_Leave(&p->cs);
- return res;
-}
-
-
-SRes MtProgress_GetError(CMtProgress *p)
-{
- SRes res;
- CriticalSection_Enter(&p->cs);
- res = p->res;
- CriticalSection_Leave(&p->cs);
- return res;
-}
-
-
-void MtProgress_SetError(CMtProgress *p, SRes res)
-{
- CriticalSection_Enter(&p->cs);
- if (p->res == SZ_OK)
- p->res = res;
- CriticalSection_Leave(&p->cs);
-}
-
-
-#define RINOK_THREAD(x) RINOK(x)
-
-
-static WRes ArEvent_OptCreate_And_Reset(CEvent *p)
-{
- if (Event_IsCreated(p))
- return Event_Reset(p);
- return AutoResetEvent_CreateNotSignaled(p);
-}
-
-
-struct __CMtDecBufLink
-{
- struct __CMtDecBufLink *next;
- void *pad[3];
-};
-
-typedef struct __CMtDecBufLink CMtDecBufLink;
-
-#define MTDEC__LINK_DATA_OFFSET sizeof(CMtDecBufLink)
-#define MTDEC__DATA_PTR_FROM_LINK(link) ((Byte *)(link) + MTDEC__LINK_DATA_OFFSET)
-
-
-
-static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp);
-
-
-static WRes MtDecThread_CreateEvents(CMtDecThread *t)
-{
- WRes wres = ArEvent_OptCreate_And_Reset(&t->canWrite);
- if (wres == 0)
- {
- wres = ArEvent_OptCreate_And_Reset(&t->canRead);
- if (wres == 0)
- return SZ_OK;
- }
- return wres;
-}
-
-
-static SRes MtDecThread_CreateAndStart(CMtDecThread *t)
-{
- WRes wres = MtDecThread_CreateEvents(t);
- // wres = 17; // for test
- if (wres == 0)
- {
- if (Thread_WasCreated(&t->thread))
- return SZ_OK;
- wres = Thread_Create(&t->thread, ThreadFunc, t);
- if (wres == 0)
- return SZ_OK;
- }
- return MY_SRes_HRESULT_FROM_WRes(wres);
-}
-
-
-void MtDecThread_FreeInBufs(CMtDecThread *t)
-{
- if (t->inBuf)
- {
- void *link = t->inBuf;
- t->inBuf = NULL;
- do
- {
- void *next = ((CMtDecBufLink *)link)->next;
- ISzAlloc_Free(t->mtDec->alloc, link);
- link = next;
- }
- while (link);
- }
-}
-
-
-static void MtDecThread_CloseThread(CMtDecThread *t)
-{
- if (Thread_WasCreated(&t->thread))
- {
- Event_Set(&t->canWrite); /* we can disable it. There are no threads waiting canWrite in normal cases */
- Event_Set(&t->canRead);
- Thread_Wait(&t->thread);
- Thread_Close(&t->thread);
- }
-
- Event_Close(&t->canRead);
- Event_Close(&t->canWrite);
-}
-
-static void MtDec_CloseThreads(CMtDec *p)
-{
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- MtDecThread_CloseThread(&p->threads[i]);
-}
-
-static void MtDecThread_Destruct(CMtDecThread *t)
-{
- MtDecThread_CloseThread(t);
- MtDecThread_FreeInBufs(t);
-}
-
-
-
-static SRes FullRead(ISeqInStream *stream, Byte *data, size_t *processedSize)
-{
- size_t size = *processedSize;
- *processedSize = 0;
- while (size != 0)
- {
- size_t cur = size;
- SRes res = ISeqInStream_Read(stream, data, &cur);
- *processedSize += cur;
- data += cur;
- size -= cur;
- RINOK(res);
- if (cur == 0)
- return SZ_OK;
- }
- return SZ_OK;
-}
-
-
-static SRes MtDec_GetError_Spec(CMtDec *p, UInt64 interruptIndex, BoolInt *wasInterrupted)
-{
- SRes res;
- CriticalSection_Enter(&p->mtProgress.cs);
- *wasInterrupted = (p->needInterrupt && interruptIndex > p->interruptIndex);
- res = p->mtProgress.res;
- CriticalSection_Leave(&p->mtProgress.cs);
- return res;
-}
-
-static SRes MtDec_Progress_GetError_Spec(CMtDec *p, UInt64 inSize, UInt64 outSize, UInt64 interruptIndex, BoolInt *wasInterrupted)
-{
- SRes res;
- CriticalSection_Enter(&p->mtProgress.cs);
-
- p->mtProgress.totalInSize += inSize;
- p->mtProgress.totalOutSize += outSize;
- if (p->mtProgress.res == SZ_OK && p->mtProgress.progress)
- if (ICompressProgress_Progress(p->mtProgress.progress, p->mtProgress.totalInSize, p->mtProgress.totalOutSize) != SZ_OK)
- p->mtProgress.res = SZ_ERROR_PROGRESS;
-
- *wasInterrupted = (p->needInterrupt && interruptIndex > p->interruptIndex);
- res = p->mtProgress.res;
-
- CriticalSection_Leave(&p->mtProgress.cs);
-
- return res;
-}
-
-static void MtDec_Interrupt(CMtDec *p, UInt64 interruptIndex)
-{
- CriticalSection_Enter(&p->mtProgress.cs);
- if (!p->needInterrupt || interruptIndex < p->interruptIndex)
- {
- p->interruptIndex = interruptIndex;
- p->needInterrupt = True;
- }
- CriticalSection_Leave(&p->mtProgress.cs);
-}
-
-Byte *MtDec_GetCrossBuff(CMtDec *p)
-{
- Byte *cr = p->crossBlock;
- if (!cr)
- {
- cr = (Byte *)ISzAlloc_Alloc(p->alloc, MTDEC__LINK_DATA_OFFSET + p->inBufSize);
- if (!cr)
- return NULL;
- p->crossBlock = cr;
- }
- return MTDEC__DATA_PTR_FROM_LINK(cr);
-}
-
-
-/*
- ThreadFunc2() returns:
- 0 - in all normal cases (even for stream error or memory allocation error)
- (!= 0) - WRes error return by system threading function
-*/
-
-// #define MTDEC_ProgessStep (1 << 22)
-#define MTDEC_ProgessStep (1 << 0)
-
-static WRes ThreadFunc2(CMtDecThread *t)
-{
- CMtDec *p = t->mtDec;
-
- PRF_STR_INT("ThreadFunc2", t->index);
-
- // SetThreadAffinityMask(GetCurrentThread(), 1 << t->index);
-
- for (;;)
- {
- SRes res, codeRes;
- BoolInt wasInterrupted, isAllocError, overflow, finish;
- SRes threadingErrorSRes;
- BoolInt needCode, needWrite, needContinue;
-
- size_t inDataSize_Start;
- UInt64 inDataSize;
- // UInt64 inDataSize_Full;
-
- UInt64 blockIndex;
-
- UInt64 inPrev = 0;
- UInt64 outPrev = 0;
- UInt64 inCodePos;
- UInt64 outCodePos;
-
- Byte *afterEndData = NULL;
- size_t afterEndData_Size = 0;
-
- BoolInt canCreateNewThread = False;
- // CMtDecCallbackInfo parse;
- CMtDecThread *nextThread;
-
- PRF_STR_INT("Event_Wait(&t->canRead)", t->index);
-
- RINOK_THREAD(Event_Wait(&t->canRead));
- if (p->exitThread)
- return 0;
-
- PRF_STR_INT("after Event_Wait(&t->canRead)", t->index);
-
- // if (t->index == 3) return 19; // for test
-
- blockIndex = p->blockIndex++;
-
- // PRF(printf("\ncanRead\n"))
-
- res = MtDec_Progress_GetError_Spec(p, 0, 0, blockIndex, &wasInterrupted);
-
- finish = p->readWasFinished;
- needCode = False;
- needWrite = False;
- isAllocError = False;
- overflow = False;
-
- inDataSize_Start = 0;
- inDataSize = 0;
- // inDataSize_Full = 0;
-
- if (res == SZ_OK && !wasInterrupted)
- {
- // if (p->inStream)
- {
- CMtDecBufLink *prev = NULL;
- CMtDecBufLink *link = (CMtDecBufLink *)t->inBuf;
- size_t crossSize = p->crossEnd - p->crossStart;
-
- PRF(printf("\ncrossSize = %d\n", crossSize));
-
- for (;;)
- {
- if (!link)
- {
- link = (CMtDecBufLink *)ISzAlloc_Alloc(p->alloc, MTDEC__LINK_DATA_OFFSET + p->inBufSize);
- if (!link)
- {
- finish = True;
- // p->allocError_for_Read_BlockIndex = blockIndex;
- isAllocError = True;
- break;
- }
- link->next = NULL;
- if (prev)
- {
- // static unsigned g_num = 0;
- // printf("\n%6d : %x", ++g_num, (unsigned)(size_t)((Byte *)link - (Byte *)prev));
- prev->next = link;
- }
- else
- t->inBuf = (void *)link;
- }
-
- {
- Byte *data = MTDEC__DATA_PTR_FROM_LINK(link);
- Byte *parseData = data;
- size_t size;
-
- if (crossSize != 0)
- {
- inDataSize = crossSize;
- // inDataSize_Full = inDataSize;
- inDataSize_Start = crossSize;
- size = crossSize;
- parseData = MTDEC__DATA_PTR_FROM_LINK(p->crossBlock) + p->crossStart;
- PRF(printf("\ncross : crossStart = %7d crossEnd = %7d finish = %1d",
- (int)p->crossStart, (int)p->crossEnd, (int)finish));
- }
- else
- {
- size = p->inBufSize;
-
- res = FullRead(p->inStream, data, &size);
-
- // size = 10; // test
-
- inDataSize += size;
- // inDataSize_Full = inDataSize;
- if (!prev)
- inDataSize_Start = size;
-
- p->readProcessed += size;
- finish = (size != p->inBufSize);
- if (finish)
- p->readWasFinished = True;
-
- // res = E_INVALIDARG; // test
-
- if (res != SZ_OK)
- {
- // PRF(printf("\nRead error = %d\n", res))
- // we want to decode all data before error
- p->readRes = res;
- // p->readError_BlockIndex = blockIndex;
- p->readWasFinished = True;
- finish = True;
- res = SZ_OK;
- // break;
- }
-
- if (inDataSize - inPrev >= MTDEC_ProgessStep)
- {
- res = MtDec_Progress_GetError_Spec(p, 0, 0, blockIndex, &wasInterrupted);
- if (res != SZ_OK || wasInterrupted)
- break;
- inPrev = inDataSize;
- }
- }
-
- {
- CMtDecCallbackInfo parse;
-
- parse.startCall = (prev == NULL);
- parse.src = parseData;
- parse.srcSize = size;
- parse.srcFinished = finish;
- parse.canCreateNewThread = True;
-
- // PRF(printf("\nParse size = %d\n", (unsigned)size))
-
- p->mtCallback->Parse(p->mtCallbackObject, t->index, &parse);
-
- needWrite = True;
- canCreateNewThread = parse.canCreateNewThread;
-
- // printf("\n\n%12I64u %12I64u", (UInt64)p->mtProgress.totalInSize, (UInt64)p->mtProgress.totalOutSize);
-
- if (
- // parseRes != SZ_OK ||
- // inDataSize - (size - parse.srcSize) > p->inBlockMax
- // ||
- parse.state == MTDEC_PARSE_OVERFLOW
- // || wasInterrupted
- )
- {
- // Overflow or Parse error - switch from MT decoding to ST decoding
- finish = True;
- overflow = True;
-
- {
- PRF(printf("\n Overflow"));
- // PRF(printf("\nisBlockFinished = %d", (unsigned)parse.blockWasFinished));
- PRF(printf("\n inDataSize = %d", (unsigned)inDataSize));
- }
-
- if (crossSize != 0)
- memcpy(data, parseData, size);
- p->crossStart = 0;
- p->crossEnd = 0;
- break;
- }
-
- if (crossSize != 0)
- {
- memcpy(data, parseData, parse.srcSize);
- p->crossStart += parse.srcSize;
- }
-
- if (parse.state != MTDEC_PARSE_CONTINUE || finish)
- {
- // we don't need to parse in current thread anymore
-
- if (parse.state == MTDEC_PARSE_END)
- finish = True;
-
- needCode = True;
- // p->crossFinished = finish;
-
- if (parse.srcSize == size)
- {
- // full parsed - no cross transfer
- p->crossStart = 0;
- p->crossEnd = 0;
- break;
- }
-
- if (parse.state == MTDEC_PARSE_END)
- {
- p->crossStart = 0;
- p->crossEnd = 0;
-
- if (crossSize != 0)
- memcpy(data + parse.srcSize, parseData + parse.srcSize, size - parse.srcSize); // we need all data
- afterEndData_Size = size - parse.srcSize;
- afterEndData = parseData + parse.srcSize;
-
- // we reduce data size to required bytes (parsed only)
- inDataSize -= (size - parse.srcSize);
- if (!prev)
- inDataSize_Start = parse.srcSize;
- break;
- }
-
- {
- // partial parsed - need cross transfer
- if (crossSize != 0)
- inDataSize = parse.srcSize; // it's only parsed now
- else
- {
- // partial parsed - is not in initial cross block - we need to copy new data to cross block
- Byte *cr = MtDec_GetCrossBuff(p);
- if (!cr)
- {
- {
- PRF(printf("\ncross alloc error error\n"));
- // res = SZ_ERROR_MEM;
- finish = True;
- // p->allocError_for_Read_BlockIndex = blockIndex;
- isAllocError = True;
- break;
- }
- }
-
- {
- size_t crSize = size - parse.srcSize;
- inDataSize -= crSize;
- p->crossEnd = crSize;
- p->crossStart = 0;
- memcpy(cr, parseData + parse.srcSize, crSize);
- }
- }
-
- // inDataSize_Full = inDataSize;
- if (!prev)
- inDataSize_Start = parse.srcSize; // it's partial size (parsed only)
-
- finish = False;
- break;
- }
- }
-
- if (parse.srcSize != size)
- {
- res = SZ_ERROR_FAIL;
- PRF(printf("\nfinished error SZ_ERROR_FAIL = %d\n", res));
- break;
- }
- }
- }
-
- prev = link;
- link = link->next;
-
- if (crossSize != 0)
- {
- crossSize = 0;
- p->crossStart = 0;
- p->crossEnd = 0;
- }
- }
- }
-
- if (res == SZ_OK)
- res = MtDec_GetError_Spec(p, blockIndex, &wasInterrupted);
- }
-
- codeRes = SZ_OK;
-
- if (res == SZ_OK && needCode && !wasInterrupted)
- {
- codeRes = p->mtCallback->PreCode(p->mtCallbackObject, t->index);
- if (codeRes != SZ_OK)
- {
- needCode = False;
- finish = True;
- // SZ_ERROR_MEM is expected error here.
- // if (codeRes == SZ_ERROR_MEM) - we will try single-thread decoding later.
- // if (codeRes != SZ_ERROR_MEM) - we can stop decoding or try single-thread decoding.
- }
- }
-
- if (res != SZ_OK || wasInterrupted)
- finish = True;
-
- nextThread = NULL;
- threadingErrorSRes = SZ_OK;
-
- if (!finish)
- {
- if (p->numStartedThreads < p->numStartedThreads_Limit && canCreateNewThread)
- {
- SRes res2 = MtDecThread_CreateAndStart(&p->threads[p->numStartedThreads]);
- if (res2 == SZ_OK)
- {
- // if (p->numStartedThreads % 1000 == 0) PRF(printf("\n numStartedThreads=%d\n", p->numStartedThreads));
- p->numStartedThreads++;
- }
- else
- {
- PRF(printf("\nERROR: numStartedThreads=%d\n", p->numStartedThreads));
- if (p->numStartedThreads == 1)
- {
- // if only one thread is possible, we leave muti-threading code
- finish = True;
- needCode = False;
- threadingErrorSRes = res2;
- }
- else
- p->numStartedThreads_Limit = p->numStartedThreads;
- }
- }
-
- if (!finish)
- {
- unsigned nextIndex = t->index + 1;
- nextThread = &p->threads[nextIndex >= p->numStartedThreads ? 0 : nextIndex];
- RINOK_THREAD(Event_Set(&nextThread->canRead))
- // We have started executing for new iteration (with next thread)
- // And that next thread now is responsible for possible exit from decoding (threading_code)
- }
- }
-
- // each call of Event_Set(&nextThread->canRead) must be followed by call of Event_Set(&nextThread->canWrite)
- // if ( !finish ) we must call Event_Set(&nextThread->canWrite) in any case
- // if ( finish ) we switch to single-thread mode and there are 2 ways at the end of current iteration (current block):
- // - if (needContinue) after Write(&needContinue), we restore decoding with new iteration
- // - otherwise we stop decoding and exit from ThreadFunc2()
-
- // Don't change (finish) variable in the further code
-
-
- // ---------- CODE ----------
-
- inPrev = 0;
- outPrev = 0;
- inCodePos = 0;
- outCodePos = 0;
-
- if (res == SZ_OK && needCode && codeRes == SZ_OK)
- {
- BoolInt isStartBlock = True;
- CMtDecBufLink *link = (CMtDecBufLink *)t->inBuf;
-
- for (;;)
- {
- size_t inSize;
- int stop;
-
- if (isStartBlock)
- inSize = inDataSize_Start;
- else
- {
- UInt64 rem = inDataSize - inCodePos;
- inSize = p->inBufSize;
- if (inSize > rem)
- inSize = (size_t)rem;
- }
-
- inCodePos += inSize;
- stop = True;
-
- codeRes = p->mtCallback->Code(p->mtCallbackObject, t->index,
- (const Byte *)MTDEC__DATA_PTR_FROM_LINK(link), inSize,
- (inCodePos == inDataSize), // srcFinished
- &inCodePos, &outCodePos, &stop);
-
- if (codeRes != SZ_OK)
- {
- PRF(printf("\nCode Interrupt error = %x\n", codeRes));
- // we interrupt only later blocks
- MtDec_Interrupt(p, blockIndex);
- break;
- }
-
- if (stop || inCodePos == inDataSize)
- break;
-
- {
- const UInt64 inDelta = inCodePos - inPrev;
- const UInt64 outDelta = outCodePos - outPrev;
- if (inDelta >= MTDEC_ProgessStep || outDelta >= MTDEC_ProgessStep)
- {
- // Sleep(1);
- res = MtDec_Progress_GetError_Spec(p, inDelta, outDelta, blockIndex, &wasInterrupted);
- if (res != SZ_OK || wasInterrupted)
- break;
- inPrev = inCodePos;
- outPrev = outCodePos;
- }
- }
-
- link = link->next;
- isStartBlock = False;
- }
- }
-
-
- // ---------- WRITE ----------
-
- RINOK_THREAD(Event_Wait(&t->canWrite));
-
- {
- BoolInt isErrorMode = False;
- BoolInt canRecode = True;
- BoolInt needWriteToStream = needWrite;
-
- if (p->exitThread) return 0; // it's never executed in normal cases
-
- if (p->wasInterrupted)
- wasInterrupted = True;
- else
- {
- if (codeRes != SZ_OK) // || !needCode // check it !!!
- {
- p->wasInterrupted = True;
- p->codeRes = codeRes;
- if (codeRes == SZ_ERROR_MEM)
- isAllocError = True;
- }
-
- if (threadingErrorSRes)
- {
- p->wasInterrupted = True;
- p->threadingErrorSRes = threadingErrorSRes;
- needWriteToStream = False;
- }
- if (isAllocError)
- {
- p->wasInterrupted = True;
- p->isAllocError = True;
- needWriteToStream = False;
- }
- if (overflow)
- {
- p->wasInterrupted = True;
- p->overflow = True;
- needWriteToStream = False;
- }
- }
-
- if (needCode)
- {
- if (wasInterrupted)
- {
- inCodePos = 0;
- outCodePos = 0;
- }
- {
- const UInt64 inDelta = inCodePos - inPrev;
- const UInt64 outDelta = outCodePos - outPrev;
- // if (inDelta != 0 || outDelta != 0)
- res = MtProgress_ProgressAdd(&p->mtProgress, inDelta, outDelta);
- }
- }
-
- needContinue = (!finish);
-
- // if (res == SZ_OK && needWrite && !wasInterrupted)
- if (needWrite)
- {
- // p->inProcessed += inCodePos;
-
- res = p->mtCallback->Write(p->mtCallbackObject, t->index,
- res == SZ_OK && needWriteToStream && !wasInterrupted, // needWrite
- afterEndData, afterEndData_Size,
- &needContinue,
- &canRecode);
-
- // res= E_INVALIDARG; // for test
-
- PRF(printf("\nAfter Write needContinue = %d\n", (unsigned)needContinue));
- PRF(printf("\nprocessed = %d\n", (unsigned)p->inProcessed));
-
- if (res != SZ_OK)
- {
- PRF(printf("\nWrite error = %d\n", res));
- isErrorMode = True;
- p->wasInterrupted = True;
- }
- if (res != SZ_OK
- || (!needContinue && !finish))
- {
- PRF(printf("\nWrite Interrupt error = %x\n", res));
- MtDec_Interrupt(p, blockIndex);
- }
- }
-
- if (canRecode)
- if (!needCode
- || res != SZ_OK
- || p->wasInterrupted
- || codeRes != SZ_OK
- || wasInterrupted
- || p->numFilledThreads != 0
- || isErrorMode)
- {
- if (p->numFilledThreads == 0)
- p->filledThreadStart = t->index;
- if (inDataSize != 0 || !finish)
- {
- t->inDataSize_Start = inDataSize_Start;
- t->inDataSize = inDataSize;
- p->numFilledThreads++;
- }
- PRF(printf("\np->numFilledThreads = %d\n", p->numFilledThreads));
- PRF(printf("p->filledThreadStart = %d\n", p->filledThreadStart));
- }
-
- if (!finish)
- {
- RINOK_THREAD(Event_Set(&nextThread->canWrite));
- }
- else
- {
- if (needContinue)
- {
- // we restore decoding with new iteration
- RINOK_THREAD(Event_Set(&p->threads[0].canWrite));
- }
- else
- {
- // we exit from decoding
- if (t->index == 0)
- return SZ_OK;
- p->exitThread = True;
- }
- RINOK_THREAD(Event_Set(&p->threads[0].canRead));
- }
- }
- }
-}
-
-#ifdef _WIN32
-#define USE_ALLOCA
-#endif
-
-#ifdef USE_ALLOCA
-#ifdef _WIN32
-#include <malloc.h>
-#else
-#include <stdlib.h>
-#endif
-#endif
-
-
-static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc1(void *pp)
-{
- WRes res;
-
- CMtDecThread *t = (CMtDecThread *)pp;
- CMtDec *p;
-
- // fprintf(stdout, "\n%d = %p\n", t->index, &t);
-
- res = ThreadFunc2(t);
- p = t->mtDec;
- if (res == 0)
- return p->exitThreadWRes;
- {
- // it's unexpected situation for some threading function error
- if (p->exitThreadWRes == 0)
- p->exitThreadWRes = res;
- PRF(printf("\nthread exit error = %d\n", res));
- p->exitThread = True;
- Event_Set(&p->threads[0].canRead);
- Event_Set(&p->threads[0].canWrite);
- MtProgress_SetError(&p->mtProgress, MY_SRes_HRESULT_FROM_WRes(res));
- }
- return res;
-}
-
-static MY_NO_INLINE THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp)
-{
- CMtDecThread *t = (CMtDecThread *)pp;
-
- // fprintf(stderr, "\n%d = %p - before", t->index, &t);
- #ifdef USE_ALLOCA
- t->allocaPtr = alloca(t->index * 128);
- #endif
- return ThreadFunc1(pp);
-}
-
-
-int MtDec_PrepareRead(CMtDec *p)
-{
- if (p->crossBlock && p->crossStart == p->crossEnd)
- {
- ISzAlloc_Free(p->alloc, p->crossBlock);
- p->crossBlock = NULL;
- }
-
- {
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- if (i > p->numStartedThreads
- || p->numFilledThreads <=
- (i >= p->filledThreadStart ?
- i - p->filledThreadStart :
- i + p->numStartedThreads - p->filledThreadStart))
- MtDecThread_FreeInBufs(&p->threads[i]);
- }
-
- return (p->numFilledThreads != 0) || (p->crossStart != p->crossEnd);
-}
-
-
-const Byte *MtDec_Read(CMtDec *p, size_t *inLim)
-{
- while (p->numFilledThreads != 0)
- {
- CMtDecThread *t = &p->threads[p->filledThreadStart];
-
- if (*inLim != 0)
- {
- {
- void *link = t->inBuf;
- void *next = ((CMtDecBufLink *)link)->next;
- ISzAlloc_Free(p->alloc, link);
- t->inBuf = next;
- }
-
- if (t->inDataSize == 0)
- {
- MtDecThread_FreeInBufs(t);
- if (--p->numFilledThreads == 0)
- break;
- if (++p->filledThreadStart == p->numStartedThreads)
- p->filledThreadStart = 0;
- t = &p->threads[p->filledThreadStart];
- }
- }
-
- {
- size_t lim = t->inDataSize_Start;
- if (lim != 0)
- t->inDataSize_Start = 0;
- else
- {
- UInt64 rem = t->inDataSize;
- lim = p->inBufSize;
- if (lim > rem)
- lim = (size_t)rem;
- }
- t->inDataSize -= lim;
- *inLim = lim;
- return (const Byte *)MTDEC__DATA_PTR_FROM_LINK(t->inBuf);
- }
- }
-
- {
- size_t crossSize = p->crossEnd - p->crossStart;
- if (crossSize != 0)
- {
- const Byte *data = MTDEC__DATA_PTR_FROM_LINK(p->crossBlock) + p->crossStart;
- *inLim = crossSize;
- p->crossStart = 0;
- p->crossEnd = 0;
- return data;
- }
- *inLim = 0;
- if (p->crossBlock)
- {
- ISzAlloc_Free(p->alloc, p->crossBlock);
- p->crossBlock = NULL;
- }
- return NULL;
- }
-}
-
-
-void MtDec_Construct(CMtDec *p)
-{
- unsigned i;
-
- p->inBufSize = (size_t)1 << 18;
-
- p->numThreadsMax = 0;
-
- p->inStream = NULL;
-
- // p->inData = NULL;
- // p->inDataSize = 0;
-
- p->crossBlock = NULL;
- p->crossStart = 0;
- p->crossEnd = 0;
-
- p->numFilledThreads = 0;
-
- p->progress = NULL;
- p->alloc = NULL;
-
- p->mtCallback = NULL;
- p->mtCallbackObject = NULL;
-
- p->allocatedBufsSize = 0;
-
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CMtDecThread *t = &p->threads[i];
- t->mtDec = p;
- t->index = i;
- t->inBuf = NULL;
- Event_Construct(&t->canRead);
- Event_Construct(&t->canWrite);
- Thread_Construct(&t->thread);
- }
-
- // Event_Construct(&p->finishedEvent);
-
- CriticalSection_Init(&p->mtProgress.cs);
-}
-
-
-static void MtDec_Free(CMtDec *p)
-{
- unsigned i;
-
- p->exitThread = True;
-
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- MtDecThread_Destruct(&p->threads[i]);
-
- // Event_Close(&p->finishedEvent);
-
- if (p->crossBlock)
- {
- ISzAlloc_Free(p->alloc, p->crossBlock);
- p->crossBlock = NULL;
- }
-}
-
-
-void MtDec_Destruct(CMtDec *p)
-{
- MtDec_Free(p);
-
- CriticalSection_Delete(&p->mtProgress.cs);
-}
-
-
-SRes MtDec_Code(CMtDec *p)
-{
- unsigned i;
-
- p->inProcessed = 0;
-
- p->blockIndex = 1; // it must be larger than not_defined index (0)
- p->isAllocError = False;
- p->overflow = False;
- p->threadingErrorSRes = SZ_OK;
-
- p->needContinue = True;
-
- p->readWasFinished = False;
- p->needInterrupt = False;
- p->interruptIndex = (UInt64)(Int64)-1;
-
- p->readProcessed = 0;
- p->readRes = SZ_OK;
- p->codeRes = SZ_OK;
- p->wasInterrupted = False;
-
- p->crossStart = 0;
- p->crossEnd = 0;
-
- p->filledThreadStart = 0;
- p->numFilledThreads = 0;
-
- {
- unsigned numThreads = p->numThreadsMax;
- if (numThreads > MTDEC__THREADS_MAX)
- numThreads = MTDEC__THREADS_MAX;
- p->numStartedThreads_Limit = numThreads;
- p->numStartedThreads = 0;
- }
-
- if (p->inBufSize != p->allocatedBufsSize)
- {
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CMtDecThread *t = &p->threads[i];
- if (t->inBuf)
- MtDecThread_FreeInBufs(t);
- }
- if (p->crossBlock)
- {
- ISzAlloc_Free(p->alloc, p->crossBlock);
- p->crossBlock = NULL;
- }
-
- p->allocatedBufsSize = p->inBufSize;
- }
-
- MtProgress_Init(&p->mtProgress, p->progress);
-
- // RINOK_THREAD(ArEvent_OptCreate_And_Reset(&p->finishedEvent));
- p->exitThread = False;
- p->exitThreadWRes = 0;
-
- {
- WRes wres;
- WRes sres;
- CMtDecThread *nextThread = &p->threads[p->numStartedThreads++];
- // wres = MtDecThread_CreateAndStart(nextThread);
- wres = MtDecThread_CreateEvents(nextThread);
- if (wres == 0) { wres = Event_Set(&nextThread->canWrite);
- if (wres == 0) { wres = Event_Set(&nextThread->canRead);
- if (wres == 0) { wres = ThreadFunc(nextThread);
- if (wres != 0)
- {
- p->needContinue = False;
- MtDec_CloseThreads(p);
- }}}}
-
- // wres = 17; // for test
- // wres = Event_Wait(&p->finishedEvent);
-
- sres = MY_SRes_HRESULT_FROM_WRes(wres);
-
- if (sres != 0)
- p->threadingErrorSRes = sres;
-
- if (
- // wres == 0
- // wres != 0
- // || p->mtc.codeRes == SZ_ERROR_MEM
- p->isAllocError
- || p->threadingErrorSRes != SZ_OK
- || p->overflow)
- {
- // p->needContinue = True;
- }
- else
- p->needContinue = False;
-
- if (p->needContinue)
- return SZ_OK;
-
- // if (sres != SZ_OK)
- return sres;
- // return E_FAIL;
- }
-}
-
-#endif
+/* MtDec.c -- Multi-thread Decoder
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+// #define SHOW_DEBUG_INFO
+
+// #include <stdio.h>
+#include <string.h>
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "MtDec.h"
+
+#ifndef Z7_ST
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
+
+void MtProgress_Init(CMtProgress *p, ICompressProgressPtr progress)
+{
+ p->progress = progress;
+ p->res = SZ_OK;
+ p->totalInSize = 0;
+ p->totalOutSize = 0;
+}
+
+
+SRes MtProgress_Progress_ST(CMtProgress *p)
+{
+ if (p->res == SZ_OK && p->progress)
+ if (ICompressProgress_Progress(p->progress, p->totalInSize, p->totalOutSize) != SZ_OK)
+ p->res = SZ_ERROR_PROGRESS;
+ return p->res;
+}
+
+
+SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize)
+{
+ SRes res;
+ CriticalSection_Enter(&p->cs);
+
+ p->totalInSize += inSize;
+ p->totalOutSize += outSize;
+ if (p->res == SZ_OK && p->progress)
+ if (ICompressProgress_Progress(p->progress, p->totalInSize, p->totalOutSize) != SZ_OK)
+ p->res = SZ_ERROR_PROGRESS;
+ res = p->res;
+
+ CriticalSection_Leave(&p->cs);
+ return res;
+}
+
+
+SRes MtProgress_GetError(CMtProgress *p)
+{
+ SRes res;
+ CriticalSection_Enter(&p->cs);
+ res = p->res;
+ CriticalSection_Leave(&p->cs);
+ return res;
+}
+
+
+void MtProgress_SetError(CMtProgress *p, SRes res)
+{
+ CriticalSection_Enter(&p->cs);
+ if (p->res == SZ_OK)
+ p->res = res;
+ CriticalSection_Leave(&p->cs);
+}
+
+
+#define RINOK_THREAD(x) RINOK_WRes(x)
+
+
+struct CMtDecBufLink_
+{
+ struct CMtDecBufLink_ *next;
+ void *pad[3];
+};
+
+typedef struct CMtDecBufLink_ CMtDecBufLink;
+
+#define MTDEC__LINK_DATA_OFFSET sizeof(CMtDecBufLink)
+#define MTDEC__DATA_PTR_FROM_LINK(link) ((Byte *)(link) + MTDEC__LINK_DATA_OFFSET)
+
+
+
+static THREAD_FUNC_DECL MtDec_ThreadFunc(void *pp);
+
+
+static WRes MtDecThread_CreateEvents(CMtDecThread *t)
+{
+ WRes wres = AutoResetEvent_OptCreate_And_Reset(&t->canWrite);
+ if (wres == 0)
+ {
+ wres = AutoResetEvent_OptCreate_And_Reset(&t->canRead);
+ if (wres == 0)
+ return SZ_OK;
+ }
+ return wres;
+}
+
+
+static SRes MtDecThread_CreateAndStart(CMtDecThread *t)
+{
+ WRes wres = MtDecThread_CreateEvents(t);
+ // wres = 17; // for test
+ if (wres == 0)
+ {
+ if (Thread_WasCreated(&t->thread))
+ return SZ_OK;
+ wres = Thread_Create(&t->thread, MtDec_ThreadFunc, t);
+ if (wres == 0)
+ return SZ_OK;
+ }
+ return MY_SRes_HRESULT_FROM_WRes(wres);
+}
+
+
+void MtDecThread_FreeInBufs(CMtDecThread *t)
+{
+ if (t->inBuf)
+ {
+ void *link = t->inBuf;
+ t->inBuf = NULL;
+ do
+ {
+ void *next = ((CMtDecBufLink *)link)->next;
+ ISzAlloc_Free(t->mtDec->alloc, link);
+ link = next;
+ }
+ while (link);
+ }
+}
+
+
+static void MtDecThread_CloseThread(CMtDecThread *t)
+{
+ if (Thread_WasCreated(&t->thread))
+ {
+ Event_Set(&t->canWrite); /* we can disable it. There are no threads waiting canWrite in normal cases */
+ Event_Set(&t->canRead);
+ Thread_Wait_Close(&t->thread);
+ }
+
+ Event_Close(&t->canRead);
+ Event_Close(&t->canWrite);
+}
+
+static void MtDec_CloseThreads(CMtDec *p)
+{
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ MtDecThread_CloseThread(&p->threads[i]);
+}
+
+static void MtDecThread_Destruct(CMtDecThread *t)
+{
+ MtDecThread_CloseThread(t);
+ MtDecThread_FreeInBufs(t);
+}
+
+
+
+static SRes MtDec_GetError_Spec(CMtDec *p, UInt64 interruptIndex, BoolInt *wasInterrupted)
+{
+ SRes res;
+ CriticalSection_Enter(&p->mtProgress.cs);
+ *wasInterrupted = (p->needInterrupt && interruptIndex > p->interruptIndex);
+ res = p->mtProgress.res;
+ CriticalSection_Leave(&p->mtProgress.cs);
+ return res;
+}
+
+static SRes MtDec_Progress_GetError_Spec(CMtDec *p, UInt64 inSize, UInt64 outSize, UInt64 interruptIndex, BoolInt *wasInterrupted)
+{
+ SRes res;
+ CriticalSection_Enter(&p->mtProgress.cs);
+
+ p->mtProgress.totalInSize += inSize;
+ p->mtProgress.totalOutSize += outSize;
+ if (p->mtProgress.res == SZ_OK && p->mtProgress.progress)
+ if (ICompressProgress_Progress(p->mtProgress.progress, p->mtProgress.totalInSize, p->mtProgress.totalOutSize) != SZ_OK)
+ p->mtProgress.res = SZ_ERROR_PROGRESS;
+
+ *wasInterrupted = (p->needInterrupt && interruptIndex > p->interruptIndex);
+ res = p->mtProgress.res;
+
+ CriticalSection_Leave(&p->mtProgress.cs);
+
+ return res;
+}
+
+static void MtDec_Interrupt(CMtDec *p, UInt64 interruptIndex)
+{
+ CriticalSection_Enter(&p->mtProgress.cs);
+ if (!p->needInterrupt || interruptIndex < p->interruptIndex)
+ {
+ p->interruptIndex = interruptIndex;
+ p->needInterrupt = True;
+ }
+ CriticalSection_Leave(&p->mtProgress.cs);
+}
+
+Byte *MtDec_GetCrossBuff(CMtDec *p)
+{
+ Byte *cr = p->crossBlock;
+ if (!cr)
+ {
+ cr = (Byte *)ISzAlloc_Alloc(p->alloc, MTDEC__LINK_DATA_OFFSET + p->inBufSize);
+ if (!cr)
+ return NULL;
+ p->crossBlock = cr;
+ }
+ return MTDEC__DATA_PTR_FROM_LINK(cr);
+}
+
+
+/*
+ MtDec_ThreadFunc2() returns:
+ 0 - in all normal cases (even for stream error or memory allocation error)
+ (!= 0) - WRes error return by system threading function
+*/
+
+// #define MTDEC_ProgessStep (1 << 22)
+#define MTDEC_ProgessStep (1 << 0)
+
+static WRes MtDec_ThreadFunc2(CMtDecThread *t)
+{
+ CMtDec *p = t->mtDec;
+
+ PRF_STR_INT("MtDec_ThreadFunc2", t->index)
+
+ // SetThreadAffinityMask(GetCurrentThread(), 1 << t->index);
+
+ for (;;)
+ {
+ SRes res, codeRes;
+ BoolInt wasInterrupted, isAllocError, overflow, finish;
+ SRes threadingErrorSRes;
+ BoolInt needCode, needWrite, needContinue;
+
+ size_t inDataSize_Start;
+ UInt64 inDataSize;
+ // UInt64 inDataSize_Full;
+
+ UInt64 blockIndex;
+
+ UInt64 inPrev = 0;
+ UInt64 outPrev = 0;
+ UInt64 inCodePos;
+ UInt64 outCodePos;
+
+ Byte *afterEndData = NULL;
+ size_t afterEndData_Size = 0;
+ BoolInt afterEndData_IsCross = False;
+
+ BoolInt canCreateNewThread = False;
+ // CMtDecCallbackInfo parse;
+ CMtDecThread *nextThread;
+
+ PRF_STR_INT("=============== Event_Wait(&t->canRead)", t->index)
+
+ RINOK_THREAD(Event_Wait(&t->canRead))
+ if (p->exitThread)
+ return 0;
+
+ PRF_STR_INT("after Event_Wait(&t->canRead)", t->index)
+
+ // if (t->index == 3) return 19; // for test
+
+ blockIndex = p->blockIndex++;
+
+ // PRF(printf("\ncanRead\n"))
+
+ res = MtDec_Progress_GetError_Spec(p, 0, 0, blockIndex, &wasInterrupted);
+
+ finish = p->readWasFinished;
+ needCode = False;
+ needWrite = False;
+ isAllocError = False;
+ overflow = False;
+
+ inDataSize_Start = 0;
+ inDataSize = 0;
+ // inDataSize_Full = 0;
+
+ if (res == SZ_OK && !wasInterrupted)
+ {
+ // if (p->inStream)
+ {
+ CMtDecBufLink *prev = NULL;
+ CMtDecBufLink *link = (CMtDecBufLink *)t->inBuf;
+ size_t crossSize = p->crossEnd - p->crossStart;
+
+ PRF(printf("\ncrossSize = %d\n", crossSize));
+
+ for (;;)
+ {
+ if (!link)
+ {
+ link = (CMtDecBufLink *)ISzAlloc_Alloc(p->alloc, MTDEC__LINK_DATA_OFFSET + p->inBufSize);
+ if (!link)
+ {
+ finish = True;
+ // p->allocError_for_Read_BlockIndex = blockIndex;
+ isAllocError = True;
+ break;
+ }
+ link->next = NULL;
+ if (prev)
+ {
+ // static unsigned g_num = 0;
+ // printf("\n%6d : %x", ++g_num, (unsigned)(size_t)((Byte *)link - (Byte *)prev));
+ prev->next = link;
+ }
+ else
+ t->inBuf = (void *)link;
+ }
+
+ {
+ Byte *data = MTDEC__DATA_PTR_FROM_LINK(link);
+ Byte *parseData = data;
+ size_t size;
+
+ if (crossSize != 0)
+ {
+ inDataSize = crossSize;
+ // inDataSize_Full = inDataSize;
+ inDataSize_Start = crossSize;
+ size = crossSize;
+ parseData = MTDEC__DATA_PTR_FROM_LINK(p->crossBlock) + p->crossStart;
+ PRF(printf("\ncross : crossStart = %7d crossEnd = %7d finish = %1d",
+ (int)p->crossStart, (int)p->crossEnd, (int)finish));
+ }
+ else
+ {
+ size = p->inBufSize;
+
+ res = SeqInStream_ReadMax(p->inStream, data, &size);
+
+ // size = 10; // test
+
+ inDataSize += size;
+ // inDataSize_Full = inDataSize;
+ if (!prev)
+ inDataSize_Start = size;
+
+ p->readProcessed += size;
+ finish = (size != p->inBufSize);
+ if (finish)
+ p->readWasFinished = True;
+
+ // res = E_INVALIDARG; // test
+
+ if (res != SZ_OK)
+ {
+ // PRF(printf("\nRead error = %d\n", res))
+ // we want to decode all data before error
+ p->readRes = res;
+ // p->readError_BlockIndex = blockIndex;
+ p->readWasFinished = True;
+ finish = True;
+ res = SZ_OK;
+ // break;
+ }
+
+ if (inDataSize - inPrev >= MTDEC_ProgessStep)
+ {
+ res = MtDec_Progress_GetError_Spec(p, 0, 0, blockIndex, &wasInterrupted);
+ if (res != SZ_OK || wasInterrupted)
+ break;
+ inPrev = inDataSize;
+ }
+ }
+
+ {
+ CMtDecCallbackInfo parse;
+
+ parse.startCall = (prev == NULL);
+ parse.src = parseData;
+ parse.srcSize = size;
+ parse.srcFinished = finish;
+ parse.canCreateNewThread = True;
+
+ PRF(printf("\nParse size = %d\n", (unsigned)size));
+
+ p->mtCallback->Parse(p->mtCallbackObject, t->index, &parse);
+
+ PRF(printf(" Parse processed = %d, state = %d \n", (unsigned)parse.srcSize, (unsigned)parse.state));
+
+ needWrite = True;
+ canCreateNewThread = parse.canCreateNewThread;
+
+ // printf("\n\n%12I64u %12I64u", (UInt64)p->mtProgress.totalInSize, (UInt64)p->mtProgress.totalOutSize);
+
+ if (
+ // parseRes != SZ_OK ||
+ // inDataSize - (size - parse.srcSize) > p->inBlockMax
+ // ||
+ parse.state == MTDEC_PARSE_OVERFLOW
+ // || wasInterrupted
+ )
+ {
+ // Overflow or Parse error - switch from MT decoding to ST decoding
+ finish = True;
+ overflow = True;
+
+ {
+ PRF(printf("\n Overflow"));
+ // PRF(printf("\nisBlockFinished = %d", (unsigned)parse.blockWasFinished));
+ PRF(printf("\n inDataSize = %d", (unsigned)inDataSize));
+ }
+
+ if (crossSize != 0)
+ memcpy(data, parseData, size);
+ p->crossStart = 0;
+ p->crossEnd = 0;
+ break;
+ }
+
+ if (crossSize != 0)
+ {
+ memcpy(data, parseData, parse.srcSize);
+ p->crossStart += parse.srcSize;
+ }
+
+ if (parse.state != MTDEC_PARSE_CONTINUE || finish)
+ {
+ // we don't need to parse in current thread anymore
+
+ if (parse.state == MTDEC_PARSE_END)
+ finish = True;
+
+ needCode = True;
+ // p->crossFinished = finish;
+
+ if (parse.srcSize == size)
+ {
+ // full parsed - no cross transfer
+ p->crossStart = 0;
+ p->crossEnd = 0;
+ break;
+ }
+
+ if (parse.state == MTDEC_PARSE_END)
+ {
+ afterEndData = parseData + parse.srcSize;
+ afterEndData_Size = size - parse.srcSize;
+ if (crossSize != 0)
+ afterEndData_IsCross = True;
+ // we reduce data size to required bytes (parsed only)
+ inDataSize -= afterEndData_Size;
+ if (!prev)
+ inDataSize_Start = parse.srcSize;
+ break;
+ }
+
+ {
+ // partial parsed - need cross transfer
+ if (crossSize != 0)
+ inDataSize = parse.srcSize; // it's only parsed now
+ else
+ {
+ // partial parsed - is not in initial cross block - we need to copy new data to cross block
+ Byte *cr = MtDec_GetCrossBuff(p);
+ if (!cr)
+ {
+ {
+ PRF(printf("\ncross alloc error error\n"));
+ // res = SZ_ERROR_MEM;
+ finish = True;
+ // p->allocError_for_Read_BlockIndex = blockIndex;
+ isAllocError = True;
+ break;
+ }
+ }
+
+ {
+ size_t crSize = size - parse.srcSize;
+ inDataSize -= crSize;
+ p->crossEnd = crSize;
+ p->crossStart = 0;
+ memcpy(cr, parseData + parse.srcSize, crSize);
+ }
+ }
+
+ // inDataSize_Full = inDataSize;
+ if (!prev)
+ inDataSize_Start = parse.srcSize; // it's partial size (parsed only)
+
+ finish = False;
+ break;
+ }
+ }
+
+ if (parse.srcSize != size)
+ {
+ res = SZ_ERROR_FAIL;
+ PRF(printf("\nfinished error SZ_ERROR_FAIL = %d\n", res));
+ break;
+ }
+ }
+ }
+
+ prev = link;
+ link = link->next;
+
+ if (crossSize != 0)
+ {
+ crossSize = 0;
+ p->crossStart = 0;
+ p->crossEnd = 0;
+ }
+ }
+ }
+
+ if (res == SZ_OK)
+ res = MtDec_GetError_Spec(p, blockIndex, &wasInterrupted);
+ }
+
+ codeRes = SZ_OK;
+
+ if (res == SZ_OK && needCode && !wasInterrupted)
+ {
+ codeRes = p->mtCallback->PreCode(p->mtCallbackObject, t->index);
+ if (codeRes != SZ_OK)
+ {
+ needCode = False;
+ finish = True;
+ // SZ_ERROR_MEM is expected error here.
+ // if (codeRes == SZ_ERROR_MEM) - we will try single-thread decoding later.
+ // if (codeRes != SZ_ERROR_MEM) - we can stop decoding or try single-thread decoding.
+ }
+ }
+
+ if (res != SZ_OK || wasInterrupted)
+ finish = True;
+
+ nextThread = NULL;
+ threadingErrorSRes = SZ_OK;
+
+ if (!finish)
+ {
+ if (p->numStartedThreads < p->numStartedThreads_Limit && canCreateNewThread)
+ {
+ SRes res2 = MtDecThread_CreateAndStart(&p->threads[p->numStartedThreads]);
+ if (res2 == SZ_OK)
+ {
+ // if (p->numStartedThreads % 1000 == 0) PRF(printf("\n numStartedThreads=%d\n", p->numStartedThreads));
+ p->numStartedThreads++;
+ }
+ else
+ {
+ PRF(printf("\nERROR: numStartedThreads=%d\n", p->numStartedThreads));
+ if (p->numStartedThreads == 1)
+ {
+ // if only one thread is possible, we leave muti-threading code
+ finish = True;
+ needCode = False;
+ threadingErrorSRes = res2;
+ }
+ else
+ p->numStartedThreads_Limit = p->numStartedThreads;
+ }
+ }
+
+ if (!finish)
+ {
+ unsigned nextIndex = t->index + 1;
+ nextThread = &p->threads[nextIndex >= p->numStartedThreads ? 0 : nextIndex];
+ RINOK_THREAD(Event_Set(&nextThread->canRead))
+ // We have started executing for new iteration (with next thread)
+ // And that next thread now is responsible for possible exit from decoding (threading_code)
+ }
+ }
+
+ // each call of Event_Set(&nextThread->canRead) must be followed by call of Event_Set(&nextThread->canWrite)
+ // if ( !finish ) we must call Event_Set(&nextThread->canWrite) in any case
+ // if ( finish ) we switch to single-thread mode and there are 2 ways at the end of current iteration (current block):
+ // - if (needContinue) after Write(&needContinue), we restore decoding with new iteration
+ // - otherwise we stop decoding and exit from MtDec_ThreadFunc2()
+
+ // Don't change (finish) variable in the further code
+
+
+ // ---------- CODE ----------
+
+ inPrev = 0;
+ outPrev = 0;
+ inCodePos = 0;
+ outCodePos = 0;
+
+ if (res == SZ_OK && needCode && codeRes == SZ_OK)
+ {
+ BoolInt isStartBlock = True;
+ CMtDecBufLink *link = (CMtDecBufLink *)t->inBuf;
+
+ for (;;)
+ {
+ size_t inSize;
+ int stop;
+
+ if (isStartBlock)
+ inSize = inDataSize_Start;
+ else
+ {
+ UInt64 rem = inDataSize - inCodePos;
+ inSize = p->inBufSize;
+ if (inSize > rem)
+ inSize = (size_t)rem;
+ }
+
+ inCodePos += inSize;
+ stop = True;
+
+ codeRes = p->mtCallback->Code(p->mtCallbackObject, t->index,
+ (const Byte *)MTDEC__DATA_PTR_FROM_LINK(link), inSize,
+ (inCodePos == inDataSize), // srcFinished
+ &inCodePos, &outCodePos, &stop);
+
+ if (codeRes != SZ_OK)
+ {
+ PRF(printf("\nCode Interrupt error = %x\n", codeRes));
+ // we interrupt only later blocks
+ MtDec_Interrupt(p, blockIndex);
+ break;
+ }
+
+ if (stop || inCodePos == inDataSize)
+ break;
+
+ {
+ const UInt64 inDelta = inCodePos - inPrev;
+ const UInt64 outDelta = outCodePos - outPrev;
+ if (inDelta >= MTDEC_ProgessStep || outDelta >= MTDEC_ProgessStep)
+ {
+ // Sleep(1);
+ res = MtDec_Progress_GetError_Spec(p, inDelta, outDelta, blockIndex, &wasInterrupted);
+ if (res != SZ_OK || wasInterrupted)
+ break;
+ inPrev = inCodePos;
+ outPrev = outCodePos;
+ }
+ }
+
+ link = link->next;
+ isStartBlock = False;
+ }
+ }
+
+
+ // ---------- WRITE ----------
+
+ RINOK_THREAD(Event_Wait(&t->canWrite))
+
+ {
+ BoolInt isErrorMode = False;
+ BoolInt canRecode = True;
+ BoolInt needWriteToStream = needWrite;
+
+ if (p->exitThread) return 0; // it's never executed in normal cases
+
+ if (p->wasInterrupted)
+ wasInterrupted = True;
+ else
+ {
+ if (codeRes != SZ_OK) // || !needCode // check it !!!
+ {
+ p->wasInterrupted = True;
+ p->codeRes = codeRes;
+ if (codeRes == SZ_ERROR_MEM)
+ isAllocError = True;
+ }
+
+ if (threadingErrorSRes)
+ {
+ p->wasInterrupted = True;
+ p->threadingErrorSRes = threadingErrorSRes;
+ needWriteToStream = False;
+ }
+ if (isAllocError)
+ {
+ p->wasInterrupted = True;
+ p->isAllocError = True;
+ needWriteToStream = False;
+ }
+ if (overflow)
+ {
+ p->wasInterrupted = True;
+ p->overflow = True;
+ needWriteToStream = False;
+ }
+ }
+
+ if (needCode)
+ {
+ if (wasInterrupted)
+ {
+ inCodePos = 0;
+ outCodePos = 0;
+ }
+ {
+ const UInt64 inDelta = inCodePos - inPrev;
+ const UInt64 outDelta = outCodePos - outPrev;
+ // if (inDelta != 0 || outDelta != 0)
+ res = MtProgress_ProgressAdd(&p->mtProgress, inDelta, outDelta);
+ }
+ }
+
+ needContinue = (!finish);
+
+ // if (res == SZ_OK && needWrite && !wasInterrupted)
+ if (needWrite)
+ {
+ // p->inProcessed += inCodePos;
+
+ PRF(printf("\n--Write afterSize = %d\n", (unsigned)afterEndData_Size));
+
+ res = p->mtCallback->Write(p->mtCallbackObject, t->index,
+ res == SZ_OK && needWriteToStream && !wasInterrupted, // needWrite
+ afterEndData, afterEndData_Size, afterEndData_IsCross,
+ &needContinue,
+ &canRecode);
+
+ // res = SZ_ERROR_FAIL; // for test
+
+ PRF(printf("\nAfter Write needContinue = %d\n", (unsigned)needContinue));
+ PRF(printf("\nprocessed = %d\n", (unsigned)p->inProcessed));
+
+ if (res != SZ_OK)
+ {
+ PRF(printf("\nWrite error = %d\n", res));
+ isErrorMode = True;
+ p->wasInterrupted = True;
+ }
+ if (res != SZ_OK
+ || (!needContinue && !finish))
+ {
+ PRF(printf("\nWrite Interrupt error = %x\n", res));
+ MtDec_Interrupt(p, blockIndex);
+ }
+ }
+
+ if (canRecode)
+ if (!needCode
+ || res != SZ_OK
+ || p->wasInterrupted
+ || codeRes != SZ_OK
+ || wasInterrupted
+ || p->numFilledThreads != 0
+ || isErrorMode)
+ {
+ if (p->numFilledThreads == 0)
+ p->filledThreadStart = t->index;
+ if (inDataSize != 0 || !finish)
+ {
+ t->inDataSize_Start = inDataSize_Start;
+ t->inDataSize = inDataSize;
+ p->numFilledThreads++;
+ }
+ PRF(printf("\np->numFilledThreads = %d\n", p->numFilledThreads));
+ PRF(printf("p->filledThreadStart = %d\n", p->filledThreadStart));
+ }
+
+ if (!finish)
+ {
+ RINOK_THREAD(Event_Set(&nextThread->canWrite))
+ }
+ else
+ {
+ if (needContinue)
+ {
+ // we restore decoding with new iteration
+ RINOK_THREAD(Event_Set(&p->threads[0].canWrite))
+ }
+ else
+ {
+ // we exit from decoding
+ if (t->index == 0)
+ return SZ_OK;
+ p->exitThread = True;
+ }
+ RINOK_THREAD(Event_Set(&p->threads[0].canRead))
+ }
+ }
+ }
+}
+
+#ifdef _WIN32
+#define USE_ALLOCA
+#endif
+
+#ifdef USE_ALLOCA
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <stdlib.h>
+#endif
+#endif
+
+
+static THREAD_FUNC_DECL MtDec_ThreadFunc1(void *pp)
+{
+ WRes res;
+
+ CMtDecThread *t = (CMtDecThread *)pp;
+ CMtDec *p;
+
+ // fprintf(stdout, "\n%d = %p\n", t->index, &t);
+
+ res = MtDec_ThreadFunc2(t);
+ p = t->mtDec;
+ if (res == 0)
+ return (THREAD_FUNC_RET_TYPE)(UINT_PTR)p->exitThreadWRes;
+ {
+ // it's unexpected situation for some threading function error
+ if (p->exitThreadWRes == 0)
+ p->exitThreadWRes = res;
+ PRF(printf("\nthread exit error = %d\n", res));
+ p->exitThread = True;
+ Event_Set(&p->threads[0].canRead);
+ Event_Set(&p->threads[0].canWrite);
+ MtProgress_SetError(&p->mtProgress, MY_SRes_HRESULT_FROM_WRes(res));
+ }
+ return (THREAD_FUNC_RET_TYPE)(UINT_PTR)res;
+}
+
+static Z7_NO_INLINE THREAD_FUNC_DECL MtDec_ThreadFunc(void *pp)
+{
+ #ifdef USE_ALLOCA
+ CMtDecThread *t = (CMtDecThread *)pp;
+ // fprintf(stderr, "\n%d = %p - before", t->index, &t);
+ t->allocaPtr = alloca(t->index * 128);
+ #endif
+ return MtDec_ThreadFunc1(pp);
+}
+
+
+int MtDec_PrepareRead(CMtDec *p)
+{
+ if (p->crossBlock && p->crossStart == p->crossEnd)
+ {
+ ISzAlloc_Free(p->alloc, p->crossBlock);
+ p->crossBlock = NULL;
+ }
+
+ {
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ if (i > p->numStartedThreads
+ || p->numFilledThreads <=
+ (i >= p->filledThreadStart ?
+ i - p->filledThreadStart :
+ i + p->numStartedThreads - p->filledThreadStart))
+ MtDecThread_FreeInBufs(&p->threads[i]);
+ }
+
+ return (p->numFilledThreads != 0) || (p->crossStart != p->crossEnd);
+}
+
+
+const Byte *MtDec_Read(CMtDec *p, size_t *inLim)
+{
+ while (p->numFilledThreads != 0)
+ {
+ CMtDecThread *t = &p->threads[p->filledThreadStart];
+
+ if (*inLim != 0)
+ {
+ {
+ void *link = t->inBuf;
+ void *next = ((CMtDecBufLink *)link)->next;
+ ISzAlloc_Free(p->alloc, link);
+ t->inBuf = next;
+ }
+
+ if (t->inDataSize == 0)
+ {
+ MtDecThread_FreeInBufs(t);
+ if (--p->numFilledThreads == 0)
+ break;
+ if (++p->filledThreadStart == p->numStartedThreads)
+ p->filledThreadStart = 0;
+ t = &p->threads[p->filledThreadStart];
+ }
+ }
+
+ {
+ size_t lim = t->inDataSize_Start;
+ if (lim != 0)
+ t->inDataSize_Start = 0;
+ else
+ {
+ UInt64 rem = t->inDataSize;
+ lim = p->inBufSize;
+ if (lim > rem)
+ lim = (size_t)rem;
+ }
+ t->inDataSize -= lim;
+ *inLim = lim;
+ return (const Byte *)MTDEC__DATA_PTR_FROM_LINK(t->inBuf);
+ }
+ }
+
+ {
+ size_t crossSize = p->crossEnd - p->crossStart;
+ if (crossSize != 0)
+ {
+ const Byte *data = MTDEC__DATA_PTR_FROM_LINK(p->crossBlock) + p->crossStart;
+ *inLim = crossSize;
+ p->crossStart = 0;
+ p->crossEnd = 0;
+ return data;
+ }
+ *inLim = 0;
+ if (p->crossBlock)
+ {
+ ISzAlloc_Free(p->alloc, p->crossBlock);
+ p->crossBlock = NULL;
+ }
+ return NULL;
+ }
+}
+
+
+void MtDec_Construct(CMtDec *p)
+{
+ unsigned i;
+
+ p->inBufSize = (size_t)1 << 18;
+
+ p->numThreadsMax = 0;
+
+ p->inStream = NULL;
+
+ // p->inData = NULL;
+ // p->inDataSize = 0;
+
+ p->crossBlock = NULL;
+ p->crossStart = 0;
+ p->crossEnd = 0;
+
+ p->numFilledThreads = 0;
+
+ p->progress = NULL;
+ p->alloc = NULL;
+
+ p->mtCallback = NULL;
+ p->mtCallbackObject = NULL;
+
+ p->allocatedBufsSize = 0;
+
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CMtDecThread *t = &p->threads[i];
+ t->mtDec = p;
+ t->index = i;
+ t->inBuf = NULL;
+ Event_Construct(&t->canRead);
+ Event_Construct(&t->canWrite);
+ Thread_CONSTRUCT(&t->thread)
+ }
+
+ // Event_Construct(&p->finishedEvent);
+
+ CriticalSection_Init(&p->mtProgress.cs);
+}
+
+
+static void MtDec_Free(CMtDec *p)
+{
+ unsigned i;
+
+ p->exitThread = True;
+
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ MtDecThread_Destruct(&p->threads[i]);
+
+ // Event_Close(&p->finishedEvent);
+
+ if (p->crossBlock)
+ {
+ ISzAlloc_Free(p->alloc, p->crossBlock);
+ p->crossBlock = NULL;
+ }
+}
+
+
+void MtDec_Destruct(CMtDec *p)
+{
+ MtDec_Free(p);
+
+ CriticalSection_Delete(&p->mtProgress.cs);
+}
+
+
+SRes MtDec_Code(CMtDec *p)
+{
+ unsigned i;
+
+ p->inProcessed = 0;
+
+ p->blockIndex = 1; // it must be larger than not_defined index (0)
+ p->isAllocError = False;
+ p->overflow = False;
+ p->threadingErrorSRes = SZ_OK;
+
+ p->needContinue = True;
+
+ p->readWasFinished = False;
+ p->needInterrupt = False;
+ p->interruptIndex = (UInt64)(Int64)-1;
+
+ p->readProcessed = 0;
+ p->readRes = SZ_OK;
+ p->codeRes = SZ_OK;
+ p->wasInterrupted = False;
+
+ p->crossStart = 0;
+ p->crossEnd = 0;
+
+ p->filledThreadStart = 0;
+ p->numFilledThreads = 0;
+
+ {
+ unsigned numThreads = p->numThreadsMax;
+ if (numThreads > MTDEC_THREADS_MAX)
+ numThreads = MTDEC_THREADS_MAX;
+ p->numStartedThreads_Limit = numThreads;
+ p->numStartedThreads = 0;
+ }
+
+ if (p->inBufSize != p->allocatedBufsSize)
+ {
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CMtDecThread *t = &p->threads[i];
+ if (t->inBuf)
+ MtDecThread_FreeInBufs(t);
+ }
+ if (p->crossBlock)
+ {
+ ISzAlloc_Free(p->alloc, p->crossBlock);
+ p->crossBlock = NULL;
+ }
+
+ p->allocatedBufsSize = p->inBufSize;
+ }
+
+ MtProgress_Init(&p->mtProgress, p->progress);
+
+ // RINOK_THREAD(AutoResetEvent_OptCreate_And_Reset(&p->finishedEvent))
+ p->exitThread = False;
+ p->exitThreadWRes = 0;
+
+ {
+ WRes wres;
+ SRes sres;
+ CMtDecThread *nextThread = &p->threads[p->numStartedThreads++];
+ // wres = MtDecThread_CreateAndStart(nextThread);
+ wres = MtDecThread_CreateEvents(nextThread);
+ if (wres == 0) { wres = Event_Set(&nextThread->canWrite);
+ if (wres == 0) { wres = Event_Set(&nextThread->canRead);
+ if (wres == 0) { THREAD_FUNC_RET_TYPE res = MtDec_ThreadFunc(nextThread);
+ wres = (WRes)(UINT_PTR)res;
+ if (wres != 0)
+ {
+ p->needContinue = False;
+ MtDec_CloseThreads(p);
+ }}}}
+
+ // wres = 17; // for test
+ // wres = Event_Wait(&p->finishedEvent);
+
+ sres = MY_SRes_HRESULT_FROM_WRes(wres);
+
+ if (sres != 0)
+ p->threadingErrorSRes = sres;
+
+ if (
+ // wres == 0
+ // wres != 0
+ // || p->mtc.codeRes == SZ_ERROR_MEM
+ p->isAllocError
+ || p->threadingErrorSRes != SZ_OK
+ || p->overflow)
+ {
+ // p->needContinue = True;
+ }
+ else
+ p->needContinue = False;
+
+ if (p->needContinue)
+ return SZ_OK;
+
+ // if (sres != SZ_OK)
+ return sres;
+ // return SZ_ERROR_FAIL;
+ }
+}
+
+#endif
+
+#undef PRF
diff --git a/C/MtDec.h b/C/MtDec.h
index 9864cc8..c28e8d9 100644
--- a/C/MtDec.h
+++ b/C/MtDec.h
@@ -1,201 +1,202 @@
-/* MtDec.h -- Multi-thread Decoder
-2018-07-04 : Igor Pavlov : Public domain */
-
-#ifndef __MT_DEC_H
-#define __MT_DEC_H
-
-#include "7zTypes.h"
-
-#ifndef _7ZIP_ST
-#include "Threads.h"
-#endif
-
-EXTERN_C_BEGIN
-
-#ifndef _7ZIP_ST
-
-#ifndef _7ZIP_ST
- #define MTDEC__THREADS_MAX 32
-#else
- #define MTDEC__THREADS_MAX 1
-#endif
-
-
-typedef struct
-{
- ICompressProgress *progress;
- SRes res;
- UInt64 totalInSize;
- UInt64 totalOutSize;
- CCriticalSection cs;
-} CMtProgress;
-
-void MtProgress_Init(CMtProgress *p, ICompressProgress *progress);
-SRes MtProgress_Progress_ST(CMtProgress *p);
-SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize);
-SRes MtProgress_GetError(CMtProgress *p);
-void MtProgress_SetError(CMtProgress *p, SRes res);
-
-struct _CMtDec;
-
-typedef struct
-{
- struct _CMtDec *mtDec;
- unsigned index;
- void *inBuf;
-
- size_t inDataSize_Start; // size of input data in start block
- UInt64 inDataSize; // total size of input data in all blocks
-
- CThread thread;
- CAutoResetEvent canRead;
- CAutoResetEvent canWrite;
- void *allocaPtr;
-} CMtDecThread;
-
-void MtDecThread_FreeInBufs(CMtDecThread *t);
-
-
-typedef enum
-{
- MTDEC_PARSE_CONTINUE, // continue this block with more input data
- MTDEC_PARSE_OVERFLOW, // MT buffers overflow, need switch to single-thread
- MTDEC_PARSE_NEW, // new block
- MTDEC_PARSE_END // end of block threading. But we still can return to threading after Write(&needContinue)
-} EMtDecParseState;
-
-typedef struct
-{
- // in
- int startCall;
- const Byte *src;
- size_t srcSize;
- // in : (srcSize == 0) is allowed
- // out : it's allowed to return less that actually was used ?
- int srcFinished;
-
- // out
- EMtDecParseState state;
- BoolInt canCreateNewThread;
- UInt64 outPos; // check it (size_t)
-} CMtDecCallbackInfo;
-
-
-typedef struct
-{
- void (*Parse)(void *p, unsigned coderIndex, CMtDecCallbackInfo *ci);
-
- // PreCode() and Code():
- // (SRes_return_result != SZ_OK) means stop decoding, no need another blocks
- SRes (*PreCode)(void *p, unsigned coderIndex);
- SRes (*Code)(void *p, unsigned coderIndex,
- const Byte *src, size_t srcSize, int srcFinished,
- UInt64 *inCodePos, UInt64 *outCodePos, int *stop);
- // stop - means stop another Code calls
-
-
- /* Write() must be called, if Parse() was called
- set (needWrite) if
- {
- && (was not interrupted by progress)
- && (was not interrupted in previous block)
- }
-
- out:
- if (*needContinue), decoder still need to continue decoding with new iteration,
- even after MTDEC_PARSE_END
- if (*canRecode), we didn't flush current block data, so we still can decode current block later.
- */
- SRes (*Write)(void *p, unsigned coderIndex,
- BoolInt needWriteToStream,
- const Byte *src, size_t srcSize,
- // int srcFinished,
- BoolInt *needContinue,
- BoolInt *canRecode);
-} IMtDecCallback;
-
-
-
-typedef struct _CMtDec
-{
- /* input variables */
-
- size_t inBufSize; /* size of input block */
- unsigned numThreadsMax;
- // size_t inBlockMax;
- unsigned numThreadsMax_2;
-
- ISeqInStream *inStream;
- // const Byte *inData;
- // size_t inDataSize;
-
- ICompressProgress *progress;
- ISzAllocPtr alloc;
-
- IMtDecCallback *mtCallback;
- void *mtCallbackObject;
-
-
- /* internal variables */
-
- size_t allocatedBufsSize;
-
- BoolInt exitThread;
- WRes exitThreadWRes;
-
- UInt64 blockIndex;
- BoolInt isAllocError;
- BoolInt overflow;
- SRes threadingErrorSRes;
-
- BoolInt needContinue;
-
- // CAutoResetEvent finishedEvent;
-
- SRes readRes;
- SRes codeRes;
-
- BoolInt wasInterrupted;
-
- unsigned numStartedThreads_Limit;
- unsigned numStartedThreads;
-
- Byte *crossBlock;
- size_t crossStart;
- size_t crossEnd;
- UInt64 readProcessed;
- BoolInt readWasFinished;
- UInt64 inProcessed;
-
- unsigned filledThreadStart;
- unsigned numFilledThreads;
-
- #ifndef _7ZIP_ST
- BoolInt needInterrupt;
- UInt64 interruptIndex;
- CMtProgress mtProgress;
- CMtDecThread threads[MTDEC__THREADS_MAX];
- #endif
-} CMtDec;
-
-
-void MtDec_Construct(CMtDec *p);
-void MtDec_Destruct(CMtDec *p);
-
-/*
-MtDec_Code() returns:
- SZ_OK - in most cases
- MY_SRes_HRESULT_FROM_WRes(WRes_error) - in case of unexpected error in threading function
-*/
-
-SRes MtDec_Code(CMtDec *p);
-Byte *MtDec_GetCrossBuff(CMtDec *p);
-
-int MtDec_PrepareRead(CMtDec *p);
-const Byte *MtDec_Read(CMtDec *p, size_t *inLim);
-
-#endif
-
-EXTERN_C_END
-
-#endif
+/* MtDec.h -- Multi-thread Decoder
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_MT_DEC_H
+#define ZIP7_INC_MT_DEC_H
+
+#include "7zTypes.h"
+
+#ifndef Z7_ST
+#include "Threads.h"
+#endif
+
+EXTERN_C_BEGIN
+
+#ifndef Z7_ST
+
+#ifndef Z7_ST
+ #define MTDEC_THREADS_MAX 32
+#else
+ #define MTDEC_THREADS_MAX 1
+#endif
+
+
+typedef struct
+{
+ ICompressProgressPtr progress;
+ SRes res;
+ UInt64 totalInSize;
+ UInt64 totalOutSize;
+ CCriticalSection cs;
+} CMtProgress;
+
+void MtProgress_Init(CMtProgress *p, ICompressProgressPtr progress);
+SRes MtProgress_Progress_ST(CMtProgress *p);
+SRes MtProgress_ProgressAdd(CMtProgress *p, UInt64 inSize, UInt64 outSize);
+SRes MtProgress_GetError(CMtProgress *p);
+void MtProgress_SetError(CMtProgress *p, SRes res);
+
+struct CMtDec;
+
+typedef struct
+{
+ struct CMtDec_ *mtDec;
+ unsigned index;
+ void *inBuf;
+
+ size_t inDataSize_Start; // size of input data in start block
+ UInt64 inDataSize; // total size of input data in all blocks
+
+ CThread thread;
+ CAutoResetEvent canRead;
+ CAutoResetEvent canWrite;
+ void *allocaPtr;
+} CMtDecThread;
+
+void MtDecThread_FreeInBufs(CMtDecThread *t);
+
+
+typedef enum
+{
+ MTDEC_PARSE_CONTINUE, // continue this block with more input data
+ MTDEC_PARSE_OVERFLOW, // MT buffers overflow, need switch to single-thread
+ MTDEC_PARSE_NEW, // new block
+ MTDEC_PARSE_END // end of block threading. But we still can return to threading after Write(&needContinue)
+} EMtDecParseState;
+
+typedef struct
+{
+ // in
+ int startCall;
+ const Byte *src;
+ size_t srcSize;
+ // in : (srcSize == 0) is allowed
+ // out : it's allowed to return less that actually was used ?
+ int srcFinished;
+
+ // out
+ EMtDecParseState state;
+ BoolInt canCreateNewThread;
+ UInt64 outPos; // check it (size_t)
+} CMtDecCallbackInfo;
+
+
+typedef struct
+{
+ void (*Parse)(void *p, unsigned coderIndex, CMtDecCallbackInfo *ci);
+
+ // PreCode() and Code():
+ // (SRes_return_result != SZ_OK) means stop decoding, no need another blocks
+ SRes (*PreCode)(void *p, unsigned coderIndex);
+ SRes (*Code)(void *p, unsigned coderIndex,
+ const Byte *src, size_t srcSize, int srcFinished,
+ UInt64 *inCodePos, UInt64 *outCodePos, int *stop);
+ // stop - means stop another Code calls
+
+
+ /* Write() must be called, if Parse() was called
+ set (needWrite) if
+ {
+ && (was not interrupted by progress)
+ && (was not interrupted in previous block)
+ }
+
+ out:
+ if (*needContinue), decoder still need to continue decoding with new iteration,
+ even after MTDEC_PARSE_END
+ if (*canRecode), we didn't flush current block data, so we still can decode current block later.
+ */
+ SRes (*Write)(void *p, unsigned coderIndex,
+ BoolInt needWriteToStream,
+ const Byte *src, size_t srcSize, BoolInt isCross,
+ // int srcFinished,
+ BoolInt *needContinue,
+ BoolInt *canRecode);
+
+} IMtDecCallback2;
+
+
+
+typedef struct CMtDec_
+{
+ /* input variables */
+
+ size_t inBufSize; /* size of input block */
+ unsigned numThreadsMax;
+ // size_t inBlockMax;
+ unsigned numThreadsMax_2;
+
+ ISeqInStreamPtr inStream;
+ // const Byte *inData;
+ // size_t inDataSize;
+
+ ICompressProgressPtr progress;
+ ISzAllocPtr alloc;
+
+ IMtDecCallback2 *mtCallback;
+ void *mtCallbackObject;
+
+
+ /* internal variables */
+
+ size_t allocatedBufsSize;
+
+ BoolInt exitThread;
+ WRes exitThreadWRes;
+
+ UInt64 blockIndex;
+ BoolInt isAllocError;
+ BoolInt overflow;
+ SRes threadingErrorSRes;
+
+ BoolInt needContinue;
+
+ // CAutoResetEvent finishedEvent;
+
+ SRes readRes;
+ SRes codeRes;
+
+ BoolInt wasInterrupted;
+
+ unsigned numStartedThreads_Limit;
+ unsigned numStartedThreads;
+
+ Byte *crossBlock;
+ size_t crossStart;
+ size_t crossEnd;
+ UInt64 readProcessed;
+ BoolInt readWasFinished;
+ UInt64 inProcessed;
+
+ unsigned filledThreadStart;
+ unsigned numFilledThreads;
+
+ #ifndef Z7_ST
+ BoolInt needInterrupt;
+ UInt64 interruptIndex;
+ CMtProgress mtProgress;
+ CMtDecThread threads[MTDEC_THREADS_MAX];
+ #endif
+} CMtDec;
+
+
+void MtDec_Construct(CMtDec *p);
+void MtDec_Destruct(CMtDec *p);
+
+/*
+MtDec_Code() returns:
+ SZ_OK - in most cases
+ MY_SRes_HRESULT_FROM_WRes(WRes_error) - in case of unexpected error in threading function
+*/
+
+SRes MtDec_Code(CMtDec *p);
+Byte *MtDec_GetCrossBuff(CMtDec *p);
+
+int MtDec_PrepareRead(CMtDec *p);
+const Byte *MtDec_Read(CMtDec *p, size_t *inLim);
+
+#endif
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Ppmd.h b/C/Ppmd.h
index 4b99415..66b2626 100644
--- a/C/Ppmd.h
+++ b/C/Ppmd.h
@@ -1,85 +1,169 @@
-/* Ppmd.h -- PPMD codec common code
-2017-04-03 : Igor Pavlov : Public domain
-This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
-
-#ifndef __PPMD_H
-#define __PPMD_H
-
-#include "CpuArch.h"
-
-EXTERN_C_BEGIN
-
-#ifdef MY_CPU_32BIT
- #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)
-
-#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 <<= 1; (p)->Count = (Byte)(3 << (p)->Shift++); }
-
-typedef struct
-{
- Byte Symbol;
- Byte Freq;
- UInt16 SuccessorLow;
- UInt16 SuccessorHigh;
-} CPpmd_State;
-
-#pragma pack(pop)
-
-typedef
- #ifdef PPMD_32BIT
- CPpmd_State *
- #else
- UInt32
- #endif
- CPpmd_State_Ref;
-
-typedef
- #ifdef PPMD_32BIT
- void *
- #else
- UInt32
- #endif
- CPpmd_Void_Ref;
-
-typedef
- #ifdef PPMD_32BIT
- Byte *
- #else
- UInt32
- #endif
- CPpmd_Byte_Ref;
-
-#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
+/* 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
diff --git a/C/Ppmd7.c b/C/Ppmd7.c
index 80e7de9..6e1307e 100644
--- a/C/Ppmd7.c
+++ b/C/Ppmd7.c
@@ -1,712 +1,1122 @@
-/* Ppmd7.c -- PPMdH codec
-2018-07-04 : 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"
-
-const Byte PPMD7_kExpEscape[16] = { 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2 };
-static const UInt16 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) (p->Indx2Units[indx])
-
-#ifdef PPMD_32BIT
- #define REF(ptr) (ptr)
-#else
- #define REF(ptr) ((UInt32)((Byte *)(ptr) - (p)->Base))
-#endif
-
-#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 * CTX_PTR;
-
-struct CPpmd7_Node_;
-
-typedef
- #ifdef PPMD_32BIT
- struct CPpmd7_Node_ *
- #else
- UInt32
- #endif
- 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;
-
-#ifdef PPMD_32BIT
- #define NODE(ptr) (ptr)
-#else
- #define NODE(offs) ((CPpmd7_Node *)(p->Base + (offs)))
-#endif
-
-void Ppmd7_Construct(CPpmd7 *p)
-{
- unsigned i, k, m;
-
- p->Base = 0;
-
- 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;
- }
-
- memset(p->HB2Flag, 0, 0x40);
- memset(p->HB2Flag + 0x40, 8, 0x100 - 0x40);
-}
-
-void Ppmd7_Free(CPpmd7 *p, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, p->Base);
- p->Size = 0;
- p->Base = 0;
-}
-
-BoolInt Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAllocPtr alloc)
-{
- if (!p->Base || p->Size != size)
- {
- size_t size2;
- Ppmd7_Free(p, alloc);
- size2 = 0
- #ifndef PPMD_32BIT
- + UNIT_SIZE
- #endif
- ;
- p->AlignOffset =
- #ifdef PPMD_32BIT
- (4 - size) & 3;
- #else
- 4 - (size & 3);
- #endif
- if ((p->Base = (Byte *)ISzAlloc_Alloc(alloc, p->AlignOffset + size + size2)) == 0)
- return False;
- p->Size = size;
- }
- return True;
-}
-
-static void InsertNode(CPpmd7 *p, void *node, unsigned indx)
-{
- *((CPpmd_Void_Ref *)node) = p->FreeList[indx];
- p->FreeList[indx] = REF(node);
-}
-
-static void *RemoveNode(CPpmd7 *p, unsigned indx)
-{
- CPpmd_Void_Ref *node = (CPpmd_Void_Ref *)Ppmd7_GetPtr(p, p->FreeList[indx]);
- p->FreeList[indx] = *node;
- return node;
-}
-
-static void 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);
- InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1);
- }
- InsertNode(p, ptr, i);
-}
-
-static void GlueFreeBlocks(CPpmd7 *p)
-{
- #ifdef PPMD_32BIT
- CPpmd7_Node headItem;
- CPpmd7_Node_Ref head = &headItem;
- #else
- CPpmd7_Node_Ref head = p->AlignOffset + p->Size;
- #endif
-
- CPpmd7_Node_Ref n = head;
- unsigned i;
-
- p->GlueCount = 255;
-
- /* create doubly-linked list of free blocks */
- for (i = 0; i < PPMD_NUM_INDEXES; i++)
- {
- UInt16 nu = I2U(i);
- CPpmd7_Node_Ref next = (CPpmd7_Node_Ref)p->FreeList[i];
- p->FreeList[i] = 0;
- while (next != 0)
- {
- CPpmd7_Node *node = NODE(next);
- node->Next = n;
- n = NODE(n)->Prev = next;
- next = *(const CPpmd7_Node_Ref *)node;
- node->Stamp = 0;
- node->NU = (UInt16)nu;
- }
- }
- NODE(head)->Stamp = 1;
- NODE(head)->Next = n;
- NODE(n)->Prev = head;
- if (p->LoUnit != p->HiUnit)
- ((CPpmd7_Node *)p->LoUnit)->Stamp = 1;
-
- /* Glue free blocks */
- while (n != head)
- {
- CPpmd7_Node *node = NODE(n);
- UInt32 nu = (UInt32)node->NU;
- for (;;)
- {
- CPpmd7_Node *node2 = NODE(n) + nu;
- nu += node2->NU;
- if (node2->Stamp != 0 || nu >= 0x10000)
- break;
- NODE(node2->Prev)->Next = node2->Next;
- NODE(node2->Next)->Prev = node2->Prev;
- node->NU = (UInt16)nu;
- }
- n = node->Next;
- }
-
- /* Fill lists of free blocks */
- for (n = NODE(head)->Next; n != head;)
- {
- CPpmd7_Node *node = NODE(n);
- unsigned nu;
- CPpmd7_Node_Ref next = node->Next;
- for (nu = node->NU; nu > 128; nu -= 128, node += 128)
- InsertNode(p, node, PPMD_NUM_INDEXES - 1);
- if (I2U(i = U2I(nu)) != nu)
- {
- unsigned k = I2U(--i);
- InsertNode(p, node + k, nu - k - 1);
- }
- InsertNode(p, node, i);
- n = next;
- }
-}
-
-static void *AllocUnitsRare(CPpmd7 *p, unsigned indx)
-{
- unsigned i;
- void *retVal;
- if (p->GlueCount == 0)
- {
- GlueFreeBlocks(p);
- if (p->FreeList[indx] != 0)
- return RemoveNode(p, indx);
- }
- i = indx;
- do
- {
- if (++i == PPMD_NUM_INDEXES)
- {
- UInt32 numBytes = U2B(I2U(indx));
- p->GlueCount--;
- return ((UInt32)(p->UnitsStart - p->Text) > numBytes) ? (p->UnitsStart -= numBytes) : (NULL);
- }
- }
- while (p->FreeList[i] == 0);
- retVal = RemoveNode(p, i);
- SplitBlock(p, retVal, i, indx);
- return retVal;
-}
-
-static void *AllocUnits(CPpmd7 *p, unsigned indx)
-{
- UInt32 numBytes;
- if (p->FreeList[indx] != 0)
- return RemoveNode(p, indx);
- numBytes = U2B(I2U(indx));
- if (numBytes <= (UInt32)(p->HiUnit - p->LoUnit))
- {
- void *retVal = p->LoUnit;
- p->LoUnit += numBytes;
- return retVal;
- }
- return AllocUnitsRare(p, indx);
-}
-
-#define MyMem12Cpy(dest, src, num) \
- { UInt32 *d = (UInt32 *)dest; const UInt32 *s = (const UInt32 *)src; UInt32 n = num; \
- do { d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; s += 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 = RemoveNode(p, i1);
- MyMem12Cpy(ptr, oldPtr, newNU);
- InsertNode(p, oldPtr, i0);
- return ptr;
- }
- SplitBlock(p, oldPtr, i0, i1);
- return oldPtr;
-}
-
-#define SUCCESSOR(p) ((CPpmd_Void_Ref)((p)->SuccessorLow | ((UInt32)(p)->SuccessorHigh << 16)))
-
-static void SetSuccessor(CPpmd_State *p, CPpmd_Void_Ref v)
-{
- (p)->SuccessorLow = (UInt16)((UInt32)(v) & 0xFFFF);
- (p)->SuccessorHigh = (UInt16)(((UInt32)(v) >> 16) & 0xFFFF);
-}
-
-static void RestartModel(CPpmd7 *p)
-{
- unsigned i, k, m;
-
- 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;
-
- p->MinContext = p->MaxContext = (CTX_PTR)(p->HiUnit -= UNIT_SIZE); /* AllocContext(p); */
- p->MinContext->Suffix = 0;
- p->MinContext->NumStats = 256;
- p->MinContext->SummFreq = 256 + 1;
- p->FoundState = (CPpmd_State *)p->LoUnit; /* AllocUnits(p, PPMD_NUM_INDEXES - 1); */
- p->LoUnit += U2B(256 / 2);
- p->MinContext->Stats = REF(p->FoundState);
- for (i = 0; i < 256; i++)
- {
- CPpmd_State *s = &p->FoundState[i];
- s->Symbol = (Byte)i;
- s->Freq = 1;
- SetSuccessor(s, 0);
- }
-
- for (i = 0; i < 128; i++)
- for (k = 0; k < 8; k++)
- {
- UInt16 *dest = p->BinSumm[i] + k;
- UInt16 val = (UInt16)(PPMD_BIN_SCALE - kInitBinEsc[k] / (i + 2));
- for (m = 0; m < 64; m += 8)
- dest[m] = val;
- }
-
- for (i = 0; i < 25; i++)
- for (k = 0; k < 16; k++)
- {
- CPpmd_See *s = &p->See[i][k];
- s->Summ = (UInt16)((5 * i + 10) << (s->Shift = PPMD_PERIOD_BITS - 4));
- s->Count = 4;
- }
-}
-
-void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder)
-{
- p->MaxOrder = maxOrder;
- RestartModel(p);
- p->DummySee.Shift = PPMD_PERIOD_BITS;
- p->DummySee.Summ = 0; /* unused */
- p->DummySee.Count = 64; /* unused */
-}
-
-static CTX_PTR CreateSuccessors(CPpmd7 *p, BoolInt skip)
-{
- CPpmd_State upState;
- CTX_PTR c = p->MinContext;
- CPpmd_Byte_Ref upBranch = (CPpmd_Byte_Ref)SUCCESSOR(p->FoundState);
- CPpmd_State *ps[PPMD7_MAX_ORDER];
- unsigned numPs = 0;
-
- if (!skip)
- ps[numPs++] = p->FoundState;
-
- while (c->Suffix)
- {
- CPpmd_Void_Ref successor;
- CPpmd_State *s;
- c = SUFFIX(c);
- if (c->NumStats != 1)
- {
- for (s = STATS(c); s->Symbol != p->FoundState->Symbol; s++);
- }
- else
- s = ONE_STATE(c);
- successor = SUCCESSOR(s);
- if (successor != upBranch)
- {
- c = CTX(successor);
- if (numPs == 0)
- return c;
- break;
- }
- ps[numPs++] = s;
- }
-
- upState.Symbol = *(const Byte *)Ppmd7_GetPtr(p, upBranch);
- SetSuccessor(&upState, upBranch + 1);
-
- if (c->NumStats == 1)
- upState.Freq = ONE_STATE(c)->Freq;
- else
- {
- UInt32 cf, s0;
- CPpmd_State *s;
- for (s = STATS(c); s->Symbol != upState.Symbol; s++);
- cf = s->Freq - 1;
- s0 = c->SummFreq - c->NumStats - cf;
- upState.Freq = (Byte)(1 + ((2 * cf <= s0) ? (5 * cf > s0) : ((2 * cf + 3 * s0 - 1) / (2 * s0))));
- }
-
- do
- {
- /* Create Child */
- CTX_PTR c1; /* = AllocContext(p); */
- if (p->HiUnit != p->LoUnit)
- c1 = (CTX_PTR)(p->HiUnit -= UNIT_SIZE);
- else if (p->FreeList[0] != 0)
- c1 = (CTX_PTR)RemoveNode(p, 0);
- else
- {
- c1 = (CTX_PTR)AllocUnitsRare(p, 0);
- if (!c1)
- return NULL;
- }
- c1->NumStats = 1;
- *ONE_STATE(c1) = upState;
- c1->Suffix = REF(c);
- SetSuccessor(ps[--numPs], REF(c1));
- c = c1;
- }
- while (numPs != 0);
-
- return c;
-}
-
-static void SwapStates(CPpmd_State *t1, CPpmd_State *t2)
-{
- CPpmd_State tmp = *t1;
- *t1 = *t2;
- *t2 = tmp;
-}
-
-static void UpdateModel(CPpmd7 *p)
-{
- CPpmd_Void_Ref successor, fSuccessor = SUCCESSOR(p->FoundState);
- CTX_PTR c;
- unsigned s0, ns;
-
- if (p->FoundState->Freq < MAX_FREQ / 4 && p->MinContext->Suffix != 0)
- {
- 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);
- if (s->Symbol != p->FoundState->Symbol)
- {
- do { s++; } while (s->Symbol != p->FoundState->Symbol);
- if (s[0].Freq >= s[-1].Freq)
- {
- SwapStates(&s[0], &s[-1]);
- s--;
- }
- }
- if (s->Freq < MAX_FREQ - 9)
- {
- s->Freq += 2;
- c->SummFreq += 2;
- }
- }
- }
-
- if (p->OrderFall == 0)
- {
- p->MinContext = p->MaxContext = CreateSuccessors(p, True);
- if (p->MinContext == 0)
- {
- RestartModel(p);
- return;
- }
- SetSuccessor(p->FoundState, REF(p->MinContext));
- return;
- }
-
- *p->Text++ = p->FoundState->Symbol;
- successor = REF(p->Text);
- if (p->Text >= p->UnitsStart)
- {
- RestartModel(p);
- return;
- }
-
- if (fSuccessor)
- {
- if (fSuccessor <= successor)
- {
- CTX_PTR cs = CreateSuccessors(p, False);
- if (cs == NULL)
- {
- RestartModel(p);
- return;
- }
- fSuccessor = REF(cs);
- }
- if (--p->OrderFall == 0)
- {
- successor = fSuccessor;
- p->Text -= (p->MaxContext != p->MinContext);
- }
- }
- else
- {
- SetSuccessor(p->FoundState, successor);
- fSuccessor = REF(p->MinContext);
- }
-
- s0 = p->MinContext->SummFreq - (ns = p->MinContext->NumStats) - (p->FoundState->Freq - 1);
-
- for (c = p->MaxContext; c != p->MinContext; c = SUFFIX(c))
- {
- unsigned ns1;
- UInt32 cf, sf;
- 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 = AllocUnits(p, i + 1);
- void *oldPtr;
- if (!ptr)
- {
- RestartModel(p);
- return;
- }
- oldPtr = STATS(c);
- MyMem12Cpy(ptr, oldPtr, oldNU);
- InsertNode(p, oldPtr, i);
- c->Stats = STATS_REF(ptr);
- }
- }
- c->SummFreq = (UInt16)(c->SummFreq + (2 * ns1 < ns) + 2 * ((4 * ns1 <= ns) & (c->SummFreq <= 8 * ns1)));
- }
- else
- {
- CPpmd_State *s = (CPpmd_State*)AllocUnits(p, 0);
- if (!s)
- {
- RestartModel(p);
- return;
- }
- *s = *ONE_STATE(c);
- c->Stats = REF(s);
- if (s->Freq < MAX_FREQ / 4 - 1)
- s->Freq <<= 1;
- else
- s->Freq = MAX_FREQ - 4;
- c->SummFreq = (UInt16)(s->Freq + p->InitEsc + (ns > 3));
- }
- cf = 2 * (UInt32)p->FoundState->Freq * (c->SummFreq + 6);
- sf = (UInt32)s0 + c->SummFreq;
- if (cf < 6 * sf)
- {
- cf = 1 + (cf > sf) + (cf >= 4 * sf);
- c->SummFreq += 3;
- }
- else
- {
- cf = 4 + (cf >= 9 * sf) + (cf >= 12 * sf) + (cf >= 15 * sf);
- c->SummFreq = (UInt16)(c->SummFreq + cf);
- }
- {
- CPpmd_State *s = STATS(c) + ns1;
- SetSuccessor(s, successor);
- s->Symbol = p->FoundState->Symbol;
- s->Freq = (Byte)cf;
- c->NumStats = (UInt16)(ns1 + 1);
- }
- }
- p->MaxContext = p->MinContext = CTX(fSuccessor);
-}
-
-static void Rescale(CPpmd7 *p)
-{
- unsigned i, adder, sumFreq, escFreq;
- CPpmd_State *stats = STATS(p->MinContext);
- CPpmd_State *s = p->FoundState;
- {
- CPpmd_State tmp = *s;
- for (; s != stats; s--)
- s[0] = s[-1];
- *s = tmp;
- }
- escFreq = p->MinContext->SummFreq - s->Freq;
- s->Freq += 4;
- adder = (p->OrderFall != 0);
- s->Freq = (Byte)((s->Freq + adder) >> 1);
- sumFreq = s->Freq;
-
- i = p->MinContext->NumStats - 1;
- do
- {
- escFreq -= (++s)->Freq;
- s->Freq = (Byte)((s->Freq + adder) >> 1);
- sumFreq += s->Freq;
- if (s[0].Freq > s[-1].Freq)
- {
- CPpmd_State *s1 = s;
- CPpmd_State tmp = *s1;
- do
- s1[0] = s1[-1];
- while (--s1 != stats && tmp.Freq > s1[-1].Freq);
- *s1 = tmp;
- }
- }
- while (--i);
-
- if (s->Freq == 0)
- {
- unsigned numStats = p->MinContext->NumStats;
- unsigned n0, n1;
- do { i++; } while ((--s)->Freq == 0);
- escFreq += i;
- p->MinContext->NumStats = (UInt16)(p->MinContext->NumStats - i);
- if (p->MinContext->NumStats == 1)
- {
- CPpmd_State tmp = *stats;
- do
- {
- tmp.Freq = (Byte)(tmp.Freq - (tmp.Freq >> 1));
- escFreq >>= 1;
- }
- while (escFreq > 1);
- InsertNode(p, stats, U2I(((numStats + 1) >> 1)));
- *(p->FoundState = ONE_STATE(p->MinContext)) = tmp;
- return;
- }
- n0 = (numStats + 1) >> 1;
- n1 = (p->MinContext->NumStats + 1) >> 1;
- if (n0 != n1)
- p->MinContext->Stats = STATS_REF(ShrinkUnits(p, stats, n0, n1));
- }
- p->MinContext->SummFreq = (UInt16)(sumFreq + escFreq - (escFreq >> 1));
- p->FoundState = STATS(p->MinContext);
-}
-
-CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq)
-{
- CPpmd_See *see;
- unsigned nonMasked = p->MinContext->NumStats - numMasked;
- if (p->MinContext->NumStats != 256)
- {
- see = p->See[(unsigned)p->NS2Indx[(size_t)nonMasked - 1]] +
- (nonMasked < (unsigned)SUFFIX(p->MinContext)->NumStats - p->MinContext->NumStats) +
- 2 * (unsigned)(p->MinContext->SummFreq < 11 * p->MinContext->NumStats) +
- 4 * (unsigned)(numMasked > nonMasked) +
- p->HiBitsFlag;
- {
- unsigned r = (see->Summ >> see->Shift);
- see->Summ = (UInt16)(see->Summ - r);
- *escFreq = r + (r == 0);
- }
- }
- else
- {
- see = &p->DummySee;
- *escFreq = 1;
- }
- return see;
-}
-
-static void NextContext(CPpmd7 *p)
-{
- CTX_PTR c = CTX(SUCCESSOR(p->FoundState));
- if (p->OrderFall == 0 && (Byte *)c > p->Text)
- p->MinContext = p->MaxContext = c;
- else
- UpdateModel(p);
-}
-
-void Ppmd7_Update1(CPpmd7 *p)
-{
- CPpmd_State *s = p->FoundState;
- s->Freq += 4;
- p->MinContext->SummFreq += 4;
- if (s[0].Freq > s[-1].Freq)
- {
- SwapStates(&s[0], &s[-1]);
- p->FoundState = --s;
- if (s->Freq > MAX_FREQ)
- Rescale(p);
- }
- NextContext(p);
-}
-
-void Ppmd7_Update1_0(CPpmd7 *p)
-{
- p->PrevSuccess = (2 * p->FoundState->Freq > p->MinContext->SummFreq);
- p->RunLength += p->PrevSuccess;
- p->MinContext->SummFreq += 4;
- if ((p->FoundState->Freq += 4) > MAX_FREQ)
- Rescale(p);
- NextContext(p);
-}
-
-void Ppmd7_UpdateBin(CPpmd7 *p)
-{
- p->FoundState->Freq = (Byte)(p->FoundState->Freq + (p->FoundState->Freq < 128 ? 1: 0));
- p->PrevSuccess = 1;
- p->RunLength++;
- NextContext(p);
-}
-
-void Ppmd7_Update2(CPpmd7 *p)
-{
- p->MinContext->SummFreq += 4;
- if ((p->FoundState->Freq += 4) > MAX_FREQ)
- Rescale(p);
- p->RunLength = p->InitRL;
- UpdateModel(p);
-}
+/* 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
diff --git a/C/Ppmd7.h b/C/Ppmd7.h
index cce93f1..d9eb326 100644
--- a/C/Ppmd7.h
+++ b/C/Ppmd7.h
@@ -1,142 +1,181 @@
-/* Ppmd7.h -- PPMdH compression codec
-2018-07-04 : Igor Pavlov : Public domain
-This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
-
-/* This code supports virtual RangeDecoder and includes the implementation
-of RangeCoder from 7z, instead of RangeCoder from original PPMd var.H.
-If you need the compatibility with original PPMd var.H, you can use external RangeDecoder */
-
-#ifndef __PPMD7_H
-#define __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
- #ifdef PPMD_32BIT
- struct CPpmd7_Context_ *
- #else
- UInt32
- #endif
- CPpmd7_Context_Ref;
-
-typedef struct CPpmd7_Context_
-{
- UInt16 NumStats;
- UInt16 SummFreq;
- CPpmd_State_Ref Stats;
- CPpmd7_Context_Ref Suffix;
-} CPpmd7_Context;
-
-#define Ppmd7Context_OneState(p) ((CPpmd_State *)&(p)->SummFreq)
-
-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;
- Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;
- UInt32 AlignOffset;
-
- Byte Indx2Units[PPMD_NUM_INDEXES];
- Byte Units2Indx[128];
- CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];
- Byte NS2Indx[256], NS2BSIndx[256], HB2Flag[256];
- CPpmd_See DummySee, See[25][16];
- UInt16 BinSumm[128][64];
-} 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 ---------- */
-
-extern const Byte PPMD7_kExpEscape[16];
-
-#ifdef PPMD_32BIT
- #define Ppmd7_GetPtr(p, ptr) (ptr)
- #define Ppmd7_GetContext(p, ptr) (ptr)
- #define Ppmd7_GetStats(p, ctx) ((ctx)->Stats)
-#else
- #define Ppmd7_GetPtr(p, offs) ((void *)((p)->Base + (offs)))
- #define Ppmd7_GetContext(p, offs) ((CPpmd7_Context *)Ppmd7_GetPtr((p), (offs)))
- #define Ppmd7_GetStats(p, ctx) ((CPpmd_State *)Ppmd7_GetPtr((p), ((ctx)->Stats)))
-#endif
-
-void Ppmd7_Update1(CPpmd7 *p);
-void Ppmd7_Update1_0(CPpmd7 *p);
-void Ppmd7_Update2(CPpmd7 *p);
-void Ppmd7_UpdateBin(CPpmd7 *p);
-
-#define Ppmd7_GetBinSumm(p) \
- &p->BinSumm[(size_t)(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1][p->PrevSuccess + \
- p->NS2BSIndx[(size_t)Ppmd7_GetContext(p, p->MinContext->Suffix)->NumStats - 1] + \
- (p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol]) + \
- 2 * p->HB2Flag[(unsigned)Ppmd7Context_OneState(p->MinContext)->Symbol] + \
- ((p->RunLength >> 26) & 0x20)]
-
-CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale);
-
-
-/* ---------- Decode ---------- */
-
-typedef struct IPpmd7_RangeDec IPpmd7_RangeDec;
-
-struct IPpmd7_RangeDec
-{
- UInt32 (*GetThreshold)(const IPpmd7_RangeDec *p, UInt32 total);
- void (*Decode)(const IPpmd7_RangeDec *p, UInt32 start, UInt32 size);
- UInt32 (*DecodeBit)(const IPpmd7_RangeDec *p, UInt32 size0);
-};
-
-typedef struct
-{
- IPpmd7_RangeDec vt;
- UInt32 Range;
- UInt32 Code;
- IByteIn *Stream;
-} CPpmd7z_RangeDec;
-
-void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p);
-BoolInt Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p);
-#define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
-
-int Ppmd7_DecodeSymbol(CPpmd7 *p, const IPpmd7_RangeDec *rc);
-
-
-/* ---------- Encode ---------- */
-
-typedef struct
-{
- UInt64 Low;
- UInt32 Range;
- Byte Cache;
- UInt64 CacheSize;
- IByteOut *Stream;
-} CPpmd7z_RangeEnc;
-
-void Ppmd7z_RangeEnc_Init(CPpmd7z_RangeEnc *p);
-void Ppmd7z_RangeEnc_FlushData(CPpmd7z_RangeEnc *p);
-
-void Ppmd7_EncodeSymbol(CPpmd7 *p, CPpmd7z_RangeEnc *rc, int symbol);
-
-EXTERN_C_END
-
-#endif
+/* 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
diff --git a/C/Ppmd7Dec.c b/C/Ppmd7Dec.c
index 2026407..8323828 100644
--- a/C/Ppmd7Dec.c
+++ b/C/Ppmd7Dec.c
@@ -1,191 +1,312 @@
-/* Ppmd7Dec.c -- PPMdH Decoder
-2018-07-04 : 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 (1 << 24)
-
-BoolInt Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p)
-{
- unsigned i;
- p->Code = 0;
- p->Range = 0xFFFFFFFF;
- if (IByteIn_Read(p->Stream) != 0)
- return False;
- for (i = 0; i < 4; i++)
- p->Code = (p->Code << 8) | IByteIn_Read(p->Stream);
- return (p->Code < 0xFFFFFFFF);
-}
-
-#define GET_Ppmd7z_RangeDec CPpmd7z_RangeDec *p = CONTAINER_FROM_VTBL(pp, CPpmd7z_RangeDec, vt);
-
-static UInt32 Range_GetThreshold(const IPpmd7_RangeDec *pp, UInt32 total)
-{
- GET_Ppmd7z_RangeDec
- return p->Code / (p->Range /= total);
-}
-
-static void Range_Normalize(CPpmd7z_RangeDec *p)
-{
- if (p->Range < kTopValue)
- {
- p->Code = (p->Code << 8) | IByteIn_Read(p->Stream);
- p->Range <<= 8;
- if (p->Range < kTopValue)
- {
- p->Code = (p->Code << 8) | IByteIn_Read(p->Stream);
- p->Range <<= 8;
- }
- }
-}
-
-static void Range_Decode(const IPpmd7_RangeDec *pp, UInt32 start, UInt32 size)
-{
- GET_Ppmd7z_RangeDec
- p->Code -= start * p->Range;
- p->Range *= size;
- Range_Normalize(p);
-}
-
-static UInt32 Range_DecodeBit(const IPpmd7_RangeDec *pp, UInt32 size0)
-{
- GET_Ppmd7z_RangeDec
- UInt32 newBound = (p->Range >> 14) * size0;
- UInt32 symbol;
- if (p->Code < newBound)
- {
- symbol = 0;
- p->Range = newBound;
- }
- else
- {
- symbol = 1;
- p->Code -= newBound;
- p->Range -= newBound;
- }
- Range_Normalize(p);
- return symbol;
-}
-
-void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p)
-{
- p->vt.GetThreshold = Range_GetThreshold;
- p->vt.Decode = Range_Decode;
- p->vt.DecodeBit = Range_DecodeBit;
-}
-
-
-#define MASK(sym) ((signed char *)charMask)[sym]
-
-int Ppmd7_DecodeSymbol(CPpmd7 *p, const IPpmd7_RangeDec *rc)
-{
- 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;
- if ((count = rc->GetThreshold(rc, p->MinContext->SummFreq)) < (hiCnt = s->Freq))
- {
- Byte symbol;
- rc->Decode(rc, 0, s->Freq);
- p->FoundState = s;
- symbol = s->Symbol;
- Ppmd7_Update1_0(p);
- return symbol;
- }
- p->PrevSuccess = 0;
- i = p->MinContext->NumStats - 1;
- do
- {
- if ((hiCnt += (++s)->Freq) > count)
- {
- Byte symbol;
- rc->Decode(rc, hiCnt - s->Freq, s->Freq);
- p->FoundState = s;
- symbol = s->Symbol;
- Ppmd7_Update1(p);
- return symbol;
- }
- }
- while (--i);
- if (count >= p->MinContext->SummFreq)
- return -2;
- p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol];
- rc->Decode(rc, hiCnt, p->MinContext->SummFreq - hiCnt);
- PPMD_SetAllBitsIn256Bytes(charMask);
- MASK(s->Symbol) = 0;
- i = p->MinContext->NumStats - 1;
- do { MASK((--s)->Symbol) = 0; } while (--i);
- }
- else
- {
- UInt16 *prob = Ppmd7_GetBinSumm(p);
- if (rc->DecodeBit(rc, *prob) == 0)
- {
- Byte symbol;
- *prob = (UInt16)PPMD_UPDATE_PROB_0(*prob);
- symbol = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;
- Ppmd7_UpdateBin(p);
- return symbol;
- }
- *prob = (UInt16)PPMD_UPDATE_PROB_1(*prob);
- p->InitEsc = PPMD7_kExpEscape[*prob >> 10];
- PPMD_SetAllBitsIn256Bytes(charMask);
- MASK(Ppmd7Context_OneState(p->MinContext)->Symbol) = 0;
- p->PrevSuccess = 0;
- }
- for (;;)
- {
- CPpmd_State *ps[256], *s;
- UInt32 freqSum, count, hiCnt;
- CPpmd_See *see;
- unsigned i, num, numMasked = p->MinContext->NumStats;
- do
- {
- p->OrderFall++;
- if (!p->MinContext->Suffix)
- return -1;
- p->MinContext = Ppmd7_GetContext(p, p->MinContext->Suffix);
- }
- while (p->MinContext->NumStats == numMasked);
- hiCnt = 0;
- s = Ppmd7_GetStats(p, p->MinContext);
- i = 0;
- num = p->MinContext->NumStats - numMasked;
- do
- {
- int k = (int)(MASK(s->Symbol));
- hiCnt += (s->Freq & k);
- ps[i] = s++;
- i -= k;
- }
- while (i != num);
-
- see = Ppmd7_MakeEscFreq(p, numMasked, &freqSum);
- freqSum += hiCnt;
- count = rc->GetThreshold(rc, freqSum);
-
- if (count < hiCnt)
- {
- Byte symbol;
- CPpmd_State **pps = ps;
- for (hiCnt = 0; (hiCnt += (*pps)->Freq) <= count; pps++);
- s = *pps;
- rc->Decode(rc, hiCnt - s->Freq, s->Freq);
- Ppmd_See_Update(see);
- p->FoundState = s;
- symbol = s->Symbol;
- Ppmd7_Update2(p);
- return symbol;
- }
- if (count >= freqSum)
- return -2;
- rc->Decode(rc, hiCnt, freqSum - hiCnt);
- see->Summ = (UInt16)(see->Summ + freqSum);
- do { MASK(ps[--i]->Symbol) = 0; } while (i != 0);
- }
-}
+/* 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
diff --git a/C/Ppmd7Enc.c b/C/Ppmd7Enc.c
index a74d300..41106ba 100644
--- a/C/Ppmd7Enc.c
+++ b/C/Ppmd7Enc.c
@@ -1,187 +1,338 @@
-/* Ppmd7Enc.c -- PPMdH Encoder
-2017-04-03 : 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 (1 << 24)
-
-void Ppmd7z_RangeEnc_Init(CPpmd7z_RangeEnc *p)
-{
- p->Low = 0;
- p->Range = 0xFFFFFFFF;
- p->Cache = 0;
- p->CacheSize = 1;
-}
-
-static void RangeEnc_ShiftLow(CPpmd7z_RangeEnc *p)
-{
- if ((UInt32)p->Low < (UInt32)0xFF000000 || (unsigned)(p->Low >> 32) != 0)
- {
- Byte temp = p->Cache;
- do
- {
- IByteOut_Write(p->Stream, (Byte)(temp + (Byte)(p->Low >> 32)));
- temp = 0xFF;
- }
- while (--p->CacheSize != 0);
- p->Cache = (Byte)((UInt32)p->Low >> 24);
- }
- p->CacheSize++;
- p->Low = (UInt32)p->Low << 8;
-}
-
-static void RangeEnc_Encode(CPpmd7z_RangeEnc *p, UInt32 start, UInt32 size, UInt32 total)
-{
- p->Low += start * (p->Range /= total);
- p->Range *= size;
- while (p->Range < kTopValue)
- {
- p->Range <<= 8;
- RangeEnc_ShiftLow(p);
- }
-}
-
-static void RangeEnc_EncodeBit_0(CPpmd7z_RangeEnc *p, UInt32 size0)
-{
- p->Range = (p->Range >> 14) * size0;
- while (p->Range < kTopValue)
- {
- p->Range <<= 8;
- RangeEnc_ShiftLow(p);
- }
-}
-
-static void RangeEnc_EncodeBit_1(CPpmd7z_RangeEnc *p, UInt32 size0)
-{
- UInt32 newBound = (p->Range >> 14) * size0;
- p->Low += newBound;
- p->Range -= newBound;
- while (p->Range < kTopValue)
- {
- p->Range <<= 8;
- RangeEnc_ShiftLow(p);
- }
-}
-
-void Ppmd7z_RangeEnc_FlushData(CPpmd7z_RangeEnc *p)
-{
- unsigned i;
- for (i = 0; i < 5; i++)
- RangeEnc_ShiftLow(p);
-}
-
-
-#define MASK(sym) ((signed char *)charMask)[sym]
-
-void Ppmd7_EncodeSymbol(CPpmd7 *p, CPpmd7z_RangeEnc *rc, int symbol)
-{
- size_t charMask[256 / sizeof(size_t)];
- if (p->MinContext->NumStats != 1)
- {
- CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
- UInt32 sum;
- unsigned i;
- if (s->Symbol == symbol)
- {
- RangeEnc_Encode(rc, 0, s->Freq, p->MinContext->SummFreq);
- p->FoundState = s;
- Ppmd7_Update1_0(p);
- return;
- }
- p->PrevSuccess = 0;
- sum = s->Freq;
- i = p->MinContext->NumStats - 1;
- do
- {
- if ((++s)->Symbol == symbol)
- {
- RangeEnc_Encode(rc, sum, s->Freq, p->MinContext->SummFreq);
- p->FoundState = s;
- Ppmd7_Update1(p);
- return;
- }
- sum += s->Freq;
- }
- while (--i);
-
- p->HiBitsFlag = p->HB2Flag[p->FoundState->Symbol];
- PPMD_SetAllBitsIn256Bytes(charMask);
- MASK(s->Symbol) = 0;
- i = p->MinContext->NumStats - 1;
- do { MASK((--s)->Symbol) = 0; } while (--i);
- RangeEnc_Encode(rc, sum, p->MinContext->SummFreq - sum, p->MinContext->SummFreq);
- }
- else
- {
- UInt16 *prob = Ppmd7_GetBinSumm(p);
- CPpmd_State *s = Ppmd7Context_OneState(p->MinContext);
- if (s->Symbol == symbol)
- {
- RangeEnc_EncodeBit_0(rc, *prob);
- *prob = (UInt16)PPMD_UPDATE_PROB_0(*prob);
- p->FoundState = s;
- Ppmd7_UpdateBin(p);
- return;
- }
- else
- {
- RangeEnc_EncodeBit_1(rc, *prob);
- *prob = (UInt16)PPMD_UPDATE_PROB_1(*prob);
- p->InitEsc = PPMD7_kExpEscape[*prob >> 10];
- PPMD_SetAllBitsIn256Bytes(charMask);
- MASK(s->Symbol) = 0;
- p->PrevSuccess = 0;
- }
- }
- for (;;)
- {
- UInt32 escFreq;
- CPpmd_See *see;
- CPpmd_State *s;
- UInt32 sum;
- unsigned i, numMasked = p->MinContext->NumStats;
- do
- {
- p->OrderFall++;
- if (!p->MinContext->Suffix)
- return; /* EndMarker (symbol = -1) */
- p->MinContext = Ppmd7_GetContext(p, p->MinContext->Suffix);
- }
- while (p->MinContext->NumStats == numMasked);
-
- see = Ppmd7_MakeEscFreq(p, numMasked, &escFreq);
- s = Ppmd7_GetStats(p, p->MinContext);
- sum = 0;
- i = p->MinContext->NumStats;
- do
- {
- int cur = s->Symbol;
- if (cur == symbol)
- {
- UInt32 low = sum;
- CPpmd_State *s1 = s;
- do
- {
- sum += (s->Freq & (int)(MASK(s->Symbol)));
- s++;
- }
- while (--i);
- RangeEnc_Encode(rc, low, s1->Freq, sum + escFreq);
- Ppmd_See_Update(see);
- p->FoundState = s1;
- Ppmd7_Update2(p);
- return;
- }
- sum += (s->Freq & (int)(MASK(cur)));
- MASK(cur) = 0;
- s++;
- }
- while (--i);
-
- RangeEnc_Encode(rc, sum, escFreq, sum + escFreq);
- see->Summ = (UInt16)(see->Summ + sum + escFreq);
- }
-}
+/* Ppmd7Enc.c -- Ppmd7z (PPMdH with 7z Range Coder) Encoder
+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 R (&p->rc.enc)
+
+void Ppmd7z_Init_RangeEnc(CPpmd7 *p)
+{
+ R->Low = 0;
+ R->Range = 0xFFFFFFFF;
+ R->Cache = 0;
+ R->CacheSize = 1;
+}
+
+Z7_NO_INLINE
+static void Ppmd7z_RangeEnc_ShiftLow(CPpmd7 *p)
+{
+ if ((UInt32)R->Low < (UInt32)0xFF000000 || (unsigned)(R->Low >> 32) != 0)
+ {
+ Byte temp = R->Cache;
+ do
+ {
+ IByteOut_Write(R->Stream, (Byte)(temp + (Byte)(R->Low >> 32)));
+ temp = 0xFF;
+ }
+ while (--R->CacheSize != 0);
+ R->Cache = (Byte)((UInt32)R->Low >> 24);
+ }
+ R->CacheSize++;
+ R->Low = (UInt32)((UInt32)R->Low << 8);
+}
+
+#define RC_NORM_BASE(p) if (R->Range < kTopValue) { R->Range <<= 8; Ppmd7z_RangeEnc_ShiftLow(p);
+#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 Ppmd7z_RangeEnc_Encode(p, start, _size_) \
+ { UInt32 size = _size_; \
+ R->Low += start * R->Range; \
+ R->Range *= size; \
+ RC_NORM_LOCAL(p); }
+*/
+
+Z7_FORCE_INLINE
+// Z7_NO_INLINE
+static void Ppmd7z_RangeEnc_Encode(CPpmd7 *p, UInt32 start, UInt32 size)
+{
+ R->Low += start * R->Range;
+ R->Range *= size;
+ RC_NORM_LOCAL(p)
+}
+
+void Ppmd7z_Flush_RangeEnc(CPpmd7 *p)
+{
+ unsigned i;
+ for (i = 0; i < 5; i++)
+ Ppmd7z_RangeEnc_ShiftLow(p);
+}
+
+
+
+#define RC_Encode(start, size) Ppmd7z_RangeEnc_Encode(p, start, size);
+#define RC_EncodeFinal(start, size) RC_Encode(start, size) RC_NORM_REMOTE(p)
+
+#define CTX(ref) ((CPpmd7_Context *)Ppmd7_GetContext(p, ref))
+#define SUFFIX(ctx) CTX((ctx)->Suffix)
+// 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
+void Ppmd7z_EncodeSymbol(CPpmd7 *p, int symbol)
+{
+ size_t charMask[256 / sizeof(size_t)];
+
+ if (p->MinContext->NumStats != 1)
+ {
+ CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
+ UInt32 sum;
+ unsigned i;
+
+
+
+
+ R->Range /= p->MinContext->Union2.SummFreq;
+
+ if (s->Symbol == symbol)
+ {
+ // R->Range /= p->MinContext->Union2.SummFreq;
+ RC_EncodeFinal(0, s->Freq)
+ p->FoundState = s;
+ Ppmd7_Update1_0(p);
+ return;
+ }
+ p->PrevSuccess = 0;
+ sum = s->Freq;
+ i = (unsigned)p->MinContext->NumStats - 1;
+ do
+ {
+ if ((++s)->Symbol == symbol)
+ {
+ // R->Range /= p->MinContext->Union2.SummFreq;
+ RC_EncodeFinal(sum, s->Freq)
+ p->FoundState = s;
+ Ppmd7_Update1(p);
+ return;
+ }
+ sum += s->Freq;
+ }
+ while (--i);
+
+ // R->Range /= p->MinContext->Union2.SummFreq;
+ RC_Encode(sum, p->MinContext->Union2.SummFreq - sum)
+
+ p->HiBitsFlag = PPMD7_HiBitsFlag_3(p->FoundState->Symbol);
+ PPMD_SetAllBitsIn256Bytes(charMask)
+ // MASK(s->Symbol) = 0;
+ // 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
+ {
+ UInt16 *prob = Ppmd7_GetBinSumm(p);
+ CPpmd_State *s = Ppmd7Context_OneState(p->MinContext);
+ UInt32 pr = *prob;
+ const UInt32 bound = (R->Range >> 14) * pr;
+ pr = PPMD_UPDATE_PROB_1(pr);
+ if (s->Symbol == symbol)
+ {
+ *prob = (UInt16)(pr + (1 << PPMD_INT_BITS));
+ // RangeEnc_EncodeBit_0(p, bound);
+ R->Range = bound;
+ RC_NORM_1(p)
+
+ // p->FoundState = s;
+ // Ppmd7_UpdateBin(p);
+ {
+ const unsigned freq = s->Freq;
+ CPpmd7_Context *c = CTX(SUCCESSOR(s));
+ 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;
+ }
+
+ *prob = (UInt16)pr;
+ p->InitEsc = p->ExpEscape[pr >> 10];
+ // RangeEnc_EncodeBit_1(p, bound);
+ R->Low += bound;
+ R->Range -= bound;
+ RC_NORM_LOCAL(p)
+
+ PPMD_SetAllBitsIn256Bytes(charMask)
+ MASK(s->Symbol) = 0;
+ p->PrevSuccess = 0;
+ }
+
+ for (;;)
+ {
+ CPpmd_See *see;
+ CPpmd_State *s;
+ UInt32 sum, escFreq;
+ CPpmd7_Context *mc;
+ unsigned i, numMasked;
+
+ RC_NORM_REMOTE(p)
+
+ mc = p->MinContext;
+ numMasked = mc->NumStats;
+
+ do
+ {
+ p->OrderFall++;
+ if (!mc->Suffix)
+ return; /* EndMarker (symbol = -1) */
+ mc = Ppmd7_GetContext(p, mc->Suffix);
+ i = mc->NumStats;
+ }
+ while (i == numMasked);
+
+ p->MinContext = mc;
+
+ // see = Ppmd7_MakeEscFreq(p, numMasked, &escFreq);
+ {
+ if (i != 256)
+ {
+ unsigned nonMasked = i - numMasked;
+ see = p->See[(unsigned)p->NS2Indx[(size_t)nonMasked - 1]]
+ + p->HiBitsFlag
+ + (nonMasked < (unsigned)SUFFIX(mc)->NumStats - i)
+ + 2 * (unsigned)(mc->Union2.SummFreq < 11 * i)
+ + 4 * (unsigned)(numMasked > nonMasked);
+ {
+ // 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;
+ }
+ }
+
+ s = Ppmd7_GetStats(p, mc);
+ sum = 0;
+ // i = mc->NumStats;
+
+ do
+ {
+ const unsigned cur = s->Symbol;
+ if ((int)cur == symbol)
+ {
+ const UInt32 low = sum;
+ const UInt32 freq = s->Freq;
+ unsigned num2;
+
+ Ppmd_See_UPDATE(see)
+ p->FoundState = s;
+ sum += escFreq;
+
+ num2 = i / 2;
+ i &= 1;
+ sum += freq & (0 - (UInt32)i);
+ if (num2 != 0)
+ {
+ s += i;
+ for (;;)
+ {
+ unsigned sym0 = s[0].Symbol;
+ unsigned sym1 = s[1].Symbol;
+ s += 2;
+ sum += (s[-2].Freq & (unsigned)(MASK(sym0)));
+ sum += (s[-1].Freq & (unsigned)(MASK(sym1)));
+ if (--num2 == 0)
+ break;
+ }
+ }
+
+
+ R->Range /= sum;
+ RC_EncodeFinal(low, freq)
+ Ppmd7_Update2(p);
+ return;
+ }
+ sum += (s->Freq & (unsigned)(MASK(cur)));
+ s++;
+ }
+ while (--i);
+
+ {
+ const UInt32 total = sum + escFreq;
+ see->Summ = (UInt16)(see->Summ + total);
+
+ R->Range /= total;
+ RC_Encode(sum, escFreq)
+ }
+
+ {
+ const CPpmd_State *s2 = Ppmd7_GetStats(p, p->MinContext);
+ s--;
+ MASK(s->Symbol) = 0;
+ do
+ {
+ const unsigned sym0 = s2[0].Symbol;
+ const unsigned sym1 = s2[1].Symbol;
+ s2 += 2;
+ MASK(sym0) = 0;
+ MASK(sym1) = 0;
+ }
+ while (s2 < s);
+ }
+ }
+}
+
+
+void Ppmd7z_EncodeSymbols(CPpmd7 *p, const Byte *buf, const Byte *lim)
+{
+ for (; buf < lim; buf++)
+ {
+ Ppmd7z_EncodeSymbol(p, *buf);
+ }
+}
+
+#undef kTopValue
+#undef WRITE_BYTE
+#undef RC_NORM_BASE
+#undef RC_NORM_1
+#undef RC_NORM
+#undef RC_NORM_LOCAL
+#undef RC_NORM_REMOTE
+#undef R
+#undef RC_Encode
+#undef RC_EncodeFinal
+#undef SUFFIX
+#undef CTX
+#undef SUCCESSOR
+#undef MASK
diff --git a/C/Ppmd7aDec.c b/C/Ppmd7aDec.c
new file mode 100644
index 0000000..55e164e
--- /dev/null
+++ b/C/Ppmd7aDec.c
@@ -0,0 +1,295 @@
+/* Ppmd7aDec.c -- PPMd7a (PPMdH) Decoder
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on:
+ PPMd var.H (2001): Dmitry Shkarin : Public domain
+ Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#include "Precomp.h"
+
+#include "Ppmd7.h"
+
+#define kTop ((UInt32)1 << 24)
+#define kBot ((UInt32)1 << 15)
+
+#define READ_BYTE(p) IByteIn_Read((p)->Stream)
+
+BoolInt Ppmd7a_RangeDec_Init(CPpmd7_RangeDec *p)
+{
+ unsigned i;
+ p->Code = 0;
+ p->Range = 0xFFFFFFFF;
+ p->Low = 0;
+
+ for (i = 0; i < 4; i++)
+ p->Code = (p->Code << 8) | READ_BYTE(p);
+ return (p->Code < 0xFFFFFFFF);
+}
+
+#define RC_NORM(p) \
+ while ((p->Low ^ (p->Low + p->Range)) < kTop \
+ || (p->Range < kBot && ((p->Range = (0 - p->Low) & (kBot - 1)), 1))) { \
+ p->Code = (p->Code << 8) | READ_BYTE(p); \
+ p->Range <<= 8; p->Low <<= 8; }
+
+// 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 Ppmd7a_RD_Decode(CPpmd7 *p, UInt32 start, UInt32 size)
+{
+ start *= R->Range;
+ R->Low += start;
+ R->Code -= start;
+ R->Range *= size;
+ RC_NORM_LOCAL(R)
+}
+
+#define RC_Decode(start, size) Ppmd7a_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]
+
+
+int Ppmd7a_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;
+
+ if (summFreq > R->Range)
+ return PPMD7_SYM_ERROR;
+
+ 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(R)
+
+
+
+ // sym = (p->FoundState = Ppmd7Context_OneState(p->MinContext))->Symbol;
+ // Ppmd7_UpdateBin(p);
+ {
+ unsigned freq = s->Freq;
+ CTX_PTR 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->Low += size0;
+ R->Code -= size0;
+ R->Range = (R->Range & ~((UInt32)PPMD_BIN_SCALE - 1)) - 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;
+
+ if (freqSum > R->Range)
+ return PPMD7_SYM_ERROR;
+
+ 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);
+ }
+}
+
+#undef kTop
+#undef kBot
+#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
diff --git a/C/Ppmd8.c b/C/Ppmd8.c
new file mode 100644
index 0000000..28abf27
--- /dev/null
+++ b/C/Ppmd8.c
@@ -0,0 +1,1565 @@
+/* Ppmd8.c -- PPMdI codec
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on PPMd var.I (2002): Dmitry Shkarin : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Ppmd8.h"
+
+
+
+
+MY_ALIGN(16)
+static const Byte PPMD8_kExpEscape[16] = { 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2 };
+MY_ALIGN(16)
+static const UInt16 PPMD8_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 REF(ptr) Ppmd_GetRef(p, ptr)
+
+#define STATS_REF(ptr) ((CPpmd_State_Ref)REF(ptr))
+
+#define CTX(ref) ((CPpmd8_Context *)Ppmd8_GetContext(p, ref))
+#define STATS(ctx) Ppmd8_GetStats(p, ctx)
+#define ONE_STATE(ctx) Ppmd8Context_OneState(ctx)
+#define SUFFIX(ctx) CTX((ctx)->Suffix)
+
+typedef CPpmd8_Context * PPMD8_CTX_PTR;
+
+struct CPpmd8_Node_;
+
+typedef Ppmd_Ref_Type(struct CPpmd8_Node_) CPpmd8_Node_Ref;
+
+typedef struct CPpmd8_Node_
+{
+ UInt32 Stamp;
+
+ CPpmd8_Node_Ref Next;
+ UInt32 NU;
+} CPpmd8_Node;
+
+#define NODE(r) Ppmd_GetPtr_Type(p, r, CPpmd8_Node)
+
+void Ppmd8_Construct(CPpmd8 *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 < 5; i++)
+ p->NS2Indx[i] = (Byte)i;
+
+ for (m = i, k = 1; i < 260; i++)
+ {
+ p->NS2Indx[i] = (Byte)m;
+ if (--k == 0)
+ k = (++m) - 4;
+ }
+
+ memcpy(p->ExpEscape, PPMD8_kExpEscape, 16);
+}
+
+
+void Ppmd8_Free(CPpmd8 *p, ISzAllocPtr alloc)
+{
+ ISzAlloc_Free(alloc, p->Base);
+ p->Size = 0;
+ p->Base = NULL;
+}
+
+
+BoolInt Ppmd8_Alloc(CPpmd8 *p, UInt32 size, ISzAllocPtr alloc)
+{
+ if (!p->Base || p->Size != size)
+ {
+ Ppmd8_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 ----------
+
+
+
+
+
+
+#define EMPTY_NODE 0xFFFFFFFF
+
+
+static void Ppmd8_InsertNode(CPpmd8 *p, void *node, unsigned indx)
+{
+ ((CPpmd8_Node *)node)->Stamp = EMPTY_NODE;
+ ((CPpmd8_Node *)node)->Next = (CPpmd8_Node_Ref)p->FreeList[indx];
+ ((CPpmd8_Node *)node)->NU = I2U(indx);
+ p->FreeList[indx] = REF(node);
+ p->Stamps[indx]++;
+}
+
+
+static void *Ppmd8_RemoveNode(CPpmd8 *p, unsigned indx)
+{
+ CPpmd8_Node *node = NODE((CPpmd8_Node_Ref)p->FreeList[indx]);
+ p->FreeList[indx] = node->Next;
+ p->Stamps[indx]--;
+
+ return node;
+}
+
+
+static void Ppmd8_SplitBlock(CPpmd8 *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);
+ Ppmd8_InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1);
+ }
+ Ppmd8_InsertNode(p, ptr, i);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static void Ppmd8_GlueFreeBlocks(CPpmd8 *p)
+{
+ /*
+ we use first UInt32 field of 12-bytes UNITs as record type stamp
+ CPpmd_State { Byte Symbol; Byte Freq; : Freq != 0xFF
+ CPpmd8_Context { Byte NumStats; Byte Flags; UInt16 SummFreq; : Flags != 0xFF ???
+ CPpmd8_Node { UInt32 Stamp : Stamp == 0xFFFFFFFF for free record
+ : Stamp == 0 for guard
+ Last 12-bytes UNIT in array is always contains 12-bytes order-0 CPpmd8_Context record
+ */
+ CPpmd8_Node_Ref n;
+
+ p->GlueCount = 1 << 13;
+ memset(p->Stamps, 0, sizeof(p->Stamps));
+
+ /* we set guard NODE at LoUnit */
+ if (p->LoUnit != p->HiUnit)
+ ((CPpmd8_Node *)(void *)p->LoUnit)->Stamp = 0;
+
+ {
+ /* Glue free blocks */
+ CPpmd8_Node_Ref *prev = &n;
+ unsigned i;
+ for (i = 0; i < PPMD_NUM_INDEXES; i++)
+ {
+
+ CPpmd8_Node_Ref next = (CPpmd8_Node_Ref)p->FreeList[i];
+ p->FreeList[i] = 0;
+ while (next != 0)
+ {
+ CPpmd8_Node *node = NODE(next);
+ UInt32 nu = node->NU;
+ *prev = next;
+ next = node->Next;
+ if (nu != 0)
+ {
+ CPpmd8_Node *node2;
+ prev = &(node->Next);
+ while ((node2 = node + nu)->Stamp == EMPTY_NODE)
+ {
+ nu += node2->NU;
+ node2->NU = 0;
+ node->NU = nu;
+ }
+ }
+ }
+ }
+
+ *prev = 0;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ /* Fill lists of free blocks */
+ while (n != 0)
+ {
+ CPpmd8_Node *node = NODE(n);
+ UInt32 nu = node->NU;
+ unsigned i;
+ n = node->Next;
+ if (nu == 0)
+ continue;
+ for (; nu > 128; nu -= 128, node += 128)
+ Ppmd8_InsertNode(p, node, PPMD_NUM_INDEXES - 1);
+ if (I2U(i = U2I(nu)) != nu)
+ {
+ unsigned k = I2U(--i);
+ Ppmd8_InsertNode(p, node + k, (unsigned)nu - k - 1);
+ }
+ Ppmd8_InsertNode(p, node, i);
+ }
+}
+
+
+Z7_NO_INLINE
+static void *Ppmd8_AllocUnitsRare(CPpmd8 *p, unsigned indx)
+{
+ unsigned i;
+
+ if (p->GlueCount == 0)
+ {
+ Ppmd8_GlueFreeBlocks(p);
+ if (p->FreeList[indx] != 0)
+ return Ppmd8_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 = Ppmd8_RemoveNode(p, i);
+ Ppmd8_SplitBlock(p, block, i, indx);
+ return block;
+ }
+}
+
+
+static void *Ppmd8_AllocUnits(CPpmd8 *p, unsigned indx)
+{
+ if (p->FreeList[indx] != 0)
+ return Ppmd8_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 Ppmd8_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(CPpmd8 *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 = Ppmd8_RemoveNode(p, i1);
+ MEM_12_CPY(ptr, oldPtr, newNU)
+ Ppmd8_InsertNode(p, oldPtr, i0);
+ return ptr;
+ }
+ Ppmd8_SplitBlock(p, oldPtr, i0, i1);
+ return oldPtr;
+}
+
+
+static void FreeUnits(CPpmd8 *p, void *ptr, unsigned nu)
+{
+ Ppmd8_InsertNode(p, ptr, U2I(nu));
+}
+
+
+static void SpecialFreeUnit(CPpmd8 *p, void *ptr)
+{
+ if ((Byte *)ptr != p->UnitsStart)
+ Ppmd8_InsertNode(p, ptr, 0);
+ else
+ {
+ #ifdef PPMD8_FREEZE_SUPPORT
+ *(UInt32 *)ptr = EMPTY_NODE; /* it's used for (Flags == 0xFF) check in RemoveBinContexts() */
+ #endif
+ p->UnitsStart += UNIT_SIZE;
+ }
+}
+
+
+/*
+static void *MoveUnitsUp(CPpmd8 *p, void *oldPtr, unsigned nu)
+{
+ unsigned indx = U2I(nu);
+ void *ptr;
+ if ((Byte *)oldPtr > p->UnitsStart + (1 << 14) || REF(oldPtr) > p->FreeList[indx])
+ return oldPtr;
+ ptr = Ppmd8_RemoveNode(p, indx);
+ MEM_12_CPY(ptr, oldPtr, nu)
+ if ((Byte *)oldPtr != p->UnitsStart)
+ Ppmd8_InsertNode(p, oldPtr, indx);
+ else
+ p->UnitsStart += U2B(I2U(indx));
+ return ptr;
+}
+*/
+
+static void ExpandTextArea(CPpmd8 *p)
+{
+ UInt32 count[PPMD_NUM_INDEXES];
+ unsigned i;
+
+ memset(count, 0, sizeof(count));
+ if (p->LoUnit != p->HiUnit)
+ ((CPpmd8_Node *)(void *)p->LoUnit)->Stamp = 0;
+
+ {
+ CPpmd8_Node *node = (CPpmd8_Node *)(void *)p->UnitsStart;
+ while (node->Stamp == EMPTY_NODE)
+ {
+ UInt32 nu = node->NU;
+ node->Stamp = 0;
+ count[U2I(nu)]++;
+ node += nu;
+ }
+ p->UnitsStart = (Byte *)node;
+ }
+
+ for (i = 0; i < PPMD_NUM_INDEXES; i++)
+ {
+ UInt32 cnt = count[i];
+ if (cnt == 0)
+ continue;
+ {
+ CPpmd8_Node_Ref *prev = (CPpmd8_Node_Ref *)&p->FreeList[i];
+ CPpmd8_Node_Ref n = *prev;
+ p->Stamps[i] -= cnt;
+ for (;;)
+ {
+ CPpmd8_Node *node = NODE(n);
+ n = node->Next;
+ if (node->Stamp != 0)
+ {
+ prev = &node->Next;
+ continue;
+ }
+ *prev = n;
+ if (--cnt == 0)
+ break;
+ }
+ }
+ }
+}
+
+
+#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)
+static void Ppmd8State_SetSuccessor(CPpmd_State *p, CPpmd_Void_Ref v)
+{
+ Ppmd_SET_SUCCESSOR(p, v)
+}
+
+#define RESET_TEXT(offs) { p->Text = p->Base + p->AlignOffset + (offs); }
+
+Z7_NO_INLINE
+static
+void Ppmd8_RestartModel(CPpmd8 *p)
+{
+ unsigned i, k, m;
+
+ memset(p->FreeList, 0, sizeof(p->FreeList));
+ memset(p->Stamps, 0, sizeof(p->Stamps));
+ RESET_TEXT(0)
+ 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;
+
+ {
+ CPpmd8_Context *mc = (PPMD8_CTX_PTR)(void *)(p->HiUnit -= UNIT_SIZE); /* AllocContext(p); */
+ CPpmd_State *s = (CPpmd_State *)p->LoUnit; /* Ppmd8_AllocUnits(p, PPMD_NUM_INDEXES - 1); */
+
+ p->LoUnit += U2B(256 / 2);
+ p->MaxContext = p->MinContext = mc;
+ p->FoundState = s;
+ mc->Flags = 0;
+ mc->NumStats = 256 - 1;
+ 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;
+ Ppmd8State_SetSuccessor(s, 0);
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+ for (i = m = 0; m < 25; m++)
+ {
+ while (p->NS2Indx[i] == m)
+ i++;
+ for (k = 0; k < 8; k++)
+ {
+ unsigned r;
+ UInt16 *dest = p->BinSumm[m] + k;
+ const UInt16 val = (UInt16)(PPMD_BIN_SCALE - PPMD8_kInitBinEsc[k] / (i + 1));
+ for (r = 0; r < 64; r += 8)
+ dest[r] = val;
+ }
+ }
+
+ for (i = m = 0; m < 24; m++)
+ {
+ unsigned summ;
+ CPpmd_See *s;
+ while (p->NS2Indx[(size_t)i + 3] == m + 3)
+ i++;
+ s = p->See[m];
+ summ = ((2 * i + 5) << (PPMD_PERIOD_BITS - 4));
+ for (k = 0; k < 32; k++, s++)
+ {
+ s->Summ = (UInt16)summ;
+ s->Shift = (PPMD_PERIOD_BITS - 4);
+ s->Count = 7;
+ }
+ }
+
+ p->DummySee.Summ = 0; /* unused */
+ p->DummySee.Shift = PPMD_PERIOD_BITS;
+ p->DummySee.Count = 64; /* unused */
+}
+
+
+void Ppmd8_Init(CPpmd8 *p, unsigned maxOrder, unsigned restoreMethod)
+{
+ p->MaxOrder = maxOrder;
+ p->RestoreMethod = restoreMethod;
+ Ppmd8_RestartModel(p);
+}
+
+
+#define FLAG_RESCALED (1 << 2)
+// #define FLAG_SYM_HIGH (1 << 3)
+#define FLAG_PREV_HIGH (1 << 4)
+
+#define HiBits_Prepare(sym) ((unsigned)(sym) + 0xC0)
+
+#define HiBits_Convert_3(flags) (((flags) >> (8 - 3)) & (1 << 3))
+#define HiBits_Convert_4(flags) (((flags) >> (8 - 4)) & (1 << 4))
+
+#define PPMD8_HiBitsFlag_3(sym) HiBits_Convert_3(HiBits_Prepare(sym))
+#define PPMD8_HiBitsFlag_4(sym) HiBits_Convert_4(HiBits_Prepare(sym))
+
+// #define PPMD8_HiBitsFlag_3(sym) (0x08 * ((sym) >= 0x40))
+// #define PPMD8_HiBitsFlag_4(sym) (0x10 * ((sym) >= 0x40))
+
+/*
+Refresh() is called when we remove some symbols (successors) in context.
+It increases Escape_Freq for sum of all removed symbols.
+*/
+
+static void Refresh(CPpmd8 *p, PPMD8_CTX_PTR ctx, unsigned oldNU, unsigned scale)
+{
+ unsigned i = ctx->NumStats, escFreq, sumFreq, flags;
+ CPpmd_State *s = (CPpmd_State *)ShrinkUnits(p, STATS(ctx), oldNU, (i + 2) >> 1);
+ ctx->Union4.Stats = REF(s);
+
+ // #ifdef PPMD8_FREEZE_SUPPORT
+ /*
+ (ctx->Union2.SummFreq >= ((UInt32)1 << 15)) can be in FREEZE mode for some files.
+ It's not good for range coder. So new versions of support fix:
+ - original PPMdI code rev.1
+ + original PPMdI code rev.2
+ - 7-Zip default ((PPMD8_FREEZE_SUPPORT is not defined)
+ + 7-Zip (p->RestoreMethod >= PPMD8_RESTORE_METHOD_FREEZE)
+ if we use that fixed line, we can lose compatibility with some files created before fix
+ if we don't use that fixed line, the program can work incorrectly in FREEZE mode in rare case.
+ */
+ // if (p->RestoreMethod >= PPMD8_RESTORE_METHOD_FREEZE)
+ {
+ scale |= (ctx->Union2.SummFreq >= ((UInt32)1 << 15));
+ }
+ // #endif
+
+
+
+ flags = HiBits_Prepare(s->Symbol);
+ {
+ unsigned freq = s->Freq;
+ escFreq = ctx->Union2.SummFreq - freq;
+ freq = (freq + scale) >> scale;
+ sumFreq = freq;
+ s->Freq = (Byte)freq;
+ }
+
+ do
+ {
+ unsigned freq = (++s)->Freq;
+ escFreq -= freq;
+ freq = (freq + scale) >> scale;
+ sumFreq += freq;
+ s->Freq = (Byte)freq;
+ flags |= HiBits_Prepare(s->Symbol);
+ }
+ while (--i);
+
+ ctx->Union2.SummFreq = (UInt16)(sumFreq + ((escFreq + scale) >> scale));
+ ctx->Flags = (Byte)((ctx->Flags & (FLAG_PREV_HIGH + FLAG_RESCALED * scale)) + HiBits_Convert_3(flags));
+}
+
+
+static void SWAP_STATES(CPpmd_State *t1, CPpmd_State *t2)
+{
+ CPpmd_State tmp = *t1;
+ *t1 = *t2;
+ *t2 = tmp;
+}
+
+
+/*
+CutOff() reduces contexts:
+ It conversts Successors at MaxOrder to another Contexts to NULL-Successors
+ It removes RAW-Successors and NULL-Successors that are not Order-0
+ and it removes contexts when it has no Successors.
+ if the (Union4.Stats) is close to (UnitsStart), it moves it up.
+*/
+
+static CPpmd_Void_Ref CutOff(CPpmd8 *p, PPMD8_CTX_PTR ctx, unsigned order)
+{
+ int ns = ctx->NumStats;
+ unsigned nu;
+ CPpmd_State *stats;
+
+ if (ns == 0)
+ {
+ CPpmd_State *s = ONE_STATE(ctx);
+ CPpmd_Void_Ref successor = SUCCESSOR(s);
+ if ((Byte *)Ppmd8_GetPtr(p, successor) >= p->UnitsStart)
+ {
+ if (order < p->MaxOrder)
+ successor = CutOff(p, CTX(successor), order + 1);
+ else
+ successor = 0;
+ Ppmd8State_SetSuccessor(s, successor);
+ if (successor || order <= 9) /* O_BOUND */
+ return REF(ctx);
+ }
+ SpecialFreeUnit(p, ctx);
+ return 0;
+ }
+
+ nu = ((unsigned)ns + 2) >> 1;
+ // ctx->Union4.Stats = STATS_REF(MoveUnitsUp(p, STATS(ctx), nu));
+ {
+ unsigned indx = U2I(nu);
+ stats = STATS(ctx);
+
+ if ((UInt32)((Byte *)stats - p->UnitsStart) <= (1 << 14)
+ && (CPpmd_Void_Ref)ctx->Union4.Stats <= p->FreeList[indx])
+ {
+ void *ptr = Ppmd8_RemoveNode(p, indx);
+ ctx->Union4.Stats = STATS_REF(ptr);
+ MEM_12_CPY(ptr, (const void *)stats, nu)
+ if ((Byte *)stats != p->UnitsStart)
+ Ppmd8_InsertNode(p, stats, indx);
+ else
+ p->UnitsStart += U2B(I2U(indx));
+ stats = ptr;
+ }
+ }
+
+ {
+ CPpmd_State *s = stats + (unsigned)ns;
+ do
+ {
+ CPpmd_Void_Ref successor = SUCCESSOR(s);
+ if ((Byte *)Ppmd8_GetPtr(p, successor) < p->UnitsStart)
+ {
+ CPpmd_State *s2 = stats + (unsigned)(ns--);
+ if (order)
+ {
+ if (s != s2)
+ *s = *s2;
+ }
+ else
+ {
+ SWAP_STATES(s, s2);
+ Ppmd8State_SetSuccessor(s2, 0);
+ }
+ }
+ else
+ {
+ if (order < p->MaxOrder)
+ Ppmd8State_SetSuccessor(s, CutOff(p, CTX(successor), order + 1));
+ else
+ Ppmd8State_SetSuccessor(s, 0);
+ }
+ }
+ while (--s >= stats);
+ }
+
+ if (ns != ctx->NumStats && order)
+ {
+ if (ns < 0)
+ {
+ FreeUnits(p, stats, nu);
+ SpecialFreeUnit(p, ctx);
+ return 0;
+ }
+ ctx->NumStats = (Byte)ns;
+ if (ns == 0)
+ {
+ const Byte sym = stats->Symbol;
+ ctx->Flags = (Byte)((ctx->Flags & FLAG_PREV_HIGH) + PPMD8_HiBitsFlag_3(sym));
+ // *ONE_STATE(ctx) = *stats;
+ ctx->Union2.State2.Symbol = sym;
+ ctx->Union2.State2.Freq = (Byte)(((unsigned)stats->Freq + 11) >> 3);
+ ctx->Union4.State4.Successor_0 = stats->Successor_0;
+ ctx->Union4.State4.Successor_1 = stats->Successor_1;
+ FreeUnits(p, stats, nu);
+ }
+ else
+ {
+ Refresh(p, ctx, nu, ctx->Union2.SummFreq > 16 * (unsigned)ns);
+ }
+ }
+
+ return REF(ctx);
+}
+
+
+
+#ifdef PPMD8_FREEZE_SUPPORT
+
+/*
+RemoveBinContexts()
+ It conversts Successors at MaxOrder to another Contexts to NULL-Successors
+ It changes RAW-Successors to NULL-Successors
+ removes Bin Context without Successor, if suffix of that context is also binary.
+*/
+
+static CPpmd_Void_Ref RemoveBinContexts(CPpmd8 *p, PPMD8_CTX_PTR ctx, unsigned order)
+{
+ if (!ctx->NumStats)
+ {
+ CPpmd_State *s = ONE_STATE(ctx);
+ CPpmd_Void_Ref successor = SUCCESSOR(s);
+ if ((Byte *)Ppmd8_GetPtr(p, successor) >= p->UnitsStart && order < p->MaxOrder)
+ successor = RemoveBinContexts(p, CTX(successor), order + 1);
+ else
+ successor = 0;
+ Ppmd8State_SetSuccessor(s, successor);
+ /* Suffix context can be removed already, since different (high-order)
+ Successors may refer to same context. So we check Flags == 0xFF (Stamp == EMPTY_NODE) */
+ if (!successor && (!SUFFIX(ctx)->NumStats || SUFFIX(ctx)->Flags == 0xFF))
+ {
+ FreeUnits(p, ctx, 1);
+ return 0;
+ }
+ }
+ else
+ {
+ CPpmd_State *s = STATS(ctx) + ctx->NumStats;
+ do
+ {
+ CPpmd_Void_Ref successor = SUCCESSOR(s);
+ if ((Byte *)Ppmd8_GetPtr(p, successor) >= p->UnitsStart && order < p->MaxOrder)
+ Ppmd8State_SetSuccessor(s, RemoveBinContexts(p, CTX(successor), order + 1));
+ else
+ Ppmd8State_SetSuccessor(s, 0);
+ }
+ while (--s >= STATS(ctx));
+ }
+
+ return REF(ctx);
+}
+
+#endif
+
+
+
+static UInt32 GetUsedMemory(const CPpmd8 *p)
+{
+ UInt32 v = 0;
+ unsigned i;
+ for (i = 0; i < PPMD_NUM_INDEXES; i++)
+ v += p->Stamps[i] * I2U(i);
+ return p->Size - (UInt32)(p->HiUnit - p->LoUnit) - (UInt32)(p->UnitsStart - p->Text) - U2B(v);
+}
+
+#ifdef PPMD8_FREEZE_SUPPORT
+ #define RESTORE_MODEL(c1, fSuccessor) RestoreModel(p, c1, fSuccessor)
+#else
+ #define RESTORE_MODEL(c1, fSuccessor) RestoreModel(p, c1)
+#endif
+
+
+static void RestoreModel(CPpmd8 *p, PPMD8_CTX_PTR ctxError
+ #ifdef PPMD8_FREEZE_SUPPORT
+ , PPMD8_CTX_PTR fSuccessor
+ #endif
+ )
+{
+ PPMD8_CTX_PTR c;
+ CPpmd_State *s;
+ RESET_TEXT(0)
+
+ // we go here in cases of error of allocation for context (c1)
+ // Order(MinContext) < Order(ctxError) <= Order(MaxContext)
+
+ // We remove last symbol from each of contexts [p->MaxContext ... ctxError) contexts
+ // So we rollback all created (symbols) before error.
+ for (c = p->MaxContext; c != ctxError; c = SUFFIX(c))
+ if (--(c->NumStats) == 0)
+ {
+ s = STATS(c);
+ c->Flags = (Byte)((c->Flags & FLAG_PREV_HIGH) + PPMD8_HiBitsFlag_3(s->Symbol));
+ // *ONE_STATE(c) = *s;
+ c->Union2.State2.Symbol = s->Symbol;
+ c->Union2.State2.Freq = (Byte)(((unsigned)s->Freq + 11) >> 3);
+ c->Union4.State4.Successor_0 = s->Successor_0;
+ c->Union4.State4.Successor_1 = s->Successor_1;
+
+ SpecialFreeUnit(p, s);
+ }
+ else
+ {
+ /* Refresh() can increase Escape_Freq on value of Freq of last symbol, that was added before error.
+ so the largest possible increase for Escape_Freq is (8) from value before ModelUpoadet() */
+ Refresh(p, c, ((unsigned)c->NumStats + 3) >> 1, 0);
+ }
+
+ // increase Escape Freq for context [ctxError ... p->MinContext)
+ for (; c != p->MinContext; c = SUFFIX(c))
+ if (c->NumStats == 0)
+ {
+ // ONE_STATE(c)
+ c->Union2.State2.Freq = (Byte)(((unsigned)c->Union2.State2.Freq + 1) >> 1);
+ }
+ else if ((c->Union2.SummFreq = (UInt16)(c->Union2.SummFreq + 4)) > 128 + 4 * c->NumStats)
+ Refresh(p, c, ((unsigned)c->NumStats + 2) >> 1, 1);
+
+ #ifdef PPMD8_FREEZE_SUPPORT
+ if (p->RestoreMethod > PPMD8_RESTORE_METHOD_FREEZE)
+ {
+ p->MaxContext = fSuccessor;
+ p->GlueCount += !(p->Stamps[1] & 1); // why?
+ }
+ else if (p->RestoreMethod == PPMD8_RESTORE_METHOD_FREEZE)
+ {
+ while (p->MaxContext->Suffix)
+ p->MaxContext = SUFFIX(p->MaxContext);
+ RemoveBinContexts(p, p->MaxContext, 0);
+ // we change the current mode to (PPMD8_RESTORE_METHOD_FREEZE + 1)
+ p->RestoreMethod = PPMD8_RESTORE_METHOD_FREEZE + 1;
+ p->GlueCount = 0;
+ p->OrderFall = p->MaxOrder;
+ }
+ else
+ #endif
+ if (p->RestoreMethod == PPMD8_RESTORE_METHOD_RESTART || GetUsedMemory(p) < (p->Size >> 1))
+ Ppmd8_RestartModel(p);
+ else
+ {
+ while (p->MaxContext->Suffix)
+ p->MaxContext = SUFFIX(p->MaxContext);
+ do
+ {
+ CutOff(p, p->MaxContext, 0);
+ ExpandTextArea(p);
+ }
+ while (GetUsedMemory(p) > 3 * (p->Size >> 2));
+ p->GlueCount = 0;
+ p->OrderFall = p->MaxOrder;
+ }
+ p->MinContext = p->MaxContext;
+}
+
+
+
+Z7_NO_INLINE
+static PPMD8_CTX_PTR Ppmd8_CreateSuccessors(CPpmd8 *p, BoolInt skip, CPpmd_State *s1, PPMD8_CTX_PTR c)
+{
+
+ CPpmd_Byte_Ref upBranch = (CPpmd_Byte_Ref)SUCCESSOR(p->FoundState);
+ Byte newSym, newFreq, flags;
+ unsigned numPs = 0;
+ CPpmd_State *ps[PPMD8_MAX_ORDER + 1]; /* fixed over Shkarin's code. Maybe it could work without + 1 too. */
+
+ if (!skip)
+ ps[numPs++] = p->FoundState;
+
+ while (c->Suffix)
+ {
+ CPpmd_Void_Ref successor;
+ CPpmd_State *s;
+ c = SUFFIX(c);
+
+ if (s1) { s = s1; s1 = NULL; }
+ else if (c->NumStats != 0)
+ {
+ Byte sym = p->FoundState->Symbol;
+ for (s = STATS(c); s->Symbol != sym; s++);
+ if (s->Freq < MAX_FREQ - 9) { s->Freq++; c->Union2.SummFreq++; }
+ }
+ else
+ {
+ s = ONE_STATE(c);
+ s->Freq = (Byte)(s->Freq + (!SUFFIX(c)->NumStats & (s->Freq < 24)));
+ }
+ successor = SUCCESSOR(s);
+ if (successor != upBranch)
+ {
+
+ c = CTX(successor);
+ if (numPs == 0)
+ {
+
+
+ return c;
+ }
+ break;
+ }
+ ps[numPs++] = s;
+ }
+
+
+
+
+
+ newSym = *(const Byte *)Ppmd8_GetPtr(p, upBranch);
+ upBranch++;
+ flags = (Byte)(PPMD8_HiBitsFlag_4(p->FoundState->Symbol) + PPMD8_HiBitsFlag_3(newSym));
+
+ if (c->NumStats == 0)
+ newFreq = c->Union2.State2.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;
+ /*
+
+
+ max(newFreq)= (s->Freq - 1), when (s0 == 1)
+
+
+ */
+ newFreq = (Byte)(1 + ((2 * cf <= s0) ? (5 * cf > s0) : ((cf + 2 * s0 - 3) / s0)));
+ }
+
+
+
+ do
+ {
+ PPMD8_CTX_PTR c1;
+ /* = AllocContext(p); */
+ if (p->HiUnit != p->LoUnit)
+ c1 = (PPMD8_CTX_PTR)(void *)(p->HiUnit -= UNIT_SIZE);
+ else if (p->FreeList[0] != 0)
+ c1 = (PPMD8_CTX_PTR)Ppmd8_RemoveNode(p, 0);
+ else
+ {
+ c1 = (PPMD8_CTX_PTR)Ppmd8_AllocUnitsRare(p, 0);
+ if (!c1)
+ return NULL;
+ }
+ c1->Flags = flags;
+ c1->NumStats = 0;
+ c1->Union2.State2.Symbol = newSym;
+ c1->Union2.State2.Freq = newFreq;
+ Ppmd8State_SetSuccessor(ONE_STATE(c1), upBranch);
+ c1->Suffix = REF(c);
+ Ppmd8State_SetSuccessor(ps[--numPs], REF(c1));
+ c = c1;
+ }
+ while (numPs != 0);
+
+ return c;
+}
+
+
+static PPMD8_CTX_PTR ReduceOrder(CPpmd8 *p, CPpmd_State *s1, PPMD8_CTX_PTR c)
+{
+ CPpmd_State *s = NULL;
+ PPMD8_CTX_PTR c1 = c;
+ CPpmd_Void_Ref upBranch = REF(p->Text);
+
+ #ifdef PPMD8_FREEZE_SUPPORT
+ /* The BUG in Shkarin's code was fixed: ps could overflow in CUT_OFF mode. */
+ CPpmd_State *ps[PPMD8_MAX_ORDER + 1];
+ unsigned numPs = 0;
+ ps[numPs++] = p->FoundState;
+ #endif
+
+ Ppmd8State_SetSuccessor(p->FoundState, upBranch);
+ p->OrderFall++;
+
+ for (;;)
+ {
+ if (s1)
+ {
+ c = SUFFIX(c);
+ s = s1;
+ s1 = NULL;
+ }
+ else
+ {
+ if (!c->Suffix)
+ {
+ #ifdef PPMD8_FREEZE_SUPPORT
+ if (p->RestoreMethod > PPMD8_RESTORE_METHOD_FREEZE)
+ {
+ do { Ppmd8State_SetSuccessor(ps[--numPs], REF(c)); } while (numPs);
+ RESET_TEXT(1)
+ p->OrderFall = 1;
+ }
+ #endif
+ return c;
+ }
+ c = SUFFIX(c);
+ if (c->NumStats)
+ {
+ if ((s = STATS(c))->Symbol != p->FoundState->Symbol)
+ do { s++; } while (s->Symbol != p->FoundState->Symbol);
+ if (s->Freq < MAX_FREQ - 9)
+ {
+ s->Freq = (Byte)(s->Freq + 2);
+ c->Union2.SummFreq = (UInt16)(c->Union2.SummFreq + 2);
+ }
+ }
+ else
+ {
+ s = ONE_STATE(c);
+ s->Freq = (Byte)(s->Freq + (s->Freq < 32));
+ }
+ }
+ if (SUCCESSOR(s))
+ break;
+ #ifdef PPMD8_FREEZE_SUPPORT
+ ps[numPs++] = s;
+ #endif
+ Ppmd8State_SetSuccessor(s, upBranch);
+ p->OrderFall++;
+ }
+
+ #ifdef PPMD8_FREEZE_SUPPORT
+ if (p->RestoreMethod > PPMD8_RESTORE_METHOD_FREEZE)
+ {
+ c = CTX(SUCCESSOR(s));
+ do { Ppmd8State_SetSuccessor(ps[--numPs], REF(c)); } while (numPs);
+ RESET_TEXT(1)
+ p->OrderFall = 1;
+ return c;
+ }
+ else
+ #endif
+ if (SUCCESSOR(s) <= upBranch)
+ {
+ PPMD8_CTX_PTR successor;
+ CPpmd_State *s2 = p->FoundState;
+ p->FoundState = s;
+
+ successor = Ppmd8_CreateSuccessors(p, False, NULL, c);
+ if (!successor)
+ Ppmd8State_SetSuccessor(s, 0);
+ else
+ Ppmd8State_SetSuccessor(s, REF(successor));
+ p->FoundState = s2;
+ }
+
+ {
+ CPpmd_Void_Ref successor = SUCCESSOR(s);
+ if (p->OrderFall == 1 && c1 == p->MaxContext)
+ {
+ Ppmd8State_SetSuccessor(p->FoundState, successor);
+ p->Text--;
+ }
+ if (successor == 0)
+ return NULL;
+ return CTX(successor);
+ }
+}
+
+
+
+void Ppmd8_UpdateModel(CPpmd8 *p);
+Z7_NO_INLINE
+void Ppmd8_UpdateModel(CPpmd8 *p)
+{
+ CPpmd_Void_Ref maxSuccessor, minSuccessor = SUCCESSOR(p->FoundState);
+ PPMD8_CTX_PTR c;
+ unsigned s0, ns, fFreq = p->FoundState->Freq;
+ Byte flag, fSymbol = p->FoundState->Symbol;
+ {
+ CPpmd_State *s = NULL;
+ if (p->FoundState->Freq < MAX_FREQ / 4 && p->MinContext->Suffix != 0)
+ {
+ /* Update Freqs in Suffix Context */
+
+ c = SUFFIX(p->MinContext);
+
+ if (c->NumStats == 0)
+ {
+ s = ONE_STATE(c);
+ if (s->Freq < 32)
+ s->Freq++;
+ }
+ else
+ {
+ Byte sym = p->FoundState->Symbol;
+ s = STATS(c);
+
+ if (s->Symbol != sym)
+ {
+ do
+ {
+
+ s++;
+ }
+ while (s->Symbol != sym);
+
+ if (s[0].Freq >= s[-1].Freq)
+ {
+ SWAP_STATES(&s[0], &s[-1]);
+ s--;
+ }
+ }
+
+ if (s->Freq < MAX_FREQ - 9)
+ {
+ s->Freq = (Byte)(s->Freq + 2);
+ c->Union2.SummFreq = (UInt16)(c->Union2.SummFreq + 2);
+ }
+ }
+ }
+
+ c = p->MaxContext;
+ if (p->OrderFall == 0 && minSuccessor)
+ {
+ PPMD8_CTX_PTR cs = Ppmd8_CreateSuccessors(p, True, s, p->MinContext);
+ if (!cs)
+ {
+ Ppmd8State_SetSuccessor(p->FoundState, 0);
+ RESTORE_MODEL(c, CTX(minSuccessor));
+ return;
+ }
+ Ppmd8State_SetSuccessor(p->FoundState, REF(cs));
+ p->MinContext = p->MaxContext = cs;
+ return;
+ }
+
+
+
+
+ {
+ Byte *text = p->Text;
+ *text++ = p->FoundState->Symbol;
+ p->Text = text;
+ if (text >= p->UnitsStart)
+ {
+ RESTORE_MODEL(c, CTX(minSuccessor)); /* check it */
+ return;
+ }
+ maxSuccessor = REF(text);
+ }
+
+ if (!minSuccessor)
+ {
+ PPMD8_CTX_PTR cs = ReduceOrder(p, s, p->MinContext);
+ if (!cs)
+ {
+ RESTORE_MODEL(c, NULL);
+ return;
+ }
+ minSuccessor = REF(cs);
+ }
+ else if ((Byte *)Ppmd8_GetPtr(p, minSuccessor) < p->UnitsStart)
+ {
+ PPMD8_CTX_PTR cs = Ppmd8_CreateSuccessors(p, False, s, p->MinContext);
+ if (!cs)
+ {
+ RESTORE_MODEL(c, NULL);
+ return;
+ }
+ minSuccessor = REF(cs);
+ }
+
+ if (--p->OrderFall == 0)
+ {
+ maxSuccessor = minSuccessor;
+ p->Text -= (p->MaxContext != p->MinContext);
+ }
+ #ifdef PPMD8_FREEZE_SUPPORT
+ else if (p->RestoreMethod > PPMD8_RESTORE_METHOD_FREEZE)
+ {
+ maxSuccessor = minSuccessor;
+ RESET_TEXT(0)
+ p->OrderFall = 0;
+ }
+ #endif
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ flag = (Byte)(PPMD8_HiBitsFlag_3(fSymbol));
+ s0 = p->MinContext->Union2.SummFreq - (ns = p->MinContext->NumStats) - fFreq;
+
+ for (; c != p->MinContext; c = SUFFIX(c))
+ {
+ unsigned ns1;
+ UInt32 sum;
+
+ if ((ns1 = c->NumStats) != 0)
+ {
+ if ((ns1 & 1) != 0)
+ {
+ /* Expand for one UNIT */
+ unsigned oldNU = (ns1 + 1) >> 1;
+ unsigned i = U2I(oldNU);
+ if (i != U2I((size_t)oldNU + 1))
+ {
+ void *ptr = Ppmd8_AllocUnits(p, i + 1);
+ void *oldPtr;
+ if (!ptr)
+ {
+ RESTORE_MODEL(c, CTX(minSuccessor));
+ return;
+ }
+ oldPtr = STATS(c);
+ MEM_12_CPY(ptr, oldPtr, oldNU)
+ Ppmd8_InsertNode(p, oldPtr, i);
+ c->Union4.Stats = STATS_REF(ptr);
+ }
+ }
+ sum = c->Union2.SummFreq;
+ /* max increase of Escape_Freq is 1 here.
+ an average increase is 1/3 per symbol */
+ sum += (3 * ns1 + 1 < ns);
+ /* original PPMdH uses 16-bit variable for (sum) here.
+ But (sum < ???). Do we need to truncate (sum) to 16-bit */
+ // sum = (UInt16)sum;
+ }
+ else
+ {
+
+ CPpmd_State *s = (CPpmd_State*)Ppmd8_AllocUnits(p, 0);
+ if (!s)
+ {
+ RESTORE_MODEL(c, CTX(minSuccessor));
+ 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;
+ // Ppmd8State_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;
+
+ s->Freq = (Byte)freq;
+
+ sum = freq + p->InitEsc + (ns > 2); // Ppmd8 (> 2)
+ }
+ }
+
+ {
+ CPpmd_State *s = STATS(c) + ns1 + 1;
+ UInt32 cf = 2 * (sum + 6) * (UInt32)fFreq;
+ UInt32 sf = (UInt32)s0 + sum;
+ s->Symbol = fSymbol;
+ c->NumStats = (Byte)(ns1 + 1);
+ Ppmd8State_SetSuccessor(s, maxSuccessor);
+ c->Flags |= flag;
+ if (cf < 6 * sf)
+ {
+ cf = (unsigned)1 + (cf > sf) + (cf >= 4 * sf);
+ sum += 4;
+ /* It can add (1, 2, 3) to Escape_Freq */
+ }
+ else
+ {
+ cf = (unsigned)4 + (cf > 9 * sf) + (cf > 12 * sf) + (cf > 15 * sf);
+ sum += cf;
+ }
+
+ c->Union2.SummFreq = (UInt16)sum;
+ s->Freq = (Byte)cf;
+ }
+
+ }
+ p->MaxContext = p->MinContext = CTX(minSuccessor);
+}
+
+
+
+Z7_NO_INLINE
+static void Ppmd8_Rescale(CPpmd8 *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;
+
+
+
+
+
+
+ adder = (p->OrderFall != 0);
+
+ #ifdef PPMD8_FREEZE_SUPPORT
+ adder |= (p->RestoreMethod > PPMD8_RESTORE_METHOD_FREEZE);
+ #endif
+
+ sumFreq = (sumFreq + 4 + adder) >> 1;
+ i = p->MinContext->NumStats;
+ 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 */
+ CPpmd8_Context *mc;
+ unsigned numStats, numStatsNew, n0, n1;
+
+ i = 0; do { i++; } while ((--s)->Freq == 0);
+
+
+
+
+ escFreq += i;
+ mc = p->MinContext;
+ numStats = mc->NumStats;
+ numStatsNew = numStats - i;
+ mc->NumStats = (Byte)(numStatsNew);
+ n0 = (numStats + 2) >> 1;
+
+ if (numStatsNew == 0)
+ {
+
+ unsigned freq = (2 * (unsigned)stats->Freq + escFreq - 1) / escFreq;
+ if (freq > MAX_FREQ / 3)
+ freq = MAX_FREQ / 3;
+ mc->Flags = (Byte)((mc->Flags & FLAG_PREV_HIGH) + PPMD8_HiBitsFlag_3(stats->Symbol));
+
+
+
+
+
+ s = ONE_STATE(mc);
+ *s = *stats;
+ s->Freq = (Byte)freq;
+ p->FoundState = s;
+ Ppmd8_InsertNode(p, stats, U2I(n0));
+ return;
+ }
+
+ n1 = (numStatsNew + 2) >> 1;
+ if (n0 != n1)
+ mc->Union4.Stats = STATS_REF(ShrinkUnits(p, stats, n0, n1));
+ {
+ // here we are for max order only. So Ppmd8_MakeEscFreq() doesn't use mc->Flags
+ // but we still need current (Flags & FLAG_PREV_HIGH), if we will convert context to 1-symbol context later.
+ /*
+ unsigned flags = HiBits_Prepare((s = STATS(mc))->Symbol);
+ i = mc->NumStats;
+ do { flags |= HiBits_Prepare((++s)->Symbol); } while (--i);
+ mc->Flags = (Byte)((mc->Flags & ~FLAG_SYM_HIGH) + HiBits_Convert_3(flags));
+ */
+ }
+ }
+
+
+
+
+
+
+ {
+ CPpmd8_Context *mc = p->MinContext;
+ mc->Union2.SummFreq = (UInt16)(sumFreq + escFreq - (escFreq >> 1));
+ mc->Flags |= FLAG_RESCALED;
+ p->FoundState = STATS(mc);
+ }
+}
+
+
+CPpmd_See *Ppmd8_MakeEscFreq(CPpmd8 *p, unsigned numMasked1, UInt32 *escFreq)
+{
+ CPpmd_See *see;
+ const CPpmd8_Context *mc = p->MinContext;
+ unsigned numStats = mc->NumStats;
+ if (numStats != 0xFF)
+ {
+ // (3 <= numStats + 2 <= 256) (3 <= NS2Indx[3] and NS2Indx[256] === 26)
+ see = p->See[(size_t)(unsigned)p->NS2Indx[(size_t)numStats + 2] - 3]
+ + (mc->Union2.SummFreq > 11 * (numStats + 1))
+ + 2 * (unsigned)(2 * numStats < ((unsigned)SUFFIX(mc)->NumStats + numMasked1))
+ + mc->Flags;
+
+ {
+ // 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 Ppmd8_NextContext(CPpmd8 *p)
+{
+ PPMD8_CTX_PTR c = CTX(SUCCESSOR(p->FoundState));
+ if (p->OrderFall == 0 && (const Byte *)c >= p->UnitsStart)
+ p->MaxContext = p->MinContext = c;
+ else
+ Ppmd8_UpdateModel(p);
+}
+
+
+void Ppmd8_Update1(CPpmd8 *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, &s[-1]);
+ p->FoundState = --s;
+ if (freq > MAX_FREQ)
+ Ppmd8_Rescale(p);
+ }
+ Ppmd8_NextContext(p);
+}
+
+
+void Ppmd8_Update1_0(CPpmd8 *p)
+{
+ CPpmd_State *s = p->FoundState;
+ CPpmd8_Context *mc = p->MinContext;
+ unsigned freq = s->Freq;
+ unsigned summFreq = mc->Union2.SummFreq;
+ p->PrevSuccess = (2 * freq >= summFreq); // Ppmd8 (>=)
+ p->RunLength += (int)p->PrevSuccess;
+ mc->Union2.SummFreq = (UInt16)(summFreq + 4);
+ freq += 4;
+ s->Freq = (Byte)freq;
+ if (freq > MAX_FREQ)
+ Ppmd8_Rescale(p);
+ Ppmd8_NextContext(p);
+}
+
+
+/*
+void Ppmd8_UpdateBin(CPpmd8 *p)
+{
+ unsigned freq = p->FoundState->Freq;
+ p->FoundState->Freq = (Byte)(freq + (freq < 196)); // Ppmd8 (196)
+ p->PrevSuccess = 1;
+ p->RunLength++;
+ Ppmd8_NextContext(p);
+}
+*/
+
+void Ppmd8_Update2(CPpmd8 *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)
+ Ppmd8_Rescale(p);
+ Ppmd8_UpdateModel(p);
+}
+
+/* H->I changes:
+ NS2Indx
+ GlueCount, and Glue method
+ BinSum
+ See / EscFreq
+ Ppmd8_CreateSuccessors updates more suffix contexts
+ Ppmd8_UpdateModel consts.
+ PrevSuccess Update
+
+Flags:
+ (1 << 2) - the Context was Rescaled
+ (1 << 3) - there is symbol in Stats with (sym >= 0x40) in
+ (1 << 4) - main symbol of context is (sym >= 0x40)
+*/
+
+#undef RESET_TEXT
+#undef FLAG_RESCALED
+#undef FLAG_PREV_HIGH
+#undef HiBits_Prepare
+#undef HiBits_Convert_3
+#undef HiBits_Convert_4
+#undef PPMD8_HiBitsFlag_3
+#undef PPMD8_HiBitsFlag_4
+#undef RESTORE_MODEL
+
+#undef MAX_FREQ
+#undef UNIT_SIZE
+#undef U2B
+#undef U2I
+#undef I2U
+
+#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
diff --git a/C/Ppmd8.h b/C/Ppmd8.h
new file mode 100644
index 0000000..d5bb57e
--- /dev/null
+++ b/C/Ppmd8.h
@@ -0,0 +1,181 @@
+/* Ppmd8.h -- Ppmd8 (PPMdI) compression codec
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on:
+ PPMd var.I (2002): Dmitry Shkarin : Public domain
+ Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#ifndef ZIP7_INC_PPMD8_H
+#define ZIP7_INC_PPMD8_H
+
+#include "Ppmd.h"
+
+EXTERN_C_BEGIN
+
+#define PPMD8_MIN_ORDER 2
+#define PPMD8_MAX_ORDER 16
+
+
+
+
+struct CPpmd8_Context_;
+
+typedef Ppmd_Ref_Type(struct CPpmd8_Context_) CPpmd8_Context_Ref;
+
+// MY_CPU_pragma_pack_push_1
+
+typedef struct CPpmd8_Context_
+{
+ Byte NumStats;
+ Byte Flags;
+
+ union
+ {
+ UInt16 SummFreq;
+ CPpmd_State2 State2;
+ } Union2;
+
+ union
+ {
+ CPpmd_State_Ref Stats;
+ CPpmd_State4 State4;
+ } Union4;
+
+ CPpmd8_Context_Ref Suffix;
+} CPpmd8_Context;
+
+// MY_CPU_pragma_pop
+
+#define Ppmd8Context_OneState(p) ((CPpmd_State *)&(p)->Union2)
+
+/* PPMdI code rev.2 contains the fix over PPMdI code rev.1.
+ But the code PPMdI.2 is not compatible with PPMdI.1 for some files compressed
+ in FREEZE mode. So we disable FREEZE mode support. */
+
+// #define PPMD8_FREEZE_SUPPORT
+
+enum
+{
+ PPMD8_RESTORE_METHOD_RESTART,
+ PPMD8_RESTORE_METHOD_CUT_OFF
+ #ifdef PPMD8_FREEZE_SUPPORT
+ , PPMD8_RESTORE_METHOD_FREEZE
+ #endif
+ , PPMD8_RESTORE_METHOD_UNSUPPPORTED
+};
+
+
+
+
+
+
+
+
+typedef struct
+{
+ CPpmd8_Context *MinContext, *MaxContext;
+ CPpmd_State *FoundState;
+ unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder, RestoreMethod;
+ Int32 RunLength, InitRL; /* must be 32-bit at least */
+
+ UInt32 Size;
+ UInt32 GlueCount;
+ UInt32 AlignOffset;
+ Byte *Base, *LoUnit, *HiUnit, *Text, *UnitsStart;
+
+ UInt32 Range;
+ UInt32 Code;
+ UInt32 Low;
+ union
+ {
+ IByteInPtr In;
+ IByteOutPtr Out;
+ } Stream;
+
+ Byte Indx2Units[PPMD_NUM_INDEXES + 2]; // +2 for alignment
+ Byte Units2Indx[128];
+ CPpmd_Void_Ref FreeList[PPMD_NUM_INDEXES];
+ UInt32 Stamps[PPMD_NUM_INDEXES];
+ Byte NS2BSIndx[256], NS2Indx[260];
+ Byte ExpEscape[16];
+ CPpmd_See DummySee, See[24][32];
+ UInt16 BinSumm[25][64];
+
+} CPpmd8;
+
+
+void Ppmd8_Construct(CPpmd8 *p);
+BoolInt Ppmd8_Alloc(CPpmd8 *p, UInt32 size, ISzAllocPtr alloc);
+void Ppmd8_Free(CPpmd8 *p, ISzAllocPtr alloc);
+void Ppmd8_Init(CPpmd8 *p, unsigned maxOrder, unsigned restoreMethod);
+#define Ppmd8_WasAllocated(p) ((p)->Base != NULL)
+
+
+/* ---------- Internal Functions ---------- */
+
+#define Ppmd8_GetPtr(p, ptr) Ppmd_GetPtr(p, ptr)
+#define Ppmd8_GetContext(p, ptr) Ppmd_GetPtr_Type(p, ptr, CPpmd8_Context)
+#define Ppmd8_GetStats(p, ctx) Ppmd_GetPtr_Type(p, (ctx)->Union4.Stats, CPpmd_State)
+
+void Ppmd8_Update1(CPpmd8 *p);
+void Ppmd8_Update1_0(CPpmd8 *p);
+void Ppmd8_Update2(CPpmd8 *p);
+
+
+
+
+
+
+#define Ppmd8_GetBinSumm(p) \
+ &p->BinSumm[p->NS2Indx[(size_t)Ppmd8Context_OneState(p->MinContext)->Freq - 1]] \
+ [ p->PrevSuccess + ((p->RunLength >> 26) & 0x20) \
+ + p->NS2BSIndx[Ppmd8_GetContext(p, p->MinContext->Suffix)->NumStats] + \
+ + p->MinContext->Flags ]
+
+
+CPpmd_See *Ppmd8_MakeEscFreq(CPpmd8 *p, unsigned numMasked, UInt32 *scale);
+
+
+/* 20.01: the original PPMdI encoder and decoder probably could work incorrectly in some rare cases,
+ where the original PPMdI code can give "Divide by Zero" operation.
+ We use the following fix to allow correct working of encoder and decoder in any cases.
+ We correct (Escape_Freq) and (_sum_), if (_sum_) is larger than p->Range) */
+#define PPMD8_CORRECT_SUM_RANGE(p, _sum_) if (_sum_ > p->Range /* /1 */) _sum_ = p->Range;
+
+
+/* ---------- Decode ---------- */
+
+#define PPMD8_SYM_END (-1)
+#define PPMD8_SYM_ERROR (-2)
+
+/*
+You must set (CPpmd8::Stream.In) before Ppmd8_RangeDec_Init()
+
+Ppmd8_DecodeSymbol()
+out:
+ >= 0 : decoded byte
+ -1 : PPMD8_SYM_END : End of payload marker
+ -2 : PPMD8_SYM_ERROR : Data error
+*/
+
+
+BoolInt Ppmd8_Init_RangeDec(CPpmd8 *p);
+#define Ppmd8_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
+int Ppmd8_DecodeSymbol(CPpmd8 *p);
+
+
+
+
+
+
+
+
+/* ---------- Encode ---------- */
+
+#define Ppmd8_Init_RangeEnc(p) { (p)->Low = 0; (p)->Range = 0xFFFFFFFF; }
+void Ppmd8_Flush_RangeEnc(CPpmd8 *p);
+void Ppmd8_EncodeSymbol(CPpmd8 *p, int symbol);
+
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Ppmd8Dec.c b/C/Ppmd8Dec.c
new file mode 100644
index 0000000..72d3626
--- /dev/null
+++ b/C/Ppmd8Dec.c
@@ -0,0 +1,295 @@
+/* Ppmd8Dec.c -- Ppmd8 (PPMdI) Decoder
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on:
+ PPMd var.I (2002): Dmitry Shkarin : Public domain
+ Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#include "Precomp.h"
+
+#include "Ppmd8.h"
+
+#define kTop ((UInt32)1 << 24)
+#define kBot ((UInt32)1 << 15)
+
+#define READ_BYTE(p) IByteIn_Read((p)->Stream.In)
+
+BoolInt Ppmd8_Init_RangeDec(CPpmd8 *p)
+{
+ unsigned i;
+ p->Code = 0;
+ p->Range = 0xFFFFFFFF;
+ p->Low = 0;
+
+ for (i = 0; i < 4; i++)
+ p->Code = (p->Code << 8) | READ_BYTE(p);
+ return (p->Code < 0xFFFFFFFF);
+}
+
+#define RC_NORM(p) \
+ while ((p->Low ^ (p->Low + p->Range)) < kTop \
+ || (p->Range < kBot && ((p->Range = (0 - p->Low) & (kBot - 1)), 1))) { \
+ p->Code = (p->Code << 8) | READ_BYTE(p); \
+ p->Range <<= 8; p->Low <<= 8; }
+
+// 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
+
+Z7_FORCE_INLINE
+// Z7_NO_INLINE
+static void Ppmd8_RD_Decode(CPpmd8 *p, UInt32 start, UInt32 size)
+{
+ start *= R->Range;
+ R->Low += start;
+ R->Code -= start;
+ R->Range *= size;
+ RC_NORM_LOCAL(R)
+}
+
+#define RC_Decode(start, size) Ppmd8_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) ((CPpmd8_Context *)Ppmd8_GetContext(p, ref))
+// typedef CPpmd8_Context * CTX_PTR;
+#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)
+void Ppmd8_UpdateModel(CPpmd8 *p);
+
+#define MASK(sym) ((unsigned char *)charMask)[sym]
+
+
+int Ppmd8_DecodeSymbol(CPpmd8 *p)
+{
+ size_t charMask[256 / sizeof(size_t)];
+
+ if (p->MinContext->NumStats != 0)
+ {
+ CPpmd_State *s = Ppmd8_GetStats(p, p->MinContext);
+ unsigned i;
+ UInt32 count, hiCnt;
+ UInt32 summFreq = p->MinContext->Union2.SummFreq;
+
+ PPMD8_CORRECT_SUM_RANGE(p, 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;
+ Ppmd8_Update1_0(p);
+ return sym;
+ }
+
+ p->PrevSuccess = 0;
+ i = p->MinContext->NumStats;
+
+ do
+ {
+ if ((Int32)(count -= (++s)->Freq) < 0)
+ {
+ Byte sym;
+ RC_DecodeFinal((hiCnt - count) - s->Freq, s->Freq)
+ p->FoundState = s;
+ sym = s->Symbol;
+ Ppmd8_Update1(p);
+ return sym;
+ }
+ }
+ while (--i);
+
+ if (hiCnt >= summFreq)
+ return PPMD8_SYM_ERROR;
+
+ hiCnt -= count;
+ RC_Decode(hiCnt, summFreq - hiCnt)
+
+
+ PPMD_SetAllBitsIn256Bytes(charMask)
+ // i = p->MinContext->NumStats - 1;
+ // do { MASK((--s)->Symbol) = 0; } while (--i);
+ {
+ CPpmd_State *s2 = Ppmd8_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 = Ppmd8Context_OneState(p->MinContext);
+ UInt16 *prob = Ppmd8_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(R)
+
+
+
+ // sym = (p->FoundState = Ppmd8Context_OneState(p->MinContext))->Symbol;
+ // Ppmd8_UpdateBin(p);
+ {
+ unsigned freq = s->Freq;
+ CPpmd8_Context *c = CTX(SUCCESSOR(s));
+ sym = s->Symbol;
+ p->FoundState = s;
+ p->PrevSuccess = 1;
+ p->RunLength++;
+ s->Freq = (Byte)(freq + (freq < 196));
+ // NextContext(p);
+ if (p->OrderFall == 0 && (const Byte *)c >= p->UnitsStart)
+ p->MaxContext = p->MinContext = c;
+ else
+ Ppmd8_UpdateModel(p);
+ }
+ return sym;
+ }
+
+ *prob = (UInt16)pr;
+ p->InitEsc = p->ExpEscape[pr >> 10];
+
+ // RangeDec_DecodeBit1(rc2, size0);
+ R->Low += size0;
+ R->Code -= size0;
+ R->Range = (R->Range & ~((UInt32)PPMD_BIN_SCALE - 1)) - size0;
+ RC_NORM_LOCAL(R)
+
+ PPMD_SetAllBitsIn256Bytes(charMask)
+ MASK(Ppmd8Context_OneState(p->MinContext)->Symbol) = 0;
+ p->PrevSuccess = 0;
+ }
+
+ for (;;)
+ {
+ CPpmd_State *s, *s2;
+ UInt32 freqSum, count, hiCnt;
+ UInt32 freqSum2;
+ CPpmd_See *see;
+ CPpmd8_Context *mc;
+ unsigned numMasked;
+ RC_NORM_REMOTE(R)
+ mc = p->MinContext;
+ numMasked = mc->NumStats;
+
+ do
+ {
+ p->OrderFall++;
+ if (!mc->Suffix)
+ return PPMD8_SYM_END;
+ mc = Ppmd8_GetContext(p, mc->Suffix);
+ }
+ while (mc->NumStats == numMasked);
+
+ s = Ppmd8_GetStats(p, mc);
+
+ {
+ unsigned num = (unsigned)mc->NumStats + 1;
+ 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 = Ppmd8_MakeEscFreq(p, numMasked, &freqSum);
+ freqSum += hiCnt;
+ freqSum2 = freqSum;
+ PPMD8_CORRECT_SUM_RANGE(R, freqSum2)
+
+
+ count = RC_GetThreshold(freqSum2);
+
+ if (count < hiCnt)
+ {
+ Byte sym;
+ // Ppmd_See_UPDATE(see) // new (see->Summ) value can overflow over 16-bits in some rare cases
+ s = Ppmd8_GetStats(p, p->MinContext);
+ hiCnt = count;
+
+
+ {
+ 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;
+ Ppmd8_Update2(p);
+ return sym;
+ }
+
+ if (count >= freqSum2)
+ return PPMD8_SYM_ERROR;
+
+ RC_Decode(hiCnt, freqSum2 - 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 = Ppmd8_GetStats(p, p->MinContext);
+ s2 = s + p->MinContext->NumStats + 1;
+ do
+ {
+ MASK(s->Symbol) = 0;
+ s++;
+ }
+ while (s != s2);
+ }
+}
+
+#undef kTop
+#undef kBot
+#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
diff --git a/C/Ppmd8Enc.c b/C/Ppmd8Enc.c
new file mode 100644
index 0000000..9e29ef7
--- /dev/null
+++ b/C/Ppmd8Enc.c
@@ -0,0 +1,338 @@
+/* Ppmd8Enc.c -- Ppmd8 (PPMdI) Encoder
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on:
+ PPMd var.I (2002): Dmitry Shkarin : Public domain
+ Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#include "Precomp.h"
+
+#include "Ppmd8.h"
+
+#define kTop ((UInt32)1 << 24)
+#define kBot ((UInt32)1 << 15)
+
+#define WRITE_BYTE(p) IByteOut_Write(p->Stream.Out, (Byte)(p->Low >> 24))
+
+void Ppmd8_Flush_RangeEnc(CPpmd8 *p)
+{
+ unsigned i;
+ for (i = 0; i < 4; i++, p->Low <<= 8 )
+ WRITE_BYTE(p);
+}
+
+
+
+
+
+
+#define RC_NORM(p) \
+ while ((p->Low ^ (p->Low + p->Range)) < kTop \
+ || (p->Range < kBot && ((p->Range = (0 - p->Low) & (kBot - 1)), 1))) \
+ { WRITE_BYTE(p); p->Range <<= 8; p->Low <<= 8; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+// 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 RC_PRE(total) p->Range /= total;
+// #define RC_PRE(total)
+
+#define R p
+
+
+
+
+Z7_FORCE_INLINE
+// Z7_NO_INLINE
+static void Ppmd8_RangeEnc_Encode(CPpmd8 *p, UInt32 start, UInt32 size, UInt32 total)
+{
+ R->Low += start * (R->Range /= total);
+ R->Range *= size;
+ RC_NORM_LOCAL(R)
+}
+
+
+
+
+
+
+
+
+
+
+#define RC_Encode(start, size, total) Ppmd8_RangeEnc_Encode(p, start, size, total);
+#define RC_EncodeFinal(start, size, total) RC_Encode(start, size, total) RC_NORM_REMOTE(p)
+
+#define CTX(ref) ((CPpmd8_Context *)Ppmd8_GetContext(p, ref))
+
+// typedef CPpmd8_Context * CTX_PTR;
+#define SUCCESSOR(p) Ppmd_GET_SUCCESSOR(p)
+
+void Ppmd8_UpdateModel(CPpmd8 *p);
+
+#define MASK(sym) ((unsigned char *)charMask)[sym]
+
+// Z7_FORCE_INLINE
+// static
+void Ppmd8_EncodeSymbol(CPpmd8 *p, int symbol)
+{
+ size_t charMask[256 / sizeof(size_t)];
+
+ if (p->MinContext->NumStats != 0)
+ {
+ CPpmd_State *s = Ppmd8_GetStats(p, p->MinContext);
+ UInt32 sum;
+ unsigned i;
+ UInt32 summFreq = p->MinContext->Union2.SummFreq;
+
+ PPMD8_CORRECT_SUM_RANGE(p, summFreq)
+
+ // RC_PRE(summFreq);
+
+ if (s->Symbol == symbol)
+ {
+
+ RC_EncodeFinal(0, s->Freq, summFreq)
+ p->FoundState = s;
+ Ppmd8_Update1_0(p);
+ return;
+ }
+ p->PrevSuccess = 0;
+ sum = s->Freq;
+ i = p->MinContext->NumStats;
+ do
+ {
+ if ((++s)->Symbol == symbol)
+ {
+
+ RC_EncodeFinal(sum, s->Freq, summFreq)
+ p->FoundState = s;
+ Ppmd8_Update1(p);
+ return;
+ }
+ sum += s->Freq;
+ }
+ while (--i);
+
+
+ RC_Encode(sum, summFreq - sum, summFreq)
+
+
+ PPMD_SetAllBitsIn256Bytes(charMask)
+ // MASK(s->Symbol) = 0;
+ // i = p->MinContext->NumStats;
+ // do { MASK((--s)->Symbol) = 0; } while (--i);
+ {
+ CPpmd_State *s2 = Ppmd8_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
+ {
+ UInt16 *prob = Ppmd8_GetBinSumm(p);
+ CPpmd_State *s = Ppmd8Context_OneState(p->MinContext);
+ UInt32 pr = *prob;
+ const UInt32 bound = (R->Range >> 14) * pr;
+ pr = PPMD_UPDATE_PROB_1(pr);
+ if (s->Symbol == symbol)
+ {
+ *prob = (UInt16)(pr + (1 << PPMD_INT_BITS));
+ // RangeEnc_EncodeBit_0(p, bound);
+ R->Range = bound;
+ RC_NORM(R)
+
+ // p->FoundState = s;
+ // Ppmd8_UpdateBin(p);
+ {
+ const unsigned freq = s->Freq;
+ CPpmd8_Context *c = CTX(SUCCESSOR(s));
+ p->FoundState = s;
+ p->PrevSuccess = 1;
+ p->RunLength++;
+ s->Freq = (Byte)(freq + (freq < 196)); // Ppmd8 (196)
+ // NextContext(p);
+ if (p->OrderFall == 0 && (const Byte *)c >= p->UnitsStart)
+ p->MaxContext = p->MinContext = c;
+ else
+ Ppmd8_UpdateModel(p);
+ }
+ return;
+ }
+
+ *prob = (UInt16)pr;
+ p->InitEsc = p->ExpEscape[pr >> 10];
+ // RangeEnc_EncodeBit_1(p, bound);
+ R->Low += bound;
+ R->Range = (R->Range & ~((UInt32)PPMD_BIN_SCALE - 1)) - bound;
+ RC_NORM_LOCAL(R)
+
+ PPMD_SetAllBitsIn256Bytes(charMask)
+ MASK(s->Symbol) = 0;
+ p->PrevSuccess = 0;
+ }
+
+ for (;;)
+ {
+ CPpmd_See *see;
+ CPpmd_State *s;
+ UInt32 sum, escFreq;
+ CPpmd8_Context *mc;
+ unsigned i, numMasked;
+
+ RC_NORM_REMOTE(p)
+
+ mc = p->MinContext;
+ numMasked = mc->NumStats;
+
+ do
+ {
+ p->OrderFall++;
+ if (!mc->Suffix)
+ return; /* EndMarker (symbol = -1) */
+ mc = Ppmd8_GetContext(p, mc->Suffix);
+
+ }
+ while (mc->NumStats == numMasked);
+
+ p->MinContext = mc;
+
+ see = Ppmd8_MakeEscFreq(p, numMasked, &escFreq);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ s = Ppmd8_GetStats(p, p->MinContext);
+ sum = 0;
+ i = (unsigned)p->MinContext->NumStats + 1;
+
+ do
+ {
+ const unsigned cur = s->Symbol;
+ if ((int)cur == symbol)
+ {
+ const UInt32 low = sum;
+ const UInt32 freq = s->Freq;
+ unsigned num2;
+
+ Ppmd_See_UPDATE(see)
+ p->FoundState = s;
+ sum += escFreq;
+
+ num2 = i / 2;
+ i &= 1;
+ sum += freq & (0 - (UInt32)i);
+ if (num2 != 0)
+ {
+ s += i;
+ for (;;)
+ {
+ unsigned sym0 = s[0].Symbol;
+ unsigned sym1 = s[1].Symbol;
+ s += 2;
+ sum += (s[-2].Freq & (unsigned)(MASK(sym0)));
+ sum += (s[-1].Freq & (unsigned)(MASK(sym1)));
+ if (--num2 == 0)
+ break;
+ }
+ }
+
+ PPMD8_CORRECT_SUM_RANGE(p, sum)
+
+ RC_EncodeFinal(low, freq, sum)
+ Ppmd8_Update2(p);
+ return;
+ }
+ sum += (s->Freq & (unsigned)(MASK(cur)));
+ s++;
+ }
+ while (--i);
+
+ {
+ UInt32 total = sum + escFreq;
+ see->Summ = (UInt16)(see->Summ + total);
+ PPMD8_CORRECT_SUM_RANGE(p, total)
+
+ RC_Encode(sum, total - sum, total)
+ }
+
+ {
+ const CPpmd_State *s2 = Ppmd8_GetStats(p, p->MinContext);
+ s--;
+ MASK(s->Symbol) = 0;
+ do
+ {
+ const unsigned sym0 = s2[0].Symbol;
+ const unsigned sym1 = s2[1].Symbol;
+ s2 += 2;
+ MASK(sym0) = 0;
+ MASK(sym1) = 0;
+ }
+ while (s2 < s);
+ }
+ }
+}
+
+
+
+
+
+
+
+
+
+#undef kTop
+#undef kBot
+#undef WRITE_BYTE
+#undef RC_NORM_BASE
+#undef RC_NORM_1
+#undef RC_NORM
+#undef RC_NORM_LOCAL
+#undef RC_NORM_REMOTE
+#undef R
+#undef RC_Encode
+#undef RC_EncodeFinal
+
+#undef CTX
+#undef SUCCESSOR
+#undef MASK
diff --git a/C/Precomp.h b/C/Precomp.h
index edb5814..69afb2f 100644
--- a/C/Precomp.h
+++ b/C/Precomp.h
@@ -1,10 +1,10 @@
-/* Precomp.h -- StdAfx
-2013-11-12 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_PRECOMP_H
-#define __7Z_PRECOMP_H
-
-#include "Compiler.h"
-/* #include "7zTypes.h" */
-
-#endif
+/* 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
diff --git a/C/RotateDefs.h b/C/RotateDefs.h
index 6c790e7..c16b4f8 100644
--- a/C/RotateDefs.h
+++ b/C/RotateDefs.h
@@ -1,30 +1,50 @@
-/* RotateDefs.h -- Rotate functions
-2015-03-25 : Igor Pavlov : Public domain */
-
-#ifndef __ROTATE_DEFS_H
-#define __ROTATE_DEFS_H
-
-#ifdef _MSC_VER
-
-#include <stdlib.h>
-
-/* don't use _rotl with 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))
-
-#else
-
-/* new compilers can translate these macros to fast commands. */
-
-#define rotlFixed(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
-#define rotrFixed(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
-
-#endif
-
-#endif
+/* 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
diff --git a/C/Sha1.c b/C/Sha1.c
new file mode 100644
index 0000000..fd6c018
--- /dev/null
+++ b/C/Sha1.c
@@ -0,0 +1,498 @@
+/* Sha1.c -- SHA-1 Hash
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on public domain code of Steve Reid from Wei Dai's Crypto++ library. */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "CpuArch.h"
+#include "RotateDefs.h"
+#include "Sha1.h"
+
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+// #define USE_MY_MM
+#endif
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #ifdef _MSC_VER
+ #if _MSC_VER >= 1200
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #elif defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 8) // fix that check
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #elif defined(__INTEL_COMPILER)
+ #if (__INTEL_COMPILER >= 1800) // fix that check
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #endif
+#elif defined(MY_CPU_ARM_OR_ARM64)
+ #ifdef _MSC_VER
+ #if _MSC_VER >= 1910 && _MSC_VER >= 1929 && _MSC_FULL_VER >= 192930037
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #elif defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define Z7_COMPILER_SHA1_SUPPORTED
+ #endif
+ #endif
+#endif
+
+void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t numBlocks);
+
+#ifdef Z7_COMPILER_SHA1_SUPPORTED
+ void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t numBlocks);
+
+ static SHA1_FUNC_UPDATE_BLOCKS g_SHA1_FUNC_UPDATE_BLOCKS = Sha1_UpdateBlocks;
+ static SHA1_FUNC_UPDATE_BLOCKS g_SHA1_FUNC_UPDATE_BLOCKS_HW;
+
+ #define SHA1_UPDATE_BLOCKS(p) p->func_UpdateBlocks
+#else
+ #define SHA1_UPDATE_BLOCKS(p) Sha1_UpdateBlocks
+#endif
+
+
+BoolInt Sha1_SetFunction(CSha1 *p, unsigned algo)
+{
+ SHA1_FUNC_UPDATE_BLOCKS func = Sha1_UpdateBlocks;
+
+ #ifdef Z7_COMPILER_SHA1_SUPPORTED
+ if (algo != SHA1_ALGO_SW)
+ {
+ if (algo == SHA1_ALGO_DEFAULT)
+ func = g_SHA1_FUNC_UPDATE_BLOCKS;
+ else
+ {
+ if (algo != SHA1_ALGO_HW)
+ return False;
+ func = g_SHA1_FUNC_UPDATE_BLOCKS_HW;
+ if (!func)
+ return False;
+ }
+ }
+ #else
+ if (algo > 1)
+ return False;
+ #endif
+
+ p->func_UpdateBlocks = func;
+ return True;
+}
+
+
+/* define it for speed optimization */
+// #define Z7_SHA1_UNROLL
+
+// allowed unroll steps: (1, 2, 4, 5, 20)
+
+#undef Z7_SHA1_BIG_W
+#ifdef Z7_SHA1_UNROLL
+ #define STEP_PRE 20
+ #define STEP_MAIN 20
+#else
+ #define Z7_SHA1_BIG_W
+ #define STEP_PRE 5
+ #define STEP_MAIN 5
+#endif
+
+
+#ifdef Z7_SHA1_BIG_W
+ #define kNumW 80
+ #define w(i) W[i]
+#else
+ #define kNumW 16
+ #define w(i) W[(i)&15]
+#endif
+
+#define w0(i) (W[i] = GetBe32(data + (size_t)(i) * 4))
+#define w1(i) (w(i) = rotlFixed(w((size_t)(i)-3) ^ w((size_t)(i)-8) ^ w((size_t)(i)-14) ^ w((size_t)(i)-16), 1))
+
+#define f0(x,y,z) ( 0x5a827999 + (z^(x&(y^z))) )
+#define f1(x,y,z) ( 0x6ed9eba1 + (x^y^z) )
+#define f2(x,y,z) ( 0x8f1bbcdc + ((x&y)|(z&(x|y))) )
+#define f3(x,y,z) ( 0xca62c1d6 + (x^y^z) )
+
+/*
+#define T1(fx, ww) \
+ tmp = e + fx(b,c,d) + ww + rotlFixed(a, 5); \
+ e = d; \
+ d = c; \
+ c = rotlFixed(b, 30); \
+ b = a; \
+ a = tmp; \
+*/
+
+#define T5(a,b,c,d,e, fx, ww) \
+ e += fx(b,c,d) + ww + rotlFixed(a, 5); \
+ b = rotlFixed(b, 30); \
+
+
+/*
+#define R1(i, fx, wx) \
+ T1 ( fx, wx(i)); \
+
+#define R2(i, fx, wx) \
+ R1 ( (i) , fx, wx); \
+ R1 ( (i) + 1, fx, wx); \
+
+#define R4(i, fx, wx) \
+ R2 ( (i) , fx, wx); \
+ R2 ( (i) + 2, fx, wx); \
+*/
+
+#define M5(i, fx, wx0, wx1) \
+ T5 ( a,b,c,d,e, fx, wx0((i) ) ) \
+ T5 ( e,a,b,c,d, fx, wx1((i)+1) ) \
+ T5 ( d,e,a,b,c, fx, wx1((i)+2) ) \
+ T5 ( c,d,e,a,b, fx, wx1((i)+3) ) \
+ T5 ( b,c,d,e,a, fx, wx1((i)+4) ) \
+
+#define R5(i, fx, wx) \
+ M5 ( i, fx, wx, wx) \
+
+
+#if STEP_PRE > 5
+
+ #define R20_START \
+ R5 ( 0, f0, w0) \
+ R5 ( 5, f0, w0) \
+ R5 ( 10, f0, w0) \
+ M5 ( 15, f0, w0, w1) \
+
+ #elif STEP_PRE == 5
+
+ #define R20_START \
+ { size_t i; for (i = 0; i < 15; i += STEP_PRE) \
+ { R5(i, f0, w0) } } \
+ M5 ( 15, f0, w0, w1) \
+
+#else
+
+ #if STEP_PRE == 1
+ #define R_PRE R1
+ #elif STEP_PRE == 2
+ #define R_PRE R2
+ #elif STEP_PRE == 4
+ #define R_PRE R4
+ #endif
+
+ #define R20_START \
+ { size_t i; for (i = 0; i < 16; i += STEP_PRE) \
+ { R_PRE(i, f0, w0) } } \
+ R4 ( 16, f0, w1) \
+
+#endif
+
+
+
+#if STEP_MAIN > 5
+
+ #define R20(ii, fx) \
+ R5 ( (ii) , fx, w1) \
+ R5 ( (ii) + 5 , fx, w1) \
+ R5 ( (ii) + 10, fx, w1) \
+ R5 ( (ii) + 15, fx, w1) \
+
+#else
+
+ #if STEP_MAIN == 1
+ #define R_MAIN R1
+ #elif STEP_MAIN == 2
+ #define R_MAIN R2
+ #elif STEP_MAIN == 4
+ #define R_MAIN R4
+ #elif STEP_MAIN == 5
+ #define R_MAIN R5
+ #endif
+
+ #define R20(ii, fx) \
+ { size_t i; for (i = (ii); i < (ii) + 20; i += STEP_MAIN) \
+ { R_MAIN(i, fx, w1) } } \
+
+#endif
+
+
+
+void Sha1_InitState(CSha1 *p)
+{
+ p->count = 0;
+ p->state[0] = 0x67452301;
+ p->state[1] = 0xEFCDAB89;
+ p->state[2] = 0x98BADCFE;
+ p->state[3] = 0x10325476;
+ p->state[4] = 0xC3D2E1F0;
+}
+
+void Sha1_Init(CSha1 *p)
+{
+ p->func_UpdateBlocks =
+ #ifdef Z7_COMPILER_SHA1_SUPPORTED
+ g_SHA1_FUNC_UPDATE_BLOCKS;
+ #else
+ NULL;
+ #endif
+ Sha1_InitState(p);
+}
+
+
+Z7_NO_INLINE
+void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t numBlocks)
+{
+ UInt32 a, b, c, d, e;
+ UInt32 W[kNumW];
+ // if (numBlocks != 0x1264378347) return;
+ if (numBlocks == 0)
+ return;
+
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+
+ do
+ {
+ #if STEP_PRE < 5 || STEP_MAIN < 5
+ UInt32 tmp;
+ #endif
+
+ R20_START
+ R20(20, f1)
+ R20(40, f2)
+ R20(60, f3)
+
+ a += state[0];
+ b += state[1];
+ c += state[2];
+ d += state[3];
+ e += state[4];
+
+ state[0] = a;
+ state[1] = b;
+ state[2] = c;
+ state[3] = d;
+ state[4] = e;
+
+ data += 64;
+ }
+ while (--numBlocks);
+}
+
+
+#define Sha1_UpdateBlock(p) SHA1_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
+
+void Sha1_Update(CSha1 *p, const Byte *data, size_t size)
+{
+ if (size == 0)
+ return;
+
+ {
+ unsigned pos = (unsigned)p->count & 0x3F;
+ unsigned num;
+
+ p->count += size;
+
+ num = 64 - pos;
+ if (num > size)
+ {
+ memcpy(p->buffer + pos, data, size);
+ return;
+ }
+
+ if (pos != 0)
+ {
+ size -= num;
+ memcpy(p->buffer + pos, data, num);
+ data += num;
+ Sha1_UpdateBlock(p);
+ }
+ }
+ {
+ size_t numBlocks = size >> 6;
+ SHA1_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
+ size &= 0x3F;
+ if (size == 0)
+ return;
+ data += (numBlocks << 6);
+ memcpy(p->buffer, data, size);
+ }
+}
+
+
+void Sha1_Final(CSha1 *p, Byte *digest)
+{
+ unsigned pos = (unsigned)p->count & 0x3F;
+
+
+ p->buffer[pos++] = 0x80;
+
+ if (pos > (64 - 8))
+ {
+ while (pos != 64) { p->buffer[pos++] = 0; }
+ // memset(&p->buf.buffer[pos], 0, 64 - pos);
+ Sha1_UpdateBlock(p);
+ pos = 0;
+ }
+
+ /*
+ if (pos & 3)
+ {
+ p->buffer[pos] = 0;
+ p->buffer[pos + 1] = 0;
+ p->buffer[pos + 2] = 0;
+ pos += 3;
+ pos &= ~3;
+ }
+ {
+ for (; pos < 64 - 8; pos += 4)
+ *(UInt32 *)(&p->buffer[pos]) = 0;
+ }
+ */
+
+ memset(&p->buffer[pos], 0, (64 - 8) - pos);
+
+ {
+ const UInt64 numBits = (p->count << 3);
+ SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32))
+ SetBe32(p->buffer + 64 - 4, (UInt32)(numBits))
+ }
+
+ Sha1_UpdateBlock(p);
+
+ SetBe32(digest, p->state[0])
+ SetBe32(digest + 4, p->state[1])
+ SetBe32(digest + 8, p->state[2])
+ SetBe32(digest + 12, p->state[3])
+ SetBe32(digest + 16, p->state[4])
+
+
+
+
+ Sha1_InitState(p);
+}
+
+
+void Sha1_PrepareBlock(const CSha1 *p, Byte *block, unsigned size)
+{
+ const UInt64 numBits = (p->count + size) << 3;
+ SetBe32(&((UInt32 *)(void *)block)[SHA1_NUM_BLOCK_WORDS - 2], (UInt32)(numBits >> 32))
+ SetBe32(&((UInt32 *)(void *)block)[SHA1_NUM_BLOCK_WORDS - 1], (UInt32)(numBits))
+ // SetBe32((UInt32 *)(block + size), 0x80000000);
+ SetUi32((UInt32 *)(void *)(block + size), 0x80)
+ size += 4;
+ while (size != (SHA1_NUM_BLOCK_WORDS - 2) * 4)
+ {
+ *((UInt32 *)(void *)(block + size)) = 0;
+ size += 4;
+ }
+}
+
+void Sha1_GetBlockDigest(const CSha1 *p, const Byte *data, Byte *destDigest)
+{
+ MY_ALIGN (16)
+ UInt32 st[SHA1_NUM_DIGEST_WORDS];
+
+ st[0] = p->state[0];
+ st[1] = p->state[1];
+ st[2] = p->state[2];
+ st[3] = p->state[3];
+ st[4] = p->state[4];
+
+ SHA1_UPDATE_BLOCKS(p)(st, data, 1);
+
+ SetBe32(destDigest + 0 , st[0])
+ SetBe32(destDigest + 1 * 4, st[1])
+ SetBe32(destDigest + 2 * 4, st[2])
+ SetBe32(destDigest + 3 * 4, st[3])
+ SetBe32(destDigest + 4 * 4, st[4])
+}
+
+
+void Sha1Prepare(void)
+{
+ #ifdef Z7_COMPILER_SHA1_SUPPORTED
+ SHA1_FUNC_UPDATE_BLOCKS f, f_hw;
+ f = Sha1_UpdateBlocks;
+ f_hw = NULL;
+ #ifdef MY_CPU_X86_OR_AMD64
+ #ifndef USE_MY_MM
+ if (CPU_IsSupported_SHA()
+ && CPU_IsSupported_SSSE3()
+ // && CPU_IsSupported_SSE41()
+ )
+ #endif
+ #else
+ if (CPU_IsSupported_SHA1())
+ #endif
+ {
+ // printf("\n========== HW SHA1 ======== \n");
+ #if defined(MY_CPU_ARM_OR_ARM64) && defined(_MSC_VER)
+ /* there was bug in MSVC compiler for ARM64 -O2 before version VS2019 16.10 (19.29.30037).
+ It generated incorrect SHA-1 code.
+ 21.03 : we test sha1-hardware code at runtime initialization */
+
+ #pragma message("== SHA1 code: MSC compiler : failure-check code was inserted")
+
+ UInt32 state[5] = { 0, 1, 2, 3, 4 } ;
+ Byte data[64];
+ unsigned i;
+ for (i = 0; i < sizeof(data); i += 2)
+ {
+ data[i ] = (Byte)(i);
+ data[i + 1] = (Byte)(i + 1);
+ }
+
+ Sha1_UpdateBlocks_HW(state, data, sizeof(data) / 64);
+
+ if ( state[0] != 0x9acd7297
+ || state[1] != 0x4624d898
+ || state[2] != 0x0bf079f0
+ || state[3] != 0x031e61b3
+ || state[4] != 0x8323fe20)
+ {
+ // printf("\n========== SHA-1 hardware version failure ======== \n");
+ }
+ else
+ #endif
+ {
+ f = f_hw = Sha1_UpdateBlocks_HW;
+ }
+ }
+ g_SHA1_FUNC_UPDATE_BLOCKS = f;
+ g_SHA1_FUNC_UPDATE_BLOCKS_HW = f_hw;
+ #endif
+}
+
+#undef kNumW
+#undef w
+#undef w0
+#undef w1
+#undef f0
+#undef f1
+#undef f2
+#undef f3
+#undef T1
+#undef T5
+#undef M5
+#undef R1
+#undef R2
+#undef R4
+#undef R5
+#undef R20_START
+#undef R_PRE
+#undef R_MAIN
+#undef STEP_PRE
+#undef STEP_MAIN
+#undef Z7_SHA1_BIG_W
+#undef Z7_SHA1_UNROLL
+#undef Z7_COMPILER_SHA1_SUPPORTED
diff --git a/C/Sha1.h b/C/Sha1.h
new file mode 100644
index 0000000..fecd9d3
--- /dev/null
+++ b/C/Sha1.h
@@ -0,0 +1,76 @@
+/* Sha1.h -- SHA-1 Hash
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_SHA1_H
+#define ZIP7_INC_SHA1_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define SHA1_NUM_BLOCK_WORDS 16
+#define SHA1_NUM_DIGEST_WORDS 5
+
+#define SHA1_BLOCK_SIZE (SHA1_NUM_BLOCK_WORDS * 4)
+#define SHA1_DIGEST_SIZE (SHA1_NUM_DIGEST_WORDS * 4)
+
+typedef void (Z7_FASTCALL *SHA1_FUNC_UPDATE_BLOCKS)(UInt32 state[5], const Byte *data, size_t numBlocks);
+
+/*
+ if (the system supports different SHA1 code implementations)
+ {
+ (CSha1::func_UpdateBlocks) will be used
+ (CSha1::func_UpdateBlocks) can be set by
+ Sha1_Init() - to default (fastest)
+ Sha1_SetFunction() - to any algo
+ }
+ else
+ {
+ (CSha1::func_UpdateBlocks) is ignored.
+ }
+*/
+
+typedef struct
+{
+ SHA1_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
+ UInt64 count;
+ UInt64 _pad_2[2];
+ UInt32 state[SHA1_NUM_DIGEST_WORDS];
+ UInt32 _pad_3[3];
+ Byte buffer[SHA1_BLOCK_SIZE];
+} CSha1;
+
+
+#define SHA1_ALGO_DEFAULT 0
+#define SHA1_ALGO_SW 1
+#define SHA1_ALGO_HW 2
+
+/*
+Sha1_SetFunction()
+return:
+ 0 - (algo) value is not supported, and func_UpdateBlocks was not changed
+ 1 - func_UpdateBlocks was set according (algo) value.
+*/
+
+BoolInt Sha1_SetFunction(CSha1 *p, unsigned algo);
+
+void Sha1_InitState(CSha1 *p);
+void Sha1_Init(CSha1 *p);
+void Sha1_Update(CSha1 *p, const Byte *data, size_t size);
+void Sha1_Final(CSha1 *p, Byte *digest);
+
+void Sha1_PrepareBlock(const CSha1 *p, Byte *block, unsigned size);
+void Sha1_GetBlockDigest(const CSha1 *p, const Byte *data, Byte *destDigest);
+
+// void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t numBlocks);
+
+/*
+call Sha1Prepare() once at program start.
+It prepares all supported implementations, and detects the fastest implementation.
+*/
+
+void Sha1Prepare(void);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Sha1Opt.c b/C/Sha1Opt.c
new file mode 100644
index 0000000..27796aa
--- /dev/null
+++ b/C/Sha1Opt.c
@@ -0,0 +1,386 @@
+/* Sha1Opt.c -- SHA-1 optimized code for SHA-1 hardware instructions
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+#include "Compiler.h"
+#include "CpuArch.h"
+
+#if defined(_MSC_VER)
+#if (_MSC_VER < 1900) && (_MSC_VER >= 1200)
+// #define USE_MY_MM
+#endif
+#endif
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1600) // fix that check
+ #define USE_HW_SHA
+ #elif defined(Z7_LLVM_CLANG_VERSION) && (Z7_LLVM_CLANG_VERSION >= 30800) \
+ || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 50100) \
+ || defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40900)
+ #define USE_HW_SHA
+ #if !defined(_INTEL_COMPILER)
+ // icc defines __GNUC__, but icc doesn't support __attribute__(__target__)
+ #if !defined(__SHA__) || !defined(__SSSE3__)
+ #define ATTRIB_SHA __attribute__((__target__("sha,ssse3")))
+ #endif
+ #endif
+ #elif defined(_MSC_VER)
+ #ifdef USE_MY_MM
+ #define USE_VER_MIN 1300
+ #else
+ #define USE_VER_MIN 1900
+ #endif
+ #if (_MSC_VER >= USE_VER_MIN)
+ #define USE_HW_SHA
+ #endif
+ #endif
+// #endif // MY_CPU_X86_OR_AMD64
+
+#ifdef USE_HW_SHA
+
+// #pragma message("Sha1 HW")
+
+// sse/sse2/ssse3:
+#include <tmmintrin.h>
+// sha*:
+#include <immintrin.h>
+
+#if defined (__clang__) && defined(_MSC_VER)
+ // #if !defined(__SSSE3__)
+ // #endif
+ #if !defined(__SHA__)
+ #include <shaintrin.h>
+ #endif
+#else
+
+#ifdef USE_MY_MM
+#include "My_mm.h"
+#endif
+
+#endif
+
+/*
+SHA1 uses:
+SSE2:
+ _mm_loadu_si128
+ _mm_storeu_si128
+ _mm_set_epi32
+ _mm_add_epi32
+ _mm_shuffle_epi32 / pshufd
+ _mm_xor_si128
+ _mm_cvtsi128_si32
+ _mm_cvtsi32_si128
+SSSE3:
+ _mm_shuffle_epi8 / pshufb
+
+SHA:
+ _mm_sha1*
+*/
+
+
+#define XOR_SI128(dest, src) dest = _mm_xor_si128(dest, src);
+#define SHUFFLE_EPI8(dest, mask) dest = _mm_shuffle_epi8(dest, mask);
+#define SHUFFLE_EPI32(dest, mask) dest = _mm_shuffle_epi32(dest, mask);
+#ifdef __clang__
+#define SHA1_RNDS4_RET_TYPE_CAST (__m128i)
+#else
+#define SHA1_RNDS4_RET_TYPE_CAST
+#endif
+#define SHA1_RND4(abcd, e0, f) abcd = SHA1_RNDS4_RET_TYPE_CAST _mm_sha1rnds4_epu32(abcd, e0, f);
+#define SHA1_NEXTE(e, m) e = _mm_sha1nexte_epu32(e, m);
+#define ADD_EPI32(dest, src) dest = _mm_add_epi32(dest, src);
+#define SHA1_MSG1(dest, src) dest = _mm_sha1msg1_epu32(dest, src);
+#define SHA1_MSG2(dest, src) dest = _mm_sha1msg2_epu32(dest, src);
+
+
+#define LOAD_SHUFFLE(m, k) \
+ m = _mm_loadu_si128((const __m128i *)(const void *)(data + (k) * 16)); \
+ SHUFFLE_EPI8(m, mask) \
+
+#define SM1(m0, m1, m2, m3) \
+ SHA1_MSG1(m0, m1) \
+
+#define SM2(m0, m1, m2, m3) \
+ XOR_SI128(m3, m1) \
+ SHA1_MSG2(m3, m2) \
+
+#define SM3(m0, m1, m2, m3) \
+ XOR_SI128(m3, m1) \
+ SM1(m0, m1, m2, m3) \
+ SHA1_MSG2(m3, m2) \
+
+#define NNN(m0, m1, m2, m3)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#define R4(k, e0, e1, m0, m1, m2, m3, OP) \
+ e1 = abcd; \
+ SHA1_RND4(abcd, e0, (k) / 5) \
+ SHA1_NEXTE(e1, m1) \
+ OP(m0, m1, m2, m3) \
+
+#define R16(k, mx, OP0, OP1, OP2, OP3) \
+ R4 ( (k)*4+0, e0,e1, m0,m1,m2,m3, OP0 ) \
+ R4 ( (k)*4+1, e1,e0, m1,m2,m3,m0, OP1 ) \
+ R4 ( (k)*4+2, e0,e1, m2,m3,m0,m1, OP2 ) \
+ R4 ( (k)*4+3, e1,e0, m3,mx,m1,m2, OP3 ) \
+
+#define PREPARE_STATE \
+ SHUFFLE_EPI32 (abcd, 0x1B) \
+ SHUFFLE_EPI32 (e0, 0x1B) \
+
+
+
+
+
+void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t numBlocks);
+#ifdef ATTRIB_SHA
+ATTRIB_SHA
+#endif
+void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t numBlocks)
+{
+ const __m128i mask = _mm_set_epi32(0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f);
+
+ __m128i abcd, e0;
+
+ if (numBlocks == 0)
+ return;
+
+ abcd = _mm_loadu_si128((const __m128i *) (const void *) &state[0]); // dbca
+ e0 = _mm_cvtsi32_si128((int)state[4]); // 000e
+
+ PREPARE_STATE
+
+ do
+ {
+ __m128i abcd_save, e2;
+ __m128i m0, m1, m2, m3;
+ __m128i e1;
+
+
+ abcd_save = abcd;
+ e2 = e0;
+
+ LOAD_SHUFFLE (m0, 0)
+ LOAD_SHUFFLE (m1, 1)
+ LOAD_SHUFFLE (m2, 2)
+ LOAD_SHUFFLE (m3, 3)
+
+ ADD_EPI32(e0, m0)
+
+ R16 ( 0, m0, SM1, SM3, SM3, SM3 )
+ R16 ( 1, m0, SM3, SM3, SM3, SM3 )
+ R16 ( 2, m0, SM3, SM3, SM3, SM3 )
+ R16 ( 3, m0, SM3, SM3, SM3, SM3 )
+ R16 ( 4, e2, SM2, NNN, NNN, NNN )
+
+ ADD_EPI32(abcd, abcd_save)
+
+ data += 64;
+ }
+ while (--numBlocks);
+
+ PREPARE_STATE
+
+ _mm_storeu_si128((__m128i *) (void *) state, abcd);
+ *(state+4) = (UInt32)_mm_cvtsi128_si32(e0);
+}
+
+#endif // USE_HW_SHA
+
+#elif defined(MY_CPU_ARM_OR_ARM64)
+
+ #if defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define USE_HW_SHA
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define USE_HW_SHA
+ #endif
+ #elif defined(_MSC_VER)
+ #if _MSC_VER >= 1910
+ #define USE_HW_SHA
+ #endif
+ #endif
+
+#ifdef USE_HW_SHA
+
+// #pragma message("=== Sha1 HW === ")
+
+#if defined(__clang__) || defined(__GNUC__)
+ #ifdef MY_CPU_ARM64
+ #define ATTRIB_SHA __attribute__((__target__("+crypto")))
+ #else
+ #define ATTRIB_SHA __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
+ #endif
+#else
+ // _MSC_VER
+ // for arm32
+ #define _ARM_USE_NEW_NEON_INTRINSICS
+#endif
+
+#if defined(_MSC_VER) && defined(MY_CPU_ARM64)
+#include <arm64_neon.h>
+#else
+#include <arm_neon.h>
+#endif
+
+typedef uint32x4_t v128;
+// typedef __n128 v128; // MSVC
+
+#ifdef MY_CPU_BE
+ #define MY_rev32_for_LE(x)
+#else
+ #define MY_rev32_for_LE(x) x = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(x)))
+#endif
+
+#define LOAD_128(_p) (*(const v128 *)(const void *)(_p))
+#define STORE_128(_p, _v) *(v128 *)(void *)(_p) = (_v)
+
+#define LOAD_SHUFFLE(m, k) \
+ m = LOAD_128((data + (k) * 16)); \
+ MY_rev32_for_LE(m); \
+
+#define SU0(dest, src2, src3) dest = vsha1su0q_u32(dest, src2, src3);
+#define SU1(dest, src) dest = vsha1su1q_u32(dest, src);
+#define C(e) abcd = vsha1cq_u32(abcd, e, t);
+#define P(e) abcd = vsha1pq_u32(abcd, e, t);
+#define M(e) abcd = vsha1mq_u32(abcd, e, t);
+#define H(e) e = vsha1h_u32(vgetq_lane_u32(abcd, 0))
+#define T(m, c) t = vaddq_u32(m, c)
+
+void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
+#ifdef ATTRIB_SHA
+ATTRIB_SHA
+#endif
+void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks)
+{
+ v128 abcd;
+ v128 c0, c1, c2, c3;
+ uint32_t e0;
+
+ if (numBlocks == 0)
+ return;
+
+ c0 = vdupq_n_u32(0x5a827999);
+ c1 = vdupq_n_u32(0x6ed9eba1);
+ c2 = vdupq_n_u32(0x8f1bbcdc);
+ c3 = vdupq_n_u32(0xca62c1d6);
+
+ abcd = LOAD_128(&state[0]);
+ e0 = state[4];
+
+ do
+ {
+ v128 abcd_save;
+ v128 m0, m1, m2, m3;
+ v128 t;
+ uint32_t e0_save, e1;
+
+ abcd_save = abcd;
+ e0_save = e0;
+
+ LOAD_SHUFFLE (m0, 0)
+ LOAD_SHUFFLE (m1, 1)
+ LOAD_SHUFFLE (m2, 2)
+ LOAD_SHUFFLE (m3, 3)
+
+ T(m0, c0); H(e1); C(e0);
+ T(m1, c0); SU0(m0, m1, m2); H(e0); C(e1);
+ T(m2, c0); SU0(m1, m2, m3); SU1(m0, m3); H(e1); C(e0);
+ T(m3, c0); SU0(m2, m3, m0); SU1(m1, m0); H(e0); C(e1);
+ T(m0, c0); SU0(m3, m0, m1); SU1(m2, m1); H(e1); C(e0);
+ T(m1, c1); SU0(m0, m1, m2); SU1(m3, m2); H(e0); P(e1);
+ T(m2, c1); SU0(m1, m2, m3); SU1(m0, m3); H(e1); P(e0);
+ T(m3, c1); SU0(m2, m3, m0); SU1(m1, m0); H(e0); P(e1);
+ T(m0, c1); SU0(m3, m0, m1); SU1(m2, m1); H(e1); P(e0);
+ T(m1, c1); SU0(m0, m1, m2); SU1(m3, m2); H(e0); P(e1);
+ T(m2, c2); SU0(m1, m2, m3); SU1(m0, m3); H(e1); M(e0);
+ T(m3, c2); SU0(m2, m3, m0); SU1(m1, m0); H(e0); M(e1);
+ T(m0, c2); SU0(m3, m0, m1); SU1(m2, m1); H(e1); M(e0);
+ T(m1, c2); SU0(m0, m1, m2); SU1(m3, m2); H(e0); M(e1);
+ T(m2, c2); SU0(m1, m2, m3); SU1(m0, m3); H(e1); M(e0);
+ T(m3, c3); SU0(m2, m3, m0); SU1(m1, m0); H(e0); P(e1);
+ T(m0, c3); SU0(m3, m0, m1); SU1(m2, m1); H(e1); P(e0);
+ T(m1, c3); SU1(m3, m2); H(e0); P(e1);
+ T(m2, c3); H(e1); P(e0);
+ T(m3, c3); H(e0); P(e1);
+
+ abcd = vaddq_u32(abcd, abcd_save);
+ e0 += e0_save;
+
+ data += 64;
+ }
+ while (--numBlocks);
+
+ STORE_128(&state[0], abcd);
+ state[4] = e0;
+}
+
+#endif // USE_HW_SHA
+
+#endif // MY_CPU_ARM_OR_ARM64
+
+
+#ifndef USE_HW_SHA
+
+// #error Stop_Compiling_UNSUPPORTED_SHA
+// #include <stdlib.h>
+
+// #include "Sha1.h"
+void Z7_FASTCALL Sha1_UpdateBlocks(UInt32 state[5], const Byte *data, size_t numBlocks);
+
+#pragma message("Sha1 HW-SW stub was used")
+
+void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t numBlocks);
+void Z7_FASTCALL Sha1_UpdateBlocks_HW(UInt32 state[5], const Byte *data, size_t numBlocks)
+{
+ Sha1_UpdateBlocks(state, data, numBlocks);
+ /*
+ UNUSED_VAR(state);
+ UNUSED_VAR(data);
+ UNUSED_VAR(numBlocks);
+ exit(1);
+ return;
+ */
+}
+
+#endif
+
+#undef SU0
+#undef SU1
+#undef C
+#undef P
+#undef M
+#undef H
+#undef T
+#undef MY_rev32_for_LE
+#undef NNN
+#undef LOAD_128
+#undef STORE_128
+#undef LOAD_SHUFFLE
+#undef SM1
+#undef SM2
+#undef SM3
+#undef NNN
+#undef R4
+#undef R16
+#undef PREPARE_STATE
+#undef USE_HW_SHA
+#undef ATTRIB_SHA
+#undef USE_VER_MIN
diff --git a/C/Sha256.c b/C/Sha256.c
index 90994e5..018cf6f 100644
--- a/C/Sha256.c
+++ b/C/Sha256.c
@@ -1,248 +1,516 @@
-/* Crypto/Sha256.c -- SHA-256 Hash
-2017-04-03 : Igor Pavlov : Public domain
-This code is based on public domain code from Wei Dai's Crypto++ library. */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "CpuArch.h"
-#include "RotateDefs.h"
-#include "Sha256.h"
-
-/* define it for speed optimization */
-#ifndef _SFX
-#define _SHA256_UNROLL
-#define _SHA256_UNROLL2
-#endif
-
-/* #define _SHA256_UNROLL2 */
-
-void Sha256_Init(CSha256 *p)
-{
- p->state[0] = 0x6a09e667;
- p->state[1] = 0xbb67ae85;
- p->state[2] = 0x3c6ef372;
- p->state[3] = 0xa54ff53a;
- p->state[4] = 0x510e527f;
- p->state[5] = 0x9b05688c;
- p->state[6] = 0x1f83d9ab;
- p->state[7] = 0x5be0cd19;
- p->count = 0;
-}
-
-#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
-#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
-#define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
-#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
-
-#define blk0(i) (W[i])
-#define blk2(i) (W[i] += s1(W[((i)-2)&15]) + W[((i)-7)&15] + s0(W[((i)-15)&15]))
-
-#define Ch(x,y,z) (z^(x&(y^z)))
-#define Maj(x,y,z) ((x&y)|(z&(x|y)))
-
-#ifdef _SHA256_UNROLL2
-
-#define R(a,b,c,d,e,f,g,h, i) \
- h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + (j ? blk2(i) : blk0(i)); \
- d += h; \
- h += S0(a) + Maj(a, b, c)
-
-#define RX_8(i) \
- R(a,b,c,d,e,f,g,h, i); \
- R(h,a,b,c,d,e,f,g, i+1); \
- R(g,h,a,b,c,d,e,f, i+2); \
- R(f,g,h,a,b,c,d,e, i+3); \
- R(e,f,g,h,a,b,c,d, i+4); \
- R(d,e,f,g,h,a,b,c, i+5); \
- R(c,d,e,f,g,h,a,b, i+6); \
- R(b,c,d,e,f,g,h,a, i+7)
-
-#define RX_16 RX_8(0); RX_8(8);
-
-#else
-
-#define a(i) T[(0-(i))&7]
-#define b(i) T[(1-(i))&7]
-#define c(i) T[(2-(i))&7]
-#define d(i) T[(3-(i))&7]
-#define e(i) T[(4-(i))&7]
-#define f(i) T[(5-(i))&7]
-#define g(i) T[(6-(i))&7]
-#define h(i) T[(7-(i))&7]
-
-#define R(i) \
- h(i) += S1(e(i)) + Ch(e(i),f(i),g(i)) + K[(i)+(size_t)(j)] + (j ? blk2(i) : blk0(i)); \
- d(i) += h(i); \
- h(i) += S0(a(i)) + Maj(a(i), b(i), c(i)) \
-
-#ifdef _SHA256_UNROLL
-
-#define RX_8(i) R(i+0); R(i+1); R(i+2); R(i+3); R(i+4); R(i+5); R(i+6); R(i+7);
-#define RX_16 RX_8(0); RX_8(8);
-
-#else
-
-#define RX_16 unsigned i; for (i = 0; i < 16; i++) { R(i); }
-
-#endif
-
-#endif
-
-static const UInt32 K[64] = {
- 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
- 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
- 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
- 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
- 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
- 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
- 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
- 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
- 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
- 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
- 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
- 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
- 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
- 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
- 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
- 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-};
-
-static void Sha256_WriteByteBlock(CSha256 *p)
-{
- UInt32 W[16];
- unsigned j;
- UInt32 *state;
-
- #ifdef _SHA256_UNROLL2
- UInt32 a,b,c,d,e,f,g,h;
- #else
- UInt32 T[8];
- #endif
-
- for (j = 0; j < 16; j += 4)
- {
- const Byte *ccc = p->buffer + j * 4;
- W[j ] = GetBe32(ccc);
- W[j + 1] = GetBe32(ccc + 4);
- W[j + 2] = GetBe32(ccc + 8);
- W[j + 3] = GetBe32(ccc + 12);
- }
-
- state = p->state;
-
- #ifdef _SHA256_UNROLL2
- a = state[0];
- b = state[1];
- c = state[2];
- d = state[3];
- e = state[4];
- f = state[5];
- g = state[6];
- h = state[7];
- #else
- for (j = 0; j < 8; j++)
- T[j] = state[j];
- #endif
-
- for (j = 0; j < 64; j += 16)
- {
- RX_16
- }
-
- #ifdef _SHA256_UNROLL2
- state[0] += a;
- state[1] += b;
- state[2] += c;
- state[3] += d;
- state[4] += e;
- state[5] += f;
- state[6] += g;
- state[7] += h;
- #else
- for (j = 0; j < 8; j++)
- state[j] += T[j];
- #endif
-
- /* Wipe variables */
- /* memset(W, 0, sizeof(W)); */
- /* memset(T, 0, sizeof(T)); */
-}
-
-#undef S0
-#undef S1
-#undef s0
-#undef s1
-
-void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
-{
- if (size == 0)
- return;
-
- {
- unsigned pos = (unsigned)p->count & 0x3F;
- unsigned num;
-
- p->count += size;
-
- num = 64 - pos;
- if (num > size)
- {
- memcpy(p->buffer + pos, data, size);
- return;
- }
-
- size -= num;
- memcpy(p->buffer + pos, data, num);
- data += num;
- }
-
- for (;;)
- {
- Sha256_WriteByteBlock(p);
- if (size < 64)
- break;
- size -= 64;
- memcpy(p->buffer, data, 64);
- data += 64;
- }
-
- if (size != 0)
- memcpy(p->buffer, data, size);
-}
-
-void Sha256_Final(CSha256 *p, Byte *digest)
-{
- unsigned pos = (unsigned)p->count & 0x3F;
- unsigned i;
-
- p->buffer[pos++] = 0x80;
-
- while (pos != (64 - 8))
- {
- pos &= 0x3F;
- if (pos == 0)
- Sha256_WriteByteBlock(p);
- p->buffer[pos++] = 0;
- }
-
- {
- UInt64 numBits = (p->count << 3);
- SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32));
- SetBe32(p->buffer + 64 - 4, (UInt32)(numBits));
- }
-
- Sha256_WriteByteBlock(p);
-
- for (i = 0; i < 8; i += 2)
- {
- UInt32 v0 = p->state[i];
- UInt32 v1 = p->state[i + 1];
- SetBe32(digest , v0);
- SetBe32(digest + 4, v1);
- digest += 8;
- }
-
- Sha256_Init(p);
-}
+/* Sha256.c -- SHA-256 Hash
+2023-04-02 : Igor Pavlov : Public domain
+This code is based on public domain code from Wei Dai's Crypto++ library. */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "CpuArch.h"
+#include "RotateDefs.h"
+#include "Sha256.h"
+
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+// #define USE_MY_MM
+#endif
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #ifdef _MSC_VER
+ #if _MSC_VER >= 1200
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #elif defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 8) // fix that check
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #elif defined(__INTEL_COMPILER)
+ #if (__INTEL_COMPILER >= 1800) // fix that check
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #endif
+#elif defined(MY_CPU_ARM_OR_ARM64)
+ #ifdef _MSC_VER
+ #if _MSC_VER >= 1910
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #elif defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define Z7_COMPILER_SHA256_SUPPORTED
+ #endif
+ #endif
+#endif
+
+void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks);
+
+#ifdef Z7_COMPILER_SHA256_SUPPORTED
+ void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
+
+ static SHA256_FUNC_UPDATE_BLOCKS g_SHA256_FUNC_UPDATE_BLOCKS = Sha256_UpdateBlocks;
+ static SHA256_FUNC_UPDATE_BLOCKS g_SHA256_FUNC_UPDATE_BLOCKS_HW;
+
+ #define SHA256_UPDATE_BLOCKS(p) p->func_UpdateBlocks
+#else
+ #define SHA256_UPDATE_BLOCKS(p) Sha256_UpdateBlocks
+#endif
+
+
+BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo)
+{
+ SHA256_FUNC_UPDATE_BLOCKS func = Sha256_UpdateBlocks;
+
+ #ifdef Z7_COMPILER_SHA256_SUPPORTED
+ if (algo != SHA256_ALGO_SW)
+ {
+ if (algo == SHA256_ALGO_DEFAULT)
+ func = g_SHA256_FUNC_UPDATE_BLOCKS;
+ else
+ {
+ if (algo != SHA256_ALGO_HW)
+ return False;
+ func = g_SHA256_FUNC_UPDATE_BLOCKS_HW;
+ if (!func)
+ return False;
+ }
+ }
+ #else
+ if (algo > 1)
+ return False;
+ #endif
+
+ p->func_UpdateBlocks = func;
+ return True;
+}
+
+
+/* define it for speed optimization */
+
+#ifdef Z7_SFX
+ #define STEP_PRE 1
+ #define STEP_MAIN 1
+#else
+ #define STEP_PRE 2
+ #define STEP_MAIN 4
+ // #define Z7_SHA256_UNROLL
+#endif
+
+#undef Z7_SHA256_BIG_W
+#if STEP_MAIN != 16
+ #define Z7_SHA256_BIG_W
+#endif
+
+
+
+
+void Sha256_InitState(CSha256 *p)
+{
+ p->count = 0;
+ p->state[0] = 0x6a09e667;
+ p->state[1] = 0xbb67ae85;
+ p->state[2] = 0x3c6ef372;
+ p->state[3] = 0xa54ff53a;
+ p->state[4] = 0x510e527f;
+ p->state[5] = 0x9b05688c;
+ p->state[6] = 0x1f83d9ab;
+ p->state[7] = 0x5be0cd19;
+}
+
+void Sha256_Init(CSha256 *p)
+{
+ p->func_UpdateBlocks =
+ #ifdef Z7_COMPILER_SHA256_SUPPORTED
+ g_SHA256_FUNC_UPDATE_BLOCKS;
+ #else
+ NULL;
+ #endif
+ Sha256_InitState(p);
+}
+
+#define S0(x) (rotrFixed(x, 2) ^ rotrFixed(x,13) ^ rotrFixed(x, 22))
+#define S1(x) (rotrFixed(x, 6) ^ rotrFixed(x,11) ^ rotrFixed(x, 25))
+#define s0(x) (rotrFixed(x, 7) ^ rotrFixed(x,18) ^ (x >> 3))
+#define s1(x) (rotrFixed(x,17) ^ rotrFixed(x,19) ^ (x >> 10))
+
+#define Ch(x,y,z) (z^(x&(y^z)))
+#define Maj(x,y,z) ((x&y)|(z&(x|y)))
+
+
+#define W_PRE(i) (W[(i) + (size_t)(j)] = GetBe32(data + ((size_t)(j) + i) * 4))
+
+#define blk2_main(j, i) s1(w(j, (i)-2)) + w(j, (i)-7) + s0(w(j, (i)-15))
+
+#ifdef Z7_SHA256_BIG_W
+ // we use +i instead of +(i) to change the order to solve CLANG compiler warning for signed/unsigned.
+ #define w(j, i) W[(size_t)(j) + i]
+ #define blk2(j, i) (w(j, i) = w(j, (i)-16) + blk2_main(j, i))
+#else
+ #if STEP_MAIN == 16
+ #define w(j, i) W[(i) & 15]
+ #else
+ #define w(j, i) W[((size_t)(j) + (i)) & 15]
+ #endif
+ #define blk2(j, i) (w(j, i) += blk2_main(j, i))
+#endif
+
+#define W_MAIN(i) blk2(j, i)
+
+
+#define T1(wx, i) \
+ tmp = h + S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
+ h = g; \
+ g = f; \
+ f = e; \
+ e = d + tmp; \
+ tmp += S0(a) + Maj(a, b, c); \
+ d = c; \
+ c = b; \
+ b = a; \
+ a = tmp; \
+
+#define R1_PRE(i) T1( W_PRE, i)
+#define R1_MAIN(i) T1( W_MAIN, i)
+
+#if (!defined(Z7_SHA256_UNROLL) || STEP_MAIN < 8) && (STEP_MAIN >= 4)
+#define R2_MAIN(i) \
+ R1_MAIN(i) \
+ R1_MAIN(i + 1) \
+
+#endif
+
+
+
+#if defined(Z7_SHA256_UNROLL) && STEP_MAIN >= 8
+
+#define T4( a,b,c,d,e,f,g,h, wx, i) \
+ h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
+ tmp = h; \
+ h += d; \
+ d = tmp + S0(a) + Maj(a, b, c); \
+
+#define R4( wx, i) \
+ T4 ( a,b,c,d,e,f,g,h, wx, (i )); \
+ T4 ( d,a,b,c,h,e,f,g, wx, (i+1)); \
+ T4 ( c,d,a,b,g,h,e,f, wx, (i+2)); \
+ T4 ( b,c,d,a,f,g,h,e, wx, (i+3)); \
+
+#define R4_PRE(i) R4( W_PRE, i)
+#define R4_MAIN(i) R4( W_MAIN, i)
+
+
+#define T8( a,b,c,d,e,f,g,h, wx, i) \
+ h += S1(e) + Ch(e,f,g) + K[(i)+(size_t)(j)] + wx(i); \
+ d += h; \
+ h += S0(a) + Maj(a, b, c); \
+
+#define R8( wx, i) \
+ T8 ( a,b,c,d,e,f,g,h, wx, i ); \
+ T8 ( h,a,b,c,d,e,f,g, wx, i+1); \
+ T8 ( g,h,a,b,c,d,e,f, wx, i+2); \
+ T8 ( f,g,h,a,b,c,d,e, wx, i+3); \
+ T8 ( e,f,g,h,a,b,c,d, wx, i+4); \
+ T8 ( d,e,f,g,h,a,b,c, wx, i+5); \
+ T8 ( c,d,e,f,g,h,a,b, wx, i+6); \
+ T8 ( b,c,d,e,f,g,h,a, wx, i+7); \
+
+#define R8_PRE(i) R8( W_PRE, i)
+#define R8_MAIN(i) R8( W_MAIN, i)
+
+#endif
+
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
+
+// static
+extern MY_ALIGN(64)
+const UInt32 SHA256_K_ARRAY[64];
+
+MY_ALIGN(64)
+const UInt32 SHA256_K_ARRAY[64] = {
+ 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+ 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+ 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+ 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+ 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+ 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+ 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+ 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+ 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+ 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+ 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+ 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+ 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+ 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+ 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+ 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+};
+
+#define K SHA256_K_ARRAY
+
+
+Z7_NO_INLINE
+void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks)
+{
+ UInt32 W
+ #ifdef Z7_SHA256_BIG_W
+ [64];
+ #else
+ [16];
+ #endif
+
+ unsigned j;
+
+ UInt32 a,b,c,d,e,f,g,h;
+
+ #if !defined(Z7_SHA256_UNROLL) || (STEP_MAIN <= 4) || (STEP_PRE <= 4)
+ UInt32 tmp;
+ #endif
+
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+ f = state[5];
+ g = state[6];
+ h = state[7];
+
+ while (numBlocks)
+ {
+
+ for (j = 0; j < 16; j += STEP_PRE)
+ {
+ #if STEP_PRE > 4
+
+ #if STEP_PRE < 8
+ R4_PRE(0);
+ #else
+ R8_PRE(0);
+ #if STEP_PRE == 16
+ R8_PRE(8);
+ #endif
+ #endif
+
+ #else
+
+ R1_PRE(0)
+ #if STEP_PRE >= 2
+ R1_PRE(1)
+ #if STEP_PRE >= 4
+ R1_PRE(2)
+ R1_PRE(3)
+ #endif
+ #endif
+
+ #endif
+ }
+
+ for (j = 16; j < 64; j += STEP_MAIN)
+ {
+ #if defined(Z7_SHA256_UNROLL) && STEP_MAIN >= 8
+
+ #if STEP_MAIN < 8
+ R4_MAIN(0)
+ #else
+ R8_MAIN(0)
+ #if STEP_MAIN == 16
+ R8_MAIN(8)
+ #endif
+ #endif
+
+ #else
+
+ R1_MAIN(0)
+ #if STEP_MAIN >= 2
+ R1_MAIN(1)
+ #if STEP_MAIN >= 4
+ R2_MAIN(2)
+ #if STEP_MAIN >= 8
+ R2_MAIN(4)
+ R2_MAIN(6)
+ #if STEP_MAIN >= 16
+ R2_MAIN(8)
+ R2_MAIN(10)
+ R2_MAIN(12)
+ R2_MAIN(14)
+ #endif
+ #endif
+ #endif
+ #endif
+ #endif
+ }
+
+ a += state[0]; state[0] = a;
+ b += state[1]; state[1] = b;
+ c += state[2]; state[2] = c;
+ d += state[3]; state[3] = d;
+ e += state[4]; state[4] = e;
+ f += state[5]; state[5] = f;
+ g += state[6]; state[6] = g;
+ h += state[7]; state[7] = h;
+
+ data += 64;
+ numBlocks--;
+ }
+
+ /* Wipe variables */
+ /* memset(W, 0, sizeof(W)); */
+}
+
+#undef S0
+#undef S1
+#undef s0
+#undef s1
+#undef K
+
+#define Sha256_UpdateBlock(p) SHA256_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
+
+void Sha256_Update(CSha256 *p, const Byte *data, size_t size)
+{
+ if (size == 0)
+ return;
+
+ {
+ unsigned pos = (unsigned)p->count & 0x3F;
+ unsigned num;
+
+ p->count += size;
+
+ num = 64 - pos;
+ if (num > size)
+ {
+ memcpy(p->buffer + pos, data, size);
+ return;
+ }
+
+ if (pos != 0)
+ {
+ size -= num;
+ memcpy(p->buffer + pos, data, num);
+ data += num;
+ Sha256_UpdateBlock(p);
+ }
+ }
+ {
+ size_t numBlocks = size >> 6;
+ SHA256_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
+ size &= 0x3F;
+ if (size == 0)
+ return;
+ data += (numBlocks << 6);
+ memcpy(p->buffer, data, size);
+ }
+}
+
+
+void Sha256_Final(CSha256 *p, Byte *digest)
+{
+ unsigned pos = (unsigned)p->count & 0x3F;
+ unsigned i;
+
+ p->buffer[pos++] = 0x80;
+
+ if (pos > (64 - 8))
+ {
+ while (pos != 64) { p->buffer[pos++] = 0; }
+ // memset(&p->buf.buffer[pos], 0, 64 - pos);
+ Sha256_UpdateBlock(p);
+ pos = 0;
+ }
+
+ /*
+ if (pos & 3)
+ {
+ p->buffer[pos] = 0;
+ p->buffer[pos + 1] = 0;
+ p->buffer[pos + 2] = 0;
+ pos += 3;
+ pos &= ~3;
+ }
+ {
+ for (; pos < 64 - 8; pos += 4)
+ *(UInt32 *)(&p->buffer[pos]) = 0;
+ }
+ */
+
+ memset(&p->buffer[pos], 0, (64 - 8) - pos);
+
+ {
+ UInt64 numBits = (p->count << 3);
+ SetBe32(p->buffer + 64 - 8, (UInt32)(numBits >> 32))
+ SetBe32(p->buffer + 64 - 4, (UInt32)(numBits))
+ }
+
+ Sha256_UpdateBlock(p);
+
+ for (i = 0; i < 8; i += 2)
+ {
+ UInt32 v0 = p->state[i];
+ UInt32 v1 = p->state[(size_t)i + 1];
+ SetBe32(digest , v0)
+ SetBe32(digest + 4, v1)
+ digest += 8;
+ }
+
+ Sha256_InitState(p);
+}
+
+
+void Sha256Prepare(void)
+{
+ #ifdef Z7_COMPILER_SHA256_SUPPORTED
+ SHA256_FUNC_UPDATE_BLOCKS f, f_hw;
+ f = Sha256_UpdateBlocks;
+ f_hw = NULL;
+ #ifdef MY_CPU_X86_OR_AMD64
+ #ifndef USE_MY_MM
+ if (CPU_IsSupported_SHA()
+ && CPU_IsSupported_SSSE3()
+ // && CPU_IsSupported_SSE41()
+ )
+ #endif
+ #else
+ if (CPU_IsSupported_SHA2())
+ #endif
+ {
+ // printf("\n========== HW SHA256 ======== \n");
+ f = f_hw = Sha256_UpdateBlocks_HW;
+ }
+ g_SHA256_FUNC_UPDATE_BLOCKS = f;
+ g_SHA256_FUNC_UPDATE_BLOCKS_HW = f_hw;
+ #endif
+}
+
+#undef S0
+#undef S1
+#undef s0
+#undef s1
+#undef Ch
+#undef Maj
+#undef W_MAIN
+#undef W_PRE
+#undef w
+#undef blk2_main
+#undef blk2
+#undef T1
+#undef T4
+#undef T8
+#undef R1_PRE
+#undef R1_MAIN
+#undef R2_MAIN
+#undef R4
+#undef R4_PRE
+#undef R4_MAIN
+#undef R8
+#undef R8_PRE
+#undef R8_MAIN
+#undef STEP_PRE
+#undef STEP_MAIN
+#undef Z7_SHA256_BIG_W
+#undef Z7_SHA256_UNROLL
+#undef Z7_COMPILER_SHA256_SUPPORTED
diff --git a/C/Sha256.h b/C/Sha256.h
index 7f17ccf..9e04223 100644
--- a/C/Sha256.h
+++ b/C/Sha256.h
@@ -1,26 +1,76 @@
-/* Sha256.h -- SHA-256 Hash
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __CRYPTO_SHA256_H
-#define __CRYPTO_SHA256_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-#define SHA256_DIGEST_SIZE 32
-
-typedef struct
-{
- UInt32 state[8];
- UInt64 count;
- Byte buffer[64];
-} CSha256;
-
-void Sha256_Init(CSha256 *p);
-void Sha256_Update(CSha256 *p, const Byte *data, size_t size);
-void Sha256_Final(CSha256 *p, Byte *digest);
-
-EXTERN_C_END
-
-#endif
+/* Sha256.h -- SHA-256 Hash
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_SHA256_H
+#define ZIP7_INC_SHA256_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define SHA256_NUM_BLOCK_WORDS 16
+#define SHA256_NUM_DIGEST_WORDS 8
+
+#define SHA256_BLOCK_SIZE (SHA256_NUM_BLOCK_WORDS * 4)
+#define SHA256_DIGEST_SIZE (SHA256_NUM_DIGEST_WORDS * 4)
+
+typedef void (Z7_FASTCALL *SHA256_FUNC_UPDATE_BLOCKS)(UInt32 state[8], const Byte *data, size_t numBlocks);
+
+/*
+ if (the system supports different SHA256 code implementations)
+ {
+ (CSha256::func_UpdateBlocks) will be used
+ (CSha256::func_UpdateBlocks) can be set by
+ Sha256_Init() - to default (fastest)
+ Sha256_SetFunction() - to any algo
+ }
+ else
+ {
+ (CSha256::func_UpdateBlocks) is ignored.
+ }
+*/
+
+typedef struct
+{
+ SHA256_FUNC_UPDATE_BLOCKS func_UpdateBlocks;
+ UInt64 count;
+ UInt64 _pad_2[2];
+ UInt32 state[SHA256_NUM_DIGEST_WORDS];
+
+ Byte buffer[SHA256_BLOCK_SIZE];
+} CSha256;
+
+
+#define SHA256_ALGO_DEFAULT 0
+#define SHA256_ALGO_SW 1
+#define SHA256_ALGO_HW 2
+
+/*
+Sha256_SetFunction()
+return:
+ 0 - (algo) value is not supported, and func_UpdateBlocks was not changed
+ 1 - func_UpdateBlocks was set according (algo) value.
+*/
+
+BoolInt Sha256_SetFunction(CSha256 *p, unsigned algo);
+
+void Sha256_InitState(CSha256 *p);
+void Sha256_Init(CSha256 *p);
+void Sha256_Update(CSha256 *p, const Byte *data, size_t size);
+void Sha256_Final(CSha256 *p, Byte *digest);
+
+
+
+
+// void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks);
+
+/*
+call Sha256Prepare() once at program start.
+It prepares all supported implementations, and detects the fastest implementation.
+*/
+
+void Sha256Prepare(void);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Sha256Opt.c b/C/Sha256Opt.c
new file mode 100644
index 0000000..e4465e3
--- /dev/null
+++ b/C/Sha256Opt.c
@@ -0,0 +1,386 @@
+/* Sha256Opt.c -- SHA-256 optimized code for SHA-256 hardware instructions
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+#include "Compiler.h"
+#include "CpuArch.h"
+
+#if defined(_MSC_VER)
+#if (_MSC_VER < 1900) && (_MSC_VER >= 1200)
+// #define USE_MY_MM
+#endif
+#endif
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1600) // fix that check
+ #define USE_HW_SHA
+ #elif defined(Z7_LLVM_CLANG_VERSION) && (Z7_LLVM_CLANG_VERSION >= 30800) \
+ || defined(Z7_APPLE_CLANG_VERSION) && (Z7_APPLE_CLANG_VERSION >= 50100) \
+ || defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40900)
+ #define USE_HW_SHA
+ #if !defined(_INTEL_COMPILER)
+ // icc defines __GNUC__, but icc doesn't support __attribute__(__target__)
+ #if !defined(__SHA__) || !defined(__SSSE3__)
+ #define ATTRIB_SHA __attribute__((__target__("sha,ssse3")))
+ #endif
+ #endif
+ #elif defined(_MSC_VER)
+ #ifdef USE_MY_MM
+ #define USE_VER_MIN 1300
+ #else
+ #define USE_VER_MIN 1900
+ #endif
+ #if (_MSC_VER >= USE_VER_MIN)
+ #define USE_HW_SHA
+ #endif
+ #endif
+// #endif // MY_CPU_X86_OR_AMD64
+
+#ifdef USE_HW_SHA
+
+// #pragma message("Sha256 HW")
+
+// sse/sse2/ssse3:
+#include <tmmintrin.h>
+// sha*:
+#include <immintrin.h>
+
+#if defined (__clang__) && defined(_MSC_VER)
+ // #if !defined(__SSSE3__)
+ // #endif
+ #if !defined(__SHA__)
+ #include <shaintrin.h>
+ #endif
+#else
+
+#ifdef USE_MY_MM
+#include "My_mm.h"
+#endif
+
+#endif
+
+/*
+SHA256 uses:
+SSE2:
+ _mm_loadu_si128
+ _mm_storeu_si128
+ _mm_set_epi32
+ _mm_add_epi32
+ _mm_shuffle_epi32 / pshufd
+
+
+
+SSSE3:
+ _mm_shuffle_epi8 / pshufb
+ _mm_alignr_epi8
+SHA:
+ _mm_sha256*
+*/
+
+// K array must be aligned for 16-bytes at least.
+// The compiler can look align attribute and selects
+// movdqu - for code without align attribute
+// movdqa - for code with align attribute
+extern
+MY_ALIGN(64)
+const UInt32 SHA256_K_ARRAY[64];
+
+#define K SHA256_K_ARRAY
+
+
+#define ADD_EPI32(dest, src) dest = _mm_add_epi32(dest, src);
+#define SHA256_MSG1(dest, src) dest = _mm_sha256msg1_epu32(dest, src);
+#define SHA25G_MSG2(dest, src) dest = _mm_sha256msg2_epu32(dest, src);
+
+
+#define LOAD_SHUFFLE(m, k) \
+ m = _mm_loadu_si128((const __m128i *)(const void *)(data + (k) * 16)); \
+ m = _mm_shuffle_epi8(m, mask); \
+
+#define SM1(g0, g1, g2, g3) \
+ SHA256_MSG1(g3, g0); \
+
+#define SM2(g0, g1, g2, g3) \
+ tmp = _mm_alignr_epi8(g1, g0, 4); \
+ ADD_EPI32(g2, tmp) \
+ SHA25G_MSG2(g2, g1); \
+
+// #define LS0(k, g0, g1, g2, g3) LOAD_SHUFFLE(g0, k)
+// #define LS1(k, g0, g1, g2, g3) LOAD_SHUFFLE(g1, k+1)
+
+
+#define NNN(g0, g1, g2, g3)
+
+
+#define RND2(t0, t1) \
+ t0 = _mm_sha256rnds2_epu32(t0, t1, msg);
+
+#define RND2_0(m, k) \
+ msg = _mm_add_epi32(m, *(const __m128i *) (const void *) &K[(k) * 4]); \
+ RND2(state0, state1); \
+ msg = _mm_shuffle_epi32(msg, 0x0E); \
+
+
+#define RND2_1 \
+ RND2(state1, state0); \
+
+
+// We use scheme with 3 rounds ahead for SHA256_MSG1 / 2 rounds ahead for SHA256_MSG2
+
+#define R4(k, g0, g1, g2, g3, OP0, OP1) \
+ RND2_0(g0, k) \
+ OP0(g0, g1, g2, g3) \
+ RND2_1 \
+ OP1(g0, g1, g2, g3) \
+
+#define R16(k, OP0, OP1, OP2, OP3, OP4, OP5, OP6, OP7) \
+ R4 ( (k)*4+0, m0,m1,m2,m3, OP0, OP1 ) \
+ R4 ( (k)*4+1, m1,m2,m3,m0, OP2, OP3 ) \
+ R4 ( (k)*4+2, m2,m3,m0,m1, OP4, OP5 ) \
+ R4 ( (k)*4+3, m3,m0,m1,m2, OP6, OP7 ) \
+
+#define PREPARE_STATE \
+ tmp = _mm_shuffle_epi32(state0, 0x1B); /* abcd */ \
+ state0 = _mm_shuffle_epi32(state1, 0x1B); /* efgh */ \
+ state1 = state0; \
+ state0 = _mm_unpacklo_epi64(state0, tmp); /* cdgh */ \
+ state1 = _mm_unpackhi_epi64(state1, tmp); /* abef */ \
+
+
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
+#ifdef ATTRIB_SHA
+ATTRIB_SHA
+#endif
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks)
+{
+ const __m128i mask = _mm_set_epi32(0x0c0d0e0f, 0x08090a0b, 0x04050607, 0x00010203);
+ __m128i tmp;
+ __m128i state0, state1;
+
+ if (numBlocks == 0)
+ return;
+
+ state0 = _mm_loadu_si128((const __m128i *) (const void *) &state[0]);
+ state1 = _mm_loadu_si128((const __m128i *) (const void *) &state[4]);
+
+ PREPARE_STATE
+
+ do
+ {
+ __m128i state0_save, state1_save;
+ __m128i m0, m1, m2, m3;
+ __m128i msg;
+ // #define msg tmp
+
+ state0_save = state0;
+ state1_save = state1;
+
+ LOAD_SHUFFLE (m0, 0)
+ LOAD_SHUFFLE (m1, 1)
+ LOAD_SHUFFLE (m2, 2)
+ LOAD_SHUFFLE (m3, 3)
+
+
+
+ R16 ( 0, NNN, NNN, SM1, NNN, SM1, SM2, SM1, SM2 )
+ R16 ( 1, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 )
+ R16 ( 2, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 )
+ R16 ( 3, SM1, SM2, NNN, SM2, NNN, NNN, NNN, NNN )
+
+ ADD_EPI32(state0, state0_save)
+ ADD_EPI32(state1, state1_save)
+
+ data += 64;
+ }
+ while (--numBlocks);
+
+ PREPARE_STATE
+
+ _mm_storeu_si128((__m128i *) (void *) &state[0], state0);
+ _mm_storeu_si128((__m128i *) (void *) &state[4], state1);
+}
+
+#endif // USE_HW_SHA
+
+#elif defined(MY_CPU_ARM_OR_ARM64)
+
+ #if defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define USE_HW_SHA
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define USE_HW_SHA
+ #endif
+ #elif defined(_MSC_VER)
+ #if _MSC_VER >= 1910
+ #define USE_HW_SHA
+ #endif
+ #endif
+
+#ifdef USE_HW_SHA
+
+// #pragma message("=== Sha256 HW === ")
+
+#if defined(__clang__) || defined(__GNUC__)
+ #ifdef MY_CPU_ARM64
+ #define ATTRIB_SHA __attribute__((__target__("+crypto")))
+ #else
+ #define ATTRIB_SHA __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
+ #endif
+#else
+ // _MSC_VER
+ // for arm32
+ #define _ARM_USE_NEW_NEON_INTRINSICS
+#endif
+
+#if defined(_MSC_VER) && defined(MY_CPU_ARM64)
+#include <arm64_neon.h>
+#else
+#include <arm_neon.h>
+#endif
+
+typedef uint32x4_t v128;
+// typedef __n128 v128; // MSVC
+
+#ifdef MY_CPU_BE
+ #define MY_rev32_for_LE(x)
+#else
+ #define MY_rev32_for_LE(x) x = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(x)))
+#endif
+
+#define LOAD_128(_p) (*(const v128 *)(const void *)(_p))
+#define STORE_128(_p, _v) *(v128 *)(void *)(_p) = (_v)
+
+#define LOAD_SHUFFLE(m, k) \
+ m = LOAD_128((data + (k) * 16)); \
+ MY_rev32_for_LE(m); \
+
+// K array must be aligned for 16-bytes at least.
+extern
+MY_ALIGN(64)
+const UInt32 SHA256_K_ARRAY[64];
+
+#define K SHA256_K_ARRAY
+
+
+#define SHA256_SU0(dest, src) dest = vsha256su0q_u32(dest, src);
+#define SHA25G_SU1(dest, src2, src3) dest = vsha256su1q_u32(dest, src2, src3);
+
+#define SM1(g0, g1, g2, g3) SHA256_SU0(g3, g0)
+#define SM2(g0, g1, g2, g3) SHA25G_SU1(g2, g0, g1)
+#define NNN(g0, g1, g2, g3)
+
+
+#define R4(k, g0, g1, g2, g3, OP0, OP1) \
+ msg = vaddq_u32(g0, *(const v128 *) (const void *) &K[(k) * 4]); \
+ tmp = state0; \
+ state0 = vsha256hq_u32( state0, state1, msg ); \
+ state1 = vsha256h2q_u32( state1, tmp, msg ); \
+ OP0(g0, g1, g2, g3); \
+ OP1(g0, g1, g2, g3); \
+
+
+#define R16(k, OP0, OP1, OP2, OP3, OP4, OP5, OP6, OP7) \
+ R4 ( (k)*4+0, m0, m1, m2, m3, OP0, OP1 ) \
+ R4 ( (k)*4+1, m1, m2, m3, m0, OP2, OP3 ) \
+ R4 ( (k)*4+2, m2, m3, m0, m1, OP4, OP5 ) \
+ R4 ( (k)*4+3, m3, m0, m1, m2, OP6, OP7 ) \
+
+
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
+#ifdef ATTRIB_SHA
+ATTRIB_SHA
+#endif
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks)
+{
+ v128 state0, state1;
+
+ if (numBlocks == 0)
+ return;
+
+ state0 = LOAD_128(&state[0]);
+ state1 = LOAD_128(&state[4]);
+
+ do
+ {
+ v128 state0_save, state1_save;
+ v128 m0, m1, m2, m3;
+ v128 msg, tmp;
+
+ state0_save = state0;
+ state1_save = state1;
+
+ LOAD_SHUFFLE (m0, 0)
+ LOAD_SHUFFLE (m1, 1)
+ LOAD_SHUFFLE (m2, 2)
+ LOAD_SHUFFLE (m3, 3)
+
+ R16 ( 0, NNN, NNN, SM1, NNN, SM1, SM2, SM1, SM2 );
+ R16 ( 1, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 );
+ R16 ( 2, SM1, SM2, SM1, SM2, SM1, SM2, SM1, SM2 );
+ R16 ( 3, SM1, SM2, NNN, SM2, NNN, NNN, NNN, NNN );
+
+ state0 = vaddq_u32(state0, state0_save);
+ state1 = vaddq_u32(state1, state1_save);
+
+ data += 64;
+ }
+ while (--numBlocks);
+
+ STORE_128(&state[0], state0);
+ STORE_128(&state[4], state1);
+}
+
+#endif // USE_HW_SHA
+
+#endif // MY_CPU_ARM_OR_ARM64
+
+
+#ifndef USE_HW_SHA
+
+// #error Stop_Compiling_UNSUPPORTED_SHA
+// #include <stdlib.h>
+
+// #include "Sha256.h"
+void Z7_FASTCALL Sha256_UpdateBlocks(UInt32 state[8], const Byte *data, size_t numBlocks);
+
+#pragma message("Sha256 HW-SW stub was used")
+
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks);
+void Z7_FASTCALL Sha256_UpdateBlocks_HW(UInt32 state[8], const Byte *data, size_t numBlocks)
+{
+ Sha256_UpdateBlocks(state, data, numBlocks);
+ /*
+ UNUSED_VAR(state);
+ UNUSED_VAR(data);
+ UNUSED_VAR(numBlocks);
+ exit(1);
+ return;
+ */
+}
+
+#endif
+
+
+
+#undef K
+#undef RND2
+#undef RND2_0
+#undef RND2_1
+
+#undef MY_rev32_for_LE
+#undef NNN
+#undef LOAD_128
+#undef STORE_128
+#undef LOAD_SHUFFLE
+#undef SM1
+#undef SM2
+
+#undef NNN
+#undef R4
+#undef R16
+#undef PREPARE_STATE
+#undef USE_HW_SHA
+#undef ATTRIB_SHA
+#undef USE_VER_MIN
diff --git a/C/Sort.c b/C/Sort.c
index 73dcbf0..e1097e3 100644
--- a/C/Sort.c
+++ b/C/Sort.c
@@ -1,141 +1,141 @@
-/* Sort.c -- Sort functions
-2014-04-05 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "Sort.h"
-
-#define HeapSortDown(p, k, size, temp) \
- { for (;;) { \
- size_t s = (k << 1); \
- if (s > size) break; \
- if (s < size && p[s + 1] > p[s]) s++; \
- if (temp >= p[s]) break; \
- p[k] = p[s]; k = s; \
- } p[k] = temp; }
-
-void HeapSort(UInt32 *p, size_t size)
-{
- if (size <= 1)
- return;
- p--;
- {
- size_t i = size / 2;
- do
- {
- UInt32 temp = p[i];
- size_t k = i;
- HeapSortDown(p, k, size, temp)
- }
- while (--i != 0);
- }
- /*
- do
- {
- size_t k = 1;
- UInt32 temp = p[size];
- p[size--] = p[1];
- HeapSortDown(p, k, size, temp)
- }
- while (size > 1);
- */
- while (size > 3)
- {
- UInt32 temp = p[size];
- size_t k = (p[3] > p[2]) ? 3 : 2;
- p[size--] = p[1];
- p[1] = p[k];
- HeapSortDown(p, k, size, temp)
- }
- {
- UInt32 temp = p[size];
- p[size] = p[1];
- if (size > 2 && p[2] < temp)
- {
- p[1] = p[2];
- p[2] = temp;
- }
- else
- p[1] = temp;
- }
-}
-
-void HeapSort64(UInt64 *p, size_t size)
-{
- if (size <= 1)
- return;
- p--;
- {
- size_t i = size / 2;
- do
- {
- UInt64 temp = p[i];
- size_t k = i;
- HeapSortDown(p, k, size, temp)
- }
- while (--i != 0);
- }
- /*
- do
- {
- size_t k = 1;
- UInt64 temp = p[size];
- p[size--] = p[1];
- HeapSortDown(p, k, size, temp)
- }
- while (size > 1);
- */
- while (size > 3)
- {
- UInt64 temp = p[size];
- size_t k = (p[3] > p[2]) ? 3 : 2;
- p[size--] = p[1];
- p[1] = p[k];
- HeapSortDown(p, k, size, temp)
- }
- {
- UInt64 temp = p[size];
- p[size] = p[1];
- if (size > 2 && p[2] < temp)
- {
- p[1] = p[2];
- p[2] = temp;
- }
- else
- p[1] = temp;
- }
-}
-
-/*
-#define HeapSortRefDown(p, vals, n, size, temp) \
- { size_t k = n; UInt32 val = vals[temp]; for (;;) { \
- size_t s = (k << 1); \
- if (s > size) break; \
- if (s < size && vals[p[s + 1]] > vals[p[s]]) s++; \
- if (val >= vals[p[s]]) break; \
- p[k] = p[s]; k = s; \
- } p[k] = temp; }
-
-void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size)
-{
- if (size <= 1)
- return;
- p--;
- {
- size_t i = size / 2;
- do
- {
- UInt32 temp = p[i];
- HeapSortRefDown(p, vals, i, size, temp);
- }
- while (--i != 0);
- }
- do
- {
- UInt32 temp = p[size];
- p[size--] = p[1];
- HeapSortRefDown(p, vals, 1, size, temp);
- }
- while (size > 1);
-}
-*/
+/* Sort.c -- Sort functions
+2014-04-05 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Sort.h"
+
+#define HeapSortDown(p, k, size, temp) \
+ { for (;;) { \
+ size_t s = (k << 1); \
+ if (s > size) break; \
+ if (s < size && p[s + 1] > p[s]) s++; \
+ if (temp >= p[s]) break; \
+ p[k] = p[s]; k = s; \
+ } p[k] = temp; }
+
+void HeapSort(UInt32 *p, size_t size)
+{
+ if (size <= 1)
+ return;
+ p--;
+ {
+ size_t i = size / 2;
+ do
+ {
+ UInt32 temp = p[i];
+ size_t k = i;
+ HeapSortDown(p, k, size, temp)
+ }
+ while (--i != 0);
+ }
+ /*
+ do
+ {
+ size_t k = 1;
+ UInt32 temp = p[size];
+ p[size--] = p[1];
+ HeapSortDown(p, k, size, temp)
+ }
+ while (size > 1);
+ */
+ while (size > 3)
+ {
+ UInt32 temp = p[size];
+ size_t k = (p[3] > p[2]) ? 3 : 2;
+ p[size--] = p[1];
+ p[1] = p[k];
+ HeapSortDown(p, k, size, temp)
+ }
+ {
+ UInt32 temp = p[size];
+ p[size] = p[1];
+ if (size > 2 && p[2] < temp)
+ {
+ p[1] = p[2];
+ p[2] = temp;
+ }
+ else
+ p[1] = temp;
+ }
+}
+
+void HeapSort64(UInt64 *p, size_t size)
+{
+ if (size <= 1)
+ return;
+ p--;
+ {
+ size_t i = size / 2;
+ do
+ {
+ UInt64 temp = p[i];
+ size_t k = i;
+ HeapSortDown(p, k, size, temp)
+ }
+ while (--i != 0);
+ }
+ /*
+ do
+ {
+ size_t k = 1;
+ UInt64 temp = p[size];
+ p[size--] = p[1];
+ HeapSortDown(p, k, size, temp)
+ }
+ while (size > 1);
+ */
+ while (size > 3)
+ {
+ UInt64 temp = p[size];
+ size_t k = (p[3] > p[2]) ? 3 : 2;
+ p[size--] = p[1];
+ p[1] = p[k];
+ HeapSortDown(p, k, size, temp)
+ }
+ {
+ UInt64 temp = p[size];
+ p[size] = p[1];
+ if (size > 2 && p[2] < temp)
+ {
+ p[1] = p[2];
+ p[2] = temp;
+ }
+ else
+ p[1] = temp;
+ }
+}
+
+/*
+#define HeapSortRefDown(p, vals, n, size, temp) \
+ { size_t k = n; UInt32 val = vals[temp]; for (;;) { \
+ size_t s = (k << 1); \
+ if (s > size) break; \
+ if (s < size && vals[p[s + 1]] > vals[p[s]]) s++; \
+ if (val >= vals[p[s]]) break; \
+ p[k] = p[s]; k = s; \
+ } p[k] = temp; }
+
+void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size)
+{
+ if (size <= 1)
+ return;
+ p--;
+ {
+ size_t i = size / 2;
+ do
+ {
+ UInt32 temp = p[i];
+ HeapSortRefDown(p, vals, i, size, temp);
+ }
+ while (--i != 0);
+ }
+ do
+ {
+ UInt32 temp = p[size];
+ p[size--] = p[1];
+ HeapSortRefDown(p, vals, 1, size, temp);
+ }
+ while (size > 1);
+}
+*/
diff --git a/C/Sort.h b/C/Sort.h
index 7209d78..1817b65 100644
--- a/C/Sort.h
+++ b/C/Sort.h
@@ -1,18 +1,18 @@
-/* Sort.h -- Sort functions
-2014-04-05 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_SORT_H
-#define __7Z_SORT_H
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-void HeapSort(UInt32 *p, size_t size);
-void HeapSort64(UInt64 *p, size_t size);
-
-/* void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size); */
-
-EXTERN_C_END
-
-#endif
+/* Sort.h -- Sort functions
+2023-03-05 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_SORT_H
+#define ZIP7_INC_SORT_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+void HeapSort(UInt32 *p, size_t size);
+void HeapSort64(UInt64 *p, size_t size);
+
+/* void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size); */
+
+EXTERN_C_END
+
+#endif
diff --git a/C/SwapBytes.c b/C/SwapBytes.c
new file mode 100644
index 0000000..7901bba
--- /dev/null
+++ b/C/SwapBytes.c
@@ -0,0 +1,800 @@
+/* SwapBytes.c -- Byte Swap conversion filter
+2023-04-07 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Compiler.h"
+#include "CpuArch.h"
+#include "RotateDefs.h"
+#include "SwapBytes.h"
+
+typedef UInt16 CSwapUInt16;
+typedef UInt32 CSwapUInt32;
+
+// #define k_SwapBytes_Mode_BASE 0
+
+#ifdef MY_CPU_X86_OR_AMD64
+
+#define k_SwapBytes_Mode_SSE2 1
+#define k_SwapBytes_Mode_SSSE3 2
+#define k_SwapBytes_Mode_AVX2 3
+
+ // #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1900)
+ #if defined(__clang__) && (__clang_major__ >= 4) \
+ || defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40701)
+ #define k_SwapBytes_Mode_MAX k_SwapBytes_Mode_AVX2
+ #define SWAP_ATTRIB_SSE2 __attribute__((__target__("sse2")))
+ #define SWAP_ATTRIB_SSSE3 __attribute__((__target__("ssse3")))
+ #define SWAP_ATTRIB_AVX2 __attribute__((__target__("avx2")))
+ #elif defined(_MSC_VER)
+ #if (_MSC_VER == 1900)
+ #pragma warning(disable : 4752) // found Intel(R) Advanced Vector Extensions; consider using /arch:AVX
+ #endif
+ #if (_MSC_VER >= 1900)
+ #define k_SwapBytes_Mode_MAX k_SwapBytes_Mode_AVX2
+ #elif (_MSC_VER >= 1500) // (VS2008)
+ #define k_SwapBytes_Mode_MAX k_SwapBytes_Mode_SSSE3
+ #elif (_MSC_VER >= 1310) // (VS2003)
+ #define k_SwapBytes_Mode_MAX k_SwapBytes_Mode_SSE2
+ #endif
+ #endif // _MSC_VER
+
+/*
+// for debug
+#ifdef k_SwapBytes_Mode_MAX
+#undef k_SwapBytes_Mode_MAX
+#endif
+*/
+
+#ifndef k_SwapBytes_Mode_MAX
+#define k_SwapBytes_Mode_MAX 0
+#endif
+
+#if (k_SwapBytes_Mode_MAX != 0) && defined(MY_CPU_AMD64)
+ #define k_SwapBytes_Mode_MIN k_SwapBytes_Mode_SSE2
+#else
+ #define k_SwapBytes_Mode_MIN 0
+#endif
+
+#if (k_SwapBytes_Mode_MAX >= k_SwapBytes_Mode_AVX2)
+ #define USE_SWAP_AVX2
+#endif
+#if (k_SwapBytes_Mode_MAX >= k_SwapBytes_Mode_SSSE3)
+ #define USE_SWAP_SSSE3
+#endif
+#if (k_SwapBytes_Mode_MAX >= k_SwapBytes_Mode_SSE2)
+ #define USE_SWAP_128
+#endif
+
+#if k_SwapBytes_Mode_MAX <= k_SwapBytes_Mode_MIN || !defined(USE_SWAP_128)
+#define FORCE_SWAP_MODE
+#endif
+
+
+#ifdef USE_SWAP_128
+/*
+ <mmintrin.h> MMX
+<xmmintrin.h> SSE
+<emmintrin.h> SSE2
+<pmmintrin.h> SSE3
+<tmmintrin.h> SSSE3
+<smmintrin.h> SSE4.1
+<nmmintrin.h> SSE4.2
+<ammintrin.h> SSE4A
+<wmmintrin.h> AES
+<immintrin.h> AVX, AVX2, FMA
+*/
+
+#include <emmintrin.h> // sse2
+// typedef __m128i v128;
+
+#define SWAP2_128(i) { \
+ const __m128i v = *(const __m128i *)(const void *)(items + (i) * 8); \
+ *( __m128i *)( void *)(items + (i) * 8) = \
+ _mm_or_si128( \
+ _mm_slli_epi16(v, 8), \
+ _mm_srli_epi16(v, 8)); }
+// _mm_or_si128() has more ports to execute than _mm_add_epi16().
+
+static
+#ifdef SWAP_ATTRIB_SSE2
+SWAP_ATTRIB_SSE2
+#endif
+void
+Z7_FASTCALL
+SwapBytes2_128(CSwapUInt16 *items, const CSwapUInt16 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP2_128(0) SWAP2_128(1) items += 2 * 8;
+ SWAP2_128(0) SWAP2_128(1) items += 2 * 8;
+ }
+ while (items != lim);
+}
+
+/*
+// sse2
+#define SWAP4_128_pack(i) { \
+ __m128i v = *(const __m128i *)(const void *)(items + (i) * 4); \
+ __m128i v0 = _mm_unpacklo_epi8(v, mask); \
+ __m128i v1 = _mm_unpackhi_epi8(v, mask); \
+ v0 = _mm_shufflelo_epi16(v0, 0x1b); \
+ v1 = _mm_shufflelo_epi16(v1, 0x1b); \
+ v0 = _mm_shufflehi_epi16(v0, 0x1b); \
+ v1 = _mm_shufflehi_epi16(v1, 0x1b); \
+ *(__m128i *)(void *)(items + (i) * 4) = _mm_packus_epi16(v0, v1); }
+
+static
+#ifdef SWAP_ATTRIB_SSE2
+SWAP_ATTRIB_SSE2
+#endif
+void
+Z7_FASTCALL
+SwapBytes4_128_pack(CSwapUInt32 *items, const CSwapUInt32 *lim)
+{
+ const __m128i mask = _mm_setzero_si128();
+ // const __m128i mask = _mm_set_epi16(0, 0, 0, 0, 0, 0, 0, 0);
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP4_128_pack(0); items += 1 * 4;
+ // SWAP4_128_pack(0); SWAP4_128_pack(1); items += 2 * 4;
+ }
+ while (items != lim);
+}
+
+// sse2
+#define SWAP4_128_shift(i) { \
+ __m128i v = *(const __m128i *)(const void *)(items + (i) * 4); \
+ __m128i v2; \
+ v2 = _mm_or_si128( \
+ _mm_slli_si128(_mm_and_si128(v, mask), 1), \
+ _mm_and_si128(_mm_srli_si128(v, 1), mask)); \
+ v = _mm_or_si128( \
+ _mm_slli_epi32(v, 24), \
+ _mm_srli_epi32(v, 24)); \
+ *(__m128i *)(void *)(items + (i) * 4) = _mm_or_si128(v2, v); }
+
+static
+#ifdef SWAP_ATTRIB_SSE2
+SWAP_ATTRIB_SSE2
+#endif
+void
+Z7_FASTCALL
+SwapBytes4_128_shift(CSwapUInt32 *items, const CSwapUInt32 *lim)
+{
+ #define M1 0xff00
+ const __m128i mask = _mm_set_epi32(M1, M1, M1, M1);
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ // SWAP4_128_shift(0) SWAP4_128_shift(1) items += 2 * 4;
+ // SWAP4_128_shift(0) SWAP4_128_shift(1) items += 2 * 4;
+ SWAP4_128_shift(0); items += 1 * 4;
+ }
+ while (items != lim);
+}
+*/
+
+
+#if defined(USE_SWAP_SSSE3) || defined(USE_SWAP_AVX2)
+
+#define SWAP_SHUF_REV_SEQ_2_VALS(v) (v)+1, (v)
+#define SWAP_SHUF_REV_SEQ_4_VALS(v) (v)+3, (v)+2, (v)+1, (v)
+
+#define SWAP2_SHUF_MASK_16_BYTES \
+ SWAP_SHUF_REV_SEQ_2_VALS (0 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (1 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (2 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (3 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (4 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (5 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (6 * 2), \
+ SWAP_SHUF_REV_SEQ_2_VALS (7 * 2)
+
+#define SWAP4_SHUF_MASK_16_BYTES \
+ SWAP_SHUF_REV_SEQ_4_VALS (0 * 4), \
+ SWAP_SHUF_REV_SEQ_4_VALS (1 * 4), \
+ SWAP_SHUF_REV_SEQ_4_VALS (2 * 4), \
+ SWAP_SHUF_REV_SEQ_4_VALS (3 * 4)
+
+#if defined(USE_SWAP_AVX2)
+/* if we use 256_BIT_INIT_MASK, each static array mask will be larger for 16 bytes */
+// #define SWAP_USE_256_BIT_INIT_MASK
+#endif
+
+#if defined(SWAP_USE_256_BIT_INIT_MASK) && defined(USE_SWAP_AVX2)
+#define SWAP_MASK_INIT_SIZE 32
+#else
+#define SWAP_MASK_INIT_SIZE 16
+#endif
+
+MY_ALIGN(SWAP_MASK_INIT_SIZE)
+static const Byte k_ShufMask_Swap2[] =
+{
+ SWAP2_SHUF_MASK_16_BYTES
+ #if SWAP_MASK_INIT_SIZE > 16
+ , SWAP2_SHUF_MASK_16_BYTES
+ #endif
+};
+
+MY_ALIGN(SWAP_MASK_INIT_SIZE)
+static const Byte k_ShufMask_Swap4[] =
+{
+ SWAP4_SHUF_MASK_16_BYTES
+ #if SWAP_MASK_INIT_SIZE > 16
+ , SWAP4_SHUF_MASK_16_BYTES
+ #endif
+};
+
+
+#ifdef USE_SWAP_SSSE3
+
+#include <tmmintrin.h> // ssse3
+
+#define SHUF_128(i) *(items + (i)) = \
+ _mm_shuffle_epi8(*(items + (i)), mask); // SSSE3
+
+// Z7_NO_INLINE
+static
+#ifdef SWAP_ATTRIB_SSSE3
+SWAP_ATTRIB_SSSE3
+#endif
+Z7_ATTRIB_NO_VECTORIZE
+void
+Z7_FASTCALL
+ShufBytes_128(void *items8, const void *lim8, const void *mask128_ptr)
+{
+ __m128i *items = (__m128i *)items8;
+ const __m128i *lim = (const __m128i *)lim8;
+ // const __m128i mask = _mm_set_epi8(SHUF_SWAP2_MASK_16_VALS);
+ // const __m128i mask = _mm_set_epi8(SHUF_SWAP4_MASK_16_VALS);
+ // const __m128i mask = _mm_load_si128((const __m128i *)(const void *)&(k_ShufMask_Swap4[0]));
+ // const __m128i mask = _mm_load_si128((const __m128i *)(const void *)&(k_ShufMask_Swap4[0]));
+ // const __m128i mask = *(const __m128i *)(const void *)&(k_ShufMask_Swap4[0]);
+ const __m128i mask = *(const __m128i *)mask128_ptr;
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SHUF_128(0) SHUF_128(1) items += 2;
+ SHUF_128(0) SHUF_128(1) items += 2;
+ }
+ while (items != lim);
+}
+
+#endif // USE_SWAP_SSSE3
+
+
+
+#ifdef USE_SWAP_AVX2
+
+#include <immintrin.h> // avx, avx2
+#if defined(__clang__)
+#include <avxintrin.h>
+#include <avx2intrin.h>
+#endif
+
+#define SHUF_256(i) *(items + (i)) = \
+ _mm256_shuffle_epi8(*(items + (i)), mask); // AVX2
+
+// Z7_NO_INLINE
+static
+#ifdef SWAP_ATTRIB_AVX2
+SWAP_ATTRIB_AVX2
+#endif
+Z7_ATTRIB_NO_VECTORIZE
+void
+Z7_FASTCALL
+ShufBytes_256(void *items8, const void *lim8, const void *mask128_ptr)
+{
+ __m256i *items = (__m256i *)items8;
+ const __m256i *lim = (const __m256i *)lim8;
+ /*
+ UNUSED_VAR(mask128_ptr)
+ __m256i mask =
+ for Swap4: _mm256_setr_epi8(SWAP4_SHUF_MASK_16_BYTES, SWAP4_SHUF_MASK_16_BYTES);
+ for Swap2: _mm256_setr_epi8(SWAP2_SHUF_MASK_16_BYTES, SWAP2_SHUF_MASK_16_BYTES);
+ */
+ const __m256i mask =
+ #if SWAP_MASK_INIT_SIZE > 16
+ *(const __m256i *)(const void *)mask128_ptr;
+ #else
+ /* msvc: broadcastsi128() version reserves the stack for no reason
+ msvc 19.29-: _mm256_insertf128_si256() / _mm256_set_m128i)) versions use non-avx movdqu xmm0,XMMWORD PTR [r8]
+ msvc 19.30+ (VS2022): replaces _mm256_set_m128i(m,m) to vbroadcastf128(m) as we want
+ */
+ // _mm256_broadcastsi128_si256(*mask128_ptr);
+ /*
+ #define MY_mm256_set_m128i(hi, lo) _mm256_insertf128_si256(_mm256_castsi128_si256(lo), (hi), 1)
+ MY_mm256_set_m128i
+ */
+ _mm256_set_m128i(
+ *(const __m128i *)mask128_ptr,
+ *(const __m128i *)mask128_ptr);
+ #endif
+
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SHUF_256(0) SHUF_256(1) items += 2;
+ SHUF_256(0) SHUF_256(1) items += 2;
+ }
+ while (items != lim);
+}
+
+#endif // USE_SWAP_AVX2
+#endif // USE_SWAP_SSSE3 || USE_SWAP_AVX2
+#endif // USE_SWAP_128
+
+
+
+// compile message "NEON intrinsics not available with the soft-float ABI"
+#elif defined(MY_CPU_ARM_OR_ARM64) || \
+ (defined(__ARM_ARCH) && (__ARM_ARCH >= 7))
+// #elif defined(MY_CPU_ARM64)
+
+ #if defined(__clang__) && (__clang_major__ >= 8) \
+ || defined(__GNUC__) && (__GNUC__ >= 8)
+ #if (defined(__ARM_ARCH) && (__ARM_ARCH >= 7)) \
+ || defined(MY_CPU_ARM64)
+ #define USE_SWAP_128
+ #endif
+ #ifdef MY_CPU_ARM64
+ // #define SWAP_ATTRIB_NEON __attribute__((__target__("")))
+ #else
+ // #define SWAP_ATTRIB_NEON __attribute__((__target__("fpu=crypto-neon-fp-armv8")))
+ #endif
+ #elif defined(_MSC_VER)
+ #if (_MSC_VER >= 1910)
+ #define USE_SWAP_128
+ #endif
+ #endif
+
+ #if defined(_MSC_VER) && defined(MY_CPU_ARM64)
+ #include <arm64_neon.h>
+ #else
+ #include <arm_neon.h>
+ #endif
+
+#ifndef USE_SWAP_128
+ #define FORCE_SWAP_MODE
+#else
+
+#ifdef MY_CPU_ARM64
+ // for debug : comment it
+ #define FORCE_SWAP_MODE
+#else
+ #define k_SwapBytes_Mode_NEON 1
+#endif
+// typedef uint8x16_t v128;
+#define SWAP2_128(i) *(uint8x16_t *) (void *)(items + (i) * 8) = \
+ vrev16q_u8(*(const uint8x16_t *)(const void *)(items + (i) * 8));
+#define SWAP4_128(i) *(uint8x16_t *) (void *)(items + (i) * 4) = \
+ vrev32q_u8(*(const uint8x16_t *)(const void *)(items + (i) * 4));
+
+// Z7_NO_INLINE
+static
+#ifdef SWAP_ATTRIB_NEON
+SWAP_ATTRIB_NEON
+#endif
+Z7_ATTRIB_NO_VECTORIZE
+void
+Z7_FASTCALL
+SwapBytes2_128(CSwapUInt16 *items, const CSwapUInt16 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP2_128(0) SWAP2_128(1) items += 2 * 8;
+ SWAP2_128(0) SWAP2_128(1) items += 2 * 8;
+ }
+ while (items != lim);
+}
+
+// Z7_NO_INLINE
+static
+#ifdef SWAP_ATTRIB_NEON
+SWAP_ATTRIB_NEON
+#endif
+Z7_ATTRIB_NO_VECTORIZE
+void
+Z7_FASTCALL
+SwapBytes4_128(CSwapUInt32 *items, const CSwapUInt32 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP4_128(0) SWAP4_128(1) items += 2 * 4;
+ SWAP4_128(0) SWAP4_128(1) items += 2 * 4;
+ }
+ while (items != lim);
+}
+
+#endif // USE_SWAP_128
+
+#else // MY_CPU_ARM_OR_ARM64
+#define FORCE_SWAP_MODE
+#endif // MY_CPU_ARM_OR_ARM64
+
+
+
+
+
+
+#if defined(Z7_MSC_VER_ORIGINAL) && defined(MY_CPU_X86)
+ /* _byteswap_ushort() in MSVC x86 32-bit works via slow { mov dh, al; mov dl, ah }
+ So we use own versions of byteswap function */
+ #if (_MSC_VER < 1400 ) // old MSVC-X86 without _rotr16() support
+ #define SWAP2_16(i) { UInt32 v = items[i]; v += (v << 16); v >>= 8; items[i] = (CSwapUInt16)v; }
+ #else // is new MSVC-X86 with fast _rotr16()
+ #include <intrin.h>
+ #define SWAP2_16(i) { items[i] = _rotr16(items[i], 8); }
+ #endif
+#else // is not MSVC-X86
+ #define SWAP2_16(i) { CSwapUInt16 v = items[i]; items[i] = Z7_BSWAP16(v); }
+#endif // MSVC-X86
+
+#if defined(Z7_CPU_FAST_BSWAP_SUPPORTED)
+ #define SWAP4_32(i) { CSwapUInt32 v = items[i]; items[i] = Z7_BSWAP32(v); }
+#else
+ #define SWAP4_32(i) \
+ { UInt32 v = items[i]; \
+ v = ((v & 0xff00ff) << 8) + ((v >> 8) & 0xff00ff); \
+ v = rotlFixed(v, 16); \
+ items[i] = v; }
+#endif
+
+
+
+
+#if defined(FORCE_SWAP_MODE) && defined(USE_SWAP_128)
+ #define DEFAULT_Swap2 SwapBytes2_128
+ #if !defined(MY_CPU_X86_OR_AMD64)
+ #define DEFAULT_Swap4 SwapBytes4_128
+ #endif
+#endif
+
+#if !defined(DEFAULT_Swap2) || !defined(DEFAULT_Swap4)
+
+#define SWAP_BASE_FUNCS_PREFIXES \
+Z7_FORCE_INLINE \
+static \
+Z7_ATTRIB_NO_VECTOR \
+void Z7_FASTCALL
+
+
+#ifdef MY_CPU_64BIT
+
+#if defined(MY_CPU_ARM64) \
+ && defined(__ARM_ARCH) && (__ARM_ARCH >= 8) \
+ && ( (defined(__GNUC__) && (__GNUC__ >= 4)) \
+ || (defined(__clang__) && (__clang_major__ >= 4)))
+
+ #define SWAP2_64_VAR(v) asm ("rev16 %x0,%x0" : "+r" (v));
+ #define SWAP4_64_VAR(v) asm ("rev32 %x0,%x0" : "+r" (v));
+
+#else // is not ARM64-GNU
+
+#if !defined(MY_CPU_X86_OR_AMD64) || (k_SwapBytes_Mode_MIN == 0) || !defined(USE_SWAP_128)
+ #define SWAP2_64_VAR(v) \
+ v = ( 0x00ff00ff00ff00ff & (v >> 8)) \
+ + ((0x00ff00ff00ff00ff & v) << 8);
+ /* plus gives faster code in MSVC */
+#endif
+
+#ifdef Z7_CPU_FAST_BSWAP_SUPPORTED
+ #define SWAP4_64_VAR(v) \
+ v = Z7_BSWAP64(v); \
+ v = Z7_ROTL64(v, 32);
+#else
+ #define SWAP4_64_VAR(v) \
+ v = ( 0x000000ff000000ff & (v >> 24)) \
+ + ((0x000000ff000000ff & v) << 24 ) \
+ + ( 0x0000ff000000ff00 & (v >> 8)) \
+ + ((0x0000ff000000ff00 & v) << 8 ) \
+ ;
+#endif
+
+#endif // ARM64-GNU
+
+
+#ifdef SWAP2_64_VAR
+
+#define SWAP2_64(i) { \
+ UInt64 v = *(const UInt64 *)(const void *)(items + (i) * 4); \
+ SWAP2_64_VAR(v) \
+ *(UInt64 *)(void *)(items + (i) * 4) = v; }
+
+SWAP_BASE_FUNCS_PREFIXES
+SwapBytes2_64(CSwapUInt16 *items, const CSwapUInt16 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP2_64(0) SWAP2_64(1) items += 2 * 4;
+ SWAP2_64(0) SWAP2_64(1) items += 2 * 4;
+ }
+ while (items != lim);
+}
+
+ #define DEFAULT_Swap2 SwapBytes2_64
+ #if !defined(FORCE_SWAP_MODE)
+ #define SWAP2_DEFAULT_MODE 0
+ #endif
+#else // !defined(SWAP2_64_VAR)
+ #define DEFAULT_Swap2 SwapBytes2_128
+ #if !defined(FORCE_SWAP_MODE)
+ #define SWAP2_DEFAULT_MODE 1
+ #endif
+#endif // SWAP2_64_VAR
+
+
+#define SWAP4_64(i) { \
+ UInt64 v = *(const UInt64 *)(const void *)(items + (i) * 2); \
+ SWAP4_64_VAR(v) \
+ *(UInt64 *)(void *)(items + (i) * 2) = v; }
+
+SWAP_BASE_FUNCS_PREFIXES
+SwapBytes4_64(CSwapUInt32 *items, const CSwapUInt32 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP4_64(0) SWAP4_64(1) items += 2 * 2;
+ SWAP4_64(0) SWAP4_64(1) items += 2 * 2;
+ }
+ while (items != lim);
+}
+
+#define DEFAULT_Swap4 SwapBytes4_64
+
+#else // is not 64BIT
+
+
+#if defined(MY_CPU_ARM_OR_ARM64) \
+ && defined(__ARM_ARCH) && (__ARM_ARCH >= 6) \
+ && ( (defined(__GNUC__) && (__GNUC__ >= 4)) \
+ || (defined(__clang__) && (__clang_major__ >= 4)))
+
+#ifdef MY_CPU_64BIT
+ #define SWAP2_32_VAR(v) asm ("rev16 %w0,%w0" : "+r" (v));
+#else
+ #define SWAP2_32_VAR(v) asm ("rev16 %0,%0" : "+r" (v)); // for clang/gcc
+ // asm ("rev16 %r0,%r0" : "+r" (a)); // for gcc
+#endif
+
+#elif defined(_MSC_VER) && (_MSC_VER < 1300) && defined(MY_CPU_X86) \
+ || !defined(Z7_CPU_FAST_BSWAP_SUPPORTED) \
+ || !defined(Z7_CPU_FAST_ROTATE_SUPPORTED)
+ // old msvc doesn't support _byteswap_ulong()
+ #define SWAP2_32_VAR(v) \
+ v = ((v & 0xff00ff) << 8) + ((v >> 8) & 0xff00ff);
+
+#else // is not ARM and is not old-MSVC-X86 and fast BSWAP/ROTATE are supported
+ #define SWAP2_32_VAR(v) \
+ v = Z7_BSWAP32(v); \
+ v = rotlFixed(v, 16);
+
+#endif // GNU-ARM*
+
+#define SWAP2_32(i) { \
+ UInt32 v = *(const UInt32 *)(const void *)(items + (i) * 2); \
+ SWAP2_32_VAR(v); \
+ *(UInt32 *)(void *)(items + (i) * 2) = v; }
+
+
+SWAP_BASE_FUNCS_PREFIXES
+SwapBytes2_32(CSwapUInt16 *items, const CSwapUInt16 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP2_32(0) SWAP2_32(1) items += 2 * 2;
+ SWAP2_32(0) SWAP2_32(1) items += 2 * 2;
+ }
+ while (items != lim);
+}
+
+
+SWAP_BASE_FUNCS_PREFIXES
+SwapBytes4_32(CSwapUInt32 *items, const CSwapUInt32 *lim)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ do
+ {
+ SWAP4_32(0) SWAP4_32(1) items += 2;
+ SWAP4_32(0) SWAP4_32(1) items += 2;
+ }
+ while (items != lim);
+}
+
+#define DEFAULT_Swap2 SwapBytes2_32
+#define DEFAULT_Swap4 SwapBytes4_32
+#if !defined(FORCE_SWAP_MODE)
+ #define SWAP2_DEFAULT_MODE 0
+#endif
+
+#endif // MY_CPU_64BIT
+#endif // if !defined(DEFAULT_Swap2) || !defined(DEFAULT_Swap4)
+
+
+
+#if !defined(FORCE_SWAP_MODE)
+static unsigned g_SwapBytes_Mode;
+#endif
+
+/* size of largest unrolled loop iteration: 128 bytes = 4 * 32 bytes (AVX). */
+#define SWAP_ITERATION_BLOCK_SIZE_MAX (1 << 7)
+
+// 32 bytes for (AVX) or 2 * 16-bytes for NEON.
+#define SWAP_VECTOR_ALIGN_SIZE (1 << 5)
+
+Z7_NO_INLINE
+void z7_SwapBytes2(CSwapUInt16 *items, size_t numItems)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ for (; numItems != 0 && ((unsigned)(ptrdiff_t)items & (SWAP_VECTOR_ALIGN_SIZE - 1)) != 0; numItems--)
+ {
+ SWAP2_16(0)
+ items++;
+ }
+ {
+ const size_t k_Align_Mask = SWAP_ITERATION_BLOCK_SIZE_MAX / sizeof(CSwapUInt16) - 1;
+ size_t numItems2 = numItems;
+ CSwapUInt16 *lim;
+ numItems &= k_Align_Mask;
+ numItems2 &= ~(size_t)k_Align_Mask;
+ lim = items + numItems2;
+ if (numItems2 != 0)
+ {
+ #if !defined(FORCE_SWAP_MODE)
+ #ifdef MY_CPU_X86_OR_AMD64
+ #ifdef USE_SWAP_AVX2
+ if (g_SwapBytes_Mode > k_SwapBytes_Mode_SSSE3)
+ ShufBytes_256((__m256i *)(void *)items,
+ (const __m256i *)(const void *)lim,
+ (const __m128i *)(const void *)&(k_ShufMask_Swap2[0]));
+ else
+ #endif
+ #ifdef USE_SWAP_SSSE3
+ if (g_SwapBytes_Mode >= k_SwapBytes_Mode_SSSE3)
+ ShufBytes_128((__m128i *)(void *)items,
+ (const __m128i *)(const void *)lim,
+ (const __m128i *)(const void *)&(k_ShufMask_Swap2[0]));
+ else
+ #endif
+ #endif // MY_CPU_X86_OR_AMD64
+ #if SWAP2_DEFAULT_MODE == 0
+ if (g_SwapBytes_Mode != 0)
+ SwapBytes2_128(items, lim);
+ else
+ #endif
+ #endif // FORCE_SWAP_MODE
+ DEFAULT_Swap2(items, lim);
+ }
+ items = lim;
+ }
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ for (; numItems != 0; numItems--)
+ {
+ SWAP2_16(0)
+ items++;
+ }
+}
+
+
+Z7_NO_INLINE
+void z7_SwapBytes4(CSwapUInt32 *items, size_t numItems)
+{
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ for (; numItems != 0 && ((unsigned)(ptrdiff_t)items & (SWAP_VECTOR_ALIGN_SIZE - 1)) != 0; numItems--)
+ {
+ SWAP4_32(0)
+ items++;
+ }
+ {
+ const size_t k_Align_Mask = SWAP_ITERATION_BLOCK_SIZE_MAX / sizeof(CSwapUInt32) - 1;
+ size_t numItems2 = numItems;
+ CSwapUInt32 *lim;
+ numItems &= k_Align_Mask;
+ numItems2 &= ~(size_t)k_Align_Mask;
+ lim = items + numItems2;
+ if (numItems2 != 0)
+ {
+ #if !defined(FORCE_SWAP_MODE)
+ #ifdef MY_CPU_X86_OR_AMD64
+ #ifdef USE_SWAP_AVX2
+ if (g_SwapBytes_Mode > k_SwapBytes_Mode_SSSE3)
+ ShufBytes_256((__m256i *)(void *)items,
+ (const __m256i *)(const void *)lim,
+ (const __m128i *)(const void *)&(k_ShufMask_Swap4[0]));
+ else
+ #endif
+ #ifdef USE_SWAP_SSSE3
+ if (g_SwapBytes_Mode >= k_SwapBytes_Mode_SSSE3)
+ ShufBytes_128((__m128i *)(void *)items,
+ (const __m128i *)(const void *)lim,
+ (const __m128i *)(const void *)&(k_ShufMask_Swap4[0]));
+ else
+ #endif
+ #else // MY_CPU_X86_OR_AMD64
+
+ if (g_SwapBytes_Mode != 0)
+ SwapBytes4_128(items, lim);
+ else
+ #endif // MY_CPU_X86_OR_AMD64
+ #endif // FORCE_SWAP_MODE
+ DEFAULT_Swap4(items, lim);
+ }
+ items = lim;
+ }
+ Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+ for (; numItems != 0; numItems--)
+ {
+ SWAP4_32(0)
+ items++;
+ }
+}
+
+
+// #define SHOW_HW_STATUS
+
+#ifdef SHOW_HW_STATUS
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+void z7_SwapBytesPrepare(void)
+{
+#ifndef FORCE_SWAP_MODE
+ unsigned mode = 0; // k_SwapBytes_Mode_BASE;
+
+#ifdef MY_CPU_ARM_OR_ARM64
+ {
+ if (CPU_IsSupported_NEON())
+ {
+ // #pragma message ("=== SwapBytes NEON")
+ PRF(printf("\n=== SwapBytes NEON\n");)
+ mode = k_SwapBytes_Mode_NEON;
+ }
+ }
+#else // MY_CPU_ARM_OR_ARM64
+ {
+ #ifdef USE_SWAP_AVX2
+ if (CPU_IsSupported_AVX2())
+ {
+ // #pragma message ("=== SwapBytes AVX2")
+ PRF(printf("\n=== SwapBytes AVX2\n");)
+ mode = k_SwapBytes_Mode_AVX2;
+ }
+ else
+ #endif
+ #ifdef USE_SWAP_SSSE3
+ if (CPU_IsSupported_SSSE3())
+ {
+ // #pragma message ("=== SwapBytes SSSE3")
+ PRF(printf("\n=== SwapBytes SSSE3\n");)
+ mode = k_SwapBytes_Mode_SSSE3;
+ }
+ else
+ #endif
+ #if !defined(MY_CPU_AMD64)
+ if (CPU_IsSupported_SSE2())
+ #endif
+ {
+ // #pragma message ("=== SwapBytes SSE2")
+ PRF(printf("\n=== SwapBytes SSE2\n");)
+ mode = k_SwapBytes_Mode_SSE2;
+ }
+ }
+#endif // MY_CPU_ARM_OR_ARM64
+ g_SwapBytes_Mode = mode;
+ // g_SwapBytes_Mode = 0; // for debug
+#endif // FORCE_SWAP_MODE
+ PRF(printf("\n=== SwapBytesPrepare\n");)
+}
+
+#undef PRF
diff --git a/C/SwapBytes.h b/C/SwapBytes.h
new file mode 100644
index 0000000..d442467
--- /dev/null
+++ b/C/SwapBytes.h
@@ -0,0 +1,17 @@
+/* SwapBytes.h -- Byte Swap conversion filter
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_SWAP_BYTES_H
+#define ZIP7_INC_SWAP_BYTES_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+void z7_SwapBytes2(UInt16 *data, size_t numItems);
+void z7_SwapBytes4(UInt32 *data, size_t numItems);
+void z7_SwapBytesPrepare(void);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Threads.c b/C/Threads.c
index 8fd86f2..cf52bd3 100644
--- a/C/Threads.c
+++ b/C/Threads.c
@@ -1,95 +1,562 @@
-/* Threads.c -- multithreading library
-2017-06-26 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#ifndef UNDER_CE
-#include <process.h>
-#endif
-
-#include "Threads.h"
-
-static WRes GetError()
-{
- DWORD res = GetLastError();
- return res ? (WRes)res : 1;
-}
-
-static WRes HandleToWRes(HANDLE h) { return (h != NULL) ? 0 : GetError(); }
-static WRes BOOLToWRes(BOOL v) { return v ? 0 : GetError(); }
-
-WRes HandlePtr_Close(HANDLE *p)
-{
- if (*p != NULL)
- {
- if (!CloseHandle(*p))
- return GetError();
- *p = NULL;
- }
- return 0;
-}
-
-WRes Handle_WaitObject(HANDLE h) { return (WRes)WaitForSingleObject(h, INFINITE); }
-
-WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
-{
- /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
-
- #ifdef UNDER_CE
-
- DWORD threadId;
- *p = CreateThread(0, 0, func, param, 0, &threadId);
-
- #else
-
- unsigned threadId;
- *p = (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId);
-
- #endif
-
- /* maybe we must use errno here, but probably GetLastError() is also OK. */
- return HandleToWRes(*p);
-}
-
-static WRes Event_Create(CEvent *p, BOOL manualReset, int signaled)
-{
- *p = CreateEvent(NULL, manualReset, (signaled ? TRUE : FALSE), NULL);
- return HandleToWRes(*p);
-}
-
-WRes Event_Set(CEvent *p) { return BOOLToWRes(SetEvent(*p)); }
-WRes Event_Reset(CEvent *p) { return BOOLToWRes(ResetEvent(*p)); }
-
-WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled) { return Event_Create(p, TRUE, signaled); }
-WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled) { return Event_Create(p, FALSE, signaled); }
-WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p) { return ManualResetEvent_Create(p, 0); }
-WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p) { return AutoResetEvent_Create(p, 0); }
-
-
-WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount)
-{
- *p = CreateSemaphore(NULL, (LONG)initCount, (LONG)maxCount, NULL);
- return HandleToWRes(*p);
-}
-
-static WRes Semaphore_Release(CSemaphore *p, LONG releaseCount, LONG *previousCount)
- { return BOOLToWRes(ReleaseSemaphore(*p, releaseCount, previousCount)); }
-WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num)
- { return Semaphore_Release(p, (LONG)num, NULL); }
-WRes Semaphore_Release1(CSemaphore *p) { return Semaphore_ReleaseN(p, 1); }
-
-WRes CriticalSection_Init(CCriticalSection *p)
-{
- /* InitializeCriticalSection can raise only STATUS_NO_MEMORY exception */
- #ifdef _MSC_VER
- __try
- #endif
- {
- InitializeCriticalSection(p);
- /* InitializeCriticalSectionAndSpinCount(p, 0); */
- }
- #ifdef _MSC_VER
- __except (EXCEPTION_EXECUTE_HANDLER) { return 1; }
- #endif
- return 0;
-}
+/* Threads.c -- multithreading library
+2023-03-04 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#ifdef _WIN32
+
+#ifndef USE_THREADS_CreateThread
+#include <process.h>
+#endif
+
+#include "Threads.h"
+
+static WRes GetError(void)
+{
+ const DWORD res = GetLastError();
+ return res ? (WRes)res : 1;
+}
+
+static WRes HandleToWRes(HANDLE h) { return (h != NULL) ? 0 : GetError(); }
+static WRes BOOLToWRes(BOOL v) { return v ? 0 : GetError(); }
+
+WRes HandlePtr_Close(HANDLE *p)
+{
+ if (*p != NULL)
+ {
+ if (!CloseHandle(*p))
+ return GetError();
+ *p = NULL;
+ }
+ return 0;
+}
+
+WRes Handle_WaitObject(HANDLE h)
+{
+ DWORD dw = WaitForSingleObject(h, INFINITE);
+ /*
+ (dw) result:
+ WAIT_OBJECT_0 // 0
+ WAIT_ABANDONED // 0x00000080 : is not compatible with Win32 Error space
+ WAIT_TIMEOUT // 0x00000102 : is compatible with Win32 Error space
+ WAIT_FAILED // 0xFFFFFFFF
+ */
+ if (dw == WAIT_FAILED)
+ {
+ dw = GetLastError();
+ if (dw == 0)
+ return WAIT_FAILED;
+ }
+ return (WRes)dw;
+}
+
+#define Thread_Wait(p) Handle_WaitObject(*(p))
+
+WRes Thread_Wait_Close(CThread *p)
+{
+ WRes res = Thread_Wait(p);
+ WRes res2 = Thread_Close(p);
+ return (res != 0 ? res : res2);
+}
+
+WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
+{
+ /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
+
+ #ifdef USE_THREADS_CreateThread
+
+ DWORD threadId;
+ *p = CreateThread(NULL, 0, func, param, 0, &threadId);
+
+ #else
+
+ unsigned threadId;
+ *p = (HANDLE)(_beginthreadex(NULL, 0, func, param, 0, &threadId));
+
+ #endif
+
+ /* maybe we must use errno here, but probably GetLastError() is also OK. */
+ return HandleToWRes(*p);
+}
+
+
+WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, CAffinityMask affinity)
+{
+ #ifdef USE_THREADS_CreateThread
+
+ UNUSED_VAR(affinity)
+ return Thread_Create(p, func, param);
+
+ #else
+
+ /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
+ HANDLE h;
+ WRes wres;
+ unsigned threadId;
+ h = (HANDLE)(_beginthreadex(NULL, 0, func, param, CREATE_SUSPENDED, &threadId));
+ *p = h;
+ wres = HandleToWRes(h);
+ if (h)
+ {
+ {
+ // DWORD_PTR prevMask =
+ SetThreadAffinityMask(h, (DWORD_PTR)affinity);
+ /*
+ if (prevMask == 0)
+ {
+ // affinity change is non-critical error, so we can ignore it
+ // wres = GetError();
+ }
+ */
+ }
+ {
+ DWORD prevSuspendCount = ResumeThread(h);
+ /* ResumeThread() returns:
+ 0 : was_not_suspended
+ 1 : was_resumed
+ -1 : error
+ */
+ if (prevSuspendCount == (DWORD)-1)
+ wres = GetError();
+ }
+ }
+
+ /* maybe we must use errno here, but probably GetLastError() is also OK. */
+ return wres;
+
+ #endif
+}
+
+
+static WRes Event_Create(CEvent *p, BOOL manualReset, int signaled)
+{
+ *p = CreateEvent(NULL, manualReset, (signaled ? TRUE : FALSE), NULL);
+ return HandleToWRes(*p);
+}
+
+WRes Event_Set(CEvent *p) { return BOOLToWRes(SetEvent(*p)); }
+WRes Event_Reset(CEvent *p) { return BOOLToWRes(ResetEvent(*p)); }
+
+WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled) { return Event_Create(p, TRUE, signaled); }
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled) { return Event_Create(p, FALSE, signaled); }
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p) { return ManualResetEvent_Create(p, 0); }
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p) { return AutoResetEvent_Create(p, 0); }
+
+
+WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount)
+{
+ // negative ((LONG)maxCount) is not supported in WIN32::CreateSemaphore()
+ *p = CreateSemaphore(NULL, (LONG)initCount, (LONG)maxCount, NULL);
+ return HandleToWRes(*p);
+}
+
+WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount)
+{
+ // if (Semaphore_IsCreated(p))
+ {
+ WRes wres = Semaphore_Close(p);
+ if (wres != 0)
+ return wres;
+ }
+ return Semaphore_Create(p, initCount, maxCount);
+}
+
+static WRes Semaphore_Release(CSemaphore *p, LONG releaseCount, LONG *previousCount)
+ { return BOOLToWRes(ReleaseSemaphore(*p, releaseCount, previousCount)); }
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num)
+ { return Semaphore_Release(p, (LONG)num, NULL); }
+WRes Semaphore_Release1(CSemaphore *p) { return Semaphore_ReleaseN(p, 1); }
+
+WRes CriticalSection_Init(CCriticalSection *p)
+{
+ /* InitializeCriticalSection() can raise exception:
+ Windows XP, 2003 : can raise a STATUS_NO_MEMORY exception
+ Windows Vista+ : no exceptions */
+ #ifdef _MSC_VER
+ #ifdef __clang__
+ #pragma GCC diagnostic ignored "-Wlanguage-extension-token"
+ #endif
+ __try
+ #endif
+ {
+ InitializeCriticalSection(p);
+ /* InitializeCriticalSectionAndSpinCount(p, 0); */
+ }
+ #ifdef _MSC_VER
+ __except (EXCEPTION_EXECUTE_HANDLER) { return ERROR_NOT_ENOUGH_MEMORY; }
+ #endif
+ return 0;
+}
+
+
+
+
+#else // _WIN32
+
+// ---------- POSIX ----------
+
+#ifndef __APPLE__
+#ifndef Z7_AFFINITY_DISABLE
+// _GNU_SOURCE can be required for pthread_setaffinity_np() / CPU_ZERO / CPU_SET
+// clang < 3.6 : unknown warning group '-Wreserved-id-macro'
+// clang 3.6 - 12.01 : gives warning "macro name is a reserved identifier"
+// clang >= 13 : do not give warning
+#if !defined(_GNU_SOURCE)
+ #if defined(__clang__) && (__clang_major__ >= 4) && (__clang_major__ <= 12)
+ #pragma GCC diagnostic ignored "-Wreserved-id-macro"
+ #endif
+#define _GNU_SOURCE
+#endif // !defined(_GNU_SOURCE)
+#endif // Z7_AFFINITY_DISABLE
+#endif // __APPLE__
+
+#include "Threads.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef Z7_AFFINITY_SUPPORTED
+// #include <sched.h>
+#endif
+
+
+// #include <stdio.h>
+// #define PRF(p) p
+#define PRF(p)
+#define Print(s) PRF(printf("\n%s\n", s);)
+
+WRes Thread_Create_With_CpuSet(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, const CCpuSet *cpuSet)
+{
+ // new thread in Posix probably inherits affinity from parrent thread
+ Print("Thread_Create_With_CpuSet")
+
+ pthread_attr_t attr;
+ int ret;
+ // int ret2;
+
+ p->_created = 0;
+
+ RINOK(pthread_attr_init(&attr))
+
+ ret = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+ if (!ret)
+ {
+ if (cpuSet)
+ {
+ #ifdef Z7_AFFINITY_SUPPORTED
+
+ /*
+ printf("\n affinity :");
+ unsigned i;
+ for (i = 0; i < sizeof(*cpuSet) && i < 8; i++)
+ {
+ Byte b = *((const Byte *)cpuSet + i);
+ char temp[32];
+ #define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
+ temp[0] = GET_HEX_CHAR((b & 0xF));
+ temp[1] = GET_HEX_CHAR((b >> 4));
+ // temp[0] = GET_HEX_CHAR((b >> 4)); // big-endian
+ // temp[1] = GET_HEX_CHAR((b & 0xF)); // big-endian
+ temp[2] = 0;
+ printf("%s", temp);
+ }
+ printf("\n");
+ */
+
+ // ret2 =
+ pthread_attr_setaffinity_np(&attr, sizeof(*cpuSet), cpuSet);
+ // if (ret2) ret = ret2;
+ #endif
+ }
+
+ ret = pthread_create(&p->_tid, &attr, func, param);
+
+ if (!ret)
+ {
+ p->_created = 1;
+ /*
+ if (cpuSet)
+ {
+ // ret2 =
+ pthread_setaffinity_np(p->_tid, sizeof(*cpuSet), cpuSet);
+ // if (ret2) ret = ret2;
+ }
+ */
+ }
+ }
+ // ret2 =
+ pthread_attr_destroy(&attr);
+ // if (ret2 != 0) ret = ret2;
+ return ret;
+}
+
+
+WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)
+{
+ return Thread_Create_With_CpuSet(p, func, param, NULL);
+}
+
+
+WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, CAffinityMask affinity)
+{
+ Print("Thread_Create_WithAffinity")
+ CCpuSet cs;
+ unsigned i;
+ CpuSet_Zero(&cs);
+ for (i = 0; i < sizeof(affinity) * 8; i++)
+ {
+ if (affinity == 0)
+ break;
+ if (affinity & 1)
+ {
+ CpuSet_Set(&cs, i);
+ }
+ affinity >>= 1;
+ }
+ return Thread_Create_With_CpuSet(p, func, param, &cs);
+}
+
+
+WRes Thread_Close(CThread *p)
+{
+ // Print("Thread_Close")
+ int ret;
+ if (!p->_created)
+ return 0;
+
+ ret = pthread_detach(p->_tid);
+ p->_tid = 0;
+ p->_created = 0;
+ return ret;
+}
+
+
+WRes Thread_Wait_Close(CThread *p)
+{
+ // Print("Thread_Wait_Close")
+ void *thread_return;
+ int ret;
+ if (!p->_created)
+ return EINVAL;
+
+ ret = pthread_join(p->_tid, &thread_return);
+ // probably we can't use that (_tid) after pthread_join(), so we close thread here
+ p->_created = 0;
+ p->_tid = 0;
+ return ret;
+}
+
+
+
+static WRes Event_Create(CEvent *p, int manualReset, int signaled)
+{
+ RINOK(pthread_mutex_init(&p->_mutex, NULL))
+ RINOK(pthread_cond_init(&p->_cond, NULL))
+ p->_manual_reset = manualReset;
+ p->_state = (signaled ? True : False);
+ p->_created = 1;
+ return 0;
+}
+
+WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled)
+ { return Event_Create(p, True, signaled); }
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p)
+ { return ManualResetEvent_Create(p, 0); }
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled)
+ { return Event_Create(p, False, signaled); }
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p)
+ { return AutoResetEvent_Create(p, 0); }
+
+
+WRes Event_Set(CEvent *p)
+{
+ RINOK(pthread_mutex_lock(&p->_mutex))
+ p->_state = True;
+ int res1 = pthread_cond_broadcast(&p->_cond);
+ int res2 = pthread_mutex_unlock(&p->_mutex);
+ return (res2 ? res2 : res1);
+}
+
+WRes Event_Reset(CEvent *p)
+{
+ RINOK(pthread_mutex_lock(&p->_mutex))
+ p->_state = False;
+ return pthread_mutex_unlock(&p->_mutex);
+}
+
+WRes Event_Wait(CEvent *p)
+{
+ RINOK(pthread_mutex_lock(&p->_mutex))
+ while (p->_state == False)
+ {
+ // ETIMEDOUT
+ // ret =
+ pthread_cond_wait(&p->_cond, &p->_mutex);
+ // if (ret != 0) break;
+ }
+ if (p->_manual_reset == False)
+ {
+ p->_state = False;
+ }
+ return pthread_mutex_unlock(&p->_mutex);
+}
+
+WRes Event_Close(CEvent *p)
+{
+ if (!p->_created)
+ return 0;
+ p->_created = 0;
+ {
+ int res1 = pthread_mutex_destroy(&p->_mutex);
+ int res2 = pthread_cond_destroy(&p->_cond);
+ return (res1 ? res1 : res2);
+ }
+}
+
+
+WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount)
+{
+ if (initCount > maxCount || maxCount < 1)
+ return EINVAL;
+ RINOK(pthread_mutex_init(&p->_mutex, NULL))
+ RINOK(pthread_cond_init(&p->_cond, NULL))
+ p->_count = initCount;
+ p->_maxCount = maxCount;
+ p->_created = 1;
+ return 0;
+}
+
+
+WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount)
+{
+ if (Semaphore_IsCreated(p))
+ {
+ /*
+ WRes wres = Semaphore_Close(p);
+ if (wres != 0)
+ return wres;
+ */
+ if (initCount > maxCount || maxCount < 1)
+ return EINVAL;
+ // return EINVAL; // for debug
+ p->_count = initCount;
+ p->_maxCount = maxCount;
+ return 0;
+ }
+ return Semaphore_Create(p, initCount, maxCount);
+}
+
+
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 releaseCount)
+{
+ UInt32 newCount;
+ int ret;
+
+ if (releaseCount < 1)
+ return EINVAL;
+
+ RINOK(pthread_mutex_lock(&p->_mutex))
+
+ newCount = p->_count + releaseCount;
+ if (newCount > p->_maxCount)
+ ret = ERROR_TOO_MANY_POSTS; // EINVAL;
+ else
+ {
+ p->_count = newCount;
+ ret = pthread_cond_broadcast(&p->_cond);
+ }
+ RINOK(pthread_mutex_unlock(&p->_mutex))
+ return ret;
+}
+
+WRes Semaphore_Wait(CSemaphore *p)
+{
+ RINOK(pthread_mutex_lock(&p->_mutex))
+ while (p->_count < 1)
+ {
+ pthread_cond_wait(&p->_cond, &p->_mutex);
+ }
+ p->_count--;
+ return pthread_mutex_unlock(&p->_mutex);
+}
+
+WRes Semaphore_Close(CSemaphore *p)
+{
+ if (!p->_created)
+ return 0;
+ p->_created = 0;
+ {
+ int res1 = pthread_mutex_destroy(&p->_mutex);
+ int res2 = pthread_cond_destroy(&p->_cond);
+ return (res1 ? res1 : res2);
+ }
+}
+
+
+
+WRes CriticalSection_Init(CCriticalSection *p)
+{
+ // Print("CriticalSection_Init")
+ if (!p)
+ return EINTR;
+ return pthread_mutex_init(&p->_mutex, NULL);
+}
+
+void CriticalSection_Enter(CCriticalSection *p)
+{
+ // Print("CriticalSection_Enter")
+ if (p)
+ {
+ // int ret =
+ pthread_mutex_lock(&p->_mutex);
+ }
+}
+
+void CriticalSection_Leave(CCriticalSection *p)
+{
+ // Print("CriticalSection_Leave")
+ if (p)
+ {
+ // int ret =
+ pthread_mutex_unlock(&p->_mutex);
+ }
+}
+
+void CriticalSection_Delete(CCriticalSection *p)
+{
+ // Print("CriticalSection_Delete")
+ if (p)
+ {
+ // int ret =
+ pthread_mutex_destroy(&p->_mutex);
+ }
+}
+
+LONG InterlockedIncrement(LONG volatile *addend)
+{
+ // Print("InterlockedIncrement")
+ #ifdef USE_HACK_UNSAFE_ATOMIC
+ LONG val = *addend + 1;
+ *addend = val;
+ return val;
+ #else
+
+ #if defined(__clang__) && (__clang_major__ >= 8)
+ #pragma GCC diagnostic ignored "-Watomic-implicit-seq-cst"
+ #endif
+ return __sync_add_and_fetch(addend, 1);
+ #endif
+}
+
+#endif // _WIN32
+
+WRes AutoResetEvent_OptCreate_And_Reset(CAutoResetEvent *p)
+{
+ if (Event_IsCreated(p))
+ return Event_Reset(p);
+ return AutoResetEvent_CreateNotSignaled(p);
+}
+
+#undef PRF
+#undef Print
diff --git a/C/Threads.h b/C/Threads.h
index f913241..4028464 100644
--- a/C/Threads.h
+++ b/C/Threads.h
@@ -1,68 +1,240 @@
-/* Threads.h -- multithreading library
-2017-06-18 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_THREADS_H
-#define __7Z_THREADS_H
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-WRes HandlePtr_Close(HANDLE *h);
-WRes Handle_WaitObject(HANDLE h);
-
-typedef HANDLE CThread;
-#define Thread_Construct(p) *(p) = NULL
-#define Thread_WasCreated(p) (*(p) != NULL)
-#define Thread_Close(p) HandlePtr_Close(p)
-#define Thread_Wait(p) Handle_WaitObject(*(p))
-
-typedef
-#ifdef UNDER_CE
- DWORD
-#else
- unsigned
-#endif
- THREAD_FUNC_RET_TYPE;
-
-#define THREAD_FUNC_CALL_TYPE MY_STD_CALL
-#define THREAD_FUNC_DECL THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
-typedef THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE * THREAD_FUNC_TYPE)(void *);
-WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param);
-
-typedef HANDLE CEvent;
-typedef CEvent CAutoResetEvent;
-typedef CEvent CManualResetEvent;
-#define Event_Construct(p) *(p) = NULL
-#define Event_IsCreated(p) (*(p) != NULL)
-#define Event_Close(p) HandlePtr_Close(p)
-#define Event_Wait(p) Handle_WaitObject(*(p))
-WRes Event_Set(CEvent *p);
-WRes Event_Reset(CEvent *p);
-WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled);
-WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p);
-WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled);
-WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p);
-
-typedef HANDLE CSemaphore;
-#define Semaphore_Construct(p) *(p) = NULL
-#define Semaphore_IsCreated(p) (*(p) != NULL)
-#define Semaphore_Close(p) HandlePtr_Close(p)
-#define Semaphore_Wait(p) Handle_WaitObject(*(p))
-WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
-WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num);
-WRes Semaphore_Release1(CSemaphore *p);
-
-typedef CRITICAL_SECTION CCriticalSection;
-WRes CriticalSection_Init(CCriticalSection *p);
-#define CriticalSection_Delete(p) DeleteCriticalSection(p)
-#define CriticalSection_Enter(p) EnterCriticalSection(p)
-#define CriticalSection_Leave(p) LeaveCriticalSection(p)
-
-EXTERN_C_END
-
-#endif
+/* Threads.h -- multithreading library
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_THREADS_H
+#define ZIP7_INC_THREADS_H
+
+#ifdef _WIN32
+#include "7zWindows.h"
+
+#else
+
+#if defined(__linux__)
+#if !defined(__APPLE__) && !defined(_AIX) && !defined(__ANDROID__)
+#ifndef Z7_AFFINITY_DISABLE
+#define Z7_AFFINITY_SUPPORTED
+// #pragma message(" ==== Z7_AFFINITY_SUPPORTED")
+// #define _GNU_SOURCE
+#endif
+#endif
+#endif
+
+#include <pthread.h>
+
+#endif
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#ifdef _WIN32
+
+WRes HandlePtr_Close(HANDLE *h);
+WRes Handle_WaitObject(HANDLE h);
+
+typedef HANDLE CThread;
+
+#define Thread_CONSTRUCT(p) { *(p) = NULL; }
+#define Thread_WasCreated(p) (*(p) != NULL)
+#define Thread_Close(p) HandlePtr_Close(p)
+// #define Thread_Wait(p) Handle_WaitObject(*(p))
+
+#ifdef UNDER_CE
+ // if (USE_THREADS_CreateThread is defined), we use _beginthreadex()
+ // if (USE_THREADS_CreateThread is not definned), we use CreateThread()
+ #define USE_THREADS_CreateThread
+#endif
+
+typedef
+ #ifdef USE_THREADS_CreateThread
+ DWORD
+ #else
+ unsigned
+ #endif
+ THREAD_FUNC_RET_TYPE;
+
+#define THREAD_FUNC_RET_ZERO 0
+
+typedef DWORD_PTR CAffinityMask;
+typedef DWORD_PTR CCpuSet;
+
+#define CpuSet_Zero(p) *(p) = (0)
+#define CpuSet_Set(p, cpu) *(p) |= ((DWORD_PTR)1 << (cpu))
+
+#else // _WIN32
+
+typedef struct
+{
+ pthread_t _tid;
+ int _created;
+} CThread;
+
+#define Thread_CONSTRUCT(p) { (p)->_tid = 0; (p)->_created = 0; }
+#define Thread_WasCreated(p) ((p)->_created != 0)
+WRes Thread_Close(CThread *p);
+// #define Thread_Wait Thread_Wait_Close
+
+typedef void * THREAD_FUNC_RET_TYPE;
+#define THREAD_FUNC_RET_ZERO NULL
+
+
+typedef UInt64 CAffinityMask;
+
+#ifdef Z7_AFFINITY_SUPPORTED
+
+typedef cpu_set_t CCpuSet;
+#define CpuSet_Zero(p) CPU_ZERO(p)
+#define CpuSet_Set(p, cpu) CPU_SET(cpu, p)
+#define CpuSet_IsSet(p, cpu) CPU_ISSET(cpu, p)
+
+#else
+
+typedef UInt64 CCpuSet;
+#define CpuSet_Zero(p) *(p) = (0)
+#define CpuSet_Set(p, cpu) *(p) |= ((UInt64)1 << (cpu))
+#define CpuSet_IsSet(p, cpu) ((*(p) & ((UInt64)1 << (cpu))) != 0)
+
+#endif
+
+
+#endif // _WIN32
+
+
+#define THREAD_FUNC_CALL_TYPE Z7_STDCALL
+
+#if defined(_WIN32) && defined(__GNUC__)
+/* GCC compiler for x86 32-bit uses the rule:
+ the stack is 16-byte aligned before CALL instruction for function calling.
+ But only root function main() contains instructions that
+ set 16-byte alignment for stack pointer. And another functions
+ just keep alignment, if it was set in some parent function.
+
+ The problem:
+ if we create new thread in MinGW (GCC) 32-bit x86 via _beginthreadex() or CreateThread(),
+ the root function of thread doesn't set 16-byte alignment.
+ And stack frames in all child functions also will be unaligned in that case.
+
+ Here we set (force_align_arg_pointer) attribute for root function of new thread.
+ Do we need (force_align_arg_pointer) also for another systems? */
+
+ #define THREAD_FUNC_ATTRIB_ALIGN_ARG __attribute__((force_align_arg_pointer))
+ // #define THREAD_FUNC_ATTRIB_ALIGN_ARG // for debug : bad alignment in SSE functions
+#else
+ #define THREAD_FUNC_ATTRIB_ALIGN_ARG
+#endif
+
+#define THREAD_FUNC_DECL THREAD_FUNC_ATTRIB_ALIGN_ARG THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
+
+typedef THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE * THREAD_FUNC_TYPE)(void *);
+WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param);
+WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, CAffinityMask affinity);
+WRes Thread_Wait_Close(CThread *p);
+
+#ifdef _WIN32
+#define Thread_Create_With_CpuSet(p, func, param, cs) \
+ Thread_Create_With_Affinity(p, func, param, *cs)
+#else
+WRes Thread_Create_With_CpuSet(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, const CCpuSet *cpuSet);
+#endif
+
+
+#ifdef _WIN32
+
+typedef HANDLE CEvent;
+typedef CEvent CAutoResetEvent;
+typedef CEvent CManualResetEvent;
+#define Event_Construct(p) *(p) = NULL
+#define Event_IsCreated(p) (*(p) != NULL)
+#define Event_Close(p) HandlePtr_Close(p)
+#define Event_Wait(p) Handle_WaitObject(*(p))
+WRes Event_Set(CEvent *p);
+WRes Event_Reset(CEvent *p);
+WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled);
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p);
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled);
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p);
+
+typedef HANDLE CSemaphore;
+#define Semaphore_Construct(p) *(p) = NULL
+#define Semaphore_IsCreated(p) (*(p) != NULL)
+#define Semaphore_Close(p) HandlePtr_Close(p)
+#define Semaphore_Wait(p) Handle_WaitObject(*(p))
+WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
+WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num);
+WRes Semaphore_Release1(CSemaphore *p);
+
+typedef CRITICAL_SECTION CCriticalSection;
+WRes CriticalSection_Init(CCriticalSection *p);
+#define CriticalSection_Delete(p) DeleteCriticalSection(p)
+#define CriticalSection_Enter(p) EnterCriticalSection(p)
+#define CriticalSection_Leave(p) LeaveCriticalSection(p)
+
+
+#else // _WIN32
+
+typedef struct _CEvent
+{
+ int _created;
+ int _manual_reset;
+ int _state;
+ pthread_mutex_t _mutex;
+ pthread_cond_t _cond;
+} CEvent;
+
+typedef CEvent CAutoResetEvent;
+typedef CEvent CManualResetEvent;
+
+#define Event_Construct(p) (p)->_created = 0
+#define Event_IsCreated(p) ((p)->_created)
+
+WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled);
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p);
+WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled);
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p);
+
+WRes Event_Set(CEvent *p);
+WRes Event_Reset(CEvent *p);
+WRes Event_Wait(CEvent *p);
+WRes Event_Close(CEvent *p);
+
+
+typedef struct _CSemaphore
+{
+ int _created;
+ UInt32 _count;
+ UInt32 _maxCount;
+ pthread_mutex_t _mutex;
+ pthread_cond_t _cond;
+} CSemaphore;
+
+#define Semaphore_Construct(p) (p)->_created = 0
+#define Semaphore_IsCreated(p) ((p)->_created)
+
+WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
+WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
+WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num);
+#define Semaphore_Release1(p) Semaphore_ReleaseN(p, 1)
+WRes Semaphore_Wait(CSemaphore *p);
+WRes Semaphore_Close(CSemaphore *p);
+
+
+typedef struct _CCriticalSection
+{
+ pthread_mutex_t _mutex;
+} CCriticalSection;
+
+WRes CriticalSection_Init(CCriticalSection *p);
+void CriticalSection_Delete(CCriticalSection *cs);
+void CriticalSection_Enter(CCriticalSection *cs);
+void CriticalSection_Leave(CCriticalSection *cs);
+
+LONG InterlockedIncrement(LONG volatile *addend);
+
+#endif // _WIN32
+
+WRes AutoResetEvent_OptCreate_And_Reset(CAutoResetEvent *p);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/Util/7z/7z.dsp b/C/Util/7z/7z.dsp
index d3bf0fe..11e1b03 100644
--- a/C/Util/7z/7z.dsp
+++ b/C/Util/7z/7z.dsp
@@ -1,241 +1,245 @@
-# Microsoft Developer Studio Project File - Name="7z" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=7z - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "7z.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "7z.mak" CFG="7z - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "7z - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "7z - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "7z - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /MD /W4 /WX /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FAcs /Yu"Precomp.h" /FD /c
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\util\7zDec.exe" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "7z - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_SZ_ALLOC_DEBUG2" /D "_SZ_NO_INT_64_A" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /GZ /c
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\util\7zDec.exe" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "7z - Win32 Release"
-# Name "7z - Win32 Debug"
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\7z.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zAlloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zAlloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zArcIn.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zBuf.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zBuf.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zCrc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zCrcOpt.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zDec.c
-# ADD CPP /D "_7ZIP_PPMD_SUPPPORT"
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zFile.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zFile.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zStream.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zTypes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bcj2.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bcj2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bra.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bra86.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\BraIA64.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\CpuArch.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\CpuArch.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Delta.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Delta.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Lzma2Dec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Lzma2Dec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Ppmd.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Ppmd7.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Ppmd7.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Ppmd7Dec.c
-# End Source File
-# End Group
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compiler.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\Precomp.c
-# ADD CPP /Yc"Precomp.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\Precomp.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\7zMain.c
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="7z" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=7z - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "7z.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "7z.mak" CFG="7z - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "7z - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "7z - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W4 /WX /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /D "Z7_PPMD_SUPPORT" /FAcs /Yu"Precomp.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\util\7zDec.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_SZ_ALLOC_DEBUG2" /D "_SZ_NO_INT_64_A" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /D "Z7_PPMD_SUPPORT" /Yu"Precomp.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\util\7zDec.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "7z - Win32 Release"
+# Name "7z - Win32 Debug"
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\7z.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zArcIn.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrcOpt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zDec.c
+# ADD CPP /D "_7ZIP_PPMD_SUPPPORT"
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zStream.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra86.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\BraIA64.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Delta.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Ppmd.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Ppmd7.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Ppmd7.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Ppmd7Dec.c
+# End Source File
+# End Group
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.c
+# ADD CPP /Yc"Precomp.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7zMain.c
+# End Source File
+# End Target
+# End Project
diff --git a/C/Util/7z/7z.dsw b/C/Util/7z/7z.dsw
index 23089fb..848d13c 100644
--- a/C/Util/7z/7z.dsw
+++ b/C/Util/7z/7z.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "7z"=.\7z.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "7z"=.\7z.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/C/Util/7z/7zMain.c b/C/Util/7z/7zMain.c
index 1c02b48..547920a 100644
--- a/C/Util/7z/7zMain.c
+++ b/C/Util/7z/7zMain.c
@@ -1,686 +1,888 @@
-/* 7zMain.c - Test application for 7z Decoder
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <stdio.h>
-#include <string.h>
-
-#include "../../CpuArch.h"
-
-#include "../../7z.h"
-#include "../../7zAlloc.h"
-#include "../../7zBuf.h"
-#include "../../7zCrc.h"
-#include "../../7zFile.h"
-#include "../../7zVersion.h"
-
-#ifndef USE_WINDOWS_FILE
-/* for mkdir */
-#ifdef _WIN32
-#include <direct.h>
-#else
-#include <sys/stat.h>
-#include <errno.h>
-#endif
-#endif
-
-
-#define kInputBufSize ((size_t)1 << 18)
-
-static const ISzAlloc g_Alloc = { SzAlloc, SzFree };
-
-
-static void Print(const char *s)
-{
- fputs(s, stdout);
-}
-
-
-static int Buf_EnsureSize(CBuf *dest, size_t size)
-{
- if (dest->size >= size)
- return 1;
- Buf_Free(dest, &g_Alloc);
- return Buf_Create(dest, size, &g_Alloc);
-}
-
-#ifndef _WIN32
-#define _USE_UTF8
-#endif
-
-/* #define _USE_UTF8 */
-
-#ifdef _USE_UTF8
-
-#define _UTF8_START(n) (0x100 - (1 << (7 - (n))))
-
-#define _UTF8_RANGE(n) (((UInt32)1) << ((n) * 5 + 6))
-
-#define _UTF8_HEAD(n, val) ((Byte)(_UTF8_START(n) + (val >> (6 * (n)))))
-#define _UTF8_CHAR(n, val) ((Byte)(0x80 + (((val) >> (6 * (n))) & 0x3F)))
-
-static size_t Utf16_To_Utf8_Calc(const UInt16 *src, const UInt16 *srcLim)
-{
- size_t size = 0;
- for (;;)
- {
- UInt32 val;
- if (src == srcLim)
- return size;
-
- size++;
- val = *src++;
-
- if (val < 0x80)
- continue;
-
- if (val < _UTF8_RANGE(1))
- {
- size++;
- continue;
- }
-
- if (val >= 0xD800 && val < 0xDC00 && src != srcLim)
- {
- UInt32 c2 = *src;
- if (c2 >= 0xDC00 && c2 < 0xE000)
- {
- src++;
- size += 3;
- continue;
- }
- }
-
- size += 2;
- }
-}
-
-static Byte *Utf16_To_Utf8(Byte *dest, const UInt16 *src, const UInt16 *srcLim)
-{
- for (;;)
- {
- UInt32 val;
- if (src == srcLim)
- return dest;
-
- val = *src++;
-
- if (val < 0x80)
- {
- *dest++ = (char)val;
- continue;
- }
-
- if (val < _UTF8_RANGE(1))
- {
- dest[0] = _UTF8_HEAD(1, val);
- dest[1] = _UTF8_CHAR(0, val);
- dest += 2;
- continue;
- }
-
- if (val >= 0xD800 && val < 0xDC00 && src != srcLim)
- {
- UInt32 c2 = *src;
- if (c2 >= 0xDC00 && c2 < 0xE000)
- {
- src++;
- val = (((val - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
- dest[0] = _UTF8_HEAD(3, val);
- dest[1] = _UTF8_CHAR(2, val);
- dest[2] = _UTF8_CHAR(1, val);
- dest[3] = _UTF8_CHAR(0, val);
- dest += 4;
- continue;
- }
- }
-
- dest[0] = _UTF8_HEAD(2, val);
- dest[1] = _UTF8_CHAR(1, val);
- dest[2] = _UTF8_CHAR(0, val);
- dest += 3;
- }
-}
-
-static SRes Utf16_To_Utf8Buf(CBuf *dest, const UInt16 *src, size_t srcLen)
-{
- size_t destLen = Utf16_To_Utf8_Calc(src, src + srcLen);
- destLen += 1;
- if (!Buf_EnsureSize(dest, destLen))
- return SZ_ERROR_MEM;
- *Utf16_To_Utf8(dest->data, src, src + srcLen) = 0;
- return SZ_OK;
-}
-
-#endif
-
-static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s
- #ifndef _USE_UTF8
- , UINT codePage
- #endif
- )
-{
- unsigned len = 0;
- for (len = 0; s[len] != 0; len++);
-
- #ifndef _USE_UTF8
- {
- unsigned size = len * 3 + 100;
- if (!Buf_EnsureSize(buf, size))
- return SZ_ERROR_MEM;
- {
- buf->data[0] = 0;
- if (len != 0)
- {
- char defaultChar = '_';
- BOOL defUsed;
- unsigned numChars = 0;
- numChars = WideCharToMultiByte(codePage, 0, (LPCWSTR)s, len, (char *)buf->data, size, &defaultChar, &defUsed);
- if (numChars == 0 || numChars >= size)
- return SZ_ERROR_FAIL;
- buf->data[numChars] = 0;
- }
- return SZ_OK;
- }
- }
- #else
- return Utf16_To_Utf8Buf(buf, s, len);
- #endif
-}
-
-#ifdef _WIN32
- #ifndef USE_WINDOWS_FILE
- static UINT g_FileCodePage = CP_ACP;
- #endif
- #define MY_FILE_CODE_PAGE_PARAM ,g_FileCodePage
-#else
- #define MY_FILE_CODE_PAGE_PARAM
-#endif
-
-static WRes MyCreateDir(const UInt16 *name)
-{
- #ifdef USE_WINDOWS_FILE
-
- return CreateDirectoryW((LPCWSTR)name, NULL) ? 0 : GetLastError();
-
- #else
-
- CBuf buf;
- WRes res;
- Buf_Init(&buf);
- RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM));
-
- res =
- #ifdef _WIN32
- _mkdir((const char *)buf.data)
- #else
- mkdir((const char *)buf.data, 0777)
- #endif
- == 0 ? 0 : errno;
- Buf_Free(&buf, &g_Alloc);
- return res;
-
- #endif
-}
-
-static WRes OutFile_OpenUtf16(CSzFile *p, const UInt16 *name)
-{
- #ifdef USE_WINDOWS_FILE
- return OutFile_OpenW(p, (LPCWSTR)name);
- #else
- CBuf buf;
- WRes res;
- Buf_Init(&buf);
- RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM));
- res = OutFile_Open(p, (const char *)buf.data);
- Buf_Free(&buf, &g_Alloc);
- return res;
- #endif
-}
-
-
-static SRes PrintString(const UInt16 *s)
-{
- CBuf buf;
- SRes res;
- Buf_Init(&buf);
- res = Utf16_To_Char(&buf, s
- #ifndef _USE_UTF8
- , CP_OEMCP
- #endif
- );
- if (res == SZ_OK)
- Print((const char *)buf.data);
- Buf_Free(&buf, &g_Alloc);
- return res;
-}
-
-static void UInt64ToStr(UInt64 value, char *s, int numDigits)
-{
- char temp[32];
- int pos = 0;
- do
- {
- temp[pos++] = (char)('0' + (unsigned)(value % 10));
- value /= 10;
- }
- while (value != 0);
-
- for (numDigits -= pos; numDigits > 0; numDigits--)
- *s++ = ' ';
-
- do
- *s++ = temp[--pos];
- while (pos);
- *s = '\0';
-}
-
-static char *UIntToStr(char *s, unsigned value, int numDigits)
-{
- char temp[16];
- int pos = 0;
- do
- temp[pos++] = (char)('0' + (value % 10));
- while (value /= 10);
-
- for (numDigits -= pos; numDigits > 0; numDigits--)
- *s++ = '0';
-
- do
- *s++ = temp[--pos];
- while (pos);
- *s = '\0';
- return s;
-}
-
-static void UIntToStr_2(char *s, unsigned value)
-{
- s[0] = (char)('0' + (value / 10));
- s[1] = (char)('0' + (value % 10));
-}
-
-#define PERIOD_4 (4 * 365 + 1)
-#define PERIOD_100 (PERIOD_4 * 25 - 1)
-#define PERIOD_400 (PERIOD_100 * 4 + 1)
-
-static void ConvertFileTimeToString(const CNtfsFileTime *nt, char *s)
-{
- unsigned year, mon, hour, min, sec;
- Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
- unsigned t;
- UInt32 v;
- UInt64 v64 = nt->Low | ((UInt64)nt->High << 32);
- v64 /= 10000000;
- sec = (unsigned)(v64 % 60); v64 /= 60;
- min = (unsigned)(v64 % 60); v64 /= 60;
- 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;
- }
- s = UIntToStr(s, year, 4); *s++ = '-';
- UIntToStr_2(s, mon + 1); s[2] = '-'; s += 3;
- UIntToStr_2(s, (unsigned)v + 1); s[2] = ' '; s += 3;
- UIntToStr_2(s, hour); s[2] = ':'; s += 3;
- UIntToStr_2(s, min); s[2] = ':'; s += 3;
- UIntToStr_2(s, sec); s[2] = 0;
-}
-
-static void PrintLF()
-{
- Print("\n");
-}
-
-static void PrintError(char *s)
-{
- Print("\nERROR: ");
- Print(s);
- PrintLF();
-}
-
-static void GetAttribString(UInt32 wa, BoolInt isDir, char *s)
-{
- #ifdef USE_WINDOWS_FILE
- s[0] = (char)(((wa & FILE_ATTRIBUTE_DIRECTORY) != 0 || isDir) ? 'D' : '.');
- s[1] = (char)(((wa & FILE_ATTRIBUTE_READONLY ) != 0) ? 'R': '.');
- s[2] = (char)(((wa & FILE_ATTRIBUTE_HIDDEN ) != 0) ? 'H': '.');
- s[3] = (char)(((wa & FILE_ATTRIBUTE_SYSTEM ) != 0) ? 'S': '.');
- s[4] = (char)(((wa & FILE_ATTRIBUTE_ARCHIVE ) != 0) ? 'A': '.');
- s[5] = 0;
- #else
- s[0] = (char)(((wa & (1 << 4)) != 0 || isDir) ? 'D' : '.');
- s[1] = 0;
- #endif
-}
-
-
-// #define NUM_PARENTS_MAX 128
-
-int MY_CDECL main(int numargs, char *args[])
-{
- ISzAlloc allocImp;
- ISzAlloc allocTempImp;
-
- CFileInStream archiveStream;
- CLookToRead2 lookStream;
- CSzArEx db;
- SRes res;
- UInt16 *temp = NULL;
- size_t tempSize = 0;
- // UInt32 parents[NUM_PARENTS_MAX];
-
- Print("\n7z Decoder " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n\n");
-
- if (numargs == 1)
- {
- Print(
- "Usage: 7zDec <command> <archive_name>\n\n"
- "<Commands>\n"
- " e: Extract files from archive (without using directory names)\n"
- " l: List contents of archive\n"
- " t: Test integrity of archive\n"
- " x: eXtract files with full paths\n");
- return 0;
- }
-
- if (numargs < 3)
- {
- PrintError("incorrect command");
- return 1;
- }
-
- #if defined(_WIN32) && !defined(USE_WINDOWS_FILE) && !defined(UNDER_CE)
- g_FileCodePage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
- #endif
-
-
- allocImp = g_Alloc;
- allocTempImp = g_Alloc;
-
- #ifdef UNDER_CE
- if (InFile_OpenW(&archiveStream.file, L"\test.7z"))
- #else
- if (InFile_Open(&archiveStream.file, args[2]))
- #endif
- {
- PrintError("can not open input file");
- return 1;
- }
-
- FileInStream_CreateVTable(&archiveStream);
- LookToRead2_CreateVTable(&lookStream, False);
- lookStream.buf = NULL;
-
- res = SZ_OK;
-
- {
- lookStream.buf = (Byte *)ISzAlloc_Alloc(&allocImp, kInputBufSize);
- if (!lookStream.buf)
- res = SZ_ERROR_MEM;
- else
- {
- lookStream.bufSize = kInputBufSize;
- lookStream.realStream = &archiveStream.vt;
- LookToRead2_Init(&lookStream);
- }
- }
-
- CrcGenerateTable();
-
- SzArEx_Init(&db);
-
- if (res == SZ_OK)
- {
- res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);
- }
-
- if (res == SZ_OK)
- {
- char *command = args[1];
- int listCommand = 0, testCommand = 0, fullPaths = 0;
-
- if (strcmp(command, "l") == 0) listCommand = 1;
- else if (strcmp(command, "t") == 0) testCommand = 1;
- else if (strcmp(command, "e") == 0) { }
- else if (strcmp(command, "x") == 0) { fullPaths = 1; }
- else
- {
- PrintError("incorrect command");
- res = SZ_ERROR_FAIL;
- }
-
- if (res == SZ_OK)
- {
- UInt32 i;
-
- /*
- if you need cache, use these 3 variables.
- if you use external function, you can make these variable as static.
- */
- UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
- Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
- size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
-
- for (i = 0; i < db.NumFiles; i++)
- {
- size_t offset = 0;
- size_t outSizeProcessed = 0;
- // const CSzFileItem *f = db.Files + i;
- size_t len;
- unsigned isDir = SzArEx_IsDir(&db, i);
- if (listCommand == 0 && isDir && !fullPaths)
- continue;
- len = SzArEx_GetFileNameUtf16(&db, i, NULL);
- // len = SzArEx_GetFullNameLen(&db, i);
-
- if (len > tempSize)
- {
- SzFree(NULL, temp);
- tempSize = len;
- temp = (UInt16 *)SzAlloc(NULL, tempSize * sizeof(temp[0]));
- if (!temp)
- {
- res = SZ_ERROR_MEM;
- break;
- }
- }
-
- SzArEx_GetFileNameUtf16(&db, i, temp);
- /*
- if (SzArEx_GetFullNameUtf16_Back(&db, i, temp + len) != temp)
- {
- res = SZ_ERROR_FAIL;
- break;
- }
- */
-
- if (listCommand)
- {
- char attr[8], s[32], t[32];
- UInt64 fileSize;
-
- GetAttribString(SzBitWithVals_Check(&db.Attribs, i) ? db.Attribs.Vals[i] : 0, isDir, attr);
-
- fileSize = SzArEx_GetFileSize(&db, i);
- UInt64ToStr(fileSize, s, 10);
-
- if (SzBitWithVals_Check(&db.MTime, i))
- ConvertFileTimeToString(&db.MTime.Vals[i], t);
- else
- {
- size_t j;
- for (j = 0; j < 19; j++)
- t[j] = ' ';
- t[j] = '\0';
- }
-
- Print(t);
- Print(" ");
- Print(attr);
- Print(" ");
- Print(s);
- Print(" ");
- res = PrintString(temp);
- if (res != SZ_OK)
- break;
- if (isDir)
- Print("/");
- PrintLF();
- continue;
- }
-
- Print(testCommand ?
- "Testing ":
- "Extracting ");
- res = PrintString(temp);
- if (res != SZ_OK)
- break;
-
- if (isDir)
- Print("/");
- else
- {
- res = SzArEx_Extract(&db, &lookStream.vt, i,
- &blockIndex, &outBuffer, &outBufferSize,
- &offset, &outSizeProcessed,
- &allocImp, &allocTempImp);
- if (res != SZ_OK)
- break;
- }
-
- if (!testCommand)
- {
- CSzFile outFile;
- size_t processedSize;
- size_t j;
- UInt16 *name = (UInt16 *)temp;
- const UInt16 *destPath = (const UInt16 *)name;
-
- for (j = 0; name[j] != 0; j++)
- if (name[j] == '/')
- {
- if (fullPaths)
- {
- name[j] = 0;
- MyCreateDir(name);
- name[j] = CHAR_PATH_SEPARATOR;
- }
- else
- destPath = name + j + 1;
- }
-
- if (isDir)
- {
- MyCreateDir(destPath);
- PrintLF();
- continue;
- }
- else if (OutFile_OpenUtf16(&outFile, destPath))
- {
- PrintError("can not open output file");
- res = SZ_ERROR_FAIL;
- break;
- }
-
- processedSize = outSizeProcessed;
-
- if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)
- {
- PrintError("can not write output file");
- res = SZ_ERROR_FAIL;
- break;
- }
-
- #ifdef USE_WINDOWS_FILE
- {
- FILETIME mtime, ctime;
- FILETIME *mtimePtr = NULL;
- FILETIME *ctimePtr = NULL;
-
- if (SzBitWithVals_Check(&db.MTime, i))
- {
- const CNtfsFileTime *t = &db.MTime.Vals[i];
- mtime.dwLowDateTime = (DWORD)(t->Low);
- mtime.dwHighDateTime = (DWORD)(t->High);
- mtimePtr = &mtime;
- }
- if (SzBitWithVals_Check(&db.CTime, i))
- {
- const CNtfsFileTime *t = &db.CTime.Vals[i];
- ctime.dwLowDateTime = (DWORD)(t->Low);
- ctime.dwHighDateTime = (DWORD)(t->High);
- ctimePtr = &ctime;
- }
- if (mtimePtr || ctimePtr)
- SetFileTime(outFile.handle, ctimePtr, NULL, mtimePtr);
- }
- #endif
-
- if (File_Close(&outFile))
- {
- PrintError("can not close output file");
- res = SZ_ERROR_FAIL;
- break;
- }
-
- #ifdef USE_WINDOWS_FILE
- if (SzBitWithVals_Check(&db.Attribs, i))
- {
- UInt32 attrib = db.Attribs.Vals[i];
- /* p7zip stores posix attributes in high 16 bits and adds 0x8000 as marker.
- We remove posix bits, if we detect posix mode field */
- if ((attrib & 0xF0000000) != 0)
- attrib &= 0x7FFF;
- SetFileAttributesW((LPCWSTR)destPath, attrib);
- }
- #endif
- }
- PrintLF();
- }
- ISzAlloc_Free(&allocImp, outBuffer);
- }
- }
-
- SzFree(NULL, temp);
- SzArEx_Free(&db, &allocImp);
- ISzAlloc_Free(&allocImp, lookStream.buf);
-
- File_Close(&archiveStream.file);
-
- if (res == SZ_OK)
- {
- Print("\nEverything is Ok\n");
- return 0;
- }
-
- if (res == SZ_ERROR_UNSUPPORTED)
- PrintError("decoder doesn't support this archive");
- else if (res == SZ_ERROR_MEM)
- PrintError("can not allocate memory");
- else if (res == SZ_ERROR_CRC)
- PrintError("CRC error");
- else
- {
- char s[32];
- UInt64ToStr(res, s, 0);
- PrintError(s);
- }
-
- return 1;
-}
+/* 7zMain.c - Test application for 7z Decoder
+2023-04-04 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "../../CpuArch.h"
+
+#include "../../7z.h"
+#include "../../7zAlloc.h"
+#include "../../7zBuf.h"
+#include "../../7zCrc.h"
+#include "../../7zFile.h"
+#include "../../7zVersion.h"
+
+#ifndef USE_WINDOWS_FILE
+/* for mkdir */
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <stdlib.h>
+#include <time.h>
+#ifdef __GNUC__
+#include <sys/time.h>
+#endif
+#include <fcntl.h>
+// #include <utime.h>
+#include <sys/stat.h>
+#include <errno.h>
+#endif
+#endif
+
+#define kInputBufSize ((size_t)1 << 18)
+
+static const ISzAlloc g_Alloc = { SzAlloc, SzFree };
+// static const ISzAlloc g_Alloc_temp = { SzAllocTemp, SzFreeTemp };
+
+
+static void Print(const char *s)
+{
+ fputs(s, stdout);
+}
+
+
+static int Buf_EnsureSize(CBuf *dest, size_t size)
+{
+ if (dest->size >= size)
+ return 1;
+ Buf_Free(dest, &g_Alloc);
+ return Buf_Create(dest, size, &g_Alloc);
+}
+
+#ifndef _WIN32
+#define MY_USE_UTF8
+#endif
+
+/* #define MY_USE_UTF8 */
+
+#ifdef MY_USE_UTF8
+
+#define MY_UTF8_START(n) (0x100 - (1 << (7 - (n))))
+
+#define MY_UTF8_RANGE(n) (((UInt32)1) << ((n) * 5 + 6))
+
+#define MY_UTF8_HEAD(n, val) ((Byte)(MY_UTF8_START(n) + (val >> (6 * (n)))))
+#define MY_UTF8_CHAR(n, val) ((Byte)(0x80 + (((val) >> (6 * (n))) & 0x3F)))
+
+static size_t Utf16_To_Utf8_Calc(const UInt16 *src, const UInt16 *srcLim)
+{
+ size_t size = 0;
+ for (;;)
+ {
+ UInt32 val;
+ if (src == srcLim)
+ return size;
+
+ size++;
+ val = *src++;
+
+ if (val < 0x80)
+ continue;
+
+ if (val < MY_UTF8_RANGE(1))
+ {
+ size++;
+ continue;
+ }
+
+ if (val >= 0xD800 && val < 0xDC00 && src != srcLim)
+ {
+ const UInt32 c2 = *src;
+ if (c2 >= 0xDC00 && c2 < 0xE000)
+ {
+ src++;
+ size += 3;
+ continue;
+ }
+ }
+
+ size += 2;
+ }
+}
+
+static Byte *Utf16_To_Utf8(Byte *dest, const UInt16 *src, const UInt16 *srcLim)
+{
+ for (;;)
+ {
+ UInt32 val;
+ if (src == srcLim)
+ return dest;
+
+ val = *src++;
+
+ if (val < 0x80)
+ {
+ *dest++ = (Byte)val;
+ continue;
+ }
+
+ if (val < MY_UTF8_RANGE(1))
+ {
+ dest[0] = MY_UTF8_HEAD(1, val);
+ dest[1] = MY_UTF8_CHAR(0, val);
+ dest += 2;
+ continue;
+ }
+
+ if (val >= 0xD800 && val < 0xDC00 && src != srcLim)
+ {
+ const UInt32 c2 = *src;
+ if (c2 >= 0xDC00 && c2 < 0xE000)
+ {
+ src++;
+ val = (((val - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
+ dest[0] = MY_UTF8_HEAD(3, val);
+ dest[1] = MY_UTF8_CHAR(2, val);
+ dest[2] = MY_UTF8_CHAR(1, val);
+ dest[3] = MY_UTF8_CHAR(0, val);
+ dest += 4;
+ continue;
+ }
+ }
+
+ dest[0] = MY_UTF8_HEAD(2, val);
+ dest[1] = MY_UTF8_CHAR(1, val);
+ dest[2] = MY_UTF8_CHAR(0, val);
+ dest += 3;
+ }
+}
+
+static SRes Utf16_To_Utf8Buf(CBuf *dest, const UInt16 *src, size_t srcLen)
+{
+ size_t destLen = Utf16_To_Utf8_Calc(src, src + srcLen);
+ destLen += 1;
+ if (!Buf_EnsureSize(dest, destLen))
+ return SZ_ERROR_MEM;
+ *Utf16_To_Utf8(dest->data, src, src + srcLen) = 0;
+ return SZ_OK;
+}
+
+#endif
+
+static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s
+ #ifndef MY_USE_UTF8
+ , UINT codePage
+ #endif
+ )
+{
+ unsigned len = 0;
+ for (len = 0; s[len] != 0; len++) {}
+
+ #ifndef MY_USE_UTF8
+ {
+ const unsigned size = len * 3 + 100;
+ if (!Buf_EnsureSize(buf, size))
+ return SZ_ERROR_MEM;
+ {
+ buf->data[0] = 0;
+ if (len != 0)
+ {
+ const char defaultChar = '_';
+ BOOL defUsed;
+ const unsigned numChars = (unsigned)WideCharToMultiByte(
+ codePage, 0, (LPCWSTR)s, (int)len, (char *)buf->data, (int)size, &defaultChar, &defUsed);
+ if (numChars == 0 || numChars >= size)
+ return SZ_ERROR_FAIL;
+ buf->data[numChars] = 0;
+ }
+ return SZ_OK;
+ }
+ }
+ #else
+ return Utf16_To_Utf8Buf(buf, s, len);
+ #endif
+}
+
+#ifdef _WIN32
+ #ifndef USE_WINDOWS_FILE
+ static UINT g_FileCodePage = CP_ACP;
+ #define MY_FILE_CODE_PAGE_PARAM ,g_FileCodePage
+ #endif
+#else
+ #define MY_FILE_CODE_PAGE_PARAM
+#endif
+
+static WRes MyCreateDir(const UInt16 *name)
+{
+ #ifdef USE_WINDOWS_FILE
+
+ return CreateDirectoryW((LPCWSTR)name, NULL) ? 0 : GetLastError();
+
+ #else
+
+ CBuf buf;
+ WRes res;
+ Buf_Init(&buf);
+ RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM))
+
+ res =
+ #ifdef _WIN32
+ _mkdir((const char *)buf.data)
+ #else
+ mkdir((const char *)buf.data, 0777)
+ #endif
+ == 0 ? 0 : errno;
+ Buf_Free(&buf, &g_Alloc);
+ return res;
+
+ #endif
+}
+
+static WRes OutFile_OpenUtf16(CSzFile *p, const UInt16 *name)
+{
+ #ifdef USE_WINDOWS_FILE
+ return OutFile_OpenW(p, (LPCWSTR)name);
+ #else
+ CBuf buf;
+ WRes res;
+ Buf_Init(&buf);
+ RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM))
+ res = OutFile_Open(p, (const char *)buf.data);
+ Buf_Free(&buf, &g_Alloc);
+ return res;
+ #endif
+}
+
+
+static SRes PrintString(const UInt16 *s)
+{
+ CBuf buf;
+ SRes res;
+ Buf_Init(&buf);
+ res = Utf16_To_Char(&buf, s
+ #ifndef MY_USE_UTF8
+ , CP_OEMCP
+ #endif
+ );
+ if (res == SZ_OK)
+ Print((const char *)buf.data);
+ Buf_Free(&buf, &g_Alloc);
+ return res;
+}
+
+static void UInt64ToStr(UInt64 value, char *s, int numDigits)
+{
+ char temp[32];
+ int pos = 0;
+ do
+ {
+ temp[pos++] = (char)('0' + (unsigned)(value % 10));
+ value /= 10;
+ }
+ while (value != 0);
+
+ for (numDigits -= pos; numDigits > 0; numDigits--)
+ *s++ = ' ';
+
+ do
+ *s++ = temp[--pos];
+ while (pos);
+ *s = '\0';
+}
+
+static char *UIntToStr(char *s, unsigned value, int numDigits)
+{
+ char temp[16];
+ int pos = 0;
+ do
+ temp[pos++] = (char)('0' + (value % 10));
+ while (value /= 10);
+
+ for (numDigits -= pos; numDigits > 0; numDigits--)
+ *s++ = '0';
+
+ do
+ *s++ = temp[--pos];
+ while (pos);
+ *s = '\0';
+ return s;
+}
+
+static void UIntToStr_2(char *s, unsigned value)
+{
+ s[0] = (char)('0' + (value / 10));
+ s[1] = (char)('0' + (value % 10));
+}
+
+
+#define PERIOD_4 (4 * 365 + 1)
+#define PERIOD_100 (PERIOD_4 * 25 - 1)
+#define PERIOD_400 (PERIOD_100 * 4 + 1)
+
+
+
+#ifndef _WIN32
+
+// MS uses long for BOOL, but long is 32-bit in MS. So we use int.
+// typedef long BOOL;
+typedef int BOOL;
+
+typedef struct _FILETIME
+{
+ DWORD dwLowDateTime;
+ DWORD dwHighDateTime;
+} FILETIME;
+
+static LONG TIME_GetBias()
+{
+ const time_t utc = time(NULL);
+ struct tm *ptm = localtime(&utc);
+ const int localdaylight = ptm->tm_isdst; /* daylight for local timezone */
+ ptm = gmtime(&utc);
+ ptm->tm_isdst = localdaylight; /* use local daylight, not that of Greenwich */
+ const LONG bias = (int)(mktime(ptm) - utc);
+ return bias;
+}
+
+#define TICKS_PER_SEC 10000000
+
+#define GET_TIME_64(pft) ((pft)->dwLowDateTime | ((UInt64)(pft)->dwHighDateTime << 32))
+
+#define SET_FILETIME(ft, v64) \
+ (ft)->dwLowDateTime = (DWORD)v64; \
+ (ft)->dwHighDateTime = (DWORD)(v64 >> 32);
+
+#define WINAPI
+#define TRUE 1
+
+static BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFileTime)
+{
+ UInt64 v = GET_TIME_64(fileTime);
+ v = (UInt64)((Int64)v - (Int64)TIME_GetBias() * TICKS_PER_SEC);
+ SET_FILETIME(localFileTime, v)
+ return TRUE;
+}
+
+static const UInt32 kNumTimeQuantumsInSecond = 10000000;
+static const UInt32 kFileTimeStartYear = 1601;
+static const UInt32 kUnixTimeStartYear = 1970;
+static const UInt64 kUnixTimeOffset =
+ (UInt64)60 * 60 * 24 * (89 + 365 * (kUnixTimeStartYear - kFileTimeStartYear));
+
+static Int64 Time_FileTimeToUnixTime64(const FILETIME *ft)
+{
+ const UInt64 winTime = GET_TIME_64(ft);
+ return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
+}
+
+#if defined(_AIX)
+ #define MY_ST_TIMESPEC st_timespec
+#else
+ #define MY_ST_TIMESPEC timespec
+#endif
+
+static void FILETIME_To_timespec(const FILETIME *ft, struct MY_ST_TIMESPEC *ts)
+{
+ if (ft)
+ {
+ const Int64 sec = Time_FileTimeToUnixTime64(ft);
+ // time_t is long
+ const time_t sec2 = (time_t)sec;
+ if (sec2 == sec)
+ {
+ ts->tv_sec = sec2;
+ const UInt64 winTime = GET_TIME_64(ft);
+ ts->tv_nsec = (long)((winTime % 10000000) * 100);
+ return;
+ }
+ }
+ // else
+ {
+ ts->tv_sec = 0;
+ // ts.tv_nsec = UTIME_NOW; // set to the current time
+ ts->tv_nsec = UTIME_OMIT; // keep old timesptamp
+ }
+}
+
+static WRes Set_File_FILETIME(const UInt16 *name, const FILETIME *mTime)
+{
+ struct timespec times[2];
+
+ const int flags = 0; // follow link
+ // = AT_SYMLINK_NOFOLLOW; // don't follow link
+
+ CBuf buf;
+ int res;
+ Buf_Init(&buf);
+ RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM))
+ FILETIME_To_timespec(NULL, ×[0]);
+ FILETIME_To_timespec(mTime, ×[1]);
+ res = utimensat(AT_FDCWD, (const char *)buf.data, times, flags);
+ Buf_Free(&buf, &g_Alloc);
+ if (res == 0)
+ return 0;
+ return errno;
+}
+
+#endif
+
+static void NtfsFileTime_to_FILETIME(const CNtfsFileTime *t, FILETIME *ft)
+{
+ ft->dwLowDateTime = (DWORD)(t->Low);
+ ft->dwHighDateTime = (DWORD)(t->High);
+}
+
+static void ConvertFileTimeToString(const CNtfsFileTime *nTime, char *s)
+{
+ unsigned year, mon, hour, min, sec;
+ Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+ unsigned t;
+ UInt32 v;
+ // UInt64 v64 = nt->Low | ((UInt64)nt->High << 32);
+ UInt64 v64;
+ {
+ FILETIME fileTime, locTime;
+ NtfsFileTime_to_FILETIME(nTime, &fileTime);
+ if (!FileTimeToLocalFileTime(&fileTime, &locTime))
+ {
+ locTime.dwHighDateTime =
+ locTime.dwLowDateTime = 0;
+ }
+ v64 = locTime.dwLowDateTime | ((UInt64)locTime.dwHighDateTime << 32);
+ }
+ v64 /= 10000000;
+ sec = (unsigned)(v64 % 60); v64 /= 60;
+ min = (unsigned)(v64 % 60); v64 /= 60;
+ 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++)
+ {
+ const unsigned d = ms[mon];
+ if (v < d)
+ break;
+ v -= d;
+ }
+ s = UIntToStr(s, year, 4); *s++ = '-';
+ UIntToStr_2(s, mon + 1); s[2] = '-'; s += 3;
+ UIntToStr_2(s, (unsigned)v + 1); s[2] = ' '; s += 3;
+ UIntToStr_2(s, hour); s[2] = ':'; s += 3;
+ UIntToStr_2(s, min); s[2] = ':'; s += 3;
+ UIntToStr_2(s, sec); s[2] = 0;
+}
+
+static void PrintLF(void)
+{
+ Print("\n");
+}
+
+static void PrintError(char *s)
+{
+ Print("\nERROR: ");
+ Print(s);
+ PrintLF();
+}
+
+static void PrintError_WRes(const char *message, WRes wres)
+{
+ Print("\nERROR: ");
+ Print(message);
+ PrintLF();
+ {
+ char s[32];
+ UIntToStr(s, (unsigned)wres, 1);
+ Print("System error code: ");
+ Print(s);
+ }
+ // sprintf(buffer + strlen(buffer), "\nSystem error code: %d", (unsigned)wres);
+ #ifdef _WIN32
+ {
+ char *s = NULL;
+ if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, wres, 0, (LPSTR) &s, 0, NULL) != 0 && s)
+ {
+ Print(" : ");
+ Print(s);
+ LocalFree(s);
+ }
+ }
+ #else
+ {
+ const char *s = strerror(wres);
+ if (s)
+ {
+ Print(" : ");
+ Print(s);
+ }
+ }
+ #endif
+ PrintLF();
+}
+
+static void GetAttribString(UInt32 wa, BoolInt isDir, char *s)
+{
+ #ifdef USE_WINDOWS_FILE
+ s[0] = (char)(((wa & FILE_ATTRIBUTE_DIRECTORY) != 0 || isDir) ? 'D' : '.');
+ s[1] = (char)(((wa & FILE_ATTRIBUTE_READONLY ) != 0) ? 'R': '.');
+ s[2] = (char)(((wa & FILE_ATTRIBUTE_HIDDEN ) != 0) ? 'H': '.');
+ s[3] = (char)(((wa & FILE_ATTRIBUTE_SYSTEM ) != 0) ? 'S': '.');
+ s[4] = (char)(((wa & FILE_ATTRIBUTE_ARCHIVE ) != 0) ? 'A': '.');
+ s[5] = 0;
+ #else
+ s[0] = (char)(((wa & (1 << 4)) != 0 || isDir) ? 'D' : '.');
+ s[1] = 0;
+ #endif
+}
+
+
+// #define NUM_PARENTS_MAX 128
+
+int Z7_CDECL main(int numargs, char *args[])
+{
+ ISzAlloc allocImp;
+ ISzAlloc allocTempImp;
+
+ CFileInStream archiveStream;
+ CLookToRead2 lookStream;
+ CSzArEx db;
+ SRes res;
+ UInt16 *temp = NULL;
+ size_t tempSize = 0;
+ // UInt32 parents[NUM_PARENTS_MAX];
+
+ Print("\n7z Decoder " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n\n");
+
+ if (numargs == 1)
+ {
+ Print(
+ "Usage: 7zDec <command> <archive_name>\n\n"
+ "<Commands>\n"
+ " e: Extract files from archive (without using directory names)\n"
+ " l: List contents of archive\n"
+ " t: Test integrity of archive\n"
+ " x: eXtract files with full paths\n");
+ return 0;
+ }
+
+ if (numargs < 3)
+ {
+ PrintError("incorrect command");
+ return 1;
+ }
+
+ #if defined(_WIN32) && !defined(USE_WINDOWS_FILE) && !defined(UNDER_CE)
+ g_FileCodePage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+ #endif
+
+
+ allocImp = g_Alloc;
+ allocTempImp = g_Alloc;
+ // allocTempImp = g_Alloc_temp;
+
+ {
+ WRes wres =
+ #ifdef UNDER_CE
+ InFile_OpenW(&archiveStream.file, L"\test.7z"); // change it
+ #else
+ InFile_Open(&archiveStream.file, args[2]);
+ #endif
+ if (wres != 0)
+ {
+ PrintError_WRes("cannot open input file", wres);
+ return 1;
+ }
+ }
+
+ FileInStream_CreateVTable(&archiveStream);
+ archiveStream.wres = 0;
+ LookToRead2_CreateVTable(&lookStream, False);
+ lookStream.buf = NULL;
+
+ res = SZ_OK;
+
+ {
+ lookStream.buf = (Byte *)ISzAlloc_Alloc(&allocImp, kInputBufSize);
+ if (!lookStream.buf)
+ res = SZ_ERROR_MEM;
+ else
+ {
+ lookStream.bufSize = kInputBufSize;
+ lookStream.realStream = &archiveStream.vt;
+ LookToRead2_INIT(&lookStream)
+ }
+ }
+
+ CrcGenerateTable();
+
+ SzArEx_Init(&db);
+
+ if (res == SZ_OK)
+ {
+ res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);
+ }
+
+ if (res == SZ_OK)
+ {
+ char *command = args[1];
+ int listCommand = 0, testCommand = 0, fullPaths = 0;
+
+ if (strcmp(command, "l") == 0) listCommand = 1;
+ else if (strcmp(command, "t") == 0) testCommand = 1;
+ else if (strcmp(command, "e") == 0) { }
+ else if (strcmp(command, "x") == 0) { fullPaths = 1; }
+ else
+ {
+ PrintError("incorrect command");
+ res = SZ_ERROR_FAIL;
+ }
+
+ if (res == SZ_OK)
+ {
+ UInt32 i;
+
+ /*
+ if you need cache, use these 3 variables.
+ if you use external function, you can make these variable as static.
+ */
+ UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
+ Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
+ size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
+
+ for (i = 0; i < db.NumFiles; i++)
+ {
+ size_t offset = 0;
+ size_t outSizeProcessed = 0;
+ // const CSzFileItem *f = db.Files + i;
+ size_t len;
+ const BoolInt isDir = SzArEx_IsDir(&db, i);
+ if (listCommand == 0 && isDir && !fullPaths)
+ continue;
+ len = SzArEx_GetFileNameUtf16(&db, i, NULL);
+ // len = SzArEx_GetFullNameLen(&db, i);
+
+ if (len > tempSize)
+ {
+ SzFree(NULL, temp);
+ tempSize = len;
+ temp = (UInt16 *)SzAlloc(NULL, tempSize * sizeof(temp[0]));
+ if (!temp)
+ {
+ res = SZ_ERROR_MEM;
+ break;
+ }
+ }
+
+ SzArEx_GetFileNameUtf16(&db, i, temp);
+ /*
+ if (SzArEx_GetFullNameUtf16_Back(&db, i, temp + len) != temp)
+ {
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ */
+
+ if (listCommand)
+ {
+ char attr[8], s[32], t[32];
+ UInt64 fileSize;
+
+ GetAttribString(SzBitWithVals_Check(&db.Attribs, i) ? db.Attribs.Vals[i] : 0, isDir, attr);
+
+ fileSize = SzArEx_GetFileSize(&db, i);
+ UInt64ToStr(fileSize, s, 10);
+
+ if (SzBitWithVals_Check(&db.MTime, i))
+ ConvertFileTimeToString(&db.MTime.Vals[i], t);
+ else
+ {
+ size_t j;
+ for (j = 0; j < 19; j++)
+ t[j] = ' ';
+ t[j] = '\0';
+ }
+
+ Print(t);
+ Print(" ");
+ Print(attr);
+ Print(" ");
+ Print(s);
+ Print(" ");
+ res = PrintString(temp);
+ if (res != SZ_OK)
+ break;
+ if (isDir)
+ Print("/");
+ PrintLF();
+ continue;
+ }
+
+ Print(testCommand ?
+ "T ":
+ "- ");
+ res = PrintString(temp);
+ if (res != SZ_OK)
+ break;
+
+ if (isDir)
+ Print("/");
+ else
+ {
+ res = SzArEx_Extract(&db, &lookStream.vt, i,
+ &blockIndex, &outBuffer, &outBufferSize,
+ &offset, &outSizeProcessed,
+ &allocImp, &allocTempImp);
+ if (res != SZ_OK)
+ break;
+ }
+
+ if (!testCommand)
+ {
+ CSzFile outFile;
+ size_t processedSize;
+ size_t j;
+ UInt16 *name = (UInt16 *)temp;
+ const UInt16 *destPath = (const UInt16 *)name;
+
+ for (j = 0; name[j] != 0; j++)
+ if (name[j] == '/')
+ {
+ if (fullPaths)
+ {
+ name[j] = 0;
+ MyCreateDir(name);
+ name[j] = CHAR_PATH_SEPARATOR;
+ }
+ else
+ destPath = name + j + 1;
+ }
+
+ if (isDir)
+ {
+ MyCreateDir(destPath);
+ PrintLF();
+ continue;
+ }
+ else
+ {
+ const WRes wres = OutFile_OpenUtf16(&outFile, destPath);
+ if (wres != 0)
+ {
+ PrintError_WRes("cannot open output file", wres);
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ }
+
+ processedSize = outSizeProcessed;
+
+ {
+ const WRes wres = File_Write(&outFile, outBuffer + offset, &processedSize);
+ if (wres != 0 || processedSize != outSizeProcessed)
+ {
+ PrintError_WRes("cannot write output file", wres);
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ }
+
+ {
+ FILETIME mtime;
+ FILETIME *mtimePtr = NULL;
+
+ #ifdef USE_WINDOWS_FILE
+ FILETIME ctime;
+ FILETIME *ctimePtr = NULL;
+ #endif
+
+ if (SzBitWithVals_Check(&db.MTime, i))
+ {
+ const CNtfsFileTime *t = &db.MTime.Vals[i];
+ mtime.dwLowDateTime = (DWORD)(t->Low);
+ mtime.dwHighDateTime = (DWORD)(t->High);
+ mtimePtr = &mtime;
+ }
+
+ #ifdef USE_WINDOWS_FILE
+ if (SzBitWithVals_Check(&db.CTime, i))
+ {
+ const CNtfsFileTime *t = &db.CTime.Vals[i];
+ ctime.dwLowDateTime = (DWORD)(t->Low);
+ ctime.dwHighDateTime = (DWORD)(t->High);
+ ctimePtr = &ctime;
+ }
+
+ if (mtimePtr || ctimePtr)
+ SetFileTime(outFile.handle, ctimePtr, NULL, mtimePtr);
+ #endif
+
+ {
+ const WRes wres = File_Close(&outFile);
+ if (wres != 0)
+ {
+ PrintError_WRes("cannot close output file", wres);
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ }
+
+ #ifndef USE_WINDOWS_FILE
+ #ifdef _WIN32
+ mtimePtr = mtimePtr;
+ #else
+ if (mtimePtr)
+ Set_File_FILETIME(destPath, mtimePtr);
+ #endif
+ #endif
+ }
+
+ #ifdef USE_WINDOWS_FILE
+ if (SzBitWithVals_Check(&db.Attribs, i))
+ {
+ UInt32 attrib = db.Attribs.Vals[i];
+ /* p7zip stores posix attributes in high 16 bits and adds 0x8000 as marker.
+ We remove posix bits, if we detect posix mode field */
+ if ((attrib & 0xF0000000) != 0)
+ attrib &= 0x7FFF;
+ SetFileAttributesW((LPCWSTR)destPath, attrib);
+ }
+ #endif
+ }
+ PrintLF();
+ }
+ ISzAlloc_Free(&allocImp, outBuffer);
+ }
+ }
+
+ SzFree(NULL, temp);
+ SzArEx_Free(&db, &allocImp);
+ ISzAlloc_Free(&allocImp, lookStream.buf);
+
+ File_Close(&archiveStream.file);
+
+ if (res == SZ_OK)
+ {
+ Print("\nEverything is Ok\n");
+ return 0;
+ }
+
+ if (res == SZ_ERROR_UNSUPPORTED)
+ PrintError("decoder doesn't support this archive");
+ else if (res == SZ_ERROR_MEM)
+ PrintError("cannot allocate memory");
+ else if (res == SZ_ERROR_CRC)
+ PrintError("CRC error");
+ else if (res == SZ_ERROR_READ /* || archiveStream.Res != 0 */)
+ PrintError_WRes("Read Error", archiveStream.wres);
+ else
+ {
+ char s[32];
+ UInt64ToStr((unsigned)res, s, 0);
+ PrintError(s);
+ }
+
+ return 1;
+}
diff --git a/C/Util/7z/Precomp.c b/C/Util/7z/Precomp.c
index 34b60f8..01605e3 100644
--- a/C/Util/7z/Precomp.c
+++ b/C/Util/7z/Precomp.c
@@ -1,4 +1,4 @@
-/* Precomp.c -- StdAfx
-2013-01-21 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
+/* Precomp.c -- StdAfx
+2013-01-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
diff --git a/C/Util/7z/Precomp.h b/C/Util/7z/Precomp.h
index 9f398d0..bc8fa21 100644
--- a/C/Util/7z/Precomp.h
+++ b/C/Util/7z/Precomp.h
@@ -1,10 +1,14 @@
-/* Precomp.h -- StdAfx
-2013-06-16 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_PRECOMP_H
-#define __7Z_PRECOMP_H
-
-#include "../../Compiler.h"
-#include "../../7zTypes.h"
-
-#endif
+/* Precomp.h -- StdAfx
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_PRECOMP_H
+#define ZIP7_INC_PRECOMP_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../Compiler.h"
+#include "../../7zTypes.h"
+
+#endif
diff --git a/C/Util/7z/makefile b/C/Util/7z/makefile
index f4a54af..dfc560e 100644
--- a/C/Util/7z/makefile
+++ b/C/Util/7z/makefile
@@ -1,40 +1,40 @@
-CFLAGS = $(CFLAGS) -D_7ZIP_PPMD_SUPPPORT
-
-PROG = 7zDec.exe
-
-C_OBJS = \
- $O\7zAlloc.obj \
- $O\7zBuf.obj \
- $O\7zCrc.obj \
- $O\7zCrcOpt.obj \
- $O\7zFile.obj \
- $O\7zDec.obj \
- $O\7zArcIn.obj \
- $O\7zStream.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\Lzma2Dec.obj \
- $O\LzmaDec.obj \
- $O\Ppmd7.obj \
- $O\Ppmd7Dec.obj \
-
-7Z_OBJS = \
- $O\7zMain.obj \
-
-OBJS = \
- $O\Precomp.obj \
- $(7Z_OBJS) \
- $(C_OBJS) \
-
-!include "../../../CPP/Build.mak"
-
-$(7Z_OBJS): $(*B).c
- $(CCOMPL_USE)
-$(C_OBJS): ../../$(*B).c
- $(CCOMPL_USE)
-$O\Precomp.obj: Precomp.c
- $(CCOMPL_PCH)
+CFLAGS = $(CFLAGS) -DZ7_PPMD_SUPPORT -DZ7_EXTRACT_ONLY
+
+PROG = 7zDec.exe
+
+C_OBJS = \
+ $O\7zAlloc.obj \
+ $O\7zBuf.obj \
+ $O\7zCrc.obj \
+ $O\7zCrcOpt.obj \
+ $O\7zFile.obj \
+ $O\7zDec.obj \
+ $O\7zArcIn.obj \
+ $O\7zStream.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\Lzma2Dec.obj \
+ $O\LzmaDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+
+7Z_OBJS = \
+ $O\7zMain.obj \
+
+OBJS = \
+ $O\Precomp.obj \
+ $(7Z_OBJS) \
+ $(C_OBJS) \
+
+!include "../../../CPP/Build.mak"
+
+$(7Z_OBJS): $(*B).c
+ $(CCOMPL_USE)
+$(C_OBJS): ../../$(*B).c
+ $(CCOMPL_USE)
+$O\Precomp.obj: Precomp.c
+ $(CCOMPL_PCH)
diff --git a/C/Util/7z/makefile.gcc b/C/Util/7z/makefile.gcc
index f707935..f48d362 100644
--- a/C/Util/7z/makefile.gcc
+++ b/C/Util/7z/makefile.gcc
@@ -1,75 +1,32 @@
-PROG = 7zDec
-CXX = gcc
-LIB =
-RM = rm -f
-CFLAGS = -c -O2 -Wall
-
-OBJS = 7zMain.o 7zAlloc.o 7zArcIn.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zCrcOpt.o 7zDec.o CpuArch.o Delta.o LzmaDec.o Lzma2Dec.o Bra.o Bra86.o BraIA64.o Bcj2.o Ppmd7.o Ppmd7Dec.o 7zFile.o 7zStream.o
-
-all: $(PROG)
-
-$(PROG): $(OBJS)
- $(CXX) -o $(PROG) $(LDFLAGS) $(OBJS) $(LIB)
-
-7zMain.o: 7zMain.c
- $(CXX) $(CFLAGS) 7zMain.c
-
-7zAlloc.o: ../../7zAlloc.c
- $(CXX) $(CFLAGS) ../../7zAlloc.c
-
-7zArcIn.o: ../../7zArcIn.c
- $(CXX) $(CFLAGS) ../../7zArcIn.c
-
-7zBuf.o: ../../7zBuf.c
- $(CXX) $(CFLAGS) ../../7zBuf.c
-
-7zBuf2.o: ../../7zBuf2.c
- $(CXX) $(CFLAGS) ../../7zBuf2.c
-
-7zCrc.o: ../../7zCrc.c
- $(CXX) $(CFLAGS) ../../7zCrc.c
-
-7zCrcOpt.o: ../../7zCrc.c
- $(CXX) $(CFLAGS) ../../7zCrcOpt.c
-
-7zDec.o: ../../7zDec.c
- $(CXX) $(CFLAGS) -D_7ZIP_PPMD_SUPPPORT ../../7zDec.c
-
-CpuArch.o: ../../CpuArch.c
- $(CXX) $(CFLAGS) ../../CpuArch.c
-
-Delta.o: ../../Delta.c
- $(CXX) $(CFLAGS) ../../Delta.c
-
-LzmaDec.o: ../../LzmaDec.c
- $(CXX) $(CFLAGS) ../../LzmaDec.c
-
-Lzma2Dec.o: ../../Lzma2Dec.c
- $(CXX) $(CFLAGS) ../../Lzma2Dec.c
-
-Bra.o: ../../Bra.c
- $(CXX) $(CFLAGS) ../../Bra.c
-
-Bra86.o: ../../Bra86.c
- $(CXX) $(CFLAGS) ../../Bra86.c
-
-BraIA64.o: ../../BraIA64.c
- $(CXX) $(CFLAGS) ../../BraIA64.c
-
-Bcj2.o: ../../Bcj2.c
- $(CXX) $(CFLAGS) ../../Bcj2.c
-
-Ppmd7.o: ../../Ppmd7.c
- $(CXX) $(CFLAGS) ../../Ppmd7.c
-
-Ppmd7Dec.o: ../../Ppmd7Dec.c
- $(CXX) $(CFLAGS) ../../Ppmd7Dec.c
-
-7zFile.o: ../../7zFile.c
- $(CXX) $(CFLAGS) ../../7zFile.c
-
-7zStream.o: ../../7zStream.c
- $(CXX) $(CFLAGS) ../../7zStream.c
-
-clean:
- -$(RM) $(PROG) $(OBJS)
+PROG = 7zdec
+
+LOCAL_FLAGS = -DZ7_PPMD_SUPPORT -DZ7_EXTRACT_ONLY
+
+include ../../../CPP/7zip/LzmaDec_gcc.mak
+
+
+OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $O/Bcj2.o \
+ $O/Bra.o \
+ $O/Bra86.o \
+ $O/BraIA64.o \
+ $O/CpuArch.o \
+ $O/Delta.o \
+ $O/Lzma2Dec.o \
+ $O/LzmaDec.o \
+ $O/Ppmd7.o \
+ $O/Ppmd7Dec.o \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+ $O/7zAlloc.o \
+ $O/7zArcIn.o \
+ $O/7zBuf.o \
+ $O/7zBuf2.o \
+ $O/7zDec.o \
+ $O/7zMain.o \
+ $O/7zFile.o \
+ $O/7zStream.o \
+
+
+include ../../7zip_gcc_c.mak
diff --git a/C/Util/7zipInstall/7zip.ico b/C/Util/7zipInstall/7zip.ico
new file mode 100644
index 0000000..47ffb78
--- /dev/null
+++ b/C/Util/7zipInstall/7zip.ico
Binary files differ
diff --git a/C/Util/7zipInstall/7zipInstall.c b/C/Util/7zipInstall/7zipInstall.c
new file mode 100644
index 0000000..7f5fd19
--- /dev/null
+++ b/C/Util/7zipInstall/7zipInstall.c
@@ -0,0 +1,1699 @@
+/* 7zipInstall.c - 7-Zip Installer
+2023-04-04 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#define SZ_ERROR_ABORT 100
+
+#include "../../7zWindows.h"
+
+#if defined(_MSC_VER) && _MSC_VER < 1600
+#pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union
+#endif
+
+#ifdef Z7_OLD_WIN_SDK
+struct IShellView;
+#define SHFOLDERAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
+SHFOLDERAPI SHGetFolderPathW(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
+#define BIF_NEWDIALOGSTYLE 0x0040 // Use the new dialog layout with the ability to resize
+typedef enum {
+ SHGFP_TYPE_CURRENT = 0, // current value for user, verify it exists
+ SHGFP_TYPE_DEFAULT = 1, // default value, may not exist
+} SHGFP_TYPE;
+#endif
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#include "../../7z.h"
+#include "../../7zAlloc.h"
+#include "../../7zCrc.h"
+#include "../../7zFile.h"
+#include "../../7zVersion.h"
+#include "../../CpuArch.h"
+#include "../../DllSecur.h"
+
+#include "resource.h"
+
+#if (defined(__GNUC__) && (__GNUC__ >= 8)) || defined(__clang__)
+ // #pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
+
+#if defined(__clang__) || defined(__GNUC__)
+typedef void (*Z7_voidFunction)(void);
+#define MY_CAST_FUNC (Z7_voidFunction)
+#elif defined(_MSC_VER) && _MSC_VER > 1920
+#define MY_CAST_FUNC (void *)
+// #pragma warning(disable : 4191) // 'type cast': unsafe conversion from 'FARPROC' to 'void (__cdecl *)()'
+#else
+#define MY_CAST_FUNC
+#endif
+
+#define LLL_(quote) L##quote
+#define LLL(quote) LLL_(quote)
+
+#define wcscat lstrcatW
+#define wcslen (size_t)lstrlenW
+#define wcscpy lstrcpyW
+// wcsncpy() and lstrcpynW() work differently. We don't use them.
+
+#define kInputBufSize ((size_t)1 << 18)
+
+#define Z7_7ZIP_CUR_VER ((MY_VER_MAJOR << 16) | MY_VER_MINOR)
+#define Z7_7ZIP_DLL_VER_COMPAT ((16 << 16) | 3)
+
+static LPCSTR const k_7zip = "7-Zip";
+
+static LPCWSTR const k_Reg_Software_7zip = L"Software\\7-Zip";
+
+// #define Z7_64BIT_INSTALLER 1
+
+#ifdef _WIN64
+ #define Z7_64BIT_INSTALLER 1
+#endif
+
+#define k_7zip_with_Ver_base L"7-Zip " LLL(MY_VERSION)
+
+#ifdef Z7_64BIT_INSTALLER
+
+ // #define USE_7ZIP_32_DLL
+
+ #if defined(_M_ARM64) || defined(_M_ARM)
+ #define k_Postfix L" (arm64)"
+ #else
+ #define k_Postfix L" (x64)"
+ #define USE_7ZIP_32_DLL
+ #endif
+#else
+ #if defined(_M_ARM64) || defined(_M_ARM)
+ #define k_Postfix L" (arm)"
+ #else
+ // #define k_Postfix L" (x86)"
+ #define k_Postfix
+ #endif
+#endif
+
+#define k_7zip_with_Ver k_7zip_with_Ver_base k_Postfix
+
+
+static LPCWSTR const k_7zip_with_Ver_str = k_7zip_with_Ver;
+
+static LPCWSTR const k_7zip_Setup = k_7zip_with_Ver L" Setup";
+
+static LPCWSTR const k_Reg_Path = L"Path";
+
+static LPCWSTR const k_Reg_Path32 = L"Path"
+ #ifdef Z7_64BIT_INSTALLER
+ L"64"
+ #else
+ L"32"
+ #endif
+ ;
+
+#if defined(Z7_64BIT_INSTALLER) && !defined(_WIN64)
+ #define k_Reg_WOW_Flag KEY_WOW64_64KEY
+#else
+ #define k_Reg_WOW_Flag 0
+#endif
+
+#ifdef _WIN64
+ #define k_Reg_WOW_Flag_32 KEY_WOW64_32KEY
+#else
+ #define k_Reg_WOW_Flag_32 0
+#endif
+
+#define k_7zip_CLSID L"{23170F69-40C1-278A-1000-000100020000}"
+
+static LPCWSTR const k_Reg_CLSID_7zip = L"CLSID\\" k_7zip_CLSID;
+static LPCWSTR const k_Reg_CLSID_7zip_Inproc = L"CLSID\\" k_7zip_CLSID L"\\InprocServer32";
+
+#define g_AllUsers True
+
+static BoolInt g_Install_was_Pressed;
+static BoolInt g_Finished;
+static BoolInt g_SilentMode;
+
+static HWND g_HWND;
+static HWND g_Path_HWND;
+static HWND g_InfoLine_HWND;
+static HWND g_Progress_HWND;
+
+static DWORD g_TotalSize;
+
+static WCHAR cmd[MAX_PATH + 4];
+static WCHAR cmdError[MAX_PATH + 4];
+static WCHAR path[MAX_PATH * 2 + 40];
+
+
+
+static void CpyAscii(wchar_t *dest, const char *s)
+{
+ for (;;)
+ {
+ Byte b = (Byte)*s++;
+ *dest++ = b;
+ if (b == 0)
+ return;
+ }
+}
+
+static void CatAscii(wchar_t *dest, const char *s)
+{
+ dest += wcslen(dest);
+ CpyAscii(dest, s);
+}
+
+static void PrintErrorMessage(const char *s1, const wchar_t *s2)
+{
+ WCHAR m[MAX_PATH + 512];
+ m[0] = 0;
+ CatAscii(m, "ERROR:");
+ if (s1)
+ {
+ CatAscii(m, "\n");
+ CatAscii(m, s1);
+ }
+ if (s2)
+ {
+ CatAscii(m, "\n");
+ wcscat(m, s2);
+ }
+ MessageBoxW(g_HWND, m, k_7zip_with_Ver_str, MB_ICONERROR | MB_OK);
+}
+
+
+typedef DWORD (WINAPI * Func_GetFileVersionInfoSizeW)(LPCWSTR lptstrFilename, LPDWORD lpdwHandle);
+typedef BOOL (WINAPI * Func_GetFileVersionInfoW)(LPCWSTR lptstrFilename, DWORD dwHandle, DWORD dwLen, LPVOID lpData);
+typedef BOOL (WINAPI * Func_VerQueryValueW)(const LPVOID pBlock, LPWSTR lpSubBlock, LPVOID * lplpBuffer, PUINT puLen);
+
+static HMODULE g_version_dll_hModule;
+
+static DWORD GetFileVersion(LPCWSTR s)
+{
+ DWORD size = 0;
+ void *vi = NULL;
+ DWORD version = 0;
+
+ Func_GetFileVersionInfoSizeW my_GetFileVersionInfoSizeW;
+ Func_GetFileVersionInfoW my_GetFileVersionInfoW;
+ Func_VerQueryValueW my_VerQueryValueW;
+
+ if (!g_version_dll_hModule)
+ {
+ wchar_t buf[MAX_PATH + 100];
+ {
+ unsigned len = GetSystemDirectoryW(buf, MAX_PATH + 2);
+ if (len == 0 || len > MAX_PATH)
+ return 0;
+ }
+ {
+ unsigned pos = (unsigned)lstrlenW(buf);
+ if (buf[pos - 1] != '\\')
+ buf[pos++] = '\\';
+ lstrcpyW(buf + pos, L"version.dll");
+ }
+ g_version_dll_hModule = LoadLibraryW(buf);
+ if (!g_version_dll_hModule)
+ return 0;
+ }
+
+ my_GetFileVersionInfoSizeW = (Func_GetFileVersionInfoSizeW) MY_CAST_FUNC GetProcAddress(g_version_dll_hModule,
+ "GetFileVersionInfoSizeW");
+ my_GetFileVersionInfoW = (Func_GetFileVersionInfoW) MY_CAST_FUNC GetProcAddress(g_version_dll_hModule,
+ "GetFileVersionInfoW");
+ my_VerQueryValueW = (Func_VerQueryValueW) MY_CAST_FUNC GetProcAddress(g_version_dll_hModule,
+ "VerQueryValueW");
+
+ if (!my_GetFileVersionInfoSizeW
+ || !my_GetFileVersionInfoW
+ || !my_VerQueryValueW)
+ return 0;
+
+ size = my_GetFileVersionInfoSizeW(s, NULL);
+ if (size == 0)
+ return 0;
+
+ vi = malloc(size);
+ if (!vi)
+ return 0;
+
+ if (my_GetFileVersionInfoW(s, 0, size, vi))
+ {
+ VS_FIXEDFILEINFO *fi = NULL;
+ UINT fiLen = 0;
+ if (my_VerQueryValueW(vi, L"\\", (LPVOID *)&fi, &fiLen))
+ version = fi->dwFileVersionMS;
+ }
+
+ free(vi);
+ return version;
+}
+
+
+static WRes MyCreateDir(LPCWSTR name)
+{
+ return CreateDirectoryW(name, NULL) ? 0 : GetLastError();
+}
+
+#define IS_SEPAR(c) (c == WCHAR_PATH_SEPARATOR)
+#define IS_LETTER_CHAR(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
+#define IS_DRIVE_PATH(s) (IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]))
+
+static int ReverseFind_PathSepar(const wchar_t *s)
+{
+ int separ = -1;
+ int i;
+ for (i = 0;; i++)
+ {
+ wchar_t c = s[i];
+ if (c == 0)
+ return separ;
+ if (IS_SEPAR(c))
+ separ = i;
+ }
+}
+
+static WRes CreateComplexDir(void)
+{
+ WCHAR s[MAX_PATH + 10];
+
+ unsigned prefixSize = 0;
+ WRes wres;
+
+ {
+ size_t len = wcslen(path);
+ if (len > MAX_PATH)
+ return ERROR_INVALID_NAME;
+ wcscpy(s, path);
+ }
+
+ if (IS_DRIVE_PATH(s))
+ prefixSize = 3;
+ else if (IS_SEPAR(s[0]) && IS_SEPAR(s[1]))
+ prefixSize = 2;
+ else
+ return ERROR_INVALID_NAME;
+
+ {
+ DWORD attrib = GetFileAttributesW(s);
+ if (attrib != INVALID_FILE_ATTRIBUTES)
+ return (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 ? 0 : ERROR_ALREADY_EXISTS;
+ }
+
+ wres = MyCreateDir(s);
+ if (wres == 0 || wres == ERROR_ALREADY_EXISTS)
+ return 0;
+
+ {
+ size_t len = wcslen(s);
+ {
+ const int pos = ReverseFind_PathSepar(s);
+ if (pos < 0)
+ return wres;
+ if ((unsigned)pos < prefixSize)
+ return wres;
+ if ((unsigned)pos == len - 1)
+ {
+ if (len == 1)
+ return 0;
+ s[pos] = 0;
+ len = (unsigned)pos;
+ }
+ }
+
+ for (;;)
+ {
+ int pos;
+ wres = MyCreateDir(s);
+ if (wres == 0)
+ break;
+ if (wres == ERROR_ALREADY_EXISTS)
+ {
+ const DWORD attrib = GetFileAttributesW(s);
+ if (attrib != INVALID_FILE_ATTRIBUTES)
+ if ((attrib & FILE_ATTRIBUTE_DIRECTORY) == 0)
+ return ERROR_ALREADY_EXISTS;
+ break;
+ }
+ pos = ReverseFind_PathSepar(s);
+ if (pos < 0 || pos == 0 || (unsigned)pos < prefixSize)
+ return wres;
+ s[pos] = 0;
+ }
+
+ for (;;)
+ {
+ const size_t pos = wcslen(s);
+ if (pos >= len)
+ return 0;
+ s[pos] = CHAR_PATH_SEPARATOR;
+ wres = MyCreateDir(s);
+ if (wres != 0)
+ return wres;
+ }
+ }
+}
+
+
+static int MyRegistry_QueryString(HKEY hKey, LPCWSTR name, LPWSTR dest)
+{
+ DWORD cnt = MAX_PATH * sizeof(name[0]);
+ DWORD type = 0;
+ const LONG res = RegQueryValueExW(hKey, name, NULL, &type, (LPBYTE)dest, &cnt);
+ if (type != REG_SZ)
+ return False;
+ return res == ERROR_SUCCESS;
+}
+
+static int MyRegistry_QueryString2(HKEY hKey, LPCWSTR keyName, LPCWSTR valName, LPWSTR dest)
+{
+ HKEY key = 0;
+ const LONG res = RegOpenKeyExW(hKey, keyName, 0, KEY_READ | k_Reg_WOW_Flag, &key);
+ if (res != ERROR_SUCCESS)
+ return False;
+ {
+ const BoolInt res2 = MyRegistry_QueryString(key, valName, dest);
+ RegCloseKey(key);
+ return res2;
+ }
+}
+
+static LONG MyRegistry_SetString(HKEY hKey, LPCWSTR name, LPCWSTR val)
+{
+ return RegSetValueExW(hKey, name, 0, REG_SZ,
+ (const BYTE *)val, (DWORD)(wcslen(val) + 1) * sizeof(val[0]));
+}
+
+static LONG MyRegistry_SetDWORD(HKEY hKey, LPCWSTR name, DWORD val)
+{
+ return RegSetValueExW(hKey, name, 0, REG_DWORD, (const BYTE *)&val, sizeof(DWORD));
+}
+
+
+static LONG MyRegistry_CreateKey(HKEY parentKey, LPCWSTR name, HKEY *destKey)
+{
+ return RegCreateKeyExW(parentKey, name, 0, NULL,
+ REG_OPTION_NON_VOLATILE,
+ KEY_ALL_ACCESS | k_Reg_WOW_Flag,
+ NULL, destKey, NULL);
+}
+
+static LONG MyRegistry_CreateKeyAndVal(HKEY parentKey, LPCWSTR keyName, LPCWSTR valName, LPCWSTR val)
+{
+ HKEY destKey = 0;
+ LONG res = MyRegistry_CreateKey(parentKey, keyName, &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ res = MyRegistry_SetString(destKey, valName, val);
+ /* res = */ RegCloseKey(destKey);
+ }
+ return res;
+}
+
+
+#ifdef USE_7ZIP_32_DLL
+
+static LONG MyRegistry_CreateKey_32(HKEY parentKey, LPCWSTR name, HKEY *destKey)
+{
+ return RegCreateKeyExW(parentKey, name, 0, NULL,
+ REG_OPTION_NON_VOLATILE,
+ KEY_ALL_ACCESS | k_Reg_WOW_Flag_32,
+ NULL, destKey, NULL);
+}
+
+static LONG MyRegistry_CreateKeyAndVal_32(HKEY parentKey, LPCWSTR keyName, LPCWSTR valName, LPCWSTR val)
+{
+ HKEY destKey = 0;
+ LONG res = MyRegistry_CreateKey_32(parentKey, keyName, &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ res = MyRegistry_SetString(destKey, valName, val);
+ /* res = */ RegCloseKey(destKey);
+ }
+ return res;
+}
+
+#endif
+
+
+
+#ifdef UNDER_CE
+ #define kBufSize (1 << 13)
+#else
+ #define kBufSize (1 << 15)
+#endif
+
+#define kSignatureSearchLimit (1 << 22)
+
+static BoolInt FindSignature(CSzFile *stream, UInt64 *resPos)
+{
+ Byte buf[kBufSize];
+ size_t numPrevBytes = 0;
+ *resPos = 0;
+
+ for (;;)
+ {
+ size_t processed, pos;
+ if (*resPos > kSignatureSearchLimit)
+ return False;
+ processed = kBufSize - numPrevBytes;
+ if (File_Read(stream, buf + numPrevBytes, &processed) != 0)
+ return False;
+ processed += numPrevBytes;
+ if (processed < k7zStartHeaderSize ||
+ (processed == k7zStartHeaderSize && numPrevBytes != 0))
+ return False;
+ processed -= k7zStartHeaderSize;
+ for (pos = 0; pos <= processed; pos++)
+ {
+ for (; pos <= processed && buf[pos] != '7'; pos++);
+ if (pos > processed)
+ break;
+ if (memcmp(buf + pos, k7zSignature, k7zSignatureSize) == 0)
+ if (CrcCalc(buf + pos + 12, 20) == GetUi32(buf + pos + 8))
+ {
+ *resPos += pos;
+ return True;
+ }
+ }
+ *resPos += processed;
+ numPrevBytes = k7zStartHeaderSize;
+ memmove(buf, buf + processed, k7zStartHeaderSize);
+ }
+}
+
+static void HexToString(UInt32 val, WCHAR *s)
+{
+ UInt64 v = val;
+ unsigned i;
+ for (i = 1;; i++)
+ {
+ v >>= 4;
+ if (v == 0)
+ break;
+ }
+ s[i] = 0;
+ do
+ {
+ unsigned t = (unsigned)((val & 0xF));
+ val >>= 4;
+ s[--i] = (WCHAR)(unsigned)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+ }
+ while (i);
+}
+
+
+#ifndef UNDER_CE
+
+static int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lp, LPARAM data)
+{
+ UNUSED_VAR(lp)
+ UNUSED_VAR(data)
+ UNUSED_VAR(hwnd)
+
+ switch (uMsg)
+ {
+ case BFFM_INITIALIZED:
+ {
+ SendMessage(hwnd, BFFM_SETSELECTIONW, TRUE, data);
+ break;
+ }
+ case BFFM_SELCHANGED:
+ {
+ // show selected path for BIF_STATUSTEXT
+ WCHAR dir[MAX_PATH];
+ if (!SHGetPathFromIDListW((LPITEMIDLIST)lp, dir))
+ dir[0] = 0;
+ SendMessage(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)dir);
+ break;
+ }
+ default:
+ break;
+ }
+ return 0;
+}
+
+static BoolInt MyBrowseForFolder(HWND owner, LPCWSTR title, UINT ulFlags,
+ LPCWSTR initialFolder, LPWSTR resultPath)
+{
+ WCHAR displayName[MAX_PATH];
+ BROWSEINFOW browseInfo;
+
+ displayName[0] = 0;
+ browseInfo.hwndOwner = owner;
+ browseInfo.pidlRoot = NULL;
+
+ // there are Unicode/Astring problems in some WinCE SDK ?
+ browseInfo.pszDisplayName = displayName;
+ browseInfo.lpszTitle = title;
+ browseInfo.ulFlags = ulFlags;
+ browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc : NULL;
+ browseInfo.lParam = (LPARAM)initialFolder;
+ {
+ LPITEMIDLIST idlist = SHBrowseForFolderW(&browseInfo);
+ if (idlist)
+ {
+ SHGetPathFromIDListW(idlist, resultPath);
+ // free idlist
+ // CoTaskMemFree(idlist);
+ return True;
+ }
+ return False;
+ }
+}
+
+#endif
+
+static void NormalizePrefix(WCHAR *s)
+{
+ size_t i = 0;
+
+ for (;; i++)
+ {
+ const wchar_t c = s[i];
+ if (c == 0)
+ break;
+ if (c == '/')
+ s[i] = WCHAR_PATH_SEPARATOR;
+ }
+
+ if (i != 0 && s[i - 1] != WCHAR_PATH_SEPARATOR)
+ {
+ s[i] = WCHAR_PATH_SEPARATOR;
+ s[i + 1] = 0;
+ }
+}
+
+static char MyCharLower_Ascii(char c)
+{
+ if (c >= 'A' && c <= 'Z')
+ return (char)((unsigned char)c + 0x20);
+ return c;
+}
+
+static wchar_t MyWCharLower_Ascii(wchar_t c)
+{
+ if (c >= 'A' && c <= 'Z')
+ return (wchar_t)(c + 0x20);
+ return c;
+}
+
+static LPCWSTR FindSubString(LPCWSTR s1, const char *s2)
+{
+ for (;;)
+ {
+ unsigned i;
+ if (*s1 == 0)
+ return NULL;
+ for (i = 0;; i++)
+ {
+ const char b = s2[i];
+ if (b == 0)
+ return s1;
+ if (MyWCharLower_Ascii(s1[i]) != (Byte)MyCharLower_Ascii(b))
+ {
+ s1++;
+ break;
+ }
+ }
+ }
+}
+
+static void Set7zipPostfix(WCHAR *s)
+{
+ NormalizePrefix(s);
+ if (FindSubString(s, "7-Zip"))
+ return;
+ CatAscii(s, "7-Zip\\");
+}
+
+
+static int Install(void);
+
+static void OnClose(void)
+{
+ if (g_Install_was_Pressed && !g_Finished)
+ {
+ if (MessageBoxW(g_HWND,
+ L"Do you want to cancel " k_7zip_with_Ver L" installation?",
+ k_7zip_with_Ver,
+ MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2) != IDYES)
+ return;
+ }
+ DestroyWindow(g_HWND);
+ g_HWND = NULL;
+}
+
+static
+#ifdef Z7_OLD_WIN_SDK
+ BOOL
+#else
+ INT_PTR
+#endif
+CALLBACK MyDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ // UNUSED_VAR(hwnd)
+ UNUSED_VAR(lParam)
+
+ switch (message)
+ {
+ case WM_INITDIALOG:
+ g_Path_HWND = GetDlgItem(hwnd, IDE_EXTRACT_PATH);
+ g_InfoLine_HWND = GetDlgItem(hwnd, IDT_CUR_FILE);
+ g_Progress_HWND = GetDlgItem(hwnd, IDC_PROGRESS);
+
+ SetWindowTextW(hwnd, k_7zip_Setup);
+ SetDlgItemTextW(hwnd, IDE_EXTRACT_PATH, path);
+
+ ShowWindow(g_Progress_HWND, SW_HIDE);
+ ShowWindow(g_InfoLine_HWND, SW_HIDE);
+
+ break;
+
+ case WM_COMMAND:
+ switch (LOWORD(wParam))
+ {
+ case IDOK:
+ {
+ if (g_Finished)
+ {
+ OnClose();
+ break;
+ }
+ if (!g_Install_was_Pressed)
+ {
+ SendMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)(void *)GetDlgItem(hwnd, IDCANCEL), TRUE);
+
+ EnableWindow(g_Path_HWND, FALSE);
+ EnableWindow(GetDlgItem(hwnd, IDB_EXTRACT_SET_PATH), FALSE);
+ EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
+
+ g_Install_was_Pressed = True;
+ return TRUE;
+ }
+ break;
+ }
+
+ case IDCANCEL:
+ {
+ OnClose();
+ break;
+ }
+
+ case IDB_EXTRACT_SET_PATH:
+ {
+ #ifndef UNDER_CE
+
+ WCHAR s[MAX_PATH];
+ WCHAR s2[MAX_PATH];
+ GetDlgItemTextW(hwnd, IDE_EXTRACT_PATH, s, MAX_PATH);
+ if (MyBrowseForFolder(hwnd, L"Select the folder for installation:" ,
+ 0
+ | BIF_NEWDIALOGSTYLE // 5.0 of ?.dll ?
+ | BIF_RETURNONLYFSDIRS
+ // | BIF_STATUSTEXT // doesn't work for BIF_NEWDIALOGSTYLE
+ , s, s2))
+ {
+ Set7zipPostfix(s2);
+ SetDlgItemTextW(hwnd, IDE_EXTRACT_PATH, s2);
+ }
+
+ #endif
+ break;
+ }
+
+ default: return FALSE;
+ }
+ break;
+
+ case WM_CLOSE:
+ OnClose();
+ break;
+ /*
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ return TRUE;
+ */
+ default:
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+
+static LONG SetRegKey_Path2(HKEY parentKey)
+{
+ HKEY destKey = 0;
+ LONG res = MyRegistry_CreateKey(parentKey, k_Reg_Software_7zip, &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ res = MyRegistry_SetString(destKey, k_Reg_Path32, path);
+ /* res = */ MyRegistry_SetString(destKey, k_Reg_Path, path);
+ /* res = */ RegCloseKey(destKey);
+ }
+ return res;
+}
+
+static void SetRegKey_Path(void)
+{
+ SetRegKey_Path2(HKEY_CURRENT_USER);
+ SetRegKey_Path2(HKEY_LOCAL_MACHINE);
+}
+
+
+static HRESULT CreateShellLink(LPCWSTR srcPath, LPCWSTR targetPath)
+{
+ IShellLinkW* sl;
+
+ // CoInitialize has already been called.
+ HRESULT hres = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (LPVOID*)&sl);
+
+ if (SUCCEEDED(hres))
+ {
+ IPersistFile* pf;
+
+ sl->lpVtbl->SetPath(sl, targetPath);
+ // sl->lpVtbl->SetDescription(sl, description);
+ hres = sl->lpVtbl->QueryInterface(sl, &IID_IPersistFile, (LPVOID*)&pf);
+
+ if (SUCCEEDED(hres))
+ {
+ hres = pf->lpVtbl->Save(pf, srcPath, TRUE);
+ pf->lpVtbl->Release(pf);
+ }
+ sl->lpVtbl->Release(sl);
+ }
+
+ return hres;
+}
+
+static void SetShellProgramsGroup(HWND hwndOwner)
+{
+ #ifdef UNDER_CE
+
+ // CpyAscii(link, "\\Program Files\\");
+ UNUSED_VAR(hwndOwner)
+
+ #else
+
+ unsigned i = (g_AllUsers ? 0 : 2);
+
+ for (; i < 3; i++)
+ {
+ BoolInt isOK = True;
+ WCHAR link[MAX_PATH + 40];
+ WCHAR destPath[MAX_PATH + 40];
+
+ link[0] = 0;
+
+ if (SHGetFolderPathW(hwndOwner,
+ i == 1 ? CSIDL_COMMON_PROGRAMS : CSIDL_PROGRAMS,
+ NULL, SHGFP_TYPE_CURRENT, link) != S_OK)
+ continue;
+
+ NormalizePrefix(link);
+ CatAscii(link, k_7zip);
+ // CatAscii(link, "2");
+
+ if (i != 0)
+ MyCreateDir(link);
+
+ NormalizePrefix(link);
+
+ {
+ unsigned baseLen = (unsigned)wcslen(link);
+ unsigned k;
+
+ for (k = 0; k < 2; k++)
+ {
+ CpyAscii(link + baseLen, k == 0 ?
+ "7-Zip File Manager.lnk" :
+ "7-Zip Help.lnk"
+ );
+ wcscpy(destPath, path);
+ CatAscii(destPath, k == 0 ?
+ "7zFM.exe" :
+ "7-zip.chm");
+
+ if (i == 0)
+ DeleteFileW(link);
+ else if (CreateShellLink(link, destPath) != S_OK)
+ isOK = False;
+ }
+ }
+
+ if (i != 0 && isOK)
+ break;
+ }
+
+ #endif
+}
+
+static LPCWSTR const k_Shell_Approved = L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved";
+static LPCWSTR const k_7zip_ShellExtension = L"7-Zip Shell Extension";
+
+static void WriteCLSID(void)
+{
+ HKEY destKey;
+ LONG res;
+
+ #ifdef USE_7ZIP_32_DLL
+
+ MyRegistry_CreateKeyAndVal_32(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip, NULL, k_7zip_ShellExtension);
+
+ res = MyRegistry_CreateKey_32(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip_Inproc, &destKey);
+
+ if (res == ERROR_SUCCESS)
+ {
+ WCHAR destPath[MAX_PATH + 40];
+ wcscpy(destPath, path);
+ CatAscii(destPath, "7-zip32.dll");
+ /* res = */ MyRegistry_SetString(destKey, NULL, destPath);
+ /* res = */ MyRegistry_SetString(destKey, L"ThreadingModel", L"Apartment");
+ // DeleteRegValue(destKey, L"InprocServer32");
+ /* res = */ RegCloseKey(destKey);
+ }
+
+ #endif
+
+
+ MyRegistry_CreateKeyAndVal(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip, NULL, k_7zip_ShellExtension);
+
+ destKey = 0;
+ res = MyRegistry_CreateKey(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip_Inproc, &destKey);
+
+ if (res == ERROR_SUCCESS)
+ {
+ WCHAR destPath[MAX_PATH + 40];
+ wcscpy(destPath, path);
+ CatAscii(destPath, "7-zip.dll");
+ /* res = */ MyRegistry_SetString(destKey, NULL, destPath);
+ /* res = */ MyRegistry_SetString(destKey, L"ThreadingModel", L"Apartment");
+ // DeleteRegValue(destKey, L"InprocServer32");
+ /* res = */ RegCloseKey(destKey);
+ }
+}
+
+static LPCSTR const k_ShellEx_Items[] =
+{
+ "*\\shellex\\ContextMenuHandlers"
+ , "Directory\\shellex\\ContextMenuHandlers"
+ , "Folder\\shellex\\ContextMenuHandlers"
+ , "Directory\\shellex\\DragDropHandlers"
+ , "Drive\\shellex\\DragDropHandlers"
+};
+
+static void WriteShellEx(void)
+{
+ unsigned i;
+ WCHAR destPath[MAX_PATH + 40];
+
+ for (i = 0; i < Z7_ARRAY_SIZE(k_ShellEx_Items); i++)
+ {
+ CpyAscii(destPath, k_ShellEx_Items[i]);
+ CatAscii(destPath, "\\7-Zip");
+
+ #ifdef USE_7ZIP_32_DLL
+ MyRegistry_CreateKeyAndVal_32(HKEY_CLASSES_ROOT, destPath, NULL, k_7zip_CLSID);
+ #endif
+ MyRegistry_CreateKeyAndVal (HKEY_CLASSES_ROOT, destPath, NULL, k_7zip_CLSID);
+ }
+
+ #ifdef USE_7ZIP_32_DLL
+ MyRegistry_CreateKeyAndVal_32(HKEY_LOCAL_MACHINE, k_Shell_Approved, k_7zip_CLSID, k_7zip_ShellExtension);
+ #endif
+ MyRegistry_CreateKeyAndVal (HKEY_LOCAL_MACHINE, k_Shell_Approved, k_7zip_CLSID, k_7zip_ShellExtension);
+
+
+ wcscpy(destPath, path);
+ CatAscii(destPath, "7zFM.exe");
+
+ {
+ HKEY destKey = 0;
+ LONG res = MyRegistry_CreateKey(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\7zFM.exe", &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ MyRegistry_SetString(destKey, NULL, destPath);
+ MyRegistry_SetString(destKey, L"Path", path);
+ RegCloseKey(destKey);
+ }
+
+ }
+
+ {
+ HKEY destKey = 0;
+ LONG res = MyRegistry_CreateKey(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\7-Zip", &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ MyRegistry_SetString(destKey, L"DisplayName", k_7zip_with_Ver_str);
+ MyRegistry_SetString(destKey, L"DisplayVersion", LLL(MY_VERSION_NUMBERS));
+ MyRegistry_SetString(destKey, L"DisplayIcon", destPath);
+ MyRegistry_SetString(destKey, L"InstallLocation", path);
+
+ destPath[0] = '\"';
+ wcscpy(destPath + 1, path);
+ CatAscii(destPath, "Uninstall.exe\"");
+ MyRegistry_SetString(destKey, L"UninstallString", destPath);
+
+ CatAscii(destPath, " /S");
+ MyRegistry_SetString(destKey, L"QuietUninstallString", destPath);
+
+ MyRegistry_SetDWORD(destKey, L"NoModify", 1);
+ MyRegistry_SetDWORD(destKey, L"NoRepair", 1);
+
+ MyRegistry_SetDWORD(destKey, L"EstimatedSize", g_TotalSize >> 10);
+
+ MyRegistry_SetDWORD(destKey, L"VersionMajor", MY_VER_MAJOR);
+ MyRegistry_SetDWORD(destKey, L"VersionMinor", MY_VER_MINOR);
+
+ MyRegistry_SetString(destKey, L"Publisher", LLL(MY_AUTHOR_NAME));
+
+ // MyRegistry_SetString(destKey, L"HelpLink", L"http://www.7-zip.org/support.html");
+ // MyRegistry_SetString(destKey, L"URLInfoAbout", L"http://www.7-zip.org/");
+ // MyRegistry_SetString(destKey, L"URLUpdateInfo", L"http://www.7-zip.org/");
+
+ RegCloseKey(destKey);
+ }
+ }
+}
+
+
+static const wchar_t *GetCmdParam(const wchar_t *s)
+{
+ unsigned pos = 0;
+ BoolInt quoteMode = False;
+ for (;; s++)
+ {
+ wchar_t c = *s;
+ if (c == 0 || (c == L' ' && !quoteMode))
+ break;
+ if (c == L'\"')
+ {
+ quoteMode = !quoteMode;
+ continue;
+ }
+ if (pos >= Z7_ARRAY_SIZE(cmd) - 1)
+ exit(1);
+ cmd[pos++] = c;
+ }
+ cmd[pos] = 0;
+ return s;
+}
+
+
+static void RemoveQuotes(wchar_t *s)
+{
+ const wchar_t *src = s;
+ for (;;)
+ {
+ wchar_t c = *src++;
+ if (c == '\"')
+ continue;
+ *s++ = c;
+ if (c == 0)
+ return;
+ }
+}
+
+// #define IS_LIMIT_CHAR(c) (c == 0 || c == ' ')
+
+
+typedef BOOL (WINAPI *Func_IsWow64Process)(HANDLE, PBOOL);
+
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ lpCmdLine, int nCmdShow)
+{
+
+ UNUSED_VAR(hPrevInstance)
+ UNUSED_VAR(lpCmdLine)
+ UNUSED_VAR(nCmdShow)
+
+ #ifndef UNDER_CE
+ LoadSecurityDlls();
+ CoInitialize(NULL);
+ #endif
+
+ CrcGenerateTable();
+
+ {
+ const wchar_t *s = GetCommandLineW();
+
+ #ifndef UNDER_CE
+ s = GetCmdParam(s);
+ #endif
+
+ for (;;)
+ {
+ {
+ const wchar_t c = *s;
+ if (c == 0)
+ break;
+ if (c == ' ')
+ {
+ s++;
+ continue;
+ }
+ }
+
+ {
+ const wchar_t *s2 = GetCmdParam(s);
+ BoolInt error = True;
+ if (cmd[0] == '/')
+ {
+ if (cmd[1] == 'S')
+ {
+ if (cmd[2] == 0)
+ {
+ g_SilentMode = True;
+ error = False;
+ }
+ }
+ else if (cmd[1] == 'D' && cmd[2] == '=')
+ {
+ wcscpy(path, cmd + 3);
+ // RemoveQuotes(path);
+ error = False;
+ }
+ }
+ s = s2;
+ if (error && cmdError[0] == 0)
+ wcscpy(cmdError, cmd);
+ }
+ }
+
+ if (cmdError[0] != 0)
+ {
+ if (!g_SilentMode)
+ PrintErrorMessage("Unsupported command:", cmdError);
+ return 1;
+ }
+ }
+
+ #if defined(Z7_64BIT_INSTALLER) && !defined(_WIN64)
+ {
+ BOOL isWow64 = FALSE;
+ const Func_IsWow64Process func_IsWow64Process = (Func_IsWow64Process)
+ MY_CAST_FUNC GetProcAddress(GetModuleHandleW(L"kernel32.dll"),
+ "IsWow64Process");
+
+ if (func_IsWow64Process)
+ func_IsWow64Process(GetCurrentProcess(), &isWow64);
+
+ if (!isWow64)
+ {
+ if (!g_SilentMode)
+ PrintErrorMessage("This installation requires Windows " MY_CPU_NAME, NULL);
+ return 1;
+ }
+ }
+ #endif
+
+
+ if (path[0] == 0)
+ {
+ HKEY key = 0;
+ BoolInt ok = False;
+ const LONG res = RegOpenKeyExW(HKEY_CURRENT_USER, k_Reg_Software_7zip, 0, KEY_READ | k_Reg_WOW_Flag, &key);
+ if (res == ERROR_SUCCESS)
+ {
+ ok = MyRegistry_QueryString(key, k_Reg_Path32, path);
+ // ok = MyRegistry_QueryString(key, k_Reg_Path, path);
+ RegCloseKey(key);
+ }
+
+ // ok = False;
+ if (!ok)
+ {
+ /*
+ #ifdef UNDER_CE
+ CpyAscii(path, "\\Program Files\\");
+ #else
+
+ #ifdef Z7_64BIT_INSTALLER
+ {
+ DWORD ttt = GetEnvironmentVariableW(L"ProgramW6432", path, MAX_PATH);
+ if (ttt == 0 || ttt > MAX_PATH)
+ CpyAscii(path, "C:\\");
+ }
+ #else
+ if (!SHGetSpecialFolderPathW(0, path, CSIDL_PROGRAM_FILES, FALSE))
+ CpyAscii(path, "C:\\");
+ #endif
+ #endif
+ */
+ if (!MyRegistry_QueryString2(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion", L"ProgramFilesDir", path))
+ CpyAscii(path,
+ #ifdef UNDER_CE
+ "\\Program Files\\"
+ #else
+ "C:\\"
+ #endif
+ );
+
+ Set7zipPostfix(path);
+ }
+ }
+
+ NormalizePrefix(path);
+
+ if (g_SilentMode)
+ return Install();
+
+ {
+ int retCode = 1;
+ // INT_PTR res = DialogBox(
+ g_HWND = CreateDialog(
+ hInstance,
+ // GetModuleHandle(NULL),
+ MAKEINTRESOURCE(IDD_INSTALL), NULL, MyDlgProc);
+ if (!g_HWND)
+ return 1;
+
+ {
+ const HICON hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON));
+ // SendMessage(g_HWND, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
+ SendMessage(g_HWND, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)hIcon);
+ }
+
+
+ {
+ BOOL bRet;
+ MSG msg;
+
+ // we need messages for all thread windows (including EDITTEXT window in dialog)
+ while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0)
+ {
+ if (bRet == -1)
+ return retCode;
+ if (!g_HWND)
+ return retCode;
+
+ if (!IsDialogMessage(g_HWND, &msg))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ if (!g_HWND)
+ return retCode;
+
+ if (g_Install_was_Pressed && !g_Finished)
+ {
+ retCode = Install();
+ g_Finished = True;
+ if (retCode != 0)
+ break;
+ if (!g_HWND)
+ break;
+ {
+ SetDlgItemTextW(g_HWND, IDOK, L"Close");
+ EnableWindow(GetDlgItem(g_HWND, IDOK), TRUE);
+ EnableWindow(GetDlgItem(g_HWND, IDCANCEL), FALSE);
+ SendMessage(g_HWND, WM_NEXTDLGCTL, (WPARAM)(void *)GetDlgItem(g_HWND, IDOK), TRUE);
+ }
+ }
+ }
+
+ if (g_HWND)
+ {
+ DestroyWindow(g_HWND);
+ g_HWND = NULL;
+ }
+ }
+
+ return retCode;
+ }
+}
+
+
+static BoolInt GetErrorMessage(DWORD errorCode, WCHAR *message)
+{
+ LPWSTR msgBuf;
+ if (FormatMessageW(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER
+ | FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, errorCode, 0, (LPWSTR) &msgBuf, 0, NULL) == 0)
+ return False;
+ wcscpy(message, msgBuf);
+ LocalFree(msgBuf);
+ return True;
+}
+
+
+
+static int Install(void)
+{
+ CFileInStream archiveStream;
+ CLookToRead2 lookStream;
+ CSzArEx db;
+
+ SRes res = SZ_OK;
+ WRes winRes = 0;
+ const char *errorMessage = NULL;
+
+ ISzAlloc allocImp;
+ ISzAlloc allocTempImp;
+ WCHAR sfxPath[MAX_PATH + 2];
+
+ int needRebootLevel = 0;
+
+ allocImp.Alloc = SzAlloc;
+ allocImp.Free = SzFree;
+
+ allocTempImp.Alloc = SzAllocTemp;
+ allocTempImp.Free = SzFreeTemp;
+
+ {
+ const DWORD len = GetModuleFileNameW(NULL, sfxPath, MAX_PATH);
+ if (len == 0 || len > MAX_PATH)
+ return 1;
+ }
+
+ winRes = InFile_OpenW(&archiveStream.file, sfxPath);
+
+ if (winRes == 0)
+ {
+ UInt64 pos = 0;
+ if (!FindSignature(&archiveStream.file, &pos))
+ errorMessage = "Can't find 7z archive";
+ else
+ winRes = File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET);
+ }
+
+ if (winRes != 0)
+ res = SZ_ERROR_FAIL;
+
+ if (errorMessage)
+ res = SZ_ERROR_FAIL;
+
+if (res == SZ_OK)
+{
+ size_t pathLen;
+ if (!g_SilentMode)
+ {
+ GetDlgItemTextW(g_HWND, IDE_EXTRACT_PATH, path, MAX_PATH);
+ }
+
+ FileInStream_CreateVTable(&archiveStream);
+ LookToRead2_CreateVTable(&lookStream, False);
+ lookStream.buf = NULL;
+
+ RemoveQuotes(path);
+ {
+ // Remove post spaces
+ unsigned endPos = 0;
+ unsigned i = 0;
+
+ for (;;)
+ {
+ const wchar_t c = path[i++];
+ if (c == 0)
+ break;
+ if (c != ' ')
+ endPos = i;
+ }
+
+ path[endPos] = 0;
+ if (path[0] == 0)
+ {
+ PrintErrorMessage("Incorrect path", NULL);
+ return 1;
+ }
+ }
+
+ NormalizePrefix(path);
+ winRes = CreateComplexDir();
+
+ if (winRes != 0)
+ res = SZ_ERROR_FAIL;
+
+ pathLen = wcslen(path);
+
+ if (res == SZ_OK)
+ {
+ lookStream.buf = (Byte *)ISzAlloc_Alloc(&allocImp, kInputBufSize);
+ if (!lookStream.buf)
+ res = SZ_ERROR_MEM;
+ else
+ {
+ lookStream.bufSize = kInputBufSize;
+ lookStream.realStream = &archiveStream.vt;
+ LookToRead2_INIT(&lookStream)
+ }
+ }
+
+ SzArEx_Init(&db);
+
+ if (res == SZ_OK)
+ {
+ res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);
+ }
+
+ if (res == SZ_OK)
+ {
+ UInt32 i;
+ UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call, if (!outBuf) */
+ Byte *outBuf = NULL; /* it must be NULL before first call for each new archive. */
+ size_t outBufSize = 0; /* it can have any value before first call, if (!outBuf) */
+
+ g_TotalSize = 0;
+
+ if (!g_SilentMode)
+ {
+ ShowWindow(g_Progress_HWND, SW_SHOW);
+ ShowWindow(g_InfoLine_HWND, SW_SHOW);
+ SendMessage(g_Progress_HWND, PBM_SETRANGE32, 0, db.NumFiles);
+ }
+
+ for (i = 0; i < db.NumFiles; i++)
+ {
+ size_t offset = 0;
+ size_t outSizeProcessed = 0;
+ WCHAR *temp;
+
+ if (!g_SilentMode)
+ {
+ MSG msg;
+
+ // g_HWND
+ while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+ {
+ if (!IsDialogMessage(g_HWND, &msg))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ if (!g_HWND)
+ return 1;
+ }
+
+ // Sleep(10);
+ SendMessage(g_Progress_HWND, PBM_SETPOS, i, 0);
+ }
+
+ {
+ const size_t len = SzArEx_GetFileNameUtf16(&db, i, NULL);
+ if (len >= MAX_PATH)
+ {
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ }
+
+ temp = path + pathLen;
+
+ SzArEx_GetFileNameUtf16(&db, i, (UInt16 *)temp);
+
+ if (!g_SilentMode)
+ SetWindowTextW(g_InfoLine_HWND, temp);
+
+ {
+ res = SzArEx_Extract(&db, &lookStream.vt, i,
+ &blockIndex, &outBuf, &outBufSize,
+ &offset, &outSizeProcessed,
+ &allocImp, &allocTempImp);
+ if (res != SZ_OK)
+ break;
+ }
+
+ {
+ CSzFile outFile;
+ size_t processedSize;
+ size_t j;
+ // size_t nameStartPos = 0;
+ UInt32 tempIndex = 0;
+ int fileLevel = 1 << 2;
+ WCHAR origPath[MAX_PATH * 2 + 10];
+
+ for (j = 0; temp[j] != 0; j++)
+ {
+ if (temp[j] == '/')
+ {
+ temp[j] = 0;
+ MyCreateDir(path);
+ temp[j] = CHAR_PATH_SEPARATOR;
+ // nameStartPos = j + 1;
+ }
+ }
+
+ if (SzArEx_IsDir(&db, i))
+ {
+ MyCreateDir(path);
+ continue;
+ }
+
+ {
+ // BoolInt skipFile = False;
+
+ wcscpy(origPath, path);
+
+ for (;;)
+ {
+ WRes openRes;
+
+ if (tempIndex != 0)
+ {
+ if (tempIndex > 100)
+ {
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ wcscpy(path, origPath);
+ CatAscii(path, ".tmp");
+ if (tempIndex > 1)
+ HexToString(tempIndex, path + wcslen(path));
+ if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
+ {
+ tempIndex++;
+ continue;
+ }
+ }
+
+ {
+ SetFileAttributesW(path, 0);
+ openRes = OutFile_OpenW(&outFile, path);
+ if (openRes == 0)
+ break;
+ }
+
+ if (tempIndex != 0)
+ {
+ tempIndex++;
+ continue;
+ }
+
+ if (FindSubString(temp, "7-zip.dll")
+ #ifdef USE_7ZIP_32_DLL
+ || FindSubString(temp, "7-zip32.dll")
+ #endif
+ )
+ {
+ const DWORD ver = GetFileVersion(path);
+ fileLevel = ((ver < Z7_7ZIP_DLL_VER_COMPAT || ver > Z7_7ZIP_CUR_VER) ? 2 : 1);
+ tempIndex++;
+ continue;
+ }
+
+ if (g_SilentMode)
+ {
+ tempIndex++;
+ continue;
+ }
+ {
+ WCHAR message[MAX_PATH * 3 + 100];
+ int mbRes;
+
+ CpyAscii(message, "Can't open file\n");
+ wcscat(message, path);
+ CatAscii(message, "\n");
+
+ GetErrorMessage(openRes, message + wcslen(message));
+
+ mbRes = MessageBoxW(g_HWND, message, L"Error", MB_ICONERROR | MB_ABORTRETRYIGNORE | MB_DEFBUTTON3);
+ if (mbRes == IDABORT)
+ {
+ res = SZ_ERROR_ABORT;
+ tempIndex = 0;
+ break;
+ }
+ if (mbRes == IDIGNORE)
+ {
+ // skipFile = True;
+ tempIndex++;
+ }
+ }
+ }
+
+ if (res != SZ_OK)
+ break;
+
+ /*
+ if (skipFile)
+ continue;
+ */
+ }
+
+ // if (res == SZ_OK)
+ {
+ processedSize = outSizeProcessed;
+ winRes = File_Write(&outFile, outBuf + offset, &processedSize);
+ if (winRes != 0 || processedSize != outSizeProcessed)
+ {
+ errorMessage = "Can't write output file";
+ res = SZ_ERROR_FAIL;
+ }
+
+ g_TotalSize += (DWORD)outSizeProcessed;
+
+ #ifdef USE_WINDOWS_FILE
+ if (SzBitWithVals_Check(&db.MTime, i))
+ {
+ const CNtfsFileTime *t = db.MTime.Vals + i;
+ FILETIME mTime;
+ mTime.dwLowDateTime = t->Low;
+ mTime.dwHighDateTime = t->High;
+ SetFileTime(outFile.handle, NULL, NULL, &mTime);
+ }
+ #endif
+
+ {
+ const WRes winRes2 = File_Close(&outFile);
+ if (res != SZ_OK)
+ break;
+ if (winRes2 != 0)
+ {
+ winRes = winRes2;
+ break;
+ }
+ }
+
+ #ifdef USE_WINDOWS_FILE
+ if (SzBitWithVals_Check(&db.Attribs, i))
+ SetFileAttributesW(path, db.Attribs.Vals[i]);
+ #endif
+ }
+
+ if (tempIndex != 0)
+ {
+ // is it supported at win2000 ?
+ #ifndef UNDER_CE
+ if (!MoveFileExW(path, origPath, MOVEFILE_DELAY_UNTIL_REBOOT | MOVEFILE_REPLACE_EXISTING))
+ {
+ winRes = GetLastError();
+ break;
+ }
+ needRebootLevel |= fileLevel;
+ #endif
+ }
+
+ }
+ }
+
+ ISzAlloc_Free(&allocImp, outBuf);
+
+ if (!g_SilentMode)
+ SendMessage(g_Progress_HWND, PBM_SETPOS, i, 0);
+
+ path[pathLen] = 0;
+
+ if (i == db.NumFiles)
+ {
+ SetRegKey_Path();
+ WriteCLSID();
+ WriteShellEx();
+
+ SetShellProgramsGroup(g_HWND);
+ if (!g_SilentMode)
+ SetWindowTextW(g_InfoLine_HWND, k_7zip_with_Ver L" is installed");
+ }
+ }
+
+ SzArEx_Free(&db, &allocImp);
+
+ ISzAlloc_Free(&allocImp, lookStream.buf);
+
+ File_Close(&archiveStream.file);
+
+}
+
+ if (winRes != 0)
+ res = SZ_ERROR_FAIL;
+
+ if (res == SZ_OK)
+ {
+ if (!g_SilentMode && needRebootLevel > 1)
+ {
+ if (MessageBoxW(g_HWND, L"You must restart your system to complete the installation.\nRestart now?",
+ k_7zip_Setup, MB_YESNO | MB_DEFBUTTON2) == IDYES)
+ {
+ #ifndef UNDER_CE
+
+ // Get a token for this process.
+ HANDLE hToken;
+
+ if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
+ {
+ TOKEN_PRIVILEGES tkp;
+ // Get the LUID for the shutdown privilege.
+ LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
+ tkp.PrivilegeCount = 1; // one privilege to set
+ tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+ // Get the shutdown privilege for this process.
+ AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
+
+ if (GetLastError() == ERROR_SUCCESS)
+ {
+ if (!ExitWindowsEx(EWX_REBOOT, 0))
+ {
+ }
+ }
+ }
+
+ #endif
+ }
+ }
+
+ if (res == SZ_OK)
+ return 0;
+ }
+
+ if (!g_SilentMode)
+ {
+ if (winRes != 0)
+ {
+ WCHAR m[MAX_PATH + 100];
+ m[0] = 0;
+ GetErrorMessage(winRes, m);
+ PrintErrorMessage(NULL, m);
+ }
+ else
+ {
+ if (res == SZ_ERROR_ABORT)
+ return 2;
+
+ if (res == SZ_ERROR_UNSUPPORTED)
+ errorMessage = "Decoder doesn't support this archive";
+ else if (res == SZ_ERROR_MEM)
+ errorMessage = "Can't allocate required memory";
+ else if (res == SZ_ERROR_CRC)
+ errorMessage = "CRC error";
+ else if (res == SZ_ERROR_DATA)
+ errorMessage = "Data error";
+
+ if (!errorMessage)
+ errorMessage = "ERROR";
+ PrintErrorMessage(errorMessage, NULL);
+ }
+ }
+
+ return 1;
+}
diff --git a/C/Util/7zipInstall/7zipInstall.dsp b/C/Util/7zipInstall/7zipInstall.dsp
new file mode 100644
index 0000000..4c6ea4d
--- /dev/null
+++ b/C/Util/7zipInstall/7zipInstall.dsp
@@ -0,0 +1,248 @@
+# Microsoft Developer Studio Project File - Name="7zipInstall" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=7zipInstall - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "7zipInstall.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "7zipInstall.mak" CFG="7zipInstall - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "7zipInstall - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "7zipInstall - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "7zipInstall - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE2" /D "UNICODE2" /Yu"Precomp.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib version.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF "$(CFG)" == "7zipInstall - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE2" /D "UNICODE2" /Yu"Precomp.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib version.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "7zipInstall - Win32 Release"
+# Name "7zipInstall - Win32 Debug"
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\7z.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zArcIn.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrcOpt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zStream.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra86.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\BraIA64.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Delta.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\DllSecur.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.h
+# End Source File
+# End Group
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.c
+# ADD CPP /Yc"Precomp.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7zipInstall.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# End Target
+# End Project
diff --git a/C/Util/7zipInstall/7zipInstall.dsw b/C/Util/7zipInstall/7zipInstall.dsw
new file mode 100644
index 0000000..b7db73f
--- /dev/null
+++ b/C/Util/7zipInstall/7zipInstall.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "7zipInstall"=.\7zipInstall.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/C/Util/7zipInstall/7zipInstall.manifest b/C/Util/7zipInstall/7zipInstall.manifest
new file mode 100644
index 0000000..f5c3ae5
--- /dev/null
+++ b/C/Util/7zipInstall/7zipInstall.manifest
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+<assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7-Zip.7-Zip.7zipInstall" type="win32"/>
+<description>7-Zip Installer</description>
+<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2"><security><requestedPrivileges>
+ <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+</requestedPrivileges></security></trustInfo>
+<dependency><dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/></dependentAssembly></dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7 --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8 --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10 --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+<asmv3:application><asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
+<dpiAware>true</dpiAware></asmv3:windowsSettings></asmv3:application>
+</assembly>
diff --git a/C/Util/7zipInstall/Precomp.c b/C/Util/7zipInstall/Precomp.c
new file mode 100644
index 0000000..01605e3
--- /dev/null
+++ b/C/Util/7zipInstall/Precomp.c
@@ -0,0 +1,4 @@
+/* Precomp.c -- StdAfx
+2013-01-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
diff --git a/C/Util/7zipInstall/Precomp.h b/C/Util/7zipInstall/Precomp.h
new file mode 100644
index 0000000..bc8fa21
--- /dev/null
+++ b/C/Util/7zipInstall/Precomp.h
@@ -0,0 +1,14 @@
+/* Precomp.h -- StdAfx
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_PRECOMP_H
+#define ZIP7_INC_PRECOMP_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../Compiler.h"
+#include "../../7zTypes.h"
+
+#endif
diff --git a/C/Util/7zipInstall/makefile b/C/Util/7zipInstall/makefile
new file mode 100644
index 0000000..18e2783
--- /dev/null
+++ b/C/Util/7zipInstall/makefile
@@ -0,0 +1,44 @@
+PROG = 7zipInstall.exe
+MY_FIXED = 1
+
+!IFDEF Z7_64BIT_INSTALLER
+CFLAGS = $(CFLAGS) -DZ7_64BIT_INSTALLER
+!ENDIF
+
+CFLAGS = $(CFLAGS) \
+ -DZ7_LZMA_SIZE_OPT \
+ -DZ7_NO_METHOD_LZMA2 \
+ -DZ7_NO_METHODS_FILTERS \
+ -DZ7_USE_NATIVE_BRANCH_FILTER \
+ -DZ7_EXTRACT_ONLY \
+
+MAIN_OBJS = \
+ $O\7zipInstall.obj \
+
+C_OBJS = \
+ $O\7zAlloc.obj \
+ $O\7zArcIn.obj \
+ $O\7zBuf.obj \
+ $O\7zBuf2.obj \
+ $O\7zCrc.obj \
+ $O\7zCrcOpt.obj \
+ $O\7zFile.obj \
+ $O\7zDec.obj \
+ $O\7zStream.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\CpuArch.obj \
+ $O\DllSecur.obj \
+ $O\LzmaDec.obj \
+
+OBJS = \
+ $(MAIN_OBJS) \
+ $(C_OBJS) \
+ $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(MAIN_OBJS): $(*B).c
+ $(COMPL_O1)
+$(C_OBJS): ../../$(*B).c
+ $(COMPL_O1)
diff --git a/C/Util/7zipInstall/resource.h b/C/Util/7zipInstall/resource.h
new file mode 100644
index 0000000..63c6b4c
--- /dev/null
+++ b/C/Util/7zipInstall/resource.h
@@ -0,0 +1,9 @@
+#define IDD_INSTALL 100
+
+#define IDT_EXTRACT_EXTRACT_TO 110
+#define IDE_EXTRACT_PATH 111
+#define IDB_EXTRACT_SET_PATH 112
+#define IDT_CUR_FILE 113
+#define IDC_PROGRESS 114
+
+#define IDI_ICON 1
diff --git a/C/Util/7zipInstall/resource.rc b/C/Util/7zipInstall/resource.rc
new file mode 100644
index 0000000..df6474e
--- /dev/null
+++ b/C/Util/7zipInstall/resource.rc
@@ -0,0 +1,47 @@
+#include <winnt.h>
+#include <WinUser.h>
+#include <CommCtrl.h>
+
+#define USE_COPYRIGHT_CR
+#include "../../7zVersion.rc"
+#include "resource.h"
+
+MY_VERSION_INFO(MY_VFT_APP, "7-Zip Installer", "7zipInstall", "7zipInstall.exe")
+
+1 ICON "7zip.ico"
+
+#define xc 184
+#define yc 96
+
+#define m 8
+#define bxs 64
+#define bys 16
+#define bxsDots 20
+
+#define xs (xc + m + m)
+#define ys (yc + m + m)
+
+#define bx1 (xs - m - bxs)
+#define bx2 (bx1 - m - bxs)
+
+#define by (ys - m - bys)
+
+IDD_INSTALL DIALOG 0, 0, xs, ys
+STYLE DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_VISIBLE
+CAPTION "Install 7-Zip"
+FONT 8, "MS Shell Dlg"
+BEGIN
+ LTEXT "Destination folder:", IDT_EXTRACT_EXTRACT_TO, m, m, xc, 8
+ EDITTEXT IDE_EXTRACT_PATH, m, 21, xc - bxsDots - 12, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, 20, bxsDots, bys, WS_GROUP
+
+ LTEXT "", IDT_CUR_FILE, m, 50, xc, 8
+ CONTROL "", IDC_PROGRESS, "msctls_progress32", WS_BORDER, m, 64, xc, 10
+
+ DEFPUSHBUTTON "&Install", IDOK, bx2, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+END
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "7zipInstall.manifest"
+#endif
diff --git a/C/Util/7zipUninstall/7zipUninstall.c b/C/Util/7zipUninstall/7zipUninstall.c
new file mode 100644
index 0000000..8bc18b3
--- /dev/null
+++ b/C/Util/7zipUninstall/7zipUninstall.c
@@ -0,0 +1,1217 @@
+/* 7zipUninstall.c - 7-Zip Uninstaller
+2022-07-15 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+// #define SZ_ERROR_ABORT 100
+
+#include "../../7zWindows.h"
+
+#if defined(_MSC_VER) && _MSC_VER < 1600
+#pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union
+#endif
+
+#ifdef Z7_OLD_WIN_SDK
+struct IShellView;
+#define SHFOLDERAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
+SHFOLDERAPI SHGetFolderPathW(HWND hwnd, int csidl, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
+#define BIF_NEWDIALOGSTYLE 0x0040 // Use the new dialog layout with the ability to resize
+typedef enum {
+ SHGFP_TYPE_CURRENT = 0, // current value for user, verify it exists
+ SHGFP_TYPE_DEFAULT = 1, // default value, may not exist
+} SHGFP_TYPE;
+#endif
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#include "../../7zVersion.h"
+
+#include "resource.h"
+
+#if (defined(__GNUC__) && (__GNUC__ >= 8)) || defined(__clang__)
+ // #pragma GCC diagnostic ignored "-Wcast-function-type"
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER > 1920
+#define MY_CAST_FUNC (void *)
+// #pragma warning(disable : 4191) // 'type cast': unsafe conversion from 'FARPROC' to 'void (__cdecl *)()'
+#else
+#define MY_CAST_FUNC
+#endif
+
+
+#define LLL_(quote) L##quote
+#define LLL(quote) LLL_(quote)
+
+#define wcscat lstrcatW
+#define wcslen (size_t)lstrlenW
+#define wcscpy lstrcpyW
+
+// static LPCWSTR const k_7zip = L"7-Zip";
+
+// #define Z7_64BIT_INSTALLER 1
+
+#ifdef _WIN64
+ #define Z7_64BIT_INSTALLER 1
+#endif
+
+#define k_7zip_with_Ver_base L"7-Zip " LLL(MY_VERSION)
+
+#ifdef Z7_64BIT_INSTALLER
+
+ // #define USE_7ZIP_32_DLL
+
+ #if defined(_M_ARM64) || defined(_M_ARM)
+ #define k_Postfix L" (arm64)"
+ #else
+ #define k_Postfix L" (x64)"
+ #define USE_7ZIP_32_DLL
+ #endif
+#else
+ #if defined(_M_ARM64) || defined(_M_ARM)
+ #define k_Postfix L" (arm)"
+ #else
+ // #define k_Postfix L" (x86)"
+ #define k_Postfix
+ #endif
+#endif
+
+#define k_7zip_with_Ver k_7zip_with_Ver_base k_Postfix
+
+static LPCWSTR const k_7zip_with_Ver_Uninstall = k_7zip_with_Ver L" Uninstall";
+
+static LPCWSTR const k_Reg_Software_7zip = L"Software\\7-Zip";
+
+static LPCWSTR const k_Reg_Path = L"Path";
+
+static LPCWSTR const k_Reg_Path32 = L"Path"
+ #ifdef Z7_64BIT_INSTALLER
+ L"64"
+ #else
+ L"32"
+ #endif
+ ;
+
+#if defined(Z7_64BIT_INSTALLER) && !defined(_WIN64)
+ #define k_Reg_WOW_Flag KEY_WOW64_64KEY
+#else
+ #define k_Reg_WOW_Flag 0
+#endif
+
+#ifdef _WIN64
+ #define k_Reg_WOW_Flag_32 KEY_WOW64_32KEY
+#else
+ #define k_Reg_WOW_Flag_32 0
+#endif
+
+#define k_7zip_CLSID L"{23170F69-40C1-278A-1000-000100020000}"
+
+static LPCWSTR const k_Reg_CLSID_7zip = L"CLSID\\" k_7zip_CLSID;
+static LPCWSTR const k_Reg_CLSID_7zip_Inproc = L"CLSID\\" k_7zip_CLSID L"\\InprocServer32";
+
+
+#define g_AllUsers True
+
+static BoolInt g_Install_was_Pressed;
+static BoolInt g_Finished;
+static BoolInt g_SilentMode;
+
+static HWND g_HWND;
+static HWND g_Path_HWND;
+static HWND g_InfoLine_HWND;
+static HWND g_Progress_HWND;
+
+// WINADVAPI
+typedef LONG (APIENTRY *Func_RegDeleteKeyExW)(HKEY hKey, LPCWSTR lpSubKey, REGSAM samDesired, DWORD Reserved);
+static Func_RegDeleteKeyExW func_RegDeleteKeyExW;
+
+static WCHAR cmd[MAX_PATH + 4];
+static WCHAR cmdError[MAX_PATH + 4];
+static WCHAR path[MAX_PATH * 2 + 40];
+static WCHAR workDir[MAX_PATH + 10];
+static WCHAR modulePath[MAX_PATH + 10];
+static WCHAR modulePrefix[MAX_PATH + 10];
+static WCHAR tempPath[MAX_PATH * 2 + 40];
+static WCHAR cmdLine[MAX_PATH * 3 + 40];
+static WCHAR copyPath[MAX_PATH * 2 + 40];
+
+static LPCWSTR const kUninstallExe = L"Uninstall.exe";
+
+#define MAKE_CHAR_UPPER(c) ((((c) >= 'a' && (c) <= 'z') ? (c) - 0x20 : (c)))
+
+
+static void CpyAscii(wchar_t *dest, const char *s)
+{
+ for (;;)
+ {
+ const Byte b = (Byte)*s++;
+ *dest++ = b;
+ if (b == 0)
+ return;
+ }
+}
+
+static void CatAscii(wchar_t *dest, const char *s)
+{
+ dest += wcslen(dest);
+ CpyAscii(dest, s);
+}
+
+static void PrintErrorMessage(const char *s1, const wchar_t *s2)
+{
+ WCHAR m[MAX_PATH + 512];
+ m[0] = 0;
+ CatAscii(m, "ERROR:");
+ if (s1)
+ {
+ CatAscii(m, "\n");
+ CatAscii(m, s1);
+ }
+ if (s2)
+ {
+ CatAscii(m, "\n");
+ wcscat(m, s2);
+ }
+ MessageBoxW(g_HWND, m, k_7zip_with_Ver_Uninstall, MB_ICONERROR | MB_OK);
+}
+
+
+static BoolInt AreStringsEqual_NoCase(const wchar_t *s1, const wchar_t *s2)
+{
+ for (;;)
+ {
+ wchar_t c1 = *s1++;
+ wchar_t c2 = *s2++;
+ if (c1 != c2 && MAKE_CHAR_UPPER(c1) != MAKE_CHAR_UPPER(c2))
+ return False;
+ if (c2 == 0)
+ return True;
+ }
+}
+
+static BoolInt IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2)
+{
+ for (;;)
+ {
+ wchar_t c1;
+ const wchar_t c2 = *s2++;
+ if (c2 == 0)
+ return True;
+ c1 = *s1++;
+ if (c1 != c2 && MAKE_CHAR_UPPER(c1) != MAKE_CHAR_UPPER(c2))
+ return False;
+ }
+}
+
+static void NormalizePrefix(WCHAR *s)
+{
+ const size_t len = wcslen(s);
+ if (len != 0)
+ if (s[len - 1] != WCHAR_PATH_SEPARATOR)
+ {
+ s[len] = WCHAR_PATH_SEPARATOR;
+ s[len + 1] = 0;
+ }
+}
+
+static int MyRegistry_QueryString(HKEY hKey, LPCWSTR name, LPWSTR dest)
+{
+ DWORD cnt = MAX_PATH * sizeof(name[0]);
+ DWORD type = 0;
+ const LONG res = RegQueryValueExW(hKey, name, NULL, &type, (LPBYTE)dest, &cnt);
+ if (type != REG_SZ)
+ return False;
+ return res == ERROR_SUCCESS;
+}
+
+static int MyRegistry_QueryString2(HKEY hKey, LPCWSTR keyName, LPCWSTR valName, LPWSTR dest)
+{
+ HKEY key = 0;
+ const LONG res = RegOpenKeyExW(hKey, keyName, 0, KEY_READ | k_Reg_WOW_Flag, &key);
+ if (res != ERROR_SUCCESS)
+ return False;
+ {
+ const BoolInt res2 = MyRegistry_QueryString(key, valName, dest);
+ RegCloseKey(key);
+ return res2;
+ }
+}
+
+static LONG MyRegistry_OpenKey_ReadWrite(HKEY parentKey, LPCWSTR name, HKEY *destKey)
+{
+ return RegOpenKeyExW(parentKey, name, 0, KEY_READ | KEY_WRITE | k_Reg_WOW_Flag, destKey);
+}
+
+static LONG MyRegistry_DeleteKey(HKEY parentKey, LPCWSTR name)
+{
+ #if k_Reg_WOW_Flag != 0
+ if (func_RegDeleteKeyExW)
+ return func_RegDeleteKeyExW(parentKey, name, k_Reg_WOW_Flag, 0);
+ return E_FAIL;
+ #else
+ return RegDeleteKeyW(parentKey, name);
+ #endif
+}
+
+#ifdef USE_7ZIP_32_DLL
+
+static int MyRegistry_QueryString2_32(HKEY hKey, LPCWSTR keyName, LPCWSTR valName, LPWSTR dest)
+{
+ HKEY key = 0;
+ const LONG res = RegOpenKeyExW(hKey, keyName, 0, KEY_READ | k_Reg_WOW_Flag_32, &key);
+ if (res != ERROR_SUCCESS)
+ return False;
+ {
+ const BoolInt res2 = MyRegistry_QueryString(key, valName, dest);
+ RegCloseKey(key);
+ return res2;
+ }
+}
+
+static LONG MyRegistry_OpenKey_ReadWrite_32(HKEY parentKey, LPCWSTR name, HKEY *destKey)
+{
+ return RegOpenKeyExW(parentKey, name, 0, KEY_READ | KEY_WRITE | k_Reg_WOW_Flag_32, destKey);
+}
+
+static LONG MyRegistry_DeleteKey_32(HKEY parentKey, LPCWSTR name)
+{
+ #if k_Reg_WOW_Flag_32 != 0
+ if (func_RegDeleteKeyExW)
+ return func_RegDeleteKeyExW(parentKey, name, k_Reg_WOW_Flag_32, 0);
+ return E_FAIL;
+ #else
+ return RegDeleteKeyW(parentKey, name);
+ #endif
+}
+
+#endif
+
+
+
+
+static void MyReg_DeleteVal_Path_if_Equal(HKEY hKey, LPCWSTR name)
+{
+ WCHAR s[MAX_PATH + 10];
+ if (MyRegistry_QueryString(hKey, name, s))
+ {
+ NormalizePrefix(s);
+ if (AreStringsEqual_NoCase(s, path))
+ RegDeleteValueW(hKey, name);
+ }
+}
+
+static void SetRegKey_Path2(HKEY parentKey)
+{
+ HKEY key = 0;
+ const LONG res = MyRegistry_OpenKey_ReadWrite(parentKey, k_Reg_Software_7zip, &key);
+ if (res == ERROR_SUCCESS)
+ {
+ MyReg_DeleteVal_Path_if_Equal(key, k_Reg_Path32);
+ MyReg_DeleteVal_Path_if_Equal(key, k_Reg_Path);
+
+ RegCloseKey(key);
+ // MyRegistry_DeleteKey(parentKey, k_Reg_Software_7zip);
+ }
+}
+
+static void SetRegKey_Path(void)
+{
+ SetRegKey_Path2(HKEY_CURRENT_USER);
+ SetRegKey_Path2(HKEY_LOCAL_MACHINE);
+}
+
+static HRESULT CreateShellLink(LPCWSTR srcPath, LPCWSTR targetPath)
+{
+ IShellLinkW *sl;
+
+ // CoInitialize has already been called.
+ HRESULT hres = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (LPVOID*)&sl);
+
+ if (SUCCEEDED(hres))
+ {
+ IPersistFile *pf;
+
+ hres = sl->lpVtbl->QueryInterface(sl, &IID_IPersistFile, (LPVOID *)&pf);
+
+ if (SUCCEEDED(hres))
+ {
+ WCHAR s[MAX_PATH + 10];
+ hres = pf->lpVtbl->Load(pf, srcPath, TRUE);
+ pf->lpVtbl->Release(pf);
+
+ if (SUCCEEDED(hres))
+ {
+ hres = sl->lpVtbl->GetPath(sl, s, MAX_PATH, NULL, 0); // SLGP_RAWPATH
+ if (!AreStringsEqual_NoCase(s, targetPath))
+ hres = S_FALSE;
+ }
+ }
+
+ sl->lpVtbl->Release(sl);
+ }
+
+ return hres;
+}
+
+static void SetShellProgramsGroup(HWND hwndOwner)
+{
+ #ifdef UNDER_CE
+
+ UNUSED_VAR(hwndOwner)
+
+ #else
+
+ unsigned i = (g_AllUsers ? 1 : 2);
+
+ for (; i < 3; i++)
+ {
+ // BoolInt isOK = True;
+ WCHAR link[MAX_PATH + 40];
+ WCHAR destPath[MAX_PATH + 40];
+
+ link[0] = 0;
+
+ if (SHGetFolderPathW(hwndOwner,
+ i == 1 ? CSIDL_COMMON_PROGRAMS : CSIDL_PROGRAMS,
+ NULL, SHGFP_TYPE_CURRENT, link) != S_OK)
+ continue;
+
+ NormalizePrefix(link);
+ CatAscii(link, "7-Zip\\");
+
+ {
+ const size_t baseLen = wcslen(link);
+ unsigned k;
+ BoolInt needDelete = False;
+
+ for (k = 0; k < 2; k++)
+ {
+ CpyAscii(link + baseLen, k == 0 ?
+ "7-Zip File Manager.lnk" :
+ "7-Zip Help.lnk");
+ wcscpy(destPath, path);
+ CatAscii(destPath, k == 0 ?
+ "7zFM.exe" :
+ "7-zip.chm");
+
+ if (CreateShellLink(link, destPath) == S_OK)
+ {
+ needDelete = True;
+ DeleteFileW(link);
+ }
+ }
+
+ if (needDelete)
+ {
+ link[baseLen] = 0;
+ RemoveDirectoryW(link);
+ }
+ }
+ }
+
+ #endif
+}
+
+
+static LPCSTR const k_ShellEx_Items[] =
+{
+ "*\\shellex\\ContextMenuHandlers"
+ , "Directory\\shellex\\ContextMenuHandlers"
+ , "Folder\\shellex\\ContextMenuHandlers"
+ , "Directory\\shellex\\DragDropHandlers"
+ , "Drive\\shellex\\DragDropHandlers"
+};
+
+static LPCWSTR const k_Shell_Approved = L"Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved";
+
+static LPCWSTR const k_AppPaths_7zFm = L"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\7zFM.exe";
+#define k_REG_Uninstall L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
+static LPCWSTR const k_Uninstall_7zip = k_REG_Uninstall L"7-Zip";
+
+
+static void RemoveQuotes(wchar_t *s)
+{
+ const size_t len = wcslen(s);
+ size_t i;
+ if (len == 0 || s[0] != '\"' || s[len - 1] != '\"')
+ return;
+ for (i = 0; i < len; i++)
+ s[i] = s[i + 1];
+ s[len - 2] = 0;
+}
+
+static BoolInt AreEqual_Path_PrefixName(const wchar_t *s, const wchar_t *prefix, const wchar_t *name)
+{
+ if (!IsString1PrefixedByString2_NoCase(s, prefix))
+ return False;
+ return AreStringsEqual_NoCase(s + wcslen(prefix), name);
+}
+
+static void WriteCLSID(void)
+{
+ WCHAR s[MAX_PATH + 30];
+
+ if (MyRegistry_QueryString2(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip_Inproc, NULL, s))
+ {
+ if (AreEqual_Path_PrefixName(s, path, L"7-zip.dll"))
+ {
+ {
+ const LONG res = MyRegistry_DeleteKey(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip_Inproc);
+ if (res == ERROR_SUCCESS)
+ MyRegistry_DeleteKey(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip);
+ }
+
+ {
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(k_ShellEx_Items); i++)
+ {
+ WCHAR destPath[MAX_PATH];
+ CpyAscii(destPath, k_ShellEx_Items[i]);
+ CatAscii(destPath, "\\7-Zip");
+
+ MyRegistry_DeleteKey(HKEY_CLASSES_ROOT, destPath);
+ }
+ }
+
+ {
+ HKEY destKey = 0;
+ const LONG res = MyRegistry_OpenKey_ReadWrite(HKEY_LOCAL_MACHINE, k_Shell_Approved, &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ RegDeleteValueW(destKey, k_7zip_CLSID);
+ /* res = */ RegCloseKey(destKey);
+ }
+ }
+ }
+ }
+
+
+ #ifdef USE_7ZIP_32_DLL
+
+ if (MyRegistry_QueryString2_32(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip_Inproc, NULL, s))
+ {
+ if (AreEqual_Path_PrefixName(s, path, L"7-zip32.dll"))
+ {
+ {
+ const LONG res = MyRegistry_DeleteKey_32(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip_Inproc);
+ if (res == ERROR_SUCCESS)
+ MyRegistry_DeleteKey_32(HKEY_CLASSES_ROOT, k_Reg_CLSID_7zip);
+ }
+
+ {
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(k_ShellEx_Items); i++)
+ {
+ WCHAR destPath[MAX_PATH];
+ CpyAscii(destPath, k_ShellEx_Items[i]);
+ CatAscii(destPath, "\\7-Zip");
+
+ MyRegistry_DeleteKey_32(HKEY_CLASSES_ROOT, destPath);
+ }
+ }
+
+ {
+ HKEY destKey = 0;
+ const LONG res = MyRegistry_OpenKey_ReadWrite_32(HKEY_LOCAL_MACHINE, k_Shell_Approved, &destKey);
+ if (res == ERROR_SUCCESS)
+ {
+ RegDeleteValueW(destKey, k_7zip_CLSID);
+ /* res = */ RegCloseKey(destKey);
+ }
+ }
+ }
+ }
+
+ #endif
+
+
+ if (MyRegistry_QueryString2(HKEY_LOCAL_MACHINE, k_AppPaths_7zFm, NULL, s))
+ {
+ // RemoveQuotes(s);
+ if (AreEqual_Path_PrefixName(s, path, L"7zFM.exe"))
+ MyRegistry_DeleteKey(HKEY_LOCAL_MACHINE, k_AppPaths_7zFm);
+ }
+
+ if (MyRegistry_QueryString2(HKEY_LOCAL_MACHINE, k_Uninstall_7zip, L"UninstallString", s))
+ {
+ RemoveQuotes(s);
+ if (AreEqual_Path_PrefixName(s, path, kUninstallExe))
+ MyRegistry_DeleteKey(HKEY_LOCAL_MACHINE, k_Uninstall_7zip);
+ }
+}
+
+
+static const wchar_t *GetCmdParam(const wchar_t *s)
+{
+ unsigned pos = 0;
+ BoolInt quoteMode = False;
+ for (;; s++)
+ {
+ const wchar_t c = *s;
+ if (c == 0 || (c == L' ' && !quoteMode))
+ break;
+ if (c == L'\"')
+ {
+ quoteMode = !quoteMode;
+ continue;
+ }
+ if (pos >= Z7_ARRAY_SIZE(cmd) - 1)
+ exit(1);
+ cmd[pos++] = c;
+ }
+ cmd[pos] = 0;
+ return s;
+}
+
+/*
+static void RemoveQuotes(wchar_t *s)
+{
+ const wchar_t *src = s;
+ for (;;)
+ {
+ wchar_t c = *src++;
+ if (c == '\"')
+ continue;
+ *s++ = c;
+ if (c == 0)
+ return;
+ }
+}
+*/
+
+static BoolInt DoesFileOrDirExist(void)
+{
+ return (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES);
+}
+
+static BOOL RemoveFileAfterReboot2(const WCHAR *s)
+{
+ #ifndef UNDER_CE
+ return MoveFileExW(s, NULL, MOVEFILE_DELAY_UNTIL_REBOOT);
+ #else
+ UNUSED_VAR(s)
+ return TRUE;
+ #endif
+}
+
+static BOOL RemoveFileAfterReboot(void)
+{
+ return RemoveFileAfterReboot2(path);
+}
+
+// #define IS_LIMIT_CHAR(c) (c == 0 || c == ' ')
+
+static BoolInt IsThereSpace(const wchar_t *s)
+{
+ for (;;)
+ {
+ const wchar_t c = *s++;
+ if (c == 0)
+ return False;
+ if (c == ' ')
+ return True;
+ }
+}
+
+static void AddPathParam(wchar_t *dest, const wchar_t *src)
+{
+ const BoolInt needQuote = IsThereSpace(src);
+ if (needQuote)
+ CatAscii(dest, "\"");
+ wcscat(dest, src);
+ if (needQuote)
+ CatAscii(dest, "\"");
+}
+
+
+
+static BoolInt GetErrorMessage(DWORD errorCode, WCHAR *message)
+{
+ LPWSTR msgBuf;
+ if (FormatMessageW(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER
+ | FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, errorCode, 0, (LPWSTR) &msgBuf, 0, NULL) == 0)
+ return False;
+ wcscpy(message, msgBuf);
+ LocalFree(msgBuf);
+ return True;
+}
+
+static BOOL RemoveDir(void)
+{
+ const DWORD attrib = GetFileAttributesW(path);
+ if (attrib == INVALID_FILE_ATTRIBUTES)
+ return TRUE;
+ if (RemoveDirectoryW(path))
+ return TRUE;
+ return RemoveFileAfterReboot();
+}
+
+
+
+
+
+#define k_Lang "Lang"
+
+// NUM_LANG_TXT_FILES files are placed before en.ttt
+#define NUM_LANG_TXT_FILES 92
+
+#ifdef USE_7ZIP_32_DLL
+ #define NUM_EXTRA_FILES_64BIT 1
+#else
+ #define NUM_EXTRA_FILES_64BIT 0
+#endif
+
+#define NUM_FILES (NUM_LANG_TXT_FILES + 1 + 13 + NUM_EXTRA_FILES_64BIT)
+
+static const char * const k_Names =
+ "af an ar ast az ba be bg bn br ca co cs cy da de el eo es et eu ext"
+ " fa fi fr fur fy ga gl gu he hi hr hu hy id io is it ja ka kaa kab kk ko ku ku-ckb ky"
+ " lij lt lv mk mn mng mng2 mr ms nb ne nl nn pa-in pl ps pt pt-br ro ru"
+ " sa si sk sl sq sr-spc sr-spl sv sw ta tg th tk tr tt ug uk uz uz-cyrl va vi yo zh-cn zh-tw"
+ " en.ttt"
+ " descript.ion"
+ " History.txt"
+ " License.txt"
+ " readme.txt"
+ " 7-zip.chm"
+ " 7z.sfx"
+ " 7zCon.sfx"
+ " 7z.exe"
+ " 7zG.exe"
+ " 7z.dll"
+ " 7zFM.exe"
+ #ifdef USE_7ZIP_32_DLL
+ " 7-zip32.dll"
+ #endif
+ " 7-zip.dll"
+ " Uninstall.exe";
+
+
+
+static int Install(void)
+{
+ SRes res = SZ_OK;
+ WRes winRes = 0;
+
+ // BoolInt needReboot = False;
+ const size_t pathLen = wcslen(path);
+
+ if (!g_SilentMode)
+ {
+ ShowWindow(g_Progress_HWND, SW_SHOW);
+ ShowWindow(g_InfoLine_HWND, SW_SHOW);
+ SendMessage(g_Progress_HWND, PBM_SETRANGE32, 0, NUM_FILES);
+ }
+
+ {
+ unsigned i;
+ const char *curName = k_Names;
+
+ for (i = 0; *curName != 0; i++)
+ {
+ WCHAR *temp;
+
+ if (!g_SilentMode)
+ {
+ MSG msg;
+
+ // g_HWND
+ while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+ {
+ if (!IsDialogMessage(g_HWND, &msg))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ if (!g_HWND)
+ return 1;
+ }
+
+ // Sleep(1);
+ SendMessage(g_Progress_HWND, PBM_SETPOS, i, 0);
+ }
+
+ path[pathLen] = 0;
+ temp = path + pathLen;
+
+ if (i <= NUM_LANG_TXT_FILES)
+ CpyAscii(temp, k_Lang "\\");
+
+ {
+ WCHAR *dest = temp + wcslen(temp);
+
+ for (;;)
+ {
+ const char c = *curName;
+ if (c == 0)
+ break;
+ curName++;
+ if (c == ' ')
+ break;
+ *dest++ = (Byte)c;
+ }
+
+ *dest = 0;
+ }
+
+ if (i < NUM_LANG_TXT_FILES)
+ CatAscii(temp, ".txt");
+
+ if (!g_SilentMode)
+ SetWindowTextW(g_InfoLine_HWND, temp);
+
+ {
+ const DWORD attrib = GetFileAttributesW(path);
+ if (attrib == INVALID_FILE_ATTRIBUTES)
+ continue;
+ if (attrib & FILE_ATTRIBUTE_READONLY)
+ SetFileAttributesW(path, 0);
+ if (!DeleteFileW(path))
+ {
+ if (!RemoveFileAfterReboot())
+ {
+ winRes = GetLastError();
+ }
+ /*
+ else
+ needReboot = True;
+ */
+ }
+ }
+ }
+
+ CpyAscii(path + pathLen, k_Lang);
+ RemoveDir();
+
+ path[pathLen] = 0;
+ RemoveDir();
+
+ if (!g_SilentMode)
+ SendMessage(g_Progress_HWND, PBM_SETPOS, i, 0);
+
+ if (*curName == 0)
+ {
+ SetRegKey_Path();
+ WriteCLSID();
+ SetShellProgramsGroup(g_HWND);
+ if (!g_SilentMode)
+ SetWindowTextW(g_InfoLine_HWND, k_7zip_with_Ver L" is uninstalled");
+ }
+ }
+
+ if (winRes != 0)
+ res = SZ_ERROR_FAIL;
+
+ if (res == SZ_OK)
+ {
+ // if (!g_SilentMode && needReboot);
+ return 0;
+ }
+
+ if (!g_SilentMode)
+ {
+ WCHAR m[MAX_PATH + 100];
+ m[0] = 0;
+ if (winRes == 0 || !GetErrorMessage(winRes, m))
+ CpyAscii(m, "ERROR");
+ PrintErrorMessage("System ERROR:", m);
+ }
+
+ return 1;
+}
+
+
+static void OnClose(void)
+{
+ if (g_Install_was_Pressed && !g_Finished)
+ {
+ if (MessageBoxW(g_HWND,
+ L"Do you want to cancel uninstallation?",
+ k_7zip_with_Ver_Uninstall,
+ MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2) != IDYES)
+ return;
+ }
+ DestroyWindow(g_HWND);
+ g_HWND = NULL;
+}
+
+static
+#ifdef Z7_OLD_WIN_SDK
+ BOOL
+#else
+ INT_PTR
+#endif
+CALLBACK MyDlgProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ UNUSED_VAR(lParam)
+
+ switch (message)
+ {
+ case WM_INITDIALOG:
+ g_Path_HWND = GetDlgItem(hwnd, IDE_EXTRACT_PATH);
+ g_InfoLine_HWND = GetDlgItem(hwnd, IDT_CUR_FILE);
+ g_Progress_HWND = GetDlgItem(hwnd, IDC_PROGRESS);
+
+ SetWindowTextW(hwnd, k_7zip_with_Ver_Uninstall);
+ SetDlgItemTextW(hwnd, IDE_EXTRACT_PATH, path);
+
+ ShowWindow(g_Progress_HWND, SW_HIDE);
+ ShowWindow(g_InfoLine_HWND, SW_HIDE);
+
+ break;
+
+ case WM_COMMAND:
+ switch (LOWORD(wParam))
+ {
+ case IDOK:
+ {
+ if (g_Finished)
+ {
+ OnClose();
+ break;
+ }
+ if (!g_Install_was_Pressed)
+ {
+ SendMessage(hwnd, WM_NEXTDLGCTL, (WPARAM)(void *)GetDlgItem(hwnd, IDCANCEL), TRUE);
+
+ EnableWindow(g_Path_HWND, FALSE);
+ EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
+
+ g_Install_was_Pressed = True;
+ return TRUE;
+ }
+ break;
+ }
+
+ case IDCANCEL:
+ {
+ OnClose();
+ break;
+ }
+
+ default: return FALSE;
+ }
+ break;
+
+ case WM_CLOSE:
+ OnClose();
+ break;
+ /*
+ case WM_DESTROY:
+ PostQuitMessage(0);
+ return TRUE;
+ */
+ default:
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ lpCmdLine, int nCmdShow)
+{
+ const wchar_t *cmdParams;
+ BoolInt useTemp = True;
+
+ UNUSED_VAR(hPrevInstance)
+ UNUSED_VAR(lpCmdLine)
+ UNUSED_VAR(nCmdShow)
+
+ #ifndef UNDER_CE
+ CoInitialize(NULL);
+ #endif
+
+ #ifndef UNDER_CE
+ func_RegDeleteKeyExW = (Func_RegDeleteKeyExW) MY_CAST_FUNC
+ GetProcAddress(GetModuleHandleW(L"advapi32.dll"), "RegDeleteKeyExW");
+ #endif
+
+ {
+ const wchar_t *s = GetCommandLineW();
+
+ #ifndef UNDER_CE
+ s = GetCmdParam(s);
+ #endif
+
+ cmdParams = s;
+
+ for (;;)
+ {
+ {
+ wchar_t c = *s;
+ if (c == 0)
+ break;
+ if (c == ' ')
+ {
+ s++;
+ continue;
+ }
+ }
+
+ {
+ const wchar_t *s2 = GetCmdParam(s);
+ BoolInt error = True;
+ if (cmd[0] == '/')
+ {
+ if (cmd[1] == 'S')
+ {
+ if (cmd[2] == 0)
+ {
+ g_SilentMode = True;
+ error = False;
+ }
+ }
+ else if (cmd[1] == 'N')
+ {
+ if (cmd[2] == 0)
+ {
+ useTemp = False;
+ error = False;
+ }
+ }
+ else if (cmd[1] == 'D' && cmd[2] == '=')
+ {
+ wcscpy(workDir, cmd + 3);
+ // RemoveQuotes(workDir);
+ useTemp = False;
+ error = False;
+ }
+ }
+ s = s2;
+ if (error && cmdError[0] == 0)
+ wcscpy(cmdError, cmd);
+ }
+ }
+
+ if (cmdError[0] != 0)
+ {
+ if (!g_SilentMode)
+ PrintErrorMessage("Unsupported command:", cmdError);
+ return 1;
+ }
+ }
+
+ {
+ wchar_t *name;
+ const DWORD len = GetModuleFileNameW(NULL, modulePath, MAX_PATH);
+ if (len == 0 || len > MAX_PATH)
+ return 1;
+
+ name = NULL;
+ wcscpy(modulePrefix, modulePath);
+
+ {
+ wchar_t *s = modulePrefix;
+ for (;;)
+ {
+ const wchar_t c = *s++;
+ if (c == 0)
+ break;
+ if (c == WCHAR_PATH_SEPARATOR)
+ name = s;
+ }
+ }
+
+ if (!name)
+ return 1;
+
+ if (!AreStringsEqual_NoCase(name, kUninstallExe))
+ useTemp = False;
+
+ *name = 0; // keep only prefix for modulePrefix
+ }
+
+
+ if (useTemp)
+ {
+ DWORD winRes = GetTempPathW(MAX_PATH, path);
+
+ // GetTempPath: the returned string ends with a backslash
+ /*
+ {
+ WCHAR s[MAX_PATH + 1];
+ wcscpy(s, path);
+ GetLongPathNameW(s, path, MAX_PATH);
+ }
+ */
+
+ if (winRes != 0 && winRes <= MAX_PATH + 1
+ && !IsString1PrefixedByString2_NoCase(modulePrefix, path))
+ {
+ unsigned i;
+ DWORD d;
+
+ const size_t pathLen = wcslen(path);
+ d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
+
+ for (i = 0; i < 100; i++, d += GetTickCount())
+ {
+ CpyAscii(path + pathLen, "7z");
+
+ {
+ wchar_t *s = path + wcslen(path);
+ UInt32 value = d;
+ unsigned k;
+ for (k = 0; k < 8; k++)
+ {
+ const unsigned t = value & 0xF;
+ value >>= 4;
+ s[7 - k] = (wchar_t)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+ }
+ s[k] = 0;
+ }
+
+ if (DoesFileOrDirExist())
+ continue;
+ if (CreateDirectoryW(path, NULL))
+ {
+ CatAscii(path, STRING_PATH_SEPARATOR);
+ wcscpy(tempPath, path);
+ break;
+ }
+ if (GetLastError() != ERROR_ALREADY_EXISTS)
+ break;
+ }
+
+ if (tempPath[0] != 0)
+ {
+ wcscpy(copyPath, tempPath);
+ CatAscii(copyPath, "Uninst.exe"); // we need not "Uninstall.exe" here
+
+ if (CopyFileW(modulePath, copyPath, TRUE))
+ {
+ RemoveFileAfterReboot2(copyPath);
+ RemoveFileAfterReboot2(tempPath);
+
+ {
+ STARTUPINFOW si;
+ PROCESS_INFORMATION pi;
+ cmdLine[0] = 0;
+
+ // maybe CreateProcess supports path with spaces even without quotes.
+ AddPathParam(cmdLine, copyPath);
+ CatAscii(cmdLine, " /N /D=");
+ AddPathParam(cmdLine, modulePrefix);
+
+ if (cmdParams[0] != 0 && wcslen(cmdParams) < MAX_PATH * 2 + 10)
+ wcscat(cmdLine, cmdParams);
+
+ memset(&si, 0, sizeof(si));
+ si.cb = sizeof(si);
+
+ if (CreateProcessW(NULL, cmdLine, NULL, NULL, FALSE, 0, NULL, tempPath, &si, &pi))
+ {
+ CloseHandle(pi.hThread);
+ if (pi.hProcess)
+ {
+ CloseHandle(pi.hProcess);
+ return 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ wcscpy(path, modulePrefix);
+
+ if (workDir[0] != 0)
+ {
+ wcscpy(path, workDir);
+ NormalizePrefix(path);
+ }
+
+ /*
+ if (path[0] == 0)
+ {
+ HKEY key = 0;
+ BoolInt ok = False;
+ LONG res = RegOpenKeyExW(HKEY_CURRENT_USER, k_Reg_Software_7zip, 0, KEY_READ | k_Reg_WOW_Flag, &key);
+ if (res == ERROR_SUCCESS)
+ {
+ ok = MyRegistry_QueryString(key, k_Reg_Path32, path);
+ // ok = MyRegistry_QueryString(key, k_Reg_Path, path);
+ RegCloseKey(key);
+ }
+ }
+ */
+
+
+ if (g_SilentMode)
+ return Install();
+
+ {
+ int retCode = 1;
+ g_HWND = CreateDialog(
+ hInstance,
+ // GetModuleHandle(NULL),
+ MAKEINTRESOURCE(IDD_INSTALL), NULL, MyDlgProc);
+ if (!g_HWND)
+ return 1;
+
+ {
+ const HICON hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON));
+ // SendMessage(g_HWND, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)hIcon);
+ SendMessage(g_HWND, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)hIcon);
+ }
+
+ {
+ BOOL bRet;
+ MSG msg;
+
+ while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0)
+ {
+ if (bRet == -1)
+ return retCode;
+ if (!g_HWND)
+ return retCode;
+
+ if (!IsDialogMessage(g_HWND, &msg))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ if (!g_HWND)
+ return retCode;
+
+ if (g_Install_was_Pressed && !g_Finished)
+ {
+ retCode = Install();
+ g_Finished = True;
+ if (retCode != 0)
+ break;
+ if (!g_HWND)
+ break;
+ {
+ SetDlgItemTextW(g_HWND, IDOK, L"Close");
+ EnableWindow(GetDlgItem(g_HWND, IDOK), TRUE);
+ EnableWindow(GetDlgItem(g_HWND, IDCANCEL), FALSE);
+ SendMessage(g_HWND, WM_NEXTDLGCTL, (WPARAM)(void *)GetDlgItem(g_HWND, IDOK), TRUE);
+ }
+ }
+ }
+
+ if (g_HWND)
+ {
+ DestroyWindow(g_HWND);
+ g_HWND = NULL;
+ }
+ }
+
+ return retCode;
+ }
+}
diff --git a/C/Util/7zipUninstall/7zipUninstall.dsp b/C/Util/7zipUninstall/7zipUninstall.dsp
new file mode 100644
index 0000000..bb7473f
--- /dev/null
+++ b/C/Util/7zipUninstall/7zipUninstall.dsp
@@ -0,0 +1,132 @@
+# Microsoft Developer Studio Project File - Name="7zipUninstall" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=7zipUninstall - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "7zipUninstall.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "7zipUninstall.mak" CFG="7zipUninstall - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "7zipUninstall - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "7zipUninstall - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "7zipUninstall - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE2" /D "UNICODE2" /FAcs /Yu"Precomp.h" /FD /GF /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"Release/Uninstall.exe"
+
+!ELSEIF "$(CFG)" == "7zipUninstall - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE2" /D "UNICODE2" /Yu"Precomp.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"Debug/Uninstall.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "7zipUninstall - Win32 Release"
+# Name "7zipUninstall - Win32 Debug"
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zVersion.h
+# End Source File
+# End Group
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.c
+# ADD CPP /Yc"Precomp.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7zipUninstall.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# End Target
+# End Project
diff --git a/C/Util/7zipUninstall/7zipUninstall.dsw b/C/Util/7zipUninstall/7zipUninstall.dsw
new file mode 100644
index 0000000..2873eda
--- /dev/null
+++ b/C/Util/7zipUninstall/7zipUninstall.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "7zipUninstall"=.\7zipUninstall.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/C/Util/7zipUninstall/7zipUninstall.ico b/C/Util/7zipUninstall/7zipUninstall.ico
new file mode 100644
index 0000000..19eb20c
--- /dev/null
+++ b/C/Util/7zipUninstall/7zipUninstall.ico
Binary files differ
diff --git a/C/Util/7zipUninstall/7zipUninstall.manifest b/C/Util/7zipUninstall/7zipUninstall.manifest
new file mode 100644
index 0000000..a601443
--- /dev/null
+++ b/C/Util/7zipUninstall/7zipUninstall.manifest
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+<assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7-Zip.7-Zip.Uninstall" type="win32"/>
+<description>7-Zip Uninstaller</description>
+<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2"><security><requestedPrivileges>
+ <requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
+</requestedPrivileges></security></trustInfo>
+<dependency><dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/></dependentAssembly></dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7 --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8 --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10 --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+<asmv3:application><asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
+<dpiAware>true</dpiAware></asmv3:windowsSettings></asmv3:application>
+</assembly>
diff --git a/C/Util/7zipUninstall/Precomp.c b/C/Util/7zipUninstall/Precomp.c
new file mode 100644
index 0000000..01605e3
--- /dev/null
+++ b/C/Util/7zipUninstall/Precomp.c
@@ -0,0 +1,4 @@
+/* Precomp.c -- StdAfx
+2013-01-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
diff --git a/C/Util/7zipUninstall/Precomp.h b/C/Util/7zipUninstall/Precomp.h
new file mode 100644
index 0000000..bc8fa21
--- /dev/null
+++ b/C/Util/7zipUninstall/Precomp.h
@@ -0,0 +1,14 @@
+/* Precomp.h -- StdAfx
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_PRECOMP_H
+#define ZIP7_INC_PRECOMP_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../Compiler.h"
+#include "../../7zTypes.h"
+
+#endif
diff --git a/C/Util/7zipUninstall/makefile b/C/Util/7zipUninstall/makefile
new file mode 100644
index 0000000..9d8aafc
--- /dev/null
+++ b/C/Util/7zipUninstall/makefile
@@ -0,0 +1,18 @@
+PROG = 7zipUninstall.exe
+MY_FIXED = 1
+
+!IFDEF Z7_64BIT_INSTALLER
+CFLAGS = $(CFLAGS) -DZ7_64BIT_INSTALLER
+!ENDIF
+
+MAIN_OBJS = \
+ $O\7zipUninstall.obj \
+
+OBJS = \
+ $(MAIN_OBJS) \
+ $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(MAIN_OBJS): $(*B).c
+ $(COMPL_O1)
diff --git a/C/Util/7zipUninstall/resource.h b/C/Util/7zipUninstall/resource.h
new file mode 100644
index 0000000..b5c33ff
--- /dev/null
+++ b/C/Util/7zipUninstall/resource.h
@@ -0,0 +1,9 @@
+#define IDD_INSTALL 100
+
+#define IDT_EXTRACT_EXTRACT_TO 110
+#define IDE_EXTRACT_PATH 111
+
+#define IDT_CUR_FILE 113
+#define IDC_PROGRESS 114
+
+#define IDI_ICON 1
diff --git a/C/Util/7zipUninstall/resource.rc b/C/Util/7zipUninstall/resource.rc
new file mode 100644
index 0000000..00bdcc0
--- /dev/null
+++ b/C/Util/7zipUninstall/resource.rc
@@ -0,0 +1,47 @@
+#include <winnt.h>
+#include <WinUser.h>
+#include <CommCtrl.h>
+
+#define USE_COPYRIGHT_CR
+#include "../../7zVersion.rc"
+#include "resource.h"
+
+MY_VERSION_INFO(MY_VFT_APP, "7-Zip Uninstaller", "Uninstall", "Uninstall.exe")
+
+1 ICON "7zipUninstall.ico"
+
+#define xc 184
+#define yc 96
+
+#define m 8
+#define bxs 64
+#define bys 16
+
+
+#define xs (xc + m + m)
+#define ys (yc + m + m)
+
+#define bx1 (xs - m - bxs)
+#define bx2 (bx1 - m - bxs)
+
+#define by (ys - m - bys)
+
+IDD_INSTALL DIALOG 0, 0, xs, ys
+STYLE DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_VISIBLE
+CAPTION "Uninstall 7-Zip"
+FONT 8, "MS Shell Dlg"
+BEGIN
+ LTEXT "Uninstall from:", IDT_EXTRACT_EXTRACT_TO, m, m, xc, 8
+ EDITTEXT IDE_EXTRACT_PATH, m, 21, xc, 14, ES_AUTOHSCROLL | WS_DISABLED
+
+
+ LTEXT "", IDT_CUR_FILE, m, 50, xc, 8
+ CONTROL "", IDC_PROGRESS, "msctls_progress32", WS_BORDER, m, 64, xc, 10
+
+ DEFPUSHBUTTON "&Uninstall", IDOK, bx2, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+END
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "7zipUninstall.manifest"
+#endif
diff --git a/C/Util/Lzma/LzmaUtil.c b/C/Util/Lzma/LzmaUtil.c
index 82130e8..b9b974b 100644
--- a/C/Util/Lzma/LzmaUtil.c
+++ b/C/Util/Lzma/LzmaUtil.c
@@ -1,258 +1,313 @@
-/* LzmaUtil.c -- Test application for LZMA compression
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "../../Precomp.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "../../CpuArch.h"
-
-#include "../../Alloc.h"
-#include "../../7zFile.h"
-#include "../../7zVersion.h"
-#include "../../LzmaDec.h"
-#include "../../LzmaEnc.h"
-
-static const char * const kCantReadMessage = "Can not read input file";
-static const char * const kCantWriteMessage = "Can not write output file";
-static const char * const kCantAllocateMessage = "Can not allocate memory";
-static const char * const kDataErrorMessage = "Data error";
-
-static void PrintHelp(char *buffer)
-{
- strcat(buffer,
- "\nLZMA-C " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n\n"
- "Usage: lzma <e|d> inputFile outputFile\n"
- " e: encode file\n"
- " d: decode file\n");
-}
-
-static int PrintError(char *buffer, const char *message)
-{
- strcat(buffer, "\nError: ");
- strcat(buffer, message);
- strcat(buffer, "\n");
- return 1;
-}
-
-static int PrintErrorNumber(char *buffer, SRes val)
-{
- sprintf(buffer + strlen(buffer), "\nError code: %x\n", (unsigned)val);
- return 1;
-}
-
-static int PrintUserError(char *buffer)
-{
- return PrintError(buffer, "Incorrect command");
-}
-
-
-#define IN_BUF_SIZE (1 << 16)
-#define OUT_BUF_SIZE (1 << 16)
-
-
-static SRes Decode2(CLzmaDec *state, ISeqOutStream *outStream, ISeqInStream *inStream,
- UInt64 unpackSize)
-{
- int thereIsSize = (unpackSize != (UInt64)(Int64)-1);
- Byte inBuf[IN_BUF_SIZE];
- Byte outBuf[OUT_BUF_SIZE];
- size_t inPos = 0, inSize = 0, outPos = 0;
- LzmaDec_Init(state);
- for (;;)
- {
- if (inPos == inSize)
- {
- inSize = IN_BUF_SIZE;
- RINOK(inStream->Read(inStream, inBuf, &inSize));
- inPos = 0;
- }
- {
- SRes res;
- SizeT inProcessed = inSize - inPos;
- SizeT outProcessed = OUT_BUF_SIZE - outPos;
- ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
- ELzmaStatus status;
- if (thereIsSize && outProcessed > unpackSize)
- {
- outProcessed = (SizeT)unpackSize;
- finishMode = LZMA_FINISH_END;
- }
-
- res = LzmaDec_DecodeToBuf(state, outBuf + outPos, &outProcessed,
- inBuf + inPos, &inProcessed, finishMode, &status);
- inPos += inProcessed;
- outPos += outProcessed;
- unpackSize -= outProcessed;
-
- if (outStream)
- if (outStream->Write(outStream, outBuf, outPos) != outPos)
- return SZ_ERROR_WRITE;
-
- outPos = 0;
-
- if (res != SZ_OK || (thereIsSize && unpackSize == 0))
- return res;
-
- if (inProcessed == 0 && outProcessed == 0)
- {
- if (thereIsSize || status != LZMA_STATUS_FINISHED_WITH_MARK)
- return SZ_ERROR_DATA;
- return res;
- }
- }
- }
-}
-
-
-static SRes Decode(ISeqOutStream *outStream, ISeqInStream *inStream)
-{
- UInt64 unpackSize;
- int i;
- SRes res = 0;
-
- CLzmaDec state;
-
- /* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
- unsigned char header[LZMA_PROPS_SIZE + 8];
-
- /* Read and parse header */
-
- RINOK(SeqInStream_Read(inStream, header, sizeof(header)));
-
- unpackSize = 0;
- for (i = 0; i < 8; i++)
- unpackSize += (UInt64)header[LZMA_PROPS_SIZE + i] << (i * 8);
-
- LzmaDec_Construct(&state);
- RINOK(LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc));
- res = Decode2(&state, outStream, inStream, unpackSize);
- LzmaDec_Free(&state, &g_Alloc);
- return res;
-}
-
-static SRes Encode(ISeqOutStream *outStream, ISeqInStream *inStream, UInt64 fileSize, char *rs)
-{
- CLzmaEncHandle enc;
- SRes res;
- CLzmaEncProps props;
-
- UNUSED_VAR(rs);
-
- enc = LzmaEnc_Create(&g_Alloc);
- if (enc == 0)
- return SZ_ERROR_MEM;
-
- LzmaEncProps_Init(&props);
- res = LzmaEnc_SetProps(enc, &props);
-
- if (res == SZ_OK)
- {
- Byte header[LZMA_PROPS_SIZE + 8];
- size_t headerSize = LZMA_PROPS_SIZE;
- int i;
-
- res = LzmaEnc_WriteProperties(enc, header, &headerSize);
- for (i = 0; i < 8; i++)
- header[headerSize++] = (Byte)(fileSize >> (8 * i));
- if (outStream->Write(outStream, header, headerSize) != headerSize)
- res = SZ_ERROR_WRITE;
- else
- {
- if (res == SZ_OK)
- res = LzmaEnc_Encode(enc, outStream, inStream, NULL, &g_Alloc, &g_Alloc);
- }
- }
- LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
- return res;
-}
-
-
-static int main2(int numArgs, const char *args[], char *rs)
-{
- CFileSeqInStream inStream;
- CFileOutStream outStream;
- char c;
- int res;
- int encodeMode;
- BoolInt useOutFile = False;
-
- FileSeqInStream_CreateVTable(&inStream);
- File_Construct(&inStream.file);
-
- FileOutStream_CreateVTable(&outStream);
- File_Construct(&outStream.file);
-
- if (numArgs == 1)
- {
- PrintHelp(rs);
- return 0;
- }
-
- if (numArgs < 3 || numArgs > 4 || strlen(args[1]) != 1)
- return PrintUserError(rs);
-
- c = args[1][0];
- encodeMode = (c == 'e' || c == 'E');
- if (!encodeMode && c != 'd' && c != 'D')
- return PrintUserError(rs);
-
- {
- size_t t4 = sizeof(UInt32);
- size_t t8 = sizeof(UInt64);
- if (t4 != 4 || t8 != 8)
- return PrintError(rs, "Incorrect UInt32 or UInt64");
- }
-
- if (InFile_Open(&inStream.file, args[2]) != 0)
- return PrintError(rs, "Can not open input file");
-
- if (numArgs > 3)
- {
- useOutFile = True;
- if (OutFile_Open(&outStream.file, args[3]) != 0)
- return PrintError(rs, "Can not open output file");
- }
- else if (encodeMode)
- PrintUserError(rs);
-
- if (encodeMode)
- {
- UInt64 fileSize;
- File_GetLength(&inStream.file, &fileSize);
- res = Encode(&outStream.vt, &inStream.vt, fileSize, rs);
- }
- else
- {
- res = Decode(&outStream.vt, useOutFile ? &inStream.vt : NULL);
- }
-
- if (useOutFile)
- File_Close(&outStream.file);
- File_Close(&inStream.file);
-
- if (res != SZ_OK)
- {
- if (res == SZ_ERROR_MEM)
- return PrintError(rs, kCantAllocateMessage);
- else if (res == SZ_ERROR_DATA)
- return PrintError(rs, kDataErrorMessage);
- else if (res == SZ_ERROR_WRITE)
- return PrintError(rs, kCantWriteMessage);
- else if (res == SZ_ERROR_READ)
- return PrintError(rs, kCantReadMessage);
- return PrintErrorNumber(rs, res);
- }
- return 0;
-}
-
-
-int MY_CDECL main(int numArgs, const char *args[])
-{
- char rs[800] = { 0 };
- int res = main2(numArgs, args, rs);
- fputs(rs, stdout);
- return res;
-}
+/* LzmaUtil.c -- Test application for LZMA compression
+2023-03-07 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../CpuArch.h"
+
+#include "../../Alloc.h"
+#include "../../7zFile.h"
+#include "../../7zVersion.h"
+#include "../../LzFind.h"
+#include "../../LzmaDec.h"
+#include "../../LzmaEnc.h"
+
+static const char * const kCantReadMessage = "Cannot read input file";
+static const char * const kCantWriteMessage = "Cannot write output file";
+static const char * const kCantAllocateMessage = "Cannot allocate memory";
+static const char * const kDataErrorMessage = "Data error";
+
+static void Print(const char *s)
+{
+ fputs(s, stdout);
+}
+
+static void PrintHelp(void)
+{
+ Print(
+ "\n" "LZMA-C " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE
+ "\n"
+ "\n" "Usage: lzma <e|d> inputFile outputFile"
+ "\n" " e: encode file"
+ "\n" " d: decode file"
+ "\n");
+}
+
+static int PrintError(const char *message)
+{
+ Print("\nError: ");
+ Print(message);
+ Print("\n");
+ return 1;
+}
+
+#define CONVERT_INT_TO_STR(charType, tempSize) \
+ unsigned char temp[tempSize]; unsigned i = 0; \
+ while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
+ *s++ = (charType)('0' + (unsigned)val); \
+ while (i != 0) { i--; *s++ = (charType)temp[i]; } \
+ *s = 0; \
+ return s;
+
+static char * Convert_unsigned_To_str(unsigned val, char *s)
+{
+ CONVERT_INT_TO_STR(char, 32)
+}
+
+static void Print_unsigned(unsigned code)
+{
+ char str[32];
+ Convert_unsigned_To_str(code, str);
+ Print(str);
+}
+
+static int PrintError_WRes(const char *message, WRes wres)
+{
+ PrintError(message);
+ Print("\nSystem error code: ");
+ Print_unsigned((unsigned)wres);
+ #ifndef _WIN32
+ {
+ const char *s = strerror(wres);
+ if (s)
+ {
+ Print(" : ");
+ Print(s);
+ }
+ }
+ #endif
+ Print("\n");
+ return 1;
+}
+
+static int PrintErrorNumber(SRes val)
+{
+ Print("\n7-Zip error code: ");
+ Print_unsigned((unsigned)val);
+ Print("\n");
+ return 1;
+}
+
+static int PrintUserError(void)
+{
+ return PrintError("Incorrect command");
+}
+
+
+#define IN_BUF_SIZE (1 << 16)
+#define OUT_BUF_SIZE (1 << 16)
+
+
+static SRes Decode2(CLzmaDec *state, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
+ UInt64 unpackSize)
+{
+ const int thereIsSize = (unpackSize != (UInt64)(Int64)-1);
+ Byte inBuf[IN_BUF_SIZE];
+ Byte outBuf[OUT_BUF_SIZE];
+ size_t inPos = 0, inSize = 0, outPos = 0;
+ LzmaDec_Init(state);
+ for (;;)
+ {
+ if (inPos == inSize)
+ {
+ inSize = IN_BUF_SIZE;
+ RINOK(inStream->Read(inStream, inBuf, &inSize))
+ inPos = 0;
+ }
+ {
+ SRes res;
+ SizeT inProcessed = inSize - inPos;
+ SizeT outProcessed = OUT_BUF_SIZE - outPos;
+ ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+ ELzmaStatus status;
+ if (thereIsSize && outProcessed > unpackSize)
+ {
+ outProcessed = (SizeT)unpackSize;
+ finishMode = LZMA_FINISH_END;
+ }
+
+ res = LzmaDec_DecodeToBuf(state, outBuf + outPos, &outProcessed,
+ inBuf + inPos, &inProcessed, finishMode, &status);
+ inPos += inProcessed;
+ outPos += outProcessed;
+ unpackSize -= outProcessed;
+
+ if (outStream)
+ if (outStream->Write(outStream, outBuf, outPos) != outPos)
+ return SZ_ERROR_WRITE;
+
+ outPos = 0;
+
+ if (res != SZ_OK || (thereIsSize && unpackSize == 0))
+ return res;
+
+ if (inProcessed == 0 && outProcessed == 0)
+ {
+ if (thereIsSize || status != LZMA_STATUS_FINISHED_WITH_MARK)
+ return SZ_ERROR_DATA;
+ return res;
+ }
+ }
+ }
+}
+
+
+static SRes Decode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream)
+{
+ UInt64 unpackSize;
+ int i;
+ SRes res = 0;
+
+ CLzmaDec state;
+
+ /* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
+ unsigned char header[LZMA_PROPS_SIZE + 8];
+
+ /* Read and parse header */
+
+ {
+ size_t size = sizeof(header);
+ RINOK(SeqInStream_ReadMax(inStream, header, &size))
+ if (size != sizeof(header))
+ return SZ_ERROR_INPUT_EOF;
+ }
+ unpackSize = 0;
+ for (i = 0; i < 8; i++)
+ unpackSize += (UInt64)header[LZMA_PROPS_SIZE + i] << (i * 8);
+
+ LzmaDec_CONSTRUCT(&state)
+ RINOK(LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc))
+ res = Decode2(&state, outStream, inStream, unpackSize);
+ LzmaDec_Free(&state, &g_Alloc);
+ return res;
+}
+
+static SRes Encode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, UInt64 fileSize)
+{
+ CLzmaEncHandle enc;
+ SRes res;
+ CLzmaEncProps props;
+
+ enc = LzmaEnc_Create(&g_Alloc);
+ if (enc == 0)
+ return SZ_ERROR_MEM;
+
+ LzmaEncProps_Init(&props);
+ res = LzmaEnc_SetProps(enc, &props);
+
+ if (res == SZ_OK)
+ {
+ Byte header[LZMA_PROPS_SIZE + 8];
+ size_t headerSize = LZMA_PROPS_SIZE;
+ int i;
+
+ res = LzmaEnc_WriteProperties(enc, header, &headerSize);
+ for (i = 0; i < 8; i++)
+ header[headerSize++] = (Byte)(fileSize >> (8 * i));
+ if (outStream->Write(outStream, header, headerSize) != headerSize)
+ res = SZ_ERROR_WRITE;
+ else
+ {
+ if (res == SZ_OK)
+ res = LzmaEnc_Encode(enc, outStream, inStream, NULL, &g_Alloc, &g_Alloc);
+ }
+ }
+ LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
+ return res;
+}
+
+
+int Z7_CDECL main(int numArgs, const char *args[])
+{
+ CFileSeqInStream inStream;
+ CFileOutStream outStream;
+ char c;
+ int res;
+ int encodeMode;
+ BoolInt useOutFile = False;
+
+ LzFindPrepare();
+
+ FileSeqInStream_CreateVTable(&inStream);
+ File_Construct(&inStream.file);
+ inStream.wres = 0;
+
+ FileOutStream_CreateVTable(&outStream);
+ File_Construct(&outStream.file);
+ outStream.wres = 0;
+
+ if (numArgs == 1)
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ if (numArgs < 3 || numArgs > 4 || strlen(args[1]) != 1)
+ return PrintUserError();
+
+ c = args[1][0];
+ encodeMode = (c == 'e' || c == 'E');
+ if (!encodeMode && c != 'd' && c != 'D')
+ return PrintUserError();
+
+ /*
+ {
+ size_t t4 = sizeof(UInt32);
+ size_t t8 = sizeof(UInt64);
+ if (t4 != 4 || t8 != 8)
+ return PrintError("Incorrect UInt32 or UInt64");
+ }
+ */
+
+ {
+ const WRes wres = InFile_Open(&inStream.file, args[2]);
+ if (wres != 0)
+ return PrintError_WRes("Cannot open input file", wres);
+ }
+
+ if (numArgs > 3)
+ {
+ WRes wres;
+ useOutFile = True;
+ wres = OutFile_Open(&outStream.file, args[3]);
+ if (wres != 0)
+ return PrintError_WRes("Cannot open output file", wres);
+ }
+ else if (encodeMode)
+ PrintUserError();
+
+ if (encodeMode)
+ {
+ UInt64 fileSize;
+ const WRes wres = File_GetLength(&inStream.file, &fileSize);
+ if (wres != 0)
+ return PrintError_WRes("Cannot get file length", wres);
+ res = Encode(&outStream.vt, &inStream.vt, fileSize);
+ }
+ else
+ {
+ res = Decode(&outStream.vt, useOutFile ? &inStream.vt : NULL);
+ }
+
+ if (useOutFile)
+ File_Close(&outStream.file);
+ File_Close(&inStream.file);
+
+ if (res != SZ_OK)
+ {
+ if (res == SZ_ERROR_MEM)
+ return PrintError(kCantAllocateMessage);
+ else if (res == SZ_ERROR_DATA)
+ return PrintError(kDataErrorMessage);
+ else if (res == SZ_ERROR_WRITE)
+ return PrintError_WRes(kCantWriteMessage, outStream.wres);
+ else if (res == SZ_ERROR_READ)
+ return PrintError_WRes(kCantReadMessage, inStream.wres);
+ return PrintErrorNumber(res);
+ }
+ return 0;
+}
diff --git a/C/Util/Lzma/LzmaUtil.dsp b/C/Util/Lzma/LzmaUtil.dsp
index eedde07..e2e7d42 100644
--- a/C/Util/Lzma/LzmaUtil.dsp
+++ b/C/Util/Lzma/LzmaUtil.dsp
@@ -1,168 +1,188 @@
-# Microsoft Developer Studio Project File - Name="LzmaUtil" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=LzmaUtil - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "LzmaUtil.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "LzmaUtil.mak" CFG="LzmaUtil - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "LzmaUtil - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "LzmaUtil - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "LzmaUtil - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /MT /W4 /WX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\util\7lzma.exe"
-
-!ELSEIF "$(CFG)" == "LzmaUtil - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /MTd /W4 /WX /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\util\7lzma.exe" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "LzmaUtil - Win32 Release"
-# Name "LzmaUtil - Win32 Debug"
-# Begin Source File
-
-SOURCE=..\..\7zFile.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zFile.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zStream.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zTypes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zVersion.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Alloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\CpuArch.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFind.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFindMt.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFindMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzHash.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaEnc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaEnc.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\LzmaUtil.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Threads.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Threads.h
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="LzmaUtil" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=LzmaUtil - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "LzmaUtil.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "LzmaUtil.mak" CFG="LzmaUtil - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "LzmaUtil - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "LzmaUtil - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "LzmaUtil - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MT /W4 /WX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\util\7lzma.exe"
+
+!ELSEIF "$(CFG)" == "LzmaUtil - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W4 /WX /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\util\7lzma.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "LzmaUtil - Win32 Release"
+# Name "LzmaUtil - Win32 Debug"
+# Begin Source File
+
+SOURCE=..\..\7zFile.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zStream.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Alloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFind.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFindMt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFindOpt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaEnc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LzmaUtil.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Precomp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Threads.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Threads.h
+# End Source File
+# End Target
+# End Project
diff --git a/C/Util/Lzma/LzmaUtil.dsw b/C/Util/Lzma/LzmaUtil.dsw
index f435487..c52eaf6 100644
--- a/C/Util/Lzma/LzmaUtil.dsw
+++ b/C/Util/Lzma/LzmaUtil.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "LzmaUtil"=.\LzmaUtil.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "LzmaUtil"=.\LzmaUtil.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/C/Util/Lzma/Precomp.h b/C/Util/Lzma/Precomp.h
new file mode 100644
index 0000000..bc8fa21
--- /dev/null
+++ b/C/Util/Lzma/Precomp.h
@@ -0,0 +1,14 @@
+/* Precomp.h -- StdAfx
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_PRECOMP_H
+#define ZIP7_INC_PRECOMP_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../Compiler.h"
+#include "../../7zTypes.h"
+
+#endif
diff --git a/C/Util/Lzma/makefile b/C/Util/Lzma/makefile
index 3b825f2..7813bdb 100644
--- a/C/Util/Lzma/makefile
+++ b/C/Util/Lzma/makefile
@@ -1,28 +1,30 @@
-# MY_STATIC_LINK=1
-PROG = LZMAc.exe
-
-CFLAGS = $(CFLAGS) \
-
-LIB_OBJS = \
- $O\LzmaUtil.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\LzFind.obj \
- $O\LzFindMt.obj \
- $O\LzmaDec.obj \
- $O\LzmaEnc.obj \
- $O\7zFile.obj \
- $O\7zStream.obj \
- $O\Threads.obj \
-
-OBJS = \
- $(LIB_OBJS) \
- $(C_OBJS) \
-
-!include "../../../CPP/Build.mak"
-
-$(LIB_OBJS): $(*B).c
- $(COMPL_O2)
-$(C_OBJS): ../../$(*B).c
- $(COMPL_O2)
+# MY_STATIC_LINK=1
+PROG = LZMAc.exe
+
+CFLAGS = $(CFLAGS) \
+
+LIB_OBJS = \
+ $O\LzmaUtil.obj \
+
+C_OBJS = \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\LzFindOpt.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\7zFile.obj \
+ $O\7zStream.obj \
+ $O\Threads.obj \
+
+OBJS = \
+ $(LIB_OBJS) \
+ $(C_OBJS) \
+
+!include "../../../CPP/Build.mak"
+
+$(LIB_OBJS): $(*B).c
+ $(COMPL_O2)
+$(C_OBJS): ../../$(*B).c
+ $(COMPL_O2)
diff --git a/C/Util/Lzma/makefile.gcc b/C/Util/Lzma/makefile.gcc
index 12a72bb..2acb0b8 100644
--- a/C/Util/Lzma/makefile.gcc
+++ b/C/Util/Lzma/makefile.gcc
@@ -1,44 +1,21 @@
-PROG = lzma
-CXX = g++
-LIB =
-RM = rm -f
-CFLAGS = -c -O2 -Wall -D_7ZIP_ST
-
-OBJS = \
- LzmaUtil.o \
- Alloc.o \
- LzFind.o \
- LzmaDec.o \
- LzmaEnc.o \
- 7zFile.o \
- 7zStream.o \
-
-
-all: $(PROG)
-
-$(PROG): $(OBJS)
- $(CXX) -o $(PROG) $(LDFLAGS) $(OBJS) $(LIB) $(LIB2)
-
-LzmaUtil.o: LzmaUtil.c
- $(CXX) $(CFLAGS) LzmaUtil.c
-
-Alloc.o: ../../Alloc.c
- $(CXX) $(CFLAGS) ../../Alloc.c
-
-LzFind.o: ../../LzFind.c
- $(CXX) $(CFLAGS) ../../LzFind.c
-
-LzmaDec.o: ../../LzmaDec.c
- $(CXX) $(CFLAGS) ../../LzmaDec.c
-
-LzmaEnc.o: ../../LzmaEnc.c
- $(CXX) $(CFLAGS) ../../LzmaEnc.c
-
-7zFile.o: ../../7zFile.c
- $(CXX) $(CFLAGS) ../../7zFile.c
-
-7zStream.o: ../../7zStream.c
- $(CXX) $(CFLAGS) ../../7zStream.c
-
-clean:
- -$(RM) $(PROG) $(OBJS)
+PROG = 7lzma
+
+include ../../../CPP/7zip/LzmaDec_gcc.mak
+
+
+OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $O/7zFile.o \
+ $O/7zStream.o \
+ $O/Alloc.o \
+ $O/CpuArch.o \
+ $O/LzFind.o \
+ $O/LzFindMt.o \
+ $O/LzFindOpt.o \
+ $O/LzmaDec.o \
+ $O/LzmaEnc.o \
+ $O/LzmaUtil.o \
+ $O/Threads.o \
+
+
+include ../../7zip_gcc_c.mak
diff --git a/C/Util/LzmaLib/LzmaLib.def b/C/Util/LzmaLib/LzmaLib.def
index 43b9597..8bc6add 100644
--- a/C/Util/LzmaLib/LzmaLib.def
+++ b/C/Util/LzmaLib/LzmaLib.def
@@ -1,4 +1,4 @@
-EXPORTS
- LzmaCompress
- LzmaUncompress
-
+EXPORTS
+ LzmaCompress
+ LzmaUncompress
+
diff --git a/C/Util/LzmaLib/LzmaLib.dsp b/C/Util/LzmaLib/LzmaLib.dsp
index 0d4c981..bacd967 100644
--- a/C/Util/LzmaLib/LzmaLib.dsp
+++ b/C/Util/LzmaLib/LzmaLib.dsp
@@ -1,178 +1,202 @@
-# Microsoft Developer Studio Project File - Name="LzmaLib" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=LzmaLib - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "LzmaLib.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "LzmaLib.mak" CFG="LzmaLib - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "LzmaLib - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "LzmaLib - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "LzmaLib - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /Gr /MT /W3 /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"C:\Util\LZMA.dll" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "LzmaLib - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MTd /W3 /Gm /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /D "COMPRESS_MF_MT" /FD /GZ /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"C:\Util\LZMA.dll" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "LzmaLib - Win32 Release"
-# Name "LzmaLib - Win32 Debug"
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\LzmaLib.def
-# End Source File
-# Begin Source File
-
-SOURCE=.\LzmaLibExports.c
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\7zTypes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Alloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\IStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFind.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFindMt.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzFindMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzHash.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaEnc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaEnc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaLib.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaLib.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\resource.rc
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Threads.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Threads.h
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="LzmaLib" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=LzmaLib - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "LzmaLib.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "LzmaLib.mak" CFG="LzmaLib - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "LzmaLib - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "LzmaLib - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "LzmaLib - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /Gr /MT /W3 /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"C:\Util\LZMA.dll" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "LzmaLib - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "LZMALIB_EXPORTS" /D "COMPRESS_MF_MT" /FD /GZ /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"C:\Util\LZMA.dll" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "LzmaLib - Win32 Release"
+# Name "LzmaLib - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\LzmaLib.def
+# End Source File
+# Begin Source File
+
+SOURCE=.\LzmaLibExports.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Alloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFind.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFindMt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzFindOpt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaEnc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaLib.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaLib.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Precomp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Threads.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Threads.h
+# End Source File
+# End Target
+# End Project
diff --git a/C/Util/LzmaLib/LzmaLib.dsw b/C/Util/LzmaLib/LzmaLib.dsw
index f6c5559..6faf333 100644
--- a/C/Util/LzmaLib/LzmaLib.dsw
+++ b/C/Util/LzmaLib/LzmaLib.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "LzmaLib"=.\LzmaLib.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "LzmaLib"=.\LzmaLib.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/C/Util/LzmaLib/LzmaLibExports.c b/C/Util/LzmaLib/LzmaLibExports.c
index 02600c7..a46c9a8 100644
--- a/C/Util/LzmaLib/LzmaLibExports.c
+++ b/C/Util/LzmaLib/LzmaLibExports.c
@@ -1,14 +1,15 @@
-/* LzmaLibExports.c -- LZMA library DLL Entry point
-2015-11-08 : Igor Pavlov : Public domain */
-
-#include "../../Precomp.h"
-
-#include <windows.h>
-
-BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
-{
- UNUSED_VAR(hInstance);
- UNUSED_VAR(dwReason);
- UNUSED_VAR(lpReserved);
- return TRUE;
-}
+/* LzmaLibExports.c -- LZMA library DLL Entry point
+2023-03-05 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "../../7zWindows.h"
+
+BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved);
+BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
+{
+ UNUSED_VAR(hInstance)
+ UNUSED_VAR(dwReason)
+ UNUSED_VAR(lpReserved)
+ return TRUE;
+}
diff --git a/C/Util/LzmaLib/Precomp.c b/C/Util/LzmaLib/Precomp.c
new file mode 100644
index 0000000..01605e3
--- /dev/null
+++ b/C/Util/LzmaLib/Precomp.c
@@ -0,0 +1,4 @@
+/* Precomp.c -- StdAfx
+2013-01-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
diff --git a/C/Util/LzmaLib/Precomp.h b/C/Util/LzmaLib/Precomp.h
new file mode 100644
index 0000000..bc8fa21
--- /dev/null
+++ b/C/Util/LzmaLib/Precomp.h
@@ -0,0 +1,14 @@
+/* Precomp.h -- StdAfx
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_PRECOMP_H
+#define ZIP7_INC_PRECOMP_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../Compiler.h"
+#include "../../7zTypes.h"
+
+#endif
diff --git a/C/Util/LzmaLib/makefile b/C/Util/LzmaLib/makefile
index e0f3114..b8e054e 100644
--- a/C/Util/LzmaLib/makefile
+++ b/C/Util/LzmaLib/makefile
@@ -1,34 +1,54 @@
-MY_STATIC_LINK=1
-SLIB = sLZMA.lib
-PROG = LZMA.dll
-SLIBPATH = $O\$(SLIB)
-
-DEF_FILE = LzmaLib.def
-CFLAGS = $(CFLAGS) \
-
-LIB_OBJS = \
- $O\LzmaLibExports.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\LzFind.obj \
- $O\LzFindMt.obj \
- $O\LzmaDec.obj \
- $O\LzmaEnc.obj \
- $O\LzmaLib.obj \
- $O\Threads.obj \
-
-OBJS = \
- $(LIB_OBJS) \
- $(C_OBJS) \
- $O\resource.res
-
-!include "../../../CPP/Build.mak"
-
-$(SLIBPATH): $O $(OBJS)
- lib -out:$(SLIBPATH) $(OBJS) $(LIBS)
-
-$(LIB_OBJS): $(*B).c
- $(COMPL_O2)
-$(C_OBJS): ../../$(*B).c
- $(COMPL_O2)
+MY_STATIC_LINK=1
+SLIB = sLZMA.lib
+PROG = LZMA.dll
+SLIBPATH = $O\$(SLIB)
+
+DEF_FILE = LzmaLib.def
+CFLAGS = $(CFLAGS) \
+
+LIB_OBJS = \
+ $O\LzmaLibExports.obj \
+
+C_OBJS = \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\LzFindOpt.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\LzmaLib.obj \
+ $O\Threads.obj \
+
+OBJS = \
+ $O\Precomp.obj \
+ $(LIB_OBJS) \
+ $(C_OBJS) \
+ $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(SLIBPATH): $O $(OBJS)
+ lib -out:$(SLIBPATH) $(OBJS) $(LIBS)
+
+
+MAK_SINGLE_FILE = 1
+
+$O\Precomp.obj: Precomp.c
+ $(CCOMPL_PCH)
+
+!IFDEF MAK_SINGLE_FILE
+
+$(LIB_OBJS): $(*B).c
+ $(CCOMPL_USE)
+$(C_OBJS): ../../$(*B).c
+ $(CCOMPL_USE)
+
+!ELSE
+
+{.}.c{$O}.obj::
+ $(CCOMPLB_USE)
+{../../../C}.c{$O}.obj::
+ $(CCOMPLB_USE)
+
+!ENDIF
diff --git a/C/Util/LzmaLib/resource.rc b/C/Util/LzmaLib/resource.rc
index d95e3f3..674832e 100644
--- a/C/Util/LzmaLib/resource.rc
+++ b/C/Util/LzmaLib/resource.rc
@@ -1,3 +1,3 @@
-#include "../../7zVersion.rc"
-
-MY_VERSION_INFO_DLL("LZMA library", "LZMA")
+#include "../../7zVersion.rc"
+
+MY_VERSION_INFO_DLL("LZMA library", "LZMA")
diff --git a/C/Util/SfxSetup/Precomp.c b/C/Util/SfxSetup/Precomp.c
index 34b60f8..01605e3 100644
--- a/C/Util/SfxSetup/Precomp.c
+++ b/C/Util/SfxSetup/Precomp.c
@@ -1,4 +1,4 @@
-/* Precomp.c -- StdAfx
-2013-01-21 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
+/* Precomp.c -- StdAfx
+2013-01-21 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
diff --git a/C/Util/SfxSetup/Precomp.h b/C/Util/SfxSetup/Precomp.h
index 9f398d0..bc8fa21 100644
--- a/C/Util/SfxSetup/Precomp.h
+++ b/C/Util/SfxSetup/Precomp.h
@@ -1,10 +1,14 @@
-/* Precomp.h -- StdAfx
-2013-06-16 : Igor Pavlov : Public domain */
-
-#ifndef __7Z_PRECOMP_H
-#define __7Z_PRECOMP_H
-
-#include "../../Compiler.h"
-#include "../../7zTypes.h"
-
-#endif
+/* Precomp.h -- StdAfx
+2023-03-04 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_PRECOMP_H
+#define ZIP7_INC_PRECOMP_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../Compiler.h"
+#include "../../7zTypes.h"
+
+#endif
diff --git a/C/Util/SfxSetup/SfxSetup.c b/C/Util/SfxSetup/SfxSetup.c
index 394369a..7304a0b 100644
--- a/C/Util/SfxSetup/SfxSetup.c
+++ b/C/Util/SfxSetup/SfxSetup.c
@@ -1,640 +1,656 @@
-/* SfxSetup.c - 7z SFX Setup
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#ifndef UNICODE
-#define UNICODE
-#endif
-
-#ifndef _UNICODE
-#define _UNICODE
-#endif
-
-#ifdef _CONSOLE
-#include <stdio.h>
-#endif
-
-#include "../../7z.h"
-#include "../../7zAlloc.h"
-#include "../../7zCrc.h"
-#include "../../7zFile.h"
-#include "../../CpuArch.h"
-#include "../../DllSecur.h"
-
-#define k_EXE_ExtIndex 2
-
-#define kInputBufSize ((size_t)1 << 18)
-
-static const char * const kExts[] =
-{
- "bat"
- , "cmd"
- , "exe"
- , "inf"
- , "msi"
- #ifdef UNDER_CE
- , "cab"
- #endif
- , "html"
- , "htm"
-};
-
-static const char * const kNames[] =
-{
- "setup"
- , "install"
- , "run"
- , "start"
-};
-
-static unsigned FindExt(const wchar_t *s, unsigned *extLen)
-{
- unsigned len = (unsigned)wcslen(s);
- unsigned i;
- for (i = len; i > 0; i--)
- {
- if (s[i - 1] == '.')
- {
- *extLen = len - i;
- return i - 1;
- }
- }
- *extLen = 0;
- return len;
-}
-
-#define MAKE_CHAR_UPPER(c) ((((c) >= 'a' && (c) <= 'z') ? (c) -= 0x20 : (c)))
-
-static unsigned FindItem(const char * const *items, unsigned num, const wchar_t *s, unsigned len)
-{
- unsigned i;
- for (i = 0; i < num; i++)
- {
- const char *item = items[i];
- unsigned itemLen = (unsigned)strlen(item);
- unsigned j;
- if (len != itemLen)
- continue;
- for (j = 0; j < len; j++)
- {
- unsigned c = (Byte)item[j];
- if (c != s[j] && MAKE_CHAR_UPPER(c) != s[j])
- break;
- }
- if (j == len)
- return i;
- }
- return i;
-}
-
-#ifdef _CONSOLE
-static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
-{
- UNUSED_VAR(ctrlType);
- return TRUE;
-}
-#endif
-
-static void PrintErrorMessage(const char *message)
-{
- #ifdef _CONSOLE
- printf("\n7-Zip Error: %s\n", message);
- #else
- #ifdef UNDER_CE
- WCHAR messageW[256 + 4];
- unsigned i;
- for (i = 0; i < 256 && message[i] != 0; i++)
- messageW[i] = message[i];
- messageW[i] = 0;
- MessageBoxW(0, messageW, L"7-Zip Error", MB_ICONERROR);
- #else
- MessageBoxA(0, message, "7-Zip Error", MB_ICONERROR);
- #endif
- #endif
-}
-
-static WRes MyCreateDir(const WCHAR *name)
-{
- return CreateDirectoryW(name, NULL) ? 0 : GetLastError();
-}
-
-#ifdef UNDER_CE
-#define kBufferSize (1 << 13)
-#else
-#define kBufferSize (1 << 15)
-#endif
-
-#define kSignatureSearchLimit (1 << 22)
-
-static BoolInt FindSignature(CSzFile *stream, UInt64 *resPos)
-{
- Byte buf[kBufferSize];
- size_t numPrevBytes = 0;
- *resPos = 0;
- for (;;)
- {
- size_t processed, pos;
- if (*resPos > kSignatureSearchLimit)
- return False;
- processed = kBufferSize - numPrevBytes;
- if (File_Read(stream, buf + numPrevBytes, &processed) != 0)
- return False;
- processed += numPrevBytes;
- if (processed < k7zStartHeaderSize ||
- (processed == k7zStartHeaderSize && numPrevBytes != 0))
- return False;
- processed -= k7zStartHeaderSize;
- for (pos = 0; pos <= processed; pos++)
- {
- for (; pos <= processed && buf[pos] != '7'; pos++);
- if (pos > processed)
- break;
- if (memcmp(buf + pos, k7zSignature, k7zSignatureSize) == 0)
- if (CrcCalc(buf + pos + 12, 20) == GetUi32(buf + pos + 8))
- {
- *resPos += pos;
- return True;
- }
- }
- *resPos += processed;
- numPrevBytes = k7zStartHeaderSize;
- memmove(buf, buf + processed, k7zStartHeaderSize);
- }
-}
-
-static BoolInt DoesFileOrDirExist(const WCHAR *path)
-{
- WIN32_FIND_DATAW fd;
- HANDLE handle;
- handle = FindFirstFileW(path, &fd);
- if (handle == INVALID_HANDLE_VALUE)
- return False;
- FindClose(handle);
- return True;
-}
-
-static WRes RemoveDirWithSubItems(WCHAR *path)
-{
- WIN32_FIND_DATAW fd;
- HANDLE handle;
- WRes res = 0;
- size_t len = wcslen(path);
- wcscpy(path + len, L"*");
- handle = FindFirstFileW(path, &fd);
- path[len] = L'\0';
- if (handle == INVALID_HANDLE_VALUE)
- return GetLastError();
-
- for (;;)
- {
- if (wcscmp(fd.cFileName, L".") != 0 &&
- wcscmp(fd.cFileName, L"..") != 0)
- {
- wcscpy(path + len, fd.cFileName);
- if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
- {
- wcscat(path, WSTRING_PATH_SEPARATOR);
- res = RemoveDirWithSubItems(path);
- }
- else
- {
- SetFileAttributesW(path, 0);
- if (DeleteFileW(path) == 0)
- res = GetLastError();
- }
-
- if (res != 0)
- break;
- }
-
- if (!FindNextFileW(handle, &fd))
- {
- res = GetLastError();
- if (res == ERROR_NO_MORE_FILES)
- res = 0;
- break;
- }
- }
-
- path[len] = L'\0';
- FindClose(handle);
- if (res == 0)
- {
- if (!RemoveDirectoryW(path))
- res = GetLastError();
- }
- return res;
-}
-
-#ifdef _CONSOLE
-int MY_CDECL main()
-#else
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
- #ifdef UNDER_CE
- LPWSTR
- #else
- LPSTR
- #endif
- lpCmdLine, int nCmdShow)
-#endif
-{
- CFileInStream archiveStream;
- CLookToRead2 lookStream;
- CSzArEx db;
- SRes res = SZ_OK;
- ISzAlloc allocImp;
- ISzAlloc allocTempImp;
- WCHAR sfxPath[MAX_PATH + 2];
- WCHAR path[MAX_PATH * 3 + 2];
- #ifndef UNDER_CE
- WCHAR workCurDir[MAX_PATH + 32];
- #endif
- size_t pathLen;
- DWORD winRes;
- const wchar_t *cmdLineParams;
- const char *errorMessage = NULL;
- BoolInt useShellExecute = True;
- DWORD exitCode = 0;
-
- LoadSecurityDlls();
-
- #ifdef _CONSOLE
- SetConsoleCtrlHandler(HandlerRoutine, TRUE);
- #else
- UNUSED_VAR(hInstance);
- UNUSED_VAR(hPrevInstance);
- UNUSED_VAR(lpCmdLine);
- UNUSED_VAR(nCmdShow);
- #endif
-
- CrcGenerateTable();
-
- allocImp.Alloc = SzAlloc;
- allocImp.Free = SzFree;
-
- allocTempImp.Alloc = SzAllocTemp;
- allocTempImp.Free = SzFreeTemp;
-
- FileInStream_CreateVTable(&archiveStream);
- LookToRead2_CreateVTable(&lookStream, False);
- lookStream.buf = NULL;
-
- winRes = GetModuleFileNameW(NULL, sfxPath, MAX_PATH);
- if (winRes == 0 || winRes > MAX_PATH)
- return 1;
- {
- cmdLineParams = GetCommandLineW();
- #ifndef UNDER_CE
- {
- BoolInt quoteMode = False;
- for (;; cmdLineParams++)
- {
- wchar_t c = *cmdLineParams;
- if (c == L'\"')
- quoteMode = !quoteMode;
- else if (c == 0 || (c == L' ' && !quoteMode))
- break;
- }
- }
- #endif
- }
-
- {
- unsigned i;
- DWORD d;
- winRes = GetTempPathW(MAX_PATH, path);
- if (winRes == 0 || winRes > MAX_PATH)
- return 1;
- pathLen = wcslen(path);
- d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
-
- for (i = 0;; i++, d += GetTickCount())
- {
- if (i >= 100)
- {
- res = SZ_ERROR_FAIL;
- break;
- }
- wcscpy(path + pathLen, L"7z");
-
- {
- wchar_t *s = path + wcslen(path);
- UInt32 value = d;
- unsigned k;
- for (k = 0; k < 8; k++)
- {
- unsigned t = value & 0xF;
- value >>= 4;
- s[7 - k] = (wchar_t)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
- }
- s[k] = '\0';
- }
-
- if (DoesFileOrDirExist(path))
- continue;
- if (CreateDirectoryW(path, NULL))
- {
- wcscat(path, WSTRING_PATH_SEPARATOR);
- pathLen = wcslen(path);
- break;
- }
- if (GetLastError() != ERROR_ALREADY_EXISTS)
- {
- res = SZ_ERROR_FAIL;
- break;
- }
- }
-
- #ifndef UNDER_CE
- wcscpy(workCurDir, path);
- #endif
- if (res != SZ_OK)
- errorMessage = "Can't create temp folder";
- }
-
- if (res != SZ_OK)
- {
- if (!errorMessage)
- errorMessage = "Error";
- PrintErrorMessage(errorMessage);
- return 1;
- }
-
- if (InFile_OpenW(&archiveStream.file, sfxPath) != 0)
- {
- errorMessage = "can not open input file";
- res = SZ_ERROR_FAIL;
- }
- else
- {
- UInt64 pos = 0;
- if (!FindSignature(&archiveStream.file, &pos))
- res = SZ_ERROR_FAIL;
- else if (File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET) != 0)
- res = SZ_ERROR_FAIL;
- if (res != 0)
- errorMessage = "Can't find 7z archive";
- }
-
- if (res == SZ_OK)
- {
- lookStream.buf = (Byte *)ISzAlloc_Alloc(&allocImp, kInputBufSize);
- if (!lookStream.buf)
- res = SZ_ERROR_MEM;
- else
- {
- lookStream.bufSize = kInputBufSize;
- lookStream.realStream = &archiveStream.vt;
- LookToRead2_Init(&lookStream);
- }
- }
-
- SzArEx_Init(&db);
-
- if (res == SZ_OK)
- {
- res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);
- }
-
- if (res == SZ_OK)
- {
- UInt32 executeFileIndex = (UInt32)(Int32)-1;
- UInt32 minPrice = 1 << 30;
- UInt32 i;
- UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
- Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
- size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
-
- for (i = 0; i < db.NumFiles; i++)
- {
- size_t offset = 0;
- size_t outSizeProcessed = 0;
- WCHAR *temp;
-
- if (SzArEx_GetFileNameUtf16(&db, i, NULL) >= MAX_PATH)
- {
- res = SZ_ERROR_FAIL;
- break;
- }
-
- temp = path + pathLen;
-
- SzArEx_GetFileNameUtf16(&db, i, (UInt16 *)temp);
- {
- res = SzArEx_Extract(&db, &lookStream.vt, i,
- &blockIndex, &outBuffer, &outBufferSize,
- &offset, &outSizeProcessed,
- &allocImp, &allocTempImp);
- if (res != SZ_OK)
- break;
- }
- {
- CSzFile outFile;
- size_t processedSize;
- size_t j;
- size_t nameStartPos = 0;
- for (j = 0; temp[j] != 0; j++)
- {
- if (temp[j] == '/')
- {
- temp[j] = 0;
- MyCreateDir(path);
- temp[j] = CHAR_PATH_SEPARATOR;
- nameStartPos = j + 1;
- }
- }
-
- if (SzArEx_IsDir(&db, i))
- {
- MyCreateDir(path);
- continue;
- }
- else
- {
- unsigned extLen;
- const WCHAR *name = temp + nameStartPos;
- unsigned len = (unsigned)wcslen(name);
- unsigned nameLen = FindExt(temp + nameStartPos, &extLen);
- unsigned extPrice = FindItem(kExts, sizeof(kExts) / sizeof(kExts[0]), name + len - extLen, extLen);
- unsigned namePrice = FindItem(kNames, sizeof(kNames) / sizeof(kNames[0]), name, nameLen);
-
- unsigned price = namePrice + extPrice * 64 + (nameStartPos == 0 ? 0 : (1 << 12));
- if (minPrice > price)
- {
- minPrice = price;
- executeFileIndex = i;
- useShellExecute = (extPrice != k_EXE_ExtIndex);
- }
-
- if (DoesFileOrDirExist(path))
- {
- errorMessage = "Duplicate file";
- res = SZ_ERROR_FAIL;
- break;
- }
- if (OutFile_OpenW(&outFile, path))
- {
- errorMessage = "Can't open output file";
- res = SZ_ERROR_FAIL;
- break;
- }
- }
-
- processedSize = outSizeProcessed;
- if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)
- {
- errorMessage = "Can't write output file";
- res = SZ_ERROR_FAIL;
- }
-
- #ifdef USE_WINDOWS_FILE
- if (SzBitWithVals_Check(&db.MTime, i))
- {
- const CNtfsFileTime *t = db.MTime.Vals + i;
- FILETIME mTime;
- mTime.dwLowDateTime = t->Low;
- mTime.dwHighDateTime = t->High;
- SetFileTime(outFile.handle, NULL, NULL, &mTime);
- }
- #endif
-
- {
- SRes res2 = File_Close(&outFile);
- if (res != SZ_OK)
- break;
- if (res2 != SZ_OK)
- {
- res = res2;
- break;
- }
- }
- #ifdef USE_WINDOWS_FILE
- if (SzBitWithVals_Check(&db.Attribs, i))
- SetFileAttributesW(path, db.Attribs.Vals[i]);
- #endif
- }
- }
-
- if (res == SZ_OK)
- {
- if (executeFileIndex == (UInt32)(Int32)-1)
- {
- errorMessage = "There is no file to execute";
- res = SZ_ERROR_FAIL;
- }
- else
- {
- WCHAR *temp = path + pathLen;
- UInt32 j;
- SzArEx_GetFileNameUtf16(&db, executeFileIndex, (UInt16 *)temp);
- for (j = 0; temp[j] != 0; j++)
- if (temp[j] == '/')
- temp[j] = CHAR_PATH_SEPARATOR;
- }
- }
- ISzAlloc_Free(&allocImp, outBuffer);
- }
-
- SzArEx_Free(&db, &allocImp);
-
- ISzAlloc_Free(&allocImp, lookStream.buf);
-
- File_Close(&archiveStream.file);
-
- if (res == SZ_OK)
- {
- HANDLE hProcess = 0;
-
- #ifndef UNDER_CE
- WCHAR oldCurDir[MAX_PATH + 2];
- oldCurDir[0] = 0;
- {
- DWORD needLen = GetCurrentDirectory(MAX_PATH + 1, oldCurDir);
- if (needLen == 0 || needLen > MAX_PATH)
- oldCurDir[0] = 0;
- SetCurrentDirectory(workCurDir);
- }
- #endif
-
- if (useShellExecute)
- {
- SHELLEXECUTEINFO ei;
- UINT32 executeRes;
- BOOL success;
-
- memset(&ei, 0, sizeof(ei));
- ei.cbSize = sizeof(ei);
- ei.lpFile = path;
- ei.fMask = SEE_MASK_NOCLOSEPROCESS
- #ifndef UNDER_CE
- | SEE_MASK_FLAG_DDEWAIT
- #endif
- /* | SEE_MASK_NO_CONSOLE */
- ;
- if (wcslen(cmdLineParams) != 0)
- ei.lpParameters = cmdLineParams;
- ei.nShow = SW_SHOWNORMAL; /* SW_HIDE; */
- success = ShellExecuteEx(&ei);
- executeRes = (UINT32)(UINT_PTR)ei.hInstApp;
- if (!success || (executeRes <= 32 && executeRes != 0)) /* executeRes = 0 in Windows CE */
- res = SZ_ERROR_FAIL;
- else
- hProcess = ei.hProcess;
- }
- else
- {
- STARTUPINFOW si;
- PROCESS_INFORMATION pi;
- WCHAR cmdLine[MAX_PATH * 3];
-
- wcscpy(cmdLine, path);
- wcscat(cmdLine, cmdLineParams);
- memset(&si, 0, sizeof(si));
- si.cb = sizeof(si);
- if (CreateProcessW(NULL, cmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) == 0)
- res = SZ_ERROR_FAIL;
- else
- {
- CloseHandle(pi.hThread);
- hProcess = pi.hProcess;
- }
- }
-
- if (hProcess != 0)
- {
- WaitForSingleObject(hProcess, INFINITE);
- if (!GetExitCodeProcess(hProcess, &exitCode))
- exitCode = 1;
- CloseHandle(hProcess);
- }
-
- #ifndef UNDER_CE
- SetCurrentDirectory(oldCurDir);
- #endif
- }
-
- path[pathLen] = L'\0';
- RemoveDirWithSubItems(path);
-
- if (res == SZ_OK)
- return (int)exitCode;
-
- {
- if (res == SZ_ERROR_UNSUPPORTED)
- errorMessage = "Decoder doesn't support this archive";
- else if (res == SZ_ERROR_MEM)
- errorMessage = "Can't allocate required memory";
- else if (res == SZ_ERROR_CRC)
- errorMessage = "CRC error";
- else
- {
- if (!errorMessage)
- errorMessage = "ERROR";
- }
-
- if (errorMessage)
- PrintErrorMessage(errorMessage);
- }
- return 1;
-}
+/* SfxSetup.c - 7z SFX Setup
+2019-02-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+#ifndef _UNICODE
+#define _UNICODE
+#endif
+
+#ifdef _CONSOLE
+#include <stdio.h>
+#endif
+
+#include "../../7z.h"
+#include "../../7zAlloc.h"
+#include "../../7zCrc.h"
+#include "../../7zFile.h"
+#include "../../CpuArch.h"
+#include "../../DllSecur.h"
+
+#define k_EXE_ExtIndex 2
+
+#define kInputBufSize ((size_t)1 << 18)
+
+
+#define wcscat lstrcatW
+#define wcslen (size_t)lstrlenW
+#define wcscpy lstrcpyW
+// wcsncpy() and lstrcpynW() work differently. We don't use them.
+
+static const char * const kExts[] =
+{
+ "bat"
+ , "cmd"
+ , "exe"
+ , "inf"
+ , "msi"
+ #ifdef UNDER_CE
+ , "cab"
+ #endif
+ , "html"
+ , "htm"
+};
+
+static const char * const kNames[] =
+{
+ "setup"
+ , "install"
+ , "run"
+ , "start"
+};
+
+static unsigned FindExt(const wchar_t *s, unsigned *extLen)
+{
+ unsigned len = (unsigned)wcslen(s);
+ unsigned i;
+ for (i = len; i > 0; i--)
+ {
+ if (s[i - 1] == '.')
+ {
+ *extLen = len - i;
+ return i - 1;
+ }
+ }
+ *extLen = 0;
+ return len;
+}
+
+#define MAKE_CHAR_UPPER(c) ((((c) >= 'a' && (c) <= 'z') ? (c) - 0x20 : (c)))
+
+static unsigned FindItem(const char * const *items, unsigned num, const wchar_t *s, unsigned len)
+{
+ unsigned i;
+ for (i = 0; i < num; i++)
+ {
+ const char *item = items[i];
+ const unsigned itemLen = (unsigned)strlen(item);
+ unsigned j;
+ if (len != itemLen)
+ continue;
+ for (j = 0; j < len; j++)
+ {
+ const unsigned c = (Byte)item[j];
+ if (c != s[j] && MAKE_CHAR_UPPER(c) != s[j])
+ break;
+ }
+ if (j == len)
+ return i;
+ }
+ return i;
+}
+
+#ifdef _CONSOLE
+static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
+{
+ UNUSED_VAR(ctrlType);
+ return TRUE;
+}
+#endif
+
+
+#ifdef _CONSOLE
+static void PrintStr(const char *s)
+{
+ fputs(s, stdout);
+}
+#endif
+
+static void PrintErrorMessage(const char *message)
+{
+ #ifdef _CONSOLE
+ PrintStr("\n7-Zip Error: ");
+ PrintStr(message);
+ PrintStr("\n");
+ #else
+ #ifdef UNDER_CE
+ WCHAR messageW[256 + 4];
+ unsigned i;
+ for (i = 0; i < 256 && message[i] != 0; i++)
+ messageW[i] = message[i];
+ messageW[i] = 0;
+ MessageBoxW(0, messageW, L"7-Zip Error", MB_ICONERROR);
+ #else
+ MessageBoxA(0, message, "7-Zip Error", MB_ICONERROR);
+ #endif
+ #endif
+}
+
+static WRes MyCreateDir(const WCHAR *name)
+{
+ return CreateDirectoryW(name, NULL) ? 0 : GetLastError();
+}
+
+#ifdef UNDER_CE
+#define kBufferSize (1 << 13)
+#else
+#define kBufferSize (1 << 15)
+#endif
+
+#define kSignatureSearchLimit (1 << 22)
+
+static BoolInt FindSignature(CSzFile *stream, UInt64 *resPos)
+{
+ Byte buf[kBufferSize];
+ size_t numPrevBytes = 0;
+ *resPos = 0;
+ for (;;)
+ {
+ size_t processed, pos;
+ if (*resPos > kSignatureSearchLimit)
+ return False;
+ processed = kBufferSize - numPrevBytes;
+ if (File_Read(stream, buf + numPrevBytes, &processed) != 0)
+ return False;
+ processed += numPrevBytes;
+ if (processed < k7zStartHeaderSize ||
+ (processed == k7zStartHeaderSize && numPrevBytes != 0))
+ return False;
+ processed -= k7zStartHeaderSize;
+ for (pos = 0; pos <= processed; pos++)
+ {
+ for (; pos <= processed && buf[pos] != '7'; pos++);
+ if (pos > processed)
+ break;
+ if (memcmp(buf + pos, k7zSignature, k7zSignatureSize) == 0)
+ if (CrcCalc(buf + pos + 12, 20) == GetUi32(buf + pos + 8))
+ {
+ *resPos += pos;
+ return True;
+ }
+ }
+ *resPos += processed;
+ numPrevBytes = k7zStartHeaderSize;
+ memmove(buf, buf + processed, k7zStartHeaderSize);
+ }
+}
+
+static BoolInt DoesFileOrDirExist(const WCHAR *path)
+{
+ WIN32_FIND_DATAW fd;
+ HANDLE handle;
+ handle = FindFirstFileW(path, &fd);
+ if (handle == INVALID_HANDLE_VALUE)
+ return False;
+ FindClose(handle);
+ return True;
+}
+
+static WRes RemoveDirWithSubItems(WCHAR *path)
+{
+ WIN32_FIND_DATAW fd;
+ HANDLE handle;
+ WRes res = 0;
+ const size_t len = wcslen(path);
+ wcscpy(path + len, L"*");
+ handle = FindFirstFileW(path, &fd);
+ path[len] = L'\0';
+ if (handle == INVALID_HANDLE_VALUE)
+ return GetLastError();
+
+ for (;;)
+ {
+ if (wcscmp(fd.cFileName, L".") != 0 &&
+ wcscmp(fd.cFileName, L"..") != 0)
+ {
+ wcscpy(path + len, fd.cFileName);
+ if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
+ {
+ wcscat(path, WSTRING_PATH_SEPARATOR);
+ res = RemoveDirWithSubItems(path);
+ }
+ else
+ {
+ SetFileAttributesW(path, 0);
+ if (DeleteFileW(path) == 0)
+ res = GetLastError();
+ }
+
+ if (res != 0)
+ break;
+ }
+
+ if (!FindNextFileW(handle, &fd))
+ {
+ res = GetLastError();
+ if (res == ERROR_NO_MORE_FILES)
+ res = 0;
+ break;
+ }
+ }
+
+ path[len] = L'\0';
+ FindClose(handle);
+ if (res == 0)
+ {
+ if (!RemoveDirectoryW(path))
+ res = GetLastError();
+ }
+ return res;
+}
+
+#ifdef _CONSOLE
+int Z7_CDECL main(void)
+#else
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ lpCmdLine, int nCmdShow)
+#endif
+{
+ CFileInStream archiveStream;
+ CLookToRead2 lookStream;
+ CSzArEx db;
+ SRes res = SZ_OK;
+ ISzAlloc allocImp;
+ ISzAlloc allocTempImp;
+ WCHAR sfxPath[MAX_PATH + 2];
+ WCHAR path[MAX_PATH * 3 + 2];
+ #ifndef UNDER_CE
+ WCHAR workCurDir[MAX_PATH + 32];
+ #endif
+ size_t pathLen;
+ DWORD winRes;
+ const wchar_t *cmdLineParams;
+ const char *errorMessage = NULL;
+ BoolInt useShellExecute = True;
+ DWORD exitCode = 0;
+
+ LoadSecurityDlls();
+
+ #ifdef _CONSOLE
+ SetConsoleCtrlHandler(HandlerRoutine, TRUE);
+ #else
+ UNUSED_VAR(hInstance);
+ UNUSED_VAR(hPrevInstance);
+ UNUSED_VAR(lpCmdLine);
+ UNUSED_VAR(nCmdShow);
+ #endif
+
+ CrcGenerateTable();
+
+ allocImp.Alloc = SzAlloc;
+ allocImp.Free = SzFree;
+
+ allocTempImp.Alloc = SzAllocTemp;
+ allocTempImp.Free = SzFreeTemp;
+
+ FileInStream_CreateVTable(&archiveStream);
+ LookToRead2_CreateVTable(&lookStream, False);
+ lookStream.buf = NULL;
+
+ winRes = GetModuleFileNameW(NULL, sfxPath, MAX_PATH);
+ if (winRes == 0 || winRes > MAX_PATH)
+ return 1;
+ {
+ cmdLineParams = GetCommandLineW();
+ #ifndef UNDER_CE
+ {
+ BoolInt quoteMode = False;
+ for (;; cmdLineParams++)
+ {
+ const wchar_t c = *cmdLineParams;
+ if (c == L'\"')
+ quoteMode = !quoteMode;
+ else if (c == 0 || (c == L' ' && !quoteMode))
+ break;
+ }
+ }
+ #endif
+ }
+
+ {
+ unsigned i;
+ DWORD d;
+ winRes = GetTempPathW(MAX_PATH, path);
+ if (winRes == 0 || winRes > MAX_PATH)
+ return 1;
+ pathLen = wcslen(path);
+ d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
+
+ for (i = 0;; i++, d += GetTickCount())
+ {
+ if (i >= 100)
+ {
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ wcscpy(path + pathLen, L"7z");
+
+ {
+ wchar_t *s = path + wcslen(path);
+ UInt32 value = d;
+ unsigned k;
+ for (k = 0; k < 8; k++)
+ {
+ const unsigned t = value & 0xF;
+ value >>= 4;
+ s[7 - k] = (wchar_t)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+ }
+ s[k] = '\0';
+ }
+
+ if (DoesFileOrDirExist(path))
+ continue;
+ if (CreateDirectoryW(path, NULL))
+ {
+ wcscat(path, WSTRING_PATH_SEPARATOR);
+ pathLen = wcslen(path);
+ break;
+ }
+ if (GetLastError() != ERROR_ALREADY_EXISTS)
+ {
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ }
+
+ #ifndef UNDER_CE
+ wcscpy(workCurDir, path);
+ #endif
+ if (res != SZ_OK)
+ errorMessage = "Can't create temp folder";
+ }
+
+ if (res != SZ_OK)
+ {
+ if (!errorMessage)
+ errorMessage = "Error";
+ PrintErrorMessage(errorMessage);
+ return 1;
+ }
+
+ if (InFile_OpenW(&archiveStream.file, sfxPath) != 0)
+ {
+ errorMessage = "can not open input file";
+ res = SZ_ERROR_FAIL;
+ }
+ else
+ {
+ UInt64 pos = 0;
+ if (!FindSignature(&archiveStream.file, &pos))
+ res = SZ_ERROR_FAIL;
+ else if (File_Seek(&archiveStream.file, (Int64 *)&pos, SZ_SEEK_SET) != 0)
+ res = SZ_ERROR_FAIL;
+ if (res != 0)
+ errorMessage = "Can't find 7z archive";
+ }
+
+ if (res == SZ_OK)
+ {
+ lookStream.buf = (Byte *)ISzAlloc_Alloc(&allocImp, kInputBufSize);
+ if (!lookStream.buf)
+ res = SZ_ERROR_MEM;
+ else
+ {
+ lookStream.bufSize = kInputBufSize;
+ lookStream.realStream = &archiveStream.vt;
+ LookToRead2_INIT(&lookStream)
+ }
+ }
+
+ SzArEx_Init(&db);
+
+ if (res == SZ_OK)
+ {
+ res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);
+ }
+
+ if (res == SZ_OK)
+ {
+ UInt32 executeFileIndex = (UInt32)(Int32)-1;
+ UInt32 minPrice = 1 << 30;
+ UInt32 i;
+ UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
+ Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
+ size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
+
+ for (i = 0; i < db.NumFiles; i++)
+ {
+ size_t offset = 0;
+ size_t outSizeProcessed = 0;
+ WCHAR *temp;
+
+ if (SzArEx_GetFileNameUtf16(&db, i, NULL) >= MAX_PATH)
+ {
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+
+ temp = path + pathLen;
+
+ SzArEx_GetFileNameUtf16(&db, i, (UInt16 *)temp);
+ {
+ res = SzArEx_Extract(&db, &lookStream.vt, i,
+ &blockIndex, &outBuffer, &outBufferSize,
+ &offset, &outSizeProcessed,
+ &allocImp, &allocTempImp);
+ if (res != SZ_OK)
+ break;
+ }
+ {
+ CSzFile outFile;
+ size_t processedSize;
+ size_t j;
+ size_t nameStartPos = 0;
+ for (j = 0; temp[j] != 0; j++)
+ {
+ if (temp[j] == '/')
+ {
+ temp[j] = 0;
+ MyCreateDir(path);
+ temp[j] = CHAR_PATH_SEPARATOR;
+ nameStartPos = j + 1;
+ }
+ }
+
+ if (SzArEx_IsDir(&db, i))
+ {
+ MyCreateDir(path);
+ continue;
+ }
+ else
+ {
+ unsigned extLen;
+ const WCHAR *name = temp + nameStartPos;
+ unsigned len = (unsigned)wcslen(name);
+ const unsigned nameLen = FindExt(temp + nameStartPos, &extLen);
+ const unsigned extPrice = FindItem(kExts, sizeof(kExts) / sizeof(kExts[0]), name + len - extLen, extLen);
+ const unsigned namePrice = FindItem(kNames, sizeof(kNames) / sizeof(kNames[0]), name, nameLen);
+
+ const unsigned price = namePrice + extPrice * 64 + (nameStartPos == 0 ? 0 : (1 << 12));
+ if (minPrice > price)
+ {
+ minPrice = price;
+ executeFileIndex = i;
+ useShellExecute = (extPrice != k_EXE_ExtIndex);
+ }
+
+ if (DoesFileOrDirExist(path))
+ {
+ errorMessage = "Duplicate file";
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ if (OutFile_OpenW(&outFile, path))
+ {
+ errorMessage = "Can't open output file";
+ res = SZ_ERROR_FAIL;
+ break;
+ }
+ }
+
+ processedSize = outSizeProcessed;
+ if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)
+ {
+ errorMessage = "Can't write output file";
+ res = SZ_ERROR_FAIL;
+ }
+
+ #ifdef USE_WINDOWS_FILE
+ if (SzBitWithVals_Check(&db.MTime, i))
+ {
+ const CNtfsFileTime *t = db.MTime.Vals + i;
+ FILETIME mTime;
+ mTime.dwLowDateTime = t->Low;
+ mTime.dwHighDateTime = t->High;
+ SetFileTime(outFile.handle, NULL, NULL, &mTime);
+ }
+ #endif
+
+ {
+ const SRes res2 = File_Close(&outFile);
+ if (res != SZ_OK)
+ break;
+ if (res2 != SZ_OK)
+ {
+ res = res2;
+ break;
+ }
+ }
+ #ifdef USE_WINDOWS_FILE
+ if (SzBitWithVals_Check(&db.Attribs, i))
+ SetFileAttributesW(path, db.Attribs.Vals[i]);
+ #endif
+ }
+ }
+
+ if (res == SZ_OK)
+ {
+ if (executeFileIndex == (UInt32)(Int32)-1)
+ {
+ errorMessage = "There is no file to execute";
+ res = SZ_ERROR_FAIL;
+ }
+ else
+ {
+ WCHAR *temp = path + pathLen;
+ UInt32 j;
+ SzArEx_GetFileNameUtf16(&db, executeFileIndex, (UInt16 *)temp);
+ for (j = 0; temp[j] != 0; j++)
+ if (temp[j] == '/')
+ temp[j] = CHAR_PATH_SEPARATOR;
+ }
+ }
+ ISzAlloc_Free(&allocImp, outBuffer);
+ }
+
+ SzArEx_Free(&db, &allocImp);
+
+ ISzAlloc_Free(&allocImp, lookStream.buf);
+
+ File_Close(&archiveStream.file);
+
+ if (res == SZ_OK)
+ {
+ HANDLE hProcess = 0;
+
+ #ifndef UNDER_CE
+ WCHAR oldCurDir[MAX_PATH + 2];
+ oldCurDir[0] = 0;
+ {
+ const DWORD needLen = GetCurrentDirectory(MAX_PATH + 1, oldCurDir);
+ if (needLen == 0 || needLen > MAX_PATH)
+ oldCurDir[0] = 0;
+ SetCurrentDirectory(workCurDir);
+ }
+ #endif
+
+ if (useShellExecute)
+ {
+ SHELLEXECUTEINFO ei;
+ UINT32 executeRes;
+ BOOL success;
+
+ memset(&ei, 0, sizeof(ei));
+ ei.cbSize = sizeof(ei);
+ ei.lpFile = path;
+ ei.fMask = SEE_MASK_NOCLOSEPROCESS
+ #ifndef UNDER_CE
+ | SEE_MASK_FLAG_DDEWAIT
+ #endif
+ /* | SEE_MASK_NO_CONSOLE */
+ ;
+ if (wcslen(cmdLineParams) != 0)
+ ei.lpParameters = cmdLineParams;
+ ei.nShow = SW_SHOWNORMAL; /* SW_HIDE; */
+ success = ShellExecuteEx(&ei);
+ executeRes = (UINT32)(UINT_PTR)ei.hInstApp;
+ if (!success || (executeRes <= 32 && executeRes != 0)) /* executeRes = 0 in Windows CE */
+ res = SZ_ERROR_FAIL;
+ else
+ hProcess = ei.hProcess;
+ }
+ else
+ {
+ STARTUPINFOW si;
+ PROCESS_INFORMATION pi;
+ WCHAR cmdLine[MAX_PATH * 3];
+
+ wcscpy(cmdLine, path);
+ wcscat(cmdLine, cmdLineParams);
+ memset(&si, 0, sizeof(si));
+ si.cb = sizeof(si);
+ if (CreateProcessW(NULL, cmdLine, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) == 0)
+ res = SZ_ERROR_FAIL;
+ else
+ {
+ CloseHandle(pi.hThread);
+ hProcess = pi.hProcess;
+ }
+ }
+
+ if (hProcess != 0)
+ {
+ WaitForSingleObject(hProcess, INFINITE);
+ if (!GetExitCodeProcess(hProcess, &exitCode))
+ exitCode = 1;
+ CloseHandle(hProcess);
+ }
+
+ #ifndef UNDER_CE
+ SetCurrentDirectory(oldCurDir);
+ #endif
+ }
+
+ path[pathLen] = L'\0';
+ RemoveDirWithSubItems(path);
+
+ if (res == SZ_OK)
+ return (int)exitCode;
+
+ {
+ if (res == SZ_ERROR_UNSUPPORTED)
+ errorMessage = "Decoder doesn't support this archive";
+ else if (res == SZ_ERROR_MEM)
+ errorMessage = "Can't allocate required memory";
+ else if (res == SZ_ERROR_CRC)
+ errorMessage = "CRC error";
+ else
+ {
+ if (!errorMessage)
+ errorMessage = "ERROR";
+ }
+
+ if (errorMessage)
+ PrintErrorMessage(errorMessage);
+ }
+ return 1;
+}
diff --git a/C/Util/SfxSetup/SfxSetup.dsp b/C/Util/SfxSetup/SfxSetup.dsp
index be9de6d..60439a6 100644
--- a/C/Util/SfxSetup/SfxSetup.dsp
+++ b/C/Util/SfxSetup/SfxSetup.dsp
@@ -1,231 +1,231 @@
-# Microsoft Developer Studio Project File - Name="SfxSetup" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Application" 0x0101
-
-CFG=SfxSetup - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "SfxSetup.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "SfxSetup.mak" CFG="SfxSetup - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "SfxSetup - Win32 Release" (based on "Win32 (x86) Application")
-!MESSAGE "SfxSetup - Win32 Debug" (based on "Win32 (x86) Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "SfxSetup - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /W4 /WX /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
-
-!ELSEIF "$(CFG)" == "SfxSetup - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /GZ /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "SfxSetup - Win32 Release"
-# Name "SfxSetup - Win32 Debug"
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\7z.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zAlloc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zAlloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zArcIn.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zBuf.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zBuf.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zCrc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zCrcOpt.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zDec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zFile.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zFile.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zStream.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\7zTypes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bcj2.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bcj2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bra.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Bra86.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\BraIA64.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\CpuArch.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\CpuArch.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Delta.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Delta.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\DllSecur.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\DllSecur.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Lzma2Dec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Lzma2Dec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\LzmaDec.h
-# End Source File
-# End Group
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\Precomp.c
-# ADD CPP /Yc"Precomp.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\Precomp.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\SfxSetup.c
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="SfxSetup" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=SfxSetup - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "SfxSetup.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "SfxSetup.mak" CFG="SfxSetup - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "SfxSetup - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "SfxSetup - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "SfxSetup - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W4 /WX /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+
+!ELSEIF "$(CFG)" == "SfxSetup - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "SfxSetup - Win32 Release"
+# Name "SfxSetup - Win32 Debug"
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\7z.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zAlloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zArcIn.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zCrcOpt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zStream.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Bra86.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\BraIA64.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Delta.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\DllSecur.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\LzmaDec.h
+# End Source File
+# End Group
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Precomp.c
+# ADD CPP /Yc"Precomp.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\Precomp.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\SfxSetup.c
+# End Source File
+# End Target
+# End Project
diff --git a/C/Util/SfxSetup/SfxSetup.dsw b/C/Util/SfxSetup/SfxSetup.dsw
index 128fcdd..ea23111 100644
--- a/C/Util/SfxSetup/SfxSetup.dsw
+++ b/C/Util/SfxSetup/SfxSetup.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "SfxSetup"=.\SfxSetup.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "SfxSetup"=.\SfxSetup.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/C/Util/SfxSetup/makefile b/C/Util/SfxSetup/makefile
index c9f59cc..bc0cf8b 100644
--- a/C/Util/SfxSetup/makefile
+++ b/C/Util/SfxSetup/makefile
@@ -1,37 +1,40 @@
-PROG = 7zS2.sfx
-MY_FIXED = 1
-
-C_OBJS = \
- $O\7zAlloc.obj \
- $O\7zArcIn.obj \
- $O\7zBuf.obj \
- $O\7zBuf2.obj \
- $O\7zCrc.obj \
- $O\7zCrcOpt.obj \
- $O\7zFile.obj \
- $O\7zDec.obj \
- $O\7zStream.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\DllSecur.obj \
- $O\Lzma2Dec.obj \
- $O\LzmaDec.obj \
-
-7Z_OBJS = \
- $O\SfxSetup.obj \
-
-OBJS = \
- $(7Z_OBJS) \
- $(C_OBJS) \
- $O\resource.res
-
-!include "../../../CPP/Build.mak"
-
-$(7Z_OBJS): $(*B).c
- $(COMPL_O1)
-$(C_OBJS): ../../$(*B).c
- $(COMPL_O1)
+PROG = 7zS2.sfx
+MY_FIXED = 1
+
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTRACT_ONLY \
+
+C_OBJS = \
+ $O\7zAlloc.obj \
+ $O\7zArcIn.obj \
+ $O\7zBuf.obj \
+ $O\7zBuf2.obj \
+ $O\7zCrc.obj \
+ $O\7zCrcOpt.obj \
+ $O\7zFile.obj \
+ $O\7zDec.obj \
+ $O\7zStream.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\DllSecur.obj \
+ $O\Lzma2Dec.obj \
+ $O\LzmaDec.obj \
+
+7Z_OBJS = \
+ $O\SfxSetup.obj \
+
+OBJS = \
+ $(7Z_OBJS) \
+ $(C_OBJS) \
+ $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(7Z_OBJS): $(*B).c
+ $(COMPL_O1)
+$(C_OBJS): ../../$(*B).c
+ $(COMPL_O1)
diff --git a/C/Util/SfxSetup/makefile_con b/C/Util/SfxSetup/makefile_con
index 6f604ed..9f4b916 100644
--- a/C/Util/SfxSetup/makefile_con
+++ b/C/Util/SfxSetup/makefile_con
@@ -1,38 +1,40 @@
-PROG = 7zS2con.sfx
-MY_FIXED = 1
-CFLAGS = $(CFLAGS) -D_CONSOLE
-
-C_OBJS = \
- $O\7zAlloc.obj \
- $O\7zArcIn.obj \
- $O\7zBuf.obj \
- $O\7zBuf2.obj \
- $O\7zCrc.obj \
- $O\7zCrcOpt.obj \
- $O\7zFile.obj \
- $O\7zDec.obj \
- $O\7zStream.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\DllSecur.obj \
- $O\Lzma2Dec.obj \
- $O\LzmaDec.obj \
-
-7Z_OBJS = \
- $O\SfxSetup.obj \
-
-OBJS = \
- $(7Z_OBJS) \
- $(C_OBJS) \
- $O\resource.res
-
-!include "../../../CPP/Build.mak"
-
-$(7Z_OBJS): $(*B).c
- $(COMPL_O1)
-$(C_OBJS): ../../$(*B).c
- $(COMPL_O1)
+PROG = 7zS2con.sfx
+MY_FIXED = 1
+
+CFLAGS = $(CFLAGS) -D_CONSOLE \
+ -DZ7_EXTRACT_ONLY \
+
+C_OBJS = \
+ $O\7zAlloc.obj \
+ $O\7zArcIn.obj \
+ $O\7zBuf.obj \
+ $O\7zBuf2.obj \
+ $O\7zCrc.obj \
+ $O\7zCrcOpt.obj \
+ $O\7zFile.obj \
+ $O\7zDec.obj \
+ $O\7zStream.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\DllSecur.obj \
+ $O\Lzma2Dec.obj \
+ $O\LzmaDec.obj \
+
+7Z_OBJS = \
+ $O\SfxSetup.obj \
+
+OBJS = \
+ $(7Z_OBJS) \
+ $(C_OBJS) \
+ $O\resource.res
+
+!include "../../../CPP/Build.mak"
+
+$(7Z_OBJS): $(*B).c
+ $(COMPL_O1)
+$(C_OBJS): ../../$(*B).c
+ $(COMPL_O1)
diff --git a/C/Util/SfxSetup/resource.rc b/C/Util/SfxSetup/resource.rc
index 64f4e2c..0c1637f 100644
--- a/C/Util/SfxSetup/resource.rc
+++ b/C/Util/SfxSetup/resource.rc
@@ -1,5 +1,5 @@
-#include "../../7zVersion.rc"
-
-MY_VERSION_INFO_APP("7z Setup SFX small", "7zS2.sfx")
-
-1 ICON "setup.ico"
+#include "../../7zVersion.rc"
+
+MY_VERSION_INFO_APP("7z Setup SFX small", "7zS2.sfx")
+
+1 ICON "setup.ico"
diff --git a/C/Xz.c b/C/Xz.c
index 7e061d6..4ad0710 100644
--- a/C/Xz.c
+++ b/C/Xz.c
@@ -1,90 +1,90 @@
-/* Xz.c - Xz
-2017-05-12 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "7zCrc.h"
-#include "CpuArch.h"
-#include "Xz.h"
-#include "XzCrc64.h"
-
-const Byte XZ_SIG[XZ_SIG_SIZE] = { 0xFD, '7', 'z', 'X', 'Z', 0 };
-/* const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE] = { 'Y', 'Z' }; */
-
-unsigned Xz_WriteVarInt(Byte *buf, UInt64 v)
-{
- unsigned i = 0;
- do
- {
- buf[i++] = (Byte)((v & 0x7F) | 0x80);
- v >>= 7;
- }
- while (v != 0);
- buf[(size_t)i - 1] &= 0x7F;
- return i;
-}
-
-void Xz_Construct(CXzStream *p)
-{
- p->numBlocks = 0;
- p->blocks = NULL;
- p->flags = 0;
-}
-
-void Xz_Free(CXzStream *p, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, p->blocks);
- p->numBlocks = 0;
- p->blocks = NULL;
-}
-
-unsigned XzFlags_GetCheckSize(CXzStreamFlags f)
-{
- unsigned t = XzFlags_GetCheckType(f);
- return (t == 0) ? 0 : (4 << ((t - 1) / 3));
-}
-
-void XzCheck_Init(CXzCheck *p, unsigned mode)
-{
- p->mode = mode;
- switch (mode)
- {
- case XZ_CHECK_CRC32: p->crc = CRC_INIT_VAL; break;
- case XZ_CHECK_CRC64: p->crc64 = CRC64_INIT_VAL; break;
- case XZ_CHECK_SHA256: Sha256_Init(&p->sha); break;
- }
-}
-
-void XzCheck_Update(CXzCheck *p, const void *data, size_t size)
-{
- switch (p->mode)
- {
- case XZ_CHECK_CRC32: p->crc = CrcUpdate(p->crc, data, size); break;
- case XZ_CHECK_CRC64: p->crc64 = Crc64Update(p->crc64, data, size); break;
- case XZ_CHECK_SHA256: Sha256_Update(&p->sha, (const Byte *)data, size); break;
- }
-}
-
-int XzCheck_Final(CXzCheck *p, Byte *digest)
-{
- switch (p->mode)
- {
- case XZ_CHECK_CRC32:
- SetUi32(digest, CRC_GET_DIGEST(p->crc));
- break;
- case XZ_CHECK_CRC64:
- {
- int i;
- UInt64 v = CRC64_GET_DIGEST(p->crc64);
- for (i = 0; i < 8; i++, v >>= 8)
- digest[i] = (Byte)(v & 0xFF);
- break;
- }
- case XZ_CHECK_SHA256:
- Sha256_Final(&p->sha, digest);
- break;
- default:
- return 0;
- }
- return 1;
-}
+/* Xz.c - Xz
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "7zCrc.h"
+#include "CpuArch.h"
+#include "Xz.h"
+#include "XzCrc64.h"
+
+const Byte XZ_SIG[XZ_SIG_SIZE] = { 0xFD, '7', 'z', 'X', 'Z', 0 };
+/* const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE] = { 'Y', 'Z' }; */
+
+unsigned Xz_WriteVarInt(Byte *buf, UInt64 v)
+{
+ unsigned i = 0;
+ do
+ {
+ buf[i++] = (Byte)((v & 0x7F) | 0x80);
+ v >>= 7;
+ }
+ while (v != 0);
+ buf[(size_t)i - 1] &= 0x7F;
+ return i;
+}
+
+void Xz_Construct(CXzStream *p)
+{
+ p->numBlocks = 0;
+ p->blocks = NULL;
+ p->flags = 0;
+}
+
+void Xz_Free(CXzStream *p, ISzAllocPtr alloc)
+{
+ ISzAlloc_Free(alloc, p->blocks);
+ p->numBlocks = 0;
+ p->blocks = NULL;
+}
+
+unsigned XzFlags_GetCheckSize(CXzStreamFlags f)
+{
+ unsigned t = XzFlags_GetCheckType(f);
+ return (t == 0) ? 0 : ((unsigned)4 << ((t - 1) / 3));
+}
+
+void XzCheck_Init(CXzCheck *p, unsigned mode)
+{
+ p->mode = mode;
+ switch (mode)
+ {
+ case XZ_CHECK_CRC32: p->crc = CRC_INIT_VAL; break;
+ case XZ_CHECK_CRC64: p->crc64 = CRC64_INIT_VAL; break;
+ case XZ_CHECK_SHA256: Sha256_Init(&p->sha); break;
+ }
+}
+
+void XzCheck_Update(CXzCheck *p, const void *data, size_t size)
+{
+ switch (p->mode)
+ {
+ case XZ_CHECK_CRC32: p->crc = CrcUpdate(p->crc, data, size); break;
+ case XZ_CHECK_CRC64: p->crc64 = Crc64Update(p->crc64, data, size); break;
+ case XZ_CHECK_SHA256: Sha256_Update(&p->sha, (const Byte *)data, size); break;
+ }
+}
+
+int XzCheck_Final(CXzCheck *p, Byte *digest)
+{
+ switch (p->mode)
+ {
+ case XZ_CHECK_CRC32:
+ SetUi32(digest, CRC_GET_DIGEST(p->crc))
+ break;
+ case XZ_CHECK_CRC64:
+ {
+ int i;
+ UInt64 v = CRC64_GET_DIGEST(p->crc64);
+ for (i = 0; i < 8; i++, v >>= 8)
+ digest[i] = (Byte)(v & 0xFF);
+ break;
+ }
+ case XZ_CHECK_SHA256:
+ Sha256_Final(&p->sha, digest);
+ break;
+ default:
+ return 0;
+ }
+ return 1;
+}
diff --git a/C/Xz.h b/C/Xz.h
index fad56a3..d5001f6 100644
--- a/C/Xz.h
+++ b/C/Xz.h
@@ -1,460 +1,535 @@
-/* Xz.h - Xz interface
-2018-07-04 : Igor Pavlov : Public domain */
-
-#ifndef __XZ_H
-#define __XZ_H
-
-#include "Sha256.h"
-
-EXTERN_C_BEGIN
-
-#define XZ_ID_Subblock 1
-#define XZ_ID_Delta 3
-#define XZ_ID_X86 4
-#define XZ_ID_PPC 5
-#define XZ_ID_IA64 6
-#define XZ_ID_ARM 7
-#define XZ_ID_ARMT 8
-#define XZ_ID_SPARC 9
-#define XZ_ID_LZMA2 0x21
-
-unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value);
-unsigned Xz_WriteVarInt(Byte *buf, UInt64 v);
-
-/* ---------- xz block ---------- */
-
-#define XZ_BLOCK_HEADER_SIZE_MAX 1024
-
-#define XZ_NUM_FILTERS_MAX 4
-#define XZ_BF_NUM_FILTERS_MASK 3
-#define XZ_BF_PACK_SIZE (1 << 6)
-#define XZ_BF_UNPACK_SIZE (1 << 7)
-
-#define XZ_FILTER_PROPS_SIZE_MAX 20
-
-typedef struct
-{
- UInt64 id;
- UInt32 propsSize;
- Byte props[XZ_FILTER_PROPS_SIZE_MAX];
-} CXzFilter;
-
-typedef struct
-{
- UInt64 packSize;
- UInt64 unpackSize;
- Byte flags;
- CXzFilter filters[XZ_NUM_FILTERS_MAX];
-} CXzBlock;
-
-#define XzBlock_GetNumFilters(p) (((p)->flags & XZ_BF_NUM_FILTERS_MASK) + 1)
-#define XzBlock_HasPackSize(p) (((p)->flags & XZ_BF_PACK_SIZE) != 0)
-#define XzBlock_HasUnpackSize(p) (((p)->flags & XZ_BF_UNPACK_SIZE) != 0)
-#define XzBlock_HasUnsupportedFlags(p) (((p)->flags & ~(XZ_BF_NUM_FILTERS_MASK | XZ_BF_PACK_SIZE | XZ_BF_UNPACK_SIZE)) != 0)
-
-SRes XzBlock_Parse(CXzBlock *p, const Byte *header);
-SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, BoolInt *isIndex, UInt32 *headerSizeRes);
-
-/* ---------- xz stream ---------- */
-
-#define XZ_SIG_SIZE 6
-#define XZ_FOOTER_SIG_SIZE 2
-
-extern const Byte XZ_SIG[XZ_SIG_SIZE];
-
-/*
-extern const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE];
-*/
-
-#define XZ_FOOTER_SIG_0 'Y'
-#define XZ_FOOTER_SIG_1 'Z'
-
-#define XZ_STREAM_FLAGS_SIZE 2
-#define XZ_STREAM_CRC_SIZE 4
-
-#define XZ_STREAM_HEADER_SIZE (XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE)
-#define XZ_STREAM_FOOTER_SIZE (XZ_FOOTER_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE + 4)
-
-#define XZ_CHECK_MASK 0xF
-#define XZ_CHECK_NO 0
-#define XZ_CHECK_CRC32 1
-#define XZ_CHECK_CRC64 4
-#define XZ_CHECK_SHA256 10
-
-typedef struct
-{
- unsigned mode;
- UInt32 crc;
- UInt64 crc64;
- CSha256 sha;
-} CXzCheck;
-
-void XzCheck_Init(CXzCheck *p, unsigned mode);
-void XzCheck_Update(CXzCheck *p, const void *data, size_t size);
-int XzCheck_Final(CXzCheck *p, Byte *digest);
-
-typedef UInt16 CXzStreamFlags;
-
-#define XzFlags_IsSupported(f) ((f) <= XZ_CHECK_MASK)
-#define XzFlags_GetCheckType(f) ((f) & XZ_CHECK_MASK)
-#define XzFlags_HasDataCrc32(f) (Xz_GetCheckType(f) == XZ_CHECK_CRC32)
-unsigned XzFlags_GetCheckSize(CXzStreamFlags f);
-
-SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf);
-SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream);
-
-typedef struct
-{
- UInt64 unpackSize;
- UInt64 totalSize;
-} CXzBlockSizes;
-
-typedef struct
-{
- CXzStreamFlags flags;
- size_t numBlocks;
- CXzBlockSizes *blocks;
- UInt64 startOffset;
-} CXzStream;
-
-void Xz_Construct(CXzStream *p);
-void Xz_Free(CXzStream *p, ISzAllocPtr alloc);
-
-#define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1)
-
-UInt64 Xz_GetUnpackSize(const CXzStream *p);
-UInt64 Xz_GetPackSize(const CXzStream *p);
-
-typedef struct
-{
- size_t num;
- size_t numAllocated;
- CXzStream *streams;
-} CXzs;
-
-void Xzs_Construct(CXzs *p);
-void Xzs_Free(CXzs *p, ISzAllocPtr alloc);
-SRes Xzs_ReadBackward(CXzs *p, ILookInStream *inStream, Int64 *startOffset, ICompressProgress *progress, ISzAllocPtr alloc);
-
-UInt64 Xzs_GetNumBlocks(const CXzs *p);
-UInt64 Xzs_GetUnpackSize(const CXzs *p);
-
-
-// ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder
-
-typedef enum
-{
- CODER_STATUS_NOT_SPECIFIED, /* use main error code instead */
- CODER_STATUS_FINISHED_WITH_MARK, /* stream was finished with end mark. */
- CODER_STATUS_NOT_FINISHED, /* stream was not finished */
- CODER_STATUS_NEEDS_MORE_INPUT /* you must provide more input bytes */
-} ECoderStatus;
-
-
-// ECoderFinishMode values are identical to ELzmaFinishMode
-
-typedef enum
-{
- CODER_FINISH_ANY, /* finish at any point */
- CODER_FINISH_END /* block must be finished at the end */
-} ECoderFinishMode;
-
-
-typedef struct _IStateCoder
-{
- void *p;
- void (*Free)(void *p, ISzAllocPtr alloc);
- SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAllocPtr alloc);
- void (*Init)(void *p);
- SRes (*Code2)(void *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
- int srcWasFinished, ECoderFinishMode finishMode,
- // int *wasFinished,
- ECoderStatus *status);
- SizeT (*Filter)(void *p, Byte *data, SizeT size);
-} IStateCoder;
-
-
-
-#define MIXCODER_NUM_FILTERS_MAX 4
-
-typedef struct
-{
- ISzAllocPtr alloc;
- Byte *buf;
- unsigned numCoders;
-
- Byte *outBuf;
- size_t outBufSize;
- size_t outWritten; // is equal to lzmaDecoder.dicPos (in outBuf mode)
- BoolInt wasFinished;
- SRes res;
- ECoderStatus status;
- // BoolInt SingleBufMode;
-
- int finished[MIXCODER_NUM_FILTERS_MAX - 1];
- size_t pos[MIXCODER_NUM_FILTERS_MAX - 1];
- size_t size[MIXCODER_NUM_FILTERS_MAX - 1];
- UInt64 ids[MIXCODER_NUM_FILTERS_MAX];
- SRes results[MIXCODER_NUM_FILTERS_MAX];
- IStateCoder coders[MIXCODER_NUM_FILTERS_MAX];
-} CMixCoder;
-
-
-typedef enum
-{
- XZ_STATE_STREAM_HEADER,
- XZ_STATE_STREAM_INDEX,
- XZ_STATE_STREAM_INDEX_CRC,
- XZ_STATE_STREAM_FOOTER,
- XZ_STATE_STREAM_PADDING,
- XZ_STATE_BLOCK_HEADER,
- XZ_STATE_BLOCK,
- XZ_STATE_BLOCK_FOOTER
-} EXzState;
-
-
-typedef struct
-{
- EXzState state;
- UInt32 pos;
- unsigned alignPos;
- unsigned indexPreSize;
-
- CXzStreamFlags streamFlags;
-
- UInt32 blockHeaderSize;
- UInt64 packSize;
- UInt64 unpackSize;
-
- UInt64 numBlocks; // number of finished blocks in current stream
- UInt64 indexSize;
- UInt64 indexPos;
- UInt64 padSize;
-
- UInt64 numStartedStreams;
- UInt64 numFinishedStreams;
- UInt64 numTotalBlocks;
-
- UInt32 crc;
- CMixCoder decoder;
- CXzBlock block;
- CXzCheck check;
- CSha256 sha;
-
- BoolInt parseMode;
- BoolInt headerParsedOk;
- BoolInt decodeToStreamSignature;
- unsigned decodeOnlyOneBlock;
-
- Byte *outBuf;
- size_t outBufSize;
- size_t outDataWritten; // the size of data in (outBuf) that were fully unpacked
-
- Byte shaDigest[SHA256_DIGEST_SIZE];
- Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];
-} CXzUnpacker;
-
-/* alloc : aligned for cache line allocation is better */
-void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc);
-void XzUnpacker_Init(CXzUnpacker *p);
-void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize);
-void XzUnpacker_Free(CXzUnpacker *p);
-
-/*
- XzUnpacker
- The sequence for decoding functions:
- {
- XzUnpacker_Construct()
- [Decoding_Calls]
- XzUnpacker_Free()
- }
-
- [Decoding_Calls]
-
- There are 3 types of interfaces for [Decoding_Calls] calls:
-
- Interface-1 : Partial output buffers:
- {
- XzUnpacker_Init()
- for()
- XzUnpacker_Code();
- }
-
- Interface-2 : Direct output buffer:
- Use it, if you know exact size of decoded data, and you need
- whole xz unpacked data in one output buffer.
- xz unpacker doesn't allocate additional buffer for lzma2 dictionary in that mode.
- {
- XzUnpacker_Init()
- XzUnpacker_SetOutBufMode(); // to set output buffer and size
- for()
- XzUnpacker_Code(); // (dest = NULL) in XzUnpacker_Code()
- }
-
- Interface-3 : Direct output buffer : One call full decoding
- It unpacks whole input buffer to output buffer in one call.
- It uses Interface-2 internally.
- {
- XzUnpacker_CodeFull()
- }
-*/
-
-/*
-finishMode:
- It has meaning only if the decoding reaches output limit (*destLen).
- CODER_FINISH_ANY - use smallest number of input bytes
- CODER_FINISH_END - read EndOfStream marker after decoding
-
-Returns:
- SZ_OK
- status:
- CODER_STATUS_NOT_FINISHED,
- CODER_STATUS_NEEDS_MORE_INPUT - maybe there are more xz streams,
- call XzUnpacker_IsStreamWasFinished to check that current stream was finished
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_DATA - Data error
- SZ_ERROR_UNSUPPORTED - Unsupported method or method properties
- SZ_ERROR_CRC - CRC error
- // SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
-
- SZ_ERROR_NO_ARCHIVE - the error with xz Stream Header with one of the following reasons:
- - xz Stream Signature failure
- - CRC32 of xz Stream Header is failed
- - The size of Stream padding is not multiple of four bytes.
- It's possible to get that error, if xz stream was finished and the stream
- contains some another data. In that case you can call XzUnpacker_GetExtraSize()
- function to get real size of xz stream.
-*/
-
-
-SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
- const Byte *src, SizeT *srcLen, int srcFinished,
- ECoderFinishMode finishMode, ECoderStatus *status);
-
-SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen,
- const Byte *src, SizeT *srcLen,
- ECoderFinishMode finishMode, ECoderStatus *status);
-
-BoolInt XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p);
-
-/*
-XzUnpacker_GetExtraSize() returns then number of uncofirmed bytes,
- if it's in (XZ_STATE_STREAM_HEADER) state or in (XZ_STATE_STREAM_PADDING) state.
-These bytes can be some bytes after xz archive, or
-it can be start of new xz stream.
-
-Call XzUnpacker_GetExtraSize() after XzUnpacker_Code() function to detect real size of
-xz stream in two cases, if XzUnpacker_Code() returns:
- res == SZ_OK && status == CODER_STATUS_NEEDS_MORE_INPUT
- res == SZ_ERROR_NO_ARCHIVE
-*/
-
-UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p);
-
-
-/*
- for random block decoding:
- XzUnpacker_Init();
- set CXzUnpacker::streamFlags
- XzUnpacker_PrepareToRandomBlockDecoding()
- loop
- {
- XzUnpacker_Code()
- XzUnpacker_IsBlockFinished()
- }
-*/
-
-void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p);
-BoolInt XzUnpacker_IsBlockFinished(const CXzUnpacker *p);
-
-#define XzUnpacker_GetPackSizeForIndex(p) ((p)->packSize + (p)->blockHeaderSize + XzFlags_GetCheckSize((p)->streamFlags))
-
-
-
-/* ---------- Multi Threading Decoding ---------- */
-
-
-typedef struct
-{
- size_t inBufSize_ST;
- size_t outStep_ST;
- BoolInt ignoreErrors;
-
- #ifndef _7ZIP_ST
- unsigned numThreads;
- size_t inBufSize_MT;
- size_t memUseMax;
- #endif
-} CXzDecMtProps;
-
-void XzDecMtProps_Init(CXzDecMtProps *p);
-
-
-typedef void * CXzDecMtHandle;
-
-/*
- alloc : XzDecMt uses CAlignOffsetAlloc for addresses allocated by (alloc).
- allocMid : for big allocations, aligned allocation is better
-*/
-
-CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid);
-void XzDecMt_Destroy(CXzDecMtHandle p);
-
-
-typedef struct
-{
- Byte UnpackSize_Defined;
- Byte NumStreams_Defined;
- Byte NumBlocks_Defined;
-
- Byte DataAfterEnd;
- Byte DecodingTruncated; // Decoding was Truncated, we need only partial output data
-
- UInt64 InSize; // pack size processed
- UInt64 OutSize;
-
- UInt64 NumStreams;
- UInt64 NumBlocks;
-
- SRes DecodeRes;
- SRes ReadRes;
- SRes ProgressRes;
- SRes CombinedRes;
- SRes CombinedRes_Type;
-
-} CXzStatInfo;
-
-void XzStatInfo_Clear(CXzStatInfo *p);
-
-/*
-XzDecMt_Decode()
-SRes:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_NO_ARCHIVE - is not xz archive
- SZ_ERROR_ARCHIVE - Headers error
- SZ_ERROR_DATA - Data Error
- SZ_ERROR_CRC - CRC Error
- SZ_ERROR_INPUT_EOF - it needs more input data
- SZ_ERROR_WRITE - ISeqOutStream error
- (SZ_ERROR_READ) - ISeqInStream errors
- (SZ_ERROR_PROGRESS) - ICompressProgress errors
- // SZ_ERROR_THREAD - error in multi-threading functions
- MY_SRes_HRESULT_FROM_WRes(WRes_error) - error in multi-threading function
-*/
-
-SRes XzDecMt_Decode(CXzDecMtHandle p,
- const CXzDecMtProps *props,
- const UInt64 *outDataSize, // NULL means undefined
- int finishMode, // 0 - partial unpacking is allowed, 1 - xz stream(s) must be finished
- ISeqOutStream *outStream,
- // Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- // const Byte *inData, size_t inDataSize,
- CXzStatInfo *stat,
- int *isMT, // 0 means that ST (Single-Thread) version was used
- ICompressProgress *progress);
-
-EXTERN_C_END
-
-#endif
+/* Xz.h - Xz interface
+2023-04-13 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_XZ_H
+#define ZIP7_INC_XZ_H
+
+#include "Sha256.h"
+#include "Delta.h"
+
+EXTERN_C_BEGIN
+
+#define XZ_ID_Subblock 1
+#define XZ_ID_Delta 3
+#define XZ_ID_X86 4
+#define XZ_ID_PPC 5
+#define XZ_ID_IA64 6
+#define XZ_ID_ARM 7
+#define XZ_ID_ARMT 8
+#define XZ_ID_SPARC 9
+#define XZ_ID_ARM64 0xa
+#define XZ_ID_LZMA2 0x21
+
+unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value);
+unsigned Xz_WriteVarInt(Byte *buf, UInt64 v);
+
+/* ---------- xz block ---------- */
+
+#define XZ_BLOCK_HEADER_SIZE_MAX 1024
+
+#define XZ_NUM_FILTERS_MAX 4
+#define XZ_BF_NUM_FILTERS_MASK 3
+#define XZ_BF_PACK_SIZE (1 << 6)
+#define XZ_BF_UNPACK_SIZE (1 << 7)
+
+#define XZ_FILTER_PROPS_SIZE_MAX 20
+
+typedef struct
+{
+ UInt64 id;
+ UInt32 propsSize;
+ Byte props[XZ_FILTER_PROPS_SIZE_MAX];
+} CXzFilter;
+
+typedef struct
+{
+ UInt64 packSize;
+ UInt64 unpackSize;
+ Byte flags;
+ CXzFilter filters[XZ_NUM_FILTERS_MAX];
+} CXzBlock;
+
+#define XzBlock_GetNumFilters(p) (((unsigned)(p)->flags & XZ_BF_NUM_FILTERS_MASK) + 1)
+#define XzBlock_HasPackSize(p) (((p)->flags & XZ_BF_PACK_SIZE) != 0)
+#define XzBlock_HasUnpackSize(p) (((p)->flags & XZ_BF_UNPACK_SIZE) != 0)
+#define XzBlock_HasUnsupportedFlags(p) (((p)->flags & ~(XZ_BF_NUM_FILTERS_MASK | XZ_BF_PACK_SIZE | XZ_BF_UNPACK_SIZE)) != 0)
+
+SRes XzBlock_Parse(CXzBlock *p, const Byte *header);
+SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStreamPtr inStream, BoolInt *isIndex, UInt32 *headerSizeRes);
+
+/* ---------- xz stream ---------- */
+
+#define XZ_SIG_SIZE 6
+#define XZ_FOOTER_SIG_SIZE 2
+
+extern const Byte XZ_SIG[XZ_SIG_SIZE];
+
+/*
+extern const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE];
+*/
+
+#define XZ_FOOTER_SIG_0 'Y'
+#define XZ_FOOTER_SIG_1 'Z'
+
+#define XZ_STREAM_FLAGS_SIZE 2
+#define XZ_STREAM_CRC_SIZE 4
+
+#define XZ_STREAM_HEADER_SIZE (XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE)
+#define XZ_STREAM_FOOTER_SIZE (XZ_FOOTER_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE + 4)
+
+#define XZ_CHECK_MASK 0xF
+#define XZ_CHECK_NO 0
+#define XZ_CHECK_CRC32 1
+#define XZ_CHECK_CRC64 4
+#define XZ_CHECK_SHA256 10
+
+typedef struct
+{
+ unsigned mode;
+ UInt32 crc;
+ UInt64 crc64;
+ CSha256 sha;
+} CXzCheck;
+
+void XzCheck_Init(CXzCheck *p, unsigned mode);
+void XzCheck_Update(CXzCheck *p, const void *data, size_t size);
+int XzCheck_Final(CXzCheck *p, Byte *digest);
+
+typedef UInt16 CXzStreamFlags;
+
+#define XzFlags_IsSupported(f) ((f) <= XZ_CHECK_MASK)
+#define XzFlags_GetCheckType(f) ((f) & XZ_CHECK_MASK)
+#define XzFlags_HasDataCrc32(f) (Xz_GetCheckType(f) == XZ_CHECK_CRC32)
+unsigned XzFlags_GetCheckSize(CXzStreamFlags f);
+
+SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf);
+SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStreamPtr inStream);
+
+typedef struct
+{
+ UInt64 unpackSize;
+ UInt64 totalSize;
+} CXzBlockSizes;
+
+typedef struct
+{
+ CXzStreamFlags flags;
+ // Byte _pad[6];
+ size_t numBlocks;
+ CXzBlockSizes *blocks;
+ UInt64 startOffset;
+} CXzStream;
+
+void Xz_Construct(CXzStream *p);
+void Xz_Free(CXzStream *p, ISzAllocPtr alloc);
+
+#define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1)
+
+UInt64 Xz_GetUnpackSize(const CXzStream *p);
+UInt64 Xz_GetPackSize(const CXzStream *p);
+
+typedef struct
+{
+ size_t num;
+ size_t numAllocated;
+ CXzStream *streams;
+} CXzs;
+
+void Xzs_Construct(CXzs *p);
+void Xzs_Free(CXzs *p, ISzAllocPtr alloc);
+SRes Xzs_ReadBackward(CXzs *p, ILookInStreamPtr inStream, Int64 *startOffset, ICompressProgressPtr progress, ISzAllocPtr alloc);
+
+UInt64 Xzs_GetNumBlocks(const CXzs *p);
+UInt64 Xzs_GetUnpackSize(const CXzs *p);
+
+
+// ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder
+
+typedef enum
+{
+ CODER_STATUS_NOT_SPECIFIED, /* use main error code instead */
+ CODER_STATUS_FINISHED_WITH_MARK, /* stream was finished with end mark. */
+ CODER_STATUS_NOT_FINISHED, /* stream was not finished */
+ CODER_STATUS_NEEDS_MORE_INPUT /* you must provide more input bytes */
+} ECoderStatus;
+
+
+// ECoderFinishMode values are identical to ELzmaFinishMode
+
+typedef enum
+{
+ CODER_FINISH_ANY, /* finish at any point */
+ CODER_FINISH_END /* block must be finished at the end */
+} ECoderFinishMode;
+
+
+typedef struct
+{
+ void *p; // state object;
+ void (*Free)(void *p, ISzAllocPtr alloc);
+ SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAllocPtr alloc);
+ void (*Init)(void *p);
+ SRes (*Code2)(void *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+ int srcWasFinished, ECoderFinishMode finishMode,
+ // int *wasFinished,
+ ECoderStatus *status);
+ SizeT (*Filter)(void *p, Byte *data, SizeT size);
+} IStateCoder;
+
+
+typedef struct
+{
+ UInt32 methodId;
+ UInt32 delta;
+ UInt32 ip;
+ UInt32 X86_State;
+ Byte delta_State[DELTA_STATE_SIZE];
+} CXzBcFilterStateBase;
+
+typedef SizeT (*Xz_Func_BcFilterStateBase_Filter)(CXzBcFilterStateBase *p, Byte *data, SizeT size);
+
+SRes Xz_StateCoder_Bc_SetFromMethod_Func(IStateCoder *p, UInt64 id,
+ Xz_Func_BcFilterStateBase_Filter func, ISzAllocPtr alloc);
+
+
+#define MIXCODER_NUM_FILTERS_MAX 4
+
+typedef struct
+{
+ ISzAllocPtr alloc;
+ Byte *buf;
+ unsigned numCoders;
+
+ Byte *outBuf;
+ size_t outBufSize;
+ size_t outWritten; // is equal to lzmaDecoder.dicPos (in outBuf mode)
+ BoolInt wasFinished;
+ SRes res;
+ ECoderStatus status;
+ // BoolInt SingleBufMode;
+
+ int finished[MIXCODER_NUM_FILTERS_MAX - 1];
+ size_t pos[MIXCODER_NUM_FILTERS_MAX - 1];
+ size_t size[MIXCODER_NUM_FILTERS_MAX - 1];
+ UInt64 ids[MIXCODER_NUM_FILTERS_MAX];
+ SRes results[MIXCODER_NUM_FILTERS_MAX];
+ IStateCoder coders[MIXCODER_NUM_FILTERS_MAX];
+} CMixCoder;
+
+
+typedef enum
+{
+ XZ_STATE_STREAM_HEADER,
+ XZ_STATE_STREAM_INDEX,
+ XZ_STATE_STREAM_INDEX_CRC,
+ XZ_STATE_STREAM_FOOTER,
+ XZ_STATE_STREAM_PADDING,
+ XZ_STATE_BLOCK_HEADER,
+ XZ_STATE_BLOCK,
+ XZ_STATE_BLOCK_FOOTER
+} EXzState;
+
+
+typedef struct
+{
+ EXzState state;
+ UInt32 pos;
+ unsigned alignPos;
+ unsigned indexPreSize;
+
+ CXzStreamFlags streamFlags;
+
+ UInt32 blockHeaderSize;
+ UInt64 packSize;
+ UInt64 unpackSize;
+
+ UInt64 numBlocks; // number of finished blocks in current stream
+ UInt64 indexSize;
+ UInt64 indexPos;
+ UInt64 padSize;
+
+ UInt64 numStartedStreams;
+ UInt64 numFinishedStreams;
+ UInt64 numTotalBlocks;
+
+ UInt32 crc;
+ CMixCoder decoder;
+ CXzBlock block;
+ CXzCheck check;
+ CSha256 sha;
+
+ BoolInt parseMode;
+ BoolInt headerParsedOk;
+ BoolInt decodeToStreamSignature;
+ unsigned decodeOnlyOneBlock;
+
+ Byte *outBuf;
+ size_t outBufSize;
+ size_t outDataWritten; // the size of data in (outBuf) that were fully unpacked
+
+ Byte shaDigest[SHA256_DIGEST_SIZE];
+ Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];
+} CXzUnpacker;
+
+/* alloc : aligned for cache line allocation is better */
+void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc);
+void XzUnpacker_Init(CXzUnpacker *p);
+void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize);
+void XzUnpacker_Free(CXzUnpacker *p);
+
+/*
+ XzUnpacker
+ The sequence for decoding functions:
+ {
+ XzUnpacker_Construct()
+ [Decoding_Calls]
+ XzUnpacker_Free()
+ }
+
+ [Decoding_Calls]
+
+ There are 3 types of interfaces for [Decoding_Calls] calls:
+
+ Interface-1 : Partial output buffers:
+ {
+ XzUnpacker_Init()
+ for()
+ {
+ XzUnpacker_Code();
+ }
+ XzUnpacker_IsStreamWasFinished()
+ }
+
+ Interface-2 : Direct output buffer:
+ Use it, if you know exact size of decoded data, and you need
+ whole xz unpacked data in one output buffer.
+ xz unpacker doesn't allocate additional buffer for lzma2 dictionary in that mode.
+ {
+ XzUnpacker_Init()
+ XzUnpacker_SetOutBufMode(); // to set output buffer and size
+ for()
+ {
+ XzUnpacker_Code(); // (dest = NULL) in XzUnpacker_Code()
+ }
+ XzUnpacker_IsStreamWasFinished()
+ }
+
+ Interface-3 : Direct output buffer : One call full decoding
+ It unpacks whole input buffer to output buffer in one call.
+ It uses Interface-2 internally.
+ {
+ XzUnpacker_CodeFull()
+ XzUnpacker_IsStreamWasFinished()
+ }
+*/
+
+/*
+finishMode:
+ It has meaning only if the decoding reaches output limit (*destLen).
+ CODER_FINISH_ANY - use smallest number of input bytes
+ CODER_FINISH_END - read EndOfStream marker after decoding
+
+Returns:
+ SZ_OK
+ status:
+ CODER_STATUS_NOT_FINISHED,
+ CODER_STATUS_NEEDS_MORE_INPUT - the decoder can return it in two cases:
+ 1) it needs more input data to finish current xz stream
+ 2) xz stream was finished successfully. But the decoder supports multiple
+ concatented xz streams. So it expects more input data for new xz streams.
+ Call XzUnpacker_IsStreamWasFinished() to check that latest xz stream was finished successfully.
+
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_DATA - Data error
+ SZ_ERROR_UNSUPPORTED - Unsupported method or method properties
+ SZ_ERROR_CRC - CRC error
+ // SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
+
+ SZ_ERROR_NO_ARCHIVE - the error with xz Stream Header with one of the following reasons:
+ - xz Stream Signature failure
+ - CRC32 of xz Stream Header is failed
+ - The size of Stream padding is not multiple of four bytes.
+ It's possible to get that error, if xz stream was finished and the stream
+ contains some another data. In that case you can call XzUnpacker_GetExtraSize()
+ function to get real size of xz stream.
+*/
+
+
+SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
+ const Byte *src, SizeT *srcLen, int srcFinished,
+ ECoderFinishMode finishMode, ECoderStatus *status);
+
+SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen,
+ const Byte *src, SizeT *srcLen,
+ ECoderFinishMode finishMode, ECoderStatus *status);
+
+/*
+If you decode full xz stream(s), then you can call XzUnpacker_IsStreamWasFinished()
+after successful XzUnpacker_CodeFull() or after last call of XzUnpacker_Code().
+*/
+
+BoolInt XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p);
+
+/*
+XzUnpacker_GetExtraSize() returns then number of unconfirmed bytes,
+ if it's in (XZ_STATE_STREAM_HEADER) state or in (XZ_STATE_STREAM_PADDING) state.
+These bytes can be some data after xz archive, or
+it can be start of new xz stream.
+
+Call XzUnpacker_GetExtraSize() after XzUnpacker_Code() function to detect real size of
+xz stream in two cases, if XzUnpacker_Code() returns:
+ res == SZ_OK && status == CODER_STATUS_NEEDS_MORE_INPUT
+ res == SZ_ERROR_NO_ARCHIVE
+*/
+
+UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p);
+
+
+/*
+ for random block decoding:
+ XzUnpacker_Init();
+ set CXzUnpacker::streamFlags
+ XzUnpacker_PrepareToRandomBlockDecoding()
+ loop
+ {
+ XzUnpacker_Code()
+ XzUnpacker_IsBlockFinished()
+ }
+*/
+
+void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p);
+BoolInt XzUnpacker_IsBlockFinished(const CXzUnpacker *p);
+
+#define XzUnpacker_GetPackSizeForIndex(p) ((p)->packSize + (p)->blockHeaderSize + XzFlags_GetCheckSize((p)->streamFlags))
+
+
+
+
+
+
+/* ---- Single-Thread and Multi-Thread xz Decoding with Input/Output Streams ---- */
+
+/*
+ if (CXzDecMtProps::numThreads > 1), the decoder can try to use
+ Multi-Threading. The decoder analyses xz block header, and if
+ there are pack size and unpack size values stored in xz block header,
+ the decoder reads compressed data of block to internal buffers,
+ and then it can start parallel decoding, if there are another blocks.
+ The decoder can switch back to Single-Thread decoding after some conditions.
+
+ The sequence of calls for xz decoding with in/out Streams:
+ {
+ XzDecMt_Create()
+ XzDecMtProps_Init(XzDecMtProps) to set default values of properties
+ // then you can change some XzDecMtProps parameters with required values
+ // here you can set the number of threads and (memUseMax) - the maximum
+ Memory usage for multithreading decoding.
+ for()
+ {
+ XzDecMt_Decode() // one call per one file
+ }
+ XzDecMt_Destroy()
+ }
+*/
+
+
+typedef struct
+{
+ size_t inBufSize_ST; // size of input buffer for Single-Thread decoding
+ size_t outStep_ST; // size of output buffer for Single-Thread decoding
+ BoolInt ignoreErrors; // if set to 1, the decoder can ignore some errors and it skips broken parts of data.
+
+ #ifndef Z7_ST
+ unsigned numThreads; // the number of threads for Multi-Thread decoding. if (umThreads == 1) it will use Single-thread decoding
+ size_t inBufSize_MT; // size of small input data buffers for Multi-Thread decoding. Big number of such small buffers can be created
+ size_t memUseMax; // the limit of total memory usage for Multi-Thread decoding.
+ // it's recommended to set (memUseMax) manually to value that is smaller of total size of RAM in computer.
+ #endif
+} CXzDecMtProps;
+
+void XzDecMtProps_Init(CXzDecMtProps *p);
+
+typedef struct CXzDecMt CXzDecMt;
+typedef CXzDecMt * CXzDecMtHandle;
+// Z7_DECLARE_HANDLE(CXzDecMtHandle)
+
+/*
+ alloc : XzDecMt uses CAlignOffsetAlloc internally for addresses allocated by (alloc).
+ allocMid : for big allocations, aligned allocation is better
+*/
+
+CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid);
+void XzDecMt_Destroy(CXzDecMtHandle p);
+
+
+typedef struct
+{
+ Byte UnpackSize_Defined;
+ Byte NumStreams_Defined;
+ Byte NumBlocks_Defined;
+
+ Byte DataAfterEnd; // there are some additional data after good xz streams, and that data is not new xz stream.
+ Byte DecodingTruncated; // Decoding was Truncated, we need only partial output data
+
+ UInt64 InSize; // pack size processed. That value doesn't include the data after
+ // end of xz stream, if that data was not correct
+ UInt64 OutSize;
+
+ UInt64 NumStreams;
+ UInt64 NumBlocks;
+
+ SRes DecodeRes; // the error code of xz streams data decoding
+ SRes ReadRes; // error code from ISeqInStream:Read()
+ SRes ProgressRes; // error code from ICompressProgress:Progress()
+
+ SRes CombinedRes; // Combined result error code that shows main rusult
+ // = S_OK, if there is no error.
+ // but check also (DataAfterEnd) that can show additional minor errors.
+
+ SRes CombinedRes_Type; // = SZ_ERROR_READ, if error from ISeqInStream
+ // = SZ_ERROR_PROGRESS, if error from ICompressProgress
+ // = SZ_ERROR_WRITE, if error from ISeqOutStream
+ // = SZ_ERROR_* codes for decoding
+} CXzStatInfo;
+
+void XzStatInfo_Clear(CXzStatInfo *p);
+
+/*
+
+XzDecMt_Decode()
+SRes: it's combined decoding result. It also is equal to stat->CombinedRes.
+
+ SZ_OK - no error
+ check also output value in (stat->DataAfterEnd)
+ that can show additional possible error
+
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_NO_ARCHIVE - is not xz archive
+ SZ_ERROR_ARCHIVE - Headers error
+ SZ_ERROR_DATA - Data Error
+ SZ_ERROR_UNSUPPORTED - Unsupported method or method properties
+ SZ_ERROR_CRC - CRC Error
+ SZ_ERROR_INPUT_EOF - it needs more input data
+ SZ_ERROR_WRITE - ISeqOutStream error
+ (SZ_ERROR_READ) - ISeqInStream errors
+ (SZ_ERROR_PROGRESS) - ICompressProgress errors
+ // SZ_ERROR_THREAD - error in multi-threading functions
+ MY_SRes_HRESULT_FROM_WRes(WRes_error) - error in multi-threading function
+*/
+
+SRes XzDecMt_Decode(CXzDecMtHandle p,
+ const CXzDecMtProps *props,
+ const UInt64 *outDataSize, // NULL means undefined
+ int finishMode, // 0 - partial unpacking is allowed, 1 - xz stream(s) must be finished
+ ISeqOutStreamPtr outStream,
+ // Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ // const Byte *inData, size_t inDataSize,
+ CXzStatInfo *stat, // out: decoding results and statistics
+ int *isMT, // out: 0 means that ST (Single-Thread) version was used
+ // 1 means that MT (Multi-Thread) version was used
+ ICompressProgressPtr progress);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/XzCrc64.c b/C/XzCrc64.c
index e9ca9ec..c2fad6c 100644
--- a/C/XzCrc64.c
+++ b/C/XzCrc64.c
@@ -1,86 +1,80 @@
-/* XzCrc64.c -- CRC64 calculation
-2017-05-23 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "XzCrc64.h"
-#include "CpuArch.h"
-
-#define kCrc64Poly UINT64_CONST(0xC96C5795D7870F42)
-
-#ifdef MY_CPU_LE
- #define CRC64_NUM_TABLES 4
-#else
- #define CRC64_NUM_TABLES 5
- #define CRC_UINT64_SWAP(v) \
- ((v >> 56) \
- | ((v >> 40) & ((UInt64)0xFF << 8)) \
- | ((v >> 24) & ((UInt64)0xFF << 16)) \
- | ((v >> 8) & ((UInt64)0xFF << 24)) \
- | ((v << 8) & ((UInt64)0xFF << 32)) \
- | ((v << 24) & ((UInt64)0xFF << 40)) \
- | ((v << 40) & ((UInt64)0xFF << 48)) \
- | ((v << 56)))
-
- UInt64 MY_FAST_CALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table);
-#endif
-
-#ifndef MY_CPU_BE
- UInt64 MY_FAST_CALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table);
-#endif
-
-typedef UInt64 (MY_FAST_CALL *CRC64_FUNC)(UInt64 v, const void *data, size_t size, const UInt64 *table);
-
-static CRC64_FUNC g_Crc64Update;
-UInt64 g_Crc64Table[256 * CRC64_NUM_TABLES];
-
-UInt64 MY_FAST_CALL Crc64Update(UInt64 v, const void *data, size_t size)
-{
- return g_Crc64Update(v, data, size, g_Crc64Table);
-}
-
-UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size)
-{
- return g_Crc64Update(CRC64_INIT_VAL, data, size, g_Crc64Table) ^ CRC64_INIT_VAL;
-}
-
-void MY_FAST_CALL Crc64GenerateTable()
-{
- UInt32 i;
- for (i = 0; i < 256; i++)
- {
- UInt64 r = i;
- unsigned j;
- for (j = 0; j < 8; j++)
- r = (r >> 1) ^ (kCrc64Poly & ((UInt64)0 - (r & 1)));
- g_Crc64Table[i] = r;
- }
- for (i = 256; i < 256 * CRC64_NUM_TABLES; i++)
- {
- UInt64 r = g_Crc64Table[(size_t)i - 256];
- g_Crc64Table[i] = g_Crc64Table[r & 0xFF] ^ (r >> 8);
- }
-
- #ifdef MY_CPU_LE
-
- g_Crc64Update = XzCrc64UpdateT4;
-
- #else
- {
- #ifndef MY_CPU_BE
- UInt32 k = 1;
- if (*(const Byte *)&k == 1)
- g_Crc64Update = XzCrc64UpdateT4;
- else
- #endif
- {
- for (i = 256 * CRC64_NUM_TABLES - 1; i >= 256; i--)
- {
- UInt64 x = g_Crc64Table[(size_t)i - 256];
- g_Crc64Table[i] = CRC_UINT64_SWAP(x);
- }
- g_Crc64Update = XzCrc64UpdateT1_BeT4;
- }
- }
- #endif
-}
+/* XzCrc64.c -- CRC64 calculation
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "XzCrc64.h"
+#include "CpuArch.h"
+
+#define kCrc64Poly UINT64_CONST(0xC96C5795D7870F42)
+
+#ifdef MY_CPU_LE
+ #define CRC64_NUM_TABLES 4
+#else
+ #define CRC64_NUM_TABLES 5
+
+ UInt64 Z7_FASTCALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table);
+#endif
+
+#ifndef MY_CPU_BE
+ UInt64 Z7_FASTCALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table);
+#endif
+
+typedef UInt64 (Z7_FASTCALL *CRC64_FUNC)(UInt64 v, const void *data, size_t size, const UInt64 *table);
+
+static CRC64_FUNC g_Crc64Update;
+UInt64 g_Crc64Table[256 * CRC64_NUM_TABLES];
+
+UInt64 Z7_FASTCALL Crc64Update(UInt64 v, const void *data, size_t size)
+{
+ return g_Crc64Update(v, data, size, g_Crc64Table);
+}
+
+UInt64 Z7_FASTCALL Crc64Calc(const void *data, size_t size)
+{
+ return g_Crc64Update(CRC64_INIT_VAL, data, size, g_Crc64Table) ^ CRC64_INIT_VAL;
+}
+
+void Z7_FASTCALL Crc64GenerateTable(void)
+{
+ UInt32 i;
+ for (i = 0; i < 256; i++)
+ {
+ UInt64 r = i;
+ unsigned j;
+ for (j = 0; j < 8; j++)
+ r = (r >> 1) ^ (kCrc64Poly & ((UInt64)0 - (r & 1)));
+ g_Crc64Table[i] = r;
+ }
+ for (i = 256; i < 256 * CRC64_NUM_TABLES; i++)
+ {
+ const UInt64 r = g_Crc64Table[(size_t)i - 256];
+ g_Crc64Table[i] = g_Crc64Table[r & 0xFF] ^ (r >> 8);
+ }
+
+ #ifdef MY_CPU_LE
+
+ g_Crc64Update = XzCrc64UpdateT4;
+
+ #else
+ {
+ #ifndef MY_CPU_BE
+ UInt32 k = 1;
+ if (*(const Byte *)&k == 1)
+ g_Crc64Update = XzCrc64UpdateT4;
+ else
+ #endif
+ {
+ for (i = 256 * CRC64_NUM_TABLES - 1; i >= 256; i--)
+ {
+ const UInt64 x = g_Crc64Table[(size_t)i - 256];
+ g_Crc64Table[i] = Z7_BSWAP64(x);
+ }
+ g_Crc64Update = XzCrc64UpdateT1_BeT4;
+ }
+ }
+ #endif
+}
+
+#undef kCrc64Poly
+#undef CRC64_NUM_TABLES
diff --git a/C/XzCrc64.h b/C/XzCrc64.h
index 71b10d5..ca46869 100644
--- a/C/XzCrc64.h
+++ b/C/XzCrc64.h
@@ -1,26 +1,26 @@
-/* XzCrc64.h -- CRC64 calculation
-2013-01-18 : Igor Pavlov : Public domain */
-
-#ifndef __XZ_CRC64_H
-#define __XZ_CRC64_H
-
-#include <stddef.h>
-
-#include "7zTypes.h"
-
-EXTERN_C_BEGIN
-
-extern UInt64 g_Crc64Table[];
-
-void MY_FAST_CALL Crc64GenerateTable(void);
-
-#define CRC64_INIT_VAL UINT64_CONST(0xFFFFFFFFFFFFFFFF)
-#define CRC64_GET_DIGEST(crc) ((crc) ^ CRC64_INIT_VAL)
-#define CRC64_UPDATE_BYTE(crc, b) (g_Crc64Table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-UInt64 MY_FAST_CALL Crc64Update(UInt64 crc, const void *data, size_t size);
-UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size);
-
-EXTERN_C_END
-
-#endif
+/* XzCrc64.h -- CRC64 calculation
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_XZ_CRC64_H
+#define ZIP7_INC_XZ_CRC64_H
+
+#include <stddef.h>
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+extern UInt64 g_Crc64Table[];
+
+void Z7_FASTCALL Crc64GenerateTable(void);
+
+#define CRC64_INIT_VAL UINT64_CONST(0xFFFFFFFFFFFFFFFF)
+#define CRC64_GET_DIGEST(crc) ((crc) ^ CRC64_INIT_VAL)
+#define CRC64_UPDATE_BYTE(crc, b) (g_Crc64Table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt64 Z7_FASTCALL Crc64Update(UInt64 crc, const void *data, size_t size);
+UInt64 Z7_FASTCALL Crc64Calc(const void *data, size_t size);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/XzCrc64Opt.c b/C/XzCrc64Opt.c
index 9273465..d03374c 100644
--- a/C/XzCrc64Opt.c
+++ b/C/XzCrc64Opt.c
@@ -1,69 +1,61 @@
-/* XzCrc64Opt.c -- CRC64 calculation
-2017-06-30 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include "CpuArch.h"
-
-#ifndef MY_CPU_BE
-
-#define CRC64_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
-
-UInt64 MY_FAST_CALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table)
-{
- const Byte *p = (const Byte *)data;
- for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
- v = CRC64_UPDATE_BYTE_2(v, *p);
- for (; size >= 4; size -= 4, p += 4)
- {
- UInt32 d = (UInt32)v ^ *(const UInt32 *)p;
- v = (v >> 32)
- ^ (table + 0x300)[((d ) & 0xFF)]
- ^ (table + 0x200)[((d >> 8) & 0xFF)]
- ^ (table + 0x100)[((d >> 16) & 0xFF)]
- ^ (table + 0x000)[((d >> 24))];
- }
- for (; size > 0; size--, p++)
- v = CRC64_UPDATE_BYTE_2(v, *p);
- return v;
-}
-
-#endif
-
-
-#ifndef MY_CPU_LE
-
-#define CRC_UINT64_SWAP(v) \
- ((v >> 56) \
- | ((v >> 40) & ((UInt64)0xFF << 8)) \
- | ((v >> 24) & ((UInt64)0xFF << 16)) \
- | ((v >> 8) & ((UInt64)0xFF << 24)) \
- | ((v << 8) & ((UInt64)0xFF << 32)) \
- | ((v << 24) & ((UInt64)0xFF << 40)) \
- | ((v << 40) & ((UInt64)0xFF << 48)) \
- | ((v << 56)))
-
-#define CRC64_UPDATE_BYTE_2_BE(crc, b) (table[(Byte)((crc) >> 56) ^ (b)] ^ ((crc) << 8))
-
-UInt64 MY_FAST_CALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table)
-{
- const Byte *p = (const Byte *)data;
- table += 0x100;
- v = CRC_UINT64_SWAP(v);
- for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
- v = CRC64_UPDATE_BYTE_2_BE(v, *p);
- for (; size >= 4; size -= 4, p += 4)
- {
- UInt32 d = (UInt32)(v >> 32) ^ *(const UInt32 *)p;
- v = (v << 32)
- ^ (table + 0x000)[((d ) & 0xFF)]
- ^ (table + 0x100)[((d >> 8) & 0xFF)]
- ^ (table + 0x200)[((d >> 16) & 0xFF)]
- ^ (table + 0x300)[((d >> 24))];
- }
- for (; size > 0; size--, p++)
- v = CRC64_UPDATE_BYTE_2_BE(v, *p);
- return CRC_UINT64_SWAP(v);
-}
-
-#endif
+/* XzCrc64Opt.c -- CRC64 calculation
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "CpuArch.h"
+
+#ifndef MY_CPU_BE
+
+#define CRC64_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt64 Z7_FASTCALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table);
+UInt64 Z7_FASTCALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table)
+{
+ const Byte *p = (const Byte *)data;
+ for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
+ v = CRC64_UPDATE_BYTE_2(v, *p);
+ for (; size >= 4; size -= 4, p += 4)
+ {
+ const UInt32 d = (UInt32)v ^ *(const UInt32 *)(const void *)p;
+ v = (v >> 32)
+ ^ (table + 0x300)[((d ) & 0xFF)]
+ ^ (table + 0x200)[((d >> 8) & 0xFF)]
+ ^ (table + 0x100)[((d >> 16) & 0xFF)]
+ ^ (table + 0x000)[((d >> 24))];
+ }
+ for (; size > 0; size--, p++)
+ v = CRC64_UPDATE_BYTE_2(v, *p);
+ return v;
+}
+
+#endif
+
+
+#ifndef MY_CPU_LE
+
+#define CRC64_UPDATE_BYTE_2_BE(crc, b) (table[(Byte)((crc) >> 56) ^ (b)] ^ ((crc) << 8))
+
+UInt64 Z7_FASTCALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table);
+UInt64 Z7_FASTCALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table)
+{
+ const Byte *p = (const Byte *)data;
+ table += 0x100;
+ v = Z7_BSWAP64(v);
+ for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
+ v = CRC64_UPDATE_BYTE_2_BE(v, *p);
+ for (; size >= 4; size -= 4, p += 4)
+ {
+ const UInt32 d = (UInt32)(v >> 32) ^ *(const UInt32 *)(const void *)p;
+ v = (v << 32)
+ ^ (table + 0x000)[((d ) & 0xFF)]
+ ^ (table + 0x100)[((d >> 8) & 0xFF)]
+ ^ (table + 0x200)[((d >> 16) & 0xFF)]
+ ^ (table + 0x300)[((d >> 24))];
+ }
+ for (; size > 0; size--, p++)
+ v = CRC64_UPDATE_BYTE_2_BE(v, *p);
+ return Z7_BSWAP64(v);
+}
+
+#endif
diff --git a/C/XzDec.c b/C/XzDec.c
index 4f53272..a5f7039 100644
--- a/C/XzDec.c
+++ b/C/XzDec.c
@@ -1,2766 +1,2875 @@
-/* XzDec.c -- Xz Decode
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-// #include <stdio.h>
-
-// #define XZ_DUMP
-
-/* #define XZ_DUMP */
-
-#ifdef XZ_DUMP
-#include <stdio.h>
-#endif
-
-// #define SHOW_DEBUG_INFO
-
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-#define PRF_STR(s) PRF(printf("\n" s "\n"))
-#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "7zCrc.h"
-#include "Alloc.h"
-#include "Bra.h"
-#include "CpuArch.h"
-#include "Delta.h"
-#include "Lzma2Dec.h"
-
-// #define USE_SUBBLOCK
-
-#ifdef USE_SUBBLOCK
-#include "Bcj3Dec.c"
-#include "SbDec.h"
-#endif
-
-#include "Xz.h"
-
-#define XZ_CHECK_SIZE_MAX 64
-
-#define CODER_BUF_SIZE ((size_t)1 << 17)
-
-unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
-{
- unsigned i, limit;
- *value = 0;
- limit = (maxSize > 9) ? 9 : (unsigned)maxSize;
-
- for (i = 0; i < limit;)
- {
- Byte b = p[i];
- *value |= (UInt64)(b & 0x7F) << (7 * i++);
- if ((b & 0x80) == 0)
- return (b == 0 && i != 1) ? 0 : i;
- }
- return 0;
-}
-
-/* ---------- BraState ---------- */
-
-#define BRA_BUF_SIZE (1 << 14)
-
-typedef struct
-{
- size_t bufPos;
- size_t bufConv;
- size_t bufTotal;
-
- int encodeMode;
-
- UInt32 methodId;
- UInt32 delta;
- UInt32 ip;
- UInt32 x86State;
- Byte deltaState[DELTA_STATE_SIZE];
-
- Byte buf[BRA_BUF_SIZE];
-} CBraState;
-
-static void BraState_Free(void *pp, ISzAllocPtr alloc)
-{
- ISzAlloc_Free(alloc, pp);
-}
-
-static SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
-{
- CBraState *p = ((CBraState *)pp);
- UNUSED_VAR(alloc);
- p->ip = 0;
- if (p->methodId == XZ_ID_Delta)
- {
- if (propSize != 1)
- return SZ_ERROR_UNSUPPORTED;
- p->delta = (unsigned)props[0] + 1;
- }
- else
- {
- if (propSize == 4)
- {
- UInt32 v = GetUi32(props);
- switch (p->methodId)
- {
- case XZ_ID_PPC:
- case XZ_ID_ARM:
- case XZ_ID_SPARC:
- if ((v & 3) != 0)
- return SZ_ERROR_UNSUPPORTED;
- break;
- case XZ_ID_ARMT:
- if ((v & 1) != 0)
- return SZ_ERROR_UNSUPPORTED;
- break;
- case XZ_ID_IA64:
- if ((v & 0xF) != 0)
- return SZ_ERROR_UNSUPPORTED;
- break;
- }
- p->ip = v;
- }
- else if (propSize != 0)
- return SZ_ERROR_UNSUPPORTED;
- }
- return SZ_OK;
-}
-
-static void BraState_Init(void *pp)
-{
- CBraState *p = ((CBraState *)pp);
- p->bufPos = p->bufConv = p->bufTotal = 0;
- x86_Convert_Init(p->x86State);
- if (p->methodId == XZ_ID_Delta)
- Delta_Init(p->deltaState);
-}
-
-
-#define CASE_BRA_CONV(isa) case XZ_ID_ ## isa: size = isa ## _Convert(data, size, p->ip, p->encodeMode); break;
-
-static SizeT BraState_Filter(void *pp, Byte *data, SizeT size)
-{
- CBraState *p = ((CBraState *)pp);
- switch (p->methodId)
- {
- case XZ_ID_Delta:
- if (p->encodeMode)
- Delta_Encode(p->deltaState, p->delta, data, size);
- else
- Delta_Decode(p->deltaState, p->delta, data, size);
- break;
- case XZ_ID_X86:
- size = x86_Convert(data, size, p->ip, &p->x86State, p->encodeMode);
- break;
- CASE_BRA_CONV(PPC)
- CASE_BRA_CONV(IA64)
- CASE_BRA_CONV(ARM)
- CASE_BRA_CONV(ARMT)
- CASE_BRA_CONV(SPARC)
- }
- p->ip += (UInt32)size;
- return size;
-}
-
-
-static SRes BraState_Code2(void *pp,
- Byte *dest, SizeT *destLen,
- const Byte *src, SizeT *srcLen, int srcWasFinished,
- ECoderFinishMode finishMode,
- // int *wasFinished
- ECoderStatus *status)
-{
- CBraState *p = ((CBraState *)pp);
- SizeT destRem = *destLen;
- SizeT srcRem = *srcLen;
- UNUSED_VAR(finishMode);
-
- *destLen = 0;
- *srcLen = 0;
- // *wasFinished = False;
- *status = CODER_STATUS_NOT_FINISHED;
-
- while (destRem > 0)
- {
- if (p->bufPos != p->bufConv)
- {
- size_t size = p->bufConv - p->bufPos;
- if (size > destRem)
- size = destRem;
- memcpy(dest, p->buf + p->bufPos, size);
- p->bufPos += size;
- *destLen += size;
- dest += size;
- destRem -= size;
- continue;
- }
-
- p->bufTotal -= p->bufPos;
- memmove(p->buf, p->buf + p->bufPos, p->bufTotal);
- p->bufPos = 0;
- p->bufConv = 0;
- {
- size_t size = BRA_BUF_SIZE - p->bufTotal;
- if (size > srcRem)
- size = srcRem;
- memcpy(p->buf + p->bufTotal, src, size);
- *srcLen += size;
- src += size;
- srcRem -= size;
- p->bufTotal += size;
- }
- if (p->bufTotal == 0)
- break;
-
- p->bufConv = BraState_Filter(pp, p->buf, p->bufTotal);
-
- if (p->bufConv == 0)
- {
- if (!srcWasFinished)
- break;
- p->bufConv = p->bufTotal;
- }
- }
-
- if (p->bufTotal == p->bufPos && srcRem == 0 && srcWasFinished)
- {
- *status = CODER_STATUS_FINISHED_WITH_MARK;
- // *wasFinished = 1;
- }
-
- return SZ_OK;
-}
-
-
-SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAllocPtr alloc)
-{
- CBraState *decoder;
- if (id < XZ_ID_Delta || id > XZ_ID_SPARC)
- return SZ_ERROR_UNSUPPORTED;
- decoder = (CBraState *)p->p;
- if (!decoder)
- {
- decoder = (CBraState *)ISzAlloc_Alloc(alloc, sizeof(CBraState));
- if (!decoder)
- return SZ_ERROR_MEM;
- p->p = decoder;
- p->Free = BraState_Free;
- p->SetProps = BraState_SetProps;
- p->Init = BraState_Init;
- p->Code2 = BraState_Code2;
- p->Filter = BraState_Filter;
- }
- decoder->methodId = (UInt32)id;
- decoder->encodeMode = encodeMode;
- return SZ_OK;
-}
-
-
-
-/* ---------- SbState ---------- */
-
-#ifdef USE_SUBBLOCK
-
-static void SbState_Free(void *pp, ISzAllocPtr alloc)
-{
- CSbDec *p = (CSbDec *)pp;
- SbDec_Free(p);
- ISzAlloc_Free(alloc, pp);
-}
-
-static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
-{
- UNUSED_VAR(pp);
- UNUSED_VAR(props);
- UNUSED_VAR(alloc);
- return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
-}
-
-static void SbState_Init(void *pp)
-{
- SbDec_Init((CSbDec *)pp);
-}
-
-static SRes SbState_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
- int srcWasFinished, ECoderFinishMode finishMode,
- // int *wasFinished
- ECoderStatus *status)
-{
- CSbDec *p = (CSbDec *)pp;
- SRes res;
- UNUSED_VAR(srcWasFinished);
- p->dest = dest;
- p->destLen = *destLen;
- p->src = src;
- p->srcLen = *srcLen;
- p->finish = finishMode; /* change it */
- res = SbDec_Decode((CSbDec *)pp);
- *destLen -= p->destLen;
- *srcLen -= p->srcLen;
- // *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */
- *status = (*destLen == 0 && *srcLen == 0) ?
- CODER_STATUS_FINISHED_WITH_MARK :
- CODER_STATUS_NOT_FINISHED;
- return res;
-}
-
-static SRes SbState_SetFromMethod(IStateCoder *p, ISzAllocPtr alloc)
-{
- CSbDec *decoder = (CSbDec *)p->p;
- if (!decoder)
- {
- decoder = (CSbDec *)ISzAlloc_Alloc(alloc, sizeof(CSbDec));
- if (!decoder)
- return SZ_ERROR_MEM;
- p->p = decoder;
- p->Free = SbState_Free;
- p->SetProps = SbState_SetProps;
- p->Init = SbState_Init;
- p->Code2 = SbState_Code2;
- p->Filter = NULL;
- }
- SbDec_Construct(decoder);
- SbDec_SetAlloc(decoder, alloc);
- return SZ_OK;
-}
-
-#endif
-
-
-
-/* ---------- Lzma2 ---------- */
-
-typedef struct
-{
- CLzma2Dec decoder;
- BoolInt outBufMode;
-} CLzma2Dec_Spec;
-
-
-static void Lzma2State_Free(void *pp, ISzAllocPtr alloc)
-{
- CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
- if (p->outBufMode)
- Lzma2Dec_FreeProbs(&p->decoder, alloc);
- else
- Lzma2Dec_Free(&p->decoder, alloc);
- ISzAlloc_Free(alloc, pp);
-}
-
-static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
-{
- if (propSize != 1)
- return SZ_ERROR_UNSUPPORTED;
- {
- CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
- if (p->outBufMode)
- return Lzma2Dec_AllocateProbs(&p->decoder, props[0], alloc);
- else
- return Lzma2Dec_Allocate(&p->decoder, props[0], alloc);
- }
-}
-
-static void Lzma2State_Init(void *pp)
-{
- Lzma2Dec_Init(&((CLzma2Dec_Spec *)pp)->decoder);
-}
-
-
-/*
- if (outBufMode), then (dest) is not used. Use NULL.
- Data is unpacked to (spec->decoder.decoder.dic) output buffer.
-*/
-
-static SRes Lzma2State_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
- int srcWasFinished, ECoderFinishMode finishMode,
- // int *wasFinished,
- ECoderStatus *status)
-{
- CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)pp;
- ELzmaStatus status2;
- /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */
- SRes res;
- UNUSED_VAR(srcWasFinished);
- if (spec->outBufMode)
- {
- SizeT dicPos = spec->decoder.decoder.dicPos;
- SizeT dicLimit = dicPos + *destLen;
- res = Lzma2Dec_DecodeToDic(&spec->decoder, dicLimit, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
- *destLen = spec->decoder.decoder.dicPos - dicPos;
- }
- else
- res = Lzma2Dec_DecodeToBuf(&spec->decoder, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
- // *wasFinished = (status2 == LZMA_STATUS_FINISHED_WITH_MARK);
- // ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder
- *status = (ECoderStatus)status2;
- return res;
-}
-
-
-static SRes Lzma2State_SetFromMethod(IStateCoder *p, Byte *outBuf, size_t outBufSize, ISzAllocPtr alloc)
-{
- CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
- if (!spec)
- {
- spec = (CLzma2Dec_Spec *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Dec_Spec));
- if (!spec)
- return SZ_ERROR_MEM;
- p->p = spec;
- p->Free = Lzma2State_Free;
- p->SetProps = Lzma2State_SetProps;
- p->Init = Lzma2State_Init;
- p->Code2 = Lzma2State_Code2;
- p->Filter = NULL;
- Lzma2Dec_Construct(&spec->decoder);
- }
- spec->outBufMode = False;
- if (outBuf)
- {
- spec->outBufMode = True;
- spec->decoder.decoder.dic = outBuf;
- spec->decoder.decoder.dicBufSize = outBufSize;
- }
- return SZ_OK;
-}
-
-
-static SRes Lzma2State_ResetOutBuf(IStateCoder *p, Byte *outBuf, size_t outBufSize)
-{
- CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
- if ((spec->outBufMode && !outBuf) || (!spec->outBufMode && outBuf))
- return SZ_ERROR_FAIL;
- if (outBuf)
- {
- spec->decoder.decoder.dic = outBuf;
- spec->decoder.decoder.dicBufSize = outBufSize;
- }
- return SZ_OK;
-}
-
-
-
-static void MixCoder_Construct(CMixCoder *p, ISzAllocPtr alloc)
-{
- unsigned i;
- p->alloc = alloc;
- p->buf = NULL;
- p->numCoders = 0;
-
- p->outBufSize = 0;
- p->outBuf = NULL;
- // p->SingleBufMode = False;
-
- for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
- p->coders[i].p = NULL;
-}
-
-
-static void MixCoder_Free(CMixCoder *p)
-{
- unsigned i;
- p->numCoders = 0;
- for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
- {
- IStateCoder *sc = &p->coders[i];
- if (sc->p)
- {
- sc->Free(sc->p, p->alloc);
- sc->p = NULL;
- }
- }
- if (p->buf)
- {
- ISzAlloc_Free(p->alloc, p->buf);
- p->buf = NULL; /* 9.31: the BUG was fixed */
- }
-}
-
-static void MixCoder_Init(CMixCoder *p)
-{
- unsigned i;
- for (i = 0; i < MIXCODER_NUM_FILTERS_MAX - 1; i++)
- {
- p->size[i] = 0;
- p->pos[i] = 0;
- p->finished[i] = 0;
- }
- for (i = 0; i < p->numCoders; i++)
- {
- IStateCoder *coder = &p->coders[i];
- coder->Init(coder->p);
- p->results[i] = SZ_OK;
- }
- p->outWritten = 0;
- p->wasFinished = False;
- p->res = SZ_OK;
- p->status = CODER_STATUS_NOT_SPECIFIED;
-}
-
-
-static SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
-{
- IStateCoder *sc = &p->coders[coderIndex];
- p->ids[coderIndex] = methodId;
- switch (methodId)
- {
- case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, outBuf, outBufSize, p->alloc);
- #ifdef USE_SUBBLOCK
- case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);
- #endif
- }
- if (coderIndex == 0)
- return SZ_ERROR_UNSUPPORTED;
- return BraState_SetFromMethod(sc, methodId, 0, p->alloc);
-}
-
-
-static SRes MixCoder_ResetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
-{
- IStateCoder *sc = &p->coders[coderIndex];
- switch (methodId)
- {
- case XZ_ID_LZMA2: return Lzma2State_ResetOutBuf(sc, outBuf, outBufSize);
- }
- return SZ_ERROR_UNSUPPORTED;
-}
-
-
-
-/*
- if (destFinish) - then unpack data block is finished at (*destLen) position,
- and we can return data that were not processed by filter
-
-output (status) can be :
- CODER_STATUS_NOT_FINISHED
- CODER_STATUS_FINISHED_WITH_MARK
- CODER_STATUS_NEEDS_MORE_INPUT - not implemented still
-*/
-
-static SRes MixCoder_Code(CMixCoder *p,
- Byte *dest, SizeT *destLen, int destFinish,
- const Byte *src, SizeT *srcLen, int srcWasFinished,
- ECoderFinishMode finishMode)
-{
- SizeT destLenOrig = *destLen;
- SizeT srcLenOrig = *srcLen;
-
- *destLen = 0;
- *srcLen = 0;
-
- if (p->wasFinished)
- return p->res;
-
- p->status = CODER_STATUS_NOT_FINISHED;
-
- // if (p->SingleBufMode)
- if (p->outBuf)
- {
- SRes res;
- SizeT destLen2, srcLen2;
- int wasFinished;
-
- PRF_STR("------- MixCoder Single ----------");
-
- srcLen2 = srcLenOrig;
- destLen2 = destLenOrig;
-
- {
- IStateCoder *coder = &p->coders[0];
- res = coder->Code2(coder->p, NULL, &destLen2, src, &srcLen2, srcWasFinished, finishMode,
- // &wasFinished,
- &p->status);
- wasFinished = (p->status == CODER_STATUS_FINISHED_WITH_MARK);
- }
-
- p->res = res;
-
- /*
- if (wasFinished)
- p->status = CODER_STATUS_FINISHED_WITH_MARK;
- else
- {
- if (res == SZ_OK)
- if (destLen2 != destLenOrig)
- p->status = CODER_STATUS_NEEDS_MORE_INPUT;
- }
- */
-
-
- *srcLen = srcLen2;
- src += srcLen2;
- p->outWritten += destLen2;
-
- if (res != SZ_OK || srcWasFinished || wasFinished)
- p->wasFinished = True;
-
- if (p->numCoders == 1)
- *destLen = destLen2;
- else if (p->wasFinished)
- {
- unsigned i;
- size_t processed = p->outWritten;
-
- for (i = 1; i < p->numCoders; i++)
- {
- IStateCoder *coder = &p->coders[i];
- processed = coder->Filter(coder->p, p->outBuf, processed);
- if (wasFinished || (destFinish && p->outWritten == destLenOrig))
- processed = p->outWritten;
- PRF_STR_INT("filter", i);
- }
- *destLen = processed;
- }
- return res;
- }
-
- PRF_STR("standard mix");
-
- if (p->numCoders != 1)
- {
- if (!p->buf)
- {
- p->buf = (Byte *)ISzAlloc_Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));
- if (!p->buf)
- return SZ_ERROR_MEM;
- }
-
- finishMode = CODER_FINISH_ANY;
- }
-
- for (;;)
- {
- BoolInt processed = False;
- BoolInt allFinished = True;
- SRes resMain = SZ_OK;
- unsigned i;
-
- p->status = CODER_STATUS_NOT_FINISHED;
- /*
- if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)
- break;
- */
-
- for (i = 0; i < p->numCoders; i++)
- {
- SRes res;
- IStateCoder *coder = &p->coders[i];
- Byte *dest2;
- SizeT destLen2, srcLen2; // destLen2_Orig;
- const Byte *src2;
- int srcFinished2;
- int encodingWasFinished;
- ECoderStatus status2;
-
- if (i == 0)
- {
- src2 = src;
- srcLen2 = srcLenOrig - *srcLen;
- srcFinished2 = srcWasFinished;
- }
- else
- {
- size_t k = i - 1;
- src2 = p->buf + (CODER_BUF_SIZE * k) + p->pos[k];
- srcLen2 = p->size[k] - p->pos[k];
- srcFinished2 = p->finished[k];
- }
-
- if (i == p->numCoders - 1)
- {
- dest2 = dest;
- destLen2 = destLenOrig - *destLen;
- }
- else
- {
- if (p->pos[i] != p->size[i])
- continue;
- dest2 = p->buf + (CODER_BUF_SIZE * i);
- destLen2 = CODER_BUF_SIZE;
- }
-
- // destLen2_Orig = destLen2;
-
- if (p->results[i] != SZ_OK)
- {
- if (resMain == SZ_OK)
- resMain = p->results[i];
- continue;
- }
-
- res = coder->Code2(coder->p,
- dest2, &destLen2,
- src2, &srcLen2, srcFinished2,
- finishMode,
- // &encodingWasFinished,
- &status2);
-
- if (res != SZ_OK)
- {
- p->results[i] = res;
- if (resMain == SZ_OK)
- resMain = res;
- }
-
- encodingWasFinished = (status2 == CODER_STATUS_FINISHED_WITH_MARK);
-
- if (!encodingWasFinished)
- {
- allFinished = False;
- if (p->numCoders == 1 && res == SZ_OK)
- p->status = status2;
- }
-
- if (i == 0)
- {
- *srcLen += srcLen2;
- src += srcLen2;
- }
- else
- p->pos[(size_t)i - 1] += srcLen2;
-
- if (i == p->numCoders - 1)
- {
- *destLen += destLen2;
- dest += destLen2;
- }
- else
- {
- p->size[i] = destLen2;
- p->pos[i] = 0;
- p->finished[i] = encodingWasFinished;
- }
-
- if (destLen2 != 0 || srcLen2 != 0)
- processed = True;
- }
-
- if (!processed)
- {
- if (allFinished)
- p->status = CODER_STATUS_FINISHED_WITH_MARK;
- return resMain;
- }
- }
-}
-
-
-SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
-{
- *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);
- if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=
- GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))
- return SZ_ERROR_NO_ARCHIVE;
- return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
-}
-
-static BoolInt Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
-{
- return indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2)
- && GetUi32(buf) == CrcCalc(buf + 4, 6)
- && flags == GetBe16(buf + 8)
- && buf[10] == XZ_FOOTER_SIG_0
- && buf[11] == XZ_FOOTER_SIG_1;
-}
-
-#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
- { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
- if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
-
-
-static BoolInt XzBlock_AreSupportedFilters(const CXzBlock *p)
-{
- unsigned numFilters = XzBlock_GetNumFilters(p) - 1;
- unsigned i;
- {
- const CXzFilter *f = &p->filters[numFilters];
- if (f->id != XZ_ID_LZMA2 || f->propsSize != 1 || f->props[0] > 40)
- return False;
- }
-
- for (i = 0; i < numFilters; i++)
- {
- const CXzFilter *f = &p->filters[i];
- if (f->id == XZ_ID_Delta)
- {
- if (f->propsSize != 1)
- return False;
- }
- else if (f->id < XZ_ID_Delta
- || f->id > XZ_ID_SPARC
- || (f->propsSize != 0 && f->propsSize != 4))
- return False;
- }
- return True;
-}
-
-
-SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
-{
- unsigned pos;
- unsigned numFilters, i;
- unsigned headerSize = (unsigned)header[0] << 2;
-
- /* (headerSize != 0) : another code checks */
-
- if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))
- return SZ_ERROR_ARCHIVE;
-
- pos = 1;
- p->flags = header[pos++];
-
- p->packSize = (UInt64)(Int64)-1;
- if (XzBlock_HasPackSize(p))
- {
- READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize);
- if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)
- return SZ_ERROR_ARCHIVE;
- }
-
- p->unpackSize = (UInt64)(Int64)-1;
- if (XzBlock_HasUnpackSize(p))
- READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize);
-
- numFilters = XzBlock_GetNumFilters(p);
- for (i = 0; i < numFilters; i++)
- {
- CXzFilter *filter = p->filters + i;
- UInt64 size;
- READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id);
- READ_VARINT_AND_CHECK(header, pos, headerSize, &size);
- if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
- return SZ_ERROR_ARCHIVE;
- filter->propsSize = (UInt32)size;
- memcpy(filter->props, header + pos, (size_t)size);
- pos += (unsigned)size;
-
- #ifdef XZ_DUMP
- printf("\nf[%u] = %2X: ", i, (unsigned)filter->id);
- {
- unsigned i;
- for (i = 0; i < size; i++)
- printf(" %2X", filter->props[i]);
- }
- #endif
- }
-
- if (XzBlock_HasUnsupportedFlags(p))
- return SZ_ERROR_UNSUPPORTED;
-
- while (pos < headerSize)
- if (header[pos++] != 0)
- return SZ_ERROR_ARCHIVE;
- return SZ_OK;
-}
-
-
-
-
-static SRes XzDecMix_Init(CMixCoder *p, const CXzBlock *block, Byte *outBuf, size_t outBufSize)
-{
- unsigned i;
- BoolInt needReInit = True;
- unsigned numFilters = XzBlock_GetNumFilters(block);
-
- if (numFilters == p->numCoders && ((p->outBuf && outBuf) || (!p->outBuf && !outBuf)))
- {
- needReInit = False;
- for (i = 0; i < numFilters; i++)
- if (p->ids[i] != block->filters[numFilters - 1 - i].id)
- {
- needReInit = True;
- break;
- }
- }
-
- // p->SingleBufMode = (outBuf != NULL);
- p->outBuf = outBuf;
- p->outBufSize = outBufSize;
-
- // p->SingleBufMode = False;
- // outBuf = NULL;
-
- if (needReInit)
- {
- MixCoder_Free(p);
- for (i = 0; i < numFilters; i++)
- {
- RINOK(MixCoder_SetFromMethod(p, i, block->filters[numFilters - 1 - i].id, outBuf, outBufSize));
- }
- p->numCoders = numFilters;
- }
- else
- {
- RINOK(MixCoder_ResetFromMethod(p, 0, block->filters[numFilters - 1].id, outBuf, outBufSize));
- }
-
- for (i = 0; i < numFilters; i++)
- {
- const CXzFilter *f = &block->filters[numFilters - 1 - i];
- IStateCoder *sc = &p->coders[i];
- RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc));
- }
-
- MixCoder_Init(p);
- return SZ_OK;
-}
-
-
-
-void XzUnpacker_Init(CXzUnpacker *p)
-{
- p->state = XZ_STATE_STREAM_HEADER;
- p->pos = 0;
- p->numStartedStreams = 0;
- p->numFinishedStreams = 0;
- p->numTotalBlocks = 0;
- p->padSize = 0;
- p->decodeOnlyOneBlock = 0;
-
- p->parseMode = False;
- p->decodeToStreamSignature = False;
-
- // p->outBuf = NULL;
- // p->outBufSize = 0;
- p->outDataWritten = 0;
-}
-
-
-void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize)
-{
- p->outBuf = outBuf;
- p->outBufSize = outBufSize;
-}
-
-
-void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc)
-{
- MixCoder_Construct(&p->decoder, alloc);
- p->outBuf = NULL;
- p->outBufSize = 0;
- XzUnpacker_Init(p);
-}
-
-
-void XzUnpacker_Free(CXzUnpacker *p)
-{
- MixCoder_Free(&p->decoder);
-}
-
-
-void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p)
-{
- p->indexSize = 0;
- p->numBlocks = 0;
- Sha256_Init(&p->sha);
- p->state = XZ_STATE_BLOCK_HEADER;
- p->pos = 0;
- p->decodeOnlyOneBlock = 1;
-}
-
-
-static void XzUnpacker_UpdateIndex(CXzUnpacker *p, UInt64 packSize, UInt64 unpackSize)
-{
- Byte temp[32];
- unsigned num = Xz_WriteVarInt(temp, packSize);
- num += Xz_WriteVarInt(temp + num, unpackSize);
- Sha256_Update(&p->sha, temp, num);
- p->indexSize += num;
- p->numBlocks++;
-}
-
-
-
-SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
- const Byte *src, SizeT *srcLen, int srcFinished,
- ECoderFinishMode finishMode, ECoderStatus *status)
-{
- SizeT destLenOrig = *destLen;
- SizeT srcLenOrig = *srcLen;
- *destLen = 0;
- *srcLen = 0;
- *status = CODER_STATUS_NOT_SPECIFIED;
-
- for (;;)
- {
- SizeT srcRem;
-
- if (p->state == XZ_STATE_BLOCK)
- {
- SizeT destLen2 = destLenOrig - *destLen;
- SizeT srcLen2 = srcLenOrig - *srcLen;
- SRes res;
-
- ECoderFinishMode finishMode2 = finishMode;
- BoolInt srcFinished2 = srcFinished;
- BoolInt destFinish = False;
-
- if (p->block.packSize != (UInt64)(Int64)-1)
- {
- UInt64 rem = p->block.packSize - p->packSize;
- if (srcLen2 >= rem)
- {
- srcFinished2 = True;
- srcLen2 = (SizeT)rem;
- }
- if (rem == 0 && p->block.unpackSize == p->unpackSize)
- return SZ_ERROR_DATA;
- }
-
- if (p->block.unpackSize != (UInt64)(Int64)-1)
- {
- UInt64 rem = p->block.unpackSize - p->unpackSize;
- if (destLen2 >= rem)
- {
- destFinish = True;
- finishMode2 = CODER_FINISH_END;
- destLen2 = (SizeT)rem;
- }
- }
-
- /*
- if (srcLen2 == 0 && destLen2 == 0)
- {
- *status = CODER_STATUS_NOT_FINISHED;
- return SZ_OK;
- }
- */
-
- {
- res = MixCoder_Code(&p->decoder,
- (p->outBuf ? NULL : dest), &destLen2, destFinish,
- src, &srcLen2, srcFinished2,
- finishMode2);
-
- *status = p->decoder.status;
- XzCheck_Update(&p->check, (p->outBuf ? p->outBuf + p->outDataWritten : dest), destLen2);
- if (!p->outBuf)
- dest += destLen2;
- p->outDataWritten += destLen2;
- }
-
- (*srcLen) += srcLen2;
- src += srcLen2;
- p->packSize += srcLen2;
- (*destLen) += destLen2;
- p->unpackSize += destLen2;
-
- RINOK(res);
-
- if (*status != CODER_STATUS_FINISHED_WITH_MARK)
- {
- if (p->block.packSize == p->packSize
- && *status == CODER_STATUS_NEEDS_MORE_INPUT)
- {
- PRF_STR("CODER_STATUS_NEEDS_MORE_INPUT");
- *status = CODER_STATUS_NOT_SPECIFIED;
- return SZ_ERROR_DATA;
- }
-
- return SZ_OK;
- }
- {
- XzUnpacker_UpdateIndex(p, XzUnpacker_GetPackSizeForIndex(p), p->unpackSize);
- p->state = XZ_STATE_BLOCK_FOOTER;
- p->pos = 0;
- p->alignPos = 0;
- *status = CODER_STATUS_NOT_SPECIFIED;
-
- if ((p->block.packSize != (UInt64)(Int64)-1 && p->block.packSize != p->packSize)
- || (p->block.unpackSize != (UInt64)(Int64)-1 && p->block.unpackSize != p->unpackSize))
- {
- PRF_STR("ERROR: block.size mismatch");
- return SZ_ERROR_DATA;
- }
- }
- // continue;
- }
-
- srcRem = srcLenOrig - *srcLen;
-
- // XZ_STATE_BLOCK_FOOTER can transit to XZ_STATE_BLOCK_HEADER without input bytes
- if (srcRem == 0 && p->state != XZ_STATE_BLOCK_FOOTER)
- {
- *status = CODER_STATUS_NEEDS_MORE_INPUT;
- return SZ_OK;
- }
-
- switch (p->state)
- {
- case XZ_STATE_STREAM_HEADER:
- {
- if (p->pos < XZ_STREAM_HEADER_SIZE)
- {
- if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])
- return SZ_ERROR_NO_ARCHIVE;
- if (p->decodeToStreamSignature)
- return SZ_OK;
- p->buf[p->pos++] = *src++;
- (*srcLen)++;
- }
- else
- {
- RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));
- p->numStartedStreams++;
- p->indexSize = 0;
- p->numBlocks = 0;
- Sha256_Init(&p->sha);
- p->state = XZ_STATE_BLOCK_HEADER;
- p->pos = 0;
- }
- break;
- }
-
- case XZ_STATE_BLOCK_HEADER:
- {
- if (p->pos == 0)
- {
- p->buf[p->pos++] = *src++;
- (*srcLen)++;
- if (p->buf[0] == 0)
- {
- if (p->decodeOnlyOneBlock)
- return SZ_ERROR_DATA;
- p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
- p->indexPos = p->indexPreSize;
- p->indexSize += p->indexPreSize;
- Sha256_Final(&p->sha, p->shaDigest);
- Sha256_Init(&p->sha);
- p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
- p->state = XZ_STATE_STREAM_INDEX;
- break;
- }
- p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;
- break;
- }
-
- if (p->pos != p->blockHeaderSize)
- {
- UInt32 cur = p->blockHeaderSize - p->pos;
- if (cur > srcRem)
- cur = (UInt32)srcRem;
- memcpy(p->buf + p->pos, src, cur);
- p->pos += cur;
- (*srcLen) += cur;
- src += cur;
- }
- else
- {
- RINOK(XzBlock_Parse(&p->block, p->buf));
- if (!XzBlock_AreSupportedFilters(&p->block))
- return SZ_ERROR_UNSUPPORTED;
- p->numTotalBlocks++;
- p->state = XZ_STATE_BLOCK;
- p->packSize = 0;
- p->unpackSize = 0;
- XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));
- if (p->parseMode)
- {
- p->headerParsedOk = True;
- return SZ_OK;
- }
- RINOK(XzDecMix_Init(&p->decoder, &p->block, p->outBuf, p->outBufSize));
- }
- break;
- }
-
- case XZ_STATE_BLOCK_FOOTER:
- {
- if ((((unsigned)p->packSize + p->alignPos) & 3) != 0)
- {
- if (srcRem == 0)
- {
- *status = CODER_STATUS_NEEDS_MORE_INPUT;
- return SZ_OK;
- }
- (*srcLen)++;
- p->alignPos++;
- if (*src++ != 0)
- return SZ_ERROR_CRC;
- }
- else
- {
- UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
- UInt32 cur = checkSize - p->pos;
- if (cur != 0)
- {
- if (srcRem == 0)
- {
- *status = CODER_STATUS_NEEDS_MORE_INPUT;
- return SZ_OK;
- }
- if (cur > srcRem)
- cur = (UInt32)srcRem;
- memcpy(p->buf + p->pos, src, cur);
- p->pos += cur;
- (*srcLen) += cur;
- src += cur;
- if (checkSize != p->pos)
- break;
- }
- {
- Byte digest[XZ_CHECK_SIZE_MAX];
- p->state = XZ_STATE_BLOCK_HEADER;
- p->pos = 0;
- if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
- return SZ_ERROR_CRC;
- if (p->decodeOnlyOneBlock)
- {
- *status = CODER_STATUS_FINISHED_WITH_MARK;
- return SZ_OK;
- }
- }
- }
- break;
- }
-
- case XZ_STATE_STREAM_INDEX:
- {
- if (p->pos < p->indexPreSize)
- {
- (*srcLen)++;
- if (*src++ != p->buf[p->pos++])
- return SZ_ERROR_CRC;
- }
- else
- {
- if (p->indexPos < p->indexSize)
- {
- UInt64 cur = p->indexSize - p->indexPos;
- if (srcRem > cur)
- srcRem = (SizeT)cur;
- p->crc = CrcUpdate(p->crc, src, srcRem);
- Sha256_Update(&p->sha, src, srcRem);
- (*srcLen) += srcRem;
- src += srcRem;
- p->indexPos += srcRem;
- }
- else if ((p->indexPos & 3) != 0)
- {
- Byte b = *src++;
- p->crc = CRC_UPDATE_BYTE(p->crc, b);
- (*srcLen)++;
- p->indexPos++;
- p->indexSize++;
- if (b != 0)
- return SZ_ERROR_CRC;
- }
- else
- {
- Byte digest[SHA256_DIGEST_SIZE];
- p->state = XZ_STATE_STREAM_INDEX_CRC;
- p->indexSize += 4;
- p->pos = 0;
- Sha256_Final(&p->sha, digest);
- if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
- return SZ_ERROR_CRC;
- }
- }
- break;
- }
-
- case XZ_STATE_STREAM_INDEX_CRC:
- {
- if (p->pos < 4)
- {
- (*srcLen)++;
- p->buf[p->pos++] = *src++;
- }
- else
- {
- p->state = XZ_STATE_STREAM_FOOTER;
- p->pos = 0;
- if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))
- return SZ_ERROR_CRC;
- }
- break;
- }
-
- case XZ_STATE_STREAM_FOOTER:
- {
- UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
- if (cur > srcRem)
- cur = (UInt32)srcRem;
- memcpy(p->buf + p->pos, src, cur);
- p->pos += cur;
- (*srcLen) += cur;
- src += cur;
- if (p->pos == XZ_STREAM_FOOTER_SIZE)
- {
- p->state = XZ_STATE_STREAM_PADDING;
- p->numFinishedStreams++;
- p->padSize = 0;
- if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))
- return SZ_ERROR_CRC;
- }
- break;
- }
-
- case XZ_STATE_STREAM_PADDING:
- {
- if (*src != 0)
- {
- if (((UInt32)p->padSize & 3) != 0)
- return SZ_ERROR_NO_ARCHIVE;
- p->pos = 0;
- p->state = XZ_STATE_STREAM_HEADER;
- }
- else
- {
- (*srcLen)++;
- src++;
- p->padSize++;
- }
- break;
- }
-
- case XZ_STATE_BLOCK: break; /* to disable GCC warning */
- }
- }
- /*
- if (p->state == XZ_STATE_FINISHED)
- *status = CODER_STATUS_FINISHED_WITH_MARK;
- return SZ_OK;
- */
-}
-
-
-SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen,
- const Byte *src, SizeT *srcLen,
- ECoderFinishMode finishMode, ECoderStatus *status)
-{
- XzUnpacker_Init(p);
- XzUnpacker_SetOutBuf(p, dest, *destLen);
-
- return XzUnpacker_Code(p,
- NULL, destLen,
- src, srcLen, True,
- finishMode, status);
-}
-
-
-BoolInt XzUnpacker_IsBlockFinished(const CXzUnpacker *p)
-{
- return (p->state == XZ_STATE_BLOCK_HEADER) && (p->pos == 0);
-}
-
-BoolInt XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p)
-{
- return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);
-}
-
-UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p)
-{
- UInt64 num = 0;
- if (p->state == XZ_STATE_STREAM_PADDING)
- num = p->padSize;
- else if (p->state == XZ_STATE_STREAM_HEADER)
- num = p->padSize + p->pos;
- return num;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#ifndef _7ZIP_ST
-#include "MtDec.h"
-#endif
-
-
-void XzDecMtProps_Init(CXzDecMtProps *p)
-{
- p->inBufSize_ST = 1 << 18;
- p->outStep_ST = 1 << 20;
- p->ignoreErrors = False;
-
- #ifndef _7ZIP_ST
- p->numThreads = 1;
- p->inBufSize_MT = 1 << 18;
- p->memUseMax = sizeof(size_t) << 28;
- #endif
-}
-
-
-
-#ifndef _7ZIP_ST
-
-/* ---------- CXzDecMtThread ---------- */
-
-typedef struct
-{
- Byte *outBuf;
- size_t outBufSize;
- size_t outPreSize;
- size_t inPreSize;
- size_t inPreHeaderSize;
- size_t blockPackSize_for_Index; // including block header and checksum.
- size_t blockPackTotal; // including stream header, block header and checksum.
- size_t inCodeSize;
- size_t outCodeSize;
- ECoderStatus status;
- SRes codeRes;
- BoolInt skipMode;
- // BoolInt finishedWithMark;
- EMtDecParseState parseState;
- BoolInt parsing_Truncated;
- BoolInt atBlockHeader;
- CXzStreamFlags streamFlags;
- // UInt64 numFinishedStreams
- UInt64 numStreams;
- UInt64 numTotalBlocks;
- UInt64 numBlocks;
-
- BoolInt dec_created;
- CXzUnpacker dec;
-
- Byte mtPad[1 << 7];
-} CXzDecMtThread;
-
-#endif
-
-
-/* ---------- CXzDecMt ---------- */
-
-typedef struct
-{
- CAlignOffsetAlloc alignOffsetAlloc;
- ISzAllocPtr allocMid;
-
- CXzDecMtProps props;
- size_t unpackBlockMaxSize;
-
- ISeqInStream *inStream;
- ISeqOutStream *outStream;
- ICompressProgress *progress;
- // CXzStatInfo *stat;
-
- BoolInt finishMode;
- BoolInt outSize_Defined;
- UInt64 outSize;
-
- UInt64 outProcessed;
- UInt64 inProcessed;
- UInt64 readProcessed;
- BoolInt readWasFinished;
- SRes readRes;
- SRes writeRes;
-
- Byte *outBuf;
- size_t outBufSize;
- Byte *inBuf;
- size_t inBufSize;
-
- CXzUnpacker dec;
-
- ECoderStatus status;
- SRes codeRes;
-
- #ifndef _7ZIP_ST
- BoolInt mainDecoderWasCalled;
- // int statErrorDefined;
- int finishedDecoderIndex;
-
- // global values that are used in Parse stage
- CXzStreamFlags streamFlags;
- // UInt64 numFinishedStreams
- UInt64 numStreams;
- UInt64 numTotalBlocks;
- UInt64 numBlocks;
-
- // UInt64 numBadBlocks;
- SRes mainErrorCode;
-
- BoolInt isBlockHeaderState_Parse;
- BoolInt isBlockHeaderState_Write;
- UInt64 outProcessed_Parse;
- BoolInt parsing_Truncated;
-
- BoolInt mtc_WasConstructed;
- CMtDec mtc;
- CXzDecMtThread coders[MTDEC__THREADS_MAX];
- #endif
-
-} CXzDecMt;
-
-
-
-CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
-{
- CXzDecMt *p = (CXzDecMt *)ISzAlloc_Alloc(alloc, sizeof(CXzDecMt));
- if (!p)
- return NULL;
-
- AlignOffsetAlloc_CreateVTable(&p->alignOffsetAlloc);
- p->alignOffsetAlloc.baseAlloc = alloc;
- p->alignOffsetAlloc.numAlignBits = 7;
- p->alignOffsetAlloc.offset = 0;
-
- p->allocMid = allocMid;
-
- p->outBuf = NULL;
- p->outBufSize = 0;
- p->inBuf = NULL;
- p->inBufSize = 0;
-
- XzUnpacker_Construct(&p->dec, &p->alignOffsetAlloc.vt);
-
- p->unpackBlockMaxSize = 0;
-
- XzDecMtProps_Init(&p->props);
-
- #ifndef _7ZIP_ST
- p->mtc_WasConstructed = False;
- {
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CXzDecMtThread *coder = &p->coders[i];
- coder->dec_created = False;
- coder->outBuf = NULL;
- coder->outBufSize = 0;
- }
- }
- #endif
-
- return p;
-}
-
-
-#ifndef _7ZIP_ST
-
-static void XzDecMt_FreeOutBufs(CXzDecMt *p)
-{
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CXzDecMtThread *coder = &p->coders[i];
- if (coder->outBuf)
- {
- ISzAlloc_Free(p->allocMid, coder->outBuf);
- coder->outBuf = NULL;
- coder->outBufSize = 0;
- }
- }
- p->unpackBlockMaxSize = 0;
-}
-
-#endif
-
-
-
-static void XzDecMt_FreeSt(CXzDecMt *p)
-{
- XzUnpacker_Free(&p->dec);
-
- if (p->outBuf)
- {
- ISzAlloc_Free(p->allocMid, p->outBuf);
- p->outBuf = NULL;
- }
- p->outBufSize = 0;
-
- if (p->inBuf)
- {
- ISzAlloc_Free(p->allocMid, p->inBuf);
- p->inBuf = NULL;
- }
- p->inBufSize = 0;
-}
-
-
-void XzDecMt_Destroy(CXzDecMtHandle pp)
-{
- CXzDecMt *p = (CXzDecMt *)pp;
-
- XzDecMt_FreeSt(p);
-
- #ifndef _7ZIP_ST
-
- if (p->mtc_WasConstructed)
- {
- MtDec_Destruct(&p->mtc);
- p->mtc_WasConstructed = False;
- }
- {
- unsigned i;
- for (i = 0; i < MTDEC__THREADS_MAX; i++)
- {
- CXzDecMtThread *t = &p->coders[i];
- if (t->dec_created)
- {
- // we don't need to free dict here
- XzUnpacker_Free(&t->dec);
- t->dec_created = False;
- }
- }
- }
- XzDecMt_FreeOutBufs(p);
-
- #endif
-
- ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, pp);
-}
-
-
-
-#ifndef _7ZIP_ST
-
-static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
-{
- CXzDecMt *me = (CXzDecMt *)obj;
- CXzDecMtThread *coder = &me->coders[coderIndex];
- size_t srcSize = cc->srcSize;
-
- cc->srcSize = 0;
- cc->outPos = 0;
- cc->state = MTDEC_PARSE_CONTINUE;
-
- cc->canCreateNewThread = True;
-
- if (cc->startCall)
- {
- coder->outPreSize = 0;
- coder->inPreSize = 0;
- coder->inPreHeaderSize = 0;
- coder->parseState = MTDEC_PARSE_CONTINUE;
- coder->parsing_Truncated = False;
- coder->skipMode = False;
- coder->codeRes = SZ_OK;
- coder->status = CODER_STATUS_NOT_SPECIFIED;
- coder->inCodeSize = 0;
- coder->outCodeSize = 0;
-
- coder->numStreams = me->numStreams;
- coder->numTotalBlocks = me->numTotalBlocks;
- coder->numBlocks = me->numBlocks;
-
- if (!coder->dec_created)
- {
- XzUnpacker_Construct(&coder->dec, &me->alignOffsetAlloc.vt);
- coder->dec_created = True;
- }
-
- XzUnpacker_Init(&coder->dec);
-
- if (me->isBlockHeaderState_Parse)
- {
- coder->dec.streamFlags = me->streamFlags;
- coder->atBlockHeader = True;
- XzUnpacker_PrepareToRandomBlockDecoding(&coder->dec);
- }
- else
- {
- coder->atBlockHeader = False;
- me->isBlockHeaderState_Parse = True;
- }
-
- coder->dec.numStartedStreams = me->numStreams;
- coder->dec.numTotalBlocks = me->numTotalBlocks;
- coder->dec.numBlocks = me->numBlocks;
- }
-
- while (!coder->skipMode)
- {
- ECoderStatus status;
- SRes res;
- size_t srcSize2 = srcSize;
- size_t destSize = (size_t)0 - 1;
-
- coder->dec.parseMode = True;
- coder->dec.headerParsedOk = False;
-
- PRF_STR_INT("Parse", srcSize2);
-
- res = XzUnpacker_Code(&coder->dec,
- NULL, &destSize,
- cc->src, &srcSize2, cc->srcFinished,
- CODER_FINISH_END, &status);
-
- // PRF(printf(" res = %d, srcSize2 = %d", res, (unsigned)srcSize2));
-
- coder->codeRes = res;
- coder->status = status;
- cc->srcSize += srcSize2;
- srcSize -= srcSize2;
- coder->inPreHeaderSize += srcSize2;
- coder->inPreSize = coder->inPreHeaderSize;
-
- if (res != SZ_OK)
- {
- cc->state =
- coder->parseState = MTDEC_PARSE_END;
- /*
- if (res == SZ_ERROR_MEM)
- return res;
- return SZ_OK;
- */
- return; // res;
- }
-
- if (coder->dec.headerParsedOk)
- {
- const CXzBlock *block = &coder->dec.block;
- if (XzBlock_HasUnpackSize(block)
- // && block->unpackSize <= me->props.outBlockMax
- && XzBlock_HasPackSize(block))
- {
- {
- if (block->unpackSize * 2 * me->mtc.numStartedThreads > me->props.memUseMax)
- {
- cc->state = MTDEC_PARSE_OVERFLOW;
- return; // SZ_OK;
- }
- }
- {
- UInt64 packSize = block->packSize;
- UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
- UInt32 checkSize = XzFlags_GetCheckSize(coder->dec.streamFlags);
- UInt64 blockPackSum = coder->inPreSize + packSizeAligned + checkSize;
- // if (blockPackSum <= me->props.inBlockMax)
- // unpackBlockMaxSize
- {
- coder->blockPackSize_for_Index = (size_t)(coder->dec.blockHeaderSize + packSize + checkSize);
- coder->blockPackTotal = (size_t)blockPackSum;
- coder->outPreSize = (size_t)block->unpackSize;
- coder->streamFlags = coder->dec.streamFlags;
- me->streamFlags = coder->dec.streamFlags;
- coder->skipMode = True;
- break;
- }
- }
- }
- }
- else
- // if (coder->inPreSize <= me->props.inBlockMax)
- {
- if (!cc->srcFinished)
- return; // SZ_OK;
- cc->state =
- coder->parseState = MTDEC_PARSE_END;
- return; // SZ_OK;
- }
- cc->state = MTDEC_PARSE_OVERFLOW;
- return; // SZ_OK;
- }
-
- // ---------- skipMode ----------
- {
- UInt64 rem = coder->blockPackTotal - coder->inPreSize;
- size_t cur = srcSize;
- if (cur > rem)
- cur = (size_t)rem;
- cc->srcSize += cur;
- coder->inPreSize += cur;
- srcSize -= cur;
-
- if (coder->inPreSize == coder->blockPackTotal)
- {
- if (srcSize == 0)
- {
- if (!cc->srcFinished)
- return; // SZ_OK;
- cc->state = MTDEC_PARSE_END;
- }
- else if ((cc->src)[cc->srcSize] == 0) // we check control byte of next block
- cc->state = MTDEC_PARSE_END;
- else
- {
- cc->state = MTDEC_PARSE_NEW;
-
- {
- size_t blockMax = me->unpackBlockMaxSize;
- if (blockMax < coder->outPreSize)
- blockMax = coder->outPreSize;
- {
- UInt64 required = (UInt64)blockMax * (me->mtc.numStartedThreads + 1) * 2;
- if (me->props.memUseMax < required)
- cc->canCreateNewThread = False;
- }
- }
-
- if (me->outSize_Defined)
- {
- // next block can be zero size
- const UInt64 rem2 = me->outSize - me->outProcessed_Parse;
- if (rem2 < coder->outPreSize)
- {
- coder->parsing_Truncated = True;
- cc->state = MTDEC_PARSE_END;
- }
- me->outProcessed_Parse += coder->outPreSize;
- }
- }
- }
- else if (cc->srcFinished)
- cc->state = MTDEC_PARSE_END;
- else
- return; // SZ_OK;
-
- coder->parseState = cc->state;
- cc->outPos = coder->outPreSize;
-
- me->numStreams = coder->dec.numStartedStreams;
- me->numTotalBlocks = coder->dec.numTotalBlocks;
- me->numBlocks = coder->dec.numBlocks + 1;
- return; // SZ_OK;
- }
-}
-
-
-static SRes XzDecMt_Callback_PreCode(void *pp, unsigned coderIndex)
-{
- CXzDecMt *me = (CXzDecMt *)pp;
- CXzDecMtThread *coder = &me->coders[coderIndex];
- Byte *dest;
-
- if (!coder->dec.headerParsedOk)
- return SZ_OK;
-
- dest = coder->outBuf;
-
- if (!dest || coder->outBufSize < coder->outPreSize)
- {
- if (dest)
- {
- ISzAlloc_Free(me->allocMid, dest);
- coder->outBuf = NULL;
- coder->outBufSize = 0;
- }
- {
- size_t outPreSize = coder->outPreSize;
- if (outPreSize == 0)
- outPreSize = 1;
- dest = (Byte *)ISzAlloc_Alloc(me->allocMid, outPreSize);
- }
- if (!dest)
- return SZ_ERROR_MEM;
- coder->outBuf = dest;
- coder->outBufSize = coder->outPreSize;
-
- if (coder->outBufSize > me->unpackBlockMaxSize)
- me->unpackBlockMaxSize = coder->outBufSize;
- }
-
- // return SZ_ERROR_MEM;
-
- XzUnpacker_SetOutBuf(&coder->dec, coder->outBuf, coder->outBufSize);
-
- {
- SRes res = XzDecMix_Init(&coder->dec.decoder, &coder->dec.block, coder->outBuf, coder->outBufSize);
- // res = SZ_ERROR_UNSUPPORTED; // to test
- coder->codeRes = res;
- if (res != SZ_OK)
- {
- // if (res == SZ_ERROR_MEM) return res;
- if (me->props.ignoreErrors && res != SZ_ERROR_MEM)
- return S_OK;
- return res;
- }
- }
-
- return SZ_OK;
-}
-
-
-static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
- const Byte *src, size_t srcSize, int srcFinished,
- // int finished, int blockFinished,
- UInt64 *inCodePos, UInt64 *outCodePos, int *stop)
-{
- CXzDecMt *me = (CXzDecMt *)pp;
- CXzDecMtThread *coder = &me->coders[coderIndex];
-
- *inCodePos = coder->inCodeSize;
- *outCodePos = coder->outCodeSize;
- *stop = True;
-
- if (coder->inCodeSize < coder->inPreHeaderSize)
- {
- UInt64 rem = coder->inPreHeaderSize - coder->inCodeSize;
- size_t step = srcSize;
- if (step > rem)
- step = (size_t)rem;
- src += step;
- srcSize -= step;
- coder->inCodeSize += step;
- if (coder->inCodeSize < coder->inPreHeaderSize)
- {
- *stop = False;
- return SZ_OK;
- }
- }
-
- if (!coder->dec.headerParsedOk)
- return SZ_OK;
- if (!coder->outBuf)
- return SZ_OK;
-
- if (coder->codeRes == SZ_OK)
- {
- ECoderStatus status;
- SRes res;
- size_t srcProcessed = srcSize;
- size_t outSizeCur = coder->outPreSize - coder->dec.outDataWritten;
-
- // PRF(printf("\nCallback_Code: Code %d %d\n", (unsigned)srcSize, (unsigned)outSizeCur));
-
- res = XzUnpacker_Code(&coder->dec,
- NULL, &outSizeCur,
- src, &srcProcessed, srcFinished,
- // coder->finishedWithMark ? CODER_FINISH_END : CODER_FINISH_ANY,
- CODER_FINISH_END,
- &status);
-
- // PRF(printf(" res = %d, srcSize2 = %d, outSizeCur = %d", res, (unsigned)srcProcessed, (unsigned)outSizeCur));
-
- coder->codeRes = res;
- coder->status = status;
- coder->inCodeSize += srcProcessed;
- coder->outCodeSize = coder->dec.outDataWritten;
- *inCodePos = coder->inCodeSize;
- *outCodePos = coder->outCodeSize;
-
- if (res == SZ_OK)
- {
- if (srcProcessed == srcSize)
- *stop = False;
- return SZ_OK;
- }
- }
-
- if (me->props.ignoreErrors && coder->codeRes != SZ_ERROR_MEM)
- {
- *inCodePos = coder->inPreSize;
- *outCodePos = coder->outPreSize;
- return S_OK;
- }
- return coder->codeRes;
-}
-
-
-#define XZDECMT_STREAM_WRITE_STEP (1 << 24)
-
-static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
- BoolInt needWriteToStream,
- const Byte *src, size_t srcSize,
- // int srcFinished,
- BoolInt *needContinue,
- BoolInt *canRecode)
-{
- CXzDecMt *me = (CXzDecMt *)pp;
- const CXzDecMtThread *coder = &me->coders[coderIndex];
-
- // PRF(printf("\nWrite processed = %d srcSize = %d\n", (unsigned)me->mtc.inProcessed, (unsigned)srcSize));
-
- *needContinue = False;
- *canRecode = True;
-
- if (!needWriteToStream)
- return SZ_OK;
-
- if (!coder->dec.headerParsedOk || !coder->outBuf)
- {
- if (me->finishedDecoderIndex < 0)
- me->finishedDecoderIndex = coderIndex;
- return SZ_OK;
- }
-
- if (me->finishedDecoderIndex >= 0)
- return SZ_OK;
-
- me->mtc.inProcessed += coder->inCodeSize;
-
- *canRecode = False;
-
- {
- SRes res;
- size_t size = coder->outCodeSize;
- Byte *data = coder->outBuf;
-
- // we use in me->dec: sha, numBlocks, indexSize
-
- if (!me->isBlockHeaderState_Write)
- {
- XzUnpacker_PrepareToRandomBlockDecoding(&me->dec);
- me->dec.decodeOnlyOneBlock = False;
- me->dec.numStartedStreams = coder->dec.numStartedStreams;
- me->dec.streamFlags = coder->streamFlags;
-
- me->isBlockHeaderState_Write = True;
- }
-
- me->dec.numTotalBlocks = coder->dec.numTotalBlocks;
- XzUnpacker_UpdateIndex(&me->dec, coder->blockPackSize_for_Index, coder->outPreSize);
-
- if (coder->outPreSize != size)
- {
- if (me->props.ignoreErrors)
- {
- memset(data + size, 0, coder->outPreSize - size);
- size = coder->outPreSize;
- }
- // me->numBadBlocks++;
- if (me->mainErrorCode == SZ_OK)
- {
- if ((int)coder->status == LZMA_STATUS_NEEDS_MORE_INPUT)
- me->mainErrorCode = SZ_ERROR_INPUT_EOF;
- else
- me->mainErrorCode = SZ_ERROR_DATA;
- }
- }
-
- if (me->writeRes != SZ_OK)
- return me->writeRes;
-
- res = SZ_OK;
- {
- if (me->outSize_Defined)
- {
- const UInt64 rem = me->outSize - me->outProcessed;
- if (size > rem)
- size = (SizeT)rem;
- }
-
- for (;;)
- {
- size_t cur = size;
- size_t written;
- if (cur > XZDECMT_STREAM_WRITE_STEP)
- cur = XZDECMT_STREAM_WRITE_STEP;
-
- written = ISeqOutStream_Write(me->outStream, data, cur);
-
- // PRF(printf("\nWritten ask = %d written = %d\n", (unsigned)cur, (unsigned)written));
-
- me->outProcessed += written;
- if (written != cur)
- {
- me->writeRes = SZ_ERROR_WRITE;
- res = me->writeRes;
- break;
- }
- data += cur;
- size -= cur;
- // PRF_STR_INT("Written size =", size);
- if (size == 0)
- break;
- res = MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0);
- if (res != SZ_OK)
- break;
- }
- }
-
- if (coder->codeRes != SZ_OK)
- if (!me->props.ignoreErrors)
- {
- me->finishedDecoderIndex = coderIndex;
- return res;
- }
-
- RINOK(res);
-
- if (coder->inPreSize != coder->inCodeSize
- || coder->blockPackTotal != coder->inCodeSize)
- {
- me->finishedDecoderIndex = coderIndex;
- return SZ_OK;
- }
-
- if (coder->parseState != MTDEC_PARSE_END)
- {
- *needContinue = True;
- return SZ_OK;
- }
- }
-
- // (coder->state == MTDEC_PARSE_END) means that there are no other working threads
- // so we can use mtc variables without lock
-
- PRF_STR_INT("Write MTDEC_PARSE_END", me->mtc.inProcessed);
-
- me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
- {
- CXzUnpacker *dec = &me->dec;
-
- PRF_STR_INT("PostSingle", srcSize);
-
- {
- size_t srcProcessed = srcSize;
- ECoderStatus status;
- size_t outSizeCur = 0;
- SRes res;
-
- // dec->decodeOnlyOneBlock = False;
- dec->decodeToStreamSignature = True;
-
- me->mainDecoderWasCalled = True;
-
- if (coder->parsing_Truncated)
- {
- me->parsing_Truncated = True;
- return SZ_OK;
- }
-
- res = XzUnpacker_Code(dec,
- NULL, &outSizeCur,
- src, &srcProcessed,
- me->mtc.readWasFinished, // srcFinished
- CODER_FINISH_END, // CODER_FINISH_ANY,
- &status);
-
- me->status = status;
- me->codeRes = res;
-
- me->mtc.inProcessed += srcProcessed;
- me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
-
- if (res != SZ_OK)
- {
- return S_OK;
- // return res;
- }
-
- if (dec->state == XZ_STATE_STREAM_HEADER)
- {
- *needContinue = True;
- me->isBlockHeaderState_Parse = False;
- me->isBlockHeaderState_Write = False;
- {
- Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
- if (!crossBuf)
- return SZ_ERROR_MEM;
- memcpy(crossBuf, src + srcProcessed, srcSize - srcProcessed);
- }
- me->mtc.crossStart = 0;
- me->mtc.crossEnd = srcSize - srcProcessed;
- return SZ_OK;
- }
-
- if (status != CODER_STATUS_NEEDS_MORE_INPUT)
- {
- return E_FAIL;
- }
-
- if (me->mtc.readWasFinished)
- {
- return SZ_OK;
- }
- }
-
- {
- size_t inPos;
- size_t inLim;
- const Byte *inData;
- UInt64 inProgressPrev = me->mtc.inProcessed;
-
- // XzDecMt_Prepare_InBuf_ST(p);
- Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
- if (!crossBuf)
- return SZ_ERROR_MEM;
-
- inPos = 0;
- inLim = 0;
- // outProcessed = 0;
-
- inData = crossBuf;
-
- for (;;)
- {
- SizeT inProcessed;
- SizeT outProcessed;
- ECoderStatus status;
- SRes res;
-
- if (inPos == inLim)
- {
- if (!me->mtc.readWasFinished)
- {
- inPos = 0;
- inLim = me->mtc.inBufSize;
- me->mtc.readRes = ISeqInStream_Read(me->inStream, (void *)inData, &inLim);
- me->mtc.readProcessed += inLim;
- if (inLim == 0 || me->mtc.readRes != SZ_OK)
- me->mtc.readWasFinished = True;
- }
- }
-
- inProcessed = inLim - inPos;
- outProcessed = 0;
-
- res = XzUnpacker_Code(dec,
- NULL, &outProcessed,
- inData + inPos, &inProcessed,
- (inProcessed == 0), // srcFinished
- CODER_FINISH_END, &status);
-
- me->codeRes = res;
- me->status = status;
- inPos += inProcessed;
- me->mtc.inProcessed += inProcessed;
- me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
-
- if (res != SZ_OK)
- {
- return S_OK;
- // return res;
- }
-
- if (dec->state == XZ_STATE_STREAM_HEADER)
- {
- *needContinue = True;
- me->mtc.crossStart = inPos;
- me->mtc.crossEnd = inLim;
- me->isBlockHeaderState_Parse = False;
- me->isBlockHeaderState_Write = False;
- return SZ_OK;
- }
-
- if (status != CODER_STATUS_NEEDS_MORE_INPUT)
- return E_FAIL;
-
- if (me->mtc.progress)
- {
- UInt64 inDelta = me->mtc.inProcessed - inProgressPrev;
- if (inDelta >= (1 << 22))
- {
- RINOK(MtProgress_Progress_ST(&me->mtc.mtProgress));
- inProgressPrev = me->mtc.inProcessed;
- }
- }
- if (me->mtc.readWasFinished)
- return SZ_OK;
- }
- }
- }
-}
-
-
-#endif
-
-
-
-void XzStatInfo_Clear(CXzStatInfo *p)
-{
- p->InSize = 0;
- p->OutSize = 0;
-
- p->NumStreams = 0;
- p->NumBlocks = 0;
-
- p->UnpackSize_Defined = False;
-
- p->NumStreams_Defined = False;
- p->NumBlocks_Defined = False;
-
- // p->IsArc = False;
- // p->UnexpectedEnd = False;
- // p->Unsupported = False;
- // p->HeadersError = False;
- // p->DataError = False;
- // p->CrcError = False;
-
- p->DataAfterEnd = False;
- p->DecodingTruncated = False;
-
- p->DecodeRes = SZ_OK;
- p->ReadRes = SZ_OK;
- p->ProgressRes = SZ_OK;
-
- p->CombinedRes = SZ_OK;
- p->CombinedRes_Type = SZ_OK;
-}
-
-
-
-
-static SRes XzDecMt_Decode_ST(CXzDecMt *p
- #ifndef _7ZIP_ST
- , BoolInt tMode
- #endif
- , CXzStatInfo *stat)
-{
- size_t outPos;
- size_t inPos, inLim;
- const Byte *inData;
- UInt64 inPrev, outPrev;
-
- CXzUnpacker *dec;
-
- #ifndef _7ZIP_ST
- if (tMode)
- {
- XzDecMt_FreeOutBufs(p);
- tMode = MtDec_PrepareRead(&p->mtc);
- }
- #endif
-
- if (!p->outBuf || p->outBufSize != p->props.outStep_ST)
- {
- ISzAlloc_Free(p->allocMid, p->outBuf);
- p->outBufSize = 0;
- p->outBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.outStep_ST);
- if (!p->outBuf)
- return SZ_ERROR_MEM;
- p->outBufSize = p->props.outStep_ST;
- }
-
- if (!p->inBuf || p->inBufSize != p->props.inBufSize_ST)
- {
- ISzAlloc_Free(p->allocMid, p->inBuf);
- p->inBufSize = 0;
- p->inBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.inBufSize_ST);
- if (!p->inBuf)
- return SZ_ERROR_MEM;
- p->inBufSize = p->props.inBufSize_ST;
- }
-
- dec = &p->dec;
- dec->decodeToStreamSignature = False;
- // dec->decodeOnlyOneBlock = False;
-
- XzUnpacker_SetOutBuf(dec, NULL, 0);
-
- inPrev = p->inProcessed;
- outPrev = p->outProcessed;
-
- inPos = 0;
- inLim = 0;
- inData = NULL;
- outPos = 0;
-
- for (;;)
- {
- SizeT outSize;
- BoolInt finished;
- ECoderFinishMode finishMode;
- SizeT inProcessed;
- ECoderStatus status;
- SRes res;
-
- SizeT outProcessed;
-
-
-
- if (inPos == inLim)
- {
- #ifndef _7ZIP_ST
- if (tMode)
- {
- inData = MtDec_Read(&p->mtc, &inLim);
- inPos = 0;
- if (inData)
- continue;
- tMode = False;
- inLim = 0;
- }
- #endif
-
- if (!p->readWasFinished)
- {
- inPos = 0;
- inLim = p->inBufSize;
- inData = p->inBuf;
- p->readRes = ISeqInStream_Read(p->inStream, (void *)inData, &inLim);
- p->readProcessed += inLim;
- if (inLim == 0 || p->readRes != SZ_OK)
- p->readWasFinished = True;
- }
- }
-
- outSize = p->props.outStep_ST - outPos;
-
- finishMode = CODER_FINISH_ANY;
- if (p->outSize_Defined)
- {
- const UInt64 rem = p->outSize - p->outProcessed;
- if (outSize >= rem)
- {
- outSize = (SizeT)rem;
- if (p->finishMode)
- finishMode = CODER_FINISH_END;
- }
- }
-
- inProcessed = inLim - inPos;
- outProcessed = outSize;
-
- res = XzUnpacker_Code(dec, p->outBuf + outPos, &outProcessed,
- inData + inPos, &inProcessed,
- (inPos == inLim), // srcFinished
- finishMode, &status);
-
- p->codeRes = res;
- p->status = status;
-
- inPos += inProcessed;
- outPos += outProcessed;
- p->inProcessed += inProcessed;
- p->outProcessed += outProcessed;
-
- finished = ((inProcessed == 0 && outProcessed == 0) || res != SZ_OK);
-
- if (finished || outProcessed >= outSize)
- if (outPos != 0)
- {
- size_t written = ISeqOutStream_Write(p->outStream, p->outBuf, outPos);
- p->outProcessed += written;
- if (written != outPos)
- {
- stat->CombinedRes_Type = SZ_ERROR_WRITE;
- return SZ_ERROR_WRITE;
- }
- outPos = 0;
- }
-
- if (p->progress && res == SZ_OK)
- {
- UInt64 inDelta = p->inProcessed - inPrev;
- UInt64 outDelta = p->outProcessed - outPrev;
- if (inDelta >= (1 << 22) || outDelta >= (1 << 22))
- {
- res = ICompressProgress_Progress(p->progress, p->inProcessed, p->outProcessed);
- if (res != SZ_OK)
- {
- stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
- stat->ProgressRes = res;
- return res;
- }
- inPrev = p->inProcessed;
- outPrev = p->outProcessed;
- }
- }
-
- if (finished)
- return res;
- }
-}
-
-static SRes XzStatInfo_SetStat(const CXzUnpacker *dec,
- int finishMode,
- UInt64 readProcessed, UInt64 inProcessed,
- SRes res, ECoderStatus status,
- BoolInt decodingTruncated,
- CXzStatInfo *stat)
-{
- UInt64 extraSize;
-
- stat->DecodingTruncated = (Byte)(decodingTruncated ? 1 : 0);
- stat->InSize = inProcessed;
- stat->NumStreams = dec->numStartedStreams;
- stat->NumBlocks = dec->numTotalBlocks;
-
- stat->UnpackSize_Defined = True;
- stat->NumStreams_Defined = True;
- stat->NumBlocks_Defined = True;
-
- extraSize = XzUnpacker_GetExtraSize(dec);
-
- if (res == SZ_OK)
- {
- if (status == CODER_STATUS_NEEDS_MORE_INPUT)
- {
- // CODER_STATUS_NEEDS_MORE_INPUT is expected status for correct xz streams
- extraSize = 0;
- if (!XzUnpacker_IsStreamWasFinished(dec))
- res = SZ_ERROR_INPUT_EOF;
- }
- else if (!decodingTruncated || finishMode) // (status == CODER_STATUS_NOT_FINISHED)
- res = SZ_ERROR_DATA;
- }
- else if (res == SZ_ERROR_NO_ARCHIVE)
- {
- /*
- SZ_ERROR_NO_ARCHIVE is possible for 2 states:
- XZ_STATE_STREAM_HEADER - if bad signature or bad CRC
- XZ_STATE_STREAM_PADDING - if non-zero padding data
- extraSize / inProcessed don't include "bad" byte
- */
- if (inProcessed != extraSize) // if good streams before error
- if (extraSize != 0 || readProcessed != inProcessed)
- {
- stat->DataAfterEnd = True;
- // there is some good xz stream before. So we set SZ_OK
- res = SZ_OK;
- }
- }
-
- stat->DecodeRes = res;
-
- stat->InSize -= extraSize;
- return res;
-}
-
-
-SRes XzDecMt_Decode(CXzDecMtHandle pp,
- const CXzDecMtProps *props,
- const UInt64 *outDataSize, int finishMode,
- ISeqOutStream *outStream,
- // Byte *outBuf, size_t *outBufSize,
- ISeqInStream *inStream,
- // const Byte *inData, size_t inDataSize,
- CXzStatInfo *stat,
- int *isMT,
- ICompressProgress *progress)
-{
- CXzDecMt *p = (CXzDecMt *)pp;
- #ifndef _7ZIP_ST
- BoolInt tMode;
- #endif
-
- XzStatInfo_Clear(stat);
-
- p->props = *props;
-
- p->inStream = inStream;
- p->outStream = outStream;
- p->progress = progress;
- // p->stat = stat;
-
- p->outSize = 0;
- p->outSize_Defined = False;
- if (outDataSize)
- {
- p->outSize_Defined = True;
- p->outSize = *outDataSize;
- }
-
- p->finishMode = finishMode;
-
- // p->outSize = 457; p->outSize_Defined = True; p->finishMode = False; // for test
-
- p->writeRes = SZ_OK;
- p->outProcessed = 0;
- p->inProcessed = 0;
- p->readProcessed = 0;
- p->readWasFinished = False;
-
- p->codeRes = 0;
- p->status = CODER_STATUS_NOT_SPECIFIED;
-
- XzUnpacker_Init(&p->dec);
-
- *isMT = False;
-
- /*
- p->outBuf = NULL;
- p->outBufSize = 0;
- if (!outStream)
- {
- p->outBuf = outBuf;
- p->outBufSize = *outBufSize;
- *outBufSize = 0;
- }
- */
-
-
- #ifndef _7ZIP_ST
-
- p->isBlockHeaderState_Parse = False;
- p->isBlockHeaderState_Write = False;
- // p->numBadBlocks = 0;
- p->mainErrorCode = SZ_OK;
- p->mainDecoderWasCalled = False;
-
- tMode = False;
-
- if (p->props.numThreads > 1)
- {
- IMtDecCallback vt;
-
- // we just free ST buffers here
- // but we still keep state variables, that was set in XzUnpacker_Init()
- XzDecMt_FreeSt(p);
-
- p->outProcessed_Parse = 0;
- p->parsing_Truncated = False;
-
- p->numStreams = 0;
- p->numTotalBlocks = 0;
- p->numBlocks = 0;
- p->finishedDecoderIndex = -1;
-
- if (!p->mtc_WasConstructed)
- {
- p->mtc_WasConstructed = True;
- MtDec_Construct(&p->mtc);
- }
-
- p->mtc.mtCallback = &vt;
- p->mtc.mtCallbackObject = p;
-
- p->mtc.progress = progress;
- p->mtc.inStream = inStream;
- p->mtc.alloc = &p->alignOffsetAlloc.vt;
- // p->mtc.inData = inData;
- // p->mtc.inDataSize = inDataSize;
- p->mtc.inBufSize = p->props.inBufSize_MT;
- // p->mtc.inBlockMax = p->props.inBlockMax;
- p->mtc.numThreadsMax = p->props.numThreads;
-
- *isMT = True;
-
- vt.Parse = XzDecMt_Callback_Parse;
- vt.PreCode = XzDecMt_Callback_PreCode;
- vt.Code = XzDecMt_Callback_Code;
- vt.Write = XzDecMt_Callback_Write;
-
- {
- BoolInt needContinue;
-
- SRes res = MtDec_Code(&p->mtc);
-
- stat->InSize = p->mtc.inProcessed;
-
- p->inProcessed = p->mtc.inProcessed;
- p->readRes = p->mtc.readRes;
- p->readWasFinished = p->mtc.readWasFinished;
- p->readProcessed = p->mtc.readProcessed;
-
- tMode = True;
- needContinue = False;
-
- if (res == SZ_OK)
- {
- if (p->mtc.mtProgress.res != SZ_OK)
- {
- res = p->mtc.mtProgress.res;
- stat->ProgressRes = res;
- stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
- }
- else
- needContinue = p->mtc.needContinue;
- }
-
- if (!needContinue)
- {
- SRes codeRes;
- BoolInt truncated = False;
- ECoderStatus status;
- CXzUnpacker *dec;
-
- stat->OutSize = p->outProcessed;
-
- if (p->finishedDecoderIndex >= 0)
- {
- CXzDecMtThread *coder = &p->coders[(unsigned)p->finishedDecoderIndex];
- codeRes = coder->codeRes;
- dec = &coder->dec;
- status = coder->status;
- }
- else if (p->mainDecoderWasCalled)
- {
- codeRes = p->codeRes;
- dec = &p->dec;
- status = p->status;
- truncated = p->parsing_Truncated;
- }
- else
- return E_FAIL;
-
- XzStatInfo_SetStat(dec, p->finishMode,
- p->mtc.readProcessed, p->mtc.inProcessed,
- codeRes, status,
- truncated,
- stat);
-
- if (res == SZ_OK)
- {
- if (p->writeRes != SZ_OK)
- {
- res = p->writeRes;
- stat->CombinedRes_Type = SZ_ERROR_WRITE;
- }
- else if (p->mtc.readRes != SZ_OK && p->mtc.inProcessed == p->mtc.readProcessed)
- {
- res = p->mtc.readRes;
- stat->ReadRes = res;
- stat->CombinedRes_Type = SZ_ERROR_READ;
- }
- else if (p->mainErrorCode != SZ_OK)
- {
- res = p->mainErrorCode;
- }
- }
-
- stat->CombinedRes = res;
- if (stat->CombinedRes_Type == SZ_OK)
- stat->CombinedRes_Type = res;
- return res;
- }
-
- PRF_STR("----- decoding ST -----");
- }
- }
-
- #endif
-
-
- *isMT = False;
-
- {
- SRes res = XzDecMt_Decode_ST(p
- #ifndef _7ZIP_ST
- , tMode
- #endif
- , stat
- );
-
- XzStatInfo_SetStat(&p->dec,
- p->finishMode,
- p->readProcessed, p->inProcessed,
- p->codeRes, p->status,
- False, // truncated
- stat);
-
- if (res == SZ_OK)
- {
- /*
- if (p->writeRes != SZ_OK)
- {
- res = p->writeRes;
- stat->CombinedRes_Type = SZ_ERROR_WRITE;
- }
- else
- */
- if (p->readRes != SZ_OK && p->inProcessed == p->readProcessed)
- {
- res = p->readRes;
- stat->ReadRes = res;
- stat->CombinedRes_Type = SZ_ERROR_READ;
- }
- #ifndef _7ZIP_ST
- else if (p->mainErrorCode != SZ_OK)
- res = p->mainErrorCode;
- #endif
- }
-
- stat->CombinedRes = res;
- if (stat->CombinedRes_Type == SZ_OK)
- stat->CombinedRes_Type = res;
- return res;
- }
-}
+/* XzDec.c -- Xz Decode
+2023-04-13 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+// #include <stdio.h>
+
+// #define XZ_DUMP
+
+/* #define XZ_DUMP */
+
+#ifdef XZ_DUMP
+#include <stdio.h>
+#endif
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#define PRF_STR(s) PRF(printf("\n" s "\n"))
+#define PRF_STR_INT(s, d) PRF(printf("\n" s " %d\n", (unsigned)d))
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "7zCrc.h"
+#include "Alloc.h"
+#include "Bra.h"
+#include "CpuArch.h"
+#include "Delta.h"
+#include "Lzma2Dec.h"
+
+// #define USE_SUBBLOCK
+
+#ifdef USE_SUBBLOCK
+#include "Bcj3Dec.c"
+#include "SbDec.h"
+#endif
+
+#include "Xz.h"
+
+#define XZ_CHECK_SIZE_MAX 64
+
+#define CODER_BUF_SIZE ((size_t)1 << 17)
+
+unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
+{
+ unsigned i, limit;
+ *value = 0;
+ limit = (maxSize > 9) ? 9 : (unsigned)maxSize;
+
+ for (i = 0; i < limit;)
+ {
+ Byte b = p[i];
+ *value |= (UInt64)(b & 0x7F) << (7 * i++);
+ if ((b & 0x80) == 0)
+ return (b == 0 && i != 1) ? 0 : i;
+ }
+ return 0;
+}
+
+
+/* ---------- XzBcFilterState ---------- */
+
+#define BRA_BUF_SIZE (1 << 14)
+
+typedef struct
+{
+ size_t bufPos;
+ size_t bufConv;
+ size_t bufTotal;
+ Byte *buf; // must be aligned for 4 bytes
+ Xz_Func_BcFilterStateBase_Filter filter_func;
+ // int encodeMode;
+ CXzBcFilterStateBase base;
+ // Byte buf[BRA_BUF_SIZE];
+} CXzBcFilterState;
+
+
+static void XzBcFilterState_Free(void *pp, ISzAllocPtr alloc)
+{
+ if (pp)
+ {
+ CXzBcFilterState *p = ((CXzBcFilterState *)pp);
+ ISzAlloc_Free(alloc, p->buf);
+ ISzAlloc_Free(alloc, pp);
+ }
+}
+
+
+static SRes XzBcFilterState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
+{
+ CXzBcFilterStateBase *p = &((CXzBcFilterState *)pp)->base;
+ UNUSED_VAR(alloc)
+ p->ip = 0;
+ if (p->methodId == XZ_ID_Delta)
+ {
+ if (propSize != 1)
+ return SZ_ERROR_UNSUPPORTED;
+ p->delta = (unsigned)props[0] + 1;
+ }
+ else
+ {
+ if (propSize == 4)
+ {
+ UInt32 v = GetUi32(props);
+ switch (p->methodId)
+ {
+ case XZ_ID_PPC:
+ case XZ_ID_ARM:
+ case XZ_ID_SPARC:
+ case XZ_ID_ARM64:
+ if ((v & 3) != 0)
+ return SZ_ERROR_UNSUPPORTED;
+ break;
+ case XZ_ID_ARMT:
+ if ((v & 1) != 0)
+ return SZ_ERROR_UNSUPPORTED;
+ break;
+ case XZ_ID_IA64:
+ if ((v & 0xF) != 0)
+ return SZ_ERROR_UNSUPPORTED;
+ break;
+ }
+ p->ip = v;
+ }
+ else if (propSize != 0)
+ return SZ_ERROR_UNSUPPORTED;
+ }
+ return SZ_OK;
+}
+
+
+static void XzBcFilterState_Init(void *pp)
+{
+ CXzBcFilterState *p = ((CXzBcFilterState *)pp);
+ p->bufPos = p->bufConv = p->bufTotal = 0;
+ p->base.X86_State = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
+ if (p->base.methodId == XZ_ID_Delta)
+ Delta_Init(p->base.delta_State);
+}
+
+
+static const z7_Func_BranchConv g_Funcs_BranchConv_RISC_Dec[] =
+{
+ Z7_BRANCH_CONV_DEC(PPC),
+ Z7_BRANCH_CONV_DEC(IA64),
+ Z7_BRANCH_CONV_DEC(ARM),
+ Z7_BRANCH_CONV_DEC(ARMT),
+ Z7_BRANCH_CONV_DEC(SPARC),
+ Z7_BRANCH_CONV_DEC(ARM64)
+};
+
+static SizeT XzBcFilterStateBase_Filter_Dec(CXzBcFilterStateBase *p, Byte *data, SizeT size)
+{
+ switch (p->methodId)
+ {
+ case XZ_ID_Delta:
+ Delta_Decode(p->delta_State, p->delta, data, size);
+ break;
+ case XZ_ID_X86:
+ size = (SizeT)(z7_BranchConvSt_X86_Dec(data, size, p->ip, &p->X86_State) - data);
+ break;
+ default:
+ if (p->methodId >= XZ_ID_PPC)
+ {
+ const UInt32 i = p->methodId - XZ_ID_PPC;
+ if (i < Z7_ARRAY_SIZE(g_Funcs_BranchConv_RISC_Dec))
+ size = (SizeT)(g_Funcs_BranchConv_RISC_Dec[i](data, size, p->ip) - data);
+ }
+ break;
+ }
+ p->ip += (UInt32)size;
+ return size;
+}
+
+
+static SizeT XzBcFilterState_Filter(void *pp, Byte *data, SizeT size)
+{
+ CXzBcFilterState *p = ((CXzBcFilterState *)pp);
+ return p->filter_func(&p->base, data, size);
+}
+
+
+static SRes XzBcFilterState_Code2(void *pp,
+ Byte *dest, SizeT *destLen,
+ const Byte *src, SizeT *srcLen, int srcWasFinished,
+ ECoderFinishMode finishMode,
+ // int *wasFinished
+ ECoderStatus *status)
+{
+ CXzBcFilterState *p = ((CXzBcFilterState *)pp);
+ SizeT destRem = *destLen;
+ SizeT srcRem = *srcLen;
+ UNUSED_VAR(finishMode)
+
+ *destLen = 0;
+ *srcLen = 0;
+ // *wasFinished = False;
+ *status = CODER_STATUS_NOT_FINISHED;
+
+ while (destRem != 0)
+ {
+ {
+ size_t size = p->bufConv - p->bufPos;
+ if (size)
+ {
+ if (size > destRem)
+ size = destRem;
+ memcpy(dest, p->buf + p->bufPos, size);
+ p->bufPos += size;
+ *destLen += size;
+ dest += size;
+ destRem -= size;
+ continue;
+ }
+ }
+
+ p->bufTotal -= p->bufPos;
+ memmove(p->buf, p->buf + p->bufPos, p->bufTotal);
+ p->bufPos = 0;
+ p->bufConv = 0;
+ {
+ size_t size = BRA_BUF_SIZE - p->bufTotal;
+ if (size > srcRem)
+ size = srcRem;
+ memcpy(p->buf + p->bufTotal, src, size);
+ *srcLen += size;
+ src += size;
+ srcRem -= size;
+ p->bufTotal += size;
+ }
+ if (p->bufTotal == 0)
+ break;
+
+ p->bufConv = p->filter_func(&p->base, p->buf, p->bufTotal);
+
+ if (p->bufConv == 0)
+ {
+ if (!srcWasFinished)
+ break;
+ p->bufConv = p->bufTotal;
+ }
+ }
+
+ if (p->bufTotal == p->bufPos && srcRem == 0 && srcWasFinished)
+ {
+ *status = CODER_STATUS_FINISHED_WITH_MARK;
+ // *wasFinished = 1;
+ }
+
+ return SZ_OK;
+}
+
+
+#define XZ_IS_SUPPORTED_FILTER_ID(id) \
+ ((id) >= XZ_ID_Delta && (id) <= XZ_ID_ARM64)
+
+SRes Xz_StateCoder_Bc_SetFromMethod_Func(IStateCoder *p, UInt64 id,
+ Xz_Func_BcFilterStateBase_Filter func, ISzAllocPtr alloc)
+{
+ CXzBcFilterState *decoder;
+ if (!XZ_IS_SUPPORTED_FILTER_ID(id))
+ return SZ_ERROR_UNSUPPORTED;
+ decoder = (CXzBcFilterState *)p->p;
+ if (!decoder)
+ {
+ decoder = (CXzBcFilterState *)ISzAlloc_Alloc(alloc, sizeof(CXzBcFilterState));
+ if (!decoder)
+ return SZ_ERROR_MEM;
+ decoder->buf = ISzAlloc_Alloc(alloc, BRA_BUF_SIZE);
+ if (!decoder->buf)
+ {
+ ISzAlloc_Free(alloc, decoder);
+ return SZ_ERROR_MEM;
+ }
+ p->p = decoder;
+ p->Free = XzBcFilterState_Free;
+ p->SetProps = XzBcFilterState_SetProps;
+ p->Init = XzBcFilterState_Init;
+ p->Code2 = XzBcFilterState_Code2;
+ p->Filter = XzBcFilterState_Filter;
+ decoder->filter_func = func;
+ }
+ decoder->base.methodId = (UInt32)id;
+ // decoder->encodeMode = encodeMode;
+ return SZ_OK;
+}
+
+
+
+/* ---------- SbState ---------- */
+
+#ifdef USE_SUBBLOCK
+
+static void SbState_Free(void *pp, ISzAllocPtr alloc)
+{
+ CSbDec *p = (CSbDec *)pp;
+ SbDec_Free(p);
+ ISzAlloc_Free(alloc, pp);
+}
+
+static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
+{
+ UNUSED_VAR(pp)
+ UNUSED_VAR(props)
+ UNUSED_VAR(alloc)
+ return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
+}
+
+static void SbState_Init(void *pp)
+{
+ SbDec_Init((CSbDec *)pp);
+}
+
+static SRes SbState_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+ int srcWasFinished, ECoderFinishMode finishMode,
+ // int *wasFinished
+ ECoderStatus *status)
+{
+ CSbDec *p = (CSbDec *)pp;
+ SRes res;
+ UNUSED_VAR(srcWasFinished)
+ p->dest = dest;
+ p->destLen = *destLen;
+ p->src = src;
+ p->srcLen = *srcLen;
+ p->finish = finishMode; /* change it */
+ res = SbDec_Decode((CSbDec *)pp);
+ *destLen -= p->destLen;
+ *srcLen -= p->srcLen;
+ // *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */
+ *status = (*destLen == 0 && *srcLen == 0) ?
+ CODER_STATUS_FINISHED_WITH_MARK :
+ CODER_STATUS_NOT_FINISHED;
+ return res;
+}
+
+static SRes SbState_SetFromMethod(IStateCoder *p, ISzAllocPtr alloc)
+{
+ CSbDec *decoder = (CSbDec *)p->p;
+ if (!decoder)
+ {
+ decoder = (CSbDec *)ISzAlloc_Alloc(alloc, sizeof(CSbDec));
+ if (!decoder)
+ return SZ_ERROR_MEM;
+ p->p = decoder;
+ p->Free = SbState_Free;
+ p->SetProps = SbState_SetProps;
+ p->Init = SbState_Init;
+ p->Code2 = SbState_Code2;
+ p->Filter = NULL;
+ }
+ SbDec_Construct(decoder);
+ SbDec_SetAlloc(decoder, alloc);
+ return SZ_OK;
+}
+
+#endif
+
+
+
+/* ---------- Lzma2 ---------- */
+
+typedef struct
+{
+ CLzma2Dec decoder;
+ BoolInt outBufMode;
+} CLzma2Dec_Spec;
+
+
+static void Lzma2State_Free(void *pp, ISzAllocPtr alloc)
+{
+ CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
+ if (p->outBufMode)
+ Lzma2Dec_FreeProbs(&p->decoder, alloc);
+ else
+ Lzma2Dec_Free(&p->decoder, alloc);
+ ISzAlloc_Free(alloc, pp);
+}
+
+static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAllocPtr alloc)
+{
+ if (propSize != 1)
+ return SZ_ERROR_UNSUPPORTED;
+ {
+ CLzma2Dec_Spec *p = (CLzma2Dec_Spec *)pp;
+ if (p->outBufMode)
+ return Lzma2Dec_AllocateProbs(&p->decoder, props[0], alloc);
+ else
+ return Lzma2Dec_Allocate(&p->decoder, props[0], alloc);
+ }
+}
+
+static void Lzma2State_Init(void *pp)
+{
+ Lzma2Dec_Init(&((CLzma2Dec_Spec *)pp)->decoder);
+}
+
+
+/*
+ if (outBufMode), then (dest) is not used. Use NULL.
+ Data is unpacked to (spec->decoder.decoder.dic) output buffer.
+*/
+
+static SRes Lzma2State_Code2(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+ int srcWasFinished, ECoderFinishMode finishMode,
+ // int *wasFinished,
+ ECoderStatus *status)
+{
+ CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)pp;
+ ELzmaStatus status2;
+ /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */
+ SRes res;
+ UNUSED_VAR(srcWasFinished)
+ if (spec->outBufMode)
+ {
+ SizeT dicPos = spec->decoder.decoder.dicPos;
+ SizeT dicLimit = dicPos + *destLen;
+ res = Lzma2Dec_DecodeToDic(&spec->decoder, dicLimit, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
+ *destLen = spec->decoder.decoder.dicPos - dicPos;
+ }
+ else
+ res = Lzma2Dec_DecodeToBuf(&spec->decoder, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status2);
+ // *wasFinished = (status2 == LZMA_STATUS_FINISHED_WITH_MARK);
+ // ECoderStatus values are identical to ELzmaStatus values of LZMA2 decoder
+ *status = (ECoderStatus)status2;
+ return res;
+}
+
+
+static SRes Lzma2State_SetFromMethod(IStateCoder *p, Byte *outBuf, size_t outBufSize, ISzAllocPtr alloc)
+{
+ CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
+ if (!spec)
+ {
+ spec = (CLzma2Dec_Spec *)ISzAlloc_Alloc(alloc, sizeof(CLzma2Dec_Spec));
+ if (!spec)
+ return SZ_ERROR_MEM;
+ p->p = spec;
+ p->Free = Lzma2State_Free;
+ p->SetProps = Lzma2State_SetProps;
+ p->Init = Lzma2State_Init;
+ p->Code2 = Lzma2State_Code2;
+ p->Filter = NULL;
+ Lzma2Dec_CONSTRUCT(&spec->decoder)
+ }
+ spec->outBufMode = False;
+ if (outBuf)
+ {
+ spec->outBufMode = True;
+ spec->decoder.decoder.dic = outBuf;
+ spec->decoder.decoder.dicBufSize = outBufSize;
+ }
+ return SZ_OK;
+}
+
+
+static SRes Lzma2State_ResetOutBuf(IStateCoder *p, Byte *outBuf, size_t outBufSize)
+{
+ CLzma2Dec_Spec *spec = (CLzma2Dec_Spec *)p->p;
+ if ((spec->outBufMode && !outBuf) || (!spec->outBufMode && outBuf))
+ return SZ_ERROR_FAIL;
+ if (outBuf)
+ {
+ spec->decoder.decoder.dic = outBuf;
+ spec->decoder.decoder.dicBufSize = outBufSize;
+ }
+ return SZ_OK;
+}
+
+
+
+static void MixCoder_Construct(CMixCoder *p, ISzAllocPtr alloc)
+{
+ unsigned i;
+ p->alloc = alloc;
+ p->buf = NULL;
+ p->numCoders = 0;
+
+ p->outBufSize = 0;
+ p->outBuf = NULL;
+ // p->SingleBufMode = False;
+
+ for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
+ p->coders[i].p = NULL;
+}
+
+
+static void MixCoder_Free(CMixCoder *p)
+{
+ unsigned i;
+ p->numCoders = 0;
+ for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
+ {
+ IStateCoder *sc = &p->coders[i];
+ if (sc->p)
+ {
+ sc->Free(sc->p, p->alloc);
+ sc->p = NULL;
+ }
+ }
+ if (p->buf)
+ {
+ ISzAlloc_Free(p->alloc, p->buf);
+ p->buf = NULL; /* 9.31: the BUG was fixed */
+ }
+}
+
+static void MixCoder_Init(CMixCoder *p)
+{
+ unsigned i;
+ for (i = 0; i < MIXCODER_NUM_FILTERS_MAX - 1; i++)
+ {
+ p->size[i] = 0;
+ p->pos[i] = 0;
+ p->finished[i] = 0;
+ }
+ for (i = 0; i < p->numCoders; i++)
+ {
+ IStateCoder *coder = &p->coders[i];
+ coder->Init(coder->p);
+ p->results[i] = SZ_OK;
+ }
+ p->outWritten = 0;
+ p->wasFinished = False;
+ p->res = SZ_OK;
+ p->status = CODER_STATUS_NOT_SPECIFIED;
+}
+
+
+static SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
+{
+ IStateCoder *sc = &p->coders[coderIndex];
+ p->ids[coderIndex] = methodId;
+ switch (methodId)
+ {
+ case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, outBuf, outBufSize, p->alloc);
+ #ifdef USE_SUBBLOCK
+ case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);
+ #endif
+ }
+ if (coderIndex == 0)
+ return SZ_ERROR_UNSUPPORTED;
+ return Xz_StateCoder_Bc_SetFromMethod_Func(sc, methodId,
+ XzBcFilterStateBase_Filter_Dec, p->alloc);
+}
+
+
+static SRes MixCoder_ResetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId, Byte *outBuf, size_t outBufSize)
+{
+ IStateCoder *sc = &p->coders[coderIndex];
+ switch (methodId)
+ {
+ case XZ_ID_LZMA2: return Lzma2State_ResetOutBuf(sc, outBuf, outBufSize);
+ }
+ return SZ_ERROR_UNSUPPORTED;
+}
+
+
+
+/*
+ if (destFinish) - then unpack data block is finished at (*destLen) position,
+ and we can return data that were not processed by filter
+
+output (status) can be :
+ CODER_STATUS_NOT_FINISHED
+ CODER_STATUS_FINISHED_WITH_MARK
+ CODER_STATUS_NEEDS_MORE_INPUT - not implemented still
+*/
+
+static SRes MixCoder_Code(CMixCoder *p,
+ Byte *dest, SizeT *destLen, int destFinish,
+ const Byte *src, SizeT *srcLen, int srcWasFinished,
+ ECoderFinishMode finishMode)
+{
+ SizeT destLenOrig = *destLen;
+ SizeT srcLenOrig = *srcLen;
+
+ *destLen = 0;
+ *srcLen = 0;
+
+ if (p->wasFinished)
+ return p->res;
+
+ p->status = CODER_STATUS_NOT_FINISHED;
+
+ // if (p->SingleBufMode)
+ if (p->outBuf)
+ {
+ SRes res;
+ SizeT destLen2, srcLen2;
+ int wasFinished;
+
+ PRF_STR("------- MixCoder Single ----------")
+
+ srcLen2 = srcLenOrig;
+ destLen2 = destLenOrig;
+
+ {
+ IStateCoder *coder = &p->coders[0];
+ res = coder->Code2(coder->p, NULL, &destLen2, src, &srcLen2, srcWasFinished, finishMode,
+ // &wasFinished,
+ &p->status);
+ wasFinished = (p->status == CODER_STATUS_FINISHED_WITH_MARK);
+ }
+
+ p->res = res;
+
+ /*
+ if (wasFinished)
+ p->status = CODER_STATUS_FINISHED_WITH_MARK;
+ else
+ {
+ if (res == SZ_OK)
+ if (destLen2 != destLenOrig)
+ p->status = CODER_STATUS_NEEDS_MORE_INPUT;
+ }
+ */
+
+
+ *srcLen = srcLen2;
+ src += srcLen2;
+ p->outWritten += destLen2;
+
+ if (res != SZ_OK || srcWasFinished || wasFinished)
+ p->wasFinished = True;
+
+ if (p->numCoders == 1)
+ *destLen = destLen2;
+ else if (p->wasFinished)
+ {
+ unsigned i;
+ size_t processed = p->outWritten;
+
+ for (i = 1; i < p->numCoders; i++)
+ {
+ IStateCoder *coder = &p->coders[i];
+ processed = coder->Filter(coder->p, p->outBuf, processed);
+ if (wasFinished || (destFinish && p->outWritten == destLenOrig))
+ processed = p->outWritten;
+ PRF_STR_INT("filter", i)
+ }
+ *destLen = processed;
+ }
+ return res;
+ }
+
+ PRF_STR("standard mix")
+
+ if (p->numCoders != 1)
+ {
+ if (!p->buf)
+ {
+ p->buf = (Byte *)ISzAlloc_Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));
+ if (!p->buf)
+ return SZ_ERROR_MEM;
+ }
+
+ finishMode = CODER_FINISH_ANY;
+ }
+
+ for (;;)
+ {
+ BoolInt processed = False;
+ BoolInt allFinished = True;
+ SRes resMain = SZ_OK;
+ unsigned i;
+
+ p->status = CODER_STATUS_NOT_FINISHED;
+ /*
+ if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)
+ break;
+ */
+
+ for (i = 0; i < p->numCoders; i++)
+ {
+ SRes res;
+ IStateCoder *coder = &p->coders[i];
+ Byte *dest2;
+ SizeT destLen2, srcLen2; // destLen2_Orig;
+ const Byte *src2;
+ int srcFinished2;
+ int encodingWasFinished;
+ ECoderStatus status2;
+
+ if (i == 0)
+ {
+ src2 = src;
+ srcLen2 = srcLenOrig - *srcLen;
+ srcFinished2 = srcWasFinished;
+ }
+ else
+ {
+ size_t k = i - 1;
+ src2 = p->buf + (CODER_BUF_SIZE * k) + p->pos[k];
+ srcLen2 = p->size[k] - p->pos[k];
+ srcFinished2 = p->finished[k];
+ }
+
+ if (i == p->numCoders - 1)
+ {
+ dest2 = dest;
+ destLen2 = destLenOrig - *destLen;
+ }
+ else
+ {
+ if (p->pos[i] != p->size[i])
+ continue;
+ dest2 = p->buf + (CODER_BUF_SIZE * i);
+ destLen2 = CODER_BUF_SIZE;
+ }
+
+ // destLen2_Orig = destLen2;
+
+ if (p->results[i] != SZ_OK)
+ {
+ if (resMain == SZ_OK)
+ resMain = p->results[i];
+ continue;
+ }
+
+ res = coder->Code2(coder->p,
+ dest2, &destLen2,
+ src2, &srcLen2, srcFinished2,
+ finishMode,
+ // &encodingWasFinished,
+ &status2);
+
+ if (res != SZ_OK)
+ {
+ p->results[i] = res;
+ if (resMain == SZ_OK)
+ resMain = res;
+ }
+
+ encodingWasFinished = (status2 == CODER_STATUS_FINISHED_WITH_MARK);
+
+ if (!encodingWasFinished)
+ {
+ allFinished = False;
+ if (p->numCoders == 1 && res == SZ_OK)
+ p->status = status2;
+ }
+
+ if (i == 0)
+ {
+ *srcLen += srcLen2;
+ src += srcLen2;
+ }
+ else
+ p->pos[(size_t)i - 1] += srcLen2;
+
+ if (i == p->numCoders - 1)
+ {
+ *destLen += destLen2;
+ dest += destLen2;
+ }
+ else
+ {
+ p->size[i] = destLen2;
+ p->pos[i] = 0;
+ p->finished[i] = encodingWasFinished;
+ }
+
+ if (destLen2 != 0 || srcLen2 != 0)
+ processed = True;
+ }
+
+ if (!processed)
+ {
+ if (allFinished)
+ p->status = CODER_STATUS_FINISHED_WITH_MARK;
+ return resMain;
+ }
+ }
+}
+
+
+SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
+{
+ *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);
+ if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=
+ GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))
+ return SZ_ERROR_NO_ARCHIVE;
+ return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
+}
+
+static BoolInt Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
+{
+ return indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2)
+ && GetUi32(buf) == CrcCalc(buf + 4, 6)
+ && flags == GetBe16(buf + 8)
+ && buf[10] == XZ_FOOTER_SIG_0
+ && buf[11] == XZ_FOOTER_SIG_1;
+}
+
+#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
+ { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+ if (s == 0) return SZ_ERROR_ARCHIVE; \
+ pos += s; }
+
+
+static BoolInt XzBlock_AreSupportedFilters(const CXzBlock *p)
+{
+ const unsigned numFilters = XzBlock_GetNumFilters(p) - 1;
+ unsigned i;
+ {
+ const CXzFilter *f = &p->filters[numFilters];
+ if (f->id != XZ_ID_LZMA2 || f->propsSize != 1 || f->props[0] > 40)
+ return False;
+ }
+
+ for (i = 0; i < numFilters; i++)
+ {
+ const CXzFilter *f = &p->filters[i];
+ if (f->id == XZ_ID_Delta)
+ {
+ if (f->propsSize != 1)
+ return False;
+ }
+ else if (!XZ_IS_SUPPORTED_FILTER_ID(f->id)
+ || (f->propsSize != 0 && f->propsSize != 4))
+ return False;
+ }
+ return True;
+}
+
+
+SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
+{
+ unsigned pos;
+ unsigned numFilters, i;
+ unsigned headerSize = (unsigned)header[0] << 2;
+
+ /* (headerSize != 0) : another code checks */
+
+ if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))
+ return SZ_ERROR_ARCHIVE;
+
+ pos = 1;
+ p->flags = header[pos++];
+
+ p->packSize = (UInt64)(Int64)-1;
+ if (XzBlock_HasPackSize(p))
+ {
+ READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize)
+ if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)
+ return SZ_ERROR_ARCHIVE;
+ }
+
+ p->unpackSize = (UInt64)(Int64)-1;
+ if (XzBlock_HasUnpackSize(p))
+ {
+ READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize)
+ }
+
+ numFilters = XzBlock_GetNumFilters(p);
+ for (i = 0; i < numFilters; i++)
+ {
+ CXzFilter *filter = p->filters + i;
+ UInt64 size;
+ READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id)
+ READ_VARINT_AND_CHECK(header, pos, headerSize, &size)
+ if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
+ return SZ_ERROR_ARCHIVE;
+ filter->propsSize = (UInt32)size;
+ memcpy(filter->props, header + pos, (size_t)size);
+ pos += (unsigned)size;
+
+ #ifdef XZ_DUMP
+ printf("\nf[%u] = %2X: ", i, (unsigned)filter->id);
+ {
+ unsigned i;
+ for (i = 0; i < size; i++)
+ printf(" %2X", filter->props[i]);
+ }
+ #endif
+ }
+
+ if (XzBlock_HasUnsupportedFlags(p))
+ return SZ_ERROR_UNSUPPORTED;
+
+ while (pos < headerSize)
+ if (header[pos++] != 0)
+ return SZ_ERROR_ARCHIVE;
+ return SZ_OK;
+}
+
+
+
+
+static SRes XzDecMix_Init(CMixCoder *p, const CXzBlock *block, Byte *outBuf, size_t outBufSize)
+{
+ unsigned i;
+ BoolInt needReInit = True;
+ unsigned numFilters = XzBlock_GetNumFilters(block);
+
+ if (numFilters == p->numCoders && ((p->outBuf && outBuf) || (!p->outBuf && !outBuf)))
+ {
+ needReInit = False;
+ for (i = 0; i < numFilters; i++)
+ if (p->ids[i] != block->filters[numFilters - 1 - i].id)
+ {
+ needReInit = True;
+ break;
+ }
+ }
+
+ // p->SingleBufMode = (outBuf != NULL);
+ p->outBuf = outBuf;
+ p->outBufSize = outBufSize;
+
+ // p->SingleBufMode = False;
+ // outBuf = NULL;
+
+ if (needReInit)
+ {
+ MixCoder_Free(p);
+ for (i = 0; i < numFilters; i++)
+ {
+ RINOK(MixCoder_SetFromMethod(p, i, block->filters[numFilters - 1 - i].id, outBuf, outBufSize))
+ }
+ p->numCoders = numFilters;
+ }
+ else
+ {
+ RINOK(MixCoder_ResetFromMethod(p, 0, block->filters[numFilters - 1].id, outBuf, outBufSize))
+ }
+
+ for (i = 0; i < numFilters; i++)
+ {
+ const CXzFilter *f = &block->filters[numFilters - 1 - i];
+ IStateCoder *sc = &p->coders[i];
+ RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc))
+ }
+
+ MixCoder_Init(p);
+ return SZ_OK;
+}
+
+
+
+void XzUnpacker_Init(CXzUnpacker *p)
+{
+ p->state = XZ_STATE_STREAM_HEADER;
+ p->pos = 0;
+ p->numStartedStreams = 0;
+ p->numFinishedStreams = 0;
+ p->numTotalBlocks = 0;
+ p->padSize = 0;
+ p->decodeOnlyOneBlock = 0;
+
+ p->parseMode = False;
+ p->decodeToStreamSignature = False;
+
+ // p->outBuf = NULL;
+ // p->outBufSize = 0;
+ p->outDataWritten = 0;
+}
+
+
+void XzUnpacker_SetOutBuf(CXzUnpacker *p, Byte *outBuf, size_t outBufSize)
+{
+ p->outBuf = outBuf;
+ p->outBufSize = outBufSize;
+}
+
+
+void XzUnpacker_Construct(CXzUnpacker *p, ISzAllocPtr alloc)
+{
+ MixCoder_Construct(&p->decoder, alloc);
+ p->outBuf = NULL;
+ p->outBufSize = 0;
+ XzUnpacker_Init(p);
+}
+
+
+void XzUnpacker_Free(CXzUnpacker *p)
+{
+ MixCoder_Free(&p->decoder);
+}
+
+
+void XzUnpacker_PrepareToRandomBlockDecoding(CXzUnpacker *p)
+{
+ p->indexSize = 0;
+ p->numBlocks = 0;
+ Sha256_Init(&p->sha);
+ p->state = XZ_STATE_BLOCK_HEADER;
+ p->pos = 0;
+ p->decodeOnlyOneBlock = 1;
+}
+
+
+static void XzUnpacker_UpdateIndex(CXzUnpacker *p, UInt64 packSize, UInt64 unpackSize)
+{
+ Byte temp[32];
+ unsigned num = Xz_WriteVarInt(temp, packSize);
+ num += Xz_WriteVarInt(temp + num, unpackSize);
+ Sha256_Update(&p->sha, temp, num);
+ p->indexSize += num;
+ p->numBlocks++;
+}
+
+
+
+SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
+ const Byte *src, SizeT *srcLen, int srcFinished,
+ ECoderFinishMode finishMode, ECoderStatus *status)
+{
+ SizeT destLenOrig = *destLen;
+ SizeT srcLenOrig = *srcLen;
+ *destLen = 0;
+ *srcLen = 0;
+ *status = CODER_STATUS_NOT_SPECIFIED;
+
+ for (;;)
+ {
+ SizeT srcRem;
+
+ if (p->state == XZ_STATE_BLOCK)
+ {
+ SizeT destLen2 = destLenOrig - *destLen;
+ SizeT srcLen2 = srcLenOrig - *srcLen;
+ SRes res;
+
+ ECoderFinishMode finishMode2 = finishMode;
+ BoolInt srcFinished2 = srcFinished;
+ BoolInt destFinish = False;
+
+ if (p->block.packSize != (UInt64)(Int64)-1)
+ {
+ UInt64 rem = p->block.packSize - p->packSize;
+ if (srcLen2 >= rem)
+ {
+ srcFinished2 = True;
+ srcLen2 = (SizeT)rem;
+ }
+ if (rem == 0 && p->block.unpackSize == p->unpackSize)
+ return SZ_ERROR_DATA;
+ }
+
+ if (p->block.unpackSize != (UInt64)(Int64)-1)
+ {
+ UInt64 rem = p->block.unpackSize - p->unpackSize;
+ if (destLen2 >= rem)
+ {
+ destFinish = True;
+ finishMode2 = CODER_FINISH_END;
+ destLen2 = (SizeT)rem;
+ }
+ }
+
+ /*
+ if (srcLen2 == 0 && destLen2 == 0)
+ {
+ *status = CODER_STATUS_NOT_FINISHED;
+ return SZ_OK;
+ }
+ */
+
+ {
+ res = MixCoder_Code(&p->decoder,
+ (p->outBuf ? NULL : dest), &destLen2, destFinish,
+ src, &srcLen2, srcFinished2,
+ finishMode2);
+
+ *status = p->decoder.status;
+ XzCheck_Update(&p->check, (p->outBuf ? p->outBuf + p->outDataWritten : dest), destLen2);
+ if (!p->outBuf)
+ dest += destLen2;
+ p->outDataWritten += destLen2;
+ }
+
+ (*srcLen) += srcLen2;
+ src += srcLen2;
+ p->packSize += srcLen2;
+ (*destLen) += destLen2;
+ p->unpackSize += destLen2;
+
+ RINOK(res)
+
+ if (*status != CODER_STATUS_FINISHED_WITH_MARK)
+ {
+ if (p->block.packSize == p->packSize
+ && *status == CODER_STATUS_NEEDS_MORE_INPUT)
+ {
+ PRF_STR("CODER_STATUS_NEEDS_MORE_INPUT")
+ *status = CODER_STATUS_NOT_SPECIFIED;
+ return SZ_ERROR_DATA;
+ }
+
+ return SZ_OK;
+ }
+ {
+ XzUnpacker_UpdateIndex(p, XzUnpacker_GetPackSizeForIndex(p), p->unpackSize);
+ p->state = XZ_STATE_BLOCK_FOOTER;
+ p->pos = 0;
+ p->alignPos = 0;
+ *status = CODER_STATUS_NOT_SPECIFIED;
+
+ if ((p->block.packSize != (UInt64)(Int64)-1 && p->block.packSize != p->packSize)
+ || (p->block.unpackSize != (UInt64)(Int64)-1 && p->block.unpackSize != p->unpackSize))
+ {
+ PRF_STR("ERROR: block.size mismatch")
+ return SZ_ERROR_DATA;
+ }
+ }
+ // continue;
+ }
+
+ srcRem = srcLenOrig - *srcLen;
+
+ // XZ_STATE_BLOCK_FOOTER can transit to XZ_STATE_BLOCK_HEADER without input bytes
+ if (srcRem == 0 && p->state != XZ_STATE_BLOCK_FOOTER)
+ {
+ *status = CODER_STATUS_NEEDS_MORE_INPUT;
+ return SZ_OK;
+ }
+
+ switch (p->state)
+ {
+ case XZ_STATE_STREAM_HEADER:
+ {
+ if (p->pos < XZ_STREAM_HEADER_SIZE)
+ {
+ if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])
+ return SZ_ERROR_NO_ARCHIVE;
+ if (p->decodeToStreamSignature)
+ return SZ_OK;
+ p->buf[p->pos++] = *src++;
+ (*srcLen)++;
+ }
+ else
+ {
+ RINOK(Xz_ParseHeader(&p->streamFlags, p->buf))
+ p->numStartedStreams++;
+ p->indexSize = 0;
+ p->numBlocks = 0;
+ Sha256_Init(&p->sha);
+ p->state = XZ_STATE_BLOCK_HEADER;
+ p->pos = 0;
+ }
+ break;
+ }
+
+ case XZ_STATE_BLOCK_HEADER:
+ {
+ if (p->pos == 0)
+ {
+ p->buf[p->pos++] = *src++;
+ (*srcLen)++;
+ if (p->buf[0] == 0)
+ {
+ if (p->decodeOnlyOneBlock)
+ return SZ_ERROR_DATA;
+ p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
+ p->indexPos = p->indexPreSize;
+ p->indexSize += p->indexPreSize;
+ Sha256_Final(&p->sha, p->shaDigest);
+ Sha256_Init(&p->sha);
+ p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
+ p->state = XZ_STATE_STREAM_INDEX;
+ break;
+ }
+ p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;
+ break;
+ }
+
+ if (p->pos != p->blockHeaderSize)
+ {
+ UInt32 cur = p->blockHeaderSize - p->pos;
+ if (cur > srcRem)
+ cur = (UInt32)srcRem;
+ memcpy(p->buf + p->pos, src, cur);
+ p->pos += cur;
+ (*srcLen) += cur;
+ src += cur;
+ }
+ else
+ {
+ RINOK(XzBlock_Parse(&p->block, p->buf))
+ if (!XzBlock_AreSupportedFilters(&p->block))
+ return SZ_ERROR_UNSUPPORTED;
+ p->numTotalBlocks++;
+ p->state = XZ_STATE_BLOCK;
+ p->packSize = 0;
+ p->unpackSize = 0;
+ XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));
+ if (p->parseMode)
+ {
+ p->headerParsedOk = True;
+ return SZ_OK;
+ }
+ RINOK(XzDecMix_Init(&p->decoder, &p->block, p->outBuf, p->outBufSize))
+ }
+ break;
+ }
+
+ case XZ_STATE_BLOCK_FOOTER:
+ {
+ if ((((unsigned)p->packSize + p->alignPos) & 3) != 0)
+ {
+ if (srcRem == 0)
+ {
+ *status = CODER_STATUS_NEEDS_MORE_INPUT;
+ return SZ_OK;
+ }
+ (*srcLen)++;
+ p->alignPos++;
+ if (*src++ != 0)
+ return SZ_ERROR_CRC;
+ }
+ else
+ {
+ UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
+ UInt32 cur = checkSize - p->pos;
+ if (cur != 0)
+ {
+ if (srcRem == 0)
+ {
+ *status = CODER_STATUS_NEEDS_MORE_INPUT;
+ return SZ_OK;
+ }
+ if (cur > srcRem)
+ cur = (UInt32)srcRem;
+ memcpy(p->buf + p->pos, src, cur);
+ p->pos += cur;
+ (*srcLen) += cur;
+ src += cur;
+ if (checkSize != p->pos)
+ break;
+ }
+ {
+ Byte digest[XZ_CHECK_SIZE_MAX];
+ p->state = XZ_STATE_BLOCK_HEADER;
+ p->pos = 0;
+ if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
+ return SZ_ERROR_CRC;
+ if (p->decodeOnlyOneBlock)
+ {
+ *status = CODER_STATUS_FINISHED_WITH_MARK;
+ return SZ_OK;
+ }
+ }
+ }
+ break;
+ }
+
+ case XZ_STATE_STREAM_INDEX:
+ {
+ if (p->pos < p->indexPreSize)
+ {
+ (*srcLen)++;
+ if (*src++ != p->buf[p->pos++])
+ return SZ_ERROR_CRC;
+ }
+ else
+ {
+ if (p->indexPos < p->indexSize)
+ {
+ UInt64 cur = p->indexSize - p->indexPos;
+ if (srcRem > cur)
+ srcRem = (SizeT)cur;
+ p->crc = CrcUpdate(p->crc, src, srcRem);
+ Sha256_Update(&p->sha, src, srcRem);
+ (*srcLen) += srcRem;
+ src += srcRem;
+ p->indexPos += srcRem;
+ }
+ else if ((p->indexPos & 3) != 0)
+ {
+ Byte b = *src++;
+ p->crc = CRC_UPDATE_BYTE(p->crc, b);
+ (*srcLen)++;
+ p->indexPos++;
+ p->indexSize++;
+ if (b != 0)
+ return SZ_ERROR_CRC;
+ }
+ else
+ {
+ Byte digest[SHA256_DIGEST_SIZE];
+ p->state = XZ_STATE_STREAM_INDEX_CRC;
+ p->indexSize += 4;
+ p->pos = 0;
+ Sha256_Final(&p->sha, digest);
+ if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
+ return SZ_ERROR_CRC;
+ }
+ }
+ break;
+ }
+
+ case XZ_STATE_STREAM_INDEX_CRC:
+ {
+ if (p->pos < 4)
+ {
+ (*srcLen)++;
+ p->buf[p->pos++] = *src++;
+ }
+ else
+ {
+ const Byte *ptr = p->buf;
+ p->state = XZ_STATE_STREAM_FOOTER;
+ p->pos = 0;
+ if (CRC_GET_DIGEST(p->crc) != GetUi32(ptr))
+ return SZ_ERROR_CRC;
+ }
+ break;
+ }
+
+ case XZ_STATE_STREAM_FOOTER:
+ {
+ UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
+ if (cur > srcRem)
+ cur = (UInt32)srcRem;
+ memcpy(p->buf + p->pos, src, cur);
+ p->pos += cur;
+ (*srcLen) += cur;
+ src += cur;
+ if (p->pos == XZ_STREAM_FOOTER_SIZE)
+ {
+ p->state = XZ_STATE_STREAM_PADDING;
+ p->numFinishedStreams++;
+ p->padSize = 0;
+ if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))
+ return SZ_ERROR_CRC;
+ }
+ break;
+ }
+
+ case XZ_STATE_STREAM_PADDING:
+ {
+ if (*src != 0)
+ {
+ if (((UInt32)p->padSize & 3) != 0)
+ return SZ_ERROR_NO_ARCHIVE;
+ p->pos = 0;
+ p->state = XZ_STATE_STREAM_HEADER;
+ }
+ else
+ {
+ (*srcLen)++;
+ src++;
+ p->padSize++;
+ }
+ break;
+ }
+
+ case XZ_STATE_BLOCK: break; /* to disable GCC warning */
+ }
+ }
+ /*
+ if (p->state == XZ_STATE_FINISHED)
+ *status = CODER_STATUS_FINISHED_WITH_MARK;
+ return SZ_OK;
+ */
+}
+
+
+SRes XzUnpacker_CodeFull(CXzUnpacker *p, Byte *dest, SizeT *destLen,
+ const Byte *src, SizeT *srcLen,
+ ECoderFinishMode finishMode, ECoderStatus *status)
+{
+ XzUnpacker_Init(p);
+ XzUnpacker_SetOutBuf(p, dest, *destLen);
+
+ return XzUnpacker_Code(p,
+ NULL, destLen,
+ src, srcLen, True,
+ finishMode, status);
+}
+
+
+BoolInt XzUnpacker_IsBlockFinished(const CXzUnpacker *p)
+{
+ return (p->state == XZ_STATE_BLOCK_HEADER) && (p->pos == 0);
+}
+
+BoolInt XzUnpacker_IsStreamWasFinished(const CXzUnpacker *p)
+{
+ return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);
+}
+
+UInt64 XzUnpacker_GetExtraSize(const CXzUnpacker *p)
+{
+ UInt64 num = 0;
+ if (p->state == XZ_STATE_STREAM_PADDING)
+ num = p->padSize;
+ else if (p->state == XZ_STATE_STREAM_HEADER)
+ num = p->padSize + p->pos;
+ return num;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#ifndef Z7_ST
+#include "MtDec.h"
+#endif
+
+
+void XzDecMtProps_Init(CXzDecMtProps *p)
+{
+ p->inBufSize_ST = 1 << 18;
+ p->outStep_ST = 1 << 20;
+ p->ignoreErrors = False;
+
+ #ifndef Z7_ST
+ p->numThreads = 1;
+ p->inBufSize_MT = 1 << 18;
+ p->memUseMax = sizeof(size_t) << 28;
+ #endif
+}
+
+
+
+#ifndef Z7_ST
+
+/* ---------- CXzDecMtThread ---------- */
+
+typedef struct
+{
+ Byte *outBuf;
+ size_t outBufSize;
+ size_t outPreSize;
+ size_t inPreSize;
+ size_t inPreHeaderSize;
+ size_t blockPackSize_for_Index; // including block header and checksum.
+ size_t blockPackTotal; // including stream header, block header and checksum.
+ size_t inCodeSize;
+ size_t outCodeSize;
+ ECoderStatus status;
+ SRes codeRes;
+ BoolInt skipMode;
+ // BoolInt finishedWithMark;
+ EMtDecParseState parseState;
+ BoolInt parsing_Truncated;
+ BoolInt atBlockHeader;
+ CXzStreamFlags streamFlags;
+ // UInt64 numFinishedStreams
+ UInt64 numStreams;
+ UInt64 numTotalBlocks;
+ UInt64 numBlocks;
+
+ BoolInt dec_created;
+ CXzUnpacker dec;
+
+ Byte mtPad[1 << 7];
+} CXzDecMtThread;
+
+#endif
+
+
+/* ---------- CXzDecMt ---------- */
+
+struct CXzDecMt
+{
+ CAlignOffsetAlloc alignOffsetAlloc;
+ ISzAllocPtr allocMid;
+
+ CXzDecMtProps props;
+ size_t unpackBlockMaxSize;
+
+ ISeqInStreamPtr inStream;
+ ISeqOutStreamPtr outStream;
+ ICompressProgressPtr progress;
+
+ BoolInt finishMode;
+ BoolInt outSize_Defined;
+ UInt64 outSize;
+
+ UInt64 outProcessed;
+ UInt64 inProcessed;
+ UInt64 readProcessed;
+ BoolInt readWasFinished;
+ SRes readRes;
+ SRes writeRes;
+
+ Byte *outBuf;
+ size_t outBufSize;
+ Byte *inBuf;
+ size_t inBufSize;
+
+ CXzUnpacker dec;
+
+ ECoderStatus status;
+ SRes codeRes;
+
+ #ifndef Z7_ST
+ BoolInt mainDecoderWasCalled;
+ // int statErrorDefined;
+ int finishedDecoderIndex;
+
+ // global values that are used in Parse stage
+ CXzStreamFlags streamFlags;
+ // UInt64 numFinishedStreams
+ UInt64 numStreams;
+ UInt64 numTotalBlocks;
+ UInt64 numBlocks;
+
+ // UInt64 numBadBlocks;
+ SRes mainErrorCode; // it's set to error code, if the size Code() output doesn't patch the size from Parsing stage
+ // it can be = SZ_ERROR_INPUT_EOF
+ // it can be = SZ_ERROR_DATA, in some another cases
+ BoolInt isBlockHeaderState_Parse;
+ BoolInt isBlockHeaderState_Write;
+ UInt64 outProcessed_Parse;
+ BoolInt parsing_Truncated;
+
+ BoolInt mtc_WasConstructed;
+ CMtDec mtc;
+ CXzDecMtThread coders[MTDEC_THREADS_MAX];
+ #endif
+};
+
+
+
+CXzDecMtHandle XzDecMt_Create(ISzAllocPtr alloc, ISzAllocPtr allocMid)
+{
+ CXzDecMt *p = (CXzDecMt *)ISzAlloc_Alloc(alloc, sizeof(CXzDecMt));
+ if (!p)
+ return NULL;
+
+ AlignOffsetAlloc_CreateVTable(&p->alignOffsetAlloc);
+ p->alignOffsetAlloc.baseAlloc = alloc;
+ p->alignOffsetAlloc.numAlignBits = 7;
+ p->alignOffsetAlloc.offset = 0;
+
+ p->allocMid = allocMid;
+
+ p->outBuf = NULL;
+ p->outBufSize = 0;
+ p->inBuf = NULL;
+ p->inBufSize = 0;
+
+ XzUnpacker_Construct(&p->dec, &p->alignOffsetAlloc.vt);
+
+ p->unpackBlockMaxSize = 0;
+
+ XzDecMtProps_Init(&p->props);
+
+ #ifndef Z7_ST
+ p->mtc_WasConstructed = False;
+ {
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CXzDecMtThread *coder = &p->coders[i];
+ coder->dec_created = False;
+ coder->outBuf = NULL;
+ coder->outBufSize = 0;
+ }
+ }
+ #endif
+
+ return (CXzDecMtHandle)p;
+}
+
+
+#ifndef Z7_ST
+
+static void XzDecMt_FreeOutBufs(CXzDecMt *p)
+{
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CXzDecMtThread *coder = &p->coders[i];
+ if (coder->outBuf)
+ {
+ ISzAlloc_Free(p->allocMid, coder->outBuf);
+ coder->outBuf = NULL;
+ coder->outBufSize = 0;
+ }
+ }
+ p->unpackBlockMaxSize = 0;
+}
+
+#endif
+
+
+
+static void XzDecMt_FreeSt(CXzDecMt *p)
+{
+ XzUnpacker_Free(&p->dec);
+
+ if (p->outBuf)
+ {
+ ISzAlloc_Free(p->allocMid, p->outBuf);
+ p->outBuf = NULL;
+ }
+ p->outBufSize = 0;
+
+ if (p->inBuf)
+ {
+ ISzAlloc_Free(p->allocMid, p->inBuf);
+ p->inBuf = NULL;
+ }
+ p->inBufSize = 0;
+}
+
+
+// #define GET_CXzDecMt_p CXzDecMt *p = pp;
+
+void XzDecMt_Destroy(CXzDecMtHandle p)
+{
+ // GET_CXzDecMt_p
+
+ XzDecMt_FreeSt(p);
+
+ #ifndef Z7_ST
+
+ if (p->mtc_WasConstructed)
+ {
+ MtDec_Destruct(&p->mtc);
+ p->mtc_WasConstructed = False;
+ }
+ {
+ unsigned i;
+ for (i = 0; i < MTDEC_THREADS_MAX; i++)
+ {
+ CXzDecMtThread *t = &p->coders[i];
+ if (t->dec_created)
+ {
+ // we don't need to free dict here
+ XzUnpacker_Free(&t->dec);
+ t->dec_created = False;
+ }
+ }
+ }
+ XzDecMt_FreeOutBufs(p);
+
+ #endif
+
+ ISzAlloc_Free(p->alignOffsetAlloc.baseAlloc, p);
+}
+
+
+
+#ifndef Z7_ST
+
+static void XzDecMt_Callback_Parse(void *obj, unsigned coderIndex, CMtDecCallbackInfo *cc)
+{
+ CXzDecMt *me = (CXzDecMt *)obj;
+ CXzDecMtThread *coder = &me->coders[coderIndex];
+ size_t srcSize = cc->srcSize;
+
+ cc->srcSize = 0;
+ cc->outPos = 0;
+ cc->state = MTDEC_PARSE_CONTINUE;
+
+ cc->canCreateNewThread = True;
+
+ if (cc->startCall)
+ {
+ coder->outPreSize = 0;
+ coder->inPreSize = 0;
+ coder->inPreHeaderSize = 0;
+ coder->parseState = MTDEC_PARSE_CONTINUE;
+ coder->parsing_Truncated = False;
+ coder->skipMode = False;
+ coder->codeRes = SZ_OK;
+ coder->status = CODER_STATUS_NOT_SPECIFIED;
+ coder->inCodeSize = 0;
+ coder->outCodeSize = 0;
+
+ coder->numStreams = me->numStreams;
+ coder->numTotalBlocks = me->numTotalBlocks;
+ coder->numBlocks = me->numBlocks;
+
+ if (!coder->dec_created)
+ {
+ XzUnpacker_Construct(&coder->dec, &me->alignOffsetAlloc.vt);
+ coder->dec_created = True;
+ }
+
+ XzUnpacker_Init(&coder->dec);
+
+ if (me->isBlockHeaderState_Parse)
+ {
+ coder->dec.streamFlags = me->streamFlags;
+ coder->atBlockHeader = True;
+ XzUnpacker_PrepareToRandomBlockDecoding(&coder->dec);
+ }
+ else
+ {
+ coder->atBlockHeader = False;
+ me->isBlockHeaderState_Parse = True;
+ }
+
+ coder->dec.numStartedStreams = me->numStreams;
+ coder->dec.numTotalBlocks = me->numTotalBlocks;
+ coder->dec.numBlocks = me->numBlocks;
+ }
+
+ while (!coder->skipMode)
+ {
+ ECoderStatus status;
+ SRes res;
+ size_t srcSize2 = srcSize;
+ size_t destSize = (size_t)0 - 1;
+
+ coder->dec.parseMode = True;
+ coder->dec.headerParsedOk = False;
+
+ PRF_STR_INT("Parse", srcSize2)
+
+ res = XzUnpacker_Code(&coder->dec,
+ NULL, &destSize,
+ cc->src, &srcSize2, cc->srcFinished,
+ CODER_FINISH_END, &status);
+
+ // PRF(printf(" res = %d, srcSize2 = %d", res, (unsigned)srcSize2));
+
+ coder->codeRes = res;
+ coder->status = status;
+ cc->srcSize += srcSize2;
+ srcSize -= srcSize2;
+ coder->inPreHeaderSize += srcSize2;
+ coder->inPreSize = coder->inPreHeaderSize;
+
+ if (res != SZ_OK)
+ {
+ cc->state =
+ coder->parseState = MTDEC_PARSE_END;
+ /*
+ if (res == SZ_ERROR_MEM)
+ return res;
+ return SZ_OK;
+ */
+ return; // res;
+ }
+
+ if (coder->dec.headerParsedOk)
+ {
+ const CXzBlock *block = &coder->dec.block;
+ if (XzBlock_HasUnpackSize(block)
+ // && block->unpackSize <= me->props.outBlockMax
+ && XzBlock_HasPackSize(block))
+ {
+ {
+ if (block->unpackSize * 2 * me->mtc.numStartedThreads > me->props.memUseMax)
+ {
+ cc->state = MTDEC_PARSE_OVERFLOW;
+ return; // SZ_OK;
+ }
+ }
+ {
+ UInt64 packSize = block->packSize;
+ UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
+ UInt32 checkSize = XzFlags_GetCheckSize(coder->dec.streamFlags);
+ UInt64 blockPackSum = coder->inPreSize + packSizeAligned + checkSize;
+ // if (blockPackSum <= me->props.inBlockMax)
+ // unpackBlockMaxSize
+ {
+ coder->blockPackSize_for_Index = (size_t)(coder->dec.blockHeaderSize + packSize + checkSize);
+ coder->blockPackTotal = (size_t)blockPackSum;
+ coder->outPreSize = (size_t)block->unpackSize;
+ coder->streamFlags = coder->dec.streamFlags;
+ me->streamFlags = coder->dec.streamFlags;
+ coder->skipMode = True;
+ break;
+ }
+ }
+ }
+ }
+ else
+ // if (coder->inPreSize <= me->props.inBlockMax)
+ {
+ if (!cc->srcFinished)
+ return; // SZ_OK;
+ cc->state =
+ coder->parseState = MTDEC_PARSE_END;
+ return; // SZ_OK;
+ }
+ cc->state = MTDEC_PARSE_OVERFLOW;
+ return; // SZ_OK;
+ }
+
+ // ---------- skipMode ----------
+ {
+ UInt64 rem = coder->blockPackTotal - coder->inPreSize;
+ size_t cur = srcSize;
+ if (cur > rem)
+ cur = (size_t)rem;
+ cc->srcSize += cur;
+ coder->inPreSize += cur;
+ srcSize -= cur;
+
+ if (coder->inPreSize == coder->blockPackTotal)
+ {
+ if (srcSize == 0)
+ {
+ if (!cc->srcFinished)
+ return; // SZ_OK;
+ cc->state = MTDEC_PARSE_END;
+ }
+ else if ((cc->src)[cc->srcSize] == 0) // we check control byte of next block
+ cc->state = MTDEC_PARSE_END;
+ else
+ {
+ cc->state = MTDEC_PARSE_NEW;
+
+ {
+ size_t blockMax = me->unpackBlockMaxSize;
+ if (blockMax < coder->outPreSize)
+ blockMax = coder->outPreSize;
+ {
+ UInt64 required = (UInt64)blockMax * (me->mtc.numStartedThreads + 1) * 2;
+ if (me->props.memUseMax < required)
+ cc->canCreateNewThread = False;
+ }
+ }
+
+ if (me->outSize_Defined)
+ {
+ // next block can be zero size
+ const UInt64 rem2 = me->outSize - me->outProcessed_Parse;
+ if (rem2 < coder->outPreSize)
+ {
+ coder->parsing_Truncated = True;
+ cc->state = MTDEC_PARSE_END;
+ }
+ me->outProcessed_Parse += coder->outPreSize;
+ }
+ }
+ }
+ else if (cc->srcFinished)
+ cc->state = MTDEC_PARSE_END;
+ else
+ return; // SZ_OK;
+
+ coder->parseState = cc->state;
+ cc->outPos = coder->outPreSize;
+
+ me->numStreams = coder->dec.numStartedStreams;
+ me->numTotalBlocks = coder->dec.numTotalBlocks;
+ me->numBlocks = coder->dec.numBlocks + 1;
+ return; // SZ_OK;
+ }
+}
+
+
+static SRes XzDecMt_Callback_PreCode(void *pp, unsigned coderIndex)
+{
+ CXzDecMt *me = (CXzDecMt *)pp;
+ CXzDecMtThread *coder = &me->coders[coderIndex];
+ Byte *dest;
+
+ if (!coder->dec.headerParsedOk)
+ return SZ_OK;
+
+ dest = coder->outBuf;
+
+ if (!dest || coder->outBufSize < coder->outPreSize)
+ {
+ if (dest)
+ {
+ ISzAlloc_Free(me->allocMid, dest);
+ coder->outBuf = NULL;
+ coder->outBufSize = 0;
+ }
+ {
+ size_t outPreSize = coder->outPreSize;
+ if (outPreSize == 0)
+ outPreSize = 1;
+ dest = (Byte *)ISzAlloc_Alloc(me->allocMid, outPreSize);
+ }
+ if (!dest)
+ return SZ_ERROR_MEM;
+ coder->outBuf = dest;
+ coder->outBufSize = coder->outPreSize;
+
+ if (coder->outBufSize > me->unpackBlockMaxSize)
+ me->unpackBlockMaxSize = coder->outBufSize;
+ }
+
+ // return SZ_ERROR_MEM;
+
+ XzUnpacker_SetOutBuf(&coder->dec, coder->outBuf, coder->outBufSize);
+
+ {
+ SRes res = XzDecMix_Init(&coder->dec.decoder, &coder->dec.block, coder->outBuf, coder->outBufSize);
+ // res = SZ_ERROR_UNSUPPORTED; // to test
+ coder->codeRes = res;
+ if (res != SZ_OK)
+ {
+ // if (res == SZ_ERROR_MEM) return res;
+ if (me->props.ignoreErrors && res != SZ_ERROR_MEM)
+ return SZ_OK;
+ return res;
+ }
+ }
+
+ return SZ_OK;
+}
+
+
+static SRes XzDecMt_Callback_Code(void *pp, unsigned coderIndex,
+ const Byte *src, size_t srcSize, int srcFinished,
+ // int finished, int blockFinished,
+ UInt64 *inCodePos, UInt64 *outCodePos, int *stop)
+{
+ CXzDecMt *me = (CXzDecMt *)pp;
+ CXzDecMtThread *coder = &me->coders[coderIndex];
+
+ *inCodePos = coder->inCodeSize;
+ *outCodePos = coder->outCodeSize;
+ *stop = True;
+
+ if (srcSize > coder->inPreSize - coder->inCodeSize)
+ return SZ_ERROR_FAIL;
+
+ if (coder->inCodeSize < coder->inPreHeaderSize)
+ {
+ size_t step = coder->inPreHeaderSize - coder->inCodeSize;
+ if (step > srcSize)
+ step = srcSize;
+ src += step;
+ srcSize -= step;
+ coder->inCodeSize += step;
+ *inCodePos = coder->inCodeSize;
+ if (coder->inCodeSize < coder->inPreHeaderSize)
+ {
+ *stop = False;
+ return SZ_OK;
+ }
+ }
+
+ if (!coder->dec.headerParsedOk)
+ return SZ_OK;
+ if (!coder->outBuf)
+ return SZ_OK;
+
+ if (coder->codeRes == SZ_OK)
+ {
+ ECoderStatus status;
+ SRes res;
+ size_t srcProcessed = srcSize;
+ size_t outSizeCur = coder->outPreSize - coder->dec.outDataWritten;
+
+ // PRF(printf("\nCallback_Code: Code %d %d\n", (unsigned)srcSize, (unsigned)outSizeCur));
+
+ res = XzUnpacker_Code(&coder->dec,
+ NULL, &outSizeCur,
+ src, &srcProcessed, srcFinished,
+ // coder->finishedWithMark ? CODER_FINISH_END : CODER_FINISH_ANY,
+ CODER_FINISH_END,
+ &status);
+
+ // PRF(printf(" res = %d, srcSize2 = %d, outSizeCur = %d", res, (unsigned)srcProcessed, (unsigned)outSizeCur));
+
+ coder->codeRes = res;
+ coder->status = status;
+ coder->inCodeSize += srcProcessed;
+ coder->outCodeSize = coder->dec.outDataWritten;
+ *inCodePos = coder->inCodeSize;
+ *outCodePos = coder->outCodeSize;
+
+ if (res == SZ_OK)
+ {
+ if (srcProcessed == srcSize)
+ *stop = False;
+ return SZ_OK;
+ }
+ }
+
+ if (me->props.ignoreErrors && coder->codeRes != SZ_ERROR_MEM)
+ {
+ *inCodePos = coder->inPreSize;
+ *outCodePos = coder->outPreSize;
+ return SZ_OK;
+ }
+ return coder->codeRes;
+}
+
+
+#define XZDECMT_STREAM_WRITE_STEP (1 << 24)
+
+static SRes XzDecMt_Callback_Write(void *pp, unsigned coderIndex,
+ BoolInt needWriteToStream,
+ const Byte *src, size_t srcSize, BoolInt isCross,
+ // int srcFinished,
+ BoolInt *needContinue,
+ BoolInt *canRecode)
+{
+ CXzDecMt *me = (CXzDecMt *)pp;
+ const CXzDecMtThread *coder = &me->coders[coderIndex];
+
+ // PRF(printf("\nWrite processed = %d srcSize = %d\n", (unsigned)me->mtc.inProcessed, (unsigned)srcSize));
+
+ *needContinue = False;
+ *canRecode = True;
+
+ if (!needWriteToStream)
+ return SZ_OK;
+
+ if (!coder->dec.headerParsedOk || !coder->outBuf)
+ {
+ if (me->finishedDecoderIndex < 0)
+ me->finishedDecoderIndex = (int)coderIndex;
+ return SZ_OK;
+ }
+
+ if (me->finishedDecoderIndex >= 0)
+ return SZ_OK;
+
+ me->mtc.inProcessed += coder->inCodeSize;
+
+ *canRecode = False;
+
+ {
+ SRes res;
+ size_t size = coder->outCodeSize;
+ Byte *data = coder->outBuf;
+
+ // we use in me->dec: sha, numBlocks, indexSize
+
+ if (!me->isBlockHeaderState_Write)
+ {
+ XzUnpacker_PrepareToRandomBlockDecoding(&me->dec);
+ me->dec.decodeOnlyOneBlock = False;
+ me->dec.numStartedStreams = coder->dec.numStartedStreams;
+ me->dec.streamFlags = coder->streamFlags;
+
+ me->isBlockHeaderState_Write = True;
+ }
+
+ me->dec.numTotalBlocks = coder->dec.numTotalBlocks;
+ XzUnpacker_UpdateIndex(&me->dec, coder->blockPackSize_for_Index, coder->outPreSize);
+
+ if (coder->outPreSize != size)
+ {
+ if (me->props.ignoreErrors)
+ {
+ memset(data + size, 0, coder->outPreSize - size);
+ size = coder->outPreSize;
+ }
+ // me->numBadBlocks++;
+ if (me->mainErrorCode == SZ_OK)
+ {
+ if ((int)coder->status == LZMA_STATUS_NEEDS_MORE_INPUT)
+ me->mainErrorCode = SZ_ERROR_INPUT_EOF;
+ else
+ me->mainErrorCode = SZ_ERROR_DATA;
+ }
+ }
+
+ if (me->writeRes != SZ_OK)
+ return me->writeRes;
+
+ res = SZ_OK;
+ {
+ if (me->outSize_Defined)
+ {
+ const UInt64 rem = me->outSize - me->outProcessed;
+ if (size > rem)
+ size = (SizeT)rem;
+ }
+
+ for (;;)
+ {
+ size_t cur = size;
+ size_t written;
+ if (cur > XZDECMT_STREAM_WRITE_STEP)
+ cur = XZDECMT_STREAM_WRITE_STEP;
+
+ written = ISeqOutStream_Write(me->outStream, data, cur);
+
+ // PRF(printf("\nWritten ask = %d written = %d\n", (unsigned)cur, (unsigned)written));
+
+ me->outProcessed += written;
+ if (written != cur)
+ {
+ me->writeRes = SZ_ERROR_WRITE;
+ res = me->writeRes;
+ break;
+ }
+ data += cur;
+ size -= cur;
+ // PRF_STR_INT("Written size =", size)
+ if (size == 0)
+ break;
+ res = MtProgress_ProgressAdd(&me->mtc.mtProgress, 0, 0);
+ if (res != SZ_OK)
+ break;
+ }
+ }
+
+ if (coder->codeRes != SZ_OK)
+ if (!me->props.ignoreErrors)
+ {
+ me->finishedDecoderIndex = (int)coderIndex;
+ return res;
+ }
+
+ RINOK(res)
+
+ if (coder->inPreSize != coder->inCodeSize
+ || coder->blockPackTotal != coder->inCodeSize)
+ {
+ me->finishedDecoderIndex = (int)coderIndex;
+ return SZ_OK;
+ }
+
+ if (coder->parseState != MTDEC_PARSE_END)
+ {
+ *needContinue = True;
+ return SZ_OK;
+ }
+ }
+
+ // (coder->state == MTDEC_PARSE_END) means that there are no other working threads
+ // so we can use mtc variables without lock
+
+ PRF_STR_INT("Write MTDEC_PARSE_END", me->mtc.inProcessed)
+
+ me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
+ {
+ CXzUnpacker *dec = &me->dec;
+
+ PRF_STR_INT("PostSingle", srcSize)
+
+ {
+ size_t srcProcessed = srcSize;
+ ECoderStatus status;
+ size_t outSizeCur = 0;
+ SRes res;
+
+ // dec->decodeOnlyOneBlock = False;
+ dec->decodeToStreamSignature = True;
+
+ me->mainDecoderWasCalled = True;
+
+ if (coder->parsing_Truncated)
+ {
+ me->parsing_Truncated = True;
+ return SZ_OK;
+ }
+
+ /*
+ We have processed all xz-blocks of stream,
+ And xz unpacker is at XZ_STATE_BLOCK_HEADER state, where
+ (src) is a pointer to xz-Index structure.
+ We finish reading of current xz-Stream, including Zero padding after xz-Stream.
+ We exit, if we reach extra byte (first byte of new-Stream or another data).
+ But we don't update input stream pointer for that new extra byte.
+ If extra byte is not correct first byte of xz-signature,
+ we have SZ_ERROR_NO_ARCHIVE error here.
+ */
+
+ res = XzUnpacker_Code(dec,
+ NULL, &outSizeCur,
+ src, &srcProcessed,
+ me->mtc.readWasFinished, // srcFinished
+ CODER_FINISH_END, // CODER_FINISH_ANY,
+ &status);
+
+ // res = SZ_ERROR_ARCHIVE; // for failure test
+
+ me->status = status;
+ me->codeRes = res;
+
+ if (isCross)
+ me->mtc.crossStart += srcProcessed;
+
+ me->mtc.inProcessed += srcProcessed;
+ me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
+
+ srcSize -= srcProcessed;
+ src += srcProcessed;
+
+ if (res != SZ_OK)
+ {
+ return SZ_OK;
+ // return res;
+ }
+
+ if (dec->state == XZ_STATE_STREAM_HEADER)
+ {
+ *needContinue = True;
+ me->isBlockHeaderState_Parse = False;
+ me->isBlockHeaderState_Write = False;
+
+ if (!isCross)
+ {
+ Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
+ if (!crossBuf)
+ return SZ_ERROR_MEM;
+ if (srcSize != 0)
+ memcpy(crossBuf, src, srcSize);
+ me->mtc.crossStart = 0;
+ me->mtc.crossEnd = srcSize;
+ }
+
+ PRF_STR_INT("XZ_STATE_STREAM_HEADER crossEnd = ", (unsigned)me->mtc.crossEnd)
+
+ return SZ_OK;
+ }
+
+ if (status != CODER_STATUS_NEEDS_MORE_INPUT || srcSize != 0)
+ {
+ return SZ_ERROR_FAIL;
+ }
+
+ if (me->mtc.readWasFinished)
+ {
+ return SZ_OK;
+ }
+ }
+
+ {
+ size_t inPos;
+ size_t inLim;
+ // const Byte *inData;
+ UInt64 inProgressPrev = me->mtc.inProcessed;
+
+ // XzDecMt_Prepare_InBuf_ST(p);
+ Byte *crossBuf = MtDec_GetCrossBuff(&me->mtc);
+ if (!crossBuf)
+ return SZ_ERROR_MEM;
+
+ inPos = 0;
+ inLim = 0;
+
+ // inData = crossBuf;
+
+ for (;;)
+ {
+ SizeT inProcessed;
+ SizeT outProcessed;
+ ECoderStatus status;
+ SRes res;
+
+ if (inPos == inLim)
+ {
+ if (!me->mtc.readWasFinished)
+ {
+ inPos = 0;
+ inLim = me->mtc.inBufSize;
+ me->mtc.readRes = ISeqInStream_Read(me->inStream, (void *)crossBuf, &inLim);
+ me->mtc.readProcessed += inLim;
+ if (inLim == 0 || me->mtc.readRes != SZ_OK)
+ me->mtc.readWasFinished = True;
+ }
+ }
+
+ inProcessed = inLim - inPos;
+ outProcessed = 0;
+
+ res = XzUnpacker_Code(dec,
+ NULL, &outProcessed,
+ crossBuf + inPos, &inProcessed,
+ (inProcessed == 0), // srcFinished
+ CODER_FINISH_END, &status);
+
+ me->codeRes = res;
+ me->status = status;
+ inPos += inProcessed;
+ me->mtc.inProcessed += inProcessed;
+ me->mtc.mtProgress.totalInSize = me->mtc.inProcessed;
+
+ if (res != SZ_OK)
+ {
+ return SZ_OK;
+ // return res;
+ }
+
+ if (dec->state == XZ_STATE_STREAM_HEADER)
+ {
+ *needContinue = True;
+ me->mtc.crossStart = inPos;
+ me->mtc.crossEnd = inLim;
+ me->isBlockHeaderState_Parse = False;
+ me->isBlockHeaderState_Write = False;
+ return SZ_OK;
+ }
+
+ if (status != CODER_STATUS_NEEDS_MORE_INPUT)
+ return SZ_ERROR_FAIL;
+
+ if (me->mtc.progress)
+ {
+ UInt64 inDelta = me->mtc.inProcessed - inProgressPrev;
+ if (inDelta >= (1 << 22))
+ {
+ RINOK(MtProgress_Progress_ST(&me->mtc.mtProgress))
+ inProgressPrev = me->mtc.inProcessed;
+ }
+ }
+ if (me->mtc.readWasFinished)
+ return SZ_OK;
+ }
+ }
+ }
+}
+
+
+#endif
+
+
+
+void XzStatInfo_Clear(CXzStatInfo *p)
+{
+ p->InSize = 0;
+ p->OutSize = 0;
+
+ p->NumStreams = 0;
+ p->NumBlocks = 0;
+
+ p->UnpackSize_Defined = False;
+
+ p->NumStreams_Defined = False;
+ p->NumBlocks_Defined = False;
+
+ p->DataAfterEnd = False;
+ p->DecodingTruncated = False;
+
+ p->DecodeRes = SZ_OK;
+ p->ReadRes = SZ_OK;
+ p->ProgressRes = SZ_OK;
+
+ p->CombinedRes = SZ_OK;
+ p->CombinedRes_Type = SZ_OK;
+}
+
+
+
+/*
+ XzDecMt_Decode_ST() can return SZ_OK or the following errors
+ - SZ_ERROR_MEM for memory allocation error
+ - error from XzUnpacker_Code() function
+ - SZ_ERROR_WRITE for ISeqOutStream::Write(). stat->CombinedRes_Type = SZ_ERROR_WRITE in that case
+ - ICompressProgress::Progress() error, stat->CombinedRes_Type = SZ_ERROR_PROGRESS.
+ But XzDecMt_Decode_ST() doesn't return ISeqInStream::Read() errors.
+ ISeqInStream::Read() result is set to p->readRes.
+ also it can set stat->CombinedRes_Type to SZ_ERROR_WRITE or SZ_ERROR_PROGRESS.
+*/
+
+static SRes XzDecMt_Decode_ST(CXzDecMt *p
+ #ifndef Z7_ST
+ , BoolInt tMode
+ #endif
+ , CXzStatInfo *stat)
+{
+ size_t outPos;
+ size_t inPos, inLim;
+ const Byte *inData;
+ UInt64 inPrev, outPrev;
+
+ CXzUnpacker *dec;
+
+ #ifndef Z7_ST
+ if (tMode)
+ {
+ XzDecMt_FreeOutBufs(p);
+ tMode = MtDec_PrepareRead(&p->mtc);
+ }
+ #endif
+
+ if (!p->outBuf || p->outBufSize != p->props.outStep_ST)
+ {
+ ISzAlloc_Free(p->allocMid, p->outBuf);
+ p->outBufSize = 0;
+ p->outBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.outStep_ST);
+ if (!p->outBuf)
+ return SZ_ERROR_MEM;
+ p->outBufSize = p->props.outStep_ST;
+ }
+
+ if (!p->inBuf || p->inBufSize != p->props.inBufSize_ST)
+ {
+ ISzAlloc_Free(p->allocMid, p->inBuf);
+ p->inBufSize = 0;
+ p->inBuf = (Byte *)ISzAlloc_Alloc(p->allocMid, p->props.inBufSize_ST);
+ if (!p->inBuf)
+ return SZ_ERROR_MEM;
+ p->inBufSize = p->props.inBufSize_ST;
+ }
+
+ dec = &p->dec;
+ dec->decodeToStreamSignature = False;
+ // dec->decodeOnlyOneBlock = False;
+
+ XzUnpacker_SetOutBuf(dec, NULL, 0);
+
+ inPrev = p->inProcessed;
+ outPrev = p->outProcessed;
+
+ inPos = 0;
+ inLim = 0;
+ inData = NULL;
+ outPos = 0;
+
+ for (;;)
+ {
+ SizeT outSize;
+ BoolInt finished;
+ ECoderFinishMode finishMode;
+ SizeT inProcessed;
+ ECoderStatus status;
+ SRes res;
+
+ SizeT outProcessed;
+
+
+
+ if (inPos == inLim)
+ {
+ #ifndef Z7_ST
+ if (tMode)
+ {
+ inData = MtDec_Read(&p->mtc, &inLim);
+ inPos = 0;
+ if (inData)
+ continue;
+ tMode = False;
+ inLim = 0;
+ }
+ #endif
+
+ if (!p->readWasFinished)
+ {
+ inPos = 0;
+ inLim = p->inBufSize;
+ inData = p->inBuf;
+ p->readRes = ISeqInStream_Read(p->inStream, (void *)p->inBuf, &inLim);
+ p->readProcessed += inLim;
+ if (inLim == 0 || p->readRes != SZ_OK)
+ p->readWasFinished = True;
+ }
+ }
+
+ outSize = p->props.outStep_ST - outPos;
+
+ finishMode = CODER_FINISH_ANY;
+ if (p->outSize_Defined)
+ {
+ const UInt64 rem = p->outSize - p->outProcessed;
+ if (outSize >= rem)
+ {
+ outSize = (SizeT)rem;
+ if (p->finishMode)
+ finishMode = CODER_FINISH_END;
+ }
+ }
+
+ inProcessed = inLim - inPos;
+ outProcessed = outSize;
+
+ res = XzUnpacker_Code(dec, p->outBuf + outPos, &outProcessed,
+ inData + inPos, &inProcessed,
+ (inPos == inLim), // srcFinished
+ finishMode, &status);
+
+ p->codeRes = res;
+ p->status = status;
+
+ inPos += inProcessed;
+ outPos += outProcessed;
+ p->inProcessed += inProcessed;
+ p->outProcessed += outProcessed;
+
+ finished = ((inProcessed == 0 && outProcessed == 0) || res != SZ_OK);
+
+ if (finished || outProcessed >= outSize)
+ if (outPos != 0)
+ {
+ const size_t written = ISeqOutStream_Write(p->outStream, p->outBuf, outPos);
+ // p->outProcessed += written; // 21.01: BUG fixed
+ if (written != outPos)
+ {
+ stat->CombinedRes_Type = SZ_ERROR_WRITE;
+ return SZ_ERROR_WRITE;
+ }
+ outPos = 0;
+ }
+
+ if (p->progress && res == SZ_OK)
+ {
+ if (p->inProcessed - inPrev >= (1 << 22) ||
+ p->outProcessed - outPrev >= (1 << 22))
+ {
+ res = ICompressProgress_Progress(p->progress, p->inProcessed, p->outProcessed);
+ if (res != SZ_OK)
+ {
+ stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
+ stat->ProgressRes = res;
+ return res;
+ }
+ inPrev = p->inProcessed;
+ outPrev = p->outProcessed;
+ }
+ }
+
+ if (finished)
+ {
+ // p->codeRes is preliminary error from XzUnpacker_Code.
+ // and it can be corrected later as final result
+ // so we return SZ_OK here instead of (res);
+ return SZ_OK;
+ // return res;
+ }
+ }
+}
+
+
+
+/*
+XzStatInfo_SetStat() transforms
+ CXzUnpacker return code and status to combined CXzStatInfo results.
+ it can convert SZ_OK to SZ_ERROR_INPUT_EOF
+ it can convert SZ_ERROR_NO_ARCHIVE to SZ_OK and (DataAfterEnd = 1)
+*/
+
+static void XzStatInfo_SetStat(const CXzUnpacker *dec,
+ int finishMode,
+ // UInt64 readProcessed,
+ UInt64 inProcessed,
+ SRes res, // it's result from CXzUnpacker unpacker
+ ECoderStatus status,
+ BoolInt decodingTruncated,
+ CXzStatInfo *stat)
+{
+ UInt64 extraSize;
+
+ stat->DecodingTruncated = (Byte)(decodingTruncated ? 1 : 0);
+ stat->InSize = inProcessed;
+ stat->NumStreams = dec->numStartedStreams;
+ stat->NumBlocks = dec->numTotalBlocks;
+
+ stat->UnpackSize_Defined = True;
+ stat->NumStreams_Defined = True;
+ stat->NumBlocks_Defined = True;
+
+ extraSize = XzUnpacker_GetExtraSize(dec);
+
+ if (res == SZ_OK)
+ {
+ if (status == CODER_STATUS_NEEDS_MORE_INPUT)
+ {
+ // CODER_STATUS_NEEDS_MORE_INPUT is expected status for correct xz streams
+ // any extra data is part of correct data
+ extraSize = 0;
+ // if xz stream was not finished, then we need more data
+ if (!XzUnpacker_IsStreamWasFinished(dec))
+ res = SZ_ERROR_INPUT_EOF;
+ }
+ else
+ {
+ // CODER_STATUS_FINISHED_WITH_MARK is not possible for multi stream xz decoding
+ // so he we have (status == CODER_STATUS_NOT_FINISHED)
+ // if (status != CODER_STATUS_FINISHED_WITH_MARK)
+ if (!decodingTruncated || finishMode)
+ res = SZ_ERROR_DATA;
+ }
+ }
+ else if (res == SZ_ERROR_NO_ARCHIVE)
+ {
+ /*
+ SZ_ERROR_NO_ARCHIVE is possible for 2 states:
+ XZ_STATE_STREAM_HEADER - if bad signature or bad CRC
+ XZ_STATE_STREAM_PADDING - if non-zero padding data
+ extraSize and inProcessed don't include "bad" byte
+ */
+ // if (inProcessed == extraSize), there was no any good xz stream header, and we keep error
+ if (inProcessed != extraSize) // if there were good xz streams before error
+ {
+ // if (extraSize != 0 || readProcessed != inProcessed)
+ {
+ // he we suppose that all xz streams were finsihed OK, and we have
+ // some extra data after all streams
+ stat->DataAfterEnd = True;
+ res = SZ_OK;
+ }
+ }
+ }
+
+ if (stat->DecodeRes == SZ_OK)
+ stat->DecodeRes = res;
+
+ stat->InSize -= extraSize;
+}
+
+
+
+SRes XzDecMt_Decode(CXzDecMtHandle p,
+ const CXzDecMtProps *props,
+ const UInt64 *outDataSize, int finishMode,
+ ISeqOutStreamPtr outStream,
+ // Byte *outBuf, size_t *outBufSize,
+ ISeqInStreamPtr inStream,
+ // const Byte *inData, size_t inDataSize,
+ CXzStatInfo *stat,
+ int *isMT,
+ ICompressProgressPtr progress)
+{
+ // GET_CXzDecMt_p
+ #ifndef Z7_ST
+ BoolInt tMode;
+ #endif
+
+ XzStatInfo_Clear(stat);
+
+ p->props = *props;
+
+ p->inStream = inStream;
+ p->outStream = outStream;
+ p->progress = progress;
+ // p->stat = stat;
+
+ p->outSize = 0;
+ p->outSize_Defined = False;
+ if (outDataSize)
+ {
+ p->outSize_Defined = True;
+ p->outSize = *outDataSize;
+ }
+
+ p->finishMode = finishMode;
+
+ // p->outSize = 457; p->outSize_Defined = True; p->finishMode = False; // for test
+
+ p->writeRes = SZ_OK;
+ p->outProcessed = 0;
+ p->inProcessed = 0;
+ p->readProcessed = 0;
+ p->readWasFinished = False;
+ p->readRes = SZ_OK;
+
+ p->codeRes = SZ_OK;
+ p->status = CODER_STATUS_NOT_SPECIFIED;
+
+ XzUnpacker_Init(&p->dec);
+
+ *isMT = False;
+
+ /*
+ p->outBuf = NULL;
+ p->outBufSize = 0;
+ if (!outStream)
+ {
+ p->outBuf = outBuf;
+ p->outBufSize = *outBufSize;
+ *outBufSize = 0;
+ }
+ */
+
+
+ #ifndef Z7_ST
+
+ p->isBlockHeaderState_Parse = False;
+ p->isBlockHeaderState_Write = False;
+ // p->numBadBlocks = 0;
+ p->mainErrorCode = SZ_OK;
+ p->mainDecoderWasCalled = False;
+
+ tMode = False;
+
+ if (p->props.numThreads > 1)
+ {
+ IMtDecCallback2 vt;
+ BoolInt needContinue;
+ SRes res;
+ // we just free ST buffers here
+ // but we still keep state variables, that was set in XzUnpacker_Init()
+ XzDecMt_FreeSt(p);
+
+ p->outProcessed_Parse = 0;
+ p->parsing_Truncated = False;
+
+ p->numStreams = 0;
+ p->numTotalBlocks = 0;
+ p->numBlocks = 0;
+ p->finishedDecoderIndex = -1;
+
+ if (!p->mtc_WasConstructed)
+ {
+ p->mtc_WasConstructed = True;
+ MtDec_Construct(&p->mtc);
+ }
+
+ p->mtc.mtCallback = &vt;
+ p->mtc.mtCallbackObject = p;
+
+ p->mtc.progress = progress;
+ p->mtc.inStream = inStream;
+ p->mtc.alloc = &p->alignOffsetAlloc.vt;
+ // p->mtc.inData = inData;
+ // p->mtc.inDataSize = inDataSize;
+ p->mtc.inBufSize = p->props.inBufSize_MT;
+ // p->mtc.inBlockMax = p->props.inBlockMax;
+ p->mtc.numThreadsMax = p->props.numThreads;
+
+ *isMT = True;
+
+ vt.Parse = XzDecMt_Callback_Parse;
+ vt.PreCode = XzDecMt_Callback_PreCode;
+ vt.Code = XzDecMt_Callback_Code;
+ vt.Write = XzDecMt_Callback_Write;
+
+
+ res = MtDec_Code(&p->mtc);
+
+
+ stat->InSize = p->mtc.inProcessed;
+
+ p->inProcessed = p->mtc.inProcessed;
+ p->readRes = p->mtc.readRes;
+ p->readWasFinished = p->mtc.readWasFinished;
+ p->readProcessed = p->mtc.readProcessed;
+
+ tMode = True;
+ needContinue = False;
+
+ if (res == SZ_OK)
+ {
+ if (p->mtc.mtProgress.res != SZ_OK)
+ {
+ res = p->mtc.mtProgress.res;
+ stat->ProgressRes = res;
+ stat->CombinedRes_Type = SZ_ERROR_PROGRESS;
+ }
+ else
+ needContinue = p->mtc.needContinue;
+ }
+
+ if (!needContinue)
+ {
+ {
+ SRes codeRes;
+ BoolInt truncated = False;
+ ECoderStatus status;
+ const CXzUnpacker *dec;
+
+ stat->OutSize = p->outProcessed;
+
+ if (p->finishedDecoderIndex >= 0)
+ {
+ const CXzDecMtThread *coder = &p->coders[(unsigned)p->finishedDecoderIndex];
+ codeRes = coder->codeRes;
+ dec = &coder->dec;
+ status = coder->status;
+ }
+ else if (p->mainDecoderWasCalled)
+ {
+ codeRes = p->codeRes;
+ dec = &p->dec;
+ status = p->status;
+ truncated = p->parsing_Truncated;
+ }
+ else
+ return SZ_ERROR_FAIL;
+
+ if (p->mainErrorCode != SZ_OK)
+ stat->DecodeRes = p->mainErrorCode;
+
+ XzStatInfo_SetStat(dec, p->finishMode,
+ // p->mtc.readProcessed,
+ p->mtc.inProcessed,
+ codeRes, status,
+ truncated,
+ stat);
+ }
+
+ if (res == SZ_OK)
+ {
+ stat->ReadRes = p->mtc.readRes;
+
+ if (p->writeRes != SZ_OK)
+ {
+ res = p->writeRes;
+ stat->CombinedRes_Type = SZ_ERROR_WRITE;
+ }
+ else if (p->mtc.readRes != SZ_OK
+ // && p->mtc.inProcessed == p->mtc.readProcessed
+ && stat->DecodeRes == SZ_ERROR_INPUT_EOF)
+ {
+ res = p->mtc.readRes;
+ stat->CombinedRes_Type = SZ_ERROR_READ;
+ }
+ else if (stat->DecodeRes != SZ_OK)
+ res = stat->DecodeRes;
+ }
+
+ stat->CombinedRes = res;
+ if (stat->CombinedRes_Type == SZ_OK)
+ stat->CombinedRes_Type = res;
+ return res;
+ }
+
+ PRF_STR("----- decoding ST -----")
+ }
+
+ #endif
+
+
+ *isMT = False;
+
+ {
+ SRes res = XzDecMt_Decode_ST(p
+ #ifndef Z7_ST
+ , tMode
+ #endif
+ , stat
+ );
+
+ #ifndef Z7_ST
+ // we must set error code from MT decoding at first
+ if (p->mainErrorCode != SZ_OK)
+ stat->DecodeRes = p->mainErrorCode;
+ #endif
+
+ XzStatInfo_SetStat(&p->dec,
+ p->finishMode,
+ // p->readProcessed,
+ p->inProcessed,
+ p->codeRes, p->status,
+ False, // truncated
+ stat);
+
+ stat->ReadRes = p->readRes;
+
+ if (res == SZ_OK)
+ {
+ if (p->readRes != SZ_OK
+ // && p->inProcessed == p->readProcessed
+ && stat->DecodeRes == SZ_ERROR_INPUT_EOF)
+ {
+ // we set read error as combined error, only if that error was the reason
+ // of decoding problem
+ res = p->readRes;
+ stat->CombinedRes_Type = SZ_ERROR_READ;
+ }
+ else if (stat->DecodeRes != SZ_OK)
+ res = stat->DecodeRes;
+ }
+
+ stat->CombinedRes = res;
+ if (stat->CombinedRes_Type == SZ_OK)
+ stat->CombinedRes_Type = res;
+ return res;
+ }
+}
+
+#undef PRF
+#undef PRF_STR
+#undef PRF_STR_INT_2
diff --git a/C/XzEnc.c b/C/XzEnc.c
index 309eca9..22408e2 100644
--- a/C/XzEnc.c
+++ b/C/XzEnc.c
@@ -1,1329 +1,1362 @@
-/* XzEnc.c -- Xz Encode
-2019-02-02 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "7zCrc.h"
-#include "Bra.h"
-#include "CpuArch.h"
-
-#ifdef USE_SUBBLOCK
-#include "Bcj3Enc.c"
-#include "SbFind.c"
-#include "SbEnc.c"
-#endif
-
-#include "XzEnc.h"
-
-// #define _7ZIP_ST
-
-#ifndef _7ZIP_ST
-#include "MtCoder.h"
-#else
-#define MTCODER__THREADS_MAX 1
-#define MTCODER__BLOCKS_MAX 1
-#endif
-
-#define XZ_GET_PAD_SIZE(dataSize) ((4 - ((unsigned)(dataSize) & 3)) & 3)
-
-/* max pack size for LZMA2 block + check-64bytrs: */
-#define XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize) ((unpackSize) + ((unpackSize) >> 10) + 16 + 64)
-
-#define XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(unpackSize) (XZ_BLOCK_HEADER_SIZE_MAX + XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize))
-
-
-#define XzBlock_ClearFlags(p) (p)->flags = 0;
-#define XzBlock_SetNumFilters(p, n) (p)->flags |= ((n) - 1);
-#define XzBlock_SetHasPackSize(p) (p)->flags |= XZ_BF_PACK_SIZE;
-#define XzBlock_SetHasUnpackSize(p) (p)->flags |= XZ_BF_UNPACK_SIZE;
-
-
-static SRes WriteBytes(ISeqOutStream *s, const void *buf, size_t size)
-{
- return (ISeqOutStream_Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE;
-}
-
-static SRes WriteBytesUpdateCrc(ISeqOutStream *s, const void *buf, size_t size, UInt32 *crc)
-{
- *crc = CrcUpdate(*crc, buf, size);
- return WriteBytes(s, buf, size);
-}
-
-
-static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStream *s)
-{
- UInt32 crc;
- Byte header[XZ_STREAM_HEADER_SIZE];
- memcpy(header, XZ_SIG, XZ_SIG_SIZE);
- header[XZ_SIG_SIZE] = (Byte)(f >> 8);
- header[XZ_SIG_SIZE + 1] = (Byte)(f & 0xFF);
- crc = CrcCalc(header + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE);
- SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc);
- return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE);
-}
-
-
-static SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStream *s)
-{
- Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
-
- unsigned pos = 1;
- unsigned numFilters, i;
- header[pos++] = p->flags;
-
- if (XzBlock_HasPackSize(p)) pos += Xz_WriteVarInt(header + pos, p->packSize);
- if (XzBlock_HasUnpackSize(p)) pos += Xz_WriteVarInt(header + pos, p->unpackSize);
- numFilters = XzBlock_GetNumFilters(p);
-
- for (i = 0; i < numFilters; i++)
- {
- const CXzFilter *f = &p->filters[i];
- pos += Xz_WriteVarInt(header + pos, f->id);
- pos += Xz_WriteVarInt(header + pos, f->propsSize);
- memcpy(header + pos, f->props, f->propsSize);
- pos += f->propsSize;
- }
-
- while ((pos & 3) != 0)
- header[pos++] = 0;
-
- header[0] = (Byte)(pos >> 2);
- SetUi32(header + pos, CrcCalc(header, pos));
- return WriteBytes(s, header, pos + 4);
-}
-
-
-
-
-typedef struct
-{
- size_t numBlocks;
- size_t size;
- size_t allocated;
- Byte *blocks;
-} CXzEncIndex;
-
-
-static void XzEncIndex_Construct(CXzEncIndex *p)
-{
- p->numBlocks = 0;
- p->size = 0;
- p->allocated = 0;
- p->blocks = NULL;
-}
-
-static void XzEncIndex_Init(CXzEncIndex *p)
-{
- p->numBlocks = 0;
- p->size = 0;
-}
-
-static void XzEncIndex_Free(CXzEncIndex *p, ISzAllocPtr alloc)
-{
- if (p->blocks)
- {
- ISzAlloc_Free(alloc, p->blocks);
- p->blocks = NULL;
- }
- p->numBlocks = 0;
- p->size = 0;
- p->allocated = 0;
-}
-
-
-static SRes XzEncIndex_ReAlloc(CXzEncIndex *p, size_t newSize, ISzAllocPtr alloc)
-{
- Byte *blocks = (Byte *)ISzAlloc_Alloc(alloc, newSize);
- if (!blocks)
- return SZ_ERROR_MEM;
- if (p->size != 0)
- memcpy(blocks, p->blocks, p->size);
- if (p->blocks)
- ISzAlloc_Free(alloc, p->blocks);
- p->blocks = blocks;
- p->allocated = newSize;
- return SZ_OK;
-}
-
-
-static SRes XzEncIndex_PreAlloc(CXzEncIndex *p, UInt64 numBlocks, UInt64 unpackSize, UInt64 totalSize, ISzAllocPtr alloc)
-{
- UInt64 pos;
- {
- Byte buf[32];
- unsigned pos2 = Xz_WriteVarInt(buf, totalSize);
- pos2 += Xz_WriteVarInt(buf + pos2, unpackSize);
- pos = numBlocks * pos2;
- }
-
- if (pos <= p->allocated - p->size)
- return SZ_OK;
- {
- UInt64 newSize64 = p->size + pos;
- size_t newSize = (size_t)newSize64;
- if (newSize != newSize64)
- return SZ_ERROR_MEM;
- return XzEncIndex_ReAlloc(p, newSize, alloc);
- }
-}
-
-
-static SRes XzEncIndex_AddIndexRecord(CXzEncIndex *p, UInt64 unpackSize, UInt64 totalSize, ISzAllocPtr alloc)
-{
- Byte buf[32];
- unsigned pos = Xz_WriteVarInt(buf, totalSize);
- pos += Xz_WriteVarInt(buf + pos, unpackSize);
-
- if (pos > p->allocated - p->size)
- {
- size_t newSize = p->allocated * 2 + 16 * 2;
- if (newSize < p->size + pos)
- return SZ_ERROR_MEM;
- RINOK(XzEncIndex_ReAlloc(p, newSize, alloc));
- }
- memcpy(p->blocks + p->size, buf, pos);
- p->size += pos;
- p->numBlocks++;
- return SZ_OK;
-}
-
-
-static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, ISeqOutStream *s)
-{
- Byte buf[32];
- UInt64 globalPos;
- UInt32 crc = CRC_INIT_VAL;
- unsigned pos = 1 + Xz_WriteVarInt(buf + 1, p->numBlocks);
-
- globalPos = pos;
- buf[0] = 0;
- RINOK(WriteBytesUpdateCrc(s, buf, pos, &crc));
- RINOK(WriteBytesUpdateCrc(s, p->blocks, p->size, &crc));
- globalPos += p->size;
-
- pos = XZ_GET_PAD_SIZE(globalPos);
- buf[1] = 0;
- buf[2] = 0;
- buf[3] = 0;
- globalPos += pos;
-
- crc = CrcUpdate(crc, buf + 4 - pos, pos);
- SetUi32(buf + 4, CRC_GET_DIGEST(crc));
-
- SetUi32(buf + 8 + 4, (UInt32)(globalPos >> 2));
- buf[8 + 8] = (Byte)(flags >> 8);
- buf[8 + 9] = (Byte)(flags & 0xFF);
- SetUi32(buf + 8, CrcCalc(buf + 8 + 4, 6));
- buf[8 + 10] = XZ_FOOTER_SIG_0;
- buf[8 + 11] = XZ_FOOTER_SIG_1;
-
- return WriteBytes(s, buf + 4 - pos, pos + 4 + 12);
-}
-
-
-
-/* ---------- CSeqCheckInStream ---------- */
-
-typedef struct
-{
- ISeqInStream vt;
- ISeqInStream *realStream;
- const Byte *data;
- UInt64 limit;
- UInt64 processed;
- int realStreamFinished;
- CXzCheck check;
-} CSeqCheckInStream;
-
-static void SeqCheckInStream_Init(CSeqCheckInStream *p, unsigned checkMode)
-{
- p->limit = (UInt64)(Int64)-1;
- p->processed = 0;
- p->realStreamFinished = 0;
- XzCheck_Init(&p->check, checkMode);
-}
-
-static void SeqCheckInStream_GetDigest(CSeqCheckInStream *p, Byte *digest)
-{
- XzCheck_Final(&p->check, digest);
-}
-
-static SRes SeqCheckInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
-{
- CSeqCheckInStream *p = CONTAINER_FROM_VTBL(pp, CSeqCheckInStream, vt);
- size_t size2 = *size;
- SRes res = SZ_OK;
-
- if (p->limit != (UInt64)(Int64)-1)
- {
- UInt64 rem = p->limit - p->processed;
- if (size2 > rem)
- size2 = (size_t)rem;
- }
- if (size2 != 0)
- {
- if (p->realStream)
- {
- res = ISeqInStream_Read(p->realStream, data, &size2);
- p->realStreamFinished = (size2 == 0) ? 1 : 0;
- }
- else
- memcpy(data, p->data + (size_t)p->processed, size2);
- XzCheck_Update(&p->check, data, size2);
- p->processed += size2;
- }
- *size = size2;
- return res;
-}
-
-
-/* ---------- CSeqSizeOutStream ---------- */
-
-typedef struct
-{
- ISeqOutStream vt;
- ISeqOutStream *realStream;
- Byte *outBuf;
- size_t outBufLimit;
- UInt64 processed;
-} CSeqSizeOutStream;
-
-static size_t SeqSizeOutStream_Write(const ISeqOutStream *pp, const void *data, size_t size)
-{
- CSeqSizeOutStream *p = CONTAINER_FROM_VTBL(pp, CSeqSizeOutStream, vt);
- if (p->realStream)
- size = ISeqOutStream_Write(p->realStream, data, size);
- else
- {
- if (size > p->outBufLimit - (size_t)p->processed)
- return 0;
- memcpy(p->outBuf + (size_t)p->processed, data, size);
- }
- p->processed += size;
- return size;
-}
-
-
-/* ---------- CSeqInFilter ---------- */
-
-#define FILTER_BUF_SIZE (1 << 20)
-
-typedef struct
-{
- ISeqInStream p;
- ISeqInStream *realStream;
- IStateCoder StateCoder;
- Byte *buf;
- size_t curPos;
- size_t endPos;
- int srcWasFinished;
-} CSeqInFilter;
-
-
-SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAllocPtr alloc);
-
-static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props, ISzAllocPtr alloc)
-{
- if (!p->buf)
- {
- p->buf = (Byte *)ISzAlloc_Alloc(alloc, FILTER_BUF_SIZE);
- if (!p->buf)
- return SZ_ERROR_MEM;
- }
- p->curPos = p->endPos = 0;
- p->srcWasFinished = 0;
- RINOK(BraState_SetFromMethod(&p->StateCoder, props->id, 1, alloc));
- RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, alloc));
- p->StateCoder.Init(p->StateCoder.p);
- return SZ_OK;
-}
-
-
-static SRes SeqInFilter_Read(const ISeqInStream *pp, void *data, size_t *size)
-{
- CSeqInFilter *p = CONTAINER_FROM_VTBL(pp, CSeqInFilter, p);
- size_t sizeOriginal = *size;
- if (sizeOriginal == 0)
- return SZ_OK;
- *size = 0;
-
- for (;;)
- {
- if (!p->srcWasFinished && p->curPos == p->endPos)
- {
- p->curPos = 0;
- p->endPos = FILTER_BUF_SIZE;
- RINOK(ISeqInStream_Read(p->realStream, p->buf, &p->endPos));
- if (p->endPos == 0)
- p->srcWasFinished = 1;
- }
- {
- SizeT srcLen = p->endPos - p->curPos;
- ECoderStatus status;
- SRes res;
- *size = sizeOriginal;
- res = p->StateCoder.Code2(p->StateCoder.p,
- (Byte *)data, size,
- p->buf + p->curPos, &srcLen,
- p->srcWasFinished, CODER_FINISH_ANY,
- &status);
- p->curPos += srcLen;
- if (*size != 0 || srcLen == 0 || res != SZ_OK)
- return res;
- }
- }
-}
-
-static void SeqInFilter_Construct(CSeqInFilter *p)
-{
- p->buf = NULL;
- p->StateCoder.p = NULL;
- p->p.Read = SeqInFilter_Read;
-}
-
-static void SeqInFilter_Free(CSeqInFilter *p, ISzAllocPtr alloc)
-{
- if (p->StateCoder.p)
- {
- p->StateCoder.Free(p->StateCoder.p, alloc);
- p->StateCoder.p = NULL;
- }
- if (p->buf)
- {
- ISzAlloc_Free(alloc, p->buf);
- p->buf = NULL;
- }
-}
-
-
-/* ---------- CSbEncInStream ---------- */
-
-#ifdef USE_SUBBLOCK
-
-typedef struct
-{
- ISeqInStream vt;
- ISeqInStream *inStream;
- CSbEnc enc;
-} CSbEncInStream;
-
-static SRes SbEncInStream_Read(const ISeqInStream *pp, void *data, size_t *size)
-{
- CSbEncInStream *p = CONTAINER_FROM_VTBL(pp, CSbEncInStream, vt);
- size_t sizeOriginal = *size;
- if (sizeOriginal == 0)
- return SZ_OK;
-
- for (;;)
- {
- if (p->enc.needRead && !p->enc.readWasFinished)
- {
- size_t processed = p->enc.needReadSizeMax;
- RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed));
- p->enc.readPos += processed;
- if (processed == 0)
- {
- p->enc.readWasFinished = True;
- p->enc.isFinalFinished = True;
- }
- p->enc.needRead = False;
- }
-
- *size = sizeOriginal;
- RINOK(SbEnc_Read(&p->enc, data, size));
- if (*size != 0 || !p->enc.needRead)
- return SZ_OK;
- }
-}
-
-void SbEncInStream_Construct(CSbEncInStream *p, ISzAllocPtr alloc)
-{
- SbEnc_Construct(&p->enc, alloc);
- p->vt.Read = SbEncInStream_Read;
-}
-
-SRes SbEncInStream_Init(CSbEncInStream *p)
-{
- return SbEnc_Init(&p->enc);
-}
-
-void SbEncInStream_Free(CSbEncInStream *p)
-{
- SbEnc_Free(&p->enc);
-}
-
-#endif
-
-
-
-/* ---------- CXzProps ---------- */
-
-
-void XzFilterProps_Init(CXzFilterProps *p)
-{
- p->id = 0;
- p->delta = 0;
- p->ip = 0;
- p->ipDefined = False;
-}
-
-void XzProps_Init(CXzProps *p)
-{
- p->checkId = XZ_CHECK_CRC32;
- p->blockSize = XZ_PROPS__BLOCK_SIZE__AUTO;
- p->numBlockThreads_Reduced = -1;
- p->numBlockThreads_Max = -1;
- p->numTotalThreads = -1;
- p->reduceSize = (UInt64)(Int64)-1;
- p->forceWriteSizesInHeader = 0;
- // p->forceWriteSizesInHeader = 1;
-
- XzFilterProps_Init(&p->filterProps);
- Lzma2EncProps_Init(&p->lzma2Props);
-}
-
-
-static void XzEncProps_Normalize_Fixed(CXzProps *p)
-{
- UInt64 fileSize;
- int t1, t1n, t2, t2r, t3;
- {
- CLzma2EncProps tp = p->lzma2Props;
- if (tp.numTotalThreads <= 0)
- tp.numTotalThreads = p->numTotalThreads;
- Lzma2EncProps_Normalize(&tp);
- t1n = tp.numTotalThreads;
- }
-
- t1 = p->lzma2Props.numTotalThreads;
- t2 = p->numBlockThreads_Max;
- t3 = p->numTotalThreads;
-
- if (t2 > MTCODER__THREADS_MAX)
- t2 = MTCODER__THREADS_MAX;
-
- if (t3 <= 0)
- {
- if (t2 <= 0)
- t2 = 1;
- t3 = t1n * t2;
- }
- else if (t2 <= 0)
- {
- t2 = t3 / t1n;
- if (t2 == 0)
- {
- t1 = 1;
- t2 = t3;
- }
- if (t2 > MTCODER__THREADS_MAX)
- t2 = MTCODER__THREADS_MAX;
- }
- else if (t1 <= 0)
- {
- t1 = t3 / t2;
- if (t1 == 0)
- t1 = 1;
- }
- else
- t3 = t1n * t2;
-
- p->lzma2Props.numTotalThreads = t1;
-
- t2r = t2;
-
- fileSize = p->reduceSize;
-
- if ((p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))
- p->lzma2Props.lzmaProps.reduceSize = p->blockSize;
-
- Lzma2EncProps_Normalize(&p->lzma2Props);
-
- t1 = p->lzma2Props.numTotalThreads;
-
- {
- if (t2 > 1 && fileSize != (UInt64)(Int64)-1)
- {
- UInt64 numBlocks = fileSize / p->blockSize;
- if (numBlocks * p->blockSize != fileSize)
- numBlocks++;
- if (numBlocks < (unsigned)t2)
- {
- t2r = (unsigned)numBlocks;
- if (t2r == 0)
- t2r = 1;
- t3 = t1 * t2r;
- }
- }
- }
-
- p->numBlockThreads_Max = t2;
- p->numBlockThreads_Reduced = t2r;
- p->numTotalThreads = t3;
-}
-
-
-static void XzProps_Normalize(CXzProps *p)
-{
- /* we normalize xzProps properties, but we normalize only some of CXzProps::lzma2Props properties.
- Lzma2Enc_SetProps() will normalize lzma2Props later. */
-
- if (p->blockSize == XZ_PROPS__BLOCK_SIZE__SOLID)
- {
- p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
- p->numBlockThreads_Reduced = 1;
- p->numBlockThreads_Max = 1;
- if (p->lzma2Props.numTotalThreads <= 0)
- p->lzma2Props.numTotalThreads = p->numTotalThreads;
- return;
- }
- else
- {
- CLzma2EncProps *lzma2 = &p->lzma2Props;
- if (p->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
- {
- // xz-auto
- p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
-
- if (lzma2->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
- {
- // if (xz-auto && lzma2-solid) - we use solid for both
- p->blockSize = XZ_PROPS__BLOCK_SIZE__SOLID;
- p->numBlockThreads_Reduced = 1;
- p->numBlockThreads_Max = 1;
- if (p->lzma2Props.numTotalThreads <= 0)
- p->lzma2Props.numTotalThreads = p->numTotalThreads;
- }
- else
- {
- // if (xz-auto && (lzma2-auto || lzma2-fixed_)
- // we calculate block size for lzma2 and use that block size for xz, lzma2 uses single-chunk per block
- CLzma2EncProps tp = p->lzma2Props;
- if (tp.numTotalThreads <= 0)
- tp.numTotalThreads = p->numTotalThreads;
-
- Lzma2EncProps_Normalize(&tp);
-
- p->blockSize = tp.blockSize; // fixed or solid
- p->numBlockThreads_Reduced = tp.numBlockThreads_Reduced;
- p->numBlockThreads_Max = tp.numBlockThreads_Max;
- if (lzma2->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
- lzma2->blockSize = tp.blockSize; // fixed or solid, LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
- if (lzma2->lzmaProps.reduceSize > tp.blockSize && tp.blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
- lzma2->lzmaProps.reduceSize = tp.blockSize;
- lzma2->numBlockThreads_Reduced = 1;
- lzma2->numBlockThreads_Max = 1;
- return;
- }
- }
- else
- {
- // xz-fixed
- // we can use xz::reduceSize or xz::blockSize as base for lzmaProps::reduceSize
-
- p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
- {
- UInt64 r = p->reduceSize;
- if (r > p->blockSize || r == (UInt64)(Int64)-1)
- r = p->blockSize;
- lzma2->lzmaProps.reduceSize = r;
- }
- if (lzma2->blockSize == LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO)
- lzma2->blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;
- else if (lzma2->blockSize > p->blockSize && lzma2->blockSize != LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID)
- lzma2->blockSize = p->blockSize;
-
- XzEncProps_Normalize_Fixed(p);
- }
- }
-}
-
-
-/* ---------- CLzma2WithFilters ---------- */
-
-typedef struct
-{
- CLzma2EncHandle lzma2;
- CSeqInFilter filter;
-
- #ifdef USE_SUBBLOCK
- CSbEncInStream sb;
- #endif
-} CLzma2WithFilters;
-
-
-static void Lzma2WithFilters_Construct(CLzma2WithFilters *p)
-{
- p->lzma2 = NULL;
- SeqInFilter_Construct(&p->filter);
-
- #ifdef USE_SUBBLOCK
- SbEncInStream_Construct(&p->sb, alloc);
- #endif
-}
-
-
-static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p, ISzAllocPtr alloc, ISzAllocPtr bigAlloc)
-{
- if (!p->lzma2)
- {
- p->lzma2 = Lzma2Enc_Create(alloc, bigAlloc);
- if (!p->lzma2)
- return SZ_ERROR_MEM;
- }
- return SZ_OK;
-}
-
-
-static void Lzma2WithFilters_Free(CLzma2WithFilters *p, ISzAllocPtr alloc)
-{
- #ifdef USE_SUBBLOCK
- SbEncInStream_Free(&p->sb);
- #endif
-
- SeqInFilter_Free(&p->filter, alloc);
- if (p->lzma2)
- {
- Lzma2Enc_Destroy(p->lzma2);
- p->lzma2 = NULL;
- }
-}
-
-
-typedef struct
-{
- UInt64 unpackSize;
- UInt64 totalSize;
- size_t headerSize;
-} CXzEncBlockInfo;
-
-
-static SRes Xz_CompressBlock(
- CLzma2WithFilters *lzmaf,
-
- ISeqOutStream *outStream,
- Byte *outBufHeader,
- Byte *outBufData, size_t outBufDataLimit,
-
- ISeqInStream *inStream,
- // UInt64 expectedSize,
- const Byte *inBuf, // used if (!inStream)
- size_t inBufSize, // used if (!inStream), it's block size, props->blockSize is ignored
-
- const CXzProps *props,
- ICompressProgress *progress,
- int *inStreamFinished, /* only for inStream version */
- CXzEncBlockInfo *blockSizes,
- ISzAllocPtr alloc,
- ISzAllocPtr allocBig)
-{
- CSeqCheckInStream checkInStream;
- CSeqSizeOutStream seqSizeOutStream;
- CXzBlock block;
- unsigned filterIndex = 0;
- CXzFilter *filter = NULL;
- const CXzFilterProps *fp = &props->filterProps;
- if (fp->id == 0)
- fp = NULL;
-
- *inStreamFinished = False;
-
- RINOK(Lzma2WithFilters_Create(lzmaf, alloc, allocBig));
-
- RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, &props->lzma2Props));
-
- XzBlock_ClearFlags(&block);
- XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0));
-
- if (fp)
- {
- filter = &block.filters[filterIndex++];
- filter->id = fp->id;
- filter->propsSize = 0;
-
- if (fp->id == XZ_ID_Delta)
- {
- filter->props[0] = (Byte)(fp->delta - 1);
- filter->propsSize = 1;
- }
- else if (fp->ipDefined)
- {
- SetUi32(filter->props, fp->ip);
- filter->propsSize = 4;
- }
- }
-
- {
- CXzFilter *f = &block.filters[filterIndex++];
- f->id = XZ_ID_LZMA2;
- f->propsSize = 1;
- f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2);
- }
-
- seqSizeOutStream.vt.Write = SeqSizeOutStream_Write;
- seqSizeOutStream.realStream = outStream;
- seqSizeOutStream.outBuf = outBufData;
- seqSizeOutStream.outBufLimit = outBufDataLimit;
- seqSizeOutStream.processed = 0;
-
- /*
- if (expectedSize != (UInt64)(Int64)-1)
- {
- block.unpackSize = expectedSize;
- if (props->blockSize != (UInt64)(Int64)-1)
- if (expectedSize > props->blockSize)
- block.unpackSize = props->blockSize;
- XzBlock_SetHasUnpackSize(&block);
- }
- */
-
- if (outStream)
- {
- RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt));
- }
-
- checkInStream.vt.Read = SeqCheckInStream_Read;
- SeqCheckInStream_Init(&checkInStream, props->checkId);
-
- checkInStream.realStream = inStream;
- checkInStream.data = inBuf;
- checkInStream.limit = props->blockSize;
- if (!inStream)
- checkInStream.limit = inBufSize;
-
- if (fp)
- {
- #ifdef USE_SUBBLOCK
- if (fp->id == XZ_ID_Subblock)
- {
- lzmaf->sb.inStream = &checkInStream.vt;
- RINOK(SbEncInStream_Init(&lzmaf->sb));
- }
- else
- #endif
- {
- lzmaf->filter.realStream = &checkInStream.vt;
- RINOK(SeqInFilter_Init(&lzmaf->filter, filter, alloc));
- }
- }
-
- {
- SRes res;
- Byte *outBuf = NULL;
- size_t outSize = 0;
- BoolInt useStream = (fp || inStream);
- // useStream = True;
-
- if (!useStream)
- {
- XzCheck_Update(&checkInStream.check, inBuf, inBufSize);
- checkInStream.processed = inBufSize;
- }
-
- if (!outStream)
- {
- outBuf = seqSizeOutStream.outBuf; // + (size_t)seqSizeOutStream.processed;
- outSize = seqSizeOutStream.outBufLimit; // - (size_t)seqSizeOutStream.processed;
- }
-
- res = Lzma2Enc_Encode2(lzmaf->lzma2,
- outBuf ? NULL : &seqSizeOutStream.vt,
- outBuf,
- outBuf ? &outSize : NULL,
-
- useStream ?
- (fp ?
- (
- #ifdef USE_SUBBLOCK
- (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.vt:
- #endif
- &lzmaf->filter.p) :
- &checkInStream.vt) : NULL,
-
- useStream ? NULL : inBuf,
- useStream ? 0 : inBufSize,
-
- progress);
-
- if (outBuf)
- seqSizeOutStream.processed += outSize;
-
- RINOK(res);
- blockSizes->unpackSize = checkInStream.processed;
- }
- {
- Byte buf[4 + 64];
- unsigned padSize = XZ_GET_PAD_SIZE(seqSizeOutStream.processed);
- UInt64 packSize = seqSizeOutStream.processed;
-
- buf[0] = 0;
- buf[1] = 0;
- buf[2] = 0;
- buf[3] = 0;
-
- SeqCheckInStream_GetDigest(&checkInStream, buf + 4);
- RINOK(WriteBytes(&seqSizeOutStream.vt, buf + (4 - padSize), padSize + XzFlags_GetCheckSize((CXzStreamFlags)props->checkId)));
-
- blockSizes->totalSize = seqSizeOutStream.processed - padSize;
-
- if (!outStream)
- {
- seqSizeOutStream.outBuf = outBufHeader;
- seqSizeOutStream.outBufLimit = XZ_BLOCK_HEADER_SIZE_MAX;
- seqSizeOutStream.processed = 0;
-
- block.unpackSize = blockSizes->unpackSize;
- XzBlock_SetHasUnpackSize(&block);
-
- block.packSize = packSize;
- XzBlock_SetHasPackSize(&block);
-
- RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt));
-
- blockSizes->headerSize = (size_t)seqSizeOutStream.processed;
- blockSizes->totalSize += seqSizeOutStream.processed;
- }
- }
-
- if (inStream)
- *inStreamFinished = checkInStream.realStreamFinished;
- else
- {
- *inStreamFinished = False;
- if (checkInStream.processed != inBufSize)
- return SZ_ERROR_FAIL;
- }
-
- return SZ_OK;
-}
-
-
-
-typedef struct
-{
- ICompressProgress vt;
- ICompressProgress *progress;
- UInt64 inOffset;
- UInt64 outOffset;
-} CCompressProgress_XzEncOffset;
-
-
-static SRes CompressProgress_XzEncOffset_Progress(const ICompressProgress *pp, UInt64 inSize, UInt64 outSize)
-{
- const CCompressProgress_XzEncOffset *p = CONTAINER_FROM_VTBL(pp, CCompressProgress_XzEncOffset, vt);
- inSize += p->inOffset;
- outSize += p->outOffset;
- return ICompressProgress_Progress(p->progress, inSize, outSize);
-}
-
-
-
-
-typedef struct
-{
- ISzAllocPtr alloc;
- ISzAllocPtr allocBig;
-
- CXzProps xzProps;
- UInt64 expectedDataSize;
-
- CXzEncIndex xzIndex;
-
- CLzma2WithFilters lzmaf_Items[MTCODER__THREADS_MAX];
-
- size_t outBufSize; /* size of allocated outBufs[i] */
- Byte *outBufs[MTCODER__BLOCKS_MAX];
-
- #ifndef _7ZIP_ST
- unsigned checkType;
- ISeqOutStream *outStream;
- BoolInt mtCoder_WasConstructed;
- CMtCoder mtCoder;
- CXzEncBlockInfo EncBlocks[MTCODER__BLOCKS_MAX];
- #endif
-
-} CXzEnc;
-
-
-static void XzEnc_Construct(CXzEnc *p)
-{
- unsigned i;
-
- XzEncIndex_Construct(&p->xzIndex);
-
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- Lzma2WithFilters_Construct(&p->lzmaf_Items[i]);
-
- #ifndef _7ZIP_ST
- p->mtCoder_WasConstructed = False;
- {
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- p->outBufs[i] = NULL;
- p->outBufSize = 0;
- }
- #endif
-}
-
-
-static void XzEnc_FreeOutBufs(CXzEnc *p)
-{
- unsigned i;
- for (i = 0; i < MTCODER__BLOCKS_MAX; i++)
- if (p->outBufs[i])
- {
- ISzAlloc_Free(p->alloc, p->outBufs[i]);
- p->outBufs[i] = NULL;
- }
- p->outBufSize = 0;
-}
-
-
-static void XzEnc_Free(CXzEnc *p, ISzAllocPtr alloc)
-{
- unsigned i;
-
- XzEncIndex_Free(&p->xzIndex, alloc);
-
- for (i = 0; i < MTCODER__THREADS_MAX; i++)
- Lzma2WithFilters_Free(&p->lzmaf_Items[i], alloc);
-
- #ifndef _7ZIP_ST
- if (p->mtCoder_WasConstructed)
- {
- MtCoder_Destruct(&p->mtCoder);
- p->mtCoder_WasConstructed = False;
- }
- XzEnc_FreeOutBufs(p);
- #endif
-}
-
-
-CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
-{
- CXzEnc *p = (CXzEnc *)ISzAlloc_Alloc(alloc, sizeof(CXzEnc));
- if (!p)
- return NULL;
- XzEnc_Construct(p);
- XzProps_Init(&p->xzProps);
- XzProps_Normalize(&p->xzProps);
- p->expectedDataSize = (UInt64)(Int64)-1;
- p->alloc = alloc;
- p->allocBig = allocBig;
- return p;
-}
-
-
-void XzEnc_Destroy(CXzEncHandle pp)
-{
- CXzEnc *p = (CXzEnc *)pp;
- XzEnc_Free(p, p->alloc);
- ISzAlloc_Free(p->alloc, p);
-}
-
-
-SRes XzEnc_SetProps(CXzEncHandle pp, const CXzProps *props)
-{
- CXzEnc *p = (CXzEnc *)pp;
- p->xzProps = *props;
- XzProps_Normalize(&p->xzProps);
- return SZ_OK;
-}
-
-
-void XzEnc_SetDataSize(CXzEncHandle pp, UInt64 expectedDataSiize)
-{
- CXzEnc *p = (CXzEnc *)pp;
- p->expectedDataSize = expectedDataSiize;
-}
-
-
-
-
-#ifndef _7ZIP_ST
-
-static SRes XzEnc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,
- const Byte *src, size_t srcSize, int finished)
-{
- CXzEnc *me = (CXzEnc *)pp;
- SRes res;
- CMtProgressThunk progressThunk;
-
- Byte *dest = me->outBufs[outBufIndex];
-
- UNUSED_VAR(finished)
-
- {
- CXzEncBlockInfo *bInfo = &me->EncBlocks[outBufIndex];
- bInfo->totalSize = 0;
- bInfo->unpackSize = 0;
- bInfo->headerSize = 0;
- }
-
- if (!dest)
- {
- dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
- if (!dest)
- return SZ_ERROR_MEM;
- me->outBufs[outBufIndex] = dest;
- }
-
- MtProgressThunk_CreateVTable(&progressThunk);
- progressThunk.mtProgress = &me->mtCoder.mtProgress;
- MtProgressThunk_Init(&progressThunk);
-
- {
- CXzEncBlockInfo blockSizes;
- int inStreamFinished;
-
- res = Xz_CompressBlock(
- &me->lzmaf_Items[coderIndex],
-
- NULL,
- dest,
- dest + XZ_BLOCK_HEADER_SIZE_MAX, me->outBufSize - XZ_BLOCK_HEADER_SIZE_MAX,
-
- NULL,
- // srcSize, // expectedSize
- src, srcSize,
-
- &me->xzProps,
- &progressThunk.vt,
- &inStreamFinished,
- &blockSizes,
- me->alloc,
- me->allocBig);
-
- if (res == SZ_OK)
- me->EncBlocks[outBufIndex] = blockSizes;
-
- return res;
- }
-}
-
-
-static SRes XzEnc_MtCallback_Write(void *pp, unsigned outBufIndex)
-{
- CXzEnc *me = (CXzEnc *)pp;
-
- const CXzEncBlockInfo *bInfo = &me->EncBlocks[outBufIndex];
- const Byte *data = me->outBufs[outBufIndex];
-
- RINOK(WriteBytes(me->outStream, data, bInfo->headerSize));
-
- {
- UInt64 totalPackFull = bInfo->totalSize + XZ_GET_PAD_SIZE(bInfo->totalSize);
- RINOK(WriteBytes(me->outStream, data + XZ_BLOCK_HEADER_SIZE_MAX, (size_t)totalPackFull - bInfo->headerSize));
- }
-
- return XzEncIndex_AddIndexRecord(&me->xzIndex, bInfo->unpackSize, bInfo->totalSize, me->alloc);
-}
-
-#endif
-
-
-
-SRes XzEnc_Encode(CXzEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress)
-{
- CXzEnc *p = (CXzEnc *)pp;
-
- const CXzProps *props = &p->xzProps;
-
- XzEncIndex_Init(&p->xzIndex);
- {
- UInt64 numBlocks = 1;
- UInt64 blockSize = props->blockSize;
-
- if (blockSize != XZ_PROPS__BLOCK_SIZE__SOLID
- && props->reduceSize != (UInt64)(Int64)-1)
- {
- numBlocks = props->reduceSize / blockSize;
- if (numBlocks * blockSize != props->reduceSize)
- numBlocks++;
- }
- else
- blockSize = (UInt64)1 << 62;
-
- RINOK(XzEncIndex_PreAlloc(&p->xzIndex, numBlocks, blockSize, XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(blockSize), p->alloc));
- }
-
- RINOK(Xz_WriteHeader((CXzStreamFlags)props->checkId, outStream));
-
-
- #ifndef _7ZIP_ST
- if (props->numBlockThreads_Reduced > 1)
- {
- IMtCoderCallback2 vt;
-
- if (!p->mtCoder_WasConstructed)
- {
- p->mtCoder_WasConstructed = True;
- MtCoder_Construct(&p->mtCoder);
- }
-
- vt.Code = XzEnc_MtCallback_Code;
- vt.Write = XzEnc_MtCallback_Write;
-
- p->checkType = props->checkId;
- p->xzProps = *props;
-
- p->outStream = outStream;
-
- p->mtCoder.allocBig = p->allocBig;
- p->mtCoder.progress = progress;
- p->mtCoder.inStream = inStream;
- p->mtCoder.inData = NULL;
- p->mtCoder.inDataSize = 0;
- p->mtCoder.mtCallback = &vt;
- p->mtCoder.mtCallbackObject = p;
-
- if ( props->blockSize == XZ_PROPS__BLOCK_SIZE__SOLID
- || props->blockSize == XZ_PROPS__BLOCK_SIZE__AUTO)
- return SZ_ERROR_FAIL;
-
- p->mtCoder.blockSize = (size_t)props->blockSize;
- if (p->mtCoder.blockSize != props->blockSize)
- return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
-
- {
- size_t destBlockSize = XZ_BLOCK_HEADER_SIZE_MAX + XZ_GET_MAX_BLOCK_PACK_SIZE(p->mtCoder.blockSize);
- if (destBlockSize < p->mtCoder.blockSize)
- return SZ_ERROR_PARAM;
- if (p->outBufSize != destBlockSize)
- XzEnc_FreeOutBufs(p);
- p->outBufSize = destBlockSize;
- }
-
- p->mtCoder.numThreadsMax = props->numBlockThreads_Max;
- p->mtCoder.expectedDataSize = p->expectedDataSize;
-
- RINOK(MtCoder_Code(&p->mtCoder));
- }
- else
- #endif
- {
- int writeStartSizes;
- CCompressProgress_XzEncOffset progress2;
- Byte *bufData = NULL;
- size_t bufSize = 0;
-
- progress2.vt.Progress = CompressProgress_XzEncOffset_Progress;
- progress2.inOffset = 0;
- progress2.outOffset = 0;
- progress2.progress = progress;
-
- writeStartSizes = 0;
-
- if (props->blockSize != XZ_PROPS__BLOCK_SIZE__SOLID)
- {
- writeStartSizes = (props->forceWriteSizesInHeader > 0);
-
- if (writeStartSizes)
- {
- size_t t2;
- size_t t = (size_t)props->blockSize;
- if (t != props->blockSize)
- return SZ_ERROR_PARAM;
- t = XZ_GET_MAX_BLOCK_PACK_SIZE(t);
- if (t < props->blockSize)
- return SZ_ERROR_PARAM;
- t2 = XZ_BLOCK_HEADER_SIZE_MAX + t;
- if (!p->outBufs[0] || t2 != p->outBufSize)
- {
- XzEnc_FreeOutBufs(p);
- p->outBufs[0] = (Byte *)ISzAlloc_Alloc(p->alloc, t2);
- if (!p->outBufs[0])
- return SZ_ERROR_MEM;
- p->outBufSize = t2;
- }
- bufData = p->outBufs[0] + XZ_BLOCK_HEADER_SIZE_MAX;
- bufSize = t;
- }
- }
-
- for (;;)
- {
- CXzEncBlockInfo blockSizes;
- int inStreamFinished;
-
- /*
- UInt64 rem = (UInt64)(Int64)-1;
- if (props->reduceSize != (UInt64)(Int64)-1
- && props->reduceSize >= progress2.inOffset)
- rem = props->reduceSize - progress2.inOffset;
- */
-
- blockSizes.headerSize = 0; // for GCC
-
- RINOK(Xz_CompressBlock(
- &p->lzmaf_Items[0],
-
- writeStartSizes ? NULL : outStream,
- writeStartSizes ? p->outBufs[0] : NULL,
- bufData, bufSize,
-
- inStream,
- // rem,
- NULL, 0,
-
- props,
- progress ? &progress2.vt : NULL,
- &inStreamFinished,
- &blockSizes,
- p->alloc,
- p->allocBig));
-
- {
- UInt64 totalPackFull = blockSizes.totalSize + XZ_GET_PAD_SIZE(blockSizes.totalSize);
-
- if (writeStartSizes)
- {
- RINOK(WriteBytes(outStream, p->outBufs[0], blockSizes.headerSize));
- RINOK(WriteBytes(outStream, bufData, (size_t)totalPackFull - blockSizes.headerSize));
- }
-
- RINOK(XzEncIndex_AddIndexRecord(&p->xzIndex, blockSizes.unpackSize, blockSizes.totalSize, p->alloc));
-
- progress2.inOffset += blockSizes.unpackSize;
- progress2.outOffset += totalPackFull;
- }
-
- if (inStreamFinished)
- break;
- }
- }
-
- return XzEncIndex_WriteFooter(&p->xzIndex, (CXzStreamFlags)props->checkId, outStream);
-}
-
-
-#include "Alloc.h"
-
-SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
- const CXzProps *props, ICompressProgress *progress)
-{
- SRes res;
- CXzEncHandle xz = XzEnc_Create(&g_Alloc, &g_BigAlloc);
- if (!xz)
- return SZ_ERROR_MEM;
- res = XzEnc_SetProps(xz, props);
- if (res == SZ_OK)
- res = XzEnc_Encode(xz, outStream, inStream, progress);
- XzEnc_Destroy(xz);
- return res;
-}
-
-
-SRes Xz_EncodeEmpty(ISeqOutStream *outStream)
-{
- SRes res;
- CXzEncIndex xzIndex;
- XzEncIndex_Construct(&xzIndex);
- res = Xz_WriteHeader((CXzStreamFlags)0, outStream);
- if (res == SZ_OK)
- res = XzEncIndex_WriteFooter(&xzIndex, (CXzStreamFlags)0, outStream);
- XzEncIndex_Free(&xzIndex, NULL); // g_Alloc
- return res;
-}
+/* XzEnc.c -- Xz Encode
+2023-04-13 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "7zCrc.h"
+#include "Bra.h"
+#include "CpuArch.h"
+
+#ifdef USE_SUBBLOCK
+#include "Bcj3Enc.c"
+#include "SbFind.c"
+#include "SbEnc.c"
+#endif
+
+#include "XzEnc.h"
+
+// #define Z7_ST
+
+#ifndef Z7_ST
+#include "MtCoder.h"
+#else
+#define MTCODER_THREADS_MAX 1
+#define MTCODER_BLOCKS_MAX 1
+#endif
+
+#define XZ_GET_PAD_SIZE(dataSize) ((4 - ((unsigned)(dataSize) & 3)) & 3)
+
+/* max pack size for LZMA2 block + check-64bytrs: */
+#define XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize) ((unpackSize) + ((unpackSize) >> 10) + 16 + 64)
+
+#define XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(unpackSize) (XZ_BLOCK_HEADER_SIZE_MAX + XZ_GET_MAX_BLOCK_PACK_SIZE(unpackSize))
+
+
+// #define XzBlock_ClearFlags(p) (p)->flags = 0;
+#define XzBlock_ClearFlags_SetNumFilters(p, n) (p)->flags = (Byte)((n) - 1);
+#define XzBlock_SetHasPackSize(p) (p)->flags |= XZ_BF_PACK_SIZE;
+#define XzBlock_SetHasUnpackSize(p) (p)->flags |= XZ_BF_UNPACK_SIZE;
+
+
+static SRes WriteBytes(ISeqOutStreamPtr s, const void *buf, size_t size)
+{
+ return (ISeqOutStream_Write(s, buf, size) == size) ? SZ_OK : SZ_ERROR_WRITE;
+}
+
+static SRes WriteBytes_UpdateCrc(ISeqOutStreamPtr s, const void *buf, size_t size, UInt32 *crc)
+{
+ *crc = CrcUpdate(*crc, buf, size);
+ return WriteBytes(s, buf, size);
+}
+
+
+static SRes Xz_WriteHeader(CXzStreamFlags f, ISeqOutStreamPtr s)
+{
+ UInt32 crc;
+ Byte header[XZ_STREAM_HEADER_SIZE];
+ memcpy(header, XZ_SIG, XZ_SIG_SIZE);
+ header[XZ_SIG_SIZE] = (Byte)(f >> 8);
+ header[XZ_SIG_SIZE + 1] = (Byte)(f & 0xFF);
+ crc = CrcCalc(header + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE);
+ SetUi32(header + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE, crc)
+ return WriteBytes(s, header, XZ_STREAM_HEADER_SIZE);
+}
+
+
+static SRes XzBlock_WriteHeader(const CXzBlock *p, ISeqOutStreamPtr s)
+{
+ Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
+
+ unsigned pos = 1;
+ unsigned numFilters, i;
+ header[pos++] = p->flags;
+
+ if (XzBlock_HasPackSize(p)) pos += Xz_WriteVarInt(header + pos, p->packSize);
+ if (XzBlock_HasUnpackSize(p)) pos += Xz_WriteVarInt(header + pos, p->unpackSize);
+ numFilters = XzBlock_GetNumFilters(p);
+
+ for (i = 0; i < numFilters; i++)
+ {
+ const CXzFilter *f = &p->filters[i];
+ pos += Xz_WriteVarInt(header + pos, f->id);
+ pos += Xz_WriteVarInt(header + pos, f->propsSize);
+ memcpy(header + pos, f->props, f->propsSize);
+ pos += f->propsSize;
+ }
+
+ while ((pos & 3) != 0)
+ header[pos++] = 0;
+
+ header[0] = (Byte)(pos >> 2);
+ SetUi32(header + pos, CrcCalc(header, pos))
+ return WriteBytes(s, header, pos + 4);
+}
+
+
+
+
+typedef struct
+{
+ size_t numBlocks;
+ size_t size;
+ size_t allocated;
+ Byte *blocks;
+} CXzEncIndex;
+
+
+static void XzEncIndex_Construct(CXzEncIndex *p)
+{
+ p->numBlocks = 0;
+ p->size = 0;
+ p->allocated = 0;
+ p->blocks = NULL;
+}
+
+static void XzEncIndex_Init(CXzEncIndex *p)
+{
+ p->numBlocks = 0;
+ p->size = 0;
+}
+
+static void XzEncIndex_Free(CXzEncIndex *p, ISzAllocPtr alloc)
+{
+ if (p->blocks)
+ {
+ ISzAlloc_Free(alloc, p->blocks);
+ p->blocks = NULL;
+ }
+ p->numBlocks = 0;
+ p->size = 0;
+ p->allocated = 0;
+}
+
+
+static SRes XzEncIndex_ReAlloc(CXzEncIndex *p, size_t newSize, ISzAllocPtr alloc)
+{
+ Byte *blocks = (Byte *)ISzAlloc_Alloc(alloc, newSize);
+ if (!blocks)
+ return SZ_ERROR_MEM;
+ if (p->size != 0)
+ memcpy(blocks, p->blocks, p->size);
+ if (p->blocks)
+ ISzAlloc_Free(alloc, p->blocks);
+ p->blocks = blocks;
+ p->allocated = newSize;
+ return SZ_OK;
+}
+
+
+static SRes XzEncIndex_PreAlloc(CXzEncIndex *p, UInt64 numBlocks, UInt64 unpackSize, UInt64 totalSize, ISzAllocPtr alloc)
+{
+ UInt64 pos;
+ {
+ Byte buf[32];
+ unsigned pos2 = Xz_WriteVarInt(buf, totalSize);
+ pos2 += Xz_WriteVarInt(buf + pos2, unpackSize);
+ pos = numBlocks * pos2;
+ }
+
+ if (pos <= p->allocated - p->size)
+ return SZ_OK;
+ {
+ UInt64 newSize64 = p->size + pos;
+ size_t newSize = (size_t)newSize64;
+ if (newSize != newSize64)
+ return SZ_ERROR_MEM;
+ return XzEncIndex_ReAlloc(p, newSize, alloc);
+ }
+}
+
+
+static SRes XzEncIndex_AddIndexRecord(CXzEncIndex *p, UInt64 unpackSize, UInt64 totalSize, ISzAllocPtr alloc)
+{
+ Byte buf[32];
+ unsigned pos = Xz_WriteVarInt(buf, totalSize);
+ pos += Xz_WriteVarInt(buf + pos, unpackSize);
+
+ if (pos > p->allocated - p->size)
+ {
+ size_t newSize = p->allocated * 2 + 16 * 2;
+ if (newSize < p->size + pos)
+ return SZ_ERROR_MEM;
+ RINOK(XzEncIndex_ReAlloc(p, newSize, alloc))
+ }
+ memcpy(p->blocks + p->size, buf, pos);
+ p->size += pos;
+ p->numBlocks++;
+ return SZ_OK;
+}
+
+
+static SRes XzEncIndex_WriteFooter(const CXzEncIndex *p, CXzStreamFlags flags, ISeqOutStreamPtr s)
+{
+ Byte buf[32];
+ UInt64 globalPos;
+ UInt32 crc = CRC_INIT_VAL;
+ unsigned pos = 1 + Xz_WriteVarInt(buf + 1, p->numBlocks);
+
+ globalPos = pos;
+ buf[0] = 0;
+ RINOK(WriteBytes_UpdateCrc(s, buf, pos, &crc))
+ RINOK(WriteBytes_UpdateCrc(s, p->blocks, p->size, &crc))
+ globalPos += p->size;
+
+ pos = XZ_GET_PAD_SIZE(globalPos);
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+ globalPos += pos;
+
+ crc = CrcUpdate(crc, buf + 4 - pos, pos);
+ SetUi32(buf + 4, CRC_GET_DIGEST(crc))
+
+ SetUi32(buf + 8 + 4, (UInt32)(globalPos >> 2))
+ buf[8 + 8] = (Byte)(flags >> 8);
+ buf[8 + 9] = (Byte)(flags & 0xFF);
+ SetUi32(buf + 8, CrcCalc(buf + 8 + 4, 6))
+ buf[8 + 10] = XZ_FOOTER_SIG_0;
+ buf[8 + 11] = XZ_FOOTER_SIG_1;
+
+ return WriteBytes(s, buf + 4 - pos, pos + 4 + 12);
+}
+
+
+
+/* ---------- CSeqCheckInStream ---------- */
+
+typedef struct
+{
+ ISeqInStream vt;
+ ISeqInStreamPtr realStream;
+ const Byte *data;
+ UInt64 limit;
+ UInt64 processed;
+ int realStreamFinished;
+ CXzCheck check;
+} CSeqCheckInStream;
+
+static void SeqCheckInStream_Init(CSeqCheckInStream *p, unsigned checkMode)
+{
+ p->limit = (UInt64)(Int64)-1;
+ p->processed = 0;
+ p->realStreamFinished = 0;
+ XzCheck_Init(&p->check, checkMode);
+}
+
+static void SeqCheckInStream_GetDigest(CSeqCheckInStream *p, Byte *digest)
+{
+ XzCheck_Final(&p->check, digest);
+}
+
+static SRes SeqCheckInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqCheckInStream)
+ size_t size2 = *size;
+ SRes res = SZ_OK;
+
+ if (p->limit != (UInt64)(Int64)-1)
+ {
+ UInt64 rem = p->limit - p->processed;
+ if (size2 > rem)
+ size2 = (size_t)rem;
+ }
+ if (size2 != 0)
+ {
+ if (p->realStream)
+ {
+ res = ISeqInStream_Read(p->realStream, data, &size2);
+ p->realStreamFinished = (size2 == 0) ? 1 : 0;
+ }
+ else
+ memcpy(data, p->data + (size_t)p->processed, size2);
+ XzCheck_Update(&p->check, data, size2);
+ p->processed += size2;
+ }
+ *size = size2;
+ return res;
+}
+
+
+/* ---------- CSeqSizeOutStream ---------- */
+
+typedef struct
+{
+ ISeqOutStream vt;
+ ISeqOutStreamPtr realStream;
+ Byte *outBuf;
+ size_t outBufLimit;
+ UInt64 processed;
+} CSeqSizeOutStream;
+
+static size_t SeqSizeOutStream_Write(ISeqOutStreamPtr pp, const void *data, size_t size)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqSizeOutStream)
+ if (p->realStream)
+ size = ISeqOutStream_Write(p->realStream, data, size);
+ else
+ {
+ if (size > p->outBufLimit - (size_t)p->processed)
+ return 0;
+ memcpy(p->outBuf + (size_t)p->processed, data, size);
+ }
+ p->processed += size;
+ return size;
+}
+
+
+/* ---------- CSeqInFilter ---------- */
+
+#define FILTER_BUF_SIZE (1 << 20)
+
+typedef struct
+{
+ ISeqInStream vt;
+ ISeqInStreamPtr realStream;
+ IStateCoder StateCoder;
+ Byte *buf;
+ size_t curPos;
+ size_t endPos;
+ int srcWasFinished;
+} CSeqInFilter;
+
+
+static const z7_Func_BranchConv g_Funcs_BranchConv_RISC_Enc[] =
+{
+ Z7_BRANCH_CONV_ENC(PPC),
+ Z7_BRANCH_CONV_ENC(IA64),
+ Z7_BRANCH_CONV_ENC(ARM),
+ Z7_BRANCH_CONV_ENC(ARMT),
+ Z7_BRANCH_CONV_ENC(SPARC),
+ Z7_BRANCH_CONV_ENC(ARM64)
+};
+
+static SizeT XzBcFilterStateBase_Filter_Enc(CXzBcFilterStateBase *p, Byte *data, SizeT size)
+{
+ switch (p->methodId)
+ {
+ case XZ_ID_Delta:
+ Delta_Encode(p->delta_State, p->delta, data, size);
+ break;
+ case XZ_ID_X86:
+ size = (SizeT)(z7_BranchConvSt_X86_Enc(data, size, p->ip, &p->X86_State) - data);
+ break;
+ default:
+ if (p->methodId >= XZ_ID_PPC)
+ {
+ const UInt32 i = p->methodId - XZ_ID_PPC;
+ if (i < Z7_ARRAY_SIZE(g_Funcs_BranchConv_RISC_Enc))
+ size = (SizeT)(g_Funcs_BranchConv_RISC_Enc[i](data, size, p->ip) - data);
+ }
+ break;
+ }
+ p->ip += (UInt32)size;
+ return size;
+}
+
+
+static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props, ISzAllocPtr alloc)
+{
+ if (!p->buf)
+ {
+ p->buf = (Byte *)ISzAlloc_Alloc(alloc, FILTER_BUF_SIZE);
+ if (!p->buf)
+ return SZ_ERROR_MEM;
+ }
+ p->curPos = p->endPos = 0;
+ p->srcWasFinished = 0;
+ RINOK(Xz_StateCoder_Bc_SetFromMethod_Func(&p->StateCoder, props->id, XzBcFilterStateBase_Filter_Enc, alloc))
+ RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, alloc))
+ p->StateCoder.Init(p->StateCoder.p);
+ return SZ_OK;
+}
+
+
+static SRes SeqInFilter_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqInFilter)
+ const size_t sizeOriginal = *size;
+ if (sizeOriginal == 0)
+ return SZ_OK;
+ *size = 0;
+
+ for (;;)
+ {
+ if (!p->srcWasFinished && p->curPos == p->endPos)
+ {
+ p->curPos = 0;
+ p->endPos = FILTER_BUF_SIZE;
+ RINOK(ISeqInStream_Read(p->realStream, p->buf, &p->endPos))
+ if (p->endPos == 0)
+ p->srcWasFinished = 1;
+ }
+ {
+ SizeT srcLen = p->endPos - p->curPos;
+ ECoderStatus status;
+ SRes res;
+ *size = sizeOriginal;
+ res = p->StateCoder.Code2(p->StateCoder.p,
+ (Byte *)data, size,
+ p->buf + p->curPos, &srcLen,
+ p->srcWasFinished, CODER_FINISH_ANY,
+ &status);
+ p->curPos += srcLen;
+ if (*size != 0 || srcLen == 0 || res != SZ_OK)
+ return res;
+ }
+ }
+}
+
+static void SeqInFilter_Construct(CSeqInFilter *p)
+{
+ p->buf = NULL;
+ p->StateCoder.p = NULL;
+ p->vt.Read = SeqInFilter_Read;
+}
+
+static void SeqInFilter_Free(CSeqInFilter *p, ISzAllocPtr alloc)
+{
+ if (p->StateCoder.p)
+ {
+ p->StateCoder.Free(p->StateCoder.p, alloc);
+ p->StateCoder.p = NULL;
+ }
+ if (p->buf)
+ {
+ ISzAlloc_Free(alloc, p->buf);
+ p->buf = NULL;
+ }
+}
+
+
+/* ---------- CSbEncInStream ---------- */
+
+#ifdef USE_SUBBLOCK
+
+typedef struct
+{
+ ISeqInStream vt;
+ ISeqInStreamPtr inStream;
+ CSbEnc enc;
+} CSbEncInStream;
+
+static SRes SbEncInStream_Read(ISeqInStreamPtr pp, void *data, size_t *size)
+{
+ CSbEncInStream *p = Z7_CONTAINER_FROM_VTBL(pp, CSbEncInStream, vt);
+ size_t sizeOriginal = *size;
+ if (sizeOriginal == 0)
+ return SZ_OK;
+
+ for (;;)
+ {
+ if (p->enc.needRead && !p->enc.readWasFinished)
+ {
+ size_t processed = p->enc.needReadSizeMax;
+ RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed))
+ p->enc.readPos += processed;
+ if (processed == 0)
+ {
+ p->enc.readWasFinished = True;
+ p->enc.isFinalFinished = True;
+ }
+ p->enc.needRead = False;
+ }
+
+ *size = sizeOriginal;
+ RINOK(SbEnc_Read(&p->enc, data, size))
+ if (*size != 0 || !p->enc.needRead)
+ return SZ_OK;
+ }
+}
+
+void SbEncInStream_Construct(CSbEncInStream *p, ISzAllocPtr alloc)
+{
+ SbEnc_Construct(&p->enc, alloc);
+ p->vt.Read = SbEncInStream_Read;
+}
+
+SRes SbEncInStream_Init(CSbEncInStream *p)
+{
+ return SbEnc_Init(&p->enc);
+}
+
+void SbEncInStream_Free(CSbEncInStream *p)
+{
+ SbEnc_Free(&p->enc);
+}
+
+#endif
+
+
+
+/* ---------- CXzProps ---------- */
+
+
+void XzFilterProps_Init(CXzFilterProps *p)
+{
+ p->id = 0;
+ p->delta = 0;
+ p->ip = 0;
+ p->ipDefined = False;
+}
+
+void XzProps_Init(CXzProps *p)
+{
+ p->checkId = XZ_CHECK_CRC32;
+ p->blockSize = XZ_PROPS_BLOCK_SIZE_AUTO;
+ p->numBlockThreads_Reduced = -1;
+ p->numBlockThreads_Max = -1;
+ p->numTotalThreads = -1;
+ p->reduceSize = (UInt64)(Int64)-1;
+ p->forceWriteSizesInHeader = 0;
+ // p->forceWriteSizesInHeader = 1;
+
+ XzFilterProps_Init(&p->filterProps);
+ Lzma2EncProps_Init(&p->lzma2Props);
+}
+
+
+static void XzEncProps_Normalize_Fixed(CXzProps *p)
+{
+ UInt64 fileSize;
+ int t1, t1n, t2, t2r, t3;
+ {
+ CLzma2EncProps tp = p->lzma2Props;
+ if (tp.numTotalThreads <= 0)
+ tp.numTotalThreads = p->numTotalThreads;
+ Lzma2EncProps_Normalize(&tp);
+ t1n = tp.numTotalThreads;
+ }
+
+ t1 = p->lzma2Props.numTotalThreads;
+ t2 = p->numBlockThreads_Max;
+ t3 = p->numTotalThreads;
+
+ if (t2 > MTCODER_THREADS_MAX)
+ t2 = MTCODER_THREADS_MAX;
+
+ if (t3 <= 0)
+ {
+ if (t2 <= 0)
+ t2 = 1;
+ t3 = t1n * t2;
+ }
+ else if (t2 <= 0)
+ {
+ t2 = t3 / t1n;
+ if (t2 == 0)
+ {
+ t1 = 1;
+ t2 = t3;
+ }
+ if (t2 > MTCODER_THREADS_MAX)
+ t2 = MTCODER_THREADS_MAX;
+ }
+ else if (t1 <= 0)
+ {
+ t1 = t3 / t2;
+ if (t1 == 0)
+ t1 = 1;
+ }
+ else
+ t3 = t1n * t2;
+
+ p->lzma2Props.numTotalThreads = t1;
+
+ t2r = t2;
+
+ fileSize = p->reduceSize;
+
+ if ((p->blockSize < fileSize || fileSize == (UInt64)(Int64)-1))
+ p->lzma2Props.lzmaProps.reduceSize = p->blockSize;
+
+ Lzma2EncProps_Normalize(&p->lzma2Props);
+
+ t1 = p->lzma2Props.numTotalThreads;
+
+ {
+ if (t2 > 1 && fileSize != (UInt64)(Int64)-1)
+ {
+ UInt64 numBlocks = fileSize / p->blockSize;
+ if (numBlocks * p->blockSize != fileSize)
+ numBlocks++;
+ if (numBlocks < (unsigned)t2)
+ {
+ t2r = (int)numBlocks;
+ if (t2r == 0)
+ t2r = 1;
+ t3 = t1 * t2r;
+ }
+ }
+ }
+
+ p->numBlockThreads_Max = t2;
+ p->numBlockThreads_Reduced = t2r;
+ p->numTotalThreads = t3;
+}
+
+
+static void XzProps_Normalize(CXzProps *p)
+{
+ /* we normalize xzProps properties, but we normalize only some of CXzProps::lzma2Props properties.
+ Lzma2Enc_SetProps() will normalize lzma2Props later. */
+
+ if (p->blockSize == XZ_PROPS_BLOCK_SIZE_SOLID)
+ {
+ p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
+ p->numBlockThreads_Reduced = 1;
+ p->numBlockThreads_Max = 1;
+ if (p->lzma2Props.numTotalThreads <= 0)
+ p->lzma2Props.numTotalThreads = p->numTotalThreads;
+ return;
+ }
+ else
+ {
+ CLzma2EncProps *lzma2 = &p->lzma2Props;
+ if (p->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
+ {
+ // xz-auto
+ p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
+
+ if (lzma2->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+ {
+ // if (xz-auto && lzma2-solid) - we use solid for both
+ p->blockSize = XZ_PROPS_BLOCK_SIZE_SOLID;
+ p->numBlockThreads_Reduced = 1;
+ p->numBlockThreads_Max = 1;
+ if (p->lzma2Props.numTotalThreads <= 0)
+ p->lzma2Props.numTotalThreads = p->numTotalThreads;
+ }
+ else
+ {
+ // if (xz-auto && (lzma2-auto || lzma2-fixed_)
+ // we calculate block size for lzma2 and use that block size for xz, lzma2 uses single-chunk per block
+ CLzma2EncProps tp = p->lzma2Props;
+ if (tp.numTotalThreads <= 0)
+ tp.numTotalThreads = p->numTotalThreads;
+
+ Lzma2EncProps_Normalize(&tp);
+
+ p->blockSize = tp.blockSize; // fixed or solid
+ p->numBlockThreads_Reduced = tp.numBlockThreads_Reduced;
+ p->numBlockThreads_Max = tp.numBlockThreads_Max;
+ if (lzma2->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
+ lzma2->blockSize = tp.blockSize; // fixed or solid, LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+ if (lzma2->lzmaProps.reduceSize > tp.blockSize && tp.blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+ lzma2->lzmaProps.reduceSize = tp.blockSize;
+ lzma2->numBlockThreads_Reduced = 1;
+ lzma2->numBlockThreads_Max = 1;
+ return;
+ }
+ }
+ else
+ {
+ // xz-fixed
+ // we can use xz::reduceSize or xz::blockSize as base for lzmaProps::reduceSize
+
+ p->lzma2Props.lzmaProps.reduceSize = p->reduceSize;
+ {
+ UInt64 r = p->reduceSize;
+ if (r > p->blockSize || r == (UInt64)(Int64)-1)
+ r = p->blockSize;
+ lzma2->lzmaProps.reduceSize = r;
+ }
+ if (lzma2->blockSize == LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO)
+ lzma2->blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID;
+ else if (lzma2->blockSize > p->blockSize && lzma2->blockSize != LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID)
+ lzma2->blockSize = p->blockSize;
+
+ XzEncProps_Normalize_Fixed(p);
+ }
+ }
+}
+
+
+/* ---------- CLzma2WithFilters ---------- */
+
+typedef struct
+{
+ CLzma2EncHandle lzma2;
+ CSeqInFilter filter;
+
+ #ifdef USE_SUBBLOCK
+ CSbEncInStream sb;
+ #endif
+} CLzma2WithFilters;
+
+
+static void Lzma2WithFilters_Construct(CLzma2WithFilters *p)
+{
+ p->lzma2 = NULL;
+ SeqInFilter_Construct(&p->filter);
+
+ #ifdef USE_SUBBLOCK
+ SbEncInStream_Construct(&p->sb, alloc);
+ #endif
+}
+
+
+static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p, ISzAllocPtr alloc, ISzAllocPtr bigAlloc)
+{
+ if (!p->lzma2)
+ {
+ p->lzma2 = Lzma2Enc_Create(alloc, bigAlloc);
+ if (!p->lzma2)
+ return SZ_ERROR_MEM;
+ }
+ return SZ_OK;
+}
+
+
+static void Lzma2WithFilters_Free(CLzma2WithFilters *p, ISzAllocPtr alloc)
+{
+ #ifdef USE_SUBBLOCK
+ SbEncInStream_Free(&p->sb);
+ #endif
+
+ SeqInFilter_Free(&p->filter, alloc);
+ if (p->lzma2)
+ {
+ Lzma2Enc_Destroy(p->lzma2);
+ p->lzma2 = NULL;
+ }
+}
+
+
+typedef struct
+{
+ UInt64 unpackSize;
+ UInt64 totalSize;
+ size_t headerSize;
+} CXzEncBlockInfo;
+
+
+static SRes Xz_CompressBlock(
+ CLzma2WithFilters *lzmaf,
+
+ ISeqOutStreamPtr outStream,
+ Byte *outBufHeader,
+ Byte *outBufData, size_t outBufDataLimit,
+
+ ISeqInStreamPtr inStream,
+ // UInt64 expectedSize,
+ const Byte *inBuf, // used if (!inStream)
+ size_t inBufSize, // used if (!inStream), it's block size, props->blockSize is ignored
+
+ const CXzProps *props,
+ ICompressProgressPtr progress,
+ int *inStreamFinished, /* only for inStream version */
+ CXzEncBlockInfo *blockSizes,
+ ISzAllocPtr alloc,
+ ISzAllocPtr allocBig)
+{
+ CSeqCheckInStream checkInStream;
+ CSeqSizeOutStream seqSizeOutStream;
+ CXzBlock block;
+ unsigned filterIndex = 0;
+ CXzFilter *filter = NULL;
+ const CXzFilterProps *fp = &props->filterProps;
+ if (fp->id == 0)
+ fp = NULL;
+
+ *inStreamFinished = False;
+
+ RINOK(Lzma2WithFilters_Create(lzmaf, alloc, allocBig))
+
+ RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, &props->lzma2Props))
+
+ // XzBlock_ClearFlags(&block)
+ XzBlock_ClearFlags_SetNumFilters(&block, 1 + (fp ? 1 : 0))
+
+ if (fp)
+ {
+ filter = &block.filters[filterIndex++];
+ filter->id = fp->id;
+ filter->propsSize = 0;
+
+ if (fp->id == XZ_ID_Delta)
+ {
+ filter->props[0] = (Byte)(fp->delta - 1);
+ filter->propsSize = 1;
+ }
+ else if (fp->ipDefined)
+ {
+ Byte *ptr = filter->props;
+ SetUi32(ptr, fp->ip)
+ filter->propsSize = 4;
+ }
+ }
+
+ {
+ CXzFilter *f = &block.filters[filterIndex++];
+ f->id = XZ_ID_LZMA2;
+ f->propsSize = 1;
+ f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2);
+ }
+
+ seqSizeOutStream.vt.Write = SeqSizeOutStream_Write;
+ seqSizeOutStream.realStream = outStream;
+ seqSizeOutStream.outBuf = outBufData;
+ seqSizeOutStream.outBufLimit = outBufDataLimit;
+ seqSizeOutStream.processed = 0;
+
+ /*
+ if (expectedSize != (UInt64)(Int64)-1)
+ {
+ block.unpackSize = expectedSize;
+ if (props->blockSize != (UInt64)(Int64)-1)
+ if (expectedSize > props->blockSize)
+ block.unpackSize = props->blockSize;
+ XzBlock_SetHasUnpackSize(&block)
+ }
+ */
+
+ if (outStream)
+ {
+ RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt))
+ }
+
+ checkInStream.vt.Read = SeqCheckInStream_Read;
+ SeqCheckInStream_Init(&checkInStream, props->checkId);
+
+ checkInStream.realStream = inStream;
+ checkInStream.data = inBuf;
+ checkInStream.limit = props->blockSize;
+ if (!inStream)
+ checkInStream.limit = inBufSize;
+
+ if (fp)
+ {
+ #ifdef USE_SUBBLOCK
+ if (fp->id == XZ_ID_Subblock)
+ {
+ lzmaf->sb.inStream = &checkInStream.vt;
+ RINOK(SbEncInStream_Init(&lzmaf->sb))
+ }
+ else
+ #endif
+ {
+ lzmaf->filter.realStream = &checkInStream.vt;
+ RINOK(SeqInFilter_Init(&lzmaf->filter, filter, alloc))
+ }
+ }
+
+ {
+ SRes res;
+ Byte *outBuf = NULL;
+ size_t outSize = 0;
+ BoolInt useStream = (fp || inStream);
+ // useStream = True;
+
+ if (!useStream)
+ {
+ XzCheck_Update(&checkInStream.check, inBuf, inBufSize);
+ checkInStream.processed = inBufSize;
+ }
+
+ if (!outStream)
+ {
+ outBuf = seqSizeOutStream.outBuf; // + (size_t)seqSizeOutStream.processed;
+ outSize = seqSizeOutStream.outBufLimit; // - (size_t)seqSizeOutStream.processed;
+ }
+
+ res = Lzma2Enc_Encode2(lzmaf->lzma2,
+ outBuf ? NULL : &seqSizeOutStream.vt,
+ outBuf,
+ outBuf ? &outSize : NULL,
+
+ useStream ?
+ (fp ?
+ (
+ #ifdef USE_SUBBLOCK
+ (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.vt:
+ #endif
+ &lzmaf->filter.vt) :
+ &checkInStream.vt) : NULL,
+
+ useStream ? NULL : inBuf,
+ useStream ? 0 : inBufSize,
+
+ progress);
+
+ if (outBuf)
+ seqSizeOutStream.processed += outSize;
+
+ RINOK(res)
+ blockSizes->unpackSize = checkInStream.processed;
+ }
+ {
+ Byte buf[4 + 64];
+ unsigned padSize = XZ_GET_PAD_SIZE(seqSizeOutStream.processed);
+ UInt64 packSize = seqSizeOutStream.processed;
+
+ buf[0] = 0;
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+
+ SeqCheckInStream_GetDigest(&checkInStream, buf + 4);
+ RINOK(WriteBytes(&seqSizeOutStream.vt, buf + (4 - padSize), padSize + XzFlags_GetCheckSize((CXzStreamFlags)props->checkId)))
+
+ blockSizes->totalSize = seqSizeOutStream.processed - padSize;
+
+ if (!outStream)
+ {
+ seqSizeOutStream.outBuf = outBufHeader;
+ seqSizeOutStream.outBufLimit = XZ_BLOCK_HEADER_SIZE_MAX;
+ seqSizeOutStream.processed = 0;
+
+ block.unpackSize = blockSizes->unpackSize;
+ XzBlock_SetHasUnpackSize(&block)
+
+ block.packSize = packSize;
+ XzBlock_SetHasPackSize(&block)
+
+ RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.vt))
+
+ blockSizes->headerSize = (size_t)seqSizeOutStream.processed;
+ blockSizes->totalSize += seqSizeOutStream.processed;
+ }
+ }
+
+ if (inStream)
+ *inStreamFinished = checkInStream.realStreamFinished;
+ else
+ {
+ *inStreamFinished = False;
+ if (checkInStream.processed != inBufSize)
+ return SZ_ERROR_FAIL;
+ }
+
+ return SZ_OK;
+}
+
+
+
+typedef struct
+{
+ ICompressProgress vt;
+ ICompressProgressPtr progress;
+ UInt64 inOffset;
+ UInt64 outOffset;
+} CCompressProgress_XzEncOffset;
+
+
+static SRes CompressProgress_XzEncOffset_Progress(ICompressProgressPtr pp, UInt64 inSize, UInt64 outSize)
+{
+ const CCompressProgress_XzEncOffset *p = Z7_CONTAINER_FROM_VTBL_CONST(pp, CCompressProgress_XzEncOffset, vt);
+ inSize += p->inOffset;
+ outSize += p->outOffset;
+ return ICompressProgress_Progress(p->progress, inSize, outSize);
+}
+
+
+
+
+struct CXzEnc
+{
+ ISzAllocPtr alloc;
+ ISzAllocPtr allocBig;
+
+ CXzProps xzProps;
+ UInt64 expectedDataSize;
+
+ CXzEncIndex xzIndex;
+
+ CLzma2WithFilters lzmaf_Items[MTCODER_THREADS_MAX];
+
+ size_t outBufSize; /* size of allocated outBufs[i] */
+ Byte *outBufs[MTCODER_BLOCKS_MAX];
+
+ #ifndef Z7_ST
+ unsigned checkType;
+ ISeqOutStreamPtr outStream;
+ BoolInt mtCoder_WasConstructed;
+ CMtCoder mtCoder;
+ CXzEncBlockInfo EncBlocks[MTCODER_BLOCKS_MAX];
+ #endif
+};
+
+
+static void XzEnc_Construct(CXzEnc *p)
+{
+ unsigned i;
+
+ XzEncIndex_Construct(&p->xzIndex);
+
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ Lzma2WithFilters_Construct(&p->lzmaf_Items[i]);
+
+ #ifndef Z7_ST
+ p->mtCoder_WasConstructed = False;
+ {
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ p->outBufs[i] = NULL;
+ p->outBufSize = 0;
+ }
+ #endif
+}
+
+
+static void XzEnc_FreeOutBufs(CXzEnc *p)
+{
+ unsigned i;
+ for (i = 0; i < MTCODER_BLOCKS_MAX; i++)
+ if (p->outBufs[i])
+ {
+ ISzAlloc_Free(p->alloc, p->outBufs[i]);
+ p->outBufs[i] = NULL;
+ }
+ p->outBufSize = 0;
+}
+
+
+static void XzEnc_Free(CXzEnc *p, ISzAllocPtr alloc)
+{
+ unsigned i;
+
+ XzEncIndex_Free(&p->xzIndex, alloc);
+
+ for (i = 0; i < MTCODER_THREADS_MAX; i++)
+ Lzma2WithFilters_Free(&p->lzmaf_Items[i], alloc);
+
+ #ifndef Z7_ST
+ if (p->mtCoder_WasConstructed)
+ {
+ MtCoder_Destruct(&p->mtCoder);
+ p->mtCoder_WasConstructed = False;
+ }
+ XzEnc_FreeOutBufs(p);
+ #endif
+}
+
+
+CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig)
+{
+ CXzEnc *p = (CXzEnc *)ISzAlloc_Alloc(alloc, sizeof(CXzEnc));
+ if (!p)
+ return NULL;
+ XzEnc_Construct(p);
+ XzProps_Init(&p->xzProps);
+ XzProps_Normalize(&p->xzProps);
+ p->expectedDataSize = (UInt64)(Int64)-1;
+ p->alloc = alloc;
+ p->allocBig = allocBig;
+ return (CXzEncHandle)p;
+}
+
+// #define GET_CXzEnc_p CXzEnc *p = (CXzEnc *)(void *)pp;
+
+void XzEnc_Destroy(CXzEncHandle p)
+{
+ // GET_CXzEnc_p
+ XzEnc_Free(p, p->alloc);
+ ISzAlloc_Free(p->alloc, p);
+}
+
+
+SRes XzEnc_SetProps(CXzEncHandle p, const CXzProps *props)
+{
+ // GET_CXzEnc_p
+ p->xzProps = *props;
+ XzProps_Normalize(&p->xzProps);
+ return SZ_OK;
+}
+
+
+void XzEnc_SetDataSize(CXzEncHandle p, UInt64 expectedDataSiize)
+{
+ // GET_CXzEnc_p
+ p->expectedDataSize = expectedDataSiize;
+}
+
+
+
+
+#ifndef Z7_ST
+
+static SRes XzEnc_MtCallback_Code(void *pp, unsigned coderIndex, unsigned outBufIndex,
+ const Byte *src, size_t srcSize, int finished)
+{
+ CXzEnc *me = (CXzEnc *)pp;
+ SRes res;
+ CMtProgressThunk progressThunk;
+
+ Byte *dest = me->outBufs[outBufIndex];
+
+ UNUSED_VAR(finished)
+
+ {
+ CXzEncBlockInfo *bInfo = &me->EncBlocks[outBufIndex];
+ bInfo->totalSize = 0;
+ bInfo->unpackSize = 0;
+ bInfo->headerSize = 0;
+ }
+
+ if (!dest)
+ {
+ dest = (Byte *)ISzAlloc_Alloc(me->alloc, me->outBufSize);
+ if (!dest)
+ return SZ_ERROR_MEM;
+ me->outBufs[outBufIndex] = dest;
+ }
+
+ MtProgressThunk_CreateVTable(&progressThunk);
+ progressThunk.mtProgress = &me->mtCoder.mtProgress;
+ MtProgressThunk_INIT(&progressThunk)
+
+ {
+ CXzEncBlockInfo blockSizes;
+ int inStreamFinished;
+
+ res = Xz_CompressBlock(
+ &me->lzmaf_Items[coderIndex],
+
+ NULL,
+ dest,
+ dest + XZ_BLOCK_HEADER_SIZE_MAX, me->outBufSize - XZ_BLOCK_HEADER_SIZE_MAX,
+
+ NULL,
+ // srcSize, // expectedSize
+ src, srcSize,
+
+ &me->xzProps,
+ &progressThunk.vt,
+ &inStreamFinished,
+ &blockSizes,
+ me->alloc,
+ me->allocBig);
+
+ if (res == SZ_OK)
+ me->EncBlocks[outBufIndex] = blockSizes;
+
+ return res;
+ }
+}
+
+
+static SRes XzEnc_MtCallback_Write(void *pp, unsigned outBufIndex)
+{
+ CXzEnc *me = (CXzEnc *)pp;
+
+ const CXzEncBlockInfo *bInfo = &me->EncBlocks[outBufIndex];
+ const Byte *data = me->outBufs[outBufIndex];
+
+ RINOK(WriteBytes(me->outStream, data, bInfo->headerSize))
+
+ {
+ UInt64 totalPackFull = bInfo->totalSize + XZ_GET_PAD_SIZE(bInfo->totalSize);
+ RINOK(WriteBytes(me->outStream, data + XZ_BLOCK_HEADER_SIZE_MAX, (size_t)totalPackFull - bInfo->headerSize))
+ }
+
+ return XzEncIndex_AddIndexRecord(&me->xzIndex, bInfo->unpackSize, bInfo->totalSize, me->alloc);
+}
+
+#endif
+
+
+
+SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress)
+{
+ // GET_CXzEnc_p
+
+ const CXzProps *props = &p->xzProps;
+
+ XzEncIndex_Init(&p->xzIndex);
+ {
+ UInt64 numBlocks = 1;
+ UInt64 blockSize = props->blockSize;
+
+ if (blockSize != XZ_PROPS_BLOCK_SIZE_SOLID
+ && props->reduceSize != (UInt64)(Int64)-1)
+ {
+ numBlocks = props->reduceSize / blockSize;
+ if (numBlocks * blockSize != props->reduceSize)
+ numBlocks++;
+ }
+ else
+ blockSize = (UInt64)1 << 62;
+
+ RINOK(XzEncIndex_PreAlloc(&p->xzIndex, numBlocks, blockSize, XZ_GET_ESTIMATED_BLOCK_TOTAL_PACK_SIZE(blockSize), p->alloc))
+ }
+
+ RINOK(Xz_WriteHeader((CXzStreamFlags)props->checkId, outStream))
+
+
+ #ifndef Z7_ST
+ if (props->numBlockThreads_Reduced > 1)
+ {
+ IMtCoderCallback2 vt;
+
+ if (!p->mtCoder_WasConstructed)
+ {
+ p->mtCoder_WasConstructed = True;
+ MtCoder_Construct(&p->mtCoder);
+ }
+
+ vt.Code = XzEnc_MtCallback_Code;
+ vt.Write = XzEnc_MtCallback_Write;
+
+ p->checkType = props->checkId;
+ p->xzProps = *props;
+
+ p->outStream = outStream;
+
+ p->mtCoder.allocBig = p->allocBig;
+ p->mtCoder.progress = progress;
+ p->mtCoder.inStream = inStream;
+ p->mtCoder.inData = NULL;
+ p->mtCoder.inDataSize = 0;
+ p->mtCoder.mtCallback = &vt;
+ p->mtCoder.mtCallbackObject = p;
+
+ if ( props->blockSize == XZ_PROPS_BLOCK_SIZE_SOLID
+ || props->blockSize == XZ_PROPS_BLOCK_SIZE_AUTO)
+ return SZ_ERROR_FAIL;
+
+ p->mtCoder.blockSize = (size_t)props->blockSize;
+ if (p->mtCoder.blockSize != props->blockSize)
+ return SZ_ERROR_PARAM; /* SZ_ERROR_MEM */
+
+ {
+ size_t destBlockSize = XZ_BLOCK_HEADER_SIZE_MAX + XZ_GET_MAX_BLOCK_PACK_SIZE(p->mtCoder.blockSize);
+ if (destBlockSize < p->mtCoder.blockSize)
+ return SZ_ERROR_PARAM;
+ if (p->outBufSize != destBlockSize)
+ XzEnc_FreeOutBufs(p);
+ p->outBufSize = destBlockSize;
+ }
+
+ p->mtCoder.numThreadsMax = (unsigned)props->numBlockThreads_Max;
+ p->mtCoder.expectedDataSize = p->expectedDataSize;
+
+ RINOK(MtCoder_Code(&p->mtCoder))
+ }
+ else
+ #endif
+ {
+ int writeStartSizes;
+ CCompressProgress_XzEncOffset progress2;
+ Byte *bufData = NULL;
+ size_t bufSize = 0;
+
+ progress2.vt.Progress = CompressProgress_XzEncOffset_Progress;
+ progress2.inOffset = 0;
+ progress2.outOffset = 0;
+ progress2.progress = progress;
+
+ writeStartSizes = 0;
+
+ if (props->blockSize != XZ_PROPS_BLOCK_SIZE_SOLID)
+ {
+ writeStartSizes = (props->forceWriteSizesInHeader > 0);
+
+ if (writeStartSizes)
+ {
+ size_t t2;
+ size_t t = (size_t)props->blockSize;
+ if (t != props->blockSize)
+ return SZ_ERROR_PARAM;
+ t = XZ_GET_MAX_BLOCK_PACK_SIZE(t);
+ if (t < props->blockSize)
+ return SZ_ERROR_PARAM;
+ t2 = XZ_BLOCK_HEADER_SIZE_MAX + t;
+ if (!p->outBufs[0] || t2 != p->outBufSize)
+ {
+ XzEnc_FreeOutBufs(p);
+ p->outBufs[0] = (Byte *)ISzAlloc_Alloc(p->alloc, t2);
+ if (!p->outBufs[0])
+ return SZ_ERROR_MEM;
+ p->outBufSize = t2;
+ }
+ bufData = p->outBufs[0] + XZ_BLOCK_HEADER_SIZE_MAX;
+ bufSize = t;
+ }
+ }
+
+ for (;;)
+ {
+ CXzEncBlockInfo blockSizes;
+ int inStreamFinished;
+
+ /*
+ UInt64 rem = (UInt64)(Int64)-1;
+ if (props->reduceSize != (UInt64)(Int64)-1
+ && props->reduceSize >= progress2.inOffset)
+ rem = props->reduceSize - progress2.inOffset;
+ */
+
+ blockSizes.headerSize = 0; // for GCC
+
+ RINOK(Xz_CompressBlock(
+ &p->lzmaf_Items[0],
+
+ writeStartSizes ? NULL : outStream,
+ writeStartSizes ? p->outBufs[0] : NULL,
+ bufData, bufSize,
+
+ inStream,
+ // rem,
+ NULL, 0,
+
+ props,
+ progress ? &progress2.vt : NULL,
+ &inStreamFinished,
+ &blockSizes,
+ p->alloc,
+ p->allocBig))
+
+ {
+ UInt64 totalPackFull = blockSizes.totalSize + XZ_GET_PAD_SIZE(blockSizes.totalSize);
+
+ if (writeStartSizes)
+ {
+ RINOK(WriteBytes(outStream, p->outBufs[0], blockSizes.headerSize))
+ RINOK(WriteBytes(outStream, bufData, (size_t)totalPackFull - blockSizes.headerSize))
+ }
+
+ RINOK(XzEncIndex_AddIndexRecord(&p->xzIndex, blockSizes.unpackSize, blockSizes.totalSize, p->alloc))
+
+ progress2.inOffset += blockSizes.unpackSize;
+ progress2.outOffset += totalPackFull;
+ }
+
+ if (inStreamFinished)
+ break;
+ }
+ }
+
+ return XzEncIndex_WriteFooter(&p->xzIndex, (CXzStreamFlags)props->checkId, outStream);
+}
+
+
+#include "Alloc.h"
+
+SRes Xz_Encode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
+ const CXzProps *props, ICompressProgressPtr progress)
+{
+ SRes res;
+ CXzEncHandle xz = XzEnc_Create(&g_Alloc, &g_BigAlloc);
+ if (!xz)
+ return SZ_ERROR_MEM;
+ res = XzEnc_SetProps(xz, props);
+ if (res == SZ_OK)
+ res = XzEnc_Encode(xz, outStream, inStream, progress);
+ XzEnc_Destroy(xz);
+ return res;
+}
+
+
+SRes Xz_EncodeEmpty(ISeqOutStreamPtr outStream)
+{
+ SRes res;
+ CXzEncIndex xzIndex;
+ XzEncIndex_Construct(&xzIndex);
+ res = Xz_WriteHeader((CXzStreamFlags)0, outStream);
+ if (res == SZ_OK)
+ res = XzEncIndex_WriteFooter(&xzIndex, (CXzStreamFlags)0, outStream);
+ XzEncIndex_Free(&xzIndex, NULL); // g_Alloc
+ return res;
+}
diff --git a/C/XzEnc.h b/C/XzEnc.h
index 529ac3f..77b78c0 100644
--- a/C/XzEnc.h
+++ b/C/XzEnc.h
@@ -1,60 +1,61 @@
-/* XzEnc.h -- Xz Encode
-2017-06-27 : Igor Pavlov : Public domain */
-
-#ifndef __XZ_ENC_H
-#define __XZ_ENC_H
-
-#include "Lzma2Enc.h"
-
-#include "Xz.h"
-
-EXTERN_C_BEGIN
-
-
-#define XZ_PROPS__BLOCK_SIZE__AUTO LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO
-#define XZ_PROPS__BLOCK_SIZE__SOLID LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
-
-
-typedef struct
-{
- UInt32 id;
- UInt32 delta;
- UInt32 ip;
- int ipDefined;
-} CXzFilterProps;
-
-void XzFilterProps_Init(CXzFilterProps *p);
-
-
-typedef struct
-{
- CLzma2EncProps lzma2Props;
- CXzFilterProps filterProps;
- unsigned checkId;
- UInt64 blockSize;
- int numBlockThreads_Reduced;
- int numBlockThreads_Max;
- int numTotalThreads;
- int forceWriteSizesInHeader;
- UInt64 reduceSize;
-} CXzProps;
-
-void XzProps_Init(CXzProps *p);
-
-
-typedef void * CXzEncHandle;
-
-CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
-void XzEnc_Destroy(CXzEncHandle p);
-SRes XzEnc_SetProps(CXzEncHandle p, const CXzProps *props);
-void XzEnc_SetDataSize(CXzEncHandle p, UInt64 expectedDataSiize);
-SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress);
-
-SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
- const CXzProps *props, ICompressProgress *progress);
-
-SRes Xz_EncodeEmpty(ISeqOutStream *outStream);
-
-EXTERN_C_END
-
-#endif
+/* XzEnc.h -- Xz Encode
+2023-04-13 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_XZ_ENC_H
+#define ZIP7_INC_XZ_ENC_H
+
+#include "Lzma2Enc.h"
+
+#include "Xz.h"
+
+EXTERN_C_BEGIN
+
+
+#define XZ_PROPS_BLOCK_SIZE_AUTO LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO
+#define XZ_PROPS_BLOCK_SIZE_SOLID LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+
+
+typedef struct
+{
+ UInt32 id;
+ UInt32 delta;
+ UInt32 ip;
+ int ipDefined;
+} CXzFilterProps;
+
+void XzFilterProps_Init(CXzFilterProps *p);
+
+
+typedef struct
+{
+ CLzma2EncProps lzma2Props;
+ CXzFilterProps filterProps;
+ unsigned checkId;
+ UInt64 blockSize;
+ int numBlockThreads_Reduced;
+ int numBlockThreads_Max;
+ int numTotalThreads;
+ int forceWriteSizesInHeader;
+ UInt64 reduceSize;
+} CXzProps;
+
+void XzProps_Init(CXzProps *p);
+
+typedef struct CXzEnc CXzEnc;
+typedef CXzEnc * CXzEncHandle;
+// Z7_DECLARE_HANDLE(CXzEncHandle)
+
+CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
+void XzEnc_Destroy(CXzEncHandle p);
+SRes XzEnc_SetProps(CXzEncHandle p, const CXzProps *props);
+void XzEnc_SetDataSize(CXzEncHandle p, UInt64 expectedDataSiize);
+SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress);
+
+SRes Xz_Encode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
+ const CXzProps *props, ICompressProgressPtr progress);
+
+SRes Xz_EncodeEmpty(ISeqOutStreamPtr outStream);
+
+EXTERN_C_END
+
+#endif
diff --git a/C/XzIn.c b/C/XzIn.c
index 792a617..d0fc763 100644
--- a/C/XzIn.c
+++ b/C/XzIn.c
@@ -1,319 +1,340 @@
-/* XzIn.c - Xz input
-2018-07-04 : Igor Pavlov : Public domain */
-
-#include "Precomp.h"
-
-#include <string.h>
-
-#include "7zCrc.h"
-#include "CpuArch.h"
-#include "Xz.h"
-
-/*
-#define XZ_FOOTER_SIG_CHECK(p) (memcmp((p), XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0)
-*/
-#define XZ_FOOTER_SIG_CHECK(p) ((p)[0] == XZ_FOOTER_SIG_0 && (p)[1] == XZ_FOOTER_SIG_1)
-
-
-SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream)
-{
- Byte sig[XZ_STREAM_HEADER_SIZE];
- RINOK(SeqInStream_Read2(inStream, sig, XZ_STREAM_HEADER_SIZE, SZ_ERROR_NO_ARCHIVE));
- if (memcmp(sig, XZ_SIG, XZ_SIG_SIZE) != 0)
- return SZ_ERROR_NO_ARCHIVE;
- return Xz_ParseHeader(p, sig);
-}
-
-#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
- { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
- if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
-
-SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, BoolInt *isIndex, UInt32 *headerSizeRes)
-{
- Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
- unsigned headerSize;
- *headerSizeRes = 0;
- RINOK(SeqInStream_ReadByte(inStream, &header[0]));
- headerSize = (unsigned)header[0];
- if (headerSize == 0)
- {
- *headerSizeRes = 1;
- *isIndex = True;
- return SZ_OK;
- }
-
- *isIndex = False;
- headerSize = (headerSize << 2) + 4;
- *headerSizeRes = headerSize;
- RINOK(SeqInStream_Read(inStream, header + 1, headerSize - 1));
- return XzBlock_Parse(p, header);
-}
-
-#define ADD_SIZE_CHECK(size, val) \
- { UInt64 newSize = size + (val); if (newSize < size) return XZ_SIZE_OVERFLOW; size = newSize; }
-
-UInt64 Xz_GetUnpackSize(const CXzStream *p)
-{
- UInt64 size = 0;
- size_t i;
- for (i = 0; i < p->numBlocks; i++)
- ADD_SIZE_CHECK(size, p->blocks[i].unpackSize);
- return size;
-}
-
-UInt64 Xz_GetPackSize(const CXzStream *p)
-{
- UInt64 size = 0;
- size_t i;
- for (i = 0; i < p->numBlocks; i++)
- ADD_SIZE_CHECK(size, (p->blocks[i].totalSize + 3) & ~(UInt64)3);
- return size;
-}
-
-/*
-SRes XzBlock_ReadFooter(CXzBlock *p, CXzStreamFlags f, ISeqInStream *inStream)
-{
- return SeqInStream_Read(inStream, p->check, XzFlags_GetCheckSize(f));
-}
-*/
-
-static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
-{
- size_t numBlocks, pos = 1;
- UInt32 crc;
-
- if (size < 5 || buf[0] != 0)
- return SZ_ERROR_ARCHIVE;
-
- size -= 4;
- crc = CrcCalc(buf, size);
- if (crc != GetUi32(buf + size))
- return SZ_ERROR_ARCHIVE;
-
- {
- UInt64 numBlocks64;
- READ_VARINT_AND_CHECK(buf, pos, size, &numBlocks64);
- numBlocks = (size_t)numBlocks64;
- if (numBlocks != numBlocks64 || numBlocks * 2 > size)
- return SZ_ERROR_ARCHIVE;
- }
-
- Xz_Free(p, alloc);
- if (numBlocks != 0)
- {
- size_t i;
- p->numBlocks = numBlocks;
- p->blocks = (CXzBlockSizes *)ISzAlloc_Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
- if (!p->blocks)
- return SZ_ERROR_MEM;
- for (i = 0; i < numBlocks; i++)
- {
- CXzBlockSizes *block = &p->blocks[i];
- READ_VARINT_AND_CHECK(buf, pos, size, &block->totalSize);
- READ_VARINT_AND_CHECK(buf, pos, size, &block->unpackSize);
- if (block->totalSize == 0)
- return SZ_ERROR_ARCHIVE;
- }
- }
- while ((pos & 3) != 0)
- if (buf[pos++] != 0)
- return SZ_ERROR_ARCHIVE;
- return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
-}
-
-static SRes Xz_ReadIndex(CXzStream *p, ILookInStream *stream, UInt64 indexSize, ISzAllocPtr alloc)
-{
- SRes res;
- size_t size;
- Byte *buf;
- if (indexSize > ((UInt32)1 << 31))
- return SZ_ERROR_UNSUPPORTED;
- size = (size_t)indexSize;
- if (size != indexSize)
- return SZ_ERROR_UNSUPPORTED;
- buf = (Byte *)ISzAlloc_Alloc(alloc, size);
- if (!buf)
- return SZ_ERROR_MEM;
- res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
- if (res == SZ_OK)
- res = Xz_ReadIndex2(p, buf, size, alloc);
- ISzAlloc_Free(alloc, buf);
- return res;
-}
-
-static SRes LookInStream_SeekRead_ForArc(ILookInStream *stream, UInt64 offset, void *buf, size_t size)
-{
- RINOK(LookInStream_SeekTo(stream, offset));
- return LookInStream_Read(stream, buf, size);
- /* return LookInStream_Read2(stream, buf, size, SZ_ERROR_NO_ARCHIVE); */
-}
-
-static SRes Xz_ReadBackward(CXzStream *p, ILookInStream *stream, Int64 *startOffset, ISzAllocPtr alloc)
-{
- UInt64 indexSize;
- Byte buf[XZ_STREAM_FOOTER_SIZE];
- UInt64 pos = *startOffset;
-
- if ((pos & 3) != 0 || pos < XZ_STREAM_FOOTER_SIZE)
- return SZ_ERROR_NO_ARCHIVE;
-
- pos -= XZ_STREAM_FOOTER_SIZE;
- RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE));
-
- if (!XZ_FOOTER_SIG_CHECK(buf + 10))
- {
- UInt32 total = 0;
- pos += XZ_STREAM_FOOTER_SIZE;
-
- for (;;)
- {
- size_t i;
- #define TEMP_BUF_SIZE (1 << 10)
- Byte temp[TEMP_BUF_SIZE];
-
- i = (pos > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)pos;
- pos -= i;
- RINOK(LookInStream_SeekRead_ForArc(stream, pos, temp, i));
- total += (UInt32)i;
- for (; i != 0; i--)
- if (temp[i - 1] != 0)
- break;
- if (i != 0)
- {
- if ((i & 3) != 0)
- return SZ_ERROR_NO_ARCHIVE;
- pos += i;
- break;
- }
- if (pos < XZ_STREAM_FOOTER_SIZE || total > (1 << 16))
- return SZ_ERROR_NO_ARCHIVE;
- }
-
- if (pos < XZ_STREAM_FOOTER_SIZE)
- return SZ_ERROR_NO_ARCHIVE;
- pos -= XZ_STREAM_FOOTER_SIZE;
- RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE));
- if (!XZ_FOOTER_SIG_CHECK(buf + 10))
- return SZ_ERROR_NO_ARCHIVE;
- }
-
- p->flags = (CXzStreamFlags)GetBe16(buf + 8);
-
- if (!XzFlags_IsSupported(p->flags))
- return SZ_ERROR_UNSUPPORTED;
-
- if (GetUi32(buf) != CrcCalc(buf + 4, 6))
- return SZ_ERROR_ARCHIVE;
-
- indexSize = ((UInt64)GetUi32(buf + 4) + 1) << 2;
-
- if (pos < indexSize)
- return SZ_ERROR_ARCHIVE;
-
- pos -= indexSize;
- RINOK(LookInStream_SeekTo(stream, pos));
- RINOK(Xz_ReadIndex(p, stream, indexSize, alloc));
-
- {
- UInt64 totalSize = Xz_GetPackSize(p);
- if (totalSize == XZ_SIZE_OVERFLOW
- || totalSize >= ((UInt64)1 << 63)
- || pos < totalSize + XZ_STREAM_HEADER_SIZE)
- return SZ_ERROR_ARCHIVE;
- pos -= (totalSize + XZ_STREAM_HEADER_SIZE);
- RINOK(LookInStream_SeekTo(stream, pos));
- *startOffset = pos;
- }
- {
- CXzStreamFlags headerFlags;
- CSecToRead secToRead;
- SecToRead_CreateVTable(&secToRead);
- secToRead.realStream = stream;
-
- RINOK(Xz_ReadHeader(&headerFlags, &secToRead.vt));
- return (p->flags == headerFlags) ? SZ_OK : SZ_ERROR_ARCHIVE;
- }
-}
-
-
-/* ---------- Xz Streams ---------- */
-
-void Xzs_Construct(CXzs *p)
-{
- p->num = p->numAllocated = 0;
- p->streams = 0;
-}
-
-void Xzs_Free(CXzs *p, ISzAllocPtr alloc)
-{
- size_t i;
- for (i = 0; i < p->num; i++)
- Xz_Free(&p->streams[i], alloc);
- ISzAlloc_Free(alloc, p->streams);
- p->num = p->numAllocated = 0;
- p->streams = 0;
-}
-
-UInt64 Xzs_GetNumBlocks(const CXzs *p)
-{
- UInt64 num = 0;
- size_t i;
- for (i = 0; i < p->num; i++)
- num += p->streams[i].numBlocks;
- return num;
-}
-
-UInt64 Xzs_GetUnpackSize(const CXzs *p)
-{
- UInt64 size = 0;
- size_t i;
- for (i = 0; i < p->num; i++)
- ADD_SIZE_CHECK(size, Xz_GetUnpackSize(&p->streams[i]));
- return size;
-}
-
-/*
-UInt64 Xzs_GetPackSize(const CXzs *p)
-{
- UInt64 size = 0;
- size_t i;
- for (i = 0; i < p->num; i++)
- ADD_SIZE_CHECK(size, Xz_GetTotalSize(&p->streams[i]));
- return size;
-}
-*/
-
-SRes Xzs_ReadBackward(CXzs *p, ILookInStream *stream, Int64 *startOffset, ICompressProgress *progress, ISzAllocPtr alloc)
-{
- Int64 endOffset = 0;
- RINOK(ILookInStream_Seek(stream, &endOffset, SZ_SEEK_END));
- *startOffset = endOffset;
- for (;;)
- {
- CXzStream st;
- SRes res;
- Xz_Construct(&st);
- res = Xz_ReadBackward(&st, stream, startOffset, alloc);
- st.startOffset = *startOffset;
- RINOK(res);
- if (p->num == p->numAllocated)
- {
- size_t newNum = p->num + p->num / 4 + 1;
- Byte *data = (Byte *)ISzAlloc_Alloc(alloc, newNum * sizeof(CXzStream));
- if (!data)
- return SZ_ERROR_MEM;
- p->numAllocated = newNum;
- if (p->num != 0)
- memcpy(data, p->streams, p->num * sizeof(CXzStream));
- ISzAlloc_Free(alloc, p->streams);
- p->streams = (CXzStream *)data;
- }
- p->streams[p->num++] = st;
- if (*startOffset == 0)
- break;
- RINOK(LookInStream_SeekTo(stream, *startOffset));
- if (progress && ICompressProgress_Progress(progress, endOffset - *startOffset, (UInt64)(Int64)-1) != SZ_OK)
- return SZ_ERROR_PROGRESS;
- }
- return SZ_OK;
-}
+/* XzIn.c - Xz input
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "7zCrc.h"
+#include "CpuArch.h"
+#include "Xz.h"
+
+/*
+#define XZ_FOOTER_SIG_CHECK(p) (memcmp((p), XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0)
+*/
+#define XZ_FOOTER_SIG_CHECK(p) ((p)[0] == XZ_FOOTER_SIG_0 && (p)[1] == XZ_FOOTER_SIG_1)
+
+
+SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStreamPtr inStream)
+{
+ Byte sig[XZ_STREAM_HEADER_SIZE];
+ size_t processedSize = XZ_STREAM_HEADER_SIZE;
+ RINOK(SeqInStream_ReadMax(inStream, sig, &processedSize))
+ if (processedSize != XZ_STREAM_HEADER_SIZE
+ || memcmp(sig, XZ_SIG, XZ_SIG_SIZE) != 0)
+ return SZ_ERROR_NO_ARCHIVE;
+ return Xz_ParseHeader(p, sig);
+}
+
+#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
+ { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+ if (s == 0) return SZ_ERROR_ARCHIVE; \
+ pos += s; }
+
+SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStreamPtr inStream, BoolInt *isIndex, UInt32 *headerSizeRes)
+{
+ Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
+ unsigned headerSize;
+ *headerSizeRes = 0;
+ RINOK(SeqInStream_ReadByte(inStream, &header[0]))
+ headerSize = (unsigned)header[0];
+ if (headerSize == 0)
+ {
+ *headerSizeRes = 1;
+ *isIndex = True;
+ return SZ_OK;
+ }
+
+ *isIndex = False;
+ headerSize = (headerSize << 2) + 4;
+ *headerSizeRes = headerSize;
+ {
+ size_t processedSize = headerSize - 1;
+ RINOK(SeqInStream_ReadMax(inStream, header + 1, &processedSize))
+ if (processedSize != headerSize - 1)
+ return SZ_ERROR_INPUT_EOF;
+ }
+ return XzBlock_Parse(p, header);
+}
+
+#define ADD_SIZE_CHECK(size, val) \
+ { UInt64 newSize = size + (val); if (newSize < size) return XZ_SIZE_OVERFLOW; size = newSize; }
+
+UInt64 Xz_GetUnpackSize(const CXzStream *p)
+{
+ UInt64 size = 0;
+ size_t i;
+ for (i = 0; i < p->numBlocks; i++)
+ {
+ ADD_SIZE_CHECK(size, p->blocks[i].unpackSize)
+ }
+ return size;
+}
+
+UInt64 Xz_GetPackSize(const CXzStream *p)
+{
+ UInt64 size = 0;
+ size_t i;
+ for (i = 0; i < p->numBlocks; i++)
+ {
+ ADD_SIZE_CHECK(size, (p->blocks[i].totalSize + 3) & ~(UInt64)3)
+ }
+ return size;
+}
+
+/*
+SRes XzBlock_ReadFooter(CXzBlock *p, CXzStreamFlags f, ISeqInStreamPtr inStream)
+{
+ return SeqInStream_Read(inStream, p->check, XzFlags_GetCheckSize(f));
+}
+*/
+
+static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
+{
+ size_t numBlocks, pos = 1;
+ UInt32 crc;
+
+ if (size < 5 || buf[0] != 0)
+ return SZ_ERROR_ARCHIVE;
+
+ size -= 4;
+ crc = CrcCalc(buf, size);
+ if (crc != GetUi32(buf + size))
+ return SZ_ERROR_ARCHIVE;
+
+ {
+ UInt64 numBlocks64;
+ READ_VARINT_AND_CHECK(buf, pos, size, &numBlocks64)
+ numBlocks = (size_t)numBlocks64;
+ if (numBlocks != numBlocks64 || numBlocks * 2 > size)
+ return SZ_ERROR_ARCHIVE;
+ }
+
+ Xz_Free(p, alloc);
+ if (numBlocks != 0)
+ {
+ size_t i;
+ p->numBlocks = numBlocks;
+ p->blocks = (CXzBlockSizes *)ISzAlloc_Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
+ if (!p->blocks)
+ return SZ_ERROR_MEM;
+ for (i = 0; i < numBlocks; i++)
+ {
+ CXzBlockSizes *block = &p->blocks[i];
+ READ_VARINT_AND_CHECK(buf, pos, size, &block->totalSize)
+ READ_VARINT_AND_CHECK(buf, pos, size, &block->unpackSize)
+ if (block->totalSize == 0)
+ return SZ_ERROR_ARCHIVE;
+ }
+ }
+ while ((pos & 3) != 0)
+ if (buf[pos++] != 0)
+ return SZ_ERROR_ARCHIVE;
+ return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
+}
+
+static SRes Xz_ReadIndex(CXzStream *p, ILookInStreamPtr stream, UInt64 indexSize, ISzAllocPtr alloc)
+{
+ SRes res;
+ size_t size;
+ Byte *buf;
+ if (indexSize > ((UInt32)1 << 31))
+ return SZ_ERROR_UNSUPPORTED;
+ size = (size_t)indexSize;
+ if (size != indexSize)
+ return SZ_ERROR_UNSUPPORTED;
+ buf = (Byte *)ISzAlloc_Alloc(alloc, size);
+ if (!buf)
+ return SZ_ERROR_MEM;
+ res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
+ if (res == SZ_OK)
+ res = Xz_ReadIndex2(p, buf, size, alloc);
+ ISzAlloc_Free(alloc, buf);
+ return res;
+}
+
+static SRes LookInStream_SeekRead_ForArc(ILookInStreamPtr stream, UInt64 offset, void *buf, size_t size)
+{
+ RINOK(LookInStream_SeekTo(stream, offset))
+ return LookInStream_Read(stream, buf, size);
+ /* return LookInStream_Read2(stream, buf, size, SZ_ERROR_NO_ARCHIVE); */
+}
+
+static SRes Xz_ReadBackward(CXzStream *p, ILookInStreamPtr stream, Int64 *startOffset, ISzAllocPtr alloc)
+{
+ UInt64 indexSize;
+ Byte buf[XZ_STREAM_FOOTER_SIZE];
+ UInt64 pos = (UInt64)*startOffset;
+
+ if ((pos & 3) != 0 || pos < XZ_STREAM_FOOTER_SIZE)
+ return SZ_ERROR_NO_ARCHIVE;
+
+ pos -= XZ_STREAM_FOOTER_SIZE;
+ RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE))
+
+ if (!XZ_FOOTER_SIG_CHECK(buf + 10))
+ {
+ UInt32 total = 0;
+ pos += XZ_STREAM_FOOTER_SIZE;
+
+ for (;;)
+ {
+ size_t i;
+ #define TEMP_BUF_SIZE (1 << 10)
+ Byte temp[TEMP_BUF_SIZE];
+
+ i = (pos > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)pos;
+ pos -= i;
+ RINOK(LookInStream_SeekRead_ForArc(stream, pos, temp, i))
+ total += (UInt32)i;
+ for (; i != 0; i--)
+ if (temp[i - 1] != 0)
+ break;
+ if (i != 0)
+ {
+ if ((i & 3) != 0)
+ return SZ_ERROR_NO_ARCHIVE;
+ pos += i;
+ break;
+ }
+ if (pos < XZ_STREAM_FOOTER_SIZE || total > (1 << 16))
+ return SZ_ERROR_NO_ARCHIVE;
+ }
+
+ if (pos < XZ_STREAM_FOOTER_SIZE)
+ return SZ_ERROR_NO_ARCHIVE;
+ pos -= XZ_STREAM_FOOTER_SIZE;
+ RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE))
+ if (!XZ_FOOTER_SIG_CHECK(buf + 10))
+ return SZ_ERROR_NO_ARCHIVE;
+ }
+
+ p->flags = (CXzStreamFlags)GetBe16(buf + 8);
+
+ if (!XzFlags_IsSupported(p->flags))
+ return SZ_ERROR_UNSUPPORTED;
+
+ {
+ /* to eliminate GCC 6.3 warning:
+ dereferencing type-punned pointer will break strict-aliasing rules */
+ const Byte *buf_ptr = buf;
+ if (GetUi32(buf_ptr) != CrcCalc(buf + 4, 6))
+ return SZ_ERROR_ARCHIVE;
+ }
+
+ indexSize = ((UInt64)GetUi32(buf + 4) + 1) << 2;
+
+ if (pos < indexSize)
+ return SZ_ERROR_ARCHIVE;
+
+ pos -= indexSize;
+ RINOK(LookInStream_SeekTo(stream, pos))
+ RINOK(Xz_ReadIndex(p, stream, indexSize, alloc))
+
+ {
+ UInt64 totalSize = Xz_GetPackSize(p);
+ if (totalSize == XZ_SIZE_OVERFLOW
+ || totalSize >= ((UInt64)1 << 63)
+ || pos < totalSize + XZ_STREAM_HEADER_SIZE)
+ return SZ_ERROR_ARCHIVE;
+ pos -= (totalSize + XZ_STREAM_HEADER_SIZE);
+ RINOK(LookInStream_SeekTo(stream, pos))
+ *startOffset = (Int64)pos;
+ }
+ {
+ CXzStreamFlags headerFlags;
+ CSecToRead secToRead;
+ SecToRead_CreateVTable(&secToRead);
+ secToRead.realStream = stream;
+
+ RINOK(Xz_ReadHeader(&headerFlags, &secToRead.vt))
+ return (p->flags == headerFlags) ? SZ_OK : SZ_ERROR_ARCHIVE;
+ }
+}
+
+
+/* ---------- Xz Streams ---------- */
+
+void Xzs_Construct(CXzs *p)
+{
+ p->num = p->numAllocated = 0;
+ p->streams = 0;
+}
+
+void Xzs_Free(CXzs *p, ISzAllocPtr alloc)
+{
+ size_t i;
+ for (i = 0; i < p->num; i++)
+ Xz_Free(&p->streams[i], alloc);
+ ISzAlloc_Free(alloc, p->streams);
+ p->num = p->numAllocated = 0;
+ p->streams = 0;
+}
+
+UInt64 Xzs_GetNumBlocks(const CXzs *p)
+{
+ UInt64 num = 0;
+ size_t i;
+ for (i = 0; i < p->num; i++)
+ num += p->streams[i].numBlocks;
+ return num;
+}
+
+UInt64 Xzs_GetUnpackSize(const CXzs *p)
+{
+ UInt64 size = 0;
+ size_t i;
+ for (i = 0; i < p->num; i++)
+ {
+ ADD_SIZE_CHECK(size, Xz_GetUnpackSize(&p->streams[i]))
+ }
+ return size;
+}
+
+/*
+UInt64 Xzs_GetPackSize(const CXzs *p)
+{
+ UInt64 size = 0;
+ size_t i;
+ for (i = 0; i < p->num; i++)
+ {
+ ADD_SIZE_CHECK(size, Xz_GetTotalSize(&p->streams[i]))
+ }
+ return size;
+}
+*/
+
+SRes Xzs_ReadBackward(CXzs *p, ILookInStreamPtr stream, Int64 *startOffset, ICompressProgressPtr progress, ISzAllocPtr alloc)
+{
+ Int64 endOffset = 0;
+ RINOK(ILookInStream_Seek(stream, &endOffset, SZ_SEEK_END))
+ *startOffset = endOffset;
+ for (;;)
+ {
+ CXzStream st;
+ SRes res;
+ Xz_Construct(&st);
+ res = Xz_ReadBackward(&st, stream, startOffset, alloc);
+ st.startOffset = (UInt64)*startOffset;
+ RINOK(res)
+ if (p->num == p->numAllocated)
+ {
+ const size_t newNum = p->num + p->num / 4 + 1;
+ void *data = ISzAlloc_Alloc(alloc, newNum * sizeof(CXzStream));
+ if (!data)
+ return SZ_ERROR_MEM;
+ p->numAllocated = newNum;
+ if (p->num != 0)
+ memcpy(data, p->streams, p->num * sizeof(CXzStream));
+ ISzAlloc_Free(alloc, p->streams);
+ p->streams = (CXzStream *)data;
+ }
+ p->streams[p->num++] = st;
+ if (*startOffset == 0)
+ break;
+ RINOK(LookInStream_SeekTo(stream, (UInt64)*startOffset))
+ if (progress && ICompressProgress_Progress(progress, (UInt64)(endOffset - *startOffset), (UInt64)(Int64)-1) != SZ_OK)
+ return SZ_ERROR_PROGRESS;
+ }
+ return SZ_OK;
+}
diff --git a/C/var_clang.mak b/C/var_clang.mak
new file mode 100644
index 0000000..a6df26e
--- /dev/null
+++ b/C/var_clang.mak
@@ -0,0 +1,11 @@
+PLATFORM=
+O=b/c
+IS_X64=
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/C/var_clang_arm64.mak b/C/var_clang_arm64.mak
new file mode 100644
index 0000000..4b35409
--- /dev/null
+++ b/C/var_clang_arm64.mak
@@ -0,0 +1,11 @@
+PLATFORM=arm64
+O=b/c_$(PLATFORM)
+IS_X64=
+IS_X86=
+IS_ARM64=1
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/C/var_clang_x64.mak b/C/var_clang_x64.mak
new file mode 100644
index 0000000..34e1b49
--- /dev/null
+++ b/C/var_clang_x64.mak
@@ -0,0 +1,11 @@
+PLATFORM=x64
+O=b/c_$(PLATFORM)
+IS_X64=1
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/C/var_clang_x86.mak b/C/var_clang_x86.mak
new file mode 100644
index 0000000..bd2317c
--- /dev/null
+++ b/C/var_clang_x86.mak
@@ -0,0 +1,11 @@
+PLATFORM=x86
+O=b/c_$(PLATFORM)
+IS_X64=
+IS_X86=1
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=-m32
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/C/var_gcc.mak b/C/var_gcc.mak
new file mode 100644
index 0000000..664491c
--- /dev/null
+++ b/C/var_gcc.mak
@@ -0,0 +1,12 @@
+PLATFORM=
+O=b/g
+IS_X64=
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
+
+# -march=armv8-a+crc+crypto
diff --git a/C/var_gcc_arm64.mak b/C/var_gcc_arm64.mak
new file mode 100644
index 0000000..4bbb687
--- /dev/null
+++ b/C/var_gcc_arm64.mak
@@ -0,0 +1,12 @@
+PLATFORM=arm64
+O=b/g_$(PLATFORM)
+IS_X64=
+IS_X86=
+IS_ARM64=1
+CROSS_COMPILE=
+MY_ARCH=-mtune=cortex-a53
+USE_ASM=1
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
+
+# -march=armv8-a+crc+crypto
diff --git a/C/var_gcc_x64.mak b/C/var_gcc_x64.mak
new file mode 100644
index 0000000..1acf604
--- /dev/null
+++ b/C/var_gcc_x64.mak
@@ -0,0 +1,10 @@
+PLATFORM=x64
+O=b/g_$(PLATFORM)
+IS_X64=1
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=1
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
diff --git a/C/var_gcc_x86.mak b/C/var_gcc_x86.mak
new file mode 100644
index 0000000..f0718ec
--- /dev/null
+++ b/C/var_gcc_x86.mak
@@ -0,0 +1,10 @@
+PLATFORM=x86
+O=b/g_$(PLATFORM)
+IS_X64=
+IS_X86=1
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=-m32
+USE_ASM=1
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
diff --git a/C/var_mac_arm64.mak b/C/var_mac_arm64.mak
new file mode 100644
index 0000000..adf5fa1
--- /dev/null
+++ b/C/var_mac_arm64.mak
@@ -0,0 +1,11 @@
+PLATFORM=arm64
+O=b/m_$(PLATFORM)
+IS_X64=
+IS_X86=
+IS_ARM64=1
+CROSS_COMPILE=
+MY_ARCH=-arch arm64
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/C/var_mac_x64.mak b/C/var_mac_x64.mak
new file mode 100644
index 0000000..13d7aa7
--- /dev/null
+++ b/C/var_mac_x64.mak
@@ -0,0 +1,11 @@
+PLATFORM=x64
+O=b/m_$(PLATFORM)
+IS_X64=1
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=-arch x86_64
+USE_ASM=
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/C/warn_clang.mak b/C/warn_clang.mak
new file mode 100644
index 0000000..0d6446d
--- /dev/null
+++ b/C/warn_clang.mak
@@ -0,0 +1 @@
+CFLAGS_WARN = -Weverything -Wfatal-errors
diff --git a/C/warn_clang_mac.mak b/C/warn_clang_mac.mak
new file mode 100644
index 0000000..44afc53
--- /dev/null
+++ b/C/warn_clang_mac.mak
@@ -0,0 +1 @@
+CFLAGS_WARN = -Weverything -Wfatal-errors -Wno-poison-system-directories
diff --git a/C/warn_gcc.mak b/C/warn_gcc.mak
new file mode 100644
index 0000000..7aab7a4
--- /dev/null
+++ b/C/warn_gcc.mak
@@ -0,0 +1,51 @@
+CFLAGS_WARN_GCC_4_5 = \
+
+CFLAGS_WARN_GCC_6 = \
+ -Waddress \
+ -Waggressive-loop-optimizations \
+ -Wattributes \
+ -Wbool-compare \
+ -Wcast-align \
+ -Wcomment \
+ -Wdiv-by-zero \
+ -Wduplicated-cond \
+ -Wformat-contains-nul \
+ -Winit-self \
+ -Wint-to-pointer-cast \
+ -Wunused \
+ -Wunused-macros \
+
+# -Wno-strict-aliasing
+
+CFLAGS_WARN_GCC_9 = \
+ -Waddress \
+ -Waddress-of-packed-member \
+ -Waggressive-loop-optimizations \
+ -Wattributes \
+ -Wbool-compare \
+ -Wbool-operation \
+ -Wcast-align \
+ -Wcast-align=strict \
+ -Wcomment \
+ -Wdangling-else \
+ -Wdiv-by-zero \
+ -Wduplicated-branches \
+ -Wduplicated-cond \
+ -Wformat-contains-nul \
+ -Wimplicit-fallthrough=5 \
+ -Winit-self \
+ -Wint-in-bool-context \
+ -Wint-to-pointer-cast \
+ -Wunused \
+ -Wunused-macros \
+ -Wconversion \
+
+# -Wno-sign-conversion \
+
+CFLAGS_WARN_GCC_PPMD_UNALIGNED = \
+ -Wno-strict-aliasing \
+
+
+CFLAGS_WARN = $(CFLAGS_WARN_GCC_9) \
+
+# $(CFLAGS_WARN_GCC_PPMD_UNALIGNED)
diff --git a/CPP/7zip/7zip.mak b/CPP/7zip/7zip.mak
index 7fec27c..6f4a0a1 100644
--- a/CPP/7zip/7zip.mak
+++ b/CPP/7zip/7zip.mak
@@ -1,240 +1,240 @@
-OBJS = \
- $O\StdAfx.obj \
- $(CURRENT_OBJS) \
- $(COMMON_OBJS) \
- $(WIN_OBJS) \
- $(WIN_CTRL_OBJS) \
- $(7ZIP_COMMON_OBJS) \
- $(AR_OBJS) \
- $(AR_COMMON_OBJS) \
- $(UI_COMMON_OBJS) \
- $(AGENT_OBJS) \
- $(CONSOLE_OBJS) \
- $(EXPLORER_OBJS) \
- $(FM_OBJS) \
- $(GUI_OBJS) \
- $(7Z_OBJS) \
- $(CAB_OBJS) \
- $(CHM_OBJS) \
- $(COM_OBJS) \
- $(ISO_OBJS) \
- $(NSIS_OBJS) \
- $(RAR_OBJS) \
- $(TAR_OBJS) \
- $(UDF_OBJS) \
- $(WIM_OBJS) \
- $(ZIP_OBJS) \
- $(COMPRESS_OBJS) \
- $(CRYPTO_OBJS) \
- $(C_OBJS) \
- $(ASM_OBJS) \
- $O\resource.res \
-
-!include "../../../Build.mak"
-
-# MAK_SINGLE_FILE = 1
-
-!IFDEF MAK_SINGLE_FILE
-
-!IFDEF CURRENT_OBJS
-$(CURRENT_OBJS): ./$(*B).cpp
- $(COMPL)
-!ENDIF
-
-
-!IFDEF COMMON_OBJS
-$(COMMON_OBJS): ../../../Common/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF WIN_OBJS
-$(WIN_OBJS): ../../../Windows/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF WIN_CTRL_OBJS
-$(WIN_CTRL_OBJS): ../../../Windows/Control/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF 7ZIP_COMMON_OBJS
-$(7ZIP_COMMON_OBJS): ../../Common/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF AR_OBJS
-$(AR_OBJS): ../../Archive/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF AR_COMMON_OBJS
-$(AR_COMMON_OBJS): ../../Archive/Common/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF 7Z_OBJS
-$(7Z_OBJS): ../../Archive/7z/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF CAB_OBJS
-$(CAB_OBJS): ../../Archive/Cab/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF CHM_OBJS
-$(CHM_OBJS): ../../Archive/Chm/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF COM_OBJS
-$(COM_OBJS): ../../Archive/Com/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF ISO_OBJS
-$(ISO_OBJS): ../../Archive/Iso/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF NSIS_OBJS
-$(NSIS_OBJS): ../../Archive/Nsis/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF RAR_OBJS
-$(RAR_OBJS): ../../Archive/Rar/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF TAR_OBJS
-$(TAR_OBJS): ../../Archive/Tar/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF UDF_OBJS
-$(UDF_OBJS): ../../Archive/Udf/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF WIM_OBJS
-$(WIM_OBJS): ../../Archive/Wim/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF ZIP_OBJS
-$(ZIP_OBJS): ../../Archive/Zip/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF COMPRESS_OBJS
-$(COMPRESS_OBJS): ../../Compress/$(*B).cpp
- $(COMPL_O2)
-!ENDIF
-
-!IFDEF CRYPTO_OBJS
-$(CRYPTO_OBJS): ../../Crypto/$(*B).cpp
- $(COMPL_O2)
-!ENDIF
-
-!IFDEF UI_COMMON_OBJS
-$(UI_COMMON_OBJS): ../../UI/Common/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF AGENT_OBJS
-$(AGENT_OBJS): ../../UI/Agent/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF CONSOLE_OBJS
-$(CONSOLE_OBJS): ../../UI/Console/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF EXPLORER_OBJS
-$(EXPLORER_OBJS): ../../UI/Explorer/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF FM_OBJS
-$(FM_OBJS): ../../UI/FileManager/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF GUI_OBJS
-$(GUI_OBJS): ../../UI/GUI/$(*B).cpp
- $(COMPL)
-!ENDIF
-
-!IFDEF C_OBJS
-$(C_OBJS): ../../../../C/$(*B).c
- $(COMPL_O2)
-!ENDIF
-
-
-!ELSE
-
-{.}.cpp{$O}.obj::
- $(COMPLB)
-{../../../Common}.cpp{$O}.obj::
- $(COMPLB)
-{../../../Windows}.cpp{$O}.obj::
- $(COMPLB)
-{../../../Windows/Control}.cpp{$O}.obj::
- $(COMPLB)
-{../../Common}.cpp{$O}.obj::
- $(COMPLB)
-
-{../../UI/Common}.cpp{$O}.obj::
- $(COMPLB)
-{../../UI/Agent}.cpp{$O}.obj::
- $(COMPLB)
-{../../UI/Console}.cpp{$O}.obj::
- $(COMPLB)
-{../../UI/Explorer}.cpp{$O}.obj::
- $(COMPLB)
-{../../UI/FileManager}.cpp{$O}.obj::
- $(COMPLB)
-{../../UI/GUI}.cpp{$O}.obj::
- $(COMPLB)
-
-
-{../../Archive}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Common}.cpp{$O}.obj::
- $(COMPLB)
-
-{../../Archive/7z}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Cab}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Chm}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Com}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Iso}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Nsis}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Rar}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Tar}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Udf}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Wim}.cpp{$O}.obj::
- $(COMPLB)
-{../../Archive/Zip}.cpp{$O}.obj::
- $(COMPLB)
-
-{../../Compress}.cpp{$O}.obj::
- $(COMPLB_O2)
-{../../Crypto}.cpp{$O}.obj::
- $(COMPLB_O2)
-{../../../../C}.c{$O}.obj::
- $(CCOMPLB)
-
-!ENDIF
-
-!include "Asm.mak"
+OBJS = \
+ $O\StdAfx.obj \
+ $(CURRENT_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(WIN_CTRL_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(UI_COMMON_OBJS) \
+ $(AGENT_OBJS) \
+ $(CONSOLE_OBJS) \
+ $(EXPLORER_OBJS) \
+ $(FM_OBJS) \
+ $(GUI_OBJS) \
+ $(AR_COMMON_OBJS) \
+ $(AR_OBJS) \
+ $(7Z_OBJS) \
+ $(CAB_OBJS) \
+ $(CHM_OBJS) \
+ $(COM_OBJS) \
+ $(ISO_OBJS) \
+ $(NSIS_OBJS) \
+ $(RAR_OBJS) \
+ $(TAR_OBJS) \
+ $(UDF_OBJS) \
+ $(WIM_OBJS) \
+ $(ZIP_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(CRYPTO_OBJS) \
+ $(C_OBJS) \
+ $(ASM_OBJS) \
+ $O\resource.res \
+
+!include "../../../Build.mak"
+
+# MAK_SINGLE_FILE = 1
+
+!IFDEF MAK_SINGLE_FILE
+
+!IFDEF CURRENT_OBJS
+$(CURRENT_OBJS): ./$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+
+!IFDEF COMMON_OBJS
+$(COMMON_OBJS): ../../../Common/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF WIN_OBJS
+$(WIN_OBJS): ../../../Windows/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF WIN_CTRL_OBJS
+$(WIN_CTRL_OBJS): ../../../Windows/Control/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF 7ZIP_COMMON_OBJS
+$(7ZIP_COMMON_OBJS): ../../Common/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF AR_OBJS
+$(AR_OBJS): ../../Archive/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF AR_COMMON_OBJS
+$(AR_COMMON_OBJS): ../../Archive/Common/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF 7Z_OBJS
+$(7Z_OBJS): ../../Archive/7z/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF CAB_OBJS
+$(CAB_OBJS): ../../Archive/Cab/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF CHM_OBJS
+$(CHM_OBJS): ../../Archive/Chm/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF COM_OBJS
+$(COM_OBJS): ../../Archive/Com/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF ISO_OBJS
+$(ISO_OBJS): ../../Archive/Iso/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF NSIS_OBJS
+$(NSIS_OBJS): ../../Archive/Nsis/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF RAR_OBJS
+$(RAR_OBJS): ../../Archive/Rar/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF TAR_OBJS
+$(TAR_OBJS): ../../Archive/Tar/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF UDF_OBJS
+$(UDF_OBJS): ../../Archive/Udf/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF WIM_OBJS
+$(WIM_OBJS): ../../Archive/Wim/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF ZIP_OBJS
+$(ZIP_OBJS): ../../Archive/Zip/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF COMPRESS_OBJS
+$(COMPRESS_OBJS): ../../Compress/$(*B).cpp
+ $(COMPL_O2)
+!ENDIF
+
+!IFDEF CRYPTO_OBJS
+$(CRYPTO_OBJS): ../../Crypto/$(*B).cpp
+ $(COMPL_O2)
+!ENDIF
+
+!IFDEF UI_COMMON_OBJS
+$(UI_COMMON_OBJS): ../../UI/Common/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF AGENT_OBJS
+$(AGENT_OBJS): ../../UI/Agent/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF CONSOLE_OBJS
+$(CONSOLE_OBJS): ../../UI/Console/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF EXPLORER_OBJS
+$(EXPLORER_OBJS): ../../UI/Explorer/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF FM_OBJS
+$(FM_OBJS): ../../UI/FileManager/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF GUI_OBJS
+$(GUI_OBJS): ../../UI/GUI/$(*B).cpp
+ $(COMPL)
+!ENDIF
+
+!IFDEF C_OBJS
+$(C_OBJS): ../../../../C/$(*B).c
+ $(COMPL_O2)
+!ENDIF
+
+
+!ELSE
+
+{.}.cpp{$O}.obj::
+ $(COMPLB)
+{../../../Common}.cpp{$O}.obj::
+ $(COMPLB)
+{../../../Windows}.cpp{$O}.obj::
+ $(COMPLB)
+{../../../Windows/Control}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Common}.cpp{$O}.obj::
+ $(COMPLB)
+
+{../../UI/Common}.cpp{$O}.obj::
+ $(COMPLB)
+{../../UI/Agent}.cpp{$O}.obj::
+ $(COMPLB)
+{../../UI/Console}.cpp{$O}.obj::
+ $(COMPLB)
+{../../UI/Explorer}.cpp{$O}.obj::
+ $(COMPLB)
+{../../UI/FileManager}.cpp{$O}.obj::
+ $(COMPLB)
+{../../UI/GUI}.cpp{$O}.obj::
+ $(COMPLB)
+
+
+{../../Archive}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Common}.cpp{$O}.obj::
+ $(COMPLB)
+
+{../../Archive/7z}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Cab}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Chm}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Com}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Iso}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Nsis}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Rar}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Tar}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Udf}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Wim}.cpp{$O}.obj::
+ $(COMPLB)
+{../../Archive/Zip}.cpp{$O}.obj::
+ $(COMPLB)
+
+{../../Compress}.cpp{$O}.obj::
+ $(COMPLB_O2)
+{../../Crypto}.cpp{$O}.obj::
+ $(COMPLB_O2)
+{../../../../C}.c{$O}.obj::
+ $(CCOMPLB)
+
+!ENDIF
+
+!include "Asm.mak"
diff --git a/CPP/7zip/7zip_gcc.mak b/CPP/7zip/7zip_gcc.mak
new file mode 100644
index 0000000..8bf0594
--- /dev/null
+++ b/CPP/7zip/7zip_gcc.mak
@@ -0,0 +1,1294 @@
+# USE_CLANG=1
+# USE_ASM = 1
+# IS_X64 = 1
+# MY_ARCH =
+# USE_ASM=
+# USE_JWASM=1
+
+MY_ARCH_2 = $(MY_ARCH)
+
+MY_ASM = asmc
+ifdef USE_JWASM
+MY_ASM = jwasm
+endif
+
+ifndef RC
+RC=windres.exe --target=pe-x86-64
+RC=windres.exe -F pe-i386
+RC=windres.exe
+endif
+
+
+PROGPATH = $(O)/$(PROG)
+PROGPATH_STATIC = $(O)/$(PROG)s
+
+
+ifneq ($(CC), xlc)
+CFLAGS_WARN_WALL = -Werror -Wall -Wextra
+endif
+
+# for object file
+# -Wa,-aln=test.s
+# -save-temps
+CFLAGS_BASE_LIST = -c
+# CFLAGS_BASE_LIST = -S
+CFLAGS_BASE = -O2 $(CFLAGS_BASE_LIST) $(CFLAGS_WARN_WALL) $(CFLAGS_WARN) \
+ -DNDEBUG -D_REENTRANT -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE \
+ -fPIC
+
+FLAGS_FLTO = -ffunction-sections
+FLAGS_FLTO = -flto
+FLAGS_FLTO =
+#
+# -DZ7_AFFINITY_DISABLE
+
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef IS_MINGW
+LDFLAGS_STATIC_2 = -static
+else
+ifndef DEF_FILE
+ifndef IS_NOT_STANDALONE
+ifndef MY_DYNAMIC_LINK
+ifneq ($(CC), clang)
+LDFLAGS_STATIC_2 =
+# -static
+# -static-libstdc++ -static-libgcc
+endif
+endif
+endif
+endif
+endif
+
+LDFLAGS_STATIC = -DNDEBUG $(LDFLAGS_STATIC_2)
+
+ifndef O
+ ifdef IS_MINGW
+ O=_o
+ else
+ O=_o
+ endif
+endif
+
+
+ifdef DEF_FILE
+
+
+ifdef IS_MINGW
+SHARED_EXT=.dll
+LDFLAGS = -shared -DEF $(DEF_FILE) $(LDFLAGS_STATIC)
+else
+SHARED_EXT=.so
+LDFLAGS = -shared -fPIC $(LDFLAGS_STATIC)
+CC_SHARED=-fPIC
+endif
+
+
+else
+
+LDFLAGS = $(LDFLAGS_STATIC)
+# -s is not required for clang, do we need it for GCC ???
+
+#-static -static-libgcc -static-libstdc++
+
+ifdef IS_MINGW
+SHARED_EXT=.exe
+else
+SHARED_EXT=
+endif
+
+endif
+
+
+PROGPATH = $(O)/$(PROG)$(SHARED_EXT)
+PROGPATH_STATIC = $(O)/$(PROG)s$(SHARED_EXT)
+
+ifdef IS_MINGW
+
+ifdef MSYSTEM
+RM = rm -f
+MY_MKDIR=mkdir -p
+DEL_OBJ_EXE = -$(RM) $(PROGPATH) $(PROGPATH_STATIC) $(OBJS)
+LIB_HTMLHELP=-lhtmlhelp
+else
+RM = del
+MY_MKDIR=mkdir
+DEL_OBJ_EXE = -$(RM) $(O)\*.o $(O)\$(PROG).exe $(O)\$(PROG).dll
+endif
+
+LIB2_GUI = -lOle32 -lGdi32 -lComctl32 -lComdlg32 -lShell32 $(LIB_HTMLHELP)
+LIB2 = -loleaut32 -luuid -ladvapi32 -lUser32 $(LIB2_GUI)
+
+CXXFLAGS_EXTRA = -DUNICODE -D_UNICODE
+# -Wno-delete-non-virtual-dtor
+
+
+else
+
+RM = rm -f
+MY_MKDIR=mkdir -p
+DEL_OBJ_EXE = -$(RM) $(PROGPATH) $(PROGPATH_STATIC) $(OBJS)
+
+# CFLAGS_BASE := $(CFLAGS_BASE) -DZ7_ST
+# CXXFLAGS_EXTRA = -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+
+# LOCAL_LIBS=-lpthread
+# LOCAL_LIBS_DLL=$(LOCAL_LIBS) -ldl
+LIB2 = -lpthread -ldl
+
+
+endif
+
+
+
+CFLAGS = $(MY_ARCH_2) $(LOCAL_FLAGS) $(CFLAGS_BASE2) $(CFLAGS_BASE) $(FLAGS_FLTO) $(CC_SHARED) -o $@
+
+
+ifdef IS_MINGW
+
+ifdef IS_X64
+AFLAGS_ABI = -win64
+else
+AFLAGS_ABI = -coff -DABI_CDECL
+# -DABI_CDECL
+# -DABI_LINUX
+# -DABI_CDECL
+endif
+AFLAGS = -nologo $(AFLAGS_ABI) -Fo$(O)/$(basename $(<F)).o
+
+else # IS_MINGW
+
+ifdef IS_X64
+AFLAGS_ABI = -elf64 -DABI_LINUX
+else
+AFLAGS_ABI = -elf -DABI_LINUX -DABI_CDECL
+# -DABI_CDECL
+# -DABI_LINUX
+# -DABI_CDECL
+endif
+AFLAGS = -nologo $(AFLAGS_ABI) -Fo$(O)/
+
+endif # IS_MINGW
+
+
+
+ifdef USE_ASM
+CONSOLE_ASM_FLAGS=-DZ7_7ZIP_ASM
+else
+CONSOLE_ASM_FLAGS=
+endif
+
+CXX_WARN_FLAGS =
+#-Wno-invalid-offsetof
+#-Wno-reorder
+
+CXXFLAGS = $(MY_ARCH_2) $(LOCAL_FLAGS) $(CXXFLAGS_BASE2) $(CFLAGS_BASE) $(FLAGS_FLTO) $(CXXFLAGS_EXTRA) $(CC_SHARED) $(CXX_WARN_FLAGS) $(CXX_STD_FLAGS) -o $@
+
+STATIC_TARGET=
+ifdef COMPL_STATIC
+STATIC_TARGET=$(PROGPATH_STATIC)
+endif
+
+
+all: $(O) $(PROGPATH) $(STATIC_TARGET)
+
+$(O):
+ $(MY_MKDIR) $(O)
+
+# LDFLAGS3= -flto
+# LDFLAGS3= -Wl,--gc-sections
+# -Wl,--print-gc-sections
+
+ifneq ($(CC), $(CROSS_COMPILE)clang)
+LFLAGS_STRIP = -s
+endif
+
+LFLAGS_ALL = $(LFLAGS_STRIP) $(MY_ARCH_2) $(LDFLAGS) $(FLAGS_FLTO) $(LD_arch) $(OBJS) $(MY_LIBS) $(LIB2)
+
+# -s : GCC : Remove all symbol table and relocation information from the executable.
+# -s : CLANG : unsupported
+# -s
+
+$(PROGPATH): $(OBJS)
+ $(CXX) -o $(PROGPATH) $(LFLAGS_ALL)
+
+$(PROGPATH_STATIC): $(OBJS)
+ $(CXX) -static -o $(PROGPATH_STATIC) $(LFLAGS_ALL)
+
+# -s strips debug sections from executable in GCC
+
+
+
+
+ifndef NO_DEFAULT_RES
+$O/resource.o: resource.rc
+ $(RC) $(RFLAGS) resource.rc $@
+
+# windres.exe : in old version mingw:
+# $(RFLAGS) resource.rc $O/resource.o
+# windres.exe : in new version mingw:
+# $(RC) $(RFLAGS) resource.rc -FO $@
+
+
+endif
+
+$O/LzmaAlone.o: LzmaAlone.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/CommandLineParser.o: ../../../Common/CommandLineParser.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CRC.o: ../../../Common/CRC.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/CrcReg.o: ../../../Common/CrcReg.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/DynLimBuf.o: ../../../Common/DynLimBuf.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/IntToString.o: ../../../Common/IntToString.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Lang.o: ../../../Common/Lang.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ListFileUtils.o: ../../../Common/ListFileUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzFindPrepare.o: ../../../Common/LzFindPrepare.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyMap.o: ../../../Common/MyMap.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyString.o: ../../../Common/MyString.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyVector.o: ../../../Common/MyVector.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyWindows.o: ../../../Common/MyWindows.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyWindows2.o: ../../../Common/MyWindows2.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyXml.o: ../../../Common/MyXml.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NewHandler.o: ../../../Common/NewHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Random.o: ../../../Common/Random.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Sha1Prepare.o: ../../../Common/Sha1Prepare.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Sha1Reg.o: ../../../Common/Sha1Reg.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Sha256Prepare.o: ../../../Common/Sha256Prepare.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Sha256Reg.o: ../../../Common/Sha256Reg.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StdInStream.o: ../../../Common/StdInStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StdOutStream.o: ../../../Common/StdOutStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StringConvert.o: ../../../Common/StringConvert.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StringToInt.o: ../../../Common/StringToInt.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TextConfig.o: ../../../Common/TextConfig.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UTFConvert.o: ../../../Common/UTFConvert.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Wildcard.o: ../../../Common/Wildcard.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XzCrc64Init.o: ../../../Common/XzCrc64Init.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XzCrc64Reg.o: ../../../Common/XzCrc64Reg.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+
+$O/Clipboard.o: ../../../Windows/Clipboard.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/COM.o: ../../../Windows/COM.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CommonDialog.o: ../../../Windows/CommonDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Console.o: ../../../Windows/Console.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DLL.o: ../../../Windows/DLL.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ErrorMsg.o: ../../../Windows/ErrorMsg.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileDir.o: ../../../Windows/FileDir.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileFind.o: ../../../Windows/FileFind.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/FileIO.o: ../../../Windows/FileIO.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/FileLink.o: ../../../Windows/FileLink.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileMapping.o: ../../../Windows/FileMapping.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileName.o: ../../../Windows/FileName.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileSystem.o: ../../../Windows/FileSystem.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MemoryGlobal.o: ../../../Windows/MemoryGlobal.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MemoryLock.o: ../../../Windows/MemoryLock.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Menu.o: ../../../Windows/Menu.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NationalTime.o: ../../../Windows/NationalTime.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Net.o: ../../../Windows/Net.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProcessMessages.o: ../../../Windows/ProcessMessages.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProcessUtils.o: ../../../Windows/ProcessUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropVariant.o: ../../../Windows/PropVariant.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropVariantConv.o: ../../../Windows/PropVariantConv.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropVariantUtils.o: ../../../Windows/PropVariantUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Registry.o: ../../../Windows/Registry.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ResourceString.o: ../../../Windows/ResourceString.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SecurityUtils.o: ../../../Windows/SecurityUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Shell.o: ../../../Windows/Shell.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Synchronization.o: ../../../Windows/Synchronization.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/System.o: ../../../Windows/System.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SystemInfo.o: ../../../Windows/SystemInfo.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TimeUtils.o: ../../../Windows/TimeUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Window.o: ../../../Windows/Window.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+
+$O/ComboBox.o: ../../../Windows/Control/ComboBox.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Dialog.o: ../../../Windows/Control/Dialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ImageList.o: ../../../Windows/Control/ImageList.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ListView.o: ../../../Windows/Control/ListView.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropertyPage.o: ../../../Windows/Control/PropertyPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Window2.o: ../../../Windows/Control/Window2.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/CreateCoder.o: ../../Common/CreateCoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CWrappers.o: ../../Common/CWrappers.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FilePathAutoRename.o: ../../Common/FilePathAutoRename.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileStreams.o: ../../Common/FileStreams.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FilterCoder.o: ../../Common/FilterCoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/InBuffer.o: ../../Common/InBuffer.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/InOutTempBuffer.o: ../../Common/InOutTempBuffer.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LimitedStreams.o: ../../Common/LimitedStreams.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LockedStream.o: ../../Common/LockedStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MemBlocks.o: ../../Common/MemBlocks.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MethodId.o: ../../Common/MethodId.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MethodProps.o: ../../Common/MethodProps.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MultiOutStream.o: ../../Common/MultiOutStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OffsetStream.o: ../../Common/OffsetStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OutBuffer.o: ../../Common/OutBuffer.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OutMemStream.o: ../../Common/OutMemStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProgressMt.o: ../../Common/ProgressMt.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProgressUtils.o: ../../Common/ProgressUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropId.o: ../../Common/PropId.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StreamBinder.o: ../../Common/StreamBinder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StreamObjects.o: ../../Common/StreamObjects.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StreamUtils.o: ../../Common/StreamUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UniqBlocks.o: ../../Common/UniqBlocks.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/VirtThread.o: ../../Common/VirtThread.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/ApfsHandler.o: ../../Archive/ApfsHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ApmHandler.o: ../../Archive/ApmHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveExports.o: ../../Archive/ArchiveExports.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArHandler.o: ../../Archive/ArHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArjHandler.o: ../../Archive/ArjHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/AvbHandler.o: ../../Archive/AvbHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Base64Handler.o: ../../Archive/Base64Handler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Bz2Handler.o: ../../Archive/Bz2Handler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ComHandler.o: ../../Archive/ComHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CpioHandler.o: ../../Archive/CpioHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CramfsHandler.o: ../../Archive/CramfsHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DeflateProps.o: ../../Archive/DeflateProps.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DllExports.o: ../../Archive/DllExports.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DllExports2.o: ../../Archive/DllExports2.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DmgHandler.o: ../../Archive/DmgHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ElfHandler.o: ../../Archive/ElfHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ExtHandler.o: ../../Archive/ExtHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FatHandler.o: ../../Archive/FatHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FlvHandler.o: ../../Archive/FlvHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/GptHandler.o: ../../Archive/GptHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/GzHandler.o: ../../Archive/GzHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HandlerCont.o: ../../Archive/HandlerCont.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HfsHandler.o: ../../Archive/HfsHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/IhexHandler.o: ../../Archive/IhexHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LpHandler.o: ../../Archive/LpHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzhHandler.o: ../../Archive/LzhHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzmaHandler.o: ../../Archive/LzmaHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MachoHandler.o: ../../Archive/MachoHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MbrHandler.o: ../../Archive/MbrHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MslzHandler.o: ../../Archive/MslzHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MubHandler.o: ../../Archive/MubHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NtfsHandler.o: ../../Archive/NtfsHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PeHandler.o: ../../Archive/PeHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PpmdHandler.o: ../../Archive/PpmdHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/QcowHandler.o: ../../Archive/QcowHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RpmHandler.o: ../../Archive/RpmHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SparseHandler.o: ../../Archive/SparseHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SplitHandler.o: ../../Archive/SplitHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SquashfsHandler.o: ../../Archive/SquashfsHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SwfHandler.o: ../../Archive/SwfHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UefiHandler.o: ../../Archive/UefiHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/VdiHandler.o: ../../Archive/VdiHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/VhdHandler.o: ../../Archive/VhdHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/VhdxHandler.o: ../../Archive/VhdxHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/VmdkHandler.o: ../../Archive/VmdkHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XarHandler.o: ../../Archive/XarHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XzHandler.o: ../../Archive/XzHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZHandler.o: ../../Archive/ZHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/7zCompressionMode.o: ../../Archive/7z/7zCompressionMode.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zDecode.o: ../../Archive/7z/7zDecode.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zEncode.o: ../../Archive/7z/7zEncode.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zExtract.o: ../../Archive/7z/7zExtract.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zFolderInStream.o: ../../Archive/7z/7zFolderInStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zHandler.o: ../../Archive/7z/7zHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zHandlerOut.o: ../../Archive/7z/7zHandlerOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zHeader.o: ../../Archive/7z/7zHeader.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zIn.o: ../../Archive/7z/7zIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zOut.o: ../../Archive/7z/7zOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zProperties.o: ../../Archive/7z/7zProperties.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zRegister.o: ../../Archive/7z/7zRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zSpecStream.o: ../../Archive/7z/7zSpecStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zUpdate.o: ../../Archive/7z/7zUpdate.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/CabBlockInStream.o: ../../Archive/Cab/CabBlockInStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CabHandler.o: ../../Archive/Cab/CabHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CabHeader.o: ../../Archive/Cab/CabHeader.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CabIn.o: ../../Archive/Cab/CabIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CabRegister.o: ../../Archive/Cab/CabRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/ChmHandler.o: ../../Archive/Chm/ChmHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ChmIn.o: ../../Archive/Chm/ChmIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/IsoHandler.o: ../../Archive/Iso/IsoHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/IsoHeader.o: ../../Archive/Iso/IsoHeader.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/IsoIn.o: ../../Archive/Iso/IsoIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/IsoRegister.o: ../../Archive/Iso/IsoRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/NsisDecode.o: ../../Archive/Nsis/NsisDecode.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NsisHandler.o: ../../Archive/Nsis/NsisHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NsisIn.o: ../../Archive/Nsis/NsisIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NsisRegister.o: ../../Archive/Nsis/NsisRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/Rar5Handler.o: ../../Archive/Rar/Rar5Handler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RarHandler.o: ../../Archive/Rar/RarHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/TarHandler.o: ../../Archive/Tar/TarHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TarHandlerOut.o: ../../Archive/Tar/TarHandlerOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TarHeader.o: ../../Archive/Tar/TarHeader.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TarIn.o: ../../Archive/Tar/TarIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TarOut.o: ../../Archive/Tar/TarOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TarRegister.o: ../../Archive/Tar/TarRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TarUpdate.o: ../../Archive/Tar/TarUpdate.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/UdfHandler.o: ../../Archive/Udf/UdfHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UdfIn.o: ../../Archive/Udf/UdfIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/WimHandler.o: ../../Archive/Wim/WimHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/WimHandlerOut.o: ../../Archive/Wim/WimHandlerOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/WimIn.o: ../../Archive/Wim/WimIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/WimRegister.o: ../../Archive/Wim/WimRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/ZipAddCommon.o: ../../Archive/Zip/ZipAddCommon.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipHandler.o: ../../Archive/Zip/ZipHandler.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipHandlerOut.o: ../../Archive/Zip/ZipHandlerOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipIn.o: ../../Archive/Zip/ZipIn.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipItem.o: ../../Archive/Zip/ZipItem.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipOut.o: ../../Archive/Zip/ZipOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipUpdate.o: ../../Archive/Zip/ZipUpdate.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipRegister.o: ../../Archive/Zip/ZipRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/Bcj2Coder.o: ../../Compress/Bcj2Coder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Bcj2Register.o: ../../Compress/Bcj2Register.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BcjCoder.o: ../../Compress/BcjCoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BcjRegister.o: ../../Compress/BcjRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BitlDecoder.o: ../../Compress/BitlDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BranchMisc.o: ../../Compress/BranchMisc.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BranchRegister.o: ../../Compress/BranchRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ByteSwap.o: ../../Compress/ByteSwap.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BZip2Crc.o: ../../Compress/BZip2Crc.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BZip2Decoder.o: ../../Compress/BZip2Decoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BZip2Encoder.o: ../../Compress/BZip2Encoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BZip2Register.o: ../../Compress/BZip2Register.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CodecExports.o: ../../Compress/CodecExports.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CopyCoder.o: ../../Compress/CopyCoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CopyRegister.o: ../../Compress/CopyRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Deflate64Register.o: ../../Compress/Deflate64Register.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DeflateDecoder.o: ../../Compress/DeflateDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DeflateEncoder.o: ../../Compress/DeflateEncoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DeflateRegister.o: ../../Compress/DeflateRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DeltaFilter.o: ../../Compress/DeltaFilter.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DllExports2Compress.o: ../../Compress/DllExports2Compress.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DllExportsCompress.o: ../../Compress/DllExportsCompress.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ImplodeDecoder.o: ../../Compress/ImplodeDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ImplodeHuffmanDecoder.o: ../../Compress/ImplodeHuffmanDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzfseDecoder.o: ../../Compress/LzfseDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzhDecoder.o: ../../Compress/LzhDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Lzma2Decoder.o: ../../Compress/Lzma2Decoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Lzma2Encoder.o: ../../Compress/Lzma2Encoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Lzma2Register.o: ../../Compress/Lzma2Register.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzmaDecoder.o: ../../Compress/LzmaDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzmaEncoder.o: ../../Compress/LzmaEncoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzmaRegister.o: ../../Compress/LzmaRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzmsDecoder.o: ../../Compress/LzmsDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzOutWindow.o: ../../Compress/LzOutWindow.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LzxDecoder.o: ../../Compress/LzxDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PpmdDecoder.o: ../../Compress/PpmdDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PpmdEncoder.o: ../../Compress/PpmdEncoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PpmdRegister.o: ../../Compress/PpmdRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PpmdZip.o: ../../Compress/PpmdZip.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/QuantumDecoder.o: ../../Compress/QuantumDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar1Decoder.o: ../../Compress/Rar1Decoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar2Decoder.o: ../../Compress/Rar2Decoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar3Decoder.o: ../../Compress/Rar3Decoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar3Vm.o: ../../Compress/Rar3Vm.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar5Decoder.o: ../../Compress/Rar5Decoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RarCodecsRegister.o: ../../Compress/RarCodecsRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ShrinkDecoder.o: ../../Compress/ShrinkDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XpressDecoder.o: ../../Compress/XpressDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XzDecoder.o: ../../Compress/XzDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/XzEncoder.o: ../../Compress/XzEncoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZDecoder.o: ../../Compress/ZDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZlibDecoder.o: ../../Compress/ZlibDecoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZlibEncoder.o: ../../Compress/ZlibEncoder.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/7zAes.o: ../../Crypto/7zAes.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/7zAesRegister.o: ../../Crypto/7zAesRegister.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HmacSha1.o: ../../Crypto/HmacSha1.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HmacSha256.o: ../../Crypto/HmacSha256.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyAes.o: ../../Crypto/MyAes.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyAesReg.o: ../../Crypto/MyAesReg.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Pbkdf2HmacSha1.o: ../../Crypto/Pbkdf2HmacSha1.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RandGen.o: ../../Crypto/RandGen.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar20Crypto.o: ../../Crypto/Rar20Crypto.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Rar5Aes.o: ../../Crypto/Rar5Aes.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RarAes.o: ../../Crypto/RarAes.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/WzAes.o: ../../Crypto/WzAes.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipCrypto.o: ../../Crypto/ZipCrypto.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipStrong.o: ../../Crypto/ZipStrong.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+
+$O/CoderMixer2.o: ../../Archive/Common/CoderMixer2.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DummyOutStream.o: ../../Archive/Common/DummyOutStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FindSignature.o: ../../Archive/Common/FindSignature.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HandlerOut.o: ../../Archive/Common/HandlerOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/InStreamWithCRC.o: ../../Archive/Common/InStreamWithCRC.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ItemNameUtils.o: ../../Archive/Common/ItemNameUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MultiStream.o: ../../Archive/Common/MultiStream.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OutStreamWithCRC.o: ../../Archive/Common/OutStreamWithCRC.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OutStreamWithSha1.o: ../../Archive/Common/OutStreamWithSha1.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ParseProperties.o: ../../Archive/Common/ParseProperties.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+
+
+$O/ArchiveCommandLine.o: ../../UI/Common/ArchiveCommandLine.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveExtractCallback.o: ../../UI/Common/ArchiveExtractCallback.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveName.o: ../../UI/Common/ArchiveName.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveOpenCallback.o: ../../UI/Common/ArchiveOpenCallback.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Bench.o: ../../UI/Common/Bench.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CompressCall.o: ../../UI/Common/CompressCall.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CompressCall2.o: ../../UI/Common/CompressCall2.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DefaultName.o: ../../UI/Common/DefaultName.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/EnumDirItems.o: ../../UI/Common/EnumDirItems.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Extract.o: ../../UI/Common/Extract.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ExtractingFilePath.o: ../../UI/Common/ExtractingFilePath.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HashCalc.o: ../../UI/Common/HashCalc.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LoadCodecs.o: ../../UI/Common/LoadCodecs.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OpenArchive.o: ../../UI/Common/OpenArchive.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropIDUtils.o: ../../UI/Common/PropIDUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SetProperties.o: ../../UI/Common/SetProperties.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SortUtils.o: ../../UI/Common/SortUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TempFiles.o: ../../UI/Common/TempFiles.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Update.o: ../../UI/Common/Update.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateAction.o: ../../UI/Common/UpdateAction.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateCallback.o: ../../UI/Common/UpdateCallback.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdatePair.o: ../../UI/Common/UpdatePair.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateProduce.o: ../../UI/Common/UpdateProduce.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/WorkDir.o: ../../UI/Common/WorkDir.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ZipRegistry.o: ../../UI/Common/ZipRegistry.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/Agent.o: ../../UI/Agent/Agent.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/AgentOut.o: ../../UI/Agent/AgentOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/AgentProxy.o: ../../UI/Agent/AgentProxy.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveFolder.o: ../../UI/Agent/ArchiveFolder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveFolderOpen.o: ../../UI/Agent/ArchiveFolderOpen.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ArchiveFolderOut.o: ../../UI/Agent/ArchiveFolderOut.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateCallbackAgent.o: ../../UI/Agent/UpdateCallbackAgent.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/Client7z.o: ../../UI/Client7z/Client7z.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+$O/BenchCon.o: ../../UI/Console/BenchCon.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ConsoleClose.o: ../../UI/Console/ConsoleClose.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ExtractCallbackConsole.o: ../../UI/Console/ExtractCallbackConsole.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HashCon.o: ../../UI/Console/HashCon.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/List.o: ../../UI/Console/List.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Main.o: ../../UI/Console/Main.cpp ../../../../C/7zVersion.h
+ $(CXX) $(CXXFLAGS) $(CONSOLE_VARIANT_FLAGS) $(CONSOLE_ASM_FLAGS) $<
+$O/MainAr.o: ../../UI/Console/MainAr.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OpenCallbackConsole.o: ../../UI/Console/OpenCallbackConsole.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PercentPrinter.o: ../../UI/Console/PercentPrinter.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateCallbackConsole.o: ../../UI/Console/UpdateCallbackConsole.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UserInputUtils.o: ../../UI/Console/UserInputUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/BenchmarkDialog.o: ../../UI/GUI/BenchmarkDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CompressDialog.o: ../../UI/GUI/CompressDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ExtractDialog.o: ../../UI/GUI/ExtractDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ExtractGUI.o: ../../UI/GUI/ExtractGUI.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/GUI.o: ../../UI/GUI/GUI.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HashGUI.o: ../../UI/GUI/HashGUI.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateCallbackGUI.o: ../../UI/GUI/UpdateCallbackGUI.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateCallbackGUI2.o: ../../UI/GUI/UpdateCallbackGUI2.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateGUI.o: ../../UI/GUI/UpdateGUI.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/MyMessages.o: ../../UI/Explorer/MyMessages.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ContextMenu.o: ../../UI/Explorer/ContextMenu.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/DllExportsExplorer.o: ../../UI/Explorer/DllExportsExplorer.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RegistryContextMenu.o: ../../UI/Explorer/RegistryContextMenu.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+
+$O/AboutDialog.o: ../../UI/FileManager/AboutDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/AltStreamsFolder.o: ../../UI/FileManager/AltStreamsFolder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/App.o: ../../UI/FileManager/App.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/BrowseDialog.o: ../../UI/FileManager/BrowseDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ClassDefs.o: ../../UI/FileManager/ClassDefs.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ComboDialog.o: ../../UI/FileManager/ComboDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/CopyDialog.o: ../../UI/FileManager/CopyDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/EditDialog.o: ../../UI/FileManager/EditDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/EditPage.o: ../../UI/FileManager/EditPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/EnumFormatEtc.o: ../../UI/FileManager/EnumFormatEtc.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ExtractCallback.o: ../../UI/FileManager/ExtractCallback.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FileFolderPluginOpen.o: ../../UI/FileManager/FileFolderPluginOpen.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FilePlugins.o: ../../UI/FileManager/FilePlugins.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FM.o: ../../UI/FileManager/FM.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FoldersPage.o: ../../UI/FileManager/FoldersPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FormatUtils.o: ../../UI/FileManager/FormatUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FSDrives.o: ../../UI/FileManager/FSDrives.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FSFolder.o: ../../UI/FileManager/FSFolder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/FSFolderCopy.o: ../../UI/FileManager/FSFolderCopy.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/HelpUtils.o: ../../UI/FileManager/HelpUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LangPage.o: ../../UI/FileManager/LangPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LangUtils.o: ../../UI/FileManager/LangUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/LinkDialog.o: ../../UI/FileManager/LinkDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ListViewDialog.o: ../../UI/FileManager/ListViewDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MenuPage.o: ../../UI/FileManager/MenuPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MessagesDialog.o: ../../UI/FileManager/MessagesDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/MyLoadMenu.o: ../../UI/FileManager/MyLoadMenu.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/NetFolder.o: ../../UI/FileManager/NetFolder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OpenCallback.o: ../../UI/FileManager/OpenCallback.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OptionsDialog.o: ../../UI/FileManager/OptionsDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/OverwriteDialog.o: ../../UI/FileManager/OverwriteDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/Panel.o: ../../UI/FileManager/Panel.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelCopy.o: ../../UI/FileManager/PanelCopy.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelCrc.o: ../../UI/FileManager/PanelCrc.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelDrag.o: ../../UI/FileManager/PanelDrag.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelFolderChange.o: ../../UI/FileManager/PanelFolderChange.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelItemOpen.o: ../../UI/FileManager/PanelItemOpen.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelItems.o: ../../UI/FileManager/PanelItems.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelKey.o: ../../UI/FileManager/PanelKey.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelListNotify.o: ../../UI/FileManager/PanelListNotify.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelMenu.o: ../../UI/FileManager/PanelMenu.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelOperations.o: ../../UI/FileManager/PanelOperations.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelSelect.o: ../../UI/FileManager/PanelSelect.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelSort.o: ../../UI/FileManager/PanelSort.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PanelSplitFile.o: ../../UI/FileManager/PanelSplitFile.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PasswordDialog.o: ../../UI/FileManager/PasswordDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProgramLocation.o: ../../UI/FileManager/ProgramLocation.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProgressDialog.o: ../../UI/FileManager/ProgressDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ProgressDialog2.o: ../../UI/FileManager/ProgressDialog2.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/PropertyName.o: ../../UI/FileManager/PropertyName.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RegistryAssociations.o: ../../UI/FileManager/RegistryAssociations.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RegistryPlugins.o: ../../UI/FileManager/RegistryPlugins.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RegistryUtils.o: ../../UI/FileManager/RegistryUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/RootFolder.o: ../../UI/FileManager/RootFolder.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SettingsPage.o: ../../UI/FileManager/SettingsPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SplitDialog.o: ../../UI/FileManager/SplitDialog.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SplitUtils.o: ../../UI/FileManager/SplitUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/StringUtils.o: ../../UI/FileManager/StringUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SysIconUtils.o: ../../UI/FileManager/SysIconUtils.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/SystemPage.o: ../../UI/FileManager/SystemPage.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/TextPairs.o: ../../UI/FileManager/TextPairs.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/UpdateCallback100.o: ../../UI/FileManager/UpdateCallback100.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/VerCtrl.o: ../../UI/FileManager/VerCtrl.cpp
+ $(CXX) $(CXXFLAGS) $<
+$O/ViewSettings.o: ../../UI/FileManager/ViewSettings.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/SfxCon.o: ../../Bundles/SFXCon/SfxCon.cpp
+ $(CXX) $(CXXFLAGS) $<
+
+$O/$(FILE_IO).o: ../../../$(FILE_IO_2).cpp
+ $(CXX) $(CXXFLAGS) $<
+
+
+
+
+
+
+$O/7zAlloc.o: ../../../../C/7zAlloc.c
+ $(CC) $(CFLAGS) $<
+$O/7zArcIn.o: ../../../../C/7zArcIn.c
+ $(CC) $(CFLAGS) $<
+$O/7zBuf.o: ../../../../C/7zBuf.c
+ $(CC) $(CFLAGS) $<
+$O/7zBuf2.o: ../../../../C/7zBuf2.c
+ $(CC) $(CFLAGS) $<
+$O/7zCrc.o: ../../../../C/7zCrc.c
+ $(CC) $(CFLAGS) $<
+$O/7zDec.o: ../../../../C/7zDec.c
+ $(CC) $(CFLAGS) $<
+$O/7zFile.o: ../../../../C/7zFile.c
+ $(CC) $(CFLAGS) $<
+$O/7zStream.o: ../../../../C/7zStream.c
+ $(CC) $(CFLAGS) $<
+$O/Aes.o: ../../../../C/Aes.c
+ $(CC) $(CFLAGS) $<
+$O/Alloc.o: ../../../../C/Alloc.c
+ $(CC) $(CFLAGS) $<
+$O/Bcj2.o: ../../../../C/Bcj2.c
+ $(CC) $(CFLAGS) $<
+$O/Bcj2Enc.o: ../../../../C/Bcj2Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Blake2s.o: ../../../../C/Blake2s.c
+ $(CC) $(CFLAGS) $<
+$O/Bra.o: ../../../../C/Bra.c
+ $(CC) $(CFLAGS) $<
+$O/Bra86.o: ../../../../C/Bra86.c
+ $(CC) $(CFLAGS) $<
+$O/BraIA64.o: ../../../../C/BraIA64.c
+ $(CC) $(CFLAGS) $<
+$O/BwtSort.o: ../../../../C/BwtSort.c
+ $(CC) $(CFLAGS) $<
+
+$O/CpuArch.o: ../../../../C/CpuArch.c
+ $(CC) $(CFLAGS) $<
+$O/Delta.o: ../../../../C/Delta.c
+ $(CC) $(CFLAGS) $<
+$O/DllSecur.o: ../../../../C/DllSecur.c
+ $(CC) $(CFLAGS) $<
+$O/HuffEnc.o: ../../../../C/HuffEnc.c
+ $(CC) $(CFLAGS) $<
+$O/LzFind.o: ../../../../C/LzFind.c
+ $(CC) $(CFLAGS) $<
+
+# ifdef MT_FILES
+$O/LzFindMt.o: ../../../../C/LzFindMt.c
+ $(CC) $(CFLAGS) $<
+
+$O/Threads.o: ../../../../C/Threads.c
+ $(CC) $(CFLAGS) $<
+# endif
+
+$O/LzmaEnc.o: ../../../../C/LzmaEnc.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma86Dec.o: ../../../../C/Lzma86Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma86Enc.o: ../../../../C/Lzma86Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma2Dec.o: ../../../../C/Lzma2Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma2DecMt.o: ../../../../C/Lzma2DecMt.c
+ $(CC) $(CFLAGS) $<
+$O/Lzma2Enc.o: ../../../../C/Lzma2Enc.c
+ $(CC) $(CFLAGS) $<
+$O/LzmaLib.o: ../../../../C/LzmaLib.c
+ $(CC) $(CFLAGS) $<
+$O/MtCoder.o: ../../../../C/MtCoder.c
+ $(CC) $(CFLAGS) $<
+$O/MtDec.o: ../../../../C/MtDec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7.o: ../../../../C/Ppmd7.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7aDec.o: ../../../../C/Ppmd7aDec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7Dec.o: ../../../../C/Ppmd7Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd7Enc.o: ../../../../C/Ppmd7Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd8.o: ../../../../C/Ppmd8.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd8Dec.o: ../../../../C/Ppmd8Dec.c
+ $(CC) $(CFLAGS) $<
+$O/Ppmd8Enc.o: ../../../../C/Ppmd8Enc.c
+ $(CC) $(CFLAGS) $<
+$O/Sha1.o: ../../../../C/Sha1.c
+ $(CC) $(CFLAGS) $<
+$O/Sha256.o: ../../../../C/Sha256.c
+ $(CC) $(CFLAGS) $<
+$O/Sort.o: ../../../../C/Sort.c
+ $(CC) $(CFLAGS) $<
+$O/SwapBytes.o: ../../../../C/SwapBytes.c
+ $(CC) $(CFLAGS) $<
+$O/Xz.o: ../../../../C/Xz.c
+ $(CC) $(CFLAGS) $<
+$O/XzCrc64.o: ../../../../C/XzCrc64.c
+ $(CC) $(CFLAGS) $<
+$O/XzDec.o: ../../../../C/XzDec.c
+ $(CC) $(CFLAGS) $<
+$O/XzEnc.o: ../../../../C/XzEnc.c
+ $(CC) $(CFLAGS) $<
+$O/XzIn.o: ../../../../C/XzIn.c
+ $(CC) $(CFLAGS) $<
+
+
+ifdef USE_ASM
+ifdef IS_X64
+USE_X86_ASM=1
+USE_X64_ASM=1
+else
+ifdef IS_X86
+USE_X86_ASM=1
+endif
+endif
+endif
+
+ifdef USE_X86_ASM
+$O/7zCrcOpt.o: ../../../../Asm/x86/7zCrcOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/XzCrc64Opt.o: ../../../../Asm/x86/XzCrc64Opt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/Sha1Opt.o: ../../../../Asm/x86/Sha1Opt.asm
+ $(MY_ASM) $(AFLAGS) $<
+$O/Sha256Opt.o: ../../../../Asm/x86/Sha256Opt.asm
+ $(MY_ASM) $(AFLAGS) $<
+
+ifndef USE_JWASM
+USE_X86_ASM_AES=1
+endif
+
+else
+$O/7zCrcOpt.o: ../../../../C/7zCrcOpt.c
+ $(CC) $(CFLAGS) $<
+$O/XzCrc64Opt.o: ../../../../C/XzCrc64Opt.c
+ $(CC) $(CFLAGS) $<
+$O/Sha1Opt.o: ../../../../C/Sha1Opt.c
+ $(CC) $(CFLAGS) $<
+$O/Sha256Opt.o: ../../../../C/Sha256Opt.c
+ $(CC) $(CFLAGS) $<
+endif
+
+
+ifdef USE_X86_ASM_AES
+$O/AesOpt.o: ../../../../Asm/x86/AesOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+else
+$O/AesOpt.o: ../../../../C/AesOpt.c
+ $(CC) $(CFLAGS) $<
+endif
+
+
+ifdef USE_X64_ASM
+$O/LzFindOpt.o: ../../../../Asm/x86/LzFindOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+else
+$O/LzFindOpt.o: ../../../../C/LzFindOpt.c
+ $(CC) $(CFLAGS) $<
+endif
+
+ifdef USE_LZMA_DEC_ASM
+
+ifdef IS_X64
+$O/LzmaDecOpt.o: ../../../../Asm/x86/LzmaDecOpt.asm
+ $(MY_ASM) $(AFLAGS) $<
+endif
+
+ifdef IS_ARM64
+$O/LzmaDecOpt.o: ../../../../Asm/arm64/LzmaDecOpt.S ../../../../Asm/arm64/7zAsm.S
+ $(CC) $(CFLAGS) $<
+endif
+
+$O/LzmaDec.o: ../../../../C/LzmaDec.c
+ $(CC) $(CFLAGS) -DZ7_LZMA_DEC_OPT $<
+
+else
+
+$O/LzmaDec.o: ../../../../C/LzmaDec.c
+ $(CC) $(CFLAGS) $<
+
+endif
+
+
+
+
+$O/7zMain.o: ../../../../C/Util/7z/7zMain.c
+ $(CC) $(CFLAGS) $<
+$O/LzmaUtil.o: ../../../../C/Util/Lzma/LzmaUtil.c
+ $(CC) $(CFLAGS) $<
+
+ifneq ($(CC), xlc)
+SHOW_PREDEF=-dM
+else
+SHOW_PREDEF= -qshowmacros=pre
+endif
+
+predef_cc:
+ $(CC) $(CFLAGS) -E $(SHOW_PREDEF) ../../../../C/CpuArch.c > predef_cc_log
+# $(CC) $(CFLAGS) -E -dM - < /dev/null
+predef_cxx:
+ $(CXX) $(CFLAGS) -E $(SHOW_PREDEF) ../../../Common/CrcReg.cpp > predef_cxx_log
+
+predef: predef_cc predef_cxx
+
+
+clean:
+ -$(DEL_OBJ_EXE)
diff --git a/CPP/7zip/Aes.mak b/CPP/7zip/Aes.mak
index 3d0d877..7d8da2d 100644
--- a/CPP/7zip/Aes.mak
+++ b/CPP/7zip/Aes.mak
@@ -1,7 +1,10 @@
-C_OBJS = $(C_OBJS) \
- $O\Aes.obj
-
-!IF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
-ASM_OBJS = $(ASM_OBJS) \
- $O\AesOpt.obj
-!ENDIF
+C_OBJS = $(C_OBJS) \
+ $O\Aes.obj
+
+!IF defined(USE_C_AES) || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+ $O\AesOpt.obj
+!ELSEIF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+ASM_OBJS = $(ASM_OBJS) \
+ $O\AesOpt.obj
+!ENDIF
diff --git a/CPP/7zip/Archive/7z/7z.dsp b/CPP/7zip/Archive/7z/7z.dsp
new file mode 100644
index 0000000..2c3e144
--- /dev/null
+++ b/CPP/7zip/Archive/7z/7z.dsp
@@ -0,0 +1,638 @@
+# Microsoft Developer Studio Project File - Name="7z" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=7z - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "7z.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "7z.mak" CFG="7z - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "7z - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "7z - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W3 /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /D "Z7_EXTERNAL_CODECS" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"C:\Util\Formats\7z.dll" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W3 /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /D "Z7_EXTERNAL_CODECS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"C:\Util\Formats\7z.dll" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "7z - Win32 Release"
+# Name "7z - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Archive.def
+# End Source File
+# Begin Source File
+
+SOURCE=..\ArchiveExports.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CodecExports.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\DllExports2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Engine"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\7zCompressionMode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zEncode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zEncode.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zFolderInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zFolderInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zSpecStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zSpecStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zUpdate.h
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IMyUnknown.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Buffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HandlerOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\InStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\InStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OutStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ParseProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ParseProperties.h
+# End Source File
+# End Group
+# Begin Group "7-Zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterArc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterCodec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/Archive/7z/7z.dsw b/CPP/7zip/Archive/7z/7z.dsw
new file mode 100644
index 0000000..702a86c
--- /dev/null
+++ b/CPP/7zip/Archive/7z/7z.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "7z"=".\7z.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Archive/7z/7zCompressionMode.cpp b/CPP/7zip/Archive/7z/7zCompressionMode.cpp
index 232c638..6774fc4 100644
--- a/CPP/7zip/Archive/7z/7zCompressionMode.cpp
+++ b/CPP/7zip/Archive/7z/7zCompressionMode.cpp
@@ -1,3 +1,3 @@
-// CompressionMethod.cpp
-
-#include "StdAfx.h"
+// CompressionMethod.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Archive/7z/7zCompressionMode.h b/CPP/7zip/Archive/7z/7zCompressionMode.h
index 2360017..ac1f6ad 100644
--- a/CPP/7zip/Archive/7z/7zCompressionMode.h
+++ b/CPP/7zip/Archive/7z/7zCompressionMode.h
@@ -1,76 +1,91 @@
-// 7zCompressionMode.h
-
-#ifndef __7Z_COMPRESSION_MODE_H
-#define __7Z_COMPRESSION_MODE_H
-
-#include "../../Common/MethodId.h"
-#include "../../Common/MethodProps.h"
-
-namespace NArchive {
-namespace N7z {
-
-struct CMethodFull: public CMethodProps
-{
- CMethodId Id;
- UInt32 NumStreams;
- int CodecIndex;
-
- CMethodFull(): CodecIndex(-1) {}
- bool IsSimpleCoder() const { return NumStreams == 1; }
-};
-
-struct CBond2
-{
- UInt32 OutCoder;
- UInt32 OutStream;
- UInt32 InCoder;
-};
-
-struct CCompressionMethodMode
-{
- /*
- if (Bonds.Empty()), then default bonds must be created
- if (Filter_was_Inserted)
- {
- Methods[0] is filter method
- Bonds don't contain bonds for filter (these bonds must be created)
- }
- */
-
- CObjectVector<CMethodFull> Methods;
- CRecordVector<CBond2> Bonds;
-
- bool IsThereBond_to_Coder(unsigned coderIndex) const
- {
- FOR_VECTOR(i, Bonds)
- if (Bonds[i].InCoder == coderIndex)
- return true;
- return false;
- }
-
- bool DefaultMethod_was_Inserted;
- bool Filter_was_Inserted;
-
- #ifndef _7ZIP_ST
- UInt32 NumThreads;
- bool MultiThreadMixer;
- #endif
-
- bool PasswordIsDefined;
- UString Password;
-
- bool IsEmpty() const { return (Methods.IsEmpty() && !PasswordIsDefined); }
- CCompressionMethodMode():
- DefaultMethod_was_Inserted(false),
- Filter_was_Inserted(false),
- PasswordIsDefined(false)
- #ifndef _7ZIP_ST
- , NumThreads(1)
- , MultiThreadMixer(true)
- #endif
- {}
-};
-
-}}
-
-#endif
+// 7zCompressionMode.h
+
+#ifndef ZIP7_INC_7Z_COMPRESSION_MODE_H
+#define ZIP7_INC_7Z_COMPRESSION_MODE_H
+
+#include "../../Common/MethodId.h"
+#include "../../Common/MethodProps.h"
+
+namespace NArchive {
+namespace N7z {
+
+struct CMethodFull: public CMethodProps
+{
+ CMethodId Id;
+ UInt32 NumStreams;
+ int CodecIndex;
+ UInt32 NumThreads;
+ bool Set_NumThreads;
+
+ CMethodFull(): CodecIndex(-1), NumThreads(1), Set_NumThreads(false) {}
+ bool IsSimpleCoder() const { return NumStreams == 1; }
+};
+
+struct CBond2
+{
+ UInt32 OutCoder;
+ UInt32 OutStream;
+ UInt32 InCoder;
+};
+
+struct CCompressionMethodMode
+{
+ /*
+ if (Bonds.Empty()), then default bonds must be created
+ if (Filter_was_Inserted)
+ {
+ Methods[0] is filter method
+ Bonds don't contain bonds for filter (these bonds must be created)
+ }
+ */
+
+ CObjectVector<CMethodFull> Methods;
+ CRecordVector<CBond2> Bonds;
+
+ bool IsThereBond_to_Coder(unsigned coderIndex) const
+ {
+ FOR_VECTOR(i, Bonds)
+ if (Bonds[i].InCoder == coderIndex)
+ return true;
+ return false;
+ }
+
+ bool DefaultMethod_was_Inserted;
+ bool Filter_was_Inserted;
+
+ #ifndef Z7_ST
+ UInt32 NumThreads;
+ bool NumThreads_WasForced;
+ bool MultiThreadMixer;
+ #endif
+
+ UInt64 MemoryUsageLimit;
+ bool MemoryUsageLimit_WasSet;
+
+ bool PasswordIsDefined;
+ UString Password; // _Wipe
+
+ bool IsEmpty() const { return (Methods.IsEmpty() && !PasswordIsDefined); }
+ CCompressionMethodMode():
+ DefaultMethod_was_Inserted(false)
+ , Filter_was_Inserted(false)
+ #ifndef Z7_ST
+ , NumThreads(1)
+ , NumThreads_WasForced(false)
+ , MultiThreadMixer(true)
+ #endif
+ , MemoryUsageLimit((UInt64)1 << 30)
+ , MemoryUsageLimit_WasSet(false)
+ , PasswordIsDefined(false)
+ {}
+
+#ifdef Z7_CPP_IS_SUPPORTED_default
+ CCompressionMethodMode(const CCompressionMethodMode &) = default;
+ CCompressionMethodMode& operator =(const CCompressionMethodMode &) = default;
+#endif
+ ~CCompressionMethodMode() { Password.Wipe_and_Empty(); }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zDecode.cpp b/CPP/7zip/Archive/7z/7zDecode.cpp
index f61ad4a..5420dce 100644
--- a/CPP/7zip/Archive/7z/7zDecode.cpp
+++ b/CPP/7zip/Archive/7z/7zDecode.cpp
@@ -1,569 +1,599 @@
-// 7zDecode.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/LimitedStreams.h"
-#include "../../Common/ProgressUtils.h"
-#include "../../Common/StreamObjects.h"
-
-#include "7zDecode.h"
-
-namespace NArchive {
-namespace N7z {
-
-class CDecProgress:
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
- CMyComPtr<ICompressProgressInfo> _progress;
-public:
- CDecProgress(ICompressProgressInfo *progress): _progress(progress) {}
-
- MY_UNKNOWN_IMP1(ICompressProgressInfo)
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-};
-
-STDMETHODIMP CDecProgress::SetRatioInfo(const UInt64 * /* inSize */, const UInt64 *outSize)
-{
- return _progress->SetRatioInfo(NULL, outSize);
-}
-
-static void Convert_FolderInfo_to_BindInfo(const CFolderEx &folder, CBindInfoEx &bi)
-{
- bi.Clear();
-
- bi.Bonds.ClearAndSetSize(folder.Bonds.Size());
- unsigned i;
- for (i = 0; i < folder.Bonds.Size(); i++)
- {
- NCoderMixer2::CBond &bond = bi.Bonds[i];
- const N7z::CBond &folderBond = folder.Bonds[i];
- bond.PackIndex = folderBond.PackIndex;
- bond.UnpackIndex = folderBond.UnpackIndex;
- }
-
- bi.Coders.ClearAndSetSize(folder.Coders.Size());
- bi.CoderMethodIDs.ClearAndSetSize(folder.Coders.Size());
- for (i = 0; i < folder.Coders.Size(); i++)
- {
- const CCoderInfo &coderInfo = folder.Coders[i];
- bi.Coders[i].NumStreams = coderInfo.NumStreams;
- bi.CoderMethodIDs[i] = coderInfo.MethodID;
- }
-
- /*
- if (!bi.SetUnpackCoder())
- throw 1112;
- */
- bi.UnpackCoder = folder.UnpackCoder;
- bi.PackStreams.ClearAndSetSize(folder.PackStreams.Size());
- for (i = 0; i < folder.PackStreams.Size(); i++)
- bi.PackStreams[i] = folder.PackStreams[i];
-}
-
-static inline bool AreCodersEqual(
- const NCoderMixer2::CCoderStreamsInfo &a1,
- const NCoderMixer2::CCoderStreamsInfo &a2)
-{
- return (a1.NumStreams == a2.NumStreams);
-}
-
-static inline bool AreBondsEqual(
- const NCoderMixer2::CBond &a1,
- const NCoderMixer2::CBond &a2)
-{
- return
- (a1.PackIndex == a2.PackIndex) &&
- (a1.UnpackIndex == a2.UnpackIndex);
-}
-
-static bool AreBindInfoExEqual(const CBindInfoEx &a1, const CBindInfoEx &a2)
-{
- if (a1.Coders.Size() != a2.Coders.Size())
- return false;
- unsigned i;
- for (i = 0; i < a1.Coders.Size(); i++)
- if (!AreCodersEqual(a1.Coders[i], a2.Coders[i]))
- return false;
-
- if (a1.Bonds.Size() != a2.Bonds.Size())
- return false;
- for (i = 0; i < a1.Bonds.Size(); i++)
- if (!AreBondsEqual(a1.Bonds[i], a2.Bonds[i]))
- return false;
-
- for (i = 0; i < a1.CoderMethodIDs.Size(); i++)
- if (a1.CoderMethodIDs[i] != a2.CoderMethodIDs[i])
- return false;
-
- if (a1.PackStreams.Size() != a2.PackStreams.Size())
- return false;
- for (i = 0; i < a1.PackStreams.Size(); i++)
- if (a1.PackStreams[i] != a2.PackStreams[i])
- return false;
-
- /*
- if (a1.UnpackCoder != a2.UnpackCoder)
- return false;
- */
- return true;
-}
-
-CDecoder::CDecoder(bool useMixerMT):
- _bindInfoPrev_Defined(false),
- _useMixerMT(useMixerMT)
-{}
-
-
-struct CLockedInStream:
- public IUnknown,
- public CMyUnknownImp
-{
- CMyComPtr<IInStream> Stream;
- UInt64 Pos;
-
- MY_UNKNOWN_IMP
-
- #ifdef USE_MIXER_MT
- NWindows::NSynchronization::CCriticalSection CriticalSection;
- #endif
-};
-
-
-#ifdef USE_MIXER_MT
-
-class CLockedSequentialInStreamMT:
- public ISequentialInStream,
- public CMyUnknownImp
-{
- CLockedInStream *_glob;
- UInt64 _pos;
- CMyComPtr<IUnknown> _globRef;
-public:
- void Init(CLockedInStream *lockedInStream, UInt64 startPos)
- {
- _globRef = lockedInStream;
- _glob = lockedInStream;
- _pos = startPos;
- }
-
- MY_UNKNOWN_IMP1(ISequentialInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CLockedSequentialInStreamMT::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- NWindows::NSynchronization::CCriticalSectionLock lock(_glob->CriticalSection);
-
- if (_pos != _glob->Pos)
- {
- RINOK(_glob->Stream->Seek(_pos, STREAM_SEEK_SET, NULL));
- _glob->Pos = _pos;
- }
-
- UInt32 realProcessedSize = 0;
- HRESULT res = _glob->Stream->Read(data, size, &realProcessedSize);
- _pos += realProcessedSize;
- _glob->Pos = _pos;
- if (processedSize)
- *processedSize = realProcessedSize;
- return res;
-}
-
-#endif
-
-
-#ifdef USE_MIXER_ST
-
-class CLockedSequentialInStreamST:
- public ISequentialInStream,
- public CMyUnknownImp
-{
- CLockedInStream *_glob;
- UInt64 _pos;
- CMyComPtr<IUnknown> _globRef;
-public:
- void Init(CLockedInStream *lockedInStream, UInt64 startPos)
- {
- _globRef = lockedInStream;
- _glob = lockedInStream;
- _pos = startPos;
- }
-
- MY_UNKNOWN_IMP1(ISequentialInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CLockedSequentialInStreamST::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (_pos != _glob->Pos)
- {
- RINOK(_glob->Stream->Seek(_pos, STREAM_SEEK_SET, NULL));
- _glob->Pos = _pos;
- }
-
- UInt32 realProcessedSize = 0;
- HRESULT res = _glob->Stream->Read(data, size, &realProcessedSize);
- _pos += realProcessedSize;
- _glob->Pos = _pos;
- if (processedSize)
- *processedSize = realProcessedSize;
- return res;
-}
-
-#endif
-
-
-
-HRESULT CDecoder::Decode(
- DECL_EXTERNAL_CODECS_LOC_VARS
- IInStream *inStream,
- UInt64 startPos,
- const CFolders &folders, unsigned folderIndex,
- const UInt64 *unpackSize
-
- , ISequentialOutStream *outStream
- , ICompressProgressInfo *compressProgress
-
- , ISequentialInStream **
- #ifdef USE_MIXER_ST
- inStreamMainRes
- #endif
-
- , bool &dataAfterEnd_Error
-
- _7Z_DECODER_CRYPRO_VARS_DECL
-
- #if !defined(_7ZIP_ST)
- , bool mtMode, UInt32 numThreads, UInt64 memUsage
- #endif
- )
-{
- dataAfterEnd_Error = false;
-
- const UInt64 *packPositions = &folders.PackPositions[folders.FoStartPackStreamIndex[folderIndex]];
- CFolderEx folderInfo;
- folders.ParseFolderEx(folderIndex, folderInfo);
-
- if (!folderInfo.IsDecodingSupported())
- return E_NOTIMPL;
-
- CBindInfoEx bindInfo;
- Convert_FolderInfo_to_BindInfo(folderInfo, bindInfo);
- if (!bindInfo.CalcMapsAndCheck())
- return E_NOTIMPL;
-
- UInt64 folderUnpackSize = folders.GetFolderUnpackSize(folderIndex);
- bool fullUnpack = true;
- if (unpackSize)
- {
- if (*unpackSize > folderUnpackSize)
- return E_FAIL;
- fullUnpack = (*unpackSize == folderUnpackSize);
- }
-
- /*
- We don't need to init isEncrypted and passwordIsDefined
- We must upgrade them only
-
- #ifndef _NO_CRYPTO
- isEncrypted = false;
- passwordIsDefined = false;
- #endif
- */
-
- if (!_bindInfoPrev_Defined || !AreBindInfoExEqual(bindInfo, _bindInfoPrev))
- {
- _mixerRef.Release();
-
- #ifdef USE_MIXER_MT
- #ifdef USE_MIXER_ST
- if (_useMixerMT)
- #endif
- {
- _mixerMT = new NCoderMixer2::CMixerMT(false);
- _mixerRef = _mixerMT;
- _mixer = _mixerMT;
- }
- #ifdef USE_MIXER_ST
- else
- #endif
- #endif
- {
- #ifdef USE_MIXER_ST
- _mixerST = new NCoderMixer2::CMixerST(false);
- _mixerRef = _mixerST;
- _mixer = _mixerST;
- #endif
- }
-
- RINOK(_mixer->SetBindInfo(bindInfo));
-
- FOR_VECTOR(i, folderInfo.Coders)
- {
- const CCoderInfo &coderInfo = folderInfo.Coders[i];
-
- #ifndef _SFX
- // we don't support RAR codecs here
- if ((coderInfo.MethodID >> 8) == 0x403)
- return E_NOTIMPL;
- #endif
-
- CCreatedCoder cod;
- RINOK(CreateCoder_Id(
- EXTERNAL_CODECS_LOC_VARS
- coderInfo.MethodID, false, cod));
-
- if (coderInfo.IsSimpleCoder())
- {
- if (!cod.Coder)
- return E_NOTIMPL;
- // CMethodId m = coderInfo.MethodID;
- // isFilter = (IsFilterMethod(m) || m == k_AES);
- }
- else
- {
- if (!cod.Coder2 || cod.NumStreams != coderInfo.NumStreams)
- return E_NOTIMPL;
- }
- _mixer->AddCoder(cod);
-
- // now there is no codec that uses another external codec
- /*
- #ifdef EXTERNAL_CODECS
- CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
- decoderUnknown.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
- if (setCompressCodecsInfo)
- {
- // we must use g_ExternalCodecs also
- RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(__externalCodecs->GetCodecs));
- }
- #endif
- */
- }
-
- _bindInfoPrev = bindInfo;
- _bindInfoPrev_Defined = true;
- }
-
- _mixer->ReInit();
-
- UInt32 packStreamIndex = 0;
- UInt32 unpackStreamIndexStart = folders.FoToCoderUnpackSizes[folderIndex];
-
- unsigned i;
-
- #if !defined(_7ZIP_ST)
- bool mt_wasUsed = false;
- #endif
-
- for (i = 0; i < folderInfo.Coders.Size(); i++)
- {
- const CCoderInfo &coderInfo = folderInfo.Coders[i];
- IUnknown *decoder = _mixer->GetCoder(i).GetUnknown();
-
- #if !defined(_7ZIP_ST)
- if (!mt_wasUsed)
- {
- if (mtMode)
- {
- CMyComPtr<ICompressSetCoderMt> setCoderMt;
- decoder->QueryInterface(IID_ICompressSetCoderMt, (void **)&setCoderMt);
- if (setCoderMt)
- {
- mt_wasUsed = true;
- RINOK(setCoderMt->SetNumberOfThreads(numThreads));
- }
- }
- // if (memUsage != 0)
- {
- CMyComPtr<ICompressSetMemLimit> setMemLimit;
- decoder->QueryInterface(IID_ICompressSetMemLimit, (void **)&setMemLimit);
- if (setMemLimit)
- {
- mt_wasUsed = true;
- RINOK(setMemLimit->SetMemLimit(memUsage));
- }
- }
- }
- #endif
-
- {
- CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
- decoder->QueryInterface(IID_ICompressSetDecoderProperties2, (void **)&setDecoderProperties);
- if (setDecoderProperties)
- {
- const CByteBuffer &props = coderInfo.Props;
- size_t size = props.Size();
- if (size > 0xFFFFFFFF)
- return E_NOTIMPL;
- HRESULT res = setDecoderProperties->SetDecoderProperties2((const Byte *)props, (UInt32)size);
- if (res == E_INVALIDARG)
- res = E_NOTIMPL;
- RINOK(res);
- }
- }
-
- #ifndef _NO_CRYPTO
- {
- CMyComPtr<ICryptoSetPassword> cryptoSetPassword;
- decoder->QueryInterface(IID_ICryptoSetPassword, (void **)&cryptoSetPassword);
- if (cryptoSetPassword)
- {
- isEncrypted = true;
- if (!getTextPassword)
- return E_NOTIMPL;
- CMyComBSTR passwordBSTR;
- RINOK(getTextPassword->CryptoGetTextPassword(&passwordBSTR));
- passwordIsDefined = true;
- password.Empty();
- size_t len = 0;
- if (passwordBSTR)
- {
- password = passwordBSTR;
- len = password.Len();
- }
- CByteBuffer buffer(len * 2);
- for (size_t k = 0; k < len; k++)
- {
- wchar_t c = passwordBSTR[k];
- ((Byte *)buffer)[k * 2] = (Byte)c;
- ((Byte *)buffer)[k * 2 + 1] = (Byte)(c >> 8);
- }
- RINOK(cryptoSetPassword->CryptoSetPassword((const Byte *)buffer, (UInt32)buffer.Size()));
- }
- }
- #endif
-
- bool finishMode = false;
- {
- CMyComPtr<ICompressSetFinishMode> setFinishMode;
- decoder->QueryInterface(IID_ICompressSetFinishMode, (void **)&setFinishMode);
- if (setFinishMode)
- {
- finishMode = fullUnpack;
- RINOK(setFinishMode->SetFinishMode(BoolToInt(finishMode)));
- }
- }
-
- UInt32 numStreams = (UInt32)coderInfo.NumStreams;
-
- CObjArray<UInt64> packSizes(numStreams);
- CObjArray<const UInt64 *> packSizesPointers(numStreams);
-
- for (UInt32 j = 0; j < numStreams; j++, packStreamIndex++)
- {
- int bond = folderInfo.FindBond_for_PackStream(packStreamIndex);
-
- if (bond >= 0)
- packSizesPointers[j] = &folders.CoderUnpackSizes[unpackStreamIndexStart + folderInfo.Bonds[(unsigned)bond].UnpackIndex];
- else
- {
- int index = folderInfo.Find_in_PackStreams(packStreamIndex);
- if (index < 0)
- return E_NOTIMPL;
- packSizes[j] = packPositions[(unsigned)index + 1] - packPositions[(unsigned)index];
- packSizesPointers[j] = &packSizes[j];
- }
- }
-
- const UInt64 *unpackSizesPointer =
- (unpackSize && i == bindInfo.UnpackCoder) ?
- unpackSize :
- &folders.CoderUnpackSizes[unpackStreamIndexStart + i];
-
- _mixer->SetCoderInfo(i, unpackSizesPointer, packSizesPointers, finishMode);
- }
-
- if (outStream)
- {
- _mixer->SelectMainCoder(!fullUnpack);
- }
-
- CObjectVector< CMyComPtr<ISequentialInStream> > inStreams;
-
- CLockedInStream *lockedInStreamSpec = new CLockedInStream;
- CMyComPtr<IUnknown> lockedInStream = lockedInStreamSpec;
-
- bool needMtLock = false;
-
- if (folderInfo.PackStreams.Size() > 1)
- {
- // lockedInStream.Pos = (UInt64)(Int64)-1;
- // RINOK(inStream->Seek(0, STREAM_SEEK_CUR, &lockedInStream.Pos));
- RINOK(inStream->Seek(startPos + packPositions[0], STREAM_SEEK_SET, &lockedInStreamSpec->Pos));
- lockedInStreamSpec->Stream = inStream;
-
- #ifdef USE_MIXER_ST
- if (_mixer->IsThere_ExternalCoder_in_PackTree(_mixer->MainCoderIndex))
- #endif
- needMtLock = true;
- }
-
- for (unsigned j = 0; j < folderInfo.PackStreams.Size(); j++)
- {
- CMyComPtr<ISequentialInStream> packStream;
- UInt64 packPos = startPos + packPositions[j];
-
- if (folderInfo.PackStreams.Size() == 1)
- {
- RINOK(inStream->Seek(packPos, STREAM_SEEK_SET, NULL));
- packStream = inStream;
- }
- else
- {
- #ifdef USE_MIXER_MT
- #ifdef USE_MIXER_ST
- if (_useMixerMT || needMtLock)
- #endif
- {
- CLockedSequentialInStreamMT *lockedStreamImpSpec = new CLockedSequentialInStreamMT;
- packStream = lockedStreamImpSpec;
- lockedStreamImpSpec->Init(lockedInStreamSpec, packPos);
- }
- #ifdef USE_MIXER_ST
- else
- #endif
- #endif
- {
- #ifdef USE_MIXER_ST
- CLockedSequentialInStreamST *lockedStreamImpSpec = new CLockedSequentialInStreamST;
- packStream = lockedStreamImpSpec;
- lockedStreamImpSpec->Init(lockedInStreamSpec, packPos);
- #endif
- }
- }
-
- CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
- inStreams.AddNew() = streamSpec;
- streamSpec->SetStream(packStream);
- streamSpec->Init(packPositions[j + 1] - packPositions[j]);
- }
-
- unsigned num = inStreams.Size();
- CObjArray<ISequentialInStream *> inStreamPointers(num);
- for (i = 0; i < num; i++)
- inStreamPointers[i] = inStreams[i];
-
- if (outStream)
- {
- CMyComPtr<ICompressProgressInfo> progress2;
- if (compressProgress && !_mixer->Is_PackSize_Correct_for_Coder(_mixer->MainCoderIndex))
- progress2 = new CDecProgress(compressProgress);
-
- ISequentialOutStream *outStreamPointer = outStream;
- return _mixer->Code(inStreamPointers, &outStreamPointer,
- progress2 ? (ICompressProgressInfo *)progress2 : compressProgress,
- dataAfterEnd_Error);
- }
-
- #ifdef USE_MIXER_ST
- return _mixerST->GetMainUnpackStream(inStreamPointers, inStreamMainRes);
- #else
- return E_FAIL;
- #endif
-}
-
-}}
+// 7zDecode.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "7zDecode.h"
+
+namespace NArchive {
+namespace N7z {
+
+Z7_CLASS_IMP_COM_1(
+ CDecProgress
+ , ICompressProgressInfo
+)
+ CMyComPtr<ICompressProgressInfo> _progress;
+public:
+ CDecProgress(ICompressProgressInfo *progress): _progress(progress) {}
+};
+
+Z7_COM7F_IMF(CDecProgress::SetRatioInfo(const UInt64 * /* inSize */, const UInt64 *outSize))
+{
+ return _progress->SetRatioInfo(NULL, outSize);
+}
+
+static void Convert_FolderInfo_to_BindInfo(const CFolderEx &folder, CBindInfoEx &bi)
+{
+ bi.Clear();
+
+ bi.Bonds.ClearAndSetSize(folder.Bonds.Size());
+ unsigned i;
+ for (i = 0; i < folder.Bonds.Size(); i++)
+ {
+ NCoderMixer2::CBond &bond = bi.Bonds[i];
+ const N7z::CBond &folderBond = folder.Bonds[i];
+ bond.PackIndex = folderBond.PackIndex;
+ bond.UnpackIndex = folderBond.UnpackIndex;
+ }
+
+ bi.Coders.ClearAndSetSize(folder.Coders.Size());
+ bi.CoderMethodIDs.ClearAndSetSize(folder.Coders.Size());
+ for (i = 0; i < folder.Coders.Size(); i++)
+ {
+ const CCoderInfo &coderInfo = folder.Coders[i];
+ bi.Coders[i].NumStreams = coderInfo.NumStreams;
+ bi.CoderMethodIDs[i] = coderInfo.MethodID;
+ }
+
+ /*
+ if (!bi.SetUnpackCoder())
+ throw 1112;
+ */
+ bi.UnpackCoder = folder.UnpackCoder;
+ bi.PackStreams.ClearAndSetSize(folder.PackStreams.Size());
+ for (i = 0; i < folder.PackStreams.Size(); i++)
+ bi.PackStreams[i] = folder.PackStreams[i];
+}
+
+static inline bool AreCodersEqual(
+ const NCoderMixer2::CCoderStreamsInfo &a1,
+ const NCoderMixer2::CCoderStreamsInfo &a2)
+{
+ return (a1.NumStreams == a2.NumStreams);
+}
+
+static inline bool AreBondsEqual(
+ const NCoderMixer2::CBond &a1,
+ const NCoderMixer2::CBond &a2)
+{
+ return
+ (a1.PackIndex == a2.PackIndex) &&
+ (a1.UnpackIndex == a2.UnpackIndex);
+}
+
+static bool AreBindInfoExEqual(const CBindInfoEx &a1, const CBindInfoEx &a2)
+{
+ if (a1.Coders.Size() != a2.Coders.Size())
+ return false;
+ unsigned i;
+ for (i = 0; i < a1.Coders.Size(); i++)
+ if (!AreCodersEqual(a1.Coders[i], a2.Coders[i]))
+ return false;
+
+ if (a1.Bonds.Size() != a2.Bonds.Size())
+ return false;
+ for (i = 0; i < a1.Bonds.Size(); i++)
+ if (!AreBondsEqual(a1.Bonds[i], a2.Bonds[i]))
+ return false;
+
+ for (i = 0; i < a1.CoderMethodIDs.Size(); i++)
+ if (a1.CoderMethodIDs[i] != a2.CoderMethodIDs[i])
+ return false;
+
+ if (a1.PackStreams.Size() != a2.PackStreams.Size())
+ return false;
+ for (i = 0; i < a1.PackStreams.Size(); i++)
+ if (a1.PackStreams[i] != a2.PackStreams[i])
+ return false;
+
+ /*
+ if (a1.UnpackCoder != a2.UnpackCoder)
+ return false;
+ */
+ return true;
+}
+
+CDecoder::CDecoder(bool useMixerMT):
+ _bindInfoPrev_Defined(false)
+{
+ #if defined(USE_MIXER_ST) && defined(USE_MIXER_MT)
+ _useMixerMT = useMixerMT;
+ #else
+ UNUSED_VAR(useMixerMT)
+ #endif
+}
+
+
+Z7_CLASS_IMP_COM_0(
+ CLockedInStream
+)
+public:
+ CMyComPtr<IInStream> Stream;
+ UInt64 Pos;
+
+ #ifdef USE_MIXER_MT
+ NWindows::NSynchronization::CCriticalSection CriticalSection;
+ #endif
+};
+
+
+#ifdef USE_MIXER_MT
+
+Z7_CLASS_IMP_COM_1(
+ CLockedSequentialInStreamMT
+ , ISequentialInStream
+)
+ CLockedInStream *_glob;
+ UInt64 _pos;
+ CMyComPtr<IUnknown> _globRef;
+public:
+ void Init(CLockedInStream *lockedInStream, UInt64 startPos)
+ {
+ _globRef = lockedInStream;
+ _glob = lockedInStream;
+ _pos = startPos;
+ }
+};
+
+Z7_COM7F_IMF(CLockedSequentialInStreamMT::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ NWindows::NSynchronization::CCriticalSectionLock lock(_glob->CriticalSection);
+
+ if (_pos != _glob->Pos)
+ {
+ RINOK(InStream_SeekSet(_glob->Stream, _pos))
+ _glob->Pos = _pos;
+ }
+
+ UInt32 realProcessedSize = 0;
+ const HRESULT res = _glob->Stream->Read(data, size, &realProcessedSize);
+ _pos += realProcessedSize;
+ _glob->Pos = _pos;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return res;
+}
+
+#endif
+
+
+#ifdef USE_MIXER_ST
+
+Z7_CLASS_IMP_COM_1(
+ CLockedSequentialInStreamST
+ , ISequentialInStream
+)
+ CLockedInStream *_glob;
+ UInt64 _pos;
+ CMyComPtr<IUnknown> _globRef;
+public:
+ void Init(CLockedInStream *lockedInStream, UInt64 startPos)
+ {
+ _globRef = lockedInStream;
+ _glob = lockedInStream;
+ _pos = startPos;
+ }
+};
+
+Z7_COM7F_IMF(CLockedSequentialInStreamST::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (_pos != _glob->Pos)
+ {
+ RINOK(InStream_SeekSet(_glob->Stream, _pos))
+ _glob->Pos = _pos;
+ }
+
+ UInt32 realProcessedSize = 0;
+ const HRESULT res = _glob->Stream->Read(data, size, &realProcessedSize);
+ _pos += realProcessedSize;
+ _glob->Pos = _pos;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return res;
+}
+
+#endif
+
+
+
+HRESULT CDecoder::Decode(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ IInStream *inStream,
+ UInt64 startPos,
+ const CFolders &folders, unsigned folderIndex,
+ const UInt64 *unpackSize
+
+ , ISequentialOutStream *outStream
+ , ICompressProgressInfo *compressProgress
+
+ , ISequentialInStream **
+ #ifdef USE_MIXER_ST
+ inStreamMainRes
+ #endif
+
+ , bool &dataAfterEnd_Error
+
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+
+ #if !defined(Z7_ST)
+ , bool mtMode, UInt32 numThreads, UInt64 memUsage
+ #endif
+ )
+{
+ dataAfterEnd_Error = false;
+
+ const UInt64 *packPositions = &folders.PackPositions[folders.FoStartPackStreamIndex[folderIndex]];
+ CFolderEx folderInfo;
+ folders.ParseFolderEx(folderIndex, folderInfo);
+
+ if (!folderInfo.IsDecodingSupported())
+ return E_NOTIMPL;
+
+ CBindInfoEx bindInfo;
+ Convert_FolderInfo_to_BindInfo(folderInfo, bindInfo);
+ if (!bindInfo.CalcMapsAndCheck())
+ return E_NOTIMPL;
+
+ UInt64 folderUnpackSize = folders.GetFolderUnpackSize(folderIndex);
+ bool fullUnpack = true;
+ if (unpackSize)
+ {
+ if (*unpackSize > folderUnpackSize)
+ return E_FAIL;
+ fullUnpack = (*unpackSize == folderUnpackSize);
+ }
+
+ /*
+ We don't need to init isEncrypted and passwordIsDefined
+ We must upgrade them only
+
+ #ifndef Z7_NO_CRYPTO
+ isEncrypted = false;
+ passwordIsDefined = false;
+ #endif
+ */
+
+ if (!_bindInfoPrev_Defined || !AreBindInfoExEqual(bindInfo, _bindInfoPrev))
+ {
+ _bindInfoPrev_Defined = false;
+ _mixerRef.Release();
+
+ #ifdef USE_MIXER_MT
+ #ifdef USE_MIXER_ST
+ if (_useMixerMT)
+ #endif
+ {
+ _mixerMT = new NCoderMixer2::CMixerMT(false);
+ _mixerRef = _mixerMT;
+ _mixer = _mixerMT;
+ }
+ #ifdef USE_MIXER_ST
+ else
+ #endif
+ #endif
+ {
+ #ifdef USE_MIXER_ST
+ _mixerST = new NCoderMixer2::CMixerST(false);
+ _mixerRef = _mixerST;
+ _mixer = _mixerST;
+ #endif
+ }
+
+ RINOK(_mixer->SetBindInfo(bindInfo))
+
+ FOR_VECTOR(i, folderInfo.Coders)
+ {
+ const CCoderInfo &coderInfo = folderInfo.Coders[i];
+
+ #ifndef Z7_SFX
+ // we don't support RAR codecs here
+ if ((coderInfo.MethodID >> 8) == 0x403)
+ return E_NOTIMPL;
+ #endif
+
+ CCreatedCoder cod;
+ RINOK(CreateCoder_Id(
+ EXTERNAL_CODECS_LOC_VARS
+ coderInfo.MethodID, false, cod))
+
+ if (coderInfo.IsSimpleCoder())
+ {
+ if (!cod.Coder)
+ return E_NOTIMPL;
+ // CMethodId m = coderInfo.MethodID;
+ // isFilter = (IsFilterMethod(m) || m == k_AES);
+ }
+ else
+ {
+ if (!cod.Coder2 || cod.NumStreams != coderInfo.NumStreams)
+ return E_NOTIMPL;
+ }
+ _mixer->AddCoder(cod);
+
+ // now there is no codec that uses another external codec
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
+ decoderUnknown.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
+ if (setCompressCodecsInfo)
+ {
+ // we must use g_ExternalCodecs also
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(_externalCodecs->GetCodecs));
+ }
+ #endif
+ */
+ }
+
+ _bindInfoPrev = bindInfo;
+ _bindInfoPrev_Defined = true;
+ }
+
+ RINOK(_mixer->ReInit2())
+
+ UInt32 packStreamIndex = 0;
+ UInt32 unpackStreamIndexStart = folders.FoToCoderUnpackSizes[folderIndex];
+
+ unsigned i;
+
+ #if !defined(Z7_ST)
+ bool mt_wasUsed = false;
+ #endif
+
+ for (i = 0; i < folderInfo.Coders.Size(); i++)
+ {
+ const CCoderInfo &coderInfo = folderInfo.Coders[i];
+ IUnknown *decoder = _mixer->GetCoder(i).GetUnknown();
+
+ // now there is no codec that uses another external codec
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(ISetCompressCodecsInfo,
+ setCompressCodecsInfo, decoder)
+ if (setCompressCodecsInfo)
+ {
+ // we must use g_ExternalCodecs also
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(_externalCodecs->GetCodecs))
+ }
+ }
+ #endif
+ */
+
+ #if !defined(Z7_ST)
+ if (!mt_wasUsed)
+ {
+ if (mtMode)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(ICompressSetCoderMt,
+ setCoderMt, decoder)
+ if (setCoderMt)
+ {
+ mt_wasUsed = true;
+ RINOK(setCoderMt->SetNumberOfThreads(numThreads))
+ }
+ }
+ // if (memUsage != 0)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(ICompressSetMemLimit,
+ setMemLimit, decoder)
+ if (setMemLimit)
+ {
+ mt_wasUsed = true;
+ RINOK(setMemLimit->SetMemLimit(memUsage))
+ }
+ }
+ }
+ #endif
+
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICompressSetDecoderProperties2,
+ setDecoderProperties, decoder)
+ const CByteBuffer &props = coderInfo.Props;
+ const UInt32 size32 = (UInt32)props.Size();
+ if (props.Size() != size32)
+ return E_NOTIMPL;
+ if (setDecoderProperties)
+ {
+ HRESULT res = setDecoderProperties->SetDecoderProperties2((const Byte *)props, size32);
+ if (res == E_INVALIDARG)
+ res = E_NOTIMPL;
+ RINOK(res)
+ }
+ else if (size32 != 0)
+ {
+ // v23: we fail, if decoder doesn't support properties
+ return E_NOTIMPL;
+ }
+ }
+
+ #ifndef Z7_NO_CRYPTO
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICryptoSetPassword,
+ cryptoSetPassword, decoder)
+ if (cryptoSetPassword)
+ {
+ isEncrypted = true;
+ if (!getTextPassword)
+ return E_NOTIMPL;
+ CMyComBSTR_Wipe passwordBSTR;
+ RINOK(getTextPassword->CryptoGetTextPassword(&passwordBSTR))
+ passwordIsDefined = true;
+ password.Wipe_and_Empty();
+ size_t len = 0;
+ if (passwordBSTR)
+ {
+ password = passwordBSTR;
+ len = password.Len();
+ }
+ CByteBuffer_Wipe buffer(len * 2);
+ for (size_t k = 0; k < len; k++)
+ {
+ const wchar_t c = passwordBSTR[k];
+ ((Byte *)buffer)[k * 2] = (Byte)c;
+ ((Byte *)buffer)[k * 2 + 1] = (Byte)(c >> 8);
+ }
+ RINOK(cryptoSetPassword->CryptoSetPassword((const Byte *)buffer, (UInt32)buffer.Size()))
+ }
+ }
+ #endif
+
+ bool finishMode = false;
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICompressSetFinishMode,
+ setFinishMode, decoder)
+ if (setFinishMode)
+ {
+ finishMode = fullUnpack;
+ RINOK(setFinishMode->SetFinishMode(BoolToUInt(finishMode)))
+ }
+ }
+
+ UInt32 numStreams = (UInt32)coderInfo.NumStreams;
+
+ CObjArray<UInt64> packSizes(numStreams);
+ CObjArray<const UInt64 *> packSizesPointers(numStreams);
+
+ for (UInt32 j = 0; j < numStreams; j++, packStreamIndex++)
+ {
+ int bond = folderInfo.FindBond_for_PackStream(packStreamIndex);
+
+ if (bond >= 0)
+ packSizesPointers[j] = &folders.CoderUnpackSizes[unpackStreamIndexStart + folderInfo.Bonds[(unsigned)bond].UnpackIndex];
+ else
+ {
+ int index = folderInfo.Find_in_PackStreams(packStreamIndex);
+ if (index < 0)
+ return E_NOTIMPL;
+ packSizes[j] = packPositions[(unsigned)index + 1] - packPositions[(unsigned)index];
+ packSizesPointers[j] = &packSizes[j];
+ }
+ }
+
+ const UInt64 *unpackSizesPointer =
+ (unpackSize && i == bindInfo.UnpackCoder) ?
+ unpackSize :
+ &folders.CoderUnpackSizes[unpackStreamIndexStart + i];
+
+ _mixer->SetCoderInfo(i, unpackSizesPointer, packSizesPointers, finishMode);
+ }
+
+ if (outStream)
+ {
+ _mixer->SelectMainCoder(!fullUnpack);
+ }
+
+ CObjectVector< CMyComPtr<ISequentialInStream> > inStreams;
+
+ CLockedInStream *lockedInStreamSpec = new CLockedInStream;
+ CMyComPtr<IUnknown> lockedInStream = lockedInStreamSpec;
+
+ #ifdef USE_MIXER_MT
+ #ifdef USE_MIXER_ST
+ bool needMtLock = _useMixerMT;
+ #endif
+ #endif
+
+ if (folderInfo.PackStreams.Size() > 1)
+ {
+ // lockedInStream.Pos = (UInt64)(Int64)-1;
+ // RINOK(InStream_GetPos(inStream, lockedInStream.Pos))
+ RINOK(inStream->Seek((Int64)(startPos + packPositions[0]), STREAM_SEEK_SET, &lockedInStreamSpec->Pos))
+ lockedInStreamSpec->Stream = inStream;
+
+ #ifdef USE_MIXER_MT
+ #ifdef USE_MIXER_ST
+ /*
+ For ST-mixer mode:
+ If parallel input stream reading from pack streams is possible,
+ we must use MT-lock for packed streams.
+ Internal decoders in 7-Zip will not read pack streams in parallel in ST-mixer mode.
+ So we force to needMtLock mode only if there is unknown (external) decoder.
+ */
+ if (!needMtLock && _mixer->IsThere_ExternalCoder_in_PackTree(_mixer->MainCoderIndex))
+ needMtLock = true;
+ #endif
+ #endif
+ }
+
+ for (unsigned j = 0; j < folderInfo.PackStreams.Size(); j++)
+ {
+ CMyComPtr<ISequentialInStream> packStream;
+ const UInt64 packPos = startPos + packPositions[j];
+
+ if (folderInfo.PackStreams.Size() == 1)
+ {
+ RINOK(InStream_SeekSet(inStream, packPos))
+ packStream = inStream;
+ }
+ else
+ {
+ #ifdef USE_MIXER_MT
+ #ifdef USE_MIXER_ST
+ if (needMtLock)
+ #endif
+ {
+ CLockedSequentialInStreamMT *lockedStreamImpSpec = new CLockedSequentialInStreamMT;
+ packStream = lockedStreamImpSpec;
+ lockedStreamImpSpec->Init(lockedInStreamSpec, packPos);
+ }
+ #ifdef USE_MIXER_ST
+ else
+ #endif
+ #endif
+ {
+ #ifdef USE_MIXER_ST
+ CLockedSequentialInStreamST *lockedStreamImpSpec = new CLockedSequentialInStreamST;
+ packStream = lockedStreamImpSpec;
+ lockedStreamImpSpec->Init(lockedInStreamSpec, packPos);
+ #endif
+ }
+ }
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ inStreams.AddNew() = streamSpec;
+ streamSpec->SetStream(packStream);
+ streamSpec->Init(packPositions[j + 1] - packPositions[j]);
+ }
+
+ const unsigned num = inStreams.Size();
+ CObjArray<ISequentialInStream *> inStreamPointers(num);
+ for (i = 0; i < num; i++)
+ inStreamPointers[i] = inStreams[i];
+
+ if (outStream)
+ {
+ CMyComPtr<ICompressProgressInfo> progress2;
+ if (compressProgress && !_mixer->Is_PackSize_Correct_for_Coder(_mixer->MainCoderIndex))
+ progress2 = new CDecProgress(compressProgress);
+
+ ISequentialOutStream *outStreamPointer = outStream;
+ return _mixer->Code(inStreamPointers, &outStreamPointer,
+ progress2 ? (ICompressProgressInfo *)progress2 : compressProgress,
+ dataAfterEnd_Error);
+ }
+
+ #ifdef USE_MIXER_ST
+ return _mixerST->GetMainUnpackStream(inStreamPointers, inStreamMainRes);
+ #else
+ return E_FAIL;
+ #endif
+}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zDecode.h b/CPP/7zip/Archive/7z/7zDecode.h
index 944f8a3..ee9d9c2 100644
--- a/CPP/7zip/Archive/7z/7zDecode.h
+++ b/CPP/7zip/Archive/7z/7zDecode.h
@@ -1,70 +1,73 @@
-// 7zDecode.h
-
-#ifndef __7Z_DECODE_H
-#define __7Z_DECODE_H
-
-#include "../Common/CoderMixer2.h"
-
-#include "7zIn.h"
-
-namespace NArchive {
-namespace N7z {
-
-struct CBindInfoEx: public NCoderMixer2::CBindInfo
-{
- CRecordVector<CMethodId> CoderMethodIDs;
-
- void Clear()
- {
- CBindInfo::Clear();
- CoderMethodIDs.Clear();
- }
-};
-
-class CDecoder
-{
- bool _bindInfoPrev_Defined;
- CBindInfoEx _bindInfoPrev;
-
- bool _useMixerMT;
-
- #ifdef USE_MIXER_ST
- NCoderMixer2::CMixerST *_mixerST;
- #endif
-
- #ifdef USE_MIXER_MT
- NCoderMixer2::CMixerMT *_mixerMT;
- #endif
-
- NCoderMixer2::CMixer *_mixer;
- CMyComPtr<IUnknown> _mixerRef;
-
-public:
-
- CDecoder(bool useMixerMT);
-
- HRESULT Decode(
- DECL_EXTERNAL_CODECS_LOC_VARS
- IInStream *inStream,
- UInt64 startPos,
- const CFolders &folders, unsigned folderIndex,
- const UInt64 *unpackSize // if (!unpackSize), then full folder is required
- // if (unpackSize), then only *unpackSize bytes from folder are required
-
- , ISequentialOutStream *outStream
- , ICompressProgressInfo *compressProgress
-
- , ISequentialInStream **inStreamMainRes
- , bool &dataAfterEnd_Error
-
- _7Z_DECODER_CRYPRO_VARS_DECL
-
- #if !defined(_7ZIP_ST)
- , bool mtMode, UInt32 numThreads, UInt64 memUsage
- #endif
- );
-};
-
-}}
-
-#endif
+// 7zDecode.h
+
+#ifndef ZIP7_INC_7Z_DECODE_H
+#define ZIP7_INC_7Z_DECODE_H
+
+#include "../Common/CoderMixer2.h"
+
+#include "7zIn.h"
+
+namespace NArchive {
+namespace N7z {
+
+struct CBindInfoEx: public NCoderMixer2::CBindInfo
+{
+ CRecordVector<CMethodId> CoderMethodIDs;
+
+ void Clear()
+ {
+ CBindInfo::Clear();
+ CoderMethodIDs.Clear();
+ }
+};
+
+class CDecoder
+{
+ bool _bindInfoPrev_Defined;
+ #ifdef USE_MIXER_ST
+ #ifdef USE_MIXER_MT
+ bool _useMixerMT;
+ #endif
+ #endif
+ CBindInfoEx _bindInfoPrev;
+
+ #ifdef USE_MIXER_ST
+ NCoderMixer2::CMixerST *_mixerST;
+ #endif
+
+ #ifdef USE_MIXER_MT
+ NCoderMixer2::CMixerMT *_mixerMT;
+ #endif
+
+ NCoderMixer2::CMixer *_mixer;
+ CMyComPtr<IUnknown> _mixerRef;
+
+public:
+
+ CDecoder(bool useMixerMT);
+
+ HRESULT Decode(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ IInStream *inStream,
+ UInt64 startPos,
+ const CFolders &folders, unsigned folderIndex,
+ const UInt64 *unpackSize // if (!unpackSize), then full folder is required
+ // if (unpackSize), then only *unpackSize bytes from folder are required
+
+ , ISequentialOutStream *outStream
+ , ICompressProgressInfo *compressProgress
+
+ , ISequentialInStream **inStreamMainRes
+ , bool &dataAfterEnd_Error
+
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+
+ #if !defined(Z7_ST)
+ , bool mtMode, UInt32 numThreads, UInt64 memUsage
+ #endif
+ );
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zEncode.cpp b/CPP/7zip/Archive/7z/7zEncode.cpp
index 4c0d221..78c91cf 100644
--- a/CPP/7zip/Archive/7z/7zEncode.cpp
+++ b/CPP/7zip/Archive/7z/7zEncode.cpp
@@ -1,678 +1,725 @@
-// 7zEncode.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/CreateCoder.h"
-#include "../../Common/FilterCoder.h"
-#include "../../Common/LimitedStreams.h"
-#include "../../Common/InOutTempBuffer.h"
-#include "../../Common/ProgressUtils.h"
-#include "../../Common/StreamObjects.h"
-
-#include "7zEncode.h"
-#include "7zSpecStream.h"
-
-namespace NArchive {
-namespace N7z {
-
-void CEncoder::InitBindConv()
-{
- unsigned numIn = _bindInfo.Coders.Size();
-
- _SrcIn_to_DestOut.ClearAndSetSize(numIn);
- _DestOut_to_SrcIn.ClearAndSetSize(numIn);
-
- unsigned numOut = _bindInfo.GetNum_Bonds_and_PackStreams();
- _SrcOut_to_DestIn.ClearAndSetSize(numOut);
- // _DestIn_to_SrcOut.ClearAndSetSize(numOut);
-
- UInt32 destIn = 0;
- UInt32 destOut = 0;
-
- for (unsigned i = _bindInfo.Coders.Size(); i != 0;)
- {
- i--;
-
- const NCoderMixer2::CCoderStreamsInfo &coder = _bindInfo.Coders[i];
-
- numIn--;
- numOut -= coder.NumStreams;
-
- _SrcIn_to_DestOut[numIn] = destOut;
- _DestOut_to_SrcIn[destOut] = numIn;
-
- destOut++;
-
- for (UInt32 j = 0; j < coder.NumStreams; j++, destIn++)
- {
- UInt32 index = numOut + j;
- _SrcOut_to_DestIn[index] = destIn;
- // _DestIn_to_SrcOut[destIn] = index;
- }
- }
-}
-
-void CEncoder::SetFolder(CFolder &folder)
-{
- folder.Bonds.SetSize(_bindInfo.Bonds.Size());
-
- unsigned i;
-
- for (i = 0; i < _bindInfo.Bonds.Size(); i++)
- {
- CBond &fb = folder.Bonds[i];
- const NCoderMixer2::CBond &mixerBond = _bindInfo.Bonds[_bindInfo.Bonds.Size() - 1 - i];
- fb.PackIndex = _SrcOut_to_DestIn[mixerBond.PackIndex];
- fb.UnpackIndex = _SrcIn_to_DestOut[mixerBond.UnpackIndex];
- }
-
- folder.Coders.SetSize(_bindInfo.Coders.Size());
-
- for (i = 0; i < _bindInfo.Coders.Size(); i++)
- {
- CCoderInfo &coderInfo = folder.Coders[i];
- const NCoderMixer2::CCoderStreamsInfo &coderStreamsInfo = _bindInfo.Coders[_bindInfo.Coders.Size() - 1 - i];
-
- coderInfo.NumStreams = coderStreamsInfo.NumStreams;
- coderInfo.MethodID = _decompressionMethods[i];
- // we don't free coderInfo.Props here. So coderInfo.Props can be non-empty.
- }
-
- folder.PackStreams.SetSize(_bindInfo.PackStreams.Size());
-
- for (i = 0; i < _bindInfo.PackStreams.Size(); i++)
- folder.PackStreams[i] = _SrcOut_to_DestIn[_bindInfo.PackStreams[i]];
-}
-
-
-
-static HRESULT SetCoderProps2(const CProps &props, const UInt64 *dataSizeReduce, IUnknown *coder)
-{
- CMyComPtr<ICompressSetCoderProperties> setCoderProperties;
- coder->QueryInterface(IID_ICompressSetCoderProperties, (void **)&setCoderProperties);
- if (setCoderProperties)
- return props.SetCoderProps(setCoderProperties, dataSizeReduce);
- return props.AreThereNonOptionalProps() ? E_INVALIDARG : S_OK;
-}
-
-
-
-void CMtEncMultiProgress::Init(ICompressProgressInfo *progress)
-{
- _progress = progress;
- OutSize = 0;
-}
-
-STDMETHODIMP CMtEncMultiProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
-{
- UInt64 outSize2;
- {
- #ifndef _7ZIP_ST
- NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
- #endif
- outSize2 = OutSize;
- }
-
- if (_progress)
- return _progress->SetRatioInfo(inSize, &outSize2);
-
- return S_OK;
-}
-
-
-
-HRESULT CEncoder::CreateMixerCoder(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const UInt64 *inSizeForReduce)
-{
- #ifdef USE_MIXER_MT
- #ifdef USE_MIXER_ST
- if (_options.MultiThreadMixer)
- #endif
- {
- _mixerMT = new NCoderMixer2::CMixerMT(true);
- _mixerRef = _mixerMT;
- _mixer = _mixerMT;
- }
- #ifdef USE_MIXER_ST
- else
- #endif
- #endif
- {
- #ifdef USE_MIXER_ST
- _mixerST = new NCoderMixer2::CMixerST(true);
- _mixerRef = _mixerST;
- _mixer = _mixerST;
- #endif
- }
-
- RINOK(_mixer->SetBindInfo(_bindInfo));
-
- FOR_VECTOR (m, _options.Methods)
- {
- const CMethodFull &methodFull = _options.Methods[m];
-
- CCreatedCoder cod;
-
- if (methodFull.CodecIndex >= 0)
- {
- RINOK(CreateCoder_Index(
- EXTERNAL_CODECS_LOC_VARS
- methodFull.CodecIndex, true, cod));
- }
- else
- {
- RINOK(CreateCoder_Id(
- EXTERNAL_CODECS_LOC_VARS
- methodFull.Id, true, cod));
- }
-
- if (cod.NumStreams != methodFull.NumStreams)
- return E_FAIL;
- if (!cod.Coder && !cod.Coder2)
- return E_FAIL;
-
- CMyComPtr<IUnknown> encoderCommon = cod.Coder ? (IUnknown *)cod.Coder : (IUnknown *)cod.Coder2;
-
- #ifndef _7ZIP_ST
- {
- CMyComPtr<ICompressSetCoderMt> setCoderMt;
- encoderCommon.QueryInterface(IID_ICompressSetCoderMt, &setCoderMt);
- if (setCoderMt)
- {
- RINOK(setCoderMt->SetNumberOfThreads(_options.NumThreads));
- }
- }
- #endif
-
- RINOK(SetCoderProps2(methodFull, inSizeForReduce, encoderCommon));
-
- /*
- CMyComPtr<ICryptoResetSalt> resetSalt;
- encoderCommon.QueryInterface(IID_ICryptoResetSalt, (void **)&resetSalt);
- if (resetSalt)
- {
- resetSalt->ResetSalt();
- }
- */
-
- // now there is no codec that uses another external codec
- /*
- #ifdef EXTERNAL_CODECS
- CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
- encoderCommon.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
- if (setCompressCodecsInfo)
- {
- // we must use g_ExternalCodecs also
- RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(__externalCodecs->GetCodecs));
- }
- #endif
- */
-
- CMyComPtr<ICryptoSetPassword> cryptoSetPassword;
- encoderCommon.QueryInterface(IID_ICryptoSetPassword, &cryptoSetPassword);
-
- if (cryptoSetPassword)
- {
- const unsigned sizeInBytes = _options.Password.Len() * 2;
- CByteBuffer buffer(sizeInBytes);
- for (unsigned i = 0; i < _options.Password.Len(); i++)
- {
- wchar_t c = _options.Password[i];
- ((Byte *)buffer)[i * 2] = (Byte)c;
- ((Byte *)buffer)[i * 2 + 1] = (Byte)(c >> 8);
- }
- RINOK(cryptoSetPassword->CryptoSetPassword((const Byte *)buffer, (UInt32)sizeInBytes));
- }
-
- _mixer->AddCoder(cod);
- }
- return S_OK;
-}
-
-
-
-class CSequentialOutTempBufferImp2:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CInOutTempBuffer *_buf;
-public:
- CMtEncMultiProgress *_mtProgresSpec;
-
- CSequentialOutTempBufferImp2(): _buf(0), _mtProgresSpec(NULL) {}
- void Init(CInOutTempBuffer *buffer) { _buf = buffer; }
- MY_UNKNOWN_IMP1(ISequentialOutStream)
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CSequentialOutTempBufferImp2::Write(const void *data, UInt32 size, UInt32 *processed)
-{
- if (!_buf->Write(data, size))
- {
- if (processed)
- *processed = 0;
- return E_FAIL;
- }
- if (processed)
- *processed = size;
- if (_mtProgresSpec)
- _mtProgresSpec->AddOutSize(size);
- return S_OK;
-}
-
-
-class CSequentialOutMtNotify:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
-public:
- CMyComPtr<ISequentialOutStream> _stream;
- CMtEncMultiProgress *_mtProgresSpec;
-
- CSequentialOutMtNotify(): _mtProgresSpec(NULL) {}
- MY_UNKNOWN_IMP1(ISequentialOutStream)
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CSequentialOutMtNotify::Write(const void *data, UInt32 size, UInt32 *processed)
-{
- UInt32 realProcessed = 0;
- HRESULT res = _stream->Write(data, size, &realProcessed);
- if (processed)
- *processed = realProcessed;
- if (_mtProgresSpec)
- _mtProgresSpec->AddOutSize(size);
- return res;
-}
-
-
-
-HRESULT CEncoder::Encode(
- DECL_EXTERNAL_CODECS_LOC_VARS
- ISequentialInStream *inStream,
- // const UInt64 *inStreamSize,
- const UInt64 *inSizeForReduce,
- CFolder &folderItem,
- CRecordVector<UInt64> &coderUnpackSizes,
- UInt64 &unpackSize,
- ISequentialOutStream *outStream,
- CRecordVector<UInt64> &packSizes,
- ICompressProgressInfo *compressProgress)
-{
- RINOK(EncoderConstr());
-
- if (!_mixerRef)
- {
- RINOK(CreateMixerCoder(EXTERNAL_CODECS_LOC_VARS inSizeForReduce));
- }
-
- _mixer->ReInit();
-
- CMtEncMultiProgress *mtProgressSpec = NULL;
- CMyComPtr<ICompressProgressInfo> mtProgress;
-
- CSequentialOutMtNotify *mtOutStreamNotifySpec = NULL;
- CMyComPtr<ISequentialOutStream> mtOutStreamNotify;
-
- CObjectVector<CInOutTempBuffer> inOutTempBuffers;
- CObjectVector<CSequentialOutTempBufferImp2 *> tempBufferSpecs;
- CObjectVector<CMyComPtr<ISequentialOutStream> > tempBuffers;
-
- unsigned numMethods = _bindInfo.Coders.Size();
-
- unsigned i;
-
- for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
- {
- CInOutTempBuffer &iotb = inOutTempBuffers.AddNew();
- iotb.Create();
- iotb.InitWriting();
- }
-
- for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
- {
- CSequentialOutTempBufferImp2 *tempBufferSpec = new CSequentialOutTempBufferImp2;
- CMyComPtr<ISequentialOutStream> tempBuffer = tempBufferSpec;
- tempBufferSpec->Init(&inOutTempBuffers[i - 1]);
- tempBuffers.Add(tempBuffer);
- tempBufferSpecs.Add(tempBufferSpec);
- }
-
- for (i = 0; i < numMethods; i++)
- _mixer->SetCoderInfo(i, NULL, NULL, false);
-
-
- /* inStreamSize can be used by BCJ2 to set optimal range of conversion.
- But current BCJ2 encoder uses also another way to check exact size of current file.
- So inStreamSize is not required. */
-
- /*
- if (inStreamSize)
- _mixer->SetCoderInfo(_bindInfo.UnpackCoder, inStreamSize, NULL);
- */
-
-
- CSequentialInStreamSizeCount2 *inStreamSizeCountSpec = new CSequentialInStreamSizeCount2;
- CMyComPtr<ISequentialInStream> inStreamSizeCount = inStreamSizeCountSpec;
-
- CSequentialOutStreamSizeCount *outStreamSizeCountSpec = NULL;
- CMyComPtr<ISequentialOutStream> outStreamSizeCount;
-
- inStreamSizeCountSpec->Init(inStream);
-
- ISequentialInStream *inStreamPointer = inStreamSizeCount;
- CRecordVector<ISequentialOutStream *> outStreamPointers;
-
- SetFolder(folderItem);
-
- for (i = 0; i < numMethods; i++)
- {
- IUnknown *coder = _mixer->GetCoder(i).GetUnknown();
-
- CMyComPtr<ICryptoResetInitVector> resetInitVector;
- coder->QueryInterface(IID_ICryptoResetInitVector, (void **)&resetInitVector);
- if (resetInitVector)
- {
- resetInitVector->ResetInitVector();
- }
-
- {
- CMyComPtr<ICompressSetCoderPropertiesOpt> optProps;
- coder->QueryInterface(IID_ICompressSetCoderPropertiesOpt, (void **)&optProps);
- if (optProps)
- {
- PROPID propID = NCoderPropID::kExpectedDataSize;
- NWindows::NCOM::CPropVariant prop = (UInt64)unpackSize;
- RINOK(optProps->SetCoderPropertiesOpt(&propID, &prop, 1));
- }
- }
-
- CMyComPtr<ICompressWriteCoderProperties> writeCoderProperties;
- coder->QueryInterface(IID_ICompressWriteCoderProperties, (void **)&writeCoderProperties);
-
- CByteBuffer &props = folderItem.Coders[numMethods - 1 - i].Props;
-
- if (writeCoderProperties)
- {
- CDynBufSeqOutStream *outStreamSpec = new CDynBufSeqOutStream;
- CMyComPtr<ISequentialOutStream> dynOutStream(outStreamSpec);
- outStreamSpec->Init();
- RINOK(writeCoderProperties->WriteCoderProperties(dynOutStream));
- outStreamSpec->CopyToBuffer(props);
- }
- else
- props.Free();
- }
-
- _mixer->SelectMainCoder(false);
- UInt32 mainCoder = _mixer->MainCoderIndex;
-
- bool useMtProgress = false;
- if (!_mixer->Is_PackSize_Correct_for_Coder(mainCoder))
- {
- #ifdef _7ZIP_ST
- if (!_mixer->IsThere_ExternalCoder_in_PackTree(mainCoder))
- #endif
- useMtProgress = true;
- }
-
- if (useMtProgress)
- {
- mtProgressSpec = new CMtEncMultiProgress;
- mtProgress = mtProgressSpec;
- mtProgressSpec->Init(compressProgress);
-
- mtOutStreamNotifySpec = new CSequentialOutMtNotify;
- mtOutStreamNotify = mtOutStreamNotifySpec;
- mtOutStreamNotifySpec->_stream = outStream;
- mtOutStreamNotifySpec->_mtProgresSpec = mtProgressSpec;
-
- FOR_VECTOR(t, tempBufferSpecs)
- {
- tempBufferSpecs[t]->_mtProgresSpec = mtProgressSpec;
- }
- }
-
-
- if (_bindInfo.PackStreams.Size() != 0)
- {
- outStreamSizeCountSpec = new CSequentialOutStreamSizeCount;
- outStreamSizeCount = outStreamSizeCountSpec;
- outStreamSizeCountSpec->SetStream(mtOutStreamNotify ? (ISequentialOutStream *)mtOutStreamNotify : outStream);
- outStreamSizeCountSpec->Init();
- outStreamPointers.Add(outStreamSizeCount);
- }
-
- for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
- outStreamPointers.Add(tempBuffers[i - 1]);
-
- bool dataAfterEnd_Error;
-
- RINOK(_mixer->Code(
- &inStreamPointer,
- &outStreamPointers.Front(),
- mtProgress ? (ICompressProgressInfo *)mtProgress : compressProgress, dataAfterEnd_Error));
-
- if (_bindInfo.PackStreams.Size() != 0)
- packSizes.Add(outStreamSizeCountSpec->GetSize());
-
- for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
- {
- CInOutTempBuffer &inOutTempBuffer = inOutTempBuffers[i - 1];
- RINOK(inOutTempBuffer.WriteToStream(outStream));
- packSizes.Add(inOutTempBuffer.GetDataSize());
- }
-
- unpackSize = 0;
-
- for (i = 0; i < _bindInfo.Coders.Size(); i++)
- {
- int bond = _bindInfo.FindBond_for_UnpackStream(_DestOut_to_SrcIn[i]);
- UInt64 streamSize;
- if (bond < 0)
- {
- streamSize = inStreamSizeCountSpec->GetSize();
- unpackSize = streamSize;
- }
- else
- streamSize = _mixer->GetBondStreamSize(bond);
- coderUnpackSizes.Add(streamSize);
- }
-
- return S_OK;
-}
-
-
-CEncoder::CEncoder(const CCompressionMethodMode &options):
- _constructed(false)
-{
- if (options.IsEmpty())
- throw 1;
-
- _options = options;
-
- #ifdef USE_MIXER_ST
- _mixerST = NULL;
- #endif
-
- #ifdef USE_MIXER_MT
- _mixerMT = NULL;
- #endif
-
- _mixer = NULL;
-}
-
-
-HRESULT CEncoder::EncoderConstr()
-{
- if (_constructed)
- return S_OK;
- if (_options.Methods.IsEmpty())
- {
- // it has only password method;
- if (!_options.PasswordIsDefined)
- throw 1;
- if (!_options.Bonds.IsEmpty())
- throw 1;
-
- CMethodFull method;
- method.Id = k_AES;
- method.NumStreams = 1;
- _options.Methods.Add(method);
-
- NCoderMixer2::CCoderStreamsInfo coderStreamsInfo;
- coderStreamsInfo.NumStreams = 1;
- _bindInfo.Coders.Add(coderStreamsInfo);
-
- _bindInfo.PackStreams.Add(0);
- _bindInfo.UnpackCoder = 0;
- }
- else
- {
-
- UInt32 numOutStreams = 0;
- unsigned i;
-
- for (i = 0; i < _options.Methods.Size(); i++)
- {
- const CMethodFull &methodFull = _options.Methods[i];
- NCoderMixer2::CCoderStreamsInfo cod;
-
- cod.NumStreams = methodFull.NumStreams;
-
- if (_options.Bonds.IsEmpty())
- {
- // if there are no bonds in options, we create bonds via first streams of coders
- if (i != _options.Methods.Size() - 1)
- {
- NCoderMixer2::CBond bond;
- bond.PackIndex = numOutStreams;
- bond.UnpackIndex = i + 1; // it's next coder
- _bindInfo.Bonds.Add(bond);
- }
- else if (cod.NumStreams != 0)
- _bindInfo.PackStreams.Insert(0, numOutStreams);
-
- for (UInt32 j = 1; j < cod.NumStreams; j++)
- _bindInfo.PackStreams.Add(numOutStreams + j);
- }
-
- numOutStreams += cod.NumStreams;
-
- _bindInfo.Coders.Add(cod);
- }
-
- if (!_options.Bonds.IsEmpty())
- {
- for (i = 0; i < _options.Bonds.Size(); i++)
- {
- NCoderMixer2::CBond mixerBond;
- const CBond2 &bond = _options.Bonds[i];
- if (bond.InCoder >= _bindInfo.Coders.Size()
- || bond.OutCoder >= _bindInfo.Coders.Size()
- || bond.OutStream >= _bindInfo.Coders[bond.OutCoder].NumStreams)
- return E_INVALIDARG;
- mixerBond.PackIndex = _bindInfo.GetStream_for_Coder(bond.OutCoder) + bond.OutStream;
- mixerBond.UnpackIndex = bond.InCoder;
- _bindInfo.Bonds.Add(mixerBond);
- }
-
- for (i = 0; i < numOutStreams; i++)
- if (_bindInfo.FindBond_for_PackStream(i) == -1)
- _bindInfo.PackStreams.Add(i);
- }
-
- if (!_bindInfo.SetUnpackCoder())
- return E_INVALIDARG;
-
- if (!_bindInfo.CalcMapsAndCheck())
- return E_INVALIDARG;
-
- if (_bindInfo.PackStreams.Size() != 1)
- {
- /* main_PackStream is pack stream of main path of coders tree.
- We find main_PackStream, and place to start of list of out streams.
- It allows to use more optimal memory usage for temp buffers,
- if main_PackStream is largest stream. */
-
- UInt32 ci = _bindInfo.UnpackCoder;
-
- for (;;)
- {
- if (_bindInfo.Coders[ci].NumStreams == 0)
- break;
-
- UInt32 outIndex = _bindInfo.Coder_to_Stream[ci];
- int bond = _bindInfo.FindBond_for_PackStream(outIndex);
- if (bond >= 0)
- {
- ci = _bindInfo.Bonds[bond].UnpackIndex;
- continue;
- }
-
- int si = _bindInfo.FindStream_in_PackStreams(outIndex);
- if (si >= 0)
- _bindInfo.PackStreams.MoveToFront(si);
- break;
- }
- }
-
- if (_options.PasswordIsDefined)
- {
- unsigned numCryptoStreams = _bindInfo.PackStreams.Size();
-
- unsigned numInStreams = _bindInfo.Coders.Size();
-
- for (i = 0; i < numCryptoStreams; i++)
- {
- NCoderMixer2::CBond bond;
- bond.UnpackIndex = numInStreams + i;
- bond.PackIndex = _bindInfo.PackStreams[i];
- _bindInfo.Bonds.Add(bond);
- }
- _bindInfo.PackStreams.Clear();
-
- /*
- if (numCryptoStreams == 0)
- numCryptoStreams = 1;
- */
-
- for (i = 0; i < numCryptoStreams; i++)
- {
- CMethodFull method;
- method.NumStreams = 1;
- method.Id = k_AES;
- _options.Methods.Add(method);
-
- NCoderMixer2::CCoderStreamsInfo cod;
- cod.NumStreams = 1;
- _bindInfo.Coders.Add(cod);
-
- _bindInfo.PackStreams.Add(numOutStreams++);
- }
- }
-
- }
-
- for (unsigned i = _options.Methods.Size(); i != 0;)
- _decompressionMethods.Add(_options.Methods[--i].Id);
-
- if (_bindInfo.Coders.Size() > 16)
- return E_INVALIDARG;
- if (_bindInfo.GetNum_Bonds_and_PackStreams() > 16)
- return E_INVALIDARG;
-
- if (!_bindInfo.CalcMapsAndCheck())
- return E_INVALIDARG;
-
- InitBindConv();
- _constructed = true;
- return S_OK;
-}
-
-CEncoder::~CEncoder() {}
-
-}}
+// 7zEncode.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/FilterCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/InOutTempBuffer.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+
+#include "7zEncode.h"
+#include "7zSpecStream.h"
+
+namespace NArchive {
+namespace N7z {
+
+void CEncoder::InitBindConv()
+{
+ unsigned numIn = _bindInfo.Coders.Size();
+
+ SrcIn_to_DestOut.ClearAndSetSize(numIn);
+ DestOut_to_SrcIn.ClearAndSetSize(numIn);
+
+ unsigned numOut = _bindInfo.GetNum_Bonds_and_PackStreams();
+ SrcOut_to_DestIn.ClearAndSetSize(numOut);
+ // _DestIn_to_SrcOut.ClearAndSetSize(numOut);
+
+ UInt32 destIn = 0;
+ UInt32 destOut = 0;
+
+ for (unsigned i = _bindInfo.Coders.Size(); i != 0;)
+ {
+ i--;
+
+ const NCoderMixer2::CCoderStreamsInfo &coder = _bindInfo.Coders[i];
+
+ numIn--;
+ numOut -= coder.NumStreams;
+
+ SrcIn_to_DestOut[numIn] = destOut;
+ DestOut_to_SrcIn[destOut] = numIn;
+
+ destOut++;
+
+ for (UInt32 j = 0; j < coder.NumStreams; j++, destIn++)
+ {
+ UInt32 index = numOut + j;
+ SrcOut_to_DestIn[index] = destIn;
+ // _DestIn_to_SrcOut[destIn] = index;
+ }
+ }
+}
+
+void CEncoder::SetFolder(CFolder &folder)
+{
+ folder.Bonds.SetSize(_bindInfo.Bonds.Size());
+
+ unsigned i;
+
+ for (i = 0; i < _bindInfo.Bonds.Size(); i++)
+ {
+ CBond &fb = folder.Bonds[i];
+ const NCoderMixer2::CBond &mixerBond = _bindInfo.Bonds[_bindInfo.Bonds.Size() - 1 - i];
+ fb.PackIndex = SrcOut_to_DestIn[mixerBond.PackIndex];
+ fb.UnpackIndex = SrcIn_to_DestOut[mixerBond.UnpackIndex];
+ }
+
+ folder.Coders.SetSize(_bindInfo.Coders.Size());
+
+ for (i = 0; i < _bindInfo.Coders.Size(); i++)
+ {
+ CCoderInfo &coderInfo = folder.Coders[i];
+ const NCoderMixer2::CCoderStreamsInfo &coderStreamsInfo = _bindInfo.Coders[_bindInfo.Coders.Size() - 1 - i];
+
+ coderInfo.NumStreams = coderStreamsInfo.NumStreams;
+ coderInfo.MethodID = _decompressionMethods[i];
+ // we don't free coderInfo.Props here. So coderInfo.Props can be non-empty.
+ }
+
+ folder.PackStreams.SetSize(_bindInfo.PackStreams.Size());
+
+ for (i = 0; i < _bindInfo.PackStreams.Size(); i++)
+ folder.PackStreams[i] = SrcOut_to_DestIn[_bindInfo.PackStreams[i]];
+}
+
+
+
+static HRESULT SetCoderProps2(const CProps &props, const UInt64 *dataSizeReduce, IUnknown *coder)
+{
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICompressSetCoderProperties,
+ setCoderProperties, coder)
+ if (setCoderProperties)
+ return props.SetCoderProps(setCoderProperties, dataSizeReduce);
+ return props.AreThereNonOptionalProps() ? E_INVALIDARG : S_OK;
+}
+
+
+
+void CMtEncMultiProgress::Init(ICompressProgressInfo *progress)
+{
+ _progress = progress;
+ OutSize = 0;
+}
+
+Z7_COM7F_IMF(CMtEncMultiProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+{
+ UInt64 outSize2;
+ {
+ #ifndef Z7_ST
+ NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+ #endif
+ outSize2 = OutSize;
+ }
+
+ if (_progress)
+ return _progress->SetRatioInfo(inSize, &outSize2);
+
+ return S_OK;
+}
+
+
+
+HRESULT CEncoder::CreateMixerCoder(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const UInt64 *inSizeForReduce)
+{
+ #ifdef USE_MIXER_MT
+ #ifdef USE_MIXER_ST
+ if (_options.MultiThreadMixer)
+ #endif
+ {
+ _mixerMT = new NCoderMixer2::CMixerMT(true);
+ _mixerRef = _mixerMT;
+ _mixer = _mixerMT;
+ }
+ #ifdef USE_MIXER_ST
+ else
+ #endif
+ #endif
+ {
+ #ifdef USE_MIXER_ST
+ _mixerST = new NCoderMixer2::CMixerST(true);
+ _mixerRef = _mixerST;
+ _mixer = _mixerST;
+ #endif
+ }
+
+ RINOK(_mixer->SetBindInfo(_bindInfo))
+
+ FOR_VECTOR (m, _options.Methods)
+ {
+ const CMethodFull &methodFull = _options.Methods[m];
+
+ CCreatedCoder cod;
+
+ if (methodFull.CodecIndex >= 0)
+ {
+ RINOK(CreateCoder_Index(
+ EXTERNAL_CODECS_LOC_VARS
+ (unsigned)methodFull.CodecIndex, true, cod))
+ }
+ else
+ {
+ RINOK(CreateCoder_Id(
+ EXTERNAL_CODECS_LOC_VARS
+ methodFull.Id, true, cod))
+ }
+
+ if (!cod.Coder && !cod.Coder2)
+ {
+ return E_NOTIMPL; // unsupported method, if encoder
+ // return E_FAIL;
+ }
+
+ if (cod.NumStreams != methodFull.NumStreams)
+ return E_FAIL;
+
+ CMyComPtr<IUnknown> encoderCommon = cod.Coder ? (IUnknown *)cod.Coder : (IUnknown *)cod.Coder2;
+
+ #ifndef Z7_ST
+ if (methodFull.Set_NumThreads)
+ {
+ CMyComPtr<ICompressSetCoderMt> setCoderMt;
+ encoderCommon.QueryInterface(IID_ICompressSetCoderMt, &setCoderMt);
+ if (setCoderMt)
+ {
+ RINOK(setCoderMt->SetNumberOfThreads(
+ /* _options.NumThreads */
+ methodFull.NumThreads
+ ))
+ }
+ }
+ #endif
+
+ RINOK(SetCoderProps2(methodFull, inSizeForReduce, encoderCommon))
+
+ /*
+ CMyComPtr<ICryptoResetSalt> resetSalt;
+ encoderCommon.QueryInterface(IID_ICryptoResetSalt, (void **)&resetSalt);
+ if (resetSalt)
+ {
+ resetSalt->ResetSalt();
+ }
+ */
+
+ // now there is no codec that uses another external codec
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
+ encoderCommon.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
+ if (setCompressCodecsInfo)
+ {
+ // we must use g_ExternalCodecs also
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(_externalCodecs->GetCodecs));
+ }
+ #endif
+ */
+
+ CMyComPtr<ICryptoSetPassword> cryptoSetPassword;
+ encoderCommon.QueryInterface(IID_ICryptoSetPassword, &cryptoSetPassword);
+
+ if (cryptoSetPassword)
+ {
+ const unsigned sizeInBytes = _options.Password.Len() * 2;
+ CByteBuffer_Wipe buffer(sizeInBytes);
+ for (unsigned i = 0; i < _options.Password.Len(); i++)
+ {
+ wchar_t c = _options.Password[i];
+ ((Byte *)buffer)[i * 2] = (Byte)c;
+ ((Byte *)buffer)[i * 2 + 1] = (Byte)(c >> 8);
+ }
+ RINOK(cryptoSetPassword->CryptoSetPassword((const Byte *)buffer, (UInt32)sizeInBytes))
+ }
+
+ _mixer->AddCoder(cod);
+ }
+ return S_OK;
+}
+
+
+
+Z7_CLASS_IMP_COM_1(
+ CSequentialOutTempBufferImp2
+ , ISequentialOutStream
+)
+public:
+ CInOutTempBuffer TempBuffer;
+ CMtEncMultiProgress *_mtProgressSpec;
+
+ CSequentialOutTempBufferImp2(): _mtProgressSpec(NULL) {}
+};
+
+Z7_COM7F_IMF(CSequentialOutTempBufferImp2::Write(const void *data, UInt32 size, UInt32 *processed))
+{
+ COM_TRY_BEGIN
+ if (processed)
+ *processed = 0;
+ RINOK(TempBuffer.Write_HRESULT(data, size))
+ if (processed)
+ *processed = size;
+ if (_mtProgressSpec)
+ _mtProgressSpec->AddOutSize(size);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_COM_1(
+ CSequentialOutMtNotify
+ , ISequentialOutStream
+)
+public:
+ CMyComPtr<ISequentialOutStream> _stream;
+ CMtEncMultiProgress *_mtProgressSpec;
+
+ CSequentialOutMtNotify(): _mtProgressSpec(NULL) {}
+};
+
+Z7_COM7F_IMF(CSequentialOutMtNotify::Write(const void *data, UInt32 size, UInt32 *processed))
+{
+ UInt32 realProcessed = 0;
+ HRESULT res = _stream->Write(data, size, &realProcessed);
+ if (processed)
+ *processed = realProcessed;
+ if (_mtProgressSpec)
+ _mtProgressSpec->AddOutSize(size);
+ return res;
+}
+
+
+static HRESULT FillProps_from_Coder(IUnknown *coder, CByteBuffer &props)
+{
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICompressWriteCoderProperties,
+ writeCoderProperties, coder)
+ if (writeCoderProperties)
+ {
+ CDynBufSeqOutStream *outStreamSpec = new CDynBufSeqOutStream;
+ CMyComPtr<ISequentialOutStream> dynOutStream(outStreamSpec);
+ outStreamSpec->Init();
+ RINOK(writeCoderProperties->WriteCoderProperties(dynOutStream))
+ outStreamSpec->CopyToBuffer(props);
+ }
+ else
+ props.Free();
+ return S_OK;
+}
+
+HRESULT CEncoder::Encode1(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ ISequentialInStream *inStream,
+ // const UInt64 *inStreamSize,
+ const UInt64 *inSizeForReduce,
+ UInt64 expectedDataSize,
+ CFolder &folderItem,
+ // CRecordVector<UInt64> &coderUnpackSizes,
+ // UInt64 &unpackSize,
+ ISequentialOutStream *outStream,
+ CRecordVector<UInt64> &packSizes,
+ ICompressProgressInfo *compressProgress)
+{
+ RINOK(EncoderConstr())
+
+ if (!_mixerRef)
+ {
+ RINOK(CreateMixerCoder(EXTERNAL_CODECS_LOC_VARS inSizeForReduce))
+ }
+
+ RINOK(_mixer->ReInit2())
+
+ CMtEncMultiProgress *mtProgressSpec = NULL;
+ CMyComPtr<ICompressProgressInfo> mtProgress;
+
+ CSequentialOutMtNotify *mtOutStreamNotifySpec = NULL;
+ CMyComPtr<ISequentialOutStream> mtOutStreamNotify;
+
+ CRecordVector<CSequentialOutTempBufferImp2 *> tempBufferSpecs;
+ CObjectVector<CMyComPtr<ISequentialOutStream> > tempBuffers;
+
+ unsigned i;
+
+ for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
+ {
+ CSequentialOutTempBufferImp2 *tempBufferSpec = new CSequentialOutTempBufferImp2();
+ CMyComPtr<ISequentialOutStream> tempBuffer = tempBufferSpec;
+ tempBufferSpecs.Add(tempBufferSpec);
+ tempBuffers.Add(tempBuffer);
+ }
+
+ const unsigned numMethods = _bindInfo.Coders.Size();
+
+ for (i = 0; i < numMethods; i++)
+ _mixer->SetCoderInfo(i, NULL, NULL, false);
+
+
+ /* inStreamSize can be used by BCJ2 to set optimal range of conversion.
+ But current BCJ2 encoder uses also another way to check exact size of current file.
+ So inStreamSize is not required. */
+
+ /*
+ if (inStreamSize)
+ _mixer->SetCoderInfo(_bindInfo.UnpackCoder, inStreamSize, NULL);
+ */
+
+
+ /*
+ CSequentialInStreamSizeCount2 *inStreamSizeCountSpec = new CSequentialInStreamSizeCount2;
+ CMyComPtr<ISequentialInStream> inStreamSizeCount = inStreamSizeCountSpec;
+ */
+
+ CSequentialOutStreamSizeCount *outStreamSizeCountSpec = NULL;
+ CMyComPtr<ISequentialOutStream> outStreamSizeCount;
+
+ // inStreamSizeCountSpec->Init(inStream);
+
+ // ISequentialInStream *inStreamPointer = inStreamSizeCount;
+ ISequentialInStream *inStreamPointer = inStream;
+
+ CRecordVector<ISequentialOutStream *> outStreamPointers;
+
+ SetFolder(folderItem);
+
+ for (i = 0; i < numMethods; i++)
+ {
+ IUnknown *coder = _mixer->GetCoder(i).GetUnknown();
+ /*
+ {
+ CEncoder *sfEncoder = NULL;
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IGetSfEncoderInternal,
+ sf, coder)
+ if (sf)
+ {
+ RINOK(sf->GetSfEncoder(&sfEncoder));
+ if (!sfEncoder)
+ return E_FAIL;
+
+ }
+ }
+ */
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ISetCompressCodecsInfo,
+ setCompressCodecsInfo, coder)
+ if (setCompressCodecsInfo)
+ {
+ // we must use g_ExternalCodecs also
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(_externalCodecs->GetCodecs))
+ }
+ }
+ #endif
+ */
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICryptoResetInitVector,
+ resetInitVector, coder)
+ if (resetInitVector)
+ {
+ RINOK(resetInitVector->ResetInitVector())
+ }
+ }
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICompressSetCoderPropertiesOpt,
+ optProps, coder)
+ if (optProps)
+ {
+ const PROPID propID = NCoderPropID::kExpectedDataSize;
+ NWindows::NCOM::CPropVariant prop = (UInt64)expectedDataSize;
+ RINOK(optProps->SetCoderPropertiesOpt(&propID, &prop, 1))
+ }
+ }
+ // we must write properties from coder after ResetInitVector()
+ RINOK(FillProps_from_Coder(coder, folderItem.Coders[numMethods - 1 - i].Props))
+ }
+
+ _mixer->SelectMainCoder(false);
+ const UInt32 mainCoder = _mixer->MainCoderIndex;
+
+ bool useMtProgress = false;
+ if (!_mixer->Is_PackSize_Correct_for_Coder(mainCoder))
+ {
+ #ifdef Z7_ST
+ if (!_mixer->IsThere_ExternalCoder_in_PackTree(mainCoder))
+ #endif
+ useMtProgress = true;
+ }
+
+ if (useMtProgress)
+ {
+ mtProgressSpec = new CMtEncMultiProgress;
+ mtProgress = mtProgressSpec;
+ mtProgressSpec->Init(compressProgress);
+
+ mtOutStreamNotifySpec = new CSequentialOutMtNotify;
+ mtOutStreamNotify = mtOutStreamNotifySpec;
+ mtOutStreamNotifySpec->_stream = outStream;
+ mtOutStreamNotifySpec->_mtProgressSpec = mtProgressSpec;
+
+ FOR_VECTOR (t, tempBufferSpecs)
+ {
+ tempBufferSpecs[t]->_mtProgressSpec = mtProgressSpec;
+ }
+ }
+
+
+ if (_bindInfo.PackStreams.Size() != 0)
+ {
+ outStreamSizeCountSpec = new CSequentialOutStreamSizeCount;
+ outStreamSizeCount = outStreamSizeCountSpec;
+ outStreamSizeCountSpec->SetStream(mtOutStreamNotify ? (ISequentialOutStream *)mtOutStreamNotify : outStream);
+ outStreamSizeCountSpec->Init();
+ outStreamPointers.Add(outStreamSizeCount);
+ }
+
+ for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
+ outStreamPointers.Add(tempBuffers[i - 1]);
+
+ bool dataAfterEnd_Error;
+
+ RINOK(_mixer->Code(
+ &inStreamPointer,
+ &outStreamPointers.Front(),
+ mtProgress ? (ICompressProgressInfo *)mtProgress : compressProgress, dataAfterEnd_Error))
+
+ if (_bindInfo.PackStreams.Size() != 0)
+ packSizes.Add(outStreamSizeCountSpec->GetSize());
+
+ for (i = 1; i < _bindInfo.PackStreams.Size(); i++)
+ {
+ CInOutTempBuffer &iotb = tempBufferSpecs[i - 1]->TempBuffer;
+ RINOK(iotb.WriteToStream(outStream))
+ packSizes.Add(iotb.GetDataSize());
+ }
+
+ /* Code() in some future codec can change properties.
+ v23: so we fill properties again after Code() */
+ for (i = 0; i < numMethods; i++)
+ {
+ IUnknown *coder = _mixer->GetCoder(i).GetUnknown();
+ RINOK(FillProps_from_Coder(coder, folderItem.Coders[numMethods - 1 - i].Props))
+ }
+
+ return S_OK;
+}
+
+
+void CEncoder::Encode_Post(
+ UInt64 unpackSize,
+ CRecordVector<UInt64> &coderUnpackSizes)
+{
+ // unpackSize = 0;
+ for (unsigned i = 0; i < _bindInfo.Coders.Size(); i++)
+ {
+ const int bond = _bindInfo.FindBond_for_UnpackStream(DestOut_to_SrcIn[i]);
+ UInt64 streamSize;
+ if (bond < 0)
+ {
+ // streamSize = inStreamSizeCountSpec->GetSize();
+ // unpackSize = streamSize;
+ streamSize = unpackSize;
+ }
+ else
+ streamSize = _mixer->GetBondStreamSize((unsigned)bond);
+ coderUnpackSizes.Add(streamSize);
+ }
+}
+
+
+CEncoder::CEncoder(const CCompressionMethodMode &options):
+ _constructed(false)
+{
+ if (options.IsEmpty())
+ throw 1;
+
+ _options = options;
+
+ #ifdef USE_MIXER_ST
+ _mixerST = NULL;
+ #endif
+
+ #ifdef USE_MIXER_MT
+ _mixerMT = NULL;
+ #endif
+
+ _mixer = NULL;
+}
+
+
+HRESULT CEncoder::EncoderConstr()
+{
+ if (_constructed)
+ return S_OK;
+ if (_options.Methods.IsEmpty())
+ {
+ // it has only password method;
+ if (!_options.PasswordIsDefined)
+ throw 1;
+ if (!_options.Bonds.IsEmpty())
+ throw 1;
+
+ CMethodFull method;
+ method.Id = k_AES;
+ method.NumStreams = 1;
+ _options.Methods.Add(method);
+
+ NCoderMixer2::CCoderStreamsInfo coderStreamsInfo;
+ coderStreamsInfo.NumStreams = 1;
+ _bindInfo.Coders.Add(coderStreamsInfo);
+
+ _bindInfo.PackStreams.Add(0);
+ _bindInfo.UnpackCoder = 0;
+ }
+ else
+ {
+
+ UInt32 numOutStreams = 0;
+ unsigned i;
+
+ for (i = 0; i < _options.Methods.Size(); i++)
+ {
+ const CMethodFull &methodFull = _options.Methods[i];
+ NCoderMixer2::CCoderStreamsInfo cod;
+
+ cod.NumStreams = methodFull.NumStreams;
+
+ if (_options.Bonds.IsEmpty())
+ {
+ // if there are no bonds in options, we create bonds via first streams of coders
+ if (i != _options.Methods.Size() - 1)
+ {
+ NCoderMixer2::CBond bond;
+ bond.PackIndex = numOutStreams;
+ bond.UnpackIndex = i + 1; // it's next coder
+ _bindInfo.Bonds.Add(bond);
+ }
+ else if (cod.NumStreams != 0)
+ _bindInfo.PackStreams.Insert(0, numOutStreams);
+
+ for (UInt32 j = 1; j < cod.NumStreams; j++)
+ _bindInfo.PackStreams.Add(numOutStreams + j);
+ }
+
+ numOutStreams += cod.NumStreams;
+
+ _bindInfo.Coders.Add(cod);
+ }
+
+ if (!_options.Bonds.IsEmpty())
+ {
+ for (i = 0; i < _options.Bonds.Size(); i++)
+ {
+ NCoderMixer2::CBond mixerBond;
+ const CBond2 &bond = _options.Bonds[i];
+ if (bond.InCoder >= _bindInfo.Coders.Size()
+ || bond.OutCoder >= _bindInfo.Coders.Size()
+ || bond.OutStream >= _bindInfo.Coders[bond.OutCoder].NumStreams)
+ return E_INVALIDARG;
+ mixerBond.PackIndex = _bindInfo.GetStream_for_Coder(bond.OutCoder) + bond.OutStream;
+ mixerBond.UnpackIndex = bond.InCoder;
+ _bindInfo.Bonds.Add(mixerBond);
+ }
+
+ for (i = 0; i < numOutStreams; i++)
+ if (_bindInfo.FindBond_for_PackStream(i) == -1)
+ _bindInfo.PackStreams.Add(i);
+ }
+
+ if (!_bindInfo.SetUnpackCoder())
+ return E_INVALIDARG;
+
+ if (!_bindInfo.CalcMapsAndCheck())
+ return E_INVALIDARG;
+
+ if (_bindInfo.PackStreams.Size() != 1)
+ {
+ /* main_PackStream is pack stream of main path of coders tree.
+ We find main_PackStream, and place to start of list of out streams.
+ It allows to use more optimal memory usage for temp buffers,
+ if main_PackStream is largest stream. */
+
+ UInt32 ci = _bindInfo.UnpackCoder;
+
+ for (;;)
+ {
+ if (_bindInfo.Coders[ci].NumStreams == 0)
+ break;
+
+ const UInt32 outIndex = _bindInfo.Coder_to_Stream[ci];
+ const int bond = _bindInfo.FindBond_for_PackStream(outIndex);
+ if (bond >= 0)
+ {
+ ci = _bindInfo.Bonds[(unsigned)bond].UnpackIndex;
+ continue;
+ }
+
+ const int si = _bindInfo.FindStream_in_PackStreams(outIndex);
+ if (si >= 0)
+ _bindInfo.PackStreams.MoveToFront((unsigned)si);
+ break;
+ }
+ }
+
+ if (_options.PasswordIsDefined)
+ {
+ unsigned numCryptoStreams = _bindInfo.PackStreams.Size();
+
+ unsigned numInStreams = _bindInfo.Coders.Size();
+
+ for (i = 0; i < numCryptoStreams; i++)
+ {
+ NCoderMixer2::CBond bond;
+ bond.UnpackIndex = numInStreams + i;
+ bond.PackIndex = _bindInfo.PackStreams[i];
+ _bindInfo.Bonds.Add(bond);
+ }
+ _bindInfo.PackStreams.Clear();
+
+ /*
+ if (numCryptoStreams == 0)
+ numCryptoStreams = 1;
+ */
+
+ for (i = 0; i < numCryptoStreams; i++)
+ {
+ CMethodFull method;
+ method.NumStreams = 1;
+ method.Id = k_AES;
+ _options.Methods.Add(method);
+
+ NCoderMixer2::CCoderStreamsInfo cod;
+ cod.NumStreams = 1;
+ _bindInfo.Coders.Add(cod);
+
+ _bindInfo.PackStreams.Add(numOutStreams++);
+ }
+ }
+
+ }
+
+ for (unsigned i = _options.Methods.Size(); i != 0;)
+ _decompressionMethods.Add(_options.Methods[--i].Id);
+
+ if (_bindInfo.Coders.Size() > 16)
+ return E_INVALIDARG;
+ if (_bindInfo.GetNum_Bonds_and_PackStreams() > 16)
+ return E_INVALIDARG;
+
+ if (!_bindInfo.CalcMapsAndCheck())
+ return E_INVALIDARG;
+
+ InitBindConv();
+ _constructed = true;
+ return S_OK;
+}
+
+CEncoder::~CEncoder() {}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zEncode.h b/CPP/7zip/Archive/7z/7zEncode.h
index 434cbec..849ac63 100644
--- a/CPP/7zip/Archive/7z/7zEncode.h
+++ b/CPP/7zip/Archive/7z/7zEncode.h
@@ -1,92 +1,95 @@
-// 7zEncode.h
-
-#ifndef __7Z_ENCODE_H
-#define __7Z_ENCODE_H
-
-#include "7zCompressionMode.h"
-
-#include "../Common/CoderMixer2.h"
-
-#include "7zItem.h"
-
-namespace NArchive {
-namespace N7z {
-
-class CMtEncMultiProgress:
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
- CMyComPtr<ICompressProgressInfo> _progress;
- #ifndef _7ZIP_ST
- NWindows::NSynchronization::CCriticalSection CriticalSection;
- #endif
-
-public:
- UInt64 OutSize;
-
- CMtEncMultiProgress(): OutSize(0) {}
-
- void Init(ICompressProgressInfo *progress);
-
- void AddOutSize(UInt64 addOutSize)
- {
- #ifndef _7ZIP_ST
- NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
- #endif
- OutSize += addOutSize;
- }
-
- MY_UNKNOWN_IMP1(ICompressProgressInfo)
-
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-};
-
-class CEncoder
-{
- #ifdef USE_MIXER_ST
- NCoderMixer2::CMixerST *_mixerST;
- #endif
- #ifdef USE_MIXER_MT
- NCoderMixer2::CMixerMT *_mixerMT;
- #endif
-
- NCoderMixer2::CMixer *_mixer;
- CMyComPtr<IUnknown> _mixerRef;
-
- CCompressionMethodMode _options;
- NCoderMixer2::CBindInfo _bindInfo;
- CRecordVector<CMethodId> _decompressionMethods;
-
- CRecordVector<UInt32> _SrcIn_to_DestOut;
- CRecordVector<UInt32> _SrcOut_to_DestIn;
- // CRecordVector<UInt32> _DestIn_to_SrcOut;
- CRecordVector<UInt32> _DestOut_to_SrcIn;
-
- void InitBindConv();
- void SetFolder(CFolder &folder);
-
- HRESULT CreateMixerCoder(DECL_EXTERNAL_CODECS_LOC_VARS
- const UInt64 *inSizeForReduce);
-
- bool _constructed;
-public:
-
- CEncoder(const CCompressionMethodMode &options);
- ~CEncoder();
- HRESULT EncoderConstr();
- HRESULT Encode(
- DECL_EXTERNAL_CODECS_LOC_VARS
- ISequentialInStream *inStream,
- // const UInt64 *inStreamSize,
- const UInt64 *inSizeForReduce,
- CFolder &folderItem,
- CRecordVector<UInt64> &coderUnpackSizes,
- UInt64 &unpackSize,
- ISequentialOutStream *outStream,
- CRecordVector<UInt64> &packSizes,
- ICompressProgressInfo *compressProgress);
-};
-
-}}
-
-#endif
+// 7zEncode.h
+
+#ifndef ZIP7_INC_7Z_ENCODE_H
+#define ZIP7_INC_7Z_ENCODE_H
+
+#include "7zCompressionMode.h"
+
+#include "../Common/CoderMixer2.h"
+
+#include "7zItem.h"
+
+namespace NArchive {
+namespace N7z {
+
+Z7_CLASS_IMP_COM_1(
+ CMtEncMultiProgress,
+ ICompressProgressInfo
+)
+ CMyComPtr<ICompressProgressInfo> _progress;
+ #ifndef Z7_ST
+ NWindows::NSynchronization::CCriticalSection CriticalSection;
+ #endif
+
+public:
+ UInt64 OutSize;
+
+ CMtEncMultiProgress(): OutSize(0) {}
+
+ void Init(ICompressProgressInfo *progress);
+
+ void AddOutSize(UInt64 addOutSize)
+ {
+ #ifndef Z7_ST
+ NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+ #endif
+ OutSize += addOutSize;
+ }
+};
+
+
+class CEncoder Z7_final MY_UNCOPYABLE
+{
+ #ifdef USE_MIXER_ST
+ NCoderMixer2::CMixerST *_mixerST;
+ #endif
+ #ifdef USE_MIXER_MT
+ NCoderMixer2::CMixerMT *_mixerMT;
+ #endif
+
+ NCoderMixer2::CMixer *_mixer;
+ CMyComPtr<IUnknown> _mixerRef;
+
+ CCompressionMethodMode _options;
+ NCoderMixer2::CBindInfo _bindInfo;
+ CRecordVector<CMethodId> _decompressionMethods;
+
+ CRecordVector<UInt32> SrcIn_to_DestOut;
+ CRecordVector<UInt32> SrcOut_to_DestIn;
+ // CRecordVector<UInt32> DestIn_to_SrcOut;
+ CRecordVector<UInt32> DestOut_to_SrcIn;
+
+ void InitBindConv();
+ void SetFolder(CFolder &folder);
+
+ HRESULT CreateMixerCoder(DECL_EXTERNAL_CODECS_LOC_VARS
+ const UInt64 *inSizeForReduce);
+
+ bool _constructed;
+public:
+
+ CEncoder(const CCompressionMethodMode &options);
+ ~CEncoder();
+ HRESULT EncoderConstr();
+ HRESULT Encode1(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ ISequentialInStream *inStream,
+ // const UInt64 *inStreamSize,
+ const UInt64 *inSizeForReduce,
+ UInt64 expectedDataSize,
+ CFolder &folderItem,
+ // CRecordVector<UInt64> &coderUnpackSizes,
+ // UInt64 &unpackSize,
+ ISequentialOutStream *outStream,
+ CRecordVector<UInt64> &packSizes,
+ ICompressProgressInfo *compressProgress);
+
+ void Encode_Post(
+ UInt64 unpackSize,
+ CRecordVector<UInt64> &coderUnpackSizes);
+
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zExtract.cpp b/CPP/7zip/Archive/7z/7zExtract.cpp
index 075644f..5498c59 100644
--- a/CPP/7zip/Archive/7z/7zExtract.cpp
+++ b/CPP/7zip/Archive/7z/7zExtract.cpp
@@ -1,423 +1,445 @@
-// 7zExtract.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/7zCrc.h"
-
-#include "../../../Common/ComTry.h"
-
-#include "../../Common/ProgressUtils.h"
-
-#include "7zDecode.h"
-#include "7zHandler.h"
-
-// EXTERN_g_ExternalCodecs
-
-namespace NArchive {
-namespace N7z {
-
-class CFolderOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
-public:
- bool TestMode;
- bool CheckCrc;
-private:
- bool _fileIsOpen;
- bool _calcCrc;
- UInt32 _crc;
- UInt64 _rem;
-
- const UInt32 *_indexes;
- unsigned _numFiles;
- unsigned _fileIndex;
-
- HRESULT OpenFile(bool isCorrupted = false);
- HRESULT CloseFile_and_SetResult(Int32 res);
- HRESULT CloseFile();
- HRESULT ProcessEmptyFiles();
-
-public:
- MY_UNKNOWN_IMP1(ISequentialOutStream)
-
- const CDbEx *_db;
- CMyComPtr<IArchiveExtractCallback> ExtractCallback;
-
- bool ExtraWriteWasCut;
-
- CFolderOutStream():
- TestMode(false),
- CheckCrc(true)
- {}
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-
- HRESULT Init(unsigned startIndex, const UInt32 *indexes, unsigned numFiles);
- HRESULT FlushCorrupted(Int32 callbackOperationResult);
-
- bool WasWritingFinished() const { return _numFiles == 0; }
-};
-
-
-HRESULT CFolderOutStream::Init(unsigned startIndex, const UInt32 *indexes, unsigned numFiles)
-{
- _fileIndex = startIndex;
- _indexes = indexes;
- _numFiles = numFiles;
-
- _fileIsOpen = false;
- ExtraWriteWasCut = false;
-
- return ProcessEmptyFiles();
-}
-
-HRESULT CFolderOutStream::OpenFile(bool isCorrupted)
-{
- const CFileItem &fi = _db->Files[_fileIndex];
- UInt32 nextFileIndex = (_indexes ? *_indexes : _fileIndex);
- Int32 askMode = (_fileIndex == nextFileIndex) ?
- (TestMode ?
- NExtract::NAskMode::kTest :
- NExtract::NAskMode::kExtract) :
- NExtract::NAskMode::kSkip;
-
- if (isCorrupted
- && askMode == NExtract::NAskMode::kExtract
- && !_db->IsItemAnti(_fileIndex)
- && !fi.IsDir)
- askMode = NExtract::NAskMode::kTest;
-
- CMyComPtr<ISequentialOutStream> realOutStream;
- RINOK(ExtractCallback->GetStream(_fileIndex, &realOutStream, askMode));
-
- _stream = realOutStream;
- _crc = CRC_INIT_VAL;
- _calcCrc = (CheckCrc && fi.CrcDefined && !fi.IsDir);
-
- _fileIsOpen = true;
- _rem = fi.Size;
-
- if (askMode == NExtract::NAskMode::kExtract
- && !realOutStream
- && !_db->IsItemAnti(_fileIndex)
- && !fi.IsDir)
- askMode = NExtract::NAskMode::kSkip;
- return ExtractCallback->PrepareOperation(askMode);
-}
-
-HRESULT CFolderOutStream::CloseFile_and_SetResult(Int32 res)
-{
- _stream.Release();
- _fileIsOpen = false;
-
- if (!_indexes)
- _numFiles--;
- else if (*_indexes == _fileIndex)
- {
- _indexes++;
- _numFiles--;
- }
-
- _fileIndex++;
- return ExtractCallback->SetOperationResult(res);
-}
-
-HRESULT CFolderOutStream::CloseFile()
-{
- const CFileItem &fi = _db->Files[_fileIndex];
- return CloseFile_and_SetResult((!_calcCrc || fi.Crc == CRC_GET_DIGEST(_crc)) ?
- NExtract::NOperationResult::kOK :
- NExtract::NOperationResult::kCRCError);
-}
-
-HRESULT CFolderOutStream::ProcessEmptyFiles()
-{
- while (_numFiles != 0 && _db->Files[_fileIndex].Size == 0)
- {
- RINOK(OpenFile());
- RINOK(CloseFile());
- }
- return S_OK;
-}
-
-STDMETHODIMP CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- while (size != 0)
- {
- if (_fileIsOpen)
- {
- UInt32 cur = (size < _rem ? size : (UInt32)_rem);
- if (_calcCrc)
- {
- const UInt32 k_Step = (UInt32)1 << 20;
- if (cur > k_Step)
- cur = k_Step;
- }
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Write(data, cur, &cur);
- if (_calcCrc)
- _crc = CrcUpdate(_crc, data, cur);
- if (processedSize)
- *processedSize += cur;
- data = (const Byte *)data + cur;
- size -= cur;
- _rem -= cur;
- if (_rem == 0)
- {
- RINOK(CloseFile());
- RINOK(ProcessEmptyFiles());
- }
- RINOK(result);
- if (cur == 0)
- break;
- continue;
- }
-
- RINOK(ProcessEmptyFiles());
- if (_numFiles == 0)
- {
- // we support partial extracting
- /*
- if (processedSize)
- *processedSize += size;
- break;
- */
- ExtraWriteWasCut = true;
- // return S_FALSE;
- return k_My_HRESULT_WritingWasCut;
- }
- RINOK(OpenFile());
- }
-
- return S_OK;
-}
-
-HRESULT CFolderOutStream::FlushCorrupted(Int32 callbackOperationResult)
-{
- while (_numFiles != 0)
- {
- if (_fileIsOpen)
- {
- RINOK(CloseFile_and_SetResult(callbackOperationResult));
- }
- else
- {
- RINOK(OpenFile(true));
- }
- }
- return S_OK;
-}
-
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
- Int32 testModeSpec, IArchiveExtractCallback *extractCallbackSpec)
-{
- COM_TRY_BEGIN
-
- CMyComPtr<IArchiveExtractCallback> extractCallback = extractCallbackSpec;
-
- UInt64 importantTotalUnpacked = 0;
-
- // numItems = (UInt32)(Int32)-1;
-
- bool allFilesMode = (numItems == (UInt32)(Int32)-1);
- if (allFilesMode)
- numItems = _db.Files.Size();
-
- if (numItems == 0)
- return S_OK;
-
- {
- CNum prevFolder = kNumNoIndex;
- UInt32 nextFile = 0;
-
- UInt32 i;
-
- for (i = 0; i < numItems; i++)
- {
- UInt32 fileIndex = allFilesMode ? i : indices[i];
- CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
- if (folderIndex == kNumNoIndex)
- continue;
- if (folderIndex != prevFolder || fileIndex < nextFile)
- nextFile = _db.FolderStartFileIndex[folderIndex];
- for (CNum index = nextFile; index <= fileIndex; index++)
- importantTotalUnpacked += _db.Files[index].Size;
- nextFile = fileIndex + 1;
- prevFolder = folderIndex;
- }
- }
-
- RINOK(extractCallback->SetTotal(importantTotalUnpacked));
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(extractCallback, false);
-
- CDecoder decoder(
- #if !defined(USE_MIXER_MT)
- false
- #elif !defined(USE_MIXER_ST)
- true
- #elif !defined(__7Z_SET_PROPERTIES)
- #ifdef _7ZIP_ST
- false
- #else
- true
- #endif
- #else
- _useMultiThreadMixer
- #endif
- );
-
- UInt64 curPacked, curUnpacked;
-
- CMyComPtr<IArchiveExtractCallbackMessage> callbackMessage;
- extractCallback.QueryInterface(IID_IArchiveExtractCallbackMessage, &callbackMessage);
-
- CFolderOutStream *folderOutStream = new CFolderOutStream;
- CMyComPtr<ISequentialOutStream> outStream(folderOutStream);
-
- folderOutStream->_db = &_db;
- folderOutStream->ExtractCallback = extractCallback;
- folderOutStream->TestMode = (testModeSpec != 0);
- folderOutStream->CheckCrc = (_crcSize != 0);
-
- for (UInt32 i = 0;; lps->OutSize += curUnpacked, lps->InSize += curPacked)
- {
- RINOK(lps->SetCur());
-
- if (i >= numItems)
- break;
-
- curUnpacked = 0;
- curPacked = 0;
-
- UInt32 fileIndex = allFilesMode ? i : indices[i];
- CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
-
- UInt32 numSolidFiles = 1;
-
- if (folderIndex != kNumNoIndex)
- {
- curPacked = _db.GetFolderFullPackSize(folderIndex);
- UInt32 nextFile = fileIndex + 1;
- fileIndex = _db.FolderStartFileIndex[folderIndex];
- UInt32 k;
-
- for (k = i + 1; k < numItems; k++)
- {
- UInt32 fileIndex2 = allFilesMode ? k : indices[k];
- if (_db.FileIndexToFolderIndexMap[fileIndex2] != folderIndex
- || fileIndex2 < nextFile)
- break;
- nextFile = fileIndex2 + 1;
- }
-
- numSolidFiles = k - i;
-
- for (k = fileIndex; k < nextFile; k++)
- curUnpacked += _db.Files[k].Size;
- }
-
- {
- HRESULT result = folderOutStream->Init(fileIndex,
- allFilesMode ? NULL : indices + i,
- numSolidFiles);
-
- i += numSolidFiles;
-
- RINOK(result);
- }
-
- // to test solid block with zero unpacked size we disable that code
- if (folderOutStream->WasWritingFinished())
- continue;
-
- #ifndef _NO_CRYPTO
- CMyComPtr<ICryptoGetTextPassword> getTextPassword;
- if (extractCallback)
- extractCallback.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
- #endif
-
- try
- {
- #ifndef _NO_CRYPTO
- bool isEncrypted = false;
- bool passwordIsDefined = false;
- UString password;
- #endif
-
-
- bool dataAfterEnd_Error = false;
-
- HRESULT result = decoder.Decode(
- EXTERNAL_CODECS_VARS
- _inStream,
- _db.ArcInfo.DataStartPosition,
- _db, folderIndex,
- &curUnpacked,
-
- outStream,
- progress,
- NULL // *inStreamMainRes
- , dataAfterEnd_Error
-
- _7Z_DECODER_CRYPRO_VARS
- #if !defined(_7ZIP_ST)
- , true, _numThreads, _memUsage
- #endif
- );
-
- if (result == S_FALSE || result == E_NOTIMPL || dataAfterEnd_Error)
- {
- bool wasFinished = folderOutStream->WasWritingFinished();
-
- int resOp = NExtract::NOperationResult::kDataError;
-
- if (result != S_FALSE)
- {
- if (result == E_NOTIMPL)
- resOp = NExtract::NOperationResult::kUnsupportedMethod;
- else if (wasFinished && dataAfterEnd_Error)
- resOp = NExtract::NOperationResult::kDataAfterEnd;
- }
-
- RINOK(folderOutStream->FlushCorrupted(resOp));
-
- if (wasFinished)
- {
- // we don't show error, if it's after required files
- if (/* !folderOutStream->ExtraWriteWasCut && */ callbackMessage)
- {
- RINOK(callbackMessage->ReportExtractResult(NEventIndexType::kBlockIndex, folderIndex, resOp));
- }
- }
- continue;
- }
-
- if (result != S_OK)
- return result;
-
- RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError));
- continue;
- }
- catch(...)
- {
- RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError));
- // continue;
- return E_FAIL;
- }
- }
-
- return S_OK;
-
- COM_TRY_END
-}
-
-}}
+// 7zExtract.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../Common/ProgressUtils.h"
+
+#include "7zDecode.h"
+#include "7zHandler.h"
+
+// EXTERN_g_ExternalCodecs
+
+namespace NArchive {
+namespace N7z {
+
+Z7_CLASS_IMP_COM_1(
+ CFolderOutStream
+ , ISequentialOutStream
+ /* , ICompressGetSubStreamSize */
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+public:
+ bool TestMode;
+ bool CheckCrc;
+private:
+ bool _fileIsOpen;
+ bool _calcCrc;
+ UInt32 _crc;
+ UInt64 _rem;
+
+ const UInt32 *_indexes;
+ // unsigned _startIndex;
+ unsigned _numFiles;
+ unsigned _fileIndex;
+
+ HRESULT OpenFile(bool isCorrupted = false);
+ HRESULT CloseFile_and_SetResult(Int32 res);
+ HRESULT CloseFile();
+ HRESULT ProcessEmptyFiles();
+
+public:
+ const CDbEx *_db;
+ CMyComPtr<IArchiveExtractCallback> ExtractCallback;
+
+ bool ExtraWriteWasCut;
+
+ CFolderOutStream():
+ TestMode(false),
+ CheckCrc(true)
+ {}
+
+ HRESULT Init(unsigned startIndex, const UInt32 *indexes, unsigned numFiles);
+ HRESULT FlushCorrupted(Int32 callbackOperationResult);
+
+ bool WasWritingFinished() const { return _numFiles == 0; }
+};
+
+
+HRESULT CFolderOutStream::Init(unsigned startIndex, const UInt32 *indexes, unsigned numFiles)
+{
+ // _startIndex = startIndex;
+ _fileIndex = startIndex;
+ _indexes = indexes;
+ _numFiles = numFiles;
+
+ _fileIsOpen = false;
+ ExtraWriteWasCut = false;
+
+ return ProcessEmptyFiles();
+}
+
+HRESULT CFolderOutStream::OpenFile(bool isCorrupted)
+{
+ const CFileItem &fi = _db->Files[_fileIndex];
+ const UInt32 nextFileIndex = (_indexes ? *_indexes : _fileIndex);
+ Int32 askMode = (_fileIndex == nextFileIndex) ? TestMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract :
+ NExtract::NAskMode::kSkip;
+
+ if (isCorrupted
+ && askMode == NExtract::NAskMode::kExtract
+ && !_db->IsItemAnti(_fileIndex)
+ && !fi.IsDir)
+ askMode = NExtract::NAskMode::kTest;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(ExtractCallback->GetStream(_fileIndex, &realOutStream, askMode))
+
+ _stream = realOutStream;
+ _crc = CRC_INIT_VAL;
+ _calcCrc = (CheckCrc && fi.CrcDefined && !fi.IsDir);
+
+ _fileIsOpen = true;
+ _rem = fi.Size;
+
+ if (askMode == NExtract::NAskMode::kExtract
+ && !realOutStream
+ && !_db->IsItemAnti(_fileIndex)
+ && !fi.IsDir)
+ askMode = NExtract::NAskMode::kSkip;
+ return ExtractCallback->PrepareOperation(askMode);
+}
+
+HRESULT CFolderOutStream::CloseFile_and_SetResult(Int32 res)
+{
+ _stream.Release();
+ _fileIsOpen = false;
+
+ if (!_indexes)
+ _numFiles--;
+ else if (*_indexes == _fileIndex)
+ {
+ _indexes++;
+ _numFiles--;
+ }
+
+ _fileIndex++;
+ return ExtractCallback->SetOperationResult(res);
+}
+
+HRESULT CFolderOutStream::CloseFile()
+{
+ const CFileItem &fi = _db->Files[_fileIndex];
+ return CloseFile_and_SetResult((!_calcCrc || fi.Crc == CRC_GET_DIGEST(_crc)) ?
+ NExtract::NOperationResult::kOK :
+ NExtract::NOperationResult::kCRCError);
+}
+
+HRESULT CFolderOutStream::ProcessEmptyFiles()
+{
+ while (_numFiles != 0 && _db->Files[_fileIndex].Size == 0)
+ {
+ RINOK(OpenFile())
+ RINOK(CloseFile())
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ if (_fileIsOpen)
+ {
+ UInt32 cur = (size < _rem ? size : (UInt32)_rem);
+ if (_calcCrc)
+ {
+ const UInt32 k_Step = (UInt32)1 << 20;
+ if (cur > k_Step)
+ cur = k_Step;
+ }
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, cur, &cur);
+ if (_calcCrc)
+ _crc = CrcUpdate(_crc, data, cur);
+ if (processedSize)
+ *processedSize += cur;
+ data = (const Byte *)data + cur;
+ size -= cur;
+ _rem -= cur;
+ if (_rem == 0)
+ {
+ RINOK(CloseFile())
+ RINOK(ProcessEmptyFiles())
+ }
+ RINOK(result)
+ if (cur == 0)
+ break;
+ continue;
+ }
+
+ RINOK(ProcessEmptyFiles())
+ if (_numFiles == 0)
+ {
+ // we support partial extracting
+ /*
+ if (processedSize)
+ *processedSize += size;
+ break;
+ */
+ ExtraWriteWasCut = true;
+ // return S_FALSE;
+ return k_My_HRESULT_WritingWasCut;
+ }
+ RINOK(OpenFile())
+ }
+
+ return S_OK;
+}
+
+HRESULT CFolderOutStream::FlushCorrupted(Int32 callbackOperationResult)
+{
+ while (_numFiles != 0)
+ {
+ if (_fileIsOpen)
+ {
+ RINOK(CloseFile_and_SetResult(callbackOperationResult))
+ }
+ else
+ {
+ RINOK(OpenFile(true))
+ }
+ }
+ return S_OK;
+}
+
+/*
+Z7_COM7F_IMF(CFolderOutStream::GetSubStreamSize(UInt64 subStream, UInt64 *value))
+{
+ *value = 0;
+ // const unsigned numFiles_Original = _numFiles + _fileIndex - _startIndex;
+ const unsigned numFiles_Original = _numFiles;
+ if (subStream >= numFiles_Original)
+ return S_FALSE; // E_FAIL;
+ *value = _db->Files[_startIndex + (unsigned)subStream].Size;
+ return S_OK;
+}
+*/
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testModeSpec, IArchiveExtractCallback *extractCallbackSpec))
+{
+ // for GCC
+ // CFolderOutStream *folderOutStream = new CFolderOutStream;
+ // CMyComPtr<ISequentialOutStream> outStream(folderOutStream);
+
+ COM_TRY_BEGIN
+
+ CMyComPtr<IArchiveExtractCallback> extractCallback = extractCallbackSpec;
+
+ UInt64 importantTotalUnpacked = 0;
+
+ // numItems = (UInt32)(Int32)-1;
+
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _db.Files.Size();
+
+ if (numItems == 0)
+ return S_OK;
+
+ {
+ CNum prevFolder = kNumNoIndex;
+ UInt32 nextFile = 0;
+
+ UInt32 i;
+
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 fileIndex = allFilesMode ? i : indices[i];
+ const CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
+ if (folderIndex == kNumNoIndex)
+ continue;
+ if (folderIndex != prevFolder || fileIndex < nextFile)
+ nextFile = _db.FolderStartFileIndex[folderIndex];
+ for (CNum index = nextFile; index <= fileIndex; index++)
+ importantTotalUnpacked += _db.Files[index].Size;
+ nextFile = fileIndex + 1;
+ prevFolder = folderIndex;
+ }
+ }
+
+ RINOK(extractCallback->SetTotal(importantTotalUnpacked))
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CDecoder decoder(
+ #if !defined(USE_MIXER_MT)
+ false
+ #elif !defined(USE_MIXER_ST)
+ true
+ #elif !defined(Z7_7Z_SET_PROPERTIES)
+ #ifdef Z7_ST
+ false
+ #else
+ true
+ #endif
+ #else
+ _useMultiThreadMixer
+ #endif
+ );
+
+ UInt64 curPacked, curUnpacked;
+
+ CMyComPtr<IArchiveExtractCallbackMessage2> callbackMessage;
+ extractCallback.QueryInterface(IID_IArchiveExtractCallbackMessage2, &callbackMessage);
+
+ CFolderOutStream *folderOutStream = new CFolderOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(folderOutStream);
+
+ folderOutStream->_db = &_db;
+ folderOutStream->ExtractCallback = extractCallback;
+ folderOutStream->TestMode = (testModeSpec != 0);
+ folderOutStream->CheckCrc = (_crcSize != 0);
+
+ for (UInt32 i = 0;; lps->OutSize += curUnpacked, lps->InSize += curPacked)
+ {
+ RINOK(lps->SetCur())
+
+ if (i >= numItems)
+ break;
+
+ curUnpacked = 0;
+ curPacked = 0;
+
+ UInt32 fileIndex = allFilesMode ? i : indices[i];
+ const CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
+
+ UInt32 numSolidFiles = 1;
+
+ if (folderIndex != kNumNoIndex)
+ {
+ curPacked = _db.GetFolderFullPackSize(folderIndex);
+ UInt32 nextFile = fileIndex + 1;
+ fileIndex = _db.FolderStartFileIndex[folderIndex];
+ UInt32 k;
+
+ for (k = i + 1; k < numItems; k++)
+ {
+ const UInt32 fileIndex2 = allFilesMode ? k : indices[k];
+ if (_db.FileIndexToFolderIndexMap[fileIndex2] != folderIndex
+ || fileIndex2 < nextFile)
+ break;
+ nextFile = fileIndex2 + 1;
+ }
+
+ numSolidFiles = k - i;
+
+ for (k = fileIndex; k < nextFile; k++)
+ curUnpacked += _db.Files[k].Size;
+ }
+
+ {
+ const HRESULT result = folderOutStream->Init(fileIndex,
+ allFilesMode ? NULL : indices + i,
+ numSolidFiles);
+
+ i += numSolidFiles;
+
+ RINOK(result)
+ }
+
+ if (folderOutStream->WasWritingFinished())
+ {
+ // for debug: to test zero size stream unpacking
+ // if (folderIndex == kNumNoIndex) // enable this check for debug
+ continue;
+ }
+
+ if (folderIndex == kNumNoIndex)
+ return E_FAIL;
+
+ #ifndef Z7_NO_CRYPTO
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ if (extractCallback)
+ extractCallback.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
+ #endif
+
+ try
+ {
+ #ifndef Z7_NO_CRYPTO
+ bool isEncrypted = false;
+ bool passwordIsDefined = false;
+ UString_Wipe password;
+ #endif
+
+ bool dataAfterEnd_Error = false;
+
+ const HRESULT result = decoder.Decode(
+ EXTERNAL_CODECS_VARS
+ _inStream,
+ _db.ArcInfo.DataStartPosition,
+ _db, folderIndex,
+ &curUnpacked,
+
+ outStream,
+ progress,
+ NULL // *inStreamMainRes
+ , dataAfterEnd_Error
+
+ Z7_7Z_DECODER_CRYPRO_VARS
+ #if !defined(Z7_ST)
+ , true, _numThreads, _memUsage_Decompress
+ #endif
+ );
+
+ if (result == S_FALSE || result == E_NOTIMPL || dataAfterEnd_Error)
+ {
+ const bool wasFinished = folderOutStream->WasWritingFinished();
+
+ int resOp = NExtract::NOperationResult::kDataError;
+
+ if (result != S_FALSE)
+ {
+ if (result == E_NOTIMPL)
+ resOp = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (wasFinished && dataAfterEnd_Error)
+ resOp = NExtract::NOperationResult::kDataAfterEnd;
+ }
+
+ RINOK(folderOutStream->FlushCorrupted(resOp))
+
+ if (wasFinished)
+ {
+ // we don't show error, if it's after required files
+ if (/* !folderOutStream->ExtraWriteWasCut && */ callbackMessage)
+ {
+ RINOK(callbackMessage->ReportExtractResult(NEventIndexType::kBlockIndex, folderIndex, resOp))
+ }
+ }
+ continue;
+ }
+
+ if (result != S_OK)
+ return result;
+
+ RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError))
+ continue;
+ }
+ catch(...)
+ {
+ RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError))
+ // continue;
+ // return E_FAIL;
+ throw;
+ }
+ }
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zFolderInStream.cpp b/CPP/7zip/Archive/7z/7zFolderInStream.cpp
index eee11a0..0823189 100644
--- a/CPP/7zip/Archive/7z/7zFolderInStream.cpp
+++ b/CPP/7zip/Archive/7z/7zFolderInStream.cpp
@@ -1,139 +1,264 @@
-// 7zFolderInStream.cpp
-
-#include "StdAfx.h"
-
-#include "7zFolderInStream.h"
-
-namespace NArchive {
-namespace N7z {
-
-void CFolderInStream::Init(IArchiveUpdateCallback *updateCallback,
- const UInt32 *indexes, unsigned numFiles)
-{
- _updateCallback = updateCallback;
- _indexes = indexes;
- _numFiles = numFiles;
- _index = 0;
-
- Processed.ClearAndReserve(numFiles);
- CRCs.ClearAndReserve(numFiles);
- Sizes.ClearAndReserve(numFiles);
-
- _pos = 0;
- _crc = CRC_INIT_VAL;
- _size_Defined = false;
- _size = 0;
-
- _stream.Release();
-}
-
-HRESULT CFolderInStream::OpenStream()
-{
- _pos = 0;
- _crc = CRC_INIT_VAL;
- _size_Defined = false;
- _size = 0;
-
- while (_index < _numFiles)
- {
- CMyComPtr<ISequentialInStream> stream;
- HRESULT result = _updateCallback->GetStream(_indexes[_index], &stream);
- if (result != S_OK)
- {
- if (result != S_FALSE)
- return result;
- }
-
- _stream = stream;
-
- if (stream)
- {
- CMyComPtr<IStreamGetSize> streamGetSize;
- stream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
- if (streamGetSize)
- {
- if (streamGetSize->GetSize(&_size) == S_OK)
- _size_Defined = true;
- }
- return S_OK;
- }
-
- _index++;
- RINOK(_updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
- AddFileInfo(result == S_OK);
- }
- return S_OK;
-}
-
-void CFolderInStream::AddFileInfo(bool isProcessed)
-{
- Processed.Add(isProcessed);
- Sizes.Add(_pos);
- CRCs.Add(CRC_GET_DIGEST(_crc));
-}
-
-STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- while (size != 0)
- {
- if (_stream)
- {
- UInt32 cur = size;
- const UInt32 kMax = (UInt32)1 << 20;
- if (cur > kMax)
- cur = kMax;
- RINOK(_stream->Read(data, cur, &cur));
- if (cur != 0)
- {
- _crc = CrcUpdate(_crc, data, cur);
- _pos += cur;
- if (processedSize)
- *processedSize = cur;
- return S_OK;
- }
-
- _stream.Release();
- _index++;
- AddFileInfo(true);
-
- _pos = 0;
- _crc = CRC_INIT_VAL;
- _size_Defined = false;
- _size = 0;
-
- RINOK(_updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
- }
-
- if (_index >= _numFiles)
- break;
- RINOK(OpenStream());
- }
- return S_OK;
-}
-
-STDMETHODIMP CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value)
-{
- *value = 0;
- if (subStream > Sizes.Size())
- return S_FALSE; // E_FAIL;
-
- unsigned index = (unsigned)subStream;
- if (index < Sizes.Size())
- {
- *value = Sizes[index];
- return S_OK;
- }
-
- if (!_size_Defined)
- {
- *value = _pos;
- return S_FALSE;
- }
-
- *value = (_pos > _size ? _pos : _size);
- return S_OK;
-}
-
-}}
+// 7zFolderInStream.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "7zFolderInStream.h"
+
+namespace NArchive {
+namespace N7z {
+
+void CFolderInStream::Init(IArchiveUpdateCallback *updateCallback,
+ const UInt32 *indexes, unsigned numFiles)
+{
+ _updateCallback = updateCallback;
+ _indexes = indexes;
+ _numFiles = numFiles;
+
+ _totalSize_for_Coder = 0;
+ ClearFileInfo();
+
+ Processed.ClearAndReserve(numFiles);
+ Sizes.ClearAndReserve(numFiles);
+ CRCs.ClearAndReserve(numFiles);
+ TimesDefined.ClearAndReserve(numFiles);
+ MTimes.ClearAndReserve(Need_MTime ? numFiles : (unsigned)0);
+ CTimes.ClearAndReserve(Need_CTime ? numFiles : (unsigned)0);
+ ATimes.ClearAndReserve(Need_ATime ? numFiles : (unsigned)0);
+ Attribs.ClearAndReserve(Need_Attrib ? numFiles : (unsigned)0);
+
+ // FolderCrc = CRC_INIT_VAL;
+ _stream.Release();
+}
+
+void CFolderInStream::ClearFileInfo()
+{
+ _pos = 0;
+ _crc = CRC_INIT_VAL;
+ _size_Defined = false;
+ _times_Defined = false;
+ _size = 0;
+ FILETIME_Clear(_mTime);
+ FILETIME_Clear(_cTime);
+ FILETIME_Clear(_aTime);
+ _attrib = 0;
+}
+
+HRESULT CFolderInStream::OpenStream()
+{
+ while (Processed.Size() < _numFiles)
+ {
+ CMyComPtr<ISequentialInStream> stream;
+ const HRESULT result = _updateCallback->GetStream(_indexes[Processed.Size()], &stream);
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ _stream = stream;
+
+ if (stream)
+ {
+ {
+ CMyComPtr<IStreamGetProps> getProps;
+ stream.QueryInterface(IID_IStreamGetProps, (void **)&getProps);
+ if (getProps)
+ {
+ // access could be changed in first myx pass
+ if (getProps->GetProps(&_size,
+ Need_CTime ? &_cTime : NULL,
+ Need_ATime ? &_aTime : NULL,
+ Need_MTime ? &_mTime : NULL,
+ Need_Attrib ? &_attrib : NULL)
+ == S_OK)
+ {
+ _size_Defined = true;
+ _times_Defined = true;
+ }
+ return S_OK;
+ }
+ }
+ {
+ CMyComPtr<IStreamGetSize> streamGetSize;
+ stream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
+ if (streamGetSize)
+ {
+ if (streamGetSize->GetSize(&_size) == S_OK)
+ _size_Defined = true;
+ }
+ return S_OK;
+ }
+ }
+
+ RINOK(AddFileInfo(result == S_OK))
+ }
+ return S_OK;
+}
+
+static void AddFt(CRecordVector<UInt64> &vec, const FILETIME &ft)
+{
+ vec.AddInReserved(FILETIME_To_UInt64(ft));
+}
+
+/*
+HRESULT ReportItemProps(IArchiveUpdateCallbackArcProp *reportArcProp,
+ UInt32 index, UInt64 size, const UInt32 *crc)
+{
+ PROPVARIANT prop;
+ prop.vt = VT_EMPTY;
+ prop.wReserved1 = 0;
+
+ NWindows::NCOM::PropVarEm_Set_UInt64(&prop, size);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidSize, &prop));
+ if (crc)
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt32(&prop, *crc);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidCRC, &prop));
+ }
+ return reportArcProp->ReportFinished(NEventIndexType::kOutArcIndex, index, NUpdate::NOperationResult::kOK);
+}
+*/
+
+HRESULT CFolderInStream::AddFileInfo(bool isProcessed)
+{
+ // const UInt32 index = _indexes[Processed.Size()];
+ Processed.AddInReserved(isProcessed);
+ Sizes.AddInReserved(_pos);
+ CRCs.AddInReserved(CRC_GET_DIGEST(_crc));
+ if (Need_Attrib) Attribs.AddInReserved(_attrib);
+ TimesDefined.AddInReserved(_times_Defined);
+ if (Need_MTime) AddFt(MTimes, _mTime);
+ if (Need_CTime) AddFt(CTimes, _cTime);
+ if (Need_ATime) AddFt(ATimes, _aTime);
+ ClearFileInfo();
+ /*
+ if (isProcessed && _reportArcProp)
+ RINOK(ReportItemProps(_reportArcProp, index, _pos, &crc))
+ */
+ return _updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK);
+}
+
+Z7_COM7F_IMF(CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ while (size != 0)
+ {
+ if (_stream)
+ {
+ /*
+ if (_pos == 0)
+ {
+ const UInt32 align = (UInt32)1 << AlignLog;
+ const UInt32 offset = (UInt32)_totalSize_for_Coder & (align - 1);
+ if (offset != 0)
+ {
+ UInt32 cur = align - offset;
+ if (cur > size)
+ cur = size;
+ memset(data, 0, cur);
+ data = (Byte *)data + cur;
+ size -= cur;
+ // _pos += cur; // for debug
+ _totalSize_for_Coder += cur;
+ if (processedSize)
+ *processedSize += cur;
+ continue;
+ }
+ }
+ */
+ UInt32 cur = size;
+ const UInt32 kMax = (UInt32)1 << 20;
+ if (cur > kMax)
+ cur = kMax;
+ RINOK(_stream->Read(data, cur, &cur))
+ if (cur != 0)
+ {
+ // if (Need_Crc)
+ _crc = CrcUpdate(_crc, data, cur);
+ /*
+ if (FolderCrc)
+ FolderCrc = CrcUpdate(FolderCrc, data, cur);
+ */
+ _pos += cur;
+ _totalSize_for_Coder += cur;
+ if (processedSize)
+ *processedSize = cur; // use +=cur, if continue is possible in loop
+ return S_OK;
+ }
+
+ _stream.Release();
+ RINOK(AddFileInfo(true))
+ }
+
+ if (Processed.Size() >= _numFiles)
+ break;
+ RINOK(OpenStream())
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value))
+{
+ *value = 0;
+ if (subStream > Sizes.Size())
+ return S_FALSE; // E_FAIL;
+
+ const unsigned index = (unsigned)subStream;
+ if (index < Sizes.Size())
+ {
+ *value = Sizes[index];
+ return S_OK;
+ }
+
+ if (!_size_Defined)
+ {
+ *value = _pos;
+ return S_FALSE;
+ }
+
+ *value = (_pos > _size ? _pos : _size);
+ return S_OK;
+}
+
+
+/*
+HRESULT CFolderInStream::CloseCrcStream()
+{
+ if (!_crcStream)
+ return S_OK;
+ if (!_crcStream_Spec->WasFinished())
+ return E_FAIL;
+ _crc = _crcStream_Spec->GetCRC() ^ CRC_INIT_VAL; // change it
+ const UInt64 size = _crcStream_Spec->GetSize();
+ _pos = size;
+ _totalSize_for_Coder += size;
+ _crcStream.Release();
+ // _crcStream->ReleaseStream();
+ _stream.Release();
+ return AddFileInfo(true);
+}
+
+Z7_COM7F_IMF(CFolderInStream::GetNextInSubStream(UInt64 *streamIndexRes, ISequentialInStream **stream)
+{
+ RINOK(CloseCrcStream())
+ *stream = NULL;
+ *streamIndexRes = Processed.Size();
+ if (Processed.Size() >= _numFiles)
+ return S_OK;
+ RINOK(OpenStream());
+ if (!_stream)
+ return S_OK;
+ if (!_crcStream)
+ {
+ _crcStream_Spec = new CSequentialInStreamWithCRC;
+ _crcStream = _crcStream_Spec;
+ }
+ _crcStream_Spec->Init();
+ _crcStream_Spec->SetStream(_stream);
+ *stream = _crcStream;
+ _crcStream->AddRef();
+ return S_OK;
+}
+*/
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zFolderInStream.h b/CPP/7zip/Archive/7z/7zFolderInStream.h
index f2b1c59..6447b25 100644
--- a/CPP/7zip/Archive/7z/7zFolderInStream.h
+++ b/CPP/7zip/Archive/7z/7zFolderInStream.h
@@ -1,61 +1,101 @@
-// 7zFolderInStream.h
-
-#ifndef __7Z_FOLDER_IN_STREAM_H
-#define __7Z_FOLDER_IN_STREAM_H
-
-#include "../../../../C/7zCrc.h"
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/MyVector.h"
-
-#include "../../ICoder.h"
-#include "../IArchive.h"
-
-namespace NArchive {
-namespace N7z {
-
-class CFolderInStream:
- public ISequentialInStream,
- public ICompressGetSubStreamSize,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialInStream> _stream;
- UInt64 _pos;
- UInt32 _crc;
- bool _size_Defined;
- UInt64 _size;
-
- const UInt32 *_indexes;
- unsigned _numFiles;
- unsigned _index;
-
- CMyComPtr<IArchiveUpdateCallback> _updateCallback;
-
- HRESULT OpenStream();
- void AddFileInfo(bool isProcessed);
-
-public:
- CRecordVector<bool> Processed;
- CRecordVector<UInt32> CRCs;
- CRecordVector<UInt64> Sizes;
-
- MY_UNKNOWN_IMP2(ISequentialInStream, ICompressGetSubStreamSize)
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value);
-
- void Init(IArchiveUpdateCallback *updateCallback, const UInt32 *indexes, unsigned numFiles);
-
- bool WasFinished() const { return _index == _numFiles; }
-
- UInt64 GetFullSize() const
- {
- UInt64 size = 0;
- FOR_VECTOR (i, Sizes)
- size += Sizes[i];
- return size;
- }
-};
-
-}}
-
-#endif
+// 7zFolderInStream.h
+
+#ifndef ZIP7_INC_7Z_FOLDER_IN_STREAM_H
+#define ZIP7_INC_7Z_FOLDER_IN_STREAM_H
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyVector.h"
+// #include "../Common/InStreamWithCRC.h"
+
+#include "../../ICoder.h"
+#include "../IArchive.h"
+
+namespace NArchive {
+namespace N7z {
+
+Z7_CLASS_IMP_COM_2(
+ CFolderInStream
+ , ISequentialInStream
+ , ICompressGetSubStreamSize
+)
+ /*
+ Z7_COM7F_IMP(GetNextStream(UInt64 *streamIndex))
+ Z7_IFACE_COM7_IMP(ICompressInSubStreams)
+ */
+
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt64 _totalSize_for_Coder;
+ UInt64 _pos;
+ UInt32 _crc;
+ bool _size_Defined;
+ bool _times_Defined;
+ UInt64 _size;
+ FILETIME _mTime;
+ FILETIME _cTime;
+ FILETIME _aTime;
+ UInt32 _attrib;
+
+ unsigned _numFiles;
+ const UInt32 *_indexes;
+
+ CMyComPtr<IArchiveUpdateCallback> _updateCallback;
+
+ void ClearFileInfo();
+ HRESULT OpenStream();
+ HRESULT AddFileInfo(bool isProcessed);
+ // HRESULT CloseCrcStream();
+public:
+ bool Need_MTime;
+ bool Need_CTime;
+ bool Need_ATime;
+ bool Need_Attrib;
+ // bool Need_Crc;
+ // bool Need_FolderCrc;
+ // unsigned AlignLog;
+
+ CRecordVector<bool> Processed;
+ CRecordVector<UInt64> Sizes;
+ CRecordVector<UInt32> CRCs;
+ CRecordVector<UInt32> Attribs;
+ CRecordVector<bool> TimesDefined;
+ CRecordVector<UInt64> MTimes;
+ CRecordVector<UInt64> CTimes;
+ CRecordVector<UInt64> ATimes;
+ // UInt32 FolderCrc;
+
+ // UInt32 GetFolderCrc() const { return CRC_GET_DIGEST(FolderCrc); }
+ // CSequentialInStreamWithCRC *_crcStream_Spec;
+ // CMyComPtr<ISequentialInStream> _crcStream;
+ // CMyComPtr<IArchiveUpdateCallbackArcProp> _reportArcProp;
+
+ void Init(IArchiveUpdateCallback *updateCallback, const UInt32 *indexes, unsigned numFiles);
+
+ bool WasFinished() const { return Processed.Size() == _numFiles; }
+
+ UInt64 Get_TotalSize_for_Coder() const { return _totalSize_for_Coder; }
+ /*
+ UInt64 GetFullSize() const
+ {
+ UInt64 size = 0;
+ FOR_VECTOR (i, Sizes)
+ size += Sizes[i];
+ return size;
+ }
+ */
+
+ CFolderInStream():
+ Need_MTime(false),
+ Need_CTime(false),
+ Need_ATime(false),
+ Need_Attrib(false)
+ // , Need_Crc(true)
+ // , Need_FolderCrc(false)
+ // , AlignLog(0)
+ {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zHandler.cpp b/CPP/7zip/Archive/7z/7zHandler.cpp
index 45dda9c..23d3a9d 100644
--- a/CPP/7zip/Archive/7z/7zHandler.cpp
+++ b/CPP/7zip/Archive/7z/7zHandler.cpp
@@ -1,763 +1,793 @@
-// 7zHandler.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/CpuArch.h"
-
-#include "../../../Common/ComTry.h"
-#include "../../../Common/IntToString.h"
-
-#ifndef __7Z_SET_PROPERTIES
-#include "../../../Windows/System.h"
-#endif
-
-#include "../Common/ItemNameUtils.h"
-
-#include "7zHandler.h"
-#include "7zProperties.h"
-
-#ifdef __7Z_SET_PROPERTIES
-#ifdef EXTRACT_ONLY
-#include "../Common/ParseProperties.h"
-#endif
-#endif
-
-using namespace NWindows;
-using namespace NCOM;
-
-namespace NArchive {
-namespace N7z {
-
-CHandler::CHandler()
-{
- #ifndef _NO_CRYPTO
- _isEncrypted = false;
- _passwordIsDefined = false;
- #endif
-
- #ifdef EXTRACT_ONLY
-
- _crcSize = 4;
-
- #ifdef __7Z_SET_PROPERTIES
- _useMultiThreadMixer = true;
- #endif
-
- #endif
-}
-
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
-{
- *numItems = _db.Files.Size();
- return S_OK;
-}
-
-#ifdef _SFX
-
-IMP_IInArchive_ArcProps_NO_Table
-
-STDMETHODIMP CHandler::GetNumberOfProperties(UInt32 *numProps)
-{
- *numProps = 0;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetPropertyInfo(UInt32 /* index */,
- BSTR * /* name */, PROPID * /* propID */, VARTYPE * /* varType */)
-{
- return E_NOTIMPL;
-}
-
-#else
-
-static const Byte kArcProps[] =
-{
- kpidHeadersSize,
- kpidMethod,
- kpidSolid,
- kpidNumBlocks
- // , kpidIsTree
-};
-
-IMP_IInArchive_ArcProps
-
-static inline char GetHex(unsigned value)
-{
- return (char)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
-}
-
-static unsigned ConvertMethodIdToString_Back(char *s, UInt64 id)
-{
- int len = 0;
- do
- {
- s[--len] = GetHex((unsigned)id & 0xF); id >>= 4;
- s[--len] = GetHex((unsigned)id & 0xF); id >>= 4;
- }
- while (id != 0);
- return (unsigned)-len;
-}
-
-static void ConvertMethodIdToString(AString &res, UInt64 id)
-{
- const unsigned kLen = 32;
- char s[kLen];
- unsigned len = kLen - 1;
- s[len] = 0;
- res += s + len - ConvertMethodIdToString_Back(s + len, id);
-}
-
-static unsigned GetStringForSizeValue(char *s, UInt32 val)
-{
- unsigned i;
- for (i = 0; i <= 31; i++)
- if (((UInt32)1 << i) == val)
- {
- if (i < 10)
- {
- s[0] = (char)('0' + i);
- s[1] = 0;
- return 1;
- }
- if (i < 20) { s[0] = '1'; s[1] = (char)('0' + i - 10); }
- else if (i < 30) { s[0] = '2'; s[1] = (char)('0' + i - 20); }
- else { s[0] = '3'; s[1] = (char)('0' + i - 30); }
- s[2] = 0;
- return 2;
- }
- char c = 'b';
- if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
- else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
- ::ConvertUInt32ToString(val, s);
- unsigned pos = MyStringLen(s);
- s[pos++] = c;
- s[pos] = 0;
- return pos;
-}
-
-/*
-static inline void AddHexToString(UString &res, Byte value)
-{
- res += GetHex((Byte)(value >> 4));
- res += GetHex((Byte)(value & 0xF));
-}
-*/
-
-static char *AddProp32(char *s, const char *name, UInt32 v)
-{
- *s++ = ':';
- s = MyStpCpy(s, name);
- ::ConvertUInt32ToString(v, s);
- return s + MyStringLen(s);
-}
-
-void CHandler::AddMethodName(AString &s, UInt64 id)
-{
- AString name;
- FindMethod(EXTERNAL_CODECS_VARS id, name);
- if (name.IsEmpty())
- ConvertMethodIdToString(s, id);
- else
- s += name;
-}
-
-#endif
-
-STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
-{
- #ifndef _SFX
- COM_TRY_BEGIN
- #endif
- NCOM::CPropVariant prop;
- switch (propID)
- {
- #ifndef _SFX
- case kpidMethod:
- {
- AString s;
- const CParsedMethods &pm = _db.ParsedMethods;
- FOR_VECTOR (i, pm.IDs)
- {
- UInt64 id = pm.IDs[i];
- s.Add_Space_if_NotEmpty();
- char temp[16];
- if (id == k_LZMA2)
- {
- s += "LZMA2:";
- if ((pm.Lzma2Prop & 1) == 0)
- ConvertUInt32ToString((pm.Lzma2Prop >> 1) + 12, temp);
- else
- GetStringForSizeValue(temp, 3 << ((pm.Lzma2Prop >> 1) + 11));
- s += temp;
- }
- else if (id == k_LZMA)
- {
- s += "LZMA:";
- GetStringForSizeValue(temp, pm.LzmaDic);
- s += temp;
- }
- else
- AddMethodName(s, id);
- }
- prop = s;
- break;
- }
- case kpidSolid: prop = _db.IsSolid(); break;
- case kpidNumBlocks: prop = (UInt32)_db.NumFolders; break;
- case kpidHeadersSize: prop = _db.HeadersSize; break;
- case kpidPhySize: prop = _db.PhySize; break;
- case kpidOffset: if (_db.ArcInfo.StartPosition != 0) prop = _db.ArcInfo.StartPosition; break;
- /*
- case kpidIsTree: if (_db.IsTree) prop = true; break;
- case kpidIsAltStream: if (_db.ThereAreAltStreams) prop = true; break;
- case kpidIsAux: if (_db.IsTree) prop = true; break;
- */
- // case kpidError: if (_db.ThereIsHeaderError) prop = "Header error"; break;
- #endif
-
- case kpidWarningFlags:
- {
- UInt32 v = 0;
- if (_db.StartHeaderWasRecovered) v |= kpv_ErrorFlags_HeadersError;
- if (_db.UnsupportedFeatureWarning) v |= kpv_ErrorFlags_UnsupportedFeature;
- if (v != 0)
- prop = v;
- break;
- }
-
- case kpidErrorFlags:
- {
- UInt32 v = 0;
- if (!_db.IsArc) v |= kpv_ErrorFlags_IsNotArc;
- if (_db.ThereIsHeaderError) v |= kpv_ErrorFlags_HeadersError;
- if (_db.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
- // if (_db.UnsupportedVersion) v |= kpv_ErrorFlags_Unsupported;
- if (_db.UnsupportedFeatureError) v |= kpv_ErrorFlags_UnsupportedFeature;
- prop = v;
- break;
- }
-
- case kpidReadOnly:
- {
- if (!_db.CanUpdate())
- prop = true;
- break;
- }
- }
- prop.Detach(value);
- return S_OK;
- #ifndef _SFX
- COM_TRY_END
- #endif
-}
-
-static void SetFileTimeProp_From_UInt64Def(PROPVARIANT *prop, const CUInt64DefVector &v, int index)
-{
- UInt64 value;
- if (v.GetItem(index, value))
- PropVarEm_Set_FileTime64(prop, value);
-}
-
-bool CHandler::IsFolderEncrypted(CNum folderIndex) const
-{
- if (folderIndex == kNumNoIndex)
- return false;
- size_t startPos = _db.FoCodersDataOffset[folderIndex];
- const Byte *p = _db.CodersData + startPos;
- size_t size = _db.FoCodersDataOffset[folderIndex + 1] - startPos;
- CInByte2 inByte;
- inByte.Init(p, size);
-
- CNum numCoders = inByte.ReadNum();
- for (; numCoders != 0; numCoders--)
- {
- Byte mainByte = inByte.ReadByte();
- unsigned idSize = (mainByte & 0xF);
- const Byte *longID = inByte.GetPtr();
- UInt64 id64 = 0;
- for (unsigned j = 0; j < idSize; j++)
- id64 = ((id64 << 8) | longID[j]);
- inByte.SkipDataNoCheck(idSize);
- if (id64 == k_AES)
- return true;
- if ((mainByte & 0x20) != 0)
- inByte.SkipDataNoCheck(inByte.ReadNum());
- }
- return false;
-}
-
-STDMETHODIMP CHandler::GetNumRawProps(UInt32 *numProps)
-{
- *numProps = 0;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID)
-{
- *name = NULL;
- *propID = kpidNtSecure;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetParent(UInt32 /* index */, UInt32 *parent, UInt32 *parentType)
-{
- /*
- const CFileItem &file = _db.Files[index];
- *parentType = (file.IsAltStream ? NParentType::kAltStream : NParentType::kDir);
- *parent = (UInt32)(Int32)file.Parent;
- */
- *parentType = NParentType::kDir;
- *parent = (UInt32)(Int32)-1;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)
-{
- *data = NULL;
- *dataSize = 0;
- *propType = 0;
-
- if (/* _db.IsTree && propID == kpidName ||
- !_db.IsTree && */ propID == kpidPath)
- {
- if (_db.NameOffsets && _db.NamesBuf)
- {
- size_t offset = _db.NameOffsets[index];
- size_t size = (_db.NameOffsets[index + 1] - offset) * 2;
- if (size < ((UInt32)1 << 31))
- {
- *data = (const void *)(_db.NamesBuf + offset * 2);
- *dataSize = (UInt32)size;
- *propType = NPropDataType::kUtf16z;
- }
- }
- return S_OK;
- }
- /*
- if (propID == kpidNtSecure)
- {
- if (index < (UInt32)_db.SecureIDs.Size())
- {
- int id = _db.SecureIDs[index];
- size_t offs = _db.SecureOffsets[id];
- size_t size = _db.SecureOffsets[id + 1] - offs;
- if (size >= 0)
- {
- *data = _db.SecureBuf + offs;
- *dataSize = (UInt32)size;
- *propType = NPropDataType::kRaw;
- }
- }
- }
- */
- return S_OK;
-}
-
-#ifndef _SFX
-
-HRESULT CHandler::SetMethodToProp(CNum folderIndex, PROPVARIANT *prop) const
-{
- PropVariant_Clear(prop);
- if (folderIndex == kNumNoIndex)
- return S_OK;
- // for (int ttt = 0; ttt < 1; ttt++) {
- const unsigned kTempSize = 256;
- char temp[kTempSize];
- unsigned pos = kTempSize;
- temp[--pos] = 0;
-
- size_t startPos = _db.FoCodersDataOffset[folderIndex];
- const Byte *p = _db.CodersData + startPos;
- size_t size = _db.FoCodersDataOffset[folderIndex + 1] - startPos;
- CInByte2 inByte;
- inByte.Init(p, size);
-
- // numCoders == 0 ???
- CNum numCoders = inByte.ReadNum();
- bool needSpace = false;
-
- for (; numCoders != 0; numCoders--, needSpace = true)
- {
- if (pos < 32) // max size of property
- break;
- Byte mainByte = inByte.ReadByte();
- unsigned idSize = (mainByte & 0xF);
- const Byte *longID = inByte.GetPtr();
- UInt64 id64 = 0;
- for (unsigned j = 0; j < idSize; j++)
- id64 = ((id64 << 8) | longID[j]);
- inByte.SkipDataNoCheck(idSize);
-
- if ((mainByte & 0x10) != 0)
- {
- inByte.ReadNum(); // NumInStreams
- inByte.ReadNum(); // NumOutStreams
- }
-
- CNum propsSize = 0;
- const Byte *props = NULL;
- if ((mainByte & 0x20) != 0)
- {
- propsSize = inByte.ReadNum();
- props = inByte.GetPtr();
- inByte.SkipDataNoCheck(propsSize);
- }
-
- const char *name = NULL;
- char s[32];
- s[0] = 0;
-
- if (id64 <= (UInt32)0xFFFFFFFF)
- {
- UInt32 id = (UInt32)id64;
- if (id == k_LZMA)
- {
- name = "LZMA";
- if (propsSize == 5)
- {
- UInt32 dicSize = GetUi32((const Byte *)props + 1);
- char *dest = s + GetStringForSizeValue(s, dicSize);
- UInt32 d = props[0];
- if (d != 0x5D)
- {
- UInt32 lc = d % 9;
- d /= 9;
- UInt32 pb = d / 5;
- UInt32 lp = d % 5;
- if (lc != 3) dest = AddProp32(dest, "lc", lc);
- if (lp != 0) dest = AddProp32(dest, "lp", lp);
- if (pb != 2) dest = AddProp32(dest, "pb", pb);
- }
- }
- }
- else if (id == k_LZMA2)
- {
- name = "LZMA2";
- if (propsSize == 1)
- {
- Byte d = props[0];
- if ((d & 1) == 0)
- ConvertUInt32ToString((UInt32)((d >> 1) + 12), s);
- else
- GetStringForSizeValue(s, 3 << ((d >> 1) + 11));
- }
- }
- else if (id == k_PPMD)
- {
- name = "PPMD";
- if (propsSize == 5)
- {
- Byte order = *props;
- char *dest = s;
- *dest++ = 'o';
- ConvertUInt32ToString(order, dest);
- dest += MyStringLen(dest);
- dest = MyStpCpy(dest, ":mem");
- GetStringForSizeValue(dest, GetUi32(props + 1));
- }
- }
- else if (id == k_Delta)
- {
- name = "Delta";
- if (propsSize == 1)
- ConvertUInt32ToString((UInt32)props[0] + 1, s);
- }
- else if (id == k_BCJ2) name = "BCJ2";
- else if (id == k_BCJ) name = "BCJ";
- else if (id == k_AES)
- {
- name = "7zAES";
- if (propsSize >= 1)
- {
- Byte firstByte = props[0];
- UInt32 numCyclesPower = firstByte & 0x3F;
- ConvertUInt32ToString(numCyclesPower, s);
- }
- }
- }
-
- if (name)
- {
- unsigned nameLen = MyStringLen(name);
- unsigned propsLen = MyStringLen(s);
- unsigned totalLen = nameLen + propsLen;
- if (propsLen != 0)
- totalLen++;
- if (needSpace)
- totalLen++;
- if (totalLen + 5 >= pos)
- break;
- pos -= totalLen;
- MyStringCopy(temp + pos, name);
- if (propsLen != 0)
- {
- char *dest = temp + pos + nameLen;
- *dest++ = ':';
- MyStringCopy(dest, s);
- }
- if (needSpace)
- temp[pos + totalLen - 1] = ' ';
- }
- else
- {
- AString methodName;
- FindMethod(EXTERNAL_CODECS_VARS id64, methodName);
- if (needSpace)
- temp[--pos] = ' ';
- if (methodName.IsEmpty())
- pos -= ConvertMethodIdToString_Back(temp + pos, id64);
- else
- {
- unsigned len = methodName.Len();
- if (len + 5 > pos)
- break;
- pos -= len;
- for (unsigned i = 0; i < len; i++)
- temp[pos + i] = methodName[i];
- }
- }
- }
-
- if (numCoders != 0 && pos >= 4)
- {
- temp[--pos] = ' ';
- temp[--pos] = '.';
- temp[--pos] = '.';
- temp[--pos] = '.';
- }
-
- return PropVarEm_Set_Str(prop, temp + pos);
- // }
-}
-
-#endif
-
-STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- PropVariant_Clear(value);
- // COM_TRY_BEGIN
- // NCOM::CPropVariant prop;
-
- /*
- const CRef2 &ref2 = _refs[index];
- if (ref2.Refs.IsEmpty())
- return E_FAIL;
- const CRef &ref = ref2.Refs.Front();
- */
-
- const CFileItem &item = _db.Files[index];
- const UInt32 index2 = index;
-
- switch (propID)
- {
- case kpidIsDir: PropVarEm_Set_Bool(value, item.IsDir); break;
- case kpidSize:
- {
- PropVarEm_Set_UInt64(value, item.Size);
- // prop = ref2.Size;
- break;
- }
- case kpidPackSize:
- {
- // prop = ref2.PackSize;
- {
- CNum folderIndex = _db.FileIndexToFolderIndexMap[index2];
- if (folderIndex != kNumNoIndex)
- {
- if (_db.FolderStartFileIndex[folderIndex] == (CNum)index2)
- PropVarEm_Set_UInt64(value, _db.GetFolderFullPackSize(folderIndex));
- /*
- else
- PropVarEm_Set_UInt64(value, 0);
- */
- }
- else
- PropVarEm_Set_UInt64(value, 0);
- }
- break;
- }
- // case kpidIsAux: prop = _db.IsItemAux(index2); break;
- case kpidPosition: { UInt64 v; if (_db.StartPos.GetItem(index2, v)) PropVarEm_Set_UInt64(value, v); break; }
- case kpidCTime: SetFileTimeProp_From_UInt64Def(value, _db.CTime, index2); break;
- case kpidATime: SetFileTimeProp_From_UInt64Def(value, _db.ATime, index2); break;
- case kpidMTime: SetFileTimeProp_From_UInt64Def(value, _db.MTime, index2); break;
- case kpidAttrib: if (_db.Attrib.ValidAndDefined(index2)) PropVarEm_Set_UInt32(value, _db.Attrib.Vals[index2]); break;
- case kpidCRC: if (item.CrcDefined) PropVarEm_Set_UInt32(value, item.Crc); break;
- case kpidEncrypted: PropVarEm_Set_Bool(value, IsFolderEncrypted(_db.FileIndexToFolderIndexMap[index2])); break;
- case kpidIsAnti: PropVarEm_Set_Bool(value, _db.IsItemAnti(index2)); break;
- /*
- case kpidIsAltStream: prop = item.IsAltStream; break;
- case kpidNtSecure:
- {
- int id = _db.SecureIDs[index];
- size_t offs = _db.SecureOffsets[id];
- size_t size = _db.SecureOffsets[id + 1] - offs;
- if (size >= 0)
- {
- prop.SetBlob(_db.SecureBuf + offs, (ULONG)size);
- }
- break;
- }
- */
-
- case kpidPath: return _db.GetPath_Prop(index, value);
-
- #ifndef _SFX
-
- case kpidMethod: return SetMethodToProp(_db.FileIndexToFolderIndexMap[index2], value);
- case kpidBlock:
- {
- CNum folderIndex = _db.FileIndexToFolderIndexMap[index2];
- if (folderIndex != kNumNoIndex)
- PropVarEm_Set_UInt32(value, (UInt32)folderIndex);
- }
- break;
- /*
- case kpidPackedSize0:
- case kpidPackedSize1:
- case kpidPackedSize2:
- case kpidPackedSize3:
- case kpidPackedSize4:
- {
- CNum folderIndex = _db.FileIndexToFolderIndexMap[index2];
- if (folderIndex != kNumNoIndex)
- {
- if (_db.FolderStartFileIndex[folderIndex] == (CNum)index2 &&
- _db.FoStartPackStreamIndex[folderIndex + 1] -
- _db.FoStartPackStreamIndex[folderIndex] > (propID - kpidPackedSize0))
- {
- PropVarEm_Set_UInt64(value, _db.GetFolderPackStreamSize(folderIndex, propID - kpidPackedSize0));
- }
- }
- else
- PropVarEm_Set_UInt64(value, 0);
- }
- break;
- */
-
- #endif
- }
- // prop.Detach(value);
- return S_OK;
- // COM_TRY_END
-}
-
-STDMETHODIMP CHandler::Open(IInStream *stream,
- const UInt64 *maxCheckStartPosition,
- IArchiveOpenCallback *openArchiveCallback)
-{
- COM_TRY_BEGIN
- Close();
- #ifndef _SFX
- _fileInfoPopIDs.Clear();
- #endif
-
- try
- {
- CMyComPtr<IArchiveOpenCallback> openArchiveCallbackTemp = openArchiveCallback;
-
- #ifndef _NO_CRYPTO
- CMyComPtr<ICryptoGetTextPassword> getTextPassword;
- if (openArchiveCallback)
- openArchiveCallbackTemp.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
- #endif
-
- CInArchive archive(
- #ifdef __7Z_SET_PROPERTIES
- _useMultiThreadMixer
- #else
- true
- #endif
- );
- _db.IsArc = false;
- RINOK(archive.Open(stream, maxCheckStartPosition));
- _db.IsArc = true;
-
- HRESULT result = archive.ReadDatabase(
- EXTERNAL_CODECS_VARS
- _db
- #ifndef _NO_CRYPTO
- , getTextPassword, _isEncrypted, _passwordIsDefined, _password
- #endif
- );
- RINOK(result);
-
- _inStream = stream;
- }
- catch(...)
- {
- Close();
- // return E_INVALIDARG;
- // return S_FALSE;
- // we must return out_of_memory here
- return E_OUTOFMEMORY;
- }
- // _inStream = stream;
- #ifndef _SFX
- FillPopIDs();
- #endif
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CHandler::Close()
-{
- COM_TRY_BEGIN
- _inStream.Release();
- _db.Clear();
- #ifndef _NO_CRYPTO
- _isEncrypted = false;
- _passwordIsDefined = false;
- _password.Empty();
- #endif
- return S_OK;
- COM_TRY_END
-}
-
-#ifdef __7Z_SET_PROPERTIES
-#ifdef EXTRACT_ONLY
-
-STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
-{
- COM_TRY_BEGIN
-
- InitCommon();
- _useMultiThreadMixer = true;
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- UString name = names[i];
- name.MakeLower_Ascii();
- if (name.IsEmpty())
- return E_INVALIDARG;
- const PROPVARIANT &value = values[i];
- UInt32 number;
- unsigned index = ParseStringToUInt32(name, number);
- if (index == 0)
- {
- if (name.IsEqualTo("mtf"))
- {
- RINOK(PROPVARIANT_to_bool(value, _useMultiThreadMixer));
- continue;
- }
- {
- HRESULT hres;
- if (SetCommonProperty(name, value, hres))
- {
- RINOK(hres);
- continue;
- }
- }
- return E_INVALIDARG;
- }
- }
- return S_OK;
- COM_TRY_END
-}
-
-#endif
-#endif
-
-IMPL_ISetCompressCodecsInfo
-
-}}
+// 7zHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+
+#ifndef Z7_7Z_SET_PROPERTIES
+#include "../../../Windows/System.h"
+#endif
+
+#include "../Common/ItemNameUtils.h"
+
+#include "7zHandler.h"
+#include "7zProperties.h"
+
+#ifdef Z7_7Z_SET_PROPERTIES
+#ifdef Z7_EXTRACT_ONLY
+#include "../Common/ParseProperties.h"
+#endif
+#endif
+
+using namespace NWindows;
+using namespace NCOM;
+
+namespace NArchive {
+namespace N7z {
+
+CHandler::CHandler()
+{
+ #ifndef Z7_NO_CRYPTO
+ _isEncrypted = false;
+ _passwordIsDefined = false;
+ #endif
+
+ #ifdef Z7_EXTRACT_ONLY
+
+ _crcSize = 4;
+
+ #ifdef Z7_7Z_SET_PROPERTIES
+ _useMultiThreadMixer = true;
+ #endif
+
+ #endif
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _db.Files.Size();
+ return S_OK;
+}
+
+#ifdef Z7_SFX
+
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetNumberOfProperties(UInt32 *numProps))
+{
+ *numProps = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetPropertyInfo(UInt32 /* index */,
+ BSTR * /* name */, PROPID * /* propID */, VARTYPE * /* varType */))
+{
+ return E_NOTIMPL;
+}
+
+#else
+
+static const Byte kArcProps[] =
+{
+ kpidHeadersSize,
+ kpidMethod,
+ kpidSolid,
+ kpidNumBlocks
+ // , kpidIsTree
+};
+
+IMP_IInArchive_ArcProps
+
+static inline char GetHex(unsigned value)
+{
+ return (char)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
+}
+
+static unsigned ConvertMethodIdToString_Back(char *s, UInt64 id)
+{
+ int len = 0;
+ do
+ {
+ s[--len] = GetHex((unsigned)id & 0xF); id >>= 4;
+ s[--len] = GetHex((unsigned)id & 0xF); id >>= 4;
+ }
+ while (id != 0);
+ return (unsigned)-len;
+}
+
+static void ConvertMethodIdToString(AString &res, UInt64 id)
+{
+ const unsigned kLen = 32;
+ char s[kLen];
+ unsigned len = kLen - 1;
+ s[len] = 0;
+ res += s + len - ConvertMethodIdToString_Back(s + len, id);
+}
+
+
+static char *GetStringForSizeValue(char *s, UInt32 val)
+{
+ for (unsigned i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == val)
+ {
+ if (i >= 10)
+ {
+ *s++= (char)('0' + i / 10);
+ i %= 10;
+ }
+ *s++ = (char)('0' + i);
+ *s = 0;
+ return s;
+ }
+
+ char c = 'b';
+ if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
+ else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
+ s = ConvertUInt32ToString(val, s);
+ *s++ = c;
+ *s = 0;
+ return s;
+}
+
+
+static void GetLzma2String(char *s, unsigned d)
+{
+ if (d > 40)
+ {
+ *s = 0;
+ return;
+ // s = MyStpCpy(s, "unsup");
+ }
+ else if ((d & 1) == 0)
+ d = (d >> 1) + 12;
+ else
+ {
+ // s = GetStringForSizeValue(s, (UInt32)3 << ((d >> 1) + 11));
+ d = (d >> 1) + 1;
+ char c = 'k';
+ if (d >= 10)
+ {
+ c = 'm';
+ d -= 10;
+ }
+ s = ConvertUInt32ToString((UInt32)3 << d, s);
+ *s++ = c;
+ *s = 0;
+ return;
+ }
+ ConvertUInt32ToString(d, s);
+}
+
+
+/*
+static inline void AddHexToString(UString &res, Byte value)
+{
+ res += GetHex((Byte)(value >> 4));
+ res += GetHex((Byte)(value & 0xF));
+}
+*/
+
+static char *AddProp32(char *s, const char *name, UInt32 v)
+{
+ *s++ = ':';
+ s = MyStpCpy(s, name);
+ return ConvertUInt32ToString(v, s);
+}
+
+void CHandler::AddMethodName(AString &s, UInt64 id)
+{
+ AString name;
+ FindMethod(EXTERNAL_CODECS_VARS id, name);
+ if (name.IsEmpty())
+ ConvertMethodIdToString(s, id);
+ else
+ s += name;
+}
+
+#endif
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ #ifndef Z7_SFX
+ COM_TRY_BEGIN
+ #endif
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ #ifndef Z7_SFX
+ case kpidMethod:
+ {
+ AString s;
+ const CParsedMethods &pm = _db.ParsedMethods;
+ FOR_VECTOR (i, pm.IDs)
+ {
+ UInt64 id = pm.IDs[i];
+ s.Add_Space_if_NotEmpty();
+ char temp[16];
+ if (id == k_LZMA2)
+ {
+ s += "LZMA2:";
+ GetLzma2String(temp, pm.Lzma2Prop);
+ s += temp;
+ }
+ else if (id == k_LZMA)
+ {
+ s += "LZMA:";
+ GetStringForSizeValue(temp, pm.LzmaDic);
+ s += temp;
+ }
+ /*
+ else if (id == k_ZSTD)
+ {
+ s += "ZSTD";
+ }
+ */
+ else
+ AddMethodName(s, id);
+ }
+ prop = s;
+ break;
+ }
+ case kpidSolid: prop = _db.IsSolid(); break;
+ case kpidNumBlocks: prop = (UInt32)_db.NumFolders; break;
+ case kpidHeadersSize: prop = _db.HeadersSize; break;
+ case kpidPhySize: prop = _db.PhySize; break;
+ case kpidOffset: if (_db.ArcInfo.StartPosition != 0) prop = _db.ArcInfo.StartPosition; break;
+ /*
+ case kpidIsTree: if (_db.IsTree) prop = true; break;
+ case kpidIsAltStream: if (_db.ThereAreAltStreams) prop = true; break;
+ case kpidIsAux: if (_db.IsTree) prop = true; break;
+ */
+ // case kpidError: if (_db.ThereIsHeaderError) prop = "Header error"; break;
+ #endif
+
+ case kpidWarningFlags:
+ {
+ UInt32 v = 0;
+ if (_db.StartHeaderWasRecovered) v |= kpv_ErrorFlags_HeadersError;
+ if (_db.UnsupportedFeatureWarning) v |= kpv_ErrorFlags_UnsupportedFeature;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_db.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_db.ThereIsHeaderError) v |= kpv_ErrorFlags_HeadersError;
+ if (_db.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+ // if (_db.UnsupportedVersion) v |= kpv_ErrorFlags_Unsupported;
+ if (_db.UnsupportedFeatureError) v |= kpv_ErrorFlags_UnsupportedFeature;
+ prop = v;
+ break;
+ }
+
+ case kpidReadOnly:
+ {
+ if (!_db.CanUpdate())
+ prop = true;
+ break;
+ }
+ }
+ return prop.Detach(value);
+ #ifndef Z7_SFX
+ COM_TRY_END
+ #endif
+}
+
+static void SetFileTimeProp_From_UInt64Def(PROPVARIANT *prop, const CUInt64DefVector &v, unsigned index)
+{
+ UInt64 value;
+ if (v.GetItem(index, value))
+ PropVarEm_Set_FileTime64_Prec(prop, value, k_PropVar_TimePrec_100ns);
+}
+
+bool CHandler::IsFolderEncrypted(CNum folderIndex) const
+{
+ if (folderIndex == kNumNoIndex)
+ return false;
+ const size_t startPos = _db.FoCodersDataOffset[folderIndex];
+ const Byte *p = _db.CodersData + startPos;
+ const size_t size = _db.FoCodersDataOffset[folderIndex + 1] - startPos;
+ CInByte2 inByte;
+ inByte.Init(p, size);
+
+ CNum numCoders = inByte.ReadNum();
+ for (; numCoders != 0; numCoders--)
+ {
+ const Byte mainByte = inByte.ReadByte();
+ const unsigned idSize = (mainByte & 0xF);
+ const Byte *longID = inByte.GetPtr();
+ UInt64 id64 = 0;
+ for (unsigned j = 0; j < idSize; j++)
+ id64 = ((id64 << 8) | longID[j]);
+ inByte.SkipDataNoCheck(idSize);
+ if (id64 == k_AES)
+ return true;
+ if ((mainByte & 0x20) != 0)
+ inByte.SkipDataNoCheck(inByte.ReadNum());
+ }
+ return false;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID))
+{
+ *name = NULL;
+ *propID = kpidNtSecure;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 /* index */, UInt32 *parent, UInt32 *parentType))
+{
+ /*
+ const CFileItem &file = _db.Files[index];
+ *parentType = (file.IsAltStream ? NParentType::kAltStream : NParentType::kDir);
+ *parent = (UInt32)(Int32)file.Parent;
+ */
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (/* _db.IsTree && propID == kpidName ||
+ !_db.IsTree && */ propID == kpidPath)
+ {
+ if (_db.NameOffsets && _db.NamesBuf)
+ {
+ size_t offset = _db.NameOffsets[index];
+ size_t size = (_db.NameOffsets[index + 1] - offset) * 2;
+ if (size < ((UInt32)1 << 31))
+ {
+ *data = (const void *)(_db.NamesBuf + offset * 2);
+ *dataSize = (UInt32)size;
+ *propType = NPropDataType::kUtf16z;
+ }
+ }
+ return S_OK;
+ }
+ /*
+ if (propID == kpidNtSecure)
+ {
+ if (index < (UInt32)_db.SecureIDs.Size())
+ {
+ int id = _db.SecureIDs[index];
+ size_t offs = _db.SecureOffsets[id];
+ size_t size = _db.SecureOffsets[id + 1] - offs;
+ if (size >= 0)
+ {
+ *data = _db.SecureBuf + offs;
+ *dataSize = (UInt32)size;
+ *propType = NPropDataType::kRaw;
+ }
+ }
+ }
+ */
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+HRESULT CHandler::SetMethodToProp(CNum folderIndex, PROPVARIANT *prop) const
+{
+ PropVariant_Clear(prop);
+ if (folderIndex == kNumNoIndex)
+ return S_OK;
+ // for (int ttt = 0; ttt < 1; ttt++) {
+ const unsigned kTempSize = 256;
+ char temp[kTempSize];
+ unsigned pos = kTempSize;
+ temp[--pos] = 0;
+
+ const size_t startPos = _db.FoCodersDataOffset[folderIndex];
+ const Byte *p = _db.CodersData + startPos;
+ const size_t size = _db.FoCodersDataOffset[folderIndex + 1] - startPos;
+ CInByte2 inByte;
+ inByte.Init(p, size);
+
+ // numCoders == 0 ???
+ CNum numCoders = inByte.ReadNum();
+ bool needSpace = false;
+
+ for (; numCoders != 0; numCoders--, needSpace = true)
+ {
+ if (pos < 32) // max size of property
+ break;
+ const Byte mainByte = inByte.ReadByte();
+ UInt64 id64 = 0;
+ const unsigned idSize = (mainByte & 0xF);
+ const Byte *longID = inByte.GetPtr();
+ for (unsigned j = 0; j < idSize; j++)
+ id64 = ((id64 << 8) | longID[j]);
+ inByte.SkipDataNoCheck(idSize);
+
+ if ((mainByte & 0x10) != 0)
+ {
+ inByte.ReadNum(); // NumInStreams
+ inByte.ReadNum(); // NumOutStreams
+ }
+
+ CNum propsSize = 0;
+ const Byte *props = NULL;
+ if ((mainByte & 0x20) != 0)
+ {
+ propsSize = inByte.ReadNum();
+ props = inByte.GetPtr();
+ inByte.SkipDataNoCheck(propsSize);
+ }
+
+ const char *name = NULL;
+ char s[32];
+ s[0] = 0;
+
+ if (id64 <= (UInt32)0xFFFFFFFF)
+ {
+ const UInt32 id = (UInt32)id64;
+ if (id == k_LZMA)
+ {
+ name = "LZMA";
+ if (propsSize == 5)
+ {
+ const UInt32 dicSize = GetUi32((const Byte *)props + 1);
+ char *dest = GetStringForSizeValue(s, dicSize);
+ UInt32 d = props[0];
+ if (d != 0x5D)
+ {
+ const UInt32 lc = d % 9;
+ d /= 9;
+ const UInt32 pb = d / 5;
+ const UInt32 lp = d % 5;
+ if (lc != 3) dest = AddProp32(dest, "lc", lc);
+ if (lp != 0) dest = AddProp32(dest, "lp", lp);
+ if (pb != 2) dest = AddProp32(dest, "pb", pb);
+ }
+ }
+ }
+ else if (id == k_LZMA2)
+ {
+ name = "LZMA2";
+ if (propsSize == 1)
+ GetLzma2String(s, props[0]);
+ }
+ else if (id == k_PPMD)
+ {
+ name = "PPMD";
+ if (propsSize == 5)
+ {
+ char *dest = s;
+ *dest++ = 'o';
+ dest = ConvertUInt32ToString(*props, dest);
+ dest = MyStpCpy(dest, ":mem");
+ GetStringForSizeValue(dest, GetUi32(props + 1));
+ }
+ }
+ else if (id == k_Delta)
+ {
+ name = "Delta";
+ if (propsSize == 1)
+ ConvertUInt32ToString((UInt32)props[0] + 1, s);
+ }
+ else if (id == k_ARM64)
+ {
+ name = "ARM64";
+ if (propsSize == 4)
+ ConvertUInt32ToString(GetUi32(props), s);
+ /*
+ else if (propsSize != 0)
+ MyStringCopy(s, "unsupported");
+ */
+ }
+ else if (id == k_BCJ2) name = "BCJ2";
+ else if (id == k_BCJ) name = "BCJ";
+ else if (id == k_AES)
+ {
+ name = "7zAES";
+ if (propsSize >= 1)
+ {
+ const Byte firstByte = props[0];
+ const UInt32 numCyclesPower = firstByte & 0x3F;
+ ConvertUInt32ToString(numCyclesPower, s);
+ }
+ }
+ }
+
+ if (name)
+ {
+ const unsigned nameLen = MyStringLen(name);
+ const unsigned propsLen = MyStringLen(s);
+ unsigned totalLen = nameLen + propsLen;
+ if (propsLen != 0)
+ totalLen++;
+ if (needSpace)
+ totalLen++;
+ if (totalLen + 5 >= pos)
+ break;
+ pos -= totalLen;
+ MyStringCopy(temp + pos, name);
+ if (propsLen != 0)
+ {
+ char *dest = temp + pos + nameLen;
+ *dest++ = ':';
+ MyStringCopy(dest, s);
+ }
+ if (needSpace)
+ temp[pos + totalLen - 1] = ' ';
+ }
+ else
+ {
+ AString methodName;
+ FindMethod(EXTERNAL_CODECS_VARS id64, methodName);
+ if (needSpace)
+ temp[--pos] = ' ';
+ if (methodName.IsEmpty())
+ pos -= ConvertMethodIdToString_Back(temp + pos, id64);
+ else
+ {
+ const unsigned len = methodName.Len();
+ if (len + 5 > pos)
+ break;
+ pos -= len;
+ for (unsigned i = 0; i < len; i++)
+ temp[pos + i] = methodName[i];
+ }
+ }
+ }
+
+ if (numCoders != 0 && pos >= 4)
+ {
+ temp[--pos] = ' ';
+ temp[--pos] = '.';
+ temp[--pos] = '.';
+ temp[--pos] = '.';
+ }
+
+ return PropVarEm_Set_Str(prop, temp + pos);
+ // }
+}
+
+#endif
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ RINOK(PropVariant_Clear(value))
+ // COM_TRY_BEGIN
+ // NCOM::CPropVariant prop;
+
+ /*
+ const CRef2 &ref2 = _refs[index];
+ if (ref2.Refs.IsEmpty())
+ return E_FAIL;
+ const CRef &ref = ref2.Refs.Front();
+ */
+
+ const CFileItem &item = _db.Files[index];
+ const UInt32 index2 = index;
+
+ switch (propID)
+ {
+ case kpidIsDir: PropVarEm_Set_Bool(value, item.IsDir); break;
+ case kpidSize:
+ {
+ PropVarEm_Set_UInt64(value, item.Size);
+ // prop = ref2.Size;
+ break;
+ }
+ case kpidPackSize:
+ {
+ // prop = ref2.PackSize;
+ {
+ const CNum folderIndex = _db.FileIndexToFolderIndexMap[index2];
+ if (folderIndex != kNumNoIndex)
+ {
+ if (_db.FolderStartFileIndex[folderIndex] == (CNum)index2)
+ PropVarEm_Set_UInt64(value, _db.GetFolderFullPackSize(folderIndex));
+ /*
+ else
+ PropVarEm_Set_UInt64(value, 0);
+ */
+ }
+ else
+ PropVarEm_Set_UInt64(value, 0);
+ }
+ break;
+ }
+ // case kpidIsAux: prop = _db.IsItemAux(index2); break;
+ case kpidPosition: { UInt64 v; if (_db.StartPos.GetItem(index2, v)) PropVarEm_Set_UInt64(value, v); break; }
+ case kpidCTime: SetFileTimeProp_From_UInt64Def(value, _db.CTime, index2); break;
+ case kpidATime: SetFileTimeProp_From_UInt64Def(value, _db.ATime, index2); break;
+ case kpidMTime: SetFileTimeProp_From_UInt64Def(value, _db.MTime, index2); break;
+ case kpidAttrib: if (_db.Attrib.ValidAndDefined(index2)) PropVarEm_Set_UInt32(value, _db.Attrib.Vals[index2]); break;
+ case kpidCRC: if (item.CrcDefined) PropVarEm_Set_UInt32(value, item.Crc); break;
+ case kpidEncrypted: PropVarEm_Set_Bool(value, IsFolderEncrypted(_db.FileIndexToFolderIndexMap[index2])); break;
+ case kpidIsAnti: PropVarEm_Set_Bool(value, _db.IsItemAnti(index2)); break;
+ /*
+ case kpidIsAltStream: prop = item.IsAltStream; break;
+ case kpidNtSecure:
+ {
+ int id = _db.SecureIDs[index];
+ size_t offs = _db.SecureOffsets[id];
+ size_t size = _db.SecureOffsets[id + 1] - offs;
+ if (size >= 0)
+ {
+ prop.SetBlob(_db.SecureBuf + offs, (ULONG)size);
+ }
+ break;
+ }
+ */
+
+ case kpidPath: return _db.GetPath_Prop(index, value);
+
+ #ifndef Z7_SFX
+
+ case kpidMethod: return SetMethodToProp(_db.FileIndexToFolderIndexMap[index2], value);
+ case kpidBlock:
+ {
+ const CNum folderIndex = _db.FileIndexToFolderIndexMap[index2];
+ if (folderIndex != kNumNoIndex)
+ PropVarEm_Set_UInt32(value, (UInt32)folderIndex);
+ }
+ break;
+ #ifdef Z7_7Z_SHOW_PACK_STREAMS_SIZES
+ case kpidPackedSize0:
+ case kpidPackedSize1:
+ case kpidPackedSize2:
+ case kpidPackedSize3:
+ case kpidPackedSize4:
+ {
+ const CNum folderIndex = _db.FileIndexToFolderIndexMap[index2];
+ if (folderIndex != kNumNoIndex)
+ {
+ if (_db.FolderStartFileIndex[folderIndex] == (CNum)index2 &&
+ _db.FoStartPackStreamIndex[folderIndex + 1] -
+ _db.FoStartPackStreamIndex[folderIndex] > (propID - kpidPackedSize0))
+ {
+ PropVarEm_Set_UInt64(value, _db.GetFolderPackStreamSize(folderIndex, propID - kpidPackedSize0));
+ }
+ }
+ else
+ PropVarEm_Set_UInt64(value, 0);
+ }
+ break;
+ #endif
+
+ #endif
+ }
+ // return prop.Detach(value);
+ return S_OK;
+ // COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openArchiveCallback))
+{
+ COM_TRY_BEGIN
+ Close();
+ #ifndef Z7_SFX
+ _fileInfoPopIDs.Clear();
+ #endif
+
+ try
+ {
+ CMyComPtr<IArchiveOpenCallback> openArchiveCallbackTemp = openArchiveCallback;
+
+ #ifndef Z7_NO_CRYPTO
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ if (openArchiveCallback)
+ openArchiveCallbackTemp.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
+ #endif
+
+ CInArchive archive(
+ #ifdef Z7_7Z_SET_PROPERTIES
+ _useMultiThreadMixer
+ #else
+ true
+ #endif
+ );
+ _db.IsArc = false;
+ RINOK(archive.Open(stream, maxCheckStartPosition))
+ _db.IsArc = true;
+
+ HRESULT result = archive.ReadDatabase(
+ EXTERNAL_CODECS_VARS
+ _db
+ #ifndef Z7_NO_CRYPTO
+ , getTextPassword, _isEncrypted, _passwordIsDefined, _password
+ #endif
+ );
+ RINOK(result)
+
+ _inStream = stream;
+ }
+ catch(...)
+ {
+ Close();
+ // return E_INVALIDARG;
+ // return S_FALSE;
+ // we must return out_of_memory here
+ return E_OUTOFMEMORY;
+ }
+ // _inStream = stream;
+ #ifndef Z7_SFX
+ FillPopIDs();
+ #endif
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ COM_TRY_BEGIN
+ _inStream.Release();
+ _db.Clear();
+ #ifndef Z7_NO_CRYPTO
+ _isEncrypted = false;
+ _passwordIsDefined = false;
+ _password.Wipe_and_Empty();
+ #endif
+ return S_OK;
+ COM_TRY_END
+}
+
+#ifdef Z7_7Z_SET_PROPERTIES
+#ifdef Z7_EXTRACT_ONLY
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ COM_TRY_BEGIN
+
+ InitCommon();
+ _useMultiThreadMixer = true;
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ UString name = names[i];
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+ const PROPVARIANT &value = values[i];
+ UInt32 number;
+ const unsigned index = ParseStringToUInt32(name, number);
+ if (index == 0)
+ {
+ if (name.IsEqualTo("mtf"))
+ {
+ RINOK(PROPVARIANT_to_bool(value, _useMultiThreadMixer))
+ continue;
+ }
+ {
+ HRESULT hres;
+ if (SetCommonProperty(name, value, hres))
+ {
+ RINOK(hres)
+ continue;
+ }
+ }
+ return E_INVALIDARG;
+ }
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+#endif
+#endif
+
+IMPL_ISetCompressCodecsInfo
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zHandler.h b/CPP/7zip/Archive/7z/7zHandler.h
index 7d5a5f0..b1c0466 100644
--- a/CPP/7zip/Archive/7z/7zHandler.h
+++ b/CPP/7zip/Archive/7z/7zHandler.h
@@ -1,181 +1,176 @@
-// 7z/Handler.h
-
-#ifndef __7Z_HANDLER_H
-#define __7Z_HANDLER_H
-
-#include "../../ICoder.h"
-#include "../IArchive.h"
-
-#include "../../Common/CreateCoder.h"
-
-#ifndef __7Z_SET_PROPERTIES
-
-#ifdef EXTRACT_ONLY
- #if !defined(_7ZIP_ST) && !defined(_SFX)
- #define __7Z_SET_PROPERTIES
- #endif
-#else
- #define __7Z_SET_PROPERTIES
-#endif
-
-#endif
-
-// #ifdef __7Z_SET_PROPERTIES
-#include "../Common/HandlerOut.h"
-// #endif
-
-#include "7zCompressionMode.h"
-#include "7zIn.h"
-
-namespace NArchive {
-namespace N7z {
-
-
-#ifndef EXTRACT_ONLY
-
-class COutHandler: public CMultiMethodProps
-{
- HRESULT SetSolidFromString(const UString &s);
- HRESULT SetSolidFromPROPVARIANT(const PROPVARIANT &value);
-public:
- UInt64 _numSolidFiles;
- UInt64 _numSolidBytes;
- bool _numSolidBytesDefined;
- bool _solidExtension;
- bool _useTypeSorting;
-
- bool _compressHeaders;
- bool _encryptHeadersSpecified;
- bool _encryptHeaders;
- // bool _useParents; 9.26
-
- CBoolPair Write_CTime;
- CBoolPair Write_ATime;
- CBoolPair Write_MTime;
- CBoolPair Write_Attrib;
-
- bool _useMultiThreadMixer;
-
- bool _removeSfxBlock;
-
- // bool _volumeMode;
-
- void InitSolidFiles() { _numSolidFiles = (UInt64)(Int64)(-1); }
- void InitSolidSize() { _numSolidBytes = (UInt64)(Int64)(-1); }
- void InitSolid()
- {
- InitSolidFiles();
- InitSolidSize();
- _solidExtension = false;
- _numSolidBytesDefined = false;
- }
-
- void InitProps7z();
- void InitProps();
-
- COutHandler() { InitProps7z(); }
-
- HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
-};
-
-#endif
-
-class CHandler:
- public IInArchive,
- public IArchiveGetRawProps,
-
- #ifdef __7Z_SET_PROPERTIES
- public ISetProperties,
- #endif
-
- #ifndef EXTRACT_ONLY
- public IOutArchive,
- #endif
-
- PUBLIC_ISetCompressCodecsInfo
-
- public CMyUnknownImp,
-
- #ifndef EXTRACT_ONLY
- public COutHandler
- #else
- public CCommonMethodProps
- #endif
-{
-public:
- MY_QUERYINTERFACE_BEGIN2(IInArchive)
- MY_QUERYINTERFACE_ENTRY(IArchiveGetRawProps)
- #ifdef __7Z_SET_PROPERTIES
- MY_QUERYINTERFACE_ENTRY(ISetProperties)
- #endif
- #ifndef EXTRACT_ONLY
- MY_QUERYINTERFACE_ENTRY(IOutArchive)
- #endif
- QUERY_ENTRY_ISetCompressCodecsInfo
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- INTERFACE_IInArchive(;)
- INTERFACE_IArchiveGetRawProps(;)
-
- #ifdef __7Z_SET_PROPERTIES
- STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
- #endif
-
- #ifndef EXTRACT_ONLY
- INTERFACE_IOutArchive(;)
- #endif
-
- DECL_ISetCompressCodecsInfo
-
- CHandler();
-
-private:
- CMyComPtr<IInStream> _inStream;
- NArchive::N7z::CDbEx _db;
-
- #ifndef _NO_CRYPTO
- bool _isEncrypted;
- bool _passwordIsDefined;
- UString _password;
- #endif
-
- #ifdef EXTRACT_ONLY
-
- #ifdef __7Z_SET_PROPERTIES
- bool _useMultiThreadMixer;
- #endif
-
- UInt32 _crcSize;
-
- #else
-
- CRecordVector<CBond2> _bonds;
-
- HRESULT PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m);
- HRESULT SetHeaderMethod(CCompressionMethodMode &headerMethod);
- HRESULT SetMainMethod(CCompressionMethodMode &method
- #ifndef _7ZIP_ST
- , UInt32 numThreads
- #endif
- );
-
-
- #endif
-
- bool IsFolderEncrypted(CNum folderIndex) const;
- #ifndef _SFX
-
- CRecordVector<UInt64> _fileInfoPopIDs;
- void FillPopIDs();
- void AddMethodName(AString &s, UInt64 id);
- HRESULT SetMethodToProp(CNum folderIndex, PROPVARIANT *prop) const;
-
- #endif
-
- DECL_EXTERNAL_CODECS_VARS
-};
-
-}}
-
-#endif
+// 7z/Handler.h
+
+#ifndef ZIP7_7Z_HANDLER_H
+#define ZIP7_7Z_HANDLER_H
+
+#include "../../ICoder.h"
+#include "../IArchive.h"
+
+#include "../../Common/CreateCoder.h"
+
+#ifndef Z7_7Z_SET_PROPERTIES
+
+#ifdef Z7_EXTRACT_ONLY
+ #if !defined(Z7_ST) && !defined(Z7_SFX)
+ #define Z7_7Z_SET_PROPERTIES
+ #endif
+#else
+ #define Z7_7Z_SET_PROPERTIES
+#endif
+
+#endif
+
+// #ifdef Z7_7Z_SET_PROPERTIES
+#include "../Common/HandlerOut.h"
+// #endif
+
+#include "7zCompressionMode.h"
+#include "7zIn.h"
+
+namespace NArchive {
+namespace N7z {
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+class COutHandler: public CMultiMethodProps
+{
+ HRESULT SetSolidFromString(const UString &s);
+ HRESULT SetSolidFromPROPVARIANT(const PROPVARIANT &value);
+public:
+ UInt64 _numSolidFiles;
+ UInt64 _numSolidBytes;
+ bool _numSolidBytesDefined;
+ bool _solidExtension;
+ bool _useTypeSorting;
+
+ bool _compressHeaders;
+ bool _encryptHeadersSpecified;
+ bool _encryptHeaders;
+ // bool _useParents; 9.26
+
+ CHandlerTimeOptions TimeOptions;
+
+ CBoolPair Write_Attrib;
+
+ bool _useMultiThreadMixer;
+
+ bool _removeSfxBlock;
+
+ // bool _volumeMode;
+
+ void InitSolidFiles() { _numSolidFiles = (UInt64)(Int64)(-1); }
+ void InitSolidSize() { _numSolidBytes = (UInt64)(Int64)(-1); }
+ void InitSolid()
+ {
+ InitSolidFiles();
+ InitSolidSize();
+ _solidExtension = false;
+ _numSolidBytesDefined = false;
+ }
+
+ void InitProps7z();
+ void InitProps();
+
+ COutHandler() { InitProps7z(); }
+
+ HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
+};
+
+#endif
+
+class CHandler Z7_final:
+ public IInArchive,
+ public IArchiveGetRawProps,
+
+ #ifdef Z7_7Z_SET_PROPERTIES
+ public ISetProperties,
+ #endif
+
+ #ifndef Z7_EXTRACT_ONLY
+ public IOutArchive,
+ #endif
+
+ Z7_PUBLIC_ISetCompressCodecsInfo_IFEC
+
+ public CMyUnknownImp,
+
+ #ifndef Z7_EXTRACT_ONLY
+ public COutHandler
+ #else
+ public CCommonMethodProps
+ #endif
+{
+ Z7_COM_QI_BEGIN2(IInArchive)
+ Z7_COM_QI_ENTRY(IArchiveGetRawProps)
+ #ifdef Z7_7Z_SET_PROPERTIES
+ Z7_COM_QI_ENTRY(ISetProperties)
+ #endif
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_COM_QI_ENTRY(IOutArchive)
+ #endif
+ Z7_COM_QI_ENTRY_ISetCompressCodecsInfo_IFEC
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IInArchive)
+ Z7_IFACE_COM7_IMP(IArchiveGetRawProps)
+ #ifdef Z7_7Z_SET_PROPERTIES
+ Z7_IFACE_COM7_IMP(ISetProperties)
+ #endif
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_IFACE_COM7_IMP(IOutArchive)
+ #endif
+ DECL_ISetCompressCodecsInfo
+
+private:
+ CMyComPtr<IInStream> _inStream;
+ NArchive::N7z::CDbEx _db;
+
+ #ifndef Z7_NO_CRYPTO
+ bool _isEncrypted;
+ bool _passwordIsDefined;
+ UString _password; // _Wipe
+ #endif
+
+ #ifdef Z7_EXTRACT_ONLY
+
+ #ifdef Z7_7Z_SET_PROPERTIES
+ bool _useMultiThreadMixer;
+ #endif
+
+ UInt32 _crcSize;
+
+ #else
+
+ CRecordVector<CBond2> _bonds;
+
+ HRESULT PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m);
+ HRESULT SetHeaderMethod(CCompressionMethodMode &headerMethod);
+ HRESULT SetMainMethod(CCompressionMethodMode &method);
+
+ #endif
+
+ bool IsFolderEncrypted(CNum folderIndex) const;
+ #ifndef Z7_SFX
+
+ CRecordVector<UInt64> _fileInfoPopIDs;
+ void FillPopIDs();
+ void AddMethodName(AString &s, UInt64 id);
+ HRESULT SetMethodToProp(CNum folderIndex, PROPVARIANT *prop) const;
+
+ #endif
+
+ DECL_EXTERNAL_CODECS_VARS
+
+public:
+ CHandler();
+ ~CHandler()
+ {
+ Close();
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zHandlerOut.cpp b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
index 62587e8..ff8735f 100644
--- a/CPP/7zip/Archive/7z/7zHandlerOut.cpp
+++ b/CPP/7zip/Archive/7z/7zHandlerOut.cpp
@@ -1,942 +1,1086 @@
-// 7zHandlerOut.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/ComTry.h"
-#include "../../../Common/StringToInt.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../Common/ItemNameUtils.h"
-#include "../Common/ParseProperties.h"
-
-#include "7zHandler.h"
-#include "7zOut.h"
-#include "7zUpdate.h"
-
-#ifndef EXTRACT_ONLY
-
-using namespace NWindows;
-
-namespace NArchive {
-namespace N7z {
-
-#define k_LZMA_Name "LZMA"
-#define kDefaultMethodName "LZMA2"
-#define k_Copy_Name "Copy"
-
-#define k_MatchFinder_ForHeaders "BT2"
-
-static const UInt32 k_NumFastBytes_ForHeaders = 273;
-static const UInt32 k_Level_ForHeaders = 5;
-static const UInt32 k_Dictionary_ForHeaders =
- #ifdef UNDER_CE
- 1 << 18;
- #else
- 1 << 20;
- #endif
-
-STDMETHODIMP CHandler::GetFileTimeType(UInt32 *type)
-{
- *type = NFileTimeType::kWindows;
- return S_OK;
-}
-
-HRESULT CHandler::PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m)
-{
- dest.CodecIndex = FindMethod_Index(
- EXTERNAL_CODECS_VARS
- m.MethodName, true,
- dest.Id, dest.NumStreams);
- if (dest.CodecIndex < 0)
- return E_INVALIDARG;
- (CProps &)dest = (CProps &)m;
- return S_OK;
-}
-
-HRESULT CHandler::SetHeaderMethod(CCompressionMethodMode &headerMethod)
-{
- if (!_compressHeaders)
- return S_OK;
- COneMethodInfo m;
- m.MethodName = k_LZMA_Name;
- m.AddProp_Ascii(NCoderPropID::kMatchFinder, k_MatchFinder_ForHeaders);
- m.AddProp_Level(k_Level_ForHeaders);
- m.AddProp32(NCoderPropID::kNumFastBytes, k_NumFastBytes_ForHeaders);
- m.AddProp32(NCoderPropID::kDictionarySize, k_Dictionary_ForHeaders);
- m.AddProp_NumThreads(1);
-
- CMethodFull &methodFull = headerMethod.Methods.AddNew();
- return PropsMethod_To_FullMethod(methodFull, m);
-}
-
-HRESULT CHandler::SetMainMethod(
- CCompressionMethodMode &methodMode
- #ifndef _7ZIP_ST
- , UInt32 numThreads
- #endif
- )
-{
- methodMode.Bonds = _bonds;
-
- CObjectVector<COneMethodInfo> methods = _methods;
-
- {
- FOR_VECTOR (i, methods)
- {
- AString &methodName = methods[i].MethodName;
- if (methodName.IsEmpty())
- methodName = kDefaultMethodName;
- }
- if (methods.IsEmpty())
- {
- COneMethodInfo &m = methods.AddNew();
- m.MethodName = (GetLevel() == 0 ? k_Copy_Name : kDefaultMethodName);
- methodMode.DefaultMethod_was_Inserted = true;
- }
- }
-
- if (!_filterMethod.MethodName.IsEmpty())
- {
- // if (methodMode.Bonds.IsEmpty())
- {
- FOR_VECTOR (k, methodMode.Bonds)
- {
- CBond2 &bond = methodMode.Bonds[k];
- bond.InCoder++;
- bond.OutCoder++;
- }
- methods.Insert(0, _filterMethod);
- methodMode.Filter_was_Inserted = true;
- }
- }
-
- const UInt64 kSolidBytes_Min = (1 << 24);
- const UInt64 kSolidBytes_Max = ((UInt64)1 << 32) - 1;
-
- bool needSolid = false;
-
- FOR_VECTOR (i, methods)
- {
- COneMethodInfo &oneMethodInfo = methods[i];
-
- SetGlobalLevelTo(oneMethodInfo);
- #ifndef _7ZIP_ST
- CMultiMethodProps::SetMethodThreadsTo(oneMethodInfo, numThreads);
- #endif
-
- CMethodFull &methodFull = methodMode.Methods.AddNew();
- RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo));
-
- if (methodFull.Id != k_Copy)
- needSolid = true;
-
- if (_numSolidBytesDefined)
- continue;
-
- UInt32 dicSize;
- switch (methodFull.Id)
- {
- case k_LZMA:
- case k_LZMA2: dicSize = oneMethodInfo.Get_Lzma_DicSize(); break;
- case k_PPMD: dicSize = oneMethodInfo.Get_Ppmd_MemSize(); break;
- case k_Deflate: dicSize = (UInt32)1 << 15; break;
- case k_BZip2: dicSize = oneMethodInfo.Get_BZip2_BlockSize(); break;
- default: continue;
- }
-
- _numSolidBytes = (UInt64)dicSize << 7;
- if (_numSolidBytes < kSolidBytes_Min) _numSolidBytes = kSolidBytes_Min;
- if (_numSolidBytes > kSolidBytes_Max) _numSolidBytes = kSolidBytes_Max;
- _numSolidBytesDefined = true;
- }
-
- if (!_numSolidBytesDefined)
- if (needSolid)
- _numSolidBytes = kSolidBytes_Max;
- else
- _numSolidBytes = 0;
- _numSolidBytesDefined = true;
- return S_OK;
-}
-
-static HRESULT GetTime(IArchiveUpdateCallback *updateCallback, int index, PROPID propID, UInt64 &ft, bool &ftDefined)
-{
- // ft = 0;
- // ftDefined = false;
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(index, propID, &prop));
- if (prop.vt == VT_FILETIME)
- {
- ft = prop.filetime.dwLowDateTime | ((UInt64)prop.filetime.dwHighDateTime << 32);
- ftDefined = true;
- }
- else if (prop.vt != VT_EMPTY)
- return E_INVALIDARG;
- else
- {
- ft = 0;
- ftDefined = false;
- }
- return S_OK;
-}
-
-/*
-
-#ifdef _WIN32
-static const wchar_t kDirDelimiter1 = L'\\';
-#endif
-static const wchar_t kDirDelimiter2 = L'/';
-
-static inline bool IsCharDirLimiter(wchar_t c)
-{
- return (
- #ifdef _WIN32
- c == kDirDelimiter1 ||
- #endif
- c == kDirDelimiter2);
-}
-
-static int FillSortIndex(CObjectVector<CTreeFolder> &treeFolders, int cur, int curSortIndex)
-{
- CTreeFolder &tf = treeFolders[cur];
- tf.SortIndex = curSortIndex++;
- for (int i = 0; i < tf.SubFolders.Size(); i++)
- curSortIndex = FillSortIndex(treeFolders, tf.SubFolders[i], curSortIndex);
- tf.SortIndexEnd = curSortIndex;
- return curSortIndex;
-}
-
-static int FindSubFolder(const CObjectVector<CTreeFolder> &treeFolders, int cur, const UString &name, int &insertPos)
-{
- const CIntVector &subFolders = treeFolders[cur].SubFolders;
- int left = 0, right = subFolders.Size();
- insertPos = -1;
- for (;;)
- {
- if (left == right)
- {
- insertPos = left;
- return -1;
- }
- int mid = (left + right) / 2;
- int midFolder = subFolders[mid];
- int compare = CompareFileNames(name, treeFolders[midFolder].Name);
- if (compare == 0)
- return midFolder;
- if (compare < 0)
- right = mid;
- else
- left = mid + 1;
- }
-}
-
-static int AddFolder(CObjectVector<CTreeFolder> &treeFolders, int cur, const UString &name)
-{
- int insertPos;
- int folderIndex = FindSubFolder(treeFolders, cur, name, insertPos);
- if (folderIndex < 0)
- {
- folderIndex = treeFolders.Size();
- CTreeFolder &newFolder = treeFolders.AddNew();
- newFolder.Parent = cur;
- newFolder.Name = name;
- treeFolders[cur].SubFolders.Insert(insertPos, folderIndex);
- }
- // else if (treeFolders[folderIndex].IsAltStreamFolder != isAltStreamFolder) throw 1123234234;
- return folderIndex;
-}
-*/
-
-STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
- IArchiveUpdateCallback *updateCallback)
-{
- COM_TRY_BEGIN
-
- const CDbEx *db = 0;
- #ifdef _7Z_VOL
- if (_volumes.Size() > 1)
- return E_FAIL;
- const CVolume *volume = 0;
- if (_volumes.Size() == 1)
- {
- volume = &_volumes.Front();
- db = &volume->Database;
- }
- #else
- if (_inStream != 0)
- db = &_db;
- #endif
-
- if (db && !db->CanUpdate())
- return E_NOTIMPL;
-
- /*
- CMyComPtr<IArchiveGetRawProps> getRawProps;
- updateCallback->QueryInterface(IID_IArchiveGetRawProps, (void **)&getRawProps);
-
- CUniqBlocks secureBlocks;
- secureBlocks.AddUniq(NULL, 0);
-
- CObjectVector<CTreeFolder> treeFolders;
- {
- CTreeFolder folder;
- folder.Parent = -1;
- treeFolders.Add(folder);
- }
- */
-
- CObjectVector<CUpdateItem> updateItems;
-
- bool need_CTime = (Write_CTime.Def && Write_CTime.Val);
- bool need_ATime = (Write_ATime.Def && Write_ATime.Val);
- bool need_MTime = (Write_MTime.Def && Write_MTime.Val || !Write_MTime.Def);
- bool need_Attrib = (Write_Attrib.Def && Write_Attrib.Val || !Write_Attrib.Def);
-
- if (db && !db->Files.IsEmpty())
- {
- if (!Write_CTime.Def) need_CTime = !db->CTime.Defs.IsEmpty();
- if (!Write_ATime.Def) need_ATime = !db->ATime.Defs.IsEmpty();
- if (!Write_MTime.Def) need_MTime = !db->MTime.Defs.IsEmpty();
- if (!Write_Attrib.Def) need_Attrib = !db->Attrib.Defs.IsEmpty();
- }
-
- // UString s;
- UString name;
-
- for (UInt32 i = 0; i < numItems; i++)
- {
- Int32 newData, newProps;
- UInt32 indexInArchive;
- if (!updateCallback)
- return E_FAIL;
- RINOK(updateCallback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive));
- CUpdateItem ui;
- ui.NewProps = IntToBool(newProps);
- ui.NewData = IntToBool(newData);
- ui.IndexInArchive = indexInArchive;
- ui.IndexInClient = i;
- ui.IsAnti = false;
- ui.Size = 0;
-
- name.Empty();
- // bool isAltStream = false;
- if (ui.IndexInArchive != -1)
- {
- if (db == 0 || (unsigned)ui.IndexInArchive >= db->Files.Size())
- return E_INVALIDARG;
- const CFileItem &fi = db->Files[ui.IndexInArchive];
- if (!ui.NewProps)
- {
- _db.GetPath(ui.IndexInArchive, name);
- }
- ui.IsDir = fi.IsDir;
- ui.Size = fi.Size;
- // isAltStream = fi.IsAltStream;
- ui.IsAnti = db->IsItemAnti(ui.IndexInArchive);
-
- if (!ui.NewProps)
- {
- ui.CTimeDefined = db->CTime.GetItem(ui.IndexInArchive, ui.CTime);
- ui.ATimeDefined = db->ATime.GetItem(ui.IndexInArchive, ui.ATime);
- ui.MTimeDefined = db->MTime.GetItem(ui.IndexInArchive, ui.MTime);
- }
- }
-
- if (ui.NewProps)
- {
- bool folderStatusIsDefined;
- if (need_Attrib)
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(i, kpidAttrib, &prop));
- if (prop.vt == VT_EMPTY)
- ui.AttribDefined = false;
- else if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- else
- {
- ui.Attrib = prop.ulVal;
- ui.AttribDefined = true;
- }
- }
-
- // we need MTime to sort files.
- if (need_CTime) RINOK(GetTime(updateCallback, i, kpidCTime, ui.CTime, ui.CTimeDefined));
- if (need_ATime) RINOK(GetTime(updateCallback, i, kpidATime, ui.ATime, ui.ATimeDefined));
- if (need_MTime) RINOK(GetTime(updateCallback, i, kpidMTime, ui.MTime, ui.MTimeDefined));
-
- /*
- if (getRawProps)
- {
- const void *data;
- UInt32 dataSize;
- UInt32 propType;
-
- getRawProps->GetRawProp(i, kpidNtSecure, &data, &dataSize, &propType);
- if (dataSize != 0 && propType != NPropDataType::kRaw)
- return E_FAIL;
- ui.SecureIndex = secureBlocks.AddUniq((const Byte *)data, dataSize);
- }
- */
-
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(i, kpidPath, &prop));
- if (prop.vt == VT_EMPTY)
- {
- }
- else if (prop.vt != VT_BSTR)
- return E_INVALIDARG;
- else
- {
- name = prop.bstrVal;
- NItemName::ReplaceSlashes_OsToUnix(name);
- }
- }
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(i, kpidIsDir, &prop));
- if (prop.vt == VT_EMPTY)
- folderStatusIsDefined = false;
- else if (prop.vt != VT_BOOL)
- return E_INVALIDARG;
- else
- {
- ui.IsDir = (prop.boolVal != VARIANT_FALSE);
- folderStatusIsDefined = true;
- }
- }
-
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(i, kpidIsAnti, &prop));
- if (prop.vt == VT_EMPTY)
- ui.IsAnti = false;
- else if (prop.vt != VT_BOOL)
- return E_INVALIDARG;
- else
- ui.IsAnti = (prop.boolVal != VARIANT_FALSE);
- }
-
- /*
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(i, kpidIsAltStream, &prop));
- if (prop.vt == VT_EMPTY)
- isAltStream = false;
- else if (prop.vt != VT_BOOL)
- return E_INVALIDARG;
- else
- isAltStream = (prop.boolVal != VARIANT_FALSE);
- }
- */
-
- if (ui.IsAnti)
- {
- ui.AttribDefined = false;
-
- ui.CTimeDefined = false;
- ui.ATimeDefined = false;
- ui.MTimeDefined = false;
-
- ui.Size = 0;
- }
-
- if (!folderStatusIsDefined && ui.AttribDefined)
- ui.SetDirStatusFromAttrib();
- }
- else
- {
- /*
- if (_db.SecureIDs.IsEmpty())
- ui.SecureIndex = secureBlocks.AddUniq(NULL, 0);
- else
- {
- int id = _db.SecureIDs[ui.IndexInArchive];
- size_t offs = _db.SecureOffsets[id];
- size_t size = _db.SecureOffsets[id + 1] - offs;
- ui.SecureIndex = secureBlocks.AddUniq(_db.SecureBuf + offs, size);
- }
- */
- }
-
- /*
- {
- int folderIndex = 0;
- if (_useParents)
- {
- int j;
- s.Empty();
- for (j = 0; j < name.Len(); j++)
- {
- wchar_t c = name[j];
- if (IsCharDirLimiter(c))
- {
- folderIndex = AddFolder(treeFolders, folderIndex, s);
- s.Empty();
- continue;
- }
- s += c;
- }
- if (isAltStream)
- {
- int colonPos = s.Find(':');
- if (colonPos < 0)
- {
- // isAltStream = false;
- return E_INVALIDARG;
- }
- UString mainName = s.Left(colonPos);
- int newFolderIndex = AddFolder(treeFolders, folderIndex, mainName);
- if (treeFolders[newFolderIndex].UpdateItemIndex < 0)
- {
- for (int j = updateItems.Size() - 1; j >= 0; j--)
- {
- CUpdateItem &ui2 = updateItems[j];
- if (ui2.ParentFolderIndex == folderIndex
- && ui2.Name == mainName)
- {
- ui2.TreeFolderIndex = newFolderIndex;
- treeFolders[newFolderIndex].UpdateItemIndex = j;
- }
- }
- }
- folderIndex = newFolderIndex;
- s.Delete(0, colonPos + 1);
- }
- ui.Name = s;
- }
- else
- ui.Name = name;
- ui.IsAltStream = isAltStream;
- ui.ParentFolderIndex = folderIndex;
- ui.TreeFolderIndex = -1;
- if (ui.IsDir && !s.IsEmpty())
- {
- ui.TreeFolderIndex = AddFolder(treeFolders, folderIndex, s);
- treeFolders[ui.TreeFolderIndex].UpdateItemIndex = updateItems.Size();
- }
- }
- */
- ui.Name = name;
-
- if (ui.NewData)
- {
- ui.Size = 0;
- if (!ui.IsDir)
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(i, kpidSize, &prop));
- if (prop.vt != VT_UI8)
- return E_INVALIDARG;
- ui.Size = (UInt64)prop.uhVal.QuadPart;
- if (ui.Size != 0 && ui.IsAnti)
- return E_INVALIDARG;
- }
- }
-
- updateItems.Add(ui);
- }
-
- /*
- FillSortIndex(treeFolders, 0, 0);
- for (i = 0; i < (UInt32)updateItems.Size(); i++)
- {
- CUpdateItem &ui = updateItems[i];
- ui.ParentSortIndex = treeFolders[ui.ParentFolderIndex].SortIndex;
- ui.ParentSortIndexEnd = treeFolders[ui.ParentFolderIndex].SortIndexEnd;
- }
- */
-
- CCompressionMethodMode methodMode, headerMethod;
-
- HRESULT res = SetMainMethod(methodMode
- #ifndef _7ZIP_ST
- , _numThreads
- #endif
- );
- RINOK(res);
-
- RINOK(SetHeaderMethod(headerMethod));
-
- #ifndef _7ZIP_ST
- methodMode.NumThreads = _numThreads;
- methodMode.MultiThreadMixer = _useMultiThreadMixer;
- headerMethod.NumThreads = 1;
- headerMethod.MultiThreadMixer = _useMultiThreadMixer;
- #endif
-
- CMyComPtr<ICryptoGetTextPassword2> getPassword2;
- updateCallback->QueryInterface(IID_ICryptoGetTextPassword2, (void **)&getPassword2);
-
- methodMode.PasswordIsDefined = false;
- methodMode.Password.Empty();
- if (getPassword2)
- {
- CMyComBSTR password;
- Int32 passwordIsDefined;
- RINOK(getPassword2->CryptoGetTextPassword2(&passwordIsDefined, &password));
- methodMode.PasswordIsDefined = IntToBool(passwordIsDefined);
- if (methodMode.PasswordIsDefined && password)
- methodMode.Password = password;
- }
-
- bool compressMainHeader = _compressHeaders; // check it
-
- bool encryptHeaders = false;
-
- #ifndef _NO_CRYPTO
- if (!methodMode.PasswordIsDefined && _passwordIsDefined)
- {
- // if header is compressed, we use that password for updated archive
- methodMode.PasswordIsDefined = true;
- methodMode.Password = _password;
- }
- #endif
-
- if (methodMode.PasswordIsDefined)
- {
- if (_encryptHeadersSpecified)
- encryptHeaders = _encryptHeaders;
- #ifndef _NO_CRYPTO
- else
- encryptHeaders = _passwordIsDefined;
- #endif
- compressMainHeader = true;
- if (encryptHeaders)
- {
- headerMethod.PasswordIsDefined = methodMode.PasswordIsDefined;
- headerMethod.Password = methodMode.Password;
- }
- }
-
- if (numItems < 2)
- compressMainHeader = false;
-
- int level = GetLevel();
-
- CUpdateOptions options;
- options.Method = &methodMode;
- options.HeaderMethod = (_compressHeaders || encryptHeaders) ? &headerMethod : NULL;
- options.UseFilters = (level != 0 && _autoFilter && !methodMode.Filter_was_Inserted);
- options.MaxFilter = (level >= 8);
- options.AnalysisLevel = GetAnalysisLevel();
-
- options.HeaderOptions.CompressMainHeader = compressMainHeader;
- /*
- options.HeaderOptions.WriteCTime = Write_CTime;
- options.HeaderOptions.WriteATime = Write_ATime;
- options.HeaderOptions.WriteMTime = Write_MTime;
- options.HeaderOptions.WriteAttrib = Write_Attrib;
- */
-
- options.NumSolidFiles = _numSolidFiles;
- options.NumSolidBytes = _numSolidBytes;
- options.SolidExtension = _solidExtension;
- options.UseTypeSorting = _useTypeSorting;
-
- options.RemoveSfxBlock = _removeSfxBlock;
- // options.VolumeMode = _volumeMode;
-
- options.MultiThreadMixer = _useMultiThreadMixer;
-
- COutArchive archive;
- CArchiveDatabaseOut newDatabase;
-
- CMyComPtr<ICryptoGetTextPassword> getPassword;
- updateCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getPassword);
-
- /*
- if (secureBlocks.Sorted.Size() > 1)
- {
- secureBlocks.GetReverseMap();
- for (int i = 0; i < updateItems.Size(); i++)
- {
- int &secureIndex = updateItems[i].SecureIndex;
- secureIndex = secureBlocks.BufIndexToSortedIndex[secureIndex];
- }
- }
- */
-
- res = Update(
- EXTERNAL_CODECS_VARS
- #ifdef _7Z_VOL
- volume ? volume->Stream: 0,
- volume ? db : 0,
- #else
- _inStream,
- db,
- #endif
- updateItems,
- // treeFolders,
- // secureBlocks,
- archive, newDatabase, outStream, updateCallback, options
- #ifndef _NO_CRYPTO
- , getPassword
- #endif
- );
-
- RINOK(res);
-
- updateItems.ClearAndFree();
-
- return archive.WriteDatabase(EXTERNAL_CODECS_VARS
- newDatabase, options.HeaderMethod, options.HeaderOptions);
-
- COM_TRY_END
-}
-
-static HRESULT ParseBond(UString &srcString, UInt32 &coder, UInt32 &stream)
-{
- stream = 0;
- {
- unsigned index = ParseStringToUInt32(srcString, coder);
- if (index == 0)
- return E_INVALIDARG;
- srcString.DeleteFrontal(index);
- }
- if (srcString[0] == 's')
- {
- srcString.Delete(0);
- unsigned index = ParseStringToUInt32(srcString, stream);
- if (index == 0)
- return E_INVALIDARG;
- srcString.DeleteFrontal(index);
- }
- return S_OK;
-}
-
-void COutHandler::InitProps7z()
-{
- _removeSfxBlock = false;
- _compressHeaders = true;
- _encryptHeadersSpecified = false;
- _encryptHeaders = false;
- // _useParents = false;
-
- Write_CTime.Init();
- Write_ATime.Init();
- Write_MTime.Init();
- Write_Attrib.Init();
-
- _useMultiThreadMixer = true;
-
- // _volumeMode = false;
-
- InitSolid();
- _useTypeSorting = false;
-}
-
-void COutHandler::InitProps()
-{
- CMultiMethodProps::Init();
- InitProps7z();
-}
-
-
-
-HRESULT COutHandler::SetSolidFromString(const UString &s)
-{
- UString s2 = s;
- s2.MakeLower_Ascii();
- for (unsigned i = 0; i < s2.Len();)
- {
- const wchar_t *start = ((const wchar_t *)s2) + i;
- const wchar_t *end;
- UInt64 v = ConvertStringToUInt64(start, &end);
- if (start == end)
- {
- if (s2[i++] != 'e')
- return E_INVALIDARG;
- _solidExtension = true;
- continue;
- }
- i += (int)(end - start);
- if (i == s2.Len())
- return E_INVALIDARG;
- wchar_t c = s2[i++];
- if (c == 'f')
- {
- if (v < 1)
- v = 1;
- _numSolidFiles = v;
- }
- else
- {
- unsigned numBits;
- switch (c)
- {
- case 'b': numBits = 0; break;
- case 'k': numBits = 10; break;
- case 'm': numBits = 20; break;
- case 'g': numBits = 30; break;
- case 't': numBits = 40; break;
- default: return E_INVALIDARG;
- }
- _numSolidBytes = (v << numBits);
- _numSolidBytesDefined = true;
- /*
- if (_numSolidBytes == 0)
- _numSolidFiles = 1;
- */
- }
- }
- return S_OK;
-}
-
-HRESULT COutHandler::SetSolidFromPROPVARIANT(const PROPVARIANT &value)
-{
- bool isSolid;
- switch (value.vt)
- {
- case VT_EMPTY: isSolid = true; break;
- case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
- case VT_BSTR:
- if (StringToBool(value.bstrVal, isSolid))
- break;
- return SetSolidFromString(value.bstrVal);
- default: return E_INVALIDARG;
- }
- if (isSolid)
- InitSolid();
- else
- _numSolidFiles = 1;
- return S_OK;
-}
-
-static HRESULT PROPVARIANT_to_BoolPair(const PROPVARIANT &prop, CBoolPair &dest)
-{
- RINOK(PROPVARIANT_to_bool(prop, dest.Val));
- dest.Def = true;
- return S_OK;
-}
-
-HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
-{
- UString name = nameSpec;
- name.MakeLower_Ascii();
- if (name.IsEmpty())
- return E_INVALIDARG;
-
- if (name[0] == L's')
- {
- name.Delete(0);
- if (name.IsEmpty())
- return SetSolidFromPROPVARIANT(value);
- if (value.vt != VT_EMPTY)
- return E_INVALIDARG;
- return SetSolidFromString(name);
- }
-
- UInt32 number;
- int index = ParseStringToUInt32(name, number);
- // UString realName = name.Ptr(index);
- if (index == 0)
- {
- if (name.IsEqualTo("rsfx")) return PROPVARIANT_to_bool(value, _removeSfxBlock);
- if (name.IsEqualTo("hc")) return PROPVARIANT_to_bool(value, _compressHeaders);
- // if (name.IsEqualToNoCase(L"HS")) return PROPVARIANT_to_bool(value, _useParents);
-
- if (name.IsEqualTo("hcf"))
- {
- bool compressHeadersFull = true;
- RINOK(PROPVARIANT_to_bool(value, compressHeadersFull));
- return compressHeadersFull ? S_OK: E_INVALIDARG;
- }
-
- if (name.IsEqualTo("he"))
- {
- RINOK(PROPVARIANT_to_bool(value, _encryptHeaders));
- _encryptHeadersSpecified = true;
- return S_OK;
- }
-
- if (name.IsEqualTo("tc")) return PROPVARIANT_to_BoolPair(value, Write_CTime);
- if (name.IsEqualTo("ta")) return PROPVARIANT_to_BoolPair(value, Write_ATime);
- if (name.IsEqualTo("tm")) return PROPVARIANT_to_BoolPair(value, Write_MTime);
-
- if (name.IsEqualTo("tr")) return PROPVARIANT_to_BoolPair(value, Write_Attrib);
-
- if (name.IsEqualTo("mtf")) return PROPVARIANT_to_bool(value, _useMultiThreadMixer);
-
- if (name.IsEqualTo("qs")) return PROPVARIANT_to_bool(value, _useTypeSorting);
-
- // if (name.IsEqualTo("v")) return PROPVARIANT_to_bool(value, _volumeMode);
- }
- return CMultiMethodProps::SetProperty(name, value);
-}
-
-STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
-{
- COM_TRY_BEGIN
- _bonds.Clear();
- InitProps();
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- UString name = names[i];
- name.MakeLower_Ascii();
- if (name.IsEmpty())
- return E_INVALIDARG;
-
- const PROPVARIANT &value = values[i];
-
- if (name[0] == 'b')
- {
- if (value.vt != VT_EMPTY)
- return E_INVALIDARG;
- name.Delete(0);
-
- CBond2 bond;
- RINOK(ParseBond(name, bond.OutCoder, bond.OutStream));
- if (name[0] != ':')
- return E_INVALIDARG;
- name.Delete(0);
- UInt32 inStream = 0;
- RINOK(ParseBond(name, bond.InCoder, inStream));
- if (inStream != 0)
- return E_INVALIDARG;
- if (!name.IsEmpty())
- return E_INVALIDARG;
- _bonds.Add(bond);
- continue;
- }
-
- RINOK(SetProperty(name, value));
- }
-
- unsigned numEmptyMethods = GetNumEmptyMethods();
- if (numEmptyMethods > 0)
- {
- unsigned k;
- for (k = 0; k < _bonds.Size(); k++)
- {
- const CBond2 &bond = _bonds[k];
- if (bond.InCoder < (UInt32)numEmptyMethods ||
- bond.OutCoder < (UInt32)numEmptyMethods)
- return E_INVALIDARG;
- }
- for (k = 0; k < _bonds.Size(); k++)
- {
- CBond2 &bond = _bonds[k];
- bond.InCoder -= (UInt32)numEmptyMethods;
- bond.OutCoder -= (UInt32)numEmptyMethods;
- }
- _methods.DeleteFrontal(numEmptyMethods);
- }
-
- FOR_VECTOR (k, _bonds)
- {
- const CBond2 &bond = _bonds[k];
- if (bond.InCoder >= (UInt32)_methods.Size() ||
- bond.OutCoder >= (UInt32)_methods.Size())
- return E_INVALIDARG;
- }
-
- return S_OK;
- COM_TRY_END
-}
-
-}}
-
-#endif
+// 7zHandlerOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../Common/ItemNameUtils.h"
+#include "../Common/ParseProperties.h"
+
+#include "7zHandler.h"
+#include "7zOut.h"
+#include "7zUpdate.h"
+
+#ifndef Z7_EXTRACT_ONLY
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace N7z {
+
+#define k_LZMA_Name "LZMA"
+#define kDefaultMethodName "LZMA2"
+#define k_Copy_Name "Copy"
+
+#define k_MatchFinder_ForHeaders "BT2"
+
+static const UInt32 k_NumFastBytes_ForHeaders = 273;
+static const UInt32 k_Level_ForHeaders = 5;
+static const UInt32 k_Dictionary_ForHeaders =
+ #ifdef UNDER_CE
+ 1 << 18;
+ #else
+ 1 << 20;
+ #endif
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *type))
+{
+ *type = NFileTimeType::kWindows;
+ return S_OK;
+}
+
+HRESULT CHandler::PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m)
+{
+ bool isFilter;
+ dest.CodecIndex = FindMethod_Index(
+ EXTERNAL_CODECS_VARS
+ m.MethodName, true,
+ dest.Id, dest.NumStreams, isFilter);
+ if (dest.CodecIndex < 0)
+ return E_INVALIDARG;
+ (CProps &)dest = (CProps &)m;
+ return S_OK;
+}
+
+HRESULT CHandler::SetHeaderMethod(CCompressionMethodMode &headerMethod)
+{
+ if (!_compressHeaders)
+ return S_OK;
+ COneMethodInfo m;
+ m.MethodName = k_LZMA_Name;
+ m.AddProp_Ascii(NCoderPropID::kMatchFinder, k_MatchFinder_ForHeaders);
+ m.AddProp_Level(k_Level_ForHeaders);
+ m.AddProp32(NCoderPropID::kNumFastBytes, k_NumFastBytes_ForHeaders);
+ m.AddProp32(NCoderPropID::kDictionarySize, k_Dictionary_ForHeaders);
+ m.AddProp_NumThreads(1);
+
+ CMethodFull &methodFull = headerMethod.Methods.AddNew();
+ return PropsMethod_To_FullMethod(methodFull, m);
+}
+
+
+HRESULT CHandler::SetMainMethod(CCompressionMethodMode &methodMode)
+{
+ methodMode.Bonds = _bonds;
+
+ // we create local copy of _methods. So we can modify it.
+ CObjectVector<COneMethodInfo> methods = _methods;
+
+ {
+ FOR_VECTOR (i, methods)
+ {
+ AString &methodName = methods[i].MethodName;
+ if (methodName.IsEmpty())
+ methodName = kDefaultMethodName;
+ }
+ if (methods.IsEmpty())
+ {
+ COneMethodInfo &m = methods.AddNew();
+ m.MethodName = (GetLevel() == 0 ? k_Copy_Name : kDefaultMethodName);
+ methodMode.DefaultMethod_was_Inserted = true;
+ }
+ }
+
+ if (!_filterMethod.MethodName.IsEmpty())
+ {
+ // if (methodMode.Bonds.IsEmpty())
+ {
+ FOR_VECTOR (k, methodMode.Bonds)
+ {
+ CBond2 &bond = methodMode.Bonds[k];
+ bond.InCoder++;
+ bond.OutCoder++;
+ }
+ methods.Insert(0, _filterMethod);
+ methodMode.Filter_was_Inserted = true;
+ }
+ }
+
+ const UInt64 kSolidBytes_Min = (1 << 24);
+ const UInt64 kSolidBytes_Max = ((UInt64)1 << 32);
+
+ bool needSolid = false;
+
+ FOR_VECTOR (i, methods)
+ {
+ COneMethodInfo &oneMethodInfo = methods[i];
+
+ SetGlobalLevelTo(oneMethodInfo);
+
+ #ifndef Z7_ST
+ const bool numThreads_WasSpecifiedInMethod = (oneMethodInfo.Get_NumThreads() >= 0);
+ if (!numThreads_WasSpecifiedInMethod)
+ {
+ // here we set the (NCoderPropID::kNumThreads) property in each method, only if there is no such property already
+ CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, methodMode.NumThreads);
+ }
+ #endif
+
+ CMethodFull &methodFull = methodMode.Methods.AddNew();
+ RINOK(PropsMethod_To_FullMethod(methodFull, oneMethodInfo))
+
+ #ifndef Z7_ST
+ methodFull.Set_NumThreads = true;
+ methodFull.NumThreads = methodMode.NumThreads;
+ #endif
+
+ if (methodFull.Id != k_Copy)
+ needSolid = true;
+
+ UInt64 dicSize;
+ switch (methodFull.Id)
+ {
+ case k_LZMA:
+ case k_LZMA2: dicSize = oneMethodInfo.Get_Lzma_DicSize(); break;
+ case k_PPMD: dicSize = oneMethodInfo.Get_Ppmd_MemSize(); break;
+ case k_Deflate: dicSize = (UInt32)1 << 15; break;
+ case k_Deflate64: dicSize = (UInt32)1 << 16; break;
+ case k_BZip2: dicSize = oneMethodInfo.Get_BZip2_BlockSize(); break;
+ // case k_ZSTD: dicSize = 1 << 23; break;
+ default: continue;
+ }
+
+ UInt64 numSolidBytes;
+
+ /*
+ if (methodFull.Id == k_ZSTD)
+ {
+ // continue;
+ NCompress::NZstd::CEncoderProps encoderProps;
+ RINOK(oneMethodInfo.Set_PropsTo_zstd(encoderProps));
+ CZstdEncProps &zstdProps = encoderProps.EncProps;
+ ZstdEncProps_NormalizeFull(&zstdProps);
+ UInt64 cs = (UInt64)(zstdProps.jobSize);
+ UInt32 winSize = (UInt32)(1 << zstdProps.windowLog);
+ if (cs < winSize)
+ cs = winSize;
+ numSolidBytes = cs << 6;
+ const UInt64 kSolidBytes_Zstd_Max = ((UInt64)1 << 34);
+ if (numSolidBytes > kSolidBytes_Zstd_Max)
+ numSolidBytes = kSolidBytes_Zstd_Max;
+
+ methodFull.Set_NumThreads = false; // we don't use ICompressSetCoderMt::SetNumberOfThreads() for LZMA2 encoder
+
+ #ifndef Z7_ST
+ if (!numThreads_WasSpecifiedInMethod
+ && !methodMode.NumThreads_WasForced
+ && methodMode.MemoryUsageLimit_WasSet
+ )
+ {
+ const UInt32 numThreads_Original = methodMode.NumThreads;
+ const UInt32 numThreads_New = ZstdEncProps_GetNumThreads_for_MemUsageLimit(
+ &zstdProps,
+ methodMode.MemoryUsageLimit,
+ numThreads_Original);
+ if (numThreads_Original != numThreads_New)
+ {
+ CMultiMethodProps::SetMethodThreadsTo_Replace(methodFull, numThreads_New);
+ }
+ }
+ #endif
+ }
+ else
+ */
+ if (methodFull.Id == k_LZMA2)
+ {
+ // he we calculate default chunk Size for LZMA2 as defined in LZMA2 encoder code
+ /* lzma2 code use dictionary up to fake 4 GiB to calculate ChunkSize.
+ So we do same */
+ UInt64 cs = (UInt64)dicSize << 2;
+ const UInt32 kMinSize = (UInt32)1 << 20;
+ const UInt32 kMaxSize = (UInt32)1 << 28;
+ if (cs < kMinSize) cs = kMinSize;
+ if (cs > kMaxSize) cs = kMaxSize;
+ if (cs < dicSize) cs = dicSize;
+ cs += (kMinSize - 1);
+ cs &= ~(UInt64)(kMinSize - 1);
+ // we want to use at least 64 chunks (threads) per one solid block.
+
+ // here we don't use chunkSize property
+ numSolidBytes = cs << 6;
+
+ // here we get real chunkSize
+ cs = oneMethodInfo.Get_Xz_BlockSize();
+ if (dicSize > cs)
+ dicSize = cs;
+
+ const UInt64 kSolidBytes_Lzma2_Max = ((UInt64)1 << 34);
+ if (numSolidBytes > kSolidBytes_Lzma2_Max)
+ numSolidBytes = kSolidBytes_Lzma2_Max;
+
+ methodFull.Set_NumThreads = false; // we don't use ICompressSetCoderMt::SetNumberOfThreads() for LZMA2 encoder
+
+ #ifndef Z7_ST
+ if (!numThreads_WasSpecifiedInMethod
+ && !methodMode.NumThreads_WasForced
+ && methodMode.MemoryUsageLimit_WasSet
+ )
+ {
+ const UInt32 lzmaThreads = oneMethodInfo.Get_Lzma_NumThreads();
+ const UInt32 numBlockThreads_Original = methodMode.NumThreads / lzmaThreads;
+
+ if (numBlockThreads_Original > 1)
+ {
+ /*
+ const UInt32 kNumThreads_Max = 1024;
+ if (numBlockThreads > kNumMaxThreads)
+ numBlockThreads = kNumMaxThreads;
+ */
+
+ UInt32 numBlockThreads = numBlockThreads_Original;
+ const UInt64 lzmaMemUsage = oneMethodInfo.Get_Lzma_MemUsage(false); // solid
+
+ for (; numBlockThreads > 1; numBlockThreads--)
+ {
+ UInt64 size = numBlockThreads * (lzmaMemUsage + cs);
+ UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
+ if (cs < ((UInt32)1 << 26)) numPackChunks++;
+ if (cs < ((UInt32)1 << 24)) numPackChunks++;
+ if (cs < ((UInt32)1 << 22)) numPackChunks++;
+ size += numPackChunks * cs;
+ // printf("\nnumBlockThreads = %d, size = %d\n", (unsigned)(numBlockThreads), (unsigned)(size >> 20));
+ if (size <= methodMode.MemoryUsageLimit)
+ break;
+ }
+
+ if (numBlockThreads == 0)
+ numBlockThreads = 1;
+ if (numBlockThreads != numBlockThreads_Original)
+ {
+ const UInt32 numThreads_New = numBlockThreads * lzmaThreads;
+ CMultiMethodProps::SetMethodThreadsTo_Replace(methodFull, numThreads_New);
+ }
+ }
+ }
+ #endif
+ }
+ else
+ {
+ numSolidBytes = (UInt64)dicSize << 7;
+ if (numSolidBytes > kSolidBytes_Max)
+ numSolidBytes = kSolidBytes_Max;
+ }
+
+ if (_numSolidBytesDefined)
+ continue;
+
+ if (numSolidBytes < kSolidBytes_Min)
+ numSolidBytes = kSolidBytes_Min;
+ _numSolidBytes = numSolidBytes;
+ _numSolidBytesDefined = true;
+ }
+
+ if (!_numSolidBytesDefined)
+ {
+ if (needSolid)
+ _numSolidBytes = kSolidBytes_Max;
+ else
+ _numSolidBytes = 0;
+ }
+ _numSolidBytesDefined = true;
+
+
+ return S_OK;
+}
+
+
+
+static HRESULT GetTime(IArchiveUpdateCallback *updateCallback, unsigned index, PROPID propID, UInt64 &ft, bool &ftDefined)
+{
+ // ft = 0;
+ // ftDefined = false;
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ {
+ ft = prop.filetime.dwLowDateTime | ((UInt64)prop.filetime.dwHighDateTime << 32);
+ ftDefined = true;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ else
+ {
+ ft = 0;
+ ftDefined = false;
+ }
+ return S_OK;
+}
+
+/*
+
+#ifdef _WIN32
+static const wchar_t kDirDelimiter1 = L'\\';
+#endif
+static const wchar_t kDirDelimiter2 = L'/';
+
+static inline bool IsCharDirLimiter(wchar_t c)
+{
+ return (
+ #ifdef _WIN32
+ c == kDirDelimiter1 ||
+ #endif
+ c == kDirDelimiter2);
+}
+
+static int FillSortIndex(CObjectVector<CTreeFolder> &treeFolders, int cur, int curSortIndex)
+{
+ CTreeFolder &tf = treeFolders[cur];
+ tf.SortIndex = curSortIndex++;
+ for (int i = 0; i < tf.SubFolders.Size(); i++)
+ curSortIndex = FillSortIndex(treeFolders, tf.SubFolders[i], curSortIndex);
+ tf.SortIndexEnd = curSortIndex;
+ return curSortIndex;
+}
+
+static int FindSubFolder(const CObjectVector<CTreeFolder> &treeFolders, int cur, const UString &name, int &insertPos)
+{
+ const CIntVector &subFolders = treeFolders[cur].SubFolders;
+ int left = 0, right = subFolders.Size();
+ insertPos = -1;
+ for (;;)
+ {
+ if (left == right)
+ {
+ insertPos = left;
+ return -1;
+ }
+ int mid = (left + right) / 2;
+ int midFolder = subFolders[mid];
+ int compare = CompareFileNames(name, treeFolders[midFolder].Name);
+ if (compare == 0)
+ return midFolder;
+ if (compare < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+}
+
+static int AddFolder(CObjectVector<CTreeFolder> &treeFolders, int cur, const UString &name)
+{
+ int insertPos;
+ int folderIndex = FindSubFolder(treeFolders, cur, name, insertPos);
+ if (folderIndex < 0)
+ {
+ folderIndex = treeFolders.Size();
+ CTreeFolder &newFolder = treeFolders.AddNew();
+ newFolder.Parent = cur;
+ newFolder.Name = name;
+ treeFolders[cur].SubFolders.Insert(insertPos, folderIndex);
+ }
+ // else if (treeFolders[folderIndex].IsAltStreamFolder != isAltStreamFolder) throw 1123234234;
+ return folderIndex;
+}
+*/
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *updateCallback))
+{
+ COM_TRY_BEGIN
+
+ const CDbEx *db = NULL;
+ #ifdef Z7_7Z_VOL
+ if (_volumes.Size() > 1)
+ return E_FAIL;
+ const CVolume *volume = 0;
+ if (_volumes.Size() == 1)
+ {
+ volume = &_volumes.Front();
+ db = &volume->Database;
+ }
+ #else
+ if (_inStream)
+ db = &_db;
+ #endif
+
+ if (db && !db->CanUpdate())
+ return E_NOTIMPL;
+
+ /*
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveGetRawProps,
+ getRawProps, updateCallback)
+
+ CUniqBlocks secureBlocks;
+ secureBlocks.AddUniq(NULL, 0);
+
+ CObjectVector<CTreeFolder> treeFolders;
+ {
+ CTreeFolder folder;
+ folder.Parent = -1;
+ treeFolders.Add(folder);
+ }
+ */
+
+ CObjectVector<CUpdateItem> updateItems;
+
+ bool need_CTime = (TimeOptions.Write_CTime.Def && TimeOptions.Write_CTime.Val);
+ bool need_ATime = (TimeOptions.Write_ATime.Def && TimeOptions.Write_ATime.Val);
+ bool need_MTime = (TimeOptions.Write_MTime.Def ? TimeOptions.Write_MTime.Val : true);
+ bool need_Attrib = (Write_Attrib.Def ? Write_Attrib.Val : true);
+
+ if (db && !db->Files.IsEmpty())
+ {
+ if (!TimeOptions.Write_CTime.Def) need_CTime = !db->CTime.Defs.IsEmpty();
+ if (!TimeOptions.Write_ATime.Def) need_ATime = !db->ATime.Defs.IsEmpty();
+ if (!TimeOptions.Write_MTime.Def) need_MTime = !db->MTime.Defs.IsEmpty();
+ if (!Write_Attrib.Def) need_Attrib = !db->Attrib.Defs.IsEmpty();
+ }
+
+ // UString s;
+ UString name;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ Int32 newData, newProps;
+ UInt32 indexInArchive;
+ if (!updateCallback)
+ return E_FAIL;
+ RINOK(updateCallback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive))
+ CUpdateItem ui;
+ ui.NewProps = IntToBool(newProps);
+ ui.NewData = IntToBool(newData);
+ ui.IndexInArchive = (int)indexInArchive;
+ ui.IndexInClient = i;
+ ui.IsAnti = false;
+ ui.Size = 0;
+
+ name.Empty();
+ // bool isAltStream = false;
+ if (ui.IndexInArchive != -1)
+ {
+ if (!db || (unsigned)ui.IndexInArchive >= db->Files.Size())
+ return E_INVALIDARG;
+ const CFileItem &fi = db->Files[(unsigned)ui.IndexInArchive];
+ if (!ui.NewProps)
+ {
+ _db.GetPath((unsigned)ui.IndexInArchive, name);
+ }
+ ui.IsDir = fi.IsDir;
+ ui.Size = fi.Size;
+ // isAltStream = fi.IsAltStream;
+ ui.IsAnti = db->IsItemAnti((unsigned)ui.IndexInArchive);
+
+ if (!ui.NewProps)
+ {
+ ui.CTimeDefined = db->CTime.GetItem((unsigned)ui.IndexInArchive, ui.CTime);
+ ui.ATimeDefined = db->ATime.GetItem((unsigned)ui.IndexInArchive, ui.ATime);
+ ui.MTimeDefined = db->MTime.GetItem((unsigned)ui.IndexInArchive, ui.MTime);
+ }
+ }
+
+ if (ui.NewProps)
+ {
+ bool folderStatusIsDefined;
+ if (need_Attrib)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(i, kpidAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.AttribDefined = false;
+ else if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ else
+ {
+ ui.Attrib = prop.ulVal;
+ ui.AttribDefined = true;
+ }
+ }
+
+ // we need MTime to sort files.
+ if (need_CTime) RINOK(GetTime(updateCallback, i, kpidCTime, ui.CTime, ui.CTimeDefined))
+ if (need_ATime) RINOK(GetTime(updateCallback, i, kpidATime, ui.ATime, ui.ATimeDefined))
+ if (need_MTime) RINOK(GetTime(updateCallback, i, kpidMTime, ui.MTime, ui.MTimeDefined))
+
+ /*
+ if (getRawProps)
+ {
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+
+ getRawProps->GetRawProp(i, kpidNtSecure, &data, &dataSize, &propType);
+ if (dataSize != 0 && propType != NPropDataType::kRaw)
+ return E_FAIL;
+ ui.SecureIndex = secureBlocks.AddUniq((const Byte *)data, dataSize);
+ }
+ */
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(i, kpidPath, &prop))
+ if (prop.vt == VT_EMPTY)
+ {
+ }
+ else if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ else
+ {
+ name = prop.bstrVal;
+ NItemName::ReplaceSlashes_OsToUnix(name);
+ }
+ }
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(i, kpidIsDir, &prop))
+ if (prop.vt == VT_EMPTY)
+ folderStatusIsDefined = false;
+ else if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ else
+ {
+ ui.IsDir = (prop.boolVal != VARIANT_FALSE);
+ folderStatusIsDefined = true;
+ }
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(i, kpidIsAnti, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.IsAnti = false;
+ else if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ else
+ ui.IsAnti = (prop.boolVal != VARIANT_FALSE);
+ }
+
+ /*
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(i, kpidIsAltStream, &prop));
+ if (prop.vt == VT_EMPTY)
+ isAltStream = false;
+ else if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ else
+ isAltStream = (prop.boolVal != VARIANT_FALSE);
+ }
+ */
+
+ if (ui.IsAnti)
+ {
+ ui.AttribDefined = false;
+
+ ui.CTimeDefined = false;
+ ui.ATimeDefined = false;
+ ui.MTimeDefined = false;
+
+ ui.Size = 0;
+ }
+
+ if (!folderStatusIsDefined && ui.AttribDefined)
+ ui.SetDirStatusFromAttrib();
+ }
+ else
+ {
+ /*
+ if (_db.SecureIDs.IsEmpty())
+ ui.SecureIndex = secureBlocks.AddUniq(NULL, 0);
+ else
+ {
+ int id = _db.SecureIDs[ui.IndexInArchive];
+ size_t offs = _db.SecureOffsets[id];
+ size_t size = _db.SecureOffsets[id + 1] - offs;
+ ui.SecureIndex = secureBlocks.AddUniq(_db.SecureBuf + offs, size);
+ }
+ */
+ }
+
+ /*
+ {
+ int folderIndex = 0;
+ if (_useParents)
+ {
+ int j;
+ s.Empty();
+ for (j = 0; j < name.Len(); j++)
+ {
+ wchar_t c = name[j];
+ if (IsCharDirLimiter(c))
+ {
+ folderIndex = AddFolder(treeFolders, folderIndex, s);
+ s.Empty();
+ continue;
+ }
+ s += c;
+ }
+ if (isAltStream)
+ {
+ int colonPos = s.Find(':');
+ if (colonPos < 0)
+ {
+ // isAltStream = false;
+ return E_INVALIDARG;
+ }
+ UString mainName = s.Left(colonPos);
+ int newFolderIndex = AddFolder(treeFolders, folderIndex, mainName);
+ if (treeFolders[newFolderIndex].UpdateItemIndex < 0)
+ {
+ for (int j = updateItems.Size() - 1; j >= 0; j--)
+ {
+ CUpdateItem &ui2 = updateItems[j];
+ if (ui2.ParentFolderIndex == folderIndex
+ && ui2.Name == mainName)
+ {
+ ui2.TreeFolderIndex = newFolderIndex;
+ treeFolders[newFolderIndex].UpdateItemIndex = j;
+ }
+ }
+ }
+ folderIndex = newFolderIndex;
+ s.Delete(0, colonPos + 1);
+ }
+ ui.Name = s;
+ }
+ else
+ ui.Name = name;
+ ui.IsAltStream = isAltStream;
+ ui.ParentFolderIndex = folderIndex;
+ ui.TreeFolderIndex = -1;
+ if (ui.IsDir && !s.IsEmpty())
+ {
+ ui.TreeFolderIndex = AddFolder(treeFolders, folderIndex, s);
+ treeFolders[ui.TreeFolderIndex].UpdateItemIndex = updateItems.Size();
+ }
+ }
+ */
+ ui.Name = name;
+
+ if (ui.NewData)
+ {
+ ui.Size = 0;
+ if (!ui.IsDir)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(i, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ ui.Size = (UInt64)prop.uhVal.QuadPart;
+ if (ui.Size != 0 && ui.IsAnti)
+ return E_INVALIDARG;
+ }
+ }
+
+ updateItems.Add(ui);
+ }
+
+ /*
+ FillSortIndex(treeFolders, 0, 0);
+ for (i = 0; i < (UInt32)updateItems.Size(); i++)
+ {
+ CUpdateItem &ui = updateItems[i];
+ ui.ParentSortIndex = treeFolders[ui.ParentFolderIndex].SortIndex;
+ ui.ParentSortIndexEnd = treeFolders[ui.ParentFolderIndex].SortIndexEnd;
+ }
+ */
+
+ CCompressionMethodMode methodMode, headerMethod;
+
+ methodMode.MemoryUsageLimit = _memUsage_Compress;
+ methodMode.MemoryUsageLimit_WasSet = _memUsage_WasSet;
+
+ #ifndef Z7_ST
+ {
+ UInt32 numThreads = _numThreads;
+ const UInt32 kNumThreads_Max = 1024;
+ if (numThreads > kNumThreads_Max)
+ numThreads = kNumThreads_Max;
+ methodMode.NumThreads = numThreads;
+ methodMode.NumThreads_WasForced = _numThreads_WasForced;
+ methodMode.MultiThreadMixer = _useMultiThreadMixer;
+ // headerMethod.NumThreads = 1;
+ headerMethod.MultiThreadMixer = _useMultiThreadMixer;
+ }
+ #endif
+
+ const HRESULT res = SetMainMethod(methodMode);
+ RINOK(res)
+
+ RINOK(SetHeaderMethod(headerMethod))
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICryptoGetTextPassword2,
+ getPassword2, updateCallback)
+
+ methodMode.PasswordIsDefined = false;
+ methodMode.Password.Wipe_and_Empty();
+ if (getPassword2)
+ {
+ CMyComBSTR_Wipe password;
+ Int32 passwordIsDefined;
+ RINOK(getPassword2->CryptoGetTextPassword2(&passwordIsDefined, &password))
+ methodMode.PasswordIsDefined = IntToBool(passwordIsDefined);
+ if (methodMode.PasswordIsDefined && password)
+ methodMode.Password = password;
+ }
+
+ bool compressMainHeader = _compressHeaders; // check it
+
+ bool encryptHeaders = false;
+
+ #ifndef Z7_NO_CRYPTO
+ if (!methodMode.PasswordIsDefined && _passwordIsDefined)
+ {
+ // if header is compressed, we use that password for updated archive
+ methodMode.PasswordIsDefined = true;
+ methodMode.Password = _password;
+ }
+ #endif
+
+ if (methodMode.PasswordIsDefined)
+ {
+ if (_encryptHeadersSpecified)
+ encryptHeaders = _encryptHeaders;
+ #ifndef Z7_NO_CRYPTO
+ else
+ encryptHeaders = _passwordIsDefined;
+ #endif
+ compressMainHeader = true;
+ if (encryptHeaders)
+ {
+ headerMethod.PasswordIsDefined = methodMode.PasswordIsDefined;
+ headerMethod.Password = methodMode.Password;
+ }
+ }
+
+ if (numItems < 2)
+ compressMainHeader = false;
+
+ const int level = GetLevel();
+
+ CUpdateOptions options;
+ options.Need_CTime = need_CTime;
+ options.Need_ATime = need_ATime;
+ options.Need_MTime = need_MTime;
+ options.Need_Attrib = need_Attrib;
+ // options.Need_Crc = (_crcSize != 0); // for debug
+
+ options.Method = &methodMode;
+ options.HeaderMethod = (_compressHeaders || encryptHeaders) ? &headerMethod : NULL;
+ options.UseFilters = (level != 0 && _autoFilter && !methodMode.Filter_was_Inserted);
+ options.MaxFilter = (level >= 8);
+ options.AnalysisLevel = GetAnalysisLevel();
+
+ options.HeaderOptions.CompressMainHeader = compressMainHeader;
+ /*
+ options.HeaderOptions.WriteCTime = Write_CTime;
+ options.HeaderOptions.WriteATime = Write_ATime;
+ options.HeaderOptions.WriteMTime = Write_MTime;
+ options.HeaderOptions.WriteAttrib = Write_Attrib;
+ */
+
+ options.NumSolidFiles = _numSolidFiles;
+ options.NumSolidBytes = _numSolidBytes;
+ options.SolidExtension = _solidExtension;
+ options.UseTypeSorting = _useTypeSorting;
+
+ options.RemoveSfxBlock = _removeSfxBlock;
+ // options.VolumeMode = _volumeMode;
+
+ options.MultiThreadMixer = _useMultiThreadMixer;
+
+ /*
+ if (secureBlocks.Sorted.Size() > 1)
+ {
+ secureBlocks.GetReverseMap();
+ for (int i = 0; i < updateItems.Size(); i++)
+ {
+ int &secureIndex = updateItems[i].SecureIndex;
+ secureIndex = secureBlocks.BufIndexToSortedIndex[secureIndex];
+ }
+ }
+ */
+
+ return Update(
+ EXTERNAL_CODECS_VARS
+ #ifdef Z7_7Z_VOL
+ volume ? volume->Stream: 0,
+ volume ? db : 0,
+ #else
+ _inStream,
+ db,
+ #endif
+ updateItems,
+ // treeFolders,
+ // secureBlocks,
+ outStream, updateCallback, options);
+
+ COM_TRY_END
+}
+
+static HRESULT ParseBond(UString &srcString, UInt32 &coder, UInt32 &stream)
+{
+ stream = 0;
+ {
+ const unsigned index = ParseStringToUInt32(srcString, coder);
+ if (index == 0)
+ return E_INVALIDARG;
+ srcString.DeleteFrontal(index);
+ }
+ if (srcString[0] == 's')
+ {
+ srcString.Delete(0);
+ const unsigned index = ParseStringToUInt32(srcString, stream);
+ if (index == 0)
+ return E_INVALIDARG;
+ srcString.DeleteFrontal(index);
+ }
+ return S_OK;
+}
+
+void COutHandler::InitProps7z()
+{
+ _removeSfxBlock = false;
+ _compressHeaders = true;
+ _encryptHeadersSpecified = false;
+ _encryptHeaders = false;
+ // _useParents = false;
+
+ TimeOptions.Init();
+ Write_Attrib.Init();
+
+ _useMultiThreadMixer = true;
+
+ // _volumeMode = false;
+
+ InitSolid();
+ _useTypeSorting = false;
+}
+
+void COutHandler::InitProps()
+{
+ CMultiMethodProps::Init();
+ InitProps7z();
+}
+
+
+
+HRESULT COutHandler::SetSolidFromString(const UString &s)
+{
+ UString s2 = s;
+ s2.MakeLower_Ascii();
+ for (unsigned i = 0; i < s2.Len();)
+ {
+ const wchar_t *start = ((const wchar_t *)s2) + i;
+ const wchar_t *end;
+ UInt64 v = ConvertStringToUInt64(start, &end);
+ if (start == end)
+ {
+ if (s2[i++] != 'e')
+ return E_INVALIDARG;
+ _solidExtension = true;
+ continue;
+ }
+ i += (unsigned)(end - start);
+ if (i == s2.Len())
+ return E_INVALIDARG;
+ const wchar_t c = s2[i++];
+ if (c == 'f')
+ {
+ if (v < 1)
+ v = 1;
+ _numSolidFiles = v;
+ }
+ else
+ {
+ unsigned numBits;
+ switch (c)
+ {
+ case 'b': numBits = 0; break;
+ case 'k': numBits = 10; break;
+ case 'm': numBits = 20; break;
+ case 'g': numBits = 30; break;
+ case 't': numBits = 40; break;
+ default: return E_INVALIDARG;
+ }
+ _numSolidBytes = (v << numBits);
+ _numSolidBytesDefined = true;
+ /*
+ if (_numSolidBytes == 0)
+ _numSolidFiles = 1;
+ */
+ }
+ }
+ return S_OK;
+}
+
+HRESULT COutHandler::SetSolidFromPROPVARIANT(const PROPVARIANT &value)
+{
+ bool isSolid;
+ switch (value.vt)
+ {
+ case VT_EMPTY: isSolid = true; break;
+ case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
+ case VT_BSTR:
+ if (StringToBool(value.bstrVal, isSolid))
+ break;
+ return SetSolidFromString(value.bstrVal);
+ default: return E_INVALIDARG;
+ }
+ if (isSolid)
+ InitSolid();
+ else
+ _numSolidFiles = 1;
+ return S_OK;
+}
+
+static HRESULT PROPVARIANT_to_BoolPair(const PROPVARIANT &prop, CBoolPair &dest)
+{
+ RINOK(PROPVARIANT_to_bool(prop, dest.Val))
+ dest.Def = true;
+ return S_OK;
+}
+
+HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
+{
+ UString name = nameSpec;
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ if (name[0] == L's')
+ {
+ name.Delete(0);
+ if (name.IsEmpty())
+ return SetSolidFromPROPVARIANT(value);
+ if (value.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ return SetSolidFromString(name);
+ }
+
+ UInt32 number;
+ const unsigned index = ParseStringToUInt32(name, number);
+ // UString realName = name.Ptr(index);
+ if (index == 0)
+ {
+ if (name.IsEqualTo("rsfx")) return PROPVARIANT_to_bool(value, _removeSfxBlock);
+ if (name.IsEqualTo("hc")) return PROPVARIANT_to_bool(value, _compressHeaders);
+ // if (name.IsEqualToNoCase(L"HS")) return PROPVARIANT_to_bool(value, _useParents);
+
+ if (name.IsEqualTo("hcf"))
+ {
+ bool compressHeadersFull = true;
+ RINOK(PROPVARIANT_to_bool(value, compressHeadersFull))
+ return compressHeadersFull ? S_OK: E_INVALIDARG;
+ }
+
+ if (name.IsEqualTo("he"))
+ {
+ RINOK(PROPVARIANT_to_bool(value, _encryptHeaders))
+ _encryptHeadersSpecified = true;
+ return S_OK;
+ }
+
+ {
+ bool processed;
+ RINOK(TimeOptions.Parse(name, value, processed))
+ if (processed)
+ {
+ if ( TimeOptions.Prec != (UInt32)(Int32)-1
+ && TimeOptions.Prec != k_PropVar_TimePrec_0
+ && TimeOptions.Prec != k_PropVar_TimePrec_HighPrec
+ && TimeOptions.Prec != k_PropVar_TimePrec_100ns)
+ return E_INVALIDARG;
+ return S_OK;
+ }
+ }
+
+ if (name.IsEqualTo("tr")) return PROPVARIANT_to_BoolPair(value, Write_Attrib);
+
+ if (name.IsEqualTo("mtf")) return PROPVARIANT_to_bool(value, _useMultiThreadMixer);
+
+ if (name.IsEqualTo("qs")) return PROPVARIANT_to_bool(value, _useTypeSorting);
+
+ // if (name.IsEqualTo("v")) return PROPVARIANT_to_bool(value, _volumeMode);
+ }
+ return CMultiMethodProps::SetProperty(name, value);
+}
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ COM_TRY_BEGIN
+ _bonds.Clear();
+ InitProps();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ UString name = names[i];
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ const PROPVARIANT &value = values[i];
+
+ if (name.Find(L':') >= 0) // 'b' was used as NCoderPropID::kBlockSize2 before v23
+ if (name[0] == 'b')
+ {
+ if (value.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ name.Delete(0);
+
+ CBond2 bond;
+ RINOK(ParseBond(name, bond.OutCoder, bond.OutStream))
+ if (name[0] != ':')
+ return E_INVALIDARG;
+ name.Delete(0);
+ UInt32 inStream = 0;
+ RINOK(ParseBond(name, bond.InCoder, inStream))
+ if (inStream != 0)
+ return E_INVALIDARG;
+ if (!name.IsEmpty())
+ return E_INVALIDARG;
+ _bonds.Add(bond);
+ continue;
+ }
+
+ RINOK(SetProperty(name, value))
+ }
+
+ unsigned numEmptyMethods = GetNumEmptyMethods();
+ if (numEmptyMethods > 0)
+ {
+ unsigned k;
+ for (k = 0; k < _bonds.Size(); k++)
+ {
+ const CBond2 &bond = _bonds[k];
+ if (bond.InCoder < (UInt32)numEmptyMethods ||
+ bond.OutCoder < (UInt32)numEmptyMethods)
+ return E_INVALIDARG;
+ }
+ for (k = 0; k < _bonds.Size(); k++)
+ {
+ CBond2 &bond = _bonds[k];
+ bond.InCoder -= (UInt32)numEmptyMethods;
+ bond.OutCoder -= (UInt32)numEmptyMethods;
+ }
+ _methods.DeleteFrontal(numEmptyMethods);
+ }
+
+ FOR_VECTOR (k, _bonds)
+ {
+ const CBond2 &bond = _bonds[k];
+ if (bond.InCoder >= (UInt32)_methods.Size() ||
+ bond.OutCoder >= (UInt32)_methods.Size())
+ return E_INVALIDARG;
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zHeader.cpp b/CPP/7zip/Archive/7z/7zHeader.cpp
index de39909..d5f9497 100644
--- a/CPP/7zip/Archive/7z/7zHeader.cpp
+++ b/CPP/7zip/Archive/7z/7zHeader.cpp
@@ -1,19 +1,19 @@
-// 7zHeader.cpp
-
-#include "StdAfx.h"
-
-#include "7zHeader.h"
-
-namespace NArchive {
-namespace N7z {
-
-Byte kSignature[kSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
-#ifdef _7Z_VOL
-Byte kFinishSignature[kSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C + 1};
-#endif
-
-// We can change signature. So file doesn't contain correct signature.
-// struct SignatureInitializer { SignatureInitializer() { kSignature[0]--; } };
-// static SignatureInitializer g_SignatureInitializer;
-
-}}
+// 7zHeader.cpp
+
+#include "StdAfx.h"
+
+#include "7zHeader.h"
+
+namespace NArchive {
+namespace N7z {
+
+Byte kSignature[kSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
+#ifdef Z7_7Z_VOL
+Byte kFinishSignature[kSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C + 1};
+#endif
+
+// We can change signature. So file doesn't contain correct signature.
+// struct SignatureInitializer { SignatureInitializer() { kSignature[0]--; } };
+// static SignatureInitializer g_SignatureInitializer;
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zHeader.h b/CPP/7zip/Archive/7z/7zHeader.h
index 7de6eee..bd96ca3 100644
--- a/CPP/7zip/Archive/7z/7zHeader.h
+++ b/CPP/7zip/Archive/7z/7zHeader.h
@@ -1,148 +1,153 @@
-// 7z/7zHeader.h
-
-#ifndef __7Z_HEADER_H
-#define __7Z_HEADER_H
-
-#include "../../../Common/MyTypes.h"
-
-namespace NArchive {
-namespace N7z {
-
-const unsigned kSignatureSize = 6;
-extern Byte kSignature[kSignatureSize];
-
-// #define _7Z_VOL
-// 7z-MultiVolume is not finished yet.
-// It can work already, but I still do not like some
-// things of that new multivolume format.
-// So please keep it commented.
-
-#ifdef _7Z_VOL
-extern Byte kFinishSignature[kSignatureSize];
-#endif
-
-struct CArchiveVersion
-{
- Byte Major;
- Byte Minor;
-};
-
-const Byte kMajorVersion = 0;
-
-struct CStartHeader
-{
- UInt64 NextHeaderOffset;
- UInt64 NextHeaderSize;
- UInt32 NextHeaderCRC;
-};
-
-const UInt32 kStartHeaderSize = 20;
-
-#ifdef _7Z_VOL
-struct CFinishHeader: public CStartHeader
-{
- UInt64 ArchiveStartOffset; // data offset from end if that struct
- UInt64 AdditionalStartBlockSize; // start signature & start header size
-};
-
-const UInt32 kFinishHeaderSize = kStartHeaderSize + 16;
-#endif
-
-namespace NID
-{
- enum EEnum
- {
- kEnd,
-
- kHeader,
-
- kArchiveProperties,
-
- kAdditionalStreamsInfo,
- kMainStreamsInfo,
- kFilesInfo,
-
- kPackInfo,
- kUnpackInfo,
- kSubStreamsInfo,
-
- kSize,
- kCRC,
-
- kFolder,
-
- kCodersUnpackSize,
- kNumUnpackStream,
-
- kEmptyStream,
- kEmptyFile,
- kAnti,
-
- kName,
- kCTime,
- kATime,
- kMTime,
- kWinAttrib,
- kComment,
-
- kEncodedHeader,
-
- kStartPos,
- kDummy
-
- // kNtSecure,
- // kParent,
- // kIsAux
- };
-}
-
-
-const UInt32 k_Copy = 0;
-const UInt32 k_Delta = 3;
-
-const UInt32 k_LZMA2 = 0x21;
-
-const UInt32 k_SWAP2 = 0x20302;
-const UInt32 k_SWAP4 = 0x20304;
-
-const UInt32 k_LZMA = 0x30101;
-const UInt32 k_PPMD = 0x30401;
-
-const UInt32 k_Deflate = 0x40108;
-const UInt32 k_BZip2 = 0x40202;
-
-const UInt32 k_BCJ = 0x3030103;
-const UInt32 k_BCJ2 = 0x303011B;
-const UInt32 k_PPC = 0x3030205;
-const UInt32 k_IA64 = 0x3030401;
-const UInt32 k_ARM = 0x3030501;
-const UInt32 k_ARMT = 0x3030701;
-const UInt32 k_SPARC = 0x3030805;
-
-const UInt32 k_AES = 0x6F10701;
-
-
-static inline bool IsFilterMethod(UInt64 m)
-{
- if (m > (UInt64)0xFFFFFFFF)
- return false;
- switch ((UInt32)m)
- {
- case k_Delta:
- case k_BCJ:
- case k_BCJ2:
- case k_PPC:
- case k_IA64:
- case k_ARM:
- case k_ARMT:
- case k_SPARC:
- case k_SWAP2:
- case k_SWAP4:
- return true;
- }
- return false;
-}
-
-}}
-
-#endif
+// 7z/7zHeader.h
+
+#ifndef ZIP7_INC_7Z_HEADER_H
+#define ZIP7_INC_7Z_HEADER_H
+
+#include "../../../Common/MyTypes.h"
+
+namespace NArchive {
+namespace N7z {
+
+const unsigned kSignatureSize = 6;
+extern Byte kSignature[kSignatureSize];
+
+// #define Z7_7Z_VOL
+// 7z-MultiVolume is not finished yet.
+// It can work already, but I still do not like some
+// things of that new multivolume format.
+// So please keep it commented.
+
+#ifdef Z7_7Z_VOL
+extern Byte kFinishSignature[kSignatureSize];
+#endif
+
+struct CArchiveVersion
+{
+ Byte Major;
+ Byte Minor;
+};
+
+const Byte kMajorVersion = 0;
+
+struct CStartHeader
+{
+ UInt64 NextHeaderOffset;
+ UInt64 NextHeaderSize;
+ UInt32 NextHeaderCRC;
+};
+
+const UInt32 kStartHeaderSize = 20;
+
+#ifdef Z7_7Z_VOL
+struct CFinishHeader: public CStartHeader
+{
+ UInt64 ArchiveStartOffset; // data offset from end if that struct
+ UInt64 AdditionalStartBlockSize; // start signature & start header size
+};
+
+const UInt32 kFinishHeaderSize = kStartHeaderSize + 16;
+#endif
+
+namespace NID
+{
+ enum EEnum
+ {
+ kEnd,
+
+ kHeader,
+
+ kArchiveProperties,
+
+ kAdditionalStreamsInfo,
+ kMainStreamsInfo,
+ kFilesInfo,
+
+ kPackInfo,
+ kUnpackInfo,
+ kSubStreamsInfo,
+
+ kSize,
+ kCRC,
+
+ kFolder,
+
+ kCodersUnpackSize,
+ kNumUnpackStream,
+
+ kEmptyStream,
+ kEmptyFile,
+ kAnti,
+
+ kName,
+ kCTime,
+ kATime,
+ kMTime,
+ kWinAttrib,
+ kComment,
+
+ kEncodedHeader,
+
+ kStartPos,
+ kDummy
+
+ // kNtSecure,
+ // kParent,
+ // kIsAux
+ };
+}
+
+
+const UInt32 k_Copy = 0;
+const UInt32 k_Delta = 3;
+const UInt32 k_ARM64 = 0xa;
+
+const UInt32 k_LZMA2 = 0x21;
+
+const UInt32 k_SWAP2 = 0x20302;
+const UInt32 k_SWAP4 = 0x20304;
+
+const UInt32 k_LZMA = 0x30101;
+const UInt32 k_PPMD = 0x30401;
+
+const UInt32 k_Deflate = 0x40108;
+const UInt32 k_Deflate64 = 0x40109;
+const UInt32 k_BZip2 = 0x40202;
+
+const UInt32 k_BCJ = 0x3030103;
+const UInt32 k_BCJ2 = 0x303011B;
+const UInt32 k_PPC = 0x3030205;
+const UInt32 k_IA64 = 0x3030401;
+const UInt32 k_ARM = 0x3030501;
+const UInt32 k_ARMT = 0x3030701;
+const UInt32 k_SPARC = 0x3030805;
+
+const UInt32 k_AES = 0x6F10701;
+
+// const UInt32 k_ZSTD = 0x4015D; // winzip zstd
+// 0x4F71101, 7z-zstd
+
+static inline bool IsFilterMethod(UInt64 m)
+{
+ if (m > (UInt32)0xFFFFFFFF)
+ return false;
+ switch ((UInt32)m)
+ {
+ case k_Delta:
+ case k_ARM64:
+ case k_BCJ:
+ case k_BCJ2:
+ case k_PPC:
+ case k_IA64:
+ case k_ARM:
+ case k_ARMT:
+ case k_SPARC:
+ case k_SWAP2:
+ case k_SWAP4:
+ return true;
+ }
+ return false;
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zIn.cpp b/CPP/7zip/Archive/7z/7zIn.cpp
index ae5ff19..4defd27 100644
--- a/CPP/7zip/Archive/7z/7zIn.cpp
+++ b/CPP/7zip/Archive/7z/7zIn.cpp
@@ -1,1666 +1,1757 @@
-// 7zIn.cpp
-
-#include "StdAfx.h"
-
-#ifdef _WIN32
-#include <wchar.h>
-#else
-#include <ctype.h>
-#endif
-
-#include "../../../../C/7zCrc.h"
-#include "../../../../C/CpuArch.h"
-
-#include "../../Common/StreamObjects.h"
-#include "../../Common/StreamUtils.h"
-
-#include "7zDecode.h"
-#include "7zIn.h"
-
-#define Get16(p) GetUi16(p)
-#define Get32(p) GetUi32(p)
-#define Get64(p) GetUi64(p)
-
-// define FORMAT_7Z_RECOVERY if you want to recover multivolume archives with empty StartHeader
-#ifndef _SFX
-#define FORMAT_7Z_RECOVERY
-#endif
-
-using namespace NWindows;
-using namespace NCOM;
-
-namespace NArchive {
-namespace N7z {
-
-unsigned BoolVector_CountSum(const CBoolVector &v)
-{
- unsigned sum = 0;
- const unsigned size = v.Size();
- for (unsigned i = 0; i < size; i++)
- if (v[i])
- sum++;
- return sum;
-}
-
-static inline bool BoolVector_Item_IsValidAndTrue(const CBoolVector &v, unsigned i)
-{
- return (i < v.Size() ? v[i] : false);
-}
-
-static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
-{
- v.ClearAndSetSize(size);
- bool *p = &v[0];
- for (unsigned i = 0; i < size; i++)
- p[i] = false;
-}
-
-
-class CInArchiveException {};
-class CUnsupportedFeatureException: public CInArchiveException {};
-
-static void ThrowException() { throw CInArchiveException(); }
-static inline void ThrowEndOfData() { ThrowException(); }
-static inline void ThrowUnsupported() { throw CUnsupportedFeatureException(); }
-static inline void ThrowIncorrect() { ThrowException(); }
-
-class CStreamSwitch
-{
- CInArchive *_archive;
- bool _needRemove;
- bool _needUpdatePos;
-public:
- CStreamSwitch(): _needRemove(false), _needUpdatePos(false) {}
- ~CStreamSwitch() { Remove(); }
- void Remove();
- void Set(CInArchive *archive, const Byte *data, size_t size, bool needUpdatePos);
- void Set(CInArchive *archive, const CByteBuffer &byteBuffer);
- void Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector);
-};
-
-void CStreamSwitch::Remove()
-{
- if (_needRemove)
- {
- if (_archive->_inByteBack->GetRem() != 0)
- _archive->ThereIsHeaderError = true;
- _archive->DeleteByteStream(_needUpdatePos);
- _needRemove = false;
- }
-}
-
-void CStreamSwitch::Set(CInArchive *archive, const Byte *data, size_t size, bool needUpdatePos)
-{
- Remove();
- _archive = archive;
- _archive->AddByteStream(data, size);
- _needRemove = true;
- _needUpdatePos = needUpdatePos;
-}
-
-void CStreamSwitch::Set(CInArchive *archive, const CByteBuffer &byteBuffer)
-{
- Set(archive, byteBuffer, byteBuffer.Size(), false);
-}
-
-void CStreamSwitch::Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector)
-{
- Remove();
- Byte external = archive->ReadByte();
- if (external != 0)
- {
- if (!dataVector)
- ThrowIncorrect();
- CNum dataIndex = archive->ReadNum();
- if (dataIndex >= dataVector->Size())
- ThrowIncorrect();
- Set(archive, (*dataVector)[dataIndex]);
- }
-}
-
-void CInArchive::AddByteStream(const Byte *buf, size_t size)
-{
- if (_numInByteBufs == kNumBufLevelsMax)
- ThrowIncorrect();
- _inByteBack = &_inByteVector[_numInByteBufs++];
- _inByteBack->Init(buf, size);
-}
-
-
-Byte CInByte2::ReadByte()
-{
- if (_pos >= _size)
- ThrowEndOfData();
- return _buffer[_pos++];
-}
-
-void CInByte2::ReadBytes(Byte *data, size_t size)
-{
- if (size == 0)
- return;
- if (size > _size - _pos)
- ThrowEndOfData();
- memcpy(data, _buffer + _pos, size);
- _pos += size;
-}
-
-void CInByte2::SkipData(UInt64 size)
-{
- if (size > _size - _pos)
- ThrowEndOfData();
- _pos += (size_t)size;
-}
-
-void CInByte2::SkipData()
-{
- SkipData(ReadNumber());
-}
-
-static UInt64 ReadNumberSpec(const Byte *p, size_t size, size_t &processed)
-{
- if (size == 0)
- {
- processed = 0;
- return 0;
- }
-
- unsigned b = *p++;
- size--;
-
- if ((b & 0x80) == 0)
- {
- processed = 1;
- return b;
- }
-
- if (size == 0)
- {
- processed = 0;
- return 0;
- }
-
- UInt64 value = (UInt64)*p;
- p++;
- size--;
-
- for (unsigned i = 1; i < 8; i++)
- {
- unsigned mask = (unsigned)0x80 >> i;
- if ((b & mask) == 0)
- {
- UInt64 high = b & (mask - 1);
- value |= (high << (i * 8));
- processed = i + 1;
- return value;
- }
-
- if (size == 0)
- {
- processed = 0;
- return 0;
- }
-
- value |= ((UInt64)*p << (i * 8));
- p++;
- size--;
- }
-
- processed = 9;
- return value;
-}
-
-UInt64 CInByte2::ReadNumber()
-{
- size_t processed;
- UInt64 res = ReadNumberSpec(_buffer + _pos, _size - _pos, processed);
- if (processed == 0)
- ThrowEndOfData();
- _pos += processed;
- return res;
-}
-
-CNum CInByte2::ReadNum()
-{
- /*
- if (_pos < _size)
- {
- Byte val = _buffer[_pos];
- if ((unsigned)val < 0x80)
- {
- _pos++;
- return (unsigned)val;
- }
- }
- */
- UInt64 value = ReadNumber();
- if (value > kNumMax)
- ThrowUnsupported();
- return (CNum)value;
-}
-
-UInt32 CInByte2::ReadUInt32()
-{
- if (_pos + 4 > _size)
- ThrowEndOfData();
- UInt32 res = Get32(_buffer + _pos);
- _pos += 4;
- return res;
-}
-
-UInt64 CInByte2::ReadUInt64()
-{
- if (_pos + 8 > _size)
- ThrowEndOfData();
- UInt64 res = Get64(_buffer + _pos);
- _pos += 8;
- return res;
-}
-
-#define CHECK_SIGNATURE if (p[0] != '7' || p[1] != 'z' || p[2] != 0xBC || p[3] != 0xAF || p[4] != 0x27 || p[5] != 0x1C) return false;
-
-static inline bool TestSignature(const Byte *p)
-{
- CHECK_SIGNATURE
- return CrcCalc(p + 12, 20) == Get32(p + 8);
-}
-
-#ifdef FORMAT_7Z_RECOVERY
-static inline bool TestSignature2(const Byte *p)
-{
- CHECK_SIGNATURE;
- if (CrcCalc(p + 12, 20) == Get32(p + 8))
- return true;
- for (unsigned i = 8; i < kHeaderSize; i++)
- if (p[i] != 0)
- return false;
- return (p[6] != 0 || p[7] != 0);
-}
-#else
-#define TestSignature2(p) TestSignature(p)
-#endif
-
-HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
-{
- RINOK(ReadStream_FALSE(stream, _header, kHeaderSize));
-
- if (TestSignature2(_header))
- return S_OK;
- if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
- return S_FALSE;
-
- const UInt32 kBufSize = 1 << 15;
- CByteArr buf(kBufSize);
- memcpy(buf, _header, kHeaderSize);
- UInt64 offset = 0;
-
- for (;;)
- {
- UInt32 readSize = kBufSize - kHeaderSize;
- if (searchHeaderSizeLimit)
- {
- UInt64 rem = *searchHeaderSizeLimit - offset;
- if (readSize > rem)
- readSize = (UInt32)rem;
- if (readSize == 0)
- return S_FALSE;
- }
-
- UInt32 processed = 0;
- RINOK(stream->Read(buf + kHeaderSize, readSize, &processed));
- if (processed == 0)
- return S_FALSE;
-
- for (UInt32 pos = 0;;)
- {
- const Byte *p = buf + pos + 1;
- const Byte *lim = buf + processed;
- for (; p <= lim; p += 4)
- {
- if (p[0] == '7') break;
- if (p[1] == '7') { p += 1; break; }
- if (p[2] == '7') { p += 2; break; }
- if (p[3] == '7') { p += 3; break; }
- };
- if (p > lim)
- break;
- pos = (UInt32)(p - buf);
- if (TestSignature(p))
- {
- memcpy(_header, p, kHeaderSize);
- _arhiveBeginStreamPosition += offset + pos;
- return stream->Seek(_arhiveBeginStreamPosition + kHeaderSize, STREAM_SEEK_SET, NULL);
- }
- }
-
- offset += processed;
- memmove(buf, buf + processed, kHeaderSize);
- }
-}
-
-// S_FALSE means that file is not archive
-HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
-{
- HeadersSize = 0;
- Close();
- RINOK(stream->Seek(0, STREAM_SEEK_CUR, &_arhiveBeginStreamPosition))
- RINOK(stream->Seek(0, STREAM_SEEK_END, &_fileEndPosition))
- RINOK(stream->Seek(_arhiveBeginStreamPosition, STREAM_SEEK_SET, NULL))
- RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit));
- _stream = stream;
- return S_OK;
-}
-
-void CInArchive::Close()
-{
- _numInByteBufs = 0;
- _stream.Release();
- ThereIsHeaderError = false;
-}
-
-void CInArchive::ReadArchiveProperties(CInArchiveInfo & /* archiveInfo */)
-{
- for (;;)
- {
- if (ReadID() == NID::kEnd)
- break;
- SkipData();
- }
-}
-
-// CFolder &folder can be non empty. So we must set all fields
-
-void CInByte2::ParseFolder(CFolder &folder)
-{
- UInt32 numCoders = ReadNum();
-
- if (numCoders == 0)
- ThrowUnsupported();
-
- folder.Coders.SetSize(numCoders);
-
- UInt32 numInStreams = 0;
- UInt32 i;
- for (i = 0; i < numCoders; i++)
- {
- CCoderInfo &coder = folder.Coders[i];
- {
- Byte mainByte = ReadByte();
- if ((mainByte & 0xC0) != 0)
- ThrowUnsupported();
- unsigned idSize = (mainByte & 0xF);
- if (idSize > 8 || idSize > GetRem())
- ThrowUnsupported();
- const Byte *longID = GetPtr();
- UInt64 id = 0;
- for (unsigned j = 0; j < idSize; j++)
- id = ((id << 8) | longID[j]);
- SkipDataNoCheck(idSize);
- coder.MethodID = id;
-
- if ((mainByte & 0x10) != 0)
- {
- coder.NumStreams = ReadNum();
- /* numOutStreams = */ ReadNum();
- }
- else
- {
- coder.NumStreams = 1;
- }
-
- if ((mainByte & 0x20) != 0)
- {
- CNum propsSize = ReadNum();
- coder.Props.Alloc((size_t)propsSize);
- ReadBytes((Byte *)coder.Props, (size_t)propsSize);
- }
- else
- coder.Props.Free();
- }
- numInStreams += coder.NumStreams;
- }
-
- UInt32 numBonds = numCoders - 1;
- folder.Bonds.SetSize(numBonds);
- for (i = 0; i < numBonds; i++)
- {
- CBond &bp = folder.Bonds[i];
- bp.PackIndex = ReadNum();
- bp.UnpackIndex = ReadNum();
- }
-
- if (numInStreams < numBonds)
- ThrowUnsupported();
- UInt32 numPackStreams = numInStreams - numBonds;
- folder.PackStreams.SetSize(numPackStreams);
-
- if (numPackStreams == 1)
- {
- for (i = 0; i < numInStreams; i++)
- if (folder.FindBond_for_PackStream(i) < 0)
- {
- folder.PackStreams[0] = i;
- break;
- }
- if (i == numInStreams)
- ThrowUnsupported();
- }
- else
- for (i = 0; i < numPackStreams; i++)
- folder.PackStreams[i] = ReadNum();
-}
-
-void CFolders::ParseFolderInfo(unsigned folderIndex, CFolder &folder) const
-{
- size_t startPos = FoCodersDataOffset[folderIndex];
- CInByte2 inByte;
- inByte.Init(CodersData + startPos, FoCodersDataOffset[folderIndex + 1] - startPos);
- inByte.ParseFolder(folder);
- if (inByte.GetRem() != 0)
- throw 20120424;
-}
-
-
-void CDatabase::GetPath(unsigned index, UString &path) const
-{
- path.Empty();
- if (!NameOffsets || !NamesBuf)
- return;
-
- size_t offset = NameOffsets[index];
- size_t size = NameOffsets[index + 1] - offset;
-
- if (size >= (1 << 28))
- return;
-
- wchar_t *s = path.GetBuf((unsigned)size - 1);
-
- const Byte *p = ((const Byte *)NamesBuf + offset * 2);
-
- #if defined(_WIN32) && defined(MY_CPU_LE)
-
- wmemcpy(s, (const wchar_t *)p, size);
-
- #else
-
- for (size_t i = 0; i < size; i++)
- {
- *s = Get16(p);
- p += 2;
- s++;
- }
-
- #endif
-
- path.ReleaseBuf_SetLen((unsigned)size - 1);
-}
-
-HRESULT CDatabase::GetPath_Prop(unsigned index, PROPVARIANT *path) const throw()
-{
- PropVariant_Clear(path);
- if (!NameOffsets || !NamesBuf)
- return S_OK;
-
- size_t offset = NameOffsets[index];
- size_t size = NameOffsets[index + 1] - offset;
-
- if (size >= (1 << 14))
- return S_OK;
-
- RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size - 1));
- wchar_t *s = path->bstrVal;
-
- const Byte *p = ((const Byte *)NamesBuf + offset * 2);
-
- for (size_t i = 0; i < size; i++)
- {
- wchar_t c = Get16(p);
- p += 2;
- #if WCHAR_PATH_SEPARATOR != L'/'
- if (c == L'/')
- c = WCHAR_PATH_SEPARATOR;
- #endif
- *s++ = c;
- }
-
- return S_OK;
-
- /*
- unsigned cur = index;
- unsigned size = 0;
-
- for (int i = 0;; i++)
- {
- size_t len = NameOffsets[cur + 1] - NameOffsets[cur];
- size += (unsigned)len;
- if (i > 256 || len > (1 << 14) || size > (1 << 14))
- return PropVarEm_Set_Str(path, "[TOO-LONG]");
- cur = Files[cur].Parent;
- if (cur < 0)
- break;
- }
- size--;
-
- RINOK(PropVarEm_Alloc_Bstr(path, size));
- wchar_t *s = path->bstrVal;
- s += size;
- *s = 0;
- cur = index;
-
- for (;;)
- {
- unsigned len = (unsigned)(NameOffsets[cur + 1] - NameOffsets[cur] - 1);
- const Byte *p = (const Byte *)NamesBuf + (NameOffsets[cur + 1] * 2) - 2;
- for (; len != 0; len--)
- {
- p -= 2;
- --s;
- wchar_t c = Get16(p);
- if (c == '/')
- c = WCHAR_PATH_SEPARATOR;
- *s = c;
- }
-
- const CFileItem &file = Files[cur];
- cur = file.Parent;
- if (cur < 0)
- return S_OK;
- *(--s) = (file.IsAltStream ? ':' : WCHAR_PATH_SEPARATOR);
- }
- */
-}
-
-void CInArchive::WaitId(UInt64 id)
-{
- for (;;)
- {
- UInt64 type = ReadID();
- if (type == id)
- return;
- if (type == NID::kEnd)
- ThrowIncorrect();
- SkipData();
- }
-}
-
-
-void CInArchive::Read_UInt32_Vector(CUInt32DefVector &v)
-{
- unsigned numItems = v.Defs.Size();
- v.Vals.ClearAndSetSize(numItems);
- UInt32 *p = &v.Vals[0];
- const bool *defs = &v.Defs[0];
- for (unsigned i = 0; i < numItems; i++)
- {
- UInt32 a = 0;
- if (defs[i])
- a = ReadUInt32();
- p[i] = a;
- }
-}
-
-
-void CInArchive::ReadHashDigests(unsigned numItems, CUInt32DefVector &crcs)
-{
- ReadBoolVector2(numItems, crcs.Defs);
- Read_UInt32_Vector(crcs);
-}
-
-
-#define k_Scan_NumCoders_MAX 64
-#define k_Scan_NumCodersStreams_in_Folder_MAX 64
-
-void CInArchive::ReadPackInfo(CFolders &f)
-{
- CNum numPackStreams = ReadNum();
-
- WaitId(NID::kSize);
- f.PackPositions.Alloc(numPackStreams + 1);
- f.NumPackStreams = numPackStreams;
- UInt64 sum = 0;
- for (CNum i = 0; i < numPackStreams; i++)
- {
- f.PackPositions[i] = sum;
- UInt64 packSize = ReadNumber();
- sum += packSize;
- if (sum < packSize)
- ThrowIncorrect();
- }
- f.PackPositions[numPackStreams] = sum;
-
- UInt64 type;
- for (;;)
- {
- type = ReadID();
- if (type == NID::kEnd)
- return;
- if (type == NID::kCRC)
- {
- CUInt32DefVector PackCRCs;
- ReadHashDigests(numPackStreams, PackCRCs);
- continue;
- }
- SkipData();
- }
-}
-
-void CInArchive::ReadUnpackInfo(
- const CObjectVector<CByteBuffer> *dataVector,
- CFolders &folders)
-{
- WaitId(NID::kFolder);
- CNum numFolders = ReadNum();
-
- CNum numCodersOutStreams = 0;
- {
- CStreamSwitch streamSwitch;
- streamSwitch.Set(this, dataVector);
- const Byte *startBufPtr = _inByteBack->GetPtr();
- folders.NumFolders = numFolders;
-
- folders.FoStartPackStreamIndex.Alloc(numFolders + 1);
- folders.FoToMainUnpackSizeIndex.Alloc(numFolders);
- folders.FoCodersDataOffset.Alloc(numFolders + 1);
- folders.FoToCoderUnpackSizes.Alloc(numFolders + 1);
-
- CBoolVector StreamUsed;
- CBoolVector CoderUsed;
-
- CNum packStreamIndex = 0;
- CNum fo;
- CInByte2 *inByte = _inByteBack;
-
- for (fo = 0; fo < numFolders; fo++)
- {
- UInt32 indexOfMainStream = 0;
- UInt32 numPackStreams = 0;
- folders.FoCodersDataOffset[fo] = _inByteBack->GetPtr() - startBufPtr;
-
- CNum numInStreams = 0;
- CNum numCoders = inByte->ReadNum();
-
- if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
- ThrowUnsupported();
-
- for (CNum ci = 0; ci < numCoders; ci++)
- {
- Byte mainByte = inByte->ReadByte();
- if ((mainByte & 0xC0) != 0)
- ThrowUnsupported();
-
- unsigned idSize = (mainByte & 0xF);
- if (idSize > 8)
- ThrowUnsupported();
- if (idSize > inByte->GetRem())
- ThrowEndOfData();
- const Byte *longID = inByte->GetPtr();
- UInt64 id = 0;
- for (unsigned j = 0; j < idSize; j++)
- id = ((id << 8) | longID[j]);
- inByte->SkipDataNoCheck(idSize);
- if (folders.ParsedMethods.IDs.Size() < 128)
- folders.ParsedMethods.IDs.AddToUniqueSorted(id);
-
- CNum coderInStreams = 1;
- if ((mainByte & 0x10) != 0)
- {
- coderInStreams = inByte->ReadNum();
- if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)
- ThrowUnsupported();
- if (inByte->ReadNum() != 1)
- ThrowUnsupported();
- }
-
- numInStreams += coderInStreams;
- if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)
- ThrowUnsupported();
-
- if ((mainByte & 0x20) != 0)
- {
- CNum propsSize = inByte->ReadNum();
- if (propsSize > inByte->GetRem())
- ThrowEndOfData();
- if (id == k_LZMA2 && propsSize == 1)
- {
- Byte v = *_inByteBack->GetPtr();
- if (folders.ParsedMethods.Lzma2Prop < v)
- folders.ParsedMethods.Lzma2Prop = v;
- }
- else if (id == k_LZMA && propsSize == 5)
- {
- UInt32 dicSize = GetUi32(_inByteBack->GetPtr() + 1);
- if (folders.ParsedMethods.LzmaDic < dicSize)
- folders.ParsedMethods.LzmaDic = dicSize;
- }
- inByte->SkipDataNoCheck((size_t)propsSize);
- }
- }
-
- if (numCoders == 1 && numInStreams == 1)
- {
- indexOfMainStream = 0;
- numPackStreams = 1;
- }
- else
- {
- UInt32 i;
- CNum numBonds = numCoders - 1;
- if (numInStreams < numBonds)
- ThrowUnsupported();
-
- BoolVector_Fill_False(StreamUsed, numInStreams);
- BoolVector_Fill_False(CoderUsed, numCoders);
-
- for (i = 0; i < numBonds; i++)
- {
- CNum index = ReadNum();
- if (index >= numInStreams || StreamUsed[index])
- ThrowUnsupported();
- StreamUsed[index] = true;
-
- index = ReadNum();
- if (index >= numCoders || CoderUsed[index])
- ThrowUnsupported();
- CoderUsed[index] = true;
- }
-
- numPackStreams = numInStreams - numBonds;
-
- if (numPackStreams != 1)
- for (i = 0; i < numPackStreams; i++)
- {
- CNum index = inByte->ReadNum(); // PackStreams
- if (index >= numInStreams || StreamUsed[index])
- ThrowUnsupported();
- StreamUsed[index] = true;
- }
-
- for (i = 0; i < numCoders; i++)
- if (!CoderUsed[i])
- {
- indexOfMainStream = i;
- break;
- }
-
- if (i == numCoders)
- ThrowUnsupported();
- }
-
- folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
- numCodersOutStreams += numCoders;
- folders.FoStartPackStreamIndex[fo] = packStreamIndex;
- if (numPackStreams > folders.NumPackStreams - packStreamIndex)
- ThrowIncorrect();
- packStreamIndex += numPackStreams;
- folders.FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;
- }
-
- size_t dataSize = _inByteBack->GetPtr() - startBufPtr;
- folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
- folders.FoStartPackStreamIndex[fo] = packStreamIndex;
- folders.FoCodersDataOffset[fo] = _inByteBack->GetPtr() - startBufPtr;
- folders.CodersData.CopyFrom(startBufPtr, dataSize);
-
- // if (folders.NumPackStreams != packStreamIndex) ThrowUnsupported();
- }
-
- WaitId(NID::kCodersUnpackSize);
- folders.CoderUnpackSizes.Alloc(numCodersOutStreams);
- for (CNum i = 0; i < numCodersOutStreams; i++)
- folders.CoderUnpackSizes[i] = ReadNumber();
-
- for (;;)
- {
- UInt64 type = ReadID();
- if (type == NID::kEnd)
- return;
- if (type == NID::kCRC)
- {
- ReadHashDigests(numFolders, folders.FolderCRCs);
- continue;
- }
- SkipData();
- }
-}
-
-void CInArchive::ReadSubStreamsInfo(
- CFolders &folders,
- CRecordVector<UInt64> &unpackSizes,
- CUInt32DefVector &digests)
-{
- folders.NumUnpackStreamsVector.Alloc(folders.NumFolders);
- CNum i;
- for (i = 0; i < folders.NumFolders; i++)
- folders.NumUnpackStreamsVector[i] = 1;
-
- UInt64 type;
-
- for (;;)
- {
- type = ReadID();
- if (type == NID::kNumUnpackStream)
- {
- for (i = 0; i < folders.NumFolders; i++)
- folders.NumUnpackStreamsVector[i] = ReadNum();
- continue;
- }
- if (type == NID::kCRC || type == NID::kSize || type == NID::kEnd)
- break;
- SkipData();
- }
-
- if (type == NID::kSize)
- {
- for (i = 0; i < folders.NumFolders; i++)
- {
- // v3.13 incorrectly worked with empty folders
- // v4.07: we check that folder is empty
- CNum numSubstreams = folders.NumUnpackStreamsVector[i];
- if (numSubstreams == 0)
- continue;
- UInt64 sum = 0;
- for (CNum j = 1; j < numSubstreams; j++)
- {
- UInt64 size = ReadNumber();
- unpackSizes.Add(size);
- sum += size;
- if (sum < size)
- ThrowIncorrect();
- }
- UInt64 folderUnpackSize = folders.GetFolderUnpackSize(i);
- if (folderUnpackSize < sum)
- ThrowIncorrect();
- unpackSizes.Add(folderUnpackSize - sum);
- }
- type = ReadID();
- }
- else
- {
- for (i = 0; i < folders.NumFolders; i++)
- {
- /* v9.26 - v9.29 incorrectly worked:
- if (folders.NumUnpackStreamsVector[i] == 0), it threw error */
- CNum val = folders.NumUnpackStreamsVector[i];
- if (val > 1)
- ThrowIncorrect();
- if (val == 1)
- unpackSizes.Add(folders.GetFolderUnpackSize(i));
- }
- }
-
- unsigned numDigests = 0;
- for (i = 0; i < folders.NumFolders; i++)
- {
- CNum numSubstreams = folders.NumUnpackStreamsVector[i];
- if (numSubstreams != 1 || !folders.FolderCRCs.ValidAndDefined(i))
- numDigests += numSubstreams;
- }
-
- for (;;)
- {
- if (type == NID::kEnd)
- break;
- if (type == NID::kCRC)
- {
- // CUInt32DefVector digests2;
- // ReadHashDigests(numDigests, digests2);
- CBoolVector digests2;
- ReadBoolVector2(numDigests, digests2);
-
- digests.ClearAndSetSize(unpackSizes.Size());
-
- unsigned k = 0;
- unsigned k2 = 0;
-
- for (i = 0; i < folders.NumFolders; i++)
- {
- CNum numSubstreams = folders.NumUnpackStreamsVector[i];
- if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
- {
- digests.Defs[k] = true;
- digests.Vals[k] = folders.FolderCRCs.Vals[i];
- k++;
- }
- else for (CNum j = 0; j < numSubstreams; j++)
- {
- bool defined = digests2[k2++];
- digests.Defs[k] = defined;
- UInt32 crc = 0;
- if (defined)
- crc = ReadUInt32();
- digests.Vals[k] = crc;
- k++;
- }
- }
- // if (k != unpackSizes.Size()) throw 1234567;
- }
- else
- SkipData();
-
- type = ReadID();
- }
-
- if (digests.Defs.Size() != unpackSizes.Size())
- {
- digests.ClearAndSetSize(unpackSizes.Size());
- unsigned k = 0;
- for (i = 0; i < folders.NumFolders; i++)
- {
- CNum numSubstreams = folders.NumUnpackStreamsVector[i];
- if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
- {
- digests.Defs[k] = true;
- digests.Vals[k] = folders.FolderCRCs.Vals[i];
- k++;
- }
- else for (CNum j = 0; j < numSubstreams; j++)
- {
- digests.Defs[k] = false;
- digests.Vals[k] = 0;
- k++;
- }
- }
- }
-}
-
-void CInArchive::ReadStreamsInfo(
- const CObjectVector<CByteBuffer> *dataVector,
- UInt64 &dataOffset,
- CFolders &folders,
- CRecordVector<UInt64> &unpackSizes,
- CUInt32DefVector &digests)
-{
- UInt64 type = ReadID();
-
- if (type == NID::kPackInfo)
- {
- dataOffset = ReadNumber();
- ReadPackInfo(folders);
- type = ReadID();
- }
-
- if (type == NID::kUnpackInfo)
- {
- ReadUnpackInfo(dataVector, folders);
- type = ReadID();
- }
-
- if (folders.NumFolders != 0 && !folders.PackPositions)
- {
- // if there are folders, we need PackPositions also
- folders.PackPositions.Alloc(1);
- folders.PackPositions[0] = 0;
- }
-
- if (type == NID::kSubStreamsInfo)
- {
- ReadSubStreamsInfo(folders, unpackSizes, digests);
- type = ReadID();
- }
- else
- {
- folders.NumUnpackStreamsVector.Alloc(folders.NumFolders);
- /* If digests.Defs.Size() == 0, it means that there are no crcs.
- So we don't need to fill digests with values. */
- // digests.Vals.ClearAndSetSize(folders.NumFolders);
- // BoolVector_Fill_False(digests.Defs, folders.NumFolders);
- for (CNum i = 0; i < folders.NumFolders; i++)
- {
- folders.NumUnpackStreamsVector[i] = 1;
- unpackSizes.Add(folders.GetFolderUnpackSize(i));
- // digests.Vals[i] = 0;
- }
- }
-
- if (type != NID::kEnd)
- ThrowIncorrect();
-}
-
-void CInArchive::ReadBoolVector(unsigned numItems, CBoolVector &v)
-{
- v.ClearAndSetSize(numItems);
- Byte b = 0;
- Byte mask = 0;
- bool *p = &v[0];
- for (unsigned i = 0; i < numItems; i++)
- {
- if (mask == 0)
- {
- b = ReadByte();
- mask = 0x80;
- }
- p[i] = ((b & mask) != 0);
- mask >>= 1;
- }
-}
-
-void CInArchive::ReadBoolVector2(unsigned numItems, CBoolVector &v)
-{
- Byte allAreDefined = ReadByte();
- if (allAreDefined == 0)
- {
- ReadBoolVector(numItems, v);
- return;
- }
- v.ClearAndSetSize(numItems);
- bool *p = &v[0];
- for (unsigned i = 0; i < numItems; i++)
- p[i] = true;
-}
-
-void CInArchive::ReadUInt64DefVector(const CObjectVector<CByteBuffer> &dataVector,
- CUInt64DefVector &v, unsigned numItems)
-{
- ReadBoolVector2(numItems, v.Defs);
-
- CStreamSwitch streamSwitch;
- streamSwitch.Set(this, &dataVector);
-
- v.Vals.ClearAndSetSize(numItems);
- UInt64 *p = &v.Vals[0];
- const bool *defs = &v.Defs[0];
-
- for (unsigned i = 0; i < numItems; i++)
- {
- UInt64 t = 0;
- if (defs[i])
- t = ReadUInt64();
- p[i] = t;
- }
-}
-
-HRESULT CInArchive::ReadAndDecodePackedStreams(
- DECL_EXTERNAL_CODECS_LOC_VARS
- UInt64 baseOffset,
- UInt64 &dataOffset, CObjectVector<CByteBuffer> &dataVector
- _7Z_DECODER_CRYPRO_VARS_DECL
- )
-{
- CFolders folders;
- CRecordVector<UInt64> unpackSizes;
- CUInt32DefVector digests;
-
- ReadStreamsInfo(NULL,
- dataOffset,
- folders,
- unpackSizes,
- digests);
-
- CDecoder decoder(_useMixerMT);
-
- for (CNum i = 0; i < folders.NumFolders; i++)
- {
- CByteBuffer &data = dataVector.AddNew();
- UInt64 unpackSize64 = folders.GetFolderUnpackSize(i);
- size_t unpackSize = (size_t)unpackSize64;
- if (unpackSize != unpackSize64)
- ThrowUnsupported();
- data.Alloc(unpackSize);
-
- CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
- CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
- outStreamSpec->Init(data, unpackSize);
-
- bool dataAfterEnd_Error = false;
-
- HRESULT result = decoder.Decode(
- EXTERNAL_CODECS_LOC_VARS
- _stream, baseOffset + dataOffset,
- folders, i,
- NULL, // *unpackSize
-
- outStream,
- NULL, // *compressProgress
-
- NULL // **inStreamMainRes
- , dataAfterEnd_Error
-
- _7Z_DECODER_CRYPRO_VARS
- #if !defined(_7ZIP_ST)
- , false // mtMode
- , 1 // numThreads
- , 0 // memUsage
- #endif
- );
-
- RINOK(result);
-
- if (dataAfterEnd_Error)
- ThereIsHeaderError = true;
-
- if (folders.FolderCRCs.ValidAndDefined(i))
- if (CrcCalc(data, unpackSize) != folders.FolderCRCs.Vals[i])
- ThrowIncorrect();
- }
-
- if (folders.PackPositions)
- HeadersSize += folders.PackPositions[folders.NumPackStreams];
-
- return S_OK;
-}
-
-HRESULT CInArchive::ReadHeader(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CDbEx &db
- _7Z_DECODER_CRYPRO_VARS_DECL
- )
-{
- UInt64 type = ReadID();
-
- if (type == NID::kArchiveProperties)
- {
- ReadArchiveProperties(db.ArcInfo);
- type = ReadID();
- }
-
- CObjectVector<CByteBuffer> dataVector;
-
- if (type == NID::kAdditionalStreamsInfo)
- {
- HRESULT result = ReadAndDecodePackedStreams(
- EXTERNAL_CODECS_LOC_VARS
- db.ArcInfo.StartPositionAfterHeader,
- db.ArcInfo.DataStartPosition2,
- dataVector
- _7Z_DECODER_CRYPRO_VARS
- );
- RINOK(result);
- db.ArcInfo.DataStartPosition2 += db.ArcInfo.StartPositionAfterHeader;
- type = ReadID();
- }
-
- CRecordVector<UInt64> unpackSizes;
- CUInt32DefVector digests;
-
- if (type == NID::kMainStreamsInfo)
- {
- ReadStreamsInfo(&dataVector,
- db.ArcInfo.DataStartPosition,
- (CFolders &)db,
- unpackSizes,
- digests);
- db.ArcInfo.DataStartPosition += db.ArcInfo.StartPositionAfterHeader;
- type = ReadID();
- }
-
- if (type == NID::kFilesInfo)
- {
-
- const CNum numFiles = ReadNum();
-
- db.ArcInfo.FileInfoPopIDs.Add(NID::kSize);
- // if (!db.PackSizes.IsEmpty())
- db.ArcInfo.FileInfoPopIDs.Add(NID::kPackInfo);
- if (numFiles > 0 && !digests.Defs.IsEmpty())
- db.ArcInfo.FileInfoPopIDs.Add(NID::kCRC);
-
- CBoolVector emptyStreamVector;
- CBoolVector emptyFileVector;
- CBoolVector antiFileVector;
- CNum numEmptyStreams = 0;
-
- for (;;)
- {
- const UInt64 type2 = ReadID();
- if (type2 == NID::kEnd)
- break;
- UInt64 size = ReadNumber();
- if (size > _inByteBack->GetRem())
- ThrowIncorrect();
- CStreamSwitch switchProp;
- switchProp.Set(this, _inByteBack->GetPtr(), (size_t)size, true);
- bool addPropIdToList = true;
- bool isKnownType = true;
- if (type2 > ((UInt32)1 << 30))
- isKnownType = false;
- else switch ((UInt32)type2)
- {
- case NID::kName:
- {
- CStreamSwitch streamSwitch;
- streamSwitch.Set(this, &dataVector);
- size_t rem = _inByteBack->GetRem();
- db.NamesBuf.Alloc(rem);
- ReadBytes(db.NamesBuf, rem);
- db.NameOffsets.Alloc(numFiles + 1);
- size_t pos = 0;
- unsigned i;
- for (i = 0; i < numFiles; i++)
- {
- size_t curRem = (rem - pos) / 2;
- const UInt16 *buf = (const UInt16 *)(db.NamesBuf + pos);
- size_t j;
- for (j = 0; j < curRem && buf[j] != 0; j++);
- if (j == curRem)
- ThrowEndOfData();
- db.NameOffsets[i] = pos / 2;
- pos += j * 2 + 2;
- }
- db.NameOffsets[i] = pos / 2;
- if (pos != rem)
- ThereIsHeaderError = true;
- break;
- }
-
- case NID::kWinAttrib:
- {
- ReadBoolVector2(numFiles, db.Attrib.Defs);
- CStreamSwitch streamSwitch;
- streamSwitch.Set(this, &dataVector);
- Read_UInt32_Vector(db.Attrib);
- break;
- }
-
- /*
- case NID::kIsAux:
- {
- ReadBoolVector(numFiles, db.IsAux);
- break;
- }
- case NID::kParent:
- {
- db.IsTree = true;
- // CBoolVector boolVector;
- // ReadBoolVector2(numFiles, boolVector);
- // CStreamSwitch streamSwitch;
- // streamSwitch.Set(this, &dataVector);
- CBoolVector boolVector;
- ReadBoolVector2(numFiles, boolVector);
-
- db.ThereAreAltStreams = false;
- for (i = 0; i < numFiles; i++)
- {
- CFileItem &file = db.Files[i];
- // file.Parent = -1;
- // if (boolVector[i])
- file.Parent = (int)ReadUInt32();
- file.IsAltStream = !boolVector[i];
- if (file.IsAltStream)
- db.ThereAreAltStreams = true;
- }
- break;
- }
- */
- case NID::kEmptyStream:
- {
- ReadBoolVector(numFiles, emptyStreamVector);
- numEmptyStreams = BoolVector_CountSum(emptyStreamVector);
- emptyFileVector.Clear();
- antiFileVector.Clear();
- break;
- }
- case NID::kEmptyFile: ReadBoolVector(numEmptyStreams, emptyFileVector); break;
- case NID::kAnti: ReadBoolVector(numEmptyStreams, antiFileVector); break;
- case NID::kStartPos: ReadUInt64DefVector(dataVector, db.StartPos, (unsigned)numFiles); break;
- case NID::kCTime: ReadUInt64DefVector(dataVector, db.CTime, (unsigned)numFiles); break;
- case NID::kATime: ReadUInt64DefVector(dataVector, db.ATime, (unsigned)numFiles); break;
- case NID::kMTime: ReadUInt64DefVector(dataVector, db.MTime, (unsigned)numFiles); break;
- case NID::kDummy:
- {
- for (UInt64 j = 0; j < size; j++)
- if (ReadByte() != 0)
- ThereIsHeaderError = true;
- addPropIdToList = false;
- break;
- }
- /*
- case NID::kNtSecure:
- {
- try
- {
- {
- CStreamSwitch streamSwitch;
- streamSwitch.Set(this, &dataVector);
- UInt32 numDescriptors = ReadUInt32();
- size_t offset = 0;
- db.SecureOffsets.Clear();
- for (i = 0; i < numDescriptors; i++)
- {
- UInt32 size = ReadUInt32();
- db.SecureOffsets.Add(offset);
- offset += size;
- }
- // ThrowIncorrect();;
- db.SecureOffsets.Add(offset);
- db.SecureBuf.SetCapacity(offset);
- for (i = 0; i < numDescriptors; i++)
- {
- offset = db.SecureOffsets[i];
- ReadBytes(db.SecureBuf + offset, db.SecureOffsets[i + 1] - offset);
- }
- db.SecureIDs.Clear();
- for (unsigned i = 0; i < numFiles; i++)
- {
- db.SecureIDs.Add(ReadNum());
- // db.SecureIDs.Add(ReadUInt32());
- }
- // ReadUInt32();
- if (_inByteBack->GetRem() != 0)
- ThrowIncorrect();;
- }
- }
- catch(CInArchiveException &)
- {
- ThereIsHeaderError = true;
- addPropIdToList = isKnownType = false;
- db.ClearSecure();
- }
- break;
- }
- */
- default:
- addPropIdToList = isKnownType = false;
- }
- if (isKnownType)
- {
- if (addPropIdToList)
- db.ArcInfo.FileInfoPopIDs.Add(type2);
- }
- else
- {
- db.UnsupportedFeatureWarning = true;
- _inByteBack->SkipRem();
- }
- // SkipData worked incorrectly in some versions before v4.59 (7zVer <= 0.02)
- if (_inByteBack->GetRem() != 0)
- ThrowIncorrect();
- }
-
- type = ReadID(); // Read (NID::kEnd) end of headers
-
- if (numFiles - numEmptyStreams != unpackSizes.Size())
- ThrowUnsupported();
-
- CNum emptyFileIndex = 0;
- CNum sizeIndex = 0;
-
- const CNum numAntiItems = BoolVector_CountSum(antiFileVector);
-
- if (numAntiItems != 0)
- db.IsAnti.ClearAndSetSize(numFiles);
-
- db.Files.ClearAndSetSize(numFiles);
-
- for (CNum i = 0; i < numFiles; i++)
- {
- CFileItem &file = db.Files[i];
- bool isAnti;
- file.Crc = 0;
- if (!BoolVector_Item_IsValidAndTrue(emptyStreamVector, i))
- {
- file.HasStream = true;
- file.IsDir = false;
- isAnti = false;
- file.Size = unpackSizes[sizeIndex];
- file.CrcDefined = digests.ValidAndDefined(sizeIndex);
- if (file.CrcDefined)
- file.Crc = digests.Vals[sizeIndex];
- sizeIndex++;
- }
- else
- {
- file.HasStream = false;
- file.IsDir = !BoolVector_Item_IsValidAndTrue(emptyFileVector, emptyFileIndex);
- isAnti = BoolVector_Item_IsValidAndTrue(antiFileVector, emptyFileIndex);
- emptyFileIndex++;
- file.Size = 0;
- file.CrcDefined = false;
- }
- if (numAntiItems != 0)
- db.IsAnti[i] = isAnti;
- }
-
- }
-
- db.FillLinks();
-
- if (type != NID::kEnd || _inByteBack->GetRem() != 0)
- {
- db.UnsupportedFeatureWarning = true;
- // ThrowIncorrect();
- }
-
- return S_OK;
-}
-
-
-void CDbEx::FillLinks()
-{
- FolderStartFileIndex.Alloc(NumFolders);
- FileIndexToFolderIndexMap.Alloc(Files.Size());
-
- CNum folderIndex = 0;
- CNum indexInFolder = 0;
- unsigned i;
-
- for (i = 0; i < Files.Size(); i++)
- {
- bool emptyStream = !Files[i].HasStream;
- if (indexInFolder == 0)
- {
- if (emptyStream)
- {
- FileIndexToFolderIndexMap[i] = kNumNoIndex;
- continue;
- }
- // v3.13 incorrectly worked with empty folders
- // v4.07: we skip empty folders
- for (;;)
- {
- if (folderIndex >= NumFolders)
- ThrowIncorrect();
- FolderStartFileIndex[folderIndex] = i;
- if (NumUnpackStreamsVector[folderIndex] != 0)
- break;
- folderIndex++;
- }
- }
- FileIndexToFolderIndexMap[i] = folderIndex;
- if (emptyStream)
- continue;
- if (++indexInFolder >= NumUnpackStreamsVector[folderIndex])
- {
- folderIndex++;
- indexInFolder = 0;
- }
- }
-
- if (indexInFolder != 0)
- {
- folderIndex++;
- // 18.06
- ThereIsHeaderError = true;
- // ThrowIncorrect();
- }
-
- for (;;)
- {
- if (folderIndex >= NumFolders)
- return;
- FolderStartFileIndex[folderIndex] = i;
- if (NumUnpackStreamsVector[folderIndex] != 0)
- {
- // 18.06
- ThereIsHeaderError = true;
- // ThrowIncorrect();
- }
- folderIndex++;
- }
-}
-
-
-HRESULT CInArchive::ReadDatabase2(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CDbEx &db
- _7Z_DECODER_CRYPRO_VARS_DECL
- )
-{
- db.Clear();
- db.ArcInfo.StartPosition = _arhiveBeginStreamPosition;
-
- db.ArcInfo.Version.Major = _header[6];
- db.ArcInfo.Version.Minor = _header[7];
-
- if (db.ArcInfo.Version.Major != kMajorVersion)
- {
- // db.UnsupportedVersion = true;
- return S_FALSE;
- }
-
- UInt64 nextHeaderOffset = Get64(_header + 12);
- UInt64 nextHeaderSize = Get64(_header + 20);
- UInt32 nextHeaderCRC = Get32(_header + 28);
-
- #ifdef FORMAT_7Z_RECOVERY
- UInt32 crcFromArc = Get32(_header + 8);
- if (crcFromArc == 0 && nextHeaderOffset == 0 && nextHeaderSize == 0 && nextHeaderCRC == 0)
- {
- UInt64 cur, fileSize;
- RINOK(_stream->Seek(0, STREAM_SEEK_CUR, &cur));
- const unsigned kCheckSize = 512;
- Byte buf[kCheckSize];
- RINOK(_stream->Seek(0, STREAM_SEEK_END, &fileSize));
- UInt64 rem = fileSize - cur;
- unsigned checkSize = kCheckSize;
- if (rem < kCheckSize)
- checkSize = (unsigned)(rem);
- if (checkSize < 3)
- return S_FALSE;
- RINOK(_stream->Seek(fileSize - checkSize, STREAM_SEEK_SET, NULL));
- RINOK(ReadStream_FALSE(_stream, buf, (size_t)checkSize));
-
- if (buf[checkSize - 1] != 0)
- return S_FALSE;
-
- unsigned i;
- for (i = checkSize - 2;; i--)
- {
- if (buf[i] == NID::kEncodedHeader && buf[i + 1] == NID::kPackInfo ||
- buf[i] == NID::kHeader && buf[i + 1] == NID::kMainStreamsInfo)
- break;
- if (i == 0)
- return S_FALSE;
- }
- nextHeaderSize = checkSize - i;
- nextHeaderOffset = rem - nextHeaderSize;
- nextHeaderCRC = CrcCalc(buf + i, (size_t)nextHeaderSize);
- RINOK(_stream->Seek(cur, STREAM_SEEK_SET, NULL));
- db.StartHeaderWasRecovered = true;
- }
- else
- #endif
- {
- // Crc was tested already at signature check
- // if (CrcCalc(_header + 12, 20) != crcFromArchive) ThrowIncorrect();
- }
-
- db.ArcInfo.StartPositionAfterHeader = _arhiveBeginStreamPosition + kHeaderSize;
- db.PhySize = kHeaderSize;
-
- db.IsArc = false;
- if ((Int64)nextHeaderOffset < 0 ||
- nextHeaderSize > ((UInt64)1 << 62))
- return S_FALSE;
- if (nextHeaderSize == 0)
- {
- if (nextHeaderOffset != 0)
- return S_FALSE;
- db.IsArc = true;
- return S_OK;
- }
-
- if (!db.StartHeaderWasRecovered)
- db.IsArc = true;
-
- HeadersSize += kHeaderSize + nextHeaderSize;
- db.PhySize = kHeaderSize + nextHeaderOffset + nextHeaderSize;
- if (_fileEndPosition - db.ArcInfo.StartPositionAfterHeader < nextHeaderOffset + nextHeaderSize)
- {
- db.UnexpectedEnd = true;
- return S_FALSE;
- }
- RINOK(_stream->Seek(nextHeaderOffset, STREAM_SEEK_CUR, NULL));
-
- size_t nextHeaderSize_t = (size_t)nextHeaderSize;
- if (nextHeaderSize_t != nextHeaderSize)
- return E_OUTOFMEMORY;
- CByteBuffer buffer2(nextHeaderSize_t);
-
- RINOK(ReadStream_FALSE(_stream, buffer2, nextHeaderSize_t));
-
- if (CrcCalc(buffer2, nextHeaderSize_t) != nextHeaderCRC)
- ThrowIncorrect();
-
- if (!db.StartHeaderWasRecovered)
- db.PhySizeWasConfirmed = true;
-
- CStreamSwitch streamSwitch;
- streamSwitch.Set(this, buffer2);
-
- CObjectVector<CByteBuffer> dataVector;
-
- UInt64 type = ReadID();
- if (type != NID::kHeader)
- {
- if (type != NID::kEncodedHeader)
- ThrowIncorrect();
- HRESULT result = ReadAndDecodePackedStreams(
- EXTERNAL_CODECS_LOC_VARS
- db.ArcInfo.StartPositionAfterHeader,
- db.ArcInfo.DataStartPosition2,
- dataVector
- _7Z_DECODER_CRYPRO_VARS
- );
- RINOK(result);
- if (dataVector.Size() == 0)
- return S_OK;
- if (dataVector.Size() > 1)
- ThrowIncorrect();
- streamSwitch.Remove();
- streamSwitch.Set(this, dataVector.Front());
- if (ReadID() != NID::kHeader)
- ThrowIncorrect();
- }
-
- db.IsArc = true;
-
- db.HeadersSize = HeadersSize;
-
- return ReadHeader(
- EXTERNAL_CODECS_LOC_VARS
- db
- _7Z_DECODER_CRYPRO_VARS
- );
-}
-
-
-HRESULT CInArchive::ReadDatabase(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CDbEx &db
- _7Z_DECODER_CRYPRO_VARS_DECL
- )
-{
- try
- {
- HRESULT res = ReadDatabase2(
- EXTERNAL_CODECS_LOC_VARS db
- _7Z_DECODER_CRYPRO_VARS
- );
- if (ThereIsHeaderError)
- db.ThereIsHeaderError = true;
- if (res == E_NOTIMPL)
- ThrowUnsupported();
- return res;
- }
- catch(CUnsupportedFeatureException &)
- {
- db.UnsupportedFeatureError = true;
- return S_FALSE;
- }
- catch(CInArchiveException &)
- {
- db.ThereIsHeaderError = true;
- return S_FALSE;
- }
-}
-
-}}
+// 7zIn.cpp
+
+#include "StdAfx.h"
+
+#ifdef _WIN32
+#include <wchar.h>
+#else
+#include <ctype.h>
+#endif
+
+#include "../../../../C/7zCrc.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyBuffer2.h"
+// #include "../../../Common/UTFConvert.h"
+
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "7zDecode.h"
+#include "7zIn.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+// define FORMAT_7Z_RECOVERY if you want to recover multivolume archives with empty StartHeader
+#ifndef Z7_SFX
+#define FORMAT_7Z_RECOVERY
+#endif
+
+using namespace NWindows;
+using namespace NCOM;
+
+namespace NArchive {
+namespace N7z {
+
+#define k_Scan_NumCoders_MAX 64
+#define k_Scan_NumCodersStreams_in_Folder_MAX 64
+
+unsigned BoolVector_CountSum(const CBoolVector &v);
+unsigned BoolVector_CountSum(const CBoolVector &v)
+{
+ unsigned sum = 0;
+ const unsigned size = v.Size();
+ for (unsigned i = 0; i < size; i++)
+ if (v[i])
+ sum++;
+ return sum;
+}
+
+static inline bool BoolVector_Item_IsValidAndTrue(const CBoolVector &v, unsigned i)
+{
+ return (i < v.Size() ? v[i] : false);
+}
+
+static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
+{
+ v.ClearAndSetSize(size);
+ bool *p = &v[0];
+ for (unsigned i = 0; i < size; i++)
+ p[i] = false;
+}
+
+
+class CInArchiveException {};
+class CUnsupportedFeatureException: public CInArchiveException {};
+
+Z7_ATTR_NORETURN
+static void ThrowException() { throw CInArchiveException(); }
+Z7_ATTR_NORETURN
+static inline void ThrowEndOfData() { ThrowException(); }
+Z7_ATTR_NORETURN
+static inline void ThrowUnsupported() { throw CUnsupportedFeatureException(); }
+Z7_ATTR_NORETURN
+static inline void ThrowIncorrect() { ThrowException(); }
+
+class CStreamSwitch
+{
+ CInArchive *_archive;
+ bool _needRemove;
+ bool _needUpdatePos;
+public:
+ CStreamSwitch(): _needRemove(false), _needUpdatePos(false) {}
+ ~CStreamSwitch() { Remove(); }
+ void Remove();
+ void Set(CInArchive *archive, const Byte *data, size_t size, bool needUpdatePos);
+ void Set(CInArchive *archive, const CByteBuffer &byteBuffer);
+ void Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector);
+};
+
+void CStreamSwitch::Remove()
+{
+ if (_needRemove)
+ {
+ if (_archive->_inByteBack->GetRem() != 0)
+ _archive->ThereIsHeaderError = true;
+ _archive->DeleteByteStream(_needUpdatePos);
+ _needRemove = false;
+ }
+}
+
+void CStreamSwitch::Set(CInArchive *archive, const Byte *data, size_t size, bool needUpdatePos)
+{
+ Remove();
+ _archive = archive;
+ _archive->AddByteStream(data, size);
+ _needRemove = true;
+ _needUpdatePos = needUpdatePos;
+}
+
+void CStreamSwitch::Set(CInArchive *archive, const CByteBuffer &byteBuffer)
+{
+ Set(archive, byteBuffer, byteBuffer.Size(), false);
+}
+
+void CStreamSwitch::Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector)
+{
+ Remove();
+ const Byte external = archive->ReadByte();
+ if (external != 0)
+ {
+ if (!dataVector)
+ ThrowIncorrect();
+ const CNum dataIndex = archive->ReadNum();
+ if (dataIndex >= dataVector->Size())
+ ThrowIncorrect();
+ Set(archive, (*dataVector)[dataIndex]);
+ }
+}
+
+void CInArchive::AddByteStream(const Byte *buf, size_t size)
+{
+ if (_numInByteBufs == kNumBufLevelsMax)
+ ThrowIncorrect();
+ _inByteBack = &_inByteVector[_numInByteBufs++];
+ _inByteBack->Init(buf, size);
+}
+
+
+Byte CInByte2::ReadByte()
+{
+ if (_pos >= _size)
+ ThrowEndOfData();
+ return _buffer[_pos++];
+}
+
+void CInByte2::ReadBytes(Byte *data, size_t size)
+{
+ if (size == 0)
+ return;
+ if (size > _size - _pos)
+ ThrowEndOfData();
+ memcpy(data, _buffer + _pos, size);
+ _pos += size;
+}
+
+void CInByte2::SkipData(UInt64 size)
+{
+ if (size > _size - _pos)
+ ThrowEndOfData();
+ _pos += (size_t)size;
+}
+
+void CInByte2::SkipData()
+{
+ SkipData(ReadNumber());
+}
+
+static UInt64 ReadNumberSpec(const Byte *p, size_t size, size_t &processed)
+{
+ if (size == 0)
+ {
+ processed = 0;
+ return 0;
+ }
+
+ const unsigned b = *p++;
+ size--;
+
+ if ((b & 0x80) == 0)
+ {
+ processed = 1;
+ return b;
+ }
+
+ if (size == 0)
+ {
+ processed = 0;
+ return 0;
+ }
+
+ UInt64 value = (UInt64)*p;
+ p++;
+ size--;
+
+ for (unsigned i = 1; i < 8; i++)
+ {
+ const unsigned mask = (unsigned)0x80 >> i;
+ if ((b & mask) == 0)
+ {
+ const UInt64 high = b & (mask - 1);
+ value |= (high << (i * 8));
+ processed = i + 1;
+ return value;
+ }
+
+ if (size == 0)
+ {
+ processed = 0;
+ return 0;
+ }
+
+ value |= ((UInt64)*p << (i * 8));
+ p++;
+ size--;
+ }
+
+ processed = 9;
+ return value;
+}
+
+UInt64 CInByte2::ReadNumber()
+{
+ size_t processed;
+ const UInt64 res = ReadNumberSpec(_buffer + _pos, _size - _pos, processed);
+ if (processed == 0)
+ ThrowEndOfData();
+ _pos += processed;
+ return res;
+}
+
+CNum CInByte2::ReadNum()
+{
+ /*
+ if (_pos < _size)
+ {
+ Byte val = _buffer[_pos];
+ if ((unsigned)val < 0x80)
+ {
+ _pos++;
+ return (unsigned)val;
+ }
+ }
+ */
+ const UInt64 value = ReadNumber();
+ if (value > kNumMax)
+ ThrowUnsupported();
+ return (CNum)value;
+}
+
+UInt32 CInByte2::ReadUInt32()
+{
+ if (_pos + 4 > _size)
+ ThrowEndOfData();
+ const UInt32 res = Get32(_buffer + _pos);
+ _pos += 4;
+ return res;
+}
+
+UInt64 CInByte2::ReadUInt64()
+{
+ if (_pos + 8 > _size)
+ ThrowEndOfData();
+ const UInt64 res = Get64(_buffer + _pos);
+ _pos += 8;
+ return res;
+}
+
+#define Y0 '7'
+#define Y1 'z'
+#define Y2 0xBC
+#define Y3 0xAF
+#define Y4 0x27
+#define Y5 0x1C
+
+#define IS_SIGNATURE(p)( \
+ (p)[2] == Y2 && \
+ (p)[3] == Y3 && \
+ (p)[5] == Y5 && \
+ (p)[4] == Y4 && \
+ (p)[1] == Y1 && \
+ (p)[0] == Y0)
+
+/* FindSignature_10() is allowed to access data up to and including &limit[9].
+ limit[10] access is not allowed.
+ return:
+ (return_ptr < limit) : signature was found at (return_ptr)
+ (return_ptr >= limit) : limit was reached or crossed. So no signature found before limit
+*/
+Z7_NO_INLINE
+static const Byte *FindSignature_10(const Byte *p, const Byte *limit)
+{
+ for (;;)
+ {
+ for (;;)
+ {
+ if (p >= limit)
+ return limit;
+ const Byte b = p[5];
+ p += 6;
+ if (b == Y0) { break; }
+ if (b == Y1) { p -= 1; break; }
+ if (b == Y2) { p -= 2; break; }
+ if (b == Y3) { p -= 3; break; }
+ if (b == Y4) { p -= 4; break; }
+ if (b == Y5) { p -= 5; break; }
+ }
+ if (IS_SIGNATURE(p - 1))
+ return p - 1;
+ }
+}
+
+
+static inline bool TestStartCrc(const Byte *p)
+{
+ return CrcCalc(p + 12, 20) == Get32(p + 8);
+}
+
+static inline bool TestSignature2(const Byte *p)
+{
+ if (!IS_SIGNATURE(p))
+ return false;
+ #ifdef FORMAT_7Z_RECOVERY
+ if (TestStartCrc(p))
+ return true;
+ for (unsigned i = 8; i < kHeaderSize; i++)
+ if (p[i] != 0)
+ return false;
+ return (p[6] != 0 || p[7] != 0);
+ #else
+ return TestStartCrc(p);
+ #endif
+}
+
+
+HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
+{
+ RINOK(ReadStream_FALSE(stream, _header, kHeaderSize))
+
+ if (TestSignature2(_header))
+ return S_OK;
+ if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
+ return S_FALSE;
+
+ const UInt32 kBufSize = (1 << 15) + kHeaderSize; // must be > (kHeaderSize * 2)
+ CAlignedBuffer1 buf(kBufSize);
+ memcpy(buf, _header, kHeaderSize);
+ UInt64 offset = 0;
+
+ for (;;)
+ {
+ UInt32 readSize =
+ (offset == 0) ?
+ kBufSize - kHeaderSize - kHeaderSize :
+ kBufSize - kHeaderSize;
+ if (searchHeaderSizeLimit)
+ {
+ const UInt64 rem = *searchHeaderSizeLimit - offset;
+ if (readSize > rem)
+ readSize = (UInt32)rem;
+ if (readSize == 0)
+ return S_FALSE;
+ }
+
+ UInt32 processed = 0;
+ RINOK(stream->Read(buf + kHeaderSize, readSize, &processed))
+ if (processed == 0)
+ return S_FALSE;
+
+ /* &buf[0] was already tested for signature before.
+ So first search here will be for &buf[1] */
+
+ for (UInt32 pos = 0;;)
+ {
+ const Byte *p = buf + pos + 1;
+ const Byte *lim = buf + processed + 1;
+ /* we have (kHeaderSize - 1 = 31) filled bytes starting from (lim),
+ and it's safe to access just 10 bytes in that reserved area */
+ p = FindSignature_10(p, lim);
+ if (p >= lim)
+ break;
+ pos = (UInt32)(p - buf);
+ if (TestStartCrc(p))
+ {
+ memcpy(_header, p, kHeaderSize);
+ _arhiveBeginStreamPosition += offset + pos;
+ return InStream_SeekSet(stream, _arhiveBeginStreamPosition + kHeaderSize);
+ }
+ }
+
+ offset += processed;
+ memmove(buf, buf + processed, kHeaderSize);
+ }
+}
+
+// S_FALSE means that file is not archive
+HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
+{
+ HeadersSize = 0;
+ Close();
+ RINOK(InStream_GetPos_GetSize(stream, _arhiveBeginStreamPosition, _fileEndPosition))
+ RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit))
+ _stream = stream;
+ return S_OK;
+}
+
+void CInArchive::Close()
+{
+ _numInByteBufs = 0;
+ _stream.Release();
+ ThereIsHeaderError = false;
+}
+
+void CInArchive::ReadArchiveProperties(CInArchiveInfo & /* archiveInfo */)
+{
+ for (;;)
+ {
+ if (ReadID() == NID::kEnd)
+ break;
+ SkipData();
+ }
+}
+
+// CFolder &folder can be non empty. So we must set all fields
+
+void CInByte2::ParseFolder(CFolder &folder)
+{
+ const UInt32 numCoders = ReadNum();
+
+ if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
+ ThrowUnsupported();
+
+ folder.Coders.SetSize(numCoders);
+
+ UInt32 numInStreams = 0;
+ UInt32 i;
+ for (i = 0; i < numCoders; i++)
+ {
+ CCoderInfo &coder = folder.Coders[i];
+ {
+ const Byte mainByte = ReadByte();
+ if ((mainByte & 0xC0) != 0)
+ ThrowUnsupported();
+ const unsigned idSize = (mainByte & 0xF);
+ if (idSize > 8 || idSize > GetRem())
+ ThrowUnsupported();
+ const Byte *longID = GetPtr();
+ UInt64 id = 0;
+ for (unsigned j = 0; j < idSize; j++)
+ id = ((id << 8) | longID[j]);
+ SkipDataNoCheck(idSize);
+ coder.MethodID = id;
+
+ if ((mainByte & 0x10) != 0)
+ {
+ coder.NumStreams = ReadNum();
+ // if (coder.NumStreams > k_Scan_NumCodersStreams_in_Folder_MAX) ThrowUnsupported();
+ /* numOutStreams = */ ReadNum();
+ // if (ReadNum() != 1) // numOutStreams ThrowUnsupported();
+ }
+ else
+ {
+ coder.NumStreams = 1;
+ }
+
+ if ((mainByte & 0x20) != 0)
+ {
+ const CNum propsSize = ReadNum();
+ coder.Props.Alloc((size_t)propsSize);
+ ReadBytes((Byte *)coder.Props, (size_t)propsSize);
+ }
+ else
+ coder.Props.Free();
+ }
+ numInStreams += coder.NumStreams;
+ }
+
+ const UInt32 numBonds = numCoders - 1;
+ folder.Bonds.SetSize(numBonds);
+ for (i = 0; i < numBonds; i++)
+ {
+ CBond &bp = folder.Bonds[i];
+ bp.PackIndex = ReadNum();
+ bp.UnpackIndex = ReadNum();
+ }
+
+ if (numInStreams < numBonds)
+ ThrowUnsupported();
+ const UInt32 numPackStreams = numInStreams - numBonds;
+ folder.PackStreams.SetSize(numPackStreams);
+
+ if (numPackStreams == 1)
+ {
+ for (i = 0; i < numInStreams; i++)
+ if (folder.FindBond_for_PackStream(i) < 0)
+ {
+ folder.PackStreams[0] = i;
+ break;
+ }
+ if (i == numInStreams)
+ ThrowUnsupported();
+ }
+ else
+ for (i = 0; i < numPackStreams; i++)
+ folder.PackStreams[i] = ReadNum();
+}
+
+void CFolders::ParseFolderInfo(unsigned folderIndex, CFolder &folder) const
+{
+ const size_t startPos = FoCodersDataOffset[folderIndex];
+ CInByte2 inByte;
+ inByte.Init(CodersData + startPos, FoCodersDataOffset[folderIndex + 1] - startPos);
+ inByte.ParseFolder(folder);
+ if (inByte.GetRem() != 0)
+ throw 20120424;
+}
+
+
+void CDatabase::GetPath(unsigned index, UString &path) const
+{
+ path.Empty();
+ if (!NameOffsets || !NamesBuf)
+ return;
+
+ const size_t offset = NameOffsets[index];
+ const size_t size = NameOffsets[index + 1] - offset;
+
+ if (size >= (1 << 28))
+ return;
+
+ wchar_t *s = path.GetBuf((unsigned)size - 1);
+
+ const Byte *p = ((const Byte *)NamesBuf + offset * 2);
+
+ #if defined(_WIN32) && defined(MY_CPU_LE)
+
+ wmemcpy(s, (const wchar_t *)(const void *)p, size);
+
+ #else
+
+ for (size_t i = 0; i < size; i++)
+ {
+ *s = Get16(p);
+ p += 2;
+ s++;
+ }
+
+ #endif
+
+ path.ReleaseBuf_SetLen((unsigned)size - 1);
+}
+
+HRESULT CDatabase::GetPath_Prop(unsigned index, PROPVARIANT *path) const throw()
+{
+ PropVariant_Clear(path);
+ if (!NameOffsets || !NamesBuf)
+ return S_OK;
+
+ const size_t offset = NameOffsets[index];
+ const size_t size = NameOffsets[index + 1] - offset;
+
+ if (size >= (1 << 14))
+ return S_OK;
+
+ // (size) includes null terminator
+
+ /*
+ #if WCHAR_MAX > 0xffff
+
+ const Byte *p = ((const Byte *)NamesBuf + offset * 2);
+ size = Utf16LE__Get_Num_WCHARs(p, size - 1);
+ // (size) doesn't include null terminator
+ RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size));
+ wchar_t *s = path->bstrVal;
+ wchar_t *sEnd = Utf16LE__To_WCHARs_Sep(p, size, s);
+ *sEnd = 0;
+ if (s + size != sEnd) return E_FAIL;
+
+ #else
+ */
+
+ RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size - 1))
+ wchar_t *s = path->bstrVal;
+ const Byte *p = ((const Byte *)NamesBuf + offset * 2);
+ // Utf16LE__To_WCHARs_Sep(p, size, s);
+
+ for (size_t i = 0; i < size; i++)
+ {
+ wchar_t c = Get16(p);
+ p += 2;
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ if (c == L'/')
+ c = WCHAR_PATH_SEPARATOR;
+ else if (c == L'\\')
+ c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
+ #endif
+ *s++ = c;
+ }
+
+ // #endif
+
+ return S_OK;
+
+ /*
+ unsigned cur = index;
+ unsigned size = 0;
+
+ for (int i = 0;; i++)
+ {
+ size_t len = NameOffsets[cur + 1] - NameOffsets[cur];
+ size += (unsigned)len;
+ if (i > 256 || len > (1 << 14) || size > (1 << 14))
+ return PropVarEm_Set_Str(path, "[TOO-LONG]");
+ cur = Files[cur].Parent;
+ if (cur < 0)
+ break;
+ }
+ size--;
+
+ RINOK(PropVarEm_Alloc_Bstr(path, size));
+ wchar_t *s = path->bstrVal;
+ s += size;
+ *s = 0;
+ cur = index;
+
+ for (;;)
+ {
+ unsigned len = (unsigned)(NameOffsets[cur + 1] - NameOffsets[cur] - 1);
+ const Byte *p = (const Byte *)NamesBuf + (NameOffsets[cur + 1] * 2) - 2;
+ for (; len != 0; len--)
+ {
+ p -= 2;
+ --s;
+ wchar_t c = Get16(p);
+ if (c == '/')
+ c = WCHAR_PATH_SEPARATOR;
+ *s = c;
+ }
+
+ const CFileItem &file = Files[cur];
+ cur = file.Parent;
+ if (cur < 0)
+ return S_OK;
+ *(--s) = (file.IsAltStream ? ':' : WCHAR_PATH_SEPARATOR);
+ }
+ */
+}
+
+void CInArchive::WaitId(UInt64 id)
+{
+ for (;;)
+ {
+ const UInt64 type = ReadID();
+ if (type == id)
+ return;
+ if (type == NID::kEnd)
+ ThrowIncorrect();
+ SkipData();
+ }
+}
+
+
+void CInArchive::Read_UInt32_Vector(CUInt32DefVector &v)
+{
+ const unsigned numItems = v.Defs.Size();
+ v.Vals.ClearAndSetSize(numItems);
+ UInt32 *p = &v.Vals[0];
+ const bool *defs = &v.Defs[0];
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ UInt32 a = 0;
+ if (defs[i])
+ a = ReadUInt32();
+ p[i] = a;
+ }
+}
+
+
+void CInArchive::ReadHashDigests(unsigned numItems, CUInt32DefVector &crcs)
+{
+ ReadBoolVector2(numItems, crcs.Defs);
+ Read_UInt32_Vector(crcs);
+}
+
+
+void CInArchive::ReadPackInfo(CFolders &f)
+{
+ const CNum numPackStreams = ReadNum();
+
+ WaitId(NID::kSize);
+ f.PackPositions.Alloc(numPackStreams + 1);
+ f.NumPackStreams = numPackStreams;
+ UInt64 sum = 0;
+ for (CNum i = 0; i < numPackStreams; i++)
+ {
+ f.PackPositions[i] = sum;
+ const UInt64 packSize = ReadNumber();
+ sum += packSize;
+ if (sum < packSize)
+ ThrowIncorrect();
+ }
+ f.PackPositions[numPackStreams] = sum;
+
+ UInt64 type;
+ for (;;)
+ {
+ type = ReadID();
+ if (type == NID::kEnd)
+ return;
+ if (type == NID::kCRC)
+ {
+ CUInt32DefVector PackCRCs;
+ ReadHashDigests(numPackStreams, PackCRCs);
+ continue;
+ }
+ SkipData();
+ }
+}
+
+void CInArchive::ReadUnpackInfo(
+ const CObjectVector<CByteBuffer> *dataVector,
+ CFolders &folders)
+{
+ WaitId(NID::kFolder);
+ const CNum numFolders = ReadNum();
+
+ CNum numCodersOutStreams = 0;
+ {
+ CStreamSwitch streamSwitch;
+ streamSwitch.Set(this, dataVector);
+ const Byte *startBufPtr = _inByteBack->GetPtr();
+ folders.NumFolders = numFolders;
+
+ folders.FoStartPackStreamIndex.Alloc(numFolders + 1);
+ folders.FoToMainUnpackSizeIndex.Alloc(numFolders);
+ folders.FoCodersDataOffset.Alloc(numFolders + 1);
+ folders.FoToCoderUnpackSizes.Alloc(numFolders + 1);
+
+ CBoolVector StreamUsed;
+ CBoolVector CoderUsed;
+
+ CNum packStreamIndex = 0;
+ CNum fo;
+ CInByte2 *inByte = _inByteBack;
+
+ for (fo = 0; fo < numFolders; fo++)
+ {
+ UInt32 indexOfMainStream = 0;
+ UInt32 numPackStreams = 0;
+ folders.FoCodersDataOffset[fo] = (size_t)(_inByteBack->GetPtr() - startBufPtr);
+
+ CNum numInStreams = 0;
+ const CNum numCoders = inByte->ReadNum();
+
+ if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
+ ThrowUnsupported();
+
+ for (CNum ci = 0; ci < numCoders; ci++)
+ {
+ const Byte mainByte = inByte->ReadByte();
+ if ((mainByte & 0xC0) != 0)
+ ThrowUnsupported();
+
+ const unsigned idSize = (mainByte & 0xF);
+ if (idSize > 8)
+ ThrowUnsupported();
+ if (idSize > inByte->GetRem())
+ ThrowEndOfData();
+ const Byte *longID = inByte->GetPtr();
+ UInt64 id = 0;
+ for (unsigned j = 0; j < idSize; j++)
+ id = ((id << 8) | longID[j]);
+ inByte->SkipDataNoCheck(idSize);
+ if (folders.ParsedMethods.IDs.Size() < 128)
+ folders.ParsedMethods.IDs.AddToUniqueSorted(id);
+
+ CNum coderInStreams = 1;
+ if ((mainByte & 0x10) != 0)
+ {
+ coderInStreams = inByte->ReadNum();
+ if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)
+ ThrowUnsupported();
+ if (inByte->ReadNum() != 1)
+ ThrowUnsupported();
+ }
+
+ numInStreams += coderInStreams;
+ if (numInStreams > k_Scan_NumCodersStreams_in_Folder_MAX)
+ ThrowUnsupported();
+
+ if ((mainByte & 0x20) != 0)
+ {
+ const CNum propsSize = inByte->ReadNum();
+ if (propsSize > inByte->GetRem())
+ ThrowEndOfData();
+ if (id == k_LZMA2 && propsSize == 1)
+ {
+ const Byte v = *_inByteBack->GetPtr();
+ if (folders.ParsedMethods.Lzma2Prop < v)
+ folders.ParsedMethods.Lzma2Prop = v;
+ }
+ else if (id == k_LZMA && propsSize == 5)
+ {
+ const UInt32 dicSize = GetUi32(_inByteBack->GetPtr() + 1);
+ if (folders.ParsedMethods.LzmaDic < dicSize)
+ folders.ParsedMethods.LzmaDic = dicSize;
+ }
+ inByte->SkipDataNoCheck((size_t)propsSize);
+ }
+ }
+
+ if (numCoders == 1 && numInStreams == 1)
+ {
+ indexOfMainStream = 0;
+ numPackStreams = 1;
+ }
+ else
+ {
+ UInt32 i;
+ const CNum numBonds = numCoders - 1;
+ if (numInStreams < numBonds)
+ ThrowUnsupported();
+
+ BoolVector_Fill_False(StreamUsed, numInStreams);
+ BoolVector_Fill_False(CoderUsed, numCoders);
+
+ for (i = 0; i < numBonds; i++)
+ {
+ CNum index = ReadNum();
+ if (index >= numInStreams || StreamUsed[index])
+ ThrowUnsupported();
+ StreamUsed[index] = true;
+
+ index = ReadNum();
+ if (index >= numCoders || CoderUsed[index])
+ ThrowUnsupported();
+ CoderUsed[index] = true;
+ }
+
+ numPackStreams = numInStreams - numBonds;
+
+ if (numPackStreams != 1)
+ for (i = 0; i < numPackStreams; i++)
+ {
+ const CNum index = inByte->ReadNum(); // PackStreams
+ if (index >= numInStreams || StreamUsed[index])
+ ThrowUnsupported();
+ StreamUsed[index] = true;
+ }
+
+ for (i = 0; i < numCoders; i++)
+ if (!CoderUsed[i])
+ {
+ indexOfMainStream = i;
+ break;
+ }
+
+ if (i == numCoders)
+ ThrowUnsupported();
+ }
+
+ folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
+ numCodersOutStreams += numCoders;
+ folders.FoStartPackStreamIndex[fo] = packStreamIndex;
+ if (numPackStreams > folders.NumPackStreams - packStreamIndex)
+ ThrowIncorrect();
+ packStreamIndex += numPackStreams;
+ folders.FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;
+ }
+
+ const size_t dataSize = (size_t)(_inByteBack->GetPtr() - startBufPtr);
+ folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
+ folders.FoStartPackStreamIndex[fo] = packStreamIndex;
+ folders.FoCodersDataOffset[fo] = (size_t)(_inByteBack->GetPtr() - startBufPtr);
+ folders.CodersData.CopyFrom(startBufPtr, dataSize);
+
+ // if (folders.NumPackStreams != packStreamIndex) ThrowUnsupported();
+ }
+
+ WaitId(NID::kCodersUnpackSize);
+ folders.CoderUnpackSizes.Alloc(numCodersOutStreams);
+ for (CNum i = 0; i < numCodersOutStreams; i++)
+ folders.CoderUnpackSizes[i] = ReadNumber();
+
+ for (;;)
+ {
+ const UInt64 type = ReadID();
+ if (type == NID::kEnd)
+ return;
+ if (type == NID::kCRC)
+ {
+ ReadHashDigests(numFolders, folders.FolderCRCs);
+ continue;
+ }
+ SkipData();
+ }
+}
+
+void CInArchive::ReadSubStreamsInfo(
+ CFolders &folders,
+ CRecordVector<UInt64> &unpackSizes,
+ CUInt32DefVector &digests)
+{
+ folders.NumUnpackStreamsVector.Alloc(folders.NumFolders);
+ CNum i;
+ for (i = 0; i < folders.NumFolders; i++)
+ folders.NumUnpackStreamsVector[i] = 1;
+
+ UInt64 type;
+
+ for (;;)
+ {
+ type = ReadID();
+ if (type == NID::kNumUnpackStream)
+ {
+ for (i = 0; i < folders.NumFolders; i++)
+ folders.NumUnpackStreamsVector[i] = ReadNum();
+ continue;
+ }
+ if (type == NID::kCRC || type == NID::kSize || type == NID::kEnd)
+ break;
+ SkipData();
+ }
+
+ if (type == NID::kSize)
+ {
+ for (i = 0; i < folders.NumFolders; i++)
+ {
+ // v3.13 incorrectly worked with empty folders
+ // v4.07: we check that folder is empty
+ const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+ if (numSubstreams == 0)
+ continue;
+ UInt64 sum = 0;
+ for (CNum j = 1; j < numSubstreams; j++)
+ {
+ const UInt64 size = ReadNumber();
+ unpackSizes.Add(size);
+ sum += size;
+ if (sum < size)
+ ThrowIncorrect();
+ }
+ const UInt64 folderUnpackSize = folders.GetFolderUnpackSize(i);
+ if (folderUnpackSize < sum)
+ ThrowIncorrect();
+ unpackSizes.Add(folderUnpackSize - sum);
+ }
+ type = ReadID();
+ }
+ else
+ {
+ for (i = 0; i < folders.NumFolders; i++)
+ {
+ /* v9.26 - v9.29 incorrectly worked:
+ if (folders.NumUnpackStreamsVector[i] == 0), it threw error */
+ const CNum val = folders.NumUnpackStreamsVector[i];
+ if (val > 1)
+ ThrowIncorrect();
+ if (val == 1)
+ unpackSizes.Add(folders.GetFolderUnpackSize(i));
+ }
+ }
+
+ unsigned numDigests = 0;
+ for (i = 0; i < folders.NumFolders; i++)
+ {
+ const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+ if (numSubstreams != 1 || !folders.FolderCRCs.ValidAndDefined(i))
+ numDigests += numSubstreams;
+ }
+
+ for (;;)
+ {
+ if (type == NID::kEnd)
+ break;
+ if (type == NID::kCRC)
+ {
+ // CUInt32DefVector digests2;
+ // ReadHashDigests(numDigests, digests2);
+ CBoolVector digests2;
+ ReadBoolVector2(numDigests, digests2);
+
+ digests.ClearAndSetSize(unpackSizes.Size());
+
+ unsigned k = 0;
+ unsigned k2 = 0;
+
+ for (i = 0; i < folders.NumFolders; i++)
+ {
+ const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+ if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
+ {
+ digests.Defs[k] = true;
+ digests.Vals[k] = folders.FolderCRCs.Vals[i];
+ k++;
+ }
+ else for (CNum j = 0; j < numSubstreams; j++)
+ {
+ bool defined = digests2[k2++];
+ digests.Defs[k] = defined;
+ UInt32 crc = 0;
+ if (defined)
+ crc = ReadUInt32();
+ digests.Vals[k] = crc;
+ k++;
+ }
+ }
+ // if (k != unpackSizes.Size()) throw 1234567;
+ }
+ else
+ SkipData();
+
+ type = ReadID();
+ }
+
+ if (digests.Defs.Size() != unpackSizes.Size())
+ {
+ digests.ClearAndSetSize(unpackSizes.Size());
+ unsigned k = 0;
+ for (i = 0; i < folders.NumFolders; i++)
+ {
+ const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+ if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
+ {
+ digests.Defs[k] = true;
+ digests.Vals[k] = folders.FolderCRCs.Vals[i];
+ k++;
+ }
+ else for (CNum j = 0; j < numSubstreams; j++)
+ {
+ digests.Defs[k] = false;
+ digests.Vals[k] = 0;
+ k++;
+ }
+ }
+ }
+}
+
+
+
+void CInArchive::ReadStreamsInfo(
+ const CObjectVector<CByteBuffer> *dataVector,
+ UInt64 &dataOffset,
+ CFolders &folders,
+ CRecordVector<UInt64> &unpackSizes,
+ CUInt32DefVector &digests)
+{
+ UInt64 type = ReadID();
+
+ if (type == NID::kPackInfo)
+ {
+ dataOffset = ReadNumber();
+ if (dataOffset > _rangeLimit)
+ ThrowIncorrect();
+ ReadPackInfo(folders);
+ if (folders.PackPositions[folders.NumPackStreams] > _rangeLimit - dataOffset)
+ ThrowIncorrect();
+ type = ReadID();
+ }
+
+ if (type == NID::kUnpackInfo)
+ {
+ ReadUnpackInfo(dataVector, folders);
+ type = ReadID();
+ }
+
+ if (folders.NumFolders != 0 && !folders.PackPositions)
+ {
+ // if there are folders, we need PackPositions also
+ folders.PackPositions.Alloc(1);
+ folders.PackPositions[0] = 0;
+ }
+
+ if (type == NID::kSubStreamsInfo)
+ {
+ ReadSubStreamsInfo(folders, unpackSizes, digests);
+ type = ReadID();
+ }
+ else
+ {
+ folders.NumUnpackStreamsVector.Alloc(folders.NumFolders);
+ /* If digests.Defs.Size() == 0, it means that there are no crcs.
+ So we don't need to fill digests with values. */
+ // digests.Vals.ClearAndSetSize(folders.NumFolders);
+ // BoolVector_Fill_False(digests.Defs, folders.NumFolders);
+ for (CNum i = 0; i < folders.NumFolders; i++)
+ {
+ folders.NumUnpackStreamsVector[i] = 1;
+ unpackSizes.Add(folders.GetFolderUnpackSize(i));
+ // digests.Vals[i] = 0;
+ }
+ }
+
+ if (type != NID::kEnd)
+ ThrowIncorrect();
+}
+
+void CInArchive::ReadBoolVector(unsigned numItems, CBoolVector &v)
+{
+ v.ClearAndSetSize(numItems);
+ Byte b = 0;
+ Byte mask = 0;
+ bool *p = &v[0];
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ if (mask == 0)
+ {
+ b = ReadByte();
+ mask = 0x80;
+ }
+ p[i] = ((b & mask) != 0);
+ mask = (Byte)(mask >> 1);
+ }
+}
+
+void CInArchive::ReadBoolVector2(unsigned numItems, CBoolVector &v)
+{
+ const Byte allAreDefined = ReadByte();
+ if (allAreDefined == 0)
+ {
+ ReadBoolVector(numItems, v);
+ return;
+ }
+ v.ClearAndSetSize(numItems);
+ bool *p = &v[0];
+ for (unsigned i = 0; i < numItems; i++)
+ p[i] = true;
+}
+
+void CInArchive::ReadUInt64DefVector(const CObjectVector<CByteBuffer> &dataVector,
+ CUInt64DefVector &v, unsigned numItems)
+{
+ ReadBoolVector2(numItems, v.Defs);
+
+ CStreamSwitch streamSwitch;
+ streamSwitch.Set(this, &dataVector);
+
+ v.Vals.ClearAndSetSize(numItems);
+ UInt64 *p = &v.Vals[0];
+ const bool *defs = &v.Defs[0];
+
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ UInt64 t = 0;
+ if (defs[i])
+ t = ReadUInt64();
+ p[i] = t;
+ }
+}
+
+HRESULT CInArchive::ReadAndDecodePackedStreams(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ UInt64 baseOffset,
+ UInt64 &dataOffset, CObjectVector<CByteBuffer> &dataVector
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ )
+{
+ CFolders folders;
+ CRecordVector<UInt64> unpackSizes;
+ CUInt32DefVector digests;
+
+ ReadStreamsInfo(NULL,
+ dataOffset,
+ folders,
+ unpackSizes,
+ digests);
+
+ CDecoder decoder(_useMixerMT);
+
+ for (CNum i = 0; i < folders.NumFolders; i++)
+ {
+ CByteBuffer &data = dataVector.AddNew();
+ const UInt64 unpackSize64 = folders.GetFolderUnpackSize(i);
+ const size_t unpackSize = (size_t)unpackSize64;
+ if (unpackSize != unpackSize64)
+ ThrowUnsupported();
+ data.Alloc(unpackSize);
+
+ CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
+ CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+ outStreamSpec->Init(data, unpackSize);
+
+ bool dataAfterEnd_Error = false;
+
+ HRESULT result = decoder.Decode(
+ EXTERNAL_CODECS_LOC_VARS
+ _stream, baseOffset + dataOffset,
+ folders, i,
+ NULL, // &unpackSize64
+
+ outStream,
+ NULL, // *compressProgress
+
+ NULL // **inStreamMainRes
+ , dataAfterEnd_Error
+
+ Z7_7Z_DECODER_CRYPRO_VARS
+ #if !defined(Z7_ST)
+ , false // mtMode
+ , 1 // numThreads
+ , 0 // memUsage
+ #endif
+ );
+
+ RINOK(result)
+
+ if (dataAfterEnd_Error)
+ ThereIsHeaderError = true;
+
+ if (unpackSize != outStreamSpec->GetPos())
+ ThrowIncorrect();
+
+ if (folders.FolderCRCs.ValidAndDefined(i))
+ if (CrcCalc(data, unpackSize) != folders.FolderCRCs.Vals[i])
+ ThrowIncorrect();
+ }
+
+ if (folders.PackPositions)
+ HeadersSize += folders.PackPositions[folders.NumPackStreams];
+
+ return S_OK;
+}
+
+HRESULT CInArchive::ReadHeader(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CDbEx &db
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ )
+{
+ UInt64 type = ReadID();
+
+ if (type == NID::kArchiveProperties)
+ {
+ ReadArchiveProperties(db.ArcInfo);
+ type = ReadID();
+ }
+
+ CObjectVector<CByteBuffer> dataVector;
+
+ if (type == NID::kAdditionalStreamsInfo)
+ {
+ const HRESULT result = ReadAndDecodePackedStreams(
+ EXTERNAL_CODECS_LOC_VARS
+ db.ArcInfo.StartPositionAfterHeader,
+ db.ArcInfo.DataStartPosition2,
+ dataVector
+ Z7_7Z_DECODER_CRYPRO_VARS
+ );
+ RINOK(result)
+ db.ArcInfo.DataStartPosition2 += db.ArcInfo.StartPositionAfterHeader;
+ type = ReadID();
+ }
+
+ CRecordVector<UInt64> unpackSizes;
+ CUInt32DefVector digests;
+
+ if (type == NID::kMainStreamsInfo)
+ {
+ ReadStreamsInfo(&dataVector,
+ db.ArcInfo.DataStartPosition,
+ (CFolders &)db,
+ unpackSizes,
+ digests);
+ db.ArcInfo.DataStartPosition += db.ArcInfo.StartPositionAfterHeader;
+ type = ReadID();
+ }
+
+ if (type == NID::kFilesInfo)
+ {
+
+ const CNum numFiles = ReadNum();
+
+ db.ArcInfo.FileInfoPopIDs.Add(NID::kSize);
+ // if (!db.PackSizes.IsEmpty())
+ db.ArcInfo.FileInfoPopIDs.Add(NID::kPackInfo);
+ if (numFiles > 0 && !digests.Defs.IsEmpty())
+ db.ArcInfo.FileInfoPopIDs.Add(NID::kCRC);
+
+ CBoolVector emptyStreamVector;
+ CBoolVector emptyFileVector;
+ CBoolVector antiFileVector;
+ CNum numEmptyStreams = 0;
+
+ for (;;)
+ {
+ const UInt64 type2 = ReadID();
+ if (type2 == NID::kEnd)
+ break;
+ const UInt64 size = ReadNumber();
+ if (size > _inByteBack->GetRem())
+ ThrowIncorrect();
+ CStreamSwitch switchProp;
+ switchProp.Set(this, _inByteBack->GetPtr(), (size_t)size, true);
+ bool addPropIdToList = true;
+ bool isKnownType = true;
+ if (type2 > ((UInt32)1 << 30))
+ isKnownType = false;
+ else switch ((UInt32)type2)
+ {
+ case NID::kName:
+ {
+ CStreamSwitch streamSwitch;
+ streamSwitch.Set(this, &dataVector);
+ const size_t rem = _inByteBack->GetRem();
+ db.NamesBuf.Alloc(rem);
+ ReadBytes(db.NamesBuf, rem);
+ db.NameOffsets.Alloc(numFiles + 1);
+ size_t pos = 0;
+ unsigned i;
+ for (i = 0; i < numFiles; i++)
+ {
+ const size_t curRem = (rem - pos) / 2;
+ const UInt16 *buf = (const UInt16 *)(const void *)(db.NamesBuf + pos);
+ size_t j;
+ for (j = 0; j < curRem && buf[j] != 0; j++);
+ if (j == curRem)
+ ThrowEndOfData();
+ db.NameOffsets[i] = pos / 2;
+ pos += j * 2 + 2;
+ }
+ db.NameOffsets[i] = pos / 2;
+ if (pos != rem)
+ ThereIsHeaderError = true;
+ break;
+ }
+
+ case NID::kWinAttrib:
+ {
+ ReadBoolVector2(numFiles, db.Attrib.Defs);
+ CStreamSwitch streamSwitch;
+ streamSwitch.Set(this, &dataVector);
+ Read_UInt32_Vector(db.Attrib);
+ break;
+ }
+
+ /*
+ case NID::kIsAux:
+ {
+ ReadBoolVector(numFiles, db.IsAux);
+ break;
+ }
+ case NID::kParent:
+ {
+ db.IsTree = true;
+ // CBoolVector boolVector;
+ // ReadBoolVector2(numFiles, boolVector);
+ // CStreamSwitch streamSwitch;
+ // streamSwitch.Set(this, &dataVector);
+ CBoolVector boolVector;
+ ReadBoolVector2(numFiles, boolVector);
+
+ db.ThereAreAltStreams = false;
+ for (i = 0; i < numFiles; i++)
+ {
+ CFileItem &file = db.Files[i];
+ // file.Parent = -1;
+ // if (boolVector[i])
+ file.Parent = (int)ReadUInt32();
+ file.IsAltStream = !boolVector[i];
+ if (file.IsAltStream)
+ db.ThereAreAltStreams = true;
+ }
+ break;
+ }
+ */
+ case NID::kEmptyStream:
+ {
+ ReadBoolVector(numFiles, emptyStreamVector);
+ numEmptyStreams = BoolVector_CountSum(emptyStreamVector);
+ emptyFileVector.Clear();
+ antiFileVector.Clear();
+ break;
+ }
+ case NID::kEmptyFile: ReadBoolVector(numEmptyStreams, emptyFileVector); break;
+ case NID::kAnti: ReadBoolVector(numEmptyStreams, antiFileVector); break;
+ case NID::kStartPos: ReadUInt64DefVector(dataVector, db.StartPos, (unsigned)numFiles); break;
+ case NID::kCTime: ReadUInt64DefVector(dataVector, db.CTime, (unsigned)numFiles); break;
+ case NID::kATime: ReadUInt64DefVector(dataVector, db.ATime, (unsigned)numFiles); break;
+ case NID::kMTime: ReadUInt64DefVector(dataVector, db.MTime, (unsigned)numFiles); break;
+ case NID::kDummy:
+ {
+ for (UInt64 j = 0; j < size; j++)
+ if (ReadByte() != 0)
+ ThereIsHeaderError = true;
+ addPropIdToList = false;
+ break;
+ }
+ /*
+ case NID::kNtSecure:
+ {
+ try
+ {
+ {
+ CStreamSwitch streamSwitch;
+ streamSwitch.Set(this, &dataVector);
+ UInt32 numDescriptors = ReadUInt32();
+ size_t offset = 0;
+ db.SecureOffsets.Clear();
+ for (i = 0; i < numDescriptors; i++)
+ {
+ UInt32 size = ReadUInt32();
+ db.SecureOffsets.Add(offset);
+ offset += size;
+ }
+ // ThrowIncorrect();;
+ db.SecureOffsets.Add(offset);
+ db.SecureBuf.SetCapacity(offset);
+ for (i = 0; i < numDescriptors; i++)
+ {
+ offset = db.SecureOffsets[i];
+ ReadBytes(db.SecureBuf + offset, db.SecureOffsets[i + 1] - offset);
+ }
+ db.SecureIDs.Clear();
+ for (unsigned i = 0; i < numFiles; i++)
+ {
+ db.SecureIDs.Add(ReadNum());
+ // db.SecureIDs.Add(ReadUInt32());
+ }
+ // ReadUInt32();
+ if (_inByteBack->GetRem() != 0)
+ ThrowIncorrect();;
+ }
+ }
+ catch(CInArchiveException &)
+ {
+ ThereIsHeaderError = true;
+ addPropIdToList = isKnownType = false;
+ db.ClearSecure();
+ }
+ break;
+ }
+ */
+ default:
+ addPropIdToList = isKnownType = false;
+ }
+ if (isKnownType)
+ {
+ if (addPropIdToList)
+ db.ArcInfo.FileInfoPopIDs.Add(type2);
+ }
+ else
+ {
+ db.UnsupportedFeatureWarning = true;
+ _inByteBack->SkipRem();
+ }
+ // SkipData worked incorrectly in some versions before v4.59 (7zVer <= 0.02)
+ if (_inByteBack->GetRem() != 0)
+ ThrowIncorrect();
+ }
+
+ type = ReadID(); // Read (NID::kEnd) end of headers
+
+ if (numFiles - numEmptyStreams != unpackSizes.Size())
+ ThrowUnsupported();
+
+ CNum emptyFileIndex = 0;
+ CNum sizeIndex = 0;
+
+ const CNum numAntiItems = BoolVector_CountSum(antiFileVector);
+
+ if (numAntiItems != 0)
+ db.IsAnti.ClearAndSetSize(numFiles);
+
+ db.Files.ClearAndSetSize(numFiles);
+
+ for (CNum i = 0; i < numFiles; i++)
+ {
+ CFileItem &file = db.Files[i];
+ bool isAnti;
+ file.Crc = 0;
+ if (!BoolVector_Item_IsValidAndTrue(emptyStreamVector, i))
+ {
+ file.HasStream = true;
+ file.IsDir = false;
+ isAnti = false;
+ file.Size = unpackSizes[sizeIndex];
+ file.CrcDefined = digests.ValidAndDefined(sizeIndex);
+ if (file.CrcDefined)
+ file.Crc = digests.Vals[sizeIndex];
+ sizeIndex++;
+ }
+ else
+ {
+ file.HasStream = false;
+ file.IsDir = !BoolVector_Item_IsValidAndTrue(emptyFileVector, emptyFileIndex);
+ isAnti = BoolVector_Item_IsValidAndTrue(antiFileVector, emptyFileIndex);
+ emptyFileIndex++;
+ file.Size = 0;
+ file.CrcDefined = false;
+ }
+ if (numAntiItems != 0)
+ db.IsAnti[i] = isAnti;
+ }
+
+ }
+
+ db.FillLinks();
+
+ if (type != NID::kEnd || _inByteBack->GetRem() != 0)
+ {
+ db.UnsupportedFeatureWarning = true;
+ // ThrowIncorrect();
+ }
+
+ return S_OK;
+}
+
+
+void CDbEx::FillLinks()
+{
+ FolderStartFileIndex.Alloc(NumFolders);
+ FileIndexToFolderIndexMap.Alloc(Files.Size());
+
+ CNum folderIndex = 0;
+ CNum indexInFolder = 0;
+ unsigned i;
+
+ for (i = 0; i < Files.Size(); i++)
+ {
+ const bool emptyStream = !Files[i].HasStream;
+ if (indexInFolder == 0)
+ {
+ if (emptyStream)
+ {
+ FileIndexToFolderIndexMap[i] = kNumNoIndex;
+ continue;
+ }
+ // v3.13 incorrectly worked with empty folders
+ // v4.07: we skip empty folders
+ for (;;)
+ {
+ if (folderIndex >= NumFolders)
+ ThrowIncorrect();
+ FolderStartFileIndex[folderIndex] = i;
+ if (NumUnpackStreamsVector[folderIndex] != 0)
+ break;
+ folderIndex++;
+ }
+ }
+ FileIndexToFolderIndexMap[i] = folderIndex;
+ if (emptyStream)
+ continue;
+ if (++indexInFolder >= NumUnpackStreamsVector[folderIndex])
+ {
+ folderIndex++;
+ indexInFolder = 0;
+ }
+ }
+
+ if (indexInFolder != 0)
+ {
+ folderIndex++;
+ // 18.06
+ ThereIsHeaderError = true;
+ // ThrowIncorrect();
+ }
+
+ for (;;)
+ {
+ if (folderIndex >= NumFolders)
+ return;
+ FolderStartFileIndex[folderIndex] = i;
+ if (NumUnpackStreamsVector[folderIndex] != 0)
+ {
+ // 18.06
+ ThereIsHeaderError = true;
+ // ThrowIncorrect();
+ }
+ folderIndex++;
+ }
+}
+
+
+HRESULT CInArchive::ReadDatabase2(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CDbEx &db
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ )
+{
+ db.Clear();
+ db.ArcInfo.StartPosition = _arhiveBeginStreamPosition;
+
+ db.ArcInfo.Version.Major = _header[6];
+ db.ArcInfo.Version.Minor = _header[7];
+
+ if (db.ArcInfo.Version.Major != kMajorVersion)
+ {
+ // db.UnsupportedVersion = true;
+ return S_FALSE;
+ }
+
+ UInt64 nextHeaderOffset = Get64(_header + 12);
+ UInt64 nextHeaderSize = Get64(_header + 20);
+ UInt32 nextHeaderCRC = Get32(_header + 28);
+
+ #ifdef FORMAT_7Z_RECOVERY
+ const UInt32 crcFromArc = Get32(_header + 8);
+ if (crcFromArc == 0 && nextHeaderOffset == 0 && nextHeaderSize == 0 && nextHeaderCRC == 0)
+ {
+ UInt64 cur, fileSize;
+ RINOK(InStream_GetPos(_stream, cur))
+ const unsigned kCheckSize = 512;
+ Byte buf[kCheckSize];
+ RINOK(InStream_GetSize_SeekToEnd(_stream, fileSize))
+ const UInt64 rem = fileSize - cur;
+ unsigned checkSize = kCheckSize;
+ if (rem < kCheckSize)
+ checkSize = (unsigned)(rem);
+ if (checkSize < 3)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(_stream, fileSize - checkSize))
+ RINOK(ReadStream_FALSE(_stream, buf, (size_t)checkSize))
+
+ if (buf[checkSize - 1] != 0)
+ return S_FALSE;
+
+ unsigned i;
+ for (i = checkSize - 2;; i--)
+ {
+ if ((buf[i] == NID::kEncodedHeader && buf[i + 1] == NID::kPackInfo) ||
+ (buf[i] == NID::kHeader && buf[i + 1] == NID::kMainStreamsInfo))
+ break;
+ if (i == 0)
+ return S_FALSE;
+ }
+ nextHeaderSize = checkSize - i;
+ nextHeaderOffset = rem - nextHeaderSize;
+ nextHeaderCRC = CrcCalc(buf + i, (size_t)nextHeaderSize);
+ RINOK(InStream_SeekSet(_stream, cur))
+ db.StartHeaderWasRecovered = true;
+ }
+ else
+ #endif
+ {
+ // Crc was tested already at signature check
+ // if (CrcCalc(_header + 12, 20) != crcFromArchive) ThrowIncorrect();
+ }
+
+ db.ArcInfo.StartPositionAfterHeader = _arhiveBeginStreamPosition + kHeaderSize;
+ db.PhySize = kHeaderSize;
+
+ db.IsArc = false;
+ if ((Int64)nextHeaderOffset < 0 ||
+ nextHeaderSize > ((UInt64)1 << 62))
+ return S_FALSE;
+
+ HeadersSize = kHeaderSize;
+
+ if (nextHeaderSize == 0)
+ {
+ if (nextHeaderOffset != 0)
+ return S_FALSE;
+ db.IsArc = true;
+ db.HeadersSize = HeadersSize;
+ return S_OK;
+ }
+
+ if (!db.StartHeaderWasRecovered)
+ db.IsArc = true;
+
+ HeadersSize += nextHeaderSize;
+ // db.EndHeaderOffset = nextHeaderOffset;
+ _rangeLimit = nextHeaderOffset;
+
+ db.PhySize = kHeaderSize + nextHeaderOffset + nextHeaderSize;
+ if (_fileEndPosition - db.ArcInfo.StartPositionAfterHeader < nextHeaderOffset + nextHeaderSize)
+ {
+ db.UnexpectedEnd = true;
+ return S_FALSE;
+ }
+ RINOK(_stream->Seek((Int64)nextHeaderOffset, STREAM_SEEK_CUR, NULL))
+
+ const size_t nextHeaderSize_t = (size_t)nextHeaderSize;
+ if (nextHeaderSize_t != nextHeaderSize)
+ return E_OUTOFMEMORY;
+ CByteBuffer buffer2(nextHeaderSize_t);
+
+ RINOK(ReadStream_FALSE(_stream, buffer2, nextHeaderSize_t))
+
+ if (CrcCalc(buffer2, nextHeaderSize_t) != nextHeaderCRC)
+ ThrowIncorrect();
+
+ if (!db.StartHeaderWasRecovered)
+ db.PhySizeWasConfirmed = true;
+
+ CStreamSwitch streamSwitch;
+ streamSwitch.Set(this, buffer2);
+
+ CObjectVector<CByteBuffer> dataVector;
+
+ const UInt64 type = ReadID();
+ if (type != NID::kHeader)
+ {
+ if (type != NID::kEncodedHeader)
+ ThrowIncorrect();
+ const HRESULT result = ReadAndDecodePackedStreams(
+ EXTERNAL_CODECS_LOC_VARS
+ db.ArcInfo.StartPositionAfterHeader,
+ db.ArcInfo.DataStartPosition2,
+ dataVector
+ Z7_7Z_DECODER_CRYPRO_VARS
+ );
+ RINOK(result)
+ if (dataVector.Size() == 0)
+ return S_OK;
+ if (dataVector.Size() > 1)
+ ThrowIncorrect();
+ streamSwitch.Remove();
+ streamSwitch.Set(this, dataVector.Front());
+ if (ReadID() != NID::kHeader)
+ ThrowIncorrect();
+ }
+
+ db.IsArc = true;
+
+ db.HeadersSize = HeadersSize;
+
+ return ReadHeader(
+ EXTERNAL_CODECS_LOC_VARS
+ db
+ Z7_7Z_DECODER_CRYPRO_VARS
+ );
+}
+
+
+HRESULT CInArchive::ReadDatabase(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CDbEx &db
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ )
+{
+ try
+ {
+ const HRESULT res = ReadDatabase2(
+ EXTERNAL_CODECS_LOC_VARS db
+ Z7_7Z_DECODER_CRYPRO_VARS
+ );
+ if (ThereIsHeaderError)
+ db.ThereIsHeaderError = true;
+ if (res == E_NOTIMPL)
+ ThrowUnsupported();
+ return res;
+ }
+ catch(CUnsupportedFeatureException &)
+ {
+ db.UnsupportedFeatureError = true;
+ return S_FALSE;
+ }
+ catch(CInArchiveException &)
+ {
+ db.ThereIsHeaderError = true;
+ return S_FALSE;
+ }
+}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zIn.h b/CPP/7zip/Archive/7z/7zIn.h
index bb0e474..a9c14fb 100644
--- a/CPP/7zip/Archive/7z/7zIn.h
+++ b/CPP/7zip/Archive/7z/7zIn.h
@@ -1,445 +1,451 @@
-// 7zIn.h
-
-#ifndef __7Z_IN_H
-#define __7Z_IN_H
-
-#include "../../../Common/MyCom.h"
-
-#include "../../../Windows/PropVariant.h"
-
-#include "../../IPassword.h"
-#include "../../IStream.h"
-
-#include "../../Common/CreateCoder.h"
-#include "../../Common/InBuffer.h"
-
-#include "7zItem.h"
-
-namespace NArchive {
-namespace N7z {
-
-/*
- We don't need to init isEncrypted and passwordIsDefined
- We must upgrade them only */
-
-#ifdef _NO_CRYPTO
-#define _7Z_DECODER_CRYPRO_VARS_DECL
-#define _7Z_DECODER_CRYPRO_VARS
-#else
-#define _7Z_DECODER_CRYPRO_VARS_DECL , ICryptoGetTextPassword *getTextPassword, bool &isEncrypted, bool &passwordIsDefined, UString &password
-#define _7Z_DECODER_CRYPRO_VARS , getTextPassword, isEncrypted, passwordIsDefined, password
-#endif
-
-struct CParsedMethods
-{
- Byte Lzma2Prop;
- UInt32 LzmaDic;
- CRecordVector<UInt64> IDs;
-
- CParsedMethods(): Lzma2Prop(0), LzmaDic(0) {}
-};
-
-struct CFolderEx: public CFolder
-{
- unsigned UnpackCoder;
-};
-
-struct CFolders
-{
- CNum NumPackStreams;
- CNum NumFolders;
-
- CObjArray<UInt64> PackPositions; // NumPackStreams + 1
- // CUInt32DefVector PackCRCs; // we don't use PackCRCs now
-
- CUInt32DefVector FolderCRCs; // NumFolders
- CObjArray<CNum> NumUnpackStreamsVector; // NumFolders
-
- CObjArray<UInt64> CoderUnpackSizes; // including unpack sizes of bond coders
- CObjArray<CNum> FoToCoderUnpackSizes; // NumFolders + 1
- CObjArray<CNum> FoStartPackStreamIndex; // NumFolders + 1
- CObjArray<Byte> FoToMainUnpackSizeIndex; // NumFolders
-
- CObjArray<size_t> FoCodersDataOffset; // NumFolders + 1
- CByteBuffer CodersData;
-
- CParsedMethods ParsedMethods;
-
- void ParseFolderInfo(unsigned folderIndex, CFolder &folder) const;
- void ParseFolderEx(unsigned folderIndex, CFolderEx &folder) const
- {
- ParseFolderInfo(folderIndex, folder);
- folder.UnpackCoder = FoToMainUnpackSizeIndex[folderIndex];
- }
-
- unsigned GetNumFolderUnpackSizes(unsigned folderIndex) const
- {
- return (unsigned)(FoToCoderUnpackSizes[folderIndex + 1] - FoToCoderUnpackSizes[folderIndex]);
- }
-
- UInt64 GetFolderUnpackSize(unsigned folderIndex) const
- {
- return CoderUnpackSizes[FoToCoderUnpackSizes[folderIndex] + FoToMainUnpackSizeIndex[folderIndex]];
- }
-
- UInt64 GetStreamPackSize(unsigned index) const
- {
- return PackPositions[index + 1] - PackPositions[index];
- }
-
- CFolders(): NumPackStreams(0), NumFolders(0) {}
-
- void Clear()
- {
- NumPackStreams = 0;
- PackPositions.Free();
- // PackCRCs.Clear();
-
- NumFolders = 0;
- FolderCRCs.Clear();
- NumUnpackStreamsVector.Free();
- CoderUnpackSizes.Free();
- FoToCoderUnpackSizes.Free();
- FoStartPackStreamIndex.Free();
- FoToMainUnpackSizeIndex.Free();
- FoCodersDataOffset.Free();
- CodersData.Free();
- }
-};
-
-struct CDatabase: public CFolders
-{
- CRecordVector<CFileItem> Files;
-
- CUInt64DefVector CTime;
- CUInt64DefVector ATime;
- CUInt64DefVector MTime;
- CUInt64DefVector StartPos;
- CUInt32DefVector Attrib;
- CBoolVector IsAnti;
- /*
- CBoolVector IsAux;
- CByteBuffer SecureBuf;
- CRecordVector<UInt32> SecureIDs;
- */
-
- CByteBuffer NamesBuf;
- CObjArray<size_t> NameOffsets; // numFiles + 1, offsets of utf-16 symbols
-
- /*
- void ClearSecure()
- {
- SecureBuf.Free();
- SecureIDs.Clear();
- }
- */
-
- void Clear()
- {
- CFolders::Clear();
- // ClearSecure();
-
- NamesBuf.Free();
- NameOffsets.Free();
-
- Files.Clear();
- CTime.Clear();
- ATime.Clear();
- MTime.Clear();
- StartPos.Clear();
- Attrib.Clear();
- IsAnti.Clear();
- // IsAux.Clear();
- }
-
- bool IsSolid() const
- {
- for (CNum i = 0; i < NumFolders; i++)
- if (NumUnpackStreamsVector[i] > 1)
- return true;
- return false;
- }
- bool IsItemAnti(unsigned index) const { return (index < IsAnti.Size() && IsAnti[index]); }
- // bool IsItemAux(unsigned index) const { return (index < IsAux.Size() && IsAux[index]); }
-
- /*
- const void* GetName(unsigned index) const
- {
- if (!NameOffsets || !NamesBuf)
- return NULL;
- return (void *)((const Byte *)NamesBuf + NameOffsets[index] * 2);
- };
- */
- void GetPath(unsigned index, UString &path) const;
- HRESULT GetPath_Prop(unsigned index, PROPVARIANT *path) const throw();
-};
-
-struct CInArchiveInfo
-{
- CArchiveVersion Version;
- UInt64 StartPosition;
- UInt64 StartPositionAfterHeader;
- UInt64 DataStartPosition;
- UInt64 DataStartPosition2;
- CRecordVector<UInt64> FileInfoPopIDs;
-
- void Clear()
- {
- StartPosition = 0;
- StartPositionAfterHeader = 0;
- DataStartPosition = 0;
- DataStartPosition2 = 0;
- FileInfoPopIDs.Clear();
- }
-};
-
-struct CDbEx: public CDatabase
-{
- CInArchiveInfo ArcInfo;
-
- CObjArray<CNum> FolderStartFileIndex;
- CObjArray<CNum> FileIndexToFolderIndexMap;
-
- UInt64 HeadersSize;
- UInt64 PhySize;
-
- /*
- CRecordVector<size_t> SecureOffsets;
- bool IsTree;
- bool ThereAreAltStreams;
- */
-
- bool IsArc;
- bool PhySizeWasConfirmed;
-
- bool ThereIsHeaderError;
- bool UnexpectedEnd;
- // bool UnsupportedVersion;
-
- bool StartHeaderWasRecovered;
- bool UnsupportedFeatureWarning;
- bool UnsupportedFeatureError;
-
- /*
- void ClearSecureEx()
- {
- ClearSecure();
- SecureOffsets.Clear();
- }
- */
-
- void Clear()
- {
- IsArc = false;
- PhySizeWasConfirmed = false;
-
- ThereIsHeaderError = false;
- UnexpectedEnd = false;
- // UnsupportedVersion = false;
-
- StartHeaderWasRecovered = false;
- UnsupportedFeatureError = false;
- UnsupportedFeatureWarning = false;
-
- /*
- IsTree = false;
- ThereAreAltStreams = false;
- */
-
- CDatabase::Clear();
-
- // SecureOffsets.Clear();
- ArcInfo.Clear();
- FolderStartFileIndex.Free();
- FileIndexToFolderIndexMap.Free();
-
- HeadersSize = 0;
- PhySize = 0;
- }
-
- bool CanUpdate() const
- {
- if (ThereIsHeaderError
- || UnexpectedEnd
- || StartHeaderWasRecovered
- || UnsupportedFeatureError)
- return false;
- return true;
- }
-
- void FillLinks();
-
- UInt64 GetFolderStreamPos(CNum folderIndex, unsigned indexInFolder) const
- {
- return ArcInfo.DataStartPosition +
- PackPositions[FoStartPackStreamIndex[folderIndex] + indexInFolder];
- }
-
- UInt64 GetFolderFullPackSize(CNum folderIndex) const
- {
- return
- PackPositions[FoStartPackStreamIndex[folderIndex + 1]] -
- PackPositions[FoStartPackStreamIndex[folderIndex]];
- }
-
- UInt64 GetFolderPackStreamSize(CNum folderIndex, unsigned streamIndex) const
- {
- size_t i = FoStartPackStreamIndex[folderIndex] + streamIndex;
- return PackPositions[i + 1] - PackPositions[i];
- }
-
- UInt64 GetFilePackSize(CNum fileIndex) const
- {
- CNum folderIndex = FileIndexToFolderIndexMap[fileIndex];
- if (folderIndex != kNumNoIndex)
- if (FolderStartFileIndex[folderIndex] == fileIndex)
- return GetFolderFullPackSize(folderIndex);
- return 0;
- }
-};
-
-const unsigned kNumBufLevelsMax = 4;
-
-struct CInByte2
-{
- const Byte *_buffer;
-public:
- size_t _size;
- size_t _pos;
-
- size_t GetRem() const { return _size - _pos; }
- const Byte *GetPtr() const { return _buffer + _pos; }
- void Init(const Byte *buffer, size_t size)
- {
- _buffer = buffer;
- _size = size;
- _pos = 0;
- }
- Byte ReadByte();
- void ReadBytes(Byte *data, size_t size);
- void SkipDataNoCheck(UInt64 size) { _pos += (size_t)size; }
- void SkipData(UInt64 size);
-
- void SkipData();
- void SkipRem() { _pos = _size; }
- UInt64 ReadNumber();
- CNum ReadNum();
- UInt32 ReadUInt32();
- UInt64 ReadUInt64();
-
- void ParseFolder(CFolder &folder);
-};
-
-class CStreamSwitch;
-
-const UInt32 kHeaderSize = 32;
-
-class CInArchive
-{
- friend class CStreamSwitch;
-
- CMyComPtr<IInStream> _stream;
-
- unsigned _numInByteBufs;
- CInByte2 _inByteVector[kNumBufLevelsMax];
-
- CInByte2 *_inByteBack;
- bool ThereIsHeaderError;
-
- UInt64 _arhiveBeginStreamPosition;
- UInt64 _fileEndPosition;
-
- Byte _header[kHeaderSize];
-
- UInt64 HeadersSize;
-
- bool _useMixerMT;
-
- void AddByteStream(const Byte *buffer, size_t size);
-
- void DeleteByteStream(bool needUpdatePos)
- {
- _numInByteBufs--;
- if (_numInByteBufs > 0)
- {
- _inByteBack = &_inByteVector[_numInByteBufs - 1];
- if (needUpdatePos)
- _inByteBack->_pos += _inByteVector[_numInByteBufs]._pos;
- }
- }
-
- HRESULT FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
-
- void ReadBytes(Byte *data, size_t size) { _inByteBack->ReadBytes(data, size); }
- Byte ReadByte() { return _inByteBack->ReadByte(); }
- UInt64 ReadNumber() { return _inByteBack->ReadNumber(); }
- CNum ReadNum() { return _inByteBack->ReadNum(); }
- UInt64 ReadID() { return _inByteBack->ReadNumber(); }
- UInt32 ReadUInt32() { return _inByteBack->ReadUInt32(); }
- UInt64 ReadUInt64() { return _inByteBack->ReadUInt64(); }
- void SkipData(UInt64 size) { _inByteBack->SkipData(size); }
- void SkipData() { _inByteBack->SkipData(); }
- void WaitId(UInt64 id);
-
- void Read_UInt32_Vector(CUInt32DefVector &v);
-
- void ReadArchiveProperties(CInArchiveInfo &archiveInfo);
- void ReadHashDigests(unsigned numItems, CUInt32DefVector &crcs);
-
- void ReadPackInfo(CFolders &f);
-
- void ReadUnpackInfo(
- const CObjectVector<CByteBuffer> *dataVector,
- CFolders &folders);
-
- void ReadSubStreamsInfo(
- CFolders &folders,
- CRecordVector<UInt64> &unpackSizes,
- CUInt32DefVector &digests);
-
- void ReadStreamsInfo(
- const CObjectVector<CByteBuffer> *dataVector,
- UInt64 &dataOffset,
- CFolders &folders,
- CRecordVector<UInt64> &unpackSizes,
- CUInt32DefVector &digests);
-
- void ReadBoolVector(unsigned numItems, CBoolVector &v);
- void ReadBoolVector2(unsigned numItems, CBoolVector &v);
- void ReadUInt64DefVector(const CObjectVector<CByteBuffer> &dataVector,
- CUInt64DefVector &v, unsigned numItems);
- HRESULT ReadAndDecodePackedStreams(
- DECL_EXTERNAL_CODECS_LOC_VARS
- UInt64 baseOffset, UInt64 &dataOffset,
- CObjectVector<CByteBuffer> &dataVector
- _7Z_DECODER_CRYPRO_VARS_DECL
- );
- HRESULT ReadHeader(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CDbEx &db
- _7Z_DECODER_CRYPRO_VARS_DECL
- );
- HRESULT ReadDatabase2(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CDbEx &db
- _7Z_DECODER_CRYPRO_VARS_DECL
- );
-public:
- CInArchive(bool useMixerMT):
- _numInByteBufs(0),
- _useMixerMT(useMixerMT)
- {}
-
- HRESULT Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit); // S_FALSE means is not archive
- void Close();
-
- HRESULT ReadDatabase(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CDbEx &db
- _7Z_DECODER_CRYPRO_VARS_DECL
- );
-};
-
-}}
-
-#endif
+// 7zIn.h
+
+#ifndef ZIP7_INC_7Z_IN_H
+#define ZIP7_INC_7Z_IN_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../IPassword.h"
+#include "../../IStream.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/InBuffer.h"
+
+#include "7zItem.h"
+
+namespace NArchive {
+namespace N7z {
+
+/*
+ We don't need to init isEncrypted and passwordIsDefined
+ We must upgrade them only */
+
+#ifdef Z7_NO_CRYPTO
+#define Z7_7Z_DECODER_CRYPRO_VARS_DECL
+#define Z7_7Z_DECODER_CRYPRO_VARS
+#else
+#define Z7_7Z_DECODER_CRYPRO_VARS_DECL , ICryptoGetTextPassword *getTextPassword, bool &isEncrypted, bool &passwordIsDefined, UString &password
+#define Z7_7Z_DECODER_CRYPRO_VARS , getTextPassword, isEncrypted, passwordIsDefined, password
+#endif
+
+struct CParsedMethods
+{
+ Byte Lzma2Prop;
+ UInt32 LzmaDic;
+ CRecordVector<UInt64> IDs;
+
+ CParsedMethods(): Lzma2Prop(0), LzmaDic(0) {}
+};
+
+struct CFolderEx: public CFolder
+{
+ unsigned UnpackCoder;
+};
+
+struct CFolders
+{
+ CNum NumPackStreams;
+ CNum NumFolders;
+
+ CObjArray<UInt64> PackPositions; // NumPackStreams + 1
+ // CUInt32DefVector PackCRCs; // we don't use PackCRCs now
+
+ CUInt32DefVector FolderCRCs; // NumFolders
+ CObjArray<CNum> NumUnpackStreamsVector; // NumFolders
+
+ CObjArray<UInt64> CoderUnpackSizes; // including unpack sizes of bond coders
+ CObjArray<CNum> FoToCoderUnpackSizes; // NumFolders + 1
+ CObjArray<CNum> FoStartPackStreamIndex; // NumFolders + 1
+ CObjArray<Byte> FoToMainUnpackSizeIndex; // NumFolders
+
+ CObjArray<size_t> FoCodersDataOffset; // NumFolders + 1
+ CByteBuffer CodersData;
+
+ CParsedMethods ParsedMethods;
+
+ void ParseFolderInfo(unsigned folderIndex, CFolder &folder) const;
+ void ParseFolderEx(unsigned folderIndex, CFolderEx &folder) const
+ {
+ ParseFolderInfo(folderIndex, folder);
+ folder.UnpackCoder = FoToMainUnpackSizeIndex[folderIndex];
+ }
+
+ unsigned GetNumFolderUnpackSizes(unsigned folderIndex) const
+ {
+ return (unsigned)(FoToCoderUnpackSizes[folderIndex + 1] - FoToCoderUnpackSizes[folderIndex]);
+ }
+
+ UInt64 GetFolderUnpackSize(unsigned folderIndex) const
+ {
+ return CoderUnpackSizes[FoToCoderUnpackSizes[folderIndex] + FoToMainUnpackSizeIndex[folderIndex]];
+ }
+
+ UInt64 GetStreamPackSize(unsigned index) const
+ {
+ return PackPositions[index + 1] - PackPositions[index];
+ }
+
+ CFolders(): NumPackStreams(0), NumFolders(0) {}
+
+ void Clear()
+ {
+ NumPackStreams = 0;
+ PackPositions.Free();
+ // PackCRCs.Clear();
+
+ NumFolders = 0;
+ FolderCRCs.Clear();
+ NumUnpackStreamsVector.Free();
+ CoderUnpackSizes.Free();
+ FoToCoderUnpackSizes.Free();
+ FoStartPackStreamIndex.Free();
+ FoToMainUnpackSizeIndex.Free();
+ FoCodersDataOffset.Free();
+ CodersData.Free();
+ }
+};
+
+struct CDatabase: public CFolders
+{
+ CRecordVector<CFileItem> Files;
+
+ CUInt64DefVector CTime;
+ CUInt64DefVector ATime;
+ CUInt64DefVector MTime;
+ CUInt64DefVector StartPos;
+ CUInt32DefVector Attrib;
+ CBoolVector IsAnti;
+ /*
+ CBoolVector IsAux;
+ CByteBuffer SecureBuf;
+ CRecordVector<UInt32> SecureIDs;
+ */
+
+ CByteBuffer NamesBuf;
+ CObjArray<size_t> NameOffsets; // numFiles + 1, offsets of utf-16 symbols
+
+ /*
+ void ClearSecure()
+ {
+ SecureBuf.Free();
+ SecureIDs.Clear();
+ }
+ */
+
+ void Clear()
+ {
+ CFolders::Clear();
+ // ClearSecure();
+
+ NamesBuf.Free();
+ NameOffsets.Free();
+
+ Files.Clear();
+ CTime.Clear();
+ ATime.Clear();
+ MTime.Clear();
+ StartPos.Clear();
+ Attrib.Clear();
+ IsAnti.Clear();
+ // IsAux.Clear();
+ }
+
+ bool IsSolid() const
+ {
+ for (CNum i = 0; i < NumFolders; i++)
+ if (NumUnpackStreamsVector[i] > 1)
+ return true;
+ return false;
+ }
+ bool IsItemAnti(unsigned index) const { return (index < IsAnti.Size() && IsAnti[index]); }
+ // bool IsItemAux(unsigned index) const { return (index < IsAux.Size() && IsAux[index]); }
+
+ /*
+ const void* GetName(unsigned index) const
+ {
+ if (!NameOffsets || !NamesBuf)
+ return NULL;
+ return (void *)((const Byte *)NamesBuf + NameOffsets[index] * 2);
+ };
+ */
+ void GetPath(unsigned index, UString &path) const;
+ HRESULT GetPath_Prop(unsigned index, PROPVARIANT *path) const throw();
+};
+
+
+struct CInArchiveInfo
+{
+ CArchiveVersion Version;
+ UInt64 StartPosition; // in stream
+ UInt64 StartPositionAfterHeader; // in stream
+ UInt64 DataStartPosition; // in stream
+ UInt64 DataStartPosition2; // in stream. it's for headers
+ CRecordVector<UInt64> FileInfoPopIDs;
+
+ void Clear()
+ {
+ StartPosition = 0;
+ StartPositionAfterHeader = 0;
+ DataStartPosition = 0;
+ DataStartPosition2 = 0;
+ FileInfoPopIDs.Clear();
+ }
+};
+
+
+struct CDbEx: public CDatabase
+{
+ CInArchiveInfo ArcInfo;
+
+ CObjArray<CNum> FolderStartFileIndex;
+ CObjArray<CNum> FileIndexToFolderIndexMap;
+
+ UInt64 HeadersSize;
+ UInt64 PhySize;
+ // UInt64 EndHeaderOffset; // relative to position after StartHeader (32 bytes)
+
+ /*
+ CRecordVector<size_t> SecureOffsets;
+ bool IsTree;
+ bool ThereAreAltStreams;
+ */
+
+ bool IsArc;
+ bool PhySizeWasConfirmed;
+
+ bool ThereIsHeaderError;
+ bool UnexpectedEnd;
+ // bool UnsupportedVersion;
+
+ bool StartHeaderWasRecovered;
+ bool UnsupportedFeatureWarning;
+ bool UnsupportedFeatureError;
+
+ /*
+ void ClearSecureEx()
+ {
+ ClearSecure();
+ SecureOffsets.Clear();
+ }
+ */
+
+ void Clear()
+ {
+ IsArc = false;
+ PhySizeWasConfirmed = false;
+
+ ThereIsHeaderError = false;
+ UnexpectedEnd = false;
+ // UnsupportedVersion = false;
+
+ StartHeaderWasRecovered = false;
+ UnsupportedFeatureError = false;
+ UnsupportedFeatureWarning = false;
+
+ /*
+ IsTree = false;
+ ThereAreAltStreams = false;
+ */
+
+ CDatabase::Clear();
+
+ // SecureOffsets.Clear();
+ ArcInfo.Clear();
+ FolderStartFileIndex.Free();
+ FileIndexToFolderIndexMap.Free();
+
+ HeadersSize = 0;
+ PhySize = 0;
+ // EndHeaderOffset = 0;
+ }
+
+ bool CanUpdate() const
+ {
+ if (ThereIsHeaderError
+ || UnexpectedEnd
+ || StartHeaderWasRecovered
+ || UnsupportedFeatureError)
+ return false;
+ return true;
+ }
+
+ void FillLinks();
+
+ UInt64 GetFolderStreamPos(CNum folderIndex, unsigned indexInFolder) const
+ {
+ return ArcInfo.DataStartPosition +
+ PackPositions[FoStartPackStreamIndex[folderIndex] + indexInFolder];
+ }
+
+ UInt64 GetFolderFullPackSize(CNum folderIndex) const
+ {
+ return
+ PackPositions[FoStartPackStreamIndex[folderIndex + 1]] -
+ PackPositions[FoStartPackStreamIndex[folderIndex]];
+ }
+
+ UInt64 GetFolderPackStreamSize(CNum folderIndex, unsigned streamIndex) const
+ {
+ size_t i = FoStartPackStreamIndex[folderIndex] + streamIndex;
+ return PackPositions[i + 1] - PackPositions[i];
+ }
+
+ UInt64 GetFilePackSize(CNum fileIndex) const
+ {
+ CNum folderIndex = FileIndexToFolderIndexMap[fileIndex];
+ if (folderIndex != kNumNoIndex)
+ if (FolderStartFileIndex[folderIndex] == fileIndex)
+ return GetFolderFullPackSize(folderIndex);
+ return 0;
+ }
+};
+
+const unsigned kNumBufLevelsMax = 4;
+
+struct CInByte2
+{
+ const Byte *_buffer;
+public:
+ size_t _size;
+ size_t _pos;
+
+ size_t GetRem() const { return _size - _pos; }
+ const Byte *GetPtr() const { return _buffer + _pos; }
+ void Init(const Byte *buffer, size_t size)
+ {
+ _buffer = buffer;
+ _size = size;
+ _pos = 0;
+ }
+ Byte ReadByte();
+ void ReadBytes(Byte *data, size_t size);
+ void SkipDataNoCheck(UInt64 size) { _pos += (size_t)size; }
+ void SkipData(UInt64 size);
+
+ void SkipData();
+ void SkipRem() { _pos = _size; }
+ UInt64 ReadNumber();
+ CNum ReadNum();
+ UInt32 ReadUInt32();
+ UInt64 ReadUInt64();
+
+ void ParseFolder(CFolder &folder);
+};
+
+class CStreamSwitch;
+
+const UInt32 kHeaderSize = 32;
+
+class CInArchive
+{
+ friend class CStreamSwitch;
+
+ CMyComPtr<IInStream> _stream;
+
+ unsigned _numInByteBufs;
+ CInByte2 _inByteVector[kNumBufLevelsMax];
+
+ CInByte2 *_inByteBack;
+ bool ThereIsHeaderError;
+
+ UInt64 _arhiveBeginStreamPosition;
+ UInt64 _fileEndPosition;
+
+ UInt64 _rangeLimit; // relative to position after StartHeader (32 bytes)
+
+ Byte _header[kHeaderSize];
+
+ UInt64 HeadersSize;
+
+ bool _useMixerMT;
+
+ void AddByteStream(const Byte *buffer, size_t size);
+
+ void DeleteByteStream(bool needUpdatePos)
+ {
+ _numInByteBufs--;
+ if (_numInByteBufs > 0)
+ {
+ _inByteBack = &_inByteVector[_numInByteBufs - 1];
+ if (needUpdatePos)
+ _inByteBack->_pos += _inByteVector[_numInByteBufs]._pos;
+ }
+ }
+
+ HRESULT FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
+
+ void ReadBytes(Byte *data, size_t size) { _inByteBack->ReadBytes(data, size); }
+ Byte ReadByte() { return _inByteBack->ReadByte(); }
+ UInt64 ReadNumber() { return _inByteBack->ReadNumber(); }
+ CNum ReadNum() { return _inByteBack->ReadNum(); }
+ UInt64 ReadID() { return _inByteBack->ReadNumber(); }
+ UInt32 ReadUInt32() { return _inByteBack->ReadUInt32(); }
+ UInt64 ReadUInt64() { return _inByteBack->ReadUInt64(); }
+ void SkipData(UInt64 size) { _inByteBack->SkipData(size); }
+ void SkipData() { _inByteBack->SkipData(); }
+ void WaitId(UInt64 id);
+
+ void Read_UInt32_Vector(CUInt32DefVector &v);
+
+ void ReadArchiveProperties(CInArchiveInfo &archiveInfo);
+ void ReadHashDigests(unsigned numItems, CUInt32DefVector &crcs);
+
+ void ReadPackInfo(CFolders &f);
+
+ void ReadUnpackInfo(
+ const CObjectVector<CByteBuffer> *dataVector,
+ CFolders &folders);
+
+ void ReadSubStreamsInfo(
+ CFolders &folders,
+ CRecordVector<UInt64> &unpackSizes,
+ CUInt32DefVector &digests);
+
+ void ReadStreamsInfo(
+ const CObjectVector<CByteBuffer> *dataVector,
+ UInt64 &dataOffset,
+ CFolders &folders,
+ CRecordVector<UInt64> &unpackSizes,
+ CUInt32DefVector &digests);
+
+ void ReadBoolVector(unsigned numItems, CBoolVector &v);
+ void ReadBoolVector2(unsigned numItems, CBoolVector &v);
+ void ReadUInt64DefVector(const CObjectVector<CByteBuffer> &dataVector,
+ CUInt64DefVector &v, unsigned numItems);
+ HRESULT ReadAndDecodePackedStreams(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ UInt64 baseOffset, UInt64 &dataOffset,
+ CObjectVector<CByteBuffer> &dataVector
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ );
+ HRESULT ReadHeader(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CDbEx &db
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ );
+ HRESULT ReadDatabase2(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CDbEx &db
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ );
+public:
+ CInArchive(bool useMixerMT):
+ _numInByteBufs(0),
+ _useMixerMT(useMixerMT)
+ {}
+
+ HRESULT Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit); // S_FALSE means is not archive
+ void Close();
+
+ HRESULT ReadDatabase(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CDbEx &db
+ Z7_7Z_DECODER_CRYPRO_VARS_DECL
+ );
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zItem.h b/CPP/7zip/Archive/7z/7zItem.h
index 90cf98c..e8c68be 100644
--- a/CPP/7zip/Archive/7z/7zItem.h
+++ b/CPP/7zip/Archive/7z/7zItem.h
@@ -1,202 +1,207 @@
-// 7zItem.h
-
-#ifndef __7Z_ITEM_H
-#define __7Z_ITEM_H
-
-#include "../../../Common/MyBuffer.h"
-#include "../../../Common/MyString.h"
-
-#include "../../Common/MethodId.h"
-
-#include "7zHeader.h"
-
-namespace NArchive {
-namespace N7z {
-
-typedef UInt32 CNum;
-const CNum kNumMax = 0x7FFFFFFF;
-const CNum kNumNoIndex = 0xFFFFFFFF;
-
-struct CCoderInfo
-{
- CMethodId MethodID;
- CByteBuffer Props;
- UInt32 NumStreams;
-
- bool IsSimpleCoder() const { return NumStreams == 1; }
-};
-
-
-struct CBond
-{
- UInt32 PackIndex;
- UInt32 UnpackIndex;
-};
-
-
-struct CFolder
-{
- CLASS_NO_COPY(CFolder)
-public:
- CObjArray2<CCoderInfo> Coders;
- CObjArray2<CBond> Bonds;
- CObjArray2<UInt32> PackStreams;
-
- CFolder() {}
-
- bool IsDecodingSupported() const { return Coders.Size() <= 32; }
-
- int Find_in_PackStreams(UInt32 packStream) const
- {
- FOR_VECTOR(i, PackStreams)
- if (PackStreams[i] == packStream)
- return i;
- return -1;
- }
-
- int FindBond_for_PackStream(UInt32 packStream) const
- {
- FOR_VECTOR(i, Bonds)
- if (Bonds[i].PackIndex == packStream)
- return i;
- return -1;
- }
-
- /*
- int FindBond_for_UnpackStream(UInt32 unpackStream) const
- {
- FOR_VECTOR(i, Bonds)
- if (Bonds[i].UnpackIndex == unpackStream)
- return i;
- return -1;
- }
-
- int FindOutCoder() const
- {
- for (int i = (int)Coders.Size() - 1; i >= 0; i--)
- if (FindBond_for_UnpackStream(i) < 0)
- return i;
- return -1;
- }
- */
-
- bool IsEncrypted() const
- {
- FOR_VECTOR(i, Coders)
- if (Coders[i].MethodID == k_AES)
- return true;
- return false;
- }
-};
-
-
-struct CUInt32DefVector
-{
- CBoolVector Defs;
- CRecordVector<UInt32> Vals;
-
- void ClearAndSetSize(unsigned newSize)
- {
- Defs.ClearAndSetSize(newSize);
- Vals.ClearAndSetSize(newSize);
- }
-
- void Clear()
- {
- Defs.Clear();
- Vals.Clear();
- }
-
- void ReserveDown()
- {
- Defs.ReserveDown();
- Vals.ReserveDown();
- }
-
- bool GetItem(unsigned index, UInt32 &value) const
- {
- if (index < Defs.Size() && Defs[index])
- {
- value = Vals[index];
- return true;
- }
- value = 0;
- return false;
- }
-
- bool ValidAndDefined(unsigned i) const { return i < Defs.Size() && Defs[i]; }
-
- bool CheckSize(unsigned size) const { return Defs.Size() == size || Defs.Size() == 0; }
-
- void SetItem(unsigned index, bool defined, UInt32 value);
-};
-
-
-struct CUInt64DefVector
-{
- CBoolVector Defs;
- CRecordVector<UInt64> Vals;
-
- void Clear()
- {
- Defs.Clear();
- Vals.Clear();
- }
-
- void ReserveDown()
- {
- Defs.ReserveDown();
- Vals.ReserveDown();
- }
-
- bool GetItem(unsigned index, UInt64 &value) const
- {
- if (index < Defs.Size() && Defs[index])
- {
- value = Vals[index];
- return true;
- }
- value = 0;
- return false;
- }
-
- bool CheckSize(unsigned size) const { return Defs.Size() == size || Defs.Size() == 0; }
-
- void SetItem(unsigned index, bool defined, UInt64 value);
-};
-
-
-struct CFileItem
-{
- UInt64 Size;
- UInt32 Crc;
- /*
- int Parent;
- bool IsAltStream;
- */
- bool HasStream; // Test it !!! it means that there is
- // stream in some folder. It can be empty stream
- bool IsDir;
- bool CrcDefined;
-
- /*
- void Clear()
- {
- HasStream = true;
- IsDir = false;
- CrcDefined = false;
- }
-
- CFileItem():
- // Parent(-1),
- // IsAltStream(false),
- HasStream(true),
- IsDir(false),
- CrcDefined(false),
- {}
- */
-};
-
-}}
-
-#endif
+// 7zItem.h
+
+#ifndef ZIP7_INC_7Z_ITEM_H
+#define ZIP7_INC_7Z_ITEM_H
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyString.h"
+
+#include "../../Common/MethodId.h"
+
+#include "7zHeader.h"
+
+namespace NArchive {
+namespace N7z {
+
+typedef UInt32 CNum;
+const CNum kNumMax = 0x7FFFFFFF;
+const CNum kNumNoIndex = 0xFFFFFFFF;
+
+struct CCoderInfo
+{
+ CMethodId MethodID;
+ CByteBuffer Props;
+ UInt32 NumStreams;
+
+ bool IsSimpleCoder() const { return NumStreams == 1; }
+};
+
+
+struct CBond
+{
+ UInt32 PackIndex;
+ UInt32 UnpackIndex;
+};
+
+
+struct CFolder
+{
+ Z7_CLASS_NO_COPY(CFolder)
+public:
+ CObjArray2<CCoderInfo> Coders;
+ CObjArray2<CBond> Bonds;
+ CObjArray2<UInt32> PackStreams;
+
+ CFolder() {}
+
+ bool IsDecodingSupported() const { return Coders.Size() <= 32; }
+
+ int Find_in_PackStreams(UInt32 packStream) const
+ {
+ FOR_VECTOR(i, PackStreams)
+ if (PackStreams[i] == packStream)
+ return (int)i;
+ return -1;
+ }
+
+ int FindBond_for_PackStream(UInt32 packStream) const
+ {
+ FOR_VECTOR(i, Bonds)
+ if (Bonds[i].PackIndex == packStream)
+ return (int)i;
+ return -1;
+ }
+
+ /*
+ int FindBond_for_UnpackStream(UInt32 unpackStream) const
+ {
+ FOR_VECTOR(i, Bonds)
+ if (Bonds[i].UnpackIndex == unpackStream)
+ return i;
+ return -1;
+ }
+
+ int FindOutCoder() const
+ {
+ for (int i = (int)Coders.Size() - 1; i >= 0; i--)
+ if (FindBond_for_UnpackStream(i) < 0)
+ return i;
+ return -1;
+ }
+ */
+
+ bool IsEncrypted() const
+ {
+ FOR_VECTOR(i, Coders)
+ if (Coders[i].MethodID == k_AES)
+ return true;
+ return false;
+ }
+};
+
+
+struct CUInt32DefVector
+{
+ CBoolVector Defs;
+ CRecordVector<UInt32> Vals;
+
+ void ClearAndSetSize(unsigned newSize)
+ {
+ Defs.ClearAndSetSize(newSize);
+ Vals.ClearAndSetSize(newSize);
+ }
+
+ void Clear()
+ {
+ Defs.Clear();
+ Vals.Clear();
+ }
+
+ void ReserveDown()
+ {
+ Defs.ReserveDown();
+ Vals.ReserveDown();
+ }
+
+ bool GetItem(unsigned index, UInt32 &value) const
+ {
+ if (index < Defs.Size() && Defs[index])
+ {
+ value = Vals[index];
+ return true;
+ }
+ value = 0;
+ return false;
+ }
+
+ bool ValidAndDefined(unsigned i) const { return i < Defs.Size() && Defs[i]; }
+
+ bool CheckSize(unsigned size) const { return Defs.Size() == size || Defs.Size() == 0; }
+
+ void SetItem(unsigned index, bool defined, UInt32 value);
+ void if_NonEmpty_FillResedue_with_false(unsigned numItems)
+ {
+ if (Defs.Size() != 0 && Defs.Size() < numItems)
+ SetItem(numItems - 1, false, 0);
+ }
+};
+
+
+struct CUInt64DefVector
+{
+ CBoolVector Defs;
+ CRecordVector<UInt64> Vals;
+
+ void Clear()
+ {
+ Defs.Clear();
+ Vals.Clear();
+ }
+
+ void ReserveDown()
+ {
+ Defs.ReserveDown();
+ Vals.ReserveDown();
+ }
+
+ bool GetItem(unsigned index, UInt64 &value) const
+ {
+ if (index < Defs.Size() && Defs[index])
+ {
+ value = Vals[index];
+ return true;
+ }
+ value = 0;
+ return false;
+ }
+
+ bool CheckSize(unsigned size) const { return Defs.Size() == size || Defs.Size() == 0; }
+
+ void SetItem(unsigned index, bool defined, UInt64 value);
+};
+
+
+struct CFileItem
+{
+ UInt64 Size;
+ UInt32 Crc;
+ /*
+ int Parent;
+ bool IsAltStream;
+ */
+ bool HasStream; // Test it !!! it means that there is
+ // stream in some folder. It can be empty stream
+ bool IsDir;
+ bool CrcDefined;
+
+ /*
+ void Clear()
+ {
+ HasStream = true;
+ IsDir = false;
+ CrcDefined = false;
+ }
+
+ CFileItem():
+ // Parent(-1),
+ // IsAltStream(false),
+ HasStream(true),
+ IsDir(false),
+ CrcDefined(false),
+ {}
+ */
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zOut.cpp b/CPP/7zip/Archive/7z/7zOut.cpp
index 5bd3a41..7f8fa5b 100644
--- a/CPP/7zip/Archive/7z/7zOut.cpp
+++ b/CPP/7zip/Archive/7z/7zOut.cpp
@@ -1,901 +1,955 @@
-// 7zOut.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/7zCrc.h"
-
-#include "../../../Common/AutoPtr.h"
-
-#include "../../Common/StreamObjects.h"
-
-#include "7zOut.h"
-
-namespace NArchive {
-namespace N7z {
-
-HRESULT COutArchive::WriteSignature()
-{
- Byte buf[8];
- memcpy(buf, kSignature, kSignatureSize);
- buf[kSignatureSize] = kMajorVersion;
- buf[kSignatureSize + 1] = 4;
- return WriteDirect(buf, 8);
-}
-
-#ifdef _7Z_VOL
-HRESULT COutArchive::WriteFinishSignature()
-{
- RINOK(WriteDirect(kFinishSignature, kSignatureSize));
- CArchiveVersion av;
- av.Major = kMajorVersion;
- av.Minor = 2;
- RINOK(WriteDirectByte(av.Major));
- return WriteDirectByte(av.Minor);
-}
-#endif
-
-static void SetUInt32(Byte *p, UInt32 d)
-{
- for (int i = 0; i < 4; i++, d >>= 8)
- p[i] = (Byte)d;
-}
-
-static void SetUInt64(Byte *p, UInt64 d)
-{
- for (int i = 0; i < 8; i++, d >>= 8)
- p[i] = (Byte)d;
-}
-
-HRESULT COutArchive::WriteStartHeader(const CStartHeader &h)
-{
- Byte buf[24];
- SetUInt64(buf + 4, h.NextHeaderOffset);
- SetUInt64(buf + 12, h.NextHeaderSize);
- SetUInt32(buf + 20, h.NextHeaderCRC);
- SetUInt32(buf, CrcCalc(buf + 4, 20));
- return WriteDirect(buf, 24);
-}
-
-#ifdef _7Z_VOL
-HRESULT COutArchive::WriteFinishHeader(const CFinishHeader &h)
-{
- CCRC crc;
- crc.UpdateUInt64(h.NextHeaderOffset);
- crc.UpdateUInt64(h.NextHeaderSize);
- crc.UpdateUInt32(h.NextHeaderCRC);
- crc.UpdateUInt64(h.ArchiveStartOffset);
- crc.UpdateUInt64(h.AdditionalStartBlockSize);
- RINOK(WriteDirectUInt32(crc.GetDigest()));
- RINOK(WriteDirectUInt64(h.NextHeaderOffset));
- RINOK(WriteDirectUInt64(h.NextHeaderSize));
- RINOK(WriteDirectUInt32(h.NextHeaderCRC));
- RINOK(WriteDirectUInt64(h.ArchiveStartOffset));
- return WriteDirectUInt64(h.AdditionalStartBlockSize);
-}
-#endif
-
-HRESULT COutArchive::Create(ISequentialOutStream *stream, bool endMarker)
-{
- Close();
- #ifdef _7Z_VOL
- // endMarker = false;
- _endMarker = endMarker;
- #endif
- SeqStream = stream;
- if (!endMarker)
- {
- SeqStream.QueryInterface(IID_IOutStream, &Stream);
- if (!Stream)
- {
- return E_NOTIMPL;
- // endMarker = true;
- }
- }
- #ifdef _7Z_VOL
- if (endMarker)
- {
- /*
- CStartHeader sh;
- sh.NextHeaderOffset = (UInt32)(Int32)-1;
- sh.NextHeaderSize = (UInt32)(Int32)-1;
- sh.NextHeaderCRC = 0;
- WriteStartHeader(sh);
- */
- }
- else
- #endif
- {
- if (!Stream)
- return E_FAIL;
- RINOK(WriteSignature());
- RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_prefixHeaderPos));
- }
- return S_OK;
-}
-
-void COutArchive::Close()
-{
- SeqStream.Release();
- Stream.Release();
-}
-
-HRESULT COutArchive::SkipPrefixArchiveHeader()
-{
- #ifdef _7Z_VOL
- if (_endMarker)
- return S_OK;
- #endif
- Byte buf[24];
- memset(buf, 0, 24);
- return WriteDirect(buf, 24);
-}
-
-UInt64 COutArchive::GetPos() const
-{
- if (_countMode)
- return _countSize;
- if (_writeToStream)
- return _outByte.GetProcessedSize();
- return _outByte2.GetPos();
-}
-
-void COutArchive::WriteBytes(const void *data, size_t size)
-{
- if (_countMode)
- _countSize += size;
- else if (_writeToStream)
- {
- _outByte.WriteBytes(data, size);
- _crc = CrcUpdate(_crc, data, size);
- }
- else
- _outByte2.WriteBytes(data, size);
-}
-
-void COutArchive::WriteByte(Byte b)
-{
- if (_countMode)
- _countSize++;
- else if (_writeToStream)
- {
- _outByte.WriteByte(b);
- _crc = CRC_UPDATE_BYTE(_crc, b);
- }
- else
- _outByte2.WriteByte(b);
-}
-
-void COutArchive::WriteUInt32(UInt32 value)
-{
- for (int i = 0; i < 4; i++)
- {
- WriteByte((Byte)value);
- value >>= 8;
- }
-}
-
-void COutArchive::WriteUInt64(UInt64 value)
-{
- for (int i = 0; i < 8; i++)
- {
- WriteByte((Byte)value);
- value >>= 8;
- }
-}
-
-void COutArchive::WriteNumber(UInt64 value)
-{
- Byte firstByte = 0;
- Byte mask = 0x80;
- int i;
- for (i = 0; i < 8; i++)
- {
- if (value < ((UInt64(1) << ( 7 * (i + 1)))))
- {
- firstByte |= Byte(value >> (8 * i));
- break;
- }
- firstByte |= mask;
- mask >>= 1;
- }
- WriteByte(firstByte);
- for (; i > 0; i--)
- {
- WriteByte((Byte)value);
- value >>= 8;
- }
-}
-
-static UInt32 GetBigNumberSize(UInt64 value)
-{
- int i;
- for (i = 1; i < 9; i++)
- if (value < (((UInt64)1 << (i * 7))))
- break;
- return i;
-}
-
-#ifdef _7Z_VOL
-UInt32 COutArchive::GetVolHeadersSize(UInt64 dataSize, int nameLength, bool props)
-{
- UInt32 result = GetBigNumberSize(dataSize) * 2 + 41;
- if (nameLength != 0)
- {
- nameLength = (nameLength + 1) * 2;
- result += nameLength + GetBigNumberSize(nameLength) + 2;
- }
- if (props)
- {
- result += 20;
- }
- if (result >= 128)
- result++;
- result += kSignatureSize + 2 + kFinishHeaderSize;
- return result;
-}
-
-UInt64 COutArchive::GetVolPureSize(UInt64 volSize, int nameLength, bool props)
-{
- UInt32 headersSizeBase = COutArchive::GetVolHeadersSize(1, nameLength, props);
- int testSize;
- if (volSize > headersSizeBase)
- testSize = volSize - headersSizeBase;
- else
- testSize = 1;
- UInt32 headersSize = COutArchive::GetVolHeadersSize(testSize, nameLength, props);
- UInt64 pureSize = 1;
- if (volSize > headersSize)
- pureSize = volSize - headersSize;
- return pureSize;
-}
-#endif
-
-void COutArchive::WriteFolder(const CFolder &folder)
-{
- WriteNumber(folder.Coders.Size());
- unsigned i;
-
- for (i = 0; i < folder.Coders.Size(); i++)
- {
- const CCoderInfo &coder = folder.Coders[i];
- {
- UInt64 id = coder.MethodID;
- unsigned idSize;
- for (idSize = 1; idSize < sizeof(id); idSize++)
- if ((id >> (8 * idSize)) == 0)
- break;
- idSize &= 0xF;
- Byte temp[16];
- for (unsigned t = idSize; t != 0; t--, id >>= 8)
- temp[t] = (Byte)(id & 0xFF);
-
- Byte b = (Byte)(idSize);
- bool isComplex = !coder.IsSimpleCoder();
- b |= (isComplex ? 0x10 : 0);
-
- size_t propsSize = coder.Props.Size();
- b |= ((propsSize != 0) ? 0x20 : 0);
- temp[0] = b;
- WriteBytes(temp, idSize + 1);
- if (isComplex)
- {
- WriteNumber(coder.NumStreams);
- WriteNumber(1); // NumOutStreams;
- }
- if (propsSize == 0)
- continue;
- WriteNumber(propsSize);
- WriteBytes(coder.Props, propsSize);
- }
- }
-
- for (i = 0; i < folder.Bonds.Size(); i++)
- {
- const CBond &bond = folder.Bonds[i];
- WriteNumber(bond.PackIndex);
- WriteNumber(bond.UnpackIndex);
- }
-
- if (folder.PackStreams.Size() > 1)
- for (i = 0; i < folder.PackStreams.Size(); i++)
- WriteNumber(folder.PackStreams[i]);
-}
-
-void COutArchive::WriteBoolVector(const CBoolVector &boolVector)
-{
- Byte b = 0;
- Byte mask = 0x80;
- FOR_VECTOR (i, boolVector)
- {
- if (boolVector[i])
- b |= mask;
- mask >>= 1;
- if (mask == 0)
- {
- WriteByte(b);
- mask = 0x80;
- b = 0;
- }
- }
- if (mask != 0x80)
- WriteByte(b);
-}
-
-static inline unsigned Bv_GetSizeInBytes(const CBoolVector &v) { return ((unsigned)v.Size() + 7) / 8; }
-
-void COutArchive::WritePropBoolVector(Byte id, const CBoolVector &boolVector)
-{
- WriteByte(id);
- WriteNumber(Bv_GetSizeInBytes(boolVector));
- WriteBoolVector(boolVector);
-}
-
-unsigned BoolVector_CountSum(const CBoolVector &v);
-
-void COutArchive::WriteHashDigests(const CUInt32DefVector &digests)
-{
- const unsigned numDefined = BoolVector_CountSum(digests.Defs);
- if (numDefined == 0)
- return;
-
- WriteByte(NID::kCRC);
- if (numDefined == digests.Defs.Size())
- WriteByte(1);
- else
- {
- WriteByte(0);
- WriteBoolVector(digests.Defs);
- }
-
- for (unsigned i = 0; i < digests.Defs.Size(); i++)
- if (digests.Defs[i])
- WriteUInt32(digests.Vals[i]);
-}
-
-void COutArchive::WritePackInfo(
- UInt64 dataOffset,
- const CRecordVector<UInt64> &packSizes,
- const CUInt32DefVector &packCRCs)
-{
- if (packSizes.IsEmpty())
- return;
- WriteByte(NID::kPackInfo);
- WriteNumber(dataOffset);
- WriteNumber(packSizes.Size());
- WriteByte(NID::kSize);
- FOR_VECTOR (i, packSizes)
- WriteNumber(packSizes[i]);
-
- WriteHashDigests(packCRCs);
-
- WriteByte(NID::kEnd);
-}
-
-void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders, const COutFolders &outFolders)
-{
- if (folders.IsEmpty())
- return;
-
- WriteByte(NID::kUnpackInfo);
-
- WriteByte(NID::kFolder);
- WriteNumber(folders.Size());
- {
- WriteByte(0);
- FOR_VECTOR (i, folders)
- WriteFolder(folders[i]);
- }
-
- WriteByte(NID::kCodersUnpackSize);
- FOR_VECTOR (i, outFolders.CoderUnpackSizes)
- WriteNumber(outFolders.CoderUnpackSizes[i]);
-
- WriteHashDigests(outFolders.FolderUnpackCRCs);
-
- WriteByte(NID::kEnd);
-}
-
-void COutArchive::WriteSubStreamsInfo(const CObjectVector<CFolder> &folders,
- const COutFolders &outFolders,
- const CRecordVector<UInt64> &unpackSizes,
- const CUInt32DefVector &digests)
-{
- const CRecordVector<CNum> &numUnpackStreamsInFolders = outFolders.NumUnpackStreamsVector;
- WriteByte(NID::kSubStreamsInfo);
-
- unsigned i;
- for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
- if (numUnpackStreamsInFolders[i] != 1)
- {
- WriteByte(NID::kNumUnpackStream);
- for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
- WriteNumber(numUnpackStreamsInFolders[i]);
- break;
- }
-
- for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
- if (numUnpackStreamsInFolders[i] > 1)
- {
- WriteByte(NID::kSize);
- CNum index = 0;
- for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
- {
- CNum num = numUnpackStreamsInFolders[i];
- for (CNum j = 0; j < num; j++)
- {
- if (j + 1 != num)
- WriteNumber(unpackSizes[index]);
- index++;
- }
- }
- break;
- }
-
- CUInt32DefVector digests2;
-
- unsigned digestIndex = 0;
- for (i = 0; i < folders.Size(); i++)
- {
- unsigned numSubStreams = (unsigned)numUnpackStreamsInFolders[i];
- if (numSubStreams == 1 && outFolders.FolderUnpackCRCs.ValidAndDefined(i))
- digestIndex++;
- else
- for (unsigned j = 0; j < numSubStreams; j++, digestIndex++)
- {
- digests2.Defs.Add(digests.Defs[digestIndex]);
- digests2.Vals.Add(digests.Vals[digestIndex]);
- }
- }
- WriteHashDigests(digests2);
- WriteByte(NID::kEnd);
-}
-
-// 7-Zip 4.50 - 4.58 contain BUG, so they do not support .7z archives with Unknown field.
-
-void COutArchive::SkipToAligned(unsigned pos, unsigned alignShifts)
-{
- if (!_useAlign)
- return;
-
- const unsigned alignSize = (unsigned)1 << alignShifts;
- pos += (unsigned)GetPos();
- pos &= (alignSize - 1);
- if (pos == 0)
- return;
- unsigned skip = alignSize - pos;
- if (skip < 2)
- skip += alignSize;
- skip -= 2;
- WriteByte(NID::kDummy);
- WriteByte((Byte)skip);
- for (unsigned i = 0; i < skip; i++)
- WriteByte(0);
-}
-
-void COutArchive::WriteAlignedBools(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSizeShifts)
-{
- const unsigned bvSize = (numDefined == v.Size()) ? 0 : Bv_GetSizeInBytes(v);
- const UInt64 dataSize = ((UInt64)numDefined << itemSizeShifts) + bvSize + 2;
- SkipToAligned(3 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), itemSizeShifts);
-
- WriteByte(type);
- WriteNumber(dataSize);
- if (numDefined == v.Size())
- WriteByte(1);
- else
- {
- WriteByte(0);
- WriteBoolVector(v);
- }
- WriteByte(0); // 0 means no switching to external stream
-}
-
-void COutArchive::WriteUInt64DefVector(const CUInt64DefVector &v, Byte type)
-{
- const unsigned numDefined = BoolVector_CountSum(v.Defs);
- if (numDefined == 0)
- return;
-
- WriteAlignedBools(v.Defs, numDefined, type, 3);
-
- for (unsigned i = 0; i < v.Defs.Size(); i++)
- if (v.Defs[i])
- WriteUInt64(v.Vals[i]);
-}
-
-HRESULT COutArchive::EncodeStream(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CEncoder &encoder, const CByteBuffer &data,
- CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders)
-{
- CBufInStream *streamSpec = new CBufInStream;
- CMyComPtr<ISequentialInStream> stream = streamSpec;
- streamSpec->Init(data, data.Size());
- outFolders.FolderUnpackCRCs.Defs.Add(true);
- outFolders.FolderUnpackCRCs.Vals.Add(CrcCalc(data, data.Size()));
- // outFolders.NumUnpackStreamsVector.Add(1);
- UInt64 dataSize64 = data.Size();
- UInt64 unpackSize = data.Size();
- RINOK(encoder.Encode(
- EXTERNAL_CODECS_LOC_VARS
- stream,
- // NULL,
- &dataSize64,
- folders.AddNew(), outFolders.CoderUnpackSizes, unpackSize, SeqStream, packSizes, NULL))
- return S_OK;
-}
-
-void COutArchive::WriteHeader(
- const CArchiveDatabaseOut &db,
- // const CHeaderOptions &headerOptions,
- UInt64 &headerOffset)
-{
- /*
- bool thereIsSecure = (db.SecureBuf.Size() != 0);
- */
- _useAlign = true;
-
- {
- UInt64 packSize = 0;
- FOR_VECTOR (i, db.PackSizes)
- packSize += db.PackSizes[i];
- headerOffset = packSize;
- }
-
-
- WriteByte(NID::kHeader);
-
- // Archive Properties
-
- if (db.Folders.Size() > 0)
- {
- WriteByte(NID::kMainStreamsInfo);
- WritePackInfo(0, db.PackSizes, db.PackCRCs);
- WriteUnpackInfo(db.Folders, (const COutFolders &)db);
-
- CRecordVector<UInt64> unpackSizes;
- CUInt32DefVector digests;
- FOR_VECTOR (i, db.Files)
- {
- const CFileItem &file = db.Files[i];
- if (!file.HasStream)
- continue;
- unpackSizes.Add(file.Size);
- digests.Defs.Add(file.CrcDefined);
- digests.Vals.Add(file.Crc);
- }
-
- WriteSubStreamsInfo(db.Folders, (const COutFolders &)db, unpackSizes, digests);
- WriteByte(NID::kEnd);
- }
-
- if (db.Files.IsEmpty())
- {
- WriteByte(NID::kEnd);
- return;
- }
-
- WriteByte(NID::kFilesInfo);
- WriteNumber(db.Files.Size());
-
- {
- /* ---------- Empty Streams ---------- */
- CBoolVector emptyStreamVector;
- emptyStreamVector.ClearAndSetSize(db.Files.Size());
- unsigned numEmptyStreams = 0;
- {
- FOR_VECTOR (i, db.Files)
- if (db.Files[i].HasStream)
- emptyStreamVector[i] = false;
- else
- {
- emptyStreamVector[i] = true;
- numEmptyStreams++;
- }
- }
-
- if (numEmptyStreams != 0)
- {
- WritePropBoolVector(NID::kEmptyStream, emptyStreamVector);
-
- CBoolVector emptyFileVector, antiVector;
- emptyFileVector.ClearAndSetSize(numEmptyStreams);
- antiVector.ClearAndSetSize(numEmptyStreams);
- bool thereAreEmptyFiles = false, thereAreAntiItems = false;
- unsigned cur = 0;
-
- FOR_VECTOR (i, db.Files)
- {
- const CFileItem &file = db.Files[i];
- if (file.HasStream)
- continue;
- emptyFileVector[cur] = !file.IsDir;
- if (!file.IsDir)
- thereAreEmptyFiles = true;
- bool isAnti = db.IsItemAnti(i);
- antiVector[cur] = isAnti;
- if (isAnti)
- thereAreAntiItems = true;
- cur++;
- }
-
- if (thereAreEmptyFiles)
- WritePropBoolVector(NID::kEmptyFile, emptyFileVector);
- if (thereAreAntiItems)
- WritePropBoolVector(NID::kAnti, antiVector);
- }
- }
-
-
- {
- /* ---------- Names ---------- */
-
- unsigned numDefined = 0;
- size_t namesDataSize = 0;
- FOR_VECTOR (i, db.Files)
- {
- const UString &name = db.Names[i];
- if (!name.IsEmpty())
- numDefined++;
- namesDataSize += (name.Len() + 1) * 2;
- }
-
- if (numDefined > 0)
- {
- namesDataSize++;
- SkipToAligned(2 + GetBigNumberSize(namesDataSize), 4);
-
- WriteByte(NID::kName);
- WriteNumber(namesDataSize);
- WriteByte(0);
- FOR_VECTOR (i, db.Files)
- {
- const UString &name = db.Names[i];
- for (unsigned t = 0; t <= name.Len(); t++)
- {
- wchar_t c = name[t];
- WriteByte((Byte)c);
- WriteByte((Byte)(c >> 8));
- }
- }
- }
- }
-
- /* if (headerOptions.WriteCTime) */ WriteUInt64DefVector(db.CTime, NID::kCTime);
- /* if (headerOptions.WriteATime) */ WriteUInt64DefVector(db.ATime, NID::kATime);
- /* if (headerOptions.WriteMTime) */ WriteUInt64DefVector(db.MTime, NID::kMTime);
- WriteUInt64DefVector(db.StartPos, NID::kStartPos);
-
- {
- /* ---------- Write Attrib ---------- */
- const unsigned numDefined = BoolVector_CountSum(db.Attrib.Defs);
-
- if (numDefined != 0)
- {
- WriteAlignedBools(db.Attrib.Defs, numDefined, NID::kWinAttrib, 2);
- FOR_VECTOR (i, db.Attrib.Defs)
- {
- if (db.Attrib.Defs[i])
- WriteUInt32(db.Attrib.Vals[i]);
- }
- }
- }
-
- /*
- {
- // ---------- Write IsAux ----------
- if (BoolVector_CountSum(db.IsAux) != 0)
- WritePropBoolVector(NID::kIsAux, db.IsAux);
- }
-
- {
- // ---------- Write Parent ----------
- CBoolVector boolVector;
- boolVector.Reserve(db.Files.Size());
- unsigned numIsDir = 0;
- unsigned numParentLinks = 0;
- for (i = 0; i < db.Files.Size(); i++)
- {
- const CFileItem &file = db.Files[i];
- bool defined = !file.IsAltStream;
- boolVector.Add(defined);
- if (defined)
- numIsDir++;
- if (file.Parent >= 0)
- numParentLinks++;
- }
- if (numParentLinks > 0)
- {
- // WriteAlignedBools(boolVector, numDefined, NID::kParent, 2);
- const unsigned bvSize = (numIsDir == boolVector.Size()) ? 0 : Bv_GetSizeInBytes(boolVector);
- const UInt64 dataSize = (UInt64)db.Files.Size() * 4 + bvSize + 1;
- SkipToAligned(2 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), 2);
-
- WriteByte(NID::kParent);
- WriteNumber(dataSize);
- if (numIsDir == boolVector.Size())
- WriteByte(1);
- else
- {
- WriteByte(0);
- WriteBoolVector(boolVector);
- }
- for (i = 0; i < db.Files.Size(); i++)
- {
- const CFileItem &file = db.Files[i];
- // if (file.Parent >= 0)
- WriteUInt32(file.Parent);
- }
- }
- }
-
- if (thereIsSecure)
- {
- UInt64 secureDataSize = 1 + 4 +
- db.SecureBuf.Size() +
- db.SecureSizes.Size() * 4;
- // secureDataSize += db.SecureIDs.Size() * 4;
- for (i = 0; i < db.SecureIDs.Size(); i++)
- secureDataSize += GetBigNumberSize(db.SecureIDs[i]);
- SkipToAligned(2 + GetBigNumberSize(secureDataSize), 2);
- WriteByte(NID::kNtSecure);
- WriteNumber(secureDataSize);
- WriteByte(0);
- WriteUInt32(db.SecureSizes.Size());
- for (i = 0; i < db.SecureSizes.Size(); i++)
- WriteUInt32(db.SecureSizes[i]);
- WriteBytes(db.SecureBuf, db.SecureBuf.Size());
- for (i = 0; i < db.SecureIDs.Size(); i++)
- {
- WriteNumber(db.SecureIDs[i]);
- // WriteUInt32(db.SecureIDs[i]);
- }
- }
- */
-
- WriteByte(NID::kEnd); // for files
- WriteByte(NID::kEnd); // for headers
-}
-
-HRESULT COutArchive::WriteDatabase(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const CArchiveDatabaseOut &db,
- const CCompressionMethodMode *options,
- const CHeaderOptions &headerOptions)
-{
- if (!db.CheckNumFiles())
- return E_FAIL;
-
- UInt64 headerOffset;
- UInt32 headerCRC;
- UInt64 headerSize;
- if (db.IsEmpty())
- {
- headerSize = 0;
- headerOffset = 0;
- headerCRC = CrcCalc(0, 0);
- }
- else
- {
- bool encodeHeaders = false;
- if (options != 0)
- if (options->IsEmpty())
- options = 0;
- if (options != 0)
- if (options->PasswordIsDefined || headerOptions.CompressMainHeader)
- encodeHeaders = true;
-
- _outByte.SetStream(SeqStream);
- _outByte.Init();
- _crc = CRC_INIT_VAL;
- _countMode = encodeHeaders;
- _writeToStream = true;
- _countSize = 0;
- WriteHeader(db, /* headerOptions, */ headerOffset);
-
- if (encodeHeaders)
- {
- CByteBuffer buf(_countSize);
- _outByte2.Init((Byte *)buf, _countSize);
-
- _countMode = false;
- _writeToStream = false;
- WriteHeader(db, /* headerOptions, */ headerOffset);
-
- if (_countSize != _outByte2.GetPos())
- return E_FAIL;
-
- CCompressionMethodMode encryptOptions;
- encryptOptions.PasswordIsDefined = options->PasswordIsDefined;
- encryptOptions.Password = options->Password;
- CEncoder encoder(headerOptions.CompressMainHeader ? *options : encryptOptions);
- CRecordVector<UInt64> packSizes;
- CObjectVector<CFolder> folders;
- COutFolders outFolders;
-
- RINOK(EncodeStream(
- EXTERNAL_CODECS_LOC_VARS
- encoder, buf,
- packSizes, folders, outFolders));
-
- _writeToStream = true;
-
- if (folders.Size() == 0)
- throw 1;
-
- WriteID(NID::kEncodedHeader);
- WritePackInfo(headerOffset, packSizes, CUInt32DefVector());
- WriteUnpackInfo(folders, outFolders);
- WriteByte(NID::kEnd);
- FOR_VECTOR (i, packSizes)
- headerOffset += packSizes[i];
- }
- RINOK(_outByte.Flush());
- headerCRC = CRC_GET_DIGEST(_crc);
- headerSize = _outByte.GetProcessedSize();
- }
- #ifdef _7Z_VOL
- if (_endMarker)
- {
- CFinishHeader h;
- h.NextHeaderSize = headerSize;
- h.NextHeaderCRC = headerCRC;
- h.NextHeaderOffset =
- UInt64(0) - (headerSize +
- 4 + kFinishHeaderSize);
- h.ArchiveStartOffset = h.NextHeaderOffset - headerOffset;
- h.AdditionalStartBlockSize = 0;
- RINOK(WriteFinishHeader(h));
- return WriteFinishSignature();
- }
- else
- #endif
- {
- CStartHeader h;
- h.NextHeaderSize = headerSize;
- h.NextHeaderCRC = headerCRC;
- h.NextHeaderOffset = headerOffset;
- RINOK(Stream->Seek(_prefixHeaderPos, STREAM_SEEK_SET, NULL));
- return WriteStartHeader(h);
- }
-}
-
-void CUInt32DefVector::SetItem(unsigned index, bool defined, UInt32 value)
-{
- while (index >= Defs.Size())
- Defs.Add(false);
- Defs[index] = defined;
- if (!defined)
- return;
- while (index >= Vals.Size())
- Vals.Add(0);
- Vals[index] = value;
-}
-
-void CUInt64DefVector::SetItem(unsigned index, bool defined, UInt64 value)
-{
- while (index >= Defs.Size())
- Defs.Add(false);
- Defs[index] = defined;
- if (!defined)
- return;
- while (index >= Vals.Size())
- Vals.Add(0);
- Vals[index] = value;
-}
-
-void CArchiveDatabaseOut::AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name)
-{
- unsigned index = Files.Size();
- CTime.SetItem(index, file2.CTimeDefined, file2.CTime);
- ATime.SetItem(index, file2.ATimeDefined, file2.ATime);
- MTime.SetItem(index, file2.MTimeDefined, file2.MTime);
- StartPos.SetItem(index, file2.StartPosDefined, file2.StartPos);
- Attrib.SetItem(index, file2.AttribDefined, file2.Attrib);
- SetItem_Anti(index, file2.IsAnti);
- // SetItem_Aux(index, file2.IsAux);
- Names.Add(name);
- Files.Add(file);
-}
-
-}}
+// 7zOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/AutoPtr.h"
+// #include "../../../Common/UTFConvert.h"
+
+#include "../../Common/StreamObjects.h"
+
+#include "7zOut.h"
+
+namespace NArchive {
+namespace N7z {
+
+static void FillSignature(Byte *buf)
+{
+ memcpy(buf, kSignature, kSignatureSize);
+ buf[kSignatureSize] = kMajorVersion;
+ buf[kSignatureSize + 1] = 4;
+}
+
+#ifdef Z7_7Z_VOL
+HRESULT COutArchive::WriteFinishSignature()
+{
+ RINOK(WriteDirect(kFinishSignature, kSignatureSize));
+ CArchiveVersion av;
+ av.Major = kMajorVersion;
+ av.Minor = 2;
+ RINOK(WriteDirectByte(av.Major));
+ return WriteDirectByte(av.Minor);
+}
+#endif
+
+static void SetUInt32(Byte *p, UInt32 d)
+{
+ for (int i = 0; i < 4; i++, d >>= 8)
+ p[i] = (Byte)d;
+}
+
+static void SetUInt64(Byte *p, UInt64 d)
+{
+ for (int i = 0; i < 8; i++, d >>= 8)
+ p[i] = (Byte)d;
+}
+
+HRESULT COutArchive::WriteStartHeader(const CStartHeader &h)
+{
+ Byte buf[32];
+ FillSignature(buf);
+ SetUInt64(buf + 8 + 4, h.NextHeaderOffset);
+ SetUInt64(buf + 8 + 12, h.NextHeaderSize);
+ SetUInt32(buf + 8 + 20, h.NextHeaderCRC);
+ SetUInt32(buf + 8, CrcCalc(buf + 8 + 4, 20));
+ return WriteDirect(buf, sizeof(buf));
+}
+
+#ifdef Z7_7Z_VOL
+HRESULT COutArchive::WriteFinishHeader(const CFinishHeader &h)
+{
+ CCRC crc;
+ crc.UpdateUInt64(h.NextHeaderOffset);
+ crc.UpdateUInt64(h.NextHeaderSize);
+ crc.UpdateUInt32(h.NextHeaderCRC);
+ crc.UpdateUInt64(h.ArchiveStartOffset);
+ crc.UpdateUInt64(h.AdditionalStartBlockSize);
+ RINOK(WriteDirectUInt32(crc.GetDigest()));
+ RINOK(WriteDirectUInt64(h.NextHeaderOffset));
+ RINOK(WriteDirectUInt64(h.NextHeaderSize));
+ RINOK(WriteDirectUInt32(h.NextHeaderCRC));
+ RINOK(WriteDirectUInt64(h.ArchiveStartOffset));
+ return WriteDirectUInt64(h.AdditionalStartBlockSize);
+}
+#endif
+
+HRESULT COutArchive::Create_and_WriteStartPrefix(ISequentialOutStream *stream /* , bool endMarker */)
+{
+ Close();
+ #ifdef Z7_7Z_VOL
+ // endMarker = false;
+ _endMarker = endMarker;
+ #endif
+ SeqStream = stream;
+ // if (!endMarker)
+ {
+ SeqStream.QueryInterface(IID_IOutStream, &Stream);
+ if (!Stream)
+ {
+ return E_NOTIMPL;
+ // endMarker = true;
+ }
+ RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_signatureHeaderPos))
+ Byte buf[32];
+ FillSignature(buf);
+ memset(&buf[8], 0, 32 - 8);
+ return WriteDirect(buf, sizeof(buf));
+ }
+ #ifdef Z7_7Z_VOL
+ if (endMarker)
+ {
+ /*
+ CStartHeader sh;
+ sh.NextHeaderOffset = (UInt32)(Int32)-1;
+ sh.NextHeaderSize = (UInt32)(Int32)-1;
+ sh.NextHeaderCRC = 0;
+ WriteStartHeader(sh);
+ return S_OK;
+ */
+ }
+ #endif
+}
+
+void COutArchive::Close()
+{
+ SeqStream.Release();
+ Stream.Release();
+}
+
+UInt64 COutArchive::GetPos() const
+{
+ if (_countMode)
+ return _countSize;
+ if (_writeToStream)
+ return _outByte.GetProcessedSize();
+ return _outByte2.GetPos();
+}
+
+void COutArchive::WriteBytes(const void *data, size_t size)
+{
+ if (_countMode)
+ _countSize += size;
+ else if (_writeToStream)
+ {
+ _outByte.WriteBytes(data, size);
+ _crc = CrcUpdate(_crc, data, size);
+ }
+ else
+ _outByte2.WriteBytes(data, size);
+}
+
+void COutArchive::WriteByte(Byte b)
+{
+ if (_countMode)
+ _countSize++;
+ else if (_writeToStream)
+ {
+ _outByte.WriteByte(b);
+ _crc = CRC_UPDATE_BYTE(_crc, b);
+ }
+ else
+ _outByte2.WriteByte(b);
+}
+
+void COutArchive::WriteUInt32(UInt32 value)
+{
+ for (int i = 0; i < 4; i++)
+ {
+ WriteByte((Byte)value);
+ value >>= 8;
+ }
+}
+
+void COutArchive::WriteUInt64(UInt64 value)
+{
+ for (int i = 0; i < 8; i++)
+ {
+ WriteByte((Byte)value);
+ value >>= 8;
+ }
+}
+
+void COutArchive::WriteNumber(UInt64 value)
+{
+ Byte firstByte = 0;
+ Byte mask = 0x80;
+ int i;
+ for (i = 0; i < 8; i++)
+ {
+ if (value < ((UInt64(1) << ( 7 * (i + 1)))))
+ {
+ firstByte |= Byte(value >> (8 * i));
+ break;
+ }
+ firstByte |= mask;
+ mask = (Byte)(mask >> 1);
+ }
+ WriteByte(firstByte);
+ for (; i > 0; i--)
+ {
+ WriteByte((Byte)value);
+ value >>= 8;
+ }
+}
+
+static unsigned GetBigNumberSize(UInt64 value)
+{
+ unsigned i;
+ for (i = 1; i < 9; i++)
+ if (value < (((UInt64)1 << (i * 7))))
+ break;
+ return i;
+}
+
+#ifdef Z7_7Z_VOL
+UInt32 COutArchive::GetVolHeadersSize(UInt64 dataSize, int nameLength, bool props)
+{
+ UInt32 result = GetBigNumberSize(dataSize) * 2 + 41;
+ if (nameLength != 0)
+ {
+ nameLength = (nameLength + 1) * 2;
+ result += nameLength + GetBigNumberSize(nameLength) + 2;
+ }
+ if (props)
+ {
+ result += 20;
+ }
+ if (result >= 128)
+ result++;
+ result += kSignatureSize + 2 + kFinishHeaderSize;
+ return result;
+}
+
+UInt64 COutArchive::GetVolPureSize(UInt64 volSize, int nameLength, bool props)
+{
+ UInt32 headersSizeBase = COutArchive::GetVolHeadersSize(1, nameLength, props);
+ int testSize;
+ if (volSize > headersSizeBase)
+ testSize = volSize - headersSizeBase;
+ else
+ testSize = 1;
+ UInt32 headersSize = COutArchive::GetVolHeadersSize(testSize, nameLength, props);
+ UInt64 pureSize = 1;
+ if (volSize > headersSize)
+ pureSize = volSize - headersSize;
+ return pureSize;
+}
+#endif
+
+void COutArchive::WriteFolder(const CFolder &folder)
+{
+ WriteNumber(folder.Coders.Size());
+ unsigned i;
+
+ for (i = 0; i < folder.Coders.Size(); i++)
+ {
+ const CCoderInfo &coder = folder.Coders[i];
+ {
+ UInt64 id = coder.MethodID;
+ unsigned idSize;
+ for (idSize = 1; idSize < sizeof(id); idSize++)
+ if ((id >> (8 * idSize)) == 0)
+ break;
+ // idSize &= 0xF; // idSize is smaller than 16 already
+ Byte temp[16];
+ for (unsigned t = idSize; t != 0; t--, id >>= 8)
+ temp[t] = (Byte)(id & 0xFF);
+
+ unsigned b = idSize;
+ const bool isComplex = !coder.IsSimpleCoder();
+ b |= (isComplex ? 0x10 : 0);
+
+ const size_t propsSize = coder.Props.Size();
+ b |= ((propsSize != 0) ? 0x20 : 0);
+ temp[0] = (Byte)b;
+ WriteBytes(temp, idSize + 1);
+ if (isComplex)
+ {
+ WriteNumber(coder.NumStreams);
+ WriteNumber(1); // NumOutStreams;
+ }
+ if (propsSize == 0)
+ continue;
+ WriteNumber(propsSize);
+ WriteBytes(coder.Props, propsSize);
+ }
+ }
+
+ for (i = 0; i < folder.Bonds.Size(); i++)
+ {
+ const CBond &bond = folder.Bonds[i];
+ WriteNumber(bond.PackIndex);
+ WriteNumber(bond.UnpackIndex);
+ }
+
+ if (folder.PackStreams.Size() > 1)
+ for (i = 0; i < folder.PackStreams.Size(); i++)
+ WriteNumber(folder.PackStreams[i]);
+}
+
+void COutArchive::WriteBoolVector(const CBoolVector &boolVector)
+{
+ Byte b = 0;
+ Byte mask = 0x80;
+ FOR_VECTOR (i, boolVector)
+ {
+ if (boolVector[i])
+ b |= mask;
+ mask = (Byte)(mask >> 1);
+ if (mask == 0)
+ {
+ WriteByte(b);
+ mask = 0x80;
+ b = 0;
+ }
+ }
+ if (mask != 0x80)
+ WriteByte(b);
+}
+
+static inline unsigned Bv_GetSizeInBytes(const CBoolVector &v) { return ((unsigned)v.Size() + 7) / 8; }
+
+void COutArchive::WritePropBoolVector(Byte id, const CBoolVector &boolVector)
+{
+ WriteByte(id);
+ WriteNumber(Bv_GetSizeInBytes(boolVector));
+ WriteBoolVector(boolVector);
+}
+
+unsigned BoolVector_CountSum(const CBoolVector &v);
+
+void COutArchive::WriteHashDigests(const CUInt32DefVector &digests)
+{
+ const unsigned numDefined = BoolVector_CountSum(digests.Defs);
+ if (numDefined == 0)
+ return;
+
+ WriteByte(NID::kCRC);
+ if (numDefined == digests.Defs.Size())
+ WriteByte(1);
+ else
+ {
+ WriteByte(0);
+ WriteBoolVector(digests.Defs);
+ }
+
+ for (unsigned i = 0; i < digests.Defs.Size(); i++)
+ if (digests.Defs[i])
+ WriteUInt32(digests.Vals[i]);
+}
+
+void COutArchive::WritePackInfo(
+ UInt64 dataOffset,
+ const CRecordVector<UInt64> &packSizes,
+ const CUInt32DefVector &packCRCs)
+{
+ if (packSizes.IsEmpty())
+ return;
+ WriteByte(NID::kPackInfo);
+ WriteNumber(dataOffset);
+ WriteNumber(packSizes.Size());
+ WriteByte(NID::kSize);
+ FOR_VECTOR (i, packSizes)
+ WriteNumber(packSizes[i]);
+
+ WriteHashDigests(packCRCs);
+
+ WriteByte(NID::kEnd);
+}
+
+void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders, const COutFolders &outFolders)
+{
+ if (folders.IsEmpty())
+ return;
+
+ WriteByte(NID::kUnpackInfo);
+
+ WriteByte(NID::kFolder);
+ WriteNumber(folders.Size());
+ {
+ WriteByte(0);
+ FOR_VECTOR (i, folders)
+ WriteFolder(folders[i]);
+ }
+
+ WriteByte(NID::kCodersUnpackSize);
+ FOR_VECTOR (i, outFolders.CoderUnpackSizes)
+ WriteNumber(outFolders.CoderUnpackSizes[i]);
+
+ WriteHashDigests(outFolders.FolderUnpackCRCs);
+
+ WriteByte(NID::kEnd);
+}
+
+void COutArchive::WriteSubStreamsInfo(const CObjectVector<CFolder> &folders,
+ const COutFolders &outFolders,
+ const CRecordVector<UInt64> &unpackSizes,
+ const CUInt32DefVector &digests)
+{
+ const CRecordVector<CNum> &numUnpackStreamsInFolders = outFolders.NumUnpackStreamsVector;
+ WriteByte(NID::kSubStreamsInfo);
+
+ unsigned i;
+ for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
+ if (numUnpackStreamsInFolders[i] != 1)
+ {
+ WriteByte(NID::kNumUnpackStream);
+ for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
+ WriteNumber(numUnpackStreamsInFolders[i]);
+ break;
+ }
+
+ for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
+ if (numUnpackStreamsInFolders[i] > 1)
+ {
+ WriteByte(NID::kSize);
+ CNum index = 0;
+ for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
+ {
+ CNum num = numUnpackStreamsInFolders[i];
+ for (CNum j = 0; j < num; j++)
+ {
+ if (j + 1 != num)
+ WriteNumber(unpackSizes[index]);
+ index++;
+ }
+ }
+ break;
+ }
+
+ CUInt32DefVector digests2;
+
+ unsigned digestIndex = 0;
+ for (i = 0; i < folders.Size(); i++)
+ {
+ unsigned numSubStreams = (unsigned)numUnpackStreamsInFolders[i];
+ if (numSubStreams == 1 && outFolders.FolderUnpackCRCs.ValidAndDefined(i))
+ digestIndex++;
+ else
+ for (unsigned j = 0; j < numSubStreams; j++, digestIndex++)
+ {
+ digests2.Defs.Add(digests.Defs[digestIndex]);
+ digests2.Vals.Add(digests.Vals[digestIndex]);
+ }
+ }
+ WriteHashDigests(digests2);
+ WriteByte(NID::kEnd);
+}
+
+// 7-Zip 4.50 - 4.58 contain BUG, so they do not support .7z archives with Unknown field.
+
+void COutArchive::SkipToAligned(unsigned pos, unsigned alignShifts)
+{
+ if (!_useAlign)
+ return;
+
+ const unsigned alignSize = (unsigned)1 << alignShifts;
+ pos += (unsigned)GetPos();
+ pos &= (alignSize - 1);
+ if (pos == 0)
+ return;
+ unsigned skip = alignSize - pos;
+ if (skip < 2)
+ skip += alignSize;
+ skip -= 2;
+ WriteByte(NID::kDummy);
+ WriteByte((Byte)skip);
+ for (unsigned i = 0; i < skip; i++)
+ WriteByte(0);
+}
+
+void COutArchive::WriteAlignedBools(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSizeShifts)
+{
+ const unsigned bvSize = (numDefined == v.Size()) ? 0 : Bv_GetSizeInBytes(v);
+ const UInt64 dataSize = ((UInt64)numDefined << itemSizeShifts) + bvSize + 2;
+ SkipToAligned(3 + bvSize + GetBigNumberSize(dataSize), itemSizeShifts);
+
+ WriteByte(type);
+ WriteNumber(dataSize);
+ if (numDefined == v.Size())
+ WriteByte(1);
+ else
+ {
+ WriteByte(0);
+ WriteBoolVector(v);
+ }
+ WriteByte(0); // 0 means no switching to external stream
+}
+
+void COutArchive::WriteUInt64DefVector(const CUInt64DefVector &v, Byte type)
+{
+ const unsigned numDefined = BoolVector_CountSum(v.Defs);
+ if (numDefined == 0)
+ return;
+
+ WriteAlignedBools(v.Defs, numDefined, type, 3);
+
+ for (unsigned i = 0; i < v.Defs.Size(); i++)
+ if (v.Defs[i])
+ WriteUInt64(v.Vals[i]);
+}
+
+HRESULT COutArchive::EncodeStream(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CEncoder &encoder, const CByteBuffer &data,
+ CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders)
+{
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> stream = streamSpec;
+ streamSpec->Init(data, data.Size());
+ outFolders.FolderUnpackCRCs.Defs.Add(true);
+ outFolders.FolderUnpackCRCs.Vals.Add(CrcCalc(data, data.Size()));
+ // outFolders.NumUnpackStreamsVector.Add(1);
+ const UInt64 dataSize64 = data.Size();
+ const UInt64 expectSize = data.Size();
+ RINOK(encoder.Encode1(
+ EXTERNAL_CODECS_LOC_VARS
+ stream,
+ // NULL,
+ &dataSize64, // inSizeForReduce
+ expectSize,
+ folders.AddNew(),
+ // outFolders.CoderUnpackSizes, unpackSize,
+ SeqStream, packSizes, NULL))
+ if (!streamSpec->WasFinished())
+ return E_FAIL;
+ encoder.Encode_Post(dataSize64, outFolders.CoderUnpackSizes);
+ return S_OK;
+}
+
+void COutArchive::WriteHeader(
+ const CArchiveDatabaseOut &db,
+ // const CHeaderOptions &headerOptions,
+ UInt64 &headerOffset)
+{
+ /*
+ bool thereIsSecure = (db.SecureBuf.Size() != 0);
+ */
+ _useAlign = true;
+
+ {
+ UInt64 packSize = 0;
+ FOR_VECTOR (i, db.PackSizes)
+ packSize += db.PackSizes[i];
+ headerOffset = packSize;
+ }
+
+
+ WriteByte(NID::kHeader);
+
+ /*
+ {
+ // It's example for per archive properies writing
+
+ WriteByte(NID::kArchiveProperties);
+
+ // you must use random 40-bit number that will identify you
+ // then you can use same kDeveloperID for any properties and methods
+ const UInt64 kDeveloperID = 0x123456789A; // change that value to real random 40-bit number
+
+ #define GENERATE_7Z_ID(developerID, subID) (((UInt64)0x3F << 56) | ((UInt64)developerID << 16) | subID)
+
+ {
+ const UInt64 kSubID = 0x1; // you can use small number for subID
+ const UInt64 kID = GENERATE_7Z_ID(kDeveloperID, kSubID);
+ WriteNumber(kID);
+ const unsigned kPropsSize = 3; // it's example size
+ WriteNumber(kPropsSize);
+ for (unsigned i = 0; i < kPropsSize; i++)
+ WriteByte((Byte)(i & 0xFF));
+ }
+ {
+ const UInt64 kSubID = 0x2; // you can use small number for subID
+ const UInt64 kID = GENERATE_7Z_ID(kDeveloperID, kSubID);
+ WriteNumber(kID);
+ const unsigned kPropsSize = 5; // it's example size
+ WriteNumber(kPropsSize);
+ for (unsigned i = 0; i < kPropsSize; i++)
+ WriteByte((Byte)(i + 16));
+ }
+ WriteByte(NID::kEnd);
+ }
+ */
+
+ if (db.Folders.Size() > 0)
+ {
+ WriteByte(NID::kMainStreamsInfo);
+ WritePackInfo(0, db.PackSizes, db.PackCRCs);
+ WriteUnpackInfo(db.Folders, (const COutFolders &)db);
+
+ CRecordVector<UInt64> unpackSizes;
+ CUInt32DefVector digests;
+ FOR_VECTOR (i, db.Files)
+ {
+ const CFileItem &file = db.Files[i];
+ if (!file.HasStream)
+ continue;
+ unpackSizes.Add(file.Size);
+ digests.Defs.Add(file.CrcDefined);
+ digests.Vals.Add(file.Crc);
+ }
+
+ WriteSubStreamsInfo(db.Folders, (const COutFolders &)db, unpackSizes, digests);
+ WriteByte(NID::kEnd);
+ }
+
+ if (db.Files.IsEmpty())
+ {
+ WriteByte(NID::kEnd);
+ return;
+ }
+
+ WriteByte(NID::kFilesInfo);
+ WriteNumber(db.Files.Size());
+
+ {
+ /* ---------- Empty Streams ---------- */
+ CBoolVector emptyStreamVector;
+ emptyStreamVector.ClearAndSetSize(db.Files.Size());
+ unsigned numEmptyStreams = 0;
+ {
+ FOR_VECTOR (i, db.Files)
+ if (db.Files[i].HasStream)
+ emptyStreamVector[i] = false;
+ else
+ {
+ emptyStreamVector[i] = true;
+ numEmptyStreams++;
+ }
+ }
+
+ if (numEmptyStreams != 0)
+ {
+ WritePropBoolVector(NID::kEmptyStream, emptyStreamVector);
+
+ CBoolVector emptyFileVector, antiVector;
+ emptyFileVector.ClearAndSetSize(numEmptyStreams);
+ antiVector.ClearAndSetSize(numEmptyStreams);
+ bool thereAreEmptyFiles = false, thereAreAntiItems = false;
+ unsigned cur = 0;
+
+ FOR_VECTOR (i, db.Files)
+ {
+ const CFileItem &file = db.Files[i];
+ if (file.HasStream)
+ continue;
+ emptyFileVector[cur] = !file.IsDir;
+ if (!file.IsDir)
+ thereAreEmptyFiles = true;
+ bool isAnti = db.IsItemAnti(i);
+ antiVector[cur] = isAnti;
+ if (isAnti)
+ thereAreAntiItems = true;
+ cur++;
+ }
+
+ if (thereAreEmptyFiles)
+ WritePropBoolVector(NID::kEmptyFile, emptyFileVector);
+ if (thereAreAntiItems)
+ WritePropBoolVector(NID::kAnti, antiVector);
+ }
+ }
+
+
+ {
+ /* ---------- Names ---------- */
+
+ unsigned numDefined = 0;
+ size_t namesDataSize = 0;
+ FOR_VECTOR (i, db.Files)
+ {
+ const UString &name = db.Names[i];
+ if (!name.IsEmpty())
+ numDefined++;
+ const size_t numUtfChars =
+ /*
+ #if WCHAR_MAX > 0xffff
+ Get_Num_Utf16_chars_from_wchar_string(name.Ptr());
+ #else
+ */
+ name.Len();
+ // #endif
+ namesDataSize += (numUtfChars + 1) * 2;
+ }
+
+ if (numDefined > 0)
+ {
+ namesDataSize++;
+ SkipToAligned(2 + GetBigNumberSize(namesDataSize), 4);
+
+ WriteByte(NID::kName);
+ WriteNumber(namesDataSize);
+ WriteByte(0);
+ FOR_VECTOR (i, db.Files)
+ {
+ const UString &name = db.Names[i];
+ for (unsigned t = 0; t <= name.Len(); t++)
+ {
+ wchar_t c = name[t];
+
+ /*
+ #if WCHAR_MAX > 0xffff
+ if (c >= 0x10000)
+ {
+ c -= 0x10000;
+ if (c < (1 << 20))
+ {
+ unsigned c0 = 0xd800 + ((c >> 10) & 0x3FF);
+ WriteByte((Byte)c0);
+ WriteByte((Byte)(c0 >> 8));
+ c = 0xdc00 + (c & 0x3FF);
+ }
+ else
+ c = '_'; // we change character unsupported by UTF16
+ }
+ #endif
+ */
+
+ WriteByte((Byte)c);
+ WriteByte((Byte)(c >> 8));
+ }
+ }
+ }
+ }
+
+ /* if (headerOptions.WriteCTime) */ WriteUInt64DefVector(db.CTime, NID::kCTime);
+ /* if (headerOptions.WriteATime) */ WriteUInt64DefVector(db.ATime, NID::kATime);
+ /* if (headerOptions.WriteMTime) */ WriteUInt64DefVector(db.MTime, NID::kMTime);
+ WriteUInt64DefVector(db.StartPos, NID::kStartPos);
+
+ {
+ /* ---------- Write Attrib ---------- */
+ const unsigned numDefined = BoolVector_CountSum(db.Attrib.Defs);
+
+ if (numDefined != 0)
+ {
+ WriteAlignedBools(db.Attrib.Defs, numDefined, NID::kWinAttrib, 2);
+ FOR_VECTOR (i, db.Attrib.Defs)
+ {
+ if (db.Attrib.Defs[i])
+ WriteUInt32(db.Attrib.Vals[i]);
+ }
+ }
+ }
+
+ /*
+ {
+ // ---------- Write IsAux ----------
+ if (BoolVector_CountSum(db.IsAux) != 0)
+ WritePropBoolVector(NID::kIsAux, db.IsAux);
+ }
+
+ {
+ // ---------- Write Parent ----------
+ CBoolVector boolVector;
+ boolVector.Reserve(db.Files.Size());
+ unsigned numIsDir = 0;
+ unsigned numParentLinks = 0;
+ for (i = 0; i < db.Files.Size(); i++)
+ {
+ const CFileItem &file = db.Files[i];
+ bool defined = !file.IsAltStream;
+ boolVector.Add(defined);
+ if (defined)
+ numIsDir++;
+ if (file.Parent >= 0)
+ numParentLinks++;
+ }
+ if (numParentLinks > 0)
+ {
+ // WriteAlignedBools(boolVector, numDefined, NID::kParent, 2);
+ const unsigned bvSize = (numIsDir == boolVector.Size()) ? 0 : Bv_GetSizeInBytes(boolVector);
+ const UInt64 dataSize = (UInt64)db.Files.Size() * 4 + bvSize + 1;
+ SkipToAligned(2 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), 2);
+
+ WriteByte(NID::kParent);
+ WriteNumber(dataSize);
+ if (numIsDir == boolVector.Size())
+ WriteByte(1);
+ else
+ {
+ WriteByte(0);
+ WriteBoolVector(boolVector);
+ }
+ for (i = 0; i < db.Files.Size(); i++)
+ {
+ const CFileItem &file = db.Files[i];
+ // if (file.Parent >= 0)
+ WriteUInt32(file.Parent);
+ }
+ }
+ }
+
+ if (thereIsSecure)
+ {
+ UInt64 secureDataSize = 1 + 4 +
+ db.SecureBuf.Size() +
+ db.SecureSizes.Size() * 4;
+ // secureDataSize += db.SecureIDs.Size() * 4;
+ for (i = 0; i < db.SecureIDs.Size(); i++)
+ secureDataSize += GetBigNumberSize(db.SecureIDs[i]);
+ SkipToAligned(2 + GetBigNumberSize(secureDataSize), 2);
+ WriteByte(NID::kNtSecure);
+ WriteNumber(secureDataSize);
+ WriteByte(0);
+ WriteUInt32(db.SecureSizes.Size());
+ for (i = 0; i < db.SecureSizes.Size(); i++)
+ WriteUInt32(db.SecureSizes[i]);
+ WriteBytes(db.SecureBuf, db.SecureBuf.Size());
+ for (i = 0; i < db.SecureIDs.Size(); i++)
+ {
+ WriteNumber(db.SecureIDs[i]);
+ // WriteUInt32(db.SecureIDs[i]);
+ }
+ }
+ */
+
+ WriteByte(NID::kEnd); // for files
+ WriteByte(NID::kEnd); // for headers
+}
+
+HRESULT COutArchive::WriteDatabase(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const CArchiveDatabaseOut &db,
+ const CCompressionMethodMode *options,
+ const CHeaderOptions &headerOptions)
+{
+ if (!db.CheckNumFiles())
+ return E_FAIL;
+
+ UInt64 headerOffset;
+ UInt32 headerCRC;
+ UInt64 headerSize;
+ if (db.IsEmpty())
+ {
+ headerSize = 0;
+ headerOffset = 0;
+ headerCRC = CrcCalc(NULL, 0);
+ }
+ else
+ {
+ bool encodeHeaders = false;
+ if (options)
+ if (options->IsEmpty())
+ options = NULL;
+ if (options)
+ if (options->PasswordIsDefined || headerOptions.CompressMainHeader)
+ encodeHeaders = true;
+
+ _outByte.SetStream(SeqStream);
+ _outByte.Init();
+ _crc = CRC_INIT_VAL;
+ _countMode = encodeHeaders;
+ _writeToStream = true;
+ _countSize = 0;
+ WriteHeader(db, /* headerOptions, */ headerOffset);
+
+ if (encodeHeaders)
+ {
+ CByteBuffer buf(_countSize);
+ _outByte2.Init((Byte *)buf, _countSize);
+
+ _countMode = false;
+ _writeToStream = false;
+ WriteHeader(db, /* headerOptions, */ headerOffset);
+
+ if (_countSize != _outByte2.GetPos())
+ return E_FAIL;
+
+ CCompressionMethodMode encryptOptions;
+ encryptOptions.PasswordIsDefined = options->PasswordIsDefined;
+ encryptOptions.Password = options->Password;
+ CEncoder encoder(headerOptions.CompressMainHeader ? *options : encryptOptions);
+ CRecordVector<UInt64> packSizes;
+ CObjectVector<CFolder> folders;
+ COutFolders outFolders;
+
+ RINOK(EncodeStream(
+ EXTERNAL_CODECS_LOC_VARS
+ encoder, buf,
+ packSizes, folders, outFolders))
+
+ _writeToStream = true;
+
+ if (folders.Size() == 0)
+ throw 1;
+
+ WriteID(NID::kEncodedHeader);
+ WritePackInfo(headerOffset, packSizes, CUInt32DefVector());
+ WriteUnpackInfo(folders, outFolders);
+ WriteByte(NID::kEnd);
+ FOR_VECTOR (i, packSizes)
+ headerOffset += packSizes[i];
+ }
+ RINOK(_outByte.Flush())
+ headerCRC = CRC_GET_DIGEST(_crc);
+ headerSize = _outByte.GetProcessedSize();
+ }
+ #ifdef Z7_7Z_VOL
+ if (_endMarker)
+ {
+ CFinishHeader h;
+ h.NextHeaderSize = headerSize;
+ h.NextHeaderCRC = headerCRC;
+ h.NextHeaderOffset =
+ UInt64(0) - (headerSize +
+ 4 + kFinishHeaderSize);
+ h.ArchiveStartOffset = h.NextHeaderOffset - headerOffset;
+ h.AdditionalStartBlockSize = 0;
+ RINOK(WriteFinishHeader(h));
+ return WriteFinishSignature();
+ }
+ else
+ #endif
+ if (Stream)
+ {
+ CStartHeader h;
+ h.NextHeaderSize = headerSize;
+ h.NextHeaderCRC = headerCRC;
+ h.NextHeaderOffset = headerOffset;
+ RINOK(Stream->Seek((Int64)_signatureHeaderPos, STREAM_SEEK_SET, NULL))
+ return WriteStartHeader(h);
+ }
+ return S_OK;
+}
+
+void CUInt32DefVector::SetItem(unsigned index, bool defined, UInt32 value)
+{
+ while (index >= Defs.Size())
+ Defs.Add(false);
+ Defs[index] = defined;
+ if (!defined)
+ return;
+ while (index >= Vals.Size())
+ Vals.Add(0);
+ Vals[index] = value;
+}
+
+void CUInt64DefVector::SetItem(unsigned index, bool defined, UInt64 value)
+{
+ while (index >= Defs.Size())
+ Defs.Add(false);
+ Defs[index] = defined;
+ if (!defined)
+ return;
+ while (index >= Vals.Size())
+ Vals.Add(0);
+ Vals[index] = value;
+}
+
+void CArchiveDatabaseOut::AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name)
+{
+ unsigned index = Files.Size();
+ CTime.SetItem(index, file2.CTimeDefined, file2.CTime);
+ ATime.SetItem(index, file2.ATimeDefined, file2.ATime);
+ MTime.SetItem(index, file2.MTimeDefined, file2.MTime);
+ StartPos.SetItem(index, file2.StartPosDefined, file2.StartPos);
+ Attrib.SetItem(index, file2.AttribDefined, file2.Attrib);
+ SetItem_Anti(index, file2.IsAnti);
+ // SetItem_Aux(index, file2.IsAux);
+ Names.Add(name);
+ Files.Add(file);
+}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zOut.h b/CPP/7zip/Archive/7z/7zOut.h
index 12e965f..940cafc 100644
--- a/CPP/7zip/Archive/7z/7zOut.h
+++ b/CPP/7zip/Archive/7z/7zOut.h
@@ -1,335 +1,330 @@
-// 7zOut.h
-
-#ifndef __7Z_OUT_H
-#define __7Z_OUT_H
-
-#include "7zCompressionMode.h"
-#include "7zEncode.h"
-#include "7zHeader.h"
-#include "7zItem.h"
-
-#include "../../Common/OutBuffer.h"
-#include "../../Common/StreamUtils.h"
-
-namespace NArchive {
-namespace N7z {
-
-class CWriteBufferLoc
-{
- Byte *_data;
- size_t _size;
- size_t _pos;
-public:
- CWriteBufferLoc(): _size(0), _pos(0) {}
- void Init(Byte *data, size_t size)
- {
- _data = data;
- _size = size;
- _pos = 0;
- }
- void WriteBytes(const void *data, size_t size)
- {
- if (size == 0)
- return;
- if (size > _size - _pos)
- throw 1;
- memcpy(_data + _pos, data, size);
- _pos += size;
- }
- void WriteByte(Byte b)
- {
- if (_size == _pos)
- throw 1;
- _data[_pos++] = b;
- }
- size_t GetPos() const { return _pos; }
-};
-
-
-struct CHeaderOptions
-{
- bool CompressMainHeader;
- /*
- bool WriteCTime;
- bool WriteATime;
- bool WriteMTime;
- */
-
- CHeaderOptions():
- CompressMainHeader(true)
- /*
- , WriteCTime(false)
- , WriteATime(false)
- , WriteMTime(true)
- */
- {}
-};
-
-
-struct CFileItem2
-{
- UInt64 CTime;
- UInt64 ATime;
- UInt64 MTime;
- UInt64 StartPos;
- UInt32 Attrib;
-
- bool CTimeDefined;
- bool ATimeDefined;
- bool MTimeDefined;
- bool StartPosDefined;
- bool AttribDefined;
- bool IsAnti;
- // bool IsAux;
-
- /*
- void Init()
- {
- CTimeDefined = false;
- ATimeDefined = false;
- MTimeDefined = false;
- StartPosDefined = false;
- AttribDefined = false;
- IsAnti = false;
- // IsAux = false;
- }
- */
-};
-
-
-struct COutFolders
-{
- CUInt32DefVector FolderUnpackCRCs; // Now we use it for headers only.
-
- CRecordVector<CNum> NumUnpackStreamsVector;
- CRecordVector<UInt64> CoderUnpackSizes; // including unpack sizes of bond coders
-
- void OutFoldersClear()
- {
- FolderUnpackCRCs.Clear();
- NumUnpackStreamsVector.Clear();
- CoderUnpackSizes.Clear();
- }
-
- void OutFoldersReserveDown()
- {
- FolderUnpackCRCs.ReserveDown();
- NumUnpackStreamsVector.ReserveDown();
- CoderUnpackSizes.ReserveDown();
- }
-};
-
-
-struct CArchiveDatabaseOut: public COutFolders
-{
- CRecordVector<UInt64> PackSizes;
- CUInt32DefVector PackCRCs;
- CObjectVector<CFolder> Folders;
-
- CRecordVector<CFileItem> Files;
- UStringVector Names;
- CUInt64DefVector CTime;
- CUInt64DefVector ATime;
- CUInt64DefVector MTime;
- CUInt64DefVector StartPos;
- CUInt32DefVector Attrib;
- CBoolVector IsAnti;
-
- /*
- CBoolVector IsAux;
-
- CByteBuffer SecureBuf;
- CRecordVector<UInt32> SecureSizes;
- CRecordVector<UInt32> SecureIDs;
-
- void ClearSecure()
- {
- SecureBuf.Free();
- SecureSizes.Clear();
- SecureIDs.Clear();
- }
- */
-
- void Clear()
- {
- OutFoldersClear();
-
- PackSizes.Clear();
- PackCRCs.Clear();
- Folders.Clear();
-
- Files.Clear();
- Names.Clear();
- CTime.Clear();
- ATime.Clear();
- MTime.Clear();
- StartPos.Clear();
- Attrib.Clear();
- IsAnti.Clear();
-
- /*
- IsAux.Clear();
- ClearSecure();
- */
- }
-
- void ReserveDown()
- {
- OutFoldersReserveDown();
-
- PackSizes.ReserveDown();
- PackCRCs.ReserveDown();
- Folders.ReserveDown();
-
- Files.ReserveDown();
- Names.ReserveDown();
- CTime.ReserveDown();
- ATime.ReserveDown();
- MTime.ReserveDown();
- StartPos.ReserveDown();
- Attrib.ReserveDown();
- IsAnti.ReserveDown();
-
- /*
- IsAux.ReserveDown();
- */
- }
-
- bool IsEmpty() const
- {
- return (
- PackSizes.IsEmpty() &&
- NumUnpackStreamsVector.IsEmpty() &&
- Folders.IsEmpty() &&
- Files.IsEmpty());
- }
-
- bool CheckNumFiles() const
- {
- unsigned size = Files.Size();
- return (
- CTime.CheckSize(size)
- && ATime.CheckSize(size)
- && MTime.CheckSize(size)
- && StartPos.CheckSize(size)
- && Attrib.CheckSize(size)
- && (size == IsAnti.Size() || IsAnti.Size() == 0));
- }
-
- bool IsItemAnti(unsigned index) const { return (index < IsAnti.Size() && IsAnti[index]); }
- // bool IsItemAux(unsigned index) const { return (index < IsAux.Size() && IsAux[index]); }
-
- void SetItem_Anti(unsigned index, bool isAnti)
- {
- while (index >= IsAnti.Size())
- IsAnti.Add(false);
- IsAnti[index] = isAnti;
- }
- /*
- void SetItem_Aux(unsigned index, bool isAux)
- {
- while (index >= IsAux.Size())
- IsAux.Add(false);
- IsAux[index] = isAux;
- }
- */
-
- void AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name);
-};
-
-
-class COutArchive
-{
- UInt64 _prefixHeaderPos;
-
- HRESULT WriteDirect(const void *data, UInt32 size) { return WriteStream(SeqStream, data, size); }
-
- UInt64 GetPos() const;
- void WriteBytes(const void *data, size_t size);
- void WriteBytes(const CByteBuffer &data) { WriteBytes(data, data.Size()); }
- void WriteByte(Byte b);
- void WriteUInt32(UInt32 value);
- void WriteUInt64(UInt64 value);
- void WriteNumber(UInt64 value);
- void WriteID(UInt64 value) { WriteNumber(value); }
-
- void WriteFolder(const CFolder &folder);
- HRESULT WriteFileHeader(const CFileItem &itemInfo);
- void WriteBoolVector(const CBoolVector &boolVector);
- void WritePropBoolVector(Byte id, const CBoolVector &boolVector);
-
- void WriteHashDigests(const CUInt32DefVector &digests);
-
- void WritePackInfo(
- UInt64 dataOffset,
- const CRecordVector<UInt64> &packSizes,
- const CUInt32DefVector &packCRCs);
-
- void WriteUnpackInfo(
- const CObjectVector<CFolder> &folders,
- const COutFolders &outFolders);
-
- void WriteSubStreamsInfo(
- const CObjectVector<CFolder> &folders,
- const COutFolders &outFolders,
- const CRecordVector<UInt64> &unpackSizes,
- const CUInt32DefVector &digests);
-
- void SkipToAligned(unsigned pos, unsigned alignShifts);
- void WriteAlignedBools(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSizeShifts);
- void WriteUInt64DefVector(const CUInt64DefVector &v, Byte type);
-
- HRESULT EncodeStream(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CEncoder &encoder, const CByteBuffer &data,
- CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders);
- void WriteHeader(
- const CArchiveDatabaseOut &db,
- // const CHeaderOptions &headerOptions,
- UInt64 &headerOffset);
-
- bool _countMode;
- bool _writeToStream;
- size_t _countSize;
- UInt32 _crc;
- COutBuffer _outByte;
- CWriteBufferLoc _outByte2;
-
- #ifdef _7Z_VOL
- bool _endMarker;
- #endif
-
- bool _useAlign;
-
- HRESULT WriteSignature();
- #ifdef _7Z_VOL
- HRESULT WriteFinishSignature();
- #endif
- HRESULT WriteStartHeader(const CStartHeader &h);
- #ifdef _7Z_VOL
- HRESULT WriteFinishHeader(const CFinishHeader &h);
- #endif
- CMyComPtr<IOutStream> Stream;
-public:
-
- COutArchive() { _outByte.Create(1 << 16); }
- CMyComPtr<ISequentialOutStream> SeqStream;
- HRESULT Create(ISequentialOutStream *stream, bool endMarker);
- void Close();
- HRESULT SkipPrefixArchiveHeader();
- HRESULT WriteDatabase(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const CArchiveDatabaseOut &db,
- const CCompressionMethodMode *options,
- const CHeaderOptions &headerOptions);
-
- #ifdef _7Z_VOL
- static UInt32 GetVolHeadersSize(UInt64 dataSize, int nameLength = 0, bool props = false);
- static UInt64 GetVolPureSize(UInt64 volSize, int nameLength = 0, bool props = false);
- #endif
-
-};
-
-}}
-
-#endif
+// 7zOut.h
+
+#ifndef ZIP7_INC_7Z_OUT_H
+#define ZIP7_INC_7Z_OUT_H
+
+#include "7zCompressionMode.h"
+#include "7zEncode.h"
+#include "7zHeader.h"
+#include "7zItem.h"
+
+#include "../../Common/OutBuffer.h"
+#include "../../Common/StreamUtils.h"
+
+namespace NArchive {
+namespace N7z {
+
+const unsigned k_StartHeadersRewriteSize = 32;
+
+class CWriteBufferLoc
+{
+ Byte *_data;
+ size_t _size;
+ size_t _pos;
+public:
+ CWriteBufferLoc(): _size(0), _pos(0) {}
+ void Init(Byte *data, size_t size)
+ {
+ _data = data;
+ _size = size;
+ _pos = 0;
+ }
+ void WriteBytes(const void *data, size_t size)
+ {
+ if (size == 0)
+ return;
+ if (size > _size - _pos)
+ throw 1;
+ memcpy(_data + _pos, data, size);
+ _pos += size;
+ }
+ void WriteByte(Byte b)
+ {
+ if (_size == _pos)
+ throw 1;
+ _data[_pos++] = b;
+ }
+ size_t GetPos() const { return _pos; }
+};
+
+
+struct CHeaderOptions
+{
+ bool CompressMainHeader;
+ /*
+ bool WriteCTime;
+ bool WriteATime;
+ bool WriteMTime;
+ */
+
+ CHeaderOptions():
+ CompressMainHeader(true)
+ /*
+ , WriteCTime(false)
+ , WriteATime(false)
+ , WriteMTime(true)
+ */
+ {}
+};
+
+
+struct CFileItem2
+{
+ UInt64 CTime;
+ UInt64 ATime;
+ UInt64 MTime;
+ UInt64 StartPos;
+ UInt32 Attrib;
+
+ bool CTimeDefined;
+ bool ATimeDefined;
+ bool MTimeDefined;
+ bool StartPosDefined;
+ bool AttribDefined;
+ bool IsAnti;
+ // bool IsAux;
+
+ /*
+ void Init()
+ {
+ CTimeDefined = false;
+ ATimeDefined = false;
+ MTimeDefined = false;
+ StartPosDefined = false;
+ AttribDefined = false;
+ IsAnti = false;
+ // IsAux = false;
+ }
+ */
+};
+
+
+struct COutFolders
+{
+ CUInt32DefVector FolderUnpackCRCs; // Now we use it for headers only.
+
+ CRecordVector<CNum> NumUnpackStreamsVector;
+ CRecordVector<UInt64> CoderUnpackSizes; // including unpack sizes of bond coders
+
+ void OutFoldersClear()
+ {
+ FolderUnpackCRCs.Clear();
+ NumUnpackStreamsVector.Clear();
+ CoderUnpackSizes.Clear();
+ }
+
+ void OutFoldersReserveDown()
+ {
+ FolderUnpackCRCs.ReserveDown();
+ NumUnpackStreamsVector.ReserveDown();
+ CoderUnpackSizes.ReserveDown();
+ }
+};
+
+
+struct CArchiveDatabaseOut: public COutFolders
+{
+ CRecordVector<UInt64> PackSizes;
+ CUInt32DefVector PackCRCs;
+ CObjectVector<CFolder> Folders;
+
+ CRecordVector<CFileItem> Files;
+ UStringVector Names;
+ CUInt64DefVector CTime;
+ CUInt64DefVector ATime;
+ CUInt64DefVector MTime;
+ CUInt64DefVector StartPos;
+ CUInt32DefVector Attrib;
+ CBoolVector IsAnti;
+
+ /*
+ CBoolVector IsAux;
+
+ CByteBuffer SecureBuf;
+ CRecordVector<UInt32> SecureSizes;
+ CRecordVector<UInt32> SecureIDs;
+
+ void ClearSecure()
+ {
+ SecureBuf.Free();
+ SecureSizes.Clear();
+ SecureIDs.Clear();
+ }
+ */
+
+ void Clear()
+ {
+ OutFoldersClear();
+
+ PackSizes.Clear();
+ PackCRCs.Clear();
+ Folders.Clear();
+
+ Files.Clear();
+ Names.Clear();
+ CTime.Clear();
+ ATime.Clear();
+ MTime.Clear();
+ StartPos.Clear();
+ Attrib.Clear();
+ IsAnti.Clear();
+
+ /*
+ IsAux.Clear();
+ ClearSecure();
+ */
+ }
+
+ void ReserveDown()
+ {
+ OutFoldersReserveDown();
+
+ PackSizes.ReserveDown();
+ PackCRCs.ReserveDown();
+ Folders.ReserveDown();
+
+ Files.ReserveDown();
+ Names.ReserveDown();
+ CTime.ReserveDown();
+ ATime.ReserveDown();
+ MTime.ReserveDown();
+ StartPos.ReserveDown();
+ Attrib.ReserveDown();
+ IsAnti.ReserveDown();
+
+ /*
+ IsAux.ReserveDown();
+ */
+ }
+
+ bool IsEmpty() const
+ {
+ return (
+ PackSizes.IsEmpty() &&
+ NumUnpackStreamsVector.IsEmpty() &&
+ Folders.IsEmpty() &&
+ Files.IsEmpty());
+ }
+
+ bool CheckNumFiles() const
+ {
+ unsigned size = Files.Size();
+ return (
+ CTime.CheckSize(size)
+ && ATime.CheckSize(size)
+ && MTime.CheckSize(size)
+ && StartPos.CheckSize(size)
+ && Attrib.CheckSize(size)
+ && (size == IsAnti.Size() || IsAnti.Size() == 0));
+ }
+
+ bool IsItemAnti(unsigned index) const { return (index < IsAnti.Size() && IsAnti[index]); }
+ // bool IsItemAux(unsigned index) const { return (index < IsAux.Size() && IsAux[index]); }
+
+ void SetItem_Anti(unsigned index, bool isAnti)
+ {
+ while (index >= IsAnti.Size())
+ IsAnti.Add(false);
+ IsAnti[index] = isAnti;
+ }
+ /*
+ void SetItem_Aux(unsigned index, bool isAux)
+ {
+ while (index >= IsAux.Size())
+ IsAux.Add(false);
+ IsAux[index] = isAux;
+ }
+ */
+
+ void AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name);
+};
+
+
+class COutArchive
+{
+ HRESULT WriteDirect(const void *data, UInt32 size) { return WriteStream(SeqStream, data, size); }
+
+ UInt64 GetPos() const;
+ void WriteBytes(const void *data, size_t size);
+ void WriteBytes(const CByteBuffer &data) { WriteBytes(data, data.Size()); }
+ void WriteByte(Byte b);
+ void WriteUInt32(UInt32 value);
+ void WriteUInt64(UInt64 value);
+ void WriteNumber(UInt64 value);
+ void WriteID(UInt64 value) { WriteNumber(value); }
+
+ void WriteFolder(const CFolder &folder);
+ HRESULT WriteFileHeader(const CFileItem &itemInfo);
+ void WriteBoolVector(const CBoolVector &boolVector);
+ void WritePropBoolVector(Byte id, const CBoolVector &boolVector);
+
+ void WriteHashDigests(const CUInt32DefVector &digests);
+
+ void WritePackInfo(
+ UInt64 dataOffset,
+ const CRecordVector<UInt64> &packSizes,
+ const CUInt32DefVector &packCRCs);
+
+ void WriteUnpackInfo(
+ const CObjectVector<CFolder> &folders,
+ const COutFolders &outFolders);
+
+ void WriteSubStreamsInfo(
+ const CObjectVector<CFolder> &folders,
+ const COutFolders &outFolders,
+ const CRecordVector<UInt64> &unpackSizes,
+ const CUInt32DefVector &digests);
+
+ void SkipToAligned(unsigned pos, unsigned alignShifts);
+ void WriteAlignedBools(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSizeShifts);
+ void WriteUInt64DefVector(const CUInt64DefVector &v, Byte type);
+
+ HRESULT EncodeStream(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CEncoder &encoder, const CByteBuffer &data,
+ CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders);
+ void WriteHeader(
+ const CArchiveDatabaseOut &db,
+ // const CHeaderOptions &headerOptions,
+ UInt64 &headerOffset);
+
+ bool _countMode;
+ bool _writeToStream;
+ bool _useAlign;
+ #ifdef Z7_7Z_VOL
+ bool _endMarker;
+ #endif
+ UInt32 _crc;
+ size_t _countSize;
+ CWriteBufferLoc _outByte2;
+ COutBuffer _outByte;
+ UInt64 _signatureHeaderPos;
+ CMyComPtr<IOutStream> Stream;
+
+ #ifdef Z7_7Z_VOL
+ HRESULT WriteFinishSignature();
+ HRESULT WriteFinishHeader(const CFinishHeader &h);
+ #endif
+ HRESULT WriteStartHeader(const CStartHeader &h);
+
+public:
+ CMyComPtr<ISequentialOutStream> SeqStream;
+
+ COutArchive() { _outByte.Create(1 << 16); }
+ HRESULT Create_and_WriteStartPrefix(ISequentialOutStream *stream /* , bool endMarker */);
+ void Close();
+ HRESULT WriteDatabase(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const CArchiveDatabaseOut &db,
+ const CCompressionMethodMode *options,
+ const CHeaderOptions &headerOptions);
+
+ #ifdef Z7_7Z_VOL
+ static UInt32 GetVolHeadersSize(UInt64 dataSize, int nameLength = 0, bool props = false);
+ static UInt64 GetVolPureSize(UInt64 volSize, int nameLength = 0, bool props = false);
+ #endif
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zProperties.cpp b/CPP/7zip/Archive/7z/7zProperties.cpp
index 388ac76..d3b3cbe 100644
--- a/CPP/7zip/Archive/7z/7zProperties.cpp
+++ b/CPP/7zip/Archive/7z/7zProperties.cpp
@@ -1,174 +1,182 @@
-// 7zProperties.cpp
-
-#include "StdAfx.h"
-
-#include "7zProperties.h"
-#include "7zHeader.h"
-#include "7zHandler.h"
-
-// #define _MULTI_PACK
-
-namespace NArchive {
-namespace N7z {
-
-struct CPropMap
-{
- UInt32 FilePropID;
- CStatProp StatProp;
-};
-
-static const CPropMap kPropMap[] =
-{
- { NID::kName, { NULL, kpidPath, VT_BSTR } },
- { NID::kSize, { NULL, kpidSize, VT_UI8 } },
- { NID::kPackInfo, { NULL, kpidPackSize, VT_UI8 } },
-
- #ifdef _MULTI_PACK
- { 100, { "Pack0", kpidPackedSize0, VT_UI8 } },
- { 101, { "Pack1", kpidPackedSize1, VT_UI8 } },
- { 102, { "Pack2", kpidPackedSize2, VT_UI8 } },
- { 103, { "Pack3", kpidPackedSize3, VT_UI8 } },
- { 104, { "Pack4", kpidPackedSize4, VT_UI8 } },
- #endif
-
- { NID::kCTime, { NULL, kpidCTime, VT_FILETIME } },
- { NID::kMTime, { NULL, kpidMTime, VT_FILETIME } },
- { NID::kATime, { NULL, kpidATime, VT_FILETIME } },
- { NID::kWinAttrib, { NULL, kpidAttrib, VT_UI4 } },
- { NID::kStartPos, { NULL, kpidPosition, VT_UI8 } },
-
- { NID::kCRC, { NULL, kpidCRC, VT_UI4 } },
-
-// { NID::kIsAux, { NULL, kpidIsAux, VT_BOOL } },
- { NID::kAnti, { NULL, kpidIsAnti, VT_BOOL } }
-
- #ifndef _SFX
- ,
- { 97, { NULL, kpidEncrypted, VT_BOOL } },
- { 98, { NULL, kpidMethod, VT_BSTR } },
- { 99, { NULL, kpidBlock, VT_UI4 } }
- #endif
-};
-
-static void CopyOneItem(CRecordVector<UInt64> &src,
- CRecordVector<UInt64> &dest, UInt32 item)
-{
- FOR_VECTOR (i, src)
- if (src[i] == item)
- {
- dest.Add(item);
- src.Delete(i);
- return;
- }
-}
-
-static void RemoveOneItem(CRecordVector<UInt64> &src, UInt32 item)
-{
- FOR_VECTOR (i, src)
- if (src[i] == item)
- {
- src.Delete(i);
- return;
- }
-}
-
-static void InsertToHead(CRecordVector<UInt64> &dest, UInt32 item)
-{
- FOR_VECTOR (i, dest)
- if (dest[i] == item)
- {
- dest.Delete(i);
- break;
- }
- dest.Insert(0, item);
-}
-
-#define COPY_ONE_ITEM(id) CopyOneItem(fileInfoPopIDs, _fileInfoPopIDs, NID::id);
-
-void CHandler::FillPopIDs()
-{
- _fileInfoPopIDs.Clear();
-
- #ifdef _7Z_VOL
- if (_volumes.Size() < 1)
- return;
- const CVolume &volume = _volumes.Front();
- const CArchiveDatabaseEx &_db = volume.Database;
- #endif
-
- CRecordVector<UInt64> fileInfoPopIDs = _db.ArcInfo.FileInfoPopIDs;
-
- RemoveOneItem(fileInfoPopIDs, NID::kEmptyStream);
- RemoveOneItem(fileInfoPopIDs, NID::kEmptyFile);
- /*
- RemoveOneItem(fileInfoPopIDs, NID::kParent);
- RemoveOneItem(fileInfoPopIDs, NID::kNtSecure);
- */
-
- COPY_ONE_ITEM(kName);
- COPY_ONE_ITEM(kAnti);
- COPY_ONE_ITEM(kSize);
- COPY_ONE_ITEM(kPackInfo);
- COPY_ONE_ITEM(kCTime);
- COPY_ONE_ITEM(kMTime);
- COPY_ONE_ITEM(kATime);
- COPY_ONE_ITEM(kWinAttrib);
- COPY_ONE_ITEM(kCRC);
- COPY_ONE_ITEM(kComment);
-
- _fileInfoPopIDs += fileInfoPopIDs;
-
- #ifndef _SFX
- _fileInfoPopIDs.Add(97);
- _fileInfoPopIDs.Add(98);
- _fileInfoPopIDs.Add(99);
- #endif
-
- #ifdef _MULTI_PACK
- _fileInfoPopIDs.Add(100);
- _fileInfoPopIDs.Add(101);
- _fileInfoPopIDs.Add(102);
- _fileInfoPopIDs.Add(103);
- _fileInfoPopIDs.Add(104);
- #endif
-
- #ifndef _SFX
- InsertToHead(_fileInfoPopIDs, NID::kMTime);
- InsertToHead(_fileInfoPopIDs, NID::kPackInfo);
- InsertToHead(_fileInfoPopIDs, NID::kSize);
- InsertToHead(_fileInfoPopIDs, NID::kName);
- #endif
-}
-
-STDMETHODIMP CHandler::GetNumberOfProperties(UInt32 *numProps)
-{
- *numProps = _fileInfoPopIDs.Size();
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)
-{
- if (index >= _fileInfoPopIDs.Size())
- return E_INVALIDARG;
- UInt64 id = _fileInfoPopIDs[index];
- for (unsigned i = 0; i < ARRAY_SIZE(kPropMap); i++)
- {
- const CPropMap &pr = kPropMap[i];
- if (pr.FilePropID == id)
- {
- const CStatProp &st = pr.StatProp;
- *propID = st.PropID;
- *varType = st.vt;
- /*
- if (st.lpwstrName)
- *name = ::SysAllocString(st.lpwstrName);
- else
- */
- *name = NULL;
- return S_OK;
- }
- }
- return E_INVALIDARG;
-}
-
-}}
+// 7zProperties.cpp
+
+#include "StdAfx.h"
+
+#include "7zHandler.h"
+#include "7zProperties.h"
+
+namespace NArchive {
+namespace N7z {
+
+struct CPropMap
+{
+ Byte FilePropID;
+ // CStatProp StatProp;
+ VARTYPE vt;
+ UInt32 StatPropID;
+};
+
+// #define STAT_PROP(name, id, vt) { name, id, vt }
+#define STAT_PROP(name, id, vt) vt, id
+
+#define STAT_PROP2(id, vt) STAT_PROP(NULL, id, vt)
+
+#define k_7z_id_Encrypted 97
+#define k_7z_id_Method 98
+#define k_7z_id_Block 99
+
+static const CPropMap kPropMap[] =
+{
+ { NID::kName, STAT_PROP2(kpidPath, VT_BSTR) },
+ { NID::kSize, STAT_PROP2(kpidSize, VT_UI8) },
+ { NID::kPackInfo, STAT_PROP2(kpidPackSize, VT_UI8) },
+
+ #ifdef Z7_7Z_SHOW_PACK_STREAMS_SIZES
+#define k_7z_id_PackedSize0 100
+ { k_7z_id_PackedSize0 + 0, STAT_PROP("Pack0", kpidPackedSize0, VT_UI8) },
+ { k_7z_id_PackedSize0 + 1, STAT_PROP("Pack1", kpidPackedSize1, VT_UI8) },
+ { k_7z_id_PackedSize0 + 2, STAT_PROP("Pack2", kpidPackedSize2, VT_UI8) },
+ { k_7z_id_PackedSize0 + 3, STAT_PROP("Pack3", kpidPackedSize3, VT_UI8) },
+ { k_7z_id_PackedSize0 + 4, STAT_PROP("Pack4", kpidPackedSize4, VT_UI8) },
+ #endif
+
+ { NID::kCTime, STAT_PROP2(kpidCTime, VT_FILETIME) },
+ { NID::kMTime, STAT_PROP2(kpidMTime, VT_FILETIME) },
+ { NID::kATime, STAT_PROP2(kpidATime, VT_FILETIME) },
+ { NID::kWinAttrib, STAT_PROP2(kpidAttrib, VT_UI4) },
+ { NID::kStartPos, STAT_PROP2(kpidPosition, VT_UI8) },
+
+ { NID::kCRC, STAT_PROP2(kpidCRC, VT_UI4) },
+ // { NID::kIsAux, STAT_PROP2(kpidIsAux, VT_BOOL) },
+ { NID::kAnti, STAT_PROP2(kpidIsAnti, VT_BOOL) }
+
+ #ifndef Z7_SFX
+ , { k_7z_id_Encrypted, STAT_PROP2(kpidEncrypted, VT_BOOL) }
+ , { k_7z_id_Method, STAT_PROP2(kpidMethod, VT_BSTR) }
+ , { k_7z_id_Block, STAT_PROP2(kpidBlock, VT_UI4) }
+ #endif
+};
+
+static void CopyOneItem(CRecordVector<UInt64> &src,
+ CRecordVector<UInt64> &dest, const UInt32 item)
+{
+ FOR_VECTOR (i, src)
+ if (src[i] == item)
+ {
+ dest.Add(item);
+ src.Delete(i);
+ return;
+ }
+}
+
+static void RemoveOneItem(CRecordVector<UInt64> &src, const UInt32 item)
+{
+ FOR_VECTOR (i, src)
+ if (src[i] == item)
+ {
+ src.Delete(i);
+ return;
+ }
+}
+
+static void InsertToHead(CRecordVector<UInt64> &dest, const UInt32 item)
+{
+ FOR_VECTOR (i, dest)
+ if (dest[i] == item)
+ {
+ dest.Delete(i);
+ break;
+ }
+ dest.Insert(0, item);
+}
+
+#define COPY_ONE_ITEM(id) CopyOneItem(fileInfoPopIDs, _fileInfoPopIDs, NID::id);
+
+void CHandler::FillPopIDs()
+{
+ _fileInfoPopIDs.Clear();
+
+ #ifdef Z7_7Z_VOL
+ if (_volumes.Size() < 1)
+ return;
+ const CVolume &volume = _volumes.Front();
+ const CArchiveDatabaseEx &_db = volume.Database;
+ #endif
+
+ CRecordVector<UInt64> fileInfoPopIDs = _db.ArcInfo.FileInfoPopIDs;
+
+ RemoveOneItem(fileInfoPopIDs, NID::kEmptyStream);
+ RemoveOneItem(fileInfoPopIDs, NID::kEmptyFile);
+ /*
+ RemoveOneItem(fileInfoPopIDs, NID::kParent);
+ RemoveOneItem(fileInfoPopIDs, NID::kNtSecure);
+ */
+
+ COPY_ONE_ITEM(kName)
+ COPY_ONE_ITEM(kAnti)
+ COPY_ONE_ITEM(kSize)
+ COPY_ONE_ITEM(kPackInfo)
+ COPY_ONE_ITEM(kCTime)
+ COPY_ONE_ITEM(kMTime)
+ COPY_ONE_ITEM(kATime)
+ COPY_ONE_ITEM(kWinAttrib)
+ COPY_ONE_ITEM(kCRC)
+ COPY_ONE_ITEM(kComment)
+
+ _fileInfoPopIDs += fileInfoPopIDs;
+
+ #ifndef Z7_SFX
+ _fileInfoPopIDs.Add(k_7z_id_Encrypted);
+ _fileInfoPopIDs.Add(k_7z_id_Method);
+ _fileInfoPopIDs.Add(k_7z_id_Block);
+ #endif
+
+ #ifdef Z7_7Z_SHOW_PACK_STREAMS_SIZES
+ for (unsigned i = 0; i < 5; i++)
+ _fileInfoPopIDs.Add(k_7z_id_PackedSize0 + i);
+ #endif
+
+ #ifndef Z7_SFX
+ InsertToHead(_fileInfoPopIDs, NID::kMTime);
+ InsertToHead(_fileInfoPopIDs, NID::kPackInfo);
+ InsertToHead(_fileInfoPopIDs, NID::kSize);
+ InsertToHead(_fileInfoPopIDs, NID::kName);
+ #endif
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfProperties(UInt32 *numProps))
+{
+ *numProps = _fileInfoPopIDs.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType))
+{
+ if (index >= _fileInfoPopIDs.Size())
+ return E_INVALIDARG;
+ const UInt64 id = _fileInfoPopIDs[index];
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kPropMap); i++)
+ {
+ const CPropMap &pr = kPropMap[i];
+ if (pr.FilePropID == id)
+ {
+ *propID = pr.StatPropID;
+ *varType = pr.vt;
+ /*
+ const CStatProp &st = pr.StatProp;
+ *propID = st.PropID;
+ *varType = st.vt;
+ */
+ /*
+ if (st.lpwstrName)
+ *name = ::SysAllocString(st.lpwstrName);
+ else
+ */
+ *name = NULL;
+ return S_OK;
+ }
+ }
+ return E_INVALIDARG;
+}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zProperties.h b/CPP/7zip/Archive/7z/7zProperties.h
index 7b78130..091c39b 100644
--- a/CPP/7zip/Archive/7z/7zProperties.h
+++ b/CPP/7zip/Archive/7z/7zProperties.h
@@ -1,22 +1,26 @@
-// 7zProperties.h
-
-#ifndef __7Z_PROPERTIES_H
-#define __7Z_PROPERTIES_H
-
-#include "../../PropID.h"
-
-namespace NArchive {
-namespace N7z {
-
-enum
-{
- kpidPackedSize0 = kpidUserDefined,
- kpidPackedSize1,
- kpidPackedSize2,
- kpidPackedSize3,
- kpidPackedSize4
-};
-
-}}
-
-#endif
+// 7zProperties.h
+
+#ifndef ZIP7_INC_7Z_PROPERTIES_H
+#define ZIP7_INC_7Z_PROPERTIES_H
+
+#include "../../PropID.h"
+
+namespace NArchive {
+namespace N7z {
+
+// #define Z7_7Z_SHOW_PACK_STREAMS_SIZES // for debug
+
+#ifdef Z7_7Z_SHOW_PACK_STREAMS_SIZES
+enum
+{
+ kpidPackedSize0 = kpidUserDefined,
+ kpidPackedSize1,
+ kpidPackedSize2,
+ kpidPackedSize3,
+ kpidPackedSize4
+};
+#endif
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zRegister.cpp b/CPP/7zip/Archive/7z/7zRegister.cpp
index 3e8cfb6..1f11079 100644
--- a/CPP/7zip/Archive/7z/7zRegister.cpp
+++ b/CPP/7zip/Archive/7z/7zRegister.cpp
@@ -1,21 +1,27 @@
-// 7zRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/RegisterArc.h"
-
-#include "7zHandler.h"
-
-namespace NArchive {
-namespace N7z {
-
-static Byte k_Signature_Dec[kSignatureSize] = {'7' + 1, 'z', 0xBC, 0xAF, 0x27, 0x1C};
-
-REGISTER_ARC_IO_DECREMENT_SIG(
- "7z", "7z", NULL, 7,
- k_Signature_Dec,
- 0,
- NArcInfoFlags::kFindSignature,
- NULL);
-
-}}
+// 7zRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "7zHandler.h"
+
+namespace NArchive {
+namespace N7z {
+
+static Byte k_Signature_Dec[kSignatureSize] = {'7' + 1, 'z', 0xBC, 0xAF, 0x27, 0x1C};
+
+REGISTER_ARC_IO_DECREMENT_SIG(
+ "7z", "7z", NULL, 7,
+ k_Signature_Dec,
+ 0,
+ NArcInfoFlags::kFindSignature
+ | NArcInfoFlags::kCTime
+ | NArcInfoFlags::kATime
+ | NArcInfoFlags::kMTime
+ | NArcInfoFlags::kMTime_Default
+ , TIME_PREC_TO_ARC_FLAGS_MASK(NFileTimeType::kWindows)
+ | TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT(NFileTimeType::kWindows)
+ , NULL)
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zSpecStream.cpp b/CPP/7zip/Archive/7z/7zSpecStream.cpp
index e9671a8..8b531bc 100644
--- a/CPP/7zip/Archive/7z/7zSpecStream.cpp
+++ b/CPP/7zip/Archive/7z/7zSpecStream.cpp
@@ -1,22 +1,31 @@
-// 7zSpecStream.cpp
-
-#include "StdAfx.h"
-
-#include "7zSpecStream.h"
-
-STDMETHODIMP CSequentialInStreamSizeCount2::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessedSize;
- HRESULT result = _stream->Read(data, size, &realProcessedSize);
- _size += realProcessedSize;
- if (processedSize)
- *processedSize = realProcessedSize;
- return result;
-}
-
-STDMETHODIMP CSequentialInStreamSizeCount2::GetSubStreamSize(UInt64 subStream, UInt64 *value)
-{
- if (!_getSubStreamSize)
- return E_NOTIMPL;
- return _getSubStreamSize->GetSubStreamSize(subStream, value);
-}
+// 7zSpecStream.cpp
+
+#include "StdAfx.h"
+
+#include "7zSpecStream.h"
+
+/*
+Z7_COM7F_IMF(CSequentialInStreamSizeCount2::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize;
+ const HRESULT result = _stream->Read(data, size, &realProcessedSize);
+ _size += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return result;
+}
+
+Z7_COM7F_IMF(CSequentialInStreamSizeCount2::GetSubStreamSize(UInt64 subStream, UInt64 *value))
+{
+ if (!_getSubStreamSize)
+ return E_NOTIMPL;
+ return _getSubStreamSize->GetSubStreamSize(subStream, value);
+}
+
+Z7_COM7F_IMF(CSequentialInStreamSizeCount2::GetNextInSubStream(UInt64 *streamIndexRes, ISequentialInStream **stream))
+{
+ if (!_compressGetSubStreamSize)
+ return E_NOTIMPL;
+ return _compressGetSubStreamSize->GetNextInSubStream(streamIndexRes, stream);
+}
+*/
diff --git a/CPP/7zip/Archive/7z/7zSpecStream.h b/CPP/7zip/Archive/7z/7zSpecStream.h
index 0994128..78f631e 100644
--- a/CPP/7zip/Archive/7z/7zSpecStream.h
+++ b/CPP/7zip/Archive/7z/7zSpecStream.h
@@ -1,35 +1,49 @@
-// 7zSpecStream.h
-
-#ifndef __7Z_SPEC_STREAM_H
-#define __7Z_SPEC_STREAM_H
-
-#include "../../../Common/MyCom.h"
-
-#include "../../ICoder.h"
-
-class CSequentialInStreamSizeCount2:
- public ISequentialInStream,
- public ICompressGetSubStreamSize,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialInStream> _stream;
- CMyComPtr<ICompressGetSubStreamSize> _getSubStreamSize;
- UInt64 _size;
-public:
- void Init(ISequentialInStream *stream)
- {
- _size = 0;
- _getSubStreamSize.Release();
- _stream = stream;
- _stream.QueryInterface(IID_ICompressGetSubStreamSize, &_getSubStreamSize);
- }
- UInt64 GetSize() const { return _size; }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, ICompressGetSubStreamSize)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-
- STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value);
-};
-
-#endif
+// 7zSpecStream.h
+
+#ifndef ZIP7_INC_7Z_SPEC_STREAM_H
+#define ZIP7_INC_7Z_SPEC_STREAM_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../ICoder.h"
+
+/*
+#define Z7_COM_QI_ENTRY_AG_2(i, sub0, sub) else if (iid == IID_ ## i) \
+ { if (!sub) RINOK(sub0->QueryInterface(IID_ ## i, (void **)&sub)) \
+ { i *ti = this; *outObject = ti; } }
+
+class CSequentialInStreamSizeCount2 Z7_final:
+ public ISequentialInStream,
+ public ICompressGetSubStreamSize,
+ public ICompressInSubStreams,
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ISequentialInStream)
+ Z7_COM_QI_ENTRY(ICompressGetSubStreamSize)
+ Z7_COM_QI_ENTRY_AG_2(ISequentialInStream, _stream, _compressGetSubStreamSize)
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+ Z7_IFACE_COM7_IMP(ICompressGetSubStreamSize)
+ Z7_IFACE_COM7_IMP(ICompressInSubStreams)
+
+ CMyComPtr<ISequentialInStream> _stream;
+ CMyComPtr<ICompressGetSubStreamSize> _getSubStreamSize;
+ CMyComPtr<ICompressInSubStreams> _compressGetSubStreamSize;
+ UInt64 _size;
+public:
+ void Init(ISequentialInStream *stream)
+ {
+ _size = 0;
+ _getSubStreamSize.Release();
+ _compressGetSubStreamSize.Release();
+ _stream = stream;
+ _stream.QueryInterface(IID_ICompressGetSubStreamSize, &_getSubStreamSize);
+ _stream.QueryInterface(IID_ICompressInSubStreams, &_compressGetSubStreamSize);
+ }
+ UInt64 GetSize() const { return _size; }
+};
+*/
+
+#endif
diff --git a/CPP/7zip/Archive/7z/7zUpdate.cpp b/CPP/7zip/Archive/7z/7zUpdate.cpp
index 5b156be..4e9ea5d 100644
--- a/CPP/7zip/Archive/7z/7zUpdate.cpp
+++ b/CPP/7zip/Archive/7z/7zUpdate.cpp
@@ -1,2500 +1,2991 @@
-// 7zUpdate.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/CpuArch.h"
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../Common/CreateCoder.h"
-#include "../../Common/LimitedStreams.h"
-#include "../../Common/ProgressUtils.h"
-
-#include "../../Compress/CopyCoder.h"
-
-#include "../Common/ItemNameUtils.h"
-
-#include "7zDecode.h"
-#include "7zEncode.h"
-#include "7zFolderInStream.h"
-#include "7zHandler.h"
-#include "7zOut.h"
-#include "7zUpdate.h"
-
-namespace NArchive {
-namespace N7z {
-
-
-#define k_X86 k_BCJ
-
-struct CFilterMode
-{
- UInt32 Id;
- UInt32 Delta;
-
- CFilterMode(): Id(0), Delta(0) {}
-
- void SetDelta()
- {
- if (Id == k_IA64)
- Delta = 16;
- else if (Id == k_ARM || Id == k_PPC || Id == k_SPARC)
- Delta = 4;
- else if (Id == k_ARMT)
- Delta = 2;
- else
- Delta = 0;
- }
-};
-
-
-/* ---------- PE ---------- */
-
-#define MZ_SIG 0x5A4D
-
-#define PE_SIG 0x00004550
-#define PE_OptHeader_Magic_32 0x10B
-#define PE_OptHeader_Magic_64 0x20B
-#define PE_SectHeaderSize 40
-#define PE_SECT_EXECUTE 0x20000000
-
-static int Parse_EXE(const Byte *buf, size_t size, CFilterMode *filterMode)
-{
- if (size < 512 || GetUi16(buf) != MZ_SIG)
- return 0;
-
- const Byte *p;
- UInt32 peOffset, optHeaderSize, filterId;
-
- peOffset = GetUi32(buf + 0x3C);
- if (peOffset >= 0x1000 || peOffset + 512 > size || (peOffset & 7) != 0)
- return 0;
- p = buf + peOffset;
- if (GetUi32(p) != PE_SIG)
- return 0;
- p += 4;
-
- switch (GetUi16(p))
- {
- case 0x014C:
- case 0x8664: filterId = k_X86; break;
-
- /*
- IMAGE_FILE_MACHINE_ARM 0x01C0 // ARM LE
- IMAGE_FILE_MACHINE_THUMB 0x01C2 // ARM Thumb / Thumb-2 LE
- IMAGE_FILE_MACHINE_ARMNT 0x01C4 // ARM Thumb-2, LE
- Note: We use ARM filter for 0x01C2. (WinCE 5 - 0x01C2) files mostly contain ARM code (not Thumb/Thumb-2).
- */
-
- case 0x01C0: // WinCE old
- case 0x01C2: filterId = k_ARM; break; // WinCE new
- case 0x01C4: filterId = k_ARMT; break; // WinRT
-
- case 0x0200: filterId = k_IA64; break;
- default: return 0;
- }
-
- optHeaderSize = GetUi16(p + 16);
- if (optHeaderSize > (1 << 10))
- return 0;
-
- p += 20; /* headerSize */
-
- switch (GetUi16(p))
- {
- case PE_OptHeader_Magic_32:
- case PE_OptHeader_Magic_64:
- break;
- default:
- return 0;
- }
-
- filterMode->Id = filterId;
- return 1;
-}
-
-
-/* ---------- ELF ---------- */
-
-#define ELF_SIG 0x464C457F
-
-#define ELF_CLASS_32 1
-#define ELF_CLASS_64 2
-
-#define ELF_DATA_2LSB 1
-#define ELF_DATA_2MSB 2
-
-static UInt16 Get16(const Byte *p, BoolInt be) { if (be) return (UInt16)GetBe16(p); return (UInt16)GetUi16(p); }
-static UInt32 Get32(const Byte *p, BoolInt be) { if (be) return GetBe32(p); return GetUi32(p); }
-// static UInt64 Get64(const Byte *p, BoolInt be) { if (be) return GetBe64(p); return GetUi64(p); }
-
-static int Parse_ELF(const Byte *buf, size_t size, CFilterMode *filterMode)
-{
- BoolInt /* is32, */ be;
- UInt32 filterId;
-
- if (size < 512 || buf[6] != 1) /* ver */
- return 0;
-
- if (GetUi32(buf) != ELF_SIG)
- return 0;
-
- switch (buf[4])
- {
- case ELF_CLASS_32: /* is32 = True; */ break;
- case ELF_CLASS_64: /* is32 = False; */ break;
- default: return 0;
- }
-
- switch (buf[5])
- {
- case ELF_DATA_2LSB: be = False; break;
- case ELF_DATA_2MSB: be = True; break;
- default: return 0;
- }
-
- switch (Get16(buf + 0x12, be))
- {
- case 3:
- case 6:
- case 62: filterId = k_X86; break;
- case 2:
- case 18:
- case 43: filterId = k_SPARC; break;
- case 20:
- case 21: if (!be) return 0; filterId = k_PPC; break;
- case 40: if ( be) return 0; filterId = k_ARM; break;
-
- /* Some IA-64 ELF exacutable have size that is not aligned for 16 bytes.
- So we don't use IA-64 filter for IA-64 ELF */
- // case 50: if ( be) return 0; filterId = k_IA64; break;
-
- default: return 0;
- }
-
- filterMode->Id = filterId;
- return 1;
-}
-
-
-
-/* ---------- Mach-O ---------- */
-
-#define MACH_SIG_BE_32 0xCEFAEDFE
-#define MACH_SIG_BE_64 0xCFFAEDFE
-#define MACH_SIG_LE_32 0xFEEDFACE
-#define MACH_SIG_LE_64 0xFEEDFACF
-
-#define MACH_ARCH_ABI64 (1 << 24)
-#define MACH_MACHINE_386 7
-#define MACH_MACHINE_ARM 12
-#define MACH_MACHINE_SPARC 14
-#define MACH_MACHINE_PPC 18
-#define MACH_MACHINE_PPC64 (MACH_ARCH_ABI64 | MACH_MACHINE_PPC)
-#define MACH_MACHINE_AMD64 (MACH_ARCH_ABI64 | MACH_MACHINE_386)
-
-static unsigned Parse_MACH(const Byte *buf, size_t size, CFilterMode *filterMode)
-{
- UInt32 filterId, numCommands, commandsSize;
-
- if (size < 512)
- return 0;
-
- BoolInt /* mode64, */ be;
- switch (GetUi32(buf))
- {
- case MACH_SIG_BE_32: /* mode64 = False; */ be = True; break;
- case MACH_SIG_BE_64: /* mode64 = True; */ be = True; break;
- case MACH_SIG_LE_32: /* mode64 = False; */ be = False; break;
- case MACH_SIG_LE_64: /* mode64 = True; */ be = False; break;
- default: return 0;
- }
-
- switch (Get32(buf + 4, be))
- {
- case MACH_MACHINE_386:
- case MACH_MACHINE_AMD64: filterId = k_X86; break;
- case MACH_MACHINE_ARM: if ( be) return 0; filterId = k_ARM; break;
- case MACH_MACHINE_SPARC: if (!be) return 0; filterId = k_SPARC; break;
- case MACH_MACHINE_PPC:
- case MACH_MACHINE_PPC64: if (!be) return 0; filterId = k_PPC; break;
- default: return 0;
- }
-
- numCommands = Get32(buf + 0x10, be);
- commandsSize = Get32(buf + 0x14, be);
-
- if (commandsSize > (1 << 24) || numCommands > (1 << 18))
- return 0;
-
- filterMode->Id = filterId;
- return 1;
-}
-
-
-/* ---------- WAV ---------- */
-
-#define WAV_SUBCHUNK_fmt 0x20746D66
-#define WAV_SUBCHUNK_data 0x61746164
-
-#define RIFF_SIG 0x46464952
-
-static BoolInt Parse_WAV(const Byte *buf, size_t size, CFilterMode *filterMode)
-{
- UInt32 subChunkSize, pos;
- if (size < 0x2C)
- return False;
-
- if (GetUi32(buf + 0) != RIFF_SIG ||
- GetUi32(buf + 8) != 0x45564157 || // WAVE
- GetUi32(buf + 0xC) != WAV_SUBCHUNK_fmt)
- return False;
- subChunkSize = GetUi32(buf + 0x10);
- /* [0x14 = format] = 1 (PCM) */
- if (subChunkSize < 0x10 || subChunkSize > 0x12 || GetUi16(buf + 0x14) != 1)
- return False;
-
- unsigned numChannels = GetUi16(buf + 0x16);
- unsigned bitsPerSample = GetUi16(buf + 0x22);
-
- if ((bitsPerSample & 0x7) != 0 || bitsPerSample >= 256 || numChannels >= 256)
- return False;
-
- pos = 0x14 + subChunkSize;
-
- const int kNumSubChunksTests = 10;
- // Do we need to scan more than 3 sub-chunks?
- for (int i = 0; i < kNumSubChunksTests; i++)
- {
- if (pos + 8 > size)
- return False;
- subChunkSize = GetUi32(buf + pos + 4);
- if (GetUi32(buf + pos) == WAV_SUBCHUNK_data)
- {
- unsigned delta = numChannels * (bitsPerSample >> 3);
- if (delta >= 256)
- return False;
- filterMode->Id = k_Delta;
- filterMode->Delta = delta;
- return True;
- }
- if (subChunkSize > (1 << 16))
- return False;
- pos += subChunkSize + 8;
- }
- return False;
-}
-
-static BoolInt ParseFile(const Byte *buf, size_t size, CFilterMode *filterMode)
-{
- filterMode->Id = 0;
- filterMode->Delta = 0;
-
- if (Parse_EXE(buf, size, filterMode)) return True;
- if (Parse_ELF(buf, size, filterMode)) return True;
- if (Parse_MACH(buf, size, filterMode)) return True;
- return Parse_WAV(buf, size, filterMode);
-}
-
-
-
-
-struct CFilterMode2: public CFilterMode
-{
- bool Encrypted;
- unsigned GroupIndex;
-
- CFilterMode2(): Encrypted(false) {}
-
- int Compare(const CFilterMode2 &m) const
- {
- if (!Encrypted)
- {
- if (m.Encrypted)
- return -1;
- }
- else if (!m.Encrypted)
- return 1;
-
- if (Id < m.Id) return -1;
- if (Id > m.Id) return 1;
-
- if (Delta < m.Delta) return -1;
- if (Delta > m.Delta) return 1;
-
- return 0;
- }
-
- bool operator ==(const CFilterMode2 &m) const
- {
- return Id == m.Id && Delta == m.Delta && Encrypted == m.Encrypted;
- }
-};
-
-static unsigned GetGroup(CRecordVector<CFilterMode2> &filters, const CFilterMode2 &m)
-{
- unsigned i;
- for (i = 0; i < filters.Size(); i++)
- {
- const CFilterMode2 &m2 = filters[i];
- if (m == m2)
- return i;
- /*
- if (m.Encrypted != m2.Encrypted)
- {
- if (!m.Encrypted)
- break;
- continue;
- }
-
- if (m.Id < m2.Id) break;
- if (m.Id != m2.Id) continue;
-
- if (m.Delta < m2.Delta) break;
- if (m.Delta != m2.Delta) continue;
- */
- }
- // filters.Insert(i, m);
- // return i;
- return filters.Add(m);
-}
-
-static inline bool Is86Filter(CMethodId m)
-{
- return (m == k_BCJ || m == k_BCJ2);
-}
-
-static inline bool IsExeFilter(CMethodId m)
-{
- switch (m)
- {
- case k_BCJ:
- case k_BCJ2:
- case k_ARM:
- case k_ARMT:
- case k_PPC:
- case k_SPARC:
- case k_IA64:
- return true;
- }
- return false;
-}
-
-static unsigned Get_FilterGroup_for_Folder(
- CRecordVector<CFilterMode2> &filters, const CFolderEx &f, bool extractFilter)
-{
- CFilterMode2 m;
- m.Id = 0;
- m.Delta = 0;
- m.Encrypted = f.IsEncrypted();
-
- if (extractFilter)
- {
- const CCoderInfo &coder = f.Coders[f.UnpackCoder];
-
- if (coder.MethodID == k_Delta)
- {
- if (coder.Props.Size() == 1)
- {
- m.Delta = (unsigned)coder.Props[0] + 1;
- m.Id = k_Delta;
- }
- }
- else if (IsExeFilter(coder.MethodID))
- {
- m.Id = (UInt32)coder.MethodID;
- if (m.Id == k_BCJ2)
- m.Id = k_BCJ;
- m.SetDelta();
- }
- }
-
- return GetGroup(filters, m);
-}
-
-
-
-
-static HRESULT WriteRange(IInStream *inStream, ISequentialOutStream *outStream,
- UInt64 position, UInt64 size, ICompressProgressInfo *progress)
-{
- RINOK(inStream->Seek(position, STREAM_SEEK_SET, 0));
- CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
- CMyComPtr<CLimitedSequentialInStream> inStreamLimited(streamSpec);
- streamSpec->SetStream(inStream);
- streamSpec->Init(size);
-
- NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
- CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
- RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress));
- return (copyCoderSpec->TotalSize == size ? S_OK : E_FAIL);
-}
-
-/*
-unsigned CUpdateItem::GetExtensionPos() const
-{
- int slashPos = Name.ReverseFind_PathSepar();
- int dotPos = Name.ReverseFind_Dot();
- if (dotPos <= slashPos)
- return Name.Len();
- return dotPos + 1;
-}
-
-UString CUpdateItem::GetExtension() const
-{
- return Name.Ptr(GetExtensionPos());
-}
-*/
-
-#define RINOZ(x) { int __tt = (x); if (__tt != 0) return __tt; }
-
-#define RINOZ_COMP(a, b) RINOZ(MyCompare(a, b))
-
-/*
-static int CompareBuffers(const CByteBuffer &a1, const CByteBuffer &a2)
-{
- size_t c1 = a1.GetCapacity();
- size_t c2 = a2.GetCapacity();
- RINOZ_COMP(c1, c2);
- for (size_t i = 0; i < c1; i++)
- RINOZ_COMP(a1[i], a2[i]);
- return 0;
-}
-
-static int CompareCoders(const CCoderInfo &c1, const CCoderInfo &c2)
-{
- RINOZ_COMP(c1.NumInStreams, c2.NumInStreams);
- RINOZ_COMP(c1.NumOutStreams, c2.NumOutStreams);
- RINOZ_COMP(c1.MethodID, c2.MethodID);
- return CompareBuffers(c1.Props, c2.Props);
-}
-
-static int CompareBonds(const CBond &b1, const CBond &b2)
-{
- RINOZ_COMP(b1.InIndex, b2.InIndex);
- return MyCompare(b1.OutIndex, b2.OutIndex);
-}
-
-static int CompareFolders(const CFolder &f1, const CFolder &f2)
-{
- int s1 = f1.Coders.Size();
- int s2 = f2.Coders.Size();
- RINOZ_COMP(s1, s2);
- int i;
- for (i = 0; i < s1; i++)
- RINOZ(CompareCoders(f1.Coders[i], f2.Coders[i]));
- s1 = f1.Bonds.Size();
- s2 = f2.Bonds.Size();
- RINOZ_COMP(s1, s2);
- for (i = 0; i < s1; i++)
- RINOZ(CompareBonds(f1.Bonds[i], f2.Bonds[i]));
- return 0;
-}
-*/
-
-/*
-static int CompareFiles(const CFileItem &f1, const CFileItem &f2)
-{
- return CompareFileNames(f1.Name, f2.Name);
-}
-*/
-
-struct CFolderRepack
-{
- unsigned FolderIndex;
- CNum NumCopyFiles;
-};
-
-/*
-static int CompareFolderRepacks(const CFolderRepack *p1, const CFolderRepack *p2, void *)
-{
- int i1 = p1->FolderIndex;
- int i2 = p2->FolderIndex;
- // In that version we don't want to parse folders here, so we don't compare folders
- // probably it must be improved in future
- // const CDbEx &db = *(const CDbEx *)param;
- // RINOZ(CompareFolders(
- // db.Folders[i1],
- // db.Folders[i2]));
-
- return MyCompare(i1, i2);
-
- // RINOZ_COMP(
- // db.NumUnpackStreamsVector[i1],
- // db.NumUnpackStreamsVector[i2]);
- // if (db.NumUnpackStreamsVector[i1] == 0)
- // return 0;
- // return CompareFiles(
- // db.Files[db.FolderStartFileIndex[i1]],
- // db.Files[db.FolderStartFileIndex[i2]]);
-}
-*/
-
-/*
- we sort empty files and dirs in such order:
- - Dir.NonAnti (name sorted)
- - File.NonAnti (name sorted)
- - File.Anti (name sorted)
- - Dir.Anti (reverse name sorted)
-*/
-
-static int CompareEmptyItems(const unsigned *p1, const unsigned *p2, void *param)
-{
- const CObjectVector<CUpdateItem> &updateItems = *(const CObjectVector<CUpdateItem> *)param;
- const CUpdateItem &u1 = updateItems[*p1];
- const CUpdateItem &u2 = updateItems[*p2];
- // NonAnti < Anti
- if (u1.IsAnti != u2.IsAnti)
- return (u1.IsAnti ? 1 : -1);
- if (u1.IsDir != u2.IsDir)
- {
- // Dir.NonAnti < File < Dir.Anti
- if (u1.IsDir)
- return (u1.IsAnti ? 1 : -1);
- return (u2.IsAnti ? -1 : 1);
- }
- int n = CompareFileNames(u1.Name, u2.Name);
- return (u1.IsDir && u1.IsAnti) ? -n : n;
-}
-
-static const char *g_Exts =
- " 7z xz lzma ace arc arj bz tbz bz2 tbz2 cab deb gz tgz ha lha lzh lzo lzx pak rar rpm sit zoo"
- " zip jar ear war msi"
- " 3gp avi mov mpeg mpg mpe wmv"
- " aac ape fla flac la mp3 m4a mp4 ofr ogg pac ra rm rka shn swa tta wv wma wav"
- " swf"
- " chm hxi hxs"
- " gif jpeg jpg jp2 png tiff bmp ico psd psp"
- " awg ps eps cgm dxf svg vrml wmf emf ai md"
- " cad dwg pps key sxi"
- " max 3ds"
- " iso bin nrg mdf img pdi tar cpio xpi"
- " vfd vhd vud vmc vsv"
- " vmdk dsk nvram vmem vmsd vmsn vmss vmtm"
- " inl inc idl acf asa"
- " h hpp hxx c cpp cxx m mm go swift"
- " rc java cs rs pas bas vb cls ctl frm dlg def"
- " f77 f f90 f95"
- " asm s"
- " sql manifest dep"
- " mak clw csproj vcproj sln dsp dsw"
- " class"
- " bat cmd bash sh"
- " xml xsd xsl xslt hxk hxc htm html xhtml xht mht mhtml htw asp aspx css cgi jsp shtml"
- " awk sed hta js json php php3 php4 php5 phptml pl pm py pyo rb tcl ts vbs"
- " text txt tex ans asc srt reg ini doc docx mcw dot rtf hlp xls xlr xlt xlw ppt pdf"
- " sxc sxd sxi sxg sxw stc sti stw stm odt ott odg otg odp otp ods ots odf"
- " abw afp cwk lwp wpd wps wpt wrf wri"
- " abf afm bdf fon mgf otf pcf pfa snf ttf"
- " dbf mdb nsf ntf wdb db fdb gdb"
- " exe dll ocx vbx sfx sys tlb awx com obj lib out o so"
- " pdb pch idb ncb opt";
-
-static unsigned GetExtIndex(const char *ext)
-{
- unsigned extIndex = 1;
- const char *p = g_Exts;
- for (;;)
- {
- char c = *p++;
- if (c == 0)
- return extIndex;
- if (c == ' ')
- continue;
- unsigned pos = 0;
- for (;;)
- {
- char c2 = ext[pos++];
- if (c2 == 0 && (c == 0 || c == ' '))
- return extIndex;
- if (c != c2)
- break;
- c = *p++;
- }
- extIndex++;
- for (;;)
- {
- if (c == 0)
- return extIndex;
- if (c == ' ')
- break;
- c = *p++;
- }
- }
-}
-
-struct CRefItem
-{
- const CUpdateItem *UpdateItem;
- UInt32 Index;
- unsigned ExtensionPos;
- unsigned NamePos;
- unsigned ExtensionIndex;
-
- CRefItem() {};
- CRefItem(UInt32 index, const CUpdateItem &ui, bool sortByType):
- UpdateItem(&ui),
- Index(index),
- ExtensionPos(0),
- NamePos(0),
- ExtensionIndex(0)
- {
- if (sortByType)
- {
- int slashPos = ui.Name.ReverseFind_PathSepar();
- NamePos = slashPos + 1;
- int dotPos = ui.Name.ReverseFind_Dot();
- if (dotPos <= slashPos)
- ExtensionPos = ui.Name.Len();
- else
- {
- ExtensionPos = dotPos + 1;
- if (ExtensionPos != ui.Name.Len())
- {
- AString s;
- for (unsigned pos = ExtensionPos;; pos++)
- {
- wchar_t c = ui.Name[pos];
- if (c >= 0x80)
- break;
- if (c == 0)
- {
- ExtensionIndex = GetExtIndex(s);
- break;
- }
- s += (char)MyCharLower_Ascii((char)c);
- }
- }
- }
- }
- }
-};
-
-struct CSortParam
-{
- // const CObjectVector<CTreeFolder> *TreeFolders;
- bool SortByType;
-};
-
-/*
- we sort files in such order:
- - Dir.NonAnti (name sorted)
- - alt streams
- - Dirs
- - Dir.Anti (reverse name sorted)
-*/
-
-
-static int CompareUpdateItems(const CRefItem *p1, const CRefItem *p2, void *param)
-{
- const CRefItem &a1 = *p1;
- const CRefItem &a2 = *p2;
- const CUpdateItem &u1 = *a1.UpdateItem;
- const CUpdateItem &u2 = *a2.UpdateItem;
-
- /*
- if (u1.IsAltStream != u2.IsAltStream)
- return u1.IsAltStream ? 1 : -1;
- */
-
- // Actually there are no dirs that time. They were stored in other steps
- // So that code is unused?
- if (u1.IsDir != u2.IsDir)
- return u1.IsDir ? 1 : -1;
- if (u1.IsDir)
- {
- if (u1.IsAnti != u2.IsAnti)
- return (u1.IsAnti ? 1 : -1);
- int n = CompareFileNames(u1.Name, u2.Name);
- return -n;
- }
-
- // bool sortByType = *(bool *)param;
- const CSortParam *sortParam = (const CSortParam *)param;
- bool sortByType = sortParam->SortByType;
- if (sortByType)
- {
- RINOZ_COMP(a1.ExtensionIndex, a2.ExtensionIndex);
- RINOZ(CompareFileNames(u1.Name.Ptr(a1.ExtensionPos), u2.Name.Ptr(a2.ExtensionPos)));
- RINOZ(CompareFileNames(u1.Name.Ptr(a1.NamePos), u2.Name.Ptr(a2.NamePos)));
- if (!u1.MTimeDefined && u2.MTimeDefined) return 1;
- if (u1.MTimeDefined && !u2.MTimeDefined) return -1;
- if (u1.MTimeDefined && u2.MTimeDefined) RINOZ_COMP(u1.MTime, u2.MTime);
- RINOZ_COMP(u1.Size, u2.Size);
- }
- /*
- int par1 = a1.UpdateItem->ParentFolderIndex;
- int par2 = a2.UpdateItem->ParentFolderIndex;
- const CTreeFolder &tf1 = (*sortParam->TreeFolders)[par1];
- const CTreeFolder &tf2 = (*sortParam->TreeFolders)[par2];
-
- int b1 = tf1.SortIndex, e1 = tf1.SortIndexEnd;
- int b2 = tf2.SortIndex, e2 = tf2.SortIndexEnd;
- if (b1 < b2)
- {
- if (e1 <= b2)
- return -1;
- // p2 in p1
- int par = par2;
- for (;;)
- {
- const CTreeFolder &tf = (*sortParam->TreeFolders)[par];
- par = tf.Parent;
- if (par == par1)
- {
- RINOZ(CompareFileNames(u1.Name, tf.Name));
- break;
- }
- }
- }
- else if (b2 < b1)
- {
- if (e2 <= b1)
- return 1;
- // p1 in p2
- int par = par1;
- for (;;)
- {
- const CTreeFolder &tf = (*sortParam->TreeFolders)[par];
- par = tf.Parent;
- if (par == par2)
- {
- RINOZ(CompareFileNames(tf.Name, u2.Name));
- break;
- }
- }
- }
- */
- // RINOZ_COMP(a1.UpdateItem->ParentSortIndex, a2.UpdateItem->ParentSortIndex);
- RINOK(CompareFileNames(u1.Name, u2.Name));
- RINOZ_COMP(a1.UpdateItem->IndexInClient, a2.UpdateItem->IndexInClient);
- RINOZ_COMP(a1.UpdateItem->IndexInArchive, a2.UpdateItem->IndexInArchive);
- return 0;
-}
-
-struct CSolidGroup
-{
- CRecordVector<UInt32> Indices;
-
- CRecordVector<CFolderRepack> folderRefs;
-};
-
-static const char * const g_ExeExts[] =
-{
- "dll"
- , "exe"
- , "ocx"
- , "sfx"
- , "sys"
-};
-
-static bool IsExeExt(const wchar_t *ext)
-{
- for (unsigned i = 0; i < ARRAY_SIZE(g_ExeExts); i++)
- if (StringsAreEqualNoCase_Ascii(ext, g_ExeExts[i]))
- return true;
- return false;
-}
-
-struct CAnalysis
-{
- CMyComPtr<IArchiveUpdateCallbackFile> Callback;
- CByteBuffer Buffer;
-
- bool ParseWav;
- bool ParseExe;
- bool ParseAll;
-
- CAnalysis():
- ParseWav(true),
- ParseExe(false),
- ParseAll(false)
- {}
-
- HRESULT GetFilterGroup(UInt32 index, const CUpdateItem &ui, CFilterMode &filterMode);
-};
-
-static const size_t kAnalysisBufSize = 1 << 14;
-
-HRESULT CAnalysis::GetFilterGroup(UInt32 index, const CUpdateItem &ui, CFilterMode &filterMode)
-{
- filterMode.Id = 0;
- filterMode.Delta = 0;
-
- CFilterMode filterModeTemp = filterMode;
-
- int slashPos = ui.Name.ReverseFind_PathSepar();
- int dotPos = ui.Name.ReverseFind_Dot();
-
- // if (dotPos > slashPos)
- {
- bool needReadFile = ParseAll;
-
- bool probablyIsSameIsa = false;
-
- if (!needReadFile || !Callback)
- {
- const wchar_t *ext;
- if (dotPos > slashPos)
- ext = ui.Name.Ptr(dotPos + 1);
- else
- ext = ui.Name.RightPtr(0);
-
- // p7zip uses the trick to store posix attributes in high 16 bits
- if (ui.Attrib & 0x8000)
- {
- unsigned st_mode = ui.Attrib >> 16;
- // st_mode = 00111;
- if ((st_mode & 00111) && (ui.Size >= 2048))
- {
- #ifndef _WIN32
- probablyIsSameIsa = true;
- #endif
- needReadFile = true;
- }
- }
-
- if (IsExeExt(ext))
- {
- needReadFile = true;
- #ifdef _WIN32
- probablyIsSameIsa = true;
- needReadFile = ParseExe;
- #endif
- }
- else if (StringsAreEqualNoCase_Ascii(ext, "wav"))
- {
- needReadFile = ParseWav;
- }
- /*
- else if (!needReadFile && ParseUnixExt)
- {
- if (StringsAreEqualNoCase_Ascii(ext, "so")
- || StringsAreEqualNoCase_Ascii(ext, ""))
-
- needReadFile = true;
- }
- */
- }
-
- if (needReadFile && Callback)
- {
- if (Buffer.Size() != kAnalysisBufSize)
- {
- Buffer.Alloc(kAnalysisBufSize);
- }
- {
- CMyComPtr<ISequentialInStream> stream;
- HRESULT result = Callback->GetStream2(index, &stream, NUpdateNotifyOp::kAnalyze);
- if (result == S_OK && stream)
- {
- size_t size = kAnalysisBufSize;
- result = ReadStream(stream, Buffer, &size);
- stream.Release();
- // RINOK(Callback->SetOperationResult2(index, NUpdate::NOperationResult::kOK));
- if (result == S_OK)
- {
- BoolInt parseRes = ParseFile(Buffer, size, &filterModeTemp);
- if (parseRes && filterModeTemp.Delta == 0)
- {
- filterModeTemp.SetDelta();
- if (filterModeTemp.Delta != 0 && filterModeTemp.Id != k_Delta)
- {
- if (ui.Size % filterModeTemp.Delta != 0)
- {
- parseRes = false;
- }
- }
- }
- if (!parseRes)
- {
- filterModeTemp.Id = 0;
- filterModeTemp.Delta = 0;
- }
- }
- }
- }
- }
- else if ((needReadFile && !Callback) || probablyIsSameIsa)
- {
- #ifdef MY_CPU_X86_OR_AMD64
- if (probablyIsSameIsa)
- filterModeTemp.Id = k_X86;
- #endif
- }
- }
-
- filterMode = filterModeTemp;
- return S_OK;
-}
-
-static inline void GetMethodFull(UInt64 methodID, UInt32 numStreams, CMethodFull &m)
-{
- m.Id = methodID;
- m.NumStreams = numStreams;
-}
-
-static HRESULT AddBondForFilter(CCompressionMethodMode &mode)
-{
- for (unsigned c = 1; c < mode.Methods.Size(); c++)
- {
- if (!mode.IsThereBond_to_Coder(c))
- {
- CBond2 bond;
- bond.OutCoder = 0;
- bond.OutStream = 0;
- bond.InCoder = c;
- mode.Bonds.Add(bond);
- return S_OK;
- }
- }
- return E_INVALIDARG;
-}
-
-static HRESULT AddFilterBond(CCompressionMethodMode &mode)
-{
- if (!mode.Bonds.IsEmpty())
- return AddBondForFilter(mode);
- return S_OK;
-}
-
-static HRESULT AddBcj2Methods(CCompressionMethodMode &mode)
-{
- // mode.Methods[0] must be k_BCJ2 method !
-
- CMethodFull m;
- GetMethodFull(k_LZMA, 1, m);
-
- m.AddProp32(NCoderPropID::kDictionarySize, 1 << 20);
- m.AddProp32(NCoderPropID::kNumFastBytes, 128);
- m.AddProp32(NCoderPropID::kNumThreads, 1);
- m.AddProp32(NCoderPropID::kLitPosBits, 2);
- m.AddProp32(NCoderPropID::kLitContextBits, 0);
- // m.AddProp_Ascii(NCoderPropID::kMatchFinder, "BT2");
-
- unsigned methodIndex = mode.Methods.Size();
-
- if (mode.Bonds.IsEmpty())
- {
- for (unsigned i = 1; i + 1 < mode.Methods.Size(); i++)
- {
- CBond2 bond;
- bond.OutCoder = i;
- bond.OutStream = 0;
- bond.InCoder = i + 1;
- mode.Bonds.Add(bond);
- }
- }
-
- mode.Methods.Add(m);
- mode.Methods.Add(m);
-
- RINOK(AddBondForFilter(mode));
- CBond2 bond;
- bond.OutCoder = 0;
- bond.InCoder = methodIndex; bond.OutStream = 1; mode.Bonds.Add(bond);
- bond.InCoder = methodIndex + 1; bond.OutStream = 2; mode.Bonds.Add(bond);
- return S_OK;
-}
-
-static HRESULT MakeExeMethod(CCompressionMethodMode &mode,
- const CFilterMode &filterMode, /* bool addFilter, */ bool bcj2Filter)
-{
- if (mode.Filter_was_Inserted)
- {
- const CMethodFull &m = mode.Methods[0];
- CMethodId id = m.Id;
- if (id == k_BCJ2)
- return AddBcj2Methods(mode);
- if (!m.IsSimpleCoder())
- return E_NOTIMPL;
- // if (Bonds.IsEmpty()) we can create bonds later
- return AddFilterBond(mode);
- }
-
- if (filterMode.Id == 0)
- return S_OK;
-
- CMethodFull &m = mode.Methods.InsertNew(0);
-
- {
- FOR_VECTOR(k, mode.Bonds)
- {
- CBond2 &bond = mode.Bonds[k];
- bond.InCoder++;
- bond.OutCoder++;
- }
- }
-
- HRESULT res;
-
- if (bcj2Filter && Is86Filter(filterMode.Id))
- {
- GetMethodFull(k_BCJ2, 4, m);
- res = AddBcj2Methods(mode);
- }
- else
- {
- GetMethodFull(filterMode.Id, 1, m);
- if (filterMode.Id == k_Delta)
- m.AddProp32(NCoderPropID::kDefaultProp, filterMode.Delta);
- res = AddFilterBond(mode);
-
- int alignBits = -1;
- if (filterMode.Id == k_Delta || filterMode.Delta != 0)
- {
- if (filterMode.Delta == 1) alignBits = 0;
- else if (filterMode.Delta == 2) alignBits = 1;
- else if (filterMode.Delta == 4) alignBits = 2;
- else if (filterMode.Delta == 8) alignBits = 3;
- else if (filterMode.Delta == 16) alignBits = 4;
- }
- else
- {
- // alignBits = GetAlignForFilterMethod(filterMode.Id);
- }
-
- if (res == S_OK && alignBits >= 0)
- {
- unsigned nextCoder = 1;
- if (!mode.Bonds.IsEmpty())
- {
- nextCoder = mode.Bonds.Back().InCoder;
- }
- if (nextCoder < mode.Methods.Size())
- {
- CMethodFull &nextMethod = mode.Methods[nextCoder];
- if (nextMethod.Id == k_LZMA || nextMethod.Id == k_LZMA2)
- {
- if (!nextMethod.Are_Lzma_Model_Props_Defined())
- {
- if (alignBits != 0)
- {
- if (alignBits > 2 || filterMode.Id == k_Delta)
- nextMethod.AddProp32(NCoderPropID::kPosStateBits, alignBits);
- unsigned lc = 0;
- if (alignBits < 3)
- lc = 3 - alignBits;
- nextMethod.AddProp32(NCoderPropID::kLitContextBits, lc);
- nextMethod.AddProp32(NCoderPropID::kLitPosBits, alignBits);
- }
- }
- }
- }
- }
- }
-
- return res;
-}
-
-
-static void UpdateItem_To_FileItem2(const CUpdateItem &ui, CFileItem2 &file2)
-{
- file2.Attrib = ui.Attrib; file2.AttribDefined = ui.AttribDefined;
- file2.CTime = ui.CTime; file2.CTimeDefined = ui.CTimeDefined;
- file2.ATime = ui.ATime; file2.ATimeDefined = ui.ATimeDefined;
- file2.MTime = ui.MTime; file2.MTimeDefined = ui.MTimeDefined;
- file2.IsAnti = ui.IsAnti;
- // file2.IsAux = false;
- file2.StartPosDefined = false;
- // file2.StartPos = 0;
-}
-
-
-static void UpdateItem_To_FileItem(const CUpdateItem &ui,
- CFileItem &file, CFileItem2 &file2)
-{
- UpdateItem_To_FileItem2(ui, file2);
-
- file.Size = ui.Size;
- file.IsDir = ui.IsDir;
- file.HasStream = ui.HasStream();
- // file.IsAltStream = ui.IsAltStream;
-}
-
-
-
-class CRepackInStreamWithSizes:
- public ISequentialInStream,
- public ICompressGetSubStreamSize,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialInStream> _stream;
- // UInt64 _size;
- const CBoolVector *_extractStatuses;
- UInt32 _startIndex;
-public:
- const CDbEx *_db;
-
- void Init(ISequentialInStream *stream, UInt32 startIndex, const CBoolVector *extractStatuses)
- {
- _startIndex = startIndex;
- _extractStatuses = extractStatuses;
- // _size = 0;
- _stream = stream;
- }
- // UInt64 GetSize() const { return _size; }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, ICompressGetSubStreamSize)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-
- STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value);
-};
-
-STDMETHODIMP CRepackInStreamWithSizes::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- return _stream->Read(data, size, processedSize);
- /*
- UInt32 realProcessedSize;
- HRESULT result = _stream->Read(data, size, &realProcessedSize);
- _size += realProcessedSize;
- if (processedSize)
- *processedSize = realProcessedSize;
- return result;
- */
-}
-
-STDMETHODIMP CRepackInStreamWithSizes::GetSubStreamSize(UInt64 subStream, UInt64 *value)
-{
- *value = 0;
- if (subStream >= _extractStatuses->Size())
- return S_FALSE; // E_FAIL;
- unsigned index = (unsigned)subStream;
- if ((*_extractStatuses)[index])
- {
- const CFileItem &fi = _db->Files[_startIndex + index];
- if (fi.HasStream)
- *value = fi.Size;
- }
- return S_OK;
-}
-
-
-class CRepackStreamBase
-{
-protected:
- bool _needWrite;
- bool _fileIsOpen;
- bool _calcCrc;
- UInt32 _crc;
- UInt64 _rem;
-
- const CBoolVector *_extractStatuses;
- UInt32 _startIndex;
- unsigned _currentIndex;
-
- HRESULT OpenFile();
- HRESULT CloseFile();
- HRESULT ProcessEmptyFiles();
-
-public:
- const CDbEx *_db;
- CMyComPtr<IArchiveUpdateCallbackFile> _opCallback;
- CMyComPtr<IArchiveExtractCallbackMessage> _extractCallback;
-
- HRESULT Init(UInt32 startIndex, const CBoolVector *extractStatuses);
- HRESULT CheckFinishedState() const { return (_currentIndex == _extractStatuses->Size()) ? S_OK: E_FAIL; }
-};
-
-HRESULT CRepackStreamBase::Init(UInt32 startIndex, const CBoolVector *extractStatuses)
-{
- _startIndex = startIndex;
- _extractStatuses = extractStatuses;
-
- _currentIndex = 0;
- _fileIsOpen = false;
-
- return ProcessEmptyFiles();
-}
-
-HRESULT CRepackStreamBase::OpenFile()
-{
- UInt32 arcIndex = _startIndex + _currentIndex;
- const CFileItem &fi = _db->Files[arcIndex];
-
- _needWrite = (*_extractStatuses)[_currentIndex];
- if (_opCallback)
- {
- RINOK(_opCallback->ReportOperation(
- NEventIndexType::kInArcIndex, arcIndex,
- _needWrite ?
- NUpdateNotifyOp::kRepack :
- NUpdateNotifyOp::kSkip));
- }
-
- _crc = CRC_INIT_VAL;
- _calcCrc = (fi.CrcDefined && !fi.IsDir);
-
- _fileIsOpen = true;
- _rem = fi.Size;
- return S_OK;
-}
-
-const HRESULT k_My_HRESULT_CRC_ERROR = 0x20000002;
-
-HRESULT CRepackStreamBase::CloseFile()
-{
- UInt32 arcIndex = _startIndex + _currentIndex;
- const CFileItem &fi = _db->Files[arcIndex];
- _fileIsOpen = false;
- _currentIndex++;
- if (!_calcCrc || fi.Crc == CRC_GET_DIGEST(_crc))
- return S_OK;
-
- if (_extractCallback)
- {
- RINOK(_extractCallback->ReportExtractResult(
- NEventIndexType::kInArcIndex, arcIndex,
- NExtract::NOperationResult::kCRCError));
- }
- // return S_FALSE;
- return k_My_HRESULT_CRC_ERROR;
-}
-
-HRESULT CRepackStreamBase::ProcessEmptyFiles()
-{
- while (_currentIndex < _extractStatuses->Size() && _db->Files[_startIndex + _currentIndex].Size == 0)
- {
- RINOK(OpenFile());
- RINOK(CloseFile());
- }
- return S_OK;
-}
-
-
-
-#ifndef _7ZIP_ST
-
-class CFolderOutStream2:
- public CRepackStreamBase,
- public ISequentialOutStream,
- public CMyUnknownImp
-{
-public:
- CMyComPtr<ISequentialOutStream> _stream;
-
- MY_UNKNOWN_IMP
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CFolderOutStream2::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- while (size != 0)
- {
- if (_fileIsOpen)
- {
- UInt32 cur = (size < _rem ? size : (UInt32)_rem);
- HRESULT result = S_OK;
- if (_needWrite)
- result = _stream->Write(data, cur, &cur);
- if (_calcCrc)
- _crc = CrcUpdate(_crc, data, cur);
- if (processedSize)
- *processedSize += cur;
- data = (const Byte *)data + cur;
- size -= cur;
- _rem -= cur;
- if (_rem == 0)
- {
- RINOK(CloseFile());
- RINOK(ProcessEmptyFiles());
- }
- RINOK(result);
- if (cur == 0)
- break;
- continue;
- }
-
- RINOK(ProcessEmptyFiles());
- if (_currentIndex == _extractStatuses->Size())
- {
- // we don't support write cut here
- return E_FAIL;
- }
- RINOK(OpenFile());
- }
-
- return S_OK;
-}
-
-#endif
-
-
-
-static const UInt32 kTempBufSize = 1 << 16;
-
-class CFolderInStream2:
- public CRepackStreamBase,
- public ISequentialInStream,
- public CMyUnknownImp
-{
- Byte *_buf;
-public:
- CMyComPtr<ISequentialInStream> _inStream;
- HRESULT Result;
-
- MY_UNKNOWN_IMP
-
- CFolderInStream2():
- Result(S_OK)
- {
- _buf = new Byte[kTempBufSize];
- }
-
- ~CFolderInStream2()
- {
- delete []_buf;
- }
-
- void Init() { Result = S_OK; }
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CFolderInStream2::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- while (size != 0)
- {
- if (_fileIsOpen)
- {
- UInt32 cur = (size < _rem ? size : (UInt32)_rem);
-
- void *buf;
- if (_needWrite)
- buf = data;
- else
- {
- buf = _buf;
- if (cur > kTempBufSize)
- cur = kTempBufSize;
- }
-
- HRESULT result = _inStream->Read(buf, cur, &cur);
- _crc = CrcUpdate(_crc, buf, cur);
- _rem -= cur;
-
- if (_needWrite)
- {
- data = (Byte *)data + cur;
- size -= cur;
- if (processedSize)
- *processedSize += cur;
- }
-
- if (result != S_OK)
- Result = result;
-
- if (_rem == 0)
- {
- RINOK(CloseFile());
- RINOK(ProcessEmptyFiles());
- }
-
- RINOK(result);
-
- if (cur == 0)
- return E_FAIL;
-
- continue;
- }
-
- RINOK(ProcessEmptyFiles());
- if (_currentIndex == _extractStatuses->Size())
- {
- return S_OK;
- }
- RINOK(OpenFile());
- }
-
- return S_OK;
-}
-
-
-class CThreadDecoder
- #ifndef _7ZIP_ST
- : public CVirtThread
- #endif
-{
-public:
- CDecoder Decoder;
-
- CThreadDecoder(bool multiThreadMixer):
- Decoder(multiThreadMixer)
- {
- #ifndef _7ZIP_ST
- if (multiThreadMixer)
- {
- MtMode = false;
- NumThreads = 1;
- FosSpec = new CFolderOutStream2;
- Fos = FosSpec;
- Result = E_FAIL;
- }
- #endif
- // UnpackSize = 0;
- // send_UnpackSize = false;
- }
-
- #ifndef _7ZIP_ST
-
- bool dataAfterEnd_Error;
- HRESULT Result;
- CMyComPtr<IInStream> InStream;
-
- CFolderOutStream2 *FosSpec;
- CMyComPtr<ISequentialOutStream> Fos;
-
- UInt64 StartPos;
- const CFolders *Folders;
- int FolderIndex;
-
- // bool send_UnpackSize;
- // UInt64 UnpackSize;
-
- #ifndef _NO_CRYPTO
- CMyComPtr<ICryptoGetTextPassword> getTextPassword;
- #endif
-
- DECL_EXTERNAL_CODECS_LOC_VARS2;
-
- #ifndef _7ZIP_ST
- bool MtMode;
- UInt32 NumThreads;
- #endif
-
-
- ~CThreadDecoder() { CVirtThread::WaitThreadFinish(); }
- virtual void Execute();
-
- #endif
-};
-
-#ifndef _7ZIP_ST
-
-void CThreadDecoder::Execute()
-{
- try
- {
- #ifndef _NO_CRYPTO
- bool isEncrypted = false;
- bool passwordIsDefined = false;
- UString password;
- #endif
-
- dataAfterEnd_Error = false;
-
- Result = Decoder.Decode(
- EXTERNAL_CODECS_LOC_VARS
- InStream,
- StartPos,
- *Folders, FolderIndex,
-
- // send_UnpackSize ? &UnpackSize : NULL,
- NULL, // unpackSize : FULL unpack
-
- Fos,
- NULL, // compressProgress
-
- NULL // *inStreamMainRes
- , dataAfterEnd_Error
-
- _7Z_DECODER_CRYPRO_VARS
- #ifndef _7ZIP_ST
- , MtMode, NumThreads,
- 0 // MemUsage
- #endif
-
- );
- }
- catch(...)
- {
- Result = E_FAIL;
- }
-
- /*
- if (Result == S_OK)
- Result = FosSpec->CheckFinishedState();
- */
- FosSpec->_stream.Release();
-}
-
-#endif
-
-#ifndef _NO_CRYPTO
-
-class CCryptoGetTextPassword:
- public ICryptoGetTextPassword,
- public CMyUnknownImp
-{
-public:
- UString Password;
-
- MY_UNKNOWN_IMP
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
-};
-
-STDMETHODIMP CCryptoGetTextPassword::CryptoGetTextPassword(BSTR *password)
-{
- return StringToBstr(Password, password);
-}
-
-#endif
-
-
-static void GetFile(const CDatabase &inDb, unsigned index, CFileItem &file, CFileItem2 &file2)
-{
- file = inDb.Files[index];
- file2.CTimeDefined = inDb.CTime.GetItem(index, file2.CTime);
- file2.ATimeDefined = inDb.ATime.GetItem(index, file2.ATime);
- file2.MTimeDefined = inDb.MTime.GetItem(index, file2.MTime);
- file2.StartPosDefined = inDb.StartPos.GetItem(index, file2.StartPos);
- file2.AttribDefined = inDb.Attrib.GetItem(index, file2.Attrib);
- file2.IsAnti = inDb.IsItemAnti(index);
- // file2.IsAux = inDb.IsItemAux(index);
-}
-
-HRESULT Update(
- DECL_EXTERNAL_CODECS_LOC_VARS
- IInStream *inStream,
- const CDbEx *db,
- const CObjectVector<CUpdateItem> &updateItems,
- // const CObjectVector<CTreeFolder> &treeFolders,
- // const CUniqBlocks &secureBlocks,
- COutArchive &archive,
- CArchiveDatabaseOut &newDatabase,
- ISequentialOutStream *seqOutStream,
- IArchiveUpdateCallback *updateCallback,
- const CUpdateOptions &options
- #ifndef _NO_CRYPTO
- , ICryptoGetTextPassword *getDecoderPassword
- #endif
- )
-{
- UInt64 numSolidFiles = options.NumSolidFiles;
- if (numSolidFiles == 0)
- numSolidFiles = 1;
-
- CMyComPtr<IArchiveUpdateCallbackFile> opCallback;
- updateCallback->QueryInterface(IID_IArchiveUpdateCallbackFile, (void **)&opCallback);
-
- CMyComPtr<IArchiveExtractCallbackMessage> extractCallback;
- updateCallback->QueryInterface(IID_IArchiveExtractCallbackMessage, (void **)&extractCallback);
-
- // size_t totalSecureDataSize = (size_t)secureBlocks.GetTotalSizeInBytes();
-
- /*
- CMyComPtr<IOutStream> outStream;
- RINOK(seqOutStream->QueryInterface(IID_IOutStream, (void **)&outStream));
- if (!outStream)
- return E_NOTIMPL;
- */
-
- UInt64 startBlockSize = db ? db->ArcInfo.StartPosition: 0;
- if (startBlockSize > 0 && !options.RemoveSfxBlock)
- {
- RINOK(WriteRange(inStream, seqOutStream, 0, startBlockSize, NULL));
- }
-
- CIntArr fileIndexToUpdateIndexMap;
- UInt64 complexity = 0;
- UInt64 inSizeForReduce2 = 0;
- bool needEncryptedRepack = false;
-
- CRecordVector<CFilterMode2> filters;
- CObjectVector<CSolidGroup> groups;
- bool thereAreRepacks = false;
-
- bool useFilters = options.UseFilters;
- if (useFilters)
- {
- const CCompressionMethodMode &method = *options.Method;
-
- FOR_VECTOR (i, method.Methods)
- if (IsFilterMethod(method.Methods[i].Id))
- {
- useFilters = false;
- break;
- }
- }
-
- if (db)
- {
- fileIndexToUpdateIndexMap.Alloc(db->Files.Size());
- unsigned i;
-
- for (i = 0; i < db->Files.Size(); i++)
- fileIndexToUpdateIndexMap[i] = -1;
-
- for (i = 0; i < updateItems.Size(); i++)
- {
- int index = updateItems[i].IndexInArchive;
- if (index != -1)
- fileIndexToUpdateIndexMap[(unsigned)index] = i;
- }
-
- for (i = 0; i < db->NumFolders; i++)
- {
- CNum indexInFolder = 0;
- CNum numCopyItems = 0;
- CNum numUnpackStreams = db->NumUnpackStreamsVector[i];
- UInt64 repackSize = 0;
-
- for (CNum fi = db->FolderStartFileIndex[i]; indexInFolder < numUnpackStreams; fi++)
- {
- if (fi >= db->Files.Size())
- return E_FAIL;
-
- const CFileItem &file = db->Files[fi];
- if (file.HasStream)
- {
- indexInFolder++;
- int updateIndex = fileIndexToUpdateIndexMap[fi];
- if (updateIndex >= 0 && !updateItems[updateIndex].NewData)
- {
- numCopyItems++;
- repackSize += file.Size;
- }
- }
- }
-
- if (numCopyItems == 0)
- continue;
-
- CFolderRepack rep;
- rep.FolderIndex = i;
- rep.NumCopyFiles = numCopyItems;
- CFolderEx f;
- db->ParseFolderEx(i, f);
-
- const bool isEncrypted = f.IsEncrypted();
- const bool needCopy = (numCopyItems == numUnpackStreams);
- const bool extractFilter = (useFilters || needCopy);
-
- unsigned groupIndex = Get_FilterGroup_for_Folder(filters, f, extractFilter);
-
- while (groupIndex >= groups.Size())
- groups.AddNew();
-
- groups[groupIndex].folderRefs.Add(rep);
-
- if (needCopy)
- complexity += db->GetFolderFullPackSize(i);
- else
- {
- thereAreRepacks = true;
- complexity += repackSize;
- if (inSizeForReduce2 < repackSize)
- inSizeForReduce2 = repackSize;
- if (isEncrypted)
- needEncryptedRepack = true;
- }
- }
- }
-
- UInt64 inSizeForReduce = 0;
- {
- bool isSolid = (numSolidFiles > 1 && options.NumSolidBytes != 0);
- FOR_VECTOR (i, updateItems)
- {
- const CUpdateItem &ui = updateItems[i];
- if (ui.NewData)
- {
- complexity += ui.Size;
- if (isSolid)
- inSizeForReduce += ui.Size;
- else if (inSizeForReduce < ui.Size)
- inSizeForReduce = ui.Size;
- }
- }
- }
-
- if (inSizeForReduce < inSizeForReduce2)
- inSizeForReduce = inSizeForReduce2;
-
- RINOK(updateCallback->SetTotal(complexity));
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(updateCallback, true);
-
- #ifndef _7ZIP_ST
-
- CStreamBinder sb;
- if (options.MultiThreadMixer)
- {
- RINOK(sb.CreateEvents());
- }
-
- #endif
-
- CThreadDecoder threadDecoder(options.MultiThreadMixer);
-
- #ifndef _7ZIP_ST
- if (options.MultiThreadMixer && thereAreRepacks)
- {
- #ifdef EXTERNAL_CODECS
- threadDecoder.__externalCodecs = __externalCodecs;
- #endif
- RINOK(threadDecoder.Create());
- }
- #endif
-
- {
- CAnalysis analysis;
- if (options.AnalysisLevel == 0)
- {
- analysis.ParseWav = false;
- analysis.ParseExe = false;
- analysis.ParseAll = false;
- }
- else
- {
- analysis.Callback = opCallback;
- if (options.AnalysisLevel > 0)
- {
- analysis.ParseWav = true;
- if (options.AnalysisLevel >= 7)
- {
- analysis.ParseExe = true;
- if (options.AnalysisLevel >= 9)
- analysis.ParseAll = true;
- }
- }
- }
-
- // ---------- Split files to groups ----------
-
- const CCompressionMethodMode &method = *options.Method;
-
- FOR_VECTOR (i, updateItems)
- {
- const CUpdateItem &ui = updateItems[i];
- if (!ui.NewData || !ui.HasStream())
- continue;
-
- CFilterMode2 fm;
- if (useFilters)
- {
- RINOK(analysis.GetFilterGroup(i, ui, fm));
- }
- fm.Encrypted = method.PasswordIsDefined;
-
- unsigned groupIndex = GetGroup(filters, fm);
- while (groupIndex >= groups.Size())
- groups.AddNew();
- groups[groupIndex].Indices.Add(i);
- }
- }
-
-
- #ifndef _NO_CRYPTO
-
- CCryptoGetTextPassword *getPasswordSpec = NULL;
- CMyComPtr<ICryptoGetTextPassword> getTextPassword;
- if (needEncryptedRepack)
- {
- getPasswordSpec = new CCryptoGetTextPassword;
- getTextPassword = getPasswordSpec;
-
- #ifndef _7ZIP_ST
- threadDecoder.getTextPassword = getPasswordSpec;
- #endif
-
- if (options.Method->PasswordIsDefined)
- getPasswordSpec->Password = options.Method->Password;
- else
- {
- if (!getDecoderPassword)
- return E_NOTIMPL;
- CMyComBSTR password;
- RINOK(getDecoderPassword->CryptoGetTextPassword(&password));
- if (password)
- getPasswordSpec->Password = password;
- }
- }
-
- #endif
-
-
- // ---------- Compress ----------
-
- RINOK(archive.Create(seqOutStream, false));
- RINOK(archive.SkipPrefixArchiveHeader());
-
- /*
- CIntVector treeFolderToArcIndex;
- treeFolderToArcIndex.Reserve(treeFolders.Size());
- for (i = 0; i < treeFolders.Size(); i++)
- treeFolderToArcIndex.Add(-1);
- // ---------- Write Tree (only AUX dirs) ----------
- for (i = 1; i < treeFolders.Size(); i++)
- {
- const CTreeFolder &treeFolder = treeFolders[i];
- CFileItem file;
- CFileItem2 file2;
- file2.Init();
- int secureID = 0;
- if (treeFolder.UpdateItemIndex < 0)
- {
- // we can store virtual dir item wuthout attrib, but we want all items have attrib.
- file.SetAttrib(FILE_ATTRIBUTE_DIRECTORY);
- file2.IsAux = true;
- }
- else
- {
- const CUpdateItem &ui = updateItems[treeFolder.UpdateItemIndex];
- // if item is not dir, then it's parent for alt streams.
- // we will write such items later
- if (!ui.IsDir)
- continue;
- secureID = ui.SecureIndex;
- if (ui.NewProps)
- UpdateItem_To_FileItem(ui, file, file2);
- else
- GetFile(*db, ui.IndexInArchive, file, file2);
- }
- file.Size = 0;
- file.HasStream = false;
- file.IsDir = true;
- file.Parent = treeFolder.Parent;
-
- treeFolderToArcIndex[i] = newDatabase.Files.Size();
- newDatabase.AddFile(file, file2, treeFolder.Name);
-
- if (totalSecureDataSize != 0)
- newDatabase.SecureIDs.Add(secureID);
- }
- */
-
- {
- /* ---------- Write non-AUX dirs and Empty files ---------- */
- CUIntVector emptyRefs;
-
- unsigned i;
-
- for (i = 0; i < updateItems.Size(); i++)
- {
- const CUpdateItem &ui = updateItems[i];
- if (ui.NewData)
- {
- if (ui.HasStream())
- continue;
- }
- else if (ui.IndexInArchive != -1 && db->Files[ui.IndexInArchive].HasStream)
- continue;
- /*
- if (ui.TreeFolderIndex >= 0)
- continue;
- */
- emptyRefs.Add(i);
- }
-
- emptyRefs.Sort(CompareEmptyItems, (void *)&updateItems);
-
- for (i = 0; i < emptyRefs.Size(); i++)
- {
- const CUpdateItem &ui = updateItems[emptyRefs[i]];
- CFileItem file;
- CFileItem2 file2;
- UString name;
- if (ui.NewProps)
- {
- UpdateItem_To_FileItem(ui, file, file2);
- file.CrcDefined = false;
- name = ui.Name;
- }
- else
- {
- GetFile(*db, ui.IndexInArchive, file, file2);
- db->GetPath(ui.IndexInArchive, name);
- }
-
- /*
- if (totalSecureDataSize != 0)
- newDatabase.SecureIDs.Add(ui.SecureIndex);
- file.Parent = ui.ParentFolderIndex;
- */
- newDatabase.AddFile(file, file2, name);
- }
- }
-
- lps->ProgressOffset = 0;
-
- {
- // ---------- Sort Filters ----------
-
- FOR_VECTOR (i, filters)
- {
- filters[i].GroupIndex = i;
- }
- filters.Sort2();
- }
-
- for (unsigned groupIndex = 0; groupIndex < filters.Size(); groupIndex++)
- {
- const CFilterMode2 &filterMode = filters[groupIndex];
-
- CCompressionMethodMode method = *options.Method;
- {
- HRESULT res = MakeExeMethod(method, filterMode,
- #ifdef _7ZIP_ST
- false
- #else
- options.MaxFilter && options.MultiThreadMixer
- #endif
- );
-
- RINOK(res);
- }
-
- if (filterMode.Encrypted)
- {
- if (!method.PasswordIsDefined)
- {
- #ifndef _NO_CRYPTO
- if (getPasswordSpec)
- method.Password = getPasswordSpec->Password;
- #endif
- method.PasswordIsDefined = true;
- }
- }
- else
- {
- method.PasswordIsDefined = false;
- method.Password.Empty();
- }
-
- CEncoder encoder(method);
-
- // ---------- Repack and copy old solid blocks ----------
-
- const CSolidGroup &group = groups[filterMode.GroupIndex];
-
- FOR_VECTOR(folderRefIndex, group.folderRefs)
- {
- const CFolderRepack &rep = group.folderRefs[folderRefIndex];
-
- unsigned folderIndex = rep.FolderIndex;
-
- CNum numUnpackStreams = db->NumUnpackStreamsVector[folderIndex];
-
- if (rep.NumCopyFiles == numUnpackStreams)
- {
- if (opCallback)
- {
- RINOK(opCallback->ReportOperation(
- NEventIndexType::kBlockIndex, (UInt32)folderIndex,
- NUpdateNotifyOp::kReplicate));
-
- // ---------- Copy old solid block ----------
- {
- CNum indexInFolder = 0;
- for (CNum fi = db->FolderStartFileIndex[folderIndex]; indexInFolder < numUnpackStreams; fi++)
- {
- if (db->Files[fi].HasStream)
- {
- indexInFolder++;
- RINOK(opCallback->ReportOperation(
- NEventIndexType::kInArcIndex, (UInt32)fi,
- NUpdateNotifyOp::kReplicate));
- }
- }
- }
- }
-
- UInt64 packSize = db->GetFolderFullPackSize(folderIndex);
- RINOK(WriteRange(inStream, archive.SeqStream,
- db->GetFolderStreamPos(folderIndex, 0), packSize, progress));
- lps->ProgressOffset += packSize;
-
- CFolder &folder = newDatabase.Folders.AddNew();
- db->ParseFolderInfo(folderIndex, folder);
- CNum startIndex = db->FoStartPackStreamIndex[folderIndex];
- FOR_VECTOR(j, folder.PackStreams)
- {
- newDatabase.PackSizes.Add(db->GetStreamPackSize(startIndex + j));
- // newDatabase.PackCRCsDefined.Add(db.PackCRCsDefined[startIndex + j]);
- // newDatabase.PackCRCs.Add(db.PackCRCs[startIndex + j]);
- }
-
- size_t indexStart = db->FoToCoderUnpackSizes[folderIndex];
- size_t indexEnd = db->FoToCoderUnpackSizes[folderIndex + 1];
- for (; indexStart < indexEnd; indexStart++)
- newDatabase.CoderUnpackSizes.Add(db->CoderUnpackSizes[indexStart]);
- }
- else
- {
- // ---------- Repack old solid block ----------
-
- CBoolVector extractStatuses;
-
- CNum indexInFolder = 0;
-
- if (opCallback)
- {
- RINOK(opCallback->ReportOperation(
- NEventIndexType::kBlockIndex, (UInt32)folderIndex,
- NUpdateNotifyOp::kRepack))
- }
-
- /* We could reduce data size of decoded folder, if we don't need to repack
- last files in folder. But the gain in speed is small in most cases.
- So we unpack full folder. */
-
- UInt64 sizeToEncode = 0;
-
- /*
- UInt64 importantUnpackSize = 0;
- unsigned numImportantFiles = 0;
- UInt64 decodeSize = 0;
- */
-
- for (CNum fi = db->FolderStartFileIndex[folderIndex]; indexInFolder < numUnpackStreams; fi++)
- {
- bool needExtract = false;
- const CFileItem &file = db->Files[fi];
-
- if (file.HasStream)
- {
- indexInFolder++;
- int updateIndex = fileIndexToUpdateIndexMap[fi];
- if (updateIndex >= 0 && !updateItems[updateIndex].NewData)
- needExtract = true;
- // decodeSize += file.Size;
- }
-
- extractStatuses.Add(needExtract);
- if (needExtract)
- {
- sizeToEncode += file.Size;
- /*
- numImportantFiles = extractStatuses.Size();
- importantUnpackSize = decodeSize;
- */
- }
- }
-
- // extractStatuses.DeleteFrom(numImportantFiles);
-
- unsigned startPackIndex = newDatabase.PackSizes.Size();
- UInt64 curUnpackSize;
- {
-
- CMyComPtr<ISequentialInStream> sbInStream;
- CRepackStreamBase *repackBase;
- CFolderInStream2 *FosSpec2 = NULL;
-
- CRepackInStreamWithSizes *inStreamSizeCountSpec = new CRepackInStreamWithSizes;
- CMyComPtr<ISequentialInStream> inStreamSizeCount = inStreamSizeCountSpec;
- {
- #ifndef _7ZIP_ST
- if (options.MultiThreadMixer)
- {
- repackBase = threadDecoder.FosSpec;
- CMyComPtr<ISequentialOutStream> sbOutStream;
- sb.CreateStreams(&sbInStream, &sbOutStream);
- sb.ReInit();
-
- threadDecoder.FosSpec->_stream = sbOutStream;
-
- threadDecoder.InStream = inStream;
- threadDecoder.StartPos = db->ArcInfo.DataStartPosition; // db->GetFolderStreamPos(folderIndex, 0);
- threadDecoder.Folders = (const CFolders *)db;
- threadDecoder.FolderIndex = folderIndex;
-
- // threadDecoder.UnpackSize = importantUnpackSize;
- // threadDecoder.send_UnpackSize = true;
- }
- else
- #endif
- {
- FosSpec2 = new CFolderInStream2;
- FosSpec2->Init();
- sbInStream = FosSpec2;
- repackBase = FosSpec2;
-
- #ifndef _NO_CRYPTO
- bool isEncrypted = false;
- bool passwordIsDefined = false;
- UString password;
- #endif
-
- CMyComPtr<ISequentialInStream> decodedStream;
- bool dataAfterEnd_Error = false;
-
- HRESULT res = threadDecoder.Decoder.Decode(
- EXTERNAL_CODECS_LOC_VARS
- inStream,
- db->ArcInfo.DataStartPosition, // db->GetFolderStreamPos(folderIndex, 0);,
- *db, folderIndex,
- // &importantUnpackSize, // *unpackSize
- NULL, // *unpackSize : FULL unpack
-
- NULL, // *outStream
- NULL, // *compressProgress
-
- &decodedStream
- , dataAfterEnd_Error
-
- _7Z_DECODER_CRYPRO_VARS
- #ifndef _7ZIP_ST
- , false // mtMode
- , 1 // numThreads
- , 0 // memUsage
- #endif
- );
-
- RINOK(res);
- if (!decodedStream)
- return E_FAIL;
-
- FosSpec2->_inStream = decodedStream;
- }
-
- repackBase->_db = db;
- repackBase->_opCallback = opCallback;
- repackBase->_extractCallback = extractCallback;
-
- UInt32 startIndex = db->FolderStartFileIndex[folderIndex];
- RINOK(repackBase->Init(startIndex, &extractStatuses));
-
- inStreamSizeCountSpec->_db = db;
- inStreamSizeCountSpec->Init(sbInStream, startIndex, &extractStatuses);
-
- #ifndef _7ZIP_ST
- if (options.MultiThreadMixer)
- {
- threadDecoder.Start();
- }
- #endif
- }
-
- curUnpackSize = sizeToEncode;
-
- HRESULT encodeRes = encoder.Encode(
- EXTERNAL_CODECS_LOC_VARS
- inStreamSizeCount,
- // NULL,
- &inSizeForReduce,
- newDatabase.Folders.AddNew(), newDatabase.CoderUnpackSizes, curUnpackSize,
- archive.SeqStream, newDatabase.PackSizes, progress);
-
- if (encodeRes == k_My_HRESULT_CRC_ERROR)
- return E_FAIL;
-
- #ifndef _7ZIP_ST
- if (options.MultiThreadMixer)
- {
- // 16.00: hang was fixed : for case if decoding was not finished.
- // We close CBinderInStream and it calls CStreamBinder::CloseRead()
- inStreamSizeCount.Release();
- sbInStream.Release();
-
- threadDecoder.WaitExecuteFinish();
-
- HRESULT decodeRes = threadDecoder.Result;
- // if (res == k_My_HRESULT_CRC_ERROR)
- if (decodeRes == S_FALSE || threadDecoder.dataAfterEnd_Error)
- {
- if (extractCallback)
- {
- RINOK(extractCallback->ReportExtractResult(
- NEventIndexType::kInArcIndex, db->FolderStartFileIndex[folderIndex],
- // NEventIndexType::kBlockIndex, (UInt32)folderIndex,
- (decodeRes != S_OK ?
- NExtract::NOperationResult::kDataError :
- NExtract::NOperationResult::kDataAfterEnd)));
- }
- if (decodeRes != S_OK)
- return E_FAIL;
- }
- RINOK(decodeRes);
- if (encodeRes == S_OK)
- if (sb.ProcessedSize != sizeToEncode)
- encodeRes = E_FAIL;
- }
- else
- #endif
- {
- if (FosSpec2->Result == S_FALSE)
- {
- if (extractCallback)
- {
- RINOK(extractCallback->ReportExtractResult(
- NEventIndexType::kBlockIndex, (UInt32)folderIndex,
- NExtract::NOperationResult::kDataError));
- }
- return E_FAIL;
- }
- RINOK(FosSpec2->Result);
- }
-
- RINOK(encodeRes);
- RINOK(repackBase->CheckFinishedState());
-
- if (curUnpackSize != sizeToEncode)
- return E_FAIL;
- }
-
- for (; startPackIndex < newDatabase.PackSizes.Size(); startPackIndex++)
- lps->OutSize += newDatabase.PackSizes[startPackIndex];
- lps->InSize += curUnpackSize;
- }
-
- newDatabase.NumUnpackStreamsVector.Add(rep.NumCopyFiles);
-
- CNum indexInFolder = 0;
- for (CNum fi = db->FolderStartFileIndex[folderIndex]; indexInFolder < numUnpackStreams; fi++)
- {
- if (db->Files[fi].HasStream)
- {
- indexInFolder++;
- int updateIndex = fileIndexToUpdateIndexMap[fi];
- if (updateIndex >= 0)
- {
- const CUpdateItem &ui = updateItems[updateIndex];
- if (ui.NewData)
- continue;
-
- UString name;
- CFileItem file;
- CFileItem2 file2;
- GetFile(*db, fi, file, file2);
-
- if (ui.NewProps)
- {
- UpdateItem_To_FileItem2(ui, file2);
- file.IsDir = ui.IsDir;
- name = ui.Name;
- }
- else
- db->GetPath(fi, name);
-
- /*
- file.Parent = ui.ParentFolderIndex;
- if (ui.TreeFolderIndex >= 0)
- treeFolderToArcIndex[ui.TreeFolderIndex] = newDatabase.Files.Size();
- if (totalSecureDataSize != 0)
- newDatabase.SecureIDs.Add(ui.SecureIndex);
- */
- newDatabase.AddFile(file, file2, name);
- }
- }
- }
- }
-
-
- // ---------- Compress files to new solid blocks ----------
-
- unsigned numFiles = group.Indices.Size();
- if (numFiles == 0)
- continue;
- CRecordVector<CRefItem> refItems;
- refItems.ClearAndSetSize(numFiles);
- // bool sortByType = (options.UseTypeSorting && isSoid); // numSolidFiles > 1
- bool sortByType = options.UseTypeSorting;
-
- unsigned i;
-
- for (i = 0; i < numFiles; i++)
- refItems[i] = CRefItem(group.Indices[i], updateItems[group.Indices[i]], sortByType);
-
- CSortParam sortParam;
- // sortParam.TreeFolders = &treeFolders;
- sortParam.SortByType = sortByType;
- refItems.Sort(CompareUpdateItems, (void *)&sortParam);
-
- CObjArray<UInt32> indices(numFiles);
-
- for (i = 0; i < numFiles; i++)
- {
- UInt32 index = refItems[i].Index;
- indices[i] = index;
- /*
- const CUpdateItem &ui = updateItems[index];
- CFileItem file;
- if (ui.NewProps)
- UpdateItem_To_FileItem(ui, file);
- else
- file = db.Files[ui.IndexInArchive];
- if (file.IsAnti || file.IsDir)
- return E_FAIL;
- newDatabase.Files.Add(file);
- */
- }
-
- for (i = 0; i < numFiles;)
- {
- UInt64 totalSize = 0;
- unsigned numSubFiles;
-
- const wchar_t *prevExtension = NULL;
-
- for (numSubFiles = 0; i + numSubFiles < numFiles && numSubFiles < numSolidFiles; numSubFiles++)
- {
- const CUpdateItem &ui = updateItems[indices[i + numSubFiles]];
- totalSize += ui.Size;
- if (totalSize > options.NumSolidBytes)
- break;
- if (options.SolidExtension)
- {
- int slashPos = ui.Name.ReverseFind_PathSepar();
- int dotPos = ui.Name.ReverseFind_Dot();
- const wchar_t *ext = ui.Name.Ptr(dotPos <= slashPos ? ui.Name.Len() : dotPos + 1);
- if (numSubFiles == 0)
- prevExtension = ext;
- else if (!StringsAreEqualNoCase(ext, prevExtension))
- break;
- }
- }
-
- if (numSubFiles < 1)
- numSubFiles = 1;
-
- RINOK(lps->SetCur());
-
- CFolderInStream *inStreamSpec = new CFolderInStream;
- CMyComPtr<ISequentialInStream> solidInStream(inStreamSpec);
- inStreamSpec->Init(updateCallback, &indices[i], numSubFiles);
-
- unsigned startPackIndex = newDatabase.PackSizes.Size();
- UInt64 curFolderUnpackSize = totalSize;
- // curFolderUnpackSize = (UInt64)(Int64)-1;
-
- RINOK(encoder.Encode(
- EXTERNAL_CODECS_LOC_VARS
- solidInStream,
- // NULL,
- &inSizeForReduce,
- newDatabase.Folders.AddNew(), newDatabase.CoderUnpackSizes, curFolderUnpackSize,
- archive.SeqStream, newDatabase.PackSizes, progress));
-
- if (!inStreamSpec->WasFinished())
- return E_FAIL;
-
- for (; startPackIndex < newDatabase.PackSizes.Size(); startPackIndex++)
- lps->OutSize += newDatabase.PackSizes[startPackIndex];
-
- lps->InSize += curFolderUnpackSize;
- // for ()
- // newDatabase.PackCRCsDefined.Add(false);
- // newDatabase.PackCRCs.Add(0);
-
- CNum numUnpackStreams = 0;
- UInt64 skippedSize = 0;
-
- for (unsigned subIndex = 0; subIndex < numSubFiles; subIndex++)
- {
- const CUpdateItem &ui = updateItems[indices[i + subIndex]];
- CFileItem file;
- CFileItem2 file2;
- UString name;
- if (ui.NewProps)
- {
- UpdateItem_To_FileItem(ui, file, file2);
- name = ui.Name;
- }
- else
- {
- GetFile(*db, ui.IndexInArchive, file, file2);
- db->GetPath(ui.IndexInArchive, name);
- }
- if (file2.IsAnti || file.IsDir)
- return E_FAIL;
-
- /*
- CFileItem &file = newDatabase.Files[
- startFileIndexInDatabase + i + subIndex];
- */
- if (!inStreamSpec->Processed[subIndex])
- {
- skippedSize += ui.Size;
- continue;
- // file.Name += ".locked";
- }
-
- file.Crc = inStreamSpec->CRCs[subIndex];
- file.Size = inStreamSpec->Sizes[subIndex];
-
- // if (file.Size >= 0) // test purposes
- if (file.Size != 0)
- {
- file.CrcDefined = true;
- file.HasStream = true;
- numUnpackStreams++;
- }
- else
- {
- file.CrcDefined = false;
- file.HasStream = false;
- }
-
- /*
- file.Parent = ui.ParentFolderIndex;
- if (ui.TreeFolderIndex >= 0)
- treeFolderToArcIndex[ui.TreeFolderIndex] = newDatabase.Files.Size();
- if (totalSecureDataSize != 0)
- newDatabase.SecureIDs.Add(ui.SecureIndex);
- */
- newDatabase.AddFile(file, file2, name);
- }
-
- // numUnpackStreams = 0 is very bad case for locked files
- // v3.13 doesn't understand it.
- newDatabase.NumUnpackStreamsVector.Add(numUnpackStreams);
- i += numSubFiles;
-
- if (skippedSize != 0 && complexity >= skippedSize)
- {
- complexity -= skippedSize;
- RINOK(updateCallback->SetTotal(complexity));
- }
- }
- }
-
- RINOK(lps->SetCur());
-
- /*
- fileIndexToUpdateIndexMap.ClearAndFree();
- groups.ClearAndFree();
- */
-
- /*
- for (i = 0; i < newDatabase.Files.Size(); i++)
- {
- CFileItem &file = newDatabase.Files[i];
- file.Parent = treeFolderToArcIndex[file.Parent];
- }
-
- if (totalSecureDataSize != 0)
- {
- newDatabase.SecureBuf.SetCapacity(totalSecureDataSize);
- size_t pos = 0;
- newDatabase.SecureSizes.Reserve(secureBlocks.Sorted.Size());
- for (i = 0; i < secureBlocks.Sorted.Size(); i++)
- {
- const CByteBuffer &buf = secureBlocks.Bufs[secureBlocks.Sorted[i]];
- size_t size = buf.GetCapacity();
- if (size != 0)
- memcpy(newDatabase.SecureBuf + pos, buf, size);
- newDatabase.SecureSizes.Add((UInt32)size);
- pos += size;
- }
- }
- */
- newDatabase.ReserveDown();
-
- if (opCallback)
- RINOK(opCallback->ReportOperation(NEventIndexType::kNoIndex, (UInt32)(Int32)-1, NUpdateNotifyOp::kHeader));
-
- return S_OK;
-}
-
-}}
+// 7zUpdate.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyLinux.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "7zDecode.h"
+#include "7zEncode.h"
+#include "7zFolderInStream.h"
+#include "7zHandler.h"
+#include "7zOut.h"
+#include "7zUpdate.h"
+
+namespace NArchive {
+namespace N7z {
+
+#define k_X86 k_BCJ
+
+struct CFilterMode
+{
+ UInt32 Id;
+ UInt32 Delta; // required File Size alignment, if Id is not k_Delta.
+ // (Delta == 0) means unknown alignment
+ UInt32 Offset; // for k_ARM64
+ // UInt32 AlignSizeOpt; // for k_ARM64
+
+ CFilterMode():
+ Id(0),
+ Delta(0),
+ Offset(0)
+ // , AlignSizeOpt(0)
+ {}
+
+ void ClearFilterMode()
+ {
+ Id = 0;
+ Delta = 0;
+ Offset = 0;
+ // AlignSizeOpt = 0;
+ }
+
+ // it sets Delta as Align value, if Id is exe filter
+ // in another cases it sets Delta = 0, that
+ void SetDelta()
+ {
+ if (Id == k_IA64)
+ Delta = 16;
+ else if (Id == k_ARM64 || Id == k_ARM || Id == k_PPC || Id == k_SPARC)
+ Delta = 4;
+ else if (Id == k_ARMT)
+ Delta = 2;
+ else if (Id == k_BCJ || Id == k_BCJ2)
+ Delta = 1; // do we need it?
+ else
+ Delta = 0;
+ }
+};
+
+
+/* ---------- PE ---------- */
+
+#define MZ_SIG 0x5A4D
+
+#define PE_SIG 0x00004550
+#define PE_OptHeader_Magic_32 0x10B
+#define PE_OptHeader_Magic_64 0x20B
+// #define PE_SectHeaderSize 40
+// #define PE_SECT_EXECUTE 0x20000000
+
+static int Parse_EXE(const Byte *buf, size_t size, CFilterMode *filterMode)
+{
+ if (size < 512 || GetUi16(buf) != MZ_SIG)
+ return 0;
+
+ const Byte *p;
+ UInt32 peOffset, optHeaderSize, filterId;
+
+ peOffset = GetUi32(buf + 0x3C);
+ if (peOffset >= 0x1000 || peOffset + 512 > size || (peOffset & 7) != 0)
+ return 0;
+ p = buf + peOffset;
+ if (GetUi32(p) != PE_SIG)
+ return 0;
+ p += 4;
+
+ switch (GetUi16(p))
+ {
+ case 0x014C:
+ case 0x8664: filterId = k_X86; break;
+ case 0xAA64: filterId = k_ARM64; break;
+
+ /*
+ IMAGE_FILE_MACHINE_ARM 0x01C0 // ARM LE
+ IMAGE_FILE_MACHINE_THUMB 0x01C2 // ARM Thumb / Thumb-2 LE
+ IMAGE_FILE_MACHINE_ARMNT 0x01C4 // ARM Thumb-2, LE
+ Note: We use ARM filter for 0x01C2. (WinCE 5 - 0x01C2) files mostly contain ARM code (not Thumb/Thumb-2).
+ */
+
+ case 0x01C0: // WinCE old
+ case 0x01C2: filterId = k_ARM; break; // WinCE new
+ case 0x01C4: filterId = k_ARMT; break; // WinRT
+
+ case 0x0200: filterId = k_IA64; break;
+ default: return 0;
+ }
+
+ // const UInt32 numSections = GetUi16(p + 2);
+ optHeaderSize = GetUi16(p + 16);
+ if (optHeaderSize > (1 << 10))
+ return 0;
+
+ p += 20; /* headerSize */
+
+ switch (GetUi16(p))
+ {
+ case PE_OptHeader_Magic_32:
+ case PE_OptHeader_Magic_64:
+ break;
+ default:
+ return 0;
+ }
+
+ /*
+ // Windows exe file sizes are not aligned for 4 KiB.
+ // So we can't use (CFilterMode::Offset != 0) in solid archives.
+ // So we just don't set Offset here.
+#define NUM_SCAN_SECTIONS_MAX (1 << 6)
+#define EXE_SECTION_OFFSET_MAX (1 << 27)
+#define EXE_SECTION_SIZE_MIN (1 << 8)
+#define EXE_SECTION_SIZE_MAX (1 << 27)
+#define PE_SectHeaderSize 40
+#define PE_SECT_EXECUTE 0x20000000
+
+ if (numSections > NUM_SCAN_SECTIONS_MAX)
+ return 0;
+
+ p += optHeaderSize;
+ // UInt32 numExeSections = 0;
+ // bool execute_finded = false;
+ // UInt32 sect_va = 0;
+ // UInt32 sect_size = 0;
+ // UInt32 sect_offset = 0;
+
+ for (UInt32 i = 0; i < numSections
+ // && numExeSections < numSectionsMax
+ ; i++, p += PE_SectHeaderSize)
+ {
+ UInt32 characts, rawSize, offset;
+ if ((UInt32)(p - buf) + PE_SectHeaderSize > size)
+ return 0;
+ rawSize = GetUi32(p + 16);
+ offset = GetUi32(p + 20);
+ characts = GetUi32(p + 36);
+ if (rawSize >= EXE_SECTION_SIZE_MIN &&
+ rawSize <= EXE_SECTION_SIZE_MAX &&
+ offset <= EXE_SECTION_OFFSET_MAX &&
+ // offset < limit &&
+ offset > 0)
+ {
+ if ((characts & PE_SECT_EXECUTE) != 0)
+ {
+ // execute_finded = true;
+ // sect_va = GetUi32(p + 12);
+ // sect_size = rawSize;
+ // sect_offset = offset;
+ break;
+ }
+ }
+ }
+
+ filterMode->Offset = 0;
+ if (filterId == k_ARM64)
+ {
+ // filterMode->AlignSizeOpt = (1 << 12);
+ // const UInt32 offs = (sect_va - sect_offset) & 0xFFF;
+ // if (offs != 0)
+ // filterMode->Offset = offs; // change it
+ }
+ */
+ filterMode->Id = filterId;
+ return 1;
+}
+
+
+/* ---------- ELF ---------- */
+
+#define ELF_SIG 0x464C457F
+
+#define ELF_CLASS_32 1
+#define ELF_CLASS_64 2
+
+#define ELF_DATA_2LSB 1
+#define ELF_DATA_2MSB 2
+
+static UInt16 Get16(const Byte *p, BoolInt be) { if (be) return (UInt16)GetBe16(p); return (UInt16)GetUi16(p); }
+static UInt32 Get32(const Byte *p, BoolInt be) { if (be) return GetBe32(p); return GetUi32(p); }
+// static UInt64 Get64(const Byte *p, BoolInt be) { if (be) return GetBe64(p); return GetUi64(p); }
+
+static int Parse_ELF(const Byte *buf, size_t size, CFilterMode *filterMode)
+{
+ BoolInt /* is32, */ be;
+ UInt32 filterId;
+
+ if (size < 512 || buf[6] != 1) /* ver */
+ return 0;
+
+ if (GetUi32(buf) != ELF_SIG)
+ return 0;
+
+ switch (buf[4])
+ {
+ case ELF_CLASS_32: /* is32 = True; */ break;
+ case ELF_CLASS_64: /* is32 = False; */ break;
+ default: return 0;
+ }
+
+ switch (buf[5])
+ {
+ case ELF_DATA_2LSB: be = False; break;
+ case ELF_DATA_2MSB: be = True; break;
+ default: return 0;
+ }
+
+ switch (Get16(buf + 0x12, be))
+ {
+ case 3:
+ case 6:
+ case 62: filterId = k_X86; break;
+ case 2:
+ case 18:
+ case 43: filterId = k_SPARC; break;
+ case 20:
+ case 21: if (!be) return 0; filterId = k_PPC; break;
+ case 40: if ( be) return 0; filterId = k_ARM; break;
+ case 183: if (be) return 0; filterId = k_ARM64; break;
+
+ /* Some IA-64 ELF executables have size that is not aligned for 16 bytes.
+ So we don't use IA-64 filter for IA-64 ELF */
+ // case 50: if ( be) return 0; filterId = k_IA64; break;
+
+ default: return 0;
+ }
+
+ filterMode->Id = filterId;
+ return 1;
+}
+
+
+
+/* ---------- Mach-O ---------- */
+
+#define MACH_SIG_BE_32 0xCEFAEDFE
+#define MACH_SIG_BE_64 0xCFFAEDFE
+#define MACH_SIG_LE_32 0xFEEDFACE
+#define MACH_SIG_LE_64 0xFEEDFACF
+
+#define MACH_ARCH_ABI64 (1 << 24)
+#define MACH_MACHINE_386 7
+#define MACH_MACHINE_ARM 12
+#define MACH_MACHINE_SPARC 14
+#define MACH_MACHINE_PPC 18
+#define MACH_MACHINE_PPC64 (MACH_ARCH_ABI64 | MACH_MACHINE_PPC)
+#define MACH_MACHINE_AMD64 (MACH_ARCH_ABI64 | MACH_MACHINE_386)
+#define MACH_MACHINE_ARM64 (MACH_ARCH_ABI64 | MACH_MACHINE_ARM)
+
+static unsigned Parse_MACH(const Byte *buf, size_t size, CFilterMode *filterMode)
+{
+ UInt32 filterId, numCommands, commandsSize;
+
+ if (size < 512)
+ return 0;
+
+ BoolInt /* mode64, */ be;
+ switch (GetUi32(buf))
+ {
+ case MACH_SIG_BE_32: /* mode64 = False; */ be = True; break;
+ case MACH_SIG_BE_64: /* mode64 = True; */ be = True; break;
+ case MACH_SIG_LE_32: /* mode64 = False; */ be = False; break;
+ case MACH_SIG_LE_64: /* mode64 = True; */ be = False; break;
+ default: return 0;
+ }
+
+ switch (Get32(buf + 4, be))
+ {
+ case MACH_MACHINE_386:
+ case MACH_MACHINE_AMD64: filterId = k_X86; break;
+ case MACH_MACHINE_ARM: if ( be) return 0; filterId = k_ARM; break;
+ case MACH_MACHINE_SPARC: if (!be) return 0; filterId = k_SPARC; break;
+ case MACH_MACHINE_PPC:
+ case MACH_MACHINE_PPC64: if (!be) return 0; filterId = k_PPC; break;
+ case MACH_MACHINE_ARM64: if ( be) return 0; filterId = k_ARM64; break;
+ default: return 0;
+ }
+
+ numCommands = Get32(buf + 0x10, be);
+ commandsSize = Get32(buf + 0x14, be);
+
+ if (commandsSize > (1 << 24) || numCommands > (1 << 18))
+ return 0;
+
+ filterMode->Id = filterId;
+ return 1;
+}
+
+
+/* ---------- WAV ---------- */
+
+#define WAV_SUBCHUNK_fmt 0x20746D66
+#define WAV_SUBCHUNK_data 0x61746164
+
+#define RIFF_SIG 0x46464952
+
+static BoolInt Parse_WAV(const Byte *buf, size_t size, CFilterMode *filterMode)
+{
+ UInt32 subChunkSize, pos;
+ if (size < 0x2C)
+ return False;
+
+ if (GetUi32(buf + 0) != RIFF_SIG ||
+ GetUi32(buf + 8) != 0x45564157 || // WAVE
+ GetUi32(buf + 0xC) != WAV_SUBCHUNK_fmt)
+ return False;
+ subChunkSize = GetUi32(buf + 0x10);
+ /* [0x14 = format] = 1 (PCM) */
+ if (subChunkSize < 0x10 || subChunkSize > 0x12 || GetUi16(buf + 0x14) != 1)
+ return False;
+
+ const unsigned numChannels = GetUi16(buf + 0x16);
+ const unsigned bitsPerSample = GetUi16(buf + 0x22);
+ if ((bitsPerSample & 0x7) != 0)
+ return False;
+ const UInt32 delta = (UInt32)numChannels * (bitsPerSample >> 3);
+ if (delta == 0 || delta > 256)
+ return False;
+
+ pos = 0x14 + subChunkSize;
+
+ const int kNumSubChunksTests = 10;
+ // Do we need to scan more than 3 sub-chunks?
+ for (int i = 0; i < kNumSubChunksTests; i++)
+ {
+ if (pos + 8 > size)
+ return False;
+ subChunkSize = GetUi32(buf + pos + 4);
+ if (GetUi32(buf + pos) == WAV_SUBCHUNK_data)
+ {
+ filterMode->Id = k_Delta;
+ filterMode->Delta = delta;
+ return True;
+ }
+ if (subChunkSize > (1 << 16))
+ return False;
+ pos += subChunkSize + 8;
+ }
+ return False;
+}
+
+
+/*
+ filterMode->Delta will be set as:
+ = delta value : [1, 256] : for k_Delta
+ = 0 for another filters (branch filters)
+*/
+static BoolInt ParseFile(const Byte *buf, size_t size, CFilterMode *filterMode)
+{
+ filterMode->ClearFilterMode();
+
+ if (Parse_EXE(buf, size, filterMode)) return True;
+ if (Parse_ELF(buf, size, filterMode)) return True;
+ if (Parse_MACH(buf, size, filterMode)) return True;
+ return Parse_WAV(buf, size, filterMode);
+}
+
+
+
+
+struct CFilterMode2: public CFilterMode
+{
+ bool Encrypted;
+ unsigned GroupIndex;
+
+ CFilterMode2(): Encrypted(false) {}
+
+ int Compare(const CFilterMode2 &m) const
+ {
+ if (!Encrypted)
+ {
+ if (m.Encrypted)
+ return -1;
+ }
+ else if (!m.Encrypted)
+ return 1;
+
+ const UInt32 id1 = Id;
+ const UInt32 id2 = m.Id;
+ /*
+ // we can change the order to place k_ARM64 files close to another exe files
+ if (id1 <= k_SPARC &&
+ id2 <= k_SPARC)
+ {
+ #define k_ARM64_FOR_SORT 0x3030901
+ if (id1 == k_ARM64) id1 = k_ARM64_FOR_SORT;
+ if (id2 == k_ARM64) id2 = k_ARM64_FOR_SORT;
+ }
+ */
+ if (id1 < id2) return -1;
+ if (id1 > id2) return 1;
+
+ if (Delta < m.Delta) return -1;
+ if (Delta > m.Delta) return 1;
+
+ if (Offset < m.Offset) return -1;
+ if (Offset > m.Offset) return 1;
+
+ /* we don't go here, because GetGroup()
+ and operator ==(const CFilterMode2 &m)
+ add only unique CFilterMode2:: { Id, Delta, Offset, Encrypted } items.
+ */
+ /*
+ if (GroupIndex < m.GroupIndex) return -1;
+ if (GroupIndex > m.GroupIndex) return 1;
+ */
+ return 0;
+ }
+
+ bool operator ==(const CFilterMode2 &m) const
+ {
+ return Id == m.Id
+ && Delta == m.Delta
+ && Offset == m.Offset
+ && Encrypted == m.Encrypted;
+ }
+};
+
+static unsigned GetGroup(CRecordVector<CFilterMode2> &filters, const CFilterMode2 &m)
+{
+ unsigned i;
+ for (i = 0; i < filters.Size(); i++)
+ {
+ const CFilterMode2 &m2 = filters[i];
+ if (m == m2)
+ return i;
+ /*
+ if (m.Encrypted != m2.Encrypted)
+ {
+ if (!m.Encrypted)
+ break;
+ continue;
+ }
+
+ if (m.Id < m2.Id) break;
+ if (m.Id != m2.Id) continue;
+
+ if (m.Delta < m2.Delta) break;
+ if (m.Delta != m2.Delta) continue;
+ */
+ }
+ // filters.Insert(i, m);
+ // return i;
+ return filters.Add(m);
+}
+
+static inline bool Is86Filter(CMethodId m)
+{
+ return (m == k_BCJ || m == k_BCJ2);
+}
+
+static inline bool IsExeFilter(CMethodId m)
+{
+ switch (m)
+ {
+ case k_ARM64:
+ case k_BCJ:
+ case k_BCJ2:
+ case k_ARM:
+ case k_ARMT:
+ case k_PPC:
+ case k_SPARC:
+ case k_IA64:
+ return true;
+ }
+ return false;
+}
+
+static unsigned Get_FilterGroup_for_Folder(
+ CRecordVector<CFilterMode2> &filters, const CFolderEx &f, bool extractFilter)
+{
+ CFilterMode2 m;
+ // m.Id = 0;
+ // m.Delta = 0;
+ // m.Offset = 0;
+ m.Encrypted = f.IsEncrypted();
+
+ if (extractFilter)
+ {
+ const CCoderInfo &coder = f.Coders[f.UnpackCoder];
+
+ if (coder.MethodID == k_Delta)
+ {
+ if (coder.Props.Size() == 1)
+ {
+ m.Delta = (unsigned)coder.Props[0] + 1;
+ m.Id = k_Delta;
+ }
+ }
+ else if (IsExeFilter(coder.MethodID))
+ {
+ m.Id = (UInt32)coder.MethodID;
+ if (m.Id == k_BCJ2)
+ m.Id = k_BCJ;
+ m.SetDelta();
+ if (m.Id == k_ARM64)
+ if (coder.Props.Size() == 4)
+ m.Offset = GetUi32(coder.Props);
+ }
+ }
+
+ return GetGroup(filters, m);
+}
+
+
+
+
+static HRESULT WriteRange(IInStream *inStream, ISequentialOutStream *outStream,
+ UInt64 position, UInt64 size, ICompressProgressInfo *progress)
+{
+ RINOK(InStream_SeekSet(inStream, position))
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStreamLimited(streamSpec);
+ streamSpec->SetStream(inStream);
+ streamSpec->Init(size);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+ RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress))
+ return (copyCoderSpec->TotalSize == size ? S_OK : E_FAIL);
+}
+
+/*
+unsigned CUpdateItem::GetExtensionPos() const
+{
+ int slashPos = Name.ReverseFind_PathSepar();
+ int dotPos = Name.ReverseFind_Dot();
+ if (dotPos <= slashPos)
+ return Name.Len();
+ return dotPos + 1;
+}
+
+UString CUpdateItem::GetExtension() const
+{
+ return Name.Ptr(GetExtensionPos());
+}
+*/
+
+#define RINOZ(x) { const int _t_ = (x); if (_t_ != 0) return _t_; }
+
+#define RINOZ_COMP(a, b) RINOZ(MyCompare(a, b))
+
+/*
+static int CompareBuffers(const CByteBuffer &a1, const CByteBuffer &a2)
+{
+ size_t c1 = a1.GetCapacity();
+ size_t c2 = a2.GetCapacity();
+ RINOZ_COMP(c1, c2);
+ for (size_t i = 0; i < c1; i++)
+ RINOZ_COMP(a1[i], a2[i]);
+ return 0;
+}
+
+static int CompareCoders(const CCoderInfo &c1, const CCoderInfo &c2)
+{
+ RINOZ_COMP(c1.NumInStreams, c2.NumInStreams);
+ RINOZ_COMP(c1.NumOutStreams, c2.NumOutStreams);
+ RINOZ_COMP(c1.MethodID, c2.MethodID);
+ return CompareBuffers(c1.Props, c2.Props);
+}
+
+static int CompareBonds(const CBond &b1, const CBond &b2)
+{
+ RINOZ_COMP(b1.InIndex, b2.InIndex);
+ return MyCompare(b1.OutIndex, b2.OutIndex);
+}
+
+static int CompareFolders(const CFolder &f1, const CFolder &f2)
+{
+ int s1 = f1.Coders.Size();
+ int s2 = f2.Coders.Size();
+ RINOZ_COMP(s1, s2);
+ int i;
+ for (i = 0; i < s1; i++)
+ RINOZ(CompareCoders(f1.Coders[i], f2.Coders[i]));
+ s1 = f1.Bonds.Size();
+ s2 = f2.Bonds.Size();
+ RINOZ_COMP(s1, s2);
+ for (i = 0; i < s1; i++)
+ RINOZ(CompareBonds(f1.Bonds[i], f2.Bonds[i]));
+ return 0;
+}
+*/
+
+/*
+static int CompareFiles(const CFileItem &f1, const CFileItem &f2)
+{
+ return CompareFileNames(f1.Name, f2.Name);
+}
+*/
+
+struct CFolderRepack
+{
+ unsigned FolderIndex;
+ CNum NumCopyFiles;
+};
+
+/*
+static int CompareFolderRepacks(const CFolderRepack *p1, const CFolderRepack *p2, void *)
+{
+ int i1 = p1->FolderIndex;
+ int i2 = p2->FolderIndex;
+ // In that version we don't want to parse folders here, so we don't compare folders
+ // probably it must be improved in future
+ // const CDbEx &db = *(const CDbEx *)param;
+ // RINOZ(CompareFolders(
+ // db.Folders[i1],
+ // db.Folders[i2]));
+
+ return MyCompare(i1, i2);
+
+ // RINOZ_COMP(
+ // db.NumUnpackStreamsVector[i1],
+ // db.NumUnpackStreamsVector[i2]);
+ // if (db.NumUnpackStreamsVector[i1] == 0)
+ // return 0;
+ // return CompareFiles(
+ // db.Files[db.FolderStartFileIndex[i1]],
+ // db.Files[db.FolderStartFileIndex[i2]]);
+}
+*/
+
+/*
+ we sort empty files and dirs in such order:
+ - Dir.NonAnti (name sorted)
+ - File.NonAnti (name sorted)
+ - File.Anti (name sorted)
+ - Dir.Anti (reverse name sorted)
+*/
+
+static int CompareEmptyItems(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const CObjectVector<CUpdateItem> &updateItems = *(const CObjectVector<CUpdateItem> *)param;
+ const CUpdateItem &u1 = updateItems[*p1];
+ const CUpdateItem &u2 = updateItems[*p2];
+ // NonAnti < Anti
+ if (u1.IsAnti != u2.IsAnti)
+ return (u1.IsAnti ? 1 : -1);
+ if (u1.IsDir != u2.IsDir)
+ {
+ // Dir.NonAnti < File < Dir.Anti
+ if (u1.IsDir)
+ return (u1.IsAnti ? 1 : -1);
+ return (u2.IsAnti ? -1 : 1);
+ }
+ int n = CompareFileNames(u1.Name, u2.Name);
+ return (u1.IsDir && u1.IsAnti) ? -n : n;
+}
+
+static const char *g_Exts =
+ " 7z xz lzma ace arc arj bz tbz bz2 tbz2 cab deb gz tgz ha lha lzh lzo lzx pak rar rpm sit zoo"
+ " zip jar ear war msi"
+ " 3gp avi mov mpeg mpg mpe wmv"
+ " aac ape fla flac la mp3 m4a mp4 ofr ogg pac ra rm rka shn swa tta wv wma wav"
+ " swf"
+ " chm hxi hxs"
+ " gif jpeg jpg jp2 png tiff bmp ico psd psp"
+ " awg ps eps cgm dxf svg vrml wmf emf ai md"
+ " cad dwg pps key sxi"
+ " max 3ds"
+ " iso bin nrg mdf img pdi tar cpio xpi"
+ " vfd vhd vud vmc vsv"
+ " vmdk dsk nvram vmem vmsd vmsn vmss vmtm"
+ " inl inc idl acf asa"
+ " h hpp hxx c cpp cxx m mm go swift"
+ " rc java cs rs pas bas vb cls ctl frm dlg def"
+ " f77 f f90 f95"
+ " asm s"
+ " sql manifest dep"
+ " mak clw csproj vcproj sln dsp dsw"
+ " class"
+ " bat cmd bash sh"
+ " xml xsd xsl xslt hxk hxc htm html xhtml xht mht mhtml htw asp aspx css cgi jsp shtml"
+ " awk sed hta js json php php3 php4 php5 phptml pl pm py pyo rb tcl ts vbs"
+ " text txt tex ans asc srt reg ini doc docx mcw dot rtf hlp xls xlr xlt xlw ppt pdf"
+ " sxc sxd sxi sxg sxw stc sti stw stm odt ott odg otg odp otp ods ots odf"
+ " abw afp cwk lwp wpd wps wpt wrf wri"
+ " abf afm bdf fon mgf otf pcf pfa snf ttf"
+ " dbf mdb nsf ntf wdb db fdb gdb"
+ " exe dll ocx vbx sfx sys tlb awx com obj lib out o so"
+ " pdb pch idb ncb opt";
+
+static unsigned GetExtIndex(const char *ext)
+{
+ unsigned extIndex = 1;
+ const char *p = g_Exts;
+ for (;;)
+ {
+ char c = *p++;
+ if (c == 0)
+ return extIndex;
+ if (c == ' ')
+ continue;
+ unsigned pos = 0;
+ for (;;)
+ {
+ char c2 = ext[pos++];
+ if (c2 == 0 && (c == 0 || c == ' '))
+ return extIndex;
+ if (c != c2)
+ break;
+ c = *p++;
+ }
+ extIndex++;
+ for (;;)
+ {
+ if (c == 0)
+ return extIndex;
+ if (c == ' ')
+ break;
+ c = *p++;
+ }
+ }
+}
+
+struct CRefItem
+{
+ const CUpdateItem *UpdateItem;
+ UInt32 Index;
+ unsigned ExtensionPos;
+ unsigned NamePos;
+ unsigned ExtensionIndex;
+
+ CRefItem() {}
+ CRefItem(UInt32 index, const CUpdateItem &ui, bool sortByType):
+ UpdateItem(&ui),
+ Index(index),
+ ExtensionPos(0),
+ NamePos(0),
+ ExtensionIndex(0)
+ {
+ if (sortByType)
+ {
+ int slashPos = ui.Name.ReverseFind_PathSepar();
+ NamePos = (unsigned)(slashPos + 1);
+ int dotPos = ui.Name.ReverseFind_Dot();
+ if (dotPos <= slashPos)
+ ExtensionPos = ui.Name.Len();
+ else
+ {
+ ExtensionPos = (unsigned)(dotPos + 1);
+ if (ExtensionPos != ui.Name.Len())
+ {
+ AString s;
+ for (unsigned pos = ExtensionPos;; pos++)
+ {
+ wchar_t c = ui.Name[pos];
+ if (c >= 0x80)
+ break;
+ if (c == 0)
+ {
+ ExtensionIndex = GetExtIndex(s);
+ break;
+ }
+ s += (char)MyCharLower_Ascii((char)c);
+ }
+ }
+ }
+ }
+ }
+};
+
+struct CSortParam
+{
+ // const CObjectVector<CTreeFolder> *TreeFolders;
+ bool SortByType;
+};
+
+/*
+ we sort files in such order:
+ - Dir.NonAnti (name sorted)
+ - alt streams
+ - Dirs
+ - Dir.Anti (reverse name sorted)
+*/
+
+
+static int CompareUpdateItems(const CRefItem *p1, const CRefItem *p2, void *param)
+{
+ const CRefItem &a1 = *p1;
+ const CRefItem &a2 = *p2;
+ const CUpdateItem &u1 = *a1.UpdateItem;
+ const CUpdateItem &u2 = *a2.UpdateItem;
+
+ /*
+ if (u1.IsAltStream != u2.IsAltStream)
+ return u1.IsAltStream ? 1 : -1;
+ */
+
+ // Actually there are no dirs that time. They were stored in other steps
+ // So that code is unused?
+ if (u1.IsDir != u2.IsDir)
+ return u1.IsDir ? 1 : -1;
+ if (u1.IsDir)
+ {
+ if (u1.IsAnti != u2.IsAnti)
+ return (u1.IsAnti ? 1 : -1);
+ int n = CompareFileNames(u1.Name, u2.Name);
+ return -n;
+ }
+
+ // bool sortByType = *(bool *)param;
+ const CSortParam *sortParam = (const CSortParam *)param;
+ const bool sortByType = sortParam->SortByType;
+ if (sortByType)
+ {
+ RINOZ_COMP(a1.ExtensionIndex, a2.ExtensionIndex)
+ RINOZ(CompareFileNames(u1.Name.Ptr(a1.ExtensionPos), u2.Name.Ptr(a2.ExtensionPos)))
+ RINOZ(CompareFileNames(u1.Name.Ptr(a1.NamePos), u2.Name.Ptr(a2.NamePos)))
+ if (!u1.MTimeDefined && u2.MTimeDefined) return 1;
+ if (u1.MTimeDefined && !u2.MTimeDefined) return -1;
+ if (u1.MTimeDefined && u2.MTimeDefined) RINOZ_COMP(u1.MTime, u2.MTime)
+ RINOZ_COMP(u1.Size, u2.Size)
+ }
+ /*
+ int par1 = a1.UpdateItem->ParentFolderIndex;
+ int par2 = a2.UpdateItem->ParentFolderIndex;
+ const CTreeFolder &tf1 = (*sortParam->TreeFolders)[par1];
+ const CTreeFolder &tf2 = (*sortParam->TreeFolders)[par2];
+
+ int b1 = tf1.SortIndex, e1 = tf1.SortIndexEnd;
+ int b2 = tf2.SortIndex, e2 = tf2.SortIndexEnd;
+ if (b1 < b2)
+ {
+ if (e1 <= b2)
+ return -1;
+ // p2 in p1
+ int par = par2;
+ for (;;)
+ {
+ const CTreeFolder &tf = (*sortParam->TreeFolders)[par];
+ par = tf.Parent;
+ if (par == par1)
+ {
+ RINOZ(CompareFileNames(u1.Name, tf.Name));
+ break;
+ }
+ }
+ }
+ else if (b2 < b1)
+ {
+ if (e2 <= b1)
+ return 1;
+ // p1 in p2
+ int par = par1;
+ for (;;)
+ {
+ const CTreeFolder &tf = (*sortParam->TreeFolders)[par];
+ par = tf.Parent;
+ if (par == par2)
+ {
+ RINOZ(CompareFileNames(tf.Name, u2.Name));
+ break;
+ }
+ }
+ }
+ */
+ // RINOZ_COMP(a1.UpdateItem->ParentSortIndex, a2.UpdateItem->ParentSortIndex);
+ RINOK(CompareFileNames(u1.Name, u2.Name))
+ RINOZ_COMP(a1.UpdateItem->IndexInClient, a2.UpdateItem->IndexInClient)
+ RINOZ_COMP(a1.UpdateItem->IndexInArchive, a2.UpdateItem->IndexInArchive)
+ return 0;
+}
+
+struct CSolidGroup
+{
+ CRecordVector<UInt32> Indices;
+
+ CRecordVector<CFolderRepack> folderRefs;
+};
+
+static const char * const g_Exe_Exts[] =
+{
+ "dll"
+ , "exe"
+ , "ocx"
+ , "sfx"
+ , "sys"
+};
+
+static const char * const g_ExeUnix_Exts[] =
+{
+ "so"
+ , "dylib"
+};
+
+static bool IsExt_Exe(const wchar_t *ext)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Exe_Exts); i++)
+ if (StringsAreEqualNoCase_Ascii(ext, g_Exe_Exts[i]))
+ return true;
+ return false;
+}
+
+/*
+static bool IsExt_ExeUnix(const wchar_t *ext)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_ExeUnix_Exts); i++)
+ if (StringsAreEqualNoCase_Ascii(ext, g_ExeUnix_Exts[i]))
+ return true;
+ return false;
+}
+*/
+
+// we try to find "so" extension in such name: libstdc++.so.6.0.29
+static bool IsExt_ExeUnix_NumericAllowed(const UString &path)
+{
+ unsigned pos = path.Len();
+ unsigned dotPos = pos;
+ for (;;)
+ {
+ if (pos == 0)
+ return false;
+ const wchar_t c = path[--pos];
+ if (IS_PATH_SEPAR(c))
+ return false;
+ if (c == '.')
+ {
+ const unsigned num = (dotPos - pos) - 1;
+ if (num < 1)
+ return false;
+ const wchar_t *cur = path.Ptr(pos + 1);
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_ExeUnix_Exts); i++)
+ {
+ const char *ext = g_ExeUnix_Exts[i];
+ if (num == MyStringLen(ext))
+ if (IsString1PrefixedByString2_NoCase_Ascii(cur, ext))
+ return true;
+ }
+ const wchar_t *end;
+ ConvertStringToUInt32(cur, &end);
+ if ((size_t)(end - cur) != num)
+ return false;
+ dotPos = pos;
+ }
+ }
+}
+
+
+struct CAnalysis
+{
+ CMyComPtr<IArchiveUpdateCallbackFile> Callback;
+ CByteBuffer Buffer;
+
+ bool ParseWav;
+ bool ParseExe;
+ bool ParseExeUnix;
+ bool ParseNoExt;
+ bool ParseAll;
+
+ /*
+ bool Need_ATime;
+ bool ATime_Defined;
+ FILETIME ATime;
+ */
+
+ CAnalysis():
+ ParseWav(false),
+ ParseExe(false),
+ ParseExeUnix(false),
+ ParseNoExt(false),
+ ParseAll(false)
+ /*
+ , Need_ATime(false)
+ , ATime_Defined(false)
+ */
+ {}
+
+ HRESULT GetFilterGroup(UInt32 index, const CUpdateItem &ui, CFilterMode &filterMode);
+};
+
+static const size_t kAnalysisBufSize = 1 << 14;
+
+HRESULT CAnalysis::GetFilterGroup(UInt32 index, const CUpdateItem &ui, CFilterMode &filterMode)
+{
+ filterMode.Id = 0;
+ filterMode.Delta = 0;
+ filterMode.Offset = 0;
+
+ CFilterMode filterModeTemp = filterMode;
+
+ const int slashPos = ui.Name.ReverseFind_PathSepar();
+ const int dotPos = ui.Name.ReverseFind_Dot();
+
+ // if (dotPos > slashPos)
+ {
+ bool needReadFile = ParseAll;
+ /* if (Callback) is not supported by client,
+ we still try to use file name extension to detect executable file */
+ bool probablyIsSameIsa = false;
+
+ if (!needReadFile || !Callback)
+ {
+ const wchar_t *ext = NULL;
+ if (dotPos > slashPos)
+ ext = ui.Name.Ptr((unsigned)(dotPos + 1));
+ // 7-zip stores posix attributes in high 16 bits and sets (0x8000) flag
+ if (ui.Attrib & 0x8000)
+ {
+ const unsigned st_mode = ui.Attrib >> 16;
+ /* note: executable ".so" can be without execute permission,
+ and symbolic link to such ".so" file is possible */
+ // st_mode = 00111; // for debug
+ /* in Linux we expect such permissions:
+ 0755 : for most executables
+ 0644 : for some ".so" files
+ 0777 : in WSL for all files.
+ We can try to exclude some such 0777 cases from analysis,
+ if there is non-executable extension.
+ */
+
+ if ((st_mode & (
+ MY_LIN_S_IXUSR |
+ MY_LIN_S_IXGRP |
+ MY_LIN_S_IXOTH)) != 0
+ && MY_LIN_S_ISREG(st_mode)
+ && (ui.Size >= (1u << 11)))
+ {
+ #ifndef _WIN32
+ probablyIsSameIsa = true;
+ #endif
+ needReadFile = true;
+ }
+ }
+
+ if (!needReadFile)
+ {
+ if (!ext)
+ needReadFile = ParseNoExt;
+ else
+ {
+ bool isUnixExt = false;
+ if (ParseExeUnix)
+ isUnixExt = IsExt_ExeUnix_NumericAllowed(ui.Name);
+ if (isUnixExt)
+ {
+ needReadFile = true;
+ #ifndef _WIN32
+ probablyIsSameIsa = true;
+ #endif
+ }
+ else if (IsExt_Exe(ext))
+ {
+ needReadFile = ParseExe;
+ #ifdef _WIN32
+ probablyIsSameIsa = true;
+ #endif
+ }
+ else if (StringsAreEqualNoCase_Ascii(ext, "wav"))
+ {
+ if (!needReadFile)
+ needReadFile = ParseWav;
+ }
+ }
+ }
+ }
+
+ if (needReadFile)
+ {
+ BoolInt parseRes = false;
+ if (Callback)
+ {
+ if (Buffer.Size() != kAnalysisBufSize)
+ Buffer.Alloc(kAnalysisBufSize);
+ CMyComPtr<ISequentialInStream> stream;
+ HRESULT result = Callback->GetStream2(index, &stream, NUpdateNotifyOp::kAnalyze);
+ if (result == S_OK && stream)
+ {
+ /*
+ if (Need_ATime)
+ {
+ // access time could be changed in analysis pass
+ CMyComPtr<IStreamGetProps> getProps;
+ stream.QueryInterface(IID_IStreamGetProps, (void **)&getProps);
+ if (getProps)
+ if (getProps->GetProps(NULL, NULL, &ATime, NULL, NULL) == S_OK)
+ ATime_Defined = true;
+ }
+ */
+ size_t size = kAnalysisBufSize;
+ result = ReadStream(stream, Buffer, &size);
+ stream.Release();
+ // RINOK(Callback->SetOperationResult2(index, NUpdate::NOperationResult::kOK));
+ if (result == S_OK)
+ {
+ parseRes = ParseFile(Buffer, size, &filterModeTemp);
+ }
+ }
+ } // Callback
+ else if (probablyIsSameIsa)
+ {
+ #ifdef MY_CPU_X86_OR_AMD64
+ filterModeTemp.Id = k_X86;
+ #endif
+ #ifdef MY_CPU_ARM64
+ filterModeTemp.Id = k_ARM64;
+ #endif
+ parseRes = true;
+ }
+
+ if (parseRes
+ && filterModeTemp.Id != k_Delta
+ && filterModeTemp.Delta == 0)
+ {
+ /* ParseFile() sets (filterModeTemp.Delta == 0) for all
+ methods except of k_Delta. */
+ // it's not k_Delta
+ // So we call SetDelta() to set Delta
+ filterModeTemp.SetDelta();
+ if (filterModeTemp.Delta > 1)
+ {
+ /* If file Size is not aligned, then branch filter
+ will not work for next file in solid block.
+ Maybe we should allow filter for non-aligned-size file in non-solid archives ?
+ */
+ if (ui.Size % filterModeTemp.Delta != 0)
+ parseRes = false;
+ // windows exe files are not aligned for 4 KiB.
+ /*
+ else if (filterModeTemp.Id == k_ARM64 && filterModeTemp.Offset != 0)
+ {
+ if (ui.Size % (1 << 12) != 0)
+ {
+ // If Size is not aligned for 4 KiB, then Offset will not work for next file in solid block.
+ // so we place such file in group with (Offset==0).
+ filterModeTemp.Offset = 0;
+ }
+ }
+ */
+ }
+ }
+ if (!parseRes)
+ filterModeTemp.ClearFilterMode();
+ }
+ }
+
+ filterMode = filterModeTemp;
+ return S_OK;
+}
+
+static inline void GetMethodFull(UInt64 methodID, UInt32 numStreams, CMethodFull &m)
+{
+ m.Id = methodID;
+ m.NumStreams = numStreams;
+}
+
+static HRESULT AddBondForFilter(CCompressionMethodMode &mode)
+{
+ for (unsigned c = 1; c < mode.Methods.Size(); c++)
+ {
+ if (!mode.IsThereBond_to_Coder(c))
+ {
+ CBond2 bond;
+ bond.OutCoder = 0;
+ bond.OutStream = 0;
+ bond.InCoder = c;
+ mode.Bonds.Add(bond);
+ return S_OK;
+ }
+ }
+ return E_INVALIDARG;
+}
+
+static HRESULT AddFilterBond(CCompressionMethodMode &mode)
+{
+ if (!mode.Bonds.IsEmpty())
+ return AddBondForFilter(mode);
+ return S_OK;
+}
+
+static HRESULT AddBcj2Methods(CCompressionMethodMode &mode)
+{
+ // mode.Methods[0] must be k_BCJ2 method !
+
+ CMethodFull m;
+ GetMethodFull(k_LZMA, 1, m);
+
+ m.AddProp32(NCoderPropID::kDictionarySize, 1 << 20);
+ m.AddProp32(NCoderPropID::kNumFastBytes, 128);
+ m.AddProp32(NCoderPropID::kNumThreads, 1);
+ m.AddProp32(NCoderPropID::kLitPosBits, 2);
+ m.AddProp32(NCoderPropID::kLitContextBits, 0);
+ // m.AddProp_Ascii(NCoderPropID::kMatchFinder, "BT2");
+
+ unsigned methodIndex = mode.Methods.Size();
+
+ if (mode.Bonds.IsEmpty())
+ {
+ for (unsigned i = 1; i + 1 < mode.Methods.Size(); i++)
+ {
+ CBond2 bond;
+ bond.OutCoder = i;
+ bond.OutStream = 0;
+ bond.InCoder = i + 1;
+ mode.Bonds.Add(bond);
+ }
+ }
+
+ mode.Methods.Add(m);
+ mode.Methods.Add(m);
+
+ RINOK(AddBondForFilter(mode))
+ CBond2 bond;
+ bond.OutCoder = 0;
+ bond.InCoder = methodIndex; bond.OutStream = 1; mode.Bonds.Add(bond);
+ bond.InCoder = methodIndex + 1; bond.OutStream = 2; mode.Bonds.Add(bond);
+ return S_OK;
+}
+
+static HRESULT MakeExeMethod(CCompressionMethodMode &mode,
+ const CFilterMode &filterMode, /* bool addFilter, */ bool bcj2Filter)
+{
+ if (mode.Filter_was_Inserted)
+ {
+ const CMethodFull &m = mode.Methods[0];
+ const CMethodId id = m.Id;
+ if (id == k_BCJ2)
+ return AddBcj2Methods(mode);
+ if (!m.IsSimpleCoder())
+ return E_NOTIMPL;
+ // if (Bonds.IsEmpty()) we can create bonds later
+ return AddFilterBond(mode);
+ }
+
+ if (filterMode.Id == 0)
+ return S_OK;
+
+ CMethodFull &m = mode.Methods.InsertNew(0);
+
+ {
+ FOR_VECTOR (k, mode.Bonds)
+ {
+ CBond2 &bond = mode.Bonds[k];
+ bond.InCoder++;
+ bond.OutCoder++;
+ }
+ }
+
+ HRESULT res;
+
+ if (bcj2Filter && Is86Filter(filterMode.Id))
+ {
+ GetMethodFull(k_BCJ2, 4, m);
+ res = AddBcj2Methods(mode);
+ }
+ else
+ {
+ GetMethodFull(filterMode.Id, 1, m);
+ if (filterMode.Id == k_Delta)
+ m.AddProp32(NCoderPropID::kDefaultProp, filterMode.Delta);
+ else if (filterMode.Id == k_ARM64)
+ {
+ // if (filterMode.Offset != 0)
+ m.AddProp32(
+ NCoderPropID::kDefaultProp,
+ // NCoderPropID::kBranchOffset,
+ filterMode.Offset);
+ }
+ res = AddFilterBond(mode);
+
+ int alignBits = -1;
+ {
+ const UInt32 delta = filterMode.Delta;
+ if (delta == 0 || delta > 16)
+ {
+ // if (delta == 0) alignBits = GetAlignForFilterMethod(filterMode.Id);
+ }
+ else if ((delta & ((1 << 4) - 1)) == 0) alignBits = 4;
+ else if ((delta & ((1 << 3) - 1)) == 0) alignBits = 3;
+ else if ((delta & ((1 << 2) - 1)) == 0) alignBits = 2;
+ else if ((delta & ((1 << 1) - 1)) == 0) alignBits = 1;
+ // else alignBits = 0;
+ /* alignBits=0 is default mode for lzma/lzma2.
+ So we don't set alignBits=0 here. */
+ }
+ if (res == S_OK && alignBits > 0)
+ {
+ unsigned nextCoder = 1;
+ if (!mode.Bonds.IsEmpty())
+ {
+ nextCoder = mode.Bonds.Back().InCoder;
+ }
+ if (nextCoder < mode.Methods.Size())
+ {
+ CMethodFull &nextMethod = mode.Methods[nextCoder];
+ if (nextMethod.Id == k_LZMA || nextMethod.Id == k_LZMA2)
+ {
+ if (!nextMethod.Are_Lzma_Model_Props_Defined())
+ {
+ if (alignBits != 0)
+ {
+ if (alignBits > 2 || filterMode.Id == k_Delta)
+ nextMethod.AddProp32(NCoderPropID::kPosStateBits, (unsigned)alignBits);
+ unsigned lc = 0;
+ if (alignBits < 3)
+ lc = (unsigned)(3 - alignBits);
+ nextMethod.AddProp32(NCoderPropID::kLitContextBits, lc);
+ nextMethod.AddProp32(NCoderPropID::kLitPosBits, (unsigned)alignBits);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return res;
+}
+
+
+static void UpdateItem_To_FileItem2(const CUpdateItem &ui, CFileItem2 &file2)
+{
+ file2.Attrib = ui.Attrib; file2.AttribDefined = ui.AttribDefined;
+ file2.CTime = ui.CTime; file2.CTimeDefined = ui.CTimeDefined;
+ file2.ATime = ui.ATime; file2.ATimeDefined = ui.ATimeDefined;
+ file2.MTime = ui.MTime; file2.MTimeDefined = ui.MTimeDefined;
+ file2.IsAnti = ui.IsAnti;
+ // file2.IsAux = false;
+ file2.StartPosDefined = false;
+ // file2.StartPos = 0;
+}
+
+
+static void UpdateItem_To_FileItem(const CUpdateItem &ui,
+ CFileItem &file, CFileItem2 &file2)
+{
+ UpdateItem_To_FileItem2(ui, file2);
+
+ file.Size = ui.Size;
+ file.IsDir = ui.IsDir;
+ file.HasStream = ui.HasStream();
+ // file.IsAltStream = ui.IsAltStream;
+}
+
+
+
+Z7_CLASS_IMP_COM_2(
+ CRepackInStreamWithSizes
+ , ISequentialInStream
+ , ICompressGetSubStreamSize
+)
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt64 _size;
+ const CBoolVector *_extractStatuses;
+ UInt32 _startIndex;
+public:
+ const CDbEx *_db;
+
+ void Init(ISequentialInStream *stream, UInt32 startIndex, const CBoolVector *extractStatuses)
+ {
+ _startIndex = startIndex;
+ _extractStatuses = extractStatuses;
+ _size = 0;
+ _stream = stream;
+ }
+ UInt64 GetSize() const { return _size; }
+};
+
+Z7_COM7F_IMF(CRepackInStreamWithSizes::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize;
+ const HRESULT result = _stream->Read(data, size, &realProcessedSize);
+ _size += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return result;
+}
+
+Z7_COM7F_IMF(CRepackInStreamWithSizes::GetSubStreamSize(UInt64 subStream, UInt64 *value))
+{
+ *value = 0;
+ if (subStream >= _extractStatuses->Size())
+ return S_FALSE; // E_FAIL;
+ const unsigned index = (unsigned)subStream;
+ if ((*_extractStatuses)[index])
+ {
+ const CFileItem &fi = _db->Files[_startIndex + index];
+ if (fi.HasStream)
+ *value = fi.Size;
+ }
+ return S_OK;
+}
+
+
+class CRepackStreamBase
+{
+protected:
+ bool _needWrite;
+ bool _fileIsOpen;
+ bool _calcCrc;
+ UInt32 _crc;
+ UInt64 _rem;
+
+ const CBoolVector *_extractStatuses;
+ UInt32 _startIndex;
+ unsigned _currentIndex;
+
+ HRESULT OpenFile();
+ HRESULT CloseFile();
+ HRESULT ProcessEmptyFiles();
+
+public:
+ const CDbEx *_db;
+ CMyComPtr<IArchiveUpdateCallbackFile> _opCallback;
+ CMyComPtr<IArchiveExtractCallbackMessage2> _extractCallback;
+
+ HRESULT Init(UInt32 startIndex, const CBoolVector *extractStatuses);
+ HRESULT CheckFinishedState() const { return (_currentIndex == _extractStatuses->Size()) ? S_OK: E_FAIL; }
+};
+
+HRESULT CRepackStreamBase::Init(UInt32 startIndex, const CBoolVector *extractStatuses)
+{
+ _startIndex = startIndex;
+ _extractStatuses = extractStatuses;
+
+ _currentIndex = 0;
+ _fileIsOpen = false;
+
+ return ProcessEmptyFiles();
+}
+
+HRESULT CRepackStreamBase::OpenFile()
+{
+ UInt32 arcIndex = _startIndex + _currentIndex;
+ const CFileItem &fi = _db->Files[arcIndex];
+
+ _needWrite = (*_extractStatuses)[_currentIndex];
+ if (_opCallback)
+ {
+ RINOK(_opCallback->ReportOperation(
+ NEventIndexType::kInArcIndex, arcIndex,
+ _needWrite ?
+ NUpdateNotifyOp::kRepack :
+ NUpdateNotifyOp::kSkip))
+ }
+
+ _crc = CRC_INIT_VAL;
+ _calcCrc = (fi.CrcDefined && !fi.IsDir);
+
+ _fileIsOpen = true;
+ _rem = fi.Size;
+ return S_OK;
+}
+
+const HRESULT k_My_HRESULT_CRC_ERROR = 0x20000002;
+
+HRESULT CRepackStreamBase::CloseFile()
+{
+ UInt32 arcIndex = _startIndex + _currentIndex;
+ const CFileItem &fi = _db->Files[arcIndex];
+ _fileIsOpen = false;
+ _currentIndex++;
+ if (!_calcCrc || fi.Crc == CRC_GET_DIGEST(_crc))
+ return S_OK;
+
+ if (_extractCallback)
+ {
+ RINOK(_extractCallback->ReportExtractResult(
+ NEventIndexType::kInArcIndex, arcIndex,
+ NExtract::NOperationResult::kCRCError))
+ }
+ // return S_FALSE;
+ return k_My_HRESULT_CRC_ERROR;
+}
+
+HRESULT CRepackStreamBase::ProcessEmptyFiles()
+{
+ while (_currentIndex < _extractStatuses->Size() && _db->Files[_startIndex + _currentIndex].Size == 0)
+ {
+ RINOK(OpenFile())
+ RINOK(CloseFile())
+ }
+ return S_OK;
+}
+
+
+
+#ifndef Z7_ST
+
+class CFolderOutStream2 Z7_final:
+ public CRepackStreamBase,
+ public ISequentialOutStream,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+public:
+ CMyComPtr<ISequentialOutStream> _stream;
+};
+
+Z7_COM7F_IMF(CFolderOutStream2::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ if (_fileIsOpen)
+ {
+ UInt32 cur = (size < _rem ? size : (UInt32)_rem);
+ HRESULT result = S_OK;
+ if (_needWrite)
+ result = _stream->Write(data, cur, &cur);
+ if (_calcCrc)
+ _crc = CrcUpdate(_crc, data, cur);
+ if (processedSize)
+ *processedSize += cur;
+ data = (const Byte *)data + cur;
+ size -= cur;
+ _rem -= cur;
+ if (_rem == 0)
+ {
+ RINOK(CloseFile())
+ RINOK(ProcessEmptyFiles())
+ }
+ RINOK(result)
+ if (cur == 0)
+ break;
+ continue;
+ }
+
+ RINOK(ProcessEmptyFiles())
+ if (_currentIndex == _extractStatuses->Size())
+ {
+ // we don't support write cut here
+ return E_FAIL;
+ }
+ RINOK(OpenFile())
+ }
+
+ return S_OK;
+}
+
+#endif
+
+
+
+static const UInt32 kTempBufSize = 1 << 16;
+
+class CFolderInStream2 Z7_final:
+ public CRepackStreamBase,
+ public ISequentialInStream,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ Byte *_buf;
+public:
+ CMyComPtr<ISequentialInStream> _inStream;
+ HRESULT Result;
+
+ CFolderInStream2():
+ Result(S_OK)
+ {
+ _buf = new Byte[kTempBufSize];
+ }
+
+ ~CFolderInStream2()
+ {
+ delete []_buf;
+ }
+
+ void Init() { Result = S_OK; }
+};
+
+Z7_COM7F_IMF(CFolderInStream2::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ if (_fileIsOpen)
+ {
+ UInt32 cur = (size < _rem ? size : (UInt32)_rem);
+
+ void *buf;
+ if (_needWrite)
+ buf = data;
+ else
+ {
+ buf = _buf;
+ if (cur > kTempBufSize)
+ cur = kTempBufSize;
+ }
+
+ const HRESULT result = _inStream->Read(buf, cur, &cur);
+ _crc = CrcUpdate(_crc, buf, cur);
+ _rem -= cur;
+
+ if (_needWrite)
+ {
+ data = (Byte *)data + cur;
+ size -= cur;
+ if (processedSize)
+ *processedSize += cur;
+ }
+
+ if (result != S_OK)
+ Result = result;
+
+ if (_rem == 0)
+ {
+ RINOK(CloseFile())
+ RINOK(ProcessEmptyFiles())
+ }
+
+ RINOK(result)
+
+ if (cur == 0)
+ return E_FAIL;
+
+ continue;
+ }
+
+ RINOK(ProcessEmptyFiles())
+ if (_currentIndex == _extractStatuses->Size())
+ {
+ return S_OK;
+ }
+ RINOK(OpenFile())
+ }
+
+ return S_OK;
+}
+
+
+class CThreadDecoder Z7_final
+ #ifndef Z7_ST
+ : public CVirtThread
+ #endif
+{
+public:
+ CDecoder Decoder;
+
+ CThreadDecoder(bool multiThreadMixer):
+ Decoder(multiThreadMixer)
+ {
+ #ifndef Z7_ST
+ if (multiThreadMixer)
+ {
+ MtMode = false;
+ NumThreads = 1;
+ FosSpec = new CFolderOutStream2;
+ Fos = FosSpec;
+ Result = E_FAIL;
+ }
+ #endif
+ // UnpackSize = 0;
+ // send_UnpackSize = false;
+ }
+
+ #ifndef Z7_ST
+
+ bool dataAfterEnd_Error;
+ HRESULT Result;
+ CMyComPtr<IInStream> InStream;
+
+ CFolderOutStream2 *FosSpec;
+ CMyComPtr<ISequentialOutStream> Fos;
+
+ UInt64 StartPos;
+ const CFolders *Folders;
+ unsigned FolderIndex;
+
+ // bool send_UnpackSize;
+ // UInt64 UnpackSize;
+
+ #ifndef Z7_NO_CRYPTO
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ #endif
+
+ DECL_EXTERNAL_CODECS_LOC_VARS_DECL
+
+ #ifndef Z7_ST
+ bool MtMode;
+ UInt32 NumThreads;
+ #endif
+
+
+ ~CThreadDecoder() Z7_DESTRUCTOR_override
+ {
+ /* WaitThreadFinish() will be called in ~CVirtThread().
+ But we need WaitThreadFinish() call before
+ destructors of this class members.
+ */
+ CVirtThread::WaitThreadFinish();
+ }
+private:
+ virtual void Execute() Z7_override;
+
+ #endif
+};
+
+#ifndef Z7_ST
+
+void CThreadDecoder::Execute()
+{
+ try
+ {
+ #ifndef Z7_NO_CRYPTO
+ bool isEncrypted = false;
+ bool passwordIsDefined = false;
+ UString password;
+ #endif
+
+ dataAfterEnd_Error = false;
+
+ Result = Decoder.Decode(
+ EXTERNAL_CODECS_LOC_VARS
+ InStream,
+ StartPos,
+ *Folders, FolderIndex,
+
+ // send_UnpackSize ? &UnpackSize : NULL,
+ NULL, // unpackSize : FULL unpack
+
+ Fos,
+ NULL, // compressProgress
+
+ NULL // *inStreamMainRes
+ , dataAfterEnd_Error
+
+ Z7_7Z_DECODER_CRYPRO_VARS
+ #ifndef Z7_ST
+ , MtMode, NumThreads,
+ 0 // MemUsage
+ #endif
+
+ );
+ }
+ catch(...)
+ {
+ Result = E_FAIL;
+ }
+
+ /*
+ if (Result == S_OK)
+ Result = FosSpec->CheckFinishedState();
+ */
+ FosSpec->_stream.Release();
+}
+
+#endif
+
+#ifndef Z7_NO_CRYPTO
+
+Z7_CLASS_IMP_NOQIB_1(
+ CCryptoGetTextPassword
+ , ICryptoGetTextPassword
+)
+public:
+ UString Password;
+};
+
+Z7_COM7F_IMF(CCryptoGetTextPassword::CryptoGetTextPassword(BSTR *password))
+{
+ return StringToBstr(Password, password);
+}
+
+#endif
+
+
+static void GetFile(const CDatabase &inDb, unsigned index, CFileItem &file, CFileItem2 &file2)
+{
+ file = inDb.Files[index];
+ file2.CTimeDefined = inDb.CTime.GetItem(index, file2.CTime);
+ file2.ATimeDefined = inDb.ATime.GetItem(index, file2.ATime);
+ file2.MTimeDefined = inDb.MTime.GetItem(index, file2.MTime);
+ file2.StartPosDefined = inDb.StartPos.GetItem(index, file2.StartPos);
+ file2.AttribDefined = inDb.Attrib.GetItem(index, file2.Attrib);
+ file2.IsAnti = inDb.IsItemAnti(index);
+ // file2.IsAux = inDb.IsItemAux(index);
+}
+
+HRESULT Update(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ IInStream *inStream,
+ const CDbEx *db,
+ CObjectVector<CUpdateItem> &updateItems,
+ // const CObjectVector<CTreeFolder> &treeFolders,
+ // const CUniqBlocks &secureBlocks,
+ ISequentialOutStream *seqOutStream,
+ IArchiveUpdateCallback *updateCallback,
+ const CUpdateOptions &options)
+{
+ UInt64 numSolidFiles = options.NumSolidFiles;
+ if (numSolidFiles == 0)
+ numSolidFiles = 1;
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveUpdateCallbackFile,
+ opCallback, updateCallback)
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveExtractCallbackMessage2,
+ extractCallback, updateCallback)
+
+ /*
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveUpdateCallbackArcProp,
+ reportArcProp, updateCallback)
+ */
+
+ // size_t totalSecureDataSize = (size_t)secureBlocks.GetTotalSizeInBytes();
+
+ CMyComPtr<IStreamSetRestriction> v_StreamSetRestriction;
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IOutStream,
+ outStream, seqOutStream)
+ if (!outStream)
+ return E_NOTIMPL;
+ const UInt64 sfxBlockSize = (db && !options.RemoveSfxBlock) ?
+ db->ArcInfo.StartPosition: 0;
+ seqOutStream->QueryInterface(IID_IStreamSetRestriction, (void **)&v_StreamSetRestriction);
+ if (v_StreamSetRestriction)
+ {
+ UInt64 offset = 0;
+ RINOK(outStream->Seek(0, STREAM_SEEK_CUR, &offset))
+ RINOK(v_StreamSetRestriction->SetRestriction(
+ outStream ? offset + sfxBlockSize : 0,
+ outStream ? offset + sfxBlockSize + k_StartHeadersRewriteSize : 0))
+ }
+ outStream.Release();
+ if (sfxBlockSize != 0)
+ {
+ RINOK(WriteRange(inStream, seqOutStream, 0, sfxBlockSize, NULL))
+ }
+ }
+
+ CIntArr fileIndexToUpdateIndexMap;
+ UInt64 complexity = 0;
+ UInt64 inSizeForReduce2 = 0;
+
+ #ifndef Z7_NO_CRYPTO
+ bool needEncryptedRepack = false;
+ #endif
+
+ CRecordVector<CFilterMode2> filters;
+ CObjectVector<CSolidGroup> groups;
+
+ #ifndef Z7_ST
+ bool thereAreRepacks = false;
+ #endif
+
+ bool useFilters = options.UseFilters;
+ if (useFilters)
+ {
+ const CCompressionMethodMode &method = *options.Method;
+
+ FOR_VECTOR (i, method.Methods)
+ {
+ /* IsFilterMethod() knows only built-in codecs
+ FIXME: we should check IsFilter status for external filters too */
+ if (IsFilterMethod(method.Methods[i].Id))
+ {
+ useFilters = false;
+ break;
+ }
+ }
+ }
+
+ if (db)
+ {
+ fileIndexToUpdateIndexMap.Alloc(db->Files.Size());
+ unsigned i;
+
+ for (i = 0; i < db->Files.Size(); i++)
+ fileIndexToUpdateIndexMap[i] = -1;
+
+ for (i = 0; i < updateItems.Size(); i++)
+ {
+ int index = updateItems[i].IndexInArchive;
+ if (index != -1)
+ fileIndexToUpdateIndexMap[(unsigned)index] = (int)i;
+ }
+
+ for (i = 0; i < db->NumFolders; i++)
+ {
+ CNum indexInFolder = 0;
+ CNum numCopyItems = 0;
+ const CNum numUnpackStreams = db->NumUnpackStreamsVector[i];
+ UInt64 repackSize = 0;
+
+ for (CNum fi = db->FolderStartFileIndex[i]; indexInFolder < numUnpackStreams; fi++)
+ {
+ if (fi >= db->Files.Size())
+ return E_FAIL;
+
+ const CFileItem &file = db->Files[fi];
+ if (file.HasStream)
+ {
+ indexInFolder++;
+ const int updateIndex = fileIndexToUpdateIndexMap[fi];
+ if (updateIndex >= 0 && !updateItems[(unsigned)updateIndex].NewData)
+ {
+ numCopyItems++;
+ repackSize += file.Size;
+ }
+ }
+ }
+
+ if (numCopyItems == 0)
+ continue;
+
+ CFolderRepack rep;
+ rep.FolderIndex = i;
+ rep.NumCopyFiles = numCopyItems;
+ CFolderEx f;
+ db->ParseFolderEx(i, f);
+
+ #ifndef Z7_NO_CRYPTO
+ const bool isEncrypted = f.IsEncrypted();
+ #endif
+ const bool needCopy = (numCopyItems == numUnpackStreams);
+ const bool extractFilter = (useFilters || needCopy);
+
+ const unsigned groupIndex = Get_FilterGroup_for_Folder(filters, f, extractFilter);
+
+ while (groupIndex >= groups.Size())
+ groups.AddNew();
+
+ groups[groupIndex].folderRefs.Add(rep);
+
+ if (needCopy)
+ complexity += db->GetFolderFullPackSize(i);
+ else
+ {
+ #ifndef Z7_ST
+ thereAreRepacks = true;
+ #endif
+ complexity += repackSize;
+ if (inSizeForReduce2 < repackSize)
+ inSizeForReduce2 = repackSize;
+ #ifndef Z7_NO_CRYPTO
+ if (isEncrypted)
+ needEncryptedRepack = true;
+ #endif
+ }
+ }
+ }
+
+ UInt64 inSizeForReduce = 0;
+ {
+ bool isSolid = (numSolidFiles > 1 && options.NumSolidBytes != 0);
+ FOR_VECTOR (i, updateItems)
+ {
+ const CUpdateItem &ui = updateItems[i];
+ if (ui.NewData)
+ {
+ complexity += ui.Size;
+ if (isSolid)
+ inSizeForReduce += ui.Size;
+ else if (inSizeForReduce < ui.Size)
+ inSizeForReduce = ui.Size;
+ }
+ }
+ }
+
+ if (inSizeForReduce < inSizeForReduce2)
+ inSizeForReduce = inSizeForReduce2;
+
+ RINOK(updateCallback->SetTotal(complexity))
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ #ifndef Z7_ST
+
+ CStreamBinder sb;
+ /*
+ if (options.MultiThreadMixer)
+ {
+ RINOK(sb.CreateEvents());
+ }
+ */
+
+ #endif
+
+ CThreadDecoder threadDecoder(options.MultiThreadMixer);
+
+ #ifndef Z7_ST
+ if (options.MultiThreadMixer && thereAreRepacks)
+ {
+ #ifdef Z7_EXTERNAL_CODECS
+ threadDecoder._externalCodecs = _externalCodecs;
+ #endif
+ const WRes wres = threadDecoder.Create();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ #endif
+
+ {
+ CAnalysis analysis;
+ // analysis.Need_ATime = options.Need_ATime;
+ int analysisLevel = options.AnalysisLevel;
+ // (analysisLevel < 0) means default level (5)
+ if (analysisLevel < 0)
+ analysisLevel = 5;
+ if (analysisLevel != 0)
+ {
+ analysis.Callback = opCallback;
+ analysis.ParseWav = true;
+ if (analysisLevel >= 5)
+ {
+ analysis.ParseExe = true;
+ analysis.ParseExeUnix = true;
+ // analysis.ParseNoExt = true;
+ if (analysisLevel >= 7)
+ {
+ analysis.ParseNoExt = true;
+ if (analysisLevel >= 9)
+ analysis.ParseAll = true;
+ }
+ }
+ }
+
+ // ---------- Split files to groups ----------
+
+ const CCompressionMethodMode &method = *options.Method;
+
+ FOR_VECTOR (i, updateItems)
+ {
+ const CUpdateItem &ui = updateItems[i];
+ if (!ui.NewData || !ui.HasStream())
+ continue;
+
+ CFilterMode2 fm;
+ if (useFilters)
+ {
+ // analysis.ATime_Defined = false;
+ RINOK(analysis.GetFilterGroup(i, ui, fm))
+ /*
+ if (analysis.ATime_Defined)
+ {
+ ui.ATime = FILETIME_To_UInt64(analysis.ATime);
+ ui.ATime_WasReadByAnalysis = true;
+ }
+ */
+ }
+ fm.Encrypted = method.PasswordIsDefined;
+
+ const unsigned groupIndex = GetGroup(filters, fm);
+ while (groupIndex >= groups.Size())
+ groups.AddNew();
+ groups[groupIndex].Indices.Add(i);
+ }
+ }
+
+
+ #ifndef Z7_NO_CRYPTO
+
+ CCryptoGetTextPassword *getPasswordSpec = NULL;
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ if (needEncryptedRepack)
+ {
+ getPasswordSpec = new CCryptoGetTextPassword;
+ getTextPassword = getPasswordSpec;
+
+ #ifndef Z7_ST
+ threadDecoder.getTextPassword = getPasswordSpec;
+ #endif
+
+ if (options.Method->PasswordIsDefined)
+ getPasswordSpec->Password = options.Method->Password;
+ else
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICryptoGetTextPassword,
+ getDecoderPassword, updateCallback)
+ if (!getDecoderPassword)
+ return E_NOTIMPL;
+ CMyComBSTR password;
+ RINOK(getDecoderPassword->CryptoGetTextPassword(&password))
+ if (password)
+ getPasswordSpec->Password = password;
+ }
+ }
+
+ #endif
+
+ // ---------- Compress ----------
+
+ COutArchive archive;
+ CArchiveDatabaseOut newDatabase;
+
+ RINOK(archive.Create_and_WriteStartPrefix(seqOutStream))
+
+ /*
+ CIntVector treeFolderToArcIndex;
+ treeFolderToArcIndex.Reserve(treeFolders.Size());
+ for (i = 0; i < treeFolders.Size(); i++)
+ treeFolderToArcIndex.Add(-1);
+ // ---------- Write Tree (only AUX dirs) ----------
+ for (i = 1; i < treeFolders.Size(); i++)
+ {
+ const CTreeFolder &treeFolder = treeFolders[i];
+ CFileItem file;
+ CFileItem2 file2;
+ file2.Init();
+ int secureID = 0;
+ if (treeFolder.UpdateItemIndex < 0)
+ {
+ // we can store virtual dir item wuthout attrib, but we want all items have attrib.
+ file.SetAttrib(FILE_ATTRIBUTE_DIRECTORY);
+ file2.IsAux = true;
+ }
+ else
+ {
+ const CUpdateItem &ui = updateItems[treeFolder.UpdateItemIndex];
+ // if item is not dir, then it's parent for alt streams.
+ // we will write such items later
+ if (!ui.IsDir)
+ continue;
+ secureID = ui.SecureIndex;
+ if (ui.NewProps)
+ UpdateItem_To_FileItem(ui, file, file2);
+ else
+ GetFile(*db, ui.IndexInArchive, file, file2);
+ }
+ file.Size = 0;
+ file.HasStream = false;
+ file.IsDir = true;
+ file.Parent = treeFolder.Parent;
+
+ treeFolderToArcIndex[i] = newDatabase.Files.Size();
+ newDatabase.AddFile(file, file2, treeFolder.Name);
+
+ if (totalSecureDataSize != 0)
+ newDatabase.SecureIDs.Add(secureID);
+ }
+ */
+
+ {
+ /* ---------- Write non-AUX dirs and Empty files ---------- */
+ CUIntVector emptyRefs;
+
+ unsigned i;
+
+ for (i = 0; i < updateItems.Size(); i++)
+ {
+ const CUpdateItem &ui = updateItems[i];
+ if (ui.NewData)
+ {
+ if (ui.HasStream())
+ continue;
+ }
+ else if (ui.IndexInArchive != -1 && db->Files[(unsigned)ui.IndexInArchive].HasStream)
+ continue;
+ /*
+ if (ui.TreeFolderIndex >= 0)
+ continue;
+ */
+ emptyRefs.Add(i);
+ }
+
+ emptyRefs.Sort(CompareEmptyItems, (void *)&updateItems);
+
+ for (i = 0; i < emptyRefs.Size(); i++)
+ {
+ const CUpdateItem &ui = updateItems[emptyRefs[i]];
+ CFileItem file;
+ CFileItem2 file2;
+ UString name;
+ if (ui.NewProps)
+ {
+ UpdateItem_To_FileItem(ui, file, file2);
+ file.CrcDefined = false;
+ name = ui.Name;
+ }
+ else
+ {
+ GetFile(*db, (unsigned)ui.IndexInArchive, file, file2);
+ db->GetPath((unsigned)ui.IndexInArchive, name);
+ }
+
+ /*
+ if (totalSecureDataSize != 0)
+ newDatabase.SecureIDs.Add(ui.SecureIndex);
+ file.Parent = ui.ParentFolderIndex;
+ */
+ newDatabase.AddFile(file, file2, name);
+ }
+ }
+
+ lps->ProgressOffset = 0;
+
+ {
+ // ---------- Sort Filters ----------
+ FOR_VECTOR (i, filters)
+ {
+ filters[i].GroupIndex = i;
+ }
+ filters.Sort2();
+ }
+
+ for (unsigned groupIndex = 0; groupIndex < filters.Size(); groupIndex++)
+ {
+ const CFilterMode2 &filterMode = filters[groupIndex];
+
+ CCompressionMethodMode method = *options.Method;
+ {
+ const HRESULT res = MakeExeMethod(method, filterMode,
+ #ifdef Z7_ST
+ false
+ #else
+ options.MaxFilter && options.MultiThreadMixer
+ #endif
+ );
+
+ RINOK(res)
+ }
+
+ if (filterMode.Encrypted)
+ {
+ if (!method.PasswordIsDefined)
+ {
+ #ifndef Z7_NO_CRYPTO
+ if (getPasswordSpec)
+ method.Password = getPasswordSpec->Password;
+ #endif
+ method.PasswordIsDefined = true;
+ }
+ }
+ else
+ {
+ method.PasswordIsDefined = false;
+ method.Password.Empty();
+ }
+
+ CEncoder encoder(method);
+
+ // ---------- Repack and copy old solid blocks ----------
+
+ const CSolidGroup &group = groups[filterMode.GroupIndex];
+
+ FOR_VECTOR (folderRefIndex, group.folderRefs)
+ {
+ const CFolderRepack &rep = group.folderRefs[folderRefIndex];
+
+ const unsigned folderIndex = rep.FolderIndex;
+
+ const CNum numUnpackStreams = db->NumUnpackStreamsVector[folderIndex];
+
+ if (rep.NumCopyFiles == numUnpackStreams)
+ {
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex,
+ NUpdateNotifyOp::kReplicate))
+
+ // ---------- Copy old solid block ----------
+ {
+ CNum indexInFolder = 0;
+ for (CNum fi = db->FolderStartFileIndex[folderIndex]; indexInFolder < numUnpackStreams; fi++)
+ {
+ if (db->Files[fi].HasStream)
+ {
+ indexInFolder++;
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kInArcIndex, (UInt32)fi,
+ NUpdateNotifyOp::kReplicate))
+ }
+ }
+ }
+ }
+
+ const UInt64 packSize = db->GetFolderFullPackSize(folderIndex);
+ RINOK(WriteRange(inStream, archive.SeqStream,
+ db->GetFolderStreamPos(folderIndex, 0), packSize, progress))
+ lps->ProgressOffset += packSize;
+
+ const unsigned folderIndex_New = newDatabase.Folders.Size();
+ CFolder &folder = newDatabase.Folders.AddNew();
+ // v23.01: we copy FolderCrc, if FolderCrc was used
+ if (db->FolderCRCs.ValidAndDefined(folderIndex))
+ newDatabase.FolderUnpackCRCs.SetItem(folderIndex_New,
+ true, db->FolderCRCs.Vals[folderIndex]);
+
+ db->ParseFolderInfo(folderIndex, folder);
+ const CNum startIndex = db->FoStartPackStreamIndex[folderIndex];
+ FOR_VECTOR (j, folder.PackStreams)
+ {
+ newDatabase.PackSizes.Add(db->GetStreamPackSize(startIndex + j));
+ // newDatabase.PackCRCsDefined.Add(db.PackCRCsDefined[startIndex + j]);
+ // newDatabase.PackCRCs.Add(db.PackCRCs[startIndex + j]);
+ }
+
+ size_t indexStart = db->FoToCoderUnpackSizes[folderIndex];
+ const size_t indexEnd = db->FoToCoderUnpackSizes[folderIndex + 1];
+ for (; indexStart < indexEnd; indexStart++)
+ newDatabase.CoderUnpackSizes.Add(db->CoderUnpackSizes[indexStart]);
+ }
+ else
+ {
+ // ---------- Repack old solid block ----------
+
+ CBoolVector extractStatuses;
+
+ CNum indexInFolder = 0;
+
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex,
+ NUpdateNotifyOp::kRepack))
+ }
+
+ /* We could reduce data size of decoded folder, if we don't need to repack
+ last files in folder. But the gain in speed is small in most cases.
+ So we unpack full folder. */
+
+ UInt64 sizeToEncode = 0;
+
+ /*
+ UInt64 importantUnpackSize = 0;
+ unsigned numImportantFiles = 0;
+ UInt64 decodeSize = 0;
+ */
+
+ for (CNum fi = db->FolderStartFileIndex[folderIndex]; indexInFolder < numUnpackStreams; fi++)
+ {
+ bool needExtract = false;
+ const CFileItem &file = db->Files[fi];
+
+ if (file.HasStream)
+ {
+ indexInFolder++;
+ const int updateIndex = fileIndexToUpdateIndexMap[fi];
+ if (updateIndex >= 0 && !updateItems[(unsigned)updateIndex].NewData)
+ needExtract = true;
+ // decodeSize += file.Size;
+ }
+
+ extractStatuses.Add(needExtract);
+ if (needExtract)
+ {
+ sizeToEncode += file.Size;
+ /*
+ numImportantFiles = extractStatuses.Size();
+ importantUnpackSize = decodeSize;
+ */
+ }
+ }
+
+ // extractStatuses.DeleteFrom(numImportantFiles);
+
+ unsigned startPackIndex = newDatabase.PackSizes.Size();
+ UInt64 curUnpackSize;
+ {
+ CMyComPtr<ISequentialInStream> sbInStream;
+ CRepackStreamBase *repackBase;
+ CFolderInStream2 *FosSpec2 = NULL;
+
+ CRepackInStreamWithSizes *inStreamSizeCountSpec = new CRepackInStreamWithSizes;
+ CMyComPtr<ISequentialInStream> inStreamSizeCount = inStreamSizeCountSpec;
+ {
+ #ifndef Z7_ST
+ if (options.MultiThreadMixer)
+ {
+ repackBase = threadDecoder.FosSpec;
+ CMyComPtr<ISequentialOutStream> sbOutStream;
+ sb.CreateStreams2(sbInStream, sbOutStream);
+ RINOK(sb.Create_ReInit())
+
+ threadDecoder.FosSpec->_stream = sbOutStream;
+
+ threadDecoder.InStream = inStream;
+ threadDecoder.StartPos = db->ArcInfo.DataStartPosition; // db->GetFolderStreamPos(folderIndex, 0);
+ threadDecoder.Folders = (const CFolders *)db;
+ threadDecoder.FolderIndex = folderIndex;
+
+ // threadDecoder.UnpackSize = importantUnpackSize;
+ // threadDecoder.send_UnpackSize = true;
+ }
+ else
+ #endif
+ {
+ FosSpec2 = new CFolderInStream2;
+ FosSpec2->Init();
+ sbInStream = FosSpec2;
+ repackBase = FosSpec2;
+
+ #ifndef Z7_NO_CRYPTO
+ bool isEncrypted = false;
+ bool passwordIsDefined = false;
+ UString password;
+ #endif
+
+ CMyComPtr<ISequentialInStream> decodedStream;
+ bool dataAfterEnd_Error = false;
+
+ const HRESULT res = threadDecoder.Decoder.Decode(
+ EXTERNAL_CODECS_LOC_VARS
+ inStream,
+ db->ArcInfo.DataStartPosition, // db->GetFolderStreamPos(folderIndex, 0);,
+ *db, folderIndex,
+ // &importantUnpackSize, // *unpackSize
+ NULL, // *unpackSize : FULL unpack
+
+ NULL, // *outStream
+ NULL, // *compressProgress
+
+ &decodedStream
+ , dataAfterEnd_Error
+
+ Z7_7Z_DECODER_CRYPRO_VARS
+ #ifndef Z7_ST
+ , false // mtMode
+ , 1 // numThreads
+ , 0 // memUsage
+ #endif
+ );
+
+ RINOK(res)
+ if (!decodedStream)
+ return E_FAIL;
+
+ FosSpec2->_inStream = decodedStream;
+ }
+
+ repackBase->_db = db;
+ repackBase->_opCallback = opCallback;
+ repackBase->_extractCallback = extractCallback;
+
+ UInt32 startIndex = db->FolderStartFileIndex[folderIndex];
+ RINOK(repackBase->Init(startIndex, &extractStatuses))
+
+ inStreamSizeCountSpec->_db = db;
+ inStreamSizeCountSpec->Init(sbInStream, startIndex, &extractStatuses);
+
+ #ifndef Z7_ST
+ if (options.MultiThreadMixer)
+ {
+ WRes wres = threadDecoder.Start();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ #endif
+ }
+
+ // curUnpackSize = sizeToEncode;
+
+ HRESULT encodeRes = encoder.Encode1(
+ EXTERNAL_CODECS_LOC_VARS
+ inStreamSizeCount,
+ // NULL,
+ &inSizeForReduce,
+ sizeToEncode, // expectedDataSize
+ newDatabase.Folders.AddNew(),
+ // newDatabase.CoderUnpackSizes, curUnpackSize,
+ archive.SeqStream, newDatabase.PackSizes, progress);
+
+ if (encodeRes == k_My_HRESULT_CRC_ERROR)
+ return E_FAIL;
+
+ curUnpackSize = inStreamSizeCountSpec->GetSize();
+
+ if (encodeRes == S_OK)
+ {
+ encoder.Encode_Post(curUnpackSize, newDatabase.CoderUnpackSizes);
+ }
+
+ #ifndef Z7_ST
+ if (options.MultiThreadMixer)
+ {
+ // 16.00: hang was fixed : for case if decoding was not finished.
+ // We close CBinderInStream and it calls CStreamBinder::CloseRead()
+ inStreamSizeCount.Release();
+ sbInStream.Release();
+
+ {
+ const WRes wres = threadDecoder.WaitExecuteFinish();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ const HRESULT decodeRes = threadDecoder.Result;
+ // if (res == k_My_HRESULT_CRC_ERROR)
+ if (decodeRes == S_FALSE || threadDecoder.dataAfterEnd_Error)
+ {
+ if (extractCallback)
+ {
+ RINOK(extractCallback->ReportExtractResult(
+ NEventIndexType::kInArcIndex, db->FolderStartFileIndex[folderIndex],
+ // NEventIndexType::kBlockIndex, (UInt32)folderIndex,
+ (decodeRes != S_OK ?
+ NExtract::NOperationResult::kDataError :
+ NExtract::NOperationResult::kDataAfterEnd)))
+ }
+ if (decodeRes != S_OK)
+ return E_FAIL;
+ }
+ RINOK(decodeRes)
+ if (encodeRes == S_OK)
+ if (sb.ProcessedSize != sizeToEncode)
+ encodeRes = E_FAIL;
+ }
+ else
+ #endif
+ {
+ if (FosSpec2->Result == S_FALSE)
+ {
+ if (extractCallback)
+ {
+ RINOK(extractCallback->ReportExtractResult(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex,
+ NExtract::NOperationResult::kDataError))
+ }
+ return E_FAIL;
+ }
+ RINOK(FosSpec2->Result)
+ }
+
+ RINOK(encodeRes)
+ RINOK(repackBase->CheckFinishedState())
+
+ if (curUnpackSize != sizeToEncode)
+ return E_FAIL;
+ }
+
+ for (; startPackIndex < newDatabase.PackSizes.Size(); startPackIndex++)
+ lps->OutSize += newDatabase.PackSizes[startPackIndex];
+ lps->InSize += curUnpackSize;
+ }
+
+ newDatabase.NumUnpackStreamsVector.Add(rep.NumCopyFiles);
+
+ CNum indexInFolder = 0;
+ for (CNum fi = db->FolderStartFileIndex[folderIndex]; indexInFolder < numUnpackStreams; fi++)
+ {
+ if (db->Files[fi].HasStream)
+ {
+ indexInFolder++;
+ const int updateIndex = fileIndexToUpdateIndexMap[fi];
+ if (updateIndex >= 0)
+ {
+ const CUpdateItem &ui = updateItems[(unsigned)updateIndex];
+ if (ui.NewData)
+ continue;
+
+ UString name;
+ CFileItem file;
+ CFileItem2 file2;
+ GetFile(*db, fi, file, file2);
+
+ if (ui.NewProps)
+ {
+ UpdateItem_To_FileItem2(ui, file2);
+ file.IsDir = ui.IsDir;
+ name = ui.Name;
+ }
+ else
+ db->GetPath(fi, name);
+
+ /*
+ file.Parent = ui.ParentFolderIndex;
+ if (ui.TreeFolderIndex >= 0)
+ treeFolderToArcIndex[ui.TreeFolderIndex] = newDatabase.Files.Size();
+ if (totalSecureDataSize != 0)
+ newDatabase.SecureIDs.Add(ui.SecureIndex);
+ */
+ newDatabase.AddFile(file, file2, name);
+ }
+ }
+ }
+ }
+
+
+ // ---------- Compress files to new solid blocks ----------
+
+ const unsigned numFiles = group.Indices.Size();
+ if (numFiles == 0)
+ continue;
+ CRecordVector<CRefItem> refItems;
+ refItems.ClearAndSetSize(numFiles);
+ // bool sortByType = (options.UseTypeSorting && isSoid); // numSolidFiles > 1
+ const bool sortByType = options.UseTypeSorting;
+
+ unsigned i;
+
+ for (i = 0; i < numFiles; i++)
+ refItems[i] = CRefItem(group.Indices[i], updateItems[group.Indices[i]], sortByType);
+
+ CSortParam sortParam;
+ // sortParam.TreeFolders = &treeFolders;
+ sortParam.SortByType = sortByType;
+ refItems.Sort(CompareUpdateItems, (void *)&sortParam);
+
+ CObjArray<UInt32> indices(numFiles);
+
+ for (i = 0; i < numFiles; i++)
+ {
+ const UInt32 index = refItems[i].Index;
+ indices[i] = index;
+ /*
+ const CUpdateItem &ui = updateItems[index];
+ CFileItem file;
+ if (ui.NewProps)
+ UpdateItem_To_FileItem(ui, file);
+ else
+ file = db.Files[ui.IndexInArchive];
+ if (file.IsAnti || file.IsDir)
+ return E_FAIL;
+ newDatabase.Files.Add(file);
+ */
+ }
+
+ for (i = 0; i < numFiles;)
+ {
+ UInt64 totalSize = 0;
+ unsigned numSubFiles;
+
+ const wchar_t *prevExtension = NULL;
+
+ for (numSubFiles = 0; i + numSubFiles < numFiles && numSubFiles < numSolidFiles; numSubFiles++)
+ {
+ const CUpdateItem &ui = updateItems[indices[i + numSubFiles]];
+ totalSize += ui.Size;
+ if (totalSize > options.NumSolidBytes)
+ break;
+ if (options.SolidExtension)
+ {
+ const int slashPos = ui.Name.ReverseFind_PathSepar();
+ const int dotPos = ui.Name.ReverseFind_Dot();
+ const wchar_t *ext = ui.Name.Ptr(dotPos <= slashPos ? ui.Name.Len() : (unsigned)(dotPos + 1));
+ if (numSubFiles == 0)
+ prevExtension = ext;
+ else if (!StringsAreEqualNoCase(ext, prevExtension))
+ break;
+ }
+ }
+
+ if (numSubFiles < 1)
+ numSubFiles = 1;
+
+ RINOK(lps->SetCur())
+
+ /*
+ const unsigned folderIndex = newDatabase.NumUnpackStreamsVector.Size();
+
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex,
+ NUpdateNotifyOp::kAdd));
+ }
+ */
+
+
+ CFolderInStream *inStreamSpec = new CFolderInStream;
+ CMyComPtr<ISequentialInStream> solidInStream(inStreamSpec);
+
+ // inStreamSpec->_reportArcProp = reportArcProp;
+
+ inStreamSpec->Need_CTime = options.Need_CTime;
+ inStreamSpec->Need_ATime = options.Need_ATime;
+ inStreamSpec->Need_MTime = options.Need_MTime;
+ inStreamSpec->Need_Attrib = options.Need_Attrib;
+ // inStreamSpec->Need_Crc = options.Need_Crc;
+
+ inStreamSpec->Init(updateCallback, &indices[i], numSubFiles);
+
+ unsigned startPackIndex = newDatabase.PackSizes.Size();
+ // UInt64 curFolderUnpackSize = totalSize;
+ // curFolderUnpackSize = (UInt64)(Int64)-1; // for debug
+ const UInt64 expectedDataSize = totalSize;
+
+ // const unsigned folderIndex_New = newDatabase.Folders.Size();
+
+ RINOK(encoder.Encode1(
+ EXTERNAL_CODECS_LOC_VARS
+ solidInStream,
+ // NULL,
+ &inSizeForReduce,
+ expectedDataSize, // expected size
+ newDatabase.Folders.AddNew(),
+ // newDatabase.CoderUnpackSizes, curFolderUnpackSize,
+ archive.SeqStream, newDatabase.PackSizes, progress))
+
+ if (!inStreamSpec->WasFinished())
+ return E_FAIL;
+
+ /*
+ if (inStreamSpec->Need_FolderCrc)
+ newDatabase.FolderUnpackCRCs.SetItem(folderIndex_New,
+ true, inStreamSpec->GetFolderCrc());
+ */
+
+ const UInt64 curFolderUnpackSize = inStreamSpec->Get_TotalSize_for_Coder();
+ encoder.Encode_Post(curFolderUnpackSize, newDatabase.CoderUnpackSizes);
+
+ UInt64 packSize = 0;
+ // const UInt32 numStreams = newDatabase.PackSizes.Size() - startPackIndex;
+ for (; startPackIndex < newDatabase.PackSizes.Size(); startPackIndex++)
+ packSize += newDatabase.PackSizes[startPackIndex];
+ lps->OutSize += packSize;
+
+ // for ()
+ // newDatabase.PackCRCsDefined.Add(false);
+ // newDatabase.PackCRCs.Add(0);
+
+ CNum numUnpackStreams = 0;
+ UInt64 skippedSize = 0;
+ UInt64 procSize = 0;
+ // unsigned numProcessedFiles = 0;
+
+ for (unsigned subIndex = 0; subIndex < numSubFiles; subIndex++)
+ {
+ const CUpdateItem &ui = updateItems[indices[i + subIndex]];
+ CFileItem file;
+ CFileItem2 file2;
+ UString name;
+ if (ui.NewProps)
+ {
+ UpdateItem_To_FileItem(ui, file, file2);
+ name = ui.Name;
+ }
+ else
+ {
+ GetFile(*db, (unsigned)ui.IndexInArchive, file, file2);
+ db->GetPath((unsigned)ui.IndexInArchive, name);
+ }
+ if (file2.IsAnti || file.IsDir)
+ return E_FAIL;
+
+ /*
+ CFileItem &file = newDatabase.Files[
+ startFileIndexInDatabase + i + subIndex];
+ */
+ if (!inStreamSpec->Processed[subIndex])
+ {
+ // we don't add file here
+ skippedSize += ui.Size;
+ continue; // comment it for debug
+ // name += ".locked"; // for debug
+ }
+
+ // if (inStreamSpec->Need_Crc)
+ file.Crc = inStreamSpec->CRCs[subIndex];
+ file.Size = inStreamSpec->Sizes[subIndex];
+
+ procSize += file.Size;
+ // if (file.Size >= 0) // for debug: test purposes
+ if (file.Size != 0)
+ {
+ file.CrcDefined = true; // inStreamSpec->Need_Crc;
+ file.HasStream = true;
+ numUnpackStreams++;
+ }
+ else
+ {
+ file.CrcDefined = false;
+ file.HasStream = false;
+ }
+
+ if (inStreamSpec->TimesDefined[subIndex])
+ {
+ if (inStreamSpec->Need_CTime)
+ { file2.CTimeDefined = true; file2.CTime = inStreamSpec->CTimes[subIndex]; }
+ if (inStreamSpec->Need_ATime
+ // && !ui.ATime_WasReadByAnalysis
+ )
+ { file2.ATimeDefined = true; file2.ATime = inStreamSpec->ATimes[subIndex]; }
+ if (inStreamSpec->Need_MTime)
+ { file2.MTimeDefined = true; file2.MTime = inStreamSpec->MTimes[subIndex]; }
+ if (inStreamSpec->Need_Attrib)
+ {
+ file2.AttribDefined = true;
+ file2.Attrib = inStreamSpec->Attribs[subIndex];
+ }
+ }
+
+ /*
+ file.Parent = ui.ParentFolderIndex;
+ if (ui.TreeFolderIndex >= 0)
+ treeFolderToArcIndex[ui.TreeFolderIndex] = newDatabase.Files.Size();
+ if (totalSecureDataSize != 0)
+ newDatabase.SecureIDs.Add(ui.SecureIndex);
+ */
+ /*
+ if (reportArcProp)
+ {
+ RINOK(ReportItemProps(reportArcProp, ui.IndexInClient, file.Size,
+ file.CrcDefined ? &file.Crc : NULL))
+ }
+ */
+
+ // numProcessedFiles++;
+ newDatabase.AddFile(file, file2, name);
+ }
+
+ /*
+ // for debug:
+ // we can write crc to folders area, if folder contains only one file
+ if (numUnpackStreams == 1 && numSubFiles == 1)
+ {
+ const CFileItem &file = newDatabase.Files.Back();
+ if (file.CrcDefined)
+ newDatabase.FolderUnpackCRCs.SetItem(folderIndex_New, true, file.Crc);
+ }
+ */
+
+ /*
+ // it's optional check to ensure that sizes are correct
+ if (inStreamSpec->TotalSize_for_Coder != curFolderUnpackSize)
+ return E_FAIL;
+ */
+ // if (inStreamSpec->AlignLog == 0)
+ {
+ if (procSize != curFolderUnpackSize)
+ return E_FAIL;
+ }
+ // else
+ {
+ /*
+ {
+ const CFolder &old = newDatabase.Folders.Back();
+ CFolder &folder = newDatabase.Folders.AddNew();
+ {
+ const unsigned numBonds = old.Bonds.Size();
+ folder.Bonds.SetSize(numBonds + 1);
+ for (unsigned k = 0; k < numBonds; k++)
+ folder.Bonds[k] = old.Bonds[k];
+ CBond &bond = folder.Bonds[numBonds];
+ bond.PackIndex = 0;
+ bond.UnpackIndex = 0;
+ }
+ {
+ const unsigned numCoders = old.Coders.Size();
+ folder.Coders.SetSize(numCoders + 1);
+ for (unsigned k = 0; k < numCoders; k++)
+ folder.Coders[k] = old.Coders[k];
+ CCoderInfo &cod = folder.Coders[numCoders];
+ cod.Props.Alloc(1);
+ cod.Props[0] = (Byte)inStreamSpec->AlignLog;
+ cod.NumStreams = 1;
+ }
+ {
+ const unsigned numPackStreams = old.Coders.Size();
+ folder.Coders.SetSize(numPackStreams);
+ for (unsigned k = 0; k < numPackStreams; k++)
+ folder.PackStreams[k] = old.PackStreams[k];
+ }
+ }
+ newDatabase.Folders.Delete(newDatabase.Folders.Size() - 2);
+ */
+ }
+
+
+ lps->InSize += procSize;
+ // lps->InSize += curFolderUnpackSize;
+
+ // numUnpackStreams = 0 is very bad case for locked files
+ // v3.13 doesn't understand it.
+ newDatabase.NumUnpackStreamsVector.Add(numUnpackStreams);
+ i += numSubFiles;
+
+ if (skippedSize != 0 && complexity >= skippedSize)
+ {
+ complexity -= skippedSize;
+ RINOK(updateCallback->SetTotal(complexity))
+ }
+
+ /*
+ if (reportArcProp)
+ {
+ PROPVARIANT prop;
+ prop.vt = VT_EMPTY;
+ prop.wReserved1 = 0;
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt32(&prop, numProcessedFiles);
+ RINOK(reportArcProp->ReportProp(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex, kpidNumSubFiles, &prop));
+ }
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt64(&prop, curFolderUnpackSize);
+ RINOK(reportArcProp->ReportProp(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex, kpidSize, &prop));
+ }
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt64(&prop, packSize);
+ RINOK(reportArcProp->ReportProp(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex, kpidPackSize, &prop));
+ }
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt32(&prop, numStreams);
+ RINOK(reportArcProp->ReportProp(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex, kpidNumStreams, &prop));
+ }
+ RINOK(reportArcProp->ReportFinished(NEventIndexType::kBlockIndex, (UInt32)folderIndex, NUpdate::NOperationResult::kOK));
+ }
+ */
+ /*
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kBlockIndex, (UInt32)folderIndex,
+ NUpdateNotifyOp::kOpFinished));
+ }
+ */
+ }
+ }
+
+ RINOK(lps->SetCur())
+
+ /*
+ fileIndexToUpdateIndexMap.ClearAndFree();
+ groups.ClearAndFree();
+ */
+
+ /*
+ for (i = 0; i < newDatabase.Files.Size(); i++)
+ {
+ CFileItem &file = newDatabase.Files[i];
+ file.Parent = treeFolderToArcIndex[file.Parent];
+ }
+
+ if (totalSecureDataSize != 0)
+ {
+ newDatabase.SecureBuf.SetCapacity(totalSecureDataSize);
+ size_t pos = 0;
+ newDatabase.SecureSizes.Reserve(secureBlocks.Sorted.Size());
+ for (i = 0; i < secureBlocks.Sorted.Size(); i++)
+ {
+ const CByteBuffer &buf = secureBlocks.Bufs[secureBlocks.Sorted[i]];
+ size_t size = buf.GetCapacity();
+ if (size != 0)
+ memcpy(newDatabase.SecureBuf + pos, buf, size);
+ newDatabase.SecureSizes.Add((UInt32)size);
+ pos += size;
+ }
+ }
+ */
+
+ {
+ const unsigned numFolders = newDatabase.Folders.Size();
+ if (newDatabase.NumUnpackStreamsVector.Size() != numFolders
+ || newDatabase.FolderUnpackCRCs.Defs.Size() > numFolders)
+ return E_FAIL;
+ newDatabase.FolderUnpackCRCs.if_NonEmpty_FillResedue_with_false(numFolders);
+ }
+
+ updateItems.ClearAndFree();
+ newDatabase.ReserveDown();
+
+ if (opCallback)
+ RINOK(opCallback->ReportOperation(NEventIndexType::kNoIndex, (UInt32)(Int32)-1, NUpdateNotifyOp::kHeader))
+
+ RINOK(archive.WriteDatabase(EXTERNAL_CODECS_LOC_VARS
+ newDatabase, options.HeaderMethod, options.HeaderOptions))
+
+ if (v_StreamSetRestriction)
+ RINOK(v_StreamSetRestriction->SetRestriction(0, 0))
+
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/7z/7zUpdate.h b/CPP/7zip/Archive/7z/7zUpdate.h
index 06a0b05..de4117a 100644
--- a/CPP/7zip/Archive/7z/7zUpdate.h
+++ b/CPP/7zip/Archive/7z/7zUpdate.h
@@ -1,139 +1,146 @@
-// 7zUpdate.h
-
-#ifndef __7Z_UPDATE_H
-#define __7Z_UPDATE_H
-
-#include "../IArchive.h"
-
-// #include "../../Common/UniqBlocks.h"
-
-#include "7zCompressionMode.h"
-#include "7zIn.h"
-#include "7zOut.h"
-
-namespace NArchive {
-namespace N7z {
-
-/*
-struct CTreeFolder
-{
- UString Name;
- int Parent;
- CIntVector SubFolders;
- int UpdateItemIndex;
- int SortIndex;
- int SortIndexEnd;
-
- CTreeFolder(): UpdateItemIndex(-1) {}
-};
-*/
-
-struct CUpdateItem
-{
- int IndexInArchive;
- int IndexInClient;
-
- UInt64 CTime;
- UInt64 ATime;
- UInt64 MTime;
-
- UInt64 Size;
- UString Name;
- /*
- bool IsAltStream;
- int ParentFolderIndex;
- int TreeFolderIndex;
- */
-
- // that code is not used in 9.26
- // int ParentSortIndex;
- // int ParentSortIndexEnd;
-
- UInt32 Attrib;
-
- bool NewData;
- bool NewProps;
-
- bool IsAnti;
- bool IsDir;
-
- bool AttribDefined;
- bool CTimeDefined;
- bool ATimeDefined;
- bool MTimeDefined;
-
- // int SecureIndex; // 0 means (no_security)
-
- bool HasStream() const { return !IsDir && !IsAnti && Size != 0; }
- // bool HasStream() const { return !IsDir && !IsAnti /* && Size != 0 */; } // for test purposes
-
- CUpdateItem():
- // ParentSortIndex(-1),
- // IsAltStream(false),
- IsAnti(false),
- IsDir(false),
- AttribDefined(false),
- CTimeDefined(false),
- ATimeDefined(false),
- MTimeDefined(false)
- // SecureIndex(0)
- {}
- void SetDirStatusFromAttrib() { IsDir = ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0); }
-
- // unsigned GetExtensionPos() const;
- // UString GetExtension() const;
-};
-
-struct CUpdateOptions
-{
- const CCompressionMethodMode *Method;
- const CCompressionMethodMode *HeaderMethod;
- bool UseFilters; // use additional filters for some files
- bool MaxFilter; // use BCJ2 filter instead of BCJ
- int AnalysisLevel;
-
- CHeaderOptions HeaderOptions;
-
- UInt64 NumSolidFiles;
- UInt64 NumSolidBytes;
- bool SolidExtension;
-
- bool UseTypeSorting;
-
- bool RemoveSfxBlock;
- bool MultiThreadMixer;
-
- CUpdateOptions():
- Method(NULL),
- HeaderMethod(NULL),
- UseFilters(false),
- MaxFilter(false),
- AnalysisLevel(-1),
- NumSolidFiles((UInt64)(Int64)(-1)),
- NumSolidBytes((UInt64)(Int64)(-1)),
- SolidExtension(false),
- UseTypeSorting(true),
- RemoveSfxBlock(false),
- MultiThreadMixer(true)
- {}
-};
-
-HRESULT Update(
- DECL_EXTERNAL_CODECS_LOC_VARS
- IInStream *inStream,
- const CDbEx *db,
- const CObjectVector<CUpdateItem> &updateItems,
- // const CObjectVector<CTreeFolder> &treeFolders, // treeFolders[0] is root
- // const CUniqBlocks &secureBlocks,
- COutArchive &archive,
- CArchiveDatabaseOut &newDatabase,
- ISequentialOutStream *seqOutStream,
- IArchiveUpdateCallback *updateCallback,
- const CUpdateOptions &options
- #ifndef _NO_CRYPTO
- , ICryptoGetTextPassword *getDecoderPassword
- #endif
- );
-}}
-
-#endif
+// 7zUpdate.h
+
+#ifndef ZIP7_INC_7Z_UPDATE_H
+#define ZIP7_INC_7Z_UPDATE_H
+
+#include "../IArchive.h"
+
+// #include "../../Common/UniqBlocks.h"
+
+#include "7zCompressionMode.h"
+#include "7zIn.h"
+
+namespace NArchive {
+namespace N7z {
+
+/*
+struct CTreeFolder
+{
+ UString Name;
+ int Parent;
+ CIntVector SubFolders;
+ int UpdateItemIndex;
+ int SortIndex;
+ int SortIndexEnd;
+
+ CTreeFolder(): UpdateItemIndex(-1) {}
+};
+*/
+
+struct CUpdateItem
+{
+ int IndexInArchive;
+ unsigned IndexInClient;
+
+ UInt64 CTime;
+ UInt64 ATime;
+ UInt64 MTime;
+
+ UInt64 Size;
+ UString Name;
+ /*
+ bool IsAltStream;
+ int ParentFolderIndex;
+ int TreeFolderIndex;
+ */
+
+ // that code is not used in 9.26
+ // int ParentSortIndex;
+ // int ParentSortIndexEnd;
+
+ UInt32 Attrib;
+
+ bool NewData;
+ bool NewProps;
+
+ bool IsAnti;
+ bool IsDir;
+
+ bool AttribDefined;
+ bool CTimeDefined;
+ bool ATimeDefined;
+ bool MTimeDefined;
+
+ // bool ATime_WasReadByAnalysis;
+
+ // int SecureIndex; // 0 means (no_security)
+
+ bool HasStream() const { return !IsDir && !IsAnti && Size != 0; }
+ // bool HasStream() const { return !IsDir && !IsAnti /* && Size != 0 */; } // for test purposes
+
+ CUpdateItem():
+ // ParentSortIndex(-1),
+ // IsAltStream(false),
+ IsAnti(false),
+ IsDir(false),
+ AttribDefined(false),
+ CTimeDefined(false),
+ ATimeDefined(false),
+ MTimeDefined(false)
+ // , ATime_WasReadByAnalysis(false)
+ // SecureIndex(0)
+ {}
+ void SetDirStatusFromAttrib() { IsDir = ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0); }
+
+ // unsigned GetExtensionPos() const;
+ // UString GetExtension() const;
+};
+
+struct CUpdateOptions
+{
+ const CCompressionMethodMode *Method;
+ const CCompressionMethodMode *HeaderMethod;
+ bool UseFilters; // use additional filters for some files
+ bool MaxFilter; // use BCJ2 filter instead of BCJ
+ int AnalysisLevel;
+
+ UInt64 NumSolidFiles;
+ UInt64 NumSolidBytes;
+ bool SolidExtension;
+
+ bool UseTypeSorting;
+
+ bool RemoveSfxBlock;
+ bool MultiThreadMixer;
+
+ bool Need_CTime;
+ bool Need_ATime;
+ bool Need_MTime;
+ bool Need_Attrib;
+ // bool Need_Crc;
+
+ CHeaderOptions HeaderOptions;
+
+ CUpdateOptions():
+ Method(NULL),
+ HeaderMethod(NULL),
+ UseFilters(false),
+ MaxFilter(false),
+ AnalysisLevel(-1),
+ NumSolidFiles((UInt64)(Int64)(-1)),
+ NumSolidBytes((UInt64)(Int64)(-1)),
+ SolidExtension(false),
+ UseTypeSorting(true),
+ RemoveSfxBlock(false),
+ MultiThreadMixer(true),
+ Need_CTime(false),
+ Need_ATime(false),
+ Need_MTime(false),
+ Need_Attrib(false)
+ // , Need_Crc(true)
+ {}
+};
+
+HRESULT Update(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ IInStream *inStream,
+ const CDbEx *db,
+ CObjectVector<CUpdateItem> &updateItems,
+ // const CObjectVector<CTreeFolder> &treeFolders, // treeFolders[0] is root
+ // const CUniqBlocks &secureBlocks,
+ ISequentialOutStream *seqOutStream,
+ IArchiveUpdateCallback *updateCallback,
+ const CUpdateOptions &options);
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/7z/StdAfx.cpp b/CPP/7zip/Archive/7z/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Archive/7z/StdAfx.cpp
+++ b/CPP/7zip/Archive/7z/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Archive/7z/StdAfx.h b/CPP/7zip/Archive/7z/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Archive/7z/StdAfx.h
+++ b/CPP/7zip/Archive/7z/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/7z/makefile b/CPP/7zip/Archive/7z/makefile
new file mode 100644
index 0000000..ff60e4d
--- /dev/null
+++ b/CPP/7zip/Archive/7z/makefile
@@ -0,0 +1,81 @@
+PROG = 7z.dll
+DEF_FILE = ../Archive.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTERNAL_CODECS \
+
+AR_OBJS = \
+ $O\ArchiveExports.obj \
+ $O\DllExports2.obj \
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zEncode.obj \
+ $O\7zExtract.obj \
+ $O\7zFolderInStream.obj \
+ $O\7zHandler.obj \
+ $O\7zHandlerOut.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zOut.obj \
+ $O\7zProperties.obj \
+ $O\7zSpecStream.obj \
+ $O\7zUpdate.obj \
+ $O\7zRegister.obj \
+
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\IntToString.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\InOutTempBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\LockedStream.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\VirtThread.obj \
+
+COMPRESS_OBJS = \
+ $O\CopyCoder.obj \
+ $O\CodecExports.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\HandlerOut.obj \
+ $O\InStreamWithCRC.obj \
+ $O\ItemNameUtils.obj \
+ $O\MultiStream.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+C_OBJS = \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Archive/7z/resource.rc b/CPP/7zip/Archive/7z/resource.rc
new file mode 100644
index 0000000..f79dac0
--- /dev/null
+++ b/CPP/7zip/Archive/7z/resource.rc
@@ -0,0 +1,11 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_DLL("7z Plugin", "7z")
+
+0 ICON "../Icons/7z.ico"
+
+STRINGTABLE
+BEGIN
+ 100 "7z:0"
+END
+
diff --git a/CPP/7zip/Archive/ApfsHandler.cpp b/CPP/7zip/Archive/ApfsHandler.cpp
new file mode 100644
index 0000000..5fb7e0a
--- /dev/null
+++ b/CPP/7zip/Archive/ApfsHandler.cpp
@@ -0,0 +1,4482 @@
+// ApfsHandler.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/Sha256.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer2.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariantConv.h"
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/ItemNameUtils.h"
+
+#include "HfsHandler.h"
+
+// if APFS_SHOW_ALT_STREAMS is defined, the handler will show attribute files.
+#define APFS_SHOW_ALT_STREAMS
+
+#define VI_MINUS1 ((unsigned)(int)-1)
+#define IsViDef(x) ((int)(x) != -1)
+#define IsViNotDef(x) ((int)(x) == -1)
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G16(_offs_, dest) dest = Get16(p + (_offs_));
+#define G32(_offs_, dest) dest = Get32(p + (_offs_));
+#define G64(_offs_, dest) dest = Get64(p + (_offs_));
+
+namespace NArchive {
+namespace NApfs {
+
+#define ValToHex(t) ((char)(((t) < 10) ? ('0' + (t)) : ('a' + ((t) - 10))))
+
+static void ConvertByteToHex(unsigned val, char *s)
+{
+ unsigned t;
+ t = val >> 4;
+ s[0] = ValToHex(t);
+ t = val & 0xF;
+ s[1] = ValToHex(t);
+}
+
+struct CUuid
+{
+ Byte Data[16];
+
+ void SetHex_To_str(char *s) const
+ {
+ for (unsigned i = 0; i < 16; i++)
+ ConvertByteToHex(Data[i], s + i * 2);
+ s[32] = 0;
+ }
+
+ void AddHexToString(UString &dest) const
+ {
+ char temp[32 + 4];
+ SetHex_To_str(temp);
+ dest += temp;
+ }
+
+ void SetFrom(const Byte *p) { memcpy(Data, p, 16); }
+};
+
+
+typedef UInt64 oid_t;
+typedef UInt64 xid_t;
+// typedef Int64 paddr_t;
+typedef UInt64 paddr_t_unsigned;
+
+#define G64o G64
+#define G64x G64
+// #define G64a G64
+
+/*
+struct prange_t
+{
+ paddr_t start_paddr;
+ UInt64 block_count;
+
+ void Parse(const Byte *p)
+ {
+ G64a (0, start_paddr);
+ G64 (8, block_count);
+ }
+};
+*/
+
+#define OBJECT_TYPE_NX_SUPERBLOCK 0x1
+#define OBJECT_TYPE_BTREE 0x2
+#define OBJECT_TYPE_BTREE_NODE 0x3
+/*
+#define OBJECT_TYPE_SPACEMAN 0x5
+#define OBJECT_TYPE_SPACEMAN_CAB 0x6
+#define OBJECT_TYPE_SPACEMAN_CIB 0x7
+#define OBJECT_TYPE_SPACEMAN_BITMAP 0x8
+#define OBJECT_TYPE_SPACEMAN_FREE_QUEUE 0x9
+#define OBJECT_TYPE_EXTENT_LIST_TREE 0xa
+*/
+#define OBJECT_TYPE_OMAP 0xb
+/*
+#define OBJECT_TYPE_CHECKPOINT_MAP 0xc
+*/
+#define OBJECT_TYPE_FS 0xd
+#define OBJECT_TYPE_FSTREE 0xe
+/*
+#define OBJECT_TYPE_BLOCKREFTREE 0xf
+#define OBJECT_TYPE_SNAPMETATREE 0x10
+#define OBJECT_TYPE_NX_REAPER 0x11
+#define OBJECT_TYPE_NX_REAP_LIST 0x12
+#define OBJECT_TYPE_OMAP_SNAPSHOT 0x13
+#define OBJECT_TYPE_EFI_JUMPSTART 0x14
+#define OBJECT_TYPE_FUSION_MIDDLE_TREE 0x15
+#define OBJECT_TYPE_NX_FUSION_WBC 0x16
+#define OBJECT_TYPE_NX_FUSION_WBC_LIST 0x17
+#define OBJECT_TYPE_ER_STATE 0x18
+#define OBJECT_TYPE_GBITMAP 0x19
+#define OBJECT_TYPE_GBITMAP_TREE 0x1a
+#define OBJECT_TYPE_GBITMAP_BLOCK 0x1b
+#define OBJECT_TYPE_ER_RECOVERY_BLOCK 0x1c
+#define OBJECT_TYPE_SNAP_META_EXT 0x1d
+*/
+#define OBJECT_TYPE_INTEGRITY_META 0x1e
+#define OBJECT_TYPE_FEXT_TREE 0x1f
+/*
+#define OBJECT_TYPE_RESERVED_20 0x20
+
+#define OBJECT_TYPE_INVALID 0x0
+#define OBJECT_TYPE_TEST 0xff
+#define OBJECT_TYPE_CONTAINER_KEYBAG 'keys'
+#define OBJECT_TYPE_VOLUME_KEYBAG 'recs'
+#define OBJECT_TYPE_MEDIA_KEYBAG 'mkey'
+
+#define OBJ_VIRTUAL 0x0
+#define OBJ_EPHEMERAL 0x80000000
+*/
+#define OBJ_PHYSICAL 0x40000000
+/*
+#define OBJ_NOHEADER 0x20000000
+#define OBJ_ENCRYPTED 0x10000000
+#define OBJ_NONPERSISTENT 0x08000000
+*/
+#define OBJECT_TYPE_MASK 0x0000ffff
+/*
+#define OBJECT_TYPE_FLAGS_MASK 0xffff0000
+#define OBJ_STORAGETYPE_MASK 0xc0000000
+#define OBJECT_TYPE_FLAGS_DEFINED_MASK 0xf8000000
+*/
+
+// #define MAX_CKSUM_SIZE 8
+
+static const unsigned k_obj_phys_Size = 0x20;
+
+// obj_phys_t
+struct CPhys
+{
+ // Byte cksum[MAX_CKSUM_SIZE];
+ oid_t oid;
+ xid_t xid;
+ UInt32 type;
+ UInt32 subtype;
+
+ UInt32 GetType() const { return type & OBJECT_TYPE_MASK; }
+ void Parse(const Byte *p);
+};
+
+void CPhys::Parse(const Byte *p)
+{
+ // memcpy(cksum, p, MAX_CKSUM_SIZE);
+ G64o (8, oid)
+ G64x (0x10, xid)
+ G32 (0x18, type)
+ G32 (0x1C, subtype)
+}
+
+#define NX_MAX_FILE_SYSTEMS 100
+/*
+#define NX_EPH_INFO_COUNT 4
+#define NX_EPH_MIN_BLOCK_COUNT 8
+#define NX_MAX_FILE_SYSTEM_EPH_STRUCTS 4
+#define NX_TX_MIN_CHECKPOINT_COUNT 4
+#define NX_EPH_INFO_VERSION_1 1
+*/
+
+/*
+typedef enum
+{
+ NX_CNTR_OBJ_CKSUM_SET = 0,
+ NX_CNTR_OBJ_CKSUM_FAIL = 1,
+ NX_NUM_COUNTERS = 32
+} counter_id_t;
+*/
+
+/* Incompatible volume feature flags */
+#define APFS_INCOMPAT_CASE_INSENSITIVE (1 << 0)
+/*
+#define APFS_INCOMPAT_DATALESS_SNAPS (1 << 1)
+#define APFS_INCOMPAT_ENC_ROLLED (1 << 2)
+*/
+#define APFS_INCOMPAT_NORMALIZATION_INSENSITIVE (1 << 3)
+/*
+#define APFS_INCOMPAT_INCOMPLETE_RESTORE (1 << 4)
+*/
+#define APFS_INCOMPAT_SEALED_VOLUME (1 << 5)
+/*
+#define APFS_INCOMPAT_RESERVED_40 (1 << 6)
+*/
+
+static const char * const g_APFS_INCOMPAT_Flags[] =
+{
+ "CASE_INSENSITIVE"
+ , "DATALESS_SNAPS"
+ , "ENC_ROLLED"
+ , "NORMALIZATION_INSENSITIVE"
+ , "INCOMPLETE_RESTORE"
+ , "SEALED_VOLUME"
+};
+
+/*
+#define APFS_SUPPORTED_INCOMPAT_MASK \
+ ( APFS_INCOMPAT_CASE_INSENSITIVE \
+ | APFS_INCOMPAT_DATALESS_SNAPS \
+ | APFS_INCOMPAT_ENC_ROLLED \
+ | APFS_INCOMPAT_NORMALIZATION_INSENSITIVE \
+ | APFS_INCOMPAT_INCOMPLETE_RESTORE \
+ | APFS_INCOMPAT_SEALED_VOLUME \
+ | APFS_INCOMPAT_RESERVED_40 \
+)
+*/
+
+// superblock_t
+struct CSuperBlock
+{
+ // CPhys o;
+ // UInt32 magic;
+ UInt32 block_size;
+ unsigned block_size_Log;
+ UInt64 block_count;
+ // UInt64 features;
+ // UInt64 readonly_compatible_features;
+ // UInt64 incompatible_features;
+ CUuid uuid;
+ /*
+ oid_t next_oid;
+ xid_t next_xid;
+ UInt32 xp_desc_blocks;
+ UInt32 xp_data_blocks;
+ paddr_t xp_desc_base;
+ paddr_t xp_data_base;
+ UInt32 xp_desc_next;
+ UInt32 xp_data_next;
+ UInt32 xp_desc_index;
+ UInt32 xp_desc_len;
+ UInt32 xp_data_index;
+ UInt32 xp_data_len;
+ oid_t spaceman_oid;
+ */
+ oid_t omap_oid;
+ // oid_t reaper_oid;
+ // UInt32 test_type;
+ UInt32 max_file_systems;
+ // oid_t fs_oid[NX_MAX_FILE_SYSTEMS];
+ /*
+ UInt64 counters[NX_NUM_COUNTERS]; // counter_id_t
+ prange_t blocked_out_prange;
+ oid_t evict_mapping_tree_oid;
+ UInt64 flags;
+ paddr_t efi_jumpstart;
+ CUuid fusion_uuid;
+ prange_t keylocker;
+ UInt64 ephemeral_info[NX_EPH_INFO_COUNT];
+ oid_t test_oid;
+ oid_t fusion_mt_oid;
+ oid_t fusion_wbc_oid;
+ prange_t fusion_wbc;
+ UInt64 newest_mounted_version;
+ prange_t mkb_locker;
+ */
+
+ bool Parse(const Byte *p);
+};
+
+struct CSuperBlock2
+{
+ oid_t fs_oid[NX_MAX_FILE_SYSTEMS];
+ void Parse(const Byte *p)
+ {
+ for (unsigned i = 0; i < NX_MAX_FILE_SYSTEMS; i++)
+ {
+ G64o (0xb8 + i * 8, fs_oid[i])
+ }
+ }
+};
+
+
+// we include one additional byte of next field (block_size)
+static const unsigned k_SignatureOffset = 32;
+static const Byte k_Signature[] = { 'N', 'X', 'S', 'B', 0 };
+
+// size must be 4 bytes aligned
+static UInt64 Fletcher64(const Byte *data, size_t size)
+{
+ const UInt32 kMax32 = 0xffffffff;
+ const UInt64 val = 0; // startVal
+ UInt64 a = val & kMax32;
+ UInt64 b = (val >> 32) & kMax32;
+ for (size_t i = 0; i < size; i += 4)
+ {
+ a += GetUi32(data + i);
+ b += a;
+ }
+ a %= kMax32;
+ b %= kMax32;
+ b = (UInt32)(kMax32 - ((a + b) % kMax32));
+ a = (UInt32)(kMax32 - ((a + b) % kMax32));
+ return (a << 32) | b;
+}
+
+static bool CheckFletcher64(const Byte *p, size_t size)
+{
+ const UInt64 calculated_checksum = Fletcher64(p + 8, size - 8);
+ const UInt64 stored_checksum = Get64(p);
+ return (stored_checksum == calculated_checksum);
+}
+
+
+static unsigned GetLogSize(UInt32 size)
+{
+ unsigned k;
+ for (k = 0; k < 32; k++)
+ if (((UInt32)1 << k) == size)
+ return k;
+ return k;
+}
+
+static const unsigned kApfsHeaderSize = 1 << 12;
+
+// #define OID_INVALID 0
+#define OID_NX_SUPERBLOCK 1
+// #define OID_RESERVED_COUNT 1024
+// This range of identifiers is reserved for physical, virtual, and ephemeral objects
+
+bool CSuperBlock::Parse(const Byte *p)
+{
+ CPhys o;
+ o.Parse(p);
+ if (o.oid != OID_NX_SUPERBLOCK)
+ return false;
+ if (o.GetType() != OBJECT_TYPE_NX_SUPERBLOCK)
+ return false;
+ if (o.subtype != 0)
+ return false;
+ if (memcmp(p + k_SignatureOffset, k_Signature, 4) != 0)
+ return false;
+ if (!CheckFletcher64(p, kApfsHeaderSize))
+ return false;
+
+ G32 (0x24, block_size)
+ {
+ const unsigned logSize = GetLogSize(block_size);
+ // don't change it. Some code requires (block_size <= 16)
+ if (logSize < 12 || logSize > 16)
+ return false;
+ block_size_Log = logSize;
+ }
+
+ G64 (0x28, block_count)
+
+ const UInt64 kArcSize_MAX = (UInt64)1 << 62;
+ if (block_count > (kArcSize_MAX >> block_size_Log))
+ return false;
+
+ // G64 (0x30, features);
+ // G64 (0x38, readonly_compatible_features);
+ // G64 (0x40, incompatible_features);
+ uuid.SetFrom(p + 0x48);
+ /*
+ G64o (0x58, next_oid);
+ G64x (0x60, next_xid);
+ G32 (0x68, xp_desc_blocks);
+ G32 (0x6c, xp_data_blocks);
+ G64a (0x70, xp_desc_base);
+ G64a (0x78, xp_data_base);
+ G32 (0x80, xp_desc_next);
+ G32 (0x84, xp_data_next);
+ G32 (0x88, xp_desc_index);
+ G32 (0x8c, xp_desc_len);
+ G32 (0x90, xp_data_index);
+ G32 (0x94, xp_data_len);
+ G64o (0x98, spaceman_oid);
+ */
+ G64o (0xa0, omap_oid)
+ // G64o (0xa8, reaper_oid);
+ // G32 (0xb0, test_type);
+ G32 (0xb4, max_file_systems)
+ if (max_file_systems > NX_MAX_FILE_SYSTEMS)
+ return false;
+ /*
+ {
+ for (unsigned i = 0; i < NX_MAX_FILE_SYSTEMS; i++)
+ {
+ G64o (0xb8 + i * 8, fs_oid[i]);
+ }
+ }
+ */
+ /*
+ {
+ for (unsigned i = 0; i < NX_NUM_COUNTERS; i++)
+ {
+ G64 (0x3d8 + i * 8, counters[i]);
+ }
+ }
+ blocked_out_prange.Parse(p + 0x4d8);
+ G64o (0x4e8, evict_mapping_tree_oid);
+ #define NX_CRYPTO_SW 0x00000004LL
+ G64 (0x4f0, flags);
+ G64a (0x4f8, efi_jumpstart);
+ fusion_uuid.SetFrom(p + 0x500);
+ keylocker.Parse(p + 0x510);
+ {
+ for (unsigned i = 0; i < NX_EPH_INFO_COUNT; i++)
+ {
+ G64 (0x520 + i * 8, ephemeral_info[i]);
+ }
+ }
+ G64o (0x540, test_oid);
+ G64o (0x548, fusion_mt_oid);
+ G64o (0x550, fusion_wbc_oid);
+ fusion_wbc.Parse(p + 0x558);
+ G64 (0x568, newest_mounted_version); // decimal 1412141 001 000 000
+ mkb_locker.Parse(p + 0x570);
+ */
+
+ return true;
+}
+
+
+enum apfs_hash_type_t
+{
+ APFS_HASH_INVALID = 0,
+ APFS_HASH_SHA256 = 1,
+ APFS_HASH_SHA512_256 = 2,
+ APFS_HASH_SHA384 = 3,
+ APFS_HASH_SHA512 = 4,
+
+ APFS_HASH_MIN = APFS_HASH_SHA256,
+ APFS_HASH_MAX = APFS_HASH_SHA512,
+
+ APFS_HASH_DEFAULT = APFS_HASH_SHA256
+};
+
+static unsigned GetHashSize(unsigned hashType)
+{
+ if (hashType > APFS_HASH_MAX) return 0;
+ if (hashType < APFS_HASH_MIN) return 0;
+ if (hashType == APFS_HASH_SHA256) return 32;
+ return hashType * 16;
+}
+
+#define APFS_HASH_MAX_SIZE 64
+
+static const char * const g_hash_types[] =
+{
+ NULL
+ , "SHA256"
+ , "SHA512_256"
+ , "SHA384"
+ , "SHA512"
+};
+
+
+struct C_integrity_meta_phys
+{
+ // CPhys im_o;
+ // UInt32 im_version;
+ UInt32 im_flags;
+ // apfs_hash_type_t
+ UInt32 im_hash_type;
+ // UInt32 im_root_hash_offset;
+ // xid_t im_broken_xid;
+ // UInt64 im_reserved[9];
+
+ unsigned HashSize;
+ Byte Hash[APFS_HASH_MAX_SIZE];
+
+ bool Is_SHA256() const { return im_hash_type == APFS_HASH_SHA256; }
+
+ C_integrity_meta_phys()
+ {
+ memset(this, 0, sizeof(*this));
+ }
+ bool Parse(const Byte *p, size_t size, oid_t oid);
+};
+
+bool C_integrity_meta_phys::Parse(const Byte *p, size_t size, oid_t oid)
+{
+ CPhys o;
+ if (!CheckFletcher64(p, size))
+ return false;
+ o.Parse(p);
+ if (o.GetType() != OBJECT_TYPE_INTEGRITY_META)
+ return false;
+ if (o.oid != oid)
+ return false;
+ // G32 (0x20, im_version);
+ G32 (0x24, im_flags)
+ G32 (0x28, im_hash_type)
+ UInt32 im_root_hash_offset;
+ G32 (0x2C, im_root_hash_offset)
+ // G64x (0x30, im_broken_xid);
+ const unsigned hashSize = GetHashSize(im_hash_type);
+ HashSize = hashSize;
+ if (im_root_hash_offset >= size || size - im_root_hash_offset < hashSize)
+ return false;
+ memcpy(Hash, p + im_root_hash_offset, hashSize);
+ return true;
+}
+
+
+struct C_omap_phys
+{
+ // om_ prefix
+ // CPhys o;
+ /*
+ UInt32 flags;
+ UInt32 snap_count;
+ UInt32 tree_type;
+ UInt32 snapshot_tree_type;
+ */
+ oid_t tree_oid;
+ /*
+ oid_t snapshot_tree_oid;
+ xid_t most_recent_snap;
+ xid_t pending_revert_min;
+ xid_t pending_revert_max;
+ */
+ bool Parse(const Byte *p, size_t size, oid_t oid);
+};
+
+bool C_omap_phys::Parse(const Byte *p, size_t size, oid_t oid)
+{
+ CPhys o;
+ if (!CheckFletcher64(p, size))
+ return false;
+ o.Parse(p);
+ if (o.GetType() != OBJECT_TYPE_OMAP)
+ return false;
+ if (o.oid != oid)
+ return false;
+ /*
+ G32 (0x20, flags);
+ G32 (0x24, snap_count);
+ G32 (0x28, tree_type);
+ G32 (0x2C, snapshot_tree_type);
+ */
+ G64o (0x30, tree_oid)
+ /*
+ G64o (0x38, snapshot_tree_oid);
+ G64x (0x40, most_recent_snap);
+ G64x (0x48, pending_revert_min);
+ G64x (0x50, pending_revert_max);
+ */
+ return true;
+}
+
+
+// #define BTOFF_INVALID 0xffff
+/* This value is stored in the off field of nloc_t to indicate that
+there's no offset. For example, the last entry in a free
+list has no entry after it, so it uses this value for its off field. */
+
+// A location within a B-tree node
+struct nloc
+{
+ UInt16 off;
+ UInt16 len;
+
+ void Parse(const Byte *p)
+ {
+ G16 (0, off)
+ G16 (2, len)
+ }
+ UInt32 GetEnd() const { return (UInt32)off + len; }
+ bool CheckOverLimit(UInt32 limit)
+ {
+ return off < limit && len <= limit - off;
+ }
+};
+
+
+// The location, within a B-tree node, of a key and value
+struct kvloc
+{
+ nloc k;
+ nloc v;
+
+ void Parse(const Byte *p)
+ {
+ k.Parse(p);
+ v.Parse(p + 4);
+ }
+};
+
+
+// The location, within a B-tree node, of a fixed-size key and value
+struct kvoff
+{
+ UInt16 k;
+ UInt16 v;
+
+ void Parse(const Byte *p)
+ {
+ G16 (0, k)
+ G16 (2, v)
+ }
+};
+
+
+#define BTNODE_ROOT (1 << 0)
+#define BTNODE_LEAF (1 << 1)
+#define BTNODE_FIXED_KV_SIZE (1 << 2)
+#define BTNODE_HASHED (1 << 3)
+#define BTNODE_NOHEADER (1 << 4)
+/*
+#define BTNODE_CHECK_KOFF_INVAL (1 << 15)
+*/
+
+static const unsigned k_Toc_offset = 0x38;
+
+// btree_node_phys
+struct CBTreeNodePhys
+{
+ // btn_ prefix
+ CPhys ophys;
+ UInt16 flags;
+ UInt16 level; // the number of child levels below this node. 0 - for a leaf node, 1 for the immediate parent of a leaf node
+ UInt32 nkeys; // The number of keys stored in this node.
+ nloc table_space;
+ /*
+ nloc free_space;
+ nloc key_free_list;
+ nloc val_free_list;
+ */
+
+ bool Is_FIXED_KV_SIZE() const { return (flags & BTNODE_FIXED_KV_SIZE) != 0; }
+ bool Is_NOHEADER() const { return (flags & BTNODE_NOHEADER) != 0; }
+ bool Is_HASHED() const { return (flags & BTNODE_HASHED) != 0; }
+
+ bool Parse(const Byte *p, size_t size, bool noHeader = false)
+ {
+ G16 (0x20, flags)
+ G16 (0x22, level)
+ G32 (0x24, nkeys)
+ table_space.Parse(p + 0x28);
+ /*
+ free_space.Parse(p + 0x2C);
+ key_free_list.Parse(p + 0x30);
+ val_free_list.Parse(p + 0x34);
+ */
+ memset(&ophys, 0, sizeof(ophys));
+ if (noHeader)
+ {
+ for (unsigned i = 0; i < k_obj_phys_Size; i++)
+ if (p[i] != 0)
+ return false;
+ }
+ else
+ {
+ if (!CheckFletcher64(p, size))
+ return false;
+ ophys.Parse(p);
+ }
+ if (Is_NOHEADER() != noHeader)
+ return false;
+ return true;
+ }
+};
+
+/*
+#define BTREE_UINT64_KEYS (1 << 0)
+#define BTREE_SEQUENTIAL_INSERT (1 << 1)
+#define BTREE_ALLOW_GHOSTS (1 << 2)
+*/
+#define BTREE_EPHEMERAL (1 << 3)
+#define BTREE_PHYSICAL (1 << 4)
+/*
+#define BTREE_NONPERSISTENT (1 << 5)
+#define BTREE_KV_NONALIGNED (1 << 6)
+#define BTREE_HASHED (1 << 7)
+*/
+#define BTREE_NOHEADER (1 << 8)
+
+/*
+ BTREE_EPHEMERAL: The nodes in the B-tree use ephemeral object identifiers to link to child nodes
+ BTREE_PHYSICAL : The nodes in the B-tree use physical object identifiers to link to child nodes.
+ If neither flag is set, nodes in the B-tree use virtual object
+ identifiers to link to their child nodes.
+*/
+
+// Static information about a B-tree.
+struct btree_info_fixed
+{
+ UInt32 flags;
+ UInt32 node_size;
+ UInt32 key_size;
+ UInt32 val_size;
+
+ void Parse(const Byte *p)
+ {
+ G32 (0, flags)
+ G32 (4, node_size)
+ G32 (8, key_size)
+ G32 (12, val_size)
+ }
+};
+
+static const unsigned k_btree_info_Size = 0x28;
+
+struct btree_info
+{
+ btree_info_fixed fixed;
+ UInt32 longest_key;
+ UInt32 longest_val;
+ UInt64 key_count;
+ UInt64 node_count;
+
+ bool Is_EPHEMERAL() const { return (fixed.flags & BTREE_EPHEMERAL) != 0; }
+ bool Is_PHYSICAL() const { return (fixed.flags & BTREE_PHYSICAL) != 0; }
+ bool Is_NOHEADER() const { return (fixed.flags & BTREE_NOHEADER) != 0; }
+
+ void Parse(const Byte *p)
+ {
+ fixed.Parse(p);
+ G32 (0x10, longest_key)
+ G32 (0x14, longest_val)
+ G64 (0x18, key_count)
+ G64 (0x20, node_count)
+ }
+};
+
+
+/*
+typedef UInt32 cp_key_class_t;
+typedef UInt32 cp_key_os_version_t;
+typedef UInt16 cp_key_revision_t;
+typedef UInt32 crypto_flags_t;
+
+struct wrapped_meta_crypto_state
+{
+ UInt16 major_version;
+ UInt16 minor_version;
+ crypto_flags_t cpflags;
+ cp_key_class_t persistent_class;
+ cp_key_os_version_t key_os_version;
+ cp_key_revision_t key_revision;
+ // UInt16 unused;
+
+ void Parse(const Byte *p)
+ {
+ G16 (0, major_version);
+ G16 (2, minor_version);
+ G32 (4, cpflags);
+ G32 (8, persistent_class);
+ G32 (12, key_os_version);
+ G16 (16, key_revision);
+ }
+};
+*/
+
+
+#define APFS_MODIFIED_NAMELEN 32
+#define sizeof_apfs_modified_by_t (APFS_MODIFIED_NAMELEN + 16)
+
+struct apfs_modified_by_t
+{
+ Byte id[APFS_MODIFIED_NAMELEN];
+ UInt64 timestamp;
+ xid_t last_xid;
+
+ void Parse(const Byte *p)
+ {
+ memcpy(id, p, APFS_MODIFIED_NAMELEN);
+ p += APFS_MODIFIED_NAMELEN;
+ G64 (0, timestamp)
+ G64x (8, last_xid)
+ }
+};
+
+
+#define APFS_MAX_HIST 8
+#define APFS_VOLNAME_LEN 256
+
+struct CApfs
+{
+ // apfs_
+ CPhys o;
+ // UInt32 magic;
+ UInt32 fs_index; // index of the object identifier for this volume's file system in the container's array of file systems.
+ // UInt64 features;
+ // UInt64 readonly_compatible_features;
+ UInt64 incompatible_features;
+ UInt64 unmount_time;
+ // UInt64 fs_reserve_block_count;
+ // UInt64 fs_quota_block_count;
+ UInt64 fs_alloc_count;
+ // wrapped_meta_crypto_state meta_crypto;
+ // UInt32 root_tree_type;
+ /* The type of the root file-system tree.
+ The value is typically OBJ_VIRTUAL | OBJECT_TYPE_BTREE,
+ with a subtype of OBJECT_TYPE_FSTREE */
+
+ // UInt32 extentref_tree_type;
+ // UInt32 snap_meta_tree_type;
+ oid_t omap_oid;
+ oid_t root_tree_oid;
+ /*
+ oid_t extentref_tree_oid;
+ oid_t snap_meta_tree_oid;
+ xid_t revert_to_xid;
+ oid_t revert_to_sblock_oid;
+ UInt64 next_obj_id;
+ */
+ UInt64 num_files;
+ UInt64 num_directories;
+ UInt64 num_symlinks;
+ UInt64 num_other_fsobjects;
+ UInt64 num_snapshots;
+ UInt64 total_blocks_alloced;
+ UInt64 total_blocks_freed;
+ CUuid vol_uuid;
+ UInt64 last_mod_time;
+ UInt64 fs_flags;
+ apfs_modified_by_t formatted_by;
+ apfs_modified_by_t modified_by[APFS_MAX_HIST];
+ Byte volname[APFS_VOLNAME_LEN];
+ /*
+ UInt32 next_doc_id;
+ UInt16 role; // APFS_VOL_ROLE_NONE APFS_VOL_ROLE_SYSTEM ....
+ UInt16 reserved;
+ xid_t root_to_xid;
+ oid_t er_state_oid;
+ UInt64 cloneinfo_id_epoch;
+ UInt64 cloneinfo_xid;
+ oid_t snap_meta_ext_oid;
+ CUuid volume_group_id;
+ */
+ oid_t integrity_meta_oid; // virtual object identifier of the integrity metadata object
+ oid_t fext_tree_oid; // virtual object identifier of the file extent tree.
+ UInt32 fext_tree_type; // The type of the file extent tree.
+ /*
+ UInt32 reserved_type;
+ oid_t reserved_oid;
+ */
+
+ UInt64 GetTotalItems() const
+ {
+ return num_files + num_directories + num_symlinks + num_other_fsobjects;
+ }
+
+ bool IsHashedName() const
+ {
+ return
+ (incompatible_features & APFS_INCOMPAT_CASE_INSENSITIVE) != 0 ||
+ (incompatible_features & APFS_INCOMPAT_NORMALIZATION_INSENSITIVE) != 0;
+ }
+
+ bool Parse(const Byte *p, size_t size);
+};
+
+
+bool CApfs::Parse(const Byte *p, size_t size)
+{
+ o.Parse(p);
+ if (Get32(p + 32) != 0x42535041) // { 'A', 'P', 'S', 'B' };
+ return false;
+ if (o.GetType() != OBJECT_TYPE_FS)
+ return false;
+ if (!CheckFletcher64(p, size))
+ return false;
+ // if (o.GetType() != OBJECT_TYPE_NX_SUPERBLOCK) return false;
+
+ G32 (0x24, fs_index)
+ // G64 (0x28, features);
+ // G64 (0x30, readonly_compatible_features);
+ G64 (0x38, incompatible_features)
+ G64 (0x40, unmount_time)
+ // G64 (0x48, fs_reserve_block_count);
+ // G64 (0x50, fs_quota_block_count);
+ G64 (0x58, fs_alloc_count)
+ // meta_crypto.Parse(p + 0x60);
+ // G32 (0x74, root_tree_type);
+ // G32 (0x78, extentref_tree_type);
+ // G32 (0x7C, snap_meta_tree_type);
+
+ G64o (0x80, omap_oid)
+ G64o (0x88, root_tree_oid)
+ /*
+ G64o (0x90, extentref_tree_oid);
+ G64o (0x98, snap_meta_tree_oid);
+ G64x (0xa0, revert_to_xid);
+ G64o (0xa8, revert_to_sblock_oid);
+ G64 (0xb0, next_obj_id);
+ */
+ G64 (0xb8, num_files)
+ G64 (0xc0, num_directories)
+ G64 (0xc8, num_symlinks)
+ G64 (0xd0, num_other_fsobjects)
+ G64 (0xd8, num_snapshots)
+ G64 (0xe0, total_blocks_alloced)
+ G64 (0xe8, total_blocks_freed)
+ vol_uuid.SetFrom(p + 0xf0);
+ G64 (0x100, last_mod_time)
+ G64 (0x108, fs_flags)
+ p += 0x110;
+ formatted_by.Parse(p);
+ p += sizeof_apfs_modified_by_t;
+ for (unsigned i = 0; i < APFS_MAX_HIST; i++)
+ {
+ modified_by[i].Parse(p);
+ p += sizeof_apfs_modified_by_t;
+ }
+ memcpy(volname, p, APFS_VOLNAME_LEN);
+ p += APFS_VOLNAME_LEN;
+ /*
+ G32 (0, next_doc_id);
+ G16 (4, role);
+ G16 (6, reserved);
+ G64x (8, root_to_xid);
+ G64o (0x10, er_state_oid);
+ G64 (0x18, cloneinfo_id_epoch);
+ G64 (0x20, cloneinfo_xid);
+ G64o (0x28, snap_meta_ext_oid);
+ volume_group_id.SetFrom(p + 0x30);
+ */
+ G64o (0x40, integrity_meta_oid)
+ G64o (0x48, fext_tree_oid)
+ G32 (0x50, fext_tree_type)
+ /*
+ G32 (0x54, reserved_type);
+ G64o (0x58, reserved_oid);
+ */
+ return true;
+}
+
+
+#define OBJ_ID_MASK 0x0fffffffffffffff
+/*
+#define OBJ_TYPE_MASK 0xf000000000000000
+#define SYSTEM_OBJ_ID_MARK 0x0fffffff00000000
+*/
+#define OBJ_TYPE_SHIFT 60
+
+typedef enum
+{
+ APFS_TYPE_ANY = 0,
+ APFS_TYPE_SNAP_METADATA = 1,
+ APFS_TYPE_EXTENT = 2,
+ APFS_TYPE_INODE = 3,
+ APFS_TYPE_XATTR = 4,
+ APFS_TYPE_SIBLING_LINK = 5,
+ APFS_TYPE_DSTREAM_ID = 6,
+ APFS_TYPE_CRYPTO_STATE = 7,
+ APFS_TYPE_FILE_EXTENT = 8,
+ APFS_TYPE_DIR_REC = 9,
+ APFS_TYPE_DIR_STATS = 10,
+ APFS_TYPE_SNAP_NAME = 11,
+ APFS_TYPE_SIBLING_MAP = 12,
+ APFS_TYPE_FILE_INFO = 13,
+ APFS_TYPE_MAX_VALID = 13,
+ APFS_TYPE_MAX = 15,
+ APFS_TYPE_INVALID = 15
+} j_obj_types;
+
+
+struct j_key_t
+{
+ UInt64 obj_id_and_type;
+
+ void Parse(const Byte *p) { G64(0, obj_id_and_type) }
+ unsigned GetType() const { return (unsigned)(obj_id_and_type >> OBJ_TYPE_SHIFT); }
+ UInt64 GetID() const { return obj_id_and_type & OBJ_ID_MASK; }
+};
+
+
+
+#define J_DREC_LEN_MASK 0x000003ff
+/*
+#define J_DREC_HASH_MASK 0xfffff400
+#define J_DREC_HASH_SHIFT 10
+*/
+
+static const unsigned k_SizeOf_j_drec_val = 0x12;
+
+struct j_drec_val
+{
+ UInt64 file_id;
+ UInt64 date_added; /* The time that this directory entry was added to the directory.
+ It's not updated when modifying the directory entry for example,
+ by renaming a file without moving it to a different directory. */
+ UInt16 flags;
+
+ // bool IsFlags_File() const { return flags == MY_LIN_DT_REG; }
+ bool IsFlags_Unknown() const { return flags == MY_LIN_DT_UNKNOWN; }
+ bool IsFlags_Dir() const { return flags == MY_LIN_DT_DIR; }
+
+ // uint8_t xfields[];
+ void Parse(const Byte *p)
+ {
+ G64 (0, file_id)
+ G64 (8, date_added)
+ G16 (0x10, flags)
+ }
+};
+
+
+struct CItem
+{
+ // j_key_t hdr;
+ UInt64 ParentId;
+ AString Name;
+ j_drec_val Val;
+
+ unsigned ParentItemIndex;
+ unsigned RefIndex;
+ // unsigned iNode_Index;
+
+ void Clear()
+ {
+ Name.Empty();
+ ParentItemIndex = VI_MINUS1;
+ RefIndex = VI_MINUS1;
+ }
+};
+
+
+/*
+#define INVALID_INO_NUM 0
+#define ROOT_DIR_PARENT 1 // parent for "root" and "private-dir", there's no inode on disk with this inode number.
+*/
+#define ROOT_DIR_INO_NUM 2 // "root" - parent for all main files
+#define PRIV_DIR_INO_NUM 3 // "private-dir"
+/*
+#define SNAP_DIR_INO_NUM 6 // the directory where snapshot metadata is stored. Snapshot inodes are stored in the snapshot metedata tree.
+#define PURGEABLE_DIR_INO_NUM 7
+#define MIN_USER_INO_NUM 16
+
+#define UNIFIED_ID_SPACE_MARK 0x0800000000000000
+*/
+
+//typedef enum
+// {
+/*
+INODE_IS_APFS_PRIVATE = 0x00000001,
+INODE_MAINTAIN_DIR_STATS = 0x00000002,
+INODE_DIR_STATS_ORIGIN = 0x00000004,
+INODE_PROT_CLASS_EXPLICIT = 0x00000008,
+INODE_WAS_CLONED = 0x00000010,
+INODE_FLAG_UNUSED = 0x00000020,
+INODE_HAS_SECURITY_EA = 0x00000040,
+INODE_BEING_TRUNCATED = 0x00000080,
+INODE_HAS_FINDER_INFO = 0x00000100,
+INODE_IS_SPARSE = 0x00000200,
+INODE_WAS_EVER_CLONED = 0x00000400,
+INODE_ACTIVE_FILE_TRIMMED = 0x00000800,
+INODE_PINNED_TO_MAIN = 0x00001000,
+INODE_PINNED_TO_TIER2 = 0x00002000,
+*/
+// INODE_HAS_RSRC_FORK = 0x00004000,
+/*
+INODE_NO_RSRC_FORK = 0x00008000,
+INODE_ALLOCATION_SPILLEDOVER = 0x00010000,
+INODE_FAST_PROMOTE = 0x00020000,
+*/
+#define INODE_HAS_UNCOMPRESSED_SIZE 0x00040000
+/*
+INODE_IS_PURGEABLE = 0x00080000,
+INODE_WANTS_TO_BE_PURGEABLE = 0x00100000,
+INODE_IS_SYNC_ROOT = 0x00200000,
+INODE_SNAPSHOT_COW_EXEMPTION = 0x00400000,
+
+
+INODE_INHERITED_INTERNAL_FLAGS = \
+ ( INODE_MAINTAIN_DIR_STATS \
+ | INODE_SNAPSHOT_COW_EXEMPTION),
+
+INODE_CLONED_INTERNAL_FLAGS = \
+ ( INODE_HAS_RSRC_FORK \
+ | INODE_NO_RSRC_FORK \
+ | INODE_HAS_FINDER_INFO \
+ | INODE_SNAPSHOT_COW_EXEMPTION),
+*/
+// }
+// j_inode_flags;
+
+
+/*
+#define APFS_VALID_INTERNAL_INODE_FLAGS \
+( INODE_IS_APFS_PRIVATE \
+| INODE_MAINTAIN_DIR_STATS \
+| INODE_DIR_STATS_ORIGIN \
+| INODE_PROT_CLASS_EXPLICIT \
+| INODE_WAS_CLONED \
+| INODE_HAS_SECURITY_EA \
+| INODE_BEING_TRUNCATED \
+| INODE_HAS_FINDER_INFO \
+| INODE_IS_SPARSE \
+| INODE_WAS_EVER_CLONED \
+| INODE_ACTIVE_FILE_TRIMMED \
+| INODE_PINNED_TO_MAIN \
+| INODE_PINNED_TO_TIER2 \
+| INODE_HAS_RSRC_FORK \
+| INODE_NO_RSRC_FORK \
+| INODE_ALLOCATION_SPILLEDOVER \
+| INODE_FAST_PROMOTE \
+| INODE_HAS_UNCOMPRESSED_SIZE \
+| INODE_IS_PURGEABLE \
+| INODE_WANTS_TO_BE_PURGEABLE \
+| INODE_IS_SYNC_ROOT \
+| INODE_SNAPSHOT_COW_EXEMPTION)
+
+#define APFS_INODE_PINNED_MASK (INODE_PINNED_TO_MAIN | INODE_PINNED_TO_TIER2)
+*/
+
+static const char * const g_INODE_Flags[] =
+{
+ "IS_APFS_PRIVATE"
+ , "MAINTAIN_DIR_STATS"
+ , "DIR_STATS_ORIGIN"
+ , "PROT_CLASS_EXPLICIT"
+ , "WAS_CLONED"
+ , "FLAG_UNUSED"
+ , "HAS_SECURITY_EA"
+ , "BEING_TRUNCATED"
+ , "HAS_FINDER_INFO"
+ , "IS_SPARSE"
+ , "WAS_EVER_CLONED"
+ , "ACTIVE_FILE_TRIMMED"
+ , "PINNED_TO_MAIN"
+ , "PINNED_TO_TIER2"
+ , "HAS_RSRC_FORK"
+ , "NO_RSRC_FORK"
+ , "ALLOCATION_SPILLEDOVER"
+ , "FAST_PROMOTE"
+ , "HAS_UNCOMPRESSED_SIZE"
+ , "IS_PURGEABLE"
+ , "WANTS_TO_BE_PURGEABLE"
+ , "IS_SYNC_ROOT"
+ , "SNAPSHOT_COW_EXEMPTION"
+};
+
+
+// bsd stat.h
+/*
+#define MY_UF_SETTABLE 0x0000ffff // mask of owner changeable flags
+#define MY_UF_NODUMP 0x00000001 // do not dump file
+#define MY_UF_IMMUTABLE 0x00000002 // file may not be changed
+#define MY_UF_APPEND 0x00000004 // writes to file may only append
+#define MY_UF_OPAQUE 0x00000008 // directory is opaque wrt. union
+#define MY_UF_NOUNLINK 0x00000010 // file entry may not be removed or renamed Not implement in MacOS
+#define MY_UF_COMPRESSED 0x00000020 // file entry is compressed
+#define MY_UF_TRACKED 0x00000040 // notify about file entry changes
+#define MY_UF_DATAVAULT 0x00000080 // entitlement required for reading and writing
+#define MY_UF_HIDDEN 0x00008000 // file entry is hidden
+
+#define MY_SF_SETTABLE 0xffff0000 // mask of superuser changeable flags
+#define MY_SF_ARCHIVED 0x00010000 // file is archived
+#define MY_SF_IMMUTABLE 0x00020000 // file may not be changed
+#define MY_SF_APPEND 0x00040000 // writes to file may only append
+#define MY_SF_RESTRICTED 0x00080000 // entitlement required for writing
+#define MY_SF_NOUNLINK 0x00100000 // file entry may not be removed, renamed or used as mount point
+#define MY_SF_SNAPSHOT 0x00200000 // snapshot inode
+Not implement in MacOS
+*/
+
+static const char * const g_INODE_BSD_Flags[] =
+{
+ "UF_NODUMP"
+ , "UF_IMMUTABLE"
+ , "UF_APPEND"
+ , "UF_OPAQUE"
+ , "UF_NOUNLINK"
+ , "UF_COMPRESSED"
+ , "UF_TRACKED"
+ , "UF_DATAVAULT"
+ , NULL, NULL, NULL, NULL
+ , NULL, NULL, NULL
+ , "UF_HIDDEN"
+
+ , "SF_ARCHIVE"
+ , "SF_IMMUTABLE"
+ , "SF_APPEND"
+ , "SF_RESTRICTED"
+ , "SF_NOUNLINK"
+ , "SF_SNAPSHOT"
+};
+
+/*
+#define INO_EXT_TYPE_SNAP_XID 1
+#define INO_EXT_TYPE_DELTA_TREE_OID 2
+#define INO_EXT_TYPE_DOCUMENT_ID 3
+*/
+#define INO_EXT_TYPE_NAME 4
+/*
+#define INO_EXT_TYPE_PREV_FSIZE 5
+#define INO_EXT_TYPE_RESERVED_6 6
+#define INO_EXT_TYPE_FINDER_INFO 7
+*/
+#define INO_EXT_TYPE_DSTREAM 8
+/*
+#define INO_EXT_TYPE_RESERVED_9 9
+#define INO_EXT_TYPE_DIR_STATS_KEY 10
+#define INO_EXT_TYPE_FS_UUID 11
+#define INO_EXT_TYPE_RESERVED_12 12
+#define INO_EXT_TYPE_SPARSE_BYTES 13
+#define INO_EXT_TYPE_RDEV 14
+#define INO_EXT_TYPE_PURGEABLE_FLAGS 15
+#define INO_EXT_TYPE_ORIG_SYNC_ROOT_ID 16
+*/
+
+
+static const unsigned k_SizeOf_j_dstream = 8 * 5;
+
+struct j_dstream
+{
+ UInt64 size;
+ UInt64 alloced_size;
+ UInt64 default_crypto_id;
+ UInt64 total_bytes_written;
+ UInt64 total_bytes_read;
+
+ void Parse(const Byte *p)
+ {
+ G64 (0, size)
+ G64 (0x8, alloced_size)
+ G64 (0x10, default_crypto_id)
+ G64 (0x18, total_bytes_written)
+ G64 (0x20, total_bytes_read)
+ }
+};
+
+static const unsigned k_SizeOf_j_file_extent_val = 8 * 3;
+
+#define J_FILE_EXTENT_LEN_MASK 0x00ffffffffffffffU
+// #define J_FILE_EXTENT_FLAG_MASK 0xff00000000000000U
+// #define J_FILE_EXTENT_FLAG_SHIFT 56
+
+#define EXTENT_GET_LEN(x) ((x) & J_FILE_EXTENT_LEN_MASK)
+
+struct j_file_extent_val
+{
+ UInt64 len_and_flags; // The length must be a multiple of the block size defined by the nx_block_size field of nx_superblock_t.
+ // There are currently no flags defined
+ UInt64 phys_block_num; // The physical block address that the extent starts at
+ // UInt64 crypto_id; // The encryption key or the encryption tweak used in this extent.
+
+ void Parse(const Byte *p)
+ {
+ G64 (0, len_and_flags)
+ G64 (0x8, phys_block_num)
+ // G64 (0x10, crypto_id);
+ }
+};
+
+
+struct CExtent
+{
+ UInt64 logical_offset;
+ UInt64 len_and_flags; // The length must be a multiple of the block size defined by the nx_block_size field of nx_superblock_t.
+ // There are currently no flags defined
+ UInt64 phys_block_num; // The physical block address that the extent starts at
+
+ UInt64 GetEndOffset() const { return logical_offset + EXTENT_GET_LEN(len_and_flags); }
+};
+
+
+typedef UInt32 MY_uid_t;
+typedef UInt32 MY_gid_t;
+typedef UInt16 MY_mode_t;
+
+
+typedef enum
+{
+ XATTR_DATA_STREAM = 1 << 0,
+ XATTR_DATA_EMBEDDED = 1 << 1,
+ XATTR_FILE_SYSTEM_OWNED = 1 << 2,
+ XATTR_RESERVED_8 = 1 << 3
+} j_xattr_flags;
+
+
+struct CAttr
+{
+ AString Name;
+ UInt32 flags;
+ bool dstream_defined;
+ bool NeedShow;
+ CByteBuffer Data;
+
+ j_dstream dstream;
+ UInt64 Id;
+
+ bool Is_dstream_OK_for_SymLink() const
+ {
+ return dstream_defined && dstream.size <= (1 << 12) && dstream.size != 0;
+ }
+
+ UInt64 GetSize() const
+ {
+ if (dstream_defined) // dstream has more priority
+ return dstream.size;
+ return Data.Size();
+ }
+
+ void Clear()
+ {
+ dstream_defined = false;
+ NeedShow = true;
+ Data.Free();
+ Name.Empty();
+ }
+
+ bool Is_STREAM() const { return (flags & XATTR_DATA_STREAM) != 0; }
+ bool Is_EMBEDDED() const { return (flags & XATTR_DATA_EMBEDDED) != 0; }
+};
+
+
+// j_inode_val_t
+struct CNode
+{
+ unsigned ItemIndex; // index to CItem. We set it only if Node is directory.
+ unsigned NumCalcedLinks; // Num links to that node
+ // unsigned NumItems; // Num Items in that node
+
+ UInt64 parent_id; // The identifier of the file system record for the parent directory.
+ UInt64 private_id;
+ UInt64 create_time;
+ UInt64 mod_time;
+ UInt64 change_time;
+ UInt64 access_time;
+ UInt64 internal_flags;
+ union
+ {
+ UInt32 nchildren; /* The number of directory entries.
+ is valid only if the inode is a directory */
+ UInt32 nlink; /* The number of hard links whose target is this inode.
+ is valid only if the inode isn't a directory.
+ Inodes with multiple hard links (nlink > 1)
+ - The parent_id field refers to the parent directory of the primary link.
+ - The name field contains the name of the primary link.
+ - The INO_EXT_TYPE_NAME extended field contains the name of this link.
+ */
+ };
+ // cp_key_class_t default_protection_class;
+ UInt32 write_generation_counter;
+ UInt32 bsd_flags;
+ MY_uid_t owner;
+ MY_gid_t group;
+ MY_mode_t mode;
+ UInt16 pad1;
+ UInt64 uncompressed_size;
+
+ j_dstream dstream;
+ AString PrimaryName;
+
+ bool dstream_defined;
+ bool refcnt_defined;
+
+ UInt32 refcnt; // j_dstream_id_val_t
+ CRecordVector<CExtent> Extents;
+ CObjectVector<CAttr> Attrs;
+ unsigned SymLinkIndex; // index in Attrs
+ unsigned DecmpfsIndex; // index in Attrs
+ unsigned ResourceIndex; // index in Attrs
+
+ NHfs::CCompressHeader CompressHeader;
+
+ CNode():
+ ItemIndex(VI_MINUS1),
+ NumCalcedLinks(0),
+ // NumItems(0),
+ dstream_defined(false),
+ refcnt_defined(false),
+ SymLinkIndex(VI_MINUS1),
+ DecmpfsIndex(VI_MINUS1),
+ ResourceIndex(VI_MINUS1)
+ {}
+
+ bool IsDir() const { return MY_LIN_S_ISDIR(mode); }
+ bool IsSymLink() const { return MY_LIN_S_ISLNK(mode); }
+
+ bool Has_UNCOMPRESSED_SIZE() const { return (internal_flags & INODE_HAS_UNCOMPRESSED_SIZE) != 0; }
+
+ unsigned Get_Type_From_mode() const { return mode >> 12; }
+
+ bool GetSize(unsigned attrIndex, UInt64 &size) const
+ {
+ if (IsViNotDef(attrIndex))
+ {
+ if (dstream_defined)
+ {
+ size = dstream.size;
+ return true;
+ }
+ size = 0;
+ if (Has_UNCOMPRESSED_SIZE())
+ {
+ size = uncompressed_size;
+ return true;
+ }
+ if (!IsSymLink())
+ return false;
+ attrIndex = SymLinkIndex;
+ if (IsViNotDef(attrIndex))
+ return false;
+ }
+ const CAttr &attr = Attrs[(unsigned)attrIndex];
+ if (attr.dstream_defined)
+ size = attr.dstream.size;
+ else
+ size = attr.Data.Size();
+ return true;
+ }
+
+ bool GetPackSize(unsigned attrIndex, UInt64 &size) const
+ {
+ if (IsViNotDef(attrIndex))
+ {
+ if (dstream_defined)
+ {
+ size = dstream.alloced_size;
+ return true;
+ }
+ size = 0;
+
+ if (IsSymLink())
+ attrIndex = SymLinkIndex;
+ else
+ {
+ if (!CompressHeader.IsCorrect ||
+ !CompressHeader.IsSupported)
+ return false;
+ const CAttr &attr = Attrs[DecmpfsIndex];
+ if (!CompressHeader.IsMethod_Resource())
+ {
+ size = attr.Data.Size() - CompressHeader.DataPos;
+ return true;
+ }
+ attrIndex = ResourceIndex;
+ }
+ if (IsViNotDef(attrIndex))
+ return false;
+ }
+ const CAttr &attr = Attrs[(unsigned)attrIndex];
+ if (attr.dstream_defined)
+ size = attr.dstream.alloced_size;
+ else
+ size = attr.Data.Size();
+ return true;
+ }
+
+ void Parse(const Byte *p);
+};
+
+
+// it's used for Attr streams
+struct CSmallNode
+{
+ CRecordVector<CExtent> Extents;
+ // UInt32 NumLinks;
+ // CSmallNode(): NumLinks(0) {}
+};
+
+static const unsigned k_SizeOf_j_inode_val = 0x5c;
+
+void CNode::Parse(const Byte *p)
+{
+ G64 (0, parent_id)
+ G64 (0x8, private_id)
+ G64 (0x10, create_time)
+ G64 (0x18, mod_time)
+ G64 (0x20, change_time)
+ G64 (0x28, access_time)
+ G64 (0x30, internal_flags)
+ {
+ G32 (0x38, nchildren)
+ // G32 (0x38, nlink);
+ }
+ // G32 (0x3c, default_protection_class);
+ G32 (0x40, write_generation_counter)
+ G32 (0x44, bsd_flags)
+ G32 (0x48, owner)
+ G32 (0x4c, group)
+ G16 (0x50, mode)
+ // G16 (0x52, pad1);
+ G64 (0x54, uncompressed_size)
+}
+
+
+struct CRef
+{
+ unsigned ItemIndex;
+ unsigned NodeIndex;
+ unsigned ParentRefIndex;
+
+ #ifdef APFS_SHOW_ALT_STREAMS
+ unsigned AttrIndex;
+ bool IsAltStream() const { return IsViDef(AttrIndex); }
+ unsigned GetAttrIndex() const { return AttrIndex; }
+ #else
+ // bool IsAltStream() const { return false; }
+ unsigned GetAttrIndex() const { return VI_MINUS1; }
+ #endif
+};
+
+
+struct CRef2
+{
+ unsigned VolIndex;
+ unsigned RefIndex;
+};
+
+
+struct CHashChunk
+{
+ UInt64 lba;
+ UInt32 hashed_len; // the value is UInt16
+ Byte hash[APFS_HASH_MAX_SIZE];
+};
+
+typedef CRecordVector<CHashChunk> CStreamHashes;
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithHash
+ , ISequentialOutStream
+)
+ bool _hashError;
+ CAlignedBuffer1 _sha;
+ CMyComPtr<ISequentialOutStream> _stream;
+ const CStreamHashes *_hashes;
+ unsigned _blockSizeLog;
+ unsigned _chunkIndex;
+ UInt32 _offsetInChunk;
+ // UInt64 _size;
+
+ CSha256 *Sha() { return (CSha256 *)(void *)(Byte *)_sha; }
+public:
+ COutStreamWithHash(): _sha(sizeof(CSha256)) {}
+
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ // void ReleaseStream() { _stream.Release(); }
+ void Init(const CStreamHashes *hashes, unsigned blockSizeLog)
+ {
+ _hashes = hashes;
+ _blockSizeLog = blockSizeLog;
+ _chunkIndex = 0;
+ _offsetInChunk = 0;
+ _hashError = false;
+ // _size = 0;
+ }
+ // UInt64 GetSize() const { return _size; }
+ bool FinalCheck();
+};
+
+
+static bool Sha256_Final_and_CheckDigest(CSha256 *sha256, const Byte *digest)
+{
+ MY_ALIGN (16)
+ UInt32 temp[SHA256_NUM_DIGEST_WORDS];
+ Sha256_Final(sha256, (Byte *)temp);
+ return memcmp(temp, digest, SHA256_DIGEST_SIZE) == 0;
+}
+
+
+Z7_COM7F_IMF(COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ if (processedSize)
+ *processedSize = size;
+ while (size != 0)
+ {
+ if (_hashError)
+ break;
+ if (_chunkIndex >= _hashes->Size())
+ {
+ _hashError = true;
+ break;
+ }
+ if (_offsetInChunk == 0)
+ Sha256_Init(Sha());
+ const CHashChunk &chunk = (*_hashes)[_chunkIndex];
+ /* (_blockSizeLog <= 16) && chunk.hashed_len is 16-bit.
+ so we can use 32-bit chunkSize here */
+ const UInt32 chunkSize = ((UInt32)chunk.hashed_len << _blockSizeLog);
+ const UInt32 rem = chunkSize - _offsetInChunk;
+ UInt32 cur = size;
+ if (cur > rem)
+ cur = (UInt32)rem;
+ Sha256_Update(Sha(), (const Byte *)data, cur);
+ data = (const void *)((const Byte *)data + cur);
+ size -= cur;
+ // _size += cur;
+ _offsetInChunk += cur;
+ if (chunkSize == _offsetInChunk)
+ {
+ if (!Sha256_Final_and_CheckDigest(Sha(), chunk.hash))
+ _hashError = true;
+ _offsetInChunk = 0;
+ _chunkIndex++;
+ }
+ }
+ return result;
+}
+
+
+bool COutStreamWithHash::FinalCheck()
+{
+ if (_hashError)
+ return false;
+
+ if (_offsetInChunk != 0)
+ {
+ const CHashChunk &chunk = (*_hashes)[_chunkIndex];
+ {
+ const UInt32 chunkSize = ((UInt32)chunk.hashed_len << _blockSizeLog);
+ const UInt32 rem = chunkSize - _offsetInChunk;
+ Byte b = 0;
+ for (UInt32 i = 0; i < rem; i++)
+ Sha256_Update(Sha(), &b, 1);
+ }
+ if (!Sha256_Final_and_CheckDigest(Sha(), chunk.hash))
+ _hashError = true;
+ _offsetInChunk = 0;
+ _chunkIndex++;
+ }
+ if (_chunkIndex != _hashes->Size())
+ _hashError = true;
+ return !_hashError;
+}
+
+
+
+struct CVol
+{
+ CObjectVector<CNode> Nodes;
+ CRecordVector<UInt64> NodeIDs;
+ CObjectVector<CItem> Items;
+ CRecordVector<CRef> Refs;
+
+ CObjectVector<CSmallNode> SmallNodes;
+ CRecordVector<UInt64> SmallNodeIDs;
+
+ CObjectVector<CSmallNode> FEXT_Nodes;
+ CRecordVector<UInt64> FEXT_NodeIDs;
+
+ CObjectVector<CStreamHashes> Hash_Vectors;
+ CRecordVector<UInt64> Hash_IDs;
+
+ unsigned StartRef2Index; // ref2_Index for Refs[0] item
+ unsigned RootRef2Index; // ref2_Index of virtual root folder (Volume1)
+ CApfs apfs;
+ C_integrity_meta_phys integrity;
+
+ bool NodeNotFound;
+ bool ThereAreUnlinkedNodes;
+ bool WrongInodeLink;
+ bool UnsupportedFeature;
+ bool UnsupportedMethod;
+
+ unsigned NumItems_In_PrivateDir;
+ unsigned NumAltStreams;
+
+ UString RootName;
+
+ bool ThereAreErrors() const
+ {
+ return NodeNotFound || ThereAreUnlinkedNodes || WrongInodeLink;
+ }
+
+ void AddComment(UString &s) const;
+
+ HRESULT FillRefs();
+
+ CVol():
+ StartRef2Index(0),
+ RootRef2Index(VI_MINUS1),
+ NodeNotFound(false),
+ ThereAreUnlinkedNodes(false),
+ WrongInodeLink(false),
+ UnsupportedFeature(false),
+ UnsupportedMethod(false),
+ NumItems_In_PrivateDir(0),
+ NumAltStreams(0)
+ {}
+};
+
+
+static void ApfsTimeToFileTime(UInt64 apfsTime, FILETIME &ft, UInt32 &ns100)
+{
+ const UInt64 s = apfsTime / 1000000000;
+ const UInt32 ns = (UInt32)(apfsTime % 1000000000);
+ ns100 = (ns % 100);
+ const UInt64 v = NWindows::NTime::UnixTime64_To_FileTime64((Int64)s) + ns / 100;
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+static void AddComment_Name(UString &s, const char *name)
+{
+ s += name;
+ s += ": ";
+}
+
+/*
+static void AddComment_Bool(UString &s, const char *name, bool val)
+{
+ AddComment_Name(s, name);
+ s += val ? "+" : "-";
+ s.Add_LF();
+}
+*/
+
+static void AddComment_UInt64(UString &s, const char *name, UInt64 v)
+{
+ AddComment_Name(s, name);
+ s.Add_UInt64(v);
+ s.Add_LF();
+}
+
+
+static void AddComment_Time(UString &s, const char *name, UInt64 v)
+{
+ AddComment_Name(s, name);
+
+ FILETIME ft;
+ UInt32 ns100;
+ ApfsTimeToFileTime(v, ft, ns100);
+ char temp[64];
+ ConvertUtcFileTimeToString2(ft, ns100, temp
+ // , kTimestampPrintLevel_SEC);
+ , kTimestampPrintLevel_NS);
+ s += temp;
+ s.Add_LF();
+}
+
+
+static void AddComment_modified_by_t(UString &s, const char *name, const apfs_modified_by_t &v)
+{
+ AddComment_Name(s, name);
+ AString s2;
+ s2.SetFrom_CalcLen((const char *)v.id, sizeof(v.id));
+ s += s2;
+ s.Add_LF();
+ s += " ";
+ AddComment_Time(s, "timestamp", v.timestamp);
+ s += " ";
+ AddComment_UInt64(s, "last_xid", v.last_xid);
+}
+
+
+static void AddVolInternalName_toString(UString &s, const CApfs &apfs)
+{
+ AString temp;
+ temp.SetFrom_CalcLen((const char *)apfs.volname, sizeof(apfs.volname));
+ UString unicode;
+ ConvertUTF8ToUnicode(temp, unicode);
+ s += unicode;
+}
+
+
+void CVol::AddComment(UString &s) const
+{
+ AddComment_UInt64(s, "fs_index", apfs.fs_index);
+ {
+ AddComment_Name(s, "volume_name");
+ AddVolInternalName_toString(s, apfs);
+ s.Add_LF();
+ }
+ AddComment_Name(s, "vol_uuid");
+ apfs.vol_uuid.AddHexToString(s);
+ s.Add_LF();
+
+ AddComment_Name(s, "incompatible_features");
+ s += FlagsToString(g_APFS_INCOMPAT_Flags,
+ Z7_ARRAY_SIZE(g_APFS_INCOMPAT_Flags),
+ (UInt32)apfs.incompatible_features);
+ s.Add_LF();
+
+
+ if (apfs.integrity_meta_oid != 0)
+ {
+ /*
+ AddComment_Name(s, "im_version");
+ s.Add_UInt32(integrity.im_version);
+ s.Add_LF();
+ */
+ AddComment_Name(s, "im_flags");
+ s.Add_UInt32(integrity.im_flags);
+ s.Add_LF();
+ AddComment_Name(s, "im_hash_type");
+ const char *p = NULL;
+ if (integrity.im_hash_type < Z7_ARRAY_SIZE(g_hash_types))
+ p = g_hash_types[integrity.im_hash_type];
+ if (p)
+ s += p;
+ else
+ s.Add_UInt32(integrity.im_hash_type);
+ s.Add_LF();
+ }
+
+
+ // AddComment_UInt64(s, "reserve_block_count", apfs.fs_reserve_block_count, false);
+ // AddComment_UInt64(s, "quota_block_count", apfs.fs_quota_block_count);
+ AddComment_UInt64(s, "fs_alloc_count", apfs.fs_alloc_count);
+
+ AddComment_UInt64(s, "num_files", apfs.num_files);
+ AddComment_UInt64(s, "num_directories", apfs.num_directories);
+ AddComment_UInt64(s, "num_symlinks", apfs.num_symlinks);
+ AddComment_UInt64(s, "num_other_fsobjects", apfs.num_other_fsobjects);
+
+ AddComment_UInt64(s, "Num_Attr_Streams", NumAltStreams);
+
+ AddComment_UInt64(s, "num_snapshots", apfs.num_snapshots);
+ AddComment_UInt64(s, "total_blocks_alloced", apfs.total_blocks_alloced);
+ AddComment_UInt64(s, "total_blocks_freed", apfs.total_blocks_freed);
+
+ AddComment_Time(s, "unmounted", apfs.unmount_time);
+ AddComment_Time(s, "last_modified", apfs.last_mod_time);
+ AddComment_modified_by_t(s, "formatted_by", apfs.formatted_by);
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(apfs.modified_by); i++)
+ {
+ const apfs_modified_by_t &v = apfs.modified_by[i];
+ if (v.last_xid == 0 && v.timestamp == 0 && v.id[0] == 0)
+ continue;
+ AString name ("modified_by[");
+ name.Add_UInt32(i);
+ name += ']';
+ AddComment_modified_by_t(s, name.Ptr(), v);
+ }
+}
+
+
+
+struct CKeyValPair
+{
+ CByteBuffer Key;
+ CByteBuffer Val;
+ // unsigned ValPos; // for alognment
+};
+
+
+struct omap_key
+{
+ oid_t oid; // The object identifier
+ xid_t xid; // The transaction identifier
+ void Parse(const Byte *p)
+ {
+ G64o (0, oid)
+ G64x (8, xid)
+ }
+};
+
+/*
+#define OMAP_VAL_DELETED (1 << 0)
+#define OMAP_VAL_SAVED (1 << 1)
+#define OMAP_VAL_ENCRYPTED (1 << 2)
+*/
+#define OMAP_VAL_NOHEADER (1 << 3)
+/*
+#define OMAP_VAL_CRYPTO_GENERATION (1 << 4)
+*/
+
+struct omap_val
+{
+ UInt32 flags;
+ UInt32 size;
+ // paddr_t paddr;
+ paddr_t_unsigned paddr;
+
+ bool IsFlag_NoHeader() const { return (flags & OMAP_VAL_NOHEADER) != 0; }
+
+ void Parse(const Byte *p)
+ {
+ G32 (0, flags)
+ G32 (4, size)
+ G64 (8, paddr)
+ }
+};
+
+
+struct CObjectMap
+{
+ CRecordVector<UInt64> Keys;
+ CRecordVector<omap_val> Vals;
+
+ bool Parse(const CObjectVector<CKeyValPair> &pairs);
+ int FindKey(UInt64 id) const { return Keys.FindInSorted(id); }
+};
+
+bool CObjectMap::Parse(const CObjectVector<CKeyValPair> &pairs)
+{
+ omap_key prev;
+ prev.oid = 0;
+ prev.xid = 0;
+ FOR_VECTOR (i, pairs)
+ {
+ const CKeyValPair &pair = pairs[i];
+ if (pair.Key.Size() != 16 || pair.Val.Size() != 16)
+ return false;
+ omap_key key;
+ key.Parse(pair.Key);
+ omap_val val;
+ val.Parse(pair.Val);
+ /* Object map B-trees are sorted by object identifier and then by transaction identifier
+ but it's possible to have identical Ids in map ?
+ do we need to look transaction id ?
+ and search key with largest transaction id? */
+ if (key.oid <= prev.oid)
+ return false;
+ prev = key;
+ Keys.Add(key.oid);
+ Vals.Add(val);
+ }
+ return true;
+}
+
+
+struct CMap
+{
+ CObjectVector<CKeyValPair> Pairs;
+
+ CObjectMap Omap;
+ btree_info bti;
+ UInt64 NumNodes;
+
+ // we use thnese options to check:
+ UInt32 Subtype;
+ bool IsPhysical;
+
+ bool CheckAtFinish() const
+ {
+ return NumNodes == bti.node_count && Pairs.Size() == bti.key_count;
+ }
+
+ CMap():
+ NumNodes(0),
+ Subtype(0),
+ IsPhysical(true)
+ {}
+};
+
+
+
+struct CDatabase
+{
+ CRecordVector<CRef2> Refs2;
+ CObjectVector<CVol> Vols;
+
+ bool HeadersError;
+ bool ThereAreAltStreams;
+ bool UnsupportedFeature;
+ bool UnsupportedMethod;
+
+ CSuperBlock sb;
+
+ IInStream *OpenInStream;
+ IArchiveOpenCallback *OpenCallback;
+ UInt64 ProgressVal_Cur;
+ UInt64 ProgressVal_Prev;
+ UInt64 ProgressVal_NumFilesTotal;
+ CObjectVector<CByteBuffer> Buffers;
+
+ UInt32 MethodsMask;
+ UInt64 GetSize(const UInt32 index) const;
+
+ void Clear()
+ {
+ HeadersError = false;
+ ThereAreAltStreams = false;
+ UnsupportedFeature = false;
+ UnsupportedMethod = false;
+
+ ProgressVal_Cur = 0;
+ ProgressVal_Prev = 0;
+ ProgressVal_NumFilesTotal = 0;
+
+ MethodsMask = 0;
+
+ Vols.Clear();
+ Refs2.Clear();
+ Buffers.Clear();
+ }
+
+ HRESULT SeekReadBlock_FALSE(UInt64 oid, void *data);
+ void GetItemPath(unsigned index, const CNode *inode, NWindows::NCOM::CPropVariant &path) const;
+ HRESULT ReadMap(UInt64 oid, bool noHeader, CVol *vol, const Byte *hash,
+ CMap &map, unsigned recurseLevel);
+ HRESULT ReadObjectMap(UInt64 oid, CVol *vol, CObjectMap &map);
+ HRESULT OpenVolume(const CObjectMap &omap, const oid_t fs_oid);
+ HRESULT Open2();
+
+ HRESULT GetAttrStream(IInStream *apfsInStream, const CVol &vol,
+ const CAttr &attr, ISequentialInStream **stream);
+
+ HRESULT GetAttrStream_dstream(IInStream *apfsInStream, const CVol &vol,
+ const CAttr &attr, ISequentialInStream **stream);
+
+ HRESULT GetStream2(
+ IInStream *apfsInStream,
+ const CRecordVector<CExtent> *extents, UInt64 rem,
+ ISequentialInStream **stream);
+};
+
+
+HRESULT CDatabase::SeekReadBlock_FALSE(UInt64 oid, void *data)
+{
+ if (OpenCallback)
+ {
+ if (ProgressVal_Cur - ProgressVal_Prev >= (1 << 22))
+ {
+ RINOK(OpenCallback->SetCompleted(NULL, &ProgressVal_Cur))
+ ProgressVal_Prev = ProgressVal_Cur;
+ }
+ ProgressVal_Cur += sb.block_size;
+ }
+ if (oid == 0 || oid >= sb.block_count)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(OpenInStream, oid << sb.block_size_Log))
+ return ReadStream_FALSE(OpenInStream, data, sb.block_size);
+}
+
+
+
+API_FUNC_static_IsArc IsArc_APFS(const Byte *p, size_t size)
+{
+ if (size < kApfsHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ CSuperBlock sb;
+ if (!sb.Parse(p))
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+
+static bool CheckHash(unsigned hashAlgo, const Byte *data, size_t size, const Byte *digest)
+{
+ if (hashAlgo == APFS_HASH_SHA256)
+ {
+ MY_ALIGN (16)
+ CSha256 sha;
+ Sha256_Init(&sha);
+ Sha256_Update(&sha, data, size);
+ return Sha256_Final_and_CheckDigest(&sha, digest);
+ }
+ return true;
+}
+
+
+HRESULT CDatabase::ReadMap(UInt64 oid, bool noHeader,
+ CVol *vol, const Byte *hash,
+ CMap &map, unsigned recurseLevel)
+{
+ // is it allowed to use big number of levels ?
+ if (recurseLevel > (1 << 10))
+ return S_FALSE;
+
+ const UInt32 blockSize = sb.block_size;
+ if (Buffers.Size() <= recurseLevel)
+ {
+ Buffers.AddNew();
+ if (Buffers.Size() <= recurseLevel)
+ throw 123;
+ Buffers.Back().Alloc(blockSize);
+ }
+ const Byte *buf;
+ {
+ CByteBuffer &buf2 = Buffers[recurseLevel];
+ RINOK(SeekReadBlock_FALSE(oid, buf2))
+ buf = buf2;
+ }
+
+ if (hash && vol)
+ if (!CheckHash(vol->integrity.im_hash_type, buf, blockSize, hash))
+ return S_FALSE;
+
+ CBTreeNodePhys bt;
+ if (!bt.Parse(buf, blockSize, noHeader))
+ return S_FALSE;
+
+ map.NumNodes++;
+
+ /* Specification: All values are stored in leaf nodes, which
+ makes these B+ trees, and the values in nonleaf nodes are object
+ identifiers of child nodes.
+
+ The entries in the table of contents are sorted by key. The comparison function used for sorting depends on the keys type
+ - Object map B-trees are sorted by object identifier and then by transaction identifier.
+ - Free queue B-trees are sorted by transaction identifier and then by physical address.
+ - File-system records are sorted according to the rules listed in File-System Objects.
+ */
+
+ if (!noHeader)
+ if (bt.ophys.subtype != map.Subtype)
+ return S_FALSE;
+
+ unsigned endLimit = blockSize;
+
+ if (recurseLevel == 0)
+ {
+ if (!noHeader)
+ if (bt.ophys.GetType() != OBJECT_TYPE_BTREE)
+ return S_FALSE;
+ if ((bt.flags & BTNODE_ROOT) == 0)
+ return S_FALSE;
+ endLimit -= k_btree_info_Size;
+ map.bti.Parse(buf + endLimit);
+ btree_info &bti = map.bti;
+ if (bti.fixed.key_size >= blockSize)
+ return S_FALSE;
+ if (bti.Is_EPHEMERAL() &&
+ bti.Is_PHYSICAL())
+ return S_FALSE;
+ if (bti.Is_PHYSICAL() != map.IsPhysical)
+ return S_FALSE;
+ if (bti.Is_NOHEADER() != noHeader)
+ return S_FALSE;
+ // we don't allow volumes with big number of Keys
+ const UInt32 kNumItemsMax = k_VectorSizeMax;
+ if (map.bti.node_count > kNumItemsMax)
+ return S_FALSE;
+ if (map.bti.key_count > kNumItemsMax)
+ return S_FALSE;
+ }
+ else
+ {
+ if (!noHeader)
+ if (bt.ophys.GetType() != OBJECT_TYPE_BTREE_NODE)
+ return S_FALSE;
+ if ((bt.flags & BTNODE_ROOT) != 0)
+ return S_FALSE;
+ if (map.NumNodes > map.bti.node_count
+ || map.Pairs.Size() > map.bti.key_count)
+ return S_FALSE;
+ }
+
+ const bool isLeaf = (bt.flags & BTNODE_LEAF) != 0;
+
+ if (isLeaf)
+ {
+ if (bt.level != 0)
+ return S_FALSE;
+ }
+ else
+ {
+ if (bt.level == 0)
+ return S_FALSE;
+ }
+
+ if (!bt.table_space.CheckOverLimit(endLimit - k_Toc_offset))
+ return S_FALSE;
+
+ const unsigned tableEnd = k_Toc_offset + bt.table_space.GetEnd();
+ const unsigned keyValRange = endLimit - tableEnd;
+ const unsigned tocEntrySize = bt.Is_FIXED_KV_SIZE() ? 4 : 8;
+ if (bt.table_space.len / tocEntrySize < bt.nkeys)
+ return S_FALSE;
+
+ for (unsigned i = 0; i < bt.nkeys; i++)
+ {
+ const Byte *p = buf + k_Toc_offset + bt.table_space.off + i * tocEntrySize;
+ if (bt.Is_FIXED_KV_SIZE())
+ {
+ kvoff a;
+ a.Parse(p);
+ if (a.k + map.bti.fixed.key_size > keyValRange
+ || a.v > keyValRange)
+ return S_FALSE;
+ {
+ CKeyValPair pair;
+
+ const Byte *p2 = buf + k_Toc_offset + bt.table_space.len;
+ p2 += a.k;
+ pair.Key.CopyFrom(p2, map.bti.fixed.key_size);
+
+ p2 = buf + endLimit;
+ p2 -= a.v;
+ if (isLeaf)
+ {
+ if (a.v < map.bti.fixed.val_size)
+ return S_FALSE;
+ pair.Val.CopyFrom(p2, map.bti.fixed.val_size);
+ // pair.ValPos = endLimit - a.v;
+ map.Pairs.Add(pair);
+ continue;
+ }
+ {
+ if (a.v < 8)
+ return S_FALSE;
+ // value is only 64-bit for non leaf.
+ const oid_t oidNext = Get64(p2);
+ if (map.bti.Is_PHYSICAL())
+ {
+ RINOK(ReadMap(oidNext, noHeader, vol,
+ NULL, /* hash */
+ map, recurseLevel + 1))
+ continue;
+ }
+ else
+ {
+ // fixme
+ return S_FALSE;
+ }
+ }
+ }
+ }
+ else
+ {
+ kvloc a;
+ a.Parse(p);
+ if (!a.k.CheckOverLimit(keyValRange)
+ || a.v.off > keyValRange
+ || a.v.len > a.v.off)
+ return S_FALSE;
+ {
+ CKeyValPair pair;
+ const Byte *p2 = buf + k_Toc_offset + bt.table_space.len;
+ p2 += a.k.off;
+ pair.Key.CopyFrom(p2, a.k.len);
+
+ p2 = buf + endLimit;
+ p2 -= a.v.off;
+ if (isLeaf)
+ {
+ pair.Val.CopyFrom(p2, a.v.len);
+ // pair.ValPos = endLimit - a.v.off;
+ map.Pairs.Add(pair);
+ continue;
+ }
+ {
+ if (a.v.len < 8)
+ return S_FALSE;
+
+ const Byte *hashNew = NULL;
+ oid_t oidNext = Get64(p2);
+
+ if (bt.Is_HASHED())
+ {
+ if (!vol)
+ return S_FALSE;
+ /*
+ struct btn_index_node_val {
+ oid_t binv_child_oid;
+ uint8_t binv_child_hash[BTREE_NODE_HASH_SIZE_MAX];
+ };
+ */
+ /* (a.v.len == 40) is possible if Is_HASHED()
+ so there is hash (for example, 256-bit) after 64-bit id) */
+ if (a.v.len != 8 + vol->integrity.HashSize)
+ return S_FALSE;
+ hashNew = p2 + 8;
+ /* we need to add root_tree_oid here,
+ but where it's defined in apfs specification ? */
+ oidNext += vol->apfs.root_tree_oid;
+ }
+ else
+ {
+ if (a.v.len != 8)
+ return S_FALSE;
+ }
+
+ // value is only 64-bit for non leaf.
+
+ if (map.bti.Is_PHYSICAL())
+ {
+ return S_FALSE;
+ // the code was not tested:
+ // RINOK(ReadMap(oidNext, map, recurseLevel + 1));
+ // continue;
+ }
+ /*
+ else if (map.bti.Is_EPHEMERAL())
+ {
+ // Ephemeral objects are stored in memory while the container is mounted and in a checkpoint when the container isn't mounted
+ // the code was not tested:
+ return S_FALSE;
+ }
+ */
+ else
+ {
+ /* nodes in the B-tree use virtual object identifiers to link to their child nodes. */
+ const int index = map.Omap.FindKey(oidNext);
+ if (index == -1)
+ return S_FALSE;
+ const omap_val &ov = map.Omap.Vals[(unsigned)index];
+ if (ov.size != blockSize) // change it : it must be multiple of
+ return S_FALSE;
+ RINOK(ReadMap(ov.paddr, ov.IsFlag_NoHeader(), vol, hashNew,
+ map, recurseLevel + 1))
+ continue;
+ }
+ }
+ }
+ }
+ }
+
+ if (recurseLevel == 0)
+ if (!map.CheckAtFinish())
+ return S_FALSE;
+ return S_OK;
+}
+
+
+
+HRESULT CDatabase::ReadObjectMap(UInt64 oid, CVol *vol, CObjectMap &omap)
+{
+ CByteBuffer buf;
+ const size_t blockSize = sb.block_size;
+ buf.Alloc(blockSize);
+ RINOK(SeekReadBlock_FALSE(oid, buf))
+ C_omap_phys op;
+ if (!op.Parse(buf, blockSize, oid))
+ return S_FALSE;
+ CMap map;
+ map.Subtype = OBJECT_TYPE_OMAP;
+ map.IsPhysical = true;
+ RINOK(ReadMap(op.tree_oid,
+ false /* noHeader */,
+ vol,
+ NULL, /* hash */
+ map, 0))
+ if (!omap.Parse(map.Pairs))
+ return S_FALSE;
+ return S_OK;
+}
+
+
+
+HRESULT CDatabase::Open2()
+{
+ Clear();
+ CSuperBlock2 sb2;
+ {
+ Byte buf[kApfsHeaderSize];
+ RINOK(ReadStream_FALSE(OpenInStream, buf, kApfsHeaderSize))
+ if (!sb.Parse(buf))
+ return S_FALSE;
+ sb2.Parse(buf);
+ }
+
+ {
+ CObjectMap omap;
+ RINOK(ReadObjectMap(sb.omap_oid,
+ NULL, /* CVol */
+ omap))
+ unsigned numRefs = 0;
+ for (unsigned i = 0; i < sb.max_file_systems; i++)
+ {
+ const oid_t oid = sb2.fs_oid[i];
+ if (oid == 0)
+ continue;
+ // for (unsigned k = 0; k < 1; k++) // for debug
+ RINOK(OpenVolume(omap, oid))
+ const unsigned a = Vols.Back().Refs.Size();
+ numRefs += a;
+ if (numRefs < a)
+ return S_FALSE; // overflow
+ }
+ }
+
+ const bool needVolumePrefix = (Vols.Size() > 1);
+ // const bool needVolumePrefix = true; // for debug
+ {
+ unsigned numRefs = 0;
+ FOR_VECTOR (i, Vols)
+ {
+ const unsigned a = Vols[i].Refs.Size();
+ numRefs += a;
+ if (numRefs < a)
+ return S_FALSE; // overflow
+ }
+ numRefs += Vols.Size();
+ if (numRefs < Vols.Size())
+ return S_FALSE; // overflow
+ Refs2.Reserve(numRefs);
+ }
+ {
+ FOR_VECTOR (i, Vols)
+ {
+ CVol &vol = Vols[i];
+
+ CRef2 ref2;
+ ref2.VolIndex = i;
+
+ if (needVolumePrefix)
+ {
+ vol.RootName = "Volume";
+ vol.RootName.Add_UInt32(1 + (UInt32)i);
+ vol.RootRef2Index = Refs2.Size();
+ ref2.RefIndex = VI_MINUS1;
+ Refs2.Add(ref2);
+ }
+
+ vol.StartRef2Index = Refs2.Size();
+ const unsigned numItems = vol.Refs.Size();
+ for (unsigned k = 0; k < numItems; k++)
+ {
+ ref2.RefIndex = k;
+ Refs2.Add(ref2);
+ }
+ }
+ }
+ return S_OK;
+}
+
+
+HRESULT CDatabase::OpenVolume(const CObjectMap &omap, const oid_t fs_oid)
+{
+ const size_t blockSize = sb.block_size;
+ CByteBuffer buf;
+ {
+ const int index = omap.FindKey(fs_oid);
+ if (index == -1)
+ return S_FALSE;
+ const omap_val &ov = omap.Vals[(unsigned)index];
+ if (ov.size != blockSize) // change it : it must be multiple of
+ return S_FALSE;
+ buf.Alloc(blockSize);
+ RINOK(SeekReadBlock_FALSE(ov.paddr, buf))
+ }
+
+ CVol &vol = Vols.AddNew();
+ CApfs &apfs = vol.apfs;
+
+ if (!apfs.Parse(buf, blockSize))
+ return S_FALSE;
+
+ if (apfs.fext_tree_oid != 0)
+ {
+ if ((apfs.incompatible_features & APFS_INCOMPAT_SEALED_VOLUME) == 0)
+ return S_FALSE;
+ if ((apfs.fext_tree_type & OBJ_PHYSICAL) == 0)
+ return S_FALSE;
+ if ((apfs.fext_tree_type & OBJECT_TYPE_MASK) != OBJECT_TYPE_BTREE)
+ return S_FALSE;
+
+ CMap map2;
+ map2.Subtype = OBJECT_TYPE_FEXT_TREE;
+ map2.IsPhysical = true;
+
+ RINOK(ReadMap(apfs.fext_tree_oid,
+ false /* noHeader */,
+ &vol,
+ NULL, /* hash */
+ map2, 0))
+
+ UInt64 prevId = 1;
+
+ FOR_VECTOR (i, map2.Pairs)
+ {
+ if (OpenCallback && (i & 0xffff) == 1)
+ {
+ const UInt64 numFiles = ProgressVal_NumFilesTotal +
+ (vol.Items.Size() + vol.Nodes.Size()) / 2;
+ RINOK(OpenCallback->SetCompleted(&numFiles, &ProgressVal_Cur))
+ }
+ // The key half of a record from a file extent tree.
+ // struct fext_tree_key
+ const CKeyValPair &pair = map2.Pairs[i];
+ if (pair.Key.Size() != 16)
+ return S_FALSE;
+ const Byte *p = pair.Key;
+ const UInt64 id = GetUi64(p);
+ if (id < prevId)
+ return S_FALSE; // IDs must be sorted
+ prevId = id;
+
+ CExtent ext;
+ ext.logical_offset = GetUi64(p + 8);
+ {
+ if (pair.Val.Size() != 16)
+ return S_FALSE;
+ const Byte *p2 = pair.Val;
+ ext.len_and_flags = GetUi64(p2);
+ ext.phys_block_num = GetUi64(p2 + 8);
+ }
+
+ PRF(printf("\n%6d: id=%6d logical_addr = %2d len_and_flags=%5x phys_block_num = %5d",
+ i, (unsigned)id,
+ (unsigned)ext.logical_offset,
+ (unsigned)ext.len_and_flags,
+ (unsigned)ext.phys_block_num));
+
+ if (vol.FEXT_NodeIDs.IsEmpty() ||
+ vol.FEXT_NodeIDs.Back() != id)
+ {
+ vol.FEXT_NodeIDs.Add(id);
+ vol.FEXT_Nodes.AddNew();
+ }
+ CRecordVector<CExtent> &extents = vol.FEXT_Nodes.Back().Extents;
+ if (!extents.IsEmpty())
+ if (ext.logical_offset != extents.Back().GetEndOffset())
+ return S_FALSE;
+ extents.Add(ext);
+ continue;
+ }
+
+ PRF(printf("\n\n"));
+ }
+
+ /* For each volume, read the root file system tree's virtual object
+ identifier from the apfs_root_tree_oid field,
+ and then look it up in the volume object map indicated
+ by the omap_oid field. */
+
+ CMap map;
+ ReadObjectMap(apfs.omap_oid, &vol, map.Omap);
+
+ const Byte *hash_for_root = NULL;
+
+ if (apfs.integrity_meta_oid != 0)
+ {
+ if ((apfs.incompatible_features & APFS_INCOMPAT_SEALED_VOLUME) == 0)
+ return S_FALSE;
+ const int index = map.Omap.FindKey(apfs.integrity_meta_oid);
+ if (index == -1)
+ return S_FALSE;
+ const omap_val &ov = map.Omap.Vals[(unsigned)index];
+ if (ov.size != blockSize)
+ return S_FALSE;
+ RINOK(SeekReadBlock_FALSE(ov.paddr, buf))
+ if (!vol.integrity.Parse(buf, blockSize, apfs.integrity_meta_oid))
+ return S_FALSE;
+ if (vol.integrity.im_hash_type != 0)
+ hash_for_root = vol.integrity.Hash;
+ }
+
+ {
+ const int index = map.Omap.FindKey(apfs.root_tree_oid);
+ if (index == -1)
+ return S_FALSE;
+ const omap_val &ov = map.Omap.Vals[(unsigned)index];
+ if (ov.size != blockSize) // change it : it must be multiple of
+ return S_FALSE;
+ map.Subtype = OBJECT_TYPE_FSTREE;
+ map.IsPhysical = false;
+ RINOK(ReadMap(ov.paddr, ov.IsFlag_NoHeader(),
+ &vol, hash_for_root,
+ map, 0))
+ }
+
+ bool needParseAttr = false;
+
+ {
+ const bool isHashed = apfs.IsHashedName();
+ UInt64 prevId = 1;
+
+ {
+ const UInt64 numApfsItems = vol.apfs.GetTotalItems()
+ + 2; // we will have 2 additional hidden directories: root and private-dir
+ const UInt64 numApfsItems_Reserve = numApfsItems
+ + 16; // we reserve 16 for some possible unexpected items
+ if (numApfsItems_Reserve < map.Pairs.Size())
+ {
+ vol.Items.ClearAndReserve((unsigned)numApfsItems_Reserve);
+ vol.Nodes.ClearAndReserve((unsigned)numApfsItems_Reserve);
+ vol.NodeIDs.ClearAndReserve((unsigned)numApfsItems_Reserve);
+ }
+ if (OpenCallback)
+ {
+ const UInt64 numFiles = ProgressVal_NumFilesTotal + numApfsItems;
+ RINOK(OpenCallback->SetTotal(&numFiles, NULL))
+ }
+ }
+
+ CAttr attr;
+ CItem item;
+
+ FOR_VECTOR (i, map.Pairs)
+ {
+ if (OpenCallback && (i & 0xffff) == 1)
+ {
+ const UInt64 numFiles = ProgressVal_NumFilesTotal +
+ (vol.Items.Size() + vol.Nodes.Size()) / 2;
+ RINOK(OpenCallback->SetCompleted(&numFiles, &ProgressVal_Cur))
+ }
+
+ const CKeyValPair &pair = map.Pairs[i];
+ j_key_t jkey;
+ if (pair.Key.Size() < 8)
+ return S_FALSE;
+ const Byte *p = pair.Key;
+ jkey.Parse(p);
+ const unsigned type = jkey.GetType();
+ const UInt64 id = jkey.GetID();
+ if (id < prevId)
+ return S_FALSE; // IDs must be sorted
+ prevId = id;
+
+ PRF(printf("\n%6d: id=%6d type = %2d ", i, (unsigned)id, type));
+
+ if (type == APFS_TYPE_INODE)
+ {
+ PRF(printf("INODE"));
+ if (pair.Key.Size() != 8 ||
+ pair.Val.Size() < k_SizeOf_j_inode_val)
+ return S_FALSE;
+
+ CNode inode;
+ inode.Parse(pair.Val);
+
+ if (inode.private_id != id)
+ {
+ /* private_id : The unique identifier used by this file's data stream.
+ This identifier appears in the owning_obj_id field of j_phys_ext_val_t
+ records that describe the extents where the data is stored.
+ For an inode that doesn't have data, the value of this
+ field is the file-system object's identifier.
+ */
+ // APFS_TYPE_EXTENT allow to link physical address extents.
+ // we don't support case (private_id != id)
+ UnsupportedFeature = true;
+ // return S_FALSE;
+ }
+ const UInt32 extraSize = (UInt32)pair.Val.Size() - k_SizeOf_j_inode_val;
+ if (extraSize != 0)
+ {
+ if (extraSize < 4)
+ return S_FALSE;
+ /*
+ struct xf_blob
+ {
+ uint16_t xf_num_exts;
+ uint16_t xf_used_data;
+ uint8_t xf_data[];
+ };
+ */
+ const Byte *p2 = pair.Val + k_SizeOf_j_inode_val;
+ const UInt32 xf_num_exts = Get16(p2);
+ const UInt32 xf_used_data = Get16(p2 + 2);
+ UInt32 offset = 4 + (UInt32)xf_num_exts * 4;
+ if (offset + xf_used_data != extraSize)
+ return S_FALSE;
+
+ PRF(printf(" parent_id = %d", (unsigned)inode.parent_id));
+
+ for (unsigned k = 0; k < xf_num_exts; k++)
+ {
+ // struct x_field
+ const Byte *p3 = p2 + 4 + k * 4;
+ const Byte x_type = p3[0];
+ // const Byte x_flags = p3[1];
+ const UInt32 x_size = Get16(p3 + 2);
+ const UInt32 x_size_ceil = (x_size + 7) & ~(UInt32)7;
+ if (offset + x_size_ceil > extraSize)
+ return S_FALSE;
+ const Byte *p4 = p2 + offset;
+ if (x_type == INO_EXT_TYPE_NAME)
+ {
+ if (x_size < 2)
+ return S_FALSE;
+ inode.PrimaryName.SetFrom_CalcLen((const char *)p4, x_size);
+ PRF(printf(" PrimaryName = %s", inode.PrimaryName.Ptr()));
+ if (inode.PrimaryName.Len() != x_size - 1)
+ HeadersError = true;
+ // return S_FALSE;
+ }
+ else if (x_type == INO_EXT_TYPE_DSTREAM)
+ {
+ if (x_size != k_SizeOf_j_dstream)
+ return S_FALSE;
+ if (inode.dstream_defined)
+ return S_FALSE;
+ inode.dstream.Parse(p4);
+ inode.dstream_defined = true;
+ }
+ else
+ {
+ // UnsupportedFeature = true;
+ // return S_FALSE;
+ }
+ offset += x_size_ceil;
+ }
+ if (offset != extraSize)
+ return S_FALSE;
+ }
+
+ if (!vol.NodeIDs.IsEmpty())
+ if (id <= vol.NodeIDs.Back())
+ return S_FALSE;
+ vol.Nodes.Add(inode);
+ vol.NodeIDs.Add(id);
+ continue;
+ }
+
+ if (type == APFS_TYPE_XATTR)
+ {
+ PRF(printf(" XATTR"));
+
+ /*
+ struct j_xattr_key
+ {
+ j_key_t hdr;
+ uint16_t name_len;
+ uint8_t name[0];
+ }
+ */
+
+ UInt32 len;
+ unsigned nameOffset;
+ {
+ nameOffset = 8 + 2;
+ if (pair.Key.Size() < nameOffset + 1)
+ return S_FALSE;
+ len = Get16(p + 8);
+ }
+ if (nameOffset + len != pair.Key.Size())
+ return S_FALSE;
+
+ attr.Clear();
+ attr.Name.SetFrom_CalcLen((const char *)p + nameOffset, len);
+ if (attr.Name.Len() != len - 1)
+ return S_FALSE;
+
+ PRF(printf(" name=%s", attr.Name.Ptr()));
+
+ const unsigned k_SizeOf_j_xattr_val = 4;
+ if (pair.Val.Size() < k_SizeOf_j_xattr_val)
+ return S_FALSE;
+ /*
+ struct j_xattr_val
+ {
+ uint16_t flags;
+ uint16_t xdata_len;
+ uint8_t xdata[0];
+ }
+ */
+ attr.flags = Get16(pair.Val);
+ const UInt32 xdata_len = Get16(pair.Val + 2);
+
+ PRF(printf(" flags=%x xdata_len = %d",
+ (unsigned)attr.flags,
+ (unsigned)xdata_len));
+
+ const Byte *p4 = pair.Val + 4;
+
+ if (k_SizeOf_j_xattr_val + xdata_len != pair.Val.Size())
+ return S_FALSE;
+ if (attr.Is_EMBEDDED())
+ attr.Data.CopyFrom(p4, xdata_len);
+ else if (attr.Is_STREAM())
+ {
+ // why (attr.flags == 0x11) here? (0x11 is undocummented flag)
+ if (k_SizeOf_j_xattr_val + 8 + k_SizeOf_j_dstream != pair.Val.Size())
+ return S_FALSE;
+ attr.Id = Get64(p4);
+ attr.dstream.Parse(p4 + 8);
+ attr.dstream_defined = true;
+ PRF(printf(" streamID=%d streamSize=%d", (unsigned)attr.Id, (unsigned)attr.dstream.size));
+ }
+ else
+ {
+ // unknown attribute
+ // UnsupportedFeature = true;
+ // return S_FALSE;
+ }
+
+ if (vol.NodeIDs.IsEmpty() ||
+ vol.NodeIDs.Back() != id)
+ {
+ return S_FALSE;
+ // UnsupportedFeature = true;
+ // continue;
+ }
+
+ CNode &inode = vol.Nodes.Back();
+
+ if (attr.Name.IsEqualTo("com.apple.fs.symlink"))
+ {
+ inode.SymLinkIndex = inode.Attrs.Size();
+ if (attr.Is_dstream_OK_for_SymLink())
+ needParseAttr = true;
+ }
+ else if (attr.Name.IsEqualTo("com.apple.decmpfs"))
+ {
+ inode.DecmpfsIndex = inode.Attrs.Size();
+ // if (attr.dstream_defined)
+ needParseAttr = true;
+ }
+ else if (attr.Name.IsEqualTo("com.apple.ResourceFork"))
+ {
+ inode.ResourceIndex = inode.Attrs.Size();
+ }
+ inode.Attrs.Add(attr);
+ continue;
+ }
+
+ if (type == APFS_TYPE_DSTREAM_ID)
+ {
+ PRF(printf(" DSTREAM_ID"));
+ if (pair.Key.Size() != 8)
+ return S_FALSE;
+ // j_dstream_id_val_t
+ if (pair.Val.Size() != 4)
+ return S_FALSE;
+ const UInt32 refcnt = Get32(pair.Val);
+
+ // The data stream record can be deleted when its reference count reaches zero.
+ PRF(printf(" refcnt = %d", (unsigned)refcnt));
+
+ if (vol.NodeIDs.IsEmpty())
+ return S_FALSE;
+
+ if (vol.NodeIDs.Back() != id)
+ {
+ // is it possible ?
+ // continue;
+ return S_FALSE;
+ }
+
+ CNode &inode = vol.Nodes.Back();
+
+ if (inode.refcnt_defined)
+ return S_FALSE;
+
+ inode.refcnt = refcnt;
+ inode.refcnt_defined = true;
+ if (inode.refcnt != (UInt32)inode.nlink)
+ {
+ PRF(printf(" refcnt != nlink"));
+ // is it possible ?
+ // return S_FALSE;
+ }
+ continue;
+ }
+
+ if (type == APFS_TYPE_FILE_EXTENT)
+ {
+ PRF(printf(" FILE_EXTENT"));
+ /*
+ struct j_file_extent_key
+ {
+ j_key_t hdr;
+ uint64_t logical_addr;
+ }
+ */
+ if (pair.Key.Size() != 16)
+ return S_FALSE;
+ // The offset within the file's data, in bytes, for the data stored in this extent
+ const UInt64 logical_addr = Get64(p + 8);
+
+ j_file_extent_val eval;
+ if (pair.Val.Size() != k_SizeOf_j_file_extent_val)
+ return S_FALSE;
+ eval.Parse(pair.Val);
+
+ if (logical_addr != 0)
+ {
+ PRF(printf(" logical_addr = %d", (unsigned)logical_addr));
+ }
+ PRF(printf(" len = %8d pos = %8d",
+ (unsigned)eval.len_and_flags,
+ (unsigned)eval.phys_block_num
+ ));
+
+ CExtent ext;
+ ext.logical_offset = logical_addr;
+ ext.len_and_flags = eval.len_and_flags;
+ ext.phys_block_num = eval.phys_block_num;
+
+ if (vol.NodeIDs.IsEmpty())
+ return S_FALSE;
+ if (vol.NodeIDs.Back() != id)
+ {
+ // extents for Attributs;
+ if (vol.SmallNodeIDs.IsEmpty() ||
+ vol.SmallNodeIDs.Back() != id)
+ {
+ vol.SmallNodeIDs.Add(id);
+ vol.SmallNodes.AddNew();
+ }
+ vol.SmallNodes.Back().Extents.Add(ext);
+ continue;
+ // return S_FALSE;
+ }
+
+ CNode &inode = vol.Nodes.Back();
+ inode.Extents.Add(ext);
+ continue;
+ }
+
+ if (type == APFS_TYPE_DIR_REC)
+ {
+ UInt32 len;
+ unsigned nameOffset;
+
+ if (isHashed)
+ {
+ /*
+ struct j_drec_hashed_key
+ {
+ j_key_t hdr;
+ UInt32 name_len_and_hash;
+ uint8_t name[0];
+ }
+ */
+ nameOffset = 8 + 4;
+ if (pair.Key.Size() < nameOffset + 1)
+ return S_FALSE;
+ const UInt32 name_len_and_hash = Get32(p + 8);
+ len = name_len_and_hash & J_DREC_LEN_MASK;
+ }
+ else
+ {
+ /*
+ struct j_drec_key
+ {
+ j_key_t hdr;
+ UInt16 name_len; // The length of the name, including the final null character
+ uint8_t name[0]; // The name, represented as a null-terminated UTF-8 string
+ }
+ */
+ nameOffset = 8 + 2;
+ if (pair.Key.Size() < nameOffset + 1)
+ return S_FALSE;
+ len = Get16(p + 8);
+ }
+ if (nameOffset + len != pair.Key.Size())
+ return S_FALSE;
+
+ // CItem item;
+ item.Clear();
+
+ item.ParentId = id;
+ item.Name.SetFrom_CalcLen((const char *)p + nameOffset, len);
+ if (item.Name.Len() != len - 1)
+ return S_FALSE;
+
+ if (pair.Val.Size() < k_SizeOf_j_drec_val)
+ return S_FALSE;
+
+ item.Val.Parse(pair.Val);
+
+ if (pair.Val.Size() > k_SizeOf_j_drec_val)
+ {
+ // fixme: parse extra fields;
+ // UnsupportedFeature = true;
+ // return S_FALSE;
+ }
+
+ vol.Items.Add(item);
+
+ /*
+ if (!vol.NodeIDs.IsEmpty() && vol.NodeIDs.Back() == id)
+ vol.Nodes.Back().NumItems++;
+ */
+ if (id == PRIV_DIR_INO_NUM)
+ vol.NumItems_In_PrivateDir++;
+
+ PRF(printf(" DIR_REC next=%6d flags=%2x %s",
+ (unsigned)item.Val.file_id,
+ (unsigned)item.Val.flags,
+ item.Name.Ptr()));
+ continue;
+ }
+
+ if (type == APFS_TYPE_FILE_INFO)
+ {
+ if (pair.Key.Size() != 16)
+ return S_FALSE;
+ // j_file_info_key
+ const UInt64 info_and_lba = Get64(p + 8);
+
+ #define J_FILE_INFO_LBA_MASK 0x00ffffffffffffffUL
+ // #define J_FILE_INFO_TYPE_MASK 0xff00000000000000UL
+ #define J_FILE_INFO_TYPE_SHIFT 56
+ #define APFS_FILE_INFO_DATA_HASH 1
+
+ const unsigned infoType = (unsigned)(info_and_lba >> J_FILE_INFO_TYPE_SHIFT);
+ // address is a paddr_t
+ const UInt64 lba = info_and_lba & J_FILE_INFO_LBA_MASK;
+ // j_file_data_hash_val_t
+ /* Use this field of the union if the type stored in the info_and_lba field of j_file_info_val_t is
+ APFS_FILE_INFO_DATA_HASH */
+ if (infoType != APFS_FILE_INFO_DATA_HASH)
+ return S_FALSE;
+ if (pair.Val.Size() != 3 + vol.integrity.HashSize)
+ return S_FALSE;
+ /*
+ struct j_file_data_hash_val
+ {
+ UInt16 hashed_len; // The length, in blocks, of the data segment that was hashed.
+ UInt8 hash_size; // must be consistent with integrity_meta_phys_t::im_hash_type
+ UInt8 hash[0];
+ }
+ */
+
+ const unsigned hash_size = pair.Val[2];
+ if (hash_size != vol.integrity.HashSize)
+ return S_FALSE;
+
+ CHashChunk hr;
+ hr.hashed_len = GetUi16(pair.Val);
+ if (hr.hashed_len == 0)
+ return S_FALSE;
+ memcpy(hr.hash, (const Byte *)pair.Val + 3, vol.integrity.HashSize);
+ // (hashed_len <= 4) : we have seen
+ hr.lba = lba;
+
+ PRF(printf(" FILE_INFO lba = %6x, hashed_len=%6d",
+ (unsigned)lba,
+ (unsigned)hr.hashed_len));
+
+ if (vol.Hash_IDs.IsEmpty() || vol.Hash_IDs.Back() != id)
+ {
+ vol.Hash_Vectors.AddNew();
+ vol.Hash_IDs.Add(id);
+ }
+ CStreamHashes &hashes = vol.Hash_Vectors.Back();
+ if (hashes.Size() != 0)
+ {
+ const CHashChunk &hr_Back = hashes.Back();
+ if (lba != hr_Back.lba + ((UInt64)hr_Back.hashed_len << sb.block_size_Log))
+ return S_FALSE;
+ }
+ hashes.Add(hr);
+ continue;
+ }
+
+ if (type == APFS_TYPE_SNAP_METADATA)
+ {
+ if (pair.Key.Size() != 8)
+ return S_FALSE;
+ PRF(printf(" SNAP_METADATA"));
+ // continue;
+ }
+
+ /* SIBLING items are used, if there are more than one hard link to some inode
+ key : value
+ parent_id_1 DIR_REC : inode_id, name_1
+ parent_id_2 DIR_REC : inode_id, name_2
+ inode_id INODE : parent_id_1, name_1
+ inode_id SIBLING_LINK sibling_id_1 : parent_id_1, name_1
+ inode_id SIBLING_LINK sibling_id_2 : parent_id_2, name_2
+ sibling_id_1 SIBLING_MAP : inode_id
+ sibling_id_2 SIBLING_MAP : inode_id
+ */
+
+ if (type == APFS_TYPE_SIBLING_LINK)
+ {
+ if (pair.Key.Size() != 16)
+ return S_FALSE;
+ if (pair.Val.Size() < 10 + 1)
+ return S_FALSE;
+ /*
+ // struct j_sibling_key
+ // The sibling's unique identifier.
+ // This value matches the object identifier for the sibling map record
+ const UInt64 sibling_id = Get64(p + 8);
+ // struct j_sibling_val
+ const Byte *v = pair.Val;
+ const UInt64 parent_id = Get64(v); // The object identifier for the inode that's the parent directory.
+ const unsigned name_len = Get16(v + 8); // len including the final null character
+ if (10 + name_len != pair.Val.Size())
+ return S_FALSE;
+ if (v[10 + name_len - 1] != 0)
+ return S_FALSE;
+ AString name ((const char *)(v + 10));
+ if (name.Len() != name_len - 1)
+ return S_FALSE;
+ PRF(printf(" SIBLING_LINK sibling_id = %6d : parent_id=%6d %s",
+ (unsigned)sibling_id, (unsigned)parent_id, name.Ptr()));
+ */
+ continue;
+ }
+
+ if (type == APFS_TYPE_SIBLING_MAP)
+ {
+ // struct j_sibling_map_key
+ // The object identifier in the header is the sibling's unique identifier
+ if (pair.Key.Size() != 8 || pair.Val.Size() != 8)
+ return S_FALSE;
+ /*
+ // j_sibling_map_val
+ // The inode number of the underlying file
+ const UInt64 file_id = Get64(pair.Val);
+ PRF(printf(" SIBLING_MAP : file_id = %d", (unsigned)file_id));
+ */
+ continue;
+ }
+
+ UnsupportedFeature = true;
+ // return S_FALSE;
+ }
+ ProgressVal_NumFilesTotal += vol.Items.Size();
+ }
+
+
+ if (needParseAttr)
+ {
+ /* we read external streams for attributes
+ So we can get SymLink for GetProperty(kpidSymLink) later */
+ FOR_VECTOR (i, vol.Nodes)
+ {
+ CNode &node = vol.Nodes[i];
+
+ FOR_VECTOR (a, node.Attrs)
+ {
+ CAttr &attr = node.Attrs[a];
+ if (attr.Data.Size() != 0 || !attr.dstream_defined)
+ continue;
+ if (a == node.SymLinkIndex)
+ {
+ if (!attr.Is_dstream_OK_for_SymLink())
+ continue;
+ }
+ else
+ {
+ if (a != node.DecmpfsIndex
+ // && a != node.ResourceIndex
+ )
+ continue;
+ }
+ // we don't expect big streams here
+ // largest dstream for Decmpfs attribute is (2Kib+17)
+ if (attr.dstream.size > ((UInt32)1 << 16))
+ continue;
+ CMyComPtr<ISequentialInStream> inStream;
+ const HRESULT res = GetAttrStream_dstream(OpenInStream, vol, attr, &inStream);
+ if (res == S_OK && inStream)
+ {
+ CByteBuffer buf2;
+ const size_t size = (size_t)attr.dstream.size;
+ buf2.Alloc(size);
+ if (ReadStream_FAIL(inStream, buf2, size) == S_OK)
+ attr.Data = buf2;
+
+ ProgressVal_Cur += size;
+ if (OpenCallback)
+ if (ProgressVal_Cur - ProgressVal_Prev >= (1 << 22))
+ {
+
+ RINOK(OpenCallback->SetCompleted(
+ &ProgressVal_NumFilesTotal,
+ &ProgressVal_Cur))
+ ProgressVal_Prev = ProgressVal_Cur;
+ }
+ }
+ }
+
+ if (node.Has_UNCOMPRESSED_SIZE())
+ if (IsViDef(node.DecmpfsIndex))
+ {
+ CAttr &attr = node.Attrs[node.DecmpfsIndex];
+ node.CompressHeader.Parse(attr.Data, attr.Data.Size());
+
+ if (node.CompressHeader.IsCorrect)
+ if (node.CompressHeader.Method < sizeof(MethodsMask) * 8)
+ MethodsMask |= ((UInt32)1 << node.CompressHeader.Method);
+
+ if (node.CompressHeader.IsCorrect
+ && node.CompressHeader.IsSupported
+ && node.CompressHeader.UnpackSize == node.uncompressed_size)
+ {
+ attr.NeedShow = false;
+ if (node.CompressHeader.IsMethod_Resource()
+ && IsViDef(node.ResourceIndex))
+ node.Attrs[node.ResourceIndex].NeedShow = false;
+ }
+ else
+ {
+ vol.UnsupportedMethod = true;
+ }
+ }
+ }
+ }
+
+ const HRESULT res = vol.FillRefs();
+
+ if (vol.ThereAreErrors())
+ HeadersError = true;
+ if (vol.UnsupportedFeature)
+ UnsupportedFeature = true;
+ if (vol.UnsupportedMethod)
+ UnsupportedMethod = true;
+ if (vol.NumAltStreams != 0)
+ ThereAreAltStreams = true;
+
+ return res;
+}
+
+
+
+HRESULT CVol::FillRefs()
+{
+ {
+ Refs.Reserve(Items.Size());
+ // we fill Refs[*]
+ // we
+ // and set Nodes[*].ItemIndex for Nodes that are directories;
+ FOR_VECTOR (i, Items)
+ {
+ CItem &item = Items[i];
+ const UInt64 id = item.Val.file_id;
+ // if (item.Id == ROOT_DIR_PARENT) continue;
+ /* for two root folders items
+ we don't set Node.ItemIndex; */
+ // so nodes
+ if (id == ROOT_DIR_INO_NUM)
+ continue;
+ if (id == PRIV_DIR_INO_NUM)
+ if (NumItems_In_PrivateDir == 0) // if (inode.NumItems == 0)
+ continue;
+
+ CRef ref;
+ ref.ItemIndex = i;
+ // ref.NodeIndex = VI_MINUS1;
+ ref.ParentRefIndex = VI_MINUS1;
+ #ifdef APFS_SHOW_ALT_STREAMS
+ ref.AttrIndex = VI_MINUS1;
+ #endif
+ const int index = NodeIDs.FindInSorted(id);
+ // const int index = -1; // for debug
+ ref.NodeIndex = (unsigned)index;
+ item.RefIndex = Refs.Size();
+ Refs.Add(ref);
+
+ if (index == -1)
+ {
+ NodeNotFound = true;
+ continue;
+ // return S_FALSE;
+ }
+
+ // item.iNode_Index = index;
+ CNode &inode = Nodes[(unsigned)index];
+ if (!item.Val.IsFlags_Unknown()
+ && inode.Get_Type_From_mode() != item.Val.flags)
+ {
+ Refs.Back().NodeIndex = VI_MINUS1;
+ WrongInodeLink = true;
+ continue;
+ // return S_FALSE;
+ }
+
+ const bool isDir = inode.IsDir();
+ if (isDir)
+ {
+ if (IsViDef(inode.ItemIndex))
+ {
+ // hard links to dirs are not supported
+ Refs.Back().NodeIndex = VI_MINUS1;
+ WrongInodeLink = true;
+ continue;
+ }
+ inode.ItemIndex = i;
+ }
+ inode.NumCalcedLinks++;
+
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!isDir)
+ {
+ // we use alt streams only for files
+ const unsigned numAttrs = inode.Attrs.Size();
+ if (numAttrs != 0)
+ {
+ ref.ParentRefIndex = item.RefIndex;
+ for (unsigned k = 0; k < numAttrs; k++)
+ {
+ // comment it for debug
+ const CAttr &attr = inode.Attrs[k];
+ if (!attr.NeedShow)
+ continue;
+
+ if (k == inode.SymLinkIndex)
+ continue;
+ ref.AttrIndex = k;
+ NumAltStreams++;
+ Refs.Add(ref);
+ /*
+ if (attr.dstream_defined)
+ {
+ const int idIndex = SmallNodeIDs.FindInSorted(attr.Id);
+ if (idIndex != -1)
+ SmallNodes[(unsigned)idIndex].NumLinks++; // for debug
+ }
+ */
+ }
+ }
+ }
+ #endif
+ }
+ }
+
+
+ {
+ // fill ghost nodes
+ CRef ref;
+ ref.ItemIndex = VI_MINUS1;
+ ref.ParentRefIndex = VI_MINUS1;
+ #ifdef APFS_SHOW_ALT_STREAMS
+ ref.AttrIndex = VI_MINUS1;
+ #endif
+ FOR_VECTOR (i, Nodes)
+ {
+ if (Nodes[i].NumCalcedLinks != 0)
+ continue;
+ const UInt64 id = NodeIDs[i];
+ if (id == ROOT_DIR_INO_NUM ||
+ id == PRIV_DIR_INO_NUM)
+ continue;
+ ThereAreUnlinkedNodes = true;
+ ref.NodeIndex = i;
+ Refs.Add(ref);
+ }
+ }
+
+ /* if want to create Refs for ghost data streams,
+ we need additional CRef::SmallNodeIndex field */
+
+ {
+ /* all Nodes[*].ItemIndex were already filled for directory Nodes,
+ except of "root" and "private-dir" Nodes. */
+
+ // now we fill Items[*].ParentItemIndex and Refs[*].ParentRefIndex
+
+ UInt64 prev_ID = (UInt64)(Int64)-1;
+ unsigned prev_ParentItemIndex = VI_MINUS1;
+
+ FOR_VECTOR (i, Items)
+ {
+ CItem &item = Items[i];
+ const UInt64 id = item.ParentId; // it's id of parent NODE
+ if (id != prev_ID)
+ {
+ prev_ID = id;
+ prev_ParentItemIndex = VI_MINUS1;
+ const int index = NodeIDs.FindInSorted(id);
+ if (index == -1)
+ continue;
+ prev_ParentItemIndex = Nodes[(unsigned)index].ItemIndex;
+ }
+
+ if (IsViNotDef(prev_ParentItemIndex))
+ continue;
+ item.ParentItemIndex = prev_ParentItemIndex;
+ if (IsViNotDef(item.RefIndex))
+ {
+ // RefIndex is not set for 2 Items (root folders)
+ // but there is no node for them usually
+ continue;
+ }
+ CRef &ref = Refs[item.RefIndex];
+
+ /*
+ // it's optional check that parent_id is set correclty
+ if (IsViDef(ref.NodeIndex))
+ {
+ const CNode &node = Nodes[ref.NodeIndex];
+ if (node.IsDir() && node.parent_id != id)
+ return S_FALSE;
+ }
+ */
+
+ /*
+ if (id == ROOT_DIR_INO_NUM)
+ {
+ // ItemIndex in Node for ROOT_DIR_INO_NUM was not set bofere
+ // probably unused now.
+ ref.ParentRefIndex = VI_MINUS1;
+ }
+ else
+ */
+ ref.ParentRefIndex = Items[prev_ParentItemIndex].RefIndex;
+ }
+ }
+
+ {
+ // check for loops
+ const unsigned numItems = Items.Size();
+ if (numItems + 1 == 0)
+ return S_FALSE;
+ CUIntArr arr;
+ arr.Alloc(numItems);
+ {
+ for (unsigned i = 0; i < numItems; i++)
+ arr[i] = 0;
+ }
+ for (unsigned i = 0; i < numItems;)
+ {
+ unsigned k = i++;
+ for (;;)
+ {
+ const unsigned a = arr[k];
+ if (a != 0)
+ {
+ if (a == i)
+ return S_FALSE;
+ break;
+ }
+ arr[k] = i;
+ k = Items[k].ParentItemIndex;
+ if (IsViNotDef(k))
+ break;
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+Z7_class_CHandler_final:
+ public IInArchive,
+ public IArchiveGetRawProps,
+ public IInArchiveGetStream,
+ public CMyUnknownImp,
+ public CDatabase
+{
+ Z7_IFACES_IMP_UNK_3(
+ IInArchive,
+ IArchiveGetRawProps,
+ IInArchiveGetStream)
+
+ CMyComPtr<IInStream> _stream;
+ int FindHashIndex_for_Item(UInt32 index);
+};
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+ OpenInStream = inStream;
+ OpenCallback = callback;
+ RINOK(Open2())
+ _stream = inStream;
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _stream.Release();
+ Clear();
+ return S_OK;
+}
+
+
+enum
+{
+ kpidBytesWritten = kpidUserDefined,
+ kpidBytesRead,
+ kpidPrimeName,
+ kpidParentINode,
+ kpidAddTime,
+ kpidGeneration,
+ kpidBsdFlags
+ // kpidUncompressedSize
+};
+
+static const CStatProp kProps[] =
+{
+ { NULL, kpidPath, VT_BSTR },
+ { NULL, kpidSize, VT_UI8 },
+ { NULL, kpidPackSize, VT_UI8 },
+ { NULL, kpidPosixAttrib, VT_UI4 },
+ { NULL, kpidMTime, VT_FILETIME },
+ { NULL, kpidCTime, VT_FILETIME },
+ { NULL, kpidATime, VT_FILETIME },
+ { NULL, kpidChangeTime, VT_FILETIME },
+ { "Added Time", kpidAddTime, VT_FILETIME },
+ { NULL, kpidMethod, VT_BSTR },
+ { NULL, kpidINode, VT_UI8 },
+ { NULL, kpidLinks, VT_UI4 },
+ { NULL, kpidSymLink, VT_BSTR },
+ { NULL, kpidUserId, VT_UI4 },
+ { NULL, kpidGroupId, VT_UI4 },
+ { NULL, kpidCharacts, VT_BSTR },
+ #ifdef APFS_SHOW_ALT_STREAMS
+ { NULL, kpidIsAltStream, VT_BOOL },
+ #endif
+ { "Parent iNode", kpidParentINode, VT_UI8 },
+ { "Primary Name", kpidPrimeName, VT_BSTR },
+ { "Generation", kpidGeneration, VT_UI4 },
+ { "Written Size", kpidBytesWritten, VT_UI8 },
+ { "Read Size", kpidBytesRead, VT_UI8 },
+ { "BSD Flags", kpidBsdFlags, VT_UI4 }
+ // , { "Uncompressed Size", kpidUncompressedSize, VT_UI8 }
+};
+
+
+static const Byte kArcProps[] =
+{
+ kpidName,
+ kpidCharacts,
+ kpidId,
+ kpidClusterSize,
+ kpidCTime,
+ kpidMTime,
+ kpidComment
+};
+
+IMP_IInArchive_Props_WITH_NAME
+IMP_IInArchive_ArcProps
+
+
+static void ApfsTimeToProp(UInt64 hfsTime, NWindows::NCOM::CPropVariant &prop)
+{
+ if (hfsTime == 0)
+ return;
+ FILETIME ft;
+ UInt32 ns100;
+ ApfsTimeToFileTime(hfsTime, ft, ns100);
+ prop.SetAsTimeFrom_FT_Prec_Ns100(ft, k_PropVar_TimePrec_1ns, ns100);
+}
+
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CApfs *apfs = NULL;
+ if (Vols.Size() == 1)
+ apfs = &Vols[0].apfs;
+ switch (propID)
+ {
+ case kpidPhySize:
+ prop = (UInt64)sb.block_count << sb.block_size_Log;
+ break;
+ case kpidClusterSize: prop = (UInt32)(sb.block_size); break;
+ case kpidCharacts: NHfs::MethodsMaskToProp(MethodsMask, prop); break;
+ case kpidMTime:
+ if (apfs)
+ ApfsTimeToProp(apfs->modified_by[0].timestamp, prop);
+ break;
+ case kpidCTime:
+ if (apfs)
+ ApfsTimeToProp(apfs->formatted_by.timestamp, prop);
+ break;
+ case kpidIsTree: prop = true; break;
+ case kpidErrorFlags:
+ {
+ UInt32 flags = 0;
+ if (HeadersError) flags |= kpv_ErrorFlags_HeadersError;
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ case kpidWarningFlags:
+ {
+ UInt32 flags = 0;
+ if (UnsupportedFeature) flags |= kpv_ErrorFlags_UnsupportedFeature;
+ if (UnsupportedMethod) flags |= kpv_ErrorFlags_UnsupportedMethod;
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+
+ case kpidName:
+ {
+ if (apfs)
+ {
+ UString s;
+ AddVolInternalName_toString(s, *apfs);
+ s += ".apfs";
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidId:
+ {
+ char s[32 + 4];
+ sb.uuid.SetHex_To_str(s);
+ prop = s;
+ break;
+ }
+
+ case kpidComment:
+ {
+ UString s;
+ {
+ AddComment_UInt64(s, "block_size", sb.block_size);
+
+ FOR_VECTOR (i, Vols)
+ {
+ if (Vols.Size() > 1)
+ {
+ if (i != 0)
+ {
+ s += "----";
+ s.Add_LF();
+ }
+ AddComment_UInt64(s, "Volume", i + 1);
+ }
+ Vols[i].AddComment(s);
+ }
+ }
+ prop = s;
+ break;
+ }
+
+ #ifdef APFS_SHOW_ALT_STREAMS
+ case kpidIsAltStream:
+ prop = ThereAreAltStreams;
+ // prop = false; // for debug
+ break;
+ #endif
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = 0;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID))
+{
+ *name = NULL;
+ *propID = 0;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+ UInt32 parentIndex = (UInt32)(Int32)-1;
+
+ if (IsViDef(ref2.RefIndex))
+ {
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (ref.IsAltStream())
+ *parentType = NParentType::kAltStream;
+ #endif
+ if (IsViDef(ref.ParentRefIndex))
+ parentIndex = (UInt32)(ref.ParentRefIndex + vol.StartRef2Index);
+ else if (index != vol.RootRef2Index && IsViDef(vol.RootRef2Index))
+ parentIndex = (UInt32)vol.RootRef2Index;
+ }
+
+ *parent = parentIndex;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ UNUSED_VAR(index)
+ UNUSED_VAR(propID)
+ return S_OK;
+}
+
+
+static void Utf8Name_to_InterName(const AString &src, UString &dest)
+{
+ ConvertUTF8ToUnicode(src, dest);
+ NItemName::NormalizeSlashes_in_FileName_for_OsPath(dest);
+}
+
+
+static void AddNodeName(UString &s, const CNode &inode, UInt64 id)
+{
+ s += "node";
+ s.Add_UInt64(id);
+ if (!inode.PrimaryName.IsEmpty())
+ {
+ s.Add_Dot();
+ UString s2;
+ Utf8Name_to_InterName(inode.PrimaryName, s2);
+ s += s2;
+ }
+}
+
+
+void CDatabase::GetItemPath(unsigned index, const CNode *inode, NWindows::NCOM::CPropVariant &path) const
+{
+ const unsigned kNumLevelsMax = (1 << 10);
+ const unsigned kLenMax = (1 << 12);
+ UString s;
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+
+ if (IsViDef(ref2.RefIndex))
+ {
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+ unsigned cur = ref.ItemIndex;
+ UString s2;
+ if (IsViNotDef(cur))
+ {
+ if (inode)
+ AddNodeName(s, *inode, vol.NodeIDs[ref.NodeIndex]);
+ }
+ else
+ {
+ for (unsigned i = 0;; i++)
+ {
+ if (i >= kNumLevelsMax || s.Len() > kLenMax)
+ {
+ s.Insert(0, UString("[LONG_PATH]"));
+ break;
+ }
+ const CItem &item = vol.Items[(unsigned)cur];
+ Utf8Name_to_InterName(item.Name, s2);
+ // s2 += "a\\b"; // for debug
+ s.Insert(0, s2);
+ cur = item.ParentItemIndex;
+ if (IsViNotDef(cur))
+ break;
+ // ParentItemIndex was not set for such items
+ // if (item.ParentId == ROOT_DIR_INO_NUM) break;
+ s.InsertAtFront(WCHAR_PATH_SEPARATOR);
+ }
+ }
+
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (IsViDef(ref.AttrIndex) && inode)
+ {
+ s += ':';
+ Utf8Name_to_InterName(inode->Attrs[(unsigned)ref.AttrIndex].Name, s2);
+ // s2 += "a\\b"; // for debug
+ s += s2;
+ }
+ #endif
+ }
+
+ if (!vol.RootName.IsEmpty())
+ {
+ if (IsViDef(ref2.RefIndex))
+ s.InsertAtFront(WCHAR_PATH_SEPARATOR);
+ s.Insert(0, vol.RootName);
+ }
+
+ path = s;
+}
+
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+
+ if (IsViNotDef(ref2.RefIndex))
+ {
+ switch (propID)
+ {
+ case kpidName:
+ case kpidPath:
+ GetItemPath(index, NULL, prop);
+ break;
+ case kpidIsDir:
+ prop = true;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+
+ const CItem *item = NULL;
+ if (IsViDef(ref.ItemIndex))
+ item = &vol.Items[ref.ItemIndex];
+
+ const CNode *inode = NULL;
+ if (IsViDef(ref.NodeIndex))
+ inode = &vol.Nodes[ref.NodeIndex];
+
+ switch (propID)
+ {
+ case kpidPath:
+ GetItemPath(index, inode, prop);
+ break;
+ case kpidPrimeName:
+ {
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode && !inode->PrimaryName.IsEmpty())
+ {
+ UString s;
+ ConvertUTF8ToUnicode(inode->PrimaryName, s);
+ /*
+ // for debug:
+ if (inode.PrimaryName != item.Name) throw 123456;
+ */
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidName:
+ {
+ UString s;
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (ref.IsAltStream())
+ {
+ // if (inode)
+ {
+ const CAttr &attr = inode->Attrs[(unsigned)ref.AttrIndex];
+ ConvertUTF8ToUnicode(attr.Name, s);
+ }
+ }
+ else
+ #endif
+ {
+ if (item)
+ ConvertUTF8ToUnicode(item->Name, s);
+ else if (inode)
+ AddNodeName(s, *inode, vol.NodeIDs[ref.NodeIndex]);
+ else
+ break;
+ }
+ // s += "s/1bs\\2"; // for debug:
+ prop = s;
+ break;
+ }
+
+ case kpidSymLink:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode)
+ {
+ if (inode->IsSymLink() && IsViDef(inode->SymLinkIndex))
+ {
+ const CByteBuffer &buf = inode->Attrs[(unsigned)inode->SymLinkIndex].Data;
+ if (buf.Size() != 0)
+ {
+ AString s;
+ s.SetFrom_CalcLen((const char *)(const Byte *)buf, (unsigned)buf.Size());
+ if (s.Len() == buf.Size() - 1)
+ {
+ UString u;
+ ConvertUTF8ToUnicode(s, u);
+ prop = u;
+ }
+ }
+ }
+ }
+ break;
+
+ case kpidSize:
+ if (inode)
+ {
+ UInt64 size = 0;
+ if (inode->GetSize(ref.GetAttrIndex(), size) ||
+ !inode->IsDir())
+ prop = size;
+ }
+ break;
+
+ case kpidPackSize:
+ if (inode)
+ {
+ UInt64 size;
+ if (inode->GetPackSize(ref.GetAttrIndex(), size) ||
+ !inode->IsDir())
+ prop = size;
+ }
+ break;
+
+ case kpidMethod:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode)
+ {
+ if (inode->CompressHeader.IsCorrect)
+ inode->CompressHeader.MethodToProp(prop);
+ else if (IsViDef(inode->DecmpfsIndex))
+ prop = "decmpfs";
+ else if (!inode->IsDir() && !inode->dstream_defined)
+ {
+ if (inode->IsSymLink())
+ {
+ if (IsViDef(inode->SymLinkIndex))
+ prop = "symlink";
+ }
+ // else prop = "no_dstream";
+ }
+ }
+ break;
+
+ /*
+ case kpidUncompressedSize:
+ if (inode && inode->Has_UNCOMPRESSED_SIZE())
+ prop = inode->uncompressed_size;
+ break;
+ */
+
+ case kpidIsDir:
+ {
+ bool isDir = false;
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ {
+ if (inode)
+ isDir = inode->IsDir();
+ else if (item)
+ isDir = item->Val.IsFlags_Dir();
+ }
+ prop = isDir;
+ break;
+ }
+
+ case kpidPosixAttrib:
+ {
+ if (inode)
+ {
+ UInt32 mode = inode->mode;
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (ref.IsAltStream())
+ {
+ mode &= 0666; // we disable execution
+ mode |= MY_LIN_S_IFREG;
+ }
+ #endif
+ prop = (UInt32)mode;
+ }
+ else if (item && !item->Val.IsFlags_Unknown())
+ prop = (UInt32)(item->Val.flags << 12);
+ break;
+ }
+
+ case kpidCTime: if (inode) ApfsTimeToProp(inode->create_time, prop); break;
+ case kpidMTime: if (inode) ApfsTimeToProp(inode->mod_time, prop); break;
+ case kpidATime: if (inode) ApfsTimeToProp(inode->access_time, prop); break;
+ case kpidChangeTime: if (inode) ApfsTimeToProp(inode->change_time, prop); break;
+ case kpidAddTime: if (item) ApfsTimeToProp(item->Val.date_added, prop); break;
+
+ case kpidBytesWritten:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode && inode->dstream_defined)
+ prop = inode->dstream.total_bytes_written;
+ break;
+ case kpidBytesRead:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode && inode->dstream_defined)
+ prop = inode->dstream.total_bytes_read;
+ break;
+
+ #ifdef APFS_SHOW_ALT_STREAMS
+ case kpidIsAltStream:
+ prop = ref.IsAltStream();
+ break;
+ #endif
+
+ case kpidCharacts:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode)
+ {
+ FLAGS_TO_PROP(g_INODE_Flags, (UInt32)inode->internal_flags, prop);
+ }
+ break;
+
+ case kpidBsdFlags:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode)
+ {
+ FLAGS_TO_PROP(g_INODE_BSD_Flags, inode->bsd_flags, prop);
+ }
+ break;
+
+ case kpidGeneration:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ // if (!ref.IsAltStream())
+ #endif
+ if (inode)
+ prop = inode->write_generation_counter;
+ break;
+
+ case kpidUserId:
+ if (inode)
+ prop = (UInt32)inode->owner;
+ break;
+
+ case kpidGroupId:
+ if (inode)
+ prop = (UInt32)inode->group;
+ break;
+
+ case kpidLinks:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode && !inode->IsDir())
+ prop = (UInt32)inode->nlink;
+ break;
+
+ case kpidINode:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ // here we can disable iNode for alt stream.
+ if (!ref.IsAltStream())
+ #endif
+ if (IsViDef(ref.NodeIndex))
+ prop = (UInt32)vol.NodeIDs[ref.NodeIndex];
+ break;
+
+ case kpidParentINode:
+ #ifdef APFS_SHOW_ALT_STREAMS
+ if (!ref.IsAltStream())
+ #endif
+ if (inode)
+ prop = (UInt32)inode->parent_id;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+UInt64 CDatabase::GetSize(const UInt32 index) const
+{
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+ if (IsViNotDef(ref2.RefIndex))
+ return 0;
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+ if (IsViNotDef(ref.NodeIndex))
+ return 0;
+ const CNode &inode = vol.Nodes[ref.NodeIndex];
+ UInt64 size;
+ if (inode.GetSize(ref.GetAttrIndex(), size))
+ return size;
+ return 0;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = Refs2.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt32 i;
+
+ {
+ UInt64 totalSize = 0;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ totalSize += GetSize(index);
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+ }
+
+ UInt64 currentTotalSize = 0, currentItemSize = 0;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ NHfs::CDecoder decoder;
+
+ for (i = 0;; i++, currentTotalSize += currentItemSize)
+ {
+ lps->InSize = currentTotalSize;
+ lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+
+ if (i >= numItems)
+ break;
+
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+
+ currentItemSize = GetSize(index);
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (IsViNotDef(ref2.RefIndex))
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+ bool isDir = false;
+ if (IsViDef(ref.NodeIndex))
+ isDir = vol.Nodes[ref.NodeIndex].IsDir();
+ else if (IsViDef(ref.ItemIndex))
+ isDir =
+ #ifdef APFS_SHOW_ALT_STREAMS
+ !ref.IsAltStream() &&
+ #endif
+ vol.Items[ref.ItemIndex].Val.IsFlags_Dir();
+
+ if (isDir)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ int opRes = NExtract::NOperationResult::kDataError;
+
+ if (IsViDef(ref.NodeIndex))
+ {
+ const CNode &inode = vol.Nodes[ref.NodeIndex];
+ if (
+ #ifdef APFS_SHOW_ALT_STREAMS
+ !ref.IsAltStream() &&
+ #endif
+ !inode.dstream_defined
+ && inode.Extents.IsEmpty()
+ && inode.Has_UNCOMPRESSED_SIZE()
+ && inode.uncompressed_size == inode.CompressHeader.UnpackSize)
+ {
+ if (inode.CompressHeader.IsSupported)
+ {
+ CMyComPtr<ISequentialInStream> inStreamFork;
+ UInt64 forkSize = 0;
+ const CByteBuffer *decmpfs_Data = NULL;
+
+ if (inode.CompressHeader.IsMethod_Resource())
+ {
+ if (IsViDef(inode.ResourceIndex))
+ {
+ const CAttr &attr = inode.Attrs[inode.ResourceIndex];
+ forkSize = attr.GetSize();
+ GetAttrStream(_stream, vol, attr, &inStreamFork);
+ }
+ }
+ else
+ {
+ const CAttr &attr = inode.Attrs[inode.DecmpfsIndex];
+ decmpfs_Data = &attr.Data;
+ }
+
+ if (inStreamFork || decmpfs_Data)
+ {
+ const HRESULT hres = decoder.Extract(
+ inStreamFork, realOutStream,
+ forkSize,
+ inode.CompressHeader,
+ decmpfs_Data,
+ currentTotalSize, extractCallback,
+ opRes);
+ if (hres != S_FALSE && hres != S_OK)
+ return hres;
+ }
+ }
+ else
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ }
+ else
+ {
+ CMyComPtr<ISequentialInStream> inStream;
+ if (GetStream(index, &inStream) == S_OK && inStream)
+ {
+ COutStreamWithHash *hashStreamSpec = NULL;
+ CMyComPtr<ISequentialOutStream> hashStream;
+
+ if (vol.integrity.Is_SHA256())
+ {
+ const int hashIndex = FindHashIndex_for_Item(index);
+ if (hashIndex != -1)
+ {
+ hashStreamSpec = new COutStreamWithHash;
+ hashStream = hashStreamSpec;
+ hashStreamSpec->SetStream(realOutStream);
+ hashStreamSpec->Init(&(vol.Hash_Vectors[(unsigned)hashIndex]), sb.block_size_Log);
+ }
+ }
+
+ RINOK(copyCoder->Code(inStream,
+ hashStream ? hashStream : realOutStream, NULL, NULL, progress))
+ opRes = NExtract::NOperationResult::kDataError;
+ if (copyCoderSpec->TotalSize == currentItemSize)
+ {
+ opRes = NExtract::NOperationResult::kOK;
+ if (hashStream)
+ if (!hashStreamSpec->FinalCheck())
+ opRes = NExtract::NOperationResult::kCRCError;
+ }
+ else if (copyCoderSpec->TotalSize < currentItemSize)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ }
+ }
+ }
+
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = Refs2.Size();
+ return S_OK;
+}
+
+
+int CHandler::FindHashIndex_for_Item(UInt32 index)
+{
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+ if (IsViNotDef(ref2.RefIndex))
+ return -1;
+
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+ if (IsViNotDef(ref.NodeIndex))
+ return -1;
+ const CNode &inode = vol.Nodes[ref.NodeIndex];
+
+ unsigned attrIndex = ref.GetAttrIndex();
+
+ if (IsViNotDef(attrIndex)
+ && !inode.dstream_defined
+ && inode.IsSymLink())
+ {
+ attrIndex = inode.SymLinkIndex;
+ if (IsViNotDef(attrIndex))
+ return -1;
+ }
+
+ if (IsViDef(attrIndex))
+ {
+ /* we have seen examples, where hash available for "com.apple.ResourceFork" stream.
+ these hashes for "com.apple.ResourceFork" stream are for unpacked data.
+ but the caller here needs packed data of stream. So we don't use hashes */
+ return -1;
+ }
+ else
+ {
+ if (!inode.dstream_defined)
+ return -1;
+ const UInt64 id = vol.NodeIDs[ref.NodeIndex];
+ return vol.Hash_IDs.FindInSorted(id);
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ *stream = NULL;
+
+ const CRef2 &ref2 = Refs2[index];
+ const CVol &vol = Vols[ref2.VolIndex];
+ if (IsViNotDef(ref2.RefIndex))
+ return S_FALSE;
+
+ const CRef &ref = vol.Refs[ref2.RefIndex];
+ if (IsViNotDef(ref.NodeIndex))
+ return S_FALSE;
+ const CNode &inode = vol.Nodes[ref.NodeIndex];
+
+ const CRecordVector<CExtent> *extents;
+ UInt64 rem = 0;
+
+ unsigned attrIndex = ref.GetAttrIndex();
+
+ if (IsViNotDef(attrIndex)
+ && !inode.dstream_defined
+ && inode.IsSymLink())
+ {
+ attrIndex = inode.SymLinkIndex;
+ if (IsViNotDef(attrIndex))
+ return S_FALSE;
+ }
+
+ if (IsViDef(attrIndex))
+ {
+ const CAttr &attr = inode.Attrs[(unsigned)attrIndex];
+ if (!attr.dstream_defined)
+ {
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->Init(attr.Data, attr.Data.Size(), (IInArchive *)this);
+ *stream = streamTemp.Detach();
+ return S_OK;
+ }
+ const int idIndex = vol.SmallNodeIDs.FindInSorted(attr.Id);
+ if (idIndex != -1)
+ extents = &vol.SmallNodes[(unsigned)idIndex].Extents;
+ else
+ {
+ const int fext_Index = vol.FEXT_NodeIDs.FindInSorted(attr.Id);
+ if (fext_Index == -1)
+ return S_FALSE;
+ extents = &vol.FEXT_Nodes[(unsigned)fext_Index].Extents;
+ }
+ rem = attr.dstream.size;
+ }
+ else
+ {
+ if (IsViDef(ref.ItemIndex))
+ if (vol.Items[ref.ItemIndex].Val.IsFlags_Dir())
+ return S_FALSE;
+ if (inode.IsDir())
+ return S_FALSE;
+ extents = &inode.Extents;
+ if (inode.dstream_defined)
+ {
+ rem = inode.dstream.size;
+ if (inode.Extents.Size() == 0)
+ {
+ const int fext_Index = vol.FEXT_NodeIDs.FindInSorted(vol.NodeIDs[ref.NodeIndex]);
+ if (fext_Index != -1)
+ extents = &vol.FEXT_Nodes[(unsigned)fext_Index].Extents;
+ }
+ }
+ else
+ {
+ // return S_FALSE; // check it !!! How zero size files are stored with dstream_defined?
+ }
+ }
+ return GetStream2(_stream, extents, rem, stream);
+}
+
+
+
+HRESULT CDatabase::GetAttrStream(IInStream *apfsInStream, const CVol &vol,
+ const CAttr &attr, ISequentialInStream **stream)
+{
+ *stream = NULL;
+ if (!attr.dstream_defined)
+ {
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->Init(attr.Data, attr.Data.Size(), (IInArchive *)this);
+ *stream = streamTemp.Detach();
+ return S_OK;
+ }
+ return GetAttrStream_dstream(apfsInStream, vol, attr, stream);
+}
+
+
+HRESULT CDatabase::GetAttrStream_dstream( IInStream *apfsInStream, const CVol &vol,
+ const CAttr &attr, ISequentialInStream **stream)
+{
+ const CRecordVector<CExtent> *extents;
+ {
+ const int idIndex = vol.SmallNodeIDs.FindInSorted(attr.Id);
+ if (idIndex != -1)
+ extents = &vol.SmallNodes[(unsigned)idIndex].Extents;
+ else
+ {
+ const int fext_Index = vol.FEXT_NodeIDs.FindInSorted(attr.Id);
+ if (fext_Index == -1)
+ return S_FALSE;
+ extents = &vol.FEXT_Nodes[(unsigned)fext_Index].Extents;
+ }
+ }
+ return GetStream2(apfsInStream, extents, attr.dstream.size, stream);
+}
+
+
+HRESULT CDatabase::GetStream2(
+ IInStream *apfsInStream,
+ const CRecordVector<CExtent> *extents, UInt64 rem,
+ ISequentialInStream **stream)
+{
+ CExtentsStream *extentStreamSpec = new CExtentsStream();
+ CMyComPtr<ISequentialInStream> extentStream = extentStreamSpec;
+
+ UInt64 virt = 0;
+ FOR_VECTOR (i, *extents)
+ {
+ const CExtent &e = (*extents)[i];
+ if (virt != e.logical_offset)
+ return S_FALSE;
+ const UInt64 len = EXTENT_GET_LEN(e.len_and_flags);
+ if (len == 0)
+ {
+ return S_FALSE;
+ // continue;
+ }
+ if (rem == 0)
+ return S_FALSE;
+ UInt64 cur = len;
+ if (cur > rem)
+ cur = rem;
+ CSeekExtent se;
+ se.Phy = (UInt64)e.phys_block_num << sb.block_size_Log;
+ se.Virt = virt;
+ virt += cur;
+ rem -= cur;
+ extentStreamSpec->Extents.Add(se);
+ if (rem == 0)
+ if (i != extents->Size() - 1)
+ return S_FALSE;
+ }
+
+ if (rem != 0)
+ return S_FALSE;
+
+ CSeekExtent se;
+ se.Phy = 0;
+ se.Virt = virt;
+ extentStreamSpec->Extents.Add(se);
+ extentStreamSpec->Stream = apfsInStream;
+ extentStreamSpec->Init();
+ *stream = extentStream.Detach();
+ return S_OK;
+}
+
+
+REGISTER_ARC_I(
+ "APFS", "apfs img", NULL, 0xc3,
+ k_Signature,
+ k_SignatureOffset,
+ 0,
+ IsArc_APFS)
+
+}}
diff --git a/CPP/7zip/Archive/ApmHandler.cpp b/CPP/7zip/Archive/ApmHandler.cpp
new file mode 100644
index 0000000..6770301
--- /dev/null
+++ b/CPP/7zip/Archive/ApmHandler.cpp
@@ -0,0 +1,314 @@
+// ApmHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/Defs.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NApm {
+
+static const Byte kSig0 = 'E';
+static const Byte kSig1 = 'R';
+
+struct CItem
+{
+ UInt32 StartBlock;
+ UInt32 NumBlocks;
+ char Name[32];
+ char Type[32];
+ /*
+ UInt32 DataStartBlock;
+ UInt32 NumDataBlocks;
+ UInt32 Status;
+ UInt32 BootStartBlock;
+ UInt32 BootSize;
+ UInt32 BootAddr;
+ UInt32 BootEntry;
+ UInt32 BootChecksum;
+ char Processor[16];
+ */
+
+ bool Parse(const Byte *p, UInt32 &numBlocksInMap)
+ {
+ numBlocksInMap = Get32(p + 4);
+ StartBlock = Get32(p + 8);
+ NumBlocks = Get32(p + 0xC);
+ memcpy(Name, p + 0x10, 32);
+ memcpy(Type, p + 0x30, 32);
+ if (p[0] != 0x50 || p[1] != 0x4D || p[2] != 0 || p[3] != 0)
+ return false;
+ /*
+ DataStartBlock = Get32(p + 0x50);
+ NumDataBlocks = Get32(p + 0x54);
+ Status = Get32(p + 0x58);
+ BootStartBlock = Get32(p + 0x5C);
+ BootSize = Get32(p + 0x60);
+ BootAddr = Get32(p + 0x64);
+ if (Get32(p + 0x68) != 0)
+ return false;
+ BootEntry = Get32(p + 0x6C);
+ if (Get32(p + 0x70) != 0)
+ return false;
+ BootChecksum = Get32(p + 0x74);
+ memcpy(Processor, p + 0x78, 16);
+ */
+ return true;
+ }
+};
+
+Z7_class_CHandler_final: public CHandlerCont
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Cont)
+
+ CRecordVector<CItem> _items;
+ unsigned _blockSizeLog;
+ UInt32 _numBlocks;
+ UInt64 _phySize;
+ bool _isArc;
+
+ HRESULT ReadTables(IInStream *stream);
+ UInt64 BlocksToBytes(UInt32 i) const { return (UInt64)i << _blockSizeLog; }
+
+ virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const Z7_override
+ {
+ const CItem &item = _items[index];
+ pos = BlocksToBytes(item.StartBlock);
+ size = BlocksToBytes(item.NumBlocks);
+ return NExtract::NOperationResult::kOK;
+ }
+};
+
+static const UInt32 kSectorSize = 512;
+
+API_FUNC_static_IsArc IsArc_Apm(const Byte *p, size_t size)
+{
+ if (size < kSectorSize)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != kSig0 || p[1] != kSig1)
+ return k_IsArc_Res_NO;
+ unsigned i;
+ for (i = 8; i < 16; i++)
+ if (p[i] != 0)
+ return k_IsArc_Res_NO;
+ UInt32 blockSize = Get16(p + 2);
+ for (i = 9; ((UInt32)1 << i) != blockSize; i++)
+ if (i >= 12)
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+HRESULT CHandler::ReadTables(IInStream *stream)
+{
+ Byte buf[kSectorSize];
+ {
+ RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+ if (buf[0] != kSig0 || buf[1] != kSig1)
+ return S_FALSE;
+ UInt32 blockSize = Get16(buf + 2);
+ unsigned i;
+ for (i = 9; ((UInt32)1 << i) != blockSize; i++)
+ if (i >= 12)
+ return S_FALSE;
+ _blockSizeLog = i;
+ _numBlocks = Get32(buf + 4);
+ for (i = 8; i < 16; i++)
+ if (buf[i] != 0)
+ return S_FALSE;
+ }
+
+ unsigned numSkips = (unsigned)1 << (_blockSizeLog - 9);
+ for (unsigned j = 1; j < numSkips; j++)
+ {
+ RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+ }
+
+ UInt32 numBlocksInMap = 0;
+
+ for (unsigned i = 0;;)
+ {
+ RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+
+ CItem item;
+
+ UInt32 numBlocksInMap2 = 0;
+ if (!item.Parse(buf, numBlocksInMap2))
+ return S_FALSE;
+ if (i == 0)
+ {
+ numBlocksInMap = numBlocksInMap2;
+ if (numBlocksInMap > (1 << 8))
+ return S_FALSE;
+ }
+ else if (numBlocksInMap2 != numBlocksInMap)
+ return S_FALSE;
+
+ UInt32 finish = item.StartBlock + item.NumBlocks;
+ if (finish < item.StartBlock)
+ return S_FALSE;
+ _numBlocks = MyMax(_numBlocks, finish);
+
+ _items.Add(item);
+ for (unsigned j = 1; j < numSkips; j++)
+ {
+ RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+ }
+ if (++i == numBlocksInMap)
+ break;
+ }
+
+ _phySize = BlocksToBytes(_numBlocks);
+ _isArc = true;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* callback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(ReadTables(stream))
+ _stream = stream;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _phySize = 0;
+ _items.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidOffset
+};
+
+static const Byte kArcProps[] =
+{
+ kpidClusterSize
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static AString GetString(const char *s)
+{
+ AString res;
+ for (unsigned i = 0; i < 32 && s[i] != 0; i++)
+ res += s[i];
+ return res;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile:
+ {
+ int mainIndex = -1;
+ FOR_VECTOR (i, _items)
+ {
+ AString s (GetString(_items[i].Type));
+ if (s != "Apple_Free" &&
+ s != "Apple_partition_map")
+ {
+ if (mainIndex >= 0)
+ {
+ mainIndex = -1;
+ break;
+ }
+ mainIndex = (int)i;
+ }
+ }
+ if (mainIndex >= 0)
+ prop = (UInt32)(Int32)mainIndex;
+ break;
+ }
+ case kpidClusterSize: prop = (UInt32)1 << _blockSizeLog; break;
+ case kpidPhySize: prop = _phySize; break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ const CItem &item = _items[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString s (GetString(item.Name));
+ if (s.IsEmpty())
+ s.Add_UInt32(index);
+ AString type (GetString(item.Type));
+ if (type == "Apple_HFS")
+ type = "hfs";
+ if (!type.IsEmpty())
+ {
+ s.Add_Dot();
+ s += type;
+ }
+ prop = s;
+ break;
+ }
+ case kpidSize:
+ case kpidPackSize:
+ prop = BlocksToBytes(item.NumBlocks);
+ break;
+ case kpidOffset: prop = BlocksToBytes(item.StartBlock); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { kSig0, kSig1 };
+
+REGISTER_ARC_I(
+ "APM", "apm", NULL, 0xD4,
+ k_Signature,
+ 0,
+ 0,
+ IsArc_Apm)
+
+}}
diff --git a/CPP/7zip/Archive/ArHandler.cpp b/CPP/7zip/Archive/ArHandler.cpp
new file mode 100644
index 0000000..07ecec6
--- /dev/null
+++ b/CPP/7zip/Archive/ArHandler.cpp
@@ -0,0 +1,843 @@
+// ArHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/StringToInt.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/ItemNameUtils.h"
+
+using namespace NWindows;
+using namespace NTime;
+
+namespace NArchive {
+namespace NAr {
+
+/*
+The end of each file member (including last file in archive) is 2-bytes aligned.
+It uses 0xA padding if required.
+
+File Names:
+
+GNU/SVR4 variant (.a static library):
+ / - archive symbol table
+ // - the list of the long filenames, separated by one or more LF characters.
+ /N - the reference to name string in long filenames list
+ name/ - the name
+
+Microsoft variant (.lib static library):
+ / - First linker file (archive symbol table)
+ / - Second linker file
+ // - the list of the long filenames, null-terminated. Each string begins
+ immediately after the null byte in the previous string.
+ /N - the reference to name string in long filenames list
+ name/ - the name
+
+BSD (Mac OS X) variant:
+ "__.SYMDEF" - archive symbol table
+ or
+ "__.SYMDEF SORTED" - archive symbol table
+ #1/N - the real filename of length N is appended to the file header.
+*/
+
+static const unsigned kSignatureLen = 8;
+static const Byte kSignature[kSignatureLen] =
+ { '!', '<', 'a', 'r', 'c', 'h', '>', 0x0A };
+
+static const unsigned kNameSize = 16;
+static const unsigned kTimeSize = 12;
+static const unsigned kUserSize = 6;
+static const unsigned kModeSize = 8;
+static const unsigned kSizeSize = 10;
+
+static const unsigned kHeaderSize = kNameSize + kTimeSize + kUserSize * 2 + kModeSize + kSizeSize + 1 + 1;
+
+enum EType
+{
+ kType_Ar,
+ kType_ALib,
+ kType_Deb,
+ kType_Lib
+};
+
+static const char * const k_TypeExtionsions[] =
+{
+ "ar"
+ , "a"
+ , "deb"
+ , "lib"
+};
+
+enum ESubType
+{
+ kSubType_None,
+ kSubType_BSD
+};
+
+/*
+struct CHeader
+{
+ char Name[kNameSize];
+ char MTime[kTimeSize];
+ char User[kUserSize];
+ char Group[kUserSize];
+ char Mode[kModeSize];
+ char Size[kSizeSize];
+ char Quote;
+ char NewLine;
+};
+*/
+
+struct CItem
+{
+ AString Name;
+ UInt64 Size;
+ UInt32 MTime;
+ UInt32 User;
+ UInt32 Group;
+ UInt32 Mode;
+
+ UInt64 HeaderPos;
+ UInt64 HeaderSize;
+
+ int TextFileIndex;
+ int SameNameIndex;
+
+ CItem(): TextFileIndex(-1), SameNameIndex(-1) {}
+ UInt64 GetDataPos() const { return HeaderPos + HeaderSize; }
+};
+
+class CInArchive
+{
+ CMyComPtr<IInStream> m_Stream;
+
+public:
+ UInt64 Position;
+ ESubType SubType;
+
+ HRESULT GetNextItem(CItem &itemInfo, bool &filled);
+ HRESULT Open(IInStream *inStream);
+ HRESULT SkipData(UInt64 dataSize)
+ {
+ return m_Stream->Seek((Int64)(dataSize + (dataSize & 1)), STREAM_SEEK_CUR, &Position);
+ }
+};
+
+HRESULT CInArchive::Open(IInStream *inStream)
+{
+ SubType = kSubType_None;
+ RINOK(InStream_GetPos(inStream, Position))
+ char signature[kSignatureLen];
+ RINOK(ReadStream_FALSE(inStream, signature, kSignatureLen))
+ Position += kSignatureLen;
+ if (memcmp(signature, kSignature, kSignatureLen) != 0)
+ return S_FALSE;
+ m_Stream = inStream;
+ return S_OK;
+}
+
+static unsigned RemoveTailSpaces(char *dest, const char *s, unsigned size)
+{
+ memcpy(dest, s, size);
+ for (; size != 0; size--)
+ {
+ if (dest[size - 1] != ' ')
+ break;
+ }
+ dest[size] = 0;
+ return size;
+}
+
+static bool OctalToNumber32(const char *s, unsigned size, UInt32 &res)
+{
+ res = 0;
+ char sz[32];
+ size = RemoveTailSpaces(sz, s, size);
+ if (size == 0 || strcmp(sz, "-1") == 0)
+ return true; // some items don't contain any numbers
+ const char *end;
+ UInt64 res64 = ConvertOctStringToUInt64(sz, &end);
+ if ((unsigned)(end - sz) != size)
+ return false;
+ res = (UInt32)res64;
+ return (res64 <= 0xFFFFFFFF);
+}
+
+static bool DecimalToNumber(const char *s, unsigned size, UInt64 &res)
+{
+ res = 0;
+ char sz[32];
+ size = RemoveTailSpaces(sz, s, size);
+ if (size == 0 || strcmp(sz, "-1") == 0)
+ return true; // some items don't contain any numbers
+ const char *end;
+ res = ConvertStringToUInt64(sz, &end);
+ return ((unsigned)(end - sz) == size);
+}
+
+static bool DecimalToNumber32(const char *s, unsigned size, UInt32 &res)
+{
+ UInt64 res64;
+ if (!DecimalToNumber(s, size, res64))
+ return false;
+ res = (UInt32)res64;
+ return (res64 <= 0xFFFFFFFF);
+}
+
+#define RIF(x) { if (!(x)) return S_FALSE; }
+
+
+HRESULT CInArchive::GetNextItem(CItem &item, bool &filled)
+{
+ filled = false;
+
+ char header[kHeaderSize];
+ const char *cur = header;
+
+ {
+ size_t processedSize = sizeof(header);
+ item.HeaderPos = Position;
+ item.HeaderSize = kHeaderSize;
+ RINOK(ReadStream(m_Stream, header, &processedSize))
+ if (processedSize != sizeof(header))
+ return S_OK;
+ if (header[kHeaderSize - 2] != 0x60 ||
+ header[kHeaderSize - 1] != 0x0A)
+ return S_OK;
+ for (unsigned i = 0; i < kHeaderSize - 2; i++)
+ // if (header[i] < 0x20)
+ if (header[i] == 0)
+ return S_OK;
+ Position += processedSize;
+ }
+
+ UInt32 longNameLen = 0;
+ if (cur[0] == '#' &&
+ cur[1] == '1' &&
+ cur[2] == '/' &&
+ cur[3] != 0)
+ {
+ // BSD variant
+ RIF(DecimalToNumber32(cur + 3, kNameSize - 3 , longNameLen))
+ if (longNameLen >= (1 << 12))
+ longNameLen = 0;
+ }
+ else
+ {
+ char tempString[kNameSize + 1];
+ RemoveTailSpaces(tempString, cur, kNameSize);
+ item.Name = tempString;
+ }
+ cur += kNameSize;
+
+ RIF(DecimalToNumber32(cur, kTimeSize, item.MTime)) cur += kTimeSize;
+ RIF(DecimalToNumber32(cur, kUserSize, item.User)) cur += kUserSize;
+ RIF(DecimalToNumber32(cur, kUserSize, item.Group)) cur += kUserSize;
+ RIF(OctalToNumber32(cur, kModeSize, item.Mode)) cur += kModeSize;
+ RIF(DecimalToNumber(cur, kSizeSize, item.Size)) cur += kSizeSize;
+
+ if (longNameLen != 0 && longNameLen <= item.Size)
+ {
+ SubType = kSubType_BSD;
+ size_t processedSize = longNameLen;
+ char *s = item.Name.GetBuf(longNameLen);
+ HRESULT res = ReadStream(m_Stream, s, &processedSize);
+ item.Name.ReleaseBuf_CalcLen(longNameLen);
+ RINOK(res)
+ if (processedSize != longNameLen)
+ return S_OK;
+ item.Size -= longNameLen;
+ item.HeaderSize += longNameLen;
+ Position += processedSize;
+ }
+
+ filled = true;
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CObjectVector<CItem> _items;
+ CMyComPtr<IInStream> _stream;
+ Int32 _mainSubfile;
+ UInt64 _phySize;
+
+ EType _type;
+ ESubType _subType;
+ int _longNames_FileIndex;
+ AString _libFiles[2];
+ unsigned _numLibFiles;
+ AString _errorMessage;
+ bool _isArc;
+
+ void UpdateErrorMessage(const char *s);
+
+ HRESULT ParseLongNames(IInStream *stream);
+ void ChangeDuplicateNames();
+ int FindItem(UInt32 offset) const;
+ HRESULT AddFunc(UInt32 offset, const Byte *data, size_t size, size_t &pos);
+ HRESULT ParseLibSymbols(IInStream *stream, unsigned fileIndex);
+};
+
+void CHandler::UpdateErrorMessage(const char *s)
+{
+ if (!_errorMessage.IsEmpty())
+ _errorMessage += '\n';
+ _errorMessage += s;
+}
+
+static const Byte kArcProps[] =
+{
+ kpidSubType
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidMTime,
+ kpidPosixAttrib,
+ kpidUserId,
+ kpidGroupId
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+HRESULT CHandler::ParseLongNames(IInStream *stream)
+{
+ unsigned i;
+ for (i = 0; i < _items.Size(); i++)
+ if (_items[i].Name == "//")
+ break;
+ if (i == _items.Size())
+ return S_OK;
+
+ unsigned fileIndex = i;
+ const CItem &item = _items[fileIndex];
+ if (item.Size > ((UInt32)1 << 30))
+ return S_FALSE;
+ RINOK(InStream_SeekSet(stream, item.GetDataPos()))
+ const size_t size = (size_t)item.Size;
+
+ CByteArr p(size);
+ RINOK(ReadStream_FALSE(stream, p, size))
+
+ for (i = 0; i < _items.Size(); i++)
+ {
+ CItem &item2 = _items[i];
+ if (item2.Name[0] != '/')
+ continue;
+ const char *ptr = item2.Name.Ptr(1);
+ const char *end;
+ UInt32 pos = ConvertStringToUInt32(ptr, &end);
+ if (*end != 0 || end == ptr)
+ continue;
+ if (pos >= size)
+ continue;
+ UInt32 start = pos;
+ for (;;)
+ {
+ if (pos >= size)
+ return S_FALSE;
+ const Byte c = p[pos];
+ if (c == 0 || c == 0x0A)
+ break;
+ pos++;
+ }
+ item2.Name.SetFrom((const char *)(p + start), (unsigned)(pos - start));
+ }
+
+ _longNames_FileIndex = (int)fileIndex;
+ return S_OK;
+}
+
+void CHandler::ChangeDuplicateNames()
+{
+ unsigned i;
+ for (i = 1; i < _items.Size(); i++)
+ {
+ CItem &item = _items[i];
+ if (item.Name[0] == '/')
+ continue;
+ CItem &prev = _items[i - 1];
+ if (item.Name == prev.Name)
+ {
+ if (prev.SameNameIndex < 0)
+ prev.SameNameIndex = 0;
+ item.SameNameIndex = prev.SameNameIndex + 1;
+ }
+ }
+ for (i = 0; i < _items.Size(); i++)
+ {
+ CItem &item = _items[i];
+ if (item.SameNameIndex < 0)
+ continue;
+ char sz[32];
+ ConvertUInt32ToString((unsigned)item.SameNameIndex + 1, sz);
+ unsigned len = MyStringLen(sz);
+ sz[len++] = '.';
+ sz[len] = 0;
+ item.Name.Insert(0, sz);
+ }
+}
+
+int CHandler::FindItem(UInt32 offset) const
+{
+ unsigned left = 0, right = _items.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const UInt64 midVal = _items[mid].HeaderPos;
+ if (offset == midVal)
+ return (int)mid;
+ if (offset < midVal)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+}
+
+HRESULT CHandler::AddFunc(UInt32 offset, const Byte *data, size_t size, size_t &pos)
+{
+ const int fileIndex = FindItem(offset);
+ if (fileIndex < (int)0)
+ return S_FALSE;
+
+ size_t i = pos;
+ do
+ {
+ if (i >= size)
+ return S_FALSE;
+ }
+ while (data[i++] != 0);
+
+ AString &s = _libFiles[_numLibFiles];
+ const AString &name = _items[(unsigned)fileIndex].Name;
+ s += name;
+ if (!name.IsEmpty() && name.Back() == '/')
+ s.DeleteBack();
+ s += " ";
+ s += (const char *)(data + pos);
+ s += (char)0xD;
+ s += (char)0xA;
+ pos = i;
+ return S_OK;
+}
+
+static UInt32 Get32(const Byte *p, unsigned be) { if (be) return GetBe32(p); return GetUi32(p); }
+
+HRESULT CHandler::ParseLibSymbols(IInStream *stream, unsigned fileIndex)
+{
+ CItem &item = _items[fileIndex];
+ if (item.Name != "/" &&
+ item.Name != "__.SYMDEF" &&
+ item.Name != "__.SYMDEF SORTED")
+ return S_OK;
+ if (item.Size > ((UInt32)1 << 30) ||
+ item.Size < 4)
+ return S_OK;
+ RINOK(InStream_SeekSet(stream, item.GetDataPos()))
+ size_t size = (size_t)item.Size;
+ CByteArr p(size);
+ RINOK(ReadStream_FALSE(stream, p, size))
+
+ size_t pos = 0;
+
+ if (item.Name != "/")
+ {
+ // "__.SYMDEF" parsing (BSD)
+ unsigned be;
+ for (be = 0; be < 2; be++)
+ {
+ const UInt32 tableSize = Get32(p, be);
+ pos = 4;
+ if (size - pos < tableSize || (tableSize & 7) != 0)
+ continue;
+ size_t namesStart = pos + tableSize;
+ const UInt32 namesSize = Get32(p + namesStart, be);
+ namesStart += 4;
+ if (namesStart > size || namesStart + namesSize != size)
+ continue;
+
+ const UInt32 numSymbols = tableSize >> 3;
+ UInt32 i;
+ for (i = 0; i < numSymbols; i++, pos += 8)
+ {
+ size_t namePos = Get32(p + pos, be);
+ const UInt32 offset = Get32(p + pos + 4, be);
+ if (AddFunc(offset, p + namesStart, namesSize, namePos) != S_OK)
+ break;
+ }
+ if (i == numSymbols)
+ {
+ pos = size;
+ _type = kType_ALib;
+ _subType = kSubType_BSD;
+ break;
+ }
+ }
+ if (be == 2)
+ return S_FALSE;
+ }
+ else if (_numLibFiles == 0)
+ {
+ // archive symbol table (GNU)
+ const UInt32 numSymbols = GetBe32(p);
+ pos = 4;
+ if (numSymbols > (size - pos) / 4)
+ return S_FALSE;
+ pos += 4 * numSymbols;
+
+ for (UInt32 i = 0; i < numSymbols; i++)
+ {
+ const UInt32 offset = GetBe32(p + 4 + i * 4);
+ RINOK(AddFunc(offset, p, size, pos))
+ }
+ _type = kType_ALib;
+ }
+ else
+ {
+ // Second linker file (Microsoft .lib)
+ const UInt32 numMembers = GetUi32(p);
+ pos = 4;
+ if (numMembers > (size - pos) / 4)
+ return S_FALSE;
+ pos += 4 * numMembers;
+
+ if (size - pos < 4)
+ return S_FALSE;
+ const UInt32 numSymbols = GetUi32(p + pos);
+ pos += 4;
+ if (numSymbols > (size - pos) / 2)
+ return S_FALSE;
+ size_t indexStart = pos;
+ pos += 2 * numSymbols;
+
+ for (UInt32 i = 0; i < numSymbols; i++)
+ {
+ // index is 1-based. So 32-bit numSymbols field works as item[0]
+ const UInt32 index = GetUi16(p + indexStart + i * 2);
+ if (index == 0 || index > numMembers)
+ return S_FALSE;
+ const UInt32 offset = GetUi32(p + index * 4);
+ RINOK(AddFunc(offset, p, size, pos))
+ }
+ _type = kType_Lib;
+ }
+ // size can be 2-byte aligned in linux files
+ if (pos != size && pos + (pos & 1) != size)
+ return S_FALSE;
+ item.TextFileIndex = (int)(_numLibFiles++);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+
+ UInt64 fileSize;
+ RINOK(InStream_AtBegin_GetSize(stream, fileSize))
+
+ CInArchive arc;
+ RINOK(arc.Open(stream))
+
+ if (callback)
+ {
+ RINOK(callback->SetTotal(NULL, &fileSize))
+ const UInt64 numFiles = _items.Size();
+ RINOK(callback->SetCompleted(&numFiles, &arc.Position))
+ }
+
+ CItem item;
+ for (;;)
+ {
+ bool filled;
+ RINOK(arc.GetNextItem(item, filled))
+ if (!filled)
+ break;
+ _items.Add(item);
+ arc.SkipData(item.Size);
+ if (callback && (_items.Size() & 0xFF) == 0)
+ {
+ UInt64 numFiles = _items.Size();
+ RINOK(callback->SetCompleted(&numFiles, &arc.Position))
+ }
+ }
+
+ if (_items.IsEmpty())
+ {
+ // we don't need false empty archives (8-bytes signature only)
+ if (arc.Position != fileSize)
+ return S_FALSE;
+ }
+
+ _isArc = true;
+
+ _subType = arc.SubType;
+
+ if (ParseLongNames(stream) != S_OK)
+ UpdateErrorMessage("Long file names parsing error");
+ if (_longNames_FileIndex >= 0)
+ _items.Delete((unsigned)_longNames_FileIndex);
+
+ if (!_items.IsEmpty() && _items[0].Name == "debian-binary")
+ {
+ _type = kType_Deb;
+ _items.DeleteFrontal(1);
+ for (unsigned i = 0; i < _items.Size(); i++)
+ if (_items[i].Name.IsPrefixedBy("data.tar."))
+ {
+ if (_mainSubfile < 0)
+ _mainSubfile = (int)i;
+ else
+ {
+ _mainSubfile = -1;
+ break;
+ }
+ }
+ }
+ else
+ {
+ ChangeDuplicateNames();
+ bool error = false;
+ for (unsigned li = 0; li < 2 && li < _items.Size(); li++)
+ if (ParseLibSymbols(stream, li) != S_OK)
+ error = true;
+ if (error)
+ UpdateErrorMessage("Library symbols information error");
+ }
+
+ _stream = stream;
+ _phySize = arc.Position;
+
+ /*
+ if (fileSize < _phySize)
+ UpdateErrorMessage("Unexpected end of archive");
+ */
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _phySize = 0;
+
+ _errorMessage.Empty();
+ _stream.Release();
+ _items.Clear();
+
+ _type = kType_Ar;
+ _subType = kSubType_None;
+ _mainSubfile = -1;
+ _longNames_FileIndex = -1;
+
+ _numLibFiles = 0;
+ _libFiles[0].Empty();
+ _libFiles[1].Empty();
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _phySize; break;
+ case kpidMainSubfile: if (_mainSubfile >= 0) prop = (UInt32)_mainSubfile; break;
+ case kpidExtension: prop = k_TypeExtionsions[(unsigned)_type]; break;
+ case kpidShortComment:
+ case kpidSubType:
+ {
+ AString s (k_TypeExtionsions[(unsigned)_type]);
+ if (_subType == kSubType_BSD)
+ s += ":BSD";
+ prop = s;
+ break;
+ }
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ prop = v;
+ break;
+ }
+ case kpidWarning: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
+ case kpidIsNotArcType: if (_type != kType_Deb) prop = true; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CItem &item = _items[index];
+ switch (propID)
+ {
+ case kpidPath:
+ if (item.TextFileIndex >= 0)
+ prop = (item.TextFileIndex == 0) ? "1.txt" : "2.txt";
+ else
+ prop = (const wchar_t *)NItemName::GetOsPath_Remove_TailSlash(MultiByteToUnicodeString(item.Name, CP_OEMCP));
+ break;
+ case kpidSize:
+ case kpidPackSize:
+ if (item.TextFileIndex >= 0)
+ prop = (UInt64)_libFiles[(unsigned)item.TextFileIndex].Len();
+ else
+ prop = item.Size;
+ break;
+ case kpidMTime:
+ {
+ if (item.MTime != 0)
+ PropVariant_SetFrom_UnixTime(prop, item.MTime);
+ break;
+ }
+ case kpidUserId: if (item.User != 0) prop = item.User; break;
+ case kpidGroupId: if (item.Group != 0) prop = item.Group; break;
+ case kpidPosixAttrib:
+ if (item.TextFileIndex < 0)
+ prop = item.Mode;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItem &item = _items[allFilesMode ? i : indices[i]];
+ totalSize +=
+ (item.TextFileIndex >= 0) ?
+ (UInt64)_libFiles[(unsigned)item.TextFileIndex].Len() : item.Size;
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = _items[index];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ currentTotalSize += (item.TextFileIndex >= 0) ?
+ (UInt64)_libFiles[(unsigned)item.TextFileIndex].Len() : item.Size;
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (testMode)
+ {
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ bool isOk = true;
+ if (item.TextFileIndex >= 0)
+ {
+ const AString &f = _libFiles[(unsigned)item.TextFileIndex];
+ if (realOutStream)
+ RINOK(WriteStream(realOutStream, f, f.Len()))
+ }
+ else
+ {
+ RINOK(InStream_SeekSet(_stream, item.GetDataPos()))
+ streamSpec->Init(item.Size);
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ isOk = (copyCoderSpec->TotalSize == item.Size);
+ }
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(isOk ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ const CItem &item = _items[index];
+ if (item.TextFileIndex >= 0)
+ {
+ const AString &f = _libFiles[(unsigned)item.TextFileIndex];
+ Create_BufInStream_WithNewBuffer((const void *)(const char *)f, f.Len(), stream);
+ return S_OK;
+ }
+ else
+ return CreateLimitedInStream(_stream, item.GetDataPos(), item.Size, stream);
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "Ar", "ar a deb udeb lib", NULL, 0xEC,
+ kSignature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Archive.def b/CPP/7zip/Archive/Archive.def
index a3fe6dd..2ed6246 100644
--- a/CPP/7zip/Archive/Archive.def
+++ b/CPP/7zip/Archive/Archive.def
@@ -1,12 +1,14 @@
-EXPORTS
- CreateObject PRIVATE
-
- GetHandlerProperty PRIVATE
- GetNumberOfFormats PRIVATE
- GetHandlerProperty2 PRIVATE
- GetIsArc PRIVATE
-
- SetCodecs PRIVATE
-
- SetLargePageMode PRIVATE
- SetCaseSensitive PRIVATE
+EXPORTS
+ CreateObject PRIVATE
+
+ GetHandlerProperty PRIVATE
+ GetNumberOfFormats PRIVATE
+ GetHandlerProperty2 PRIVATE
+ GetIsArc PRIVATE
+
+ SetCodecs PRIVATE
+
+ SetLargePageMode PRIVATE
+ SetCaseSensitive PRIVATE
+
+ GetModuleProp PRIVATE
diff --git a/CPP/7zip/Archive/Archive2.def b/CPP/7zip/Archive/Archive2.def
index de744b5..f891ad3 100644
--- a/CPP/7zip/Archive/Archive2.def
+++ b/CPP/7zip/Archive/Archive2.def
@@ -1,19 +1,21 @@
-EXPORTS
- CreateObject PRIVATE
-
- GetHandlerProperty PRIVATE
- GetNumberOfFormats PRIVATE
- GetHandlerProperty2 PRIVATE
- GetIsArc PRIVATE
-
- GetNumberOfMethods PRIVATE
- GetMethodProperty PRIVATE
- CreateDecoder PRIVATE
- CreateEncoder PRIVATE
-
- GetHashers PRIVATE
-
- SetCodecs PRIVATE
-
- SetLargePageMode PRIVATE
- SetCaseSensitive PRIVATE
+EXPORTS
+ CreateObject PRIVATE
+
+ GetHandlerProperty PRIVATE
+ GetNumberOfFormats PRIVATE
+ GetHandlerProperty2 PRIVATE
+ GetIsArc PRIVATE
+
+ GetNumberOfMethods PRIVATE
+ GetMethodProperty PRIVATE
+ CreateDecoder PRIVATE
+ CreateEncoder PRIVATE
+
+ GetHashers PRIVATE
+
+ SetCodecs PRIVATE
+
+ SetLargePageMode PRIVATE
+ SetCaseSensitive PRIVATE
+
+ GetModuleProp PRIVATE
diff --git a/CPP/7zip/Archive/ArchiveExports.cpp b/CPP/7zip/Archive/ArchiveExports.cpp
index 94f2fff..4735fcf 100644
--- a/CPP/7zip/Archive/ArchiveExports.cpp
+++ b/CPP/7zip/Archive/ArchiveExports.cpp
@@ -1,151 +1,158 @@
-// ArchiveExports.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/7zVersion.h"
-
-#include "../../Common/ComTry.h"
-
-#include "../../Windows/PropVariant.h"
-
-#include "../Common/RegisterArc.h"
-
-static const unsigned kNumArcsMax = 64;
-static unsigned g_NumArcs = 0;
-static unsigned g_DefaultArcIndex = 0;
-static const CArcInfo *g_Arcs[kNumArcsMax];
-
-void RegisterArc(const CArcInfo *arcInfo) throw()
-{
- if (g_NumArcs < kNumArcsMax)
- {
- const char *p = arcInfo->Name;
- if (p[0] == '7' && p[1] == 'z' && p[2] == 0)
- g_DefaultArcIndex = g_NumArcs;
- g_Arcs[g_NumArcs++] = arcInfo;
- }
-}
-
-DEFINE_GUID(CLSID_CArchiveHandler,
- k_7zip_GUID_Data1,
- k_7zip_GUID_Data2,
- k_7zip_GUID_Data3_Common,
- 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
-
-#define CLS_ARC_ID_ITEM(cls) ((cls).Data4[5])
-
-static inline HRESULT SetPropStrFromBin(const char *s, unsigned size, PROPVARIANT *value)
-{
- if ((value->bstrVal = ::SysAllocStringByteLen(s, size)) != 0)
- value->vt = VT_BSTR;
- return S_OK;
-}
-
-static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value)
-{
- return SetPropStrFromBin((const char *)&guid, sizeof(guid), value);
-}
-
-int FindFormatCalssId(const GUID *clsid)
-{
- GUID cls = *clsid;
- CLS_ARC_ID_ITEM(cls) = 0;
- if (cls != CLSID_CArchiveHandler)
- return -1;
- Byte id = CLS_ARC_ID_ITEM(*clsid);
- for (unsigned i = 0; i < g_NumArcs; i++)
- if (g_Arcs[i]->Id == id)
- return (int)i;
- return -1;
-}
-
-STDAPI CreateArchiver(const GUID *clsid, const GUID *iid, void **outObject)
-{
- COM_TRY_BEGIN
- {
- int needIn = (*iid == IID_IInArchive);
- int needOut = (*iid == IID_IOutArchive);
- if (!needIn && !needOut)
- return E_NOINTERFACE;
- int formatIndex = FindFormatCalssId(clsid);
- if (formatIndex < 0)
- return CLASS_E_CLASSNOTAVAILABLE;
-
- const CArcInfo &arc = *g_Arcs[formatIndex];
- if (needIn)
- {
- *outObject = arc.CreateInArchive();
- ((IInArchive *)*outObject)->AddRef();
- }
- else
- {
- if (!arc.CreateOutArchive)
- return CLASS_E_CLASSNOTAVAILABLE;
- *outObject = arc.CreateOutArchive();
- ((IOutArchive *)*outObject)->AddRef();
- }
- }
- COM_TRY_END
- return S_OK;
-}
-
-STDAPI GetHandlerProperty2(UInt32 formatIndex, PROPID propID, PROPVARIANT *value)
-{
- COM_TRY_BEGIN
- NWindows::NCOM::PropVariant_Clear(value);
- if (formatIndex >= g_NumArcs)
- return E_INVALIDARG;
- const CArcInfo &arc = *g_Arcs[formatIndex];
- NWindows::NCOM::CPropVariant prop;
- switch (propID)
- {
- case NArchive::NHandlerPropID::kName: prop = arc.Name; break;
- case NArchive::NHandlerPropID::kClassID:
- {
- GUID clsId = CLSID_CArchiveHandler;
- CLS_ARC_ID_ITEM(clsId) = arc.Id;
- return SetPropGUID(clsId, value);
- }
- case NArchive::NHandlerPropID::kExtension: if (arc.Ext) prop = arc.Ext; break;
- case NArchive::NHandlerPropID::kAddExtension: if (arc.AddExt) prop = arc.AddExt; break;
- case NArchive::NHandlerPropID::kUpdate: prop = (bool)(arc.CreateOutArchive != NULL); break;
- case NArchive::NHandlerPropID::kKeepName: prop = ((arc.Flags & NArcInfoFlags::kKeepName) != 0); break;
- case NArchive::NHandlerPropID::kAltStreams: prop = ((arc.Flags & NArcInfoFlags::kAltStreams) != 0); break;
- case NArchive::NHandlerPropID::kNtSecure: prop = ((arc.Flags & NArcInfoFlags::kNtSecure) != 0); break;
- case NArchive::NHandlerPropID::kFlags: prop = (UInt32)arc.Flags; break;
- case NArchive::NHandlerPropID::kSignatureOffset: prop = (UInt32)arc.SignatureOffset; break;
- // case NArchive::NHandlerPropID::kVersion: prop = (UInt32)MY_VER_MIX; break;
-
- case NArchive::NHandlerPropID::kSignature:
- if (arc.SignatureSize != 0 && !arc.IsMultiSignature())
- return SetPropStrFromBin((const char *)arc.Signature, arc.SignatureSize, value);
- break;
- case NArchive::NHandlerPropID::kMultiSignature:
- if (arc.SignatureSize != 0 && arc.IsMultiSignature())
- return SetPropStrFromBin((const char *)arc.Signature, arc.SignatureSize, value);
- break;
- }
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
-}
-
-STDAPI GetHandlerProperty(PROPID propID, PROPVARIANT *value)
-{
- return GetHandlerProperty2(g_DefaultArcIndex, propID, value);
-}
-
-STDAPI GetNumberOfFormats(UINT32 *numFormats)
-{
- *numFormats = g_NumArcs;
- return S_OK;
-}
-
-STDAPI GetIsArc(UInt32 formatIndex, Func_IsArc *isArc)
-{
- *isArc = NULL;
- if (formatIndex >= g_NumArcs)
- return E_INVALIDARG;
- *isArc = g_Arcs[formatIndex]->IsArc;
- return S_OK;
-}
+// ArchiveExports.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zVersion.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+
+static const unsigned kNumArcsMax = 72;
+static unsigned g_NumArcs = 0;
+static unsigned g_DefaultArcIndex = 0;
+static const CArcInfo *g_Arcs[kNumArcsMax];
+
+void RegisterArc(const CArcInfo *arcInfo) throw()
+{
+ if (g_NumArcs < kNumArcsMax)
+ {
+ const char *p = arcInfo->Name;
+ if (p[0] == '7' && p[1] == 'z' && p[2] == 0)
+ g_DefaultArcIndex = g_NumArcs;
+ g_Arcs[g_NumArcs++] = arcInfo;
+ }
+ // else throw 1;
+}
+
+Z7_DEFINE_GUID(CLSID_CArchiveHandler,
+ k_7zip_GUID_Data1,
+ k_7zip_GUID_Data2,
+ k_7zip_GUID_Data3_Common,
+ 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
+
+#define CLS_ARC_ID_ITEM(cls) ((cls).Data4[5])
+
+static inline HRESULT SetPropStrFromBin(const char *s, unsigned size, PROPVARIANT *value)
+{
+ if ((value->bstrVal = ::SysAllocStringByteLen(s, size)) != NULL)
+ value->vt = VT_BSTR;
+ return S_OK;
+}
+
+static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value)
+{
+ return SetPropStrFromBin((const char *)&guid, sizeof(guid), value);
+}
+
+static int FindFormatCalssId(const GUID *clsid)
+{
+ GUID cls = *clsid;
+ CLS_ARC_ID_ITEM(cls) = 0;
+ if (cls != CLSID_CArchiveHandler)
+ return -1;
+ const Byte id = CLS_ARC_ID_ITEM(*clsid);
+ for (unsigned i = 0; i < g_NumArcs; i++)
+ if (g_Arcs[i]->Id == id)
+ return (int)i;
+ return -1;
+}
+
+STDAPI CreateArchiver(const GUID *clsid, const GUID *iid, void **outObject);
+STDAPI CreateArchiver(const GUID *clsid, const GUID *iid, void **outObject)
+{
+ COM_TRY_BEGIN
+ {
+ const int needIn = (*iid == IID_IInArchive);
+ const int needOut = (*iid == IID_IOutArchive);
+ if (!needIn && !needOut)
+ return E_NOINTERFACE;
+ const int formatIndex = FindFormatCalssId(clsid);
+ if (formatIndex < 0)
+ return CLASS_E_CLASSNOTAVAILABLE;
+
+ const CArcInfo &arc = *g_Arcs[formatIndex];
+ if (needIn)
+ {
+ *outObject = arc.CreateInArchive();
+ ((IInArchive *)*outObject)->AddRef();
+ }
+ else
+ {
+ if (!arc.CreateOutArchive)
+ return CLASS_E_CLASSNOTAVAILABLE;
+ *outObject = arc.CreateOutArchive();
+ ((IOutArchive *)*outObject)->AddRef();
+ }
+ }
+ COM_TRY_END
+ return S_OK;
+}
+
+STDAPI GetHandlerProperty2(UInt32 formatIndex, PROPID propID, PROPVARIANT *value);
+STDAPI GetHandlerProperty2(UInt32 formatIndex, PROPID propID, PROPVARIANT *value)
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::PropVariant_Clear(value);
+ if (formatIndex >= g_NumArcs)
+ return E_INVALIDARG;
+ const CArcInfo &arc = *g_Arcs[formatIndex];
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case NArchive::NHandlerPropID::kName: prop = arc.Name; break;
+ case NArchive::NHandlerPropID::kClassID:
+ {
+ GUID clsId = CLSID_CArchiveHandler;
+ CLS_ARC_ID_ITEM(clsId) = arc.Id;
+ return SetPropGUID(clsId, value);
+ }
+ case NArchive::NHandlerPropID::kExtension: if (arc.Ext) prop = arc.Ext; break;
+ case NArchive::NHandlerPropID::kAddExtension: if (arc.AddExt) prop = arc.AddExt; break;
+ case NArchive::NHandlerPropID::kUpdate: prop = (bool)(arc.CreateOutArchive != NULL); break;
+ case NArchive::NHandlerPropID::kKeepName: prop = ((arc.Flags & NArcInfoFlags::kKeepName) != 0); break;
+ case NArchive::NHandlerPropID::kAltStreams: prop = ((arc.Flags & NArcInfoFlags::kAltStreams) != 0); break;
+ case NArchive::NHandlerPropID::kNtSecure: prop = ((arc.Flags & NArcInfoFlags::kNtSecure) != 0); break;
+ case NArchive::NHandlerPropID::kFlags: prop = (UInt32)arc.Flags; break;
+ case NArchive::NHandlerPropID::kTimeFlags: prop = (UInt32)arc.TimeFlags; break;
+ case NArchive::NHandlerPropID::kSignatureOffset: prop = (UInt32)arc.SignatureOffset; break;
+ // case NArchive::NHandlerPropID::kVersion: prop = (UInt32)MY_VER_MIX; break;
+
+ case NArchive::NHandlerPropID::kSignature:
+ if (arc.SignatureSize != 0 && !arc.IsMultiSignature())
+ return SetPropStrFromBin((const char *)arc.Signature, arc.SignatureSize, value);
+ break;
+ case NArchive::NHandlerPropID::kMultiSignature:
+ if (arc.SignatureSize != 0 && arc.IsMultiSignature())
+ return SetPropStrFromBin((const char *)arc.Signature, arc.SignatureSize, value);
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+STDAPI GetHandlerProperty(PROPID propID, PROPVARIANT *value);
+STDAPI GetHandlerProperty(PROPID propID, PROPVARIANT *value)
+{
+ return GetHandlerProperty2(g_DefaultArcIndex, propID, value);
+}
+
+STDAPI GetNumberOfFormats(UINT32 *numFormats);
+STDAPI GetNumberOfFormats(UINT32 *numFormats)
+{
+ *numFormats = g_NumArcs;
+ return S_OK;
+}
+
+STDAPI GetIsArc(UInt32 formatIndex, Func_IsArc *isArc);
+STDAPI GetIsArc(UInt32 formatIndex, Func_IsArc *isArc)
+{
+ *isArc = NULL;
+ if (formatIndex >= g_NumArcs)
+ return E_INVALIDARG;
+ *isArc = g_Arcs[formatIndex]->IsArc;
+ return S_OK;
+}
diff --git a/CPP/7zip/Archive/ArjHandler.cpp b/CPP/7zip/Archive/ArjHandler.cpp
new file mode 100644
index 0000000..2f982c4
--- /dev/null
+++ b/CPP/7zip/Archive/ArjHandler.cpp
@@ -0,0 +1,1009 @@
+// ArjHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/LzhDecoder.h"
+
+#include "Common/ItemNameUtils.h"
+#include "Common/OutStreamWithCRC.h"
+
+namespace NCompress {
+namespace NArj {
+namespace NDecoder {
+
+static const unsigned kMatchMinLen = 3;
+
+static const UInt32 kWindowSize = 1 << 15; // must be >= (1 << 14)
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CCoder
+ , ICompressCoder
+)
+ CLzOutWindow _outWindow;
+ NBitm::CDecoder<CInBuffer> _inBitStream;
+
+ class CCoderReleaser
+ {
+ CCoder *_coder;
+ public:
+ CCoderReleaser(CCoder *coder): _coder(coder) {}
+ void Disable() { _coder = NULL; }
+ ~CCoderReleaser() { if (_coder) _coder->_outWindow.Flush(); }
+ };
+ friend class CCoderReleaser;
+
+ HRESULT CodeReal(UInt64 outSize, ICompressProgressInfo *progress);
+public:
+ bool FinishMode;
+
+ CCoder(): FinishMode(false) {}
+ UInt64 GetInputProcessedSize() const { return _inBitStream.GetProcessedSize(); }
+};
+
+
+HRESULT CCoder::CodeReal(UInt64 rem, ICompressProgressInfo *progress)
+{
+ const UInt32 kStep = 1 << 20;
+ UInt64 next = 0;
+ if (rem > kStep && progress)
+ next = rem - kStep;
+
+ while (rem != 0)
+ {
+ if (rem <= next)
+ {
+ if (_inBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ UInt64 packSize = _inBitStream.GetProcessedSize();
+ UInt64 pos = _outWindow.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &pos))
+ next = 0;
+ if (rem > kStep)
+ next = rem - kStep;
+ }
+
+ UInt32 len;
+
+ {
+ const unsigned kNumBits = 7 + 7;
+ UInt32 val = _inBitStream.GetValue(kNumBits);
+
+ if ((val & (1 << (kNumBits - 1))) == 0)
+ {
+ _outWindow.PutByte((Byte)(val >> 5));
+ _inBitStream.MovePos(1 + 8);
+ rem--;
+ continue;
+ }
+
+ UInt32 mask = 1 << (kNumBits - 2);
+ unsigned w;
+
+ for (w = 1; w < 7; w++, mask >>= 1)
+ if ((val & mask) == 0)
+ break;
+
+ unsigned readBits = (w != 7 ? 1 : 0);
+ readBits += w + w;
+ len = (1 << w) - 1 + kMatchMinLen - 1 +
+ (((val >> (kNumBits - readBits)) & ((1 << w) - 1)));
+ _inBitStream.MovePos(readBits);
+ }
+
+ {
+ const unsigned kNumBits = 4 + 13;
+ UInt32 val = _inBitStream.GetValue(kNumBits);
+
+ unsigned readBits = 1;
+ unsigned w;
+
+ if ((val & ((UInt32)1 << 16)) == 0) w = 9;
+ else if ((val & ((UInt32)1 << 15)) == 0) w = 10;
+ else if ((val & ((UInt32)1 << 14)) == 0) w = 11;
+ else if ((val & ((UInt32)1 << 13)) == 0) w = 12;
+ else { w = 13; readBits = 0; }
+
+ readBits += w + w - 9;
+
+ UInt32 dist = ((UInt32)1 << w) - (1 << 9) +
+ (((val >> (kNumBits - readBits)) & ((1 << w) - 1)));
+ _inBitStream.MovePos(readBits);
+
+ if (len > rem)
+ len = (UInt32)rem;
+
+ if (!_outWindow.CopyBlock(dist, len))
+ return S_FALSE;
+ rem -= len;
+ }
+ }
+
+ if (FinishMode)
+ {
+ if (_inBitStream.ReadAlignBits() != 0)
+ return S_FALSE;
+ }
+
+ if (_inBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+
+Z7_COM7F_IMF(CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try
+ {
+ if (!outSize)
+ return E_INVALIDARG;
+
+ if (!_outWindow.Create(kWindowSize))
+ return E_OUTOFMEMORY;
+ if (!_inBitStream.Create(1 << 17))
+ return E_OUTOFMEMORY;
+
+ _outWindow.SetStream(outStream);
+ _outWindow.Init(false);
+ _inBitStream.SetStream(inStream);
+ _inBitStream.Init();
+
+ CCoderReleaser coderReleaser(this);
+ HRESULT res;
+ {
+ res = CodeReal(*outSize, progress);
+ if (res != S_OK)
+ return res;
+ }
+
+ coderReleaser.Disable();
+ return _outWindow.Flush();
+ }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+}}}
+
+
+
+
+using namespace NWindows;
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+namespace NArchive {
+namespace NArj {
+
+static const unsigned kBlockSizeMin = 30;
+static const unsigned kBlockSizeMax = 2600;
+
+static const Byte kSig0 = 0x60;
+static const Byte kSig1 = 0xEA;
+
+namespace NCompressionMethod
+{
+ enum
+ {
+ kStored = 0,
+ kCompressed1a = 1,
+ kCompressed1b = 2,
+ kCompressed1c = 3,
+ kCompressed2 = 4,
+ kNoDataNoCRC = 8,
+ kNoData = 9
+ };
+}
+
+namespace NFileType
+{
+ enum
+ {
+ kBinary = 0,
+ k7BitText,
+ kArchiveHeader,
+ kDirectory,
+ kVolumeLablel,
+ kChapterLabel
+ };
+}
+
+namespace NFlags
+{
+ const Byte kGarbled = 1 << 0;
+ // const Byte kAnsiPage = 1 << 1; // or (OLD_SECURED_FLAG) obsolete
+ const Byte kVolume = 1 << 2;
+ const Byte kExtFile = 1 << 3;
+ // const Byte kPathSym = 1 << 4;
+ // const Byte kBackup = 1 << 5; // obsolete
+ // const Byte kSecured = 1 << 6;
+ // const Byte kDualName = 1 << 7;
+}
+
+namespace NHostOS
+{
+ enum EEnum
+ {
+ kMSDOS = 0, // MS-DOS, OS/2, Win32, pkarj 2.50 (FAT / VFAT / FAT32)
+ kPRIMOS,
+ kUnix,
+ kAMIGA,
+ kMac,
+ kOS_2,
+ kAPPLE_GS,
+ kAtari_ST,
+ kNext,
+ kVAX_VMS,
+ kWIN95
+ };
+}
+
+static const char * const kHostOS[] =
+{
+ "MSDOS"
+ , "PRIMOS"
+ , "UNIX"
+ , "AMIGA"
+ , "MAC"
+ , "OS/2"
+ , "APPLE GS"
+ , "ATARI ST"
+ , "NEXT"
+ , "VAX VMS"
+ , "WIN95"
+};
+
+struct CArcHeader
+{
+ // Byte ArchiverVersion;
+ // Byte ExtractVersion;
+ Byte HostOS;
+ // Byte Flags;
+ // Byte SecuryVersion;
+ // Byte FileType;
+ // Byte Reserved;
+ UInt32 CTime;
+ UInt32 MTime;
+ UInt32 ArchiveSize;
+ // UInt32 SecurPos;
+ // UInt16 FilespecPosInFilename;
+ UInt16 SecurSize;
+ // Byte EncryptionVersion;
+ // Byte LastChapter;
+ AString Name;
+ AString Comment;
+
+ HRESULT Parse(const Byte *p, unsigned size);
+};
+
+API_FUNC_static_IsArc IsArc_Arj(const Byte *p, size_t size)
+{
+ if (size < kBlockSizeMin + 4)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != kSig0 || p[1] != kSig1)
+ return k_IsArc_Res_NO;
+ UInt32 blockSize = Get16(p + 2);
+ if (blockSize < kBlockSizeMin ||
+ blockSize > kBlockSizeMax)
+ return k_IsArc_Res_NO;
+
+ p += 4;
+ size -= 4;
+
+ Byte headerSize = p[0];
+ if (headerSize < kBlockSizeMin ||
+ headerSize > blockSize ||
+ p[6] != NFileType::kArchiveHeader ||
+ p[28] > 8) // EncryptionVersion
+ return k_IsArc_Res_NO;
+
+ if (blockSize + 4 <= size)
+ if (Get32(p + blockSize) != CrcCalc(p, blockSize))
+ return k_IsArc_Res_NO;
+
+ return k_IsArc_Res_YES;
+}
+}
+
+static HRESULT ReadString(const Byte *p, unsigned &size, AString &res)
+{
+ unsigned num = size;
+ for (unsigned i = 0; i < num;)
+ {
+ if (p[i++] == 0)
+ {
+ size = i;
+ res = (const char *)p;
+ return S_OK;
+ }
+ }
+ return S_FALSE;
+}
+
+HRESULT CArcHeader::Parse(const Byte *p, unsigned size)
+{
+ Byte headerSize = p[0];
+ if (headerSize < kBlockSizeMin || headerSize > size)
+ return S_FALSE;
+ // ArchiverVersion = p[1];
+ // ExtractVersion = p[2];
+ HostOS = p[3];
+ // Flags = p[4];
+ // SecuryVersion = p[5];
+ if (p[6] != NFileType::kArchiveHeader)
+ return S_FALSE;
+ // Reserved = p[7];
+ CTime = Get32(p + 8);
+ MTime = Get32(p + 12);
+ ArchiveSize = Get32(p + 16); // it can be zero. (currently used only for secured archives)
+ // SecurPos = Get32(p + 20);
+ // UInt16 filespecPositionInFilename = Get16(p + 24);
+ SecurSize = Get16(p + 26);
+ // EncryptionVersion = p[28];
+ // LastChapter = p[29];
+ unsigned pos = headerSize;
+ unsigned size1 = size - pos;
+ RINOK(ReadString(p + pos, size1, Name))
+ pos += size1;
+ size1 = size - pos;
+ RINOK(ReadString(p + pos, size1, Comment))
+ pos += size1;
+ return S_OK;
+}
+
+
+struct CExtendedInfo
+{
+ UInt64 Size;
+ bool CrcError;
+
+ void Clear()
+ {
+ Size = 0;
+ CrcError = false;
+ }
+ void ParseToPropVar(NCOM::CPropVariant &prop) const
+ {
+ if (Size != 0)
+ {
+ AString s;
+ s += "Extended:";
+ s.Add_UInt32((UInt32)Size);
+ if (CrcError)
+ s += ":CRC_ERROR";
+ prop = s;
+ }
+ }
+};
+
+
+struct CItem
+{
+ AString Name;
+ AString Comment;
+
+ UInt32 MTime;
+ UInt32 PackSize;
+ UInt32 Size;
+ UInt32 FileCRC;
+ UInt32 SplitPos;
+
+ Byte Version;
+ Byte ExtractVersion;
+ Byte HostOS;
+ Byte Flags;
+ Byte Method;
+ Byte FileType;
+
+ // UInt16 FilespecPosInFilename;
+ UInt16 FileAccessMode;
+ // Byte FirstChapter;
+ // Byte LastChapter;
+
+ UInt64 DataPosition;
+
+ CExtendedInfo ExtendedInfo;
+
+ bool IsEncrypted() const { return (Flags & NFlags::kGarbled) != 0; }
+ bool IsDir() const { return (FileType == NFileType::kDirectory); }
+ bool IsSplitAfter() const { return (Flags & NFlags::kVolume) != 0; }
+ bool IsSplitBefore() const { return (Flags & NFlags::kExtFile) != 0; }
+ UInt32 GetWinAttrib() const
+ {
+ UInt32 atrrib = 0;
+ switch (HostOS)
+ {
+ case NHostOS::kMSDOS:
+ case NHostOS::kWIN95:
+ atrrib = FileAccessMode;
+ break;
+ }
+ if (IsDir())
+ atrrib |= FILE_ATTRIBUTE_DIRECTORY;
+ return atrrib;
+ }
+
+ HRESULT Parse(const Byte *p, unsigned size);
+};
+
+HRESULT CItem::Parse(const Byte *p, unsigned size)
+{
+ Byte headerSize = p[0];
+ if (headerSize < kBlockSizeMin || headerSize > size)
+ return S_FALSE;
+ Version = p[1];
+ ExtractVersion = p[2];
+ HostOS = p[3];
+ Flags = p[4];
+ Method = p[5];
+ FileType = p[6];
+ // Reserved = p[7];
+ MTime = Get32(p + 8);
+ PackSize = Get32(p + 12);
+ Size = Get32(p + 16);
+ FileCRC = Get32(p + 20);
+ // FilespecPosInFilename = Get16(p + 24);
+ FileAccessMode = Get16(p + 26);
+ // FirstChapter = p[28];
+ // FirstChapter = p[29];
+
+ SplitPos = 0;
+ if (IsSplitBefore() && headerSize >= 34)
+ SplitPos = Get32(p + 30);
+
+ unsigned pos = headerSize;
+ unsigned size1 = size - pos;
+ RINOK(ReadString(p + pos, size1, Name))
+ pos += size1;
+ size1 = size - pos;
+ RINOK(ReadString(p + pos, size1, Comment))
+ pos += size1;
+
+ return S_OK;
+}
+
+enum EErrorType
+{
+ k_ErrorType_OK,
+ k_ErrorType_Corrupted,
+ k_ErrorType_UnexpectedEnd
+};
+
+class CArc
+{
+public:
+ UInt64 Processed;
+ EErrorType Error;
+ bool IsArc;
+ IInStream *Stream;
+ IArchiveOpenCallback *Callback;
+ UInt64 NumFiles;
+ CArcHeader Header;
+
+ CExtendedInfo ExtendedInfo;
+
+ HRESULT Open();
+ HRESULT GetNextItem(CItem &item, bool &filled);
+ void Close()
+ {
+ IsArc = false;
+ Error = k_ErrorType_OK;
+ ExtendedInfo.Clear();
+ }
+private:
+ unsigned _blockSize;
+ CByteBuffer _block;
+
+ HRESULT ReadBlock(bool &filled, CExtendedInfo *extendedInfo);
+ HRESULT SkipExtendedHeaders(CExtendedInfo &extendedInfo);
+ HRESULT Read(void *data, size_t *size);
+};
+
+HRESULT CArc::Read(void *data, size_t *size)
+{
+ HRESULT res = ReadStream(Stream, data, size);
+ Processed += *size;
+ return res;
+}
+
+#define READ_STREAM(_dest_, _size_) \
+ { size_t _processed_ = (_size_); RINOK(Read(_dest_, &_processed_)); \
+ if (_processed_ != (_size_)) { Error = k_ErrorType_UnexpectedEnd; return S_OK; } }
+
+HRESULT CArc::ReadBlock(bool &filled, CExtendedInfo *extendedInfo)
+{
+ Error = k_ErrorType_OK;
+ filled = false;
+ Byte buf[4];
+ const unsigned signSize = extendedInfo ? 0 : 2;
+ READ_STREAM(buf, signSize + 2)
+ if (!extendedInfo)
+ if (buf[0] != kSig0 || buf[1] != kSig1)
+ {
+ Error = k_ErrorType_Corrupted;
+ return S_OK;
+ }
+ _blockSize = Get16(buf + signSize);
+ if (_blockSize == 0) // end of archive
+ return S_OK;
+
+ if (!extendedInfo)
+ if (_blockSize < kBlockSizeMin || _blockSize > kBlockSizeMax)
+ {
+ Error = k_ErrorType_Corrupted;
+ return S_OK;
+ }
+
+ const size_t readSize = _blockSize + 4;
+ if (readSize > _block.Size())
+ {
+ // extended data size is limited by (64 KB)
+ // _blockSize is less than 64 KB
+ const size_t upSize = (_blockSize > kBlockSizeMax ? (1 << 16) : kBlockSizeMax);
+ _block.Alloc(upSize + 4);
+ }
+
+ if (extendedInfo)
+ extendedInfo->Size += _blockSize;
+
+ READ_STREAM(_block, readSize)
+ if (Get32(_block + _blockSize) != CrcCalc(_block, _blockSize))
+ {
+ if (extendedInfo)
+ extendedInfo->CrcError = true;
+ else
+ {
+ Error = k_ErrorType_Corrupted;
+ return S_OK;
+ }
+ }
+ filled = true;
+ return S_OK;
+}
+
+HRESULT CArc::SkipExtendedHeaders(CExtendedInfo &extendedInfo)
+{
+ extendedInfo.Clear();
+ for (UInt32 i = 0;; i++)
+ {
+ bool filled;
+ RINOK(ReadBlock(filled, &extendedInfo))
+ if (!filled)
+ return S_OK;
+ if (Callback && (i & 0xFF) == 0)
+ RINOK(Callback->SetCompleted(&NumFiles, &Processed))
+ }
+}
+
+HRESULT CArc::Open()
+{
+ bool filled;
+ RINOK(ReadBlock(filled, NULL)) // (extendedInfo = NULL)
+ if (!filled)
+ return S_FALSE;
+ RINOK(Header.Parse(_block, _blockSize))
+ IsArc = true;
+ return SkipExtendedHeaders(ExtendedInfo);
+}
+
+HRESULT CArc::GetNextItem(CItem &item, bool &filled)
+{
+ RINOK(ReadBlock(filled, NULL)) // (extendedInfo = NULL)
+ if (!filled)
+ return S_OK;
+ filled = false;
+ if (item.Parse(_block, _blockSize) != S_OK)
+ {
+ Error = k_ErrorType_Corrupted;
+ return S_OK;
+ }
+ /*
+ UInt32 extraData;
+ if ((header.Flags & NFlags::kExtFile) != 0)
+ extraData = GetUi32(_block + pos);
+ */
+
+ RINOK(SkipExtendedHeaders(item.ExtendedInfo))
+ filled = true;
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ CObjectVector<CItem> _items;
+ CMyComPtr<IInStream> _stream;
+ UInt64 _phySize;
+ CArc _arc;
+
+ HRESULT Open2(IInStream *inStream, IArchiveOpenCallback *callback);
+};
+
+static const Byte kArcProps[] =
+{
+ kpidName,
+ kpidCTime,
+ kpidMTime,
+ kpidHostOS,
+ kpidComment,
+ kpidCharacts
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPosition,
+ kpidPackSize,
+ kpidMTime,
+ kpidAttrib,
+ kpidEncrypted,
+ kpidCRC,
+ kpidMethod,
+ kpidHostOS,
+ kpidComment,
+ kpidCharacts
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static void SetTime(UInt32 dosTime, NCOM::CPropVariant &prop)
+{
+ if (dosTime == 0)
+ return;
+ PropVariant_SetFrom_DosTime(prop, dosTime);
+}
+
+static void SetHostOS(Byte hostOS, NCOM::CPropVariant &prop)
+{
+ TYPE_TO_PROP(kHostOS, hostOS, prop);
+}
+
+static void SetUnicodeString(const AString &s, NCOM::CPropVariant &prop)
+{
+ if (!s.IsEmpty())
+ prop = MultiByteToUnicodeString(s, CP_OEMCP);
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _phySize; break;
+ case kpidName: SetUnicodeString(_arc.Header.Name, prop); break;
+ case kpidCTime: SetTime(_arc.Header.CTime, prop); break;
+ case kpidMTime: SetTime(_arc.Header.MTime, prop); break;
+ case kpidHostOS: SetHostOS(_arc.Header.HostOS, prop); break;
+ case kpidComment: SetUnicodeString(_arc.Header.Comment, prop); break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_arc.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+ switch (_arc.Error)
+ {
+ case k_ErrorType_UnexpectedEnd: v |= kpv_ErrorFlags_UnexpectedEnd; break;
+ case k_ErrorType_Corrupted: v |= kpv_ErrorFlags_HeadersError; break;
+ case k_ErrorType_OK:
+ // default:
+ break;
+ }
+ prop = v;
+ break;
+ }
+ case kpidCharacts: _arc.ExtendedInfo.ParseToPropVar(prop); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ const CItem &item = _items[index];
+ switch (propID)
+ {
+ case kpidPath: prop = NItemName::GetOsPath(MultiByteToUnicodeString(item.Name, CP_OEMCP)); break;
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: prop = item.Size; break;
+ case kpidPackSize: prop = item.PackSize; break;
+ case kpidPosition: if (item.IsSplitBefore() || item.IsSplitAfter()) prop = (UInt64)item.SplitPos; break;
+ case kpidAttrib: prop = item.GetWinAttrib(); break;
+ case kpidEncrypted: prop = item.IsEncrypted(); break;
+ case kpidCRC: prop = item.FileCRC; break;
+ case kpidMethod: prop = item.Method; break;
+ case kpidHostOS: SetHostOS(item.HostOS, prop); break;
+ case kpidMTime: SetTime(item.MTime, prop); break;
+ case kpidComment: SetUnicodeString(item.Comment, prop); break;
+ case kpidCharacts: item.ExtendedInfo.ParseToPropVar(prop); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+HRESULT CHandler::Open2(IInStream *inStream, IArchiveOpenCallback *callback)
+{
+ Close();
+
+ UInt64 endPos;
+ RINOK(InStream_AtBegin_GetSize(inStream, endPos))
+
+ _arc.Stream = inStream;
+ _arc.Callback = callback;
+ _arc.NumFiles = 0;
+ _arc.Processed = 0;
+
+ RINOK(_arc.Open())
+
+ _phySize = _arc.Processed;
+ if (_arc.Header.ArchiveSize != 0)
+ _phySize = (UInt64)_arc.Header.ArchiveSize + _arc.Header.SecurSize;
+
+ for (;;)
+ {
+ CItem item;
+ bool filled;
+
+ _arc.Error = k_ErrorType_OK;
+ RINOK(_arc.GetNextItem(item, filled))
+
+ if (_arc.Error != k_ErrorType_OK)
+ break;
+
+ if (!filled)
+ {
+ if (_arc.Error == k_ErrorType_OK)
+ if (_arc.Header.ArchiveSize == 0)
+ _phySize = _arc.Processed;
+ break;
+ }
+ item.DataPosition = _arc.Processed;
+ _items.Add(item);
+
+ UInt64 pos = item.DataPosition + item.PackSize;
+ if (_arc.Header.ArchiveSize == 0)
+ _phySize = pos;
+ if (pos > endPos)
+ {
+ _arc.Error = k_ErrorType_UnexpectedEnd;
+ break;
+ }
+
+ RINOK(InStream_SeekSet(inStream, pos))
+ _arc.NumFiles = _items.Size();
+ _arc.Processed = pos;
+
+ if (callback && (_items.Size() & 0xFF) == 0)
+ {
+ RINOK(callback->SetCompleted(&_arc.NumFiles, &_arc.Processed))
+ }
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ HRESULT res;
+ {
+ res = Open2(inStream, callback);
+ if (res == S_OK)
+ {
+ _stream = inStream;
+ return S_OK;
+ }
+ }
+ return res;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _arc.Close();
+ _phySize = 0;
+ _items.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ UInt64 totalUnpacked = 0, totalPacked = 0;
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItem &item = _items[allFilesMode ? i : indices[i]];
+ totalUnpacked += item.Size;
+ // totalPacked += item.PackSize;
+ }
+ extractCallback->SetTotal(totalUnpacked);
+
+ totalUnpacked = totalPacked = 0;
+ UInt64 curUnpacked, curPacked;
+
+ NCompress::NLzh::NDecoder::CCoder *lzhDecoderSpec = NULL;
+ CMyComPtr<ICompressCoder> lzhDecoder;
+
+ NCompress::NArj::NDecoder::CCoder *arjDecoderSpec = NULL;
+ CMyComPtr<ICompressCoder> arjDecoder;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *inStreamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(inStreamSpec);
+ inStreamSpec->SetStream(_stream);
+
+ for (i = 0; i < numItems; i++, totalUnpacked += curUnpacked, totalPacked += curPacked)
+ {
+ lps->InSize = totalPacked;
+ lps->OutSize = totalUnpacked;
+ RINOK(lps->SetCur())
+
+ curUnpacked = curPacked = 0;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = _items[index];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (item.IsDir())
+ {
+ // if (!testMode)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ continue;
+ }
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ curUnpacked = item.Size;
+ curPacked = item.PackSize;
+
+ {
+ COutStreamWithCRC *outStreamSpec = new COutStreamWithCRC;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ realOutStream.Release();
+ outStreamSpec->Init();
+
+ inStreamSpec->Init(item.PackSize);
+
+ RINOK(InStream_SeekSet(_stream, item.DataPosition))
+
+ HRESULT result = S_OK;
+ Int32 opRes = NExtract::NOperationResult::kOK;
+
+ if (item.IsEncrypted())
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ {
+ switch (item.Method)
+ {
+ case NCompressionMethod::kStored:
+ {
+ result = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
+ if (result == S_OK && copyCoderSpec->TotalSize != item.PackSize)
+ result = S_FALSE;
+ break;
+ }
+ case NCompressionMethod::kCompressed1a:
+ case NCompressionMethod::kCompressed1b:
+ case NCompressionMethod::kCompressed1c:
+ {
+ if (!lzhDecoder)
+ {
+ lzhDecoderSpec = new NCompress::NLzh::NDecoder::CCoder;
+ lzhDecoder = lzhDecoderSpec;
+ }
+ lzhDecoderSpec->FinishMode = true;
+ const UInt32 kHistorySize = 26624;
+ lzhDecoderSpec->SetDictSize(kHistorySize);
+ result = lzhDecoder->Code(inStream, outStream, NULL, &curUnpacked, progress);
+ if (result == S_OK && lzhDecoderSpec->GetInputProcessedSize() != item.PackSize)
+ result = S_FALSE;
+ break;
+ }
+ case NCompressionMethod::kCompressed2:
+ {
+ if (!arjDecoder)
+ {
+ arjDecoderSpec = new NCompress::NArj::NDecoder::CCoder;
+ arjDecoder = arjDecoderSpec;
+ }
+ arjDecoderSpec->FinishMode = true;
+ result = arjDecoder->Code(inStream, outStream, NULL, &curUnpacked, progress);
+ if (result == S_OK && arjDecoderSpec->GetInputProcessedSize() != item.PackSize)
+ result = S_FALSE;
+ break;
+ }
+ default:
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ }
+ }
+
+ if (opRes == NExtract::NOperationResult::kOK)
+ {
+ if (result == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else
+ {
+ RINOK(result)
+ opRes = (outStreamSpec->GetCRC() == item.FileCRC) ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kCRCError;
+ }
+ }
+
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { kSig0, kSig1 };
+
+REGISTER_ARC_I(
+ "Arj", "arj", NULL, 4,
+ k_Signature,
+ 0,
+ 0,
+ IsArc_Arj)
+
+}}
diff --git a/CPP/7zip/Archive/Base64Handler.cpp b/CPP/7zip/Archive/Base64Handler.cpp
new file mode 100644
index 0000000..5b06051
--- /dev/null
+++ b/CPP/7zip/Archive/Base64Handler.cpp
@@ -0,0 +1,505 @@
+// Base64Handler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyVector.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+#include "../Common/InBuffer.h"
+
+/*
+spaces:
+ 9(TAB),10(LF),13(CR),32(SPACE)
+ Non-breaking space:
+ 0xa0 : Unicode, Windows code pages 1250-1258
+ 0xff (unused): DOS code pages
+
+end of stream markers: '=' (0x3d):
+ "=" , if numBytes (% 3 == 2)
+ "==" , if numBytes (% 3 == 1)
+*/
+
+
+static const Byte k_Base64Table[256] =
+{
+ 66,77,77,77,77,77,77,77,77,65,65,77,77,65,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 65,77,77,77,77,77,77,77,77,77,77,62,77,77,77,63,
+ 52,53,54,55,56,57,58,59,60,61,77,77,77,64,77,77,
+ 77, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+ 15,16,17,18,19,20,21,22,23,24,25,77,77,77,77,77,
+ 77,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+ 41,42,43,44,45,46,47,48,49,50,51,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 65,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,
+ 77,77,77,77,77,77,77,77,77,77,77,77,77,77,77,77
+};
+
+static const unsigned k_Code_Equals = 64;
+static const unsigned k_Code_Space = 65;
+static const unsigned k_Code_Zero = 66;
+
+API_FUNC_static_IsArc IsArc_Base64(const Byte *p, size_t size)
+{
+ size_t num = 0;
+ size_t firstSpace = 0;
+
+ for (;;)
+ {
+ if (size == 0)
+ return k_IsArc_Res_NEED_MORE;
+ UInt32 c = k_Base64Table[(Byte)(*p++)];
+ size--;
+ if (c < 64)
+ {
+ num++;
+ continue;
+ }
+
+ if (c == k_Code_Space)
+ {
+ if (p[-1] == ' ' && firstSpace == 0)
+ firstSpace = num;
+ continue;
+ }
+
+ if (c != k_Code_Equals)
+ return k_IsArc_Res_NO;
+ break;
+ }
+
+ {
+ // we try to redece false positive detection here.
+ // we don't expect space character in starting base64 line
+ const unsigned kNumExpectedNonSpaceSyms = 20;
+ if (firstSpace != 0 && firstSpace < num && firstSpace < kNumExpectedNonSpaceSyms)
+ return k_IsArc_Res_NO;
+ }
+
+ num &= 3;
+
+ if (num <= 1)
+ return k_IsArc_Res_NO;
+ if (num != 3)
+ {
+ if (size == 0)
+ return k_IsArc_Res_NEED_MORE;
+ UInt32 c = k_Base64Table[(Byte)(*p++)];
+ size--;
+ if (c != k_Code_Equals)
+ return k_IsArc_Res_NO;
+ }
+
+ for (;;)
+ {
+ if (size == 0)
+ return k_IsArc_Res_YES;
+ UInt32 c = k_Base64Table[(Byte)(*p++)];
+ size--;
+ if (c == k_Code_Space)
+ continue;
+ return k_IsArc_Res_NO;
+ }
+}
+}
+
+
+enum EBase64Res
+{
+ k_Base64_RES_MaybeFinished,
+ k_Base64_RES_Finished,
+ k_Base64_RES_NeedMoreInput,
+ k_Base64_RES_UnexpectedChar
+};
+
+
+static EBase64Res Base64ToBin(Byte *p, size_t size, const Byte **srcEnd, Byte **destEnd)
+{
+ Byte *dest = p;
+ UInt32 val = 1;
+ EBase64Res res = k_Base64_RES_NeedMoreInput;
+
+ for (;;)
+ {
+ if (size == 0)
+ {
+ if (val == 1)
+ res = k_Base64_RES_MaybeFinished;
+ break;
+ }
+ UInt32 c = k_Base64Table[(Byte)(*p++)];
+ size--;
+ if (c < 64)
+ {
+ val = (val << 6) | c;
+ if ((val & ((UInt32)1 << 24)) == 0)
+ continue;
+ dest[0] = (Byte)(val >> 16);
+ dest[1] = (Byte)(val >> 8);
+ dest[2] = (Byte)(val);
+ dest += 3;
+ val = 1;
+ continue;
+ }
+
+ if (c == k_Code_Space)
+ continue;
+
+ if (c == k_Code_Equals)
+ {
+ if (val >= (1 << 12))
+ {
+ if (val & (1 << 18))
+ {
+ res = k_Base64_RES_Finished;
+ break;
+ }
+ if (size == 0)
+ break;
+ c = k_Base64Table[(Byte)(*p++)];
+ size--;
+ if (c == k_Code_Equals)
+ {
+ res = k_Base64_RES_Finished;
+ break;
+ }
+ }
+ }
+
+ p--;
+ res = k_Base64_RES_UnexpectedChar;
+ break;
+ }
+
+ if (val >= ((UInt32)1 << 12))
+ {
+ if (val & (1 << 18))
+ {
+ *dest++ = (Byte)(val >> 10);
+ val <<= 2;
+ }
+ *dest++ = (Byte)(val >> 4);
+ }
+
+ *srcEnd = p;
+ *destEnd = dest;
+ return res;
+}
+
+
+static const Byte *Base64_SkipSpaces(const Byte *p, size_t size)
+{
+ for (;;)
+ {
+ if (size == 0)
+ return p;
+ const UInt32 c = k_Base64Table[(Byte)(*p++)];
+ size--;
+ if (c == k_Code_Space)
+ continue;
+ return p - 1;
+ }
+}
+
+
+// the following function is used by DmgHandler.cpp
+
+Byte *Base64ToBin(Byte *dest, const char *src);
+Byte *Base64ToBin(Byte *dest, const char *src)
+{
+ UInt32 val = 1;
+
+ for (;;)
+ {
+ const UInt32 c = k_Base64Table[(Byte)(*src++)];
+
+ if (c < 64)
+ {
+ val = (val << 6) | c;
+ if ((val & ((UInt32)1 << 24)) == 0)
+ continue;
+ dest[0] = (Byte)(val >> 16);
+ dest[1] = (Byte)(val >> 8);
+ dest[2] = (Byte)(val);
+ dest += 3;
+ val = 1;
+ continue;
+ }
+
+ if (c == k_Code_Space)
+ continue;
+
+ if (c == k_Code_Equals)
+ break;
+
+ if (c == k_Code_Zero && val == 1) // end of string
+ return dest;
+
+ return NULL;
+ }
+
+ if (val < (1 << 12))
+ return NULL;
+
+ if (val & (1 << 18))
+ {
+ *dest++ = (Byte)(val >> 10);
+ val <<= 2;
+ }
+ else if (k_Base64Table[(Byte)(*src++)] != k_Code_Equals)
+ return NULL;
+ *dest++ = (Byte)(val >> 4);
+
+ for (;;)
+ {
+ const Byte c = k_Base64Table[(Byte)(*src++)];
+ if (c == k_Code_Space)
+ continue;
+ if (c == k_Code_Zero)
+ return dest;
+ return NULL;
+ }
+}
+
+
+namespace NArchive {
+namespace NBase64 {
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ bool _isArc;
+ UInt64 _phySize;
+ size_t _size;
+ EBase64Res _sres;
+ CByteBuffer _data;
+};
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize,
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_sres == k_Base64_RES_NeedMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ // COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidSize: prop = (UInt64)_size; break;
+ case kpidPackSize: prop = _phySize; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ // COM_TRY_END
+}
+
+
+static HRESULT ReadStream_OpenProgress(ISequentialInStream *stream, void *data, size_t size, IArchiveOpenCallback *openCallback) throw()
+{
+ UInt64 bytes = 0;
+ while (size != 0)
+ {
+ const UInt32 kBlockSize = ((UInt32)1 << 24);
+ const UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
+ UInt32 processedSizeLoc;
+ RINOK(stream->Read(data, curSize, &processedSizeLoc))
+ if (processedSizeLoc == 0)
+ return E_FAIL;
+ data = (void *)((Byte *)data + processedSizeLoc);
+ size -= processedSizeLoc;
+ bytes += processedSizeLoc;
+ const UInt64 files = 1;
+ RINOK(openCallback->SetCompleted(&files, &bytes))
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *openCallback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ {
+ const unsigned kStartSize = 1 << 12;
+ _data.Alloc(kStartSize);
+ size_t size = kStartSize;
+ RINOK(ReadStream(stream, _data, &size))
+ UInt32 isArcRes = IsArc_Base64(_data, size);
+ if (isArcRes == k_IsArc_Res_NO)
+ return S_FALSE;
+ }
+ _isArc = true;
+
+ UInt64 packSize64;
+ RINOK(InStream_GetSize_SeekToEnd(stream, packSize64))
+
+ if (packSize64 == 0)
+ return S_FALSE;
+
+ size_t curSize = 1 << 16;
+ if (curSize > packSize64)
+ curSize = (size_t)packSize64;
+ const unsigned kLogStep = 4;
+
+ for (;;)
+ {
+ RINOK(InStream_SeekSet(stream, 0))
+
+ _data.Alloc(curSize);
+ RINOK(ReadStream_OpenProgress(stream, _data, curSize, openCallback))
+
+ const Byte *srcEnd;
+ Byte *dest;
+ _sres = Base64ToBin(_data, curSize, &srcEnd, &dest);
+ _size = (size_t)(dest - _data);
+ const size_t mainSize = (size_t)(srcEnd - _data);
+ _phySize = mainSize;
+ if (_sres == k_Base64_RES_UnexpectedChar)
+ break;
+ if (curSize != mainSize)
+ {
+ const Byte *end2 = Base64_SkipSpaces(srcEnd, curSize - mainSize);
+ if ((size_t)(end2 - _data) != curSize)
+ break;
+ _phySize = curSize;
+ }
+
+ if (curSize == packSize64)
+ break;
+
+ UInt64 curSize64 = packSize64;
+ if (curSize < (packSize64 >> kLogStep))
+ curSize64 = (UInt64)curSize << kLogStep;
+ curSize = (size_t)curSize64;
+ if (curSize != curSize64)
+ return E_OUTOFMEMORY;
+ }
+ if (_size == 0)
+ return S_FALSE;
+ return S_OK;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+ _size = 0;
+ _isArc = false;
+ _sres = k_Base64_RES_MaybeFinished;
+ _data.Free();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ RINOK(extractCallback->SetTotal(_size))
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ {
+ lps->InSize = lps->OutSize = 0;
+ RINOK(lps->SetCur())
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, (const Byte *)_data, _size))
+ realOutStream.Release();
+ }
+
+ Int32 opRes = NExtract::NOperationResult::kOK;
+
+ if (_sres != k_Base64_RES_Finished)
+ {
+ if (_sres == k_Base64_RES_NeedMoreInput)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (_sres == k_Base64_RES_UnexpectedChar)
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ lps->InSize = _phySize;
+ lps->OutSize = _size;
+ return lps->SetCur();
+
+ COM_TRY_END
+}
+
+REGISTER_ARC_I_NO_SIG(
+ "Base64", "b64", NULL, 0xC5,
+ 0,
+ NArcInfoFlags::kKeepName
+ | NArcInfoFlags::kStartOpen
+ | NArcInfoFlags::kByExtOnlyOpen,
+ IsArc_Base64)
+
+}}
diff --git a/CPP/7zip/Archive/Bz2Handler.cpp b/CPP/7zip/Archive/Bz2Handler.cpp
new file mode 100644
index 0000000..994b1ad
--- /dev/null
+++ b/CPP/7zip/Archive/Bz2Handler.cpp
@@ -0,0 +1,478 @@
+// Bz2Handler.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/BZip2Decoder.h"
+#include "../Compress/BZip2Encoder.h"
+#include "../Compress/CopyCoder.h"
+
+#include "Common/DummyOutStream.h"
+#include "Common/HandlerOut.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NBz2 {
+
+Z7_CLASS_IMP_CHandler_IInArchive_3(
+ IArchiveOpenSeq,
+ IOutArchive,
+ ISetProperties
+)
+ CMyComPtr<IInStream> _stream;
+ CMyComPtr<ISequentialInStream> _seqStream;
+
+ bool _isArc;
+ bool _needSeekToStart;
+ bool _dataAfterEnd;
+ bool _needMoreInput;
+
+ bool _packSize_Defined;
+ bool _unpackSize_Defined;
+ bool _numStreams_Defined;
+ bool _numBlocks_Defined;
+
+ UInt64 _packSize;
+ UInt64 _unpackSize;
+ UInt64 _numStreams;
+ UInt64 _numBlocks;
+
+ CSingleMethodProps _props;
+};
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize
+};
+
+static const Byte kArcProps[] =
+{
+ kpidNumStreams,
+ kpidNumBlocks
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidUnpackSize: if (_unpackSize_Defined) prop = _unpackSize; break;
+ case kpidNumStreams: if (_numStreams_Defined) prop = _numStreams; break;
+ case kpidNumBlocks: if (_numBlocks_Defined) prop = _numBlocks; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
+ prop = v;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPackSize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidSize: if (_unpackSize_Defined) prop = _unpackSize; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+static const unsigned kSignatureCheckSize = 10;
+
+API_FUNC_static_IsArc IsArc_BZip2(const Byte *p, size_t size)
+{
+ if (size < kSignatureCheckSize)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != 'B' || p[1] != 'Z' || p[2] != 'h' || p[3] < '1' || p[3] > '9')
+ return k_IsArc_Res_NO;
+ p += 4;
+ if (NCompress::NBZip2::IsBlockSig(p))
+ return k_IsArc_Res_YES;
+ if (NCompress::NBZip2::IsEndSig(p))
+ return k_IsArc_Res_YES;
+ return k_IsArc_Res_NO;
+}
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *))
+{
+ COM_TRY_BEGIN
+ Close();
+ {
+ Byte buf[kSignatureCheckSize];
+ RINOK(ReadStream_FALSE(stream, buf, kSignatureCheckSize))
+ if (IsArc_BZip2(buf, kSignatureCheckSize) == k_IsArc_Res_NO)
+ return S_FALSE;
+ _isArc = true;
+ _stream = stream;
+ _seqStream = stream;
+ _needSeekToStart = true;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ Close();
+ _isArc = true;
+ _seqStream = stream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _needSeekToStart = false;
+ _dataAfterEnd = false;
+ _needMoreInput = false;
+
+ _packSize_Defined = false;
+ _unpackSize_Defined = false;
+ _numStreams_Defined = false;
+ _numBlocks_Defined = false;
+
+ _packSize = 0;
+
+ _seqStream.Release();
+ _stream.Release();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ if (_packSize_Defined)
+ extractCallback->SetTotal(_packSize);
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ if (_needSeekToStart)
+ {
+ if (!_stream)
+ return E_FAIL;
+ RINOK(InStream_SeekToBegin(_stream))
+ }
+ else
+ _needSeekToStart = true;
+
+ // try {
+
+ NCompress::NBZip2::CDecoder *decoderSpec = new NCompress::NBZip2::CDecoder;
+ CMyComPtr<ICompressCoder> decoder = decoderSpec;
+
+ #ifndef Z7_ST
+ RINOK(decoderSpec->SetNumberOfThreads(_props._numThreads))
+ #endif
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+
+ realOutStream.Release();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, true);
+
+ decoderSpec->FinishMode = true;
+ decoderSpec->Base.DecodeAllStreams = true;
+
+ _dataAfterEnd = false;
+ _needMoreInput = false;
+
+ lps->InSize = 0;
+ lps->OutSize = 0;
+
+ HRESULT result = decoder->Code(_seqStream, outStream, NULL, NULL, progress);
+
+ if (result != S_FALSE && result != S_OK)
+ return result;
+
+ if (decoderSpec->Base.NumStreams == 0)
+ {
+ _isArc = false;
+ result = S_FALSE;
+ }
+ else
+ {
+ const UInt64 inProcessedSize = decoderSpec->GetInputProcessedSize();
+ UInt64 packSize = inProcessedSize;
+
+ if (decoderSpec->Base.NeedMoreInput)
+ _needMoreInput = true;
+
+ if (!decoderSpec->Base.IsBz)
+ {
+ packSize = decoderSpec->Base.FinishedPackSize;
+ if (packSize != inProcessedSize)
+ _dataAfterEnd = true;
+ }
+
+ _packSize = packSize;
+ _unpackSize = decoderSpec->GetOutProcessedSize();
+ _numStreams = decoderSpec->Base.NumStreams;
+ _numBlocks = decoderSpec->GetNumBlocks();
+
+ _packSize_Defined = true;
+ _unpackSize_Defined = true;
+ _numStreams_Defined = true;
+ _numBlocks_Defined = true;
+ }
+
+ outStream.Release();
+
+ Int32 opRes;
+
+ if (!_isArc)
+ opRes = NExtract::NOperationResult::kIsNotArc;
+ else if (_needMoreInput)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (decoderSpec->GetCrcError())
+ opRes = NExtract::NOperationResult::kCRCError;
+ else if (_dataAfterEnd)
+ opRes = NExtract::NOperationResult::kDataAfterEnd;
+ else if (result == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (decoderSpec->Base.MinorError)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (result == S_OK)
+ opRes = NExtract::NOperationResult::kOK;
+ else
+ return result;
+
+ return extractCallback->SetOperationResult(opRes);
+
+ // } catch(...) { return E_FAIL; }
+
+ COM_TRY_END
+}
+
+
+/*
+static HRESULT ReportItemProp(IArchiveUpdateCallbackArcProp *reportArcProp, PROPID propID, const PROPVARIANT *value)
+{
+ return reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, 0, propID, value);
+}
+
+static HRESULT ReportArcProp(IArchiveUpdateCallbackArcProp *reportArcProp, PROPID propID, const PROPVARIANT *value)
+{
+ return reportArcProp->ReportProp(NEventIndexType::kArcProp, 0, propID, value);
+}
+
+static HRESULT ReportArcProps(IArchiveUpdateCallbackArcProp *reportArcProp,
+ const UInt64 *unpackSize,
+ const UInt64 *numBlocks)
+{
+ NCOM::CPropVariant sizeProp;
+ if (unpackSize)
+ {
+ sizeProp = *unpackSize;
+ RINOK(ReportItemProp(reportArcProp, kpidSize, &sizeProp));
+ RINOK(reportArcProp->ReportFinished(NEventIndexType::kOutArcIndex, 0, NArchive::NUpdate::NOperationResult::kOK));
+ }
+
+ if (unpackSize)
+ {
+ RINOK(ReportArcProp(reportArcProp, kpidSize, &sizeProp));
+ }
+ if (numBlocks)
+ {
+ NCOM::CPropVariant prop;
+ prop = *numBlocks;
+ RINOK(ReportArcProp(reportArcProp, kpidNumBlocks, &prop));
+ }
+ return S_OK;
+}
+*/
+
+static HRESULT UpdateArchive(
+ UInt64 unpackSize,
+ ISequentialOutStream *outStream,
+ const CProps &props,
+ IArchiveUpdateCallback *updateCallback
+ // , ArchiveUpdateCallbackArcProp *reportArcProp
+ )
+{
+ {
+ CMyComPtr<ISequentialInStream> fileInStream;
+ RINOK(updateCallback->GetStream(0, &fileInStream))
+ if (!fileInStream)
+ return S_FALSE;
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamGetSize,
+ streamGetSize, fileInStream)
+ if (streamGetSize)
+ {
+ UInt64 size;
+ if (streamGetSize->GetSize(&size) == S_OK)
+ unpackSize = size;
+ }
+ }
+ RINOK(updateCallback->SetTotal(unpackSize))
+ CLocalProgress *localProgressSpec = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> localProgress = localProgressSpec;
+ localProgressSpec->Init(updateCallback, true);
+ {
+ NCompress::NBZip2::CEncoder *encoderSpec = new NCompress::NBZip2::CEncoder;
+ CMyComPtr<ICompressCoder> encoder = encoderSpec;
+ RINOK(props.SetCoderProps(encoderSpec, NULL))
+ RINOK(encoder->Code(fileInStream, outStream, NULL, NULL, localProgress))
+ /*
+ if (reportArcProp)
+ {
+ unpackSize = encoderSpec->GetInProcessedSize();
+ RINOK(ReportArcProps(reportArcProp, &unpackSize, &encoderSpec->NumBlocks));
+ }
+ */
+ }
+ }
+ return updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK);
+}
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *timeType))
+{
+ *timeType = GET_FileTimeType_NotDefined_for_GetFileTimeType;
+ // *timeType = NFileTimeType::kUnix;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *updateCallback))
+{
+ COM_TRY_BEGIN
+
+ if (numItems != 1)
+ return E_INVALIDARG;
+
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamSetRestriction,
+ setRestriction, outStream)
+ if (setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+ }
+
+ Int32 newData, newProps;
+ UInt32 indexInArchive;
+ if (!updateCallback)
+ return E_FAIL;
+ RINOK(updateCallback->GetUpdateItemInfo(0, &newData, &newProps, &indexInArchive))
+
+ // Z7_DECL_CMyComPtr_QI_FROM(IArchiveUpdateCallbackArcProp, reportArcProp, updateCallback)
+
+ if (IntToBool(newProps))
+ {
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidIsDir, &prop))
+ if (prop.vt != VT_EMPTY)
+ if (prop.vt != VT_BOOL || prop.boolVal != VARIANT_FALSE)
+ return E_INVALIDARG;
+ }
+ }
+
+ if (IntToBool(newData))
+ {
+ UInt64 size;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ size = prop.uhVal.QuadPart;
+ }
+
+ CMethodProps props2 = _props;
+ #ifndef Z7_ST
+ props2.AddProp_NumThreads(_props._numThreads);
+ #endif
+
+ return UpdateArchive(size, outStream, props2, updateCallback);
+ }
+
+ if (indexInArchive != 0)
+ return E_INVALIDARG;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveUpdateCallbackFile,
+ opCallback, updateCallback)
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kInArcIndex, 0,
+ NUpdateNotifyOp::kReplicate))
+ }
+
+ if (_stream)
+ RINOK(InStream_SeekToBegin(_stream))
+
+ return NCompress::CopyStream(_stream, outStream, progress);
+
+ // return ReportArcProps(reportArcProp, NULL, NULL);
+
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ return _props.SetProperties(names, values, numProps);
+}
+
+static const Byte k_Signature[] = { 'B', 'Z', 'h' };
+
+REGISTER_ARC_IO(
+ "bzip2", "bz2 bzip2 tbz2 tbz", "* * .tar .tar", 2,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kKeepName
+ , 0
+ , IsArc_BZip2)
+
+}}
diff --git a/CPP/7zip/Archive/Cab/CabBlockInStream.cpp b/CPP/7zip/Archive/Cab/CabBlockInStream.cpp
new file mode 100644
index 0000000..dc767a4
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabBlockInStream.cpp
@@ -0,0 +1,100 @@
+// CabBlockInStream.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Alloc.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "CabBlockInStream.h"
+
+namespace NArchive {
+namespace NCab {
+
+static const UInt32 kBlockSize = (1 << 16);
+
+bool CCabBlockInStream::Create()
+{
+ if (!_buf)
+ _buf = (Byte *)::MyAlloc(kBlockSize);
+ return _buf != NULL;
+}
+
+CCabBlockInStream::~CCabBlockInStream()
+{
+ ::MyFree(_buf);
+}
+
+static UInt32 CheckSum(const Byte *p, UInt32 size)
+{
+ UInt32 sum = 0;
+
+ for (; size >= 8; size -= 8)
+ {
+ sum ^= GetUi32(p) ^ GetUi32(p + 4);
+ p += 8;
+ }
+
+ if (size >= 4)
+ {
+ sum ^= GetUi32(p);
+ p += 4;
+ }
+
+ size &= 3;
+ if (size > 2) sum ^= (UInt32)(*p++) << 16;
+ if (size > 1) sum ^= (UInt32)(*p++) << 8;
+ if (size > 0) sum ^= (UInt32)(*p++);
+
+ return sum;
+}
+
+HRESULT CCabBlockInStream::PreRead(ISequentialInStream *stream, UInt32 &packSize, UInt32 &unpackSize)
+{
+ const UInt32 kHeaderSize = 8;
+ const UInt32 kReservedMax = 256;
+ Byte header[kHeaderSize + kReservedMax];
+ RINOK(ReadStream_FALSE(stream, header, kHeaderSize + ReservedSize))
+ packSize = GetUi16(header + 4);
+ unpackSize = GetUi16(header + 6);
+ if (packSize > kBlockSize - _size)
+ return S_FALSE;
+ RINOK(ReadStream_FALSE(stream, _buf + _size, packSize))
+
+ if (MsZip)
+ {
+ if (_size == 0)
+ {
+ if (packSize < 2 || _buf[0] != 0x43 || _buf[1] != 0x4B)
+ return S_FALSE;
+ _pos = 2;
+ }
+ if (_size + packSize > ((UInt32)1 << 15) + 12) /* v9.31 fix. MSZIP specification */
+ return S_FALSE;
+ }
+
+ if (GetUi32(header) != 0) // checkSum
+ if (CheckSum(header, kHeaderSize + ReservedSize) != CheckSum(_buf + _size, packSize))
+ return S_FALSE;
+
+ _size += packSize;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CCabBlockInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (size != 0)
+ {
+ UInt32 rem = _size - _pos;
+ if (size > rem)
+ size = rem;
+ memcpy(data, _buf + _pos, size);
+ _pos += size;
+ }
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Cab/CabBlockInStream.h b/CPP/7zip/Archive/Cab/CabBlockInStream.h
new file mode 100644
index 0000000..d14fff8
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabBlockInStream.h
@@ -0,0 +1,39 @@
+// CabBlockInStream.h
+
+#ifndef ZIP7_INC_CAB_BLOCK_IN_STREAM_H
+#define ZIP7_INC_CAB_BLOCK_IN_STREAM_H
+
+#include "../../../Common/MyCom.h"
+#include "../../IStream.h"
+
+namespace NArchive {
+namespace NCab {
+
+Z7_CLASS_IMP_NOQIB_1(
+ CCabBlockInStream
+ , ISequentialInStream
+)
+ Byte *_buf;
+ UInt32 _size;
+ UInt32 _pos;
+
+public:
+ UInt32 ReservedSize; // < 256
+ bool MsZip;
+
+ CCabBlockInStream(): _buf(NULL), ReservedSize(0), MsZip(false) {}
+ ~CCabBlockInStream();
+
+ bool Create();
+
+ void InitForNewBlock() { _size = 0; _pos = 0; }
+
+ HRESULT PreRead(ISequentialInStream *stream, UInt32 &packSize, UInt32 &unpackSize);
+
+ UInt32 GetPackSizeAvail() const { return _size - _pos; }
+ const Byte *GetData() const { return _buf + _pos; }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Cab/CabHandler.cpp b/CPP/7zip/Archive/Cab/CabHandler.cpp
new file mode 100644
index 0000000..f015145
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabHandler.cpp
@@ -0,0 +1,1261 @@
+// CabHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+#include "../../Compress/DeflateDecoder.h"
+#include "../../Compress/LzxDecoder.h"
+#include "../../Compress/QuantumDecoder.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "CabBlockInStream.h"
+#include "CabHandler.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NCab {
+
+// #define CAB_DETAILS
+
+#ifdef CAB_DETAILS
+enum
+{
+ kpidBlockReal = kpidUserDefined
+};
+#endif
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidMTime,
+ kpidAttrib,
+ kpidMethod,
+ kpidBlock
+ #ifdef CAB_DETAILS
+ ,
+ // kpidBlockReal, // L"BlockReal",
+ kpidOffset,
+ kpidVolume
+ #endif
+};
+
+static const Byte kArcProps[] =
+{
+ kpidTotalPhySize,
+ kpidMethod,
+ // kpidSolid,
+ kpidNumBlocks,
+ kpidNumVolumes,
+ kpidVolumeIndex,
+ kpidId
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static const char * const kMethods[] =
+{
+ "None"
+ , "MSZip"
+ , "Quantum"
+ , "LZX"
+};
+
+static const unsigned kMethodNameBufSize = 32; // "Quantum:255"
+
+static void SetMethodName(char *s, unsigned method, unsigned param)
+{
+ if (method < Z7_ARRAY_SIZE(kMethods))
+ {
+ s = MyStpCpy(s, kMethods[method]);
+ if (method != NHeader::NMethod::kLZX &&
+ method != NHeader::NMethod::kQuantum)
+ return;
+ *s++ = ':';
+ method = param;
+ }
+ ConvertUInt32ToString(method, s);
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMethod:
+ {
+ UInt32 mask = 0;
+ UInt32 params[2] = { 0, 0 };
+ {
+ FOR_VECTOR (v, m_Database.Volumes)
+ {
+ const CRecordVector<CFolder> &folders = m_Database.Volumes[v].Folders;
+ FOR_VECTOR (i, folders)
+ {
+ const CFolder &folder = folders[i];
+ unsigned method = folder.GetMethod();
+ mask |= ((UInt32)1 << method);
+ if (method == NHeader::NMethod::kLZX ||
+ method == NHeader::NMethod::kQuantum)
+ {
+ unsigned di = (method == NHeader::NMethod::kQuantum) ? 0 : 1;
+ if (params[di] < folder.MethodMinor)
+ params[di] = folder.MethodMinor;
+ }
+ }
+ }
+ }
+
+ AString s;
+
+ for (unsigned i = 0; i < kNumMethodsMax; i++)
+ {
+ if ((mask & (1 << i)) == 0)
+ continue;
+ s.Add_Space_if_NotEmpty();
+ char temp[kMethodNameBufSize];
+ SetMethodName(temp, i, params[i == NHeader::NMethod::kQuantum ? 0 : 1]);
+ s += temp;
+ }
+
+ prop = s;
+ break;
+ }
+ // case kpidSolid: prop = _database.IsSolid(); break;
+ case kpidNumBlocks:
+ {
+ UInt32 numFolders = 0;
+ FOR_VECTOR (v, m_Database.Volumes)
+ numFolders += m_Database.Volumes[v].Folders.Size();
+ prop = numFolders;
+ break;
+ }
+
+ case kpidTotalPhySize:
+ {
+ if (m_Database.Volumes.Size() > 1)
+ {
+ UInt64 sum = 0;
+ FOR_VECTOR (v, m_Database.Volumes)
+ sum += m_Database.Volumes[v].ArcInfo.Size;
+ prop = sum;
+ }
+ break;
+ }
+
+ case kpidNumVolumes:
+ prop = (UInt32)m_Database.Volumes.Size();
+ break;
+
+ case kpidVolumeIndex:
+ {
+ if (!m_Database.Volumes.IsEmpty())
+ {
+ const CDatabaseEx &db = m_Database.Volumes[0];
+ const CInArcInfo &ai = db.ArcInfo;
+ prop = (UInt32)ai.CabinetNumber;
+ }
+ break;
+ }
+
+ case kpidId:
+ {
+ if (m_Database.Volumes.Size() != 0)
+ {
+ prop = (UInt32)m_Database.Volumes[0].ArcInfo.SetID;
+ }
+ break;
+ }
+
+ case kpidOffset:
+ /*
+ if (m_Database.Volumes.Size() == 1)
+ prop = m_Database.Volumes[0].StartPosition;
+ */
+ prop = _offset;
+ break;
+
+ case kpidPhySize:
+ /*
+ if (m_Database.Volumes.Size() == 1)
+ prop = (UInt64)m_Database.Volumes[0].ArcInfo.Size;
+ */
+ prop = (UInt64)_phySize;
+ break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_errorInHeaders) v |= kpv_ErrorFlags_HeadersError;
+ if (_unexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+ prop = v;
+ break;
+ }
+
+ case kpidError:
+ if (!_errorMessage.IsEmpty())
+ prop = _errorMessage;
+ break;
+
+ case kpidName:
+ {
+ if (m_Database.Volumes.Size() == 1)
+ {
+ const CDatabaseEx &db = m_Database.Volumes[0];
+ const CInArcInfo &ai = db.ArcInfo;
+ if (ai.SetID != 0)
+ {
+ AString s;
+ s.Add_UInt32(ai.SetID);
+ s += '_';
+ s.Add_UInt32(ai.CabinetNumber + 1);
+ s += ".cab";
+ prop = s;
+ }
+ /*
+ // that code is incomplete. It gcan give accurate name of volume
+ char s[32];
+ ConvertUInt32ToString(ai.CabinetNumber + 2, s);
+ unsigned len = MyStringLen(s);
+ if (ai.IsThereNext())
+ {
+ AString fn = ai.NextArc.FileName;
+ if (fn.Len() > 4 && StringsAreEqualNoCase_Ascii(fn.RightPtr(4), ".cab"))
+ fn.DeleteFrom(fn.Len() - 4);
+ if (len < fn.Len())
+ {
+ if (strcmp(s, fn.RightPtr(len)) == 0)
+ {
+ AString s2 = fn;
+ s2.DeleteFrom(fn.Len() - len);
+ ConvertUInt32ToString(ai.CabinetNumber + 1, s);
+ s2 += s;
+ s2 += ".cab";
+ prop = GetUnicodeString(s2);
+ }
+ }
+ }
+ */
+ }
+ break;
+ }
+
+ // case kpidShortComment:
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CMvItem &mvItem = m_Database.Items[index];
+ const CDatabaseEx &db = m_Database.Volumes[mvItem.VolumeIndex];
+ unsigned itemIndex = mvItem.ItemIndex;
+ const CItem &item = db.Items[itemIndex];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString unicodeName;
+ if (item.IsNameUTF())
+ ConvertUTF8ToUnicode(item.Name, unicodeName);
+ else
+ unicodeName = MultiByteToUnicodeString(item.Name, CP_ACP);
+ prop = (const wchar_t *)NItemName::WinPathToOsPath(unicodeName);
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: prop = item.Size; break;
+ case kpidAttrib: prop = item.GetWinAttrib(); break;
+
+ case kpidMTime:
+ {
+ PropVariant_SetFrom_DosTime(prop, item.Time);
+ break;
+ }
+
+ case kpidMethod:
+ {
+ const int realFolderIndex = item.GetFolderIndex(db.Folders.Size());
+ if (realFolderIndex >= 0)
+ {
+ const CFolder &folder = db.Folders[(unsigned)realFolderIndex];
+ char s[kMethodNameBufSize];
+ SetMethodName(s, folder.GetMethod(), folder.MethodMinor);
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidBlock: prop.Set_Int32((Int32)m_Database.GetFolderIndex(&mvItem)); break;
+
+ #ifdef CAB_DETAILS
+
+ // case kpidBlockReal: prop = (UInt32)item.FolderIndex; break;
+ case kpidOffset: prop = (UInt32)item.Offset; break;
+ case kpidVolume: prop = (UInt32)mvItem.VolumeIndex; break;
+
+ #endif
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+
+ CInArchive archive;
+ CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
+ if (callback)
+ callback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&openVolumeCallback);
+
+ CMyComPtr<IInStream> nextStream = inStream;
+ bool prevChecked = false;
+ UString startVolName;
+ bool startVolName_was_Requested = false;
+ UInt64 numItems = 0;
+ unsigned numTempVolumes = 0;
+ // try
+ {
+ while (nextStream)
+ {
+ CDatabaseEx db;
+ db.Stream = nextStream;
+
+ HRESULT res = archive.Open(db, maxCheckStartPosition);
+
+ _errorInHeaders |= archive.HeaderError;
+ _errorInHeaders |= archive.ErrorInNames;
+ _unexpectedEnd |= archive.UnexpectedEnd;
+
+ if (res == S_OK && !m_Database.Volumes.IsEmpty())
+ {
+ const CArchInfo &lastArc = m_Database.Volumes.Back().ArcInfo;
+ unsigned cabNumber = db.ArcInfo.CabinetNumber;
+ if (lastArc.SetID != db.ArcInfo.SetID)
+ res = S_FALSE;
+ else if (prevChecked)
+ {
+ if (cabNumber != lastArc.CabinetNumber + 1)
+ res = S_FALSE;
+ }
+ else if (cabNumber >= lastArc.CabinetNumber)
+ res = S_FALSE;
+ else if (numTempVolumes != 0)
+ {
+ const CArchInfo &prevArc = m_Database.Volumes[numTempVolumes - 1].ArcInfo;
+ if (cabNumber != prevArc.CabinetNumber + 1)
+ res = S_FALSE;
+ }
+ }
+
+ if (archive.IsArc || res == S_OK)
+ {
+ _isArc = true;
+ if (m_Database.Volumes.IsEmpty())
+ {
+ _offset = db.StartPosition;
+ _phySize = db.ArcInfo.Size;
+ }
+ }
+
+ if (res == S_OK)
+ {
+ numItems += db.Items.Size();
+ m_Database.Volumes.Insert(prevChecked ? m_Database.Volumes.Size() : numTempVolumes, db);
+ if (!prevChecked && m_Database.Volumes.Size() > 1)
+ {
+ numTempVolumes++;
+ if (db.ArcInfo.CabinetNumber + 1 == m_Database.Volumes[numTempVolumes].ArcInfo.CabinetNumber)
+ numTempVolumes = 0;
+ }
+ }
+ else
+ {
+ if (res != S_FALSE)
+ return res;
+ if (m_Database.Volumes.IsEmpty())
+ return S_FALSE;
+ if (prevChecked)
+ break;
+ prevChecked = true;
+ if (numTempVolumes != 0)
+ {
+ m_Database.Volumes.DeleteFrontal(numTempVolumes);
+ numTempVolumes = 0;
+ }
+ }
+
+ if (callback)
+ {
+ RINOK(callback->SetCompleted(&numItems, NULL))
+ }
+
+ nextStream = NULL;
+
+ for (;;)
+ {
+ const COtherArc *otherArc = NULL;
+
+ if (!prevChecked)
+ {
+ if (numTempVolumes == 0)
+ {
+ const CInArcInfo &ai = m_Database.Volumes[0].ArcInfo;
+ if (ai.IsTherePrev())
+ otherArc = &ai.PrevArc;
+ else
+ prevChecked = true;
+ }
+ else
+ {
+ const CInArcInfo &ai = m_Database.Volumes[numTempVolumes - 1].ArcInfo;
+ if (ai.IsThereNext())
+ otherArc = &ai.NextArc;
+ else
+ {
+ prevChecked = true;
+ m_Database.Volumes.DeleteFrontal(numTempVolumes);
+ numTempVolumes = 0;
+ }
+ }
+ }
+
+ if (!otherArc)
+ {
+ const CInArcInfo &ai = m_Database.Volumes.Back().ArcInfo;
+ if (ai.IsThereNext())
+ otherArc = &ai.NextArc;
+ }
+
+ if (!otherArc)
+ break;
+ if (!openVolumeCallback)
+ break;
+ // printf("\n%s", otherArc->FileName);
+ const UString fullName = MultiByteToUnicodeString(otherArc->FileName, CP_ACP);
+
+ if (!startVolName_was_Requested)
+ {
+ // some "bad" cab example can contain the link to itself.
+ startVolName_was_Requested = true;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
+ if (prop.vt == VT_BSTR)
+ startVolName = prop.bstrVal;
+ }
+ if (fullName == startVolName)
+ break;
+ }
+
+ HRESULT result = openVolumeCallback->GetStream(fullName, &nextStream);
+ if (result == S_OK)
+ break;
+ if (result != S_FALSE)
+ return result;
+
+ if (!_errorMessage.IsEmpty())
+ _errorMessage.Add_LF();
+ _errorMessage += "Can't open volume: ";
+ _errorMessage += fullName;
+
+ if (prevChecked)
+ break;
+ prevChecked = true;
+ if (numTempVolumes != 0)
+ {
+ m_Database.Volumes.DeleteFrontal(numTempVolumes);
+ numTempVolumes = 0;
+ }
+ }
+
+ } // read nextStream iteration
+
+ if (numTempVolumes != 0)
+ {
+ m_Database.Volumes.DeleteFrontal(numTempVolumes);
+ numTempVolumes = 0;
+ }
+ if (m_Database.Volumes.IsEmpty())
+ return S_FALSE;
+ else
+ {
+ m_Database.FillSortAndShrink();
+ if (!m_Database.Check())
+ return S_FALSE;
+ }
+ }
+ COM_TRY_END
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _errorMessage.Empty();
+ _isArc = false;
+ _errorInHeaders = false;
+ _unexpectedEnd = false;
+ // _mainVolIndex = -1;
+ _phySize = 0;
+ _offset = 0;
+
+ m_Database.Clear();
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CFolderOutStream
+ , ISequentialOutStream
+)
+ const CMvDatabaseEx *m_Database;
+ const CRecordVector<bool> *m_ExtractStatuses;
+
+ Byte *TempBuf;
+ UInt32 TempBufSize;
+ UInt32 TempBufWritten;
+ unsigned NumIdenticalFiles;
+ bool TempBufMode;
+
+ unsigned m_StartIndex;
+ unsigned m_CurrentIndex;
+ CMyComPtr<IArchiveExtractCallback> m_ExtractCallback;
+ bool m_TestMode;
+
+ CMyComPtr<ISequentialOutStream> m_RealOutStream;
+
+ bool m_IsOk;
+ bool m_FileIsOpen;
+ UInt32 m_RemainFileSize;
+ UInt64 m_FolderSize;
+ UInt64 m_PosInFolder;
+
+ void FreeTempBuf()
+ {
+ ::MyFree(TempBuf);
+ TempBuf = NULL;
+ }
+
+ HRESULT OpenFile();
+ HRESULT CloseFileWithResOp(Int32 resOp);
+ HRESULT CloseFile();
+public:
+ HRESULT WriteEmptyFiles();
+
+ CFolderOutStream(): TempBuf(NULL) {}
+ ~CFolderOutStream() { FreeTempBuf(); }
+ void Init(
+ const CMvDatabaseEx *database,
+ const CRecordVector<bool> *extractStatuses,
+ unsigned startIndex,
+ UInt64 folderSize,
+ IArchiveExtractCallback *extractCallback,
+ bool testMode);
+ HRESULT FlushCorrupted(unsigned folderIndex);
+ HRESULT Unsupported();
+
+ bool NeedMoreWrite() const { return (m_FolderSize > m_PosInFolder); }
+ UInt64 GetRemain() const { return m_FolderSize - m_PosInFolder; }
+ UInt64 GetPosInFolder() const { return m_PosInFolder; }
+};
+
+
+void CFolderOutStream::Init(
+ const CMvDatabaseEx *database,
+ const CRecordVector<bool> *extractStatuses,
+ unsigned startIndex,
+ UInt64 folderSize,
+ IArchiveExtractCallback *extractCallback,
+ bool testMode)
+{
+ m_Database = database;
+ m_ExtractStatuses = extractStatuses;
+ m_StartIndex = startIndex;
+ m_FolderSize = folderSize;
+
+ m_ExtractCallback = extractCallback;
+ m_TestMode = testMode;
+
+ m_CurrentIndex = 0;
+ m_PosInFolder = 0;
+ m_FileIsOpen = false;
+ m_IsOk = true;
+ TempBufMode = false;
+ NumIdenticalFiles = 0;
+}
+
+
+HRESULT CFolderOutStream::CloseFileWithResOp(Int32 resOp)
+{
+ m_RealOutStream.Release();
+ m_FileIsOpen = false;
+ NumIdenticalFiles--;
+ return m_ExtractCallback->SetOperationResult(resOp);
+}
+
+
+HRESULT CFolderOutStream::CloseFile()
+{
+ return CloseFileWithResOp(m_IsOk ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError);
+}
+
+
+HRESULT CFolderOutStream::OpenFile()
+{
+ if (NumIdenticalFiles == 0)
+ {
+ const CMvItem &mvItem = m_Database->Items[m_StartIndex + m_CurrentIndex];
+ const CItem &item = m_Database->Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
+ unsigned numExtractItems = 0;
+ unsigned curIndex;
+
+ for (curIndex = m_CurrentIndex; curIndex < m_ExtractStatuses->Size(); curIndex++)
+ {
+ const CMvItem &mvItem2 = m_Database->Items[m_StartIndex + curIndex];
+ const CItem &item2 = m_Database->Volumes[mvItem2.VolumeIndex].Items[mvItem2.ItemIndex];
+ if (item.Offset != item2.Offset ||
+ item.Size != item2.Size ||
+ item.Size == 0)
+ break;
+ if (!m_TestMode && (*m_ExtractStatuses)[curIndex])
+ numExtractItems++;
+ }
+
+ NumIdenticalFiles = (curIndex - m_CurrentIndex);
+ if (NumIdenticalFiles == 0)
+ NumIdenticalFiles = 1;
+ TempBufMode = false;
+
+ if (numExtractItems > 1)
+ {
+ if (!TempBuf || item.Size > TempBufSize)
+ {
+ FreeTempBuf();
+ TempBuf = (Byte *)MyAlloc(item.Size);
+ TempBufSize = item.Size;
+ if (!TempBuf)
+ return E_OUTOFMEMORY;
+ }
+ TempBufMode = true;
+ TempBufWritten = 0;
+ }
+ else if (numExtractItems == 1)
+ {
+ while (NumIdenticalFiles && !(*m_ExtractStatuses)[m_CurrentIndex])
+ {
+ CMyComPtr<ISequentialOutStream> stream;
+ RINOK(m_ExtractCallback->GetStream(m_StartIndex + m_CurrentIndex, &stream, NExtract::NAskMode::kSkip))
+ if (stream)
+ return E_FAIL;
+ RINOK(m_ExtractCallback->PrepareOperation(NExtract::NAskMode::kSkip))
+ m_CurrentIndex++;
+ m_FileIsOpen = true;
+ CloseFile();
+ }
+ }
+ }
+
+ Int32 askMode = (*m_ExtractStatuses)[m_CurrentIndex] ? m_TestMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract :
+ NExtract::NAskMode::kSkip;
+ RINOK(m_ExtractCallback->GetStream(m_StartIndex + m_CurrentIndex, &m_RealOutStream, askMode))
+ if (!m_RealOutStream && !m_TestMode)
+ askMode = NExtract::NAskMode::kSkip;
+ return m_ExtractCallback->PrepareOperation(askMode);
+}
+
+
+HRESULT CFolderOutStream::WriteEmptyFiles()
+{
+ if (m_FileIsOpen)
+ return S_OK;
+ for (; m_CurrentIndex < m_ExtractStatuses->Size(); m_CurrentIndex++)
+ {
+ const CMvItem &mvItem = m_Database->Items[m_StartIndex + m_CurrentIndex];
+ const CItem &item = m_Database->Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
+ UInt64 fileSize = item.Size;
+ if (fileSize != 0)
+ return S_OK;
+ HRESULT result = OpenFile();
+ m_RealOutStream.Release();
+ RINOK(result)
+ RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ // (data == NULL) means Error_Data for solid folder flushing
+ COM_TRY_BEGIN
+
+ UInt32 realProcessed = 0;
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ if (m_FileIsOpen)
+ {
+ UInt32 numBytesToWrite = MyMin(m_RemainFileSize, size);
+ HRESULT res = S_OK;
+ if (numBytesToWrite != 0)
+ {
+ if (!data)
+ m_IsOk = false;
+
+ if (m_RealOutStream)
+ {
+ UInt32 processedSizeLocal = 0;
+ // 18.01 : we don't want ZEROs instead of missing data
+ if (data)
+ res = m_RealOutStream->Write((const Byte *)data, numBytesToWrite, &processedSizeLocal);
+ else
+ processedSizeLocal = numBytesToWrite;
+ numBytesToWrite = processedSizeLocal;
+ }
+
+ if (TempBufMode && TempBuf)
+ {
+ if (data)
+ {
+ memcpy(TempBuf + TempBufWritten, data, numBytesToWrite);
+ TempBufWritten += numBytesToWrite;
+ }
+ }
+ }
+ realProcessed += numBytesToWrite;
+ if (processedSize)
+ *processedSize = realProcessed;
+ if (data)
+ data = (const void *)((const Byte *)data + numBytesToWrite);
+ size -= numBytesToWrite;
+ m_RemainFileSize -= numBytesToWrite;
+ m_PosInFolder += numBytesToWrite;
+
+ if (res != S_OK)
+ return res;
+
+ if (m_RemainFileSize == 0)
+ {
+ RINOK(CloseFile())
+
+ while (NumIdenticalFiles)
+ {
+ HRESULT result = OpenFile();
+ m_FileIsOpen = true;
+ m_CurrentIndex++;
+ if (result == S_OK && m_RealOutStream && TempBuf)
+ result = WriteStream(m_RealOutStream, TempBuf, TempBufWritten);
+
+ if (!TempBuf && TempBufMode && m_RealOutStream)
+ {
+ RINOK(CloseFileWithResOp(NExtract::NOperationResult::kUnsupportedMethod))
+ }
+ else
+ {
+ RINOK(CloseFile())
+ }
+
+ RINOK(result)
+ }
+
+ TempBufMode = false;
+ }
+
+ if (realProcessed > 0)
+ break; // with this break this function works as Write-Part
+ }
+ else
+ {
+ if (m_CurrentIndex >= m_ExtractStatuses->Size())
+ {
+ // we ignore extra data;
+ realProcessed += size;
+ if (processedSize)
+ *processedSize = realProcessed;
+ m_PosInFolder += size;
+ return S_OK;
+ // return E_FAIL;
+ }
+
+ const CMvItem &mvItem = m_Database->Items[m_StartIndex + m_CurrentIndex];
+ const CItem &item = m_Database->Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
+
+ m_RemainFileSize = item.Size;
+
+ UInt32 fileOffset = item.Offset;
+
+ if (fileOffset < m_PosInFolder)
+ return E_FAIL;
+
+ if (fileOffset > m_PosInFolder)
+ {
+ UInt32 numBytesToWrite = MyMin(fileOffset - (UInt32)m_PosInFolder, size);
+ realProcessed += numBytesToWrite;
+ if (processedSize)
+ *processedSize = realProcessed;
+ if (data)
+ data = (const void *)((const Byte *)data + numBytesToWrite);
+ size -= numBytesToWrite;
+ m_PosInFolder += numBytesToWrite;
+ }
+
+ if (fileOffset == m_PosInFolder)
+ {
+ RINOK(OpenFile())
+ m_FileIsOpen = true;
+ m_CurrentIndex++;
+ m_IsOk = true;
+ }
+ }
+ }
+
+ return WriteEmptyFiles();
+
+ COM_TRY_END
+}
+
+
+HRESULT CFolderOutStream::FlushCorrupted(unsigned folderIndex)
+{
+ if (!NeedMoreWrite())
+ {
+ CMyComPtr<IArchiveExtractCallbackMessage2> callbackMessage;
+ m_ExtractCallback.QueryInterface(IID_IArchiveExtractCallbackMessage2, &callbackMessage);
+ if (callbackMessage)
+ {
+ RINOK(callbackMessage->ReportExtractResult(NEventIndexType::kBlockIndex, folderIndex, NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ }
+
+ for (;;)
+ {
+ if (!NeedMoreWrite())
+ return S_OK;
+ UInt64 remain = GetRemain();
+ UInt32 size = (UInt32)1 << 20;
+ if (size > remain)
+ size = (UInt32)remain;
+ UInt32 processedSizeLocal = 0;
+ RINOK(Write(NULL, size, &processedSizeLocal))
+ }
+}
+
+
+HRESULT CFolderOutStream::Unsupported()
+{
+ while (m_CurrentIndex < m_ExtractStatuses->Size())
+ {
+ HRESULT result = OpenFile();
+ if (result != S_FALSE && result != S_OK)
+ return result;
+ m_RealOutStream.Release();
+ RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ m_CurrentIndex++;
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testModeSpec, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = m_Database.Items.Size();
+ if (numItems == 0)
+ return S_OK;
+ bool testMode = (testModeSpec != 0);
+ UInt64 totalUnPacked = 0;
+
+ UInt32 i;
+ int lastFolder = -2;
+ UInt64 lastFolderSize = 0;
+
+ for (i = 0; i < numItems; i++)
+ {
+ unsigned index = allFilesMode ? i : indices[i];
+ const CMvItem &mvItem = m_Database.Items[index];
+ const CItem &item = m_Database.Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
+ if (item.IsDir())
+ continue;
+ int folderIndex = m_Database.GetFolderIndex(&mvItem);
+ if (folderIndex != lastFolder)
+ totalUnPacked += lastFolderSize;
+ lastFolder = folderIndex;
+ lastFolderSize = item.GetEndOffset();
+ }
+
+ totalUnPacked += lastFolderSize;
+
+ extractCallback->SetTotal(totalUnPacked);
+
+ totalUnPacked = 0;
+
+ UInt64 totalPacked = 0;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ NCompress::NDeflate::NDecoder::CCOMCoder *deflateDecoderSpec = NULL;
+ CMyComPtr<ICompressCoder> deflateDecoder;
+
+ NCompress::NLzx::CDecoder *lzxDecoderSpec = NULL;
+ CMyComPtr<IUnknown> lzxDecoder;
+
+ NCompress::NQuantum::CDecoder *quantumDecoderSpec = NULL;
+ CMyComPtr<IUnknown> quantumDecoder;
+
+ CCabBlockInStream *cabBlockInStreamSpec = new CCabBlockInStream();
+ CMyComPtr<ISequentialInStream> cabBlockInStream = cabBlockInStreamSpec;
+ if (!cabBlockInStreamSpec->Create())
+ return E_OUTOFMEMORY;
+
+ CRecordVector<bool> extractStatuses;
+
+ for (i = 0;;)
+ {
+ lps->OutSize = totalUnPacked;
+ lps->InSize = totalPacked;
+ RINOK(lps->SetCur())
+
+ if (i >= numItems)
+ break;
+
+ const unsigned index = allFilesMode ? i : indices[i];
+
+ const CMvItem &mvItem = m_Database.Items[index];
+ const CDatabaseEx &db = m_Database.Volumes[mvItem.VolumeIndex];
+ const unsigned itemIndex = mvItem.ItemIndex;
+ const CItem &item = db.Items[itemIndex];
+
+ i++;
+ if (item.IsDir())
+ {
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const int folderIndex = m_Database.GetFolderIndex(&mvItem);
+
+ if (folderIndex < 0)
+ {
+ // If we need previous archive
+ const Int32 askMode= testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kDataError))
+ continue;
+ }
+
+ const unsigned startIndex2 = m_Database.FolderStartFileIndex[(unsigned)folderIndex];
+ unsigned startIndex = startIndex2;
+ extractStatuses.Clear();
+ for (; startIndex < index; startIndex++)
+ extractStatuses.Add(false);
+ extractStatuses.Add(true);
+ startIndex++;
+ UInt64 curUnpack = item.GetEndOffset();
+
+ for (; i < numItems; i++)
+ {
+ const unsigned indexNext = allFilesMode ? i : indices[i];
+ const CMvItem &mvItem2 = m_Database.Items[indexNext];
+ const CItem &item2 = m_Database.Volumes[mvItem2.VolumeIndex].Items[mvItem2.ItemIndex];
+ if (item2.IsDir())
+ continue;
+ const int newFolderIndex = m_Database.GetFolderIndex(&mvItem2);
+
+ if (newFolderIndex != folderIndex)
+ break;
+ for (; startIndex < indexNext; startIndex++)
+ extractStatuses.Add(false);
+ extractStatuses.Add(true);
+ startIndex++;
+ curUnpack = item2.GetEndOffset();
+ }
+
+ CFolderOutStream *cabFolderOutStream = new CFolderOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(cabFolderOutStream);
+
+ const int folderIndex2 = item.GetFolderIndex(db.Folders.Size());
+ if (folderIndex2 < 0)
+ return E_FAIL;
+ const CFolder &folder = db.Folders[(unsigned)folderIndex2];
+
+ cabFolderOutStream->Init(&m_Database, &extractStatuses, startIndex2,
+ curUnpack, extractCallback, testMode);
+
+ cabBlockInStreamSpec->MsZip = false;
+ HRESULT res = S_OK;
+
+ switch (folder.GetMethod())
+ {
+ case NHeader::NMethod::kNone:
+ break;
+
+ case NHeader::NMethod::kMSZip:
+ if (!deflateDecoder)
+ {
+ deflateDecoderSpec = new NCompress::NDeflate::NDecoder::CCOMCoder;
+ deflateDecoder = deflateDecoderSpec;
+ }
+ cabBlockInStreamSpec->MsZip = true;
+ break;
+
+ case NHeader::NMethod::kLZX:
+ if (!lzxDecoder)
+ {
+ lzxDecoderSpec = new NCompress::NLzx::CDecoder;
+ lzxDecoder = lzxDecoderSpec;
+ }
+ res = lzxDecoderSpec->SetParams_and_Alloc(folder.MethodMinor);
+ break;
+
+ case NHeader::NMethod::kQuantum:
+ if (!quantumDecoder)
+ {
+ quantumDecoderSpec = new NCompress::NQuantum::CDecoder;
+ quantumDecoder = quantumDecoderSpec;
+ }
+ res = quantumDecoderSpec->SetParams(folder.MethodMinor);
+ break;
+
+ default:
+ res = E_INVALIDARG;
+ break;
+ }
+
+ if (res == E_INVALIDARG)
+ {
+ RINOK(cabFolderOutStream->Unsupported())
+ totalUnPacked += curUnpack;
+ continue;
+ }
+ RINOK(res)
+
+ {
+ unsigned volIndex = mvItem.VolumeIndex;
+ int locFolderIndex = item.GetFolderIndex(db.Folders.Size());
+ bool keepHistory = false;
+ bool keepInputBuffer = false;
+ bool thereWasNotAlignedChunk = false;
+
+ for (UInt32 bl = 0; cabFolderOutStream->NeedMoreWrite();)
+ {
+ if (volIndex >= m_Database.Volumes.Size())
+ {
+ res = S_FALSE;
+ break;
+ }
+
+ const CDatabaseEx &db2 = m_Database.Volumes[volIndex];
+ if (locFolderIndex < 0)
+ return E_FAIL;
+ const CFolder &folder2 = db2.Folders[(unsigned)locFolderIndex];
+
+ if (bl == 0)
+ {
+ cabBlockInStreamSpec->ReservedSize = db2.ArcInfo.GetDataBlockReserveSize();
+ RINOK(InStream_SeekSet(db2.Stream, db2.StartPosition + folder2.DataStart))
+ }
+
+ if (bl == folder2.NumDataBlocks)
+ {
+ /*
+ CFolder::NumDataBlocks (CFFOLDER::cCFData in CAB specification) is 16-bit.
+ But there are some big CAB archives from MS that contain more
+ than (0xFFFF) CFDATA blocks in folder.
+ Old cab extracting software can show error (or ask next volume)
+ but cab extracting library in new Windows ignores this error.
+ 15.00 : We also try to ignore such error, if archive is not multi-volume.
+ */
+ if (m_Database.Volumes.Size() > 1)
+ {
+ volIndex++;
+ locFolderIndex = 0;
+ bl = 0;
+ continue;
+ }
+ }
+
+ bl++;
+
+ if (!keepInputBuffer)
+ cabBlockInStreamSpec->InitForNewBlock();
+
+ UInt32 packSize, unpackSize;
+ res = cabBlockInStreamSpec->PreRead(db2.Stream, packSize, unpackSize);
+ if (res == S_FALSE)
+ break;
+ RINOK(res)
+ keepInputBuffer = (unpackSize == 0);
+ if (keepInputBuffer)
+ continue;
+
+ UInt64 totalUnPacked2 = totalUnPacked + cabFolderOutStream->GetPosInFolder();
+ totalPacked += packSize;
+
+ lps->OutSize = totalUnPacked2;
+ lps->InSize = totalPacked;
+ RINOK(lps->SetCur())
+
+ const UInt32 kBlockSizeMax = (1 << 15);
+
+ /* We don't try to reduce last block.
+ Note that LZX converts data with x86 filter.
+ and filter needs larger input data than reduced size.
+ It's simpler to decompress full chunk here.
+ also we need full block for quantum for more integrity checks */
+
+ if (unpackSize > kBlockSizeMax)
+ {
+ res = S_FALSE;
+ break;
+ }
+
+ if (unpackSize != kBlockSizeMax)
+ {
+ if (thereWasNotAlignedChunk)
+ {
+ res = S_FALSE;
+ break;
+ }
+ thereWasNotAlignedChunk = true;
+ }
+
+ UInt64 unpackSize64 = unpackSize;
+ UInt32 packSizeChunk = cabBlockInStreamSpec->GetPackSizeAvail();
+
+ switch (folder2.GetMethod())
+ {
+ case NHeader::NMethod::kNone:
+ res = copyCoder->Code(cabBlockInStream, outStream, NULL, &unpackSize64, NULL);
+ break;
+
+ case NHeader::NMethod::kMSZip:
+ deflateDecoderSpec->Set_KeepHistory(keepHistory);
+ /* v9.31: now we follow MSZIP specification that requires to finish deflate stream at the end of each block.
+ But PyCabArc can create CAB archives that doesn't have finish marker at the end of block.
+ Cabarc probably ignores such errors in cab archives.
+ Maybe we also should ignore that error?
+ Or we should extract full file and show the warning? */
+ deflateDecoderSpec->Set_NeedFinishInput(true);
+ res = deflateDecoder->Code(cabBlockInStream, outStream, NULL, &unpackSize64, NULL);
+ if (res == S_OK)
+ {
+ if (!deflateDecoderSpec->IsFinished())
+ res = S_FALSE;
+ if (!deflateDecoderSpec->IsFinalBlock())
+ res = S_FALSE;
+ }
+ break;
+
+ case NHeader::NMethod::kLZX:
+ lzxDecoderSpec->SetKeepHistory(keepHistory);
+ lzxDecoderSpec->KeepHistoryForNext = true;
+
+ res = lzxDecoderSpec->Code(cabBlockInStreamSpec->GetData(), packSizeChunk, unpackSize);
+
+ if (res == S_OK)
+ res = WriteStream(outStream,
+ lzxDecoderSpec->GetUnpackData(),
+ lzxDecoderSpec->GetUnpackSize());
+ break;
+
+ case NHeader::NMethod::kQuantum:
+ res = quantumDecoderSpec->Code(cabBlockInStreamSpec->GetData(),
+ packSizeChunk, outStream, unpackSize, keepHistory);
+ break;
+ }
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ RINOK(res)
+ break;
+ }
+
+ keepHistory = true;
+ }
+
+ if (res == S_OK)
+ {
+ RINOK(cabFolderOutStream->WriteEmptyFiles())
+ }
+ }
+
+ if (res != S_OK || cabFolderOutStream->NeedMoreWrite())
+ {
+ RINOK(cabFolderOutStream->FlushCorrupted((unsigned)folderIndex2))
+ }
+
+ totalUnPacked += curUnpack;
+ }
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = m_Database.Items.Size();
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Cab/CabHandler.h b/CPP/7zip/Archive/Cab/CabHandler.h
new file mode 100644
index 0000000..1e1811f
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabHandler.h
@@ -0,0 +1,29 @@
+// CabHandler.h
+
+#ifndef ZIP7_INC_CAB_HANDLER_H
+#define ZIP7_INC_CAB_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../IArchive.h"
+
+#include "CabIn.h"
+
+namespace NArchive {
+namespace NCab {
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ CMvDatabaseEx m_Database;
+ UString _errorMessage;
+ bool _isArc;
+ bool _errorInHeaders;
+ bool _unexpectedEnd;
+ // int _mainVolIndex;
+ UInt32 _phySize;
+ UInt64 _offset;
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Cab/CabHeader.cpp b/CPP/7zip/Archive/Cab/CabHeader.cpp
new file mode 100644
index 0000000..370a2f1
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabHeader.cpp
@@ -0,0 +1,15 @@
+// CabHeader.cpp
+
+#include "StdAfx.h"
+
+#include "CabHeader.h"
+
+namespace NArchive {
+namespace NCab {
+namespace NHeader {
+
+const Byte kMarker[kMarkerSize] = {'M', 'S', 'C', 'F', 0, 0, 0, 0 };
+
+// struct CSignatureInitializer { CSignatureInitializer() { kMarker[0]--; } } g_SignatureInitializer;
+
+}}}
diff --git a/CPP/7zip/Archive/Cab/CabHeader.h b/CPP/7zip/Archive/Cab/CabHeader.h
new file mode 100644
index 0000000..ecb9a87
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabHeader.h
@@ -0,0 +1,41 @@
+// Archive/CabHeader.h
+
+#ifndef ZIP7_INC_ARCHIVE_CAB_HEADER_H
+#define ZIP7_INC_ARCHIVE_CAB_HEADER_H
+
+#include "../../../Common/MyTypes.h"
+
+namespace NArchive {
+namespace NCab {
+namespace NHeader {
+
+const unsigned kMarkerSize = 8;
+extern const Byte kMarker[kMarkerSize];
+
+namespace NArcFlags
+{
+ const unsigned kPrevCabinet = 1;
+ const unsigned kNextCabinet = 2;
+ const unsigned kReservePresent = 4;
+}
+
+namespace NMethod
+{
+ const Byte kNone = 0;
+ const Byte kMSZip = 1;
+ const Byte kQuantum = 2;
+ const Byte kLZX = 3;
+}
+
+const unsigned kFileNameIsUtf8_Mask = 0x80;
+
+namespace NFolderIndex
+{
+ const unsigned kContinuedFromPrev = 0xFFFD;
+ const unsigned kContinuedToNext = 0xFFFE;
+ const unsigned kContinuedPrevAndNext = 0xFFFF;
+}
+
+}}}
+
+#endif
diff --git a/CPP/7zip/Archive/Cab/CabIn.cpp b/CPP/7zip/Archive/Cab/CabIn.cpp
new file mode 100644
index 0000000..fb69643
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabIn.cpp
@@ -0,0 +1,491 @@
+// Archive/CabIn.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/StreamUtils.h"
+
+#include "CabIn.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+namespace NArchive {
+namespace NCab {
+
+struct CUnexpectedEndException {};
+
+void CInArchive::Skip(unsigned size)
+{
+ if (_inBuffer.Skip(size) != size)
+ throw CUnexpectedEndException();
+}
+
+void CInArchive::Read(Byte *data, unsigned size)
+{
+ if (_inBuffer.ReadBytes(data, size) != size)
+ throw CUnexpectedEndException();
+}
+
+void CInArchive::ReadName(AString &s)
+{
+ for (size_t i = 0; i < ((size_t)1 << 13); i++)
+ {
+ Byte b;
+ if (!_inBuffer.ReadByte(b))
+ throw CUnexpectedEndException();
+ if (b == 0)
+ {
+ s.SetFrom((const char *)(const Byte *)_tempBuf, (unsigned)i);
+ return;
+ }
+ if (_tempBuf.Size() == i)
+ _tempBuf.ChangeSize_KeepData(i * 2, i);
+ _tempBuf[i] = b;
+ }
+
+ for (;;)
+ {
+ Byte b;
+ if (!_inBuffer.ReadByte(b))
+ throw CUnexpectedEndException();
+ if (b == 0)
+ break;
+ }
+
+ ErrorInNames = true;
+ s = "[ERROR-LONG-PATH]";
+}
+
+void CInArchive::ReadOtherArc(COtherArc &oa)
+{
+ ReadName(oa.FileName);
+ ReadName(oa.DiskName);
+}
+
+
+struct CSignatureFinder
+{
+ Byte *Buf;
+ UInt32 Pos;
+ UInt32 End;
+ const Byte *Signature;
+ UInt32 SignatureSize;
+
+ UInt32 _headerSize;
+ UInt32 _alignSize;
+ UInt32 _bufUseCapacity;
+
+ ISequentialInStream *Stream;
+ UInt64 Processed; // Global offset of start of Buf
+
+ const UInt64 *SearchLimit;
+
+ UInt32 GetTotalCapacity(UInt32 basicSize, UInt32 headerSize)
+ {
+ _headerSize = headerSize;
+ for (_alignSize = (1 << 5); _alignSize < _headerSize; _alignSize <<= 1);
+ _bufUseCapacity = basicSize + _alignSize;
+ return _bufUseCapacity + 16;
+ }
+
+ /*
+ returns:
+ S_OK - signature found (at Pos)
+ S_FALSE - signature not found
+ */
+ HRESULT Find();
+};
+
+
+HRESULT CSignatureFinder::Find()
+{
+ for (;;)
+ {
+ Buf[End] = Signature[0]; // it's for fast search;
+
+ while (End - Pos >= _headerSize)
+ {
+ const Byte *p = Buf + Pos;
+ Byte b = Signature[0];
+ for (;;)
+ {
+ if (*p == b) { break; } p++;
+ if (*p == b) { break; } p++;
+ }
+ Pos = (UInt32)(p - Buf);
+ if (End - Pos < _headerSize)
+ {
+ Pos = End - _headerSize + 1;
+ break;
+ }
+ UInt32 i;
+ for (i = 1; i < SignatureSize && p[i] == Signature[i]; i++);
+ if (i == SignatureSize)
+ return S_OK;
+ Pos++;
+ }
+
+ if (Pos >= _alignSize)
+ {
+ UInt32 num = (Pos & ~(_alignSize - 1));
+ Processed += num;
+ Pos -= num;
+ End -= num;
+ memmove(Buf, Buf + num, End);
+ }
+ UInt32 rem = _bufUseCapacity - End;
+ if (SearchLimit)
+ {
+ if (Processed + Pos > *SearchLimit)
+ return S_FALSE;
+ UInt64 rem2 = *SearchLimit - (Processed + End) + _headerSize;
+ if (rem > rem2)
+ rem = (UInt32)rem2;
+ }
+
+ UInt32 processedSize;
+ if (Processed == 0 && rem == _bufUseCapacity - _headerSize)
+ rem -= _alignSize; // to make reads more aligned.
+ RINOK(Stream->Read(Buf + End, rem, &processedSize))
+ if (processedSize == 0)
+ return S_FALSE;
+ End += processedSize;
+ }
+}
+
+
+bool CInArcInfo::Parse(const Byte *p)
+{
+ if (Get32(p + 0x0C) != 0 ||
+ Get32(p + 0x14) != 0)
+ return false;
+ Size = Get32(p + 8);
+ if (Size < 36)
+ return false;
+ Flags = Get16(p + 0x1E);
+ if (Flags > 7)
+ return false;
+ FileHeadersOffset = Get32(p + 0x10);
+ if (FileHeadersOffset != 0 && FileHeadersOffset > Size)
+ return false;
+ VersionMinor = p[0x18];
+ VersionMajor = p[0x19];
+ NumFolders = Get16(p + 0x1A);
+ NumFiles = Get16(p + 0x1C);
+ return true;
+}
+
+
+HRESULT CInArchive::Open2(CDatabaseEx &db, const UInt64 *searchHeaderSizeLimit)
+{
+ IsArc = false;
+ ErrorInNames = false;
+ UnexpectedEnd = false;
+ HeaderError = false;
+
+ db.Clear();
+ RINOK(InStream_GetPos(db.Stream, db.StartPosition))
+ // UInt64 temp = db.StartPosition;
+
+ CByteBuffer buffer;
+ CInArcInfo &ai = db.ArcInfo;
+ UInt64 startInBuf = 0;
+
+ CLimitedSequentialInStream *limitedStreamSpec = NULL;
+ CMyComPtr<ISequentialInStream> limitedStream;
+
+ // for (int iii = 0; iii < 10000; iii++)
+ {
+ // db.StartPosition = temp; RINOK(InStream_SeekSet(db.Stream, db.StartPosition))
+
+ const UInt32 kMainHeaderSize = 32;
+ Byte header[kMainHeaderSize];
+ const UInt32 kBufSize = 1 << 15;
+ RINOK(ReadStream_FALSE(db.Stream, header, kMainHeaderSize))
+ if (memcmp(header, NHeader::kMarker, NHeader::kMarkerSize) == 0 && ai.Parse(header))
+ {
+ limitedStreamSpec = new CLimitedSequentialInStream;
+ limitedStream = limitedStreamSpec;
+ limitedStreamSpec->SetStream(db.Stream);
+ limitedStreamSpec->Init(ai.Size - NHeader::kMarkerSize);
+ buffer.Alloc(kBufSize);
+ memcpy(buffer, header, kMainHeaderSize);
+ UInt32 numProcessedBytes;
+ RINOK(limitedStream->Read(buffer + kMainHeaderSize, kBufSize - kMainHeaderSize, &numProcessedBytes))
+ _inBuffer.SetBuf(buffer, (UInt32)kBufSize, kMainHeaderSize + numProcessedBytes, kMainHeaderSize);
+ }
+ else
+ {
+ if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
+ return S_FALSE;
+
+ CSignatureFinder finder;
+
+ finder.Stream = db.Stream;
+ finder.Signature = NHeader::kMarker;
+ finder.SignatureSize = NHeader::kMarkerSize;
+ finder.SearchLimit = searchHeaderSizeLimit;
+
+ buffer.Alloc(finder.GetTotalCapacity(kBufSize, kMainHeaderSize));
+ finder.Buf = buffer;
+
+ memcpy(buffer, header, kMainHeaderSize);
+ finder.Processed = db.StartPosition;
+ finder.End = kMainHeaderSize;
+ finder.Pos = 1;
+
+ for (;;)
+ {
+ RINOK(finder.Find())
+ if (ai.Parse(finder.Buf + finder.Pos))
+ {
+ db.StartPosition = finder.Processed + finder.Pos;
+ limitedStreamSpec = new CLimitedSequentialInStream;
+ limitedStreamSpec->SetStream(db.Stream);
+ limitedStream = limitedStreamSpec;
+ UInt32 remInFinder = finder.End - finder.Pos;
+ if (ai.Size <= remInFinder)
+ {
+ limitedStreamSpec->Init(0);
+ finder.End = finder.Pos + ai.Size;
+ }
+ else
+ limitedStreamSpec->Init(ai.Size - remInFinder);
+
+ startInBuf = finder.Pos;
+ _inBuffer.SetBuf(buffer, (UInt32)kBufSize, finder.End, finder.Pos + kMainHeaderSize);
+ break;
+ }
+ finder.Pos++;
+ }
+ }
+ }
+
+ IsArc = true;
+
+ _inBuffer.SetStream(limitedStream);
+ if (_tempBuf.Size() == 0)
+ _tempBuf.Alloc(1 << 12);
+
+ Byte p[16];
+ unsigned nextSize = 4 + (ai.ReserveBlockPresent() ? 4 : 0);
+ Read(p, nextSize);
+ ai.SetID = Get16(p);
+ ai.CabinetNumber = Get16(p + 2);
+
+ if (ai.ReserveBlockPresent())
+ {
+ ai.PerCabinet_AreaSize = Get16(p + 4);
+ ai.PerFolder_AreaSize = p[6];
+ ai.PerDataBlock_AreaSize = p[7];
+ Skip(ai.PerCabinet_AreaSize);
+ }
+
+ if (ai.IsTherePrev()) ReadOtherArc(ai.PrevArc);
+ if (ai.IsThereNext()) ReadOtherArc(ai.NextArc);
+
+ UInt32 i;
+
+ db.Folders.ClearAndReserve(ai.NumFolders);
+
+ for (i = 0; i < ai.NumFolders; i++)
+ {
+ Read(p, 8);
+ CFolder folder;
+ folder.DataStart = Get32(p);
+ folder.NumDataBlocks = Get16(p + 4);
+ folder.MethodMajor = p[6];
+ folder.MethodMinor = p[7];
+ Skip(ai.PerFolder_AreaSize);
+ db.Folders.AddInReserved(folder);
+ }
+
+ // for (int iii = 0; iii < 10000; iii++) {
+
+ if (_inBuffer.GetProcessedSize() - startInBuf != ai.FileHeadersOffset)
+ {
+ // printf("\n!!! Seek Error !!!!\n");
+ // fflush(stdout);
+ RINOK(InStream_SeekSet(db.Stream, db.StartPosition + ai.FileHeadersOffset))
+ limitedStreamSpec->Init(ai.Size - ai.FileHeadersOffset);
+ _inBuffer.Init();
+ }
+
+ db.Items.ClearAndReserve(ai.NumFiles);
+
+ for (i = 0; i < ai.NumFiles; i++)
+ {
+ Read(p, 16);
+ CItem &item = db.Items.AddNewInReserved();
+ item.Size = Get32(p);
+ item.Offset = Get32(p + 4);
+ item.FolderIndex = Get16(p + 8);
+ UInt16 pureDate = Get16(p + 10);
+ UInt16 pureTime = Get16(p + 12);
+ item.Time = (((UInt32)pureDate << 16)) | pureTime;
+ item.Attributes = Get16(p + 14);
+
+ ReadName(item.Name);
+
+ if (item.GetFolderIndex(db.Folders.Size()) >= (int)db.Folders.Size())
+ {
+ HeaderError = true;
+ return S_FALSE;
+ }
+ }
+
+ // }
+
+ return S_OK;
+}
+
+
+HRESULT CInArchive::Open(CDatabaseEx &db, const UInt64 *searchHeaderSizeLimit)
+{
+ try
+ {
+ return Open2(db, searchHeaderSizeLimit);
+ }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(CUnexpectedEndException &) { UnexpectedEnd = true; return S_FALSE; }
+}
+
+
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+static int CompareMvItems(const CMvItem *p1, const CMvItem *p2, void *param)
+{
+ const CMvDatabaseEx &mvDb = *(const CMvDatabaseEx *)param;
+ const CDatabaseEx &db1 = mvDb.Volumes[p1->VolumeIndex];
+ const CDatabaseEx &db2 = mvDb.Volumes[p2->VolumeIndex];
+ const CItem &item1 = db1.Items[p1->ItemIndex];
+ const CItem &item2 = db2.Items[p2->ItemIndex];
+ bool isDir1 = item1.IsDir();
+ bool isDir2 = item2.IsDir();
+ if (isDir1 && !isDir2) return -1;
+ if (isDir2 && !isDir1) return 1;
+ int f1 = mvDb.GetFolderIndex(p1);
+ int f2 = mvDb.GetFolderIndex(p2);
+ RINOZ(MyCompare(f1, f2))
+ RINOZ(MyCompare(item1.Offset, item2.Offset))
+ RINOZ(MyCompare(item1.Size, item2.Size))
+ RINOZ(MyCompare(p1->VolumeIndex, p2->VolumeIndex))
+ return MyCompare(p1->ItemIndex, p2->ItemIndex);
+}
+
+
+bool CMvDatabaseEx::AreItemsEqual(unsigned i1, unsigned i2)
+{
+ const CMvItem *p1 = &Items[i1];
+ const CMvItem *p2 = &Items[i2];
+ const CDatabaseEx &db1 = Volumes[p1->VolumeIndex];
+ const CDatabaseEx &db2 = Volumes[p2->VolumeIndex];
+ const CItem &item1 = db1.Items[p1->ItemIndex];
+ const CItem &item2 = db2.Items[p2->ItemIndex];
+ return GetFolderIndex(p1) == GetFolderIndex(p2)
+ && item1.Offset == item2.Offset
+ && item1.Size == item2.Size
+ && item1.Name == item2.Name;
+}
+
+
+void CMvDatabaseEx::FillSortAndShrink()
+{
+ Items.Clear();
+ StartFolderOfVol.Clear();
+ FolderStartFileIndex.Clear();
+
+ int offset = 0;
+
+ FOR_VECTOR (v, Volumes)
+ {
+ const CDatabaseEx &db = Volumes[v];
+ int curOffset = offset;
+ if (db.IsTherePrevFolder())
+ curOffset--;
+ StartFolderOfVol.Add(curOffset);
+ offset += db.GetNumberOfNewFolders();
+
+ CMvItem mvItem;
+ mvItem.VolumeIndex = v;
+ FOR_VECTOR (i, db.Items)
+ {
+ mvItem.ItemIndex = i;
+ Items.Add(mvItem);
+ }
+ }
+
+ if (Items.Size() > 1)
+ {
+ Items.Sort(CompareMvItems, (void *)this);
+ unsigned j = 1;
+ unsigned i = 1;
+ for (; i < Items.Size(); i++)
+ if (!AreItemsEqual(i, i - 1))
+ Items[j++] = Items[i];
+ Items.DeleteFrom(j);
+ }
+
+ FOR_VECTOR (i, Items)
+ {
+ int folderIndex = GetFolderIndex(&Items[i]);
+ while (folderIndex >= (int)FolderStartFileIndex.Size())
+ FolderStartFileIndex.Add(i);
+ }
+}
+
+
+bool CMvDatabaseEx::Check()
+{
+ for (unsigned v = 1; v < Volumes.Size(); v++)
+ {
+ const CDatabaseEx &db1 = Volumes[v];
+ if (db1.IsTherePrevFolder())
+ {
+ const CDatabaseEx &db0 = Volumes[v - 1];
+ if (db0.Folders.IsEmpty() || db1.Folders.IsEmpty())
+ return false;
+ const CFolder &f0 = db0.Folders.Back();
+ const CFolder &f1 = db1.Folders.Front();
+ if (f0.MethodMajor != f1.MethodMajor ||
+ f0.MethodMinor != f1.MethodMinor)
+ return false;
+ }
+ }
+
+ UInt32 beginPos = 0;
+ UInt64 endPos = 0;
+ int prevFolder = -2;
+
+ FOR_VECTOR (i, Items)
+ {
+ const CMvItem &mvItem = Items[i];
+ int fIndex = GetFolderIndex(&mvItem);
+ if (fIndex >= (int)FolderStartFileIndex.Size())
+ return false;
+ const CItem &item = Volumes[mvItem.VolumeIndex].Items[mvItem.ItemIndex];
+ if (item.IsDir())
+ continue;
+
+ int folderIndex = GetFolderIndex(&mvItem);
+
+ if (folderIndex != prevFolder)
+ prevFolder = folderIndex;
+ else if (item.Offset < endPos &&
+ (item.Offset != beginPos || item.GetEndOffset() != endPos))
+ return false;
+
+ beginPos = item.Offset;
+ endPos = item.GetEndOffset();
+ }
+
+ return true;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Cab/CabIn.h b/CPP/7zip/Archive/Cab/CabIn.h
new file mode 100644
index 0000000..06aa34c
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabIn.h
@@ -0,0 +1,176 @@
+// Archive/CabIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_CAB_IN_H
+#define ZIP7_INC_ARCHIVE_CAB_IN_H
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyCom.h"
+
+#include "../../Common/InBuffer.h"
+
+#include "CabItem.h"
+
+namespace NArchive {
+namespace NCab {
+
+struct COtherArc
+{
+ AString FileName;
+ AString DiskName;
+
+ void Clear()
+ {
+ FileName.Empty();
+ DiskName.Empty();
+ }
+};
+
+
+struct CArchInfo
+{
+ Byte VersionMinor; // cabinet file format version, minor
+ Byte VersionMajor; // cabinet file format version, major
+ UInt32 NumFolders; // number of CFFOLDER entries in this cabinet
+ UInt32 NumFiles; // number of CFFILE entries in this cabinet
+ UInt32 Flags; // cabinet file option indicators
+ UInt32 SetID; // must be the same for all cabinets in a set
+ UInt32 CabinetNumber; // number of this cabinet file in a set
+
+ UInt16 PerCabinet_AreaSize; // (optional) size of per-cabinet reserved area
+ Byte PerFolder_AreaSize; // (optional) size of per-folder reserved area
+ Byte PerDataBlock_AreaSize; // (optional) size of per-datablock reserved area
+
+ COtherArc PrevArc; // prev link can skip some volumes !!!
+ COtherArc NextArc;
+
+ bool ReserveBlockPresent() const { return (Flags & NHeader::NArcFlags::kReservePresent) != 0; }
+ bool IsTherePrev() const { return (Flags & NHeader::NArcFlags::kPrevCabinet) != 0; }
+ bool IsThereNext() const { return (Flags & NHeader::NArcFlags::kNextCabinet) != 0; }
+ Byte GetDataBlockReserveSize() const { return (Byte)(ReserveBlockPresent() ? PerDataBlock_AreaSize : 0); }
+
+ CArchInfo()
+ {
+ PerCabinet_AreaSize = 0;
+ PerFolder_AreaSize = 0;
+ PerDataBlock_AreaSize = 0;
+ }
+
+ void Clear()
+ {
+ PerCabinet_AreaSize = 0;
+ PerFolder_AreaSize = 0;
+ PerDataBlock_AreaSize = 0;
+
+ PrevArc.Clear();
+ NextArc.Clear();
+ }
+};
+
+
+struct CInArcInfo: public CArchInfo
+{
+ UInt32 Size; // size of this cabinet file in bytes
+ UInt32 FileHeadersOffset; // offset of the first CFFILE entry
+
+ bool Parse(const Byte *p);
+};
+
+
+struct CDatabase
+{
+ CRecordVector<CFolder> Folders;
+ CObjectVector<CItem> Items;
+ UInt64 StartPosition;
+ CInArcInfo ArcInfo;
+
+ void Clear()
+ {
+ ArcInfo.Clear();
+ Folders.Clear();
+ Items.Clear();
+ }
+
+ bool IsTherePrevFolder() const
+ {
+ FOR_VECTOR (i, Items)
+ if (Items[i].ContinuedFromPrev())
+ return true;
+ return false;
+ }
+
+ int GetNumberOfNewFolders() const
+ {
+ int res = (int)Folders.Size();
+ if (IsTherePrevFolder())
+ res--;
+ return res;
+ }
+};
+
+
+struct CDatabaseEx: public CDatabase
+{
+ CMyComPtr<IInStream> Stream;
+};
+
+
+struct CMvItem
+{
+ unsigned VolumeIndex;
+ unsigned ItemIndex;
+};
+
+
+class CMvDatabaseEx
+{
+ bool AreItemsEqual(unsigned i1, unsigned i2);
+
+public:
+ CObjectVector<CDatabaseEx> Volumes;
+ CRecordVector<CMvItem> Items;
+ CRecordVector<int> StartFolderOfVol; // can be negative
+ CRecordVector<unsigned> FolderStartFileIndex;
+
+ int GetFolderIndex(const CMvItem *mvi) const
+ {
+ const CDatabaseEx &db = Volumes[mvi->VolumeIndex];
+ return StartFolderOfVol[mvi->VolumeIndex] +
+ db.Items[mvi->ItemIndex].GetFolderIndex(db.Folders.Size());
+ }
+
+ void Clear()
+ {
+ Volumes.Clear();
+ Items.Clear();
+ StartFolderOfVol.Clear();
+ FolderStartFileIndex.Clear();
+ }
+
+ void FillSortAndShrink();
+ bool Check();
+};
+
+
+class CInArchive
+{
+ CInBufferBase _inBuffer;
+ CByteBuffer _tempBuf;
+
+ void Skip(unsigned size);
+ void Read(Byte *data, unsigned size);
+ void ReadName(AString &s);
+ void ReadOtherArc(COtherArc &oa);
+ HRESULT Open2(CDatabaseEx &db, const UInt64 *searchHeaderSizeLimit);
+
+public:
+ bool IsArc;
+ bool ErrorInNames;
+ bool UnexpectedEnd;
+ bool HeaderError;
+
+ HRESULT Open(CDatabaseEx &db, const UInt64 *searchHeaderSizeLimit);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Cab/CabItem.h b/CPP/7zip/Archive/Cab/CabItem.h
new file mode 100644
index 0000000..b7e07d1
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabItem.h
@@ -0,0 +1,66 @@
+// Archive/CabItem.h
+
+#ifndef ZIP7_INC_ARCHIVE_CAB_ITEM_H
+#define ZIP7_INC_ARCHIVE_CAB_ITEM_H
+
+#include "../../../Common/MyString.h"
+
+#include "CabHeader.h"
+
+namespace NArchive {
+namespace NCab {
+
+const unsigned kNumMethodsMax = 16;
+
+struct CFolder
+{
+ UInt32 DataStart; // offset of the first CFDATA block in this folder
+ UInt16 NumDataBlocks; // number of CFDATA blocks in this folder
+ Byte MethodMajor;
+ Byte MethodMinor;
+
+ Byte GetMethod() const { return (Byte)(MethodMajor & 0xF); }
+};
+
+struct CItem
+{
+ AString Name;
+ UInt32 Offset;
+ UInt32 Size;
+ UInt32 Time;
+ UInt32 FolderIndex;
+ UInt16 Flags;
+ UInt16 Attributes;
+
+ UInt64 GetEndOffset() const { return (UInt64)Offset + Size; }
+ UInt32 GetWinAttrib() const { return (UInt32)Attributes & ~(UInt32)NHeader::kFileNameIsUtf8_Mask; }
+ bool IsNameUTF() const { return (Attributes & NHeader::kFileNameIsUtf8_Mask) != 0; }
+ bool IsDir() const { return (Attributes & FILE_ATTRIBUTE_DIRECTORY) != 0; }
+
+ bool ContinuedFromPrev() const
+ {
+ return
+ FolderIndex == NHeader::NFolderIndex::kContinuedFromPrev ||
+ FolderIndex == NHeader::NFolderIndex::kContinuedPrevAndNext;
+ }
+
+ bool ContinuedToNext() const
+ {
+ return
+ FolderIndex == NHeader::NFolderIndex::kContinuedToNext ||
+ FolderIndex == NHeader::NFolderIndex::kContinuedPrevAndNext;
+ }
+
+ int GetFolderIndex(unsigned numFolders) const
+ {
+ if (ContinuedFromPrev())
+ return 0;
+ if (ContinuedToNext())
+ return (int)numFolders - 1;
+ return (int)FolderIndex;
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Cab/CabRegister.cpp b/CPP/7zip/Archive/Cab/CabRegister.cpp
new file mode 100644
index 0000000..8f4f323
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/CabRegister.cpp
@@ -0,0 +1,19 @@
+// CabRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "CabHandler.h"
+
+namespace NArchive {
+namespace NCab {
+
+REGISTER_ARC_I(
+ "Cab", "cab", NULL, 8,
+ NHeader::kMarker,
+ 0,
+ NArcInfoFlags::kFindSignature,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Cab/StdAfx.h b/CPP/7zip/Archive/Cab/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Cab/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/Chm/ChmHandler.cpp b/CPP/7zip/Archive/Chm/ChmHandler.cpp
new file mode 100644
index 0000000..38e2543
--- /dev/null
+++ b/CPP/7zip/Archive/Chm/ChmHandler.cpp
@@ -0,0 +1,800 @@
+// ChmHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+#include "../../Common/RegisterArc.h"
+
+#include "../../Compress/CopyCoder.h"
+#include "../../Compress/LzxDecoder.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "ChmHandler.h"
+
+using namespace NWindows;
+using namespace NTime;
+
+namespace NArchive {
+namespace NChm {
+
+// #define CHM_DETAILS
+
+#ifdef CHM_DETAILS
+
+enum
+{
+ kpidSection = kpidUserDefined
+};
+
+#endif
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidMethod,
+ kpidBlock
+
+ #ifdef CHM_DETAILS
+ ,
+ L"Section", kpidSection,
+ kpidOffset
+ #endif
+};
+
+/*
+static const Byte kArcProps[] =
+{
+ // kpidNumBlocks,
+};
+*/
+
+IMP_IInArchive_Props
+
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ // COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ /*
+ case kpidNumBlocks:
+ {
+ UInt64 numBlocks = 0;
+ FOR_VECTOR(i, m_Database.Sections)
+ {
+ const CSectionInfo &s = m_Database.Sections[i];
+ FOR_VECTOR(j, s.Methods)
+ {
+ const CMethodInfo &m = s.Methods[j];
+ if (m.IsLzx())
+ numBlocks += m.LzxInfo.ResetTable.GetNumBlocks();
+ }
+ }
+ prop = numBlocks;
+ break;
+ }
+ */
+ case kpidOffset: prop = m_Database.StartPosition; break;
+ case kpidPhySize: prop = m_Database.PhySize; break;
+
+ case kpidErrorFlags: prop = m_ErrorFlags; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ // COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ if (m_Database.NewFormat)
+ {
+ switch (propID)
+ {
+ case kpidSize:
+ prop = (UInt64)m_Database.NewFormatString.Len();
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ unsigned entryIndex;
+ if (m_Database.LowLevel)
+ entryIndex = index;
+ else
+ entryIndex = m_Database.Indices[index];
+
+ const CItem &item = m_Database.Items[entryIndex];
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString us;
+ // if (
+ ConvertUTF8ToUnicode(item.Name, us);
+ {
+ if (!m_Database.LowLevel)
+ {
+ if (us.Len() > 1 && us[0] == L'/')
+ us.Delete(0);
+ }
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(us);
+ prop = us;
+ }
+ break;
+ }
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: prop = item.Size; break;
+ case kpidMethod:
+ {
+ if (!item.IsDir())
+ {
+ if (item.Section == 0)
+ prop = "Copy";
+ else if (item.Section < m_Database.Sections.Size())
+ prop = m_Database.Sections[(unsigned)item.Section].GetMethodName();
+ }
+ break;
+ }
+ case kpidBlock:
+ if (m_Database.LowLevel)
+ prop = item.Section;
+ else if (item.Section != 0 && item.Section < m_Database.Sections.Size())
+ prop = m_Database.GetFolder(index);
+ break;
+
+ #ifdef CHM_DETAILS
+
+ case kpidSection: prop = (UInt32)item.Section; break;
+ case kpidOffset: prop = (UInt32)item.Offset; break;
+
+ #endif
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ try
+ {
+ CInArchive archive(_help2);
+ // CProgressImp progressImp(openArchiveCallback);
+ const HRESULT res = archive.Open(inStream, maxCheckStartPosition, m_Database);
+ if (!archive.IsArc) m_ErrorFlags |= kpv_ErrorFlags_IsNotArc;
+ if (archive.HeadersError) m_ErrorFlags |= kpv_ErrorFlags_HeadersError;
+ if (archive.UnexpectedEnd) m_ErrorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+ if (archive.UnsupportedFeature) m_ErrorFlags |= kpv_ErrorFlags_UnsupportedFeature;
+
+ RINOK(res)
+ /*
+ if (m_Database.LowLevel)
+ return S_FALSE;
+ */
+ m_Stream = inStream;
+ }
+ catch(...)
+ {
+ return S_FALSE;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ m_ErrorFlags = 0;
+ m_Database.Clear();
+ m_Stream.Release();
+ return S_OK;
+}
+
+Z7_CLASS_IMP_NOQIB_1(
+ CChmFolderOutStream
+ , ISequentialOutStream
+)
+ bool m_TestMode;
+ bool m_IsOk;
+ bool m_FileIsOpen;
+ const CFilesDatabase *m_Database;
+ CMyComPtr<IArchiveExtractCallback> m_ExtractCallback;
+ CMyComPtr<ISequentialOutStream> m_RealOutStream;
+ UInt64 m_RemainFileSize;
+
+ HRESULT OpenFile();
+ HRESULT WriteEmptyFiles();
+ HRESULT Write2(const void *data, UInt32 size, UInt32 *processedSize, bool isOK);
+public:
+
+ UInt64 m_FolderSize;
+ UInt64 m_PosInFolder;
+ UInt64 m_PosInSection;
+ const CRecordVector<bool> *m_ExtractStatuses;
+ unsigned m_StartIndex;
+ unsigned m_CurrentIndex;
+ unsigned m_NumFiles;
+
+ void Init(
+ const CFilesDatabase *database,
+ IArchiveExtractCallback *extractCallback,
+ bool testMode);
+ HRESULT FlushCorrupted(UInt64 maxSize);
+};
+
+void CChmFolderOutStream::Init(
+ const CFilesDatabase *database,
+ IArchiveExtractCallback *extractCallback,
+ bool testMode)
+{
+ m_Database = database;
+ m_ExtractCallback = extractCallback;
+ m_TestMode = testMode;
+
+ m_CurrentIndex = 0;
+ m_FileIsOpen = false;
+}
+
+HRESULT CChmFolderOutStream::OpenFile()
+{
+ Int32 askMode = (*m_ExtractStatuses)[m_CurrentIndex] ? m_TestMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract :
+ NExtract::NAskMode::kSkip;
+ m_RealOutStream.Release();
+ RINOK(m_ExtractCallback->GetStream(m_StartIndex + m_CurrentIndex, &m_RealOutStream, askMode))
+ if (!m_RealOutStream && !m_TestMode)
+ askMode = NExtract::NAskMode::kSkip;
+ return m_ExtractCallback->PrepareOperation(askMode);
+}
+
+HRESULT CChmFolderOutStream::WriteEmptyFiles()
+{
+ if (m_FileIsOpen)
+ return S_OK;
+ for (; m_CurrentIndex < m_NumFiles; m_CurrentIndex++)
+ {
+ const UInt64 fileSize = m_Database->GetFileSize(m_StartIndex + m_CurrentIndex);
+ if (fileSize != 0)
+ return S_OK;
+ const HRESULT result = OpenFile();
+ m_RealOutStream.Release();
+ RINOK(result)
+ RINOK(m_ExtractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ return S_OK;
+}
+
+// This is WritePart function
+HRESULT CChmFolderOutStream::Write2(const void *data, UInt32 size, UInt32 *processedSize, bool isOK)
+{
+ UInt32 realProcessed = 0;
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ if (m_FileIsOpen)
+ {
+ UInt32 numBytesToWrite = (UInt32)MyMin(m_RemainFileSize, (UInt64)(size));
+ HRESULT res = S_OK;
+ if (numBytesToWrite > 0)
+ {
+ if (!isOK)
+ m_IsOk = false;
+ if (m_RealOutStream)
+ {
+ UInt32 processedSizeLocal = 0;
+ res = m_RealOutStream->Write((const Byte *)data, numBytesToWrite, &processedSizeLocal);
+ numBytesToWrite = processedSizeLocal;
+ }
+ }
+ realProcessed += numBytesToWrite;
+ if (processedSize)
+ *processedSize = realProcessed;
+ data = (const void *)((const Byte *)data + numBytesToWrite);
+ size -= numBytesToWrite;
+ m_RemainFileSize -= numBytesToWrite;
+ m_PosInSection += numBytesToWrite;
+ m_PosInFolder += numBytesToWrite;
+ if (res != S_OK)
+ return res;
+ if (m_RemainFileSize == 0)
+ {
+ m_RealOutStream.Release();
+ RINOK(m_ExtractCallback->SetOperationResult(
+ m_IsOk ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError))
+ m_FileIsOpen = false;
+ }
+ if (realProcessed > 0)
+ break; // with this break this function works as write part
+ }
+ else
+ {
+ if (m_CurrentIndex >= m_NumFiles)
+ {
+ realProcessed += size;
+ if (processedSize)
+ *processedSize = realProcessed;
+ return S_OK;
+ // return E_FAIL;
+ }
+
+ unsigned fullIndex = m_StartIndex + m_CurrentIndex;
+ m_RemainFileSize = m_Database->GetFileSize(fullIndex);
+ UInt64 fileOffset = m_Database->GetFileOffset(fullIndex);
+ if (fileOffset < m_PosInSection)
+ return E_FAIL;
+
+ if (fileOffset > m_PosInSection)
+ {
+ UInt32 numBytesToWrite = (UInt32)MyMin(fileOffset - m_PosInSection, UInt64(size));
+ realProcessed += numBytesToWrite;
+ if (processedSize)
+ *processedSize = realProcessed;
+ data = (const void *)((const Byte *)data + numBytesToWrite);
+ size -= numBytesToWrite;
+ m_PosInSection += numBytesToWrite;
+ m_PosInFolder += numBytesToWrite;
+ }
+
+ if (fileOffset == m_PosInSection)
+ {
+ RINOK(OpenFile())
+ m_FileIsOpen = true;
+ m_CurrentIndex++;
+ m_IsOk = true;
+ }
+ }
+ }
+
+ return WriteEmptyFiles();
+}
+
+Z7_COM7F_IMF(CChmFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ return Write2(data, size, processedSize, true);
+}
+
+HRESULT CChmFolderOutStream::FlushCorrupted(UInt64 maxSize)
+{
+ const UInt32 kBufferSize = (1 << 10);
+ Byte buffer[kBufferSize];
+ for (unsigned i = 0; i < kBufferSize; i++)
+ buffer[i] = 0;
+ if (maxSize > m_FolderSize)
+ maxSize = m_FolderSize;
+ while (m_PosInFolder < maxSize)
+ {
+ UInt32 size = (UInt32)MyMin(maxSize - m_PosInFolder, (UInt64)kBufferSize);
+ UInt32 processedSizeLocal = 0;
+ RINOK(Write2(buffer, size, &processedSizeLocal, false))
+ if (processedSizeLocal == 0)
+ return S_OK;
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testModeSpec, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+
+ if (allFilesMode)
+ numItems = m_Database.NewFormat ? 1:
+ (m_Database.LowLevel ?
+ m_Database.Items.Size():
+ m_Database.Indices.Size());
+ if (numItems == 0)
+ return S_OK;
+ bool testMode = (testModeSpec != 0);
+
+ UInt64 currentTotalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+ UInt32 i;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(m_Stream);
+
+ if (m_Database.LowLevel)
+ {
+ UInt64 currentItemSize = 0;
+ UInt64 totalSize = 0;
+
+ if (m_Database.NewFormat)
+ totalSize = m_Database.NewFormatString.Len();
+ else
+ for (i = 0; i < numItems; i++)
+ totalSize += m_Database.Items[allFilesMode ? i : indices[i]].Size;
+
+ extractCallback->SetTotal(totalSize);
+
+ for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
+ {
+ currentItemSize = 0;
+ lps->InSize = currentTotalSize; // Change it
+ lps->OutSize = currentTotalSize;
+
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode= testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (m_Database.NewFormat)
+ {
+ if (index != 0)
+ return E_FAIL;
+ if (!testMode && !realOutStream)
+ continue;
+ if (!testMode)
+ {
+ UInt32 size = m_Database.NewFormatString.Len();
+ RINOK(WriteStream(realOutStream, (const char *)m_Database.NewFormatString, size))
+ }
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const CItem &item = m_Database.Items[index];
+
+ currentItemSize = item.Size;
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (item.Section != 0)
+ {
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ continue;
+ }
+
+ if (testMode)
+ {
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ RINOK(InStream_SeekSet(m_Stream, m_Database.ContentOffset + item.Offset))
+ streamSpec->Init(item.Size);
+
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult((copyCoderSpec->TotalSize == item.Size) ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ }
+
+ UInt64 lastFolderIndex = ((UInt64)0 - 1);
+
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = m_Database.Items[m_Database.Indices[index]];
+ const UInt64 sectionIndex = item.Section;
+ if (item.IsDir() || item.Size == 0)
+ continue;
+ if (sectionIndex == 0)
+ {
+ currentTotalSize += item.Size;
+ continue;
+ }
+
+ if (sectionIndex >= m_Database.Sections.Size())
+ continue;
+
+ const CSectionInfo §ion = m_Database.Sections[(unsigned)sectionIndex];
+ if (section.IsLzx())
+ {
+ const CLzxInfo &lzxInfo = section.Methods[0].LzxInfo;
+ UInt64 folderIndex = m_Database.GetFolder(index);
+ if (lastFolderIndex == folderIndex)
+ folderIndex++;
+ lastFolderIndex = m_Database.GetLastFolder(index);
+ for (; folderIndex <= lastFolderIndex; folderIndex++)
+ currentTotalSize += lzxInfo.GetFolderSize();
+ }
+ }
+
+ RINOK(extractCallback->SetTotal(currentTotalSize))
+
+ NCompress::NLzx::CDecoder *lzxDecoderSpec = NULL;
+ CMyComPtr<IUnknown> lzxDecoder;
+ CChmFolderOutStream *chmFolderOutStream = NULL;
+ CMyComPtr<ISequentialOutStream> outStream;
+
+ currentTotalSize = 0;
+
+ CRecordVector<bool> extractStatuses;
+
+ CByteBuffer packBuf;
+
+ for (i = 0;;)
+ {
+ RINOK(extractCallback->SetCompleted(¤tTotalSize))
+
+ if (i >= numItems)
+ break;
+
+ UInt32 index = allFilesMode ? i : indices[i];
+ i++;
+ const CItem &item = m_Database.Items[m_Database.Indices[index]];
+ const UInt64 sectionIndex = item.Section;
+ Int32 askMode= testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ if (item.IsDir())
+ {
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ lps->InSize = currentTotalSize; // Change it
+ lps->OutSize = currentTotalSize;
+
+ if (item.Size == 0 || sectionIndex == 0)
+ {
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ Int32 opRes = NExtract::NOperationResult::kOK;
+ if (!testMode && item.Size != 0)
+ {
+ RINOK(InStream_SeekSet(m_Stream, m_Database.ContentOffset + item.Offset))
+ streamSpec->Init(item.Size);
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize != item.Size)
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ currentTotalSize += item.Size;
+ continue;
+ }
+
+ if (sectionIndex >= m_Database.Sections.Size())
+ {
+ // we must report error here;
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kHeadersError))
+ continue;
+ }
+
+ const CSectionInfo §ion = m_Database.Sections[(unsigned)sectionIndex];
+
+ if (!section.IsLzx())
+ {
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ continue;
+ }
+
+ const CLzxInfo &lzxInfo = section.Methods[0].LzxInfo;
+
+ if (!chmFolderOutStream)
+ {
+ chmFolderOutStream = new CChmFolderOutStream;
+ outStream = chmFolderOutStream;
+ }
+
+ chmFolderOutStream->Init(&m_Database, extractCallback, testMode);
+
+ if (!lzxDecoderSpec)
+ {
+ lzxDecoderSpec = new NCompress::NLzx::CDecoder;
+ lzxDecoder = lzxDecoderSpec;
+ }
+
+ UInt64 folderIndex = m_Database.GetFolder(index);
+
+ const UInt64 compressedPos = m_Database.ContentOffset + section.Offset;
+ RINOK(lzxDecoderSpec->SetParams_and_Alloc(lzxInfo.GetNumDictBits()))
+
+ const CItem *lastItem = &item;
+ extractStatuses.Clear();
+ extractStatuses.Add(true);
+
+ for (;; folderIndex++)
+ {
+ RINOK(extractCallback->SetCompleted(¤tTotalSize))
+
+ UInt64 startPos = lzxInfo.GetFolderPos(folderIndex);
+ UInt64 finishPos = lastItem->Offset + lastItem->Size;
+ UInt64 limitFolderIndex = lzxInfo.GetFolder(finishPos);
+
+ lastFolderIndex = m_Database.GetLastFolder(index);
+ UInt64 folderSize = lzxInfo.GetFolderSize();
+ UInt64 unPackSize = folderSize;
+
+ if (extractStatuses.IsEmpty())
+ chmFolderOutStream->m_StartIndex = index + 1;
+ else
+ chmFolderOutStream->m_StartIndex = index;
+
+ if (limitFolderIndex == folderIndex)
+ {
+ for (; i < numItems; i++)
+ {
+ const UInt32 nextIndex = allFilesMode ? i : indices[i];
+ const CItem &nextItem = m_Database.Items[m_Database.Indices[nextIndex]];
+ if (nextItem.Section != sectionIndex)
+ break;
+ const UInt64 nextFolderIndex = m_Database.GetFolder(nextIndex);
+ if (nextFolderIndex != folderIndex)
+ break;
+ for (index++; index < nextIndex; index++)
+ extractStatuses.Add(false);
+ extractStatuses.Add(true);
+ index = nextIndex;
+ lastItem = &nextItem;
+ if (nextItem.Size != 0)
+ finishPos = nextItem.Offset + nextItem.Size;
+ lastFolderIndex = m_Database.GetLastFolder(index);
+ }
+ }
+
+ unPackSize = MyMin(finishPos - startPos, unPackSize);
+
+ chmFolderOutStream->m_FolderSize = folderSize;
+ chmFolderOutStream->m_PosInFolder = 0;
+ chmFolderOutStream->m_PosInSection = startPos;
+ chmFolderOutStream->m_ExtractStatuses = &extractStatuses;
+ chmFolderOutStream->m_NumFiles = extractStatuses.Size();
+ chmFolderOutStream->m_CurrentIndex = 0;
+
+ try
+ {
+ UInt64 startBlock = lzxInfo.GetBlockIndexFromFolderIndex(folderIndex);
+ const CResetTable &rt = lzxInfo.ResetTable;
+ UInt32 numBlocks = (UInt32)rt.GetNumBlocks(unPackSize);
+
+ for (UInt32 b = 0; b < numBlocks; b++)
+ {
+ UInt64 completedSize = currentTotalSize + chmFolderOutStream->m_PosInSection - startPos;
+ RINOK(extractCallback->SetCompleted(&completedSize))
+ UInt64 bCur = startBlock + b;
+ if (bCur >= rt.ResetOffsets.Size())
+ return E_FAIL;
+ UInt64 offset = rt.ResetOffsets[(unsigned)bCur];
+ UInt64 compressedSize;
+ rt.GetCompressedSizeOfBlock(bCur, compressedSize);
+
+ // chm writes full blocks. So we don't need to use reduced size for last block
+
+ RINOK(InStream_SeekSet(m_Stream, compressedPos + offset))
+ streamSpec->SetStream(m_Stream);
+ streamSpec->Init(compressedSize);
+
+ lzxDecoderSpec->SetKeepHistory(b > 0);
+
+ size_t compressedSizeT = (size_t)compressedSize;
+ if (compressedSizeT != compressedSize)
+ throw 2;
+ packBuf.AllocAtLeast(compressedSizeT);
+
+ HRESULT res = ReadStream_FALSE(inStream, packBuf, compressedSizeT);
+
+ if (res == S_OK)
+ {
+ lzxDecoderSpec->KeepHistoryForNext = true;
+ res = lzxDecoderSpec->Code(packBuf, compressedSizeT, kBlockSize); // rt.BlockSize;
+ if (res == S_OK)
+ res = WriteStream(chmFolderOutStream,
+ lzxDecoderSpec->GetUnpackData(),
+ lzxDecoderSpec->GetUnpackSize());
+ }
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ throw 1;
+ }
+ }
+ }
+ catch(...)
+ {
+ RINOK(chmFolderOutStream->FlushCorrupted(unPackSize))
+ }
+
+ currentTotalSize += folderSize;
+ if (folderIndex == lastFolderIndex)
+ break;
+ extractStatuses.Clear();
+ }
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = m_Database.NewFormat ? 1:
+ (m_Database.LowLevel ?
+ m_Database.Items.Size():
+ m_Database.Indices.Size());
+ return S_OK;
+}
+
+namespace NChm {
+
+static const Byte k_Signature[] = { 'I', 'T', 'S', 'F', 3, 0, 0, 0, 0x60, 0, 0, 0 };
+
+REGISTER_ARC_I_CLS(
+ CHandler(false),
+ "Chm", "chm chi chq chw", NULL, 0xE9,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}
+
+namespace NHxs {
+
+static const Byte k_Signature[] = { 'I', 'T', 'O', 'L', 'I', 'T', 'L', 'S', 1, 0, 0, 0, 0x28, 0, 0, 0 };
+
+REGISTER_ARC_I_CLS(
+ CHandler(true),
+ "Hxs", "hxs hxi hxr hxq hxw lit", NULL, 0xCE,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kFindSignature,
+ NULL)
+
+}
+
+}}
diff --git a/CPP/7zip/Archive/Chm/ChmHandler.h b/CPP/7zip/Archive/Chm/ChmHandler.h
new file mode 100644
index 0000000..94821b2
--- /dev/null
+++ b/CPP/7zip/Archive/Chm/ChmHandler.h
@@ -0,0 +1,27 @@
+// ChmHandler.h
+
+#ifndef ZIP7_INC_ARCHIVE_CHM_HANDLER_H
+#define ZIP7_INC_ARCHIVE_CHM_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../IArchive.h"
+
+#include "ChmIn.h"
+
+namespace NArchive {
+namespace NChm {
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ CFilesDatabase m_Database;
+ CMyComPtr<IInStream> m_Stream;
+ bool _help2;
+ UInt32 m_ErrorFlags;
+public:
+ CHandler(bool help2): _help2(help2) {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Chm/ChmIn.cpp b/CPP/7zip/Archive/Chm/ChmIn.cpp
new file mode 100644
index 0000000..28d512d
--- /dev/null
+++ b/CPP/7zip/Archive/Chm/ChmIn.cpp
@@ -0,0 +1,1018 @@
+// Archive/ChmIn.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/StreamUtils.h"
+
+#include "ChmIn.h"
+
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+namespace NArchive {
+namespace NChm {
+
+static const UInt32 kSignature_ITSP = 0x50535449;
+static const UInt32 kSignature_PMGL = 0x4C474D50;
+static const UInt32 kSignature_LZXC = 0x43585A4C;
+
+static const UInt32 kSignature_IFCM = 0x4D434649;
+static const UInt32 kSignature_AOLL = 0x4C4C4F41;
+static const UInt32 kSignature_CAOL = 0x4C4F4143;
+
+static const UInt32 kSignature_ITSF = 0x46535449;
+static const UInt32 kSignature_ITOL = 0x4C4F5449;
+static const UInt32 kSignature_ITLS = 0x534C5449;
+
+struct CEnexpectedEndException {};
+struct CHeaderErrorException {};
+
+// define CHM_LOW, if you want to see low level items
+// #define CHM_LOW
+
+static const Byte kChmLzxGuid[16] = { 0x40, 0x89, 0xC2, 0x7F, 0x31, 0x9D, 0xD0, 0x11, 0x9B, 0x27, 0x00, 0xA0, 0xC9, 0x1E, 0x9C, 0x7C };
+static const Byte kHelp2LzxGuid[16] = { 0xC6, 0x07, 0x90, 0x0A, 0x76, 0x40, 0xD3, 0x11, 0x87, 0x89, 0x00, 0x00, 0xF8, 0x10, 0x57, 0x54 };
+static const Byte kDesGuid[16] = { 0xA2, 0xE4, 0xF6, 0x67, 0xBF, 0x60, 0xD3, 0x11, 0x85, 0x40, 0x00, 0xC0, 0x4F, 0x58, 0xC3, 0xCF };
+
+static bool inline AreGuidsEqual(const Byte *g1, const Byte *g2)
+{
+ return memcmp(g1, g2, 16) == 0;
+}
+
+static char GetHex(unsigned v)
+{
+ return (char)((v < 10) ? ('0' + v) : ('A' + (v - 10)));
+}
+
+static void PrintByte(Byte b, AString &s)
+{
+ s += GetHex(b >> 4);
+ s += GetHex(b & 0xF);
+}
+
+AString CMethodInfo::GetGuidString() const
+{
+ char s[48];
+ RawLeGuidToString_Braced(Guid, s);
+ // MyStringUpper_Ascii(s);
+ return (AString)s;
+}
+
+bool CMethodInfo::IsLzx() const
+{
+ if (AreGuidsEqual(Guid, kChmLzxGuid))
+ return true;
+ return AreGuidsEqual(Guid, kHelp2LzxGuid);
+}
+
+bool CMethodInfo::IsDes() const
+{
+ return AreGuidsEqual(Guid, kDesGuid);
+}
+
+AString CMethodInfo::GetName() const
+{
+ AString s;
+ if (IsLzx())
+ {
+ s = "LZX:";
+ s.Add_UInt32(LzxInfo.GetNumDictBits());
+ }
+ else
+ {
+ if (IsDes())
+ s = "DES";
+ else
+ {
+ s = GetGuidString();
+ if (ControlData.Size() > 0)
+ {
+ s += ':';
+ for (size_t i = 0; i < ControlData.Size(); i++)
+ PrintByte(ControlData[i], s);
+ }
+ }
+ }
+ return s;
+}
+
+bool CSectionInfo::IsLzx() const
+{
+ if (Methods.Size() != 1)
+ return false;
+ return Methods[0].IsLzx();
+}
+
+UString CSectionInfo::GetMethodName() const
+{
+ UString s;
+ if (!IsLzx())
+ {
+ UString temp;
+ ConvertUTF8ToUnicode(Name, temp);
+ s += temp;
+ s += ": ";
+ }
+ FOR_VECTOR (i, Methods)
+ {
+ if (i != 0)
+ s.Add_Space();
+ s += Methods[i].GetName();
+ }
+ return s;
+}
+
+Byte CInArchive::ReadByte()
+{
+ Byte b;
+ if (!_inBuffer.ReadByte(b))
+ throw CEnexpectedEndException();
+ return b;
+}
+
+void CInArchive::Skip(size_t size)
+{
+ if (_inBuffer.Skip(size) != size)
+ throw CEnexpectedEndException();
+}
+
+void CInArchive::ReadBytes(Byte *data, UInt32 size)
+{
+ if (_inBuffer.ReadBytes(data, size) != size)
+ throw CEnexpectedEndException();
+}
+
+UInt16 CInArchive::ReadUInt16()
+{
+ Byte b0, b1;
+ if (!_inBuffer.ReadByte(b0)) throw CEnexpectedEndException();
+ if (!_inBuffer.ReadByte(b1)) throw CEnexpectedEndException();
+ return (UInt16)(((UInt16)b1 << 8) | b0);
+}
+
+UInt32 CInArchive::ReadUInt32()
+{
+ Byte p[4];
+ ReadBytes(p, 4);
+ return Get32(p);
+}
+
+UInt64 CInArchive::ReadUInt64()
+{
+ Byte p[8];
+ ReadBytes(p, 8);
+ return Get64(p);
+}
+
+UInt64 CInArchive::ReadEncInt()
+{
+ UInt64 val = 0;
+ for (int i = 0; i < 9; i++)
+ {
+ Byte b = ReadByte();
+ val |= (b & 0x7F);
+ if (b < 0x80)
+ return val;
+ val <<= 7;
+ }
+ throw CHeaderErrorException();
+}
+
+void CInArchive::ReadGUID(Byte *g)
+{
+ ReadBytes(g, 16);
+}
+
+void CInArchive::ReadString(unsigned size, AString &s)
+{
+ s.Empty();
+ if (size != 0)
+ {
+ ReadBytes((Byte *)s.GetBuf(size), size);
+ s.ReleaseBuf_CalcLen(size);
+ }
+}
+
+void CInArchive::ReadUString(unsigned size, UString &s)
+{
+ s.Empty();
+ while (size-- != 0)
+ {
+ wchar_t c = ReadUInt16();
+ if (c == 0)
+ {
+ Skip(2 * size);
+ return;
+ }
+ s += c;
+ }
+}
+
+HRESULT CInArchive::ReadChunk(IInStream *inStream, UInt64 pos, UInt64 size)
+{
+ RINOK(InStream_SeekSet(inStream, pos))
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> limitedStream(streamSpec);
+ streamSpec->SetStream(inStream);
+ streamSpec->Init(size);
+ m_InStreamRef = limitedStream;
+ _inBuffer.SetStream(limitedStream);
+ _inBuffer.Init();
+ return S_OK;
+}
+
+HRESULT CInArchive::ReadDirEntry(CDatabase &database)
+{
+ CItem item;
+ UInt64 nameLen = ReadEncInt();
+ if (nameLen == 0 || nameLen > (1 << 13))
+ return S_FALSE;
+ ReadString((unsigned)nameLen, item.Name);
+ item.Section = ReadEncInt();
+ item.Offset = ReadEncInt();
+ item.Size = ReadEncInt();
+ database.Items.Add(item);
+ return S_OK;
+}
+
+HRESULT CInArchive::OpenChm(IInStream *inStream, CDatabase &database)
+{
+ UInt32 headerSize = ReadUInt32();
+ if (headerSize != 0x60)
+ return S_FALSE;
+ database.PhySize = headerSize;
+
+ UInt32 unknown1 = ReadUInt32();
+ if (unknown1 != 0 && unknown1 != 1) // it's 0 in one .sll file
+ return S_FALSE;
+
+ IsArc = true;
+
+ /* UInt32 timeStamp = */ ReadUInt32();
+ // Considered as a big-endian DWORD, it appears to contain seconds (MSB) and
+ // fractional seconds (second byte).
+ // The third and fourth bytes may contain even more fractional bits.
+ // The 4 least significant bits in the last byte are constant.
+ /* UInt32 lang = */ ReadUInt32();
+ Byte g[16];
+ ReadGUID(g); // {7C01FD10-7BAA-11D0-9E0C-00A0-C922-E6EC}
+ ReadGUID(g); // {7C01FD11-7BAA-11D0-9E0C-00A0-C922-E6EC}
+ const unsigned kNumSections = 2;
+ UInt64 sectionOffsets[kNumSections];
+ UInt64 sectionSizes[kNumSections];
+ unsigned i;
+ for (i = 0; i < kNumSections; i++)
+ {
+ sectionOffsets[i] = ReadUInt64();
+ sectionSizes[i] = ReadUInt64();
+ UInt64 end = sectionOffsets[i] + sectionSizes[i];
+ database.UpdatePhySize(end);
+ }
+ // if (chmVersion == 3)
+ database.ContentOffset = ReadUInt64();
+ /*
+ else
+ database.ContentOffset = database.StartPosition + 0x58
+ */
+
+ // Section 0
+ ReadChunk(inStream, sectionOffsets[0], sectionSizes[0]);
+ if (sectionSizes[0] < 0x18)
+ return S_FALSE;
+ if (ReadUInt32() != 0x01FE)
+ return S_FALSE;
+ ReadUInt32(); // unknown: 0
+ UInt64 fileSize = ReadUInt64();
+ database.UpdatePhySize(fileSize);
+ ReadUInt32(); // unknown: 0
+ ReadUInt32(); // unknown: 0
+
+ // Section 1: The Directory Listing
+ ReadChunk(inStream, sectionOffsets[1], sectionSizes[1]);
+ if (ReadUInt32() != kSignature_ITSP)
+ return S_FALSE;
+ if (ReadUInt32() != 1) // version
+ return S_FALSE;
+ /* UInt32 dirHeaderSize = */ ReadUInt32();
+ ReadUInt32(); // 0x0A (unknown)
+ UInt32 dirChunkSize = ReadUInt32(); // $1000
+ if (dirChunkSize < 32)
+ return S_FALSE;
+ /* UInt32 density = */ ReadUInt32(); // "Density" of quickref section, usually 2.
+ /* UInt32 depth = */ ReadUInt32(); // Depth of the index tree: 1 there is no index,
+ // 2 if there is one level of PMGI chunks.
+
+ /* UInt32 chunkNumber = */ ReadUInt32(); // Chunk number of root index chunk, -1 if there is none
+ // (though at least one file has 0 despite there being no
+ // index chunk, probably a bug.)
+ /* UInt32 firstPmglChunkNumber = */ ReadUInt32(); // Chunk number of first PMGL (listing) chunk
+ /* UInt32 lastPmglChunkNumber = */ ReadUInt32(); // Chunk number of last PMGL (listing) chunk
+ ReadUInt32(); // -1 (unknown)
+ UInt32 numDirChunks = ReadUInt32(); // Number of directory chunks (total)
+ /* UInt32 windowsLangId = */ ReadUInt32();
+ ReadGUID(g); // {5D02926A-212E-11D0-9DF9-00A0C922E6EC}
+ ReadUInt32(); // 0x54 (This is the length again)
+ ReadUInt32(); // -1 (unknown)
+ ReadUInt32(); // -1 (unknown)
+ ReadUInt32(); // -1 (unknown)
+
+ for (UInt32 ci = 0; ci < numDirChunks; ci++)
+ {
+ UInt64 chunkPos = _inBuffer.GetProcessedSize();
+ if (ReadUInt32() == kSignature_PMGL)
+ {
+ // The quickref area is written backwards from the end of the chunk.
+ // One quickref entry exists for every n entries in the file, where n
+ // is calculated as 1 + (1 << quickref density). So for density = 2, n = 5.
+
+ UInt32 quickrefLength = ReadUInt32(); // Len of free space and/or quickref area at end of directory chunk
+ if (quickrefLength > dirChunkSize || quickrefLength < 2)
+ return S_FALSE;
+ ReadUInt32(); // Always 0
+ ReadUInt32(); // Chunk number of previous listing chunk when reading
+ // directory in sequence (-1 if this is the first listing chunk)
+ ReadUInt32(); // Chunk number of next listing chunk when reading
+ // directory in sequence (-1 if this is the last listing chunk)
+ unsigned numItems = 0;
+
+ for (;;)
+ {
+ UInt64 offset = _inBuffer.GetProcessedSize() - chunkPos;
+ UInt32 offsetLimit = dirChunkSize - quickrefLength;
+ if (offset > offsetLimit)
+ return S_FALSE;
+ if (offset == offsetLimit)
+ break;
+ RINOK(ReadDirEntry(database))
+ numItems++;
+ }
+
+ Skip(quickrefLength - 2);
+
+ unsigned rrr = ReadUInt16();
+ if (rrr != numItems)
+ {
+ // Lazarus 9-26-2 chm contains 0 here.
+ if (rrr != 0)
+ return S_FALSE;
+ }
+ }
+ else
+ Skip(dirChunkSize - 4);
+ }
+ return S_OK;
+}
+
+HRESULT CInArchive::OpenHelp2(IInStream *inStream, CDatabase &database)
+{
+ if (ReadUInt32() != 1) // version
+ return S_FALSE;
+ if (ReadUInt32() != 0x28) // Location of header section table
+ return S_FALSE;
+ UInt32 numHeaderSections = ReadUInt32();
+ const unsigned kNumHeaderSectionsMax = 5;
+ if (numHeaderSections != kNumHeaderSectionsMax)
+ return S_FALSE;
+
+ IsArc = true;
+
+ ReadUInt32(); // Len of post-header table
+ Byte g[16];
+ ReadGUID(g); // {0A9007C1-4076-11D3-8789-0000F8105754}
+
+ // header section table
+ UInt64 sectionOffsets[kNumHeaderSectionsMax];
+ UInt64 sectionSizes[kNumHeaderSectionsMax];
+ UInt32 i;
+ for (i = 0; i < numHeaderSections; i++)
+ {
+ sectionOffsets[i] = ReadUInt64();
+ sectionSizes[i] = ReadUInt64();
+ UInt64 end = sectionOffsets[i] + sectionSizes[i];
+ database.UpdatePhySize(end);
+ }
+
+ // Post-Header
+ ReadUInt32(); // 2
+ ReadUInt32(); // 0x98: offset to CAOL from beginning of post-header)
+ // ----- Directory information
+ ReadUInt64(); // Chunk number of top-level AOLI chunk in directory, or -1
+ ReadUInt64(); // Chunk number of first AOLL chunk in directory
+ ReadUInt64(); // Chunk number of last AOLL chunk in directory
+ ReadUInt64(); // 0 (unknown)
+ ReadUInt32(); // $2000 (Directory chunk size of directory)
+ ReadUInt32(); // Quickref density for main directory, usually 2
+ ReadUInt32(); // 0 (unknown)
+ ReadUInt32(); // Depth of main directory index tree
+ // 1 there is no index, 2 if there is one level of AOLI chunks.
+ ReadUInt64(); // 0 (unknown)
+ UInt64 numDirEntries = ReadUInt64(); // Number of directory entries
+ // ----- Directory Index Information
+ ReadUInt64(); // -1 (unknown, probably chunk number of top-level AOLI in directory index)
+ ReadUInt64(); // Chunk number of first AOLL chunk in directory index
+ ReadUInt64(); // Chunk number of last AOLL chunk in directory index
+ ReadUInt64(); // 0 (unknown)
+ ReadUInt32(); // $200 (Directory chunk size of directory index)
+ ReadUInt32(); // Quickref density for directory index, usually 2
+ ReadUInt32(); // 0 (unknown)
+ ReadUInt32(); // Depth of directory index index tree.
+ ReadUInt64(); // Possibly flags -- sometimes 1, sometimes 0.
+ ReadUInt64(); // Number of directory index entries (same as number of AOLL
+ // chunks in main directory)
+
+ // (The obvious guess for the following two fields, which recur in a number
+ // of places, is they are maximum sizes for the directory and directory index.
+ // However, I have seen no direct evidence that this is the case.)
+
+ ReadUInt32(); // $100000 (Same as field following chunk size in directory)
+ ReadUInt32(); // $20000 (Same as field following chunk size in directory index)
+
+ ReadUInt64(); // 0 (unknown)
+ if (ReadUInt32() != kSignature_CAOL)
+ return S_FALSE;
+ if (ReadUInt32() != 2) // (Most likely a version number)
+ return S_FALSE;
+ UInt32 caolLength = ReadUInt32(); // $50 (Len of the CAOL section, which includes the ITSF section)
+ if (caolLength >= 0x2C)
+ {
+ /* UInt32 c7 = */ ReadUInt16(); // Unknown. Remains the same when identical files are built.
+ // Does not appear to be a checksum. Many files have
+ // 'HH' (HTML Help?) here, indicating this may be a compiler ID
+ // field. But at least one ITOL/ITLS compiler does not set this
+ // field to a constant value.
+ ReadUInt16(); // 0 (Unknown. Possibly part of 00A4 field)
+ ReadUInt32(); // Unknown. Two values have been seen -- $43ED, and 0.
+ ReadUInt32(); // $2000 (Directory chunk size of directory)
+ ReadUInt32(); // $200 (Directory chunk size of directory index)
+ ReadUInt32(); // $100000 (Same as field following chunk size in directory)
+ ReadUInt32(); // $20000 (Same as field following chunk size in directory index)
+ ReadUInt32(); // 0 (unknown)
+ ReadUInt32(); // 0 (Unknown)
+ if (caolLength == 0x2C)
+ {
+ // fprintf(stdout, "\n !!!NewFormat\n");
+ // fflush(stdout);
+ database.ContentOffset = 0; // maybe we must add database.StartPosition here?
+ database.NewFormat = true;
+ }
+ else if (caolLength == 0x50)
+ {
+ ReadUInt32(); // 0 (Unknown)
+ if (ReadUInt32() != kSignature_ITSF)
+ return S_FALSE;
+ if (ReadUInt32() != 4) // $4 (Version number -- CHM uses 3)
+ return S_FALSE;
+ if (ReadUInt32() != 0x20) // $20 (length of ITSF)
+ return S_FALSE;
+ UInt32 unknown = ReadUInt32();
+ if (unknown != 0 && unknown != 1) // = 0 for some HxW files, 1 in other cases;
+ return S_FALSE;
+ database.ContentOffset = database.StartPosition + ReadUInt64();
+ /* UInt32 timeStamp = */ ReadUInt32();
+ // A timestamp of some sort.
+ // Considered as a big-endian DWORD, it appears to contain
+ // seconds (MSB) and fractional seconds (second byte).
+ // The third and fourth bytes may contain even more fractional
+ // bits. The 4 least significant bits in the last byte are constant.
+ /* UInt32 lang = */ ReadUInt32(); // BE?
+ }
+ else
+ return S_FALSE;
+ }
+
+ // Section 0
+ ReadChunk(inStream, database.StartPosition + sectionOffsets[0], sectionSizes[0]);
+ if (sectionSizes[0] < 0x18)
+ return S_FALSE;
+ if (ReadUInt32() != 0x01FE)
+ return S_FALSE;
+ ReadUInt32(); // unknown: 0
+ UInt64 fileSize = ReadUInt64();
+ database.UpdatePhySize(fileSize);
+ ReadUInt32(); // unknown: 0
+ ReadUInt32(); // unknown: 0
+
+ // Section 1: The Directory Listing
+ ReadChunk(inStream, database.StartPosition + sectionOffsets[1], sectionSizes[1]);
+ if (ReadUInt32() != kSignature_IFCM)
+ return S_FALSE;
+ if (ReadUInt32() != 1) // (probably a version number)
+ return S_FALSE;
+ UInt32 dirChunkSize = ReadUInt32(); // $2000
+ if (dirChunkSize < 64)
+ return S_FALSE;
+ ReadUInt32(); // $100000 (unknown)
+ ReadUInt32(); // -1 (unknown)
+ ReadUInt32(); // -1 (unknown)
+ UInt32 numDirChunks = ReadUInt32();
+ ReadUInt32(); // 0 (unknown, probably high word of above)
+
+ for (UInt32 ci = 0; ci < numDirChunks; ci++)
+ {
+ UInt64 chunkPos = _inBuffer.GetProcessedSize();
+ if (ReadUInt32() == kSignature_AOLL)
+ {
+ UInt32 quickrefLength = ReadUInt32(); // Len of quickref area at end of directory chunk
+ if (quickrefLength > dirChunkSize || quickrefLength < 2)
+ return S_FALSE;
+ ReadUInt64(); // Directory chunk number
+ // This must match physical position in file, that is
+ // the chunk size times the chunk number must be the
+ // offset from the end of the directory header.
+ ReadUInt64(); // Chunk number of previous listing chunk when reading
+ // directory in sequence (-1 if first listing chunk)
+ ReadUInt64(); // Chunk number of next listing chunk when reading
+ // directory in sequence (-1 if last listing chunk)
+ ReadUInt64(); // Number of first listing entry in this chunk
+ ReadUInt32(); // 1 (unknown -- other values have also been seen here)
+ ReadUInt32(); // 0 (unknown)
+
+ unsigned numItems = 0;
+ for (;;)
+ {
+ UInt64 offset = _inBuffer.GetProcessedSize() - chunkPos;
+ UInt32 offsetLimit = dirChunkSize - quickrefLength;
+ if (offset > offsetLimit)
+ return S_FALSE;
+ if (offset == offsetLimit)
+ break;
+ if (database.NewFormat)
+ {
+ UInt16 nameLen = ReadUInt16();
+ if (nameLen == 0)
+ return S_FALSE;
+ UString name;
+ ReadUString((unsigned)nameLen, name);
+ AString s;
+ ConvertUnicodeToUTF8(name, s);
+ Byte b = ReadByte();
+ s.Add_Space();
+ PrintByte(b, s);
+ s.Add_Space();
+ UInt64 len = ReadEncInt();
+ // then number of items ?
+ // then length ?
+ // then some data (binary encoding?)
+ while (len-- != 0)
+ {
+ b = ReadByte();
+ PrintByte(b, s);
+ }
+ database.NewFormatString += s;
+ database.NewFormatString += "\r\n";
+ }
+ else
+ {
+ RINOK(ReadDirEntry(database))
+ }
+ numItems++;
+ }
+ Skip(quickrefLength - 2);
+ if (ReadUInt16() != numItems)
+ return S_FALSE;
+ if (numItems > numDirEntries)
+ return S_FALSE;
+ numDirEntries -= numItems;
+ }
+ else
+ Skip(dirChunkSize - 4);
+ }
+ return numDirEntries == 0 ? S_OK : S_FALSE;
+}
+
+HRESULT CInArchive::DecompressStream(IInStream *inStream, const CDatabase &database, const AString &name)
+{
+ int index = database.FindItem(name);
+ if (index < 0)
+ return S_FALSE;
+ const CItem &item = database.Items[index];
+ _chunkSize = item.Size;
+ return ReadChunk(inStream, database.ContentOffset + item.Offset, item.Size);
+}
+
+
+#define DATA_SPACE "::DataSpace/"
+#define kNameList DATA_SPACE "NameList"
+#define kStorage DATA_SPACE "Storage/"
+#define kContent "Content"
+#define kControlData "ControlData"
+#define kSpanInfo "SpanInfo"
+#define kTransform "Transform/"
+#define kResetTable "/InstanceData/ResetTable"
+#define kTransformList "List"
+
+static AString GetSectionPrefix(const AString &name)
+{
+ AString s (kStorage);
+ s += name;
+ s += '/';
+ return s;
+}
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+static int CompareFiles(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const CObjectVector<CItem> &items = *(const CObjectVector<CItem> *)param;
+ const CItem &item1 = items[*p1];
+ const CItem &item2 = items[*p2];
+ bool isDir1 = item1.IsDir();
+ bool isDir2 = item2.IsDir();
+ if (isDir1 && !isDir2)
+ return -1;
+ if (isDir2)
+ {
+ if (!isDir1)
+ return 1;
+ }
+ else
+ {
+ RINOZ(MyCompare(item1.Section, item2.Section))
+ RINOZ(MyCompare(item1.Offset, item2.Offset))
+ RINOZ(MyCompare(item1.Size, item2.Size))
+ }
+ return MyCompare(*p1, *p2);
+}
+
+void CFilesDatabase::SetIndices()
+{
+ FOR_VECTOR (i, Items)
+ {
+ const CItem &item = Items[i];
+ if (item.IsUserItem() && item.Name.Len() != 1)
+ Indices.Add(i);
+ }
+}
+
+void CFilesDatabase::Sort()
+{
+ Indices.Sort(CompareFiles, (void *)&Items);
+}
+
+bool CFilesDatabase::Check()
+{
+ UInt64 maxPos = 0;
+ UInt64 prevSection = 0;
+ FOR_VECTOR (i, Indices)
+ {
+ const CItem &item = Items[Indices[i]];
+ if (item.Section == 0 || item.IsDir())
+ continue;
+ if (item.Section != prevSection)
+ {
+ prevSection = item.Section;
+ maxPos = 0;
+ continue;
+ }
+ if (item.Offset < maxPos)
+ return false;
+ maxPos = item.Offset + item.Size;
+ if (maxPos < item.Offset)
+ return false;
+ }
+ return true;
+}
+
+bool CFilesDatabase::CheckSectionRefs()
+{
+ FOR_VECTOR (i, Indices)
+ {
+ const CItem &item = Items[Indices[i]];
+ if (item.Section == 0 || item.IsDir())
+ continue;
+ if (item.Section >= Sections.Size())
+ return false;
+ }
+ return true;
+}
+
+static int inline GetLog(UInt32 num)
+{
+ for (int i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == num)
+ return i;
+ return -1;
+}
+
+HRESULT CInArchive::OpenHighLevel(IInStream *inStream, CFilesDatabase &database)
+{
+ {
+ // The NameList file
+ RINOK(DecompressStream(inStream, database, (AString)kNameList))
+ /* UInt16 length = */ ReadUInt16();
+ UInt16 numSections = ReadUInt16();
+ for (unsigned i = 0; i < numSections; i++)
+ {
+ CSectionInfo section;
+ UInt16 nameLen = ReadUInt16();
+ UString name;
+ ReadUString(nameLen, name);
+ if (ReadUInt16() != 0)
+ return S_FALSE;
+ ConvertUnicodeToUTF8(name, section.Name);
+ // if (!ConvertUnicodeToUTF8(name, section.Name)) return S_FALSE;
+ database.Sections.Add(section);
+ }
+ }
+
+ unsigned si;
+ for (si = 1; si < database.Sections.Size(); si++)
+ {
+ CSectionInfo §ion = database.Sections[si];
+ AString sectionPrefix (GetSectionPrefix(section.Name));
+ {
+ // Content
+ int index = database.FindItem(sectionPrefix + kContent);
+ if (index < 0)
+ return S_FALSE;
+ const CItem &item = database.Items[index];
+ section.Offset = item.Offset;
+ section.CompressedSize = item.Size;
+ }
+ AString transformPrefix (sectionPrefix + kTransform);
+ if (database.Help2Format)
+ {
+ // Transform List
+ RINOK(DecompressStream(inStream, database, transformPrefix + kTransformList))
+ if ((_chunkSize & 0xF) != 0)
+ return S_FALSE;
+ unsigned numGuids = (unsigned)(_chunkSize / 0x10);
+ if (numGuids < 1)
+ return S_FALSE;
+ for (unsigned i = 0; i < numGuids; i++)
+ {
+ CMethodInfo method;
+ ReadGUID(method.Guid);
+ section.Methods.Add(method);
+ }
+ }
+ else
+ {
+ CMethodInfo method;
+ memcpy(method.Guid, kChmLzxGuid, 16);
+ section.Methods.Add(method);
+ }
+
+ {
+ // Control Data
+ RINOK(DecompressStream(inStream, database, sectionPrefix + kControlData))
+
+ FOR_VECTOR (mi, section.Methods)
+ {
+ CMethodInfo &method = section.Methods[mi];
+ UInt32 numDWORDS = ReadUInt32();
+ if (method.IsLzx())
+ {
+ if (numDWORDS < 5)
+ return S_FALSE;
+ if (ReadUInt32() != kSignature_LZXC)
+ return S_FALSE;
+ CLzxInfo &li = method.LzxInfo;
+ li.Version = ReadUInt32();
+ if (li.Version != 2 && li.Version != 3)
+ return S_FALSE;
+
+ {
+ // There is bug in VC6, if we use function call as parameter for inline function
+ const UInt32 val32 = ReadUInt32();
+ const int n = GetLog(val32);
+ if (n < 0 || n > 16)
+ return S_FALSE;
+ li.ResetIntervalBits = (unsigned)n;
+ }
+
+ {
+ const UInt32 val32 = ReadUInt32();
+ const int n = GetLog(val32);
+ if (n < 0 || n > 16)
+ return S_FALSE;
+ li.WindowSizeBits = (unsigned)n;
+ }
+
+ li.CacheSize = ReadUInt32();
+ numDWORDS -= 5;
+ while (numDWORDS-- != 0)
+ ReadUInt32();
+ }
+ else
+ {
+ UInt32 numBytes = numDWORDS * 4;
+ method.ControlData.Alloc(numBytes);
+ ReadBytes(method.ControlData, numBytes);
+ }
+ }
+ }
+
+ {
+ // SpanInfo
+ RINOK(DecompressStream(inStream, database, sectionPrefix + kSpanInfo))
+ section.UncompressedSize = ReadUInt64();
+ }
+
+ // read ResetTable for LZX
+ FOR_VECTOR (mi, section.Methods)
+ {
+ CMethodInfo &method = section.Methods[mi];
+ if (method.IsLzx())
+ {
+ // ResetTable;
+ RINOK(DecompressStream(inStream, database, transformPrefix +
+ method.GetGuidString() + kResetTable))
+ CResetTable &rt = method.LzxInfo.ResetTable;
+
+ if (_chunkSize < 4)
+ {
+ if (_chunkSize != 0)
+ return S_FALSE;
+ // ResetTable is empty in .chw files
+ if (section.UncompressedSize != 0)
+ return S_FALSE;
+ rt.UncompressedSize = 0;
+ rt.CompressedSize = 0;
+ // rt.BlockSize = 0;
+ }
+ else
+ {
+ UInt32 ver = ReadUInt32(); // 2 unknown (possibly a version number)
+ if (ver != 2 && ver != 3)
+ return S_FALSE;
+ UInt32 numEntries = ReadUInt32();
+ const unsigned kEntrySize = 8;
+ if (ReadUInt32() != kEntrySize)
+ return S_FALSE;
+ const unsigned kRtHeaderSize = 4 * 4 + 8 * 3;
+ if (ReadUInt32() != kRtHeaderSize)
+ return S_FALSE;
+ if (kRtHeaderSize + kEntrySize * (UInt64)numEntries != _chunkSize)
+ return S_FALSE;
+
+ rt.UncompressedSize = ReadUInt64();
+ rt.CompressedSize = ReadUInt64();
+ UInt64 blockSize = ReadUInt64();
+ if (blockSize != kBlockSize)
+ return S_FALSE;
+ UInt64 numBlocks = (rt.UncompressedSize + kBlockSize + 1) / kBlockSize;
+ if (numEntries != numBlocks &&
+ numEntries != numBlocks + 1)
+ return S_FALSE;
+
+ rt.ResetOffsets.ClearAndReserve(numEntries);
+
+ for (UInt32 i = 0; i < numEntries; i++)
+ {
+ UInt64 v = ReadUInt64();
+ if (i != 0 && v < rt.ResetOffsets[i - 1])
+ return S_FALSE;
+ rt.ResetOffsets.AddInReserved(v);
+ }
+
+ if (numEntries != 0)
+ if (rt.ResetOffsets[0] != 0)
+ return S_FALSE;
+
+ if (numEntries == numBlocks + 1)
+ {
+ // Lazarus 9-26-2 chm contains additional entty
+ if (rt.ResetOffsets.Back() != rt.CompressedSize)
+ return S_FALSE;
+ }
+ }
+ }
+ }
+ }
+
+ database.SetIndices();
+ database.Sort();
+ return database.Check() ? S_OK : S_FALSE;
+}
+
+HRESULT CInArchive::Open2(IInStream *inStream,
+ const UInt64 *searchHeaderSizeLimit,
+ CFilesDatabase &database)
+{
+ IsArc = false;
+ HeadersError = false;
+ UnexpectedEnd = false;
+ UnsupportedFeature = false;
+
+ database.Clear();
+ database.Help2Format = _help2;
+ const UInt32 chmVersion = 3;
+
+ RINOK(InStream_GetPos(inStream, database.StartPosition))
+
+ if (!_inBuffer.Create(1 << 14))
+ return E_OUTOFMEMORY;
+ _inBuffer.SetStream(inStream);
+ _inBuffer.Init();
+
+ if (_help2)
+ {
+ const unsigned kSignatureSize = 8;
+ const UInt64 signature = ((UInt64)kSignature_ITLS << 32) | kSignature_ITOL;
+ UInt64 limit = 1 << 18;
+
+ if (searchHeaderSizeLimit)
+ if (limit > *searchHeaderSizeLimit)
+ limit = *searchHeaderSizeLimit;
+
+ UInt64 val = 0;
+
+ for (;;)
+ {
+ Byte b;
+ if (!_inBuffer.ReadByte(b))
+ return S_FALSE;
+ val >>= 8;
+ val |= ((UInt64)b) << ((kSignatureSize - 1) * 8);
+ if (_inBuffer.GetProcessedSize() >= kSignatureSize)
+ {
+ if (val == signature)
+ break;
+ if (_inBuffer.GetProcessedSize() > limit)
+ return S_FALSE;
+ }
+ }
+
+ database.StartPosition += _inBuffer.GetProcessedSize() - kSignatureSize;
+ RINOK(OpenHelp2(inStream, database))
+ if (database.NewFormat)
+ return S_OK;
+ }
+ else
+ {
+ if (ReadUInt32() != kSignature_ITSF)
+ return S_FALSE;
+ if (ReadUInt32() != chmVersion)
+ return S_FALSE;
+ RINOK(OpenChm(inStream, database))
+ }
+
+
+ #ifndef CHM_LOW
+
+ try
+ {
+ try
+ {
+ HRESULT res = OpenHighLevel(inStream, database);
+ if (res == S_FALSE)
+ {
+ UnsupportedFeature = true;
+ database.HighLevelClear();
+ return S_OK;
+ }
+ RINOK(res)
+ if (!database.CheckSectionRefs())
+ HeadersError = true;
+ database.LowLevel = false;
+ }
+ catch(...)
+ {
+ database.HighLevelClear();
+ throw;
+ }
+ }
+ // catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(CEnexpectedEndException &) { UnexpectedEnd = true; }
+ catch(CHeaderErrorException &) { HeadersError = true; }
+ catch(...) { throw; }
+
+ #endif
+
+ return S_OK;
+}
+
+HRESULT CInArchive::Open(IInStream *inStream,
+ const UInt64 *searchHeaderSizeLimit,
+ CFilesDatabase &database)
+{
+ try
+ {
+ try
+ {
+ HRESULT res = Open2(inStream, searchHeaderSizeLimit, database);
+ m_InStreamRef.Release();
+ return res;
+ }
+ catch(...)
+ {
+ m_InStreamRef.Release();
+ throw;
+ }
+ }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(CEnexpectedEndException &) { UnexpectedEnd = true; }
+ catch(CHeaderErrorException &) { HeadersError = true; }
+ return S_FALSE;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Chm/ChmIn.h b/CPP/7zip/Archive/Chm/ChmIn.h
new file mode 100644
index 0000000..c01ef4d
--- /dev/null
+++ b/CPP/7zip/Archive/Chm/ChmIn.h
@@ -0,0 +1,282 @@
+// Archive/ChmIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_CHM_IN_H
+#define ZIP7_INC_ARCHIVE_CHM_IN_H
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyString.h"
+
+#include "../../IStream.h"
+
+#include "../../Common/InBuffer.h"
+
+namespace NArchive {
+namespace NChm {
+
+struct CItem
+{
+ UInt64 Section;
+ UInt64 Offset;
+ UInt64 Size;
+ AString Name;
+
+ bool IsFormatRelatedItem() const
+ {
+ if (Name.Len() < 2)
+ return false;
+ return Name[0] == ':' && Name[1] == ':';
+ }
+
+ bool IsUserItem() const
+ {
+ if (Name.Len() < 2)
+ return false;
+ return Name[0] == '/';
+ }
+
+ bool IsDir() const
+ {
+ if (Name.IsEmpty())
+ return false;
+ return (Name.Back() == '/');
+ }
+};
+
+
+struct CDatabase
+{
+ UInt64 StartPosition;
+ UInt64 ContentOffset;
+ CObjectVector<CItem> Items;
+ AString NewFormatString;
+ bool Help2Format;
+ bool NewFormat;
+ UInt64 PhySize;
+
+ void UpdatePhySize(UInt64 v) { if (PhySize < v) PhySize = v; }
+
+ int FindItem(const AString &name) const
+ {
+ FOR_VECTOR (i, Items)
+ if (Items[i].Name == name)
+ return (int)i;
+ return -1;
+ }
+
+ void Clear()
+ {
+ NewFormat = false;
+ NewFormatString.Empty();
+ Help2Format = false;
+ Items.Clear();
+ StartPosition = 0;
+ PhySize = 0;
+ }
+};
+
+
+const UInt32 kBlockSize = 1 << 15;
+
+struct CResetTable
+{
+ UInt64 UncompressedSize;
+ UInt64 CompressedSize;
+ // unsigned BlockSizeBits;
+ CRecordVector<UInt64> ResetOffsets;
+
+ CResetTable():
+ UncompressedSize(0),
+ CompressedSize(0)
+ {}
+
+ bool GetCompressedSizeOfBlocks(UInt64 blockIndex, UInt32 numBlocks, UInt64 &size) const
+ {
+ if (blockIndex >= ResetOffsets.Size())
+ return false;
+ UInt64 startPos = ResetOffsets[(unsigned)blockIndex];
+ if (blockIndex + numBlocks >= ResetOffsets.Size())
+ size = CompressedSize - startPos;
+ else
+ size = ResetOffsets[(unsigned)(blockIndex + numBlocks)] - startPos;
+ return true;
+ }
+
+ bool GetCompressedSizeOfBlock(UInt64 blockIndex, UInt64 &size) const
+ {
+ return GetCompressedSizeOfBlocks(blockIndex, 1, size);
+ }
+
+ UInt64 GetNumBlocks(UInt64 size) const
+ {
+ return (size + kBlockSize - 1) / kBlockSize;
+ }
+};
+
+
+struct CLzxInfo
+{
+ UInt32 Version;
+
+ unsigned ResetIntervalBits;
+ unsigned WindowSizeBits;
+ UInt32 CacheSize;
+
+ CResetTable ResetTable;
+
+ CLzxInfo():
+ Version(0),
+ ResetIntervalBits(0),
+ WindowSizeBits(0),
+ CacheSize(0)
+ {}
+
+ unsigned GetNumDictBits() const
+ {
+ if (Version == 2 || Version == 3)
+ return 15 + WindowSizeBits;
+ return 0;
+ }
+
+ UInt64 GetFolderSize() const { return kBlockSize << ResetIntervalBits; }
+ UInt64 GetFolder(UInt64 offset) const { return offset / GetFolderSize(); }
+ UInt64 GetFolderPos(UInt64 folderIndex) const { return folderIndex * GetFolderSize(); }
+ UInt64 GetBlockIndexFromFolderIndex(UInt64 folderIndex) const { return folderIndex << ResetIntervalBits; }
+
+ bool GetOffsetOfFolder(UInt64 folderIndex, UInt64 &offset) const
+ {
+ UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
+ if (blockIndex >= ResetTable.ResetOffsets.Size())
+ return false;
+ offset = ResetTable.ResetOffsets[(unsigned)blockIndex];
+ return true;
+ }
+
+ bool GetCompressedSizeOfFolder(UInt64 folderIndex, UInt64 &size) const
+ {
+ UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
+ return ResetTable.GetCompressedSizeOfBlocks(blockIndex, (UInt32)1 << ResetIntervalBits, size);
+ }
+};
+
+
+struct CMethodInfo
+{
+ Byte Guid[16];
+ CByteBuffer ControlData;
+ CLzxInfo LzxInfo;
+
+ bool IsLzx() const;
+ bool IsDes() const;
+ AString GetGuidString() const;
+ AString GetName() const;
+};
+
+
+struct CSectionInfo
+{
+ UInt64 Offset;
+ UInt64 CompressedSize;
+ UInt64 UncompressedSize;
+
+ AString Name;
+ CObjectVector<CMethodInfo> Methods;
+
+ bool IsLzx() const;
+ UString GetMethodName() const;
+};
+
+class CFilesDatabase: public CDatabase
+{
+public:
+ bool LowLevel;
+ CUIntVector Indices;
+ CObjectVector<CSectionInfo> Sections;
+
+ UInt64 GetFileSize(unsigned fileIndex) const { return Items[Indices[fileIndex]].Size; }
+ UInt64 GetFileOffset(unsigned fileIndex) const { return Items[Indices[fileIndex]].Offset; }
+
+ UInt64 GetFolder(unsigned fileIndex) const
+ {
+ const CItem &item = Items[Indices[fileIndex]];
+ if (item.Section < Sections.Size())
+ {
+ const CSectionInfo §ion = Sections[(unsigned)item.Section];
+ if (section.IsLzx())
+ return section.Methods[0].LzxInfo.GetFolder(item.Offset);
+ }
+ return 0;
+ }
+
+ UInt64 GetLastFolder(unsigned fileIndex) const
+ {
+ const CItem &item = Items[Indices[fileIndex]];
+ if (item.Section < Sections.Size())
+ {
+ const CSectionInfo §ion = Sections[(unsigned)item.Section];
+ if (section.IsLzx())
+ return section.Methods[0].LzxInfo.GetFolder(item.Offset + item.Size - 1);
+ }
+ return 0;
+ }
+
+ void HighLevelClear()
+ {
+ LowLevel = true;
+ Indices.Clear();
+ Sections.Clear();
+ }
+
+ void Clear()
+ {
+ CDatabase::Clear();
+ HighLevelClear();
+ }
+
+ void SetIndices();
+ void Sort();
+ bool Check();
+ bool CheckSectionRefs();
+};
+
+
+class CInArchive
+{
+ CMyComPtr<ISequentialInStream> m_InStreamRef;
+ ::CInBuffer _inBuffer;
+ UInt64 _chunkSize;
+ bool _help2;
+
+ Byte ReadByte();
+ void ReadBytes(Byte *data, UInt32 size);
+ void Skip(size_t size);
+ UInt16 ReadUInt16();
+ UInt32 ReadUInt32();
+ UInt64 ReadUInt64();
+ UInt64 ReadEncInt();
+ void ReadString(unsigned size, AString &s);
+ void ReadUString(unsigned size, UString &s);
+ void ReadGUID(Byte *g);
+
+ HRESULT ReadChunk(IInStream *inStream, UInt64 pos, UInt64 size);
+
+ HRESULT ReadDirEntry(CDatabase &database);
+ HRESULT DecompressStream(IInStream *inStream, const CDatabase &database, const AString &name);
+
+public:
+ bool IsArc;
+ bool HeadersError;
+ bool UnexpectedEnd;
+ bool UnsupportedFeature;
+
+ CInArchive(bool help2) { _help2 = help2; }
+
+ HRESULT OpenChm(IInStream *inStream, CDatabase &database);
+ HRESULT OpenHelp2(IInStream *inStream, CDatabase &database);
+ HRESULT OpenHighLevel(IInStream *inStream, CFilesDatabase &database);
+ HRESULT Open2(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
+ HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Chm/StdAfx.h b/CPP/7zip/Archive/Chm/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Chm/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/ComHandler.cpp b/CPP/7zip/Archive/ComHandler.cpp
new file mode 100644
index 0000000..7aabd65
--- /dev/null
+++ b/CPP/7zip/Archive/ComHandler.cpp
@@ -0,0 +1,896 @@
+// ComHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/IntToString.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+namespace NArchive {
+namespace NCom {
+
+static const Byte kSignature[] =
+ { 0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1 };
+
+enum EType
+{
+ k_Type_Common,
+ k_Type_Msi,
+ k_Type_Msp,
+ k_Type_Doc,
+ k_Type_Ppt,
+ k_Type_Xls
+};
+
+static const char * const kExtensions[] =
+{
+ "compound"
+ , "msi"
+ , "msp"
+ , "doc"
+ , "ppt"
+ , "xls"
+};
+
+namespace NFatID
+{
+ // static const UInt32 kFree = 0xFFFFFFFF;
+ static const UInt32 kEndOfChain = 0xFFFFFFFE;
+ // static const UInt32 kFatSector = 0xFFFFFFFD;
+ // static const UInt32 kMatSector = 0xFFFFFFFC;
+ static const UInt32 kMaxValue = 0xFFFFFFFA;
+}
+
+namespace NItemType
+{
+ static const Byte kEmpty = 0;
+ static const Byte kStorage = 1;
+ // static const Byte kStream = 2;
+ // static const Byte kLockBytes = 3;
+ // static const Byte kProperty = 4;
+ static const Byte kRootStorage = 5;
+}
+
+static const UInt32 kNameSizeMax = 64;
+
+struct CItem
+{
+ Byte Name[kNameSizeMax];
+ // UInt16 NameSize;
+ // UInt32 Flags;
+ FILETIME CTime;
+ FILETIME MTime;
+ UInt64 Size;
+ UInt32 LeftDid;
+ UInt32 RightDid;
+ UInt32 SonDid;
+ UInt32 Sid;
+ Byte Type;
+
+ bool IsEmpty() const { return Type == NItemType::kEmpty; }
+ bool IsDir() const { return Type == NItemType::kStorage || Type == NItemType::kRootStorage; }
+
+ void Parse(const Byte *p, bool mode64bit);
+};
+
+struct CRef
+{
+ int Parent;
+ UInt32 Did;
+};
+
+class CDatabase
+{
+ UInt32 NumSectorsInMiniStream;
+ CObjArray<UInt32> MiniSids;
+
+ HRESULT AddNode(int parent, UInt32 did);
+public:
+
+ CObjArray<UInt32> Fat;
+ UInt32 FatSize;
+
+ CObjArray<UInt32> Mat;
+ UInt32 MatSize;
+
+ CObjectVector<CItem> Items;
+ CRecordVector<CRef> Refs;
+
+ UInt32 LongStreamMinSize;
+ unsigned SectorSizeBits;
+ unsigned MiniSectorSizeBits;
+
+ Int32 MainSubfile;
+
+ UInt64 PhySize;
+ UInt64 PhySize_Aligned;
+ EType Type;
+
+ bool IsNotArcType() const
+ {
+ return
+ Type != k_Type_Msi &&
+ Type != k_Type_Msp;
+ }
+
+ void UpdatePhySize(UInt64 val, UInt64 val_Aligned)
+ {
+ if (PhySize < val)
+ PhySize = val;
+ if (PhySize_Aligned < val_Aligned)
+ PhySize_Aligned = val_Aligned;
+ }
+ HRESULT ReadSector(IInStream *inStream, Byte *buf, unsigned sectorSizeBits, UInt32 sid);
+ HRESULT ReadIDs(IInStream *inStream, Byte *buf, unsigned sectorSizeBits, UInt32 sid, UInt32 *dest);
+
+ HRESULT Update_PhySize_WithItem(unsigned index);
+
+ void Clear();
+ bool IsLargeStream(UInt64 size) const { return size >= LongStreamMinSize; }
+ UString GetItemPath(UInt32 index) const;
+
+ UInt64 GetItemPackSize(UInt64 size) const
+ {
+ UInt64 mask = ((UInt64)1 << (IsLargeStream(size) ? SectorSizeBits : MiniSectorSizeBits)) - 1;
+ return (size + mask) & ~mask;
+ }
+
+ bool GetMiniCluster(UInt32 sid, UInt64 &res) const
+ {
+ unsigned subBits = SectorSizeBits - MiniSectorSizeBits;
+ UInt32 fid = sid >> subBits;
+ if (fid >= NumSectorsInMiniStream)
+ return false;
+ res = (((UInt64)MiniSids[fid] + 1) << subBits) + (sid & ((1 << subBits) - 1));
+ return true;
+ }
+
+ HRESULT Open(IInStream *inStream);
+};
+
+
+HRESULT CDatabase::ReadSector(IInStream *inStream, Byte *buf, unsigned sectorSizeBits, UInt32 sid)
+{
+ const UInt64 end = ((UInt64)sid + 2) << sectorSizeBits;
+ UpdatePhySize(end, end);
+ RINOK(InStream_SeekSet(inStream, (((UInt64)sid + 1) << sectorSizeBits)))
+ return ReadStream_FALSE(inStream, buf, (size_t)1 << sectorSizeBits);
+}
+
+HRESULT CDatabase::ReadIDs(IInStream *inStream, Byte *buf, unsigned sectorSizeBits, UInt32 sid, UInt32 *dest)
+{
+ RINOK(ReadSector(inStream, buf, sectorSizeBits, sid))
+ UInt32 sectorSize = (UInt32)1 << sectorSizeBits;
+ for (UInt32 t = 0; t < sectorSize; t += 4)
+ *dest++ = Get32(buf + t);
+ return S_OK;
+}
+
+static void GetFileTimeFromMem(const Byte *p, FILETIME *ft)
+{
+ ft->dwLowDateTime = Get32(p);
+ ft->dwHighDateTime = Get32(p + 4);
+}
+
+void CItem::Parse(const Byte *p, bool mode64bit)
+{
+ memcpy(Name, p, kNameSizeMax);
+ // NameSize = Get16(p + 64);
+ Type = p[66];
+ LeftDid = Get32(p + 68);
+ RightDid = Get32(p + 72);
+ SonDid = Get32(p + 76);
+ // Flags = Get32(p + 96);
+ GetFileTimeFromMem(p + 100, &CTime);
+ GetFileTimeFromMem(p + 108, &MTime);
+ Sid = Get32(p + 116);
+ Size = Get32(p + 120);
+ if (mode64bit)
+ Size |= ((UInt64)Get32(p + 124) << 32);
+}
+
+void CDatabase::Clear()
+{
+ PhySize = 0;
+ PhySize_Aligned = 0;
+
+ Fat.Free();
+ MiniSids.Free();
+ Mat.Free();
+ Items.Clear();
+ Refs.Clear();
+}
+
+static const UInt32 kNoDid = 0xFFFFFFFF;
+
+HRESULT CDatabase::AddNode(int parent, UInt32 did)
+{
+ if (did == kNoDid)
+ return S_OK;
+ if (did >= (UInt32)Items.Size())
+ return S_FALSE;
+ const CItem &item = Items[did];
+ if (item.IsEmpty())
+ return S_FALSE;
+ CRef ref;
+ ref.Parent = parent;
+ ref.Did = did;
+ const unsigned index = Refs.Add(ref);
+ if (Refs.Size() > Items.Size())
+ return S_FALSE;
+ RINOK(AddNode(parent, item.LeftDid))
+ RINOK(AddNode(parent, item.RightDid))
+ if (item.IsDir())
+ {
+ RINOK(AddNode((int)index, item.SonDid))
+ }
+ return S_OK;
+}
+
+static UString CompoundNameToFileName(const UString &s)
+{
+ UString res;
+ for (unsigned i = 0; i < s.Len(); i++)
+ {
+ const wchar_t c = s[i];
+ if ((unsigned)(int)c < 0x20)
+ {
+ res += '[';
+ res.Add_UInt32((UInt32)(unsigned)(int)c);
+ res += ']';
+ }
+ else
+ res += c;
+ }
+ return res;
+}
+
+static const char k_Msi_Chars[] =
+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._";
+
+// static const char * const k_Msi_ID = ""; // "{msi}";
+static const char k_Msi_SpecChar = '!';
+
+static const unsigned k_Msi_NumBits = 6;
+static const unsigned k_Msi_NumChars = 1 << k_Msi_NumBits;
+static const unsigned k_Msi_CharMask = k_Msi_NumChars - 1;
+static const unsigned k_Msi_StartUnicodeChar = 0x3800;
+static const unsigned k_Msi_UnicodeRange = k_Msi_NumChars * (k_Msi_NumChars + 1);
+
+
+static bool IsMsiName(const Byte *p)
+{
+ UInt32 c = Get16(p);
+ return
+ c >= k_Msi_StartUnicodeChar &&
+ c <= k_Msi_StartUnicodeChar + k_Msi_UnicodeRange;
+}
+
+static bool AreEqualNames(const Byte *rawName, const char *asciiName)
+{
+ for (unsigned i = 0; i < kNameSizeMax / 2; i++)
+ {
+ wchar_t c = Get16(rawName + i * 2);
+ wchar_t c2 = (Byte)asciiName[i];
+ if (c != c2)
+ return false;
+ if (c == 0)
+ return true;
+ }
+ return false;
+}
+
+static bool CompoundMsiNameToFileName(const UString &name, UString &res)
+{
+ res.Empty();
+ for (unsigned i = 0; i < name.Len(); i++)
+ {
+ wchar_t c = name[i];
+ if (c < (wchar_t)k_Msi_StartUnicodeChar || c > (wchar_t)(k_Msi_StartUnicodeChar + k_Msi_UnicodeRange))
+ return false;
+ /*
+ if (i == 0)
+ res += k_Msi_ID;
+ */
+ c -= k_Msi_StartUnicodeChar;
+
+ unsigned c0 = (unsigned)c & k_Msi_CharMask;
+ unsigned c1 = (unsigned)c >> k_Msi_NumBits;
+
+ if (c1 <= k_Msi_NumChars)
+ {
+ res += k_Msi_Chars[c0];
+ if (c1 == k_Msi_NumChars)
+ break;
+ res += k_Msi_Chars[c1];
+ }
+ else
+ res += k_Msi_SpecChar;
+ }
+ return true;
+}
+
+static UString ConvertName(const Byte *p, bool &isMsi)
+{
+ isMsi = false;
+ UString s;
+
+ for (unsigned i = 0; i < kNameSizeMax; i += 2)
+ {
+ wchar_t c = Get16(p + i);
+ if (c == 0)
+ break;
+ s += c;
+ }
+
+ UString msiName;
+ if (CompoundMsiNameToFileName(s, msiName))
+ {
+ isMsi = true;
+ return msiName;
+ }
+ return CompoundNameToFileName(s);
+}
+
+static UString ConvertName(const Byte *p)
+{
+ bool isMsi;
+ return ConvertName(p, isMsi);
+}
+
+UString CDatabase::GetItemPath(UInt32 index) const
+{
+ UString s;
+ while (index != kNoDid)
+ {
+ const CRef &ref = Refs[index];
+ const CItem &item = Items[ref.Did];
+ if (!s.IsEmpty())
+ s.InsertAtFront(WCHAR_PATH_SEPARATOR);
+ s.Insert(0, ConvertName(item.Name));
+ index = (unsigned)ref.Parent;
+ }
+ return s;
+}
+
+HRESULT CDatabase::Update_PhySize_WithItem(unsigned index)
+{
+ const CItem &item = Items[index];
+ bool isLargeStream = (index == 0 || IsLargeStream(item.Size));
+ if (!isLargeStream)
+ return S_OK;
+ const unsigned bsLog = isLargeStream ? SectorSizeBits : MiniSectorSizeBits;
+ // streamSpec->Size = item.Size;
+
+ const UInt32 clusterSize = (UInt32)1 << bsLog;
+ const UInt64 numClusters64 = (item.Size + clusterSize - 1) >> bsLog;
+ if (numClusters64 >= ((UInt32)1 << 31))
+ return S_FALSE;
+ UInt32 sid = item.Sid;
+ UInt64 size = item.Size;
+
+ if (size != 0)
+ {
+ for (;; size -= clusterSize)
+ {
+ // if (isLargeStream)
+ {
+ if (sid >= FatSize)
+ return S_FALSE;
+ UInt64 end = ((UInt64)sid + 1) << bsLog;
+ const UInt64 end_Aligned = end + clusterSize;
+ if (size < clusterSize)
+ end += size;
+ else
+ end = end_Aligned;
+ UpdatePhySize(end, end_Aligned);
+ sid = Fat[sid];
+ }
+ if (size <= clusterSize)
+ break;
+ }
+ }
+ if (sid != NFatID::kEndOfChain)
+ return S_FALSE;
+ return S_OK;
+}
+
+// There is name "[!]MsiPatchSequence" in msp files
+static const unsigned kMspSequence_Size = 18;
+static const Byte kMspSequence[kMspSequence_Size] =
+ { 0x40, 0x48, 0x96, 0x45, 0x6C, 0x3E, 0xE4, 0x45,
+ 0xE6, 0x42, 0x16, 0x42, 0x37, 0x41, 0x27, 0x41,
+ 0x37, 0x41 };
+
+HRESULT CDatabase::Open(IInStream *inStream)
+{
+ MainSubfile = -1;
+ Type = k_Type_Common;
+ const UInt32 kHeaderSize = 512;
+ Byte p[kHeaderSize];
+ PhySize = kHeaderSize;
+ RINOK(ReadStream_FALSE(inStream, p, kHeaderSize))
+ if (memcmp(p, kSignature, Z7_ARRAY_SIZE(kSignature)) != 0)
+ return S_FALSE;
+ if (Get16(p + 0x1A) > 4) // majorVer
+ return S_FALSE;
+ if (Get16(p + 0x1C) != 0xFFFE) // Little-endian
+ return S_FALSE;
+ unsigned sectorSizeBits = Get16(p + 0x1E);
+ bool mode64bit = (sectorSizeBits >= 12);
+ unsigned miniSectorSizeBits = Get16(p + 0x20);
+ SectorSizeBits = sectorSizeBits;
+ MiniSectorSizeBits = miniSectorSizeBits;
+
+ if (sectorSizeBits > 24 ||
+ sectorSizeBits < 7 ||
+ miniSectorSizeBits > 24 ||
+ miniSectorSizeBits < 2 ||
+ miniSectorSizeBits > sectorSizeBits)
+ return S_FALSE;
+ UInt32 numSectorsForFAT = Get32(p + 0x2C); // SAT
+ LongStreamMinSize = Get32(p + 0x38);
+
+ UInt32 sectSize = (UInt32)1 << sectorSizeBits;
+
+ CByteBuffer sect(sectSize);
+
+ unsigned ssb2 = sectorSizeBits - 2;
+ UInt32 numSidsInSec = (UInt32)1 << ssb2;
+ UInt32 numFatItems = numSectorsForFAT << ssb2;
+ if ((numFatItems >> ssb2) != numSectorsForFAT)
+ return S_FALSE;
+ FatSize = numFatItems;
+
+ {
+ UInt32 numSectorsForBat = Get32(p + 0x48); // master sector allocation table
+ const UInt32 kNumHeaderBatItems = 109;
+ UInt32 numBatItems = kNumHeaderBatItems + (numSectorsForBat << ssb2);
+ if (numBatItems < kNumHeaderBatItems || ((numBatItems - kNumHeaderBatItems) >> ssb2) != numSectorsForBat)
+ return S_FALSE;
+ CObjArray<UInt32> bat(numBatItems);
+ UInt32 i;
+ for (i = 0; i < kNumHeaderBatItems; i++)
+ bat[i] = Get32(p + 0x4c + i * 4);
+ UInt32 sid = Get32(p + 0x44);
+ for (UInt32 s = 0; s < numSectorsForBat; s++)
+ {
+ RINOK(ReadIDs(inStream, sect, sectorSizeBits, sid, bat + i))
+ i += numSidsInSec - 1;
+ sid = bat[i];
+ }
+ numBatItems = i;
+
+ Fat.Alloc(numFatItems);
+ UInt32 j = 0;
+
+ for (i = 0; i < numFatItems; j++, i += numSidsInSec)
+ {
+ if (j >= numBatItems)
+ return S_FALSE;
+ RINOK(ReadIDs(inStream, sect, sectorSizeBits, bat[j], Fat + i))
+ }
+ FatSize = numFatItems = i;
+ }
+
+ UInt32 numMatItems;
+ {
+ UInt32 numSectorsForMat = Get32(p + 0x40);
+ numMatItems = (UInt32)numSectorsForMat << ssb2;
+ if ((numMatItems >> ssb2) != numSectorsForMat)
+ return S_FALSE;
+ Mat.Alloc(numMatItems);
+ UInt32 i;
+ UInt32 sid = Get32(p + 0x3C); // short-sector table SID
+ for (i = 0; i < numMatItems; i += numSidsInSec)
+ {
+ RINOK(ReadIDs(inStream, sect, sectorSizeBits, sid, Mat + i))
+ if (sid >= numFatItems)
+ return S_FALSE;
+ sid = Fat[sid];
+ }
+ if (sid != NFatID::kEndOfChain)
+ return S_FALSE;
+ }
+
+ {
+ CByteBuffer used(numFatItems);
+ for (UInt32 i = 0; i < numFatItems; i++)
+ used[i] = 0;
+ UInt32 sid = Get32(p + 0x30); // directory stream SID
+ for (;;)
+ {
+ if (sid >= numFatItems)
+ return S_FALSE;
+ if (used[sid])
+ return S_FALSE;
+ used[sid] = 1;
+ RINOK(ReadSector(inStream, sect, sectorSizeBits, sid))
+ for (UInt32 i = 0; i < sectSize; i += 128)
+ {
+ CItem item;
+ item.Parse(sect + i, mode64bit);
+ Items.Add(item);
+ }
+ sid = Fat[sid];
+ if (sid == NFatID::kEndOfChain)
+ break;
+ }
+ }
+
+ const CItem &root = Items[0];
+
+ {
+ UInt32 numSectorsInMiniStream;
+ {
+ UInt64 numSatSects64 = (root.Size + sectSize - 1) >> sectorSizeBits;
+ if (numSatSects64 > NFatID::kMaxValue)
+ return S_FALSE;
+ numSectorsInMiniStream = (UInt32)numSatSects64;
+ }
+ NumSectorsInMiniStream = numSectorsInMiniStream;
+ MiniSids.Alloc(numSectorsInMiniStream);
+ {
+ UInt64 matSize64 = (root.Size + ((UInt64)1 << miniSectorSizeBits) - 1) >> miniSectorSizeBits;
+ if (matSize64 > NFatID::kMaxValue)
+ return S_FALSE;
+ MatSize = (UInt32)matSize64;
+ if (numMatItems < MatSize)
+ return S_FALSE;
+ }
+
+ UInt32 sid = root.Sid;
+ for (UInt32 i = 0; ; i++)
+ {
+ if (sid == NFatID::kEndOfChain)
+ {
+ if (i != numSectorsInMiniStream)
+ return S_FALSE;
+ break;
+ }
+ if (i >= numSectorsInMiniStream)
+ return S_FALSE;
+ MiniSids[i] = sid;
+ if (sid >= numFatItems)
+ return S_FALSE;
+ sid = Fat[sid];
+ }
+ }
+
+ RINOK(AddNode(-1, root.SonDid))
+
+ unsigned numCabs = 0;
+
+ FOR_VECTOR (i, Refs)
+ {
+ const CItem &item = Items[Refs[i].Did];
+ if (item.IsDir() || numCabs > 1)
+ continue;
+ bool isMsiName;
+ const UString msiName = ConvertName(item.Name, isMsiName);
+ if (isMsiName && !msiName.IsEmpty())
+ {
+ // bool isThereExt = (msiName.Find(L'.') >= 0);
+ bool isMsiSpec = (msiName[0] == k_Msi_SpecChar);
+ if ((msiName.Len() >= 4 && StringsAreEqualNoCase_Ascii(msiName.RightPtr(4), ".cab"))
+ || (!isMsiSpec && msiName.Len() >= 3 && StringsAreEqualNoCase_Ascii(msiName.RightPtr(3), "exe"))
+ // || (!isMsiSpec && !isThereExt)
+ )
+ {
+ numCabs++;
+ MainSubfile = (int)i;
+ }
+ }
+ }
+
+ if (numCabs > 1)
+ MainSubfile = -1;
+
+ {
+ FOR_VECTOR (t, Items)
+ {
+ Update_PhySize_WithItem(t);
+ }
+ }
+ {
+ if (PhySize != PhySize_Aligned)
+ {
+ /* some msi (in rare cases) have unaligned size of archive,
+ where there is no padding data after payload data in last cluster of archive */
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(inStream, fileSize))
+ if (PhySize != fileSize)
+ PhySize = PhySize_Aligned;
+ }
+ }
+ {
+ FOR_VECTOR (t, Items)
+ {
+ const CItem &item = Items[t];
+
+ if (IsMsiName(item.Name))
+ {
+ Type = k_Type_Msi;
+ if (memcmp(item.Name, kMspSequence, kMspSequence_Size) == 0)
+ {
+ Type = k_Type_Msp;
+ break;
+ }
+ continue;
+ }
+ if (AreEqualNames(item.Name, "WordDocument"))
+ {
+ Type = k_Type_Doc;
+ break;
+ }
+ if (AreEqualNames(item.Name, "PowerPoint Document"))
+ {
+ Type = k_Type_Ppt;
+ break;
+ }
+ if (AreEqualNames(item.Name, "Workbook"))
+ {
+ Type = k_Type_Xls;
+ break;
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CMyComPtr<IInStream> _stream;
+ CDatabase _db;
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidCTime,
+ kpidMTime
+};
+
+static const Byte kArcProps[] =
+{
+ kpidExtension,
+ kpidClusterSize,
+ kpidSectorSize
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidExtension: prop = kExtensions[(unsigned)_db.Type]; break;
+ case kpidPhySize: prop = _db.PhySize; break;
+ case kpidClusterSize: prop = (UInt32)1 << _db.SectorSizeBits; break;
+ case kpidSectorSize: prop = (UInt32)1 << _db.MiniSectorSizeBits; break;
+ case kpidMainSubfile: if (_db.MainSubfile >= 0) prop = (UInt32)_db.MainSubfile; break;
+ case kpidIsNotArcType: if (_db.IsNotArcType()) prop = true; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CRef &ref = _db.Refs[index];
+ const CItem &item = _db.Items[ref.Did];
+
+ switch (propID)
+ {
+ case kpidPath: prop = _db.GetItemPath(index); break;
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidCTime: prop = item.CTime; break;
+ case kpidMTime: prop = item.MTime; break;
+ case kpidPackSize: if (!item.IsDir()) prop = _db.GetItemPackSize(item.Size); break;
+ case kpidSize: if (!item.IsDir()) prop = item.Size; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ try
+ {
+ if (_db.Open(inStream) != S_OK)
+ return S_FALSE;
+ _stream = inStream;
+ }
+ catch(...) { return S_FALSE; }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _db.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _db.Refs.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt32 i;
+ UInt64 totalSize = 0;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItem &item = _db.Items[_db.Refs[allFilesMode ? i : indices[i]].Did];
+ if (!item.IsDir())
+ totalSize += item.Size;
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = _db.Items[_db.Refs[index].Did];
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+
+ if (item.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ totalPackSize += _db.GetItemPackSize(item.Size);
+ totalSize += item.Size;
+
+ if (!testMode && !outStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ Int32 res = NExtract::NOperationResult::kDataError;
+ CMyComPtr<ISequentialInStream> inStream;
+ HRESULT hres = GetStream(index, &inStream);
+ if (hres == S_FALSE)
+ res = NExtract::NOperationResult::kDataError;
+ else if (hres == E_NOTIMPL)
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ {
+ RINOK(hres)
+ if (inStream)
+ {
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize == item.Size)
+ res = NExtract::NOperationResult::kOK;
+ }
+ }
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _db.Refs.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ const UInt32 itemIndex = _db.Refs[index].Did;
+ const CItem &item = _db.Items[itemIndex];
+ CClusterInStream *streamSpec = new CClusterInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->Stream = _stream;
+ streamSpec->StartOffset = 0;
+
+ const bool isLargeStream = (itemIndex == 0 || _db.IsLargeStream(item.Size));
+ const unsigned bsLog = isLargeStream ? _db.SectorSizeBits : _db.MiniSectorSizeBits;
+ streamSpec->BlockSizeLog = bsLog;
+ streamSpec->Size = item.Size;
+
+ const UInt32 clusterSize = (UInt32)1 << bsLog;
+ const UInt64 numClusters64 = (item.Size + clusterSize - 1) >> bsLog;
+ if (numClusters64 >= ((UInt32)1 << 31))
+ return E_NOTIMPL;
+ streamSpec->Vector.ClearAndReserve((unsigned)numClusters64);
+ UInt32 sid = item.Sid;
+ UInt64 size = item.Size;
+
+ if (size != 0)
+ {
+ for (;; size -= clusterSize)
+ {
+ if (isLargeStream)
+ {
+ if (sid >= _db.FatSize)
+ return S_FALSE;
+ streamSpec->Vector.AddInReserved(sid + 1);
+ sid = _db.Fat[sid];
+ }
+ else
+ {
+ UInt64 val = 0;
+ if (sid >= _db.MatSize || !_db.GetMiniCluster(sid, val) || val >= (UInt64)1 << 32)
+ return S_FALSE;
+ streamSpec->Vector.AddInReserved((UInt32)val);
+ sid = _db.Mat[sid];
+ }
+ if (size <= clusterSize)
+ break;
+ }
+ }
+ if (sid != NFatID::kEndOfChain)
+ return S_FALSE;
+ RINOK(streamSpec->InitAndSeek())
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "Compound", "msi msp doc xls ppt", NULL, 0xE5,
+ kSignature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Common/CoderMixer2.cpp b/CPP/7zip/Archive/Common/CoderMixer2.cpp
index baddddf..b6ddeb8 100644
--- a/CPP/7zip/Archive/Common/CoderMixer2.cpp
+++ b/CPP/7zip/Archive/Common/CoderMixer2.cpp
@@ -1,1125 +1,1144 @@
-// CoderMixer2.cpp
-
-#include "StdAfx.h"
-
-#include "CoderMixer2.h"
-
-#ifdef USE_MIXER_ST
-
-STDMETHODIMP CSequentialInStreamCalcSize::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessed = 0;
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Read(data, size, &realProcessed);
- _size += realProcessed;
- if (size != 0 && realProcessed == 0)
- _wasFinished = true;
- if (processedSize)
- *processedSize = realProcessed;
- return result;
-}
-
-
-STDMETHODIMP COutStreamCalcSize::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Write(data, size, &size);
- _size += size;
- if (processedSize)
- *processedSize = size;
- return result;
-}
-
-STDMETHODIMP COutStreamCalcSize::OutStreamFinish()
-{
- HRESULT result = S_OK;
- if (_stream)
- {
- CMyComPtr<IOutStreamFinish> outStreamFinish;
- _stream.QueryInterface(IID_IOutStreamFinish, &outStreamFinish);
- if (outStreamFinish)
- result = outStreamFinish->OutStreamFinish();
- }
- return result;
-}
-
-#endif
-
-
-
-
-namespace NCoderMixer2 {
-
-static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
-{
- v.ClearAndSetSize(size);
- bool *p = &v[0];
- for (unsigned i = 0; i < size; i++)
- p[i] = false;
-}
-
-
-HRESULT CCoder::CheckDataAfterEnd(bool &dataAfterEnd_Error /* , bool &InternalPackSizeError */) const
-{
- if (Coder)
- {
- if (PackSizePointers.IsEmpty() || !PackSizePointers[0])
- return S_OK;
- CMyComPtr<ICompressGetInStreamProcessedSize> getInStreamProcessedSize;
- Coder.QueryInterface(IID_ICompressGetInStreamProcessedSize, (void **)&getInStreamProcessedSize);
- // if (!getInStreamProcessedSize) return E_FAIL;
- if (getInStreamProcessedSize)
- {
- UInt64 processed;
- RINOK(getInStreamProcessedSize->GetInStreamProcessedSize(&processed));
- if (processed != (UInt64)(Int64)-1)
- {
- const UInt64 size = PackSizes[0];
- if (processed < size && Finish)
- dataAfterEnd_Error = true;
- if (processed > size)
- {
- // InternalPackSizeError = true;
- // return S_FALSE;
- }
- }
- }
- }
- else if (Coder2)
- {
- CMyComPtr<ICompressGetInStreamProcessedSize2> getInStreamProcessedSize2;
- Coder2.QueryInterface(IID_ICompressGetInStreamProcessedSize2, (void **)&getInStreamProcessedSize2);
- if (getInStreamProcessedSize2)
- FOR_VECTOR (i, PackSizePointers)
- {
- if (!PackSizePointers[i])
- continue;
- UInt64 processed;
- RINOK(getInStreamProcessedSize2->GetInStreamProcessedSize2(i, &processed));
- if (processed != (UInt64)(Int64)-1)
- {
- const UInt64 size = PackSizes[i];
- if (processed < size && Finish)
- dataAfterEnd_Error = true;
- else if (processed > size)
- {
- // InternalPackSizeError = true;
- // return S_FALSE;
- }
- }
- }
- }
-
- return S_OK;
-}
-
-
-
-class CBondsChecks
-{
- CBoolVector _coderUsed;
-
- bool Init();
- bool CheckCoder(unsigned coderIndex);
-public:
- const CBindInfo *BindInfo;
-
- bool Check();
-};
-
-bool CBondsChecks::CheckCoder(unsigned coderIndex)
-{
- const CCoderStreamsInfo &coder = BindInfo->Coders[coderIndex];
-
- if (coderIndex >= _coderUsed.Size() || _coderUsed[coderIndex])
- return false;
- _coderUsed[coderIndex] = true;
-
- UInt32 start = BindInfo->Coder_to_Stream[coderIndex];
-
- for (unsigned i = 0; i < coder.NumStreams; i++)
- {
- UInt32 ind = start + i;
-
- if (BindInfo->IsStream_in_PackStreams(ind))
- continue;
-
- int bond = BindInfo->FindBond_for_PackStream(ind);
- if (bond < 0)
- return false;
- if (!CheckCoder(BindInfo->Bonds[bond].UnpackIndex))
- return false;
- }
-
- return true;
-}
-
-bool CBondsChecks::Check()
-{
- BoolVector_Fill_False(_coderUsed, BindInfo->Coders.Size());
-
- if (!CheckCoder(BindInfo->UnpackCoder))
- return false;
-
- FOR_VECTOR(i, _coderUsed)
- if (!_coderUsed[i])
- return false;
-
- return true;
-}
-
-void CBindInfo::ClearMaps()
-{
- Coder_to_Stream.Clear();
- Stream_to_Coder.Clear();
-}
-
-bool CBindInfo::CalcMapsAndCheck()
-{
- ClearMaps();
-
- UInt32 numStreams = 0;
-
- if (Coders.Size() == 0)
- return false;
- if (Coders.Size() - 1 != Bonds.Size())
- return false;
-
- FOR_VECTOR(i, Coders)
- {
- Coder_to_Stream.Add(numStreams);
-
- const CCoderStreamsInfo &c = Coders[i];
-
- for (unsigned j = 0; j < c.NumStreams; j++)
- Stream_to_Coder.Add(i);
-
- numStreams += c.NumStreams;
- }
-
- if (numStreams != GetNum_Bonds_and_PackStreams())
- return false;
-
- CBondsChecks bc;
- bc.BindInfo = this;
- return bc.Check();
-}
-
-
-void CCoder::SetCoderInfo(const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
-{
- Finish = finish;
-
- if (unpackSize)
- {
- UnpackSize = *unpackSize;
- UnpackSizePointer = &UnpackSize;
- }
- else
- {
- UnpackSize = 0;
- UnpackSizePointer = NULL;
- }
-
- PackSizes.ClearAndSetSize((unsigned)NumStreams);
- PackSizePointers.ClearAndSetSize((unsigned)NumStreams);
-
- for (unsigned i = 0; i < NumStreams; i++)
- {
- if (packSizes && packSizes[i])
- {
- PackSizes[i] = *(packSizes[i]);
- PackSizePointers[i] = &PackSizes[i];
- }
- else
- {
- PackSizes[i] = 0;
- PackSizePointers[i] = NULL;
- }
- }
-}
-
-bool CMixer::Is_UnpackSize_Correct_for_Coder(UInt32 coderIndex)
-{
- if (coderIndex == _bi.UnpackCoder)
- return true;
-
- int bond = _bi.FindBond_for_UnpackStream(coderIndex);
- if (bond < 0)
- throw 20150213;
-
- /*
- UInt32 coderIndex, coderStreamIndex;
- _bi.GetCoder_for_Stream(_bi.Bonds[bond].PackIndex, coderIndex, coderStreamIndex);
- */
- UInt32 nextCoder = _bi.Stream_to_Coder[_bi.Bonds[bond].PackIndex];
-
- if (!IsFilter_Vector[nextCoder])
- return false;
-
- return Is_UnpackSize_Correct_for_Coder(nextCoder);
-}
-
-bool CMixer::Is_PackSize_Correct_for_Stream(UInt32 streamIndex)
-{
- if (_bi.IsStream_in_PackStreams(streamIndex))
- return true;
-
- int bond = _bi.FindBond_for_PackStream(streamIndex);
- if (bond < 0)
- throw 20150213;
-
- UInt32 nextCoder = _bi.Bonds[bond].UnpackIndex;
-
- if (!IsFilter_Vector[nextCoder])
- return false;
-
- return Is_PackSize_Correct_for_Coder(nextCoder);
-}
-
-bool CMixer::Is_PackSize_Correct_for_Coder(UInt32 coderIndex)
-{
- UInt32 startIndex = _bi.Coder_to_Stream[coderIndex];
- UInt32 numStreams = _bi.Coders[coderIndex].NumStreams;
- for (UInt32 i = 0; i < numStreams; i++)
- if (!Is_PackSize_Correct_for_Stream(startIndex + i))
- return false;
- return true;
-}
-
-bool CMixer::IsThere_ExternalCoder_in_PackTree(UInt32 coderIndex)
-{
- if (IsExternal_Vector[coderIndex])
- return true;
- UInt32 startIndex = _bi.Coder_to_Stream[coderIndex];
- UInt32 numStreams = _bi.Coders[coderIndex].NumStreams;
- for (UInt32 i = 0; i < numStreams; i++)
- {
- UInt32 si = startIndex + i;
- if (_bi.IsStream_in_PackStreams(si))
- continue;
-
- int bond = _bi.FindBond_for_PackStream(si);
- if (bond < 0)
- throw 20150213;
-
- if (IsThere_ExternalCoder_in_PackTree(_bi.Bonds[bond].UnpackIndex))
- return true;
- }
- return false;
-}
-
-
-
-
-#ifdef USE_MIXER_ST
-
-CMixerST::CMixerST(bool encodeMode):
- CMixer(encodeMode)
- {}
-
-CMixerST::~CMixerST() {}
-
-void CMixerST::AddCoder(const CCreatedCoder &cod)
-{
- IsFilter_Vector.Add(cod.IsFilter);
- IsExternal_Vector.Add(cod.IsExternal);
- // const CCoderStreamsInfo &c = _bi.Coders[_coders.Size()];
- CCoderST &c2 = _coders.AddNew();
- c2.NumStreams = cod.NumStreams;
- c2.Coder = cod.Coder;
- c2.Coder2 = cod.Coder2;
-
- /*
- if (isFilter)
- {
- c2.CanRead = true;
- c2.CanWrite = true;
- }
- else
- */
- {
- IUnknown *unk = (cod.Coder ? (IUnknown *)cod.Coder : (IUnknown *)cod.Coder2);
- {
- CMyComPtr<ISequentialInStream> s;
- unk->QueryInterface(IID_ISequentialInStream, (void**)&s);
- c2.CanRead = (s != NULL);
- }
- {
- CMyComPtr<ISequentialOutStream> s;
- unk->QueryInterface(IID_ISequentialOutStream, (void**)&s);
- c2.CanWrite = (s != NULL);
- }
- }
-}
-
-CCoder &CMixerST::GetCoder(unsigned index)
-{
- return _coders[index];
-}
-
-void CMixerST::ReInit() {}
-
-HRESULT CMixerST::GetInStream2(
- ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
- UInt32 outStreamIndex, ISequentialInStream **inStreamRes)
-{
- UInt32 coderIndex = outStreamIndex, coderStreamIndex = 0;
-
- if (EncodeMode)
- {
- _bi.GetCoder_for_Stream(outStreamIndex, coderIndex, coderStreamIndex);
- if (coderStreamIndex != 0)
- return E_NOTIMPL;
- }
-
- const CCoder &coder = _coders[coderIndex];
-
- CMyComPtr<ISequentialInStream> seqInStream;
- coder.QueryInterface(IID_ISequentialInStream, (void **)&seqInStream);
- if (!seqInStream)
- return E_NOTIMPL;
-
- UInt32 numInStreams = EncodeMode ? 1 : coder.NumStreams;
- UInt32 startIndex = EncodeMode ? coderIndex : _bi.Coder_to_Stream[coderIndex];
-
- bool isSet = false;
-
- if (numInStreams == 1)
- {
- CMyComPtr<ICompressSetInStream> setStream;
- coder.QueryInterface(IID_ICompressSetInStream, (void **)&setStream);
- if (setStream)
- {
- CMyComPtr<ISequentialInStream> seqInStream2;
- RINOK(GetInStream(inStreams, /* inSizes, */ startIndex + 0, &seqInStream2));
- RINOK(setStream->SetInStream(seqInStream2));
- isSet = true;
- }
- }
-
- if (!isSet && numInStreams != 0)
- {
- CMyComPtr<ICompressSetInStream2> setStream2;
- coder.QueryInterface(IID_ICompressSetInStream2, (void **)&setStream2);
- if (!setStream2)
- return E_NOTIMPL;
-
- for (UInt32 i = 0; i < numInStreams; i++)
- {
- CMyComPtr<ISequentialInStream> seqInStream2;
- RINOK(GetInStream(inStreams, /* inSizes, */ startIndex + i, &seqInStream2));
- RINOK(setStream2->SetInStream2(i, seqInStream2));
- }
- }
-
- *inStreamRes = seqInStream.Detach();
- return S_OK;
-}
-
-
-HRESULT CMixerST::GetInStream(
- ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
- UInt32 inStreamIndex, ISequentialInStream **inStreamRes)
-{
- CMyComPtr<ISequentialInStream> seqInStream;
-
- {
- int index = -1;
- if (EncodeMode)
- {
- if (_bi.UnpackCoder == inStreamIndex)
- index = 0;
- }
- else
- index = _bi.FindStream_in_PackStreams(inStreamIndex);
-
- if (index >= 0)
- {
- seqInStream = inStreams[(unsigned)index];
- *inStreamRes = seqInStream.Detach();
- return S_OK;
- }
- }
-
- int bond = FindBond_for_Stream(
- true, // forInputStream
- inStreamIndex);
- if (bond < 0)
- return E_INVALIDARG;
-
- RINOK(GetInStream2(inStreams, /* inSizes, */
- _bi.Bonds[bond].Get_OutIndex(EncodeMode), &seqInStream));
-
- while (_binderStreams.Size() <= (unsigned)bond)
- _binderStreams.AddNew();
- CStBinderStream &bs = _binderStreams[bond];
-
- if (bs.StreamRef || bs.InStreamSpec)
- return E_NOTIMPL;
-
- CSequentialInStreamCalcSize *spec = new CSequentialInStreamCalcSize;
- bs.StreamRef = spec;
- bs.InStreamSpec = spec;
-
- spec->SetStream(seqInStream);
- spec->Init();
-
- seqInStream = bs.InStreamSpec;
-
- *inStreamRes = seqInStream.Detach();
- return S_OK;
-}
-
-
-HRESULT CMixerST::GetOutStream(
- ISequentialOutStream * const *outStreams, /* const UInt64 * const *outSizes, */
- UInt32 outStreamIndex, ISequentialOutStream **outStreamRes)
-{
- CMyComPtr<ISequentialOutStream> seqOutStream;
-
- {
- int index = -1;
- if (!EncodeMode)
- {
- if (_bi.UnpackCoder == outStreamIndex)
- index = 0;
- }
- else
- index = _bi.FindStream_in_PackStreams(outStreamIndex);
-
- if (index >= 0)
- {
- seqOutStream = outStreams[(unsigned)index];
- *outStreamRes = seqOutStream.Detach();
- return S_OK;
- }
- }
-
- int bond = FindBond_for_Stream(
- false, // forInputStream
- outStreamIndex);
- if (bond < 0)
- return E_INVALIDARG;
-
- UInt32 inStreamIndex = _bi.Bonds[bond].Get_InIndex(EncodeMode);
-
- UInt32 coderIndex = inStreamIndex;
- UInt32 coderStreamIndex = 0;
-
- if (!EncodeMode)
- _bi.GetCoder_for_Stream(inStreamIndex, coderIndex, coderStreamIndex);
-
- CCoder &coder = _coders[coderIndex];
-
- /*
- if (!coder.Coder)
- return E_NOTIMPL;
- */
-
- coder.QueryInterface(IID_ISequentialOutStream, (void **)&seqOutStream);
- if (!seqOutStream)
- return E_NOTIMPL;
-
- UInt32 numOutStreams = EncodeMode ? coder.NumStreams : 1;
- UInt32 startIndex = EncodeMode ? _bi.Coder_to_Stream[coderIndex]: coderIndex;
-
- bool isSet = false;
-
- if (numOutStreams == 1)
- {
- CMyComPtr<ICompressSetOutStream> setOutStream;
- coder.Coder.QueryInterface(IID_ICompressSetOutStream, &setOutStream);
- if (setOutStream)
- {
- CMyComPtr<ISequentialOutStream> seqOutStream2;
- RINOK(GetOutStream(outStreams, /* outSizes, */ startIndex + 0, &seqOutStream2));
- RINOK(setOutStream->SetOutStream(seqOutStream2));
- isSet = true;
- }
- }
-
- if (!isSet && numOutStreams != 0)
- {
- return E_NOTIMPL;
- /*
- CMyComPtr<ICompressSetOutStream2> setStream2;
- coder.QueryInterface(IID_ICompressSetOutStream2, (void **)&setStream2);
- if (!setStream2)
- return E_NOTIMPL;
- for (UInt32 i = 0; i < numOutStreams; i++)
- {
- CMyComPtr<ISequentialOutStream> seqOutStream2;
- RINOK(GetOutStream(outStreams, startIndex + i, &seqOutStream2));
- RINOK(setStream2->SetOutStream2(i, seqOutStream2));
- }
- */
- }
-
- while (_binderStreams.Size() <= (unsigned)bond)
- _binderStreams.AddNew();
- CStBinderStream &bs = _binderStreams[bond];
-
- if (bs.StreamRef || bs.OutStreamSpec)
- return E_NOTIMPL;
-
- COutStreamCalcSize *spec = new COutStreamCalcSize;
- bs.StreamRef = (ISequentialOutStream *)spec;
- bs.OutStreamSpec = spec;
-
- spec->SetStream(seqOutStream);
- spec->Init();
-
- seqOutStream = bs.OutStreamSpec;
-
- *outStreamRes = seqOutStream.Detach();
- return S_OK;
-}
-
-
-static HRESULT GetError(HRESULT res, HRESULT res2)
-{
- if (res == res2)
- return res;
- if (res == S_OK)
- return res2;
- if (res == k_My_HRESULT_WritingWasCut)
- {
- if (res2 != S_OK)
- return res2;
- }
- return res;
-}
-
-
-HRESULT CMixerST::FinishStream(UInt32 streamIndex)
-{
- {
- int index = -1;
- if (!EncodeMode)
- {
- if (_bi.UnpackCoder == streamIndex)
- index = 0;
- }
- else
- index = _bi.FindStream_in_PackStreams(streamIndex);
-
- if (index >= 0)
- return S_OK;
- }
-
- int bond = FindBond_for_Stream(
- false, // forInputStream
- streamIndex);
- if (bond < 0)
- return E_INVALIDARG;
-
- UInt32 inStreamIndex = _bi.Bonds[bond].Get_InIndex(EncodeMode);
-
- UInt32 coderIndex = inStreamIndex;
- UInt32 coderStreamIndex = 0;
- if (!EncodeMode)
- _bi.GetCoder_for_Stream(inStreamIndex, coderIndex, coderStreamIndex);
-
- CCoder &coder = _coders[coderIndex];
- CMyComPtr<IOutStreamFinish> finish;
- coder.QueryInterface(IID_IOutStreamFinish, (void **)&finish);
- HRESULT res = S_OK;
- if (finish)
- {
- res = finish->OutStreamFinish();
- }
- return GetError(res, FinishCoder(coderIndex));
-}
-
-
-HRESULT CMixerST::FinishCoder(UInt32 coderIndex)
-{
- CCoder &coder = _coders[coderIndex];
-
- UInt32 numOutStreams = EncodeMode ? coder.NumStreams : 1;
- UInt32 startIndex = EncodeMode ? _bi.Coder_to_Stream[coderIndex]: coderIndex;
-
- HRESULT res = S_OK;
- for (unsigned i = 0; i < numOutStreams; i++)
- res = GetError(res, FinishStream(startIndex + i));
- return res;
-}
-
-
-void CMixerST::SelectMainCoder(bool useFirst)
-{
- unsigned ci = _bi.UnpackCoder;
-
- int firstNonFilter = -1;
- int firstAllowed = ci;
-
- for (;;)
- {
- const CCoderST &coder = _coders[ci];
- // break;
-
- if (ci != _bi.UnpackCoder)
- if (EncodeMode ? !coder.CanWrite : !coder.CanRead)
- {
- firstAllowed = ci;
- firstNonFilter = -2;
- }
-
- if (coder.NumStreams != 1)
- break;
-
- UInt32 st = _bi.Coder_to_Stream[ci];
- if (_bi.IsStream_in_PackStreams(st))
- break;
- int bond = _bi.FindBond_for_PackStream(st);
- if (bond < 0)
- throw 20150213;
-
- if (EncodeMode ? !coder.CanRead : !coder.CanWrite)
- break;
-
- if (firstNonFilter == -1 && !IsFilter_Vector[ci])
- firstNonFilter = ci;
-
- ci = _bi.Bonds[bond].UnpackIndex;
- }
-
- if (useFirst)
- ci = firstAllowed;
- else if (firstNonFilter >= 0)
- ci = firstNonFilter;
-
- MainCoderIndex = ci;
-}
-
-
-HRESULT CMixerST::Code(
- ISequentialInStream * const *inStreams,
- ISequentialOutStream * const *outStreams,
- ICompressProgressInfo *progress,
- bool &dataAfterEnd_Error)
-{
- // InternalPackSizeError = false;
- dataAfterEnd_Error = false;
-
- _binderStreams.Clear();
- unsigned ci = MainCoderIndex;
-
- const CCoder &mainCoder = _coders[MainCoderIndex];
-
- CObjectVector< CMyComPtr<ISequentialInStream> > seqInStreams;
- CObjectVector< CMyComPtr<ISequentialOutStream> > seqOutStreams;
-
- UInt32 numInStreams = EncodeMode ? 1 : mainCoder.NumStreams;
- UInt32 numOutStreams = !EncodeMode ? 1 : mainCoder.NumStreams;
-
- UInt32 startInIndex = EncodeMode ? ci : _bi.Coder_to_Stream[ci];
- UInt32 startOutIndex = !EncodeMode ? ci : _bi.Coder_to_Stream[ci];
-
- UInt32 i;
-
- for (i = 0; i < numInStreams; i++)
- {
- CMyComPtr<ISequentialInStream> seqInStream;
- RINOK(GetInStream(inStreams, /* inSizes, */ startInIndex + i, &seqInStream));
- seqInStreams.Add(seqInStream);
- }
-
- for (i = 0; i < numOutStreams; i++)
- {
- CMyComPtr<ISequentialOutStream> seqOutStream;
- RINOK(GetOutStream(outStreams, /* outSizes, */ startOutIndex + i, &seqOutStream));
- seqOutStreams.Add(seqOutStream);
- }
-
- CRecordVector< ISequentialInStream * > seqInStreamsSpec;
- CRecordVector< ISequentialOutStream * > seqOutStreamsSpec;
-
- for (i = 0; i < numInStreams; i++)
- seqInStreamsSpec.Add(seqInStreams[i]);
- for (i = 0; i < numOutStreams; i++)
- seqOutStreamsSpec.Add(seqOutStreams[i]);
-
- for (i = 0; i < _coders.Size(); i++)
- {
- if (i == ci)
- continue;
-
- CCoder &coder = _coders[i];
-
- if (EncodeMode)
- {
- CMyComPtr<ICompressInitEncoder> initEncoder;
- coder.QueryInterface(IID_ICompressInitEncoder, (void **)&initEncoder);
- if (initEncoder)
- RINOK(initEncoder->InitEncoder());
- }
- else
- {
- CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
- coder.QueryInterface(IID_ICompressSetOutStreamSize, (void **)&setOutStreamSize);
- if (setOutStreamSize)
- RINOK(setOutStreamSize->SetOutStreamSize(
- EncodeMode ? coder.PackSizePointers[0] : coder.UnpackSizePointer));
- }
- }
-
- const UInt64 * const *isSizes2 = EncodeMode ? &mainCoder.UnpackSizePointer : &mainCoder.PackSizePointers.Front();
- const UInt64 * const *outSizes2 = EncodeMode ? &mainCoder.PackSizePointers.Front() : &mainCoder.UnpackSizePointer;
-
- HRESULT res;
- if (mainCoder.Coder)
- {
- res = mainCoder.Coder->Code(
- seqInStreamsSpec[0], seqOutStreamsSpec[0],
- isSizes2[0], outSizes2[0],
- progress);
- }
- else
- {
- res = mainCoder.Coder2->Code(
- &seqInStreamsSpec.Front(), isSizes2, numInStreams,
- &seqOutStreamsSpec.Front(), outSizes2, numOutStreams,
- progress);
- }
-
- if (res == k_My_HRESULT_WritingWasCut)
- res = S_OK;
-
- if (res == S_OK || res == S_FALSE)
- {
- res = GetError(res, FinishCoder(ci));
- }
-
- for (i = 0; i < _binderStreams.Size(); i++)
- {
- const CStBinderStream &bs = _binderStreams[i];
- if (bs.InStreamSpec)
- bs.InStreamSpec->ReleaseStream();
- else
- bs.OutStreamSpec->ReleaseStream();
- }
-
- if (res == k_My_HRESULT_WritingWasCut)
- res = S_OK;
-
- if (res != S_OK)
- return res;
-
- for (i = 0; i < _coders.Size(); i++)
- {
- RINOK(_coders[i].CheckDataAfterEnd(dataAfterEnd_Error /*, InternalPackSizeError */));
- }
-
- return S_OK;
-}
-
-
-HRESULT CMixerST::GetMainUnpackStream(
- ISequentialInStream * const *inStreams,
- ISequentialInStream **inStreamRes)
-{
- CMyComPtr<ISequentialInStream> seqInStream;
-
- RINOK(GetInStream2(inStreams, /* inSizes, */
- _bi.UnpackCoder, &seqInStream))
-
- FOR_VECTOR (i, _coders)
- {
- CCoder &coder = _coders[i];
- CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
- coder.QueryInterface(IID_ICompressSetOutStreamSize, (void **)&setOutStreamSize);
- if (setOutStreamSize)
- {
- RINOK(setOutStreamSize->SetOutStreamSize(coder.UnpackSizePointer));
- }
- }
-
- *inStreamRes = seqInStream.Detach();
- return S_OK;
-}
-
-
-UInt64 CMixerST::GetBondStreamSize(unsigned bondIndex) const
-{
- const CStBinderStream &bs = _binderStreams[bondIndex];
- if (bs.InStreamSpec)
- return bs.InStreamSpec->GetSize();
- return bs.OutStreamSpec->GetSize();
-}
-
-#endif
-
-
-
-
-
-
-#ifdef USE_MIXER_MT
-
-
-void CCoderMT::Execute()
-{
- try
- {
- Code(NULL);
- }
- catch(...)
- {
- Result = E_FAIL;
- }
-}
-
-void CCoderMT::Code(ICompressProgressInfo *progress)
-{
- unsigned numInStreams = EncodeMode ? 1 : NumStreams;
- unsigned numOutStreams = EncodeMode ? NumStreams : 1;
-
- InStreamPointers.ClearAndReserve(numInStreams);
- OutStreamPointers.ClearAndReserve(numOutStreams);
-
- unsigned i;
-
- for (i = 0; i < numInStreams; i++)
- InStreamPointers.AddInReserved((ISequentialInStream *)InStreams[i]);
-
- for (i = 0; i < numOutStreams; i++)
- OutStreamPointers.AddInReserved((ISequentialOutStream *)OutStreams[i]);
-
- // we suppose that UnpackSizePointer and PackSizePointers contain correct pointers.
- /*
- if (UnpackSizePointer)
- UnpackSizePointer = &UnpackSize;
- for (i = 0; i < NumStreams; i++)
- if (PackSizePointers[i])
- PackSizePointers[i] = &PackSizes[i];
- */
-
- CReleaser releaser(*this);
-
- if (Coder)
- Result = Coder->Code(InStreamPointers[0], OutStreamPointers[0],
- EncodeMode ? UnpackSizePointer : PackSizePointers[0],
- EncodeMode ? PackSizePointers[0] : UnpackSizePointer,
- progress);
- else
- Result = Coder2->Code(
- &InStreamPointers.Front(), EncodeMode ? &UnpackSizePointer : &PackSizePointers.Front(), numInStreams,
- &OutStreamPointers.Front(), EncodeMode ? &PackSizePointers.Front(): &UnpackSizePointer, numOutStreams,
- progress);
-}
-
-HRESULT CMixerMT::SetBindInfo(const CBindInfo &bindInfo)
-{
- CMixer::SetBindInfo(bindInfo);
-
- _streamBinders.Clear();
- FOR_VECTOR (i, _bi.Bonds)
- {
- RINOK(_streamBinders.AddNew().CreateEvents());
- }
- return S_OK;
-}
-
-void CMixerMT::AddCoder(const CCreatedCoder &cod)
-{
- IsFilter_Vector.Add(cod.IsFilter);
- IsExternal_Vector.Add(cod.IsExternal);
- // const CCoderStreamsInfo &c = _bi.Coders[_coders.Size()];
- CCoderMT &c2 = _coders.AddNew();
- c2.NumStreams = cod.NumStreams;
- c2.Coder = cod.Coder;
- c2.Coder2 = cod.Coder2;
- c2.EncodeMode = EncodeMode;
-}
-
-CCoder &CMixerMT::GetCoder(unsigned index)
-{
- return _coders[index];
-}
-
-void CMixerMT::ReInit()
-{
- FOR_VECTOR (i, _streamBinders)
- _streamBinders[i].ReInit();
-}
-
-void CMixerMT::SelectMainCoder(bool useFirst)
-{
- unsigned ci = _bi.UnpackCoder;
-
- if (!useFirst)
- for (;;)
- {
- if (_coders[ci].NumStreams != 1)
- break;
- if (!IsFilter_Vector[ci])
- break;
-
- UInt32 st = _bi.Coder_to_Stream[ci];
- if (_bi.IsStream_in_PackStreams(st))
- break;
- int bond = _bi.FindBond_for_PackStream(st);
- if (bond < 0)
- throw 20150213;
- ci = _bi.Bonds[bond].UnpackIndex;
- }
-
- MainCoderIndex = ci;
-}
-
-HRESULT CMixerMT::Init(ISequentialInStream * const *inStreams, ISequentialOutStream * const *outStreams)
-{
- unsigned i;
-
- for (i = 0; i < _coders.Size(); i++)
- {
- CCoderMT &coderInfo = _coders[i];
- const CCoderStreamsInfo &csi = _bi.Coders[i];
-
- UInt32 j;
-
- unsigned numInStreams = EncodeMode ? 1 : csi.NumStreams;
- unsigned numOutStreams = EncodeMode ? csi.NumStreams : 1;
-
- coderInfo.InStreams.Clear();
- for (j = 0; j < numInStreams; j++)
- coderInfo.InStreams.AddNew();
-
- coderInfo.OutStreams.Clear();
- for (j = 0; j < numOutStreams; j++)
- coderInfo.OutStreams.AddNew();
- }
-
- for (i = 0; i < _bi.Bonds.Size(); i++)
- {
- const CBond &bond = _bi.Bonds[i];
-
- UInt32 inCoderIndex, inCoderStreamIndex;
- UInt32 outCoderIndex, outCoderStreamIndex;
-
- {
- UInt32 coderIndex, coderStreamIndex;
- _bi.GetCoder_for_Stream(bond.PackIndex, coderIndex, coderStreamIndex);
-
- inCoderIndex = EncodeMode ? bond.UnpackIndex : coderIndex;
- outCoderIndex = EncodeMode ? coderIndex : bond.UnpackIndex;
-
- inCoderStreamIndex = EncodeMode ? 0 : coderStreamIndex;
- outCoderStreamIndex = EncodeMode ? coderStreamIndex : 0;
- }
-
- _streamBinders[i].CreateStreams(
- &_coders[inCoderIndex].InStreams[inCoderStreamIndex],
- &_coders[outCoderIndex].OutStreams[outCoderStreamIndex]);
-
- CMyComPtr<ICompressSetBufSize> inSetSize, outSetSize;
- _coders[inCoderIndex].QueryInterface(IID_ICompressSetBufSize, (void **)&inSetSize);
- _coders[outCoderIndex].QueryInterface(IID_ICompressSetBufSize, (void **)&outSetSize);
- if (inSetSize && outSetSize)
- {
- const UInt32 kBufSize = 1 << 19;
- inSetSize->SetInBufSize(inCoderStreamIndex, kBufSize);
- outSetSize->SetOutBufSize(outCoderStreamIndex, kBufSize);
- }
- }
-
- {
- CCoderMT &cod = _coders[_bi.UnpackCoder];
- if (EncodeMode)
- cod.InStreams[0] = inStreams[0];
- else
- cod.OutStreams[0] = outStreams[0];
- }
-
- for (i = 0; i < _bi.PackStreams.Size(); i++)
- {
- UInt32 coderIndex, coderStreamIndex;
- _bi.GetCoder_for_Stream(_bi.PackStreams[i], coderIndex, coderStreamIndex);
- CCoderMT &cod = _coders[coderIndex];
- if (EncodeMode)
- cod.OutStreams[coderStreamIndex] = outStreams[i];
- else
- cod.InStreams[coderStreamIndex] = inStreams[i];
- }
-
- return S_OK;
-}
-
-HRESULT CMixerMT::ReturnIfError(HRESULT code)
-{
- FOR_VECTOR (i, _coders)
- if (_coders[i].Result == code)
- return code;
- return S_OK;
-}
-
-HRESULT CMixerMT::Code(
- ISequentialInStream * const *inStreams,
- ISequentialOutStream * const *outStreams,
- ICompressProgressInfo *progress,
- bool &dataAfterEnd_Error)
-{
- // InternalPackSizeError = false;
- dataAfterEnd_Error = false;
-
- Init(inStreams, outStreams);
-
- unsigned i;
- for (i = 0; i < _coders.Size(); i++)
- if (i != MainCoderIndex)
- {
- RINOK(_coders[i].Create());
- }
-
- for (i = 0; i < _coders.Size(); i++)
- if (i != MainCoderIndex)
- _coders[i].Start();
-
- _coders[MainCoderIndex].Code(progress);
-
- for (i = 0; i < _coders.Size(); i++)
- if (i != MainCoderIndex)
- _coders[i].WaitExecuteFinish();
-
- RINOK(ReturnIfError(E_ABORT));
- RINOK(ReturnIfError(E_OUTOFMEMORY));
-
- for (i = 0; i < _coders.Size(); i++)
- {
- HRESULT result = _coders[i].Result;
- if (result != S_OK
- && result != k_My_HRESULT_WritingWasCut
- && result != S_FALSE
- && result != E_FAIL)
- return result;
- }
-
- RINOK(ReturnIfError(S_FALSE));
-
- for (i = 0; i < _coders.Size(); i++)
- {
- HRESULT result = _coders[i].Result;
- if (result != S_OK && result != k_My_HRESULT_WritingWasCut)
- return result;
- }
-
- for (i = 0; i < _coders.Size(); i++)
- {
- RINOK(_coders[i].CheckDataAfterEnd(dataAfterEnd_Error /* , InternalPackSizeError */));
- }
-
- return S_OK;
-}
-
-UInt64 CMixerMT::GetBondStreamSize(unsigned bondIndex) const
-{
- return _streamBinders[bondIndex].ProcessedSize;
-}
-
-#endif
-
-}
+// CoderMixer2.cpp
+
+#include "StdAfx.h"
+
+#include "CoderMixer2.h"
+
+#ifdef USE_MIXER_ST
+
+Z7_COM7F_IMF(CSequentialInStreamCalcSize::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessed = 0;
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Read(data, size, &realProcessed);
+ _size += realProcessed;
+ if (size != 0 && realProcessed == 0)
+ _wasFinished = true;
+ if (processedSize)
+ *processedSize = realProcessed;
+ return result;
+}
+
+
+Z7_COM7F_IMF(COutStreamCalcSize::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ _size += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+Z7_COM7F_IMF(COutStreamCalcSize::OutStreamFinish())
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ {
+ CMyComPtr<IOutStreamFinish> outStreamFinish;
+ _stream.QueryInterface(IID_IOutStreamFinish, &outStreamFinish);
+ if (outStreamFinish)
+ result = outStreamFinish->OutStreamFinish();
+ }
+ return result;
+}
+
+#endif
+
+
+
+
+namespace NCoderMixer2 {
+
+static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
+{
+ v.ClearAndSetSize(size);
+ bool *p = &v[0];
+ for (unsigned i = 0; i < size; i++)
+ p[i] = false;
+}
+
+
+HRESULT CCoder::CheckDataAfterEnd(bool &dataAfterEnd_Error /* , bool &InternalPackSizeError */) const
+{
+ if (Coder)
+ {
+ if (PackSizePointers.IsEmpty() || !PackSizePointers[0])
+ return S_OK;
+ CMyComPtr<ICompressGetInStreamProcessedSize> getInStreamProcessedSize;
+ Coder.QueryInterface(IID_ICompressGetInStreamProcessedSize, (void **)&getInStreamProcessedSize);
+ // if (!getInStreamProcessedSize) return E_FAIL;
+ if (getInStreamProcessedSize)
+ {
+ UInt64 processed;
+ RINOK(getInStreamProcessedSize->GetInStreamProcessedSize(&processed))
+ if (processed != (UInt64)(Int64)-1)
+ {
+ const UInt64 size = PackSizes[0];
+ if (processed < size && Finish)
+ dataAfterEnd_Error = true;
+ if (processed > size)
+ {
+ // InternalPackSizeError = true;
+ // return S_FALSE;
+ }
+ }
+ }
+ }
+ else if (Coder2)
+ {
+ CMyComPtr<ICompressGetInStreamProcessedSize2> getInStreamProcessedSize2;
+ Coder2.QueryInterface(IID_ICompressGetInStreamProcessedSize2, (void **)&getInStreamProcessedSize2);
+ if (getInStreamProcessedSize2)
+ FOR_VECTOR (i, PackSizePointers)
+ {
+ if (!PackSizePointers[i])
+ continue;
+ UInt64 processed;
+ RINOK(getInStreamProcessedSize2->GetInStreamProcessedSize2(i, &processed))
+ if (processed != (UInt64)(Int64)-1)
+ {
+ const UInt64 size = PackSizes[i];
+ if (processed < size && Finish)
+ dataAfterEnd_Error = true;
+ else if (processed > size)
+ {
+ // InternalPackSizeError = true;
+ // return S_FALSE;
+ }
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+class CBondsChecks
+{
+ CBoolVector _coderUsed;
+
+ bool Init();
+ bool CheckCoder(unsigned coderIndex);
+public:
+ const CBindInfo *BindInfo;
+
+ bool Check();
+};
+
+bool CBondsChecks::CheckCoder(unsigned coderIndex)
+{
+ const CCoderStreamsInfo &coder = BindInfo->Coders[coderIndex];
+
+ if (coderIndex >= _coderUsed.Size() || _coderUsed[coderIndex])
+ return false;
+ _coderUsed[coderIndex] = true;
+
+ const UInt32 start = BindInfo->Coder_to_Stream[coderIndex];
+
+ for (unsigned i = 0; i < coder.NumStreams; i++)
+ {
+ UInt32 ind = start + i;
+
+ if (BindInfo->IsStream_in_PackStreams(ind))
+ continue;
+
+ const int bond = BindInfo->FindBond_for_PackStream(ind);
+ if (bond < 0)
+ return false;
+ if (!CheckCoder(BindInfo->Bonds[(unsigned)bond].UnpackIndex))
+ return false;
+ }
+
+ return true;
+}
+
+bool CBondsChecks::Check()
+{
+ BoolVector_Fill_False(_coderUsed, BindInfo->Coders.Size());
+
+ if (!CheckCoder(BindInfo->UnpackCoder))
+ return false;
+
+ FOR_VECTOR(i, _coderUsed)
+ if (!_coderUsed[i])
+ return false;
+
+ return true;
+}
+
+void CBindInfo::ClearMaps()
+{
+ Coder_to_Stream.Clear();
+ Stream_to_Coder.Clear();
+}
+
+bool CBindInfo::CalcMapsAndCheck()
+{
+ ClearMaps();
+
+ UInt32 numStreams = 0;
+
+ if (Coders.Size() == 0)
+ return false;
+ if (Coders.Size() - 1 != Bonds.Size())
+ return false;
+
+ FOR_VECTOR(i, Coders)
+ {
+ Coder_to_Stream.Add(numStreams);
+
+ const CCoderStreamsInfo &c = Coders[i];
+
+ for (unsigned j = 0; j < c.NumStreams; j++)
+ Stream_to_Coder.Add(i);
+
+ numStreams += c.NumStreams;
+ }
+
+ if (numStreams != GetNum_Bonds_and_PackStreams())
+ return false;
+
+ CBondsChecks bc;
+ bc.BindInfo = this;
+ return bc.Check();
+}
+
+
+void CCoder::SetCoderInfo(const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
+{
+ Finish = finish;
+
+ if (unpackSize)
+ {
+ UnpackSize = *unpackSize;
+ UnpackSizePointer = &UnpackSize;
+ }
+ else
+ {
+ UnpackSize = 0;
+ UnpackSizePointer = NULL;
+ }
+
+ PackSizes.ClearAndSetSize((unsigned)NumStreams);
+ PackSizePointers.ClearAndSetSize((unsigned)NumStreams);
+
+ for (unsigned i = 0; i < NumStreams; i++)
+ {
+ if (packSizes && packSizes[i])
+ {
+ PackSizes[i] = *(packSizes[i]);
+ PackSizePointers[i] = &PackSizes[i];
+ }
+ else
+ {
+ PackSizes[i] = 0;
+ PackSizePointers[i] = NULL;
+ }
+ }
+}
+
+bool CMixer::Is_UnpackSize_Correct_for_Coder(UInt32 coderIndex)
+{
+ if (coderIndex == _bi.UnpackCoder)
+ return true;
+
+ const int bond = _bi.FindBond_for_UnpackStream(coderIndex);
+ if (bond < 0)
+ throw 20150213;
+
+ /*
+ UInt32 coderIndex, coderStreamIndex;
+ _bi.GetCoder_for_Stream(_bi.Bonds[(unsigned)bond].PackIndex, coderIndex, coderStreamIndex);
+ */
+ const UInt32 nextCoder = _bi.Stream_to_Coder[_bi.Bonds[(unsigned)bond].PackIndex];
+
+ if (!IsFilter_Vector[nextCoder])
+ return false;
+
+ return Is_UnpackSize_Correct_for_Coder(nextCoder);
+}
+
+bool CMixer::Is_PackSize_Correct_for_Stream(UInt32 streamIndex)
+{
+ if (_bi.IsStream_in_PackStreams(streamIndex))
+ return true;
+
+ const int bond = _bi.FindBond_for_PackStream(streamIndex);
+ if (bond < 0)
+ throw 20150213;
+
+ const UInt32 nextCoder = _bi.Bonds[(unsigned)bond].UnpackIndex;
+
+ if (!IsFilter_Vector[nextCoder])
+ return false;
+
+ return Is_PackSize_Correct_for_Coder(nextCoder);
+}
+
+bool CMixer::Is_PackSize_Correct_for_Coder(UInt32 coderIndex)
+{
+ const UInt32 startIndex = _bi.Coder_to_Stream[coderIndex];
+ const UInt32 numStreams = _bi.Coders[coderIndex].NumStreams;
+ for (UInt32 i = 0; i < numStreams; i++)
+ if (!Is_PackSize_Correct_for_Stream(startIndex + i))
+ return false;
+ return true;
+}
+
+bool CMixer::IsThere_ExternalCoder_in_PackTree(UInt32 coderIndex)
+{
+ if (IsExternal_Vector[coderIndex])
+ return true;
+ const UInt32 startIndex = _bi.Coder_to_Stream[coderIndex];
+ const UInt32 numStreams = _bi.Coders[coderIndex].NumStreams;
+ for (UInt32 i = 0; i < numStreams; i++)
+ {
+ const UInt32 si = startIndex + i;
+ if (_bi.IsStream_in_PackStreams(si))
+ continue;
+
+ const int bond = _bi.FindBond_for_PackStream(si);
+ if (bond < 0)
+ throw 20150213;
+
+ if (IsThere_ExternalCoder_in_PackTree(_bi.Bonds[(unsigned)bond].UnpackIndex))
+ return true;
+ }
+ return false;
+}
+
+
+
+
+#ifdef USE_MIXER_ST
+
+CMixerST::CMixerST(bool encodeMode):
+ CMixer(encodeMode)
+ {}
+
+CMixerST::~CMixerST() {}
+
+void CMixerST::AddCoder(const CCreatedCoder &cod)
+{
+ IsFilter_Vector.Add(cod.IsFilter);
+ IsExternal_Vector.Add(cod.IsExternal);
+ // const CCoderStreamsInfo &c = _bi.Coders[_coders.Size()];
+ CCoderST &c2 = _coders.AddNew();
+ c2.NumStreams = cod.NumStreams;
+ c2.Coder = cod.Coder;
+ c2.Coder2 = cod.Coder2;
+
+ /*
+ if (isFilter)
+ {
+ c2.CanRead = true;
+ c2.CanWrite = true;
+ }
+ else
+ */
+ {
+ IUnknown *unk = (cod.Coder ? (IUnknown *)cod.Coder : (IUnknown *)cod.Coder2);
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(ISequentialInStream, s, unk)
+ c2.CanRead = (s != NULL);
+ }
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(ISequentialOutStream, s, unk)
+ c2.CanWrite = (s != NULL);
+ }
+ }
+}
+
+CCoder &CMixerST::GetCoder(unsigned index)
+{
+ return _coders[index];
+}
+
+HRESULT CMixerST::ReInit2() { return S_OK; }
+
+HRESULT CMixerST::GetInStream2(
+ ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
+ UInt32 outStreamIndex, ISequentialInStream **inStreamRes)
+{
+ UInt32 coderIndex = outStreamIndex, coderStreamIndex = 0;
+
+ if (EncodeMode)
+ {
+ _bi.GetCoder_for_Stream(outStreamIndex, coderIndex, coderStreamIndex);
+ if (coderStreamIndex != 0)
+ return E_NOTIMPL;
+ }
+
+ const CCoder &coder = _coders[coderIndex];
+
+ CMyComPtr<ISequentialInStream> seqInStream;
+ coder.QueryInterface(IID_ISequentialInStream, (void **)&seqInStream);
+ if (!seqInStream)
+ return E_NOTIMPL;
+
+ const UInt32 numInStreams = EncodeMode ? 1 : coder.NumStreams;
+ const UInt32 startIndex = EncodeMode ? coderIndex : _bi.Coder_to_Stream[coderIndex];
+
+ bool isSet = false;
+
+ if (numInStreams == 1)
+ {
+ CMyComPtr<ICompressSetInStream> setStream;
+ coder.QueryInterface(IID_ICompressSetInStream, (void **)&setStream);
+ if (setStream)
+ {
+ CMyComPtr<ISequentialInStream> seqInStream2;
+ RINOK(GetInStream(inStreams, /* inSizes, */ startIndex + 0, &seqInStream2))
+ RINOK(setStream->SetInStream(seqInStream2))
+ isSet = true;
+ }
+ }
+
+ if (!isSet && numInStreams != 0)
+ {
+ CMyComPtr<ICompressSetInStream2> setStream2;
+ coder.QueryInterface(IID_ICompressSetInStream2, (void **)&setStream2);
+ if (!setStream2)
+ return E_NOTIMPL;
+
+ for (UInt32 i = 0; i < numInStreams; i++)
+ {
+ CMyComPtr<ISequentialInStream> seqInStream2;
+ RINOK(GetInStream(inStreams, /* inSizes, */ startIndex + i, &seqInStream2))
+ RINOK(setStream2->SetInStream2(i, seqInStream2))
+ }
+ }
+
+ *inStreamRes = seqInStream.Detach();
+ return S_OK;
+}
+
+
+HRESULT CMixerST::GetInStream(
+ ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
+ UInt32 inStreamIndex, ISequentialInStream **inStreamRes)
+{
+ CMyComPtr<ISequentialInStream> seqInStream;
+
+ {
+ int index = -1;
+ if (EncodeMode)
+ {
+ if (_bi.UnpackCoder == inStreamIndex)
+ index = 0;
+ }
+ else
+ index = _bi.FindStream_in_PackStreams(inStreamIndex);
+
+ if (index >= 0)
+ {
+ seqInStream = inStreams[(unsigned)index];
+ *inStreamRes = seqInStream.Detach();
+ return S_OK;
+ }
+ }
+
+ const int bond = FindBond_for_Stream(
+ true, // forInputStream
+ inStreamIndex);
+ if (bond < 0)
+ return E_INVALIDARG;
+
+ RINOK(GetInStream2(inStreams, /* inSizes, */
+ _bi.Bonds[(unsigned)bond].Get_OutIndex(EncodeMode), &seqInStream))
+
+ while (_binderStreams.Size() <= (unsigned)bond)
+ _binderStreams.AddNew();
+ CStBinderStream &bs = _binderStreams[(unsigned)bond];
+
+ if (bs.StreamRef || bs.InStreamSpec)
+ return E_NOTIMPL;
+
+ CSequentialInStreamCalcSize *spec = new CSequentialInStreamCalcSize;
+ bs.StreamRef = spec;
+ bs.InStreamSpec = spec;
+
+ spec->SetStream(seqInStream);
+ spec->Init();
+
+ seqInStream = bs.InStreamSpec;
+
+ *inStreamRes = seqInStream.Detach();
+ return S_OK;
+}
+
+
+HRESULT CMixerST::GetOutStream(
+ ISequentialOutStream * const *outStreams, /* const UInt64 * const *outSizes, */
+ UInt32 outStreamIndex, ISequentialOutStream **outStreamRes)
+{
+ CMyComPtr<ISequentialOutStream> seqOutStream;
+
+ {
+ int index = -1;
+ if (!EncodeMode)
+ {
+ if (_bi.UnpackCoder == outStreamIndex)
+ index = 0;
+ }
+ else
+ index = _bi.FindStream_in_PackStreams(outStreamIndex);
+
+ if (index >= 0)
+ {
+ seqOutStream = outStreams[(unsigned)index];
+ *outStreamRes = seqOutStream.Detach();
+ return S_OK;
+ }
+ }
+
+ const int bond = FindBond_for_Stream(
+ false, // forInputStream
+ outStreamIndex);
+ if (bond < 0)
+ return E_INVALIDARG;
+
+ const UInt32 inStreamIndex = _bi.Bonds[(unsigned)bond].Get_InIndex(EncodeMode);
+
+ UInt32 coderIndex = inStreamIndex;
+ UInt32 coderStreamIndex = 0;
+
+ if (!EncodeMode)
+ _bi.GetCoder_for_Stream(inStreamIndex, coderIndex, coderStreamIndex);
+
+ CCoder &coder = _coders[coderIndex];
+
+ /*
+ if (!coder.Coder)
+ return E_NOTIMPL;
+ */
+
+ coder.QueryInterface(IID_ISequentialOutStream, (void **)&seqOutStream);
+ if (!seqOutStream)
+ return E_NOTIMPL;
+
+ const UInt32 numOutStreams = EncodeMode ? coder.NumStreams : 1;
+ const UInt32 startIndex = EncodeMode ? _bi.Coder_to_Stream[coderIndex]: coderIndex;
+
+ bool isSet = false;
+
+ if (numOutStreams == 1)
+ {
+ CMyComPtr<ICompressSetOutStream> setOutStream;
+ coder.Coder.QueryInterface(IID_ICompressSetOutStream, &setOutStream);
+ if (setOutStream)
+ {
+ CMyComPtr<ISequentialOutStream> seqOutStream2;
+ RINOK(GetOutStream(outStreams, /* outSizes, */ startIndex + 0, &seqOutStream2))
+ RINOK(setOutStream->SetOutStream(seqOutStream2))
+ isSet = true;
+ }
+ }
+
+ if (!isSet && numOutStreams != 0)
+ {
+ return E_NOTIMPL;
+ /*
+ CMyComPtr<ICompressSetOutStream2> setStream2;
+ coder.QueryInterface(IID_ICompressSetOutStream2, (void **)&setStream2);
+ if (!setStream2)
+ return E_NOTIMPL;
+ for (UInt32 i = 0; i < numOutStreams; i++)
+ {
+ CMyComPtr<ISequentialOutStream> seqOutStream2;
+ RINOK(GetOutStream(outStreams, startIndex + i, &seqOutStream2))
+ RINOK(setStream2->SetOutStream2(i, seqOutStream2))
+ }
+ */
+ }
+
+ while (_binderStreams.Size() <= (unsigned)bond)
+ _binderStreams.AddNew();
+ CStBinderStream &bs = _binderStreams[(unsigned)bond];
+
+ if (bs.StreamRef || bs.OutStreamSpec)
+ return E_NOTIMPL;
+
+ COutStreamCalcSize *spec = new COutStreamCalcSize;
+ bs.StreamRef = (ISequentialOutStream *)spec;
+ bs.OutStreamSpec = spec;
+
+ spec->SetStream(seqOutStream);
+ spec->Init();
+
+ seqOutStream = bs.OutStreamSpec;
+
+ *outStreamRes = seqOutStream.Detach();
+ return S_OK;
+}
+
+
+static HRESULT GetError(HRESULT res, HRESULT res2)
+{
+ if (res == res2)
+ return res;
+ if (res == S_OK)
+ return res2;
+ if (res == k_My_HRESULT_WritingWasCut)
+ {
+ if (res2 != S_OK)
+ return res2;
+ }
+ return res;
+}
+
+
+HRESULT CMixerST::FinishStream(UInt32 streamIndex)
+{
+ {
+ int index = -1;
+ if (!EncodeMode)
+ {
+ if (_bi.UnpackCoder == streamIndex)
+ index = 0;
+ }
+ else
+ index = _bi.FindStream_in_PackStreams(streamIndex);
+
+ if (index >= 0)
+ return S_OK;
+ }
+
+ const int bond = FindBond_for_Stream(
+ false, // forInputStream
+ streamIndex);
+ if (bond < 0)
+ return E_INVALIDARG;
+
+ const UInt32 inStreamIndex = _bi.Bonds[(unsigned)bond].Get_InIndex(EncodeMode);
+
+ UInt32 coderIndex = inStreamIndex;
+ UInt32 coderStreamIndex = 0;
+ if (!EncodeMode)
+ _bi.GetCoder_for_Stream(inStreamIndex, coderIndex, coderStreamIndex);
+
+ CCoder &coder = _coders[coderIndex];
+ CMyComPtr<IOutStreamFinish> finish;
+ coder.QueryInterface(IID_IOutStreamFinish, (void **)&finish);
+ HRESULT res = S_OK;
+ if (finish)
+ {
+ res = finish->OutStreamFinish();
+ }
+ return GetError(res, FinishCoder(coderIndex));
+}
+
+
+HRESULT CMixerST::FinishCoder(UInt32 coderIndex)
+{
+ CCoder &coder = _coders[coderIndex];
+
+ const UInt32 numOutStreams = EncodeMode ? coder.NumStreams : 1;
+ const UInt32 startIndex = EncodeMode ? _bi.Coder_to_Stream[coderIndex]: coderIndex;
+
+ HRESULT res = S_OK;
+ for (unsigned i = 0; i < numOutStreams; i++)
+ res = GetError(res, FinishStream(startIndex + i));
+ return res;
+}
+
+
+void CMixerST::SelectMainCoder(bool useFirst)
+{
+ unsigned ci = _bi.UnpackCoder;
+
+ int firstNonFilter = -1;
+ unsigned firstAllowed = ci;
+
+ for (;;)
+ {
+ const CCoderST &coder = _coders[ci];
+ // break;
+
+ if (ci != _bi.UnpackCoder)
+ if (EncodeMode ? !coder.CanWrite : !coder.CanRead)
+ {
+ firstAllowed = ci;
+ firstNonFilter = -2;
+ }
+
+ if (coder.NumStreams != 1)
+ break;
+
+ const UInt32 st = _bi.Coder_to_Stream[ci];
+ if (_bi.IsStream_in_PackStreams(st))
+ break;
+ const int bond = _bi.FindBond_for_PackStream(st);
+ if (bond < 0)
+ throw 20150213;
+
+ if (EncodeMode ? !coder.CanRead : !coder.CanWrite)
+ break;
+
+ if (firstNonFilter == -1 && !IsFilter_Vector[ci])
+ firstNonFilter = (int)ci;
+
+ ci = _bi.Bonds[(unsigned)bond].UnpackIndex;
+ }
+
+ if (useFirst)
+ ci = firstAllowed;
+ else if (firstNonFilter >= 0)
+ ci = (unsigned)firstNonFilter;
+
+ MainCoderIndex = ci;
+}
+
+
+HRESULT CMixerST::Code(
+ ISequentialInStream * const *inStreams,
+ ISequentialOutStream * const *outStreams,
+ ICompressProgressInfo *progress,
+ bool &dataAfterEnd_Error)
+{
+ // InternalPackSizeError = false;
+ dataAfterEnd_Error = false;
+
+ _binderStreams.Clear();
+ const unsigned ci = MainCoderIndex;
+
+ const CCoder &mainCoder = _coders[MainCoderIndex];
+
+ CObjectVector< CMyComPtr<ISequentialInStream> > seqInStreams;
+ CObjectVector< CMyComPtr<ISequentialOutStream> > seqOutStreams;
+
+ const UInt32 numInStreams = EncodeMode ? 1 : mainCoder.NumStreams;
+ const UInt32 numOutStreams = !EncodeMode ? 1 : mainCoder.NumStreams;
+
+ const UInt32 startInIndex = EncodeMode ? ci : _bi.Coder_to_Stream[ci];
+ const UInt32 startOutIndex = !EncodeMode ? ci : _bi.Coder_to_Stream[ci];
+
+ UInt32 i;
+
+ for (i = 0; i < numInStreams; i++)
+ {
+ CMyComPtr<ISequentialInStream> seqInStream;
+ RINOK(GetInStream(inStreams, /* inSizes, */ startInIndex + i, &seqInStream))
+ seqInStreams.Add(seqInStream);
+ }
+
+ for (i = 0; i < numOutStreams; i++)
+ {
+ CMyComPtr<ISequentialOutStream> seqOutStream;
+ RINOK(GetOutStream(outStreams, /* outSizes, */ startOutIndex + i, &seqOutStream))
+ seqOutStreams.Add(seqOutStream);
+ }
+
+ CRecordVector< ISequentialInStream * > seqInStreamsSpec;
+ CRecordVector< ISequentialOutStream * > seqOutStreamsSpec;
+
+ for (i = 0; i < numInStreams; i++)
+ seqInStreamsSpec.Add(seqInStreams[i]);
+ for (i = 0; i < numOutStreams; i++)
+ seqOutStreamsSpec.Add(seqOutStreams[i]);
+
+ for (i = 0; i < _coders.Size(); i++)
+ {
+ if (i == ci)
+ continue;
+
+ CCoder &coder = _coders[i];
+
+ if (EncodeMode)
+ {
+ CMyComPtr<ICompressInitEncoder> initEncoder;
+ coder.QueryInterface(IID_ICompressInitEncoder, (void **)&initEncoder);
+ if (initEncoder)
+ {
+ RINOK(initEncoder->InitEncoder())
+ }
+ }
+ else
+ {
+ CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
+ coder.QueryInterface(IID_ICompressSetOutStreamSize, (void **)&setOutStreamSize);
+ if (setOutStreamSize)
+ {
+ RINOK(setOutStreamSize->SetOutStreamSize(
+ EncodeMode ? coder.PackSizePointers[0] : coder.UnpackSizePointer))
+ }
+ }
+ }
+
+ const UInt64 * const *isSizes2 = EncodeMode ? &mainCoder.UnpackSizePointer : &mainCoder.PackSizePointers.Front();
+ const UInt64 * const *outSizes2 = EncodeMode ? &mainCoder.PackSizePointers.Front() : &mainCoder.UnpackSizePointer;
+
+ HRESULT res;
+ if (mainCoder.Coder)
+ {
+ res = mainCoder.Coder->Code(
+ seqInStreamsSpec[0], seqOutStreamsSpec[0],
+ isSizes2[0], outSizes2[0],
+ progress);
+ }
+ else
+ {
+ res = mainCoder.Coder2->Code(
+ &seqInStreamsSpec.Front(), isSizes2, numInStreams,
+ &seqOutStreamsSpec.Front(), outSizes2, numOutStreams,
+ progress);
+ }
+
+ if (res == k_My_HRESULT_WritingWasCut)
+ res = S_OK;
+
+ if (res == S_OK || res == S_FALSE)
+ {
+ res = GetError(res, FinishCoder(ci));
+ }
+
+ for (i = 0; i < _binderStreams.Size(); i++)
+ {
+ const CStBinderStream &bs = _binderStreams[i];
+ if (bs.InStreamSpec)
+ bs.InStreamSpec->ReleaseStream();
+ else
+ bs.OutStreamSpec->ReleaseStream();
+ }
+
+ if (res == k_My_HRESULT_WritingWasCut)
+ res = S_OK;
+
+ if (res != S_OK)
+ return res;
+
+ for (i = 0; i < _coders.Size(); i++)
+ {
+ RINOK(_coders[i].CheckDataAfterEnd(dataAfterEnd_Error /*, InternalPackSizeError */))
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CMixerST::GetMainUnpackStream(
+ ISequentialInStream * const *inStreams,
+ ISequentialInStream **inStreamRes)
+{
+ CMyComPtr<ISequentialInStream> seqInStream;
+
+ RINOK(GetInStream2(inStreams, /* inSizes, */
+ _bi.UnpackCoder, &seqInStream))
+
+ FOR_VECTOR (i, _coders)
+ {
+ CCoder &coder = _coders[i];
+ CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
+ coder.QueryInterface(IID_ICompressSetOutStreamSize, (void **)&setOutStreamSize);
+ if (setOutStreamSize)
+ {
+ RINOK(setOutStreamSize->SetOutStreamSize(coder.UnpackSizePointer))
+ }
+ }
+
+ *inStreamRes = seqInStream.Detach();
+ return S_OK;
+}
+
+
+UInt64 CMixerST::GetBondStreamSize(unsigned bondIndex) const
+{
+ const CStBinderStream &bs = _binderStreams[bondIndex];
+ if (bs.InStreamSpec)
+ return bs.InStreamSpec->GetSize();
+ return bs.OutStreamSpec->GetSize();
+}
+
+#endif
+
+
+
+
+
+
+#ifdef USE_MIXER_MT
+
+
+void CCoderMT::Execute()
+{
+ try
+ {
+ Code(NULL);
+ }
+ catch(...)
+ {
+ Result = E_FAIL;
+ }
+}
+
+void CCoderMT::Code(ICompressProgressInfo *progress)
+{
+ unsigned numInStreams = EncodeMode ? 1 : NumStreams;
+ unsigned numOutStreams = EncodeMode ? NumStreams : 1;
+
+ InStreamPointers.ClearAndReserve(numInStreams);
+ OutStreamPointers.ClearAndReserve(numOutStreams);
+
+ unsigned i;
+
+ for (i = 0; i < numInStreams; i++)
+ InStreamPointers.AddInReserved((ISequentialInStream *)InStreams[i]);
+
+ for (i = 0; i < numOutStreams; i++)
+ OutStreamPointers.AddInReserved((ISequentialOutStream *)OutStreams[i]);
+
+ // we suppose that UnpackSizePointer and PackSizePointers contain correct pointers.
+ /*
+ if (UnpackSizePointer)
+ UnpackSizePointer = &UnpackSize;
+ for (i = 0; i < NumStreams; i++)
+ if (PackSizePointers[i])
+ PackSizePointers[i] = &PackSizes[i];
+ */
+
+ CReleaser releaser(*this);
+
+ if (Coder)
+ Result = Coder->Code(InStreamPointers[0], OutStreamPointers[0],
+ EncodeMode ? UnpackSizePointer : PackSizePointers[0],
+ EncodeMode ? PackSizePointers[0] : UnpackSizePointer,
+ progress);
+ else
+ Result = Coder2->Code(
+ &InStreamPointers.Front(), EncodeMode ? &UnpackSizePointer : &PackSizePointers.Front(), numInStreams,
+ &OutStreamPointers.Front(), EncodeMode ? &PackSizePointers.Front(): &UnpackSizePointer, numOutStreams,
+ progress);
+}
+
+HRESULT CMixerMT::SetBindInfo(const CBindInfo &bindInfo)
+{
+ CMixer::SetBindInfo(bindInfo);
+
+ _streamBinders.Clear();
+ FOR_VECTOR (i, _bi.Bonds)
+ {
+ // RINOK(_streamBinders.AddNew().CreateEvents())
+ _streamBinders.AddNew();
+ }
+ return S_OK;
+}
+
+void CMixerMT::AddCoder(const CCreatedCoder &cod)
+{
+ IsFilter_Vector.Add(cod.IsFilter);
+ IsExternal_Vector.Add(cod.IsExternal);
+ // const CCoderStreamsInfo &c = _bi.Coders[_coders.Size()];
+ CCoderMT &c2 = _coders.AddNew();
+ c2.NumStreams = cod.NumStreams;
+ c2.Coder = cod.Coder;
+ c2.Coder2 = cod.Coder2;
+ c2.EncodeMode = EncodeMode;
+}
+
+CCoder &CMixerMT::GetCoder(unsigned index)
+{
+ return _coders[index];
+}
+
+HRESULT CMixerMT::ReInit2()
+{
+ FOR_VECTOR (i, _streamBinders)
+ {
+ RINOK(_streamBinders[i].Create_ReInit())
+ }
+ return S_OK;
+}
+
+void CMixerMT::SelectMainCoder(bool useFirst)
+{
+ unsigned ci = _bi.UnpackCoder;
+
+ if (!useFirst)
+ for (;;)
+ {
+ if (_coders[ci].NumStreams != 1)
+ break;
+ if (!IsFilter_Vector[ci])
+ break;
+
+ UInt32 st = _bi.Coder_to_Stream[ci];
+ if (_bi.IsStream_in_PackStreams(st))
+ break;
+ const int bond = _bi.FindBond_for_PackStream(st);
+ if (bond < 0)
+ throw 20150213;
+ ci = _bi.Bonds[(unsigned)bond].UnpackIndex;
+ }
+
+ MainCoderIndex = ci;
+}
+
+HRESULT CMixerMT::Init(ISequentialInStream * const *inStreams, ISequentialOutStream * const *outStreams)
+{
+ unsigned i;
+
+ for (i = 0; i < _coders.Size(); i++)
+ {
+ CCoderMT &coderInfo = _coders[i];
+ const CCoderStreamsInfo &csi = _bi.Coders[i];
+
+ UInt32 j;
+
+ const unsigned numInStreams = EncodeMode ? 1 : csi.NumStreams;
+ const unsigned numOutStreams = EncodeMode ? csi.NumStreams : 1;
+
+ coderInfo.InStreams.Clear();
+ for (j = 0; j < numInStreams; j++)
+ coderInfo.InStreams.AddNew();
+
+ coderInfo.OutStreams.Clear();
+ for (j = 0; j < numOutStreams; j++)
+ coderInfo.OutStreams.AddNew();
+ }
+
+ for (i = 0; i < _bi.Bonds.Size(); i++)
+ {
+ const CBond &bond = _bi.Bonds[i];
+
+ UInt32 inCoderIndex, inCoderStreamIndex;
+ UInt32 outCoderIndex, outCoderStreamIndex;
+
+ {
+ UInt32 coderIndex, coderStreamIndex;
+ _bi.GetCoder_for_Stream(bond.PackIndex, coderIndex, coderStreamIndex);
+
+ inCoderIndex = EncodeMode ? bond.UnpackIndex : coderIndex;
+ outCoderIndex = EncodeMode ? coderIndex : bond.UnpackIndex;
+
+ inCoderStreamIndex = EncodeMode ? 0 : coderStreamIndex;
+ outCoderStreamIndex = EncodeMode ? coderStreamIndex : 0;
+ }
+
+ _streamBinders[i].CreateStreams2(
+ _coders[inCoderIndex].InStreams[inCoderStreamIndex],
+ _coders[outCoderIndex].OutStreams[outCoderStreamIndex]);
+
+ CMyComPtr<ICompressSetBufSize> inSetSize, outSetSize;
+ _coders[inCoderIndex].QueryInterface(IID_ICompressSetBufSize, (void **)&inSetSize);
+ _coders[outCoderIndex].QueryInterface(IID_ICompressSetBufSize, (void **)&outSetSize);
+ if (inSetSize && outSetSize)
+ {
+ const UInt32 kBufSize = 1 << 19;
+ inSetSize->SetInBufSize(inCoderStreamIndex, kBufSize);
+ outSetSize->SetOutBufSize(outCoderStreamIndex, kBufSize);
+ }
+ }
+
+ {
+ CCoderMT &cod = _coders[_bi.UnpackCoder];
+ if (EncodeMode)
+ cod.InStreams[0] = inStreams[0];
+ else
+ cod.OutStreams[0] = outStreams[0];
+ }
+
+ for (i = 0; i < _bi.PackStreams.Size(); i++)
+ {
+ UInt32 coderIndex, coderStreamIndex;
+ _bi.GetCoder_for_Stream(_bi.PackStreams[i], coderIndex, coderStreamIndex);
+ CCoderMT &cod = _coders[coderIndex];
+ if (EncodeMode)
+ cod.OutStreams[coderStreamIndex] = outStreams[i];
+ else
+ cod.InStreams[coderStreamIndex] = inStreams[i];
+ }
+
+ return S_OK;
+}
+
+HRESULT CMixerMT::ReturnIfError(HRESULT code)
+{
+ FOR_VECTOR (i, _coders)
+ if (_coders[i].Result == code)
+ return code;
+ return S_OK;
+}
+
+HRESULT CMixerMT::Code(
+ ISequentialInStream * const *inStreams,
+ ISequentialOutStream * const *outStreams,
+ ICompressProgressInfo *progress,
+ bool &dataAfterEnd_Error)
+{
+ // InternalPackSizeError = false;
+ dataAfterEnd_Error = false;
+
+ Init(inStreams, outStreams);
+
+ unsigned i;
+ for (i = 0; i < _coders.Size(); i++)
+ if (i != MainCoderIndex)
+ {
+ const WRes wres = _coders[i].Create();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ for (i = 0; i < _coders.Size(); i++)
+ if (i != MainCoderIndex)
+ {
+ const WRes wres = _coders[i].Start();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ _coders[MainCoderIndex].Code(progress);
+
+ WRes wres = 0;
+ for (i = 0; i < _coders.Size(); i++)
+ if (i != MainCoderIndex)
+ {
+ WRes wres2 = _coders[i].WaitExecuteFinish();
+ if (wres == 0)
+ wres = wres2;
+ }
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+
+ RINOK(ReturnIfError(E_ABORT))
+ RINOK(ReturnIfError(E_OUTOFMEMORY))
+
+ for (i = 0; i < _coders.Size(); i++)
+ {
+ HRESULT result = _coders[i].Result;
+ if (result != S_OK
+ && result != k_My_HRESULT_WritingWasCut
+ && result != S_FALSE
+ && result != E_FAIL)
+ return result;
+ }
+
+ RINOK(ReturnIfError(S_FALSE))
+
+ for (i = 0; i < _coders.Size(); i++)
+ {
+ HRESULT result = _coders[i].Result;
+ if (result != S_OK && result != k_My_HRESULT_WritingWasCut)
+ return result;
+ }
+
+ for (i = 0; i < _coders.Size(); i++)
+ {
+ RINOK(_coders[i].CheckDataAfterEnd(dataAfterEnd_Error /* , InternalPackSizeError */))
+ }
+
+ return S_OK;
+}
+
+UInt64 CMixerMT::GetBondStreamSize(unsigned bondIndex) const
+{
+ return _streamBinders[bondIndex].ProcessedSize;
+}
+
+#endif
+
+}
diff --git a/CPP/7zip/Archive/Common/CoderMixer2.h b/CPP/7zip/Archive/Common/CoderMixer2.h
index 4bd6418..484a608 100644
--- a/CPP/7zip/Archive/Common/CoderMixer2.h
+++ b/CPP/7zip/Archive/Common/CoderMixer2.h
@@ -1,447 +1,447 @@
-// CoderMixer2.h
-
-#ifndef __CODER_MIXER2_H
-#define __CODER_MIXER2_H
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/MyVector.h"
-
-#include "../../ICoder.h"
-
-#include "../../Common/CreateCoder.h"
-
-#ifdef _7ZIP_ST
- #define USE_MIXER_ST
-#else
- #define USE_MIXER_MT
- #ifndef _SFX
- #define USE_MIXER_ST
- #endif
-#endif
-
-#ifdef USE_MIXER_MT
-#include "../../Common/StreamBinder.h"
-#include "../../Common/VirtThread.h"
-#endif
-
-
-
-#ifdef USE_MIXER_ST
-
-class CSequentialInStreamCalcSize:
- public ISequentialInStream,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(ISequentialInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-private:
- CMyComPtr<ISequentialInStream> _stream;
- UInt64 _size;
- bool _wasFinished;
-public:
- void SetStream(ISequentialInStream *stream) { _stream = stream; }
- void Init()
- {
- _size = 0;
- _wasFinished = false;
- }
- void ReleaseStream() { _stream.Release(); }
- UInt64 GetSize() const { return _size; }
- bool WasFinished() const { return _wasFinished; }
-};
-
-
-class COutStreamCalcSize:
- public ISequentialOutStream,
- public IOutStreamFinish,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
- UInt64 _size;
-public:
- MY_UNKNOWN_IMP2(ISequentialOutStream, IOutStreamFinish)
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(OutStreamFinish)();
-
- void SetStream(ISequentialOutStream *stream) { _stream = stream; }
- void ReleaseStream() { _stream.Release(); }
- void Init() { _size = 0; }
- UInt64 GetSize() const { return _size; }
-};
-
-#endif
-
-
-
-namespace NCoderMixer2 {
-
-struct CBond
-{
- UInt32 PackIndex;
- UInt32 UnpackIndex;
-
- UInt32 Get_InIndex(bool encodeMode) const { return encodeMode ? UnpackIndex : PackIndex; }
- UInt32 Get_OutIndex(bool encodeMode) const { return encodeMode ? PackIndex : UnpackIndex; }
-};
-
-
-struct CCoderStreamsInfo
-{
- UInt32 NumStreams;
-};
-
-
-struct CBindInfo
-{
- CRecordVector<CCoderStreamsInfo> Coders;
- CRecordVector<CBond> Bonds;
- CRecordVector<UInt32> PackStreams;
- unsigned UnpackCoder;
-
- unsigned GetNum_Bonds_and_PackStreams() const { return Bonds.Size() + PackStreams.Size(); }
-
- int FindBond_for_PackStream(UInt32 packStream) const
- {
- FOR_VECTOR (i, Bonds)
- if (Bonds[i].PackIndex == packStream)
- return i;
- return -1;
- }
-
- int FindBond_for_UnpackStream(UInt32 unpackStream) const
- {
- FOR_VECTOR (i, Bonds)
- if (Bonds[i].UnpackIndex == unpackStream)
- return i;
- return -1;
- }
-
- bool SetUnpackCoder()
- {
- bool isOk = false;
- FOR_VECTOR(i, Coders)
- {
- if (FindBond_for_UnpackStream(i) < 0)
- {
- if (isOk)
- return false;
- UnpackCoder = i;
- isOk = true;
- }
- }
- return isOk;
- }
-
- bool IsStream_in_PackStreams(UInt32 streamIndex) const
- {
- return FindStream_in_PackStreams(streamIndex) >= 0;
- }
-
- int FindStream_in_PackStreams(UInt32 streamIndex) const
- {
- FOR_VECTOR(i, PackStreams)
- if (PackStreams[i] == streamIndex)
- return i;
- return -1;
- }
-
-
- // that function is used before Maps is calculated
-
- UInt32 GetStream_for_Coder(UInt32 coderIndex) const
- {
- UInt32 streamIndex = 0;
- for (UInt32 i = 0; i < coderIndex; i++)
- streamIndex += Coders[i].NumStreams;
- return streamIndex;
- }
-
- // ---------- Maps Section ----------
-
- CRecordVector<UInt32> Coder_to_Stream;
- CRecordVector<UInt32> Stream_to_Coder;
-
- void ClearMaps();
- bool CalcMapsAndCheck();
-
- // ---------- End of Maps Section ----------
-
- void Clear()
- {
- Coders.Clear();
- Bonds.Clear();
- PackStreams.Clear();
-
- ClearMaps();
- }
-
- void GetCoder_for_Stream(UInt32 streamIndex, UInt32 &coderIndex, UInt32 &coderStreamIndex) const
- {
- coderIndex = Stream_to_Coder[streamIndex];
- coderStreamIndex = streamIndex - Coder_to_Stream[coderIndex];
- }
-};
-
-
-
-class CCoder
-{
- CLASS_NO_COPY(CCoder);
-public:
- CMyComPtr<ICompressCoder> Coder;
- CMyComPtr<ICompressCoder2> Coder2;
- UInt32 NumStreams;
-
- UInt64 UnpackSize;
- const UInt64 *UnpackSizePointer;
-
- CRecordVector<UInt64> PackSizes;
- CRecordVector<const UInt64 *> PackSizePointers;
-
- bool Finish;
-
- CCoder(): Finish(false) {}
-
- void SetCoderInfo(const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish);
-
- HRESULT CheckDataAfterEnd(bool &dataAfterEnd_Error /* , bool &InternalPackSizeError */) const;
-
- IUnknown *GetUnknown() const
- {
- return Coder ? (IUnknown *)Coder : (IUnknown *)Coder2;
- }
-
- HRESULT QueryInterface(REFGUID iid, void** pp) const
- {
- return GetUnknown()->QueryInterface(iid, pp);
- }
-};
-
-
-
-class CMixer
-{
- bool Is_PackSize_Correct_for_Stream(UInt32 streamIndex);
-
-protected:
- CBindInfo _bi;
-
- int FindBond_for_Stream(bool forInputStream, UInt32 streamIndex) const
- {
- if (EncodeMode == forInputStream)
- return _bi.FindBond_for_UnpackStream(streamIndex);
- else
- return _bi.FindBond_for_PackStream(streamIndex);
- }
-
- CBoolVector IsFilter_Vector;
- CBoolVector IsExternal_Vector;
- bool EncodeMode;
-public:
- unsigned MainCoderIndex;
-
- // bool InternalPackSizeError;
-
- CMixer(bool encodeMode):
- EncodeMode(encodeMode),
- MainCoderIndex(0)
- // , InternalPackSizeError(false)
- {}
-
- /*
- Sequence of calling:
-
- SetBindInfo();
- for each coder
- AddCoder();
- SelectMainCoder();
-
- for each file
- {
- ReInit()
- for each coder
- SetCoderInfo();
- Code();
- }
- */
-
- virtual HRESULT SetBindInfo(const CBindInfo &bindInfo)
- {
- _bi = bindInfo;
- IsFilter_Vector.Clear();
- MainCoderIndex = 0;
- return S_OK;
- }
-
- virtual void AddCoder(const CCreatedCoder &cod) = 0;
- virtual CCoder &GetCoder(unsigned index) = 0;
- virtual void SelectMainCoder(bool useFirst) = 0;
- virtual void ReInit() = 0;
- virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) = 0;
- virtual HRESULT Code(
- ISequentialInStream * const *inStreams,
- ISequentialOutStream * const *outStreams,
- ICompressProgressInfo *progress,
- bool &dataAfterEnd_Error) = 0;
- virtual UInt64 GetBondStreamSize(unsigned bondIndex) const = 0;
-
- bool Is_UnpackSize_Correct_for_Coder(UInt32 coderIndex);
- bool Is_PackSize_Correct_for_Coder(UInt32 coderIndex);
- bool IsThere_ExternalCoder_in_PackTree(UInt32 coderIndex);
-};
-
-
-
-
-#ifdef USE_MIXER_ST
-
-struct CCoderST: public CCoder
-{
- bool CanRead;
- bool CanWrite;
-
- CCoderST(): CanRead(false), CanWrite(false) {}
-};
-
-
-struct CStBinderStream
-{
- CSequentialInStreamCalcSize *InStreamSpec;
- COutStreamCalcSize *OutStreamSpec;
- CMyComPtr<IUnknown> StreamRef;
-
- CStBinderStream(): InStreamSpec(NULL), OutStreamSpec(NULL) {}
-};
-
-
-class CMixerST:
- public IUnknown,
- public CMixer,
- public CMyUnknownImp
-{
- HRESULT GetInStream2(ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
- UInt32 outStreamIndex, ISequentialInStream **inStreamRes);
- HRESULT GetInStream(ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
- UInt32 inStreamIndex, ISequentialInStream **inStreamRes);
- HRESULT GetOutStream(ISequentialOutStream * const *outStreams, /* const UInt64 * const *outSizes, */
- UInt32 outStreamIndex, ISequentialOutStream **outStreamRes);
-
- HRESULT FinishStream(UInt32 streamIndex);
- HRESULT FinishCoder(UInt32 coderIndex);
-
-public:
- CObjectVector<CCoderST> _coders;
-
- CObjectVector<CStBinderStream> _binderStreams;
-
- MY_UNKNOWN_IMP
-
- CMixerST(bool encodeMode);
- ~CMixerST();
-
- virtual void AddCoder(const CCreatedCoder &cod);
- virtual CCoder &GetCoder(unsigned index);
- virtual void SelectMainCoder(bool useFirst);
- virtual void ReInit();
- virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
- { _coders[coderIndex].SetCoderInfo(unpackSize, packSizes, finish); }
- virtual HRESULT Code(
- ISequentialInStream * const *inStreams,
- ISequentialOutStream * const *outStreams,
- ICompressProgressInfo *progress,
- bool &dataAfterEnd_Error);
- virtual UInt64 GetBondStreamSize(unsigned bondIndex) const;
-
- HRESULT GetMainUnpackStream(
- ISequentialInStream * const *inStreams,
- ISequentialInStream **inStreamRes);
-};
-
-#endif
-
-
-
-
-#ifdef USE_MIXER_MT
-
-class CCoderMT: public CCoder, public CVirtThread
-{
- CLASS_NO_COPY(CCoderMT)
- CRecordVector<ISequentialInStream*> InStreamPointers;
- CRecordVector<ISequentialOutStream*> OutStreamPointers;
-
-private:
- void Execute();
-public:
- bool EncodeMode;
- HRESULT Result;
- CObjectVector< CMyComPtr<ISequentialInStream> > InStreams;
- CObjectVector< CMyComPtr<ISequentialOutStream> > OutStreams;
-
- void Release()
- {
- InStreamPointers.Clear();
- OutStreamPointers.Clear();
- unsigned i;
- for (i = 0; i < InStreams.Size(); i++)
- InStreams[i].Release();
- for (i = 0; i < OutStreams.Size(); i++)
- OutStreams[i].Release();
- }
-
- class CReleaser
- {
- CLASS_NO_COPY(CReleaser)
- CCoderMT &_c;
- public:
- CReleaser(CCoderMT &c): _c(c) {}
- ~CReleaser() { _c.Release(); }
- };
-
- CCoderMT(): EncodeMode(false) {}
- ~CCoderMT() { CVirtThread::WaitThreadFinish(); }
-
- void Code(ICompressProgressInfo *progress);
-};
-
-
-class CMixerMT:
- public IUnknown,
- public CMixer,
- public CMyUnknownImp
-{
- CObjectVector<CStreamBinder> _streamBinders;
-
- HRESULT Init(ISequentialInStream * const *inStreams, ISequentialOutStream * const *outStreams);
- HRESULT ReturnIfError(HRESULT code);
-
-public:
- CObjectVector<CCoderMT> _coders;
-
- MY_UNKNOWN_IMP
-
- virtual HRESULT SetBindInfo(const CBindInfo &bindInfo);
- virtual void AddCoder(const CCreatedCoder &cod);
- virtual CCoder &GetCoder(unsigned index);
- virtual void SelectMainCoder(bool useFirst);
- virtual void ReInit();
- virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
- { _coders[coderIndex].SetCoderInfo(unpackSize, packSizes, finish); }
- virtual HRESULT Code(
- ISequentialInStream * const *inStreams,
- ISequentialOutStream * const *outStreams,
- ICompressProgressInfo *progress,
- bool &dataAfterEnd_Error);
- virtual UInt64 GetBondStreamSize(unsigned bondIndex) const;
-
- CMixerMT(bool encodeMode): CMixer(encodeMode) {}
-};
-
-#endif
-
-}
-
-#endif
+// CoderMixer2.h
+
+#ifndef ZIP7_INC_CODER_MIXER2_H
+#define ZIP7_INC_CODER_MIXER2_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyVector.h"
+
+#include "../../ICoder.h"
+
+#include "../../Common/CreateCoder.h"
+
+#ifdef Z7_ST
+ #define USE_MIXER_ST
+#else
+ #define USE_MIXER_MT
+ #ifndef Z7_SFX
+ #define USE_MIXER_ST
+ #endif
+#endif
+
+#ifdef USE_MIXER_MT
+#include "../../Common/StreamBinder.h"
+#include "../../Common/VirtThread.h"
+#endif
+
+
+
+#ifdef USE_MIXER_ST
+
+Z7_CLASS_IMP_COM_1(
+ CSequentialInStreamCalcSize
+ , ISequentialInStream
+)
+ bool _wasFinished;
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt64 _size;
+public:
+ void SetStream(ISequentialInStream *stream) { _stream = stream; }
+ void Init()
+ {
+ _size = 0;
+ _wasFinished = false;
+ }
+ void ReleaseStream() { _stream.Release(); }
+ UInt64 GetSize() const { return _size; }
+ bool WasFinished() const { return _wasFinished; }
+};
+
+
+Z7_CLASS_IMP_COM_2(
+ COutStreamCalcSize
+ , ISequentialOutStream
+ , IOutStreamFinish
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init() { _size = 0; }
+ UInt64 GetSize() const { return _size; }
+};
+
+#endif
+
+
+
+namespace NCoderMixer2 {
+
+struct CBond
+{
+ UInt32 PackIndex;
+ UInt32 UnpackIndex;
+
+ UInt32 Get_InIndex(bool encodeMode) const { return encodeMode ? UnpackIndex : PackIndex; }
+ UInt32 Get_OutIndex(bool encodeMode) const { return encodeMode ? PackIndex : UnpackIndex; }
+};
+
+
+struct CCoderStreamsInfo
+{
+ UInt32 NumStreams;
+};
+
+
+struct CBindInfo
+{
+ CRecordVector<CCoderStreamsInfo> Coders;
+ CRecordVector<CBond> Bonds;
+ CRecordVector<UInt32> PackStreams;
+ unsigned UnpackCoder;
+
+ unsigned GetNum_Bonds_and_PackStreams() const { return Bonds.Size() + PackStreams.Size(); }
+
+ int FindBond_for_PackStream(UInt32 packStream) const
+ {
+ FOR_VECTOR (i, Bonds)
+ if (Bonds[i].PackIndex == packStream)
+ return (int)i;
+ return -1;
+ }
+
+ int FindBond_for_UnpackStream(UInt32 unpackStream) const
+ {
+ FOR_VECTOR (i, Bonds)
+ if (Bonds[i].UnpackIndex == unpackStream)
+ return (int)i;
+ return -1;
+ }
+
+ bool SetUnpackCoder()
+ {
+ bool isOk = false;
+ FOR_VECTOR (i, Coders)
+ {
+ if (FindBond_for_UnpackStream(i) < 0)
+ {
+ if (isOk)
+ return false;
+ UnpackCoder = i;
+ isOk = true;
+ }
+ }
+ return isOk;
+ }
+
+ bool IsStream_in_PackStreams(UInt32 streamIndex) const
+ {
+ return FindStream_in_PackStreams(streamIndex) >= 0;
+ }
+
+ int FindStream_in_PackStreams(UInt32 streamIndex) const
+ {
+ FOR_VECTOR (i, PackStreams)
+ if (PackStreams[i] == streamIndex)
+ return (int)i;
+ return -1;
+ }
+
+
+ // that function is used before Maps is calculated
+
+ UInt32 GetStream_for_Coder(UInt32 coderIndex) const
+ {
+ UInt32 streamIndex = 0;
+ for (UInt32 i = 0; i < coderIndex; i++)
+ streamIndex += Coders[i].NumStreams;
+ return streamIndex;
+ }
+
+ // ---------- Maps Section ----------
+
+ CRecordVector<UInt32> Coder_to_Stream;
+ CRecordVector<UInt32> Stream_to_Coder;
+
+ void ClearMaps();
+ bool CalcMapsAndCheck();
+
+ // ---------- End of Maps Section ----------
+
+ void Clear()
+ {
+ Coders.Clear();
+ Bonds.Clear();
+ PackStreams.Clear();
+
+ ClearMaps();
+ }
+
+ void GetCoder_for_Stream(UInt32 streamIndex, UInt32 &coderIndex, UInt32 &coderStreamIndex) const
+ {
+ coderIndex = Stream_to_Coder[streamIndex];
+ coderStreamIndex = streamIndex - Coder_to_Stream[coderIndex];
+ }
+};
+
+
+
+class CCoder
+{
+ Z7_CLASS_NO_COPY(CCoder)
+public:
+ CMyComPtr<ICompressCoder> Coder;
+ CMyComPtr<ICompressCoder2> Coder2;
+ UInt32 NumStreams;
+ bool Finish;
+
+ UInt64 UnpackSize;
+ const UInt64 *UnpackSizePointer;
+
+ CRecordVector<UInt64> PackSizes;
+ CRecordVector<const UInt64 *> PackSizePointers;
+
+ CCoder(): Finish(false) {}
+
+ void SetCoderInfo(const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish);
+
+ HRESULT CheckDataAfterEnd(bool &dataAfterEnd_Error /* , bool &InternalPackSizeError */) const;
+
+ IUnknown *GetUnknown() const
+ {
+ return Coder ? (IUnknown *)Coder : (IUnknown *)Coder2;
+ }
+
+ HRESULT QueryInterface(REFGUID iid, void** pp) const
+ {
+ return GetUnknown()->QueryInterface(iid, pp);
+ }
+};
+
+
+
+class CMixer
+{
+ bool Is_PackSize_Correct_for_Stream(UInt32 streamIndex);
+
+protected:
+ CBindInfo _bi;
+
+ int FindBond_for_Stream(bool forInputStream, UInt32 streamIndex) const
+ {
+ if (EncodeMode == forInputStream)
+ return _bi.FindBond_for_UnpackStream(streamIndex);
+ else
+ return _bi.FindBond_for_PackStream(streamIndex);
+ }
+
+ CBoolVector IsFilter_Vector;
+ CBoolVector IsExternal_Vector;
+ bool EncodeMode;
+public:
+ unsigned MainCoderIndex;
+
+ // bool InternalPackSizeError;
+
+ CMixer(bool encodeMode):
+ EncodeMode(encodeMode),
+ MainCoderIndex(0)
+ // , InternalPackSizeError(false)
+ {}
+
+ virtual ~CMixer() {}
+ /*
+ Sequence of calling:
+
+ SetBindInfo();
+ for each coder
+ AddCoder();
+ SelectMainCoder();
+
+ for each file
+ {
+ ReInit()
+ for each coder
+ SetCoderInfo();
+ Code();
+ }
+ */
+
+ virtual HRESULT SetBindInfo(const CBindInfo &bindInfo)
+ {
+ _bi = bindInfo;
+ IsFilter_Vector.Clear();
+ MainCoderIndex = 0;
+ return S_OK;
+ }
+
+ virtual void AddCoder(const CCreatedCoder &cod) = 0;
+ virtual CCoder &GetCoder(unsigned index) = 0;
+ virtual void SelectMainCoder(bool useFirst) = 0;
+ virtual HRESULT ReInit2() = 0;
+ virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) = 0;
+ virtual HRESULT Code(
+ ISequentialInStream * const *inStreams,
+ ISequentialOutStream * const *outStreams,
+ ICompressProgressInfo *progress,
+ bool &dataAfterEnd_Error) = 0;
+ virtual UInt64 GetBondStreamSize(unsigned bondIndex) const = 0;
+
+ bool Is_UnpackSize_Correct_for_Coder(UInt32 coderIndex);
+ bool Is_PackSize_Correct_for_Coder(UInt32 coderIndex);
+ bool IsThere_ExternalCoder_in_PackTree(UInt32 coderIndex);
+};
+
+
+
+
+#ifdef USE_MIXER_ST
+
+struct CCoderST: public CCoder
+{
+ bool CanRead;
+ bool CanWrite;
+
+ CCoderST(): CanRead(false), CanWrite(false) {}
+};
+
+
+struct CStBinderStream
+{
+ CSequentialInStreamCalcSize *InStreamSpec;
+ COutStreamCalcSize *OutStreamSpec;
+ CMyComPtr<IUnknown> StreamRef;
+
+ CStBinderStream(): InStreamSpec(NULL), OutStreamSpec(NULL) {}
+};
+
+
+class CMixerST:
+ public IUnknown,
+ public CMixer,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_CLASS_NO_COPY(CMixerST)
+
+ HRESULT GetInStream2(ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
+ UInt32 outStreamIndex, ISequentialInStream **inStreamRes);
+ HRESULT GetInStream(ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
+ UInt32 inStreamIndex, ISequentialInStream **inStreamRes);
+ HRESULT GetOutStream(ISequentialOutStream * const *outStreams, /* const UInt64 * const *outSizes, */
+ UInt32 outStreamIndex, ISequentialOutStream **outStreamRes);
+
+ HRESULT FinishStream(UInt32 streamIndex);
+ HRESULT FinishCoder(UInt32 coderIndex);
+
+public:
+ CObjectVector<CCoderST> _coders;
+
+ CObjectVector<CStBinderStream> _binderStreams;
+
+ CMixerST(bool encodeMode);
+ ~CMixerST() Z7_DESTRUCTOR_override;
+
+ virtual void AddCoder(const CCreatedCoder &cod) Z7_override;
+ virtual CCoder &GetCoder(unsigned index) Z7_override;
+ virtual void SelectMainCoder(bool useFirst) Z7_override;
+ virtual HRESULT ReInit2() Z7_override;
+ virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) Z7_override
+ { _coders[coderIndex].SetCoderInfo(unpackSize, packSizes, finish); }
+ virtual HRESULT Code(
+ ISequentialInStream * const *inStreams,
+ ISequentialOutStream * const *outStreams,
+ ICompressProgressInfo *progress,
+ bool &dataAfterEnd_Error) Z7_override;
+ virtual UInt64 GetBondStreamSize(unsigned bondIndex) const Z7_override;
+
+ HRESULT GetMainUnpackStream(
+ ISequentialInStream * const *inStreams,
+ ISequentialInStream **inStreamRes);
+};
+
+#endif
+
+
+
+
+#ifdef USE_MIXER_MT
+
+class CCoderMT: public CCoder, public CVirtThread
+{
+ Z7_CLASS_NO_COPY(CCoderMT)
+ CRecordVector<ISequentialInStream*> InStreamPointers;
+ CRecordVector<ISequentialOutStream*> OutStreamPointers;
+
+private:
+ virtual void Execute() Z7_override;
+public:
+ bool EncodeMode;
+ HRESULT Result;
+ CObjectVector< CMyComPtr<ISequentialInStream> > InStreams;
+ CObjectVector< CMyComPtr<ISequentialOutStream> > OutStreams;
+
+ void Release()
+ {
+ InStreamPointers.Clear();
+ OutStreamPointers.Clear();
+ unsigned i;
+ for (i = 0; i < InStreams.Size(); i++)
+ InStreams[i].Release();
+ for (i = 0; i < OutStreams.Size(); i++)
+ OutStreams[i].Release();
+ }
+
+ class CReleaser
+ {
+ Z7_CLASS_NO_COPY(CReleaser)
+ CCoderMT &_c;
+ public:
+ CReleaser(CCoderMT &c): _c(c) {}
+ ~CReleaser() { _c.Release(); }
+ };
+
+ CCoderMT(): EncodeMode(false) {}
+ ~CCoderMT() Z7_DESTRUCTOR_override
+ {
+ /* WaitThreadFinish() will be called in ~CVirtThread().
+ But we need WaitThreadFinish() call before CCoder destructor,
+ and before destructors of this class members.
+ */
+ CVirtThread::WaitThreadFinish();
+ }
+
+ void Code(ICompressProgressInfo *progress);
+};
+
+
+class CMixerMT:
+ public IUnknown,
+ public CMixer,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_CLASS_NO_COPY(CMixerMT)
+
+ CObjectVector<CStreamBinder> _streamBinders;
+
+ HRESULT Init(ISequentialInStream * const *inStreams, ISequentialOutStream * const *outStreams);
+ HRESULT ReturnIfError(HRESULT code);
+
+ // virtual ~CMixerMT() {}
+public:
+ CObjectVector<CCoderMT> _coders;
+
+ virtual HRESULT SetBindInfo(const CBindInfo &bindInfo) Z7_override;
+ virtual void AddCoder(const CCreatedCoder &cod) Z7_override;
+ virtual CCoder &GetCoder(unsigned index) Z7_override;
+ virtual void SelectMainCoder(bool useFirst) Z7_override;
+ virtual HRESULT ReInit2() Z7_override;
+ virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) Z7_override
+ { _coders[coderIndex].SetCoderInfo(unpackSize, packSizes, finish); }
+ virtual HRESULT Code(
+ ISequentialInStream * const *inStreams,
+ ISequentialOutStream * const *outStreams,
+ ICompressProgressInfo *progress,
+ bool &dataAfterEnd_Error) Z7_override;
+ virtual UInt64 GetBondStreamSize(unsigned bondIndex) const Z7_override;
+
+ CMixerMT(bool encodeMode): CMixer(encodeMode) {}
+};
+
+#endif
+
+}
+
+#endif
diff --git a/CPP/7zip/Archive/Common/DummyOutStream.cpp b/CPP/7zip/Archive/Common/DummyOutStream.cpp
index c7d45e7..f48c32f 100644
--- a/CPP/7zip/Archive/Common/DummyOutStream.cpp
+++ b/CPP/7zip/Archive/Common/DummyOutStream.cpp
@@ -1,17 +1,17 @@
-// DummyOutStream.cpp
-
-#include "StdAfx.h"
-
-#include "DummyOutStream.h"
-
-STDMETHODIMP CDummyOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessedSize = size;
- HRESULT res = S_OK;
- if (_stream)
- res = _stream->Write(data, size, &realProcessedSize);
- _size += realProcessedSize;
- if (processedSize)
- *processedSize = realProcessedSize;
- return res;
-}
+// DummyOutStream.cpp
+
+#include "StdAfx.h"
+
+#include "DummyOutStream.h"
+
+Z7_COM7F_IMF(CDummyOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize = size;
+ HRESULT res = S_OK;
+ if (_stream)
+ res = _stream->Write(data, size, &realProcessedSize);
+ _size += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return res;
+}
diff --git a/CPP/7zip/Archive/Common/DummyOutStream.h b/CPP/7zip/Archive/Common/DummyOutStream.h
index 30e84c5..f884e13 100644
--- a/CPP/7zip/Archive/Common/DummyOutStream.h
+++ b/CPP/7zip/Archive/Common/DummyOutStream.h
@@ -1,25 +1,23 @@
-// DummyOutStream.h
-
-#ifndef __DUMMY_OUT_STREAM_H
-#define __DUMMY_OUT_STREAM_H
-
-#include "../../../Common/MyCom.h"
-
-#include "../../IStream.h"
-
-class CDummyOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
- UInt64 _size;
-public:
- void SetStream(ISequentialOutStream *outStream) { _stream = outStream; }
- void ReleaseStream() { _stream.Release(); }
- void Init() { _size = 0; }
- MY_UNKNOWN_IMP
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- UInt64 GetSize() const { return _size; }
-};
-
-#endif
+// DummyOutStream.h
+
+#ifndef ZIP7_INC_DUMMY_OUT_STREAM_H
+#define ZIP7_INC_DUMMY_OUT_STREAM_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+Z7_CLASS_IMP_NOQIB_1(
+ CDummyOutStream
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+public:
+ void SetStream(ISequentialOutStream *outStream) { _stream = outStream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init() { _size = 0; }
+ UInt64 GetSize() const { return _size; }
+};
+
+#endif
diff --git a/CPP/7zip/Archive/Common/FindSignature.cpp b/CPP/7zip/Archive/Common/FindSignature.cpp
new file mode 100644
index 0000000..6c6740f
--- /dev/null
+++ b/CPP/7zip/Archive/Common/FindSignature.cpp
@@ -0,0 +1,62 @@
+// FindSignature.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "../../../Common/MyBuffer.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "FindSignature.h"
+
+HRESULT FindSignatureInStream(ISequentialInStream *stream,
+ const Byte *signature, unsigned signatureSize,
+ const UInt64 *limit, UInt64 &resPos)
+{
+ resPos = 0;
+ CByteBuffer byteBuffer2(signatureSize);
+ RINOK(ReadStream_FALSE(stream, byteBuffer2, signatureSize))
+
+ if (memcmp(byteBuffer2, signature, signatureSize) == 0)
+ return S_OK;
+
+ const UInt32 kBufferSize = (1 << 16);
+ CByteBuffer byteBuffer(kBufferSize);
+ Byte *buffer = byteBuffer;
+ UInt32 numPrevBytes = signatureSize - 1;
+ memcpy(buffer, (const Byte *)byteBuffer2 + 1, numPrevBytes);
+ resPos = 1;
+ for (;;)
+ {
+ if (limit)
+ if (resPos > *limit)
+ return S_FALSE;
+ do
+ {
+ const UInt32 numReadBytes = kBufferSize - numPrevBytes;
+ UInt32 processedSize;
+ RINOK(stream->Read(buffer + numPrevBytes, numReadBytes, &processedSize))
+ numPrevBytes += processedSize;
+ if (processedSize == 0)
+ return S_FALSE;
+ }
+ while (numPrevBytes < signatureSize);
+ const UInt32 numTests = numPrevBytes - signatureSize + 1;
+ for (UInt32 pos = 0; pos < numTests; pos++)
+ {
+ const Byte b = signature[0];
+ for (; buffer[pos] != b && pos < numTests; pos++);
+ if (pos == numTests)
+ break;
+ if (memcmp(buffer + pos, signature, signatureSize) == 0)
+ {
+ resPos += pos;
+ return S_OK;
+ }
+ }
+ resPos += numTests;
+ numPrevBytes -= numTests;
+ memmove(buffer, buffer + numTests, numPrevBytes);
+ }
+}
diff --git a/CPP/7zip/Archive/Common/FindSignature.h b/CPP/7zip/Archive/Common/FindSignature.h
new file mode 100644
index 0000000..f0e6cdd
--- /dev/null
+++ b/CPP/7zip/Archive/Common/FindSignature.h
@@ -0,0 +1,12 @@
+// FindSignature.h
+
+#ifndef ZIP7_INC_FIND_SIGNATURE_H
+#define ZIP7_INC_FIND_SIGNATURE_H
+
+#include "../../IStream.h"
+
+HRESULT FindSignatureInStream(ISequentialInStream *stream,
+ const Byte *signature, unsigned signatureSize,
+ const UInt64 *limit, UInt64 &resPos);
+
+#endif
diff --git a/CPP/7zip/Archive/Common/HandlerOut.cpp b/CPP/7zip/Archive/Common/HandlerOut.cpp
index 41762d9..17fed67 100644
--- a/CPP/7zip/Archive/Common/HandlerOut.cpp
+++ b/CPP/7zip/Archive/Common/HandlerOut.cpp
@@ -1,232 +1,311 @@
-// HandlerOut.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/StringToInt.h"
-
-#include "../Common/ParseProperties.h"
-
-#include "HandlerOut.h"
-
-namespace NArchive {
-
-bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsBase, UInt64 &res)
-{
- if (*s == 0)
- {
- switch (prop.vt)
- {
- case VT_UI4: res = prop.ulVal; return true;
- case VT_UI8: res = prop.uhVal.QuadPart; return true;
- case VT_BSTR:
- s = prop.bstrVal;
- break;
- default: return false;
- }
- }
- else if (prop.vt != VT_EMPTY)
- return false;
-
- const wchar_t *end;
- UInt64 v = ConvertStringToUInt64(s, &end);
- if (s == end)
- return false;
- wchar_t c = *end;
- if (c == 0)
- {
- res = v;
- return true;
- }
- if (end[1] != 0)
- return false;
-
- if (c == '%')
- {
- res = percentsBase / 100 * v;
- return true;
- }
-
- unsigned numBits;
- switch (MyCharLower_Ascii(c))
- {
- case 'b': numBits = 0; break;
- case 'k': numBits = 10; break;
- case 'm': numBits = 20; break;
- case 'g': numBits = 30; break;
- case 't': numBits = 40; break;
- default: return false;
- }
- UInt64 val2 = v << numBits;
- if ((val2 >> numBits) != v)
- return false;
- res = val2;
- return true;
-}
-
-bool CCommonMethodProps::SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres)
-{
- hres = S_OK;
-
- if (name.IsPrefixedBy_Ascii_NoCase("mt"))
- {
- #ifndef _7ZIP_ST
- hres = ParseMtProp(name.Ptr(2), value, _numProcessors, _numThreads);
- #endif
- return true;
- }
-
- if (name.IsPrefixedBy_Ascii_NoCase("memuse"))
- {
- if (!ParseSizeString(name.Ptr(6), value, _memAvail, _memUsage))
- hres = E_INVALIDARG;
- return true;
- }
-
- return false;
-}
-
-
-#ifndef EXTRACT_ONLY
-
-static void SetMethodProp32(COneMethodInfo &m, PROPID propID, UInt32 value)
-{
- if (m.FindProp(propID) < 0)
- m.AddProp32(propID, value);
-}
-
-void CMultiMethodProps::SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const
-{
- UInt32 level = _level;
- if (level != (UInt32)(Int32)-1)
- SetMethodProp32(oneMethodInfo, NCoderPropID::kLevel, (UInt32)level);
-}
-
-#ifndef _7ZIP_ST
-void CMultiMethodProps::SetMethodThreadsTo(COneMethodInfo &oneMethodInfo, UInt32 numThreads)
-{
- SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
-}
-#endif
-
-void CMultiMethodProps::InitMulti()
-{
- _level = (UInt32)(Int32)-1;
- _analysisLevel = -1;
- _crcSize = 4;
- _autoFilter = true;
-}
-
-void CMultiMethodProps::Init()
-{
- InitCommon();
- InitMulti();
- _methods.Clear();
- _filterMethod.Clear();
-}
-
-
-HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
-{
- UString name = nameSpec;
- name.MakeLower_Ascii();
- if (name.IsEmpty())
- return E_INVALIDARG;
-
- if (name[0] == 'x')
- {
- name.Delete(0);
- _level = 9;
- return ParsePropToUInt32(name, value, _level);
- }
-
- if (name.IsPrefixedBy_Ascii_NoCase("yx"))
- {
- name.Delete(0, 2);
- UInt32 v = 9;
- RINOK(ParsePropToUInt32(name, value, v));
- _analysisLevel = (int)v;
- return S_OK;
- }
-
- if (name.IsPrefixedBy_Ascii_NoCase("crc"))
- {
- name.Delete(0, 3);
- _crcSize = 4;
- return ParsePropToUInt32(name, value, _crcSize);
- }
-
- {
- HRESULT hres;
- if (SetCommonProperty(name, value, hres))
- return hres;
- }
-
- UInt32 number;
- unsigned index = ParseStringToUInt32(name, number);
- UString realName = name.Ptr(index);
- if (index == 0)
- {
- if (name.IsEqualTo("f"))
- {
- HRESULT res = PROPVARIANT_to_bool(value, _autoFilter);
- if (res == S_OK)
- return res;
- if (value.vt != VT_BSTR)
- return E_INVALIDARG;
- return _filterMethod.ParseMethodFromPROPVARIANT(UString(), value);
- }
- number = 0;
- }
- if (number > 64)
- return E_FAIL;
- for (int j = _methods.Size(); j <= (int)number; j++)
- _methods.Add(COneMethodInfo());
- return _methods[number].ParseMethodFromPROPVARIANT(realName, value);
-}
-
-
-
-void CSingleMethodProps::Init()
-{
- InitCommon();
- InitSingle();
- Clear();
-}
-
-
-HRESULT CSingleMethodProps::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
-{
- Init();
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- UString name = names[i];
- name.MakeLower_Ascii();
- if (name.IsEmpty())
- return E_INVALIDARG;
- const PROPVARIANT &value = values[i];
- if (name[0] == L'x')
- {
- UInt32 a = 9;
- RINOK(ParsePropToUInt32(name.Ptr(1), value, a));
- _level = a;
- AddProp_Level(a);
- continue;
- }
- {
- HRESULT hres;
- if (SetCommonProperty(name, value, hres))
- {
- RINOK(hres)
- continue;
- }
- }
- RINOK(ParseMethodFromPROPVARIANT(names[i], value));
- }
-
- return S_OK;
-}
-
-#endif
-
-}
+// HandlerOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringToInt.h"
+
+#include "../Common/ParseProperties.h"
+
+#include "HandlerOut.h"
+
+namespace NArchive {
+
+bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsBase, UInt64 &res)
+{
+ if (*s == 0)
+ {
+ switch (prop.vt)
+ {
+ case VT_UI4: res = prop.ulVal; return true;
+ case VT_UI8: res = prop.uhVal.QuadPart; return true;
+ case VT_BSTR:
+ s = prop.bstrVal;
+ break;
+ default: return false;
+ }
+ }
+ else if (prop.vt != VT_EMPTY)
+ return false;
+
+ bool percentMode = false;
+ {
+ const wchar_t c = *s;
+ if (MyCharLower_Ascii(c) == 'p')
+ {
+ percentMode = true;
+ s++;
+ }
+ }
+
+ const wchar_t *end;
+ const UInt64 v = ConvertStringToUInt64(s, &end);
+ if (s == end)
+ return false;
+ const wchar_t c = *end;
+
+ if (percentMode)
+ {
+ if (c != 0)
+ return false;
+ res = Calc_From_Val_Percents(percentsBase, v);
+ return true;
+ }
+
+ if (c == 0)
+ {
+ res = v;
+ return true;
+ }
+ if (end[1] != 0)
+ return false;
+
+ if (c == '%')
+ {
+ res = Calc_From_Val_Percents(percentsBase, v);
+ return true;
+ }
+
+ unsigned numBits;
+ switch (MyCharLower_Ascii(c))
+ {
+ case 'b': numBits = 0; break;
+ case 'k': numBits = 10; break;
+ case 'm': numBits = 20; break;
+ case 'g': numBits = 30; break;
+ case 't': numBits = 40; break;
+ default: return false;
+ }
+ const UInt64 val2 = v << numBits;
+ if ((val2 >> numBits) != v)
+ return false;
+ res = val2;
+ return true;
+}
+
+bool CCommonMethodProps::SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres)
+{
+ hres = S_OK;
+
+ if (name.IsPrefixedBy_Ascii_NoCase("mt"))
+ {
+ #ifndef Z7_ST
+ _numThreads = _numProcessors;
+ _numThreads_WasForced = false;
+ hres = ParseMtProp2(name.Ptr(2), value, _numThreads, _numThreads_WasForced);
+ // "mt" means "_numThreads_WasForced = false" here
+ #endif
+ return true;
+ }
+
+ if (name.IsPrefixedBy_Ascii_NoCase("memuse"))
+ {
+ UInt64 v;
+ if (!ParseSizeString(name.Ptr(6), value, _memAvail, v))
+ hres = E_INVALIDARG;
+ _memUsage_Decompress = v;
+ _memUsage_Compress = v;
+ _memUsage_WasSet = true;
+ return true;
+ }
+
+ return false;
+}
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+static void SetMethodProp32(CMethodProps &m, PROPID propID, UInt32 value)
+{
+ if (m.FindProp(propID) < 0)
+ m.AddProp32(propID, value);
+}
+
+void CMultiMethodProps::SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const
+{
+ UInt32 level = _level;
+ if (level != (UInt32)(Int32)-1)
+ SetMethodProp32(oneMethodInfo, NCoderPropID::kLevel, (UInt32)level);
+}
+
+#ifndef Z7_ST
+
+static void SetMethodProp32_Replace(CMethodProps &m, PROPID propID, UInt32 value)
+{
+ const int i = m.FindProp(propID);
+ if (i >= 0)
+ {
+ NWindows::NCOM::CPropVariant &val = m.Props[(unsigned)i].Value;
+ val = (UInt32)value;
+ return;
+ }
+ m.AddProp32(propID, value);
+}
+
+void CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(CMethodProps &oneMethodInfo, UInt32 numThreads)
+{
+ SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
+}
+
+void CMultiMethodProps::SetMethodThreadsTo_Replace(CMethodProps &oneMethodInfo, UInt32 numThreads)
+{
+ SetMethodProp32_Replace(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
+}
+
+#endif // Z7_ST
+
+
+void CMultiMethodProps::InitMulti()
+{
+ _level = (UInt32)(Int32)-1;
+ _analysisLevel = -1;
+ _crcSize = 4;
+ _autoFilter = true;
+}
+
+void CMultiMethodProps::Init()
+{
+ InitCommon();
+ InitMulti();
+ _methods.Clear();
+ _filterMethod.Clear();
+}
+
+
+HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
+{
+ UString name = nameSpec;
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ if (name[0] == 'x')
+ {
+ name.Delete(0);
+ _level = 9;
+ return ParsePropToUInt32(name, value, _level);
+ }
+
+ if (name.IsPrefixedBy_Ascii_NoCase("yx"))
+ {
+ name.Delete(0, 2);
+ UInt32 v = 9;
+ RINOK(ParsePropToUInt32(name, value, v))
+ _analysisLevel = (int)v;
+ return S_OK;
+ }
+
+ if (name.IsPrefixedBy_Ascii_NoCase("crc"))
+ {
+ name.Delete(0, 3);
+ _crcSize = 4;
+ return ParsePropToUInt32(name, value, _crcSize);
+ }
+
+ {
+ HRESULT hres;
+ if (SetCommonProperty(name, value, hres))
+ return hres;
+ }
+
+ UInt32 number;
+ const unsigned index = ParseStringToUInt32(name, number);
+ const UString realName = name.Ptr(index);
+ if (index == 0)
+ {
+ if (name.IsEqualTo("f"))
+ {
+ const HRESULT res = PROPVARIANT_to_bool(value, _autoFilter);
+ if (res == S_OK)
+ return res;
+ if (value.vt != VT_BSTR)
+ return E_INVALIDARG;
+ return _filterMethod.ParseMethodFromPROPVARIANT(UString(), value);
+ }
+ number = 0;
+ }
+ if (number > 64)
+ return E_INVALIDARG;
+ for (unsigned j = _methods.Size(); j <= number; j++)
+ _methods.AddNew();
+ return _methods[number].ParseMethodFromPROPVARIANT(realName, value);
+}
+
+
+
+void CSingleMethodProps::Init()
+{
+ InitCommon();
+ InitSingle();
+ Clear();
+}
+
+
+HRESULT CSingleMethodProps::SetProperty(const wchar_t *name2, const PROPVARIANT &value)
+{
+ // processed = false;
+ UString name = name2;
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+ if (name.IsPrefixedBy_Ascii_NoCase("x"))
+ {
+ UInt32 a = 9;
+ RINOK(ParsePropToUInt32(name.Ptr(1), value, a))
+ _level = a;
+ AddProp_Level(a);
+ // processed = true;
+ return S_OK;
+ }
+ {
+ HRESULT hres;
+ if (SetCommonProperty(name, value, hres))
+ {
+ // processed = true;
+ return S_OK;
+ }
+ }
+ RINOK(ParseMethodFromPROPVARIANT(name, value))
+ return S_OK;
+}
+
+
+HRESULT CSingleMethodProps::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
+{
+ Init();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ RINOK(SetProperty(names[i], values[i]))
+ }
+
+ return S_OK;
+}
+
+#endif
+
+
+static HRESULT PROPVARIANT_to_BoolPair(const PROPVARIANT &prop, CBoolPair &dest)
+{
+ RINOK(PROPVARIANT_to_bool(prop, dest.Val))
+ dest.Def = true;
+ return S_OK;
+}
+
+HRESULT CHandlerTimeOptions::Parse(const UString &name, const PROPVARIANT &prop, bool &processed)
+{
+ processed = true;
+ if (name.IsEqualTo_Ascii_NoCase("tm")) { return PROPVARIANT_to_BoolPair(prop, Write_MTime); }
+ if (name.IsEqualTo_Ascii_NoCase("ta")) { return PROPVARIANT_to_BoolPair(prop, Write_ATime); }
+ if (name.IsEqualTo_Ascii_NoCase("tc")) { return PROPVARIANT_to_BoolPair(prop, Write_CTime); }
+ if (name.IsPrefixedBy_Ascii_NoCase("tp"))
+ {
+ UInt32 v = 0;
+ RINOK(ParsePropToUInt32(name.Ptr(2), prop, v))
+ Prec = v;
+ return S_OK;
+ }
+ processed = false;
+ return S_OK;
+}
+
+}
diff --git a/CPP/7zip/Archive/Common/HandlerOut.h b/CPP/7zip/Archive/Common/HandlerOut.h
index 90b000a..cfba46e 100644
--- a/CPP/7zip/Archive/Common/HandlerOut.h
+++ b/CPP/7zip/Archive/Common/HandlerOut.h
@@ -1,110 +1,154 @@
-// HandlerOut.h
-
-#ifndef __HANDLER_OUT_H
-#define __HANDLER_OUT_H
-
-#include "../../../Windows/System.h"
-
-#include "../../Common/MethodProps.h"
-
-namespace NArchive {
-
-bool ParseSizeString(const wchar_t *name, const PROPVARIANT &prop, UInt64 percentsBase, UInt64 &res);
-
-class CCommonMethodProps
-{
-protected:
- void InitCommon()
- {
- #ifndef _7ZIP_ST
- _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
- #endif
-
- UInt64 memAvail = (UInt64)(sizeof(size_t)) << 28;
- _memAvail = memAvail;
- _memUsage = memAvail;
- if (NWindows::NSystem::GetRamSize(memAvail))
- {
- _memAvail = memAvail;
- _memUsage = memAvail / 32 * 17;
- }
- }
-
-public:
- #ifndef _7ZIP_ST
- UInt32 _numThreads;
- UInt32 _numProcessors;
- #endif
-
- UInt64 _memUsage;
- UInt64 _memAvail;
-
- bool SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres);
-
- CCommonMethodProps() { InitCommon(); }
-};
-
-
-#ifndef EXTRACT_ONLY
-
-class CMultiMethodProps: public CCommonMethodProps
-{
- UInt32 _level;
- int _analysisLevel;
-
- void InitMulti();
-public:
- UInt32 _crcSize;
- CObjectVector<COneMethodInfo> _methods;
- COneMethodInfo _filterMethod;
- bool _autoFilter;
-
-
- void SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const;
-
- #ifndef _7ZIP_ST
- static void SetMethodThreadsTo(COneMethodInfo &oneMethodInfo, UInt32 numThreads);
- #endif
-
-
- unsigned GetNumEmptyMethods() const
- {
- unsigned i;
- for (i = 0; i < _methods.Size(); i++)
- if (!_methods[i].IsEmpty())
- break;
- return i;
- }
-
- int GetLevel() const { return _level == (UInt32)(Int32)-1 ? 5 : (int)_level; }
- int GetAnalysisLevel() const { return _analysisLevel; }
-
- void Init();
- CMultiMethodProps() { InitMulti(); }
-
- HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
-};
-
-
-class CSingleMethodProps: public COneMethodInfo, public CCommonMethodProps
-{
- UInt32 _level;
-
- void InitSingle()
- {
- _level = (UInt32)(Int32)-1;
- }
-
-public:
- void Init();
- CSingleMethodProps() { InitSingle(); }
-
- int GetLevel() const { return _level == (UInt32)(Int32)-1 ? 5 : (int)_level; }
- HRESULT SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
-};
-
-#endif
-
-}
-
-#endif
+// HandlerOut.h
+
+#ifndef ZIP7_INC_HANDLER_OUT_H
+#define ZIP7_INC_HANDLER_OUT_H
+
+#include "../../../Windows/System.h"
+
+#include "../../Common/MethodProps.h"
+
+namespace NArchive {
+
+bool ParseSizeString(const wchar_t *name, const PROPVARIANT &prop, UInt64 percentsBase, UInt64 &res);
+
+class CCommonMethodProps
+{
+protected:
+ void InitCommon()
+ {
+ // _Write_MTime = true;
+ #ifndef Z7_ST
+ _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
+ _numThreads_WasForced = false;
+ #endif
+
+ UInt64 memAvail = (UInt64)(sizeof(size_t)) << 28;
+ _memAvail = memAvail;
+ _memUsage_Compress = memAvail;
+ _memUsage_Decompress = memAvail;
+ _memUsage_WasSet = NWindows::NSystem::GetRamSize(memAvail);
+ if (_memUsage_WasSet)
+ {
+ _memAvail = memAvail;
+ unsigned bits = sizeof(size_t) * 8;
+ if (bits == 32)
+ {
+ const UInt32 limit2 = (UInt32)7 << 28;
+ if (memAvail > limit2)
+ memAvail = limit2;
+ }
+ // 80% - is auto usage limit in handlers
+ // _memUsage_Compress = memAvail * 4 / 5;
+ // _memUsage_Compress = Calc_From_Val_Percents(memAvail, 80);
+ _memUsage_Compress = Calc_From_Val_Percents_Less100(memAvail, 80);
+ _memUsage_Decompress = memAvail / 32 * 17;
+ }
+ }
+
+public:
+ #ifndef Z7_ST
+ UInt32 _numThreads;
+ UInt32 _numProcessors;
+ bool _numThreads_WasForced;
+ #endif
+
+ bool _memUsage_WasSet;
+ UInt64 _memUsage_Compress;
+ UInt64 _memUsage_Decompress;
+ UInt64 _memAvail;
+
+ bool SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres);
+
+ CCommonMethodProps() { InitCommon(); }
+};
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+class CMultiMethodProps: public CCommonMethodProps
+{
+ UInt32 _level;
+ int _analysisLevel;
+
+ void InitMulti();
+public:
+ UInt32 _crcSize;
+ CObjectVector<COneMethodInfo> _methods;
+ COneMethodInfo _filterMethod;
+ bool _autoFilter;
+
+
+ void SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const;
+
+ #ifndef Z7_ST
+ static void SetMethodThreadsTo_IfNotFinded(CMethodProps &props, UInt32 numThreads);
+ static void SetMethodThreadsTo_Replace(CMethodProps &props, UInt32 numThreads);
+ #endif
+
+
+ unsigned GetNumEmptyMethods() const
+ {
+ unsigned i;
+ for (i = 0; i < _methods.Size(); i++)
+ if (!_methods[i].IsEmpty())
+ break;
+ return i;
+ }
+
+ int GetLevel() const { return _level == (UInt32)(Int32)-1 ? 5 : (int)_level; }
+ int GetAnalysisLevel() const { return _analysisLevel; }
+
+ void Init();
+ CMultiMethodProps() { InitMulti(); }
+
+ HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
+};
+
+
+class CSingleMethodProps: public COneMethodInfo, public CCommonMethodProps
+{
+ UInt32 _level;
+
+ void InitSingle()
+ {
+ _level = (UInt32)(Int32)-1;
+ }
+
+public:
+ void Init();
+ CSingleMethodProps() { InitSingle(); }
+
+ int GetLevel() const { return _level == (UInt32)(Int32)-1 ? 5 : (int)_level; }
+ HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &values);
+ HRESULT SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
+};
+
+#endif
+
+struct CHandlerTimeOptions
+{
+ CBoolPair Write_MTime;
+ CBoolPair Write_ATime;
+ CBoolPair Write_CTime;
+ UInt32 Prec;
+
+ void Init()
+ {
+ Write_MTime.Init();
+ Write_MTime.Val = true;
+ Write_ATime.Init();
+ Write_CTime.Init();
+ Prec = (UInt32)(Int32)-1;
+ }
+
+ CHandlerTimeOptions()
+ {
+ Init();
+ }
+
+ HRESULT Parse(const UString &name, const PROPVARIANT &prop, bool &processed);
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/Archive/Common/InStreamWithCRC.cpp b/CPP/7zip/Archive/Common/InStreamWithCRC.cpp
index cddc083..735d5d1 100644
--- a/CPP/7zip/Archive/Common/InStreamWithCRC.cpp
+++ b/CPP/7zip/Archive/Common/InStreamWithCRC.cpp
@@ -1,46 +1,57 @@
-// InStreamWithCRC.cpp
-
-#include "StdAfx.h"
-
-#include "InStreamWithCRC.h"
-
-STDMETHODIMP CSequentialInStreamWithCRC::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessed = 0;
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Read(data, size, &realProcessed);
- _size += realProcessed;
- if (size != 0 && realProcessed == 0)
- _wasFinished = true;
- _crc = CrcUpdate(_crc, data, realProcessed);
- if (processedSize)
- *processedSize = realProcessed;
- return result;
-}
-
-STDMETHODIMP CInStreamWithCRC::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessed = 0;
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Read(data, size, &realProcessed);
- _size += realProcessed;
- /*
- if (size != 0 && realProcessed == 0)
- _wasFinished = true;
- */
- _crc = CrcUpdate(_crc, data, realProcessed);
- if (processedSize)
- *processedSize = realProcessed;
- return result;
-}
-
-STDMETHODIMP CInStreamWithCRC::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- if (seekOrigin != STREAM_SEEK_SET || offset != 0)
- return E_FAIL;
- _size = 0;
- _crc = CRC_INIT_VAL;
- return _stream->Seek(offset, seekOrigin, newPosition);
-}
+// InStreamWithCRC.cpp
+
+#include "StdAfx.h"
+
+#include "InStreamWithCRC.h"
+
+Z7_COM7F_IMF(CSequentialInStreamWithCRC::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessed = 0;
+ HRESULT result = S_OK;
+ if (size != 0)
+ {
+ if (_stream)
+ result = _stream->Read(data, size, &realProcessed);
+ _size += realProcessed;
+ if (realProcessed == 0)
+ _wasFinished = true;
+ else
+ _crc = CrcUpdate(_crc, data, realProcessed);
+ }
+ if (processedSize)
+ *processedSize = realProcessed;
+ return result;
+}
+
+Z7_COM7F_IMF(CSequentialInStreamWithCRC::GetSize(UInt64 *size))
+{
+ *size = _fullSize;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CInStreamWithCRC::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessed = 0;
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Read(data, size, &realProcessed);
+ _size += realProcessed;
+ /*
+ if (size != 0 && realProcessed == 0)
+ _wasFinished = true;
+ */
+ _crc = CrcUpdate(_crc, data, realProcessed);
+ if (processedSize)
+ *processedSize = realProcessed;
+ return result;
+}
+
+Z7_COM7F_IMF(CInStreamWithCRC::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ if (seekOrigin != STREAM_SEEK_SET || offset != 0)
+ return E_FAIL;
+ _size = 0;
+ _crc = CRC_INIT_VAL;
+ return _stream->Seek(offset, seekOrigin, newPosition);
+}
diff --git a/CPP/7zip/Archive/Common/InStreamWithCRC.h b/CPP/7zip/Archive/Common/InStreamWithCRC.h
index 1a4b2c9..2a91d76 100644
--- a/CPP/7zip/Archive/Common/InStreamWithCRC.h
+++ b/CPP/7zip/Archive/Common/InStreamWithCRC.h
@@ -1,67 +1,67 @@
-// InStreamWithCRC.h
-
-#ifndef __IN_STREAM_WITH_CRC_H
-#define __IN_STREAM_WITH_CRC_H
-
-#include "../../../../C/7zCrc.h"
-
-#include "../../../Common/MyCom.h"
-
-#include "../../IStream.h"
-
-class CSequentialInStreamWithCRC:
- public ISequentialInStream,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-private:
- CMyComPtr<ISequentialInStream> _stream;
- UInt64 _size;
- UInt32 _crc;
- bool _wasFinished;
-public:
- void SetStream(ISequentialInStream *stream) { _stream = stream; }
- void Init()
- {
- _size = 0;
- _wasFinished = false;
- _crc = CRC_INIT_VAL;
- }
- void ReleaseStream() { _stream.Release(); }
- UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
- UInt64 GetSize() const { return _size; }
- bool WasFinished() const { return _wasFinished; }
-};
-
-class CInStreamWithCRC:
- public IInStream,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-private:
- CMyComPtr<IInStream> _stream;
- UInt64 _size;
- UInt32 _crc;
- // bool _wasFinished;
-public:
- void SetStream(IInStream *stream) { _stream = stream; }
- void Init()
- {
- _size = 0;
- // _wasFinished = false;
- _crc = CRC_INIT_VAL;
- }
- void ReleaseStream() { _stream.Release(); }
- UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
- UInt64 GetSize() const { return _size; }
- // bool WasFinished() const { return _wasFinished; }
-};
-
-#endif
+// InStreamWithCRC.h
+
+#ifndef ZIP7_INC_IN_STREAM_WITH_CRC_H
+#define ZIP7_INC_IN_STREAM_WITH_CRC_H
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+Z7_CLASS_IMP_NOQIB_2(
+ CSequentialInStreamWithCRC
+ , ISequentialInStream
+ , IStreamGetSize
+)
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt64 _size;
+ UInt32 _crc;
+ bool _wasFinished;
+ UInt64 _fullSize;
+public:
+
+ CSequentialInStreamWithCRC():
+ _fullSize((UInt64)(Int64)-1)
+ {}
+
+ void SetStream(ISequentialInStream *stream) { _stream = stream; }
+ void SetFullSize(UInt64 fullSize) { _fullSize = fullSize; }
+ void Init()
+ {
+ _size = 0;
+ _crc = CRC_INIT_VAL;
+ _wasFinished = false;
+ }
+ void ReleaseStream() { _stream.Release(); }
+ UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
+ UInt64 GetSize() const { return _size; }
+ bool WasFinished() const { return _wasFinished; }
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CInStreamWithCRC,
+ IInStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ CMyComPtr<IInStream> _stream;
+ UInt64 _size;
+ UInt32 _crc;
+ // bool _wasFinished;
+public:
+ void SetStream(IInStream *stream) { _stream = stream; }
+ void Init()
+ {
+ _size = 0;
+ // _wasFinished = false;
+ _crc = CRC_INIT_VAL;
+ }
+ void ReleaseStream() { _stream.Release(); }
+ UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
+ UInt64 GetSize() const { return _size; }
+ // bool WasFinished() const { return _wasFinished; }
+};
+
+#endif
diff --git a/CPP/7zip/Archive/Common/ItemNameUtils.cpp b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
index e0c35a9..8caf1d1 100644
--- a/CPP/7zip/Archive/Common/ItemNameUtils.cpp
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.cpp
@@ -1,88 +1,135 @@
-// Archive/Common/ItemNameUtils.cpp
-
-#include "StdAfx.h"
-
-#include "ItemNameUtils.h"
-
-namespace NArchive {
-namespace NItemName {
-
-static const wchar_t kOsPathSepar = WCHAR_PATH_SEPARATOR;
-static const wchar_t kUnixPathSepar = L'/';
-
-void ReplaceSlashes_OsToUnix
-#if WCHAR_PATH_SEPARATOR != L'/'
- (UString &name)
- {
- name.Replace(kOsPathSepar, kUnixPathSepar);
- }
-#else
- (UString &) {}
-#endif
-
-
-UString GetOsPath(const UString &name)
-{
- #if WCHAR_PATH_SEPARATOR != L'/'
- UString newName = name;
- newName.Replace(kUnixPathSepar, kOsPathSepar);
- return newName;
- #else
- return name;
- #endif
-}
-
-
-UString GetOsPath_Remove_TailSlash(const UString &name)
-{
- if (name.IsEmpty())
- return UString();
- UString newName = GetOsPath(name);
- if (newName.Back() == kOsPathSepar)
- newName.DeleteBack();
- return newName;
-}
-
-
-void ReplaceToOsSlashes_Remove_TailSlash(UString &name)
-{
- if (!name.IsEmpty())
- {
- #if WCHAR_PATH_SEPARATOR != L'/'
- name.Replace(kUnixPathSepar, kOsPathSepar);
- #endif
-
- if (name.Back() == kOsPathSepar)
- name.DeleteBack();
- }
-}
-
-
-bool HasTailSlash(const AString &name, UINT
- #if defined(_WIN32) && !defined(UNDER_CE)
- codePage
- #endif
- )
-{
- if (name.IsEmpty())
- return false;
- char c =
- #if defined(_WIN32) && !defined(UNDER_CE)
- *CharPrevExA((WORD)codePage, name, name.Ptr(name.Len()), 0);
- #else
- name.Back();
- #endif
- return (c == '/');
-}
-
-
-#ifndef _WIN32
-UString WinPathToOsPath(const UString &name)
-{
- UString newName = name;
- newName.Replace(L'\\', WCHAR_PATH_SEPARATOR);
- return newName;
-}
-#endif
-
-}}
+// Archive/Common/ItemNameUtils.cpp
+
+#include "StdAfx.h"
+
+#include "ItemNameUtils.h"
+
+namespace NArchive {
+namespace NItemName {
+
+static const wchar_t kOsPathSepar = WCHAR_PATH_SEPARATOR;
+
+#if WCHAR_PATH_SEPARATOR != L'/'
+static const wchar_t kUnixPathSepar = L'/';
+#endif
+
+void ReplaceSlashes_OsToUnix
+#if WCHAR_PATH_SEPARATOR != L'/'
+ (UString &name)
+ {
+ name.Replace(kOsPathSepar, kUnixPathSepar);
+ }
+#else
+ (UString &) {}
+#endif
+
+
+UString GetOsPath(const UString &name)
+{
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ UString newName = name;
+ newName.Replace(kUnixPathSepar, kOsPathSepar);
+ return newName;
+ #else
+ return name;
+ #endif
+}
+
+
+UString GetOsPath_Remove_TailSlash(const UString &name)
+{
+ if (name.IsEmpty())
+ return UString();
+ UString newName = GetOsPath(name);
+ if (newName.Back() == kOsPathSepar)
+ newName.DeleteBack();
+ return newName;
+}
+
+
+void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ useBackslashReplacement
+ #endif
+ )
+{
+ if (name.IsEmpty())
+ return;
+
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ {
+ // name.Replace(kUnixPathSepar, kOsPathSepar);
+ const unsigned len = name.Len();
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = name[i];
+ if (c == L'/')
+ c = WCHAR_PATH_SEPARATOR;
+ else if (useBackslashReplacement && c == L'\\')
+ c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
+ else
+ continue;
+ name.ReplaceOneCharAtPos(i, c);
+ }
+ }
+ #endif
+
+ if (name.Back() == kOsPathSepar)
+ name.DeleteBack();
+}
+
+
+void NormalizeSlashes_in_FileName_for_OsPath(wchar_t *name, unsigned len)
+{
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = name[i];
+ if (c == L'/')
+ c = L'_';
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ else if (c == L'\\')
+ c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
+ #endif
+ else
+ continue;
+ name[i] = c;
+ }
+}
+
+void NormalizeSlashes_in_FileName_for_OsPath(UString &name)
+{
+ NormalizeSlashes_in_FileName_for_OsPath(name.GetBuf(), name.Len());
+}
+
+
+bool HasTailSlash(const AString &name, UINT
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ codePage
+ #endif
+ )
+{
+ if (name.IsEmpty())
+ return false;
+ char c;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (codePage != CP_UTF8)
+ c = *CharPrevExA((WORD)codePage, name, name.Ptr(name.Len()), 0);
+ else
+ #endif
+ {
+ c = name.Back();
+ }
+ return (c == '/');
+}
+
+
+#ifndef _WIN32
+UString WinPathToOsPath(const UString &name)
+{
+ UString newName = name;
+ newName.Replace(L'\\', WCHAR_PATH_SEPARATOR);
+ return newName;
+}
+#endif
+
+}}
diff --git a/CPP/7zip/Archive/Common/ItemNameUtils.h b/CPP/7zip/Archive/Common/ItemNameUtils.h
index 404fce4..8ab9b61 100644
--- a/CPP/7zip/Archive/Common/ItemNameUtils.h
+++ b/CPP/7zip/Archive/Common/ItemNameUtils.h
@@ -1,28 +1,30 @@
-// Archive/Common/ItemNameUtils.h
-
-#ifndef __ARCHIVE_ITEM_NAME_UTILS_H
-#define __ARCHIVE_ITEM_NAME_UTILS_H
-
-#include "../../../Common/MyString.h"
-
-namespace NArchive {
-namespace NItemName {
-
-void ReplaceSlashes_OsToUnix(UString &name);
-
-UString GetOsPath(const UString &name);
-UString GetOsPath_Remove_TailSlash(const UString &name);
-
-void ReplaceToOsSlashes_Remove_TailSlash(UString &name);
-
-bool HasTailSlash(const AString &name, UINT codePage);
-
-#ifdef _WIN32
- inline UString WinPathToOsPath(const UString &name) { return name; }
-#else
- UString WinPathToOsPath(const UString &name);
-#endif
-
-}}
-
-#endif
+// Archive/Common/ItemNameUtils.h
+
+#ifndef ZIP7_INC_ARCHIVE_ITEM_NAME_UTILS_H
+#define ZIP7_INC_ARCHIVE_ITEM_NAME_UTILS_H
+
+#include "../../../Common/MyString.h"
+
+namespace NArchive {
+namespace NItemName {
+
+void ReplaceSlashes_OsToUnix(UString &name);
+
+UString GetOsPath(const UString &name);
+UString GetOsPath_Remove_TailSlash(const UString &name);
+
+void ReplaceToOsSlashes_Remove_TailSlash(UString &name, bool useBackslashReplacement = false);
+void NormalizeSlashes_in_FileName_for_OsPath(wchar_t *s, unsigned len);
+void NormalizeSlashes_in_FileName_for_OsPath(UString &name);
+
+bool HasTailSlash(const AString &name, UINT codePage);
+
+#ifdef _WIN32
+ inline UString WinPathToOsPath(const UString &name) { return name; }
+#else
+ UString WinPathToOsPath(const UString &name);
+#endif
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Common/MultiStream.cpp b/CPP/7zip/Archive/Common/MultiStream.cpp
index 39d1521..5d357af 100644
--- a/CPP/7zip/Archive/Common/MultiStream.cpp
+++ b/CPP/7zip/Archive/Common/MultiStream.cpp
@@ -1,191 +1,193 @@
-// MultiStream.cpp
-
-#include "StdAfx.h"
-
-#include "MultiStream.h"
-
-STDMETHODIMP CMultiStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- if (_pos >= _totalLength)
- return S_OK;
-
- {
- unsigned left = 0, mid = _streamIndex, right = Streams.Size();
- for (;;)
- {
- CSubStreamInfo &m = Streams[mid];
- if (_pos < m.GlobalOffset)
- right = mid;
- else if (_pos >= m.GlobalOffset + m.Size)
- left = mid + 1;
- else
- {
- _streamIndex = mid;
- break;
- }
- mid = (left + right) / 2;
- }
- _streamIndex = mid;
- }
-
- CSubStreamInfo &s = Streams[_streamIndex];
- UInt64 localPos = _pos - s.GlobalOffset;
- if (localPos != s.LocalPos)
- {
- RINOK(s.Stream->Seek(localPos, STREAM_SEEK_SET, &s.LocalPos));
- }
- UInt64 rem = s.Size - localPos;
- if (size > rem)
- size = (UInt32)rem;
- HRESULT result = s.Stream->Read(data, size, &size);
- _pos += size;
- s.LocalPos += size;
- if (processedSize)
- *processedSize = size;
- return result;
-}
-
-STDMETHODIMP CMultiStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _pos; break;
- case STREAM_SEEK_END: offset += _totalLength; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _pos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
-
-
-/*
-class COutVolumeStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- unsigned _volIndex;
- UInt64 _volSize;
- UInt64 _curPos;
- CMyComPtr<ISequentialOutStream> _volumeStream;
- COutArchive _archive;
- CCRC _crc;
-
-public:
- MY_UNKNOWN_IMP
-
- CFileItem _file;
- CUpdateOptions _options;
- CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
- void Init(IArchiveUpdateCallback2 *volumeCallback,
- const UString &name)
- {
- _file.Name = name;
- _file.IsStartPosDefined = true;
- _file.StartPos = 0;
-
- VolumeCallback = volumeCallback;
- _volIndex = 0;
- _volSize = 0;
- }
-
- HRESULT Flush();
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-HRESULT COutVolumeStream::Flush()
-{
- if (_volumeStream)
- {
- _file.UnPackSize = _curPos;
- _file.FileCRC = _crc.GetDigest();
- RINOK(WriteVolumeHeader(_archive, _file, _options));
- _archive.Close();
- _volumeStream.Release();
- _file.StartPos += _file.UnPackSize;
- }
- return S_OK;
-}
-*/
-
-/*
-STDMETHODIMP COutMultiStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- while (size > 0)
- {
- if (_streamIndex >= Streams.Size())
- {
- CSubStreamInfo subStream;
- RINOK(VolumeCallback->GetVolumeSize(Streams.Size(), &subStream.Size));
- RINOK(VolumeCallback->GetVolumeStream(Streams.Size(), &subStream.Stream));
- subStream.Pos = 0;
- Streams.Add(subStream);
- continue;
- }
- CSubStreamInfo &subStream = Streams[_streamIndex];
- if (_offsetPos >= subStream.Size)
- {
- _offsetPos -= subStream.Size;
- _streamIndex++;
- continue;
- }
- if (_offsetPos != subStream.Pos)
- {
- CMyComPtr<IOutStream> outStream;
- RINOK(subStream.Stream.QueryInterface(IID_IOutStream, &outStream));
- RINOK(outStream->Seek(_offsetPos, STREAM_SEEK_SET, NULL));
- subStream.Pos = _offsetPos;
- }
-
- UInt32 curSize = (UInt32)MyMin((UInt64)size, subStream.Size - subStream.Pos);
- UInt32 realProcessed;
- RINOK(subStream.Stream->Write(data, curSize, &realProcessed));
- data = (void *)((Byte *)data + realProcessed);
- size -= realProcessed;
- subStream.Pos += realProcessed;
- _offsetPos += realProcessed;
- _absPos += realProcessed;
- if (_absPos > _length)
- _length = _absPos;
- if (processedSize)
- *processedSize += realProcessed;
- if (subStream.Pos == subStream.Size)
- {
- _streamIndex++;
- _offsetPos = 0;
- }
- if (realProcessed != curSize && realProcessed == 0)
- return E_FAIL;
- }
- return S_OK;
-}
-
-STDMETHODIMP COutMultiStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _absPos; break;
- case STREAM_SEEK_END: offset += _length; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _absPos = offset;
- _offsetPos = _absPos;
- _streamIndex = 0;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
-*/
+// MultiStream.cpp
+
+#include "StdAfx.h"
+
+#include "MultiStream.h"
+
+Z7_COM7F_IMF(CMultiStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (_pos >= _totalLength)
+ return S_OK;
+
+ {
+ unsigned left = 0, mid = _streamIndex, right = Streams.Size();
+ for (;;)
+ {
+ CSubStreamInfo &m = Streams[mid];
+ if (_pos < m.GlobalOffset)
+ right = mid;
+ else if (_pos >= m.GlobalOffset + m.Size)
+ left = mid + 1;
+ else
+ break;
+ mid = (left + right) / 2;
+ }
+ _streamIndex = mid;
+ }
+
+ CSubStreamInfo &s = Streams[_streamIndex];
+ UInt64 localPos = _pos - s.GlobalOffset;
+ if (localPos != s.LocalPos)
+ {
+ RINOK(s.Stream->Seek((Int64)localPos, STREAM_SEEK_SET, &s.LocalPos))
+ }
+ {
+ const UInt64 rem = s.Size - localPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ const HRESULT result = s.Stream->Read(data, size, &size);
+ _pos += size;
+ s.LocalPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+Z7_COM7F_IMF(CMultiStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _pos; break;
+ case STREAM_SEEK_END: offset += _totalLength; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _pos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+/*
+class COutVolumeStream:
+ public ISequentialOutStream,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ unsigned _volIndex;
+ UInt64 _volSize;
+ UInt64 _curPos;
+ CMyComPtr<ISequentialOutStream> _volumeStream;
+ COutArchive _archive;
+ CCRC _crc;
+
+public:
+ CFileItem _file;
+ CUpdateOptions _options;
+ CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
+ void Init(IArchiveUpdateCallback2 *volumeCallback,
+ const UString &name)
+ {
+ _file.Name = name;
+ _file.IsStartPosDefined = true;
+ _file.StartPos = 0;
+
+ VolumeCallback = volumeCallback;
+ _volIndex = 0;
+ _volSize = 0;
+ }
+
+ HRESULT Flush();
+};
+
+HRESULT COutVolumeStream::Flush()
+{
+ if (_volumeStream)
+ {
+ _file.UnPackSize = _curPos;
+ _file.FileCRC = _crc.GetDigest();
+ RINOK(WriteVolumeHeader(_archive, _file, _options))
+ _archive.Close();
+ _volumeStream.Release();
+ _file.StartPos += _file.UnPackSize;
+ }
+ return S_OK;
+}
+*/
+
+/*
+
+#include "../../../Common/Defs.h"
+
+Z7_COM7F_IMF(COutMultiStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ while (size > 0)
+ {
+ if (_streamIndex >= Streams.Size())
+ {
+ CSubStreamInfo subStream;
+ RINOK(VolumeCallback->GetVolumeSize(Streams.Size(), &subStream.Size))
+ RINOK(VolumeCallback->GetVolumeStream(Streams.Size(), &subStream.Stream))
+ subStream.Pos = 0;
+ Streams.Add(subStream);
+ continue;
+ }
+ CSubStreamInfo &subStream = Streams[_streamIndex];
+ if (_offsetPos >= subStream.Size)
+ {
+ _offsetPos -= subStream.Size;
+ _streamIndex++;
+ continue;
+ }
+ if (_offsetPos != subStream.Pos)
+ {
+ CMyComPtr<IOutStream> outStream;
+ RINOK(subStream.Stream.QueryInterface(IID_IOutStream, &outStream))
+ RINOK(outStream->Seek((Int64)_offsetPos, STREAM_SEEK_SET, NULL))
+ subStream.Pos = _offsetPos;
+ }
+
+ const UInt32 curSize = (UInt32)MyMin((UInt64)size, subStream.Size - subStream.Pos);
+ UInt32 realProcessed;
+ RINOK(subStream.Stream->Write(data, curSize, &realProcessed))
+ data = (const void *)((const Byte *)data + realProcessed);
+ size -= realProcessed;
+ subStream.Pos += realProcessed;
+ _offsetPos += realProcessed;
+ _absPos += realProcessed;
+ if (_absPos > _length)
+ _length = _absPos;
+ if (processedSize)
+ *processedSize += realProcessed;
+ if (subStream.Pos == subStream.Size)
+ {
+ _streamIndex++;
+ _offsetPos = 0;
+ }
+ if (realProcessed != curSize && realProcessed == 0)
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COutMultiStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _absPos; break;
+ case STREAM_SEEK_END: offset += _length; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _absPos = (UInt64)offset;
+ _offsetPos = _absPos;
+ _streamIndex = 0;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+*/
diff --git a/CPP/7zip/Archive/Common/MultiStream.h b/CPP/7zip/Archive/Common/MultiStream.h
index 39e041d..e3096f5 100644
--- a/CPP/7zip/Archive/Common/MultiStream.h
+++ b/CPP/7zip/Archive/Common/MultiStream.h
@@ -1,89 +1,88 @@
-// MultiStream.h
-
-#ifndef __MULTI_STREAM_H
-#define __MULTI_STREAM_H
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/MyVector.h"
-
-#include "../../IStream.h"
-
-class CMultiStream:
- public IInStream,
- public CMyUnknownImp
-{
- UInt64 _pos;
- UInt64 _totalLength;
- unsigned _streamIndex;
-
-public:
-
- struct CSubStreamInfo
- {
- CMyComPtr<IInStream> Stream;
- UInt64 Size;
- UInt64 GlobalOffset;
- UInt64 LocalPos;
-
- CSubStreamInfo(): Size(0), GlobalOffset(0), LocalPos(0) {}
- };
-
- CObjectVector<CSubStreamInfo> Streams;
-
- HRESULT Init()
- {
- UInt64 total = 0;
- FOR_VECTOR (i, Streams)
- {
- CSubStreamInfo &s = Streams[i];
- s.GlobalOffset = total;
- total += Streams[i].Size;
- RINOK(s.Stream->Seek(0, STREAM_SEEK_CUR, &s.LocalPos));
- }
- _totalLength = total;
- _pos = 0;
- _streamIndex = 0;
- return S_OK;
- }
-
- MY_UNKNOWN_IMP1(IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-};
-
-/*
-class COutMultiStream:
- public IOutStream,
- public CMyUnknownImp
-{
- unsigned _streamIndex; // required stream
- UInt64 _offsetPos; // offset from start of _streamIndex index
- UInt64 _absPos;
- UInt64 _length;
-
- struct CSubStreamInfo
- {
- CMyComPtr<ISequentialOutStream> Stream;
- UInt64 Size;
- UInt64 Pos;
- };
- CObjectVector<CSubStreamInfo> Streams;
-public:
- CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
- void Init()
- {
- _streamIndex = 0;
- _offsetPos = 0;
- _absPos = 0;
- _length = 0;
- }
-
- MY_UNKNOWN_IMP1(IOutStream)
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-};
-*/
-
-#endif
+// MultiStream.h
+
+#ifndef ZIP7_INC_MULTI_STREAM_H
+#define ZIP7_INC_MULTI_STREAM_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyVector.h"
+
+#include "../../IStream.h"
+#include "../../Archive/IArchive.h"
+
+Z7_CLASS_IMP_COM_1(
+ CMultiStream
+ , IInStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ unsigned _streamIndex;
+ UInt64 _pos;
+ UInt64 _totalLength;
+
+public:
+
+ struct CSubStreamInfo
+ {
+ CMyComPtr<IInStream> Stream;
+ UInt64 Size;
+ UInt64 GlobalOffset;
+ UInt64 LocalPos;
+ CSubStreamInfo(): Size(0), GlobalOffset(0), LocalPos(0) {}
+ };
+
+ CMyComPtr<IArchiveUpdateCallbackFile> updateCallbackFile;
+ CObjectVector<CSubStreamInfo> Streams;
+
+ HRESULT Init()
+ {
+ UInt64 total = 0;
+ FOR_VECTOR (i, Streams)
+ {
+ CSubStreamInfo &s = Streams[i];
+ s.GlobalOffset = total;
+ total += s.Size;
+ s.LocalPos = 0;
+ {
+ // it was already set to start
+ // RINOK(InStream_GetPos(s.Stream, s.LocalPos));
+ }
+ }
+ _totalLength = total;
+ _pos = 0;
+ _streamIndex = 0;
+ return S_OK;
+ }
+};
+
+/*
+Z7_CLASS_IMP_COM_1(
+ COutMultiStream,
+ IOutStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ unsigned _streamIndex; // required stream
+ UInt64 _offsetPos; // offset from start of _streamIndex index
+ UInt64 _absPos;
+ UInt64 _length;
+
+ struct CSubStreamInfo
+ {
+ CMyComPtr<ISequentialOutStream> Stream;
+ UInt64 Size;
+ UInt64 Pos;
+ };
+ CObjectVector<CSubStreamInfo> Streams;
+public:
+ CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
+ void Init()
+ {
+ _streamIndex = 0;
+ _offsetPos = 0;
+ _absPos = 0;
+ _length = 0;
+ }
+};
+*/
+
+#endif
diff --git a/CPP/7zip/Archive/Common/OutStreamWithCRC.cpp b/CPP/7zip/Archive/Common/OutStreamWithCRC.cpp
index e0d3894..7dcd44a 100644
--- a/CPP/7zip/Archive/Common/OutStreamWithCRC.cpp
+++ b/CPP/7zip/Archive/Common/OutStreamWithCRC.cpp
@@ -1,18 +1,18 @@
-// OutStreamWithCRC.cpp
-
-#include "StdAfx.h"
-
-#include "OutStreamWithCRC.h"
-
-STDMETHODIMP COutStreamWithCRC::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Write(data, size, &size);
- if (_calculate)
- _crc = CrcUpdate(_crc, data, size);
- _size += size;
- if (processedSize != NULL)
- *processedSize = size;
- return result;
-}
+// OutStreamWithCRC.cpp
+
+#include "StdAfx.h"
+
+#include "OutStreamWithCRC.h"
+
+Z7_COM7F_IMF(COutStreamWithCRC::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ if (_calculate)
+ _crc = CrcUpdate(_crc, data, size);
+ _size += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
diff --git a/CPP/7zip/Archive/Common/OutStreamWithCRC.h b/CPP/7zip/Archive/Common/OutStreamWithCRC.h
index 0cc9a85..845146a 100644
--- a/CPP/7zip/Archive/Common/OutStreamWithCRC.h
+++ b/CPP/7zip/Archive/Common/OutStreamWithCRC.h
@@ -1,37 +1,35 @@
-// OutStreamWithCRC.h
-
-#ifndef __OUT_STREAM_WITH_CRC_H
-#define __OUT_STREAM_WITH_CRC_H
-
-#include "../../../../C/7zCrc.h"
-
-#include "../../../Common/MyCom.h"
-
-#include "../../IStream.h"
-
-class COutStreamWithCRC:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
- UInt64 _size;
- UInt32 _crc;
- bool _calculate;
-public:
- MY_UNKNOWN_IMP
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- void SetStream(ISequentialOutStream *stream) { _stream = stream; }
- void ReleaseStream() { _stream.Release(); }
- void Init(bool calculate = true)
- {
- _size = 0;
- _calculate = calculate;
- _crc = CRC_INIT_VAL;
- }
- void EnableCalc(bool calculate) { _calculate = calculate; }
- void InitCRC() { _crc = CRC_INIT_VAL; }
- UInt64 GetSize() const { return _size; }
- UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
-};
-
-#endif
+// OutStreamWithCRC.h
+
+#ifndef ZIP7_INC_OUT_STREAM_WITH_CRC_H
+#define ZIP7_INC_OUT_STREAM_WITH_CRC_H
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithCRC
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+ UInt32 _crc;
+ bool _calculate;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init(bool calculate = true)
+ {
+ _size = 0;
+ _calculate = calculate;
+ _crc = CRC_INIT_VAL;
+ }
+ void EnableCalc(bool calculate) { _calculate = calculate; }
+ void InitCRC() { _crc = CRC_INIT_VAL; }
+ UInt64 GetSize() const { return _size; }
+ UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
+};
+
+#endif
diff --git a/CPP/7zip/Archive/Common/OutStreamWithSha1.cpp b/CPP/7zip/Archive/Common/OutStreamWithSha1.cpp
new file mode 100644
index 0000000..57c18ec
--- /dev/null
+++ b/CPP/7zip/Archive/Common/OutStreamWithSha1.cpp
@@ -0,0 +1,18 @@
+// OutStreamWithSha1.cpp
+
+#include "StdAfx.h"
+
+#include "OutStreamWithSha1.h"
+
+Z7_COM7F_IMF(COutStreamWithSha1::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ if (_calculate)
+ Sha1_Update(Sha(), (const Byte *)data, size);
+ _size += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
diff --git a/CPP/7zip/Archive/Common/OutStreamWithSha1.h b/CPP/7zip/Archive/Common/OutStreamWithSha1.h
new file mode 100644
index 0000000..74bc53c
--- /dev/null
+++ b/CPP/7zip/Archive/Common/OutStreamWithSha1.h
@@ -0,0 +1,39 @@
+// OutStreamWithSha1.h
+
+#ifndef ZIP7_INC_OUT_STREAM_WITH_SHA1_H
+#define ZIP7_INC_OUT_STREAM_WITH_SHA1_H
+
+#include "../../../../C/Sha1.h"
+
+#include "../../../Common/MyBuffer2.h"
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithSha1
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+ // CSha1 _sha;
+ bool _calculate;
+ CAlignedBuffer1 _sha;
+
+ CSha1 *Sha() { return (CSha1 *)(void *)(Byte *)_sha; }
+public:
+ COutStreamWithSha1(): _sha(sizeof(CSha1)) {}
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init(bool calculate = true)
+ {
+ _size = 0;
+ _calculate = calculate;
+ Sha1_Init(Sha());
+ }
+ void InitSha1() { Sha1_Init(Sha()); }
+ UInt64 GetSize() const { return _size; }
+ void Final(Byte *digest) { Sha1_Final(Sha(), digest); }
+};
+
+#endif
diff --git a/CPP/7zip/Archive/Common/ParseProperties.cpp b/CPP/7zip/Archive/Common/ParseProperties.cpp
index 0fe89b3..63e4f3e 100644
--- a/CPP/7zip/Archive/Common/ParseProperties.cpp
+++ b/CPP/7zip/Archive/Common/ParseProperties.cpp
@@ -1,3 +1,3 @@
-// ParseProperties.cpp
-
-#include "StdAfx.h"
+// ParseProperties.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Archive/Common/ParseProperties.h b/CPP/7zip/Archive/Common/ParseProperties.h
index f4367a7..4ec2e48 100644
--- a/CPP/7zip/Archive/Common/ParseProperties.h
+++ b/CPP/7zip/Archive/Common/ParseProperties.h
@@ -1,6 +1,6 @@
-// ParseProperties.h
-
-#ifndef __PARSE_PROPERTIES_H
-#define __PARSE_PROPERTIES_H
-
-#endif
+// ParseProperties.h
+
+#ifndef ZIP7_INC_PARSE_PROPERTIES_H
+#define ZIP7_INC_PARSE_PROPERTIES_H
+
+#endif
diff --git a/CPP/7zip/Archive/Common/StdAfx.h b/CPP/7zip/Archive/Common/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Archive/Common/StdAfx.h
+++ b/CPP/7zip/Archive/Common/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/CpioHandler.cpp b/CPP/7zip/Archive/CpioHandler.cpp
new file mode 100644
index 0000000..872cea7
--- /dev/null
+++ b/CPP/7zip/Archive/CpioHandler.cpp
@@ -0,0 +1,1099 @@
+// CpioHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/StringToInt.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/ItemNameUtils.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NCpio {
+
+static const Byte kMagicBin0 = 0xC7;
+static const Byte kMagicBin1 = 0x71;
+
+// #define MAGIC_ASCII { '0', '7', '0', '7', '0' }
+
+static const Byte kMagicHex = '1'; // New ASCII Format
+static const Byte kMagicHexCrc = '2'; // New CRC Format
+static const Byte kMagicOct = '7'; // Portable ASCII Format
+
+static const char * const kName_TRAILER = "TRAILER!!!";
+
+static const unsigned k_BinRecord_Size = 2 + 8 * 2 + 2 * 4;
+static const unsigned k_OctRecord_Size = 6 + 8 * 6 + 2 * 11;
+static const unsigned k_HexRecord_Size = 6 + 13 * 8;
+
+static const unsigned k_RecordSize_Max = k_HexRecord_Size;
+
+enum EType
+{
+ k_Type_BinLe,
+ k_Type_BinBe,
+ k_Type_Oct,
+ k_Type_Hex,
+ k_Type_HexCrc
+};
+
+static const char * const k_Types[] =
+{
+ "Binary LE"
+ , "Binary BE"
+ , "Portable ASCII"
+ , "New ASCII"
+ , "New CRC"
+};
+
+struct CItem
+{
+ UInt32 inode;
+ unsigned MainIndex_ForInode;
+ UInt32 Mode;
+ UInt32 MTime;
+ UInt32 DevMajor;
+ UInt32 DevMinor;
+ UInt64 Size;
+ AString Name;
+ UInt32 NumLinks;
+ UInt32 UID;
+ UInt32 GID;
+ UInt32 RDevMajor;
+ UInt32 RDevMinor;
+ UInt32 ChkSum;
+
+ UInt32 AlignMask;
+ EType Type;
+
+ UInt32 HeaderSize;
+ UInt64 HeaderPos;
+
+ CByteBuffer Data; // for symlink
+
+
+ UInt32 GetAlignedSize(UInt32 size) const
+ {
+ return (size + AlignMask) & ~(UInt32)AlignMask;
+ }
+
+ UInt64 GetPackSize() const
+ {
+ const UInt64 alignMask64 = AlignMask;
+ return (Size + alignMask64) & ~(UInt64)alignMask64;
+ }
+
+ bool IsSame_inode_Dev(const CItem &item) const
+ {
+ return inode == item.inode
+ && DevMajor == item.DevMajor
+ && DevMinor == item.DevMinor;
+ }
+
+ bool IsBin() const { return Type == k_Type_BinLe || Type == k_Type_BinBe; }
+ bool IsCrcFormat() const { return Type == k_Type_HexCrc; }
+ bool IsDir() const { return MY_LIN_S_ISDIR(Mode); }
+ bool Is_SymLink() const { return MY_LIN_S_ISLNK(Mode); }
+ bool IsTrailer() const { return strcmp(Name, kName_TRAILER) == 0; }
+ UInt64 GetDataPosition() const { return HeaderPos + HeaderSize; }
+};
+
+
+enum EErrorType
+{
+ k_ErrorType_OK,
+ k_ErrorType_BadSignature,
+ k_ErrorType_Corrupted,
+ k_ErrorType_UnexpectedEnd
+};
+
+
+struct CInArchive
+{
+ EErrorType errorType;
+ ISequentialInStream *Stream;
+ UInt64 Processed;
+ CItem item;
+
+ HRESULT Read(void *data, size_t *size);
+ HRESULT GetNextItem();
+};
+
+HRESULT CInArchive::Read(void *data, size_t *size)
+{
+ const HRESULT res = ReadStream(Stream, data, size);
+ Processed += *size;
+ return res;
+}
+
+
+static bool CheckOctRecord(const Byte *p)
+{
+ for (unsigned i = 6; i < k_OctRecord_Size; i++)
+ {
+ const Byte c = p[i];
+ if (c < '0' || c > '7')
+ return false;
+ }
+ return true;
+}
+
+static bool CheckHexRecord(const Byte *p)
+{
+ for (unsigned i = 6; i < k_HexRecord_Size; i++)
+ {
+ const Byte c = p[i];
+ if ((c < '0' || c > '9') &&
+ (c < 'A' || c > 'F') &&
+ (c < 'a' || c > 'f'))
+ return false;
+ }
+ return true;
+}
+
+static UInt32 ReadHex(const Byte *p)
+{
+ char sz[16];
+ memcpy(sz, p, 8);
+ sz[8] = 0;
+ const char *end;
+ return ConvertHexStringToUInt32(sz, &end);
+}
+
+static UInt32 ReadOct6(const Byte *p)
+{
+ char sz[16];
+ memcpy(sz, p, 6);
+ sz[6] = 0;
+ const char *end;
+ return ConvertOctStringToUInt32(sz, &end);
+}
+
+static UInt64 ReadOct11(const Byte *p)
+{
+ char sz[16];
+ memcpy(sz, p, 11);
+ sz[11] = 0;
+ const char *end;
+ return ConvertOctStringToUInt64(sz, &end);
+}
+
+
+#define READ_HEX( y, dest) dest = ReadHex (p + 6 + (y) * 8);
+#define READ_OCT_6( y, dest) dest = ReadOct6 (p + 6 + (y));
+#define READ_OCT_11( y, dest) dest = ReadOct11(p + 6 + (y));
+
+#define Get32spec(p) (((UInt32)GetUi16(p) << 16) + GetUi16(p + 2))
+#define G16(offs, v) v = GetUi16(p + (offs))
+#define G32(offs, v) v = Get32spec(p + (offs))
+
+static const unsigned kNameSizeMax = 1 << 12;
+
+
+API_FUNC_static_IsArc IsArc_Cpio(const Byte *p, size_t size)
+{
+ if (size < k_BinRecord_Size)
+ return k_IsArc_Res_NEED_MORE;
+
+ UInt32 namePos;
+ UInt32 nameSize;
+ UInt32 mode;
+ UInt32 rDevMinor;
+ UInt32 rDevMajor = 0;
+
+ if (p[0] == '0')
+ {
+ if (p[1] != '7' ||
+ p[2] != '0' ||
+ p[3] != '7' ||
+ p[4] != '0')
+ return k_IsArc_Res_NO;
+ if (p[5] == kMagicOct)
+ {
+ if (size < k_OctRecord_Size)
+ return k_IsArc_Res_NEED_MORE;
+ if (!CheckOctRecord(p))
+ return k_IsArc_Res_NO;
+ READ_OCT_6 (2 * 6, mode)
+ READ_OCT_6 (6 * 6, rDevMinor)
+ READ_OCT_6 (7 * 6 + 11, nameSize)
+ namePos = k_OctRecord_Size;
+ }
+ else if (p[5] == kMagicHex || p[5] == kMagicHexCrc)
+ {
+ if (size < k_HexRecord_Size)
+ return k_IsArc_Res_NEED_MORE;
+ if (!CheckHexRecord(p))
+ return k_IsArc_Res_NO;
+ READ_HEX (1, mode)
+ READ_HEX (9, rDevMajor)
+ READ_HEX (10, rDevMinor)
+ READ_HEX (11, nameSize)
+ namePos = k_HexRecord_Size;
+ }
+ else
+ return k_IsArc_Res_NO;
+ }
+ else
+ {
+ if (p[0] == kMagicBin0 && p[1] == kMagicBin1)
+ {
+ mode = GetUi16(p + 6);
+ rDevMinor = GetUi16(p + 14);
+ nameSize = GetUi16(p + 20);
+ }
+ else if (p[0] == kMagicBin1 && p[1] == kMagicBin0)
+ {
+ mode = GetBe16(p + 6);
+ rDevMinor = GetBe16(p + 14);
+ nameSize = GetBe16(p + 20);
+ }
+ else
+ return k_IsArc_Res_NO;
+ namePos = k_BinRecord_Size;
+ }
+
+ if (mode >= (1 << 16))
+ return k_IsArc_Res_NO;
+
+ if (rDevMajor != 0 ||
+ rDevMinor != 0)
+ {
+ if (!MY_LIN_S_ISCHR(mode) &&
+ !MY_LIN_S_ISBLK(mode))
+ return k_IsArc_Res_NO;
+ }
+
+ // nameSize must include the null byte
+ if (nameSize == 0 || nameSize > kNameSizeMax)
+ return k_IsArc_Res_NO;
+ {
+ unsigned lim = namePos + nameSize - 1;
+ if (lim >= size)
+ lim = (unsigned)size;
+ else if (p[lim] != 0)
+ return k_IsArc_Res_NO;
+ for (unsigned i = namePos; i < lim; i++)
+ if (p[i] == 0)
+ return k_IsArc_Res_NO;
+ }
+
+ return k_IsArc_Res_YES;
+}
+}
+
+
+#define READ_STREAM(_dest_, _size_) \
+ { size_t processed = (_size_); RINOK(Read(_dest_, &processed)); \
+if (processed != (_size_)) { errorType = k_ErrorType_UnexpectedEnd; return S_OK; } }
+
+HRESULT CInArchive::GetNextItem()
+{
+ errorType = k_ErrorType_BadSignature;
+
+ Byte p[k_RecordSize_Max];
+
+ READ_STREAM(p, k_BinRecord_Size)
+
+ UInt32 nameSize;
+ UInt32 namePos;
+
+ /* we try to reduce probability of false detection,
+ so we check some fields for unuxpected values */
+
+ if (p[0] != '0')
+ {
+ if (p[0] == kMagicBin0 && p[1] == kMagicBin1) { item.Type = k_Type_BinLe; }
+ else if (p[0] == kMagicBin1 && p[1] == kMagicBin0)
+ {
+ for (unsigned i = 2; i < k_BinRecord_Size; i += 2)
+ {
+ const Byte b = p[i];
+ p[i] = p[i + 1];
+ p[i + 1] = b;
+ }
+ item.Type = k_Type_BinBe;
+ }
+ else
+ return S_OK;
+
+ errorType = k_ErrorType_Corrupted;
+
+ item.AlignMask = 2 - 1;
+ item.DevMajor = 0;
+ item.RDevMajor = 0;
+ item.ChkSum = 0;
+
+ G16(2, item.DevMinor);
+ G16(4, item.inode);
+ G16(6, item.Mode);
+ G16(8, item.UID);
+ G16(10, item.GID);
+ G16(12, item.NumLinks);
+ G16(14, item.RDevMinor);
+ G32(16, item.MTime);
+ G16(20, nameSize);
+ G32(22, item.Size);
+
+ namePos = k_BinRecord_Size;
+ }
+ else
+ {
+ if (p[1] != '7' ||
+ p[2] != '0' ||
+ p[3] != '7' ||
+ p[4] != '0')
+ return S_OK;
+ if (p[5] == kMagicOct)
+ {
+ errorType = k_ErrorType_Corrupted;
+
+ item.Type = k_Type_Oct;
+ READ_STREAM(p + k_BinRecord_Size, k_OctRecord_Size - k_BinRecord_Size)
+ item.AlignMask = 1 - 1;
+ item.DevMajor = 0;
+ item.RDevMajor = 0;
+ item.ChkSum = 0;
+
+ if (!CheckOctRecord(p))
+ return S_OK;
+
+ READ_OCT_6 (0, item.DevMinor)
+ READ_OCT_6 (1 * 6, item.inode)
+ READ_OCT_6 (2 * 6, item.Mode)
+ READ_OCT_6 (3 * 6, item.UID)
+ READ_OCT_6 (4 * 6, item.GID)
+ READ_OCT_6 (5 * 6, item.NumLinks)
+ READ_OCT_6 (6 * 6, item.RDevMinor)
+ {
+ UInt64 mTime64;
+ READ_OCT_11 (7 * 6, mTime64)
+ item.MTime = 0;
+ if (mTime64 <= (UInt32)(Int32)-1)
+ item.MTime = (UInt32)mTime64;
+ }
+ READ_OCT_6 (7 * 6 + 11, nameSize)
+ READ_OCT_11 (8 * 6 + 11, item.Size) // ?????
+
+ namePos = k_OctRecord_Size;
+ }
+ else
+ {
+ if (p[5] == kMagicHex) item.Type = k_Type_Hex;
+ else if (p[5] == kMagicHexCrc) item.Type = k_Type_HexCrc;
+ else return S_OK;
+
+ errorType = k_ErrorType_Corrupted;
+
+ READ_STREAM(p + k_BinRecord_Size, k_HexRecord_Size - k_BinRecord_Size)
+
+ if (!CheckHexRecord(p))
+ return S_OK;
+
+ item.AlignMask = 4 - 1;
+ READ_HEX (0, item.inode)
+ READ_HEX (1, item.Mode)
+ READ_HEX (2, item.UID)
+ READ_HEX (3, item.GID)
+ READ_HEX (4, item.NumLinks)
+ READ_HEX (5, item.MTime)
+ READ_HEX (6, item.Size)
+ READ_HEX (7, item.DevMajor)
+ READ_HEX (8, item.DevMinor)
+ READ_HEX (9, item.RDevMajor)
+ READ_HEX (10, item.RDevMinor)
+ READ_HEX (11, nameSize)
+ READ_HEX (12, item.ChkSum)
+
+ if (item.Type == k_Type_Hex && item.ChkSum != 0)
+ return S_OK;
+
+ namePos = k_HexRecord_Size;
+ }
+ }
+
+ if (item.Mode >= (1 << 16))
+ return S_OK;
+
+ if (item.RDevMinor != 0 ||
+ item.RDevMajor != 0)
+ {
+ if (!MY_LIN_S_ISCHR(item.Mode) &&
+ !MY_LIN_S_ISBLK(item.Mode))
+ return S_OK;
+ }
+
+ // Size must be 0 for FIFOs and directories
+ if (item.IsDir() || MY_LIN_S_ISFIFO(item.Mode))
+ if (item.Size != 0)
+ return S_OK;
+
+ // nameSize must include the null byte
+ if (nameSize == 0 || nameSize > kNameSizeMax)
+ return S_OK;
+ item.HeaderSize = item.GetAlignedSize(namePos + nameSize);
+ const UInt32 rem = item.HeaderSize - namePos;
+ char *s = item.Name.GetBuf(rem);
+ size_t processedSize = rem;
+ RINOK(Read(s, &processedSize))
+ if (processedSize != rem)
+ {
+ item.Name.ReleaseBuf_SetEnd(0);
+ errorType = k_ErrorType_UnexpectedEnd;
+ return S_OK;
+ }
+ bool pad_error = false;
+ for (size_t i = nameSize; i < processedSize; i++)
+ if (s[i] != 0)
+ pad_error = true;
+ item.Name.ReleaseBuf_CalcLen(nameSize);
+ if (item.Name.Len() + 1 != nameSize || pad_error)
+ return S_OK;
+ errorType = k_ErrorType_OK;
+ return S_OK;
+}
+
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CObjectVector<CItem> _items;
+ CMyComPtr<IInStream> _stream;
+ UInt64 _phySize;
+ EType _type;
+ EErrorType _error;
+ bool _isArc;
+ bool _moreThanOneHardLinks_Error;
+ bool _numLinks_Error;
+ bool _pad_Error;
+ bool _symLink_Error;
+};
+
+static const Byte kArcProps[] =
+{
+ kpidSubType
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidPosixAttrib,
+ kpidLinks,
+ kpidINode,
+ kpidUserId,
+ kpidGroupId,
+ kpidDevMajor,
+ kpidDevMinor,
+ kpidDeviceMajor,
+ kpidDeviceMinor,
+ kpidChecksum,
+ kpidSymLink,
+ kpidStreamId, // for debug
+ kpidOffset
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidSubType: prop = k_Types[(unsigned)_type]; break;
+ case kpidPhySize: prop = _phySize; break;
+ case kpidINode: prop = true; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc)
+ v |= kpv_ErrorFlags_IsNotArc;
+ switch (_error)
+ {
+ case k_ErrorType_UnexpectedEnd: v |= kpv_ErrorFlags_UnexpectedEnd; break;
+ case k_ErrorType_Corrupted: v |= kpv_ErrorFlags_HeadersError; break;
+ case k_ErrorType_OK:
+ case k_ErrorType_BadSignature:
+ // default:
+ break;
+ }
+ prop = v;
+ break;
+ }
+ case kpidWarningFlags:
+ {
+ UInt32 v = 0;
+ if (_moreThanOneHardLinks_Error)
+ v |= kpv_ErrorFlags_UnsupportedFeature; // kpv_ErrorFlags_HeadersError
+ if (_numLinks_Error
+ || _pad_Error
+ || _symLink_Error)
+ v |= kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+static int CompareItems(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const CObjectVector<CItem> &items = *(const CObjectVector<CItem> *)param;
+ const unsigned index1 = *p1;
+ const unsigned index2 = *p2;
+ const CItem &i1 = items[index1];
+ const CItem &i2 = items[index2];
+ if (i1.DevMajor < i2.DevMajor) return -1;
+ if (i1.DevMajor > i2.DevMajor) return 1;
+ if (i1.DevMinor < i2.DevMinor) return -1;
+ if (i1.DevMinor > i2.DevMinor) return 1;
+ if (i1.inode < i2.inode) return -1;
+ if (i1.inode > i2.inode) return 1;
+ if (i1.IsDir())
+ {
+ if (!i2.IsDir())
+ return -1;
+ }
+ else if (i2.IsDir())
+ return 1;
+ return MyCompare(index1, index2);
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+
+ UInt64 endPos;
+ RINOK(InStream_AtBegin_GetSize(stream, endPos))
+ if (callback)
+ {
+ RINOK(callback->SetTotal(NULL, &endPos))
+ }
+
+ CInArchive arc;
+
+ arc.Stream = stream;
+ arc.Processed = 0;
+
+ for (;;)
+ {
+ CItem &item = arc.item;
+ item.HeaderPos = arc.Processed;
+
+ RINOK(arc.GetNextItem())
+
+ _error = arc.errorType;
+
+ if (_error != k_ErrorType_OK)
+ {
+ if (_error == k_ErrorType_BadSignature ||
+ _error == k_ErrorType_Corrupted)
+ arc.Processed = item.HeaderPos;
+ break;
+ }
+
+ if (_items.IsEmpty())
+ _type = item.Type;
+ else if (_items.Back().Type != item.Type)
+ {
+ _error = k_ErrorType_Corrupted;
+ arc.Processed = item.HeaderPos;
+ break;
+ }
+
+ if (item.IsTrailer())
+ break;
+
+ item.MainIndex_ForInode = _items.Size();
+ _items.Add(item);
+
+ const UInt64 dataSize = item.GetPackSize();
+ arc.Processed += dataSize;
+ if (arc.Processed > endPos)
+ {
+ _error = k_ErrorType_UnexpectedEnd;
+ break;
+ }
+
+ if (item.Is_SymLink() && dataSize <= (1 << 12) && item.Size != 0)
+ {
+ size_t cur = (size_t)dataSize;
+ CByteBuffer buf;
+ buf.Alloc(cur);
+ RINOK(ReadStream(stream, buf, &cur))
+ if (cur != dataSize)
+ {
+ _error = k_ErrorType_UnexpectedEnd;
+ break;
+ }
+ size_t i;
+
+ for (i = (size_t)item.Size; i < dataSize; i++)
+ if (buf[i] != 0)
+ break;
+ if (i != dataSize)
+ _pad_Error = true;
+
+ for (i = 0; i < (size_t)item.Size; i++)
+ if (buf[i] == 0)
+ break;
+ if (i != (size_t)item.Size)
+ _symLink_Error = true;
+ else
+ _items.Back().Data.CopyFrom(buf, (size_t)item.Size);
+ }
+ else if (dataSize != 0)
+ {
+ UInt64 newPos;
+ RINOK(stream->Seek((Int64)dataSize, STREAM_SEEK_CUR, &newPos))
+ if (arc.Processed != newPos)
+ return E_FAIL;
+ }
+
+ if (callback && (_items.Size() & 0xFFF) == 0)
+ {
+ const UInt64 numFiles = _items.Size();
+ RINOK(callback->SetCompleted(&numFiles, &item.HeaderPos))
+ }
+ }
+
+ _phySize = arc.Processed;
+ }
+
+ {
+ if (_error != k_ErrorType_OK)
+ {
+ // we try to reduce probability of false detection
+ if (_items.Size() == 0)
+ return S_FALSE;
+ // bin file uses small signature. So we do additional check for single item case.
+ if (_items.Size() == 1 && _items[0].IsBin())
+ return S_FALSE;
+ }
+ else
+ {
+ // Read tailing zeros.
+ // Most of cpio files use 512-bytes aligned zeros
+ // rare case: 4K/8K aligment is possible also
+ const unsigned kTailSize_MAX = 1 << 9;
+ Byte buf[kTailSize_MAX];
+
+ unsigned pos = (unsigned)_phySize & (kTailSize_MAX - 1);
+ if (pos != 0) // use this check to support 512 bytes alignment only
+ for (;;)
+ {
+ const unsigned rem = kTailSize_MAX - pos;
+ size_t processed = rem;
+ RINOK(ReadStream(stream, buf + pos, &processed))
+ if (processed != rem)
+ break;
+ for (; pos < kTailSize_MAX && buf[pos] == 0; pos++)
+ {}
+ if (pos != kTailSize_MAX)
+ break;
+ _phySize += processed;
+ pos = 0;
+
+ // use break to support 512 bytes alignment zero tail
+ // don't use break to support 512*n bytes alignment zero tail
+ break;
+ }
+ }
+ }
+
+ {
+ /* there was such cpio archive example with hard links:
+ {
+ all hard links (same dev/inode) are stored in neighboring items, and
+ (item.Size == 0) for non last hard link items
+ (item.Size != 0) for last hard link item
+ }
+ but here we sort items by (dev/inode) to support cases
+ where hard links (same dev/inode) are not stored in neighboring items.
+
+ // note: some cpio files have (numLinks == 0) ??
+ */
+
+ CUIntVector indices;
+ {
+ const unsigned numItems = _items.Size();
+ indices.ClearAndSetSize(numItems);
+ if (numItems != 0)
+ {
+ unsigned *vals = &indices[0];
+ for (unsigned i = 0; i < numItems; i++)
+ vals[i] = i;
+ indices.Sort(CompareItems, (void *)&_items);
+ }
+ }
+
+ /* Note: if cpio archive (maybe incorrect) contains
+ more then one non empty streams with identical inode number,
+ we want to extract all such data streams too.
+
+ So we place items with identical inode to groups:
+ all items in group will have same MainIndex_ForInode,
+ that is index of last item in group with (Size != 0).
+ Another (non last) items in group have (Size == 0).
+ If there are another hard links with same inode number
+ after (Size != 0) item, we place them to another next group(s).
+
+ Check it: maybe we should use single group for items
+ with identical inode instead, and ignore some extra data streams ?
+ */
+
+ for (unsigned i = 0; i < indices.Size();)
+ {
+ unsigned k;
+ {
+ const CItem &item_Base = _items[indices[i]];
+
+ if (item_Base.IsDir())
+ {
+ i++;
+ continue;
+ }
+
+ if (i != 0)
+ {
+ const CItem &item_Prev = _items[indices[i - 1]];
+ if (!item_Prev.IsDir())
+ if (item_Base.IsSame_inode_Dev(item_Prev))
+ _moreThanOneHardLinks_Error = true;
+ }
+
+ if (item_Base.Size != 0)
+ {
+ if (item_Base.NumLinks != 1)
+ _numLinks_Error = true;
+ i++;
+ continue;
+ }
+
+ for (k = i + 1; k < indices.Size();)
+ {
+ const CItem &item = _items[indices[k]];
+ if (item.IsDir())
+ break;
+ if (!item.IsSame_inode_Dev(item_Base))
+ break;
+ k++;
+ if (item.Size != 0)
+ break;
+ }
+ }
+
+ const unsigned numLinks = k - i;
+ for (;;)
+ {
+ CItem &item = _items[indices[i]];
+ if (item.NumLinks != numLinks)
+ _numLinks_Error = true;
+ if (++i == k)
+ break;
+ // if (item.Size == 0)
+ item.MainIndex_ForInode = indices[k - 1];
+ }
+ }
+ }
+
+ _isArc = true;
+ _stream = stream;
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _items.Clear();
+ _stream.Release();
+ _phySize = 0;
+ _type = k_Type_BinLe;
+ _isArc = false;
+ _moreThanOneHardLinks_Error = false;
+ _numLinks_Error = false;
+ _pad_Error = false;
+ _symLink_Error = false;
+ _error = k_ErrorType_OK;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ const CItem &item = _items[index];
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString res;
+ bool needConvert = true;
+ #ifdef _WIN32
+ // if (
+ ConvertUTF8ToUnicode(item.Name, res);
+ // )
+ needConvert = false;
+ #endif
+ if (needConvert)
+ res = MultiByteToUnicodeString(item.Name, CP_OEMCP);
+ prop = NItemName::GetOsPath(res);
+ break;
+ }
+ case kpidIsDir: prop = item.IsDir(); break;
+
+ case kpidSize:
+ prop = (UInt64)_items[item.MainIndex_ForInode].Size;
+ break;
+
+ case kpidPackSize:
+ prop = (UInt64)item.GetPackSize();
+ break;
+
+ case kpidMTime:
+ {
+ if (item.MTime != 0)
+ PropVariant_SetFrom_UnixTime(prop, item.MTime);
+ break;
+ }
+ case kpidPosixAttrib: prop = item.Mode; break;
+ case kpidINode: prop = item.inode; break;
+ case kpidStreamId:
+ if (!item.IsDir())
+ prop = (UInt32)item.MainIndex_ForInode;
+ break;
+ case kpidDevMajor: prop = (UInt32)item.DevMajor; break;
+ case kpidDevMinor: prop = (UInt32)item.DevMinor; break;
+
+ case kpidUserId: prop = item.UID; break;
+ case kpidGroupId: prop = item.GID; break;
+
+ case kpidSymLink:
+ if (item.Is_SymLink() && item.Data.Size() != 0)
+ {
+ AString s;
+ s.SetFrom_CalcLen((const char *)(const void *)(const Byte *)item.Data, (unsigned)item.Data.Size());
+ if (s.Len() == item.Data.Size())
+ {
+ UString u;
+ bool needConvert = true;
+ #ifdef _WIN32
+ // if (
+ ConvertUTF8ToUnicode(item.Name, u);
+ // )
+ needConvert = false;
+ #endif
+ if (needConvert)
+ u = MultiByteToUnicodeString(s, CP_OEMCP);
+ prop = u;
+ }
+ }
+ break;
+
+ case kpidLinks: prop = item.NumLinks; break;
+ case kpidDeviceMajor:
+ // if (item.RDevMajor != 0)
+ prop = (UInt32)item.RDevMajor;
+ break;
+ case kpidDeviceMinor:
+ // if (item.RDevMinor != 0)
+ prop = (UInt32)item.RDevMinor;
+ break;
+ case kpidChecksum:
+ if (item.IsCrcFormat())
+ prop = item.ChkSum;
+ break;
+ case kpidOffset: prop = item.GetDataPosition(); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithSum
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+ UInt32 _crc;
+ bool _calculate;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init(bool calculate = true)
+ {
+ _size = 0;
+ _calculate = calculate;
+ _crc = 0;
+ }
+ void EnableCalc(bool calculate) { _calculate = calculate; }
+ void InitCRC() { _crc = 0; }
+ UInt64 GetSize() const { return _size; }
+ UInt32 GetCRC() const { return _crc; }
+};
+
+Z7_COM7F_IMF(COutStreamWithSum::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ if (_calculate)
+ {
+ UInt32 crc = 0;
+ for (UInt32 i = 0; i < size; i++)
+ crc += (UInt32)(((const Byte *)data)[i]);
+ _crc += crc;
+ }
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item2 = _items[index];
+ const CItem &item = _items[item2.MainIndex_ForInode];
+ totalSize += item.Size;
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ COutStreamWithSum *outStreamSumSpec = new COutStreamWithSum;
+ CMyComPtr<ISequentialOutStream> outStreamSum(outStreamSumSpec);
+
+ UInt64 total_PackSize = 0;
+ UInt64 total_UnpackSize = 0;
+
+ for (i = 0;; i++)
+ {
+ lps->InSize = total_PackSize;
+ lps->OutSize = total_UnpackSize;
+ RINOK(lps->SetCur())
+ if (i >= numItems)
+ break;
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item2 = _items[index];
+ const CItem &item = _items[item2.MainIndex_ForInode];
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+
+ total_PackSize += item2.GetPackSize();
+ total_UnpackSize += item.Size;
+
+ if (item2.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ if (!testMode && !outStream)
+ continue;
+ outStreamSumSpec->Init(item.IsCrcFormat());
+ outStreamSumSpec->SetStream(outStream);
+ outStream.Release();
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(InStream_SeekSet(_stream, item.GetDataPosition()))
+ streamSpec->Init(item.Size);
+ RINOK(copyCoder->Code(inStream, outStreamSum, NULL, NULL, progress))
+ outStreamSumSpec->ReleaseStream();
+ Int32 res = NExtract::NOperationResult::kDataError;
+ if (copyCoderSpec->TotalSize == item.Size)
+ {
+ res = NExtract::NOperationResult::kOK;
+ if (item.IsCrcFormat() && item.ChkSum != outStreamSumSpec->GetCRC())
+ res = NExtract::NOperationResult::kCRCError;
+ }
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ const CItem &item2 = _items[index];
+ const CItem &item = _items[item2.MainIndex_ForInode];
+ return CreateLimitedInStream(_stream, item.GetDataPosition(), item.Size, stream);
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = {
+ 5, '0', '7', '0', '7', '0',
+ 2, kMagicBin0, kMagicBin1,
+ 2, kMagicBin1, kMagicBin0 };
+
+REGISTER_ARC_I(
+ "Cpio", "cpio", NULL, 0xED,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kMultiSignature,
+ IsArc_Cpio)
+
+}}
diff --git a/CPP/7zip/Archive/CramfsHandler.cpp b/CPP/7zip/Archive/CramfsHandler.cpp
new file mode 100644
index 0000000..fd83f71
--- /dev/null
+++ b/CPP/7zip/Archive/CramfsHandler.cpp
@@ -0,0 +1,784 @@
+// CramfsHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/LzmaDec.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+namespace NArchive {
+namespace NCramfs {
+
+static const Byte kSignature[] =
+ { 'C','o','m','p','r','e','s','s','e','d',' ','R','O','M','F','S' };
+
+static const UInt32 kArcSizeMax = (256 + 16) << 20;
+static const UInt32 kNumFilesMax = (1 << 19);
+static const unsigned kNumDirLevelsMax = (1 << 8);
+
+static const UInt32 kHeaderSize = 0x40;
+static const unsigned kHeaderNameSize = 16;
+static const UInt32 kNodeSize = 12;
+
+static const UInt32 kFlag_FsVer2 = (1 << 0);
+
+static const unsigned k_Flags_BlockSize_Shift = 11;
+static const unsigned k_Flags_BlockSize_Mask = 7;
+static const unsigned k_Flags_Method_Shift = 14;
+static const unsigned k_Flags_Method_Mask = 3;
+
+/*
+ There is possible collision in flags:
+ - Original CramFS writes 0 in method field. But it uses ZLIB.
+ - Modified CramFS writes 0 in method field for "NONE" compression?
+ How to solve that collision?
+*/
+
+#define k_Flags_Method_NONE 0
+#define k_Flags_Method_ZLIB 1
+#define k_Flags_Method_LZMA 2
+
+static const char * const k_Methods[] =
+{
+ "Copy"
+ , "ZLIB"
+ , "LZMA"
+ , "Unknown"
+};
+
+static const CUInt32PCharPair k_Flags[] =
+{
+ { 0, "Ver2" },
+ { 1, "SortedDirs" },
+ { 8, "Holes" },
+ { 9, "WrongSignature" },
+ { 10, "ShiftedRootOffset" }
+};
+
+static const unsigned kBlockSizeLog = 12;
+
+/*
+struct CNode
+{
+ UInt16 Mode;
+ UInt16 Uid;
+ UInt32 Size;
+ Byte Gid;
+ UInt32 NameLen;
+ UInt32 Offset;
+
+ void Parse(const Byte *p)
+ {
+ Mode = GetUi16(p);
+ Uid = GetUi16(p + 2);
+ Size = Get32(p + 4) & 0xFFFFFF;
+ Gid = p[7];
+ NameLen = p[8] & 0x3F;
+ Offset = Get32(p + 8) >> 6;
+ }
+};
+*/
+
+#define Get32(p) (be ? GetBe32(p) : GetUi32(p))
+
+static UInt32 GetMode(const Byte *p, bool be) { return be ? GetBe16(p) : GetUi16(p); }
+static bool IsDir(const Byte *p, bool be) { return MY_LIN_S_ISDIR(GetMode(p, be)); }
+
+static UInt32 GetSize(const Byte *p, bool be)
+{
+ if (be)
+ return GetBe32(p + 4) >> 8;
+ else
+ return GetUi32(p + 4) & 0xFFFFFF;
+}
+
+static UInt32 GetNameLen(const Byte *p, bool be)
+{
+ if (be)
+ return (p[8] & 0xFC);
+ else
+ return ((UInt32)p[8] & (UInt32)0x3F) << 2;
+}
+
+static UInt32 GetOffset(const Byte *p, bool be)
+{
+ if (be)
+ return (GetBe32(p + 8) & 0x03FFFFFF) << 2;
+ else
+ return GetUi32(p + 8) >> 6 << 2;
+}
+
+struct CItem
+{
+ UInt32 Offset;
+ int Parent;
+};
+
+struct CHeader
+{
+ bool be;
+ UInt32 Size;
+ UInt32 Flags;
+ // UInt32 Future;
+ UInt32 Crc;
+ // UInt32 Edition;
+ UInt32 NumBlocks;
+ UInt32 NumFiles;
+ char Name[kHeaderNameSize];
+
+ bool Parse(const Byte *p)
+ {
+ if (memcmp(p + 16, kSignature, Z7_ARRAY_SIZE(kSignature)) != 0)
+ return false;
+ switch (GetUi32(p))
+ {
+ case 0x28CD3D45: be = false; break;
+ case 0x453DCD28: be = true; break;
+ default: return false;
+ }
+ Size = Get32(p + 4);
+ Flags = Get32(p + 8);
+ // Future = Get32(p + 0xC);
+ Crc = Get32(p + 0x20);
+ // Edition = Get32(p + 0x24);
+ NumBlocks = Get32(p + 0x28);
+ NumFiles = Get32(p + 0x2C);
+ memcpy(Name, p + 0x30, kHeaderNameSize);
+ return true;
+ }
+
+ bool IsVer2() const { return (Flags & kFlag_FsVer2) != 0; }
+ unsigned GetBlockSizeShift() const { return (unsigned)(Flags >> k_Flags_BlockSize_Shift) & k_Flags_BlockSize_Mask; }
+ unsigned GetMethod() const { return (unsigned)(Flags >> k_Flags_Method_Shift) & k_Flags_Method_Mask; }
+};
+
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CRecordVector<CItem> _items;
+ CMyComPtr<IInStream> _stream;
+ Byte *_data;
+ UInt32 _size;
+ UInt32 _headersSize;
+
+ UInt32 _errorFlags;
+ bool _isArc;
+
+ CHeader _h;
+ UInt32 _phySize;
+
+ unsigned _method;
+ unsigned _blockSizeLog;
+
+ // Current file
+
+ NCompress::NZlib::CDecoder *_zlibDecoderSpec;
+ CMyComPtr<ICompressCoder> _zlibDecoder;
+
+ CBufInStream *_inStreamSpec;
+ CMyComPtr<ISequentialInStream> _inStream;
+
+ CBufPtrSeqOutStream *_outStreamSpec;
+ CMyComPtr<ISequentialOutStream> _outStream;
+
+ UInt32 _curBlocksOffset;
+ UInt32 _curNumBlocks;
+
+ HRESULT OpenDir(int parent, UInt32 baseOffsetBase, unsigned level);
+ HRESULT Open2(IInStream *inStream);
+ AString GetPath(unsigned index) const;
+ bool GetPackSize(unsigned index, UInt32 &res) const;
+ void Free();
+
+ UInt32 GetNumBlocks(UInt32 size) const
+ {
+ return (size + ((UInt32)1 << _blockSizeLog) - 1) >> _blockSizeLog;
+ }
+
+ void UpdatePhySize(UInt32 s)
+ {
+ if (_phySize < s)
+ _phySize = s;
+ }
+
+public:
+ CHandler(): _data(NULL) {}
+ ~CHandler() { Free(); }
+ HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize);
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidPosixAttrib
+ // kpidOffset
+};
+
+static const Byte kArcProps[] =
+{
+ kpidVolumeName,
+ kpidBigEndian,
+ kpidCharacts,
+ kpidClusterSize,
+ kpidMethod,
+ kpidHeadersSize,
+ kpidNumSubFiles,
+ kpidNumBlocks
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+HRESULT CHandler::OpenDir(int parent, UInt32 baseOffset, unsigned level)
+{
+ const Byte *p = _data + baseOffset;
+ bool be = _h.be;
+ if (!IsDir(p, be))
+ return S_OK;
+ UInt32 offset = GetOffset(p, be);
+ UInt32 size = GetSize(p, be);
+ if (offset == 0 && size == 0)
+ return S_OK;
+ UInt32 end = offset + size;
+ if (offset < kHeaderSize || end > _size || level > kNumDirLevelsMax)
+ return S_FALSE;
+ UpdatePhySize(end);
+ if (end > _headersSize)
+ _headersSize = end;
+
+ unsigned startIndex = _items.Size();
+
+ while (size != 0)
+ {
+ if (size < kNodeSize || (UInt32)_items.Size() >= kNumFilesMax)
+ return S_FALSE;
+ CItem item;
+ item.Parent = parent;
+ item.Offset = offset;
+ _items.Add(item);
+ UInt32 nodeLen = kNodeSize + GetNameLen(_data + offset, be);
+ if (size < nodeLen)
+ return S_FALSE;
+ offset += nodeLen;
+ size -= nodeLen;
+ }
+
+ unsigned endIndex = _items.Size();
+ for (unsigned i = startIndex; i < endIndex; i++)
+ {
+ RINOK(OpenDir((int)i, _items[i].Offset, level + 1))
+ }
+ return S_OK;
+}
+
+HRESULT CHandler::Open2(IInStream *inStream)
+{
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(inStream, buf, kHeaderSize))
+ if (!_h.Parse(buf))
+ return S_FALSE;
+ _method = k_Flags_Method_ZLIB;
+ _blockSizeLog = kBlockSizeLog;
+ _phySize = kHeaderSize;
+ if (_h.IsVer2())
+ {
+ _method = _h.GetMethod();
+ // FIT IT. Now we don't know correct way to work with collision in method field.
+ if (_method == k_Flags_Method_NONE)
+ _method = k_Flags_Method_ZLIB;
+ _blockSizeLog = kBlockSizeLog + _h.GetBlockSizeShift();
+ if (_h.Size < kHeaderSize || _h.Size > kArcSizeMax || _h.NumFiles > kNumFilesMax)
+ return S_FALSE;
+ _phySize = _h.Size;
+ }
+ else
+ {
+ UInt64 size;
+ RINOK(InStream_GetSize_SeekToEnd(inStream, size))
+ if (size > kArcSizeMax)
+ size = kArcSizeMax;
+ _h.Size = (UInt32)size;
+ RINOK(InStream_SeekSet(inStream, kHeaderSize))
+ }
+ _data = (Byte *)MidAlloc(_h.Size);
+ if (!_data)
+ return E_OUTOFMEMORY;
+ memcpy(_data, buf, kHeaderSize);
+ size_t processed = _h.Size - kHeaderSize;
+ RINOK(ReadStream(inStream, _data + kHeaderSize, &processed))
+ if (processed < kNodeSize)
+ return S_FALSE;
+ _size = kHeaderSize + (UInt32)processed;
+ if (_h.IsVer2())
+ {
+ if (_size != _h.Size)
+ _errorFlags = kpv_ErrorFlags_UnexpectedEnd;
+ else
+ {
+ SetUi32(_data + 0x20, 0)
+ if (CrcCalc(_data, _h.Size) != _h.Crc)
+ {
+ _errorFlags = kpv_ErrorFlags_HeadersError;
+ // _errorMessage = "CRC error";
+ }
+ }
+ if (_h.NumFiles >= 1)
+ _items.ClearAndReserve(_h.NumFiles - 1);
+ }
+
+ RINOK(OpenDir(-1, kHeaderSize, 0))
+
+ if (!_h.IsVer2())
+ {
+ FOR_VECTOR (i, _items)
+ {
+ const CItem &item = _items[i];
+ const Byte *p = _data + item.Offset;
+ bool be = _h.be;
+ if (IsDir(p, be))
+ continue;
+ UInt32 offset = GetOffset(p, be);
+ if (offset < kHeaderSize)
+ continue;
+ UInt32 numBlocks = GetNumBlocks(GetSize(p, be));
+ if (numBlocks == 0)
+ continue;
+ UInt32 start = offset + numBlocks * 4;
+ if (start > _size)
+ continue;
+ UInt32 end = Get32(_data + start - 4);
+ if (end >= start)
+ UpdatePhySize(end);
+ }
+
+ // Read tailing zeros. Most cramfs archives use 4096-bytes aligned zeros
+ const UInt32 kTailSize_MAX = 1 << 12;
+ UInt32 endPos = (_phySize + kTailSize_MAX - 1) & ~(kTailSize_MAX - 1);
+ if (endPos > _size)
+ endPos = _size;
+ UInt32 pos;
+ for (pos = _phySize; pos < endPos && _data[pos] == 0; pos++);
+ if (pos == endPos)
+ _phySize = endPos;
+ }
+ return S_OK;
+}
+
+AString CHandler::GetPath(unsigned index) const
+{
+ unsigned len = 0;
+ unsigned indexMem = index;
+ for (;;)
+ {
+ const CItem &item = _items[index];
+ const Byte *p = _data + item.Offset;
+ unsigned size = GetNameLen(p, _h.be);
+ p += kNodeSize;
+ unsigned i;
+ for (i = 0; i < size && p[i]; i++);
+ len += i + 1;
+ index = (unsigned)item.Parent;
+ if (item.Parent < 0)
+ break;
+ }
+ len--;
+
+ AString path;
+ char *dest = path.GetBuf_SetEnd(len) + len;
+ index = indexMem;
+ for (;;)
+ {
+ const CItem &item = _items[index];
+ const Byte *p = _data + item.Offset;
+ unsigned size = GetNameLen(p, _h.be);
+ p += kNodeSize;
+ unsigned i;
+ for (i = 0; i < size && p[i]; i++);
+ dest -= i;
+ memcpy(dest, p, i);
+ index = (unsigned)item.Parent;
+ if (item.Parent < 0)
+ break;
+ *(--dest) = CHAR_PATH_SEPARATOR;
+ }
+ return path;
+}
+
+bool CHandler::GetPackSize(unsigned index, UInt32 &res) const
+{
+ res = 0;
+ const CItem &item = _items[index];
+ const Byte *p = _data + item.Offset;
+ const bool be = _h.be;
+ const UInt32 offset = GetOffset(p, be);
+ if (offset < kHeaderSize)
+ return false;
+ const UInt32 numBlocks = GetNumBlocks(GetSize(p, be));
+ if (numBlocks == 0)
+ return true;
+ const UInt32 start = offset + numBlocks * 4;
+ if (start > _size)
+ return false;
+ const UInt32 end = Get32(_data + start - 4);
+ if (end < start)
+ return false;
+ res = end - start;
+ return true;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* callback */))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ RINOK(Open2(stream))
+ _isArc = true;
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+void CHandler::Free()
+{
+ MidFree(_data);
+ _data = NULL;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _phySize = 0;
+ _errorFlags = 0;
+ _headersSize = 0;
+ _items.Clear();
+ _stream.Release();
+ Free();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidVolumeName:
+ {
+ char dest[kHeaderNameSize + 4];
+ memcpy(dest, _h.Name, kHeaderNameSize);
+ dest[kHeaderNameSize] = 0;
+ prop = dest;
+ break;
+ }
+ case kpidBigEndian: prop = _h.be; break;
+ case kpidCharacts: FLAGS_TO_PROP(k_Flags, _h.Flags, prop); break;
+ case kpidMethod: prop = k_Methods[_method]; break;
+ case kpidClusterSize: prop = (UInt32)1 << _blockSizeLog; break;
+ case kpidNumBlocks: if (_h.IsVer2()) prop = _h.NumBlocks; break;
+ case kpidNumSubFiles: if (_h.IsVer2()) prop = _h.NumFiles; break;
+ case kpidPhySize: prop = _phySize; break;
+ case kpidHeadersSize: prop = _headersSize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = _errorFlags;
+ if (!_isArc)
+ v |= kpv_ErrorFlags_IsNotArc;
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CItem &item = _items[index];
+ const Byte *p = _data + item.Offset;
+ bool be = _h.be;
+ bool isDir = IsDir(p, be);
+ switch (propID)
+ {
+ case kpidPath: prop = MultiByteToUnicodeString(GetPath(index), CP_OEMCP); break;
+ case kpidIsDir: prop = isDir; break;
+ // case kpidOffset: prop = (UInt32)GetOffset(p, be); break;
+ case kpidSize: if (!isDir) prop = GetSize(p, be); break;
+ case kpidPackSize:
+ if (!isDir)
+ {
+ UInt32 size;
+ if (GetPackSize(index, size))
+ prop = size;
+ }
+ break;
+ case kpidPosixAttrib: prop = (UInt32)GetMode(p, be); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+class CCramfsInStream: public CCachedInStream
+{
+ HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) Z7_override;
+public:
+ CHandler *Handler;
+};
+
+HRESULT CCramfsInStream::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
+{
+ return Handler->ReadBlock(blockIndex, dest, blockSize);
+}
+
+HRESULT CHandler::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
+{
+ if (_method == k_Flags_Method_ZLIB)
+ {
+ if (!_zlibDecoder)
+ {
+ _zlibDecoderSpec = new NCompress::NZlib::CDecoder();
+ _zlibDecoder = _zlibDecoderSpec;
+ }
+ }
+ else
+ {
+ if (_method != k_Flags_Method_LZMA)
+ {
+ // probably we must support no-compression archives here.
+ return E_NOTIMPL;
+ }
+ }
+
+ const bool be = _h.be;
+ const Byte *p2 = _data + (_curBlocksOffset + (UInt32)blockIndex * 4);
+ const UInt32 start = (blockIndex == 0 ? _curBlocksOffset + _curNumBlocks * 4: Get32(p2 - 4));
+ const UInt32 end = Get32(p2);
+ if (end < start || end > _size)
+ return S_FALSE;
+ const UInt32 inSize = end - start;
+
+ if (_method == k_Flags_Method_LZMA)
+ {
+ const unsigned kLzmaHeaderSize = LZMA_PROPS_SIZE + 4;
+ if (inSize < kLzmaHeaderSize)
+ return S_FALSE;
+ const Byte *p = _data + start;
+ UInt32 destSize32 = GetUi32(p + LZMA_PROPS_SIZE);
+ if (destSize32 > blockSize)
+ return S_FALSE;
+ SizeT destLen = destSize32;
+ SizeT srcLen = inSize - kLzmaHeaderSize;
+ ELzmaStatus status;
+ SRes res = LzmaDecode(dest, &destLen, p + kLzmaHeaderSize, &srcLen,
+ p, LZMA_PROPS_SIZE, LZMA_FINISH_END, &status, &g_Alloc);
+ if (res != SZ_OK
+ || (status != LZMA_STATUS_FINISHED_WITH_MARK &&
+ status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+ || destLen != destSize32
+ || srcLen != inSize - kLzmaHeaderSize)
+ return S_FALSE;
+ return S_OK;
+ }
+
+ if (!_inStream)
+ {
+ _inStreamSpec = new CBufInStream();
+ _inStream = _inStreamSpec;
+ }
+ if (!_outStream)
+ {
+ _outStreamSpec = new CBufPtrSeqOutStream();
+ _outStream = _outStreamSpec;
+ }
+ _inStreamSpec->Init(_data + start, inSize);
+ _outStreamSpec->Init(dest, blockSize);
+ RINOK(_zlibDecoder->Code(_inStream, _outStream, NULL, NULL, NULL))
+ return (inSize == _zlibDecoderSpec->GetInputProcessedSize() &&
+ _outStreamSpec->GetPos() == blockSize) ? S_OK : S_FALSE;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ bool be = _h.be;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const Byte *p = _data + _items[allFilesMode ? i : indices[i]].Offset;
+ if (!IsDir(p, be))
+ totalSize += GetSize(p, be);
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = _items[index];
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ const Byte *p = _data + item.Offset;
+
+ if (IsDir(p, be))
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ UInt32 curSize = GetSize(p, be);
+ totalSize += curSize;
+ UInt32 packSize;
+ if (GetPackSize(index, packSize))
+ totalPackSize += packSize;
+
+ if (!testMode && !outStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ UInt32 offset = GetOffset(p, be);
+ if (offset < kHeaderSize)
+ curSize = 0;
+
+ int res = NExtract::NOperationResult::kDataError;
+ {
+ CMyComPtr<ISequentialInStream> inSeqStream;
+ HRESULT hres = GetStream(index, &inSeqStream);
+ if (hres == E_OUTOFMEMORY)
+ return E_OUTOFMEMORY;
+ if (hres == S_FALSE || !inSeqStream)
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ {
+ RINOK(hres)
+ {
+ hres = copyCoder->Code(inSeqStream, outStream, NULL, NULL, progress);
+ if (hres == S_OK)
+ {
+ if (copyCoderSpec->TotalSize == curSize)
+ res = NExtract::NOperationResult::kOK;
+ }
+ else if (hres == E_NOTIMPL)
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (hres != S_FALSE)
+ return hres;
+ }
+ }
+ }
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+
+ const CItem &item = _items[index];
+ const Byte *p = _data + item.Offset;
+
+ bool be = _h.be;
+ if (IsDir(p, be))
+ return E_FAIL;
+
+ UInt32 size = GetSize(p, be);
+ UInt32 numBlocks = GetNumBlocks(size);
+ UInt32 offset = GetOffset(p, be);
+ if (offset < kHeaderSize)
+ {
+ if (offset != 0)
+ return S_FALSE;
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+ streamSpec->Init(NULL, 0);
+ *stream = streamTemp.Detach();
+ return S_OK;
+ }
+
+ if (offset + numBlocks * 4 > _size)
+ return S_FALSE;
+ UInt32 prev = offset;
+ for (UInt32 i = 0; i < numBlocks; i++)
+ {
+ UInt32 next = Get32(_data + offset + i * 4);
+ if (next < prev || next > _size)
+ return S_FALSE;
+ prev = next;
+ }
+
+ CCramfsInStream *streamSpec = new CCramfsInStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+ _curNumBlocks = numBlocks;
+ _curBlocksOffset = offset;
+ streamSpec->Handler = this;
+ if (!streamSpec->Alloc(_blockSizeLog, 21 - _blockSizeLog))
+ return E_OUTOFMEMORY;
+ streamSpec->Init(size);
+ *stream = streamTemp.Detach();
+
+ return S_OK;
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "CramFS", "cramfs", NULL, 0xD3,
+ kSignature,
+ 16,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/DeflateProps.cpp b/CPP/7zip/Archive/DeflateProps.cpp
new file mode 100644
index 0000000..ca3dc6f
--- /dev/null
+++ b/CPP/7zip/Archive/DeflateProps.cpp
@@ -0,0 +1,3 @@
+// DeflateProps.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Archive/DeflateProps.h b/CPP/7zip/Archive/DeflateProps.h
new file mode 100644
index 0000000..666fb39
--- /dev/null
+++ b/CPP/7zip/Archive/DeflateProps.h
@@ -0,0 +1,6 @@
+// DeflateProps.h
+
+#ifndef ZIP7_INC_DEFLATE_PROPS_H
+#define ZIP7_INC_DEFLATE_PROPS_H
+
+#endif
diff --git a/CPP/7zip/Archive/DllExports.cpp b/CPP/7zip/Archive/DllExports.cpp
new file mode 100644
index 0000000..9def208
--- /dev/null
+++ b/CPP/7zip/Archive/DllExports.cpp
@@ -0,0 +1,96 @@
+// DLLExports.cpp
+
+#include "StdAfx.h"
+
+#if defined(Z7_LARGE_PAGES)
+#include "../../../C/Alloc.h"
+#endif
+
+#include "../../Common/MyWindows.h"
+#include "../../Common/MyInitGuid.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/NtCheck.h"
+#include "../../Windows/PropVariant.h"
+
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+#include "../Common/CreateCoder.h"
+
+#include "IArchive.h"
+
+static
+HINSTANCE g_hInstance;
+
+#define NT_CHECK_FAIL_ACTION return FALSE;
+
+extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/);
+extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
+{
+ if (dwReason == DLL_PROCESS_ATTACH)
+ {
+ g_hInstance = hInstance;
+ NT_CHECK
+ }
+ return TRUE;
+}
+
+Z7_DEFINE_GUID(CLSID_CArchiveHandler,
+ k_7zip_GUID_Data1,
+ k_7zip_GUID_Data2,
+ k_7zip_GUID_Data3_Common,
+ 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
+
+STDAPI CreateArchiver(const GUID *classID, const GUID *iid, void **outObject);
+
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
+{
+ return CreateArchiver(clsid, iid, outObject);
+}
+
+STDAPI SetLargePageMode()
+{
+ #if defined(Z7_LARGE_PAGES)
+ SetLargePageSize();
+ #endif
+ return S_OK;
+}
+
+extern bool g_CaseSensitive;
+
+STDAPI SetCaseSensitive(Int32 caseSensitive)
+{
+ g_CaseSensitive = (caseSensitive != 0);
+ return S_OK;
+}
+
+#ifdef Z7_EXTERNAL_CODECS
+
+CExternalCodecs g_ExternalCodecs;
+
+STDAPI SetCodecs(ICompressCodecsInfo *compressCodecsInfo)
+{
+ COM_TRY_BEGIN
+
+ // OutputDebugStringA(compressCodecsInfo ? "SetCodecs" : "SetCodecs NULL");
+ if (compressCodecsInfo)
+ {
+ g_ExternalCodecs.GetCodecs = compressCodecsInfo;
+ return g_ExternalCodecs.Load();
+ }
+ g_ExternalCodecs.ClearAndRelease();
+ return S_OK;
+
+ COM_TRY_END
+}
+
+#else
+
+STDAPI SetCodecs(ICompressCodecsInfo *)
+{
+ return S_OK;
+}
+
+#endif
diff --git a/CPP/7zip/Archive/DllExports2.cpp b/CPP/7zip/Archive/DllExports2.cpp
index c43e72a..ae8d8ac 100644
--- a/CPP/7zip/Archive/DllExports2.cpp
+++ b/CPP/7zip/Archive/DllExports2.cpp
@@ -1,122 +1,175 @@
-// DLLExports2.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/MyWindows.h"
-
-#include "../../Common/MyInitGuid.h"
-
-#if defined(_7ZIP_LARGE_PAGES)
-#include "../../../C/Alloc.h"
-#endif
-
-#include "../../Common/ComTry.h"
-
-#include "../../Windows/NtCheck.h"
-#include "../../Windows/PropVariant.h"
-
-#include "../ICoder.h"
-#include "../IPassword.h"
-
-#include "../Common/CreateCoder.h"
-
-#include "IArchive.h"
-
-HINSTANCE g_hInstance;
-
-#define NT_CHECK_FAIL_ACTION return FALSE;
-
-#ifdef _WIN32
-extern "C"
-BOOL WINAPI DllMain(
- #ifdef UNDER_CE
- HANDLE
- #else
- HINSTANCE
- #endif
- hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
-{
- if (dwReason == DLL_PROCESS_ATTACH)
- {
- // OutputDebugStringA("7z.dll DLL_PROCESS_ATTACH");
- g_hInstance = (HINSTANCE)hInstance;
- NT_CHECK;
- }
- /*
- if (dwReason == DLL_PROCESS_DETACH)
- {
- OutputDebugStringA("7z.dll DLL_PROCESS_DETACH");
- }
- */
- return TRUE;
-}
-#endif
-
-DEFINE_GUID(CLSID_CArchiveHandler,
- k_7zip_GUID_Data1,
- k_7zip_GUID_Data2,
- k_7zip_GUID_Data3_Common,
- 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
-
-STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
-STDAPI CreateHasher(const GUID *clsid, IHasher **hasher);
-STDAPI CreateArchiver(const GUID *clsid, const GUID *iid, void **outObject);
-
-STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
-{
- // COM_TRY_BEGIN
- *outObject = 0;
- if (*iid == IID_ICompressCoder ||
- *iid == IID_ICompressCoder2 ||
- *iid == IID_ICompressFilter)
- return CreateCoder(clsid, iid, outObject);
- if (*iid == IID_IHasher)
- return CreateHasher(clsid, (IHasher **)outObject);
- return CreateArchiver(clsid, iid, outObject);
- // COM_TRY_END
-}
-
-STDAPI SetLargePageMode()
-{
- #if defined(_7ZIP_LARGE_PAGES)
- SetLargePageSize();
- #endif
- return S_OK;
-}
-
-extern bool g_CaseSensitive;
-
-STDAPI SetCaseSensitive(Int32 caseSensitive)
-{
- g_CaseSensitive = (caseSensitive != 0);
- return S_OK;
-}
-
-#ifdef EXTERNAL_CODECS
-
-CExternalCodecs g_ExternalCodecs;
-
-STDAPI SetCodecs(ICompressCodecsInfo *compressCodecsInfo)
-{
- COM_TRY_BEGIN
-
- // OutputDebugStringA(compressCodecsInfo ? "SetCodecs" : "SetCodecs NULL");
- if (compressCodecsInfo)
- {
- g_ExternalCodecs.GetCodecs = compressCodecsInfo;
- return g_ExternalCodecs.Load();
- }
- g_ExternalCodecs.ClearAndRelease();
- return S_OK;
-
- COM_TRY_END
-}
-
-#else
-
-STDAPI SetCodecs(ICompressCodecsInfo *)
-{
- return S_OK;
-}
-
-#endif
+// DLLExports2.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyWindows.h"
+#include "../../Common/MyInitGuid.h"
+
+#if defined(Z7_LARGE_PAGES)
+#include "../../../C/Alloc.h"
+#endif
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/NtCheck.h"
+#include "../../Windows/PropVariant.h"
+
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+#include "../Common/CreateCoder.h"
+
+#include "IArchive.h"
+
+
+#ifdef _WIN32
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION return FALSE;
+#endif
+
+static
+HINSTANCE g_hInstance;
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ hInstance, DWORD dwReason, LPVOID /*lpReserved*/);
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
+{
+ if (dwReason == DLL_PROCESS_ATTACH)
+ {
+ // OutputDebugStringA("7z.dll DLL_PROCESS_ATTACH");
+ g_hInstance = (HINSTANCE)hInstance;
+ NT_CHECK
+ }
+ /*
+ if (dwReason == DLL_PROCESS_DETACH)
+ {
+ OutputDebugStringA("7z.dll DLL_PROCESS_DETACH");
+ }
+ */
+ return TRUE;
+}
+
+#else // _WIN32
+
+#include "../../Common/StringConvert.h"
+// #include <stdio.h>
+
+// STDAPI LibStartup();
+static __attribute__((constructor)) void Init_ForceToUTF8();
+static __attribute__((constructor)) void Init_ForceToUTF8()
+{
+ g_ForceToUTF8 = IsNativeUTF8();
+ // printf("\nDLLExports2.cpp::Init_ForceToUTF8 =%d\n", g_ForceToUTF8 ? 1 : 0);
+}
+
+#endif // _WIN32
+
+
+Z7_DEFINE_GUID(CLSID_CArchiveHandler,
+ k_7zip_GUID_Data1,
+ k_7zip_GUID_Data2,
+ k_7zip_GUID_Data3_Common,
+ 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
+
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
+STDAPI CreateHasher(const GUID *clsid, IHasher **hasher);
+STDAPI CreateArchiver(const GUID *clsid, const GUID *iid, void **outObject);
+
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject);
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
+{
+ // COM_TRY_BEGIN
+ *outObject = NULL;
+ if (*iid == IID_ICompressCoder ||
+ *iid == IID_ICompressCoder2 ||
+ *iid == IID_ICompressFilter)
+ return CreateCoder(clsid, iid, outObject);
+ if (*iid == IID_IHasher)
+ return CreateHasher(clsid, (IHasher **)outObject);
+ return CreateArchiver(clsid, iid, outObject);
+ // COM_TRY_END
+}
+
+STDAPI SetLargePageMode();
+STDAPI SetLargePageMode()
+{
+ #if defined(Z7_LARGE_PAGES)
+ #ifdef _WIN32
+ SetLargePageSize();
+ #endif
+ #endif
+ return S_OK;
+}
+
+extern bool g_CaseSensitive;
+
+STDAPI SetCaseSensitive(Int32 caseSensitive);
+STDAPI SetCaseSensitive(Int32 caseSensitive)
+{
+ g_CaseSensitive = (caseSensitive != 0);
+ return S_OK;
+}
+
+/*
+UInt32 g_ClientVersion;
+STDAPI SetClientVersion(UInt32 version);
+STDAPI SetClientVersion(UInt32 version)
+{
+ g_ClientVersion = version;
+ return S_OK;
+}
+*/
+
+/*
+STDAPI SetProperty(Int32 id, const PROPVARIANT *value);
+STDAPI SetProperty(Int32 id, const PROPVARIANT *value)
+{
+ return S_OK;
+}
+*/
+
+#ifdef Z7_EXTERNAL_CODECS
+
+CExternalCodecs g_ExternalCodecs;
+
+STDAPI SetCodecs(ICompressCodecsInfo *compressCodecsInfo);
+STDAPI SetCodecs(ICompressCodecsInfo *compressCodecsInfo)
+{
+ COM_TRY_BEGIN
+
+ // OutputDebugStringA(compressCodecsInfo ? "SetCodecs" : "SetCodecs NULL");
+ if (compressCodecsInfo)
+ {
+ g_ExternalCodecs.GetCodecs = compressCodecsInfo;
+ return g_ExternalCodecs.Load();
+ }
+ g_ExternalCodecs.ClearAndRelease();
+ return S_OK;
+
+ COM_TRY_END
+}
+
+#else
+
+STDAPI SetCodecs(ICompressCodecsInfo *);
+STDAPI SetCodecs(ICompressCodecsInfo *)
+{
+ return S_OK;
+}
+
+#endif
diff --git a/CPP/7zip/Archive/DmgHandler.cpp b/CPP/7zip/Archive/DmgHandler.cpp
new file mode 100644
index 0000000..4bcb904
--- /dev/null
+++ b/CPP/7zip/Archive/DmgHandler.cpp
@@ -0,0 +1,1771 @@
+// DmgHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyXml.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/BZip2Decoder.h"
+#include "../Compress/CopyCoder.h"
+#include "../Compress/LzfseDecoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+#include "Common/OutStreamWithCRC.h"
+
+// #define DMG_SHOW_RAW
+
+// #include <stdio.h>
+#define PRF(x) // x
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+#define Get64(p) GetBe64(p)
+
+Byte *Base64ToBin(Byte *dest, const char *src);
+
+namespace NArchive {
+namespace NDmg {
+
+
+static const UInt32 METHOD_ZERO_0 = 0;
+static const UInt32 METHOD_COPY = 1;
+static const UInt32 METHOD_ZERO_2 = 2; // without file CRC calculation
+static const UInt32 METHOD_ADC = 0x80000004;
+static const UInt32 METHOD_ZLIB = 0x80000005;
+static const UInt32 METHOD_BZIP2 = 0x80000006;
+static const UInt32 METHOD_LZFSE = 0x80000007;
+static const UInt32 METHOD_COMMENT = 0x7FFFFFFE; // is used to comment "+beg" and "+end" in extra field.
+static const UInt32 METHOD_END = 0xFFFFFFFF;
+
+
+struct CBlock
+{
+ UInt32 Type;
+ UInt64 UnpPos;
+ UInt64 UnpSize;
+ UInt64 PackPos;
+ UInt64 PackSize;
+
+ UInt64 GetNextPackOffset() const { return PackPos + PackSize; }
+ UInt64 GetNextUnpPos() const { return UnpPos + UnpSize; }
+
+ bool IsZeroMethod() const { return Type == METHOD_ZERO_0 || Type == METHOD_ZERO_2; }
+ bool ThereAreDataInBlock() const { return Type != METHOD_COMMENT && Type != METHOD_END; }
+};
+
+static const UInt32 kCheckSumType_CRC = 2;
+
+static const size_t kChecksumSize_Max = 0x80;
+
+struct CChecksum
+{
+ UInt32 Type;
+ UInt32 NumBits;
+ Byte Data[kChecksumSize_Max];
+
+ bool IsCrc32() const { return Type == kCheckSumType_CRC && NumBits == 32; }
+ UInt32 GetCrc32() const { return Get32(Data); }
+ void Parse(const Byte *p);
+};
+
+void CChecksum::Parse(const Byte *p)
+{
+ Type = Get32(p);
+ NumBits = Get32(p + 4);
+ memcpy(Data, p + 8, kChecksumSize_Max);
+}
+
+struct CFile
+{
+ UInt64 Size;
+ UInt64 PackSize;
+ UInt64 StartPos;
+ AString Name;
+ CRecordVector<CBlock> Blocks;
+ CChecksum Checksum;
+ bool FullFileChecksum;
+
+ HRESULT Parse(const Byte *p, UInt32 size);
+};
+
+#ifdef DMG_SHOW_RAW
+struct CExtraFile
+{
+ CByteBuffer Data;
+ AString Name;
+};
+#endif
+
+
+struct CForkPair
+{
+ UInt64 Offset;
+ UInt64 Len;
+
+ void Parse(const Byte *p)
+ {
+ Offset = Get64(p);
+ Len = Get64(p + 8);
+ }
+
+ bool UpdateTop(UInt64 limit, UInt64 &top)
+ {
+ if (Offset > limit || Len > limit - Offset)
+ return false;
+ UInt64 top2 = Offset + Len;
+ if (top <= top2)
+ top = top2;
+ return true;
+ }
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CMyComPtr<IInStream> _inStream;
+ CObjectVector<CFile> _files;
+ bool _masterCrcError;
+ bool _headersError;
+
+ UInt32 _dataStartOffset;
+ UInt64 _startPos;
+ UInt64 _phySize;
+
+ AString _name;
+
+ #ifdef DMG_SHOW_RAW
+ CObjectVector<CExtraFile> _extras;
+ #endif
+
+ HRESULT ReadData(IInStream *stream, const CForkPair &pair, CByteBuffer &buf);
+ bool ParseBlob(const CByteBuffer &data);
+ HRESULT Open2(IInStream *stream);
+ HRESULT Extract(IInStream *stream);
+};
+
+// that limit can be increased, if there are such dmg files
+static const size_t kXmlSizeMax = 0xFFFF0000; // 4 GB - 64 KB;
+
+struct CMethods
+{
+ CRecordVector<UInt32> Types;
+ CRecordVector<UInt32> ChecksumTypes;
+
+ void Update(const CFile &file);
+ void GetString(AString &s) const;
+};
+
+void CMethods::Update(const CFile &file)
+{
+ ChecksumTypes.AddToUniqueSorted(file.Checksum.Type);
+ FOR_VECTOR (i, file.Blocks)
+ Types.AddToUniqueSorted(file.Blocks[i].Type);
+}
+
+void CMethods::GetString(AString &res) const
+{
+ res.Empty();
+
+ unsigned i;
+
+ for (i = 0; i < Types.Size(); i++)
+ {
+ const UInt32 type = Types[i];
+ if (type == METHOD_COMMENT || type == METHOD_END)
+ continue;
+ char buf[16];
+ const char *s;
+ switch (type)
+ {
+ case METHOD_ZERO_0: s = "Zero0"; break;
+ case METHOD_ZERO_2: s = "Zero2"; break;
+ case METHOD_COPY: s = "Copy"; break;
+ case METHOD_ADC: s = "ADC"; break;
+ case METHOD_ZLIB: s = "ZLIB"; break;
+ case METHOD_BZIP2: s = "BZip2"; break;
+ case METHOD_LZFSE: s = "LZFSE"; break;
+ default: ConvertUInt32ToString(type, buf); s = buf;
+ }
+ res.Add_OptSpaced(s);
+ }
+
+ for (i = 0; i < ChecksumTypes.Size(); i++)
+ {
+ res.Add_Space_if_NotEmpty();
+ UInt32 type = ChecksumTypes[i];
+ switch (type)
+ {
+ case kCheckSumType_CRC: res += "CRC"; break;
+ default:
+ res += "Check";
+ res.Add_UInt32(type);
+ }
+ }
+}
+
+struct CAppleName
+{
+ bool IsFs;
+ const char *Ext;
+ const char *AppleName;
+};
+
+static const CAppleName k_Names[] =
+{
+ { true, "hfs", "Apple_HFS" },
+ { true, "hfsx", "Apple_HFSX" },
+ { true, "ufs", "Apple_UFS" },
+ { true, "apfs", "Apple_APFS" },
+
+ // efi_sys partition is FAT32, but it's not main file. So we use (IsFs = false)
+ { false, "efi_sys", "C12A7328-F81F-11D2-BA4B-00A0C93EC93B" },
+
+ { false, "free", "Apple_Free" },
+ { false, "ddm", "DDM" },
+ { false, NULL, "Apple_partition_map" },
+ { false, NULL, " GPT " },
+ { false, NULL, "MBR" },
+ { false, NULL, "Driver" },
+ { false, NULL, "Patches" }
+};
+
+static const unsigned kNumAppleNames = Z7_ARRAY_SIZE(k_Names);
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidCRC,
+ kpidComment,
+ kpidMethod
+ // kpidOffset
+};
+
+IMP_IInArchive_Props
+
+static const Byte kArcProps[] =
+{
+ kpidMethod,
+ kpidNumBlocks,
+ kpidComment
+};
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMethod:
+ {
+ CMethods m;
+ FOR_VECTOR (i, _files)
+ m.Update(_files[i]);
+ AString s;
+ m.GetString(s);
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+ case kpidNumBlocks:
+ {
+ UInt64 numBlocks = 0;
+ FOR_VECTOR (i, _files)
+ numBlocks += _files[i].Blocks.Size();
+ prop = numBlocks;
+ break;
+ }
+ case kpidMainSubfile:
+ {
+ int mainIndex = -1;
+ unsigned numFS = 0;
+ unsigned numUnknown = 0;
+ FOR_VECTOR (i, _files)
+ {
+ const AString &name = _files[i].Name;
+ unsigned n;
+ for (n = 0; n < kNumAppleNames; n++)
+ {
+ const CAppleName &appleName = k_Names[n];
+ // if (name.Find(appleName.AppleName) >= 0)
+ if (strstr(name, appleName.AppleName))
+ {
+ if (appleName.IsFs)
+ {
+ numFS++;
+ mainIndex = (int)i;
+ }
+ break;
+ }
+ }
+ if (n == kNumAppleNames)
+ {
+ mainIndex = (int)i;
+ numUnknown++;
+ }
+ }
+ if (numFS + numUnknown == 1)
+ prop = (UInt32)(Int32)mainIndex;
+ break;
+ }
+ case kpidWarning:
+ if (_masterCrcError)
+ prop = "Master CRC error";
+ break;
+
+ case kpidWarningFlags:
+ {
+ UInt32 v = 0;
+ if (_headersError) v |= kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidOffset: prop = _startPos; break;
+ case kpidPhySize: prop = _phySize; break;
+
+ case kpidComment:
+ if (!_name.IsEmpty() && _name.Len() < 256)
+ prop = _name;
+ break;
+
+ case kpidName:
+ if (!_name.IsEmpty() && _name.Len() < 256)
+ {
+ prop = _name + ".dmg";
+ }
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+IMP_IInArchive_ArcProps
+
+HRESULT CFile::Parse(const Byte *p, UInt32 size)
+{
+ const UInt32 kHeadSize = 0xCC;
+ if (size < kHeadSize)
+ return S_FALSE;
+ if (Get32(p) != 0x6D697368) // "mish" signature
+ return S_FALSE;
+ if (Get32(p + 4) != 1) // version
+ return S_FALSE;
+ // UInt64 firstSectorNumber = Get64(p + 8);
+ UInt64 numSectors = Get64(p + 0x10);
+
+ StartPos = Get64(p + 0x18);
+
+ // UInt32 decompressedBufRequested = Get32(p + 0x20); // ???
+ // UInt32 blocksDescriptor = Get32(p + 0x24); // number starting from -1?
+ // char Reserved1[24];
+
+ Checksum.Parse(p + 0x40);
+ PRF(printf("\n\nChecksum Type = %2d", Checksum.Type));
+
+ UInt32 numBlocks = Get32(p + 0xC8);
+ if (numBlocks > ((UInt32)1 << 28))
+ return S_FALSE;
+
+ const UInt32 kRecordSize = 40;
+ if (numBlocks * kRecordSize + kHeadSize != size)
+ return S_FALSE;
+
+ PackSize = 0;
+ Size = 0;
+ Blocks.ClearAndReserve(numBlocks);
+ FullFileChecksum = true;
+
+ p += kHeadSize;
+ UInt32 i;
+
+ for (i = 0; i < numBlocks; i++, p += kRecordSize)
+ {
+ CBlock b;
+ b.Type = Get32(p);
+ b.UnpPos = Get64(p + 0x08) << 9;
+ b.UnpSize = Get64(p + 0x10) << 9;
+ b.PackPos = Get64(p + 0x18);
+ b.PackSize = Get64(p + 0x20);
+
+ // b.PackPos can be 0 for some types. So we don't check it
+ if (!Blocks.IsEmpty())
+ if (b.UnpPos != Blocks.Back().GetNextUnpPos())
+ return S_FALSE;
+
+ PRF(printf("\nType=%8x m[1]=%8x uPos=%8x uSize=%7x pPos=%8x pSize=%7x",
+ b.Type, Get32(p + 4), (UInt32)b.UnpPos, (UInt32)b.UnpSize, (UInt32)b.PackPos, (UInt32)b.PackSize));
+
+ if (b.Type == METHOD_COMMENT)
+ continue;
+ if (b.Type == METHOD_END)
+ break;
+ PackSize += b.PackSize;
+
+ if (b.UnpSize != 0)
+ {
+ if (b.Type == METHOD_ZERO_2)
+ FullFileChecksum = false;
+ Blocks.AddInReserved(b);
+ }
+ }
+
+ if (i != numBlocks - 1)
+ return S_FALSE;
+ if (!Blocks.IsEmpty())
+ Size = Blocks.Back().GetNextUnpPos();
+ if (Size != (numSectors << 9))
+ return S_FALSE;
+
+ return S_OK;
+}
+
+static int FindKeyPair(const CXmlItem &item, const char *key, const char *nextTag)
+{
+ for (unsigned i = 0; i + 1 < item.SubItems.Size(); i++)
+ {
+ const CXmlItem &si = item.SubItems[i];
+ if (si.IsTagged("key") && si.GetSubString() == key && item.SubItems[i + 1].IsTagged(nextTag))
+ return (int)(i + 1);
+ }
+ return -1;
+}
+
+static const AString *GetStringFromKeyPair(const CXmlItem &item, const char *key, const char *nextTag)
+{
+ int index = FindKeyPair(item, key, nextTag);
+ if (index >= 0)
+ return item.SubItems[index].GetSubStringPtr();
+ return NULL;
+}
+
+static const unsigned HEADER_SIZE = 0x200;
+
+static const Byte k_Signature[] = { 'k','o','l','y', 0, 0, 0, 4, 0, 0, 2, 0 };
+
+static inline bool IsKoly(const Byte *p)
+{
+ return memcmp(p, k_Signature, Z7_ARRAY_SIZE(k_Signature)) == 0;
+ /*
+ if (Get32(p) != 0x6B6F6C79) // "koly" signature
+ return false;
+ if (Get32(p + 4) != 4) // version
+ return false;
+ if (Get32(p + 8) != HEADER_SIZE)
+ return false;
+ return true;
+ */
+}
+
+
+HRESULT CHandler::ReadData(IInStream *stream, const CForkPair &pair, CByteBuffer &buf)
+{
+ size_t size = (size_t)pair.Len;
+ if (size != pair.Len)
+ return E_OUTOFMEMORY;
+ buf.Alloc(size);
+ RINOK(InStream_SeekSet(stream, _startPos + pair.Offset))
+ return ReadStream_FALSE(stream, buf, size);
+}
+
+
+bool CHandler::ParseBlob(const CByteBuffer &data)
+{
+ if (data.Size() < 12)
+ return false;
+ const Byte *p = (const Byte *)data;
+ if (Get32(p) != 0xFADE0CC0)
+ return true;
+ const UInt32 size = Get32(p + 4);
+ if (size != data.Size())
+ return false;
+ const UInt32 num = Get32(p + 8);
+ if (num > (size - 12) / 8)
+ return false;
+
+ for (UInt32 i = 0; i < num; i++)
+ {
+ // UInt32 type = Get32(p + i * 8 + 12);
+ UInt32 offset = Get32(p + i * 8 + 12 + 4);
+ if (size - offset < 8)
+ return false;
+ const Byte *p2 = (const Byte *)data + offset;
+ const UInt32 magic = Get32(p2);
+ const UInt32 len = Get32(p2 + 4);
+ if (size - offset < len || len < 8)
+ return false;
+
+ #ifdef DMG_SHOW_RAW
+ CExtraFile &extra = _extras.AddNew();
+ extra.Name = "_blob_";
+ extra.Data.CopyFrom(p2, len);
+ #endif
+
+ if (magic == 0xFADE0C02)
+ {
+ #ifdef DMG_SHOW_RAW
+ extra.Name += "codedir";
+ #endif
+
+ if (len < 11 * 4)
+ return false;
+ UInt32 idOffset = Get32(p2 + 0x14);
+ if (idOffset >= len)
+ return false;
+ UInt32 len2 = len - idOffset;
+ if (len2 < (1 << 10))
+ _name.SetFrom_CalcLen((const char *)(p2 + idOffset), len2);
+ }
+ #ifdef DMG_SHOW_RAW
+ else if (magic == 0xFADE0C01)
+ extra.Name += "requirements";
+ else if (magic == 0xFADE0B01)
+ extra.Name += "signed";
+ else
+ {
+ char temp[16];
+ ConvertUInt32ToHex8Digits(magic, temp);
+ extra.Name += temp;
+ }
+ #endif
+ }
+
+ return true;
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ /*
+ - usual dmg contains Koly Header at the end:
+ - rare case dmg contains Koly Header at the start.
+ */
+
+ _dataStartOffset = 0;
+ UInt64 fileSize;
+ RINOK(InStream_GetPos_GetSize(stream, _startPos, fileSize))
+
+ Byte buf[HEADER_SIZE];
+ RINOK(ReadStream_FALSE(stream, buf, HEADER_SIZE))
+
+ UInt64 headerPos;
+ bool startKolyMode = false;
+
+ if (IsKoly(buf))
+ {
+ // it can be normal koly-at-the-end or koly-at-the-start
+ headerPos = _startPos;
+ if (_startPos <= (1 << 8))
+ {
+ // we want to support startKolyMode, even if there is
+ // some data before dmg file, like 128 bytes MacBin header
+ _dataStartOffset = HEADER_SIZE;
+ startKolyMode = true;
+ }
+ }
+ else
+ {
+ // we check only koly-at-the-end
+ headerPos = fileSize;
+ if (headerPos < HEADER_SIZE)
+ return S_FALSE;
+ headerPos -= HEADER_SIZE;
+ RINOK(InStream_SeekSet(stream, headerPos))
+ RINOK(ReadStream_FALSE(stream, buf, HEADER_SIZE))
+ if (!IsKoly(buf))
+ return S_FALSE;
+ }
+
+ // UInt32 flags = Get32(buf + 12);
+ // UInt64 runningDataForkOffset = Get64(buf + 0x10);
+
+ CForkPair dataForkPair, rsrcPair, xmlPair, blobPair;
+
+ dataForkPair.Parse(buf + 0x18);
+ rsrcPair.Parse(buf + 0x28);
+ xmlPair.Parse(buf + 0xD8);
+ blobPair.Parse(buf + 0x128);
+
+ // UInt32 segmentNumber = Get32(buf + 0x38);
+ // UInt32 segmentCount = Get32(buf + 0x3C);
+ // Byte segmentGUID[16];
+ // CChecksum dataForkChecksum;
+ // dataForkChecksum.Parse(buf + 0x50);
+
+ UInt64 top = 0;
+ UInt64 limit = startKolyMode ? fileSize : headerPos;
+
+ if (!dataForkPair.UpdateTop(limit, top)) return S_FALSE;
+ if (!xmlPair.UpdateTop(limit, top)) return S_FALSE;
+ if (!rsrcPair.UpdateTop(limit, top)) return S_FALSE;
+
+ /* Some old dmg files contain garbage data in blobPair field.
+ So we need to ignore such garbage case;
+ And we still need to detect offset of start of archive for "parser" mode. */
+
+ bool useBlob = blobPair.UpdateTop(limit, top);
+
+
+ if (startKolyMode)
+ _phySize = top;
+ else
+ {
+ _phySize = headerPos + HEADER_SIZE;
+ _startPos = 0;
+ if (top != headerPos)
+ {
+ /*
+ if expected absolute offset is not equal to real header offset,
+ 2 cases are possible:
+ - additional (unknown) headers
+ - archive with offset.
+ So we try to read XML with absolute offset to select from these two ways.
+ */
+ CForkPair xmlPair2 = xmlPair;
+ const char *sz = "<?xml version";
+ const unsigned len = (unsigned)strlen(sz);
+ if (xmlPair2.Len > len)
+ xmlPair2.Len = len;
+ CByteBuffer buf2;
+ if (xmlPair2.Len < len
+ || ReadData(stream, xmlPair2, buf2) != S_OK
+ || memcmp(buf2, sz, len) != 0)
+ {
+ // if absolute offset is not OK, probably it's archive with offset
+ _startPos = headerPos - top;
+ _phySize = top + HEADER_SIZE;
+ }
+ }
+ }
+
+ // Byte reserved[0x78]
+
+ if (useBlob && blobPair.Len != 0)
+ {
+ #ifdef DMG_SHOW_RAW
+ CExtraFile &extra = _extras.AddNew();
+ extra.Name = "_blob.bin";
+ CByteBuffer &blobBuf = extra.Data;
+ #else
+ CByteBuffer blobBuf;
+ #endif
+ RINOK(ReadData(stream, blobPair, blobBuf))
+ if (!ParseBlob(blobBuf))
+ _headersError = true;
+ }
+
+
+ CChecksum masterChecksum;
+ masterChecksum.Parse(buf + 0x160);
+
+ // UInt32 imageVariant = Get32(buf + 0x1E8);
+ // UInt64 numSectors = Get64(buf + 0x1EC);
+ // Byte reserved[0x12]
+
+ const UInt32 RSRC_HEAD_SIZE = 0x100;
+
+ // We don't know the size of the field "offset" in rsrc.
+ // We suppose that it uses 24 bits. So we use Rsrc, only if the rsrcLen < (1 << 24).
+ bool useRsrc = (rsrcPair.Len > RSRC_HEAD_SIZE && rsrcPair.Len < ((UInt32)1 << 24));
+ // useRsrc = false;
+
+ if (useRsrc)
+ {
+ #ifdef DMG_SHOW_RAW
+ CExtraFile &extra = _extras.AddNew();
+ extra.Name = "rsrc.bin";
+ CByteBuffer &rsrcBuf = extra.Data;
+ #else
+ CByteBuffer rsrcBuf;
+ #endif
+
+ RINOK(ReadData(stream, rsrcPair, rsrcBuf))
+
+ const Byte *p = rsrcBuf;
+ UInt32 headSize = Get32(p + 0);
+ UInt32 footerOffset = Get32(p + 4);
+ UInt32 mainDataSize = Get32(p + 8);
+ UInt32 footerSize = Get32(p + 12);
+ if (headSize != RSRC_HEAD_SIZE
+ || footerOffset >= rsrcPair.Len
+ || mainDataSize >= rsrcPair.Len
+ || footerOffset < mainDataSize
+ || footerOffset != headSize + mainDataSize)
+ return S_FALSE;
+
+ const UInt32 footerEnd = footerOffset + footerSize;
+ if (footerEnd != rsrcPair.Len)
+ {
+ // there is rare case dmg example, where there are 4 additional bytes
+ UInt64 rem = rsrcPair.Len - footerOffset;
+ if (rem < footerSize
+ || rem - footerSize != 4
+ || Get32(p + footerEnd) != 0)
+ return S_FALSE;
+ }
+
+ if (footerSize < 16)
+ return S_FALSE;
+ if (memcmp(p, p + footerOffset, 16) != 0)
+ return S_FALSE;
+
+ p += footerOffset;
+
+ if ((UInt32)Get16(p + 0x18) != 0x1C)
+ return S_FALSE;
+ const UInt32 namesOffset = Get16(p + 0x1A);
+ if (namesOffset > footerSize)
+ return S_FALSE;
+
+ UInt32 numItems = (UInt32)Get16(p + 0x1C) + 1;
+ if (numItems * 8 + 0x1E > namesOffset)
+ return S_FALSE;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ const Byte *p2 = p + 0x1E + i * 8;
+
+ const UInt32 typeId = Get32(p2);
+
+ #ifndef DMG_SHOW_RAW
+ if (typeId != 0x626C6B78) // blkx
+ continue;
+ #endif
+
+ const UInt32 numFiles = (UInt32)Get16(p2 + 4) + 1;
+ const UInt32 offs = Get16(p2 + 6);
+ if (0x1C + offs + 12 * numFiles > namesOffset)
+ return S_FALSE;
+
+ for (UInt32 k = 0; k < numFiles; k++)
+ {
+ const Byte *p3 = p + 0x1C + offs + k * 12;
+ // UInt32 id = Get16(p3);
+ const UInt32 namePos = Get16(p3 + 2);
+ // Byte attributes = p3[4]; // = 0x50 for blkx
+ // we don't know how many bits we can use. So we use 24 bits only
+ UInt32 blockOffset = Get32(p3 + 4);
+ blockOffset &= (((UInt32)1 << 24) - 1);
+ // UInt32 unknown2 = Get32(p3 + 8); // ???
+ if (blockOffset + 4 >= mainDataSize)
+ return S_FALSE;
+ const Byte *pBlock = rsrcBuf + headSize + blockOffset;
+ const UInt32 blockSize = Get32(pBlock);
+ if (mainDataSize - (blockOffset + 4) < blockSize)
+ return S_FALSE;
+
+ AString name;
+
+ if (namePos != 0xFFFF)
+ {
+ UInt32 namesBlockSize = footerSize - namesOffset;
+ if (namePos >= namesBlockSize)
+ return S_FALSE;
+ const Byte *namePtr = p + namesOffset + namePos;
+ UInt32 nameLen = *namePtr;
+ if (namesBlockSize - namePos <= nameLen)
+ return S_FALSE;
+ for (UInt32 r = 1; r <= nameLen; r++)
+ {
+ Byte c = namePtr[r];
+ if (c < 0x20 || c >= 0x80)
+ break;
+ name += (char)c;
+ }
+ }
+
+ if (typeId == 0x626C6B78) // blkx
+ {
+ CFile &file = _files.AddNew();
+ file.Name = name;
+ RINOK(file.Parse(pBlock + 4, blockSize))
+ }
+
+ #ifdef DMG_SHOW_RAW
+ {
+ AString name2;
+
+ name2.Add_UInt32(i);
+ name2 += '_';
+
+ {
+ char temp[4 + 1] = { 0 };
+ memcpy(temp, p2, 4);
+ name2 += temp;
+ }
+ name2.Trim();
+ name2 += '_';
+ name2.Add_UInt32(k);
+
+ if (!name.IsEmpty())
+ {
+ name2 += '_';
+ name2 += name;
+ }
+
+ CExtraFile &extra = _extras.AddNew();
+ extra.Name = name2;
+ extra.Data.CopyFrom(pBlock + 4, blockSize);
+ }
+ #endif
+ }
+ }
+ }
+ else
+ {
+ if (xmlPair.Len >= kXmlSizeMax || xmlPair.Len == 0)
+ return S_FALSE;
+ size_t size = (size_t)xmlPair.Len;
+ if (size != xmlPair.Len)
+ return S_FALSE;
+
+ RINOK(InStream_SeekSet(stream, _startPos + xmlPair.Offset))
+
+ CXml xml;
+ {
+ CObjArray<char> xmlStr(size + 1);
+ RINOK(ReadStream_FALSE(stream, xmlStr, size))
+ xmlStr[size] = 0;
+ // if (strlen(xmlStr) != size) return S_FALSE;
+ if (!xml.Parse(xmlStr))
+ return S_FALSE;
+
+ #ifdef DMG_SHOW_RAW
+ CExtraFile &extra = _extras.AddNew();
+ extra.Name = "a.xml";
+ extra.Data.CopyFrom((const Byte *)(const char *)xmlStr, size);
+ #endif
+ }
+
+ if (xml.Root.Name != "plist")
+ return S_FALSE;
+
+ int dictIndex = xml.Root.FindSubTag("dict");
+ if (dictIndex < 0)
+ return S_FALSE;
+
+ const CXmlItem &dictItem = xml.Root.SubItems[dictIndex];
+ int rfDictIndex = FindKeyPair(dictItem, "resource-fork", "dict");
+ if (rfDictIndex < 0)
+ return S_FALSE;
+
+ const CXmlItem &rfDictItem = dictItem.SubItems[rfDictIndex];
+ int arrIndex = FindKeyPair(rfDictItem, "blkx", "array");
+ if (arrIndex < 0)
+ return S_FALSE;
+
+ const CXmlItem &arrItem = rfDictItem.SubItems[arrIndex];
+
+ FOR_VECTOR (i, arrItem.SubItems)
+ {
+ const CXmlItem &item = arrItem.SubItems[i];
+ if (!item.IsTagged("dict"))
+ continue;
+
+ CByteBuffer rawBuf;
+ unsigned destLen = 0;
+ {
+ const AString *dataString = GetStringFromKeyPair(item, "Data", "data");
+ if (!dataString)
+ return S_FALSE;
+ destLen = dataString->Len() / 4 * 3 + 4;
+ rawBuf.Alloc(destLen);
+ {
+ const Byte *endPtr = Base64ToBin(rawBuf, *dataString);
+ if (!endPtr)
+ return S_FALSE;
+ destLen = (unsigned)(endPtr - (const Byte *)rawBuf);
+ }
+
+ #ifdef DMG_SHOW_RAW
+ CExtraFile &extra = _extras.AddNew();
+ extra.Name.Add_UInt32(_files.Size());
+ extra.Data.CopyFrom(rawBuf, destLen);
+ #endif
+ }
+ CFile &file = _files.AddNew();
+ {
+ const AString *name = GetStringFromKeyPair(item, "Name", "string");
+ if (!name || name->IsEmpty())
+ name = GetStringFromKeyPair(item, "CFName", "string");
+ if (name)
+ file.Name = *name;
+ }
+ RINOK(file.Parse(rawBuf, destLen))
+ }
+ }
+
+ if (masterChecksum.IsCrc32())
+ {
+ UInt32 crc = CRC_INIT_VAL;
+ unsigned i;
+ for (i = 0; i < _files.Size(); i++)
+ {
+ const CChecksum &cs = _files[i].Checksum;
+ if ((cs.NumBits & 0x7) != 0)
+ break;
+ UInt32 len = cs.NumBits >> 3;
+ if (len > kChecksumSize_Max)
+ break;
+ crc = CrcUpdate(crc, cs.Data, (size_t)len);
+ }
+ if (i == _files.Size())
+ _masterCrcError = (CRC_GET_DIGEST(crc) != masterChecksum.GetCrc32());
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ if (Open2(stream) != S_OK)
+ return S_FALSE;
+ _inStream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+ _inStream.Release();
+ _files.Clear();
+ _masterCrcError = false;
+ _headersError = false;
+ _name.Empty();
+ #ifdef DMG_SHOW_RAW
+ _extras.Clear();
+ #endif
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _files.Size()
+ #ifdef DMG_SHOW_RAW
+ + _extras.Size()
+ #endif
+ ;
+ return S_OK;
+}
+
+#ifdef DMG_SHOW_RAW
+#define RAW_PREFIX "raw" STRING_PATH_SEPARATOR
+#endif
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+
+ #ifdef DMG_SHOW_RAW
+ if (index >= _files.Size())
+ {
+ const CExtraFile &extra = _extras[index - _files.Size()];
+ switch (propID)
+ {
+ case kpidPath:
+ prop = (AString)RAW_PREFIX + extra.Name;
+ break;
+ case kpidSize:
+ case kpidPackSize:
+ prop = (UInt64)extra.Data.Size();
+ break;
+ }
+ }
+ else
+ #endif
+ {
+ const CFile &item = _files[index];
+ switch (propID)
+ {
+ case kpidSize: prop = item.Size; break;
+ case kpidPackSize: prop = item.PackSize; break;
+ case kpidCRC:
+ {
+ if (item.Checksum.IsCrc32() && item.FullFileChecksum)
+ prop = item.Checksum.GetCrc32();
+ break;
+ }
+
+ /*
+ case kpidOffset:
+ {
+ prop = item.StartPos;
+ break;
+ }
+ */
+
+ case kpidMethod:
+ {
+ CMethods m;
+ m.Update(item);
+ AString s;
+ m.GetString(s);
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidPath:
+ {
+ UString name;
+ name.Add_UInt32(index);
+ unsigned num = 10;
+ unsigned numDigits;
+ for (numDigits = 1; num < _files.Size(); numDigits++)
+ num *= 10;
+ while (name.Len() < numDigits)
+ name.InsertAtFront(L'0');
+
+ AString subName;
+ int pos1 = item.Name.Find('(');
+ if (pos1 >= 0)
+ {
+ pos1++;
+ const int pos2 = item.Name.Find(')', pos1);
+ if (pos2 >= 0)
+ {
+ subName.SetFrom(item.Name.Ptr(pos1), pos2 - pos1);
+ pos1 = subName.Find(':');
+ if (pos1 >= 0)
+ subName.DeleteFrom(pos1);
+ }
+ }
+ else
+ subName = item.Name; // new apfs dmg can be without braces
+ subName.Trim();
+ if (!subName.IsEmpty())
+ {
+ for (unsigned n = 0; n < kNumAppleNames; n++)
+ {
+ const CAppleName &appleName = k_Names[n];
+ if (appleName.Ext)
+ {
+ if (subName == appleName.AppleName)
+ {
+ subName = appleName.Ext;
+ break;
+ }
+ }
+ }
+ UString name2;
+ ConvertUTF8ToUnicode(subName, name2);
+ name.Add_Dot();
+ name += name2;
+ }
+ else
+ {
+ UString name2;
+ ConvertUTF8ToUnicode(item.Name, name2);
+ if (!name2.IsEmpty())
+ name += "_";
+ name += name2;
+ }
+ prop = name;
+ break;
+ }
+
+ case kpidComment:
+ {
+ UString name;
+ ConvertUTF8ToUnicode(item.Name, name);
+ prop = name;
+ break;
+ }
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CAdcDecoder
+ , ICompressCoder
+)
+ CLzOutWindow m_OutWindowStream;
+ CInBuffer m_InStream;
+
+ /*
+ void ReleaseStreams()
+ {
+ m_OutWindowStream.ReleaseStream();
+ m_InStream.ReleaseStream();
+ }
+ */
+
+ class CCoderReleaser Z7_final
+ {
+ CAdcDecoder *m_Coder;
+ public:
+ bool NeedFlush;
+ CCoderReleaser(CAdcDecoder *coder): m_Coder(coder), NeedFlush(true) {}
+ ~CCoderReleaser()
+ {
+ if (NeedFlush)
+ m_Coder->m_OutWindowStream.Flush();
+ // m_Coder->ReleaseStreams();
+ }
+ };
+ friend class CCoderReleaser;
+
+public:
+ HRESULT CodeReal(ISequentialInStream *inStream,
+ ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
+ ICompressProgressInfo *progress);
+};
+
+HRESULT CAdcDecoder::CodeReal(ISequentialInStream *inStream,
+ ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
+ ICompressProgressInfo *progress)
+{
+ if (!m_OutWindowStream.Create(1 << 18))
+ return E_OUTOFMEMORY;
+ if (!m_InStream.Create(1 << 18))
+ return E_OUTOFMEMORY;
+
+ m_OutWindowStream.SetStream(outStream);
+ m_OutWindowStream.Init(false);
+ m_InStream.SetStream(inStream);
+ m_InStream.Init();
+
+ CCoderReleaser coderReleaser(this);
+
+ const UInt32 kStep = (1 << 20);
+ UInt64 nextLimit = kStep;
+
+ UInt64 pos = 0;
+ while (pos < *outSize)
+ {
+ if (pos > nextLimit && progress)
+ {
+ UInt64 packSize = m_InStream.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &pos))
+ nextLimit += kStep;
+ }
+ Byte b;
+ if (!m_InStream.ReadByte(b))
+ return S_FALSE;
+ UInt64 rem = *outSize - pos;
+ if (b & 0x80)
+ {
+ unsigned num = (b & 0x7F) + 1;
+ if (num > rem)
+ return S_FALSE;
+ for (unsigned i = 0; i < num; i++)
+ {
+ if (!m_InStream.ReadByte(b))
+ return S_FALSE;
+ m_OutWindowStream.PutByte(b);
+ }
+ pos += num;
+ continue;
+ }
+ Byte b1;
+ if (!m_InStream.ReadByte(b1))
+ return S_FALSE;
+
+ UInt32 len, distance;
+
+ if (b & 0x40)
+ {
+ len = ((UInt32)b & 0x3F) + 4;
+ Byte b2;
+ if (!m_InStream.ReadByte(b2))
+ return S_FALSE;
+ distance = ((UInt32)b1 << 8) + b2;
+ }
+ else
+ {
+ b &= 0x3F;
+ len = ((UInt32)b >> 2) + 3;
+ distance = (((UInt32)b & 3) << 8) + b1;
+ }
+
+ if (distance >= pos || len > rem)
+ return S_FALSE;
+ m_OutWindowStream.CopyBlock(distance, len);
+ pos += len;
+ }
+ if (*inSize != m_InStream.GetProcessedSize())
+ return S_FALSE;
+ coderReleaser.NeedFlush = false;
+ return m_OutWindowStream.Flush();
+}
+
+Z7_COM7F_IMF(CAdcDecoder::Code(ISequentialInStream *inStream,
+ ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
+ ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress);}
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+
+
+
+
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _files.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+
+ for (i = 0; i < numItems; i++)
+ {
+ UInt32 index = (allFilesMode ? i : indices[i]);
+ #ifdef DMG_SHOW_RAW
+ if (index >= _files.Size())
+ totalSize += _extras[index - _files.Size()].Data.Size();
+ else
+ #endif
+ totalSize += _files[index].Size;
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentPackTotal = 0;
+ UInt64 currentUnpTotal = 0;
+ UInt64 currentPackSize = 0;
+ UInt64 currentUnpSize = 0;
+
+ const UInt32 kZeroBufSize = (1 << 14);
+ CByteBuffer zeroBuf(kZeroBufSize);
+ memset(zeroBuf, 0, kZeroBufSize);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ NCompress::NBZip2::CDecoder *bzip2CoderSpec = new NCompress::NBZip2::CDecoder();
+ CMyComPtr<ICompressCoder> bzip2Coder = bzip2CoderSpec;
+
+ NCompress::NZlib::CDecoder *zlibCoderSpec = new NCompress::NZlib::CDecoder();
+ CMyComPtr<ICompressCoder> zlibCoder = zlibCoderSpec;
+
+ CAdcDecoder *adcCoderSpec = new CAdcDecoder();
+ CMyComPtr<ICompressCoder> adcCoder = adcCoderSpec;
+
+ NCompress::NLzfse::CDecoder *lzfseCoderSpec = new NCompress::NLzfse::CDecoder();
+ CMyComPtr<ICompressCoder> lzfseCoder = lzfseCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_inStream);
+
+ for (i = 0; i < numItems; i++, currentPackTotal += currentPackSize, currentUnpTotal += currentUnpSize)
+ {
+ lps->InSize = currentPackTotal;
+ lps->OutSize = currentUnpTotal;
+ currentPackSize = 0;
+ currentUnpSize = 0;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+
+ COutStreamWithCRC *outCrcStreamSpec = new COutStreamWithCRC;
+ CMyComPtr<ISequentialOutStream> outCrcStream = outCrcStreamSpec;
+ outCrcStreamSpec->SetStream(realOutStream);
+ bool needCrc = false;
+ outCrcStreamSpec->Init(needCrc);
+
+ CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(outCrcStream);
+
+ realOutStream.Release();
+
+ Int32 opRes = NExtract::NOperationResult::kOK;
+ #ifdef DMG_SHOW_RAW
+ if (index >= _files.Size())
+ {
+ const CByteBuffer &buf = _extras[index - _files.Size()].Data;
+ outStreamSpec->Init(buf.Size());
+ RINOK(WriteStream(outStream, buf, buf.Size()));
+ currentPackSize = currentUnpSize = buf.Size();
+ }
+ else
+ #endif
+ {
+ const CFile &item = _files[index];
+ currentPackSize = item.PackSize;
+ currentUnpSize = item.Size;
+
+ needCrc = item.Checksum.IsCrc32();
+
+ UInt64 unpPos = 0;
+ UInt64 packPos = 0;
+ {
+ FOR_VECTOR (j, item.Blocks)
+ {
+ lps->InSize = currentPackTotal + packPos;
+ lps->OutSize = currentUnpTotal + unpPos;
+ RINOK(lps->SetCur())
+
+ const CBlock &block = item.Blocks[j];
+ if (!block.ThereAreDataInBlock())
+ continue;
+
+ packPos += block.PackSize;
+ if (block.UnpPos != unpPos)
+ {
+ opRes = NExtract::NOperationResult::kDataError;
+ break;
+ }
+
+ RINOK(InStream_SeekSet(_inStream, _startPos + _dataStartOffset + item.StartPos + block.PackPos))
+ streamSpec->Init(block.PackSize);
+ bool realMethod = true;
+ outStreamSpec->Init(block.UnpSize);
+ HRESULT res = S_OK;
+
+ outCrcStreamSpec->EnableCalc(needCrc);
+
+ switch (block.Type)
+ {
+ case METHOD_ZERO_0:
+ case METHOD_ZERO_2:
+ realMethod = false;
+ if (block.PackSize != 0)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ outCrcStreamSpec->EnableCalc(block.Type == METHOD_ZERO_0);
+ break;
+
+ case METHOD_COPY:
+ if (block.UnpSize != block.PackSize)
+ {
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ break;
+ }
+ res = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
+ break;
+
+ case METHOD_ADC:
+ {
+ res = adcCoder->Code(inStream, outStream, &block.PackSize, &block.UnpSize, progress);
+ break;
+ }
+
+ case METHOD_ZLIB:
+ {
+ res = zlibCoder->Code(inStream, outStream, NULL, NULL, progress);
+ if (res == S_OK)
+ if (zlibCoderSpec->GetInputProcessedSize() != block.PackSize)
+ opRes = NExtract::NOperationResult::kDataError;
+ break;
+ }
+
+ case METHOD_BZIP2:
+ {
+ res = bzip2Coder->Code(inStream, outStream, NULL, NULL, progress);
+ if (res == S_OK)
+ if (bzip2CoderSpec->GetInputProcessedSize() != block.PackSize)
+ opRes = NExtract::NOperationResult::kDataError;
+ break;
+ }
+
+ case METHOD_LZFSE:
+ {
+ res = lzfseCoder->Code(inStream, outStream, &block.PackSize, &block.UnpSize, progress);
+ break;
+ }
+
+ default:
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ break;
+ }
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ if (opRes == NExtract::NOperationResult::kOK)
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+
+ unpPos += block.UnpSize;
+
+ if (!outStreamSpec->IsFinishedOK())
+ {
+ if (realMethod && opRes == NExtract::NOperationResult::kOK)
+ opRes = NExtract::NOperationResult::kDataError;
+
+ while (outStreamSpec->GetRem() != 0)
+ {
+ UInt64 rem = outStreamSpec->GetRem();
+ UInt32 size = (UInt32)MyMin(rem, (UInt64)kZeroBufSize);
+ RINOK(WriteStream(outStream, zeroBuf, size))
+ }
+ }
+ }
+ }
+
+ if (needCrc && opRes == NExtract::NOperationResult::kOK)
+ {
+ if (outCrcStreamSpec->GetCRC() != item.Checksum.GetCrc32())
+ opRes = NExtract::NOperationResult::kCRCError;
+ }
+ }
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+struct CChunk
+{
+ int BlockIndex;
+ UInt64 AccessMark;
+ CByteBuffer Buf;
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CInStream
+ , IInStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ UInt64 _virtPos;
+ int _latestChunk;
+ int _latestBlock;
+ UInt64 _accessMark;
+ CObjectVector<CChunk> _chunks;
+
+ NCompress::NBZip2::CDecoder *bzip2CoderSpec;
+ CMyComPtr<ICompressCoder> bzip2Coder;
+
+ NCompress::NZlib::CDecoder *zlibCoderSpec;
+ CMyComPtr<ICompressCoder> zlibCoder;
+
+ CAdcDecoder *adcCoderSpec;
+ CMyComPtr<ICompressCoder> adcCoder;
+
+ NCompress::NLzfse::CDecoder *lzfseCoderSpec;
+ CMyComPtr<ICompressCoder> lzfseCoder;
+
+ CBufPtrSeqOutStream *outStreamSpec;
+ CMyComPtr<ISequentialOutStream> outStream;
+
+ CLimitedSequentialInStream *limitedStreamSpec;
+ CMyComPtr<ISequentialInStream> inStream;
+
+public:
+ CMyComPtr<IInStream> Stream;
+ UInt64 Size;
+ const CFile *File;
+ UInt64 _startPos;
+
+ HRESULT InitAndSeek(UInt64 startPos)
+ {
+ _startPos = startPos;
+ _virtPos = 0;
+ _latestChunk = -1;
+ _latestBlock = -1;
+ _accessMark = 0;
+
+ limitedStreamSpec = new CLimitedSequentialInStream;
+ inStream = limitedStreamSpec;
+ limitedStreamSpec->SetStream(Stream);
+
+ outStreamSpec = new CBufPtrSeqOutStream;
+ outStream = outStreamSpec;
+ return S_OK;
+ }
+};
+
+
+static unsigned FindBlock(const CRecordVector<CBlock> &blocks, UInt64 pos)
+{
+ unsigned left = 0, right = blocks.Size();
+ for (;;)
+ {
+ unsigned mid = (left + right) / 2;
+ if (mid == left)
+ return left;
+ if (pos < blocks[mid].UnpPos)
+ right = mid;
+ else
+ left = mid;
+ }
+}
+
+Z7_COM7F_IMF(CInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ COM_TRY_BEGIN
+
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (_virtPos >= Size)
+ return S_OK; // (Size == _virtPos) ? S_OK: E_FAIL;
+ {
+ UInt64 rem = Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ if (_latestBlock >= 0)
+ {
+ const CBlock &block = File->Blocks[(unsigned)_latestBlock];
+ if (_virtPos < block.UnpPos || (_virtPos - block.UnpPos) >= block.UnpSize)
+ _latestBlock = -1;
+ }
+
+ if (_latestBlock < 0)
+ {
+ _latestChunk = -1;
+ unsigned blockIndex = FindBlock(File->Blocks, _virtPos);
+ const CBlock &block = File->Blocks[blockIndex];
+
+ if (!block.IsZeroMethod() && block.Type != METHOD_COPY)
+ {
+ unsigned i;
+ for (i = 0; i < _chunks.Size(); i++)
+ if (_chunks[i].BlockIndex == (int)blockIndex)
+ break;
+
+ if (i != _chunks.Size())
+ _latestChunk = (int)i;
+ else
+ {
+ const unsigned kNumChunksMax = 128;
+ unsigned chunkIndex;
+
+ if (_chunks.Size() != kNumChunksMax)
+ chunkIndex = _chunks.Add(CChunk());
+ else
+ {
+ chunkIndex = 0;
+ for (i = 0; i < _chunks.Size(); i++)
+ if (_chunks[i].AccessMark < _chunks[chunkIndex].AccessMark)
+ chunkIndex = i;
+ }
+
+ CChunk &chunk = _chunks[chunkIndex];
+ chunk.BlockIndex = -1;
+ chunk.AccessMark = 0;
+
+ if (chunk.Buf.Size() < block.UnpSize)
+ {
+ chunk.Buf.Free();
+ if (block.UnpSize > ((UInt32)1 << 31))
+ return E_FAIL;
+ chunk.Buf.Alloc((size_t)block.UnpSize);
+ }
+
+ outStreamSpec->Init(chunk.Buf, (size_t)block.UnpSize);
+
+ RINOK(InStream_SeekSet(Stream, _startPos + File->StartPos + block.PackPos))
+
+ limitedStreamSpec->Init(block.PackSize);
+ HRESULT res = S_OK;
+
+ switch (block.Type)
+ {
+ case METHOD_COPY:
+ if (block.PackSize != block.UnpSize)
+ return E_FAIL;
+ res = ReadStream_FAIL(inStream, chunk.Buf, (size_t)block.UnpSize);
+ break;
+
+ case METHOD_ADC:
+ if (!adcCoder)
+ {
+ adcCoderSpec = new CAdcDecoder();
+ adcCoder = adcCoderSpec;
+ }
+ res = adcCoder->Code(inStream, outStream, &block.PackSize, &block.UnpSize, NULL);
+ break;
+
+ case METHOD_ZLIB:
+ if (!zlibCoder)
+ {
+ zlibCoderSpec = new NCompress::NZlib::CDecoder();
+ zlibCoder = zlibCoderSpec;
+ }
+ res = zlibCoder->Code(inStream, outStream, NULL, NULL, NULL);
+ if (res == S_OK && zlibCoderSpec->GetInputProcessedSize() != block.PackSize)
+ res = S_FALSE;
+ break;
+
+ case METHOD_BZIP2:
+ if (!bzip2Coder)
+ {
+ bzip2CoderSpec = new NCompress::NBZip2::CDecoder();
+ bzip2Coder = bzip2CoderSpec;
+ }
+ res = bzip2Coder->Code(inStream, outStream, NULL, NULL, NULL);
+ if (res == S_OK && bzip2CoderSpec->GetInputProcessedSize() != block.PackSize)
+ res = S_FALSE;
+ break;
+
+ case METHOD_LZFSE:
+ if (!lzfseCoder)
+ {
+ lzfseCoderSpec = new NCompress::NLzfse::CDecoder();
+ lzfseCoder = lzfseCoderSpec;
+ }
+ res = lzfseCoder->Code(inStream, outStream, &block.PackSize, &block.UnpSize, NULL);
+ break;
+
+ default:
+ return E_FAIL;
+ }
+
+ if (res != S_OK)
+ return res;
+ if (block.Type != METHOD_COPY && outStreamSpec->GetPos() != block.UnpSize)
+ return E_FAIL;
+ chunk.BlockIndex = (int)blockIndex;
+ _latestChunk = (int)chunkIndex;
+ }
+
+ _chunks[_latestChunk].AccessMark = _accessMark++;
+ }
+
+ _latestBlock = (int)blockIndex;
+ }
+
+ const CBlock &block = File->Blocks[(unsigned)_latestBlock];
+ const UInt64 offset = _virtPos - block.UnpPos;
+ const UInt64 rem = block.UnpSize - offset;
+ if (size > rem)
+ size = (UInt32)rem;
+
+ HRESULT res = S_OK;
+
+ if (block.Type == METHOD_COPY)
+ {
+ RINOK(InStream_SeekSet(Stream, _startPos + File->StartPos + block.PackPos + offset))
+ res = Stream->Read(data, size, &size);
+ }
+ else if (block.IsZeroMethod())
+ memset(data, 0, size);
+ else if (size != 0)
+ memcpy(data, _chunks[_latestChunk].Buf + (size_t)offset, size);
+
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+
+ return res;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+
+ #ifdef DMG_SHOW_RAW
+ if (index >= (UInt32)_files.Size())
+ return S_FALSE;
+ #endif
+
+ CInStream *spec = new CInStream;
+ CMyComPtr<ISequentialInStream> specStream = spec;
+ spec->File = &_files[index];
+ const CFile &file = *spec->File;
+
+ FOR_VECTOR (i, file.Blocks)
+ {
+ const CBlock &block = file.Blocks[i];
+ switch (block.Type)
+ {
+ case METHOD_ZERO_0:
+ case METHOD_ZERO_2:
+ case METHOD_COPY:
+ case METHOD_ADC:
+ case METHOD_ZLIB:
+ case METHOD_BZIP2:
+ case METHOD_LZFSE:
+ case METHOD_END:
+ break;
+ default:
+ return S_FALSE;
+ }
+ }
+
+ spec->Stream = _inStream;
+ spec->Size = spec->File->Size;
+ RINOK(spec->InitAndSeek(_startPos + _dataStartOffset))
+ *stream = specStream.Detach();
+ return S_OK;
+
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "Dmg", "dmg", NULL, 0xE4,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kBackwardOpen |
+ NArcInfoFlags::kUseGlobalOffset,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/ElfHandler.cpp b/CPP/7zip/Archive/ElfHandler.cpp
new file mode 100644
index 0000000..7e1facc
--- /dev/null
+++ b/CPP/7zip/Archive/ElfHandler.cpp
@@ -0,0 +1,1108 @@
+// ElfHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+using namespace NWindows;
+
+static UInt16 Get16(const Byte *p, bool be) { if (be) return GetBe16(p); return GetUi16(p); }
+static UInt32 Get32(const Byte *p, bool be) { if (be) return GetBe32(p); return GetUi32(p); }
+static UInt64 Get64(const Byte *p, bool be) { if (be) return GetBe64(p); return GetUi64(p); }
+
+#define G16(offs, v) v = Get16(p + (offs), be)
+#define G32(offs, v) v = Get32(p + (offs), be)
+#define G64(offs, v) v = Get64(p + (offs), be)
+
+namespace NArchive {
+namespace NElf {
+
+/*
+ ELF Structure for most files (real order can be different):
+ Header
+ Program (segment) header table (used at runtime)
+ Segment1 (Section ... Section)
+ Segment2
+ ...
+ SegmentN
+ Section header table (the data for linking and relocation)
+*/
+
+#define ELF_CLASS_32 1
+#define ELF_CLASS_64 2
+
+#define ELF_DATA_2LSB 1
+#define ELF_DATA_2MSB 2
+
+static const UInt32 kHeaderSize32 = 0x34;
+static const UInt32 kHeaderSize64 = 0x40;
+
+static const UInt32 kSegmentSize32 = 0x20;
+static const UInt32 kSegmentSize64 = 0x38;
+
+static const UInt32 kSectionSize32 = 0x28;
+static const UInt32 kSectionSize64 = 0x40;
+
+struct CHeader
+{
+ bool Mode64;
+ bool Be;
+ Byte Os;
+ Byte AbiVer;
+
+ UInt16 Type;
+ UInt16 Machine;
+ // UInt32 Version;
+
+ // UInt64 EntryVa;
+ UInt64 ProgOffset;
+ UInt64 SectOffset;
+ UInt32 Flags;
+ UInt16 HeaderSize;
+ UInt16 SegmentEntrySize;
+ UInt16 NumSegments;
+ UInt16 SectionEntrySize;
+ UInt16 NumSections;
+ UInt16 NamesSectIndex;
+
+ bool Parse(const Byte *buf);
+
+ UInt64 GetHeadersSize() const { return (UInt64)HeaderSize +
+ (UInt32)NumSegments * SegmentEntrySize +
+ (UInt32)NumSections * SectionEntrySize; }
+};
+
+bool CHeader::Parse(const Byte *p)
+{
+ switch (p[4])
+ {
+ case ELF_CLASS_32: Mode64 = false; break;
+ case ELF_CLASS_64: Mode64 = true; break;
+ default: return false;
+ }
+ bool be;
+ switch (p[5])
+ {
+ case ELF_DATA_2LSB: be = false; break;
+ case ELF_DATA_2MSB: be = true; break;
+ default: return false;
+ }
+ Be = be;
+ if (p[6] != 1) // Version
+ return false;
+ Os = p[7];
+ AbiVer = p[8];
+ for (int i = 9; i < 16; i++)
+ if (p[i] != 0)
+ return false;
+
+ G16(0x10, Type);
+ G16(0x12, Machine);
+ if (Get32(p + 0x14, be) != 1) // Version
+ return false;
+
+ if (Mode64)
+ {
+ // G64(0x18, EntryVa);
+ G64(0x20, ProgOffset);
+ G64(0x28, SectOffset);
+ p += 0x30;
+ }
+ else
+ {
+ // G32(0x18, EntryVa);
+ G32(0x1C, ProgOffset);
+ G32(0x20, SectOffset);
+ p += 0x24;
+ }
+
+ G32(0, Flags);
+ G16(4, HeaderSize);
+ if (HeaderSize != (Mode64 ? kHeaderSize64 : kHeaderSize32))
+ return false;
+
+ G16(6, SegmentEntrySize);
+ G16(8, NumSegments);
+ G16(10, SectionEntrySize);
+ G16(12, NumSections);
+ G16(14, NamesSectIndex);
+
+ if (ProgOffset < HeaderSize && (ProgOffset != 0 || NumSegments != 0)) return false;
+ if (SectOffset < HeaderSize && (SectOffset != 0 || NumSections != 0)) return false;
+
+ if (SegmentEntrySize == 0) { if (NumSegments != 0) return false; }
+ else if (SegmentEntrySize != (Mode64 ? kSegmentSize64 : kSegmentSize32)) return false;
+
+ if (SectionEntrySize == 0) { if (NumSections != 0) return false; }
+ else if (SectionEntrySize != (Mode64 ? kSectionSize64 : kSectionSize32)) return false;
+
+ return true;
+}
+
+// The program header table itself.
+
+#define PT_PHDR 6
+
+static const CUInt32PCharPair g_SegnmentTypes[] =
+{
+ { 0, "Unused" },
+ { 1, "Loadable segment" },
+ { 2, "Dynamic linking tables" },
+ { 3, "Program interpreter path name" },
+ { 4, "Note section" },
+ { 5, "SHLIB" },
+ { 6, "Program header table" },
+ { 7, "TLS" },
+ { 0x6474e550, "GNU_EH_FRAME" },
+ { 0x6474e551, "GNU_STACK" },
+ { 0x6474e552, "GNU_RELRO" }
+};
+
+
+static const char * const g_SegmentFlags[] =
+{
+ "Execute"
+ , "Write"
+ , "Read"
+};
+
+struct CSegment
+{
+ UInt32 Type;
+ UInt32 Flags;
+ UInt64 Offset;
+ UInt64 Va;
+ // UInt64 Pa;
+ UInt64 Size;
+ UInt64 VSize;
+ UInt64 Align;
+
+ void UpdateTotalSize(UInt64 &totalSize)
+ {
+ UInt64 t = Offset + Size;
+ if (totalSize < t)
+ totalSize = t;
+ }
+ void Parse(const Byte *p, bool mode64, bool be);
+};
+
+void CSegment::Parse(const Byte *p, bool mode64, bool be)
+{
+ G32(0, Type);
+ if (mode64)
+ {
+ G32(4, Flags);
+ G64(8, Offset);
+ G64(0x10, Va);
+ // G64(0x18, Pa);
+ G64(0x20, Size);
+ G64(0x28, VSize);
+ G64(0x30, Align);
+ }
+ else
+ {
+ G32(4, Offset);
+ G32(8, Va);
+ // G32(0x0C, Pa);
+ G32(0x10, Size);
+ G32(0x14, VSize);
+ G32(0x18, Flags);
+ G32(0x1C, Align);
+ }
+}
+
+// Section_index = 0 means NO section
+
+#define SHN_UNDEF 0
+
+// Section types
+
+/*
+#define SHT_NULL 0
+#define SHT_PROGBITS 1
+#define SHT_SYMTAB 2
+#define SHT_STRTAB 3
+#define SHT_RELA 4
+#define SHT_HASH 5
+#define SHT_DYNAMIC 6
+#define SHT_NOTE 7
+*/
+#define SHT_NOBITS 8
+/*
+#define SHT_REL 9
+#define SHT_SHLIB 10
+#define SHT_DYNSYM 11
+#define SHT_UNKNOWN12 12
+#define SHT_UNKNOWN13 13
+#define SHT_INIT_ARRAY 14
+#define SHT_FINI_ARRAY 15
+#define SHT_PREINIT_ARRAY 16
+#define SHT_GROUP 17
+#define SHT_SYMTAB_SHNDX 18
+*/
+
+static const CUInt32PCharPair g_SectTypes[] =
+{
+ { 0, "NULL" },
+ { 1, "PROGBITS" },
+ { 2, "SYMTAB" },
+ { 3, "STRTAB" },
+ { 4, "RELA" },
+ { 5, "HASH" },
+ { 6, "DYNAMIC" },
+ { 7, "NOTE" },
+ { 8, "NOBITS" },
+ { 9, "REL" },
+ { 10, "SHLIB" },
+ { 11, "DYNSYM" },
+ { 12, "UNKNOWN12" },
+ { 13, "UNKNOWN13" },
+ { 14, "INIT_ARRAY" },
+ { 15, "FINI_ARRAY" },
+ { 16, "PREINIT_ARRAY" },
+ { 17, "GROUP" },
+ { 18, "SYMTAB_SHNDX" },
+
+ { 0x6ffffff5, "GNU_ATTRIBUTES" },
+ { 0x6ffffff6, "GNU_HASH" },
+ { 0x6ffffffd, "GNU_verdef" },
+ { 0x6ffffffe, "GNU_verneed" },
+ { 0x6fffffff, "GNU_versym" },
+ // { 0x70000001, "X86_64_UNWIND" },
+ { 0x70000001, "ARM_EXIDX" },
+ { 0x70000002, "ARM_PREEMPTMAP" },
+ { 0x70000003, "ARM_ATTRIBUTES" },
+ { 0x70000004, "ARM_DEBUGOVERLAY" },
+ { 0x70000005, "ARM_OVERLAYSECTION" }
+};
+
+static const CUInt32PCharPair g_SectionFlags[] =
+{
+ { 0, "WRITE" },
+ { 1, "ALLOC" },
+ { 2, "EXECINSTR" },
+
+ { 4, "MERGE" },
+ { 5, "STRINGS" },
+ { 6, "INFO_LINK" },
+ { 7, "LINK_ORDER" },
+ { 8, "OS_NONCONFORMING" },
+ { 9, "GROUP" },
+ { 10, "TLS" },
+ { 11, "CP_SECTION" },
+ { 12, "DP_SECTION" },
+ { 13, "XCORE_SHF_CP_SECTION" },
+ { 28, "64_LARGE" },
+};
+
+struct CSection
+{
+ UInt32 Name;
+ UInt32 Type;
+ UInt64 Flags;
+ UInt64 Va;
+ UInt64 Offset;
+ UInt64 VSize;
+ UInt32 Link;
+ UInt32 Info;
+ UInt64 AddrAlign;
+ UInt64 EntSize;
+
+ UInt64 GetSize() const { return Type == SHT_NOBITS ? 0 : VSize; }
+
+ void UpdateTotalSize(UInt64 &totalSize)
+ {
+ UInt64 t = Offset + GetSize();
+ if (totalSize < t)
+ totalSize = t;
+ }
+ bool Parse(const Byte *p, bool mode64, bool be);
+};
+
+bool CSection::Parse(const Byte *p, bool mode64, bool be)
+{
+ G32(0, Name);
+ G32(4, Type);
+ if (mode64)
+ {
+ G64(0x08, Flags);
+ G64(0x10, Va);
+ G64(0x18, Offset);
+ G64(0x20, VSize);
+ G32(0x28, Link);
+ G32(0x2C, Info);
+ G64(0x30, AddrAlign);
+ G64(0x38, EntSize);
+ }
+ else
+ {
+ G32(0x08, Flags);
+ G32(0x0C, Va);
+ G32(0x10, Offset);
+ G32(0x14, VSize);
+ G32(0x18, Link);
+ G32(0x1C, Info);
+ G32(0x20, AddrAlign);
+ G32(0x24, EntSize);
+ }
+ if (EntSize >= ((UInt32)1 << 31))
+ return false;
+ if (EntSize >= ((UInt32)1 << 10) &&
+ EntSize >= VSize &&
+ VSize != 0)
+ return false;
+ return true;
+}
+
+
+static const char * const g_Machines[] =
+{
+ "None"
+ , "AT&T WE 32100"
+ , "SPARC"
+ , "Intel 386"
+ , "Motorola 68000"
+ , "Motorola 88000"
+ , "Intel 486"
+ , "Intel i860"
+ , "MIPS"
+ , "IBM S/370"
+ , "MIPS RS3000 LE"
+ , "RS6000"
+ , NULL
+ , NULL
+ , NULL
+ , "PA-RISC"
+ , "nCUBE"
+ , "Fujitsu VPP500"
+ , "SPARC 32+"
+ , "Intel i960"
+ , "PowerPC"
+ , "PowerPC 64-bit"
+ , "IBM S/390"
+ , "SPU"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "NEX v800"
+ , "Fujitsu FR20"
+ , "TRW RH-32"
+ , "Motorola RCE"
+ , "ARM"
+ , "Alpha"
+ , "Hitachi SH"
+ , "SPARC-V9"
+ , "Siemens Tricore"
+ , "ARC"
+ , "H8/300"
+ , "H8/300H"
+ , "H8S"
+ , "H8/500"
+ , "IA-64"
+ , "Stanford MIPS-X"
+ , "Motorola ColdFire"
+ , "M68HC12"
+ , "Fujitsu MMA"
+ , "Siemens PCP"
+ , "Sony nCPU"
+ , "Denso NDR1"
+ , "Motorola StarCore"
+ , "Toyota ME16"
+ , "ST100"
+ , "Advanced Logic TinyJ"
+ , "AMD64"
+ , "Sony DSP"
+ , NULL
+ , NULL
+ , "Siemens FX66"
+ , "ST9+"
+ , "ST7"
+ , "MC68HC16"
+ , "MC68HC11"
+ , "MC68HC08"
+ , "MC68HC05"
+ , "Silicon Graphics SVx"
+ , "ST19"
+ , "Digital VAX"
+ , "Axis CRIS"
+ , "Infineon JAVELIN"
+ , "Element 14 FirePath"
+ , "LSI ZSP"
+ , "MMIX"
+ , "HUANY"
+ , "SiTera Prism"
+ , "Atmel AVR"
+ , "Fujitsu FR30"
+ , "Mitsubishi D10V"
+ , "Mitsubishi D30V"
+ , "NEC v850"
+ , "Mitsubishi M32R"
+ , "Matsushita MN10300"
+ , "Matsushita MN10200"
+ , "picoJava"
+ , "OpenRISC"
+ , "ARC Tangent-A5"
+ , "Tensilica Xtensa"
+ , "Alphamosaic VideoCore"
+ , "Thompson MM GPP"
+ , "National Semiconductor 32K"
+ , "Tenor Network TPC"
+ , "Trebia SNP 1000"
+ , "ST200"
+ , "Ubicom IP2xxx"
+ , "MAX"
+ , "NS CompactRISC"
+ , "Fujitsu F2MC16"
+ , "TI msp430"
+ , "Blackfin (DSP)"
+ , "SE S1C33"
+ , "Sharp embedded"
+ , "Arca RISC"
+ , "Unicore"
+ , "eXcess"
+ , "DXP"
+ , "Altera Nios II"
+ , "NS CRX"
+ , "Motorola XGATE"
+ , "Infineon C16x/XC16x"
+ , "Renesas M16C"
+ , "Microchip Technology dsPIC30F"
+ , "Freescale CE"
+ , "Renesas M32C"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "Altium TSK3000"
+ , "Freescale RS08"
+ , "Analog Devices SHARC"
+ , "Cyan Technology eCOG2"
+ , "Sunplus S+core7 RISC"
+ , "NJR 24-bit DSP"
+ , "Broadcom VideoCore III"
+ , "Lattice FPGA"
+ , "SE C17"
+ , "TI TMS320C6000"
+ , "TI TMS320C2000"
+ , "TI TMS320C55x"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "STM 64bit VLIW Data Signal"
+ , "Cypress M8C"
+ , "Renesas R32C"
+ , "NXP TriMedia"
+ , "Qualcomm Hexagon"
+ , "Intel 8051"
+ , "STMicroelectronics STxP7x"
+ , "Andes"
+ , "Cyan Technology eCOG1X"
+ , "Dallas Semiconductor MAXQ30"
+ , "NJR 16-bit DSP"
+ , "M2000"
+ , "Cray NV2"
+ , "Renesas RX"
+ , "Imagination Technologies META"
+ , "MCST Elbrus"
+ , "Cyan Technology eCOG16"
+ , "National Semiconductor CR16"
+ , "Freescale ETPUnit"
+ , "Infineon SLE9X"
+ , "Intel L10M"
+ , "Intel K10M"
+ , NULL
+ , "ARM64"
+ , NULL
+ , "Atmel AVR32"
+ , "STM8"
+ , "Tilera TILE64"
+ , "Tilera TILEPro"
+ , "Xilinx MicroBlaze"
+ , "NVIDIA CUDA"
+ , "Tilera TILE-Gx"
+ , "CloudShield"
+ , "KIPO-KAIST Core-A 1st"
+ , "KIPO-KAIST Core-A 2nd"
+ , "Synopsys ARCompact V2"
+ , "Open8"
+ , "Renesas RL78"
+ , "Broadcom VideoCore V"
+ , "Renesas 78KOR"
+ , "Freescale 56800EX" // 200
+};
+
+static const CUInt32PCharPair g_MachinePairs[] =
+{
+ { 243, "RISC-V" },
+ { 47787, "Xilinx MicroBlaze" }
+ // { 0x9026, "Alpha" }
+};
+
+static const CUInt32PCharPair g_OS[] =
+{
+ { 0, "None" },
+ { 1, "HP-UX" },
+ { 2, "NetBSD" },
+ { 3, "Linux" },
+ { 4, "Hurd" },
+
+ { 6, "Solaris" },
+ { 7, "AIX" },
+ { 8, "IRIX" },
+ { 9, "FreeBSD" },
+ { 10, "TRU64" },
+ { 11, "Novell Modesto" },
+ { 12, "OpenBSD" },
+ { 13, "OpenVMS" },
+ { 14, "HP NSK" },
+ { 15, "AROS" },
+ { 16, "FenixOS" },
+ { 64, "Bare-metal TMS320C6000" },
+ { 65, "Linux TMS320C6000" },
+ { 97, "ARM" },
+ { 255, "Standalone" }
+};
+
+#define k_Machine_MIPS 8
+#define k_Machine_ARM 40
+
+/*
+#define EF_ARM_ABIMASK 0xFF000000
+#define EF_ARM_BE8 0x00800000
+#define EF_ARM_GCCMASK 0x00400FFF
+#define EF_ARM_ABI_FLOAT_SOFT 0x00000200
+#define EF_ARM_ABI_FLOAT_HARD 0x00000400
+*/
+
+static const CUInt32PCharPair g_ARM_Flags[] =
+{
+ { 1, "HasEntry" },
+ { 9, "SF" },
+ { 10, "HF" },
+ { 23, "BE8" }
+};
+
+
+static const CUInt32PCharPair g_MIPS_Flags[] =
+{
+ { 0, "NOREORDER" },
+ { 1, "PIC" },
+ { 2, "CPIC" },
+ { 3, "XGOT" },
+ { 4, "64BIT_WHIRL" },
+ { 5, "ABI2" },
+ { 6, "ABI_ON32" },
+ { 10, "NAN2008" },
+ { 25, "MicroMIPS" },
+ { 26, "M16" },
+ { 27, "MDMX" }
+};
+
+
+// #define ET_NONE 0
+#define ET_REL 1
+// #define ET_EXEC 2
+#define ET_DYN 3
+// #define ET_CORE 4
+
+static const char * const g_Types[] =
+{
+ "None"
+ , "Relocatable file"
+ , "Executable file"
+ , "Shared object file"
+ , "Core file"
+};
+
+
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IArchiveAllowTail
+)
+ CRecordVector<CSegment> _segments;
+ CRecordVector<CSection> _sections;
+ CByteBuffer _namesData;
+ CMyComPtr<IInStream> _inStream;
+ UInt64 _totalSize;
+ CHeader _header;
+ bool _headersError;
+ bool _allowTail;
+
+ void GetSectionName(UInt32 index, NCOM::CPropVariant &prop, bool showNULL) const;
+ HRESULT Open2(IInStream *stream);
+public:
+ CHandler(): _allowTail(false) {}
+};
+
+void CHandler::GetSectionName(UInt32 index, NCOM::CPropVariant &prop, bool showNULL) const
+{
+ if (index >= _sections.Size())
+ return;
+ const CSection §ion = _sections[index];
+ const UInt32 offset = section.Name;
+ if (index == SHN_UNDEF /* && section.Type == SHT_NULL && offset == 0 */)
+ {
+ if (showNULL)
+ prop = "NULL";
+ return;
+ }
+ const Byte *p = _namesData;
+ size_t size = _namesData.Size();
+ for (size_t i = offset; i < size; i++)
+ if (p[i] == 0)
+ {
+ prop = (const char *)(p + offset);
+ return;
+ }
+}
+
+static const Byte kArcProps[] =
+{
+ kpidCpu,
+ kpidBit64,
+ kpidBigEndian,
+ kpidHostOS,
+ kpidCharacts,
+ kpidHeadersSize
+};
+
+enum
+{
+ kpidLinkSection = kpidUserDefined,
+ kpidInfoSection
+};
+
+static const CStatProp kProps[] =
+{
+ { NULL, kpidPath, VT_BSTR },
+ { NULL, kpidSize, VT_UI8 },
+ { NULL, kpidVirtualSize, VT_UI8 },
+ { NULL, kpidOffset, VT_UI8 },
+ { NULL, kpidVa, VT_UI8 },
+ { NULL, kpidType, VT_BSTR },
+ { NULL, kpidCharacts, VT_BSTR }
+ , { "Link Section", kpidLinkSection, VT_BSTR}
+ , { "Info Section", kpidInfoSection, VT_BSTR}
+};
+
+IMP_IInArchive_Props_WITH_NAME
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _totalSize; break;
+ case kpidHeadersSize: prop = _header.GetHeadersSize(); break;
+ case kpidBit64: if (_header.Mode64) prop = _header.Mode64; break;
+ case kpidBigEndian: if (_header.Be) prop = _header.Be; break;
+ case kpidShortComment:
+
+ case kpidCpu:
+ {
+ AString s;
+ if (_header.Machine < Z7_ARRAY_SIZE(g_Machines))
+ {
+ const char *name = g_Machines[_header.Machine];
+ if (name)
+ s = name;
+ }
+ if (s.IsEmpty())
+ s = TypePairToString(g_MachinePairs, Z7_ARRAY_SIZE(g_MachinePairs), _header.Machine);
+ UInt32 flags = _header.Flags;
+ if (flags != 0)
+ {
+ s.Add_Space();
+ if (_header.Machine == k_Machine_ARM)
+ {
+ s += FlagsToString(g_ARM_Flags, Z7_ARRAY_SIZE(g_ARM_Flags), flags & (((UInt32)1 << 24) - 1));
+ s += " ABI:";
+ s.Add_UInt32(flags >> 24);
+ }
+ else if (_header.Machine == k_Machine_MIPS)
+ {
+ const UInt32 ver = flags >> 28;
+ s += "v";
+ s.Add_UInt32(ver);
+ flags &= (((UInt32)1 << 28) - 1);
+
+ UInt32 abi = (flags >> 12) & 7;
+ if (abi != 0)
+ {
+ s += " ABI:";
+ s.Add_UInt32(abi);
+ }
+ flags &= ~((UInt32)7 << 12);
+
+ s.Add_Space();
+ s += FlagsToString(g_MIPS_Flags, Z7_ARRAY_SIZE(g_MIPS_Flags), flags);
+ }
+ else
+ {
+ char sz[16];
+ ConvertUInt32ToHex(flags, sz);
+ s += sz;
+ }
+ }
+ prop = s;
+ break;
+ }
+
+ case kpidHostOS: PAIR_TO_PROP(g_OS, _header.Os, prop); break;
+ case kpidCharacts: TYPE_TO_PROP(g_Types, _header.Type, prop); break;
+ case kpidExtension:
+ {
+ const char *s = NULL;
+ if (_header.Type == ET_DYN)
+ s = "so";
+ else if (_header.Type == ET_REL)
+ s = "o";
+ if (s)
+ prop = s;
+ break;
+ }
+ // case kpidIsSelfExe: prop = (_header.Type != ET_DYN) && (_header.Type == ET_REL); break;
+ case kpidErrorFlags:
+ {
+ UInt32 flags = 0;
+ if (_headersError) flags |= kpv_ErrorFlags_HeadersError;
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (index < _segments.Size())
+ {
+ const CSegment &item = _segments[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ char sz[16];
+ ConvertUInt32ToString(index, sz);
+ prop = sz;
+ break;
+ }
+ case kpidOffset: prop = item.Offset; break;
+ case kpidVa: prop = item.Va; break;
+ case kpidSize:
+ case kpidPackSize: prop = (UInt64)item.Size; break;
+ case kpidVirtualSize: prop = (UInt64)item.VSize; break;
+ case kpidType: PAIR_TO_PROP(g_SegnmentTypes, item.Type, prop); break;
+ case kpidCharacts: FLAGS_TO_PROP(g_SegmentFlags, item.Flags, prop); break;
+
+ }
+ }
+ else
+ {
+ index -= _segments.Size();
+ const CSection &item = _sections[index];
+ switch (propID)
+ {
+ case kpidPath: GetSectionName(index, prop, true); break;
+ case kpidOffset: prop = item.Offset; break;
+ case kpidVa: prop = item.Va; break;
+ case kpidSize:
+ case kpidPackSize: prop = (UInt64)(item.Type == SHT_NOBITS ? 0 : item.VSize); break;
+ case kpidVirtualSize: prop = item.GetSize(); break;
+ case kpidType: PAIR_TO_PROP(g_SectTypes, item.Type, prop); break;
+ case kpidCharacts: FLAGS_TO_PROP(g_SectionFlags, (UInt32)item.Flags, prop); break;
+ case kpidLinkSection: GetSectionName(item.Link, prop, false); break;
+ case kpidInfoSection: GetSectionName(item.Info, prop, false); break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ const UInt32 kStartSize = kHeaderSize64;
+ Byte h[kStartSize];
+ RINOK(ReadStream_FALSE(stream, h, kStartSize))
+ if (h[0] != 0x7F || h[1] != 'E' || h[2] != 'L' || h[3] != 'F')
+ return S_FALSE;
+ if (!_header.Parse(h))
+ return S_FALSE;
+
+ _totalSize = _header.HeaderSize;
+
+ bool addSegments = false;
+ bool addSections = false;
+
+ if (_header.NumSections > 1)
+ addSections = true;
+ else
+ addSegments = true;
+
+ if (_header.NumSegments != 0)
+ {
+ if (_header.ProgOffset > (UInt64)1 << 60) return S_FALSE;
+ RINOK(InStream_SeekSet(stream, _header.ProgOffset))
+ const size_t size = (size_t)_header.SegmentEntrySize * _header.NumSegments;
+
+ CByteArr buf(size);
+
+ RINOK(ReadStream_FALSE(stream, buf, size))
+
+ const UInt64 total = _header.ProgOffset + size;
+ if (_totalSize < total)
+ _totalSize = total;
+
+ const Byte *p = buf;
+
+ if (addSegments)
+ _segments.ClearAndReserve(_header.NumSegments);
+ for (unsigned i = 0; i < _header.NumSegments; i++, p += _header.SegmentEntrySize)
+ {
+ CSegment seg;
+ seg.Parse(p, _header.Mode64, _header.Be);
+ seg.UpdateTotalSize(_totalSize);
+ if (addSegments)
+ if (seg.Type != PT_PHDR)
+ _segments.AddInReserved(seg);
+ }
+ }
+
+ if (_header.NumSections != 0)
+ {
+ if (_header.SectOffset > (UInt64)1 << 60) return S_FALSE;
+ RINOK(InStream_SeekSet(stream, _header.SectOffset))
+ size_t size = (size_t)_header.SectionEntrySize * _header.NumSections;
+
+ CByteArr buf(size);
+
+ RINOK(ReadStream_FALSE(stream, buf, size))
+
+ UInt64 total = _header.SectOffset + size;
+ if (_totalSize < total)
+ _totalSize = total;
+
+ const Byte *p = buf;
+
+ if (addSections)
+ _sections.ClearAndReserve(_header.NumSections);
+ for (unsigned i = 0; i < _header.NumSections; i++, p += _header.SectionEntrySize)
+ {
+ CSection sect;
+ if (!sect.Parse(p, _header.Mode64, _header.Be))
+ {
+ _headersError = true;
+ return S_FALSE;
+ }
+ sect.UpdateTotalSize(_totalSize);
+ if (addSections)
+ _sections.AddInReserved(sect);
+ }
+ }
+
+ if (addSections)
+ {
+ if (_header.NamesSectIndex < _sections.Size())
+ {
+ const CSection § = _sections[_header.NamesSectIndex];
+ const UInt64 size = sect.GetSize();
+ if (size != 0
+ && size < ((UInt64)1 << 31)
+ && (Int64)sect.Offset >= 0)
+ {
+ _namesData.Alloc((size_t)size);
+ RINOK(InStream_SeekSet(stream, sect.Offset))
+ RINOK(ReadStream_FALSE(stream, _namesData, (size_t)size))
+ }
+ }
+
+ /*
+ // we will not delete NULL sections, since we have links to section via indexes
+ for (int i = _sections.Size() - 1; i >= 0; i--)
+ if (_sections[i].Type == SHT_NULL)
+ _items.Delete(i);
+ */
+ }
+
+ if (!_allowTail)
+ {
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(stream, fileSize))
+ if (fileSize > _totalSize)
+ return S_FALSE;
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(Open2(inStream))
+ _inStream = inStream;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ _headersError = false;
+
+ _inStream.Release();
+ _segments.Clear();
+ _sections.Clear();
+ _namesData.Free();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _segments.Size() + _sections.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _segments.Size() + _sections.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ totalSize += (index < _segments.Size()) ?
+ _segments[index].Size :
+ _sections[index - _segments.Size()].GetSize();
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+ UInt64 currentItemSize;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_inStream);
+
+ for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ UInt64 offset;
+ if (index < _segments.Size())
+ {
+ const CSegment &item = _segments[index];
+ currentItemSize = item.Size;
+ offset = item.Offset;
+ }
+ else
+ {
+ const CSection &item = _sections[index - _segments.Size()];
+ currentItemSize = item.GetSize();
+ offset = item.Offset;
+ }
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(InStream_SeekSet(_inStream, offset))
+ streamSpec->Init(currentItemSize);
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(copyCoderSpec->TotalSize == currentItemSize ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::AllowTail(Int32 allowTail))
+{
+ _allowTail = IntToBool(allowTail);
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { 0x7F, 'E', 'L', 'F' };
+
+REGISTER_ARC_I(
+ "ELF", "elf", NULL, 0xDE,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kPreArc,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/ExtHandler.cpp b/CPP/7zip/Archive/ExtHandler.cpp
new file mode 100644
index 0000000..f309485
--- /dev/null
+++ b/CPP/7zip/Archive/ExtHandler.cpp
@@ -0,0 +1,2869 @@
+// ExtHandler.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+// #include <stdio.h>
+// #define PRF2(x) x
+
+#define PRF2(x)
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+using namespace NWindows;
+
+UInt32 LzhCrc16Update(UInt32 crc, const void *data, size_t size);
+
+namespace NArchive {
+namespace NExt {
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define LE_16(offs, dest) dest = Get16(p + (offs));
+#define LE_32(offs, dest) dest = Get32(p + (offs));
+#define LE_64(offs, dest) dest = Get64(p + (offs));
+
+#define HI_16(offs, dest) dest |= (((UInt32)Get16(p + (offs))) << 16);
+#define HI_32(offs, dest) dest |= (((UInt64)Get32(p + (offs))) << 32);
+
+/*
+static UInt32 g_Crc32CTable[256];
+
+static struct CInitCrc32C
+{
+ CInitCrc32C()
+ {
+ for (unsigned i = 0; i < 256; i++)
+ {
+ UInt32 r = i;
+ unsigned j;
+ for (j = 0; j < 8; j++)
+ r = (r >> 1) ^ (0x82F63B78 & ~((r & 1) - 1));
+ g_Crc32CTable[i] = r;
+ }
+ }
+} g_InitCrc32C;
+
+#define CRC32C_INIT_VAL 0xFFFFFFFF
+#define CRC32C_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL)
+#define CRC32C_UPDATE_BYTE(crc, b) (g_Crc32CTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+static UInt32 Crc32C_Update(UInt32 crc, Byte const *data, size_t size)
+{
+ for (size_t i = 0; i < size; i++)
+ crc = CRC32C_UPDATE_BYTE(crc, data[i]);
+ return crc;
+}
+
+static UInt32 Crc32C_Calc(Byte const *data, size_t size)
+{
+ return Crc32C_Update(CRC32C_INIT_VAL, data, size);
+}
+*/
+
+
+#define CRC16_INIT_VAL 0xFFFF
+
+#define Crc16Update(crc, data, size) LzhCrc16Update(crc, data, size)
+
+static UInt32 Crc16Calc(Byte const *data, size_t size)
+{
+ return Crc16Update(CRC16_INIT_VAL, data, size);
+}
+
+
+#define EXT4_GOOD_OLD_INODE_SIZE 128
+#define EXT_NODE_SIZE_MIN 128
+
+
+// inodes numbers
+
+// #define k_INODE_BAD 1 // Bad blocks
+#define k_INODE_ROOT 2 // Root dir
+// #define k_INODE_USR_QUOTA 3 // User quota
+// #define k_INODE_GRP_QUOTA 4 // Group quota
+// #define k_INODE_BOOT_LOADER 5 // Boot loader
+// #define k_INODE_UNDEL_DIR 6 // Undelete dir
+#define k_INODE_RESIZE 7 // Reserved group descriptors
+// #define k_INODE_JOURNAL 8 // Journal
+
+// First non-reserved inode for old ext4 filesystems
+#define k_INODE_GOOD_OLD_FIRST 11
+
+static const char * const k_SysInode_Names[] =
+{
+ "0"
+ , "Bad"
+ , "Root"
+ , "UserQuota"
+ , "GroupQuota"
+ , "BootLoader"
+ , "Undelete"
+ , "Resize"
+ , "Journal"
+ , "Exclude"
+ , "Replica"
+};
+
+static const char * const kHostOS[] =
+{
+ "Linux"
+ , "Hurd"
+ , "Masix"
+ , "FreeBSD"
+ , "Lites"
+};
+
+static const char * const g_FeatureCompat_Flags[] =
+{
+ "DIR_PREALLOC"
+ , "IMAGIC_INODES"
+ , "HAS_JOURNAL"
+ , "EXT_ATTR"
+ , "RESIZE_INODE"
+ , "DIR_INDEX"
+ , "LAZY_BG" // not in Linux
+ , NULL // { 7, "EXCLUDE_INODE" // not used
+ , NULL // { 8, "EXCLUDE_BITMAP" // not in kernel
+ , "SPARSE_SUPER2"
+};
+
+
+#define EXT4_FEATURE_INCOMPAT_FILETYPE (1 << 1)
+#define EXT4_FEATURE_INCOMPAT_64BIT (1 << 7)
+
+static const char * const g_FeatureIncompat_Flags[] =
+{
+ "COMPRESSION"
+ , "FILETYPE"
+ , "RECOVER" /* Needs recovery */
+ , "JOURNAL_DEV" /* Journal device */
+ , "META_BG"
+ , NULL
+ , "EXTENTS" /* extents support */
+ , "64BIT"
+ , "MMP"
+ , "FLEX_BG"
+ , "EA_INODE" /* EA in inode */
+ , NULL
+ , "DIRDATA" /* data in dirent */
+ , "BG_USE_META_CSUM" /* use crc32c for bg */
+ , "LARGEDIR" /* >2GB or 3-lvl htree */
+ , "INLINE_DATA" /* data in inode */
+ , "ENCRYPT" // 16
+};
+
+
+static const UInt32 RO_COMPAT_GDT_CSUM = 1 << 4;
+static const UInt32 RO_COMPAT_METADATA_CSUM = 1 << 10;
+
+static const char * const g_FeatureRoCompat_Flags[] =
+{
+ "SPARSE_SUPER"
+ , "LARGE_FILE"
+ , "BTREE_DIR"
+ , "HUGE_FILE"
+ , "GDT_CSUM"
+ , "DIR_NLINK"
+ , "EXTRA_ISIZE"
+ , "HAS_SNAPSHOT"
+ , "QUOTA"
+ , "BIGALLOC"
+ , "METADATA_CSUM"
+ , "REPLICA"
+ , "READONLY" // 12
+};
+
+
+
+static const UInt32 k_NodeFlags_HUGE = (UInt32)1 << 18;
+static const UInt32 k_NodeFlags_EXTENTS = (UInt32)1 << 19;
+
+
+static const char * const g_NodeFlags[] =
+{
+ "SECRM"
+ , "UNRM"
+ , "COMPR"
+ , "SYNC"
+ , "IMMUTABLE"
+ , "APPEND"
+ , "NODUMP"
+ , "NOATIME"
+ , "DIRTY"
+ , "COMPRBLK"
+ , "NOCOMPR"
+ , "ENCRYPT"
+ , "INDEX"
+ , "IMAGIC"
+ , "JOURNAL_DATA"
+ , "NOTAIL"
+ , "DIRSYNC"
+ , "TOPDIR"
+ , "HUGE_FILE"
+ , "EXTENTS"
+ , NULL
+ , "EA_INODE"
+ , "EOFBLOCKS"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "INLINE_DATA" // 28
+};
+
+
+static inline char GetHex(unsigned t) { return (char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))); }
+
+static inline void PrintHex(unsigned v, char *s)
+{
+ s[0] = GetHex((v >> 4) & 0xF);
+ s[1] = GetHex(v & 0xF);
+}
+
+
+enum
+{
+ k_Type_UNKNOWN,
+ k_Type_REG_FILE,
+ k_Type_DIR,
+ k_Type_CHRDEV,
+ k_Type_BLKDEV,
+ k_Type_FIFO,
+ k_Type_SOCK,
+ k_Type_SYMLINK
+};
+
+static const UInt16 k_TypeToMode[] =
+{
+ 0,
+ MY_LIN_S_IFREG,
+ MY_LIN_S_IFDIR,
+ MY_LIN_S_IFCHR,
+ MY_LIN_S_IFBLK,
+ MY_LIN_S_IFIFO,
+ MY_LIN_S_IFSOCK,
+ MY_LIN_S_IFLNK
+};
+
+
+#define EXT4_GOOD_OLD_REV 0 // old (original) format
+// #define EXT4_DYNAMIC_REV 1 // V2 format with dynamic inode sizes
+
+struct CHeader
+{
+ unsigned BlockBits;
+ unsigned ClusterBits;
+
+ UInt32 NumInodes;
+ UInt64 NumBlocks;
+ // UInt64 NumBlocksSuper;
+ UInt64 NumFreeBlocks;
+ UInt32 NumFreeInodes;
+ // UInt32 FirstDataBlock;
+
+ UInt32 BlocksPerGroup;
+ UInt32 ClustersPerGroup;
+ UInt32 InodesPerGroup;
+
+ UInt32 MountTime;
+ UInt32 WriteTime;
+
+ // UInt16 NumMounts;
+ // UInt16 NumMountsMax;
+
+ // UInt16 State;
+ // UInt16 Errors;
+ // UInt16 MinorRevLevel;
+
+ UInt32 LastCheckTime;
+ // UInt32 CheckInterval;
+ UInt32 CreatorOs;
+ UInt32 RevLevel;
+
+ // UInt16 DefResUid;
+ // UInt16 DefResGid;
+
+ UInt32 FirstInode;
+ UInt16 InodeSize;
+ UInt16 BlockGroupNr;
+ UInt32 FeatureCompat;
+ UInt32 FeatureIncompat;
+ UInt32 FeatureRoCompat;
+ Byte Uuid[16];
+ char VolName[16];
+ char LastMount[64];
+ // UInt32 BitmapAlgo;
+
+ UInt32 JournalInode;
+ UInt16 GdSize; // = 64 if 64-bit();
+ UInt32 CTime;
+ UInt16 MinExtraISize;
+ // UInt16 WantExtraISize;
+ // UInt32 Flags;
+ // Byte LogGroupsPerFlex;
+ // Byte ChecksumType;
+
+ UInt64 WrittenKB;
+
+ bool IsOldRev() const { return RevLevel == EXT4_GOOD_OLD_REV; }
+
+ UInt64 GetNumGroups() const { return (NumBlocks + BlocksPerGroup - 1) / BlocksPerGroup; }
+ UInt64 GetNumGroups2() const { return ((UInt64)NumInodes + InodesPerGroup - 1) / InodesPerGroup; }
+
+ bool IsThereFileType() const { return (FeatureIncompat & EXT4_FEATURE_INCOMPAT_FILETYPE) != 0; }
+ bool Is64Bit() const { return (FeatureIncompat & EXT4_FEATURE_INCOMPAT_64BIT) != 0; }
+ bool UseGdtChecksum() const { return (FeatureRoCompat & RO_COMPAT_GDT_CSUM) != 0; }
+ bool UseMetadataChecksum() const { return (FeatureRoCompat & RO_COMPAT_METADATA_CSUM) != 0; }
+
+ UInt64 GetPhySize() const { return NumBlocks << BlockBits; }
+
+ bool Parse(const Byte *p);
+};
+
+
+static int inline GetLog(UInt32 num)
+{
+ for (unsigned i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == num)
+ return (int)i;
+ return -1;
+}
+
+static bool inline IsEmptyData(const Byte *data, unsigned size)
+{
+ for (unsigned i = 0; i < size; i++)
+ if (data[i] != 0)
+ return false;
+ return true;
+}
+
+
+bool CHeader::Parse(const Byte *p)
+{
+ if (GetUi16(p + 0x38) != 0xEF53)
+ return false;
+
+ LE_32 (0x18, BlockBits)
+ LE_32 (0x1C, ClusterBits)
+
+ if (ClusterBits != 0 && BlockBits != ClusterBits)
+ return false;
+
+ if (BlockBits > 16 - 10)
+ return false;
+ BlockBits += 10;
+
+ LE_32 (0x00, NumInodes)
+ LE_32 (0x04, NumBlocks)
+ // LE_32 (0x08, NumBlocksSuper);
+ LE_32 (0x0C, NumFreeBlocks)
+ LE_32 (0x10, NumFreeInodes)
+
+ if (NumInodes < 2 || NumInodes <= NumFreeInodes)
+ return false;
+
+ UInt32 FirstDataBlock;
+ LE_32 (0x14, FirstDataBlock)
+ if (FirstDataBlock != (unsigned)(BlockBits == 10 ? 1 : 0))
+ return false;
+
+ LE_32 (0x20, BlocksPerGroup)
+ LE_32 (0x24, ClustersPerGroup)
+
+ if (BlocksPerGroup != ClustersPerGroup)
+ return false;
+ if (BlocksPerGroup == 0)
+ return false;
+ if (BlocksPerGroup != ((UInt32)1 << (BlockBits + 3)))
+ {
+ // it's allowed in ext2
+ // return false;
+ }
+
+ LE_32 (0x28, InodesPerGroup)
+
+ if (InodesPerGroup < 1 || InodesPerGroup > NumInodes)
+ return false;
+
+ LE_32 (0x2C, MountTime)
+ LE_32 (0x30, WriteTime)
+
+ // LE_16 (0x34, NumMounts);
+ // LE_16 (0x36, NumMountsMax);
+
+ // LE_16 (0x3A, State);
+ // LE_16 (0x3C, Errors);
+ // LE_16 (0x3E, MinorRevLevel);
+
+ LE_32 (0x40, LastCheckTime)
+ // LE_32 (0x44, CheckInterval);
+ LE_32 (0x48, CreatorOs)
+ LE_32 (0x4C, RevLevel)
+
+ // LE_16 (0x50, DefResUid);
+ // LE_16 (0x52, DefResGid);
+
+ FirstInode = k_INODE_GOOD_OLD_FIRST;
+ InodeSize = EXT4_GOOD_OLD_INODE_SIZE;
+
+ if (!IsOldRev())
+ {
+ LE_32 (0x54, FirstInode)
+ LE_16 (0x58, InodeSize)
+ if (FirstInode < k_INODE_GOOD_OLD_FIRST)
+ return false;
+ if (InodeSize > ((UInt32)1 << BlockBits)
+ || InodeSize < EXT_NODE_SIZE_MIN
+ || GetLog(InodeSize) < 0)
+ return false;
+ }
+
+ LE_16 (0x5A, BlockGroupNr)
+ LE_32 (0x5C, FeatureCompat)
+ LE_32 (0x60, FeatureIncompat)
+ LE_32 (0x64, FeatureRoCompat)
+
+ memcpy(Uuid, p + 0x68, sizeof(Uuid));
+ memcpy(VolName, p + 0x78, sizeof(VolName));
+ memcpy(LastMount, p + 0x88, sizeof(LastMount));
+
+ // LE_32 (0xC8, BitmapAlgo);
+
+ LE_32 (0xE0, JournalInode)
+
+ LE_16 (0xFE, GdSize)
+
+ LE_32 (0x108, CTime)
+
+ if (Is64Bit())
+ {
+ HI_32(0x150, NumBlocks)
+ // HI_32(0x154, NumBlocksSuper);
+ HI_32(0x158, NumFreeBlocks)
+ }
+
+ if (NumBlocks >= (UInt64)1 << (63 - BlockBits))
+ return false;
+
+
+ LE_16(0x15C, MinExtraISize)
+ // LE_16(0x15E, WantExtraISize);
+ // LE_32(0x160, Flags);
+ // LE_16(0x164, RaidStride);
+ // LE_16(0x166, MmpInterval);
+ // LE_64(0x168, MmpBlock);
+
+ // LogGroupsPerFlex = p[0x174];
+ // ChecksumType = p[0x175];
+
+ LE_64 (0x178, WrittenKB)
+
+ // LE_32(0x194, ErrorCount);
+ // LE_32(0x198, ErrorTime);
+ // LE_32(0x19C, ErrorINode);
+ // LE_32(0x1A0, ErrorBlock);
+
+ if (NumBlocks < 1)
+ return false;
+ if (NumFreeBlocks > NumBlocks)
+ return false;
+
+ if (GetNumGroups() != GetNumGroups2())
+ return false;
+
+ return true;
+}
+
+
+struct CGroupDescriptor
+{
+ UInt64 BlockBitmap;
+ UInt64 InodeBitmap;
+ UInt64 InodeTable;
+ UInt32 NumFreeBlocks;
+ UInt32 NumFreeInodes;
+ UInt32 DirCount;
+
+ UInt16 Flags;
+
+ UInt64 ExcludeBitmap;
+ UInt32 BlockBitmap_Checksum;
+ UInt32 InodeBitmap_Checksum;
+ UInt32 UnusedCount;
+ UInt16 Checksum;
+
+ void Parse(const Byte *p, unsigned size);
+};
+
+void CGroupDescriptor::Parse(const Byte *p, unsigned size)
+{
+ LE_32 (0x00, BlockBitmap)
+ LE_32 (0x04, InodeBitmap)
+ LE_32 (0x08, InodeTable)
+ LE_16 (0x0C, NumFreeBlocks)
+ LE_16 (0x0E, NumFreeInodes)
+ LE_16 (0x10, DirCount)
+ LE_16 (0x12, Flags)
+ LE_32 (0x14, ExcludeBitmap)
+ LE_16 (0x18, BlockBitmap_Checksum)
+ LE_16 (0x1A, InodeBitmap_Checksum)
+ LE_16 (0x1C, UnusedCount)
+ LE_16 (0x1E, Checksum)
+
+ if (size >= 64)
+ {
+ p += 0x20;
+ HI_32 (0x00, BlockBitmap)
+ HI_32 (0x04, InodeBitmap)
+ HI_32 (0x08, InodeTable)
+ HI_16 (0x0C, NumFreeBlocks)
+ HI_16 (0x0E, NumFreeInodes)
+ HI_16 (0x10, DirCount)
+ HI_16 (0x12, UnusedCount) // instead of Flags
+ HI_32 (0x14, ExcludeBitmap)
+ HI_16 (0x18, BlockBitmap_Checksum)
+ HI_16 (0x1A, InodeBitmap_Checksum)
+ // HI_16 (0x1C, Reserved);
+ }
+}
+
+
+static const unsigned kNodeBlockFieldSize = 60;
+
+struct CExtentTreeHeader
+{
+ UInt16 NumEntries;
+ UInt16 MaxEntries;
+ UInt16 Depth;
+ // UInt32 Generation;
+
+ bool Parse(const Byte *p)
+ {
+ LE_16 (0x02, NumEntries)
+ LE_16 (0x04, MaxEntries)
+ LE_16 (0x06, Depth)
+ // LE_32 (0x08, Generation);
+ return Get16(p) == 0xF30A; // magic
+ }
+};
+
+struct CExtentIndexNode
+{
+ UInt32 VirtBlock;
+ UInt64 PhyLeaf;
+
+ void Parse(const Byte *p)
+ {
+ LE_32 (0x00, VirtBlock)
+ LE_32 (0x04, PhyLeaf)
+ PhyLeaf |= (((UInt64)Get16(p + 8)) << 32);
+ // unused 16-bit field (at offset 0x0A) can be not zero in some cases. Why?
+ }
+};
+
+struct CExtent
+{
+ UInt32 VirtBlock;
+ UInt16 Len;
+ bool IsInited;
+ UInt64 PhyStart;
+
+ UInt32 GetVirtEnd() const { return VirtBlock + Len; }
+ bool IsLenOK() const { return VirtBlock + Len >= VirtBlock; }
+
+ void Parse(const Byte *p)
+ {
+ LE_32 (0x00, VirtBlock)
+ LE_16 (0x04, Len)
+ IsInited = true;
+ if (Len > (UInt32)0x8000)
+ {
+ IsInited = false;
+ Len = (UInt16)(Len - (UInt32)0x8000);
+ }
+ LE_32 (0x08, PhyStart)
+ UInt16 hi;
+ LE_16 (0x06, hi)
+ PhyStart |= ((UInt64)hi << 32);
+ }
+};
+
+
+
+struct CExtTime
+{
+ UInt32 Val;
+ UInt32 Extra;
+};
+
+struct CNode
+{
+ Int32 ParentNode; // in _refs[], -1 if not dir
+ int ItemIndex; // in _items[] , (set as >=0 only for if (IsDir())
+ int SymLinkIndex; // in _symLinks[]
+ int DirIndex; // in _dirs[]
+
+ UInt16 Mode;
+ UInt32 Uid; // fixed 21.02
+ UInt32 Gid; // fixed 21.02
+ // UInt16 Checksum;
+
+ UInt64 FileSize;
+ CExtTime MTime;
+ CExtTime ATime;
+ CExtTime CTime;
+ CExtTime ChangeTime;
+ // CExtTime DTime;
+
+ UInt64 NumBlocks;
+ UInt32 NumLinks;
+ UInt32 Flags;
+
+ UInt32 NumLinksCalced;
+
+ Byte Block[kNodeBlockFieldSize];
+
+ CNode():
+ ParentNode(-1),
+ ItemIndex(-1),
+ SymLinkIndex(-1),
+ DirIndex(-1),
+ NumLinksCalced(0)
+ {}
+
+ bool IsFlags_HUGE() const { return (Flags & k_NodeFlags_HUGE) != 0; }
+ bool IsFlags_EXTENTS() const { return (Flags & k_NodeFlags_EXTENTS) != 0; }
+
+ bool IsDir() const { return MY_LIN_S_ISDIR(Mode); }
+ bool IsRegular() const { return MY_LIN_S_ISREG(Mode); }
+ bool IsLink() const { return MY_LIN_S_ISLNK(Mode); }
+
+ bool Parse(const Byte *p, const CHeader &_h);
+};
+
+
+bool CNode::Parse(const Byte *p, const CHeader &_h)
+{
+ MTime.Extra = 0;
+ ATime.Extra = 0;
+ CTime.Extra = 0;
+ CTime.Val = 0;
+ ChangeTime.Extra = 0;
+ // DTime.Extra = 0;
+
+ LE_16 (0x00, Mode)
+ LE_16 (0x02, Uid)
+ LE_32 (0x04, FileSize)
+ LE_32 (0x08, ATime.Val)
+ LE_32 (0x0C, ChangeTime.Val)
+ LE_32 (0x10, MTime.Val)
+ // LE_32 (0x14, DTime.Val);
+ LE_16 (0x18, Gid)
+ LE_16 (0x1A, NumLinks)
+
+ LE_32 (0x1C, NumBlocks)
+ LE_32 (0x20, Flags)
+ // LE_32 (0x24, Union osd1);
+
+ memcpy(Block, p + 0x28, kNodeBlockFieldSize);
+
+ // LE_32 (0x64, Generation); // File version (for NFS)
+ // LE_32 (0x68, ACL);
+
+ {
+ UInt32 highSize;
+ LE_32 (0x6C, highSize) // In ext2/3 this field was named i_dir_acl
+
+ if (IsRegular()) // do we need that check ?
+ FileSize |= ((UInt64)highSize << 32);
+ }
+
+ // UInt32 fragmentAddress;
+ // LE_32 (0x70, fragmentAddress);
+
+ // osd2
+ {
+ // Linux;
+ // ext2:
+ // Byte FragmentNumber = p[0x74];
+ // Byte FragmentSize = p[0x74 + 1];
+
+ // ext4:
+ UInt32 numBlocksHigh;
+ LE_16 (0x74, numBlocksHigh)
+ NumBlocks |= (UInt64)numBlocksHigh << 32;
+
+ HI_16 (0x74 + 4, Uid)
+ HI_16 (0x74 + 6, Gid)
+ /*
+ UInt32 checksum;
+ LE_16 (0x74 + 8, checksum);
+ checksum = checksum;
+ */
+ }
+
+ // 0x74: Byte Union osd2[12];
+
+ if (_h.InodeSize > 128)
+ {
+ // InodeSize is power of 2, so the following check is not required:
+ // if (_h.InodeSize < 128 + 2) return false;
+ UInt16 extra_isize;
+ LE_16 (0x80, extra_isize)
+ if (128 + extra_isize > _h.InodeSize)
+ return false;
+ if (extra_isize >= 0x1C)
+ {
+ // UInt16 checksumUpper;
+ // LE_16 (0x82, checksumUpper);
+ LE_32 (0x84, ChangeTime.Extra)
+ LE_32 (0x88, MTime.Extra)
+ LE_32 (0x8C, ATime.Extra)
+ LE_32 (0x90, CTime.Val)
+ LE_32 (0x94, CTime.Extra)
+ // LE_32 (0x98, VersionHi)
+ }
+ }
+
+ PRF(printf("size = %5d", (unsigned)FileSize));
+
+ return true;
+}
+
+
+struct CItem
+{
+ unsigned Node; // in _refs[]
+ int ParentNode; // in _refs[]
+ int SymLinkItemIndex; // in _items[], if the Node contains SymLink to existing dir
+ Byte Type;
+
+ AString Name;
+
+ CItem():
+ Node(0),
+ ParentNode(-1),
+ SymLinkItemIndex(-1),
+ Type(k_Type_UNKNOWN)
+ {}
+
+ void Clear()
+ {
+ Node = 0;
+ ParentNode = -1;
+ SymLinkItemIndex = -1;
+ Type = k_Type_UNKNOWN;
+ Name.Empty();
+ }
+
+ bool IsDir() const { return Type == k_Type_DIR; }
+ // bool IsNotDir() const { return Type != k_Type_DIR && Type != k_Type_UNKNOWN; }
+};
+
+
+
+static const unsigned kNumTreeLevelsMax = 6; // must be >= 3
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_2(
+ IArchiveGetRawProps,
+ IInArchiveGetStream
+)
+ CObjectVector<CItem> _items;
+ CIntVector _refs; // iNode -> (index in _nodes). if (_refs[iNode] < 0), that node is not filled
+ CRecordVector<CNode> _nodes;
+ CObjectVector<CUIntVector> _dirs; // each CUIntVector contains indexes in _items[] only for dir items;
+ AStringVector _symLinks;
+ AStringVector _auxItems;
+ int _auxSysIndex;
+ int _auxUnknownIndex;
+
+ CMyComPtr<IInStream> _stream;
+ UInt64 _phySize;
+ bool _isArc;
+ bool _headersError;
+ bool _headersWarning;
+ bool _linksError;
+
+ bool _isUTF;
+
+ CHeader _h;
+
+ IArchiveOpenCallback *_openCallback;
+ UInt64 _totalRead;
+ UInt64 _totalReadPrev;
+
+ CByteBuffer _tempBufs[kNumTreeLevelsMax];
+
+
+ HRESULT CheckProgress2()
+ {
+ const UInt64 numFiles = _items.Size();
+ return _openCallback->SetCompleted(&numFiles, &_totalRead);
+ }
+
+ HRESULT CheckProgress()
+ {
+ HRESULT res = S_OK;
+ if (_openCallback)
+ {
+ if (_totalRead - _totalReadPrev >= ((UInt32)1 << 20))
+ {
+ _totalReadPrev = _totalRead;
+ res = CheckProgress2();
+ }
+ }
+ return res;
+ }
+
+
+ int GetParentAux(const CItem &item) const
+ {
+ if (item.Node < _h.FirstInode && _auxSysIndex >= 0)
+ return _auxSysIndex;
+ return _auxUnknownIndex;
+ }
+
+ HRESULT SeekAndRead(IInStream *inStream, UInt64 block, Byte *data, size_t size);
+ HRESULT ParseDir(const Byte *data, size_t size, unsigned iNodeDir);
+ int FindTargetItem_for_SymLink(unsigned dirNode, const AString &path) const;
+
+ HRESULT FillFileBlocks2(UInt32 block, unsigned level, unsigned numBlocks, CRecordVector<UInt32> &blocks);
+ HRESULT FillFileBlocks(const Byte *p, unsigned numBlocks, CRecordVector<UInt32> &blocks);
+ HRESULT FillExtents(const Byte *p, size_t size, CRecordVector<CExtent> &extents, int parentDepth);
+
+ HRESULT GetStream_Node(unsigned nodeIndex, ISequentialInStream **stream);
+ HRESULT ExtractNode(unsigned nodeIndex, CByteBuffer &data);
+
+ void ClearRefs();
+ HRESULT Open2(IInStream *inStream);
+
+ void GetPath(unsigned index, AString &s) const;
+ bool GetPackSize(unsigned index, UInt64 &res) const;
+};
+
+
+
+HRESULT CHandler::ParseDir(const Byte *p, size_t size, unsigned iNodeDir)
+{
+ bool isThereSelfLink = false;
+
+ PRF(printf("\n\n========= node = %5d size = %5d", (unsigned)iNodeDir, (unsigned)size));
+
+ CNode &nodeDir = _nodes[_refs[iNodeDir]];
+ nodeDir.DirIndex = (int)_dirs.Size();
+ CUIntVector &dir = _dirs.AddNew();
+ int parentNode = -1;
+
+ CItem item;
+
+ for (;;)
+ {
+ if (size == 0)
+ break;
+ if (size < 8)
+ return S_FALSE;
+ UInt32 iNode;
+ LE_32 (0x00, iNode)
+ unsigned recLen;
+ LE_16 (0x04, recLen)
+ const unsigned nameLen = p[6];
+ const Byte type = p[7];
+
+ if (recLen > size)
+ return S_FALSE;
+ if (nameLen + 8 > recLen)
+ return S_FALSE;
+
+ if (iNode >= _refs.Size())
+ return S_FALSE;
+
+ item.Clear();
+
+ if (_h.IsThereFileType())
+ item.Type = type;
+ else if (type != 0)
+ return S_FALSE;
+
+ item.ParentNode = (int)iNodeDir;
+ item.Node = iNode;
+ item.Name.SetFrom_CalcLen((const char *)(p + 8), nameLen);
+
+ p += recLen;
+ size -= recLen;
+
+ if (item.Name.Len() != nameLen)
+ return S_FALSE;
+
+ if (_isUTF)
+ {
+ // 21.07 : we force UTF8
+ // _isUTF = CheckUTF8_AString(item.Name);
+ }
+
+ if (iNode == 0)
+ {
+ /*
+ ext3 deleted??
+ if (item.Name.Len() != 0)
+ return S_FALSE;
+ */
+
+ PRF(printf("\n EMPTY %6d %d %s", (unsigned)recLen, (unsigned)type, (const char *)item.Name));
+ if (type == 0xDE)
+ {
+ // checksum
+ }
+ continue;
+ }
+
+ const int nodeIndex = _refs[iNode];
+ if (nodeIndex < 0)
+ return S_FALSE;
+ CNode &node = _nodes[nodeIndex];
+
+ if (_h.IsThereFileType() && type != 0)
+ {
+ if (type >= Z7_ARRAY_SIZE(k_TypeToMode))
+ return S_FALSE;
+ if (k_TypeToMode[type] != (node.Mode & MY_LIN_S_IFMT))
+ return S_FALSE;
+ }
+
+ node.NumLinksCalced++;
+
+ PRF(printf("\n%s %6d %s", item.IsDir() ? "DIR " : " ", (unsigned)item.Node, (const char *)item.Name));
+
+ if (item.Name[0] == '.')
+ {
+ if (item.Name[1] == 0)
+ {
+ if (isThereSelfLink)
+ return S_FALSE;
+ isThereSelfLink = true;
+ if (iNode != iNodeDir)
+ return S_FALSE;
+ continue;
+ }
+
+ if (item.Name[1] == '.' && item.Name[2] == 0)
+ {
+ if (parentNode >= 0)
+ return S_FALSE;
+ if (!node.IsDir())
+ return S_FALSE;
+ if (iNode == iNodeDir && iNode != k_INODE_ROOT)
+ return S_FALSE;
+
+ parentNode = (int)iNode;
+
+ if (nodeDir.ParentNode < 0)
+ nodeDir.ParentNode = (int)iNode;
+ else if ((unsigned)nodeDir.ParentNode != iNode)
+ return S_FALSE;
+
+ continue;
+ }
+ }
+
+ if (iNode == iNodeDir)
+ return S_FALSE;
+
+ if (parentNode < 0)
+ return S_FALSE;
+
+ if (node.IsDir())
+ {
+ if (node.ParentNode < 0)
+ node.ParentNode = (int)iNodeDir;
+ else if ((unsigned)node.ParentNode != iNodeDir)
+ return S_FALSE;
+ const unsigned itemIndex = _items.Size();
+ dir.Add(itemIndex);
+ node.ItemIndex = (int)itemIndex;
+ }
+
+ _items.Add(item);
+ }
+
+ if (parentNode < 0 || !isThereSelfLink)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+static int CompareItemsNames(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const CObjectVector<CItem> &items = *(const CObjectVector<CItem> *)param;
+ return strcmp(items[*p1].Name, items[*p2].Name);
+}
+
+
+int CHandler::FindTargetItem_for_SymLink(unsigned iNode, const AString &path) const
+{
+ unsigned pos = 0;
+
+ if (path.IsEmpty())
+ return -1;
+
+ if (path[0] == '/')
+ {
+ iNode = k_INODE_ROOT;
+ if (iNode >= _refs.Size())
+ return -1;
+ pos = 1;
+ }
+
+ AString s;
+
+ while (pos != path.Len())
+ {
+ const CNode &node = _nodes[_refs[iNode]];
+ const int slash = path.Find('/', pos);
+
+ if (slash < 0)
+ {
+ s = path.Ptr(pos);
+ pos = path.Len();
+ }
+ else
+ {
+ s.SetFrom(path.Ptr(pos), (unsigned)slash - pos);
+ pos = (unsigned)slash + 1;
+ }
+
+ if (s[0] == '.')
+ {
+ if (s[1] == 0)
+ continue;
+ else if (s[1] == '.' && s[2] == 0)
+ {
+ if (node.ParentNode < 0)
+ return -1;
+ if (iNode == k_INODE_ROOT)
+ return -1;
+ iNode = (unsigned)node.ParentNode;
+ continue;
+ }
+ }
+
+ if (node.DirIndex < 0)
+ return -1;
+
+ const CUIntVector &dir = _dirs[node.DirIndex];
+
+ /*
+ for (unsigned i = 0;; i++)
+ {
+ if (i >= dir.Size())
+ return -1;
+ const CItem &item = _items[dir[i]];
+ if (item.Name == s)
+ {
+ iNode = item.Node;
+ break;
+ }
+ }
+ */
+
+ unsigned left = 0, right = dir.Size();
+ for (;;)
+ {
+ if (left == right)
+ return -1;
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const CItem &item = _items[dir[mid]];
+ const int comp = strcmp(s, item.Name);
+ if (comp == 0)
+ {
+ iNode = item.Node;
+ break;
+ }
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ }
+
+ return _nodes[_refs[iNode]].ItemIndex;
+}
+
+
+HRESULT CHandler::SeekAndRead(IInStream *inStream, UInt64 block, Byte *data, size_t size)
+{
+ if (block == 0 || block >= _h.NumBlocks)
+ return S_FALSE;
+ if (((size + ((size_t)1 << _h.BlockBits) - 1) >> _h.BlockBits) > _h.NumBlocks - block)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(inStream, (UInt64)block << _h.BlockBits))
+ _totalRead += size;
+ return ReadStream_FALSE(inStream, data, size);
+}
+
+
+static const unsigned kHeaderSize = 2 * 1024;
+static const unsigned kHeaderDataOffset = 1024;
+
+HRESULT CHandler::Open2(IInStream *inStream)
+{
+ {
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(inStream, buf, kHeaderSize))
+ if (!_h.Parse(buf + kHeaderDataOffset))
+ return S_FALSE;
+ if (_h.BlockGroupNr != 0)
+ return S_FALSE; // it's just copy of super block
+ }
+
+ {
+ // ---------- Read groups and nodes ----------
+
+ unsigned numGroups;
+ {
+ const UInt64 numGroups64 = _h.GetNumGroups();
+ if (numGroups64 > (UInt32)1 << 31)
+ return S_FALSE;
+ numGroups = (unsigned)numGroups64;
+ }
+
+ unsigned gdBits = 5;
+ if (_h.Is64Bit())
+ {
+ if (_h.GdSize != 64)
+ return S_FALSE;
+ gdBits = 6;
+ }
+
+ _isArc = true;
+ _phySize = _h.GetPhySize();
+
+ if (_openCallback)
+ {
+ RINOK(_openCallback->SetTotal(NULL, &_phySize))
+ }
+
+ UInt64 fileSize = 0;
+ RINOK(InStream_GetSize_SeekToEnd(inStream, fileSize))
+
+ CRecordVector<CGroupDescriptor> groups;
+
+ {
+ // ---------- Read groups ----------
+
+ CByteBuffer gdBuf;
+ const size_t gdBufSize = (size_t)numGroups << gdBits;
+ if ((gdBufSize >> gdBits) != numGroups)
+ return S_FALSE;
+ gdBuf.Alloc(gdBufSize);
+ RINOK(SeekAndRead(inStream, (_h.BlockBits <= 10 ? 2 : 1), gdBuf, gdBufSize))
+
+ for (unsigned i = 0; i < numGroups; i++)
+ {
+ CGroupDescriptor gd;
+
+ const Byte *p = gdBuf + ((size_t)i << gdBits);
+ const unsigned gd_Size = (unsigned)1 << gdBits;
+ gd.Parse(p, gd_Size);
+
+ if (_h.UseMetadataChecksum())
+ {
+ // use CRC32c
+ }
+ else if (_h.UseGdtChecksum())
+ {
+ UInt32 crc = Crc16Calc(_h.Uuid, sizeof(_h.Uuid));
+ Byte i_le[4];
+ SetUi32(i_le, i)
+ crc = Crc16Update(crc, i_le, 4);
+ crc = Crc16Update(crc, p, 32 - 2);
+ if (gd_Size != 32)
+ crc = Crc16Update(crc, p + 32, gd_Size - 32);
+ if (crc != gd.Checksum)
+ return S_FALSE;
+ }
+
+ groups.Add(gd);
+ }
+ }
+
+ {
+ // ---------- Read nodes ----------
+
+ if (_h.NumInodes < _h.NumFreeInodes)
+ return S_FALSE;
+
+ UInt32 numNodes = _h.InodesPerGroup;
+ if (numNodes > _h.NumInodes)
+ numNodes = _h.NumInodes;
+ const size_t nodesDataSize = (size_t)numNodes * _h.InodeSize;
+
+ if (nodesDataSize / _h.InodeSize != numNodes)
+ return S_FALSE;
+
+ // that code to reduce false detecting cases
+ if (nodesDataSize > fileSize)
+ {
+ if (numNodes > (1 << 24))
+ return S_FALSE;
+ }
+
+ const UInt32 numReserveInodes = _h.NumInodes - _h.NumFreeInodes + 1;
+ // numReserveInodes = _h.NumInodes + 1;
+ if (numReserveInodes != 0)
+ {
+ _nodes.Reserve(numReserveInodes);
+ _refs.Reserve(numReserveInodes);
+ }
+
+ CByteBuffer nodesData;
+ nodesData.Alloc(nodesDataSize);
+
+ CByteBuffer nodesMap;
+ const size_t blockSize = (size_t)1 << _h.BlockBits;
+ nodesMap.Alloc(blockSize);
+
+ unsigned globalNodeIndex = 0;
+ // unsigned numEmpty = 0;
+ unsigned numEmpty_in_Maps = 0;
+
+ FOR_VECTOR (gi, groups)
+ {
+ if (globalNodeIndex >= _h.NumInodes)
+ break;
+
+ const CGroupDescriptor &gd = groups[gi];
+
+ PRF(printf("\n\ng%6d block = %6x\n", gi, (unsigned)gd.InodeTable));
+
+ RINOK(SeekAndRead(inStream, gd.InodeBitmap, nodesMap, blockSize))
+ RINOK(SeekAndRead(inStream, gd.InodeTable, nodesData, nodesDataSize))
+
+ unsigned numEmpty_in_Map = 0;
+
+ for (size_t n = 0; n < numNodes && globalNodeIndex < _h.NumInodes; n++, globalNodeIndex++)
+ {
+ if ((nodesMap[n >> 3] & ((unsigned)1 << (n & 7))) == 0)
+ {
+ numEmpty_in_Map++;
+ continue;
+ }
+
+ const Byte *p = nodesData + (size_t)n * _h.InodeSize;
+ if (IsEmptyData(p, _h.InodeSize))
+ {
+ if (globalNodeIndex + 1 >= _h.FirstInode)
+ {
+ _headersError = true;
+ // return S_FALSE;
+ }
+ continue;
+ }
+
+ CNode node;
+
+ PRF(printf("\nnode = %5d ", (unsigned)n));
+
+ if (!node.Parse(p, _h))
+ return S_FALSE;
+
+ // PRF(printf("\n %6d", (unsigned)n));
+ /*
+ SetUi32(p + 0x7C, 0)
+ SetUi32(p + 0x82, 0)
+
+ UInt32 crc = Crc32C_Calc(_h.Uuid, sizeof(_h.Uuid));
+ Byte i_le[4];
+ SetUi32(i_le, n);
+ crc = Crc32C_Update(crc, i_le, 4);
+ crc = Crc32C_Update(crc, p, _h.InodeSize);
+ if (crc != node.Checksum) return S_FALSE;
+ */
+
+ while (_refs.Size() < globalNodeIndex + 1)
+ {
+ // numEmpty++;
+ _refs.Add(-1);
+ }
+
+ _refs.Add((int)_nodes.Add(node));
+ }
+
+
+ numEmpty_in_Maps += numEmpty_in_Map;
+
+ if (numEmpty_in_Map != gd.NumFreeInodes)
+ {
+ _headersWarning = true;
+ // return S_FALSE;
+ }
+ }
+
+ if (numEmpty_in_Maps != _h.NumFreeInodes)
+ {
+ // some ext2 examples has incorrect value in _h.NumFreeInodes.
+ // so we disable check;
+ _headersWarning = true;
+ }
+
+ if (_refs.Size() <= k_INODE_ROOT)
+ return S_FALSE;
+
+ // printf("\n numReserveInodes = %6d, _refs.Size() = %d, numEmpty = %7d\n", numReserveInodes, _refs.Size(), (unsigned)numEmpty);
+ }
+ }
+
+ _stream = inStream; // we need stream for dir nodes
+
+ {
+ // ---------- Read Dirs ----------
+
+ CByteBuffer dataBuf;
+
+ FOR_VECTOR (i, _refs)
+ {
+ const int nodeIndex = _refs[i];
+ {
+ if (nodeIndex < 0)
+ continue;
+ const CNode &node = _nodes[nodeIndex];
+ if (!node.IsDir())
+ continue;
+ }
+ RINOK(ExtractNode((unsigned)nodeIndex, dataBuf))
+ if (dataBuf.Size() == 0)
+ {
+ // _headersError = true;
+ return S_FALSE;
+ }
+ else
+ {
+ RINOK(ParseDir(dataBuf, dataBuf.Size(), i))
+ }
+ RINOK(CheckProgress())
+ }
+
+ const int ref = _refs[k_INODE_ROOT];
+ if (ref < 0 || _nodes[ref].ParentNode != k_INODE_ROOT)
+ return S_FALSE;
+ }
+
+ {
+ // ---------- Check NumLinks and unreferenced dir nodes ----------
+
+ FOR_VECTOR (i, _refs)
+ {
+ int nodeIndex = _refs[i];
+ if (nodeIndex < 0)
+ continue;
+ const CNode &node = _nodes[nodeIndex];
+
+ if (node.NumLinks != node.NumLinksCalced)
+ {
+ if (node.NumLinks != 1 || node.NumLinksCalced != 0
+ // ) && i >= _h.FirstInode
+ )
+ {
+ _linksError = true;
+ // return S_FALSE;
+ }
+ }
+
+ if (!node.IsDir())
+ continue;
+
+ if (node.ParentNode < 0)
+ {
+ if (i >= _h.FirstInode)
+ return S_FALSE;
+ continue;
+ }
+ }
+ }
+
+ {
+ // ---------- Check that there is no loops in parents list ----------
+
+ unsigned numNodes = _refs.Size();
+ CIntArr UsedByNode(numNodes);
+ {
+ {
+ for (unsigned i = 0; i < numNodes; i++)
+ UsedByNode[i] = -1;
+ }
+ }
+
+ FOR_VECTOR (i, _refs)
+ {
+ {
+ int nodeIndex = _refs[i];
+ if (nodeIndex < 0)
+ continue;
+ const CNode &node = _nodes[nodeIndex];
+ if (node.ParentNode < 0 // not dir
+ || i == k_INODE_ROOT)
+ continue;
+ }
+
+ unsigned c = i;
+
+ for (;;)
+ {
+ const int nodeIndex = _refs[c];
+ if (nodeIndex < 0)
+ return S_FALSE;
+ CNode &node = _nodes[nodeIndex];
+
+ if (UsedByNode[c] != -1)
+ {
+ if ((unsigned)UsedByNode[c] == i)
+ return S_FALSE;
+ break;
+ }
+
+ UsedByNode[c] = (int)i;
+ if (node.ParentNode < 0 || node.ParentNode == k_INODE_ROOT)
+ break;
+ if ((unsigned)node.ParentNode == i)
+ return S_FALSE;
+ c = (unsigned)node.ParentNode;
+ }
+ }
+ }
+
+ {
+ // ---------- Fill SymLinks data ----------
+
+ AString s;
+ CByteBuffer data;
+
+ unsigned i;
+ for (i = 0; i < _refs.Size(); i++)
+ {
+ const int nodeIndex = _refs[i];
+ if (nodeIndex < 0)
+ continue;
+ CNode &node = _nodes[nodeIndex];
+ if (!node.IsLink())
+ continue;
+ if (node.FileSize > ((UInt32)1 << 14))
+ continue;
+ if (ExtractNode((unsigned)nodeIndex, data) == S_OK && data.Size() != 0)
+ {
+ s.SetFrom_CalcLen((const char *)(const Byte *)data, (unsigned)data.Size());
+ if (s.Len() == data.Size())
+ node.SymLinkIndex = (int)_symLinks.Add(s);
+ RINOK(CheckProgress())
+ }
+ }
+
+ for (i = 0; i < _dirs.Size(); i++)
+ {
+ _dirs[i].Sort(CompareItemsNames, (void *)&_items);
+ }
+
+ unsigned prev = 0;
+ unsigned complex = 0;
+
+ for (i = 0; i < _items.Size(); i++)
+ {
+ CItem &item = _items[i];
+ const int sym = _nodes[_refs[item.Node]].SymLinkIndex;
+ if (sym >= 0 && item.ParentNode >= 0)
+ {
+ item.SymLinkItemIndex = FindTargetItem_for_SymLink((unsigned)item.ParentNode, _symLinks[sym]);
+ if (_openCallback)
+ {
+ complex++;
+ if (complex - prev >= (1 << 10))
+ {
+ prev = complex;
+ RINOK(CheckProgress2())
+ }
+ }
+ }
+ }
+ }
+
+ {
+ // ---------- Add items and aux folders for unreferenced files ----------
+
+ bool useSys = false;
+ bool useUnknown = false;
+
+ FOR_VECTOR (i, _refs)
+ {
+ const int nodeIndex = _refs[i];
+ if (nodeIndex < 0)
+ continue;
+ const CNode &node = _nodes[nodeIndex];
+
+ if (node.NumLinksCalced == 0 /* || i > 100 && i < 150 */) // for debug
+ {
+ CItem item;
+ item.Node = i;
+
+ // we don't know how to work with k_INODE_RESIZE node (strange FileSize and Block values).
+ // so we ignore it;
+
+ if (i == k_INODE_RESIZE)
+ continue;
+
+ if (node.FileSize == 0)
+ continue;
+
+ if (i < _h.FirstInode)
+ {
+ if (item.Node < Z7_ARRAY_SIZE(k_SysInode_Names))
+ item.Name = k_SysInode_Names[item.Node];
+ useSys = true;
+ }
+ else
+ useUnknown = true;
+
+ if (item.Name.IsEmpty())
+ item.Name.Add_UInt32(item.Node);
+
+ _items.Add(item);
+ }
+ }
+
+ if (useSys)
+ _auxSysIndex = (int)_auxItems.Add((AString)"[SYS]");
+ if (useUnknown)
+ _auxUnknownIndex = (int)_auxItems.Add((AString)"[UNKNOWN]");
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ HRESULT res;
+ try
+ {
+ _openCallback = callback;
+ res = Open2(stream);
+ }
+ catch(...)
+ {
+ ClearRefs();
+ throw;
+ }
+
+ if (res != S_OK)
+ {
+ ClearRefs();
+ return res;
+ }
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+void CHandler::ClearRefs()
+{
+ _stream.Release();
+ _items.Clear();
+ _nodes.Clear();
+ _refs.Clear();
+ _auxItems.Clear();
+ _symLinks.Clear();
+ _dirs.Clear();
+ _auxSysIndex = -1;
+ _auxUnknownIndex = -1;
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalRead = 0;
+ _totalReadPrev = 0;
+ _phySize = 0;
+ _isArc = false;
+ _headersError = false;
+ _headersWarning = false;
+ _linksError = false;
+ _isUTF = true;
+
+ ClearRefs();
+ return S_OK;
+}
+
+
+static void ChangeSeparatorsInName(char *s, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ {
+ char c = s[i];
+ if (c == CHAR_PATH_SEPARATOR || c == '/')
+ s[i] = '_';
+ }
+}
+
+
+void CHandler::GetPath(unsigned index, AString &s) const
+{
+ s.Empty();
+
+ if (index >= _items.Size())
+ {
+ s = _auxItems[index - _items.Size()];
+ return;
+ }
+
+ for (;;)
+ {
+ const CItem &item = _items[index];
+ if (!s.IsEmpty())
+ s.InsertAtFront(CHAR_PATH_SEPARATOR);
+ s.Insert(0, item.Name);
+ // 18.06
+ ChangeSeparatorsInName(s.GetBuf(), item.Name.Len());
+
+ if (item.ParentNode == k_INODE_ROOT)
+ return;
+
+ if (item.ParentNode < 0)
+ {
+ int aux = GetParentAux(item);
+ if (aux < 0)
+ break;
+ s.InsertAtFront(CHAR_PATH_SEPARATOR);
+ s.Insert(0, _auxItems[aux]);
+ return;
+ }
+
+ const CNode &node = _nodes[_refs[item.ParentNode]];
+ if (node.ItemIndex < 0)
+ return;
+ index = (unsigned)node.ItemIndex;
+
+ if (s.Len() > ((UInt32)1 << 16))
+ {
+ s.Insert(0, "[LONG]" STRING_PATH_SEPARATOR);
+ return;
+ }
+ }
+}
+
+
+bool CHandler::GetPackSize(unsigned index, UInt64 &totalPack) const
+{
+ if (index >= _items.Size())
+ {
+ totalPack = 0;
+ return false;
+ }
+
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[_refs[item.Node]];
+
+ // if (!node.IsFlags_EXTENTS())
+ {
+ totalPack = (UInt64)node.NumBlocks << (node.IsFlags_HUGE() ? _h.BlockBits : 9);
+ return true;
+ }
+
+ /*
+ CExtentTreeHeader eth;
+ if (!eth.Parse(node.Block))
+ return false;
+ if (eth.NumEntries > 3)
+ return false;
+ if (!eth.Depth == 0)
+ return false;
+
+ UInt64 numBlocks = 0;
+ {
+ for (unsigned i = 0; i < eth.NumEntries; i++)
+ {
+ CExtent e;
+ e.Parse(node.Block + 12 + i * 12);
+ // const CExtent &e = node.leafs[i];
+ if (e.IsInited)
+ numBlocks += e.Len;
+ }
+ }
+
+ totalPack = numBlocks << _h.BlockBits;
+ return true;
+ */
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size() + _auxItems.Size();
+ return S_OK;
+}
+
+enum
+{
+ kpidMountTime = kpidUserDefined,
+ kpidLastCheckTime,
+ kpidRevision,
+ kpidINodeSize,
+ kpidLastMount,
+ kpidFeatureIncompat,
+ kpidFeatureRoCompat,
+ kpidWrittenKB
+
+ // kpidGroupSize,
+
+ // kpidChangeTime = kpidUserDefined + 256,
+ // kpidDTime
+};
+
+static const UInt32 kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidPosixAttrib,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ // kpidChangeTime,
+ // kpidDTime,
+ kpidINode,
+ kpidLinks,
+ kpidSymLink,
+ kpidCharacts,
+ kpidUserId,
+ kpidGroupId
+};
+
+
+static const CStatProp kArcProps[] =
+{
+ { NULL, kpidHeadersSize, VT_BSTR },
+ // { NULL, kpidFileSystem, VT_BSTR },
+ // kpidMethod,
+ { NULL, kpidClusterSize, VT_UI4 },
+ // { "Group Size", kpidGroupSize, VT_UI8 },
+ { NULL, kpidFreeSpace, VT_UI8 },
+
+ { NULL, kpidMTime, VT_FILETIME },
+ { NULL, kpidCTime, VT_FILETIME },
+ { "Mount Time", kpidMountTime, VT_FILETIME },
+ { "Last Check Time", kpidLastCheckTime, VT_FILETIME },
+
+ { NULL, kpidHostOS, VT_BSTR},
+ { "Revision", kpidRevision, VT_UI4},
+ { "inode Size", kpidINodeSize, VT_UI4},
+ { NULL, kpidCodePage, VT_BSTR},
+ { NULL, kpidVolumeName, VT_BSTR},
+ { "Last Mounted", kpidLastMount, VT_BSTR},
+ { NULL, kpidId, VT_BSTR},
+ { NULL, kpidCharacts, VT_BSTR },
+ { "Incompatible Features", kpidFeatureIncompat, VT_BSTR },
+ { "Readonly-compatible Features", kpidFeatureRoCompat, VT_BSTR },
+ { "Written KiB", kpidWrittenKB, VT_UI8 }
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+static void StringToProp(bool isUTF, const char *s, unsigned size, NCOM::CPropVariant &prop)
+{
+ UString u;
+ AString a;
+ a.SetFrom_CalcLen(s, size);
+ if (!isUTF || !ConvertUTF8ToUnicode(a, u))
+ MultiByteToUnicodeString2(u, a);
+ prop = u;
+}
+
+static void UnixTimeToProp(UInt32 val, NCOM::CPropVariant &prop)
+{
+ if (val != 0)
+ PropVariant_SetFrom_UnixTime(prop, val);
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ /*
+ case kpidFileSystem:
+ {
+ AString res = "Ext4";
+ prop = res;
+ break;
+ }
+ */
+
+ case kpidIsTree: prop = true; break;
+ case kpidIsAux: prop = true; break;
+ case kpidINode: prop = true; break;
+
+ case kpidClusterSize: prop = (UInt32)1 << _h.BlockBits; break;
+ // case kpidGroupSize: prop = (UInt64)_h.BlocksPerGroup << _h.BlockBits; break;
+
+ case kpidFreeSpace: prop = (UInt64)_h.NumFreeBlocks << _h.BlockBits; break;
+
+ case kpidCTime: UnixTimeToProp(_h.CTime, prop); break;
+ case kpidMTime: UnixTimeToProp(_h.WriteTime, prop); break;
+ case kpidMountTime: UnixTimeToProp(_h.MountTime, prop); break;
+ case kpidLastCheckTime: UnixTimeToProp(_h.LastCheckTime, prop); break;
+
+ case kpidHostOS:
+ {
+ TYPE_TO_PROP(kHostOS, _h.CreatorOs, prop);
+ break;
+ }
+
+ case kpidRevision: prop = _h.RevLevel; break;
+
+ case kpidINodeSize: prop = (UInt32)_h.InodeSize; break;
+
+ case kpidId:
+ {
+ if (!IsEmptyData(_h.Uuid, 16))
+ {
+ char s[16 * 2 + 2];
+ for (unsigned i = 0; i < 16; i++)
+ PrintHex(_h.Uuid[i], s + i * 2);
+ s[16 * 2] = 0;
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidCodePage: if (_isUTF) prop = "UTF-8"; break;
+
+ case kpidShortComment:
+ case kpidVolumeName:
+ StringToProp(_isUTF, _h.VolName, sizeof(_h.VolName), prop); break;
+
+ case kpidLastMount: StringToProp(_isUTF, _h.LastMount, sizeof(_h.LastMount), prop); break;
+
+ case kpidCharacts: FLAGS_TO_PROP(g_FeatureCompat_Flags, _h.FeatureCompat, prop); break;
+ case kpidFeatureIncompat: FLAGS_TO_PROP(g_FeatureIncompat_Flags, _h.FeatureIncompat, prop); break;
+ case kpidFeatureRoCompat: FLAGS_TO_PROP(g_FeatureRoCompat_Flags, _h.FeatureRoCompat, prop); break;
+ case kpidWrittenKB: if (_h.WrittenKB != 0) prop = _h.WrittenKB; break;
+
+ case kpidPhySize: prop = _phySize; break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_linksError) v |= kpv_ErrorFlags_HeadersError;
+ if (_headersError) v |= kpv_ErrorFlags_HeadersError;
+ if (!_stream && v == 0 && _isArc)
+ v = kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidWarningFlags:
+ {
+ UInt32 v = 0;
+ if (_headersWarning) v |= kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+/*
+static const Byte kRawProps[] =
+{
+ // kpidSha1,
+};
+*/
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ // *numProps = Z7_ARRAY_SIZE(kRawProps);
+ *numProps = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID))
+{
+ // *propID = kRawProps[index];
+ *propID = 0;
+ *name = NULL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+
+ if (index >= _items.Size())
+ return S_OK;
+
+ const CItem &item = _items[index];
+
+ if (item.ParentNode < 0)
+ {
+ const int aux = GetParentAux(item);
+ if (aux >= 0)
+ *parent = _items.Size() + (unsigned)aux;
+ }
+ else
+ {
+ const int itemIndex = _nodes[_refs[item.ParentNode]].ItemIndex;
+ if (itemIndex >= 0)
+ *parent = (unsigned)itemIndex;
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (propID == kpidName && _isUTF)
+ {
+ if (index < _items.Size())
+ {
+ const AString &s = _items[index].Name;
+ if (!s.IsEmpty())
+ {
+ *data = (void *)(const char *)s;
+ *dataSize = (UInt32)s.Len() + 1;
+ *propType = NPropDataType::kUtf8z;
+ }
+ return S_OK;
+ }
+ else
+ {
+ const AString &s = _auxItems[index - _items.Size()];
+ {
+ *data = (void *)(const char *)s;
+ *dataSize = (UInt32)s.Len() + 1;
+ *propType = NPropDataType::kUtf8z;
+ }
+ return S_OK;
+ }
+ }
+
+ return S_OK;
+}
+
+
+static void ExtTimeToProp(const CExtTime &t, NCOM::CPropVariant &prop)
+{
+ if (t.Val == 0 && t.Extra == 0)
+ return;
+
+ FILETIME ft;
+ unsigned low100ns = 0;
+ // if (t.Extra != 0)
+ {
+ // 1901-2446 :
+ Int64 v = (Int64)(Int32)t.Val;
+ v += (UInt64)(t.Extra & 3) << 32; // 2 low bits are offset for main timestamp
+ UInt64 ft64 = NTime::UnixTime64_To_FileTime64(v);
+ const UInt32 ns = (t.Extra >> 2);
+ if (ns < 1000000000)
+ {
+ ft64 += ns / 100;
+ low100ns = (unsigned)(ns % 100);
+ }
+ ft.dwLowDateTime = (DWORD)ft64;
+ ft.dwHighDateTime = (DWORD)(ft64 >> 32);
+ }
+ /*
+ else
+ {
+ // 1901-2038 : that code is good for ext4 and compatibility with Extra
+ NTime::UnixTime64ToFileTime((Int32)t.Val, ft); // for
+
+ // 1970-2106 : that code is good if timestamp is used as unsigned 32-bit
+ // are there such systems?
+ // NTime::UnixTimeToFileTime(t.Val, ft); // for
+ }
+ */
+ prop.SetAsTimeFrom_FT_Prec_Ns100(ft, k_PropVar_TimePrec_1ns, low100ns);
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ if (index >= _items.Size())
+ {
+ switch (propID)
+ {
+ case kpidPath:
+ case kpidName:
+ {
+ prop = _auxItems[index - _items.Size()];
+ break;
+ }
+ case kpidIsDir: prop = true; break;
+ case kpidIsAux: prop = true; break;
+ }
+ }
+ else
+ {
+
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[_refs[item.Node]];
+ bool isDir = node.IsDir();
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString u;
+ {
+ AString s;
+ GetPath(index, s);
+ if (!_isUTF || !ConvertUTF8ToUnicode(s, u))
+ MultiByteToUnicodeString2(u, s);
+ }
+ prop = u;
+ break;
+ }
+
+ case kpidName:
+ {
+ {
+ UString u;
+ {
+ if (!_isUTF || !ConvertUTF8ToUnicode(item.Name, u))
+ MultiByteToUnicodeString2(u, item.Name);
+ }
+ prop = u;
+ }
+ break;
+ }
+
+ case kpidIsDir:
+ {
+ bool isDir2 = isDir;
+ if (item.SymLinkItemIndex >= 0)
+ isDir2 = _nodes[_refs[_items[item.SymLinkItemIndex].Node]].IsDir();
+ prop = isDir2;
+ break;
+ }
+
+ case kpidSize: if (!isDir) prop = node.FileSize; break;
+
+ case kpidPackSize:
+ if (!isDir)
+ {
+ UInt64 size;
+ if (GetPackSize(index, size))
+ prop = size;
+ }
+ break;
+
+ case kpidPosixAttrib:
+ {
+ /*
+ if (node.Type != 0 && node.Type < Z7_ARRAY_SIZE(k_TypeToMode))
+ prop = (UInt32)(node.Mode & 0xFFF) | k_TypeToMode[node.Type];
+ */
+ prop = (UInt32)(node.Mode);
+ break;
+ }
+
+ case kpidMTime: ExtTimeToProp(node.MTime, prop); break;
+ case kpidCTime: ExtTimeToProp(node.CTime, prop); break;
+ case kpidATime: ExtTimeToProp(node.ATime, prop); break;
+ // case kpidDTime: ExtTimeToProp(node.DTime, prop); break;
+ case kpidChangeTime: ExtTimeToProp(node.ChangeTime, prop); break;
+ case kpidUserId: prop = (UInt32)node.Uid; break;
+ case kpidGroupId: prop = (UInt32)node.Gid; break;
+ case kpidLinks: prop = node.NumLinks; break;
+ case kpidINode: prop = (UInt32)item.Node; break;
+ case kpidStreamId: if (!isDir) prop = (UInt32)item.Node; break;
+ case kpidCharacts: FLAGS_TO_PROP(g_NodeFlags, (UInt32)node.Flags, prop); break;
+
+ case kpidSymLink:
+ {
+ if (node.SymLinkIndex >= 0)
+ {
+ UString u;
+ {
+ const AString &s = _symLinks[node.SymLinkIndex];
+ if (!_isUTF || !ConvertUTF8ToUnicode(s, u))
+ MultiByteToUnicodeString2(u, s);
+ }
+ prop = u;
+ }
+ break;
+ }
+ }
+
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_IInStream(CClusterInStream2
+)
+ UInt64 _virtPos;
+ UInt64 _physPos;
+ UInt32 _curRem;
+public:
+ unsigned BlockBits;
+ UInt64 Size;
+ CMyComPtr<IInStream> Stream;
+ CRecordVector<UInt32> Vector;
+
+ HRESULT SeekToPhys() { return InStream_SeekSet(Stream, _physPos); }
+
+ HRESULT InitAndSeek()
+ {
+ _curRem = 0;
+ _virtPos = 0;
+ _physPos = 0;
+ if (Vector.Size() > 0)
+ {
+ _physPos = (Vector[0] << BlockBits);
+ return SeekToPhys();
+ }
+ return S_OK;
+ }
+};
+
+
+Z7_COM7F_IMF(CClusterInStream2::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= Size)
+ return S_OK;
+ {
+ UInt64 rem = Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+
+ if (_curRem == 0)
+ {
+ const UInt32 blockSize = (UInt32)1 << BlockBits;
+ const UInt32 virtBlock = (UInt32)(_virtPos >> BlockBits);
+ const UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
+ const UInt32 phyBlock = Vector[virtBlock];
+
+ if (phyBlock == 0)
+ {
+ UInt32 cur = blockSize - offsetInBlock;
+ if (cur > size)
+ cur = size;
+ memset(data, 0, cur);
+ _virtPos += cur;
+ if (processedSize)
+ *processedSize = cur;
+ return S_OK;
+ }
+
+ UInt64 newPos = ((UInt64)phyBlock << BlockBits) + offsetInBlock;
+ if (newPos != _physPos)
+ {
+ _physPos = newPos;
+ RINOK(SeekToPhys())
+ }
+
+ _curRem = blockSize - offsetInBlock;
+
+ for (unsigned i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
+ _curRem += (UInt32)1 << BlockBits;
+ }
+
+ if (size > _curRem)
+ size = _curRem;
+ HRESULT res = Stream->Read(data, size, &size);
+ if (processedSize)
+ *processedSize = size;
+ _physPos += size;
+ _virtPos += size;
+ _curRem -= size;
+ return res;
+}
+
+Z7_COM7F_IMF(CClusterInStream2::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ if (_virtPos != (UInt64)offset)
+ _curRem = 0;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_IInStream(
+ CExtInStream
+)
+ UInt64 _virtPos;
+ UInt64 _phyPos;
+public:
+ unsigned BlockBits;
+ UInt64 Size;
+ CMyComPtr<IInStream> Stream;
+ CRecordVector<CExtent> Extents;
+
+ HRESULT StartSeek()
+ {
+ _virtPos = 0;
+ _phyPos = 0;
+ return InStream_SeekSet(Stream, _phyPos);
+ }
+};
+
+Z7_COM7F_IMF(CExtInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= Size)
+ return S_OK;
+ {
+ UInt64 rem = Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+
+ UInt32 blockIndex = (UInt32)(_virtPos >> BlockBits);
+
+ unsigned left = 0, right = Extents.Size();
+ for (;;)
+ {
+ unsigned mid = (left + right) / 2;
+ if (mid == left)
+ break;
+ if (blockIndex < Extents[mid].VirtBlock)
+ right = mid;
+ else
+ left = mid;
+ }
+
+ {
+ const CExtent &extent = Extents[left];
+ if (blockIndex < extent.VirtBlock)
+ return E_FAIL;
+ UInt32 bo = blockIndex - extent.VirtBlock;
+ if (bo >= extent.Len)
+ return E_FAIL;
+
+ UInt32 offset = ((UInt32)_virtPos & (((UInt32)1 << BlockBits) - 1));
+ UInt32 remBlocks = extent.Len - bo;
+ UInt64 remBytes = ((UInt64)remBlocks << BlockBits);
+ remBytes -= offset;
+
+ if (size > remBytes)
+ size = (UInt32)remBytes;
+
+ if (!extent.IsInited)
+ {
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ const UInt64 phyBlock = extent.PhyStart + bo;
+ const UInt64 phy = (phyBlock << BlockBits) + offset;
+
+ if (phy != _phyPos)
+ {
+ RINOK(InStream_SeekSet(Stream, phy))
+ _phyPos = phy;
+ }
+
+ UInt32 realProcessSize = 0;
+
+ const HRESULT res = Stream->Read(data, size, &realProcessSize);
+
+ _phyPos += realProcessSize;
+ _virtPos += realProcessSize;
+ if (processedSize)
+ *processedSize = realProcessSize;
+ return res;
+ }
+}
+
+
+Z7_COM7F_IMF(CExtInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+
+HRESULT CHandler::FillFileBlocks2(UInt32 block, unsigned level, unsigned numBlocks, CRecordVector<UInt32> &blocks)
+{
+ const size_t blockSize = (size_t)1 << _h.BlockBits;
+ CByteBuffer &tempBuf = _tempBufs[level];
+ tempBuf.Alloc(blockSize);
+
+ PRF2(printf("\n level = %d, block = %7d", level, (unsigned)block));
+
+ RINOK(SeekAndRead(_stream, block, tempBuf, blockSize))
+
+ const Byte *p = tempBuf;
+ size_t num = (size_t)1 << (_h.BlockBits - 2);
+
+ for (size_t i = 0; i < num; i++)
+ {
+ if (blocks.Size() == numBlocks)
+ break;
+ UInt32 val = GetUi32(p + 4 * i);
+ if (val >= _h.NumBlocks)
+ return S_FALSE;
+
+ if (level != 0)
+ {
+ if (val == 0)
+ {
+ /*
+ size_t num = (size_t)1 << ((_h.BlockBits - 2) * (level));
+ PRF2(printf("\n num empty = %3d", (unsigned)num));
+ for (size_t k = 0; k < num; k++)
+ {
+ blocks.Add(0);
+ if (blocks.Size() == numBlocks)
+ return S_OK;
+ }
+ continue;
+ */
+ return S_FALSE;
+ }
+
+ RINOK(FillFileBlocks2(val, level - 1, numBlocks, blocks))
+ continue;
+ }
+
+ PRF2(printf("\n i = %3d, blocks.Size() = %6d, block = %5d ", i, blocks.Size(), (unsigned)val));
+
+ PRF(printf("\n i = %3d, start = %5d ", (unsigned)i, (unsigned)val));
+
+ blocks.Add(val);
+ }
+
+ return S_OK;
+}
+
+
+static const unsigned kNumDirectNodeBlocks = 12;
+
+HRESULT CHandler::FillFileBlocks(const Byte *p, unsigned numBlocks, CRecordVector<UInt32> &blocks)
+{
+ // ext2 supports zero blocks (blockIndex == 0).
+
+ blocks.ClearAndReserve(numBlocks);
+
+ for (unsigned i = 0; i < kNumDirectNodeBlocks; i++)
+ {
+ if (i == numBlocks)
+ return S_OK;
+ UInt32 val = GetUi32(p + 4 * i);
+ if (val >= _h.NumBlocks)
+ return S_FALSE;
+ blocks.Add(val);
+ }
+
+ for (unsigned level = 0; level < 3; level++)
+ {
+ if (blocks.Size() == numBlocks)
+ break;
+ UInt32 val = GetUi32(p + 4 * (kNumDirectNodeBlocks + level));
+ if (val >= _h.NumBlocks)
+ return S_FALSE;
+
+ if (val == 0)
+ {
+ /*
+ size_t num = (size_t)1 << ((_h.BlockBits - 2) * (level + 1));
+ for (size_t k = 0; k < num; k++)
+ {
+ blocks.Add(0);
+ if (blocks.Size() == numBlocks)
+ return S_OK;
+ }
+ continue;
+ */
+ return S_FALSE;
+ }
+
+ RINOK(FillFileBlocks2(val, level, numBlocks, blocks))
+ }
+
+ return S_OK;
+}
+
+
+static void AddSkipExtents(CRecordVector<CExtent> &extents, UInt32 virtBlock, UInt32 numBlocks)
+{
+ while (numBlocks != 0)
+ {
+ UInt32 len = numBlocks;
+ const UInt32 kLenMax = (UInt32)1 << 15;
+ if (len > kLenMax)
+ len = kLenMax;
+ CExtent e;
+ e.VirtBlock = virtBlock;
+ e.Len = (UInt16)len;
+ e.IsInited = false;
+ e.PhyStart = 0;
+ extents.Add(e);
+ virtBlock += len;
+ numBlocks -= len;
+ }
+}
+
+static bool UpdateExtents(CRecordVector<CExtent> &extents, UInt32 block)
+{
+ if (extents.IsEmpty())
+ {
+ if (block == 0)
+ return true;
+ AddSkipExtents(extents, 0, block);
+ return true;
+ }
+
+ const CExtent &prev = extents.Back();
+ if (block < prev.VirtBlock)
+ return false;
+ UInt32 prevEnd = prev.GetVirtEnd();
+ if (block == prevEnd)
+ return true;
+ AddSkipExtents(extents, prevEnd, block - prevEnd);
+ return true;
+}
+
+
+HRESULT CHandler::FillExtents(const Byte *p, size_t size, CRecordVector<CExtent> &extents, int parentDepth)
+{
+ CExtentTreeHeader eth;
+ if (!eth.Parse(p))
+ return S_FALSE;
+
+ if (parentDepth >= 0 && eth.Depth != parentDepth - 1) // (eth.Depth >= parentDepth)
+ return S_FALSE;
+
+ if (12 + 12 * (size_t)eth.NumEntries > size)
+ return S_FALSE;
+
+ if (eth.Depth >= kNumTreeLevelsMax)
+ return S_FALSE;
+
+ if (eth.Depth == 0)
+ {
+ for (unsigned i = 0; i < eth.NumEntries; i++)
+ {
+ CExtent e;
+ e.Parse(p + 12 + i * 12);
+ if (e.PhyStart == 0
+ || e.PhyStart > _h.NumBlocks
+ || e.PhyStart + e.Len > _h.NumBlocks
+ || !e.IsLenOK())
+ return S_FALSE;
+ if (!UpdateExtents(extents, e.VirtBlock))
+ return S_FALSE;
+ extents.Add(e);
+ }
+
+ return S_OK;
+ }
+
+ const size_t blockSize = (size_t)1 << _h.BlockBits;
+ CByteBuffer &tempBuf = _tempBufs[eth.Depth];
+ tempBuf.Alloc(blockSize);
+
+ for (unsigned i = 0; i < eth.NumEntries; i++)
+ {
+ CExtentIndexNode e;
+ e.Parse(p + 12 + i * 12);
+
+ if (e.PhyLeaf == 0 || e.PhyLeaf >= _h.NumBlocks)
+ return S_FALSE;
+
+ if (!UpdateExtents(extents, e.VirtBlock))
+ return S_FALSE;
+
+ RINOK(SeekAndRead(_stream, e.PhyLeaf, tempBuf, blockSize))
+ RINOK(FillExtents(tempBuf, blockSize, extents, eth.Depth))
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CHandler::GetStream_Node(unsigned nodeIndex, ISequentialInStream **stream)
+{
+ COM_TRY_BEGIN
+
+ *stream = NULL;
+
+ const CNode &node = _nodes[nodeIndex];
+
+ if (!node.IsFlags_EXTENTS())
+ {
+ // maybe sparse file can have (node.NumBlocks == 0) ?
+
+ /* The following code doesn't work correctly for some CentOS images,
+ where there are nodes with inline data and (node.NumBlocks != 0).
+ If you know better way to detect inline data, please notify 7-Zip developers. */
+
+ if (node.NumBlocks == 0 && node.FileSize < kNodeBlockFieldSize)
+ {
+ Create_BufInStream_WithNewBuffer(node.Block, (size_t)node.FileSize, stream);
+ return S_OK;
+ }
+ }
+
+ if (node.FileSize >= ((UInt64)1 << 63))
+ return S_FALSE;
+
+ CMyComPtr<IInStream> streamTemp;
+
+ UInt64 numBlocks64 = (node.FileSize + (UInt64)(((UInt32)1 << _h.BlockBits) - 1)) >> _h.BlockBits;
+
+ if (node.IsFlags_EXTENTS())
+ {
+ if ((UInt32)numBlocks64 != numBlocks64)
+ return S_FALSE;
+
+ CExtInStream *streamSpec = new CExtInStream;
+ streamTemp = streamSpec;
+
+ streamSpec->BlockBits = _h.BlockBits;
+ streamSpec->Size = node.FileSize;
+ streamSpec->Stream = _stream;
+
+ RINOK(FillExtents(node.Block, kNodeBlockFieldSize, streamSpec->Extents, -1))
+
+ UInt32 end = 0;
+ if (!streamSpec->Extents.IsEmpty())
+ end = streamSpec->Extents.Back().GetVirtEnd();
+ if (end < numBlocks64)
+ {
+ AddSkipExtents(streamSpec->Extents, end, (UInt32)(numBlocks64 - end));
+ // return S_FALSE;
+ }
+
+ RINOK(streamSpec->StartSeek())
+ }
+ else
+ {
+ {
+ UInt64 numBlocks2 = numBlocks64;
+
+ if (numBlocks64 > kNumDirectNodeBlocks)
+ {
+ UInt64 rem = numBlocks64 - kNumDirectNodeBlocks;
+ const unsigned refBits = (_h.BlockBits - 2);
+ const size_t numRefsInBlocks = (size_t)1 << refBits;
+ numBlocks2++;
+ if (rem > numRefsInBlocks)
+ {
+ numBlocks2++;
+ const UInt64 numL2 = (rem - 1) >> refBits;
+ numBlocks2 += numL2;
+ if (numL2 > numRefsInBlocks)
+ {
+ numBlocks2++;
+ numBlocks2 += (numL2 - 1) >> refBits;
+ }
+ }
+ }
+
+ const unsigned specBits = (node.IsFlags_HUGE() ? 0 : _h.BlockBits - 9);
+ const UInt32 specMask = ((UInt32)1 << specBits) - 1;
+ if ((node.NumBlocks & specMask) != 0)
+ return S_FALSE;
+ const UInt64 numBlocks64_from_header = node.NumBlocks >> specBits;
+ if (numBlocks64_from_header < numBlocks2)
+ {
+ // why (numBlocks64_from_header > numBlocks2) in some cases?
+ // return S_FALSE;
+ }
+ }
+
+ unsigned numBlocks = (unsigned)numBlocks64;
+ if (numBlocks != numBlocks64)
+ return S_FALSE;
+
+ CClusterInStream2 *streamSpec = new CClusterInStream2;
+ streamTemp = streamSpec;
+
+ streamSpec->BlockBits = _h.BlockBits;
+ streamSpec->Size = node.FileSize;
+ streamSpec->Stream = _stream;
+
+ RINOK(FillFileBlocks(node.Block, numBlocks, streamSpec->Vector))
+ streamSpec->InitAndSeek();
+ }
+
+ *stream = streamTemp.Detach();
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::ExtractNode(unsigned nodeIndex, CByteBuffer &data)
+{
+ data.Free();
+ const CNode &node = _nodes[nodeIndex];
+ size_t size = (size_t)node.FileSize;
+ if (size != node.FileSize)
+ return S_FALSE;
+ CMyComPtr<ISequentialInStream> inSeqStream;
+ RINOK(GetStream_Node(nodeIndex, &inSeqStream))
+ if (!inSeqStream)
+ return S_FALSE;
+ data.Alloc(size);
+ _totalRead += size;
+ return ReadStream_FALSE(inSeqStream, data, size);
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size() + _auxItems.Size();
+ if (numItems == 0)
+ return S_OK;
+
+ UInt64 totalSize = 0;
+ UInt32 i;
+
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ if (index >= _items.Size())
+ continue;
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[_refs[item.Node]];
+ if (!node.IsDir())
+ totalSize += node.FileSize;
+ }
+
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0;; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+
+ if (i == numItems)
+ break;
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+
+ if (index >= _items.Size())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[_refs[item.Node]];
+
+ if (node.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ UInt64 unpackSize = node.FileSize;
+ totalSize += unpackSize;
+ UInt64 packSize;
+ if (GetPackSize(index, packSize))
+ totalPackSize += packSize;
+
+ if (!testMode && !outStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ int res = NExtract::NOperationResult::kDataError;
+ {
+ CMyComPtr<ISequentialInStream> inSeqStream;
+ HRESULT hres = GetStream(index, &inSeqStream);
+ if (hres == S_FALSE || !inSeqStream)
+ {
+ if (hres == E_OUTOFMEMORY)
+ return hres;
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ }
+ else
+ {
+ RINOK(hres)
+ {
+ hres = copyCoder->Code(inSeqStream, outStream, NULL, NULL, progress);
+ if (hres == S_OK)
+ {
+ if (copyCoderSpec->TotalSize == unpackSize)
+ res = NExtract::NOperationResult::kOK;
+ }
+ else if (hres == E_NOTIMPL)
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ }
+ else if (hres != S_FALSE)
+ {
+ RINOK(hres)
+ }
+ }
+ }
+ }
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ *stream = NULL;
+ if (index >= _items.Size())
+ return S_FALSE;
+ return GetStream_Node((unsigned)_refs[_items[index].Node], stream);
+}
+
+
+API_FUNC_IsArc IsArc_Ext_PhySize(const Byte *p, size_t size, UInt64 *phySize);
+API_FUNC_IsArc IsArc_Ext_PhySize(const Byte *p, size_t size, UInt64 *phySize)
+{
+ if (phySize)
+ *phySize = 0;
+ if (size < kHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ CHeader h;
+ if (!h.Parse(p + kHeaderDataOffset))
+ return k_IsArc_Res_NO;
+ if (phySize)
+ *phySize = h.GetPhySize();
+ return k_IsArc_Res_YES;
+}
+
+
+API_FUNC_IsArc IsArc_Ext(const Byte *p, size_t size);
+API_FUNC_IsArc IsArc_Ext(const Byte *p, size_t size)
+{
+ return IsArc_Ext_PhySize(p, size, NULL);
+}
+
+
+static const Byte k_Signature[] = { 0x53, 0xEF };
+
+REGISTER_ARC_I(
+ "Ext", "ext ext2 ext3 ext4 img", NULL, 0xC7,
+ k_Signature,
+ 0x438,
+ 0,
+ IsArc_Ext)
+
+}}
diff --git a/CPP/7zip/Archive/FatHandler.cpp b/CPP/7zip/Archive/FatHandler.cpp
new file mode 100644
index 0000000..4a843a8
--- /dev/null
+++ b/CPP/7zip/Archive/FatHandler.cpp
@@ -0,0 +1,1068 @@
+// FatHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/DummyOutStream.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+#define PRF(x) /* x */
+
+namespace NArchive {
+namespace NFat {
+
+static const UInt32 kFatItemUsedByDirMask = (UInt32)1 << 31;
+
+struct CHeader
+{
+ UInt32 NumSectors;
+ UInt16 NumReservedSectors;
+ Byte NumFats;
+ UInt32 NumFatSectors;
+ UInt32 RootDirSector;
+ UInt32 NumRootDirSectors;
+ UInt32 DataSector;
+
+ UInt32 FatSize;
+ UInt32 BadCluster;
+
+ Byte NumFatBits;
+ Byte SectorSizeLog;
+ Byte SectorsPerClusterLog;
+ Byte ClusterSizeLog;
+
+ UInt16 SectorsPerTrack;
+ UInt16 NumHeads;
+ UInt32 NumHiddenSectors;
+
+ bool VolFieldsDefined;
+
+ UInt32 VolId;
+ // Byte VolName[11];
+ // Byte FileSys[8];
+
+ // Byte OemName[5];
+ Byte MediaType;
+
+ // 32-bit FAT
+ UInt16 Flags;
+ UInt16 FsInfoSector;
+ UInt32 RootCluster;
+
+ bool IsFat32() const { return NumFatBits == 32; }
+ UInt64 GetPhySize() const { return (UInt64)NumSectors << SectorSizeLog; }
+ UInt32 SectorSize() const { return (UInt32)1 << SectorSizeLog; }
+ UInt32 ClusterSize() const { return (UInt32)1 << ClusterSizeLog; }
+ UInt32 ClusterToSector(UInt32 c) const { return DataSector + ((c - 2) << SectorsPerClusterLog); }
+ UInt32 IsEoc(UInt32 c) const { return c > BadCluster; }
+ UInt32 IsEocAndUnused(UInt32 c) const { return c > BadCluster && (c & kFatItemUsedByDirMask) == 0; }
+ UInt32 IsValidCluster(UInt32 c) const { return c >= 2 && c < FatSize; }
+ UInt32 SizeToSectors(UInt32 size) const { return (size + SectorSize() - 1) >> SectorSizeLog; }
+ UInt32 CalcFatSizeInSectors() const { return SizeToSectors((FatSize * (NumFatBits / 4) + 1) / 2); }
+
+ UInt32 GetFatSector() const
+ {
+ UInt32 index = (IsFat32() && (Flags & 0x80) != 0) ? (Flags & 0xF) : 0;
+ if (index > NumFats)
+ index = 0;
+ return NumReservedSectors + index * NumFatSectors;
+ }
+
+ UInt64 GetFilePackSize(UInt32 unpackSize) const
+ {
+ UInt64 mask = ClusterSize() - 1;
+ return (unpackSize + mask) & ~mask;
+ }
+
+ UInt32 GetNumClusters(UInt32 size) const
+ { return (UInt32)(((UInt64)size + ClusterSize() - 1) >> ClusterSizeLog); }
+
+ bool Parse(const Byte *p);
+};
+
+static int GetLog(UInt32 num)
+{
+ for (int i = 0; i < 31; i++)
+ if (((UInt32)1 << i) == num)
+ return i;
+ return -1;
+}
+
+static const UInt32 kHeaderSize = 512;
+
+API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size);
+API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size)
+{
+ if (size < kHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ CHeader h;
+ return h.Parse(p) ? k_IsArc_Res_YES : k_IsArc_Res_NO;
+}
+
+bool CHeader::Parse(const Byte *p)
+{
+ if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+ return false;
+
+ int codeOffset = 0;
+ switch (p[0])
+ {
+ case 0xE9: codeOffset = 3 + (Int16)Get16(p + 1); break;
+ case 0xEB: if (p[2] != 0x90) return false; codeOffset = 2 + (signed char)p[1]; break;
+ default: return false;
+ }
+ {
+ {
+ const UInt32 val32 = Get16(p + 11);
+ const int s = GetLog(val32);
+ if (s < 9 || s > 12)
+ return false;
+ SectorSizeLog = (Byte)s;
+ }
+ {
+ const UInt32 val32 = p[13];
+ const int s = GetLog(val32);
+ if (s < 0)
+ return false;
+ SectorsPerClusterLog = (Byte)s;
+ }
+ ClusterSizeLog = (Byte)(SectorSizeLog + SectorsPerClusterLog);
+ if (ClusterSizeLog > 24)
+ return false;
+ }
+
+ NumReservedSectors = Get16(p + 14);
+ if (NumReservedSectors == 0)
+ return false;
+
+ NumFats = p[16];
+ if (NumFats < 1 || NumFats > 4)
+ return false;
+
+ // we also support images that contain 0 in offset field.
+ const bool isOkOffset = (codeOffset == 0)
+ || (codeOffset == (p[0] == 0xEB ? 2 : 3));
+
+ const UInt16 numRootDirEntries = Get16(p + 17);
+ if (numRootDirEntries == 0)
+ {
+ if (codeOffset < 90 && !isOkOffset)
+ return false;
+ NumFatBits = 32;
+ NumRootDirSectors = 0;
+ }
+ else
+ {
+ // Some FAT12s don't contain VolFields
+ if (codeOffset < 62 - 24 && !isOkOffset)
+ return false;
+ NumFatBits = 0;
+ const UInt32 mask = (1 << (SectorSizeLog - 5)) - 1;
+ if ((numRootDirEntries & mask) != 0)
+ return false;
+ NumRootDirSectors = (numRootDirEntries + mask) >> (SectorSizeLog - 5);
+ }
+
+ NumSectors = Get16(p + 19);
+ if (NumSectors == 0)
+ NumSectors = Get32(p + 32);
+ /*
+ // mkfs.fat could create fat32 image with 16-bit number of sectors.
+ // v23: we allow 16-bit value for number of sectors in fat32.
+ else if (IsFat32())
+ return false;
+ */
+
+ MediaType = p[21];
+ NumFatSectors = Get16(p + 22);
+ SectorsPerTrack = Get16(p + 24);
+ NumHeads = Get16(p + 26);
+ NumHiddenSectors = Get32(p + 28);
+
+ // memcpy(OemName, p + 3, 5);
+
+ int curOffset = 36;
+ p += 36;
+ if (IsFat32())
+ {
+ if (NumFatSectors != 0)
+ return false;
+ NumFatSectors = Get32(p);
+ if (NumFatSectors >= (1 << 24))
+ return false;
+
+ Flags = Get16(p + 4);
+ if (Get16(p + 6) != 0)
+ return false;
+ RootCluster = Get32(p + 8);
+ FsInfoSector = Get16(p + 12);
+ for (int i = 16; i < 28; i++)
+ if (p[i] != 0)
+ return false;
+ p += 28;
+ curOffset += 28;
+ }
+
+ // DriveNumber = p[0];
+ VolFieldsDefined = false;
+ if (codeOffset >= curOffset + 3)
+ {
+ VolFieldsDefined = (p[2] == 0x29); // ExtendedBootSig
+ if (VolFieldsDefined)
+ {
+ if (codeOffset < curOffset + 26)
+ return false;
+ VolId = Get32(p + 3);
+ // memcpy(VolName, p + 7, 11);
+ // memcpy(FileSys, p + 18, 8);
+ }
+ }
+
+ if (NumFatSectors == 0)
+ return false;
+ RootDirSector = NumReservedSectors + NumFatSectors * NumFats;
+ DataSector = RootDirSector + NumRootDirSectors;
+ if (NumSectors < DataSector)
+ return false;
+ const UInt32 numDataSectors = NumSectors - DataSector;
+ const UInt32 numClusters = numDataSectors >> SectorsPerClusterLog;
+
+ BadCluster = 0x0FFFFFF7;
+ // v23: we support unusual (< 0xFFF5) numClusters values in fat32 systems
+ if (NumFatBits != 32)
+ {
+ if (numClusters >= 0xFFF5)
+ return false;
+ NumFatBits = (Byte)(numClusters < 0xFF5 ? 12 : 16);
+ BadCluster &= ((1 << NumFatBits) - 1);
+ }
+
+ FatSize = numClusters + 2;
+ if (FatSize > BadCluster || CalcFatSizeInSectors() > NumFatSectors)
+ return false;
+ return true;
+}
+
+struct CItem
+{
+ UString UName;
+ char DosName[11];
+ Byte CTime2;
+ UInt32 CTime;
+ UInt32 MTime;
+ UInt16 ADate;
+ Byte Attrib;
+ Byte Flags;
+ UInt32 Size;
+ UInt32 Cluster;
+ Int32 Parent;
+
+ // NT uses Flags to store Low Case status
+ bool NameIsLow() const { return (Flags & 0x8) != 0; }
+ bool ExtIsLow() const { return (Flags & 0x10) != 0; }
+ bool IsDir() const { return (Attrib & 0x10) != 0; }
+ UString GetShortName() const;
+ UString GetName() const;
+ UString GetVolName() const;
+};
+
+static unsigned CopyAndTrim(char *dest, const char *src, unsigned size, bool toLower)
+{
+ memcpy(dest, src, size);
+ if (toLower)
+ {
+ for (unsigned i = 0; i < size; i++)
+ {
+ char c = dest[i];
+ if (c >= 'A' && c <= 'Z')
+ dest[i] = (char)(c + 0x20);
+ }
+ }
+
+ for (unsigned i = size;;)
+ {
+ if (i == 0)
+ return 0;
+ if (dest[i - 1] != ' ')
+ return i;
+ i--;
+ }
+}
+
+static UString FatStringToUnicode(const char *s)
+{
+ return MultiByteToUnicodeString(s, CP_OEMCP);
+}
+
+UString CItem::GetShortName() const
+{
+ char s[16];
+ unsigned i = CopyAndTrim(s, DosName, 8, NameIsLow());
+ s[i++] = '.';
+ unsigned j = CopyAndTrim(s + i, DosName + 8, 3, ExtIsLow());
+ if (j == 0)
+ i--;
+ s[i + j] = 0;
+ return FatStringToUnicode(s);
+}
+
+UString CItem::GetName() const
+{
+ if (!UName.IsEmpty())
+ return UName;
+ return GetShortName();
+}
+
+UString CItem::GetVolName() const
+{
+ if (!UName.IsEmpty())
+ return UName;
+ char s[12];
+ unsigned i = CopyAndTrim(s, DosName, 11, false);
+ s[i] = 0;
+ return FatStringToUnicode(s);
+}
+
+struct CDatabase
+{
+ CHeader Header;
+ CObjectVector<CItem> Items;
+ UInt32 *Fat;
+ CMyComPtr<IInStream> InStream;
+ IArchiveOpenCallback *OpenCallback;
+
+ UInt32 NumFreeClusters;
+ bool VolItemDefined;
+ CItem VolItem;
+ UInt32 NumDirClusters;
+ CByteBuffer ByteBuf;
+ UInt64 NumCurUsedBytes;
+
+ UInt64 PhySize;
+
+ CDatabase(): Fat(NULL) {}
+ ~CDatabase() { ClearAndClose(); }
+
+ void Clear();
+ void ClearAndClose();
+ HRESULT OpenProgressFat(bool changeTotal = true);
+ HRESULT OpenProgress();
+
+ UString GetItemPath(UInt32 index) const;
+ HRESULT Open();
+ HRESULT ReadDir(Int32 parent, UInt32 cluster, unsigned level);
+
+ UInt64 GetHeadersSize() const
+ {
+ return (UInt64)(Header.DataSector + (NumDirClusters << Header.SectorsPerClusterLog)) << Header.SectorSizeLog;
+ }
+ HRESULT SeekToSector(UInt32 sector);
+ HRESULT SeekToCluster(UInt32 cluster) { return SeekToSector(Header.ClusterToSector(cluster)); }
+};
+
+HRESULT CDatabase::SeekToSector(UInt32 sector)
+{
+ return InStream_SeekSet(InStream, (UInt64)sector << Header.SectorSizeLog);
+}
+
+void CDatabase::Clear()
+{
+ PhySize = 0;
+ VolItemDefined = false;
+ NumDirClusters = 0;
+ NumCurUsedBytes = 0;
+
+ Items.Clear();
+ delete []Fat;
+ Fat = NULL;
+}
+
+void CDatabase::ClearAndClose()
+{
+ Clear();
+ InStream.Release();
+}
+
+HRESULT CDatabase::OpenProgressFat(bool changeTotal)
+{
+ if (!OpenCallback)
+ return S_OK;
+ if (changeTotal)
+ {
+ UInt64 numTotalBytes = (Header.CalcFatSizeInSectors() << Header.SectorSizeLog) +
+ ((UInt64)(Header.FatSize - NumFreeClusters) << Header.ClusterSizeLog);
+ RINOK(OpenCallback->SetTotal(NULL, &numTotalBytes))
+ }
+ return OpenCallback->SetCompleted(NULL, &NumCurUsedBytes);
+}
+
+HRESULT CDatabase::OpenProgress()
+{
+ if (!OpenCallback)
+ return S_OK;
+ UInt64 numItems = Items.Size();
+ return OpenCallback->SetCompleted(&numItems, &NumCurUsedBytes);
+}
+
+UString CDatabase::GetItemPath(UInt32 index) const
+{
+ const CItem *item = &Items[index];
+ UString name = item->GetName();
+ for (;;)
+ {
+ index = (UInt32)item->Parent;
+ if (item->Parent < 0)
+ return name;
+ item = &Items[index];
+ name.InsertAtFront(WCHAR_PATH_SEPARATOR);
+ if (item->UName.IsEmpty())
+ name.Insert(0, item->GetShortName());
+ else
+ name.Insert(0, item->UName);
+ }
+}
+
+static wchar_t *AddSubStringToName(wchar_t *dest, const Byte *p, unsigned numChars)
+{
+ for (unsigned i = 0; i < numChars; i++)
+ {
+ wchar_t c = Get16(p + i * 2);
+ if (c != 0 && c != 0xFFFF)
+ *dest++ = c;
+ }
+ *dest = 0;
+ return dest;
+}
+
+HRESULT CDatabase::ReadDir(Int32 parent, UInt32 cluster, unsigned level)
+{
+ unsigned startIndex = Items.Size();
+ if (startIndex >= (1 << 30) || level > 256)
+ return S_FALSE;
+
+ UInt32 sectorIndex = 0;
+ UInt32 blockSize = Header.ClusterSize();
+ bool clusterMode = (Header.IsFat32() || parent >= 0);
+ if (!clusterMode)
+ {
+ blockSize = Header.SectorSize();
+ RINOK(SeekToSector(Header.RootDirSector))
+ }
+
+ ByteBuf.Alloc(blockSize);
+ UString curName;
+ int checkSum = -1;
+ int numLongRecords = -1;
+
+ for (UInt32 pos = blockSize;; pos += 32)
+ {
+ if (pos == blockSize)
+ {
+ pos = 0;
+
+ if ((NumDirClusters & 0xFF) == 0)
+ {
+ RINOK(OpenProgress())
+ }
+
+ if (clusterMode)
+ {
+ if (Header.IsEoc(cluster))
+ break;
+ if (!Header.IsValidCluster(cluster))
+ return S_FALSE;
+ PRF(printf("\nCluster = %4X", cluster));
+ RINOK(SeekToCluster(cluster))
+ UInt32 newCluster = Fat[cluster];
+ if ((newCluster & kFatItemUsedByDirMask) != 0)
+ return S_FALSE;
+ Fat[cluster] |= kFatItemUsedByDirMask;
+ cluster = newCluster;
+ NumDirClusters++;
+ NumCurUsedBytes += Header.ClusterSize();
+ }
+ else if (sectorIndex++ >= Header.NumRootDirSectors)
+ break;
+
+ RINOK(ReadStream_FALSE(InStream, ByteBuf, blockSize))
+ }
+
+ const Byte *p = ByteBuf + pos;
+
+ if (p[0] == 0)
+ {
+ /*
+ // FreeDOS formats FAT partition with cluster chain longer than required.
+ if (clusterMode && !Header.IsEoc(cluster))
+ return S_FALSE;
+ */
+ break;
+ }
+
+ if (p[0] == 0xE5)
+ {
+ if (numLongRecords > 0)
+ return S_FALSE;
+ continue;
+ }
+
+ Byte attrib = p[11];
+ if ((attrib & 0x3F) == 0xF)
+ {
+ if (p[0] > 0x7F || Get16(p + 26) != 0)
+ return S_FALSE;
+ int longIndex = p[0] & 0x3F;
+ if (longIndex == 0)
+ return S_FALSE;
+ bool isLast = (p[0] & 0x40) != 0;
+ if (numLongRecords < 0)
+ {
+ if (!isLast)
+ return S_FALSE;
+ numLongRecords = longIndex;
+ }
+ else if (isLast || numLongRecords != longIndex)
+ return S_FALSE;
+
+ numLongRecords--;
+
+ if (p[12] == 0)
+ {
+ wchar_t nameBuf[14];
+ wchar_t *dest;
+
+ dest = AddSubStringToName(nameBuf, p + 1, 5);
+ dest = AddSubStringToName(dest, p + 14, 6);
+ AddSubStringToName(dest, p + 28, 2);
+ curName = nameBuf + curName;
+ if (isLast)
+ checkSum = p[13];
+ if (checkSum != p[13])
+ return S_FALSE;
+ }
+ }
+ else
+ {
+ if (numLongRecords > 0)
+ return S_FALSE;
+ CItem item;
+ memcpy(item.DosName, p, 11);
+
+ if (checkSum >= 0)
+ {
+ Byte sum = 0;
+ for (unsigned i = 0; i < 11; i++)
+ sum = (Byte)(((sum & 1) ? 0x80 : 0) + (sum >> 1) + (Byte)item.DosName[i]);
+ if (sum == checkSum)
+ item.UName = curName;
+ }
+
+ if (item.DosName[0] == 5)
+ item.DosName[0] = (char)(Byte)0xE5;
+ item.Attrib = attrib;
+ item.Flags = p[12];
+ item.Size = Get32(p + 28);
+ item.Cluster = Get16(p + 26);
+ if (Header.NumFatBits > 16)
+ item.Cluster |= ((UInt32)Get16(p + 20) << 16);
+ else
+ {
+ // OS/2 and WinNT probably can store EA (extended atributes) in that field.
+ }
+
+ item.CTime = Get32(p + 14);
+ item.CTime2 = p[13];
+ item.ADate = Get16(p + 18);
+ item.MTime = Get32(p + 22);
+ item.Parent = parent;
+
+ if (attrib == 8)
+ {
+ VolItem = item;
+ VolItemDefined = true;
+ }
+ else
+ if (memcmp(item.DosName, ". ", 11) != 0 &&
+ memcmp(item.DosName, ".. ", 11) != 0)
+ {
+ if (!item.IsDir())
+ NumCurUsedBytes += Header.GetFilePackSize(item.Size);
+ Items.Add(item);
+ PRF(printf("\n%7d: %S", Items.Size(), GetItemPath(Items.Size() - 1)));
+ }
+ numLongRecords = -1;
+ curName.Empty();
+ checkSum = -1;
+ }
+ }
+
+ unsigned finishIndex = Items.Size();
+ for (unsigned i = startIndex; i < finishIndex; i++)
+ {
+ const CItem &item = Items[i];
+ if (item.IsDir())
+ {
+ PRF(printf("\n%S", GetItemPath(i)));
+ RINOK(CDatabase::ReadDir((int)i, item.Cluster, level + 1))
+ }
+ }
+ return S_OK;
+}
+
+HRESULT CDatabase::Open()
+{
+ Clear();
+ bool numFreeClustersDefined = false;
+ {
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(InStream, buf, kHeaderSize))
+ if (!Header.Parse(buf))
+ return S_FALSE;
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(InStream, fileSize))
+
+ /* we comment that check to support truncated images */
+ /*
+ if (fileSize < Header.GetPhySize())
+ return S_FALSE;
+ */
+
+ if (Header.IsFat32())
+ {
+ SeekToSector(Header.FsInfoSector);
+ RINOK(ReadStream_FALSE(InStream, buf, kHeaderSize))
+ if (buf[0x1FE] != 0x55 || buf[0x1FF] != 0xAA)
+ return S_FALSE;
+ if (Get32(buf) == 0x41615252 && Get32(buf + 484) == 0x61417272)
+ {
+ NumFreeClusters = Get32(buf + 488);
+ numFreeClustersDefined = (NumFreeClusters <= Header.FatSize);
+ }
+ }
+ }
+
+ // numFreeClustersDefined = false; // to recalculate NumFreeClusters
+ if (!numFreeClustersDefined)
+ NumFreeClusters = 0;
+
+ CByteBuffer byteBuf;
+ Fat = new UInt32[Header.FatSize];
+
+ RINOK(OpenProgressFat())
+ RINOK(SeekToSector(Header.GetFatSector()))
+ if (Header.NumFatBits == 32)
+ {
+ const UInt32 kBufSize = (1 << 15);
+ byteBuf.Alloc(kBufSize);
+ for (UInt32 i = 0; i < Header.FatSize;)
+ {
+ UInt32 size = Header.FatSize - i;
+ const UInt32 kBufSize32 = kBufSize / 4;
+ if (size > kBufSize32)
+ size = kBufSize32;
+ UInt32 readSize = Header.SizeToSectors(size * 4) << Header.SectorSizeLog;
+ RINOK(ReadStream_FALSE(InStream, byteBuf, readSize))
+ NumCurUsedBytes += readSize;
+
+ const UInt32 *src = (const UInt32 *)(const void *)(const Byte *)byteBuf;
+ UInt32 *dest = Fat + i;
+ if (numFreeClustersDefined)
+ for (UInt32 j = 0; j < size; j++)
+ dest[j] = Get32(src + j) & 0x0FFFFFFF;
+ else
+ {
+ UInt32 numFreeClusters = 0;
+ for (UInt32 j = 0; j < size; j++)
+ {
+ UInt32 v = Get32(src + j) & 0x0FFFFFFF;
+ numFreeClusters += (UInt32)(v - 1) >> 31;
+ dest[j] = v;
+ }
+ NumFreeClusters += numFreeClusters;
+ }
+ i += size;
+ if ((i & 0xFFFFF) == 0)
+ {
+ RINOK(OpenProgressFat(!numFreeClustersDefined))
+ }
+ }
+ }
+ else
+ {
+ const UInt32 kBufSize = (UInt32)Header.CalcFatSizeInSectors() << Header.SectorSizeLog;
+ NumCurUsedBytes += kBufSize;
+ byteBuf.Alloc(kBufSize);
+ Byte *p = byteBuf;
+ RINOK(ReadStream_FALSE(InStream, p, kBufSize))
+ UInt32 fatSize = Header.FatSize;
+ UInt32 *fat = &Fat[0];
+ if (Header.NumFatBits == 16)
+ for (UInt32 j = 0; j < fatSize; j++)
+ fat[j] = Get16(p + j * 2);
+ else
+ for (UInt32 j = 0; j < fatSize; j++)
+ fat[j] = (Get16(p + j * 3 / 2) >> ((j & 1) << 2)) & 0xFFF;
+
+ if (!numFreeClustersDefined)
+ {
+ UInt32 numFreeClusters = 0;
+ for (UInt32 i = 0; i < fatSize; i++)
+ numFreeClusters += (UInt32)(fat[i] - 1) >> 31;
+ NumFreeClusters = numFreeClusters;
+ }
+ }
+
+ RINOK(OpenProgressFat())
+
+ if ((Fat[0] & 0xFF) != Header.MediaType)
+ {
+ // that case can mean error in FAT,
+ // but xdf file: (MediaType == 0xF0 && Fat[0] == 0xFF9)
+ // 19.00: so we use non-strict check
+ if ((Fat[0] & 0xFF) < 0xF0)
+ return S_FALSE;
+ }
+
+ RINOK(ReadDir(-1, Header.RootCluster, 0))
+
+ PhySize = Header.GetPhySize();
+ return S_OK;
+}
+
+
+
+Z7_class_CHandler_final:
+ public IInArchive,
+ public IInArchiveGetStream,
+ public CMyUnknownImp,
+ CDatabase
+{
+ Z7_IFACES_IMP_UNK_2(IInArchive, IInArchiveGetStream)
+};
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ const CItem &item = Items[index];
+ CClusterInStream *streamSpec = new CClusterInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->Stream = InStream;
+ streamSpec->StartOffset = Header.DataSector << Header.SectorSizeLog;
+ streamSpec->BlockSizeLog = Header.ClusterSizeLog;
+ streamSpec->Size = item.Size;
+
+ UInt32 numClusters = Header.GetNumClusters(item.Size);
+ streamSpec->Vector.ClearAndReserve(numClusters);
+ UInt32 cluster = item.Cluster;
+ UInt32 size = item.Size;
+
+ if (size == 0)
+ {
+ if (cluster != 0)
+ return S_FALSE;
+ }
+ else
+ {
+ UInt32 clusterSize = Header.ClusterSize();
+ for (;; size -= clusterSize)
+ {
+ if (!Header.IsValidCluster(cluster))
+ return S_FALSE;
+ streamSpec->Vector.AddInReserved(cluster - 2);
+ cluster = Fat[cluster];
+ if (size <= clusterSize)
+ break;
+ }
+ if (!Header.IsEocAndUnused(cluster))
+ return S_FALSE;
+ }
+ RINOK(streamSpec->InitAndSeek())
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidAttrib,
+ kpidShortName
+};
+
+enum
+{
+ kpidNumFats = kpidUserDefined
+ // kpidOemName,
+ // kpidVolName,
+ // kpidFileSysType
+};
+
+static const CStatProp kArcProps[] =
+{
+ { NULL, kpidFileSystem, VT_BSTR},
+ { NULL, kpidClusterSize, VT_UI4},
+ { NULL, kpidFreeSpace, VT_UI8},
+ { NULL, kpidHeadersSize, VT_UI8},
+ { NULL, kpidMTime, VT_FILETIME},
+ { NULL, kpidVolumeName, VT_BSTR},
+
+ { "FATs", kpidNumFats, VT_UI4},
+ { NULL, kpidSectorSize, VT_UI4},
+ { NULL, kpidId, VT_UI4},
+ // { "OEM Name", kpidOemName, VT_BSTR},
+ // { "Volume Name", kpidVolName, VT_BSTR},
+ // { "File System Type", kpidFileSysType, VT_BSTR}
+ // { NULL, kpidSectorsPerTrack, VT_UI4},
+ // { NULL, kpidNumHeads, VT_UI4},
+ // { NULL, kpidHiddenSectors, VT_UI4}
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+
+static void FatTimeToProp(UInt32 dosTime, UInt32 ms10, NWindows::NCOM::CPropVariant &prop)
+{
+ FILETIME localFileTime, utc;
+ if (NWindows::NTime::DosTime_To_FileTime(dosTime, localFileTime))
+ if (LocalFileTimeToFileTime(&localFileTime, &utc))
+ {
+ UInt64 t64 = (((UInt64)utc.dwHighDateTime) << 32) + utc.dwLowDateTime;
+ t64 += ms10 * 100000;
+ utc.dwLowDateTime = (DWORD)t64;
+ utc.dwHighDateTime = (DWORD)(t64 >> 32);
+ prop.SetAsTimeFrom_FT_Prec(utc, k_PropVar_TimePrec_Base + 2);
+ }
+}
+
+/*
+static void StringToProp(const Byte *src, unsigned size, NWindows::NCOM::CPropVariant &prop)
+{
+ char dest[32];
+ memcpy(dest, src, size);
+ dest[size] = 0;
+ prop = FatStringToUnicode(dest);
+}
+
+#define STRING_TO_PROP(s, p) StringToProp(s, sizeof(s), prop)
+*/
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidFileSystem:
+ {
+ char s[16];
+ s[0] = 'F';
+ s[1] = 'A';
+ s[2] = 'T';
+ ConvertUInt32ToString(Header.NumFatBits, s + 3);
+ prop = s;
+ break;
+ }
+ case kpidClusterSize: prop = Header.ClusterSize(); break;
+ case kpidPhySize: prop = PhySize; break;
+ case kpidFreeSpace: prop = (UInt64)NumFreeClusters << Header.ClusterSizeLog; break;
+ case kpidHeadersSize: prop = GetHeadersSize(); break;
+ case kpidMTime: if (VolItemDefined) PropVariant_SetFrom_DosTime(prop, VolItem.MTime); break;
+ case kpidShortComment:
+ case kpidVolumeName: if (VolItemDefined) prop = VolItem.GetVolName(); break;
+ case kpidNumFats: if (Header.NumFats != 2) prop = Header.NumFats; break;
+ case kpidSectorSize: prop = (UInt32)1 << Header.SectorSizeLog; break;
+ // case kpidSectorsPerTrack: prop = Header.SectorsPerTrack; break;
+ // case kpidNumHeads: prop = Header.NumHeads; break;
+ // case kpidOemName: STRING_TO_PROP(Header.OemName, prop); break;
+ case kpidId: if (Header.VolFieldsDefined) prop = Header.VolId; break;
+ // case kpidVolName: if (Header.VolFieldsDefined) STRING_TO_PROP(Header.VolName, prop); break;
+ // case kpidFileSysType: if (Header.VolFieldsDefined) STRING_TO_PROP(Header.FileSys, prop); break;
+ // case kpidHiddenSectors: prop = Header.NumHiddenSectors; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CItem &item = Items[index];
+ switch (propID)
+ {
+ case kpidPath: prop = GetItemPath(index); break;
+ case kpidShortName: prop = item.GetShortName(); break;
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidMTime: PropVariant_SetFrom_DosTime(prop, item.MTime); break;
+ case kpidCTime: FatTimeToProp(item.CTime, item.CTime2, prop); break;
+ case kpidATime: PropVariant_SetFrom_DosTime(prop, ((UInt32)item.ADate << 16)); break;
+ case kpidAttrib: prop = (UInt32)item.Attrib; break;
+ case kpidSize: if (!item.IsDir()) prop = item.Size; break;
+ case kpidPackSize: if (!item.IsDir()) prop = Header.GetFilePackSize(item.Size); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ OpenCallback = callback;
+ InStream = stream;
+ HRESULT res;
+ try
+ {
+ res = CDatabase::Open();
+ if (res == S_OK)
+ return S_OK;
+ }
+ catch(...)
+ {
+ Close();
+ throw;
+ }
+ Close();
+ return res;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ ClearAndClose();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = Items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt32 i;
+ UInt64 totalSize = 0;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItem &item = Items[allFilesMode ? i : indices[i]];
+ if (!item.IsDir())
+ totalSize += item.Size;
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+
+ for (i = 0;; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ if (i == numItems)
+ break;
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = Items[index];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (item.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ totalPackSize += Header.GetFilePackSize(item.Size);
+ totalSize += item.Size;
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ outStreamSpec->SetStream(realOutStream);
+ realOutStream.Release();
+ outStreamSpec->Init();
+
+ int res = NExtract::NOperationResult::kDataError;
+ CMyComPtr<ISequentialInStream> inStream;
+ HRESULT hres = GetStream(index, &inStream);
+ if (hres != S_FALSE)
+ {
+ RINOK(hres)
+ if (inStream)
+ {
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize == item.Size)
+ res = NExtract::NOperationResult::kOK;
+ }
+ }
+ outStreamSpec->ReleaseStream();
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = Items.Size();
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { 0x55, 0xAA };
+
+REGISTER_ARC_I(
+ "FAT", "fat img", NULL, 0xDA,
+ k_Signature,
+ 0x1FE,
+ 0,
+ IsArc_Fat)
+
+}}
diff --git a/CPP/7zip/Archive/FlvHandler.cpp b/CPP/7zip/Archive/FlvHandler.cpp
new file mode 100644
index 0000000..1f746aa
--- /dev/null
+++ b/CPP/7zip/Archive/FlvHandler.cpp
@@ -0,0 +1,521 @@
+// FlvHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/InBuffer.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#define GetBe24(p) ( \
+ ((UInt32)((const Byte *)(p))[0] << 16) | \
+ ((UInt32)((const Byte *)(p))[1] << 8) | \
+ ((const Byte *)(p))[2] )
+
+// #define Get16(p) GetBe16(p)
+#define Get24(p) GetBe24(p)
+#define Get32(p) GetBe32(p)
+
+namespace NArchive {
+namespace NFlv {
+
+// static const UInt32 kFileSizeMax = (UInt32)1 << 30;
+static const UInt32 kNumChunksMax = (UInt32)1 << 23;
+
+static const UInt32 kTagHeaderSize = 11;
+
+static const Byte kFlag_Video = 1;
+static const Byte kFlag_Audio = 4;
+
+static const Byte kType_Audio = 8;
+static const Byte kType_Video = 9;
+static const Byte kType_Meta = 18;
+static const unsigned kNumTypes = 19;
+
+struct CItem
+{
+ CByteBuffer Data;
+ Byte Type;
+};
+
+struct CItem2
+{
+ Byte Type;
+ Byte SubType;
+ Byte Props;
+ bool SameSubTypes;
+ unsigned NumChunks;
+ size_t Size;
+
+ CReferenceBuf *BufSpec;
+ CMyComPtr<IUnknown> RefBuf;
+
+ bool IsAudio() const { return Type == kType_Audio; }
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CMyComPtr<IInStream> _stream;
+ CObjectVector<CItem2> _items2;
+ CByteBuffer _metadata;
+ bool _isRaw;
+ UInt64 _phySize;
+
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *callback);
+ // AString GetComment();
+};
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidNumBlocks,
+ kpidComment
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+static const char * const g_AudioTypes[16] =
+{
+ "pcm"
+ , "adpcm"
+ , "mp3"
+ , "pcm_le"
+ , "nellymoser16"
+ , "nellymoser8"
+ , "nellymoser"
+ , "g711a"
+ , "g711m"
+ , "audio9"
+ , "aac"
+ , "speex"
+ , "audio12"
+ , "audio13"
+ , "mp3"
+ , "audio15"
+};
+
+static const char * const g_VideoTypes[16] =
+{
+ "video0"
+ , "jpeg"
+ , "h263"
+ , "screen"
+ , "vp6"
+ , "vp6alpha"
+ , "screen2"
+ , "avc"
+ , "video8"
+ , "video9"
+ , "video10"
+ , "video11"
+ , "video12"
+ , "video13"
+ , "video14"
+ , "video15"
+};
+
+static const char * const g_Rates[4] =
+{
+ "5.5 kHz"
+ , "11 kHz"
+ , "22 kHz"
+ , "44 kHz"
+};
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ const CItem2 &item = _items2[index];
+ switch (propID)
+ {
+ case kpidExtension:
+ prop = _isRaw ?
+ (item.IsAudio() ? g_AudioTypes[item.SubType] : g_VideoTypes[item.SubType]) :
+ (item.IsAudio() ? "audio.flv" : "video.flv");
+ break;
+ case kpidSize:
+ case kpidPackSize:
+ prop = (UInt64)item.Size;
+ break;
+ case kpidNumBlocks: prop = (UInt32)item.NumChunks; break;
+ case kpidComment:
+ {
+ char sz[64];
+ char *s = MyStpCpy(sz, (item.IsAudio() ? g_AudioTypes[item.SubType] : g_VideoTypes[item.SubType]) );
+ if (item.IsAudio())
+ {
+ *s++ = ' ';
+ s = MyStpCpy(s, g_Rates[(item.Props >> 2) & 3]);
+ s = MyStpCpy(s, (item.Props & 2) ? " 16-bit" : " 8-bit");
+ s = MyStpCpy(s, (item.Props & 1) ? " stereo" : " mono");
+ }
+ prop = sz;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+/*
+AString CHandler::GetComment()
+{
+ const Byte *p = _metadata;
+ size_t size = _metadata.Size();
+ AString res;
+ if (size > 0)
+ {
+ p++;
+ size--;
+ for (;;)
+ {
+ if (size < 2)
+ break;
+ int len = Get16(p);
+ p += 2;
+ size -= 2;
+ if (len == 0 || (size_t)len > size)
+ break;
+ {
+ AString temp;
+ temp.SetFrom_CalcLen((const char *)p, len);
+ if (!res.IsEmpty())
+ res += '\n';
+ res += temp;
+ }
+ p += len;
+ size -= len;
+ if (size < 1)
+ break;
+ Byte type = *p++;
+ size--;
+ bool ok = false;
+ switch (type)
+ {
+ case 0:
+ {
+ if (size < 8)
+ break;
+ ok = true;
+ Byte reverse[8];
+ for (int i = 0; i < 8; i++)
+ {
+ bool little_endian = 1;
+ if (little_endian)
+ reverse[i] = p[7 - i];
+ else
+ reverse[i] = p[i];
+ }
+ double d = *(double *)reverse;
+ char temp[32];
+ sprintf(temp, " = %.3f", d);
+ res += temp;
+ p += 8;
+ size -= 8;
+ break;
+ }
+ case 8:
+ {
+ if (size < 4)
+ break;
+ ok = true;
+ // UInt32 numItems = Get32(p);
+ p += 4;
+ size -= 4;
+ break;
+ }
+ }
+ if (!ok)
+ break;
+ }
+ }
+ return res;
+}
+*/
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ // COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ // case kpidComment: prop = GetComment(); break;
+ case kpidPhySize: prop = (UInt64)_phySize; break;
+ case kpidIsNotArcType: prop = true; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ // COM_TRY_END
+}
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
+{
+ const UInt32 kHeaderSize = 13;
+ Byte header[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, header, kHeaderSize))
+ if (header[0] != 'F' ||
+ header[1] != 'L' ||
+ header[2] != 'V' ||
+ header[3] != 1 ||
+ (header[4] & 0xFA) != 0)
+ return S_FALSE;
+ UInt64 offset = Get32(header + 5);
+ if (offset != 9 || Get32(header + 9) != 0)
+ return S_FALSE;
+ offset = kHeaderSize;
+
+ CInBuffer inBuf;
+ if (!inBuf.Create(1 << 15))
+ return E_OUTOFMEMORY;
+ inBuf.SetStream(stream);
+
+ CObjectVector<CItem> items;
+ int lasts[kNumTypes];
+ unsigned i;
+ for (i = 0; i < kNumTypes; i++)
+ lasts[i] = -1;
+
+ _phySize = offset;
+ for (;;)
+ {
+ Byte buf[kTagHeaderSize];
+ CItem item;
+ if (inBuf.ReadBytes(buf, kTagHeaderSize) != kTagHeaderSize)
+ break;
+ item.Type = buf[0];
+ UInt32 size = Get24(buf + 1);
+ if (size < 1)
+ break;
+ // item.Time = Get24(buf + 4);
+ // item.Time |= (UInt32)buf[7] << 24;
+ if (Get24(buf + 8) != 0) // streamID
+ break;
+
+ UInt32 curSize = kTagHeaderSize + size + 4;
+ item.Data.Alloc(curSize);
+ memcpy(item.Data, buf, kTagHeaderSize);
+ if (inBuf.ReadBytes(item.Data + kTagHeaderSize, size) != size)
+ break;
+ if (inBuf.ReadBytes(item.Data + kTagHeaderSize + size, 4) != 4)
+ break;
+
+ if (Get32(item.Data + kTagHeaderSize + size) != kTagHeaderSize + size)
+ break;
+
+ offset += curSize;
+
+ // printf("\noffset = %6X type = %2d time = %6d size = %6d", (UInt32)offset, item.Type, item.Time, item.Size);
+
+ if (item.Type == kType_Meta)
+ {
+ // _metadata = item.Buf;
+ }
+ else
+ {
+ if (item.Type != kType_Audio && item.Type != kType_Video)
+ break;
+ if (items.Size() >= kNumChunksMax)
+ return S_FALSE;
+ Byte firstByte = item.Data[kTagHeaderSize];
+ Byte subType, props;
+ if (item.Type == kType_Audio)
+ {
+ subType = (Byte)(firstByte >> 4);
+ props = (Byte)(firstByte & 0xF);
+ }
+ else
+ {
+ subType = (Byte)(firstByte & 0xF);
+ props = (Byte)(firstByte >> 4);
+ }
+ int last = lasts[item.Type];
+ if (last < 0)
+ {
+ CItem2 item2;
+ item2.RefBuf = item2.BufSpec = new CReferenceBuf;
+ item2.Size = curSize;
+ item2.Type = item.Type;
+ item2.SubType = subType;
+ item2.Props = props;
+ item2.NumChunks = 1;
+ item2.SameSubTypes = true;
+ lasts[item.Type] = (int)_items2.Add(item2);
+ }
+ else
+ {
+ CItem2 &item2 = _items2[last];
+ if (subType != item2.SubType)
+ item2.SameSubTypes = false;
+ item2.Size += curSize;
+ item2.NumChunks++;
+ }
+ items.Add(item);
+ }
+ _phySize = offset;
+ if (callback && (items.Size() & 0xFF) == 0)
+ {
+ RINOK(callback->SetCompleted(NULL, &offset))
+ }
+ }
+ if (items.IsEmpty())
+ return S_FALSE;
+
+ _isRaw = (_items2.Size() == 1);
+ for (i = 0; i < _items2.Size(); i++)
+ {
+ CItem2 &item2 = _items2[i];
+ CByteBuffer &itemBuf = item2.BufSpec->Buf;
+ if (_isRaw)
+ {
+ if (!item2.SameSubTypes)
+ return S_FALSE;
+ itemBuf.Alloc((size_t)item2.Size - (size_t)(kTagHeaderSize + 4 + 1) * item2.NumChunks);
+ item2.Size = 0;
+ }
+ else
+ {
+ itemBuf.Alloc(kHeaderSize + (size_t)item2.Size);
+ memcpy(itemBuf, header, kHeaderSize);
+ itemBuf[4] = item2.IsAudio() ? kFlag_Audio : kFlag_Video;
+ item2.Size = kHeaderSize;
+ }
+ }
+
+ for (i = 0; i < items.Size(); i++)
+ {
+ const CItem &item = items[i];
+ CItem2 &item2 = _items2[lasts[item.Type]];
+ size_t size = item.Data.Size();
+ const Byte *src = item.Data;
+ if (_isRaw)
+ {
+ src += kTagHeaderSize + 1;
+ size -= (kTagHeaderSize + 4 + 1);
+ }
+ if (size != 0)
+ {
+ memcpy(item2.BufSpec->Buf + item2.Size, src, size);
+ item2.Size += size;
+ }
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+ HRESULT res;
+ try
+ {
+ res = Open2(inStream, callback);
+ if (res == S_OK)
+ _stream = inStream;
+ }
+ catch(...) { res = S_FALSE; }
+ if (res != S_OK)
+ {
+ Close();
+ return S_FALSE;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+ _stream.Release();
+ _items2.Clear();
+ // _metadata.SetCapacity(0);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items2.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items2.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _items2[allFilesMode ? i : indices[i]].Size;
+ extractCallback->SetTotal(totalSize);
+
+ totalSize = 0;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem2 &item = _items2[index];
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ totalSize += item.Size;
+ if (!testMode && !outStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (outStream)
+ {
+ RINOK(WriteStream(outStream, item.BufSpec->Buf, item.BufSpec->Buf.Size()))
+ }
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->Init(_items2[index].BufSpec);
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { 'F', 'L', 'V', 1, };
+
+REGISTER_ARC_I(
+ "FLV", "flv", NULL, 0xD6,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/GptHandler.cpp b/CPP/7zip/Archive/GptHandler.cpp
new file mode 100644
index 0000000..78c76cf
--- /dev/null
+++ b/CPP/7zip/Archive/GptHandler.cpp
@@ -0,0 +1,472 @@
+// GptHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+
+namespace NFat {
+API_FUNC_IsArc IsArc_Fat(const Byte *p, size_t size);
+}
+
+namespace NGpt {
+
+static const unsigned k_SignatureSize = 12;
+static const Byte k_Signature[k_SignatureSize] =
+ { 'E', 'F', 'I', ' ', 'P', 'A', 'R', 'T', 0, 0, 1, 0 };
+
+static const UInt32 kSectorSize = 512;
+
+static const CUInt32PCharPair g_PartitionFlags[] =
+{
+ { 0, "Sys" },
+ { 1, "Ignore" },
+ { 2, "Legacy" },
+ { 60, "Win-Read-only" },
+ { 62, "Win-Hidden" },
+ { 63, "Win-Not-Automount" }
+};
+
+static const unsigned kNameLen = 36;
+
+struct CPartition
+{
+ Byte Type[16];
+ Byte Id[16];
+ UInt64 FirstLba;
+ UInt64 LastLba;
+ UInt64 Flags;
+ const char *Ext; // detected later
+ Byte Name[kNameLen * 2];
+
+ bool IsUnused() const
+ {
+ for (unsigned i = 0; i < 16; i++)
+ if (Type[i] != 0)
+ return false;
+ return true;
+ }
+
+ UInt64 GetSize() const { return (LastLba - FirstLba + 1) * kSectorSize; }
+ UInt64 GetPos() const { return FirstLba * kSectorSize; }
+ UInt64 GetEnd() const { return (LastLba + 1) * kSectorSize; }
+
+ void Parse(const Byte *p)
+ {
+ memcpy(Type, p, 16);
+ memcpy(Id, p + 16, 16);
+ FirstLba = Get64(p + 32);
+ LastLba = Get64(p + 40);
+ Flags = Get64(p + 48);
+ memcpy(Name, p + 56, kNameLen * 2);
+ Ext = NULL;
+ }
+};
+
+
+struct CPartType
+{
+ UInt32 Id;
+ const char *Ext;
+ const char *Type;
+};
+
+static const CPartType kPartTypes[] =
+{
+ // { 0x0, NULL, "Unused" },
+
+ { 0x21686148, NULL, "BIOS Boot" },
+
+ { 0xC12A7328, NULL, "EFI System" },
+ { 0x024DEE41, NULL, "MBR" },
+
+ { 0xE3C9E316, NULL, "Windows MSR" },
+ { 0xEBD0A0A2, NULL, "Windows BDP" },
+ { 0x5808C8AA, NULL, "Windows LDM Metadata" },
+ { 0xAF9B60A0, NULL, "Windows LDM Data" },
+ { 0xDE94BBA4, NULL, "Windows Recovery" },
+ // { 0x37AFFC90, NULL, "IBM GPFS" },
+ // { 0xE75CAF8F, NULL, "Windows Storage Spaces" },
+
+ { 0x0FC63DAF, NULL, "Linux Data" },
+ { 0x0657FD6D, NULL, "Linux Swap" },
+
+ { 0x83BD6B9D, NULL, "FreeBSD Boot" },
+ { 0x516E7CB4, NULL, "FreeBSD Data" },
+ { 0x516E7CB5, NULL, "FreeBSD Swap" },
+ { 0x516E7CB6, "ufs", "FreeBSD UFS" },
+ { 0x516E7CB8, NULL, "FreeBSD Vinum" },
+ { 0x516E7CB8, "zfs", "FreeBSD ZFS" },
+
+ { 0x48465300, "hfsx", "HFS+" },
+ { 0x7C3457EF, "apfs", "APFS" },
+};
+
+static int FindPartType(const Byte *guid)
+{
+ const UInt32 val = Get32(guid);
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kPartTypes); i++)
+ if (kPartTypes[i].Id == val)
+ return (int)i;
+ return -1;
+}
+
+
+static void RawLeGuidToString_Upper(const Byte *g, char *s)
+{
+ RawLeGuidToString(g, s);
+ // MyStringUpper_Ascii(s);
+}
+
+
+Z7_class_CHandler_final: public CHandlerCont
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Cont)
+
+ CRecordVector<CPartition> _items;
+ UInt64 _totalSize;
+ Byte Guid[16];
+
+ CByteBuffer _buffer;
+
+ HRESULT Open2(IInStream *stream);
+
+ virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const Z7_override
+ {
+ const CPartition &item = _items[index];
+ pos = item.GetPos();
+ size = item.GetSize();
+ return NExtract::NOperationResult::kOK;
+ }
+};
+
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ _buffer.Alloc(kSectorSize * 2);
+ RINOK(ReadStream_FALSE(stream, _buffer, kSectorSize * 2))
+
+ const Byte *buf = _buffer;
+ if (buf[0x1FE] != 0x55 || buf[0x1FF] != 0xAA)
+ return S_FALSE;
+
+ buf += kSectorSize;
+ if (memcmp(buf, k_Signature, k_SignatureSize) != 0)
+ return S_FALSE;
+ {
+ // if (Get32(buf + 8) != 0x10000) return S_FALSE; // revision
+ UInt32 headerSize = Get32(buf + 12); // = 0x5C usually
+ if (headerSize > kSectorSize)
+ return S_FALSE;
+ UInt32 crc = Get32(buf + 0x10);
+ SetUi32(_buffer + kSectorSize + 0x10, 0)
+ if (CrcCalc(_buffer + kSectorSize, headerSize) != crc)
+ return S_FALSE;
+ }
+ // UInt32 reserved = Get32(buf + 0x14);
+ const UInt64 curLba = Get64(buf + 0x18);
+ if (curLba != 1)
+ return S_FALSE;
+ const UInt64 backupLba = Get64(buf + 0x20);
+ // UInt64 firstUsableLba = Get64(buf + 0x28);
+ // UInt64 lastUsableLba = Get64(buf + 0x30);
+ memcpy(Guid, buf + 0x38, 16);
+ const UInt64 tableLba = Get64(buf + 0x48);
+ if (tableLba < 2)
+ return S_FALSE;
+ const UInt32 numEntries = Get32(buf + 0x50);
+ const UInt32 entrySize = Get32(buf + 0x54); // = 128 usually
+ const UInt32 entriesCrc = Get32(buf + 0x58);
+
+ if (entrySize < 128
+ || entrySize > (1 << 12)
+ || numEntries > (1 << 16)
+ || tableLba < 2
+ || tableLba >= ((UInt64)1 << (64 - 10)))
+ return S_FALSE;
+
+ const UInt32 tableSize = entrySize * numEntries;
+ const UInt32 tableSizeAligned = (tableSize + kSectorSize - 1) & ~(kSectorSize - 1);
+ _buffer.Alloc(tableSizeAligned);
+ const UInt64 tableOffset = tableLba * kSectorSize;
+ RINOK(InStream_SeekSet(stream, tableOffset))
+ RINOK(ReadStream_FALSE(stream, _buffer, tableSizeAligned))
+
+ if (CrcCalc(_buffer, tableSize) != entriesCrc)
+ return S_FALSE;
+
+ _totalSize = tableOffset + tableSizeAligned;
+
+ for (UInt32 i = 0; i < numEntries; i++)
+ {
+ CPartition item;
+ item.Parse(_buffer + i * entrySize);
+ if (item.IsUnused())
+ continue;
+ UInt64 endPos = item.GetEnd();
+ if (_totalSize < endPos)
+ _totalSize = endPos;
+ _items.Add(item);
+ }
+
+ {
+ const UInt64 end = (backupLba + 1) * kSectorSize;
+ if (_totalSize < end)
+ _totalSize = end;
+ }
+
+ {
+ UInt64 fileEnd;
+ RINOK(InStream_GetSize_SeekToEnd(stream, fileEnd))
+
+ if (_totalSize < fileEnd)
+ {
+ const UInt64 rem = fileEnd - _totalSize;
+ const UInt64 kRemMax = 1 << 22;
+ if (rem <= kRemMax)
+ {
+ RINOK(InStream_SeekSet(stream, _totalSize))
+ bool areThereNonZeros = false;
+ UInt64 numZeros = 0;
+ if (ReadZeroTail(stream, areThereNonZeros, numZeros, kRemMax) == S_OK)
+ if (!areThereNonZeros)
+ _totalSize += numZeros;
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+static const unsigned k_Ntfs_Fat_HeaderSize = 512;
+
+static const Byte k_NtfsSignature[] = { 'N', 'T', 'F', 'S', ' ', ' ', ' ', ' ', 0 };
+
+static bool IsNtfs(const Byte *p)
+{
+ if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+ return false;
+ if (memcmp(p + 3, k_NtfsSignature, Z7_ARRAY_SIZE(k_NtfsSignature)) != 0)
+ return false;
+ switch (p[0])
+ {
+ case 0xE9: /* codeOffset = 3 + (Int16)Get16(p + 1); */ break;
+ case 0xEB: if (p[2] != 0x90) return false; /* codeOffset = 2 + (int)(signed char)p[1]; */ break;
+ default: return false;
+ }
+ return true;
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(Open2(stream))
+ _stream = stream;
+
+ FOR_VECTOR (fileIndex, _items)
+ {
+ CPartition &item = _items[fileIndex];
+ const int typeIndex = FindPartType(item.Type);
+ if (typeIndex < 0)
+ continue;
+ const CPartType &t = kPartTypes[(unsigned)typeIndex];
+ if (t.Ext)
+ {
+ item.Ext = t.Ext;
+ continue;
+ }
+ if (t.Type && IsString1PrefixedByString2_NoCase_Ascii(t.Type, "Windows"))
+ {
+ CMyComPtr<ISequentialInStream> inStream;
+ if (
+ // ((IInArchiveGetStream *)this)->
+ GetStream(fileIndex, &inStream) == S_OK && inStream)
+ {
+ Byte temp[k_Ntfs_Fat_HeaderSize];
+ if (ReadStream_FAIL(inStream, temp, k_Ntfs_Fat_HeaderSize) == S_OK)
+ {
+ if (IsNtfs(temp))
+ {
+ item.Ext = "ntfs";
+ continue;
+ }
+ if (NFat::IsArc_Fat(temp, k_Ntfs_Fat_HeaderSize) == k_IsArc_Res_YES)
+ {
+ item.Ext = "fat";
+ continue;
+ }
+ }
+ }
+ }
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ memset(Guid, 0, sizeof(Guid));
+ _items.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidFileSystem,
+ kpidCharacts,
+ kpidOffset,
+ kpidId
+};
+
+static const Byte kArcProps[] =
+{
+ kpidId
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile:
+ {
+ if (_items.Size() == 1)
+ prop = (UInt32)0;
+ break;
+ }
+ case kpidPhySize: prop = _totalSize; break;
+ case kpidId:
+ {
+ char s[48];
+ RawLeGuidToString_Upper(Guid, s);
+ prop = s;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CPartition &item = _items[index];
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ // Windows BDP partitions can have identical names.
+ // So we add the partition number at front
+ UString s;
+ s.Add_UInt32(index);
+ {
+ UString s2;
+ for (unsigned i = 0; i < kNameLen; i++)
+ {
+ wchar_t c = (wchar_t)Get16(item.Name + i * 2);
+ if (c == 0)
+ break;
+ s2 += c;
+ }
+ if (!s2.IsEmpty())
+ {
+ s.Add_Dot();
+ s += s2;
+ }
+ }
+ {
+ s.Add_Dot();
+ s += (item.Ext ? item.Ext : "img");
+ }
+ prop = s;
+ break;
+ }
+
+ case kpidSize:
+ case kpidPackSize: prop = item.GetSize(); break;
+ case kpidOffset: prop = item.GetPos(); break;
+
+ case kpidFileSystem:
+ {
+ char s[48];
+ const char *res;
+ const int typeIndex = FindPartType(item.Type);
+ if (typeIndex >= 0 && kPartTypes[(unsigned)typeIndex].Type)
+ res = kPartTypes[(unsigned)typeIndex].Type;
+ else
+ {
+ RawLeGuidToString_Upper(item.Type, s);
+ res = s;
+ }
+ prop = res;
+ break;
+ }
+
+ case kpidId:
+ {
+ char s[48];
+ RawLeGuidToString_Upper(item.Id, s);
+ prop = s;
+ break;
+ }
+
+ case kpidCharacts: FLAGS64_TO_PROP(g_PartitionFlags, item.Flags, prop); break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "GPT", "gpt mbr", NULL, 0xCB,
+ k_Signature,
+ kSectorSize,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/GzHandler.cpp b/CPP/7zip/Archive/GzHandler.cpp
new file mode 100644
index 0000000..ad9a074
--- /dev/null
+++ b/CPP/7zip/Archive/GzHandler.cpp
@@ -0,0 +1,1210 @@
+// GzHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/Defs.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/DeflateDecoder.h"
+#include "../Compress/DeflateEncoder.h"
+
+#include "Common/HandlerOut.h"
+#include "Common/InStreamWithCRC.h"
+#include "Common/OutStreamWithCRC.h"
+
+#define Get32(p) GetUi32(p)
+
+using namespace NWindows;
+
+using namespace NCompress;
+using namespace NDeflate;
+
+namespace NArchive {
+namespace NGz {
+
+ static const Byte kSignature_0 = 0x1F;
+ static const Byte kSignature_1 = 0x8B;
+ static const Byte kSignature_2 = 8; // NCompressionMethod::kDeflate
+
+ // Latest versions of gzip program don't write comment field to gz archive.
+ // We also don't write comment field to gz archive.
+
+ namespace NFlags
+ {
+ // const Byte kIsText = 1 << 0;
+ const Byte kCrc = 1 << 1;
+ const Byte kExtra = 1 << 2;
+ const Byte kName = 1 << 3;
+ const Byte kComment = 1 << 4;
+ const Byte kReserved = 0xE0;
+ }
+
+ namespace NExtraFlags
+ {
+ const Byte kMaximum = 2;
+ const Byte kFastest = 4;
+ }
+
+ namespace NHostOS
+ {
+ enum EEnum
+ {
+ kFAT = 0,
+ kAMIGA,
+ kVMS,
+ kUnix,
+ kVM_CMS,
+ kAtari,
+ kHPFS,
+ kMac,
+ kZ_System,
+ kCPM,
+ kTOPS20,
+ kNTFS,
+ kQDOS,
+ kAcorn,
+ kVFAT,
+ kMVS,
+ kBeOS,
+ kTandem,
+
+ kUnknown = 255
+ };
+ }
+
+static const char * const kHostOSes[] =
+{
+ "FAT"
+ , "AMIGA"
+ , "VMS"
+ , "Unix"
+ , "VM/CMS"
+ , "Atari"
+ , "HPFS"
+ , "Macintosh"
+ , "Z-System"
+ , "CP/M"
+ , "TOPS-20"
+ , "NTFS"
+ , "SMS/QDOS"
+ , "Acorn"
+ , "VFAT"
+ , "MVS"
+ , "BeOS"
+ , "Tandem"
+ , "OS/400"
+ , "OS/X"
+};
+
+
+class CItem
+{
+ bool TestFlag(Byte flag) const { return (Flags & flag) != 0; }
+public:
+ Byte Flags;
+ Byte ExtraFlags;
+ Byte HostOS;
+ UInt32 Time;
+ UInt32 Crc;
+ UInt32 Size32;
+
+ AString Name;
+ AString Comment;
+ // CByteBuffer Extra;
+
+ CItem():
+ Flags(0),
+ ExtraFlags(0),
+ HostOS(0),
+ Time(0),
+ Crc(0),
+ Size32(0) {}
+
+ void Clear()
+ {
+ Name.Empty();
+ Comment.Empty();
+ // Extra.Free();
+ }
+
+ void CopyMetaPropsFrom(const CItem &a)
+ {
+ Flags = a.Flags;
+ HostOS = a.HostOS;
+ Time = a.Time;
+ Name = a.Name;
+ Comment = a.Comment;
+ // Extra = a.Extra;
+ }
+
+ void CopyDataPropsFrom(const CItem &a)
+ {
+ ExtraFlags = a.ExtraFlags;
+ Crc = a.Crc;
+ Size32 = a.Size32;
+ }
+
+ // bool IsText() const { return TestFlag(NFlags::kIsText); }
+ bool HeaderCrcIsPresent() const { return TestFlag(NFlags::kCrc); }
+ bool ExtraFieldIsPresent() const { return TestFlag(NFlags::kExtra); }
+ bool NameIsPresent() const { return TestFlag(NFlags::kName); }
+ bool CommentIsPresent() const { return TestFlag(NFlags::kComment); }
+ bool IsSupported() const { return (Flags & NFlags::kReserved) == 0; }
+
+ HRESULT ReadHeader(NDecoder::CCOMCoder *stream);
+ HRESULT ReadFooter1(NDecoder::CCOMCoder *stream);
+ HRESULT ReadFooter2(ISequentialInStream *stream);
+
+ HRESULT WriteHeader(ISequentialOutStream *stream);
+ HRESULT WriteFooter(ISequentialOutStream *stream);
+};
+
+static HRESULT ReadBytes(NDecoder::CCOMCoder *stream, Byte *data, UInt32 size)
+{
+ for (UInt32 i = 0; i < size; i++)
+ data[i] = stream->ReadAlignedByte();
+ return stream->InputEofError() ? S_FALSE : S_OK;
+}
+
+static HRESULT SkipBytes(NDecoder::CCOMCoder *stream, UInt32 size)
+{
+ for (UInt32 i = 0; i < size; i++)
+ stream->ReadAlignedByte();
+ return stream->InputEofError() ? S_FALSE : S_OK;
+}
+
+static HRESULT ReadUInt16(NDecoder::CCOMCoder *stream, UInt32 &value /* , UInt32 &crc */)
+{
+ value = 0;
+ for (int i = 0; i < 2; i++)
+ {
+ Byte b = stream->ReadAlignedByte();
+ if (stream->InputEofError())
+ return S_FALSE;
+ // crc = CRC_UPDATE_BYTE(crc, b);
+ value |= ((UInt32)(b) << (8 * i));
+ }
+ return S_OK;
+}
+
+static HRESULT ReadString(NDecoder::CCOMCoder *stream, AString &s, size_t limit /* , UInt32 &crc */)
+{
+ s.Empty();
+ for (size_t i = 0; i < limit; i++)
+ {
+ Byte b = stream->ReadAlignedByte();
+ if (stream->InputEofError())
+ return S_FALSE;
+ // crc = CRC_UPDATE_BYTE(crc, b);
+ if (b == 0)
+ return S_OK;
+ s += (char)b;
+ }
+ return S_FALSE;
+}
+
+static UInt32 Is_Deflate(const Byte *p, size_t size)
+{
+ if (size < 1)
+ return k_IsArc_Res_NEED_MORE;
+ Byte b = *p;
+ p++;
+ size--;
+ unsigned type = ((unsigned)b >> 1) & 3;
+ if (type == 3)
+ return k_IsArc_Res_NO;
+ if (type == 0)
+ {
+ // Stored (uncompreessed data)
+ if ((b >> 3) != 0)
+ return k_IsArc_Res_NO;
+ if (size < 4)
+ return k_IsArc_Res_NEED_MORE;
+ UInt16 r = (UInt16)~GetUi16(p + 2);
+ if (GetUi16(p) != r)
+ return k_IsArc_Res_NO;
+ }
+ else if (type == 2)
+ {
+ // Dynamic Huffman
+ if (size < 1)
+ return k_IsArc_Res_NEED_MORE;
+ if ((*p & 0x1F) + 1 > 30) // numDistLevels
+ return k_IsArc_Res_NO;
+ }
+ return k_IsArc_Res_YES;
+}
+
+static const unsigned kNameMaxLen = 1 << 12;
+static const unsigned kCommentMaxLen = 1 << 16;
+
+API_FUNC_static_IsArc IsArc_Gz(const Byte *p, size_t size)
+{
+ if (size < 10)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != kSignature_0 ||
+ p[1] != kSignature_1 ||
+ p[2] != kSignature_2)
+ return k_IsArc_Res_NO;
+
+ Byte flags = p[3];
+ if ((flags & NFlags::kReserved) != 0)
+ return k_IsArc_Res_NO;
+
+ Byte extraFlags = p[8];
+ // maybe that flag can have another values for some gz archives?
+ if (extraFlags != 0 &&
+ extraFlags != NExtraFlags::kMaximum &&
+ extraFlags != NExtraFlags::kFastest)
+ return k_IsArc_Res_NO;
+
+ size -= 10;
+ p += 10;
+
+ if ((flags & NFlags::kExtra) != 0)
+ {
+ if (size < 2)
+ return k_IsArc_Res_NEED_MORE;
+ unsigned xlen = GetUi16(p);
+ size -= 2;
+ p += 2;
+ while (xlen != 0)
+ {
+ if (xlen < 4)
+ return k_IsArc_Res_NO;
+ if (size < 4)
+ return k_IsArc_Res_NEED_MORE;
+ unsigned len = GetUi16(p + 2);
+ size -= 4;
+ xlen -= 4;
+ p += 4;
+ if (len > xlen)
+ return k_IsArc_Res_NO;
+ if (len > size)
+ return k_IsArc_Res_NEED_MORE;
+ size -= len;
+ xlen -= len;
+ p += len;
+ }
+ }
+
+ if ((flags & NFlags::kName) != 0)
+ {
+ size_t limit = kNameMaxLen;
+ if (limit > size)
+ limit = size;
+ size_t i;
+ for (i = 0; i < limit && p[i] != 0; i++);
+ if (i == size)
+ return k_IsArc_Res_NEED_MORE;
+ if (i == limit)
+ return k_IsArc_Res_NO;
+ i++;
+ p += i;
+ size -= i;
+ }
+
+ if ((flags & NFlags::kComment) != 0)
+ {
+ size_t limit = kCommentMaxLen;
+ if (limit > size)
+ limit = size;
+ size_t i;
+ for (i = 0; i < limit && p[i] != 0; i++);
+ if (i == size)
+ return k_IsArc_Res_NEED_MORE;
+ if (i == limit)
+ return k_IsArc_Res_NO;
+ i++;
+ p += i;
+ size -= i;
+ }
+
+ if ((flags & NFlags::kCrc) != 0)
+ {
+ if (size < 2)
+ return k_IsArc_Res_NEED_MORE;
+ p += 2;
+ size -= 2;
+ }
+
+ return Is_Deflate(p, size);
+}
+}
+
+HRESULT CItem::ReadHeader(NDecoder::CCOMCoder *stream)
+{
+ Clear();
+
+ // Header-CRC field had another meaning in old version of gzip!
+ // UInt32 crc = CRC_INIT_VAL;
+ Byte buf[10];
+
+ RINOK(ReadBytes(stream, buf, 10))
+
+ if (buf[0] != kSignature_0 ||
+ buf[1] != kSignature_1 ||
+ buf[2] != kSignature_2)
+ return S_FALSE;
+
+ Flags = buf[3];
+ if (!IsSupported())
+ return S_FALSE;
+
+ Time = Get32(buf + 4);
+ ExtraFlags = buf[8];
+ HostOS = buf[9];
+
+ // crc = CrcUpdate(crc, buf, 10);
+
+ if (ExtraFieldIsPresent())
+ {
+ UInt32 xlen;
+ RINOK(ReadUInt16(stream, xlen /* , crc */))
+ RINOK(SkipBytes(stream, xlen))
+ // Extra.SetCapacity(xlen);
+ // RINOK(ReadStream_FALSE(stream, Extra, xlen));
+ // crc = CrcUpdate(crc, Extra, xlen);
+ }
+ if (NameIsPresent())
+ RINOK(ReadString(stream, Name, kNameMaxLen /* , crc */))
+ if (CommentIsPresent())
+ RINOK(ReadString(stream, Comment, kCommentMaxLen /* , crc */))
+
+ if (HeaderCrcIsPresent())
+ {
+ UInt32 headerCRC;
+ // UInt32 dummy = 0;
+ RINOK(ReadUInt16(stream, headerCRC /* , dummy */))
+ /*
+ if ((UInt16)CRC_GET_DIGEST(crc) != headerCRC)
+ return S_FALSE;
+ */
+ }
+ return stream->InputEofError() ? S_FALSE : S_OK;
+}
+
+HRESULT CItem::ReadFooter1(NDecoder::CCOMCoder *stream)
+{
+ Byte buf[8];
+ RINOK(ReadBytes(stream, buf, 8))
+ Crc = Get32(buf);
+ Size32 = Get32(buf + 4);
+ return stream->InputEofError() ? S_FALSE : S_OK;
+}
+
+HRESULT CItem::ReadFooter2(ISequentialInStream *stream)
+{
+ Byte buf[8];
+ RINOK(ReadStream_FALSE(stream, buf, 8))
+ Crc = Get32(buf);
+ Size32 = Get32(buf + 4);
+ return S_OK;
+}
+
+HRESULT CItem::WriteHeader(ISequentialOutStream *stream)
+{
+ Byte buf[10];
+ buf[0] = kSignature_0;
+ buf[1] = kSignature_1;
+ buf[2] = kSignature_2;
+ buf[3] = (Byte)(Flags & NFlags::kName);
+ // buf[3] |= NFlags::kCrc;
+ SetUi32(buf + 4, Time)
+ buf[8] = ExtraFlags;
+ buf[9] = HostOS;
+ RINOK(WriteStream(stream, buf, 10))
+ // crc = CrcUpdate(CRC_INIT_VAL, buf, 10);
+ if (NameIsPresent())
+ {
+ // crc = CrcUpdate(crc, (const char *)Name, Name.Len() + 1);
+ RINOK(WriteStream(stream, (const char *)Name, Name.Len() + 1))
+ }
+ // SetUi16(buf, (UInt16)CRC_GET_DIGEST(crc));
+ // RINOK(WriteStream(stream, buf, 2));
+ return S_OK;
+}
+
+HRESULT CItem::WriteFooter(ISequentialOutStream *stream)
+{
+ Byte buf[8];
+ SetUi32(buf, Crc)
+ SetUi32(buf + 4, Size32)
+ return WriteStream(stream, buf, 8);
+}
+
+Z7_CLASS_IMP_CHandler_IInArchive_3(
+ IArchiveOpenSeq,
+ IOutArchive,
+ ISetProperties
+)
+ CItem _item;
+
+ bool _isArc;
+ bool _needSeekToStart;
+ bool _dataAfterEnd;
+ bool _needMoreInput;
+
+ bool _packSize_Defined;
+ bool _unpackSize_Defined;
+ bool _numStreams_Defined;
+
+ UInt64 _packSize;
+ UInt64 _unpackSize; // real unpack size (NOT from footer)
+ UInt64 _numStreams;
+ UInt64 _headerSize; // only start header (without footer)
+
+ CMyComPtr<IInStream> _stream;
+ CMyComPtr<ICompressCoder> _decoder;
+ NDecoder::CCOMCoder *_decoderSpec;
+
+ CSingleMethodProps _props;
+ CHandlerTimeOptions _timeOptions;
+
+public:
+ CHandler():
+ _isArc(false),
+ _decoderSpec(NULL)
+ {}
+
+ void CreateDecoder()
+ {
+ if (_decoder)
+ return;
+ _decoderSpec = new NDecoder::CCOMCoder;
+ _decoder = _decoderSpec;
+ }
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidHostOS,
+ kpidCRC
+ // kpidComment
+};
+
+static const Byte kArcProps[] =
+{
+ kpidHeadersSize,
+ kpidNumStreams
+};
+
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidUnpackSize: if (_unpackSize_Defined) prop = _unpackSize; break;
+ case kpidNumStreams: if (_numStreams_Defined) prop = _numStreams; break;
+ case kpidHeadersSize: if (_headerSize != 0) prop = _headerSize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
+ prop = v;
+ break;
+ }
+ case kpidName:
+ if (_item.NameIsPresent())
+ {
+ UString s = MultiByteToUnicodeString(_item.Name, CP_ACP);
+ s += ".gz";
+ prop = s;
+ }
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPath:
+ if (_item.NameIsPresent())
+ prop = MultiByteToUnicodeString(_item.Name, CP_ACP);
+ break;
+ // case kpidComment: if (_item.CommentIsPresent()) prop = MultiByteToUnicodeString(_item.Comment, CP_ACP); break;
+ case kpidMTime:
+ // gzip specification: MTIME = 0 means no time stamp is available.
+ if (_item.Time != 0)
+ PropVariant_SetFrom_UnixTime(prop, _item.Time);
+ break;
+ case kpidTimeType:
+ if (_item.Time != 0)
+ prop = (UInt32)NFileTimeType::kUnix;
+ break;
+ case kpidSize:
+ {
+ if (_unpackSize_Defined)
+ prop = _unpackSize;
+ else if (_stream)
+ prop = (UInt64)_item.Size32;
+ break;
+ }
+ case kpidPackSize:
+ {
+ if (_packSize_Defined || _stream)
+ prop = _packSize;
+ break;
+ }
+ case kpidHostOS: TYPE_TO_PROP(kHostOSes, _item.HostOS, prop); break;
+ case kpidCRC: if (_stream) prop = _item.Crc; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_CLASS_IMP_COM_1(
+ CCompressProgressInfoImp,
+ ICompressProgressInfo
+)
+ CMyComPtr<IArchiveOpenCallback> Callback;
+public:
+ UInt64 Offset;
+ void Init(IArchiveOpenCallback *callback) { Callback = callback; }
+};
+
+Z7_COM7F_IMF(CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+{
+ if (Callback)
+ {
+ UInt64 files = 0;
+ UInt64 value = Offset + *inSize;
+ return Callback->SetCompleted(&files, &value);
+ }
+ return S_OK;
+}
+
+/*
+*/
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *))
+{
+ COM_TRY_BEGIN
+ RINOK(OpenSeq(stream))
+ _isArc = false;
+ UInt64 endPos;
+ RINOK(stream->Seek(-8, STREAM_SEEK_END, &endPos))
+ _packSize = endPos + 8;
+ RINOK(_item.ReadFooter2(stream))
+ _stream = stream;
+ _isArc = true;
+ _needSeekToStart = true;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ COM_TRY_BEGIN
+ try
+ {
+ Close();
+ CreateDecoder();
+ _decoderSpec->SetInStream(stream);
+ _decoderSpec->InitInStream(true);
+ RINOK(_item.ReadHeader(_decoderSpec))
+ if (_decoderSpec->InputEofError())
+ return S_FALSE;
+ _headerSize = _decoderSpec->GetInputProcessedSize();
+ _isArc = true;
+ return S_OK;
+ }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _needSeekToStart = false;
+ _dataAfterEnd = false;
+ _needMoreInput = false;
+
+ _packSize_Defined = false;
+ _unpackSize_Defined = false;
+ _numStreams_Defined = false;
+
+ _packSize = 0;
+ _headerSize = 0;
+
+ _stream.Release();
+ if (_decoder)
+ _decoderSpec->ReleaseInStream();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ if (_packSize_Defined)
+ extractCallback->SetTotal(_packSize);
+ // UInt64 currentTotalPacked = 0;
+ // RINOK(extractCallback->SetCompleted(¤tTotalPacked));
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CreateDecoder();
+
+ COutStreamWithCRC *outStreamSpec = new COutStreamWithCRC;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, true);
+
+ bool needReadFirstItem = _needSeekToStart;
+
+ if (_needSeekToStart)
+ {
+ if (!_stream)
+ return E_FAIL;
+ RINOK(InStream_SeekToBegin(_stream))
+ _decoderSpec->InitInStream(true);
+ // printf("\nSeek");
+ }
+ else
+ _needSeekToStart = true;
+
+ bool firstItem = true;
+
+ UInt64 packSize = _decoderSpec->GetInputProcessedSize();
+ // printf("\npackSize = %d", (unsigned)packSize);
+
+ UInt64 unpackedSize = 0;
+ UInt64 numStreams = 0;
+
+ bool crcError = false;
+
+ HRESULT result = S_OK;
+
+ try {
+
+ for (;;)
+ {
+ lps->InSize = packSize;
+ lps->OutSize = unpackedSize;
+
+ RINOK(lps->SetCur())
+
+ CItem item;
+
+ if (!firstItem || needReadFirstItem)
+ {
+ result = item.ReadHeader(_decoderSpec);
+
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ if (_decoderSpec->InputEofError())
+ result = S_FALSE;
+
+ if (result != S_OK && firstItem)
+ {
+ _isArc = false;
+ break;
+ }
+
+ if (packSize == _decoderSpec->GetStreamSize())
+ {
+ result = S_OK;
+ break;
+ }
+
+ if (result != S_OK)
+ {
+ _dataAfterEnd = true;
+ break;
+ }
+ }
+
+ numStreams++;
+ firstItem = false;
+
+ UInt64 startOffset = outStreamSpec->GetSize();
+ outStreamSpec->InitCRC();
+
+ result = _decoderSpec->CodeResume(outStream, NULL, progress);
+
+ packSize = _decoderSpec->GetInputProcessedSize();
+ unpackedSize = outStreamSpec->GetSize();
+
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ if (_decoderSpec->InputEofError())
+ {
+ packSize = _decoderSpec->GetStreamSize();
+ _needMoreInput = true;
+ result = S_FALSE;
+ }
+
+ if (result != S_OK)
+ break;
+
+ _decoderSpec->AlignToByte();
+
+ result = item.ReadFooter1(_decoderSpec);
+
+ packSize = _decoderSpec->GetInputProcessedSize();
+
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ if (result != S_OK)
+ {
+ if (_decoderSpec->InputEofError())
+ {
+ _needMoreInput = true;
+ result = S_FALSE;
+ }
+ break;
+ }
+
+ if (item.Crc != outStreamSpec->GetCRC() ||
+ item.Size32 != (UInt32)(unpackedSize - startOffset))
+ {
+ crcError = true;
+ result = S_FALSE;
+ break;
+ }
+
+ // break; // we can use break, if we need only first stream
+ }
+
+ } catch(const CInBufferException &e) { return e.ErrorCode; }
+
+ if (!firstItem)
+ {
+ _packSize = packSize;
+ _unpackSize = unpackedSize;
+ _numStreams = numStreams;
+
+ _packSize_Defined = true;
+ _unpackSize_Defined = true;
+ _numStreams_Defined = true;
+ }
+
+ outStream.Release();
+
+ Int32 retResult = NExtract::NOperationResult::kDataError;
+
+ if (!_isArc)
+ retResult = NExtract::NOperationResult::kIsNotArc;
+ else if (_needMoreInput)
+ retResult = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (crcError)
+ retResult = NExtract::NOperationResult::kCRCError;
+ else if (_dataAfterEnd)
+ retResult = NExtract::NOperationResult::kDataAfterEnd;
+ else if (result == S_FALSE)
+ retResult = NExtract::NOperationResult::kDataError;
+ else if (result == S_OK)
+ retResult = NExtract::NOperationResult::kOK;
+ else
+ return result;
+
+ return extractCallback->SetOperationResult(retResult);
+
+
+ COM_TRY_END
+}
+
+static const Byte kHostOS =
+ #ifdef _WIN32
+ NHostOS::kFAT;
+ #else
+ NHostOS::kUnix;
+ #endif
+
+
+/*
+static HRESULT ReportItemProp(IArchiveUpdateCallbackArcProp *reportArcProp, PROPID propID, const PROPVARIANT *value)
+{
+ return reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, 0, propID, value);
+}
+
+static HRESULT ReportArcProp(IArchiveUpdateCallbackArcProp *reportArcProp, PROPID propID, const PROPVARIANT *value)
+{
+ return reportArcProp->ReportProp(NEventIndexType::kArcProp, 0, propID, value);
+}
+
+static HRESULT ReportArcProps(IArchiveUpdateCallbackArcProp *reportArcProp,
+ const CItem &item,
+ bool needTime,
+ bool needCrc,
+ const UInt64 *unpackSize)
+{
+ NCOM::CPropVariant timeProp;
+ NCOM::CPropVariant sizeProp;
+ if (needTime)
+ {
+ FILETIME ft;
+ NTime::UnixTimeToFileTime(item.Time, ft);
+ timeProp.SetAsTimeFrom_FT_Prec(ft, k_PropVar_TimePrec_Unix);
+ }
+ if (unpackSize)
+ {
+ sizeProp = *unpackSize;
+ RINOK(ReportItemProp(reportArcProp, kpidSize, &sizeProp));
+ }
+ if (needCrc)
+ {
+ NCOM::CPropVariant prop;
+ prop = item.Crc;
+ RINOK(ReportItemProp(reportArcProp, kpidCRC, &prop));
+ }
+ {
+ RINOK(ReportItemProp(reportArcProp, kpidMTime, &timeProp));
+ }
+
+ RINOK(reportArcProp->ReportFinished(NEventIndexType::kOutArcIndex, 0, NArchive::NUpdate::NOperationResult::kOK));
+
+ if (unpackSize)
+ {
+ RINOK(ReportArcProp(reportArcProp, kpidSize, &sizeProp));
+ }
+ {
+ RINOK(ReportArcProp(reportArcProp, kpidComboMTime, &timeProp));
+ }
+ return S_OK;
+}
+*/
+
+static HRESULT UpdateArchive(
+ ISequentialOutStream *outStream,
+ UInt64 unpackSize,
+ CItem &item,
+ const CSingleMethodProps &props,
+ const CHandlerTimeOptions &timeOptions,
+ IArchiveUpdateCallback *updateCallback
+ // , IArchiveUpdateCallbackArcProp *reportArcProp
+ )
+{
+ UInt64 unpackSizeReal;
+ {
+ CMyComPtr<ISequentialInStream> fileInStream;
+
+ RINOK(updateCallback->GetStream(0, &fileInStream))
+
+ if (!fileInStream)
+ return S_FALSE;
+
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamGetProps,
+ getProps, fileInStream)
+ if (getProps)
+ {
+ FILETIME mTime;
+ UInt64 size;
+ if (getProps->GetProps(&size, NULL, NULL, &mTime, NULL) == S_OK)
+ {
+ unpackSize = size;
+ if (timeOptions.Write_MTime.Val)
+ NTime::FileTime_To_UnixTime(mTime, item.Time);
+ }
+ }
+ }
+
+ UInt64 complexity = 0;
+ RINOK(updateCallback->SetTotal(unpackSize))
+ RINOK(updateCallback->SetCompleted(&complexity))
+
+ CSequentialInStreamWithCRC *inStreamSpec = new CSequentialInStreamWithCRC;
+ CMyComPtr<ISequentialInStream> crcStream(inStreamSpec);
+ inStreamSpec->SetStream(fileInStream);
+ inStreamSpec->Init();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ item.ExtraFlags = props.GetLevel() >= 7 ?
+ NExtraFlags::kMaximum :
+ NExtraFlags::kFastest;
+
+ item.HostOS = kHostOS;
+
+ RINOK(item.WriteHeader(outStream))
+
+ NEncoder::CCOMCoder *deflateEncoderSpec = new NEncoder::CCOMCoder;
+ CMyComPtr<ICompressCoder> deflateEncoder = deflateEncoderSpec;
+ RINOK(props.SetCoderProps(deflateEncoderSpec, NULL))
+ RINOK(deflateEncoder->Code(crcStream, outStream, NULL, NULL, progress))
+
+ item.Crc = inStreamSpec->GetCRC();
+ unpackSizeReal = inStreamSpec->GetSize();
+ item.Size32 = (UInt32)unpackSizeReal;
+ RINOK(item.WriteFooter(outStream))
+ }
+ /*
+ if (reportArcProp)
+ {
+ RINOK(ReportArcProps(reportArcProp,
+ item,
+ props._Write_MTime, // item.Time != 0,
+ true, // writeCrc
+ &unpackSizeReal));
+ }
+ */
+ return updateCallback->SetOperationResult(NUpdate::NOperationResult::kOK);
+}
+
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *timeType))
+{
+ /*
+ if (_item.Time != 0)
+ {
+ we set NFileTimeType::kUnix in precision,
+ and we return NFileTimeType::kUnix in kpidTimeType
+ so GetFileTimeType() value is not used in any version of 7-zip.
+ }
+ else // (_item.Time == 0)
+ {
+ kpidMTime and kpidTimeType are not defined
+ before 22.00 : GetFileTimeType() value is used in GetUpdatePairInfoList();
+ 22.00 : GetFileTimeType() value is not used
+ }
+ */
+
+ UInt32 t;
+ t = NFileTimeType::kUnix;
+ if (_isArc ? (_item.Time == 0) : !_timeOptions.Write_MTime.Val)
+ {
+ t = GET_FileTimeType_NotDefined_for_GetFileTimeType;
+ // t = k_PropVar_TimePrec_1ns; // failed in 7-Zip 21
+ // t = (UInt32)(Int32)NFileTimeType::kNotDefined; // failed in 7-Zip 21
+ }
+ *timeType = t;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *updateCallback))
+{
+ COM_TRY_BEGIN
+
+ if (numItems != 1)
+ return E_INVALIDARG;
+
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamSetRestriction,
+ setRestriction, outStream)
+ if (setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+ }
+
+ Int32 newData, newProps;
+ UInt32 indexInArchive;
+ if (!updateCallback)
+ return E_FAIL;
+ RINOK(updateCallback->GetUpdateItemInfo(0, &newData, &newProps, &indexInArchive))
+
+ // Z7_DECL_CMyComPtr_QI_FROM(IArchiveUpdateCallbackArcProp, reportArcProp, updateCallback)
+
+ CItem newItem;
+
+ if (!IntToBool(newProps))
+ {
+ newItem.CopyMetaPropsFrom(_item);
+ }
+ else
+ {
+ newItem.HostOS = kHostOS;
+ if (_timeOptions.Write_MTime.Val)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidMTime, &prop))
+ if (prop.vt == VT_FILETIME)
+ NTime::FileTime_To_UnixTime(prop.filetime, newItem.Time);
+ else if (prop.vt == VT_EMPTY)
+ newItem.Time = 0;
+ else
+ return E_INVALIDARG;
+ }
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidPath, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ UString name = prop.bstrVal;
+ int slashPos = name.ReverseFind_PathSepar();
+ if (slashPos >= 0)
+ name.DeleteFrontal((unsigned)(slashPos + 1));
+ newItem.Name = UnicodeStringToMultiByte(name, CP_ACP);
+ if (!newItem.Name.IsEmpty())
+ newItem.Flags |= NFlags::kName;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidIsDir, &prop))
+ if (prop.vt != VT_EMPTY)
+ if (prop.vt != VT_BOOL || prop.boolVal != VARIANT_FALSE)
+ return E_INVALIDARG;
+ }
+ }
+
+ if (IntToBool(newData))
+ {
+ UInt64 size;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ size = prop.uhVal.QuadPart;
+ }
+ return UpdateArchive(outStream, size, newItem, _props, _timeOptions, updateCallback);
+ }
+
+ if (indexInArchive != 0)
+ return E_INVALIDARG;
+
+ if (!_stream)
+ return E_NOTIMPL;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveUpdateCallbackFile,
+ opCallback, updateCallback)
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kInArcIndex, 0,
+ NUpdateNotifyOp::kReplicate))
+ }
+
+ newItem.CopyDataPropsFrom(_item);
+
+ UInt64 offset = 0;
+ if (IntToBool(newProps))
+ {
+ newItem.WriteHeader(outStream);
+ offset += _headerSize;
+ }
+ RINOK(InStream_SeekSet(_stream, offset))
+
+ /*
+ if (reportArcProp)
+ ReportArcProps(reportArcProp, newItem,
+ _props._Write_MTime,
+ false, // writeCrc
+ NULL); // unpacksize
+ */
+
+ return NCompress::CopyStream(_stream, outStream, progress);
+
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ _timeOptions.Init();
+ _props.Init();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ UString name = names[i];
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+ const PROPVARIANT &value = values[i];
+ {
+ bool processed = false;
+ RINOK(_timeOptions.Parse(name, value, processed))
+ if (processed)
+ {
+ if (_timeOptions.Write_CTime.Val ||
+ _timeOptions.Write_ATime.Val)
+ return E_INVALIDARG;
+ if ( _timeOptions.Prec != (UInt32)(Int32)-1
+ && _timeOptions.Prec != k_PropVar_TimePrec_0
+ && _timeOptions.Prec != k_PropVar_TimePrec_Unix
+ && _timeOptions.Prec != k_PropVar_TimePrec_HighPrec
+ && _timeOptions.Prec != k_PropVar_TimePrec_Base)
+ return E_INVALIDARG;
+ continue;
+ }
+ }
+ RINOK(_props.SetProperty(name, value))
+ }
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { kSignature_0, kSignature_1, kSignature_2 };
+
+REGISTER_ARC_IO(
+ "gzip", "gz gzip tgz tpz apk", "* * .tar .tar .tar", 0xEF,
+ k_Signature, 0,
+ NArcInfoFlags::kKeepName
+ | NArcInfoFlags::kMTime
+ | NArcInfoFlags::kMTime_Default
+ , TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kUnix)
+ | TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT (NFileTimeType::kUnix)
+ , IsArc_Gz)
+
+}}
diff --git a/CPP/7zip/Archive/HandlerCont.cpp b/CPP/7zip/Archive/HandlerCont.cpp
new file mode 100644
index 0000000..b4524a4
--- /dev/null
+++ b/CPP/7zip/Archive/HandlerCont.cpp
@@ -0,0 +1,346 @@
+// HandlerCont.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "HandlerCont.h"
+
+namespace NArchive {
+
+namespace NExt {
+API_FUNC_IsArc IsArc_Ext(const Byte *p, size_t size);
+}
+
+Z7_COM7F_IMF(CHandlerCont::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ {
+ RINOK(GetNumberOfItems(&numItems))
+ }
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ UInt64 pos, size;
+ GetItem_ExtractInfo(allFilesMode ? i : indices[i], pos, size);
+ totalSize += size;
+ }
+ extractCallback->SetTotal(totalSize);
+
+ totalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+
+ UInt64 pos, size;
+ int opRes = GetItem_ExtractInfo(index, pos, size);
+ totalSize += size;
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ if (opRes == NExtract::NOperationResult::kOK)
+ {
+ RINOK(InStream_SeekSet(_stream, pos))
+ streamSpec->Init(size);
+
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+
+ opRes = NExtract::NOperationResult::kDataError;
+
+ if (copyCoderSpec->TotalSize == size)
+ opRes = NExtract::NOperationResult::kOK;
+ else if (copyCoderSpec->TotalSize < size)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ }
+
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandlerCont::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ UInt64 pos, size;
+ if (GetItem_ExtractInfo(index, pos, size) != NExtract::NOperationResult::kOK)
+ return S_FALSE;
+ return CreateLimitedInStream(_stream, pos, size, stream);
+ COM_TRY_END
+}
+
+
+
+CHandlerImg::CHandlerImg()
+{
+ Clear_HandlerImg_Vars();
+}
+
+Z7_COM7F_IMF(CHandlerImg::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += _size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ {
+ if (newPosition)
+ *newPosition = _virtPos;
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ }
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+static const Byte k_GDP_Signature[] = { 'E', 'F', 'I', ' ', 'P', 'A', 'R', 'T' };
+// static const Byte k_Ext_Signature[] = { 0x53, 0xEF };
+// static const unsigned k_Ext_Signature_offset = 0x438;
+
+static const char *GetImgExt(ISequentialInStream *stream)
+{
+ const size_t kHeaderSize = 1 << 11;
+ Byte buf[kHeaderSize];
+ if (ReadStream_FAIL(stream, buf, kHeaderSize) == S_OK)
+ {
+ if (buf[0x1FE] == 0x55 && buf[0x1FF] == 0xAA)
+ {
+ if (memcmp(buf + 512, k_GDP_Signature, sizeof(k_GDP_Signature)) == 0)
+ return "gpt";
+ return "mbr";
+ }
+ if (NExt::IsArc_Ext(buf, kHeaderSize) == k_IsArc_Res_YES)
+ return "ext";
+ }
+ return NULL;
+}
+
+void CHandlerImg::CloseAtError()
+{
+ Stream.Release();
+}
+
+void CHandlerImg::Clear_HandlerImg_Vars()
+{
+ _imgExt = NULL;
+ _size = 0;
+ ClearStreamVars();
+ Reset_VirtPos();
+ Reset_PosInArc();
+}
+
+Z7_COM7F_IMF(CHandlerImg::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * openCallback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ HRESULT res;
+ try
+ {
+ res = Open2(stream, openCallback);
+ if (res == S_OK)
+ {
+ CMyComPtr<ISequentialInStream> inStream;
+ const HRESULT res2 = GetStream(0, &inStream);
+ if (res2 == S_OK && inStream)
+ _imgExt = GetImgExt(inStream);
+ // _imgExt = GetImgExt(this); // for debug
+ /* we reset (_virtPos) to support cases, if some code will
+ call Read() from Handler object instead of GetStream() object. */
+ Reset_VirtPos();
+ // optional: we reset (_posInArc). if real seek position of stream will be changed in external code
+ Reset_PosInArc();
+ // optional: here we could also reset seek positions in parent streams..
+ return S_OK;
+ }
+ }
+ catch(...)
+ {
+ CloseAtError();
+ throw;
+ }
+ CloseAtError();
+ return res;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandlerImg::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CHandlerImgProgress
+ , ICompressProgressInfo
+)
+public:
+ CHandlerImg &Handler;
+ CMyComPtr<ICompressProgressInfo> _ratioProgress;
+
+ CHandlerImgProgress(CHandlerImg &handler) : Handler(handler) {}
+};
+
+
+Z7_COM7F_IMF(CHandlerImgProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ UInt64 inSize2;
+ if (Handler.Get_PackSizeProcessed(inSize2))
+ inSize = &inSize2;
+ return _ratioProgress->SetRatioInfo(inSize, outSize);
+}
+
+
+Z7_COM7F_IMF(CHandlerImg::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ RINOK(extractCallback->SetTotal(_size))
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &outStream, askMode))
+ if (!testMode && !outStream)
+ return S_OK;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ int opRes = NExtract::NOperationResult::kDataError;
+
+ ClearStreamVars();
+
+ CMyComPtr<ISequentialInStream> inStream;
+ HRESULT hres = GetStream(0, &inStream);
+ if (hres == S_FALSE)
+ hres = E_NOTIMPL;
+
+ if (hres == S_OK && inStream)
+ {
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ if (Init_PackSizeProcessed())
+ {
+ CHandlerImgProgress *imgProgressSpec = new CHandlerImgProgress(*this);
+ CMyComPtr<ICompressProgressInfo> imgProgress = imgProgressSpec;
+ imgProgressSpec->_ratioProgress = progress;
+ progress.Release();
+ progress = imgProgress;
+ }
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ hres = copyCoder->Code(inStream, outStream, NULL, &_size, progress);
+ if (hres == S_OK)
+ {
+ if (copyCoderSpec->TotalSize == _size)
+ opRes = NExtract::NOperationResult::kOK;
+
+ if (_stream_unavailData)
+ opRes = NExtract::NOperationResult::kUnavailable;
+ else if (_stream_unsupportedMethod)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (_stream_dataError)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (copyCoderSpec->TotalSize < _size)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ }
+ }
+
+ inStream.Release();
+ outStream.Release();
+
+ if (hres != S_OK)
+ {
+ if (hres == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (hres == E_NOTIMPL)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ return hres;
+ }
+
+ return extractCallback->SetOperationResult(opRes);
+ COM_TRY_END
+}
+
+
+HRESULT ReadZeroTail(ISequentialInStream *stream, bool &areThereNonZeros, UInt64 &numZeros, UInt64 maxSize)
+{
+ areThereNonZeros = false;
+ numZeros = 0;
+ const size_t kBufSize = 1 << 11;
+ Byte buf[kBufSize];
+ for (;;)
+ {
+ UInt32 size = 0;
+ RINOK(stream->Read(buf, kBufSize, &size))
+ if (size == 0)
+ return S_OK;
+ for (UInt32 i = 0; i < size; i++)
+ if (buf[i] != 0)
+ {
+ areThereNonZeros = true;
+ numZeros += i;
+ return S_OK;
+ }
+ numZeros += size;
+ if (numZeros > maxSize)
+ return S_OK;
+ }
+}
+
+}
diff --git a/CPP/7zip/Archive/HandlerCont.h b/CPP/7zip/Archive/HandlerCont.h
new file mode 100644
index 0000000..2dd0529
--- /dev/null
+++ b/CPP/7zip/Archive/HandlerCont.h
@@ -0,0 +1,134 @@
+// HandlerCont.h
+
+#ifndef ZIP7_INC_HANDLER_CONT_H
+#define ZIP7_INC_HANDLER_CONT_H
+
+#include "../../Common/MyCom.h"
+
+#include "IArchive.h"
+
+namespace NArchive {
+
+#define Z7_IFACEM_IInArchive_Cont(x) \
+ x(Open(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *openCallback)) \
+ x(Close()) \
+ x(GetNumberOfItems(UInt32 *numItems)) \
+ x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+ /* x(Extract(const UInt32 *indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback)) */ \
+ x(GetArchiveProperty(PROPID propID, PROPVARIANT *value)) \
+ x(GetNumberOfProperties(UInt32 *numProps)) \
+ x(GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ x(GetNumberOfArchiveProperties(UInt32 *numProps)) \
+ x(GetArchivePropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+
+
+// #define Z7_COM7F_PUREO(f) virtual Z7_COM7F_IMF(f) Z7_override =0;
+// #define Z7_COM7F_PUREO2(t, f) virtual Z7_COM7F_IMF2(t, f) Z7_override =0;
+
+class CHandlerCont:
+ public IInArchive,
+ public IInArchiveGetStream,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_2(
+ IInArchive,
+ IInArchiveGetStream)
+ /*
+ Z7_IFACEM_IInArchive_Cont(Z7_COM7F_PUREO)
+ // Z7_IFACE_COM7_PURE(IInArchive_Cont)
+ */
+ Z7_COM7F_IMP(Extract(const UInt32 *indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback))
+protected:
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+
+ CMyComPtr<IInStream> _stream;
+ virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const = 0;
+ // destructor must be virtual for this class
+ virtual ~CHandlerCont() {}
+};
+
+
+
+#define Z7_IFACEM_IInArchive_Img(x) \
+ /* x(Open(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *openCallback)) */ \
+ x(Close()) \
+ /* x(GetNumberOfItems(UInt32 *numItems)) */ \
+ x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+ /* x(Extract(const UInt32 *indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback)) */ \
+ x(GetArchiveProperty(PROPID propID, PROPVARIANT *value)) \
+ x(GetNumberOfProperties(UInt32 *numProps)) \
+ x(GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ x(GetNumberOfArchiveProperties(UInt32 *numProps)) \
+ x(GetArchivePropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+
+
+class CHandlerImg:
+ public IInArchive,
+ public IInArchiveGetStream,
+ public IInStream,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_3(
+ IInArchive,
+ IInArchiveGetStream,
+ IInStream)
+
+ Z7_COM7F_IMP(Open(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *openCallback))
+ Z7_COM7F_IMP(GetNumberOfItems(UInt32 *numItems))
+ Z7_COM7F_IMP(Extract(const UInt32 *indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback))
+ Z7_IFACE_COM7_IMP(IInStream)
+ // Z7_IFACEM_IInArchive_Img(Z7_COM7F_PUREO)
+
+protected:
+ UInt64 _virtPos;
+ UInt64 _posInArc;
+ UInt64 _size;
+ CMyComPtr<IInStream> Stream;
+ const char *_imgExt;
+
+ bool _stream_unavailData;
+ bool _stream_unsupportedMethod;
+ bool _stream_dataError;
+ // bool _stream_UsePackSize;
+ // UInt64 _stream_PackSize;
+
+ void Reset_PosInArc() { _posInArc = (UInt64)0 - 1; }
+ void Reset_VirtPos() { _virtPos = (UInt64)0; }
+
+ void ClearStreamVars()
+ {
+ _stream_unavailData = false;
+ _stream_unsupportedMethod = false;
+ _stream_dataError = false;
+ // _stream_UsePackSize = false;
+ // _stream_PackSize = 0;
+ }
+
+ void Clear_HandlerImg_Vars(); // it doesn't Release (Stream) var.
+
+ virtual HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openCallback) = 0;
+ virtual void CloseAtError();
+
+ // returns (true), if Get_PackSizeProcessed() is required in Extract()
+ virtual bool Init_PackSizeProcessed()
+ {
+ return false;
+ }
+public:
+ virtual bool Get_PackSizeProcessed(UInt64 &size)
+ {
+ size = 0;
+ return false;
+ }
+
+ CHandlerImg();
+ // destructor must be virtual for this class
+ virtual ~CHandlerImg() {}
+};
+
+
+HRESULT ReadZeroTail(ISequentialInStream *stream, bool &areThereNonZeros, UInt64 &numZeros, UInt64 maxSize);
+
+}
+
+#endif
diff --git a/CPP/7zip/Archive/HfsHandler.cpp b/CPP/7zip/Archive/HfsHandler.cpp
new file mode 100644
index 0000000..696ecd7
--- /dev/null
+++ b/CPP/7zip/Archive/HfsHandler.cpp
@@ -0,0 +1,2590 @@
+// HfsHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "HfsHandler.h"
+
+/* if HFS_SHOW_ALT_STREAMS is defined, the handler will show attribute files
+ and resource forks. In most cases it looks useless. So we disable it. */
+
+#define HFS_SHOW_ALT_STREAMS
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+#define Get64(p) GetBe64(p)
+
+namespace NArchive {
+namespace NHfs {
+
+static const char * const kResFileName = "rsrc"; // "com.apple.ResourceFork";
+
+struct CExtent
+{
+ UInt32 Pos;
+ UInt32 NumBlocks;
+};
+
+struct CIdExtents
+{
+ UInt32 ID;
+ UInt32 StartBlock;
+ CRecordVector<CExtent> Extents;
+};
+
+struct CFork
+{
+ UInt64 Size;
+ UInt32 NumBlocks;
+ // UInt32 ClumpSize;
+ CRecordVector<CExtent> Extents;
+
+ CFork(): Size(0), NumBlocks(0) {}
+
+ void Parse(const Byte *p);
+
+ bool IsEmpty() const { return Size == 0 && NumBlocks == 0 && Extents.Size() == 0; }
+
+ UInt32 Calc_NumBlocks_from_Extents() const;
+ bool Check_NumBlocks() const;
+
+ bool Check_Size_with_NumBlocks(unsigned blockSizeLog) const
+ {
+ return Size <= ((UInt64)NumBlocks << blockSizeLog);
+ }
+
+ bool IsOk(unsigned blockSizeLog) const
+ {
+ // we don't check cases with extra (empty) blocks in last extent
+ return Check_NumBlocks() && Check_Size_with_NumBlocks(blockSizeLog);
+ }
+
+ bool Upgrade(const CObjectVector<CIdExtents> &items, UInt32 id);
+ bool UpgradeAndTest(const CObjectVector<CIdExtents> &items, UInt32 id, unsigned blockSizeLog)
+ {
+ if (!Upgrade(items, id))
+ return false;
+ return IsOk(blockSizeLog);
+ }
+};
+
+static const unsigned kNumFixedExtents = 8;
+static const unsigned kForkRecSize = 16 + kNumFixedExtents * 8;
+
+
+void CFork::Parse(const Byte *p)
+{
+ Extents.Clear();
+ Size = Get64(p);
+ // ClumpSize = Get32(p + 8);
+ NumBlocks = Get32(p + 12);
+ p += 16;
+ for (unsigned i = 0; i < kNumFixedExtents; i++, p += 8)
+ {
+ CExtent e;
+ e.Pos = Get32(p);
+ e.NumBlocks = Get32(p + 4);
+ if (e.NumBlocks != 0)
+ Extents.Add(e);
+ }
+}
+
+UInt32 CFork::Calc_NumBlocks_from_Extents() const
+{
+ UInt32 num = 0;
+ FOR_VECTOR (i, Extents)
+ {
+ num += Extents[i].NumBlocks;
+ }
+ return num;
+}
+
+bool CFork::Check_NumBlocks() const
+{
+ UInt32 num = 0;
+ FOR_VECTOR (i, Extents)
+ {
+ UInt32 next = num + Extents[i].NumBlocks;
+ if (next < num)
+ return false;
+ num = next;
+ }
+ return num == NumBlocks;
+}
+
+struct CIdIndexPair
+{
+ UInt32 ID;
+ unsigned Index;
+
+ int Compare(const CIdIndexPair &a) const;
+};
+
+#define RINOZ(x) { const int _t_ = (x); if (_t_ != 0) return _t_; }
+
+int CIdIndexPair::Compare(const CIdIndexPair &a) const
+{
+ RINOZ(MyCompare(ID, a.ID))
+ return MyCompare(Index, a.Index);
+}
+
+static int FindItemIndex(const CRecordVector<CIdIndexPair> &items, UInt32 id)
+{
+ unsigned left = 0, right = items.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const UInt32 midVal = items[mid].ID;
+ if (id == midVal)
+ return (int)items[mid].Index;
+ if (id < midVal)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+}
+
+static int Find_in_IdExtents(const CObjectVector<CIdExtents> &items, UInt32 id)
+{
+ unsigned left = 0, right = items.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const UInt32 midVal = items[mid].ID;
+ if (id == midVal)
+ return (int)mid;
+ if (id < midVal)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+}
+
+bool CFork::Upgrade(const CObjectVector<CIdExtents> &items, UInt32 id)
+{
+ int index = Find_in_IdExtents(items, id);
+ if (index < 0)
+ return true;
+ const CIdExtents &item = items[index];
+ if (Calc_NumBlocks_from_Extents() != item.StartBlock)
+ return false;
+ Extents += item.Extents;
+ return true;
+}
+
+
+struct CVolHeader
+{
+ Byte Header[2];
+ UInt16 Version;
+ // UInt32 Attr;
+ // UInt32 LastMountedVersion;
+ // UInt32 JournalInfoBlock;
+
+ UInt32 CTime;
+ UInt32 MTime;
+ // UInt32 BackupTime;
+ // UInt32 CheckedTime;
+
+ UInt32 NumFiles;
+ UInt32 NumFolders;
+ unsigned BlockSizeLog;
+ UInt32 NumBlocks;
+ UInt32 NumFreeBlocks;
+
+ // UInt32 WriteCount;
+ // UInt32 FinderInfo[8];
+ // UInt64 VolID;
+
+ UInt64 GetPhySize() const { return (UInt64)NumBlocks << BlockSizeLog; }
+ UInt64 GetFreeSize() const { return (UInt64)NumFreeBlocks << BlockSizeLog; }
+ bool IsHfsX() const { return Version > 4; }
+};
+
+inline void HfsTimeToFileTime(UInt32 hfsTime, FILETIME &ft)
+{
+ UInt64 v = ((UInt64)3600 * 24 * (365 * 303 + 24 * 3) + hfsTime) * 10000000;
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+enum ERecordType
+{
+ RECORD_TYPE_FOLDER = 1,
+ RECORD_TYPE_FILE,
+ RECORD_TYPE_FOLDER_THREAD,
+ RECORD_TYPE_FILE_THREAD
+};
+
+
+
+// static const UInt32 kMethod_1_NO_COMPRESSION = 1; // in xattr
+static const UInt32 kMethod_ZLIB_ATTR = 3;
+static const UInt32 kMethod_ZLIB_RSRC = 4;
+// static const UInt32 kMethod_DEDUP = 5; // de-dup within the generation store
+// macos 10.10
+static const UInt32 kMethod_LZVN_ATTR = 7;
+static const UInt32 kMethod_LZVN_RSRC = 8;
+static const UInt32 kMethod_COPY_ATTR = 9;
+static const UInt32 kMethod_COPY_RSRC = 10;
+// macos 10.11
+// static const UInt32 kMethod_LZFSE_ATTR = 11;
+static const UInt32 kMethod_LZFSE_RSRC = 12;
+
+// static const UInt32 kMethod_ZBM_RSRC = 14;
+
+static const char * const g_Methods[] =
+{
+ NULL
+ , NULL
+ , NULL
+ , "ZLIB-attr"
+ , "ZLIB-rsrc"
+ , NULL
+ , NULL
+ , "LZVN-attr"
+ , "LZVN-rsrc"
+ , "COPY-attr"
+ , "COPY-rsrc"
+ , "LZFSE-attr"
+ , "LZFSE-rsrc"
+ , NULL
+ , "ZBM-rsrc"
+};
+
+
+static const Byte k_COPY_Uncompressed_Marker = 0xcc;
+static const Byte k_LZVN_Uncompressed_Marker = 6;
+
+void CCompressHeader::Parse(const Byte *p, size_t dataSize)
+{
+ Clear();
+
+ if (dataSize < k_decmpfs_HeaderSize)
+ return;
+ if (GetUi32(p) != 0x636D7066) // magic == "fpmc"
+ return;
+ Method = GetUi32(p + 4);
+ UnpackSize = GetUi64(p + 8);
+ dataSize -= k_decmpfs_HeaderSize;
+ IsCorrect = true;
+
+ if ( Method == kMethod_ZLIB_RSRC
+ || Method == kMethod_COPY_RSRC
+ || Method == kMethod_LZVN_RSRC
+ || Method == kMethod_LZFSE_RSRC
+ // || Method == kMethod_ZBM_RSRC // for debug
+ )
+ {
+ IsResource = true;
+ if (dataSize == 0)
+ IsSupported = (
+ Method != kMethod_LZFSE_RSRC &&
+ Method != kMethod_COPY_RSRC);
+ return;
+ }
+
+ if ( Method == kMethod_ZLIB_ATTR
+ || Method == kMethod_COPY_ATTR
+ || Method == kMethod_LZVN_ATTR
+ // || Method == kMethod_LZFSE_ATTR
+ )
+ {
+ if (dataSize == 0)
+ return;
+ const Byte b = p[k_decmpfs_HeaderSize];
+ if ( (Method == kMethod_ZLIB_ATTR && (b & 0xf) == 0xf)
+ || (Method == kMethod_COPY_ATTR && b == k_COPY_Uncompressed_Marker)
+ || (Method == kMethod_LZVN_ATTR && b == k_LZVN_Uncompressed_Marker))
+ {
+ dataSize--;
+ // if (UnpackSize > dataSize)
+ if (UnpackSize != dataSize)
+ return;
+ DataPos = k_decmpfs_HeaderSize + 1;
+ IsSupported = true;
+ }
+ else
+ {
+ if (Method != kMethod_COPY_ATTR)
+ IsSupported = true;
+ DataPos = k_decmpfs_HeaderSize;
+ }
+ }
+}
+
+
+void CCompressHeader::MethodToProp(NWindows::NCOM::CPropVariant &prop) const
+{
+ if (!IsCorrect)
+ return;
+ const UInt32 method = Method;
+ const char *p = NULL;
+ if (method < Z7_ARRAY_SIZE(g_Methods))
+ p = g_Methods[method];
+ AString s;
+ if (p)
+ s = p;
+ else
+ s.Add_UInt32(method);
+ // if (!IsSupported) s += "-unsuported";
+ prop = s;
+}
+
+void MethodsMaskToProp(UInt32 methodsMask, NWindows::NCOM::CPropVariant &prop)
+{
+ FLAGS_TO_PROP(g_Methods, methodsMask, prop);
+}
+
+
+struct CItem
+{
+ UString Name;
+
+ UInt32 ParentID;
+
+ UInt16 Type;
+ UInt16 FileMode;
+ // UInt16 Flags;
+ // UInt32 Valence;
+ UInt32 ID;
+ UInt32 CTime;
+ UInt32 MTime;
+ UInt32 AttrMTime;
+ UInt32 ATime;
+ // UInt32 BackupDate;
+
+ /*
+ UInt32 OwnerID;
+ UInt32 GroupID;
+ Byte AdminFlags;
+ Byte OwnerFlags;
+ union
+ {
+ UInt32 iNodeNum;
+ UInt32 LinkCount;
+ UInt32 RawDevice;
+ } special;
+
+ UInt32 FileType;
+ UInt32 FileCreator;
+ UInt16 FinderFlags;
+ UInt16 Point[2];
+ */
+
+ CFork DataFork;
+ CFork ResourceFork;
+
+ // for compressed attribute (decmpfs)
+ int decmpfs_AttrIndex;
+ CCompressHeader CompressHeader;
+
+ CItem():
+ decmpfs_AttrIndex(-1)
+ {}
+ bool IsDir() const { return Type == RECORD_TYPE_FOLDER; }
+ // const CFork *GetFork(bool isResource) const { return (isResource ? &ResourceFork: &DataFork); }
+};
+
+
+struct CAttr
+{
+ UInt32 ID;
+ bool Fork_defined;
+
+ // UInt32 Size; // for (Fork_defined == false) case
+ // size_t DataPos; // for (Fork_defined == false) case
+ CByteBuffer Data;
+
+ CFork Fork;
+
+ UString Name;
+
+ UInt64 GetSize() const
+ {
+ if (Fork_defined)
+ return Fork.Size;
+ return Data.Size();
+ }
+
+ CAttr():
+ Fork_defined(false)
+ // Size(0),
+ // DataPos(0),
+ {}
+};
+
+
+static const int kAttrIndex_Item = -1;
+static const int kAttrIndex_Resource = -2;
+
+struct CRef
+{
+ unsigned ItemIndex;
+ int AttrIndex;
+ int Parent;
+
+ CRef(): AttrIndex(kAttrIndex_Item), Parent(-1) {}
+ bool IsResource() const { return AttrIndex == kAttrIndex_Resource; }
+ bool IsAltStream() const { return AttrIndex != kAttrIndex_Item; }
+ bool IsItem() const { return AttrIndex == kAttrIndex_Item; }
+};
+
+
+class CDatabase
+{
+ HRESULT ReadFile(const CFork &fork, CByteBuffer &buf, IInStream *inStream);
+ HRESULT LoadExtentFile(const CFork &fork, IInStream *inStream, CObjectVector<CIdExtents> *overflowExtentsArray);
+ HRESULT LoadAttrs(const CFork &fork, IInStream *inStream, IArchiveOpenCallback *progress);
+ HRESULT LoadCatalog(const CFork &fork, const CObjectVector<CIdExtents> *overflowExtentsArray, IInStream *inStream, IArchiveOpenCallback *progress);
+ bool Parse_decmpgfs(unsigned attrIndex, CItem &item, bool &skip);
+public:
+ CRecordVector<CRef> Refs;
+ CObjectVector<CItem> Items;
+ CObjectVector<CAttr> Attrs;
+
+ // CByteBuffer AttrBuf;
+
+ CVolHeader Header;
+ bool HeadersError;
+ bool UnsupportedFeature;
+ bool ThereAreAltStreams;
+ // bool CaseSensetive;
+ UString ResFileName;
+
+ UInt64 SpecOffset;
+ UInt64 PhySize;
+ UInt64 PhySize2;
+ UInt64 ArcFileSize;
+ UInt32 MethodsMask;
+
+ void Clear()
+ {
+ SpecOffset = 0;
+ PhySize = 0;
+ PhySize2 = 0;
+ ArcFileSize = 0;
+ MethodsMask = 0;
+ HeadersError = false;
+ UnsupportedFeature = false;
+ ThereAreAltStreams = false;
+ // CaseSensetive = false;
+
+ Refs.Clear();
+ Items.Clear();
+ Attrs.Clear();
+ // AttrBuf.Free();
+ }
+
+ UInt64 Get_UnpackSize_of_Ref(const CRef &ref) const
+ {
+ if (ref.AttrIndex >= 0)
+ return Attrs[ref.AttrIndex].GetSize();
+ const CItem &item = Items[ref.ItemIndex];
+ if (ref.IsResource())
+ return item.ResourceFork.Size;
+ if (item.IsDir())
+ return 0;
+ else if (item.CompressHeader.IsCorrect)
+ return item.CompressHeader.UnpackSize;
+ return item.DataFork.Size;
+ }
+
+ void GetItemPath(unsigned index, NWindows::NCOM::CPropVariant &path) const;
+ HRESULT Open2(IInStream *inStream, IArchiveOpenCallback *progress);
+};
+
+enum
+{
+ kHfsID_Root = 1,
+ kHfsID_RootFolder = 2,
+ kHfsID_ExtentsFile = 3,
+ kHfsID_CatalogFile = 4,
+ kHfsID_BadBlockFile = 5,
+ kHfsID_AllocationFile = 6,
+ kHfsID_StartupFile = 7,
+ kHfsID_AttributesFile = 8,
+ kHfsID_RepairCatalogFile = 14,
+ kHfsID_BogusExtentFile = 15,
+ kHfsID_FirstUserCatalogNode = 16
+};
+
+void CDatabase::GetItemPath(unsigned index, NWindows::NCOM::CPropVariant &path) const
+{
+ unsigned len = 0;
+ const unsigned kNumLevelsMax = (1 << 10);
+ unsigned cur = index;
+ unsigned i;
+
+ for (i = 0; i < kNumLevelsMax; i++)
+ {
+ const CRef &ref = Refs[cur];
+ const UString *s;
+
+ if (ref.IsResource())
+ s = &ResFileName;
+ else if (ref.AttrIndex >= 0)
+ s = &Attrs[ref.AttrIndex].Name;
+ else
+ s = &Items[ref.ItemIndex].Name;
+
+ len += s->Len();
+ len++;
+ cur = (unsigned)ref.Parent;
+ if (ref.Parent < 0)
+ break;
+ }
+
+ len--;
+ wchar_t *p = path.AllocBstr(len);
+ p[len] = 0;
+ cur = index;
+
+ for (;;)
+ {
+ const CRef &ref = Refs[cur];
+ const UString *s;
+ wchar_t delimChar = L':';
+
+ if (ref.IsResource())
+ s = &ResFileName;
+ else if (ref.AttrIndex >= 0)
+ s = &Attrs[ref.AttrIndex].Name;
+ else
+ {
+ delimChar = WCHAR_PATH_SEPARATOR;
+ s = &Items[ref.ItemIndex].Name;
+ }
+
+ unsigned curLen = s->Len();
+ len -= curLen;
+
+ const wchar_t *src = (const wchar_t *)*s;
+ wchar_t *dest = p + len;
+ for (unsigned j = 0; j < curLen; j++)
+ {
+ wchar_t c = src[j];
+ // 18.06
+ if (c == CHAR_PATH_SEPARATOR || c == '/')
+ c = '_';
+ dest[j] = c;
+ }
+
+ if (len == 0)
+ break;
+ p[--len] = delimChar;
+ cur = (unsigned)ref.Parent;
+ }
+}
+
+// Actually we read all blocks. It can be larger than fork.Size
+
+HRESULT CDatabase::ReadFile(const CFork &fork, CByteBuffer &buf, IInStream *inStream)
+{
+ if (fork.NumBlocks >= Header.NumBlocks)
+ return S_FALSE;
+ if ((ArcFileSize >> Header.BlockSizeLog) + 1 < fork.NumBlocks)
+ return S_FALSE;
+
+ const size_t totalSize = (size_t)fork.NumBlocks << Header.BlockSizeLog;
+ if ((totalSize >> Header.BlockSizeLog) != fork.NumBlocks)
+ return S_FALSE;
+ buf.Alloc(totalSize);
+ UInt32 curBlock = 0;
+ FOR_VECTOR (i, fork.Extents)
+ {
+ if (curBlock >= fork.NumBlocks)
+ return S_FALSE;
+ const CExtent &e = fork.Extents[i];
+ if (e.Pos > Header.NumBlocks ||
+ e.NumBlocks > fork.NumBlocks - curBlock ||
+ e.NumBlocks > Header.NumBlocks - e.Pos)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(inStream, SpecOffset + ((UInt64)e.Pos << Header.BlockSizeLog)))
+ RINOK(ReadStream_FALSE(inStream,
+ (Byte *)buf + ((size_t)curBlock << Header.BlockSizeLog),
+ (size_t)e.NumBlocks << Header.BlockSizeLog))
+ curBlock += e.NumBlocks;
+ }
+ return S_OK;
+}
+
+static const unsigned kNodeDescriptor_Size = 14;
+
+struct CNodeDescriptor
+{
+ UInt32 fLink;
+ // UInt32 bLink;
+ Byte Kind;
+ // Byte Height;
+ unsigned NumRecords;
+
+ bool Parse(const Byte *p, unsigned nodeSizeLog);
+};
+
+
+bool CNodeDescriptor::Parse(const Byte *p, unsigned nodeSizeLog)
+{
+ fLink = Get32(p);
+ // bLink = Get32(p + 4);
+ Kind = p[8];
+ // Height = p[9];
+ NumRecords = Get16(p + 10);
+
+ const size_t nodeSize = (size_t)1 << nodeSizeLog;
+ if (kNodeDescriptor_Size + ((UInt32)NumRecords + 1) * 2 > nodeSize)
+ return false;
+ const size_t limit = nodeSize - ((UInt32)NumRecords + 1) * 2;
+
+ p += nodeSize - 2;
+
+ for (unsigned i = 0; i < NumRecords; i++)
+ {
+ const UInt32 offs = Get16(p);
+ p -= 2;
+ const UInt32 offsNext = Get16(p);
+ if (offs < kNodeDescriptor_Size
+ || offs >= offsNext
+ || offsNext > limit)
+ return false;
+ }
+ return true;
+}
+
+struct CHeaderRec
+{
+ // UInt16 TreeDepth;
+ // UInt32 RootNode;
+ // UInt32 LeafRecords;
+ UInt32 FirstLeafNode;
+ // UInt32 LastLeafNode;
+ unsigned NodeSizeLog;
+ // UInt16 MaxKeyLength;
+ UInt32 TotalNodes;
+ // UInt32 FreeNodes;
+ // UInt16 Reserved1;
+ // UInt32 ClumpSize;
+ // Byte BtreeType;
+ // Byte KeyCompareType;
+ // UInt32 Attributes;
+ // UInt32 Reserved3[16];
+
+ HRESULT Parse2(const CByteBuffer &buf);
+};
+
+HRESULT CHeaderRec::Parse2(const CByteBuffer &buf)
+{
+ if (buf.Size() < kNodeDescriptor_Size + 0x2A + 16 * 4)
+ return S_FALSE;
+ const Byte * p = (const Byte *)buf + kNodeDescriptor_Size;
+ // TreeDepth = Get16(p);
+ // RootNode = Get32(p + 2);
+ // LeafRecords = Get32(p + 6);
+ FirstLeafNode = Get32(p + 0xA);
+ // LastLeafNode = Get32(p + 0xE);
+ const UInt32 nodeSize = Get16(p + 0x12);
+
+ unsigned i;
+ for (i = 9; ((UInt32)1 << i) != nodeSize; i++)
+ if (i == 16)
+ return S_FALSE;
+ NodeSizeLog = i;
+
+ // MaxKeyLength = Get16(p + 0x14);
+ TotalNodes = Get32(p + 0x16);
+ // FreeNodes = Get32(p + 0x1A);
+ // Reserved1 = Get16(p + 0x1E);
+ // ClumpSize = Get32(p + 0x20);
+ // BtreeType = p[0x24];
+ // KeyCompareType = p[0x25];
+ // Attributes = Get32(p + 0x26);
+ /*
+ for (int i = 0; i < 16; i++)
+ Reserved3[i] = Get32(p + 0x2A + i * 4);
+ */
+
+ if ((buf.Size() >> NodeSizeLog) < TotalNodes)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+static const Byte kNodeType_Leaf = 0xFF;
+// static const Byte kNodeType_Index = 0;
+// static const Byte kNodeType_Header = 1;
+// static const Byte kNodeType_Mode = 2;
+
+static const Byte kExtentForkType_Data = 0;
+static const Byte kExtentForkType_Resource = 0xFF;
+
+/* It loads data extents from Extents Overflow File
+ Most dmg installers are not fragmented. So there are no extents in Overflow File. */
+
+HRESULT CDatabase::LoadExtentFile(const CFork &fork, IInStream *inStream, CObjectVector<CIdExtents> *overflowExtentsArray)
+{
+ if (fork.NumBlocks == 0)
+ return S_OK;
+ CByteBuffer buf;
+ RINOK(ReadFile(fork, buf, inStream))
+ const Byte *p = (const Byte *)buf;
+
+ // CNodeDescriptor nodeDesc;
+ // nodeDesc.Parse(p);
+ CHeaderRec hr;
+ RINOK(hr.Parse2(buf))
+
+ UInt32 node = hr.FirstLeafNode;
+ if (node == 0)
+ return S_OK;
+ if (hr.TotalNodes == 0)
+ return S_FALSE;
+
+ CByteArr usedBuf(hr.TotalNodes);
+ memset(usedBuf, 0, hr.TotalNodes);
+
+ while (node != 0)
+ {
+ if (node >= hr.TotalNodes || usedBuf[node] != 0)
+ return S_FALSE;
+ usedBuf[node] = 1;
+
+ const size_t nodeOffset = (size_t)node << hr.NodeSizeLog;
+ CNodeDescriptor desc;
+ if (!desc.Parse(p + nodeOffset, hr.NodeSizeLog))
+ return S_FALSE;
+ if (desc.Kind != kNodeType_Leaf)
+ return S_FALSE;
+
+ UInt32 endBlock = 0;
+
+ for (unsigned i = 0; i < desc.NumRecords; i++)
+ {
+ const UInt32 nodeSize = ((UInt32)1 << hr.NodeSizeLog);
+ const Byte *r = p + nodeOffset + nodeSize - i * 2;
+ const UInt32 offs = Get16(r - 2);
+ UInt32 recSize = Get16(r - 4) - offs;
+ const unsigned kKeyLen = 10;
+
+ if (recSize != 2 + kKeyLen + kNumFixedExtents * 8)
+ return S_FALSE;
+
+ r = p + nodeOffset + offs;
+ if (Get16(r) != kKeyLen)
+ return S_FALSE;
+
+ const Byte forkType = r[2];
+ unsigned forkTypeIndex;
+ if (forkType == kExtentForkType_Data)
+ forkTypeIndex = 0;
+ else if (forkType == kExtentForkType_Resource)
+ forkTypeIndex = 1;
+ else
+ continue;
+ CObjectVector<CIdExtents> &overflowExtents = overflowExtentsArray[forkTypeIndex];
+
+ const UInt32 id = Get32(r + 4);
+ const UInt32 startBlock = Get32(r + 8);
+ r += 2 + kKeyLen;
+
+ bool needNew = true;
+
+ if (overflowExtents.Size() != 0)
+ {
+ CIdExtents &e = overflowExtents.Back();
+ if (e.ID == id)
+ {
+ if (endBlock != startBlock)
+ return S_FALSE;
+ needNew = false;
+ }
+ }
+
+ if (needNew)
+ {
+ CIdExtents &e = overflowExtents.AddNew();
+ e.ID = id;
+ e.StartBlock = startBlock;
+ endBlock = startBlock;
+ }
+
+ CIdExtents &e = overflowExtents.Back();
+
+ for (unsigned k = 0; k < kNumFixedExtents; k++, r += 8)
+ {
+ CExtent ee;
+ ee.Pos = Get32(r);
+ ee.NumBlocks = Get32(r + 4);
+ if (ee.NumBlocks != 0)
+ {
+ e.Extents.Add(ee);
+ endBlock += ee.NumBlocks;
+ }
+ }
+ }
+
+ node = desc.fLink;
+ }
+ return S_OK;
+}
+
+static void LoadName(const Byte *data, unsigned len, UString &dest)
+{
+ wchar_t *p = dest.GetBuf(len);
+ unsigned i;
+ for (i = 0; i < len; i++)
+ {
+ const wchar_t c = Get16(data + i * 2);
+ if (c == 0)
+ break;
+ p[i] = c;
+ }
+ p[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+}
+
+static bool IsNameEqualTo(const Byte *data, const char *name)
+{
+ for (unsigned i = 0;; i++)
+ {
+ const char c = name[i];
+ if (c == 0)
+ return true;
+ if (Get16(data + i * 2) != (Byte)c)
+ return false;
+ }
+}
+
+static const UInt32 kAttrRecordType_Inline = 0x10;
+static const UInt32 kAttrRecordType_Fork = 0x20;
+// static const UInt32 kAttrRecordType_Extents = 0x30;
+
+HRESULT CDatabase::LoadAttrs(const CFork &fork, IInStream *inStream, IArchiveOpenCallback *progress)
+{
+ if (fork.NumBlocks == 0)
+ return S_OK;
+
+ CByteBuffer AttrBuf;
+ RINOK(ReadFile(fork, AttrBuf, inStream))
+ const Byte *p = (const Byte *)AttrBuf;
+
+ // CNodeDescriptor nodeDesc;
+ // nodeDesc.Parse(p);
+ CHeaderRec hr;
+ RINOK(hr.Parse2(AttrBuf))
+
+ // CaseSensetive = (Header.IsHfsX() && hr.KeyCompareType == 0xBC);
+
+ UInt32 node = hr.FirstLeafNode;
+ if (node == 0)
+ return S_OK;
+ if (hr.TotalNodes == 0)
+ return S_FALSE;
+
+ CByteArr usedBuf(hr.TotalNodes);
+ memset(usedBuf, 0, hr.TotalNodes);
+
+ CFork resFork;
+
+ while (node != 0)
+ {
+ if (node >= hr.TotalNodes || usedBuf[node] != 0)
+ return S_FALSE;
+ usedBuf[node] = 1;
+
+ const size_t nodeOffset = (size_t)node << hr.NodeSizeLog;
+ CNodeDescriptor desc;
+ if (!desc.Parse(p + nodeOffset, hr.NodeSizeLog))
+ return S_FALSE;
+ if (desc.Kind != kNodeType_Leaf)
+ return S_FALSE;
+
+ for (unsigned i = 0; i < desc.NumRecords; i++)
+ {
+ const UInt32 nodeSize = ((UInt32)1 << hr.NodeSizeLog);
+ const Byte *r = p + nodeOffset + nodeSize - i * 2;
+ const UInt32 offs = Get16(r - 2);
+ UInt32 recSize = Get16(r - 4) - offs;
+ const unsigned kHeadSize = 14;
+ if (recSize < kHeadSize)
+ return S_FALSE;
+
+ r = p + nodeOffset + offs;
+ const UInt32 keyLen = Get16(r);
+
+ // UInt16 pad = Get16(r + 2);
+ const UInt32 fileID = Get32(r + 4);
+ const unsigned startBlock = Get32(r + 8);
+ if (startBlock != 0)
+ {
+ // that case is still unsupported
+ UnsupportedFeature = true;
+ continue;
+ }
+ const unsigned nameLen = Get16(r + 12);
+
+ if (keyLen + 2 > recSize ||
+ keyLen != kHeadSize - 2 + nameLen * 2)
+ return S_FALSE;
+ r += kHeadSize;
+ recSize -= kHeadSize;
+
+ const Byte *name = r;
+ r += nameLen * 2;
+ recSize -= nameLen * 2;
+
+ if (recSize < 4)
+ return S_FALSE;
+
+ const UInt32 recordType = Get32(r);
+
+ if (progress && (Attrs.Size() & 0xFFF) == 0)
+ {
+ const UInt64 numFiles = 0;
+ RINOK(progress->SetCompleted(&numFiles, NULL))
+ }
+
+ if (Attrs.Size() >= ((UInt32)1 << 31))
+ return S_FALSE;
+
+ CAttr &attr = Attrs.AddNew();
+ attr.ID = fileID;
+ LoadName(name, nameLen, attr.Name);
+
+ if (recordType == kAttrRecordType_Fork)
+ {
+ // 22.00 : some hfs files contain it;
+ /* spec: If the attribute has more than 8 extents, there will be additional
+ records (of type kAttrRecordType_Extents) for this attribute. */
+ if (recSize != 8 + kForkRecSize)
+ return S_FALSE;
+ if (Get32(r + 4) != 0) // reserved
+ return S_FALSE;
+ attr.Fork.Parse(r + 8);
+ attr.Fork_defined = true;
+ continue;
+ }
+ else if (recordType != kAttrRecordType_Inline)
+ {
+ UnsupportedFeature = true;
+ continue;
+ }
+
+ const unsigned kRecordHeaderSize = 16;
+ if (recSize < kRecordHeaderSize)
+ return S_FALSE;
+ if (Get32(r + 4) != 0 || Get32(r + 8) != 0) // reserved
+ return S_FALSE;
+ const UInt32 dataSize = Get32(r + 12);
+
+ r += kRecordHeaderSize;
+ recSize -= kRecordHeaderSize;
+
+ if (recSize < dataSize)
+ return S_FALSE;
+
+ attr.Data.CopyFrom(r, dataSize);
+ // attr.DataPos = nodeOffset + offs + 2 + keyLen + kRecordHeaderSize;
+ // attr.Size = dataSize;
+ }
+
+ node = desc.fLink;
+ }
+ return S_OK;
+}
+
+
+bool CDatabase::Parse_decmpgfs(unsigned attrIndex, CItem &item, bool &skip)
+{
+ const CAttr &attr = Attrs[attrIndex];
+ skip = false;
+ if (item.CompressHeader.IsCorrect || !item.DataFork.IsEmpty())
+ return false;
+
+ item.CompressHeader.Parse(attr.Data, attr.Data.Size());
+
+ if (item.CompressHeader.IsCorrect)
+ {
+ item.decmpfs_AttrIndex = (int)attrIndex;
+ skip = true;
+ if (item.CompressHeader.Method < sizeof(MethodsMask) * 8)
+ MethodsMask |= ((UInt32)1 << item.CompressHeader.Method);
+ }
+
+ return true;
+}
+
+
+HRESULT CDatabase::LoadCatalog(const CFork &fork, const CObjectVector<CIdExtents> *overflowExtentsArray, IInStream *inStream, IArchiveOpenCallback *progress)
+{
+ CByteBuffer buf;
+ RINOK(ReadFile(fork, buf, inStream))
+ const Byte *p = (const Byte *)buf;
+
+ // CNodeDescriptor nodeDesc;
+ // nodeDesc.Parse(p);
+ CHeaderRec hr;
+ RINOK(hr.Parse2(buf))
+
+ CRecordVector<CIdIndexPair> IdToIndexMap;
+
+ const unsigned reserveSize = (unsigned)(Header.NumFolders + 1 + Header.NumFiles);
+
+ const unsigned kBasicRecSize = 0x58;
+ const unsigned kMinRecSize = kBasicRecSize + 10;
+
+ if ((UInt64)reserveSize * kMinRecSize < buf.Size())
+ {
+ Items.ClearAndReserve(reserveSize);
+ Refs.ClearAndReserve(reserveSize);
+ IdToIndexMap.ClearAndReserve(reserveSize);
+ }
+
+ // CaseSensetive = (Header.IsHfsX() && hr.KeyCompareType == 0xBC);
+
+ CByteArr usedBuf(hr.TotalNodes);
+ if (hr.TotalNodes != 0)
+ memset(usedBuf, 0, hr.TotalNodes);
+
+ CFork resFork;
+
+ UInt32 node = hr.FirstLeafNode;
+ UInt32 numFiles = 0;
+ UInt32 numFolders = 0;
+
+ while (node != 0)
+ {
+ if (node >= hr.TotalNodes || usedBuf[node] != 0)
+ return S_FALSE;
+ usedBuf[node] = 1;
+
+ const size_t nodeOffset = (size_t)node << hr.NodeSizeLog;
+ CNodeDescriptor desc;
+ if (!desc.Parse(p + nodeOffset, hr.NodeSizeLog))
+ return S_FALSE;
+ if (desc.Kind != kNodeType_Leaf)
+ return S_FALSE;
+
+ for (unsigned i = 0; i < desc.NumRecords; i++)
+ {
+ const UInt32 nodeSize = (1 << hr.NodeSizeLog);
+ const Byte *r = p + nodeOffset + nodeSize - i * 2;
+ const UInt32 offs = Get16(r - 2);
+ UInt32 recSize = Get16(r - 4) - offs;
+ if (recSize < 6)
+ return S_FALSE;
+
+ r = p + nodeOffset + offs;
+ UInt32 keyLen = Get16(r);
+ UInt32 parentID = Get32(r + 2);
+ if (keyLen < 6 || (keyLen & 1) != 0 || keyLen + 2 > recSize)
+ return S_FALSE;
+ r += 6;
+ recSize -= 6;
+ keyLen -= 6;
+
+ unsigned nameLen = Get16(r);
+ if (nameLen * 2 != (unsigned)keyLen)
+ return S_FALSE;
+ r += 2;
+ recSize -= 2;
+
+ r += nameLen * 2;
+ recSize -= nameLen * 2;
+
+ if (recSize < 2)
+ return S_FALSE;
+ UInt16 type = Get16(r);
+
+ if (type != RECORD_TYPE_FOLDER &&
+ type != RECORD_TYPE_FILE)
+ continue;
+
+ if (recSize < kBasicRecSize)
+ return S_FALSE;
+
+ CItem &item = Items.AddNew();
+ item.ParentID = parentID;
+ item.Type = type;
+ // item.Flags = Get16(r + 2);
+ // item.Valence = Get32(r + 4);
+ item.ID = Get32(r + 8);
+ {
+ const Byte *name = r - (nameLen * 2);
+ LoadName(name, nameLen, item.Name);
+ if (item.Name.Len() <= 1)
+ {
+ if (item.Name.IsEmpty() && nameLen == 21)
+ {
+ if (GetUi32(name) == 0 &&
+ GetUi32(name + 4) == 0 &&
+ IsNameEqualTo(name + 8, "HFS+ Private Data"))
+ {
+ // it's folder for "Hard Links" files
+ item.Name = "[HFS+ Private Data]";
+ }
+ }
+
+ // Some dmg files have ' ' folder item.
+ if (item.Name.IsEmpty() || item.Name[0] == L' ')
+ item.Name = "[]";
+ }
+ }
+
+ item.CTime = Get32(r + 0xC);
+ item.MTime = Get32(r + 0x10);
+ item.AttrMTime = Get32(r + 0x14);
+ item.ATime = Get32(r + 0x18);
+ // item.BackupDate = Get32(r + 0x1C);
+
+ /*
+ item.OwnerID = Get32(r + 0x20);
+ item.GroupID = Get32(r + 0x24);
+ item.AdminFlags = r[0x28];
+ item.OwnerFlags = r[0x29];
+ */
+ item.FileMode = Get16(r + 0x2A);
+ /*
+ item.special.iNodeNum = Get16(r + 0x2C); // or .linkCount
+ item.FileType = Get32(r + 0x30);
+ item.FileCreator = Get32(r + 0x34);
+ item.FinderFlags = Get16(r + 0x38);
+ item.Point[0] = Get16(r + 0x3A); // v
+ item.Point[1] = Get16(r + 0x3C); // h
+ */
+
+ // const refIndex = Refs.Size();
+ CIdIndexPair pair;
+ pair.ID = item.ID;
+ pair.Index = Items.Size() - 1;
+ IdToIndexMap.Add(pair);
+
+ recSize -= kBasicRecSize;
+ r += kBasicRecSize;
+ if (item.IsDir())
+ {
+ numFolders++;
+ if (recSize != 0)
+ return S_FALSE;
+ }
+ else
+ {
+ numFiles++;
+ if (recSize != kForkRecSize * 2)
+ return S_FALSE;
+
+ item.DataFork.Parse(r);
+
+ if (!item.DataFork.UpgradeAndTest(overflowExtentsArray[0], item.ID, Header.BlockSizeLog))
+ HeadersError = true;
+
+ item.ResourceFork.Parse(r + kForkRecSize);
+ if (!item.ResourceFork.IsEmpty())
+ {
+ if (!item.ResourceFork.UpgradeAndTest(overflowExtentsArray[1], item.ID, Header.BlockSizeLog))
+ HeadersError = true;
+ // ThereAreAltStreams = true;
+ }
+ }
+ if (progress && (Items.Size() & 0xFFF) == 0)
+ {
+ const UInt64 numItems = Items.Size();
+ RINOK(progress->SetCompleted(&numItems, NULL))
+ }
+ }
+ node = desc.fLink;
+ }
+
+ if (Header.NumFiles != numFiles ||
+ Header.NumFolders + 1 != numFolders)
+ HeadersError = true;
+
+ IdToIndexMap.Sort2();
+ {
+ for (unsigned i = 1; i < IdToIndexMap.Size(); i++)
+ if (IdToIndexMap[i - 1].ID == IdToIndexMap[i].ID)
+ return S_FALSE;
+ }
+
+
+ CBoolArr skipAttr(Attrs.Size());
+ {
+ for (unsigned i = 0; i < Attrs.Size(); i++)
+ skipAttr[i] = false;
+ }
+
+ {
+ FOR_VECTOR (i, Attrs)
+ {
+ const CAttr &attr = Attrs[i];
+
+ const int itemIndex = FindItemIndex(IdToIndexMap, attr.ID);
+ if (itemIndex < 0)
+ {
+ HeadersError = true;
+ continue;
+ }
+
+ if (attr.Name.IsEqualTo("com.apple.decmpfs"))
+ {
+ if (!Parse_decmpgfs(i, Items[itemIndex], skipAttr[i]))
+ HeadersError = true;
+ }
+ }
+ }
+
+ IdToIndexMap.ClearAndReserve(Items.Size());
+
+ {
+ FOR_VECTOR (i, Items)
+ {
+ const CItem &item = Items[i];
+
+ CIdIndexPair pair;
+ pair.ID = item.ID;
+ pair.Index = Refs.Size();
+ IdToIndexMap.Add(pair);
+
+ CRef ref;
+ ref.ItemIndex = i;
+ Refs.Add(ref);
+
+ #ifdef HFS_SHOW_ALT_STREAMS
+
+ if (item.ResourceFork.IsEmpty())
+ continue;
+ if (item.CompressHeader.IsSupported && item.CompressHeader.IsMethod_Resource())
+ continue;
+
+ ThereAreAltStreams = true;
+ ref.AttrIndex = kAttrIndex_Resource;
+ ref.Parent = (int)(Refs.Size() - 1);
+ Refs.Add(ref);
+
+ #endif
+ }
+ }
+
+ IdToIndexMap.Sort2();
+
+ {
+ FOR_VECTOR (i, Refs)
+ {
+ CRef &ref = Refs[i];
+ if (ref.IsResource())
+ continue;
+ const CItem &item = Items[ref.ItemIndex];
+ ref.Parent = FindItemIndex(IdToIndexMap, item.ParentID);
+ if (ref.Parent >= 0)
+ {
+ if (!Items[Refs[ref.Parent].ItemIndex].IsDir())
+ {
+ ref.Parent = -1;
+ HeadersError = true;
+ }
+ }
+ }
+ }
+
+ #ifdef HFS_SHOW_ALT_STREAMS
+ {
+ FOR_VECTOR (i, Attrs)
+ {
+ if (skipAttr[i])
+ continue;
+ const CAttr &attr = Attrs[i];
+
+ const int refIndex = FindItemIndex(IdToIndexMap, attr.ID);
+ if (refIndex < 0)
+ {
+ HeadersError = true;
+ continue;
+ }
+
+ ThereAreAltStreams = true;
+
+ CRef ref;
+ ref.AttrIndex = (int)i;
+ ref.Parent = refIndex;
+ ref.ItemIndex = Refs[refIndex].ItemIndex;
+ Refs.Add(ref);
+ }
+ }
+ #endif
+
+ return S_OK;
+}
+
+static const unsigned kHeaderPadSize = (1 << 10);
+static const unsigned kMainHeaderSize = 512;
+static const unsigned kHfsHeaderSize = kHeaderPadSize + kMainHeaderSize;
+
+API_FUNC_static_IsArc IsArc_HFS(const Byte *p, size_t size)
+{
+ if (size < kHfsHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ p += kHeaderPadSize;
+ if (p[0] == 'B' && p[1] == 'D')
+ {
+ if (p[0x7C] != 'H' || p[0x7C + 1] != '+')
+ return k_IsArc_Res_NO;
+ }
+ else
+ {
+ if (p[0] != 'H' || (p[1] != '+' && p[1] != 'X'))
+ return k_IsArc_Res_NO;
+ UInt32 version = Get16(p + 2);
+ if (version < 4 || version > 5)
+ return k_IsArc_Res_NO;
+ }
+ return k_IsArc_Res_YES;
+}
+}
+
+HRESULT CDatabase::Open2(IInStream *inStream, IArchiveOpenCallback *progress)
+{
+ Clear();
+ Byte buf[kHfsHeaderSize];
+ RINOK(ReadStream_FALSE(inStream, buf, kHfsHeaderSize))
+ {
+ for (unsigned i = 0; i < kHeaderPadSize; i++)
+ if (buf[i] != 0)
+ return S_FALSE;
+ }
+ const Byte *p = buf + kHeaderPadSize;
+ CVolHeader &h = Header;
+
+ h.Header[0] = p[0];
+ h.Header[1] = p[1];
+
+ if (p[0] == 'B' && p[1] == 'D')
+ {
+ /*
+ It's header for old HFS format.
+ We don't support old HFS format, but we support
+ special HFS volume that contains embedded HFS+ volume
+ */
+
+ if (p[0x7C] != 'H' || p[0x7C + 1] != '+')
+ return S_FALSE;
+
+ /*
+ h.CTime = Get32(p + 0x2);
+ h.MTime = Get32(p + 0x6);
+
+ h.NumFiles = Get32(p + 0x54);
+ h.NumFolders = Get32(p + 0x58);
+
+ if (h.NumFolders > ((UInt32)1 << 29) ||
+ h.NumFiles > ((UInt32)1 << 30))
+ return S_FALSE;
+ if (progress)
+ {
+ UInt64 numFiles = (UInt64)h.NumFiles + h.NumFolders + 1;
+ RINOK(progress->SetTotal(&numFiles, NULL))
+ }
+ h.NumFreeBlocks = Get16(p + 0x22);
+ */
+
+ UInt32 blockSize = Get32(p + 0x14);
+
+ {
+ unsigned i;
+ for (i = 9; ((UInt32)1 << i) != blockSize; i++)
+ if (i == 31)
+ return S_FALSE;
+ h.BlockSizeLog = i;
+ }
+
+ h.NumBlocks = Get16(p + 0x12);
+ /*
+ we suppose that it has the follwing layout
+ {
+ start block with header
+ [h.NumBlocks]
+ end block with header
+ }
+ */
+ PhySize2 = ((UInt64)h.NumBlocks + 2) << h.BlockSizeLog;
+
+ UInt32 startBlock = Get16(p + 0x7C + 2);
+ UInt32 blockCount = Get16(p + 0x7C + 4);
+ SpecOffset = (UInt64)(1 + startBlock) << h.BlockSizeLog;
+ UInt64 phy = SpecOffset + ((UInt64)blockCount << h.BlockSizeLog);
+ if (PhySize2 < phy)
+ PhySize2 = phy;
+ RINOK(InStream_SeekSet(inStream, SpecOffset))
+ RINOK(ReadStream_FALSE(inStream, buf, kHfsHeaderSize))
+ }
+
+ if (p[0] != 'H' || (p[1] != '+' && p[1] != 'X'))
+ return S_FALSE;
+ h.Version = Get16(p + 2);
+ if (h.Version < 4 || h.Version > 5)
+ return S_FALSE;
+
+ // h.Attr = Get32(p + 4);
+ // h.LastMountedVersion = Get32(p + 8);
+ // h.JournalInfoBlock = Get32(p + 0xC);
+
+ h.CTime = Get32(p + 0x10);
+ h.MTime = Get32(p + 0x14);
+ // h.BackupTime = Get32(p + 0x18);
+ // h.CheckedTime = Get32(p + 0x1C);
+
+ h.NumFiles = Get32(p + 0x20);
+ h.NumFolders = Get32(p + 0x24);
+
+ if (h.NumFolders > ((UInt32)1 << 29) ||
+ h.NumFiles > ((UInt32)1 << 30))
+ return S_FALSE;
+
+ RINOK(InStream_GetSize_SeekToEnd(inStream, ArcFileSize))
+
+ if (progress)
+ {
+ const UInt64 numFiles = (UInt64)h.NumFiles + h.NumFolders + 1;
+ RINOK(progress->SetTotal(&numFiles, NULL))
+ }
+
+ UInt32 blockSize = Get32(p + 0x28);
+
+ {
+ unsigned i;
+ for (i = 9; ((UInt32)1 << i) != blockSize; i++)
+ if (i == 31)
+ return S_FALSE;
+ h.BlockSizeLog = i;
+ }
+
+ h.NumBlocks = Get32(p + 0x2C);
+ h.NumFreeBlocks = Get32(p + 0x30);
+
+ /*
+ h.NextCalatlogNodeID = Get32(p + 0x40);
+ h.WriteCount = Get32(p + 0x44);
+ for (i = 0; i < 6; i++)
+ h.FinderInfo[i] = Get32(p + 0x50 + i * 4);
+ h.VolID = Get64(p + 0x68);
+ */
+
+ ResFileName = kResFileName;
+
+ CFork extentsFork, catalogFork, attrFork;
+ // allocationFork.Parse(p + 0x70 + 0x50 * 0);
+ extentsFork.Parse(p + 0x70 + 0x50 * 1);
+ catalogFork.Parse(p + 0x70 + 0x50 * 2);
+ attrFork.Parse (p + 0x70 + 0x50 * 3);
+ // startupFork.Parse(p + 0x70 + 0x50 * 4);
+
+ CObjectVector<CIdExtents> overflowExtents[2];
+ if (!extentsFork.IsOk(Header.BlockSizeLog))
+ HeadersError = true;
+ else
+ {
+ HRESULT res = LoadExtentFile(extentsFork, inStream, overflowExtents);
+ if (res == S_FALSE)
+ HeadersError = true;
+ else if (res != S_OK)
+ return res;
+ }
+
+ if (!catalogFork.UpgradeAndTest(overflowExtents[0], kHfsID_CatalogFile, Header.BlockSizeLog))
+ return S_FALSE;
+
+ if (!attrFork.UpgradeAndTest(overflowExtents[0], kHfsID_AttributesFile, Header.BlockSizeLog))
+ HeadersError = true;
+ else
+ {
+ if (attrFork.Size != 0)
+ RINOK(LoadAttrs(attrFork, inStream, progress))
+ }
+
+ RINOK(LoadCatalog(catalogFork, overflowExtents, inStream, progress))
+
+ PhySize = Header.GetPhySize();
+ return S_OK;
+}
+
+
+
+Z7_class_CHandler_final:
+ public IInArchive,
+ public IArchiveGetRawProps,
+ public IInArchiveGetStream,
+ public CMyUnknownImp,
+ public CDatabase
+{
+ Z7_IFACES_IMP_UNK_3(
+ IInArchive,
+ IArchiveGetRawProps,
+ IInArchiveGetStream)
+
+ CMyComPtr<IInStream> _stream;
+ HRESULT GetForkStream(const CFork &fork, ISequentialInStream **stream);
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidCTime,
+ kpidMTime,
+ kpidATime,
+ kpidChangeTime,
+ kpidPosixAttrib,
+ /*
+ kpidUserId,
+ kpidGroupId,
+ */
+#ifdef HFS_SHOW_ALT_STREAMS
+ kpidIsAltStream,
+#endif
+ kpidMethod
+};
+
+static const Byte kArcProps[] =
+{
+ kpidMethod,
+ kpidCharacts,
+ kpidClusterSize,
+ kpidFreeSpace,
+ kpidCTime,
+ kpidMTime
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static void HfsTimeToProp(UInt32 hfsTime, NWindows::NCOM::CPropVariant &prop)
+{
+ if (hfsTime == 0)
+ return;
+ FILETIME ft;
+ HfsTimeToFileTime(hfsTime, ft);
+ prop.SetAsTimeFrom_FT_Prec(ft, k_PropVar_TimePrec_Base);
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidExtension: prop = Header.IsHfsX() ? "hfsx" : "hfs"; break;
+ case kpidMethod: prop = Header.IsHfsX() ? "HFSX" : "HFS+"; break;
+ case kpidCharacts: MethodsMaskToProp(MethodsMask, prop); break;
+ case kpidPhySize:
+ {
+ UInt64 v = SpecOffset + PhySize;
+ if (v < PhySize2)
+ v = PhySize2;
+ prop = v;
+ break;
+ }
+ case kpidClusterSize: prop = (UInt32)1 << Header.BlockSizeLog; break;
+ case kpidFreeSpace: prop = (UInt64)Header.GetFreeSize(); break;
+ case kpidMTime: HfsTimeToProp(Header.MTime, prop); break;
+ case kpidCTime:
+ {
+ if (Header.CTime != 0)
+ {
+ FILETIME localFt, ft;
+ HfsTimeToFileTime(Header.CTime, localFt);
+ if (LocalFileTimeToFileTime(&localFt, &ft))
+ prop.SetAsTimeFrom_FT_Prec(ft, k_PropVar_TimePrec_Base);
+ }
+ break;
+ }
+ case kpidIsTree: prop = true; break;
+ case kpidErrorFlags:
+ {
+ UInt32 flags = 0;
+ if (HeadersError) flags |= kpv_ErrorFlags_HeadersError;
+ if (UnsupportedFeature) flags |= kpv_ErrorFlags_UnsupportedFeature;
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ case kpidIsAltStream: prop = ThereAreAltStreams; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID))
+{
+ *name = NULL;
+ *propID = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+ const CRef &ref = Refs[index];
+ *parentType = ref.IsAltStream() ?
+ NParentType::kAltStream :
+ NParentType::kDir;
+ *parent = (UInt32)(Int32)ref.Parent;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ #ifdef MY_CPU_LE
+ if (propID == kpidName)
+ {
+ const CRef &ref = Refs[index];
+ const UString *s;
+ if (ref.IsResource())
+ s = &ResFileName;
+ else if (ref.AttrIndex >= 0)
+ s = &Attrs[ref.AttrIndex].Name;
+ else
+ s = &Items[ref.ItemIndex].Name;
+ *data = (const wchar_t *)(*s);
+ *dataSize = (s->Len() + 1) * (UInt32)sizeof(wchar_t);
+ *propType = PROP_DATA_TYPE_wchar_t_PTR_Z_LE;
+ return S_OK;
+ }
+ #else
+ UNUSED_VAR(index);
+ UNUSED_VAR(propID);
+ #endif
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CRef &ref = Refs[index];
+ const CItem &item = Items[ref.ItemIndex];
+ switch (propID)
+ {
+ case kpidPath: GetItemPath(index, prop); break;
+ case kpidName:
+ {
+ const UString *s;
+ if (ref.IsResource())
+ s = &ResFileName;
+ else if (ref.AttrIndex >= 0)
+ s = &Attrs[ref.AttrIndex].Name;
+ else
+ s = &item.Name;
+ prop = *s;
+ break;
+ }
+ case kpidPackSize:
+ {
+ UInt64 size;
+ if (ref.AttrIndex >= 0)
+ size = Attrs[ref.AttrIndex].GetSize();
+ else if (ref.IsResource())
+ size = (UInt64)item.ResourceFork.NumBlocks << Header.BlockSizeLog;
+ else if (item.IsDir())
+ break;
+ else if (item.CompressHeader.IsCorrect)
+ {
+ if (item.CompressHeader.IsMethod_Resource())
+ size = (UInt64)item.ResourceFork.NumBlocks << Header.BlockSizeLog;
+ else if (item.decmpfs_AttrIndex >= 0)
+ {
+ // size = item.PackSize;
+ const CAttr &attr = Attrs[item.decmpfs_AttrIndex];
+ size = attr.Data.Size() - item.CompressHeader.DataPos;
+ }
+ else
+ size = 0;
+ }
+ else
+ size = (UInt64)item.DataFork.NumBlocks << Header.BlockSizeLog;
+ prop = size;
+ break;
+ }
+ case kpidSize:
+ {
+ UInt64 size;
+ if (ref.AttrIndex >= 0)
+ size = Attrs[ref.AttrIndex].GetSize();
+ else if (ref.IsResource())
+ size = item.ResourceFork.Size;
+ else if (item.IsDir())
+ break;
+ else if (item.CompressHeader.IsCorrect)
+ size = item.CompressHeader.UnpackSize;
+ else
+ size = item.DataFork.Size;
+ prop = size;
+ break;
+ }
+ case kpidIsDir: prop = (ref.IsItem() && item.IsDir()); break;
+ case kpidIsAltStream: prop = ref.IsAltStream(); break;
+ case kpidCTime: HfsTimeToProp(item.CTime, prop); break;
+ case kpidMTime: HfsTimeToProp(item.MTime, prop); break;
+ case kpidATime: HfsTimeToProp(item.ATime, prop); break;
+ case kpidChangeTime: HfsTimeToProp(item.AttrMTime, prop); break;
+ case kpidPosixAttrib: if (ref.IsItem()) prop = (UInt32)item.FileMode; break;
+ /*
+ case kpidUserId: prop = (UInt32)item.OwnerID; break;
+ case kpidGroupId: prop = (UInt32)item.GroupID; break;
+ */
+
+ case kpidMethod:
+ if (ref.IsItem())
+ item.CompressHeader.MethodToProp(prop);
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(Open2(inStream, callback))
+ _stream = inStream;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _stream.Release();
+ Clear();
+ return S_OK;
+}
+
+static const UInt32 kCompressionBlockSize = 1 << 16;
+
+CDecoder::CDecoder()
+{
+ _zlibDecoderSpec = new NCompress::NZlib::CDecoder();
+ _zlibDecoder = _zlibDecoderSpec;
+
+ _lzfseDecoderSpec = new NCompress::NLzfse::CDecoder();
+ _lzfseDecoder = _lzfseDecoderSpec;
+ _lzfseDecoderSpec->LzvnMode = true;
+}
+
+HRESULT CDecoder::ExtractResourceFork_ZLIB(
+ ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ UInt64 forkSize, UInt64 unpackSize,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback)
+{
+ const unsigned kHeaderSize = 0x100 + 8;
+
+ const size_t kBufSize = kCompressionBlockSize;
+ _buf.Alloc(kBufSize + 0x10); // we need 1 additional bytes for uncompressed chunk header
+
+ RINOK(ReadStream_FALSE(inStream, _buf, kHeaderSize))
+ Byte *buf = _buf;
+ const UInt32 dataPos = Get32(buf);
+ const UInt32 mapPos = Get32(buf + 4);
+ const UInt32 dataSize = Get32(buf + 8);
+ const UInt32 mapSize = Get32(buf + 12);
+
+ const UInt32 kResMapSize = 50;
+
+ if (mapSize != kResMapSize
+ || dataPos > mapPos
+ || dataSize != mapPos - dataPos
+ || mapSize > forkSize
+ || mapPos != forkSize - mapSize)
+ return S_FALSE;
+
+ const UInt32 dataSize2 = Get32(buf + 0x100);
+ if (4 + dataSize2 != dataSize
+ || dataSize2 < 8
+ || dataSize2 > dataSize)
+ return S_FALSE;
+
+ const UInt32 numBlocks = GetUi32(buf + 0x100 + 4);
+ if (((dataSize2 - 4) >> 3) < numBlocks)
+ return S_FALSE;
+ {
+ const UInt64 up = unpackSize + kCompressionBlockSize - 1;
+ if (up < unpackSize || up / kCompressionBlockSize != numBlocks)
+ return S_FALSE;
+ }
+
+ const UInt32 tableSize = (numBlocks << 3);
+
+ _tableBuf.AllocAtLeast(tableSize);
+
+ RINOK(ReadStream_FALSE(inStream, _tableBuf, tableSize))
+ const Byte *tableBuf = _tableBuf;
+
+ UInt32 prev = 4 + tableSize;
+
+ UInt32 i;
+ for (i = 0; i < numBlocks; i++)
+ {
+ const UInt32 offs = GetUi32(tableBuf + i * 8);
+ const UInt32 size = GetUi32(tableBuf + i * 8 + 4);
+ if (size == 0
+ || prev != offs
+ || offs > dataSize2
+ || size > dataSize2 - offs)
+ return S_FALSE;
+ prev = offs + size;
+ }
+
+ if (prev != dataSize2)
+ return S_FALSE;
+
+ CBufInStream *bufInStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> bufInStream = bufInStreamSpec;
+
+ // bool padError = false;
+ UInt64 outPos = 0;
+
+ for (i = 0; i < numBlocks; i++)
+ {
+ const UInt64 rem = unpackSize - outPos;
+ if (rem == 0)
+ return S_FALSE;
+ UInt32 blockSize = kCompressionBlockSize;
+ if (rem < kCompressionBlockSize)
+ blockSize = (UInt32)rem;
+
+ const UInt32 size = GetUi32(tableBuf + i * 8 + 4);
+
+ if (size > kCompressionBlockSize + 1)
+ return S_FALSE;
+
+ RINOK(ReadStream_FALSE(inStream, buf, size))
+
+ if ((buf[0] & 0xF) == 0xF)
+ {
+ // (buf[0] = 0xff) is marker of uncompressed block in APFS
+ // that code was not tested in HFS
+ if (size - 1 != blockSize)
+ return S_FALSE;
+
+ if (outStream)
+ {
+ RINOK(WriteStream(outStream, buf + 1, blockSize))
+ }
+ }
+ else
+ {
+ const UInt64 blockSize64 = blockSize;
+ bufInStreamSpec->Init(buf, size);
+ RINOK(_zlibDecoder->Code(bufInStream, outStream, NULL, &blockSize64, NULL))
+ if (_zlibDecoderSpec->GetOutputProcessedSize() != blockSize)
+ return S_FALSE;
+ const UInt64 inSize = _zlibDecoderSpec->GetInputProcessedSize();
+ if (inSize != size)
+ {
+ if (inSize > size)
+ return S_FALSE;
+ // apfs file can contain junk (non-zeros) after data block.
+ /*
+ if (!padError)
+ {
+ const Byte *p = buf + (UInt32)inSize;
+ const Byte *e = p + (size - (UInt32)inSize);
+ do
+ {
+ if (*p != 0)
+ {
+ padError = true;
+ break;
+ }
+ }
+ while (++p != e);
+ }
+ */
+ }
+ }
+
+ outPos += blockSize;
+ if ((i & 0xFF) == 0)
+ {
+ const UInt64 progressPos = progressStart + outPos;
+ RINOK(extractCallback->SetCompleted(&progressPos))
+ }
+ }
+
+ if (outPos != unpackSize)
+ return S_FALSE;
+
+ // if (padError) return S_FALSE;
+
+ /* We check Resource Map
+ Are there HFS files with another values in Resource Map ??? */
+
+ RINOK(ReadStream_FALSE(inStream, buf, mapSize))
+ const UInt32 types = Get16(buf + 24);
+ const UInt32 names = Get16(buf + 26);
+ const UInt32 numTypes = Get16(buf + 28);
+ if (numTypes != 0 || types != 28 || names != kResMapSize)
+ return S_FALSE;
+ const UInt32 resType = Get32(buf + 30);
+ const UInt32 numResources = Get16(buf + 34);
+ const UInt32 resListOffset = Get16(buf + 36);
+ if (resType != 0x636D7066) // cmpf
+ return S_FALSE;
+ if (numResources != 0 || resListOffset != 10)
+ return S_FALSE;
+
+ const UInt32 entryId = Get16(buf + 38);
+ const UInt32 nameOffset = Get16(buf + 40);
+ // Byte attrib = buf[42];
+ const UInt32 resourceOffset = Get32(buf + 42) & 0xFFFFFF;
+ if (entryId != 1 || nameOffset != 0xFFFF || resourceOffset != 0)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+
+HRESULT CDecoder::ExtractResourceFork_LZFSE(
+ ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ UInt64 forkSize, UInt64 unpackSize,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback)
+{
+ const UInt32 kNumBlocksMax = (UInt32)1 << 29;
+ if (unpackSize >= (UInt64)kNumBlocksMax * kCompressionBlockSize)
+ return S_FALSE;
+ const UInt32 numBlocks = (UInt32)((unpackSize + kCompressionBlockSize - 1) / kCompressionBlockSize);
+ const UInt32 numBlocks2 = numBlocks + 1;
+ const UInt32 tableSize = (numBlocks2 << 2);
+ if (tableSize > forkSize)
+ return S_FALSE;
+ _tableBuf.AllocAtLeast(tableSize);
+ RINOK(ReadStream_FALSE(inStream, _tableBuf, tableSize))
+ const Byte *tableBuf = _tableBuf;
+
+ {
+ UInt32 prev = GetUi32(tableBuf);
+ if (prev != tableSize)
+ return S_FALSE;
+ for (UInt32 i = 1; i < numBlocks2; i++)
+ {
+ const UInt32 offs = GetUi32(tableBuf + i * 4);
+ if (offs <= prev)
+ return S_FALSE;
+ prev = offs;
+ }
+ if (prev != forkSize)
+ return S_FALSE;
+ }
+
+ const size_t kBufSize = kCompressionBlockSize;
+ _buf.Alloc(kBufSize + 0x10); // we need 1 additional bytes for uncompressed chunk header
+
+ CBufInStream *bufInStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> bufInStream = bufInStreamSpec;
+
+ UInt64 outPos = 0;
+
+ for (UInt32 i = 0; i < numBlocks; i++)
+ {
+ const UInt64 rem = unpackSize - outPos;
+ if (rem == 0)
+ return S_FALSE;
+ UInt32 blockSize = kCompressionBlockSize;
+ if (rem < kCompressionBlockSize)
+ blockSize = (UInt32)rem;
+
+ const UInt32 size =
+ GetUi32(tableBuf + i * 4 + 4) -
+ GetUi32(tableBuf + i * 4);
+
+ if (size > kCompressionBlockSize + 1)
+ return S_FALSE;
+
+ RINOK(ReadStream_FALSE(inStream, _buf, size))
+ const Byte *buf = _buf;
+
+ if (buf[0] == k_LZVN_Uncompressed_Marker)
+ {
+ if (size - 1 != blockSize)
+ return S_FALSE;
+ if (outStream)
+ {
+ RINOK(WriteStream(outStream, buf + 1, blockSize))
+ }
+ }
+ else
+ {
+ const UInt64 blockSize64 = blockSize;
+ const UInt64 packSize64 = size;
+ bufInStreamSpec->Init(buf, size);
+ RINOK(_lzfseDecoder->Code(bufInStream, outStream, &packSize64, &blockSize64, NULL))
+ // in/out sizes were checked in Code()
+ }
+
+ outPos += blockSize;
+ if ((i & 0xFF) == 0)
+ {
+ const UInt64 progressPos = progressStart + outPos;
+ RINOK(extractCallback->SetCompleted(&progressPos))
+ }
+ }
+
+ return S_OK;
+}
+
+
+/*
+static UInt32 GetUi24(const Byte *p)
+{
+ return p[0] + ((UInt32)p[1] << 8) + ((UInt32)p[2] << 24);
+}
+
+HRESULT CDecoder::ExtractResourceFork_ZBM(
+ ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ UInt64 forkSize, UInt64 unpackSize,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback)
+{
+ const UInt32 kNumBlocksMax = (UInt32)1 << 29;
+ if (unpackSize >= (UInt64)kNumBlocksMax * kCompressionBlockSize)
+ return S_FALSE;
+ const UInt32 numBlocks = (UInt32)((unpackSize + kCompressionBlockSize - 1) / kCompressionBlockSize);
+ const UInt32 numBlocks2 = numBlocks + 1;
+ const UInt32 tableSize = (numBlocks2 << 2);
+ if (tableSize > forkSize)
+ return S_FALSE;
+ _tableBuf.AllocAtLeast(tableSize);
+ RINOK(ReadStream_FALSE(inStream, _tableBuf, tableSize));
+ const Byte *tableBuf = _tableBuf;
+
+ {
+ UInt32 prev = GetUi32(tableBuf);
+ if (prev != tableSize)
+ return S_FALSE;
+ for (UInt32 i = 1; i < numBlocks2; i++)
+ {
+ const UInt32 offs = GetUi32(tableBuf + i * 4);
+ if (offs <= prev)
+ return S_FALSE;
+ prev = offs;
+ }
+ if (prev != forkSize)
+ return S_FALSE;
+ }
+
+ const size_t kBufSize = kCompressionBlockSize;
+ _buf.Alloc(kBufSize + 0x10); // we need 1 additional bytes for uncompressed chunk header
+
+ CBufInStream *bufInStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> bufInStream = bufInStreamSpec;
+
+ UInt64 outPos = 0;
+
+ for (UInt32 i = 0; i < numBlocks; i++)
+ {
+ const UInt64 rem = unpackSize - outPos;
+ if (rem == 0)
+ return S_FALSE;
+ UInt32 blockSize = kCompressionBlockSize;
+ if (rem < kCompressionBlockSize)
+ blockSize = (UInt32)rem;
+
+ const UInt32 size =
+ GetUi32(tableBuf + i * 4 + 4) -
+ GetUi32(tableBuf + i * 4);
+
+ // if (size > kCompressionBlockSize + 1)
+ if (size > blockSize + 1)
+ return S_FALSE; // we don't expect it, because encode will use uncompressed chunk
+
+ RINOK(ReadStream_FALSE(inStream, _buf, size));
+ const Byte *buf = _buf;
+
+ // (size != 0)
+ // if (size == 0) return S_FALSE;
+
+ if (buf[0] == 0xFF) // uncompressed marker
+ {
+ if (size != blockSize + 1)
+ return S_FALSE;
+ if (outStream)
+ {
+ RINOK(WriteStream(outStream, buf + 1, blockSize));
+ }
+ }
+ else
+ {
+ if (size < 4)
+ return S_FALSE;
+ if (buf[0] != 'Z' ||
+ buf[1] != 'B' ||
+ buf[2] != 'M' ||
+ buf[3] != 9)
+ return S_FALSE;
+ // for debug:
+ unsigned packPos = 4;
+ unsigned unpackPos = 0;
+ unsigned packRem = size - packPos;
+ for (;;)
+ {
+ if (packRem < 6)
+ return S_FALSE;
+ const UInt32 packSize = GetUi24(buf + packPos);
+ const UInt32 chunkUnpackSize = GetUi24(buf + packPos + 3);
+ if (packSize < 6)
+ return S_FALSE;
+ if (packSize > packRem)
+ return S_FALSE;
+ if (chunkUnpackSize > blockSize - unpackPos)
+ return S_FALSE;
+ packPos += packSize;
+ packRem -= packSize;
+ unpackPos += chunkUnpackSize;
+ if (packSize == 6)
+ {
+ if (chunkUnpackSize != 0)
+ return S_FALSE;
+ break;
+ }
+ if (packSize >= chunkUnpackSize + 6)
+ {
+ if (packSize > chunkUnpackSize + 6)
+ return S_FALSE;
+ // uncompressed chunk;
+ }
+ else
+ {
+ // compressed chunk
+ const Byte *t = buf + packPos - packSize + 6;
+ UInt32 r = packSize - 6;
+ if (r < 9)
+ return S_FALSE;
+ const UInt32 v0 = GetUi24(t);
+ const UInt32 v1 = GetUi24(t + 3);
+ const UInt32 v2 = GetUi24(t + 6);
+ if (v0 > v1 || v1 > v2 || v2 > packSize)
+ return S_FALSE;
+ // here we need the code that will decompress ZBM chunk
+ }
+ }
+
+ if (unpackPos != blockSize)
+ return S_FALSE;
+
+ UInt32 size1 = size;
+ if (size1 > kCompressionBlockSize)
+ {
+ size1 = kCompressionBlockSize;
+ // return S_FALSE;
+ }
+ if (outStream)
+ {
+ RINOK(WriteStream(outStream, buf, size1))
+
+ const UInt32 kTempSize = 1 << 16;
+ Byte temp[kTempSize];
+ memset(temp, 0, kTempSize);
+
+ for (UInt32 k = size1; k < kCompressionBlockSize; k++)
+ {
+ UInt32 cur = kCompressionBlockSize - k;
+ if (cur > kTempSize)
+ cur = kTempSize;
+ RINOK(WriteStream(outStream, temp, cur))
+ k += cur;
+ }
+ }
+
+ // const UInt64 blockSize64 = blockSize;
+ // const UInt64 packSize64 = size;
+ // bufInStreamSpec->Init(buf, size);
+ // RINOK(_zbmDecoderSpec->Code(bufInStream, outStream, &packSize64, &blockSize64, NULL));
+ // in/out sizes were checked in Code()
+ }
+
+ outPos += blockSize;
+ if ((i & 0xFF) == 0)
+ {
+ const UInt64 progressPos = progressStart + outPos;
+ RINOK(extractCallback->SetCompleted(&progressPos));
+ }
+ }
+
+ return S_OK;
+}
+*/
+
+HRESULT CDecoder::Extract(
+ ISequentialInStream *inStreamFork, ISequentialOutStream *realOutStream,
+ UInt64 forkSize,
+ const CCompressHeader &compressHeader,
+ const CByteBuffer *data,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback,
+ int &opRes)
+{
+ opRes = NExtract::NOperationResult::kDataError;
+
+ if (compressHeader.IsMethod_Uncompressed_Inline())
+ {
+ const size_t packSize = data->Size() - compressHeader.DataPos;
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, *data + compressHeader.DataPos, packSize))
+ }
+ opRes = NExtract::NOperationResult::kOK;
+ return S_OK;
+ }
+
+ if (compressHeader.Method == kMethod_ZLIB_ATTR ||
+ compressHeader.Method == kMethod_LZVN_ATTR)
+ {
+ CBufInStream *bufInStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> bufInStream = bufInStreamSpec;
+ const size_t packSize = data->Size() - compressHeader.DataPos;
+ bufInStreamSpec->Init(*data + compressHeader.DataPos, packSize);
+
+ if (compressHeader.Method == kMethod_ZLIB_ATTR)
+ {
+ const HRESULT hres = _zlibDecoder->Code(bufInStream, realOutStream,
+ NULL, &compressHeader.UnpackSize, NULL);
+ if (hres == S_OK)
+ if (_zlibDecoderSpec->GetOutputProcessedSize() == compressHeader.UnpackSize
+ && _zlibDecoderSpec->GetInputProcessedSize() == packSize)
+ opRes = NExtract::NOperationResult::kOK;
+ return hres;
+ }
+ {
+ const UInt64 packSize64 = packSize;
+ const HRESULT hres = _lzfseDecoder->Code(bufInStream, realOutStream,
+ &packSize64, &compressHeader.UnpackSize, NULL);
+ if (hres == S_OK)
+ {
+ // in/out sizes were checked in Code()
+ opRes = NExtract::NOperationResult::kOK;
+ }
+ return hres;
+ }
+ }
+
+ HRESULT hres;
+ if (compressHeader.Method == NHfs::kMethod_ZLIB_RSRC)
+ {
+ hres = ExtractResourceFork_ZLIB(
+ inStreamFork, realOutStream,
+ forkSize, compressHeader.UnpackSize,
+ progressStart, extractCallback);
+ }
+ else if (compressHeader.Method == NHfs::kMethod_LZVN_RSRC)
+ {
+ hres = ExtractResourceFork_LZFSE(
+ inStreamFork, realOutStream,
+ forkSize, compressHeader.UnpackSize,
+ progressStart, extractCallback);
+ }
+ /*
+ else if (compressHeader.Method == NHfs::kMethod_ZBM_RSRC)
+ {
+ hres = ExtractResourceFork_ZBM(
+ inStreamFork, realOutStream,
+ forkSize, compressHeader.UnpackSize,
+ progressStart, extractCallback);
+ }
+ */
+ else
+ {
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ hres = S_FALSE;
+ }
+
+ if (hres == S_OK)
+ opRes = NExtract::NOperationResult::kOK;
+ return hres;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = Refs.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt32 i;
+ UInt64 totalSize = 0;
+ for (i = 0; i < numItems; i++)
+ {
+ const CRef &ref = Refs[allFilesMode ? i : indices[i]];
+ totalSize += Get_UnpackSize_of_Ref(ref);
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ UInt64 currentTotalSize = 0, currentItemSize = 0;
+
+ const size_t kBufSize = kCompressionBlockSize;
+ CByteBuffer buf(kBufSize + 0x10); // we need 1 additional bytes for uncompressed chunk header
+
+ CDecoder decoder;
+
+ for (i = 0;; i++, currentTotalSize += currentItemSize)
+ {
+ RINOK(extractCallback->SetCompleted(¤tTotalSize))
+ if (i == numItems)
+ break;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CRef &ref = Refs[index];
+ const CItem &item = Items[ref.ItemIndex];
+ currentItemSize = Get_UnpackSize_of_Ref(ref);
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (ref.IsItem() && item.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ UInt64 pos = 0;
+ int opRes = NExtract::NOperationResult::kDataError;
+ const CFork *fork = NULL;
+
+ if (ref.AttrIndex >= 0)
+ {
+ const CAttr &attr = Attrs[ref.AttrIndex];
+ if (attr.Fork_defined && attr.Data.Size() == 0)
+ fork = &attr.Fork;
+ else
+ {
+ opRes = NExtract::NOperationResult::kOK;
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream,
+ // AttrBuf + attr.Pos, attr.Size
+ attr.Data, attr.Data.Size()
+ ))
+ }
+ }
+ }
+ else if (ref.IsResource())
+ fork = &item.ResourceFork;
+ else if (item.CompressHeader.IsSupported)
+ {
+ CMyComPtr<ISequentialInStream> inStreamFork;
+ UInt64 forkSize = 0;
+ const CByteBuffer *decmpfs_Data = NULL;
+
+ if (item.CompressHeader.IsMethod_Resource())
+ {
+ const CFork &resourceFork = item.ResourceFork;
+ forkSize = resourceFork.Size;
+ GetForkStream(resourceFork, &inStreamFork);
+ }
+ else
+ {
+ const CAttr &attr = Attrs[item.decmpfs_AttrIndex];
+ decmpfs_Data = &attr.Data;
+ }
+
+ if (inStreamFork || decmpfs_Data)
+ {
+ const HRESULT hres = decoder.Extract(
+ inStreamFork, realOutStream,
+ forkSize,
+ item.CompressHeader,
+ decmpfs_Data,
+ currentTotalSize, extractCallback,
+ opRes);
+ if (hres != S_FALSE && hres != S_OK)
+ return hres;
+ }
+ }
+ else if (item.CompressHeader.IsCorrect)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ fork = &item.DataFork;
+
+ if (fork)
+ {
+ if (fork->IsOk(Header.BlockSizeLog))
+ {
+ opRes = NExtract::NOperationResult::kOK;
+ unsigned extentIndex;
+ for (extentIndex = 0; extentIndex < fork->Extents.Size(); extentIndex++)
+ {
+ if (opRes != NExtract::NOperationResult::kOK)
+ break;
+ if (fork->Size == pos)
+ break;
+ const CExtent &e = fork->Extents[extentIndex];
+ RINOK(InStream_SeekSet(_stream, SpecOffset + ((UInt64)e.Pos << Header.BlockSizeLog)))
+ UInt64 extentRem = (UInt64)e.NumBlocks << Header.BlockSizeLog;
+ while (extentRem != 0)
+ {
+ const UInt64 rem = fork->Size - pos;
+ if (rem == 0)
+ {
+ // Here we check that there are no extra (empty) blocks in last extent.
+ if (extentRem >= ((UInt64)1 << Header.BlockSizeLog))
+ opRes = NExtract::NOperationResult::kDataError;
+ break;
+ }
+ size_t cur = kBufSize;
+ if (cur > rem)
+ cur = (size_t)rem;
+ if (cur > extentRem)
+ cur = (size_t)extentRem;
+ RINOK(ReadStream(_stream, buf, &cur))
+ if (cur == 0)
+ {
+ opRes = NExtract::NOperationResult::kDataError;
+ break;
+ }
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, buf, cur))
+ }
+ pos += cur;
+ extentRem -= cur;
+ const UInt64 processed = currentTotalSize + pos;
+ RINOK(extractCallback->SetCompleted(&processed))
+ }
+ }
+ if (extentIndex != fork->Extents.Size() || fork->Size != pos)
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+ }
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = Refs.Size();
+ return S_OK;
+}
+
+HRESULT CHandler::GetForkStream(const CFork &fork, ISequentialInStream **stream)
+{
+ *stream = NULL;
+
+ if (!fork.IsOk(Header.BlockSizeLog))
+ return S_FALSE;
+
+ CExtentsStream *extentStreamSpec = new CExtentsStream();
+ CMyComPtr<ISequentialInStream> extentStream = extentStreamSpec;
+
+ UInt64 rem = fork.Size;
+ UInt64 virt = 0;
+
+ FOR_VECTOR (i, fork.Extents)
+ {
+ const CExtent &e = fork.Extents[i];
+ if (e.NumBlocks == 0)
+ continue;
+ UInt64 cur = ((UInt64)e.NumBlocks << Header.BlockSizeLog);
+ if (cur > rem)
+ {
+ cur = rem;
+ if (i != fork.Extents.Size() - 1)
+ return S_FALSE;
+ }
+ CSeekExtent se;
+ se.Phy = (UInt64)e.Pos << Header.BlockSizeLog;
+ se.Virt = virt;
+ virt += cur;
+ rem -= cur;
+ extentStreamSpec->Extents.Add(se);
+ }
+
+ if (rem != 0)
+ return S_FALSE;
+
+ CSeekExtent se;
+ se.Phy = 0;
+ se.Virt = virt;
+ extentStreamSpec->Extents.Add(se);
+ extentStreamSpec->Stream = _stream;
+ extentStreamSpec->Init();
+ *stream = extentStream.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ *stream = NULL;
+
+ const CRef &ref = Refs[index];
+ const CFork *fork = NULL;
+ if (ref.AttrIndex >= 0)
+ {
+ const CAttr &attr = Attrs[ref.AttrIndex];
+ if (!attr.Fork_defined || attr.Data.Size() != 0)
+ return S_FALSE;
+ fork = &attr.Fork;
+ }
+ else
+ {
+ const CItem &item = Items[ref.ItemIndex];
+ if (ref.IsResource())
+ fork = &item.ResourceFork;
+ else if (item.IsDir())
+ return S_FALSE;
+ else if (item.CompressHeader.IsCorrect)
+ return S_FALSE;
+ else
+ fork = &item.DataFork;
+ }
+ return GetForkStream(*fork, stream);
+}
+
+static const Byte k_Signature[] = {
+ 2, 'B', 'D',
+ 4, 'H', '+', 0, 4,
+ 4, 'H', 'X', 0, 5 };
+
+REGISTER_ARC_I(
+ "HFS", "hfs hfsx", NULL, 0xE3,
+ k_Signature,
+ kHeaderPadSize,
+ NArcInfoFlags::kMultiSignature,
+ IsArc_HFS)
+
+}}
diff --git a/CPP/7zip/Archive/HfsHandler.h b/CPP/7zip/Archive/HfsHandler.h
new file mode 100644
index 0000000..0006e12
--- /dev/null
+++ b/CPP/7zip/Archive/HfsHandler.h
@@ -0,0 +1,90 @@
+// HfsHandler.h
+
+#ifndef ZIP7_INC_HFS_HANDLER_H
+#define ZIP7_INC_HFS_HANDLER_H
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Compress/LzfseDecoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+namespace NArchive {
+namespace NHfs {
+
+static const UInt32 k_decmpfs_HeaderSize = 16;
+
+struct CCompressHeader
+{
+ UInt64 UnpackSize;
+ UInt32 Method;
+ Byte DataPos;
+ bool IsCorrect;
+ bool IsSupported;
+ bool IsResource;
+
+ bool IsMethod_Compressed_Inline() const { return DataPos == k_decmpfs_HeaderSize; }
+ bool IsMethod_Uncompressed_Inline() const { return DataPos == k_decmpfs_HeaderSize + 1; }
+ bool IsMethod_Resource() const { return IsResource; }
+
+ void Parse(const Byte *p, size_t size);
+
+ void Clear()
+ {
+ UnpackSize = 0;
+ Method = 0;
+ DataPos = 0;
+ IsCorrect = false;
+ IsSupported = false;
+ IsResource = false;
+ }
+
+ CCompressHeader() { Clear(); }
+
+ void MethodToProp(NWindows::NCOM::CPropVariant &prop) const;
+};
+
+void MethodsMaskToProp(UInt32 methodsMask, NWindows::NCOM::CPropVariant &prop);
+
+
+class CDecoder
+{
+ NCompress::NZlib::CDecoder *_zlibDecoderSpec;
+ CMyComPtr<ICompressCoder> _zlibDecoder;
+
+ NCompress::NLzfse::CDecoder *_lzfseDecoderSpec;
+ CMyComPtr<ICompressCoder> _lzfseDecoder;
+
+ CByteBuffer _tableBuf;
+ CByteBuffer _buf;
+
+ HRESULT ExtractResourceFork_ZLIB(
+ ISequentialInStream *inStream, ISequentialOutStream *realOutStream,
+ UInt64 forkSize, UInt64 unpackSize,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback);
+
+ HRESULT ExtractResourceFork_LZFSE(
+ ISequentialInStream *inStream, ISequentialOutStream *realOutStream,
+ UInt64 forkSize, UInt64 unpackSize,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback);
+
+ HRESULT ExtractResourceFork_ZBM(
+ ISequentialInStream *inStream, ISequentialOutStream *realOutStream,
+ UInt64 forkSize, UInt64 unpackSize,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback);
+
+public:
+
+ HRESULT Extract(
+ ISequentialInStream *inStreamFork, ISequentialOutStream *realOutStream,
+ UInt64 forkSize,
+ const CCompressHeader &compressHeader,
+ const CByteBuffer *data,
+ UInt64 progressStart, IArchiveExtractCallback *extractCallback,
+ int &opRes);
+
+ CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/IArchive.h b/CPP/7zip/Archive/IArchive.h
index 96451a6..3e68ac3 100644
--- a/CPP/7zip/Archive/IArchive.h
+++ b/CPP/7zip/Archive/IArchive.h
@@ -1,608 +1,704 @@
-// IArchive.h
-
-#ifndef __IARCHIVE_H
-#define __IARCHIVE_H
-
-#include "../IProgress.h"
-#include "../IStream.h"
-#include "../PropID.h"
-
-#define ARCHIVE_INTERFACE_SUB(i, base, x) DECL_INTERFACE_SUB(i, base, 6, x)
-#define ARCHIVE_INTERFACE(i, x) ARCHIVE_INTERFACE_SUB(i, IUnknown, x)
-
-namespace NFileTimeType
-{
- enum EEnum
- {
- kWindows,
- kUnix,
- kDOS
- };
-}
-
-namespace NArcInfoFlags
-{
- const UInt32 kKeepName = 1 << 0; // keep name of file in archive name
- const UInt32 kAltStreams = 1 << 1; // the handler supports alt streams
- const UInt32 kNtSecure = 1 << 2; // the handler supports NT security
- const UInt32 kFindSignature = 1 << 3; // the handler can find start of archive
- const UInt32 kMultiSignature = 1 << 4; // there are several signatures
- const UInt32 kUseGlobalOffset = 1 << 5; // the seek position of stream must be set as global offset
- const UInt32 kStartOpen = 1 << 6; // call handler for each start position
- const UInt32 kPureStartOpen = 1 << 7; // call handler only for start of file
- const UInt32 kBackwardOpen = 1 << 8; // archive can be open backward
- const UInt32 kPreArc = 1 << 9; // such archive can be stored before real archive (like SFX stub)
- const UInt32 kSymLinks = 1 << 10; // the handler supports symbolic links
- const UInt32 kHardLinks = 1 << 11; // the handler supports hard links
-}
-
-namespace NArchive
-{
- namespace NHandlerPropID
- {
- enum
- {
- kName = 0, // VT_BSTR
- kClassID, // binary GUID in VT_BSTR
- kExtension, // VT_BSTR
- kAddExtension, // VT_BSTR
- kUpdate, // VT_BOOL
- kKeepName, // VT_BOOL
- kSignature, // binary in VT_BSTR
- kMultiSignature, // binary in VT_BSTR
- kSignatureOffset, // VT_UI4
- kAltStreams, // VT_BOOL
- kNtSecure, // VT_BOOL
- kFlags // VT_UI4
- // kVersion // VT_UI4 ((VER_MAJOR << 8) | VER_MINOR)
- };
- }
-
- namespace NExtract
- {
- namespace NAskMode
- {
- enum
- {
- kExtract = 0,
- kTest,
- kSkip
- };
- }
-
- namespace NOperationResult
- {
- enum
- {
- kOK = 0,
- kUnsupportedMethod,
- kDataError,
- kCRCError,
- kUnavailable,
- kUnexpectedEnd,
- kDataAfterEnd,
- kIsNotArc,
- kHeadersError,
- kWrongPassword
- };
- }
- }
-
- namespace NEventIndexType
- {
- enum
- {
- kNoIndex = 0,
- kInArcIndex,
- kBlockIndex,
- kOutArcIndex
- };
- }
-
- namespace NUpdate
- {
- namespace NOperationResult
- {
- enum
- {
- kOK = 0
- , // kError
- };
- }
- }
-}
-
-#define INTERFACE_IArchiveOpenCallback(x) \
- STDMETHOD(SetTotal)(const UInt64 *files, const UInt64 *bytes) x; \
- STDMETHOD(SetCompleted)(const UInt64 *files, const UInt64 *bytes) x; \
-
-ARCHIVE_INTERFACE(IArchiveOpenCallback, 0x10)
-{
- INTERFACE_IArchiveOpenCallback(PURE);
-};
-
-/*
-IArchiveExtractCallback::
-
-7-Zip doesn't call IArchiveExtractCallback functions
- GetStream()
- PrepareOperation()
- SetOperationResult()
-from different threads simultaneously.
-But 7-Zip can call functions for IProgress or ICompressProgressInfo functions
-from another threads simultaneously with calls for IArchiveExtractCallback interface.
-
-IArchiveExtractCallback::GetStream()
- UInt32 index - index of item in Archive
- Int32 askExtractMode (Extract::NAskMode)
- if (askMode != NExtract::NAskMode::kExtract)
- {
- then the callee can not real stream: (*inStream == NULL)
- }
-
- Out:
- (*inStream == NULL) - for directories
- (*inStream == NULL) - if link (hard link or symbolic link) was created
- if (*inStream == NULL && askMode == NExtract::NAskMode::kExtract)
- {
- then the caller must skip extracting of that file.
- }
-
- returns:
- S_OK : OK
- S_FALSE : data error (for decoders)
-
-if (IProgress::SetTotal() was called)
-{
- IProgress::SetCompleted(completeValue) uses
- packSize - for some stream formats (xz, gz, bz2, lzma, z, ppmd).
- unpackSize - for another formats.
-}
-else
-{
- IProgress::SetCompleted(completeValue) uses packSize.
-}
-
-SetOperationResult()
- 7-Zip calls SetOperationResult at the end of extracting,
- so the callee can close the file, set attributes, timestamps and security information.
-
- Int32 opRes (NExtract::NOperationResult)
-*/
-
-#define INTERFACE_IArchiveExtractCallback(x) \
- INTERFACE_IProgress(x) \
- STDMETHOD(GetStream)(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode) x; \
- STDMETHOD(PrepareOperation)(Int32 askExtractMode) x; \
- STDMETHOD(SetOperationResult)(Int32 opRes) x; \
-
-ARCHIVE_INTERFACE_SUB(IArchiveExtractCallback, IProgress, 0x20)
-{
- INTERFACE_IArchiveExtractCallback(PURE)
-};
-
-
-
-/*
-IArchiveExtractCallbackMessage can be requested from IArchiveExtractCallback object
- by Extract() or UpdateItems() functions to report about extracting errors
-ReportExtractResult()
- UInt32 indexType (NEventIndexType)
- UInt32 index
- Int32 opRes (NExtract::NOperationResult)
-*/
-
-#define INTERFACE_IArchiveExtractCallbackMessage(x) \
- STDMETHOD(ReportExtractResult)(UInt32 indexType, UInt32 index, Int32 opRes) x; \
-
-ARCHIVE_INTERFACE_SUB(IArchiveExtractCallbackMessage, IProgress, 0x21)
-{
- INTERFACE_IArchiveExtractCallbackMessage(PURE)
-};
-
-
-#define INTERFACE_IArchiveOpenVolumeCallback(x) \
- STDMETHOD(GetProperty)(PROPID propID, PROPVARIANT *value) x; \
- STDMETHOD(GetStream)(const wchar_t *name, IInStream **inStream) x; \
-
-ARCHIVE_INTERFACE(IArchiveOpenVolumeCallback, 0x30)
-{
- INTERFACE_IArchiveOpenVolumeCallback(PURE);
-};
-
-
-ARCHIVE_INTERFACE(IInArchiveGetStream, 0x40)
-{
- STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream) PURE;
-};
-
-
-ARCHIVE_INTERFACE(IArchiveOpenSetSubArchiveName, 0x50)
-{
- STDMETHOD(SetSubArchiveName)(const wchar_t *name) PURE;
-};
-
-
-/*
-IInArchive::Open
- stream
- if (kUseGlobalOffset), stream current position can be non 0.
- if (!kUseGlobalOffset), stream current position is 0.
- if (maxCheckStartPosition == NULL), the handler can try to search archive start in stream
- if (*maxCheckStartPosition == 0), the handler must check only current position as archive start
-
-IInArchive::Extract:
- indices must be sorted
- numItems = (UInt32)(Int32)-1 = 0xFFFFFFFF means "all files"
- testMode != 0 means "test files without writing to outStream"
-
-IInArchive::GetArchiveProperty:
- kpidOffset - start offset of archive.
- VT_EMPTY : means offset = 0.
- VT_UI4, VT_UI8, VT_I8 : result offset; negative values is allowed
- kpidPhySize - size of archive. VT_EMPTY means unknown size.
- kpidPhySize is allowed to be larger than file size. In that case it must show
- supposed size.
-
- kpidIsDeleted:
- kpidIsAltStream:
- kpidIsAux:
- kpidINode:
- must return VARIANT_TRUE (VT_BOOL), if archive can support that property in GetProperty.
-
-
-Notes:
- Don't call IInArchive functions for same IInArchive object from different threads simultaneously.
- Some IInArchive handlers will work incorrectly in that case.
-*/
-
-#ifdef _MSC_VER
- #define MY_NO_THROW_DECL_ONLY throw()
-#else
- #define MY_NO_THROW_DECL_ONLY
-#endif
-
-#define INTERFACE_IInArchive(x) \
- STDMETHOD(Open)(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *openCallback) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(Close)() MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetNumberOfItems)(UInt32 *numItems) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(Extract)(const UInt32* indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetArchiveProperty)(PROPID propID, PROPVARIANT *value) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetNumberOfProperties)(UInt32 *numProps) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetPropertyInfo)(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetNumberOfArchiveProperties)(UInt32 *numProps) MY_NO_THROW_DECL_ONLY x; \
- STDMETHOD(GetArchivePropertyInfo)(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) MY_NO_THROW_DECL_ONLY x; \
-
-ARCHIVE_INTERFACE(IInArchive, 0x60)
-{
- INTERFACE_IInArchive(PURE)
-};
-
-namespace NParentType
-{
- enum
- {
- kDir = 0,
- kAltStream
- };
-};
-
-namespace NPropDataType
-{
- const UInt32 kMask_ZeroEnd = 1 << 4;
- // const UInt32 kMask_BigEndian = 1 << 5;
- const UInt32 kMask_Utf = 1 << 6;
- const UInt32 kMask_Utf8 = kMask_Utf | 0;
- const UInt32 kMask_Utf16 = kMask_Utf | 1;
- // const UInt32 kMask_Utf32 = kMask_Utf | 2;
-
- const UInt32 kNotDefined = 0;
- const UInt32 kRaw = 1;
-
- const UInt32 kUtf8z = kMask_Utf8 | kMask_ZeroEnd;
- const UInt32 kUtf16z = kMask_Utf16 | kMask_ZeroEnd;
-};
-
-// UTF string (pointer to wchar_t) with zero end and little-endian.
-#define PROP_DATA_TYPE_wchar_t_PTR_Z_LE ((NPropDataType::kMask_Utf | NPropDataType::kMask_ZeroEnd) + (sizeof(wchar_t) >> 1))
-
-/*
-GetRawProp:
- Result:
- S_OK - even if property is not set
-*/
-
-#define INTERFACE_IArchiveGetRawProps(x) \
- STDMETHOD(GetParent)(UInt32 index, UInt32 *parent, UInt32 *parentType) x; \
- STDMETHOD(GetRawProp)(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType) x; \
- STDMETHOD(GetNumRawProps)(UInt32 *numProps) x; \
- STDMETHOD(GetRawPropInfo)(UInt32 index, BSTR *name, PROPID *propID) x;
-
-ARCHIVE_INTERFACE(IArchiveGetRawProps, 0x70)
-{
- INTERFACE_IArchiveGetRawProps(PURE)
-};
-
-#define INTERFACE_IArchiveGetRootProps(x) \
- STDMETHOD(GetRootProp)(PROPID propID, PROPVARIANT *value) x; \
- STDMETHOD(GetRootRawProp)(PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType) x; \
-
-ARCHIVE_INTERFACE(IArchiveGetRootProps, 0x71)
-{
- INTERFACE_IArchiveGetRootProps(PURE)
-};
-
-ARCHIVE_INTERFACE(IArchiveOpenSeq, 0x61)
-{
- STDMETHOD(OpenSeq)(ISequentialInStream *stream) PURE;
-};
-
-/*
- OpenForSize
- Result:
- S_FALSE - is not archive
- ? - DATA error
-*/
-
-/*
-const UInt32 kOpenFlags_RealPhySize = 1 << 0;
-const UInt32 kOpenFlags_NoSeek = 1 << 1;
-// const UInt32 kOpenFlags_BeforeExtract = 1 << 2;
-*/
-
-/*
-Flags:
- 0 - opens archive with IInStream, if IInStream interface is supported
- - if phySize is not available, it doesn't try to make full parse to get phySize
- kOpenFlags_NoSeek - ArcOpen2 function doesn't use IInStream interface, even if it's available
- kOpenFlags_RealPhySize - the handler will try to get PhySize, even if it requires full decompression for file
-
- if handler is not allowed to use IInStream and the flag kOpenFlags_RealPhySize is not specified,
- the handler can return S_OK, but it doesn't check even Signature.
- So next Extract can be called for that sequential stream.
-*/
-
-/*
-ARCHIVE_INTERFACE(IArchiveOpen2, 0x62)
-{
- STDMETHOD(ArcOpen2)(ISequentialInStream *stream, UInt32 flags, IArchiveOpenCallback *openCallback) PURE;
-};
-*/
-
-// ---------- UPDATE ----------
-
-/*
-GetUpdateItemInfo outs:
-*newData *newProps
- 0 0 - Copy data and properties from archive
- 0 1 - Copy data from archive, request new properties
- 1 0 - that combination is unused now
- 1 1 - Request new data and new properties. It can be used even for folders
-
- indexInArchive = -1 if there is no item in archive, or if it doesn't matter.
-
-
-GetStream out:
- Result:
- S_OK:
- (*inStream == NULL) - only for directories
- - the bug was fixed in 9.33: (*Stream == NULL) was in case of anti-file
- (*inStream != NULL) - for any file, even for empty file or anti-file
- S_FALSE - skip that file (don't add item to archive) - (client code can't open stream of that file by some reason)
- (*inStream == NULL)
-
-The order of calling for hard links:
- - GetStream()
- - GetProperty(kpidHardLink)
-
-SetOperationResult()
- Int32 opRes (NExtract::NOperationResult::kOK)
-*/
-
-#define INTERFACE_IArchiveUpdateCallback(x) \
- INTERFACE_IProgress(x); \
- STDMETHOD(GetUpdateItemInfo)(UInt32 index, Int32 *newData, Int32 *newProps, UInt32 *indexInArchive) x; \
- STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value) x; \
- STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **inStream) x; \
- STDMETHOD(SetOperationResult)(Int32 operationResult) x; \
-
-ARCHIVE_INTERFACE_SUB(IArchiveUpdateCallback, IProgress, 0x80)
-{
- INTERFACE_IArchiveUpdateCallback(PURE);
-};
-
-#define INTERFACE_IArchiveUpdateCallback2(x) \
- INTERFACE_IArchiveUpdateCallback(x) \
- STDMETHOD(GetVolumeSize)(UInt32 index, UInt64 *size) x; \
- STDMETHOD(GetVolumeStream)(UInt32 index, ISequentialOutStream **volumeStream) x; \
-
-ARCHIVE_INTERFACE_SUB(IArchiveUpdateCallback2, IArchiveUpdateCallback, 0x82)
-{
- INTERFACE_IArchiveUpdateCallback2(PURE);
-};
-
-namespace NUpdateNotifyOp
-{
- enum
- {
- kAdd = 0,
- kUpdate,
- kAnalyze,
- kReplicate,
- kRepack,
- kSkip,
- kDelete,
- kHeader
-
- // kNumDefined
- };
-};
-
-/*
-IArchiveUpdateCallbackFile::ReportOperation
- UInt32 indexType (NEventIndexType)
- UInt32 index
- UInt32 notifyOp (NUpdateNotifyOp)
-*/
-
-#define INTERFACE_IArchiveUpdateCallbackFile(x) \
- STDMETHOD(GetStream2)(UInt32 index, ISequentialInStream **inStream, UInt32 notifyOp) x; \
- STDMETHOD(ReportOperation)(UInt32 indexType, UInt32 index, UInt32 notifyOp) x; \
-
-ARCHIVE_INTERFACE(IArchiveUpdateCallbackFile, 0x83)
-{
- INTERFACE_IArchiveUpdateCallbackFile(PURE);
-};
-
-
-/*
-UpdateItems()
--------------
-
- outStream: output stream. (the handler) MUST support the case when
- Seek position in outStream is not ZERO.
- but the caller calls with empty outStream and seek position is ZERO??
-
- archives with stub:
-
- If archive is open and the handler and (Offset > 0), then the handler
- knows about stub size.
- UpdateItems():
- 1) the handler MUST copy that stub to outStream
- 2) the caller MUST NOT copy the stub to outStream, if
- "rsfx" property is set with SetProperties
-
- the handler must support the case where
- ISequentialOutStream *outStream
-*/
-
-
-#define INTERFACE_IOutArchive(x) \
- STDMETHOD(UpdateItems)(ISequentialOutStream *outStream, UInt32 numItems, IArchiveUpdateCallback *updateCallback) x; \
- STDMETHOD(GetFileTimeType)(UInt32 *type) x;
-
-ARCHIVE_INTERFACE(IOutArchive, 0xA0)
-{
- INTERFACE_IOutArchive(PURE)
-};
-
-
-/*
-ISetProperties::SetProperties()
- PROPVARIANT values[i].vt:
- VT_EMPTY
- VT_BOOL
- VT_UI4 - if 32-bit number
- VT_UI8 - if 64-bit number
- VT_BSTR
-*/
-
-ARCHIVE_INTERFACE(ISetProperties, 0x03)
-{
- STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps) PURE;
-};
-
-ARCHIVE_INTERFACE(IArchiveKeepModeForNextOpen, 0x04)
-{
- STDMETHOD(KeepModeForNextOpen)() PURE;
-};
-
-/* Exe handler: the handler for executable format (PE, ELF, Mach-O).
- SFX archive: executable stub + some tail data.
- before 9.31: exe handler didn't parse SFX archives as executable format.
- for 9.31+: exe handler parses SFX archives as executable format, only if AllowTail(1) was called */
-
-ARCHIVE_INTERFACE(IArchiveAllowTail, 0x05)
-{
- STDMETHOD(AllowTail)(Int32 allowTail) PURE;
-};
-
-
-#define IMP_IInArchive_GetProp(k) \
- (UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) \
- { if (index >= ARRAY_SIZE(k)) return E_INVALIDARG; \
- *propID = k[index]; *varType = k7z_PROPID_To_VARTYPE[(unsigned)*propID]; *name = 0; return S_OK; } \
-
-
-struct CStatProp
-{
- const char *Name;
- UInt32 PropID;
- VARTYPE vt;
-};
-
-namespace NWindows {
-namespace NCOM {
-// PropVariant.cpp
-BSTR AllocBstrFromAscii(const char *s) throw();
-}}
-
-#define IMP_IInArchive_GetProp_WITH_NAME(k) \
- (UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType) \
- { if (index >= ARRAY_SIZE(k)) return E_INVALIDARG; \
- const CStatProp &prop = k[index]; \
- *propID = (PROPID)prop.PropID; *varType = prop.vt; \
- *name = NWindows::NCOM::AllocBstrFromAscii(prop.Name); return S_OK; } \
-
-#define IMP_IInArchive_Props \
- STDMETHODIMP CHandler::GetNumberOfProperties(UInt32 *numProps) \
- { *numProps = ARRAY_SIZE(kProps); return S_OK; } \
- STDMETHODIMP CHandler::GetPropertyInfo IMP_IInArchive_GetProp(kProps)
-
-#define IMP_IInArchive_Props_WITH_NAME \
- STDMETHODIMP CHandler::GetNumberOfProperties(UInt32 *numProps) \
- { *numProps = ARRAY_SIZE(kProps); return S_OK; } \
- STDMETHODIMP CHandler::GetPropertyInfo IMP_IInArchive_GetProp_WITH_NAME(kProps)
-
-
-#define IMP_IInArchive_ArcProps \
- STDMETHODIMP CHandler::GetNumberOfArchiveProperties(UInt32 *numProps) \
- { *numProps = ARRAY_SIZE(kArcProps); return S_OK; } \
- STDMETHODIMP CHandler::GetArchivePropertyInfo IMP_IInArchive_GetProp(kArcProps)
-
-#define IMP_IInArchive_ArcProps_WITH_NAME \
- STDMETHODIMP CHandler::GetNumberOfArchiveProperties(UInt32 *numProps) \
- { *numProps = ARRAY_SIZE(kArcProps); return S_OK; } \
- STDMETHODIMP CHandler::GetArchivePropertyInfo IMP_IInArchive_GetProp_WITH_NAME(kArcProps)
-
-#define IMP_IInArchive_ArcProps_NO_Table \
- STDMETHODIMP CHandler::GetNumberOfArchiveProperties(UInt32 *numProps) \
- { *numProps = 0; return S_OK; } \
- STDMETHODIMP CHandler::GetArchivePropertyInfo(UInt32, BSTR *, PROPID *, VARTYPE *) \
- { return E_NOTIMPL; } \
-
-#define IMP_IInArchive_ArcProps_NO \
- IMP_IInArchive_ArcProps_NO_Table \
- STDMETHODIMP CHandler::GetArchiveProperty(PROPID, PROPVARIANT *value) \
- { value->vt = VT_EMPTY; return S_OK; }
-
-
-
-#define k_IsArc_Res_NO 0
-#define k_IsArc_Res_YES 1
-#define k_IsArc_Res_NEED_MORE 2
-// #define k_IsArc_Res_YES_LOW_PROB 3
-
-#define API_FUNC_IsArc EXTERN_C UInt32 WINAPI
-#define API_FUNC_static_IsArc extern "C" { static UInt32 WINAPI
-
-extern "C"
-{
- typedef HRESULT (WINAPI *Func_CreateObject)(const GUID *clsID, const GUID *iid, void **outObject);
-
- typedef UInt32 (WINAPI *Func_IsArc)(const Byte *p, size_t size);
- typedef HRESULT (WINAPI *Func_GetIsArc)(UInt32 formatIndex, Func_IsArc *isArc);
-
- typedef HRESULT (WINAPI *Func_GetNumberOfFormats)(UInt32 *numFormats);
- typedef HRESULT (WINAPI *Func_GetHandlerProperty)(PROPID propID, PROPVARIANT *value);
- typedef HRESULT (WINAPI *Func_GetHandlerProperty2)(UInt32 index, PROPID propID, PROPVARIANT *value);
-
- typedef HRESULT (WINAPI *Func_SetCaseSensitive)(Int32 caseSensitive);
- typedef HRESULT (WINAPI *Func_SetLargePageMode)();
-
- typedef IOutArchive * (*Func_CreateOutArchive)();
- typedef IInArchive * (*Func_CreateInArchive)();
-}
-
-#endif
+// IArchive.h
+
+#ifndef ZIP7_INC_IARCHIVE_H
+#define ZIP7_INC_IARCHIVE_H
+
+#include "../IProgress.h"
+#include "../IStream.h"
+#include "../PropID.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+
+#define Z7_IFACE_CONSTR_ARCHIVE_SUB(i, base, n) \
+ Z7_DECL_IFACE_7ZIP_SUB(i, base, 6, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACE_CONSTR_ARCHIVE(i, n) \
+ Z7_IFACE_CONSTR_ARCHIVE_SUB(i, IUnknown, n)
+
+/*
+How the function in 7-Zip returns object for output parameter via pointer
+
+1) The caller sets the value of variable before function call:
+ PROPVARIANT : vt = VT_EMPTY
+ BSTR : NULL
+ IUnknown* and derived interfaces : NULL
+ another scalar types : any non-initialized value is allowed
+
+2) The callee in current 7-Zip code now can free input object for output parameter:
+ PROPVARIANT : the callee calls VariantClear(propvaiant_ptr) for input
+ value stored in variable
+ another types : the callee ignores stored value.
+
+3) The callee writes new value to variable for output parameter and
+ returns execution to caller.
+
+4) The caller must free or release object returned by the callee:
+ PROPVARIANT : VariantClear(&propvaiant)
+ BSTR : SysFreeString(bstr)
+ IUnknown* and derived interfaces : if (ptr) ptr->Relase()
+*/
+
+
+namespace NFileTimeType
+{
+ enum EEnum
+ {
+ kNotDefined = -1,
+ kWindows = 0,
+ kUnix,
+ kDOS,
+ k1ns
+ };
+}
+
+namespace NArcInfoFlags
+{
+ const UInt32 kKeepName = 1 << 0; // keep name of file in archive name
+ const UInt32 kAltStreams = 1 << 1; // the handler supports alt streams
+ const UInt32 kNtSecure = 1 << 2; // the handler supports NT security
+ const UInt32 kFindSignature = 1 << 3; // the handler can find start of archive
+ const UInt32 kMultiSignature = 1 << 4; // there are several signatures
+ const UInt32 kUseGlobalOffset = 1 << 5; // the seek position of stream must be set as global offset
+ const UInt32 kStartOpen = 1 << 6; // call handler for each start position
+ const UInt32 kPureStartOpen = 1 << 7; // call handler only for start of file
+ const UInt32 kBackwardOpen = 1 << 8; // archive can be open backward
+ const UInt32 kPreArc = 1 << 9; // such archive can be stored before real archive (like SFX stub)
+ const UInt32 kSymLinks = 1 << 10; // the handler supports symbolic links
+ const UInt32 kHardLinks = 1 << 11; // the handler supports hard links
+ const UInt32 kByExtOnlyOpen = 1 << 12; // call handler only if file extension matches
+ const UInt32 kHashHandler = 1 << 13; // the handler contains the hashes (checksums)
+ const UInt32 kCTime = 1 << 14;
+ const UInt32 kCTime_Default = 1 << 15;
+ const UInt32 kATime = 1 << 16;
+ const UInt32 kATime_Default = 1 << 17;
+ const UInt32 kMTime = 1 << 18;
+ const UInt32 kMTime_Default = 1 << 19;
+ // const UInt32 kTTime_Reserved = 1 << 20;
+ // const UInt32 kTTime_Reserved_Default = 1 << 21;
+}
+
+namespace NArcInfoTimeFlags
+{
+ const unsigned kTime_Prec_Mask_bit_index = 0;
+ const unsigned kTime_Prec_Mask_num_bits = 26;
+
+ const unsigned kTime_Prec_Default_bit_index = 27;
+ const unsigned kTime_Prec_Default_num_bits = 5;
+}
+
+#define TIME_PREC_TO_ARC_FLAGS_MASK(v) \
+ ((UInt32)1 << (NArcInfoTimeFlags::kTime_Prec_Mask_bit_index + (v)))
+
+#define TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT(v) \
+ ((UInt32)(v) << NArcInfoTimeFlags::kTime_Prec_Default_bit_index)
+
+namespace NArchive
+{
+ namespace NHandlerPropID
+ {
+ enum
+ {
+ kName = 0, // VT_BSTR
+ kClassID, // binary GUID in VT_BSTR
+ kExtension, // VT_BSTR
+ kAddExtension, // VT_BSTR
+ kUpdate, // VT_BOOL
+ kKeepName, // VT_BOOL
+ kSignature, // binary in VT_BSTR
+ kMultiSignature, // binary in VT_BSTR
+ kSignatureOffset, // VT_UI4
+ kAltStreams, // VT_BOOL
+ kNtSecure, // VT_BOOL
+ kFlags, // VT_UI4
+ kTimeFlags // VT_UI4
+ };
+ }
+
+ namespace NExtract
+ {
+ namespace NAskMode
+ {
+ enum
+ {
+ kExtract = 0,
+ kTest,
+ kSkip,
+ kReadExternal
+ };
+ }
+
+ namespace NOperationResult
+ {
+ enum
+ {
+ kOK = 0,
+ kUnsupportedMethod,
+ kDataError,
+ kCRCError,
+ kUnavailable,
+ kUnexpectedEnd,
+ kDataAfterEnd,
+ kIsNotArc,
+ kHeadersError,
+ kWrongPassword
+ // , kMemError
+ };
+ }
+ }
+
+ namespace NEventIndexType
+ {
+ enum
+ {
+ kNoIndex = 0,
+ kInArcIndex,
+ kBlockIndex,
+ kOutArcIndex
+ // kArcProp
+ };
+ }
+
+ namespace NUpdate
+ {
+ namespace NOperationResult
+ {
+ enum
+ {
+ kOK = 0
+ // kError = 1,
+ // kError_FileChanged
+ };
+ }
+ }
+}
+
+#define Z7_IFACEM_IArchiveOpenCallback(x) \
+ x(SetTotal(const UInt64 *files, const UInt64 *bytes)) \
+ x(SetCompleted(const UInt64 *files, const UInt64 *bytes)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenCallback, 0x10)
+
+/*
+IArchiveExtractCallback::
+
+7-Zip doesn't call IArchiveExtractCallback functions
+ GetStream()
+ PrepareOperation()
+ SetOperationResult()
+from different threads simultaneously.
+But 7-Zip can call functions for IProgress or ICompressProgressInfo functions
+from another threads simultaneously with calls for IArchiveExtractCallback interface.
+
+IArchiveExtractCallback::GetStream()
+ UInt32 index - index of item in Archive
+ Int32 askExtractMode (Extract::NAskMode)
+ if (askMode != NExtract::NAskMode::kExtract)
+ {
+ then the callee doesn't write data to stream: (*outStream == NULL)
+ }
+
+ Out:
+ (*outStream == NULL) - for directories
+ (*outStream == NULL) - if link (hard link or symbolic link) was created
+ if (*outStream == NULL && askMode == NExtract::NAskMode::kExtract)
+ {
+ then the caller must skip extracting of that file.
+ }
+
+ returns:
+ S_OK : OK
+ S_FALSE : data error (for decoders)
+
+if (IProgress::SetTotal() was called)
+{
+ IProgress::SetCompleted(completeValue) uses
+ packSize - for some stream formats (xz, gz, bz2, lzma, z, ppmd).
+ unpackSize - for another formats.
+}
+else
+{
+ IProgress::SetCompleted(completeValue) uses packSize.
+}
+
+SetOperationResult()
+ 7-Zip calls SetOperationResult at the end of extracting,
+ so the callee can close the file, set attributes, timestamps and security information.
+
+ Int32 opRes (NExtract::NOperationResult)
+*/
+
+// INTERFACE_IProgress(x)
+
+#define Z7_IFACEM_IArchiveExtractCallback(x) \
+ x(GetStream(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode)) \
+ x(PrepareOperation(Int32 askExtractMode)) \
+ x(SetOperationResult(Int32 opRes)) \
+
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveExtractCallback, IProgress, 0x20)
+
+
+
+/*
+v23:
+IArchiveExtractCallbackMessage2 can be requested from IArchiveExtractCallback object
+ by Extract() or UpdateItems() functions to report about extracting errors
+ReportExtractResult()
+ UInt32 indexType (NEventIndexType)
+ UInt32 index
+ Int32 opRes (NExtract::NOperationResult)
+*/
+/*
+before v23:
+#define Z7_IFACEM_IArchiveExtractCallbackMessage(x) \
+ x(ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes))
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveExtractCallbackMessage, IProgress, 0x21)
+*/
+#define Z7_IFACEM_IArchiveExtractCallbackMessage2(x) \
+ x(ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveExtractCallbackMessage2, 0x22)
+
+#define Z7_IFACEM_IArchiveOpenVolumeCallback(x) \
+ x(GetProperty(PROPID propID, PROPVARIANT *value)) \
+ x(GetStream(const wchar_t *name, IInStream **inStream))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenVolumeCallback, 0x30)
+
+
+#define Z7_IFACEM_IInArchiveGetStream(x) \
+ x(GetStream(UInt32 index, ISequentialInStream **stream))
+Z7_IFACE_CONSTR_ARCHIVE(IInArchiveGetStream, 0x40)
+
+#define Z7_IFACEM_IArchiveOpenSetSubArchiveName(x) \
+ x(SetSubArchiveName(const wchar_t *name))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenSetSubArchiveName, 0x50)
+
+
+/*
+IInArchive::Open
+ stream
+ if (kUseGlobalOffset), stream current position can be non 0.
+ if (!kUseGlobalOffset), stream current position is 0.
+ if (maxCheckStartPosition == NULL), the handler can try to search archive start in stream
+ if (*maxCheckStartPosition == 0), the handler must check only current position as archive start
+
+IInArchive::Extract:
+ indices must be sorted
+ numItems = (UInt32)(Int32)-1 = 0xFFFFFFFF means "all files"
+ testMode != 0 means "test files without writing to outStream"
+
+IInArchive::GetArchiveProperty:
+ kpidOffset - start offset of archive.
+ VT_EMPTY : means offset = 0.
+ VT_UI4, VT_UI8, VT_I8 : result offset; negative values is allowed
+ kpidPhySize - size of archive. VT_EMPTY means unknown size.
+ kpidPhySize is allowed to be larger than file size. In that case it must show
+ supposed size.
+
+ kpidIsDeleted:
+ kpidIsAltStream:
+ kpidIsAux:
+ kpidINode:
+ must return VARIANT_TRUE (VT_BOOL), if archive can support that property in GetProperty.
+
+
+Notes:
+ Don't call IInArchive functions for same IInArchive object from different threads simultaneously.
+ Some IInArchive handlers will work incorrectly in that case.
+*/
+
+#if defined(_MSC_VER) && !defined(__clang__)
+ #define MY_NO_THROW_DECL_ONLY Z7_COM7F_E
+#else
+ #define MY_NO_THROW_DECL_ONLY
+#endif
+
+#define Z7_IFACEM_IInArchive(x) \
+ x(Open(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *openCallback)) \
+ x(Close()) \
+ x(GetNumberOfItems(UInt32 *numItems)) \
+ x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+ x(Extract(const UInt32 *indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback)) \
+ x(GetArchiveProperty(PROPID propID, PROPVARIANT *value)) \
+ x(GetNumberOfProperties(UInt32 *numProps)) \
+ x(GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ x(GetNumberOfArchiveProperties(UInt32 *numProps)) \
+ x(GetArchivePropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IInArchive, 0x60)
+
+namespace NParentType
+{
+ enum
+ {
+ kDir = 0,
+ kAltStream
+ };
+}
+
+namespace NPropDataType
+{
+ const UInt32 kMask_ZeroEnd = 1 << 4;
+ // const UInt32 kMask_BigEndian = 1 << 5;
+ const UInt32 kMask_Utf = 1 << 6;
+ const UInt32 kMask_Utf8 = kMask_Utf | 0;
+ const UInt32 kMask_Utf16 = kMask_Utf | 1;
+ // const UInt32 kMask_Utf32 = kMask_Utf | 2;
+
+ const UInt32 kNotDefined = 0;
+ const UInt32 kRaw = 1;
+
+ const UInt32 kUtf8z = kMask_Utf8 | kMask_ZeroEnd;
+ const UInt32 kUtf16z = kMask_Utf16 | kMask_ZeroEnd;
+}
+
+// UTF string (pointer to wchar_t) with zero end and little-endian.
+#define PROP_DATA_TYPE_wchar_t_PTR_Z_LE ((NPropDataType::kMask_Utf | NPropDataType::kMask_ZeroEnd) + (sizeof(wchar_t) >> 1))
+
+
+/*
+GetRawProp:
+ Result:
+ S_OK - even if property is not set
+*/
+
+#define Z7_IFACEM_IArchiveGetRawProps(x) \
+ x(GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType)) \
+ x(GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)) \
+ x(GetNumRawProps(UInt32 *numProps)) \
+ x(GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveGetRawProps, 0x70)
+
+#define Z7_IFACEM_IArchiveGetRootProps(x) \
+ x(GetRootProp(PROPID propID, PROPVARIANT *value)) \
+ x(GetRootRawProp(PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveGetRootProps, 0x71)
+
+#define Z7_IFACEM_IArchiveOpenSeq(x) \
+ x(OpenSeq(ISequentialInStream *stream)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenSeq, 0x61)
+
+/*
+ OpenForSize
+ Result:
+ S_FALSE - is not archive
+ ? - DATA error
+*/
+
+/*
+const UInt32 kOpenFlags_RealPhySize = 1 << 0;
+const UInt32 kOpenFlags_NoSeek = 1 << 1;
+// const UInt32 kOpenFlags_BeforeExtract = 1 << 2;
+*/
+
+/*
+Flags:
+ 0 - opens archive with IInStream, if IInStream interface is supported
+ - if phySize is not available, it doesn't try to make full parse to get phySize
+ kOpenFlags_NoSeek - ArcOpen2 function doesn't use IInStream interface, even if it's available
+ kOpenFlags_RealPhySize - the handler will try to get PhySize, even if it requires full decompression for file
+
+ if handler is not allowed to use IInStream and the flag kOpenFlags_RealPhySize is not specified,
+ the handler can return S_OK, but it doesn't check even Signature.
+ So next Extract can be called for that sequential stream.
+*/
+/*
+#define Z7_IFACEM_IArchiveOpen2(x) \
+ x(ArcOpen2(ISequentialInStream *stream, UInt32 flags, IArchiveOpenCallback *openCallback))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpen2, 0x62)
+*/
+
+// ---------- UPDATE ----------
+
+/*
+GetUpdateItemInfo outs:
+*newData *newProps
+ 0 0 - Copy data and properties from archive
+ 0 1 - Copy data from archive, request new properties
+ 1 0 - that combination is unused now
+ 1 1 - Request new data and new properties. It can be used even for folders
+
+ indexInArchive = -1 if there is no item in archive, or if it doesn't matter.
+
+
+GetStream out:
+ Result:
+ S_OK:
+ (*inStream == NULL) - only for directories
+ - the bug was fixed in 9.33: (*Stream == NULL) was in case of anti-file
+ (*inStream != NULL) - for any file, even for empty file or anti-file
+ S_FALSE - skip that file (don't add item to archive) - (client code can't open stream of that file by some reason)
+ (*inStream == NULL)
+
+The order of calling for hard links:
+ - GetStream()
+ - GetProperty(kpidHardLink)
+
+SetOperationResult()
+ Int32 opRes (NExtract::NOperationResult::kOK)
+*/
+
+// INTERFACE_IProgress(x)
+#define Z7_IFACEM_IArchiveUpdateCallback(x) \
+ x(GetUpdateItemInfo(UInt32 index, Int32 *newData, Int32 *newProps, UInt32 *indexInArchive)) \
+ x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+ x(GetStream(UInt32 index, ISequentialInStream **inStream)) \
+ x(SetOperationResult(Int32 operationResult)) \
+
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveUpdateCallback, IProgress, 0x80)
+
+// INTERFACE_IArchiveUpdateCallback(x)
+#define Z7_IFACEM_IArchiveUpdateCallback2(x) \
+ x(GetVolumeSize(UInt32 index, UInt64 *size)) \
+ x(GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream)) \
+
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveUpdateCallback2, IArchiveUpdateCallback, 0x82)
+
+namespace NUpdateNotifyOp
+{
+ enum
+ {
+ kAdd = 0,
+ kUpdate,
+ kAnalyze,
+ kReplicate,
+ kRepack,
+ kSkip,
+ kDelete,
+ kHeader,
+ kHashRead,
+ kInFileChanged
+ // , kOpFinished
+ // , kNumDefined
+ };
+}
+
+/*
+IArchiveUpdateCallbackFile::ReportOperation
+ UInt32 indexType (NEventIndexType)
+ UInt32 index
+ UInt32 notifyOp (NUpdateNotifyOp)
+*/
+
+#define Z7_IFACEM_IArchiveUpdateCallbackFile(x) \
+ x(GetStream2(UInt32 index, ISequentialInStream **inStream, UInt32 notifyOp)) \
+ x(ReportOperation(UInt32 indexType, UInt32 index, UInt32 notifyOp)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveUpdateCallbackFile, 0x83)
+
+
+#define Z7_IFACEM_IArchiveGetDiskProperty(x) \
+ x(GetDiskProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveGetDiskProperty, 0x84)
+
+/*
+#define Z7_IFACEM_IArchiveUpdateCallbackArcProp(x) \
+ x(ReportProp(UInt32 indexType, UInt32 index, PROPID propID, const PROPVARIANT *value)) \
+ x(ReportRawProp(UInt32 indexType, UInt32 index, PROPID propID, const void *data, UInt32 dataSize, UInt32 propType)) \
+ x(ReportFinished(UInt32 indexType, UInt32 index, Int32 opRes)) \
+ x(DoNeedArcProp(PROPID propID, Int32 *answer)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveUpdateCallbackArcProp, 0x85)
+*/
+
+/*
+UpdateItems()
+-------------
+
+ outStream: output stream. (the handler) MUST support the case when
+ Seek position in outStream is not ZERO.
+ but the caller calls with empty outStream and seek position is ZERO??
+
+ archives with stub:
+
+ If archive is open and the handler and (Offset > 0), then the handler
+ knows about stub size.
+ UpdateItems():
+ 1) the handler MUST copy that stub to outStream
+ 2) the caller MUST NOT copy the stub to outStream, if
+ "rsfx" property is set with SetProperties
+
+ the handler must support the case where
+ ISequentialOutStream *outStream
+*/
+
+
+#define Z7_IFACEM_IOutArchive(x) \
+ x(UpdateItems(ISequentialOutStream *outStream, UInt32 numItems, IArchiveUpdateCallback *updateCallback)) \
+ x(GetFileTimeType(UInt32 *type))
+
+Z7_IFACE_CONSTR_ARCHIVE(IOutArchive, 0xA0)
+
+
+/*
+ISetProperties::SetProperties()
+ PROPVARIANT values[i].vt:
+ VT_EMPTY
+ VT_BOOL
+ VT_UI4 - if 32-bit number
+ VT_UI8 - if 64-bit number
+ VT_BSTR
+*/
+
+#define Z7_IFACEM_ISetProperties(x) \
+ x(SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+
+Z7_IFACE_CONSTR_ARCHIVE(ISetProperties, 0x03)
+
+#define Z7_IFACEM_IArchiveKeepModeForNextOpen(x) \
+ x(KeepModeForNextOpen()) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveKeepModeForNextOpen, 0x04)
+
+/* Exe handler: the handler for executable format (PE, ELF, Mach-O).
+ SFX archive: executable stub + some tail data.
+ before 9.31: exe handler didn't parse SFX archives as executable format.
+ for 9.31+: exe handler parses SFX archives as executable format, only if AllowTail(1) was called */
+
+#define Z7_IFACEM_IArchiveAllowTail(x) \
+ x(AllowTail(Int32 allowTail)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveAllowTail, 0x05)
+
+
+
+struct CStatProp
+{
+ const char *Name;
+ UInt32 PropID;
+ VARTYPE vt;
+};
+
+namespace NWindows {
+namespace NCOM {
+// PropVariant.cpp
+BSTR AllocBstrFromAscii(const char *s) throw();
+}}
+
+
+#define IMP_IInArchive_GetProp_Base(fn, f, k) \
+ Z7_COM7F_IMF(CHandler::fn(UInt32 *numProps)) \
+ { *numProps = Z7_ARRAY_SIZE(k); return S_OK; } \
+ Z7_COM7F_IMF(CHandler::f(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ { if (index >= Z7_ARRAY_SIZE(k)) return E_INVALIDARG; \
+
+#define IMP_IInArchive_GetProp_NO_NAME(fn, f, k) \
+ IMP_IInArchive_GetProp_Base(fn, f, k) \
+ *propID = k[index]; \
+ *varType = k7z_PROPID_To_VARTYPE[(unsigned)*propID]; \
+ *name = NULL; return S_OK; } \
+
+#define IMP_IInArchive_GetProp_WITH_NAME(fn, f, k) \
+ IMP_IInArchive_GetProp_Base(fn, f, k) \
+ const CStatProp &prop = k[index]; \
+ *propID = (PROPID)prop.PropID; \
+ *varType = prop.vt; \
+ *name = NWindows::NCOM::AllocBstrFromAscii(prop.Name); return S_OK; } \
+
+
+#define IMP_IInArchive_Props \
+ IMP_IInArchive_GetProp_NO_NAME(GetNumberOfProperties, GetPropertyInfo, kProps)
+
+#define IMP_IInArchive_Props_WITH_NAME \
+ IMP_IInArchive_GetProp_WITH_NAME(GetNumberOfProperties, GetPropertyInfo, kProps)
+
+#define IMP_IInArchive_ArcProps \
+ IMP_IInArchive_GetProp_NO_NAME(GetNumberOfArchiveProperties, GetArchivePropertyInfo, kArcProps)
+
+#define IMP_IInArchive_ArcProps_WITH_NAME \
+ IMP_IInArchive_GetProp_WITH_NAME(GetNumberOfArchiveProperties, GetArchivePropertyInfo, kArcProps)
+
+#define IMP_IInArchive_ArcProps_NO_Table \
+ Z7_COM7F_IMF(CHandler::GetNumberOfArchiveProperties(UInt32 *numProps)) \
+ { *numProps = 0; return S_OK; } \
+ Z7_COM7F_IMF(CHandler::GetArchivePropertyInfo(UInt32, BSTR *, PROPID *, VARTYPE *)) \
+ { return E_NOTIMPL; } \
+
+#define IMP_IInArchive_ArcProps_NO \
+ IMP_IInArchive_ArcProps_NO_Table \
+ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID, PROPVARIANT *value)) \
+ { value->vt = VT_EMPTY; return S_OK; }
+
+
+#define Z7_class_CHandler_final \
+ Z7_class_final(CHandler)
+
+
+#define Z7_CLASS_IMP_CHandler_IInArchive_0 \
+ Z7_CLASS_IMP_COM_1(CHandler, IInArchive)
+#define Z7_CLASS_IMP_CHandler_IInArchive_1(i1) \
+ Z7_CLASS_IMP_COM_2(CHandler, IInArchive, i1)
+#define Z7_CLASS_IMP_CHandler_IInArchive_2(i1, i2) \
+ Z7_CLASS_IMP_COM_3(CHandler, IInArchive, i1, i2)
+#define Z7_CLASS_IMP_CHandler_IInArchive_3(i1, i2, i3) \
+ Z7_CLASS_IMP_COM_4(CHandler, IInArchive, i1, i2, i3)
+#define Z7_CLASS_IMP_CHandler_IInArchive_4(i1, i2, i3, i4) \
+ Z7_CLASS_IMP_COM_5(CHandler, IInArchive, i1, i2, i3, i4)
+#define Z7_CLASS_IMP_CHandler_IInArchive_5(i1, i2, i3, i4, i5) \
+ Z7_CLASS_IMP_COM_6(CHandler, IInArchive, i1, i2, i3, i4, i5)
+
+
+
+#define k_IsArc_Res_NO 0
+#define k_IsArc_Res_YES 1
+#define k_IsArc_Res_NEED_MORE 2
+// #define k_IsArc_Res_YES_LOW_PROB 3
+
+#define API_FUNC_IsArc EXTERN_C UInt32 WINAPI
+#define API_FUNC_static_IsArc extern "C" { static UInt32 WINAPI
+
+extern "C"
+{
+ typedef HRESULT (WINAPI *Func_CreateObject)(const GUID *clsID, const GUID *iid, void **outObject);
+
+ typedef UInt32 (WINAPI *Func_IsArc)(const Byte *p, size_t size);
+ typedef HRESULT (WINAPI *Func_GetIsArc)(UInt32 formatIndex, Func_IsArc *isArc);
+
+ typedef HRESULT (WINAPI *Func_GetNumberOfFormats)(UInt32 *numFormats);
+ typedef HRESULT (WINAPI *Func_GetHandlerProperty)(PROPID propID, PROPVARIANT *value);
+ typedef HRESULT (WINAPI *Func_GetHandlerProperty2)(UInt32 index, PROPID propID, PROPVARIANT *value);
+
+ typedef HRESULT (WINAPI *Func_SetCaseSensitive)(Int32 caseSensitive);
+ typedef HRESULT (WINAPI *Func_SetLargePageMode)();
+ // typedef HRESULT (WINAPI *Func_SetClientVersion)(UInt32 version);
+
+ typedef IOutArchive * (*Func_CreateOutArchive)();
+ typedef IInArchive * (*Func_CreateInArchive)();
+}
+
+
+/*
+ if there is no time in archive, external MTime of archive
+ will be used instead of _item.Time from archive.
+ For 7-zip before 22.00 we need to return some supported value.
+ But (kpidTimeType > kDOS) is not allowed in 7-Zip before 22.00.
+ So we return highest precision value supported by old 7-Zip.
+ new 7-Zip 22.00 doesn't use that value in usual cases.
+*/
+
+
+#define DECLARE_AND_SET_CLIENT_VERSION_VAR
+#define GET_FileTimeType_NotDefined_for_GetFileTimeType \
+ NFileTimeType::kWindows
+
+/*
+extern UInt32 g_ClientVersion;
+
+#define GET_CLIENT_VERSION(major, minor) \
+ ((UInt32)(((UInt32)(major) << 16) | (UInt32)(minor)))
+
+#define DECLARE_AND_SET_CLIENT_VERSION_VAR \
+ UInt32 g_ClientVersion = GET_CLIENT_VERSION(MY_VER_MAJOR, MY_VER_MINOR);
+
+#define GET_FileTimeType_NotDefined_for_GetFileTimeType \
+ ((UInt32)(g_ClientVersion >= GET_CLIENT_VERSION(22, 0) ? \
+ (UInt32)(Int32)NFileTimeType::kNotDefined : \
+ NFileTimeType::kWindows))
+*/
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/Archive/Icons/apfs.ico b/CPP/7zip/Archive/Icons/apfs.ico
new file mode 100644
index 0000000..124eb76
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/apfs.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/arj.ico b/CPP/7zip/Archive/Icons/arj.ico
new file mode 100644
index 0000000..c0f8b14
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/arj.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/bz2.ico b/CPP/7zip/Archive/Icons/bz2.ico
new file mode 100644
index 0000000..f22abeb
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/bz2.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/cab.ico b/CPP/7zip/Archive/Icons/cab.ico
new file mode 100644
index 0000000..c96c0f0
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/cab.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/cpio.ico b/CPP/7zip/Archive/Icons/cpio.ico
new file mode 100644
index 0000000..9abaabc
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/cpio.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/deb.ico b/CPP/7zip/Archive/Icons/deb.ico
new file mode 100644
index 0000000..97a0865
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/deb.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/dmg.ico b/CPP/7zip/Archive/Icons/dmg.ico
new file mode 100644
index 0000000..7d63b09
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/dmg.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/fat.ico b/CPP/7zip/Archive/Icons/fat.ico
new file mode 100644
index 0000000..7503d93
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/fat.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/gz.ico b/CPP/7zip/Archive/Icons/gz.ico
new file mode 100644
index 0000000..d402a69
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/gz.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/hfs.ico b/CPP/7zip/Archive/Icons/hfs.ico
new file mode 100644
index 0000000..bf2c198
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/hfs.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/iso.ico b/CPP/7zip/Archive/Icons/iso.ico
new file mode 100644
index 0000000..b3e3ac2
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/iso.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/lzh.ico b/CPP/7zip/Archive/Icons/lzh.ico
new file mode 100644
index 0000000..84dab49
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/lzh.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/lzma.ico b/CPP/7zip/Archive/Icons/lzma.ico
new file mode 100644
index 0000000..2de2c24
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/lzma.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/ntfs.ico b/CPP/7zip/Archive/Icons/ntfs.ico
new file mode 100644
index 0000000..6b2aeb0
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/ntfs.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/rar.ico b/CPP/7zip/Archive/Icons/rar.ico
new file mode 100644
index 0000000..2918d29
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/rar.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/rpm.ico b/CPP/7zip/Archive/Icons/rpm.ico
new file mode 100644
index 0000000..cdeb8d1
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/rpm.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/split.ico b/CPP/7zip/Archive/Icons/split.ico
new file mode 100644
index 0000000..65723ff
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/split.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/squashfs.ico b/CPP/7zip/Archive/Icons/squashfs.ico
new file mode 100644
index 0000000..b802d94
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/squashfs.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/tar.ico b/CPP/7zip/Archive/Icons/tar.ico
new file mode 100644
index 0000000..6835885
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/tar.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/vhd.ico b/CPP/7zip/Archive/Icons/vhd.ico
new file mode 100644
index 0000000..33bed3c
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/vhd.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/wim.ico b/CPP/7zip/Archive/Icons/wim.ico
new file mode 100644
index 0000000..887975e
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/wim.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/xar.ico b/CPP/7zip/Archive/Icons/xar.ico
new file mode 100644
index 0000000..281aa7d
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/xar.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/xz.ico b/CPP/7zip/Archive/Icons/xz.ico
new file mode 100644
index 0000000..bc07a7e
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/xz.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/z.ico b/CPP/7zip/Archive/Icons/z.ico
new file mode 100644
index 0000000..2db5358
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/z.ico
Binary files differ
diff --git a/CPP/7zip/Archive/Icons/zip.ico b/CPP/7zip/Archive/Icons/zip.ico
new file mode 100644
index 0000000..2af4606
--- /dev/null
+++ b/CPP/7zip/Archive/Icons/zip.ico
Binary files differ
diff --git a/CPP/7zip/Archive/IhexHandler.cpp b/CPP/7zip/Archive/IhexHandler.cpp
new file mode 100644
index 0000000..badb559
--- /dev/null
+++ b/CPP/7zip/Archive/IhexHandler.cpp
@@ -0,0 +1,493 @@
+// IhexHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/DynamicBuffer.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyVector.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+#include "../Common/InBuffer.h"
+
+namespace NArchive {
+namespace NIhex {
+
+/* We still don't support files with custom record types: 20, 22: used by Samsung */
+
+struct CBlock
+{
+ CByteDynamicBuffer Data;
+ UInt32 Offset;
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ bool _isArc;
+ bool _needMoreInput;
+ bool _dataError;
+
+ UInt64 _phySize;
+
+ CObjectVector<CBlock> _blocks;
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidVa
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _blocks.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_dataError) v |= kpv_ErrorFlags_DataError;
+ prop = v;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CBlock &block = _blocks[index];
+ switch (propID)
+ {
+ case kpidSize: prop = (UInt64)block.Data.GetPos(); break;
+ case kpidVa: prop = block.Offset; break;
+ case kpidPath:
+ {
+ if (_blocks.Size() != 1)
+ {
+ char s[16];
+ ConvertUInt32ToString(index, s);
+ prop = s;
+ }
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+static inline int HexToByte(unsigned c)
+{
+ if (c >= '0' && c <= '9') return (int)(c - '0');
+ if (c >= 'A' && c <= 'F') return (int)(c - 'A' + 10);
+ if (c >= 'a' && c <= 'f') return (int)(c - 'a' + 10);
+ return -1;
+}
+
+static int Parse(const Byte *p)
+{
+ const int c1 = HexToByte(p[0]); if (c1 < 0) return -1;
+ const int c2 = HexToByte(p[1]); if (c2 < 0) return -1;
+ return (c1 << 4) | c2;
+}
+
+#define kType_Data 0
+#define kType_Eof 1
+#define kType_Seg 2
+// #define kType_CsIp 3
+#define kType_High 4
+// #define kType_Ip32 5
+
+#define kType_MAX 5
+
+#define IS_LINE_DELIMITER(c) ((c) == 0 || (c) == 10 || (c) == 13)
+
+API_FUNC_static_IsArc IsArc_Ihex(const Byte *p, size_t size)
+{
+ if (size < 1)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != ':')
+ return k_IsArc_Res_NO;
+ p++;
+ size--;
+
+ const unsigned kNumLinesToCheck = 3; // 1 line is OK also, but we don't want false detection
+
+ for (unsigned j = 0; j < kNumLinesToCheck; j++)
+ {
+ if (size < 4 * 2)
+ return k_IsArc_Res_NEED_MORE;
+
+ int num = Parse(p);
+ if (num < 0)
+ return k_IsArc_Res_NO;
+
+ int type = Parse(p + 6);
+ if (type < 0 || type > kType_MAX)
+ return k_IsArc_Res_NO;
+
+ unsigned numChars = ((unsigned)num + 5) * 2;
+ unsigned sum = 0;
+
+ for (unsigned i = 0; i < numChars; i += 2)
+ {
+ if (i + 2 > size)
+ return k_IsArc_Res_NEED_MORE;
+ int v = Parse(p + i);
+ if (v < 0)
+ return k_IsArc_Res_NO;
+ sum += (unsigned)v;
+ }
+
+ if ((sum & 0xFF) != 0)
+ return k_IsArc_Res_NO;
+
+ if (type == kType_Data)
+ {
+ // we don't want to open :0000000000 files
+ if (num == 0)
+ return k_IsArc_Res_NO;
+ }
+ else
+ {
+ if (type == kType_Eof)
+ {
+ if (num != 0)
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+ }
+ if (p[2] != 0 ||
+ p[3] != 0 ||
+ p[4] != 0 ||
+ p[5] != 0)
+ return k_IsArc_Res_NO;
+ if (type == kType_Seg || type == kType_High)
+ {
+ if (num != 2)
+ return k_IsArc_Res_NO;
+ }
+ else
+ {
+ if (num != 4)
+ return k_IsArc_Res_NO;
+ }
+ }
+
+ p += numChars;
+ size -= numChars;
+
+ for (;;)
+ {
+ if (size == 0)
+ return k_IsArc_Res_NEED_MORE;
+ const Byte b = *p++;
+ size--;
+ if (IS_LINE_DELIMITER(b))
+ continue;
+ if (b == ':')
+ break;
+ return k_IsArc_Res_NO;
+ }
+ }
+
+ return k_IsArc_Res_YES;
+}
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ try
+ {
+ const unsigned kStartSize = (2 + (256 + 5) + 2) * 2;
+ Byte temp[kStartSize];
+ {
+ size_t size = kStartSize;
+ RINOK(ReadStream(stream, temp, &size))
+ UInt32 isArcRes = IsArc_Ihex(temp, size);
+ if (isArcRes == k_IsArc_Res_NO)
+ return S_FALSE;
+ if (isArcRes == k_IsArc_Res_NEED_MORE && size != kStartSize)
+ return S_FALSE;
+ }
+ _isArc = true;
+
+ RINOK(InStream_SeekToBegin(stream))
+ CInBuffer s;
+ if (!s.Create(1 << 15))
+ return E_OUTOFMEMORY;
+ s.SetStream(stream);
+ s.Init();
+
+ {
+ Byte b;
+ if (!s.ReadByte(b))
+ {
+ _needMoreInput = true;
+ return S_FALSE;
+ }
+ if (b != ':')
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+ }
+
+ UInt32 globalOffset = 0;
+
+ for (;;)
+ {
+ if (s.ReadBytes(temp, 2) != 2)
+ {
+ _needMoreInput = true;
+ return S_FALSE;
+ }
+ const int num = Parse(temp);
+ if (num < 0)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+
+ {
+ size_t numPairs = ((unsigned)num + 4);
+ size_t numBytes = numPairs * 2;
+ if (s.ReadBytes(temp, numBytes) != numBytes)
+ {
+ _needMoreInput = true;
+ return S_FALSE;
+ }
+
+ unsigned sum = (unsigned)num;
+ for (size_t i = 0; i < numPairs; i++)
+ {
+ const int a = Parse(temp + i * 2);
+ if (a < 0)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+ temp[i] = (Byte)a;
+ sum += (unsigned)a;
+ }
+ if ((sum & 0xFF) != 0)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+ }
+
+ unsigned type = temp[2];
+ if (type > kType_MAX)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+
+ UInt32 a = GetBe16(temp);
+
+ if (type == kType_Data)
+ {
+ if (num == 0)
+ {
+ // we don't want to open :0000000000 files
+ // maybe it can mean EOF in old-style files?
+ _dataError = true;
+ return S_FALSE;
+ }
+ // if (num != 0)
+ {
+ UInt32 offs = globalOffset + a;
+ CBlock *block = NULL;
+ if (!_blocks.IsEmpty())
+ {
+ block = &_blocks.Back();
+ if (block->Offset + block->Data.GetPos() != offs)
+ block = NULL;
+ }
+ if (!block)
+ {
+ block = &_blocks.AddNew();
+ block->Offset = offs;
+ }
+ block->Data.AddData(temp + 3, (unsigned)num);
+ }
+ }
+ else if (type == kType_Eof)
+ {
+ _phySize = s.GetProcessedSize();
+ {
+ Byte b;
+ if (s.ReadByte(b))
+ {
+ if (b == 10)
+ _phySize++;
+ else if (b == 13)
+ {
+ _phySize++;
+ if (s.ReadByte(b))
+ {
+ if (b == 10)
+ _phySize++;
+ }
+ }
+ }
+ }
+ return S_OK;
+ }
+ else
+ {
+ if (a != 0)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+ if (type == kType_Seg || type == kType_High)
+ {
+ if (num != 2)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+ UInt32 d = GetBe16(temp + 3);
+ globalOffset = d << (type == kType_Seg ? 4 : 16);
+ }
+ else
+ {
+ if (num != 4)
+ {
+ _dataError = true;
+ return S_FALSE;
+ }
+ }
+ }
+
+ for (;;)
+ {
+ Byte b;
+ if (!s.ReadByte(b))
+ {
+ _needMoreInput = true;
+ return S_FALSE;
+ }
+ if (IS_LINE_DELIMITER(b))
+ continue;
+ if (b == ':')
+ break;
+ _dataError = true;
+ return S_FALSE;
+ }
+ }
+ }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+
+ _isArc = false;
+ _needMoreInput = false;
+ _dataError = false;
+
+ _blocks.Clear();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _blocks.Size();
+ if (numItems == 0)
+ return S_OK;
+
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _blocks[allFilesMode ? i : indices[i]].Data.GetPos();
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+ UInt64 currentItemSize;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
+ {
+ currentItemSize = 0;
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CByteDynamicBuffer &data = _blocks[index].Data;
+ currentItemSize = data.GetPos();
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ extractCallback->PrepareOperation(askMode);
+
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, (const Byte *)data, data.GetPos()))
+ }
+
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+
+ lps->InSize = lps->OutSize = currentTotalSize;
+ return lps->SetCur();
+
+ COM_TRY_END
+}
+
+// k_Signature: { ':', '1' }
+
+REGISTER_ARC_I_NO_SIG(
+ "IHex", "ihex", NULL, 0xCD,
+ 0,
+ NArcInfoFlags::kStartOpen,
+ IsArc_Ihex)
+
+}}
diff --git a/CPP/7zip/Archive/Iso/IsoHandler.cpp b/CPP/7zip/Archive/Iso/IsoHandler.cpp
new file mode 100644
index 0000000..0c63c71
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoHandler.cpp
@@ -0,0 +1,486 @@
+// IsoHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/MyLinux.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "IsoHandler.h"
+
+using namespace NWindows;
+using namespace NTime;
+
+namespace NArchive {
+namespace NIso {
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ // kpidCTime,
+ // kpidATime,
+ kpidPosixAttrib,
+ // kpidUserId,
+ // kpidGroupId,
+ // kpidLinks,
+ kpidSymLink
+};
+
+static const Byte kArcProps[] =
+{
+ kpidComment,
+ kpidCTime,
+ kpidMTime,
+ // kpidHeadersSize
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ {
+ RINOK(_archive.Open(stream))
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _archive.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _archive.Refs.Size() + _archive.BootEntries.Size();
+ return S_OK;
+}
+
+static void AddString(AString &s, const char *name, const Byte *p, unsigned size)
+{
+ unsigned i;
+ for (i = 0; i < size && p[i]; i++);
+ for (; i > 0 && p[i - 1] == ' '; i--);
+ if (i != 0)
+ {
+ AString d;
+ d.SetFrom((const char *)p, i);
+ s += '\n';
+ s += name;
+ s += ": ";
+ s += d;
+ }
+}
+
+#define ADD_STRING(n, v) AddString(s, n, vol. v, sizeof(vol. v))
+
+static void AddErrorMessage(AString &s, const char *message)
+{
+ if (!s.IsEmpty())
+ s += ". ";
+ s += message;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (_stream)
+ {
+ const CVolumeDescriptor &vol = _archive.VolDescs[_archive.MainVolDescIndex];
+ switch (propID)
+ {
+ case kpidComment:
+ {
+ AString s;
+ ADD_STRING("System", SystemId);
+ ADD_STRING("Volume", VolumeId);
+ ADD_STRING("VolumeSet", VolumeSetId);
+ ADD_STRING("Publisher", PublisherId);
+ ADD_STRING("Preparer", DataPreparerId);
+ ADD_STRING("Application", ApplicationId);
+ ADD_STRING("Copyright", CopyrightFileId);
+ ADD_STRING("Abstract", AbstractFileId);
+ ADD_STRING("Bib", BibFileId);
+ prop = s;
+ break;
+ }
+ case kpidCTime: { vol.CTime.GetFileTime(prop); break; }
+ case kpidMTime: { vol.MTime.GetFileTime(prop); break; }
+ }
+ }
+
+ switch (propID)
+ {
+ case kpidPhySize: prop = _archive.PhySize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_archive.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_archive.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_archive.HeadersError) v |= kpv_ErrorFlags_HeadersError;
+ prop = v;
+ break;
+ }
+
+ case kpidError:
+ {
+ AString s;
+ if (_archive.IncorrectBigEndian)
+ AddErrorMessage(s, "Incorrect big-endian headers");
+ if (_archive.SelfLinkedDirs)
+ AddErrorMessage(s, "Self-linked directory");
+ if (_archive.TooDeepDirs)
+ AddErrorMessage(s, "Too deep directory levels");
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (index >= (UInt32)_archive.Refs.Size())
+ {
+ index -= _archive.Refs.Size();
+ const CBootInitialEntry &be = _archive.BootEntries[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString s ("[BOOT]" STRING_PATH_SEPARATOR);
+ if (_archive.BootEntries.Size() != 1)
+ {
+ s.Add_UInt32(index + 1);
+ s.Add_Minus();
+ }
+ s += be.GetName();
+ prop = s;
+ break;
+ }
+ case kpidIsDir: prop = false; break;
+ case kpidSize:
+ case kpidPackSize:
+ prop = (UInt64)_archive.GetBootItemSize(index);
+ break;
+ }
+ }
+ else
+ {
+ const CRef &ref = _archive.Refs[index];
+ const CDir &item = ref.Dir->_subItems[ref.Index];
+ switch (propID)
+ {
+ case kpidPath:
+ // if (item.FileId.GetCapacity() >= 0)
+ {
+ UString s;
+ if (_archive.IsJoliet())
+ item.GetPathU(s);
+ else
+ s = MultiByteToUnicodeString(item.GetPath(_archive.IsSusp, _archive.SuspSkipSize), CP_OEMCP);
+
+ if (s.Len() >= 2 && s[s.Len() - 2] == ';' && s.Back() == '1')
+ s.DeleteFrom(s.Len() - 2);
+
+ if (!s.IsEmpty() && s.Back() == L'.')
+ s.DeleteBack();
+
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(s);
+ prop = s;
+ }
+ break;
+
+ case kpidSymLink:
+ if (_archive.IsSusp)
+ {
+ UInt32 mode;
+ if (item.GetPx(_archive.SuspSkipSize, k_Px_Mode, mode))
+ {
+ if (MY_LIN_S_ISLNK(mode))
+ {
+ AString s8;
+ if (item.GetSymLink(_archive.SuspSkipSize, s8))
+ {
+ UString s = MultiByteToUnicodeString(s8, CP_OEMCP);
+ prop = s;
+ }
+ }
+ }
+ }
+ break;
+
+
+ case kpidPosixAttrib:
+ /*
+ case kpidLinks:
+ case kpidUserId:
+ case kpidGroupId:
+ */
+ {
+ if (_archive.IsSusp)
+ {
+ UInt32 t = 0;
+ switch (propID)
+ {
+ case kpidPosixAttrib: t = k_Px_Mode; break;
+ /*
+ case kpidLinks: t = k_Px_Links; break;
+ case kpidUserId: t = k_Px_User; break;
+ case kpidGroupId: t = k_Px_Group; break;
+ */
+ }
+ UInt32 v;
+ if (item.GetPx(_archive.SuspSkipSize, t, v))
+ prop = v;
+ }
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize:
+ case kpidPackSize:
+ if (!item.IsDir())
+ prop = (UInt64)ref.TotalSize;
+ break;
+
+ case kpidMTime:
+ // case kpidCTime:
+ // case kpidATime:
+ {
+ // if
+ item.DateTime.GetFileTime(prop);
+ /*
+ else
+ {
+ UInt32 t = 0;
+ switch (propID)
+ {
+ case kpidMTime: t = k_Tf_MTime; break;
+ case kpidCTime: t = k_Tf_CTime; break;
+ case kpidATime: t = k_Tf_ATime; break;
+ }
+ CRecordingDateTime dt;
+ if (item.GetTf(_archive.SuspSkipSize, t, dt))
+ {
+ FILETIME utc;
+ if (dt.GetFileTime(utc))
+ prop = utc;
+ }
+ }
+ */
+ break;
+ }
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _archive.Refs.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ UInt32 index = (allFilesMode ? i : indices[i]);
+ if (index < (UInt32)_archive.Refs.Size())
+ {
+ const CRef &ref = _archive.Refs[index];
+ const CDir &item = ref.Dir->_subItems[ref.Index];
+ if (!item.IsDir())
+ totalSize += ref.TotalSize;
+ }
+ else
+ totalSize += _archive.GetBootItemSize(index - _archive.Refs.Size());
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+ UInt64 currentItemSize;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ currentItemSize = 0;
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ UInt64 blockIndex;
+ if (index < (UInt32)_archive.Refs.Size())
+ {
+ const CRef &ref = _archive.Refs[index];
+ const CDir &item = ref.Dir->_subItems[ref.Index];
+ if (item.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ currentItemSize = ref.TotalSize;
+ blockIndex = item.ExtentLocation;
+ }
+ else
+ {
+ unsigned bootIndex = index - _archive.Refs.Size();
+ const CBootInitialEntry &be = _archive.BootEntries[bootIndex];
+ currentItemSize = _archive.GetBootItemSize(bootIndex);
+ blockIndex = be.LoadRBA;
+ }
+
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ bool isOK = true;
+ if (index < (UInt32)_archive.Refs.Size())
+ {
+ const CRef &ref = _archive.Refs[index];
+ UInt64 offset = 0;
+ for (UInt32 e = 0; e < ref.NumExtents; e++)
+ {
+ const CDir &item2 = ref.Dir->_subItems[ref.Index + e];
+ if (item2.Size == 0)
+ continue;
+ lps->InSize = lps->OutSize = currentTotalSize + offset;
+ RINOK(InStream_SeekSet(_stream, (UInt64)item2.ExtentLocation * kBlockSize))
+ streamSpec->Init(item2.Size);
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize != item2.Size)
+ {
+ isOK = false;
+ break;
+ }
+ offset += item2.Size;
+ }
+ }
+ else
+ {
+ RINOK(InStream_SeekSet(_stream, (UInt64)blockIndex * kBlockSize))
+ streamSpec->Init(currentItemSize);
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize != currentItemSize)
+ isOK = false;
+ }
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(isOK ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ UInt64 blockIndex;
+ UInt64 currentItemSize;
+
+ if (index < _archive.Refs.Size())
+ {
+ const CRef &ref = _archive.Refs[index];
+ const CDir &item = ref.Dir->_subItems[ref.Index];
+ if (item.IsDir())
+ return S_FALSE;
+
+ if (ref.NumExtents > 1)
+ {
+ CExtentsStream *extentStreamSpec = new CExtentsStream();
+ CMyComPtr<ISequentialInStream> extentStream = extentStreamSpec;
+
+ extentStreamSpec->Stream = _stream;
+
+ UInt64 virtOffset = 0;
+ for (UInt32 i = 0; i < ref.NumExtents; i++)
+ {
+ const CDir &item2 = ref.Dir->_subItems[ref.Index + i];
+ if (item2.Size == 0)
+ continue;
+ CSeekExtent se;
+ se.Phy = (UInt64)item2.ExtentLocation * kBlockSize;
+ se.Virt = virtOffset;
+ extentStreamSpec->Extents.Add(se);
+ virtOffset += item2.Size;
+ }
+ if (virtOffset != ref.TotalSize)
+ return S_FALSE;
+ CSeekExtent se;
+ se.Phy = 0;
+ se.Virt = virtOffset;
+ extentStreamSpec->Extents.Add(se);
+ extentStreamSpec->Init();
+ *stream = extentStream.Detach();
+ return S_OK;
+ }
+
+ currentItemSize = item.Size;
+ blockIndex = item.ExtentLocation;
+ }
+ else
+ {
+ unsigned bootIndex = index - _archive.Refs.Size();
+ const CBootInitialEntry &be = _archive.BootEntries[bootIndex];
+ currentItemSize = _archive.GetBootItemSize(bootIndex);
+ blockIndex = be.LoadRBA;
+ }
+
+ return CreateLimitedInStream(_stream, (UInt64)blockIndex * kBlockSize, currentItemSize, stream);
+ COM_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Archive/Iso/IsoHandler.h b/CPP/7zip/Archive/Iso/IsoHandler.h
new file mode 100644
index 0000000..507814a
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoHandler.h
@@ -0,0 +1,24 @@
+// IsoHandler.h
+
+#ifndef ZIP7_INC_ISO_HANDLER_H
+#define ZIP7_INC_ISO_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../IArchive.h"
+
+#include "IsoIn.h"
+
+namespace NArchive {
+namespace NIso {
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CMyComPtr<IInStream> _stream;
+ CInArchive _archive;
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Iso/IsoHeader.cpp b/CPP/7zip/Archive/Iso/IsoHeader.cpp
new file mode 100644
index 0000000..3b59060
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoHeader.cpp
@@ -0,0 +1,12 @@
+// Archive/Iso/Header.h
+
+#include "StdAfx.h"
+
+#include "IsoHeader.h"
+
+namespace NArchive {
+namespace NIso {
+
+const char * const kElToritoSpec = "EL TORITO SPECIFICATION\0\0\0\0\0\0\0\0\0";
+
+}}
diff --git a/CPP/7zip/Archive/Iso/IsoHeader.h b/CPP/7zip/Archive/Iso/IsoHeader.h
new file mode 100644
index 0000000..0b14c9f
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoHeader.h
@@ -0,0 +1,64 @@
+// Archive/IsoHeader.h
+
+#ifndef ZIP7_INC_ARCHIVE_ISO_HEADER_H
+#define ZIP7_INC_ARCHIVE_ISO_HEADER_H
+
+#include "../../../Common/MyTypes.h"
+
+namespace NArchive {
+namespace NIso {
+
+namespace NVolDescType
+{
+ const Byte kBootRecord = 0;
+ const Byte kPrimaryVol = 1;
+ const Byte kSupplementaryVol = 2;
+ const Byte kVolParttition = 3;
+ const Byte kTerminator = 255;
+}
+
+const Byte kVersion = 1;
+
+namespace NFileFlags
+{
+ const Byte kDirectory = 1 << 1;
+ const Byte kNonFinalExtent = 1 << 7;
+}
+
+extern const char * const kElToritoSpec;
+
+const UInt32 kStartPos = 0x8000;
+
+namespace NBootEntryId
+{
+ const Byte kValidationEntry = 1;
+ const Byte kInitialEntryNotBootable = 0;
+ const Byte kInitialEntryBootable = 0x88;
+
+ const Byte kMoreHeaders = 0x90;
+ const Byte kFinalHeader = 0x91;
+
+ const Byte kExtensionIndicator = 0x44;
+}
+
+namespace NBootPlatformId
+{
+ const Byte kX86 = 0;
+ const Byte kPowerPC = 1;
+ const Byte kMac = 2;
+}
+
+const Byte kBootMediaTypeMask = 0xF;
+
+namespace NBootMediaType
+{
+ const Byte kNoEmulation = 0;
+ const Byte k1d2Floppy = 1;
+ const Byte k1d44Floppy = 2;
+ const Byte k2d88Floppy = 3;
+ const Byte kHardDisk = 4;
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Iso/IsoIn.cpp b/CPP/7zip/Archive/Iso/IsoIn.cpp
new file mode 100644
index 0000000..1d3a42f
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoIn.cpp
@@ -0,0 +1,693 @@
+// Archive/IsoIn.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyException.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "../HandlerCont.h"
+
+#include "IsoIn.h"
+
+namespace NArchive {
+namespace NIso {
+
+struct CUnexpectedEndException {};
+struct CHeaderErrorException {};
+struct CEndianErrorException {};
+
+static const char * const kMediaTypes[] =
+{
+ "NoEmul"
+ , "1.2M"
+ , "1.44M"
+ , "2.88M"
+ , "HardDisk"
+};
+
+bool CBootInitialEntry::Parse(const Byte *p)
+{
+ Bootable = (p[0] == NBootEntryId::kInitialEntryBootable);
+ BootMediaType = p[1];
+ LoadSegment = GetUi16(p + 2);
+ SystemType = p[4];
+ SectorCount = GetUi16(p + 6);
+ LoadRBA = GetUi32(p + 8);
+ memcpy(VendorSpec, p + 12, 20);
+ if (p[5] != 0)
+ return false;
+ if (p[0] != NBootEntryId::kInitialEntryBootable
+ && p[0] != NBootEntryId::kInitialEntryNotBootable)
+ return false;
+ return true;
+}
+
+AString CBootInitialEntry::GetName() const
+{
+ AString s (Bootable ? "Boot" : "NotBoot");
+ s.Add_Minus();
+
+ if (BootMediaType < Z7_ARRAY_SIZE(kMediaTypes))
+ s += kMediaTypes[BootMediaType];
+ else
+ s.Add_UInt32(BootMediaType);
+
+ if (VendorSpec[0] == 1)
+ {
+ // "Language and Version Information (IBM)"
+
+ unsigned i;
+ for (i = 1; i < sizeof(VendorSpec); i++)
+ if (VendorSpec[i] > 0x7F)
+ break;
+ if (i == sizeof(VendorSpec))
+ {
+ s.Add_Minus();
+ for (i = 1; i < sizeof(VendorSpec); i++)
+ {
+ char c = (char)VendorSpec[i];
+ if (c == 0)
+ break;
+ if (c == '\\' || c == '/')
+ c = '_';
+ s += c;
+ }
+ }
+ }
+
+ s += ".img";
+ return s;
+}
+
+Byte CInArchive::ReadByte()
+{
+ if (m_BufferPos >= kBlockSize)
+ m_BufferPos = 0;
+ if (m_BufferPos == 0)
+ {
+ size_t processed = kBlockSize;
+ HRESULT res = ReadStream(_stream, m_Buffer, &processed);
+ if (res != S_OK)
+ throw CSystemException(res);
+ if (processed != kBlockSize)
+ throw CUnexpectedEndException();
+ UInt64 end = _position + processed;
+ if (PhySize < end)
+ PhySize = end;
+ }
+ Byte b = m_Buffer[m_BufferPos++];
+ _position++;
+ return b;
+}
+
+void CInArchive::ReadBytes(Byte *data, UInt32 size)
+{
+ for (UInt32 i = 0; i < size; i++)
+ data[i] = ReadByte();
+}
+
+void CInArchive::Skip(size_t size)
+{
+ while (size-- != 0)
+ ReadByte();
+}
+
+void CInArchive::SkipZeros(size_t size)
+{
+ while (size-- != 0)
+ {
+ Byte b = ReadByte();
+ if (b != 0)
+ throw CHeaderErrorException();
+ }
+}
+
+UInt16 CInArchive::ReadUInt16()
+{
+ Byte b[4];
+ ReadBytes(b, 4);
+ UInt32 val = 0;
+ for (int i = 0; i < 2; i++)
+ {
+ if (b[i] != b[3 - i])
+ IncorrectBigEndian = true;
+ val |= ((UInt32)(b[i]) << (8 * i));
+ }
+ return (UInt16)val;
+}
+
+UInt32 CInArchive::ReadUInt32Le()
+{
+ UInt32 val = 0;
+ for (int i = 0; i < 4; i++)
+ val |= ((UInt32)(ReadByte()) << (8 * i));
+ return val;
+}
+
+UInt32 CInArchive::ReadUInt32Be()
+{
+ UInt32 val = 0;
+ for (int i = 0; i < 4; i++)
+ {
+ val <<= 8;
+ val |= ReadByte();
+ }
+ return val;
+}
+
+UInt32 CInArchive::ReadUInt32()
+{
+ Byte b[8];
+ ReadBytes(b, 8);
+ UInt32 val = 0;
+ for (int i = 0; i < 4; i++)
+ {
+ if (b[i] != b[7 - i])
+ throw CEndianErrorException();
+ val |= ((UInt32)(b[i]) << (8 * i));
+ }
+ return val;
+}
+
+UInt32 CInArchive::ReadDigits(int numDigits)
+{
+ UInt32 res = 0;
+ for (int i = 0; i < numDigits; i++)
+ {
+ Byte b = ReadByte();
+ if (b < '0' || b > '9')
+ {
+ if (b == 0 || b == ' ') // it's bug in some CD's
+ b = '0';
+ else
+ throw CHeaderErrorException();
+ }
+ UInt32 d = (UInt32)(b - '0');
+ res *= 10;
+ res += d;
+ }
+ return res;
+}
+
+void CInArchive::ReadDateTime(CDateTime &d)
+{
+ d.Year = (UInt16)ReadDigits(4);
+ d.Month = (Byte)ReadDigits(2);
+ d.Day = (Byte)ReadDigits(2);
+ d.Hour = (Byte)ReadDigits(2);
+ d.Minute = (Byte)ReadDigits(2);
+ d.Second = (Byte)ReadDigits(2);
+ d.Hundredths = (Byte)ReadDigits(2);
+ d.GmtOffset = (signed char)ReadByte();
+}
+
+void CInArchive::ReadBootRecordDescriptor(CBootRecordDescriptor &d)
+{
+ ReadBytes(d.BootSystemId, sizeof(d.BootSystemId));
+ ReadBytes(d.BootId, sizeof(d.BootId));
+ ReadBytes(d.BootSystemUse, sizeof(d.BootSystemUse));
+}
+
+void CInArchive::ReadRecordingDateTime(CRecordingDateTime &t)
+{
+ t.Year = ReadByte();
+ t.Month = ReadByte();
+ t.Day = ReadByte();
+ t.Hour = ReadByte();
+ t.Minute = ReadByte();
+ t.Second = ReadByte();
+ t.GmtOffset = (signed char)ReadByte();
+}
+
+void CInArchive::ReadDirRecord2(CDirRecord &r, Byte len)
+{
+ r.ExtendedAttributeRecordLen = ReadByte();
+ if (r.ExtendedAttributeRecordLen != 0)
+ throw CHeaderErrorException();
+ r.ExtentLocation = ReadUInt32();
+ r.Size = ReadUInt32();
+ ReadRecordingDateTime(r.DateTime);
+ r.FileFlags = ReadByte();
+ r.FileUnitSize = ReadByte();
+ r.InterleaveGapSize = ReadByte();
+ r.VolSequenceNumber = ReadUInt16();
+ Byte idLen = ReadByte();
+ r.FileId.Alloc(idLen);
+ ReadBytes((Byte *)r.FileId, idLen);
+ unsigned padSize = 1 - (idLen & 1);
+
+ // SkipZeros(padSize);
+ Skip(padSize); // it's bug in some cd's. Must be zeros
+
+ unsigned curPos = 33 + idLen + padSize;
+ if (curPos > len)
+ throw CHeaderErrorException();
+ unsigned rem = len - curPos;
+ r.SystemUse.Alloc(rem);
+ ReadBytes((Byte *)r.SystemUse, rem);
+}
+
+void CInArchive::ReadDirRecord(CDirRecord &r)
+{
+ Byte len = ReadByte();
+ // Some CDs can have incorrect value len = 48 ('0') in VolumeDescriptor.
+ // But maybe we must use real "len" for other records.
+ len = 34;
+ ReadDirRecord2(r, len);
+}
+
+void CInArchive::ReadVolumeDescriptor(CVolumeDescriptor &d)
+{
+ d.VolFlags = ReadByte();
+ ReadBytes(d.SystemId, sizeof(d.SystemId));
+ ReadBytes(d.VolumeId, sizeof(d.VolumeId));
+ SkipZeros(8);
+ d.VolumeSpaceSize = ReadUInt32();
+ ReadBytes(d.EscapeSequence, sizeof(d.EscapeSequence));
+ d.VolumeSetSize = ReadUInt16();
+ d.VolumeSequenceNumber = ReadUInt16();
+ d.LogicalBlockSize = ReadUInt16();
+ d.PathTableSize = ReadUInt32();
+ d.LPathTableLocation = ReadUInt32Le();
+ d.LOptionalPathTableLocation = ReadUInt32Le();
+ d.MPathTableLocation = ReadUInt32Be();
+ d.MOptionalPathTableLocation = ReadUInt32Be();
+ ReadDirRecord(d.RootDirRecord);
+ ReadBytes(d.VolumeSetId, sizeof(d.VolumeSetId));
+ ReadBytes(d.PublisherId, sizeof(d.PublisherId));
+ ReadBytes(d.DataPreparerId, sizeof(d.DataPreparerId));
+ ReadBytes(d.ApplicationId, sizeof(d.ApplicationId));
+ ReadBytes(d.CopyrightFileId, sizeof(d.CopyrightFileId));
+ ReadBytes(d.AbstractFileId, sizeof(d.AbstractFileId));
+ ReadBytes(d.BibFileId, sizeof(d.BibFileId));
+ ReadDateTime(d.CTime);
+ ReadDateTime(d.MTime);
+ ReadDateTime(d.ExpirationTime);
+ ReadDateTime(d.EffectiveTime);
+ d.FileStructureVersion = ReadByte(); // = 1
+ SkipZeros(1);
+ ReadBytes(d.ApplicationUse, sizeof(d.ApplicationUse));
+
+ // Most ISO contains zeros in the following field (reserved for future standardization).
+ // But some ISO programs write some data to that area.
+ // So we disable check for zeros.
+ Skip(653); // SkipZeros(653);
+}
+
+static const Byte kSig_CD001[5] = { 'C', 'D', '0', '0', '1' };
+
+/*
+static const Byte kSig_NSR02[5] = { 'N', 'S', 'R', '0', '2' };
+static const Byte kSig_NSR03[5] = { 'N', 'S', 'R', '0', '3' };
+static const Byte kSig_BEA01[5] = { 'B', 'E', 'A', '0', '1' };
+static const Byte kSig_TEA01[5] = { 'T', 'E', 'A', '0', '1' };
+*/
+
+static inline bool CheckSignature(const Byte *sig, const Byte *data)
+{
+ for (int i = 0; i < 5; i++)
+ if (sig[i] != data[i])
+ return false;
+ return true;
+}
+
+void CInArchive::SeekToBlock(UInt32 blockIndex)
+{
+ const HRESULT res = _stream->Seek(
+ (Int64)((UInt64)blockIndex * VolDescs[MainVolDescIndex].LogicalBlockSize),
+ STREAM_SEEK_SET, &_position);
+ if (res != S_OK)
+ throw CSystemException(res);
+ m_BufferPos = 0;
+}
+
+static const int kNumLevelsMax = 256;
+
+void CInArchive::ReadDir(CDir &d, int level)
+{
+ if (!d.IsDir())
+ return;
+ if (level > kNumLevelsMax)
+ {
+ TooDeepDirs = true;
+ return;
+ }
+
+ {
+ FOR_VECTOR (i, UniqStartLocations)
+ if (UniqStartLocations[i] == d.ExtentLocation)
+ {
+ SelfLinkedDirs = true;
+ return;
+ }
+ UniqStartLocations.Add(d.ExtentLocation);
+ }
+
+ SeekToBlock(d.ExtentLocation);
+ UInt64 startPos = _position;
+
+ bool firstItem = true;
+ for (;;)
+ {
+ UInt64 offset = _position - startPos;
+ if (offset >= d.Size)
+ break;
+ Byte len = ReadByte();
+ if (len == 0)
+ continue;
+ CDir subItem;
+ ReadDirRecord2(subItem, len);
+ if (firstItem && level == 0)
+ IsSusp = subItem.CheckSusp(SuspSkipSize);
+
+ if (!subItem.IsSystemItem())
+ d._subItems.Add(subItem);
+
+ firstItem = false;
+ }
+ FOR_VECTOR (i, d._subItems)
+ ReadDir(d._subItems[i], level + 1);
+
+ UniqStartLocations.DeleteBack();
+}
+
+void CInArchive::CreateRefs(CDir &d)
+{
+ if (!d.IsDir())
+ return;
+ for (unsigned i = 0; i < d._subItems.Size();)
+ {
+ CRef ref;
+ CDir &subItem = d._subItems[i];
+ subItem.Parent = &d;
+ ref.Dir = &d;
+ ref.Index = i++;
+ ref.NumExtents = 1;
+ ref.TotalSize = subItem.Size;
+ if (subItem.IsNonFinalExtent())
+ {
+ for (;;)
+ {
+ if (i == d._subItems.Size())
+ {
+ HeadersError = true;
+ break;
+ }
+ const CDir &next = d._subItems[i];
+ if (!subItem.AreMultiPartEqualWith(next))
+ break;
+ i++;
+ ref.NumExtents++;
+ ref.TotalSize += next.Size;
+ if (!next.IsNonFinalExtent())
+ break;
+ }
+ }
+ Refs.Add(ref);
+ CreateRefs(subItem);
+ }
+}
+
+void CInArchive::ReadBootInfo()
+{
+ if (!_bootIsDefined)
+ return;
+ HeadersError = true;
+
+ if (memcmp(_bootDesc.BootSystemId, kElToritoSpec, sizeof(_bootDesc.BootSystemId)) != 0)
+ return;
+
+ UInt32 blockIndex = GetUi32(_bootDesc.BootSystemUse);
+ SeekToBlock(blockIndex);
+
+ Byte buf[32];
+ ReadBytes(buf, 32);
+
+ if (buf[0] != NBootEntryId::kValidationEntry
+ || buf[2] != 0
+ || buf[3] != 0
+ || buf[30] != 0x55
+ || buf[31] != 0xAA)
+ return;
+
+ {
+ UInt32 sum = 0;
+ for (unsigned i = 0; i < 32; i += 2)
+ sum += GetUi16(buf + i);
+ if ((sum & 0xFFFF) != 0)
+ return;
+ /*
+ CBootValidationEntry e;
+ e.PlatformId = buf[1];
+ memcpy(e.Id, buf + 4, sizeof(e.Id));
+ // UInt16 checkSum = GetUi16(p + 28);
+ */
+ }
+
+ ReadBytes(buf, 32);
+ {
+ CBootInitialEntry e;
+ if (!e.Parse(buf))
+ return;
+ BootEntries.Add(e);
+ }
+
+ bool error = false;
+
+ for (;;)
+ {
+ ReadBytes(buf, 32);
+ Byte headerIndicator = buf[0];
+ if (headerIndicator != NBootEntryId::kMoreHeaders
+ && headerIndicator != NBootEntryId::kFinalHeader)
+ break;
+
+ // Section Header
+ // Byte platform = p[1];
+ unsigned numEntries = GetUi16(buf + 2);
+ // id[28]
+
+ for (unsigned i = 0; i < numEntries; i++)
+ {
+ ReadBytes(buf, 32);
+ CBootInitialEntry e;
+ if (!e.Parse(buf))
+ {
+ error = true;
+ break;
+ }
+ if (e.BootMediaType & (1 << 5))
+ {
+ // Section entry extension
+ for (unsigned j = 0;; j++)
+ {
+ ReadBytes(buf, 32);
+ if (j > 32 || buf[0] != NBootEntryId::kExtensionIndicator)
+ {
+ error = true;
+ break;
+ }
+ if ((buf[1] & (1 << 5)) == 0)
+ break;
+ // info += (buf + 2, 30)
+ }
+ }
+ BootEntries.Add(e);
+ }
+
+ if (headerIndicator != NBootEntryId::kMoreHeaders)
+ break;
+ }
+
+ HeadersError = error;
+}
+
+HRESULT CInArchive::Open2()
+{
+ _position = 0;
+ RINOK(InStream_GetSize_SeekToEnd(_stream, _fileSize))
+ if (_fileSize < kStartPos)
+ return S_FALSE;
+ RINOK(_stream->Seek(kStartPos, STREAM_SEEK_SET, &_position))
+
+ PhySize = _position;
+ m_BufferPos = 0;
+ // BlockSize = kBlockSize;
+
+ for (;;)
+ {
+ Byte sig[7];
+ ReadBytes(sig, 7);
+ Byte ver = sig[6];
+
+ if (!CheckSignature(kSig_CD001, sig + 1))
+ {
+ return S_FALSE;
+ /*
+ if (sig[0] != 0 || ver != 1)
+ break;
+ if (CheckSignature(kSig_BEA01, sig + 1))
+ {
+ }
+ else if (CheckSignature(kSig_TEA01, sig + 1))
+ {
+ break;
+ }
+ else if (CheckSignature(kSig_NSR02, sig + 1))
+ {
+ }
+ else
+ break;
+ SkipZeros(0x800 - 7);
+ continue;
+ */
+ }
+
+ // version = 2 for ISO 9660:1999?
+ if (ver > 2)
+ return S_FALSE;
+
+ if (sig[0] == NVolDescType::kTerminator)
+ {
+ break;
+ // Skip(0x800 - 7);
+ // continue;
+ }
+
+ switch (sig[0])
+ {
+ case NVolDescType::kBootRecord:
+ {
+ _bootIsDefined = true;
+ ReadBootRecordDescriptor(_bootDesc);
+ break;
+ }
+ case NVolDescType::kPrimaryVol:
+ case NVolDescType::kSupplementaryVol:
+ {
+ // some ISOs have two PrimaryVols.
+ CVolumeDescriptor vd;
+ ReadVolumeDescriptor(vd);
+ if (sig[0] == NVolDescType::kPrimaryVol)
+ {
+ // some burners write "Joliet" Escape Sequence to primary volume
+ memset(vd.EscapeSequence, 0, sizeof(vd.EscapeSequence));
+ }
+ VolDescs.Add(vd);
+ break;
+ }
+ default:
+ break;
+ }
+ }
+
+ if (VolDescs.IsEmpty())
+ return S_FALSE;
+ for (MainVolDescIndex = (int)VolDescs.Size() - 1; MainVolDescIndex > 0; MainVolDescIndex--)
+ if (VolDescs[MainVolDescIndex].IsJoliet())
+ break;
+ /* FIXME: some volume can contain Rock Ridge, that is better than
+ Joliet volume. So we need some way to detect such case */
+ // MainVolDescIndex = 0; // to read primary volume
+ const CVolumeDescriptor &vd = VolDescs[MainVolDescIndex];
+ if (vd.LogicalBlockSize != kBlockSize)
+ return S_FALSE;
+
+ IsArc = true;
+
+ (CDirRecord &)_rootDir = vd.RootDirRecord;
+ ReadDir(_rootDir, 0);
+ CreateRefs(_rootDir);
+ ReadBootInfo();
+
+ {
+ FOR_VECTOR (i, Refs)
+ {
+ const CRef &ref = Refs[i];
+ for (UInt32 j = 0; j < ref.NumExtents; j++)
+ {
+ const CDir &item = ref.Dir->_subItems[ref.Index + j];
+ if (!item.IsDir() && item.Size != 0)
+ UpdatePhySize(item.ExtentLocation, item.Size);
+ }
+ }
+ }
+ {
+ FOR_VECTOR (i, BootEntries)
+ {
+ const CBootInitialEntry &be = BootEntries[i];
+ UpdatePhySize(be.LoadRBA, GetBootItemSize(i));
+ }
+ }
+
+ if (PhySize < _fileSize)
+ {
+ UInt64 rem = _fileSize - PhySize;
+ const UInt64 kRemMax = 1 << 21;
+ if (rem <= kRemMax)
+ {
+ RINOK(InStream_SeekSet(_stream, PhySize))
+ bool areThereNonZeros = false;
+ UInt64 numZeros = 0;
+ RINOK(ReadZeroTail(_stream, areThereNonZeros, numZeros, kRemMax))
+ if (!areThereNonZeros)
+ PhySize += numZeros;
+ }
+ }
+
+ return S_OK;
+}
+
+HRESULT CInArchive::Open(IInStream *inStream)
+{
+ Clear();
+ _stream = inStream;
+ try { return Open2(); }
+ catch(const CSystemException &e) { return e.ErrorCode; }
+ catch(CUnexpectedEndException &) { UnexpectedEnd = true; return S_FALSE; }
+ catch(CHeaderErrorException &) { HeadersError = true; return S_FALSE; }
+ catch(CEndianErrorException &) { IncorrectBigEndian = true; return S_FALSE; }
+}
+
+void CInArchive::Clear()
+{
+ IsArc = false;
+ UnexpectedEnd = false;
+ HeadersError = false;
+ IncorrectBigEndian = false;
+ TooDeepDirs = false;
+ SelfLinkedDirs = false;
+
+ UniqStartLocations.Clear();
+
+ Refs.Clear();
+ _rootDir.Clear();
+ VolDescs.Clear();
+ _bootIsDefined = false;
+ BootEntries.Clear();
+ SuspSkipSize = 0;
+ IsSusp = false;
+}
+
+
+UInt64 CInArchive::GetBootItemSize(unsigned index) const
+{
+ const CBootInitialEntry &be = BootEntries[index];
+ UInt64 size = be.GetSize();
+ if (be.BootMediaType == NBootMediaType::k1d2Floppy) size = 1200 << 10;
+ else if (be.BootMediaType == NBootMediaType::k1d44Floppy) size = 1440 << 10;
+ else if (be.BootMediaType == NBootMediaType::k2d88Floppy) size = 2880 << 10;
+ const UInt64 startPos = (UInt64)be.LoadRBA * kBlockSize;
+ if (startPos < _fileSize)
+ {
+ const UInt64 rem = _fileSize - startPos;
+ if (rem < size)
+ size = rem;
+ }
+ return size;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Iso/IsoIn.h b/CPP/7zip/Archive/Iso/IsoIn.h
new file mode 100644
index 0000000..f3e4751
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoIn.h
@@ -0,0 +1,318 @@
+// Archive/IsoIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_ISO_IN_H
+#define ZIP7_INC_ARCHIVE_ISO_IN_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+#include "IsoHeader.h"
+#include "IsoItem.h"
+
+namespace NArchive {
+namespace NIso {
+
+struct CDir: public CDirRecord
+{
+ CDir *Parent;
+ CObjectVector<CDir> _subItems;
+
+ void Clear()
+ {
+ Parent = NULL;
+ _subItems.Clear();
+ }
+
+ AString GetPath(bool checkSusp, unsigned skipSize) const
+ {
+ AString s;
+
+ unsigned len = 0;
+ const CDir *cur = this;
+
+ for (;;)
+ {
+ unsigned curLen;
+ cur->GetNameCur(checkSusp, skipSize, curLen);
+ len += curLen;
+ cur = cur->Parent;
+ if (!cur || !cur->Parent)
+ break;
+ len++;
+ }
+
+ char *p = s.GetBuf_SetEnd(len) + len;
+
+ cur = this;
+
+ for (;;)
+ {
+ unsigned curLen;
+ const Byte *name = cur->GetNameCur(checkSusp, skipSize, curLen);
+ p -= curLen;
+ if (curLen != 0)
+ memcpy(p, name, curLen);
+ cur = cur->Parent;
+ if (!cur || !cur->Parent)
+ break;
+ p--;
+ *p = CHAR_PATH_SEPARATOR;
+ }
+
+ return s;
+ }
+
+ void GetPathU(UString &s) const
+ {
+ s.Empty();
+
+ unsigned len = 0;
+ const CDir *cur = this;
+
+ for (;;)
+ {
+ unsigned curLen = (unsigned)(cur->FileId.Size() / 2);
+ const Byte *fid = cur->FileId;
+
+ unsigned i;
+ for (i = 0; i < curLen; i++)
+ if (fid[i * 2] == 0 && fid[i * 2 + 1] == 0)
+ break;
+ len += i;
+ cur = cur->Parent;
+ if (!cur || !cur->Parent)
+ break;
+ len++;
+ }
+
+ wchar_t *p = s.GetBuf_SetEnd(len) + len;
+
+ cur = this;
+
+ for (;;)
+ {
+ unsigned curLen = (unsigned)(cur->FileId.Size() / 2);
+ const Byte *fid = cur->FileId;
+
+ unsigned i;
+ for (i = 0; i < curLen; i++)
+ if (fid[i * 2] == 0 && fid[i * 2 + 1] == 0)
+ break;
+ curLen = i;
+
+ p -= curLen;
+ for (i = 0; i < curLen; i++)
+ p[i] = (wchar_t)(((wchar_t)fid[i * 2] << 8) | fid[i * 2 + 1]);
+ cur = cur->Parent;
+ if (!cur || !cur->Parent)
+ break;
+ p--;
+ *p = WCHAR_PATH_SEPARATOR;
+ }
+ }
+};
+
+struct CDateTime
+{
+ UInt16 Year;
+ Byte Month;
+ Byte Day;
+ Byte Hour;
+ Byte Minute;
+ Byte Second;
+ Byte Hundredths;
+ signed char GmtOffset; // min intervals from -48 (West) to +52 (East) recorded.
+
+ bool NotSpecified() const { return Year == 0 && Month == 0 && Day == 0 &&
+ Hour == 0 && Minute == 0 && Second == 0 && GmtOffset == 0; }
+
+ bool GetFileTime(NWindows::NCOM::CPropVariant &prop) const
+ {
+ UInt64 v;
+ const bool res = NWindows::NTime::GetSecondsSince1601(Year, Month, Day, Hour, Minute, Second, v);
+ if (res)
+ {
+ v = (UInt64)((Int64)v - (Int64)((Int32)GmtOffset * 15 * 60));
+ v *= 10000000;
+ if (Hundredths < 100)
+ v += (UInt32)Hundredths * 100000;
+ prop.SetAsTimeFrom_Ft64_Prec(v, k_PropVar_TimePrec_Base + 2);
+ }
+ return res;
+ }
+};
+
+struct CBootRecordDescriptor
+{
+ Byte BootSystemId[32]; // a-characters
+ Byte BootId[32]; // a-characters
+ Byte BootSystemUse[1977];
+};
+
+struct CBootValidationEntry
+{
+ Byte PlatformId;
+ Byte Id[24]; // to identify the manufacturer/developer of the CD-ROM.
+};
+
+struct CBootInitialEntry
+{
+ bool Bootable;
+ Byte BootMediaType;
+ UInt16 LoadSegment;
+ /* This is the load segment for the initial boot image. If this
+ value is 0 the system will use the traditional segment of 7C0. If this value
+ is non-zero the system will use the specified segment. This applies to x86
+ architectures only. For "flat" model architectures (such as Motorola) this
+ is the address divided by 10. */
+ Byte SystemType; // This must be a copy of byte 5 (System Type) from the
+ // Partition Table found in the boot image.
+ UInt16 SectorCount; // This is the number of virtual/emulated sectors the system
+ // will store at Load Segment during the initial boot procedure.
+ UInt32 LoadRBA; // This is the start address of the virtual disk. CDs use
+ // Relative/Logical block addressing.
+
+ Byte VendorSpec[20];
+
+ UInt32 GetSize() const
+ {
+ // if (BootMediaType == NBootMediaType::k1d44Floppy) (1440 << 10);
+ return (UInt32)SectorCount * 512;
+ }
+
+ bool Parse(const Byte *p);
+ AString GetName() const;
+};
+
+struct CVolumeDescriptor
+{
+ Byte VolFlags;
+ Byte SystemId[32]; // a-characters. An identification of a system
+ // which can recognize and act upon the content of the Logical
+ // Sectors with logical Sector Numbers 0 to 15 of the volume.
+ Byte VolumeId[32]; // d-characters. An identification of the volume.
+ UInt32 VolumeSpaceSize; // the number of Logical Blocks in which the Volume Space of the volume is recorded
+ Byte EscapeSequence[32];
+ UInt16 VolumeSetSize;
+ UInt16 VolumeSequenceNumber; // the ordinal number of the volume in the Volume Set of which the volume is a member.
+ UInt16 LogicalBlockSize;
+ UInt32 PathTableSize;
+ UInt32 LPathTableLocation;
+ UInt32 LOptionalPathTableLocation;
+ UInt32 MPathTableLocation;
+ UInt32 MOptionalPathTableLocation;
+ CDirRecord RootDirRecord;
+ Byte VolumeSetId[128];
+ Byte PublisherId[128];
+ Byte DataPreparerId[128];
+ Byte ApplicationId[128];
+ Byte CopyrightFileId[37];
+ Byte AbstractFileId[37];
+ Byte BibFileId[37];
+ CDateTime CTime;
+ CDateTime MTime;
+ CDateTime ExpirationTime;
+ CDateTime EffectiveTime;
+ Byte FileStructureVersion; // = 1;
+ Byte ApplicationUse[512];
+
+ bool IsJoliet() const
+ {
+ if ((VolFlags & 1) != 0)
+ return false;
+ Byte b = EscapeSequence[2];
+ return (EscapeSequence[0] == 0x25 && EscapeSequence[1] == 0x2F &&
+ (b == 0x40 || b == 0x43 || b == 0x45));
+ }
+};
+
+struct CRef
+{
+ const CDir *Dir;
+ UInt32 Index;
+ UInt32 NumExtents;
+ UInt64 TotalSize;
+};
+
+const UInt32 kBlockSize = 1 << 11;
+
+class CInArchive
+{
+ IInStream *_stream;
+ UInt64 _position;
+
+ UInt32 m_BufferPos;
+
+ void Skip(size_t size);
+ void SkipZeros(size_t size);
+ Byte ReadByte();
+ void ReadBytes(Byte *data, UInt32 size);
+ UInt16 ReadUInt16();
+ UInt32 ReadUInt32Le();
+ UInt32 ReadUInt32Be();
+ UInt32 ReadUInt32();
+ UInt64 ReadUInt64();
+ UInt32 ReadDigits(int numDigits);
+ void ReadDateTime(CDateTime &d);
+ void ReadRecordingDateTime(CRecordingDateTime &t);
+ void ReadDirRecord2(CDirRecord &r, Byte len);
+ void ReadDirRecord(CDirRecord &r);
+
+ void ReadBootRecordDescriptor(CBootRecordDescriptor &d);
+ void ReadVolumeDescriptor(CVolumeDescriptor &d);
+
+ void SeekToBlock(UInt32 blockIndex);
+ void ReadDir(CDir &d, int level);
+ void CreateRefs(CDir &d);
+
+ void ReadBootInfo();
+ HRESULT Open2();
+public:
+ HRESULT Open(IInStream *inStream);
+ void Clear();
+
+ UInt64 _fileSize;
+ UInt64 PhySize;
+
+ CRecordVector<CRef> Refs;
+ CObjectVector<CVolumeDescriptor> VolDescs;
+ int MainVolDescIndex;
+ // UInt32 BlockSize;
+ CObjectVector<CBootInitialEntry> BootEntries;
+
+private:
+ bool _bootIsDefined;
+public:
+ bool IsArc;
+ bool UnexpectedEnd;
+ bool HeadersError;
+ bool IncorrectBigEndian;
+ bool TooDeepDirs;
+ bool SelfLinkedDirs;
+ bool IsSusp;
+ unsigned SuspSkipSize;
+
+ CRecordVector<UInt32> UniqStartLocations;
+
+ void UpdatePhySize(const UInt32 blockIndex, const UInt64 size)
+ {
+ const UInt64 alignedSize = (size + kBlockSize - 1) & ~((UInt64)kBlockSize - 1);
+ const UInt64 end = (UInt64)blockIndex * kBlockSize + alignedSize;
+ if (PhySize < end)
+ PhySize = end;
+ }
+
+ bool IsJoliet() const { return VolDescs[MainVolDescIndex].IsJoliet(); }
+
+ UInt64 GetBootItemSize(unsigned index) const;
+
+private:
+ CDir _rootDir;
+ Byte m_Buffer[kBlockSize];
+ CBootRecordDescriptor _bootDesc;
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Iso/IsoItem.h b/CPP/7zip/Archive/Iso/IsoItem.h
new file mode 100644
index 0000000..9556805
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoItem.h
@@ -0,0 +1,320 @@
+// Archive/IsoItem.h
+
+#ifndef ZIP7_INC_ARCHIVE_ISO_ITEM_H
+#define ZIP7_INC_ARCHIVE_ISO_ITEM_H
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyString.h"
+#include "../../../Common/MyBuffer.h"
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "IsoHeader.h"
+
+namespace NArchive {
+namespace NIso {
+
+struct CRecordingDateTime
+{
+ Byte Year;
+ Byte Month;
+ Byte Day;
+ Byte Hour;
+ Byte Minute;
+ Byte Second;
+ signed char GmtOffset; // min intervals from -48 (West) to +52 (East) recorded.
+
+ bool GetFileTime(NWindows::NCOM::CPropVariant &prop) const
+ {
+ UInt64 v;
+ const bool res = NWindows::NTime::GetSecondsSince1601(Year + 1900, Month, Day, Hour, Minute, Second, v);
+ if (res)
+ {
+ v = (UInt64)((Int64)v - (Int64)((Int32)GmtOffset * 15 * 60));
+ v *= 10000000;
+ prop.SetAsTimeFrom_Ft64_Prec(v, k_PropVar_TimePrec_Base);
+ }
+ return res;
+ }
+};
+
+enum EPx
+{
+ k_Px_Mode,
+ k_Px_Links,
+ k_Px_User,
+ k_Px_Group,
+ k_Px_SerialNumber
+
+ // k_Px_Num
+};
+
+/*
+enum ETf
+{
+ k_Tf_CTime,
+ k_Tf_MTime,
+ k_Tf_ATime,
+ k_Tf_Attrib,
+ k_Tf_Backup,
+ k_Tf_Expiration,
+ k_Tf_Effective
+
+ // k_Tf_Num
+};
+*/
+
+struct CDirRecord
+{
+ UInt32 ExtentLocation;
+ UInt32 Size;
+ CRecordingDateTime DateTime;
+ Byte FileFlags;
+ Byte FileUnitSize;
+ Byte InterleaveGapSize;
+ Byte ExtendedAttributeRecordLen;
+ UInt16 VolSequenceNumber;
+ CByteBuffer FileId;
+ CByteBuffer SystemUse;
+
+ bool AreMultiPartEqualWith(const CDirRecord &a) const
+ {
+ return FileId == a.FileId
+ && (FileFlags & (~NFileFlags::kNonFinalExtent)) ==
+ (a.FileFlags & (~NFileFlags::kNonFinalExtent));
+ }
+
+ bool IsDir() const { return (FileFlags & NFileFlags::kDirectory) != 0; }
+ bool IsNonFinalExtent() const { return (FileFlags & NFileFlags::kNonFinalExtent) != 0; }
+
+ bool IsSystemItem() const
+ {
+ if (FileId.Size() != 1)
+ return false;
+ Byte b = *(const Byte *)FileId;
+ return (b == 0 || b == 1);
+ }
+
+
+ const Byte* FindSuspRecord(unsigned skipSize, Byte id0, Byte id1, unsigned &lenRes) const
+ {
+ lenRes = 0;
+ if (SystemUse.Size() < skipSize)
+ return NULL;
+ const Byte *p = (const Byte *)SystemUse + skipSize;
+ unsigned rem = (unsigned)(SystemUse.Size() - skipSize);
+ while (rem >= 5)
+ {
+ unsigned len = p[2];
+ if (len < 3 || len > rem)
+ return NULL;
+ if (p[0] == id0 && p[1] == id1 && p[3] == 1)
+ {
+ if (len < 4)
+ return NULL; // Check it
+ lenRes = len - 4;
+ return p + 4;
+ }
+ p += len;
+ rem -= len;
+ }
+ return NULL;
+ }
+
+
+ const Byte* GetNameCur(bool checkSusp, unsigned skipSize, unsigned &nameLenRes) const
+ {
+ const Byte *res = NULL;
+ unsigned len = 0;
+ if (checkSusp)
+ res = FindSuspRecord(skipSize, 'N', 'M', len);
+ if (!res || len < 1)
+ {
+ res = (const Byte *)FileId;
+ len = (unsigned)FileId.Size();
+ }
+ else
+ {
+ res++;
+ len--;
+ }
+ unsigned i;
+ for (i = 0; i < len; i++)
+ if (res[i] == 0)
+ break;
+ nameLenRes = i;
+ return res;
+ }
+
+
+ bool GetSymLink(unsigned skipSize, AString &link) const
+ {
+ link.Empty();
+ const Byte *p = NULL;
+ unsigned len = 0;
+ p = FindSuspRecord(skipSize, 'S', 'L', len);
+ if (!p || len < 1)
+ return false;
+
+ if (*p != 0)
+ return false;
+
+ p++;
+ len--;
+
+ while (len != 0)
+ {
+ if (len < 2)
+ return false;
+ unsigned flags = p[0];
+ unsigned cl = p[1];
+ p += 2;
+ len -= 2;
+
+ if (cl > len)
+ return false;
+
+ bool needSlash = false;
+
+ if (flags & (1 << 1)) link += "./";
+ else if (flags & (1 << 2)) link += "../";
+ else if (flags & (1 << 3)) link += '/';
+ else
+ needSlash = true;
+
+ for (unsigned i = 0; i < cl; i++)
+ {
+ const Byte c = p[i];
+ if (c == 0)
+ {
+ break;
+ // return false;
+ }
+ link += (char)c;
+ }
+
+ p += cl;
+ len -= cl;
+
+ if (len == 0)
+ break;
+
+ if (needSlash)
+ link += '/';
+ }
+
+ return true;
+ }
+
+ static bool GetLe32Be32(const Byte *p, UInt32 &dest)
+ {
+ UInt32 v1 = GetUi32(p);
+ UInt32 v2 = GetBe32(p + 4);
+ if (v1 == v2)
+ {
+ dest = v1;
+ return true;
+ }
+ return false;
+ }
+
+
+ bool GetPx(unsigned skipSize, unsigned pxType, UInt32 &val) const
+ {
+ val = 0;
+ const Byte *p = NULL;
+ unsigned len = 0;
+ p = FindSuspRecord(skipSize, 'P', 'X', len);
+ if (!p)
+ return false;
+ // px.Clear();
+ if (len < (pxType + 1) * 8)
+ return false;
+
+ return GetLe32Be32(p + pxType * 8, val);
+ }
+
+ /*
+ bool GetTf(int skipSize, unsigned pxType, CRecordingDateTime &t) const
+ {
+ const Byte *p = NULL;
+ unsigned len = 0;
+ p = FindSuspRecord(skipSize, 'T', 'F', len);
+ if (!p)
+ return false;
+ if (len < 1)
+ return false;
+ Byte flags = *p++;
+ len--;
+
+ unsigned step = 7;
+ if (flags & 0x80)
+ {
+ step = 17;
+ return false;
+ }
+
+ if ((flags & (1 << pxType)) == 0)
+ return false;
+
+ for (unsigned i = 0; i < pxType; i++)
+ {
+ if (len < step)
+ return false;
+ if (flags & (1 << i))
+ {
+ p += step;
+ len -= step;
+ }
+ }
+
+ if (len < step)
+ return false;
+
+ t.Year = p[0];
+ t.Month = p[1];
+ t.Day = p[2];
+ t.Hour = p[3];
+ t.Minute = p[4];
+ t.Second = p[5];
+ t.GmtOffset = (signed char)p[6];
+
+ return true;
+ }
+ */
+
+ bool CheckSusp(const Byte *p, unsigned &startPos) const
+ {
+ if (p[0] == 'S' &&
+ p[1] == 'P' &&
+ p[2] == 0x7 &&
+ p[3] == 0x1 &&
+ p[4] == 0xBE &&
+ p[5] == 0xEF)
+ {
+ startPos = p[6];
+ return true;
+ }
+ return false;
+ }
+
+ bool CheckSusp(unsigned &startPos) const
+ {
+ const Byte *p = (const Byte *)SystemUse;
+ const size_t len = SystemUse.Size();
+ const unsigned kMinLen = 7;
+ if (len < kMinLen)
+ return false;
+ if (CheckSusp(p, startPos))
+ return true;
+ const unsigned kOffset2 = 14;
+ if (len < kOffset2 + kMinLen)
+ return false;
+ return CheckSusp(p + kOffset2, startPos);
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Iso/IsoRegister.cpp b/CPP/7zip/Archive/Iso/IsoRegister.cpp
new file mode 100644
index 0000000..41b56ba
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/IsoRegister.cpp
@@ -0,0 +1,21 @@
+// IsoRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "IsoHandler.h"
+
+namespace NArchive {
+namespace NIso {
+
+static const Byte k_Signature[] = { 'C', 'D', '0', '0', '1' };
+
+REGISTER_ARC_I(
+ "Iso", "iso img", NULL, 0xE7,
+ k_Signature,
+ NArchive::NIso::kStartPos + 1,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Iso/StdAfx.h b/CPP/7zip/Archive/Iso/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Iso/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/LpHandler.cpp b/CPP/7zip/Archive/LpHandler.cpp
new file mode 100644
index 0000000..c1a76b4
--- /dev/null
+++ b/CPP/7zip/Archive/LpHandler.cpp
@@ -0,0 +1,1166 @@
+// LpHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/Sha256.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G16(_offs_, dest) dest = Get16(p + (_offs_));
+#define G32(_offs_, dest) dest = Get32(p + (_offs_));
+#define G64(_offs_, dest) dest = Get64(p + (_offs_));
+
+using namespace NWindows;
+
+namespace NArchive {
+
+namespace NExt {
+API_FUNC_IsArc IsArc_Ext_PhySize(const Byte *p, size_t size, UInt64 *phySize);
+}
+
+namespace NLp {
+
+/*
+Android 10+ use Android's Dynamic Partitions to allow the
+different read-only system partitions (e.g. system, vendor, product)
+to share the same pool of storage space (as LVM in Linux).
+Name for partition: "super" (for GPT) or "super.img" (for file).
+Dynamic Partition Tools: lpmake
+All partitions that are A/B-ed should be named as follows (slots are always named a, b, etc.):
+boot_a, boot_b, system_a, system_b, vendor_a, vendor_b.
+*/
+
+#define LP_METADATA_MAJOR_VERSION 10
+// #define LP_METADATA_MINOR_VERSION_MIN 0
+// #define LP_METADATA_MINOR_VERSION_MAX 2
+
+// #define LP_SECTOR_SIZE 512
+static const unsigned kSectorSizeLog = 9;
+
+/* Amount of space reserved at the start of every super partition to avoid
+ * creating an accidental boot sector. */
+#define LP_PARTITION_RESERVED_BYTES 4096
+#define LP_METADATA_GEOMETRY_SIZE 4096
+#define LP_METADATA_HEADER_MAGIC 0x414C5030
+
+static const unsigned k_SignatureSize = 8;
+static const Byte k_Signature[k_SignatureSize] =
+ { 0x67, 0x44, 0x6c, 0x61, 0x34, 0, 0, 0 };
+
+// The length (36) is the same as the maximum length of a GPT partition name.
+static const unsigned kNameLen = 36;
+
+static void AddName36ToString(AString &s, const char *name, bool strictConvert)
+{
+ for (unsigned i = 0; i < kNameLen; i++)
+ {
+ char c = name[i];
+ if (c == 0)
+ return;
+ if (strictConvert && c < 32)
+ c = '_';
+ s += c;
+ }
+}
+
+
+static const unsigned k_Geometry_Size = 0x34;
+
+// LpMetadataGeometry
+struct CGeometry
+{
+ // UInt32 magic;
+ // UInt32 struct_size;
+ // Byte checksum[32]; /* SHA256 checksum of this struct, with this field set to 0. */
+
+ /* Maximum amount of space a single copy of the metadata can use,
+ a multiple of LP_SECTOR_SIZE. */
+ UInt32 metadata_max_size;
+
+ /* Number of copies of the metadata to keep.
+ For Non-A/B: 1, For A/B: 2, for A/B/C: 3.
+ A backup copy of each slot is kept */
+ UInt32 metadata_slot_count;
+
+ /* minimal alignment for partition and extent sizes, a multiple of LP_SECTOR_SIZE. */
+ UInt32 logical_block_size;
+
+ bool Parse(const Byte *p)
+ {
+ G32 (40, metadata_max_size)
+ G32 (44, metadata_slot_count)
+ G32 (48, logical_block_size)
+ if (metadata_slot_count == 0 || metadata_slot_count >= ((UInt32)1 << 20))
+ return false;
+ if (metadata_max_size == 0)
+ return false;
+ if ((metadata_max_size & (((UInt32)1 << kSectorSizeLog) - 1)) != 0)
+ return false;
+ return true;
+ }
+
+ UInt64 GetTotalMetadataSize() const
+ {
+ // there are 2 copies of GEOMETRY and METADATA slots
+ return LP_PARTITION_RESERVED_BYTES +
+ LP_METADATA_GEOMETRY_SIZE * 2 +
+ ((UInt64)metadata_max_size * metadata_slot_count) * 2;
+ }
+};
+
+
+
+// LpMetadataTableDescriptor
+struct CDescriptor
+{
+ UInt32 offset; /* Location of the table, relative to end of the metadata header. */
+ UInt32 num_entries; /* Number of entries in the table. */
+ UInt32 entry_size; /* Size of each entry in the table, in bytes. */
+
+ void Parse(const Byte *p)
+ {
+ G32 (0, offset)
+ G32 (4, num_entries)
+ G32 (8, entry_size)
+ }
+
+ bool CheckLimits(UInt32 limit) const
+ {
+ if (entry_size == 0)
+ return false;
+ const UInt32 size = num_entries * entry_size;
+ if (size / entry_size != num_entries)
+ return false;
+ if (offset > limit || limit - offset < size)
+ return false;
+ return true;
+ }
+};
+
+
+// #define LP_PARTITION_ATTR_NONE 0x0
+// #define LP_PARTITION_ATTR_READONLY (1 << 0)
+
+/* This flag is only intended to be used with super_empty.img and super.img on
+ * retrofit devices. On these devices there are A and B super partitions, and
+ * we don't know ahead of time which slot the image will be applied to.
+ *
+ * If set, the partition name needs a slot suffix applied. The slot suffix is
+ * determined by the metadata slot number (0 = _a, 1 = _b).
+ */
+// #define LP_PARTITION_ATTR_SLOT_SUFFIXED (1 << 1)
+
+/* This flag is applied automatically when using MetadataBuilder::NewForUpdate.
+ * It signals that the partition was created (or modified) for a snapshot-based
+ * update. If this flag is not present, the partition was likely flashed via
+ * fastboot.
+ */
+// #define LP_PARTITION_ATTR_UPDATED (1 << 2)
+
+/* This flag marks a partition as disabled. It should not be used or mapped. */
+// #define LP_PARTITION_ATTR_DISABLED (1 << 3)
+
+static const char * const g_PartitionAttr[] =
+{
+ "READONLY"
+ , "SLOT_SUFFIXED"
+ , "UPDATED"
+ , "DISABLED"
+};
+
+static unsigned const k_MetaPartition_Size = 52;
+
+// LpMetadataPartition
+struct CPartition
+{
+ /* ASCII characters: alphanumeric or _. at least one ASCII character,
+ (name) must be unique across all partition names. */
+ char name[kNameLen];
+
+ UInt32 attributes; /* (LP_PARTITION_ATTR_*). */
+
+ /* Index of the first extent owned by this partition. The extent will
+ * start at logical sector 0. Gaps between extents are not allowed. */
+ UInt32 first_extent_index;
+
+ /* Number of extents in the partition. Every partition must have at least one extent. */
+ UInt32 num_extents;
+
+ /* Group this partition belongs to. */
+ UInt32 group_index;
+
+ void Parse(const Byte *p)
+ {
+ memcpy(name, p, kNameLen);
+ G32 (36, attributes)
+ G32 (40, first_extent_index)
+ G32 (44, num_extents)
+ G32 (48, group_index)
+ }
+
+ // calced properties:
+ UInt32 MethodsMask;
+ UInt64 NumSectors;
+ UInt64 NumSectors_Pack;
+ const char *Ext;
+
+ UInt64 GetSize() const { return NumSectors << kSectorSizeLog; }
+ UInt64 GetPackSize() const { return NumSectors_Pack << kSectorSizeLog; }
+
+ CPartition():
+ MethodsMask(0),
+ NumSectors(0),
+ NumSectors_Pack(0),
+ Ext(NULL)
+ {}
+};
+
+
+
+
+#define LP_TARGET_TYPE_LINEAR 0
+/* This extent is a dm-zero target. The index is ignored and must be 0. */
+#define LP_TARGET_TYPE_ZERO 1
+
+static const char * const g_Methods[] =
+{
+ "RAW" // "LINEAR"
+ , "ZERO"
+};
+
+static unsigned const k_MetaExtent_Size = 24;
+
+// LpMetadataExtent
+struct CExtent
+{
+ UInt64 num_sectors; /* Length in 512-byte sectors. */
+ UInt32 target_type; /* Target type for device-mapper (LP_TARGET_TYPE_*). */
+
+ /* for LINEAR: The sector on the physical partition that this extent maps onto.
+ for ZERO: must be 0. */
+ UInt64 target_data;
+
+ /* for LINEAR: index into the block devices table.
+ for ZERO: must be 0. */
+ UInt32 target_source;
+
+ bool IsRAW() const { return target_type == LP_TARGET_TYPE_LINEAR; }
+
+ void Parse(const Byte *p)
+ {
+ G64 (0, num_sectors)
+ G32 (8, target_type)
+ G64 (12, target_data)
+ G32 (20, target_source)
+ }
+};
+
+
+/* This flag is only intended to be used with super_empty.img and super.img on
+ * retrofit devices. If set, the group needs a slot suffix to be interpreted
+ * correctly. The suffix is automatically applied by ReadMetadata().
+ */
+// #define LP_GROUP_SLOT_SUFFIXED (1 << 0)
+static unsigned const k_Group_Size = 48;
+
+// LpMetadataPartitionGroup
+struct CGroup
+{
+ char name[kNameLen];
+ UInt32 flags; /* (LP_GROUP_*). */
+ UInt64 maximum_size; /* Maximum size in bytes. If 0, the group has no maximum size. */
+
+ void Parse(const Byte *p)
+ {
+ memcpy(name, p, kNameLen);
+ G32 (36, flags)
+ G64 (40, maximum_size)
+ }
+};
+
+
+
+
+/* This flag is only intended to be used with super_empty.img and super.img on
+ * retrofit devices. On these devices there are A and B super partitions, and
+ * we don't know ahead of time which slot the image will be applied to.
+ *
+ * If set, the block device needs a slot suffix applied before being used with
+ * IPartitionOpener. The slot suffix is determined by the metadata slot number
+ * (0 = _a, 1 = _b).
+ */
+// #define LP_BLOCK_DEVICE_SLOT_SUFFIXED (1 << 0)
+
+static unsigned const k_Device_Size = 64;
+
+/* This struct defines an entry in the block_devices table. There must be at
+ * least one device, and the first device must represent the partition holding
+ * the super metadata.
+ */
+// LpMetadataBlockDevice
+struct CDevice
+{
+ /* 0: First usable sector for allocating logical partitions. this will be
+ * the first sector after the initial geometry blocks, followed by the
+ * space consumed by metadata_max_size*metadata_slot_count*2.
+ */
+ UInt64 first_logical_sector;
+
+ /* 8: Alignment for defining partitions or partition extents. For example,
+ * an alignment of 1MiB will require that all partitions have a size evenly
+ * divisible by 1MiB, and that the smallest unit the partition can grow by
+ * is 1MiB.
+ *
+ * Alignment is normally determined at runtime when growing or adding
+ * partitions. If for some reason the alignment cannot be determined, then
+ * this predefined alignment in the geometry is used instead. By default
+ * it is set to 1MiB.
+ */
+ UInt32 alignment;
+
+ /* 12: Alignment offset for "stacked" devices. For example, if the "super"
+ * partition itself is not aligned within the parent block device's
+ * partition table, then we adjust for this in deciding where to place
+ * |first_logical_sector|.
+ *
+ * Similar to |alignment|, this will be derived from the operating system.
+ * If it cannot be determined, it is assumed to be 0.
+ */
+ UInt32 alignment_offset;
+
+ /* 16: Block device size, as specified when the metadata was created. This
+ * can be used to verify the geometry against a target device.
+ */
+ UInt64 size;
+
+ /* 24: Partition name in the GPT*/
+ char partition_name[kNameLen];
+
+ /* 60: Flags (see LP_BLOCK_DEVICE_* flags below). */
+ UInt32 flags;
+
+ void Parse(const Byte *p)
+ {
+ memcpy(partition_name, p + 24, kNameLen);
+ G64 (0, first_logical_sector)
+ G32 (8, alignment)
+ G32 (12, alignment_offset)
+ G64 (16, size)
+ G32 (60, flags)
+ }
+};
+
+
+/* This device uses Virtual A/B. Note that on retrofit devices, the expanded
+ * header may not be present.
+ */
+// #define LP_HEADER_FLAG_VIRTUAL_AB_DEVICE 0x1
+
+static const char * const g_Header_Flags[] =
+{
+ "VIRTUAL_AB"
+};
+
+
+static const unsigned k_LpMetadataHeader10_size = 128;
+static const unsigned k_LpMetadataHeader12_size = 256;
+
+struct LpMetadataHeader
+{
+ /* 0: Four bytes equal to LP_METADATA_HEADER_MAGIC. */
+ UInt32 magic;
+
+ /* 4: Version number required to read this metadata. If the version is not
+ * equal to the library version, the metadata should be considered
+ * incompatible.
+ */
+ UInt16 major_version;
+
+ /* 6: Minor version. A library supporting newer features should be able to
+ * read metadata with an older minor version. However, an older library
+ * should not support reading metadata if its minor version is higher.
+ */
+ UInt16 minor_version;
+
+ /* 8: The size of this header struct. */
+ UInt32 header_size;
+
+ /* 12: SHA256 checksum of the header, up to |header_size| bytes, computed as
+ * if this field were set to 0.
+ */
+ // Byte header_checksum[32];
+
+ /* 44: The total size of all tables. This size is contiguous; tables may not
+ * have gaps in between, and they immediately follow the header.
+ */
+ UInt32 tables_size;
+
+ /* 48: SHA256 checksum of all table contents. */
+ Byte tables_checksum[32];
+
+ /* 80: Partition table descriptor. */
+ CDescriptor partitions;
+ /* 92: Extent table descriptor. */
+ CDescriptor extents;
+ /* 104: Updateable group descriptor. */
+ CDescriptor groups;
+ /* 116: Block device table. */
+ CDescriptor block_devices;
+
+ /* Everything past here is header version 1.2+, and is only included if
+ * needed. When liblp supporting >= 1.2 reads a < 1.2 header, it must
+ * zero these additional fields.
+ */
+
+ /* 128: See LP_HEADER_FLAG_ constants for possible values. Header flags are
+ * independent of the version number and intended to be informational only.
+ * New flags can be added without bumping the version.
+ */
+ // UInt32 flags;
+
+ /* 132: Reserved (zero), pad to 256 bytes. */
+ // Byte reserved[124];
+
+ void Parse128(const Byte *p)
+ {
+ G32 (0, magic)
+ G16 (4, major_version)
+ G16 (6, minor_version)
+ G32 (8, header_size)
+ // Byte header_checksum[32];
+ G32 (44, tables_size)
+ memcpy (tables_checksum, p + 48, 32);
+ partitions.Parse(p + 80);
+ extents.Parse(p + 92);
+ groups.Parse(p + 104);
+ block_devices.Parse(p + 116);
+ /* Everything past here is header version 1.2+, and is only included if
+ * needed. When liblp supporting >= 1.2 reads a < 1.2 header, it must
+ * zero these additional fields.
+ */
+ }
+};
+
+
+static bool CheckSha256(const Byte *data, size_t size, const Byte *checksum)
+{
+ CSha256 sha;
+ Sha256_Init(&sha);
+ Sha256_Update(&sha, data, size);
+ Byte calced[32];
+ Sha256_Final(&sha, calced);
+ return memcmp(checksum, calced, 32) == 0;
+}
+
+static bool CheckSha256_csOffset(Byte *data, size_t size, unsigned hashOffset)
+{
+ Byte checksum[32];
+ Byte *shaData = &data[hashOffset];
+ memcpy(checksum, shaData, 32);
+ memset(shaData, 0, 32);
+ return CheckSha256(data, size, checksum);
+}
+
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CRecordVector<CPartition> _items;
+ CRecordVector<CExtent> Extents;
+
+ CMyComPtr<IInStream> _stream;
+ UInt64 _totalSize;
+ // UInt64 _usedSize;
+ // UInt64 _headersSize;
+
+ CGeometry geom;
+ UInt16 Major_version;
+ UInt16 Minor_version;
+ UInt32 Flags;
+
+ Int32 _mainFileIndex;
+ UInt32 MethodsMask;
+ bool _headerWarning;
+ AString GroupsString;
+ AString DevicesString;
+ AString DeviceArcName;
+
+ HRESULT Open2(IInStream *stream);
+};
+
+
+static void AddComment_UInt64(AString &s, const char *name, UInt64 val)
+{
+ s.Add_Space();
+ s += name;
+ s += '=';
+ s.Add_UInt64(val);
+}
+
+
+static bool IsBufZero(const Byte *data, size_t size)
+{
+ for (size_t i = 0; i < size; i += 4)
+ if (*(const UInt32 *)(const void *)(data + i) != 0)
+ return false;
+ return true;
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ RINOK(InStream_SeekSet(stream, LP_PARTITION_RESERVED_BYTES))
+ {
+ Byte buf[k_Geometry_Size];
+ RINOK(ReadStream_FALSE(stream, buf, k_Geometry_Size))
+ if (memcmp(buf, k_Signature, k_SignatureSize) != 0)
+ return S_FALSE;
+ if (!geom.Parse(buf))
+ return S_FALSE;
+ if (!CheckSha256_csOffset(buf, k_Geometry_Size, 8))
+ return S_FALSE;
+ }
+
+ CByteBuffer buffer;
+ RINOK(InStream_SeekToBegin(stream))
+ buffer.Alloc(LP_METADATA_GEOMETRY_SIZE * 2);
+ {
+ // buffer.Size() >= LP_PARTITION_RESERVED_BYTES
+ RINOK(ReadStream_FALSE(stream, buffer, LP_PARTITION_RESERVED_BYTES))
+ if (!IsBufZero(buffer, LP_PARTITION_RESERVED_BYTES))
+ {
+ _headerWarning = true;
+ // return S_FALSE;
+ }
+ }
+
+ RINOK(ReadStream_FALSE(stream, buffer, LP_METADATA_GEOMETRY_SIZE * 2))
+ // we check that 2 copies of GEOMETRY are identical:
+ if (memcmp(buffer, buffer + LP_METADATA_GEOMETRY_SIZE, LP_METADATA_GEOMETRY_SIZE) != 0
+ || !IsBufZero(buffer + k_Geometry_Size, LP_METADATA_GEOMETRY_SIZE - k_Geometry_Size))
+ {
+ _headerWarning = true;
+ // return S_FALSE;
+ }
+
+ RINOK(ReadStream_FALSE(stream, buffer, k_LpMetadataHeader10_size))
+ LpMetadataHeader header;
+ header.Parse128(buffer);
+ if (header.magic != LP_METADATA_HEADER_MAGIC ||
+ header.major_version != LP_METADATA_MAJOR_VERSION ||
+ header.header_size < k_LpMetadataHeader10_size)
+ return S_FALSE;
+ Flags = 0;
+ if (header.header_size > k_LpMetadataHeader10_size)
+ {
+ if (header.header_size != k_LpMetadataHeader12_size)
+ return S_FALSE;
+ RINOK(ReadStream_FALSE(stream, buffer + k_LpMetadataHeader10_size,
+ header.header_size - k_LpMetadataHeader10_size))
+ Flags = Get32(buffer + k_LpMetadataHeader10_size);
+ }
+ Major_version = header.major_version;
+ Minor_version = header.minor_version;
+
+ if (!CheckSha256_csOffset(buffer, header.header_size, 12))
+ return S_FALSE;
+
+ if (geom.metadata_max_size < header.tables_size ||
+ geom.metadata_max_size - header.tables_size < header.header_size)
+ return S_FALSE;
+
+ buffer.AllocAtLeast(header.tables_size);
+ RINOK(ReadStream_FALSE(stream, buffer, header.tables_size))
+
+ const UInt64 totalMetaSize = geom.GetTotalMetadataSize();
+ // _headersSize = _totalSize;
+ _totalSize = totalMetaSize;
+
+ if (!CheckSha256(buffer, header.tables_size, header.tables_checksum))
+ return S_FALSE;
+
+ {
+ const CDescriptor &d = header.partitions;
+ if (!d.CheckLimits(header.tables_size))
+ return S_FALSE;
+ if (d.entry_size != k_MetaPartition_Size)
+ return S_FALSE;
+ for (UInt32 i = 0; i < d.num_entries; i++)
+ {
+ CPartition part;
+ part.Parse(buffer + d.offset + i * d.entry_size);
+ const UInt32 extLimit = part.first_extent_index + part.num_extents;
+ if (extLimit < part.first_extent_index ||
+ extLimit > header.extents.num_entries ||
+ part.group_index >= header.groups.num_entries)
+ return S_FALSE;
+ _items.Add(part);
+ }
+ }
+ {
+ const CDescriptor &d = header.extents;
+ if (!d.CheckLimits(header.tables_size))
+ return S_FALSE;
+ if (d.entry_size != k_MetaExtent_Size)
+ return S_FALSE;
+ for (UInt32 i = 0; i < d.num_entries; i++)
+ {
+ CExtent e;
+ e.Parse(buffer + d.offset + i * d.entry_size);
+ // if (e.target_type > LP_TARGET_TYPE_ZERO) return S_FALSE;
+ if (e.IsRAW())
+ {
+ if (e.target_source >= header.block_devices.num_entries)
+ return S_FALSE;
+ const UInt64 endSector = e.target_data + e.num_sectors;
+ const UInt64 endOffset = endSector << kSectorSizeLog;
+ if (_totalSize < endOffset)
+ _totalSize = endOffset;
+ }
+ MethodsMask |= (UInt32)1 << e.target_type;
+ Extents.Add(e);
+ }
+ }
+
+ // _usedSize = _totalSize;
+ {
+ const CDescriptor &d = header.groups;
+ if (!d.CheckLimits(header.tables_size))
+ return S_FALSE;
+ if (d.entry_size != k_Group_Size)
+ return S_FALSE;
+ AString s;
+ for (UInt32 i = 0; i < d.num_entries; i++)
+ {
+ CGroup g;
+ g.Parse(buffer + d.offset + i * d.entry_size);
+ if (_totalSize < g.maximum_size)
+ _totalSize = g.maximum_size;
+ s += " ";
+ AddName36ToString(s, g.name, true);
+ AddComment_UInt64(s, "maximum_size", g.maximum_size);
+ AddComment_UInt64(s, "flags", g.flags);
+ s.Add_LF();
+ }
+ GroupsString = s;
+ }
+
+ {
+ const CDescriptor &d = header.block_devices;
+ if (!d.CheckLimits(header.tables_size))
+ return S_FALSE;
+ if (d.entry_size != k_Device_Size)
+ return S_FALSE;
+ AString s;
+ // CRecordVector<CDevice> devices;
+ for (UInt32 i = 0; i < d.num_entries; i++)
+ {
+ CDevice v;
+ v.Parse(buffer + d.offset + i * d.entry_size);
+ // if (i == 0)
+ {
+ // it's super_device is first device;
+ if (totalMetaSize > (v.first_logical_sector << kSectorSizeLog))
+ return S_FALSE;
+ }
+ if (_totalSize < v.size)
+ _totalSize = v.size;
+ s += " ";
+ if (i == 0)
+ AddName36ToString(DeviceArcName, v.partition_name, true);
+ // devices.Add(v);
+ AddName36ToString(s, v.partition_name, true);
+ AddComment_UInt64(s, "size", v.size);
+ AddComment_UInt64(s, "first_logical_sector", v.first_logical_sector);
+ AddComment_UInt64(s, "alignment", v.alignment);
+ AddComment_UInt64(s, "alignment_offset", v.alignment_offset);
+ AddComment_UInt64(s, "flags", v.flags);
+ s.Add_LF();
+ }
+ DevicesString = s;
+ }
+
+ {
+ FOR_VECTOR (i, _items)
+ {
+ CPartition &part = _items[i];
+ if (part.first_extent_index > Extents.Size() ||
+ part.num_extents > Extents.Size() - part.first_extent_index)
+ return S_FALSE;
+
+ UInt64 numSectors = 0;
+ UInt64 numSectors_Pack = 0;
+ UInt32 methods = 0;
+ for (UInt32 k = 0; k < part.num_extents; k++)
+ {
+ const CExtent &e = Extents[part.first_extent_index + k];
+ numSectors += e.num_sectors;
+ if (e.IsRAW())
+ numSectors_Pack += e.num_sectors;
+ methods |= (UInt32)1 << e.target_type;
+ }
+ part.NumSectors = numSectors;
+ part.NumSectors_Pack = numSectors_Pack;
+ part.MethodsMask = methods;
+ }
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(Open2(stream))
+ _stream = stream;
+
+ int mainFileIndex = -1;
+ unsigned numNonEmptyParts = 0;
+
+ FOR_VECTOR (fileIndex, _items)
+ {
+ CPartition &item = _items[fileIndex];
+ if (item.NumSectors != 0)
+ {
+ mainFileIndex = (int)fileIndex;
+ numNonEmptyParts++;
+ CMyComPtr<ISequentialInStream> parseStream;
+ if (GetStream(fileIndex, &parseStream) == S_OK && parseStream)
+ {
+ const size_t kParseSize = 1 << 11;
+ Byte buf[kParseSize];
+ if (ReadStream_FAIL(parseStream, buf, kParseSize) == S_OK)
+ {
+ UInt64 extSize;
+ if (NExt::IsArc_Ext_PhySize(buf, kParseSize, &extSize) == k_IsArc_Res_YES)
+ if (extSize == item.GetSize())
+ item.Ext = "ext";
+ }
+ }
+ }
+ }
+ if (numNonEmptyParts == 1)
+ _mainFileIndex = mainFileIndex;
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ // _usedSize = 0;
+ // _headersSize = 0;
+ _items.Clear();
+ Extents.Clear();
+ _stream.Release();
+ _mainFileIndex = -1;
+ _headerWarning = false;
+ MethodsMask = 0;
+ GroupsString.Empty();
+ DevicesString.Empty();
+ DeviceArcName.Empty();
+ return S_OK;
+}
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidCharacts,
+ kpidMethod,
+ kpidNumBlocks,
+ kpidOffset
+};
+
+static const Byte kArcProps[] =
+{
+ kpidUnpackVer,
+ kpidMethod,
+ kpidClusterSize,
+ // kpidHeadersSize,
+ // kpidFreeSpace,
+ kpidName,
+ kpidComment
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile:
+ {
+ if (_mainFileIndex >= 0)
+ prop = (UInt32)_mainFileIndex;
+ break;
+ }
+ case kpidPhySize: prop = _totalSize; break;
+
+ // case kpidFreeSpace: if (_usedSize != 0) prop = _totalSize - _usedSize; break;
+ // case kpidHeadersSize: prop = _headersSize; break;
+
+ case kpidMethod:
+ {
+ const UInt32 m = MethodsMask;
+ if (m != 0)
+ {
+ FLAGS_TO_PROP(g_Methods, m, prop);
+ }
+ break;
+ }
+
+ case kpidUnpackVer:
+ {
+ AString s;
+ s.Add_UInt32(Major_version);
+ s.Add_Dot();
+ s.Add_UInt32(Minor_version);
+ prop = s;
+ break;
+ }
+
+ case kpidClusterSize:
+ prop = geom.logical_block_size;
+ break;
+
+ case kpidComment:
+ {
+ AString s;
+
+ s += "metadata_slot_count: ";
+ s.Add_UInt32(geom.metadata_slot_count);
+ s.Add_LF();
+
+ s += "metadata_max_size: ";
+ s.Add_UInt32(geom.metadata_max_size);
+ s.Add_LF();
+
+ if (Flags != 0)
+ {
+ s += "flags: ";
+ s += FlagsToString(g_Header_Flags, Z7_ARRAY_SIZE(g_Header_Flags), Flags);
+ s.Add_LF();
+ }
+
+ if (!GroupsString.IsEmpty())
+ {
+ s += "Groups:";
+ s.Add_LF();
+ s += GroupsString;
+ }
+
+ if (!DevicesString.IsEmpty())
+ {
+ s += "BlockDevices:";
+ s.Add_LF();
+ s += DevicesString;
+ }
+
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidName:
+ if (!DeviceArcName.IsEmpty())
+ prop = DeviceArcName + ".lpimg";
+ break;
+
+ case kpidWarningFlags:
+ if (_headerWarning)
+ {
+ UInt32 v = kpv_ErrorFlags_HeadersError;
+ prop = v;
+ }
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CPartition &item = _items[index];
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString s;
+ AddName36ToString(s, item.name, false);
+ if (s.IsEmpty())
+ s.Add_UInt32(index);
+ if (item.num_extents != 0)
+ {
+ s.Add_Dot();
+ s += (item.Ext ? item.Ext : "img");
+ }
+ prop = s;
+ break;
+ }
+
+ case kpidSize: prop = item.GetSize(); break;
+ case kpidPackSize: prop = item.GetPackSize(); break;
+ case kpidNumBlocks: prop = item.num_extents; break;
+ case kpidMethod:
+ {
+ const UInt32 m = item.MethodsMask;
+ if (m != 0)
+ {
+ FLAGS_TO_PROP(g_Methods, m, prop);
+ }
+ break;
+ }
+ case kpidOffset:
+ if (item.num_extents != 0)
+ if (item.first_extent_index < Extents.Size())
+ prop = Extents[item.first_extent_index].target_data << kSectorSizeLog;
+ break;
+
+ case kpidCharacts:
+ {
+ AString s;
+ s += "group:";
+ s.Add_UInt32(item.group_index);
+ s.Add_Space();
+ s += FlagsToString(g_PartitionAttr, Z7_ARRAY_SIZE(g_PartitionAttr), item.attributes);
+ prop = s;
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+
+ const CPartition &item = _items[index];
+
+ if (item.first_extent_index > Extents.Size()
+ || item.num_extents > Extents.Size() - item.first_extent_index)
+ return S_FALSE;
+
+ if (item.num_extents == 0)
+ return CreateLimitedInStream(_stream, 0, 0, stream);
+
+ if (item.num_extents == 1)
+ {
+ const CExtent &e = Extents[item.first_extent_index];
+ if (e.IsRAW())
+ {
+ const UInt64 pos = e.target_data << kSectorSizeLog;
+ if ((pos >> kSectorSizeLog) != e.target_data)
+ return S_FALSE;
+ const UInt64 size = item.GetSize();
+ if (pos + size < pos)
+ return S_FALSE;
+ return CreateLimitedInStream(_stream, pos, size, stream);
+ }
+ }
+
+ CExtentsStream *extentStreamSpec = new CExtentsStream();
+ CMyComPtr<ISequentialInStream> extentStream = extentStreamSpec;
+
+ // const unsigned kNumDebugExtents = 10;
+ extentStreamSpec->Extents.Reserve(item.num_extents + 1
+ // + kNumDebugExtents
+ );
+
+ UInt64 virt = 0;
+ for (UInt32 k = 0; k < item.num_extents; k++)
+ {
+ const CExtent &e = Extents[item.first_extent_index + k];
+
+ CSeekExtent se;
+ {
+ const UInt64 numSectors = e.num_sectors;
+ if (numSectors == 0)
+ {
+ continue;
+ // return S_FALSE;
+ }
+ const UInt64 numBytes = numSectors << kSectorSizeLog;
+ if ((numBytes >> kSectorSizeLog) != numSectors)
+ return S_FALSE;
+ if (numBytes >= ((UInt64)1 << 63) - virt)
+ return S_FALSE;
+
+ se.Virt = virt;
+ virt += numBytes;
+ }
+
+ const UInt64 phySector = e.target_data;
+ if (e.target_type == LP_TARGET_TYPE_ZERO)
+ {
+ if (phySector != 0)
+ return S_FALSE;
+ se.SetAs_ZeroFill();
+ }
+ else if (e.target_type == LP_TARGET_TYPE_LINEAR)
+ {
+ se.Phy = phySector << kSectorSizeLog;
+ if ((se.Phy >> kSectorSizeLog) != phySector)
+ return S_FALSE;
+ if (se.Phy >= ((UInt64)1 << 63))
+ return S_FALSE;
+ }
+ else
+ return S_FALSE;
+
+ extentStreamSpec->Extents.AddInReserved(se);
+
+ /*
+ {
+ // for debug
+ const UInt64 kAdd = (e.num_sectors << kSectorSizeLog) / kNumDebugExtents;
+ for (unsigned i = 0; i < kNumDebugExtents; i++)
+ {
+ se.Phy += kAdd;
+ // se.Phy += (UInt64)1 << 63; // for debug
+ // se.Phy += 1; // for debug
+ se.Virt += kAdd;
+ extentStreamSpec->Extents.AddInReserved(se);
+ }
+ }
+ */
+ }
+
+ CSeekExtent se;
+ se.Phy = 0;
+ se.Virt = virt;
+ extentStreamSpec->Extents.Add(se);
+ extentStreamSpec->Stream = _stream;
+ extentStreamSpec->Init();
+ *stream = extentStream.Detach();
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ totalSize += _items[index].GetSize();
+ }
+ extractCallback->SetTotal(totalSize);
+
+ totalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+
+ const UInt64 size = _items[index].GetSize();
+ totalSize += size;
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ CMyComPtr<ISequentialInStream> inStream;
+ const HRESULT hres = GetStream(index, &inStream);
+ int opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ if (hres != S_FALSE)
+ {
+ if (hres != S_OK)
+ return hres;
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ opRes = NExtract::NOperationResult::kDataError;
+ if (copyCoderSpec->TotalSize == size)
+ opRes = NExtract::NOperationResult::kOK;
+ else if (copyCoderSpec->TotalSize < size)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ }
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+REGISTER_ARC_I(
+ "LP", "lpimg img", NULL, 0xc1,
+ k_Signature,
+ LP_PARTITION_RESERVED_BYTES,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/LzhHandler.cpp b/CPP/7zip/Archive/LzhHandler.cpp
new file mode 100644
index 0000000..9239afd
--- /dev/null
+++ b/CPP/7zip/Archive/LzhHandler.cpp
@@ -0,0 +1,733 @@
+// LzhHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../ICoder.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/LzhDecoder.h"
+
+#include "IArchive.h"
+
+#include "Common/ItemNameUtils.h"
+
+using namespace NWindows;
+using namespace NTime;
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+
+// CRC-16 (-IBM, -ANSI). The poly is 0x8005 (x^16 + x^15 + x^2 + 1)
+
+static const UInt16 kCrc16Poly = 0xA001;
+
+static UInt16 g_LzhCrc16Table[256];
+
+#define CRC16_UPDATE_BYTE(crc, b) (g_LzhCrc16Table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt32 LzhCrc16Update(UInt32 crc, const void *data, size_t size);
+UInt32 LzhCrc16Update(UInt32 crc, const void *data, size_t size)
+{
+ const Byte *p = (const Byte *)data;
+ const Byte *pEnd = p + size;
+ for (; p != pEnd; p++)
+ crc = CRC16_UPDATE_BYTE(crc, *p);
+ return crc;
+}
+
+static struct CLzhCrc16TableInit
+{
+ CLzhCrc16TableInit()
+ {
+ for (UInt32 i = 0; i < 256; i++)
+ {
+ UInt32 r = i;
+ for (unsigned j = 0; j < 8; j++)
+ r = (r >> 1) ^ (kCrc16Poly & ((UInt32)0 - (r & 1)));
+ g_LzhCrc16Table[i] = (UInt16)r;
+ }
+ }
+} g_LzhCrc16TableInit;
+
+
+namespace NArchive {
+namespace NLzh{
+
+const unsigned kMethodIdSize = 5;
+
+const Byte kExtIdFileName = 0x01;
+const Byte kExtIdDirName = 0x02;
+const Byte kExtIdUnixTime = 0x54;
+
+struct CExtension
+{
+ Byte Type;
+ CByteBuffer Data;
+
+ AString GetString() const
+ {
+ AString s;
+ s.SetFrom_CalcLen((const char *)(const Byte *)Data, (unsigned)Data.Size());
+ return s;
+ }
+};
+
+const UInt32 kBasicPartSize = 22;
+
+API_FUNC_static_IsArc IsArc_Lzh(const Byte *p, size_t size)
+{
+ if (size < 2 + kBasicPartSize)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[2] != '-' || p[3] != 'l' || p[4] != 'h' || p[6] != '-')
+ return k_IsArc_Res_NO;
+ Byte n = p[5];
+ if (n != 'd')
+ if (n < '0' || n > '7')
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+struct CItem
+{
+ AString Name;
+ Byte Method[kMethodIdSize];
+ Byte Attributes;
+ Byte Level;
+ Byte OsId;
+ UInt32 PackSize;
+ UInt32 Size;
+ UInt32 ModifiedTime;
+ UInt16 CRC;
+ CObjectVector<CExtension> Extensions;
+
+ bool IsValidMethod() const { return (Method[0] == '-' && Method[1] == 'l' && Method[4] == '-'); }
+ bool IsLhMethod() const {return (IsValidMethod() && Method[2] == 'h'); }
+ bool IsDir() const {return (IsLhMethod() && Method[3] == 'd'); }
+
+ bool IsCopyMethod() const
+ {
+ return (IsLhMethod() && Method[3] == '0') ||
+ (IsValidMethod() && Method[2] == 'z' && Method[3] == '4');
+ }
+
+ bool IsLh1GroupMethod() const
+ {
+ if (!IsLhMethod())
+ return false;
+ switch (Method[3])
+ {
+ case '1':
+ return true;
+ }
+ return false;
+ }
+
+ bool IsLh4GroupMethod() const
+ {
+ if (!IsLhMethod())
+ return false;
+ switch (Method[3])
+ {
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ return true;
+ }
+ return false;
+ }
+
+ unsigned GetNumDictBits() const
+ {
+ if (!IsLhMethod())
+ return 0;
+ switch (Method[3])
+ {
+ case '1': return 12;
+ case '2': return 13;
+ case '3': return 13;
+ case '4': return 12;
+ case '5': return 13;
+ case '6': return 15;
+ case '7': return 16;
+ }
+ return 0;
+ }
+
+ int FindExt(Byte type) const
+ {
+ FOR_VECTOR (i, Extensions)
+ if (Extensions[i].Type == type)
+ return (int)i;
+ return -1;
+ }
+
+ bool GetUnixTime(UInt32 &value) const
+ {
+ value = 0;
+ int index = FindExt(kExtIdUnixTime);
+ if (index < 0
+ || Extensions[index].Data.Size() < 4)
+ {
+ if (Level == 2)
+ {
+ value = ModifiedTime;
+ return true;
+ }
+ return false;
+ }
+ const Byte *data = (const Byte *)(Extensions[index].Data);
+ value = GetUi32(data);
+ return true;
+ }
+
+ AString GetDirName() const
+ {
+ int index = FindExt(kExtIdDirName);
+ if (index < 0)
+ return AString();
+ return Extensions[index].GetString();
+ }
+
+ AString GetFileName() const
+ {
+ int index = FindExt(kExtIdFileName);
+ if (index < 0)
+ return Name;
+ return Extensions[index].GetString();
+ }
+
+ AString GetName() const
+ {
+ AString s (GetDirName());
+ const char kDirSeparator = '\\';
+ // check kDirSeparator in Linux
+ s.Replace((char)(unsigned char)0xFF, kDirSeparator);
+ if (!s.IsEmpty() && s.Back() != kDirSeparator)
+ s += kDirSeparator;
+ s += GetFileName();
+ return s;
+ }
+};
+
+static const Byte *ReadUInt16(const Byte *p, UInt16 &v)
+{
+ v = Get16(p);
+ return p + 2;
+}
+
+static const Byte *ReadString(const Byte *p, size_t size, AString &s)
+{
+ s.Empty();
+ for (size_t i = 0; i < size; i++)
+ {
+ const Byte c = p[i];
+ if (c == 0)
+ break;
+ s += (char)c;
+ }
+ return p + size;
+}
+
+static Byte CalcSum(const Byte *data, size_t size)
+{
+ Byte sum = 0;
+ for (size_t i = 0; i < size; i++)
+ sum = (Byte)(sum + data[i]);
+ return sum;
+}
+
+static HRESULT GetNextItem(ISequentialInStream *stream, bool &filled, CItem &item)
+{
+ filled = false;
+
+ size_t processedSize = 2;
+ Byte startHeader[2];
+ RINOK(ReadStream(stream, startHeader, &processedSize))
+ if (processedSize == 0)
+ return S_OK;
+ if (processedSize == 1)
+ return (startHeader[0] == 0) ? S_OK: S_FALSE;
+ if (startHeader[0] == 0 && startHeader[1] == 0)
+ return S_OK;
+
+ Byte header[256];
+ processedSize = kBasicPartSize;
+ RINOK(ReadStream(stream, header, &processedSize))
+ if (processedSize != kBasicPartSize)
+ return (startHeader[0] == 0) ? S_OK: S_FALSE;
+
+ const Byte *p = header;
+ memcpy(item.Method, p, kMethodIdSize);
+ if (!item.IsValidMethod())
+ return S_OK;
+ p += kMethodIdSize;
+ item.PackSize = Get32(p);
+ item.Size = Get32(p + 4);
+ item.ModifiedTime = Get32(p + 8);
+ item.Attributes = p[12];
+ item.Level = p[13];
+ p += 14;
+ if (item.Level > 2)
+ return S_FALSE;
+ UInt32 headerSize;
+ if (item.Level < 2)
+ {
+ headerSize = startHeader[0];
+ if (headerSize < kBasicPartSize)
+ return S_FALSE;
+ RINOK(ReadStream_FALSE(stream, header + kBasicPartSize, headerSize - kBasicPartSize))
+ if (startHeader[1] != CalcSum(header, headerSize))
+ return S_FALSE;
+ const size_t nameLength = *p++;
+ if ((size_t)(p - header) + nameLength + 2 > headerSize)
+ return S_FALSE;
+ p = ReadString(p, nameLength, item.Name);
+ }
+ else
+ headerSize = startHeader[0] | ((UInt32)startHeader[1] << 8);
+ p = ReadUInt16(p, item.CRC);
+ if (item.Level != 0)
+ {
+ if (item.Level == 2)
+ {
+ RINOK(ReadStream_FALSE(stream, header + kBasicPartSize, 2))
+ }
+ if ((size_t)(p - header) + 3 > headerSize)
+ return S_FALSE;
+ item.OsId = *p++;
+ UInt16 nextSize;
+ p = ReadUInt16(p, nextSize);
+ while (nextSize != 0)
+ {
+ if (nextSize < 3)
+ return S_FALSE;
+ if (item.Level == 1)
+ {
+ if (item.PackSize < nextSize)
+ return S_FALSE;
+ item.PackSize -= nextSize;
+ }
+ if (item.Extensions.Size() >= (1 << 8))
+ return S_FALSE;
+ CExtension ext;
+ RINOK(ReadStream_FALSE(stream, &ext.Type, 1))
+ nextSize = (UInt16)(nextSize - 3);
+ ext.Data.Alloc(nextSize);
+ RINOK(ReadStream_FALSE(stream, (Byte *)ext.Data, nextSize))
+ item.Extensions.Add(ext);
+ Byte hdr2[2];
+ RINOK(ReadStream_FALSE(stream, hdr2, 2))
+ ReadUInt16(hdr2, nextSize);
+ }
+ }
+ filled = true;
+ return S_OK;
+}
+
+
+static const CUInt32PCharPair g_OsPairs[] =
+{
+ { 0, "MS-DOS" },
+ { 'M', "MS-DOS" },
+ { '2', "OS/2" },
+ { '9', "OS9" },
+ { 'K', "OS/68K" },
+ { '3', "OS/386" },
+ { 'H', "HUMAN" },
+ { 'U', "UNIX" },
+ { 'C', "CP/M" },
+ { 'F', "FLEX" },
+ { 'm', "Mac" },
+ { 'R', "Runser" },
+ { 'T', "TownsOS" },
+ { 'X', "XOSK" },
+ { 'w', "Windows 95" },
+ { 'W', "Windows NT" },
+ { 'J', "Java VM" }
+};
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ // kpidAttrib,
+ kpidCRC,
+ kpidMethod,
+ kpidHostOS
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithCRC
+ , ISequentialOutStream
+)
+ UInt32 _crc;
+ CMyComPtr<ISequentialOutStream> _stream;
+public:
+ void Init(ISequentialOutStream *stream)
+ {
+ _stream = stream;
+ _crc = 0;
+ }
+ void ReleaseStream() { _stream.Release(); }
+ UInt32 GetCRC() const { return _crc; }
+};
+
+Z7_COM7F_IMF(COutStreamWithCRC::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT res = S_OK;
+ if (_stream)
+ res = _stream->Write(data, size, &size);
+ _crc = LzhCrc16Update(_crc, data, size);
+ if (processedSize)
+ *processedSize = size;
+ return res;
+}
+
+
+struct CItemEx: public CItem
+{
+ UInt64 DataPosition;
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ CObjectVector<CItemEx> _items;
+ CMyComPtr<IInStream> _stream;
+ UInt64 _phySize;
+ UInt32 _errorFlags;
+ bool _isArc;
+public:
+ CHandler();
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+CHandler::CHandler() {}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _phySize; break;
+
+ case kpidErrorFlags:
+ UInt32 v = _errorFlags;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ prop = v;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ const CItemEx &item = _items[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString s = NItemName::WinPathToOsPath(MultiByteToUnicodeString(item.GetName(), CP_OEMCP));
+ if (!s.IsEmpty())
+ {
+ if (s.Back() == WCHAR_PATH_SEPARATOR)
+ s.DeleteBack();
+ prop = s;
+ }
+ break;
+ }
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: prop = item.Size; break;
+ case kpidPackSize: prop = item.PackSize; break;
+ case kpidCRC: prop = (UInt32)item.CRC; break;
+ case kpidHostOS: PAIR_TO_PROP(g_OsPairs, item.OsId, prop); break;
+ case kpidMTime:
+ {
+ UInt32 unixTime;
+ if (item.GetUnixTime(unixTime))
+ PropVariant_SetFrom_UnixTime(prop, unixTime);
+ else
+ PropVariant_SetFrom_DosTime(prop, item.ModifiedTime);
+ break;
+ }
+ // case kpidAttrib: prop = (UInt32)item.Attributes; break;
+ case kpidMethod:
+ {
+ char method2[kMethodIdSize + 1];
+ method2[kMethodIdSize] = 0;
+ memcpy(method2, item.Method, kMethodIdSize);
+ prop = method2;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+ try
+ {
+ _items.Clear();
+
+ UInt64 endPos;
+ bool needSetTotal = true;
+
+ RINOK(InStream_AtBegin_GetSize(stream, endPos))
+
+ for (;;)
+ {
+ CItemEx item;
+ bool filled;
+ const HRESULT res = GetNextItem(stream, filled, item);
+ RINOK(InStream_GetPos(stream, item.DataPosition))
+ if (res == S_FALSE)
+ {
+ _errorFlags = kpv_ErrorFlags_HeadersError;
+ break;
+ }
+
+ if (res != S_OK)
+ return S_FALSE;
+ _phySize = item.DataPosition;
+ if (!filled)
+ break;
+ _items.Add(item);
+
+ _isArc = true;
+
+ UInt64 newPostion;
+ RINOK(stream->Seek(item.PackSize, STREAM_SEEK_CUR, &newPostion))
+ if (newPostion > endPos)
+ {
+ _phySize = endPos;
+ _errorFlags = kpv_ErrorFlags_UnexpectedEnd;
+ break;
+ }
+ _phySize = newPostion;
+ if (callback)
+ {
+ if (needSetTotal)
+ {
+ RINOK(callback->SetTotal(NULL, &endPos))
+ needSetTotal = false;
+ }
+ if (_items.Size() % 100 == 0)
+ {
+ UInt64 numFiles = _items.Size();
+ UInt64 numBytes = item.DataPosition;
+ RINOK(callback->SetCompleted(&numFiles, &numBytes))
+ }
+ }
+ }
+ if (_items.IsEmpty())
+ return S_FALSE;
+
+ _stream = stream;
+ }
+ catch(...)
+ {
+ return S_FALSE;
+ }
+ COM_TRY_END
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _phySize = 0;
+ _errorFlags = 0;
+ _items.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalUnPacked = 0 /* , totalPacked = 0 */;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItemEx &item = _items[allFilesMode ? i : indices[i]];
+ totalUnPacked += item.Size;
+ // totalPacked += item.PackSize;
+ }
+ RINOK(extractCallback->SetTotal(totalUnPacked))
+
+ UInt64 currentItemUnPacked, currentItemPacked;
+
+ NCompress::NLzh::NDecoder::CCoder *lzhDecoderSpec = NULL;
+ CMyComPtr<ICompressCoder> lzhDecoder;
+ // CMyComPtr<ICompressCoder> lzh1Decoder;
+ // CMyComPtr<ICompressCoder> arj2Decoder;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ for (i = 0;; i++,
+ lps->OutSize += currentItemUnPacked,
+ lps->InSize += currentItemPacked)
+ {
+ currentItemUnPacked = 0;
+ currentItemPacked = 0;
+
+ RINOK(lps->SetCur())
+
+ if (i >= numItems)
+ break;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItemEx &item = _items[index];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (item.IsDir())
+ {
+ // if (!testMode)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ continue;
+ }
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ currentItemUnPacked = item.Size;
+ currentItemPacked = item.PackSize;
+
+ {
+ COutStreamWithCRC *outStreamSpec = new COutStreamWithCRC;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->Init(realOutStream);
+ realOutStream.Release();
+
+ RINOK(InStream_SeekSet(_stream, item.DataPosition))
+
+ streamSpec->Init(item.PackSize);
+
+ HRESULT res = S_OK;
+ Int32 opRes = NExtract::NOperationResult::kOK;
+
+ if (item.IsCopyMethod())
+ {
+ res = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
+ if (res == S_OK && copyCoderSpec->TotalSize != item.PackSize)
+ res = S_FALSE;
+ }
+ else if (item.IsLh4GroupMethod())
+ {
+ if (!lzhDecoder)
+ {
+ lzhDecoderSpec = new NCompress::NLzh::NDecoder::CCoder;
+ lzhDecoder = lzhDecoderSpec;
+ }
+ lzhDecoderSpec->FinishMode = true;
+ lzhDecoderSpec->SetDictSize(1 << item.GetNumDictBits());
+ res = lzhDecoder->Code(inStream, outStream, NULL, ¤tItemUnPacked, progress);
+ if (res == S_OK && lzhDecoderSpec->GetInputProcessedSize() != item.PackSize)
+ res = S_FALSE;
+ }
+ /*
+ else if (item.IsLh1GroupMethod())
+ {
+ if (!lzh1Decoder)
+ {
+ lzh1DecoderSpec = new NCompress::NLzh1::NDecoder::CCoder;
+ lzh1Decoder = lzh1DecoderSpec;
+ }
+ lzh1DecoderSpec->SetDictionary(item.GetNumDictBits());
+ res = lzh1Decoder->Code(inStream, outStream, NULL, ¤tItemUnPacked, progress);
+ }
+ */
+ else
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+
+ if (opRes == NExtract::NOperationResult::kOK)
+ {
+ if (res == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else
+ {
+ RINOK(res)
+ if (outStreamSpec->GetCRC() != item.CRC)
+ opRes = NExtract::NOperationResult::kCRCError;
+ }
+ }
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { '-', 'l', 'h' };
+
+REGISTER_ARC_I(
+ "Lzh", "lzh lha", NULL, 6,
+ k_Signature,
+ 2,
+ 0,
+ IsArc_Lzh)
+
+}}
diff --git a/CPP/7zip/Archive/LzmaHandler.cpp b/CPP/7zip/Archive/LzmaHandler.cpp
index f13fca7..11cb76e 100644
--- a/CPP/7zip/Archive/LzmaHandler.cpp
+++ b/CPP/7zip/Archive/LzmaHandler.cpp
@@ -1,629 +1,611 @@
-// LzmaHandler.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/CpuArch.h"
-
-#include "../../Common/ComTry.h"
-#include "../../Common/IntToString.h"
-
-#include "../../Windows/PropVariant.h"
-
-#include "../Common/FilterCoder.h"
-#include "../Common/ProgressUtils.h"
-#include "../Common/RegisterArc.h"
-#include "../Common/StreamUtils.h"
-
-#include "../Compress/BcjCoder.h"
-#include "../Compress/LzmaDecoder.h"
-
-#include "Common/DummyOutStream.h"
-
-using namespace NWindows;
-
-namespace NArchive {
-namespace NLzma {
-
-static bool CheckDicSize(const Byte *p)
-{
- UInt32 dicSize = GetUi32(p);
- if (dicSize == 1)
- return true;
- for (unsigned i = 0; i <= 30; i++)
- if (dicSize == ((UInt32)2 << i) || dicSize == ((UInt32)3 << i))
- return true;
- return (dicSize == 0xFFFFFFFF);
-}
-
-static const Byte kProps[] =
-{
- kpidSize,
- kpidPackSize,
- kpidMethod
-};
-
-static const Byte kArcProps[] =
-{
- kpidNumStreams,
- kpidMethod
-};
-
-struct CHeader
-{
- UInt64 Size;
- Byte FilterID;
- Byte LzmaProps[5];
-
- Byte GetProp() const { return LzmaProps[0]; }
- UInt32 GetDicSize() const { return GetUi32(LzmaProps + 1); }
- bool HasSize() const { return (Size != (UInt64)(Int64)-1); }
- bool Parse(const Byte *buf, bool isThereFilter);
-};
-
-bool CHeader::Parse(const Byte *buf, bool isThereFilter)
-{
- FilterID = 0;
- if (isThereFilter)
- FilterID = buf[0];
- const Byte *sig = buf + (isThereFilter ? 1 : 0);
- for (int i = 0; i < 5; i++)
- LzmaProps[i] = sig[i];
- Size = GetUi64(sig + 5);
- return
- LzmaProps[0] < 5 * 5 * 9 &&
- FilterID < 2 &&
- (!HasSize() || Size < ((UInt64)1 << 56))
- && CheckDicSize(LzmaProps + 1);
-}
-
-class CDecoder
-{
- CMyComPtr<ISequentialOutStream> _bcjStream;
- CFilterCoder *_filterCoder;
- CMyComPtr<ICompressCoder> _lzmaDecoder;
-public:
- NCompress::NLzma::CDecoder *_lzmaDecoderSpec;
-
- ~CDecoder();
- HRESULT Create(bool filtered, ISequentialInStream *inStream);
-
- HRESULT Code(const CHeader &header, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
-
- UInt64 GetInputProcessedSize() const { return _lzmaDecoderSpec->GetInputProcessedSize(); }
-
- void ReleaseInStream() { if (_lzmaDecoder) _lzmaDecoderSpec->ReleaseInStream(); }
-
- HRESULT ReadInput(Byte *data, UInt32 size, UInt32 *processedSize)
- { return _lzmaDecoderSpec->ReadFromInputStream(data, size, processedSize); }
-};
-
-HRESULT CDecoder::Create(bool filteredMode, ISequentialInStream *inStream)
-{
- if (!_lzmaDecoder)
- {
- _lzmaDecoderSpec = new NCompress::NLzma::CDecoder;
- _lzmaDecoderSpec->FinishStream = true;
- _lzmaDecoder = _lzmaDecoderSpec;
- }
-
- if (filteredMode)
- {
- if (!_bcjStream)
- {
- _filterCoder = new CFilterCoder(false);
- CMyComPtr<ICompressCoder> coder = _filterCoder;
- _filterCoder->Filter = new NCompress::NBcj::CCoder(false);
- _bcjStream = _filterCoder;
- }
- }
-
- return _lzmaDecoderSpec->SetInStream(inStream);
-}
-
-CDecoder::~CDecoder()
-{
- ReleaseInStream();
-}
-
-HRESULT CDecoder::Code(const CHeader &header, ISequentialOutStream *outStream,
- ICompressProgressInfo *progress)
-{
- if (header.FilterID > 1)
- return E_NOTIMPL;
-
- RINOK(_lzmaDecoderSpec->SetDecoderProperties2(header.LzmaProps, 5));
-
- bool filteredMode = (header.FilterID == 1);
-
- if (filteredMode)
- {
- RINOK(_filterCoder->SetOutStream(outStream));
- outStream = _bcjStream;
- RINOK(_filterCoder->SetOutStreamSize(NULL));
- }
-
- const UInt64 *Size = header.HasSize() ? &header.Size : NULL;
- HRESULT res = _lzmaDecoderSpec->CodeResume(outStream, Size, progress);
-
- if (filteredMode)
- {
- {
- HRESULT res2 = _filterCoder->OutStreamFinish();
- if (res == S_OK)
- res = res2;
- }
- HRESULT res2 = _filterCoder->ReleaseOutStream();
- if (res == S_OK)
- res = res2;
- }
-
- RINOK(res);
-
- if (header.HasSize())
- if (_lzmaDecoderSpec->GetOutputProcessedSize() != header.Size)
- return S_FALSE;
-
- return S_OK;
-}
-
-
-class CHandler:
- public IInArchive,
- public IArchiveOpenSeq,
- public CMyUnknownImp
-{
- CHeader _header;
- bool _lzma86;
- CMyComPtr<IInStream> _stream;
- CMyComPtr<ISequentialInStream> _seqStream;
-
- bool _isArc;
- bool _needSeekToStart;
- bool _dataAfterEnd;
- bool _needMoreInput;
-
- bool _packSize_Defined;
- bool _unpackSize_Defined;
- bool _numStreams_Defined;
-
- bool _unsupported;
- bool _dataError;
-
- UInt64 _packSize;
- UInt64 _unpackSize;
- UInt64 _numStreams;
-
- void GetMethod(NCOM::CPropVariant &prop);
-
-public:
- MY_UNKNOWN_IMP2(IInArchive, IArchiveOpenSeq)
-
- INTERFACE_IInArchive(;)
- STDMETHOD(OpenSeq)(ISequentialInStream *stream);
-
- CHandler(bool lzma86) { _lzma86 = lzma86; }
-
- unsigned GetHeaderSize() const { return 5 + 8 + (_lzma86 ? 1 : 0); }
-
-};
-
-IMP_IInArchive_Props
-IMP_IInArchive_ArcProps
-
-STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
-{
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
- case kpidNumStreams: if (_numStreams_Defined) prop = _numStreams; break;
- case kpidUnpackSize: if (_unpackSize_Defined) prop = _unpackSize; break;
- case kpidMethod: GetMethod(prop); break;
- case kpidErrorFlags:
- {
- UInt32 v = 0;
- if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;;
- if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
- if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
- if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
- if (_dataError) v |= kpv_ErrorFlags_DataError;
- prop = v;
- break;
- }
- }
- prop.Detach(value);
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
-{
- *numItems = 1;
- return S_OK;
-}
-
-
-static void DictSizeToString(UInt32 val, char *s)
-{
- for (unsigned i = 0; i <= 31; i++)
- if (((UInt32)1 << i) == val)
- {
- ::ConvertUInt32ToString(i, s);
- return;
- }
- char c = 'b';
- if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
- else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
- ::ConvertUInt32ToString(val, s);
- s += MyStringLen(s);
- *s++ = c;
- *s = 0;
-}
-
-static char *AddProp32(char *s, const char *name, UInt32 v)
-{
- *s++ = ':';
- s = MyStpCpy(s, name);
- ::ConvertUInt32ToString(v, s);
- return s + MyStringLen(s);
-}
-
-void CHandler::GetMethod(NCOM::CPropVariant &prop)
-{
- if (!_stream)
- return;
-
- char sz[64];
- char *s = sz;
- if (_header.FilterID != 0)
- s = MyStpCpy(s, "BCJ ");
- s = MyStpCpy(s, "LZMA:");
- DictSizeToString(_header.GetDicSize(), s);
- s += strlen(s);
-
- UInt32 d = _header.GetProp();
- // if (d != 0x5D)
- {
- UInt32 lc = d % 9;
- d /= 9;
- UInt32 pb = d / 5;
- UInt32 lp = d % 5;
- if (lc != 3) s = AddProp32(s, "lc", lc);
- if (lp != 0) s = AddProp32(s, "lp", lp);
- if (pb != 2) s = AddProp32(s, "pb", pb);
- }
- prop = sz;
-}
-
-
-STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
-{
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidSize: if (_stream && _header.HasSize()) prop = _header.Size; break;
- case kpidPackSize: if (_packSize_Defined) prop = _packSize; break;
- case kpidMethod: GetMethod(prop); break;
- }
- prop.Detach(value);
- return S_OK;
-}
-
-API_FUNC_static_IsArc IsArc_Lzma(const Byte *p, size_t size)
-{
- const UInt32 kHeaderSize = 1 + 4 + 8;
- if (size < kHeaderSize)
- return k_IsArc_Res_NEED_MORE;
- if (p[0] >= 5 * 5 * 9)
- return k_IsArc_Res_NO;
- UInt64 unpackSize = GetUi64(p + 1 + 4);
- if (unpackSize != (UInt64)(Int64)-1)
- {
- if (size >= ((UInt64)1 << 56))
- return k_IsArc_Res_NO;
- }
- if (unpackSize != 0)
- {
- if (size < kHeaderSize + 2)
- return k_IsArc_Res_NEED_MORE;
- if (p[kHeaderSize] != 0)
- return k_IsArc_Res_NO;
- if (unpackSize != (UInt64)(Int64)-1)
- {
- if ((p[kHeaderSize + 1] & 0x80) != 0)
- return k_IsArc_Res_NO;
- }
- }
- if (!CheckDicSize(p + 1))
- // return k_IsArc_Res_YES_LOW_PROB;
- return k_IsArc_Res_NO;
- return k_IsArc_Res_YES;
-}
-}
-
-API_FUNC_static_IsArc IsArc_Lzma86(const Byte *p, size_t size)
-{
- if (size < 1)
- return k_IsArc_Res_NEED_MORE;
- Byte filterID = p[0];
- if (filterID != 0 && filterID != 1)
- return k_IsArc_Res_NO;
- return IsArc_Lzma(p + 1, size - 1);
-}
-}
-
-
-
-STDMETHODIMP CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *)
-{
- Close();
-
- const unsigned headerSize = GetHeaderSize();
- const UInt32 kBufSize = 1 << 7;
- Byte buf[kBufSize];
- size_t processedSize = kBufSize;
- RINOK(ReadStream(inStream, buf, &processedSize));
- if (processedSize < headerSize + 2)
- return S_FALSE;
- if (!_header.Parse(buf, _lzma86))
- return S_FALSE;
- const Byte *start = buf + headerSize;
- if (start[0] != 0 /* || (start[1] & 0x80) != 0 */ ) // empty stream with EOS is not 0x80
- return S_FALSE;
-
- RINOK(inStream->Seek(0, STREAM_SEEK_END, &_packSize));
-
- SizeT srcLen = processedSize - headerSize;
-
- if (srcLen > 10
- && _header.Size == 0
- // && _header.FilterID == 0
- && _header.LzmaProps[0] == 0
- )
- return S_FALSE;
-
- CDecoder state;
- const UInt32 outLimit = 1 << 11;
- Byte outBuf[outLimit];
-
- SizeT outSize = outLimit;
- if (outSize > _header.Size)
- outSize = (SizeT)_header.Size;
- SizeT destLen = outSize;
- ELzmaStatus status;
-
- SRes res = LzmaDecode(outBuf, &destLen, start, &srcLen,
- _header.LzmaProps, 5, LZMA_FINISH_ANY,
- &status, &g_Alloc);
-
- if (res != SZ_OK)
- if (res != SZ_ERROR_INPUT_EOF)
- return S_FALSE;
-
- _isArc = true;
- _stream = inStream;
- _seqStream = inStream;
- _needSeekToStart = true;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::OpenSeq(ISequentialInStream *stream)
-{
- Close();
- _isArc = true;
- _seqStream = stream;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::Close()
-{
- _isArc = false;
- _packSize_Defined = false;
- _unpackSize_Defined = false;
- _numStreams_Defined = false;
-
- _dataAfterEnd = false;
- _needMoreInput = false;
- _unsupported = false;
- _dataError = false;
-
- _packSize = 0;
-
- _needSeekToStart = false;
-
- _stream.Release();
- _seqStream.Release();
- return S_OK;
-}
-
-class CCompressProgressInfoImp:
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
- CMyComPtr<IArchiveOpenCallback> Callback;
-public:
- UInt64 Offset;
-
- MY_UNKNOWN_IMP1(ICompressProgressInfo)
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
- void Init(IArchiveOpenCallback *callback) { Callback = callback; }
-};
-
-STDMETHODIMP CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
-{
- if (Callback)
- {
- const UInt64 files = 0;
- const UInt64 val = Offset + *inSize;
- return Callback->SetCompleted(&files, &val);
- }
- return S_OK;
-}
-
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
- Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
- COM_TRY_BEGIN
-
- if (numItems == 0)
- return S_OK;
- if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
- return E_INVALIDARG;
-
- if (_packSize_Defined)
- extractCallback->SetTotal(_packSize);
-
-
- CMyComPtr<ISequentialOutStream> realOutStream;
- Int32 askMode = testMode ?
- NExtract::NAskMode::kTest :
- NExtract::NAskMode::kExtract;
- RINOK(extractCallback->GetStream(0, &realOutStream, askMode));
- if (!testMode && !realOutStream)
- return S_OK;
-
- extractCallback->PrepareOperation(askMode);
-
- CDummyOutStream *outStreamSpec = new CDummyOutStream;
- CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
- outStreamSpec->SetStream(realOutStream);
- outStreamSpec->Init();
- realOutStream.Release();
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(extractCallback, true);
-
- if (_needSeekToStart)
- {
- if (!_stream)
- return E_FAIL;
- RINOK(_stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
- else
- _needSeekToStart = true;
-
- CDecoder decoder;
- HRESULT result = decoder.Create(_lzma86, _seqStream);
- RINOK(result);
-
- bool firstItem = true;
-
- UInt64 packSize = 0;
- UInt64 unpackSize = 0;
- UInt64 numStreams = 0;
-
- bool dataAfterEnd = false;
-
- for (;;)
- {
- lps->InSize = packSize;
- lps->OutSize = unpackSize;
- RINOK(lps->SetCur());
-
- const UInt32 kBufSize = 1 + 5 + 8;
- Byte buf[kBufSize];
- const UInt32 headerSize = GetHeaderSize();
- UInt32 processed;
- RINOK(decoder.ReadInput(buf, headerSize, &processed));
- if (processed != headerSize)
- {
- if (processed != 0)
- dataAfterEnd = true;
- break;
- }
-
- CHeader st;
- if (!st.Parse(buf, _lzma86))
- {
- dataAfterEnd = true;
- break;
- }
- numStreams++;
- firstItem = false;
-
- result = decoder.Code(st, outStream, progress);
-
- packSize = decoder.GetInputProcessedSize();
- unpackSize = outStreamSpec->GetSize();
-
- if (result == E_NOTIMPL)
- {
- _unsupported = true;
- result = S_FALSE;
- break;
- }
- if (result == S_FALSE)
- break;
- RINOK(result);
- }
-
- if (firstItem)
- {
- _isArc = false;
- result = S_FALSE;
- }
- else if (result == S_OK || result == S_FALSE)
- {
- if (dataAfterEnd)
- _dataAfterEnd = true;
- else if (decoder._lzmaDecoderSpec->NeedsMoreInput())
- _needMoreInput = true;
-
- _packSize = packSize;
- _unpackSize = unpackSize;
- _numStreams = numStreams;
-
- _packSize_Defined = true;
- _unpackSize_Defined = true;
- _numStreams_Defined = true;
- }
-
- Int32 opResult = NExtract::NOperationResult::kOK;
-
- if (!_isArc)
- opResult = NExtract::NOperationResult::kIsNotArc;
- else if (_needMoreInput)
- opResult = NExtract::NOperationResult::kUnexpectedEnd;
- else if (_unsupported)
- opResult = NExtract::NOperationResult::kUnsupportedMethod;
- else if (_dataAfterEnd)
- opResult = NExtract::NOperationResult::kDataAfterEnd;
- else if (result == S_FALSE)
- opResult = NExtract::NOperationResult::kDataError;
- else if (result == S_OK)
- opResult = NExtract::NOperationResult::kOK;
- else
- return result;
-
- outStream.Release();
- return extractCallback->SetOperationResult(opResult);
-
- COM_TRY_END
-}
-
-namespace NLzmaAr {
-
-// 2, { 0x5D, 0x00 },
-
-REGISTER_ARC_I_CLS_NO_SIG(
- CHandler(false),
- "lzma", "lzma", 0, 0xA,
- 0,
- NArcInfoFlags::kStartOpen |
- NArcInfoFlags::kKeepName,
- IsArc_Lzma)
-
-}
-
-namespace NLzma86Ar {
-
-REGISTER_ARC_I_CLS_NO_SIG(
- CHandler(true),
- "lzma86", "lzma86", 0, 0xB,
- 0,
- NArcInfoFlags::kKeepName,
- IsArc_Lzma86)
-
-}
-
-}}
+// LzmaHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/FilterCoder.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/BcjCoder.h"
+#include "../Compress/LzmaDecoder.h"
+
+#include "Common/DummyOutStream.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NLzma {
+
+static bool CheckDicSize(const Byte *p)
+{
+ UInt32 dicSize = GetUi32(p);
+ if (dicSize == 1)
+ return true;
+ for (unsigned i = 0; i <= 30; i++)
+ if (dicSize == ((UInt32)2 << i) || dicSize == ((UInt32)3 << i))
+ return true;
+ return (dicSize == 0xFFFFFFFF);
+}
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize,
+ kpidMethod
+};
+
+static const Byte kArcProps[] =
+{
+ kpidNumStreams,
+ kpidMethod
+};
+
+struct CHeader
+{
+ UInt64 Size;
+ Byte FilterID;
+ Byte LzmaProps[5];
+
+ Byte GetProp() const { return LzmaProps[0]; }
+ UInt32 GetDicSize() const { return GetUi32(LzmaProps + 1); }
+ bool HasSize() const { return (Size != (UInt64)(Int64)-1); }
+ bool Parse(const Byte *buf, bool isThereFilter);
+};
+
+bool CHeader::Parse(const Byte *buf, bool isThereFilter)
+{
+ FilterID = 0;
+ if (isThereFilter)
+ FilterID = buf[0];
+ const Byte *sig = buf + (isThereFilter ? 1 : 0);
+ for (int i = 0; i < 5; i++)
+ LzmaProps[i] = sig[i];
+ Size = GetUi64(sig + 5);
+ return
+ LzmaProps[0] < 5 * 5 * 9 &&
+ FilterID < 2 &&
+ (!HasSize() || Size < ((UInt64)1 << 56))
+ && CheckDicSize(LzmaProps + 1);
+}
+
+class CDecoder Z7_final
+{
+ CMyComPtr<ISequentialOutStream> _bcjStream;
+ CFilterCoder *_filterCoder;
+ CMyComPtr<ICompressCoder> _lzmaDecoder;
+public:
+ NCompress::NLzma::CDecoder *_lzmaDecoderSpec;
+
+ ~CDecoder();
+ HRESULT Create(bool filtered, ISequentialInStream *inStream);
+
+ HRESULT Code(const CHeader &header, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+
+ UInt64 GetInputProcessedSize() const { return _lzmaDecoderSpec->GetInputProcessedSize(); }
+
+ void ReleaseInStream() { if (_lzmaDecoder) _lzmaDecoderSpec->ReleaseInStream(); }
+
+ HRESULT ReadInput(Byte *data, UInt32 size, UInt32 *processedSize)
+ { return _lzmaDecoderSpec->ReadFromInputStream(data, size, processedSize); }
+};
+
+HRESULT CDecoder::Create(bool filteredMode, ISequentialInStream *inStream)
+{
+ if (!_lzmaDecoder)
+ {
+ _lzmaDecoderSpec = new NCompress::NLzma::CDecoder;
+ _lzmaDecoderSpec->FinishStream = true;
+ _lzmaDecoder = _lzmaDecoderSpec;
+ }
+
+ if (filteredMode)
+ {
+ if (!_bcjStream)
+ {
+ _filterCoder = new CFilterCoder(false);
+ CMyComPtr<ICompressCoder> coder = _filterCoder;
+ _filterCoder->Filter = new NCompress::NBcj::CCoder2(z7_BranchConvSt_X86_Dec);
+ _bcjStream = _filterCoder;
+ }
+ }
+
+ return _lzmaDecoderSpec->SetInStream(inStream);
+}
+
+CDecoder::~CDecoder()
+{
+ ReleaseInStream();
+}
+
+HRESULT CDecoder::Code(const CHeader &header, ISequentialOutStream *outStream,
+ ICompressProgressInfo *progress)
+{
+ if (header.FilterID > 1)
+ return E_NOTIMPL;
+
+ RINOK(_lzmaDecoderSpec->SetDecoderProperties2(header.LzmaProps, 5))
+
+ bool filteredMode = (header.FilterID == 1);
+
+ if (filteredMode)
+ {
+ RINOK(_filterCoder->SetOutStream(outStream))
+ outStream = _bcjStream;
+ RINOK(_filterCoder->SetOutStreamSize(NULL))
+ }
+
+ const UInt64 *Size = header.HasSize() ? &header.Size : NULL;
+ HRESULT res = _lzmaDecoderSpec->CodeResume(outStream, Size, progress);
+
+ if (filteredMode)
+ {
+ {
+ HRESULT res2 = _filterCoder->OutStreamFinish();
+ if (res == S_OK)
+ res = res2;
+ }
+ HRESULT res2 = _filterCoder->ReleaseOutStream();
+ if (res == S_OK)
+ res = res2;
+ }
+
+ RINOK(res)
+
+ if (header.HasSize())
+ if (_lzmaDecoderSpec->GetOutputProcessedSize() != header.Size)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IArchiveOpenSeq
+)
+ CHeader _header;
+ bool _lzma86;
+ CMyComPtr<IInStream> _stream;
+ CMyComPtr<ISequentialInStream> _seqStream;
+
+ bool _isArc;
+ bool _needSeekToStart;
+ bool _dataAfterEnd;
+ bool _needMoreInput;
+ bool _unsupported;
+ bool _dataError;
+
+ bool _packSize_Defined;
+ bool _unpackSize_Defined;
+ bool _numStreams_Defined;
+
+ UInt64 _packSize;
+ UInt64 _unpackSize;
+ UInt64 _numStreams;
+
+ void GetMethod(NCOM::CPropVariant &prop);
+
+ unsigned GetHeaderSize() const { return 5 + 8 + (_lzma86 ? 1 : 0); }
+public:
+ CHandler(bool lzma86) { _lzma86 = lzma86; }
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidNumStreams: if (_numStreams_Defined) prop = _numStreams; break;
+ case kpidUnpackSize: if (_unpackSize_Defined) prop = _unpackSize; break;
+ case kpidMethod: GetMethod(prop); break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
+ if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
+ if (_dataError) v |= kpv_ErrorFlags_DataError;
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+
+static char * DictSizeToString(UInt32 val, char *s)
+{
+ for (unsigned i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == val)
+ return ::ConvertUInt32ToString(i, s);
+ char c = 'b';
+ if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
+ else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
+ s = ::ConvertUInt32ToString(val, s);
+ *s++ = c;
+ *s = 0;
+ return s;
+}
+
+static char *AddProp32(char *s, const char *name, UInt32 v)
+{
+ *s++ = ':';
+ s = MyStpCpy(s, name);
+ return ::ConvertUInt32ToString(v, s);
+}
+
+void CHandler::GetMethod(NCOM::CPropVariant &prop)
+{
+ if (!_stream)
+ return;
+
+ char sz[64];
+ char *s = sz;
+ if (_header.FilterID != 0)
+ s = MyStpCpy(s, "BCJ ");
+ s = MyStpCpy(s, "LZMA:");
+ s = DictSizeToString(_header.GetDicSize(), s);
+
+ UInt32 d = _header.GetProp();
+ // if (d != 0x5D)
+ {
+ UInt32 lc = d % 9;
+ d /= 9;
+ UInt32 pb = d / 5;
+ UInt32 lp = d % 5;
+ if (lc != 3) s = AddProp32(s, "lc", lc);
+ if (lp != 0) s = AddProp32(s, "lp", lp);
+ if (pb != 2) s = AddProp32(s, "pb", pb);
+ }
+ prop = sz;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidSize: if (_stream && _header.HasSize()) prop = _header.Size; break;
+ case kpidPackSize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidMethod: GetMethod(prop); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+API_FUNC_static_IsArc IsArc_Lzma(const Byte *p, size_t size)
+{
+ const UInt32 kHeaderSize = 1 + 4 + 8;
+ if (size < kHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] >= 5 * 5 * 9)
+ return k_IsArc_Res_NO;
+ const UInt64 unpackSize = GetUi64(p + 1 + 4);
+ if (unpackSize != (UInt64)(Int64)-1)
+ {
+ if (unpackSize >= ((UInt64)1 << 56))
+ return k_IsArc_Res_NO;
+ }
+ if (unpackSize != 0)
+ {
+ if (size < kHeaderSize + 2)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[kHeaderSize] != 0)
+ return k_IsArc_Res_NO;
+ if (unpackSize != (UInt64)(Int64)-1)
+ {
+ if ((p[kHeaderSize + 1] & 0x80) != 0)
+ return k_IsArc_Res_NO;
+ }
+ }
+ if (!CheckDicSize(p + 1))
+ // return k_IsArc_Res_YES_LOW_PROB;
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+API_FUNC_static_IsArc IsArc_Lzma86(const Byte *p, size_t size)
+{
+ if (size < 1)
+ return k_IsArc_Res_NEED_MORE;
+ Byte filterID = p[0];
+ if (filterID != 0 && filterID != 1)
+ return k_IsArc_Res_NO;
+ return IsArc_Lzma(p + 1, size - 1);
+}
+}
+
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *))
+{
+ Close();
+
+ const unsigned headerSize = GetHeaderSize();
+ const UInt32 kBufSize = 1 << 7;
+ Byte buf[kBufSize];
+ size_t processedSize = kBufSize;
+ RINOK(ReadStream(inStream, buf, &processedSize))
+ if (processedSize < headerSize + 2)
+ return S_FALSE;
+ if (!_header.Parse(buf, _lzma86))
+ return S_FALSE;
+ const Byte *start = buf + headerSize;
+ if (start[0] != 0 /* || (start[1] & 0x80) != 0 */ ) // empty stream with EOS is not 0x80
+ return S_FALSE;
+
+ RINOK(InStream_GetSize_SeekToEnd(inStream, _packSize))
+
+ SizeT srcLen = (SizeT)processedSize - headerSize;
+
+ if (srcLen > 10
+ && _header.Size == 0
+ // && _header.FilterID == 0
+ && _header.LzmaProps[0] == 0
+ )
+ return S_FALSE;
+
+ CDecoder state;
+ const UInt32 outLimit = 1 << 11;
+ Byte outBuf[outLimit];
+
+ SizeT outSize = outLimit;
+ if (outSize > _header.Size)
+ outSize = (SizeT)_header.Size;
+ SizeT destLen = outSize;
+ ELzmaStatus status;
+
+ SRes res = LzmaDecode(outBuf, &destLen, start, &srcLen,
+ _header.LzmaProps, 5, LZMA_FINISH_ANY,
+ &status, &g_Alloc);
+
+ if (res != SZ_OK)
+ if (res != SZ_ERROR_INPUT_EOF)
+ return S_FALSE;
+
+ _isArc = true;
+ _stream = inStream;
+ _seqStream = inStream;
+ _needSeekToStart = true;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ Close();
+ _isArc = true;
+ _seqStream = stream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+ _needSeekToStart = false;
+ _dataAfterEnd = false;
+ _needMoreInput = false;
+ _unsupported = false;
+ _dataError = false;
+
+ _packSize_Defined = false;
+ _unpackSize_Defined = false;
+ _numStreams_Defined = false;
+
+ _packSize = 0;
+
+ _stream.Release();
+ _seqStream.Release();
+ return S_OK;
+}
+
+Z7_CLASS_IMP_COM_1(
+ CCompressProgressInfoImp,
+ ICompressProgressInfo
+)
+ CMyComPtr<IArchiveOpenCallback> Callback;
+public:
+ UInt64 Offset;
+
+ void Init(IArchiveOpenCallback *callback) { Callback = callback; }
+};
+
+Z7_COM7F_IMF(CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+{
+ if (Callback)
+ {
+ const UInt64 files = 0;
+ const UInt64 val = Offset + *inSize;
+ return Callback->SetCompleted(&files, &val);
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ if (_packSize_Defined)
+ extractCallback->SetTotal(_packSize);
+
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, true);
+
+ if (_needSeekToStart)
+ {
+ if (!_stream)
+ return E_FAIL;
+ RINOK(InStream_SeekToBegin(_stream))
+ }
+ else
+ _needSeekToStart = true;
+
+ CDecoder decoder;
+ HRESULT result = decoder.Create(_lzma86, _seqStream);
+ RINOK(result)
+
+ bool firstItem = true;
+
+ UInt64 packSize = 0;
+ UInt64 unpackSize = 0;
+ UInt64 numStreams = 0;
+
+ bool dataAfterEnd = false;
+
+ for (;;)
+ {
+ lps->InSize = packSize;
+ lps->OutSize = unpackSize;
+ RINOK(lps->SetCur())
+
+ const UInt32 kBufSize = 1 + 5 + 8;
+ Byte buf[kBufSize];
+ const UInt32 headerSize = GetHeaderSize();
+ UInt32 processed;
+ RINOK(decoder.ReadInput(buf, headerSize, &processed))
+ if (processed != headerSize)
+ {
+ if (processed != 0)
+ dataAfterEnd = true;
+ break;
+ }
+
+ CHeader st;
+ if (!st.Parse(buf, _lzma86))
+ {
+ dataAfterEnd = true;
+ break;
+ }
+ numStreams++;
+ firstItem = false;
+
+ result = decoder.Code(st, outStream, progress);
+
+ packSize = decoder.GetInputProcessedSize();
+ unpackSize = outStreamSpec->GetSize();
+
+ if (result == E_NOTIMPL)
+ {
+ _unsupported = true;
+ result = S_FALSE;
+ break;
+ }
+ if (result == S_FALSE)
+ break;
+ RINOK(result)
+ }
+
+ if (firstItem)
+ {
+ _isArc = false;
+ result = S_FALSE;
+ }
+ else if (result == S_OK || result == S_FALSE)
+ {
+ if (dataAfterEnd)
+ _dataAfterEnd = true;
+ else if (decoder._lzmaDecoderSpec->NeedsMoreInput())
+ _needMoreInput = true;
+
+ _packSize = packSize;
+ _unpackSize = unpackSize;
+ _numStreams = numStreams;
+
+ _packSize_Defined = true;
+ _unpackSize_Defined = true;
+ _numStreams_Defined = true;
+ }
+
+ Int32 opResult = NExtract::NOperationResult::kOK;
+
+ if (!_isArc)
+ opResult = NExtract::NOperationResult::kIsNotArc;
+ else if (_needMoreInput)
+ opResult = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (_unsupported)
+ opResult = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (_dataAfterEnd)
+ opResult = NExtract::NOperationResult::kDataAfterEnd;
+ else if (result == S_FALSE)
+ opResult = NExtract::NOperationResult::kDataError;
+ else if (result == S_OK)
+ opResult = NExtract::NOperationResult::kOK;
+ else
+ return result;
+
+ outStream.Release();
+ return extractCallback->SetOperationResult(opResult);
+
+ COM_TRY_END
+}
+
+namespace NLzmaAr {
+
+// 2, { 0x5D, 0x00 },
+
+REGISTER_ARC_I_CLS_NO_SIG(
+ CHandler(false),
+ "lzma", "lzma", NULL, 0xA,
+ 0,
+ NArcInfoFlags::kStartOpen |
+ NArcInfoFlags::kKeepName,
+ IsArc_Lzma)
+
+}
+
+namespace NLzma86Ar {
+
+REGISTER_ARC_I_CLS_NO_SIG(
+ CHandler(true),
+ "lzma86", "lzma86", NULL, 0xB,
+ 0,
+ NArcInfoFlags::kKeepName,
+ IsArc_Lzma86)
+
+}
+
+}}
diff --git a/CPP/7zip/Archive/MachoHandler.cpp b/CPP/7zip/Archive/MachoHandler.cpp
new file mode 100644
index 0000000..4920a04
--- /dev/null
+++ b/CPP/7zip/Archive/MachoHandler.cpp
@@ -0,0 +1,744 @@
+// MachoHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/IntToString.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+static UInt32 Get32(const Byte *p, bool be) { if (be) return GetBe32(p); return GetUi32(p); }
+static UInt64 Get64(const Byte *p, bool be) { if (be) return GetBe64(p); return GetUi64(p); }
+
+using namespace NWindows;
+using namespace NCOM;
+
+namespace NArchive {
+namespace NMacho {
+
+#define CPU_ARCH_ABI64 (1 << 24)
+#define CPU_TYPE_386 7
+#define CPU_TYPE_ARM 12
+#define CPU_TYPE_SPARC 14
+#define CPU_TYPE_PPC 18
+
+#define CPU_SUBTYPE_I386_ALL 3
+
+// #define CPU_TYPE_PPC64 (CPU_ARCH_ABI64 | CPU_TYPE_PPC)
+#define CPU_TYPE_AMD64 (CPU_ARCH_ABI64 | CPU_TYPE_386)
+#define CPU_TYPE_ARM64 (CPU_ARCH_ABI64 | CPU_TYPE_ARM)
+
+#define CPU_SUBTYPE_LIB64 ((UInt32)1 << 31)
+
+#define CPU_SUBTYPE_POWERPC_970 100
+
+static const char * const k_PowerPc_SubTypes[] =
+{
+ NULL
+ , "601"
+ , "602"
+ , "603"
+ , "603e"
+ , "603ev"
+ , "604"
+ , "604e"
+ , "620"
+ , "750"
+ , "7400"
+ , "7450"
+};
+
+static const CUInt32PCharPair g_CpuPairs[] =
+{
+ { CPU_TYPE_AMD64, "x64" },
+ { CPU_TYPE_ARM64, "ARM64" },
+ { CPU_TYPE_386, "x86" },
+ { CPU_TYPE_ARM, "ARM" },
+ { CPU_TYPE_SPARC, "SPARC" },
+ { CPU_TYPE_PPC, "PowerPC" }
+};
+
+
+#define CMD_SEGMENT_32 1
+#define CMD_SEGMENT_64 0x19
+
+#define SECT_TYPE_MASK 0x000000FF
+#define SECT_ATTR_MASK 0xFFFFFF00
+
+#define SECT_ATTR_ZEROFILL 1
+
+static const char * const g_SectTypes[] =
+{
+ "REGULAR"
+ , "ZEROFILL"
+ , "CSTRINGS"
+ , "4BYTE_LITERALS"
+ , "8BYTE_LITERALS"
+ , "LITERAL_POINTERS"
+ , "NON_LAZY_SYMBOL_POINTERS"
+ , "LAZY_SYMBOL_POINTERS"
+ , "SYMBOL_STUBS"
+ , "MOD_INIT_FUNC_POINTERS"
+ , "MOD_TERM_FUNC_POINTERS"
+ , "COALESCED"
+ , "GB_ZEROFILL"
+ , "INTERPOSING"
+ , "16BYTE_LITERALS"
+ , "DTRACE_DOF"
+ , "LAZY_DYLIB_SYMBOL_POINTERS"
+ , "THREAD_LOCAL_REGULAR"
+ , "THREAD_LOCAL_ZEROFILL"
+ , "THREAD_LOCAL_VARIABLES"
+ , "THREAD_LOCAL_VARIABLE_POINTERS"
+ , "THREAD_LOCAL_INIT_FUNCTION_POINTERS"
+};
+
+enum EFileType
+{
+ kType_OBJECT = 1,
+ kType_EXECUTE,
+ kType_FVMLIB,
+ kType_CORE,
+ kType_PRELOAD,
+ kType_DYLIB,
+ kType_DYLINKER,
+ kType_BUNDLE,
+ kType_DYLIB_STUB,
+ kType_DSYM
+};
+
+static const char * const g_FileTypes[] =
+{
+ "0"
+ , "OBJECT"
+ , "EXECUTE"
+ , "FVMLIB"
+ , "CORE"
+ , "PRELOAD"
+ , "DYLIB"
+ , "DYLINKER"
+ , "BUNDLE"
+ , "DYLIB_STUB"
+ , "DSYM"
+};
+
+
+static const char * const g_ArcFlags[] =
+{
+ "NOUNDEFS"
+ , "INCRLINK"
+ , "DYLDLINK"
+ , "BINDATLOAD"
+ , "PREBOUND"
+ , "SPLIT_SEGS"
+ , "LAZY_INIT"
+ , "TWOLEVEL"
+ , "FORCE_FLAT"
+ , "NOMULTIDEFS"
+ , "NOFIXPREBINDING"
+ , "PREBINDABLE"
+ , "ALLMODSBOUND"
+ , "SUBSECTIONS_VIA_SYMBOLS"
+ , "CANONICAL"
+ , "WEAK_DEFINES"
+ , "BINDS_TO_WEAK"
+ , "ALLOW_STACK_EXECUTION"
+ , "ROOT_SAFE"
+ , "SETUID_SAFE"
+ , "NO_REEXPORTED_DYLIBS"
+ , "PIE"
+ , "DEAD_STRIPPABLE_DYLIB"
+ , "HAS_TLV_DESCRIPTORS"
+ , "NO_HEAP_EXECUTION"
+};
+
+
+static const CUInt32PCharPair g_SectFlags[] =
+{
+ { 31, "PURE_INSTRUCTIONS" },
+ { 30, "NO_TOC" },
+ { 29, "STRIP_STATIC_SYMS" },
+ { 28, "NO_DEAD_STRIP" },
+ { 27, "LIVE_SUPPORT" },
+ { 26, "SELF_MODIFYING_CODE" },
+ { 25, "DEBUG" },
+ { 10, "SOME_INSTRUCTIONS" },
+ { 9, "EXT_RELOC" },
+ { 8, "LOC_RELOC" }
+};
+
+
+// VM_PROT_*
+static const char * const g_SegmentProt[] =
+{
+ "READ"
+ , "WRITE"
+ , "EXECUTE"
+ /*
+ , "NO_CHANGE"
+ , "COPY"
+ , "TRUSTED"
+ , "IS_MASK"
+ */
+};
+
+// SG_*
+
+static const char * const g_SegmentFlags[] =
+{
+ "SG_HIGHVM"
+ , "SG_FVMLIB"
+ , "SG_NORELOC"
+ , "SG_PROTECTED_VERSION_1"
+ , "SG_READ_ONLY"
+};
+
+static const unsigned kNameSize = 16;
+
+struct CSegment
+{
+ char Name[kNameSize];
+ UInt32 MaxProt;
+ UInt32 InitProt;
+ UInt32 Flags;
+};
+
+struct CSection
+{
+ char Name[kNameSize];
+ // char SegName[kNameSize];
+ UInt64 Va;
+ UInt64 Pa;
+ UInt64 VSize;
+ UInt64 PSize;
+
+ UInt32 Align;
+ UInt32 Flags;
+ unsigned SegmentIndex;
+ bool IsDummy;
+
+ CSection(): IsDummy(false) {}
+ // UInt64 GetPackSize() const { return Flags == SECT_ATTR_ZEROFILL ? 0 : Size; }
+ UInt64 GetPackSize() const { return PSize; }
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IArchiveAllowTail
+)
+ CMyComPtr<IInStream> _inStream;
+ CObjectVector<CSegment> _segments;
+ CObjectVector<CSection> _sections;
+ bool _allowTail;
+ bool _mode64;
+ bool _be;
+ UInt32 _cpuType;
+ UInt32 _cpuSubType;
+ UInt32 _type;
+ UInt32 _flags;
+ UInt32 _headersSize;
+ UInt64 _totalSize;
+
+ HRESULT Open2(ISequentialInStream *stream);
+public:
+ CHandler(): _allowTail(false) {}
+};
+
+static const Byte kArcProps[] =
+{
+ kpidCpu,
+ kpidBit64,
+ kpidBigEndian,
+ kpidCharacts,
+ kpidHeadersSize
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidCharacts,
+ kpidOffset,
+ kpidVa,
+ kpidClusterSize // Align
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ CPropVariant prop;
+ switch (propID)
+ {
+ case kpidShortComment:
+ case kpidCpu:
+ {
+ AString s;
+ const UInt32 cpu = _cpuType & ~(UInt32)CPU_ARCH_ABI64;
+ UInt32 flag64 = _cpuType & (UInt32)CPU_ARCH_ABI64;
+ {
+ s.Add_UInt32(cpu);
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_CpuPairs); i++)
+ {
+ const CUInt32PCharPair &pair = g_CpuPairs[i];
+ if (pair.Value == cpu || pair.Value == _cpuType)
+ {
+ if (pair.Value == _cpuType)
+ flag64 = 0;
+ s = pair.Name;
+ break;
+ }
+ }
+
+ if (flag64 != 0)
+ s.Add_OptSpaced("64-bit");
+ else if ((_cpuSubType & CPU_SUBTYPE_LIB64) && _cpuType != CPU_TYPE_AMD64)
+ s.Add_OptSpaced("64-bit-lib");
+ }
+ const UInt32 t = _cpuSubType & ~(UInt32)CPU_SUBTYPE_LIB64;
+ if (t != 0 && (t != CPU_SUBTYPE_I386_ALL || cpu != CPU_TYPE_386))
+ {
+ const char *n = NULL;
+ if (cpu == CPU_TYPE_PPC)
+ {
+ if (t == CPU_SUBTYPE_POWERPC_970)
+ n = "970";
+ else if (t < Z7_ARRAY_SIZE(k_PowerPc_SubTypes))
+ n = k_PowerPc_SubTypes[t];
+ }
+ s.Add_Space();
+ if (n)
+ s += n;
+ else
+ s.Add_UInt32(t);
+ }
+ prop = s;
+ break;
+ }
+ case kpidCharacts:
+ {
+ // TYPE_TO_PROP(g_FileTypes, _type, prop); break;
+ AString res (TypeToString(g_FileTypes, Z7_ARRAY_SIZE(g_FileTypes), _type));
+ const AString s (FlagsToString(g_ArcFlags, Z7_ARRAY_SIZE(g_ArcFlags), _flags));
+ if (!s.IsEmpty())
+ {
+ res.Add_Space();
+ res += s;
+ }
+ prop = res;
+ break;
+ }
+ case kpidPhySize: prop = _totalSize; break;
+ case kpidHeadersSize: prop = _headersSize; break;
+ case kpidBit64: if (_mode64) prop = _mode64; break;
+ case kpidBigEndian: if (_be) prop = _be; break;
+ case kpidExtension:
+ {
+ const char *ext = NULL;
+ if (_type == kType_OBJECT)
+ ext = "o";
+ else if (_type == kType_BUNDLE)
+ ext = "bundle";
+ else if (_type == kType_DYLIB)
+ ext = "dylib"; // main shared library usually does not have extension
+ if (ext)
+ prop = ext;
+ break;
+ }
+ // case kpidIsSelfExe: prop = (_type == kType_EXECUTE); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+static void AddName(AString &s, const char *name)
+{
+ char temp[kNameSize + 1];
+ memcpy(temp, name, kNameSize);
+ temp[kNameSize] = 0;
+ s += temp;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ CPropVariant prop;
+ const CSection &item = _sections[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString s;
+ AddName(s, _segments[item.SegmentIndex].Name);
+ if (!item.IsDummy)
+ {
+ // CSection::SegName and CSegment::Name are same in real cases.
+ // AddName(s, item.SegName);
+ AddName(s, item.Name);
+ }
+ prop = MultiByteToUnicodeString(s);
+ break;
+ }
+ case kpidSize: /* prop = (UInt64)item.VSize; break; */
+ case kpidPackSize: prop = (UInt64)item.GetPackSize(); break;
+ case kpidCharacts:
+ {
+ AString res;
+ {
+ if (!item.IsDummy)
+ {
+ {
+ const AString s (TypeToString(g_SectTypes, Z7_ARRAY_SIZE(g_SectTypes), item.Flags & SECT_TYPE_MASK));
+ if (!s.IsEmpty())
+ {
+ res.Add_OptSpaced("sect_type:");
+ res.Add_OptSpaced(s);
+ }
+ }
+ {
+ const AString s (FlagsToString(g_SectFlags, Z7_ARRAY_SIZE(g_SectFlags), item.Flags & SECT_ATTR_MASK));
+ if (!s.IsEmpty())
+ {
+ res.Add_OptSpaced("sect_flags:");
+ res.Add_OptSpaced(s);
+ }
+ }
+ }
+ const CSegment &seg = _segments[item.SegmentIndex];
+ {
+ const AString s (FlagsToString(g_SegmentFlags, Z7_ARRAY_SIZE(g_SegmentFlags), seg.Flags));
+ if (!s.IsEmpty())
+ {
+ res.Add_OptSpaced("seg_flags:");
+ res.Add_OptSpaced(s);
+ }
+ }
+ {
+ const AString s (FlagsToString(g_SegmentProt, Z7_ARRAY_SIZE(g_SegmentProt), seg.MaxProt));
+ if (!s.IsEmpty())
+ {
+ res.Add_OptSpaced("max_prot:");
+ res.Add_OptSpaced(s);
+ }
+ }
+ {
+ const AString s (FlagsToString(g_SegmentProt, Z7_ARRAY_SIZE(g_SegmentProt), seg.InitProt));
+ if (!s.IsEmpty())
+ {
+ res.Add_OptSpaced("init_prot:");
+ res.Add_OptSpaced(s);
+ }
+ }
+ }
+ if (!res.IsEmpty())
+ prop = res;
+ break;
+ }
+ case kpidOffset: prop = item.Pa; break;
+ case kpidVa: prop = item.Va; break;
+ case kpidClusterSize: prop = (UInt32)1 << item.Align; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::Open2(ISequentialInStream *stream)
+{
+ const UInt32 kStartHeaderSize = 7 * 4;
+
+ Byte header[kStartHeaderSize];
+ RINOK(ReadStream_FALSE(stream, header, kStartHeaderSize))
+ bool be, mode64;
+ switch (GetUi32(header))
+ {
+ case 0xCEFAEDFE: be = true; mode64 = false; break;
+ case 0xCFFAEDFE: be = true; mode64 = true; break;
+ case 0xFEEDFACE: be = false; mode64 = false; break;
+ case 0xFEEDFACF: be = false; mode64 = true; break;
+ default: return S_FALSE;
+ }
+
+ _mode64 = mode64;
+ _be = be;
+
+ const UInt32 numCommands = Get32(header + 0x10, be);
+ const UInt32 commandsSize = Get32(header + 0x14, be);
+
+ if (numCommands == 0)
+ return S_FALSE;
+
+ if (commandsSize > (1 << 24) ||
+ numCommands > (1 << 21) ||
+ numCommands * 8 > commandsSize)
+ return S_FALSE;
+
+ _cpuType = Get32(header + 4, be);
+ _cpuSubType = Get32(header + 8, be);
+ _type = Get32(header + 0xC, be);
+ _flags = Get32(header + 0x18, be);
+
+ /*
+ // Probably the sections are in first commands. So we can reduce the number of commands.
+ bool reduceCommands = false;
+ const UInt32 kNumReduceCommands = 16;
+ if (numCommands > kNumReduceCommands)
+ {
+ reduceCommands = true;
+ numCommands = kNumReduceCommands;
+ }
+ */
+
+ UInt32 startHeaderSize = kStartHeaderSize;
+ if (mode64)
+ startHeaderSize += 4;
+ _headersSize = startHeaderSize + commandsSize;
+ _totalSize = _headersSize;
+ CByteArr buffer(_headersSize);
+ RINOK(ReadStream_FALSE(stream, buffer + kStartHeaderSize, _headersSize - kStartHeaderSize))
+ const Byte *buf = buffer + startHeaderSize;
+ size_t size = _headersSize - startHeaderSize;
+ for (UInt32 cmdIndex = 0; cmdIndex < numCommands; cmdIndex++)
+ {
+ if (size < 8)
+ return S_FALSE;
+ UInt32 cmd = Get32(buf, be);
+ UInt32 cmdSize = Get32(buf + 4, be);
+ if (cmdSize < 8)
+ return S_FALSE;
+ if (size < cmdSize)
+ return S_FALSE;
+ if (cmd == CMD_SEGMENT_32 || cmd == CMD_SEGMENT_64)
+ {
+ UInt32 offs = (cmd == CMD_SEGMENT_64) ? 0x48 : 0x38;
+ if (cmdSize < offs)
+ break;
+
+ UInt64 vmAddr, vmSize, phAddr, phSize;
+
+ {
+ if (cmd == CMD_SEGMENT_64)
+ {
+ vmAddr = Get64(buf + 0x18, be);
+ vmSize = Get64(buf + 0x20, be);
+ phAddr = Get64(buf + 0x28, be);
+ phSize = Get64(buf + 0x30, be);
+ }
+ else
+ {
+ vmAddr = Get32(buf + 0x18, be);
+ vmSize = Get32(buf + 0x1C, be);
+ phAddr = Get32(buf + 0x20, be);
+ phSize = Get32(buf + 0x24, be);
+ }
+ {
+ UInt64 totalSize = phAddr + phSize;
+ if (totalSize < phAddr)
+ return S_FALSE;
+ if (_totalSize < totalSize)
+ _totalSize = totalSize;
+ }
+ }
+
+ CSegment seg;
+ seg.MaxProt = Get32(buf + offs - 16, be);
+ seg.InitProt = Get32(buf + offs - 12, be);
+ seg.Flags = Get32(buf + offs - 4, be);
+ memcpy(seg.Name, buf + 8, kNameSize);
+ _segments.Add(seg);
+
+ UInt32 numSections = Get32(buf + offs - 8, be);
+ if (numSections > (1 << 8))
+ return S_FALSE;
+
+ if (numSections == 0)
+ {
+ CSection § = _sections.AddNew();
+ sect.IsDummy = true;
+ sect.SegmentIndex = _segments.Size() - 1;
+ sect.Va = vmAddr;
+ sect.PSize = phSize;
+ sect.VSize = vmSize;
+ sect.Pa = phAddr;
+ sect.Align = 0;
+ sect.Flags = 0;
+ }
+ else do
+ {
+ const UInt32 headSize = (cmd == CMD_SEGMENT_64) ? 0x50 : 0x44;
+ const Byte *p = buf + offs;
+ if (cmdSize - offs < headSize)
+ break;
+ CSection § = _sections.AddNew();
+ unsigned f32Offset;
+ if (cmd == CMD_SEGMENT_64)
+ {
+ sect.Va = Get64(p + 0x20, be);
+ sect.VSize = Get64(p + 0x28, be);
+ f32Offset = 0x30;
+ }
+ else
+ {
+ sect.Va = Get32(p + 0x20, be);
+ sect.VSize = Get32(p + 0x24, be);
+ f32Offset = 0x28;
+ }
+ sect.Pa = Get32(p + f32Offset, be);
+ sect.Align = Get32(p + f32Offset + 4, be);
+ // sect.reloff = Get32(p + f32Offset + 8, be);
+ // sect.nreloc = Get32(p + f32Offset + 12, be);
+ sect.Flags = Get32(p + f32Offset + 16, be);
+ if ((sect.Flags & SECT_TYPE_MASK) == SECT_ATTR_ZEROFILL)
+ sect.PSize = 0;
+ else
+ sect.PSize = sect.VSize;
+ memcpy(sect.Name, p, kNameSize);
+ // memcpy(sect.SegName, p + kNameSize, kNameSize);
+ sect.SegmentIndex = _segments.Size() - 1;
+ offs += headSize;
+ }
+ while (--numSections);
+
+ if (offs != cmdSize)
+ return S_FALSE;
+ }
+ buf += cmdSize;
+ size -= cmdSize;
+ }
+ // return (reduceCommands || (size == 0)) ? S_OK : S_FALSE;
+ if (size != 0)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(Open2(inStream))
+ if (!_allowTail)
+ {
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(inStream, fileSize))
+ if (fileSize > _totalSize)
+ return S_FALSE;
+ }
+ _inStream = inStream;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ _inStream.Release();
+ _sections.Clear();
+ _segments.Clear();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _sections.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _sections.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _sections[allFilesMode ? i : indices[i]].GetPackSize();
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+ UInt64 currentItemSize;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_inStream);
+
+ for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CSection &item = _sections[index];
+ currentItemSize = item.GetPackSize();
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(InStream_SeekSet(_inStream, item.Pa))
+ streamSpec->Init(currentItemSize);
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(copyCoderSpec->TotalSize == currentItemSize ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::AllowTail(Int32 allowTail))
+{
+ _allowTail = IntToBool(allowTail);
+ return S_OK;
+}
+
+static const Byte k_Signature[] = {
+ 4, 0xCE, 0xFA, 0xED, 0xFE,
+ 4, 0xCF, 0xFA, 0xED, 0xFE,
+ 4, 0xFE, 0xED, 0xFA, 0xCE,
+ 4, 0xFE, 0xED, 0xFA, 0xCF };
+
+REGISTER_ARC_I(
+ "MachO", "macho", NULL, 0xDF,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kMultiSignature |
+ NArcInfoFlags::kPreArc,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/MbrHandler.cpp b/CPP/7zip/Archive/MbrHandler.cpp
new file mode 100644
index 0000000..0d3611b
--- /dev/null
+++ b/CPP/7zip/Archive/MbrHandler.cpp
@@ -0,0 +1,567 @@
+// MbrHandler.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NMbr {
+
+struct CChs
+{
+ Byte Head;
+ Byte SectCyl;
+ Byte Cyl8;
+
+ UInt32 GetSector() const { return SectCyl & 0x3F; }
+ UInt32 GetCyl() const { return ((UInt32)SectCyl >> 6 << 8) | Cyl8; }
+ void ToString(NCOM::CPropVariant &prop) const;
+
+ void Parse(const Byte *p)
+ {
+ Head = p[0];
+ SectCyl = p[1];
+ Cyl8 = p[2];
+ }
+ bool Check() const { return GetSector() > 0; }
+};
+
+
+// Chs in some MBRs contains only low bits of "Cyl number". So we disable check.
+/*
+#define RINOZ(x) { int _t_ = (x); if (_t_ != 0) return _t_; }
+static int CompareChs(const CChs &c1, const CChs &c2)
+{
+ RINOZ(MyCompare(c1.GetCyl(), c2.GetCyl()));
+ RINOZ(MyCompare(c1.Head, c2.Head));
+ return MyCompare(c1.GetSector(), c2.GetSector());
+}
+*/
+
+void CChs::ToString(NCOM::CPropVariant &prop) const
+{
+ AString s;
+ s.Add_UInt32(GetCyl());
+ s.Add_Minus();
+ s.Add_UInt32(Head);
+ s.Add_Minus();
+ s.Add_UInt32(GetSector());
+ prop = s;
+}
+
+struct CPartition
+{
+ Byte Status;
+ CChs BeginChs;
+ Byte Type;
+ CChs EndChs;
+ UInt32 Lba;
+ UInt32 NumBlocks;
+
+ CPartition() { memset (this, 0, sizeof(*this)); }
+
+ bool IsEmpty() const { return Type == 0; }
+ bool IsExtended() const { return Type == 5 || Type == 0xF; }
+ UInt32 GetLimit() const { return Lba + NumBlocks; }
+ // bool IsActive() const { return Status == 0x80; }
+ UInt64 GetPos() const { return (UInt64)Lba * 512; }
+ UInt64 GetSize() const { return (UInt64)NumBlocks * 512; }
+
+ bool CheckLbaLimits() const { return (UInt32)0xFFFFFFFF - Lba >= NumBlocks; }
+ bool Parse(const Byte *p)
+ {
+ Status = p[0];
+ BeginChs.Parse(p + 1);
+ Type = p[4];
+ EndChs.Parse(p + 5);
+ Lba = GetUi32(p + 8);
+ NumBlocks = GetUi32(p + 12);
+ if (Type == 0)
+ return true;
+ if (Status != 0 && Status != 0x80)
+ return false;
+ return BeginChs.Check()
+ && EndChs.Check()
+ // && CompareChs(BeginChs, EndChs) <= 0
+ && NumBlocks > 0
+ && CheckLbaLimits();
+ }
+
+ #ifdef SHOW_DEBUG_INFO
+ void Print() const
+ {
+ NCOM::CPropVariant prop, prop2;
+ BeginChs.ToString(prop);
+ EndChs.ToString(prop2);
+ printf(" %2x %2x %8X %8X %12S %12S", (int)Status, (int)Type, Lba, NumBlocks, prop.bstrVal, prop2.bstrVal);
+ }
+ #endif
+};
+
+struct CPartType
+{
+ UInt32 Id;
+ const char *Ext;
+ const char *Name;
+};
+
+#define kFat "fat"
+
+/*
+if we use "format" command in Windows 10 for existing partition:
+ - if we format to ExFAT, it sets type=7
+ - if we format to UDF, it doesn't change type from previous value.
+*/
+
+static const unsigned kType_Windows_NTFS = 7;
+
+static const CPartType kPartTypes[] =
+{
+ { 0x01, kFat, "FAT12" },
+ { 0x04, kFat, "FAT16 DOS 3.0+" },
+ { 0x05, NULL, "Extended" },
+ { 0x06, kFat, "FAT16 DOS 3.31+" },
+ { 0x07, "ntfs", "NTFS" },
+ { 0x0B, kFat, "FAT32" },
+ { 0x0C, kFat, "FAT32-LBA" },
+ { 0x0E, kFat, "FAT16-LBA" },
+ { 0x0F, NULL, "Extended-LBA" },
+ { 0x11, kFat, "FAT12-Hidden" },
+ { 0x14, kFat, "FAT16-Hidden < 32 MB" },
+ { 0x16, kFat, "FAT16-Hidden >= 32 MB" },
+ { 0x1B, kFat, "FAT32-Hidden" },
+ { 0x1C, kFat, "FAT32-LBA-Hidden" },
+ { 0x1E, kFat, "FAT16-LBA-WIN95-Hidden" },
+ { 0x27, "ntfs", "NTFS-WinRE" },
+ { 0x82, NULL, "Solaris x86 / Linux swap" },
+ { 0x83, NULL, "Linux" },
+ { 0x8E, "lvm", "Linux LVM" },
+ { 0xA5, NULL, "BSD slice" },
+ { 0xBE, NULL, "Solaris 8 boot" },
+ { 0xBF, NULL, "New Solaris x86" },
+ { 0xC2, NULL, "Linux-Hidden" },
+ { 0xC3, NULL, "Linux swap-Hidden" },
+ { 0xEE, NULL, "GPT" },
+ { 0xEE, NULL, "EFI" }
+};
+
+static int FindPartType(UInt32 type)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kPartTypes); i++)
+ if (kPartTypes[i].Id == type)
+ return (int)i;
+ return -1;
+}
+
+struct CItem
+{
+ bool IsReal;
+ bool IsPrim;
+ bool WasParsed;
+ const char *FileSystem;
+ UInt64 Size;
+ CPartition Part;
+
+ CItem():
+ WasParsed(false),
+ FileSystem(NULL)
+ {}
+};
+
+
+Z7_class_CHandler_final: public CHandlerCont
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Cont)
+
+ CObjectVector<CItem> _items;
+ UInt64 _totalSize;
+ CByteBuffer _buffer;
+
+ virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const Z7_override Z7_final
+ {
+ const CItem &item = _items[index];
+ pos = item.Part.GetPos();
+ size = item.Size;
+ return NExtract::NOperationResult::kOK;
+ }
+
+ HRESULT ReadTables(IInStream *stream, UInt32 baseLba, UInt32 lba, unsigned level);
+};
+
+HRESULT CHandler::ReadTables(IInStream *stream, UInt32 baseLba, UInt32 lba, unsigned level)
+{
+ if (level >= 128 || _items.Size() >= 128)
+ return S_FALSE;
+
+ const unsigned kNumHeaderParts = 4;
+ CPartition parts[kNumHeaderParts];
+
+ {
+ const UInt32 kSectorSize = 512;
+ _buffer.Alloc(kSectorSize);
+ Byte *buf = _buffer;
+ UInt64 newPos = (UInt64)lba << 9;
+ if (newPos + 512 > _totalSize)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(stream, newPos))
+ RINOK(ReadStream_FALSE(stream, buf, kSectorSize))
+
+ if (buf[0x1FE] != 0x55 || buf[0x1FF] != 0xAA)
+ return S_FALSE;
+
+ for (unsigned i = 0; i < kNumHeaderParts; i++)
+ if (!parts[i].Parse(buf + 0x1BE + 16 * i))
+ return S_FALSE;
+ }
+
+ PRF(printf("\n# %8X", lba));
+
+ UInt32 limLba = lba + 1;
+ if (limLba == 0)
+ return S_FALSE;
+
+ for (unsigned i = 0; i < kNumHeaderParts; i++)
+ {
+ CPartition &part = parts[i];
+
+ if (part.IsEmpty())
+ continue;
+ PRF(printf("\n %2d ", (unsigned)level));
+ #ifdef SHOW_DEBUG_INFO
+ part.Print();
+ #endif
+
+ unsigned numItems = _items.Size();
+ UInt32 newLba = lba + part.Lba;
+
+ if (part.IsExtended())
+ {
+ // if (part.Type == 5) // Check it!
+ newLba = baseLba + part.Lba;
+ if (newLba < limLba)
+ return S_FALSE;
+ HRESULT res = ReadTables(stream, level < 1 ? newLba : baseLba, newLba, level + 1);
+ if (res != S_FALSE && res != S_OK)
+ return res;
+ }
+ if (newLba < limLba)
+ return S_FALSE;
+ part.Lba = newLba;
+ if (!part.CheckLbaLimits())
+ return S_FALSE;
+
+ CItem n;
+ n.Part = part;
+ bool addItem = false;
+ if (numItems == _items.Size())
+ {
+ n.IsPrim = (level == 0);
+ n.IsReal = true;
+ addItem = true;
+ }
+ else
+ {
+ const CItem &back = _items.Back();
+ UInt32 backLimit = back.Part.GetLimit();
+ UInt32 partLimit = part.GetLimit();
+ if (backLimit < partLimit)
+ {
+ n.IsReal = false;
+ n.Part.Lba = backLimit;
+ n.Part.NumBlocks = partLimit - backLimit;
+ addItem = true;
+ }
+ }
+ if (addItem)
+ {
+ if (n.Part.GetLimit() < limLba)
+ return S_FALSE;
+ limLba = n.Part.GetLimit();
+ n.Size = n.Part.GetSize();
+ _items.Add(n);
+ }
+ }
+ return S_OK;
+}
+
+
+static bool Is_Ntfs(const Byte *p)
+{
+ if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+ return false;
+ // int codeOffset = 0;
+ switch (p[0])
+ {
+ case 0xE9: /* codeOffset = 3 + (Int16)Get16(p + 1); */ break;
+ case 0xEB: if (p[2] != 0x90) return false; /* codeOffset = 2 + (int)(signed char)p[1]; */ break;
+ default: return false;
+ }
+ return memcmp(p + 3, "NTFS ", 8) == 0;
+}
+
+static bool Is_ExFat(const Byte *p)
+{
+ if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+ return false;
+ if (p[0] != 0xEB || p[1] != 0x76 || p[2] != 0x90)
+ return false;
+ return memcmp(p + 3, "EXFAT ", 8) == 0;
+}
+
+static bool AllAreZeros(const Byte *p, size_t size)
+{
+ for (size_t i = 0; i < size; i++)
+ if (p[i] != 0)
+ return false;
+ return true;
+}
+
+static const UInt32 k_Udf_StartPos = 0x8000;
+static const Byte k_Udf_Signature[] = { 0, 'B', 'E', 'A', '0', '1', 1, 0 };
+
+static bool Is_Udf(const Byte *p)
+{
+ return memcmp(p + k_Udf_StartPos, k_Udf_Signature, sizeof(k_Udf_Signature)) == 0;
+}
+
+
+static const char *GetFileSystem(
+ ISequentialInStream *stream, UInt64 partitionSize)
+{
+ const size_t kHeaderSize = 1 << 9;
+ if (partitionSize >= kHeaderSize)
+ {
+ Byte buf[kHeaderSize];
+ if (ReadStream_FAIL(stream, buf, kHeaderSize) == S_OK)
+ {
+ // NTFS is expected default filesystem for (Type == 7)
+ if (Is_Ntfs(buf))
+ return "NTFS";
+ if (Is_ExFat(buf))
+ return "exFAT";
+ const size_t kHeaderSize2 = k_Udf_StartPos + (1 << 9);
+ if (partitionSize >= kHeaderSize2)
+ {
+ if (AllAreZeros(buf, kHeaderSize))
+ {
+ CByteBuffer buffer(kHeaderSize2);
+ // memcpy(buffer, buf, kHeaderSize);
+ if (ReadStream_FAIL(stream, buffer + kHeaderSize, kHeaderSize2 - kHeaderSize) == S_OK)
+ if (Is_Udf(buffer))
+ return "UDF";
+ }
+ }
+ }
+ }
+ return NULL;
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(InStream_GetSize_SeekToEnd(stream, _totalSize))
+ RINOK(ReadTables(stream, 0, 0, 0))
+ if (_items.IsEmpty())
+ return S_FALSE;
+ UInt32 lbaLimit = _items.Back().Part.GetLimit();
+ UInt64 lim = (UInt64)lbaLimit << 9;
+ if (lim < _totalSize)
+ {
+ CItem n;
+ n.Part.Lba = lbaLimit;
+ n.Size = _totalSize - lim;
+ n.IsReal = false;
+ _items.Add(n);
+ }
+
+ FOR_VECTOR (i, _items)
+ {
+ CItem &item = _items[i];
+ if (item.Part.Type != kType_Windows_NTFS)
+ continue;
+ if (InStream_SeekSet(stream, item.Part.GetPos()) != S_OK)
+ continue;
+ item.FileSystem = GetFileSystem(stream, item.Size);
+ item.WasParsed = true;
+ }
+
+ _stream = stream;
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ _items.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+
+enum
+{
+ kpidPrimary = kpidUserDefined,
+ kpidBegChs,
+ kpidEndChs
+};
+
+static const CStatProp kProps[] =
+{
+ { NULL, kpidPath, VT_BSTR},
+ { NULL, kpidSize, VT_UI8},
+ { NULL, kpidFileSystem, VT_BSTR},
+ { NULL, kpidOffset, VT_UI8},
+ { "Primary", kpidPrimary, VT_BOOL},
+ { "Begin CHS", kpidBegChs, VT_BSTR},
+ { "End CHS", kpidEndChs, VT_BSTR}
+};
+
+IMP_IInArchive_Props_WITH_NAME
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile:
+ {
+ int mainIndex = -1;
+ FOR_VECTOR (i, _items)
+ if (_items[i].IsReal)
+ {
+ if (mainIndex >= 0)
+ {
+ mainIndex = -1;
+ break;
+ }
+ mainIndex = (int)i;
+ }
+ if (mainIndex >= 0)
+ prop = (UInt32)(Int32)mainIndex;
+ break;
+ }
+ case kpidPhySize: prop = _totalSize; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CItem &item = _items[index];
+ const CPartition &part = item.Part;
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString s;
+ s.Add_UInt32(index);
+ if (item.IsReal)
+ {
+ s.Add_Dot();
+ const char *ext = NULL;
+ if (item.FileSystem)
+ {
+ ext = "";
+ AString fs (item.FileSystem);
+ fs.MakeLower_Ascii();
+ s += fs;
+ }
+ else if (!item.WasParsed)
+ {
+ const int typeIndex = FindPartType(part.Type);
+ if (typeIndex >= 0)
+ ext = kPartTypes[(unsigned)typeIndex].Ext;
+ }
+ if (!ext)
+ ext = "img";
+ s += ext;
+ }
+ prop = s;
+ break;
+ }
+ case kpidFileSystem:
+ if (item.IsReal)
+ {
+ char s[32];
+ ConvertUInt32ToString(part.Type, s);
+ const char *res = s;
+ if (item.FileSystem)
+ {
+ // strcat(s, "-");
+ // strcpy(s, item.FileSystem);
+ res = item.FileSystem;
+ }
+ else if (!item.WasParsed)
+ {
+ const int typeIndex = FindPartType(part.Type);
+ if (typeIndex >= 0 && kPartTypes[(unsigned)typeIndex].Name)
+ res = kPartTypes[(unsigned)typeIndex].Name;
+ }
+ prop = res;
+ }
+ break;
+ case kpidSize:
+ case kpidPackSize: prop = item.Size; break;
+ case kpidOffset: prop = part.GetPos(); break;
+ case kpidPrimary: if (item.IsReal) prop = item.IsPrim; break;
+ case kpidBegChs: if (item.IsReal) part.BeginChs.ToString(prop); break;
+ case kpidEndChs: if (item.IsReal) part.EndChs.ToString(prop); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+ // 3, { 1, 1, 0 },
+ // 2, { 0x55, 0x1FF },
+
+REGISTER_ARC_I_NO_SIG(
+ "MBR", "mbr", NULL, 0xDB,
+ 0,
+ NArcInfoFlags::kPureStartOpen,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/MslzHandler.cpp b/CPP/7zip/Archive/MslzHandler.cpp
new file mode 100644
index 0000000..04549f8
--- /dev/null
+++ b/CPP/7zip/Archive/MslzHandler.cpp
@@ -0,0 +1,390 @@
+// MslzHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/InBuffer.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "Common/DummyOutStream.h"
+
+namespace NArchive {
+namespace NMslz {
+
+static const UInt32 kUnpackSizeMax = 0xFFFFFFE0;
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IArchiveOpenSeq
+)
+ CMyComPtr<IInStream> _inStream;
+ CMyComPtr<ISequentialInStream> _seqStream;
+
+ bool _isArc;
+ bool _needSeekToStart;
+ bool _dataAfterEnd;
+ bool _needMoreInput;
+
+ bool _packSize_Defined;
+ bool _unpackSize_Defined;
+
+ UInt32 _unpackSize;
+ UInt64 _packSize;
+ UInt64 _originalFileSize;
+ UString _name;
+
+ void ParseName(Byte replaceByte, IArchiveOpenCallback *callback);
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidExtension: prop = "mslz"; break;
+ case kpidIsNotArcType: prop = true; break;
+ case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
+ prop = v;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPath: if (!_name.IsEmpty()) prop = _name; break;
+ case kpidSize: if (_unpackSize_Defined || _inStream) prop = _unpackSize; break;
+ case kpidPackSize: if (_packSize_Defined || _inStream) prop = _packSize; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+static const unsigned kSignatureSize = 9;
+static const unsigned kHeaderSize = kSignatureSize + 1 + 4;
+#define MSLZ_SIGNATURE { 0x53, 0x5A, 0x44, 0x44, 0x88, 0xF0, 0x27, 0x33, 0x41 }
+// old signature: 53 5A 20 88 F0 27 33
+static const Byte kSignature[kSignatureSize] = MSLZ_SIGNATURE;
+
+// we support only 3 chars strings here
+static const char * const g_Exts[] =
+{
+ "bin"
+ , "dll"
+ , "exe"
+ , "kmd"
+ , "pdf"
+ , "sys"
+};
+
+void CHandler::ParseName(Byte replaceByte, IArchiveOpenCallback *callback)
+{
+ if (!callback)
+ return;
+ Z7_DECL_CMyComPtr_QI_FROM(IArchiveOpenVolumeCallback, volumeCallback, callback)
+ if (!volumeCallback)
+ return;
+
+ NWindows::NCOM::CPropVariant prop;
+ if (volumeCallback->GetProperty(kpidName, &prop) != S_OK || prop.vt != VT_BSTR)
+ return;
+
+ UString s = prop.bstrVal;
+ if (s.IsEmpty() ||
+ s.Back() != L'_')
+ return;
+
+ s.DeleteBack();
+ _name = s;
+
+ if (replaceByte == 0)
+ {
+ if (s.Len() < 3 || s[s.Len() - 3] != '.')
+ return;
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Exts); i++)
+ {
+ const char *ext = g_Exts[i];
+ if (s[s.Len() - 2] == (Byte)ext[0] &&
+ s[s.Len() - 1] == (Byte)ext[1])
+ {
+ replaceByte = (Byte)ext[2];
+ break;
+ }
+ }
+ }
+
+ if (replaceByte >= 0x20 && replaceByte < 0x80)
+ _name += (char)replaceByte;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ _needSeekToStart = true;
+ Byte buffer[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buffer, kHeaderSize))
+ if (memcmp(buffer, kSignature, kSignatureSize) != 0)
+ return S_FALSE;
+ _unpackSize = GetUi32(buffer + 10);
+ if (_unpackSize > kUnpackSizeMax)
+ return S_FALSE;
+ RINOK(InStream_GetSize_SeekToEnd(stream, _originalFileSize))
+ _packSize = _originalFileSize;
+
+ ParseName(buffer[kSignatureSize], callback);
+
+ _isArc = true;
+ _unpackSize_Defined = true;
+ _inStream = stream;
+ _seqStream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _originalFileSize = 0;
+ _packSize = 0;
+ _unpackSize = 0;
+
+ _isArc = false;
+ _needSeekToStart = false;
+ _dataAfterEnd = false;
+ _needMoreInput = false;
+
+ _packSize_Defined = false;
+ _unpackSize_Defined = false;
+
+ _seqStream.Release();
+ _inStream.Release();
+ _name.Empty();
+ return S_OK;
+}
+
+// MslzDec is modified LZSS algorithm of Haruhiko Okumura:
+// maxLen = 18; Okumura
+// maxLen = 16; MS
+
+#define PROGRESS_AND_WRITE \
+ if ((dest & kMask) == 0) { if (outStream) RINOK(WriteStream(outStream, buf, kBufSize)); \
+ if ((dest & ((1 << 20) - 1)) == 0) \
+ if (progress) \
+ { UInt64 inSize = inStream.GetProcessedSize(); UInt64 outSize = dest; \
+ RINOK(progress->SetRatioInfo(&inSize, &outSize)); }}
+
+static HRESULT MslzDec(CInBuffer &inStream, ISequentialOutStream *outStream, UInt32 unpackSize, bool &needMoreData, ICompressProgressInfo *progress)
+{
+ const unsigned kBufSize = (1 << 12);
+ const unsigned kMask = kBufSize - 1;
+ Byte buf[kBufSize];
+ UInt32 dest = 0;
+ memset(buf, ' ', kBufSize);
+
+ while (dest < unpackSize)
+ {
+ Byte b;
+ if (!inStream.ReadByte(b))
+ {
+ needMoreData = true;
+ return S_FALSE;
+ }
+
+ for (unsigned mask = (unsigned)b | 0x100; mask > 1 && dest < unpackSize; mask >>= 1)
+ {
+ if (!inStream.ReadByte(b))
+ {
+ needMoreData = true;
+ return S_FALSE;
+ }
+
+ if (mask & 1)
+ {
+ buf[dest++ & kMask] = b;
+ PROGRESS_AND_WRITE
+ }
+ else
+ {
+ Byte b1;
+ if (!inStream.ReadByte(b1))
+ {
+ needMoreData = true;
+ return S_FALSE;
+ }
+ const unsigned kMaxLen = 16; // 18 in Okumura's code.
+ unsigned src = (((((unsigned)b1 & 0xF0) << 4) | b) + kMaxLen) & kMask;
+ unsigned len = (b1 & 0xF) + 3;
+ if (len > kMaxLen || dest + len > unpackSize)
+ return S_FALSE;
+
+ do
+ {
+ buf[dest++ & kMask] = buf[src++ & kMask];
+ PROGRESS_AND_WRITE
+ }
+ while (--len != 0);
+ }
+ }
+ }
+
+ if (outStream)
+ RINOK(WriteStream(outStream, buf, dest & kMask))
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ COM_TRY_BEGIN
+ Close();
+ _isArc = true;
+ _seqStream = stream;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ // extractCallback->SetTotal(_unpackSize);
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ if (_needSeekToStart)
+ {
+ if (!_inStream)
+ return E_FAIL;
+ RINOK(InStream_SeekToBegin(_inStream))
+ }
+ else
+ _needSeekToStart = true;
+
+ Int32 opRes = NExtract::NOperationResult::kDataError;
+
+ bool isArc = false;
+ bool needMoreInput = false;
+ try
+ {
+ CInBuffer s;
+ if (!s.Create(1 << 20))
+ return E_OUTOFMEMORY;
+ s.SetStream(_seqStream);
+ s.Init();
+
+ Byte buffer[kHeaderSize];
+ if (s.ReadBytes(buffer, kHeaderSize) == kHeaderSize)
+ {
+ UInt32 unpackSize;
+ if (memcmp(buffer, kSignature, kSignatureSize) == 0)
+ {
+ unpackSize = GetUi32(buffer + 10);
+ if (unpackSize <= kUnpackSizeMax)
+ {
+ HRESULT result = MslzDec(s, outStream, unpackSize, needMoreInput, progress);
+ if (result == S_OK)
+ opRes = NExtract::NOperationResult::kOK;
+ else if (result != S_FALSE)
+ return result;
+ _unpackSize = unpackSize;
+ _unpackSize_Defined = true;
+
+ _packSize = s.GetProcessedSize();
+ _packSize_Defined = true;
+
+ if (_inStream && _packSize < _originalFileSize)
+ _dataAfterEnd = true;
+
+ isArc = true;
+ }
+ }
+ }
+ }
+ catch (CInBufferException &e) { return e.ErrorCode; }
+
+ _isArc = isArc;
+ if (isArc)
+ _needMoreInput = needMoreInput;
+ if (!_isArc)
+ opRes = NExtract::NOperationResult::kIsNotArc;
+ else if (_needMoreInput)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (_dataAfterEnd)
+ opRes = NExtract::NOperationResult::kDataAfterEnd;
+
+ outStream.Release();
+ return extractCallback->SetOperationResult(opRes);
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "MsLZ", "mslz", NULL, 0xD5,
+ kSignature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/MubHandler.cpp b/CPP/7zip/Archive/MubHandler.cpp
new file mode 100644
index 0000000..7363b1b
--- /dev/null
+++ b/CPP/7zip/Archive/MubHandler.cpp
@@ -0,0 +1,262 @@
+// MubHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/SwapBytes.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+using namespace NWindows;
+using namespace NCOM;
+
+namespace NArchive {
+namespace NMub {
+
+#define MACH_CPU_ARCH_ABI64 ((UInt32)1 << 24)
+#define MACH_CPU_TYPE_386 7
+#define MACH_CPU_TYPE_ARM 12
+#define MACH_CPU_TYPE_SPARC 14
+#define MACH_CPU_TYPE_PPC 18
+
+#define MACH_CPU_TYPE_PPC64 (MACH_CPU_ARCH_ABI64 | MACH_CPU_TYPE_PPC)
+#define MACH_CPU_TYPE_AMD64 (MACH_CPU_ARCH_ABI64 | MACH_CPU_TYPE_386)
+#define MACH_CPU_TYPE_ARM64 (MACH_CPU_ARCH_ABI64 | MACH_CPU_TYPE_ARM)
+
+#define MACH_CPU_SUBTYPE_LIB64 ((UInt32)1 << 31)
+
+#define MACH_CPU_SUBTYPE_I386_ALL 3
+
+struct CItem
+{
+ UInt32 Type;
+ UInt32 SubType;
+ UInt32 Offset;
+ UInt32 Size;
+ UInt32 Align;
+};
+
+static const UInt32 kNumFilesMax = 6;
+
+Z7_class_CHandler_final: public CHandlerCont
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Cont)
+
+ // UInt64 _startPos;
+ UInt64 _phySize;
+ UInt32 _numItems;
+ bool _bigEndian;
+ CItem _items[kNumFilesMax];
+
+ HRESULT Open2(IInStream *stream);
+
+ virtual int GetItem_ExtractInfo(UInt32 index, UInt64 &pos, UInt64 &size) const Z7_override
+ {
+ const CItem &item = _items[index];
+ pos = item.Offset;
+ size = item.Size;
+ return NExtract::NOperationResult::kOK;
+ }
+};
+
+static const Byte kArcProps[] =
+{
+ kpidBigEndian
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidOffset,
+ kpidClusterSize // Align
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ PropVariant_Clear(value);
+ switch (propID)
+ {
+ case kpidBigEndian: PropVarEm_Set_Bool(value, _bigEndian); break;
+ case kpidPhySize: PropVarEm_Set_UInt64(value, _phySize); break;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ PropVariant_Clear(value);
+ const CItem &item = _items[index];
+ switch (propID)
+ {
+ case kpidExtension:
+ {
+ char temp[32];
+ const char *ext = NULL;
+ switch (item.Type)
+ {
+ case MACH_CPU_TYPE_386: ext = "x86"; break;
+ case MACH_CPU_TYPE_ARM: ext = "arm"; break;
+ case MACH_CPU_TYPE_SPARC: ext = "sparc"; break;
+ case MACH_CPU_TYPE_PPC: ext = "ppc"; break;
+ case MACH_CPU_TYPE_AMD64: ext = "x64"; break;
+ case MACH_CPU_TYPE_ARM64: ext = "arm64"; break;
+ case MACH_CPU_TYPE_PPC64: ext = "ppc64"; break;
+ default:
+ temp[0] = 'c';
+ temp[1] = 'p';
+ temp[2] = 'u';
+ char *p = ConvertUInt32ToString(item.Type & ~MACH_CPU_ARCH_ABI64, temp + 3);
+ if (item.Type & MACH_CPU_ARCH_ABI64)
+ MyStringCopy(p, "_64");
+ break;
+ }
+ if (ext)
+ MyStringCopy(temp, ext);
+ if (item.SubType != 0)
+ if ((item.Type != MACH_CPU_TYPE_386 &&
+ item.Type != MACH_CPU_TYPE_AMD64)
+ || (item.SubType & ~(UInt32)MACH_CPU_SUBTYPE_LIB64) != MACH_CPU_SUBTYPE_I386_ALL
+ )
+ {
+ unsigned pos = MyStringLen(temp);
+ temp[pos++] = '-';
+ ConvertUInt32ToString(item.SubType, temp + pos);
+ }
+ return PropVarEm_Set_Str(value, temp);
+ }
+ case kpidSize:
+ case kpidPackSize:
+ PropVarEm_Set_UInt64(value, item.Size);
+ break;
+ case kpidOffset:
+ PropVarEm_Set_UInt64(value, item.Offset);
+ break;
+ case kpidClusterSize:
+ PropVarEm_Set_UInt32(value, (UInt32)1 << item.Align);
+ break;
+ }
+ return S_OK;
+}
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ // RINOK(InStream_GetPos(stream, _startPos));
+
+ const UInt32 kHeaderSize = 2;
+ const UInt32 kRecordSize = 5;
+ const UInt32 kBufSize = kHeaderSize + kNumFilesMax * kRecordSize;
+ UInt32 buf[kBufSize];
+ size_t processed = kBufSize * 4;
+ RINOK(ReadStream(stream, buf, &processed))
+ processed >>= 2;
+ if (processed < kHeaderSize)
+ return S_FALSE;
+
+ bool be;
+ switch (buf[0])
+ {
+ case Z7_CONV_BE_TO_NATIVE_CONST32(0xCAFEBABE): be = true; break;
+ case Z7_CONV_BE_TO_NATIVE_CONST32(0xB9FAF10E): be = false; break;
+ default: return S_FALSE;
+ }
+ _bigEndian = be;
+ if (
+ #if defined(MY_CPU_BE)
+ !
+ #endif
+ be)
+ z7_SwapBytes4(&buf[1], processed - 1);
+ const UInt32 num = buf[1];
+ if (num > kNumFilesMax || processed < kHeaderSize + num * kRecordSize)
+ return S_FALSE;
+ if (num == 0)
+ return S_FALSE;
+ UInt64 endPosMax = kHeaderSize;
+
+ for (UInt32 i = 0; i < num; i++)
+ {
+ const UInt32 *p = buf + kHeaderSize + i * kRecordSize;
+ CItem &sb = _items[i];
+ sb.Type = p[0];
+ sb.SubType = p[1];
+ sb.Offset = p[2];
+ sb.Size = p[3];
+ const UInt32 align = p[4];
+ sb.Align = align;
+ if (align > 31)
+ return S_FALSE;
+ if (sb.Offset < kHeaderSize + num * kRecordSize)
+ return S_FALSE;
+ if ((sb.Type & ~MACH_CPU_ARCH_ABI64) >= 0x100 ||
+ (sb.SubType & ~MACH_CPU_SUBTYPE_LIB64) >= 0x100)
+ return S_FALSE;
+
+ const UInt64 endPos = (UInt64)sb.Offset + sb.Size;
+ if (endPosMax < endPos)
+ endPosMax = endPos;
+ }
+ _numItems = num;
+ _phySize = endPosMax;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ try
+ {
+ if (Open2(inStream) != S_OK)
+ return S_FALSE;
+ _stream = inStream;
+ }
+ catch(...) { return S_FALSE; }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _stream.Release();
+ _numItems = 0;
+ _phySize = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _numItems;
+ return S_OK;
+}
+
+namespace NBe {
+
+static const Byte k_Signature[] = {
+ 7, 0xCA, 0xFE, 0xBA, 0xBE, 0, 0, 0,
+ 4, 0xB9, 0xFA, 0xF1, 0x0E };
+
+REGISTER_ARC_I(
+ "Mub", "mub", NULL, 0xE2,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kMultiSignature,
+ NULL)
+
+}
+
+}}
diff --git a/CPP/7zip/Archive/Nsis/NsisDecode.cpp b/CPP/7zip/Archive/Nsis/NsisDecode.cpp
new file mode 100644
index 0000000..044de37
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisDecode.cpp
@@ -0,0 +1,295 @@
+// NsisDecode.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "NsisDecode.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/MethodId.h"
+
+#include "../../Compress/BcjCoder.h"
+
+#define Get32(p) GetUi32(p)
+
+namespace NArchive {
+namespace NNsis {
+
+UInt64 CDecoder::GetInputProcessedSize() const
+{
+ if (_lzmaDecoder)
+ return _lzmaDecoder->GetInputProcessedSize();
+ if (_deflateDecoder)
+ return _deflateDecoder->GetInputProcessedSize();
+ if (_bzDecoder)
+ return _bzDecoder->GetInputProcessedSize();
+ return 0;
+}
+
+
+HRESULT CDecoder::Init(ISequentialInStream *inStream, bool &useFilter)
+{
+ useFilter = false;
+
+ if (_decoderInStream)
+ if (Method != _curMethod)
+ Release();
+ _curMethod = Method;
+
+ if (!_codecInStream)
+ {
+ switch ((int)Method)
+ {
+ // case NMethodType::kCopy: return E_NOTIMPL;
+ case NMethodType::kDeflate:
+ _deflateDecoder = new NCompress::NDeflate::NDecoder::CCOMCoder();
+ _codecInStream = _deflateDecoder;
+ break;
+ case NMethodType::kBZip2:
+ _bzDecoder = new NCompress::NBZip2::CNsisDecoder();
+ _codecInStream = _bzDecoder;
+ break;
+ case NMethodType::kLZMA:
+ _lzmaDecoder = new NCompress::NLzma::CDecoder();
+ _codecInStream = _lzmaDecoder;
+ break;
+ default: return E_NOTIMPL;
+ }
+ }
+
+ if (Method == NMethodType::kDeflate)
+ _deflateDecoder->SetNsisMode(IsNsisDeflate);
+
+ if (FilterFlag)
+ {
+ Byte flag;
+ RINOK(ReadStream_FALSE(inStream, &flag, 1))
+ if (flag > 1)
+ return E_NOTIMPL;
+ useFilter = (flag != 0);
+ }
+
+ if (!useFilter)
+ _decoderInStream = _codecInStream;
+ else
+ {
+ if (!_filterInStream)
+ {
+ _filter = new CFilterCoder(false);
+ _filterInStream = _filter;
+ _filter->Filter = new NCompress::NBcj::CCoder2(z7_BranchConvSt_X86_Dec);
+ }
+ RINOK(_filter->SetInStream(_codecInStream))
+ _decoderInStream = _filterInStream;
+ }
+
+ if (Method == NMethodType::kLZMA)
+ {
+ const unsigned kPropsSize = LZMA_PROPS_SIZE;
+ Byte props[kPropsSize];
+ RINOK(ReadStream_FALSE(inStream, props, kPropsSize))
+ RINOK(_lzmaDecoder->SetDecoderProperties2((const Byte *)props, kPropsSize))
+ }
+
+ {
+ CMyComPtr<ICompressSetInStream> setInStream;
+ _codecInStream.QueryInterface(IID_ICompressSetInStream, &setInStream);
+ if (!setInStream)
+ return E_NOTIMPL;
+ RINOK(setInStream->SetInStream(inStream))
+ }
+
+ {
+ CMyComPtr<ICompressSetOutStreamSize> setOutStreamSize;
+ _codecInStream.QueryInterface(IID_ICompressSetOutStreamSize, &setOutStreamSize);
+ if (!setOutStreamSize)
+ return E_NOTIMPL;
+ RINOK(setOutStreamSize->SetOutStreamSize(NULL))
+ }
+
+ if (useFilter)
+ {
+ RINOK(_filter->SetOutStreamSize(NULL))
+ }
+
+ return S_OK;
+}
+
+
+static const UInt32 kMask_IsCompressed = (UInt32)1 << 31;
+
+
+HRESULT CDecoder::SetToPos(UInt64 pos, ICompressProgressInfo *progress)
+{
+ if (StreamPos > pos)
+ return E_FAIL;
+ const UInt64 inSizeStart = GetInputProcessedSize();
+ UInt64 offset = 0;
+ while (StreamPos < pos)
+ {
+ size_t size = (size_t)MyMin(pos - StreamPos, (UInt64)Buffer.Size());
+ RINOK(Read(Buffer, &size))
+ if (size == 0)
+ return S_FALSE;
+ StreamPos += size;
+ offset += size;
+
+ const UInt64 inSize = GetInputProcessedSize() - inSizeStart;
+ RINOK(progress->SetRatioInfo(&inSize, &offset))
+ }
+ return S_OK;
+}
+
+
+HRESULT CDecoder::Decode(CByteBuffer *outBuf, bool unpackSizeDefined, UInt32 unpackSize,
+ ISequentialOutStream *realOutStream, ICompressProgressInfo *progress,
+ UInt32 &packSizeRes, UInt32 &unpackSizeRes)
+{
+ CLimitedSequentialInStream *limitedStreamSpec = NULL;
+ CMyComPtr<ISequentialInStream> limitedStream;
+ packSizeRes = 0;
+ unpackSizeRes = 0;
+
+ if (Solid)
+ {
+ Byte temp[4];
+ size_t processedSize = 4;
+ RINOK(Read(temp, &processedSize))
+ StreamPos += processedSize;
+ if (processedSize != 4)
+ return S_FALSE;
+ UInt32 size = Get32(temp);
+ if (unpackSizeDefined && size != unpackSize)
+ return S_FALSE;
+ unpackSize = size;
+ unpackSizeDefined = true;
+ }
+ else
+ {
+ Byte temp[4];
+ {
+ size_t processedSize = 4;
+ RINOK(ReadStream(InputStream, temp, &processedSize))
+ StreamPos += processedSize;
+ if (processedSize != 4)
+ return S_FALSE;
+ }
+ UInt32 size = Get32(temp);
+
+ if ((size & kMask_IsCompressed) == 0)
+ {
+ if (unpackSizeDefined && size != unpackSize)
+ return S_FALSE;
+ packSizeRes = size;
+ if (outBuf)
+ outBuf->Alloc(size);
+
+ UInt64 offset = 0;
+
+ while (size > 0)
+ {
+ UInt32 curSize = (UInt32)MyMin((size_t)size, Buffer.Size());
+ UInt32 processedSize;
+ RINOK(InputStream->Read(Buffer, curSize, &processedSize))
+ if (processedSize == 0)
+ return S_FALSE;
+ if (outBuf)
+ memcpy((Byte *)*outBuf + (size_t)offset, Buffer, processedSize);
+ offset += processedSize;
+ size -= processedSize;
+ StreamPos += processedSize;
+ unpackSizeRes += processedSize;
+ if (realOutStream)
+ RINOK(WriteStream(realOutStream, Buffer, processedSize))
+ RINOK(progress->SetRatioInfo(&offset, &offset))
+ }
+
+ return S_OK;
+ }
+
+ size &= ~kMask_IsCompressed;
+ packSizeRes = size;
+ limitedStreamSpec = new CLimitedSequentialInStream;
+ limitedStream = limitedStreamSpec;
+ limitedStreamSpec->SetStream(InputStream);
+ limitedStreamSpec->Init(size);
+ {
+ bool useFilter;
+ RINOK(Init(limitedStream, useFilter))
+ }
+ }
+
+ if (outBuf)
+ {
+ if (unpackSizeDefined)
+ outBuf->Alloc(unpackSize);
+ }
+
+ const UInt64 inSizeStart = GetInputProcessedSize();
+
+ // we don't allow files larger than 4 GB;
+ if (!unpackSizeDefined)
+ unpackSize = 0xFFFFFFFF;
+ UInt32 offset = 0;
+
+ HRESULT res = S_OK;
+
+ for (;;)
+ {
+ size_t rem = unpackSize - offset;
+ if (rem == 0)
+ break;
+ size_t size = Buffer.Size();
+ if (size > rem)
+ size = rem;
+ RINOK(Read(Buffer, &size))
+ if (size == 0)
+ {
+ if (unpackSizeDefined)
+ res = S_FALSE;
+ break;
+ }
+
+ if (outBuf)
+ {
+ size_t nextSize = offset + size;
+ if (outBuf->Size() < nextSize)
+ {
+ {
+ const size_t nextSize2 = outBuf->Size() * 2;
+ if (nextSize < nextSize2)
+ nextSize = nextSize2;
+ }
+ outBuf->ChangeSize_KeepData(nextSize, offset);
+ }
+ memcpy((Byte *)*outBuf + (size_t)offset, Buffer, size);
+ }
+
+ StreamPos += size;
+ offset += (UInt32)size;
+
+ const UInt64 inSize = GetInputProcessedSize() - inSizeStart;
+
+ if (Solid)
+ packSizeRes = (UInt32)inSize;
+ unpackSizeRes += (UInt32)size;
+
+ UInt64 outSize = offset;
+ RINOK(progress->SetRatioInfo(&inSize, &outSize))
+ if (realOutStream)
+ {
+ res = WriteStream(realOutStream, Buffer, size);
+ if (res != S_OK)
+ break;
+ }
+ }
+
+ if (outBuf && offset != outBuf->Size())
+ outBuf->ChangeSize_KeepData(offset, offset);
+
+ return res;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Nsis/NsisDecode.h b/CPP/7zip/Archive/Nsis/NsisDecode.h
new file mode 100644
index 0000000..1d08d01
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisDecode.h
@@ -0,0 +1,97 @@
+// NsisDecode.h
+
+#ifndef ZIP7_INC_NSIS_DECODE_H
+#define ZIP7_INC_NSIS_DECODE_H
+
+#include "../../../Common/MyBuffer.h"
+
+#include "../../Common/FilterCoder.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/BZip2Decoder.h"
+#include "../../Compress/DeflateDecoder.h"
+#include "../../Compress/LzmaDecoder.h"
+
+namespace NArchive {
+namespace NNsis {
+
+namespace NMethodType
+{
+ enum EEnum
+ {
+ kCopy,
+ kDeflate,
+ kBZip2,
+ kLZMA
+ };
+}
+
+/* 7-Zip installers 4.38 - 9.08 used modified version of NSIS that
+ supported BCJ filter for better compression ratio.
+ We support such modified NSIS archives. */
+
+class CDecoder
+{
+ NMethodType::EEnum _curMethod; // method of created decoder
+
+ CFilterCoder *_filter;
+ CMyComPtr<ISequentialInStream> _filterInStream;
+ CMyComPtr<ISequentialInStream> _codecInStream;
+ CMyComPtr<ISequentialInStream> _decoderInStream;
+
+ NCompress::NBZip2::CNsisDecoder *_bzDecoder;
+ NCompress::NDeflate::NDecoder::CCOMCoder *_deflateDecoder;
+ NCompress::NLzma::CDecoder *_lzmaDecoder;
+
+public:
+ CMyComPtr<IInStream> InputStream; // for non-solid
+ UInt64 StreamPos; // the pos in unpacked for solid, the pos in Packed for non-solid
+
+ NMethodType::EEnum Method;
+ bool FilterFlag;
+ bool Solid;
+ bool IsNsisDeflate;
+
+ CByteBuffer Buffer; // temp buf
+
+ CDecoder():
+ FilterFlag(false),
+ Solid(true),
+ IsNsisDeflate(true)
+ {
+ _bzDecoder = NULL;
+ _deflateDecoder = NULL;
+ _lzmaDecoder = NULL;
+ }
+
+ void Release()
+ {
+ _filterInStream.Release();
+ _codecInStream.Release();
+ _decoderInStream.Release();
+ InputStream.Release();
+
+ _bzDecoder = NULL;
+ _deflateDecoder = NULL;
+ _lzmaDecoder = NULL;
+ }
+
+ UInt64 GetInputProcessedSize() const;
+
+ HRESULT Init(ISequentialInStream *inStream, bool &useFilter);
+
+ HRESULT Read(void *data, size_t *processedSize)
+ {
+ return ReadStream(_decoderInStream, data, processedSize);
+ }
+
+
+ HRESULT SetToPos(UInt64 pos, ICompressProgressInfo *progress); // for solid
+ HRESULT Decode(CByteBuffer *outBuf, bool unpackSizeDefined, UInt32 unpackSize,
+ ISequentialOutStream *realOutStream, ICompressProgressInfo *progress,
+ UInt32 &packSizeRes, UInt32 &unpackSizeRes);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Nsis/NsisHandler.cpp b/CPP/7zip/Archive/Nsis/NsisHandler.cpp
new file mode 100644
index 0000000..7a512b7
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisHandler.cpp
@@ -0,0 +1,694 @@
+// NSisHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "NsisHandler.h"
+
+#define Get32(p) GetUi32(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NNsis {
+
+#define kBcjMethod "BCJ"
+#define kUnknownMethod "Unknown"
+
+static const char * const kMethods[] =
+{
+ "Copy"
+ , "Deflate"
+ , "BZip2"
+ , "LZMA"
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidAttrib,
+ kpidMethod,
+ kpidSolid,
+ kpidOffset
+};
+
+static const Byte kArcProps[] =
+{
+ kpidMethod,
+ kpidSolid,
+ kpidBit64,
+ kpidHeadersSize,
+ kpidEmbeddedStubSize,
+ kpidSubType
+ // kpidCodePage
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+
+static void AddDictProp(AString &s, UInt32 val)
+{
+ for (unsigned i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == val)
+ {
+ s.Add_UInt32(i);
+ return;
+ }
+ char c = 'b';
+ if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
+ else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
+ s.Add_UInt32(val);
+ s += c;
+}
+
+static AString GetMethod(bool useFilter, NMethodType::EEnum method, UInt32 dict)
+{
+ AString s;
+ if (useFilter)
+ {
+ s += kBcjMethod;
+ s.Add_Space();
+ }
+ s += ((unsigned)method < Z7_ARRAY_SIZE(kMethods)) ? kMethods[(unsigned)method] : kUnknownMethod;
+ if (method == NMethodType::kLZMA)
+ {
+ s += ':';
+ AddDictProp(s, dict);
+ }
+ return s;
+}
+
+/*
+AString CHandler::GetMethod(NMethodType::EEnum method, bool useItemFilter, UInt32 dictionary) const
+{
+ AString s;
+ if (_archive.IsSolid && _archive.UseFilter || !_archive.IsSolid && useItemFilter)
+ {
+ s += kBcjMethod;
+ s.Add_Space();
+ }
+ s += (method < Z7_ARRAY_SIZE(kMethods)) ? kMethods[method] : kUnknownMethod;
+ if (method == NMethodType::kLZMA)
+ {
+ s += ':';
+ s += GetStringForSizeValue(_archive.IsSolid ? _archive.DictionarySize: dictionary);
+ }
+ return s;
+}
+*/
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ // case kpidCodePage: if (_archive.IsUnicode) prop = "UTF-16"; break;
+ case kpidSubType:
+ {
+ AString s (_archive.GetFormatDescription());
+ if (!_archive.IsInstaller)
+ {
+ s.Add_Space_if_NotEmpty();
+ s += "(Uninstall)";
+ }
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidBit64: if (_archive.Is64Bit) prop = true; break;
+ case kpidMethod: prop = _methodString; break;
+ case kpidSolid: prop = _archive.IsSolid; break;
+ case kpidOffset: prop = _archive.StartOffset; break;
+ case kpidPhySize: prop = (UInt64)((UInt64)_archive.ExeStub.Size() + _archive.FirstHeader.ArcSize); break;
+ case kpidEmbeddedStubSize: prop = (UInt64)_archive.ExeStub.Size(); break;
+ case kpidHeadersSize: prop = _archive.FirstHeader.HeaderSize; break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_archive.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_archive.IsTruncated()) v |= kpv_ErrorFlags_UnexpectedEnd;
+ prop = v;
+ break;
+ }
+
+ case kpidName:
+ {
+ AString s;
+
+ #ifdef NSIS_SCRIPT
+ if (!_archive.Name.IsEmpty())
+ s = _archive.Name;
+ if (!_archive.IsInstaller)
+ {
+ if (!s.IsEmpty())
+ s.Add_Dot();
+ s += "Uninstall";
+ }
+ #endif
+
+ if (s.IsEmpty())
+ s = _archive.IsInstaller ? "Install" : "Uninstall";
+ s += (_archive.ExeStub.Size() == 0) ? ".nsis" : ".exe";
+
+ prop = _archive.ConvertToUnicode(s);
+ break;
+ }
+
+ #ifdef NSIS_SCRIPT
+ case kpidShortComment:
+ {
+ if (!_archive.BrandingText.IsEmpty())
+ prop = _archive.ConvertToUnicode(_archive.BrandingText);
+ break;
+ }
+ #endif
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ {
+ if (_archive.Open(stream, maxCheckStartPosition) != S_OK)
+ return S_FALSE;
+ {
+ UInt32 dict = _archive.DictionarySize;
+ if (!_archive.IsSolid)
+ {
+ FOR_VECTOR (i, _archive.Items)
+ {
+ const CItem &item = _archive.Items[i];
+ if (item.DictionarySize > dict)
+ dict = item.DictionarySize;
+ }
+ }
+ _methodString = GetMethod(_archive.UseFilter, _archive.Method, dict);
+ }
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _archive.Clear();
+ _archive.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _archive.Items.Size()
+ #ifdef NSIS_SCRIPT
+ + 1 + _archive.LicenseFiles.Size()
+ #endif
+ ;
+ return S_OK;
+}
+
+bool CHandler::GetUncompressedSize(unsigned index, UInt32 &size) const
+{
+ size = 0;
+ const CItem &item = _archive.Items[index];
+ if (item.Size_Defined)
+ size = item.Size;
+ else if (_archive.IsSolid && item.EstimatedSize_Defined)
+ size = item.EstimatedSize;
+ else if (!item.IsEmptyFile)
+ return false;
+ return true;
+}
+
+bool CHandler::GetCompressedSize(unsigned index, UInt32 &size) const
+{
+ size = 0;
+ const CItem &item = _archive.Items[index];
+ if (item.CompressedSize_Defined)
+ size = item.CompressedSize;
+ else
+ {
+ if (_archive.IsSolid)
+ {
+ if (index == 0)
+ size = _archive.FirstHeader.GetDataSize();
+ else
+ return false;
+ }
+ else
+ {
+ if (!item.IsCompressed)
+ size = item.Size;
+ else
+ return false;
+ }
+ }
+ return true;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ #ifdef NSIS_SCRIPT
+ if (index >= (UInt32)_archive.Items.Size())
+ {
+ if (index == (UInt32)_archive.Items.Size())
+ {
+ switch (propID)
+ {
+ case kpidPath: prop = "[NSIS].nsi"; break;
+ case kpidSize:
+ case kpidPackSize: prop = (UInt64)_archive.Script.Len(); break;
+ case kpidSolid: prop = false; break;
+ }
+ }
+ else
+ {
+ const CLicenseFile &lic = _archive.LicenseFiles[index - (_archive.Items.Size() + 1)];
+ switch (propID)
+ {
+ case kpidPath: prop = lic.Name; break;
+ case kpidSize:
+ case kpidPackSize: prop = (UInt64)lic.Size; break;
+ case kpidSolid: prop = false; break;
+ }
+ }
+ }
+ else
+ #endif
+ {
+ const CItem &item = _archive.Items[index];
+ switch (propID)
+ {
+ case kpidOffset: prop = item.Pos; break;
+ case kpidPath:
+ {
+ UString s = NItemName::WinPathToOsPath(_archive.GetReducedName(index));
+ if (!s.IsEmpty())
+ prop = (const wchar_t *)s;
+ break;
+ }
+ case kpidSize:
+ {
+ UInt32 size;
+ if (GetUncompressedSize(index, size))
+ prop = (UInt64)size;
+ break;
+ }
+ case kpidPackSize:
+ {
+ UInt32 size;
+ if (GetCompressedSize(index, size))
+ prop = (UInt64)size;
+ break;
+ }
+ case kpidMTime:
+ {
+ if (item.MTime.dwHighDateTime > 0x01000000 &&
+ item.MTime.dwHighDateTime < 0xFF000000)
+ prop = item.MTime;
+ break;
+ }
+ case kpidAttrib:
+ {
+ if (item.Attrib_Defined)
+ prop = item.Attrib;
+ break;
+ }
+
+ case kpidMethod:
+ if (_archive.IsSolid)
+ prop = _methodString;
+ else
+ prop = GetMethod(_archive.UseFilter, item.IsCompressed ? _archive.Method :
+ NMethodType::kCopy, item.DictionarySize);
+ break;
+
+ case kpidSolid: prop = _archive.IsSolid; break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+static bool UninstallerPatch(const Byte *p, size_t size, Byte *dest, size_t destSize)
+{
+ for (;;)
+ {
+ if (size < 4)
+ return false;
+ const UInt32 len = Get32(p);
+ if (len == 0)
+ return size == 4;
+ if (size < 8)
+ return false;
+ const UInt32 offs = Get32(p + 4);
+ p += 8;
+ size -= 8;
+ if (size < len || offs > destSize || len > destSize - offs)
+ return false;
+ memcpy(dest + offs, p, len);
+ p += len;
+ size -= len;
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ GetNumberOfItems(&numItems);
+ if (numItems == 0)
+ return S_OK;
+
+ UInt64 totalSize = 0;
+ UInt64 solidPosMax = 0;
+
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = (allFilesMode ? i : indices[i]);
+
+ #ifdef NSIS_SCRIPT
+ if (index >= _archive.Items.Size())
+ {
+ if (index == _archive.Items.Size())
+ totalSize += _archive.Script.Len();
+ else
+ totalSize += _archive.LicenseFiles[index - (_archive.Items.Size() + 1)].Size;
+ }
+ else
+ #endif
+ {
+ UInt32 size;
+ if (_archive.IsSolid)
+ {
+ GetUncompressedSize(index, size);
+ UInt64 pos = (UInt64)_archive.GetPosOfSolidItem(index) + size;
+ if (solidPosMax < pos)
+ solidPosMax = pos;
+ }
+ else
+ {
+ GetCompressedSize(index, size);
+ totalSize += size;
+ }
+ }
+ }
+
+ extractCallback->SetTotal(totalSize + solidPosMax);
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, !_archive.IsSolid);
+
+ if (_archive.IsSolid)
+ {
+ RINOK(_archive.SeekTo_DataStreamOffset())
+ RINOK(_archive.InitDecoder())
+ _archive.Decoder.StreamPos = 0;
+ }
+
+ /* We use tempBuf for solid archives, if there is duplicate item.
+ We don't know uncompressed size for non-solid archives, so we can't
+ allocate exact buffer.
+ We use tempBuf also for first part (EXE stub) of unistall.exe
+ and tempBuf2 is used for second part (NSIS script). */
+
+ CByteBuffer tempBuf;
+ CByteBuffer tempBuf2;
+
+ /* tempPos is pos in uncompressed stream of previous item for solid archive, that
+ was written to tempBuf */
+ UInt64 tempPos = (UInt64)(Int64)-1;
+
+ /* prevPos is pos in uncompressed stream of previous item for solid archive.
+ It's used for test mode (where we don't need to test same file second time */
+ UInt64 prevPos = (UInt64)(Int64)-1;
+
+ // if there is error in solid archive, we show error for all subsequent files
+ bool solidDataError = false;
+
+ UInt64 curTotalPacked = 0, curTotalUnpacked = 0;
+ UInt32 curPacked = 0;
+ UInt64 curUnpacked = 0;
+
+ for (i = 0; i < numItems; i++,
+ curTotalPacked += curPacked,
+ curTotalUnpacked += curUnpacked)
+ {
+ lps->InSize = curTotalPacked;
+ lps->OutSize = curTotalUnpacked;
+ if (_archive.IsSolid)
+ lps->OutSize += _archive.Decoder.StreamPos;
+
+ curPacked = 0;
+ curUnpacked = 0;
+ RINOK(lps->SetCur())
+
+ // RINOK(extractCallback->SetCompleted(¤tTotalSize))
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ bool dataError = false;
+
+ #ifdef NSIS_SCRIPT
+ if (index >= (UInt32)_archive.Items.Size())
+ {
+ const void *data;
+ size_t size;
+ if (index == (UInt32)_archive.Items.Size())
+ {
+ data = (const Byte *)_archive.Script;
+ size = _archive.Script.Len();
+ }
+ else
+ {
+ CLicenseFile &lic = _archive.LicenseFiles[index - (_archive.Items.Size() + 1)];
+ if (lic.Text.Size() != 0)
+ data = lic.Text;
+ else
+ data = _archive._data + lic.Offset;
+ size = lic.Size;
+ }
+ curUnpacked = size;
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (realOutStream)
+ RINOK(WriteStream(realOutStream, data, size))
+ }
+ else
+ #endif
+ {
+ const CItem &item = _archive.Items[index];
+
+ if (!_archive.IsSolid)
+ GetCompressedSize(index, curPacked);
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ dataError = solidDataError;
+
+ bool needDecompress = false;
+
+ if (!item.IsEmptyFile)
+ {
+ needDecompress = !solidDataError;
+ if (needDecompress)
+ {
+ if (testMode && _archive.IsSolid && _archive.GetPosOfSolidItem(index) == prevPos)
+ needDecompress = false;
+ }
+ }
+
+ if (needDecompress)
+ {
+ bool writeToTemp = false;
+ bool readFromTemp = false;
+
+ if (!_archive.IsSolid)
+ {
+ RINOK(_archive.SeekToNonSolidItem(index))
+ }
+ else
+ {
+ UInt64 pos = _archive.GetPosOfSolidItem(index);
+ if (pos < _archive.Decoder.StreamPos)
+ {
+ if (pos != tempPos)
+ solidDataError = dataError = true;
+ readFromTemp = true;
+ }
+ else
+ {
+ HRESULT res = _archive.Decoder.SetToPos(pos, progress);
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ solidDataError = dataError = true;
+ }
+ else if (!testMode && i + 1 < numItems)
+ {
+ const UInt32 next = allFilesMode ? i + 1 : indices[i + 1];
+ if (next < _archive.Items.Size())
+ {
+ // next cannot be IsEmptyFile
+ const UInt64 nextPos = _archive.GetPosOfSolidItem(next);
+ if (nextPos == pos)
+ {
+ writeToTemp = true;
+ tempPos = pos;
+ }
+ }
+ }
+ }
+ prevPos = pos;
+ }
+
+ /* nsis 3.08 can use (PatchSize == 0) for uninstaller without patched section */
+
+ const bool is_PatchedUninstaller = item.Is_PatchedUninstaller();
+
+ if (!dataError)
+ {
+ // UInt32 unpackSize = 0;
+ // bool unpackSize_Defined = false;
+ bool writeToTemp1 = writeToTemp;
+ if (is_PatchedUninstaller)
+ {
+ // unpackSize = item.PatchSize;
+ // unpackSize_Defined = true;
+ if (!readFromTemp)
+ writeToTemp = true;
+ writeToTemp1 = writeToTemp;
+ if (_archive.ExeStub.Size() == 0)
+ {
+ if (writeToTemp1 && !readFromTemp)
+ tempBuf.Free();
+ writeToTemp1 = false;
+ }
+ }
+
+ if (readFromTemp)
+ {
+ if (realOutStream && !is_PatchedUninstaller)
+ RINOK(WriteStream(realOutStream, tempBuf, tempBuf.Size()))
+ }
+ else
+ {
+ UInt32 curUnpacked32 = 0;
+ const HRESULT res = _archive.Decoder.Decode(
+ writeToTemp1 ? &tempBuf : NULL,
+ is_PatchedUninstaller, item.PatchSize,
+ is_PatchedUninstaller ? NULL : (ISequentialOutStream *)realOutStream,
+ progress,
+ curPacked, curUnpacked32);
+ curUnpacked = curUnpacked32;
+ if (_archive.IsSolid)
+ curUnpacked = 0;
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ dataError = true;
+ if (_archive.IsSolid)
+ solidDataError = true;
+ }
+ }
+ }
+
+ if (!dataError && is_PatchedUninstaller)
+ {
+ if (_archive.ExeStub.Size() != 0)
+ {
+ CByteBuffer destBuf = _archive.ExeStub;
+ dataError = !UninstallerPatch(tempBuf, tempBuf.Size(), destBuf, destBuf.Size());
+ if (realOutStream)
+ RINOK(WriteStream(realOutStream, destBuf, destBuf.Size()))
+ }
+
+ if (readFromTemp)
+ {
+ if (realOutStream)
+ RINOK(WriteStream(realOutStream, tempBuf2, tempBuf2.Size()))
+ }
+ else
+ {
+ UInt32 curPacked2 = 0;
+ UInt32 curUnpacked2 = 0;
+
+ if (!_archive.IsSolid)
+ {
+ RINOK(_archive.SeekTo(_archive.GetPosOfNonSolidItem(index) + 4 + curPacked ))
+ }
+
+ const HRESULT res = _archive.Decoder.Decode(
+ writeToTemp ? &tempBuf2 : NULL,
+ false, 0,
+ realOutStream,
+ progress,
+ curPacked2, curUnpacked2);
+ curPacked += curPacked2;
+ if (!_archive.IsSolid)
+ curUnpacked += curUnpacked2;
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ dataError = true;
+ if (_archive.IsSolid)
+ solidDataError = true;
+ }
+ }
+ }
+ }
+ }
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(dataError ?
+ NExtract::NOperationResult::kDataError :
+ NExtract::NOperationResult::kOK))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Archive/Nsis/NsisHandler.h b/CPP/7zip/Archive/Nsis/NsisHandler.h
new file mode 100644
index 0000000..bb90bfe
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisHandler.h
@@ -0,0 +1,30 @@
+// NSisHandler.h
+
+#ifndef ZIP7_INC_NSIS_HANDLER_H
+#define ZIP7_INC_NSIS_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../Common/CreateCoder.h"
+
+#include "../IArchive.h"
+
+#include "NsisIn.h"
+
+namespace NArchive {
+namespace NNsis {
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ CInArchive _archive;
+ AString _methodString;
+
+ bool GetUncompressedSize(unsigned index, UInt32 &size) const;
+ bool GetCompressedSize(unsigned index, UInt32 &size) const;
+
+ // AString GetMethod(NMethodType::EEnum method, bool useItemFilter, UInt32 dictionary) const;
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Nsis/NsisIn.cpp b/CPP/7zip/Archive/Nsis/NsisIn.cpp
new file mode 100644
index 0000000..05ebfd0
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisIn.cpp
@@ -0,0 +1,6138 @@
+// NsisIn.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../Common/LimitedStreams.h"
+
+#include "NsisIn.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+// #define NUM_SPEED_TESTS 1000
+
+namespace NArchive {
+namespace NNsis {
+
+static const size_t kInputBufSize = 1 << 20;
+
+const Byte kSignature[kSignatureSize] = NSIS_SIGNATURE;
+static const UInt32 kMask_IsCompressed = (UInt32)1 << 31;
+
+static const unsigned kNumCommandParams = 6;
+static const unsigned kCmdSize = 4 + kNumCommandParams * 4;
+
+#ifdef NSIS_SCRIPT
+#define CR_LF "\x0D\x0A"
+#endif
+
+static const char * const kErrorStr = "$_ERROR_STR_";
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+
+/* There are several versions of NSIS:
+ 1) Original NSIS:
+ NSIS-2 ANSI
+ NSIS-3 ANSI
+ NSIS-3 Unicode
+ 2) NSIS from Jim Park that extends old NSIS-2 to Unicode support:
+ NSIS-Park-(1,2,3) ANSI
+ NSIS-Park-(1,2,3) Unicode
+
+ The command IDs layout is slightly different for different versions.
+ Also there are additional "log" versions of NSIS that support EW_LOG.
+ We use the layout of "NSIS-3 Unicode" without "log" as main layout.
+ And we transfer the command IDs to main layout, if another layout is detected. */
+
+
+enum
+{
+ EW_INVALID_OPCODE,
+ EW_RET, // Return
+ EW_NOP, // Nop, Goto
+ EW_ABORT, // Abort
+ EW_QUIT, // Quit
+ EW_CALL, // Call, InitPluginsDir
+ EW_UPDATETEXT, // DetailPrint
+ EW_SLEEP, // Sleep
+ EW_BRINGTOFRONT, // BringToFront
+ EW_CHDETAILSVIEW, // SetDetailsView
+ EW_SETFILEATTRIBUTES, // SetFileAttributes
+ EW_CREATEDIR, // CreateDirectory, SetOutPath
+ EW_IFFILEEXISTS, // IfFileExists
+ EW_SETFLAG, // SetRebootFlag, ...
+ EW_IFFLAG, // IfAbort, IfSilent, IfErrors, IfRebootFlag
+ EW_GETFLAG, // GetInstDirError, GetErrorLevel
+ EW_RENAME, // Rename
+ EW_GETFULLPATHNAME, // GetFullPathName
+ EW_SEARCHPATH, // SearchPath
+ EW_GETTEMPFILENAME, // GetTempFileName
+ EW_EXTRACTFILE, // File
+ EW_DELETEFILE, // Delete
+ EW_MESSAGEBOX, // MessageBox
+ EW_RMDIR, // RMDir
+ EW_STRLEN, // StrLen
+ EW_ASSIGNVAR, // StrCpy
+ EW_STRCMP, // StrCmp
+ EW_READENVSTR, // ReadEnvStr, ExpandEnvStrings
+ EW_INTCMP, // IntCmp, IntCmpU
+ EW_INTOP, // IntOp
+ EW_INTFMT, // IntFmt/Int64Fmt
+ EW_PUSHPOP, // Push/Pop/Exchange
+ EW_FINDWINDOW, // FindWindow
+ EW_SENDMESSAGE, // SendMessage
+ EW_ISWINDOW, // IsWindow
+ EW_GETDLGITEM, // GetDlgItem
+ EW_SETCTLCOLORS, // SetCtlColors
+ EW_SETBRANDINGIMAGE, // SetBrandingImage / LoadAndSetImage
+ EW_CREATEFONT, // CreateFont
+ EW_SHOWWINDOW, // ShowWindow, EnableWindow, HideWindow
+ EW_SHELLEXEC, // ExecShell
+ EW_EXECUTE, // Exec, ExecWait
+ EW_GETFILETIME, // GetFileTime
+ EW_GETDLLVERSION, // GetDLLVersion
+
+ // EW_GETFONTVERSION, // Park : 2.46.2
+ // EW_GETFONTNAME, // Park : 2.46.3
+
+ EW_REGISTERDLL, // RegDLL, UnRegDLL, CallInstDLL
+ EW_CREATESHORTCUT, // CreateShortCut
+ EW_COPYFILES, // CopyFiles
+ EW_REBOOT, // Reboot
+ EW_WRITEINI, // WriteINIStr, DeleteINISec, DeleteINIStr, FlushINI
+ EW_READINISTR, // ReadINIStr
+ EW_DELREG, // DeleteRegValue, DeleteRegKey
+ EW_WRITEREG, // WriteRegStr, WriteRegExpandStr, WriteRegBin, WriteRegDWORD
+ EW_READREGSTR, // ReadRegStr, ReadRegDWORD
+ EW_REGENUM, // EnumRegKey, EnumRegValue
+ EW_FCLOSE, // FileClose
+ EW_FOPEN, // FileOpen
+ EW_FPUTS, // FileWrite, FileWriteByte
+ EW_FGETS, // FileRead, FileReadByte
+
+ // Park
+ // EW_FPUTWS, // FileWriteUTF16LE, FileWriteWord
+ // EW_FGETWS, // FileReadUTF16LE, FileReadWord
+
+ EW_FSEEK, // FileSeek
+ EW_FINDCLOSE, // FindClose
+ EW_FINDNEXT, // FindNext
+ EW_FINDFIRST, // FindFirst
+ EW_WRITEUNINSTALLER, // WriteUninstaller
+
+ // Park : since 2.46.3 the log is enabled in main Park version
+ // EW_LOG, // LogSet, LogText
+
+ EW_SECTIONSET, // Get*, Set*
+ EW_INSTTYPESET, // InstTypeSetText, InstTypeGetText, SetCurInstType, GetCurInstType
+
+ /*
+ // before v3.06 nsis it was so:
+ // instructions not actually implemented in exehead, but used in compiler.
+ EW_GETLABELADDR, // both of these get converted to EW_ASSIGNVAR
+ EW_GETFUNCTIONADDR,
+ */
+
+ // v3.06 and later it was changed to:
+ EW_GETOSINFO,
+ EW_RESERVEDOPCODE,
+
+ EW_LOCKWINDOW, // LockWindow
+
+ // 2 unicode commands available only in Unicode archive
+ EW_FPUTWS, // FileWriteUTF16LE, FileWriteWord
+ EW_FGETWS, // FileReadUTF16LE, FileReadWord
+
+ /*
+ // since v3.06 the fllowing IDs codes was moved here:
+ // Opcodes listed here are not actually used in exehead. No exehead opcodes should be present after these!
+ EW_GETLABELADDR, // --> EW_ASSIGNVAR
+ EW_GETFUNCTIONADDR, // --> EW_ASSIGNVAR
+ */
+
+ // The following IDs are not IDs in real order.
+ // We just need some IDs to translate eny extended layout to main layout.
+
+ EW_LOG, // LogSet, LogText
+
+ // Park
+ EW_FINDPROC, // FindProc
+
+ EW_GETFONTVERSION, // GetFontVersion
+ EW_GETFONTNAME, // GetFontName
+
+ kNumCmds
+};
+
+
+
+struct CCommandInfo
+{
+ Byte NumParams;
+};
+
+static const CCommandInfo k_Commands[kNumCmds] =
+{
+ { 0 }, // "Invalid" },
+ { 0 }, // Return
+ { 1 }, // Nop, Goto
+ { 1 }, // "Abort" },
+ { 0 }, // "Quit" },
+ { 2 }, // Call
+ { 6 }, // "DetailPrint" }, // 1 param in new versions, 6 in old NSIS versions
+ { 1 }, // "Sleep" },
+ { 0 }, // "BringToFront" },
+ { 2 }, // "SetDetailsView" },
+ { 2 }, // "SetFileAttributes" },
+ { 3 }, // CreateDirectory, SetOutPath
+ { 3 }, // "IfFileExists" },
+ { 3 }, // SetRebootFlag, ...
+ { 4 }, // "If" }, // IfAbort, IfSilent, IfErrors, IfRebootFlag
+ { 2 }, // "Get" }, // GetInstDirError, GetErrorLevel
+ { 4 }, // "Rename" },
+ { 3 }, // "GetFullPathName" },
+ { 2 }, // "SearchPath" },
+ { 2 }, // "GetTempFileName" },
+ { 6 }, // "File"
+ { 2 }, // "Delete" },
+ { 6 }, // "MessageBox" },
+ { 2 }, // "RMDir" },
+ { 2 }, // "StrLen" },
+ { 4 }, // StrCpy, GetCurrentAddress
+ { 5 }, // "StrCmp" },
+ { 3 }, // ReadEnvStr, ExpandEnvStrings
+ { 6 }, // "IntCmp" },
+ { 4 }, // "IntOp" },
+ { 4 }, // "IntFmt" }, EW_INTFMT
+ { 6 }, // Push, Pop, Exch // it must be 3 params. But some multi-command write garbage.
+ { 5 }, // "FindWindow" },
+ { 6 }, // "SendMessage" },
+ { 3 }, // "IsWindow" },
+ { 3 }, // "GetDlgItem" },
+ { 2 }, // "SetCtlColors" },
+ { 4 }, // "SetBrandingImage" } // LoadAndSetImage
+ { 5 }, // "CreateFont" },
+ { 4 }, // ShowWindow, EnableWindow, HideWindow
+ { 6 }, // "ExecShell" },
+ { 3 }, // "Exec" }, // Exec, ExecWait
+ { 3 }, // "GetFileTime" },
+ { 4 }, // "GetDLLVersion" },
+ { 6 }, // RegDLL, UnRegDLL, CallInstDLL // it must be 5 params. But some multi-command write garbage.
+ { 6 }, // "CreateShortCut" },
+ { 4 }, // "CopyFiles" },
+ { 1 }, // "Reboot" },
+ { 5 }, // WriteINIStr, DeleteINISec, DeleteINIStr, FlushINI
+ { 4 }, // "ReadINIStr" },
+ { 5 }, // "DeleteReg" }, // DeleteRegKey, DeleteRegValue
+ { 6 }, // "WriteReg" }, // WriteRegStr, WriteRegExpandStr, WriteRegBin, WriteRegDWORD
+ { 5 }, // "ReadReg" }, // ReadRegStr, ReadRegDWORD
+ { 5 }, // "EnumReg" }, // EnumRegKey, EnumRegValue
+ { 1 }, // "FileClose" },
+ { 4 }, // "FileOpen" },
+ { 3 }, // "FileWrite" }, // FileWrite, FileWriteByte
+ { 4 }, // "FileRead" }, // FileRead, FileReadByte
+ { 4 }, // "FileSeek" },
+ { 1 }, // "FindClose" },
+ { 2 }, // "FindNext" },
+ { 3 }, // "FindFirst" },
+ { 4 }, // "WriteUninstaller" },
+ { 5 }, // "Section" }, // ***
+ { 4 }, // InstTypeSetText, InstTypeGetText, SetCurInstType, GetCurInstType
+
+ // { 6 }, // "GetLabelAddr" }, // before 3.06
+ { 6 }, // "GetOsInfo" }, GetKnownFolderPath, ReadMemory, // v3.06+
+
+ { 2 }, // "GetFunctionAddress" }, // before 3.06
+
+ { 1 }, // "LockWindow" },
+ { 4 }, // "FileWrite" }, // FileWriteUTF16LE, FileWriteWord
+ { 4 }, // "FileRead" }, // FileReadUTF16LE, FileReadWord
+
+ { 2 }, // "Log" }, // LogSet, LogText
+ // Park
+ { 2 }, // "FindProc" },
+ { 2 }, // "GetFontVersion" },
+ { 2 }, // "GetFontName" }
+};
+
+#ifdef NSIS_SCRIPT
+
+static const char * const k_CommandNames[kNumCmds] =
+{
+ "Invalid"
+ , NULL // Return
+ , NULL // Nop, Goto
+ , "Abort"
+ , "Quit"
+ , NULL // Call
+ , "DetailPrint" // 1 param in new versions, 6 in old NSIS versions
+ , "Sleep"
+ , "BringToFront"
+ , "SetDetailsView"
+ , "SetFileAttributes"
+ , NULL // CreateDirectory, SetOutPath
+ , "IfFileExists"
+ , NULL // SetRebootFlag, ...
+ , "If" // IfAbort, IfSilent, IfErrors, IfRebootFlag
+ , "Get" // GetInstDirError, GetErrorLevel
+ , "Rename"
+ , "GetFullPathName"
+ , "SearchPath"
+ , "GetTempFileName"
+ , NULL // File
+ , "Delete"
+ , "MessageBox"
+ , "RMDir"
+ , "StrLen"
+ , NULL // StrCpy, GetCurrentAddress
+ , "StrCmp"
+ , NULL // ReadEnvStr, ExpandEnvStrings
+ , NULL // IntCmp / Int64Cmp / EW_INTCMP
+ , "IntOp"
+ , NULL // IntFmt / Int64Fmt / EW_INTFMT
+ , NULL // Push, Pop, Exch // it must be 3 params. But some multi-command write garbage.
+ , "FindWindow"
+ , "SendMessage"
+ , "IsWindow"
+ , "GetDlgItem"
+ , "SetCtlColors"
+ , "SetBrandingImage"
+ , "CreateFont"
+ , NULL // ShowWindow, EnableWindow, HideWindow
+ , "ExecShell"
+ , "Exec" // Exec, ExecWait
+ , "GetFileTime"
+ , "GetDLLVersion"
+ , NULL // RegDLL, UnRegDLL, CallInstDLL // it must be 5 params. But some multi-command write garbage.
+ , "CreateShortCut"
+ , "CopyFiles"
+ , "Reboot"
+ , NULL // WriteINIStr, DeleteINISec, DeleteINIStr, FlushINI
+ , "ReadINIStr"
+ , "DeleteReg" // DeleteRegKey, DeleteRegValue
+ , "WriteReg" // WriteRegStr, WriteRegExpandStr, WriteRegBin, WriteRegDWORD
+ , "ReadReg" // ReadRegStr, ReadRegDWORD
+ , "EnumReg" // EnumRegKey, EnumRegValue
+ , "FileClose"
+ , "FileOpen"
+ , "FileWrite" // FileWrite, FileWriteByte
+ , "FileRead" // FileRead, FileReadByte
+ , "FileSeek"
+ , "FindClose"
+ , "FindNext"
+ , "FindFirst"
+ , "WriteUninstaller"
+ , "Section" // ***
+ , NULL // InstTypeSetText, InstTypeGetText, SetCurInstType, GetCurInstType
+
+ , NULL // "GetOsInfo" // , "GetLabelAddr" //
+ , "GetFunctionAddress"
+
+ , "LockWindow"
+ , "FileWrite" // FileWriteUTF16LE, FileWriteWord
+ , "FileRead" // FileReadUTF16LE, FileReadWord
+
+ , "Log" // LogSet, LogText
+
+ // Park
+ , "FindProc"
+ , "GetFontVersion"
+ , "GetFontName"
+};
+
+#endif
+
+/* NSIS can use one name for two CSIDL_*** and CSIDL_COMMON_*** items (CurrentUser / AllUsers)
+ Some NSIS shell names are not identical to WIN32 CSIDL_* names.
+ NSIS doesn't use some CSIDL_* values. But we add name for all CSIDL_ (marked with '+'). */
+
+static const char * const kShellStrings[] =
+{
+ "DESKTOP" // +
+ , "INTERNET" // +
+ , "SMPROGRAMS" // CSIDL_PROGRAMS
+ , "CONTROLS" // +
+ , "PRINTERS" // +
+ , "DOCUMENTS" // CSIDL_PERSONAL
+ , "FAVORITES" // CSIDL_FAVORITES
+ , "SMSTARTUP" // CSIDL_STARTUP
+ , "RECENT" // CSIDL_RECENT
+ , "SENDTO" // CSIDL_SENDTO
+ , "BITBUCKET" // +
+ , "STARTMENU"
+ , NULL // CSIDL_MYDOCUMENTS = CSIDL_PERSONAL
+ , "MUSIC" // CSIDL_MYMUSIC
+ , "VIDEOS" // CSIDL_MYVIDEO
+ , NULL
+ , "DESKTOP" // CSIDL_DESKTOPDIRECTORY
+ , "DRIVES" // +
+ , "NETWORK" // +
+ , "NETHOOD"
+ , "FONTS"
+ , "TEMPLATES"
+ , "STARTMENU" // CSIDL_COMMON_STARTMENU
+ , "SMPROGRAMS" // CSIDL_COMMON_PROGRAMS
+ , "SMSTARTUP" // CSIDL_COMMON_STARTUP
+ , "DESKTOP" // CSIDL_COMMON_DESKTOPDIRECTORY
+ , "APPDATA" // CSIDL_APPDATA !!! "QUICKLAUNCH"
+ , "PRINTHOOD"
+ , "LOCALAPPDATA"
+ , "ALTSTARTUP"
+ , "ALTSTARTUP" // CSIDL_COMMON_ALTSTARTUP
+ , "FAVORITES" // CSIDL_COMMON_FAVORITES
+ , "INTERNET_CACHE"
+ , "COOKIES"
+ , "HISTORY"
+ , "APPDATA" // CSIDL_COMMON_APPDATA
+ , "WINDIR"
+ , "SYSDIR"
+ , "PROGRAM_FILES" // +
+ , "PICTURES" // CSIDL_MYPICTURES
+ , "PROFILE"
+ , "SYSTEMX86" // +
+ , "PROGRAM_FILESX86" // +
+ , "PROGRAM_FILES_COMMON" // +
+ , "PROGRAM_FILES_COMMONX8" // + CSIDL_PROGRAM_FILES_COMMONX86
+ , "TEMPLATES" // CSIDL_COMMON_TEMPLATES
+ , "DOCUMENTS" // CSIDL_COMMON_DOCUMENTS
+ , "ADMINTOOLS" // CSIDL_COMMON_ADMINTOOLS
+ , "ADMINTOOLS" // CSIDL_ADMINTOOLS
+ , "CONNECTIONS" // +
+ , NULL
+ , NULL
+ , NULL
+ , "MUSIC" // CSIDL_COMMON_MUSIC
+ , "PICTURES" // CSIDL_COMMON_PICTURES
+ , "VIDEOS" // CSIDL_COMMON_VIDEO
+ , "RESOURCES"
+ , "RESOURCES_LOCALIZED"
+ , "COMMON_OEM_LINKS" // +
+ , "CDBURN_AREA"
+ , NULL // unused
+ , "COMPUTERSNEARME" // +
+};
+
+
+static inline void UIntToString(AString &s, UInt32 v)
+{
+ s.Add_UInt32(v);
+}
+
+#ifdef NSIS_SCRIPT
+
+void CInArchive::Add_UInt(UInt32 v)
+{
+ char sz[16];
+ ConvertUInt32ToString(v, sz);
+ Script += sz;
+}
+
+static void Add_SignedInt(CDynLimBuf &s, Int32 v)
+{
+ char sz[32];
+ ConvertInt64ToString(v, sz);
+ s += sz;
+}
+
+static void Add_Hex(CDynLimBuf &s, UInt32 v)
+{
+ char sz[16];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt32ToHex(v, sz + 2);
+ s += sz;
+}
+
+static UInt32 GetUi16Str_Len(const Byte *p)
+{
+ const Byte *pp = p;
+ for (; *pp != 0 || *(pp + 1) != 0; pp += 2);
+ return (UInt32)((pp - p) >> 1);
+}
+
+void CInArchive::AddLicense(UInt32 param, Int32 langID)
+{
+ Space();
+ if (param >= NumStringChars ||
+ param + 1 >= NumStringChars)
+ {
+ Script += kErrorStr;
+ return;
+ }
+ strUsed[param] = 1;
+
+ const UInt32 start = _stringsPos + (IsUnicode ? param * 2 : param);
+ const UInt32 offset = start + (IsUnicode ? 2 : 1);
+ {
+ FOR_VECTOR (i, LicenseFiles)
+ {
+ const CLicenseFile &lic = LicenseFiles[i];
+ if (offset == lic.Offset)
+ {
+ Script += lic.Name;
+ return;
+ }
+ }
+ }
+ AString fileName ("[LICENSE]");
+ if (langID >= 0)
+ {
+ fileName += "\\license-";
+ // LangId_To_String(fileName, langID);
+ UIntToString(fileName, (UInt32)langID);
+ }
+ else if (++_numRootLicenses > 1)
+ {
+ fileName.Add_Minus();
+ UIntToString(fileName, _numRootLicenses);
+ }
+ const Byte *sz = (_data + start);
+ const unsigned marker = IsUnicode ? Get16(sz) : *sz;
+ const bool isRTF = (marker == 2);
+ fileName += isRTF ? ".rtf" : ".txt"; // if (*sz == 1) it's text;
+ Script += fileName;
+
+ CLicenseFile &lic = LicenseFiles.AddNew();
+ lic.Name = fileName;
+ lic.Offset = offset;
+ if (!IsUnicode)
+ lic.Size = (UInt32)strlen((const char *)sz + 1);
+ else
+ {
+ sz += 2;
+ const UInt32 len = GetUi16Str_Len(sz);
+ lic.Size = len * 2;
+ if (isRTF)
+ {
+ lic.Text.Alloc((size_t)len);
+ for (UInt32 i = 0; i < len; i++, sz += 2)
+ {
+ unsigned c = Get16(sz);
+ if (c >= 256)
+ c = '?';
+ lic.Text[i] = (Byte)(c);
+ }
+ lic.Size = len;
+ lic.Offset = 0;
+ }
+ }
+}
+
+#endif
+
+
+#ifdef NSIS_SCRIPT
+#define Z7_NSIS_WIN_GENERIC_READ ((UInt32)1 << 31)
+#endif
+#define Z7_NSIS_WIN_GENERIC_WRITE ((UInt32)1 << 30)
+#ifdef NSIS_SCRIPT
+#define Z7_NSIS_WIN_GENERIC_EXECUTE ((UInt32)1 << 29)
+#define Z7_NSIS_WIN_GENERIC_ALL ((UInt32)1 << 28)
+#endif
+
+#ifdef NSIS_SCRIPT
+#define Z7_NSIS_WIN_CREATE_NEW 1
+#endif
+#define Z7_NSIS_WIN_CREATE_ALWAYS 2
+#ifdef NSIS_SCRIPT
+#define Z7_NSIS_WIN_OPEN_EXISTING 3
+#define Z7_NSIS_WIN_OPEN_ALWAYS 4
+#define Z7_NSIS_WIN_TRUNCATE_EXISTING 5
+#endif
+
+
+// #define kVar_CMDLINE 20
+#define kVar_INSTDIR 21
+#define kVar_OUTDIR 22
+#define kVar_EXEDIR 23
+// #define kVar_LANGUAGE 24
+#define kVar_TEMP 25
+#define kVar_PLUGINSDIR 26
+#define kVar_EXEPATH 27 // NSIS 2.26+
+// #define kVar_EXEFILE 28 // NSIS 2.26+
+
+#define kVar_HWNDPARENT_225 27
+#ifdef NSIS_SCRIPT
+#define kVar_HWNDPARENT 29
+#endif
+
+// #define kVar__CLICK 30
+#define kVar_Spec_OUTDIR_225 29 // NSIS 2.04 - 2.25
+#define kVar_Spec_OUTDIR 31 // NSIS 2.26+
+
+
+static const char * const kVarStrings[] =
+{
+ "CMDLINE"
+ , "INSTDIR"
+ , "OUTDIR"
+ , "EXEDIR"
+ , "LANGUAGE"
+ , "TEMP"
+ , "PLUGINSDIR"
+ , "EXEPATH" // NSIS 2.26+
+ , "EXEFILE" // NSIS 2.26+
+ , "HWNDPARENT"
+ , "_CLICK" // is set from page->clicknext
+ , "_OUTDIR" // NSIS 2.04+
+};
+
+static const unsigned kNumInternalVars = 20 + Z7_ARRAY_SIZE(kVarStrings);
+
+#define GET_NUM_INTERNAL_VARS (IsNsis200 ? kNumInternalVars - 3 : IsNsis225 ? kNumInternalVars - 2 : kNumInternalVars)
+
+void CInArchive::GetVar2(AString &res, UInt32 index)
+{
+ if (index < 20)
+ {
+ if (index >= 10)
+ {
+ res += 'R';
+ index -= 10;
+ }
+ UIntToString(res, index);
+ }
+ else
+ {
+ unsigned numInternalVars = GET_NUM_INTERNAL_VARS;
+ if (index < numInternalVars)
+ {
+ if (IsNsis225 && index >= kVar_EXEPATH)
+ index += 2;
+ res += kVarStrings[index - 20];
+ }
+ else
+ {
+ res += '_';
+ UIntToString(res, index - numInternalVars);
+ res += '_';
+ }
+ }
+}
+
+void CInArchive::GetVar(AString &res, UInt32 index)
+{
+ res += '$';
+ GetVar2(res, index);
+}
+
+#ifdef NSIS_SCRIPT
+
+void CInArchive::Add_Var(UInt32 index)
+{
+ _tempString_for_GetVar.Empty();
+ GetVar(_tempString_for_GetVar, index);
+ Script += _tempString_for_GetVar;
+}
+
+void CInArchive::AddParam_Var(UInt32 index)
+{
+ Space();
+ Add_Var(index);
+}
+
+void CInArchive::AddParam_UInt(UInt32 value)
+{
+ Space();
+ Add_UInt(value);
+}
+
+#endif
+
+
+#define NS_CODE_SKIP 252
+#define NS_CODE_VAR 253
+#define NS_CODE_SHELL 254
+// #define NS_CODE_LANG 255
+
+// #define NS_3_CODE_LANG 1
+#define NS_3_CODE_SHELL 2
+#define NS_3_CODE_VAR 3
+#define NS_3_CODE_SKIP 4
+
+#define PARK_CODE_SKIP 0xE000
+#define PARK_CODE_VAR 0xE001
+#define PARK_CODE_SHELL 0xE002
+#define PARK_CODE_LANG 0xE003
+
+#define IS_NS_SPEC_CHAR(c) ((c) >= NS_CODE_SKIP)
+#define IS_PARK_SPEC_CHAR(c) ((c) >= PARK_CODE_SKIP && (c) <= PARK_CODE_LANG)
+
+#define DECODE_NUMBER_FROM_2_CHARS(c0, c1) (((unsigned)(c0) & 0x7F) | (((unsigned)((c1) & 0x7F)) << 7))
+#define CONVERT_NUMBER_NS_3_UNICODE(n) n = ((n & 0x7F) | (((n >> 8) & 0x7F) << 7))
+#define CONVERT_NUMBER_PARK(n) n &= 0x7FFF
+
+
+static bool AreStringsEqual_16and8(const Byte *p16, const char *p8)
+{
+ for (;;)
+ {
+ unsigned c16 = Get16(p16); p16 += 2;
+ unsigned c = (Byte)(*p8++);
+ if (c16 != c)
+ return false;
+ if (c == 0)
+ return true;
+ }
+}
+
+void CInArchive::GetShellString(AString &s, unsigned index1, unsigned index2)
+{
+ // zeros are not allowed here.
+ // if (index1 == 0 || index2 == 0) throw 333;
+
+ if ((index1 & 0x80) != 0)
+ {
+ unsigned offset = (index1 & 0x3F);
+
+ /* NSIS reads registry string:
+ keyName = HKLM Software\\Microsoft\\Windows\\CurrentVersion
+ mask = KEY_WOW64_64KEY, If 64-bit flag in index1 is set
+ valueName = string(offset)
+ If registry reading is failed, NSIS uses second parameter (index2)
+ to read string. The recursion is possible in that case in NSIS.
+ We don't parse index2 string. We only set strUsed status for that
+ string (but without recursion). */
+
+ if (offset >= NumStringChars)
+ {
+ s += kErrorStr;
+ return;
+ }
+
+ #ifdef NSIS_SCRIPT
+ strUsed[offset] = 1;
+ if (index2 < NumStringChars)
+ strUsed[index2] = 1;
+ #endif
+
+ const Byte *p = (const Byte *)(_data + _stringsPos);
+ int id = -1;
+ if (IsUnicode)
+ {
+ p += offset * 2;
+ if (AreStringsEqual_16and8(p, "ProgramFilesDir"))
+ id = 0;
+ else if (AreStringsEqual_16and8(p, "CommonFilesDir"))
+ id = 1;
+ }
+ else
+ {
+ p += offset;
+ if (strcmp((const char *)p, "ProgramFilesDir") == 0)
+ id = 0;
+ else if (strcmp((const char *)p, "CommonFilesDir") == 0)
+ id = 1;
+ }
+
+ s += ((id >= 0) ? (id == 0 ? "$PROGRAMFILES" : "$COMMONFILES") :
+ "$_ERROR_UNSUPPORTED_VALUE_REGISTRY_");
+ // s += ((index1 & 0x40) != 0) ? "64" : "32";
+ if ((index1 & 0x40) != 0)
+ s += "64";
+
+ if (id < 0)
+ {
+ s += '(';
+ if (IsUnicode)
+ {
+ for (unsigned i = 0; i < 256; i++)
+ {
+ wchar_t c = Get16(p + i * 2);
+ if (c == 0)
+ break;
+ if (c < 0x80)
+ s += (char)c;
+ }
+ }
+ else
+ s += (const char *)p;
+ s += ')';
+ }
+ return;
+ }
+
+ s += '$';
+ if (index1 < Z7_ARRAY_SIZE(kShellStrings))
+ {
+ const char *sz = kShellStrings[index1];
+ if (sz)
+ {
+ s += sz;
+ return;
+ }
+ }
+ if (index2 < Z7_ARRAY_SIZE(kShellStrings))
+ {
+ const char *sz = kShellStrings[index2];
+ if (sz)
+ {
+ s += sz;
+ return;
+ }
+ }
+ s += "_ERROR_UNSUPPORTED_SHELL_";
+ s += '[';
+ UIntToString(s, index1);
+ s += ',';
+ UIntToString(s, index2);
+ s += ']';
+}
+
+#ifdef NSIS_SCRIPT
+
+void CInArchive::Add_LangStr_Simple(UInt32 id)
+{
+ Script += "LSTR_";
+ Add_UInt(id);
+}
+
+#endif
+
+void CInArchive::Add_LangStr(AString &res, UInt32 id)
+{
+ #ifdef NSIS_SCRIPT
+ langStrIDs.Add(id);
+ #endif
+ res += "$(LSTR_";
+ UIntToString(res, id);
+ res += ')';
+}
+
+void CInArchive::GetNsisString_Raw(const Byte *s)
+{
+ Raw_AString.Empty();
+
+ if (NsisType != k_NsisType_Nsis3)
+ {
+ for (;;)
+ {
+ Byte c = *s++;
+ if (c == 0)
+ return;
+ if (IS_NS_SPEC_CHAR(c))
+ {
+ Byte c0 = *s++;
+ if (c0 == 0)
+ return;
+ if (c != NS_CODE_SKIP)
+ {
+ Byte c1 = *s++;
+ if (c1 == 0)
+ return;
+
+ if (c == NS_CODE_SHELL)
+ GetShellString(Raw_AString, c0, c1);
+ else
+ {
+ unsigned n = DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+ if (c == NS_CODE_VAR)
+ GetVar(Raw_AString, n);
+ else // if (c == NS_CODE_LANG)
+ Add_LangStr(Raw_AString, n);
+ }
+ continue;
+ }
+ c = c0;
+ }
+ Raw_AString += (char)c;
+ }
+ }
+
+ // NSIS-3 ANSI
+ for (;;)
+ {
+ Byte c = *s++;
+ if (c <= NS_3_CODE_SKIP)
+ {
+ if (c == 0)
+ return;
+ Byte c0 = *s++;
+ if (c0 == 0)
+ return;
+ if (c != NS_3_CODE_SKIP)
+ {
+ Byte c1 = *s++;
+ if (c1 == 0)
+ return;
+
+ if (c == NS_3_CODE_SHELL)
+ GetShellString(Raw_AString, c0, c1);
+ else
+ {
+ unsigned n = DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+ if (c == NS_3_CODE_VAR)
+ GetVar(Raw_AString, n);
+ else // if (c == NS_3_CODE_LANG)
+ Add_LangStr(Raw_AString, n);
+ }
+ continue;
+ }
+ c = c0;
+ }
+ Raw_AString += (char)c;
+ }
+}
+
+#ifdef NSIS_SCRIPT
+
+void CInArchive::GetNsisString(AString &res, const Byte *s)
+{
+ for (;;)
+ {
+ Byte c = *s++;
+ if (c == 0)
+ return;
+ if (NsisType != k_NsisType_Nsis3)
+ {
+ if (IS_NS_SPEC_CHAR(c))
+ {
+ Byte c0 = *s++;
+ if (c0 == 0)
+ return;
+ if (c != NS_CODE_SKIP)
+ {
+ Byte c1 = *s++;
+ if (c1 == 0)
+ return;
+ if (c == NS_CODE_SHELL)
+ GetShellString(res, c0, c1);
+ else
+ {
+ unsigned n = DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+ if (c == NS_CODE_VAR)
+ GetVar(res, n);
+ else // if (c == NS_CODE_LANG)
+ Add_LangStr(res, n);
+ }
+ continue;
+ }
+ c = c0;
+ }
+ }
+ else
+ {
+ // NSIS-3 ANSI
+ if (c <= NS_3_CODE_SKIP)
+ {
+ Byte c0 = *s++;
+ if (c0 == 0)
+ return;
+ if (c0 == 0)
+ break;
+ if (c != NS_3_CODE_SKIP)
+ {
+ Byte c1 = *s++;
+ if (c1 == 0)
+ return;
+ if (c == NS_3_CODE_SHELL)
+ GetShellString(res, c0, c1);
+ else
+ {
+ unsigned n = DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+ if (c == NS_3_CODE_VAR)
+ GetVar(res, n);
+ else // if (c == NS_3_CODE_LANG)
+ Add_LangStr(res, n);
+ }
+ continue;
+ }
+ c = c0;
+ }
+ }
+
+ {
+ const char *e;
+ if (c == 9) e = "$\\t";
+ else if (c == 10) e = "$\\n";
+ else if (c == 13) e = "$\\r";
+ else if (c == '"') e = "$\\\"";
+ else if (c == '$') e = "$$";
+ else
+ {
+ res += (char)c;
+ continue;
+ }
+ res += e;
+ continue;
+ }
+ }
+}
+
+#endif
+
+void CInArchive::GetNsisString_Unicode_Raw(const Byte *p)
+{
+ Raw_UString.Empty();
+
+ if (IsPark())
+ {
+ for (;;)
+ {
+ unsigned c = Get16(p);
+ p += 2;
+ if (c == 0)
+ break;
+ if (c < 0x80)
+ {
+ Raw_UString += (char)c;
+ continue;
+ }
+
+ if (IS_PARK_SPEC_CHAR(c))
+ {
+ unsigned n = Get16(p);
+ p += 2;
+ if (n == 0)
+ break;
+ if (c != PARK_CODE_SKIP)
+ {
+ Raw_AString.Empty();
+ if (c == PARK_CODE_SHELL)
+ GetShellString(Raw_AString, n & 0xFF, n >> 8);
+ else
+ {
+ CONVERT_NUMBER_PARK(n);
+ if (c == PARK_CODE_VAR)
+ GetVar(Raw_AString, n);
+ else // if (c == PARK_CODE_LANG)
+ Add_LangStr(Raw_AString, n);
+ }
+ Raw_UString += Raw_AString.Ptr(); // check it !
+ continue;
+ }
+ c = n;
+ }
+
+ Raw_UString += (wchar_t)c;
+ }
+
+ return;
+ }
+
+ // NSIS-3 Unicode
+ for (;;)
+ {
+ unsigned c = Get16(p);
+ p += 2;
+ if (c > NS_3_CODE_SKIP)
+ {
+ Raw_UString += (wchar_t)c;
+ continue;
+ }
+ if (c == 0)
+ break;
+
+ unsigned n = Get16(p);
+ p += 2;
+ if (n == 0)
+ break;
+ if (c == NS_3_CODE_SKIP)
+ {
+ Raw_UString += (wchar_t)n;
+ continue;
+ }
+
+ Raw_AString.Empty();
+ if (c == NS_3_CODE_SHELL)
+ GetShellString(Raw_AString, n & 0xFF, n >> 8);
+ else
+ {
+ CONVERT_NUMBER_NS_3_UNICODE(n);
+ if (c == NS_3_CODE_VAR)
+ GetVar(Raw_AString, n);
+ else // if (c == NS_3_CODE_LANG)
+ Add_LangStr(Raw_AString, n);
+ }
+ Raw_UString += Raw_AString.Ptr();
+ }
+}
+
+#ifdef NSIS_SCRIPT
+
+static const Byte kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+void CInArchive::GetNsisString_Unicode(AString &res, const Byte *p)
+{
+ for (;;)
+ {
+ unsigned c = Get16(p);
+ p += 2;
+ if (c == 0)
+ break;
+ if (IsPark())
+ {
+ if (IS_PARK_SPEC_CHAR(c))
+ {
+ unsigned n = Get16(p);
+ p += 2;
+ if (n == 0)
+ break;
+ if (c != PARK_CODE_SKIP)
+ {
+ if (c == PARK_CODE_SHELL)
+ GetShellString(res, n & 0xFF, n >> 8);
+ else
+ {
+ CONVERT_NUMBER_PARK(n);
+ if (c == PARK_CODE_VAR)
+ GetVar(res, n);
+ else // if (c == PARK_CODE_LANG)
+ Add_LangStr(res, n);
+ }
+ continue;
+ }
+ c = n;
+ }
+ }
+ else
+ {
+ // NSIS-3 Unicode
+ if (c <= NS_3_CODE_SKIP)
+ {
+ unsigned n = Get16(p);
+ p += 2;
+ if (n == 0)
+ break;
+ if (c != NS_3_CODE_SKIP)
+ {
+ if (c == NS_3_CODE_SHELL)
+ GetShellString(res, n & 0xFF, n >> 8);
+ else
+ {
+ CONVERT_NUMBER_NS_3_UNICODE(n);
+ if (c == NS_3_CODE_VAR)
+ GetVar(res, n);
+ else // if (c == NS_3_CODE_LANG)
+ Add_LangStr(res, n);
+ }
+ continue;
+ }
+ c = n;
+ }
+ }
+
+ if (c < 0x80)
+ {
+ const char *e;
+ if (c == 9) e = "$\\t";
+ else if (c == 10) e = "$\\n";
+ else if (c == 13) e = "$\\r";
+ else if (c == '"') e = "$\\\"";
+ else if (c == '$') e = "$$";
+ else
+ {
+ res += (char)c;
+ continue;
+ }
+ res += e;
+ continue;
+ }
+
+ UInt32 value = c;
+ /*
+ if (value >= 0xD800 && value < 0xE000)
+ {
+ UInt32 c2;
+ if (value >= 0xDC00 || srcPos == srcLen)
+ break;
+ c2 = src[srcPos++];
+ if (c2 < 0xDC00 || c2 >= 0xE000)
+ break;
+ value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
+ }
+ */
+ unsigned numAdds;
+ for (numAdds = 1; numAdds < 5; numAdds++)
+ if (value < (((UInt32)1) << (numAdds * 5 + 6)))
+ break;
+ res += (char)(kUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));
+ do
+ {
+ numAdds--;
+ res += (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));
+ // destPos++;
+ }
+ while (numAdds != 0);
+
+ // AddToUtf8(res, c);
+ }
+}
+
+#endif
+
+void CInArchive::ReadString2_Raw(UInt32 pos)
+{
+ Raw_AString.Empty();
+ Raw_UString.Empty();
+ if ((Int32)pos < 0)
+ Add_LangStr(Raw_AString, (UInt32)-((Int32)pos + 1));
+ else if (pos >= NumStringChars)
+ {
+ Raw_AString += kErrorStr;
+ // UIntToString(Raw_AString, pos);
+ }
+ else
+ {
+ if (IsUnicode)
+ GetNsisString_Unicode_Raw(_data + _stringsPos + pos * 2);
+ else
+ GetNsisString_Raw(_data + _stringsPos + pos);
+ return;
+ }
+ Raw_UString = Raw_AString.Ptr();
+}
+
+bool CInArchive::IsGoodString(UInt32 param) const
+{
+ if (param >= NumStringChars)
+ return false;
+ if (param == 0)
+ return true;
+ const Byte *p = _data + _stringsPos;
+ unsigned c;
+ if (IsUnicode)
+ c = Get16(p + param * 2 - 2);
+ else
+ c = p[param - 1];
+ // some files have '\\' character before string?
+ return (c == 0 || c == '\\');
+}
+
+bool CInArchive::AreTwoParamStringsEqual(UInt32 param1, UInt32 param2) const
+{
+ if (param1 == param2)
+ return true;
+
+ /* NSIS-3.0a1 probably contains bug, so it can use 2 different strings
+ with same content. So we check real string also.
+ Also it's possible to check identical postfix parts of strings. */
+
+ if (param1 >= NumStringChars ||
+ param2 >= NumStringChars)
+ return false;
+
+ const Byte *p = _data + _stringsPos;
+
+ if (IsUnicode)
+ {
+ const Byte *p1 = p + param1 * 2;
+ const Byte *p2 = p + param2 * 2;
+ for (;;)
+ {
+ UInt16 c = Get16(p1);
+ if (c != Get16(p2))
+ return false;
+ if (c == 0)
+ return true;
+ p1 += 2;
+ p2 += 2;
+ }
+ }
+ else
+ {
+ const Byte *p1 = p + param1;
+ const Byte *p2 = p + param2;
+ for (;;)
+ {
+ Byte c = *p1++;
+ if (c != *p2++)
+ return false;
+ if (c == 0)
+ return true;
+ }
+ }
+}
+
+#ifdef NSIS_SCRIPT
+
+UInt32 CInArchive::GetNumUsedVars() const
+{
+ UInt32 numUsedVars = 0;
+ const Byte *data = (const Byte *)_data + _stringsPos;
+ unsigned npi = 0;
+ for (UInt32 i = 0; i < NumStringChars;)
+ {
+ bool process = true;
+ if (npi < noParseStringIndexes.Size() && noParseStringIndexes[npi] == i)
+ {
+ process = false;
+ npi++;
+ }
+
+ if (IsUnicode)
+ {
+ if (IsPark())
+ {
+ for (;;)
+ {
+ unsigned c = Get16(data + i * 2);
+ i++;
+ if (c == 0)
+ break;
+ if (IS_PARK_SPEC_CHAR(c))
+ {
+ UInt32 n = Get16(data + i * 2);
+ i++;
+ if (n == 0)
+ break;
+ if (process && c == PARK_CODE_VAR)
+ {
+ CONVERT_NUMBER_PARK(n);
+ n++;
+ if (numUsedVars < n)
+ numUsedVars = n;
+ }
+ }
+ }
+ }
+ else // NSIS-3 Unicode
+ {
+ for (;;)
+ {
+ unsigned c = Get16(data + i * 2);
+ i++;
+ if (c == 0)
+ break;
+ if (c > NS_3_CODE_SKIP)
+ continue;
+ UInt32 n = Get16(data + i * 2);
+ i++;
+ if (n == 0)
+ break;
+ if (process && c == NS_3_CODE_VAR)
+ {
+ CONVERT_NUMBER_NS_3_UNICODE(n);
+ n++;
+ if (numUsedVars < n)
+ numUsedVars = n;
+ }
+ }
+ }
+ }
+ else // not Unicode (ANSI)
+ {
+ if (NsisType != k_NsisType_Nsis3)
+ {
+ for (;;)
+ {
+ Byte c = data[i++];
+ if (c == 0)
+ break;
+ if (IS_NS_SPEC_CHAR(c))
+ {
+ Byte c0 = data[i++];
+ if (c0 == 0)
+ break;
+ if (c == NS_CODE_SKIP)
+ continue;
+ Byte c1 = data[i++];
+ if (c1 == 0)
+ break;
+ if (process && c == NS_CODE_VAR)
+ {
+ UInt32 n = DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+ n++;
+ if (numUsedVars < n)
+ numUsedVars = n;
+ }
+ }
+ }
+ }
+ else
+ {
+ // NSIS-3 ANSI
+ for (;;)
+ {
+ Byte c = data[i++];
+ if (c == 0)
+ break;
+ if (c > NS_3_CODE_SKIP)
+ continue;
+
+ Byte c0 = data[i++];
+ if (c0 == 0)
+ break;
+ if (c == NS_3_CODE_SKIP)
+ continue;
+ Byte c1 = data[i++];
+ if (c1 == 0)
+ break;
+ if (process && c == NS_3_CODE_VAR)
+ {
+ UInt32 n = DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+ n++;
+ if (numUsedVars < n)
+ numUsedVars = n;
+ }
+ }
+ }
+ }
+ }
+ return numUsedVars;
+}
+
+void CInArchive::ReadString2(AString &s, UInt32 pos)
+{
+ if ((Int32)pos < 0)
+ {
+ Add_LangStr(s, (UInt32)-((Int32)pos + 1));
+ return;
+ }
+
+ if (pos >= NumStringChars)
+ {
+ s += kErrorStr;
+ // UIntToString(s, pos);
+ return;
+ }
+
+ #ifdef NSIS_SCRIPT
+ strUsed[pos] = 1;
+ #endif
+
+ if (IsUnicode)
+ GetNsisString_Unicode(s, _data + _stringsPos + pos * 2);
+ else
+ GetNsisString(s, _data + _stringsPos + pos);
+}
+
+#endif
+
+#ifdef NSIS_SCRIPT
+
+// #define DEL_DIR 1
+#define DEL_RECURSE 2
+#define DEL_REBOOT 4
+// #define DEL_SIMPLE 8
+
+void CInArchive::AddRegRoot(UInt32 val)
+{
+ Space();
+ const char *s;
+ switch (val)
+ {
+ case 0: s = "SHCTX"; break;
+ case 0x80000000: s = "HKCR"; break;
+ case 0x80000001: s = "HKCU"; break;
+ case 0x80000002: s = "HKLM"; break;
+ case 0x80000003: s = "HKU"; break;
+ case 0x80000004: s = "HKPD"; break;
+ case 0x80000005: s = "HKCC"; break;
+ case 0x80000006: s = "HKDD"; break;
+ case 0x80000050: s = "HKPT"; break;
+ case 0x80000060: s = "HKPN"; break;
+ default:
+ // Script += " RRRRR ";
+ // throw 1;
+ Add_Hex(Script, val); return;
+ }
+ Script += s;
+}
+
+static const char * const g_WinAttrib[] =
+{
+ "READONLY"
+ , "HIDDEN"
+ , "SYSTEM"
+ , NULL
+ , "DIRECTORY"
+ , "ARCHIVE"
+ , "DEVICE"
+ , "NORMAL"
+ , "TEMPORARY"
+ , "SPARSE_FILE"
+ , "REPARSE_POINT"
+ , "COMPRESSED"
+ , "OFFLINE"
+ , "NOT_CONTENT_INDEXED"
+ , "ENCRYPTED"
+ , NULL
+ , "VIRTUAL"
+};
+
+#define FLAGS_DELIMITER '|'
+
+static void FlagsToString2(CDynLimBuf &s, const char * const *table, unsigned num, UInt32 flags)
+{
+ bool filled = false;
+ for (unsigned i = 0; i < num; i++)
+ {
+ UInt32 f = (UInt32)1 << i;
+ if ((flags & f) != 0)
+ {
+ const char *name = table[i];
+ if (name)
+ {
+ if (filled)
+ s += FLAGS_DELIMITER;
+ filled = true;
+ s += name;
+ flags &= ~f;
+ }
+ }
+ }
+ if (flags != 0)
+ {
+ if (filled)
+ s += FLAGS_DELIMITER;
+ Add_Hex(s, flags);
+ }
+}
+
+static bool DoesNeedQuotes(const char *s)
+{
+ {
+ char c = s[0];
+ if (c == 0 || c == '#' || c == ';' || (c == '/' && s[1] == '*'))
+ return true;
+ }
+ for (;;)
+ {
+ char c = *s++;
+ if (c == 0)
+ return false;
+ if (c == ' ')
+ return true;
+ }
+}
+
+void CInArchive::Add_QuStr(const AString &s)
+{
+ bool needQuotes = DoesNeedQuotes(s);
+ if (needQuotes)
+ Script += '\"';
+ Script += s;
+ if (needQuotes)
+ Script += '\"';
+}
+
+void CInArchive::SpaceQuStr(const AString &s)
+{
+ Space();
+ Add_QuStr(s);
+}
+
+void CInArchive::AddParam(UInt32 pos)
+{
+ _tempString.Empty();
+ ReadString2(_tempString, pos);
+ SpaceQuStr(_tempString);
+}
+
+void CInArchive::AddParams(const UInt32 *params, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ AddParam(params[i]);
+}
+
+void CInArchive::AddOptionalParam(UInt32 pos)
+{
+ if (pos != 0)
+ AddParam(pos);
+}
+
+static unsigned GetNumParams(const UInt32 *params, unsigned num)
+{
+ for (; num > 0 && params[num - 1] == 0; num--);
+ return num;
+}
+
+void CInArchive::AddOptionalParams(const UInt32 *params, unsigned num)
+{
+ AddParams(params, GetNumParams(params, num));
+}
+
+
+static const UInt32 CMD_REF_Goto = (1 << 0);
+static const UInt32 CMD_REF_Call = (1 << 1);
+static const UInt32 CMD_REF_Pre = (1 << 2);
+static const UInt32 CMD_REF_Show = (1 << 3);
+static const UInt32 CMD_REF_Leave = (1 << 4);
+static const UInt32 CMD_REF_OnFunc = (1 << 5);
+static const UInt32 CMD_REF_Section = (1 << 6);
+static const UInt32 CMD_REF_InitPluginDir = (1 << 7);
+// static const UInt32 CMD_REF_Creator = (1 << 5); // CMD_REF_Pre is used instead
+static const unsigned CMD_REF_OnFunc_NumShifts = 28; // it uses for onFunc too
+static const unsigned CMD_REF_Page_NumShifts = 16; // it uses for onFunc too
+static const UInt32 CMD_REF_Page_Mask = 0x0FFF0000;
+static const UInt32 CMD_REF_OnFunc_Mask = 0xF0000000;
+
+inline bool IsPageFunc(UInt32 flag)
+{
+ return (flag & (CMD_REF_Pre | CMD_REF_Show | CMD_REF_Leave)) != 0;
+}
+
+inline bool IsFunc(UInt32 flag)
+{
+ // return (flag & (CMD_REF_Pre | CMD_REF_Show | CMD_REF_Leave | CMD_REF_OnFunc)) != 0;
+ return (flag & (CMD_REF_Call | CMD_REF_Pre | CMD_REF_Show | CMD_REF_Leave | CMD_REF_OnFunc)) != 0;
+}
+
+inline bool IsProbablyEndOfFunc(UInt32 flag)
+{
+ return (flag != 0 && flag != CMD_REF_Goto);
+}
+
+static const char * const kOnFunc[] =
+{
+ "Init"
+ , "InstSuccess"
+ , "InstFailed"
+ , "UserAbort"
+ , "GUIInit"
+ , "GUIEnd"
+ , "MouseOverSection"
+ , "VerifyInstDir"
+ , "SelChange"
+ , "RebootFailed"
+};
+
+void CInArchive::Add_FuncName(const UInt32 *labels, UInt32 index)
+{
+ UInt32 mask = labels[index];
+ if (mask & CMD_REF_OnFunc)
+ {
+ Script += ".on";
+ Script += kOnFunc[labels[index] >> CMD_REF_OnFunc_NumShifts];
+ }
+ else if (mask & CMD_REF_InitPluginDir)
+ {
+ /*
+ if (!IsInstaller)
+ Script += "un."
+ */
+ Script += "Initialize_____Plugins";
+ }
+ else
+ {
+ Script += "func_";
+ Add_UInt(index);
+ }
+}
+
+void CInArchive::AddParam_Func(const UInt32 *labels, UInt32 index)
+{
+ Space();
+ if ((Int32)index >= 0)
+ Add_FuncName(labels, index);
+ else
+ AddQuotes();
+}
+
+
+void CInArchive::Add_LabelName(UInt32 index)
+{
+ Script += "label_";
+ Add_UInt(index);
+}
+
+// param != 0
+void CInArchive::Add_GotoVar(UInt32 param)
+{
+ Space();
+ if ((Int32)param < 0)
+ Add_Var((UInt32)-((Int32)param + 1));
+ else
+ Add_LabelName(param - 1);
+}
+
+void CInArchive::Add_GotoVar1(UInt32 param)
+{
+ if (param == 0)
+ Script += " 0";
+ else
+ Add_GotoVar(param);
+}
+
+void CInArchive::Add_GotoVars2(const UInt32 *params)
+{
+ Add_GotoVar1(params[0]);
+ if (params[1] != 0)
+ Add_GotoVar(params[1]);
+}
+
+static bool NoLabels(const UInt32 *labels, UInt32 num)
+{
+ for (UInt32 i = 0; i < num; i++)
+ if (labels[i] != 0)
+ return false;
+ return true;
+}
+
+static const char * const k_REBOOTOK = " /REBOOTOK";
+
+#define Z7_NSIS_WIN_MB_ABORTRETRYIGNORE 2
+#define Z7_NSIS_WIN_MB_RETRYCANCEL 5
+
+static const char * const k_MB_Buttons[] =
+{
+ "OK"
+ , "OKCANCEL"
+ , "ABORTRETRYIGNORE"
+ , "YESNOCANCEL"
+ , "YESNO"
+ , "RETRYCANCEL"
+ , "CANCELTRYCONTINUE"
+};
+
+#define Z7_NSIS_WIN_MB_ICONSTOP (1 << 4)
+
+static const char * const k_MB_Icons[] =
+{
+ NULL
+ , "ICONSTOP"
+ , "ICONQUESTION"
+ , "ICONEXCLAMATION"
+ , "ICONINFORMATION"
+};
+
+static const char * const k_MB_Flags[] =
+{
+ "HELP"
+ , "NOFOCUS"
+ , "SETFOREGROUND"
+ , "DEFAULT_DESKTOP_ONLY"
+ , "TOPMOST"
+ , "RIGHT"
+ , "RTLREADING"
+ // , "SERVICE_NOTIFICATION" // unsupported. That bit is used for NSIS purposes
+};
+
+#define Z7_NSIS_WIN_IDCANCEL 2
+#define Z7_NSIS_WIN_IDIGNORE 5
+
+static const char * const k_Button_IDs[] =
+{
+ "0"
+ , "IDOK"
+ , "IDCANCEL"
+ , "IDABORT"
+ , "IDRETRY"
+ , "IDIGNORE"
+ , "IDYES"
+ , "IDNO"
+ , "IDCLOSE"
+ , "IDHELP"
+ , "IDTRYAGAIN"
+ , "IDCONTINUE"
+};
+
+void CInArchive::Add_ButtonID(UInt32 buttonID)
+{
+ Space();
+ if (buttonID < Z7_ARRAY_SIZE(k_Button_IDs))
+ Script += k_Button_IDs[buttonID];
+ else
+ {
+ Script += "Button_";
+ Add_UInt(buttonID);
+ }
+}
+
+bool CInArchive::IsDirectString_Equal(UInt32 offset, const char *s) const
+{
+ if (offset >= NumStringChars)
+ return false;
+ if (IsUnicode)
+ return AreStringsEqual_16and8(_data + _stringsPos + offset * 2, s);
+ else
+ return strcmp((const char *)(const Byte *)_data + _stringsPos + offset, s) == 0;
+}
+
+static bool StringToUInt32(const char *s, UInt32 &res)
+{
+ const char *end;
+ if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
+ res = ConvertHexStringToUInt32(s + 2, &end);
+ else
+ res = ConvertStringToUInt32(s, &end);
+ return (*end == 0);
+}
+
+static const unsigned k_CtlColors32_Size = 24;
+static const unsigned k_CtlColors64_Size = 28;
+
+#define GET_CtlColors_SIZE(is64) ((is64) ? k_CtlColors64_Size : k_CtlColors32_Size)
+
+struct CNsis_CtlColors
+{
+ UInt32 text; // COLORREF
+ UInt32 bkc; // COLORREF
+ UInt32 lbStyle;
+ UInt32 bkb; // HBRUSH
+ Int32 bkmode;
+ Int32 flags;
+ UInt32 bkb_hi32;
+
+ void Parse(const Byte *p, bool is64);
+};
+
+void CNsis_CtlColors::Parse(const Byte *p, bool is64)
+{
+ text = Get32(p);
+ bkc = Get32(p + 4);
+ if (is64)
+ {
+ bkb = Get32(p + 8);
+ bkb_hi32 = Get32(p + 12);
+ lbStyle = Get32(p + 16);
+ p += 4;
+ }
+ else
+ {
+ lbStyle = Get32(p + 8);
+ bkb = Get32(p + 12);
+ }
+ bkmode = (Int32)Get32(p + 16);
+ flags = (Int32)Get32(p + 20);
+}
+
+// Win32 constants
+#define Z7_NSIS_WIN_TRANSPARENT 1
+// #define Z7_NSIS_WIN_OPAQUE 2
+
+// text/bg colors
+#define kColorsFlags_TEXT 1
+#define kColorsFlags_TEXT_SYS 2
+#define kColorsFlags_BK 4
+#define kColorsFlags_BK_SYS 8
+#define kColorsFlags_BKB 16
+
+void CInArchive::Add_Color2(UInt32 v)
+{
+ v = ((v & 0xFF) << 16) | (v & 0xFF00) | ((v >> 16) & 0xFF);
+ char sz[32];
+ for (int i = 5; i >= 0; i--)
+ {
+ unsigned t = v & 0xF;
+ v >>= 4;
+ sz[i] = (char)(((t < 10) ? ('0' + t) : ('A' + (t - 10))));
+ }
+ sz[6] = 0;
+ Script += sz;
+}
+
+void CInArchive::Add_ColorParam(UInt32 v)
+{
+ Space();
+ Add_Color2(v);
+}
+
+void CInArchive::Add_Color(UInt32 v)
+{
+ Script += "0x";
+ Add_Color2(v);
+}
+
+#define Z7_NSIS_WIN_SW_HIDE 0
+#define Z7_NSIS_WIN_SW_SHOWNORMAL 1
+
+#define Z7_NSIS_WIN_SW_SHOWMINIMIZED 2
+#define Z7_NSIS_WIN_SW_SHOWMINNOACTIVE 7
+#define Z7_NSIS_WIN_SW_SHOWNA 8
+
+static const char * const kShowWindow_Commands[] =
+{
+ "HIDE"
+ , "SHOWNORMAL" // "NORMAL"
+ , "SHOWMINIMIZED"
+ , "SHOWMAXIMIZED" // "MAXIMIZE"
+ , "SHOWNOACTIVATE"
+ , "SHOW"
+ , "MINIMIZE"
+ , "SHOWMINNOACTIVE"
+ , "SHOWNA"
+ , "RESTORE"
+ , "SHOWDEFAULT"
+ , "FORCEMINIMIZE" // "MAX"
+};
+
+static void Add_ShowWindow_Cmd_2(AString &s, UInt32 cmd)
+{
+ if (cmd < Z7_ARRAY_SIZE(kShowWindow_Commands))
+ {
+ s += "SW_";
+ s += kShowWindow_Commands[cmd];
+ }
+ else
+ UIntToString(s, cmd);
+}
+
+void CInArchive::Add_ShowWindow_Cmd(UInt32 cmd)
+{
+ if (cmd < Z7_ARRAY_SIZE(kShowWindow_Commands))
+ {
+ Script += "SW_";
+ Script += kShowWindow_Commands[cmd];
+ }
+ else
+ Add_UInt(cmd);
+}
+
+void CInArchive::Add_TypeFromList(const char * const *table, unsigned tableSize, UInt32 type)
+{
+ if (type < tableSize)
+ Script += table[type];
+ else
+ {
+ Script += '_';
+ Add_UInt(type);
+ }
+}
+
+#define ADD_TYPE_FROM_LIST(table, type) Add_TypeFromList(table, Z7_ARRAY_SIZE(table), type)
+
+enum
+{
+ k_ExecFlags_AutoClose,
+ k_ExecFlags_ShellVarContext,
+ k_ExecFlags_Errors,
+ k_ExecFlags_Abort,
+ k_ExecFlags_RebootFlag,
+ k_ExecFlags_reboot_called,
+ k_ExecFlags_cur_insttype,
+ k_ExecFlags_plugin_api_version,
+ k_ExecFlags_Silent,
+ k_ExecFlags_InstDirError,
+ k_ExecFlags_rtl,
+ k_ExecFlags_ErrorLevel,
+ k_ExecFlags_RegView,
+ k_ExecFlags_DetailsPrint = 13
+};
+
+// Names for NSIS exec_flags_t structure vars
+static const char * const kExecFlags_VarsNames[] =
+{
+ "AutoClose" // autoclose;
+ , "ShellVarContext" // all_user_var;
+ , "Errors" // exec_error;
+ , "Abort" // abort;
+ , "RebootFlag" // exec_reboot; // NSIS_SUPPORT_REBOOT
+ , "reboot_called" // reboot_called; // NSIS_SUPPORT_REBOOT
+ , "cur_insttype" // XXX_cur_insttype; // depreacted
+ , "plugin_api_version" // plugin_api_version; // see NSISPIAPIVER_CURR
+ // used to be XXX_insttype_changed
+ , "Silent" // silent; // NSIS_CONFIG_SILENT_SUPPORT
+ , "InstDirError" // instdir_error;
+ , "rtl" // rtl;
+ , "ErrorLevel" // errlvl;
+ , "RegView" // alter_reg_view;
+ , "DetailsPrint" // status_update;
+};
+
+void CInArchive::Add_ExecFlags(UInt32 flagsType)
+{
+ ADD_TYPE_FROM_LIST(kExecFlags_VarsNames, flagsType);
+}
+
+
+// ---------- Page ----------
+
+// page flags
+#define PF_CANCEL_ENABLE 4
+#define PF_LICENSE_FORCE_SELECTION 32
+#define PF_LICENSE_NO_FORCE_SELECTION 64
+#define PF_PAGE_EX 512
+#define PF_DIR_NO_BTN_DISABLE 1024
+/*
+#define PF_LICENSE_SELECTED 1
+#define PF_NEXT_ENABLE 2
+#define PF_BACK_SHOW 8
+#define PF_LICENSE_STREAM 16
+#define PF_NO_NEXT_FOCUS 128
+#define PF_BACK_ENABLE 256
+*/
+
+// page window proc
+enum
+{
+ PWP_LICENSE,
+ PWP_SELCOM,
+ PWP_DIR,
+ PWP_INSTFILES,
+ PWP_UNINST,
+ PWP_COMPLETED,
+ PWP_CUSTOM
+};
+
+static const char * const kPageTypes[] =
+{
+ "license"
+ , "components"
+ , "directory"
+ , "instfiles"
+ , "uninstConfirm"
+ , "COMPLETED"
+ , "custom"
+};
+
+#define SET_FUNC_REF(x, flag) if ((Int32)(x) >= 0 && (x) < bh.Num) \
+ { labels[x] = (labels[x] & ~CMD_REF_Page_Mask) | ((flag) | (pageIndex << CMD_REF_Page_NumShifts)); }
+
+// #define IDD_LICENSE 102
+#define IDD_LICENSE_FSRB 108
+#define IDD_LICENSE_FSCB 109
+
+void CInArchive::AddPageOption1(UInt32 param, const char *name)
+{
+ if (param == 0)
+ return;
+ TabString(name);
+ AddParam(param);
+ NewLine();
+}
+
+void CInArchive::AddPageOption(const UInt32 *params, unsigned num, const char *name)
+{
+ num = GetNumParams(params, num);
+ if (num == 0)
+ return;
+ TabString(name);
+ AddParams(params, num);
+ NewLine();
+}
+
+void CInArchive::Separator()
+{
+ AddLF();
+ AddCommentAndString("--------------------");
+ AddLF();
+}
+
+void CInArchive::Space()
+{
+ Script += ' ';
+}
+
+void CInArchive::Tab()
+{
+ Script += " ";
+}
+
+void CInArchive::Tab(bool commented)
+{
+ Script += commented ? " ; " : " ";
+}
+
+void CInArchive::BigSpaceComment()
+{
+ Script += " ; ";
+}
+
+void CInArchive::SmallSpaceComment()
+{
+ Script += " ; ";
+}
+
+void CInArchive::AddCommentAndString(const char *s)
+{
+ Script += "; ";
+ Script += s;
+}
+
+void CInArchive::AddError(const char *s)
+{
+ BigSpaceComment();
+ Script += "!!! ERROR: ";
+ Script += s;
+}
+
+void CInArchive::AddErrorLF(const char *s)
+{
+ AddError(s);
+ AddLF();
+}
+
+void CInArchive::CommentOpen()
+{
+ AddStringLF("/*");
+}
+
+void CInArchive::CommentClose()
+{
+ AddStringLF("*/");
+}
+
+void CInArchive::AddLF()
+{
+ Script += CR_LF;
+}
+
+void CInArchive::AddQuotes()
+{
+ Script += "\"\"";
+}
+
+void CInArchive::TabString(const char *s)
+{
+ Tab();
+ Script += s;
+}
+
+void CInArchive::AddStringLF(const char *s)
+{
+ Script += s;
+ AddLF();
+}
+
+// ---------- Section ----------
+
+static const char * const kSection_VarsNames[] =
+{
+ "Text"
+ , "InstTypes"
+ , "Flags"
+ , "Code"
+ , "CodeSize"
+ , "Size" // size in KB
+};
+
+void CInArchive::Add_SectOp(UInt32 opType)
+{
+ ADD_TYPE_FROM_LIST(kSection_VarsNames, opType);
+}
+
+void CSection::Parse(const Byte *p)
+{
+ Name = Get32(p);
+ InstallTypes = Get32(p + 4);
+ Flags = Get32(p + 8);
+ StartCmdIndex = Get32(p + 12);
+ NumCommands = Get32(p + 16);
+ SizeKB = Get32(p + 20);
+}
+
+// used for section->flags
+#define SF_SELECTED (1 << 0)
+#define SF_SECGRP (1 << 1)
+#define SF_SECGRPEND (1 << 2)
+#define SF_BOLD (1 << 3)
+#define SF_RO (1 << 4)
+#define SF_EXPAND (1 << 5)
+/*
+#define SF_PSELECTED (1 << 6)
+#define SF_TOGGLED (1 << 7)
+#define SF_NAMECHG (1 << 8)
+*/
+
+bool CInArchive::PrintSectionBegin(const CSection §, unsigned index)
+{
+ AString name;
+ if (sect.Flags & SF_BOLD)
+ name += '!';
+ AString s2;
+ ReadString2(s2, sect.Name);
+ if (!IsInstaller)
+ {
+ if (!StringsAreEqualNoCase_Ascii(s2, "uninstall"))
+ name += "un.";
+ }
+ name += s2;
+
+ if (sect.Flags & SF_SECGRPEND)
+ {
+ AddStringLF("SectionGroupEnd");
+ return true;
+ }
+
+ if (sect.Flags & SF_SECGRP)
+ {
+ Script += "SectionGroup";
+ if (sect.Flags & SF_EXPAND)
+ Script += " /e";
+ SpaceQuStr(name);
+ Script += " ; Section";
+ AddParam_UInt(index);
+ NewLine();
+ return true;
+ }
+
+ Script += "Section";
+ if ((sect.Flags & SF_SELECTED) == 0)
+ Script += " /o";
+ if (!name.IsEmpty())
+ SpaceQuStr(name);
+
+ /*
+ if (!name.IsEmpty())
+ Script += ' ';
+ else
+ */
+ SmallSpaceComment();
+ Script += "Section_";
+ Add_UInt(index);
+
+ /*
+ Script += " ; flags = ";
+ Add_Hex(Script, sect.Flags);
+ */
+
+ NewLine();
+
+ if (sect.SizeKB != 0)
+ {
+ // probably we must show AddSize, only if there is additional size.
+ Tab();
+ AddCommentAndString("AddSize");
+ AddParam_UInt(sect.SizeKB);
+ AddLF();
+ }
+
+ bool needSectionIn =
+ (sect.Name != 0 && sect.InstallTypes != 0) ||
+ (sect.Name == 0 && sect.InstallTypes != 0xFFFFFFFF);
+ if (needSectionIn || (sect.Flags & SF_RO) != 0)
+ {
+ TabString("SectionIn");
+ UInt32 instTypes = sect.InstallTypes;
+ for (unsigned i = 0; i < 32; i++, instTypes >>= 1)
+ if ((instTypes & 1) != 0)
+ {
+ AddParam_UInt(i + 1);
+ }
+ if ((sect.Flags & SF_RO) != 0)
+ Script += " RO";
+ AddLF();
+ }
+ return false;
+}
+
+void CInArchive::PrintSectionEnd()
+{
+ AddStringLF("SectionEnd");
+ AddLF();
+}
+
+// static const unsigned kOnFuncShift = 4;
+
+void CInArchive::ClearLangComment()
+{
+ langStrIDs.Clear();
+}
+
+void CInArchive::PrintNumComment(const char *name, UInt32 value)
+{
+ // size_t len = Script.Len();
+ AddCommentAndString(name);
+ Script += ": ";
+ Add_UInt(value);
+ AddLF();
+ /*
+ len = Script.Len() - len;
+ char sz[16];
+ ConvertUInt32ToString(value, sz);
+ len += MyStringLen(sz);
+ for (; len < 20; len++)
+ Space();
+ AddStringLF(sz);
+ */
+}
+
+
+void CInArchive::NewLine()
+{
+ if (!langStrIDs.IsEmpty())
+ {
+ BigSpaceComment();
+ for (unsigned i = 0; i < langStrIDs.Size() && i < 20; i++)
+ {
+ /*
+ if (i != 0)
+ Script += ' ';
+ */
+ UInt32 langStr = langStrIDs[i];
+ if (langStr >= _numLangStrings)
+ {
+ AddError("langStr");
+ break;
+ }
+ UInt32 param = Get32(_mainLang + langStr * 4);
+ if (param != 0)
+ AddParam(param);
+ }
+ ClearLangComment();
+ }
+ AddLF();
+}
+
+static const UInt32 kPageSize = 16 * 4;
+
+static const char * const k_SetOverwrite_Modes[] =
+{
+ "on"
+ , "off"
+ , "try"
+ , "ifnewer"
+ , "ifdiff"
+ // "lastused"
+};
+
+
+void CInArchive::MessageBox_MB_Part(UInt32 param)
+{
+ {
+ UInt32 v = param & 0xF;
+ Script += " MB_";
+ if (v < Z7_ARRAY_SIZE(k_MB_Buttons))
+ Script += k_MB_Buttons[v];
+ else
+ {
+ Script += "Buttons_";
+ Add_UInt(v);
+ }
+ }
+ {
+ UInt32 icon = (param >> 4) & 0x7;
+ if (icon != 0)
+ {
+ Script += "|MB_";
+ if (icon < Z7_ARRAY_SIZE(k_MB_Icons) && k_MB_Icons[icon])
+ Script += k_MB_Icons[icon];
+ else
+ {
+ Script += "Icon_";
+ Add_UInt(icon);
+ }
+ }
+ }
+ if ((param & 0x80) != 0)
+ Script += "|MB_USERICON";
+ {
+ UInt32 defButton = (param >> 8) & 0xF;
+ if (defButton != 0)
+ {
+ Script += "|MB_DEFBUTTON";
+ Add_UInt(defButton + 1);
+ }
+ }
+ {
+ UInt32 modal = (param >> 12) & 0x3;
+ if (modal == 1) Script += "|MB_SYSTEMMODAL";
+ else if (modal == 2) Script += "|MB_TASKMODAL";
+ else if (modal == 3) Script += "|0x3000";
+ UInt32 flags = (param >> 14);
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_MB_Flags); i++)
+ if ((flags & (1 << i)) != 0)
+ {
+ Script += "|MB_";
+ Script += k_MB_Flags[i];
+ }
+ }
+}
+
+#define GET_CMD_PARAM(ppp, index) Get32((ppp) + 4 + (index) * 4)
+
+static const Byte k_InitPluginDir_Commands[] =
+ { 13, 26, 31, 13, 19, 21, 11, 14, 25, 31, 1, 22, 4, 1 };
+
+bool CInArchive::CompareCommands(const Byte *rawCmds, const Byte *sequence, size_t numCommands)
+{
+ for (UInt32 kkk = 0; kkk < numCommands; kkk++, rawCmds += kCmdSize)
+ if (GetCmd(Get32(rawCmds)) != sequence[kkk])
+ return false;
+ return true;
+}
+
+
+static const UInt32 kSectionSize_base = 6 * 4;
+// static const UInt32 kSectionSize_8bit = kSectionSize_base + 1024;
+// static const UInt32 kSectionSize_16bit = kSectionSize_base + 1024 * 2;
+// static const UInt32 kSectionSize_16bit_Big = kSectionSize_base + 8196 * 2;
+// 8196 is default string length in NSIS-Unicode since 2.37.3
+
+#endif
+
+
+static void AddString(AString &dest, const char *src)
+{
+ dest.Add_Space_if_NotEmpty();
+ dest += src;
+}
+
+AString CInArchive::GetFormatDescription() const
+{
+ AString s ("NSIS-");
+ char c;
+ if (IsPark())
+ {
+ s += "Park-";
+ c = '1';
+ if (NsisType == k_NsisType_Park2) c = '2';
+ else if (NsisType == k_NsisType_Park3) c = '3';
+ }
+ else
+ {
+ c = '2';
+ if (NsisType == k_NsisType_Nsis3)
+ c = '3';
+ }
+ s += c;
+ if (IsNsis200)
+ s += ".00";
+ else if (IsNsis225)
+ s += ".25";
+
+ if (IsUnicode)
+ AddString(s, "Unicode");
+
+ if (Is64Bit)
+ AddString(s, "64-bit");
+
+ if (LogCmdIsEnabled)
+ AddString(s, "log");
+
+ if (BadCmd >= 0)
+ {
+ AddString(s, "BadCmd=");
+ UIntToString(s, (UInt32)BadCmd);
+ }
+ return s;
+}
+
+#ifdef NSIS_SCRIPT
+
+static const unsigned kNumAdditionalParkCmds = 3;
+
+unsigned CInArchive::GetNumSupportedCommands() const
+{
+ unsigned numCmds = IsPark() ? (unsigned)kNumCmds : (unsigned)(kNumCmds) - kNumAdditionalParkCmds;
+ if (!LogCmdIsEnabled)
+ numCmds--;
+ if (!IsUnicode)
+ numCmds -= 2;
+ return numCmds;
+}
+
+#endif
+
+UInt32 CInArchive::GetCmd(UInt32 a)
+{
+ if (!IsPark())
+ {
+ if (!LogCmdIsEnabled)
+ return a;
+ if (a < EW_SECTIONSET)
+ return a;
+ if (a == EW_SECTIONSET)
+ return EW_LOG;
+ return a - 1;
+ }
+
+ if (a < EW_REGISTERDLL)
+ return a;
+ if (NsisType >= k_NsisType_Park2)
+ {
+ if (a == EW_REGISTERDLL) return EW_GETFONTVERSION;
+ a--;
+ }
+ if (NsisType >= k_NsisType_Park3)
+ {
+ if (a == EW_REGISTERDLL) return EW_GETFONTNAME;
+ a--;
+ }
+ if (a >= EW_FSEEK)
+ {
+ if (IsUnicode)
+ {
+ if (a == EW_FSEEK) return EW_FPUTWS;
+ if (a == EW_FSEEK + 1) return EW_FPUTWS + 1;
+ a -= 2;
+ }
+
+ if (a >= EW_SECTIONSET && LogCmdIsEnabled)
+ {
+ if (a == EW_SECTIONSET)
+ return EW_LOG;
+ return a - 1;
+ }
+ if (a == EW_FPUTWS)
+ return EW_FINDPROC;
+ // if (a > EW_FPUTWS) return 0;
+ }
+ return a;
+}
+
+void CInArchive::FindBadCmd(const CBlockHeader &bh, const Byte *p)
+{
+ BadCmd = -1;
+
+ for (UInt32 kkk = 0; kkk < bh.Num; kkk++, p += kCmdSize)
+ {
+ const UInt32 id = GetCmd(Get32(p));
+ if (id >= kNumCmds)
+ continue;
+ if (BadCmd >= 0 && id >= (unsigned)BadCmd)
+ continue;
+ unsigned i;
+ if (IsNsis3_OrHigher())
+ {
+ if (id == EW_RESERVEDOPCODE)
+ {
+ BadCmd = (int)id;
+ continue;
+ }
+ }
+ else
+ {
+ // if (id == EW_GETLABELADDR || id == EW_GETFUNCTIONADDR)
+ if (id == EW_RESERVEDOPCODE || id == EW_GETOSINFO)
+ {
+ BadCmd = (int)id;
+ continue;
+ }
+ }
+ for (i = 6; i != 0; i--)
+ {
+ const UInt32 param = Get32(p + i * 4);
+ if (param != 0)
+ break;
+ }
+ if (id == EW_FINDPROC && i == 0)
+ {
+ BadCmd = (int)id;
+ continue;
+ }
+ if (k_Commands[id].NumParams < i)
+ BadCmd = (int)id;
+ }
+}
+
+/* We calculate the number of parameters in commands to detect
+ layout of commands. It's not very good way.
+ If you know simpler and more robust way to detect Version and layout,
+ please write to 7-Zip forum */
+
+void CInArchive::DetectNsisType(const CBlockHeader &bh, const Byte *p)
+{
+ bool strongPark = false;
+ bool strongNsis = false;
+
+ if (NumStringChars > 2)
+ {
+ const Byte *strData = _data + _stringsPos;
+ if (IsUnicode)
+ {
+ UInt32 num = NumStringChars - 2;
+ for (UInt32 i = 0; i < num; i++)
+ {
+ if (Get16(strData + i * 2) == 0)
+ {
+ unsigned c2 = Get16(strData + 2 + i * 2);
+ // it can be TXT/RTF with marker char (1 or 2). so we must check next char
+ // if (c2 <= NS_3_CODE_SKIP && c2 != NS_3_CODE_SHELL)
+ if (c2 == NS_3_CODE_VAR)
+ {
+ // 18.06: fixed: is it correct ?
+ // if ((Get16(strData + 3 + i * 2) & 0x8000) != 0)
+ if ((Get16(strData + 4 + i * 2) & 0x8080) == 0x8080)
+ {
+ NsisType = k_NsisType_Nsis3;
+ strongNsis = true;
+ break;
+ }
+ }
+ }
+ }
+ if (!strongNsis)
+ {
+ NsisType = k_NsisType_Park1;
+ strongPark = true;
+ }
+ }
+ else
+ {
+ UInt32 num = NumStringChars - 2;
+ for (UInt32 i = 0; i < num; i++)
+ {
+ if (strData[i] == 0)
+ {
+ Byte c2 = strData[i + 1];
+ // it can be TXT/RTF with marker char (1 or 2). so we must check next char
+ // for marker=1 (txt)
+ if (c2 == NS_3_CODE_VAR)
+ // if (c2 <= NS_3_CODE_SKIP && c2 != NS_3_CODE_SHELL && c2 != 1)
+ {
+ if ((strData[i + 2] & 0x80) != 0)
+ {
+ // const char *p2 = (const char *)(strData + i + 1);
+ // p2 = p2;
+ NsisType = k_NsisType_Nsis3;
+ strongNsis = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (NsisType == k_NsisType_Nsis2 && !IsUnicode)
+ {
+ const Byte *p2 = p;
+
+ for (UInt32 kkk = 0; kkk < bh.Num; kkk++, p2 += kCmdSize)
+ {
+ UInt32 cmd = GetCmd(Get32(p2));
+ if (cmd != EW_GETDLGITEM &&
+ cmd != EW_ASSIGNVAR)
+ continue;
+
+ UInt32 params[kNumCommandParams];
+ for (unsigned i = 0; i < kNumCommandParams; i++)
+ params[i] = Get32(p2 + 4 + 4 * i);
+
+ if (cmd == EW_GETDLGITEM)
+ {
+ // we can use also EW_SETCTLCOLORS
+ if (IsVarStr(params[1], kVar_HWNDPARENT_225))
+ {
+ IsNsis225 = true;
+ if (params[0] == kVar_Spec_OUTDIR_225)
+ {
+ IsNsis200 = true;
+ break;
+ }
+ }
+ }
+ else // if (cmd == EW_ASSIGNVAR)
+ {
+ if (params[0] == kVar_Spec_OUTDIR_225 &&
+ params[2] == 0 &&
+ params[3] == 0 &&
+ IsVarStr(params[1], kVar_OUTDIR))
+ IsNsis225 = true;
+ }
+ }
+ }
+
+ bool parkVer_WasDetected = false;
+
+ if (!strongNsis && !IsNsis225 && !IsNsis200)
+ {
+ // it must be before FindBadCmd(bh, p);
+ unsigned mask = 0;
+
+ unsigned numInsertMax = IsUnicode ? 4 : 2;
+
+ const Byte *p2 = p;
+
+ for (UInt32 kkk = 0; kkk < bh.Num; kkk++, p2 += kCmdSize)
+ {
+ UInt32 cmd = Get32(p2); // we use original (not converted) command
+
+ if (cmd < EW_WRITEUNINSTALLER ||
+ cmd > EW_WRITEUNINSTALLER + numInsertMax)
+ continue;
+
+ UInt32 params[kNumCommandParams];
+ for (unsigned i = 0; i < kNumCommandParams; i++)
+ params[i] = Get32(p2 + 4 + 4 * i);
+
+ if (params[4] != 0 ||
+ params[5] != 0 ||
+ params[0] <= 1 ||
+ params[3] <= 1)
+ continue;
+
+ UInt32 altParam = params[3];
+ if (!IsGoodString(params[0]) ||
+ !IsGoodString(altParam))
+ continue;
+
+ UInt32 additional = 0;
+ if (GetVarIndexFinished(altParam, '\\', additional) != kVar_INSTDIR)
+ continue;
+ if (AreTwoParamStringsEqual(altParam + additional, params[0]))
+ {
+ unsigned numInserts = cmd - EW_WRITEUNINSTALLER;
+ mask |= (1 << numInserts);
+ }
+ }
+
+ if (mask == 1)
+ {
+ parkVer_WasDetected = true; // it can be original NSIS or Park-1
+ }
+ else if (mask != 0)
+ {
+ ENsisType newType = NsisType;
+ if (IsUnicode)
+ switch (mask)
+ {
+ case (1 << 3): newType = k_NsisType_Park2; break;
+ case (1 << 4): newType = k_NsisType_Park3; break;
+ }
+ else
+ switch (mask)
+ {
+ case (1 << 1): newType = k_NsisType_Park2; break;
+ case (1 << 2): newType = k_NsisType_Park3; break;
+ }
+ if (newType != NsisType)
+ {
+ parkVer_WasDetected = true;
+ NsisType = newType;
+ }
+ }
+ }
+
+ FindBadCmd(bh, p);
+
+ /*
+ if (strongNsis)
+ return;
+ */
+
+ if (BadCmd < EW_REGISTERDLL)
+ return;
+
+ /*
+ // in ANSI archive we don't check Park and log version
+ if (!IsUnicode)
+ return;
+ */
+
+ // We can support Park-ANSI archives, if we remove if (strongPark) check
+ if (strongPark && !parkVer_WasDetected)
+ {
+ if (BadCmd < EW_SECTIONSET)
+ {
+ NsisType = k_NsisType_Park3;
+ LogCmdIsEnabled = true; // version 3 is provided with log enabled
+ FindBadCmd(bh, p);
+ if (BadCmd > 0 && BadCmd < EW_SECTIONSET)
+ {
+ NsisType = k_NsisType_Park2;
+ LogCmdIsEnabled = false;
+ FindBadCmd(bh, p);
+ if (BadCmd > 0 && BadCmd < EW_SECTIONSET)
+ {
+ NsisType = k_NsisType_Park1;
+ FindBadCmd(bh, p);
+ }
+ }
+ }
+ }
+
+ if (BadCmd >= EW_SECTIONSET)
+ {
+ LogCmdIsEnabled = !LogCmdIsEnabled;
+ FindBadCmd(bh, p);
+ if (BadCmd >= EW_SECTIONSET && LogCmdIsEnabled)
+ {
+ LogCmdIsEnabled = false;
+ FindBadCmd(bh, p);
+ }
+ }
+}
+
+Int32 CInArchive::GetVarIndex(UInt32 strPos) const
+{
+ if (strPos >= NumStringChars)
+ return -1;
+
+ if (IsUnicode)
+ {
+ if (NumStringChars - strPos < 3 * 2)
+ return -1;
+ const Byte *p = _data + _stringsPos + strPos * 2;
+ unsigned code = Get16(p);
+ if (IsPark())
+ {
+ if (code != PARK_CODE_VAR)
+ return -1;
+ UInt32 n = Get16(p + 2);
+ if (n == 0)
+ return -1;
+ CONVERT_NUMBER_PARK(n);
+ return (Int32)n;
+ }
+
+ // NSIS-3
+ {
+ if (code != NS_3_CODE_VAR)
+ return -1;
+ UInt32 n = Get16(p + 2);
+ if (n == 0)
+ return -1;
+ CONVERT_NUMBER_NS_3_UNICODE(n);
+ return (Int32)n;
+ }
+ }
+
+ if (NumStringChars - strPos < 4)
+ return -1;
+
+ const Byte *p = _data + _stringsPos + strPos;
+ unsigned c = *p;
+ if (NsisType == k_NsisType_Nsis3)
+ {
+ if (c != NS_3_CODE_VAR)
+ return -1;
+ }
+ else if (c != NS_CODE_VAR)
+ return -1;
+
+ const unsigned c0 = p[1];
+ if (c0 == 0)
+ return -1;
+ const unsigned c1 = p[2];
+ if (c1 == 0)
+ return -1;
+ return (Int32)DECODE_NUMBER_FROM_2_CHARS(c0, c1);
+}
+
+Int32 CInArchive::GetVarIndex(UInt32 strPos, UInt32 &resOffset) const
+{
+ resOffset = 0;
+ Int32 varIndex = GetVarIndex(strPos);
+ if (varIndex < 0)
+ return varIndex;
+ if (IsUnicode)
+ {
+ if (NumStringChars - strPos < 2 * 2)
+ return -1;
+ resOffset = 2;
+ }
+ else
+ {
+ if (NumStringChars - strPos < 3)
+ return -1;
+ resOffset = 3;
+ }
+ return varIndex;
+}
+
+Int32 CInArchive::GetVarIndexFinished(UInt32 strPos, Byte endChar, UInt32 &resOffset) const
+{
+ resOffset = 0;
+ Int32 varIndex = GetVarIndex(strPos);
+ if (varIndex < 0)
+ return varIndex;
+ if (IsUnicode)
+ {
+ if (NumStringChars - strPos < 3 * 2)
+ return -1;
+ const Byte *p = _data + _stringsPos + strPos * 2;
+ if (Get16(p + 4) != endChar)
+ return -1;
+ resOffset = 3;
+ }
+ else
+ {
+ if (NumStringChars - strPos < 4)
+ return -1;
+ const Byte *p = _data + _stringsPos + strPos;
+ if (p[3] != endChar)
+ return -1;
+ resOffset = 4;
+ }
+ return varIndex;
+}
+
+bool CInArchive::IsVarStr(UInt32 strPos, UInt32 varIndex) const
+{
+ if (varIndex > (UInt32)0x7FFF)
+ return false;
+ UInt32 resOffset;
+ return GetVarIndexFinished(strPos, 0, resOffset) == (Int32)varIndex;
+}
+
+bool CInArchive::IsAbsolutePathVar(UInt32 strPos) const
+{
+ Int32 varIndex = GetVarIndex(strPos);
+ if (varIndex < 0)
+ return false;
+ switch (varIndex)
+ {
+ case kVar_INSTDIR:
+ case kVar_EXEDIR:
+ case kVar_TEMP:
+ case kVar_PLUGINSDIR:
+ return true;
+ }
+ return false;
+}
+
+#define IS_LETTER_CHAR(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
+
+// We use same check as in NSIS decoder
+static bool IsDrivePath(const wchar_t *s) { return IS_LETTER_CHAR(s[0]) && s[1] == ':' /* && s[2] == '\\' */ ; }
+static bool IsDrivePath(const char *s) { return IS_LETTER_CHAR(s[0]) && s[1] == ':' /* && s[2] == '\\' */ ; }
+
+static bool IsAbsolutePath(const wchar_t *s)
+{
+ return (s[0] == WCHAR_PATH_SEPARATOR && s[1] == WCHAR_PATH_SEPARATOR) || IsDrivePath(s);
+}
+
+static bool IsAbsolutePath(const char *s)
+{
+ return (s[0] == CHAR_PATH_SEPARATOR && s[1] == CHAR_PATH_SEPARATOR) || IsDrivePath(s);
+}
+
+void CInArchive::SetItemName(CItem &item, UInt32 strPos)
+{
+ ReadString2_Raw(strPos);
+ const bool isAbs = IsAbsolutePathVar(strPos);
+ if (IsUnicode)
+ {
+ item.NameU = Raw_UString;
+ if (!isAbs && !IsAbsolutePath(Raw_UString))
+ item.Prefix = (int)UPrefixes.Size() - 1;
+ }
+ else
+ {
+ item.NameA = Raw_AString;
+ if (!isAbs && !IsAbsolutePath(Raw_AString))
+ item.Prefix = (int)APrefixes.Size() - 1;
+ }
+}
+
+HRESULT CInArchive::ReadEntries(const CBlockHeader &bh)
+{
+ #ifdef NSIS_SCRIPT
+ CDynLimBuf &s = Script;
+
+ CObjArray<UInt32> labels;
+ labels.Alloc(bh.Num);
+ memset(labels, 0, bh.Num * sizeof(UInt32));
+
+ {
+ const Byte *p = _data;
+ UInt32 i;
+ for (i = 0; i < numOnFunc; i++)
+ {
+ UInt32 func = Get32(p + onFuncOffset + 4 * i);
+ if (func < bh.Num)
+ labels[func] = (labels[func] & ~CMD_REF_OnFunc_Mask) | (CMD_REF_OnFunc | (i << CMD_REF_OnFunc_NumShifts));
+ }
+ }
+
+ /*
+ {
+ for (int i = 0; i < OnFuncs.Size(); i++)
+ {
+ UInt32 address = OnFuncs[i] >> kOnFuncShift;
+ if (address < bh.Num)
+ }
+ }
+ */
+
+ if (bhPages.Num != 0)
+ {
+ Separator();
+ PrintNumComment("PAGES", bhPages.Num);
+
+ if (bhPages.Num > (1 << 12)
+ || bhPages.Offset > _size
+ || bhPages.Num * kPageSize > _size - bhPages.Offset)
+ {
+ AddErrorLF("Pages error");
+ }
+ else
+ {
+
+ AddLF();
+ const Byte *p = _data + bhPages.Offset;
+
+ for (UInt32 pageIndex = 0; pageIndex < bhPages.Num; pageIndex++, p += kPageSize)
+ {
+ UInt32 dlgID = Get32(p);
+ UInt32 wndProcID = Get32(p + 4);
+ UInt32 preFunc = Get32(p + 8);
+ UInt32 showFunc = Get32(p + 12);
+ UInt32 leaveFunc = Get32(p + 16);
+ UInt32 flags = Get32(p + 20);
+ UInt32 caption = Get32(p + 24);
+ // UInt32 back = Get32(p + 28);
+ UInt32 next = Get32(p + 32);
+ // UInt32 clickNext = Get32(p + 36);
+ // UInt32 cancel = Get32(p + 40);
+ UInt32 params[5];
+ for (int i = 0; i < 5; i++)
+ params[i] = Get32(p + 44 + 4 * i);
+
+ SET_FUNC_REF(preFunc, CMD_REF_Pre)
+ SET_FUNC_REF(showFunc, CMD_REF_Show)
+ SET_FUNC_REF(leaveFunc, CMD_REF_Leave)
+
+ if (wndProcID == PWP_COMPLETED)
+ CommentOpen();
+
+ AddCommentAndString("Page ");
+ Add_UInt(pageIndex);
+ AddLF();
+
+ if (flags & PF_PAGE_EX)
+ {
+ s += "PageEx ";
+ if (!IsInstaller)
+ s += "un.";
+ }
+ else
+ s += IsInstaller ? "Page " : "UninstPage ";
+
+ if (wndProcID < Z7_ARRAY_SIZE(kPageTypes))
+ s += kPageTypes[wndProcID];
+ else
+ Add_UInt(wndProcID);
+
+
+ bool needCallbacks = (
+ (Int32)preFunc >= 0 ||
+ (Int32)showFunc >= 0 ||
+ (Int32)leaveFunc >= 0);
+
+ if (flags & PF_PAGE_EX)
+ {
+ AddLF();
+ if (needCallbacks)
+ TabString("PageCallbacks");
+ }
+
+ if (needCallbacks)
+ {
+ AddParam_Func(labels, preFunc); // it's creator_function for PWP_CUSTOM
+ if (wndProcID != PWP_CUSTOM)
+ {
+ AddParam_Func(labels, showFunc);
+ }
+ AddParam_Func(labels, leaveFunc);
+ }
+
+ if ((flags & PF_PAGE_EX) == 0)
+ {
+ // AddOptionalParam(caption);
+ if (flags & PF_CANCEL_ENABLE)
+ s += " /ENABLECANCEL";
+ AddLF();
+ }
+ else
+ {
+ AddLF();
+ AddPageOption1(caption, "Caption");
+ }
+
+ if (wndProcID == PWP_LICENSE)
+ {
+ if ((flags & PF_LICENSE_NO_FORCE_SELECTION) != 0 ||
+ (flags & PF_LICENSE_FORCE_SELECTION) != 0)
+ {
+ TabString("LicenseForceSelection ");
+ if (flags & PF_LICENSE_NO_FORCE_SELECTION)
+ s += "off";
+ else
+ {
+ if (dlgID == IDD_LICENSE_FSCB)
+ s += "checkbox";
+ else if (dlgID == IDD_LICENSE_FSRB)
+ s += "radiobuttons";
+ else
+ Add_UInt(dlgID);
+ AddOptionalParams(params + 2, 2);
+ }
+ NewLine();
+ }
+
+ if (params[0] != 0 || next != 0)
+ {
+ TabString("LicenseText");
+ AddParam(params[0]);
+ AddOptionalParam(next);
+ NewLine();
+ }
+ if (params[1] != 0)
+ {
+ TabString("LicenseData");
+ if ((Int32)params[1] < 0)
+ AddParam(params[1]);
+ else
+ AddLicense(params[1], -1);
+ ClearLangComment();
+ NewLine();
+ }
+ }
+ else if (wndProcID == PWP_SELCOM)
+ AddPageOption(params, 3, "ComponentsText");
+ else if (wndProcID == PWP_DIR)
+ {
+ AddPageOption(params, 4, "DirText");
+ if (params[4] != 0)
+ {
+ TabString("DirVar");
+ AddParam_Var(params[4] - 1);
+ AddLF();
+ }
+ if (flags & PF_DIR_NO_BTN_DISABLE)
+ {
+ TabString("DirVerify leave");
+ AddLF();
+ }
+
+ }
+ else if (wndProcID == PWP_INSTFILES)
+ {
+ AddPageOption1(params[2], "CompletedText");
+ AddPageOption1(params[1], "DetailsButtonText");
+ }
+ else if (wndProcID == PWP_UNINST)
+ {
+ if (params[4] != 0)
+ {
+ TabString("DirVar");
+ AddParam_Var(params[4] - 1);
+ AddLF();
+ }
+ AddPageOption(params, 2, "UninstallText");
+ }
+
+ if (flags & PF_PAGE_EX)
+ {
+ s += "PageExEnd";
+ NewLine();
+ }
+ if (wndProcID == PWP_COMPLETED)
+ CommentClose();
+ NewLine();
+ }
+ }
+ }
+
+ CObjArray<CSection> Sections;
+
+ {
+ Separator();
+ PrintNumComment("SECTIONS", bhSections.Num);
+ PrintNumComment("COMMANDS", bh.Num);
+ AddLF();
+
+ if (bhSections.Num > (1 << 15)
+ // || bhSections.Offset > _size
+ // || (bhSections.Num * SectionSize > _size - bhSections.Offset)
+ )
+ {
+ AddErrorLF("Sections error");
+ }
+ else if (bhSections.Num != 0)
+ {
+ Sections.Alloc((unsigned)bhSections.Num);
+ const Byte *p = _data + bhSections.Offset;
+ for (UInt32 i = 0; i < bhSections.Num; i++, p += SectionSize)
+ {
+ CSection §ion = Sections[i];
+ section.Parse(p);
+ if (section.StartCmdIndex < bh.Num)
+ labels[section.StartCmdIndex] |= CMD_REF_Section;
+ }
+ }
+ }
+
+ #endif
+
+ const Byte *p;
+ UInt32 kkk;
+
+ #ifdef NSIS_SCRIPT
+
+ p = _data + bh.Offset;
+
+ for (kkk = 0; kkk < bh.Num; kkk++, p += kCmdSize)
+ {
+ UInt32 commandId = GetCmd(Get32(p));
+ UInt32 mask;
+ switch (commandId)
+ {
+ case EW_NOP: mask = 1 << 0; break;
+ case EW_IFFILEEXISTS: mask = 3 << 1; break;
+ case EW_IFFLAG: mask = 3 << 0; break;
+ case EW_MESSAGEBOX: mask = 5 << 3; break;
+ case EW_STRCMP: mask = 3 << 2; break;
+ case EW_INTCMP: mask = 7 << 2; break;
+ case EW_ISWINDOW: mask = 3 << 1; break;
+ case EW_CALL:
+ {
+ if (Get32(p + 4 + 4) == 1) // it's Call :Label
+ {
+ mask = 1 << 0;
+ break;
+ }
+ UInt32 param0 = Get32(p + 4);
+ if ((Int32)param0 > 0)
+ labels[param0 - 1] |= CMD_REF_Call;
+ continue;
+ }
+ default: continue;
+ }
+ for (unsigned i = 0; mask != 0; i++, mask >>= 1)
+ if (mask & 1)
+ {
+ UInt32 param = Get32(p + 4 + 4 * i);
+ if ((Int32)param > 0 && (Int32)param <= (Int32)bh.Num)
+ labels[param - 1] |= CMD_REF_Goto;
+ }
+ }
+
+ int InitPluginsDir_Start = -1;
+ int InitPluginsDir_End = -1;
+ p = _data + bh.Offset;
+ for (kkk = 0; kkk < bh.Num; kkk++, p += kCmdSize)
+ {
+ UInt32 flg = labels[kkk];
+ /*
+ if (IsFunc(flg))
+ {
+ AddLF();
+ for (int i = 0; i < 14; i++)
+ {
+ UInt32 commandId = GetCmd(Get32(p + kCmdSize * i));
+ s += ", ";
+ UIntToString(s, commandId);
+ }
+ AddLF();
+ }
+ */
+ if (IsFunc(flg)
+ && bh.Num - kkk >= Z7_ARRAY_SIZE(k_InitPluginDir_Commands)
+ && CompareCommands(p, k_InitPluginDir_Commands, Z7_ARRAY_SIZE(k_InitPluginDir_Commands)))
+ {
+ InitPluginsDir_Start = (int)kkk;
+ InitPluginsDir_End = (int)(kkk + Z7_ARRAY_SIZE(k_InitPluginDir_Commands));
+ labels[kkk] |= CMD_REF_InitPluginDir;
+ break;
+ }
+ }
+
+ #endif
+
+ // AString prefixA_Temp;
+ // UString prefixU_Temp;
+
+
+ // const UInt32 kFindS = 158;
+
+ #ifdef NSIS_SCRIPT
+
+ UInt32 curSectionIndex = 0;
+ // UInt32 lastSectionEndCmd = 0xFFFFFFFF;
+ bool sectionIsOpen = false;
+ // int curOnFunc = 0;
+ bool onFuncIsOpen = false;
+
+ /*
+ for (unsigned yyy = 0; yyy + 3 < _data.Size(); yyy++)
+ {
+ UInt32 val = Get32(_data + yyy);
+ if (val == kFindS)
+ val = val;
+ }
+ */
+
+ UInt32 overwrite_State = 0; // "SetOverwrite on"
+ Int32 allowSkipFiles_State = -1; // -1: on, -2: off, >=0 : RAW value
+ UInt32 endCommentIndex = 0;
+
+ unsigned numSupportedCommands = GetNumSupportedCommands();
+
+ #endif
+
+ p = _data + bh.Offset;
+
+ UString spec_outdir_U;
+ AString spec_outdir_A;
+
+ UPrefixes.Add(UString("$INSTDIR"));
+ APrefixes.Add(AString("$INSTDIR"));
+
+ p = _data + bh.Offset;
+
+ unsigned spec_outdir_VarIndex = IsNsis225 ?
+ kVar_Spec_OUTDIR_225 :
+ kVar_Spec_OUTDIR;
+
+ for (kkk = 0; kkk < bh.Num; kkk++, p += kCmdSize)
+ {
+ UInt32 commandId;
+ UInt32 params[kNumCommandParams];
+ commandId = GetCmd(Get32(p));
+ {
+ for (unsigned i = 0; i < kNumCommandParams; i++)
+ {
+ params[i] = Get32(p + 4 + 4 * i);
+ /*
+ if (params[i] == kFindS)
+ i = i;
+ */
+ }
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ bool IsSectionGroup = false;
+ while (curSectionIndex < bhSections.Num)
+ {
+ const CSection § = Sections[curSectionIndex];
+ if (sectionIsOpen)
+ {
+ if (sect.StartCmdIndex + sect.NumCommands + 1 != kkk)
+ break;
+ PrintSectionEnd();
+ sectionIsOpen = false;
+ // lastSectionEndCmd = kkk;
+ curSectionIndex++;
+ continue;
+ }
+ if (sect.StartCmdIndex != kkk)
+ break;
+ if (PrintSectionBegin(sect, curSectionIndex))
+ {
+ IsSectionGroup = true;
+ curSectionIndex++;
+ // do we need to flush prefixes in new section?
+ // FlushOutPathPrefixes();
+ }
+ else
+ sectionIsOpen = true;
+ }
+
+ /*
+ if (curOnFunc < OnFuncs.Size())
+ {
+ if ((OnFuncs[curOnFunc] >> kOnFuncShift) == kkk)
+ {
+ s += "Function .on";
+ s += kOnFunc[OnFuncs[curOnFunc++] & ((1 << kOnFuncShift) - 1)];
+ AddLF();
+ onFuncIsOpen = true;
+ }
+ }
+ */
+
+ if (labels[kkk] != 0 && labels[kkk] != CMD_REF_Section)
+ {
+ UInt32 flg = labels[kkk];
+ if (IsFunc(flg))
+ {
+ if ((int)kkk == InitPluginsDir_Start)
+ CommentOpen();
+
+ onFuncIsOpen = true;
+ s += "Function ";
+ Add_FuncName(labels, kkk);
+ if (IsPageFunc(flg))
+ {
+ BigSpaceComment();
+ s += "Page ";
+ Add_UInt((flg & CMD_REF_Page_Mask) >> CMD_REF_Page_NumShifts);
+ // if (flg & CMD_REF_Creator) s += ", Creator";
+ if (flg & CMD_REF_Leave) s += ", Leave";
+ if (flg & CMD_REF_Pre) s += ", Pre";
+ if (flg & CMD_REF_Show) s += ", Show";
+ }
+ AddLF();
+ }
+ if (flg & CMD_REF_Goto)
+ {
+ Add_LabelName(kkk);
+ s += ':';
+ AddLF();
+ }
+ }
+
+ if (commandId != EW_RET)
+ {
+ Tab(kkk < endCommentIndex);
+ }
+
+ /*
+ UInt32 originalCmd = Get32(p);
+ if (originalCmd >= EW_REGISTERDLL)
+ {
+ UIntToString(s, originalCmd);
+ s += ' ';
+ if (originalCmd != commandId)
+ {
+ UIntToString(s, commandId);
+ s += ' ';
+ }
+ }
+ */
+
+ unsigned numSkipParams = 0;
+
+ if (commandId < Z7_ARRAY_SIZE(k_Commands) && commandId < numSupportedCommands)
+ {
+ numSkipParams = k_Commands[commandId].NumParams;
+ const char *sz = k_CommandNames[commandId];
+ if (sz)
+ s += sz;
+ }
+ else
+ {
+ s += "Command";
+ Add_UInt(commandId);
+ /* We don't show wrong commands that use overlapped ids.
+ So we change commandId to big value */
+ if (commandId < (1 << 12))
+ commandId += (1 << 12);
+ }
+
+ #endif
+
+ switch (commandId)
+ {
+ case EW_CREATEDIR:
+ {
+ bool isSetOutPath = (params[1] != 0);
+
+ if (isSetOutPath)
+ {
+ UInt32 par0 = params[0];
+
+ UInt32 resOffset;
+ Int32 idx = GetVarIndex(par0, resOffset);
+ if (idx == (Int32)spec_outdir_VarIndex ||
+ idx == kVar_OUTDIR)
+ par0 += resOffset;
+
+ ReadString2_Raw(par0);
+
+ if (IsUnicode)
+ {
+ if (idx == (Int32)spec_outdir_VarIndex)
+ Raw_UString.Insert(0, spec_outdir_U);
+ else if (idx == kVar_OUTDIR)
+ Raw_UString.Insert(0, UPrefixes.Back());
+ UPrefixes.Add(Raw_UString);
+ }
+ else
+ {
+ if (idx == (Int32)spec_outdir_VarIndex)
+ Raw_AString.Insert(0, spec_outdir_A);
+ else if (idx == kVar_OUTDIR)
+ Raw_AString.Insert(0, APrefixes.Back());
+ APrefixes.Add(Raw_AString);
+ }
+ }
+
+ #ifdef NSIS_SCRIPT
+ s += isSetOutPath ? "SetOutPath" : "CreateDirectory";
+ AddParam(params[0]);
+ if (params[2] != 0) // 2.51+ & 3.0b3+
+ {
+ SmallSpaceComment();
+ s += "CreateRestrictedDirectory";
+ }
+ #endif
+
+ break;
+ }
+
+
+ case EW_ASSIGNVAR:
+ {
+ if (params[0] == spec_outdir_VarIndex)
+ {
+ spec_outdir_U.Empty();
+ spec_outdir_A.Empty();
+ if (IsVarStr(params[1], kVar_OUTDIR) &&
+ params[2] == 0 &&
+ params[3] == 0)
+ {
+ spec_outdir_U = UPrefixes.Back(); // outdir_U;
+ spec_outdir_A = APrefixes.Back(); // outdir_A;
+ }
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ if (params[2] == 0 &&
+ params[3] == 0 &&
+ params[4] == 0 &&
+ params[5] == 0 &&
+ params[1] != 0 &&
+ params[1] < NumStringChars)
+ {
+ char sz[16];
+ ConvertUInt32ToString(kkk + 1, sz);
+ if (IsDirectString_Equal(params[1], sz))
+ {
+ // we suppose that it's GetCurrentAddress command
+ // but there is probability that it's StrCpy command
+ s += "GetCurrentAddress";
+ AddParam_Var(params[0]);
+ SmallSpaceComment();
+ }
+ }
+ s += "StrCpy";
+ AddParam_Var(params[0]);
+ AddParam(params[1]);
+
+ AddOptionalParams(params + 2, 2);
+
+ #endif
+
+ break;
+ }
+
+ case EW_EXTRACTFILE:
+ {
+ CItem &item = Items.AddNew();
+
+ UInt32 par1 = params[1];
+
+ SetItemName(item, par1);
+
+ item.Pos = params[2];
+ item.MTime.dwLowDateTime = params[3];
+ item.MTime.dwHighDateTime = params[4];
+
+ #ifdef NSIS_SCRIPT
+
+ {
+ UInt32 overwrite = params[0] & 0x7;
+ if (overwrite != overwrite_State)
+ {
+ s += "SetOverwrite ";
+ ADD_TYPE_FROM_LIST(k_SetOverwrite_Modes, overwrite);
+ overwrite_State = overwrite;
+ AddLF();
+ Tab(kkk < endCommentIndex);
+ }
+ }
+
+ {
+ UInt32 nsisMB = params[0] >> 3;
+ if ((Int32)nsisMB != allowSkipFiles_State)
+ {
+ UInt32 mb = nsisMB & ((1 << 20) - 1); // old/new NSIS
+ UInt32 b1 = nsisMB >> 21; // NSIS 2.06+
+ UInt32 b2 = nsisMB >> 20; // NSIS old
+ Int32 asf = (Int32)nsisMB;
+ if (mb == (Z7_NSIS_WIN_MB_ABORTRETRYIGNORE | Z7_NSIS_WIN_MB_ICONSTOP) && (b1 == Z7_NSIS_WIN_IDIGNORE || b2 == Z7_NSIS_WIN_IDIGNORE))
+ asf = -1;
+ else if (mb == (Z7_NSIS_WIN_MB_RETRYCANCEL | Z7_NSIS_WIN_MB_ICONSTOP) && (b1 == Z7_NSIS_WIN_IDCANCEL || b2 == Z7_NSIS_WIN_IDCANCEL))
+ asf = -2;
+ else
+ {
+ AddCommentAndString("AllowSkipFiles [Overwrite]: ");
+ MessageBox_MB_Part(mb);
+ if (b1 != 0)
+ {
+ s += " /SD";
+ Add_ButtonID(b1);
+ }
+ }
+ if (asf != allowSkipFiles_State)
+ {
+ if (asf < 0)
+ {
+ s += "AllowSkipFiles ";
+ s += (asf == -1) ? "on" : "off";
+ }
+ AddLF();
+ Tab(kkk < endCommentIndex);
+ }
+ allowSkipFiles_State = (Int32)nsisMB;
+ }
+ }
+
+ s += "File";
+ AddParam(params[1]);
+
+ /* params[5] contains link to LangString (negative value)
+ with NLF_FILE_ERROR or NLF_FILE_ERROR_NOIGNORE message for MessageBox.
+ We don't need to print it. */
+
+ #endif
+
+ if (IsVarStr(par1, 10)) // is $R0
+ {
+ // we parse InstallLib macro in 7-Zip installers
+ unsigned kBackOffset = 28;
+ if (kkk > 1)
+ {
+ // detect old version of InstallLib macro
+ if (Get32(p - 1 * kCmdSize) == EW_NOP) // goto command
+ kBackOffset -= 2;
+ }
+
+ if (kkk > kBackOffset)
+ {
+ const Byte *p2 = p - kBackOffset * kCmdSize;
+ UInt32 cmd = Get32(p2);
+ if (cmd == EW_ASSIGNVAR)
+ {
+ UInt32 pars[6];
+ for (int i = 0; i < 6; i++)
+ pars[i] = Get32(p2 + i * 4 + 4);
+ if (pars[0] == 10 + 4 && pars[2] == 0 && pars[3] == 0) // 10 + 4 means $R4
+ {
+ item.Prefix = -1;
+ item.NameA.Empty();
+ item.NameU.Empty();
+ SetItemName(item, pars[1]);
+ // maybe here we can restore original item name, if new name is empty
+ }
+ }
+ }
+ }
+ /* UInt32 allowIgnore = params[5]; */
+ break;
+ }
+
+ case EW_SETFILEATTRIBUTES:
+ {
+ if (kkk > 0 && Get32(p - kCmdSize) == EW_EXTRACTFILE)
+ {
+ if (params[0] == Get32(p - kCmdSize + 4 + 4 * 1)) // compare with PrevCmd.Params[1]
+ {
+ CItem &item = Items.Back();
+ item.Attrib_Defined = true;
+ item.Attrib = params[1];
+ }
+ }
+ #ifdef NSIS_SCRIPT
+ AddParam(params[0]);
+ Space();
+ FlagsToString2(s, g_WinAttrib, Z7_ARRAY_SIZE(g_WinAttrib), params[1]);
+ #endif
+ break;
+ }
+
+ case EW_WRITEUNINSTALLER:
+ {
+ /* NSIS 2.29+ writes alternative path to params[3]
+ "$INSTDIR\\" + Str(params[0])
+ NSIS installer uses alternative path, if main path
+ from params[0] is not absolute path */
+
+ const bool pathOk = (params[0] > 0) && IsGoodString(params[0]);
+
+ if (!pathOk)
+ {
+ #ifdef NSIS_SCRIPT
+ AddError("bad path");
+ #endif
+ break;
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ bool altPathOk = true;
+
+ const UInt32 altParam = params[3];
+ if (altParam != 0)
+ {
+ altPathOk = false;
+ UInt32 additional = 0;
+ if (GetVarIndexFinished(altParam, '\\', additional) == kVar_INSTDIR)
+ altPathOk = AreTwoParamStringsEqual(altParam + additional, params[0]);
+ }
+
+ AddParam(params[0]);
+
+ /*
+ for (int i = 1; i < 3; i++)
+ AddParam_UInt(params[i]);
+ */
+
+ if (params[3] != 0)
+ {
+ SmallSpaceComment();
+ AddParam(params[3]);
+ }
+
+ if (!altPathOk)
+ {
+ #ifdef NSIS_SCRIPT
+ AddError("alt path error");
+ #endif
+ }
+
+ #endif
+
+ if (BadCmd >= 0 && BadCmd <= EW_WRITEUNINSTALLER)
+ {
+ /* We don't support cases with incorrect installer commands.
+ Such bad installer item can break unpacking for other items. */
+ #ifdef NSIS_SCRIPT
+ AddError("SKIP possible BadCmd");
+ #endif
+ break;
+ }
+
+ CItem &item = Items.AddNew();
+
+ SetItemName(item, params[0]);
+
+ item.Pos = params[1];
+ item.PatchSize = params[2];
+ item.IsUninstaller = true;
+ const UInt32 param3 = params[3];
+ if (param3 != 0 && item.Prefix != -1)
+ {
+ /* (item.Prefix != -1) case means that param[0] path was not absolute.
+ So we use params[3] in that case, as original nsis */
+ SetItemName(item, param3);
+ }
+ /* UNINSTALLER file doesn't use directory prefixes.
+ So we remove prefix: */
+ item.Prefix = -1;
+
+ /*
+ // we can add second time to test the code
+ CItem item2 = item;
+ item2.NameU += L'2';
+ item2.NameA += '2';
+ Items.Add(item2);
+ */
+
+ break;
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ case EW_RET:
+ {
+ // bool needComment = false;
+ if (onFuncIsOpen)
+ {
+ if (kkk == bh.Num - 1 || IsProbablyEndOfFunc(labels[kkk + 1]))
+ {
+ AddStringLF("FunctionEnd");
+
+ if ((int)kkk + 1 == InitPluginsDir_End)
+ CommentClose();
+ AddLF();
+ onFuncIsOpen = false;
+ // needComment = true;
+ break;
+ }
+ }
+ // if (!needComment)
+ if (IsSectionGroup)
+ break;
+ if (sectionIsOpen)
+ {
+ const CSection § = Sections[curSectionIndex];
+ if (sect.StartCmdIndex + sect.NumCommands == kkk)
+ {
+ PrintSectionEnd();
+ sectionIsOpen = false;
+ curSectionIndex++;
+ break;
+ }
+
+ // needComment = true;
+ // break;
+ }
+
+ /*
+ if (needComment)
+ s += " ;";
+ */
+ TabString("Return");
+ AddLF();
+ break;
+ }
+
+ case EW_NOP:
+ {
+ if (params[0] == 0)
+ s += "Nop";
+ else
+ {
+ s += "Goto";
+ Add_GotoVar(params[0]);
+ }
+ break;
+ }
+
+ case EW_ABORT:
+ {
+ AddOptionalParam(params[0]);
+ break;
+ }
+
+ case EW_CALL:
+ {
+ if (kkk + 1 < bh.Num && GetCmd(Get32(p + kCmdSize)) == EW_EXTRACTFILE)
+ {
+ UInt32 par1 = GET_CMD_PARAM(p + kCmdSize, 1);
+
+ UInt32 pluginPar = 0;
+
+ if (GetVarIndexFinished(par1, '\\', pluginPar) == kVar_PLUGINSDIR)
+ {
+ pluginPar += par1;
+ UInt32 commandId2 = GetCmd(Get32(p + kCmdSize * 2));
+ if (commandId2 == EW_SETFLAG || commandId2 == EW_UPDATETEXT)
+ {
+ UInt32 i;
+ for (i = kkk + 3; i < bh.Num; i++)
+ {
+ const Byte *pCmd = p + kCmdSize * (i - kkk);
+ UInt32 commandId3 = GetCmd(Get32(pCmd));
+ if (commandId3 != EW_PUSHPOP
+ || GET_CMD_PARAM(pCmd, 1) != 0
+ || GET_CMD_PARAM(pCmd, 2) != 0)
+ break;
+ }
+ if (i < bh.Num)
+ {
+ const Byte *pCmd = p + kCmdSize * (i - kkk);
+
+ // UInt32 callDll_Param = GET_CMD_PARAM(pCmd, 0);
+ // UInt32 file_Param = GET_CMD_PARAM(p + kCmdSize, 1);
+
+ if (GetCmd(Get32(pCmd)) == EW_REGISTERDLL &&
+ AreTwoParamStringsEqual(
+ GET_CMD_PARAM(pCmd, 0),
+ GET_CMD_PARAM(p + kCmdSize, 1)))
+ {
+ // params[4] = 1 means GetModuleHandle attempt before default LoadLibraryEx;
+ /// new versions of NSIS use params[4] = 1 for Plugin command
+ if (GET_CMD_PARAM(pCmd, 2) == 0
+ // && GET_CMD_PARAM(pCmd, 4) != 0
+ )
+ {
+ {
+ AString s2;
+ ReadString2(s2, pluginPar);
+ if (s2.Len() >= 4 &&
+ StringsAreEqualNoCase_Ascii(s2.RightPtr(4), ".dll"))
+ s2.DeleteFrom(s2.Len() - 4);
+ s2 += "::";
+ AString func;
+ ReadString2(func, GET_CMD_PARAM(pCmd, 1));
+ s2 += func;
+ Add_QuStr(s2);
+
+ if (GET_CMD_PARAM(pCmd, 3) == 1)
+ s += " /NOUNLOAD";
+
+ for (UInt32 j = i - 1; j >= kkk + 3; j--)
+ {
+ const Byte *pCmd2 = p + kCmdSize * (j - kkk);
+ AddParam(GET_CMD_PARAM(pCmd2, 0));
+ }
+ NewLine();
+ Tab(true);
+ endCommentIndex = i + 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ {
+ const Byte *nextCmd = p + kCmdSize;
+ UInt32 commandId2 = GetCmd(Get32(nextCmd));
+ if (commandId2 == EW_SETFLAG
+ && GET_CMD_PARAM(nextCmd, 0) == k_ExecFlags_DetailsPrint
+ && GET_CMD_PARAM(nextCmd, 2) != 0) // is "lastused"
+ // || commandId2 == EW_UPDATETEXT)
+ {
+ if ((Int32)params[0] > 0 && labels[params[0] - 1] & CMD_REF_InitPluginDir)
+ {
+ s += "InitPluginsDir";
+ AddLF();
+ Tab(true);
+ endCommentIndex = kkk + 2;
+ }
+ }
+ }
+
+ s += "Call ";
+ if ((Int32)params[0] < 0)
+ Add_Var((UInt32)-((Int32)params[0] + 1));
+ else if (params[0] == 0)
+ s += '0';
+ else
+ {
+ const UInt32 val = params[0] - 1;
+ if (params[1] == 1) // it's Call :Label
+ {
+ s += ':';
+ Add_LabelName(val);
+ }
+ else // if (params[1] == 0) // it's Call Func
+ Add_FuncName(labels, val);
+ }
+ break;
+ }
+
+ case EW_UPDATETEXT:
+ case EW_SLEEP:
+ {
+ AddParam(params[0]);
+ break;
+ }
+
+ case EW_CHDETAILSVIEW:
+ {
+ if (params[0] == Z7_NSIS_WIN_SW_SHOWNA && params[1] == Z7_NSIS_WIN_SW_HIDE) s += " show";
+ else if (params[1] == Z7_NSIS_WIN_SW_SHOWNA && params[0] == Z7_NSIS_WIN_SW_HIDE) s += " hide";
+ else
+ for (int i = 0; i < 2; i++)
+ {
+ Space();
+ Add_ShowWindow_Cmd(params[i]);
+ }
+ break;
+ }
+
+ case EW_IFFILEEXISTS:
+ {
+ AddParam(params[0]);
+ Add_GotoVars2(¶ms[1]);
+ break;
+ }
+
+ case EW_SETFLAG:
+ {
+ AString temp;
+ ReadString2(temp, params[1]);
+ if (params[0] == k_ExecFlags_Errors && params[2] == 0)
+ {
+ s += (temp.Len() == 1 && temp[0] == '0') ? "ClearErrors" : "SetErrors";
+ break;
+ }
+ s += "Set";
+ Add_ExecFlags(params[0]);
+
+ if (params[2] != 0)
+ {
+ s += " lastused";
+ break;
+ }
+ UInt32 v;
+ if (StringToUInt32(temp, v))
+ {
+ const char *s2 = NULL;
+ switch (params[0])
+ {
+ case k_ExecFlags_AutoClose:
+ case k_ExecFlags_RebootFlag:
+ if (v < 2) { s2 = (v == 0) ? "false" : "true"; } break;
+ case k_ExecFlags_ShellVarContext:
+ if (v < 2) { s2 = (v == 0) ? "current" : "all"; } break;
+ case k_ExecFlags_Silent:
+ if (v < 2) { s2 = (v == 0) ? "normal" : "silent"; } break;
+ case k_ExecFlags_RegView:
+ if (v == 0) s2 = "32";
+ else if (v == 256) s2 = "64";
+ break;
+ case k_ExecFlags_DetailsPrint:
+ if (v == 0) s2 = "both";
+ else if (v == 2) s2 = "textonly";
+ else if (v == 4) s2 = "listonly";
+ else if (v == 6) s2 = "none";
+ break;
+ }
+ if (s2)
+ {
+ s += ' ';
+ s += s2;
+ break;
+ }
+ }
+ SpaceQuStr(temp);
+ break;
+ }
+
+ case EW_IFFLAG:
+ {
+ Add_ExecFlags(params[2]);
+ Add_GotoVars2(¶ms[0]);
+ /*
+ const unsigned kIfErrors = 2;
+ if (params[2] != kIfErrors && params[3] != 0xFFFFFFFF ||
+ params[2] == kIfErrors && params[3] != 0)
+ {
+ s += " # FLAG &= ";
+ AddParam_UInt(params[3]);
+ }
+ */
+ break;
+ }
+
+ case EW_GETFLAG:
+ {
+ Add_ExecFlags(params[1]);
+ AddParam_Var(params[0]);
+ break;
+ }
+
+ case EW_RENAME:
+ {
+ if (params[2] != 0)
+ s += k_REBOOTOK;
+ AddParams(params, 2);
+ if (params[3] != 0)
+ {
+ SmallSpaceComment();
+ AddParam(params[3]); // rename comment for log file
+ }
+ break;
+ }
+
+ case EW_GETFULLPATHNAME:
+ {
+ if (params[2] == 0)
+ s += " /SHORT";
+ AddParam_Var(params[1]);
+ AddParam(params[0]);
+ break;
+ }
+
+ case EW_SEARCHPATH:
+ case EW_STRLEN:
+ {
+ AddParam_Var(params[0]);
+ AddParam(params[1]);
+ break;
+ }
+
+ case EW_GETTEMPFILENAME:
+ {
+ AddParam_Var(params[0]);
+ AString temp;
+ ReadString2(temp, params[1]);
+ if (temp != "$TEMP")
+ SpaceQuStr(temp);
+ break;
+ }
+
+ case EW_DELETEFILE:
+ {
+ UInt32 flag = params[1];
+ if ((flag & DEL_REBOOT) != 0)
+ s += k_REBOOTOK;
+ AddParam(params[0]);
+ break;
+ }
+
+ case EW_MESSAGEBOX:
+ {
+ MessageBox_MB_Part(params[0]);
+ AddParam(params[1]);
+ {
+ UInt32 buttonID = (params[0] >> 21); // NSIS 2.06+
+ if (buttonID != 0)
+ {
+ s += " /SD";
+ Add_ButtonID(buttonID);
+ }
+ }
+ for (int i = 2; i < 6; i += 2)
+ if (params[i] != 0)
+ {
+ Add_ButtonID(params[i]);
+ Add_GotoVar1(params[i + 1]);
+ }
+ break;
+ }
+
+ case EW_RMDIR:
+ {
+ UInt32 flag = params[1];
+ if ((flag & DEL_RECURSE) != 0)
+ s += " /r";
+ if ((flag & DEL_REBOOT) != 0)
+ s += k_REBOOTOK;
+ AddParam(params[0]);
+ break;
+ }
+
+ case EW_STRCMP:
+ {
+ if (params[4] != 0)
+ s += 'S';
+ AddParams(params, 2);
+ Add_GotoVars2(¶ms[2]);
+ break;
+ }
+
+ case EW_READENVSTR:
+ {
+ s += (params[2] != 0) ?
+ "ReadEnvStr" :
+ "ExpandEnvStrings";
+ AddParam_Var(params[0]);
+ AString temp;
+ ReadString2(temp, params[1]);
+ if (params[2] != 0 &&temp.Len() >= 2 && temp[0] == '%' && temp.Back() == '%')
+ {
+ temp.DeleteBack();
+ temp.Delete(0);
+ }
+ SpaceQuStr(temp);
+ break;
+ }
+
+ case EW_INTCMP:
+ {
+ s += "Int";
+ const UInt32 param5 = params[5];
+ if (param5 & 0x8000)
+ s += "64"; // v3.03+
+ s += "Cmp";
+ if (IsNsis3_OrHigher() ? (param5 & 1) : (param5 != 0))
+ s += 'U';
+ AddParams(params, 2);
+ Add_GotoVar1(params[2]);
+ if (params[3] != 0 || params[4] != 0)
+ Add_GotoVars2(params + 3);
+ break;
+ }
+
+ case EW_INTOP:
+ {
+ AddParam_Var(params[0]);
+ const char * const kOps = "+-*/|&^!|&%<>>"; // NSIS 2.01+
+ // "+-*/|&^!|&%"; // NSIS 2.0b4+
+ // "+-*/|&^~!|&%"; // NSIS old
+ const UInt32 opIndex = params[3];
+ const char c = (opIndex < 14) ? kOps[opIndex] : '?';
+ const char c2 = (opIndex < 8 || opIndex == 10) ? (char)0 : c;
+ const int numOps = (opIndex == 7) ? 1 : 2;
+ AddParam(params[1]);
+ if (numOps == 2 && c == '^' && IsDirectString_Equal(params[2], "0xFFFFFFFF"))
+ s += " ~ ;";
+ Space();
+ s += c;
+ if (numOps != 1)
+ {
+ if (opIndex == 13) // v3.03+ : operation ">>>"
+ s += c;
+ if (c2 != 0)
+ s += c2;
+ AddParam(params[2]);
+ }
+ break;
+ }
+
+ case EW_INTFMT:
+ {
+ if (params[3])
+ s += "Int64Fmt"; // v3.03+
+ else
+ s += "IntFmt";
+ AddParam_Var(params[0]);
+ AddParams(params + 1, 2);
+ break;
+ }
+
+ case EW_PUSHPOP:
+ {
+ if (params[2] != 0)
+ {
+ s += "Exch";
+ if (params[2] != 1)
+ AddParam_UInt(params[2]);
+ }
+ else if (params[1] != 0)
+ {
+ s += "Pop";
+ AddParam_Var(params[0]);
+ }
+ else
+ {
+ if (NoLabels(labels + kkk + 1, 2)
+ && Get32(p + kCmdSize) == EW_PUSHPOP // Exch"
+ && GET_CMD_PARAM(p + kCmdSize, 2) == 1
+ && Get32(p + kCmdSize * 2) == EW_PUSHPOP // Pop $VAR
+ && GET_CMD_PARAM(p + kCmdSize * 2, 1) != 0)
+ {
+ if (IsVarStr(params[0], GET_CMD_PARAM(p + kCmdSize * 2, 0)))
+ {
+ s += "Exch";
+ AddParam(params[0]);
+ NewLine();
+ Tab(true);
+ endCommentIndex = kkk + 3;
+ }
+ }
+ s += "Push";
+ AddParam(params[0]);
+ }
+ break;
+ }
+
+ case EW_FINDWINDOW:
+ {
+ AddParam_Var(params[0]);
+ AddParam(params[1]);
+ AddOptionalParams(params + 2, 3);
+ break;
+ }
+
+ case EW_SENDMESSAGE:
+ {
+ // SendMessage: 6 [output, hwnd, msg, wparam, lparam, [wparamstring?1:0 | lparamstring?2:0 | timeout<<2]
+ AddParam(params[1]);
+
+ const char *w = NULL;
+ AString t;
+ ReadString2(t, params[2]);
+ UInt32 wm;
+ if (StringToUInt32(t, wm))
+ {
+ switch (wm)
+ {
+ case 0x0C: w = "SETTEXT"; break;
+ case 0x10: w = "CLOSE"; break;
+ case 0x30: w = "SETFONT"; break;
+ }
+ }
+ if (w)
+ {
+ s += " ${WM_";
+ s += w;
+ s += '}';
+ }
+ else
+ SpaceQuStr(t);
+
+ UInt32 spec = params[5];
+ for (unsigned i = 0; i < 2; i++)
+ {
+ AString s2;
+ if (spec & ((UInt32)1 << i))
+ s2 += "STR:";
+ ReadString2(s2, params[3 + i]);
+ SpaceQuStr(s2);
+ }
+
+ if ((Int32)params[0] >= 0)
+ AddParam_Var(params[0]);
+
+ spec >>= 2;
+ if (spec != 0)
+ {
+ s += " /TIMEOUT=";
+ Add_UInt(spec);
+ }
+ break;
+ }
+
+ case EW_ISWINDOW:
+ {
+ AddParam(params[0]);
+ Add_GotoVars2(¶ms[1]);
+ break;
+ }
+
+ case EW_GETDLGITEM:
+ {
+ AddParam_Var(params[0]);
+ AddParams(params + 1, 2);
+ break;
+ }
+
+ case EW_SETCTLCOLORS:
+ {
+ AddParam(params[0]);
+
+ UInt32 offset = params[1];
+
+ if (_size < bhCtlColors.Offset
+ || _size - bhCtlColors.Offset < offset
+ || _size - bhCtlColors.Offset - offset < GET_CtlColors_SIZE(Is64Bit))
+ {
+ AddError("bad offset");
+ break;
+ }
+
+ const Byte *p2 = _data + bhCtlColors.Offset + offset;
+ CNsis_CtlColors colors;
+ colors.Parse(p2, Is64Bit);
+
+ if ((colors.flags & kColorsFlags_BK_SYS) != 0 ||
+ (colors.flags & kColorsFlags_TEXT_SYS) != 0)
+ s += " /BRANDING";
+
+ AString bk;
+ bool bkc = false;
+ if (colors.bkmode == Z7_NSIS_WIN_TRANSPARENT)
+ bk += " transparent";
+ else if (colors.flags & kColorsFlags_BKB)
+ {
+ if ((colors.flags & kColorsFlags_BK_SYS) == 0 &&
+ (colors.flags & kColorsFlags_BK) != 0)
+ bkc = true;
+ }
+ if ((colors.flags & kColorsFlags_TEXT) != 0 || !bk.IsEmpty() || bkc)
+ {
+ Space();
+ if ((colors.flags & kColorsFlags_TEXT_SYS) != 0 || (colors.flags & kColorsFlags_TEXT) == 0)
+ AddQuotes();
+ else
+ Add_Color(colors.text);
+ }
+ s += bk;
+ if (bkc)
+ {
+ Space();
+ Add_Color(colors.bkc);
+ }
+
+ break;
+ }
+
+ // case EW_LOADANDSETIMAGE:
+ case EW_SETBRANDINGIMAGE:
+ {
+ s += " /IMGID=";
+ Add_UInt(params[1]);
+ if (params[2] == 1)
+ s += " /RESIZETOFIT";
+ AddParam(params[0]);
+ break;
+ }
+
+ case EW_CREATEFONT:
+ {
+ AddParam_Var(params[0]);
+ AddParam(params[1]);
+ AddOptionalParams(params + 2, 2);
+ if (params[4] & 1) s += " /ITALIC";
+ if (params[4] & 2) s += " /UNDERLINE";
+ if (params[4] & 4) s += " /STRIKE";
+ break;
+ }
+
+ case EW_SHOWWINDOW:
+ {
+ AString hw, sw;
+ ReadString2(hw, params[0]);
+ ReadString2(sw, params[1]);
+ if (params[3] != 0)
+ s += "EnableWindow";
+ else
+ {
+ UInt32 val;
+ bool valDefined = false;
+ if (StringToUInt32(sw, val))
+ {
+ if (val < Z7_ARRAY_SIZE(kShowWindow_Commands))
+ {
+ sw.Empty();
+ sw += "${";
+ Add_ShowWindow_Cmd_2(sw, val);
+ sw += '}';
+ valDefined = true;
+ }
+ }
+ bool isHwndParent = IsVarStr(params[0], IsNsis225 ? kVar_HWNDPARENT_225 : kVar_HWNDPARENT);
+ if (params[2] != 0)
+ {
+ if (valDefined && val == 0 && isHwndParent)
+ {
+ s += "HideWindow";
+ break;
+ }
+ }
+ if (valDefined && val == 5 && isHwndParent &&
+ kkk + 1 < bh.Num && GetCmd(Get32(p + kCmdSize)) == EW_BRINGTOFRONT)
+ {
+ s += " ; ";
+ }
+ s += "ShowWindow";
+ }
+ SpaceQuStr(hw);
+ SpaceQuStr(sw);
+ break;
+ }
+
+ case EW_SHELLEXEC:
+ {
+ AddParams(params, 2);
+ if (params[2] != 0 || params[3] != Z7_NSIS_WIN_SW_SHOWNORMAL)
+ {
+ AddParam(params[2]);
+ if (params[3] != Z7_NSIS_WIN_SW_SHOWNORMAL)
+ {
+ Space();
+ Add_ShowWindow_Cmd(params[3]);
+ }
+ }
+ if (params[5] != 0)
+ {
+ s += " ;";
+ AddParam(params[5]); // it's tatus text update
+ }
+ break;
+ }
+
+ case EW_EXECUTE:
+ {
+ if (params[2] != 0)
+ s += "Wait";
+ AddParam(params[0]);
+ if (params[2] != 0)
+ if ((Int32)params[1] >= 0)
+ AddParam_Var(params[1]);
+ break;
+ }
+
+ case EW_GETFILETIME:
+ case EW_GETDLLVERSION:
+ {
+ if (commandId == EW_GETDLLVERSION)
+ if (params[3] == 2)
+ s += " /ProductVersion"; // v3.08+
+ AddParam(params[2]);
+ AddParam_Var(params[0]);
+ AddParam_Var(params[1]);
+ break;
+ }
+
+ case EW_REGISTERDLL:
+ {
+ AString func;
+ ReadString2(func, params[1]);
+ bool printFunc = true;
+ // params[4] = 1; for plugin command
+ if (params[2] == 0)
+ {
+ s += "CallInstDLL";
+ AddParam(params[0]);
+ if (params[3] == 1)
+ s += " /NOUNLOAD";
+ }
+ else
+ {
+ if (func == "DllUnregisterServer")
+ {
+ s += "UnRegDLL";
+ printFunc = false;
+ }
+ else
+ {
+ s += "RegDLL";
+ if (func == "DllRegisterServer")
+ printFunc = false;
+ }
+ AddParam(params[0]);
+ }
+ if (printFunc)
+ SpaceQuStr(func);
+ break;
+ }
+
+ case EW_CREATESHORTCUT:
+ {
+ unsigned numParams;
+ #define IsNsis3d0b3_OrHigher() 0 // change it
+ const unsigned v3_0b3 = IsNsis3d0b3_OrHigher();
+ for (numParams = 6; numParams > 2; numParams--)
+ if (params[numParams - 1] != 0)
+ break;
+
+ const UInt32 spec = params[4];
+ const unsigned sw_shift = v3_0b3 ? 12 : 8;
+ const UInt32 sw_mask = v3_0b3 ? 0x7000 : 0x7F;
+ if (spec & 0x8000) // NSIS 3.0b0
+ s += " /NoWorkingDir";
+
+ AddParams(params, numParams > 4 ? 4 : numParams);
+ if (numParams <= 4)
+ break;
+
+ UInt32 icon = (spec & (v3_0b3 ? 0xFFF : 0xFF));
+ Space();
+ if (icon != 0)
+ Add_UInt(icon);
+ else
+ AddQuotes();
+
+ if ((spec >> sw_shift) == 0 && numParams < 6)
+ break;
+ UInt32 sw = (spec >> sw_shift) & sw_mask;
+ Space();
+ // NSIS encoder replaces these names:
+ if (sw == Z7_NSIS_WIN_SW_SHOWMINNOACTIVE)
+ sw = Z7_NSIS_WIN_SW_SHOWMINIMIZED;
+ if (sw == 0)
+ AddQuotes();
+ else
+ Add_ShowWindow_Cmd(sw);
+
+ UInt32 modKey = spec >> 24;
+ UInt32 key = (spec >> 16) & 0xFF;
+
+ if (modKey == 0 && key == 0)
+ {
+ if (numParams < 6)
+ break;
+ Space();
+ AddQuotes();
+ }
+ else
+ {
+ Space();
+ if (modKey & 1) s += "SHIFT|"; // HOTKEYF_SHIFT
+ if (modKey & 2) s += "CONTROL|";
+ if (modKey & 4) s += "ALT|";
+ if (modKey & 8) s += "EXT|";
+
+ const unsigned kMy_VK_F1 = 0x70;
+ if (key >= kMy_VK_F1 && key <= kMy_VK_F1 + 23)
+ {
+ s += 'F';
+ Add_UInt(key - kMy_VK_F1 + 1);
+ }
+ else if ((key >= 'A' && key <= 'Z') || (key >= '0' && key <= '9'))
+ s += (char)key;
+ else
+ {
+ s += "Char_";
+ Add_UInt(key);
+ }
+ }
+ AddOptionalParam(params[5]); // description
+ break;
+ }
+
+ case EW_COPYFILES:
+ {
+ if (params[2] & 0x04) s += " /SILENT"; // FOF_SILENT
+ if (params[2] & 0x80) s += " /FILESONLY"; // FOF_FILESONLY
+ AddParams(params, 2);
+ if (params[3] != 0)
+ {
+ s += " ;";
+ AddParam(params[3]); // status text update
+ }
+ break;
+ }
+
+ case EW_REBOOT:
+ {
+ if (params[0] != 0xbadf00d)
+ s += " ; Corrupted ???";
+ else if (kkk + 1 < bh.Num && GetCmd(Get32(p + kCmdSize)) == EW_QUIT)
+ endCommentIndex = kkk + 2;
+ break;
+ }
+
+ case EW_WRITEINI:
+ {
+ unsigned numAlwaysParams = 0;
+ if (params[0] == 0) // Section
+ s += "FlushINI";
+ else if (params[4] != 0)
+ {
+ s += "WriteINIStr";
+ numAlwaysParams = 3;
+ }
+ else
+ {
+ s += "DeleteINI";
+ s += (params[1] == 0) ? "Sec" : "Str";
+ numAlwaysParams = 1;
+ }
+ AddParam(params[3]); // filename
+ // Section, EntryName, Value
+ AddParams(params, numAlwaysParams);
+ AddOptionalParams(params + numAlwaysParams, 3 - numAlwaysParams);
+ break;
+ }
+
+ case EW_READINISTR:
+ {
+ AddParam_Var(params[0]);
+ AddParam(params[3]); // FileName
+ AddParams(params +1, 2); // Section, EntryName
+ break;
+ }
+
+ case EW_DELREG:
+ {
+ // NSIS 2.00 used another scheme!
+
+ if (params[4] == 0)
+ s += "Value";
+ else
+ {
+ s += "Key";
+ if (params[4] & 2)
+ s += " /ifempty";
+ // TODO: /ifnosubkeys, /ifnovalues
+ }
+ AddRegRoot(params[1]);
+ AddParam(params[2]);
+ AddOptionalParam(params[3]);
+ break;
+ }
+
+ case EW_WRITEREG:
+ {
+ const char *s2 = NULL;
+ switch (params[4])
+ {
+ case 1: s2 = "Str"; break;
+ case 2: s2 = "ExpandStr"; break; // maybe unused
+ case 3: s2 = "Bin"; break;
+ case 4: s2 = "DWORD"; break;
+ default:
+ s += '?';
+ Add_UInt(params[4]);
+ }
+ if (params[4] == 1 && params[5] == 2)
+ s2 = "ExpandStr";
+ if (params[4] == 3 && params[5] == 7)
+ s2 = "MultiStr"; // v3.02+
+ if (s2)
+ s += s2;
+ AddRegRoot(params[0]);
+ AddParams(params + 1, 2); // keyName, valueName
+ if (params[4] != 3)
+ AddParam(params[3]); // value
+ else
+ {
+ // Binary data.
+ Space();
+ UInt32 offset = params[3];
+ bool isSupported = false;
+ if (AfterHeaderSize >= 4
+ && bhData.Offset <= AfterHeaderSize - 4
+ && offset <= AfterHeaderSize - 4 - bhData.Offset)
+ {
+ // we support it for solid archives.
+ const Byte *p2 = _afterHeader + bhData.Offset + offset;
+ UInt32 size = Get32(p2);
+ if (size <= AfterHeaderSize - 4 - bhData.Offset - offset)
+ {
+ for (UInt32 i = 0; i < size; i++)
+ {
+ Byte b = (p2 + 4)[i];
+ unsigned t;
+ t = (b >> 4); s += (char)(((t < 10) ? ('0' + t) : ('A' + (t - 10))));
+ t = (b & 15); s += (char)(((t < 10) ? ('0' + t) : ('A' + (t - 10))));
+ }
+ isSupported = true;
+ }
+ }
+ if (!isSupported)
+ {
+ // we must read from file here;
+ s += "data[";
+ Add_UInt(offset);
+ s += " ... ]";
+ s += " ; !!! Unsupported";
+ }
+ }
+ break;
+ }
+
+ case EW_READREGSTR:
+ {
+ s += (params[4] == 1) ? "DWORD" : "Str";
+ AddParam_Var(params[0]);
+ AddRegRoot(params[1]);
+ AddParams(params + 2, 2);
+ break;
+ }
+
+ case EW_REGENUM:
+ {
+ s += (params[4] != 0) ? "Key" : "Value";
+ AddParam_Var(params[0]);
+ AddRegRoot(params[1]);
+ AddParams(params + 2, 2);
+ break;
+ }
+
+ case EW_FCLOSE:
+ case EW_FINDCLOSE:
+ {
+ AddParam_Var(params[0]);
+ break;
+ }
+
+ #endif
+
+ case EW_FOPEN:
+ {
+ /*
+ the pattern for empty files is following:
+ FileOpen $0 "file_name" w
+ FileClose $0
+ */
+
+ const UInt32 acc = params[1]; // dwDesiredAccess
+ const UInt32 creat = params[2]; // dwCreationDisposition
+ if (creat == Z7_NSIS_WIN_CREATE_ALWAYS && acc == Z7_NSIS_WIN_GENERIC_WRITE)
+ {
+ if (kkk + 1 < bh.Num)
+ if (Get32(p + kCmdSize) == EW_FCLOSE)
+ if (Get32(p + kCmdSize + 4) == params[0])
+ {
+ CItem &item = Items.AddNew();
+ item.IsEmptyFile = true;
+ SetItemName(item, params[3]);
+ }
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ AddParam_Var(params[0]);
+ AddParam(params[3]);
+ if (acc == 0 && creat == 0)
+ break;
+ char cc = 0;
+ if (creat == Z7_NSIS_WIN_OPEN_EXISTING && acc == Z7_NSIS_WIN_GENERIC_READ)
+ cc = 'r';
+ else if (creat == Z7_NSIS_WIN_CREATE_ALWAYS && acc == Z7_NSIS_WIN_GENERIC_WRITE)
+ cc = 'w';
+ else if (creat == Z7_NSIS_WIN_OPEN_ALWAYS && (acc == (Z7_NSIS_WIN_GENERIC_WRITE | Z7_NSIS_WIN_GENERIC_READ)))
+ cc = 'a';
+ // cc = 0;
+ if (cc != 0)
+ {
+ Space();
+ s += cc;
+ break;
+ }
+
+ if (acc & Z7_NSIS_WIN_GENERIC_READ) s += " GENERIC_READ";
+ if (acc & Z7_NSIS_WIN_GENERIC_WRITE) s += " GENERIC_WRITE";
+ if (acc & Z7_NSIS_WIN_GENERIC_EXECUTE) s += " GENERIC_EXECUTE";
+ if (acc & Z7_NSIS_WIN_GENERIC_ALL) s += " GENERIC_ALL";
+
+ const char *s2 = NULL;
+ switch (creat)
+ {
+ case Z7_NSIS_WIN_CREATE_NEW: s2 = "CREATE_NEW"; break;
+ case Z7_NSIS_WIN_CREATE_ALWAYS: s2 = "CREATE_ALWAYS"; break;
+ case Z7_NSIS_WIN_OPEN_EXISTING: s2 = "OPEN_EXISTING"; break;
+ case Z7_NSIS_WIN_OPEN_ALWAYS: s2 = "OPEN_ALWAYS"; break;
+ case Z7_NSIS_WIN_TRUNCATE_EXISTING: s2 = "TRUNCATE_EXISTING"; break;
+ }
+ Space();
+ if (s2)
+ s += s2;
+ else
+ Add_UInt(creat);
+ #endif
+
+ break;
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ case EW_FPUTS:
+ case EW_FPUTWS:
+ {
+ if (commandId == EW_FPUTWS)
+ s += (params[2] == 0) ? "UTF16LE" : "Word";
+ else if (params[2] != 0)
+ s += "Byte";
+ if (params[2] == 0 && params[3])
+ s += " /BOM"; // v3.0b3+
+ AddParam_Var(params[0]);
+ AddParam(params[1]);
+ break;
+ }
+
+ case EW_FGETS:
+ case EW_FGETWS:
+ {
+ if (commandId == EW_FPUTWS)
+ s += (params[3] == 0) ? "UTF16LE" : "Word";
+ if (params[3] != 0)
+ s += "Byte";
+ AddParam_Var(params[0]);
+ AddParam_Var(params[1]);
+ AString maxLenStr;
+ ReadString2(maxLenStr, params[2]);
+ UInt32 maxLen;
+ if (StringToUInt32(maxLenStr, maxLen))
+ {
+ if (maxLen == 1 && params[3] != 0)
+ break;
+ if (maxLen == 1023 && params[3] == 0) // NSIS_MAX_STRLEN - 1; can be other value!!
+ break;
+ }
+ SpaceQuStr(maxLenStr);
+ break;
+ }
+
+ case EW_FSEEK:
+ {
+ AddParam_Var(params[0]);
+ AddParam(params[2]);
+ if (params[3] == 1) s += " CUR"; // FILE_CURRENT
+ if (params[3] == 2) s += " END"; // FILE_END
+ if ((Int32)params[1] >= 0)
+ {
+ if (params[3] == 0) s += " SET"; // FILE_BEGIN
+ AddParam_Var(params[1]);
+ }
+ break;
+ }
+
+ case EW_FINDNEXT:
+ {
+ AddParam_Var(params[1]);
+ AddParam_Var(params[0]);
+ break;
+ }
+
+ case EW_FINDFIRST:
+ {
+ AddParam_Var(params[1]);
+ AddParam_Var(params[0]);
+ AddParam(params[2]);
+ break;
+ }
+
+ case EW_LOG:
+ {
+ if (params[0] != 0)
+ {
+ s += "Set ";
+ s += (params[1] == 0) ? "off" : "on";
+ }
+ else
+ {
+ s += "Text";
+ AddParam(params[1]);
+ }
+ break;
+ }
+
+ case EW_SECTIONSET:
+ {
+ if ((Int32)params[2] >= 0)
+ {
+ s += "Get";
+ Add_SectOp(params[2]);
+ AddParam(params[0]);
+ AddParam_Var(params[1]);
+ }
+ else
+ {
+ s += "Set";
+ const UInt32 t = (UInt32)(-(Int32)params[2] - 1);
+ Add_SectOp(t);
+ AddParam(params[0]);
+ AddParam(params[t == 0 ? 4 : 1]);
+
+ // params[3] != 0 means call SectionFlagsChanged in installer
+ // used by SECTIONSETFLAGS command
+ }
+ break;
+ }
+
+ case EW_INSTTYPESET:
+ {
+ unsigned numQwParams = 0;
+ const char *s2;
+ if (params[3] == 0)
+ {
+ if (params[2] == 0)
+ {
+ s2 = "InstTypeGetText";
+ numQwParams = 1;
+ }
+ else
+ {
+ s2 = "InstTypeSetText";
+ numQwParams = 2;
+ }
+ }
+ else
+ {
+ if (params[2] == 0)
+ s2 = "GetCurInstType";
+ else
+ {
+ s2 = "SetCurInstType";
+ numQwParams = 1;
+ }
+ }
+ s += s2;
+ AddParams(params, numQwParams);
+ if (params[2] == 0)
+ AddParam_Var(params[1]);
+ break;
+ }
+
+ case EW_GETOSINFO:
+ {
+ if (IsNsis3_OrHigher())
+ {
+ // v3.06+
+ if (params[3] == 0) // GETOSINFO_KNOWNFOLDER
+ {
+ s += "GetKnownFolderPath";
+ AddParam_Var(params[1]);
+ AddParam(params[2]);
+ break;
+ }
+ else if (params[3] == 1) // GETOSINFO_READMEMORY
+ {
+ s += "ReadMemory";
+ AddParam_Var(params[1]);
+ AddParam(params[2]);
+ AddParam(params[4]);
+ // if (params[2] == "0") AddCommentAndString("GetWinVer");
+ }
+ else
+ s += "GetOsInfo";
+ break;
+ }
+ s += "GetLabelAddr"; // before v3.06+
+ break;
+ }
+
+ case EW_LOCKWINDOW:
+ {
+ s += (params[0] == 0) ? " on" : " off";
+ break;
+ }
+
+ case EW_FINDPROC:
+ {
+ AddParam_Var(params[0]);
+ AddParam(params[1]);
+ break;
+ }
+
+ default:
+ {
+ numSkipParams = 0;
+ }
+ #endif
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ unsigned numParams = kNumCommandParams;
+
+ for (; numParams > 0; numParams--)
+ if (params[numParams - 1] != 0)
+ break;
+
+ if (numParams > numSkipParams)
+ {
+ s += " ; !!!! Unknown Params: ";
+ unsigned i;
+ for (i = 0; i < numParams; i++)
+ AddParam(params[i]);
+
+ s += " ;";
+
+ for (i = 0; i < numParams; i++)
+ {
+ Space();
+ UInt32 v = params[i];
+ if (v > 0xFFF00000)
+ Add_SignedInt(s, (Int32)v);
+ else
+ Add_UInt(v);
+ }
+ }
+
+ NewLine();
+
+ #endif
+ }
+
+ #ifdef NSIS_SCRIPT
+
+ if (sectionIsOpen)
+ {
+ if (curSectionIndex < bhSections.Num)
+ {
+ const CSection § = Sections[curSectionIndex];
+ if (sect.StartCmdIndex + sect.NumCommands + 1 == kkk)
+ {
+ PrintSectionEnd();
+ sectionIsOpen = false;
+ // lastSectionEndCmd = kkk;
+ curSectionIndex++;
+ }
+ }
+ }
+
+ while (curSectionIndex < bhSections.Num)
+ {
+ const CSection § = Sections[curSectionIndex];
+ if (sectionIsOpen)
+ {
+ if (sect.StartCmdIndex + sect.NumCommands != kkk)
+ AddErrorLF("SECTION ERROR");
+ PrintSectionEnd();
+ sectionIsOpen = false;
+ curSectionIndex++;
+ }
+ else
+ {
+ if (PrintSectionBegin(sect, curSectionIndex))
+ curSectionIndex++;
+ else
+ sectionIsOpen = true;
+ }
+ }
+
+ #endif
+
+ return S_OK;
+}
+
+static int CompareItems(void *const *p1, void *const *p2, void *param)
+{
+ const CItem &i1 = **(const CItem *const *)p1;
+ const CItem &i2 = **(const CItem *const *)p2;
+ RINOZ(MyCompare(i1.Pos, i2.Pos))
+
+ /* In another code we check CItem::Pos after each solid item.
+ So here we place empty files before all non empty files */
+ if (i1.IsEmptyFile)
+ {
+ if (!i2.IsEmptyFile)
+ return -1;
+ }
+ else if (i2.IsEmptyFile)
+ return 1;
+
+ const CInArchive *inArchive = (const CInArchive *)param;
+ if (inArchive->IsUnicode)
+ {
+ if (i1.Prefix != i2.Prefix)
+ {
+ if (i1.Prefix < 0) return -1;
+ if (i2.Prefix < 0) return 1;
+ RINOZ(
+ inArchive->UPrefixes[i1.Prefix].Compare(
+ inArchive->UPrefixes[i2.Prefix]))
+ }
+ RINOZ(i1.NameU.Compare(i2.NameU))
+ }
+ else
+ {
+ if (i1.Prefix != i2.Prefix)
+ {
+ if (i1.Prefix < 0) return -1;
+ if (i2.Prefix < 0) return 1;
+ RINOZ(strcmp(
+ inArchive->APrefixes[i1.Prefix],
+ inArchive->APrefixes[i2.Prefix]))
+ }
+ RINOZ(strcmp(i1.NameA, i2.NameA))
+ }
+ return 0;
+}
+
+HRESULT CInArchive::SortItems()
+{
+ {
+ Items.Sort(CompareItems, (void *)this);
+ unsigned i;
+
+ for (i = 0; i + 1 < Items.Size(); i++)
+ {
+ const CItem &i1 = Items[i];
+ if (i1.IsEmptyFile)
+ continue;
+ const CItem &i2 = Items[i + 1];
+ if (i1.Pos != i2.Pos)
+ continue;
+
+ if (IsUnicode)
+ {
+ if (i1.NameU != i2.NameU) continue;
+ if (i1.Prefix != i2.Prefix)
+ {
+ if (i1.Prefix < 0 || i2.Prefix < 0) continue;
+ if (UPrefixes[i1.Prefix] != UPrefixes[i2.Prefix]) continue;
+ }
+ }
+ else
+ {
+ if (i1.NameA != i2.NameA) continue;
+ if (i1.Prefix != i2.Prefix)
+ {
+ if (i1.Prefix < 0 || i2.Prefix < 0) continue;
+ if (APrefixes[i1.Prefix] != APrefixes[i2.Prefix]) continue;
+ }
+ }
+ Items.Delete(i + 1);
+ i--;
+ }
+
+ for (i = 0; i < Items.Size(); i++)
+ {
+ CItem &item = Items[i];
+ if (item.IsEmptyFile)
+ continue;
+ const UInt32 curPos = item.Pos + 4;
+ for (unsigned nextIndex = i + 1; nextIndex < Items.Size(); nextIndex++)
+ {
+ const CItem &nextItem = Items[nextIndex];
+ // if (nextItem.IsEmptyFile) continue;
+ const UInt32 nextPos = nextItem.Pos;
+ if (curPos <= nextPos)
+ {
+ item.EstimatedSize_Defined = true;
+ item.EstimatedSize = nextPos - curPos;
+ break;
+ }
+ }
+ }
+
+ if (!IsSolid)
+ {
+ for (i = 0; i < Items.Size(); i++)
+ {
+ CItem &item = Items[i];
+ if (item.IsEmptyFile)
+ continue;
+ RINOK(SeekToNonSolidItem(i))
+ const UInt32 kSigSize = 4 + 1 + 1 + 4; // size,[flag],prop,dict
+ BYTE sig[kSigSize];
+ size_t processedSize = kSigSize;
+ RINOK(ReadStream(_stream, sig, &processedSize))
+ if (processedSize < 4)
+ return S_FALSE;
+ UInt32 size = Get32(sig);
+ if ((size & kMask_IsCompressed) != 0)
+ {
+ item.IsCompressed = true;
+ size &= ~kMask_IsCompressed;
+ if (Method == NMethodType::kLZMA)
+ {
+ if (processedSize < 9)
+ return S_FALSE;
+ /*
+ if (FilterFlag)
+ item.UseFilter = (sig[4] != 0);
+ */
+ item.DictionarySize = Get32(sig + 4 + 1 + (FilterFlag ? 1 : 0));
+ }
+ }
+ else
+ {
+ item.IsCompressed = false;
+ item.Size = size;
+ item.Size_Defined = true;
+ }
+ item.CompressedSize = size;
+ item.CompressedSize_Defined = true;
+ }
+ }
+ }
+ return S_OK;
+}
+
+#ifdef NSIS_SCRIPT
+// Flags for common_header.flags
+// #define CH_FLAGS_DETAILS_SHOWDETAILS 1
+// #define CH_FLAGS_DETAILS_NEVERSHOW 2
+#define CH_FLAGS_PROGRESS_COLORED 4
+#define CH_FLAGS_SILENT 8
+#define CH_FLAGS_SILENT_LOG 16
+#define CH_FLAGS_AUTO_CLOSE 32
+// #define CH_FLAGS_DIR_NO_SHOW 64 // unused now
+#define CH_FLAGS_NO_ROOT_DIR 128
+#define CH_FLAGS_COMP_ONLY_ON_CUSTOM 256
+#define CH_FLAGS_NO_CUSTOM 512
+
+static const char * const k_PostStrings[] =
+{
+ "install_directory_auto_append"
+ , "uninstchild" // NSIS 2.25+, used by uninstaller:
+ , "uninstcmd" // NSIS 2.25+, used by uninstaller:
+ , "wininit" // NSIS 2.25+, used by move file on reboot
+};
+#endif
+
+
+void CBlockHeader::Parse(const Byte *p, unsigned bhoSize)
+{
+ if (bhoSize == 12)
+ {
+ // UInt64 a = GetUi64(p);
+ if (GetUi32(p + 4) != 0)
+ throw 1;
+ }
+ Offset = GetUi32(p);
+ Num = GetUi32(p + bhoSize - 4);
+}
+
+#define PARSE_BH(k, bh) bh.Parse (p1 + 4 + bhoSize * k, bhoSize)
+
+
+HRESULT CInArchive::Parse()
+{
+ // UInt32 offset = ReadUInt32();
+ // ???? offset == FirstHeader.HeaderSize
+ const Byte * const p1 = _data;
+
+ if (_size < 4 + 12 * 8)
+ Is64Bit = false;
+ else
+ {
+ Is64Bit = true;
+ // here we test high 32-bit of possible UInt64 CBlockHeader::Offset field
+ for (int k = 0; k < 8; k++)
+ if (GetUi32(p1 + 4 + 12 * k + 4) != 0)
+ Is64Bit = false;
+ }
+
+ const unsigned bhoSize = Is64Bit ? 12 : 8;
+ if (_size < 4 + bhoSize * 8)
+ return S_FALSE;
+
+ CBlockHeader bhEntries, bhStrings, bhLangTables;
+
+ PARSE_BH (2, bhEntries);
+ PARSE_BH (3, bhStrings);
+ PARSE_BH (4, bhLangTables);
+
+ #ifdef NSIS_SCRIPT
+
+ CBlockHeader bhFont;
+ PARSE_BH (0, bhPages);
+ PARSE_BH (1, bhSections);
+ PARSE_BH (5, bhCtlColors);
+ PARSE_BH (6, bhFont);
+ PARSE_BH (7, bhData);
+
+ #endif
+
+ _stringsPos = bhStrings.Offset;
+ if (_stringsPos > _size
+ || bhLangTables.Offset > _size
+ || bhEntries.Offset > _size)
+ return S_FALSE;
+ {
+ if (bhLangTables.Offset < bhStrings.Offset)
+ return S_FALSE;
+ const UInt32 stringTableSize = bhLangTables.Offset - bhStrings.Offset;
+ if (stringTableSize < 2)
+ return S_FALSE;
+ const Byte *strData = _data + _stringsPos;
+ if (strData[stringTableSize - 1] != 0)
+ return S_FALSE;
+ IsUnicode = (Get16(strData) == 0);
+ NumStringChars = stringTableSize;
+ if (IsUnicode)
+ {
+ if ((stringTableSize & 1) != 0)
+ return S_FALSE;
+ NumStringChars >>= 1;
+ if (strData[stringTableSize - 2] != 0)
+ return S_FALSE;
+ }
+ }
+
+ if (bhEntries.Num > (1 << 25))
+ return S_FALSE;
+ if (bhEntries.Num * kCmdSize > _size - bhEntries.Offset)
+ return S_FALSE;
+
+ DetectNsisType(bhEntries, _data + bhEntries.Offset);
+
+ Decoder.IsNsisDeflate = (NsisType != k_NsisType_Nsis3);
+
+ // some NSIS files (that are not detected as k_NsisType_Nsis3)
+ // use original (non-NSIS) Deflate
+ // How to detect these cases?
+
+ // Decoder.IsNsisDeflate = false;
+
+
+ #ifdef NSIS_SCRIPT
+
+ {
+ AddCommentAndString("NSIS script");
+ if (IsUnicode)
+ Script += " (UTF-8)";
+ Space();
+ Script += GetFormatDescription();
+ AddLF();
+ }
+ {
+ AddCommentAndString(IsInstaller ? "Install" : "Uninstall");
+ AddLF();
+ }
+
+ AddLF();
+ if (Is64Bit)
+ AddStringLF("Target AMD64-Unicode"); // TODO: Read PE machine type and use the correct CPU type
+ else if (IsUnicode)
+ AddStringLF("Unicode true");
+ else if (IsNsis3_OrHigher())
+ AddStringLF("Unicode false"); // Unicode is the default in 3.07+
+
+ if (Method != NMethodType::kCopy)
+ {
+ const char *m = NULL;
+ switch ((int)Method)
+ {
+ case NMethodType::kDeflate: m = "zlib"; break;
+ case NMethodType::kBZip2: m = "bzip2"; break;
+ case NMethodType::kLZMA: m = "lzma"; break;
+ default: break;
+ }
+ Script += "SetCompressor";
+ if (IsSolid)
+ Script += " /SOLID";
+ if (m)
+ {
+ Space();
+ Script += m;
+ }
+ AddLF();
+ }
+ if (Method == NMethodType::kLZMA)
+ {
+ // if (DictionarySize != (8 << 20))
+ {
+ Script += "SetCompressorDictSize";
+ AddParam_UInt(DictionarySize >> 20);
+ AddLF();
+ }
+ }
+
+ Separator();
+ PrintNumComment("HEADER SIZE", FirstHeader.HeaderSize);
+ // if (bhPages.Offset != 300 && bhPages.Offset != 288)
+ if (bhPages.Offset != 0)
+ {
+ PrintNumComment("START HEADER SIZE", bhPages.Offset);
+ }
+
+ if (bhSections.Num > 0)
+ {
+ if (bhEntries.Offset < bhSections.Offset)
+ return S_FALSE;
+ SectionSize = (bhEntries.Offset - bhSections.Offset) / bhSections.Num;
+ if (bhSections.Offset + bhSections.Num * SectionSize != bhEntries.Offset)
+ return S_FALSE;
+ if (SectionSize < kSectionSize_base)
+ return S_FALSE;
+ UInt32 maxStringLen = SectionSize - kSectionSize_base;
+ if (IsUnicode)
+ {
+ if ((maxStringLen & 1) != 0)
+ return S_FALSE;
+ maxStringLen >>= 1;
+ }
+ // if (maxStringLen != 1024)
+ {
+ if (maxStringLen == 0)
+ PrintNumComment("SECTION SIZE", SectionSize);
+ else
+ PrintNumComment("MAX STRING LENGTH", maxStringLen);
+ }
+ }
+
+ PrintNumComment("STRING CHARS", NumStringChars);
+ // PrintNumComment("LANG TABLE SIZE", bhCtlColors.Offset - bhLangTables.Offset);
+
+ if (bhCtlColors.Offset > _size)
+ AddErrorLF("Bad COLORS TABLE");
+ // PrintNumComment("COLORS TABLE SIZE", bhFont.Offset - bhCtlColors.Offset);
+ if (bhCtlColors.Num != 0)
+ PrintNumComment("COLORS Num", bhCtlColors.Num);
+
+ // bhData uses offset in _afterHeader (not in _data)
+ // PrintNumComment("FONT TABLE SIZE", bhData.Offset - bhFont.Offset);
+ if (bhFont.Num != 0)
+ PrintNumComment("FONTS Num", bhFont.Num);
+
+ // PrintNumComment("DATA SIZE", FirstHeader.HeaderSize - bhData.Offset);
+ if (bhData.Num != 0)
+ PrintNumComment("DATA NUM", bhData.Num);
+
+ AddLF();
+
+ AddStringLF("OutFile [NSIS].exe");
+ AddStringLF("!include WinMessages.nsh");
+
+ AddLF();
+
+ strUsed.Alloc(NumStringChars);
+ memset(strUsed, 0, NumStringChars);
+
+ {
+ UInt32 ehFlags = Get32(p1);
+ UInt32 showDetails = ehFlags & 3;// CH_FLAGS_DETAILS_SHOWDETAILS & CH_FLAGS_DETAILS_NEVERSHOW;
+ if (showDetails >= 1 && showDetails <= 2)
+ {
+ Script += IsInstaller ? "ShowInstDetails" : "ShowUninstDetails";
+ Script += (showDetails == 1) ? " show" : " nevershow";
+ AddLF();
+ }
+ if (ehFlags & CH_FLAGS_PROGRESS_COLORED) AddStringLF("InstProgressFlags colored" );
+ if ((ehFlags & (CH_FLAGS_SILENT | CH_FLAGS_SILENT_LOG)) != 0)
+ {
+ Script += IsInstaller ? "SilentInstall " : "SilentUnInstall ";
+ Script += (ehFlags & CH_FLAGS_SILENT_LOG) ? "silentlog" : "silent";
+ AddLF();
+ }
+ if (ehFlags & CH_FLAGS_AUTO_CLOSE) AddStringLF("AutoCloseWindow true");
+ if ((ehFlags & CH_FLAGS_NO_ROOT_DIR) == 0) AddStringLF("AllowRootDirInstall true");
+ if (ehFlags & CH_FLAGS_NO_CUSTOM) AddStringLF("InstType /NOCUSTOM");
+ if (ehFlags & CH_FLAGS_COMP_ONLY_ON_CUSTOM) AddStringLF("InstType /COMPONENTSONLYONCUSTOM");
+ }
+
+ // Separator();
+ // AddLF();
+
+ Int32 licenseLangIndex = -1;
+ {
+ const Byte *pp = _data + bhPages.Offset;
+
+ for (UInt32 pageIndex = 0; pageIndex < bhPages.Num; pageIndex++, pp += kPageSize)
+ {
+ UInt32 wndProcID = Get32(pp + 4);
+ UInt32 param1 = Get32(pp + 44 + 4 * 1);
+ if (wndProcID != PWP_LICENSE || param1 == 0)
+ continue;
+ if ((Int32)param1 < 0)
+ licenseLangIndex = - ((Int32)param1 + 1);
+ else
+ noParseStringIndexes.AddToUniqueSorted(param1);
+ }
+ }
+
+ unsigned paramsOffset;
+ {
+ unsigned numBhs = 8;
+ // probably its for old NSIS?
+ if (bhoSize == 8 && bhPages.Offset == 276)
+ numBhs = 7;
+ paramsOffset = 4 + bhoSize * numBhs;
+ }
+
+ const Byte *p2 = p1 + paramsOffset;
+
+ {
+ UInt32 rootKey = Get32(p2); // (rootKey = -1) in uninstaller by default (the bug in NSIS)
+ UInt32 subKey = Get32(p2 + 4);
+ UInt32 value = Get32(p2 + 8);
+ if ((rootKey != 0 && rootKey != (UInt32)(Int32)-1) || subKey != 0 || value != 0)
+ {
+ Script += "InstallDirRegKey";
+ AddRegRoot(rootKey);
+ AddParam(subKey);
+ AddParam(value);
+ AddLF();
+ }
+ }
+
+
+ {
+ UInt32 bg_color1 = Get32(p2 + 12);
+ UInt32 bg_color2 = Get32(p2 + 16);
+ UInt32 bg_textcolor = Get32(p2 + 20);
+ if (bg_color1 != (UInt32)(Int32)-1 || bg_color2 != (UInt32)(Int32)-1 || bg_textcolor != (UInt32)(Int32)-1)
+ {
+ Script += "BGGradient";
+ if (bg_color1 != 0 || bg_color2 != 0xFF0000 || bg_textcolor != (UInt32)(Int32)-1)
+ {
+ Add_ColorParam(bg_color1);
+ Add_ColorParam(bg_color2);
+ if (bg_textcolor != (UInt32)(Int32)-1)
+ Add_ColorParam(bg_textcolor);
+ }
+ AddLF();
+ }
+ }
+
+ {
+ UInt32 lb_bg = Get32(p2 + 24);
+ UInt32 lb_fg = Get32(p2 + 28);
+ if ((lb_bg != (UInt32)(Int32)-1 || lb_fg != (UInt32)(Int32)-1) &&
+ (lb_bg != 0 || lb_fg != 0xFF00))
+ {
+ Script += "InstallColors";
+ Add_ColorParam(lb_fg);
+ Add_ColorParam(lb_bg);
+ AddLF();
+ }
+ }
+
+ UInt32 license_bg = Get32(p2 + 36);
+ if (license_bg != (UInt32)(Int32)-1 &&
+ license_bg != (UInt32)(Int32)-15) // COLOR_BTNFACE
+ {
+ Script += "LicenseBkColor";
+ if ((Int32)license_bg == -5) // COLOR_WINDOW
+ Script += " /windows";
+ /*
+ else if ((Int32)license_bg == -15)
+ Script += " /grey";
+ */
+ else
+ Add_ColorParam(license_bg);
+ AddLF();
+ }
+
+ if (bhLangTables.Num > 0)
+ {
+ const UInt32 langtable_size = Get32(p2 + 32);
+
+ if (langtable_size == (UInt32)(Int32)-1)
+ return E_NOTIMPL; // maybe it's old NSIS archive()
+
+ if (langtable_size < 10)
+ return S_FALSE;
+ if (bhLangTables.Num > (_size - bhLangTables.Offset) / langtable_size)
+ return S_FALSE;
+
+ const UInt32 numStrings = (langtable_size - 10) / 4;
+ _numLangStrings = numStrings;
+ AddLF();
+ Separator();
+ PrintNumComment("LANG TABLES", bhLangTables.Num);
+ PrintNumComment("LANG STRINGS", numStrings);
+ AddLF();
+
+ if (licenseLangIndex >= 0 && (unsigned)licenseLangIndex < numStrings)
+ {
+ for (UInt32 i = 0; i < bhLangTables.Num; i++)
+ {
+ const Byte * const p = _data + bhLangTables.Offset + langtable_size * i;
+ const UInt16 langID = Get16(p);
+ UInt32 val = Get32(p + 10 + (UInt32)licenseLangIndex * 4);
+ if (val != 0)
+ {
+ Script += "LicenseLangString ";
+ Add_LangStr_Simple((UInt32)licenseLangIndex);
+ AddParam_UInt(langID);
+ AddLicense(val, langID);
+ noParseStringIndexes.AddToUniqueSorted(val);
+ NewLine();
+ }
+ }
+ AddLF();
+ }
+
+ UInt32 names[3] = { 0 };
+
+ UInt32 i;
+ for (i = 0; i < bhLangTables.Num; i++)
+ {
+ const Byte * const p = _data + bhLangTables.Offset + langtable_size * i;
+ const UInt16 langID = Get16(p);
+ if (i == 0 || langID == 1033)
+ _mainLang = p + 10;
+ for (unsigned k = 0; k < Z7_ARRAY_SIZE(names) && k < numStrings; k++)
+ {
+ UInt32 v = Get32(p + 10 + k * 4);
+ if (v != 0 && (langID == 1033 || names[k] == 0))
+ names[k] = v;
+ }
+ }
+
+ const UInt32 name = names[2];
+ if (name != 0)
+ {
+ Script += "Name";
+ AddParam(name);
+ NewLine();
+
+ ReadString2(Name, name);
+ }
+
+ /*
+ const UInt32 caption = names[1];
+ if (caption != 0)
+ {
+ Script += "Caption";
+ AddParam(caption);
+ NewLine();
+ }
+ */
+
+ const UInt32 brandingText = names[0];
+ if (brandingText != 0)
+ {
+ Script += "BrandingText";
+ AddParam(brandingText);
+ NewLine();
+
+ ReadString2(BrandingText, brandingText);
+ }
+
+ for (i = 0; i < bhLangTables.Num; i++)
+ {
+ const Byte * const p = _data + bhLangTables.Offset + langtable_size * i;
+ const UInt16 langID = Get16(p);
+
+ AddLF();
+ AddCommentAndString("LANG:");
+ AddParam_UInt(langID);
+ /*
+ Script += " (";
+ LangId_To_String(Script, langID);
+ Script += ')';
+ */
+ AddLF();
+ // UInt32 dlg_offset = Get32(p + 2);
+ // UInt32 g_exec_flags_rtl = Get32(p + 6);
+
+
+ for (UInt32 j = 0; j < numStrings; j++)
+ {
+ UInt32 val = Get32(p + 10 + j * 4);
+ if (val != 0)
+ {
+ if ((Int32)j != licenseLangIndex)
+ {
+ Script += "LangString ";
+ Add_LangStr_Simple(j);
+ AddParam_UInt(langID);
+ AddParam(val);
+ AddLF();
+ }
+ }
+ }
+ AddLF();
+ }
+ ClearLangComment();
+ }
+
+ {
+ unsigned numInternalVars = GET_NUM_INTERNAL_VARS;
+ UInt32 numUsedVars = GetNumUsedVars();
+ if (numUsedVars > numInternalVars)
+ {
+ Separator();
+ PrintNumComment("VARIABLES", numUsedVars - numInternalVars);
+ AddLF();
+ AString temp;
+ for (UInt32 i = numInternalVars; i < numUsedVars; i++)
+ {
+ Script += "Var ";
+ temp.Empty();
+ GetVar2(temp, i);
+ AddStringLF(temp);
+ }
+ AddLF();
+ }
+ }
+
+ onFuncOffset = paramsOffset + 40;
+ numOnFunc = Z7_ARRAY_SIZE(kOnFunc);
+ if (bhPages.Offset == 276)
+ numOnFunc--;
+ p2 += 40 + numOnFunc * 4;
+
+ #define NSIS_MAX_INST_TYPES 32
+
+ AddLF();
+
+ UInt32 i;
+ for (i = 0; i < NSIS_MAX_INST_TYPES + 1; i++, p2 += 4)
+ {
+ UInt32 instType = Get32(p2);
+ if (instType != 0)
+ {
+ Script += "InstType";
+ AString s2;
+ if (!IsInstaller)
+ s2 += "un.";
+ ReadString2(s2, instType);
+ SpaceQuStr(s2);
+ NewLine();
+ }
+ }
+
+ {
+ UInt32 installDir = Get32(p2);
+ p2 += 4;
+ if (installDir != 0)
+ {
+ Script += "InstallDir";
+ AddParam(installDir);
+ NewLine();
+ }
+ }
+
+ if (bhPages.Offset >= 288)
+ for (i = 0; i < 4; i++)
+ {
+ if (i != 0 && bhPages.Offset < 300)
+ break;
+ UInt32 param = Get32(p2 + 4 * i);
+ if (param == 0 || param == (UInt32)(Int32)-1)
+ continue;
+
+ /*
+ uninstaller:
+ UInt32 uninstChild = Get32(p2 + 8); // "$TEMP\\$1u_.exe"
+ UInt32 uninstCmd = Get32(p2 + 12); // "\"$TEMP\\$1u_.exe\" $0 _?=$INSTDIR\\"
+ int str_wininit = Get32(p2 + 16); // "$WINDIR\\wininit.ini"
+ */
+
+ AddCommentAndString(k_PostStrings[i]);
+ Script += " =";
+ AddParam(param);
+ NewLine();
+ }
+
+ AddLF();
+
+ #endif
+
+ RINOK(ReadEntries(bhEntries))
+
+ #ifdef NSIS_SCRIPT
+
+ Separator();
+ AddCommentAndString("UNREFERENCED STRINGS:");
+ AddLF();
+ AddLF();
+ CommentOpen();
+
+ for (i = 0; i < NumStringChars;)
+ {
+ if (!strUsed[i] && i != 0)
+ // Script += "!!! ";
+ {
+ Add_UInt(i);
+ AddParam(i);
+ NewLine();
+ }
+ if (IsUnicode)
+ i += GetUi16Str_Len((const Byte *)_data + _stringsPos + i * 2);
+ else
+ i += (UInt32)strlen((const char *)(const Byte *)_data + _stringsPos + i);
+ i++;
+ }
+ CommentClose();
+ #endif
+
+ return SortItems();
+}
+
+static bool IsLZMA(const Byte *p, UInt32 &dictionary)
+{
+ dictionary = Get32(p + 1);
+ return (p[0] == 0x5D &&
+ p[1] == 0x00 && p[2] == 0x00 &&
+ p[5] == 0x00 && (p[6] & 0x80) == 0x00);
+}
+
+static bool IsLZMA(const Byte *p, UInt32 &dictionary, bool &thereIsFlag)
+{
+ if (IsLZMA(p, dictionary))
+ {
+ thereIsFlag = false;
+ return true;
+ }
+ if (p[0] <= 1 && IsLZMA(p + 1, dictionary))
+ {
+ thereIsFlag = true;
+ return true;
+ }
+ return false;
+}
+
+static bool IsBZip2(const Byte *p)
+{
+ return (p[0] == 0x31 && p[1] < 14);
+}
+
+HRESULT CInArchive::Open2(const Byte *sig, size_t size)
+{
+ const UInt32 kSigSize = 4 + 1 + 5 + 2; // size, flag, 5 - lzma props, 2 - lzma first bytes
+ if (size < kSigSize)
+ return S_FALSE;
+
+ _headerIsCompressed = true;
+ IsSolid = true;
+ FilterFlag = false;
+ UseFilter = false;
+ DictionarySize = 1;
+
+ #ifdef NSIS_SCRIPT
+ AfterHeaderSize = 0;
+ #endif
+
+ UInt32 compressedHeaderSize = Get32(sig);
+
+
+ /*
+ XX XX XX XX XX XX XX XX == FirstHeader.HeaderSize, nonsolid, uncompressed
+ 5D 00 00 dd dd 00 solid LZMA
+ 00 5D 00 00 dd dd 00 solid LZMA, empty filter (there are no such archives)
+ 01 5D 00 00 dd dd 00 solid LZMA, BCJ filter (only 7-Zip installer used that format)
+
+ SS SS SS 80 00 5D 00 00 dd dd 00 non-solid LZMA, empty filter
+ SS SS SS 80 01 5D 00 00 dd dd 00 non-solid LZMA, BCJ filte
+ SS SS SS 80 01 tt non-solid BZip (tt < 14
+ SS SS SS 80 non-solid deflate
+
+ 01 tt solid BZip (tt < 14
+ other solid Deflate
+ */
+
+ if (compressedHeaderSize == FirstHeader.HeaderSize)
+ {
+ _headerIsCompressed = false;
+ IsSolid = false;
+ Method = NMethodType::kCopy;
+ }
+ else if (IsLZMA(sig, DictionarySize, FilterFlag))
+ Method = NMethodType::kLZMA;
+ else if (sig[3] == 0x80)
+ {
+ IsSolid = false;
+ if (IsLZMA(sig + 4, DictionarySize, FilterFlag) && sig[3] == 0x80)
+ Method = NMethodType::kLZMA;
+ else if (IsBZip2(sig + 4))
+ Method = NMethodType::kBZip2;
+ else
+ Method = NMethodType::kDeflate;
+ }
+ else if (IsBZip2(sig))
+ Method = NMethodType::kBZip2;
+ else
+ Method = NMethodType::kDeflate;
+
+ if (IsSolid)
+ {
+ RINOK(SeekTo_DataStreamOffset())
+ }
+ else
+ {
+ _headerIsCompressed = ((compressedHeaderSize & kMask_IsCompressed) != 0);
+ compressedHeaderSize &= ~kMask_IsCompressed;
+ _nonSolidStartOffset = compressedHeaderSize;
+ RINOK(SeekTo(DataStreamOffset + 4))
+ }
+
+ if (FirstHeader.HeaderSize == 0)
+ return S_FALSE;
+
+ _data.Alloc(FirstHeader.HeaderSize);
+ _size = (size_t)FirstHeader.HeaderSize;
+
+ Decoder.Method = Method;
+ Decoder.FilterFlag = FilterFlag;
+ Decoder.Solid = IsSolid;
+
+ Decoder.IsNsisDeflate = true; // we need some smart check that NSIS is not NSIS3 here.
+
+ Decoder.InputStream = _stream;
+ Decoder.Buffer.Alloc(kInputBufSize);
+ Decoder.StreamPos = 0;
+
+ if (_headerIsCompressed)
+ {
+ RINOK(Decoder.Init(_stream, UseFilter))
+ if (IsSolid)
+ {
+ size_t processedSize = 4;
+ Byte buf[4];
+ RINOK(Decoder.Read(buf, &processedSize))
+ if (processedSize != 4)
+ return S_FALSE;
+ if (Get32((const Byte *)buf) != FirstHeader.HeaderSize)
+ return S_FALSE;
+ }
+ {
+ size_t processedSize = FirstHeader.HeaderSize;
+ RINOK(Decoder.Read(_data, &processedSize))
+ if (processedSize != FirstHeader.HeaderSize)
+ return S_FALSE;
+ }
+
+ #ifdef NSIS_SCRIPT
+ if (IsSolid)
+ {
+ /* we need additional bytes for data for WriteRegBin */
+ AfterHeaderSize = (1 << 12);
+ _afterHeader.Alloc(AfterHeaderSize);
+ size_t processedSize = AfterHeaderSize;
+ RINOK(Decoder.Read(_afterHeader, &processedSize))
+ AfterHeaderSize = (UInt32)processedSize;
+ }
+ #endif
+ }
+ else
+ {
+ size_t processedSize = FirstHeader.HeaderSize;
+ RINOK(ReadStream(_stream, (Byte *)_data, &processedSize))
+ if (processedSize < FirstHeader.HeaderSize)
+ return S_FALSE;
+ }
+
+ #ifdef NUM_SPEED_TESTS
+ for (unsigned i = 0; i < NUM_SPEED_TESTS; i++)
+ {
+ RINOK(Parse());
+ Clear2();
+ }
+ #endif
+
+ return Parse();
+}
+
+/*
+NsisExe =
+{
+ ExeStub
+ Archive // must start from 512 * N
+ #ifndef NSIS_CONFIG_CRC_ANAL
+ {
+ Some additional data
+ }
+}
+
+Archive
+{
+ FirstHeader
+ Data
+ #ifdef NSIS_CONFIG_CRC_SUPPORT && FirstHeader.ThereIsCrc()
+ {
+ CRC
+ }
+}
+
+FirstHeader
+{
+ UInt32 Flags;
+ Byte Signature[16];
+ // points to the header+sections+entries+stringtable in the datablock
+ UInt32 HeaderSize;
+ UInt32 ArcSize;
+}
+*/
+
+
+// ---------- PE (EXE) parsing ----------
+
+static const unsigned k_PE_StartSize = 0x40;
+static const unsigned k_PE_HeaderSize = 4 + 20;
+static const unsigned k_PE_OptHeader32_Size_MIN = 96;
+
+static inline bool CheckPeOffset(UInt32 pe)
+{
+ return (pe >= 0x40 && pe <= 0x1000 && (pe & 7) == 0);
+}
+
+
+static bool IsArc_Pe(const Byte *p, size_t size)
+{
+ if (size < 2)
+ return false;
+ if (p[0] != 'M' || p[1] != 'Z')
+ return false;
+ if (size < k_PE_StartSize)
+ return false; // k_IsArc_Res_NEED_MORE;
+ UInt32 pe = Get32(p + 0x3C);
+ if (!CheckPeOffset(pe))
+ return false;
+ if (pe + k_PE_HeaderSize > size)
+ return false; // k_IsArc_Res_NEED_MORE;
+
+ p += pe;
+ if (Get32(p) != 0x00004550)
+ return false;
+ return Get16(p + 4 + 16) >= k_PE_OptHeader32_Size_MIN;
+}
+
+HRESULT CInArchive::Open(IInStream *inStream, const UInt64 *maxCheckStartPosition)
+{
+ Clear();
+
+ RINOK(InStream_GetPos(inStream, StartOffset))
+
+ const UInt32 kStartHeaderSize = 4 * 7;
+ const unsigned kStep = 512; // nsis start is aligned for 512
+ Byte buf[kStep];
+ UInt64 pos = StartOffset;
+ size_t bufSize = 0;
+ UInt64 pePos = (UInt64)(Int64)-1;
+
+ for (;;)
+ {
+ bufSize = kStep;
+ RINOK(ReadStream(inStream, buf, &bufSize))
+ if (bufSize < kStartHeaderSize)
+ return S_FALSE;
+ if (memcmp(buf + 4, kSignature, kSignatureSize) == 0)
+ break;
+ if (IsArc_Pe(buf, bufSize))
+ pePos = pos;
+ pos += kStep;
+ UInt64 proc = pos - StartOffset;
+ if (maxCheckStartPosition && proc > *maxCheckStartPosition)
+ {
+ if (pePos == 0)
+ {
+ if (proc > (1 << 20))
+ return S_FALSE;
+ }
+ else
+ return S_FALSE;
+ }
+ }
+
+ if (pePos == (UInt64)(Int64)-1)
+ {
+ UInt64 posCur = StartOffset;
+ for (;;)
+ {
+ if (posCur < kStep)
+ break;
+ posCur -= kStep;
+ if (pos - posCur > (1 << 20))
+ break;
+ bufSize = kStep;
+ RINOK(InStream_SeekSet(inStream, posCur))
+ RINOK(ReadStream(inStream, buf, &bufSize))
+ if (bufSize < kStep)
+ break;
+ if (IsArc_Pe(buf, bufSize))
+ {
+ pePos = posCur;
+ break;
+ }
+ }
+
+ // restore buf to nsis header
+ bufSize = kStep;
+ RINOK(InStream_SeekSet(inStream, pos))
+ RINOK(ReadStream(inStream, buf, &bufSize))
+ if (bufSize < kStartHeaderSize)
+ return S_FALSE;
+ }
+
+ StartOffset = pos;
+ UInt32 peSize = 0;
+
+ if (pePos != (UInt64)(Int64)-1)
+ {
+ UInt64 peSize64 = (pos - pePos);
+ if (peSize64 < (1 << 20))
+ {
+ peSize = (UInt32)peSize64;
+ StartOffset = pePos;
+ }
+ }
+
+ DataStreamOffset = pos + kStartHeaderSize;
+ FirstHeader.Flags = Get32(buf);
+ if ((FirstHeader.Flags & (~kFlagsMask)) != 0)
+ {
+ // return E_NOTIMPL;
+ return S_FALSE;
+ }
+ IsInstaller = (FirstHeader.Flags & NFlags::kUninstall) == 0;
+
+ FirstHeader.HeaderSize = Get32(buf + kSignatureSize + 4);
+ FirstHeader.ArcSize = Get32(buf + kSignatureSize + 8);
+ if (FirstHeader.ArcSize <= kStartHeaderSize)
+ return S_FALSE;
+
+ /*
+ if ((FirstHeader.Flags & NFlags::k_BI_ExternalFileSupport) != 0)
+ {
+ UInt32 datablock_low = Get32(buf + kSignatureSize + 12);
+ UInt32 datablock_high = Get32(buf + kSignatureSize + 16);
+ }
+ */
+
+ RINOK(InStream_GetSize_SeekToEnd(inStream, _fileSize))
+
+ IsArc = true;
+
+ if (peSize != 0)
+ {
+ ExeStub.Alloc(peSize);
+ RINOK(InStream_SeekSet(inStream, pePos))
+ RINOK(ReadStream_FALSE(inStream, ExeStub, peSize))
+ }
+
+ HRESULT res = S_FALSE;
+ try
+ {
+ CLimitedInStream *_limitedStreamSpec = new CLimitedInStream;
+ _stream = _limitedStreamSpec;
+ _limitedStreamSpec->SetStream(inStream);
+ _limitedStreamSpec->InitAndSeek(pos, FirstHeader.ArcSize);
+ DataStreamOffset -= pos;
+ res = Open2(buf + kStartHeaderSize, bufSize - kStartHeaderSize);
+ }
+ catch(...)
+ {
+ _stream.Release();
+ throw;
+ // res = S_FALSE;
+ }
+ if (res != S_OK)
+ {
+ _stream.Release();
+ // Clear();
+ }
+ return res;
+}
+
+UString CInArchive::ConvertToUnicode(const AString &s) const
+{
+ if (IsUnicode)
+ {
+ UString res;
+ // if (
+ ConvertUTF8ToUnicode(s, res);
+ return res;
+ }
+ return MultiByteToUnicodeString(s);
+}
+
+void CInArchive::Clear2()
+{
+ IsUnicode = false;
+ NsisType = k_NsisType_Nsis2;
+ IsNsis225 = false;
+ IsNsis200 = false;
+ LogCmdIsEnabled = false;
+ BadCmd = -1;
+ Is64Bit = false;
+
+ #ifdef NSIS_SCRIPT
+ Name.Empty();
+ BrandingText.Empty();
+ Script.Empty();
+ LicenseFiles.Clear();
+ _numRootLicenses = 0;
+ _numLangStrings = 0;
+ langStrIDs.Clear();
+ LangComment.Empty();
+ noParseStringIndexes.Clear();
+ #endif
+
+ APrefixes.Clear();
+ UPrefixes.Clear();
+ Items.Clear();
+ IsUnicode = false;
+ ExeStub.Free();
+}
+
+void CInArchive::Clear()
+{
+ Clear2();
+ IsArc = false;
+ _stream.Release();
+}
+
+}}
diff --git a/CPP/7zip/Archive/Nsis/NsisIn.h b/CPP/7zip/Archive/Nsis/NsisIn.h
new file mode 100644
index 0000000..bb8de62
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisIn.h
@@ -0,0 +1,458 @@
+// NsisIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_NSIS_IN_H
+#define ZIP7_INC_ARCHIVE_NSIS_IN_H
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/DynLimBuf.h"
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyCom.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "NsisDecode.h"
+
+/* If NSIS_SCRIPT is defined, it will decompile NSIS script to [NSIS].nsi file.
+ The code is much larger in that case. */
+
+// #define NSIS_SCRIPT
+
+namespace NArchive {
+namespace NNsis {
+
+const size_t kScriptSizeLimit = 1 << 27;
+
+const unsigned kSignatureSize = 16;
+extern const Byte kSignature[kSignatureSize];
+#define NSIS_SIGNATURE { 0xEF, 0xBE, 0xAD, 0xDE, 'N', 'u', 'l', 'l', 's', 'o', 'f', 't', 'I', 'n', 's', 't' }
+
+const UInt32 kFlagsMask = 0xF;
+namespace NFlags
+{
+ const UInt32 kUninstall = 1;
+ const UInt32 kSilent = 2;
+ const UInt32 kNoCrc = 4;
+ const UInt32 kForceCrc = 8;
+ // NSISBI fork flags:
+ const UInt32 k_BI_LongOffset = 16;
+ const UInt32 k_BI_ExternalFileSupport = 32;
+ const UInt32 k_BI_ExternalFile = 64;
+ const UInt32 k_BI_IsStubInstaller = 128;
+}
+
+struct CFirstHeader
+{
+ UInt32 Flags;
+ UInt32 HeaderSize;
+ UInt32 ArcSize;
+
+ bool ThereIsCrc() const
+ {
+ return
+ (Flags & NFlags::kForceCrc) != 0 ||
+ (Flags & NFlags::kNoCrc) == 0;
+ }
+
+ UInt32 GetDataSize() const { return ArcSize - (ThereIsCrc() ? 4 : 0); }
+};
+
+
+struct CBlockHeader
+{
+ UInt32 Offset;
+ UInt32 Num;
+
+ void Parse(const Byte *p, unsigned bhoSize);
+};
+
+struct CItem
+{
+ bool IsEmptyFile;
+ bool IsCompressed;
+ bool Size_Defined;
+ bool CompressedSize_Defined;
+ bool EstimatedSize_Defined;
+ bool Attrib_Defined;
+ bool IsUninstaller;
+ // bool UseFilter;
+
+ UInt32 Attrib;
+ UInt32 Pos; // = 0, if (IsEmptyFile == true)
+ UInt32 Size;
+ UInt32 CompressedSize;
+ UInt32 EstimatedSize;
+ UInt32 DictionarySize;
+ UInt32 PatchSize; // for Uninstaller.exe
+ int Prefix; // - 1 means no prefix
+
+ FILETIME MTime;
+ AString NameA;
+ UString NameU;
+
+ bool Is_PatchedUninstaller() const { return PatchSize != 0; }
+
+ CItem():
+ IsEmptyFile(false),
+ IsCompressed(true),
+ Size_Defined(false),
+ CompressedSize_Defined(false),
+ EstimatedSize_Defined(false),
+ Attrib_Defined(false),
+ IsUninstaller(false),
+ // UseFilter(false),
+ Attrib(0),
+ Pos(0),
+ Size(0),
+ CompressedSize(0),
+ EstimatedSize(0),
+ DictionarySize(1),
+ PatchSize(0),
+ Prefix(-1)
+ {
+ MTime.dwLowDateTime = 0;
+ MTime.dwHighDateTime = 0;
+ }
+
+ /*
+ bool IsINSTDIR() const
+ {
+ return (PrefixA.Len() >= 3 || PrefixU.Len() >= 3);
+ }
+ */
+};
+
+enum ENsisType
+{
+ k_NsisType_Nsis2,
+ k_NsisType_Nsis3,
+ k_NsisType_Park1, // Park 2.46.1-
+ k_NsisType_Park2, // Park 2.46.2 : GetFontVersion
+ k_NsisType_Park3 // Park 2.46.3+ : GetFontName
+};
+
+#ifdef NSIS_SCRIPT
+
+struct CSection
+{
+ UInt32 InstallTypes; // bits set for each of the different install_types, if any.
+ UInt32 Flags; // SF_* - defined above
+ UInt32 StartCmdIndex; // code;
+ UInt32 NumCommands; // code_size;
+ UInt32 SizeKB;
+ UInt32 Name;
+
+ void Parse(const Byte *data);
+};
+
+struct CLicenseFile
+{
+ UInt32 Offset;
+ UInt32 Size;
+ AString Name;
+ CByteBuffer Text;
+};
+
+#endif
+
+class CInArchive
+{
+public:
+ #ifdef NSIS_SCRIPT
+ CDynLimBuf Script;
+ #endif
+ CByteBuffer _data;
+ CObjectVector<CItem> Items;
+ bool IsUnicode;
+ bool Is64Bit;
+private:
+ UInt32 _stringsPos; // relative to _data
+ UInt32 NumStringChars;
+ size_t _size; // it's Header Size
+
+ AString Raw_AString;
+ UString Raw_UString;
+
+ ENsisType NsisType;
+ bool IsNsis200; // NSIS 2.03 and before
+ bool IsNsis225; // NSIS 2.25 and before
+ bool LogCmdIsEnabled;
+ int BadCmd; // -1: no bad command; in another cases lowest bad command id
+
+ bool IsPark() const { return NsisType >= k_NsisType_Park1; }
+ bool IsNsis3_OrHigher() const { return NsisType == k_NsisType_Nsis3; }
+
+ UInt64 _fileSize;
+
+ bool _headerIsCompressed;
+ UInt32 _nonSolidStartOffset;
+
+ #ifdef NSIS_SCRIPT
+
+ CByteBuffer strUsed;
+
+ CBlockHeader bhPages;
+ CBlockHeader bhSections;
+ CBlockHeader bhCtlColors;
+ CBlockHeader bhData;
+ UInt32 AfterHeaderSize;
+ CByteBuffer _afterHeader;
+
+ UInt32 SectionSize;
+ const Byte *_mainLang;
+ UInt32 _numLangStrings;
+ AString LangComment;
+ CRecordVector<UInt32> langStrIDs;
+ UInt32 numOnFunc;
+ UInt32 onFuncOffset;
+ // CRecordVector<UInt32> OnFuncs;
+ unsigned _numRootLicenses;
+ CRecordVector<UInt32> noParseStringIndexes;
+ AString _tempString_for_GetVar;
+ AString _tempString_for_AddFuncName;
+ AString _tempString;
+
+ #endif
+
+
+public:
+ CMyComPtr<IInStream> _stream; // it's limited stream that contains only NSIS archive
+ UInt64 StartOffset; // offset in original stream.
+ UInt64 DataStreamOffset; // = sizeof(FirstHeader) = offset of Header in _stream
+
+ bool IsArc;
+
+ CDecoder Decoder;
+ CByteBuffer ExeStub;
+ CFirstHeader FirstHeader;
+ NMethodType::EEnum Method;
+ UInt32 DictionarySize;
+ bool IsSolid;
+ bool UseFilter;
+ bool FilterFlag;
+
+ bool IsInstaller;
+ AString Name;
+ AString BrandingText;
+ UStringVector UPrefixes;
+ AStringVector APrefixes;
+
+ #ifdef NSIS_SCRIPT
+ CObjectVector<CLicenseFile> LicenseFiles;
+ #endif
+
+private:
+ void GetShellString(AString &s, unsigned index1, unsigned index2);
+ void GetNsisString_Raw(const Byte *s);
+ void GetNsisString_Unicode_Raw(const Byte *s);
+ void ReadString2_Raw(UInt32 pos);
+ bool IsGoodString(UInt32 param) const;
+ bool AreTwoParamStringsEqual(UInt32 param1, UInt32 param2) const;
+
+ void Add_LangStr(AString &res, UInt32 id);
+
+ #ifdef NSIS_SCRIPT
+
+ void Add_UInt(UInt32 v);
+ void AddLicense(UInt32 param, Int32 langID);
+
+ void Add_LangStr_Simple(UInt32 id);
+ void Add_FuncName(const UInt32 *labels, UInt32 index);
+ void AddParam_Func(const UInt32 *labels, UInt32 index);
+ void Add_LabelName(UInt32 index);
+
+ void Add_Color2(UInt32 v);
+ void Add_ColorParam(UInt32 v);
+ void Add_Color(UInt32 index);
+
+ void Add_ButtonID(UInt32 buttonID);
+
+ void Add_ShowWindow_Cmd(UInt32 cmd);
+ void Add_TypeFromList(const char * const *table, unsigned tableSize, UInt32 type);
+ void Add_ExecFlags(UInt32 flagsType);
+ void Add_SectOp(UInt32 opType);
+
+ void Add_Var(UInt32 index);
+ void AddParam_Var(UInt32 value);
+ void AddParam_UInt(UInt32 value);
+
+ void Add_GotoVar(UInt32 param);
+ void Add_GotoVar1(UInt32 param);
+ void Add_GotoVars2(const UInt32 *params);
+
+
+
+ bool PrintSectionBegin(const CSection §, unsigned index);
+ void PrintSectionEnd();
+
+ void GetNsisString(AString &res, const Byte *s);
+ void GetNsisString_Unicode(AString &res, const Byte *s);
+ UInt32 GetNumUsedVars() const;
+ void ReadString2(AString &s, UInt32 pos);
+
+ void MessageBox_MB_Part(UInt32 param);
+ void AddParam(UInt32 pos);
+ void AddOptionalParam(UInt32 pos);
+ void AddParams(const UInt32 *params, unsigned num);
+ void AddPageOption1(UInt32 param, const char *name);
+ void AddPageOption(const UInt32 *params, unsigned num, const char *name);
+ void AddOptionalParams(const UInt32 *params, unsigned num);
+ void AddRegRoot(UInt32 value);
+
+
+ void ClearLangComment();
+ void Separator();
+ void Space();
+ void Tab();
+ void Tab(bool commented);
+ void BigSpaceComment();
+ void SmallSpaceComment();
+ void AddCommentAndString(const char *s);
+ void AddError(const char *s);
+ void AddErrorLF(const char *s);
+ void CommentOpen();
+ void CommentClose();
+ void AddLF();
+ void AddQuotes();
+ void TabString(const char *s);
+ void AddStringLF(const char *s);
+ void NewLine();
+ void PrintNumComment(const char *name, UInt32 value);
+ void Add_QuStr(const AString &s);
+ void SpaceQuStr(const AString &s);
+ bool CompareCommands(const Byte *rawCmds, const Byte *sequence, size_t numCommands);
+
+ #endif
+
+ #ifdef NSIS_SCRIPT
+ unsigned GetNumSupportedCommands() const;
+ #endif
+
+ UInt32 GetCmd(UInt32 a);
+ void FindBadCmd(const CBlockHeader &bh, const Byte *);
+ void DetectNsisType(const CBlockHeader &bh, const Byte *);
+
+ HRESULT ReadEntries(const CBlockHeader &bh);
+ HRESULT SortItems();
+ HRESULT Parse();
+ HRESULT Open2(const Byte *data, size_t size);
+ void Clear2();
+
+ void GetVar2(AString &res, UInt32 index);
+ void GetVar(AString &res, UInt32 index);
+ Int32 GetVarIndex(UInt32 strPos) const;
+ Int32 GetVarIndex(UInt32 strPos, UInt32 &resOffset) const;
+ Int32 GetVarIndexFinished(UInt32 strPos, Byte endChar, UInt32 &resOffset) const;
+ bool IsVarStr(UInt32 strPos, UInt32 varIndex) const;
+ bool IsAbsolutePathVar(UInt32 strPos) const;
+ void SetItemName(CItem &item, UInt32 strPos);
+
+public:
+ HRESULT Open(IInStream *inStream, const UInt64 *maxCheckStartPosition);
+ AString GetFormatDescription() const;
+ HRESULT InitDecoder()
+ {
+ bool useFilter;
+ return Decoder.Init(_stream, useFilter);
+ }
+
+ HRESULT SeekTo(UInt64 pos)
+ {
+ return InStream_SeekSet(_stream, pos);
+ }
+
+ HRESULT SeekTo_DataStreamOffset()
+ {
+ return SeekTo(DataStreamOffset);
+ }
+
+ HRESULT SeekToNonSolidItem(unsigned index)
+ {
+ return SeekTo(GetPosOfNonSolidItem(index));
+ }
+
+ void Clear();
+
+ bool IsDirectString_Equal(UInt32 offset, const char *s) const;
+ /*
+ UInt64 GetDataPos(unsigned index)
+ {
+ const CItem &item = Items[index];
+ return GetOffset() + FirstHeader.HeaderSize + item.Pos;
+ }
+ */
+
+ UInt64 GetPosOfSolidItem(unsigned index) const
+ {
+ const CItem &item = Items[index];
+ return 4 + (UInt64)FirstHeader.HeaderSize + item.Pos;
+ }
+
+ UInt64 GetPosOfNonSolidItem(unsigned index) const
+ {
+ const CItem &item = Items[index];
+ return DataStreamOffset + _nonSolidStartOffset + 4 + item.Pos;
+ }
+
+ void Release()
+ {
+ Decoder.Release();
+ }
+
+ bool IsTruncated() const { return (_fileSize - StartOffset < FirstHeader.ArcSize); }
+
+ UString GetReducedName(unsigned index) const
+ {
+ const CItem &item = Items[index];
+
+ UString s;
+ if (item.Prefix >= 0)
+ {
+ if (IsUnicode)
+ s = UPrefixes[item.Prefix];
+ else
+ s = MultiByteToUnicodeString(APrefixes[item.Prefix]);
+ if (s.Len() > 0)
+ if (s.Back() != L'\\')
+ s += '\\';
+ }
+
+ if (IsUnicode)
+ {
+ s += item.NameU;
+ if (item.NameU.IsEmpty())
+ s += "file";
+ }
+ else
+ {
+ s += MultiByteToUnicodeString(item.NameA);
+ if (item.NameA.IsEmpty())
+ s += "file";
+ }
+
+ const char * const kRemoveStr = "$INSTDIR\\";
+ if (s.IsPrefixedBy_Ascii_NoCase(kRemoveStr))
+ {
+ s.Delete(0, MyStringLen(kRemoveStr));
+ if (s[0] == L'\\')
+ s.DeleteFrontal(1);
+ }
+ if (item.Is_PatchedUninstaller() && ExeStub.Size() == 0)
+ s += ".nsis";
+ return s;
+ }
+
+ UString ConvertToUnicode(const AString &s) const;
+
+ CInArchive()
+ #ifdef NSIS_SCRIPT
+ : Script(kScriptSizeLimit)
+ #endif
+ {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Nsis/NsisRegister.cpp b/CPP/7zip/Archive/Nsis/NsisRegister.cpp
new file mode 100644
index 0000000..a500381
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/NsisRegister.cpp
@@ -0,0 +1,20 @@
+// NsisRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "NsisHandler.h"
+
+namespace NArchive {
+namespace NNsis {
+
+REGISTER_ARC_I(
+ "Nsis", "nsis", NULL, 0x9,
+ kSignature,
+ 4,
+ NArcInfoFlags::kFindSignature |
+ NArcInfoFlags::kUseGlobalOffset,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Nsis/StdAfx.h b/CPP/7zip/Archive/Nsis/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Nsis/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/NtfsHandler.cpp b/CPP/7zip/Archive/NtfsHandler.cpp
new file mode 100644
index 0000000..c13e0ca
--- /dev/null
+++ b/CPP/7zip/Archive/NtfsHandler.cpp
@@ -0,0 +1,2861 @@
+// NtfsHandler.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+// #define SHOW_DEBUG_INFO2
+
+#if defined(SHOW_DEBUG_INFO) || defined(SHOW_DEBUG_INFO2)
+#include <stdio.h>
+#endif
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/MethodProps.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/DummyOutStream.h"
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#define PRF_UTF16(x) PRF(printf("%S", x))
+#else
+#define PRF(x)
+#define PRF_UTF16(x)
+#endif
+
+#ifdef SHOW_DEBUG_INFO2
+#define PRF2(x) x
+#else
+#define PRF2(x)
+#endif
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G16(p, dest) dest = Get16(p)
+#define G32(p, dest) dest = Get32(p)
+#define G64(p, dest) dest = Get64(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace Ntfs {
+
+static const wchar_t * const kVirtualFolder_System = L"[SYSTEM]";
+static const wchar_t * const kVirtualFolder_Lost_Normal = L"[LOST]";
+static const wchar_t * const kVirtualFolder_Lost_Deleted = L"[UNKNOWN]";
+
+static const unsigned kNumSysRecs = 16;
+
+static const unsigned kRecIndex_Volume = 3;
+static const unsigned kRecIndex_RootDir = 5;
+static const unsigned kRecIndex_BadClus = 8;
+static const unsigned kRecIndex_Security = 9;
+
+struct CHeader
+{
+ unsigned SectorSizeLog;
+ unsigned ClusterSizeLog;
+ // Byte MediaType;
+ UInt32 NumHiddenSectors;
+ UInt64 NumSectors;
+ UInt64 NumClusters;
+ UInt64 MftCluster;
+ UInt64 SerialNumber;
+ UInt16 SectorsPerTrack;
+ UInt16 NumHeads;
+
+ UInt64 GetPhySize_Clusters() const { return NumClusters << ClusterSizeLog; }
+ UInt64 GetPhySize_Max() const { return (NumSectors + 1) << SectorSizeLog; }
+ UInt32 ClusterSize() const { return (UInt32)1 << ClusterSizeLog; }
+ bool Parse(const Byte *p);
+};
+
+static int GetLog(UInt32 num)
+{
+ for (int i = 0; i < 31; i++)
+ if (((UInt32)1 << i) == num)
+ return i;
+ return -1;
+}
+
+bool CHeader::Parse(const Byte *p)
+{
+ if (p[0x1FE] != 0x55 || p[0x1FF] != 0xAA)
+ return false;
+
+ // int codeOffset = 0;
+ switch (p[0])
+ {
+ case 0xE9: /* codeOffset = 3 + (Int16)Get16(p + 1); */ break;
+ case 0xEB: if (p[2] != 0x90) return false; /* codeOffset = 2 + (int)(signed char)p[1]; */ break;
+ default: return false;
+ }
+ unsigned sectorsPerClusterLog;
+
+ if (memcmp(p + 3, "NTFS ", 8) != 0)
+ return false;
+ {
+ int t = GetLog(Get16(p + 11));
+ if (t < 9 || t > 12)
+ return false;
+ SectorSizeLog = (unsigned)t;
+ t = GetLog(p[13]);
+ if (t < 0)
+ return false;
+ sectorsPerClusterLog = (unsigned)t;
+ ClusterSizeLog = SectorSizeLog + sectorsPerClusterLog;
+ if (ClusterSizeLog > 30)
+ return false;
+ }
+
+ for (int i = 14; i < 21; i++)
+ if (p[i] != 0)
+ return false;
+
+ if (p[21] != 0xF8) // MediaType = Fixed_Disk
+ return false;
+ if (Get16(p + 22) != 0) // NumFatSectors
+ return false;
+ G16(p + 24, SectorsPerTrack); // 63 usually
+ G16(p + 26, NumHeads); // 255
+ G32(p + 28, NumHiddenSectors); // 63 (XP) / 2048 (Vista and win7) / (0 on media that are not partitioned ?)
+ if (Get32(p + 32) != 0) // NumSectors32
+ return false;
+
+ // DriveNumber = p[0x24];
+ if (p[0x25] != 0) // CurrentHead
+ return false;
+ /*
+ NTFS-HDD: p[0x26] = 0x80
+ NTFS-FLASH: p[0x26] = 0
+ */
+ if (p[0x26] != 0x80 && p[0x26] != 0) // ExtendedBootSig
+ return false;
+ if (p[0x27] != 0) // reserved
+ return false;
+
+ NumSectors = Get64(p + 0x28);
+ if (NumSectors >= ((UInt64)1 << (62 - SectorSizeLog)))
+ return false;
+
+ NumClusters = NumSectors >> sectorsPerClusterLog;
+
+ G64(p + 0x30, MftCluster);
+ // G64(p + 0x38, Mft2Cluster);
+ G64(p + 0x48, SerialNumber);
+ UInt32 numClustersInMftRec;
+ UInt32 numClustersInIndexBlock;
+ G32(p + 0x40, numClustersInMftRec); // -10 means 2 ^10 = 1024 bytes.
+ G32(p + 0x44, numClustersInIndexBlock);
+ return (numClustersInMftRec < 256 && numClustersInIndexBlock < 256);
+}
+
+struct CMftRef
+{
+ UInt64 Val;
+
+ UInt64 GetIndex() const { return Val & (((UInt64)1 << 48) - 1); }
+ UInt16 GetNumber() const { return (UInt16)(Val >> 48); }
+ bool IsBaseItself() const { return Val == 0; }
+
+ CMftRef(): Val(0) {}
+};
+
+#define ATNAME(n) ATTR_TYPE_ ## n
+#define DEF_ATTR_TYPE(v, n) ATNAME(n) = v
+
+enum
+{
+ DEF_ATTR_TYPE(0x00, UNUSED),
+ DEF_ATTR_TYPE(0x10, STANDARD_INFO),
+ DEF_ATTR_TYPE(0x20, ATTRIBUTE_LIST),
+ DEF_ATTR_TYPE(0x30, FILE_NAME),
+ DEF_ATTR_TYPE(0x40, OBJECT_ID),
+ DEF_ATTR_TYPE(0x50, SECURITY_DESCRIPTOR),
+ DEF_ATTR_TYPE(0x60, VOLUME_NAME),
+ DEF_ATTR_TYPE(0x70, VOLUME_INFO),
+ DEF_ATTR_TYPE(0x80, DATA),
+ DEF_ATTR_TYPE(0x90, INDEX_ROOT),
+ DEF_ATTR_TYPE(0xA0, INDEX_ALLOCATION),
+ DEF_ATTR_TYPE(0xB0, BITMAP),
+ DEF_ATTR_TYPE(0xC0, REPARSE_POINT),
+ DEF_ATTR_TYPE(0xD0, EA_INFO),
+ DEF_ATTR_TYPE(0xE0, EA),
+ DEF_ATTR_TYPE(0xF0, PROPERTY_SET),
+ DEF_ATTR_TYPE(0x100, LOGGED_UTILITY_STREAM),
+ DEF_ATTR_TYPE(0x1000, FIRST_USER_DEFINED_ATTRIBUTE)
+};
+
+
+/* WinXP-64:
+ Probably only one short name (dos name) per record is allowed.
+ There are no short names for hard links.
+ The pair (Win32,Dos) can be in any order.
+ Posix name can be after or before Win32 name
+*/
+
+// static const Byte kFileNameType_Posix = 0; // for hard links
+static const Byte kFileNameType_Win32 = 1; // after Dos name
+static const Byte kFileNameType_Dos = 2; // short name
+static const Byte kFileNameType_Win32Dos = 3; // short and full name are same
+
+struct CFileNameAttr
+{
+ CMftRef ParentDirRef;
+
+ // Probably these timestamps don't contain some useful timestamps. So we don't use them
+ // UInt64 CTime;
+ // UInt64 MTime;
+ // UInt64 ThisRecMTime; // xp-64: the time of previous name change (not last name change. why?)
+ // UInt64 ATime;
+ // UInt64 AllocatedSize;
+ // UInt64 DataSize;
+ // UInt16 PackedEaSize;
+ UString2 Name;
+ UInt32 Attrib;
+ Byte NameType;
+
+ bool IsDos() const { return NameType == kFileNameType_Dos; }
+ bool IsWin32() const { return (NameType == kFileNameType_Win32); }
+
+ bool Parse(const Byte *p, unsigned size);
+
+ CFileNameAttr():
+ Attrib(0),
+ NameType(0)
+ {}
+};
+
+static void GetString(const Byte *p, unsigned len, UString2 &res)
+{
+ if (len == 0 && res.IsEmpty())
+ return;
+ wchar_t *s = res.GetBuf(len);
+ unsigned i;
+ for (i = 0; i < len; i++)
+ {
+ wchar_t c = Get16(p + i * 2);
+ if (c == 0)
+ break;
+ s[i] = c;
+ }
+ s[i] = 0;
+ res.ReleaseBuf_SetLen(i);
+}
+
+bool CFileNameAttr::Parse(const Byte *p, unsigned size)
+{
+ if (size < 0x42)
+ return false;
+ G64(p + 0x00, ParentDirRef.Val);
+ // G64(p + 0x08, CTime);
+ // G64(p + 0x10, MTime);
+ // G64(p + 0x18, ThisRecMTime);
+ // G64(p + 0x20, ATime);
+ // G64(p + 0x28, AllocatedSize);
+ // G64(p + 0x30, DataSize);
+ G32(p + 0x38, Attrib);
+ // G16(p + 0x3C, PackedEaSize);
+ NameType = p[0x41];
+ unsigned len = p[0x40];
+ if (0x42 + len > size)
+ return false;
+ if (len != 0)
+ GetString(p + 0x42, len, Name);
+ return true;
+}
+
+struct CSiAttr
+{
+ UInt64 CTime;
+ UInt64 MTime;
+ UInt64 ThisRecMTime;
+ UInt64 ATime;
+ UInt32 Attrib;
+
+ /*
+ UInt32 MaxVersions;
+ UInt32 Version;
+ UInt32 ClassId;
+ UInt32 OwnerId;
+ */
+ UInt32 SecurityId; // SecurityId = 0 is possible ?
+ // UInt64 QuotaCharged;
+
+ bool Parse(const Byte *p, unsigned size);
+
+ CSiAttr():
+ CTime(0),
+ MTime(0),
+ ThisRecMTime(0),
+ ATime(0),
+ Attrib(0),
+ SecurityId(0)
+ {}
+};
+
+
+bool CSiAttr::Parse(const Byte *p, unsigned size)
+{
+ if (size < 0x24)
+ return false;
+ G64(p + 0x00, CTime);
+ G64(p + 0x08, MTime);
+ G64(p + 0x10, ThisRecMTime);
+ G64(p + 0x18, ATime);
+ G32(p + 0x20, Attrib);
+ SecurityId = 0;
+ if (size >= 0x38)
+ G32(p + 0x34, SecurityId);
+ return true;
+}
+
+static const UInt64 kEmptyExtent = (UInt64)(Int64)-1;
+
+struct CExtent
+{
+ UInt64 Virt;
+ UInt64 Phy;
+
+ bool IsEmpty() const { return Phy == kEmptyExtent; }
+};
+
+struct CVolInfo
+{
+ Byte MajorVer;
+ Byte MinorVer;
+ // UInt16 Flags;
+
+ bool Parse(const Byte *p, unsigned size);
+};
+
+bool CVolInfo::Parse(const Byte *p, unsigned size)
+{
+ if (size < 12)
+ return false;
+ MajorVer = p[8];
+ MinorVer = p[9];
+ // Flags = Get16(p + 10);
+ return true;
+}
+
+struct CAttr
+{
+ UInt32 Type;
+
+ Byte NonResident;
+
+ // Non-Resident
+ Byte CompressionUnit;
+
+ // UInt32 Len;
+ UString2 Name;
+ // UInt16 Flags;
+ // UInt16 Instance;
+ CByteBuffer Data;
+
+ // Non-Resident
+ UInt64 LowVcn;
+ UInt64 HighVcn;
+ UInt64 AllocatedSize;
+ UInt64 Size;
+ UInt64 PackSize;
+ UInt64 InitializedSize;
+
+ // Resident
+ // UInt16 ResidentFlags;
+
+ bool IsCompressionUnitSupported() const { return CompressionUnit == 0 || CompressionUnit == 4; }
+
+ UInt32 Parse(const Byte *p, unsigned size);
+ bool ParseFileName(CFileNameAttr &a) const { return a.Parse(Data, (unsigned)Data.Size()); }
+ bool ParseSi(CSiAttr &a) const { return a.Parse(Data, (unsigned)Data.Size()); }
+ bool ParseVolInfo(CVolInfo &a) const { return a.Parse(Data, (unsigned)Data.Size()); }
+ bool ParseExtents(CRecordVector<CExtent> &extents, UInt64 numClustersMax, unsigned compressionUnit) const;
+ UInt64 GetSize() const { return NonResident ? Size : Data.Size(); }
+ UInt64 GetPackSize() const
+ {
+ if (!NonResident)
+ return Data.Size();
+ if (CompressionUnit != 0)
+ return PackSize;
+ return AllocatedSize;
+ }
+};
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+static int CompareAttr(void *const *elem1, void *const *elem2, void *)
+{
+ const CAttr &a1 = *(*((const CAttr *const *)elem1));
+ const CAttr &a2 = *(*((const CAttr *const *)elem2));
+ RINOZ(MyCompare(a1.Type, a2.Type))
+ if (a1.Name.IsEmpty())
+ {
+ if (!a2.Name.IsEmpty())
+ return -1;
+ }
+ else if (a2.Name.IsEmpty())
+ return 1;
+ else
+ {
+ RINOZ(a1.Name.Compare(a2.Name.GetRawPtr()))
+ }
+ return MyCompare(a1.LowVcn, a2.LowVcn);
+}
+
+UInt32 CAttr::Parse(const Byte *p, unsigned size)
+{
+ if (size < 4)
+ return 0;
+ G32(p, Type);
+ if (Type == 0xFFFFFFFF)
+ return 8; // required size is 4, but attributes are 8 bytes aligned. So we return 8
+ if (size < 0x18)
+ return 0;
+
+ PRF(printf(" T=%2X", Type));
+
+ UInt32 len = Get32(p + 4);
+ PRF(printf(" L=%3d", len));
+ if (len > size)
+ return 0;
+ if ((len & 7) != 0)
+ return 0;
+ NonResident = p[8];
+ {
+ unsigned nameLen = p[9];
+ UInt32 nameOffset = Get16(p + 0x0A);
+ if (nameLen != 0)
+ {
+ if (nameOffset + nameLen * 2 > len)
+ return 0;
+ GetString(p + nameOffset, nameLen, Name);
+ PRF(printf(" N="));
+ PRF_UTF16(Name);
+ }
+ }
+
+ // G16(p + 0x0C, Flags);
+ // G16(p + 0x0E, Instance);
+ // PRF(printf(" F=%4X", Flags));
+ // PRF(printf(" Inst=%d", Instance));
+
+ UInt32 dataSize;
+ UInt32 offs;
+
+ if (NonResident)
+ {
+ if (len < 0x40)
+ return 0;
+ PRF(printf(" NR"));
+ G64(p + 0x10, LowVcn);
+ G64(p + 0x18, HighVcn);
+ G64(p + 0x28, AllocatedSize);
+ G64(p + 0x30, Size);
+ G64(p + 0x38, InitializedSize);
+ G16(p + 0x20, offs);
+ CompressionUnit = p[0x22];
+
+ PackSize = Size;
+ if (CompressionUnit != 0)
+ {
+ if (len < 0x48)
+ return 0;
+ G64(p + 0x40, PackSize);
+ PRF(printf(" PS=%I64x", PackSize));
+ }
+
+ // PRF(printf("\n"));
+ PRF(printf(" ASize=%4I64d", AllocatedSize));
+ PRF(printf(" Size=%I64d", Size));
+ PRF(printf(" IS=%I64d", InitializedSize));
+ PRF(printf(" Low=%I64d", LowVcn));
+ PRF(printf(" High=%I64d", HighVcn));
+ PRF(printf(" CU=%d", (unsigned)CompressionUnit));
+ dataSize = len - offs;
+ }
+ else
+ {
+ if (len < 0x18)
+ return 0;
+ G32(p + 0x10, dataSize);
+ G16(p + 0x14, offs);
+ // G16(p + 0x16, ResidentFlags);
+ PRF(printf(" RES"));
+ PRF(printf(" dataSize=%3d", dataSize));
+ // PRF(printf(" ResFlags=%4X", ResidentFlags));
+ }
+
+ if (offs > len || dataSize > len || len - dataSize < offs)
+ return 0;
+
+ Data.CopyFrom(p + offs, dataSize);
+
+ #ifdef SHOW_DEBUG_INFO
+ PRF(printf(" : "));
+ for (unsigned i = 0; i < Data.Size(); i++)
+ {
+ PRF(printf(" %02X", (unsigned)Data[i]));
+ }
+ #endif
+
+ return len;
+}
+
+
+bool CAttr::ParseExtents(CRecordVector<CExtent> &extents, UInt64 numClustersMax, unsigned compressionUnit) const
+{
+ const Byte *p = Data;
+ unsigned size = (unsigned)Data.Size();
+ UInt64 vcn = LowVcn;
+ UInt64 lcn = 0;
+ const UInt64 highVcn1 = HighVcn + 1;
+
+ if (LowVcn != extents.Back().Virt || highVcn1 > (UInt64)1 << 63)
+ return false;
+
+ extents.DeleteBack();
+
+ PRF2(printf("\n# ParseExtents # LowVcn = %4I64X # HighVcn = %4I64X", LowVcn, HighVcn));
+
+ while (size > 0)
+ {
+ Byte b = *p++;
+ size--;
+ if (b == 0)
+ break;
+ UInt32 num = b & 0xF;
+ if (num == 0 || num > 8 || num > size)
+ return false;
+
+ UInt64 vSize = 0;
+ {
+ unsigned i = num;
+ do vSize = (vSize << 8) | p[--i]; while (i);
+ }
+ if (vSize == 0)
+ return false;
+ p += num;
+ size -= num;
+ if ((highVcn1 - vcn) < vSize)
+ return false;
+
+ CExtent e;
+ e.Virt = vcn;
+ vcn += vSize;
+
+ num = (b >> 4) & 0xF;
+ if (num > 8 || num > size)
+ return false;
+
+ if (num == 0)
+ {
+ // Sparse
+
+ /* if Unit is compressed, it can have many Elements for each compressed Unit:
+ and last Element for unit MUST be without LCN.
+ Element 0: numCompressedClusters2, LCN_0
+ Element 1: numCompressedClusters2, LCN_1
+ ...
+ Last Element : (16 - total_clusters_in_previous_elements), no LCN
+ */
+
+ // sparse is not allowed for (compressionUnit == 0) ? Why ?
+ if (compressionUnit == 0)
+ return false;
+
+ e.Phy = kEmptyExtent;
+ }
+ else
+ {
+ Int64 v = (signed char)p[num - 1];
+ {
+ for (unsigned i = num - 1; i != 0;)
+ v = (v << 8) | p[--i];
+ }
+ p += num;
+ size -= num;
+ lcn = (UInt64)((Int64)lcn + v);
+ if (lcn > numClustersMax)
+ return false;
+ e.Phy = lcn;
+ }
+
+ extents.Add(e);
+ }
+
+ CExtent e;
+ e.Phy = kEmptyExtent;
+ e.Virt = vcn;
+ extents.Add(e);
+ return (highVcn1 == vcn);
+}
+
+
+static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
+
+static const unsigned kNumCacheChunksLog = 1;
+static const size_t kNumCacheChunks = (size_t)1 << kNumCacheChunksLog;
+
+Z7_CLASS_IMP_COM_1(
+ CInStream
+ , IInStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ UInt64 _virtPos;
+ UInt64 _physPos;
+ UInt64 _curRem;
+ bool _sparseMode;
+public:
+ bool InUse;
+private:
+ unsigned _chunkSizeLog;
+ CByteBuffer _inBuf;
+ CByteBuffer _outBuf;
+public:
+ UInt64 Size;
+ UInt64 InitializedSize;
+ unsigned BlockSizeLog;
+ unsigned CompressionUnit;
+ CRecordVector<CExtent> Extents;
+ CMyComPtr<IInStream> Stream;
+private:
+ UInt64 _tags[kNumCacheChunks];
+
+ HRESULT SeekToPhys() { return InStream_SeekSet(Stream, _physPos); }
+ UInt32 GetCuSize() const { return (UInt32)1 << (BlockSizeLog + CompressionUnit); }
+public:
+ HRESULT InitAndSeek(unsigned compressionUnit)
+ {
+ CompressionUnit = compressionUnit;
+ _chunkSizeLog = BlockSizeLog + CompressionUnit;
+ if (compressionUnit != 0)
+ {
+ UInt32 cuSize = GetCuSize();
+ _inBuf.Alloc(cuSize);
+ _outBuf.Alloc(kNumCacheChunks << _chunkSizeLog);
+ }
+ for (size_t i = 0; i < kNumCacheChunks; i++)
+ _tags[i] = kEmptyTag;
+
+ _sparseMode = false;
+ _curRem = 0;
+ _virtPos = 0;
+ _physPos = 0;
+ const CExtent &e = Extents[0];
+ if (!e.IsEmpty())
+ _physPos = e.Phy << BlockSizeLog;
+ return SeekToPhys();
+ }
+};
+
+static size_t Lznt1Dec(Byte *dest, size_t outBufLim, size_t destLen, const Byte *src, size_t srcLen)
+{
+ size_t destSize = 0;
+ while (destSize < destLen)
+ {
+ if (srcLen < 2 || (destSize & 0xFFF) != 0)
+ break;
+ UInt32 comprSize;
+ {
+ const UInt32 v = Get16(src);
+ if (v == 0)
+ break;
+ src += 2;
+ srcLen -= 2;
+ comprSize = (v & 0xFFF) + 1;
+ if (comprSize > srcLen)
+ break;
+ srcLen -= comprSize;
+ if ((v & 0x8000) == 0)
+ {
+ if (comprSize != (1 << 12))
+ break;
+ memcpy(dest + destSize, src, comprSize);
+ src += comprSize;
+ destSize += comprSize;
+ continue;
+ }
+ }
+ {
+ if (destSize + (1 << 12) > outBufLim || (src[0] & 1) != 0)
+ return 0;
+ unsigned numDistBits = 4;
+ UInt32 sbOffset = 0;
+ UInt32 pos = 0;
+
+ do
+ {
+ comprSize--;
+ for (UInt32 mask = src[pos++] | 0x100; mask > 1 && comprSize > 0; mask >>= 1)
+ {
+ if ((mask & 1) == 0)
+ {
+ if (sbOffset >= (1 << 12))
+ return 0;
+ dest[destSize++] = src[pos++];
+ sbOffset++;
+ comprSize--;
+ }
+ else
+ {
+ if (comprSize < 2)
+ return 0;
+ const UInt32 v = Get16(src + pos);
+ pos += 2;
+ comprSize -= 2;
+
+ while (((sbOffset - 1) >> numDistBits) != 0)
+ numDistBits++;
+
+ UInt32 len = (v & (0xFFFF >> numDistBits)) + 3;
+ if (sbOffset + len > (1 << 12))
+ return 0;
+ UInt32 dist = (v >> (16 - numDistBits));
+ if (dist >= sbOffset)
+ return 0;
+ const size_t offs = 1 + dist;
+ Byte *p = dest + destSize - offs;
+ destSize += len;
+ sbOffset += len;
+ const Byte *lim = p + len;
+ p[offs] = *p; ++p;
+ p[offs] = *p; ++p;
+ do
+ p[offs] = *p;
+ while (++p != lim);
+ }
+ }
+ }
+ while (comprSize > 0);
+ src += pos;
+ }
+ }
+ return destSize;
+}
+
+Z7_COM7F_IMF(CInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= Size)
+ return (Size == _virtPos) ? S_OK: E_FAIL;
+ if (size == 0)
+ return S_OK;
+ {
+ const UInt64 rem = Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ if (_virtPos >= InitializedSize)
+ {
+ memset((Byte *)data, 0, size);
+ _virtPos += size;
+ *processedSize = size;
+ return S_OK;
+ }
+
+ {
+ const UInt64 rem = InitializedSize - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ while (_curRem == 0)
+ {
+ const UInt64 cacheTag = _virtPos >> _chunkSizeLog;
+ const size_t cacheIndex = (size_t)cacheTag & (kNumCacheChunks - 1);
+
+ if (_tags[cacheIndex] == cacheTag)
+ {
+ const size_t chunkSize = (size_t)1 << _chunkSizeLog;
+ const size_t offset = (size_t)_virtPos & (chunkSize - 1);
+ size_t cur = chunkSize - offset;
+ if (cur > size)
+ cur = size;
+ memcpy(data, _outBuf + (cacheIndex << _chunkSizeLog) + offset, cur);
+ *processedSize = (UInt32)cur;
+ _virtPos += cur;
+ return S_OK;
+ }
+
+ PRF2(printf("\nVirtPos = %6d", _virtPos));
+
+ const UInt32 comprUnitSize = (UInt32)1 << CompressionUnit;
+ const UInt64 virtBlock = _virtPos >> BlockSizeLog;
+ const UInt64 virtBlock2 = virtBlock & ~((UInt64)comprUnitSize - 1);
+
+ unsigned left = 0, right = Extents.Size();
+ for (;;)
+ {
+ unsigned mid = (left + right) / 2;
+ if (mid == left)
+ break;
+ if (virtBlock2 < Extents[mid].Virt)
+ right = mid;
+ else
+ left = mid;
+ }
+
+ bool isCompressed = false;
+ const UInt64 virtBlock2End = virtBlock2 + comprUnitSize;
+ if (CompressionUnit != 0)
+ for (unsigned i = left; i < Extents.Size(); i++)
+ {
+ const CExtent &e = Extents[i];
+ if (e.Virt >= virtBlock2End)
+ break;
+ if (e.IsEmpty())
+ {
+ isCompressed = true;
+ break;
+ }
+ }
+
+ unsigned i;
+ for (i = left; Extents[i + 1].Virt <= virtBlock; i++);
+
+ _sparseMode = false;
+ if (!isCompressed)
+ {
+ const CExtent &e = Extents[i];
+ UInt64 newPos = (e.Phy << BlockSizeLog) + _virtPos - (e.Virt << BlockSizeLog);
+ if (newPos != _physPos)
+ {
+ _physPos = newPos;
+ RINOK(SeekToPhys())
+ }
+ UInt64 next = Extents[i + 1].Virt;
+ if (next > virtBlock2End)
+ next &= ~((UInt64)comprUnitSize - 1);
+ next <<= BlockSizeLog;
+ if (next > Size)
+ next = Size;
+ _curRem = next - _virtPos;
+ break;
+ }
+
+ bool thereArePhy = false;
+
+ for (unsigned i2 = left; i2 < Extents.Size(); i2++)
+ {
+ const CExtent &e = Extents[i2];
+ if (e.Virt >= virtBlock2End)
+ break;
+ if (!e.IsEmpty())
+ {
+ thereArePhy = true;
+ break;
+ }
+ }
+
+ if (!thereArePhy)
+ {
+ _curRem = (Extents[i + 1].Virt << BlockSizeLog) - _virtPos;
+ _sparseMode = true;
+ break;
+ }
+
+ size_t offs = 0;
+ UInt64 curVirt = virtBlock2;
+
+ for (i = left; i < Extents.Size(); i++)
+ {
+ const CExtent &e = Extents[i];
+ if (e.IsEmpty())
+ break;
+ if (e.Virt >= virtBlock2End)
+ return S_FALSE;
+ const UInt64 newPos = (e.Phy + (curVirt - e.Virt)) << BlockSizeLog;
+ if (newPos != _physPos)
+ {
+ _physPos = newPos;
+ RINOK(SeekToPhys())
+ }
+ UInt64 numChunks = Extents[i + 1].Virt - curVirt;
+ if (curVirt + numChunks > virtBlock2End)
+ numChunks = virtBlock2End - curVirt;
+ const size_t compressed = (size_t)numChunks << BlockSizeLog;
+ RINOK(ReadStream_FALSE(Stream, _inBuf + offs, compressed))
+ curVirt += numChunks;
+ _physPos += compressed;
+ offs += compressed;
+ }
+
+ const size_t destLenMax = GetCuSize();
+ size_t destLen = destLenMax;
+ const UInt64 rem = Size - (virtBlock2 << BlockSizeLog);
+ if (destLen > rem)
+ destLen = (size_t)rem;
+
+ Byte *dest = _outBuf + (cacheIndex << _chunkSizeLog);
+ const size_t destSizeRes = Lznt1Dec(dest, destLenMax, destLen, _inBuf, offs);
+ _tags[cacheIndex] = cacheTag;
+
+ // some files in Vista have destSize > destLen
+ if (destSizeRes < destLen)
+ {
+ memset(dest, 0, destLenMax);
+ if (InUse)
+ return S_FALSE;
+ }
+ }
+
+ if (size > _curRem)
+ size = (UInt32)_curRem;
+ HRESULT res = S_OK;
+ if (_sparseMode)
+ memset(data, 0, size);
+ else
+ {
+ res = Stream->Read(data, size, &size);
+ _physPos += size;
+ }
+ if (processedSize)
+ *processedSize = size;
+ _virtPos += size;
+ _curRem -= size;
+ return res;
+}
+
+Z7_COM7F_IMF(CInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ if (_virtPos != (UInt64)offset)
+ {
+ _curRem = 0;
+ _virtPos = (UInt64)offset;
+ }
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+static HRESULT DataParseExtents(unsigned clusterSizeLog, const CObjectVector<CAttr> &attrs,
+ unsigned attrIndex, unsigned attrIndexLim, UInt64 numPhysClusters, CRecordVector<CExtent> &Extents)
+{
+ {
+ CExtent e;
+ e.Virt = 0;
+ e.Phy = kEmptyExtent;
+ Extents.Add(e);
+ }
+
+ const CAttr &attr0 = attrs[attrIndex];
+
+ /*
+ if (attrs[attrIndexLim - 1].HighVcn + 1 != (attr0.AllocatedSize >> clusterSizeLog))
+ {
+ }
+ */
+
+ if (attr0.AllocatedSize < attr0.Size ||
+ (attrs[attrIndexLim - 1].HighVcn + 1) != (attr0.AllocatedSize >> clusterSizeLog) ||
+ (attr0.AllocatedSize & ((1 << clusterSizeLog) - 1)) != 0)
+ return S_FALSE;
+
+ for (unsigned i = attrIndex; i < attrIndexLim; i++)
+ if (!attrs[i].ParseExtents(Extents, numPhysClusters, attr0.CompressionUnit))
+ return S_FALSE;
+
+ UInt64 packSizeCalc = 0;
+ FOR_VECTOR (k, Extents)
+ {
+ CExtent &e = Extents[k];
+ if (!e.IsEmpty())
+ packSizeCalc += (Extents[k + 1].Virt - e.Virt) << clusterSizeLog;
+ PRF2(printf("\nSize = %4I64X", Extents[k + 1].Virt - e.Virt));
+ PRF2(printf(" Pos = %4I64X", e.Phy));
+ }
+
+ if (attr0.CompressionUnit != 0)
+ {
+ if (packSizeCalc != attr0.PackSize)
+ return S_FALSE;
+ }
+ else
+ {
+ if (packSizeCalc != attr0.AllocatedSize)
+ return S_FALSE;
+ }
+ return S_OK;
+}
+
+struct CDataRef
+{
+ unsigned Start;
+ unsigned Num;
+};
+
+static const UInt32 kMagic_FILE = 0x454C4946;
+static const UInt32 kMagic_BAAD = 0x44414142;
+
+// 22.02: we support some rare case magic values:
+static const UInt32 kMagic_INDX = 0x58444e49;
+static const UInt32 kMagic_HOLE = 0x454c4f48;
+static const UInt32 kMagic_RSTR = 0x52545352;
+static const UInt32 kMagic_RCRD = 0x44524352;
+static const UInt32 kMagic_CHKD = 0x444b4843;
+static const UInt32 kMagic_FFFFFFFF = 0xFFFFFFFF;
+
+
+struct CMftRec
+{
+ UInt32 Magic;
+ // UInt64 Lsn;
+ UInt16 SeqNumber; // Number of times this mft record has been reused
+ UInt16 Flags;
+ // UInt16 LinkCount;
+ // UInt16 NextAttrInstance;
+ CMftRef BaseMftRef;
+ // UInt32 ThisRecNumber;
+
+ UInt32 MyNumNameLinks;
+ int MyItemIndex; // index in Items[] of main item for that record, or -1 if there is no item for that record
+
+ CObjectVector<CAttr> DataAttrs;
+ CObjectVector<CFileNameAttr> FileNames;
+ CRecordVector<CDataRef> DataRefs;
+ // CAttr SecurityAttr;
+
+ CSiAttr SiAttr;
+
+ CByteBuffer ReparseData;
+
+ int FindWin32Name_for_DosName(unsigned dosNameIndex) const
+ {
+ const CFileNameAttr &cur = FileNames[dosNameIndex];
+ if (cur.IsDos())
+ for (unsigned i = 0; i < FileNames.Size(); i++)
+ {
+ const CFileNameAttr &next = FileNames[i];
+ if (next.IsWin32() && cur.ParentDirRef.Val == next.ParentDirRef.Val)
+ return (int)i;
+ }
+ return -1;
+ }
+
+ int FindDosName(unsigned nameIndex) const
+ {
+ const CFileNameAttr &cur = FileNames[nameIndex];
+ if (cur.IsWin32())
+ for (unsigned i = 0; i < FileNames.Size(); i++)
+ {
+ const CFileNameAttr &next = FileNames[i];
+ if (next.IsDos() && cur.ParentDirRef.Val == next.ParentDirRef.Val)
+ return (int)i;
+ }
+ return -1;
+ }
+
+ /*
+ bool IsAltStream(int dataIndex) const
+ {
+ return dataIndex >= 0 && (
+ (IsDir() ||
+ !DataAttrs[DataRefs[dataIndex].Start].Name.IsEmpty()));
+ }
+ */
+
+ void MoveAttrsFrom(CMftRec &src)
+ {
+ DataAttrs += src.DataAttrs;
+ FileNames += src.FileNames;
+ src.DataAttrs.ClearAndFree();
+ src.FileNames.ClearAndFree();
+ }
+
+ UInt64 GetPackSize() const
+ {
+ UInt64 res = 0;
+ FOR_VECTOR (i, DataRefs)
+ res += DataAttrs[DataRefs[i].Start].GetPackSize();
+ return res;
+ }
+
+ bool Parse(Byte *p, unsigned sectorSizeLog, UInt32 numSectors, UInt32 recNumber, CObjectVector<CAttr> *attrs);
+
+ bool Is_Magic_Empty() const
+ {
+ // what exact Magic values are possible for empty and unused records?
+ const UInt32 k_Magic_Unused_MAX = 5; // 22.02
+ return (Magic <= k_Magic_Unused_MAX);
+ }
+ bool Is_Magic_FILE() const { return (Magic == kMagic_FILE); }
+ // bool Is_Magic_BAAD() const { return (Magic == kMagic_BAAD); }
+ bool Is_Magic_CanIgnore() const
+ {
+ return Is_Magic_Empty()
+ || Magic == kMagic_BAAD
+ || Magic == kMagic_INDX
+ || Magic == kMagic_HOLE
+ || Magic == kMagic_RSTR
+ || Magic == kMagic_RCRD
+ || Magic == kMagic_CHKD
+ || Magic == kMagic_FFFFFFFF;
+ }
+
+ bool InUse() const { return (Flags & 1) != 0; }
+ bool IsDir() const { return (Flags & 2) != 0; }
+
+ void ParseDataNames();
+ HRESULT GetStream(IInStream *mainStream, int dataIndex,
+ unsigned clusterSizeLog, UInt64 numPhysClusters, IInStream **stream) const;
+ unsigned GetNumExtents(int dataIndex, unsigned clusterSizeLog, UInt64 numPhysClusters) const;
+
+ UInt64 GetSize(unsigned dataIndex) const { return DataAttrs[DataRefs[dataIndex].Start].GetSize(); }
+
+ CMftRec():
+ SeqNumber(0),
+ Flags(0),
+ MyNumNameLinks(0),
+ MyItemIndex(-1) {}
+};
+
+void CMftRec::ParseDataNames()
+{
+ DataRefs.Clear();
+ DataAttrs.Sort(CompareAttr, NULL);
+
+ for (unsigned i = 0; i < DataAttrs.Size();)
+ {
+ CDataRef ref;
+ ref.Start = i;
+ for (i++; i < DataAttrs.Size(); i++)
+ if (DataAttrs[ref.Start].Name != DataAttrs[i].Name)
+ break;
+ ref.Num = i - ref.Start;
+ DataRefs.Add(ref);
+ }
+}
+
+HRESULT CMftRec::GetStream(IInStream *mainStream, int dataIndex,
+ unsigned clusterSizeLog, UInt64 numPhysClusters, IInStream **destStream) const
+{
+ *destStream = NULL;
+ CBufferInStream *streamSpec = new CBufferInStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+
+ if (dataIndex >= 0)
+ if ((unsigned)dataIndex < DataRefs.Size())
+ {
+ const CDataRef &ref = DataRefs[dataIndex];
+ unsigned numNonResident = 0;
+ unsigned i;
+ for (i = ref.Start; i < ref.Start + ref.Num; i++)
+ if (DataAttrs[i].NonResident)
+ numNonResident++;
+
+ const CAttr &attr0 = DataAttrs[ref.Start];
+
+ if (numNonResident != 0 || ref.Num != 1)
+ {
+ if (numNonResident != ref.Num || !attr0.IsCompressionUnitSupported())
+ return S_FALSE;
+ CInStream *ss = new CInStream;
+ CMyComPtr<IInStream> streamTemp2 = ss;
+ RINOK(DataParseExtents(clusterSizeLog, DataAttrs, ref.Start, ref.Start + ref.Num, numPhysClusters, ss->Extents))
+ ss->Size = attr0.Size;
+ ss->InitializedSize = attr0.InitializedSize;
+ ss->Stream = mainStream;
+ ss->BlockSizeLog = clusterSizeLog;
+ ss->InUse = InUse();
+ RINOK(ss->InitAndSeek(attr0.CompressionUnit))
+ *destStream = streamTemp2.Detach();
+ return S_OK;
+ }
+
+ streamSpec->Buf = attr0.Data;
+ }
+
+ streamSpec->Init();
+ *destStream = streamTemp.Detach();
+ return S_OK;
+}
+
+unsigned CMftRec::GetNumExtents(int dataIndex, unsigned clusterSizeLog, UInt64 numPhysClusters) const
+{
+ if (dataIndex < 0)
+ return 0;
+ {
+ const CDataRef &ref = DataRefs[dataIndex];
+ unsigned numNonResident = 0;
+ unsigned i;
+ for (i = ref.Start; i < ref.Start + ref.Num; i++)
+ if (DataAttrs[i].NonResident)
+ numNonResident++;
+
+ const CAttr &attr0 = DataAttrs[ref.Start];
+
+ if (numNonResident != 0 || ref.Num != 1)
+ {
+ if (numNonResident != ref.Num || !attr0.IsCompressionUnitSupported())
+ return 0; // error;
+ CRecordVector<CExtent> extents;
+ if (DataParseExtents(clusterSizeLog, DataAttrs, ref.Start, ref.Start + ref.Num, numPhysClusters, extents) != S_OK)
+ return 0; // error;
+ return extents.Size() - 1;
+ }
+ // if (attr0.Data.Size() != 0)
+ // return 1;
+ return 0;
+ }
+}
+
+bool CMftRec::Parse(Byte *p, unsigned sectorSizeLog, UInt32 numSectors, UInt32 recNumber,
+ CObjectVector<CAttr> *attrs)
+{
+ G32(p, Magic);
+ if (!Is_Magic_FILE())
+ return Is_Magic_CanIgnore();
+
+ {
+ UInt32 usaOffset;
+ UInt32 numUsaItems;
+ G16(p + 0x04, usaOffset);
+ G16(p + 0x06, numUsaItems);
+
+ /* NTFS stores (usn) to 2 last bytes in each sector (before writing record to disk).
+ Original values of these two bytes are stored in table.
+ So we restore original data from table */
+
+ if ((usaOffset & 1) != 0
+ || usaOffset + numUsaItems * 2 > ((UInt32)1 << sectorSizeLog) - 2
+ || numUsaItems == 0
+ || numUsaItems - 1 != numSectors)
+ return false;
+
+ if (usaOffset >= 0x30) // NTFS 3.1+
+ {
+ UInt32 iii = Get32(p + 0x2C);
+ if (iii != recNumber)
+ {
+ // ntfs-3g probably writes 0 (that probably is incorrect value) to this field for unused records.
+ // so we support that "bad" case.
+ if (iii != 0)
+ return false;
+ }
+ }
+
+ UInt16 usn = Get16(p + usaOffset);
+ // PRF(printf("\nusn = %d", usn));
+ for (UInt32 i = 1; i < numUsaItems; i++)
+ {
+ void *pp = p + (i << sectorSizeLog) - 2;
+ if (Get16(pp) != usn)
+ return false;
+ SetUi16(pp, Get16(p + usaOffset + i * 2))
+ }
+ }
+
+ // G64(p + 0x08, Lsn);
+ G16(p + 0x10, SeqNumber);
+ // G16(p + 0x12, LinkCount);
+ // PRF(printf(" L=%d", LinkCount));
+ UInt32 attrOffs = Get16(p + 0x14);
+ G16(p + 0x16, Flags);
+ PRF(printf(" F=%4X", Flags));
+
+ UInt32 bytesInUse = Get32(p + 0x18);
+ UInt32 bytesAlloc = Get32(p + 0x1C);
+ G64(p + 0x20, BaseMftRef.Val);
+ if (BaseMftRef.Val != 0)
+ {
+ PRF(printf(" BaseRef=%d", (int)BaseMftRef.Val));
+ // return false; // Check it;
+ }
+ // G16(p + 0x28, NextAttrInstance);
+
+ UInt32 limit = numSectors << sectorSizeLog;
+ if (attrOffs >= limit
+ || (attrOffs & 7) != 0
+ || (bytesInUse & 7) != 0
+ || bytesInUse > limit
+ || bytesAlloc != limit)
+ return false;
+
+ limit = bytesInUse;
+
+ for (UInt32 t = attrOffs;;)
+ {
+ if (t >= limit)
+ return false;
+
+ CAttr attr;
+ // PRF(printf("\n %2d:", Attrs.Size()));
+ PRF(printf("\n"));
+ UInt32 len = attr.Parse(p + t, limit - t);
+ if (len == 0 || limit - t < len)
+ return false;
+ t += len;
+ if (attr.Type == 0xFFFFFFFF)
+ {
+ if (t != limit)
+ return false;
+ break;
+ }
+ switch (attr.Type)
+ {
+ case ATTR_TYPE_FILE_NAME:
+ {
+ CFileNameAttr fna;
+ if (!attr.ParseFileName(fna))
+ return false;
+ FileNames.Add(fna);
+ PRF(printf(" flags = %4x\n ", (int)fna.NameType));
+ PRF_UTF16(fna.Name);
+ break;
+ }
+ case ATTR_TYPE_STANDARD_INFO:
+ if (!attr.ParseSi(SiAttr))
+ return false;
+ break;
+ case ATTR_TYPE_DATA:
+ DataAttrs.Add(attr);
+ break;
+ case ATTR_TYPE_REPARSE_POINT:
+ ReparseData = attr.Data;
+ break;
+ /*
+ case ATTR_TYPE_SECURITY_DESCRIPTOR:
+ SecurityAttr = attr;
+ break;
+ */
+ default:
+ if (attrs)
+ attrs->Add(attr);
+ break;
+ }
+ }
+
+ return true;
+}
+
+/*
+ NTFS probably creates empty DATA_ATTRIBUTE for empty file,
+ But it doesn't do it for
+ $Secure (:$SDS),
+ $Extend\$Quota
+ $Extend\$ObjId
+ $Extend\$Reparse
+*/
+
+static const int k_Item_DataIndex_IsEmptyFile = -1; // file without unnamed data stream
+static const int k_Item_DataIndex_IsDir = -2;
+
+// static const int k_ParentFolderIndex_Root = -1;
+static const int k_ParentFolderIndex_Lost = -2;
+static const int k_ParentFolderIndex_Deleted = -3;
+
+struct CItem
+{
+ unsigned RecIndex; // index in Recs array
+ unsigned NameIndex; // index in CMftRec::FileNames
+
+ int DataIndex; /* index in CMftRec::DataRefs
+ -1: file without unnamed data stream
+ -2: for directories */
+
+ int ParentFolder; /* index in Items array
+ -1: for root items
+ -2: [LOST] folder
+ -3: [UNKNOWN] folder (deleted lost) */
+ int ParentHost; /* index in Items array, if it's AltStream
+ -1: if it's not AltStream */
+
+ CItem(): DataIndex(k_Item_DataIndex_IsDir), ParentFolder(-1), ParentHost(-1) {}
+
+ bool IsAltStream() const { return ParentHost != -1; }
+ bool IsDir() const { return DataIndex == k_Item_DataIndex_IsDir; }
+ // check it !!!
+ // probably NTFS for empty file still creates empty DATA_ATTRIBUTE
+ // But it doesn't do it for $Secure:$SDS
+};
+
+struct CDatabase
+{
+ CRecordVector<CItem> Items;
+ CObjectVector<CMftRec> Recs;
+ CMyComPtr<IInStream> InStream;
+ CHeader Header;
+ unsigned RecSizeLog;
+ UInt64 PhySize;
+
+ IArchiveOpenCallback *OpenCallback;
+
+ CByteBuffer ByteBuf;
+
+ CObjectVector<CAttr> VolAttrs;
+
+ CByteBuffer SecurData;
+ CRecordVector<size_t> SecurOffsets;
+
+ bool _showSystemFiles;
+ bool _showDeletedFiles;
+ CObjectVector<UString2> VirtFolderNames;
+ UString EmptyString;
+
+ int _systemFolderIndex;
+ int _lostFolderIndex_Normal;
+ int _lostFolderIndex_Deleted;
+
+ // bool _headerWarning;
+
+ bool ThereAreAltStreams;
+
+ void InitProps()
+ {
+ _showSystemFiles = true;
+ // we show SystemFiles by default since it's difficult to track $Extend\* system files
+ // it must be fixed later
+ _showDeletedFiles = false;
+ }
+
+ CDatabase() { InitProps(); }
+ ~CDatabase() { ClearAndClose(); }
+
+ void Clear();
+ void ClearAndClose();
+
+ void GetItemPath(unsigned index, NCOM::CPropVariant &path) const;
+ HRESULT Open();
+
+ HRESULT SeekToCluster(UInt64 cluster);
+
+ int FindDirItemForMtfRec(UInt64 recIndex) const
+ {
+ if (recIndex >= Recs.Size())
+ return -1;
+ const CMftRec &rec = Recs[(unsigned)recIndex];
+ if (!rec.IsDir())
+ return -1;
+ return rec.MyItemIndex;
+ /*
+ unsigned left = 0, right = Items.Size();
+ while (left != right)
+ {
+ unsigned mid = (left + right) / 2;
+ const CItem &item = Items[mid];
+ UInt64 midValue = item.RecIndex;
+ if (recIndex == midValue)
+ {
+ // if item is not dir (file or alt stream we don't return it)
+ // if (item.DataIndex < 0)
+ if (item.IsDir())
+ return mid;
+ right = mid;
+ }
+ else if (recIndex < midValue)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+ */
+ }
+
+ bool FindSecurityDescritor(UInt32 id, UInt64 &offset, UInt32 &size) const;
+
+ HRESULT ParseSecuritySDS_2();
+ void ParseSecuritySDS()
+ {
+ HRESULT res = ParseSecuritySDS_2();
+ if (res != S_OK)
+ {
+ SecurOffsets.Clear();
+ SecurData.Free();
+ }
+ }
+
+};
+
+HRESULT CDatabase::SeekToCluster(UInt64 cluster)
+{
+ return InStream_SeekSet(InStream, cluster << Header.ClusterSizeLog);
+}
+
+void CDatabase::Clear()
+{
+ Items.Clear();
+ Recs.Clear();
+ SecurOffsets.Clear();
+ SecurData.Free();
+ VirtFolderNames.Clear();
+ _systemFolderIndex = -1;
+ _lostFolderIndex_Normal = -1;
+ _lostFolderIndex_Deleted = -1;
+ ThereAreAltStreams = false;
+ // _headerWarning = false;
+ PhySize = 0;
+}
+
+void CDatabase::ClearAndClose()
+{
+ Clear();
+ InStream.Release();
+}
+
+
+static void CopyName(wchar_t *dest, const wchar_t *src)
+{
+ for (;;)
+ {
+ wchar_t c = *src++;
+ // 18.06
+ if (c == '\\' || c == '/')
+ c = '_';
+ *dest++ = c;
+ if (c == 0)
+ return;
+ }
+}
+
+void CDatabase::GetItemPath(unsigned index, NCOM::CPropVariant &path) const
+{
+ const CItem *item = &Items[index];
+ unsigned size = 0;
+ const CMftRec &rec = Recs[item->RecIndex];
+ size += rec.FileNames[item->NameIndex].Name.Len();
+
+ bool isAltStream = item->IsAltStream();
+
+ if (isAltStream)
+ {
+ const CAttr &data = rec.DataAttrs[rec.DataRefs[item->DataIndex].Start];
+ if (item->RecIndex == kRecIndex_RootDir)
+ {
+ wchar_t *s = path.AllocBstr(data.Name.Len() + 1);
+ s[0] = L':';
+ if (!data.Name.IsEmpty())
+ CopyName(s + 1, data.Name.GetRawPtr());
+ return;
+ }
+
+ size += data.Name.Len();
+ size++;
+ }
+
+ for (unsigned i = 0;; i++)
+ {
+ if (i > 256)
+ {
+ path = "[TOO-LONG]";
+ return;
+ }
+ const wchar_t *servName;
+ if (item->RecIndex < kNumSysRecs
+ /* && item->RecIndex != kRecIndex_RootDir */)
+ servName = kVirtualFolder_System;
+ else
+ {
+ int index2 = item->ParentFolder;
+ if (index2 >= 0)
+ {
+ item = &Items[index2];
+ size += Recs[item->RecIndex].FileNames[item->NameIndex].Name.Len() + 1;
+ continue;
+ }
+ if (index2 == -1)
+ break;
+ servName = (index2 == k_ParentFolderIndex_Lost) ?
+ kVirtualFolder_Lost_Normal :
+ kVirtualFolder_Lost_Deleted;
+ }
+ size += MyStringLen(servName) + 1;
+ break;
+ }
+
+ wchar_t *s = path.AllocBstr(size);
+
+ item = &Items[index];
+
+ bool needColon = false;
+ if (isAltStream)
+ {
+ const UString2 &name = rec.DataAttrs[rec.DataRefs[item->DataIndex].Start].Name;
+ if (!name.IsEmpty())
+ {
+ size -= name.Len();
+ CopyName(s + size, name.GetRawPtr());
+ }
+ s[--size] = ':';
+ needColon = true;
+ }
+
+ {
+ const UString2 &name = rec.FileNames[item->NameIndex].Name;
+ unsigned len = name.Len();
+ if (len != 0)
+ CopyName(s + size - len, name.GetRawPtr());
+ if (needColon)
+ s[size] = ':';
+ size -= len;
+ }
+
+ for (;;)
+ {
+ const wchar_t *servName;
+ if (item->RecIndex < kNumSysRecs
+ /* && && item->RecIndex != kRecIndex_RootDir */)
+ servName = kVirtualFolder_System;
+ else
+ {
+ int index2 = item->ParentFolder;
+ if (index2 >= 0)
+ {
+ item = &Items[index2];
+ const UString2 &name = Recs[item->RecIndex].FileNames[item->NameIndex].Name;
+ unsigned len = name.Len();
+ size--;
+ if (len != 0)
+ {
+ size -= len;
+ CopyName(s + size, name.GetRawPtr());
+ }
+ s[size + len] = WCHAR_PATH_SEPARATOR;
+ continue;
+ }
+ if (index2 == -1)
+ break;
+ servName = (index2 == k_ParentFolderIndex_Lost) ?
+ kVirtualFolder_Lost_Normal :
+ kVirtualFolder_Lost_Deleted;
+ }
+ MyStringCopy(s, servName);
+ s[MyStringLen(servName)] = WCHAR_PATH_SEPARATOR;
+ break;
+ }
+}
+
+bool CDatabase::FindSecurityDescritor(UInt32 item, UInt64 &offset, UInt32 &size) const
+{
+ offset = 0;
+ size = 0;
+ unsigned left = 0, right = SecurOffsets.Size();
+ while (left != right)
+ {
+ unsigned mid = (left + right) / 2;
+ size_t offs = SecurOffsets[mid];
+ UInt32 midValue = Get32(((const Byte *)SecurData) + offs + 4);
+ if (item == midValue)
+ {
+ offset = Get64((const Byte *)SecurData + offs + 8) + 20;
+ size = Get32((const Byte *)SecurData + offs + 16) - 20;
+ return true;
+ }
+ if (item < midValue)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return false;
+}
+
+/*
+static int CompareIDs(const size_t *p1, const size_t *p2, void *data)
+{
+ UInt32 id1 = Get32(((const Byte *)data) + *p1 + 4);
+ UInt32 id2 = Get32(((const Byte *)data) + *p2 + 4);
+ return MyCompare(id1, id2);
+}
+*/
+
+// security data contains duplication copy after each 256 KB.
+static const unsigned kSecureDuplicateStepBits = 18;
+
+HRESULT CDatabase::ParseSecuritySDS_2()
+{
+ const Byte *p = SecurData;
+ size_t size = SecurData.Size();
+ const size_t kDuplicateStep = (size_t)1 << kSecureDuplicateStepBits;
+ const size_t kDuplicateMask = kDuplicateStep - 1;
+ size_t lim = MyMin(size, kDuplicateStep);
+ UInt32 idPrev = 0;
+ for (size_t pos = 0; pos < size && size - pos >= 20;)
+ {
+ UInt32 id = Get32(p + pos + 4);
+ UInt64 offs = Get64(p + pos + 8);
+ UInt32 entrySize = Get32(p + pos + 16);
+ if (offs == pos && entrySize >= 20 && lim - pos >= entrySize)
+ {
+ if (id <= idPrev)
+ return S_FALSE;
+ idPrev = id;
+ SecurOffsets.Add(pos);
+ pos += entrySize;
+ pos = (pos + 0xF) & ~(size_t)0xF;
+ if ((pos & kDuplicateMask) != 0)
+ continue;
+ }
+ else
+ pos = (pos + kDuplicateStep) & ~kDuplicateMask;
+ pos += kDuplicateStep;
+ lim = pos + kDuplicateStep;
+ if (lim >= size)
+ lim = size;
+ }
+ // we checked that IDs are sorted, so we don't need Sort
+ // SecurOffsets.Sort(CompareIDs, (void *)p);
+ return S_OK;
+}
+
+HRESULT CDatabase::Open()
+{
+ Clear();
+
+ /* NTFS layout:
+ 1) main part (as specified by NumClusters). Only that part is available, if we open "\\.\c:"
+ 2) additional empty sectors (as specified by NumSectors)
+ 3) the copy of first sector (boot sector)
+
+ We support both cases:
+ - the file with only main part
+ - full file (as raw data on partition), including the copy
+ of first sector (boot sector) at the end of data
+
+ We don't support the case, when only the copy of boot sector
+ at the end was detected as NTFS signature.
+ */
+
+ {
+ const UInt32 kHeaderSize = 512;
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(InStream, buf, kHeaderSize))
+ if (!Header.Parse(buf))
+ return S_FALSE;
+
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(InStream, fileSize))
+ PhySize = Header.GetPhySize_Clusters();
+ if (fileSize < PhySize)
+ return S_FALSE;
+
+ UInt64 phySizeMax = Header.GetPhySize_Max();
+ if (fileSize >= phySizeMax)
+ {
+ RINOK(InStream_SeekSet(InStream, Header.NumSectors << Header.SectorSizeLog))
+ Byte buf2[kHeaderSize];
+ if (ReadStream_FALSE(InStream, buf2, kHeaderSize) == S_OK)
+ {
+ if (memcmp(buf, buf2, kHeaderSize) == 0)
+ PhySize = phySizeMax;
+ // else _headerWarning = true;
+ }
+ }
+ }
+
+ SeekToCluster(Header.MftCluster);
+
+ CMftRec mftRec;
+ UInt32 numSectorsInRec;
+
+ CMyComPtr<IInStream> mftStream;
+ {
+ UInt32 blockSize = 1 << 12;
+ ByteBuf.Alloc(blockSize);
+ RINOK(ReadStream_FALSE(InStream, ByteBuf, blockSize))
+
+ {
+ const UInt32 allocSize = Get32(ByteBuf + 0x1C);
+ const int t = GetLog(allocSize);
+ if (t < (int)Header.SectorSizeLog)
+ return S_FALSE;
+ RecSizeLog = (unsigned)t;
+ if (RecSizeLog > 15)
+ return S_FALSE;
+ }
+
+ numSectorsInRec = 1 << (RecSizeLog - Header.SectorSizeLog);
+ if (!mftRec.Parse(ByteBuf, Header.SectorSizeLog, numSectorsInRec, 0, NULL))
+ return S_FALSE;
+ if (!mftRec.Is_Magic_FILE())
+ return S_FALSE;
+ mftRec.ParseDataNames();
+ if (mftRec.DataRefs.IsEmpty())
+ return S_FALSE;
+ RINOK(mftRec.GetStream(InStream, 0, Header.ClusterSizeLog, Header.NumClusters, &mftStream))
+ if (!mftStream)
+ return S_FALSE;
+ }
+
+ // CObjectVector<CAttr> SecurityAttrs;
+
+ UInt64 mftSize = mftRec.DataAttrs[0].Size;
+ if ((mftSize >> 4) > Header.GetPhySize_Clusters())
+ return S_FALSE;
+
+ const size_t kBufSize = (1 << 15);
+ const size_t recSize = ((size_t)1 << RecSizeLog);
+ if (kBufSize < recSize)
+ return S_FALSE;
+
+ {
+ const UInt64 numFiles = mftSize >> RecSizeLog;
+ if (numFiles > (1 << 30))
+ return S_FALSE;
+ if (OpenCallback)
+ {
+ RINOK(OpenCallback->SetTotal(&numFiles, &mftSize))
+ }
+
+ ByteBuf.Alloc(kBufSize);
+ Recs.ClearAndReserve((unsigned)numFiles);
+ }
+
+ for (UInt64 pos64 = 0;;)
+ {
+ if (OpenCallback)
+ {
+ const UInt64 numFiles = Recs.Size();
+ if ((numFiles & 0x3FFF) == 0)
+ {
+ RINOK(OpenCallback->SetCompleted(&numFiles, &pos64))
+ }
+ }
+ size_t readSize = kBufSize;
+ {
+ const UInt64 rem = mftSize - pos64;
+ if (readSize > rem)
+ readSize = (size_t)rem;
+ }
+ if (readSize < recSize)
+ break;
+ RINOK(ReadStream_FALSE(mftStream, ByteBuf, readSize))
+ pos64 += readSize;
+
+ for (size_t i = 0; readSize >= recSize; i += recSize, readSize -= recSize)
+ {
+ PRF(printf("\n---------------------"));
+ PRF(printf("\n%5d:", Recs.Size()));
+
+ Byte *p = ByteBuf + i;
+ CMftRec rec;
+
+ CObjectVector<CAttr> *attrs = NULL;
+ unsigned recIndex = Recs.Size();
+ switch (recIndex)
+ {
+ case kRecIndex_Volume: attrs = &VolAttrs; break;
+ // case kRecIndex_Security: attrs = &SecurityAttrs; break;
+ }
+
+ if (!rec.Parse(p, Header.SectorSizeLog, numSectorsInRec, (UInt32)Recs.Size(), attrs))
+ return S_FALSE;
+ Recs.Add(rec);
+ }
+ }
+
+ /*
+ // that code looks too complex. And we can get security info without index parsing
+ for (i = 0; i < SecurityAttrs.Size(); i++)
+ {
+ const CAttr &attr = SecurityAttrs[i];
+ if (attr.Name == L"$SII")
+ {
+ if (attr.Type == ATTR_TYPE_INDEX_ROOT)
+ {
+ const Byte *data = attr.Data;
+ size_t size = attr.Data.Size();
+
+ // Index Root
+ UInt32 attrType = Get32(data);
+ UInt32 collationRule = Get32(data + 4);
+ UInt32 indexAllocationEtrySizeSize = Get32(data + 8);
+ UInt32 clustersPerIndexRecord = Get32(data + 0xC);
+ data += 0x10;
+
+ // Index Header
+ UInt32 firstEntryOffset = Get32(data);
+ UInt32 totalSize = Get32(data + 4);
+ UInt32 allocSize = Get32(data + 8);
+ UInt32 flags = Get32(data + 0xC);
+
+ int num = 0;
+ for (int j = 0 ; j < num; j++)
+ {
+ if (Get32(data) != 0x1414 || // offset and size
+ Get32(data + 4) != 0 ||
+ Get32(data + 8) != 0x428) // KeySize / EntrySize
+ break;
+ UInt32 flags = Get32(data + 12);
+ UInt32 id = Get32(data + 0x10);
+ if (id = Get32(data + 0x18))
+ break;
+ UInt32 descriptorOffset = Get64(data + 0x1C);
+ UInt32 descriptorSize = Get64(data + 0x24);
+ data += 0x28;
+ }
+ // break;
+ }
+ }
+ }
+ */
+
+ unsigned i;
+
+ for (i = 0; i < Recs.Size(); i++)
+ {
+ CMftRec &rec = Recs[i];
+ if (!rec.Is_Magic_FILE())
+ continue;
+
+ if (!rec.BaseMftRef.IsBaseItself())
+ {
+ const UInt64 refIndex = rec.BaseMftRef.GetIndex();
+ if (refIndex >= Recs.Size())
+ return S_FALSE;
+ CMftRec &refRec = Recs[(unsigned)refIndex];
+ if (!refRec.Is_Magic_FILE())
+ continue;
+
+ bool moveAttrs = (refRec.SeqNumber == rec.BaseMftRef.GetNumber() && refRec.BaseMftRef.IsBaseItself());
+ if (rec.InUse() && refRec.InUse())
+ {
+ if (!moveAttrs)
+ return S_FALSE;
+ }
+ else if (rec.InUse() || refRec.InUse())
+ moveAttrs = false;
+ if (moveAttrs)
+ refRec.MoveAttrsFrom(rec);
+ }
+ }
+
+ for (i = 0; i < Recs.Size(); i++)
+ {
+ CMftRec &rec = Recs[i];
+ if (!rec.Is_Magic_FILE())
+ continue;
+ rec.ParseDataNames();
+ }
+
+ for (i = 0; i < Recs.Size(); i++)
+ {
+ CMftRec &rec = Recs[i];
+ if (!rec.Is_Magic_FILE() || !rec.BaseMftRef.IsBaseItself())
+ continue;
+ if (i < kNumSysRecs && !_showSystemFiles)
+ continue;
+ if (!rec.InUse() && !_showDeletedFiles)
+ continue;
+
+ rec.MyNumNameLinks = rec.FileNames.Size();
+
+ // printf("\n%4d: ", i);
+
+ /* Actually DataAttrs / DataRefs are sorted by name.
+ It can not be more than one unnamed stream in DataRefs
+ And indexOfUnnamedStream <= 0.
+ */
+
+ int indexOfUnnamedStream = -1;
+ if (!rec.IsDir())
+ {
+ FOR_VECTOR (di, rec.DataRefs)
+ if (rec.DataAttrs[rec.DataRefs[di].Start].Name.IsEmpty())
+ {
+ indexOfUnnamedStream = (int)di;
+ break;
+ }
+ }
+
+ if (rec.FileNames.IsEmpty())
+ {
+ bool needShow = true;
+ if (i < kNumSysRecs)
+ {
+ needShow = false;
+ FOR_VECTOR (di, rec.DataRefs)
+ if (rec.GetSize(di) != 0)
+ {
+ needShow = true;
+ break;
+ }
+ }
+ if (needShow)
+ {
+ CFileNameAttr &fna = rec.FileNames.AddNew();
+ // we set incorrect ParentDirRef, that will place item to [LOST] folder
+ fna.ParentDirRef.Val = (UInt64)(Int64)-1;
+ char s[16 + 16];
+ ConvertUInt32ToString(i, MyStpCpy(s, "[NONAME]-"));
+ fna.Name.SetFromAscii(s);
+ fna.NameType = kFileNameType_Win32Dos;
+ fna.Attrib = 0;
+ }
+ }
+
+ // bool isMainName = true;
+
+ FOR_VECTOR (t, rec.FileNames)
+ {
+ #ifdef SHOW_DEBUG_INFO
+ const CFileNameAttr &fna = rec.FileNames[t];
+ #endif
+ PRF(printf("\n %4d ", (int)fna.NameType));
+ PRF_UTF16(fna.Name);
+ // PRF(printf(" | "));
+
+ if (rec.FindWin32Name_for_DosName(t) >= 0)
+ {
+ rec.MyNumNameLinks--;
+ continue;
+ }
+
+ CItem item;
+ item.NameIndex = t;
+ item.RecIndex = i;
+ item.DataIndex = rec.IsDir() ?
+ k_Item_DataIndex_IsDir :
+ (indexOfUnnamedStream < 0 ?
+ k_Item_DataIndex_IsEmptyFile :
+ indexOfUnnamedStream);
+
+ if (rec.MyItemIndex < 0)
+ rec.MyItemIndex = (int)Items.Size();
+ item.ParentHost = (int)Items.Add(item);
+
+ /* we can use that code to reduce the number of alt streams:
+ it will not show how alt streams for hard links. */
+ // if (!isMainName) continue; isMainName = false;
+
+ // unsigned numAltStreams = 0;
+
+ FOR_VECTOR (di, rec.DataRefs)
+ {
+ if (!rec.IsDir() && (int)di == indexOfUnnamedStream)
+ continue;
+
+ const UString2 &subName = rec.DataAttrs[rec.DataRefs[di].Start].Name;
+
+ PRF(printf("\n alt stream: "));
+ PRF_UTF16(subName);
+
+ {
+ // $BadClus:$Bad is sparse file for all clusters. So we skip it.
+ if (i == kRecIndex_BadClus && subName == L"$Bad")
+ continue;
+ }
+
+ // numAltStreams++;
+ ThereAreAltStreams = true;
+ item.DataIndex = (int)di;
+ Items.Add(item);
+ }
+ }
+ }
+
+ if (Recs.Size() > kRecIndex_Security)
+ {
+ const CMftRec &rec = Recs[kRecIndex_Security];
+ FOR_VECTOR (di, rec.DataRefs)
+ {
+ const CAttr &attr = rec.DataAttrs[rec.DataRefs[di].Start];
+ if (attr.Name == L"$SDS")
+ {
+ CMyComPtr<IInStream> sdsStream;
+ RINOK(rec.GetStream(InStream, (int)di, Header.ClusterSizeLog, Header.NumClusters, &sdsStream))
+ if (sdsStream)
+ {
+ const UInt64 size64 = attr.GetSize();
+ if (size64 < (UInt32)1 << 29)
+ {
+ size_t size = (size_t)size64;
+ if ((((size + 1) >> kSecureDuplicateStepBits) & 1) != 0)
+ {
+ size -= (1 << kSecureDuplicateStepBits);
+ SecurData.Alloc(size);
+ if (ReadStream_FALSE(sdsStream, SecurData, size) == S_OK)
+ {
+ ParseSecuritySDS();
+ break;
+ }
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ bool thereAreUnknownFolders_Normal = false;
+ bool thereAreUnknownFolders_Deleted = false;
+
+ for (i = 0; i < Items.Size(); i++)
+ {
+ CItem &item = Items[i];
+ const CMftRec &rec = Recs[item.RecIndex];
+ const CFileNameAttr &fn = rec.FileNames[item.NameIndex];
+ const CMftRef &parentDirRef = fn.ParentDirRef;
+ const UInt64 refIndex = parentDirRef.GetIndex();
+ if (refIndex == kRecIndex_RootDir)
+ item.ParentFolder = -1;
+ else
+ {
+ int index = FindDirItemForMtfRec(refIndex);
+ if (index < 0 ||
+ Recs[Items[index].RecIndex].SeqNumber != parentDirRef.GetNumber())
+ {
+ if (Recs[item.RecIndex].InUse())
+ {
+ thereAreUnknownFolders_Normal = true;
+ index = k_ParentFolderIndex_Lost;
+ }
+ else
+ {
+ thereAreUnknownFolders_Deleted = true;
+ index = k_ParentFolderIndex_Deleted;
+ }
+ }
+ item.ParentFolder = index;
+ }
+ }
+
+ unsigned virtIndex = Items.Size();
+ if (_showSystemFiles)
+ {
+ _systemFolderIndex = (int)(virtIndex++);
+ VirtFolderNames.Add(kVirtualFolder_System);
+ }
+ if (thereAreUnknownFolders_Normal)
+ {
+ _lostFolderIndex_Normal = (int)(virtIndex++);
+ VirtFolderNames.Add(kVirtualFolder_Lost_Normal);
+ }
+ if (thereAreUnknownFolders_Deleted)
+ {
+ _lostFolderIndex_Deleted = (int)(virtIndex++);
+ VirtFolderNames.Add(kVirtualFolder_Lost_Deleted);
+ }
+
+ return S_OK;
+}
+
+Z7_class_CHandler_final:
+ public IInArchive,
+ public IArchiveGetRawProps,
+ public IInArchiveGetStream,
+ public ISetProperties,
+ public CMyUnknownImp,
+ public CDatabase
+{
+ Z7_IFACES_IMP_UNK_4(
+ IInArchive,
+ IArchiveGetRawProps,
+ IInArchiveGetStream,
+ ISetProperties)
+};
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = 2;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+{
+ *name = NULL;
+ *propID = index == 0 ? kpidNtReparse : kpidNtSecure;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+ int par = -1;
+
+ if (index < Items.Size())
+ {
+ const CItem &item = Items[index];
+
+ if (item.ParentHost >= 0)
+ {
+ *parentType = NParentType::kAltStream;
+ par = (item.RecIndex == kRecIndex_RootDir ? -1 : item.ParentHost);
+ }
+ else if (item.RecIndex < kNumSysRecs)
+ {
+ if (_showSystemFiles)
+ par = _systemFolderIndex;
+ }
+ else if (item.ParentFolder >= 0)
+ par = item.ParentFolder;
+ else if (item.ParentFolder == k_ParentFolderIndex_Lost)
+ par = _lostFolderIndex_Normal;
+ else if (item.ParentFolder == k_ParentFolderIndex_Deleted)
+ par = _lostFolderIndex_Deleted;
+ }
+ *parent = (UInt32)(Int32)par;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (propID == kpidName)
+ {
+ #ifdef MY_CPU_LE
+ const UString2 *s;
+ if (index >= Items.Size())
+ s = &VirtFolderNames[index - Items.Size()];
+ else
+ {
+ const CItem &item = Items[index];
+ const CMftRec &rec = Recs[item.RecIndex];
+ if (item.IsAltStream())
+ s = &rec.DataAttrs[rec.DataRefs[item.DataIndex].Start].Name;
+ else
+ s = &rec.FileNames[item.NameIndex].Name;
+ }
+ if (s->IsEmpty())
+ *data = (const wchar_t *)EmptyString;
+ else
+ *data = s->GetRawPtr();
+ *dataSize = (s->Len() + 1) * (UInt32)sizeof(wchar_t);
+ *propType = PROP_DATA_TYPE_wchar_t_PTR_Z_LE;
+ #endif
+ return S_OK;
+ }
+
+ if (propID == kpidNtReparse)
+ {
+ if (index >= Items.Size())
+ return S_OK;
+ const CItem &item = Items[index];
+ const CMftRec &rec = Recs[item.RecIndex];
+ const CByteBuffer &reparse = rec.ReparseData;
+
+ if (reparse.Size() != 0)
+ {
+ *dataSize = (UInt32)reparse.Size();
+ *propType = NPropDataType::kRaw;
+ *data = (const Byte *)reparse;
+ }
+ }
+
+ if (propID == kpidNtSecure)
+ {
+ if (index >= Items.Size())
+ return S_OK;
+ const CItem &item = Items[index];
+ const CMftRec &rec = Recs[item.RecIndex];
+ if (rec.SiAttr.SecurityId > 0)
+ {
+ UInt64 offset;
+ UInt32 size;
+ if (FindSecurityDescritor(rec.SiAttr.SecurityId, offset, size))
+ {
+ *dataSize = size;
+ *propType = NPropDataType::kRaw;
+ *data = (const Byte *)SecurData + offset;
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ if (index >= Items.Size())
+ return S_OK;
+ IInStream *stream2;
+ const CItem &item = Items[index];
+ const CMftRec &rec = Recs[item.RecIndex];
+ HRESULT res = rec.GetStream(InStream, item.DataIndex, Header.ClusterSizeLog, Header.NumClusters, &stream2);
+ *stream = (ISequentialInStream *)stream2;
+ return res;
+ COM_TRY_END
+}
+
+/*
+enum
+{
+ kpidLink2 = kpidUserDefined,
+ kpidLinkType,
+ kpidRecMTime,
+ kpidRecMTime2,
+ kpidMTime2,
+ kpidCTime2,
+ kpidATime2
+};
+
+static const CStatProp kProps[] =
+{
+ { NULL, kpidPath, VT_BSTR},
+ { NULL, kpidSize, VT_UI8},
+ { NULL, kpidPackSize, VT_UI8},
+
+ // { NULL, kpidLink, VT_BSTR},
+
+ // { "Link 2", kpidLink2, VT_BSTR},
+ // { "Link Type", kpidLinkType, VT_UI2},
+ { NULL, kpidINode, VT_UI8},
+
+ { NULL, kpidMTime, VT_FILETIME},
+ { NULL, kpidCTime, VT_FILETIME},
+ { NULL, kpidATime, VT_FILETIME},
+
+ // { "Record Modified", kpidRecMTime, VT_FILETIME},
+
+ // { "Modified 2", kpidMTime2, VT_FILETIME},
+ // { "Created 2", kpidCTime2, VT_FILETIME},
+ // { "Accessed 2", kpidATime2, VT_FILETIME},
+ // { "Record Modified 2", kpidRecMTime2, VT_FILETIME},
+
+ { NULL, kpidAttrib, VT_UI4},
+ { NULL, kpidNumBlocks, VT_UI4},
+ { NULL, kpidIsDeleted, VT_BOOL},
+};
+*/
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidChangeTime,
+ kpidAttrib,
+ kpidLinks,
+ kpidINode,
+ kpidNumBlocks,
+ kpidNumAltStreams,
+ kpidIsAltStream,
+ kpidShortName,
+ kpidIsDeleted
+};
+
+enum
+{
+ kpidRecordSize = kpidUserDefined
+};
+
+static const CStatProp kArcProps[] =
+{
+ { NULL, kpidVolumeName, VT_BSTR},
+ { NULL, kpidFileSystem, VT_BSTR},
+ { NULL, kpidClusterSize, VT_UI4},
+ { NULL, kpidSectorSize, VT_UI4},
+ { "Record Size", kpidRecordSize, VT_UI4},
+ { NULL, kpidHeadersSize, VT_UI8},
+ { NULL, kpidCTime, VT_FILETIME},
+ { NULL, kpidId, VT_UI8},
+};
+
+/*
+static const Byte kArcProps[] =
+{
+ kpidVolumeName,
+ kpidFileSystem,
+ kpidClusterSize,
+ kpidHeadersSize,
+ kpidCTime,
+
+ kpidSectorSize,
+ kpidId
+ // kpidSectorsPerTrack,
+ // kpidNumHeads,
+ // kpidHiddenSectors
+};
+*/
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+static void NtfsTimeToProp(UInt64 t, NCOM::CPropVariant &prop)
+{
+ FILETIME ft;
+ ft.dwLowDateTime = (DWORD)t;
+ ft.dwHighDateTime = (DWORD)(t >> 32);
+ prop = ft;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CMftRec *volRec = (Recs.Size() > kRecIndex_Volume ? &Recs[kRecIndex_Volume] : NULL);
+
+ switch (propID)
+ {
+ case kpidClusterSize: prop = Header.ClusterSize(); break;
+ case kpidPhySize: prop = PhySize; break;
+ /*
+ case kpidHeadersSize:
+ {
+ UInt64 val = 0;
+ for (unsigned i = 0; i < kNumSysRecs; i++)
+ {
+ printf("\n%2d: %8I64d ", i, Recs[i].GetPackSize());
+ if (i == 8)
+ i = i
+ val += Recs[i].GetPackSize();
+ }
+ prop = val;
+ break;
+ }
+ */
+ case kpidCTime: if (volRec) NtfsTimeToProp(volRec->SiAttr.CTime, prop); break;
+ case kpidMTime: if (volRec) NtfsTimeToProp(volRec->SiAttr.MTime, prop); break;
+ case kpidShortComment:
+ case kpidVolumeName:
+ {
+ FOR_VECTOR (i, VolAttrs)
+ {
+ const CAttr &attr = VolAttrs[i];
+ if (attr.Type == ATTR_TYPE_VOLUME_NAME)
+ {
+ UString2 name;
+ GetString(attr.Data, (unsigned)attr.Data.Size() / 2, name);
+ if (!name.IsEmpty())
+ prop = name.GetRawPtr();
+ break;
+ }
+ }
+ break;
+ }
+ case kpidFileSystem:
+ {
+ AString s ("NTFS");
+ FOR_VECTOR (i, VolAttrs)
+ {
+ const CAttr &attr = VolAttrs[i];
+ if (attr.Type == ATTR_TYPE_VOLUME_INFO)
+ {
+ CVolInfo vi;
+ if (attr.ParseVolInfo(vi))
+ {
+ s.Add_Space();
+ s.Add_UInt32(vi.MajorVer);
+ s.Add_Dot();
+ s.Add_UInt32(vi.MinorVer);
+ }
+ break;
+ }
+ }
+ prop = s;
+ break;
+ }
+ case kpidSectorSize: prop = (UInt32)1 << Header.SectorSizeLog; break;
+ case kpidRecordSize: prop = (UInt32)1 << RecSizeLog; break;
+ case kpidId: prop = Header.SerialNumber; break;
+
+ case kpidIsTree: prop = true; break;
+ case kpidIsDeleted: prop = _showDeletedFiles; break;
+ case kpidIsAltStream: prop = ThereAreAltStreams; break;
+ case kpidIsAux: prop = true; break;
+ case kpidINode: prop = true; break;
+
+ case kpidWarning:
+ if (_lostFolderIndex_Normal >= 0)
+ prop = "There are lost files";
+ break;
+
+ /*
+ case kpidWarningFlags:
+ {
+ UInt32 flags = 0;
+ if (_headerWarning)
+ flags |= k_ErrorFlags_HeadersError;
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ */
+
+ // case kpidMediaType: prop = Header.MediaType; break;
+ // case kpidSectorsPerTrack: prop = Header.SectorsPerTrack; break;
+ // case kpidNumHeads: prop = Header.NumHeads; break;
+ // case kpidHiddenSectors: prop = Header.NumHiddenSectors; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (index >= Items.Size())
+ {
+ switch (propID)
+ {
+ case kpidName:
+ case kpidPath:
+ prop = VirtFolderNames[index - Items.Size()].GetRawPtr();
+ break;
+ case kpidIsDir: prop = true; break;
+ case kpidIsAux: prop = true; break;
+ case kpidIsDeleted:
+ if ((int)index == _lostFolderIndex_Deleted)
+ prop = true;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ const CItem &item = Items[index];
+ const CMftRec &rec = Recs[item.RecIndex];
+
+ const CAttr *data= NULL;
+ if (item.DataIndex >= 0)
+ data = &rec.DataAttrs[rec.DataRefs[item.DataIndex].Start];
+
+ // const CFileNameAttr *fn = &rec.FileNames[item.NameIndex];
+ /*
+ if (rec.FileNames.Size() > 0)
+ fn = &rec.FileNames[0];
+ */
+
+ switch (propID)
+ {
+ case kpidPath:
+ GetItemPath(index, prop);
+ break;
+
+ /*
+ case kpidLink:
+ if (!rec.ReparseAttr.SubsName.IsEmpty())
+ {
+ prop = rec.ReparseAttr.SubsName;
+ }
+ break;
+ case kpidLink2:
+ if (!rec.ReparseAttr.PrintName.IsEmpty())
+ {
+ prop = rec.ReparseAttr.PrintName;
+ }
+ break;
+
+ case kpidLinkType:
+ if (rec.ReparseAttr.Tag != 0)
+ {
+ prop = (rec.ReparseAttr.Tag & 0xFFFF);
+ }
+ break;
+ */
+
+ case kpidINode:
+ {
+ // const CMftRec &rec = Recs[item.RecIndex];
+ // prop = ((UInt64)rec.SeqNumber << 48) | item.RecIndex;
+ prop = (UInt32)item.RecIndex;
+ break;
+ }
+ case kpidStreamId:
+ {
+ if (item.DataIndex >= 0)
+ prop = ((UInt64)item.RecIndex << 32) | (unsigned)item.DataIndex;
+ break;
+ }
+
+ case kpidName:
+ {
+ const UString2 *s;
+ if (item.IsAltStream())
+ s = &rec.DataAttrs[rec.DataRefs[item.DataIndex].Start].Name;
+ else
+ s = &rec.FileNames[item.NameIndex].Name;
+ if (s->IsEmpty())
+ prop = (const wchar_t *)EmptyString;
+ else
+ prop = s->GetRawPtr();
+ break;
+ }
+
+ case kpidShortName:
+ {
+ if (!item.IsAltStream())
+ {
+ int dosNameIndex = rec.FindDosName(item.NameIndex);
+ if (dosNameIndex >= 0)
+ {
+ const UString2 &s = rec.FileNames[dosNameIndex].Name;
+ if (s.IsEmpty())
+ prop = (const wchar_t *)EmptyString;
+ else
+ prop = s.GetRawPtr();
+ }
+ }
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidIsAltStream: prop = item.IsAltStream(); break;
+ case kpidIsDeleted: prop = !rec.InUse(); break;
+ case kpidIsAux: prop = false; break;
+
+ case kpidMTime: NtfsTimeToProp(rec.SiAttr.MTime, prop); break;
+ case kpidCTime: NtfsTimeToProp(rec.SiAttr.CTime, prop); break;
+ case kpidATime: NtfsTimeToProp(rec.SiAttr.ATime, prop); break;
+ case kpidChangeTime: NtfsTimeToProp(rec.SiAttr.ThisRecMTime, prop); break;
+
+ /*
+ case kpidMTime2: if (fn) NtfsTimeToProp(fn->MTime, prop); break;
+ case kpidCTime2: if (fn) NtfsTimeToProp(fn->CTime, prop); break;
+ case kpidATime2: if (fn) NtfsTimeToProp(fn->ATime, prop); break;
+ case kpidRecMTime2: if (fn) NtfsTimeToProp(fn->ThisRecMTime, prop); break;
+ */
+
+ case kpidAttrib:
+ {
+ UInt32 attrib;
+ /* WinXP-64: The CFileNameAttr::Attrib is not updated after some changes. Why?
+ CSiAttr:attrib is updated better. So we use CSiAttr:Sttrib */
+ /*
+ if (fn)
+ attrib = fn->Attrib;
+ else
+ */
+ attrib = rec.SiAttr.Attrib;
+ if (item.IsDir())
+ attrib |= FILE_ATTRIBUTE_DIRECTORY;
+
+ /* some system entries can contain extra flags (Index View).
+ // 0x10000000 (Directory)
+ // 0x20000000 FILE_ATTR_VIEW_INDEX_PRESENT MFT_RECORD_IS_VIEW_INDEX (Index View)
+ But we don't need them */
+ attrib &= 0xFFFF;
+
+ prop = attrib;
+ break;
+ }
+ case kpidLinks: if (rec.MyNumNameLinks != 1) prop = rec.MyNumNameLinks; break;
+
+ case kpidNumAltStreams:
+ {
+ if (!item.IsAltStream())
+ {
+ unsigned num = rec.DataRefs.Size();
+ if (num > 0)
+ {
+ if (!rec.IsDir() && rec.DataAttrs[rec.DataRefs[0].Start].Name.IsEmpty())
+ num--;
+ if (num > 0)
+ prop = (UInt32)num;
+ }
+ }
+ break;
+ }
+
+ case kpidSize: if (data) prop = data->GetSize(); else if (!item.IsDir()) prop = (UInt64)0; break;
+ case kpidPackSize: if (data) prop = data->GetPackSize(); else if (!item.IsDir()) prop = (UInt64)0; break;
+ case kpidNumBlocks: if (data) prop = (UInt32)rec.GetNumExtents(item.DataIndex, Header.ClusterSizeLog, Header.NumClusters); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ OpenCallback = callback;
+ InStream = stream;
+ HRESULT res;
+ try
+ {
+ res = CDatabase::Open();
+ if (res == S_OK)
+ return S_OK;
+ }
+ catch(...)
+ {
+ Close();
+ throw;
+ }
+ Close();
+ return res;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ ClearAndClose();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = Items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt32 i;
+ UInt64 totalSize = 0;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ if (index >= (UInt32)Items.Size())
+ continue;
+ const CItem &item = Items[allFilesMode ? i : indices[i]];
+ const CMftRec &rec = Recs[item.RecIndex];
+ if (item.DataIndex >= 0)
+ totalSize += rec.GetSize((unsigned)item.DataIndex);
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ UInt32 clusterSize = Header.ClusterSize();
+ CByteBuffer buf(clusterSize);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (index >= (UInt32)Items.Size() || Items[index].IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const CItem &item = Items[index];
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ outStreamSpec->SetStream(realOutStream);
+ realOutStream.Release();
+ outStreamSpec->Init();
+
+ const CMftRec &rec = Recs[item.RecIndex];
+
+ int res = NExtract::NOperationResult::kDataError;
+ {
+ CMyComPtr<IInStream> inStream;
+ HRESULT hres = rec.GetStream(InStream, item.DataIndex, Header.ClusterSizeLog, Header.NumClusters, &inStream);
+ if (hres == S_FALSE)
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ {
+ RINOK(hres)
+ if (inStream)
+ {
+ hres = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
+ if (hres != S_OK && hres != S_FALSE)
+ {
+ RINOK(hres)
+ }
+ if (/* copyCoderSpec->TotalSize == item.GetSize() && */ hres == S_OK)
+ res = NExtract::NOperationResult::kOK;
+ }
+ }
+ }
+ if (item.DataIndex >= 0)
+ {
+ const CAttr &data = rec.DataAttrs[rec.DataRefs[item.DataIndex].Start];
+ totalPackSize += data.GetPackSize();
+ totalSize += data.GetSize();
+ }
+ outStreamSpec->ReleaseStream();
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = Items.Size() + VirtFolderNames.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ InitProps();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const wchar_t *name = names[i];
+ const PROPVARIANT &prop = values[i];
+
+ if (StringsAreEqualNoCase_Ascii(name, "ld"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, _showDeletedFiles))
+ }
+ else if (StringsAreEqualNoCase_Ascii(name, "ls"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, _showSystemFiles))
+ }
+ else
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { 'N', 'T', 'F', 'S', ' ', ' ', ' ', ' ', 0 };
+
+REGISTER_ARC_I(
+ "NTFS", "ntfs img", NULL, 0xD9,
+ k_Signature,
+ 3,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/PeHandler.cpp b/CPP/7zip/Archive/PeHandler.cpp
new file mode 100644
index 0000000..9851ed3
--- /dev/null
+++ b/CPP/7zip/Archive/PeHandler.cpp
@@ -0,0 +1,3272 @@
+// PeHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/DynamicBuffer.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G16(offs, v) v = Get16(p + (offs))
+#define G32(offs, v) v = Get32(p + (offs))
+#define G32_signed(offs, v) v = (Int32)Get32(p + (offs))
+#define G64(offs, v) v = Get64(p + (offs))
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NPe {
+
+static const UInt32 k_Signature32 = 0x00004550;
+
+static HRESULT CalcCheckSum(ISequentialInStream *stream, UInt32 size, UInt32 excludePos, UInt32 &res)
+{
+ const UInt32 kBufSizeMax = (UInt32)1 << 15;
+ UInt32 bufSize = kBufSizeMax;
+ CByteBuffer buffer(bufSize);
+ Byte *buf = buffer;
+ UInt32 sum = 0;
+ UInt32 pos = 0;
+ for (;;)
+ {
+ UInt32 rem = size - pos;
+ if (rem > bufSize)
+ rem = bufSize;
+ if (rem == 0)
+ break;
+ size_t processed = rem;
+ RINOK(ReadStream(stream, buf, &processed))
+
+ for (unsigned j = 0; j < 4; j++)
+ {
+ UInt32 e = excludePos + j;
+ if (pos <= e)
+ {
+ e -= pos;
+ if (e < processed)
+ buf[e] = 0;
+ }
+ }
+
+ const unsigned kStep = (1 << 4);
+ {
+ for (size_t i = processed; (i & (kStep - 1)) != 0; i++)
+ buf[i] = 0;
+ }
+ {
+ const Byte *buf2 = buf;
+ const Byte *bufLimit = buf + processed;
+ UInt64 sum2 = 0;
+ for (; buf2 < bufLimit; buf2 += kStep)
+ {
+ UInt64 sum3 = (UInt64)Get32(buf2)
+ + Get32(buf2 + 4)
+ + Get32(buf2 + 8)
+ + Get32(buf2 + 12);
+ sum2 += sum3;
+ }
+ sum2 = (UInt32)(sum2) + (UInt64)(sum2 >> 32);
+ UInt32 sum3 = ((UInt32)sum2 + (UInt32)(sum2 >> 32));
+ sum += (sum3 & 0xFFFF) + (sum3 >> 16);
+ sum = (sum & 0xFFFF) + (sum >> 16);
+ sum = (sum & 0xFFFF) + (sum >> 16);
+ }
+
+ pos += (UInt32)processed;
+ if (rem != processed)
+ break;
+ }
+ res = sum + pos;
+ return S_OK;
+}
+
+
+struct CVersion
+{
+ UInt16 Major;
+ UInt16 Minor;
+
+ void Parse(const Byte *p)
+ {
+ G16(0, Major);
+ G16(2, Minor);
+ }
+ void ToProp(NCOM::CPropVariant &prop);
+};
+
+void CVersion::ToProp(NCOM::CPropVariant &prop)
+{
+ char sz[32];
+ ConvertUInt32ToString(Major, sz);
+ unsigned len = MyStringLen(sz);
+ sz[len] = '.';
+ ConvertUInt32ToString(Minor, sz + len + 1);
+ prop = sz;
+}
+
+static const unsigned kCoffHeaderSize = 20;
+static const unsigned kPeHeaderSize = 4 + kCoffHeaderSize;
+static const unsigned k_OptHeader32_Size_MIN = 96;
+static const unsigned k_OptHeader64_Size_MIN = 112;
+
+static const UInt32 PE_IMAGE_FILE_DLL = (1 << 13);
+
+struct CHeader
+{
+ UInt16 Machine;
+ UInt16 NumSections;
+ UInt32 Time;
+ UInt32 PointerToSymbolTable;
+ UInt32 NumSymbols;
+ UInt16 OptHeaderSize;
+ UInt16 Flags;
+
+ void ParseBase(const Byte *p);
+ bool ParseCoff(const Byte *p);
+ bool ParsePe(const Byte *p);
+ bool IsDll() const { return (Flags & PE_IMAGE_FILE_DLL) != 0; }
+};
+
+void CHeader::ParseBase(const Byte *p)
+{
+ G16( 0, Machine);
+ G16( 2, NumSections);
+ G32( 4, Time);
+ G32( 8, PointerToSymbolTable);
+ G32(12, NumSymbols);
+ G16(16, OptHeaderSize);
+ G16(18, Flags);
+}
+
+bool CHeader::ParsePe(const Byte *p)
+{
+ if (Get32(p) != k_Signature32)
+ return false;
+ ParseBase(p + 4);
+ return OptHeaderSize >= k_OptHeader32_Size_MIN;
+}
+
+struct CDirLink
+{
+ UInt32 Va;
+ UInt32 Size;
+
+ CDirLink(): Va(0), Size(0) {}
+ void Parse(const Byte *p)
+ {
+ G32(0, Va);
+ G32(4, Size);
+ }
+};
+
+enum
+{
+ kDirLink_Certificate = 4,
+ kDirLink_Debug = 6
+};
+
+static const UInt32 kNumDirItemsMax = 16;
+
+struct CDebugEntry
+{
+ UInt32 Flags;
+ UInt32 Time;
+ CVersion Ver;
+ UInt32 Type;
+ UInt32 Size;
+ UInt32 Va;
+ UInt32 Pa;
+
+ void Parse(const Byte *p)
+ {
+ G32(0, Flags);
+ G32(4, Time);
+ Ver.Parse(p + 8);
+ G32(12, Type);
+ G32(16, Size);
+ G32(20, Va);
+ G32(24, Pa);
+ }
+};
+
+static const UInt32 k_CheckSum_Field_Offset = 64;
+
+static const UInt32 PE_OptHeader_Magic_32 = 0x10B;
+static const UInt32 PE_OptHeader_Magic_64 = 0x20B;
+
+static const UInt32 k_SubSystems_EFI_First = 10;
+static const UInt32 k_SubSystems_EFI_Last = 13;
+
+struct COptHeader
+{
+ UInt16 Magic;
+ Byte LinkerVerMajor;
+ Byte LinkerVerMinor;
+
+ UInt32 CodeSize;
+ UInt32 InitDataSize;
+ UInt32 UninitDataSize;
+
+ // UInt32 AddressOfEntryPoint;
+ // UInt32 BaseOfCode;
+ // UInt32 BaseOfData32;
+ UInt64 ImageBase;
+
+ UInt32 SectAlign;
+ UInt32 FileAlign;
+
+ CVersion OsVer;
+ CVersion ImageVer;
+ CVersion SubsysVer;
+
+ UInt32 ImageSize;
+ UInt32 HeadersSize;
+ UInt32 CheckSum;
+ UInt16 SubSystem;
+ UInt16 DllCharacts;
+
+ UInt64 StackReserve;
+ UInt64 StackCommit;
+ UInt64 HeapReserve;
+ UInt64 HeapCommit;
+
+ UInt32 NumDirItems;
+ CDirLink DirItems[kNumDirItemsMax];
+
+ bool Is64Bit() const { return Magic == PE_OptHeader_Magic_64; }
+ bool Parse(const Byte *p, UInt32 size);
+
+ int GetNumFileAlignBits() const
+ {
+ for (unsigned i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == FileAlign)
+ return (int)i;
+ return -1;
+ }
+
+ bool IsSybSystem_EFI() const
+ {
+ return
+ SubSystem >= k_SubSystems_EFI_First &&
+ SubSystem <= k_SubSystems_EFI_Last;
+ }
+};
+
+bool COptHeader::Parse(const Byte *p, UInt32 size)
+{
+ if (size < k_OptHeader32_Size_MIN)
+ return false;
+ Magic = Get16(p);
+ switch (Magic)
+ {
+ case PE_OptHeader_Magic_32:
+ case PE_OptHeader_Magic_64:
+ break;
+ default:
+ return false;
+ }
+ LinkerVerMajor = p[2];
+ LinkerVerMinor = p[3];
+
+ G32( 4, CodeSize);
+ G32( 8, InitDataSize);
+ G32(12, UninitDataSize);
+ // G32(16, AddressOfEntryPoint);
+ // G32(20, BaseOfCode);
+
+ G32(32, SectAlign);
+ G32(36, FileAlign);
+
+ OsVer.Parse(p + 40);
+ ImageVer.Parse(p + 44);
+ SubsysVer.Parse(p + 48);
+
+ // reserved = Get32(p + 52);
+
+ G32(56, ImageSize);
+ G32(60, HeadersSize);
+ G32(64, CheckSum);
+ G16(68, SubSystem);
+ G16(70, DllCharacts);
+
+ UInt32 pos;
+ if (Is64Bit())
+ {
+ if (size < k_OptHeader64_Size_MIN)
+ return false;
+ // BaseOfData32 = 0;
+ G64(24, ImageBase);
+ G64(72, StackReserve);
+ G64(80, StackCommit);
+ G64(88, HeapReserve);
+ G64(96, HeapCommit);
+ pos = 108;
+ }
+ else
+ {
+ // G32(24, BaseOfData32);
+ G32(28, ImageBase);
+ G32(72, StackReserve);
+ G32(76, StackCommit);
+ G32(80, HeapReserve);
+ G32(84, HeapCommit);
+ pos = 92;
+ }
+
+ G32(pos, NumDirItems);
+ if (NumDirItems > (1 << 16))
+ return false;
+ pos += 4;
+ if (pos + 8 * NumDirItems > size)
+ return false;
+ memset((void *)DirItems, 0, sizeof(DirItems));
+ for (UInt32 i = 0; i < NumDirItems && i < kNumDirItemsMax; i++)
+ DirItems[i].Parse(p + pos + i * 8);
+ return true;
+}
+
+static const UInt32 kSectionSize = 40;
+
+struct CSection
+{
+ AString Name;
+
+ UInt32 VSize;
+ UInt32 Va;
+ UInt32 PSize;
+ UInt32 Pa;
+ UInt32 Flags;
+ UInt32 Time;
+ // UInt16 NumRelocs;
+ bool IsRealSect;
+ bool IsDebug;
+ bool IsAdditionalSection;
+
+ CSection(): IsRealSect(false), IsDebug(false), IsAdditionalSection(false) {}
+
+ UInt32 GetSizeExtract() const { return PSize; }
+ UInt32 GetSizeMin() const { return MyMin(PSize, VSize); }
+
+ void UpdateTotalSize(UInt32 &totalSize) const
+ {
+ UInt32 t = Pa + PSize;
+ if (totalSize < t)
+ totalSize = t;
+ }
+
+ void Parse(const Byte *p);
+
+ int Compare(const CSection &s) const
+ {
+ RINOZ(MyCompare(Pa, s.Pa))
+ UInt32 size1 = GetSizeExtract();
+ UInt32 size2 = s.GetSizeExtract();
+ return MyCompare(size1, size2);
+ }
+};
+
+static const unsigned kNameSize = 8;
+
+static void GetName(const Byte *name, AString &res)
+{
+ res.SetFrom_CalcLen((const char *)name, kNameSize);
+}
+
+void CSection::Parse(const Byte *p)
+{
+ GetName(p, Name);
+ G32( 8, VSize);
+ G32(12, Va);
+ G32(16, PSize);
+ G32(20, Pa);
+ // G16(32, NumRelocs);
+ G32(36, Flags);
+}
+
+
+
+// IMAGE_FILE_*
+
+static const CUInt32PCharPair g_HeaderCharacts[] =
+{
+ { 1, "Executable" },
+ { 13, "DLL" },
+ { 8, "32-bit" },
+ { 5, "LargeAddress" },
+ { 0, "NoRelocs" },
+ { 2, "NoLineNums" },
+ { 3, "NoLocalSyms" },
+ { 4, "AggressiveWsTrim" },
+ { 9, "NoDebugInfo" },
+ { 10, "RemovableRun" },
+ { 11, "NetRun" },
+ { 12, "System" },
+ { 14, "UniCPU" },
+ { 7, "Little-Endian" },
+ { 15, "Big-Endian" }
+};
+
+// IMAGE_DLLCHARACTERISTICS_*
+
+static const char * const g_DllCharacts[] =
+{
+ NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "HighEntropyVA"
+ , "Relocated"
+ , "Integrity"
+ , "NX-Compatible"
+ , "NoIsolation"
+ , "NoSEH"
+ , "NoBind"
+ , "AppContainer"
+ , "WDM"
+ , "GuardCF"
+ , "TerminalServerAware"
+};
+
+
+// IMAGE_SCN_* constants:
+
+static const char * const g_SectFlags[] =
+{
+ NULL
+ , NULL
+ , NULL
+ , "NoPad"
+ , NULL
+ , "Code"
+ , "InitializedData"
+ , "UninitializedData"
+ , "Other"
+ , "Comments"
+ , NULL // OVER
+ , "Remove"
+ , "COMDAT"
+ , NULL
+ , "NO_DEFER_SPEC_EXC"
+ , "GP" // MEM_FARDATA
+ , NULL // SYSHEAP
+ , "PURGEABLE" // 16BIT
+ , "LOCKED"
+ , "PRELOAD"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "ExtendedRelocations"
+ , "Discardable"
+ , "NotCached"
+ , "NotPaged"
+ , "Shared"
+ , "Execute"
+ , "Read"
+ , "Write"
+};
+
+static const CUInt32PCharPair g_MachinePairs[] =
+{
+ { 0x014C, "x86" },
+ { 0x014D, "I860" },
+ { 0x0162, "MIPS-R3000" },
+ { 0x0166, "MIPS-R4000" },
+ { 0x0168, "MIPS-R10000" },
+ { 0x0169, "MIPS-V2" },
+ { 0x0184, "Alpha" },
+ { 0x01A2, "SH3" },
+ { 0x01A3, "SH3-DSP" },
+ { 0x01A4, "SH3E" },
+ { 0x01A6, "SH4" },
+ { 0x01A8, "SH5" },
+ { 0x01C0, "ARM" },
+ { 0x01C2, "ARM-Thumb" },
+ { 0x01C4, "ARM-NT" },
+ { 0x01D3, "AM33" },
+ { 0x01F0, "PPC" },
+ { 0x01F1, "PPC-FP" },
+ { 0x0200, "IA-64" },
+ { 0x0266, "MIPS-16" },
+ { 0x0284, "Alpha-64" },
+ { 0x0366, "MIPS-FPU" },
+ { 0x0466, "MIPS-FPU16" },
+ { 0x0520, "TriCore" },
+ { 0x0CEF, "CEF" },
+ { 0x0EBC, "EFI" },
+ { 0x8664, "x64" },
+ { 0x9041, "M32R" },
+ { 0xAA64, "ARM64" },
+ { 0xC0EE, "CEE" }
+};
+
+static const char * const g_SubSystems[] =
+{
+ "Unknown"
+ , "Native"
+ , "Windows GUI"
+ , "Windows CUI"
+ , NULL // "Old Windows CE"
+ , "OS2"
+ , NULL
+ , "Posix"
+ , "Win9x"
+ , "Windows CE"
+ , "EFI"
+ , "EFI Boot"
+ , "EFI Runtime"
+ , "EFI ROM"
+ , "XBOX"
+ , NULL
+ , "Windows Boot"
+ , "XBOX Catalog" // 17
+};
+
+static const char * const g_ResTypes[] =
+{
+ NULL
+ , "CURSOR"
+ , "BITMAP"
+ , "ICON"
+ , "MENU"
+ , "DIALOG"
+ , "STRING"
+ , "FONTDIR"
+ , "FONT"
+ , "ACCELERATOR"
+ , "RCDATA"
+ , "MESSAGETABLE"
+ , "GROUP_CURSOR"
+ , NULL
+ , "GROUP_ICON"
+ , NULL
+ , "VERSION"
+ , "DLGINCLUDE"
+ , NULL
+ , "PLUGPLAY"
+ , "VXD"
+ , "ANICURSOR"
+ , "ANIICON"
+ , "HTML"
+ , "MANIFEST"
+};
+
+static const UInt32 kFlag = (UInt32)1 << 31;
+static const UInt32 kMask = ~kFlag;
+
+struct CTableItem
+{
+ UInt32 Offset;
+ UInt32 ID;
+};
+
+
+static const UInt32 kBmpHeaderSize = 14;
+static const UInt32 kIconHeaderSize = 22;
+
+struct CResItem
+{
+ UInt32 Type;
+ UInt32 ID;
+ UInt32 Lang;
+
+ UInt32 Size;
+ UInt32 Offset;
+
+ UInt32 HeaderSize;
+ Byte Header[kIconHeaderSize]; // it must be enough for max size header.
+ bool Enabled;
+
+ bool IsNameEqual(const CResItem &item) const { return Lang == item.Lang; }
+ UInt32 GetSize() const { return Size + HeaderSize; }
+ bool IsBmp() const { return Type == 2; }
+ bool IsIcon() const { return Type == 3; }
+ bool IsString() const { return Type == 6; }
+ bool IsRcData() const { return Type == 10; }
+ bool IsVersion() const { return Type == 16; }
+ bool IsRcDataOrUnknown() const { return IsRcData() || Type > 64; }
+};
+
+struct CTextFile
+{
+ CByteDynamicBuffer Buf;
+
+ size_t FinalSize() const { return Buf.GetPos(); }
+
+ void AddChar(char c);
+ void AddWChar(UInt16 c);
+ void AddWChar_Smart(UInt16 c);
+ void NewLine();
+ void AddString(const char *s);
+ void AddSpaces(int num);
+ void AddBytes(const Byte *p, size_t size)
+ {
+ Buf.AddData(p, size);
+ }
+
+ void OpenBlock(int num)
+ {
+ AddSpaces(num);
+ AddChar('{');
+ NewLine();
+ }
+ void CloseBlock(int num)
+ {
+ AddSpaces(num);
+ AddChar('}');
+ NewLine();
+ }
+};
+
+void CTextFile::AddChar(char c)
+{
+ Byte *p = Buf.GetCurPtrAndGrow(2);
+ p[0] = (Byte)c;
+ p[1] = 0;
+}
+
+void CTextFile::AddWChar(UInt16 c)
+{
+ Byte *p = Buf.GetCurPtrAndGrow(2);
+ SetUi16(p, c)
+}
+
+void CTextFile::AddWChar_Smart(UInt16 c)
+{
+ if (c == '\n')
+ {
+ AddChar('\\');
+ c = 'n';
+ }
+ AddWChar(c);
+}
+
+void CTextFile::NewLine()
+{
+ AddChar(0x0D);
+ AddChar(0x0A);
+}
+
+void CTextFile::AddString(const char *s)
+{
+ for (;; s++)
+ {
+ char c = *s;
+ if (c == 0)
+ return;
+ AddChar(c);
+ }
+}
+
+void CTextFile::AddSpaces(int num)
+{
+ for (int i = 0; i < num; i++)
+ AddChar(' ');
+}
+
+struct CStringItem: public CTextFile
+{
+ UInt32 Lang;
+};
+
+struct CByteBuffer_WithLang: public CByteBuffer
+{
+ UInt32 Lang;
+};
+
+
+struct CMixItem
+{
+ int SectionIndex;
+ int ResourceIndex;
+ int StringIndex;
+ int VersionIndex;
+
+ CMixItem(): SectionIndex(-1), ResourceIndex(-1), StringIndex(-1), VersionIndex(-1) {}
+ bool IsSectionItem() const { return ResourceIndex < 0 && StringIndex < 0 && VersionIndex < 0; }
+};
+
+struct CUsedBitmap
+{
+ CByteBuffer Buf;
+public:
+ void Alloc(size_t size)
+ {
+ size = (size + 7) / 8;
+ Buf.Alloc(size);
+ memset(Buf, 0, size);
+ }
+
+ void Free()
+ {
+ Buf.Free();
+ }
+
+ bool SetRange(size_t from, unsigned size)
+ {
+ for (unsigned i = 0; i < size; i++)
+ {
+ size_t pos = (from + i) >> 3;
+ Byte mask = (Byte)(1 << ((from + i) & 7));
+ Byte b = Buf[pos];
+ if ((b & mask) != 0)
+ return false;
+ Buf[pos] = (Byte)(b | mask);
+ }
+ return true;
+ }
+};
+
+struct CStringKeyValue
+{
+ UString Key;
+ UString Value;
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_2(
+ IInArchiveGetStream,
+ IArchiveAllowTail
+)
+ CMyComPtr<IInStream> _stream;
+ CObjectVector<CSection> _sections;
+ CHeader _header;
+ UInt32 _totalSize;
+ Int32 _mainSubfile;
+
+ CRecordVector<CMixItem> _mixItems;
+ CRecordVector<CResItem> _items;
+ CObjectVector<CStringItem> _strings;
+ CObjectVector<CByteBuffer_WithLang> _versionFiles;
+ UString _versionFullString;
+ UString _versionShortString;
+ UString _originalFilename;
+ CObjectVector<CStringKeyValue> _versionKeys;
+
+ CByteBuffer _buf;
+ bool _oneLang;
+ UString _resourcesPrefix;
+ CUsedBitmap _usedRes;
+ // bool _parseResources;
+ bool _checksumError;
+ bool _sectionsError;
+
+ bool IsOpt() const { return _header.OptHeaderSize != 0; }
+
+ COptHeader _optHeader;
+
+ bool _coffMode;
+ bool _allowTail;
+
+ HRESULT LoadDebugSections(IInStream *stream, bool &thereIsSection);
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *callback);
+
+ void AddResNameToString(UString &s, UInt32 id) const;
+ void AddLangPrefix(UString &s, UInt32 lang) const;
+ HRESULT ReadString(UInt32 offset, UString &dest) const;
+ HRESULT ReadTable(UInt32 offset, CRecordVector<CTableItem> &items);
+ bool ParseStringRes(UInt32 id, UInt32 lang, const Byte *src, UInt32 size);
+ HRESULT OpenResources(unsigned sectIndex, IInStream *stream, IArchiveOpenCallback *callback);
+ void CloseResources();
+
+
+ bool CheckItem(const CSection §, const CResItem &item, size_t offset) const
+ {
+ return item.Offset >= sect.Va && offset <= _buf.Size() && _buf.Size() - offset >= item.Size;
+ }
+
+public:
+ CHandler(bool coffMode = false):
+ _coffMode(coffMode),
+ _allowTail(coffMode)
+ {}
+};
+
+
+enum
+{
+ kpidSectAlign = kpidUserDefined,
+ kpidFileAlign,
+ kpidLinkerVer,
+ kpidOsVer,
+ kpidImageVer,
+ kpidSubsysVer,
+ kpidCodeSize,
+ kpidImageSize,
+ kpidInitDataSize,
+ kpidUnInitDataSize,
+ kpidHeadersSizeUnInitDataSize,
+ kpidSubSystem,
+ kpidDllCharacts,
+ kpidStackReserve,
+ kpidStackCommit,
+ kpidHeapReserve,
+ kpidHeapCommit,
+ kpidImageBase
+ // kpidAddressOfEntryPoint,
+ // kpidBaseOfCode,
+ // kpidBaseOfData32,
+};
+
+static const CStatProp kArcProps[] =
+{
+ // { NULL, kpidWarning, VT_BSTR},
+ { NULL, kpidCpu, VT_BSTR},
+ { NULL, kpidBit64, VT_BOOL},
+ { NULL, kpidCharacts, VT_BSTR},
+ { NULL, kpidCTime, VT_FILETIME},
+ { NULL, kpidHeadersSize, VT_UI4},
+ { NULL, kpidChecksum, VT_UI4},
+ { NULL, kpidName, VT_BSTR},
+
+ { "Image Size", kpidImageSize, VT_UI4},
+ { "Section Alignment", kpidSectAlign, VT_UI4},
+ { "File Alignment", kpidFileAlign, VT_UI4},
+ { "Code Size", kpidCodeSize, VT_UI4},
+ { "Initialized Data Size", kpidInitDataSize, VT_UI4},
+ { "Uninitialized Data Size", kpidUnInitDataSize, VT_UI4},
+ { "Linker Version", kpidLinkerVer, VT_BSTR},
+ { "OS Version", kpidOsVer, VT_BSTR},
+ { "Image Version", kpidImageVer, VT_BSTR},
+ { "Subsystem Version", kpidSubsysVer, VT_BSTR},
+ { "Subsystem", kpidSubSystem, VT_BSTR},
+ { "DLL Characteristics", kpidDllCharacts, VT_BSTR},
+ { "Stack Reserve", kpidStackReserve, VT_UI8},
+ { "Stack Commit", kpidStackCommit, VT_UI8},
+ { "Heap Reserve", kpidHeapReserve, VT_UI8},
+ { "Heap Commit", kpidHeapCommit, VT_UI8},
+ { "Image Base", kpidImageBase, VT_UI8},
+ { NULL, kpidComment, VT_BSTR},
+
+ // { "Address Of Entry Point", kpidAddressOfEntryPoint, VT_UI8},
+ // { "Base Of Code", kpidBaseOfCode, VT_UI8},
+ // { "Base Of Data", kpidBaseOfData32, VT_UI8},
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidVirtualSize,
+ kpidCharacts,
+ kpidOffset,
+ kpidVa,
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+static void TimeToProp(UInt32 unixTime, NCOM::CPropVariant &prop)
+{
+ if (unixTime != 0)
+ PropVariant_SetFrom_UnixTime(prop, unixTime);
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _totalSize; break;
+ case kpidComment: if (!_versionFullString.IsEmpty()) prop = _versionFullString; break;
+ case kpidShortComment:
+ if (!_versionShortString.IsEmpty())
+ prop = _versionShortString;
+ else
+ {
+ PAIR_TO_PROP(g_MachinePairs, _header.Machine, prop);
+ }
+ break;
+
+ case kpidName: if (!_originalFilename.IsEmpty()) prop = _originalFilename; break;
+
+ // case kpidIsSelfExe: prop = !_header.IsDll(); break;
+ // case kpidError:
+ case kpidWarning: if (_checksumError) prop = "Checksum error"; break;
+
+ case kpidWarningFlags:
+ {
+ UInt32 v = 0;
+ if (_sectionsError) v |= kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidCpu: PAIR_TO_PROP(g_MachinePairs, _header.Machine, prop); break;
+ case kpidMTime:
+ case kpidCTime: TimeToProp(_header.Time, prop); break;
+ case kpidCharacts: FLAGS_TO_PROP(g_HeaderCharacts, _header.Flags, prop); break;
+ case kpidMainSubfile: if (_mainSubfile >= 0) prop = (UInt32)_mainSubfile; break;
+
+ default:
+ if (IsOpt())
+ switch (propID)
+ {
+
+ case kpidSectAlign: prop = _optHeader.SectAlign; break;
+ case kpidFileAlign: prop = _optHeader.FileAlign; break;
+ case kpidLinkerVer:
+ {
+ CVersion v = { _optHeader.LinkerVerMajor, _optHeader.LinkerVerMinor };
+ v.ToProp(prop);
+ break;
+ }
+
+ case kpidOsVer: _optHeader.OsVer.ToProp(prop); break;
+ case kpidImageVer: _optHeader.ImageVer.ToProp(prop); break;
+ case kpidSubsysVer: _optHeader.SubsysVer.ToProp(prop); break;
+ case kpidCodeSize: prop = _optHeader.CodeSize; break;
+ case kpidInitDataSize: prop = _optHeader.InitDataSize; break;
+ case kpidUnInitDataSize: prop = _optHeader.UninitDataSize; break;
+ case kpidImageSize: prop = _optHeader.ImageSize; break;
+ case kpidHeadersSize: prop = _optHeader.HeadersSize; break;
+ case kpidChecksum: prop = _optHeader.CheckSum; break;
+
+ case kpidExtension:
+ if (_header.IsDll())
+ prop = "dll";
+ else if (_optHeader.IsSybSystem_EFI())
+ prop = "efi";
+ break;
+
+ case kpidBit64: if (_optHeader.Is64Bit()) prop = true; break;
+ case kpidSubSystem: TYPE_TO_PROP(g_SubSystems, _optHeader.SubSystem, prop); break;
+
+ case kpidDllCharacts: FLAGS_TO_PROP(g_DllCharacts, _optHeader.DllCharacts, prop); break;
+ case kpidStackReserve: prop = _optHeader.StackReserve; break;
+ case kpidStackCommit: prop = _optHeader.StackCommit; break;
+ case kpidHeapReserve: prop = _optHeader.HeapReserve; break;
+ case kpidHeapCommit: prop = _optHeader.HeapCommit; break;
+
+ case kpidImageBase: prop = _optHeader.ImageBase; break;
+ // case kpidAddressOfEntryPoint: prop = _optHeader.AddressOfEntryPoint; break;
+ // case kpidBaseOfCode: prop = _optHeader.BaseOfCode; break;
+ // case kpidBaseOfData32: if (!_optHeader.Is64Bit()) prop = _optHeader.BaseOfData32; break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+HRESULT CHandler::ReadString(UInt32 offset, UString &dest) const
+{
+ if ((offset & 1) != 0 || offset >= _buf.Size())
+ return S_FALSE;
+ size_t rem = _buf.Size() - offset;
+ if (rem < 2)
+ return S_FALSE;
+ unsigned len = Get16(_buf + offset);
+ if ((rem - 2) / 2 < len)
+ return S_FALSE;
+ dest.Empty();
+ wchar_t *destBuf = dest.GetBuf(len);
+ offset += 2;
+ const Byte *src = _buf + offset;
+ unsigned i;
+ for (i = 0; i < len; i++)
+ {
+ wchar_t c = (wchar_t)Get16(src + i * 2);
+ if (c == 0)
+ break;
+ destBuf[i] = c;
+ }
+ destBuf[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+ return S_OK;
+}
+
+void CHandler::AddResNameToString(UString &s, UInt32 id) const
+{
+ if ((id & kFlag) != 0)
+ {
+ UString name;
+ if (ReadString(id & kMask, name) == S_OK)
+ {
+ const wchar_t *str = L"[]";
+ if (name.Len() > 1 && name[0] == '"' && name.Back() == '"')
+ {
+ if (name.Len() != 2)
+ {
+ name.DeleteBack();
+ str = name.Ptr(1);
+ }
+ }
+ else if (!name.IsEmpty())
+ str = name;
+ s += str;
+ return;
+ }
+ }
+ s.Add_UInt32(id);
+}
+
+void CHandler::AddLangPrefix(UString &s, UInt32 lang) const
+{
+ if (!_oneLang)
+ {
+ AddResNameToString(s, lang);
+ s.Add_PathSepar();
+ }
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ const CMixItem &mixItem = _mixItems[index];
+ if (mixItem.StringIndex >= 0)
+ {
+ const CStringItem &item = _strings[mixItem.StringIndex];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString s = _resourcesPrefix;
+ AddLangPrefix(s, item.Lang);
+ s += "string.txt";
+ prop = s;
+ break;
+ }
+ case kpidSize:
+ case kpidPackSize:
+ prop = (UInt64)item.FinalSize(); break;
+ }
+ }
+ else if (mixItem.VersionIndex >= 0)
+ {
+ const CByteBuffer_WithLang &item = _versionFiles[mixItem.VersionIndex];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString s = _resourcesPrefix;
+ AddLangPrefix(s, item.Lang);
+ s += "version.txt";
+ prop = s;
+ break;
+ }
+ case kpidSize:
+ case kpidPackSize:
+ prop = (UInt64)item.Size(); break;
+ }
+ }
+ else if (mixItem.ResourceIndex >= 0)
+ {
+ const CResItem &item = _items[mixItem.ResourceIndex];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString s = _resourcesPrefix;
+ AddLangPrefix(s, item.Lang);
+ {
+ const char *p = NULL;
+ if (item.Type < Z7_ARRAY_SIZE(g_ResTypes))
+ p = g_ResTypes[item.Type];
+ if (p)
+ s += p;
+ else
+ AddResNameToString(s, item.Type);
+ }
+ s.Add_PathSepar();
+ AddResNameToString(s, item.ID);
+ if (item.HeaderSize != 0)
+ {
+ if (item.IsBmp())
+ s += ".bmp";
+ else if (item.IsIcon())
+ s += ".ico";
+ }
+ prop = s;
+ break;
+ }
+ case kpidSize: prop = (UInt64)item.GetSize(); break;
+ case kpidPackSize: prop = (UInt64)item.Size; break;
+ }
+ }
+ else
+ {
+ const CSection &item = _sections[mixItem.SectionIndex];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString s = item.Name;
+ s.Replace('/', '_');
+ s.Replace('\\', '_');
+ prop = MultiByteToUnicodeString(s);
+ break;
+ }
+ case kpidSize: prop = (UInt64)item.PSize; break;
+ case kpidPackSize: prop = (UInt64)item.PSize; break;
+ case kpidVirtualSize: prop = (UInt64)item.VSize; break;
+ case kpidOffset: prop = item.Pa; break;
+ case kpidVa: if (item.IsRealSect) prop = item.Va; break;
+ case kpidMTime:
+ case kpidCTime:
+ TimeToProp(item.IsDebug ? item.Time : _header.Time, prop); break;
+ case kpidCharacts:
+ if (item.IsRealSect)
+ {
+ UInt32 flags = item.Flags;
+ const UInt32 MY_IMAGE_SCN_ALIGN_MASK = 0x00F00000;
+ AString s = FlagsToString(g_SectFlags, Z7_ARRAY_SIZE(g_SectFlags), item.Flags & ~MY_IMAGE_SCN_ALIGN_MASK);
+ const UInt32 align = ((flags >> 20) & 0xF);
+ if (align != 0)
+ {
+ char sz[32];
+ ConvertUInt32ToString(1 << (align - 1), sz);
+ s.Add_Space();
+ s += "align_";
+ s += sz;
+ }
+ prop = s;
+ }
+ break;
+ case kpidZerosTailIsAllowed: if (!item.IsRealSect) prop = true; break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+HRESULT CHandler::LoadDebugSections(IInStream *stream, bool &thereIsSection)
+{
+ thereIsSection = false;
+ const CDirLink &debugLink = _optHeader.DirItems[kDirLink_Debug];
+ if (debugLink.Size == 0)
+ return S_OK;
+ const unsigned kEntrySize = 28;
+ UInt32 numItems = debugLink.Size / kEntrySize;
+ if (numItems > 16)
+ return S_FALSE;
+
+ // MAC's EFI file: numItems can be incorrect. Only first CDebugEntry entry is correct.
+ // debugLink.Size = kEntrySize + some_data, pointed by entry[0].
+ if (numItems * kEntrySize != debugLink.Size)
+ {
+ // return S_FALSE;
+ if (numItems > 1)
+ numItems = 1;
+ }
+
+ UInt64 pa = 0;
+ unsigned i;
+ for (i = 0; i < _sections.Size(); i++)
+ {
+ const CSection § = _sections[i];
+ if (sect.Va <= debugLink.Va && debugLink.Va + debugLink.Size <= sect.Va + sect.PSize)
+ {
+ pa = sect.Pa + (debugLink.Va - sect.Va);
+ break;
+ }
+ }
+ if (i == _sections.Size())
+ {
+ // Exe for ARM requires S_OK
+ // return S_FALSE;
+ return S_OK;
+ }
+
+ CByteBuffer buffer(debugLink.Size);
+ Byte *buf = buffer;
+
+ RINOK(InStream_SeekSet(stream, pa))
+ RINOK(ReadStream_FALSE(stream, buf, debugLink.Size))
+
+ for (i = 0; i < numItems; i++)
+ {
+ CDebugEntry de;
+ de.Parse(buf);
+
+ if (de.Size == 0)
+ continue;
+
+ UInt32 totalSize = de.Pa + de.Size;
+ if (totalSize > _totalSize)
+ {
+ _totalSize = totalSize;
+ thereIsSection = true;
+
+ CSection § = _sections.AddNew();
+ sect.Name = ".debug";
+ sect.Name.Add_UInt32(i);
+ sect.IsDebug = true;
+ sect.Time = de.Time;
+ sect.Va = de.Va;
+ sect.Pa = de.Pa;
+ sect.PSize = sect.VSize = de.Size;
+ }
+ buf += kEntrySize;
+ }
+
+ return S_OK;
+}
+
+HRESULT CHandler::ReadTable(UInt32 offset, CRecordVector<CTableItem> &items)
+{
+ if ((offset & 3) != 0 || offset >= _buf.Size())
+ return S_FALSE;
+ size_t rem = _buf.Size() - offset;
+ if (rem < 16)
+ return S_FALSE;
+ unsigned numNameItems = Get16(_buf + offset + 12);
+ unsigned numIdItems = Get16(_buf + offset + 14);
+ unsigned numItems = numNameItems + numIdItems;
+ if ((rem - 16) / 8 < numItems)
+ return S_FALSE;
+ if (!_usedRes.SetRange(offset, 16 + numItems * 8))
+ return S_FALSE;
+ offset += 16;
+ items.ClearAndReserve(numItems);
+ for (unsigned i = 0; i < numItems; i++, offset += 8)
+ {
+ const Byte *buf = _buf + offset;
+ CTableItem item;
+ item.ID = Get32(buf + 0);
+ if ((bool)((item.ID & kFlag) != 0) != (bool)(i < numNameItems))
+ return S_FALSE;
+ item.Offset = Get32(buf + 4);
+ items.AddInReserved(item);
+ }
+ return S_OK;
+}
+
+static const UInt32 kFileSizeMax = (UInt32)1 << 31;
+static const unsigned kNumResItemsMax = (unsigned)1 << 23;
+static const unsigned kNumStringLangsMax = 256;
+
+// BITMAPINFOHEADER
+struct CBitmapInfoHeader
+{
+ // UInt32 HeaderSize;
+ UInt32 XSize;
+ Int32 YSize;
+ UInt16 Planes;
+ UInt16 BitCount;
+ UInt32 Compression;
+ UInt32 SizeImage;
+
+ bool Parse(const Byte *p, size_t size);
+};
+
+static const UInt32 kBitmapInfoHeader_Size = 0x28;
+
+bool CBitmapInfoHeader::Parse(const Byte *p, size_t size)
+{
+ if (size < kBitmapInfoHeader_Size || Get32(p) != kBitmapInfoHeader_Size)
+ return false;
+ G32( 4, XSize);
+ G32_signed( 8, YSize);
+ G16(12, Planes);
+ G16(14, BitCount);
+ G32(16, Compression);
+ G32(20, SizeImage);
+ return true;
+}
+
+static UInt32 GetImageSize(UInt32 xSize, UInt32 ySize, UInt32 bitCount)
+{
+ return ((xSize * bitCount + 7) / 8 + 3) / 4 * 4 * ySize;
+}
+
+static UInt32 SetBitmapHeader(Byte *dest, const Byte *src, UInt32 size)
+{
+ CBitmapInfoHeader h;
+ if (!h.Parse(src, size))
+ return 0;
+ if (h.YSize < 0)
+ h.YSize = -h.YSize;
+ if (h.XSize > (1 << 26)
+ || h.YSize > (1 << 26)
+ || h.YSize < 0
+ || h.Planes != 1 || h.BitCount > 32)
+ return 0;
+ if (h.SizeImage == 0)
+ {
+ if (h.Compression != 0) // BI_RGB
+ return 0;
+ h.SizeImage = GetImageSize(h.XSize, (UInt32)h.YSize, h.BitCount);
+ }
+ UInt32 totalSize = kBmpHeaderSize + size;
+ UInt32 offBits = totalSize - h.SizeImage;
+ // BITMAPFILEHEADER
+ SetUi16(dest, 0x4D42)
+ SetUi32(dest + 2, totalSize)
+ SetUi32(dest + 6, 0)
+ SetUi32(dest + 10, offBits)
+ return kBmpHeaderSize;
+}
+
+static UInt32 SetIconHeader(Byte *dest, const Byte *src, UInt32 size)
+{
+ CBitmapInfoHeader h;
+ if (!h.Parse(src, size))
+ return 0;
+ if (h.YSize < 0)
+ h.YSize = -h.YSize;
+ if (h.XSize > (1 << 26)
+ || h.YSize > (1 << 26)
+ || h.YSize < 0
+ || h.Planes != 1
+ || h.Compression != 0) // BI_RGB
+ return 0;
+
+ const UInt32 numBitCount = h.BitCount;
+ if (numBitCount != 1 &&
+ numBitCount != 4 &&
+ numBitCount != 8 &&
+ numBitCount != 24 &&
+ numBitCount != 32)
+ return 0;
+
+ if ((h.YSize & 1) != 0)
+ return 0;
+ h.YSize /= 2;
+ if (h.XSize > 0x100 || h.YSize > 0x100)
+ return 0;
+
+ UInt32 imageSize;
+ // imageSize is not correct if AND mask array contains zeros
+ // in this case it is equal image1Size
+
+ // UInt32 imageSize = h.SizeImage;
+ // if (imageSize == 0)
+ // {
+ const UInt32 image1Size = GetImageSize(h.XSize, (UInt32)h.YSize, h.BitCount);
+ const UInt32 image2Size = GetImageSize(h.XSize, (UInt32)h.YSize, 1);
+ imageSize = image1Size + image2Size;
+ // }
+ UInt32 numColors = 0;
+ if (numBitCount < 16)
+ numColors = 1 << numBitCount;
+
+ SetUi16(dest, 0) // Reserved
+ SetUi16(dest + 2, 1) // RES_ICON
+ SetUi16(dest + 4, 1) // ResCount
+
+ dest[6] = (Byte)h.XSize; // Width
+ dest[7] = (Byte)h.YSize; // Height
+ dest[8] = (Byte)numColors; // ColorCount
+ dest[9] = 0; // Reserved
+
+ SetUi32(dest + 10, 0) // Reserved1 / Reserved2
+
+ UInt32 numQuadsBytes = numColors * 4;
+ UInt32 BytesInRes = kBitmapInfoHeader_Size + numQuadsBytes + imageSize;
+ SetUi32(dest + 14, BytesInRes)
+ SetUi32(dest + 18, kIconHeaderSize)
+
+ /*
+ Description = DWORDToString(xSize) +
+ kDelimiterChar + DWORDToString(ySize) +
+ kDelimiterChar + DWORDToString(numBitCount);
+ */
+ return kIconHeaderSize;
+}
+
+bool CHandler::ParseStringRes(UInt32 id, UInt32 lang, const Byte *src, UInt32 size)
+{
+ if ((size & 1) != 0)
+ return false;
+
+ unsigned i;
+ for (i = 0; i < _strings.Size(); i++)
+ if (_strings[i].Lang == lang)
+ break;
+ if (i == _strings.Size())
+ {
+ if (_strings.Size() >= kNumStringLangsMax)
+ return false;
+ CStringItem &item = _strings.AddNew();
+ item.Lang = lang;
+ }
+
+ CStringItem &item = _strings[i];
+ id = (id - 1) << 4;
+ UInt32 pos = 0;
+ for (i = 0; i < 16; i++)
+ {
+ if (size - pos < 2)
+ return false;
+ UInt32 len = Get16(src + pos);
+ pos += 2;
+ if (len != 0)
+ {
+ if (size - pos < len * 2)
+ return false;
+ char temp[32];
+ ConvertUInt32ToString(id + i, temp);
+ size_t tempLen = strlen(temp);
+ size_t j;
+ for (j = 0; j < tempLen; j++)
+ item.AddChar(temp[j]);
+ item.AddChar('\t');
+ for (j = 0; j < len; j++, pos += 2)
+ item.AddWChar_Smart(Get16(src + pos));
+ item.NewLine();
+ }
+ }
+ if (size == pos)
+ return true;
+
+ // Some rare case files have additional ZERO.
+ if (size == pos + 2 && Get16(src + pos) == 0)
+ return true;
+
+ return false;
+}
+
+
+// ---------- VERSION ----------
+
+static const UInt32 kMy_VS_FFI_SIGNATURE = 0xFEEF04BD;
+
+struct CMy_VS_FIXEDFILEINFO
+{
+ // UInt32 Signature;
+ // UInt32 StrucVersion;
+ UInt32 VersionMS;
+ UInt32 VersionLS;
+ UInt32 ProductVersionMS;
+ UInt32 ProductVersionLS;
+ UInt32 FlagsMask;
+ UInt32 Flags;
+ UInt32 OS;
+ UInt32 Type;
+ UInt32 Subtype;
+ UInt32 DateMS;
+ UInt32 DateLS;
+
+ bool Parse(const Byte *p);
+ void PrintToTextFile(CTextFile &f, CObjectVector<CStringKeyValue> &keys);
+};
+
+bool CMy_VS_FIXEDFILEINFO::Parse(const Byte *p)
+{
+ if (Get32(p) != kMy_VS_FFI_SIGNATURE) // signature;
+ return false;
+ // G32(0x04, StrucVersion);
+ G32(0x08, VersionMS);
+ G32(0x0C, VersionLS);
+ G32(0x10, ProductVersionMS);
+ G32(0x14, ProductVersionLS);
+ G32(0x18, FlagsMask);
+ G32(0x1C, Flags);
+ G32(0x20, OS);
+ G32(0x24, Type);
+ G32(0x28, Subtype);
+ G32(0x2C, DateMS);
+ G32(0x40, DateLS);
+ return true;
+}
+
+static void PrintUInt32(CTextFile &f, UInt32 v)
+{
+ char s[16];
+ ConvertUInt32ToString(v, s);
+ f.AddString(s);
+}
+
+static inline void PrintUInt32(UString &dest, UInt32 v)
+{
+ dest.Add_UInt32(v);
+}
+
+static void PrintHex(CTextFile &f, UInt32 val)
+{
+ char temp[16];
+ temp[0] = '0';
+ temp[1] = 'x';
+ ConvertUInt32ToHex(val, temp + 2);
+ f.AddString(temp);
+}
+
+static void PrintVersion(CTextFile &f, UInt32 ms, UInt32 ls)
+{
+ PrintUInt32(f, HIWORD(ms)); f.AddChar(',');
+ PrintUInt32(f, LOWORD(ms)); f.AddChar(',');
+ PrintUInt32(f, HIWORD(ls)); f.AddChar(',');
+ PrintUInt32(f, LOWORD(ls));
+}
+
+static void PrintVersion(UString &s, UInt32 ms, UInt32 ls)
+{
+ PrintUInt32(s, HIWORD(ms)); s.Add_Dot();
+ PrintUInt32(s, LOWORD(ms)); s.Add_Dot();
+ PrintUInt32(s, HIWORD(ls)); s.Add_Dot();
+ PrintUInt32(s, LOWORD(ls));
+}
+
+static const char * const k_VS_FileFlags[] =
+{
+ "DEBUG"
+ , "PRERELEASE"
+ , "PATCHED"
+ , "PRIVATEBUILD"
+ , "INFOINFERRED"
+ , "SPECIALBUILD"
+};
+
+static const CUInt32PCharPair k_VS_FileOS[] =
+{
+ { 0x10001, "VOS_DOS_WINDOWS16" },
+ { 0x10004, "VOS_DOS_WINDOWS32" },
+ { 0x20002, "VOS_OS216_PM16" },
+ { 0x30003, "VOS_OS232_PM32" },
+ { 0x40004, "VOS_NT_WINDOWS32" }
+};
+
+static const char * const k_VS_FileOS_High[] =
+{
+ "VOS_UNKNOWN"
+ , "VOS_DOS"
+ , "VOS_OS216"
+ , "VOS_OS232"
+ , "VOS_NT"
+ , "VOS_WINCE"
+};
+
+static const UInt32 kMY_VFT_DRV = 3;
+static const UInt32 kMY_VFT_FONT = 4;
+
+static const char * const k_VS_FileOS_Low[] =
+{
+ "VOS__BASE"
+ , "VOS__WINDOWS16"
+ , "VOS__PM16"
+ , "VOS__PM32"
+ , "VOS__WINDOWS32"
+};
+
+static const char * const k_VS_FileType[] =
+{
+ "VFT_UNKNOWN"
+ , "VFT_APP"
+ , "VFT_DLL"
+ , "VFT_DRV"
+ , "VFT_FONT"
+ , "VFT_VXD"
+ , "0x6"
+ , "VFT_STATIC_LIB"
+};
+
+// Subtype for VFT_DRV Type
+static const char * const k_VS_FileSubType_DRV[] =
+{
+ "0"
+ , "PRINTER"
+ , "KEYBOARD"
+ , "LANGUAGE"
+ , "DISPLAY"
+ , "MOUSE"
+ , "NETWORK"
+ , "SYSTEM"
+ , "INSTALLABLE"
+ , "SOUND"
+ , "COMM"
+ , "INPUTMETHOD"
+ , "VERSIONED_PRINTER"
+};
+
+// Subtype for VFT_FONT Type
+static const char * const k_VS_FileSubType_FONT[] =
+{
+ "0"
+ , "VFT2_FONT_RASTER"
+ , "VFT2_FONT_VECTOR"
+ , "VFT2_FONT_TRUETYPE"
+};
+
+static int FindKey(CObjectVector<CStringKeyValue> &v, const char *key)
+{
+ FOR_VECTOR (i, v)
+ if (v[i].Key.IsEqualTo(key))
+ return (int)i;
+ return -1;
+}
+
+static void AddToUniqueUStringVector(CObjectVector<CStringKeyValue> &v, const UString &key, const UString &value)
+{
+ bool needInsert = false;
+ unsigned i;
+ for (i = 0; i < v.Size(); i++)
+ {
+ if (v[i].Key == key)
+ {
+ if (v[i].Value == value)
+ return;
+ needInsert = true;
+ }
+ else if (needInsert)
+ break;
+ }
+ CStringKeyValue &pair = v.InsertNew(i);
+ pair.Key = key;
+ pair.Value = value;
+}
+
+void CMy_VS_FIXEDFILEINFO::PrintToTextFile(CTextFile &f, CObjectVector<CStringKeyValue> &keys)
+{
+ f.AddString("FILEVERSION ");
+ PrintVersion(f, VersionMS, VersionLS);
+ f.NewLine();
+
+ f.AddString("PRODUCTVERSION ");
+ PrintVersion(f, ProductVersionMS, ProductVersionLS);
+ f.NewLine();
+
+ {
+ UString s;
+ PrintVersion(s, VersionMS, VersionLS);
+ AddToUniqueUStringVector(keys, L"FileVersion", s);
+ }
+ {
+ UString s;
+ PrintVersion(s, ProductVersionMS, ProductVersionLS);
+ AddToUniqueUStringVector(keys, L"ProductVersion", s);
+ }
+
+ f.AddString("FILEFLAGSMASK ");
+ PrintHex(f, FlagsMask);
+ f.NewLine();
+
+ f.AddString("FILEFLAGS ");
+ {
+ bool wasPrinted = false;
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_VS_FileFlags); i++)
+ {
+ if ((Flags & ((UInt32)1 << i)) != 0)
+ {
+ if (wasPrinted)
+ f.AddString(" | ");
+ f.AddString("VS_FF_");
+ f.AddString(k_VS_FileFlags[i]);
+ wasPrinted = true;
+ }
+ }
+ UInt32 v = Flags & ~(((UInt32)1 << Z7_ARRAY_SIZE(k_VS_FileFlags)) - 1);
+ if (v != 0 || !wasPrinted)
+ {
+ if (wasPrinted)
+ f.AddString(" | ");
+ PrintHex(f, v);
+ }
+ }
+ f.NewLine();
+
+ // OS = 0x111230;
+ f.AddString("FILEOS ");
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(k_VS_FileOS); i++)
+ {
+ const CUInt32PCharPair &pair = k_VS_FileOS[i];
+ if (OS == pair.Value)
+ {
+ // continue;
+ // f.AddString("VOS_");
+ f.AddString(pair.Name);
+ break;
+ }
+ }
+ if (i == Z7_ARRAY_SIZE(k_VS_FileOS))
+ {
+ UInt32 high = OS >> 16;
+ if (high < Z7_ARRAY_SIZE(k_VS_FileOS_High))
+ f.AddString(k_VS_FileOS_High[high]);
+ else
+ PrintHex(f, high << 16);
+ UInt32 low = OS & 0xFFFF;
+ if (low != 0)
+ {
+ f.AddString(" | ");
+ if (low < Z7_ARRAY_SIZE(k_VS_FileOS_Low))
+ f.AddString(k_VS_FileOS_Low[low]);
+ else
+ PrintHex(f, low);
+ }
+ }
+ f.NewLine();
+
+ f.AddString("FILETYPE ");
+ if (Type < Z7_ARRAY_SIZE(k_VS_FileType))
+ f.AddString(k_VS_FileType[Type]);
+ else
+ PrintHex(f, Type);
+ f.NewLine();
+
+ f.AddString("FILESUBTYPE ");
+ bool needPrintSubType = true;
+ if (Type == kMY_VFT_DRV)
+ {
+ if (Subtype != 0 && Subtype < Z7_ARRAY_SIZE(k_VS_FileSubType_DRV))
+ {
+ f.AddString("VFT2_DRV_");
+ f.AddString(k_VS_FileSubType_DRV[Subtype]);
+ needPrintSubType = false;
+ }
+ }
+ else if (Type == kMY_VFT_FONT)
+ {
+ if (Subtype != 0 && Subtype < Z7_ARRAY_SIZE(k_VS_FileSubType_FONT))
+ {
+ f.AddString(k_VS_FileSubType_FONT[Subtype]);
+ needPrintSubType = false;
+ }
+ }
+ if (needPrintSubType)
+ PrintHex(f, Subtype);
+ f.NewLine();
+}
+
+static void CopyToUString(const Byte *p, UString &s)
+{
+ for (;;)
+ {
+ wchar_t c = (wchar_t)Get16(p);
+ p += 2;
+ if (c == 0)
+ return;
+ s += c;
+ }
+}
+
+static bool CompareWStrStrings(const Byte *p, const char *s)
+{
+ unsigned pos = 0;
+ for (;;)
+ {
+ const Byte c = (Byte)*s++;
+ if (Get16(p + pos) != c)
+ return false;
+ pos += 2;
+ if (c == 0)
+ return true;
+ }
+}
+
+struct CVersionBlock
+{
+ UInt32 TotalLen;
+ UInt32 ValueLen;
+ bool IsTextValue;
+ unsigned StrSize;
+
+ bool Parse(const Byte *p, UInt32 size);
+};
+
+static int Get_Utf16Str_Len_InBytes(const Byte *p, size_t size)
+{
+ unsigned pos = 0;
+ for (;;)
+ {
+ if (pos + 1 >= size)
+ return -1;
+ if (Get16(p + pos) == 0)
+ return (int)pos;
+ pos += 2;
+ }
+}
+
+static const unsigned k_ResoureBlockHeader_Size = 6;
+
+bool CVersionBlock::Parse(const Byte *p, UInt32 size)
+{
+ if (size < k_ResoureBlockHeader_Size)
+ return false;
+ TotalLen = Get16(p);
+ ValueLen = Get16(p + 2);
+ if (TotalLen < k_ResoureBlockHeader_Size || TotalLen > size)
+ return false;
+ switch (Get16(p + 4))
+ {
+ case 0: IsTextValue = false; break;
+ case 1: IsTextValue = true; break;
+ default: return false;
+ }
+ StrSize = 0;
+ const int t = Get_Utf16Str_Len_InBytes(p + k_ResoureBlockHeader_Size, TotalLen - k_ResoureBlockHeader_Size);
+ if (t < 0)
+ return false;
+ StrSize = (unsigned)t;
+ return true;
+}
+
+static void AddParamString(CTextFile &f, const Byte *p, size_t sLen)
+{
+ f.AddChar(' ');
+ f.AddChar('\"');
+ f.AddBytes(p, sLen);
+ f.AddChar('\"');
+}
+
+static bool ParseVersion(const Byte *p, UInt32 size, CTextFile &f, CObjectVector<CStringKeyValue> &keys)
+{
+ UInt32 pos;
+ {
+ const unsigned k_sizeof_VS_FIXEDFILEINFO = 13 * 4;
+
+ CVersionBlock vb;
+ if (!vb.Parse(p, size))
+ return false;
+ if (vb.ValueLen != k_sizeof_VS_FIXEDFILEINFO) // maybe 0 is allowed here?
+ return false;
+ if (vb.IsTextValue)
+ return false;
+ pos = k_ResoureBlockHeader_Size;
+ if (!CompareWStrStrings(p + pos, "VS_VERSION_INFO"))
+ return false;
+ pos += vb.StrSize + 2;
+ pos += (4 - pos) & 3;
+ if (pos + vb.ValueLen > vb.TotalLen)
+ return false;
+ /* sometimes resource contains zeros in remainder.
+ So we don't check that size != vb.TotalLen
+ // if (size != vb.TotalLen) return false;
+ */
+ if (size > vb.TotalLen)
+ size = vb.TotalLen;
+ CMy_VS_FIXEDFILEINFO FixedFileInfo;
+ if (!FixedFileInfo.Parse(p + pos))
+ return false;
+ FixedFileInfo.PrintToTextFile(f, keys);
+ pos += vb.ValueLen;
+ }
+
+ f.OpenBlock(0);
+
+ for (;;)
+ {
+ pos += (4 - pos) & 3;
+ if (pos >= size)
+ break;
+
+ CVersionBlock vb;
+ if (!vb.Parse(p + pos, size - pos))
+ return false;
+ if (vb.ValueLen != 0)
+ return false;
+ UInt32 endPos = pos + vb.TotalLen;
+ pos += k_ResoureBlockHeader_Size;
+
+ f.AddSpaces(2);
+ f.AddString("BLOCK");
+ AddParamString(f, p + pos, vb.StrSize);
+
+ f.NewLine();
+ f.OpenBlock(2);
+
+ if (CompareWStrStrings(p + pos, "VarFileInfo"))
+ {
+ pos += vb.StrSize + 2;
+ for (;;)
+ {
+ pos += (4 - pos) & 3;
+ if (pos >= endPos)
+ break;
+ CVersionBlock vb2;
+ if (!vb2.Parse(p + pos, endPos - pos))
+ return false;
+ UInt32 endPos2 = pos + vb2.TotalLen;
+ if (vb2.IsTextValue)
+ return false;
+ pos += k_ResoureBlockHeader_Size;
+ f.AddSpaces(4);
+ f.AddString("VALUE");
+ AddParamString(f, p + pos, vb2.StrSize);
+ if (!CompareWStrStrings(p + pos, "Translation"))
+ return false;
+ pos += vb2.StrSize + 2;
+ pos += (4 - pos) & 3;
+ if (pos + vb2.ValueLen != endPos2)
+ return false;
+ if ((vb2.ValueLen & 3) != 0)
+ return false;
+ UInt32 num = (vb2.ValueLen >> 2);
+ for (; num != 0; num--, pos += 4)
+ {
+ UInt32 dw = Get32(p + pos);
+ UInt32 lang = LOWORD(dw);
+ UInt32 codePage = HIWORD(dw);
+
+ f.AddString(", ");
+ PrintHex(f, lang);
+ f.AddString(", ");
+ PrintUInt32(f, codePage);
+ }
+ f.NewLine();
+ }
+ }
+ else
+ {
+ if (!CompareWStrStrings(p + pos, "StringFileInfo"))
+ return false;
+ pos += vb.StrSize + 2;
+
+ for (;;)
+ {
+ pos += (4 - pos) & 3;
+ if (pos >= endPos)
+ break;
+ CVersionBlock vb2;
+ if (!vb2.Parse(p + pos, endPos - pos))
+ return false;
+ UInt32 endPos2 = pos + vb2.TotalLen;
+ if (vb2.ValueLen != 0)
+ return false;
+ pos += k_ResoureBlockHeader_Size;
+
+ f.AddSpaces(4);
+ f.AddString("BLOCK");
+ AddParamString(f, p + pos, vb2.StrSize);
+ pos += vb2.StrSize + 2;
+
+ f.NewLine();
+ f.OpenBlock(4);
+
+ for (;;)
+ {
+ pos += (4 - pos) & 3;
+ if (pos >= endPos2)
+ break;
+
+ CVersionBlock vb3;
+ if (!vb3.Parse(p + pos, endPos2 - pos))
+ return false;
+ // ValueLen sometimes is a number of characters (not bytes)?
+ // So we don't use it.
+ UInt32 endPos3 = pos + vb3.TotalLen;
+ pos += k_ResoureBlockHeader_Size;
+
+ // we don't write string if it's not text
+ if (vb3.IsTextValue)
+ {
+ f.AddSpaces(6);
+ f.AddString("VALUE");
+ AddParamString(f, p + pos, vb3.StrSize);
+ UString key;
+ UString value;
+ CopyToUString(p + pos, key);
+ pos += vb3.StrSize + 2;
+
+ pos += (4 - pos) & 3;
+ if (vb3.ValueLen > 0 && pos + 2 <= endPos3)
+ {
+ f.AddChar(',');
+ f.AddSpaces((34 - (int)vb3.StrSize) / 2);
+ const int sLen = Get_Utf16Str_Len_InBytes(p + pos, endPos3 - pos);
+ if (sLen < 0)
+ return false;
+ AddParamString(f, p + pos, (unsigned)sLen);
+ CopyToUString(p + pos, value);
+ pos += (unsigned)sLen + 2;
+ }
+ AddToUniqueUStringVector(keys, key, value);
+ }
+ pos = endPos3;
+ f.NewLine();
+ }
+ f.CloseBlock(4);
+ }
+ }
+ f.CloseBlock(2);
+ }
+
+ f.CloseBlock(0);
+ return true;
+}
+
+
+HRESULT CHandler::OpenResources(unsigned sectionIndex, IInStream *stream, IArchiveOpenCallback *callback)
+{
+ const CSection § = _sections[sectionIndex];
+ size_t fileSize = sect.PSize;
+ {
+ size_t fileSizeMin = sect.PSize;
+
+ if (sect.VSize < sect.PSize)
+ {
+ fileSize = fileSizeMin = sect.VSize;
+ const int numBits = _optHeader.GetNumFileAlignBits();
+ if (numBits > 0)
+ {
+ const UInt32 mask = ((UInt32)1 << numBits) - 1;
+ const size_t end = (size_t)((sect.VSize + mask) & (UInt32)~mask);
+ if (end > sect.VSize)
+ {
+ if (end <= sect.PSize)
+ fileSize = end;
+ else
+ fileSize = sect.PSize;
+ }
+ }
+ }
+
+ if (fileSize > kFileSizeMax)
+ return S_FALSE;
+
+ {
+ const UInt64 fileSize64 = fileSize;
+ if (callback)
+ RINOK(callback->SetTotal(NULL, &fileSize64))
+ }
+
+ RINOK(InStream_SeekSet(stream, sect.Pa))
+
+ _buf.Alloc(fileSize);
+
+ size_t pos;
+
+ for (pos = 0; pos < fileSize;)
+ {
+ {
+ const UInt64 offset64 = pos;
+ if (callback)
+ RINOK(callback->SetCompleted(NULL, &offset64))
+ }
+ size_t rem = MyMin(fileSize - pos, (size_t)(1 << 22));
+ RINOK(ReadStream(stream, _buf + pos, &rem))
+ if (rem == 0)
+ {
+ if (pos < fileSizeMin)
+ return S_FALSE;
+ break;
+ }
+ pos += rem;
+ }
+
+ if (pos < fileSize)
+ memset(_buf + pos, 0, fileSize - pos);
+ }
+
+ _usedRes.Alloc(fileSize);
+ CRecordVector<CTableItem> specItems;
+ RINOK(ReadTable(0, specItems))
+
+ _oneLang = true;
+ bool stringsOk = true;
+ size_t maxOffset = 0;
+
+ FOR_VECTOR (i, specItems)
+ {
+ const CTableItem &item1 = specItems[i];
+ if ((item1.Offset & kFlag) == 0)
+ return S_FALSE;
+
+ CRecordVector<CTableItem> specItems2;
+ RINOK(ReadTable(item1.Offset & kMask, specItems2))
+
+ FOR_VECTOR (j, specItems2)
+ {
+ const CTableItem &item2 = specItems2[j];
+ if ((item2.Offset & kFlag) == 0)
+ return S_FALSE;
+
+ CRecordVector<CTableItem> specItems3;
+ RINOK(ReadTable(item2.Offset & kMask, specItems3))
+
+ CResItem item;
+ item.Type = item1.ID;
+ item.ID = item2.ID;
+
+ FOR_VECTOR (k, specItems3)
+ {
+ if (_items.Size() >= kNumResItemsMax)
+ return S_FALSE;
+ const CTableItem &item3 = specItems3[k];
+ if ((item3.Offset & kFlag) != 0)
+ return S_FALSE;
+ if (item3.Offset >= _buf.Size() || _buf.Size() - item3.Offset < 16)
+ return S_FALSE;
+ const Byte *buf = _buf + item3.Offset;
+ item.Lang = item3.ID;
+ item.Offset = Get32(buf + 0);
+ item.Size = Get32(buf + 4);
+ // UInt32 codePage = Get32(buf + 8);
+ if (Get32(buf + 12) != 0)
+ return S_FALSE;
+ if (!_items.IsEmpty() && _oneLang && !item.IsNameEqual(_items.Back()))
+ _oneLang = false;
+
+ item.HeaderSize = 0;
+
+ size_t offset = item.Offset - sect.Va;
+ if (offset > maxOffset)
+ maxOffset = offset;
+ if (offset + item.Size > maxOffset)
+ maxOffset = offset + item.Size;
+
+ if (CheckItem(sect, item, offset))
+ {
+ const Byte *data = _buf + offset;
+ if (item.IsBmp())
+ item.HeaderSize = SetBitmapHeader(item.Header, data, item.Size);
+ else if (item.IsIcon())
+ item.HeaderSize = SetIconHeader(item.Header, data, item.Size);
+ else if (item.IsString())
+ {
+ if (stringsOk)
+ stringsOk = ParseStringRes(item.ID, item.Lang, data, item.Size);
+ }
+ }
+
+ if (item.IsVersion())
+ {
+ if (offset > _buf.Size() || _buf.Size() - offset < item.Size)
+ continue;
+ CTextFile f;
+ if (ParseVersion((const Byte *)_buf + offset, item.Size, f, _versionKeys))
+ {
+ CMixItem mixItem;
+ mixItem.VersionIndex = (int)_versionFiles.Size();
+ mixItem.SectionIndex = (int)sectionIndex; // check it !!!!
+ CByteBuffer_WithLang &vf = _versionFiles.AddNew();
+ vf.Lang = item.Lang;
+ vf.CopyFrom(f.Buf, f.Buf.GetPos());
+ _mixItems.Add(mixItem);
+ continue;
+ }
+ // PrintError("ver.Parse error");
+ }
+
+ item.Enabled = true;
+ _items.Add(item);
+ }
+ }
+ }
+
+ if (stringsOk && !_strings.IsEmpty())
+ {
+ unsigned i;
+ for (i = 0; i < _items.Size(); i++)
+ {
+ CResItem &item = _items[i];
+ if (item.IsString())
+ item.Enabled = false;
+ }
+ for (i = 0; i < _strings.Size(); i++)
+ {
+ if (_strings[i].FinalSize() == 0)
+ continue;
+ CMixItem mixItem;
+ mixItem.StringIndex = (int)i;
+ mixItem.SectionIndex = (int)sectionIndex;
+ _mixItems.Add(mixItem);
+ }
+ }
+
+ _usedRes.Free();
+
+ {
+ // PSize can be much larger than VSize in some exe installers.
+ // it contains archive data after PE resources.
+ // So we need to use PSize here!
+ if (maxOffset < sect.PSize)
+ {
+ size_t end = fileSize;
+
+ // we skip Zeros to start of aligned block
+ size_t i;
+ for (i = maxOffset; i < end; i++)
+ if (_buf[i] != 0)
+ break;
+ if (i == end)
+ maxOffset = end;
+
+ CSection sect2;
+ sect2.Flags = 0;
+ sect2.Pa = sect.Pa + (UInt32)maxOffset;
+ sect2.Va = sect.Va + (UInt32)maxOffset;
+
+ // 9.29: we use sect.PSize instead of sect.VSize to support some CAB-SFX
+ // the code for .rsrc_2 is commented.
+ sect2.PSize = sect.PSize - (UInt32)maxOffset;
+
+ if (sect2.PSize != 0)
+ {
+ sect2.VSize = sect2.PSize;
+ sect2.Name = ".rsrc_1";
+ sect2.Time = 0;
+ sect2.IsAdditionalSection = true;
+ _sections.Add(sect2);
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+bool CHeader::ParseCoff(const Byte *p)
+{
+ ParseBase(p);
+ if (PointerToSymbolTable < kCoffHeaderSize)
+ return false;
+ if (NumSymbols >= (1 << 24))
+ return false;
+ if (OptHeaderSize != 0 && OptHeaderSize < k_OptHeader32_Size_MIN)
+ return false;
+
+ // 18.04: we reduce false detections
+ if (NumSections == 0 && OptHeaderSize == 0)
+ return false;
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_MachinePairs); i++)
+ if (Machine == g_MachinePairs[i].Value)
+ return true;
+ if (Machine == 0)
+ return true;
+
+ return false;
+}
+
+
+static inline bool CheckPeOffset(UInt32 pe)
+{
+ // ((pe & 7) == 0) is for most PE files. But there is unusual EFI-PE file that uses unaligned pe value.
+ return pe >= 0x40 && pe <= 0x1000 /* && (pe & 7) == 0 */ ;
+}
+
+static const unsigned kStartSize = 0x40;
+
+API_FUNC_static_IsArc IsArc_Pe(const Byte *p, size_t size)
+{
+ if (size < 2)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != 'M' || p[1] != 'Z')
+ return k_IsArc_Res_NO;
+ if (size < kStartSize)
+ return k_IsArc_Res_NEED_MORE;
+ UInt32 pe = Get32(p + 0x3C);
+ if (!CheckPeOffset(pe))
+ return k_IsArc_Res_NO;
+ if (pe + kPeHeaderSize > size)
+ return k_IsArc_Res_NEED_MORE;
+ CHeader header;
+ if (!header.ParsePe(p + pe))
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
+{
+ UInt32 coffOffset = 0;
+ if (_coffMode)
+ {
+ Byte h[kCoffHeaderSize];
+ RINOK(ReadStream_FALSE(stream, h, kCoffHeaderSize))
+ if (!_header.ParseCoff(h))
+ return S_FALSE;
+ }
+ else
+ {
+ UInt32 _peOffset;
+ {
+ Byte h[kStartSize];
+ RINOK(ReadStream_FALSE(stream, h, kStartSize))
+ if (h[0] != 'M' || h[1] != 'Z')
+ return S_FALSE;
+ /* most of PE files contain 0x0090 at offset 2.
+ But some rare PE files contain another values. So we don't use that check.
+ if (Get16(h + 2) != 0x90) return false; */
+ _peOffset = Get32(h + 0x3C);
+ if (!CheckPeOffset(_peOffset))
+ return S_FALSE;
+ coffOffset = _peOffset + 4;
+ }
+ {
+ Byte h[kPeHeaderSize];
+ RINOK(InStream_SeekSet(stream, _peOffset))
+ RINOK(ReadStream_FALSE(stream, h, kPeHeaderSize))
+ if (!_header.ParsePe(h))
+ return S_FALSE;
+ }
+ }
+
+ const UInt32 optStart = coffOffset + kCoffHeaderSize;
+ const UInt32 bufSize = _header.OptHeaderSize + (UInt32)_header.NumSections * kSectionSize;
+ _totalSize = optStart + bufSize;
+ CByteBuffer buffer(bufSize);
+
+ RINOK(ReadStream_FALSE(stream, buffer, bufSize))
+
+ // memset((void *)&_optHeader, 0, sizeof(_optHeader));
+ if (_header.OptHeaderSize != 0)
+ if (!_optHeader.Parse(buffer, _header.OptHeaderSize))
+ return S_FALSE;
+
+ UInt32 pos = _header.OptHeaderSize;
+ unsigned i;
+ for (i = 0; i < _header.NumSections; i++, pos += kSectionSize)
+ {
+ CSection § = _sections.AddNew();
+ sect.Parse(buffer + pos);
+ sect.IsRealSect = true;
+
+ /* PE pre-file in .hxs file has errors:
+ PSize of resource is larger than real size.
+ So it overlaps next ".its" section.
+ 7-zip before 22.02: we corrected it.
+
+ 22.02: another bad case is possible in incorrect pe (exe) file:
+ PSize in .rsrc section is correct,
+ but next .reloc section has incorrect (Pa) that overlaps with .rsrc.
+ */
+
+ if (i != 0)
+ {
+ const CSection &prev = _sections[i - 1];
+ if (prev.Pa < sect.Pa
+ && prev.Pa + prev.PSize > sect.Pa
+ && sect.PSize != 0
+ && prev.PSize != 0)
+ {
+ _sectionsError = true;
+ // PRF(printf("\n !!!! Section correction: %s\n ", prev.Name));
+
+ /* we corrected that case in 7-zip before 22.02: */
+ // prev.PSize = sect.Pa - prev.Pa;
+
+ /* 22.02: here we can try to change bad section position to expected postion.
+ but original Windows code probably will not do same things. */
+ // if (prev.PSize <= sect.Va - prev.Va) sect.Pa = prev.Pa + prev.PSize;
+ }
+ }
+ /* last ".its" section in hxs file has incorrect sect.PSize.
+ 7-zip before 22.02: we reduced section to real sect.VSize */
+ /*
+ if (sect.VSize == 24 && sect.PSize == 512 && i == (unsigned)_header.NumSections - 1)
+ sect.PSize = sect.VSize;
+ */
+ }
+
+ for (i = 0; i < _sections.Size(); i++)
+ _sections[i].UpdateTotalSize(_totalSize);
+
+ bool thereISDebug = false;
+ if (IsOpt())
+ {
+ RINOK(LoadDebugSections(stream, thereISDebug))
+
+ const CDirLink &certLink = _optHeader.DirItems[kDirLink_Certificate];
+ if (certLink.Size != 0)
+ {
+ CSection § = _sections.AddNew();
+ sect.Name = "CERTIFICATE";
+ sect.Va = 0;
+ sect.Pa = certLink.Va;
+ sect.PSize = sect.VSize = certLink.Size;
+ sect.UpdateTotalSize(_totalSize);
+ }
+
+ if (thereISDebug)
+ {
+ /* sometime there is some data after debug section.
+ We don't see any reference in exe file to that data.
+ But we suppose that it's part of EXE file */
+
+ const UInt32 kAlign = 1 << 12;
+ UInt32 alignPos = _totalSize & (kAlign - 1);
+ if (alignPos != 0)
+ {
+ UInt32 size = kAlign - alignPos;
+ RINOK(InStream_SeekSet(stream, _totalSize))
+ buffer.Alloc(kAlign);
+ Byte *buf = buffer;
+ size_t processed = size;
+ RINOK(ReadStream(stream, buf, &processed))
+
+ /*
+ if (processed != 0)
+ {
+ printf("\ndata after debug %d, %d \n", (int)size, (int)processed);
+ fflush(stdout);
+ }
+ */
+
+ size_t k;
+ for (k = 0; k < processed; k++)
+ if (buf[k] != 0)
+ break;
+ if (processed < size && processed < 100)
+ _totalSize += (UInt32)processed;
+ else if (((_totalSize + k) & 0x1FF) == 0 || processed < size)
+ _totalSize += (UInt32)k;
+ }
+ }
+ }
+
+ if (_header.NumSymbols > 0 && _header.PointerToSymbolTable >= optStart)
+ {
+ if (_header.NumSymbols >= (1 << 24))
+ return S_FALSE;
+ UInt32 size = _header.NumSymbols * 18;
+ RINOK(InStream_SeekSet(stream, (UInt64)_header.PointerToSymbolTable + size))
+ Byte buf[4];
+ RINOK(ReadStream_FALSE(stream, buf, 4))
+ UInt32 size2 = Get32(buf);
+ if (size2 >= (1 << 28))
+ return S_FALSE;
+ size += size2;
+
+ CSection § = _sections.AddNew();
+ sect.Name = "COFF_SYMBOLS";
+ sect.Va = 0;
+ sect.Pa = _header.PointerToSymbolTable;
+ sect.PSize = sect.VSize = size;
+ sect.UpdateTotalSize(_totalSize);
+ }
+
+ {
+ CObjectVector<CSection> sections = _sections;
+ sections.Sort();
+ UInt32 limit = (1 << 12);
+ unsigned num = 0;
+ FOR_VECTOR (k, sections)
+ {
+ const CSection &s = sections[k];
+ if (s.Pa > limit)
+ {
+ CSection &s2 = _sections.AddNew();
+ s2.Pa = s2.Va = limit;
+ s2.PSize = s2.VSize = s.Pa - limit;
+ s2.IsAdditionalSection = true;
+ s2.Name = '[';
+ s2.Name.Add_UInt32(num++);
+ s2.Name += ']';
+ limit = s.Pa;
+ }
+ UInt32 next = s.Pa + s.PSize;
+ if (next < s.Pa)
+ break;
+ if (next >= limit)
+ limit = next;
+ }
+ }
+
+
+ if (IsOpt())
+ if (_optHeader.CheckSum != 0)
+ {
+ RINOK(InStream_SeekToBegin(stream))
+ UInt32 checkSum = 0;
+ RINOK(CalcCheckSum(stream, _totalSize, optStart + k_CheckSum_Field_Offset, checkSum))
+ _checksumError = (checkSum != _optHeader.CheckSum);
+ }
+
+
+ if (!_allowTail)
+ {
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(stream, fileSize))
+ if (fileSize > _totalSize)
+ return S_FALSE;
+ }
+
+ bool _parseResources = true;
+ // _parseResources = false; // for debug
+
+ UInt64 mainSize = 0, mainSize2 = 0;
+
+ for (i = 0; i < _sections.Size(); i++)
+ {
+ const CSection § = _sections[i];
+ if (IsOpt())
+ if (_parseResources && sect.Name == ".rsrc")
+ {
+ // 20.01: we try to parse only first copy of .rsrc section.
+ _parseResources = false;
+ const unsigned numMixItems = _mixItems.Size();
+ HRESULT res = OpenResources(i, stream, callback);
+ if (res == S_OK)
+ {
+ _resourcesPrefix = sect.Name.Ptr();
+ _resourcesPrefix.Add_PathSepar();
+ FOR_VECTOR (j, _items)
+ {
+ const CResItem &item = _items[j];
+ if (item.Enabled)
+ {
+ CMixItem mixItem;
+ mixItem.SectionIndex = (int)i;
+ mixItem.ResourceIndex = (int)j;
+ if (item.IsRcDataOrUnknown())
+ {
+ if (item.Size >= mainSize)
+ {
+ mainSize2 = mainSize;
+ mainSize = item.Size;
+ _mainSubfile = (Int32)(int)_mixItems.Size();
+ }
+ else if (item.Size >= mainSize2)
+ mainSize2 = item.Size;
+ }
+ _mixItems.Add(mixItem);
+ }
+ }
+ // 9.29: .rsrc_2 code was commented.
+ // .rsrc_1 now must include that .rsrc_2 block.
+ /*
+ if (sect.PSize > sect.VSize)
+ {
+ int numBits = _optHeader.GetNumFileAlignBits();
+ if (numBits >= 0)
+ {
+ UInt32 mask = (1 << numBits) - 1;
+ UInt32 end = ((sect.VSize + mask) & ~mask);
+
+ if (sect.PSize > end)
+ {
+ CSection §2 = _sections.AddNew();
+ sect2.Flags = 0;
+ sect2.Pa = sect.Pa + end;
+ sect2.Va = sect.Va + end;
+ sect2.PSize = sect.PSize - end;
+ sect2.VSize = sect2.PSize;
+ sect2.Name = ".rsrc_2";
+ sect2.Time = 0;
+ sect2.IsAdditionalSection = true;
+ }
+ }
+ }
+ */
+ continue;
+ }
+ if (res != S_FALSE)
+ return res;
+ _mixItems.DeleteFrom(numMixItems);
+ CloseResources();
+ }
+
+ if (sect.IsAdditionalSection)
+ {
+ if (sect.PSize >= mainSize)
+ {
+ mainSize2 = mainSize;
+ mainSize = sect.PSize;
+ _mainSubfile = (Int32)(int)_mixItems.Size();
+ }
+ else if (sect.PSize >= mainSize2)
+ mainSize2 = sect.PSize;
+ }
+
+ CMixItem mixItem;
+ mixItem.SectionIndex = (int)i;
+ _mixItems.Add(mixItem);
+ }
+
+ if (mainSize2 >= (1 << 20) && mainSize < mainSize2 * 2)
+ _mainSubfile = -1;
+
+ for (i = 0; i < _mixItems.Size(); i++)
+ {
+ const CMixItem &mixItem = _mixItems[i];
+ if (mixItem.StringIndex < 0 && mixItem.ResourceIndex < 0 && _sections[mixItem.SectionIndex].Name == "_winzip_")
+ {
+ _mainSubfile = (Int32)(int)i;
+ break;
+ }
+ }
+
+ for (i = 0; i < _versionKeys.Size(); i++)
+ {
+ if (i != 0)
+ _versionFullString.Add_LF();
+ const CStringKeyValue &k = _versionKeys[i];
+ _versionFullString += k.Key;
+ _versionFullString += ": ";
+ _versionFullString += k.Value;
+ }
+
+ {
+ int keyIndex = FindKey(_versionKeys, "OriginalFilename");
+ if (keyIndex >= 0)
+ _originalFilename = _versionKeys[keyIndex].Value;
+ }
+ {
+ int keyIndex = FindKey(_versionKeys, "FileDescription");
+ if (keyIndex >= 0)
+ _versionShortString = _versionKeys[keyIndex].Value;
+ }
+ {
+ int keyIndex = FindKey(_versionKeys, "FileVersion");
+ if (keyIndex >= 0)
+ {
+ _versionShortString.Add_Space();
+ _versionShortString += _versionKeys[keyIndex].Value;
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+ RINOK(Open2(inStream, callback))
+ _stream = inStream;
+ return S_OK;
+ COM_TRY_END
+}
+
+void CHandler::CloseResources()
+{
+ _usedRes.Free();
+ _items.Clear();
+ _strings.Clear();
+ _versionFiles.Clear();
+ _buf.Free();
+ _versionFullString.Empty();
+ _versionShortString.Empty();
+ _originalFilename.Empty();
+ _versionKeys.Clear();
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ _checksumError = false;
+ _sectionsError = false;
+ _mainSubfile = -1;
+
+ _stream.Release();
+ _sections.Clear();
+ _mixItems.Clear();
+ CloseResources();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _mixItems.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _mixItems.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CMixItem &mixItem = _mixItems[allFilesMode ? i : indices[i]];
+ UInt64 size;
+ if (mixItem.StringIndex >= 0)
+ size = _strings[mixItem.StringIndex].FinalSize();
+ else if (mixItem.VersionIndex >= 0)
+ size = _versionFiles[mixItem.VersionIndex].Size();
+ else if (mixItem.ResourceIndex >= 0)
+ size = _items[mixItem.ResourceIndex].GetSize();
+ else
+ size = _sections[mixItem.SectionIndex].GetSizeExtract();
+ totalSize += size;
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+ UInt64 currentItemSize;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ const CMixItem &mixItem = _mixItems[index];
+
+ const CSection § = _sections[mixItem.SectionIndex];
+ bool isOk = true;
+ if (mixItem.StringIndex >= 0)
+ {
+ const CStringItem &item = _strings[mixItem.StringIndex];
+ currentItemSize = item.FinalSize();
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (outStream)
+ RINOK(WriteStream(outStream, item.Buf, item.FinalSize()))
+ }
+ else if (mixItem.VersionIndex >= 0)
+ {
+ const CByteBuffer &item = _versionFiles[mixItem.VersionIndex];
+ currentItemSize = item.Size();
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (outStream)
+ RINOK(WriteStream(outStream, item, item.Size()))
+ }
+ else if (mixItem.ResourceIndex >= 0)
+ {
+ const CResItem &item = _items[mixItem.ResourceIndex];
+ currentItemSize = item.GetSize();
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ size_t offset = item.Offset - sect.Va;
+ if (!CheckItem(sect, item, offset))
+ isOk = false;
+ else if (outStream)
+ {
+ if (item.HeaderSize != 0)
+ RINOK(WriteStream(outStream, item.Header, item.HeaderSize))
+ RINOK(WriteStream(outStream, _buf + offset, item.Size))
+ }
+ }
+ else
+ {
+ currentItemSize = sect.GetSizeExtract();
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(InStream_SeekSet(_stream, sect.Pa))
+ streamSpec->Init(currentItemSize);
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ isOk = (copyCoderSpec->TotalSize == currentItemSize);
+ }
+
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(isOk ?
+ NExtract::NOperationResult::kOK :
+ NExtract::NOperationResult::kDataError))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+
+ const CMixItem &mixItem = _mixItems[index];
+ const CSection § = _sections[mixItem.SectionIndex];
+ if (mixItem.IsSectionItem())
+ return CreateLimitedInStream(_stream, sect.Pa, sect.PSize, stream);
+
+ CBufInStream *inStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
+ CReferenceBuf *referenceBuf = new CReferenceBuf;
+ CMyComPtr<IUnknown> ref = referenceBuf;
+ if (mixItem.StringIndex >= 0)
+ {
+ const CStringItem &item = _strings[mixItem.StringIndex];
+ referenceBuf->Buf.CopyFrom(item.Buf, item.FinalSize());
+ }
+ else if (mixItem.VersionIndex >= 0)
+ {
+ const CByteBuffer &item = _versionFiles[mixItem.VersionIndex];
+ referenceBuf->Buf.CopyFrom(item, item.Size());
+ }
+ else
+ {
+ const CResItem &item = _items[mixItem.ResourceIndex];
+ size_t offset = item.Offset - sect.Va;
+ if (!CheckItem(sect, item, offset))
+ return S_FALSE;
+ if (item.HeaderSize == 0)
+ {
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<IInStream> streamTemp2 = streamSpec;
+ streamSpec->Init(_buf + offset, item.Size, (IInArchive *)this);
+ *stream = streamTemp2.Detach();
+ return S_OK;
+ }
+ referenceBuf->Buf.Alloc(item.HeaderSize + item.Size);
+ memcpy(referenceBuf->Buf, item.Header, item.HeaderSize);
+ if (item.Size != 0)
+ memcpy(referenceBuf->Buf + item.HeaderSize, _buf + offset, item.Size);
+ }
+ inStreamSpec->Init(referenceBuf);
+
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::AllowTail(Int32 allowTail))
+{
+ _allowTail = IntToBool(allowTail);
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { 'M', 'Z' };
+
+REGISTER_ARC_I(
+ "PE", "exe dll sys", NULL, 0xDD,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kPreArc,
+ IsArc_Pe)
+
+}
+
+namespace NCoff {
+
+API_FUNC_static_IsArc IsArc_Coff(const Byte *p, size_t size)
+{
+ if (size < NPe::kCoffHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ NPe::CHeader header;
+ if (!header.ParseCoff(p))
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+/*
+static const Byte k_Signature[] =
+{
+ 2, 0x4C, 0x01, // x86
+ 2, 0x64, 0x86, // x64
+ 2, 0x64, 0xAA // ARM64
+};
+REGISTER_ARC_I_CLS(
+*/
+
+REGISTER_ARC_I_CLS_NO_SIG(
+ NPe::CHandler(true),
+ "COFF", "obj", NULL, 0xC6,
+ // k_Signature,
+ 0,
+ // NArcInfoFlags::kMultiSignature |
+ NArcInfoFlags::kStartOpen,
+ IsArc_Coff)
+}
+
+
+namespace NTe {
+
+// Terse Executable (TE) image
+
+struct CDataDir
+{
+ UInt32 Va;
+ UInt32 Size;
+
+ void Parse(const Byte *p)
+ {
+ G32(0, Va);
+ G32(4, Size);
+ }
+};
+
+static const UInt32 kHeaderSize = 40;
+
+static bool FindValue(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
+{
+ for (unsigned i = 0; i < num; i++)
+ if (pairs[i].Value == value)
+ return true;
+ return false;
+}
+
+#define MY_FIND_VALUE(pairs, val) FindValue(pairs, Z7_ARRAY_SIZE(pairs), val)
+#define MY_FIND_VALUE_2(strings, val) (val < Z7_ARRAY_SIZE(strings) && strings[val])
+
+static const UInt32 kNumSection_MAX = 32;
+
+struct CHeader
+{
+ UInt16 Machine;
+ Byte NumSections;
+ Byte SubSystem;
+ UInt16 StrippedSize;
+ /*
+ UInt32 AddressOfEntryPoint;
+ UInt32 BaseOfCode;
+ UInt64 ImageBase;
+ */
+ CDataDir DataDir[2]; // base relocation and debug directory
+
+ bool ConvertPa(UInt32 &pa) const
+ {
+ if (pa < StrippedSize)
+ return false;
+ pa = pa - StrippedSize + kHeaderSize;
+ return true;
+ }
+ bool Parse(const Byte *p);
+};
+
+bool CHeader::Parse(const Byte *p)
+{
+ NumSections = p[4];
+ if (NumSections > kNumSection_MAX)
+ return false;
+ SubSystem = p[5];
+ G16(2, Machine);
+ G16(6, StrippedSize);
+ /*
+ G32(8, AddressOfEntryPoint);
+ G32(12, BaseOfCode);
+ G64(16, ImageBase);
+ */
+ for (int i = 0; i < 2; i++)
+ {
+ CDataDir &dd = DataDir[i];
+ dd.Parse(p + 24 + i * 8);
+ if (dd.Size >= ((UInt32)1 << 28))
+ return false;
+ }
+ return
+ MY_FIND_VALUE(NPe::g_MachinePairs, Machine) &&
+ MY_FIND_VALUE_2(NPe::g_SubSystems, SubSystem);
+}
+
+API_FUNC_static_IsArc IsArc_Te(const Byte *p, size_t size)
+{
+ if (size < 2)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != 'V' || p[1] != 'Z')
+ return k_IsArc_Res_NO;
+ if (size < kHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+
+ CHeader h;
+ if (!h.Parse(p))
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+
+struct CSection
+{
+ Byte Name[NPe::kNameSize];
+
+ UInt32 VSize;
+ UInt32 Va;
+ UInt32 PSize;
+ UInt32 Pa;
+ UInt32 Flags;
+ // UInt16 NumRelocs;
+
+ void Parse(const Byte *p)
+ {
+ memcpy(Name, p, NPe::kNameSize);
+ G32(8, VSize);
+ G32(12, Va);
+ G32(16, PSize);
+ G32(20, Pa);
+ // G32(p + 32, NumRelocs);
+ G32(36, Flags);
+ }
+
+ bool Check() const
+ {
+ return
+ Pa <= ((UInt32)1 << 30) &&
+ PSize <= ((UInt32)1 << 30);
+ }
+
+ void UpdateTotalSize(UInt32 &totalSize)
+ {
+ UInt32 t = Pa + PSize;
+ if (t > totalSize)
+ totalSize = t;
+ }
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_2(
+ IInArchiveGetStream,
+ IArchiveAllowTail
+)
+ CRecordVector<CSection> _items;
+ CMyComPtr<IInStream> _stream;
+ UInt32 _totalSize;
+ bool _allowTail;
+ CHeader _h;
+
+ HRESULT Open2(IInStream *stream);
+public:
+ CHandler(): _allowTail(false) {}
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidVirtualSize,
+ kpidCharacts,
+ kpidOffset,
+ kpidVa
+};
+
+enum
+{
+ kpidSubSystem = kpidUserDefined
+ // , kpidImageBase
+};
+
+static const CStatProp kArcProps[] =
+{
+ // { NULL, kpidHeadersSize, VT_UI4 },
+ { NULL, kpidCpu, VT_BSTR},
+ { "Subsystem", kpidSubSystem, VT_BSTR },
+ // { "Image Base", kpidImageBase, VT_UI8 }
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _totalSize; break;
+ case kpidCpu: PAIR_TO_PROP(NPe::g_MachinePairs, _h.Machine, prop); break;
+ case kpidSubSystem: TYPE_TO_PROP(NPe::g_SubSystems, _h.SubSystem, prop); break;
+ /*
+ case kpidImageBase: prop = _h.ImageBase; break;
+ case kpidAddressOfEntryPoint: prop = _h.AddressOfEntryPoint; break;
+ case kpidBaseOfCode: prop = _h.BaseOfCode; break;
+ */
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ {
+ const CSection &item = _items[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString name;
+ NPe::GetName(item.Name, name);
+ prop = MultiByteToUnicodeString(name);
+ break;
+ }
+ case kpidSize:
+ case kpidPackSize: prop = (UInt64)item.PSize; break;
+ case kpidVirtualSize: prop = (UInt64)item.VSize; break;
+ case kpidOffset: prop = item.Pa; break;
+ case kpidVa: prop = item.Va; break;
+ case kpidCharacts: FLAGS_TO_PROP(NPe::g_SectFlags, item.Flags, prop); break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ Byte h[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, h, kHeaderSize))
+ if (h[0] != 'V' || h[1] != 'Z')
+ return S_FALSE;
+ if (!_h.Parse(h))
+ return S_FALSE;
+
+ UInt32 headerSize = NPe::kSectionSize * (UInt32)_h.NumSections;
+ CByteArr buf(headerSize);
+ RINOK(ReadStream_FALSE(stream, buf, headerSize))
+ headerSize += kHeaderSize;
+
+ _totalSize = headerSize;
+ _items.ClearAndReserve(_h.NumSections);
+ for (UInt32 i = 0; i < _h.NumSections; i++)
+ {
+ CSection sect;
+ sect.Parse(buf + i * NPe::kSectionSize);
+ if (!_h.ConvertPa(sect.Pa))
+ return S_FALSE;
+ if (sect.Pa < headerSize)
+ return S_FALSE;
+ if (!sect.Check())
+ return S_FALSE;
+ _items.AddInReserved(sect);
+ sect.UpdateTotalSize(_totalSize);
+ }
+
+ if (!_allowTail)
+ {
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(stream, fileSize))
+ if (fileSize > _totalSize)
+ return S_FALSE;
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ Close();
+ try
+ {
+ if (Open2(inStream) != S_OK)
+ return S_FALSE;
+ _stream = inStream;
+ }
+ catch(...) { return S_FALSE; }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ _stream.Release();
+ _items.Clear();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _items[allFilesMode ? i : indices[i]].PSize;
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CSection &item = _items[index];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ currentTotalSize += item.PSize;
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ int res = NExtract::NOperationResult::kDataError;
+
+ RINOK(InStream_SeekSet(_stream, item.Pa))
+ streamSpec->Init(item.PSize);
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize == item.PSize)
+ res = NExtract::NOperationResult::kOK;
+
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ const CSection &item = _items[index];
+ return CreateLimitedInStream(_stream, item.Pa, item.PSize, stream);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::AllowTail(Int32 allowTail))
+{
+ _allowTail = IntToBool(allowTail);
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { 'V', 'Z' };
+
+REGISTER_ARC_I(
+ "TE", "te", NULL, 0xCF,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kPreArc,
+ IsArc_Te)
+
+}
+}
diff --git a/CPP/7zip/Archive/PpmdHandler.cpp b/CPP/7zip/Archive/PpmdHandler.cpp
new file mode 100644
index 0000000..e5c2f9b
--- /dev/null
+++ b/CPP/7zip/Archive/PpmdHandler.cpp
@@ -0,0 +1,398 @@
+/* PpmdHandler.cpp -- PPMd format handler
+2020 : Igor Pavlov : Public domain
+This code is based on:
+ PPMd var.H (2001) / var.I (2002): Dmitry Shkarin : Public domain
+ Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/Alloc.h"
+#include "../../../C/Ppmd7.h"
+#include "../../../C/Ppmd8.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NPpmd {
+
+static const UInt32 kBufSize = (1 << 20);
+
+struct CBuf
+{
+ Byte *Buf;
+
+ CBuf(): Buf(NULL) {}
+ ~CBuf() { ::MidFree(Buf); }
+ bool Alloc()
+ {
+ if (!Buf)
+ Buf = (Byte *)::MidAlloc(kBufSize);
+ return (Buf != NULL);
+ }
+};
+
+static const UInt32 kHeaderSize = 16;
+static const UInt32 kSignature = 0x84ACAF8F;
+static const unsigned kNewHeaderVer = 8;
+
+struct CItem
+{
+ UInt32 Attrib;
+ UInt32 Time;
+ AString Name;
+
+ unsigned Order;
+ unsigned MemInMB;
+ unsigned Ver;
+ unsigned Restor;
+
+ HRESULT ReadHeader(ISequentialInStream *s, UInt32 &headerSize);
+ bool IsSupported() const
+ {
+ return (Ver == 7 && Order >= PPMD7_MIN_ORDER)
+ || (Ver == 8 && Order >= PPMD8_MIN_ORDER && Restor < PPMD8_RESTORE_METHOD_UNSUPPPORTED);
+ }
+};
+
+HRESULT CItem::ReadHeader(ISequentialInStream *s, UInt32 &headerSize)
+{
+ Byte h[kHeaderSize];
+ RINOK(ReadStream_FALSE(s, h, kHeaderSize))
+ if (GetUi32(h) != kSignature)
+ return S_FALSE;
+ Attrib = GetUi32(h + 4);
+ Time = GetUi32(h + 12);
+ unsigned info = GetUi16(h + 8);
+ Order = (info & 0xF) + 1;
+ MemInMB = ((info >> 4) & 0xFF) + 1;
+ Ver = info >> 12;
+
+ if (Ver < 6 || Ver > 11) return S_FALSE;
+
+ UInt32 nameLen = GetUi16(h + 10);
+ Restor = nameLen >> 14;
+ if (Restor > 2)
+ return S_FALSE;
+ if (Ver >= kNewHeaderVer)
+ nameLen &= 0x3FFF;
+ if (nameLen > (1 << 9))
+ return S_FALSE;
+ char *name = Name.GetBuf(nameLen);
+ HRESULT res = ReadStream_FALSE(s, name, nameLen);
+ Name.ReleaseBuf_CalcLen(nameLen);
+ headerSize = kHeaderSize + nameLen;
+ return res;
+}
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IArchiveOpenSeq
+)
+ CItem _item;
+ UInt32 _headerSize;
+ bool _packSize_Defined;
+ UInt64 _packSize;
+ CMyComPtr<ISequentialInStream> _stream;
+
+ void GetVersion(NCOM::CPropVariant &prop);
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidMTime,
+ kpidAttrib,
+ kpidMethod
+};
+
+static const Byte kArcProps[] =
+{
+ kpidMethod
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+void CHandler::GetVersion(NCOM::CPropVariant &prop)
+{
+ AString s ("PPMd");
+ s += (char)('A' + _item.Ver);
+ s += ":o";
+ s.Add_UInt32(_item.Order);
+ s += ":mem";
+ s.Add_UInt32(_item.MemInMB);
+ s += 'm';
+ if (_item.Ver >= kNewHeaderVer && _item.Restor != 0)
+ {
+ s += ":r";
+ s.Add_UInt32(_item.Restor);
+ }
+ prop = s;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidMethod: GetVersion(prop); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPath: prop = MultiByteToUnicodeString(_item.Name, CP_ACP); break;
+ case kpidMTime:
+ {
+ // time can be in Unix format ???
+ FILETIME utc;
+ if (NTime::DosTime_To_FileTime(_item.Time, utc))
+ prop = utc;
+ break;
+ }
+ case kpidAttrib: prop = _item.Attrib; break;
+ case kpidPackSize: if (_packSize_Defined) prop = _packSize; break;
+ case kpidMethod: GetVersion(prop); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *))
+{
+ return OpenSeq(stream);
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ COM_TRY_BEGIN
+ HRESULT res;
+ try
+ {
+ Close();
+ res = _item.ReadHeader(stream, _headerSize);
+ }
+ catch(...) { res = S_FALSE; }
+ if (res == S_OK)
+ _stream = stream;
+ else
+ Close();
+ return res;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _packSize = 0;
+ _packSize_Defined = false;
+ _stream.Release();
+ return S_OK;
+}
+
+
+
+struct CPpmdCpp
+{
+ unsigned Ver;
+ CPpmd7 _ppmd7;
+ CPpmd8 _ppmd8;
+
+ CPpmdCpp(unsigned version)
+ {
+ Ver = version;
+ Ppmd7_Construct(&_ppmd7);
+ Ppmd8_Construct(&_ppmd8);
+ }
+
+ ~CPpmdCpp()
+ {
+ Ppmd7_Free(&_ppmd7, &g_BigAlloc);
+ Ppmd8_Free(&_ppmd8, &g_BigAlloc);
+ }
+
+ bool Alloc(UInt32 memInMB)
+ {
+ memInMB <<= 20;
+ if (Ver == 7)
+ return Ppmd7_Alloc(&_ppmd7, memInMB, &g_BigAlloc) != 0;
+ return Ppmd8_Alloc(&_ppmd8, memInMB, &g_BigAlloc) != 0;
+ }
+
+ void Init(unsigned order, unsigned restor)
+ {
+ if (Ver == 7)
+ Ppmd7_Init(&_ppmd7, order);
+ else
+ Ppmd8_Init(&_ppmd8, order, restor);
+ }
+
+ bool InitRc(CByteInBufWrap *inStream)
+ {
+ if (Ver == 7)
+ {
+ _ppmd7.rc.dec.Stream = &inStream->vt;
+ return (Ppmd7a_RangeDec_Init(&_ppmd7.rc.dec) != 0);
+ }
+ else
+ {
+ _ppmd8.Stream.In = &inStream->vt;
+ return Ppmd8_Init_RangeDec(&_ppmd8) != 0;
+ }
+ }
+
+ bool IsFinishedOK()
+ {
+ if (Ver == 7)
+ return Ppmd7z_RangeDec_IsFinishedOK(&_ppmd7.rc.dec);
+ return Ppmd8_RangeDec_IsFinishedOK(&_ppmd8);
+ }
+};
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ // extractCallback->SetTotal(_packSize);
+ UInt64 currentTotalPacked = 0;
+ RINOK(extractCallback->SetCompleted(¤tTotalPacked))
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CByteInBufWrap inBuf;
+ if (!inBuf.Alloc(1 << 20))
+ return E_OUTOFMEMORY;
+ inBuf.Stream = _stream;
+
+ CBuf outBuf;
+ if (!outBuf.Alloc())
+ return E_OUTOFMEMORY;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, true);
+
+ CPpmdCpp ppmd(_item.Ver);
+ if (!ppmd.Alloc(_item.MemInMB))
+ return E_OUTOFMEMORY;
+
+ Int32 opRes = NExtract::NOperationResult::kUnsupportedMethod;
+
+ if (_item.IsSupported())
+ {
+ opRes = NExtract::NOperationResult::kDataError;
+
+ ppmd.Init(_item.Order, _item.Restor);
+ inBuf.Init();
+ UInt64 outSize = 0;
+
+ if (ppmd.InitRc(&inBuf) && !inBuf.Extra && inBuf.Res == S_OK)
+ for (;;)
+ {
+ lps->InSize = _packSize = inBuf.GetProcessed();
+ lps->OutSize = outSize;
+ RINOK(lps->SetCur())
+
+ size_t i;
+ int sym = 0;
+
+ Byte *buf = outBuf.Buf;
+ if (ppmd.Ver == 7)
+ {
+ for (i = 0; i < kBufSize; i++)
+ {
+ sym = Ppmd7a_DecodeSymbol(&ppmd._ppmd7);
+ if (inBuf.Extra || sym < 0)
+ break;
+ buf[i] = (Byte)sym;
+ }
+ }
+ else
+ {
+ for (i = 0; i < kBufSize; i++)
+ {
+ sym = Ppmd8_DecodeSymbol(&ppmd._ppmd8);
+ if (inBuf.Extra || sym < 0)
+ break;
+ buf[i] = (Byte)sym;
+ }
+ }
+
+ outSize += i;
+ _packSize = _headerSize + inBuf.GetProcessed();
+ _packSize_Defined = true;
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, outBuf.Buf, i))
+ }
+
+ if (inBuf.Extra)
+ {
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ break;
+ }
+
+ if (sym < 0)
+ {
+ if (sym == -1 && ppmd.IsFinishedOK())
+ opRes = NExtract::NOperationResult::kOK;
+ break;
+ }
+ }
+
+ RINOK(inBuf.Res)
+ }
+
+ realOutStream.Release();
+ return extractCallback->SetOperationResult(opRes);
+}
+
+
+static const Byte k_Signature[] = { 0x8F, 0xAF, 0xAC, 0x84 };
+
+REGISTER_ARC_I(
+ "Ppmd", "pmd", NULL, 0xD,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/QcowHandler.cpp b/CPP/7zip/Archive/QcowHandler.cpp
new file mode 100644
index 0000000..5a80daa
--- /dev/null
+++ b/CPP/7zip/Archive/QcowHandler.cpp
@@ -0,0 +1,668 @@
+// QcowHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer2.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/DeflateDecoder.h"
+
+#include "HandlerCont.h"
+
+#define Get32(p) GetBe32(p)
+#define Get64(p) GetBe64(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NQcow {
+
+static const Byte k_Signature[] = { 'Q', 'F', 'I', 0xFB, 0, 0, 0 };
+
+/*
+VA to PA maps:
+ high bits (L1) : : in L1 Table : the reference to L1 Table
+ mid bits (L2) : _numMidBits : in L2 Table : the reference to cluster
+ low bits : _clusterBits
+*/
+
+Z7_class_CHandler_final: public CHandlerImg
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Img)
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ unsigned _clusterBits;
+ unsigned _numMidBits;
+ UInt64 _compressedFlag;
+
+ CObjArray2<UInt32> _dir;
+ CAlignedBuffer _table;
+ UInt64 _cacheCluster;
+ CByteBuffer _cache;
+ CByteBuffer _cacheCompressed;
+
+ UInt64 _comprPos;
+ size_t _comprSize;
+
+ UInt64 _phySize;
+
+ CBufInStream *_bufInStreamSpec;
+ CMyComPtr<ISequentialInStream> _bufInStream;
+
+ CBufPtrSeqOutStream *_bufOutStreamSpec;
+ CMyComPtr<ISequentialOutStream> _bufOutStream;
+
+ NCompress::NDeflate::NDecoder::CCOMCoder *_deflateDecoderSpec;
+ CMyComPtr<ICompressCoder> _deflateDecoder;
+
+ bool _needDeflate;
+ bool _isArc;
+ bool _unsupported;
+
+ UInt32 _version;
+ UInt32 _cryptMethod;
+
+ HRESULT Seek2(UInt64 offset)
+ {
+ _posInArc = offset;
+ return InStream_SeekSet(Stream, offset);
+ }
+
+ HRESULT InitAndSeek()
+ {
+ _virtPos = 0;
+ return Seek2(0);
+ }
+
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openCallback) Z7_override;
+};
+
+
+static const UInt32 kEmptyDirItem = (UInt32)0 - 1;
+
+Z7_COM7F_IMF(CHandler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ // printf("\nRead _virtPos = %6d size = %6d\n", (UInt32)_virtPos, size);
+
+ if (_virtPos >= _size)
+ return S_OK;
+ {
+ UInt64 rem = _size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ if (size == 0)
+ return S_OK;
+ }
+
+ for (;;)
+ {
+ const UInt64 cluster = _virtPos >> _clusterBits;
+ const size_t clusterSize = (size_t)1 << _clusterBits;
+ const size_t lowBits = (size_t)_virtPos & (clusterSize - 1);
+ {
+ size_t rem = clusterSize - lowBits;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ if (cluster == _cacheCluster)
+ {
+ memcpy(data, _cache + lowBits, size);
+ break;
+ }
+
+ const UInt64 high = cluster >> _numMidBits;
+
+ if (high < _dir.Size())
+ {
+ const UInt32 tabl = _dir[(unsigned)high];
+
+ if (tabl != kEmptyDirItem)
+ {
+ const Byte *buffer = _table + ((size_t)tabl << (_numMidBits + 3));
+ const size_t midBits = (size_t)cluster & (((size_t)1 << _numMidBits) - 1);
+ const Byte *p = (const Byte *)buffer + (midBits << 3);
+ UInt64 v = Get64(p);
+
+ if (v != 0)
+ {
+ if ((v & _compressedFlag) != 0)
+ {
+ if (_version <= 1)
+ return E_FAIL;
+
+ /*
+ the example of table record for 12-bit clusters (4KB uncompressed).
+ 2 bits : isCompressed status
+ 4 bits : num_sectors_minus1; packSize = (num_sectors_minus1 + 1) * 512;
+ it uses one additional bit over unpacked cluster_bits
+ 49 bits : offset of 512-sector
+ 9 bits : offset in 512-sector
+ */
+
+ const unsigned numOffsetBits = (62 - (_clusterBits - 9 + 1));
+ const UInt64 offset = v & (((UInt64)1 << 62) - 1);
+ const size_t dataSize = ((size_t)(offset >> numOffsetBits) + 1) << 9;
+ UInt64 sectorOffset = offset & (((UInt64)1 << numOffsetBits) - (1 << 9));
+ const UInt64 offset2inCache = sectorOffset - _comprPos;
+
+ // _comprPos is aligned for 512-bytes
+ // we try to use previous _cacheCompressed that contains compressed data
+ // that was read for previous unpacking
+
+ if (sectorOffset >= _comprPos && offset2inCache < _comprSize)
+ {
+ if (offset2inCache != 0)
+ {
+ _comprSize -= (size_t)offset2inCache;
+ memmove(_cacheCompressed, _cacheCompressed + (size_t)offset2inCache, _comprSize);
+ _comprPos = sectorOffset;
+ }
+ sectorOffset += _comprSize;
+ }
+ else
+ {
+ _comprPos = sectorOffset;
+ _comprSize = 0;
+ }
+
+ if (dataSize > _comprSize)
+ {
+ if (sectorOffset != _posInArc)
+ {
+ // printf("\nDeflate-Seek %12I64x %12I64x\n", sectorOffset, sectorOffset - _posInArc);
+ RINOK(Seek2(sectorOffset))
+ }
+ if (_cacheCompressed.Size() < dataSize)
+ return E_FAIL;
+ const size_t dataSize3 = dataSize - _comprSize;
+ size_t dataSize2 = dataSize3;
+ // printf("\n\n=======\nReadStream = %6d _comprPos = %6d \n", (UInt32)dataSize2, (UInt32)_comprPos);
+ RINOK(ReadStream(Stream, _cacheCompressed + _comprSize, &dataSize2))
+ _posInArc += dataSize2;
+ if (dataSize2 != dataSize3)
+ return E_FAIL;
+ _comprSize += dataSize2;
+ }
+
+ const size_t kSectorMask = (1 << 9) - 1;
+ const size_t offsetInSector = ((size_t)offset & kSectorMask);
+ _bufInStreamSpec->Init(_cacheCompressed + offsetInSector, dataSize - offsetInSector);
+
+ _cacheCluster = (UInt64)(Int64)-1;
+ if (_cache.Size() < clusterSize)
+ return E_FAIL;
+ _bufOutStreamSpec->Init(_cache, clusterSize);
+
+ // Do we need to use smaller block than clusterSize for last cluster?
+ const UInt64 blockSize64 = clusterSize;
+ HRESULT res = _deflateDecoder->Code(_bufInStream, _bufOutStream, NULL, &blockSize64, NULL);
+
+ /*
+ if (_bufOutStreamSpec->GetPos() != clusterSize)
+ memset(_cache + _bufOutStreamSpec->GetPos(), 0, clusterSize - _bufOutStreamSpec->GetPos());
+ */
+
+ if (res == S_OK)
+ if (!_deflateDecoderSpec->IsFinished()
+ || _bufOutStreamSpec->GetPos() != clusterSize)
+ res = S_FALSE;
+
+ RINOK(res)
+ _cacheCluster = cluster;
+
+ continue;
+ /*
+ memcpy(data, _cache + lowBits, size);
+ break;
+ */
+ }
+
+ // version 3 support zero clusters
+ if (((UInt32)v & 511) != 1)
+ {
+ v &= (_compressedFlag - 1);
+ v += lowBits;
+ if (v != _posInArc)
+ {
+ // printf("\n%12I64x\n", v - _posInArc);
+ RINOK(Seek2(v))
+ }
+ HRESULT res = Stream->Read(data, size, &size);
+ _posInArc += size;
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return res;
+ }
+ }
+ }
+ }
+
+ memset(data, 0, size);
+ break;
+ }
+
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+}
+
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize
+};
+
+static const Byte kArcProps[] =
+{
+ kpidClusterSize,
+ kpidUnpackVer,
+ kpidMethod
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidClusterSize: prop = (UInt32)1 << _clusterBits; break;
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+ case kpidUnpackVer: prop = _version; break;
+
+ case kpidMethod:
+ {
+ AString s;
+
+ if (_needDeflate)
+ s = "Deflate";
+
+ if (_cryptMethod != 0)
+ {
+ s.Add_Space_if_NotEmpty();
+ if (_cryptMethod == 1)
+ s += "AES";
+ else
+ s.Add_UInt32(_cryptMethod);
+ }
+
+ if (!s.IsEmpty())
+ prop = s;
+
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
+ // if (_headerError) v |= kpv_ErrorFlags_HeadersError;
+ if (!Stream && v == 0 && _isArc)
+ v = kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidSize: prop = _size; break;
+ case kpidPackSize: prop = _phySize; break;
+ case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openCallback)
+{
+ const unsigned kHeaderSize = 18 * 4;
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buf, kHeaderSize))
+
+ if (memcmp(buf, k_Signature, 4) != 0)
+ return S_FALSE;
+
+ _version = Get32(buf + 4);
+ if (_version < 1 || _version > 3)
+ return S_FALSE;
+
+ const UInt64 backOffset = Get64(buf + 8);
+ // UInt32 backSize = Get32(buf + 0x10);
+
+ UInt64 l1Offset;
+ UInt32 l1Size;
+
+ if (_version == 1)
+ {
+ // _mTime = Get32(buf + 0x14); // is unused im most images
+ _size = Get64(buf + 0x18);
+ _clusterBits = buf[0x20];
+ _numMidBits = buf[0x21];
+ if (_clusterBits < 9 || _clusterBits > 30)
+ return S_FALSE;
+ if (_numMidBits < 1 || _numMidBits > 28)
+ return S_FALSE;
+ _cryptMethod = Get32(buf + 0x24);
+ l1Offset = Get64(buf + 0x28);
+ if (l1Offset < 0x30)
+ return S_FALSE;
+ const unsigned numBits2 = (_clusterBits + _numMidBits);
+ const UInt64 l1Size64 = (_size + (((UInt64)1 << numBits2) - 1)) >> numBits2;
+ if (l1Size64 > ((UInt32)1 << 31))
+ return S_FALSE;
+ l1Size = (UInt32)l1Size64;
+ }
+ else
+ {
+ _clusterBits = Get32(buf + 0x14);
+ if (_clusterBits < 9 || _clusterBits > 30)
+ return S_FALSE;
+ _numMidBits = _clusterBits - 3;
+ _size = Get64(buf + 0x18);
+ _cryptMethod = Get32(buf + 0x20);
+ l1Size = Get32(buf + 0x24);
+ l1Offset = Get64(buf + 0x28); // must be aligned for cluster
+
+ const UInt64 refOffset = Get64(buf + 0x30); // must be aligned for cluster
+ const UInt32 refClusters = Get32(buf + 0x38);
+
+ // UInt32 numSnapshots = Get32(buf + 0x3C);
+ // UInt64 snapshotsOffset = Get64(buf + 0x40); // must be aligned for cluster
+ /*
+ if (numSnapshots != 0)
+ return S_FALSE;
+ */
+
+ if (refClusters != 0)
+ {
+ const size_t numBytes = refClusters << _clusterBits;
+ /*
+ CByteBuffer refs;
+ refs.Alloc(numBytes);
+ RINOK(InStream_SeekSet(stream, refOffset))
+ RINOK(ReadStream_FALSE(stream, refs, numBytes));
+ */
+ const UInt64 end = refOffset + numBytes;
+ if (_phySize < end)
+ _phySize = end;
+ /*
+ for (size_t i = 0; i < numBytes; i += 2)
+ {
+ UInt32 v = GetBe16((const Byte *)refs + (size_t)i);
+ if (v == 0)
+ continue;
+ }
+ */
+ }
+ }
+
+ _isArc = true;
+
+ if (backOffset != 0)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+
+ const size_t clusterSize = (size_t)1 << _clusterBits;
+
+ CByteBuffer table;
+ {
+ const size_t t1SizeBytes = (size_t)l1Size << 3;
+ if ((t1SizeBytes >> 3) != l1Size)
+ return S_FALSE;
+ table.Alloc(t1SizeBytes);
+ RINOK(InStream_SeekSet(stream, l1Offset))
+ RINOK(ReadStream_FALSE(stream, table, t1SizeBytes))
+
+ {
+ UInt64 end = l1Offset + t1SizeBytes;
+ // we need to uses align end for empty qcow files
+ end = (end + clusterSize - 1) >> _clusterBits << _clusterBits;
+ if (_phySize < end)
+ _phySize = end;
+ }
+ }
+
+ _compressedFlag = (_version <= 1) ? ((UInt64)1 << 63) : ((UInt64)1 << 62);
+ const UInt64 offsetMask = _compressedFlag - 1;
+
+ UInt32 numTables = 0;
+ UInt32 i;
+
+ for (i = 0; i < l1Size; i++)
+ {
+ const UInt64 v = Get64((const Byte *)table + (size_t)i * 8) & offsetMask;
+ if (v != 0)
+ numTables++;
+ }
+
+ if (numTables != 0)
+ {
+ const size_t size = (size_t)numTables << (_numMidBits + 3);
+ if (size >> (_numMidBits + 3) != numTables)
+ return E_OUTOFMEMORY;
+ _table.Alloc(size);
+ if (!_table.IsAllocated())
+ return E_OUTOFMEMORY;
+ }
+
+ _dir.SetSize(l1Size);
+
+ UInt32 curTable = 0;
+
+ if (openCallback)
+ {
+ const UInt64 totalBytes = (UInt64)numTables << (_numMidBits + 3);
+ RINOK(openCallback->SetTotal(NULL, &totalBytes))
+ }
+
+ for (i = 0; i < l1Size; i++)
+ {
+ Byte *buf2;
+ const size_t midSize = (size_t)1 << (_numMidBits + 3);
+
+ {
+ const UInt64 v = Get64((const Byte *)table + (size_t)i * 8) & offsetMask;
+ if (v == 0)
+ {
+ _dir[i] = kEmptyDirItem;
+ continue;
+ }
+
+ _dir[i] = curTable;
+ const size_t tableOffset = ((size_t)curTable << (_numMidBits + 3));
+ buf2 = (Byte *)_table + tableOffset;
+ curTable++;
+
+ if (openCallback && (tableOffset & 0xFFFFF) == 0)
+ {
+ const UInt64 numBytes = tableOffset;
+ RINOK(openCallback->SetCompleted(NULL, &numBytes))
+ }
+
+ RINOK(InStream_SeekSet(stream, v))
+ RINOK(ReadStream_FALSE(stream, buf2, midSize))
+
+ const UInt64 end = v + midSize;
+ if (_phySize < end)
+ _phySize = end;
+ }
+
+ for (size_t k = 0; k < midSize; k += 8)
+ {
+ const UInt64 v = Get64((const Byte *)buf2 + (size_t)k);
+ if (v == 0)
+ continue;
+ UInt64 offset = v & offsetMask;
+ size_t dataSize = clusterSize;
+
+ if ((v & _compressedFlag) != 0)
+ {
+ if (_version <= 1)
+ {
+ unsigned numOffsetBits = (63 - _clusterBits);
+ dataSize = ((size_t)(offset >> numOffsetBits) + 1) << 9;
+ offset &= ((UInt64)1 << numOffsetBits) - 1;
+ dataSize = 0;
+ // offset >>= 9;
+ // offset <<= 9;
+ }
+ else
+ {
+ unsigned numOffsetBits = (62 - (_clusterBits - 8));
+ dataSize = ((size_t)(offset >> numOffsetBits) + 1) << 9;
+ offset &= ((UInt64)1 << numOffsetBits) - 1;
+ offset >>= 9;
+ offset <<= 9;
+ }
+ _needDeflate = true;
+ }
+ else
+ {
+ UInt32 low = (UInt32)v & 511;
+ if (low != 0)
+ {
+ // version 3 support zero clusters
+ if (_version < 3 || low != 1)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+ }
+ }
+
+ const UInt64 end = offset + dataSize;
+ if (_phySize < end)
+ _phySize = end;
+ }
+ }
+
+ if (curTable != numTables)
+ return E_FAIL;
+
+ if (_cryptMethod != 0)
+ _unsupported = true;
+
+ if (_needDeflate && _version <= 1) // that case was not implemented
+ _unsupported = true;
+
+ Stream = stream;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _table.Free();
+ _dir.Free();
+ _phySize = 0;
+
+ _cacheCluster = (UInt64)(Int64)-1;
+ _comprPos = 0;
+ _comprSize = 0;
+ _needDeflate = false;
+
+ _isArc = false;
+ _unsupported = false;
+
+ // CHandlerImg:
+ Clear_HandlerImg_Vars();
+ Stream.Release();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+
+ if (_unsupported)
+ return S_FALSE;
+
+ if (_needDeflate)
+ {
+ if (_version <= 1)
+ return S_FALSE;
+
+ if (!_bufInStream)
+ {
+ _bufInStreamSpec = new CBufInStream;
+ _bufInStream = _bufInStreamSpec;
+ }
+
+ if (!_bufOutStream)
+ {
+ _bufOutStreamSpec = new CBufPtrSeqOutStream();
+ _bufOutStream = _bufOutStreamSpec;
+ }
+
+ if (!_deflateDecoder)
+ {
+ _deflateDecoderSpec = new NCompress::NDeflate::NDecoder::CCOMCoder();
+ _deflateDecoder = _deflateDecoderSpec;
+ _deflateDecoderSpec->Set_NeedFinishInput(true);
+ }
+
+ const size_t clusterSize = (size_t)1 << _clusterBits;
+ _cache.AllocAtLeast(clusterSize);
+ _cacheCompressed.AllocAtLeast(clusterSize * 2);
+ }
+
+ CMyComPtr<ISequentialInStream> streamTemp = this;
+ RINOK(InitAndSeek())
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+REGISTER_ARC_I(
+ "QCOW", "qcow qcow2 qcow2c", NULL, 0xCA,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.cpp b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
new file mode 100644
index 0000000..87d11e7
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.cpp
@@ -0,0 +1,3001 @@
+// Rar5Handler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer2.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/PropVariantUtils.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../IPassword.h"
+
+#include "../../Common/FilterCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/RegisterArc.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Common/RegisterCodec.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../../Crypto/Rar5Aes.h"
+
+#include "../Common/FindSignature.h"
+#include "../Common/ItemNameUtils.h"
+
+#include "../HandlerCont.h"
+
+#include "RarVol.h"
+#include "Rar5Handler.h"
+
+using namespace NWindows;
+
+#define Get32(p) GetUi32(p)
+
+namespace NArchive {
+namespace NRar5 {
+
+static const unsigned kMarkerSize = 8;
+
+static const Byte kMarker[kMarkerSize] =
+ { 0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x01, 0 };
+
+static const size_t kCommentSize_Max = (size_t)1 << 16;
+
+
+static const char * const kHostOS[] =
+{
+ "Windows"
+ , "Unix"
+};
+
+
+static const char * const k_ArcFlags[] =
+{
+ "Volume"
+ , "VolumeField"
+ , "Solid"
+ , "Recovery"
+ , "Lock" // 4
+};
+
+
+static const char * const k_FileFlags[] =
+{
+ "Dir"
+ , "UnixTime"
+ , "CRC"
+ , "UnknownSize"
+};
+
+
+static const char * const g_ExtraTypes[] =
+{
+ "0"
+ , "Crypto"
+ , "Hash"
+ , "Time"
+ , "Version"
+ , "Link"
+ , "UnixOwner"
+ , "Subdata"
+};
+
+
+static const char * const g_LinkTypes[] =
+{
+ "0"
+ , "UnixSymLink"
+ , "WinSymLink"
+ , "WinJunction"
+ , "HardLink"
+ , "FileCopy"
+};
+
+
+static const char g_ExtraTimeFlags[] = { 'u', 'M', 'C', 'A', 'n' };
+
+
+static unsigned ReadVarInt(const Byte *p, size_t maxSize, UInt64 *val)
+{
+ *val = 0;
+
+ for (unsigned i = 0; i < maxSize && i < 10;)
+ {
+ Byte b = p[i];
+ *val |= (UInt64)(b & 0x7F) << (7 * i);
+ i++;
+ if ((b & 0x80) == 0)
+ return i;
+ }
+ return 0;
+}
+
+
+bool CLinkInfo::Parse(const Byte *p, unsigned size)
+{
+ const Byte *pStart = p;
+ unsigned num;
+ UInt64 len;
+ num = ReadVarInt(p, size, &Type); if (num == 0) { return false; } p += num; size -= num;
+ num = ReadVarInt(p, size, &Flags); if (num == 0) { return false; } p += num; size -= num;
+ num = ReadVarInt(p, size, &len); if (num == 0) { return false; } p += num; size -= num;
+ if (size != len)
+ return false;
+ NameLen = (unsigned)len;
+ NameOffset = (unsigned)(p - pStart);
+ return true;
+}
+
+
+static void AddHex64(AString &s, UInt64 v)
+{
+ char sz[32];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt64ToHex(v, sz + 2);
+ s += sz;
+}
+
+
+static void PrintType(AString &s, const char * const table[], unsigned num, UInt64 val)
+{
+ char sz[32];
+ const char *p = NULL;
+ if (val < num)
+ p = table[(unsigned)val];
+ if (!p)
+ {
+ ConvertUInt64ToString(val, sz);
+ p = sz;
+ }
+ s += p;
+}
+
+
+int CItem::FindExtra(unsigned extraID, unsigned &recordDataSize) const
+{
+ recordDataSize = 0;
+ size_t offset = 0;
+
+ for (;;)
+ {
+ size_t rem = Extra.Size() - offset;
+ if (rem == 0)
+ return -1;
+
+ {
+ UInt64 size;
+ unsigned num = ReadVarInt(Extra + offset, rem, &size);
+ if (num == 0)
+ return -1;
+ offset += num;
+ rem -= num;
+ if (size > rem)
+ return -1;
+ rem = (size_t)size;
+ }
+ {
+ UInt64 id;
+ unsigned num = ReadVarInt(Extra + offset, rem, &id);
+ if (num == 0)
+ return -1;
+ offset += num;
+ rem -= num;
+
+ // There was BUG in RAR 5.21- : it stored (size-1) instead of (size)
+ // for Subdata record in Service header.
+ // That record always was last in bad archives, so we can fix that case.
+ if (id == NExtraID::kSubdata
+ && RecordType == NHeaderType::kService
+ && rem + 1 == Extra.Size() - offset)
+ rem++;
+
+ if (id == extraID)
+ {
+ recordDataSize = (unsigned)rem;
+ return (int)offset;
+ }
+
+ offset += rem;
+ }
+ }
+}
+
+
+void CItem::PrintInfo(AString &s) const
+{
+ size_t offset = 0;
+
+ for (;;)
+ {
+ size_t rem = Extra.Size() - offset;
+ if (rem == 0)
+ return;
+
+ {
+ UInt64 size;
+ unsigned num = ReadVarInt(Extra + offset, rem, &size);
+ if (num == 0)
+ return;
+ offset += num;
+ rem -= num;
+ if (size > rem)
+ break;
+ rem = (size_t)size;
+ }
+ {
+ UInt64 id;
+ {
+ unsigned num = ReadVarInt(Extra + offset, rem, &id);
+ if (num == 0)
+ break;
+ offset += num;
+ rem -= num;
+ }
+
+ // There was BUG in RAR 5.21- : it stored (size-1) instead of (size)
+ // for Subdata record in Service header.
+ // That record always was last in bad archives, so we can fix that case.
+ if (id == NExtraID::kSubdata
+ && RecordType == NHeaderType::kService
+ && rem + 1 == Extra.Size() - offset)
+ rem++;
+
+ s.Add_Space_if_NotEmpty();
+ PrintType(s, g_ExtraTypes, Z7_ARRAY_SIZE(g_ExtraTypes), id);
+
+ if (id == NExtraID::kTime)
+ {
+ const Byte *p = Extra + offset;
+ UInt64 flags;
+ unsigned num = ReadVarInt(p, rem, &flags);
+ if (num != 0)
+ {
+ s += ':';
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_ExtraTimeFlags); i++)
+ if ((flags & ((UInt64)1 << i)) != 0)
+ s += g_ExtraTimeFlags[i];
+ flags &= ~(((UInt64)1 << Z7_ARRAY_SIZE(g_ExtraTimeFlags)) - 1);
+ if (flags != 0)
+ {
+ s += '_';
+ AddHex64(s, flags);
+ }
+ }
+ }
+ else if (id == NExtraID::kLink)
+ {
+ CLinkInfo linkInfo;
+ if (linkInfo.Parse(Extra + offset, (unsigned)rem))
+ {
+ s += ':';
+ PrintType(s, g_LinkTypes, Z7_ARRAY_SIZE(g_LinkTypes), linkInfo.Type);
+ UInt64 flags = linkInfo.Flags;
+ if (flags != 0)
+ {
+ s += ':';
+ if (flags & NLinkFlags::kTargetIsDir)
+ {
+ s += 'D';
+ flags &= ~((UInt64)NLinkFlags::kTargetIsDir);
+ }
+ if (flags != 0)
+ {
+ s += '_';
+ AddHex64(s, flags);
+ }
+ }
+ }
+ }
+
+ offset += rem;
+ }
+ }
+
+ s.Add_OptSpaced("ERROR");
+}
+
+
+bool CCryptoInfo::Parse(const Byte *p, size_t size)
+{
+ Algo = 0;
+ Flags = 0;
+ Cnt = 0;
+
+ unsigned num = ReadVarInt(p, size, &Algo);
+ if (num == 0) { return false; } p += num; size -= num;
+
+ num = ReadVarInt(p, size, &Flags);
+ if (num == 0) { return false; } p += num; size -= num;
+
+ if (size > 0)
+ Cnt = p[0];
+
+ if (size != 1 + 16 + 16 + (unsigned)(IsThereCheck() ? 12 : 0))
+ return false;
+
+ return true;
+}
+
+
+bool CItem::FindExtra_Version(UInt64 &version) const
+{
+ unsigned size;
+ int offset = FindExtra(NExtraID::kVersion, size);
+ if (offset < 0)
+ return false;
+ const Byte *p = Extra + (unsigned)offset;
+
+ UInt64 flags;
+ unsigned num = ReadVarInt(p, size, &flags);
+ if (num == 0) { return false; } p += num; size -= num;
+
+ num = ReadVarInt(p, size, &version);
+ if (num == 0) { return false; } p += num; size -= num;
+
+ return size == 0;
+}
+
+bool CItem::FindExtra_Link(CLinkInfo &link) const
+{
+ unsigned size;
+ const int offset = FindExtra(NExtraID::kLink, size);
+ if (offset < 0)
+ return false;
+ if (!link.Parse(Extra + (unsigned)offset, size))
+ return false;
+ link.NameOffset += (unsigned)offset;
+ return true;
+}
+
+bool CItem::Is_CopyLink() const
+{
+ CLinkInfo link;
+ return FindExtra_Link(link) && link.Type == NLinkType::kFileCopy;
+}
+
+bool CItem::Is_HardLink() const
+{
+ CLinkInfo link;
+ return FindExtra_Link(link) && link.Type == NLinkType::kHardLink;
+}
+
+bool CItem::Is_CopyLink_or_HardLink() const
+{
+ CLinkInfo link;
+ return FindExtra_Link(link) && (link.Type == NLinkType::kFileCopy || link.Type == NLinkType::kHardLink);
+}
+
+void CItem::Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop) const
+{
+ CLinkInfo link;
+ if (!FindExtra_Link(link))
+ return;
+
+ if (link.Type != linkType)
+ {
+ if (linkType != NLinkType::kUnixSymLink)
+ return;
+ switch ((unsigned)link.Type)
+ {
+ case NLinkType::kUnixSymLink:
+ case NLinkType::kWinSymLink:
+ case NLinkType::kWinJunction:
+ break;
+ default: return;
+ }
+ }
+
+ AString s;
+ s.SetFrom_CalcLen((const char *)(Extra + link.NameOffset), link.NameLen);
+
+ UString unicode;
+ ConvertUTF8ToUnicode(s, unicode);
+ prop = NItemName::GetOsPath(unicode);
+}
+
+bool CItem::GetAltStreamName(AString &name) const
+{
+ name.Empty();
+ unsigned size;
+ int offset = FindExtra(NExtraID::kSubdata, size);
+ if (offset < 0)
+ return false;
+ name.SetFrom_CalcLen((const char *)(Extra + (unsigned)offset), size);
+ return true;
+}
+
+
+class CHash
+{
+ bool _calcCRC;
+ UInt32 _crc;
+ int _blakeOffset;
+ CBlake2sp _blake;
+public:
+
+ void Init_NoCalc()
+ {
+ _calcCRC = false;
+ _crc = CRC_INIT_VAL;
+ _blakeOffset = -1;
+ }
+
+ void Init(const CItem &item);
+ void Update(const void *data, size_t size);
+ UInt32 GetCRC() const { return CRC_GET_DIGEST(_crc); }
+
+ bool Check(const CItem &item, NCrypto::NRar5::CDecoder *cryptoDecoderSpec);
+};
+
+void CHash::Init(const CItem &item)
+{
+ _crc = CRC_INIT_VAL;
+ _calcCRC = item.Has_CRC();
+
+ _blakeOffset = item.FindExtra_Blake();
+ if (_blakeOffset >= 0)
+ Blake2sp_Init(&_blake);
+}
+
+void CHash::Update(const void *data, size_t size)
+{
+ if (_calcCRC)
+ _crc = CrcUpdate(_crc, data, size);
+ if (_blakeOffset >= 0)
+ Blake2sp_Update(&_blake, (const Byte *)data, size);
+}
+
+bool CHash::Check(const CItem &item, NCrypto::NRar5::CDecoder *cryptoDecoderSpec)
+{
+ if (_calcCRC)
+ {
+ UInt32 crc = GetCRC();
+ if (cryptoDecoderSpec)
+ crc = cryptoDecoderSpec->Hmac_Convert_Crc32(crc);
+ if (crc != item.CRC)
+ return false;
+ }
+
+ if (_blakeOffset >= 0)
+ {
+ Byte digest[BLAKE2S_DIGEST_SIZE];
+ Blake2sp_Final(&_blake, digest);
+ if (cryptoDecoderSpec)
+ cryptoDecoderSpec->Hmac_Convert_32Bytes(digest);
+ if (memcmp(digest, &item.Extra[(unsigned)_blakeOffset], BLAKE2S_DIGEST_SIZE) != 0)
+ return false;
+ }
+
+ return true;
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithHash
+ , ISequentialOutStream
+)
+ ISequentialOutStream *_stream;
+ UInt64 _pos;
+ UInt64 _size;
+ bool _size_Defined;
+ Byte *_destBuf;
+public:
+ CHash _hash;
+
+ COutStreamWithHash(): _destBuf(NULL) {}
+
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void Init(const CItem &item, Byte *destBuf)
+ {
+ _size_Defined = false;
+ _size = 0;
+ _destBuf = NULL;
+ if (!item.Is_UnknownSize())
+ {
+ _size_Defined = true;
+ _size = item.Size;
+ _destBuf = destBuf;
+ }
+ _pos = 0;
+ _hash.Init(item);
+ }
+ UInt64 GetPos() const { return _pos; }
+};
+
+
+Z7_COM7F_IMF(COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_size_Defined)
+ {
+ UInt64 rem = _size - _pos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ if (_destBuf)
+ memcpy(_destBuf + (size_t)_pos, data, size);
+ _hash.Update(data, size);
+ _pos += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+
+
+
+
+class CInArchive
+{
+ CAlignedBuffer _buf;
+ size_t _bufSize;
+ size_t _bufPos;
+ ISequentialInStream *_stream;
+
+ NCrypto::NRar5::CDecoder *m_CryptoDecoderSpec;
+ CMyComPtr<ICompressFilter> m_CryptoDecoder;
+
+ Z7_CLASS_NO_COPY(CInArchive)
+
+ HRESULT ReadStream_Check(void *data, size_t size);
+
+public:
+ bool m_CryptoMode;
+
+ bool WrongPassword;
+ bool IsArc;
+ bool UnexpectedEnd;
+
+ UInt64 StreamStartPosition;
+ UInt64 Position;
+
+ bool ReadVar(UInt64 &val);
+
+ struct CHeader
+ {
+ UInt64 Type;
+ UInt64 Flags;
+ size_t ExtraSize;
+ UInt64 DataSize;
+ };
+
+ CInArchive() {}
+
+ HRESULT ReadBlockHeader(CHeader &h);
+ bool ReadFileHeader(const CHeader &header, CItem &item);
+ void AddToSeekValue(UInt64 addValue)
+ {
+ Position += addValue;
+ }
+
+ HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, ICryptoGetTextPassword *getTextPassword,
+ CInArcInfo &info);
+};
+
+
+static HRESULT MySetPassword(ICryptoGetTextPassword *getTextPassword, NCrypto::NRar5::CDecoder *cryptoDecoderSpec)
+{
+ CMyComBSTR_Wipe password;
+ RINOK(getTextPassword->CryptoGetTextPassword(&password))
+ AString_Wipe utf8;
+ const unsigned kPasswordLen_MAX = 127;
+ UString_Wipe unicode;
+ unicode.SetFromBstr(password);
+ if (unicode.Len() > kPasswordLen_MAX)
+ unicode.DeleteFrom(kPasswordLen_MAX);
+ ConvertUnicodeToUTF8(unicode, utf8);
+ cryptoDecoderSpec->SetPassword((const Byte *)(const char *)utf8, utf8.Len());
+ return S_OK;
+}
+
+
+bool CInArchive::ReadVar(UInt64 &val)
+{
+ unsigned offset = ReadVarInt(_buf + _bufPos, _bufSize - _bufPos, &val);
+ _bufPos += offset;
+ return (offset != 0);
+}
+
+
+HRESULT CInArchive::ReadStream_Check(void *data, size_t size)
+{
+ size_t size2 = size;
+ RINOK(ReadStream(_stream, data, &size2))
+ if (size2 == size)
+ return S_OK;
+ UnexpectedEnd = true;
+ return S_FALSE;
+}
+
+
+HRESULT CInArchive::ReadBlockHeader(CHeader &h)
+{
+ h.Type = 0;
+ h.Flags = 0;
+ h.ExtraSize = 0;
+ h.DataSize = 0;
+
+ const unsigned kStartSize = 4 + 3;
+ const unsigned kBufSize = AES_BLOCK_SIZE + AES_BLOCK_SIZE; // must be >= kStartSize;
+ Byte buf[kBufSize];
+ unsigned filled;
+
+ if (m_CryptoMode)
+ {
+ RINOK(ReadStream_Check(buf, kBufSize))
+ memcpy(m_CryptoDecoderSpec->_iv, buf, AES_BLOCK_SIZE);
+ RINOK(m_CryptoDecoderSpec->Init())
+
+ _buf.AllocAtLeast(1 << 12);
+ if (!(Byte *)_buf)
+ return E_OUTOFMEMORY;
+
+ memcpy(_buf, buf + AES_BLOCK_SIZE, AES_BLOCK_SIZE);
+ if (m_CryptoDecoder->Filter(_buf, AES_BLOCK_SIZE) != AES_BLOCK_SIZE)
+ return E_FAIL;
+ memcpy(buf, _buf, AES_BLOCK_SIZE);
+ filled = AES_BLOCK_SIZE;
+ }
+ else
+ {
+ RINOK(ReadStream_Check(buf, kStartSize))
+ filled = kStartSize;
+ }
+
+ UInt64 val;
+ unsigned offset = ReadVarInt(buf + 4, 3, &val);
+ if (offset == 0)
+ return S_FALSE;
+ {
+ size_t size = (size_t)val;
+ _bufPos = (4 + offset);
+ _bufSize = _bufPos + size;
+ if (size < 2)
+ return S_FALSE;
+ }
+
+ size_t allocSize = _bufSize;
+ if (m_CryptoMode)
+ allocSize = (allocSize + AES_BLOCK_SIZE - 1) & ~(size_t)(AES_BLOCK_SIZE - 1);
+ _buf.AllocAtLeast(allocSize);
+ if (!(Byte *)_buf)
+ return E_OUTOFMEMORY;
+
+ memcpy(_buf, buf, filled);
+
+ size_t rem = allocSize - filled;
+ AddToSeekValue(allocSize + (m_CryptoMode ? AES_BLOCK_SIZE : 0));
+ RINOK(ReadStream_Check(_buf + filled, rem))
+ if (m_CryptoMode)
+ {
+ if (m_CryptoDecoder->Filter(_buf + filled, (UInt32)rem) != rem)
+ return E_FAIL;
+ }
+
+ if (CrcCalc(_buf + 4, _bufSize - 4) != Get32(buf))
+ return S_FALSE;
+
+ if (!ReadVar(h.Type)) return S_FALSE;
+ if (!ReadVar(h.Flags)) return S_FALSE;
+
+ if (h.Flags & NHeaderFlags::kExtra)
+ {
+ UInt64 extraSize;
+ if (!ReadVar(extraSize))
+ return S_FALSE;
+ if (extraSize > _bufSize)
+ return S_FALSE;
+ h.ExtraSize = (size_t)extraSize;
+ }
+
+ if (h.Flags & NHeaderFlags::kData)
+ {
+ if (!ReadVar(h.DataSize))
+ return S_FALSE;
+ }
+
+ return S_OK;
+}
+
+
+/*
+int CInArcInfo::FindExtra(unsigned extraID, unsigned &recordDataSize) const
+{
+ recordDataSize = 0;
+ size_t offset = 0;
+
+ for (;;)
+ {
+ size_t rem = Extra.Size() - offset;
+ if (rem == 0)
+ return -1;
+
+ {
+ UInt64 size;
+ unsigned num = ReadVarInt(Extra + offset, rem, &size);
+ if (num == 0)
+ return -1;
+ offset += num;
+ rem -= num;
+ if (size > rem)
+ return -1;
+ rem = (size_t)size;
+ }
+ {
+ UInt64 id;
+ unsigned num = ReadVarInt(Extra + offset, rem, &id);
+ if (num == 0)
+ return -1;
+ offset += num;
+ rem -= num;
+
+ if (id == extraID)
+ {
+ recordDataSize = (unsigned)rem;
+ return (int)offset;
+ }
+
+ offset += rem;
+ }
+ }
+}
+
+
+bool CInArcInfo::FindExtra_Locator(CLocator &locator) const
+{
+ locator.Flags = 0;
+ locator.QuickOpen = 0;
+ locator.Recovery = 0;
+
+ unsigned size;
+ int offset = FindExtra(kArcExtraRecordType_Locator, size);
+ if (offset < 0)
+ return false;
+ const Byte *p = Extra + (unsigned)offset;
+
+ unsigned num;
+
+ num = ReadVarInt(p, size, &locator.Flags);
+ if (num == 0) return false; p += num; size -= num;
+
+ if (locator.Is_QuickOpen())
+ {
+ num = ReadVarInt(p, size, &locator.QuickOpen);
+ if (num == 0) return false; p += num; size -= num;
+ }
+
+ if (locator.Is_Recovery())
+ {
+ num = ReadVarInt(p, size, &locator.Recovery);
+ if (num == 0) return false; p += num; size -= num;
+ }
+
+ return true;
+}
+*/
+
+
+HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit, ICryptoGetTextPassword *getTextPassword,
+ CInArcInfo &info)
+{
+ m_CryptoMode = false;
+
+ WrongPassword = false;
+ IsArc = false;
+ UnexpectedEnd = false;
+
+ Position = StreamStartPosition;
+
+ UInt64 arcStartPos = StreamStartPosition;
+ {
+ Byte marker[kMarkerSize];
+ RINOK(ReadStream_FALSE(stream, marker, kMarkerSize))
+ if (memcmp(marker, kMarker, kMarkerSize) == 0)
+ Position += kMarkerSize;
+ else
+ {
+ if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(stream, StreamStartPosition))
+ RINOK(FindSignatureInStream(stream, kMarker, kMarkerSize,
+ searchHeaderSizeLimit, arcStartPos))
+ arcStartPos += StreamStartPosition;
+ Position = arcStartPos + kMarkerSize;
+ RINOK(InStream_SeekSet(stream, Position))
+ }
+ }
+
+ info.StartPos = arcStartPos;
+ _stream = stream;
+
+ CHeader h;
+ RINOK(ReadBlockHeader(h))
+ info.IsEncrypted = false;
+
+ if (h.Type == NHeaderType::kArcEncrypt)
+ {
+ info.IsEncrypted = true;
+ IsArc = true;
+ if (!getTextPassword)
+ return E_NOTIMPL;
+
+ m_CryptoMode = true;
+
+ if (!m_CryptoDecoder)
+ {
+ m_CryptoDecoderSpec = new NCrypto::NRar5::CDecoder;
+ m_CryptoDecoder = m_CryptoDecoderSpec;
+ }
+
+ RINOK(m_CryptoDecoderSpec->SetDecoderProps(
+ _buf + _bufPos, (unsigned)(_bufSize - _bufPos), false, false))
+
+ RINOK(MySetPassword(getTextPassword, m_CryptoDecoderSpec))
+
+ if (!m_CryptoDecoderSpec->CalcKey_and_CheckPassword())
+ {
+ WrongPassword = True;
+ return S_FALSE;
+ }
+
+ RINOK(ReadBlockHeader(h))
+ }
+
+ if (h.Type != NHeaderType::kArc)
+ return S_FALSE;
+
+ IsArc = true;
+ info.VolNumber = 0;
+
+ if (!ReadVar(info.Flags))
+ return S_FALSE;
+
+ if (info.Flags & NArcFlags::kVolNumber)
+ if (!ReadVar(info.VolNumber))
+ return S_FALSE;
+
+ if (h.ExtraSize != 0)
+ {
+ if (_bufSize - _bufPos < h.ExtraSize)
+ return S_FALSE;
+ /*
+ info.Extra.Alloc(h.ExtraSize);
+ memcpy(info.Extra, _buf + _bufPos, h.ExtraSize);
+ */
+ _bufPos += h.ExtraSize;
+
+ /*
+ CInArcInfo::CLocator locator;
+ if (info.FindExtra_Locator(locator))
+ locator.Flags = locator.Flags;
+ */
+ }
+
+ if (_bufPos != _bufSize)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+bool CInArchive::ReadFileHeader(const CHeader &header, CItem &item)
+{
+ item.UnixMTime = 0;
+ item.CRC = 0;
+ item.Flags = 0;
+
+ item.CommonFlags = (UInt32)header.Flags;
+ item.PackSize = header.DataSize;
+
+ UInt64 flags64;
+ if (!ReadVar(flags64)) return false;
+ item.Flags = (UInt32)flags64;
+
+ if (!ReadVar(item.Size)) return false;
+
+ {
+ UInt64 attrib;
+ if (!ReadVar(attrib)) return false;
+ item.Attrib = (UInt32)attrib;
+ }
+
+ if (item.Has_UnixMTime())
+ {
+ if (_bufSize - _bufPos < 4)
+ return false;
+ item.UnixMTime = Get32(_buf + _bufPos);
+ _bufPos += 4;
+ }
+
+ if (item.Has_CRC())
+ {
+ if (_bufSize - _bufPos < 4)
+ return false;
+ item.CRC = Get32(_buf + _bufPos);
+ _bufPos += 4;
+ }
+
+ {
+ UInt64 method;
+ if (!ReadVar(method)) return false;
+ item.Method = (UInt32)method;
+ }
+
+ if (!ReadVar(item.HostOS)) return false;
+
+ {
+ UInt64 len;
+ if (!ReadVar(len)) return false;
+ if (len > _bufSize - _bufPos)
+ return false;
+ item.Name.SetFrom_CalcLen((const char *)(_buf + _bufPos), (unsigned)len);
+ _bufPos += (unsigned)len;
+ }
+
+ item.Extra.Free();
+ size_t extraSize = header.ExtraSize;
+ if (extraSize != 0)
+ {
+ if (_bufSize - _bufPos < extraSize)
+ return false;
+ item.Extra.Alloc(extraSize);
+ memcpy(item.Extra, _buf + _bufPos, extraSize);
+ _bufPos += extraSize;
+ }
+
+
+ return (_bufPos == _bufSize);
+}
+
+
+
+struct CLinkFile
+{
+ unsigned Index;
+ unsigned NumLinks; // the number of links to Data
+ CByteBuffer Data;
+ HRESULT Res;
+ bool crcOK;
+
+ CLinkFile(): Index(0), NumLinks(0), Res(S_OK), crcOK(true) {}
+};
+
+
+struct CUnpacker
+{
+ NCompress::CCopyCoder *copyCoderSpec;
+ CMyComPtr<ICompressCoder> copyCoder;
+
+ CMyComPtr<ICompressCoder> LzCoders[2];
+ bool SolidAllowed;
+
+ CFilterCoder *filterStreamSpec;
+ CMyComPtr<ISequentialInStream> filterStream;
+
+ NCrypto::NRar5::CDecoder *cryptoDecoderSpec;
+ CMyComPtr<ICompressFilter> cryptoDecoder;
+
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+
+ COutStreamWithHash *outStreamSpec;
+ CMyComPtr<ISequentialOutStream> outStream;
+
+ CByteBuffer _tempBuf;
+
+ CLinkFile *linkFile;
+
+ CUnpacker(): linkFile(NULL) { SolidAllowed = false; }
+
+ HRESULT Create(DECL_EXTERNAL_CODECS_LOC_VARS const CItem &item, bool isSolid, bool &wrongPassword);
+
+ HRESULT Code(const CItem &item, const CItem &lastItem, UInt64 packSize,
+ ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress,
+ bool &isCrcOK);
+
+ HRESULT DecodeToBuf(DECL_EXTERNAL_CODECS_LOC_VARS const CItem &item, UInt64 packSize, ISequentialInStream *inStream, CByteBuffer &buffer);
+};
+
+
+static const unsigned kLzMethodMax = 5;
+
+HRESULT CUnpacker::Create(DECL_EXTERNAL_CODECS_LOC_VARS const CItem &item, bool isSolid, bool &wrongPassword)
+{
+ wrongPassword = false;
+
+ if (item.GetAlgoVersion() != 0)
+ return E_NOTIMPL;
+
+ if (!outStream)
+ {
+ outStreamSpec = new COutStreamWithHash;
+ outStream = outStreamSpec;
+ }
+
+ unsigned method = item.GetMethod();
+
+ if (method == 0)
+ {
+ if (!copyCoder)
+ {
+ copyCoderSpec = new NCompress::CCopyCoder;
+ copyCoder = copyCoderSpec;
+ }
+ }
+ else
+ {
+ if (method > kLzMethodMax)
+ return E_NOTIMPL;
+
+ /*
+ if (item.IsSplitBefore())
+ return S_FALSE;
+ */
+
+ int lzIndex = item.IsService() ? 1 : 0;
+ CMyComPtr<ICompressCoder> &lzCoder = LzCoders[lzIndex];
+
+ if (!lzCoder)
+ {
+ const UInt32 methodID = 0x40305;
+ RINOK(CreateCoder_Id(EXTERNAL_CODECS_LOC_VARS methodID, false, lzCoder))
+ if (!lzCoder)
+ return E_NOTIMPL;
+ }
+
+ CMyComPtr<ICompressSetDecoderProperties2> csdp;
+ RINOK(lzCoder.QueryInterface(IID_ICompressSetDecoderProperties2, &csdp))
+
+ Byte props[2] = { (Byte)(item.GetDictSize()), (Byte)(isSolid ? 1 : 0) };
+ RINOK(csdp->SetDecoderProperties2(props, 2))
+ }
+
+ unsigned cryptoSize = 0;
+ int cryptoOffset = item.FindExtra(NExtraID::kCrypto, cryptoSize);
+
+ if (cryptoOffset >= 0)
+ {
+ if (!filterStream)
+ {
+ filterStreamSpec = new CFilterCoder(false);
+ filterStream = filterStreamSpec;
+ }
+
+ if (!cryptoDecoder)
+ {
+ cryptoDecoderSpec = new NCrypto::NRar5::CDecoder;
+ cryptoDecoder = cryptoDecoderSpec;
+ }
+
+ RINOK(cryptoDecoderSpec->SetDecoderProps(item.Extra + (unsigned)cryptoOffset, cryptoSize, true, item.IsService()))
+
+ if (!getTextPassword)
+ {
+ wrongPassword = True;
+ return E_NOTIMPL;
+ }
+
+ RINOK(MySetPassword(getTextPassword, cryptoDecoderSpec))
+
+ if (!cryptoDecoderSpec->CalcKey_and_CheckPassword())
+ wrongPassword = True;
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CUnpacker::Code(const CItem &item, const CItem &lastItem, UInt64 packSize,
+ ISequentialInStream *volsInStream, ISequentialOutStream *realOutStream, ICompressProgressInfo *progress,
+ bool &isCrcOK)
+{
+ isCrcOK = true;
+
+ unsigned method = item.GetMethod();
+ if (method > kLzMethodMax)
+ return E_NOTIMPL;
+
+ bool needBuf = (linkFile && linkFile->NumLinks != 0);
+
+ if (needBuf && !lastItem.Is_UnknownSize())
+ {
+ size_t dataSize = (size_t)lastItem.Size;
+ if (dataSize != lastItem.Size)
+ return E_NOTIMPL;
+ linkFile->Data.Alloc(dataSize);
+ }
+
+ bool isCryptoMode = false;
+ ISequentialInStream *inStream;
+
+ if (item.IsEncrypted())
+ {
+ filterStreamSpec->Filter = cryptoDecoder;
+ filterStreamSpec->SetInStream(volsInStream);
+ filterStreamSpec->SetOutStreamSize(NULL);
+ inStream = filterStream;
+ isCryptoMode = true;
+ }
+ else
+ inStream = volsInStream;
+
+ ICompressCoder *commonCoder = (method == 0) ? copyCoder : LzCoders[item.IsService() ? 1 : 0];
+
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init(lastItem, (needBuf ? (Byte *)linkFile->Data : NULL));
+
+ HRESULT res = S_OK;
+ if (packSize != 0 || lastItem.Is_UnknownSize() || lastItem.Size != 0)
+ {
+ res = commonCoder->Code(inStream, outStream, &packSize,
+ lastItem.Is_UnknownSize() ? NULL : &lastItem.Size, progress);
+ if (!item.IsService())
+ SolidAllowed = true;
+ }
+ else
+ {
+ // res = res;
+ }
+
+ if (isCryptoMode)
+ filterStreamSpec->ReleaseInStream();
+
+ UInt64 processedSize = outStreamSpec->GetPos();
+ if (res == S_OK && !lastItem.Is_UnknownSize() && processedSize != lastItem.Size)
+ res = S_FALSE;
+
+ // if (res == S_OK)
+ {
+ unsigned cryptoSize = 0;
+ int cryptoOffset = lastItem.FindExtra(NExtraID::kCrypto, cryptoSize);
+ NCrypto::NRar5::CDecoder *crypto = NULL;
+
+ if (cryptoOffset >= 0)
+ {
+ CCryptoInfo cryptoInfo;
+ if (cryptoInfo.Parse(lastItem.Extra + (unsigned)cryptoOffset, cryptoSize))
+ if (cryptoInfo.UseMAC())
+ crypto = cryptoDecoderSpec;
+ }
+
+ isCrcOK = outStreamSpec->_hash.Check(lastItem, crypto);
+ }
+
+ if (linkFile)
+ {
+ linkFile->Res = res;
+ linkFile->crcOK = isCrcOK;
+ if (needBuf
+ && !lastItem.Is_UnknownSize()
+ && processedSize != lastItem.Size)
+ linkFile->Data.ChangeSize_KeepData((size_t)processedSize, (size_t)processedSize);
+ }
+
+ return res;
+}
+
+
+HRESULT CUnpacker::DecodeToBuf(DECL_EXTERNAL_CODECS_LOC_VARS const CItem &item, UInt64 packSize, ISequentialInStream *inStream, CByteBuffer &buffer)
+{
+ CBufPtrSeqOutStream *outSpec = new CBufPtrSeqOutStream;
+ CMyComPtr<ISequentialOutStream> out = outSpec;
+ _tempBuf.AllocAtLeast((size_t)item.Size);
+ outSpec->Init(_tempBuf, (size_t)item.Size);
+
+ bool wrongPassword;
+
+ if (item.IsSolid())
+ return E_NOTIMPL;
+
+ HRESULT res = Create(EXTERNAL_CODECS_LOC_VARS item, item.IsSolid(), wrongPassword);
+
+ if (res == S_OK)
+ {
+ if (wrongPassword)
+ return S_FALSE;
+
+ CLimitedSequentialInStream *limitedStreamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> limitedStream(limitedStreamSpec);
+ limitedStreamSpec->SetStream(inStream);
+ limitedStreamSpec->Init(packSize);
+
+ bool crcOK = true;
+ res = Code(item, item, packSize, limitedStream, out, NULL, crcOK);
+ if (res == S_OK)
+ {
+ if (!crcOK || outSpec->GetPos() != item.Size)
+ res = S_FALSE;
+ else
+ buffer.CopyFrom(_tempBuf, (size_t)item.Size);
+ }
+ }
+
+ return res;
+}
+
+
+struct CTempBuf
+{
+ CByteBuffer _buf;
+ size_t _offset;
+ bool _isOK;
+
+ void Clear()
+ {
+ _offset = 0;
+ _isOK = true;
+ }
+
+ CTempBuf() { Clear(); }
+
+ HRESULT Decode(DECL_EXTERNAL_CODECS_LOC_VARS
+ const CItem &item,
+ ISequentialInStream *inStream, CUnpacker &unpacker, CByteBuffer &destBuf);
+};
+
+
+HRESULT CTempBuf::Decode(DECL_EXTERNAL_CODECS_LOC_VARS
+ const CItem &item,
+ ISequentialInStream *inStream,
+ CUnpacker &unpacker,
+ CByteBuffer &destBuf)
+{
+ const size_t kPackSize_Max = (1 << 24);
+ if (item.Size > (1 << 24)
+ || item.Size == 0
+ || item.PackSize >= kPackSize_Max)
+ {
+ Clear();
+ return S_OK;
+ }
+
+ if (item.IsSplit() /* && _isOK */)
+ {
+ size_t packSize = (size_t)item.PackSize;
+ if (packSize > kPackSize_Max - _offset)
+ return S_OK;
+ size_t newSize = _offset + packSize;
+ if (newSize > _buf.Size())
+ _buf.ChangeSize_KeepData(newSize, _offset);
+
+ Byte *data = (Byte *)_buf + _offset;
+ RINOK(ReadStream_FALSE(inStream, data, packSize))
+
+ _offset += packSize;
+
+ if (item.IsSplitAfter())
+ {
+ CHash hash;
+ hash.Init(item);
+ hash.Update(data, packSize);
+ _isOK = hash.Check(item, NULL); // RAR5 doesn't use HMAC for packed part
+ }
+ }
+
+ if (_isOK)
+ {
+ if (!item.IsSplitAfter())
+ {
+ if (_offset == 0)
+ {
+ RINOK(unpacker.DecodeToBuf(EXTERNAL_CODECS_LOC_VARS
+ item, item.PackSize, inStream, destBuf))
+ }
+ else
+ {
+ CBufInStream *bufInStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> bufInStream = bufInStreamSpec;
+ bufInStreamSpec->Init(_buf, _offset);
+ RINOK(unpacker.DecodeToBuf(EXTERNAL_CODECS_LOC_VARS
+ item, _offset, bufInStream, destBuf))
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidAttrib,
+
+ kpidIsAltStream,
+ kpidEncrypted,
+ kpidSolid,
+ kpidSplitBefore,
+ kpidSplitAfter,
+ kpidCRC,
+ kpidHostOS,
+ kpidMethod,
+ kpidCharacts,
+ kpidSymLink,
+ kpidHardLink,
+ kpidCopyLink,
+
+ kpidVolumeIndex
+};
+
+
+static const Byte kArcProps[] =
+{
+ kpidTotalPhySize,
+ kpidCharacts,
+ kpidSolid,
+ kpidNumBlocks,
+ kpidEncrypted,
+ kpidIsVolume,
+ kpidVolumeIndex,
+ kpidNumVolumes,
+ kpidComment
+};
+
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+
+UInt64 CHandler::GetPackSize(unsigned refIndex) const
+{
+ UInt64 size = 0;
+ unsigned index = _refs[refIndex].Item;
+ for (;;)
+ {
+ const CItem &item = _items[index];
+ size += item.PackSize;
+ if (item.NextItem < 0)
+ return size;
+ index = (unsigned)item.NextItem;
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+
+ NCOM::CPropVariant prop;
+
+ const CInArcInfo *arcInfo = NULL;
+ if (!_arcs.IsEmpty())
+ arcInfo = &_arcs[0].Info;
+
+ switch (propID)
+ {
+ case kpidVolumeIndex: if (arcInfo && arcInfo->IsVolume()) prop = arcInfo->GetVolIndex(); break;
+ case kpidSolid: if (arcInfo) prop = arcInfo->IsSolid(); break;
+ case kpidCharacts:
+ {
+ if (!_arcs.IsEmpty())
+ {
+ FLAGS_TO_PROP(k_ArcFlags, (UInt32)arcInfo->Flags, prop);
+ }
+ break;
+ }
+ case kpidEncrypted: if (arcInfo) prop = arcInfo->IsEncrypted; break; // it's for encrypted names.
+ case kpidIsVolume: if (arcInfo) prop = arcInfo->IsVolume(); break;
+ case kpidNumVolumes: prop = (UInt32)_arcs.Size(); break;
+ case kpidOffset: if (arcInfo && arcInfo->StartPos != 0) prop = arcInfo->StartPos; break;
+
+ case kpidTotalPhySize:
+ {
+ if (_arcs.Size() > 1)
+ {
+ UInt64 sum = 0;
+ FOR_VECTOR (v, _arcs)
+ sum += _arcs[v].Info.GetPhySize();
+ prop = sum;
+ }
+ break;
+ }
+
+ case kpidPhySize:
+ {
+ if (arcInfo)
+ prop = arcInfo->GetPhySize();
+ break;
+ }
+
+ case kpidComment:
+ {
+ // if (!_arcs.IsEmpty())
+ {
+ // const CArc &arc = _arcs[0];
+ const CByteBuffer &cmt = _comment;
+ if (cmt.Size() != 0 && cmt.Size() < (1 << 16))
+ {
+ AString s;
+ s.SetFrom_CalcLen((const char *)(const Byte *)cmt, (unsigned)cmt.Size());
+ UString unicode;
+ ConvertUTF8ToUnicode(s, unicode);
+ prop = unicode;
+ }
+ }
+ break;
+ }
+
+ case kpidNumBlocks:
+ {
+ UInt32 numBlocks = 0;
+ FOR_VECTOR (i, _refs)
+ if (!_items[_refs[i].Item].IsSolid())
+ numBlocks++;
+ prop = (UInt32)numBlocks;
+ break;
+ }
+
+ case kpidError:
+ {
+ if (/* &_missingVol || */ !_missingVolName.IsEmpty())
+ {
+ UString s ("Missing volume : ");
+ s += _missingVolName;
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = _errorFlags;
+ if (!_isArc)
+ v |= kpv_ErrorFlags_IsNotArc;
+ prop = v;
+ break;
+ }
+
+ /*
+ case kpidWarningFlags:
+ {
+ if (_warningFlags != 0)
+ prop = _warningFlags;
+ break;
+ }
+ */
+
+ case kpidExtension:
+ if (_arcs.Size() == 1)
+ {
+ if (arcInfo->IsVolume())
+ {
+ AString s ("part");
+ UInt32 v = (UInt32)arcInfo->GetVolIndex() + 1;
+ if (v < 10)
+ s += '0';
+ s.Add_UInt32(v);
+ s += ".rar";
+ prop = s;
+ }
+ }
+ break;
+
+ case kpidIsAltStream: prop = true; break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _refs.Size();
+ return S_OK;
+}
+
+
+static const Byte kRawProps[] =
+{
+ kpidChecksum,
+ kpidNtSecure
+};
+
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = Z7_ARRAY_SIZE(kRawProps);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+{
+ *propID = kRawProps[index];
+ *name = NULL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+
+ if (index >= _refs.Size())
+ return S_OK;
+
+ const CRefItem &ref = _refs[index];
+ const CItem &item = _items[ref.Item];
+
+ if (item.Is_STM() && ref.Parent >= 0)
+ {
+ *parent = (UInt32)ref.Parent;
+ *parentType = NParentType::kAltStream;
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (index >= _refs.Size())
+ return E_INVALIDARG;
+
+ const CItem &item = _items[_refs[index].Item];
+
+ if (propID == kpidNtSecure)
+ {
+ if (item.ACL >= 0)
+ {
+ const CByteBuffer &buf = _acls[item.ACL];
+ *dataSize = (UInt32)buf.Size();
+ *propType = NPropDataType::kRaw;
+ *data = (const Byte *)buf;
+ }
+ return S_OK;
+ }
+
+ if (propID == kpidChecksum)
+ {
+ int hashRecOffset = item.FindExtra_Blake();
+ if (hashRecOffset >= 0)
+ {
+ *dataSize = BLAKE2S_DIGEST_SIZE;
+ *propType = NPropDataType::kRaw;
+ *data = &item.Extra[hashRecOffset];
+ }
+ return S_OK;
+ }
+
+ return S_OK;
+}
+
+
+static void TimeRecordToProp(const CItem &item, unsigned stampIndex, NCOM::CPropVariant &prop)
+{
+ unsigned size;
+ const int offset = item.FindExtra(NExtraID::kTime, size);
+ if (offset < 0)
+ return;
+
+ const Byte *p = item.Extra + (unsigned)offset;
+ UInt64 flags;
+ {
+ const unsigned num = ReadVarInt(p, size, &flags);
+ if (num == 0)
+ return;
+ p += num;
+ size -= num;
+ }
+
+ if ((flags & (NTimeRecord::NFlags::kMTime << stampIndex)) == 0)
+ return;
+
+ unsigned numStamps = 0;
+ unsigned curStamp = 0;
+
+ for (unsigned i = 0; i < 3; i++)
+ if ((flags & (NTimeRecord::NFlags::kMTime << i)) != 0)
+ {
+ if (i == stampIndex)
+ curStamp = numStamps;
+ numStamps++;
+ }
+
+ FILETIME ft;
+
+ unsigned timePrec = 0;
+ unsigned ns100 = 0;
+
+ if ((flags & NTimeRecord::NFlags::kUnixTime) != 0)
+ {
+ curStamp *= 4;
+ if (curStamp + 4 > size)
+ return;
+ p += curStamp;
+ UInt64 val = NTime::UnixTime_To_FileTime64(Get32(p));
+ numStamps *= 4;
+ timePrec = k_PropVar_TimePrec_Unix;
+ if ((flags & NTimeRecord::NFlags::kUnixNs) != 0 && numStamps * 2 <= size)
+ {
+ const UInt32 ns = Get32(p + numStamps) & 0x3FFFFFFF;
+ if (ns < 1000000000)
+ {
+ val += ns / 100;
+ ns100 = (unsigned)(ns % 100);
+ timePrec = k_PropVar_TimePrec_1ns;
+ }
+ }
+ ft.dwLowDateTime = (DWORD)val;
+ ft.dwHighDateTime = (DWORD)(val >> 32);
+ }
+ else
+ {
+ curStamp *= 8;
+ if (curStamp + 8 > size)
+ return;
+ p += curStamp;
+ ft.dwLowDateTime = Get32(p);
+ ft.dwHighDateTime = Get32(p + 4);
+ }
+
+ prop.SetAsTimeFrom_FT_Prec_Ns100(ft, timePrec, ns100);
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+
+ NCOM::CPropVariant prop;
+ const CRefItem &ref = _refs[index];
+ const CItem &item = _items[ref.Item];
+ const CItem &lastItem = _items[ref.Last];
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString unicodeName;
+
+ if (item.Is_STM())
+ {
+ AString s;
+ if (ref.Parent >= 0)
+ {
+ const CItem &mainItem = _items[_refs[ref.Parent].Item];
+ s = mainItem.Name;
+ }
+
+ AString name;
+ item.GetAltStreamName(name);
+ if (name[0] != ':')
+ s += ':';
+ s += name;
+ ConvertUTF8ToUnicode(s, unicodeName);
+ }
+ else
+ {
+ ConvertUTF8ToUnicode(item.Name, unicodeName);
+
+ if (item.Version_Defined)
+ {
+ char temp[32];
+ // temp[0] = ';';
+ // ConvertUInt64ToString(item.Version, temp + 1);
+ // unicodeName += temp;
+ ConvertUInt64ToString(item.Version, temp);
+ UString s2 ("[VER]" STRING_PATH_SEPARATOR);
+ s2 += temp;
+ s2.Add_PathSepar();
+ unicodeName.Insert(0, s2);
+ }
+ }
+
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(unicodeName);
+ prop = unicodeName;
+
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: if (!lastItem.Is_UnknownSize()) prop = lastItem.Size; break;
+ case kpidPackSize: prop = GetPackSize(index); break;
+
+ case kpidMTime:
+ {
+ TimeRecordToProp(item, NTimeRecord::k_Index_MTime, prop);
+ if (prop.vt == VT_EMPTY && item.Has_UnixMTime())
+ PropVariant_SetFrom_UnixTime(prop, item.UnixMTime);
+ if (prop.vt == VT_EMPTY && ref.Parent >= 0)
+ {
+ const CItem &baseItem = _items[_refs[ref.Parent].Item];
+ TimeRecordToProp(baseItem, NTimeRecord::k_Index_MTime, prop);
+ if (prop.vt == VT_EMPTY && baseItem.Has_UnixMTime())
+ PropVariant_SetFrom_UnixTime(prop, baseItem.UnixMTime);
+ }
+ break;
+ }
+ case kpidCTime: TimeRecordToProp(item, NTimeRecord::k_Index_CTime, prop); break;
+ case kpidATime: TimeRecordToProp(item, NTimeRecord::k_Index_ATime, prop); break;
+
+ case kpidName:
+ {
+ if (item.Is_STM())
+ {
+ AString name;
+ item.GetAltStreamName(name);
+ if (name[0] == ':')
+ {
+ name.DeleteFrontal(1);
+ UString unicodeName;
+ ConvertUTF8ToUnicode(name, unicodeName);
+ prop = unicodeName;
+ }
+ }
+ break;
+ }
+
+ case kpidIsAltStream: prop = item.Is_STM(); break;
+
+ case kpidSymLink: item.Link_to_Prop(NLinkType::kUnixSymLink, prop); break;
+ case kpidHardLink: item.Link_to_Prop(NLinkType::kHardLink, prop); break;
+ case kpidCopyLink: item.Link_to_Prop(NLinkType::kFileCopy, prop); break;
+
+ case kpidAttrib: prop = item.GetWinAttrib(); break;
+ case kpidEncrypted: prop = item.IsEncrypted(); break;
+ case kpidSolid: prop = item.IsSolid(); break;
+
+ case kpidSplitBefore: prop = item.IsSplitBefore(); break;
+ case kpidSplitAfter: prop = lastItem.IsSplitAfter(); break;
+
+ case kpidVolumeIndex:
+ {
+ if (item.VolIndex < _arcs.Size())
+ {
+ const CInArcInfo &arcInfo = _arcs[item.VolIndex].Info;
+ if (arcInfo.IsVolume())
+ prop = (UInt64)arcInfo.GetVolIndex();
+ }
+ break;
+ }
+
+ case kpidCRC:
+ {
+ const CItem *item2 = (lastItem.IsSplitAfter() ? &item : &lastItem);
+ if (item2->Has_CRC())
+ prop = item2->CRC;
+ break;
+ }
+
+ case kpidMethod:
+ {
+ char temp[128];
+ unsigned algo = item.GetAlgoVersion();
+ char *s = temp;
+ if (algo != 0)
+ {
+ ConvertUInt32ToString(algo, s);
+ s += MyStringLen(s);
+ *s++ = ':';
+ }
+ unsigned m = item.GetMethod();
+ {
+ s[0] = 'm';
+ s[1] = (char)(m + '0');
+ s[2] = 0;
+ if (!item.IsDir())
+ {
+ s[2] = ':';
+ ConvertUInt32ToString(item.GetDictSize() + 17, s + 3);
+ }
+ }
+
+ unsigned cryptoSize = 0;
+ int cryptoOffset = item.FindExtra(NExtraID::kCrypto, cryptoSize);
+ if (cryptoOffset >= 0)
+ {
+ s = temp + strlen(temp);
+ *s++ = ' ';
+
+ CCryptoInfo cryptoInfo;
+
+ bool isOK = cryptoInfo.Parse(item.Extra + (unsigned)cryptoOffset, cryptoSize);
+
+ if (cryptoInfo.Algo == 0)
+ s = MyStpCpy(s, "AES");
+ else
+ {
+ s = MyStpCpy(s, "Crypto_");
+ ConvertUInt64ToString(cryptoInfo.Algo, s);
+ s += strlen(s);
+ }
+
+ if (isOK)
+ {
+ *s++ = ':';
+ ConvertUInt32ToString(cryptoInfo.Cnt, s);
+ s += strlen(s);
+ *s++ = ':';
+ ConvertUInt64ToString(cryptoInfo.Flags, s);
+ }
+ }
+
+ prop = temp;
+ break;
+ }
+
+ case kpidCharacts:
+ {
+ AString s;
+
+ if (item.ACL >= 0)
+ {
+ s.Add_OptSpaced("ACL");
+ }
+
+ UInt32 flags = item.Flags;
+ // flags &= ~(6); // we don't need compression related bits here.
+
+ if (flags != 0)
+ {
+ AString s2 = FlagsToString(k_FileFlags, Z7_ARRAY_SIZE(k_FileFlags), flags);
+ if (!s2.IsEmpty())
+ {
+ s.Add_OptSpaced(s2);
+ }
+ }
+
+ item.PrintInfo(s);
+
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+
+ case kpidHostOS:
+ if (item.HostOS < Z7_ARRAY_SIZE(kHostOS))
+ prop = kHostOS[(size_t)item.HostOS];
+ else
+ prop = (UInt64)item.HostOS;
+ break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+
+// ---------- Copy Links ----------
+
+static int CompareItemsPaths(const CHandler &handler, unsigned p1, unsigned p2, const AString *name1)
+{
+ const CItem &item1 = handler._items[handler._refs[p1].Item];
+ const CItem &item2 = handler._items[handler._refs[p2].Item];
+
+ if (item1.Version_Defined)
+ {
+ if (!item2.Version_Defined)
+ return -1;
+ int res = MyCompare(item1.Version, item2.Version);
+ if (res != 0)
+ return res;
+ }
+ else if (item2.Version_Defined)
+ return 1;
+
+ if (!name1)
+ name1 = &item1.Name;
+ return strcmp(*name1, item2.Name);
+}
+
+static int CompareItemsPaths2(const CHandler &handler, unsigned p1, unsigned p2, const AString *name1)
+{
+ int res = CompareItemsPaths(handler, p1, p2, name1);
+ if (res != 0)
+ return res;
+ return MyCompare(p1, p2);
+}
+
+static int CompareItemsPaths_Sort(const unsigned *p1, const unsigned *p2, void *param)
+{
+ return CompareItemsPaths2(*(const CHandler *)param, *p1, *p2, NULL);
+}
+
+static int FindLink(const CHandler &handler, const CUIntVector &sorted,
+ const AString &s, unsigned index)
+{
+ unsigned left = 0, right = sorted.Size();
+ for (;;)
+ {
+ if (left == right)
+ {
+ if (left > 0)
+ {
+ const unsigned refIndex = sorted[left - 1];
+ if (CompareItemsPaths(handler, index, refIndex, &s) == 0)
+ return (int)refIndex;
+ }
+ if (right < sorted.Size())
+ {
+ const unsigned refIndex = sorted[right];
+ if (CompareItemsPaths(handler, index, refIndex, &s) == 0)
+ return (int)refIndex;
+ }
+ return -1;
+ }
+
+ const unsigned mid = (left + right) / 2;
+ const unsigned refIndex = sorted[mid];
+ const int compare = CompareItemsPaths2(handler, index, refIndex, &s);
+ if (compare == 0)
+ return (int)refIndex;
+ if (compare < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+}
+
+void CHandler::FillLinks()
+{
+ unsigned i;
+
+ for (i = 0; i < _refs.Size(); i++)
+ {
+ const CItem &item = _items[_refs[i].Item];
+ if (!item.IsDir() && !item.IsService() && item.NeedUse_as_CopyLink())
+ break;
+ }
+
+ if (i == _refs.Size())
+ return;
+
+ CUIntVector sorted;
+ for (i = 0; i < _refs.Size(); i++)
+ {
+ const CItem &item = _items[_refs[i].Item];
+ if (!item.IsDir() && !item.IsService())
+ sorted.Add(i);
+ }
+
+ if (sorted.IsEmpty())
+ return;
+
+ sorted.Sort(CompareItemsPaths_Sort, (void *)this);
+
+ AString link;
+
+ for (i = 0; i < _refs.Size(); i++)
+ {
+ CRefItem &ref = _refs[i];
+ const CItem &item = _items[ref.Item];
+ if (item.IsDir() || item.IsService() || item.PackSize != 0)
+ continue;
+ CLinkInfo linkInfo;
+ if (!item.FindExtra_Link(linkInfo) || linkInfo.Type != NLinkType::kFileCopy)
+ continue;
+ link.SetFrom_CalcLen((const char *)(item.Extra + linkInfo.NameOffset), linkInfo.NameLen);
+ int linkIndex = FindLink(*this, sorted, link, i);
+ if (linkIndex < 0)
+ continue;
+ if ((unsigned)linkIndex >= i)
+ continue; // we don't support forward links that can lead to loops
+ const CRefItem &linkRef = _refs[linkIndex];
+ const CItem &linkItem = _items[linkRef.Item];
+ if (linkItem.Size == item.Size)
+ {
+ if (linkRef.Link >= 0)
+ ref.Link = linkRef.Link;
+ else if (!linkItem.NeedUse_as_CopyLink())
+ ref.Link = linkIndex;
+ }
+ }
+}
+
+
+
+HRESULT CHandler::Open2(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback)
+{
+ CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+
+ NRar::CVolumeName seqName;
+
+ UInt64 totalBytes = 0;
+ UInt64 curBytes = 0;
+
+ if (openCallback)
+ {
+ openCallback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&openVolumeCallback);
+ openCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getTextPassword);
+ }
+
+ CTempBuf tempBuf;
+
+ CUnpacker unpacker;
+ unpacker.getTextPassword = getTextPassword;
+
+ int prevSplitFile = -1;
+ int prevMainFile = -1;
+
+ bool nextVol_is_Required = false;
+
+ CInArchive arch;
+
+ for (;;)
+ {
+ CMyComPtr<IInStream> inStream;
+
+ if (_arcs.IsEmpty())
+ inStream = stream;
+ else
+ {
+ if (!openVolumeCallback)
+ break;
+
+ if (_arcs.Size() == 1)
+ {
+ UString baseName;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
+ if (prop.vt != VT_BSTR)
+ break;
+ baseName = prop.bstrVal;
+ }
+ if (!seqName.InitName(baseName))
+ break;
+ }
+
+ const UString volName = seqName.GetNextName();
+
+ HRESULT result = openVolumeCallback->GetStream(volName, &inStream);
+
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ if (!inStream || result != S_OK)
+ {
+ if (nextVol_is_Required)
+ _missingVolName = volName;
+ break;
+ }
+ }
+
+ UInt64 endPos = 0;
+ RINOK(InStream_GetPos_GetSize(inStream, arch.StreamStartPosition, endPos))
+
+ if (openCallback)
+ {
+ totalBytes += endPos;
+ RINOK(openCallback->SetTotal(NULL, &totalBytes))
+ }
+
+ CInArcInfo arcInfoOpen;
+ {
+ HRESULT res = arch.Open(inStream, maxCheckStartPosition, getTextPassword, arcInfoOpen);
+ if (arch.IsArc && arch.UnexpectedEnd)
+ _errorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_arcs.IsEmpty())
+ {
+ _isArc = arch.IsArc;
+ }
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ if (_arcs.IsEmpty())
+ return res;
+ break;
+ }
+ }
+
+ CArc &arc = _arcs.AddNew();
+ CInArcInfo &arcInfo = arc.Info;
+ arcInfo = arcInfoOpen;
+ arc.Stream = inStream;
+
+ CItem item;
+
+ for (;;)
+ {
+ item.Clear();
+
+ arcInfo.EndPos = arch.Position;
+
+ if (arch.Position > endPos)
+ {
+ _errorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+ break;
+ }
+
+ RINOK(InStream_SeekSet(inStream, arch.Position))
+
+ {
+ CInArchive::CHeader h;
+ HRESULT res = arch.ReadBlockHeader(h);
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ if (arch.UnexpectedEnd)
+ {
+ _errorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+ if (arcInfo.EndPos < arch.Position)
+ arcInfo.EndPos = arch.Position;
+ if (arcInfo.EndPos < endPos)
+ arcInfo.EndPos = endPos;
+ }
+ else
+ _errorFlags |= kpv_ErrorFlags_HeadersError;
+ break;
+ }
+
+ if (h.Type == NHeaderType::kEndOfArc)
+ {
+ arcInfo.EndPos = arch.Position;
+ arcInfo.EndOfArchive_was_Read = true;
+ if (!arch.ReadVar(arcInfo.EndFlags))
+ _errorFlags |= kpv_ErrorFlags_HeadersError;
+ if (arcInfo.IsVolume())
+ {
+ // for multivolume archives RAR can add ZERO bytes at the end for alignment.
+ // We must skip these bytes to prevent phySize warning.
+ RINOK(InStream_SeekSet(inStream, arcInfo.EndPos))
+ bool areThereNonZeros;
+ UInt64 numZeros;
+ const UInt64 maxSize = 1 << 12;
+ RINOK(ReadZeroTail(inStream, areThereNonZeros, numZeros, maxSize))
+ if (!areThereNonZeros && numZeros != 0 && numZeros <= maxSize)
+ arcInfo.EndPos += numZeros;
+ }
+ break;
+ }
+
+ if (h.Type != NHeaderType::kFile &&
+ h.Type != NHeaderType::kService)
+ {
+ _errorFlags |= kpv_ErrorFlags_UnsupportedFeature;
+ break;
+ }
+
+ item.RecordType = (Byte)h.Type;
+
+ if (!arch.ReadFileHeader(h, item))
+ {
+ _errorFlags |= kpv_ErrorFlags_HeadersError;
+ break;
+ }
+
+ // item.MainPartSize = (UInt32)(Position - item.Position);
+ item.DataPos = arch.Position;
+ }
+
+ bool isOk_packSize = true;
+ {
+ arcInfo.EndPos = arch.Position;
+ if (arch.Position + item.PackSize < arch.Position)
+ {
+ isOk_packSize = false;
+ _errorFlags |= kpv_ErrorFlags_HeadersError;
+ if (arcInfo.EndPos < endPos)
+ arcInfo.EndPos = endPos;
+ }
+ else
+ {
+ arch.AddToSeekValue(item.PackSize); // Position points to next header;
+ arcInfo.EndPos = arch.Position;
+ }
+ }
+
+ bool needAdd = true;
+
+ {
+ if (_comment.Size() == 0
+ && item.Is_CMT()
+ && item.PackSize < kCommentSize_Max
+ && item.PackSize == item.Size
+ && item.PackSize != 0
+ && item.GetMethod() == 0
+ && !item.IsSplit())
+ {
+ RINOK(unpacker.DecodeToBuf(EXTERNAL_CODECS_VARS item, item.PackSize, inStream, _comment))
+ needAdd = false;
+ }
+ }
+
+ if (needAdd)
+ {
+ CRefItem ref;
+ ref.Item = _items.Size();
+ ref.Last = ref.Item;
+ ref.Parent = -1;
+ ref.Link = -1;
+
+ if (item.IsService())
+ {
+ if (item.Is_STM())
+ {
+ if (prevMainFile >= 0)
+ ref.Parent = prevMainFile;
+ }
+ else
+ {
+ needAdd = false;
+ if (item.Is_ACL() && (!item.IsEncrypted() || arch.m_CryptoMode))
+ {
+ if (prevMainFile >= 0 && item.Size < (1 << 24) && item.Size != 0)
+ {
+ CItem &mainItem = _items[_refs[prevMainFile].Item];
+
+ if (mainItem.ACL < 0)
+ {
+ CByteBuffer acl;
+ HRESULT res = tempBuf.Decode(EXTERNAL_CODECS_VARS item, inStream, unpacker, acl);
+ if (!item.IsSplitAfter())
+ tempBuf.Clear();
+ if (res != S_OK)
+ {
+ tempBuf.Clear();
+ if (res != S_FALSE && res != E_NOTIMPL)
+ return res;
+ }
+ // RINOK();
+
+ if (res == S_OK && acl.Size() != 0)
+ {
+ if (_acls.IsEmpty() || acl != _acls.Back())
+ _acls.Add(acl);
+ mainItem.ACL = (int)_acls.Size() - 1;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (needAdd)
+ {
+ if (item.IsSplitBefore())
+ {
+ if (prevSplitFile >= 0)
+ {
+ CRefItem &ref2 = _refs[prevSplitFile];
+ CItem &prevItem = _items[ref2.Last];
+ if (item.IsNextForItem(prevItem))
+ {
+ ref2.Last = _items.Size();
+ prevItem.NextItem = (int)ref2.Last;
+ needAdd = false;
+ }
+ }
+ }
+ }
+
+ if (needAdd)
+ {
+ if (item.IsSplitAfter())
+ prevSplitFile = (int)_refs.Size();
+ if (!item.IsService())
+ prevMainFile = (int)_refs.Size();
+ _refs.Add(ref);
+ }
+ }
+
+ {
+ UInt64 version;
+ if (item.FindExtra_Version(version))
+ {
+ item.Version_Defined = true;
+ item.Version = version;
+ }
+ }
+
+ item.VolIndex = _arcs.Size() - 1;
+ _items.Add(item);
+
+ if (openCallback && (_items.Size() & 0xFF) == 0)
+ {
+ UInt64 numFiles = _items.Size();
+ UInt64 numBytes = curBytes + item.DataPos;
+ RINOK(openCallback->SetCompleted(&numFiles, &numBytes))
+ }
+
+ if (!isOk_packSize)
+ break;
+ }
+
+ curBytes += endPos;
+
+ nextVol_is_Required = false;
+
+ if (!arcInfo.IsVolume())
+ break;
+
+ if (arcInfo.EndOfArchive_was_Read)
+ {
+ if (!arcInfo.AreMoreVolumes())
+ break;
+ nextVol_is_Required = true;
+ }
+ }
+
+ FillLinks();
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback))
+{
+ COM_TRY_BEGIN
+ Close();
+ return Open2(stream, maxCheckStartPosition, openCallback);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ COM_TRY_BEGIN
+ _missingVolName.Empty();
+ _errorFlags = 0;
+ // _warningFlags = 0;
+ _isArc = false;
+ _refs.Clear();
+ _items.Clear();
+ _arcs.Clear();
+ _acls.Clear();
+ _comment.Free();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CVolsInStream
+ , ISequentialInStream
+)
+ UInt64 _rem;
+ ISequentialInStream *_stream;
+ const CObjectVector<CArc> *_arcs;
+ const CObjectVector<CItem> *_items;
+ int _itemIndex;
+public:
+ bool CrcIsOK;
+private:
+ CHash _hash;
+public:
+ void Init(const CObjectVector<CArc> *arcs,
+ const CObjectVector<CItem> *items,
+ unsigned itemIndex)
+ {
+ _arcs = arcs;
+ _items = items;
+ _itemIndex = (int)itemIndex;
+ _stream = NULL;
+ CrcIsOK = true;
+ }
+};
+
+Z7_COM7F_IMF(CVolsInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ UInt32 realProcessedSize = 0;
+
+ while (size != 0)
+ {
+ if (!_stream)
+ {
+ if (_itemIndex < 0)
+ break;
+ const CItem &item = (*_items)[_itemIndex];
+ IInStream *s = (*_arcs)[item.VolIndex].Stream;
+ RINOK(InStream_SeekSet(s, item.GetDataPosition()))
+ _stream = s;
+ if (CrcIsOK && item.IsSplitAfter())
+ _hash.Init(item);
+ else
+ _hash.Init_NoCalc();
+ _rem = item.PackSize;
+ }
+ {
+ UInt32 cur = size;
+ if (cur > _rem)
+ cur = (UInt32)_rem;
+ UInt32 num = cur;
+ HRESULT res = _stream->Read(data, cur, &cur);
+ _hash.Update(data, cur);
+ realProcessedSize += cur;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ data = (Byte *)data + cur;
+ size -= cur;
+ _rem -= cur;
+ if (_rem == 0)
+ {
+ const CItem &item = (*_items)[_itemIndex];
+ _itemIndex = item.NextItem;
+ if (!_hash.Check(item, NULL)) // RAR doesn't use MAC here
+ CrcIsOK = false;
+ _stream = NULL;
+ }
+ if (res != S_OK)
+ return res;
+ if (realProcessedSize != 0)
+ return S_OK;
+ if (cur == 0 && num != 0)
+ return S_OK;
+ }
+ }
+
+ return S_OK;
+}
+
+
+static int FindLinkBuf(CObjectVector<CLinkFile> &linkFiles, unsigned index)
+{
+ unsigned left = 0, right = linkFiles.Size();
+ for (;;)
+ {
+ if (left == right)
+ return -1;
+ const unsigned mid = (left + right) / 2;
+ const unsigned linkIndex = linkFiles[mid].Index;
+ if (index == linkIndex)
+ return (int)mid;
+ if (index < linkIndex)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+}
+
+
+static inline int DecoderRes_to_OpRes(HRESULT res, bool crcOK)
+{
+ if (res == E_NOTIMPL)
+ return NExtract::NOperationResult::kUnsupportedMethod;
+ // if (res == S_FALSE)
+ if (res != S_OK)
+ return NExtract::NOperationResult::kDataError;
+ return crcOK ?
+ NExtract::NOperationResult::kOK :
+ NExtract::NOperationResult::kCRCError;
+}
+
+
+static HRESULT CopyData_with_Progress(const Byte *data, size_t size,
+ ISequentialOutStream *outStream, ICompressProgressInfo *progress)
+{
+ size_t pos = 0;
+
+ while (pos < size)
+ {
+ const UInt32 kStepSize = ((UInt32)1 << 24);
+ UInt32 cur32;
+ {
+ size_t cur = size - pos;
+ if (cur > kStepSize)
+ cur = kStepSize;
+ cur32 = (UInt32)cur;
+ }
+ RINOK(outStream->Write(data + pos, cur32, &cur32))
+ if (cur32 == 0)
+ return E_FAIL;
+ pos += cur32;
+ if (progress)
+ {
+ UInt64 pos64 = pos;
+ RINOK(progress->SetRatioInfo(&pos64, &pos64))
+ }
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _refs.Size();
+ if (numItems == 0)
+ return S_OK;
+
+ CByteArr extractStatuses(_refs.Size());
+ memset(extractStatuses, 0, _refs.Size());
+
+ // we don't want to use temp buffer for big link files.
+ const size_t k_CopyLinkFile_MaxSize = (size_t)1 << (28 + sizeof(size_t) / 2);
+
+ const Byte kStatus_Extract = 1 << 0;
+ const Byte kStatus_Skip = 1 << 1;
+ const Byte kStatus_Link = 1 << 2;
+
+ /*
+ In original RAR:
+ 1) service streams are not allowed to be solid,
+ and solid flag must be ignored for service streams.
+ 2) If RAR creates new solid block and first file in solid block is Link file,
+ then it can clear solid flag for Link file and
+ clear solid flag for first non-Link file after Link file.
+ */
+
+ CObjectVector<CLinkFile> linkFiles;
+
+ {
+ UInt64 total = 0;
+ bool isThereUndefinedSize = false;
+ bool thereAreLinks = false;
+
+ {
+ unsigned solidLimit = 0;
+ for (UInt32 t = 0; t < numItems; t++)
+ {
+ unsigned index = allFilesMode ? t : indices[t];
+ const CRefItem &ref = _refs[index];
+ const CItem &item = _items[ref.Item];
+ const CItem &lastItem = _items[ref.Last];
+
+ extractStatuses[index] |= kStatus_Extract;
+
+ if (!lastItem.Is_UnknownSize())
+ total += lastItem.Size;
+ else
+ isThereUndefinedSize = true;
+
+ if (ref.Link >= 0)
+ {
+ // 18.06 fixed: we use links for Test mode too
+ // if (!testMode)
+ {
+ if ((unsigned)ref.Link < index)
+ {
+ const CRefItem &linkRef = _refs[(unsigned)ref.Link];
+ const CItem &linkItem = _items[linkRef.Item];
+ if (linkItem.IsSolid())
+ if (testMode || linkItem.Size <= k_CopyLinkFile_MaxSize)
+ {
+ if (extractStatuses[(unsigned)ref.Link] == 0)
+ {
+ const CItem &lastLinkItem = _items[linkRef.Last];
+ if (!lastLinkItem.Is_UnknownSize())
+ total += lastLinkItem.Size;
+ else
+ isThereUndefinedSize = true;
+ }
+ extractStatuses[(unsigned)ref.Link] |= kStatus_Link;
+ thereAreLinks = true;
+ }
+ }
+ }
+ continue;
+ }
+
+ if (item.IsService())
+ continue;
+
+ if (item.IsSolid())
+ {
+ unsigned j = index;
+
+ while (j > solidLimit)
+ {
+ j--;
+ const CRefItem &ref2 = _refs[j];
+ const CItem &item2 = _items[ref2.Item];
+ if (!item2.IsService())
+ {
+ if (extractStatuses[j] == 0)
+ {
+ const CItem &lastItem2 = _items[ref2.Last];
+ if (!lastItem2.Is_UnknownSize())
+ total += lastItem2.Size;
+ else
+ isThereUndefinedSize = true;
+ }
+ extractStatuses[j] |= kStatus_Skip;
+ if (!item2.IsSolid())
+ break;
+ }
+ }
+ }
+
+ solidLimit = index + 1;
+ }
+ }
+
+ if (thereAreLinks)
+ {
+ unsigned solidLimit = 0;
+
+ FOR_VECTOR (i, _refs)
+ {
+ if ((extractStatuses[i] & kStatus_Link) == 0)
+ continue;
+
+ // We use CLinkFile for testMode too.
+ // So we can show errors for copy files.
+ // if (!testMode)
+ {
+ CLinkFile &linkFile = linkFiles.AddNew();
+ linkFile.Index = i;
+ }
+
+ const CItem &item = _items[_refs[i].Item];
+ /*
+ if (item.IsService())
+ continue;
+ */
+
+ if (item.IsSolid())
+ {
+ unsigned j = i;
+
+ while (j > solidLimit)
+ {
+ j--;
+ const CRefItem &ref2 = _refs[j];
+ const CItem &item2 = _items[ref2.Item];
+ if (!item2.IsService())
+ {
+ if (extractStatuses[j] != 0)
+ break;
+ extractStatuses[j] = kStatus_Skip;
+ {
+ const CItem &lastItem2 = _items[ref2.Last];
+ if (!lastItem2.Is_UnknownSize())
+ total += lastItem2.Size;
+ else
+ isThereUndefinedSize = true;
+ }
+ if (!item2.IsSolid())
+ break;
+ }
+ }
+ }
+
+ solidLimit = i + 1;
+ }
+
+ if (!testMode)
+ for (UInt32 t = 0; t < numItems; t++)
+ {
+ unsigned index = allFilesMode ? t : indices[t];
+ const CRefItem &ref = _refs[index];
+
+ int linkIndex = ref.Link;
+ if (linkIndex < 0 || (unsigned)linkIndex >= index)
+ continue;
+ const CItem &linkItem = _items[_refs[(unsigned)linkIndex].Item];
+ if (!linkItem.IsSolid() || linkItem.Size > k_CopyLinkFile_MaxSize)
+ continue;
+ const int bufIndex = FindLinkBuf(linkFiles, (unsigned)linkIndex);
+ if (bufIndex < 0)
+ return E_FAIL;
+ linkFiles[bufIndex].NumLinks++;
+ }
+ }
+
+ if (total != 0 || !isThereUndefinedSize)
+ {
+ RINOK(extractCallback->SetTotal(total))
+ }
+ }
+
+
+ UInt64 totalUnpacked = 0;
+ UInt64 totalPacked = 0;
+ UInt64 curUnpackSize = 0;
+ UInt64 curPackSize = 0;
+
+ CUnpacker unpacker;
+
+ CVolsInStream *volsInStreamSpec = new CVolsInStream;
+ CMyComPtr<ISequentialInStream> volsInStream = volsInStreamSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ // bool needClearSolid = true;
+
+ FOR_VECTOR (i, _refs)
+ {
+ if (extractStatuses[i] == 0)
+ continue;
+
+ totalUnpacked += curUnpackSize;
+ totalPacked += curPackSize;
+ lps->InSize = totalPacked;
+ lps->OutSize = totalUnpacked;
+ RINOK(lps->SetCur())
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+
+ // isExtract means that we don't skip that item. So we need read data.
+
+ bool isExtract = ((extractStatuses[i] & kStatus_Extract) != 0);
+ Int32 askMode =
+ isExtract ? (testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract) :
+ NExtract::NAskMode::kSkip;
+
+ unpacker.linkFile = NULL;
+
+ // if (!testMode)
+ if ((extractStatuses[i] & kStatus_Link) != 0)
+ {
+ int bufIndex = FindLinkBuf(linkFiles, i);
+ if (bufIndex < 0)
+ return E_FAIL;
+ unpacker.linkFile = &linkFiles[bufIndex];
+ }
+
+ UInt32 index = i;
+
+ const CRefItem *ref = &_refs[index];
+ const CItem *item = &_items[ref->Item];
+ const CItem &lastItem = _items[ref->Last];
+
+ curUnpackSize = 0;
+ if (!lastItem.Is_UnknownSize())
+ curUnpackSize = lastItem.Size;
+
+ curPackSize = GetPackSize(index);
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ bool isSolid = false;
+ if (!item->IsService())
+ {
+ if (item->IsSolid())
+ isSolid = unpacker.SolidAllowed;
+ unpacker.SolidAllowed = isSolid;
+ }
+
+ if (item->IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ int index2 = ref->Link;
+
+ int bufIndex = -1;
+
+ if (index2 >= 0)
+ {
+ const CRefItem &ref2 = _refs[index2];
+ const CItem &item2 = _items[ref2.Item];
+ const CItem &lastItem2 = _items[ref2.Last];
+ if (!item2.IsSolid())
+ {
+ item = &item2;
+ ref = &ref2;
+ if (!lastItem2.Is_UnknownSize())
+ curUnpackSize = lastItem2.Size;
+ else
+ curUnpackSize = 0;
+ curPackSize = GetPackSize((unsigned)index2);
+ }
+ else
+ {
+ if ((unsigned)index2 < index)
+ bufIndex = FindLinkBuf(linkFiles, (unsigned)index2);
+ }
+ }
+
+ bool needCallback = true;
+
+ if (!realOutStream)
+ {
+ if (testMode)
+ {
+ if (item->NeedUse_as_CopyLink_or_HardLink())
+ {
+ Int32 opRes = NExtract::NOperationResult::kOK;
+ if (bufIndex >= 0)
+ {
+ const CLinkFile &linkFile = linkFiles[bufIndex];
+ opRes = DecoderRes_to_OpRes(linkFile.Res, linkFile.crcOK);
+ }
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(opRes))
+ continue;
+ }
+ }
+ else
+ {
+ if (item->IsService())
+ continue;
+
+ needCallback = false;
+
+ if (!item->NeedUse_as_HardLink())
+ if (index2 < 0)
+
+ for (unsigned n = i + 1; n < _refs.Size(); n++)
+ {
+ const CItem &nextItem = _items[_refs[n].Item];
+ if (nextItem.IsService())
+ continue;
+ if (!nextItem.IsSolid())
+ break;
+ if (extractStatuses[i] != 0)
+ {
+ needCallback = true;
+ break;
+ }
+ }
+
+ askMode = NExtract::NAskMode::kSkip;
+ }
+ }
+
+ if (needCallback)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ }
+
+ if (bufIndex >= 0)
+ {
+ CLinkFile &linkFile = linkFiles[bufIndex];
+
+ if (isExtract)
+ {
+ if (linkFile.NumLinks == 0)
+ return E_FAIL;
+
+ if (needCallback)
+ if (realOutStream)
+ {
+ RINOK(CopyData_with_Progress(linkFile.Data, linkFile.Data.Size(), realOutStream, progress))
+ }
+
+ if (--linkFile.NumLinks == 0)
+ linkFile.Data.Free();
+ }
+
+ if (needCallback)
+ {
+ RINOK(extractCallback->SetOperationResult(DecoderRes_to_OpRes(linkFile.Res, linkFile.crcOK)))
+ }
+ continue;
+ }
+
+ if (!needCallback)
+ continue;
+
+ if (item->NeedUse_as_CopyLink())
+ {
+ int opRes = realOutStream ?
+ NExtract::NOperationResult::kUnsupportedMethod:
+ NExtract::NOperationResult::kOK;
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ continue;
+ }
+
+ volsInStreamSpec->Init(&_arcs, &_items, ref->Item);
+
+ UInt64 packSize = curPackSize;
+
+ if (item->IsEncrypted())
+ if (!unpacker.getTextPassword)
+ extractCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&unpacker.getTextPassword);
+
+ bool wrongPassword;
+ HRESULT result = unpacker.Create(EXTERNAL_CODECS_VARS *item, isSolid, wrongPassword);
+
+ if (wrongPassword)
+ {
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kWrongPassword))
+ continue;
+ }
+
+ bool crcOK = true;
+ if (result == S_OK)
+ result = unpacker.Code(*item, _items[ref->Last], packSize, volsInStream, realOutStream, progress, crcOK);
+ realOutStream.Release();
+ if (!volsInStreamSpec->CrcIsOK)
+ crcOK = false;
+
+ int opRes = crcOK ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kCRCError;
+
+ if (result != S_OK)
+ {
+ if (result == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (result == E_NOTIMPL)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ return result;
+ }
+
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ {
+ FOR_VECTOR (i, linkFiles)
+ if (linkFiles[i].NumLinks != 0)
+ return E_FAIL;
+ }
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+IMPL_ISetCompressCodecsInfo
+
+REGISTER_ARC_I(
+ "Rar5", "rar r00", NULL, 0xCC,
+ kMarker,
+ 0,
+ NArcInfoFlags::kFindSignature,
+ NULL)
+
+}}
+
+
+Z7_CLASS_IMP_COM_1(
+ CBlake2spHasher
+ , IHasher
+)
+ CBlake2sp _blake;
+public:
+ Byte _mtDummy[1 << 7]; // it's public to eliminate clang warning: unused private field
+ CBlake2spHasher() { Init(); }
+};
+
+Z7_COM7F_IMF2(void, CBlake2spHasher::Init())
+{
+ Blake2sp_Init(&_blake);
+}
+
+Z7_COM7F_IMF2(void, CBlake2spHasher::Update(const void *data, UInt32 size))
+{
+ Blake2sp_Update(&_blake, (const Byte *)data, size);
+}
+
+Z7_COM7F_IMF2(void, CBlake2spHasher::Final(Byte *digest))
+{
+ Blake2sp_Final(&_blake, digest);
+}
+
+REGISTER_HASHER(CBlake2spHasher, 0x202, "BLAKE2sp", BLAKE2S_DIGEST_SIZE)
diff --git a/CPP/7zip/Archive/Rar/Rar5Handler.h b/CPP/7zip/Archive/Rar/Rar5Handler.h
new file mode 100644
index 0000000..72e1efc
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/Rar5Handler.h
@@ -0,0 +1,419 @@
+// Rar5Handler.h
+
+#ifndef ZIP7_INC_RAR5_HANDLER_H
+#define ZIP7_INC_RAR5_HANDLER_H
+
+#include "../../../../C/Blake2.h"
+
+#include "../../../Common/MyBuffer.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Common/CreateCoder.h"
+
+#include "../IArchive.h"
+
+namespace NArchive {
+namespace NRar5 {
+
+namespace NHeaderFlags
+{
+ const unsigned kExtra = 1 << 0;
+ const unsigned kData = 1 << 1;
+ // const unsigned kUnknown = 1 << 2;
+ const unsigned kPrevVol = 1 << 3;
+ const unsigned kNextVol = 1 << 4;
+ // const unsigned kIsChild = 1 << 5;
+ // const unsigned kPreserveChild = 1 << 6;
+}
+
+namespace NHeaderType
+{
+ enum
+ {
+ kArc = 1,
+ kFile,
+ kService,
+ kArcEncrypt,
+ kEndOfArc
+ };
+}
+
+namespace NArcFlags
+{
+ const unsigned kVol = 1 << 0;
+ const unsigned kVolNumber = 1 << 1;
+ const unsigned kSolid = 1 << 2;
+ // const unsigned kRecovery = 1 << 3;
+ // const unsigned kLocked = 1 << 4;
+}
+
+const unsigned kArcExtraRecordType_Locator = 1;
+
+namespace NLocatorFlags
+{
+ const unsigned kQuickOpen = 1 << 0;
+ const unsigned kRecovery = 1 << 1;
+}
+
+namespace NFileFlags
+{
+ const unsigned kIsDir = 1 << 0;
+ const unsigned kUnixTime = 1 << 1;
+ const unsigned kCrc32 = 1 << 2;
+ const unsigned kUnknownSize = 1 << 3;
+}
+
+namespace NMethodFlags
+{
+ // const unsigned kVersionMask = 0x3F;
+ const unsigned kSolid = 1 << 6;
+}
+
+namespace NArcEndFlags
+{
+ const unsigned kMoreVols = 1 << 0;
+}
+
+enum EHostOS
+{
+ kHost_Windows = 0,
+ kHost_Unix
+};
+
+
+
+// ---------- Extra ----------
+
+namespace NExtraID
+{
+ enum
+ {
+ kCrypto = 1,
+ kHash,
+ kTime,
+ kVersion,
+ kLink,
+ kUnixOwner,
+ kSubdata
+ };
+}
+
+const unsigned kCryptoAlgo_AES = 0;
+
+namespace NCryptoFlags
+{
+ const unsigned kPswCheck = 1 << 0;
+ const unsigned kUseMAC = 1 << 1;
+}
+
+struct CCryptoInfo
+{
+ UInt64 Algo;
+ UInt64 Flags;
+ Byte Cnt;
+
+ bool UseMAC() const { return (Flags & NCryptoFlags::kUseMAC) != 0; }
+ bool IsThereCheck() const { return (Flags & NCryptoFlags::kPswCheck) != 0; }
+ bool Parse(const Byte *p, size_t size);
+};
+
+const unsigned kHashID_Blake2sp = 0;
+
+namespace NTimeRecord
+{
+ enum
+ {
+ k_Index_MTime = 0,
+ k_Index_CTime,
+ k_Index_ATime
+ };
+
+ namespace NFlags
+ {
+ const unsigned kUnixTime = 1 << 0;
+ const unsigned kMTime = 1 << 1;
+ const unsigned kCTime = 1 << 2;
+ const unsigned kATime = 1 << 3;
+ const unsigned kUnixNs = 1 << 4;
+ }
+}
+
+namespace NLinkType
+{
+ enum
+ {
+ kUnixSymLink = 1,
+ kWinSymLink,
+ kWinJunction,
+ kHardLink,
+ kFileCopy
+ };
+}
+
+namespace NLinkFlags
+{
+ const unsigned kTargetIsDir = 1 << 0;
+}
+
+
+struct CLinkInfo
+{
+ UInt64 Type;
+ UInt64 Flags;
+ unsigned NameOffset;
+ unsigned NameLen;
+
+ bool Parse(const Byte *p, unsigned size);
+};
+
+
+struct CItem
+{
+ UInt32 CommonFlags;
+ UInt32 Flags;
+
+ Byte RecordType;
+ bool Version_Defined;
+
+ int ACL;
+
+ AString Name;
+
+ unsigned VolIndex;
+ int NextItem;
+
+ UInt32 UnixMTime;
+ UInt32 CRC;
+ UInt32 Attrib;
+ UInt32 Method;
+
+ CByteBuffer Extra;
+
+ UInt64 Size;
+ UInt64 PackSize;
+ UInt64 HostOS;
+
+ UInt64 DataPos;
+ UInt64 Version;
+
+ CItem() { Clear(); }
+
+ void Clear()
+ {
+ CommonFlags = 0;
+ Flags = 0;
+
+ VolIndex = 0;
+ NextItem = -1;
+
+ Version_Defined = false;
+ Version = 0;
+
+ Name.Empty();
+ Extra.Free();
+ ACL = -1;
+ }
+
+ bool IsSplitBefore() const { return (CommonFlags & NHeaderFlags::kPrevVol) != 0; }
+ bool IsSplitAfter() const { return (CommonFlags & NHeaderFlags::kNextVol) != 0; }
+ bool IsSplit() const { return (CommonFlags & (NHeaderFlags::kPrevVol | NHeaderFlags::kNextVol)) != 0; }
+
+ bool IsDir() const { return (Flags & NFileFlags::kIsDir) != 0; }
+ bool Has_UnixMTime() const { return (Flags & NFileFlags::kUnixTime) != 0; }
+ bool Has_CRC() const { return (Flags & NFileFlags::kCrc32) != 0; }
+ bool Is_UnknownSize() const { return (Flags & NFileFlags::kUnknownSize) != 0; }
+
+ bool IsNextForItem(const CItem &prev) const
+ {
+ return !IsDir() && !prev.IsDir() && IsSplitBefore() && prev.IsSplitAfter() && (Name == prev.Name);
+ // && false;
+ }
+
+ bool IsSolid() const { return ((UInt32)Method & NMethodFlags::kSolid) != 0; }
+ unsigned GetAlgoVersion() const { return (unsigned)Method & 0x3F; }
+ unsigned GetMethod() const { return ((unsigned)Method >> 7) & 0x7; }
+ UInt32 GetDictSize() const { return (((UInt32)Method >> 10) & 0xF); }
+
+ bool IsService() const { return RecordType == NHeaderType::kService; }
+
+ bool Is_STM() const { return IsService() && Name == "STM"; }
+ bool Is_CMT() const { return IsService() && Name == "CMT"; }
+ bool Is_ACL() const { return IsService() && Name == "ACL"; }
+ // bool Is_QO() const { return IsService() && Name == "QO"; }
+
+ int FindExtra(unsigned extraID, unsigned &recordDataSize) const;
+ void PrintInfo(AString &s) const;
+
+
+ bool IsEncrypted() const
+ {
+ unsigned size;
+ return FindExtra(NExtraID::kCrypto, size) >= 0;
+ }
+
+ int FindExtra_Blake() const
+ {
+ unsigned size = 0;
+ int offset = FindExtra(NExtraID::kHash, size);
+ if (offset >= 0
+ && size == BLAKE2S_DIGEST_SIZE + 1
+ && Extra[(unsigned)offset] == kHashID_Blake2sp)
+ return offset + 1;
+ return -1;
+ }
+
+ bool FindExtra_Version(UInt64 &version) const;
+
+ bool FindExtra_Link(CLinkInfo &link) const;
+ void Link_to_Prop(unsigned linkType, NWindows::NCOM::CPropVariant &prop) const;
+ bool Is_CopyLink() const;
+ bool Is_HardLink() const;
+ bool Is_CopyLink_or_HardLink() const;
+
+ bool NeedUse_as_CopyLink() const { return PackSize == 0 && Is_CopyLink(); }
+ bool NeedUse_as_HardLink() const { return PackSize == 0 && Is_HardLink(); }
+ bool NeedUse_as_CopyLink_or_HardLink() const { return PackSize == 0 && Is_CopyLink_or_HardLink(); }
+
+ bool GetAltStreamName(AString &name) const;
+
+ UInt32 GetWinAttrib() const
+ {
+ UInt32 a;
+ switch (HostOS)
+ {
+ case kHost_Windows: a = Attrib; break;
+ case kHost_Unix: a = (Attrib << 16); break;
+ default: a = 0;
+ }
+ // if (IsDir()) a |= FILE_ATTRIBUTE_DIRECTORY;
+ return a;
+ }
+
+ UInt64 GetDataPosition() const { return DataPos; }
+};
+
+
+struct CInArcInfo
+{
+ UInt64 Flags;
+ UInt64 VolNumber;
+ UInt64 StartPos;
+ UInt64 EndPos;
+
+ UInt64 EndFlags;
+ bool EndOfArchive_was_Read;
+
+ bool IsEncrypted;
+
+ // CByteBuffer Extra;
+
+ /*
+ struct CLocator
+ {
+ UInt64 Flags;
+ UInt64 QuickOpen;
+ UInt64 Recovery;
+
+ bool Is_QuickOpen() const { return (Flags & NLocatorFlags::kQuickOpen) != 0; }
+ bool Is_Recovery() const { return (Flags & NLocatorFlags::kRecovery) != 0; }
+ };
+
+ int FindExtra(unsigned extraID, unsigned &recordDataSize) const;
+ bool FindExtra_Locator(CLocator &locator) const;
+ */
+
+ CInArcInfo():
+ Flags(0),
+ VolNumber(0),
+ StartPos(0),
+ EndPos(0),
+ EndFlags(0),
+ EndOfArchive_was_Read(false),
+ IsEncrypted(false)
+ {}
+
+ /*
+ void Clear()
+ {
+ Flags = 0;
+ VolNumber = 0;
+ StartPos = 0;
+ EndPos = 0;
+ EndFlags = 0;
+ EndOfArchive_was_Read = false;
+ Extra.Free();
+ }
+ */
+
+ UInt64 GetPhySize() const { return EndPos - StartPos; }
+
+ bool AreMoreVolumes() const { return (EndFlags & NArcEndFlags::kMoreVols) != 0; }
+
+ bool IsVolume() const { return (Flags & NArcFlags::kVol) != 0; }
+ bool IsSolid() const { return (Flags & NArcFlags::kSolid) != 0; }
+ bool Is_VolNumber_Defined() const { return (Flags & NArcFlags::kVolNumber) != 0; }
+
+ UInt64 GetVolIndex() const { return Is_VolNumber_Defined() ? VolNumber : 0; }
+};
+
+
+struct CRefItem
+{
+ unsigned Item;
+ unsigned Last;
+ int Parent;
+ int Link;
+};
+
+
+struct CArc
+{
+ CMyComPtr<IInStream> Stream;
+ CInArcInfo Info;
+};
+
+
+class CHandler Z7_final:
+ public IInArchive,
+ public IArchiveGetRawProps,
+ Z7_PUBLIC_ISetCompressCodecsInfo_IFEC
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IInArchive)
+ Z7_COM_QI_ENTRY(IArchiveGetRawProps)
+ Z7_COM_QI_ENTRY_ISetCompressCodecsInfo_IFEC
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IInArchive)
+ Z7_IFACE_COM7_IMP(IArchiveGetRawProps)
+ DECL_ISetCompressCodecsInfo
+
+public:
+ CRecordVector<CRefItem> _refs;
+ CObjectVector<CItem> _items;
+private:
+ CObjectVector<CArc> _arcs;
+ CObjectVector<CByteBuffer> _acls;
+
+ UInt32 _errorFlags;
+ // UInt32 _warningFlags;
+ bool _isArc;
+ CByteBuffer _comment;
+ UString _missingVolName;
+
+ DECL_EXTERNAL_CODECS_VARS
+
+ UInt64 GetPackSize(unsigned refIndex) const;
+
+ void FillLinks();
+
+ HRESULT Open2(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Rar/RarHandler.cpp b/CPP/7zip/Archive/Rar/RarHandler.cpp
new file mode 100644
index 0000000..9157acc
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/RarHandler.cpp
@@ -0,0 +1,1782 @@
+// RarHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer2.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/PropVariantUtils.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../IPassword.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/FilterCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/MethodId.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/RegisterArc.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../../Crypto/Rar20Crypto.h"
+#include "../../Crypto/RarAes.h"
+
+#include "../Common/FindSignature.h"
+#include "../Common/ItemNameUtils.h"
+#include "../Common/OutStreamWithCRC.h"
+
+#include "../HandlerCont.h"
+
+#include "RarVol.h"
+#include "RarHandler.h"
+
+using namespace NWindows;
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+namespace NArchive {
+namespace NRar {
+
+static const Byte kMarker[NHeader::kMarkerSize] =
+ { 0x52, 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 };
+
+const unsigned kPasswordLen_MAX = 127;
+
+bool CItem::IgnoreItem() const
+{
+ switch (HostOS)
+ {
+ case NHeader::NFile::kHostMSDOS:
+ case NHeader::NFile::kHostOS2:
+ case NHeader::NFile::kHostWin32:
+ return ((Attrib & NHeader::NFile::kLabelFileAttribute) != 0);
+ }
+ return false;
+}
+
+bool CItem::IsDir() const
+{
+ if (GetDictSize() == NHeader::NFile::kDictDirectoryValue)
+ return true;
+ switch (HostOS)
+ {
+ case NHeader::NFile::kHostMSDOS:
+ case NHeader::NFile::kHostOS2:
+ case NHeader::NFile::kHostWin32:
+ if ((Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+ return true;
+ }
+ return false;
+}
+
+UInt32 CItem::GetWinAttrib() const
+{
+ UInt32 a;
+ switch (HostOS)
+ {
+ case NHeader::NFile::kHostMSDOS:
+ case NHeader::NFile::kHostOS2:
+ case NHeader::NFile::kHostWin32:
+ a = Attrib;
+ break;
+ default:
+ a = 0; // must be converted from unix value;
+ }
+ if (IsDir())
+ a |= NHeader::NFile::kWinFileDirectoryAttributeMask;
+ return a;
+}
+
+static const char * const kHostOS[] =
+{
+ "MS DOS"
+ , "OS/2"
+ , "Win32"
+ , "Unix"
+ , "Mac OS"
+ , "BeOS"
+};
+
+static const char * const k_Flags[] =
+{
+ "Volume"
+ , "Comment"
+ , "Lock"
+ , "Solid"
+ , "NewVolName" // pack_comment in old versuons
+ , "Authenticity"
+ , "Recovery"
+ , "BlockEncryption"
+ , "FirstVolume"
+ , "EncryptVer" // 9
+};
+
+enum EErrorType
+{
+ k_ErrorType_OK,
+ k_ErrorType_Corrupted,
+ k_ErrorType_UnexpectedEnd,
+ k_ErrorType_DecryptionError
+};
+
+class CInArchive
+{
+ IInStream *m_Stream;
+ UInt64 m_StreamStartPosition;
+ UString _unicodeNameBuffer;
+ CByteBuffer _comment;
+ CByteBuffer m_FileHeaderData;
+ NHeader::NBlock::CBlock m_BlockHeader;
+ NCrypto::NRar3::CDecoder *m_RarAESSpec;
+ CMyComPtr<ICompressFilter> m_RarAES;
+ CAlignedBuffer m_DecryptedDataAligned;
+ UInt32 m_DecryptedDataSize;
+ bool m_CryptoMode;
+ UInt32 m_CryptoPos;
+
+
+ HRESULT ReadBytesSpec(void *data, size_t *size);
+ bool ReadBytesAndTestSize(void *data, UInt32 size);
+ void ReadName(const Byte *p, unsigned nameSize, CItem &item);
+ bool ReadHeaderReal(const Byte *p, unsigned size, CItem &item);
+
+ HRESULT Open2(IInStream *stream, const UInt64 *searchHeaderSizeLimit);
+
+ void AddToSeekValue(UInt64 addValue)
+ {
+ m_Position += addValue;
+ }
+
+ void FinishCryptoBlock()
+ {
+ if (m_CryptoMode)
+ while ((m_CryptoPos & 0xF) != 0)
+ {
+ m_CryptoPos++;
+ m_Position++;
+ }
+ }
+
+public:
+ UInt64 m_Position;
+ CInArcInfo ArcInfo;
+ bool HeaderErrorWarning;
+
+ HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit);
+ HRESULT GetNextItem(CItem &item, ICryptoGetTextPassword *getTextPassword,
+ bool &filled, EErrorType &error);
+};
+
+static bool CheckHeaderCrc(const Byte *header, size_t headerSize)
+{
+ return Get16(header) == (UInt16)(CrcCalc(header + 2, headerSize - 2) & 0xFFFF);
+}
+
+HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
+{
+ HeaderErrorWarning = false;
+ m_CryptoMode = false;
+ RINOK(InStream_GetPos_GetSize(stream, m_StreamStartPosition, ArcInfo.FileSize))
+ m_Position = m_StreamStartPosition;
+
+ UInt64 arcStartPos = m_StreamStartPosition;
+ {
+ Byte marker[NHeader::kMarkerSize];
+ RINOK(ReadStream_FALSE(stream, marker, NHeader::kMarkerSize))
+ if (memcmp(marker, kMarker, NHeader::kMarkerSize) == 0)
+ m_Position += NHeader::kMarkerSize;
+ else
+ {
+ if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(stream, m_StreamStartPosition))
+ RINOK(FindSignatureInStream(stream, kMarker, NHeader::kMarkerSize,
+ searchHeaderSizeLimit, arcStartPos))
+ m_Position = arcStartPos + NHeader::kMarkerSize;
+ RINOK(InStream_SeekSet(stream, m_Position))
+ }
+ }
+ Byte buf[NHeader::NArchive::kArchiveHeaderSize + 1];
+
+ RINOK(ReadStream_FALSE(stream, buf, NHeader::NArchive::kArchiveHeaderSize))
+ AddToSeekValue(NHeader::NArchive::kArchiveHeaderSize);
+
+
+ const UInt32 blockSize = Get16(buf + 5);
+
+ ArcInfo.EncryptVersion = 0;
+ ArcInfo.Flags = Get16(buf + 3);
+
+ UInt32 headerSize = NHeader::NArchive::kArchiveHeaderSize;
+
+ /*
+ if (ArcInfo.IsThereEncryptVer())
+ {
+ if (blockSize <= headerSize)
+ return S_FALSE;
+ RINOK(ReadStream_FALSE(stream, buf + NHeader::NArchive::kArchiveHeaderSize, 1));
+ AddToSeekValue(1);
+ ArcInfo.EncryptVersion = buf[NHeader::NArchive::kArchiveHeaderSize];
+ headerSize += 1;
+ }
+ */
+
+ if (blockSize < headerSize
+ || buf[2] != NHeader::NBlockType::kArchiveHeader
+ || !CheckHeaderCrc(buf, headerSize))
+ return S_FALSE;
+
+ size_t commentSize = blockSize - headerSize;
+ _comment.Alloc(commentSize);
+ RINOK(ReadStream_FALSE(stream, _comment, commentSize))
+ AddToSeekValue(commentSize);
+ m_Stream = stream;
+ ArcInfo.StartPos = arcStartPos;
+ return S_OK;
+}
+
+HRESULT CInArchive::ReadBytesSpec(void *data, size_t *resSize)
+{
+ if (m_CryptoMode)
+ {
+ size_t size = *resSize;
+ *resSize = 0;
+ const Byte *bufData = m_DecryptedDataAligned;
+ UInt32 bufSize = m_DecryptedDataSize;
+ size_t i;
+ for (i = 0; i < size && m_CryptoPos < bufSize; i++)
+ ((Byte *)data)[i] = bufData[m_CryptoPos++];
+ *resSize = i;
+ return S_OK;
+ }
+ return ReadStream(m_Stream, data, resSize);
+}
+
+bool CInArchive::ReadBytesAndTestSize(void *data, UInt32 size)
+{
+ size_t processed = size;
+ if (ReadBytesSpec(data, &processed) != S_OK)
+ return false;
+ return processed == size;
+}
+
+
+static unsigned DecodeUnicodeFileName(const Byte *name, const Byte *encName,
+ unsigned encSize, wchar_t *unicodeName, unsigned maxDecSize)
+{
+ unsigned encPos = 0;
+ unsigned decPos = 0;
+ unsigned flagBits = 0;
+ Byte flags = 0;
+
+ if (encPos >= encSize)
+ return 0; // error
+ const unsigned highBits = ((unsigned)encName[encPos++]) << 8;
+
+ while (encPos < encSize && decPos < maxDecSize)
+ {
+ if (flagBits == 0)
+ {
+ flags = encName[encPos++];
+ flagBits = 8;
+ }
+
+ if (encPos >= encSize)
+ break; // error
+ unsigned len = encName[encPos++];
+
+ flagBits -= 2;
+ const unsigned mode = (flags >> flagBits) & 3;
+
+ if (mode != 3)
+ {
+ if (mode == 1)
+ len += highBits;
+ else if (mode == 2)
+ {
+ if (encPos >= encSize)
+ break; // error
+ len += ((unsigned)encName[encPos++] << 8);
+ }
+ unicodeName[decPos++] = (wchar_t)len;
+ }
+ else
+ {
+ if (len & 0x80)
+ {
+ if (encPos >= encSize)
+ break; // error
+ Byte correction = encName[encPos++];
+ for (len = (len & 0x7f) + 2; len > 0 && decPos < maxDecSize; len--, decPos++)
+ unicodeName[decPos] = (wchar_t)(((name[decPos] + correction) & 0xff) + highBits);
+ }
+ else
+ for (len += 2; len > 0 && decPos < maxDecSize; len--, decPos++)
+ unicodeName[decPos] = name[decPos];
+ }
+ }
+
+ return decPos < maxDecSize ? decPos : maxDecSize - 1;
+}
+
+
+void CInArchive::ReadName(const Byte *p, unsigned nameSize, CItem &item)
+{
+ item.UnicodeName.Empty();
+ if (nameSize > 0)
+ {
+ unsigned i;
+ for (i = 0; i < nameSize && p[i] != 0; i++);
+ item.Name.SetFrom((const char *)p, i);
+
+ if (item.HasUnicodeName())
+ {
+ if (i < nameSize)
+ {
+ i++;
+ unsigned uNameSizeMax = MyMin(nameSize, (unsigned)0x400);
+ unsigned len = DecodeUnicodeFileName(p, p + i, nameSize - i, _unicodeNameBuffer.GetBuf(uNameSizeMax), uNameSizeMax);
+ _unicodeNameBuffer.ReleaseBuf_SetEnd(len);
+ item.UnicodeName = _unicodeNameBuffer;
+ }
+ else if (!ConvertUTF8ToUnicode(item.Name, item.UnicodeName))
+ item.UnicodeName.Empty();
+ }
+ }
+ else
+ item.Name.Empty();
+}
+
+static int ReadTime(const Byte *p, unsigned size, Byte mask, CRarTime &rarTime)
+{
+ rarTime.LowSecond = (Byte)(((mask & 4) != 0) ? 1 : 0);
+ const unsigned numDigits = (mask & 3);
+ rarTime.SubTime[0] =
+ rarTime.SubTime[1] =
+ rarTime.SubTime[2] = 0;
+ if (numDigits > size)
+ return -1;
+ for (unsigned i = 0; i < numDigits; i++)
+ rarTime.SubTime[3 - numDigits + i] = p[i];
+ return (int)numDigits;
+}
+
+#define READ_TIME(_mask_, _ttt_) \
+ { int size2 = ReadTime(p, size, _mask_, _ttt_); if (size2 < 0) return false; p += (unsigned)size2, size -= (unsigned)size2; }
+
+#define READ_TIME_2(_mask_, _def_, _ttt_) \
+ _def_ = ((_mask_ & 8) != 0); if (_def_) \
+ { if (size < 4) return false; \
+ _ttt_ .DosTime = Get32(p); p += 4; size -= 4; \
+ READ_TIME(_mask_, _ttt_); } \
+
+
+bool CInArchive::ReadHeaderReal(const Byte *p, unsigned size, CItem &item)
+{
+ const Byte *pStart = p;
+
+ item.Clear();
+ item.Flags = m_BlockHeader.Flags;
+
+ const unsigned kFileHeaderSize = 25;
+
+ if (size < kFileHeaderSize)
+ return false;
+
+ item.PackSize = Get32(p);
+ item.Size = Get32(p + 4);
+ item.HostOS = p[8];
+ item.FileCRC = Get32(p + 9);
+ item.MTime.DosTime = Get32(p + 13);
+ item.UnPackVersion = p[17];
+ item.Method = p[18];
+ unsigned nameSize = Get16(p + 19);
+ item.Attrib = Get32(p + 21);
+
+ item.MTime.LowSecond = 0;
+ item.MTime.SubTime[0] =
+ item.MTime.SubTime[1] =
+ item.MTime.SubTime[2] = 0;
+
+ p += kFileHeaderSize;
+ size -= kFileHeaderSize;
+ if ((item.Flags & NHeader::NFile::kSize64Bits) != 0)
+ {
+ if (size < 8)
+ return false;
+ item.PackSize |= ((UInt64)Get32(p) << 32);
+ if (item.PackSize >= ((UInt64)1 << 63))
+ return false;
+ item.Size |= ((UInt64)Get32(p + 4) << 32);
+ p += 8;
+ size -= 8;
+ }
+ if (nameSize > size)
+ return false;
+ ReadName(p, nameSize, item);
+ p += nameSize;
+ size -= nameSize;
+
+ /*
+ // It was commented, since it's difficult to support alt Streams for solid archives.
+ if (m_BlockHeader.Type == NHeader::NBlockType::kSubBlock)
+ {
+ if (item.HasSalt())
+ {
+ if (size < sizeof(item.Salt))
+ return false;
+ size -= sizeof(item.Salt);
+ p += sizeof(item.Salt);
+ }
+ if (item.Name == "ACL" && size == 0)
+ {
+ item.IsAltStream = true;
+ item.Name.Empty();
+ item.UnicodeName.SetFromAscii(".ACL");
+ }
+ else if (item.Name == "STM" && size != 0 && (size & 1) == 0)
+ {
+ item.IsAltStream = true;
+ item.Name.Empty();
+ for (UInt32 i = 0; i < size; i += 2)
+ {
+ wchar_t c = Get16(p + i);
+ if (c == 0)
+ return false;
+ item.UnicodeName += c;
+ }
+ }
+ }
+ */
+
+ if (item.HasSalt())
+ {
+ if (size < sizeof(item.Salt))
+ return false;
+ for (unsigned i = 0; i < sizeof(item.Salt); i++)
+ item.Salt[i] = p[i];
+ p += sizeof(item.Salt);
+ size -= (unsigned)sizeof(item.Salt);
+ }
+
+ // some rar archives have HasExtTime flag without field.
+ if (size >= 2 && item.HasExtTime())
+ {
+ Byte aMask = (Byte)(p[0] >> 4);
+ Byte b = p[1];
+ p += 2;
+ size -= 2;
+ Byte mMask = (Byte)(b >> 4);
+ Byte cMask = (Byte)(b & 0xF);
+ if ((mMask & 8) != 0)
+ {
+ READ_TIME(mMask, item.MTime)
+ }
+ READ_TIME_2(cMask, item.CTimeDefined, item.CTime)
+ READ_TIME_2(aMask, item.ATimeDefined, item.ATime)
+ }
+
+ unsigned fileHeaderWithNameSize = 7 + (unsigned)(p - pStart);
+
+ item.Position = m_Position;
+ item.MainPartSize = fileHeaderWithNameSize;
+ item.CommentSize = (UInt16)(m_BlockHeader.HeadSize - fileHeaderWithNameSize);
+
+ if (m_CryptoMode)
+ item.AlignSize = (UInt16)((16 - ((m_BlockHeader.HeadSize) & 0xF)) & 0xF);
+ else
+ item.AlignSize = 0;
+ AddToSeekValue(m_BlockHeader.HeadSize);
+
+ // return (m_BlockHeader.Type != NHeader::NBlockType::kSubBlock || item.IsAltStream);
+ return true;
+}
+
+HRESULT CInArchive::GetNextItem(CItem &item, ICryptoGetTextPassword *getTextPassword, bool &filled, EErrorType &error)
+{
+ filled = false;
+ error = k_ErrorType_OK;
+ for (;;)
+ {
+ RINOK(InStream_SeekSet(m_Stream, m_Position))
+ ArcInfo.EndPos = m_Position;
+ if (!m_CryptoMode && (ArcInfo.Flags &
+ NHeader::NArchive::kBlockHeadersAreEncrypted) != 0)
+ {
+ m_CryptoMode = false;
+ if (!getTextPassword)
+ {
+ error = k_ErrorType_DecryptionError;
+ return S_OK; // return S_FALSE;
+ }
+ if (!m_RarAES)
+ {
+ m_RarAESSpec = new NCrypto::NRar3::CDecoder;
+ m_RarAES = m_RarAESSpec;
+ }
+ // m_RarAESSpec->SetRar350Mode(ArcInfo.IsEncryptOld());
+
+ {
+ // Salt
+ const UInt32 kSaltSize = 8;
+ Byte salt[kSaltSize];
+ if (!ReadBytesAndTestSize(salt, kSaltSize))
+ return S_FALSE;
+ m_Position += kSaltSize;
+ RINOK(m_RarAESSpec->SetDecoderProperties2(salt, kSaltSize))
+ }
+
+ {
+ // Password
+ CMyComBSTR_Wipe password;
+ RINOK(getTextPassword->CryptoGetTextPassword(&password))
+ unsigned len = 0;
+ if (password)
+ len = MyStringLen(password);
+ if (len > kPasswordLen_MAX)
+ len = kPasswordLen_MAX;
+
+ CByteBuffer_Wipe buffer(len * 2);
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = password[i];
+ ((Byte *)buffer)[i * 2] = (Byte)c;
+ ((Byte *)buffer)[i * 2 + 1] = (Byte)(c >> 8);
+ }
+
+ m_RarAESSpec->SetPassword((const Byte *)buffer, len * 2);
+ }
+
+ const UInt32 kDecryptedBufferSize = (1 << 12);
+ if (m_DecryptedDataAligned.Size() == 0)
+ {
+ // const UInt32 kAlign = 16;
+ m_DecryptedDataAligned.AllocAtLeast(kDecryptedBufferSize);
+ if (!m_DecryptedDataAligned.IsAllocated())
+ return E_OUTOFMEMORY;
+ }
+ RINOK(m_RarAES->Init())
+ size_t decryptedDataSizeT = kDecryptedBufferSize;
+ RINOK(ReadStream(m_Stream, m_DecryptedDataAligned, &decryptedDataSizeT))
+ m_DecryptedDataSize = (UInt32)decryptedDataSizeT;
+ m_DecryptedDataSize = m_RarAES->Filter(m_DecryptedDataAligned, m_DecryptedDataSize);
+
+ m_CryptoMode = true;
+ m_CryptoPos = 0;
+ }
+
+ m_FileHeaderData.AllocAtLeast(7);
+ size_t processed = 7;
+ RINOK(ReadBytesSpec((Byte *)m_FileHeaderData, &processed))
+ if (processed != 7)
+ {
+ if (processed != 0)
+ error = k_ErrorType_UnexpectedEnd;
+ ArcInfo.EndPos = m_Position + processed; // test it
+ return S_OK;
+ }
+
+ const Byte *p = m_FileHeaderData;
+ m_BlockHeader.CRC = Get16(p + 0);
+ m_BlockHeader.Type = p[2];
+ m_BlockHeader.Flags = Get16(p + 3);
+ m_BlockHeader.HeadSize = Get16(p + 5);
+
+ if (m_BlockHeader.HeadSize < 7)
+ {
+ error = k_ErrorType_Corrupted;
+ return S_OK;
+ // ThrowExceptionWithCode(CInArchiveException::kIncorrectArchive);
+ }
+
+ if (m_BlockHeader.Type < NHeader::NBlockType::kFileHeader ||
+ m_BlockHeader.Type > NHeader::NBlockType::kEndOfArchive)
+ {
+ error = m_CryptoMode ?
+ k_ErrorType_DecryptionError :
+ k_ErrorType_Corrupted;
+ return S_OK;
+ }
+
+ if (m_BlockHeader.Type == NHeader::NBlockType::kEndOfArchive)
+ {
+ bool footerError = false;
+
+ unsigned expectHeadLen = 7;
+ if (m_BlockHeader.Flags & NHeader::NArchive::kEndOfArc_Flags_DataCRC)
+ expectHeadLen += 4;
+ if (m_BlockHeader.Flags & NHeader::NArchive::kEndOfArc_Flags_VolNumber)
+ expectHeadLen += 2;
+ if (m_BlockHeader.Flags & NHeader::NArchive::kEndOfArc_Flags_RevSpace)
+ expectHeadLen += 7;
+
+ // rar 5.0 beta 1 writes incorrect RevSpace and headSize
+
+ if (m_BlockHeader.HeadSize < expectHeadLen)
+ HeaderErrorWarning = true;
+
+ if (m_BlockHeader.HeadSize > 7)
+ {
+ /* We suppose that EndOfArchive header is always small.
+ It's only 20 bytes for multivolume
+ Fix the limit, if larger footers are possible */
+ if (m_BlockHeader.HeadSize > (1 << 8))
+ footerError = true;
+ else
+ {
+ if (m_FileHeaderData.Size() < m_BlockHeader.HeadSize)
+ m_FileHeaderData.ChangeSize_KeepData(m_BlockHeader.HeadSize, 7);
+ UInt32 afterSize = m_BlockHeader.HeadSize - 7;
+ if (ReadBytesAndTestSize(m_FileHeaderData + 7, afterSize))
+ processed += afterSize;
+ else
+ {
+ if (!m_CryptoMode)
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return S_OK;
+ }
+ footerError = true;
+ }
+ }
+ }
+
+ if (footerError || !CheckHeaderCrc(m_FileHeaderData, m_BlockHeader.HeadSize))
+ {
+ error = m_CryptoMode ?
+ k_ErrorType_DecryptionError :
+ k_ErrorType_Corrupted;
+ }
+ else
+ {
+ ArcInfo.EndFlags = m_BlockHeader.Flags;
+ UInt32 offset = 7;
+
+ if (m_BlockHeader.Flags & NHeader::NArchive::kEndOfArc_Flags_DataCRC)
+ {
+ if (processed < offset + 4)
+ error = k_ErrorType_Corrupted;
+ else
+ ArcInfo.DataCRC = Get32(m_FileHeaderData + offset);
+ offset += 4;
+ }
+
+ if (m_BlockHeader.Flags & NHeader::NArchive::kEndOfArc_Flags_VolNumber)
+ {
+ if (processed < offset + 2)
+ error = k_ErrorType_Corrupted;
+ else
+ ArcInfo.VolNumber = (UInt32)Get16(m_FileHeaderData + offset);
+ }
+
+ ArcInfo.EndOfArchive_was_Read = true;
+ }
+
+ m_Position += processed;
+ FinishCryptoBlock();
+ ArcInfo.EndPos = m_Position;
+ return S_OK;
+ }
+
+ if (m_BlockHeader.Type == NHeader::NBlockType::kFileHeader
+ /* || m_BlockHeader.Type == NHeader::NBlockType::kSubBlock */)
+ {
+ if (m_FileHeaderData.Size() < m_BlockHeader.HeadSize)
+ m_FileHeaderData.ChangeSize_KeepData(m_BlockHeader.HeadSize, 7);
+ // m_CurData = (Byte *)m_FileHeaderData;
+ // m_PosLimit = m_BlockHeader.HeadSize;
+ if (!ReadBytesAndTestSize(m_FileHeaderData + 7, m_BlockHeader.HeadSize - 7))
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return S_OK;
+ }
+
+ bool okItem = ReadHeaderReal(m_FileHeaderData + 7, m_BlockHeader.HeadSize - 7, item);
+ if (okItem)
+ {
+ if (!CheckHeaderCrc(m_FileHeaderData, (unsigned)m_BlockHeader.HeadSize - item.CommentSize))
+ {
+ error = k_ErrorType_Corrupted; // ThrowExceptionWithCode(CInArchiveException::kFileHeaderCRCError);
+ return S_OK;
+ }
+ filled = true;
+ }
+
+ FinishCryptoBlock();
+ m_CryptoMode = false;
+ // Move Position to compressed Data;
+ RINOK(InStream_SeekSet(m_Stream, m_Position))
+ AddToSeekValue(item.PackSize); // m_Position points to next header;
+ // if (okItem)
+ return S_OK;
+ /*
+ else
+ continue;
+ */
+ }
+
+ if (m_CryptoMode && m_BlockHeader.HeadSize > (1 << 10))
+ {
+ error = k_ErrorType_DecryptionError;
+ return S_OK;
+ }
+
+ if ((m_BlockHeader.Flags & NHeader::NBlock::kLongBlock) != 0)
+ {
+ if (m_FileHeaderData.Size() < 7 + 4)
+ m_FileHeaderData.ChangeSize_KeepData(7 + 4, 7);
+ if (!ReadBytesAndTestSize(m_FileHeaderData + 7, 4))
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return S_OK;
+ }
+ UInt32 dataSize = Get32(m_FileHeaderData + 7);
+ AddToSeekValue(dataSize);
+ if (m_CryptoMode && dataSize > (1 << 27))
+ {
+ error = k_ErrorType_DecryptionError;
+ return S_OK;
+ }
+ m_CryptoPos = m_BlockHeader.HeadSize;
+ }
+ else
+ m_CryptoPos = 0;
+
+ {
+ UInt64 newPos = m_Position + m_BlockHeader.HeadSize;
+ if (newPos > ArcInfo.FileSize)
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return S_OK;
+ }
+ }
+ AddToSeekValue(m_BlockHeader.HeadSize);
+ FinishCryptoBlock();
+ m_CryptoMode = false;
+ }
+}
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidAttrib,
+
+ kpidEncrypted,
+ kpidSolid,
+ kpidCommented,
+ kpidSplitBefore,
+ kpidSplitAfter,
+ kpidCRC,
+ kpidHostOS,
+ kpidMethod,
+ kpidUnpackVer,
+
+ kpidVolumeIndex
+};
+
+static const Byte kArcProps[] =
+{
+ kpidTotalPhySize,
+ kpidCharacts,
+ kpidSolid,
+ kpidNumBlocks,
+ // kpidEncrypted,
+ kpidIsVolume,
+ kpidVolumeIndex,
+ kpidNumVolumes
+ // kpidCommented
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+UInt64 CHandler::GetPackSize(unsigned refIndex) const
+{
+ const CRefItem &refItem = _refItems[refIndex];
+ UInt64 totalPackSize = 0;
+ for (unsigned i = 0; i < refItem.NumItems; i++)
+ totalPackSize += _items[refItem.ItemIndex + i].PackSize;
+ return totalPackSize;
+}
+
+bool CHandler::IsSolid(unsigned refIndex) const
+{
+ const CItem &item = _items[_refItems[refIndex].ItemIndex];
+ if (item.UnPackVersion < 20)
+ {
+ if (_arcInfo.IsSolid())
+ return (refIndex > 0);
+ return false;
+ }
+ return item.IsSolid();
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidVolumeIndex: if (_arcInfo.Is_VolNumber_Defined()) prop = (UInt32)_arcInfo.VolNumber; break;
+ case kpidSolid: prop = _arcInfo.IsSolid(); break;
+ case kpidCharacts:
+ {
+ AString s (FlagsToString(k_Flags, Z7_ARRAY_SIZE(k_Flags), _arcInfo.Flags));
+ // FLAGS_TO_PROP(k_Flags, _arcInfo.Flags, prop);
+ if (_arcInfo.Is_DataCRC_Defined())
+ {
+ s.Add_Space_if_NotEmpty();
+ s += "VolCRC";
+ }
+ prop = s;
+ break;
+ }
+ // case kpidEncrypted: prop = _arcInfo.IsEncrypted(); break; // it's for encrypted names.
+ case kpidIsVolume: prop = _arcInfo.IsVolume(); break;
+ case kpidNumVolumes: prop = (UInt32)_arcs.Size(); break;
+ case kpidOffset: if (_arcs.Size() == 1 && _arcInfo.StartPos != 0) prop = _arcInfo.StartPos; break;
+
+ case kpidTotalPhySize:
+ {
+ if (_arcs.Size() > 1)
+ {
+ UInt64 sum = 0;
+ FOR_VECTOR (v, _arcs)
+ sum += _arcs[v].PhySize;
+ prop = sum;
+ }
+ break;
+ }
+
+ case kpidPhySize:
+ {
+ if (_arcs.Size() != 0)
+ prop = _arcInfo.GetPhySize();
+ break;
+ }
+
+ // case kpidCommented: prop = _arcInfo.IsCommented(); break;
+
+ case kpidNumBlocks:
+ {
+ UInt32 numBlocks = 0;
+ FOR_VECTOR (i, _refItems)
+ if (!IsSolid(i))
+ numBlocks++;
+ prop = (UInt32)numBlocks;
+ break;
+ }
+
+
+ case kpidError:
+ {
+ // if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
+
+ if (/* &_missingVol || */ !_missingVolName.IsEmpty())
+ {
+ UString s ("Missing volume : ");
+ s += _missingVolName;
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = _errorFlags;
+ if (!_isArc)
+ v |= kpv_ErrorFlags_IsNotArc;
+ prop = v;
+ break;
+ }
+
+ case kpidWarningFlags:
+ {
+ if (_warningFlags != 0)
+ prop = _warningFlags;
+ break;
+ }
+
+ case kpidExtension:
+ if (_arcs.Size() == 1)
+ {
+ if (_arcInfo.Is_VolNumber_Defined())
+ {
+ AString s ("part");
+ UInt32 v = (UInt32)_arcInfo.VolNumber + 1;
+ if (v < 10)
+ s += '0';
+ s.Add_UInt32(v);
+ s += ".rar";
+ prop = s;
+ }
+ }
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _refItems.Size();
+ return S_OK;
+}
+
+static bool RarTimeToFileTime(const CRarTime &rarTime, FILETIME &ft)
+{
+ if (!NTime::DosTime_To_FileTime(rarTime.DosTime, ft))
+ return false;
+ UInt64 v = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
+ v += (UInt32)rarTime.LowSecond * 10000000;
+ v +=
+ ((UInt32)rarTime.SubTime[2] << 16) +
+ ((UInt32)rarTime.SubTime[1] << 8) +
+ ((UInt32)rarTime.SubTime[0]);
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+ return true;
+}
+
+static void RarTimeToProp(const CRarTime &rarTime, NCOM::CPropVariant &prop)
+{
+ FILETIME localFileTime, utc;
+ if (RarTimeToFileTime(rarTime, localFileTime)
+ && LocalFileTimeToFileTime(&localFileTime, &utc))
+ prop.SetAsTimeFrom_FT_Prec(utc, k_PropVar_TimePrec_100ns);
+ /*
+ else
+ utc.dwHighDateTime = utc.dwLowDateTime = 0;
+ // prop.SetAsTimeFrom_FT_Prec(utc, k_PropVar_TimePrec_100ns);
+ */
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ const CRefItem &refItem = _refItems[index];
+ const CItem &item = _items[refItem.ItemIndex];
+ const CItem &lastItem = _items[refItem.ItemIndex + refItem.NumItems - 1];
+
+ /*
+ const CItem *mainItem = &item;
+ if (item.BaseFileIndex >= 0)
+ mainItem = &_items[_refItems[item.BaseFileIndex].ItemIndex];
+ */
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ /*
+ UString u;
+ if (item.BaseFileIndex >= 0)
+ u = mainItem->GetName();
+ u += item.GetName();
+ */
+ prop = (const wchar_t *)NItemName::WinPathToOsPath(item.GetName());
+ break;
+ }
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: if (lastItem.Is_Size_Defined()) prop = lastItem.Size; break;
+ case kpidPackSize: prop = GetPackSize(index); break;
+ case kpidMTime: RarTimeToProp(item.MTime, prop); break;
+ case kpidCTime: if (item.CTimeDefined) RarTimeToProp(item.CTime, prop); break;
+ case kpidATime: if (item.ATimeDefined) RarTimeToProp(item.ATime, prop); break;
+ case kpidAttrib: prop = item.GetWinAttrib(); break;
+ case kpidEncrypted: prop = item.IsEncrypted(); break;
+ case kpidSolid: prop = IsSolid(index); break;
+ case kpidCommented: prop = item.IsCommented(); break;
+ case kpidSplitBefore: prop = item.IsSplitBefore(); break;
+ case kpidSplitAfter: prop = _items[refItem.ItemIndex + refItem.NumItems - 1].IsSplitAfter(); break;
+
+ case kpidVolumeIndex:
+ if (_arcInfo.Is_VolNumber_Defined())
+ prop = (UInt32)(_arcInfo.VolNumber + refItem.VolumeIndex);
+ break;
+
+ case kpidCRC:
+ {
+ prop = ((lastItem.IsSplitAfter()) ? item.FileCRC : lastItem.FileCRC);
+ break;
+ }
+ case kpidUnpackVer: prop = item.UnPackVersion; break;
+ case kpidMethod:
+ {
+ char s[16];
+ Byte m = item.Method;
+ if (m < (Byte)'0' || m > (Byte)'5')
+ ConvertUInt32ToString(m, s);
+ else
+ {
+ s[0] = 'm';
+ s[1] = (char)m;
+ s[2] = 0;
+ if (!item.IsDir())
+ {
+ s[2] = ':';
+ ConvertUInt32ToString(16 + item.GetDictSize(), &s[3]);
+ }
+ }
+ prop = s;
+ break;
+ }
+ case kpidHostOS:
+ TYPE_TO_PROP(kHostOS, item.HostOS, prop);
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback)
+{
+ {
+ CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+
+ CVolumeName seqName;
+
+ UInt64 totalBytes = 0;
+ UInt64 curBytes = 0;
+
+ if (openCallback)
+ {
+ openCallback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&openVolumeCallback);
+ openCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getTextPassword);
+ }
+
+ bool nextVol_is_Required = false;
+
+ CInArchive archive;
+
+ for (;;)
+ {
+ CMyComPtr<IInStream> inStream;
+ if (!_arcs.IsEmpty())
+ {
+ if (!openVolumeCallback)
+ break;
+
+ if (_arcs.Size() == 1)
+ {
+ if (!_arcInfo.IsVolume())
+ break;
+ UString baseName;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
+ if (prop.vt != VT_BSTR)
+ break;
+ baseName = prop.bstrVal;
+ }
+ if (!seqName.InitName(baseName, _arcInfo.HaveNewVolumeName()))
+ break;
+ /*
+ if (_arcInfo.HaveNewVolumeName() && !_arcInfo.IsFirstVolume())
+ {
+ seqName.MakeBeforeFirstName();
+ }
+ */
+ }
+
+ const UString volName = seqName.GetNextName();
+
+ HRESULT result = openVolumeCallback->GetStream(volName, &inStream);
+
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ if (!inStream || result != S_OK)
+ {
+ if (nextVol_is_Required)
+ _missingVolName = volName;
+ break;
+ }
+ }
+ else
+ inStream = stream;
+
+ UInt64 endPos;
+ RINOK(InStream_AtBegin_GetSize(inStream, endPos))
+ if (openCallback)
+ {
+ totalBytes += endPos;
+ RINOK(openCallback->SetTotal(NULL, &totalBytes))
+ }
+
+ RINOK(archive.Open(inStream, maxCheckStartPosition))
+ _isArc = true;
+ CItem item;
+
+ for (;;)
+ {
+ if (archive.m_Position > endPos)
+ {
+ _errorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+ break;
+ }
+
+ EErrorType error;
+ // bool decryptionError;
+ // AString errorMessageLoc;
+ bool filled;
+ HRESULT result = archive.GetNextItem(item, getTextPassword, filled, error);
+
+ if (error != k_ErrorType_OK)
+ {
+ if (error == k_ErrorType_UnexpectedEnd)
+ _errorFlags |= kpv_ErrorFlags_UnexpectedEnd;
+ else if (error == k_ErrorType_Corrupted)
+ _errorFlags |= kpv_ErrorFlags_HeadersError;
+ else if (error == k_ErrorType_DecryptionError)
+ _errorFlags |= kpv_ErrorFlags_EncryptedHeadersError;
+
+ // AddErrorMessage(errorMessageLoc);
+ }
+ RINOK(result)
+
+ if (!filled)
+ {
+ if (error == k_ErrorType_DecryptionError && _items.IsEmpty())
+ return S_FALSE;
+
+ if (archive.ArcInfo.ExtraZeroTail_is_Possible())
+ {
+ /* if there is recovery record for multivolume archive,
+ RAR adds 18 bytes (ZERO bytes) at the end for alignment.
+ We must skip these bytes to prevent phySize warning. */
+ RINOK(InStream_SeekSet(inStream, archive.ArcInfo.EndPos))
+ bool areThereNonZeros;
+ UInt64 numZeros;
+ const UInt64 maxSize = 1 << 12;
+ RINOK(ReadZeroTail(inStream, areThereNonZeros, numZeros, maxSize))
+ if (!areThereNonZeros && numZeros != 0 && numZeros <= maxSize)
+ archive.ArcInfo.EndPos += numZeros;
+ }
+ break;
+ }
+
+ if (item.IgnoreItem())
+ continue;
+
+ bool needAdd = true;
+
+ if (item.IsSplitBefore())
+ {
+ if (!_refItems.IsEmpty())
+ {
+ CRefItem &refItem = _refItems.Back();
+ refItem.NumItems++;
+ needAdd = false;
+ }
+ }
+
+ if (needAdd)
+ {
+ CRefItem refItem;
+ refItem.ItemIndex = _items.Size();
+ refItem.NumItems = 1;
+ refItem.VolumeIndex = _arcs.Size();
+ _refItems.Add(refItem);
+ }
+
+ _items.Add(item);
+
+ if (openCallback && _items.Size() % 100 == 0)
+ {
+ UInt64 numFiles = _items.Size();
+ UInt64 numBytes = curBytes + item.Position;
+ RINOK(openCallback->SetCompleted(&numFiles, &numBytes))
+ }
+ }
+
+ if (archive.HeaderErrorWarning)
+ _warningFlags |= kpv_ErrorFlags_HeadersError;
+
+ /*
+ if (archive.m_Position < endPos)
+ _warningFlags |= kpv_ErrorFlags_DataAfterEnd;
+ */
+ if (_arcs.IsEmpty())
+ _arcInfo = archive.ArcInfo;
+ // _arcInfo.EndPos = archive.EndPos;
+
+ curBytes += endPos;
+ {
+ CArc &arc = _arcs.AddNew();
+ arc.PhySize = archive.ArcInfo.GetPhySize();
+ arc.Stream = inStream;
+ }
+
+ nextVol_is_Required = false;
+
+ if (!archive.ArcInfo.IsVolume())
+ break;
+
+ if (archive.ArcInfo.EndOfArchive_was_Read)
+ {
+ if (!archive.ArcInfo.AreMoreVolumes())
+ break;
+ nextVol_is_Required = true;
+ }
+ }
+ }
+
+ /*
+ int baseFileIndex = -1;
+ for (unsigned i = 0; i < _refItems.Size(); i++)
+ {
+ CItem &item = _items[_refItems[i].ItemIndex];
+ if (item.IsAltStream)
+ item.BaseFileIndex = baseFileIndex;
+ else
+ baseFileIndex = i;
+ }
+ */
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback))
+{
+ COM_TRY_BEGIN
+ Close();
+ // try
+ {
+ HRESULT res = Open2(stream, maxCheckStartPosition, openCallback);
+ /*
+ if (res != S_OK)
+ Close();
+ */
+
+ return res;
+ }
+ // catch(const CInArchiveException &) { Close(); return S_FALSE; }
+ // catch(...) { Close(); throw; }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ COM_TRY_BEGIN
+ // _errorMessage.Empty();
+ _missingVolName.Empty();
+ _errorFlags = 0;
+ _warningFlags = 0;
+ _isArc = false;
+ _refItems.Clear();
+ _items.Clear();
+ _arcs.Clear();
+ return S_OK;
+ COM_TRY_END
+}
+
+struct CMethodItem
+{
+ Byte RarUnPackVersion;
+ CMyComPtr<ICompressCoder> Coder;
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CVolsInStream
+ , ISequentialInStream
+)
+ UInt64 _rem;
+ ISequentialInStream *_stream;
+ const CObjectVector<CArc> *_arcs;
+ const CObjectVector<CItem> *_items;
+ CRefItem _refItem;
+ unsigned _curIndex;
+ UInt32 _crc;
+ bool _calcCrc;
+
+public:
+ void Init(const CObjectVector<CArc> *arcs,
+ const CObjectVector<CItem> *items,
+ const CRefItem &refItem)
+ {
+ _arcs = arcs;
+ _items = items;
+ _refItem = refItem;
+ _curIndex = 0;
+ _stream = NULL;
+ CrcIsOK = true;
+ }
+
+ bool CrcIsOK;
+};
+
+
+Z7_COM7F_IMF(CVolsInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ UInt32 realProcessedSize = 0;
+
+ while (size != 0)
+ {
+ if (!_stream)
+ {
+ if (_curIndex >= _refItem.NumItems)
+ break;
+ const CItem &item = (*_items)[_refItem.ItemIndex + _curIndex];
+ unsigned volIndex = _refItem.VolumeIndex + _curIndex;
+ if (volIndex >= _arcs->Size())
+ {
+ return S_OK;
+ // return S_FALSE;
+ }
+ IInStream *s = (*_arcs)[volIndex].Stream;
+ RINOK(InStream_SeekSet(s, item.GetDataPosition()))
+ _stream = s;
+ _calcCrc = (CrcIsOK && item.IsSplitAfter());
+ _crc = CRC_INIT_VAL;
+ _rem = item.PackSize;
+ }
+ {
+ UInt32 cur = size;
+ if (cur > _rem)
+ cur = (UInt32)_rem;
+ UInt32 num = cur;
+ HRESULT res = _stream->Read(data, cur, &cur);
+ if (_calcCrc)
+ _crc = CrcUpdate(_crc, data, cur);
+ realProcessedSize += cur;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ data = (Byte *)data + cur;
+ size -= cur;
+ _rem -= cur;
+ if (_rem == 0)
+ {
+ const CItem &item = (*_items)[_refItem.ItemIndex + _curIndex];
+ _curIndex++;
+ if (_calcCrc && CRC_GET_DIGEST(_crc) != item.FileCRC)
+ CrcIsOK = false;
+ _stream = NULL;
+ }
+ if (res != S_OK)
+ return res;
+ if (realProcessedSize != 0)
+ return S_OK;
+ if (cur == 0 && num != 0)
+ return S_OK;
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ UInt64 // censoredTotalUnPacked = 0,
+ // censoredTotalPacked = 0,
+ importantTotalUnPacked = 0;
+ // importantTotalPacked = 0;
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _refItems.Size();
+ if (numItems == 0)
+ return S_OK;
+ unsigned lastIndex = 0;
+ CRecordVector<unsigned> importantIndexes;
+ CRecordVector<bool> extractStatuses;
+
+ bool isThereUndefinedSize = false;
+
+ for (UInt32 t = 0; t < numItems; t++)
+ {
+ unsigned index = allFilesMode ? t : indices[t];
+
+ {
+ const CRefItem &refItem = _refItems[index];
+ const CItem &item = _items[refItem.ItemIndex + refItem.NumItems - 1];
+
+ if (item.Is_Size_Defined())
+ {
+ // censoredTotalUnPacked += item.Size;
+ }
+ else
+ isThereUndefinedSize = true;
+
+ // censoredTotalPacked += item.PackSize;
+ }
+
+ unsigned j;
+ for (j = lastIndex; j <= index; j++)
+ // if (!_items[_refItems[j].ItemIndex].IsSolid())
+ if (!IsSolid(j))
+ lastIndex = j;
+
+ for (j = lastIndex; j <= index; j++)
+ {
+ const CRefItem &refItem = _refItems[j];
+ const CItem &item = _items[refItem.ItemIndex + refItem.NumItems - 1];
+
+ if (item.Is_Size_Defined())
+ importantTotalUnPacked += item.Size;
+ else
+ isThereUndefinedSize = true;
+ // importantTotalPacked += item.PackSize;
+ importantIndexes.Add(j);
+ extractStatuses.Add(j == index);
+ }
+
+ lastIndex = index + 1;
+ }
+
+ if (importantTotalUnPacked != 0 || !isThereUndefinedSize)
+ {
+ RINOK(extractCallback->SetTotal(importantTotalUnPacked))
+ }
+
+ UInt64 currentImportantTotalUnPacked = 0;
+ UInt64 currentImportantTotalPacked = 0;
+ UInt64 currentUnPackSize, currentPackSize;
+
+ CObjectVector<CMethodItem> methodItems;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CFilterCoder *filterStreamSpec = new CFilterCoder(false);
+ CMyComPtr<ISequentialInStream> filterStream = filterStreamSpec;
+
+ NCrypto::NRar2::CDecoder *rar20CryptoDecoderSpec = NULL;
+ CMyComPtr<ICompressFilter> rar20CryptoDecoder;
+ NCrypto::NRar3::CDecoder *rar3CryptoDecoderSpec = NULL;
+ CMyComPtr<ICompressFilter> rar3CryptoDecoder;
+
+ CVolsInStream *volsInStreamSpec = NULL;
+ CMyComPtr<ISequentialInStream> volsInStream;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ bool solidStart = true;
+
+ for (unsigned i = 0;;
+ i++,
+ currentImportantTotalUnPacked += currentUnPackSize,
+ currentImportantTotalPacked += currentPackSize)
+ {
+ lps->InSize = currentImportantTotalPacked;
+ lps->OutSize = currentImportantTotalUnPacked;
+ RINOK(lps->SetCur())
+
+ if (i >= importantIndexes.Size())
+ break;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+
+ Int32 askMode;
+ if (extractStatuses[i])
+ askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ else
+ askMode = NExtract::NAskMode::kSkip;
+
+ UInt32 index = importantIndexes[i];
+
+ const CRefItem &refItem = _refItems[index];
+ const CItem &item = _items[refItem.ItemIndex];
+ const CItem &lastItem = _items[refItem.ItemIndex + refItem.NumItems - 1];
+
+ UInt64 outSize = (UInt64)(Int64)-1;
+ currentUnPackSize = 0;
+ if (lastItem.Is_Size_Defined())
+ {
+ outSize = lastItem.Size;
+ currentUnPackSize = outSize;
+ }
+
+ currentPackSize = GetPackSize(index);
+
+ if (item.IgnoreItem())
+ continue;
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (!IsSolid(index))
+ solidStart = true;
+ if (item.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ bool mustBeProcessedAnywhere = false;
+ if (i < importantIndexes.Size() - 1)
+ {
+ // const CRefItem &nextRefItem = _refItems[importantIndexes[i + 1]];
+ // const CItem &nextItemInfo = _items[nextRefItem.ItemIndex];
+ // mustBeProcessedAnywhere = nextItemInfo.IsSolid();
+ mustBeProcessedAnywhere = IsSolid(importantIndexes[i + 1]);
+ }
+
+ if (!mustBeProcessedAnywhere && !testMode && !realOutStream)
+ continue;
+
+ if (!realOutStream && !testMode)
+ askMode = NExtract::NAskMode::kSkip;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ COutStreamWithCRC *outStreamSpec = new COutStreamWithCRC;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+
+ if (!volsInStream)
+ {
+ volsInStreamSpec = new CVolsInStream;
+ volsInStream = volsInStreamSpec;
+ }
+
+ volsInStreamSpec->Init(&_arcs, &_items, refItem);
+
+ UInt64 packSize = currentPackSize;
+
+ // packedPos += item.PackSize;
+ // unpackedPos += 0;
+
+ CMyComPtr<ISequentialInStream> inStream;
+
+ if (item.IsEncrypted())
+ {
+ // CMyComPtr<ICryptoSetPassword> cryptoSetPassword;
+
+ if (item.UnPackVersion >= 29)
+ {
+ if (!rar3CryptoDecoder)
+ {
+ rar3CryptoDecoderSpec = new NCrypto::NRar3::CDecoder;
+ rar3CryptoDecoder = rar3CryptoDecoderSpec;
+ }
+ // rar3CryptoDecoderSpec->SetRar350Mode(item.UnPackVersion < 36);
+ /*
+ CMyComPtr<ICompressSetDecoderProperties2> cryptoProperties;
+ RINOK(rar3CryptoDecoder.QueryInterface(IID_ICompressSetDecoderProperties2,
+ &cryptoProperties));
+ */
+ RINOK(rar3CryptoDecoderSpec->SetDecoderProperties2(item.Salt, item.HasSalt() ? sizeof(item.Salt) : 0))
+ filterStreamSpec->Filter = rar3CryptoDecoder;
+ }
+ else if (item.UnPackVersion >= 20)
+ {
+ if (!rar20CryptoDecoder)
+ {
+ rar20CryptoDecoderSpec = new NCrypto::NRar2::CDecoder;
+ rar20CryptoDecoder = rar20CryptoDecoderSpec;
+ }
+ filterStreamSpec->Filter = rar20CryptoDecoder;
+ }
+ else
+ {
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ continue;
+ }
+
+ // RINOK(filterStreamSpec->Filter.QueryInterface(IID_ICryptoSetPassword, &cryptoSetPassword));
+
+ if (!getTextPassword)
+ extractCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getTextPassword);
+
+ if (!getTextPassword)
+ {
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ continue;
+ }
+
+ // if (getTextPassword)
+ {
+ CMyComBSTR_Wipe password;
+ RINOK(getTextPassword->CryptoGetTextPassword(&password))
+
+ if (item.UnPackVersion >= 29)
+ {
+ unsigned len = 0;
+ if (password)
+ len = MyStringLen(password);
+ if (len > kPasswordLen_MAX)
+ len = kPasswordLen_MAX;
+ CByteBuffer_Wipe buffer(len * 2);
+ for (unsigned k = 0; k < len; k++)
+ {
+ wchar_t c = password[k];
+ ((Byte *)buffer)[k * 2] = (Byte)c;
+ ((Byte *)buffer)[k * 2 + 1] = (Byte)(c >> 8);
+ }
+ rar3CryptoDecoderSpec->SetPassword((const Byte *)buffer, len * 2);
+ }
+ else
+ {
+ AString_Wipe oemPassword;
+ if (password)
+ {
+ UString_Wipe unicode;
+ unicode.SetFromBstr(password);
+ if (unicode.Len() > kPasswordLen_MAX)
+ unicode.DeleteFrom(kPasswordLen_MAX);
+ UnicodeStringToMultiByte2(oemPassword, unicode, CP_OEMCP);
+ }
+ rar20CryptoDecoderSpec->SetPassword((const Byte *)(const char *)oemPassword, oemPassword.Len());
+ }
+ }
+ /*
+ else
+ {
+ RINOK(cryptoSetPassword->CryptoSetPassword(NULL, 0));
+ }
+ */
+
+ filterStreamSpec->SetInStream(volsInStream);
+ filterStreamSpec->SetOutStreamSize(NULL);
+ inStream = filterStream;
+ }
+ else
+ {
+ inStream = volsInStream;
+ }
+
+ CMyComPtr<ICompressCoder> commonCoder;
+
+ switch (item.Method)
+ {
+ case '0':
+ {
+ commonCoder = copyCoder;
+ break;
+ }
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ {
+ unsigned m;
+ for (m = 0; m < methodItems.Size(); m++)
+ if (methodItems[m].RarUnPackVersion == item.UnPackVersion)
+ break;
+ if (m == methodItems.Size())
+ {
+ CMethodItem mi;
+ mi.RarUnPackVersion = item.UnPackVersion;
+
+ mi.Coder.Release();
+ if (item.UnPackVersion <= 40)
+ {
+ UInt32 methodID = 0x40300;
+ if (item.UnPackVersion < 20)
+ methodID += 1;
+ else if (item.UnPackVersion < 29)
+ methodID += 2;
+ else
+ methodID += 3;
+ RINOK(CreateCoder_Id(EXTERNAL_CODECS_VARS methodID, false, mi.Coder))
+ }
+
+ if (!mi.Coder)
+ {
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ continue;
+ }
+
+ m = methodItems.Add(mi);
+ }
+ CMyComPtr<ICompressCoder> decoder = methodItems[m].Coder;
+
+ CMyComPtr<ICompressSetDecoderProperties2> compressSetDecoderProperties;
+ RINOK(decoder.QueryInterface(IID_ICompressSetDecoderProperties2,
+ &compressSetDecoderProperties))
+
+ Byte isSolid = (Byte)((IsSolid(index) || item.IsSplitBefore()) ? 1: 0);
+ if (solidStart)
+ {
+ isSolid = 0;
+ solidStart = false;
+ }
+
+
+ RINOK(compressSetDecoderProperties->SetDecoderProperties2(&isSolid, 1))
+
+ commonCoder = decoder;
+ break;
+ }
+ default:
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnsupportedMethod))
+ continue;
+ }
+
+ HRESULT result = commonCoder->Code(inStream, outStream, &packSize, &outSize, progress);
+
+ if (item.IsEncrypted())
+ filterStreamSpec->ReleaseInStream();
+
+ if (outSize == (UInt64)(Int64)-1)
+ currentUnPackSize = outStreamSpec->GetSize();
+
+ int opRes = (volsInStreamSpec->CrcIsOK && outStreamSpec->GetCRC() == lastItem.FileCRC) ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kCRCError;
+ outStream.Release();
+
+ if (result != S_OK)
+ {
+ if (result == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (result == E_NOTIMPL)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ return result;
+ }
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+IMPL_ISetCompressCodecsInfo
+
+REGISTER_ARC_I(
+ "Rar", "rar r00", NULL, 3,
+ kMarker,
+ 0,
+ NArcInfoFlags::kFindSignature,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Rar/RarHandler.h b/CPP/7zip/Archive/Rar/RarHandler.h
new file mode 100644
index 0000000..c4d8450
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/RarHandler.h
@@ -0,0 +1,114 @@
+// RarHandler.h
+
+#ifndef ZIP7_INC_RAR_HANDLER_H
+#define ZIP7_INC_RAR_HANDLER_H
+
+#include "../IArchive.h"
+
+#include "../../Common/CreateCoder.h"
+
+#include "RarItem.h"
+
+namespace NArchive {
+namespace NRar {
+
+struct CInArcInfo
+{
+ UInt32 Flags;
+ Byte EncryptVersion;
+
+ UInt64 StartPos;
+ UInt64 EndPos;
+ UInt64 FileSize;
+
+ UInt32 EndFlags;
+ UInt32 VolNumber;
+ UInt32 DataCRC;
+ bool EndOfArchive_was_Read;
+
+ CInArcInfo(): EndFlags(0), VolNumber(0), EndOfArchive_was_Read(false) {}
+
+ UInt64 GetPhySize() const { return EndPos - StartPos; }
+
+ bool ExtraZeroTail_is_Possible() const { return IsVolume() && IsRecovery() && EndOfArchive_was_Read; }
+
+ bool IsVolume() const { return (Flags & NHeader::NArchive::kVolume) != 0; }
+ bool IsCommented() const { return (Flags & NHeader::NArchive::kComment) != 0; }
+ // kLock
+ bool IsSolid() const { return (Flags & NHeader::NArchive::kSolid) != 0; }
+ bool HaveNewVolumeName() const { return (Flags & NHeader::NArchive::kNewVolName) != 0; }
+ // kAuthenticity
+ bool IsRecovery() const { return (Flags & NHeader::NArchive::kRecovery) != 0; }
+ bool IsEncrypted() const { return (Flags & NHeader::NArchive::kBlockEncryption) != 0; }
+ bool IsFirstVolume() const { return (Flags & NHeader::NArchive::kFirstVolume) != 0; }
+
+ // bool IsThereEncryptVer() const { return (Flags & NHeader::NArchive::kEncryptVer) != 0; }
+ // bool IsEncryptOld() const { return (!IsThereEncryptVer() || EncryptVersion < 36); }
+
+ bool AreMoreVolumes() const { return (EndFlags & NHeader::NArchive::kEndOfArc_Flags_NextVol) != 0; }
+ bool Is_VolNumber_Defined() const { return (EndFlags & NHeader::NArchive::kEndOfArc_Flags_VolNumber) != 0; }
+ bool Is_DataCRC_Defined() const { return (EndFlags & NHeader::NArchive::kEndOfArc_Flags_DataCRC) != 0; }
+};
+
+struct CArc
+{
+ CMyComPtr<IInStream> Stream;
+ UInt64 PhySize;
+ // CByteBuffer Comment;
+
+ CArc(): PhySize(0) {}
+ ISequentialInStream *CreateLimitedStream(UInt64 offset, UInt64 size) const;
+};
+
+struct CRefItem
+{
+ unsigned VolumeIndex;
+ unsigned ItemIndex;
+ unsigned NumItems;
+};
+
+class CHandler Z7_final:
+ public IInArchive,
+ Z7_PUBLIC_ISetCompressCodecsInfo_IFEC
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IInArchive)
+ Z7_COM_QI_ENTRY_ISetCompressCodecsInfo_IFEC
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IInArchive)
+ DECL_ISetCompressCodecsInfo
+
+ CRecordVector<CRefItem> _refItems;
+ CObjectVector<CItem> _items;
+ CObjectVector<CArc> _arcs;
+ NArchive::NRar::CInArcInfo _arcInfo;
+ // AString _errorMessage;
+ UInt32 _errorFlags;
+ UInt32 _warningFlags;
+ bool _isArc;
+ UString _missingVolName;
+
+ DECL_EXTERNAL_CODECS_VARS
+
+ UInt64 GetPackSize(unsigned refIndex) const;
+ bool IsSolid(unsigned refIndex) const;
+
+ /*
+ void AddErrorMessage(const AString &s)
+ {
+ if (!_errorMessage.IsEmpty())
+ _errorMessage += '\n';
+ _errorMessage += s;
+ }
+ */
+
+ HRESULT Open2(IInStream *stream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Rar/RarHeader.h b/CPP/7zip/Archive/Rar/RarHeader.h
new file mode 100644
index 0000000..031fea6
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/RarHeader.h
@@ -0,0 +1,209 @@
+// Archive/RarHeader.h
+
+#ifndef ZIP7_INC_ARCHIVE_RAR_HEADER_H
+#define ZIP7_INC_ARCHIVE_RAR_HEADER_H
+
+#include "../../../Common/MyTypes.h"
+
+namespace NArchive {
+namespace NRar {
+namespace NHeader {
+
+const unsigned kMarkerSize = 7;
+
+const unsigned kArchiveSolid = 0x1;
+
+namespace NBlockType
+{
+ enum EBlockType
+ {
+ kMarker = 0x72,
+ kArchiveHeader,
+ kFileHeader,
+ kCommentHeader,
+ kOldAuthenticity,
+ kOldSubBlock,
+ kRecoveryRecord,
+ kAuthenticity,
+ kSubBlock,
+ kEndOfArchive
+ };
+}
+
+namespace NArchive
+{
+ const UInt16 kVolume = 1;
+ const UInt16 kComment = 2;
+ const UInt16 kLock = 4;
+ const UInt16 kSolid = 8;
+ const UInt16 kNewVolName = 0x10; // ('volname.partN.rar')
+ const UInt16 kAuthenticity = 0x20;
+ const UInt16 kRecovery = 0x40;
+ const UInt16 kBlockEncryption = 0x80;
+ const UInt16 kFirstVolume = 0x100; // (set only by RAR 3.0 and later)
+
+ // const UInt16 kEncryptVer = 0x200; // RAR 3.6 : that feature was discarded by origial RAR
+
+ const UInt16 kEndOfArc_Flags_NextVol = 1;
+ const UInt16 kEndOfArc_Flags_DataCRC = 2;
+ const UInt16 kEndOfArc_Flags_RevSpace = 4;
+ const UInt16 kEndOfArc_Flags_VolNumber = 8;
+
+ const unsigned kHeaderSizeMin = 7;
+
+ const unsigned kArchiveHeaderSize = 13;
+
+ const unsigned kBlockHeadersAreEncrypted = 0x80;
+}
+
+namespace NFile
+{
+ const unsigned kSplitBefore = 1 << 0;
+ const unsigned kSplitAfter = 1 << 1;
+ const unsigned kEncrypted = 1 << 2;
+ const unsigned kComment = 1 << 3;
+ const unsigned kSolid = 1 << 4;
+
+ const unsigned kDictBitStart = 5;
+ const unsigned kNumDictBits = 3;
+ const unsigned kDictMask = (1 << kNumDictBits) - 1;
+ const unsigned kDictDirectoryValue = 0x7;
+
+ const unsigned kSize64Bits = 1 << 8;
+ const unsigned kUnicodeName = 1 << 9;
+ const unsigned kSalt = 1 << 10;
+ const unsigned kOldVersion = 1 << 11;
+ const unsigned kExtTime = 1 << 12;
+ // const unsigned kExtFlags = 1 << 13;
+ // const unsigned kSkipIfUnknown = 1 << 14;
+
+ const unsigned kLongBlock = 1 << 15;
+
+ /*
+ struct CBlock
+ {
+ // UInt16 HeadCRC;
+ // Byte Type;
+ // UInt16 Flags;
+ // UInt16 HeadSize;
+ UInt32 PackSize;
+ UInt32 UnPackSize;
+ Byte HostOS;
+ UInt32 FileCRC;
+ UInt32 Time;
+ Byte UnPackVersion;
+ Byte Method;
+ UInt16 NameSize;
+ UInt32 Attributes;
+ };
+ */
+
+ /*
+ struct CBlock32
+ {
+ UInt16 HeadCRC;
+ Byte Type;
+ UInt16 Flags;
+ UInt16 HeadSize;
+ UInt32 PackSize;
+ UInt32 UnPackSize;
+ Byte HostOS;
+ UInt32 FileCRC;
+ UInt32 Time;
+ Byte UnPackVersion;
+ Byte Method;
+ UInt16 NameSize;
+ UInt32 Attributes;
+ UInt16 GetRealCRC(const void *aName, UInt32 aNameSize,
+ bool anExtraDataDefined = false, Byte *anExtraData = 0) const;
+ };
+ struct CBlock64
+ {
+ UInt16 HeadCRC;
+ Byte Type;
+ UInt16 Flags;
+ UInt16 HeadSize;
+ UInt32 PackSizeLow;
+ UInt32 UnPackSizeLow;
+ Byte HostOS;
+ UInt32 FileCRC;
+ UInt32 Time;
+ Byte UnPackVersion;
+ Byte Method;
+ UInt16 NameSize;
+ UInt32 Attributes;
+ UInt32 PackSizeHigh;
+ UInt32 UnPackSizeHigh;
+ UInt16 GetRealCRC(const void *aName, UInt32 aNameSize) const;
+ };
+ */
+
+ const unsigned kLabelFileAttribute = 0x08;
+ const unsigned kWinFileDirectoryAttributeMask = 0x10;
+
+ enum CHostOS
+ {
+ kHostMSDOS = 0,
+ kHostOS2 = 1,
+ kHostWin32 = 2,
+ kHostUnix = 3,
+ kHostMacOS = 4,
+ kHostBeOS = 5
+ };
+}
+
+namespace NBlock
+{
+ const UInt16 kLongBlock = 1 << 15;
+ struct CBlock
+ {
+ UInt16 CRC;
+ Byte Type;
+ UInt16 Flags;
+ UInt16 HeadSize;
+ // UInt32 DataSize;
+ };
+}
+
+/*
+struct CSubBlock
+{
+ UInt16 HeadCRC;
+ Byte HeadType;
+ UInt16 Flags;
+ UInt16 HeadSize;
+ UInt32 DataSize;
+ UInt16 SubType;
+ Byte Level; // Reserved : Must be 0
+};
+
+struct CCommentBlock
+{
+ UInt16 HeadCRC;
+ Byte HeadType;
+ UInt16 Flags;
+ UInt16 HeadSize;
+ UInt16 UnpSize;
+ Byte UnpVer;
+ Byte Method;
+ UInt16 CommCRC;
+};
+
+
+struct CProtectHeader
+{
+ UInt16 HeadCRC;
+ Byte HeadType;
+ UInt16 Flags;
+ UInt16 HeadSize;
+ UInt32 DataSize;
+ Byte Version;
+ UInt16 RecSectors;
+ UInt32 TotalBlocks;
+ Byte Mark[8];
+};
+*/
+
+}}}
+
+#endif
diff --git a/CPP/7zip/Archive/Rar/RarItem.h b/CPP/7zip/Archive/Rar/RarItem.h
new file mode 100644
index 0000000..e1028ba
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/RarItem.h
@@ -0,0 +1,97 @@
+// RarItem.h
+
+#ifndef ZIP7_INC_ARCHIVE_RAR_ITEM_H
+#define ZIP7_INC_ARCHIVE_RAR_ITEM_H
+
+#include "../../../Common/StringConvert.h"
+
+#include "RarHeader.h"
+
+namespace NArchive {
+namespace NRar {
+
+struct CRarTime
+{
+ UInt32 DosTime;
+ Byte LowSecond;
+ Byte SubTime[3];
+};
+
+struct CItem
+{
+ UInt64 Size;
+ UInt64 PackSize;
+
+ CRarTime CTime;
+ CRarTime ATime;
+ CRarTime MTime;
+
+ UInt32 FileCRC;
+ UInt32 Attrib;
+
+ UInt16 Flags;
+ Byte HostOS;
+ Byte UnPackVersion;
+ Byte Method;
+
+ bool CTimeDefined;
+ bool ATimeDefined;
+
+ AString Name;
+ UString UnicodeName;
+
+ Byte Salt[8];
+
+ bool Is_Size_Defined() const { return Size != (UInt64)(Int64)-1; }
+
+ bool IsEncrypted() const { return (Flags & NHeader::NFile::kEncrypted) != 0; }
+ bool IsSolid() const { return (Flags & NHeader::NFile::kSolid) != 0; }
+ bool IsCommented() const { return (Flags & NHeader::NFile::kComment) != 0; }
+ bool IsSplitBefore() const { return (Flags & NHeader::NFile::kSplitBefore) != 0; }
+ bool IsSplitAfter() const { return (Flags & NHeader::NFile::kSplitAfter) != 0; }
+ bool HasSalt() const { return (Flags & NHeader::NFile::kSalt) != 0; }
+ bool HasExtTime() const { return (Flags & NHeader::NFile::kExtTime) != 0; }
+ bool HasUnicodeName()const { return (Flags & NHeader::NFile::kUnicodeName) != 0; }
+ bool IsOldVersion() const { return (Flags & NHeader::NFile::kOldVersion) != 0; }
+
+ UInt32 GetDictSize() const { return (Flags >> NHeader::NFile::kDictBitStart) & NHeader::NFile::kDictMask; }
+ bool IsDir() const;
+ bool IgnoreItem() const;
+ UInt32 GetWinAttrib() const;
+
+ UInt64 Position;
+ unsigned MainPartSize;
+ UInt16 CommentSize;
+ UInt16 AlignSize;
+
+ // int BaseFileIndex;
+ // bool IsAltStream;
+
+ UString GetName() const
+ {
+ if (( /* IsAltStream || */ HasUnicodeName()) && !UnicodeName.IsEmpty())
+ return UnicodeName;
+ return MultiByteToUnicodeString(Name, CP_OEMCP);
+ }
+
+ void Clear()
+ {
+ CTimeDefined = false;
+ ATimeDefined = false;
+ Name.Empty();
+ UnicodeName.Empty();
+ // IsAltStream = false;
+ // BaseFileIndex = -1;
+ }
+
+ CItem() { Clear(); }
+
+ UInt64 GetFullSize() const { return MainPartSize + CommentSize + AlignSize + PackSize; }
+ // DWORD GetHeaderWithCommentSize() const { return MainPartSize + CommentSize; }
+ UInt64 GetCommentPosition() const { return Position + MainPartSize; }
+ UInt64 GetDataPosition() const { return GetCommentPosition() + CommentSize + AlignSize; }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Rar/RarVol.h b/CPP/7zip/Archive/Rar/RarVol.h
new file mode 100644
index 0000000..9ee8e86
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/RarVol.h
@@ -0,0 +1,136 @@
+// RarVol.h
+
+#ifndef ZIP7_INC_ARCHIVE_RAR_VOL_H
+#define ZIP7_INC_ARCHIVE_RAR_VOL_H
+
+#include "../../../Common/StringConvert.h"
+
+#include "RarHeader.h"
+
+namespace NArchive {
+namespace NRar {
+
+inline bool IsDigit(wchar_t c)
+{
+ return c >= L'0' && c <= L'9';
+}
+
+class CVolumeName
+{
+ bool _needChangeForNext;
+ UString _before;
+ UString _changed;
+ UString _after;
+public:
+ CVolumeName(): _needChangeForNext(true) {}
+
+ bool InitName(const UString &name, bool newStyle = true)
+ {
+ _needChangeForNext = true;
+ _after.Empty();
+ UString base (name);
+ const int dotPos = name.ReverseFind_Dot();
+
+ if (dotPos >= 0)
+ {
+ const UString ext (name.Ptr(dotPos + 1));
+ if (ext.IsEqualTo_Ascii_NoCase("rar"))
+ {
+ _after = name.Ptr(dotPos);
+ base.DeleteFrom(dotPos);
+ }
+ else if (ext.IsEqualTo_Ascii_NoCase("exe"))
+ {
+ _after = ".rar";
+ base.DeleteFrom(dotPos);
+ }
+ else if (!newStyle)
+ {
+ if (ext.IsEqualTo_Ascii_NoCase("000") ||
+ ext.IsEqualTo_Ascii_NoCase("001") ||
+ ext.IsEqualTo_Ascii_NoCase("r00") ||
+ ext.IsEqualTo_Ascii_NoCase("r01"))
+ {
+ _changed = ext;
+ _before.SetFrom(name.Ptr(), (unsigned)dotPos + 1);
+ return true;
+ }
+ }
+ }
+
+ if (newStyle)
+ {
+ unsigned k = base.Len();
+
+ for (; k != 0; k--)
+ if (IsDigit(base[k - 1]))
+ break;
+
+ unsigned i = k;
+
+ for (; i != 0; i--)
+ if (!IsDigit(base[i - 1]))
+ break;
+
+ if (i != k)
+ {
+ _before.SetFrom(base.Ptr(), i);
+ _changed.SetFrom(base.Ptr(i), k - i);
+ _after.Insert(0, base.Ptr(k));
+ return true;
+ }
+ }
+
+ _after.Empty();
+ _before = base;
+ _before.Add_Dot();
+ _changed = "r00";
+ _needChangeForNext = false;
+ return true;
+ }
+
+ /*
+ void MakeBeforeFirstName()
+ {
+ unsigned len = _changed.Len();
+ _changed.Empty();
+ for (unsigned i = 0; i < len; i++)
+ _changed += L'0';
+ }
+ */
+
+ UString GetNextName()
+ {
+ if (_needChangeForNext)
+ {
+ unsigned i = _changed.Len();
+ if (i == 0)
+ return UString();
+ for (;;)
+ {
+ wchar_t c = _changed[--i];
+ if (c == L'9')
+ {
+ c = L'0';
+ _changed.ReplaceOneCharAtPos(i, c);
+ if (i == 0)
+ {
+ _changed.InsertAtFront(L'1');
+ break;
+ }
+ continue;
+ }
+ c++;
+ _changed.ReplaceOneCharAtPos(i, c);
+ break;
+ }
+ }
+
+ _needChangeForNext = true;
+ return _before + _changed + _after;
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Rar/StdAfx.cpp b/CPP/7zip/Archive/Rar/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Archive/Rar/StdAfx.h b/CPP/7zip/Archive/Rar/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Rar/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/RpmHandler.cpp b/CPP/7zip/Archive/RpmHandler.cpp
new file mode 100644
index 0000000..e05ac26
--- /dev/null
+++ b/CPP/7zip/Archive/RpmHandler.cpp
@@ -0,0 +1,769 @@
+// RpmHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+// #define Z7_RPM_SHOW_METADATA
+
+using namespace NWindows;
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+
+namespace NArchive {
+namespace NRpm {
+
+static const unsigned kNameSize = 66;
+static const unsigned kLeadSize = kNameSize + 30;
+static const unsigned k_HeaderSig_Size = 16;
+static const unsigned k_Entry_Size = 16;
+
+#define RPMSIG_NONE 0 // Old signature
+#define RPMSIG_PGP262_1024 1 // Old signature
+#define RPMSIG_HEADERSIG 5 // New signature
+
+enum
+{
+ kRpmType_Bin = 0,
+ kRpmType_Src = 1
+};
+
+// There are two sets of TAGs: signature tags and header tags
+
+// ----- Signature TAGs -----
+
+#define RPMSIGTAG_SIZE 1000 // Header + Payload size (32bit)
+
+// ----- Header TAGs -----
+
+#define RPMTAG_NAME 1000
+#define RPMTAG_VERSION 1001
+#define RPMTAG_RELEASE 1002
+#define RPMTAG_BUILDTIME 1006
+#define RPMTAG_OS 1021 // string (old version used int?)
+#define RPMTAG_ARCH 1022 // string (old version used int?)
+#define RPMTAG_PAYLOADFORMAT 1124
+#define RPMTAG_PAYLOADCOMPRESSOR 1125
+// #define RPMTAG_PAYLOADFLAGS 1126
+
+enum
+{
+ k_EntryType_NULL,
+ k_EntryType_CHAR,
+ k_EntryType_INT8,
+ k_EntryType_INT16,
+ k_EntryType_INT32,
+ k_EntryType_INT64,
+ k_EntryType_STRING,
+ k_EntryType_BIN,
+ k_EntryType_STRING_ARRAY,
+ k_EntryType_I18NSTRING
+};
+
+static const char * const k_CPUs[] =
+{
+ "noarch"
+ , "i386"
+ , "alpha"
+ , "sparc"
+ , "mips"
+ , "ppc"
+ , "m68k"
+ , "sgi"
+ , "rs6000"
+ , "ia64"
+ , "sparc64" // 10 ???
+ , "mipsel"
+ , "arm"
+ , "m68kmint"
+ , "s390"
+ , "s390x"
+ , "ppc64"
+ , "sh"
+ , "xtensa"
+ , "aarch64" // 19
+};
+
+static const char * const k_OS[] =
+{
+ "0"
+ , "Linux"
+ , "Irix"
+ , "solaris"
+ , "SunOS"
+ , "AmigaOS" // AIX
+ , "HP-UX"
+ , "osf"
+ , "FreeBSD"
+ , "SCO_SV"
+ , "Irix64"
+ , "NextStep"
+ , "bsdi"
+ , "machten"
+ , "cygwin32-NT"
+ , "cygwin32-95"
+ , "MP_RAS"
+ , "MiNT"
+ , "OS/390"
+ , "VM/ESA"
+ , "Linux/390" // "Linux/ESA"
+ , "Darwin" // "MacOSX" 21
+};
+
+struct CLead
+{
+ unsigned char Major;
+ unsigned char Minor;
+ UInt16 Type;
+ UInt16 Cpu;
+ UInt16 Os;
+ UInt16 SignatureType;
+ char Name[kNameSize];
+ // char Reserved[16];
+
+ void Parse(const Byte *p)
+ {
+ Major = p[4];
+ Minor = p[5];
+ Type = Get16(p + 6);
+ Cpu= Get16(p + 8);
+ memcpy(Name, p + 10, kNameSize);
+ p += 10 + kNameSize;
+ Os = Get16(p);
+ SignatureType = Get16(p + 2);
+ }
+
+ bool IsSupported() const { return Major >= 3 && Type <= 1; }
+};
+
+struct CEntry
+{
+ UInt32 Tag;
+ UInt32 Type;
+ UInt32 Offset;
+ UInt32 Count;
+
+ void Parse(const Byte *p)
+ {
+ Tag = Get32(p + 0);
+ Type = Get32(p + 4);
+ Offset = Get32(p + 8);
+ Count = Get32(p + 12);
+ }
+};
+
+
+#ifdef Z7_RPM_SHOW_METADATA
+struct CMetaFile
+{
+ UInt32 Tag;
+ UInt32 Offset;
+ UInt32 Size;
+};
+#endif
+
+Z7_class_CHandler_final: public CHandlerCont
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Cont)
+
+ UInt64 _headersSize; // is equal to start offset of payload data
+ UInt64 _payloadSize;
+ UInt64 _size;
+ // _size = _payloadSize, if (_payloadSize_Defined)
+ // _size = (fileSize - _headersSize), if (!_payloadSize_Defined)
+ UInt64 _phySize; // _headersSize + _payloadSize, if (_phySize_Defined)
+ UInt32 _headerPlusPayload_Size;
+ UInt32 _buildTime;
+
+ bool _payloadSize_Defined;
+ bool _phySize_Defined;
+ bool _headerPlusPayload_Size_Defined;
+ bool _time_Defined;
+
+ Byte _payloadSig[6]; // start data of payload
+
+ AString _name; // p7zip
+ AString _version; // 9.20.1
+ AString _release; // 8.1.1
+ AString _arch; // x86_64
+ AString _os; // linux
+
+ AString _format; // cpio
+ AString _compressor; // xz, gzip, bzip2
+
+ CLead _lead;
+
+ #ifdef Z7_RPM_SHOW_METADATA
+ AString _metadata;
+ CRecordVector<CMetaFile> _metaFiles;
+ #endif
+
+ void SetTime(NCOM::CPropVariant &prop) const
+ {
+ if (_time_Defined && _buildTime != 0)
+ PropVariant_SetFrom_UnixTime(prop, _buildTime);
+ }
+
+ void SetStringProp(const AString &s, NCOM::CPropVariant &prop) const
+ {
+ UString us;
+ if (!ConvertUTF8ToUnicode(s, us))
+ us = GetUnicodeString(s);
+ if (!us.IsEmpty())
+ prop = us;
+ }
+
+ void AddCPU(AString &s) const;
+ AString GetBaseName() const;
+ void AddSubFileExtension(AString &res) const;
+
+ HRESULT ReadHeader(ISequentialInStream *stream, bool isMainHeader);
+ HRESULT Open2(ISequentialInStream *stream);
+
+ virtual int GetItem_ExtractInfo(UInt32 /* index */, UInt64 &pos, UInt64 &size) const Z7_override
+ {
+ pos = _headersSize;
+ size = _size;
+ return NExtract::NOperationResult::kOK;
+ }
+};
+
+static const Byte kArcProps[] =
+{
+ kpidHeadersSize,
+ kpidCpu,
+ kpidHostOS,
+ kpidCTime
+ #ifdef Z7_RPM_SHOW_METADATA
+ , kpidComment
+ #endif
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidCTime
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+void CHandler::AddCPU(AString &s) const
+{
+ if (!_arch.IsEmpty())
+ s += _arch;
+ else
+ {
+ if (_lead.Type == kRpmType_Bin)
+ {
+ if (_lead.Cpu < Z7_ARRAY_SIZE(k_CPUs))
+ s += k_CPUs[_lead.Cpu];
+ else
+ s.Add_UInt32(_lead.Cpu);
+ }
+ }
+}
+
+AString CHandler::GetBaseName() const
+{
+ AString s;
+ if (!_name.IsEmpty())
+ {
+ s = _name;
+ if (!_version.IsEmpty())
+ {
+ s.Add_Minus();
+ s += _version;
+ }
+ if (!_release.IsEmpty())
+ {
+ s.Add_Minus();
+ s += _release;
+ }
+ }
+ else
+ s.SetFrom_CalcLen(_lead.Name, kNameSize);
+
+ s.Add_Dot();
+ if (_lead.Type == kRpmType_Src)
+ s += "src";
+ else
+ AddCPU(s);
+ return s;
+}
+
+void CHandler::AddSubFileExtension(AString &res) const
+{
+ if (!_format.IsEmpty())
+ res += _format;
+ else
+ res += "cpio";
+ res.Add_Dot();
+
+ const char *s;
+
+ if (!_compressor.IsEmpty())
+ {
+ s = _compressor;
+ if (_compressor == "bzip2")
+ s = "bz2";
+ else if (_compressor == "gzip")
+ s = "gz";
+ }
+ else
+ {
+ const Byte *p = _payloadSig;
+ if (p[0] == 0x1F && p[1] == 0x8B)
+ s = "gz";
+ else if (p[0] == 0xFD && p[1] == '7' && p[2] == 'z' && p[3] == 'X' && p[4] == 'Z' && p[5] == 0)
+ s = "xz";
+ else if (p[0] == 'B' && p[1] == 'Z' && p[2] == 'h' && p[3] >= '1' && p[3] <= '9')
+ s = "bz2";
+ else
+ s = "lzma";
+ }
+
+ res += s;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+
+ case kpidHeadersSize: prop = _headersSize; break;
+ case kpidPhySize: if (_phySize_Defined) prop = _phySize; break;
+
+ case kpidMTime:
+ case kpidCTime:
+ SetTime(prop);
+ break;
+
+ case kpidCpu:
+ {
+ AString s;
+ AddCPU(s);
+ /*
+ if (_lead.Type == kRpmType_Src)
+ s = "src";
+ */
+ SetStringProp(s, prop);
+ break;
+ }
+
+ case kpidHostOS:
+ {
+ if (!_os.IsEmpty())
+ SetStringProp(_os, prop);
+ else
+ {
+ TYPE_TO_PROP(k_OS, _lead.Os, prop);
+ }
+ break;
+ }
+
+ #ifdef Z7_RPM_SHOW_METADATA
+ // case kpidComment: SetStringProp(_metadata, prop); break;
+ #endif
+
+ case kpidName:
+ {
+ SetStringProp(GetBaseName() + ".rpm", prop);
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ if (index == 0)
+ switch (propID)
+ {
+ case kpidSize:
+ case kpidPackSize:
+ prop = _size;
+ break;
+
+ case kpidMTime:
+ case kpidCTime:
+ SetTime(prop);
+ break;
+
+ case kpidPath:
+ {
+ AString s (GetBaseName());
+ s.Add_Dot();
+ AddSubFileExtension(s);
+ SetStringProp(s, prop);
+ break;
+ }
+
+ /*
+ case kpidExtension:
+ {
+ prop = GetSubFileExtension();
+ break;
+ }
+ */
+ }
+ #ifdef Z7_RPM_SHOW_METADATA
+ else
+ {
+ index--;
+ if (index > _metaFiles.Size())
+ return E_INVALIDARG;
+ const CMetaFile &meta = _metaFiles[index];
+ switch (propID)
+ {
+ case kpidSize:
+ case kpidPackSize:
+ prop = meta.Size;
+ break;
+
+ case kpidMTime:
+ case kpidCTime:
+ SetTime(prop);
+ break;
+
+ case kpidPath:
+ {
+ AString s ("[META]");
+ s.Add_PathSepar();
+ s.Add_UInt32(meta.Tag);
+ prop = s;
+ break;
+ }
+ }
+ }
+ #endif
+
+ prop.Detach(value);
+ return S_OK;
+}
+
+#ifdef Z7_RPM_SHOW_METADATA
+static inline char GetHex(unsigned value)
+{
+ return (char)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
+}
+#endif
+
+HRESULT CHandler::ReadHeader(ISequentialInStream *stream, bool isMainHeader)
+{
+ UInt32 numEntries;
+ UInt32 dataLen;
+ {
+ char buf[k_HeaderSig_Size];
+ RINOK(ReadStream_FALSE(stream, buf, k_HeaderSig_Size))
+ if (Get32(buf) != 0x8EADE801) // buf[3] = 0x01 - is version
+ return S_FALSE;
+ // reserved = Get32(buf + 4);
+ numEntries = Get32(buf + 8);
+ dataLen = Get32(buf + 12);
+ if (numEntries >= 1 << 24)
+ return S_FALSE;
+ }
+ size_t indexSize = (size_t)numEntries * k_Entry_Size;
+ size_t headerSize = indexSize + dataLen;
+ if (headerSize < dataLen)
+ return S_FALSE;
+ CByteBuffer buffer(headerSize);
+ RINOK(ReadStream_FALSE(stream, buffer, headerSize))
+
+ for (UInt32 i = 0; i < numEntries; i++)
+ {
+ CEntry entry;
+
+ entry.Parse(buffer + (size_t)i * k_Entry_Size);
+ if (entry.Offset > dataLen)
+ return S_FALSE;
+
+ const Byte *p = buffer + indexSize + entry.Offset;
+ size_t rem = dataLen - entry.Offset;
+
+ if (!isMainHeader)
+ {
+ if (entry.Tag == RPMSIGTAG_SIZE &&
+ entry.Type == k_EntryType_INT32)
+ {
+ if (rem < 4 || entry.Count != 1)
+ return S_FALSE;
+ _headerPlusPayload_Size = Get32(p);
+ _headerPlusPayload_Size_Defined = true;
+ }
+ }
+ else
+ {
+ #ifdef Z7_RPM_SHOW_METADATA
+ {
+ _metadata.Add_UInt32(entry.Tag);
+ _metadata += ": ";
+ }
+ #endif
+
+ if (entry.Type == k_EntryType_STRING)
+ {
+ if (entry.Count != 1)
+ return S_FALSE;
+ size_t j;
+ for (j = 0; j < rem && p[j] != 0; j++);
+ if (j == rem)
+ return S_FALSE;
+ AString s((const char *)p);
+ switch (entry.Tag)
+ {
+ case RPMTAG_NAME: _name = s; break;
+ case RPMTAG_VERSION: _version = s; break;
+ case RPMTAG_RELEASE: _release = s; break;
+ case RPMTAG_ARCH: _arch = s; break;
+ case RPMTAG_OS: _os = s; break;
+ case RPMTAG_PAYLOADFORMAT: _format = s; break;
+ case RPMTAG_PAYLOADCOMPRESSOR: _compressor = s; break;
+ }
+
+ #ifdef Z7_RPM_SHOW_METADATA
+ _metadata += s;
+ #endif
+ }
+ else if (entry.Type == k_EntryType_INT32)
+ {
+ if (rem / 4 < entry.Count)
+ return S_FALSE;
+ if (entry.Tag == RPMTAG_BUILDTIME)
+ {
+ if (entry.Count != 1)
+ return S_FALSE;
+ _buildTime = Get32(p);
+ _time_Defined = true;
+ }
+
+ #ifdef Z7_RPM_SHOW_METADATA
+ for (UInt32 t = 0; t < entry.Count; t++)
+ {
+ if (t != 0)
+ _metadata.Add_Space();
+ _metadata.Add_UInt32(Get32(p + t * 4));
+ }
+ #endif
+ }
+
+ #ifdef Z7_RPM_SHOW_METADATA
+
+ else if (
+ entry.Type == k_EntryType_STRING_ARRAY ||
+ entry.Type == k_EntryType_I18NSTRING)
+ {
+ const Byte *p2 = p;
+ size_t rem2 = rem;
+ for (UInt32 t = 0; t < entry.Count; t++)
+ {
+ if (rem2 == 0)
+ return S_FALSE;
+ if (t != 0)
+ _metadata += '\n';
+ size_t j;
+ for (j = 0; j < rem2 && p2[j] != 0; j++);
+ if (j == rem2)
+ return S_FALSE;
+ _metadata += (const char *)p2;
+ j++;
+ p2 += j;
+ rem2 -= j;
+ }
+ }
+ else if (entry.Type == k_EntryType_INT16)
+ {
+ if (rem / 2 < entry.Count)
+ return S_FALSE;
+ for (UInt32 t = 0; t < entry.Count; t++)
+ {
+ if (t != 0)
+ _metadata.Add_Space();
+ _metadata.Add_UInt32(Get16(p + t * 2));
+ }
+ }
+ else if (entry.Type == k_EntryType_BIN)
+ {
+ if (rem < entry.Count)
+ return S_FALSE;
+ for (UInt32 t = 0; t < entry.Count; t++)
+ {
+ const unsigned b = p[t];
+ _metadata += GetHex((b >> 4) & 0xF);
+ _metadata += GetHex(b & 0xF);
+ }
+ }
+ else
+ {
+ // p = p;
+ }
+
+ _metadata += '\n';
+ #endif
+ }
+
+ #ifdef Z7_RPM_SHOW_METADATA
+ CMetaFile meta;
+ meta.Offset = entry.Offset;
+ meta.Tag = entry.Tag;
+ meta.Size = entry.Count;
+ _metaFiles.Add(meta);
+ #endif
+ }
+
+ headerSize += k_HeaderSig_Size;
+ _headersSize += headerSize;
+ if (isMainHeader && _headerPlusPayload_Size_Defined)
+ {
+ if (_headerPlusPayload_Size < headerSize)
+ return S_FALSE;
+ _payloadSize = _headerPlusPayload_Size - headerSize;
+ _size = _payloadSize;
+ _phySize = _headersSize + _payloadSize;
+ _payloadSize_Defined = true;
+ _phySize_Defined = true;
+ }
+ return S_OK;
+}
+
+HRESULT CHandler::Open2(ISequentialInStream *stream)
+{
+ {
+ Byte buf[kLeadSize];
+ RINOK(ReadStream_FALSE(stream, buf, kLeadSize))
+ if (Get32(buf) != 0xEDABEEDB)
+ return S_FALSE;
+ _lead.Parse(buf);
+ if (!_lead.IsSupported())
+ return S_FALSE;
+ }
+
+ _headersSize = kLeadSize;
+
+ if (_lead.SignatureType == RPMSIG_NONE)
+ {
+
+ }
+ else if (_lead.SignatureType == RPMSIG_PGP262_1024)
+ {
+ Byte temp[256];
+ RINOK(ReadStream_FALSE(stream, temp, sizeof(temp)))
+ }
+ else if (_lead.SignatureType == RPMSIG_HEADERSIG)
+ {
+ RINOK(ReadHeader(stream, false))
+ unsigned pos = (unsigned)_headersSize & 7;
+ if (pos != 0)
+ {
+ Byte temp[8];
+ unsigned num = 8 - pos;
+ RINOK(ReadStream_FALSE(stream, temp, num))
+ _headersSize += num;
+ }
+ }
+ else
+ return S_FALSE;
+
+ return ReadHeader(stream, true);
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ RINOK(Open2(inStream))
+
+ // start of payload is allowed to be unaligned
+ RINOK(ReadStream_FALSE(inStream, _payloadSig, sizeof(_payloadSig)))
+
+ if (!_payloadSize_Defined)
+ {
+ UInt64 endPos;
+ RINOK(InStream_GetSize_SeekToEnd(inStream, endPos))
+ _size = endPos - _headersSize;
+ }
+ _stream = inStream;
+ return S_OK;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _headersSize = 0;
+ _payloadSize = 0;
+ _size = 0;
+ _phySize = 0;
+ _headerPlusPayload_Size = 0;
+
+ _payloadSize_Defined = false;
+ _phySize_Defined = false;
+ _headerPlusPayload_Size_Defined = false;
+ _time_Defined = false;
+
+ _name.Empty();
+ _version.Empty();
+ _release.Empty();
+ _arch.Empty();
+ _os.Empty();
+
+ _format.Empty();
+ _compressor.Empty();
+
+ #ifdef Z7_RPM_SHOW_METADATA
+ _metadata.Empty();
+ _metaFiles.Size();
+ #endif
+
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1
+ #ifdef Z7_RPM_SHOW_METADATA
+ + _metaFiles.Size()
+ #endif
+ ;
+
+ return S_OK;
+}
+
+static const Byte k_Signature[] = { 0xED, 0xAB, 0xEE, 0xDB};
+
+REGISTER_ARC_I(
+ "Rpm", "rpm", NULL, 0xEB,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/SparseHandler.cpp b/CPP/7zip/Archive/SparseHandler.cpp
new file mode 100644
index 0000000..ab76f32
--- /dev/null
+++ b/CPP/7zip/Archive/SparseHandler.cpp
@@ -0,0 +1,547 @@
+// SparseHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+#define G16(_offs_, dest) dest = Get16(p + (_offs_));
+#define G32(_offs_, dest) dest = Get32(p + (_offs_));
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NSparse {
+
+// libsparse and simg2img
+
+struct CHeader
+{
+ // UInt32 magic; /* 0xed26ff3a */
+ // UInt16 major_version; /* (0x1) - reject images with higher major versions */
+ // UInt16 minor_version; /* (0x0) - allow images with higer minor versions */
+ UInt16 file_hdr_sz; /* 28 bytes for first revision of the file format */
+ UInt16 chunk_hdr_sz; /* 12 bytes for first revision of the file format */
+ UInt32 BlockSize; /* block size in bytes, must be a multiple of 4 (4096) */
+ UInt32 NumBlocks; /* total blocks in the non-sparse output image */
+ UInt32 NumChunks; /* total chunks in the sparse input image */
+ // UInt32 image_checksum; /* CRC32 checksum of the original data, counting "don't care" as 0. */
+
+ void Parse(const Byte *p)
+ {
+ // G16 (4, major_version);
+ // G16 (6, minor_version);
+ G16 (8, file_hdr_sz)
+ G16 (10, chunk_hdr_sz)
+ G32 (12, BlockSize)
+ G32 (16, NumBlocks)
+ G32 (20, NumChunks)
+ // G32 (24, image_checksum);
+ }
+};
+
+// #define SPARSE_HEADER_MAGIC 0xed26ff3a
+
+#define CHUNK_TYPE_RAW 0xCAC1
+#define CHUNK_TYPE_FILL 0xCAC2
+#define CHUNK_TYPE_DONT_CARE 0xCAC3
+#define CHUNK_TYPE_CRC32 0xCAC4
+
+#define MY_CHUNK_TYPE_FILL 0
+#define MY_CHUNK_TYPE_DONT_CARE 1
+#define MY_CHUNK_TYPE_RAW_START 2
+
+static const char * const g_Methods[] =
+{
+ "RAW"
+ , "FILL"
+ , "SPARSE" // "DONT_CARE"
+ , "CRC32"
+};
+
+static const unsigned kFillSize = 4;
+
+struct CChunk
+{
+ UInt32 VirtBlock;
+ Byte Fill [kFillSize];
+ UInt64 PhyOffset;
+};
+
+static const Byte k_Signature[] = { 0x3a, 0xff, 0x26, 0xed, 1, 0 };
+
+
+Z7_class_CHandler_final: public CHandlerImg
+{
+ Z7_IFACE_COM7_IMP(IInArchive_Img)
+
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ CRecordVector<CChunk> Chunks;
+ UInt64 _virtSize_fromChunks;
+ unsigned _blockSizeLog;
+ UInt32 _chunkIndexPrev;
+
+ UInt64 _packSizeProcessed;
+ UInt64 _phySize;
+ UInt32 _methodFlags;
+ bool _isArc;
+ bool _headersError;
+ bool _unexpectedEnd;
+ // bool _unsupported;
+ UInt32 NumChunks; // from header
+
+ HRESULT Seek2(UInt64 offset)
+ {
+ _posInArc = offset;
+ return InStream_SeekSet(Stream, offset);
+ }
+
+ void InitSeekPositions()
+ {
+ /* (_virtPos) and (_posInArc) is used only in Read() (that calls ReadPhy()).
+ So we must reset these variables before first call of Read() */
+ Reset_VirtPos();
+ Reset_PosInArc();
+ _chunkIndexPrev = 0;
+ _packSizeProcessed = 0;
+ }
+
+ // virtual functions
+ bool Init_PackSizeProcessed() Z7_override
+ {
+ _packSizeProcessed = 0;
+ return true;
+ }
+ bool Get_PackSizeProcessed(UInt64 &size) Z7_override
+ {
+ size = _packSizeProcessed;
+ return true;
+ }
+
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openCallback) Z7_override;
+ HRESULT ReadPhy(UInt64 offset, void *data, UInt32 size, UInt32 &processed);
+};
+
+
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize
+};
+
+static const Byte kArcProps[] =
+{
+ kpidClusterSize,
+ kpidNumBlocks,
+ kpidMethod
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidClusterSize: prop = (UInt32)((UInt32)1 << _blockSizeLog); break;
+ case kpidNumBlocks: prop = (UInt32)NumChunks; break;
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+
+ case kpidMethod:
+ {
+ FLAGS_TO_PROP(g_Methods, _methodFlags, prop);
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_headersError) v |= kpv_ErrorFlags_HeadersError;
+ if (_unexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+ // if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
+ if (!Stream && v == 0 && _isArc)
+ v = kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidSize: prop = _size; break;
+ case kpidPackSize: prop = _phySize; break;
+ case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+static unsigned GetLogSize(UInt32 size)
+{
+ unsigned k;
+ for (k = 0; k < 32; k++)
+ if (((UInt32)1 << k) == size)
+ return k;
+ return k;
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openCallback)
+{
+ const unsigned kHeaderSize = 28;
+ const unsigned kChunkHeaderSize = 12;
+ CHeader h;
+ {
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buf, kHeaderSize))
+ if (memcmp(buf, k_Signature, 6) != 0)
+ return S_FALSE;
+ h.Parse(buf);
+ }
+
+ if (h.file_hdr_sz != kHeaderSize ||
+ h.chunk_hdr_sz != kChunkHeaderSize)
+ return S_FALSE;
+
+ NumChunks = h.NumChunks;
+
+ const unsigned logSize = GetLogSize(h.BlockSize);
+ if (logSize < 2 || logSize >= 32)
+ return S_FALSE;
+ _blockSizeLog = logSize;
+
+ _size = (UInt64)h.NumBlocks << logSize;
+
+ if (h.NumChunks >= (UInt32)(Int32)-2) // it's our limit
+ return S_FALSE;
+
+ _isArc = true;
+ Chunks.Reserve(h.NumChunks + 1);
+ UInt64 offset = kHeaderSize;
+ UInt32 virtBlock = 0;
+ UInt32 i;
+
+ for (i = 0; i < h.NumChunks; i++)
+ {
+ {
+ const UInt32 mask = ((UInt32)1 << 16) - 1;
+ if ((i & mask) == mask && openCallback)
+ {
+ RINOK(openCallback->SetCompleted(NULL, &offset))
+ }
+ }
+ Byte buf[kChunkHeaderSize];
+ {
+ size_t processed = kChunkHeaderSize;
+ RINOK(ReadStream(stream, buf, &processed))
+ if (kChunkHeaderSize != processed)
+ {
+ offset += kChunkHeaderSize;
+ break;
+ }
+ }
+ const UInt32 type = Get32(&buf[0]);
+ const UInt32 numBlocks = Get32(&buf[4]);
+ UInt32 size = Get32(&buf[8]);
+
+ if (type < CHUNK_TYPE_RAW ||
+ type > CHUNK_TYPE_CRC32)
+ return S_FALSE;
+ if (size < kChunkHeaderSize)
+ return S_FALSE;
+ CChunk c;
+ c.PhyOffset = offset + kChunkHeaderSize;
+ c.VirtBlock = virtBlock;
+ offset += size;
+ size -= kChunkHeaderSize;
+ _methodFlags |= ((UInt32)1 << (type - CHUNK_TYPE_RAW));
+
+ if (numBlocks > h.NumBlocks - virtBlock)
+ return S_FALSE;
+
+ if (type == CHUNK_TYPE_CRC32)
+ {
+ // crc chunk must be last chunk (i == h.NumChunks -1);
+ if (size != kFillSize || numBlocks != 0)
+ return S_FALSE;
+ {
+ size_t processed = kFillSize;
+ RINOK(ReadStream(stream, c.Fill, &processed))
+ if (kFillSize != processed)
+ break;
+ }
+ continue;
+ }
+ // else
+ {
+ if (numBlocks == 0)
+ return S_FALSE;
+
+ if (type == CHUNK_TYPE_DONT_CARE)
+ {
+ if (size != 0)
+ return S_FALSE;
+ c.PhyOffset = MY_CHUNK_TYPE_DONT_CARE;
+ }
+ else if (type == CHUNK_TYPE_FILL)
+ {
+ if (size != kFillSize)
+ return S_FALSE;
+ c.PhyOffset = MY_CHUNK_TYPE_FILL;
+ size_t processed = kFillSize;
+ RINOK(ReadStream(stream, c.Fill, &processed))
+ if (kFillSize != processed)
+ break;
+ }
+ else if (type == CHUNK_TYPE_RAW)
+ {
+ /* Here we require (size == virtSize).
+ Probably original decoder also requires it.
+ But maybe size of last chunk can be non-aligned with blockSize ? */
+ const UInt32 virtSize = (numBlocks << _blockSizeLog);
+ if (size != virtSize || numBlocks != (virtSize >> _blockSizeLog))
+ return S_FALSE;
+ }
+ else
+ return S_FALSE;
+
+ virtBlock += numBlocks;
+ Chunks.AddInReserved(c);
+ if (type == CHUNK_TYPE_RAW)
+ RINOK(InStream_SeekSet(stream, offset))
+ }
+ }
+
+ if (i != h.NumChunks)
+ _unexpectedEnd = true;
+ else if (virtBlock != h.NumBlocks)
+ _headersError = true;
+
+ _phySize = offset;
+
+ {
+ CChunk c;
+ c.VirtBlock = virtBlock;
+ c.PhyOffset = offset;
+ Chunks.AddInReserved(c);
+ }
+ _virtSize_fromChunks = (UInt64)virtBlock << _blockSizeLog;
+
+ Stream = stream;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ Chunks.Clear();
+ _isArc = false;
+ _virtSize_fromChunks = 0;
+ // _unsupported = false;
+ _headersError = false;
+ _unexpectedEnd = false;
+ _phySize = 0;
+ _methodFlags = 0;
+
+ _chunkIndexPrev = 0;
+ _packSizeProcessed = 0;
+
+ // CHandlerImg:
+ Clear_HandlerImg_Vars();
+ Stream.Release();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ if (Chunks.Size() < 1)
+ return S_FALSE;
+ if (Chunks.Size() < 2 && _virtSize_fromChunks != 0)
+ return S_FALSE;
+ // if (_unsupported) return S_FALSE;
+ InitSeekPositions();
+ CMyComPtr<ISequentialInStream> streamTemp = this;
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+
+HRESULT CHandler::ReadPhy(UInt64 offset, void *data, UInt32 size, UInt32 &processed)
+{
+ processed = 0;
+ if (offset > _phySize || offset + size > _phySize)
+ {
+ // we don't expect these cases, if (_phySize) was set correctly.
+ return S_FALSE;
+ }
+ if (offset != _posInArc)
+ {
+ const HRESULT res = Seek2(offset);
+ if (res != S_OK)
+ {
+ Reset_PosInArc(); // we don't trust seek_pos in case of error
+ return res;
+ }
+ }
+ {
+ size_t size2 = size;
+ const HRESULT res = ReadStream(Stream, data, &size2);
+ processed = (UInt32)size2;
+ _packSizeProcessed += size2;
+ _posInArc += size2;
+ if (res != S_OK)
+ Reset_PosInArc(); // we don't trust seek_pos in case of reading error
+ return res;
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ // const unsigned kLimit = (1 << 16) + 1; if (size > kLimit) size = kLimit; // for debug
+ if (_virtPos >= _virtSize_fromChunks)
+ return S_OK;
+ {
+ const UInt64 rem = _virtSize_fromChunks - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ if (size == 0)
+ return S_OK;
+ }
+
+ UInt32 chunkIndex = _chunkIndexPrev;
+ if (chunkIndex + 1 >= Chunks.Size())
+ return S_FALSE;
+ {
+ const UInt32 blockIndex = (UInt32)(_virtPos >> _blockSizeLog);
+ if (blockIndex < Chunks[chunkIndex ].VirtBlock ||
+ blockIndex >= Chunks[chunkIndex + 1].VirtBlock)
+ {
+ unsigned left = 0, right = Chunks.Size() - 1;
+ for (;;)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ if (mid == left)
+ break;
+ if (blockIndex < Chunks[mid].VirtBlock)
+ right = mid;
+ else
+ left = mid;
+ }
+ chunkIndex = left;
+ _chunkIndexPrev = chunkIndex;
+ }
+ }
+
+ const CChunk &c = Chunks[chunkIndex];
+ const UInt64 offset = _virtPos - ((UInt64)c.VirtBlock << _blockSizeLog);
+ {
+ const UInt32 numBlocks = Chunks[chunkIndex + 1].VirtBlock - c.VirtBlock;
+ const UInt64 rem = ((UInt64)numBlocks << _blockSizeLog) - offset;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ const UInt64 phyOffset = c.PhyOffset;
+
+ if (phyOffset >= MY_CHUNK_TYPE_RAW_START)
+ {
+ UInt32 processed = 0;
+ const HRESULT res = ReadPhy(phyOffset + offset, data, size, processed);
+ if (processedSize)
+ *processedSize = processed;
+ _virtPos += processed;
+ return res;
+ }
+
+ Byte b = 0;
+
+ if (phyOffset == MY_CHUNK_TYPE_FILL)
+ {
+ const Byte b0 = c.Fill [0];
+ const Byte b1 = c.Fill [1];
+ const Byte b2 = c.Fill [2];
+ const Byte b3 = c.Fill [3];
+ if (b0 != b1 ||
+ b0 != b2 ||
+ b0 != b3)
+ {
+ if (processedSize)
+ *processedSize = size;
+ _virtPos += size;
+ Byte *dest = (Byte *)data;
+ while (size >= 4)
+ {
+ dest[0] = b0;
+ dest[1] = b1;
+ dest[2] = b2;
+ dest[3] = b3;
+ dest += 4;
+ size -= 4;
+ }
+ if (size > 0) dest[0] = b0;
+ if (size > 1) dest[1] = b1;
+ if (size > 2) dest[2] = b2;
+ return S_OK;
+ }
+ b = b0;
+ }
+ else if (phyOffset != MY_CHUNK_TYPE_DONT_CARE)
+ return S_FALSE;
+
+ memset(data, b, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+}
+
+REGISTER_ARC_I(
+ "Sparse", "simg img", NULL, 0xc2,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/SplitHandler.cpp b/CPP/7zip/Archive/SplitHandler.cpp
index ffb0e33..ae7ca03 100644
--- a/CPP/7zip/Archive/SplitHandler.cpp
+++ b/CPP/7zip/Archive/SplitHandler.cpp
@@ -1,359 +1,351 @@
-// SplitHandler.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/ComTry.h"
-#include "../../Common/MyString.h"
-
-#include "../../Windows/PropVariant.h"
-
-#include "../Common/ProgressUtils.h"
-#include "../Common/RegisterArc.h"
-
-#include "../Compress/CopyCoder.h"
-
-#include "Common/MultiStream.h"
-
-using namespace NWindows;
-
-namespace NArchive {
-namespace NSplit {
-
-static const Byte kProps[] =
-{
- kpidPath,
- kpidSize
-};
-
-static const Byte kArcProps[] =
-{
- kpidNumVolumes,
- kpidTotalPhySize
-};
-
-class CHandler:
- public IInArchive,
- public IInArchiveGetStream,
- public CMyUnknownImp
-{
- CObjectVector<CMyComPtr<IInStream> > _streams;
- CRecordVector<UInt64> _sizes;
- UString _subName;
- UInt64 _totalSize;
-
- HRESULT Open2(IInStream *stream, IArchiveOpenCallback *callback);
-public:
- MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
- INTERFACE_IInArchive(;)
- STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
-};
-
-IMP_IInArchive_Props
-IMP_IInArchive_ArcProps
-
-STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
-{
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidMainSubfile: prop = (UInt32)0; break;
- case kpidPhySize: if (!_sizes.IsEmpty()) prop = _sizes[0]; break;
- case kpidTotalPhySize: prop = _totalSize; break;
- case kpidNumVolumes: prop = (UInt32)_streams.Size(); break;
- }
- prop.Detach(value);
- return S_OK;
-}
-
-struct CSeqName
-{
- UString _unchangedPart;
- UString _changedPart;
- bool _splitStyle;
-
- bool GetNextName(UString &s)
- {
- {
- unsigned i = _changedPart.Len();
- for (;;)
- {
- wchar_t c = _changedPart[--i];
-
- if (_splitStyle)
- {
- if (c == 'z')
- {
- _changedPart.ReplaceOneCharAtPos(i, L'a');
- if (i == 0)
- return false;
- continue;
- }
- else if (c == 'Z')
- {
- _changedPart.ReplaceOneCharAtPos(i, L'A');
- if (i == 0)
- return false;
- continue;
- }
- }
- else
- {
- if (c == '9')
- {
- _changedPart.ReplaceOneCharAtPos(i, L'0');
- if (i == 0)
- {
- _changedPart.InsertAtFront(L'1');
- break;
- }
- continue;
- }
- }
-
- c++;
- _changedPart.ReplaceOneCharAtPos(i, c);
- break;
- }
- }
-
- s = _unchangedPart + _changedPart;
- return true;
- }
-};
-
-HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
-{
- Close();
- if (!callback)
- return S_FALSE;
-
- CMyComPtr<IArchiveOpenVolumeCallback> volumeCallback;
- callback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&volumeCallback);
- if (!volumeCallback)
- return S_FALSE;
-
- UString name;
- {
- NCOM::CPropVariant prop;
- RINOK(volumeCallback->GetProperty(kpidName, &prop));
- if (prop.vt != VT_BSTR)
- return S_FALSE;
- name = prop.bstrVal;
- }
-
- int dotPos = name.ReverseFind_Dot();
- const UString prefix = name.Left(dotPos + 1);
- const UString ext = name.Ptr(dotPos + 1);
- UString ext2 = ext;
- ext2.MakeLower_Ascii();
-
- CSeqName seqName;
-
- unsigned numLetters = 2;
- bool splitStyle = false;
-
- if (ext2.Len() >= 2 && StringsAreEqual_Ascii(ext2.RightPtr(2), "aa"))
- {
- splitStyle = true;
- while (numLetters < ext2.Len())
- {
- if (ext2[ext2.Len() - numLetters - 1] != 'a')
- break;
- numLetters++;
- }
- }
- else if (ext.Len() >= 2 && StringsAreEqual_Ascii(ext2.RightPtr(2), "01"))
- {
- while (numLetters < ext2.Len())
- {
- if (ext2[ext2.Len() - numLetters - 1] != '0')
- break;
- numLetters++;
- }
- if (numLetters != ext.Len())
- return S_FALSE;
- }
- else
- return S_FALSE;
-
- seqName._unchangedPart = prefix + ext.Left(ext2.Len() - numLetters);
- seqName._changedPart = ext.RightPtr(numLetters);
- seqName._splitStyle = splitStyle;
-
- if (prefix.Len() < 1)
- _subName = "file";
- else
- _subName.SetFrom(prefix, prefix.Len() - 1);
-
- UInt64 size;
- {
- /*
- NCOM::CPropVariant prop;
- RINOK(volumeCallback->GetProperty(kpidSize, &prop));
- if (prop.vt != VT_UI8)
- return E_INVALIDARG;
- size = prop.uhVal.QuadPart;
- */
- RINOK(stream->Seek(0, STREAM_SEEK_END, &size));
- RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
-
- _totalSize += size;
- _sizes.Add(size);
- _streams.Add(stream);
-
- {
- const UInt64 numFiles = _streams.Size();
- RINOK(callback->SetCompleted(&numFiles, NULL));
- }
-
- for (;;)
- {
- UString fullName;
- if (!seqName.GetNextName(fullName))
- break;
- CMyComPtr<IInStream> nextStream;
- HRESULT result = volumeCallback->GetStream(fullName, &nextStream);
- if (result == S_FALSE)
- break;
- if (result != S_OK)
- return result;
- if (!nextStream)
- break;
- {
- /*
- NCOM::CPropVariant prop;
- RINOK(volumeCallback->GetProperty(kpidSize, &prop));
- if (prop.vt != VT_UI8)
- return E_INVALIDARG;
- size = prop.uhVal.QuadPart;
- */
- RINOK(nextStream->Seek(0, STREAM_SEEK_END, &size));
- RINOK(nextStream->Seek(0, STREAM_SEEK_SET, NULL));
- }
- _totalSize += size;
- _sizes.Add(size);
- _streams.Add(nextStream);
- {
- const UInt64 numFiles = _streams.Size();
- RINOK(callback->SetCompleted(&numFiles, NULL));
- }
- }
-
- if (_streams.Size() == 1)
- {
- if (splitStyle)
- return S_FALSE;
- }
- return S_OK;
-}
-
-STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback)
-{
- COM_TRY_BEGIN
- HRESULT res = Open2(stream, callback);
- if (res != S_OK)
- Close();
- return res;
- COM_TRY_END
-}
-
-STDMETHODIMP CHandler::Close()
-{
- _totalSize = 0;
- _subName.Empty();
- _streams.Clear();
- _sizes.Clear();
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
-{
- *numItems = _streams.IsEmpty() ? 0 : 1;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
-{
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidPath: prop = _subName; break;
- case kpidSize:
- case kpidPackSize:
- prop = _totalSize;
- break;
- }
- prop.Detach(value);
- return S_OK;
-}
-
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
- Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
- COM_TRY_BEGIN
- if (numItems == 0)
- return S_OK;
- if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
- return E_INVALIDARG;
-
- UInt64 currentTotalSize = 0;
- RINOK(extractCallback->SetTotal(_totalSize));
- CMyComPtr<ISequentialOutStream> outStream;
- Int32 askMode = testMode ?
- NExtract::NAskMode::kTest :
- NExtract::NAskMode::kExtract;
- RINOK(extractCallback->GetStream(0, &outStream, askMode));
- if (!testMode && !outStream)
- return S_OK;
- RINOK(extractCallback->PrepareOperation(askMode));
-
- NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
- CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(extractCallback, false);
-
- FOR_VECTOR (i, _streams)
- {
- lps->InSize = lps->OutSize = currentTotalSize;
- RINOK(lps->SetCur());
- IInStream *inStream = _streams[i];
- RINOK(inStream->Seek(0, STREAM_SEEK_SET, NULL));
- RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
- currentTotalSize += copyCoderSpec->TotalSize;
- }
- outStream.Release();
- return extractCallback->SetOperationResult(NExtract::NOperationResult::kOK);
- COM_TRY_END
-}
-
-STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
-{
- COM_TRY_BEGIN
- if (index != 0)
- return E_INVALIDARG;
- *stream = 0;
- CMultiStream *streamSpec = new CMultiStream;
- CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
- FOR_VECTOR (i, _streams)
- {
- CMultiStream::CSubStreamInfo subStreamInfo;
- subStreamInfo.Stream = _streams[i];
- subStreamInfo.Size = _sizes[i];
- streamSpec->Streams.Add(subStreamInfo);
- }
- streamSpec->Init();
- *stream = streamTemp.Detach();
- return S_OK;
- COM_TRY_END
-}
-
-REGISTER_ARC_I_NO_SIG(
- "Split", "001", 0, 0xEA,
- 0,
- 0,
- NULL)
-
-}}
+// SplitHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/MultiStream.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NSplit {
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize
+};
+
+static const Byte kArcProps[] =
+{
+ kpidNumVolumes,
+ kpidTotalPhySize
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CObjectVector<CMyComPtr<IInStream> > _streams;
+ CRecordVector<UInt64> _sizes;
+ UString _subName;
+ UInt64 _totalSize;
+
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *callback);
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidPhySize: if (!_sizes.IsEmpty()) prop = _sizes[0]; break;
+ case kpidTotalPhySize: prop = _totalSize; break;
+ case kpidNumVolumes: prop = (UInt32)_streams.Size(); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+struct CSeqName
+{
+ UString _unchangedPart;
+ UString _changedPart;
+ bool _splitStyle;
+
+ bool GetNextName(UString &s)
+ {
+ {
+ unsigned i = _changedPart.Len();
+ for (;;)
+ {
+ wchar_t c = _changedPart[--i];
+
+ if (_splitStyle)
+ {
+ if (c == 'z')
+ {
+ _changedPart.ReplaceOneCharAtPos(i, L'a');
+ if (i == 0)
+ return false;
+ continue;
+ }
+ else if (c == 'Z')
+ {
+ _changedPart.ReplaceOneCharAtPos(i, L'A');
+ if (i == 0)
+ return false;
+ continue;
+ }
+ }
+ else
+ {
+ if (c == '9')
+ {
+ _changedPart.ReplaceOneCharAtPos(i, L'0');
+ if (i == 0)
+ {
+ _changedPart.InsertAtFront(L'1');
+ break;
+ }
+ continue;
+ }
+ }
+
+ c++;
+ _changedPart.ReplaceOneCharAtPos(i, c);
+ break;
+ }
+ }
+
+ s = _unchangedPart + _changedPart;
+ return true;
+ }
+};
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
+{
+ Close();
+ if (!callback)
+ return S_FALSE;
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpenVolumeCallback,
+ volumeCallback, callback)
+ if (!volumeCallback)
+ return S_FALSE;
+
+ UString name;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(volumeCallback->GetProperty(kpidName, &prop))
+ if (prop.vt != VT_BSTR)
+ return S_FALSE;
+ name = prop.bstrVal;
+ }
+
+ const int dotPos = name.ReverseFind_Dot();
+ const UString prefix = name.Left((unsigned)(dotPos + 1));
+ const UString ext = name.Ptr((unsigned)(dotPos + 1));
+ UString ext2 = ext;
+ ext2.MakeLower_Ascii();
+
+ CSeqName seqName;
+
+ unsigned numLetters = 2;
+ bool splitStyle = false;
+
+ if (ext2.Len() >= 2 && StringsAreEqual_Ascii(ext2.RightPtr(2), "aa"))
+ {
+ splitStyle = true;
+ while (numLetters < ext2.Len())
+ {
+ if (ext2[ext2.Len() - numLetters - 1] != 'a')
+ break;
+ numLetters++;
+ }
+ }
+ else if (ext2.Len() >= 2 && (
+ StringsAreEqual_Ascii(ext2.RightPtr(2), "01")
+ || StringsAreEqual_Ascii(ext2.RightPtr(2), "00")
+ ))
+ {
+ while (numLetters < ext2.Len())
+ {
+ if (ext2[ext2.Len() - numLetters - 1] != '0')
+ break;
+ numLetters++;
+ }
+ if (numLetters != ext2.Len())
+ return S_FALSE;
+ }
+ else
+ return S_FALSE;
+
+ seqName._unchangedPart = prefix + ext.Left(ext2.Len() - numLetters);
+ seqName._changedPart = ext.RightPtr(numLetters);
+ seqName._splitStyle = splitStyle;
+
+ if (prefix.Len() < 1)
+ _subName = "file";
+ else
+ _subName.SetFrom(prefix, prefix.Len() - 1);
+
+ UInt64 size;
+ {
+ /*
+ NCOM::CPropVariant prop;
+ RINOK(volumeCallback->GetProperty(kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ size = prop.uhVal.QuadPart;
+ */
+ }
+ RINOK(InStream_AtBegin_GetSize(stream, size))
+
+ _totalSize += size;
+ _sizes.Add(size);
+ _streams.Add(stream);
+
+ {
+ const UInt64 numFiles = _streams.Size();
+ RINOK(callback->SetCompleted(&numFiles, NULL))
+ }
+
+ for (;;)
+ {
+ UString fullName;
+ if (!seqName.GetNextName(fullName))
+ break;
+ CMyComPtr<IInStream> nextStream;
+ const HRESULT result = volumeCallback->GetStream(fullName, &nextStream);
+ if (result == S_FALSE)
+ break;
+ if (result != S_OK)
+ return result;
+ if (!nextStream)
+ break;
+ RINOK(InStream_AtBegin_GetSize(nextStream, size))
+ _totalSize += size;
+ _sizes.Add(size);
+ _streams.Add(nextStream);
+ {
+ const UInt64 numFiles = _streams.Size();
+ RINOK(callback->SetCompleted(&numFiles, NULL))
+ }
+ }
+
+ if (_streams.Size() == 1)
+ {
+ if (splitStyle)
+ return S_FALSE;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ const HRESULT res = Open2(stream, callback);
+ if (res != S_OK)
+ Close();
+ return res;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _totalSize = 0;
+ _subName.Empty();
+ _streams.Clear();
+ _sizes.Clear();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _streams.IsEmpty() ? 0 : 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPath: prop = _subName; break;
+ case kpidSize:
+ case kpidPackSize:
+ prop = _totalSize;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ UInt64 currentTotalSize = 0;
+ RINOK(extractCallback->SetTotal(_totalSize))
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &outStream, askMode))
+ if (!testMode && !outStream)
+ return S_OK;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (unsigned i = 0;; i++)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ if (i == _streams.Size())
+ break;
+ IInStream *inStream = _streams[i];
+ RINOK(InStream_SeekToBegin(inStream))
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+ currentTotalSize += copyCoderSpec->TotalSize;
+ }
+ outStream.Release();
+ return extractCallback->SetOperationResult(NExtract::NOperationResult::kOK);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ if (index != 0)
+ return E_INVALIDARG;
+ *stream = NULL;
+ CMultiStream *streamSpec = new CMultiStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ FOR_VECTOR (i, _streams)
+ {
+ CMultiStream::CSubStreamInfo subStreamInfo;
+ subStreamInfo.Stream = _streams[i];
+ subStreamInfo.Size = _sizes[i];
+ streamSpec->Streams.Add(subStreamInfo);
+ }
+ streamSpec->Init();
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+REGISTER_ARC_I_NO_SIG(
+ "Split", "001", NULL, 0xEA,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/SquashfsHandler.cpp b/CPP/7zip/Archive/SquashfsHandler.cpp
new file mode 100644
index 0000000..9c9ec03
--- /dev/null
+++ b/CPP/7zip/Archive/SquashfsHandler.cpp
@@ -0,0 +1,2326 @@
+// SquashfsHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/LzmaDec.h"
+#include "../../../C/Xz.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariantUtils.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/ZlibDecoder.h"
+// #include "../Compress/LzmaDecoder.h"
+
+namespace NArchive {
+namespace NSquashfs {
+
+static const UInt32 kNumFilesMax = (1 << 28);
+static const unsigned kNumDirLevelsMax = (1 << 10);
+
+// Layout: Header, Data, inodes, Directories, Fragments, UIDs, GIDs
+
+/*
+#define Get16(p) (be ? GetBe16(p) : GetUi16(p))
+#define Get32(p) (be ? GetBe32(p) : GetUi32(p))
+#define Get64(p) (be ? GetBe64(p) : GetUi64(p))
+*/
+
+static UInt16 Get16b(const Byte *p, bool be) { return be ? GetBe16(p) : GetUi16(p); }
+static UInt32 Get32b(const Byte *p, bool be) { return be ? GetBe32(p) : GetUi32(p); }
+static UInt64 Get64b(const Byte *p, bool be) { return be ? GetBe64(p) : GetUi64(p); }
+
+#define Get16(p) Get16b(p, be)
+#define Get32(p) Get32b(p, be)
+#define Get64(p) Get64b(p, be)
+
+#define LE_16(offs, dest) dest = GetUi16(p + (offs))
+#define LE_32(offs, dest) dest = GetUi32(p + (offs))
+#define LE_64(offs, dest) dest = GetUi64(p + (offs))
+
+#define GET_16(offs, dest) dest = Get16(p + (offs))
+#define GET_32(offs, dest) dest = Get32(p + (offs))
+#define GET_64(offs, dest) dest = Get64(p + (offs))
+
+static const UInt32 kSignature32_LE = 0x73717368;
+static const UInt32 kSignature32_BE = 0x68737173;
+static const UInt32 kSignature32_LZ = 0x71736873;
+static const UInt32 kSignature32_B2 = 0x73687371;
+
+#define kMethod_ZLIB 1
+#define kMethod_LZMA 2
+#define kMethod_LZO 3
+#define kMethod_XZ 4
+
+static const char * const k_Methods[] =
+{
+ "0"
+ , "ZLIB"
+ , "LZMA"
+ , "LZO"
+ , "XZ"
+};
+
+static const unsigned kMetadataBlockSizeLog = 13;
+static const UInt32 kMetadataBlockSize = (1 << kMetadataBlockSizeLog);
+
+enum
+{
+ kType_IPC,
+ kType_DIR,
+ kType_FILE,
+ kType_LNK,
+ kType_BLK,
+ kType_CHR,
+ kType_FIFO,
+ kType_SOCK
+};
+
+static const UInt32 k_TypeToMode[] =
+{
+ 0,
+ MY_LIN_S_IFDIR, MY_LIN_S_IFREG, MY_LIN_S_IFLNK, MY_LIN_S_IFBLK, MY_LIN_S_IFCHR, MY_LIN_S_IFIFO, MY_LIN_S_IFSOCK,
+ MY_LIN_S_IFDIR, MY_LIN_S_IFREG, MY_LIN_S_IFLNK, MY_LIN_S_IFBLK, MY_LIN_S_IFCHR, MY_LIN_S_IFIFO, MY_LIN_S_IFSOCK
+};
+
+
+enum
+{
+ kFlag_UNC_INODES,
+ kFlag_UNC_DATA,
+ kFlag_CHECK,
+ kFlag_UNC_FRAGS,
+ kFlag_NO_FRAGS,
+ kFlag_ALWAYS_FRAG,
+ kFlag_DUPLICATE,
+ kFlag_EXPORT
+};
+
+static const char * const k_Flags[] =
+{
+ "UNCOMPRESSED_INODES"
+ , "UNCOMPRESSED_DATA"
+ , "CHECK"
+ , "UNCOMPRESSED_FRAGMENTS"
+ , "NO_FRAGMENTS"
+ , "ALWAYS_FRAGMENTS"
+ , "DUPLICATES_REMOVED"
+ , "EXPORTABLE"
+ , "UNCOMPRESSED_XATTRS"
+ , "NO_XATTRS"
+ , "COMPRESSOR_OPTIONS"
+ , "UNCOMPRESSED_IDS"
+};
+
+static const UInt32 kNotCompressedBit16 = (1 << 15);
+static const UInt32 kNotCompressedBit32 = (1 << 24);
+
+#define GET_COMPRESSED_BLOCK_SIZE(size) ((size) & ~kNotCompressedBit32)
+#define IS_COMPRESSED_BLOCK(size) (((size) & kNotCompressedBit32) == 0)
+
+// static const UInt32 kHeaderSize1 = 0x33;
+// static const UInt32 kHeaderSize2 = 0x3F;
+static const UInt32 kHeaderSize3 = 0x77;
+// static const UInt32 kHeaderSize4 = 0x60;
+
+struct CHeader
+{
+ bool be;
+ bool SeveralMethods;
+ Byte NumUids;
+ Byte NumGids;
+
+ UInt32 NumInodes;
+ UInt32 CTime;
+ UInt32 BlockSize;
+ UInt32 NumFrags;
+ UInt16 Method;
+ UInt16 BlockSizeLog;
+ UInt16 Flags;
+ UInt16 NumIDs;
+ UInt16 Major;
+ UInt16 Minor;
+ UInt64 RootInode;
+ UInt64 Size;
+ UInt64 UidTable;
+ UInt64 GidTable;
+ UInt64 XattrIdTable;
+ UInt64 InodeTable;
+ UInt64 DirTable;
+ UInt64 FragTable;
+ UInt64 LookupTable;
+
+ void Parse3(const Byte *p)
+ {
+ Method = kMethod_ZLIB;
+ GET_32 (0x08, Size);
+ GET_32 (0x0C, UidTable);
+ GET_32 (0x10, GidTable);
+ GET_32 (0x14, InodeTable);
+ GET_32 (0x18, DirTable);
+ GET_16 (0x20, BlockSize);
+ GET_16 (0x22, BlockSizeLog);
+ Flags = p[0x24];
+ NumUids = p[0x25];
+ NumGids = p[0x26];
+ GET_32 (0x27, CTime);
+ GET_64 (0x2B, RootInode);
+ NumFrags = 0;
+ FragTable = UidTable;
+
+ if (Major >= 2)
+ {
+ GET_32 (0x33, BlockSize);
+ GET_32 (0x37, NumFrags);
+ GET_32 (0x3B, FragTable);
+ if (Major == 3)
+ {
+ GET_64 (0x3F, Size);
+ GET_64 (0x47, UidTable);
+ GET_64 (0x4F, GidTable);
+ GET_64 (0x57, InodeTable);
+ GET_64 (0x5F, DirTable);
+ GET_64 (0x67, FragTable);
+ GET_64 (0x6F, LookupTable);
+ }
+ }
+ }
+
+ void Parse4(const Byte *p)
+ {
+ LE_32 (0x08, CTime);
+ LE_32 (0x0C, BlockSize);
+ LE_32 (0x10, NumFrags);
+ LE_16 (0x14, Method);
+ LE_16 (0x16, BlockSizeLog);
+ LE_16 (0x18, Flags);
+ LE_16 (0x1A, NumIDs);
+ LE_64 (0x20, RootInode);
+ LE_64 (0x28, Size);
+ LE_64 (0x30, UidTable);
+ LE_64 (0x38, XattrIdTable);
+ LE_64 (0x40, InodeTable);
+ LE_64 (0x48, DirTable);
+ LE_64 (0x50, FragTable);
+ LE_64 (0x58, LookupTable);
+ GidTable = 0;
+ }
+
+ bool Parse(const Byte *p)
+ {
+ be = false;
+ SeveralMethods = false;
+ switch (GetUi32(p))
+ {
+ case kSignature32_LE: break;
+ case kSignature32_BE: be = true; break;
+ case kSignature32_LZ: SeveralMethods = true; break;
+ case kSignature32_B2: SeveralMethods = true; be = true; break;
+ default: return false;
+ }
+ GET_32 (4, NumInodes);
+ GET_16 (0x1C, Major);
+ GET_16 (0x1E, Minor);
+ if (Major <= 3)
+ Parse3(p);
+ else
+ {
+ if (be)
+ return false;
+ Parse4(p);
+ }
+ return
+ InodeTable < DirTable &&
+ DirTable <= FragTable &&
+ FragTable <= Size &&
+ UidTable <= Size &&
+ BlockSizeLog >= 12 &&
+ BlockSizeLog < 31 &&
+ BlockSize == ((UInt32)1 << BlockSizeLog);
+ }
+
+ bool IsSupported() const { return Major > 0 && Major <= 4 && BlockSizeLog <= 23; }
+ bool IsOldVersion() const { return Major < 4; }
+ bool NeedCheckData() const { return (Flags & (1 << kFlag_CHECK)) != 0; }
+ unsigned GetFileNameOffset() const { return Major <= 2 ? 3 : (Major == 3 ? 5 : 8); }
+ unsigned GetSymLinkOffset() const { return Major <= 1 ? 5: (Major <= 2 ? 6: (Major == 3 ? 18 : 24)); }
+ unsigned GetSpecGuidIndex() const { return Major <= 1 ? 0xF: 0xFF; }
+};
+
+static const UInt32 kFrag_Empty = (UInt32)(Int32)-1;
+// static const UInt32 kXattr_Empty = (UInt32)(Int32)-1;
+
+struct CNode
+{
+ UInt16 Type;
+ UInt16 Mode;
+ UInt16 Uid;
+ UInt16 Gid;
+ UInt32 Frag;
+ UInt32 Offset;
+ // UInt32 MTime;
+ // UInt32 Number;
+ // UInt32 NumLinks;
+ // UInt32 RDev;
+ // UInt32 Xattr;
+ // UInt32 Parent;
+
+ UInt64 FileSize;
+ UInt64 StartBlock;
+ // UInt64 Sparse;
+
+ UInt32 Parse1(const Byte *p, UInt32 size, const CHeader &_h);
+ UInt32 Parse2(const Byte *p, UInt32 size, const CHeader &_h);
+ UInt32 Parse3(const Byte *p, UInt32 size, const CHeader &_h);
+ UInt32 Parse4(const Byte *p, UInt32 size, const CHeader &_h);
+
+ bool IsDir() const { return (Type == kType_DIR || Type == kType_DIR + 7); }
+ bool IsLink() const { return (Type == kType_LNK || Type == kType_LNK + 7); }
+ UInt64 GetSize() const { return IsDir() ? 0 : FileSize; }
+
+ bool ThereAreFrags() const { return Frag != kFrag_Empty; }
+ UInt64 GetNumBlocks(const CHeader &_h) const
+ {
+ return (FileSize >> _h.BlockSizeLog) +
+ (!ThereAreFrags() && (FileSize & (_h.BlockSize - 1)) != 0);
+ }
+};
+
+UInt32 CNode::Parse1(const Byte *p, UInt32 size, const CHeader &_h)
+{
+ const bool be = _h.be;
+ if (size < 4)
+ return 0;
+ {
+ const UInt32 t = Get16(p);
+ if (be)
+ {
+ Type = (UInt16)(t >> 12);
+ Mode = (UInt16)(t & 0xFFF);
+ Uid = (UInt16)(p[2] >> 4);
+ Gid = (UInt16)(p[2] & 0xF);
+ }
+ else
+ {
+ Type = (UInt16)(t & 0xF);
+ Mode = (UInt16)(t >> 4);
+ Uid = (UInt16)(p[2] & 0xF);
+ Gid = (UInt16)(p[2] >> 4);
+ }
+ }
+
+ // Xattr = kXattr_Empty;
+ // MTime = 0;
+ FileSize = 0;
+ StartBlock = 0;
+ Frag = kFrag_Empty;
+
+ if (Type == 0)
+ {
+ Byte t = p[3];
+ if (be)
+ {
+ Type = (UInt16)(t >> 4);
+ Offset = (UInt16)(t & 0xF);
+ }
+ else
+ {
+ Type = (UInt16)(t & 0xF);
+ Offset = (UInt16)(t >> 4);
+ }
+ return (Type == kType_FIFO || Type == kType_SOCK) ? 4 : 0;
+ }
+
+ Type--;
+ Uid = (UInt16)(Uid + (Type / 5) * 16);
+ Type = (UInt16)((Type % 5) + 1);
+
+ if (Type == kType_FILE)
+ {
+ if (size < 15)
+ return 0;
+ // GET_32 (3, MTime);
+ GET_32 (7, StartBlock);
+ UInt32 t;
+ GET_32 (11, t);
+ FileSize = t;
+ UInt32 numBlocks = t >> _h.BlockSizeLog;
+ if ((t & (_h.BlockSize - 1)) != 0)
+ numBlocks++;
+ UInt32 pos = numBlocks * 2 + 15;
+ return (pos <= size) ? pos : 0;
+ }
+
+ if (Type == kType_DIR)
+ {
+ if (size < 14)
+ return 0;
+ UInt32 t = Get32(p + 3);
+ if (be)
+ {
+ FileSize = t >> 13;
+ Offset = t & 0x1FFF;
+ }
+ else
+ {
+ FileSize = t & 0x7FFFF;
+ Offset = t >> 19;
+ }
+ // GET_32 (7, MTime);
+ GET_32 (10, StartBlock);
+ if (be)
+ StartBlock &= 0xFFFFFF;
+ else
+ StartBlock >>= 8;
+ return 14;
+ }
+
+ if (size < 5)
+ return 0;
+
+ if (Type == kType_LNK)
+ {
+ UInt32 len;
+ GET_16 (3, len);
+ FileSize = len;
+ len += 5;
+ return (len <= size) ? len : 0;
+ }
+
+ // GET_32 (3, RDev);
+ return 5;
+}
+
+UInt32 CNode::Parse2(const Byte *p, UInt32 size, const CHeader &_h)
+{
+ const bool be = _h.be;
+ if (size < 4)
+ return 0;
+ {
+ const UInt32 t = Get16(p);
+ if (be)
+ {
+ Type = (UInt16)(t >> 12);
+ Mode = (UInt16)(t & 0xFFF);
+ }
+ else
+ {
+ Type = (UInt16)(t & 0xF);
+ Mode = (UInt16)(t >> 4);
+ }
+ }
+
+ Uid = p[2];
+ Gid = p[3];
+
+ // Xattr = kXattr_Empty;
+
+ if (Type == kType_FILE)
+ {
+ if (size < 24)
+ return 0;
+ // GET_32 (4, MTime);
+ GET_32 (8, StartBlock);
+ GET_32 (12, Frag);
+ GET_32 (16, Offset);
+ UInt32 t;
+ GET_32 (20, t);
+ FileSize = t;
+ UInt32 numBlocks = t >> _h.BlockSizeLog;
+ if (!ThereAreFrags() && (t & (_h.BlockSize - 1)) != 0)
+ numBlocks++;
+ UInt32 pos = numBlocks * 4 + 24;
+ return (pos <= size) ? (UInt32)pos : 0;
+ }
+
+ FileSize = 0;
+ // MTime = 0;
+ StartBlock = 0;
+ Frag = kFrag_Empty;
+
+ if (Type == kType_DIR)
+ {
+ if (size < 15)
+ return 0;
+ UInt32 t = Get32(p + 4);
+ if (be)
+ {
+ FileSize = t >> 13;
+ Offset = t & 0x1FFF;
+ }
+ else
+ {
+ FileSize = t & 0x7FFFF;
+ Offset = t >> 19;
+ }
+ // GET_32 (8, MTime);
+ GET_32 (11, StartBlock);
+ if (be)
+ StartBlock &= 0xFFFFFF;
+ else
+ StartBlock >>= 8;
+ return 15;
+ }
+
+ if (Type == kType_DIR + 7)
+ {
+ if (size < 18)
+ return 0;
+ UInt32 t = Get32(p + 4);
+ UInt32 t2 = Get16(p + 7);
+ if (be)
+ {
+ FileSize = t >> 5;
+ Offset = t2 & 0x1FFF;
+ }
+ else
+ {
+ FileSize = t & 0x7FFFFFF;
+ Offset = t2 >> 3;
+ }
+ // GET_32 (9, MTime);
+ GET_32 (12, StartBlock);
+ if (be)
+ StartBlock &= 0xFFFFFF;
+ else
+ StartBlock >>= 8;
+ UInt32 iCount;
+ GET_16 (16, iCount);
+ UInt32 pos = 18;
+ for (UInt32 i = 0; i < iCount; i++)
+ {
+ // 27 bits: index
+ // 29 bits: startBlock
+ if (pos + 8 > size)
+ return 0;
+ pos += 8 + (UInt32)p[pos + 7] + 1; // nameSize
+ if (pos > size)
+ return 0;
+ }
+ return pos;
+ }
+
+ if (Type == kType_FIFO || Type == kType_SOCK)
+ return 4;
+
+ if (size < 6)
+ return 0;
+
+ if (Type == kType_LNK)
+ {
+ UInt32 len;
+ GET_16 (4, len);
+ FileSize = len;
+ len += 6;
+ return (len <= size) ? len : 0;
+ }
+
+ if (Type == kType_BLK || Type == kType_CHR)
+ {
+ // GET_16 (4, RDev);
+ return 6;
+ }
+
+ return 0;
+}
+
+UInt32 CNode::Parse3(const Byte *p, UInt32 size, const CHeader &_h)
+{
+ const bool be = _h.be;
+ if (size < 12)
+ return 0;
+
+ {
+ const UInt32 t = Get16(p);
+ if (be)
+ {
+ Type = (UInt16)(t >> 12);
+ Mode = (UInt16)(t & 0xFFF);
+ }
+ else
+ {
+ Type = (UInt16)(t & 0xF);
+ Mode = (UInt16)(t >> 4);
+ }
+ }
+
+ Uid = p[2];
+ Gid = p[3];
+ // GET_32 (4, MTime);
+ // GET_32 (8, Number);
+ // Xattr = kXattr_Empty;
+ FileSize = 0;
+ StartBlock = 0;
+
+ if (Type == kType_FILE || Type == kType_FILE + 7)
+ {
+ UInt32 offset;
+ if (Type == kType_FILE)
+ {
+ if (size < 32)
+ return 0;
+ GET_64 (12, StartBlock);
+ GET_32 (20, Frag);
+ GET_32 (24, Offset);
+ GET_32 (28, FileSize);
+ offset = 32;
+ }
+ else
+ {
+ if (size < 40)
+ return 0;
+ // GET_32 (12, NumLinks);
+ GET_64 (16, StartBlock);
+ GET_32 (24, Frag);
+ GET_32 (28, Offset);
+ GET_64 (32, FileSize);
+ offset = 40;
+ }
+ UInt64 pos = GetNumBlocks(_h) * 4 + offset;
+ return (pos <= size) ? (UInt32)pos : 0;
+ }
+
+ if (size < 16)
+ return 0;
+ // GET_32 (12, NumLinks);
+
+ if (Type == kType_DIR)
+ {
+ if (size < 28)
+ return 0;
+ UInt32 t = Get32(p + 16);
+ if (be)
+ {
+ FileSize = t >> 13;
+ Offset = t & 0x1FFF;
+ }
+ else
+ {
+ FileSize = t & 0x7FFFF;
+ Offset = t >> 19;
+ }
+ GET_32 (20, StartBlock);
+ // GET_32 (24, Parent);
+ return 28;
+ }
+
+ if (Type == kType_DIR + 7)
+ {
+ if (size < 31)
+ return 0;
+ UInt32 t = Get32(p + 16);
+ UInt32 t2 = Get16(p + 19);
+ if (be)
+ {
+ FileSize = t >> 5;
+ Offset = t2 & 0x1FFF;
+ }
+ else
+ {
+ FileSize = t & 0x7FFFFFF;
+ Offset = t2 >> 3;
+ }
+ GET_32 (21, StartBlock);
+ UInt32 iCount;
+ GET_16 (25, iCount);
+ // GET_32 (27, Parent);
+ UInt32 pos = 31;
+ for (UInt32 i = 0; i < iCount; i++)
+ {
+ // UInt32 index
+ // UInt32 startBlock
+ if (pos + 9 > size)
+ return 0;
+ pos += 9 + (unsigned)p[pos + 8] + 1; // nameSize
+ if (pos > size)
+ return 0;
+ }
+ return pos;
+ }
+
+ if (Type == kType_FIFO || Type == kType_SOCK)
+ return 16;
+
+ if (size < 18)
+ return 0;
+ if (Type == kType_LNK)
+ {
+ UInt32 len;
+ GET_16 (16, len);
+ FileSize = len;
+ len += 18;
+ return (len <= size) ? len : 0;
+ }
+
+ if (Type == kType_BLK || Type == kType_CHR)
+ {
+ // GET_16 (16, RDev);
+ return 18;
+ }
+
+ return 0;
+}
+
+UInt32 CNode::Parse4(const Byte *p, UInt32 size, const CHeader &_h)
+{
+ if (size < 20)
+ return 0;
+ LE_16 (0, Type);
+ LE_16 (2, Mode);
+ LE_16 (4, Uid);
+ LE_16 (6, Gid);
+ // LE_32 (8, MTime);
+ // LE_32 (12, Number);
+
+ // Xattr = kXattr_Empty;
+ FileSize = 0;
+ StartBlock = 0;
+
+ if (Type == kType_FILE || Type == kType_FILE + 7)
+ {
+ UInt32 offset;
+ if (Type == kType_FILE)
+ {
+ if (size < 32)
+ return 0;
+ LE_32 (16, StartBlock);
+ LE_32 (20, Frag);
+ LE_32 (24, Offset);
+ LE_32 (28, FileSize);
+ offset = 32;
+ }
+ else
+ {
+ if (size < 56)
+ return 0;
+ LE_64 (16, StartBlock);
+ LE_64 (24, FileSize);
+ // LE_64 (32, Sparse);
+ // LE_32 (40, NumLinks);
+ LE_32 (44, Frag);
+ LE_32 (48, Offset);
+ // LE_32 (52, Xattr);
+ offset = 56;
+ }
+ UInt64 pos = GetNumBlocks(_h) * 4 + offset;
+ return (pos <= size) ? (UInt32)pos : 0;
+ }
+
+ if (Type == kType_DIR)
+ {
+ if (size < 32)
+ return 0;
+ LE_32 (16, StartBlock);
+ // LE_32 (20, NumLinks);
+ LE_16 (24, FileSize);
+ LE_16 (26, Offset);
+ // LE_32 (28, Parent);
+ return 32;
+ }
+
+ // LE_32 (16, NumLinks);
+
+ if (Type == kType_DIR + 7)
+ {
+ if (size < 40)
+ return 0;
+ LE_32 (20, FileSize);
+ LE_32 (24, StartBlock);
+ // LE_32 (28, Parent);
+ UInt32 iCount;
+ LE_16 (32, iCount);
+ LE_16 (34, Offset);
+ // LE_32 (36, Xattr);
+
+ UInt32 pos = 40;
+ for (UInt32 i = 0; i < iCount; i++)
+ {
+ // UInt32 index
+ // UInt32 startBlock
+ if (pos + 12 > size)
+ return 0;
+ UInt32 nameLen = GetUi32(p + pos + 8);
+ pos += 12 + nameLen + 1;
+ if (pos > size || nameLen > (1 << 10))
+ return 0;
+ }
+ return pos;
+ }
+
+ unsigned offset = 20;
+ switch (Type)
+ {
+ case kType_FIFO: case kType_FIFO + 7:
+ case kType_SOCK: case kType_SOCK + 7:
+ break;
+ case kType_LNK: case kType_LNK + 7:
+ {
+ if (size < 24)
+ return 0;
+ UInt32 len;
+ LE_32 (20, len);
+ FileSize = len;
+ offset = len + 24;
+ if (size < offset || len > (1 << 30))
+ return 0;
+ break;
+ }
+ case kType_BLK: case kType_BLK + 7:
+ case kType_CHR: case kType_CHR + 7:
+ if (size < 24)
+ return 0;
+ // LE_32 (20, RDev);
+ offset = 24;
+ break;
+ default:
+ return 0;
+ }
+
+ if (Type >= 8)
+ {
+ if (size < offset + 4)
+ return 0;
+ // LE_32 (offset, Xattr);
+ offset += 4;
+ }
+ return offset;
+}
+
+struct CItem
+{
+ int Node;
+ int Parent;
+ UInt32 Ptr;
+
+ CItem(): Node(-1), Parent(-1), Ptr(0) {}
+};
+
+struct CData
+{
+ CByteBuffer Data;
+ CRecordVector<UInt32> PackPos;
+ CRecordVector<UInt32> UnpackPos; // additional item at the end contains TotalUnpackSize
+
+ UInt32 GetNumBlocks() const { return PackPos.Size(); }
+ void Clear()
+ {
+ Data.Free();
+ PackPos.Clear();
+ UnpackPos.Clear();
+ }
+};
+
+struct CFrag
+{
+ UInt64 StartBlock;
+ UInt32 Size;
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CRecordVector<CItem> _items;
+ CRecordVector<CNode> _nodes;
+ CRecordVector<UInt32> _nodesPos;
+ CRecordVector<UInt32> _blockToNode;
+ CData _inodesData;
+ CData _dirs;
+ CRecordVector<CFrag> _frags;
+ CByteBuffer _uids;
+ CByteBuffer _gids;
+ CHeader _h;
+ bool _noPropsLZMA;
+ bool _needCheckLzma;
+
+ UInt32 _openCodePage;
+
+ CMyComPtr<IInStream> _stream;
+ UInt64 _sizeCalculated;
+
+ IArchiveOpenCallback *_openCallback;
+
+ int _nodeIndex;
+ CRecordVector<bool> _blockCompressed;
+ CRecordVector<UInt64> _blockOffsets;
+
+ CByteBuffer _cachedBlock;
+ UInt64 _cachedBlockStartPos;
+ UInt32 _cachedPackBlockSize;
+ UInt32 _cachedUnpackBlockSize;
+
+ CLimitedSequentialInStream *_limitedInStreamSpec;
+ CMyComPtr<ISequentialInStream> _limitedInStream;
+
+ CBufPtrSeqOutStream *_outStreamSpec;
+ CMyComPtr<ISequentialOutStream> _outStream;
+
+ // NCompress::NLzma::CDecoder *_lzmaDecoderSpec;
+ // CMyComPtr<ICompressCoder> _lzmaDecoder;
+
+ NCompress::NZlib::CDecoder *_zlibDecoderSpec;
+ CMyComPtr<ICompressCoder> _zlibDecoder;
+
+ CXzUnpacker _xz;
+
+ CByteBuffer _inputBuffer;
+
+ CDynBufSeqOutStream *_dynOutStreamSpec;
+ CMyComPtr<ISequentialOutStream> _dynOutStream;
+
+ void ClearCache()
+ {
+ _cachedBlockStartPos = 0;
+ _cachedPackBlockSize = 0;
+ _cachedUnpackBlockSize = 0;
+ }
+
+ HRESULT Seek2(UInt64 offset)
+ {
+ return InStream_SeekSet(_stream, offset);
+ }
+
+ HRESULT Decompress(ISequentialOutStream *outStream, Byte *outBuf, bool *outBufWasWritten, UInt32 *outBufWasWrittenSize,
+ UInt32 inSize, UInt32 outSizeMax);
+ HRESULT ReadMetadataBlock(UInt32 &packSize);
+ HRESULT ReadMetadataBlock2();
+ HRESULT ReadData(CData &data, UInt64 start, UInt64 end);
+
+ HRESULT OpenDir(int parent, UInt32 startBlock, UInt32 offset, unsigned level, int &nodeIndex);
+ HRESULT ScanInodes(UInt64 ptr);
+ HRESULT ReadUids(UInt64 start, UInt32 num, CByteBuffer &ids);
+ HRESULT Open2(IInStream *inStream);
+ AString GetPath(unsigned index) const;
+ bool GetPackSize(unsigned index, UInt64 &res, bool fillOffsets);
+
+public:
+ CHandler();
+ ~CHandler()
+ {
+ XzUnpacker_Free(&_xz);
+ }
+
+ HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize);
+};
+
+
+CHandler::CHandler()
+{
+ XzUnpacker_Construct(&_xz, &g_Alloc);
+
+ _limitedInStreamSpec = new CLimitedSequentialInStream;
+ _limitedInStream = _limitedInStreamSpec;
+
+ _outStreamSpec = new CBufPtrSeqOutStream();
+ _outStream = _outStreamSpec;
+
+ _dynOutStreamSpec = new CDynBufSeqOutStream;
+ _dynOutStream = _dynOutStreamSpec;
+}
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidPosixAttrib,
+ kpidUserId,
+ kpidGroupId
+ // kpidLinks,
+ // kpidOffset
+};
+
+static const Byte kArcProps[] =
+{
+ kpidHeadersSize,
+ kpidFileSystem,
+ kpidMethod,
+ kpidClusterSize,
+ kpidBigEndian,
+ kpidCTime,
+ kpidCharacts,
+ kpidCodePage
+ // kpidNumBlocks
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static HRESULT LzoDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen)
+{
+ SizeT destRem = *destLen;
+ SizeT srcRem = *srcLen;
+ *destLen = 0;
+ *srcLen = 0;
+ const Byte *destStart = dest;
+ const Byte *srcStart = src;
+ unsigned mode = 0;
+
+ {
+ if (srcRem == 0)
+ return S_FALSE;
+ UInt32 b = *src;
+ if (b > 17)
+ {
+ src++;
+ srcRem--;
+ b -= 17;
+ mode = (b < 4 ? 1 : 4);
+ if (b > srcRem || b > destRem)
+ return S_FALSE;
+ srcRem -= b;
+ destRem -= b;
+ do
+ *dest++ = *src++;
+ while (--b);
+ }
+ }
+
+ for (;;)
+ {
+ if (srcRem < 3)
+ return S_FALSE;
+ UInt32 b = *src++;
+ srcRem--;
+ UInt32 len, back;
+
+ if (b >= 64)
+ {
+ srcRem--;
+ back = ((b >> 2) & 7) + ((UInt32)*src++ << 3);
+ len = (b >> 5) + 1;
+ }
+ else if (b < 16)
+ {
+ if (mode == 0)
+ {
+ if (b == 0)
+ {
+ for (b = 15;; b += 255)
+ {
+ if (srcRem == 0)
+ return S_FALSE;
+ UInt32 b2 = *src++;
+ srcRem--;
+ if (b2 != 0)
+ {
+ b += b2;
+ break;
+ }
+ }
+ }
+
+ b += 3;
+ if (b > srcRem || b > destRem)
+ return S_FALSE;
+ srcRem -= b;
+ destRem -= b;
+ mode = 4;
+ do
+ *dest++ = *src++;
+ while (--b);
+ continue;
+ }
+
+ srcRem--;
+ back = (b >> 2) + ((UInt32)*src++ << 2);
+ len = 2;
+ if (mode == 4)
+ {
+ back += (1 << 11);
+ len = 3;
+ }
+ }
+ else
+ {
+ UInt32 bOld = b;
+ b = (b < 32 ? 7 : 31);
+ len = bOld & b;
+
+ if (len == 0)
+ {
+ for (len = b;; len += 255)
+ {
+ if (srcRem == 0)
+ return S_FALSE;
+ UInt32 b2 = *src++;
+ srcRem--;
+ if (b2 != 0)
+ {
+ len += b2;
+ break;
+ }
+ }
+ }
+
+ len += 2;
+ if (srcRem < 2)
+ return S_FALSE;
+ b = *src;
+ back = (b >> 2) + ((UInt32)src[1] << 6);
+ src += 2;
+ srcRem -= 2;
+ if (bOld < 32)
+ {
+ back += ((bOld & 8) << 11);
+ if (back == 0)
+ {
+ *destLen = (size_t)(dest - destStart);
+ *srcLen = (size_t)(src - srcStart);
+ return S_OK;
+ }
+ back += (1 << 14) - 1;
+ }
+ }
+
+ back++;
+ if (len > destRem || (size_t)(dest - destStart) < back)
+ return S_FALSE;
+ destRem -= len;
+ Byte *destTemp = dest - back;
+ dest += len;
+
+ do
+ {
+ *(destTemp + back) = *destTemp;
+ destTemp++;
+ }
+ while (--len);
+
+ b &= 3;
+ mode = b;
+ if (b == 0)
+ continue;
+ if (b > srcRem || b > destRem)
+ return S_FALSE;
+ srcRem -= b;
+ destRem -= b;
+ *dest++ = *src++;
+ if (b > 1)
+ {
+ *dest++ = *src++;
+ if (b > 2)
+ *dest++ = *src++;
+ }
+ }
+}
+
+HRESULT CHandler::Decompress(ISequentialOutStream *outStream, Byte *outBuf, bool *outBufWasWritten, UInt32 *outBufWasWrittenSize, UInt32 inSize, UInt32 outSizeMax)
+{
+ if (outBuf)
+ {
+ *outBufWasWritten = false;
+ *outBufWasWrittenSize = 0;
+ }
+ UInt32 method = _h.Method;
+ if (_h.SeveralMethods)
+ {
+ Byte b;
+ RINOK(ReadStream_FALSE(_stream, &b, 1))
+ RINOK(_stream->Seek(-1, STREAM_SEEK_CUR, NULL))
+ method = (b == 0x5D ? kMethod_LZMA : kMethod_ZLIB);
+ }
+
+ if (method == kMethod_ZLIB && _needCheckLzma)
+ {
+ Byte b;
+ RINOK(ReadStream_FALSE(_stream, &b, 1))
+ RINOK(_stream->Seek(-1, STREAM_SEEK_CUR, NULL))
+ if (b == 0)
+ {
+ _noPropsLZMA = true;
+ method = _h.Method = kMethod_LZMA;
+ }
+ _needCheckLzma = false;
+ }
+
+ if (method == kMethod_ZLIB)
+ {
+ if (!_zlibDecoder)
+ {
+ _zlibDecoderSpec = new NCompress::NZlib::CDecoder();
+ _zlibDecoder = _zlibDecoderSpec;
+ }
+ RINOK(_zlibDecoder->Code(_limitedInStream, outStream, NULL, NULL, NULL))
+ if (inSize != _zlibDecoderSpec->GetInputProcessedSize())
+ return S_FALSE;
+ }
+ /*
+ else if (method == kMethod_LZMA)
+ {
+ if (!_lzmaDecoder)
+ {
+ _lzmaDecoderSpec = new NCompress::NLzma::CDecoder();
+ // _lzmaDecoderSpec->FinishStream = true;
+ _lzmaDecoder = _lzmaDecoderSpec;
+ }
+ const UInt32 kPropsSize = LZMA_PROPS_SIZE + 8;
+ Byte props[kPropsSize];
+ UInt32 propsSize;
+ UInt64 outSize;
+ if (_noPropsLZMA)
+ {
+ props[0] = 0x5D;
+ SetUi32(&props[1], _h.BlockSize);
+ propsSize = 0;
+ outSize = outSizeMax;
+ }
+ else
+ {
+ RINOK(ReadStream_FALSE(_limitedInStream, props, kPropsSize));
+ propsSize = kPropsSize;
+ outSize = GetUi64(&props[LZMA_PROPS_SIZE]);
+ if (outSize > outSizeMax)
+ return S_FALSE;
+ }
+ RINOK(_lzmaDecoderSpec->SetDecoderProperties2(props, LZMA_PROPS_SIZE));
+ RINOK(_lzmaDecoder->Code(_limitedInStream, outStream, NULL, &outSize, NULL));
+ if (inSize != propsSize + _lzmaDecoderSpec->GetInputProcessedSize())
+ return S_FALSE;
+ }
+ */
+ else
+ {
+ if (_inputBuffer.Size() < inSize)
+ _inputBuffer.Alloc(inSize);
+ RINOK(ReadStream_FALSE(_stream, _inputBuffer, inSize))
+
+ Byte *dest = outBuf;
+ if (!outBuf)
+ {
+ dest = _dynOutStreamSpec->GetBufPtrForWriting(outSizeMax);
+ if (!dest)
+ return E_OUTOFMEMORY;
+ }
+
+ SizeT destLen = outSizeMax, srcLen = inSize;
+
+ if (method == kMethod_LZO)
+ {
+ RINOK(LzoDecode(dest, &destLen, _inputBuffer, &srcLen))
+ }
+ else if (method == kMethod_LZMA)
+ {
+ Byte props[5];
+ const Byte *src = _inputBuffer;
+
+ if (_noPropsLZMA)
+ {
+ props[0] = 0x5D;
+ SetUi32(&props[1], _h.BlockSize)
+ }
+ else
+ {
+ const UInt32 kPropsSize = LZMA_PROPS_SIZE + 8;
+ if (inSize < kPropsSize)
+ return S_FALSE;
+ memcpy(props, src, LZMA_PROPS_SIZE);
+ UInt64 outSize = GetUi64(src + LZMA_PROPS_SIZE);
+ if (outSize > outSizeMax)
+ return S_FALSE;
+ destLen = (SizeT)outSize;
+ src += kPropsSize;
+ inSize -= kPropsSize;
+ srcLen = inSize;
+ }
+
+ ELzmaStatus status;
+ SRes res = LzmaDecode(dest, &destLen,
+ src, &srcLen,
+ props, LZMA_PROPS_SIZE,
+ LZMA_FINISH_END,
+ &status, &g_Alloc);
+ if (res != 0)
+ return SResToHRESULT(res);
+ if (status != LZMA_STATUS_FINISHED_WITH_MARK
+ && status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+ return S_FALSE;
+ }
+ else
+ {
+ ECoderStatus status;
+ SRes res = XzUnpacker_CodeFull(&_xz,
+ dest, &destLen,
+ _inputBuffer, &srcLen,
+ CODER_FINISH_END, &status);
+ if (res != 0)
+ return SResToHRESULT(res);
+ if (status != CODER_STATUS_NEEDS_MORE_INPUT || !XzUnpacker_IsStreamWasFinished(&_xz))
+ return S_FALSE;
+ }
+
+ if (inSize != srcLen)
+ return S_FALSE;
+ if (outBuf)
+ {
+ *outBufWasWritten = true;
+ *outBufWasWrittenSize = (UInt32)destLen;
+ }
+ else
+ _dynOutStreamSpec->UpdateSize(destLen);
+ }
+ return S_OK;
+}
+
+HRESULT CHandler::ReadMetadataBlock(UInt32 &packSize)
+{
+ Byte temp[3];
+ const unsigned offset = _h.NeedCheckData() ? 3 : 2;
+ if (offset > packSize)
+ return S_FALSE;
+ RINOK(ReadStream_FALSE(_stream, temp, offset))
+ // if (NeedCheckData && Major < 4) checkByte must be = 0xFF
+ const bool be = _h.be;
+ UInt32 size = Get16(temp);
+ const bool isCompressed = ((size & kNotCompressedBit16) == 0);
+ if (size != kNotCompressedBit16)
+ size &= ~kNotCompressedBit16;
+
+ if (size > kMetadataBlockSize || offset + size > packSize)
+ return S_FALSE;
+ packSize = offset + size;
+ if (isCompressed)
+ {
+ _limitedInStreamSpec->Init(size);
+ RINOK(Decompress(_dynOutStream, NULL, NULL, NULL, size, kMetadataBlockSize))
+ }
+ else
+ {
+ // size != 0 here
+ Byte *buf = _dynOutStreamSpec->GetBufPtrForWriting(size);
+ if (!buf)
+ return E_OUTOFMEMORY;
+ RINOK(ReadStream_FALSE(_stream, buf, size))
+ _dynOutStreamSpec->UpdateSize(size);
+ }
+ return S_OK;
+}
+
+
+HRESULT CHandler::ReadMetadataBlock2()
+{
+ _dynOutStreamSpec->Init();
+ UInt32 packSize = kMetadataBlockSize + 3; // check it
+ return ReadMetadataBlock(packSize);
+}
+
+HRESULT CHandler::ReadData(CData &data, UInt64 start, UInt64 end)
+{
+ if (end < start || end - start >= ((UInt64)1 << 32))
+ return S_FALSE;
+ const UInt32 size = (UInt32)(end - start);
+ RINOK(Seek2(start))
+ _dynOutStreamSpec->Init();
+ UInt32 packPos = 0;
+ while (packPos != size)
+ {
+ data.PackPos.Add(packPos);
+ data.UnpackPos.Add((UInt32)_dynOutStreamSpec->GetSize());
+ if (packPos > size)
+ return S_FALSE;
+ UInt32 packSize = size - packPos;
+ RINOK(ReadMetadataBlock(packSize))
+ {
+ const size_t tSize = _dynOutStreamSpec->GetSize();
+ if (tSize != (UInt32)tSize)
+ return S_FALSE;
+ }
+ packPos += packSize;
+ }
+ data.UnpackPos.Add((UInt32)_dynOutStreamSpec->GetSize());
+ _dynOutStreamSpec->CopyToBuffer(data.Data);
+ return S_OK;
+}
+
+struct CTempItem
+{
+ UInt32 StartBlock;
+ // UInt32 iNodeNumber1;
+ UInt32 Offset;
+ // UInt16 iNodeNumber2;
+ UInt16 Type;
+};
+
+HRESULT CHandler::OpenDir(int parent, UInt32 startBlock, UInt32 offset, unsigned level, int &nodeIndex)
+{
+ if (level > kNumDirLevelsMax)
+ return S_FALSE;
+
+ int blockIndex = _inodesData.PackPos.FindInSorted(startBlock);
+ if (blockIndex < 0)
+ return S_FALSE;
+ UInt32 unpackPos = _inodesData.UnpackPos[blockIndex] + offset;
+ if (unpackPos < offset)
+ return S_FALSE;
+
+ nodeIndex = _nodesPos.FindInSorted(unpackPos, _blockToNode[blockIndex], _blockToNode[blockIndex + 1]);
+ // nodeIndex = _nodesPos.FindInSorted(unpackPos);
+ if (nodeIndex < 0)
+ return S_FALSE;
+
+ const CNode &n = _nodes[nodeIndex];
+ if (!n.IsDir())
+ return S_OK;
+ blockIndex = _dirs.PackPos.FindInSorted((UInt32)n.StartBlock);
+ if (blockIndex < 0)
+ return S_FALSE;
+ unpackPos = _dirs.UnpackPos[blockIndex] + n.Offset;
+ if (unpackPos < n.Offset || unpackPos > _dirs.Data.Size())
+ return S_FALSE;
+
+ UInt32 rem = (UInt32)_dirs.Data.Size() - unpackPos;
+ const Byte *p = _dirs.Data + unpackPos;
+ UInt32 fileSize = (UInt32)n.FileSize;
+
+ // for some squashfs files: fileSize = rem + 3 !!!
+ if (_h.Major >= 3)
+ {
+ if (fileSize < 3)
+ return S_FALSE;
+ fileSize -= 3;
+ }
+ if (fileSize > rem)
+ return S_FALSE;
+ rem = fileSize;
+
+ AString tempString;
+
+ CRecordVector<CTempItem> tempItems;
+ while (rem != 0)
+ {
+ const bool be = _h.be;
+ UInt32 count;
+ CTempItem tempItem;
+ if (_h.Major <= 2)
+ {
+ if (rem < 4)
+ return S_FALSE;
+ count = p[0];
+ tempItem.StartBlock = Get32(p);
+ if (be)
+ tempItem.StartBlock &= 0xFFFFFF;
+ else
+ tempItem.StartBlock >>= 8;
+ p += 4;
+ rem -= 4;
+ }
+ else
+ {
+ if (_h.Major == 3)
+ {
+ if (rem < 9)
+ return S_FALSE;
+ count = p[0];
+ p += 1;
+ rem -= 1;
+ }
+ else
+ {
+ if (rem < 12)
+ return S_FALSE;
+ count = GetUi32(p);
+ p += 4;
+ rem -= 4;
+ }
+ GET_32 (0, tempItem.StartBlock);
+ // GET_32 (4, tempItem.iNodeNumber1);
+ p += 8;
+ rem -= 8;
+ }
+ count++;
+
+ for (UInt32 i = 0; i < count; i++)
+ {
+ if (rem == 0)
+ return S_FALSE;
+
+ UInt32 nameOffset = _h.GetFileNameOffset();
+ if (rem < nameOffset)
+ return S_FALSE;
+
+ if ((UInt32)_items.Size() >= kNumFilesMax)
+ return S_FALSE;
+ if (_openCallback)
+ {
+ UInt64 numFiles = _items.Size();
+ if ((numFiles & 0xFFFF) == 0)
+ {
+ RINOK(_openCallback->SetCompleted(&numFiles, NULL))
+ }
+ }
+
+ CItem item;
+ item.Ptr = (UInt32)(p - (const Byte *)_dirs.Data);
+
+ UInt32 size;
+ if (_h.IsOldVersion())
+ {
+ UInt32 t = Get16(p);
+ if (be)
+ {
+ tempItem.Offset = t >> 3;
+ tempItem.Type = (UInt16)(t & 0x7);
+ }
+ else
+ {
+ tempItem.Offset = t & 0x1FFF;
+ tempItem.Type = (UInt16)(t >> 13);
+ }
+ size = (UInt32)p[2];
+ /*
+ if (_h.Major > 2)
+ tempItem.iNodeNumber2 = Get16(p + 3);
+ */
+ }
+ else
+ {
+ GET_16 (0, tempItem.Offset);
+ // GET_16 (2, tempItem.iNodeNumber2);
+ GET_16 (4, tempItem.Type);
+ GET_16 (6, size);
+ }
+ p += nameOffset;
+ rem -= nameOffset;
+ size++;
+ if (rem < size)
+ return S_FALSE;
+
+ if (_openCodePage == CP_UTF8)
+ {
+ tempString.SetFrom_CalcLen((const char *)p, size);
+ if (!CheckUTF8_AString(tempString))
+ _openCodePage = CP_OEMCP;
+ }
+
+ p += size;
+ rem -= size;
+ item.Parent = parent;
+ _items.Add(item);
+ tempItems.Add(tempItem);
+ }
+ }
+
+ const unsigned startItemIndex = _items.Size() - tempItems.Size();
+ FOR_VECTOR (i, tempItems)
+ {
+ const CTempItem &tempItem = tempItems[i];
+ const unsigned index = startItemIndex + i;
+ CItem &item = _items[index];
+ RINOK(OpenDir((int)index, tempItem.StartBlock, tempItem.Offset, level + 1, item.Node))
+ }
+
+ return S_OK;
+}
+
+HRESULT CHandler::ReadUids(UInt64 start, UInt32 num, CByteBuffer &ids)
+{
+ const size_t size = (size_t)num * 4;
+ ids.Alloc(size);
+ if (num == 0)
+ return S_OK;
+ RINOK(Seek2(start))
+ return ReadStream_FALSE(_stream, ids, size);
+}
+
+HRESULT CHandler::Open2(IInStream *inStream)
+{
+ {
+ Byte buf[kHeaderSize3];
+ RINOK(ReadStream_FALSE(inStream, buf, kHeaderSize3))
+ if (!_h.Parse(buf))
+ return S_FALSE;
+ if (!_h.IsSupported())
+ return E_NOTIMPL;
+
+ _noPropsLZMA = false;
+ _needCheckLzma = false;
+ switch (_h.Method)
+ {
+ case kMethod_ZLIB: _needCheckLzma = true; break;
+ case kMethod_LZMA:
+ case kMethod_LZO:
+ case kMethod_XZ:
+ break;
+ default:
+ return E_NOTIMPL;
+ }
+ }
+
+ _stream = inStream;
+
+ if (_h.NumFrags != 0)
+ {
+ if (_h.NumFrags > kNumFilesMax)
+ return S_FALSE;
+ _frags.ClearAndReserve(_h.NumFrags);
+ const unsigned bigFrag = (_h.Major > 2);
+
+ const unsigned fragPtrsInBlockLog = kMetadataBlockSizeLog - (3 + bigFrag);
+ const UInt32 numBlocks = (_h.NumFrags + (1 << fragPtrsInBlockLog) - 1) >> fragPtrsInBlockLog;
+ const size_t numBlocksBytes = (size_t)numBlocks << (2 + bigFrag);
+ CByteBuffer data(numBlocksBytes);
+ RINOK(Seek2(_h.FragTable))
+ RINOK(ReadStream_FALSE(inStream, data, numBlocksBytes))
+ const bool be = _h.be;
+
+ for (UInt32 i = 0; i < numBlocks; i++)
+ {
+ const UInt64 offset = bigFrag ? Get64(data + i * 8) : Get32(data + i * 4);
+ RINOK(Seek2(offset))
+ RINOK(ReadMetadataBlock2())
+ const UInt32 unpackSize = (UInt32)_dynOutStreamSpec->GetSize();
+ if (unpackSize != kMetadataBlockSize)
+ if (i != numBlocks - 1 || unpackSize != ((_h.NumFrags << (3 + bigFrag)) & (kMetadataBlockSize - 1)))
+ return S_FALSE;
+ const Byte *buf = _dynOutStreamSpec->GetBuffer();
+ for (UInt32 j = 0; j < kMetadataBlockSize && j < unpackSize;)
+ {
+ CFrag frag;
+ if (bigFrag)
+ {
+ frag.StartBlock = Get64(buf + j);
+ frag.Size = Get32(buf + j + 8);
+ // some archives contain nonzero in unused (buf + j + 12)
+ j += 16;
+ }
+ else
+ {
+ frag.StartBlock = Get32(buf + j);
+ frag.Size = Get32(buf + j + 4);
+ j += 8;
+ }
+ _frags.Add(frag);
+ }
+ }
+ if ((UInt32)_frags.Size() != _h.NumFrags)
+ return S_FALSE;
+ }
+
+ RINOK(ReadData(_inodesData, _h.InodeTable, _h.DirTable))
+ RINOK(ReadData(_dirs, _h.DirTable, _h.FragTable))
+
+ UInt64 absOffset = _h.RootInode >> 16;
+ if (absOffset >= ((UInt64)1 << 32))
+ return S_FALSE;
+ {
+ UInt32 pos = 0;
+ UInt32 totalSize = (UInt32)_inodesData.Data.Size();
+ const unsigned kMinNodeParseSize = 4;
+ if (_h.NumInodes > totalSize / kMinNodeParseSize)
+ return S_FALSE;
+ _nodesPos.ClearAndReserve(_h.NumInodes);
+ _nodes.ClearAndReserve(_h.NumInodes);
+ // we use _blockToNode for binary search seed optimizations
+ _blockToNode.ClearAndReserve(_inodesData.GetNumBlocks() + 1);
+ unsigned curBlock = 0;
+ for (UInt32 i = 0; i < _h.NumInodes; i++)
+ {
+ CNode n;
+ const Byte *p = _inodesData.Data + pos;
+ UInt32 size = totalSize - pos;
+
+ switch (_h.Major)
+ {
+ case 1: size = n.Parse1(p, size, _h); break;
+ case 2: size = n.Parse2(p, size, _h); break;
+ case 3: size = n.Parse3(p, size, _h); break;
+ default: size = n.Parse4(p, size, _h); break;
+ }
+ if (size == 0)
+ return S_FALSE;
+ while (pos >= _inodesData.UnpackPos[curBlock])
+ {
+ _blockToNode.Add(_nodesPos.Size());
+ curBlock++;
+ }
+ _nodesPos.AddInReserved(pos);
+ _nodes.AddInReserved(n);
+ pos += size;
+ }
+ _blockToNode.Add(_nodesPos.Size());
+ if (pos != totalSize)
+ return S_FALSE;
+ }
+ int rootNodeIndex;
+ RINOK(OpenDir(-1, (UInt32)absOffset, (UInt32)_h.RootInode & 0xFFFF, 0, rootNodeIndex))
+
+ if (_h.Major < 4)
+ {
+ RINOK(ReadUids(_h.UidTable, _h.NumUids, _uids))
+ RINOK(ReadUids(_h.GidTable, _h.NumGids, _gids))
+ }
+ else
+ {
+ const UInt32 size = (UInt32)_h.NumIDs * 4;
+ _uids.Alloc(size);
+
+ const UInt32 numBlocks = (size + kMetadataBlockSize - 1) / kMetadataBlockSize;
+ const UInt32 numBlocksBytes = numBlocks << 3;
+ CByteBuffer data(numBlocksBytes);
+ RINOK(Seek2(_h.UidTable))
+ RINOK(ReadStream_FALSE(inStream, data, numBlocksBytes))
+
+ for (UInt32 i = 0; i < numBlocks; i++)
+ {
+ const UInt64 offset = GetUi64(data + i * 8);
+ RINOK(Seek2(offset))
+ // RINOK(ReadMetadataBlock(NULL, _uids + kMetadataBlockSize * i, packSize, unpackSize));
+ RINOK(ReadMetadataBlock2())
+ const size_t unpackSize = _dynOutStreamSpec->GetSize();
+ const UInt32 remSize = (i == numBlocks - 1) ?
+ (size & (kMetadataBlockSize - 1)) : kMetadataBlockSize;
+ if (unpackSize != remSize)
+ return S_FALSE;
+ memcpy(_uids + kMetadataBlockSize * i, _dynOutStreamSpec->GetBuffer(), remSize);
+ }
+ }
+
+ {
+ const UInt32 alignSize = 1 << 12;
+ Byte buf[alignSize];
+ RINOK(Seek2(_h.Size))
+ UInt32 rem = (UInt32)(0 - _h.Size) & (alignSize - 1);
+ _sizeCalculated = _h.Size;
+ if (rem != 0)
+ {
+ if (ReadStream_FALSE(_stream, buf, rem) == S_OK)
+ {
+ size_t i;
+ for (i = 0; i < rem && buf[i] == 0; i++);
+ if (i == rem)
+ _sizeCalculated = _h.Size + rem;
+ }
+ }
+ }
+ return S_OK;
+}
+
+AString CHandler::GetPath(unsigned index) const
+{
+ unsigned len = 0;
+ const unsigned indexMem = index;
+ const bool be = _h.be;
+ for (;;)
+ {
+ const CItem &item = _items[index];
+ const Byte *p = _dirs.Data + item.Ptr;
+ const unsigned size = (_h.IsOldVersion() ? (unsigned)p[2] : (unsigned)Get16(p + 6)) + 1;
+ p += _h.GetFileNameOffset();
+ unsigned i;
+ for (i = 0; i < size && p[i]; i++);
+ len += i + 1;
+ index = (unsigned)item.Parent;
+ if (item.Parent < 0)
+ break;
+ }
+ len--;
+
+ AString path;
+ char *dest = path.GetBuf_SetEnd(len) + len;
+ index = indexMem;
+ for (;;)
+ {
+ const CItem &item = _items[index];
+ const Byte *p = _dirs.Data + item.Ptr;
+ const unsigned size = (_h.IsOldVersion() ? (unsigned)p[2] : (unsigned)Get16(p + 6)) + 1;
+ p += _h.GetFileNameOffset();
+ unsigned i;
+ for (i = 0; i < size && p[i]; i++);
+ dest -= i;
+ memcpy(dest, p, i);
+ index = (unsigned)item.Parent;
+ if (item.Parent < 0)
+ break;
+ *(--dest) = CHAR_PATH_SEPARATOR;
+ }
+ return path;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ _limitedInStreamSpec->SetStream(stream);
+ HRESULT res;
+ try
+ {
+ _openCallback = callback;
+ res = Open2(stream);
+ }
+ catch(...)
+ {
+ Close();
+ throw;
+ }
+ if (res != S_OK)
+ {
+ Close();
+ return res;
+ }
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _openCodePage = CP_UTF8;
+ _sizeCalculated = 0;
+
+ _limitedInStreamSpec->ReleaseStream();
+ _stream.Release();
+
+ _items.Clear();
+ _nodes.Clear();
+ _nodesPos.Clear();
+ _blockToNode.Clear();
+ _frags.Clear();
+ _inodesData.Clear();
+ _dirs.Clear();
+
+ _uids.Free();
+ _gids.Free();
+
+ _cachedBlock.Free();
+ ClearCache();
+
+ return S_OK;
+}
+
+bool CHandler::GetPackSize(unsigned index, UInt64 &totalPack, bool fillOffsets)
+{
+ totalPack = 0;
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[item.Node];
+ const UInt32 ptr = _nodesPos[item.Node];
+ const Byte *p = _inodesData.Data + ptr;
+ const bool be = _h.be;
+
+ const UInt32 type = node.Type;
+ UInt32 offset;
+ if (node.IsLink() || node.FileSize == 0)
+ {
+ totalPack = node.FileSize;
+ return true;
+ }
+
+ const UInt32 numBlocks = (UInt32)node.GetNumBlocks(_h);
+
+ if (fillOffsets)
+ {
+ _blockOffsets.Clear();
+ _blockCompressed.Clear();
+ _blockOffsets.Add(totalPack);
+ }
+
+ if (_h.Major <= 1)
+ {
+ offset = 15;
+ p += offset;
+
+ for (UInt32 i = 0; i < numBlocks; i++)
+ {
+ UInt32 t = Get16(p + i * 2);
+ if (fillOffsets)
+ _blockCompressed.Add((t & kNotCompressedBit16) == 0);
+ if (t != kNotCompressedBit16)
+ t &= ~kNotCompressedBit16;
+ totalPack += t;
+ if (fillOffsets)
+ _blockOffsets.Add(totalPack);
+ }
+ }
+ else
+ {
+ if (_h.Major <= 2)
+ offset = 24;
+ else if (type == kType_FILE)
+ offset = 32;
+ else if (type == kType_FILE + 7)
+ offset = (_h.Major <= 3 ? 40 : 56);
+ else
+ return false;
+
+ p += offset;
+
+ for (UInt64 i = 0; i < numBlocks; i++)
+ {
+ UInt32 t = Get32(p + i * 4);
+ if (fillOffsets)
+ _blockCompressed.Add(IS_COMPRESSED_BLOCK(t));
+ UInt32 size = GET_COMPRESSED_BLOCK_SIZE(t);
+ if (size > _h.BlockSize)
+ return false;
+ totalPack += size;
+ if (fillOffsets)
+ _blockOffsets.Add(totalPack);
+ }
+
+ if (node.ThereAreFrags())
+ {
+ if (node.Frag >= (UInt32)_frags.Size())
+ return false;
+ const CFrag &frag = _frags[node.Frag];
+ if (node.Offset == 0)
+ {
+ UInt32 size = GET_COMPRESSED_BLOCK_SIZE(frag.Size);
+ if (size > _h.BlockSize)
+ return false;
+ totalPack += size;
+ }
+ }
+ }
+ return true;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMethod:
+ {
+ char sz[16];
+ const char *s;
+ if (_noPropsLZMA)
+ s = "LZMA Spec";
+ else if (_h.SeveralMethods)
+ s = "LZMA ZLIB";
+ else
+ {
+ s = NULL;
+ if (_h.Method < Z7_ARRAY_SIZE(k_Methods))
+ s = k_Methods[_h.Method];
+ if (!s)
+ {
+ ConvertUInt32ToString(_h.Method, sz);
+ s = sz;
+ }
+ }
+ prop = s;
+ break;
+ }
+ case kpidFileSystem:
+ {
+ AString res ("SquashFS");
+ if (_h.SeveralMethods)
+ res += "-LZMA";
+ res.Add_Space();
+ res.Add_UInt32(_h.Major);
+ res.Add_Dot();
+ res.Add_UInt32(_h.Minor);
+ prop = res;
+ break;
+ }
+ case kpidClusterSize: prop = _h.BlockSize; break;
+ case kpidBigEndian: prop = _h.be; break;
+ case kpidCTime:
+ if (_h.CTime != 0)
+ PropVariant_SetFrom_UnixTime(prop, _h.CTime);
+ break;
+ case kpidCharacts: FLAGS_TO_PROP(k_Flags, _h.Flags, prop); break;
+ // case kpidNumBlocks: prop = _h.NumFrags; break;
+ case kpidPhySize: prop = _sizeCalculated; break;
+ case kpidHeadersSize:
+ if (_sizeCalculated >= _h.InodeTable)
+ prop = _sizeCalculated - _h.InodeTable;
+ break;
+
+ case kpidCodePage:
+ {
+ char sz[16];
+ const char *name = NULL;
+ switch (_openCodePage)
+ {
+ case CP_OEMCP: name = "OEM"; break;
+ case CP_UTF8: name = "UTF-8"; break;
+ }
+ if (!name)
+ {
+ ConvertUInt32ToString(_openCodePage, sz);
+ name = sz;
+ }
+ prop = name;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[item.Node];
+ const bool isDir = node.IsDir();
+ const bool be = _h.be;
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString path (GetPath(index));
+ UString s;
+ if (_openCodePage == CP_UTF8)
+ ConvertUTF8ToUnicode(path, s);
+ else
+ MultiByteToUnicodeString2(s, path, _openCodePage);
+ prop = s;
+ break;
+ }
+ case kpidIsDir: prop = isDir; break;
+ // case kpidOffset: if (!node.IsLink()) prop = (UInt64)node.StartBlock; break;
+ case kpidSize: if (!isDir) prop = node.GetSize(); break;
+ case kpidPackSize:
+ if (!isDir)
+ {
+ UInt64 size;
+ if (GetPackSize(index, size, false))
+ prop = size;
+ }
+ break;
+ case kpidMTime:
+ {
+ UInt32 offset = 0;
+ switch (_h.Major)
+ {
+ case 1:
+ if (node.Type == kType_FILE)
+ offset = 3;
+ else if (node.Type == kType_DIR)
+ offset = 7;
+ break;
+ case 2:
+ if (node.Type == kType_FILE)
+ offset = 4;
+ else if (node.Type == kType_DIR)
+ offset = 8;
+ else if (node.Type == kType_DIR + 7)
+ offset = 9;
+ break;
+ case 3: offset = 4; break;
+ case 4: offset = 8; break;
+ }
+ if (offset != 0)
+ {
+ const Byte *p = _inodesData.Data + _nodesPos[item.Node] + offset;
+ PropVariant_SetFrom_UnixTime(prop, Get32(p));
+ }
+ break;
+ }
+ case kpidPosixAttrib:
+ {
+ if (node.Type != 0 && node.Type < Z7_ARRAY_SIZE(k_TypeToMode))
+ prop = (UInt32)(node.Mode & 0xFFF) | k_TypeToMode[node.Type];
+ break;
+ }
+ case kpidUserId:
+ case kpidGroupId:
+ {
+ UInt32 id = node.Uid;
+ const CByteBuffer *ids = &_uids;
+ if (propID == kpidGroupId)
+ {
+ id = node.Gid;
+ if (_h.Major < 4)
+ {
+ if (id == _h.GetSpecGuidIndex())
+ id = node.Uid;
+ else
+ ids = &_gids;
+ }
+ }
+ const UInt32 offset = (UInt32)id * 4;
+ if (offset < ids->Size())
+ prop = (UInt32)Get32(*ids + offset);
+ break;
+ }
+ /*
+ case kpidLinks:
+ if (_h.Major >= 3 && node.Type != kType_FILE)
+ prop = node.NumLinks;
+ break;
+ */
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+class CSquashfsInStream: public CCachedInStream
+{
+ HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) Z7_override;
+public:
+ CHandler *Handler;
+};
+
+HRESULT CSquashfsInStream::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
+{
+ return Handler->ReadBlock(blockIndex, dest, blockSize);
+}
+
+HRESULT CHandler::ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize)
+{
+ const CNode &node = _nodes[_nodeIndex];
+ UInt64 blockOffset;
+ UInt32 packBlockSize;
+ UInt32 offsetInBlock = 0;
+ bool compressed;
+ if (blockIndex < _blockCompressed.Size())
+ {
+ compressed = _blockCompressed[(unsigned)blockIndex];
+ blockOffset = _blockOffsets[(unsigned)blockIndex];
+ packBlockSize = (UInt32)(_blockOffsets[(unsigned)blockIndex + 1] - blockOffset);
+ blockOffset += node.StartBlock;
+ }
+ else
+ {
+ if (!node.ThereAreFrags())
+ return S_FALSE;
+ const CFrag &frag = _frags[node.Frag];
+ offsetInBlock = node.Offset;
+ blockOffset = frag.StartBlock;
+ packBlockSize = GET_COMPRESSED_BLOCK_SIZE(frag.Size);
+ compressed = IS_COMPRESSED_BLOCK(frag.Size);
+ }
+
+ if (packBlockSize == 0)
+ {
+ // sparse file ???
+ memset(dest, 0, blockSize);
+ return S_OK;
+ }
+
+ if (blockOffset != _cachedBlockStartPos ||
+ packBlockSize != _cachedPackBlockSize)
+ {
+ ClearCache();
+ RINOK(Seek2(blockOffset))
+ _limitedInStreamSpec->Init(packBlockSize);
+
+ if (compressed)
+ {
+ _outStreamSpec->Init((Byte *)_cachedBlock, _h.BlockSize);
+ bool outBufWasWritten;
+ UInt32 outBufWasWrittenSize;
+ HRESULT res = Decompress(_outStream, _cachedBlock, &outBufWasWritten, &outBufWasWrittenSize, packBlockSize, _h.BlockSize);
+ RINOK(res)
+ if (outBufWasWritten)
+ _cachedUnpackBlockSize = outBufWasWrittenSize;
+ else
+ _cachedUnpackBlockSize = (UInt32)_outStreamSpec->GetPos();
+ }
+ else
+ {
+ if (packBlockSize > _h.BlockSize)
+ return S_FALSE;
+ RINOK(ReadStream_FALSE(_limitedInStream, _cachedBlock, packBlockSize))
+ _cachedUnpackBlockSize = packBlockSize;
+ }
+ _cachedBlockStartPos = blockOffset;
+ _cachedPackBlockSize = packBlockSize;
+ }
+ if (offsetInBlock + blockSize > _cachedUnpackBlockSize)
+ return S_FALSE;
+ if (blockSize != 0)
+ memcpy(dest, _cachedBlock + offsetInBlock, blockSize);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItem &item = _items[allFilesMode ? i : indices[i]];
+ const CNode &node = _nodes[item.Node];
+ totalSize += node.GetSize();
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> outStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[item.Node];
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ // const Byte *p = _data + item.Offset;
+
+ if (node.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ UInt64 unpackSize = node.GetSize();
+ totalSize += unpackSize;
+ UInt64 packSize;
+ if (GetPackSize(index, packSize, false))
+ totalPackSize += packSize;
+
+ if (!testMode && !outStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ int res = NExtract::NOperationResult::kDataError;
+ {
+ CMyComPtr<ISequentialInStream> inSeqStream;
+ HRESULT hres = GetStream(index, &inSeqStream);
+ if (hres == S_FALSE || !inSeqStream)
+ {
+ if (hres == E_OUTOFMEMORY)
+ return hres;
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ }
+ else
+ {
+ RINOK(hres)
+ {
+ hres = copyCoder->Code(inSeqStream, outStream, NULL, NULL, progress);
+ if (hres == S_OK)
+ {
+ if (copyCoderSpec->TotalSize == unpackSize)
+ res = NExtract::NOperationResult::kOK;
+ }
+ else if (hres == E_NOTIMPL)
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ }
+ else if (hres != S_FALSE)
+ {
+ RINOK(hres)
+ }
+ }
+ }
+ }
+
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+
+ const CItem &item = _items[index];
+ const CNode &node = _nodes[item.Node];
+
+ if (node.IsDir())
+ return E_FAIL;
+
+ const Byte *p = _inodesData.Data + _nodesPos[item.Node];
+
+ if (node.FileSize == 0 || node.IsLink())
+ {
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+ if (node.IsLink())
+ streamSpec->Init(p + _h.GetSymLinkOffset(), (size_t)node.FileSize);
+ else
+ streamSpec->Init(NULL, 0);
+ *stream = streamTemp.Detach();
+ return S_OK;
+ }
+
+ UInt64 packSize;
+ if (!GetPackSize(index, packSize, true))
+ return S_FALSE;
+
+ _nodeIndex = item.Node;
+
+ size_t cacheSize = _h.BlockSize;
+ if (_cachedBlock.Size() != cacheSize)
+ {
+ ClearCache();
+ _cachedBlock.Alloc(cacheSize);
+ }
+
+ CSquashfsInStream *streamSpec = new CSquashfsInStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+ streamSpec->Handler = this;
+ unsigned cacheSizeLog = 22;
+ if (cacheSizeLog <= _h.BlockSizeLog)
+ cacheSizeLog = _h.BlockSizeLog + 1;
+ if (!streamSpec->Alloc(_h.BlockSizeLog, cacheSizeLog - _h.BlockSizeLog))
+ return E_OUTOFMEMORY;
+ streamSpec->Init(node.FileSize);
+ *stream = streamTemp.Detach();
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = {
+ 4, 'h', 's', 'q', 's',
+ 4, 's', 'q', 's', 'h',
+ 4, 's', 'h', 's', 'q',
+ 4, 'q', 's', 'h', 's' };
+
+REGISTER_ARC_I(
+ "SquashFS", "squashfs", NULL, 0xD2,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kMultiSignature,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/StdAfx.h b/CPP/7zip/Archive/StdAfx.h
index 42a088f..8086655 100644
--- a/CPP/7zip/Archive/StdAfx.h
+++ b/CPP/7zip/Archive/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/SwfHandler.cpp b/CPP/7zip/Archive/SwfHandler.cpp
new file mode 100644
index 0000000..ab704b6
--- /dev/null
+++ b/CPP/7zip/Archive/SwfHandler.cpp
@@ -0,0 +1,994 @@
+// SwfHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/InBuffer.h"
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/LzmaDecoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+#include "Common/DummyOutStream.h"
+
+// #define Z7_SWF_UPDATE
+
+#ifdef Z7_SWF_UPDATE
+
+#include "../Compress/LzmaEncoder.h"
+#include "../Compress/ZlibEncoder.h"
+
+#include "Common/HandlerOut.h"
+
+#endif
+
+using namespace NWindows;
+
+namespace NArchive {
+
+static const UInt32 kFileSizeMax = (UInt32)1 << 29;
+
+namespace NSwfc {
+
+static const unsigned kHeaderBaseSize = 8;
+static const unsigned kHeaderLzmaSize = 17;
+
+static const Byte SWF_UNCOMPRESSED = 'F';
+static const Byte SWF_COMPRESSED_ZLIB = 'C';
+static const Byte SWF_COMPRESSED_LZMA = 'Z';
+
+static const Byte SWF_MIN_COMPRESSED_ZLIB_VER = 6;
+static const Byte SWF_MIN_COMPRESSED_LZMA_VER = 13;
+
+static const Byte kVerLim = 64;
+
+API_FUNC_static_IsArc IsArc_Swf(const Byte *p, size_t size)
+{
+ if (size < kHeaderBaseSize)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != SWF_UNCOMPRESSED ||
+ p[1] != 'W' ||
+ p[2] != 'S' ||
+ p[3] >= kVerLim)
+ return k_IsArc_Res_NO;
+ UInt32 uncompressedSize = GetUi32(p + 4);
+ if (uncompressedSize > kFileSizeMax)
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+API_FUNC_static_IsArc IsArc_Swfc(const Byte *p, size_t size)
+{
+ if (size < kHeaderBaseSize + 2 + 1) // 2 + 1 (for zlib check)
+ return k_IsArc_Res_NEED_MORE;
+ if ((p[0] != SWF_COMPRESSED_ZLIB &&
+ p[0] != SWF_COMPRESSED_LZMA) ||
+ p[1] != 'W' ||
+ p[2] != 'S' ||
+ p[3] >= kVerLim)
+ return k_IsArc_Res_NO;
+ UInt32 uncompressedSize = GetUi32(p + 4);
+ if (uncompressedSize > kFileSizeMax)
+ return k_IsArc_Res_NO;
+
+ if (p[0] == SWF_COMPRESSED_ZLIB)
+ {
+ if (!NCompress::NZlib::IsZlib_3bytes(p + 8))
+ return k_IsArc_Res_NO;
+ }
+ else
+ {
+ if (size < kHeaderLzmaSize + 2)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[kHeaderLzmaSize] != 0 ||
+ (p[kHeaderLzmaSize + 1] & 0x80) != 0)
+ return k_IsArc_Res_NO;
+ UInt32 lzmaPackSize = GetUi32(p + 8);
+ UInt32 lzmaProp = p[12];
+ UInt32 lzmaDicSize = GetUi32(p + 13);
+ if (lzmaProp > 5 * 5 * 9 ||
+ lzmaDicSize > ((UInt32)1 << 28) ||
+ lzmaPackSize < 5 ||
+ lzmaPackSize > ((UInt32)1 << 28))
+ return k_IsArc_Res_NO;
+ }
+
+ return k_IsArc_Res_YES;
+}
+}
+
+struct CItem
+{
+ Byte Buf[kHeaderLzmaSize];
+ unsigned HeaderSize;
+
+ UInt32 GetSize() const { return GetUi32(Buf + 4); }
+ UInt32 GetLzmaPackSize() const { return GetUi32(Buf + 8); }
+ UInt32 GetLzmaDicSize() const { return GetUi32(Buf + 13); }
+
+ bool IsSwf() const { return (Buf[1] == 'W' && Buf[2] == 'S' && Buf[3] < kVerLim); }
+ bool IsUncompressed() const { return Buf[0] == SWF_UNCOMPRESSED; }
+ bool IsZlib() const { return Buf[0] == SWF_COMPRESSED_ZLIB; }
+ bool IsLzma() const { return Buf[0] == SWF_COMPRESSED_LZMA; }
+
+ void MakeUncompressed()
+ {
+ Buf[0] = SWF_UNCOMPRESSED;
+ HeaderSize = kHeaderBaseSize;
+ }
+ void MakeZlib()
+ {
+ Buf[0] = SWF_COMPRESSED_ZLIB;
+ if (Buf[3] < SWF_MIN_COMPRESSED_ZLIB_VER)
+ Buf[3] = SWF_MIN_COMPRESSED_ZLIB_VER;
+ }
+ void MakeLzma(UInt32 packSize)
+ {
+ Buf[0] = SWF_COMPRESSED_LZMA;
+ if (Buf[3] < SWF_MIN_COMPRESSED_LZMA_VER)
+ Buf[3] = SWF_MIN_COMPRESSED_LZMA_VER;
+ SetUi32(Buf + 8, packSize)
+ HeaderSize = kHeaderLzmaSize;
+ }
+
+ HRESULT ReadHeader(ISequentialInStream *stream)
+ {
+ HeaderSize = kHeaderBaseSize;
+ return ReadStream_FALSE(stream, Buf, kHeaderBaseSize);
+ }
+ HRESULT WriteHeader(ISequentialOutStream *stream)
+ {
+ return WriteStream(stream, Buf, HeaderSize);
+ }
+};
+
+
+Z7_class_CHandler_final:
+ public IInArchive,
+ public IArchiveOpenSeq,
+ #ifdef Z7_SWF_UPDATE
+ public IOutArchive,
+ public ISetProperties,
+ #endif
+ public CMyUnknownImp
+{
+ #ifdef Z7_SWF_UPDATE
+ Z7_IFACES_IMP_UNK_4(IInArchive, IArchiveOpenSeq, IOutArchive, ISetProperties)
+ #else
+ Z7_IFACES_IMP_UNK_2(IInArchive, IArchiveOpenSeq)
+ #endif
+
+ CItem _item;
+ UInt64 _packSize;
+ bool _packSizeDefined;
+ CMyComPtr<ISequentialInStream> _seqStream;
+ CMyComPtr<IInStream> _stream;
+
+ #ifdef Z7_SWF_UPDATE
+ CSingleMethodProps _props;
+ bool _lzmaMode;
+ #endif
+
+public:
+ #ifdef Z7_SWF_UPDATE
+ CHandler(): _lzmaMode(false) {}
+ #endif
+};
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize,
+ kpidMethod
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_packSizeDefined) prop = _item.HeaderSize + _packSize; break;
+ case kpidIsNotArcType: prop = true; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+static void DicSizeToString(char *s, UInt32 val)
+{
+ char c = 0;
+ unsigned i;
+ for (i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == val)
+ {
+ val = i;
+ break;
+ }
+ if (i == 32)
+ {
+ c = 'b';
+ if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
+ else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
+ }
+ ::ConvertUInt32ToString(val, s);
+ unsigned pos = MyStringLen(s);
+ s[pos++] = c;
+ s[pos] = 0;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidSize: prop = (UInt64)_item.GetSize(); break;
+ case kpidPackSize: if (_packSizeDefined) prop = _item.HeaderSize + _packSize; break;
+ case kpidMethod:
+ {
+ char s[32];
+ if (_item.IsZlib())
+ MyStringCopy(s, "zlib");
+ else
+ {
+ MyStringCopy(s, "LZMA:");
+ DicSizeToString(s + 5, _item.GetLzmaDicSize());
+ }
+ prop = s;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *))
+{
+ RINOK(OpenSeq(stream))
+ _stream = stream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ Close();
+ RINOK(_item.ReadHeader(stream))
+ if (!_item.IsSwf())
+ return S_FALSE;
+ if (_item.IsLzma())
+ {
+ RINOK(ReadStream_FALSE(stream, _item.Buf + kHeaderBaseSize, kHeaderLzmaSize - kHeaderBaseSize))
+ _item.HeaderSize = kHeaderLzmaSize;
+ _packSize = _item.GetLzmaPackSize();
+ _packSizeDefined = true;
+ }
+ else if (!_item.IsZlib())
+ return S_FALSE;
+ if (_item.GetSize() < _item.HeaderSize)
+ return S_FALSE;
+ _seqStream = stream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _packSize = 0;
+ _packSizeDefined = false;
+ _seqStream.Release();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_CLASS_IMP_COM_1(
+ CCompressProgressInfoImp,
+ ICompressProgressInfo
+)
+ CMyComPtr<IArchiveOpenCallback> Callback;
+public:
+ UInt64 Offset;
+ void Init(IArchiveOpenCallback *callback) { Callback = callback; }
+};
+
+Z7_COM7F_IMF(CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+{
+ if (Callback)
+ {
+ const UInt64 files = 0;
+ const UInt64 value = Offset + *inSize;
+ return Callback->SetCompleted(&files, &value);
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ RINOK(extractCallback->SetTotal(_item.GetSize()))
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ lps->InSize = _item.HeaderSize;
+ lps->OutSize = outStreamSpec->GetSize();
+ RINOK(lps->SetCur())
+
+ CItem item = _item;
+ item.MakeUncompressed();
+ if (_stream)
+ RINOK(InStream_SeekSet(_stream, _item.HeaderSize))
+ NCompress::NZlib::CDecoder *_decoderZlibSpec = NULL;
+ NCompress::NLzma::CDecoder *_decoderLzmaSpec = NULL;
+ CMyComPtr<ICompressCoder> _decoder;
+
+ CMyComPtr<ISequentialInStream> inStream2;
+
+ UInt64 unpackSize = _item.GetSize() - (UInt32)8;
+ if (_item.IsZlib())
+ {
+ _decoderZlibSpec = new NCompress::NZlib::CDecoder;
+ _decoder = _decoderZlibSpec;
+ inStream2 = _seqStream;
+ }
+ else
+ {
+ /* Some .swf files with lzma contain additional 8 bytes at the end
+ in uncompressed stream.
+ What does that data mean ???
+ We don't decompress these additional 8 bytes */
+
+ // unpackSize = _item.GetSize();
+ // SetUi32(item.Buf + 4, (UInt32)(unpackSize + 8));
+ CLimitedSequentialInStream *limitedStreamSpec = new CLimitedSequentialInStream;
+ inStream2 = limitedStreamSpec;
+ limitedStreamSpec->SetStream(_seqStream);
+ limitedStreamSpec->Init(_item.GetLzmaPackSize());
+
+ _decoderLzmaSpec = new NCompress::NLzma::CDecoder;
+ _decoder = _decoderLzmaSpec;
+ // _decoderLzmaSpec->FinishStream = true;
+
+ Byte props[5];
+ memcpy(props, _item.Buf + 12, 5);
+ UInt32 dicSize = _item.GetLzmaDicSize();
+ if (dicSize > (UInt32)unpackSize)
+ {
+ dicSize = (UInt32)unpackSize;
+ SetUi32(props + 1, dicSize)
+ }
+ RINOK(_decoderLzmaSpec->SetDecoderProperties2(props, 5))
+ }
+ RINOK(item.WriteHeader(outStream))
+ HRESULT result = _decoder->Code(inStream2, outStream, NULL, &unpackSize, progress);
+ Int32 opRes = NExtract::NOperationResult::kDataError;
+ if (result == S_OK)
+ {
+ if (item.GetSize() == outStreamSpec->GetSize())
+ {
+ if (_item.IsZlib())
+ {
+ _packSizeDefined = true;
+ _packSize = _decoderZlibSpec->GetInputProcessedSize();
+ opRes = NExtract::NOperationResult::kOK;
+ }
+ else
+ {
+ // if (_decoderLzmaSpec->GetInputProcessedSize() == _packSize)
+ opRes = NExtract::NOperationResult::kOK;
+ }
+ }
+ }
+ else if (result != S_FALSE)
+ return result;
+
+ outStream.Release();
+ return extractCallback->SetOperationResult(opRes);
+ COM_TRY_END
+}
+
+
+#ifdef Z7_SWF_UPDATE
+
+static HRESULT UpdateArchive(ISequentialOutStream *outStream, UInt64 size,
+ bool lzmaMode, const CSingleMethodProps &props,
+ IArchiveUpdateCallback *updateCallback)
+{
+ UInt64 complexity = 0;
+ RINOK(updateCallback->SetTotal(size))
+ RINOK(updateCallback->SetCompleted(&complexity))
+
+ CMyComPtr<ISequentialInStream> fileInStream;
+ RINOK(updateCallback->GetStream(0, &fileInStream))
+
+ /*
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+ */
+
+ CItem item;
+ const HRESULT res = item.ReadHeader(fileInStream);
+ if (res == S_FALSE)
+ return E_INVALIDARG;
+ RINOK(res)
+ if (!item.IsSwf() || !item.IsUncompressed() || size != item.GetSize())
+ return E_INVALIDARG;
+
+ NCompress::NZlib::CEncoder *encoderZlibSpec = NULL;
+ NCompress::NLzma::CEncoder *encoderLzmaSpec = NULL;
+ CMyComPtr<ICompressCoder> encoder;
+ CMyComPtr<IOutStream> outSeekStream;
+ if (lzmaMode)
+ {
+ outStream->QueryInterface(IID_IOutStream, (void **)&outSeekStream);
+ if (!outSeekStream)
+ return E_NOTIMPL;
+ encoderLzmaSpec = new NCompress::NLzma::CEncoder;
+ encoder = encoderLzmaSpec;
+ RINOK(props.SetCoderProps(encoderLzmaSpec, &size))
+ item.MakeLzma((UInt32)0xFFFFFFFF);
+ CBufPtrSeqOutStream *propStreamSpec = new CBufPtrSeqOutStream;
+ CMyComPtr<ISequentialOutStream> propStream = propStreamSpec;
+ propStreamSpec->Init(item.Buf + 12, 5);
+ RINOK(encoderLzmaSpec->WriteCoderProperties(propStream))
+ }
+ else
+ {
+ encoderZlibSpec = new NCompress::NZlib::CEncoder;
+ encoder = encoderZlibSpec;
+ encoderZlibSpec->Create();
+ RINOK(props.SetCoderProps(encoderZlibSpec->DeflateEncoderSpec, NULL))
+ item.MakeZlib();
+ }
+ RINOK(item.WriteHeader(outStream))
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ RINOK(encoder->Code(fileInStream, outStream, NULL, NULL, progress))
+ UInt64 inputProcessed;
+ if (lzmaMode)
+ {
+ UInt64 curPos = 0;
+ RINOK(outSeekStream->Seek(0, STREAM_SEEK_CUR, &curPos))
+ const UInt64 packSize = curPos - kHeaderLzmaSize;
+ if (packSize > (UInt32)0xFFFFFFFF)
+ return E_INVALIDARG;
+ item.MakeLzma((UInt32)packSize);
+ RINOK(outSeekStream->Seek(0, STREAM_SEEK_SET, NULL))
+ RINOK(item.WriteHeader(outStream))
+ inputProcessed = encoderLzmaSpec->GetInputProcessedSize();
+ }
+ else
+ {
+ inputProcessed = encoderZlibSpec->GetInputProcessedSize();
+ }
+ if (inputProcessed + kHeaderBaseSize != size)
+ return E_INVALIDARG;
+ return updateCallback->SetOperationResult(NUpdate::NOperationResult::kOK);
+}
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *timeType))
+{
+ *timeType = NFileTimeType::kUnix;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *updateCallback))
+{
+ if (numItems != 1)
+ return E_INVALIDARG;
+
+ Int32 newData, newProps;
+ UInt32 indexInArchive;
+ if (!updateCallback)
+ return E_FAIL;
+ RINOK(updateCallback->GetUpdateItemInfo(0, &newData, &newProps, &indexInArchive))
+
+ if (IntToBool(newProps))
+ {
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidIsDir, &prop))
+ if (prop.vt == VT_BOOL)
+ {
+ if (prop.boolVal != VARIANT_FALSE)
+ return E_INVALIDARG;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ }
+
+ if (IntToBool(newData))
+ {
+ UInt64 size;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ size = prop.uhVal.QuadPart;
+ }
+ return UpdateArchive(outStream, size, _lzmaMode, _props, updateCallback);
+ }
+
+ if (indexInArchive != 0)
+ return E_INVALIDARG;
+
+ if (!_seqStream)
+ return E_NOTIMPL;
+
+ if (_stream)
+ {
+ RINOK(InStream_SeekToBegin(_stream))
+ }
+ else
+ _item.WriteHeader(outStream);
+ return NCompress::CopyStream(_seqStream, outStream, NULL);
+}
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ _lzmaMode = false;
+ RINOK(_props.SetProperties(names, values, numProps))
+ const AString &m = _props.MethodName;
+ if (m.IsEqualTo_Ascii_NoCase("lzma"))
+ {
+ return E_NOTIMPL;
+ // _lzmaMode = true;
+ }
+ else if (m.IsEqualTo_Ascii_NoCase("Deflate") || m.IsEmpty())
+ _lzmaMode = false;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+#endif
+
+
+static const Byte k_Signature[] = {
+ 3, 'C', 'W', 'S',
+ 3, 'Z', 'W', 'S' };
+
+REGISTER_ARC_I(
+ "SWFc", "swf", "~.swf", 0xD8,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kMultiSignature,
+ IsArc_Swfc)
+
+}
+
+namespace NSwf {
+
+static const unsigned kNumTagsMax = 1 << 23;
+
+struct CTag
+{
+ UInt32 Type;
+ CByteBuffer Buf;
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IArchiveOpenSeq
+)
+ CObjectVector<CTag> _tags;
+ NSwfc::CItem _item;
+ UInt64 _phySize;
+
+ HRESULT OpenSeq3(ISequentialInStream *stream, IArchiveOpenCallback *callback);
+ HRESULT OpenSeq2(ISequentialInStream *stream, IArchiveOpenCallback *callback);
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidComment,
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _phySize; break;
+ case kpidIsNotArcType: prop = true; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _tags.Size();
+ return S_OK;
+}
+
+static const char * const g_TagDesc[92] =
+{
+ "End"
+ , "ShowFrame"
+ , "DefineShape"
+ , NULL
+ , "PlaceObject"
+ , "RemoveObject"
+ , "DefineBits"
+ , "DefineButton"
+ , "JPEGTables"
+ , "SetBackgroundColor"
+ , "DefineFont"
+ , "DefineText"
+ , "DoAction"
+ , "DefineFontInfo"
+ , "DefineSound"
+ , "StartSound"
+ , NULL
+ , "DefineButtonSound"
+ , "SoundStreamHead"
+ , "SoundStreamBlock"
+ , "DefineBitsLossless"
+ , "DefineBitsJPEG2"
+ , "DefineShape2"
+ , "DefineButtonCxform"
+ , "Protect"
+ , NULL
+ , "PlaceObject2"
+ , NULL
+ , "RemoveObject2"
+ , NULL
+ , NULL
+ , NULL
+ , "DefineShape3"
+ , "DefineText2"
+ , "DefineButton2"
+ , "DefineBitsJPEG3"
+ , "DefineBitsLossless2"
+ , "DefineEditText"
+ , NULL
+ , "DefineSprite"
+ , NULL
+ , "41"
+ , NULL
+ , "FrameLabel"
+ , NULL
+ , "SoundStreamHead2"
+ , "DefineMorphShape"
+ , NULL
+ , "DefineFont2"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "ExportAssets"
+ , "ImportAssets"
+ , "EnableDebugger"
+ , "DoInitAction"
+ , "DefineVideoStream"
+ , "VideoFrame"
+ , "DefineFontInfo2"
+ , NULL
+ , "EnableDebugger2"
+ , "ScriptLimits"
+ , "SetTabIndex"
+ , NULL
+ , NULL
+ , "FileAttributes"
+ , "PlaceObject3"
+ , "ImportAssets2"
+ , NULL
+ , "DefineFontAlignZones"
+ , "CSMTextSettings"
+ , "DefineFont3"
+ , "SymbolClass"
+ , "Metadata"
+ , "DefineScalingGrid"
+ , NULL
+ , NULL
+ , NULL
+ , "DoABC"
+ , "DefineShape4"
+ , "DefineMorphShape2"
+ , NULL
+ , "DefineSceneAndFrameLabelData"
+ , "DefineBinaryData"
+ , "DefineFontName"
+ , "StartSound2"
+ , "DefineBitsJPEG4"
+ , "DefineFont4"
+};
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ const CTag &tag = _tags[index];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ char s[32];
+ ConvertUInt32ToString(index, s);
+ size_t i = strlen(s);
+ s[i++] = '.';
+ ConvertUInt32ToString(tag.Type, s + i);
+ prop = s;
+ break;
+ }
+ case kpidSize:
+ case kpidPackSize:
+ prop = (UInt64)tag.Buf.Size(); break;
+ case kpidComment:
+ TYPE_TO_PROP(g_TagDesc, tag.Type, prop);
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ return OpenSeq2(stream, callback);
+}
+
+static UInt16 Read16(CInBuffer &stream)
+{
+ UInt32 res = 0;
+ for (unsigned i = 0; i < 2; i++)
+ {
+ Byte b;
+ if (!stream.ReadByte(b))
+ throw 1;
+ res |= (UInt32)b << (i * 8);
+ }
+ return (UInt16)res;
+}
+
+static UInt32 Read32(CInBuffer &stream)
+{
+ UInt32 res = 0;
+ for (unsigned i = 0; i < 4; i++)
+ {
+ Byte b;
+ if (!stream.ReadByte(b))
+ throw 1;
+ res |= (UInt32)b << (i * 8);
+ }
+ return res;
+}
+
+struct CBitReader
+{
+ CInBuffer *stream;
+ unsigned NumBits;
+ Byte Val;
+
+ CBitReader(): NumBits(0), Val(0) {}
+
+ UInt32 ReadBits(unsigned numBits);
+};
+
+UInt32 CBitReader::ReadBits(unsigned numBits)
+{
+ UInt32 res = 0;
+ while (numBits > 0)
+ {
+ if (NumBits == 0)
+ {
+ Val = stream->ReadByte();
+ NumBits = 8;
+ }
+ if (numBits <= NumBits)
+ {
+ res <<= numBits;
+ NumBits -= numBits;
+ res |= (Val >> NumBits);
+ Val = (Byte)(Val & (((unsigned)1 << NumBits) - 1));
+ break;
+ }
+ else
+ {
+ res <<= NumBits;
+ res |= Val;
+ numBits -= NumBits;
+ NumBits = 0;
+ }
+ }
+ return res;
+}
+
+HRESULT CHandler::OpenSeq3(ISequentialInStream *stream, IArchiveOpenCallback *callback)
+{
+ RINOK(_item.ReadHeader(stream))
+ if (!_item.IsSwf() || !_item.IsUncompressed())
+ return S_FALSE;
+ const UInt32 uncompressedSize = _item.GetSize();
+ if (uncompressedSize > kFileSizeMax)
+ return S_FALSE;
+
+
+ CInBuffer s;
+ if (!s.Create(1 << 20))
+ return E_OUTOFMEMORY;
+ s.SetStream(stream);
+ s.Init();
+ {
+ CBitReader br;
+ br.stream = &s;
+ const unsigned numBits = br.ReadBits(5);
+ /* UInt32 xMin = */ br.ReadBits(numBits);
+ /* UInt32 xMax = */ br.ReadBits(numBits);
+ /* UInt32 yMin = */ br.ReadBits(numBits);
+ /* UInt32 yMax = */ br.ReadBits(numBits);
+ }
+ /* UInt32 frameDelay = */ Read16(s);
+ /* UInt32 numFrames = */ Read16(s);
+
+ _tags.Clear();
+ UInt64 offsetPrev = 0;
+ for (;;)
+ {
+ const UInt32 pair = Read16(s);
+ const UInt32 type = pair >> 6;
+ UInt32 length = pair & 0x3F;
+ if (length == 0x3F)
+ length = Read32(s);
+ if (type == 0)
+ break;
+ const UInt64 offset = s.GetProcessedSize() + NSwfc::kHeaderBaseSize + length;
+ if (offset > uncompressedSize || _tags.Size() >= kNumTagsMax)
+ return S_FALSE;
+ CTag &tag = _tags.AddNew();
+ tag.Type = type;
+ tag.Buf.Alloc(length);
+ if (s.ReadBytes(tag.Buf, length) != length)
+ return S_FALSE;
+ if (callback && offset >= offsetPrev + (1 << 20))
+ {
+ const UInt64 numItems = _tags.Size();
+ RINOK(callback->SetCompleted(&numItems, &offset))
+ offsetPrev = offset;
+ }
+ }
+ _phySize = s.GetProcessedSize() + NSwfc::kHeaderBaseSize;
+ if (_phySize != uncompressedSize)
+ {
+ // do we need to support files extracted from SFW-LZMA with additional 8 bytes?
+ return S_FALSE;
+ }
+ return S_OK;
+}
+
+HRESULT CHandler::OpenSeq2(ISequentialInStream *stream, IArchiveOpenCallback *callback)
+{
+ HRESULT res;
+ try { res = OpenSeq3(stream, callback); }
+ catch(...) { res = S_FALSE; }
+ return res;
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ return OpenSeq2(stream, NULL);
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _tags.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _tags[allFilesMode ? i : indices[i]].Buf.Size();
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ totalSize = 0;
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CByteBuffer &buf = _tags[index].Buf;
+ totalSize += buf.Size();
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ RINOK(extractCallback->GetStream(index, &outStream, askMode))
+ if (!testMode && !outStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (outStream)
+ RINOK(WriteStream(outStream, buf, buf.Size()))
+ outStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { 'F', 'W', 'S' };
+
+REGISTER_ARC_I(
+ "SWF", "swf", NULL, 0xD7,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kKeepName,
+ NSwfc::IsArc_Swf)
+
+}}
diff --git a/CPP/7zip/Archive/Tar/StdAfx.h b/CPP/7zip/Archive/Tar/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/Tar/TarHandler.cpp b/CPP/7zip/Archive/Tar/TarHandler.cpp
new file mode 100644
index 0000000..d7fe175
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarHandler.cpp
@@ -0,0 +1,1045 @@
+// TarHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/MethodProps.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "TarHandler.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NTar {
+
+// 21.02: we use UTF8 code page by default, even if some files show error
+// before 21.02 : CP_OEMCP;
+// static const UINT k_DefaultCodePage = CP_UTF8;
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidPosixAttrib,
+ kpidUser,
+ kpidGroup,
+ kpidUserId,
+ kpidGroupId,
+ kpidSymLink,
+ kpidHardLink,
+ kpidCharacts,
+ kpidComment
+ , kpidDeviceMajor
+ , kpidDeviceMinor
+ // , kpidDevice
+ // , kpidHeadersSize // for debug
+ // , kpidOffset // for debug
+};
+
+static const Byte kArcProps[] =
+{
+ kpidHeadersSize,
+ kpidCodePage,
+ kpidCharacts,
+ kpidComment
+};
+
+static const char *k_Characts_Prefix = "PREFIX";
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_arc._phySize_Defined) prop = _arc._phySize; break;
+ case kpidHeadersSize: if (_arc._phySize_Defined) prop = _arc._headersSize; break;
+ case kpidErrorFlags:
+ {
+ UInt32 flags = 0;
+ if (!_isArc)
+ flags |= kpv_ErrorFlags_IsNotArc;
+ else switch (_arc._error)
+ {
+ case k_ErrorType_UnexpectedEnd: flags = kpv_ErrorFlags_UnexpectedEnd; break;
+ case k_ErrorType_Corrupted: flags = kpv_ErrorFlags_HeadersError; break;
+ case k_ErrorType_OK: break;
+ // case k_ErrorType_Warning: break;
+ // default: break;
+ }
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+
+ case kpidWarningFlags:
+ {
+ if (_arc._is_Warning)
+ prop = kpv_ErrorFlags_HeadersError;
+ break;
+ }
+
+ case kpidCodePage:
+ {
+ char sz[16];
+ const char *name = NULL;
+ switch (_openCodePage)
+ {
+ case CP_OEMCP: name = "OEM"; break;
+ case CP_UTF8: name = "UTF-8"; break;
+ }
+ if (!name)
+ {
+ ConvertUInt32ToString(_openCodePage, sz);
+ name = sz;
+ }
+ prop = name;
+ break;
+ }
+
+ case kpidCharacts:
+ {
+ AString s;
+ if (_arc._are_Gnu) s.Add_OptSpaced("GNU");
+ if (_arc._are_Posix) s.Add_OptSpaced("POSIX");
+ if (_arc._are_Pax_Items) s.Add_OptSpaced("PAX_ITEM");
+ if (_arc._pathPrefix_WasUsed) s.Add_OptSpaced(k_Characts_Prefix);
+ if (_arc._are_LongName) s.Add_OptSpaced("LongName");
+ if (_arc._are_LongLink) s.Add_OptSpaced("LongLink");
+ if (_arc._are_Pax) s.Add_OptSpaced("PAX");
+ if (_arc._are_pax_path) s.Add_OptSpaced("path");
+ if (_arc._are_pax_link) s.Add_OptSpaced("linkpath");
+ if (_arc._are_mtime) s.Add_OptSpaced("mtime");
+ if (_arc._are_atime) s.Add_OptSpaced("atime");
+ if (_arc._are_ctime) s.Add_OptSpaced("ctime");
+ if (_arc._is_PaxGlobal_Error) s.Add_OptSpaced("PAX_GLOBAL_ERROR");
+ s.Add_OptSpaced(_encodingCharacts.GetCharactsString());
+ prop = s;
+ break;
+ }
+
+ case kpidComment:
+ {
+ if (_arc.PaxGlobal_Defined)
+ {
+ AString s;
+ _arc.PaxGlobal.Print_To_String(s);
+ if (!s.IsEmpty())
+ prop = s;
+ }
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+void CEncodingCharacts::Check(const AString &s)
+{
+ IsAscii = s.IsAscii();
+ if (!IsAscii)
+ {
+ /*
+ {
+ Oem_Checked = true;
+ UString u;
+ MultiByteToUnicodeString2(u, s, CP_OEMCP);
+ Oem_Ok = (u.Find((wchar_t)0xfffd) <= 0);
+ }
+ Utf_Checked = true;
+ */
+ UtfCheck.Check_AString(s);
+ }
+}
+
+
+AString CEncodingCharacts::GetCharactsString() const
+{
+ AString s;
+ if (IsAscii)
+ {
+ s += "ASCII";
+ }
+ /*
+ if (Oem_Checked)
+ {
+ s.Add_Space_if_NotEmpty();
+ s += (Oem_Ok ? "oem-ok" : "oem-error");
+ }
+ if (Utf_Checked)
+ */
+ else
+ {
+ s.Add_Space_if_NotEmpty();
+ s += (UtfCheck.IsOK() ? "UTF8" : "UTF8-ERROR"); // "UTF8-error"
+ {
+ AString s2;
+ UtfCheck.PrintStatus(s2);
+ s.Add_Space_if_NotEmpty();
+ s += s2;
+ }
+ }
+ return s;
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *callback)
+{
+ UInt64 endPos;
+ {
+ RINOK(InStream_AtBegin_GetSize(stream, endPos))
+ }
+
+ _arc._phySize_Defined = true;
+
+ // bool utf8_OK = true;
+
+ _arc.SeqStream = stream;
+ _arc.InStream = stream;
+ _arc.OpenCallback = callback;
+
+ CItemEx item;
+ for (;;)
+ {
+ _arc.NumFiles = _items.Size();
+ RINOK(_arc.ReadItem(item))
+ if (!_arc.filled)
+ break;
+
+ _isArc = true;
+
+ /*
+ if (!_forceCodePage)
+ {
+ if (utf8_OK) utf8_OK = CheckUTF8(item.Name, item.NameCouldBeReduced);
+ if (utf8_OK) utf8_OK = CheckUTF8(item.LinkName, item.LinkNameCouldBeReduced);
+ if (utf8_OK) utf8_OK = CheckUTF8(item.User);
+ if (utf8_OK) utf8_OK = CheckUTF8(item.Group);
+ }
+ */
+
+ item.EncodingCharacts.Check(item.Name);
+ _encodingCharacts.Update(item.EncodingCharacts);
+
+ _items.Add(item);
+
+ RINOK(stream->Seek((Int64)item.Get_PackSize_Aligned(), STREAM_SEEK_CUR, &_arc._phySize))
+ if (_arc._phySize > endPos)
+ {
+ _arc._error = k_ErrorType_UnexpectedEnd;
+ break;
+ }
+ /*
+ if (_phySize == endPos)
+ {
+ _errorMessage = "There are no trailing zero-filled records";
+ break;
+ }
+ */
+ /*
+ if (callback)
+ {
+ if (_items.Size() == 1)
+ {
+ RINOK(callback->SetTotal(NULL, &endPos));
+ }
+ if ((_items.Size() & 0x3FF) == 0)
+ {
+ const UInt64 numFiles = _items.Size();
+ RINOK(callback->SetCompleted(&numFiles, &_phySize));
+ }
+ }
+ */
+ }
+
+ /*
+ if (!_forceCodePage)
+ {
+ if (!utf8_OK)
+ _curCodePage = k_DefaultCodePage;
+ }
+ */
+ _openCodePage = _curCodePage;
+
+ if (_items.Size() == 0)
+ {
+ if (_arc._error != k_ErrorType_OK)
+ {
+ _isArc = false;
+ return S_FALSE;
+ }
+ if (!callback)
+ return S_FALSE;
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpenVolumeCallback,
+ openVolumeCallback, callback)
+ if (!openVolumeCallback)
+ return S_FALSE;
+ NCOM::CPropVariant prop;
+ if (openVolumeCallback->GetProperty(kpidName, &prop) != S_OK)
+ return S_FALSE;
+ if (prop.vt != VT_BSTR)
+ return S_FALSE;
+ unsigned len = MyStringLen(prop.bstrVal);
+ if (len < 4 || MyStringCompareNoCase(prop.bstrVal + len - 4, L".tar") != 0)
+ return S_FALSE;
+ }
+
+ _isArc = true;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *openArchiveCallback))
+{
+ COM_TRY_BEGIN
+ // for (int i = 0; i < 10; i++) // for debug
+ {
+ Close();
+ RINOK(Open2(stream, openArchiveCallback))
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ Close();
+ _seqStream = stream;
+ _isArc = true;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _isArc = false;
+
+ _arc.Clear();
+
+ _curIndex = 0;
+ _latestIsRead = false;
+ _encodingCharacts.Clear();
+ _items.Clear();
+ _seqStream.Release();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = (_stream ? _items.Size() : (UInt32)(Int32)-1);
+ return S_OK;
+}
+
+CHandler::CHandler()
+{
+ copyCoderSpec = new NCompress::CCopyCoder();
+ copyCoder = copyCoderSpec;
+ _openCodePage = CP_UTF8;
+ Init();
+}
+
+HRESULT CHandler::SkipTo(UInt32 index)
+{
+ while (_curIndex < index || !_latestIsRead)
+ {
+ if (_latestIsRead)
+ {
+ const UInt64 packSize = _latestItem.Get_PackSize_Aligned();
+ RINOK(copyCoder->Code(_seqStream, NULL, &packSize, &packSize, NULL))
+ _arc._phySize += copyCoderSpec->TotalSize;
+ if (copyCoderSpec->TotalSize != packSize)
+ {
+ _arc._error = k_ErrorType_UnexpectedEnd;
+ return S_FALSE;
+ }
+ _latestIsRead = false;
+ _curIndex++;
+ }
+ else
+ {
+ _arc.SeqStream = _seqStream;
+ _arc.InStream = NULL;
+ RINOK(_arc.ReadItem(_latestItem))
+ if (!_arc.filled)
+ {
+ _arc._phySize_Defined = true;
+ return E_INVALIDARG;
+ }
+ _latestIsRead = true;
+ }
+ }
+ return S_OK;
+}
+
+void CHandler::TarStringToUnicode(const AString &s, NWindows::NCOM::CPropVariant &prop, bool toOs) const
+{
+ UString dest;
+ if (_curCodePage == CP_UTF8)
+ ConvertUTF8ToUnicode(s, dest);
+ else
+ MultiByteToUnicodeString2(dest, s, _curCodePage);
+ if (toOs)
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(dest,
+ true); // useBackslashReplacement
+ prop = dest;
+}
+
+
+// CPaxTime is defined (NumDigits >= 0)
+static void PaxTimeToProp(const CPaxTime &pt, NWindows::NCOM::CPropVariant &prop)
+{
+ UInt64 v;
+ if (!NTime::UnixTime64_To_FileTime64(pt.Sec, v))
+ return;
+ if (pt.Ns != 0)
+ v += pt.Ns / 100;
+ FILETIME ft;
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+ prop.SetAsTimeFrom_FT_Prec_Ns100(ft,
+ k_PropVar_TimePrec_Base + (unsigned)pt.NumDigits, pt.Ns % 100);
+}
+
+
+#define ValToHex(t) ((char)(((t) < 10) ? ('0' + (t)) : ('a' + ((t) - 10))))
+
+static void AddByteToHex2(unsigned val, AString &s)
+{
+ unsigned t;
+ t = val >> 4;
+ s += ValToHex(t);
+ t = val & 0xF;
+ s += ValToHex(t);
+}
+
+static void AddSpecCharToString(const char c, AString &s)
+{
+ if ((Byte)c <= 0x20 || (Byte)c > 127)
+ {
+ s += '[';
+ AddByteToHex2((Byte)(c), s);
+ s += ']';
+ }
+ else
+ s += c;
+}
+
+static void AddSpecUInt64(AString &s, const char *name, UInt64 v)
+{
+ if (v != 0)
+ {
+ s.Add_OptSpaced(name);
+ if (v > 1)
+ {
+ s += ':';
+ s.Add_UInt64(v);
+ }
+ }
+}
+
+static void AddSpecBools(AString &s, const char *name, bool b1, bool b2)
+{
+ if (b1)
+ {
+ s.Add_OptSpaced(name);
+ if (b2)
+ s += '*';
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CItemEx *item;
+ if (_stream)
+ item = &_items[index];
+ else
+ {
+ if (index < _curIndex)
+ return E_INVALIDARG;
+ else
+ {
+ RINOK(SkipTo(index))
+ item = &_latestItem;
+ }
+ }
+
+ switch (propID)
+ {
+ case kpidPath: TarStringToUnicode(item->Name, prop, true); break;
+ case kpidIsDir: prop = item->IsDir(); break;
+ case kpidSize: prop = item->Get_UnpackSize(); break;
+ case kpidPackSize: prop = item->Get_PackSize_Aligned(); break;
+ case kpidMTime:
+ {
+ /*
+ // for debug:
+ PropVariant_SetFrom_UnixTime(prop, 1 << 30);
+ prop.wReserved1 = k_PropVar_TimePrec_Base + 1;
+ prop.wReserved2 = 12;
+ break;
+ */
+
+ if (item->PaxTimes.MTime.IsDefined())
+ PaxTimeToProp(item->PaxTimes.MTime, prop);
+ else
+ // if (item->MTime != 0)
+ {
+ // we allow (item->MTime == 0)
+ FILETIME ft;
+ if (NTime::UnixTime64_To_FileTime(item->MTime, ft))
+ {
+ unsigned prec = k_PropVar_TimePrec_Unix;
+ if (item->MTime_IsBin)
+ {
+ /* we report here that it's Int64-UnixTime
+ instead of basic UInt32-UnixTime range */
+ prec = k_PropVar_TimePrec_Base;
+ }
+ prop.SetAsTimeFrom_FT_Prec(ft, prec);
+ }
+ }
+ break;
+ }
+ case kpidATime:
+ if (item->PaxTimes.ATime.IsDefined())
+ PaxTimeToProp(item->PaxTimes.ATime, prop);
+ break;
+ case kpidCTime:
+ if (item->PaxTimes.CTime.IsDefined())
+ PaxTimeToProp(item->PaxTimes.CTime, prop);
+ break;
+ case kpidPosixAttrib: prop = item->Get_Combined_Mode(); break;
+
+ case kpidUser:
+ if (!item->User.IsEmpty())
+ TarStringToUnicode(item->User, prop);
+ break;
+ case kpidGroup:
+ if (!item->Group.IsEmpty())
+ TarStringToUnicode(item->Group, prop);
+ break;
+
+ case kpidUserId:
+ // if (item->UID != 0)
+ prop = (UInt32)item->UID;
+ break;
+ case kpidGroupId:
+ // if (item->GID != 0)
+ prop = (UInt32)item->GID;
+ break;
+
+ case kpidDeviceMajor:
+ if (item->DeviceMajor_Defined)
+ // if (item->DeviceMajor != 0)
+ prop = (UInt32)item->DeviceMajor;
+ break;
+
+ case kpidDeviceMinor:
+ if (item->DeviceMinor_Defined)
+ // if (item->DeviceMinor != 0)
+ prop = (UInt32)item->DeviceMinor;
+ break;
+ /*
+ case kpidDevice:
+ if (item->DeviceMajor_Defined)
+ if (item->DeviceMinor_Defined)
+ prop = (UInt64)MY_dev_makedev(item->DeviceMajor, item->DeviceMinor);
+ break;
+ */
+
+ case kpidSymLink:
+ if (item->Is_SymLink())
+ if (!item->LinkName.IsEmpty())
+ TarStringToUnicode(item->LinkName, prop);
+ break;
+ case kpidHardLink:
+ if (item->Is_HardLink())
+ if (!item->LinkName.IsEmpty())
+ TarStringToUnicode(item->LinkName, prop);
+ break;
+
+ case kpidCharacts:
+ {
+ AString s;
+ {
+ s.Add_Space_if_NotEmpty();
+ AddSpecCharToString(item->LinkFlag, s);
+ }
+ if (item->IsMagic_GNU())
+ s.Add_OptSpaced("GNU");
+ else if (item->IsMagic_Posix_ustar_00())
+ s.Add_OptSpaced("POSIX");
+ else
+ {
+ s.Add_Space_if_NotEmpty();
+ for (unsigned i = 0; i < sizeof(item->Magic); i++)
+ AddSpecCharToString(item->Magic[i], s);
+ }
+
+ if (item->IsSignedChecksum)
+ s.Add_OptSpaced("SignedChecksum");
+
+ if (item->Prefix_WasUsed)
+ s.Add_OptSpaced(k_Characts_Prefix);
+
+ s.Add_OptSpaced(item->EncodingCharacts.GetCharactsString());
+
+ // AddSpecUInt64(s, "LongName", item->Num_LongName_Records);
+ // AddSpecUInt64(s, "LongLink", item->Num_LongLink_Records);
+ AddSpecBools(s, "LongName", item->LongName_WasUsed, item->LongName_WasUsed_2);
+ AddSpecBools(s, "LongLink", item->LongLink_WasUsed, item->LongLink_WasUsed_2);
+
+ if (item->MTime_IsBin)
+ s.Add_OptSpaced("bin_mtime");
+ if (item->PackSize_IsBin)
+ s.Add_OptSpaced("bin_psize");
+ if (item->Size_IsBin)
+ s.Add_OptSpaced("bin_size");
+
+ AddSpecUInt64(s, "PAX", item->Num_Pax_Records);
+
+ if (item->PaxTimes.MTime.IsDefined()) s.Add_OptSpaced("mtime");
+ if (item->PaxTimes.ATime.IsDefined()) s.Add_OptSpaced("atime");
+ if (item->PaxTimes.CTime.IsDefined()) s.Add_OptSpaced("ctime");
+
+ if (item->pax_path_WasUsed)
+ s.Add_OptSpaced("pax_path");
+ if (item->pax_link_WasUsed)
+ s.Add_OptSpaced("pax_linkpath");
+ if (item->pax_size_WasUsed)
+ s.Add_OptSpaced("pax_size");
+
+ if (item->IsThereWarning())
+ s.Add_OptSpaced("WARNING");
+ if (item->HeaderError)
+ s.Add_OptSpaced("ERROR");
+ if (item->Pax_Error)
+ s.Add_OptSpaced("PAX_error");
+ if (!item->PaxExtra.RawLines.IsEmpty())
+ s.Add_OptSpaced("PAX_unsupported_line");
+ if (item->Pax_Overflow)
+ s.Add_OptSpaced("PAX_overflow");
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+ case kpidComment:
+ {
+ AString s;
+ item->PaxExtra.Print_To_String(s);
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+ // case kpidHeadersSize: prop = item->HeaderSize; break; // for debug
+ // case kpidOffset: prop = item->HeaderPos; break; // for debug
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ ISequentialInStream *stream = _seqStream;
+ const bool seqMode = (_stream == NULL);
+ if (!seqMode)
+ stream = _stream;
+
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (_stream && numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _items[allFilesMode ? i : indices[i]].Get_UnpackSize();
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 totalPackSize;
+ totalSize = totalPackSize = 0;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(stream);
+
+ CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+
+ for (i = 0; i < numItems || seqMode; i++)
+ {
+ lps->InSize = totalPackSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItemEx *item;
+ if (seqMode)
+ {
+ HRESULT res = SkipTo(index);
+ if (res == E_INVALIDARG)
+ break;
+ RINOK(res)
+ item = &_latestItem;
+ }
+ else
+ item = &_items[index];
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ const UInt64 unpackSize = item->Get_UnpackSize();
+ totalSize += unpackSize;
+ totalPackSize += item->Get_PackSize_Aligned();
+ if (item->IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ bool skipMode = false;
+ if (!testMode && !realOutStream)
+ {
+ if (!seqMode)
+ {
+ /*
+ // probably we must show extracting info it callback handler instead
+ if (item->IsHardLink() ||
+ item->IsSymLink())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ */
+ continue;
+ }
+ skipMode = true;
+ askMode = NExtract::NAskMode::kSkip;
+ }
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ outStreamSpec->SetStream(realOutStream);
+ realOutStream.Release();
+ outStreamSpec->Init(skipMode ? 0 : unpackSize, true);
+
+ Int32 opRes = NExtract::NOperationResult::kOK;
+ CMyComPtr<ISequentialInStream> inStream2;
+ if (!item->Is_Sparse())
+ inStream2 = inStream;
+ else
+ {
+ GetStream(index, &inStream2);
+ if (!inStream2)
+ return E_FAIL;
+ }
+
+ {
+ if (item->Is_SymLink())
+ {
+ RINOK(WriteStream(outStreamSpec, (const char *)item->LinkName, item->LinkName.Len()))
+ }
+ else
+ {
+ if (!seqMode)
+ {
+ RINOK(InStream_SeekSet(_stream, item->Get_DataPos()))
+ }
+ streamSpec->Init(item->Get_PackSize_Aligned());
+ RINOK(copyCoder->Code(inStream2, outStream, NULL, NULL, progress))
+ }
+ if (outStreamSpec->GetRem() != 0)
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+ if (seqMode)
+ {
+ _latestIsRead = false;
+ _curIndex++;
+ }
+ outStreamSpec->ReleaseStream();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_IInStream(
+ CSparseStream
+)
+ UInt64 _phyPos;
+ UInt64 _virtPos;
+ bool _needStartSeek;
+
+public:
+ CHandler *Handler;
+ CMyComPtr<IUnknown> HandlerRef;
+ unsigned ItemIndex;
+ CRecordVector<UInt64> PhyOffsets;
+
+ void Init()
+ {
+ _virtPos = 0;
+ _phyPos = 0;
+ _needStartSeek = true;
+ }
+};
+
+
+Z7_COM7F_IMF(CSparseStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ const CItemEx &item = Handler->_items[ItemIndex];
+ if (_virtPos >= item.Size)
+ return S_OK;
+ {
+ UInt64 rem = item.Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ HRESULT res = S_OK;
+
+ if (item.SparseBlocks.IsEmpty())
+ memset(data, 0, size);
+ else
+ {
+ unsigned left = 0, right = item.SparseBlocks.Size();
+ for (;;)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ if (mid == left)
+ break;
+ if (_virtPos < item.SparseBlocks[mid].Offset)
+ right = mid;
+ else
+ left = mid;
+ }
+
+ const CSparseBlock &sb = item.SparseBlocks[left];
+ UInt64 relat = _virtPos - sb.Offset;
+
+ if (_virtPos >= sb.Offset && relat < sb.Size)
+ {
+ UInt64 rem = sb.Size - relat;
+ if (size > rem)
+ size = (UInt32)rem;
+ UInt64 phyPos = PhyOffsets[left] + relat;
+ if (_needStartSeek || _phyPos != phyPos)
+ {
+ RINOK(InStream_SeekSet(Handler->_stream, (item.Get_DataPos() + phyPos)))
+ _needStartSeek = false;
+ _phyPos = phyPos;
+ }
+ res = Handler->_stream->Read(data, size, &size);
+ _phyPos += size;
+ }
+ else
+ {
+ UInt64 next = item.Size;
+ if (_virtPos < sb.Offset)
+ next = sb.Offset;
+ else if (left + 1 < item.SparseBlocks.Size())
+ next = item.SparseBlocks[left + 1].Offset;
+ UInt64 rem = next - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ memset(data, 0, size);
+ }
+ }
+
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return res;
+}
+
+Z7_COM7F_IMF(CSparseStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Handler->_items[ItemIndex].Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+
+ const CItemEx &item = _items[index];
+
+ if (item.Is_Sparse())
+ {
+ CSparseStream *streamSpec = new CSparseStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+ streamSpec->Init();
+ streamSpec->Handler = this;
+ streamSpec->HandlerRef = (IInArchive *)this;
+ streamSpec->ItemIndex = index;
+ streamSpec->PhyOffsets.Reserve(item.SparseBlocks.Size());
+ UInt64 offs = 0;
+ FOR_VECTOR(i, item.SparseBlocks)
+ {
+ const CSparseBlock &sb = item.SparseBlocks[i];
+ streamSpec->PhyOffsets.AddInReserved(offs);
+ offs += sb.Size;
+ }
+ *stream = streamTemp.Detach();
+ return S_OK;
+ }
+
+ if (item.Is_SymLink())
+ {
+ Create_BufInStream_WithReference((const Byte *)(const char *)item.LinkName, item.LinkName.Len(), (IInArchive *)this, stream);
+ return S_OK;
+ }
+
+ return CreateLimitedInStream(_stream, item.Get_DataPos(), item.PackSize, stream);
+
+ COM_TRY_END
+}
+
+
+void CHandler::Init()
+{
+ _forceCodePage = false;
+ _curCodePage = _specifiedCodePage = CP_UTF8; // CP_OEMCP;
+ _posixMode = false;
+ _posixMode_WasForced = false;
+ // TimeOptions.Clear();
+ _handlerTimeOptions.Init();
+ // _handlerTimeOptions.Write_MTime.Val = true; // it's default already
+}
+
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ Init();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ UString name = names[i];
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ const PROPVARIANT &prop = values[i];
+
+ if (name[0] == L'x')
+ {
+ // some clients write 'x' property. So we support it
+ UInt32 level = 0;
+ RINOK(ParsePropToUInt32(name.Ptr(1), prop, level))
+ }
+ else if (name.IsEqualTo("cp"))
+ {
+ UInt32 cp = CP_OEMCP;
+ RINOK(ParsePropToUInt32(L"", prop, cp))
+ _forceCodePage = true;
+ _curCodePage = _specifiedCodePage = cp;
+ }
+ else if (name.IsPrefixedBy_Ascii_NoCase("mt"))
+ {
+ }
+ else if (name.IsPrefixedBy_Ascii_NoCase("memuse"))
+ {
+ }
+ else if (name.IsEqualTo("m"))
+ {
+ if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ const UString s = prop.bstrVal;
+ if (s.IsEqualTo_Ascii_NoCase("pax") ||
+ s.IsEqualTo_Ascii_NoCase("posix"))
+ _posixMode = true;
+ else if (s.IsEqualTo_Ascii_NoCase("gnu"))
+ _posixMode = false;
+ else
+ return E_INVALIDARG;
+ _posixMode_WasForced = true;
+ }
+ else
+ {
+ /*
+ if (name.IsPrefixedBy_Ascii_NoCase("td"))
+ {
+ name.Delete(0, 3);
+ if (prop.vt == VT_EMPTY)
+ {
+ if (name.IsEqualTo_Ascii_NoCase("n"))
+ {
+ // TimeOptions.UseNativeDigits = true;
+ }
+ else if (name.IsEqualTo_Ascii_NoCase("r"))
+ {
+ // TimeOptions.RemoveZeroDigits = true;
+ }
+ else
+ return E_INVALIDARG;
+ }
+ else
+ {
+ UInt32 numTimeDigits = 0;
+ RINOK(ParsePropToUInt32(name, prop, numTimeDigits));
+ TimeOptions.NumDigits_WasForced = true;
+ TimeOptions.NumDigits = numTimeDigits;
+ }
+ }
+ */
+ bool processed = false;
+ RINOK(_handlerTimeOptions.Parse(name, prop, processed))
+ if (processed)
+ continue;
+ return E_INVALIDARG;
+ }
+ }
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Tar/TarHandler.h b/CPP/7zip/Archive/Tar/TarHandler.h
new file mode 100644
index 0000000..451c2fd
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarHandler.h
@@ -0,0 +1,58 @@
+// TarHandler.h
+
+#ifndef ZIP7_INC_TAR_HANDLER_H
+#define ZIP7_INC_TAR_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../Common/HandlerOut.h"
+
+#include "TarIn.h"
+
+namespace NArchive {
+namespace NTar {
+
+Z7_CLASS_IMP_CHandler_IInArchive_4(
+ IArchiveOpenSeq
+ , IInArchiveGetStream
+ , ISetProperties
+ , IOutArchive
+)
+public:
+ CObjectVector<CItemEx> _items;
+ CMyComPtr<IInStream> _stream;
+ CMyComPtr<ISequentialInStream> _seqStream;
+private:
+ bool _isArc;
+ bool _posixMode_WasForced;
+ bool _posixMode;
+ bool _forceCodePage;
+ UInt32 _specifiedCodePage;
+ UInt32 _curCodePage;
+ UInt32 _openCodePage;
+ // CTimeOptions TimeOptions;
+ CHandlerTimeOptions _handlerTimeOptions;
+ CEncodingCharacts _encodingCharacts;
+
+ UInt32 _curIndex;
+ bool _latestIsRead;
+ CItemEx _latestItem;
+
+ CArchive _arc;
+
+ NCompress::CCopyCoder *copyCoderSpec;
+ CMyComPtr<ICompressCoder> copyCoder;
+
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *callback);
+ HRESULT SkipTo(UInt32 index);
+ void TarStringToUnicode(const AString &s, NWindows::NCOM::CPropVariant &prop, bool toOs = false) const;
+public:
+ void Init();
+ CHandler();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Tar/TarHandlerOut.cpp b/CPP/7zip/Archive/Tar/TarHandlerOut.cpp
new file mode 100644
index 0000000..c93a86e
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarHandlerOut.cpp
@@ -0,0 +1,332 @@
+// TarHandlerOut.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/MyLinux.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "TarHandler.h"
+#include "TarUpdate.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NTar {
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *type))
+{
+ UInt32 t = NFileTimeType::kUnix;
+ const UInt32 prec = _handlerTimeOptions.Prec;
+ if (prec != (UInt32)(Int32)-1)
+ {
+ t = NFileTimeType::kWindows;
+ if (prec == k_PropVar_TimePrec_0 ||
+ prec == k_PropVar_TimePrec_100ns)
+ t = NFileTimeType::kWindows;
+ else if (prec == k_PropVar_TimePrec_HighPrec)
+ t = k_PropVar_TimePrec_1ns;
+ else if (prec >= k_PropVar_TimePrec_Base)
+ t = prec;
+ }
+ // 7-Zip before 22.00 fails, if unknown typeType.
+ *type = t;
+ return S_OK;
+}
+
+
+void Get_AString_From_UString(const UString &s, AString &res,
+ UINT codePage, unsigned utfFlags)
+{
+ if (codePage == CP_UTF8)
+ ConvertUnicodeToUTF8_Flags(s, res, utfFlags);
+ else
+ UnicodeStringToMultiByte2(res, s, codePage);
+}
+
+
+HRESULT GetPropString(IArchiveUpdateCallback *callback, UInt32 index, PROPID propId, AString &res,
+ UINT codePage, unsigned utfFlags, bool convertSlash)
+{
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(index, propId, &prop))
+
+ if (prop.vt == VT_BSTR)
+ {
+ UString s = prop.bstrVal;
+ if (convertSlash)
+ NItemName::ReplaceSlashes_OsToUnix(s);
+ Get_AString_From_UString(s, res, codePage, utfFlags);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+
+ return S_OK;
+}
+
+
+// sort old files with original order.
+
+static int CompareUpdateItems(void *const *p1, void *const *p2, void *)
+{
+ const CUpdateItem &u1 = *(*((const CUpdateItem *const *)p1));
+ const CUpdateItem &u2 = *(*((const CUpdateItem *const *)p2));
+ if (!u1.NewProps)
+ {
+ if (u2.NewProps)
+ return -1;
+ return MyCompare(u1.IndexInArc, u2.IndexInArc);
+ }
+ if (!u2.NewProps)
+ return 1;
+ return MyCompare(u1.IndexInClient, u2.IndexInClient);
+}
+
+
+static HRESULT GetTime(UInt32 i, UInt32 pid, IArchiveUpdateCallback *callback,
+ CPaxTime &pt)
+{
+ pt.Clear();
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, pid, &prop))
+ return Prop_To_PaxTime(prop, pt);
+}
+
+
+/*
+static HRESULT GetDevice(IArchiveUpdateCallback *callback, UInt32 i,
+ UInt32 &majo, UInt32 &mino, bool &majo_defined, bool &mino_defined)
+{
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidDevice, &prop));
+ if (prop.vt == VT_EMPTY)
+ return S_OK;
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ {
+ const UInt64 v = prop.uhVal.QuadPart;
+ majo = MY_dev_major(v);
+ mino = MY_dev_minor(v);
+ majo_defined = true;
+ mino_defined = true;
+ }
+ return S_OK;
+}
+*/
+
+static HRESULT GetDevice(IArchiveUpdateCallback *callback, UInt32 i,
+ UInt32 pid, UInt32 &id, bool &defined)
+{
+ defined = false;
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, pid, &prop))
+ if (prop.vt == VT_EMPTY)
+ return S_OK;
+ if (prop.vt == VT_UI4)
+ {
+ id = prop.ulVal;
+ defined = true;
+ return S_OK;
+ }
+ return E_INVALIDARG;
+}
+
+
+static HRESULT GetUser(IArchiveUpdateCallback *callback, UInt32 i,
+ UInt32 pidName, UInt32 pidId, AString &name, UInt32 &id,
+ UINT codePage, unsigned utfFlags)
+{
+ // printf("\ncallback->GetProperty(i, pidId, &prop))\n");
+
+ bool isSet = false;
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, pidId, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ isSet = true;
+ id = prop.ulVal;
+ // printf("\ncallback->GetProperty(i, pidId, &prop)); = %d \n", (unsigned)id);
+ name.Empty();
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, pidName, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ const UString s = prop.bstrVal;
+ Get_AString_From_UString(s, name, codePage, utfFlags);
+ if (!isSet)
+ id = 0;
+ }
+ else if (prop.vt == VT_UI4)
+ {
+ id = prop.ulVal;
+ name.Empty();
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *callback))
+{
+ COM_TRY_BEGIN
+
+ if ((_stream && (_arc._error != k_ErrorType_OK || _arc._is_Warning
+ /* || _isSparse */
+ )) || _seqStream)
+ return E_NOTIMPL;
+ CObjectVector<CUpdateItem> updateItems;
+ const UINT codePage = (_forceCodePage ? _specifiedCodePage : _openCodePage);
+ const unsigned utfFlags = g_Unicode_To_UTF8_Flags;
+ /*
+ // for debug only:
+ unsigned utfFlags = 0;
+ utfFlags |= Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE;
+ utfFlags |= Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR;
+ */
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ CUpdateItem ui;
+ Int32 newData;
+ Int32 newProps;
+ UInt32 indexInArc;
+
+ if (!callback)
+ return E_FAIL;
+
+ RINOK(callback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArc))
+
+ ui.NewProps = IntToBool(newProps);
+ ui.NewData = IntToBool(newData);
+ ui.IndexInArc = (int)indexInArc;
+ ui.IndexInClient = i;
+
+ if (IntToBool(newProps))
+ {
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidIsDir, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.IsDir = false;
+ else if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ else
+ ui.IsDir = (prop.boolVal != VARIANT_FALSE);
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidPosixAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.Mode =
+ MY_LIN_S_IRWXO
+ | MY_LIN_S_IRWXG
+ | MY_LIN_S_IRWXU
+ | (ui.IsDir ? MY_LIN_S_IFDIR : MY_LIN_S_IFREG);
+ else if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ else
+ ui.Mode = prop.ulVal;
+ // 21.07 : we clear high file type bits as GNU TAR.
+ // we will clear it later
+ // ui.Mode &= ~(UInt32)MY_LIN_S_IFMT;
+ }
+
+ if (_handlerTimeOptions.Write_MTime.Val)
+ RINOK(GetTime(i, kpidMTime, callback, ui.PaxTimes.MTime))
+ if (_handlerTimeOptions.Write_ATime.Val)
+ RINOK(GetTime(i, kpidATime, callback, ui.PaxTimes.ATime))
+ if (_handlerTimeOptions.Write_CTime.Val)
+ RINOK(GetTime(i, kpidCTime, callback, ui.PaxTimes.CTime))
+
+ RINOK(GetPropString(callback, i, kpidPath, ui.Name, codePage, utfFlags, true))
+ if (ui.IsDir && !ui.Name.IsEmpty() && ui.Name.Back() != '/')
+ ui.Name += '/';
+ // ui.Name += '/'; // for debug
+
+ if (_posixMode)
+ {
+ RINOK(GetDevice(callback, i, kpidDeviceMajor, ui.DeviceMajor, ui.DeviceMajor_Defined))
+ RINOK(GetDevice(callback, i, kpidDeviceMinor, ui.DeviceMinor, ui.DeviceMinor_Defined))
+ }
+
+ RINOK(GetUser(callback, i, kpidUser, kpidUserId, ui.User, ui.UID, codePage, utfFlags))
+ RINOK(GetUser(callback, i, kpidGroup, kpidGroupId, ui.Group, ui.GID, codePage, utfFlags))
+ }
+
+ if (IntToBool(newData))
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ ui.Size = prop.uhVal.QuadPart;
+ /*
+ // now we support GNU extension for big files
+ if (ui.Size >= ((UInt64)1 << 33))
+ return E_INVALIDARG;
+ */
+ }
+
+ updateItems.Add(ui);
+ }
+
+ if (_arc._are_Pax_Items)
+ {
+ // we restore original order of files, if there are pax items
+ updateItems.Sort(CompareUpdateItems, NULL);
+ }
+
+ CUpdateOptions options;
+
+ options.CodePage = codePage;
+ options.UtfFlags = utfFlags;
+ options.PosixMode = _posixMode;
+
+ options.Write_MTime = _handlerTimeOptions.Write_MTime;
+ options.Write_ATime = _handlerTimeOptions.Write_ATime;
+ options.Write_CTime = _handlerTimeOptions.Write_CTime;
+
+ // options.TimeOptions = TimeOptions;
+
+ const UInt32 prec = _handlerTimeOptions.Prec;
+ if (prec != (UInt32)(Int32)-1)
+ {
+ unsigned numDigits = 0;
+ if (prec == 0)
+ numDigits = 7;
+ else if (prec == k_PropVar_TimePrec_HighPrec
+ || prec >= k_PropVar_TimePrec_1ns)
+ numDigits = 9;
+ else if (prec >= k_PropVar_TimePrec_Base)
+ numDigits = prec - k_PropVar_TimePrec_Base;
+ options.TimeOptions.NumDigitsMax = numDigits;
+ // options.TimeOptions.RemoveZeroMode =
+ // k_PaxTimeMode_DontRemoveZero; // pure for debug
+ // k_PaxTimeMode_RemoveZero_if_PureSecondOnly; // optimized code
+ // k_PaxTimeMode_RemoveZero_Always; // original pax code
+ }
+
+ return UpdateArchive(_stream, outStream, _items, updateItems,
+ options, callback);
+
+ COM_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Archive/Tar/TarHeader.cpp b/CPP/7zip/Archive/Tar/TarHeader.cpp
new file mode 100644
index 0000000..deae357
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarHeader.cpp
@@ -0,0 +1,99 @@
+// Archive/TarHeader.cpp
+
+#include "StdAfx.h"
+
+#include "TarHeader.h"
+
+namespace NArchive {
+namespace NTar {
+namespace NFileHeader {
+
+ const char * const kLongLink = "././@LongLink";
+ const char * const kLongLink2 = "@LongLink";
+
+ // The magic field is filled with this if uname and gname are valid.
+ namespace NMagic
+ {
+ // const char * const kUsTar = "ustar"; // 5 chars
+ // const char * const kGNUTar = "GNUtar "; // 7 chars and a null
+ // const char * const kEmpty = "\0\0\0\0\0\0\0\0";
+ // 7-Zip used kUsTar_00 before 21.07:
+ const char k_Posix_ustar_00[8] = { 'u', 's', 't', 'a', 'r', 0, '0', '0' } ;
+ // GNU TAR uses such header:
+ const char k_GNU_ustar[8] = { 'u', 's', 't', 'a', 'r', ' ', ' ', 0 } ;
+ }
+
+/*
+pre-POSIX.1-1988 (i.e. v7) tar header:
+-----
+Link indicator:
+'0' or 0 : Normal file
+'1' : Hard link
+'2' : Symbolic link
+Some pre-POSIX.1-1988 tar implementations indicated a directory by having
+a trailing slash (/) in the name.
+
+Numeric values : octal with leading zeroes.
+For historical reasons, a final NUL or space character should also be used.
+Thus only 11 octal digits can be stored from 12 bytes field.
+
+2001 star : introduced a base-256 coding that is indicated by
+setting the high-order bit of the leftmost byte of a numeric field.
+GNU-tar and BSD-tar followed this idea.
+
+versions of tar from before the first POSIX standard from 1988
+pad the values with spaces instead of zeroes.
+
+UStar
+-----
+UStar (Unix Standard TAR) : POSIX IEEE P1003.1 : 1988.
+ 257 signature: "ustar", 0, "00"
+ 265 32 Owner user name
+ 297 32 Owner group name
+ 329 8 Device major number
+ 337 8 Device minor number
+ 345 155 Filename prefix
+
+POSIX.1-2001/pax
+----
+format is known as extended tar format or pax format
+vendor-tagged vendor-specific enhancements.
+tags Defined by the POSIX standard:
+ atime, mtime, path, linkpath, uname, gname, size, uid, gid, ...
+
+
+PAX EXTENSION
+-----------
+Hard links
+A further difference from the ustar header block is that data blocks
+for files of typeflag 1 (hard link) may be included,
+which means that the size field may be greater than zero.
+Archives created by pax -o linkdata shall include these data
+blocks with the hard links.
+*
+
+compatiblity
+------------
+ 7-Zip 16.03 supports "PaxHeader/"
+ 7-Zip 20.01 supports "PaxHeaders.X/" with optional "./"
+ 7-Zip 21.02 supports "@PaxHeader" with optional "./" "./"
+
+ GNU tar --format=posix uses "PaxHeaders/" in folder of file
+
+
+GNU TAR format
+==============
+v7 - Unix V7
+oldgnu - GNU tar <=1.12 : writes zero in last character in name
+gnu - GNU tar 1.13 : doesn't write zero in last character in name
+ as 7-zip 21.07
+ustar - POSIX.1-1988
+posix (pax) - POSIX.1-2001
+
+ gnu tar:
+ if (S_ISCHR (st->stat.st_mode) || S_ISBLK (st->stat.st_mode)) {
+ major_t devmajor = major (st->stat.st_rdev);
+ minor_t devminor = minor (st->stat.st_rdev); }
+*/
+
+}}}
diff --git a/CPP/7zip/Archive/Tar/TarHeader.h b/CPP/7zip/Archive/Tar/TarHeader.h
new file mode 100644
index 0000000..aeccd28
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarHeader.h
@@ -0,0 +1,90 @@
+// Archive/TarHeader.h
+
+#ifndef ZIP7_INC_ARCHIVE_TAR_HEADER_H
+#define ZIP7_INC_ARCHIVE_TAR_HEADER_H
+
+#include "../../../Common/MyTypes.h"
+
+namespace NArchive {
+namespace NTar {
+
+namespace NFileHeader
+{
+ const unsigned kRecordSize = 512;
+ const unsigned kNameSize = 100;
+ const unsigned kUserNameSize = 32;
+ const unsigned kGroupNameSize = 32;
+ const unsigned kPrefixSize = 155;
+
+ const unsigned kUstarMagic_Offset = 257;
+
+ /*
+ struct CHeader
+ {
+ char Name[kNameSize];
+ char Mode[8];
+ char UID[8];
+ char GID[8];
+ char Size[12];
+ char ModificationTime[12];
+ char CheckSum[8];
+ char LinkFlag;
+ char LinkName[kNameSize];
+ char Magic[8];
+ char UserName[kUserNameSize];
+ char GroupName[kGroupNameSize];
+ char DeviceMajor[8];
+ char DeviceMinor[8];
+ char Prefix[155];
+ };
+ union CRecord
+ {
+ CHeader Header;
+ Byte Padding[kRecordSize];
+ };
+ */
+
+ namespace NLinkFlag
+ {
+ const char kOldNormal = 0; // Normal disk file, Unix compatible
+ const char kNormal = '0'; // Normal disk file
+ const char kHardLink = '1'; // Link to previously dumped file
+ const char kSymLink = '2'; // Symbolic link
+ const char kCharacter = '3'; // Character special file
+ const char kBlock = '4'; // Block special file
+ const char kDirectory = '5'; // Directory
+ const char kFIFO = '6'; // FIFO special file
+ const char kContiguous = '7'; // Contiguous file
+ const char kGnu_LongLink = 'K';
+ const char kGnu_LongName = 'L';
+ const char kSparse = 'S';
+ const char kLabel = 'V';
+ const char kPax = 'x'; // Extended header with meta data for the next file in the archive (POSIX.1-2001)
+ const char kPax_2 = 'X';
+ const char kGlobal = 'g'; // Global extended header with meta data (POSIX.1-2001)
+ const char kDumpDir = 'D'; /* GNUTYPE_DUMPDIR.
+ data: list of files created by the --incremental (-G) option
+ Each file name is preceded by either
+ - 'Y' (file should be in this archive)
+ - 'N' (file is a directory, or is not stored in the archive.)
+ Each file name is terminated by a null + an additional null after
+ the last file name. */
+ // 'A'-'Z' Vendor specific extensions (POSIX.1-1988)
+ }
+
+ extern const char * const kLongLink; // = "././@LongLink";
+ extern const char * const kLongLink2; // = "@LongLink";
+
+ namespace NMagic
+ {
+ // extern const char * const kUsTar; // = "ustar"; // 5 chars
+ // extern const char * const kGNUTar; // = "GNUtar "; // 7 chars and a null
+ // extern const char * const kEmpty; // = "\0\0\0\0\0\0\0\0"
+ extern const char k_Posix_ustar_00[8];
+ extern const char k_GNU_ustar[8];
+ }
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Tar/TarIn.cpp b/CPP/7zip/Archive/Tar/TarIn.cpp
new file mode 100644
index 0000000..90b6f84
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarIn.cpp
@@ -0,0 +1,1132 @@
+// TarIn.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/StringToInt.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "../IArchive.h"
+
+#include "TarIn.h"
+
+#define NUM_UNROLL_BYTES (8 * 4)
+
+Z7_NO_INLINE static bool IsBufNonZero(const void *data, size_t size);
+Z7_NO_INLINE static bool IsBufNonZero(const void *data, size_t size)
+{
+ const Byte *p = (const Byte *)data;
+
+ for (; size != 0 && ((unsigned)(ptrdiff_t)p & (NUM_UNROLL_BYTES - 1)) != 0; size--)
+ if (*p++ != 0)
+ return true;
+
+ if (size >= NUM_UNROLL_BYTES)
+ {
+ const Byte *lim = p + size;
+ size &= (NUM_UNROLL_BYTES - 1);
+ lim -= size;
+ do
+ {
+ if (*(const UInt64 *)(const void *)(p ) != 0) return true;
+ if (*(const UInt64 *)(const void *)(p + 8 * 1) != 0) return true;
+ if (*(const UInt64 *)(const void *)(p + 8 * 2) != 0) return true;
+ if (*(const UInt64 *)(const void *)(p + 8 * 3) != 0) return true;
+ // if (*(const UInt32 *)(const void *)(p ) != 0) return true;
+ // if (*(const UInt32 *)(const void *)(p + 4 * 1) != 0) return true;
+ // if (*(const UInt32 *)(const void *)(p + 4 * 2) != 0) return true;
+ // if (*(const UInt32 *)(const void *)(p + 4 * 3) != 0) return true;
+ p += NUM_UNROLL_BYTES;
+ }
+ while (p != lim);
+ }
+
+ for (; size != 0; size--)
+ if (*p++ != 0)
+ return true;
+
+ return false;
+}
+
+
+namespace NArchive {
+namespace NTar {
+
+static void MyStrNCpy(char *dest, const char *src, unsigned size)
+{
+ for (unsigned i = 0; i < size; i++)
+ {
+ char c = src[i];
+ dest[i] = c;
+ if (c == 0)
+ break;
+ }
+}
+
+static bool OctalToNumber(const char *srcString, unsigned size, UInt64 &res, bool allowEmpty = false)
+{
+ res = 0;
+ char sz[32];
+ MyStrNCpy(sz, srcString, size);
+ sz[size] = 0;
+ const char *end;
+ unsigned i;
+ for (i = 0; sz[i] == ' '; i++);
+ if (sz[i] == 0)
+ return allowEmpty;
+ res = ConvertOctStringToUInt64(sz + i, &end);
+ return (*end == ' ' || *end == 0);
+}
+
+static bool OctalToNumber32(const char *srcString, UInt32 &res, bool allowEmpty = false)
+{
+ const unsigned kSize = 8;
+ UInt64 res64;
+ if (!OctalToNumber(srcString, kSize, res64, allowEmpty))
+ return false;
+ res = (UInt32)res64;
+ return (res64 <= 0xFFFFFFFF);
+}
+
+#define RIF(x) { if (!(x)) return S_OK; }
+
+static void ReadString(const char *s, unsigned size, AString &result)
+{
+ result.SetFrom_CalcLen(s, size);
+}
+
+static bool ParseInt64(const char *p, Int64 &val, bool &isBin)
+{
+ const UInt32 h = GetBe32(p);
+ val = (Int64)GetBe64(p + 4);
+ isBin = true;
+ if (h == (UInt32)1 << 31)
+ return ((val >> 63) & 1) == 0;
+ if (h == (UInt32)(Int32)-1)
+ return ((val >> 63) & 1) != 0;
+ isBin = false;
+ UInt64 u;
+ const bool res = OctalToNumber(p, 12, u);
+ val = (Int64)u;
+ return res;
+}
+
+static bool ParseInt64_MTime(const char *p, Int64 &val, bool &isBin)
+{
+ // rare case tar : ZEROs in Docker-Windows TARs
+ // rare case tar : spaces
+ isBin = false;
+ if (GetUi32(p) != 0)
+ for (unsigned i = 0; i < 12; i++)
+ if (p[i] != ' ')
+ return ParseInt64(p, val, isBin);
+ val = 0;
+ return true;
+}
+
+static bool ParseSize(const char *p, UInt64 &val, bool &isBin)
+{
+ if (GetBe32(p) == (UInt32)1 << 31)
+ {
+ // GNU extension
+ isBin = true;
+ val = GetBe64(p + 4);
+ return ((val >> 63) & 1) == 0;
+ }
+ isBin = false;
+ return OctalToNumber(p, 12, val,
+ true // 20.03: allow empty size for 'V' Label entry
+ );
+}
+
+static bool ParseSize(const char *p, UInt64 &val)
+{
+ bool isBin;
+ return ParseSize(p, val, isBin);
+}
+
+#define CHECK(x) { if (!(x)) return k_IsArc_Res_NO; }
+
+API_FUNC_IsArc IsArc_Tar(const Byte *p2, size_t size)
+{
+ if (size < NFileHeader::kRecordSize)
+ return k_IsArc_Res_NEED_MORE;
+
+ const char *p = (const char *)p2;
+ p += NFileHeader::kNameSize;
+
+ UInt32 mode;
+ // we allow empty Mode value for LongName prefix items
+ CHECK(OctalToNumber32(p, mode, true)) p += 8;
+
+ // if (!OctalToNumber32(p, item.UID)) item.UID = 0;
+ p += 8;
+ // if (!OctalToNumber32(p, item.GID)) item.GID = 0;
+ p += 8;
+
+ UInt64 packSize;
+ Int64 time;
+ UInt32 checkSum;
+ bool isBin;
+ CHECK(ParseSize(p, packSize, isBin)) p += 12;
+ CHECK(ParseInt64_MTime(p, time, isBin)) p += 12;
+ CHECK(OctalToNumber32(p, checkSum))
+ return k_IsArc_Res_YES;
+}
+
+
+HRESULT CArchive::GetNextItemReal(CItemEx &item)
+{
+ char buf[NFileHeader::kRecordSize];
+
+ error = k_ErrorType_OK;
+ filled = false;
+
+ bool thereAreEmptyRecords = false;
+ for (;;)
+ {
+ size_t processedSize = NFileHeader::kRecordSize;
+ RINOK(ReadStream(SeqStream, buf, &processedSize))
+ if (processedSize == 0)
+ {
+ if (!thereAreEmptyRecords)
+ error = k_ErrorType_UnexpectedEnd; // "There are no trailing zero-filled records";
+ return S_OK;
+ }
+ if (processedSize != NFileHeader::kRecordSize)
+ {
+ if (!thereAreEmptyRecords)
+ error = k_ErrorType_UnexpectedEnd; // error = "There is no correct record at the end of archive";
+ else
+ {
+ /*
+ if (IsEmptyData(buf, processedSize))
+ error = k_ErrorType_UnexpectedEnd;
+ else
+ {
+ // extraReadSize = processedSize;
+ // error = k_ErrorType_Corrupted; // some data after the end tail zeros
+ }
+ */
+ }
+
+ return S_OK;
+ }
+ if (IsBufNonZero(buf, NFileHeader::kRecordSize))
+ break;
+ item.HeaderSize += NFileHeader::kRecordSize;
+ thereAreEmptyRecords = true;
+ if (OpenCallback)
+ {
+ RINOK(Progress(item, 0))
+ }
+ }
+ if (thereAreEmptyRecords)
+ {
+ // error = "There are data after end of archive";
+ return S_OK;
+ }
+
+ char *p = buf;
+
+ error = k_ErrorType_Corrupted;
+
+ // ReadString(p, NFileHeader::kNameSize, item.Name);
+ p += NFileHeader::kNameSize;
+
+ /*
+ item.Name_CouldBeReduced =
+ (item.Name.Len() == NFileHeader::kNameSize ||
+ item.Name.Len() == NFileHeader::kNameSize - 1);
+ */
+
+ // we allow empty Mode value for LongName prefix items
+ RIF(OctalToNumber32(p, item.Mode, true)) p += 8;
+
+ if (!OctalToNumber32(p, item.UID)) { item.UID = 0; } p += 8;
+ if (!OctalToNumber32(p, item.GID)) { item.GID = 0; } p += 8;
+
+ RIF(ParseSize(p, item.PackSize, item.PackSize_IsBin))
+ item.Size = item.PackSize;
+ item.Size_IsBin = item.PackSize_IsBin;
+ p += 12;
+ RIF(ParseInt64_MTime(p, item.MTime, item.MTime_IsBin)) p += 12;
+
+ UInt32 checkSum;
+ RIF(OctalToNumber32(p, checkSum))
+ memset(p, ' ', 8); p += 8;
+
+ item.LinkFlag = *p++;
+
+ ReadString(p, NFileHeader::kNameSize, item.LinkName); p += NFileHeader::kNameSize;
+
+ /*
+ item.LinkName_CouldBeReduced =
+ (item.LinkName.Len() == NFileHeader::kNameSize ||
+ item.LinkName.Len() == NFileHeader::kNameSize - 1);
+ */
+
+ memcpy(item.Magic, p, 8); p += 8;
+
+ ReadString(p, NFileHeader::kUserNameSize, item.User); p += NFileHeader::kUserNameSize;
+ ReadString(p, NFileHeader::kGroupNameSize, item.Group); p += NFileHeader::kGroupNameSize;
+
+ item.DeviceMajor_Defined = (p[0] != 0); if (item.DeviceMajor_Defined) { RIF(OctalToNumber32(p, item.DeviceMajor)) } p += 8;
+ item.DeviceMinor_Defined = (p[0] != 0); if (item.DeviceMinor_Defined) { RIF(OctalToNumber32(p, item.DeviceMinor)) } p += 8;
+
+ if (p[0] != 0
+ && item.IsMagic_ustar_5chars()
+ && (item.LinkFlag != 'L' ))
+ {
+ item.Prefix_WasUsed = true;
+ ReadString(p, NFileHeader::kPrefixSize, item.Name);
+ item.Name += '/';
+ unsigned i;
+ for (i = 0; i < NFileHeader::kNameSize; i++)
+ if (buf[i] == 0)
+ break;
+ item.Name.AddFrom(buf, i);
+ }
+ else
+ ReadString(buf, NFileHeader::kNameSize, item.Name);
+
+ p += NFileHeader::kPrefixSize;
+
+ if (item.LinkFlag == NFileHeader::NLinkFlag::kHardLink)
+ {
+ item.PackSize = 0;
+ item.Size = 0;
+ }
+
+ if (item.LinkFlag == NFileHeader::NLinkFlag::kDirectory)
+ {
+ // GNU tar ignores Size field, if LinkFlag is kDirectory
+ // 21.02 : we set PackSize = 0 to be more compatible with GNU tar
+ item.PackSize = 0;
+ // item.Size = 0;
+ }
+
+ /*
+ TAR standard requires sum of unsigned byte values.
+ But some old TAR programs use sum of signed byte values.
+ So we check both values.
+ */
+ // for (int y = 0; y < 100; y++) // for debug
+ {
+ UInt32 sum0 = 0;
+ {
+ for (unsigned i = 0; i < NFileHeader::kRecordSize; i++)
+ sum0 += (Byte)buf[i];
+ }
+ if (sum0 != checkSum)
+ {
+ Int32 sum = 0;
+ for (unsigned i = 0; i < NFileHeader::kRecordSize; i++)
+ sum += (signed char)buf[i];
+ if ((UInt32)sum != checkSum)
+ return S_OK;
+ item.IsSignedChecksum = true;
+ }
+ }
+
+ item.HeaderSize += NFileHeader::kRecordSize;
+
+ if (item.LinkFlag == NFileHeader::NLinkFlag::kSparse)
+ {
+ Byte isExtended = (Byte)buf[482];
+ if (isExtended != 0 && isExtended != 1)
+ return S_OK;
+ RIF(ParseSize(buf + 483, item.Size, item.Size_IsBin))
+ UInt64 min = 0;
+ for (unsigned i = 0; i < 4; i++)
+ {
+ p = buf + 386 + 24 * i;
+ if (GetBe32(p) == 0)
+ {
+ if (isExtended != 0)
+ return S_OK;
+ break;
+ }
+ CSparseBlock sb;
+ RIF(ParseSize(p, sb.Offset))
+ RIF(ParseSize(p + 12, sb.Size))
+ item.SparseBlocks.Add(sb);
+ if (sb.Offset < min || sb.Offset > item.Size)
+ return S_OK;
+ if ((sb.Offset & 0x1FF) != 0 || (sb.Size & 0x1FF) != 0)
+ return S_OK;
+ min = sb.Offset + sb.Size;
+ if (min < sb.Offset)
+ return S_OK;
+ }
+ if (min > item.Size)
+ return S_OK;
+
+ while (isExtended != 0)
+ {
+ size_t processedSize = NFileHeader::kRecordSize;
+ RINOK(ReadStream(SeqStream, buf, &processedSize))
+ if (processedSize != NFileHeader::kRecordSize)
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return S_OK;
+ }
+
+ item.HeaderSize += NFileHeader::kRecordSize;
+
+ if (OpenCallback)
+ {
+ RINOK(Progress(item, 0))
+ }
+
+ isExtended = (Byte)buf[21 * 24];
+ if (isExtended != 0 && isExtended != 1)
+ return S_OK;
+ for (unsigned i = 0; i < 21; i++)
+ {
+ p = buf + 24 * i;
+ if (GetBe32(p) == 0)
+ {
+ if (isExtended != 0)
+ return S_OK;
+ break;
+ }
+ CSparseBlock sb;
+ RIF(ParseSize(p, sb.Offset))
+ RIF(ParseSize(p + 12, sb.Size))
+ item.SparseBlocks.Add(sb);
+ if (sb.Offset < min || sb.Offset > item.Size)
+ return S_OK;
+ if ((sb.Offset & 0x1FF) != 0 || (sb.Size & 0x1FF) != 0)
+ return S_OK;
+ min = sb.Offset + sb.Size;
+ if (min < sb.Offset)
+ return S_OK;
+ }
+ }
+ if (min > item.Size)
+ return S_OK;
+ }
+
+ if (item.PackSize >= (UInt64)1 << 63)
+ return S_OK;
+
+ filled = true;
+ error = k_ErrorType_OK;
+ return S_OK;
+}
+
+
+HRESULT CArchive::Progress(const CItemEx &item, UInt64 posOffset)
+{
+ const UInt64 pos = item.Get_DataPos() + posOffset;
+ if (NumFiles - NumFiles_Prev < (1 << 16)
+ // && NumRecords - NumRecords_Prev < (1 << 16)
+ && pos - Pos_Prev < ((UInt32)1 << 28))
+ return S_OK;
+ {
+ Pos_Prev = pos;
+ NumFiles_Prev = NumFiles;
+ // NumRecords_Prev = NumRecords;
+ // Sleep(100); // for debug
+ return OpenCallback->SetCompleted(&NumFiles, &pos);
+ }
+}
+
+
+HRESULT CArchive::ReadDataToBuffer(const CItemEx &item,
+ CTempBuffer &tb, size_t stringLimit)
+{
+ tb.Init();
+ UInt64 packSize = item.Get_PackSize_Aligned();
+ if (packSize == 0)
+ return S_OK;
+
+ UInt64 pos;
+
+ {
+ size_t size = stringLimit;
+ if (size > packSize)
+ size = (size_t)packSize;
+ tb.Buffer.AllocAtLeast(size);
+ size_t processedSize = size;
+ const HRESULT res = ReadStream(SeqStream, tb.Buffer, &processedSize);
+ pos = processedSize;
+ if (processedSize != size)
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return res;
+ }
+ RINOK(res)
+
+ packSize -= size;
+
+ size_t i;
+ const Byte *p = tb.Buffer;
+ for (i = 0; i < size; i++)
+ if (p[i] == 0)
+ break;
+ if (i >= item.PackSize)
+ tb.StringSize_IsConfirmed = true;
+ if (i > item.PackSize)
+ {
+ tb.StringSize = (size_t)item.PackSize;
+ tb.IsNonZeroTail = true;
+ }
+ else
+ {
+ tb.StringSize = i;
+ if (i != size)
+ {
+ tb.StringSize_IsConfirmed = true;
+ if (IsBufNonZero(p + i, size - i))
+ tb.IsNonZeroTail = true;
+ }
+ }
+
+ if (packSize == 0)
+ return S_OK;
+ }
+
+ if (InStream)
+ {
+ RINOK(InStream->Seek((Int64)packSize, STREAM_SEEK_CUR, NULL))
+ return S_OK;
+ }
+ const unsigned kBufSize = 1 << 15;
+ Buffer.AllocAtLeast(kBufSize);
+
+ do
+ {
+ if (OpenCallback)
+ {
+ RINOK(Progress(item, pos))
+ }
+
+ unsigned size = kBufSize;
+ if (size > packSize)
+ size = (unsigned)packSize;
+ size_t processedSize = size;
+ const HRESULT res = ReadStream(SeqStream, Buffer, &processedSize);
+ if (processedSize != size)
+ {
+ error = k_ErrorType_UnexpectedEnd;
+ return res;
+ }
+ if (!tb.IsNonZeroTail)
+ {
+ if (IsBufNonZero(Buffer, size))
+ tb.IsNonZeroTail = true;
+ }
+ packSize -= size;
+ pos += size;
+ }
+ while (packSize != 0);
+ return S_OK;
+}
+
+
+
+struct CPaxInfo: public CPaxTimes
+{
+ bool DoubleTagError;
+ bool TagParsingError;
+ bool UnknownLines_Overflow;
+ bool Size_Defined;
+ bool UID_Defined;
+ bool GID_Defined;
+ bool Path_Defined;
+ bool Link_Defined;
+ bool User_Defined;
+ bool Group_Defined;
+
+ UInt64 Size;
+ UInt32 UID;
+ UInt32 GID;
+
+ AString Path;
+ AString Link;
+ AString User;
+ AString Group;
+ AString UnknownLines;
+
+ bool ParseID(const AString &val, bool &defined, UInt32 &res)
+ {
+ if (defined)
+ DoubleTagError = true;
+ if (val.IsEmpty())
+ return false;
+ const char *end2;
+ res = ConvertStringToUInt32(val.Ptr(), &end2);
+ if (*end2 != 0)
+ return false;
+ defined = true;
+ return true;
+ }
+
+ bool ParsePax(const CTempBuffer &tb, bool isFile);
+};
+
+
+static bool ParsePaxTime(const AString &src, CPaxTime &pt, bool &doubleTagError)
+{
+ if (pt.IsDefined())
+ doubleTagError = true;
+ pt.Clear();
+ const char *s = src.Ptr();
+ bool isNegative = false;
+ if (*s == '-')
+ {
+ isNegative = true;
+ s++;
+ }
+ const char *end;
+ {
+ UInt64 sec = ConvertStringToUInt64(s, &end);
+ if (s == end)
+ return false;
+ if (sec >= ((UInt64)1 << 63))
+ return false;
+ if (isNegative)
+ sec = (UInt64)-(Int64)sec;
+ pt.Sec = (Int64)sec;
+ }
+ if (*end == 0)
+ {
+ pt.Ns = 0;
+ pt.NumDigits = 0;
+ return true;
+ }
+ if (*end != '.')
+ return false;
+ s = end + 1;
+
+ UInt32 ns = 0;
+ unsigned i;
+ const unsigned kNsDigits = 9;
+ for (i = 0;; i++)
+ {
+ const char c = s[i];
+ if (c == 0)
+ break;
+ if (c < '0' || c > '9')
+ return false;
+ // we ignore digits after 9 digits as GNU TAR
+ if (i < kNsDigits)
+ {
+ ns *= 10;
+ ns += (unsigned)(c - '0');
+ }
+ }
+ pt.NumDigits = (int)(i < kNsDigits ? i : kNsDigits);
+ while (i < kNsDigits)
+ {
+ ns *= 10;
+ i++;
+ }
+ if (isNegative && ns != 0)
+ {
+ pt.Sec--;
+ ns = (UInt32)1000 * 1000 * 1000 - ns;
+ }
+ pt.Ns = ns;
+ return true;
+}
+
+
+bool CPaxInfo::ParsePax(const CTempBuffer &tb, bool isFile)
+{
+ DoubleTagError = false;
+ TagParsingError = false;
+ UnknownLines_Overflow = false;
+ Size_Defined = false;
+ UID_Defined = false;
+ GID_Defined = false;
+ Path_Defined = false;
+ Link_Defined = false;
+ User_Defined = false;
+ Group_Defined = false;
+
+ // CPaxTimes::Clear();
+
+ const char *s = (const char *)(const void *)(const Byte *)tb.Buffer;
+ size_t rem = tb.StringSize;
+
+ Clear();
+
+ AString name, val;
+
+ while (rem != 0)
+ {
+ unsigned i;
+ for (i = 0;; i++)
+ {
+ if (i > 24 || i >= rem) // we use limitation for size of (size) field
+ return false;
+ if (s[i] == ' ')
+ break;
+ }
+ if (i == 0)
+ return false;
+ const char *end;
+ const UInt32 size = ConvertStringToUInt32(s, &end);
+ const unsigned offset = (unsigned)(end - s) + 1;
+ if (size > rem
+ || size <= offset + 1
+ || offset != i + 1
+ || s[size - 1] != '\n')
+ return false;
+
+ for (i = offset; i < size; i++)
+ if (s[i] == 0)
+ return false;
+
+ for (i = offset; i < size - 1; i++)
+ if (s[i] == '=')
+ break;
+ if (i == size - 1)
+ return false;
+
+ name.SetFrom(s + offset, i - offset);
+ val.SetFrom(s + i + 1, (unsigned)(size - 1 - (i + 1)));
+
+ bool parsed = false;
+ if (isFile)
+ {
+ bool isDetectedName = true;
+ // only lower case (name) is supported
+ if (name.IsEqualTo("path"))
+ {
+ if (Path_Defined)
+ DoubleTagError = true;
+ Path = val;
+ Path_Defined = true;
+ parsed = true;
+ }
+ else if (name.IsEqualTo("linkpath"))
+ {
+ if (Link_Defined)
+ DoubleTagError = true;
+ Link = val;
+ Link_Defined = true;
+ parsed = true;
+ }
+ else if (name.IsEqualTo("uname"))
+ {
+ if (User_Defined)
+ DoubleTagError = true;
+ User = val;
+ User_Defined = true;
+ parsed = true;
+ }
+ else if (name.IsEqualTo("gname"))
+ {
+ if (Group_Defined)
+ DoubleTagError = true;
+ Group = val;
+ Group_Defined = true;
+ parsed = true;
+ }
+ else if (name.IsEqualTo("uid"))
+ {
+ parsed = ParseID(val, UID_Defined, UID);
+ }
+ else if (name.IsEqualTo("gid"))
+ {
+ parsed = ParseID(val, GID_Defined, GID);
+ }
+ else if (name.IsEqualTo("size"))
+ {
+ if (Size_Defined)
+ DoubleTagError = true;
+ Size_Defined = false;
+ if (!val.IsEmpty())
+ {
+ const char *end2;
+ Size = ConvertStringToUInt64(val.Ptr(), &end2);
+ if (*end2 == 0)
+ {
+ Size_Defined = true;
+ parsed = true;
+ }
+ }
+ }
+ else if (name.IsEqualTo("mtime"))
+ { parsed = ParsePaxTime(val, MTime, DoubleTagError); }
+ else if (name.IsEqualTo("atime"))
+ { parsed = ParsePaxTime(val, ATime, DoubleTagError); }
+ else if (name.IsEqualTo("ctime"))
+ { parsed = ParsePaxTime(val, CTime, DoubleTagError); }
+ else
+ isDetectedName = false;
+ if (isDetectedName && !parsed)
+ TagParsingError = true;
+ }
+ if (!parsed)
+ {
+ if (!UnknownLines_Overflow)
+ {
+ const unsigned addSize = size - offset;
+ if (UnknownLines.Len() + addSize < (1 << 16))
+ UnknownLines.AddFrom(s + offset, addSize);
+ else
+ UnknownLines_Overflow = true;
+ }
+ }
+
+ s += size;
+ rem -= size;
+ }
+ return true;
+}
+
+
+HRESULT CArchive::ReadItem2(CItemEx &item)
+{
+ // CItem
+
+ item.SparseBlocks.Clear();
+ item.PaxTimes.Clear();
+
+ // CItemEx
+
+ item.HeaderSize = 0;
+ item.Num_Pax_Records = 0;
+
+ item.LongName_WasUsed = false;
+ item.LongName_WasUsed_2 = false;
+
+ item.LongLink_WasUsed = false;
+ item.LongLink_WasUsed_2 = false;
+
+ item.HeaderError = false;
+ item.IsSignedChecksum = false;
+ item.Prefix_WasUsed = false;
+
+ item.Pax_Error = false;
+ item.Pax_Overflow = false;
+ item.pax_path_WasUsed = false;
+ item.pax_link_WasUsed = false;
+ item.pax_size_WasUsed = false;
+
+ item.PaxExtra.Clear();
+
+ item.EncodingCharacts.Clear();
+
+ // CArchive temp variable
+
+ NameBuf.Init();
+ LinkBuf.Init();
+ PaxBuf.Init();
+ PaxBuf_global.Init();
+
+ UInt64 numExtraRecords = 0;
+
+ for (;;)
+ {
+ if (OpenCallback)
+ {
+ RINOK(Progress(item, 0))
+ }
+
+ RINOK(GetNextItemReal(item))
+
+ // NumRecords++;
+
+ if (!filled)
+ {
+ if (error == k_ErrorType_OK)
+ if (numExtraRecords != 0
+ || item.LongName_WasUsed
+ || item.LongLink_WasUsed
+ || item.Num_Pax_Records != 0)
+ error = k_ErrorType_Corrupted;
+ return S_OK;
+ }
+ if (error != k_ErrorType_OK)
+ return S_OK;
+
+ numExtraRecords++;
+
+ const char lf = item.LinkFlag;
+ if (lf == NFileHeader::NLinkFlag::kGnu_LongName ||
+ lf == NFileHeader::NLinkFlag::kGnu_LongLink)
+ {
+ // GNU tar ignores item.Name after LinkFlag test
+ // 22.00 : now we also ignore item.Name here
+ /*
+ if (item.Name != NFileHeader::kLongLink &&
+ item.Name != NFileHeader::kLongLink2)
+ {
+ break;
+ // return S_OK;
+ }
+ */
+
+ CTempBuffer *tb =
+ lf == NFileHeader::NLinkFlag::kGnu_LongName ?
+ &NameBuf :
+ &LinkBuf;
+
+ /*
+ if (item.PackSize > (1 << 29))
+ {
+ // break;
+ return S_OK;
+ }
+ */
+
+ const unsigned kLongNameSizeMax = (unsigned)1 << 14;
+ RINOK(ReadDataToBuffer(item, *tb, kLongNameSizeMax))
+ if (error != k_ErrorType_OK)
+ return S_OK;
+
+ if (lf == NFileHeader::NLinkFlag::kGnu_LongName)
+ {
+ item.LongName_WasUsed_2 =
+ item.LongName_WasUsed;
+ item.LongName_WasUsed = true;
+ }
+ else
+ {
+ item.LongLink_WasUsed_2 =
+ item.LongLink_WasUsed;
+ item.LongLink_WasUsed = true;
+ }
+
+ if (!tb->StringSize_IsConfirmed)
+ tb->StringSize = 0;
+ item.HeaderSize += item.Get_PackSize_Aligned();
+ if (tb->StringSize == 0 ||
+ tb->StringSize + 1 != item.PackSize)
+ item.HeaderError = true;
+ if (tb->IsNonZeroTail)
+ item.HeaderError = true;
+ continue;
+ }
+
+ if (lf == NFileHeader::NLinkFlag::kGlobal ||
+ lf == NFileHeader::NLinkFlag::kPax ||
+ lf == NFileHeader::NLinkFlag::kPax_2)
+ {
+ // GNU tar ignores item.Name after LinkFlag test
+ // 22.00 : now we also ignore item.Name here
+ /*
+ if (item.PackSize > (UInt32)1 << 26)
+ {
+ break; // we don't want big PaxBuf files
+ // return S_OK;
+ }
+ */
+ const unsigned kParsingPaxSizeMax = (unsigned)1 << 26;
+
+ const bool isStartHeader = (item.HeaderSize == NFileHeader::kRecordSize);
+
+ CTempBuffer *tb = (lf == NFileHeader::NLinkFlag::kGlobal ? &PaxBuf_global : &PaxBuf);
+
+ RINOK(ReadDataToBuffer(item, *tb, kParsingPaxSizeMax))
+ if (error != k_ErrorType_OK)
+ return S_OK;
+
+ item.HeaderSize += item.Get_PackSize_Aligned();
+
+ if (tb->StringSize != item.PackSize
+ || tb->StringSize == 0
+ || tb->IsNonZeroTail)
+ item.Pax_Error = true;
+
+ item.Num_Pax_Records++;
+ if (lf != NFileHeader::NLinkFlag::kGlobal)
+ {
+ item.PaxExtra.RecordPath = item.Name;
+ continue;
+ }
+ // break; // for debug
+ {
+ if (PaxGlobal_Defined)
+ _is_PaxGlobal_Error = true;
+ CPaxInfo paxInfo;
+ if (paxInfo.ParsePax(PaxBuf_global, false))
+ {
+ PaxGlobal.RawLines = paxInfo.UnknownLines;
+ PaxGlobal.RecordPath = item.Name;
+ PaxGlobal_Defined = true;
+ }
+ else
+ _is_PaxGlobal_Error = true;
+
+ if (isStartHeader
+ && item.Num_Pax_Records == 1
+ && numExtraRecords == 1)
+ {
+ // we skip global pax header info after parsing
+ item.HeaderPos += item.HeaderSize;
+ item.HeaderSize = 0;
+ item.Num_Pax_Records = 0;
+ numExtraRecords = 0;
+ }
+ else
+ _is_PaxGlobal_Error = true;
+ }
+ continue;
+ }
+
+ /*
+ if (lf == NFileHeader::NLinkFlag::kDumpDir ||
+ lf == NFileHeader::NLinkFlag::kSparse)
+ {
+ // GNU Extensions to the Archive Format
+ break;
+ }
+ if (lf > '7' || (lf < '0' && lf != 0))
+ {
+ break;
+ // return S_OK;
+ }
+ */
+ break;
+ }
+
+ // we still use name from main header, if long_name is bad
+ if (item.LongName_WasUsed && NameBuf.StringSize != 0)
+ {
+ NameBuf.CopyToString(item.Name);
+ // item.Name_CouldBeReduced = false;
+ }
+
+ if (item.LongLink_WasUsed)
+ {
+ // we use empty link, if long_link is bad
+ LinkBuf.CopyToString(item.LinkName);
+ // item.LinkName_CouldBeReduced = false;
+ }
+
+ error = k_ErrorType_OK;
+
+ if (PaxBuf.StringSize != 0)
+ {
+ CPaxInfo paxInfo;
+ if (!paxInfo.ParsePax(PaxBuf, true))
+ item.Pax_Error = true;
+ else
+ {
+ if (paxInfo.Path_Defined) // if (!paxInfo.Path.IsEmpty())
+ {
+ item.Name = paxInfo.Path;
+ item.pax_path_WasUsed = true;
+ }
+ if (paxInfo.Link_Defined) // (!paxInfo.Link.IsEmpty())
+ {
+ item.LinkName = paxInfo.Link;
+ item.pax_link_WasUsed = true;
+ }
+ if (paxInfo.User_Defined)
+ {
+ item.User = paxInfo.User;
+ // item.pax_uname_WasUsed = true;
+ }
+ if (paxInfo.Group_Defined)
+ {
+ item.Group = paxInfo.Group;
+ // item.pax_gname_WasUsed = true;
+ }
+ if (paxInfo.UID_Defined)
+ {
+ item.UID = (UInt32)paxInfo.UID;
+ }
+ if (paxInfo.GID_Defined)
+ {
+ item.GID = (UInt32)paxInfo.GID;
+ }
+
+ if (paxInfo.Size_Defined)
+ {
+ const UInt64 piSize = paxInfo.Size;
+ // GNU TAR ignores (item.Size) in that case
+ if (item.Size != 0 && item.Size != piSize)
+ item.Pax_Error = true;
+ item.Size = piSize;
+ item.PackSize = piSize;
+ item.pax_size_WasUsed = true;
+ }
+
+ item.PaxTimes = paxInfo;
+ item.PaxExtra.RawLines = paxInfo.UnknownLines;
+ if (paxInfo.UnknownLines_Overflow)
+ item.Pax_Overflow = true;
+ if (paxInfo.TagParsingError)
+ item.Pax_Error = true;
+ if (paxInfo.DoubleTagError)
+ item.Pax_Error = true;
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+HRESULT CArchive::ReadItem(CItemEx &item)
+{
+ item.HeaderPos = _phySize;
+
+ const HRESULT res = ReadItem2(item);
+
+ /*
+ if (error == k_ErrorType_Warning)
+ _is_Warning = true;
+ else
+ */
+
+ if (error != k_ErrorType_OK)
+ _error = error;
+
+ RINOK(res)
+
+ if (filled)
+ {
+ if (item.IsMagic_GNU())
+ _are_Gnu = true;
+ else if (item.IsMagic_Posix_ustar_00())
+ _are_Posix = true;
+
+ if (item.Num_Pax_Records != 0)
+ _are_Pax = true;
+
+ if (item.PaxTimes.MTime.IsDefined()) _are_mtime = true;
+ if (item.PaxTimes.ATime.IsDefined()) _are_atime = true;
+ if (item.PaxTimes.CTime.IsDefined()) _are_ctime = true;
+
+ if (item.pax_path_WasUsed)
+ _are_pax_path = true;
+ if (item.pax_link_WasUsed)
+ _are_pax_link = true;
+ if (item.LongName_WasUsed)
+ _are_LongName = true;
+ if (item.LongLink_WasUsed)
+ _are_LongLink = true;
+ if (item.Prefix_WasUsed)
+ _pathPrefix_WasUsed = true;
+ /*
+ if (item.IsSparse())
+ _isSparse = true;
+ */
+ if (item.Is_PaxExtendedHeader())
+ _are_Pax_Items = true;
+ if (item.IsThereWarning()
+ || item.HeaderError
+ || item.Pax_Error)
+ _is_Warning = true;
+ }
+
+ const UInt64 headerEnd = item.HeaderPos + item.HeaderSize;
+ // _headersSize += headerEnd - _phySize;
+ // we don't count skipped records
+ _headersSize += item.HeaderSize;
+ _phySize = headerEnd;
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Tar/TarIn.h b/CPP/7zip/Archive/Tar/TarIn.h
new file mode 100644
index 0000000..8c69057
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarIn.h
@@ -0,0 +1,149 @@
+// TarIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_TAR_IN_H
+#define ZIP7_INC_ARCHIVE_TAR_IN_H
+
+#include "../IArchive.h"
+
+#include "TarItem.h"
+
+namespace NArchive {
+namespace NTar {
+
+enum EErrorType
+{
+ k_ErrorType_OK,
+ k_ErrorType_Corrupted,
+ k_ErrorType_UnexpectedEnd
+ // , k_ErrorType_Warning
+};
+
+
+struct CTempBuffer
+{
+ CByteBuffer Buffer;
+ size_t StringSize; // num characters before zero Byte (StringSize <= item.PackSize)
+ bool IsNonZeroTail;
+ bool StringSize_IsConfirmed;
+
+ void CopyToString(AString &s)
+ {
+ s.Empty();
+ if (StringSize != 0)
+ s.SetFrom((const char *)(const void *)(const Byte *)Buffer, (unsigned)StringSize);
+ }
+
+ void Init()
+ {
+ StringSize = 0;
+ IsNonZeroTail = false;
+ StringSize_IsConfirmed = false;
+ }
+};
+
+
+class CArchive
+{
+public:
+ bool _phySize_Defined;
+ bool _is_Warning;
+ bool PaxGlobal_Defined;
+ bool _is_PaxGlobal_Error;
+ bool _are_Pax_Items;
+ bool _are_Gnu;
+ bool _are_Posix;
+ bool _are_Pax;
+ bool _are_mtime;
+ bool _are_atime;
+ bool _are_ctime;
+ bool _are_pax_path;
+ bool _are_pax_link;
+ bool _are_LongName;
+ bool _are_LongLink;
+ bool _pathPrefix_WasUsed;
+ // bool _isSparse;
+
+ // temp internal vars for ReadItem():
+ bool filled;
+private:
+ EErrorType error;
+
+public:
+ UInt64 _phySize;
+ UInt64 _headersSize;
+ EErrorType _error;
+
+ ISequentialInStream *SeqStream;
+ IInStream *InStream;
+ IArchiveOpenCallback *OpenCallback;
+ UInt64 NumFiles;
+ UInt64 NumFiles_Prev;
+ UInt64 Pos_Prev;
+ // UInt64 NumRecords;
+ // UInt64 NumRecords_Prev;
+
+ CPaxExtra PaxGlobal;
+
+ void Clear()
+ {
+ SeqStream = NULL;
+ InStream = NULL;
+ OpenCallback = NULL;
+ NumFiles = 0;
+ NumFiles_Prev = 0;
+ Pos_Prev = 0;
+ // NumRecords = 0;
+ // NumRecords_Prev = 0;
+
+ PaxGlobal.Clear();
+ PaxGlobal_Defined = false;
+ _is_PaxGlobal_Error = false;
+ _are_Pax_Items = false; // if there are final paxItems
+ _are_Gnu = false;
+ _are_Posix = false;
+ _are_Pax = false;
+ _are_mtime = false;
+ _are_atime = false;
+ _are_ctime = false;
+ _are_pax_path = false;
+ _are_pax_link = false;
+ _are_LongName = false;
+ _are_LongLink = false;
+ _pathPrefix_WasUsed = false;
+ // _isSparse = false;
+
+ _is_Warning = false;
+ _error = k_ErrorType_OK;
+
+ _phySize_Defined = false;
+ _phySize = 0;
+ _headersSize = 0;
+ }
+
+private:
+ CTempBuffer NameBuf;
+ CTempBuffer LinkBuf;
+ CTempBuffer PaxBuf;
+ CTempBuffer PaxBuf_global;
+
+ CByteBuffer Buffer;
+
+ HRESULT ReadDataToBuffer(const CItemEx &item, CTempBuffer &tb, size_t stringLimit);
+ HRESULT Progress(const CItemEx &item, UInt64 posOffset);
+ HRESULT GetNextItemReal(CItemEx &item);
+ HRESULT ReadItem2(CItemEx &itemInfo);
+public:
+ CArchive()
+ {
+ // we will call Clear() in CHandler::Close().
+ // Clear(); // it's not required here
+ }
+ HRESULT ReadItem(CItemEx &itemInfo);
+};
+
+
+API_FUNC_IsArc IsArc_Tar(const Byte *p, size_t size);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Tar/TarItem.h b/CPP/7zip/Archive/Tar/TarItem.h
new file mode 100644
index 0000000..2e12c9d
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarItem.h
@@ -0,0 +1,360 @@
+// TarItem.h
+
+#ifndef ZIP7_INC_ARCHIVE_TAR_ITEM_H
+#define ZIP7_INC_ARCHIVE_TAR_ITEM_H
+
+#include "../../../Common/MyLinux.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "TarHeader.h"
+
+namespace NArchive {
+namespace NTar {
+
+struct CSparseBlock
+{
+ UInt64 Offset;
+ UInt64 Size;
+};
+
+
+enum EPaxTimeRemoveZeroMode
+{
+ k_PaxTimeMode_DontRemoveZero,
+ k_PaxTimeMode_RemoveZero_if_PureSecondOnly,
+ k_PaxTimeMode_RemoveZero_Always
+};
+
+struct CTimeOptions
+{
+ EPaxTimeRemoveZeroMode RemoveZeroMode;
+ unsigned NumDigitsMax;
+
+ void Init()
+ {
+ RemoveZeroMode = k_PaxTimeMode_RemoveZero_if_PureSecondOnly;
+ NumDigitsMax = 0;
+ }
+ CTimeOptions() { Init(); }
+};
+
+
+struct CPaxTime
+{
+ Int32 NumDigits; // -1 means undefined
+ UInt32 Ns; // it's smaller than 1G. Even if (Sec < 0), larger (Ns) value means newer files.
+ Int64 Sec; // can be negative
+
+ Int64 GetSec() const { return NumDigits != -1 ? Sec : 0; }
+
+ bool IsDefined() const { return NumDigits != -1; }
+ // bool IsDefined_And_nonZero() const { return NumDigits != -1 && (Sec != 0 || Ns != 0); }
+
+ void Clear()
+ {
+ NumDigits = -1;
+ Ns = 0;
+ Sec = 0;
+ }
+ CPaxTime() { Clear(); }
+
+ /*
+ void ReducePrecison(int numDigits)
+ {
+ // we don't use this->NumDigits here
+ if (numDigits > 0)
+ {
+ if (numDigits >= 9)
+ return;
+ UInt32 r = 1;
+ for (unsigned i = numDigits; i < 9; i++)
+ r *= 10;
+ Ns /= r;
+ Ns *= r;
+ return;
+ }
+ Ns = 0;
+ if (numDigits == 0)
+ return;
+ UInt32 r;
+ if (numDigits == -1) r = 60;
+ else if (numDigits == -2) r = 60 * 60;
+ else if (numDigits == -3) r = 60 * 60 * 24;
+ else return;
+ Sec /= r;
+ Sec *= r;
+ }
+ */
+};
+
+
+struct CPaxTimes
+{
+ CPaxTime MTime;
+ CPaxTime ATime;
+ CPaxTime CTime;
+
+ void Clear()
+ {
+ MTime.Clear();
+ ATime.Clear();
+ CTime.Clear();
+ }
+
+ /*
+ void ReducePrecison(int numDigits)
+ {
+ MTime.ReducePrecison(numDigits);
+ CTime.ReducePrecison(numDigits);
+ ATime.ReducePrecison(numDigits);
+ }
+ */
+};
+
+
+struct CItem
+{
+ UInt64 PackSize;
+ UInt64 Size;
+ Int64 MTime;
+
+ char LinkFlag;
+ bool DeviceMajor_Defined;
+ bool DeviceMinor_Defined;
+
+ UInt32 Mode;
+ UInt32 UID;
+ UInt32 GID;
+ UInt32 DeviceMajor;
+ UInt32 DeviceMinor;
+
+ AString Name;
+ AString LinkName;
+ AString User;
+ AString Group;
+
+ char Magic[8];
+
+ CPaxTimes PaxTimes;
+
+ CRecordVector<CSparseBlock> SparseBlocks;
+
+ void SetMagic_Posix(bool posixMode)
+ {
+ memcpy(Magic, posixMode ?
+ NFileHeader::NMagic::k_Posix_ustar_00 :
+ NFileHeader::NMagic::k_GNU_ustar,
+ 8);
+ }
+
+ bool Is_SymLink() const { return LinkFlag == NFileHeader::NLinkFlag::kSymLink && (Size == 0); }
+ bool Is_HardLink() const { return LinkFlag == NFileHeader::NLinkFlag::kHardLink; }
+ bool Is_Sparse() const { return LinkFlag == NFileHeader::NLinkFlag::kSparse; }
+
+ UInt64 Get_UnpackSize() const { return Is_SymLink() ? LinkName.Len() : Size; }
+
+ bool Is_PaxExtendedHeader() const
+ {
+ switch (LinkFlag)
+ {
+ case NFileHeader::NLinkFlag::kPax:
+ case NFileHeader::NLinkFlag::kPax_2:
+ case NFileHeader::NLinkFlag::kGlobal:
+ return true;
+ }
+ return false;
+ }
+
+ UInt32 Get_Combined_Mode() const
+ {
+ return (Mode & ~(UInt32)MY_LIN_S_IFMT) | Get_FileTypeMode_from_LinkFlag();
+ }
+
+ void Set_LinkFlag_for_File(UInt32 mode)
+ {
+ char lf = NFileHeader::NLinkFlag::kNormal;
+ if (MY_LIN_S_ISCHR(mode)) lf = NFileHeader::NLinkFlag::kCharacter;
+ else if (MY_LIN_S_ISBLK(mode)) lf = NFileHeader::NLinkFlag::kBlock;
+ else if (MY_LIN_S_ISFIFO(mode)) lf = NFileHeader::NLinkFlag::kFIFO;
+ // else if (MY_LIN_S_ISDIR(mode)) lf = NFileHeader::NLinkFlag::kDirectory;
+ // else if (MY_LIN_S_ISLNK(mode)) lf = NFileHeader::NLinkFlag::kSymLink;
+ LinkFlag = lf;
+ }
+
+ UInt32 Get_FileTypeMode_from_LinkFlag() const
+ {
+ switch (LinkFlag)
+ {
+ /*
+ case NFileHeader::NLinkFlag::kDirectory:
+ case NFileHeader::NLinkFlag::kDumpDir:
+ return MY_LIN_S_IFDIR;
+ */
+ case NFileHeader::NLinkFlag::kSymLink: return MY_LIN_S_IFLNK;
+ case NFileHeader::NLinkFlag::kBlock: return MY_LIN_S_IFBLK;
+ case NFileHeader::NLinkFlag::kCharacter: return MY_LIN_S_IFCHR;
+ case NFileHeader::NLinkFlag::kFIFO: return MY_LIN_S_IFIFO;
+ // case return MY_LIN_S_IFSOCK;
+ }
+
+ if (IsDir())
+ return MY_LIN_S_IFDIR;
+ return MY_LIN_S_IFREG;
+ }
+
+ bool IsDir() const
+ {
+ switch (LinkFlag)
+ {
+ case NFileHeader::NLinkFlag::kDirectory:
+ case NFileHeader::NLinkFlag::kDumpDir:
+ return true;
+ case NFileHeader::NLinkFlag::kOldNormal:
+ case NFileHeader::NLinkFlag::kNormal:
+ case NFileHeader::NLinkFlag::kSymLink:
+ if (Name.IsEmpty())
+ return false;
+ // GNU TAR uses last character as directory marker
+ // we also do it
+ return Name.Back() == '/';
+ // return NItemName::HasTailSlash(Name, CP_OEMCP);
+ }
+ return false;
+ }
+
+ bool IsMagic_ustar_5chars() const
+ {
+ for (unsigned i = 0; i < 5; i++)
+ if (Magic[i] != NFileHeader::NMagic::k_GNU_ustar[i])
+ return false;
+ return true;
+ }
+
+ bool IsMagic_Posix_ustar_00() const
+ {
+ for (unsigned i = 0; i < 8; i++)
+ if (Magic[i] != NFileHeader::NMagic::k_Posix_ustar_00[i])
+ return false;
+ return true;
+ }
+
+ bool IsMagic_GNU() const
+ {
+ for (unsigned i = 0; i < 8; i++)
+ if (Magic[i] != NFileHeader::NMagic::k_GNU_ustar[i])
+ return false;
+ return true;
+ }
+
+ UInt64 Get_PackSize_Aligned() const { return (PackSize + 0x1FF) & (~((UInt64)0x1FF)); }
+
+ bool IsThereWarning() const
+ {
+ // that Header Warning is possible if (Size != 0) for dir item
+ return (PackSize < Size) && (LinkFlag == NFileHeader::NLinkFlag::kDirectory);
+ }
+};
+
+
+
+struct CEncodingCharacts
+{
+ bool IsAscii;
+ // bool Oem_Checked;
+ // bool Oem_Ok;
+ // bool Utf_Checked;
+ CUtf8Check UtfCheck;
+
+ void Clear()
+ {
+ IsAscii = true;
+ // Oem_Checked = false;
+ // Oem_Ok = false;
+ // Utf_Checked = false;
+ UtfCheck.Clear();
+ }
+
+ void Update(const CEncodingCharacts &ec)
+ {
+ if (!ec.IsAscii)
+ IsAscii = false;
+
+ // if (ec.Utf_Checked)
+ {
+ UtfCheck.Update(ec.UtfCheck);
+ // Utf_Checked = true;
+ }
+ }
+
+ CEncodingCharacts() { Clear(); }
+ void Check(const AString &s);
+ AString GetCharactsString() const;
+};
+
+
+struct CPaxExtra
+{
+ AString RecordPath;
+ AString RawLines;
+
+ void Clear()
+ {
+ RecordPath.Empty();
+ RawLines.Empty();
+ }
+
+ void Print_To_String(AString &s) const
+ {
+ if (!RecordPath.IsEmpty())
+ {
+ s += RecordPath;
+ s.Add_LF();
+ }
+ if (!RawLines.IsEmpty())
+ s += RawLines;
+ }
+};
+
+
+struct CItemEx: public CItem
+{
+ bool HeaderError;
+
+ bool IsSignedChecksum;
+ bool Prefix_WasUsed;
+
+ bool Pax_Error;
+ bool Pax_Overflow;
+ bool pax_path_WasUsed;
+ bool pax_link_WasUsed;
+ bool pax_size_WasUsed;
+
+ bool MTime_IsBin;
+ bool PackSize_IsBin;
+ bool Size_IsBin;
+
+ bool LongName_WasUsed;
+ bool LongName_WasUsed_2;
+
+ bool LongLink_WasUsed;
+ bool LongLink_WasUsed_2;
+
+ // bool Name_CouldBeReduced;
+ // bool LinkName_CouldBeReduced;
+
+ UInt64 HeaderPos;
+ UInt64 HeaderSize;
+
+ UInt64 Num_Pax_Records;
+ CPaxExtra PaxExtra;
+
+ CEncodingCharacts EncodingCharacts;
+
+ UInt64 Get_DataPos() const { return HeaderPos + HeaderSize; }
+ // UInt64 GetFullSize() const { return HeaderSize + PackSize; }
+ UInt64 Get_FullSize_Aligned() const { return HeaderSize + Get_PackSize_Aligned(); }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Tar/TarOut.cpp b/CPP/7zip/Archive/Tar/TarOut.cpp
new file mode 100644
index 0000000..26d0855
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarOut.cpp
@@ -0,0 +1,644 @@
+// TarOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "TarOut.h"
+
+namespace NArchive {
+namespace NTar {
+
+using namespace NFileHeader;
+
+// it's path prefix assigned by 7-Zip to show that file path was cut
+#define K_PREFIX_PATH_CUT "@PathCut"
+
+static const UInt32 k_7_oct_digits_Val_Max = ((UInt32)1 << (7 * 3)) - 1;
+
+static void WriteOctal_8(char *s, UInt32 val)
+{
+ const unsigned kNumDigits = 8 - 1;
+ if (val >= ((UInt32)1 << (kNumDigits * 3)))
+ {
+ val = 0;
+ // return false;
+ }
+ for (unsigned i = 0; i < kNumDigits; i++)
+ {
+ s[kNumDigits - 1 - i] = (char)('0' + (val & 7));
+ val >>= 3;
+ }
+ // return true;
+}
+
+static void WriteBin_64bit(char *s, UInt64 val)
+{
+ for (unsigned i = 0; i < 8; i++, val <<= 8)
+ s[i] = (char)(val >> 56);
+}
+
+static void WriteOctal_12(char *s, UInt64 val)
+{
+ const unsigned kNumDigits = 12 - 1;
+ if (val >= ((UInt64)1 << (kNumDigits * 3)))
+ {
+ // GNU extension;
+ s[0] = (char)(Byte)0x80;
+ s[1] = s[2] = s[3] = 0;
+ WriteBin_64bit(s + 4, val);
+ return;
+ }
+ for (unsigned i = 0; i < kNumDigits; i++)
+ {
+ s[kNumDigits - 1 - i] = (char)('0' + (val & 7));
+ val >>= 3;
+ }
+}
+
+static void WriteOctal_12_Signed(char *s, const Int64 val)
+{
+ if (val >= 0)
+ {
+ WriteOctal_12(s, (UInt64)val);
+ return;
+ }
+ s[0] = s[1] = s[2] = s[3] = (char)(Byte)0xFF;
+ WriteBin_64bit(s + 4, (UInt64)val);
+}
+
+static void CopyString(char *dest, const AString &src, const unsigned maxSize)
+{
+ unsigned len = src.Len();
+ if (len == 0)
+ return;
+ // 21.07: new gnu : we don't require additional 0 character at the end
+ // if (len >= maxSize)
+ if (len > maxSize)
+ {
+ len = maxSize;
+ /*
+ // oldgnu needs 0 character at the end
+ len = maxSize - 1;
+ dest[len] = 0;
+ */
+ }
+ memcpy(dest, src.Ptr(), len);
+}
+
+// #define RETURN_IF_NOT_TRUE(x) { if (!(x)) return E_INVALIDARG; }
+#define RETURN_IF_NOT_TRUE(x) { x; }
+
+#define COPY_STRING_CHECK(dest, src, size) \
+ CopyString(dest, src, size); dest += (size);
+
+#define WRITE_OCTAL_8_CHECK(dest, src) \
+ RETURN_IF_NOT_TRUE(WriteOctal_8(dest, src))
+
+
+HRESULT COutArchive::WriteHeaderReal(const CItem &item, bool isPax
+ // , bool zero_PackSize
+ // , bool zero_MTime
+ )
+{
+ /*
+ if (isPax) { we don't use Glob_Name and Prefix }
+ if (!isPax)
+ {
+ we use Glob_Name if it's not empty
+ we use Prefix if it's not empty
+ }
+ */
+ char record[kRecordSize];
+ memset(record, 0, kRecordSize);
+ char *cur = record;
+
+ COPY_STRING_CHECK (cur,
+ (!isPax && !Glob_Name.IsEmpty()) ? Glob_Name : item.Name,
+ kNameSize)
+
+ WRITE_OCTAL_8_CHECK (cur, item.Mode) cur += 8; // & k_7_oct_digits_Val_Max
+ WRITE_OCTAL_8_CHECK (cur, item.UID) cur += 8;
+ WRITE_OCTAL_8_CHECK (cur, item.GID) cur += 8;
+
+ WriteOctal_12 (cur, /* zero_PackSize ? 0 : */ item.PackSize); cur += 12;
+ WriteOctal_12_Signed (cur, /* zero_MTime ? 0 : */ item.MTime); cur += 12;
+
+ // we will use binary init for checksum instead of memset
+ // checksum field:
+ // memset(cur, ' ', 8);
+ cur += 8;
+
+ *cur++ = item.LinkFlag;
+
+ COPY_STRING_CHECK (cur, item.LinkName, kNameSize)
+
+ memcpy(cur, item.Magic, 8);
+ cur += 8;
+
+ COPY_STRING_CHECK (cur, item.User, kUserNameSize)
+ COPY_STRING_CHECK (cur, item.Group, kGroupNameSize)
+
+ const bool needDevice = (IsPosixMode && !isPax);
+
+ if (item.DeviceMajor_Defined)
+ WRITE_OCTAL_8_CHECK (cur, item.DeviceMajor)
+ else if (needDevice)
+ WRITE_OCTAL_8_CHECK (cur, 0)
+ cur += 8;
+
+ if (item.DeviceMinor_Defined)
+ WRITE_OCTAL_8_CHECK (cur, item.DeviceMinor)
+ else if (needDevice)
+ WRITE_OCTAL_8_CHECK (cur, 0)
+ cur += 8;
+
+ if (!isPax && !Prefix.IsEmpty())
+ {
+ COPY_STRING_CHECK (cur, Prefix, kPrefixSize)
+ }
+
+ if (item.Is_Sparse())
+ {
+ record[482] = (char)(item.SparseBlocks.Size() > 4 ? 1 : 0);
+ WriteOctal_12(record + 483, item.Size);
+ for (unsigned i = 0; i < item.SparseBlocks.Size() && i < 4; i++)
+ {
+ const CSparseBlock &sb = item.SparseBlocks[i];
+ char *p = record + 386 + 24 * i;
+ WriteOctal_12(p, sb.Offset);
+ WriteOctal_12(p + 12, sb.Size);
+ }
+ }
+
+ {
+ UInt32 sum = (unsigned)(' ') * 8; // we use binary init
+ {
+ for (unsigned i = 0; i < kRecordSize; i++)
+ sum += (Byte)record[i];
+ }
+ /* checksum field is formatted differently from the
+ other fields: it has [6] digits, a null, then a space. */
+ // WRITE_OCTAL_8_CHECK(record + 148, sum);
+ const unsigned kNumDigits = 6;
+ for (unsigned i = 0; i < kNumDigits; i++)
+ {
+ record[148 + kNumDigits - 1 - i] = (char)('0' + (sum & 7));
+ sum >>= 3;
+ }
+ // record[148 + 6] = 0; // we need it, if we use memset(' ') init
+ record[148 + 7] = ' '; // we need it, if we use binary init
+ }
+
+ RINOK(Write_Data(record, kRecordSize))
+
+ if (item.Is_Sparse())
+ {
+ for (unsigned i = 4; i < item.SparseBlocks.Size();)
+ {
+ memset(record, 0, kRecordSize);
+ for (unsigned t = 0; t < 21 && i < item.SparseBlocks.Size(); t++, i++)
+ {
+ const CSparseBlock &sb = item.SparseBlocks[i];
+ char *p = record + 24 * t;
+ WriteOctal_12(p, sb.Offset);
+ WriteOctal_12(p + 12, sb.Size);
+ }
+ record[21 * 24] = (char)(i < item.SparseBlocks.Size() ? 1 : 0);
+ RINOK(Write_Data(record, kRecordSize))
+ }
+ }
+
+ return S_OK;
+}
+
+
+static void AddPaxLine(AString &s, const char *name, const AString &val)
+{
+ // s.Add_LF(); // for debug
+ const unsigned len = 3 + (unsigned)strlen(name) + val.Len();
+ AString n;
+ for (unsigned numDigits = 1;; numDigits++)
+ {
+ n.Empty();
+ n.Add_UInt32(numDigits + len);
+ if (numDigits == n.Len())
+ break;
+ }
+ s += n;
+ s.Add_Space();
+ s += name;
+ s += '=';
+ s += val;
+ s.Add_LF();
+}
+
+// pt is defined : (pt.NumDigits >= 0)
+static void AddPaxTime(AString &s, const char *name, const CPaxTime &pt,
+ const CTimeOptions &options)
+{
+ unsigned numDigits = (unsigned)pt.NumDigits;
+ if (numDigits > options.NumDigitsMax)
+ numDigits = options.NumDigitsMax;
+
+ bool needNs = false;
+ UInt32 ns = 0;
+ if (numDigits != 0)
+ {
+ ns = pt.Ns;
+ // if (ns != 0) before reduction, we show all digits after digits reduction
+ needNs = (ns != 0 || options.RemoveZeroMode == k_PaxTimeMode_DontRemoveZero);
+ UInt32 d = 1;
+ for (unsigned k = numDigits; k < 9; k++)
+ d *= 10;
+ ns /= d;
+ ns *= d;
+ }
+
+ AString v;
+ {
+ Int64 sec = pt.Sec;
+ if (pt.Sec < 0)
+ {
+ sec = -sec;
+ v.Add_Minus();
+ if (ns != 0)
+ {
+ ns = 1000*1000*1000 - ns;
+ sec--;
+ }
+ }
+ v.Add_UInt64((UInt64)sec);
+ }
+
+ if (needNs)
+ {
+ AString d;
+ d.Add_UInt32(ns);
+ while (d.Len() < 9)
+ d.InsertAtFront('0');
+ // here we have precision
+ while (d.Len() > (unsigned)numDigits)
+ d.DeleteBack();
+ // GNU TAR reduces '0' digits.
+ if (options.RemoveZeroMode == k_PaxTimeMode_RemoveZero_Always)
+ while (!d.IsEmpty() && d.Back() == '0')
+ d.DeleteBack();
+
+ if (!d.IsEmpty())
+ {
+ v.Add_Dot();
+ v += d;
+ // v += "1234567009999"; // for debug
+ // for (int y = 0; y < 1000; y++) v += '8'; // for debug
+ }
+ }
+
+ AddPaxLine(s, name, v);
+}
+
+
+static void AddPax_UInt32_ifBig(AString &s, const char *name, const UInt32 &v)
+{
+ if (v > k_7_oct_digits_Val_Max)
+ {
+ AString s2;
+ s2.Add_UInt32(v);
+ AddPaxLine(s, name, s2);
+ }
+}
+
+
+/* OLD_GNU_TAR: writes name with zero at the end
+ NEW_GNU_TAR: can write name filled with all kNameSize characters */
+
+static const unsigned kNameSize_Max =
+ kNameSize; // NEW_GNU_TAR / 7-Zip 21.07
+ // kNameSize - 1; // OLD_GNU_TAR / old 7-Zip
+
+#define DOES_NAME_FIT_IN_FIELD(name) ((name).Len() <= kNameSize_Max)
+
+
+HRESULT COutArchive::WriteHeader(const CItem &item)
+{
+ Glob_Name.Empty();
+ Prefix.Empty();
+
+ unsigned namePos = 0;
+ bool needPathCut = false;
+ bool allowPrefix = false;
+
+ if (!DOES_NAME_FIT_IN_FIELD(item.Name))
+ {
+ const char *s = item.Name;
+ const char *p = s + item.Name.Len() - 1;
+ for (; *p == '/' && p != s; p--)
+ {}
+ for (; p != s && p[-1] != '/'; p--)
+ {}
+ namePos = (unsigned)(p - s);
+ needPathCut = true;
+ }
+
+ if (IsPosixMode)
+ {
+ AString s;
+
+ if (needPathCut)
+ {
+ const unsigned nameLen = item.Name.Len() - namePos;
+ if ( item.LinkFlag >= NLinkFlag::kNormal
+ && item.LinkFlag <= NLinkFlag::kDirectory
+ && namePos > 1
+ && nameLen != 0
+ // && IsPrefixAllowed
+ && item.IsMagic_Posix_ustar_00())
+ {
+ /* GNU TAR decoder supports prefix field, only if (magic)
+ signature matches 6-bytes "ustar\0".
+ so here we use prefix field only in posix mode with posix signature */
+
+ allowPrefix = true;
+ // allowPrefix = false; // for debug
+ if (namePos <= kPrefixSize + 1 && nameLen <= kNameSize_Max)
+ {
+ needPathCut = false;
+ /* we will set Prefix and Glob_Name later, for such conditions:
+ if (!DOES_NAME_FIT_IN_FIELD(item.Name) && !needPathCut) */
+ }
+ }
+
+ if (needPathCut)
+ AddPaxLine(s, "path", item.Name);
+ }
+
+ // AddPaxLine(s, "testname", AString("testval")); // for debug
+
+ if (item.LinkName.Len() > kNameSize_Max)
+ AddPaxLine(s, "linkpath", item.LinkName);
+
+ const UInt64 kPaxSize_Limit = ((UInt64)1 << 33);
+ // const UInt64 kPaxSize_Limit = ((UInt64)1 << 1); // for debug
+ // bool zero_PackSize = false;
+ if (item.PackSize >= kPaxSize_Limit)
+ {
+ /* GNU TAR in pax mode sets PackSize = 0 in main record, if pack_size >= 8 GiB
+ But old 7-Zip doesn't detect "size" property from pax header.
+ So we write real size (>= 8 GiB) to main record in binary format,
+ and old 7-Zip can decode size correctly */
+ // zero_PackSize = true;
+ AString v;
+ v.Add_UInt64(item.PackSize);
+ AddPaxLine(s, "size", v);
+ }
+
+ /* GNU TAR encoder can set "devmajor" / "devminor" attributes,
+ but GNU TAR decoder doesn't parse "devmajor" / "devminor" */
+ if (item.DeviceMajor_Defined)
+ AddPax_UInt32_ifBig(s, "devmajor", item.DeviceMajor);
+ if (item.DeviceMinor_Defined)
+ AddPax_UInt32_ifBig(s, "devminor", item.DeviceMinor);
+
+ AddPax_UInt32_ifBig(s, "uid", item.UID);
+ AddPax_UInt32_ifBig(s, "gid", item.GID);
+
+ const UInt64 kPax_MTime_Limit = ((UInt64)1 << 33);
+ const bool zero_MTime = (
+ item.MTime < 0 ||
+ item.MTime >= (Int64)kPax_MTime_Limit);
+
+ const CPaxTime &mtime = item.PaxTimes.MTime;
+ if (mtime.IsDefined())
+ {
+ bool needPax = false;
+ if (zero_MTime)
+ needPax = true;
+ else if (TimeOptions.NumDigitsMax > 0)
+ if (mtime.Ns != 0 ||
+ (mtime.NumDigits != 0 &&
+ TimeOptions.RemoveZeroMode == k_PaxTimeMode_DontRemoveZero))
+ needPax = true;
+ if (needPax)
+ AddPaxTime(s, "mtime", mtime, TimeOptions);
+ }
+
+ if (item.PaxTimes.ATime.IsDefined())
+ AddPaxTime(s, "atime", item.PaxTimes.ATime, TimeOptions);
+ if (item.PaxTimes.CTime.IsDefined())
+ AddPaxTime(s, "ctime", item.PaxTimes.CTime, TimeOptions);
+
+ if (item.User.Len() > kUserNameSize)
+ AddPaxLine(s, "uname", item.User);
+ if (item.Group.Len() > kGroupNameSize)
+ AddPaxLine(s, "gname", item.Group);
+
+ /*
+ // for debug
+ AString a ("11"); for (int y = 0; y < (1 << 24); y++) AddPaxLine(s, "temp", a);
+ */
+
+ const unsigned paxSize = s.Len();
+ if (paxSize != 0)
+ {
+ CItem mi = item;
+ mi.LinkName.Empty();
+ // SparseBlocks will be ignored by Is_Sparse()
+ // mi.SparseBlocks.Clear();
+ // we use "PaxHeader/*" for compatibility with previous 7-Zip decoder
+
+ // GNU TAR writes empty for these fields;
+ mi.User.Empty();
+ mi.Group.Empty();
+ mi.UID = 0;
+ mi.GID = 0;
+
+ mi.DeviceMajor_Defined = false;
+ mi.DeviceMinor_Defined = false;
+
+ mi.Name = "PaxHeader/@PaxHeader";
+ mi.Mode = 0644; // octal
+ if (zero_MTime)
+ mi.MTime = 0;
+ mi.LinkFlag = NLinkFlag::kPax;
+ // mi.LinkFlag = 'Z'; // for debug
+ mi.PackSize = paxSize;
+ // for (unsigned y = 0; y < 1; y++) { // for debug
+ RINOK(WriteHeaderReal(mi, true)) // isPax
+ RINOK(Write_Data_And_Residual(s, paxSize))
+ // } // for debug
+ /*
+ we can send (zero_MTime) for compatibility with gnu tar output.
+ we can send (zero_MTime = false) for better compatibility with old 7-Zip
+ */
+ // return WriteHeaderReal(item);
+ /*
+ false, // isPax
+ false, // zero_PackSize
+ false); // zero_MTime
+ */
+ }
+ }
+ else // !PosixMode
+ if (!DOES_NAME_FIT_IN_FIELD(item.Name) ||
+ !DOES_NAME_FIT_IN_FIELD(item.LinkName))
+ {
+ // here we can get all fields from main (item) or create new empty item
+ /*
+ CItem mi;
+ mi.SetDefaultWriteFields();
+ */
+ CItem mi = item;
+ mi.LinkName.Empty();
+ // SparseBlocks will be ignored by Is_Sparse()
+ // mi.SparseBlocks.Clear();
+ mi.Name = kLongLink;
+ // mi.Name = "././@BAD_LONG_LINK_TEST"; // for debug
+ // 21.07 : we set Mode and MTime props as in GNU TAR:
+ mi.Mode = 0644; // octal
+ mi.MTime = 0;
+
+ mi.User.Empty();
+ mi.Group.Empty();
+ /*
+ gnu tar sets "root" for such items:
+ uid_to_uname (0, &uname);
+ gid_to_gname (0, &gname);
+ */
+ /*
+ mi.User = "root";
+ mi.Group = "root";
+ */
+ mi.UID = 0;
+ mi.GID = 0;
+ mi.DeviceMajor_Defined = false;
+ mi.DeviceMinor_Defined = false;
+
+
+ for (unsigned i = 0; i < 2; i++)
+ {
+ const AString *name;
+ // We suppose that GNU TAR also writes item for long link before item for LongName?
+ if (i == 0)
+ {
+ mi.LinkFlag = NLinkFlag::kGnu_LongLink;
+ name = &item.LinkName;
+ }
+ else
+ {
+ mi.LinkFlag = NLinkFlag::kGnu_LongName;
+ name = &item.Name;
+ }
+ if (DOES_NAME_FIT_IN_FIELD(*name))
+ continue;
+ // GNU TAR writes null character after NAME to file. We do same here:
+ const unsigned nameStreamSize = name->Len() + 1;
+ mi.PackSize = nameStreamSize;
+ // for (unsigned y = 0; y < 3; y++) { // for debug
+ RINOK(WriteHeaderReal(mi))
+ RINOK(Write_Data_And_Residual(name->Ptr(), nameStreamSize))
+ // }
+
+ // for debug
+ /*
+ const unsigned kSize = (1 << 29) + 16;
+ CByteBuffer buf;
+ buf.Alloc(kSize);
+ memset(buf, 0, kSize);
+ memcpy(buf, name->Ptr(), name->Len());
+ const unsigned nameStreamSize = kSize;
+ mi.PackSize = nameStreamSize;
+ // for (unsigned y = 0; y < 3; y++) { // for debug
+ RINOK(WriteHeaderReal(mi));
+ RINOK(WriteBytes(buf, nameStreamSize));
+ RINOK(FillDataResidual(nameStreamSize));
+ */
+ }
+ }
+
+ // bool fals = false; if (fals) // for debug: for bit-to-bit output compatibility with GNU TAR
+
+ if (!DOES_NAME_FIT_IN_FIELD(item.Name))
+ {
+ const unsigned nameLen = item.Name.Len() - namePos;
+ if (!needPathCut)
+ Prefix.SetFrom(item.Name, namePos - 1);
+ else
+ {
+ Glob_Name = K_PREFIX_PATH_CUT "/_pc_";
+
+ if (namePos == 0)
+ Glob_Name += "root";
+ else
+ {
+ Glob_Name += "crc32/";
+ char temp[12];
+ ConvertUInt32ToHex8Digits(CrcCalc(item.Name, namePos - 1), temp);
+ Glob_Name += temp;
+ }
+
+ if (!allowPrefix || Glob_Name.Len() + 1 + nameLen <= kNameSize_Max)
+ Glob_Name.Add_Slash();
+ else
+ {
+ Prefix = Glob_Name;
+ Glob_Name.Empty();
+ }
+ }
+ Glob_Name.AddFrom(item.Name.Ptr(namePos), nameLen);
+ }
+
+ return WriteHeaderReal(item);
+}
+
+
+HRESULT COutArchive::Write_Data(const void *data, unsigned size)
+{
+ Pos += size;
+ return WriteStream(Stream, data, size);
+}
+
+HRESULT COutArchive::Write_AfterDataResidual(UInt64 dataSize)
+{
+ const unsigned v = ((unsigned)dataSize & (kRecordSize - 1));
+ if (v == 0)
+ return S_OK;
+ const unsigned rem = kRecordSize - v;
+ Byte buf[kRecordSize];
+ memset(buf, 0, rem);
+ return Write_Data(buf, rem);
+}
+
+
+HRESULT COutArchive::Write_Data_And_Residual(const void *data, unsigned size)
+{
+ RINOK(Write_Data(data, size))
+ return Write_AfterDataResidual(size);
+}
+
+
+HRESULT COutArchive::WriteFinishHeader()
+{
+ Byte record[kRecordSize];
+ memset(record, 0, kRecordSize);
+
+ const unsigned kNumFinishRecords = 2;
+
+ /* GNU TAR by default uses --blocking-factor=20 (512 * 20 = 10 KiB)
+ we also can use cluster alignment:
+ const unsigned numBlocks = (unsigned)(Pos / kRecordSize) + kNumFinishRecords;
+ const unsigned kNumClusterBlocks = (1 << 3); // 8 blocks = 4 KiB
+ const unsigned numFinishRecords = kNumFinishRecords + ((kNumClusterBlocks - numBlocks) & (kNumClusterBlocks - 1));
+ */
+
+ for (unsigned i = 0; i < kNumFinishRecords; i++)
+ {
+ RINOK(Write_Data(record, kRecordSize))
+ }
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Tar/TarOut.h b/CPP/7zip/Archive/Tar/TarOut.h
new file mode 100644
index 0000000..7b99c26
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarOut.h
@@ -0,0 +1,53 @@
+// Archive/TarOut.h
+
+#ifndef ZIP7_INC_ARCHIVE_TAR_OUT_H
+#define ZIP7_INC_ARCHIVE_TAR_OUT_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IStream.h"
+
+#include "TarItem.h"
+
+namespace NArchive {
+namespace NTar {
+
+class COutArchive
+{
+ CMyComPtr<ISequentialOutStream> Stream;
+
+ AString Glob_Name;
+ AString Prefix;
+
+ HRESULT WriteHeaderReal(const CItem &item, bool isPax = false
+ // , bool zero_PackSize = false
+ // , bool zero_MTime = false
+ );
+
+ HRESULT Write_Data(const void *data, unsigned size);
+ HRESULT Write_Data_And_Residual(const void *data, unsigned size);
+
+public:
+ UInt64 Pos;
+ bool IsPosixMode;
+ // bool IsPrefixAllowed; // it's used only if (IsPosixMode == true)
+ CTimeOptions TimeOptions;
+
+ void Create(ISequentialOutStream *outStream)
+ {
+ Stream = outStream;
+ }
+ HRESULT WriteHeader(const CItem &item);
+ HRESULT Write_AfterDataResidual(UInt64 dataSize);
+ HRESULT WriteFinishHeader();
+
+ COutArchive():
+ Pos(0),
+ IsPosixMode(false)
+ // , IsPrefixAllowed(true)
+ {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Tar/TarRegister.cpp b/CPP/7zip/Archive/Tar/TarRegister.cpp
new file mode 100644
index 0000000..709c191
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarRegister.cpp
@@ -0,0 +1,31 @@
+// TarRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "TarHandler.h"
+
+namespace NArchive {
+namespace NTar {
+
+static const Byte k_Signature[] = { 'u', 's', 't', 'a', 'r' };
+
+REGISTER_ARC_IO(
+ "tar", "tar ova", NULL, 0xEE,
+ k_Signature,
+ NFileHeader::kUstarMagic_Offset,
+ NArcInfoFlags::kStartOpen
+ | NArcInfoFlags::kSymLinks
+ | NArcInfoFlags::kHardLinks
+ | NArcInfoFlags::kMTime
+ | NArcInfoFlags::kMTime_Default
+ // | NArcInfoTimeFlags::kCTime
+ // | NArcInfoTimeFlags::kATime
+ , TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kWindows)
+ | TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kUnix)
+ | TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::k1ns)
+ | TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT (NFileTimeType::kUnix)
+ , IsArc_Tar)
+
+}}
diff --git a/CPP/7zip/Archive/Tar/TarUpdate.cpp b/CPP/7zip/Archive/Tar/TarUpdate.cpp
new file mode 100644
index 0000000..0b348e9
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarUpdate.cpp
@@ -0,0 +1,555 @@
+// TarUpdate.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "TarOut.h"
+#include "TarUpdate.h"
+
+namespace NArchive {
+namespace NTar {
+
+static void FILETIME_To_PaxTime(const FILETIME &ft, CPaxTime &pt)
+{
+ UInt32 ns;
+ pt.Sec = NWindows::NTime::FileTime_To_UnixTime64_and_Quantums(ft, ns);
+ pt.Ns = ns * 100;
+ pt.NumDigits = 7;
+}
+
+
+HRESULT Prop_To_PaxTime(const NWindows::NCOM::CPropVariant &prop, CPaxTime &pt)
+{
+ pt.Clear();
+ if (prop.vt == VT_EMPTY)
+ {
+ // pt.Sec = 0;
+ return S_OK;
+ }
+ if (prop.vt != VT_FILETIME)
+ return E_INVALIDARG;
+ {
+ UInt32 ns;
+ pt.Sec = NWindows::NTime::FileTime_To_UnixTime64_and_Quantums(prop.filetime, ns);
+ ns *= 100;
+ pt.NumDigits = 7;
+ const unsigned prec = prop.wReserved1;
+ if (prec >= k_PropVar_TimePrec_Base)
+ {
+ pt.NumDigits = (int)(prec - k_PropVar_TimePrec_Base);
+ if (prop.wReserved2 < 100)
+ ns += prop.wReserved2;
+ }
+ pt.Ns = ns;
+ return S_OK;
+ }
+}
+
+
+static HRESULT GetTime(IStreamGetProp *getProp, UInt32 pid, CPaxTime &pt)
+{
+ pt.Clear();
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(pid, &prop))
+ return Prop_To_PaxTime(prop, pt);
+}
+
+
+static HRESULT GetUser(IStreamGetProp *getProp,
+ UInt32 pidName, UInt32 pidId, AString &name, UInt32 &id,
+ UINT codePage, unsigned utfFlags)
+{
+ // printf("\nGetUser\n");
+ // we keep old values, if both GetProperty() return VT_EMPTY
+ // we clear old values, if any of GetProperty() returns non-VT_EMPTY;
+ bool isSet = false;
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(pidId, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ isSet = true;
+ id = prop.ulVal;
+ name.Empty();
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(pidName, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ const UString s = prop.bstrVal;
+ Get_AString_From_UString(s, name, codePage, utfFlags);
+ // printf("\ngetProp->GetProperty(pidName, &prop) : %s" , name.Ptr());
+ if (!isSet)
+ id = 0;
+ }
+ else if (prop.vt == VT_UI4)
+ {
+ id = prop.ulVal;
+ name.Empty();
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+
+/*
+static HRESULT GetDevice(IStreamGetProp *getProp,
+ UInt32 &majo, UInt32 &mino, bool &majo_defined, bool &mino_defined)
+{
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(kpidDevice, &prop));
+ if (prop.vt == VT_EMPTY)
+ return S_OK;
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ {
+ printf("\nTarUpdate.cpp :: GetDevice()\n");
+ const UInt64 v = prop.uhVal.QuadPart;
+ majo = MY_dev_major(v);
+ mino = MY_dev_minor(v);
+ majo_defined = true;
+ mino_defined = true;
+ }
+ return S_OK;
+}
+*/
+
+static HRESULT GetDevice(IStreamGetProp *getProp,
+ UInt32 pid, UInt32 &id, bool &defined)
+{
+ defined = false;
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(pid, &prop))
+ if (prop.vt == VT_EMPTY)
+ return S_OK;
+ if (prop.vt == VT_UI4)
+ {
+ id = prop.ulVal;
+ defined = true;
+ return S_OK;
+ }
+ return E_INVALIDARG;
+}
+
+
+HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
+ const CObjectVector<NArchive::NTar::CItemEx> &inputItems,
+ const CObjectVector<CUpdateItem> &updateItems,
+ const CUpdateOptions &options,
+ IArchiveUpdateCallback *updateCallback)
+{
+ COutArchive outArchive;
+ outArchive.Create(outStream);
+ outArchive.Pos = 0;
+ outArchive.IsPosixMode = options.PosixMode;
+ outArchive.TimeOptions = options.TimeOptions;
+
+ Z7_DECL_CMyComPtr_QI_FROM(IOutStream, outSeekStream, outStream)
+ Z7_DECL_CMyComPtr_QI_FROM(IStreamSetRestriction, setRestriction, outStream)
+ Z7_DECL_CMyComPtr_QI_FROM(IArchiveUpdateCallbackFile, opCallback, outStream)
+
+ if (outSeekStream)
+ {
+ /*
+ // for debug
+ Byte buf[1 << 14];
+ memset (buf, 0, sizeof(buf));
+ RINOK(outStream->Write(buf, sizeof(buf), NULL));
+ */
+ // we need real outArchive.Pos, if outSeekStream->SetSize() will be used.
+ RINOK(outSeekStream->Seek(0, STREAM_SEEK_CUR, &outArchive.Pos))
+ }
+ if (setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+
+ UInt64 complexity = 0;
+
+ unsigned i;
+ for (i = 0; i < updateItems.Size(); i++)
+ {
+ const CUpdateItem &ui = updateItems[i];
+ if (ui.NewData)
+ complexity += ui.Size;
+ else
+ complexity += inputItems[(unsigned)ui.IndexInArc].Get_FullSize_Aligned();
+ }
+
+ RINOK(updateCallback->SetTotal(complexity))
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStreamLimited(streamSpec);
+ streamSpec->SetStream(inStream);
+
+ complexity = 0;
+
+ // const int kNumReduceDigits = -1; // for debug
+
+ for (i = 0;; i++)
+ {
+ lps->InSize = lps->OutSize = complexity;
+ RINOK(lps->SetCur())
+
+ if (i == updateItems.Size())
+ {
+ if (outSeekStream && setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+ return outArchive.WriteFinishHeader();
+ }
+
+ const CUpdateItem &ui = updateItems[i];
+ CItem item;
+
+ if (ui.NewProps)
+ {
+ item.SetMagic_Posix(options.PosixMode);
+ item.Name = ui.Name;
+ item.User = ui.User;
+ item.Group = ui.Group;
+ item.UID = ui.UID;
+ item.GID = ui.GID;
+ item.DeviceMajor = ui.DeviceMajor;
+ item.DeviceMinor = ui.DeviceMinor;
+ item.DeviceMajor_Defined = ui.DeviceMajor_Defined;
+ item.DeviceMinor_Defined = ui.DeviceMinor_Defined;
+
+ if (ui.IsDir)
+ {
+ item.LinkFlag = NFileHeader::NLinkFlag::kDirectory;
+ item.PackSize = 0;
+ }
+ else
+ {
+ item.PackSize = ui.Size;
+ item.Set_LinkFlag_for_File(ui.Mode);
+ }
+
+ // 22.00
+ item.Mode = ui.Mode & ~(UInt32)MY_LIN_S_IFMT;
+ item.PaxTimes = ui.PaxTimes;
+ // item.PaxTimes.ReducePrecison(kNumReduceDigits); // for debug
+ item.MTime = ui.PaxTimes.MTime.GetSec();
+ }
+ else
+ item = inputItems[(unsigned)ui.IndexInArc];
+
+ AString symLink;
+ if (ui.NewData || ui.NewProps)
+ {
+ RINOK(GetPropString(updateCallback, ui.IndexInClient, kpidSymLink, symLink,
+ options.CodePage, options.UtfFlags, true))
+ if (!symLink.IsEmpty())
+ {
+ item.LinkFlag = NFileHeader::NLinkFlag::kSymLink;
+ item.LinkName = symLink;
+ }
+ }
+
+ if (ui.NewData)
+ {
+ item.SparseBlocks.Clear();
+ item.PackSize = ui.Size;
+ item.Size = ui.Size;
+ if (ui.Size == (UInt64)(Int64)-1)
+ return E_INVALIDARG;
+
+ CMyComPtr<ISequentialInStream> fileInStream;
+
+ bool needWrite = true;
+
+ if (!symLink.IsEmpty())
+ {
+ item.PackSize = 0;
+ item.Size = 0;
+ }
+ else
+ {
+ const HRESULT res = updateCallback->GetStream(ui.IndexInClient, &fileInStream);
+
+ if (res == S_FALSE)
+ needWrite = false;
+ else
+ {
+ RINOK(res)
+
+ if (!fileInStream)
+ {
+ item.PackSize = 0;
+ item.Size = 0;
+ }
+ else
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(IStreamGetProp, getProp, fileInStream)
+ if (getProp)
+ {
+ if (options.Write_MTime.Val) RINOK(GetTime(getProp, kpidMTime, item.PaxTimes.MTime))
+ if (options.Write_ATime.Val) RINOK(GetTime(getProp, kpidATime, item.PaxTimes.ATime))
+ if (options.Write_CTime.Val) RINOK(GetTime(getProp, kpidCTime, item.PaxTimes.CTime))
+
+ if (options.PosixMode)
+ {
+ /*
+ RINOK(GetDevice(getProp, item.DeviceMajor, item.DeviceMinor,
+ item.DeviceMajor_Defined, item.DeviceMinor_Defined));
+ */
+ bool defined = false;
+ UInt32 val = 0;
+ RINOK(GetDevice(getProp, kpidDeviceMajor, val, defined))
+ if (defined)
+ {
+ item.DeviceMajor = val;
+ item.DeviceMajor_Defined = true;
+ item.DeviceMinor = 0;
+ item.DeviceMinor_Defined = false;
+ RINOK(GetDevice(getProp, kpidDeviceMinor, item.DeviceMinor, item.DeviceMinor_Defined))
+ }
+ }
+
+ RINOK(GetUser(getProp, kpidUser, kpidUserId, item.User, item.UID, options.CodePage, options.UtfFlags))
+ RINOK(GetUser(getProp, kpidGroup, kpidGroupId, item.Group, item.GID, options.CodePage, options.UtfFlags))
+
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(kpidPosixAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ item.Mode =
+ MY_LIN_S_IRWXO
+ | MY_LIN_S_IRWXG
+ | MY_LIN_S_IRWXU
+ | (ui.IsDir ? MY_LIN_S_IFDIR : MY_LIN_S_IFREG);
+ else if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ else
+ item.Mode = prop.ulVal;
+ // 21.07 : we clear high file type bits as GNU TAR.
+ item.Set_LinkFlag_for_File(item.Mode);
+ item.Mode &= ~(UInt32)MY_LIN_S_IFMT;
+ }
+
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(getProp->GetProperty(kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ const UInt64 size = prop.uhVal.QuadPart;
+ item.PackSize = size;
+ item.Size = size;
+ }
+ /*
+ printf("\nNum digits = %d %d\n",
+ (int)item.PaxTimes.MTime.NumDigits,
+ (int)item.PaxTimes.MTime.Ns);
+ */
+ }
+ else
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(IStreamGetProps, getProps, fileInStream)
+ if (getProps)
+ {
+ FILETIME mTime, aTime, cTime;
+ UInt64 size2;
+ if (getProps->GetProps(&size2,
+ options.Write_CTime.Val ? &cTime : NULL,
+ options.Write_ATime.Val ? &aTime : NULL,
+ options.Write_MTime.Val ? &mTime : NULL,
+ NULL) == S_OK)
+ {
+ item.PackSize = size2;
+ item.Size = size2;
+ if (options.Write_MTime.Val) FILETIME_To_PaxTime(mTime, item.PaxTimes.MTime);
+ if (options.Write_ATime.Val) FILETIME_To_PaxTime(aTime, item.PaxTimes.ATime);
+ if (options.Write_CTime.Val) FILETIME_To_PaxTime(cTime, item.PaxTimes.CTime);
+ }
+ }
+ }
+ }
+
+ {
+ // we must request kpidHardLink after updateCallback->GetStream()
+ AString hardLink;
+ RINOK(GetPropString(updateCallback, ui.IndexInClient, kpidHardLink, hardLink,
+ options.CodePage, options.UtfFlags, true))
+ if (!hardLink.IsEmpty())
+ {
+ item.LinkFlag = NFileHeader::NLinkFlag::kHardLink;
+ item.LinkName = hardLink;
+ item.PackSize = 0;
+ item.Size = 0;
+ fileInStream.Release();
+ }
+ }
+ }
+ }
+
+ // item.PaxTimes.ReducePrecison(kNumReduceDigits); // for debug
+
+ if (ui.NewProps)
+ item.MTime = item.PaxTimes.MTime.GetSec();
+
+ if (needWrite)
+ {
+ const UInt64 headerPos = outArchive.Pos;
+ // item.PackSize = ((UInt64)1 << 33); // for debug
+
+ if (outSeekStream && setRestriction)
+ RINOK(setRestriction->SetRestriction(outArchive.Pos, (UInt64)(Int64)-1))
+
+ RINOK(outArchive.WriteHeader(item))
+ if (fileInStream)
+ {
+ for (unsigned numPasses = 0;; numPasses++)
+ {
+ /* we support 2 attempts to write header:
+ pass-0: main pass:
+ pass-1: additional pass, if size_of_file and size_of_header are changed */
+ if (numPasses >= 2)
+ {
+ // opRes = NArchive::NUpdate::NOperationResult::kError_FileChanged;
+ // break;
+ return E_FAIL;
+ }
+
+ const UInt64 dataPos = outArchive.Pos;
+ RINOK(copyCoder->Code(fileInStream, outStream, NULL, NULL, progress))
+ outArchive.Pos += copyCoderSpec->TotalSize;
+ RINOK(outArchive.Write_AfterDataResidual(copyCoderSpec->TotalSize))
+
+ // if (numPasses >= 10) // for debug
+ if (copyCoderSpec->TotalSize == item.PackSize)
+ break;
+
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kOutArcIndex, (UInt32)ui.IndexInClient,
+ NUpdateNotifyOp::kInFileChanged))
+ }
+
+ if (!outSeekStream)
+ return E_FAIL;
+ const UInt64 nextPos = outArchive.Pos;
+ RINOK(outSeekStream->Seek(-(Int64)(nextPos - headerPos), STREAM_SEEK_CUR, NULL))
+ outArchive.Pos = headerPos;
+ item.PackSize = copyCoderSpec->TotalSize;
+
+ RINOK(outArchive.WriteHeader(item))
+
+ // if (numPasses >= 10) // for debug
+ if (outArchive.Pos == dataPos)
+ {
+ const UInt64 alignedSize = nextPos - dataPos;
+ if (alignedSize != 0)
+ {
+ RINOK(outSeekStream->Seek((Int64)alignedSize, STREAM_SEEK_CUR, NULL))
+ outArchive.Pos += alignedSize;
+ }
+ break;
+ }
+
+ // size of header was changed.
+ // we remove data after header and try new attempt, if required
+ Z7_DECL_CMyComPtr_QI_FROM(IInStream, fileSeekStream, fileInStream)
+ if (!fileSeekStream)
+ return E_FAIL;
+ RINOK(InStream_SeekToBegin(fileSeekStream))
+ RINOK(outSeekStream->SetSize(outArchive.Pos))
+ if (item.PackSize == 0)
+ break;
+ }
+ }
+ }
+
+ complexity += item.PackSize;
+ fileInStream.Release();
+ RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ }
+ else
+ {
+ // (ui.NewData == false)
+
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kInArcIndex, (UInt32)ui.IndexInArc,
+ NUpdateNotifyOp::kReplicate))
+ }
+
+ const CItemEx &existItem = inputItems[(unsigned)ui.IndexInArc];
+ UInt64 size, pos;
+
+ if (ui.NewProps)
+ {
+ // memcpy(item.Magic, NFileHeader::NMagic::kEmpty, 8);
+
+ if (!symLink.IsEmpty())
+ {
+ item.PackSize = 0;
+ item.Size = 0;
+ }
+ else
+ {
+ if (ui.IsDir == existItem.IsDir())
+ item.LinkFlag = existItem.LinkFlag;
+
+ item.SparseBlocks = existItem.SparseBlocks;
+ item.Size = existItem.Size;
+ item.PackSize = existItem.PackSize;
+ }
+
+ item.DeviceMajor_Defined = existItem.DeviceMajor_Defined;
+ item.DeviceMinor_Defined = existItem.DeviceMinor_Defined;
+ item.DeviceMajor = existItem.DeviceMajor;
+ item.DeviceMinor = existItem.DeviceMinor;
+ item.UID = existItem.UID;
+ item.GID = existItem.GID;
+
+ RINOK(outArchive.WriteHeader(item))
+ size = existItem.Get_PackSize_Aligned();
+ pos = existItem.Get_DataPos();
+ }
+ else
+ {
+ size = existItem.Get_FullSize_Aligned();
+ pos = existItem.HeaderPos;
+ }
+
+ if (size != 0)
+ {
+ RINOK(InStream_SeekSet(inStream, pos))
+ streamSpec->Init(size);
+ if (outSeekStream && setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+ // 22.00 : we copy Residual data from old archive to new archive instead of zeroing
+ RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize != size)
+ return E_FAIL;
+ outArchive.Pos += size;
+ // RINOK(outArchive.Write_AfterDataResidual(existItem.PackSize));
+ complexity += size;
+ }
+ }
+ }
+}
+
+}}
diff --git a/CPP/7zip/Archive/Tar/TarUpdate.h b/CPP/7zip/Archive/Tar/TarUpdate.h
new file mode 100644
index 0000000..f6c2e77
--- /dev/null
+++ b/CPP/7zip/Archive/Tar/TarUpdate.h
@@ -0,0 +1,74 @@
+// TarUpdate.h
+
+#ifndef ZIP7_INC_TAR_UPDATE_H
+#define ZIP7_INC_TAR_UPDATE_H
+
+#include "../IArchive.h"
+
+#include "TarItem.h"
+
+namespace NArchive {
+namespace NTar {
+
+struct CUpdateItem
+{
+ int IndexInArc;
+ unsigned IndexInClient;
+ UInt64 Size;
+ // Int64 MTime;
+ UInt32 Mode;
+ bool NewData;
+ bool NewProps;
+ bool IsDir;
+ bool DeviceMajor_Defined;
+ bool DeviceMinor_Defined;
+ UInt32 UID;
+ UInt32 GID;
+ UInt32 DeviceMajor;
+ UInt32 DeviceMinor;
+ AString Name;
+ AString User;
+ AString Group;
+
+ CPaxTimes PaxTimes;
+
+ CUpdateItem():
+ Size(0),
+ IsDir(false),
+ DeviceMajor_Defined(false),
+ DeviceMinor_Defined(false),
+ UID(0),
+ GID(0)
+ {}
+};
+
+
+struct CUpdateOptions
+{
+ UINT CodePage;
+ unsigned UtfFlags;
+ bool PosixMode;
+ CBoolPair Write_MTime;
+ CBoolPair Write_ATime;
+ CBoolPair Write_CTime;
+ CTimeOptions TimeOptions;
+};
+
+
+HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
+ const CObjectVector<CItemEx> &inputItems,
+ const CObjectVector<CUpdateItem> &updateItems,
+ const CUpdateOptions &options,
+ IArchiveUpdateCallback *updateCallback);
+
+HRESULT GetPropString(IArchiveUpdateCallback *callback, UInt32 index, PROPID propId, AString &res,
+ UINT codePage, unsigned utfFlags, bool convertSlash);
+
+HRESULT Prop_To_PaxTime(const NWindows::NCOM::CPropVariant &prop, CPaxTime &pt);
+
+void Get_AString_From_UString(const UString &s, AString &res,
+ UINT codePage, unsigned utfFlags);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Udf/StdAfx.h b/CPP/7zip/Archive/Udf/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Udf/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/Udf/UdfHandler.cpp b/CPP/7zip/Archive/Udf/UdfHandler.cpp
new file mode 100644
index 0000000..ae6113f
--- /dev/null
+++ b/CPP/7zip/Archive/Udf/UdfHandler.cpp
@@ -0,0 +1,428 @@
+// UdfHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/RegisterArc.h"
+#include "../../Common/StreamObjects.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "UdfHandler.h"
+
+namespace NArchive {
+namespace NUdf {
+
+static void UdfTimeToFileTime(const CTime &t, NWindows::NCOM::CPropVariant &prop)
+{
+ UInt64 numSecs;
+ const Byte *d = t.Data;
+ if (!NWindows::NTime::GetSecondsSince1601(t.GetYear(), d[4], d[5], d[6], d[7], d[8], numSecs))
+ return;
+ if (t.IsLocal())
+ numSecs = (UInt64)((Int64)numSecs - (Int64)((Int32)t.GetMinutesOffset() * 60));
+ const UInt32 m0 = d[9];
+ const UInt32 m1 = d[10];
+ const UInt32 m2 = d[11];
+ unsigned numDigits = 0;
+ UInt64 v = numSecs * 10000000;
+ if (m0 < 100 && m1 < 100 && m2 < 100)
+ {
+ v += m0 * 100000 + m1 * 1000 + m2 * 10;
+ numDigits = 6;
+ }
+ prop.SetAsTimeFrom_Ft64_Prec(v, k_PropVar_TimePrec_Base + numDigits);
+}
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidATime,
+ kpidCTime,
+ kpidChangeTime,
+ // kpidUserId,
+ // kpidGroupId,
+ // kpidPosixAttrib,
+ kpidLinks
+};
+
+static const Byte kArcProps[] =
+{
+ kpidUnpackVer,
+ kpidClusterSize,
+ kpidSectorSize,
+ kpidCTime,
+ kpidMTime,
+ kpidComment
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: prop = _archive.PhySize; break;
+
+ case kpidUnpackVer:
+ {
+ if (_archive.LogVols.Size() == 1)
+ {
+ UString s;
+ const CLogVol &vol = _archive.LogVols[0];
+ vol.DomainId.AddUdfVersionTo(s);
+ if (!s.IsEmpty())
+ prop = s;
+ }
+ break;
+ }
+ case kpidComment:
+ {
+ UString comment = _archive.GetComment();
+ if (!comment.IsEmpty())
+ prop = comment;
+ break;
+ }
+
+ case kpidClusterSize:
+ if (_archive.LogVols.Size() > 0)
+ {
+ UInt32 blockSize = _archive.LogVols[0].BlockSize;
+ unsigned i;
+ for (i = 1; i < _archive.LogVols.Size(); i++)
+ if (_archive.LogVols[i].BlockSize != blockSize)
+ break;
+ if (i == _archive.LogVols.Size())
+ prop = blockSize;
+ }
+ break;
+
+ case kpidSectorSize: prop = ((UInt32)1 << _archive.SecLogSize); break;
+
+ case kpidCTime:
+ if (_archive.LogVols.Size() == 1)
+ {
+ const CLogVol &vol = _archive.LogVols[0];
+ if (vol.FileSets.Size() >= 1)
+ UdfTimeToFileTime(vol.FileSets[0].RecordingTime, prop);
+ }
+ break;
+ case kpidMTime:
+ if (_archive.PrimeVols.Size() == 1)
+ {
+ const CPrimeVol &pv = _archive.PrimeVols[0];
+ UdfTimeToFileTime(pv.RecordingTime, prop);
+ }
+ break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_archive.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_archive.Unsupported) v |= kpv_ErrorFlags_UnsupportedFeature;
+ if (_archive.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_archive.NoEndAnchor) v |= kpv_ErrorFlags_HeadersError;
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+class CProgressImp Z7_final: public CProgressVirt
+{
+ CMyComPtr<IArchiveOpenCallback> _callback;
+ UInt64 _numFiles;
+ UInt64 _numBytes;
+public:
+ HRESULT SetTotal(UInt64 numBytes) Z7_override;
+ HRESULT SetCompleted(UInt64 numFiles, UInt64 numBytes) Z7_override;
+ HRESULT SetCompleted() Z7_override;
+ CProgressImp(IArchiveOpenCallback *callback): _callback(callback), _numFiles(0), _numBytes(0) {}
+};
+
+HRESULT CProgressImp::SetTotal(UInt64 numBytes)
+{
+ if (_callback)
+ return _callback->SetTotal(NULL, &numBytes);
+ return S_OK;
+}
+
+HRESULT CProgressImp::SetCompleted(UInt64 numFiles, UInt64 numBytes)
+{
+ _numFiles = numFiles;
+ _numBytes = numBytes;
+ return SetCompleted();
+}
+
+HRESULT CProgressImp::SetCompleted()
+{
+ if (_callback)
+ return _callback->SetCompleted(&_numFiles, &_numBytes);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ CProgressImp progressImp(callback);
+ RINOK(_archive.Open(stream, &progressImp))
+ bool showVolName = (_archive.LogVols.Size() > 1);
+ FOR_VECTOR (volIndex, _archive.LogVols)
+ {
+ const CLogVol &vol = _archive.LogVols[volIndex];
+ bool showFileSetName = (vol.FileSets.Size() > 1);
+ // showFileSetName = true; // for debug
+ FOR_VECTOR (fsIndex, vol.FileSets)
+ {
+ const CFileSet &fs = vol.FileSets[fsIndex];
+ for (unsigned i = ((showVolName || showFileSetName) ? 0 : 1); i < fs.Refs.Size(); i++)
+ {
+ CRef2 ref2;
+ ref2.Vol = volIndex;
+ ref2.Fs = fsIndex;
+ ref2.Ref = i;
+ _refs2.Add(ref2);
+ }
+ }
+ }
+ _inStream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _inStream.Release();
+ _archive.Clear();
+ _refs2.Clear();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _refs2.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ {
+ const CRef2 &ref2 = _refs2[index];
+ const CLogVol &vol = _archive.LogVols[ref2.Vol];
+ const CRef &ref = vol.FileSets[ref2.Fs].Refs[ref2.Ref];
+ const CFile &file = _archive.Files[ref.FileIndex];
+ const CItem &item = _archive.Items[file.ItemIndex];
+ switch (propID)
+ {
+ case kpidPath: prop = _archive.GetItemPath(ref2.Vol, ref2.Fs, ref2.Ref,
+ _archive.LogVols.Size() > 1, vol.FileSets.Size() > 1); break;
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize: if (!item.IsDir()) prop = (UInt64)item.Size; break;
+ case kpidPackSize: if (!item.IsDir()) prop = (UInt64)item.NumLogBlockRecorded * vol.BlockSize; break;
+ case kpidMTime: UdfTimeToFileTime(item.MTime, prop); break;
+ case kpidATime: UdfTimeToFileTime(item.ATime, prop); break;
+ case kpidCTime:
+ if (item.IsExtended)
+ UdfTimeToFileTime(item.CreateTime, prop);
+ break;
+ case kpidChangeTime: UdfTimeToFileTime(item.AttribTime, prop); break;
+ // case kpidUserId: prop = item.Uid; break;
+ // case kpidGroupId: prop = item.Gid; break;
+ // case kpidPosixAttrib: prop = (UInt32)item.Permissions; break;
+ case kpidLinks: prop = (UInt32)item.FileLinkCount; break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ *stream = NULL;
+
+ const CRef2 &ref2 = _refs2[index];
+ const CLogVol &vol = _archive.LogVols[ref2.Vol];
+ const CRef &ref = vol.FileSets[ref2.Fs].Refs[ref2.Ref];
+ const CFile &file = _archive.Files[ref.FileIndex];
+ const CItem &item = _archive.Items[file.ItemIndex];
+ UInt64 size = item.Size;
+
+ if (!item.IsRecAndAlloc() || !item.CheckChunkSizes() || ! _archive.CheckItemExtents(ref2.Vol, item))
+ return E_NOTIMPL;
+
+ if (item.IsInline)
+ {
+ Create_BufInStream_WithNewBuffer(item.InlineData, stream);
+ return S_OK;
+ }
+
+ CExtentsStream *extentStreamSpec = new CExtentsStream();
+ CMyComPtr<ISequentialInStream> extentStream = extentStreamSpec;
+
+ extentStreamSpec->Stream = _inStream;
+
+ UInt64 virtOffset = 0;
+ FOR_VECTOR (extentIndex, item.Extents)
+ {
+ const CMyExtent &extent = item.Extents[extentIndex];
+ UInt32 len = extent.GetLen();
+ if (len == 0)
+ continue;
+ if (size < len)
+ return S_FALSE;
+
+ const unsigned partitionIndex = vol.PartitionMaps[extent.PartitionRef].PartitionIndex;
+ UInt32 logBlockNumber = extent.Pos;
+ const CPartition &partition = _archive.Partitions[partitionIndex];
+ UInt64 offset = ((UInt64)partition.Pos << _archive.SecLogSize) +
+ (UInt64)logBlockNumber * vol.BlockSize;
+
+ CSeekExtent se;
+ se.Phy = offset;
+ se.Virt = virtOffset;
+ virtOffset += len;
+ extentStreamSpec->Extents.Add(se);
+
+ size -= len;
+ }
+ if (size != 0)
+ return S_FALSE;
+ CSeekExtent se;
+ se.Phy = 0;
+ se.Virt = virtOffset;
+ extentStreamSpec->Extents.Add(se);
+ extentStreamSpec->Init();
+ *stream = extentStream.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _refs2.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+
+ for (i = 0; i < numItems; i++)
+ {
+ UInt32 index = (allFilesMode ? i : indices[i]);
+ const CRef2 &ref2 = _refs2[index];
+ const CRef &ref = _archive.LogVols[ref2.Vol].FileSets[ref2.Fs].Refs[ref2.Ref];
+ const CFile &file = _archive.Files[ref.FileIndex];
+ const CItem &item = _archive.Items[file.ItemIndex];
+ if (!item.IsDir())
+ totalSize += item.Size;
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ const CRef2 &ref2 = _refs2[index];
+ const CRef &ref = _archive.LogVols[ref2.Vol].FileSets[ref2.Fs].Refs[ref2.Ref];
+ const CFile &file = _archive.Files[ref.FileIndex];
+ const CItem &item = _archive.Items[file.ItemIndex];
+
+ if (item.IsDir())
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ currentTotalSize += item.Size;
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+ outStreamSpec->SetStream(realOutStream);
+ realOutStream.Release();
+ outStreamSpec->Init(item.Size);
+ Int32 opRes;
+ CMyComPtr<ISequentialInStream> udfInStream;
+ HRESULT res = GetStream(index, &udfInStream);
+ if (res == E_NOTIMPL)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (res != S_OK)
+ opRes = NExtract::NOperationResult::kDataError;
+ else
+ {
+ RINOK(copyCoder->Code(udfInStream, outStream, NULL, NULL, progress))
+ opRes = outStreamSpec->IsFinishedOK() ?
+ NExtract::NOperationResult::kOK:
+ NExtract::NOperationResult::kDataError;
+ }
+ outStreamSpec->ReleaseStream();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+static const UInt32 kIsoStartPos = 0x8000;
+
+// 5, { 0, 'N', 'S', 'R', '0' },
+
+static const Byte k_Signature[] =
+{
+ 8, 0, 'B', 'E', 'A', '0', '1', 1, 0,
+ 6, 1, 'C', 'D', '0', '0', '1'
+};
+
+REGISTER_ARC_I(
+ "Udf", "udf iso img", NULL, 0xE0,
+ k_Signature,
+ kIsoStartPos,
+ NArcInfoFlags::kMultiSignature |
+ NArcInfoFlags::kStartOpen,
+ IsArc_Udf)
+
+}}
diff --git a/CPP/7zip/Archive/Udf/UdfHandler.h b/CPP/7zip/Archive/Udf/UdfHandler.h
new file mode 100644
index 0000000..5426d06
--- /dev/null
+++ b/CPP/7zip/Archive/Udf/UdfHandler.h
@@ -0,0 +1,32 @@
+// UdfHandler.h
+
+#ifndef ZIP7_INC_UDF_HANDLER_H
+#define ZIP7_INC_UDF_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../IArchive.h"
+
+#include "UdfIn.h"
+
+namespace NArchive {
+namespace NUdf {
+
+struct CRef2
+{
+ unsigned Vol;
+ unsigned Fs;
+ unsigned Ref;
+};
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CRecordVector<CRef2> _refs2;
+ CMyComPtr<IInStream> _inStream;
+ CInArchive _archive;
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Udf/UdfIn.cpp b/CPP/7zip/Archive/Udf/UdfIn.cpp
new file mode 100644
index 0000000..13d84e0
--- /dev/null
+++ b/CPP/7zip/Archive/Udf/UdfIn.cpp
@@ -0,0 +1,1741 @@
+// Archive/UdfIn.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Windows/PropVariantUtils.h"
+
+#include "../../Common/RegisterArc.h"
+#include "../../Common/StreamUtils.h"
+
+#include "UdfIn.h"
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G16(_offs_, dest) dest = Get16(p + (_offs_))
+#define G32(_offs_, dest) dest = Get32(p + (_offs_))
+#define G64(_offs_, dest) dest = Get64(p + (_offs_))
+
+namespace NArchive {
+namespace NUdf {
+
+static const unsigned kNumPartitionsMax = 64;
+static const unsigned kNumLogVolumesMax = 64;
+static const unsigned kNumRecursionLevelsMax = 1 << 10;
+static const unsigned kNumItemsMax = 1 << 27;
+static const unsigned kNumFilesMax = 1 << 28;
+static const unsigned kNumRefsMax = 1 << 28;
+static const UInt32 kNumExtentsMax = (UInt32)1 << 30;
+static const UInt64 kFileNameLengthTotalMax = (UInt64)1 << 33;
+static const UInt64 kInlineExtentsSizeMax = (UInt64)1 << 33;
+
+#define CRC16_INIT_VAL 0
+#define CRC16_UPDATE_BYTE(crc, b) ((UInt16)(g_Crc16Table[(((crc) >> 8) ^ (b)) & 0xFF] ^ ((crc) << 8)))
+
+#define kCrc16Poly 0x1021
+static UInt16 g_Crc16Table[256];
+
+static void Z7_FASTCALL Crc16GenerateTable(void)
+{
+ UInt32 i;
+ for (i = 0; i < 256; i++)
+ {
+ UInt32 r = (i << 8);
+ for (unsigned j = 0; j < 8; j++)
+ r = ((r << 1) ^ (kCrc16Poly & ((UInt32)0 - (r >> 15)))) & 0xFFFF;
+ g_Crc16Table[i] = (UInt16)r;
+ }
+}
+
+static UInt32 Z7_FASTCALL Crc16Calc(const void *data, size_t size)
+{
+ UInt32 v = CRC16_INIT_VAL;
+ const Byte *p = (const Byte *)data;
+ const Byte *pEnd = p + size;
+ for (; p != pEnd; p++)
+ v = CRC16_UPDATE_BYTE(v, *p);
+ return v;
+}
+
+static struct CCrc16TableInit { CCrc16TableInit() { Crc16GenerateTable(); } } g_Crc16TableInit;
+
+
+// ---------- ECMA Part 1 ----------
+
+void CDString::Parse(const Byte *p, unsigned size)
+{
+ Data.CopyFrom(p, size);
+}
+
+static UString ParseDString(const Byte *data, unsigned size)
+{
+ UString res;
+ if (size != 0)
+ {
+ wchar_t *p;
+ const Byte type = *data++;
+ size--;
+ if (type == 8)
+ {
+ p = res.GetBuf(size);
+ for (unsigned i = 0; i < size; i++)
+ {
+ const wchar_t c = data[i];
+ if (c == 0)
+ break;
+ *p++ = c;
+ }
+ }
+ else if (type == 16)
+ {
+ size &= ~(unsigned)1;
+ p = res.GetBuf(size / 2);
+ for (unsigned i = 0; i < size; i += 2)
+ {
+ const wchar_t c = GetBe16(data + i);
+ if (c == 0)
+ break;
+ *p++ = c;
+ }
+ }
+ else
+ return UString("[unknown]");
+ *p = 0;
+ res.ReleaseBuf_SetLen((unsigned)(p - (const wchar_t *)res));
+ }
+ return res;
+}
+
+UString CDString32::GetString() const
+{
+ const unsigned size = Data[sizeof(Data) - 1];
+ return ParseDString(Data, MyMin(size, (unsigned)(sizeof(Data) - 1)));
+}
+
+UString CDString128::GetString() const
+{
+ const unsigned size = Data[sizeof(Data) - 1];
+ return ParseDString(Data, MyMin(size, (unsigned)(sizeof(Data) - 1)));
+}
+
+UString CDString::GetString() const { return ParseDString(Data, (unsigned)Data.Size()); }
+
+void CTime::Parse(const Byte *p) { memcpy(Data, p, sizeof(Data)); }
+
+
+static void AddCommentChars(UString &dest, const char *s, size_t size)
+{
+ for (size_t i = 0; i < size; i++)
+ {
+ char c = s[i];
+ if (c == 0)
+ break;
+ if (c < 0x20)
+ c = '_';
+ dest += (wchar_t)c;
+ }
+}
+
+
+void CRegId::Parse(const Byte *p)
+{
+ Flags = p[0];
+ memcpy(Id, p + 1, sizeof(Id));
+ memcpy(Suffix, p + 24, sizeof(Suffix));
+}
+
+void CRegId::AddCommentTo(UString &s) const
+{
+ AddCommentChars(s, Id, sizeof(Id));
+}
+
+void CRegId::AddUdfVersionTo(UString &s) const
+{
+ // use it only for "Domain Identifier Suffix" and "UDF Identifier Suffix"
+ // UDF 2.1.5.3
+ // Revision in hex (3 digits)
+ const Byte minor = Suffix[0];
+ const Byte major = Suffix[1];
+ if (major != 0 || minor != 0)
+ {
+ char temp[16];
+ ConvertUInt32ToHex(major, temp);
+ s += temp;
+ s.Add_Dot();
+ ConvertUInt32ToHex8Digits(minor, temp);
+ s += &temp[8 - 2];
+ }
+}
+
+
+// ---------- ECMA Part 3: Volume Structure ----------
+
+void CExtent::Parse(const Byte *p)
+{
+ /* Len shall be less than < 2^30.
+ Unless otherwise specified, the length shall be an integral multiple of the logical sector size.
+ If (Len == 0), no extent is specified and (Pos) shall contain 0 */
+ G32 (0, Len);
+ G32 (4, Pos);
+}
+
+
+// ECMA 3/7.2
+
+struct CTag
+{
+ UInt16 Id;
+ // UInt16 Version;
+ // Byte Checksum;
+ // UInt16 SerialNumber;
+ // UInt16 Crc;
+ UInt16 CrcLen;
+ // UInt32 TagLocation; // the number of the logical sector
+
+ HRESULT Parse(const Byte *p, size_t size);
+};
+
+HRESULT CTag::Parse(const Byte *p, size_t size)
+{
+ if (size < 16)
+ return S_FALSE;
+ {
+ unsigned sum = 0;
+ for (unsigned i = 0; i < 16; i++)
+ sum = sum + p[i];
+ if ((Byte)(sum - p[4]) != p[4] || p[5] != 0)
+ return S_FALSE;
+ }
+ Id = Get16(p);
+ const UInt16 Version = Get16(p + 2);
+ if (Version != 2 && Version != 3)
+ return S_FALSE;
+ // SerialNumber = Get16(p + 6);
+ const UInt32 crc = Get16(p + 8);
+ CrcLen = Get16(p + 10);
+ // TagLocation = Get32(p + 12);
+
+ if (size >= 16 + (size_t)CrcLen)
+ if (crc == Crc16Calc(p + 16, (size_t)CrcLen))
+ return S_OK;
+ return S_FALSE;
+}
+
+// ECMA 3/7.2.1
+
+enum EDescriptorType
+{
+ DESC_TYPE_SpoaringTable = 0, // UDF
+ DESC_TYPE_PrimVol = 1,
+ DESC_TYPE_AnchorVolPtr = 2,
+ DESC_TYPE_VolPtr = 3,
+ DESC_TYPE_ImplUseVol = 4,
+ DESC_TYPE_Partition = 5,
+ DESC_TYPE_LogicalVol = 6,
+ DESC_TYPE_UnallocSpace = 7,
+ DESC_TYPE_Terminating = 8,
+ DESC_TYPE_LogicalVolIntegrity = 9,
+ DESC_TYPE_FileSet = 256,
+ DESC_TYPE_FileId = 257,
+ DESC_TYPE_AllocationExtent = 258,
+ DESC_TYPE_Indirect = 259,
+ DESC_TYPE_Terminal = 260,
+ DESC_TYPE_File = 261,
+ DESC_TYPE_ExtendedAttrHeader = 262,
+ DESC_TYPE_UnallocatedSpaceEntry = 263,
+ DESC_TYPE_SpaceBitmap = 264,
+ DESC_TYPE_PartitionIntegrity = 265,
+ DESC_TYPE_ExtendedFile = 266
+};
+
+
+void CLogBlockAddr::Parse(const Byte *p)
+{
+ G32 (0, Pos);
+ G16 (4, PartitionRef);
+}
+
+void CShortAllocDesc::Parse(const Byte *p)
+{
+ G32 (0, Len);
+ G32 (4, Pos);
+}
+
+/*
+void CADImpUse::Parse(const Byte *p)
+{
+ G16 (0, Flags);
+ G32 (2, UdfUniqueId);
+}
+*/
+
+void CLongAllocDesc::Parse(const Byte *p)
+{
+ G32 (0, Len);
+ Location.Parse(p + 4);
+ // memcpy(ImplUse, p + 10, sizeof(ImplUse));
+ // adImpUse.Parse(ImplUse);
+}
+
+
+void CPrimeVol::Parse(const Byte *p)
+{
+ // G32 (16, VolumeDescriptorSequenceNumber);
+ G32 (20, PrimaryVolumeDescriptorNumber);
+ VolumeId.Parse(p + 24);
+ G16 (56, VolumeSequenceNumber);
+ G16 (58, MaximumVolumeSequenceNumber);
+ // G16 (60, InterchangeLevel);
+ // G16 (62, MaximumInterchangeLevel);
+ // G32 (64, CharacterSetList)
+ // G32 (68, MaximumCharacterSetList)
+ VolumeSetId.Parse(p + 72);
+ // 200 64 Descriptor Character Set charspec (1/7.2.1)
+ // 264 64 Explanatory Character Set charspec (1/7.2.1)
+ // VolumeAbstract.Parse(p + 328);
+ // VolumeCopyrightNotice.Parse(p + 336);
+ ApplicationId.Parse(p + 344);
+ RecordingTime.Parse(p + 376);
+ ImplId.Parse(p + 388);
+ // 420 64 Implementation Use bytes
+ // G32 (484, PredecessorVolumeDescriptorSequenceLocation);
+ // G16 (488, Flags);
+}
+
+
+
+bool CInArchive::CheckExtent(unsigned volIndex, unsigned partitionRef, UInt32 blockPos, UInt32 len) const
+{
+ const CLogVol &vol = LogVols[volIndex];
+ if (partitionRef >= vol.PartitionMaps.Size())
+ return false;
+ const CPartition &partition = Partitions[vol.PartitionMaps[partitionRef].PartitionIndex];
+ return ((UInt64)blockPos * vol.BlockSize + len) <= ((UInt64)partition.Len << SecLogSize);
+}
+
+bool CInArchive::CheckItemExtents(unsigned volIndex, const CItem &item) const
+{
+ FOR_VECTOR (i, item.Extents)
+ {
+ const CMyExtent &e = item.Extents[i];
+ if (!CheckExtent(volIndex, e.PartitionRef, e.Pos, e.GetLen()))
+ return false;
+ }
+ return true;
+}
+
+HRESULT CInArchive::Read(unsigned volIndex, unsigned partitionRef, UInt32 blockPos, UInt32 len, Byte *buf)
+{
+ if (!CheckExtent(volIndex, partitionRef, blockPos, len))
+ return S_FALSE;
+ const CLogVol &vol = LogVols[volIndex];
+ const CPartition &partition = Partitions[vol.PartitionMaps[partitionRef].PartitionIndex];
+ UInt64 offset = ((UInt64)partition.Pos << SecLogSize) + (UInt64)blockPos * vol.BlockSize;
+ RINOK(InStream_SeekSet(_stream, offset))
+ offset += len;
+ UpdatePhySize(offset);
+ const HRESULT res = ReadStream_FALSE(_stream, buf, len);
+ if (res == S_FALSE && offset > FileSize)
+ UnexpectedEnd = true;
+ return res;
+}
+
+HRESULT CInArchive::ReadLad(unsigned volIndex, const CLongAllocDesc &lad, Byte *buf)
+{
+ return Read(volIndex, lad.Location.PartitionRef, lad.Location.Pos, lad.GetLen(), (Byte *)buf);
+}
+
+HRESULT CInArchive::ReadFromFile(unsigned volIndex, const CItem &item, CByteBuffer &buf)
+{
+ if (item.Size >= (UInt32)1 << 30)
+ return S_FALSE;
+ if (item.IsInline)
+ {
+ buf = item.InlineData;
+ return S_OK;
+ }
+ buf.Alloc((size_t)item.Size);
+ size_t pos = 0;
+ FOR_VECTOR (i, item.Extents)
+ {
+ const CMyExtent &e = item.Extents[i];
+ const UInt32 len = e.GetLen();
+ RINOK(Read(volIndex, e.PartitionRef, e.Pos, len, (Byte *)buf + pos))
+ pos += len;
+ }
+ return S_OK;
+}
+
+
+void CIcbTag::Parse(const Byte *p)
+{
+ // G32 (0, PriorDirectNum);
+ // G16 (4, StrategyType);
+ // G16 (6, StrategyParam);
+ // G16 (8, MaxNumOfEntries);
+ FileType = p[11];
+ // ParentIcb.Parse(p + 12);
+ G16 (18, Flags);
+}
+
+
+// ECMA 4/14.9 File Entry
+// UDF FileEntry 2.3.6
+
+// ECMA 4/14.17 Extended File Entry
+
+void CItem::Parse(const Byte *p)
+{
+ // (-1) can be stored in Uid/Gid.
+ // G32 (36, Uid);
+ // G32 (40, Gid);
+ // G32 (44, Permissions);
+ G16 (48, FileLinkCount);
+ // RecordFormat = p[50];
+ // RecordDisplayAttr = p[51];
+ // G32 (52, RecordLen);
+ G64 (56, Size);
+ if (IsExtended)
+ {
+ // The sum of all Information Length fields for all streams of a file (including the default stream). If this file has no
+ // streams, the Object Size shall be equal to the Information Length.
+ // G64 (64, ObjectSize);
+ p += 8;
+ }
+ G64 (64, NumLogBlockRecorded);
+ ATime.Parse(p + 72);
+ MTime.Parse(p + 84);
+ if (IsExtended)
+ {
+ CreateTime.Parse(p + 96);
+ p += 12;
+ }
+ AttribTime.Parse(p + 96);
+ // G32 (108, CheckPoint);
+ /*
+ if (IsExtended)
+ {
+ // Get32(p + 112); // reserved
+ p += 4;
+ }
+ // ExtendedAttrIcb.Parse(p + 112);
+ if (IsExtended)
+ {
+ StreamDirectoryIcb.Parse(p + 128);
+ p += 16;
+ }
+ */
+
+ // ImplId.Parse(p + 128);
+ // G64 (160, UniqueId);
+}
+
+
+// ECMA 4/14.4
+// UDF 2.3.4
+
+/*
+File Characteristics:
+Deleted bit:
+ ECMA: If set to ONE, shall mean this File Identifier Descriptor
+ identifies a file that has been deleted;
+ UDF: If the space for the file or directory is deallocated,
+ the implementation shall set the ICB field to zero.
+ ECMA 167 4/8.6 requires that the File Identifiers of all FIDs in a directory shall be unique.
+ The implementations shall follow these rules when a Deleted bit is set:
+ rewrire the compression ID of the File Identifier: 8 -> 254, 16 -> 255.
+*/
+
+struct CFileId
+{
+ // UInt16 FileVersion;
+ Byte FileCharacteristics;
+ // CByteBuffer ImplUse;
+ CDString Id;
+ CLongAllocDesc Icb;
+
+ bool IsItLink_Dir () const { return (FileCharacteristics & FILEID_CHARACS_Dir) != 0; }
+ bool IsItLink_Deleted() const { return (FileCharacteristics & FILEID_CHARACS_Deleted) != 0; }
+ bool IsItLink_Parent () const { return (FileCharacteristics & FILEID_CHARACS_Parent) != 0; }
+
+ size_t Parse(const Byte *p, size_t size);
+};
+
+size_t CFileId::Parse(const Byte *p, size_t size)
+{
+ size_t processed = 0;
+ if (size < 38)
+ return 0;
+ CTag tag;
+ if (tag.Parse(p, size) != S_OK)
+ return 0;
+ if (tag.Id != DESC_TYPE_FileId)
+ return 0;
+ // FileVersion = Get16(p + 16);
+ // UDF: There shall be only one version of a file as specified below with the value being set to 1.
+
+ FileCharacteristics = p[18];
+ const unsigned idLen = p[19];
+ Icb.Parse(p + 20);
+ const unsigned impLen = Get16(p + 36);
+ if (size < 38 + idLen + impLen)
+ return 0;
+ processed = 38;
+ // ImplUse.CopyFrom(p + processed, impLen);
+ processed += impLen;
+ Id.Parse(p + processed, idLen);
+ processed += idLen;
+ for (;(processed & 3) != 0; processed++)
+ if (p[processed] != 0)
+ return 0;
+ if ((size_t)tag.CrcLen + 16 != processed) return 0;
+ return (processed <= size) ? processed : 0;
+}
+
+
+
+HRESULT CInArchive::ReadFileItem(unsigned volIndex, unsigned fsIndex, const CLongAllocDesc &lad, bool isDir, int numRecurseAllowed)
+{
+ if (Files.Size() % 100 == 0)
+ RINOK(_progress->SetCompleted(Files.Size(), _processedProgressBytes))
+ if (numRecurseAllowed-- == 0)
+ return S_FALSE;
+ CFile &file = Files.Back();
+ const CLogVol &vol = LogVols[volIndex];
+ const unsigned partitionRef = lad.Location.PartitionRef;
+ if (partitionRef >= vol.PartitionMaps.Size())
+ return S_FALSE;
+ CPartition &partition = Partitions[vol.PartitionMaps[partitionRef].PartitionIndex];
+
+ const UInt32 key = lad.Location.Pos;
+ UInt32 value;
+ const UInt32 kRecursedErrorValue = (UInt32)(Int32)-1;
+ if (partition.Map.Find(key, value))
+ {
+ if (value == kRecursedErrorValue)
+ return S_FALSE;
+ file.ItemIndex = (int)(Int32)value;
+ }
+ else
+ {
+ value = Items.Size();
+ file.ItemIndex = (int)(Int32)value;
+ if (partition.Map.Set(key, kRecursedErrorValue))
+ return S_FALSE;
+ RINOK(ReadItem(volIndex, (int)fsIndex, lad, isDir, numRecurseAllowed))
+ if (!partition.Map.Set(key, value))
+ return S_FALSE;
+ }
+ return S_OK;
+}
+
+
+// (fsIndex = -1) means that it's metadata file
+
+HRESULT CInArchive::ReadItem(unsigned volIndex, int fsIndex, const CLongAllocDesc &lad, bool isDir, int numRecurseAllowed)
+{
+ if (Items.Size() >= kNumItemsMax)
+ return S_FALSE;
+ CItem &item = Items.AddNew();
+
+ const CLogVol &vol = LogVols[volIndex];
+
+ const size_t size = lad.GetLen();
+ if (size != vol.BlockSize)
+ return S_FALSE;
+
+ CByteBuffer buf(size);
+ RINOK(ReadLad(volIndex, lad, buf))
+
+ CTag tag;
+ const Byte *p = buf;
+ RINOK(tag.Parse(p, size))
+
+ item.IsExtended = (tag.Id == DESC_TYPE_ExtendedFile);
+ const size_t kExtendOffset = item.IsExtended ? 40 : 0;
+
+ if (size < kExtendOffset + 176)
+ return S_FALSE;
+ if (tag.Id != DESC_TYPE_File &&
+ tag.Id != DESC_TYPE_ExtendedFile)
+ return S_FALSE;
+
+ item.IcbTag.Parse(p + 16);
+
+ if (fsIndex < 0)
+ {
+ if (item.IcbTag.FileType != ICB_FILE_TYPE_METADATA &&
+ item.IcbTag.FileType != ICB_FILE_TYPE_METADATA_MIRROR)
+ return S_FALSE;
+ }
+ else if (
+ item.IcbTag.FileType != ICB_FILE_TYPE_DIR &&
+ item.IcbTag.FileType != ICB_FILE_TYPE_FILE)
+ return S_FALSE;
+
+ item.Parse(p);
+
+ _processedProgressBytes += (UInt64)item.NumLogBlockRecorded * vol.BlockSize + size;
+
+ const UInt32 extendedAttrLen = Get32(p + 168 + kExtendOffset);
+ const UInt32 allocDescriptorsLen = Get32(p + 172 + kExtendOffset);
+
+ if ((extendedAttrLen & 3) != 0)
+ return S_FALSE;
+ size_t pos = 176 + kExtendOffset;
+ if (extendedAttrLen > size - pos)
+ return S_FALSE;
+ /*
+ if (extendedAttrLen != 16)
+ {
+ if (extendedAttrLen < 24)
+ return S_FALSE;
+ CTag attrTag;
+ RINOK(attrTag.Parse(p + pos, size));
+ if (attrTag.Id != DESC_TYPE_ExtendedAttrHeader)
+ return S_FALSE;
+ // UInt32 implAttrLocation = Get32(p + pos + 16);
+ // UInt32 applicationlAttrLocation = Get32(p + pos + 20);
+ }
+ */
+ pos += extendedAttrLen;
+
+ const int descType = item.IcbTag.GetDescriptorType();
+ if (allocDescriptorsLen > size - pos)
+ return S_FALSE;
+ if (descType == ICB_DESC_TYPE_INLINE)
+ {
+ item.IsInline = true;
+ item.InlineData.CopyFrom(p + pos, allocDescriptorsLen);
+ }
+ else
+ {
+ item.IsInline = false;
+ if (descType != ICB_DESC_TYPE_SHORT && descType != ICB_DESC_TYPE_LONG)
+ return S_FALSE;
+ for (UInt32 i = 0; i < allocDescriptorsLen;)
+ {
+ CMyExtent e;
+ if (descType == ICB_DESC_TYPE_SHORT)
+ {
+ if (i + 8 > allocDescriptorsLen)
+ return S_FALSE;
+ CShortAllocDesc sad;
+ sad.Parse(p + pos + i);
+ e.Pos = sad.Pos;
+ e.Len = sad.Len;
+ e.PartitionRef = lad.Location.PartitionRef;
+ i += 8;
+ }
+ else
+ {
+ if (i + 16 > allocDescriptorsLen)
+ return S_FALSE;
+ CLongAllocDesc ladNew;
+ ladNew.Parse(p + pos + i);
+ e.Pos = ladNew.Location.Pos;
+ e.PartitionRef = ladNew.Location.PartitionRef;
+ e.Len = ladNew.Len;
+ i += 16;
+ }
+ item.Extents.Add(e);
+ }
+ }
+
+ if (isDir != item.IcbTag.IsDir())
+ return S_FALSE;
+
+ if (item.IcbTag.IsDir())
+ {
+ if (fsIndex < 0)
+ return S_FALSE;
+
+ if (!item.CheckChunkSizes() || !CheckItemExtents(volIndex, item))
+ return S_FALSE;
+ CByteBuffer buf2;
+ RINOK(ReadFromFile(volIndex, item, buf2))
+ item.Size = 0;
+ item.Extents.ClearAndFree();
+ item.InlineData.Free();
+
+ const Byte *p2 = buf2;
+ size_t size2 = buf2.Size();
+ while (size2 != 0)
+ {
+ CFileId fileId;
+ {
+ const size_t cur = fileId.Parse(p2, size2);
+ if (cur == 0)
+ return S_FALSE;
+ p2 += cur;
+ size2 -= cur;
+ }
+ if (fileId.IsItLink_Parent())
+ continue;
+ if (fileId.IsItLink_Deleted())
+ continue;
+ {
+ CFile file;
+ // file.FileVersion = fileId.FileVersion;
+ // file.FileCharacteristics = fileId.FileCharacteristics;
+ // file.ImplUse = fileId.ImplUse;
+ file.Id = fileId.Id;
+
+ _fileNameLengthTotal += file.Id.Data.Size();
+ if (_fileNameLengthTotal > kFileNameLengthTotalMax)
+ return S_FALSE;
+
+ item.SubFiles.Add(Files.Size());
+ if (Files.Size() >= kNumFilesMax)
+ return S_FALSE;
+ Files.Add(file);
+ RINOK(ReadFileItem(volIndex, (unsigned)fsIndex, fileId.Icb,
+ fileId.IsItLink_Dir(), numRecurseAllowed))
+ }
+ }
+ }
+ else
+ {
+ if ((UInt32)item.Extents.Size() > kNumExtentsMax - _numExtents)
+ return S_FALSE;
+ _numExtents += item.Extents.Size();
+
+ if (item.InlineData.Size() > kInlineExtentsSizeMax - _inlineExtentsSize)
+ return S_FALSE;
+ _inlineExtentsSize += item.InlineData.Size();
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CInArchive::FillRefs(CFileSet &fs, unsigned fileIndex, int parent, int numRecurseAllowed)
+{
+ if ((_numRefs & 0xFFF) == 0)
+ {
+ RINOK(_progress->SetCompleted())
+ }
+ if (numRecurseAllowed-- == 0)
+ return S_FALSE;
+ if (_numRefs >= kNumRefsMax)
+ return S_FALSE;
+ _numRefs++;
+ CRef ref;
+ ref.FileIndex = fileIndex;
+ ref.Parent = parent;
+ parent = (int)fs.Refs.Size();
+ fs.Refs.Add(ref);
+ const CItem &item = Items[Files[fileIndex].ItemIndex];
+ FOR_VECTOR (i, item.SubFiles)
+ {
+ RINOK(FillRefs(fs, item.SubFiles[i], parent, numRecurseAllowed))
+ }
+ return S_OK;
+}
+
+
+API_FUNC_IsArc IsArc_Udf(const Byte *p, size_t size)
+{
+ UInt32 res = k_IsArc_Res_NO;
+ unsigned SecLogSize;
+ for (SecLogSize = 11;; SecLogSize -= 2)
+ {
+ if (SecLogSize < 9)
+ return res;
+ const UInt32 offset = (UInt32)256 << SecLogSize;
+ const UInt32 bufSize = (UInt32)1 << SecLogSize;
+ if (offset + bufSize > size)
+ res = k_IsArc_Res_NEED_MORE;
+ else
+ {
+ CTag tag;
+ if (tag.Parse(p + offset, bufSize) == S_OK)
+ if (tag.Id == DESC_TYPE_AnchorVolPtr)
+ {
+ if (Get32(p + offset + 12) == 256 && // TagLocation
+ tag.CrcLen >= 16)
+ return k_IsArc_Res_YES;
+ }
+ }
+ }
+}
+
+
+HRESULT CInArchive::Open2()
+{
+ Clear();
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(_stream, fileSize))
+ FileSize = fileSize;
+
+ // Some UDFs contain additional pad zeros (2 KB).
+ // Seek to STREAM_SEEK_END for direct DVD reading can return 8 KB more, so we check last 16 KB.
+ // And when we read last block, result read size can be smaller than required size.
+
+ /*
+ const size_t kBufSize = 1 << 14;
+ Byte buf[kBufSize];
+ size_t readSize = (fileSize < kBufSize) ? (size_t)fileSize : kBufSize;
+ RINOK(InStream_SeekSet(_stream, fileSize - readSize))
+ RINOK(ReadStream(_stream, buf, &readSize));
+ size_t i = readSize;
+ for (;;)
+ {
+ const size_t kSecSizeMin = 1 << 8;
+ if (i < kSecSizeMin)
+ return S_FALSE;
+ i -= kSecSizeMin;
+ SecLogSize = (readSize - i < ((size_t)1 << 11)) ? 8 : 11;
+ CTag tag;
+ if (tag.Parse(buf + i, (1 << SecLogSize)) == S_OK)
+ if (tag.Id == DESC_TYPE_AnchorVolPtr)
+ break;
+ }
+ PhySize = fileSize;
+ CExtent extentVDS;
+ extentVDS.Parse(buf + i + 16);
+ */
+
+ /*
+ An Anchor Volume Descriptor Pointer structure shall be recorded in at
+ least 2 of the following 3 locations on the media:
+ Logical Sector 256.
+ Logical Sector (N - 256).
+ N
+ */
+
+ const size_t kBufSize = 1 << 11;
+ Byte buf[kBufSize];
+
+ for (SecLogSize = 11;; SecLogSize -= 2)
+ {
+ // Windows 10 uses unusual (SecLogSize = 9)
+ if (SecLogSize < 9)
+ return S_FALSE;
+ const UInt32 offset = (UInt32)256 << SecLogSize;
+ if (offset >= fileSize)
+ continue;
+ RINOK(InStream_SeekSet(_stream, offset))
+ const size_t bufSize = (size_t)1 << SecLogSize;
+ size_t readSize = bufSize;
+ RINOK(ReadStream(_stream, buf, &readSize))
+ if (readSize == bufSize)
+ {
+ CTag tag;
+ if (tag.Parse(buf, readSize) == S_OK)
+ if (tag.Id == DESC_TYPE_AnchorVolPtr)
+ {
+ if (Get32(buf + 12) == 256 &&
+ tag.CrcLen >= 16) // TagLocation
+ break;
+ }
+ }
+ }
+
+ PhySize = (UInt32)(256 + 1) << SecLogSize;
+ IsArc = true;
+
+ // UDF 2.2.3 AnchorVolumeDescriptorPointer
+
+ CExtent extentVDS;
+ extentVDS.Parse(buf + 16);
+ {
+ CExtent extentVDS2;
+ extentVDS2.Parse(buf + 24);
+ UpdatePhySize(extentVDS);
+ UpdatePhySize(extentVDS2);
+ }
+
+ for (UInt32 location = 0; ; location++)
+ {
+ if (location >= (extentVDS.Len >> SecLogSize))
+ return S_FALSE;
+
+ const size_t bufSize = (size_t)1 << SecLogSize;
+ {
+ const UInt64 offs = ((UInt64)extentVDS.Pos + location) << SecLogSize;
+ RINOK(InStream_SeekSet(_stream, offs))
+ const HRESULT res = ReadStream_FALSE(_stream, buf, bufSize);
+ if (res == S_FALSE && offs + bufSize > FileSize)
+ UnexpectedEnd = true;
+ RINOK(res)
+ }
+
+ CTag tag;
+ RINOK(tag.Parse(buf, bufSize))
+
+ if (tag.Id == DESC_TYPE_Terminating)
+ break;
+
+ if (tag.Id == DESC_TYPE_PrimVol)
+ {
+ CPrimeVol &pm = PrimeVols.AddNew();
+ pm.Parse(buf);
+ continue;
+ }
+
+ if (tag.Id == DESC_TYPE_Partition)
+ {
+ // Partition Descriptor
+ // ECMA 3/10.5
+ // UDF 2.2.14
+ if (Partitions.Size() >= kNumPartitionsMax)
+ return S_FALSE;
+ CPartition partition;
+ // const UInt32 volDescSeqNumer = Get32(buf + 16);
+ partition.Flags = Get16(buf + 20);
+ partition.Number = Get16(buf + 22);
+ partition.ContentsId.Parse(buf + 24);
+
+ // memcpy(partition.ContentsUse, buf + 56, sizeof(partition.ContentsUse));
+ // ContentsUse contains Partition Header Description.
+ // ECMA 4/14.3
+ // UDF PartitionHeaderDescriptor 2.3.3
+
+ partition.AccessType = Get32(buf + 184);
+ partition.Pos = Get32(buf + 188);
+ partition.Len = Get32(buf + 192);
+ partition.ImplId.Parse(buf + 196);
+ // memcpy(partition.ImplUse, buf + 228, sizeof(partition.ImplUse));
+
+ PRF(printf("\nPartition number = %2d pos = %d len = %d", partition.Number, partition.Pos, partition.Len));
+ Partitions.Add(partition);
+ continue;
+ }
+
+ if (tag.Id == DESC_TYPE_LogicalVol)
+ {
+ /* Logical Volume Descriptor
+ ECMA 3/10.6
+ UDF 2.60 2.2.4 */
+
+ if (LogVols.Size() >= kNumLogVolumesMax)
+ return S_FALSE;
+ CLogVol &vol = LogVols.AddNew();
+
+ vol.Id.Parse(buf + 84);
+ vol.BlockSize = Get32(buf + 212);
+ if (vol.BlockSize != ((UInt32)1 << SecLogSize))
+ {
+ // UDF 2.2.4.2 LogicalBlockSize
+ // UDF probably doesn't allow different sizes
+ return S_FALSE;
+ }
+ /*
+ if (vol.BlockSize < 512 || vol.BlockSize > ((UInt32)1 << 30))
+ return S_FALSE;
+ */
+
+ vol.DomainId.Parse(buf + 216);
+
+ // ECMA 4/3.1
+ // UDF 2.2.4.4 LogicalVolumeContentsUse
+ /* the extent in which the first File Set Descriptor Sequence
+ of the logical volume is recorded */
+ vol.FileSetLocation.Parse(buf + 248);
+ // memcpy(vol.ContentsUse, buf + 248, sizeof(vol.ContentsUse));
+
+ vol.ImplId.Parse(buf + 272);
+ // memcpy(vol.ImplUse, buf + 304, sizeof(vol.ImplUse));
+ // vol.IntegritySequenceExtent.Parse(buf + 432);
+
+ const UInt32 mapTableLen = Get32(buf + 264);
+ const UInt32 numPartitionMaps = Get32(buf + 268);
+ if (numPartitionMaps > kNumPartitionsMax)
+ return S_FALSE;
+
+ PRF(printf("\nLogicalVol numPartitionMaps = %2d", numPartitionMaps));
+
+ size_t pos = 440;
+ if (mapTableLen > bufSize - pos)
+ return S_FALSE;
+ const size_t posLimit = pos + mapTableLen;
+
+ for (UInt32 i = 0; i < numPartitionMaps; i++)
+ {
+ // ECMA 3/10.7 Partition maps
+ if (pos + 2 > posLimit)
+ return S_FALSE;
+ CPartitionMap pm;
+ pm.Type = buf[pos + 0];
+ // pm.Length = buf[pos + 1];
+ const Byte len = buf[pos + 1];
+ if (pos + len > posLimit)
+ return S_FALSE;
+
+ // memcpy(pm.Data, buf + pos + 2, pm.Length - 2);
+ if (pm.Type == 1)
+ {
+ // ECMA 3/10.7.2
+ if (len != 6)
+ return S_FALSE;
+ pm.VolumeSequenceNumber = Get16(buf + pos + 2);
+ pm.PartitionNumber = Get16(buf + pos + 4);
+ PRF(printf("\nPartitionMap type 1 PartitionNumber = %2d", pm.PartitionNumber));
+ }
+ else if (pm.Type == 2)
+ {
+ if (len != 64)
+ return S_FALSE;
+ /* ECMA 10.7.3 / Type 2 Partition Map
+ 62 bytes: Partition Identifier. */
+
+ /* UDF
+ 2.2.8 "*UDF Virtual Partition"
+ 2.2.9 "*UDF Sparable Partition"
+ 2.2.10 "*UDF Metadata Partition"
+ */
+
+ if (Get16(buf + pos + 2) != 0) // reserved
+ return S_FALSE;
+
+ pm.PartitionTypeId.Parse(buf + pos + 4);
+ pm.VolumeSequenceNumber = Get16(buf + pos + 36);
+ pm.PartitionNumber = Get16(buf + pos + 38);
+
+ if (memcmp(pm.PartitionTypeId.Id, "*UDF Metadata Partition", 23) != 0)
+ return S_FALSE;
+
+ // UDF 2.2.10 Metadata Partition Map
+ pm.MetadataFileLocation = Get32(buf + pos + 40);
+ // pm.MetadataMirrorFileLocation = Get32(buf + pos + 44);
+ // pm.MetadataBitmapFileLocation = Get32(buf + pos + 48);
+ // pm.AllocationUnitSize = Get32(buf + pos + 52);
+ // pm.AlignmentUnitSize = Get16(buf + pos + 56);
+ // pm.Flags = buf[pos + 58];
+
+ PRF(printf("\nPartitionMap type 2 PartitionNumber = %2d", pm.PartitionNumber));
+ // Unsupported = true;
+ // return S_FALSE;
+ }
+ else
+ return S_FALSE;
+ pos += len;
+ vol.PartitionMaps.Add(pm);
+ }
+ continue;
+ }
+
+ /*
+ if (tag.Id == DESC_TYPE_UnallocSpace)
+ {
+ // UInt32 volDescSeqNumer = Get32(buf + 16);
+ const UInt32 numAlocDescs = Get32(buf + 20);
+ // we need examples for (numAlocDescs != 0) case
+ if (numAlocDescs > (bufSize - 24) / 8)
+ return S_FALSE;
+ for (UInt32 i = 0; i < numAlocDescs; i++)
+ {
+ CExtent e;
+ e.Parse(buf + 24 + i * 8);
+ }
+ continue;
+ }
+ else
+ continue;
+ */
+ }
+
+ UInt64 totalSize = 0;
+
+ unsigned volIndex;
+ for (volIndex = 0; volIndex < LogVols.Size(); volIndex++)
+ {
+ CLogVol &vol = LogVols[volIndex];
+ FOR_VECTOR (pmIndex, vol.PartitionMaps)
+ {
+ CPartitionMap &pm = vol.PartitionMaps[pmIndex];
+ for (unsigned i = 0;; i++)
+ {
+ if (i == Partitions.Size())
+ return S_FALSE;
+ CPartition &part = Partitions[i];
+ if (part.Number == pm.PartitionNumber)
+ {
+ pm.PartitionIndex = i;
+ if (pm.Type == 2)
+ break;
+
+ /*
+ if (part.VolIndex >= 0)
+ {
+ // it's for 2.60. Fix it
+ if (part.VolIndex != (int)volIndex)
+ return S_FALSE;
+ // return S_FALSE;
+ }
+ part.VolIndex = volIndex;
+ */
+
+ totalSize += (UInt64)part.Len << SecLogSize;
+ break;
+ }
+ }
+ }
+ }
+
+ for (volIndex = 0; volIndex < LogVols.Size(); volIndex++)
+ {
+ CLogVol &vol = LogVols[volIndex];
+ FOR_VECTOR (pmIndex, vol.PartitionMaps)
+ {
+ CPartitionMap &pm = vol.PartitionMaps[pmIndex];
+ if (pm.Type != 2)
+ continue;
+
+ {
+ CLongAllocDesc lad;
+ lad.Len = vol.BlockSize;
+ lad.Location.Pos = pm.MetadataFileLocation;
+ // lad.Location.Pos = pm.MetadataMirrorFileLocation;
+
+ lad.Location.PartitionRef = (UInt16)pmIndex;
+
+ /* we need correct PartitionMaps[lad.Location.PartitionRef].PartitionIndex.
+ so we can use pmIndex or find (Type==1) PartitionMap */
+ FOR_VECTOR (pmIndex2, vol.PartitionMaps)
+ {
+ const CPartitionMap &pm2 = vol.PartitionMaps[pmIndex2];
+ if (pm2.PartitionNumber == pm.PartitionNumber && pm2.Type == 1)
+ {
+ lad.Location.PartitionRef = (UInt16)pmIndex2;
+ break;
+ }
+ }
+
+ RINOK(ReadItem(volIndex,
+ -1, // (fsIndex = -1) means that it's metadata
+ lad,
+ false, // isDir
+ 1)) // numRecurseAllowed
+ }
+ {
+ const CItem &item = Items.Back();
+ if (!CheckItemExtents(volIndex, item))
+ return S_FALSE;
+ if (item.Extents.Size() != 1)
+ {
+ if (item.Extents.Size() < 1)
+ return S_FALSE;
+ /* Windows 10 writes empty record item.Extents[1].
+ we ignore such extent here */
+ for (unsigned k = 1; k < item.Extents.Size(); k++)
+ {
+ const CMyExtent &e = item.Extents[k];
+ if (e.GetLen() != 0)
+ return S_FALSE;
+ }
+ }
+
+ const CMyExtent &e = item.Extents[0];
+ const CPartition &part = Partitions[pm.PartitionIndex];
+ CPartition mp = part;
+ mp.IsMetadata = true;
+ // mp.Number = part.Number;
+ mp.Pos = part.Pos + e.Pos;
+ mp.Len = e.Len >> SecLogSize;
+ pm.PartitionIndex = Partitions.Add(mp);
+ }
+ // Items.DeleteBack(); // we can delete that metadata item
+
+ /*
+ // short version of code to read metadata file.
+ RINOK(CInArchive::Read(volIndex, pmIndex, pm.MetadataFileLocation, 224, buf));
+ CTag tag;
+ RINOK(tag.Parse(buf, 224));
+ if (tag.Id != DESC_TYPE_ExtendedFile)
+ return S_FALSE;
+ CShortAllocDesc sad;
+ sad.Parse(buf + 216);
+ const CPartition &part = Partitions[pm.PartitionIndex];
+ CPartition mp = part;
+ mp.IsMetadata = true;
+ // mp.Number = part.Number;
+ mp.Pos = part.Pos + sad.Pos;
+ mp.Len = sad.Len >> SecLogSize;
+ pm.PartitionIndex = Partitions.Add(mp);
+ */
+ }
+ }
+
+ RINOK(_progress->SetTotal(totalSize))
+
+ PRF(printf("\n Read files"));
+
+ for (volIndex = 0; volIndex < LogVols.Size(); volIndex++)
+ {
+ CLogVol &vol = LogVols[volIndex];
+
+ PRF(printf("\nLogVol %2d", volIndex));
+
+ CLongAllocDesc nextExtent = vol.FileSetLocation;
+ // while (nextExtent.ExtentLen != 0)
+ // for (int i = 0; i < 1; i++)
+ {
+ if (nextExtent.GetLen() < 512)
+ return S_FALSE;
+ CByteBuffer buf2(nextExtent.GetLen());
+ RINOK(ReadLad(volIndex, nextExtent, buf2))
+ const Byte *p = buf2;
+ const size_t size = nextExtent.GetLen();
+
+ CTag tag;
+ RINOK(tag.Parse(p, size))
+
+ /*
+ // commented in 22.01
+ if (tag.Id == DESC_TYPE_ExtendedFile)
+ {
+ // ECMA 4 / 14.17
+ // 2.60 ??
+ return S_FALSE;
+ }
+ */
+
+ if (tag.Id != DESC_TYPE_FileSet)
+ return S_FALSE;
+
+ PRF(printf("\n FileSet", volIndex));
+ CFileSet fs;
+ fs.RecordingTime.Parse(p + 16);
+ // fs.InterchangeLevel = Get16(p + 18);
+ // fs.MaxInterchangeLevel = Get16(p + 20);
+ fs.FileSetNumber = Get32(p + 40);
+ fs.FileSetDescNumber = Get32(p + 44);
+
+ fs.LogicalVolumeId.Parse(p + 112);
+ fs.Id.Parse(p + 304);
+ fs.CopyrightId.Parse(p + 336);
+ fs.AbstractId.Parse(p + 368);
+
+ fs.RootDirICB.Parse(p + 400);
+ fs.DomainId.Parse(p + 416);
+
+ // fs.SystemStreamDirICB.Parse(p + 464);
+
+ vol.FileSets.Add(fs);
+
+ // nextExtent.Parse(p + 448);
+ }
+
+ FOR_VECTOR (fsIndex, vol.FileSets)
+ {
+ CFileSet &fs = vol.FileSets[fsIndex];
+ const unsigned fileIndex = Files.Size();
+ Files.AddNew();
+ RINOK(ReadFileItem(volIndex, fsIndex, fs.RootDirICB,
+ true, // isDir
+ kNumRecursionLevelsMax))
+ RINOK(FillRefs(fs, fileIndex, -1, kNumRecursionLevelsMax))
+ }
+ }
+
+
+ for (volIndex = 0; volIndex < LogVols.Size(); volIndex++)
+ {
+ const CLogVol &vol = LogVols[volIndex];
+ // bool showFileSetName = (vol.FileSets.Size() > 1);
+ FOR_VECTOR (fsIndex, vol.FileSets)
+ {
+ const CFileSet &fs = vol.FileSets[fsIndex];
+ for (unsigned i =
+ // ((showVolName || showFileSetName) ? 0 : 1)
+ 0; i < fs.Refs.Size(); i++)
+ {
+ const CRef &ref = vol.FileSets[fsIndex].Refs[i];
+ const CFile &file = Files[ref.FileIndex];
+ const CItem &item = Items[file.ItemIndex];
+ UInt64 size = item.Size;
+
+ if (!item.IsRecAndAlloc() || !item.CheckChunkSizes() || !CheckItemExtents(volIndex, item))
+ continue;
+
+ FOR_VECTOR (extentIndex, item.Extents)
+ {
+ const CMyExtent &extent = item.Extents[extentIndex];
+ const UInt32 len = extent.GetLen();
+ if (len == 0)
+ continue;
+ if (size < len)
+ break;
+
+ const unsigned partitionIndex = vol.PartitionMaps[extent.PartitionRef].PartitionIndex;
+ const UInt32 logBlockNumber = extent.Pos;
+ const CPartition &partition = Partitions[partitionIndex];
+ const UInt64 offset = ((UInt64)partition.Pos << SecLogSize) +
+ (UInt64)logBlockNumber * vol.BlockSize;
+ UpdatePhySize(offset + len);
+ }
+ }
+ }
+ }
+
+ {
+ const UInt32 secMask = ((UInt32)1 << SecLogSize) - 1;
+ PhySize = (PhySize + secMask) & ~(UInt64)secMask;
+ }
+
+ NoEndAnchor = true;
+
+ if (PhySize < fileSize)
+ {
+ UInt64 rem = fileSize - PhySize;
+ const size_t secSize = (size_t)1 << SecLogSize;
+
+ RINOK(InStream_SeekSet(_stream, PhySize))
+
+ // some UDF images contain ZEROs before "Anchor Volume Descriptor Pointer" at the end
+
+ for (unsigned sec = 0; sec < 1024; sec++)
+ {
+ if (rem == 0)
+ break;
+
+ size_t readSize = secSize;
+ if (readSize > rem)
+ readSize = (size_t)rem;
+
+ RINOK(ReadStream(_stream, buf, &readSize))
+
+ if (readSize == 0)
+ break;
+
+ // some udf contain many EndAnchors
+ if (readSize == secSize /* && NoEndAnchor */)
+ {
+ CTag tag;
+ if (tag.Parse(buf, readSize) == S_OK
+ && tag.Id == DESC_TYPE_AnchorVolPtr
+ && Get32(buf + 12) == (UInt32)((fileSize - rem) >> SecLogSize))
+ {
+ NoEndAnchor = false;
+ rem -= readSize;
+ PhySize = fileSize - rem;
+ continue;
+ }
+ }
+
+ size_t i;
+ for (i = 0; i < readSize && buf[i] == 0; i++);
+ if (i != readSize)
+ break;
+ rem -= readSize;
+ }
+
+ if (rem == 0)
+ PhySize = fileSize;
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CInArchive::Open(IInStream *inStream, CProgressVirt *progress)
+{
+ _progress = progress;
+ _stream = inStream;
+ HRESULT res = Open2();
+ if (res == S_FALSE && IsArc && !UnexpectedEnd)
+ Unsupported = true;
+ return res;
+
+ /*
+ HRESULT res;
+ try
+ {
+ res = Open2();
+ }
+ catch(...)
+ {
+ // Clear();
+ // res = S_FALSE;
+ _stream.Release();
+ throw;
+ }
+ _stream.Release();
+ return res;
+ */
+}
+
+void CInArchive::Clear()
+{
+ IsArc = false;
+ Unsupported = false;
+ UnexpectedEnd = false;
+ NoEndAnchor = false;
+
+ PhySize = 0;
+ FileSize = 0;
+
+ Partitions.Clear();
+ LogVols.Clear();
+ PrimeVols.Clear();
+ Items.Clear();
+ Files.Clear();
+ _fileNameLengthTotal = 0;
+ _numRefs = 0;
+ _numExtents = 0;
+ _inlineExtentsSize = 0;
+ _processedProgressBytes = 0;
+}
+
+
+static const char * const g_PartitionTypes[] =
+{
+ "Pseudo-Overwritable" // UDF
+ , "Read-Only"
+ , "Write-Once"
+ , "Rewritable"
+ , "Overwritable"
+};
+
+
+static void AddComment_Align(UString &s)
+{
+ s += " ";
+}
+
+static void AddComment_PropName(UString &s, const char *name)
+{
+ AddComment_Align(s);
+ s += name;
+ s += ": ";
+}
+
+static void AddComment_UInt32(UString &s, const char *name, UInt32 val)
+{
+ AddComment_PropName(s, name);
+ s.Add_UInt32(val);
+ s.Add_LF();
+}
+
+static void AddComment_UInt32_2(UString &s, const char *name, UInt32 val)
+{
+ AddComment_Align(s);
+ AddComment_UInt32(s, name, val);
+}
+
+
+static void AddComment_UInt64(UString &s, const char *name, UInt64 val)
+{
+ AddComment_PropName(s, name);
+ s.Add_UInt64(val);
+ s.Add_LF();
+}
+
+static void AddComment_RegId(UString &s, const char *name, const CRegId &ri)
+{
+ AddComment_PropName(s, name);
+ ri.AddCommentTo(s);
+ s.Add_LF();
+}
+
+static void AddComment_RegId_Domain(UString &s, const char *name, const CRegId &ri)
+{
+ AddComment_PropName(s, name);
+ ri.AddCommentTo(s);
+ {
+ UString s2;
+ ri.AddUdfVersionTo(s2);
+ if (!s2.IsEmpty())
+ {
+ s += "::";
+ s += s2;
+ }
+ }
+ s.Add_LF();
+}
+
+
+// UDF 6.3.1 OS Class
+
+static const char * const g_OsClasses[] =
+{
+ NULL
+ , "DOS"
+ , "OS/2"
+ , "Macintosh OS"
+ , "UNIX"
+ , "Windows 9x"
+ , "Windows NT"
+ , "OS/400"
+ , "BeOS"
+ , "Windows CE"
+};
+
+// UDF 6.3.2 OS Identifier
+
+static const char * const g_OsIds_Unix[] =
+{
+ NULL // "Generic"
+ , "AIX"
+ , "SUN OS / Solaris"
+ , "HP/UX"
+ , "Silicon Graphics Irix"
+ , "Linux"
+ , "MKLinux"
+ , "FreeBSD"
+ , "NetBSD"
+};
+
+static void AddOs_Class_Id(UString &s, const Byte *p)
+{
+ // UDF 2.1.5.3 Implementation Identifier Suffix
+ // Appendix 6.3 Operating System Identifiers.
+ const Byte osClass = p[0];
+ if (osClass != 0)
+ {
+ s += "::";
+ s += TypeToString(g_OsClasses, Z7_ARRAY_SIZE(g_OsClasses), osClass);
+ }
+ const Byte osId = p[1];
+ if (osId != 0)
+ {
+ s += "::";
+ if (osClass == 4) // unix
+ {
+ s += TypeToString(g_OsIds_Unix, Z7_ARRAY_SIZE(g_OsIds_Unix), osId);
+ }
+ else
+ s.Add_UInt32(osId);
+ }
+}
+
+
+static void AddComment_RegId_Impl(UString &s, const char *name, const CRegId &ri)
+{
+ AddComment_PropName(s, name);
+ ri.AddCommentTo(s);
+ {
+ AddOs_Class_Id(s, ri.Suffix);
+ }
+ s.Add_LF();
+}
+
+
+static void AddComment_RegId_UdfId(UString &s, const char *name, const CRegId &ri)
+{
+ AddComment_PropName(s, name);
+ ri.AddCommentTo(s);
+ {
+ // UDF 2.1.5.3
+ // UDF Identifier Suffix format
+ UString s2;
+ ri.AddUdfVersionTo(s2);
+ if (!s2.IsEmpty())
+ {
+ s += "::";
+ s += s2;
+ }
+ AddOs_Class_Id(s, &ri.Suffix[2]);
+ }
+ s.Add_LF();
+}
+
+static void AddComment_DString32(UString &s, const char *name, const CDString32 &d)
+{
+ AddComment_Align(s);
+ AddComment_PropName(s, name);
+ s += d.GetString();
+ s.Add_LF();
+}
+
+UString CInArchive::GetComment() const
+{
+ UString s;
+ {
+ s += "Primary Volumes:";
+ s.Add_LF();
+ FOR_VECTOR (i, PrimeVols)
+ {
+ if (i != 0)
+ s.Add_LF();
+ const CPrimeVol &pv = PrimeVols[i];
+ // AddComment_UInt32(s, "VolumeDescriptorSequenceNumber", pv.VolumeDescriptorSequenceNumber);
+ // if (PrimeVols.Size() != 1 || pv.PrimaryVolumeDescriptorNumber != 0)
+ AddComment_UInt32(s, "PrimaryVolumeDescriptorNumber", pv.PrimaryVolumeDescriptorNumber);
+ // if (pv.MaximumVolumeSequenceNumber != 1 || pv.VolumeSequenceNumber != 1)
+ AddComment_UInt32(s, "VolumeSequenceNumber", pv.VolumeSequenceNumber);
+ if (pv.MaximumVolumeSequenceNumber != 1)
+ AddComment_UInt32(s, "MaximumVolumeSequenceNumber", pv.MaximumVolumeSequenceNumber);
+ AddComment_PropName(s, "VolumeId");
+ s += pv.VolumeId.GetString();
+ s.Add_LF();
+ AddComment_PropName(s, "VolumeSetId");
+ s += pv.VolumeSetId.GetString();
+ s.Add_LF();
+ // AddComment_UInt32(s, "InterchangeLevel", pv.InterchangeLevel);
+ // AddComment_UInt32(s, "MaximumInterchangeLevel", pv.MaximumInterchangeLevel);
+ AddComment_RegId(s, "ApplicationId", pv.ApplicationId);
+ AddComment_RegId_Impl(s, "ImplementationId", pv.ImplId);
+ }
+ }
+ {
+ s += "Partitions:";
+ s.Add_LF();
+ FOR_VECTOR (i, Partitions)
+ {
+ if (i != 0)
+ s.Add_LF();
+ const CPartition &part = Partitions[i];
+ AddComment_UInt32(s, "PartitionIndex", i);
+ AddComment_UInt32(s, "PartitionNumber", part.Number);
+ if (part.IsMetadata)
+ AddComment_UInt32(s, "IsMetadata", 1);
+ else
+ {
+ AddComment_RegId(s, "ContentsId", part.ContentsId);
+ AddComment_RegId_Impl(s, "ImplementationId", part.ImplId);
+ AddComment_PropName(s, "AccessType");
+ s += TypeToString(g_PartitionTypes, Z7_ARRAY_SIZE(g_PartitionTypes), part.AccessType);
+ s.Add_LF();
+ }
+ AddComment_UInt64(s, "Size", (UInt64)part.Len << SecLogSize);
+ AddComment_UInt64(s, "Pos", (UInt64)part.Pos << SecLogSize);
+ }
+ }
+ s += "Logical Volumes:";
+ s.Add_LF();
+ {
+ FOR_VECTOR (i, LogVols)
+ {
+ if (i != 0)
+ s.Add_LF();
+ const CLogVol &vol = LogVols[i];
+ if (LogVols.Size() != 1)
+ AddComment_UInt32(s, "Number", i);
+ AddComment_PropName(s, "Id");
+ s += vol.Id.GetString();
+ s.Add_LF();
+ AddComment_UInt32(s, "BlockSize", vol.BlockSize);
+ AddComment_RegId_Domain(s, "DomainId", vol.DomainId);
+ AddComment_RegId_Impl(s, "ImplementationId", vol.ImplId);
+ // AddComment_UInt64(s, "IntegritySequenceExtent_Len", vol.IntegritySequenceExtent.Len);
+ // AddComment_UInt64(s, "IntegritySequenceExtent_Pos", (UInt64)vol.IntegritySequenceExtent.Pos << SecLogSize);
+
+ s += " Partition Maps:";
+ s.Add_LF();
+ {
+ FOR_VECTOR (j, vol.PartitionMaps)
+ {
+ if (j != 0)
+ s.Add_LF();
+ const CPartitionMap &pm = vol.PartitionMaps[j];
+ AddComment_UInt32_2(s, "PartitionMap", j);
+ AddComment_UInt32_2(s, "Type", pm.Type);
+ AddComment_UInt32_2(s, "VolumeSequenceNumber", pm.VolumeSequenceNumber);
+ AddComment_UInt32_2(s, "PartitionNumber", pm.PartitionNumber);
+ if (pm.Type == 2)
+ {
+ AddComment_UInt32_2(s, "MetadataFileLocation", pm.MetadataFileLocation);
+ // AddComment_UInt32_2(s, "MetadataMirrorFileLocation", pm.MetadataMirrorFileLocation);
+ // AddComment_UInt32_2(s, "MetadataBitmapFileLocation", pm.MetadataBitmapFileLocation);
+ // AddComment_UInt32_2(s, "AllocationUnitSize", pm.AllocationUnitSize);
+ // AddComment_UInt32_2(s, "AlignmentUnitSize", pm.AlignmentUnitSize);
+ // AddComment_UInt32_2(s, "Flags", pm.Flags);
+ AddComment_Align(s); AddComment_RegId_UdfId(s, "PartitionTypeId", pm.PartitionTypeId);
+ }
+ }
+ }
+ s += " File Sets:";
+ s.Add_LF();
+ {
+ FOR_VECTOR (j, vol.FileSets)
+ {
+ if (j != 0)
+ s.Add_LF();
+ const CFileSet &fs = vol.FileSets[j];
+ AddComment_Align(s); AddComment_UInt32(s, "FileSetNumber", fs.FileSetNumber);
+ AddComment_Align(s); AddComment_UInt32(s, "FileSetDescNumber", fs.FileSetDescNumber);
+
+ AddComment_Align(s);
+ AddComment_PropName(s, "LogicalVolumeId");
+ s += fs.LogicalVolumeId.GetString();
+ s.Add_LF();
+
+ AddComment_DString32(s, "Id", fs.Id);
+ AddComment_DString32(s, "CopyrightId", fs.CopyrightId);
+ AddComment_DString32(s, "AbstractId", fs.AbstractId);
+
+ AddComment_Align(s);
+ AddComment_RegId_Domain(s, "DomainId", fs.DomainId);
+ }
+ }
+ }
+ }
+ return s;
+}
+
+static UString GetSpecName(const UString &name)
+{
+ UString name2 = name;
+ name2.Trim();
+ if (name2.IsEmpty())
+ return UString("[]");
+ return name;
+}
+
+static void UpdateWithName(UString &res, const UString &addString)
+{
+ if (res.IsEmpty())
+ res = addString;
+ else
+ res.Insert(0, addString + WCHAR_PATH_SEPARATOR);
+}
+
+UString CInArchive::GetItemPath(unsigned volIndex, unsigned fsIndex, unsigned refIndex,
+ bool showVolName, bool showFsName) const
+{
+ // showVolName = true;
+ const CLogVol &vol = LogVols[volIndex];
+ const CFileSet &fs = vol.FileSets[fsIndex];
+
+ UString name;
+
+ for (;;)
+ {
+ const CRef &ref = fs.Refs[refIndex];
+ // we break on root file (that probably has empty name)
+ if (ref.Parent < 0)
+ break;
+ refIndex = (unsigned)ref.Parent;
+ UpdateWithName(name, GetSpecName(Files[ref.FileIndex].GetName()));
+ }
+
+ if (showFsName)
+ {
+ UString newName ("File Set ");
+ newName.Add_UInt32(fsIndex);
+ UpdateWithName(name, newName);
+ }
+
+ if (showVolName)
+ {
+ UString newName;
+ newName.Add_UInt32(volIndex);
+ UString newName2 = vol.GetName();
+ if (newName2.IsEmpty())
+ newName2 = "Volume";
+ newName += '-';
+ newName += newName2;
+ UpdateWithName(name, newName);
+ }
+ return name;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Udf/UdfIn.h b/CPP/7zip/Archive/Udf/UdfIn.h
new file mode 100644
index 0000000..9ccbf74
--- /dev/null
+++ b/CPP/7zip/Archive/Udf/UdfIn.h
@@ -0,0 +1,507 @@
+// Archive/UdfIn.h -- UDF / ECMA-167
+
+#ifndef ZIP7_INC_ARCHIVE_UDF_IN_H
+#define ZIP7_INC_ARCHIVE_UDF_IN_H
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyMap.h"
+#include "../../../Common/MyString.h"
+
+#include "../../IStream.h"
+
+namespace NArchive {
+namespace NUdf {
+
+// ---------- ECMA Part 1 ----------
+
+// ECMA 1/7.2.12
+// UDF 2.1.3
+
+struct CDString32
+{
+ Byte Data[32];
+
+ void Parse(const Byte *buf) { memcpy(Data, buf, sizeof(Data)); }
+ UString GetString() const;
+};
+
+struct CDString128
+{
+ Byte Data[128];
+
+ void Parse(const Byte *buf) { memcpy(Data, buf, sizeof(Data)); }
+ UString GetString() const;
+};
+
+struct CDString
+{
+ CByteBuffer Data;
+
+ void Parse(const Byte *p, unsigned size);
+ UString GetString() const;
+};
+
+
+// ECMA 1/7.3
+// UDF 2.1.4 timestamp
+
+struct CTime
+{
+ Byte Data[12];
+
+ unsigned GetType() const { return Data[1] >> 4; }
+ bool IsLocal() const { return GetType() == 1; }
+ int GetMinutesOffset() const
+ {
+ int t = (Data[0] | ((unsigned)Data[1] << 8)) & 0xFFF;
+ if ((t >> 11) != 0)
+ t -= (1 << 12);
+ return (t > (60 * 24) || t < -(60 * 24)) ? 0 : t;
+ }
+ unsigned GetYear() const { return (Data[2] | ((unsigned)Data[3] << 8)); }
+ void Parse(const Byte *buf);
+};
+
+
+// ECMA 1/7.4 regid
+// UDF 2.1.5 EntityID
+
+struct CRegId
+{
+ Byte Flags;
+ char Id[23];
+ Byte Suffix[8];
+
+ void Parse(const Byte *buf);
+ void AddCommentTo(UString &s) const;
+ void AddUdfVersionTo(UString &s) const;
+};
+
+
+
+// ---------- ECMA Part 3: Volume Structure ----------
+
+// ECMA 3/7.1
+
+struct CExtent
+{
+ UInt32 Len;
+ UInt32 Pos; // logical sector number
+
+ void Parse(const Byte *p);
+};
+
+
+// ECMA 3/10.1
+// UDF 2.2.2 PrimaryVolumeDescriptor
+
+struct CPrimeVol
+{
+ // UInt32 VolumeDescriptorSequenceNumber;
+ UInt32 PrimaryVolumeDescriptorNumber;
+ CDString32 VolumeId;
+ UInt16 VolumeSequenceNumber;
+ UInt16 MaximumVolumeSequenceNumber;
+ // UInt16 InterchangeLevel;
+ // UInt16 MaximumInterchangeLevel;
+ // UInt32 CharacterSetList;
+ // UInt32 MaximumCharacterSetList;
+ CDString128 VolumeSetId;
+ // charspec DescriptorCharacterSet; // (1/7.2.1)
+ // charspec ExplanatoryCharacterSet; // (1/7.2.1)
+ // CExtent VolumeAbstract;
+ // CExtent VolumeCopyrightNotice;
+ CRegId ApplicationId;
+ CTime RecordingTime;
+ CRegId ImplId;
+ // bytes ImplementationUse
+ // UInt32 PredecessorVolumeDescriptorSequenceLocation;
+ // UInt16 Flags;
+
+ void Parse(const Byte *p);
+};
+
+
+// ECMA 3/10.5
+// UDF 2.2.14 PartitionDescriptor
+
+struct CPartition
+{
+ UInt32 Pos;
+ UInt32 Len;
+
+ UInt16 Flags;
+ UInt16 Number;
+ CRegId ContentsId;
+ // Byte ContentsUse[128];
+ UInt32 AccessType;
+
+ CRegId ImplId;
+ // Byte ImplUse[128];
+
+ // int VolIndex;
+ CMap32 Map;
+
+ bool IsMetadata;
+
+ CPartition():
+ // VolIndex(-1),
+ IsMetadata(false) {}
+
+ // bool IsNsr() const { return (strncmp(ContentsId.Id, "+NSR0", 5) == 0); }
+ // bool IsAllocated() const { return ((Flags & 1) != 0); }
+};
+
+
+// ECMA 4/7.1 lb_addr
+
+struct CLogBlockAddr
+{
+ UInt32 Pos;
+ UInt16 PartitionRef;
+
+ void Parse(const Byte *p);
+};
+
+
+enum EShortAllocDescType
+{
+ SHORT_ALLOC_DESC_TYPE_RecordedAndAllocated = 0,
+ SHORT_ALLOC_DESC_TYPE_NotRecordedButAllocated = 1,
+ SHORT_ALLOC_DESC_TYPE_NotRecordedAndNotAllocated = 2,
+ SHORT_ALLOC_DESC_TYPE_NextExtent = 3
+};
+
+
+// ECMA 4/14.14.1 short_ad
+
+struct CShortAllocDesc
+{
+ UInt32 Len;
+ UInt32 Pos;
+
+ // UInt32 GetLen() const { return Len & 0x3FFFFFFF; }
+ // UInt32 GetType() const { return Len >> 30; }
+ // bool IsRecAndAlloc() const { return GetType() == SHORT_ALLOC_DESC_TYPE_RecordedAndAllocated; }
+ void Parse(const Byte *p);
+};
+
+/*
+struct CADImpUse
+{
+ UInt16 Flags;
+ UInt32 UdfUniqueId;
+ void Parse(const Byte *p);
+};
+*/
+
+// ECMA 4/14.14.2 long_ad
+// UDF 2.3.10.1
+
+struct CLongAllocDesc
+{
+ UInt32 Len;
+ CLogBlockAddr Location;
+
+ // Byte ImplUse[6];
+ // CADImpUse adImpUse; // UDF
+
+ UInt32 GetLen() const { return Len & 0x3FFFFFFF; }
+ UInt32 GetType() const { return Len >> 30; }
+ bool IsRecAndAlloc() const { return GetType() == SHORT_ALLOC_DESC_TYPE_RecordedAndAllocated; }
+ void Parse(const Byte *p);
+};
+
+
+// ECMA 3/10.7 Partition maps
+// UDF 2.2.8-2.2.10 Partition Maps
+
+struct CPartitionMap
+{
+ unsigned PartitionIndex;
+
+ Byte Type;
+ // Byte Len;
+
+ // ECMA 10.7.2
+ UInt16 VolumeSequenceNumber;
+ UInt16 PartitionNumber;
+
+ CRegId PartitionTypeId;
+
+ // UDF 2.2.10 Metadata Partition Map
+ UInt32 MetadataFileLocation;
+ // UInt32 MetadataMirrorFileLocation;
+ // UInt32 MetadataBitmapFileLocation;
+ // UInt32 AllocationUnitSize; // (Blocks)
+ // UInt16 AlignmentUnitSize; // (Blocks)
+ // Byte Flags;
+
+ // Byte Data[256];
+ // CPartitionMap(): PartitionIndex(-1) {}
+};
+
+
+// ECMA 4/14.6.6
+
+enum EIcbFileType
+{
+ ICB_FILE_TYPE_DIR = 4,
+ ICB_FILE_TYPE_FILE = 5,
+
+ ICB_FILE_TYPE_METADATA = 250, // 2.2.13.1 Metadata File
+ ICB_FILE_TYPE_METADATA_MIRROR = 251
+};
+
+enum EIcbDescriptorType
+{
+ ICB_DESC_TYPE_SHORT = 0,
+ ICB_DESC_TYPE_LONG = 1,
+ ICB_DESC_TYPE_EXTENDED = 2,
+ ICB_DESC_TYPE_INLINE = 3
+};
+
+// ECMA 4/14.6
+// UDF 3.3.2
+
+struct CIcbTag
+{
+ // UInt32 PriorDirectNum;
+ // UInt16 StrategyType;
+ // UInt16 StrategyParam;
+ // UInt16 MaxNumOfEntries;
+ Byte FileType;
+ // CLogBlockAddr ParentIcb;
+ UInt16 Flags;
+
+ bool IsDir() const { return FileType == ICB_FILE_TYPE_DIR; }
+ int GetDescriptorType() const { return Flags & 3; }
+ void Parse(const Byte *p);
+};
+
+
+// ECMA 4/14.4.3
+// UDF 2.3.4.2 FileCharacteristics
+
+// const Byte FILEID_CHARACS_Existance = (1 << 0);
+const Byte FILEID_CHARACS_Dir = (1 << 1);
+const Byte FILEID_CHARACS_Deleted = (1 << 2);
+const Byte FILEID_CHARACS_Parent = (1 << 3);
+// const Byte FILEID_CHARACS_Metadata = (1 << 4);
+
+struct CFile
+{
+ int ItemIndex;
+ // UInt16 FileVersion;
+ // Byte FileCharacteristics;
+ // CByteBuffer ImplUse;
+ CDString Id;
+
+ CFile(): /* FileVersion(0), FileCharacteristics(0), */ ItemIndex(-1) {}
+ UString GetName() const { return Id.GetString(); }
+};
+
+
+struct CMyExtent
+{
+ UInt32 Pos;
+ UInt32 Len;
+ unsigned PartitionRef; // index in CLogVol::PartitionMaps
+
+ UInt32 GetLen() const { return Len & 0x3FFFFFFF; }
+ UInt32 GetType() const { return Len >> 30; }
+ bool IsRecAndAlloc() const { return GetType() == SHORT_ALLOC_DESC_TYPE_RecordedAndAllocated; }
+};
+
+
+struct CItem
+{
+ CIcbTag IcbTag;
+
+ // UInt32 Uid;
+ // UInt32 Gid;
+ // UInt32 Permissions;
+ UInt16 FileLinkCount;
+ // Byte RecordFormat;
+ // Byte RecordDisplayAttr;
+ // UInt32 RecordLen;
+ UInt64 Size;
+ UInt64 NumLogBlockRecorded;
+ // UInt64 ObjectSize;
+
+ CTime ATime;
+ CTime MTime;
+ CTime AttribTime; // Attribute time : most recent date and time of the day of file creation or modification of the attributes of.
+ CTime CreateTime;
+ // UInt32 CheckPoint;
+ // CLongAllocDesc ExtendedAttrIcb;
+ // CRegId ImplId;
+ // UInt64 UniqueId;
+
+ bool IsExtended;
+ bool IsInline;
+ CByteBuffer InlineData;
+ CRecordVector<CMyExtent> Extents;
+ CUIntVector SubFiles;
+
+ void Parse(const Byte *p);
+
+ bool IsRecAndAlloc() const
+ {
+ FOR_VECTOR (i, Extents)
+ if (!Extents[i].IsRecAndAlloc())
+ return false;
+ return true;
+ }
+
+ UInt64 GetChunksSumSize() const
+ {
+ if (IsInline)
+ return InlineData.Size();
+ UInt64 size = 0;
+ FOR_VECTOR (i, Extents)
+ size += Extents[i].GetLen();
+ return size;
+ }
+
+ bool CheckChunkSizes() const { return GetChunksSumSize() == Size; }
+
+ bool IsDir() const { return IcbTag.IsDir(); }
+};
+
+
+struct CRef
+{
+ unsigned FileIndex;
+ int Parent;
+};
+
+
+// ECMA 4 / 14.1
+struct CFileSet
+{
+ CRecordVector<CRef> Refs;
+
+ CTime RecordingTime;
+ // UInt16 InterchangeLevel;
+ // UInt16 MaxInterchangeLevel;
+ UInt32 FileSetNumber;
+ UInt32 FileSetDescNumber;
+ CDString128 LogicalVolumeId;
+ CDString32 Id;
+ CDString32 CopyrightId;
+ CDString32 AbstractId;
+
+ CLongAllocDesc RootDirICB;
+ CRegId DomainId;
+ // CLongAllocDesc SystemStreamDirICB;
+};
+
+
+/* 8.3 Volume descriptors
+8.4
+A Volume Descriptor Sequence:
+ shall contain one or more Primary Volume Descriptors.
+*/
+
+// ECMA 3/10.6
+// UDF 2.2.4 LogicalVolumeDescriptor
+
+struct CLogVol
+{
+ CObjectVector<CPartitionMap> PartitionMaps;
+ CObjectVector<CFileSet> FileSets;
+
+ UInt32 BlockSize;
+ CDString128 Id;
+ CRegId DomainId;
+
+ // Byte ContentsUse[16];
+ CLongAllocDesc FileSetLocation; // UDF
+
+ CRegId ImplId;
+ // Byte ImplUse[128];
+ // CExtent IntegritySequenceExtent;
+
+ UString GetName() const { return Id.GetString(); }
+};
+
+
+Z7_PURE_INTERFACES_BEGIN
+struct Z7_DECLSPEC_NOVTABLE CProgressVirt
+{
+ virtual HRESULT SetTotal(UInt64 numBytes) =0; \
+ virtual HRESULT SetCompleted(UInt64 numFiles, UInt64 numBytes) =0; \
+ virtual HRESULT SetCompleted() =0; \
+};
+Z7_PURE_INTERFACES_END
+
+class CInArchive
+{
+public:
+ CObjectVector<CLogVol> LogVols;
+ CObjectVector<CItem> Items;
+ CObjectVector<CFile> Files;
+ CObjectVector<CPartition> Partitions;
+
+ unsigned SecLogSize;
+ UInt64 PhySize;
+ UInt64 FileSize;
+
+ bool IsArc;
+ bool Unsupported;
+ bool UnexpectedEnd;
+ bool NoEndAnchor;
+
+ CObjectVector<CPrimeVol> PrimeVols;
+
+ HRESULT Open(IInStream *inStream, CProgressVirt *progress);
+ void Clear();
+
+ UString GetComment() const;
+ UString GetItemPath(unsigned volIndex, unsigned fsIndex, unsigned refIndex,
+ bool showVolName, bool showFsName) const;
+
+ bool CheckItemExtents(unsigned volIndex, const CItem &item) const;
+
+private:
+ IInStream *_stream;
+ CProgressVirt *_progress;
+
+ HRESULT Read(unsigned volIndex, unsigned partitionRef, UInt32 blockPos, UInt32 len, Byte *buf);
+ HRESULT ReadLad(unsigned volIndex, const CLongAllocDesc &lad, Byte *buf);
+ HRESULT ReadFromFile(unsigned volIndex, const CItem &item, CByteBuffer &buf);
+
+ HRESULT ReadFileItem(unsigned volIndex, unsigned fsIndex, const CLongAllocDesc &lad, bool isDir, int numRecurseAllowed);
+ HRESULT ReadItem(unsigned volIndex, int fsIndex, const CLongAllocDesc &lad, bool isDir, int numRecurseAllowed);
+
+ HRESULT Open2();
+ HRESULT FillRefs(CFileSet &fs, unsigned fileIndex, int parent, int numRecurseAllowed);
+
+ UInt64 _processedProgressBytes;
+
+ UInt64 _fileNameLengthTotal;
+ unsigned _numRefs;
+ UInt32 _numExtents;
+ UInt64 _inlineExtentsSize;
+ bool CheckExtent(unsigned volIndex, unsigned partitionRef, UInt32 blockPos, UInt32 len) const;
+
+ void UpdatePhySize(UInt64 val)
+ {
+ if (PhySize < val)
+ PhySize = val;
+ }
+
+ void UpdatePhySize(const CExtent &e)
+ {
+ UpdatePhySize(((UInt64)e.Pos << SecLogSize) + e.Len);
+ }
+};
+
+API_FUNC_IsArc IsArc_Udf(const Byte *p, size_t size);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/UefiHandler.cpp b/CPP/7zip/Archive/UefiHandler.cpp
new file mode 100644
index 0000000..cd6fcbd
--- /dev/null
+++ b/CPP/7zip/Archive/UefiHandler.cpp
@@ -0,0 +1,1893 @@
+// UefiHandler.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/LzmaDec.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/LzhDecoder.h"
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+#define Get24(p) (Get32(p) & 0xFFFFFF)
+
+namespace NArchive {
+namespace NUefi {
+
+static const size_t kBufTotalSizeMax = (1 << 29);
+static const unsigned kNumFilesMax = (1 << 18);
+static const unsigned kLevelMax = 64;
+
+static const Byte k_IntelMeSignature[] =
+{
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0x5A, 0xA5, 0xF0, 0x0F
+};
+
+static bool IsIntelMe(const Byte *p)
+{
+ return memcmp(p, k_IntelMeSignature, sizeof(k_IntelMeSignature)) == 0;
+}
+
+static const unsigned kFvHeaderSize = 0x38;
+
+static const unsigned kGuidSize = 16;
+
+#define CAPSULE_SIGNATURE 0xBD,0x86,0x66,0x3B,0x76,0x0D,0x30,0x40,0xB7,0x0E,0xB5,0x51,0x9E,0x2F,0xC5,0xA0
+#define CAPSULE2_SIGNATURE 0x8B,0xA6,0x3C,0x4A,0x23,0x77,0xFB,0x48,0x80,0x3D,0x57,0x8C,0xC1,0xFE,0xC4,0x4D
+#define CAPSULE_UEFI_SIGNATURE 0xB9,0x82,0x91,0x53,0xB5,0xAB,0x91,0x43,0xB6,0x9A,0xE3,0xA9,0x43,0xF7,0x2F,0xCC
+/*
+ 6dcbd5ed-e82d-4c44-bda1-7194199ad92a : Firmware Management `
+*/
+
+static const Byte k_Guids_Capsules[][kGuidSize] =
+{
+ { CAPSULE_SIGNATURE },
+ { CAPSULE2_SIGNATURE },
+ { CAPSULE_UEFI_SIGNATURE }
+};
+
+
+static const unsigned kFfsGuidOffset = 16;
+
+#define FFS1_SIGNATURE 0xD9,0x54,0x93,0x7A,0x68,0x04,0x4A,0x44,0x81,0xCE,0x0B,0xF6,0x17,0xD8,0x90,0xDF
+#define FFS2_SIGNATURE 0x78,0xE5,0x8C,0x8C,0x3D,0x8A,0x1C,0x4F,0x99,0x35,0x89,0x61,0x85,0xC3,0x2D,0xD3
+#define MACFS_SIGNATURE 0xAD,0xEE,0xAD,0x04,0xFF,0x61,0x31,0x4D,0xB6,0xBA,0x64,0xF8,0xBF,0x90,0x1F,0x5A
+// APPLE_BOOT
+/*
+ "FFS3": "5473c07a-3dcb-4dca-bd6f-1e9689e7349a",
+ "NVRAM_EVSA": "fff12b8d-7696-4c8b-a985-2747075b4f50",
+ "NVRAM_NVAR": "cef5b9a3-476d-497f-9fdc-e98143e0422c",
+ "NVRAM_EVSA2": "00504624-8a59-4eeb-bd0f-6b36e96128e0",
+static const Byte k_NVRAM_NVAR_Guid[kGuidSize] =
+ { 0xA3,0xB9,0xF5,0xCE,0x6D,0x47,0x7F,0x49,0x9F,0xDC,0xE9,0x81,0x43,0xE0,0x42,0x2C };
+*/
+
+static const Byte k_Guids_FS[][kGuidSize] =
+{
+ { FFS1_SIGNATURE },
+ { FFS2_SIGNATURE },
+ { MACFS_SIGNATURE }
+};
+
+
+static const UInt32 kFvSignature = 0x4856465F; // "_FVH"
+
+static const Byte kGuids[][kGuidSize] =
+{
+ { 0xB0,0xCD,0x1B,0xFC,0x31,0x7D,0xAA,0x49,0x93,0x6A,0xA4,0x60,0x0D,0x9D,0xD0,0x83 },
+ { 0x2E,0x06,0xA0,0x1B,0x79,0xC7,0x82,0x45,0x85,0x66,0x33,0x6A,0xE8,0xF7,0x8F,0x09 },
+ { 0x25,0x4E,0x37,0x7E,0x01,0x8E,0xEE,0x4F,0x87,0xf2,0x39,0x0C,0x23,0xC6,0x06,0xCD },
+ { 0x97,0xE5,0x1B,0x16,0xC5,0xE9,0xDB,0x49,0xAE,0x50,0xC4,0x62,0xAB,0x54,0xEE,0xDA },
+ { 0xDB,0x7F,0xAD,0x77,0x2A,0xDF,0x02,0x43,0x88,0x98,0xC7,0x2E,0x4C,0xDB,0xD0,0xF4 },
+ { 0xAB,0x71,0xCF,0xF5,0x4B,0xB0,0x7E,0x4B,0x98,0x8A,0xD8,0xA0,0xD4,0x98,0xE6,0x92 },
+ { 0x91,0x45,0x53,0x7A,0xCE,0x37,0x81,0x48,0xB3,0xC9,0x71,0x38,0x14,0xF4,0x5D,0x6B },
+ { 0x84,0xE6,0x7A,0x36,0x5D,0x33,0x71,0x46,0xA1,0x6D,0x89,0x9D,0xBF,0xEA,0x6B,0x88 },
+ { 0x98,0x07,0x40,0x24,0x07,0x38,0x42,0x4A,0xB4,0x13,0xA1,0xEC,0xEE,0x20,0x5D,0xD8 },
+ { 0xEE,0xA2,0x3F,0x28,0x2C,0x53,0x4D,0x48,0x93,0x83,0x9F,0x93,0xB3,0x6F,0x0B,0x7E },
+ { 0x9B,0xD5,0xB8,0x98,0xBA,0xE8,0xEE,0x48,0x98,0xDD,0xC2,0x95,0x39,0x2F,0x1E,0xDB },
+ { 0x09,0x6D,0xE3,0xC3,0x94,0x82,0x97,0x4B,0xA8,0x57,0xD5,0x28,0x8F,0xE3,0x3E,0x28 },
+ { 0x18,0x88,0x53,0x4A,0xE0,0x5A,0xB2,0x4E,0xB2,0xEB,0x48,0x8B,0x23,0x65,0x70,0x22 }
+};
+
+static const Byte k_Guid_LZMA_COMPRESSED[kGuidSize] =
+ { 0x98,0x58,0x4E,0xEE,0x14,0x39,0x59,0x42,0x9D,0x6E,0xDC,0x7B,0xD7,0x94,0x03,0xCF };
+
+static const char * const kGuidNames[] =
+{
+ "CRC"
+ , "VolumeTopFile"
+ , "ACPI"
+ , "ACPI2"
+ , "Main"
+ , "Intel32"
+ , "Intel64"
+ , "Intel32c"
+ , "Intel64c"
+ , "MacVolume"
+ , "MacUpdate.txt"
+ , "MacName"
+ , "Insyde"
+};
+
+enum
+{
+ kGuidIndex_CRC = 0
+};
+
+struct CSigExtPair
+{
+ const char *ext;
+ unsigned sigSize;
+ Byte sig[16];
+};
+
+static const CSigExtPair g_Sigs[] =
+{
+ { "bmp", 2, { 'B','M' } },
+ { "riff", 4, { 'R','I','F','F' } },
+ { "pe", 2, { 'M','Z'} },
+ { "gif", 6, { 'G','I','F','8','9', 'a' } },
+ { "png", 8, { 0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A } },
+ { "jpg", 10, { 0xFF,0xD8,0xFF,0xE0,0x00,0x10,0x4A,0x46,0x49,0x46 } },
+ { "rom", 2, { 0x55,0xAA } }
+};
+
+enum
+{
+ kSig_BMP,
+ kSig_RIFF,
+ kSig_PE
+};
+
+static const char *FindExt(const Byte *p, size_t size)
+{
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(g_Sigs); i++)
+ {
+ const CSigExtPair &pair = g_Sigs[i];
+ if (size >= pair.sigSize)
+ if (memcmp(p, pair.sig, pair.sigSize) == 0)
+ break;
+ }
+ if (i == Z7_ARRAY_SIZE(g_Sigs))
+ return NULL;
+ switch (i)
+ {
+ case kSig_BMP:
+ if (GetUi32(p + 2) > size || GetUi32(p + 0xA) > size)
+ return NULL;
+ break;
+ case kSig_RIFF:
+ if (GetUi32(p + 8) == 0x45564157 || GetUi32(p + 0xC) == 0x20746D66 )
+ return "wav";
+ break;
+ case kSig_PE:
+ {
+ if (size < 512)
+ return NULL;
+ UInt32 peOffset = GetUi32(p + 0x3C);
+ if (peOffset >= 0x1000 || peOffset + 512 > size || (peOffset & 7) != 0)
+ return NULL;
+ if (GetUi32(p + peOffset) != 0x00004550)
+ return NULL;
+ break;
+ }
+ }
+ return g_Sigs[i].ext;
+}
+
+static bool AreGuidsEq(const Byte *p1, const Byte *p2)
+{
+ return memcmp(p1, p2, kGuidSize) == 0;
+}
+
+static int FindGuid(const Byte *p)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kGuids); i++)
+ if (AreGuidsEq(p, kGuids[i]))
+ return (int)i;
+ return -1;
+}
+
+static bool IsFfs(const Byte *p)
+{
+ if (Get32(p + 0x28) != kFvSignature)
+ return false;
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_Guids_FS); i++)
+ if (AreGuidsEq(p + kFfsGuidOffset, k_Guids_FS[i]))
+ return true;
+ return false;
+}
+
+#define FVB_ERASE_POLARITY (1 << 11)
+
+/*
+static const CUInt32PCharPair g_FV_Attribs[] =
+{
+ { 0, "ReadDisabledCap" },
+ { 1, "ReadEnabledCap" },
+ { 2, "ReadEnabled" },
+ { 3, "WriteDisabledCap" },
+ { 4, "WriteEnabledCap" },
+ { 5, "WriteEnabled" },
+ { 6, "LockCap" },
+ { 7, "Locked" },
+
+ { 9, "StickyWrite" },
+ { 10, "MemoryMapped" },
+ { 11, "ErasePolarity" },
+
+ { 12, "ReadLockCap" },
+ { 13, "WriteLockCap" },
+ { 14, "WriteLockCap" }
+};
+*/
+
+enum
+{
+ FV_FILETYPE_ALL,
+ FV_FILETYPE_RAW,
+ FV_FILETYPE_FREEFORM,
+ FV_FILETYPE_SECURITY_CORE,
+ FV_FILETYPE_PEI_CORE,
+ FV_FILETYPE_DXE_CORE,
+ FV_FILETYPE_PEIM,
+ FV_FILETYPE_DRIVER,
+ FV_FILETYPE_COMBINED_PEIM_DRIVER,
+ FV_FILETYPE_APPLICATION,
+ // The value 0x0A is reserved and should not be used
+ FV_FILETYPE_FIRMWARE_VOLUME_IMAGE = 0x0B,
+ // types 0xF0 - 0xFF are FFS file types
+ FV_FILETYPE_FFS_PAD = 0xF0
+};
+
+static const char * const g_FileTypes[] =
+{
+ "ALL"
+ , "RAW"
+ , "FREEFORM"
+ , "SECURITY_CORE"
+ , "PEI_CORE"
+ , "DXE_CORE"
+ , "PEIM"
+ , "DRIVER"
+ , "COMBINED_PEIM_DRIVER"
+ , "APPLICATION"
+ , "0xA"
+ , "VOLUME"
+};
+
+// typedef Byte FFS_FILE_ATTRIBUTES;
+// FFS File Attributes
+#define FFS_ATTRIB_TAIL_PRESENT 0x01
+// #define FFS_ATTRIB_RECOVERY 0x02
+// #define FFS_ATTRIB_HEADER_EXTENSION 0x04
+// #define FFS_ATTRIB_DATA_ALIGNMENT 0x38
+#define FFS_ATTRIB_CHECKSUM 0x40
+
+static const CUInt32PCharPair g_FFS_FILE_ATTRIBUTES[] =
+{
+ { 0, "" /* "TAIL" */ },
+ { 1, "RECOVERY" },
+ // { 2, "HEADER_EXTENSION" }, // reserved for future
+ { 6, "" /* "CHECKSUM" */ }
+};
+
+// static const Byte g_Allignment[8] = { 3, 4, 7, 9, 10, 12, 15, 16 };
+
+// typedef Byte FFS_FILE_STATE;
+
+// Look also FVB_ERASE_POLARITY.
+// Lower-order State bits are superceded by higher-order State bits.
+
+// #define FILE_HEADER_CONSTRUCTION 0x01
+// #define FILE_HEADER_VALID 0x02
+#define FILE_DATA_VALID 0x04
+// #define FILE_MARKED_FOR_UPDATE 0x08
+// #define FILE_DELETED 0x10
+// #define FILE_HEADER_INVALID 0x20
+
+// SECTION_TYPE
+
+// #define SECTION_ALL 0x00
+
+#define SECTION_COMPRESSION 0x01
+#define SECTION_GUID_DEFINED 0x02
+
+// Leaf section Type values
+// #define SECTION_PE32 0x10
+// #define SECTION_PIC 0x11
+// #define SECTION_TE 0x12
+#define SECTION_DXE_DEPEX 0x13
+#define SECTION_VERSION 0x14
+#define SECTION_USER_INTERFACE 0x15
+// #define SECTION_COMPATIBILITY16 0x16
+#define SECTION_FIRMWARE_VOLUME_IMAGE 0x17
+#define SECTION_FREEFORM_SUBTYPE_GUID 0x18
+#define SECTION_RAW 0x19
+#define SECTION_PEI_DEPEX 0x1B
+
+
+// #define GUIDED_SECTION_PROCESSING_REQUIRED 0x01
+// #define GUIDED_SECTION_AUTH_STATUS_VALID 0x02
+
+static const CUInt32PCharPair g_GUIDED_SECTION_ATTRIBUTES[] =
+{
+ { 0, "PROCESSING_REQUIRED" },
+ { 1, "AUTH" }
+};
+
+static const CUInt32PCharPair g_SECTION_TYPE[] =
+{
+ { 0x01, "COMPRESSION" },
+ { 0x02, "GUID" },
+ { 0x10, "efi" },
+ { 0x11, "PIC" },
+ { 0x12, "te" },
+ { 0x13, "DXE_DEPEX" },
+ { 0x14, "VERSION" },
+ { 0x15, "USER_INTERFACE" },
+ { 0x16, "COMPATIBILITY16" },
+ { 0x17, "VOLUME" },
+ { 0x18, "FREEFORM_SUBTYPE_GUID" },
+ { 0x19, "raw" },
+ { 0x1B, "PEI_DEPEX" }
+};
+
+#define COMPRESSION_TYPE_NONE 0
+#define COMPRESSION_TYPE_LZH 1
+#define COMPRESSION_TYPE_LZMA 2
+
+static const char * const g_Methods[] =
+{
+ "COPY"
+ , "LZH"
+ , "LZMA"
+};
+
+
+static void AddGuid(AString &dest, const Byte *p, bool full)
+{
+ char s[64];
+ ::RawLeGuidToString(p, s);
+ // MyStringUpper_Ascii(s);
+ if (!full)
+ s[8] = 0;
+ dest += s;
+}
+
+static const char * const kExpressionCommands[] =
+{
+ "BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"
+};
+
+static bool ParseDepedencyExpression(const Byte *p, UInt32 size, AString &res)
+{
+ res.Empty();
+ for (UInt32 i = 0; i < size;)
+ {
+ unsigned command = p[i++];
+ if (command > Z7_ARRAY_SIZE(kExpressionCommands))
+ return false;
+ res += kExpressionCommands[command];
+ if (command < 3)
+ {
+ if (i + kGuidSize > size)
+ return false;
+ res.Add_Space();
+ AddGuid(res, p + i, false);
+ i += kGuidSize;
+ }
+ res += "; ";
+ }
+ return true;
+}
+
+static bool ParseUtf16zString(const Byte *p, UInt32 size, UString &res)
+{
+ if ((size & 1) != 0)
+ return false;
+ res.Empty();
+ UInt32 i;
+ for (i = 0; i < size; i += 2)
+ {
+ wchar_t c = Get16(p + i);
+ if (c == 0)
+ break;
+ res += c;
+ }
+ return (i == size - 2);
+}
+
+static bool ParseUtf16zString2(const Byte *p, UInt32 size, AString &res)
+{
+ UString s;
+ if (!ParseUtf16zString(p, size, s))
+ return false;
+ res = UnicodeStringToMultiByte(s);
+ return true;
+}
+
+#define FLAGS_TO_STRING(pairs, value) FlagsToString(pairs, Z7_ARRAY_SIZE(pairs), value)
+#define TYPE_TO_STRING(table, value) TypeToString(table, Z7_ARRAY_SIZE(table), value)
+#define TYPE_PAIR_TO_STRING(table, value) TypePairToString(table, Z7_ARRAY_SIZE(table), value)
+
+static const UInt32 kFileHeaderSize = 24;
+
+static void AddSpaceAndString(AString &res, const AString &newString)
+{
+ if (!newString.IsEmpty())
+ {
+ res.Add_Space_if_NotEmpty();
+ res += newString;
+ }
+}
+
+class CFfsFileHeader
+{
+PRF(public:)
+ Byte CheckHeader;
+ Byte CheckFile;
+ Byte Attrib;
+ Byte State;
+
+ UInt16 GetTailReference() const { return (UInt16)(CheckHeader | ((UInt16)CheckFile << 8)); }
+ UInt32 GetTailSize() const { return IsThereTail() ? 2 : 0; }
+ bool IsThereFileChecksum() const { return (Attrib & FFS_ATTRIB_CHECKSUM) != 0; }
+ bool IsThereTail() const { return (Attrib & FFS_ATTRIB_TAIL_PRESENT) != 0; }
+public:
+ Byte GuidName[kGuidSize];
+ Byte Type;
+ UInt32 Size;
+
+ bool Parse(const Byte *p)
+ {
+ unsigned i;
+ for (i = 0; i < kFileHeaderSize; i++)
+ if (p[i] != 0xFF)
+ break;
+ if (i == kFileHeaderSize)
+ return false;
+ memcpy(GuidName, p, kGuidSize);
+ CheckHeader = p[0x10];
+ CheckFile = p[0x11];
+ Type = p[0x12];
+ Attrib = p[0x13];
+ Size = Get24(p + 0x14);
+ State = p[0x17];
+ return true;
+ }
+
+ UInt32 GetDataSize() const { return Size - kFileHeaderSize - GetTailSize(); }
+ UInt32 GetDataSize2(UInt32 rem) const { return rem - kFileHeaderSize - GetTailSize(); }
+
+ bool Check(const Byte *p, UInt32 size)
+ {
+ if (Size > size)
+ return false;
+ UInt32 tailSize = GetTailSize();
+ if (Size < kFileHeaderSize + tailSize)
+ return false;
+
+ {
+ unsigned checkSum = 0;
+ for (UInt32 i = 0; i < kFileHeaderSize; i++)
+ checkSum += p[i];
+ checkSum -= p[0x17];
+ checkSum -= p[0x11];
+ if ((Byte)checkSum != 0)
+ return false;
+ }
+
+ if (IsThereFileChecksum())
+ {
+ unsigned checkSum = 0;
+ UInt32 checkSize = Size - tailSize;
+ for (UInt32 i = 0; i < checkSize; i++)
+ checkSum += p[i];
+ checkSum -= p[0x17];
+ if ((Byte)checkSum != 0)
+ return false;
+ }
+
+ if (IsThereTail())
+ if (GetTailReference() != (UInt16)~Get16(p + Size - 2))
+ return false;
+
+ int polarity = 0;
+ int i;
+ for (i = 5; i >= 0; i--)
+ if (((State >> i) & 1) == polarity)
+ {
+ // AddSpaceAndString(s, g_FFS_FILE_STATE_Flags[i]);
+ if ((1 << i) != FILE_DATA_VALID)
+ return false;
+ break;
+ }
+ if (i < 0)
+ return false;
+
+ return true;
+ }
+
+ AString GetCharacts() const
+ {
+ AString s;
+ if (Type == FV_FILETYPE_FFS_PAD)
+ s += "PAD";
+ else
+ s += TYPE_TO_STRING(g_FileTypes, Type);
+ AddSpaceAndString(s, FLAGS_TO_STRING(g_FFS_FILE_ATTRIBUTES, Attrib & 0xC7));
+ /*
+ int align = (Attrib >> 3) & 7;
+ if (align != 0)
+ {
+ s += " Align:";
+ s.Add_UInt32((UInt32)1 << g_Allignment[align]);
+ }
+ */
+ return s;
+ }
+};
+
+#define G32(_offs_, dest) dest = Get32(p + (_offs_))
+#define G16(_offs_, dest) dest = Get16(p + (_offs_))
+
+struct CCapsuleHeader
+{
+ UInt32 HeaderSize;
+ UInt32 Flags;
+ UInt32 CapsuleImageSize;
+ UInt32 SequenceNumber;
+ // Guid InstanceId;
+ UInt32 OffsetToSplitInformation;
+ UInt32 OffsetToCapsuleBody;
+ UInt32 OffsetToOemDefinedHeader;
+ UInt32 OffsetToAuthorInformation;
+ UInt32 OffsetToRevisionInformation;
+ UInt32 OffsetToShortDescription;
+ UInt32 OffsetToLongDescription;
+ UInt32 OffsetToApplicableDevices;
+
+ void Clear() { memset(this, 0, sizeof(*this)); }
+
+ bool Parse(const Byte *p)
+ {
+ Clear();
+ G32(0x10, HeaderSize);
+ G32(0x14, Flags);
+ G32(0x18, CapsuleImageSize);
+ if (HeaderSize < 0x1C)
+ return false;
+ if (AreGuidsEq(p, k_Guids_Capsules[0]))
+ {
+ const unsigned kHeaderSize = 80;
+ if (HeaderSize != kHeaderSize)
+ return false;
+ G32(0x1C, SequenceNumber);
+ G32(0x30, OffsetToSplitInformation);
+ G32(0x34, OffsetToCapsuleBody);
+ G32(0x38, OffsetToOemDefinedHeader);
+ G32(0x3C, OffsetToAuthorInformation);
+ G32(0x40, OffsetToRevisionInformation);
+ G32(0x44, OffsetToShortDescription);
+ G32(0x48, OffsetToLongDescription);
+ G32(0x4C, OffsetToApplicableDevices);
+ return true;
+ }
+ else if (AreGuidsEq(p, k_Guids_Capsules[1]))
+ {
+ // capsule v2
+ G16(0x1C, OffsetToCapsuleBody);
+ G16(0x1E, OffsetToOemDefinedHeader);
+ return true;
+ }
+ else if (AreGuidsEq(p, k_Guids_Capsules[2]))
+ {
+ OffsetToCapsuleBody = HeaderSize;
+ return true;
+ }
+ else
+ {
+ // here we must check for another capsule types
+ return false;
+ }
+ }
+};
+
+
+struct CItem
+{
+ AString Name;
+ AString Characts;
+ int Parent;
+ int Method;
+ int NameIndex;
+ unsigned NumChilds;
+ bool IsDir;
+ bool Skip;
+ bool ThereAreSubDirs;
+ bool ThereIsUniqueName;
+ bool KeepName;
+
+ unsigned BufIndex;
+ UInt32 Offset;
+ UInt32 Size;
+
+ CItem(): Parent(-1), Method(-1), NameIndex(-1), NumChilds(0),
+ IsDir(false), Skip(false), ThereAreSubDirs(false), ThereIsUniqueName(false), KeepName(true) {}
+ void SetGuid(const Byte *guidName, bool full = false);
+ AString GetName(int numChildsInParent) const;
+};
+
+void CItem::SetGuid(const Byte *guidName, bool full)
+{
+ ThereIsUniqueName = true;
+ int index = FindGuid(guidName);
+ if (index >= 0)
+ Name = kGuidNames[(unsigned)index];
+ else
+ {
+ Name.Empty();
+ AddGuid(Name, guidName, full);
+ }
+}
+
+AString CItem::GetName(int numChildsInParent) const
+{
+ if (numChildsInParent <= 1 || NameIndex < 0)
+ return Name;
+ char sz[32];
+ char sz2[32];
+ ConvertUInt32ToString((unsigned)NameIndex, sz);
+ ConvertUInt32ToString((unsigned)numChildsInParent - 1, sz2);
+ const int numZeros = (int)strlen(sz2) - (int)strlen(sz);
+ AString res;
+ for (int i = 0; i < numZeros; i++)
+ res += '0';
+ res += sz;
+ res.Add_Dot();
+ res += Name;
+ return res;
+}
+
+struct CItem2
+{
+ AString Name;
+ AString Characts;
+ unsigned MainIndex;
+ int Parent;
+
+ CItem2(): Parent(-1) {}
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ CObjectVector<CItem> _items;
+ CObjectVector<CItem2> _items2;
+ CObjectVector<CByteBuffer> _bufs;
+ UString _comment;
+ UInt32 _methodsMask;
+ bool _capsuleMode;
+ bool _headersError;
+
+ size_t _totalBufsSize;
+ CCapsuleHeader _h;
+ UInt64 _phySize;
+
+ void AddCommentString(const char *name, UInt32 pos);
+ unsigned AddItem(const CItem &item);
+ unsigned AddFileItemWithIndex(CItem &item);
+ unsigned AddDirItem(CItem &item);
+ unsigned AddBuf(size_t size);
+
+ HRESULT DecodeLzma(const Byte *data, size_t inputSize);
+
+ HRESULT ParseSections(unsigned bufIndex, UInt32 pos,
+ UInt32 size,
+ int parent, int method, unsigned level,
+ bool &error);
+
+ HRESULT ParseIntelMe(unsigned bufIndex, UInt32 posBase,
+ UInt32 exactSize, UInt32 limitSize,
+ int parent, int method, unsigned level);
+
+ HRESULT ParseVolume(unsigned bufIndex, UInt32 posBase,
+ UInt32 exactSize, UInt32 limitSize,
+ int parent, int method, unsigned level);
+
+ HRESULT OpenCapsule(IInStream *stream);
+ HRESULT OpenFv(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback);
+ HRESULT Open2(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback);
+public:
+ CHandler(bool capsuleMode): _capsuleMode(capsuleMode) {}
+};
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ // kpidOffset,
+ kpidMethod,
+ kpidCharacts
+};
+
+static const Byte kArcProps[] =
+{
+ kpidComment,
+ kpidMethod,
+ kpidCharacts
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CItem2 &item2 = _items2[index];
+ const CItem &item = _items[item2.MainIndex];
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ AString path (item2.Name);
+ int cur = item2.Parent;
+ while (cur >= 0)
+ {
+ const CItem2 &item3 = _items2[cur];
+ path.InsertAtFront(CHAR_PATH_SEPARATOR);
+ path.Insert(0, item3.Name);
+ cur = item3.Parent;
+ }
+ prop = path;
+ break;
+ }
+ case kpidIsDir: prop = item.IsDir; break;
+ case kpidMethod: if (item.Method >= 0) prop = g_Methods[(unsigned)item.Method]; break;
+ case kpidCharacts: if (!item2.Characts.IsEmpty()) prop = item2.Characts; break;
+ case kpidSize: if (!item.IsDir) prop = (UInt64)item.Size; break;
+ // case kpidOffset: if (!item.IsDir) prop = item.Offset; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+void CHandler::AddCommentString(const char *name, UInt32 pos)
+{
+ UString s;
+ if (pos < _h.HeaderSize)
+ return;
+ if (pos >= _h.OffsetToCapsuleBody)
+ return;
+ UInt32 limit = (_h.OffsetToCapsuleBody - pos) & ~(UInt32)1;
+ const Byte *buf = _bufs[0] + pos;
+ for (UInt32 i = 0;;)
+ {
+ if (s.Len() > (1 << 16) || i >= limit)
+ return;
+ wchar_t c = Get16(buf + i);
+ i += 2;
+ if (c == 0)
+ {
+ if (i >= limit)
+ return;
+ c = Get16(buf + i);
+ i += 2;
+ if (c == 0)
+ break;
+ s.Add_LF();
+ }
+ s += c;
+ }
+ if (s.IsEmpty())
+ return;
+ _comment.Add_LF();
+ _comment += name;
+ _comment += ": ";
+ _comment += s;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMethod:
+ {
+ AString s;
+ for (unsigned i = 0; i < 32; i++)
+ if ((_methodsMask & ((UInt32)1 << i)) != 0)
+ AddSpaceAndString(s, (AString)g_Methods[i]);
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+ case kpidComment: if (!_comment.IsEmpty()) prop = _comment; break;
+ case kpidPhySize: prop = (UInt64)_phySize; break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_headersError) v |= kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+#ifdef SHOW_DEBUG_INFO
+static void PrintLevel(unsigned level)
+{
+ PRF(printf("\n"));
+ for (unsigned i = 0; i < level; i++)
+ PRF(printf(" "));
+}
+static void MyPrint(UInt32 posBase, UInt32 size, unsigned level, const char *name)
+{
+ PrintLevel(level);
+ PRF(printf("%s, pos = %6x, size = %6x", name, posBase, size));
+}
+#else
+#define PrintLevel(level)
+#define MyPrint(posBase, size, level, name)
+#endif
+
+
+
+unsigned CHandler::AddItem(const CItem &item)
+{
+ if (_items.Size() >= kNumFilesMax)
+ throw 2;
+ return _items.Add(item);
+}
+
+unsigned CHandler::AddFileItemWithIndex(CItem &item)
+{
+ unsigned nameIndex = _items.Size();
+ if (item.Parent >= 0)
+ nameIndex = _items[item.Parent].NumChilds++;
+ item.NameIndex = (int)nameIndex;
+ return AddItem(item);
+}
+
+unsigned CHandler::AddDirItem(CItem &item)
+{
+ if (item.Parent >= 0)
+ _items[item.Parent].ThereAreSubDirs = true;
+ item.IsDir = true;
+ item.Size = 0;
+ return AddItem(item);
+}
+
+unsigned CHandler::AddBuf(size_t size)
+{
+ if (size > kBufTotalSizeMax - _totalBufsSize)
+ throw 1;
+ _totalBufsSize += size;
+ unsigned index = _bufs.Size();
+ _bufs.AddNew().Alloc(size);
+ return index;
+}
+
+
+HRESULT CHandler::DecodeLzma(const Byte *data, size_t inputSize)
+{
+ if (inputSize < 5 + 8)
+ return S_FALSE;
+ const UInt64 unpackSize = Get64(data + 5);
+ if (unpackSize > ((UInt32)1 << 30))
+ return S_FALSE;
+ SizeT destLen = (SizeT)unpackSize;
+ const unsigned newBufIndex = AddBuf((size_t)unpackSize);
+ CByteBuffer &buf = _bufs[newBufIndex];
+ ELzmaStatus status;
+ SizeT srcLen = inputSize - (5 + 8);
+ const SizeT srcLen2 = srcLen;
+ SRes res = LzmaDecode(buf, &destLen, data + 13, &srcLen,
+ data, 5, LZMA_FINISH_END, &status, &g_Alloc);
+ if (res != 0)
+ return S_FALSE;
+ if (srcLen != srcLen2 || destLen != unpackSize || (
+ status != LZMA_STATUS_FINISHED_WITH_MARK &&
+ status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK))
+ return S_FALSE;
+ return S_OK;
+}
+
+
+HRESULT CHandler::ParseSections(unsigned bufIndex, UInt32 posBase, UInt32 size, int parent, int method, unsigned level, bool &error)
+{
+ error = false;
+
+ if (level > kLevelMax)
+ return S_FALSE;
+ MyPrint(posBase, size, level, "Sections");
+ level++;
+ const Byte *bufData = _bufs[bufIndex];
+ UInt32 pos = 0;
+ for (;;)
+ {
+ if (size == pos)
+ return S_OK;
+ PrintLevel(level);
+ PRF(printf("%s, abs = %6x, relat = %6x", "Sect", posBase + pos, pos));
+ pos = (pos + 3) & ~(UInt32)3;
+ if (pos > size)
+ return S_FALSE;
+ UInt32 rem = size - pos;
+ if (rem == 0)
+ return S_OK;
+ if (rem < 4)
+ return S_FALSE;
+
+ const Byte *p = bufData + posBase + pos;
+
+ const UInt32 sectSize = Get24(p);
+ const Byte type = p[3];
+
+ // PrintLevel(level);
+ PRF(printf(" type = %2x, sectSize = %6x", type, sectSize));
+
+ if (sectSize > rem || sectSize < 4)
+ {
+ _headersError = true;
+ error = true;
+ return S_OK;
+ // return S_FALSE;
+ }
+
+ CItem item;
+ item.Method = method;
+ item.BufIndex = bufIndex;
+ item.Parent = parent;
+ item.Offset = posBase + pos + 4;
+ UInt32 sectDataSize = sectSize - 4;
+ item.Size = sectDataSize;
+ item.Name = TYPE_PAIR_TO_STRING(g_SECTION_TYPE, type);
+
+ if (type == SECTION_COMPRESSION)
+ {
+ if (sectSize < 4 + 5)
+ return S_FALSE;
+ UInt32 uncompressedSize = Get32(p + 4);
+ Byte compressionType = p[8];
+
+ UInt32 newSectSize = sectSize - 9;
+ UInt32 newOffset = posBase + pos + 9;
+ const Byte *pStart = p + 9;
+
+ item.KeepName = false;
+ if (compressionType > 2)
+ {
+ // AddFileItemWithIndex(item);
+ return S_FALSE;
+ }
+ else
+ {
+ item.Name = g_Methods[compressionType];
+ // int parent = AddDirItem(item);
+ if (compressionType == COMPRESSION_TYPE_NONE)
+ {
+ bool error2;
+ RINOK(ParseSections(bufIndex, newOffset, newSectSize, parent, method, level, error2))
+ }
+ else if (compressionType == COMPRESSION_TYPE_LZH)
+ {
+ unsigned newBufIndex = AddBuf(uncompressedSize);
+ CByteBuffer &buf = _bufs[newBufIndex];
+
+ NCompress::NLzh::NDecoder::CCoder *lzhDecoderSpec = NULL;
+ CMyComPtr<ICompressCoder> lzhDecoder;
+
+ lzhDecoderSpec = new NCompress::NLzh::NDecoder::CCoder;
+ lzhDecoder = lzhDecoderSpec;
+
+ {
+ const Byte *src = pStart;
+ if (newSectSize < 8)
+ return S_FALSE;
+ UInt32 packSize = Get32(src);
+ UInt32 unpackSize = Get32(src + 4);
+
+ PRF(printf(" LZH packSize = %6x, unpackSize = %6x", packSize, unpackSize));
+
+ if (uncompressedSize != unpackSize || newSectSize - 8 != packSize)
+ return S_FALSE;
+ if (packSize < 1)
+ return S_FALSE;
+ packSize--;
+ src += 8;
+ if (src[packSize] != 0)
+ return S_FALSE;
+
+ CBufInStream *inStreamSpec = new CBufInStream;
+ CMyComPtr<IInStream> inStream = inStreamSpec;
+
+ CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
+ CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+
+ UInt64 uncompressedSize64 = uncompressedSize;
+ lzhDecoderSpec->FinishMode = true;
+ /*
+ EFI 1.1 probably used LZH with small dictionary and (pbit = 4). It was named "Efi compression".
+ New version of compression code (named Tiano) uses LZH with (1 << 19) dictionary.
+ But maybe LZH decoder in UEFI decoder supports larger than (1 << 19) dictionary.
+ We check both LZH versions: Tiano and then Efi.
+ */
+ HRESULT res = S_FALSE;
+
+ for (unsigned m = 0 ; m < 2; m++)
+ {
+ inStreamSpec->Init(src, packSize);
+ outStreamSpec->Init(buf, uncompressedSize);
+ lzhDecoderSpec->SetDictSize((m == 0) ? ((UInt32)1 << 19) : ((UInt32)1 << 14));
+ res = lzhDecoder->Code(inStream, outStream, NULL, &uncompressedSize64, NULL);
+ if (res == S_OK)
+ break;
+ }
+ RINOK(res)
+ }
+
+ bool error2;
+ RINOK(ParseSections(newBufIndex, 0, uncompressedSize, parent, compressionType, level, error2))
+ }
+ else
+ {
+ if (newSectSize < 4 + 5 + 8)
+ return S_FALSE;
+ unsigned addSize = 4;
+ if (pStart[0] == 0x5d && pStart[1] == 0 && pStart[2] == 0 && pStart[3] == 0x80 && pStart[4] == 0)
+ {
+ addSize = 0;
+ // some archives have such header
+ }
+ else
+ {
+ // normal BIOS contains uncompressed size here
+ // UInt32 uncompressedSize2 = Get24(pStart);
+ // Byte firstSectType = p[9 + 3];
+ // firstSectType can be 0 in some archives
+ }
+ pStart += addSize;
+
+ RINOK(DecodeLzma(pStart, newSectSize - addSize))
+ const size_t lzmaUncompressedSize = _bufs.Back().Size();
+ // if (lzmaUncompressedSize != uncompressedSize)
+ if (lzmaUncompressedSize < uncompressedSize)
+ return S_FALSE;
+ bool error2;
+ RINOK(ParseSections(_bufs.Size() - 1, 0, (UInt32)lzmaUncompressedSize, parent, compressionType, level, error2))
+ }
+ _methodsMask |= (1 << compressionType);
+ }
+ }
+ else if (type == SECTION_GUID_DEFINED)
+ {
+ const unsigned kHeaderSize = 4 + kGuidSize + 4;
+ if (sectSize < kHeaderSize)
+ return S_FALSE;
+ item.SetGuid(p + 4);
+ const UInt32 dataOffset = Get16(p + 4 + kGuidSize);
+ const UInt32 attrib = Get16(p + 4 + kGuidSize + 2);
+ if (dataOffset > sectSize || dataOffset < kHeaderSize)
+ return S_FALSE;
+ UInt32 newSectSize = sectSize - dataOffset;
+ item.Size = newSectSize;
+ UInt32 newOffset = posBase + pos + dataOffset;
+ item.Offset = newOffset;
+ const UInt32 propsSize = dataOffset - kHeaderSize;
+ AddSpaceAndString(item.Characts, FLAGS_TO_STRING(g_GUIDED_SECTION_ATTRIBUTES, attrib));
+
+ bool needDir = true;
+ unsigned newBufIndex = bufIndex;
+ int newMethod = method;
+
+ if (AreGuidsEq(p + 0x4, k_Guid_LZMA_COMPRESSED))
+ {
+ // item.Name = "guid.lzma";
+ // AddItem(item);
+ const Byte *pStart = bufData + newOffset;
+ // do we need correct pStart here for lzma steram offset?
+ RINOK(DecodeLzma(pStart, newSectSize))
+ _methodsMask |= (1 << COMPRESSION_TYPE_LZMA);
+ newBufIndex = _bufs.Size() - 1;
+ newOffset = 0;
+ newSectSize = (UInt32)_bufs.Back().Size();
+ newMethod = COMPRESSION_TYPE_LZMA;
+ }
+ else if (AreGuidsEq(p + 0x4, kGuids[kGuidIndex_CRC]) && propsSize == 4)
+ {
+ needDir = false;
+ item.KeepName = false;
+ if (CrcCalc(bufData + newOffset, newSectSize) != Get32(p + kHeaderSize))
+ return S_FALSE;
+ }
+ else
+ {
+ if (propsSize != 0)
+ {
+ CItem item2 = item;
+ item2.Name += ".prop";
+ item2.Size = propsSize;
+ item2.Offset = posBase + pos + kHeaderSize;
+ AddItem(item2);
+ }
+ }
+
+ int newParent = parent;
+ if (needDir)
+ newParent = (int)AddDirItem(item);
+ bool error2;
+ RINOK(ParseSections(newBufIndex, newOffset, newSectSize, newParent, newMethod, level, error2))
+ }
+ else if (type == SECTION_FIRMWARE_VOLUME_IMAGE)
+ {
+ item.KeepName = false;
+ const int newParent = (int)AddDirItem(item);
+ RINOK(ParseVolume(bufIndex, posBase + pos + 4,
+ sectSize - 4,
+ sectSize - 4,
+ newParent, method, level))
+ }
+ else
+ {
+ bool needAdd = true;
+ switch (type)
+ {
+ case SECTION_RAW:
+ {
+ const UInt32 kInsydeOffset = 12;
+ if (sectDataSize >= kFvHeaderSize + kInsydeOffset)
+ {
+ if (IsFfs(p + 4 + kInsydeOffset) &&
+ sectDataSize - kInsydeOffset == Get64(p + 4 + kInsydeOffset + 0x20))
+ {
+ needAdd = false;
+ item.Name = "vol";
+ const unsigned newParent = AddDirItem(item);
+ RINOK(ParseVolume(bufIndex, posBase + pos + 4 + kInsydeOffset,
+ sectDataSize - kInsydeOffset,
+ sectDataSize - kInsydeOffset,
+ (int)newParent, method, level))
+ }
+
+ if (needAdd)
+ {
+ const char *ext = FindExt(p + 4, sectDataSize);
+ if (ext)
+ item.Name = ext;
+ }
+ }
+ break;
+ }
+ case SECTION_DXE_DEPEX:
+ case SECTION_PEI_DEPEX:
+ {
+ AString s;
+ if (ParseDepedencyExpression(p + 4, sectDataSize, s))
+ {
+ if (s.Len() < (1 << 9))
+ {
+ s.InsertAtFront('[');
+ s += ']';
+ AddSpaceAndString(_items[item.Parent].Characts, s);
+ needAdd = false;
+ }
+ else
+ {
+ item.BufIndex = AddBuf(s.Len());
+ CByteBuffer &buf0 = _bufs[item.BufIndex];
+ if (s.Len() != 0)
+ memcpy(buf0, s, s.Len());
+ item.Offset = 0;
+ item.Size = s.Len();
+ }
+ }
+ break;
+ }
+ case SECTION_VERSION:
+ {
+ if (sectDataSize > 2)
+ {
+ AString s;
+ if (ParseUtf16zString2(p + 6, sectDataSize - 2, s))
+ {
+ AString s2 ("ver:");
+ s2.Add_UInt32(Get16(p + 4));
+ s2.Add_Space();
+ s2 += s;
+ AddSpaceAndString(_items[item.Parent].Characts, s2);
+ needAdd = false;
+ }
+ }
+ break;
+ }
+ case SECTION_USER_INTERFACE:
+ {
+ AString s;
+ if (ParseUtf16zString2(p + 4, sectDataSize, s))
+ {
+ _items[parent].Name = s;
+ needAdd = false;
+ }
+ break;
+ }
+ case SECTION_FREEFORM_SUBTYPE_GUID:
+ {
+ if (sectDataSize >= kGuidSize)
+ {
+ item.SetGuid(p + 4);
+ item.Size = sectDataSize - kGuidSize;
+ item.Offset = posBase + pos + 4 + kGuidSize;
+ }
+ break;
+ }
+ }
+
+ if (needAdd)
+ AddFileItemWithIndex(item);
+ }
+
+ pos += sectSize;
+ }
+}
+
+static UInt32 Count_FF_Bytes(const Byte *p, UInt32 size)
+{
+ UInt32 i;
+ for (i = 0; i < size && p[i] == 0xFF; i++);
+ return i;
+}
+
+static bool Is_FF_Stream(const Byte *p, UInt32 size)
+{
+ return (Count_FF_Bytes(p, size) == size);
+}
+
+struct CVolFfsHeader
+{
+ UInt32 HeaderLen;
+ UInt64 VolSize;
+
+ bool Parse(const Byte *p);
+};
+
+bool CVolFfsHeader::Parse(const Byte *p)
+{
+ if (Get32(p + 0x28) != kFvSignature)
+ return false;
+
+ UInt32 attribs = Get32(p + 0x2C);
+ if ((attribs & FVB_ERASE_POLARITY) == 0)
+ return false;
+ VolSize = Get64(p + 0x20);
+ HeaderLen = Get16(p + 0x30);
+ if (HeaderLen < kFvHeaderSize || (HeaderLen & 0x7) != 0 || VolSize < HeaderLen)
+ return false;
+ return true;
+}
+
+
+HRESULT CHandler::ParseVolume(
+ unsigned bufIndex, UInt32 posBase,
+ UInt32 exactSize, UInt32 limitSize,
+ int parent, int method, unsigned level)
+{
+ if (level > kLevelMax)
+ return S_FALSE;
+ MyPrint(posBase, exactSize, level, "Volume");
+ level++;
+ if (exactSize < kFvHeaderSize)
+ return S_FALSE;
+ const Byte *p = _bufs[bufIndex] + posBase;
+ // first 16 bytes must be zeros, but they are not zeros sometimes.
+ if (!IsFfs(p))
+ {
+ CItem item;
+ item.Method = method;
+ item.BufIndex = bufIndex;
+ item.Parent = parent;
+ item.Offset = posBase;
+ item.Size = exactSize;
+ if (!Is_FF_Stream(p + kFfsGuidOffset, 16))
+ item.SetGuid(p + kFfsGuidOffset);
+ // if (item.Name.IsEmpty())
+ item.Name += "[VOL]";
+ AddItem(item);
+ return S_OK;
+ }
+
+ CVolFfsHeader ffsHeader;
+ if (!ffsHeader.Parse(p))
+ return S_FALSE;
+ // if (parent >= 0) AddSpaceAndString(_items[parent].Characts, FLAGS_TO_STRING(g_FV_Attribs, attribs));
+
+ // VolSize > exactSize (fh.Size) for some UEFI archives (is it correct UEFI?)
+ // so we check VolSize for limitSize instead.
+
+ if (ffsHeader.HeaderLen > limitSize || ffsHeader.VolSize > limitSize)
+ return S_FALSE;
+
+ {
+ UInt32 checkCalc = 0;
+ for (UInt32 i = 0; i < ffsHeader.HeaderLen; i += 2)
+ checkCalc += Get16(p + i);
+ if ((checkCalc & 0xFFFF) != 0)
+ return S_FALSE;
+ }
+
+ // 3 reserved bytes are not zeros sometimes.
+ // UInt16 ExtHeaderOffset; // in new SPECIFICATION?
+ // Byte revision = p[0x37];
+
+ UInt32 pos = kFvHeaderSize;
+ for (;;)
+ {
+ if (pos >= ffsHeader.HeaderLen)
+ return S_FALSE;
+ UInt32 numBlocks = Get32(p + pos);
+ UInt32 length = Get32(p + pos + 4);
+ pos += 8;
+ if (numBlocks == 0 && length == 0)
+ break;
+ }
+ if (pos != ffsHeader.HeaderLen)
+ return S_FALSE;
+
+ CRecordVector<UInt32> guidsVector;
+
+ for (;;)
+ {
+ UInt32 rem = (UInt32)ffsHeader.VolSize - pos;
+ if (rem < kFileHeaderSize)
+ break;
+ pos = (pos + 7) & ~7u;
+ rem = (UInt32)ffsHeader.VolSize - pos;
+ if (rem < kFileHeaderSize)
+ break;
+
+ CItem item;
+ item.Method = method;
+ item.BufIndex = bufIndex;
+ item.Parent = parent;
+
+ const Byte *pFile = p + pos;
+ CFfsFileHeader fh;
+ if (!fh.Parse(pFile))
+ {
+ UInt32 num_FF_bytes = Count_FF_Bytes(pFile, rem);
+ if (num_FF_bytes != rem)
+ {
+ item.Name = "[junk]";
+ item.Offset = posBase + pos + num_FF_bytes;
+ item.Size = rem - num_FF_bytes;
+ AddItem(item);
+ }
+ PrintLevel(level); PRF(printf("== FF FF reminder"));
+
+ break;
+ }
+
+ PrintLevel(level); PRF(printf("%s, type = %3d, pos = %7x, size = %7x", "FILE", fh.Type, posBase + pos, fh.Size));
+
+ if (!fh.Check(pFile, rem))
+ return S_FALSE;
+
+ UInt32 offset = posBase + pos + kFileHeaderSize;
+ UInt32 sectSize = fh.GetDataSize();
+ item.Offset = offset;
+ item.Size = sectSize;
+
+ pos += fh.Size;
+
+ if (fh.Type == FV_FILETYPE_FFS_PAD)
+ if (Is_FF_Stream(pFile + kFileHeaderSize, sectSize))
+ continue;
+
+ UInt32 guid32 = Get32(fh.GuidName);
+ bool full = true;
+ if (guidsVector.FindInSorted(guid32) < 0)
+ {
+ guidsVector.AddToUniqueSorted(guid32);
+ full = false;
+ }
+ item.SetGuid(fh.GuidName, full);
+
+ item.Characts = fh.GetCharacts();
+ // PrintLevel(level);
+ PRF(printf(" : %s", item.Characts));
+
+ {
+ PRF(printf(" attrib = %2d State = %3d ", (unsigned)fh.Attrib, (unsigned)fh.State));
+ PRF(char s[64]);
+ PRF(RawLeGuidToString(fh.GuidName, s));
+ PRF(printf(" : %s ", s));
+ }
+
+ if (fh.Type == FV_FILETYPE_FFS_PAD ||
+ fh.Type == FV_FILETYPE_RAW)
+ {
+ bool isVolume = false;
+ if (fh.Type == FV_FILETYPE_RAW)
+ {
+ if (sectSize >= kFvHeaderSize)
+ if (IsFfs(pFile + kFileHeaderSize))
+ isVolume = true;
+ }
+ if (isVolume)
+ {
+ const unsigned newParent = AddDirItem(item);
+ const UInt32 limSize = fh.GetDataSize2(rem);
+ // volume.VolSize > fh.Size for some UEFI archives (is it correct UEFI?)
+ // so we will check VolSize for limitSize instead.
+ RINOK(ParseVolume(bufIndex, offset, sectSize, limSize, (int)newParent, method, level))
+ }
+ else
+ AddItem(item);
+ }
+ else
+ {
+ /*
+ if (fh.Type == FV_FILETYPE_FREEFORM)
+ {
+ // in intel bio example: one FV_FILETYPE_FREEFORM file is wav file (not sections)
+ // AddItem(item);
+ }
+ else
+ */
+ {
+ const unsigned newParent = AddDirItem(item);
+ bool error2;
+ RINOK(ParseSections(bufIndex, offset, sectSize, (int)newParent, method, level + 1, error2))
+ if (error2)
+ {
+ // in intel bio example: one FV_FILETYPE_FREEFORM file is wav file (not sections)
+ item.IsDir = false;
+ item.Size = sectSize;
+ item.Name.Insert(0, "[ERROR]");
+ AddItem(item);
+ }
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+static const char * const kRegionName[] =
+{
+ "Descriptor"
+ , "BIOS"
+ , "ME"
+ , "GbE"
+ , "PDR"
+ , "Region5"
+ , "Region6"
+ , "Region7"
+};
+
+
+HRESULT CHandler::ParseIntelMe(
+ unsigned bufIndex, UInt32 posBase,
+ UInt32 exactSize, UInt32 limitSize,
+ int parent, int method, unsigned /* level */)
+{
+ UNUSED_VAR(limitSize)
+ // level++;
+
+ const Byte *p = _bufs[bufIndex] + posBase;
+ if (exactSize < 16 + 16)
+ return S_FALSE;
+ if (!IsIntelMe(p))
+ return S_FALSE;
+
+ UInt32 v0 = GetUi32(p + 20);
+ // UInt32 numRegions = (v0 >> 24) & 0x7;
+ UInt32 regAddr = (v0 >> 12) & 0xFF0;
+ // UInt32 numComps = (v0 >> 8) & 0x3;
+ // UInt32 fcba = (v0 << 4) & 0xFF0;
+
+ // (numRegions == 0) in header in some new images.
+ // So we don't use the value from header
+ UInt32 numRegions = 7;
+
+ for (unsigned i = 0; i <= numRegions; i++)
+ {
+ UInt32 offset = regAddr + i * 4;
+ if (offset + 4 > exactSize)
+ break;
+ UInt32 val = GetUi32(p + offset);
+
+ // only 12 bits probably are OK.
+ // How does it work for files larger than 16 MB?
+ const UInt32 kMask = 0xFFF;
+ // const UInt32 kMask = 0xFFFF; // 16-bit is more logical
+ const UInt32 lim = (val >> 16) & kMask;
+ const UInt32 base = (val & kMask);
+
+ /*
+ strange combinations:
+ PDR: base = 0x1FFF lim = 0;
+ empty: base = 0xFFFF lim = 0xFFFF;
+
+ PDR: base = 0x7FFF lim = 0;
+ empty: base = 0x7FFF lim = 0;
+ */
+ if (base == kMask && lim == 0)
+ continue; // unused
+
+ if (lim < base)
+ continue; // unused
+
+ CItem item;
+ item.Name = kRegionName[i];
+ item.Method = method;
+ item.BufIndex = bufIndex;
+ item.Parent = parent;
+ item.Offset = posBase + (base << 12);
+ if (item.Offset > exactSize)
+ continue;
+ item.Size = (lim + 1 - base) << 12;
+ // item.SetGuid(p + kFfsGuidOffset);
+ // item.Name += " [VOLUME]";
+ AddItem(item);
+ }
+ return S_OK;
+}
+
+
+HRESULT CHandler::OpenCapsule(IInStream *stream)
+{
+ const unsigned kHeaderSize = 80;
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buf, kHeaderSize))
+ if (!_h.Parse(buf))
+ return S_FALSE;
+ if (_h.CapsuleImageSize < kHeaderSize
+ || _h.CapsuleImageSize < _h.HeaderSize
+ || _h.OffsetToCapsuleBody < _h.HeaderSize
+ || _h.OffsetToCapsuleBody > _h.CapsuleImageSize
+ )
+ return S_FALSE;
+ _phySize = _h.CapsuleImageSize;
+
+ if (_h.SequenceNumber != 0 ||
+ _h.OffsetToSplitInformation != 0 )
+ return E_NOTIMPL;
+
+ unsigned bufIndex = AddBuf(_h.CapsuleImageSize);
+ CByteBuffer &buf0 = _bufs[bufIndex];
+ memcpy(buf0, buf, kHeaderSize);
+ ReadStream_FALSE(stream, buf0 + kHeaderSize, _h.CapsuleImageSize - kHeaderSize);
+
+ AddCommentString("Author", _h.OffsetToAuthorInformation);
+ AddCommentString("Revision", _h.OffsetToRevisionInformation);
+ AddCommentString("Short Description", _h.OffsetToShortDescription);
+ AddCommentString("Long Description", _h.OffsetToLongDescription);
+
+
+ const UInt32 size = _h.CapsuleImageSize - _h.OffsetToCapsuleBody;
+
+ if (size >= 32 && IsIntelMe(buf0 + _h.OffsetToCapsuleBody))
+ return ParseIntelMe(bufIndex, _h.OffsetToCapsuleBody, size, size, -1, -1, 0);
+
+ return ParseVolume(bufIndex, _h.OffsetToCapsuleBody, size, size, -1, -1, 0);
+}
+
+
+HRESULT CHandler::OpenFv(IInStream *stream, const UInt64 * /* maxCheckStartPosition */, IArchiveOpenCallback * /* callback */)
+{
+ Byte buf[kFvHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buf, kFvHeaderSize))
+ if (!IsFfs(buf))
+ return S_FALSE;
+ CVolFfsHeader ffsHeader;
+ if (!ffsHeader.Parse(buf))
+ return S_FALSE;
+ if (ffsHeader.VolSize > ((UInt32)1 << 30))
+ return S_FALSE;
+ _phySize = ffsHeader.VolSize;
+ RINOK(InStream_SeekToBegin(stream))
+ UInt32 fvSize32 = (UInt32)ffsHeader.VolSize;
+ unsigned bufIndex = AddBuf(fvSize32);
+ RINOK(ReadStream_FALSE(stream, _bufs[bufIndex], fvSize32))
+ return ParseVolume(bufIndex, 0, fvSize32, fvSize32, -1, -1, 0);
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback)
+{
+ if (_capsuleMode)
+ {
+ RINOK(OpenCapsule(stream))
+ }
+ else
+ {
+ RINOK(OpenFv(stream, maxCheckStartPosition, callback))
+ }
+
+ const unsigned num = _items.Size();
+ CIntArr numChilds(num);
+
+ unsigned i;
+
+ for (i = 0; i < num; i++)
+ numChilds[i] = 0;
+
+ for (i = 0; i < num; i++)
+ {
+ const int parent = _items[i].Parent;
+ if (parent >= 0)
+ numChilds[(unsigned)parent]++;
+ }
+
+ for (i = 0; i < num; i++)
+ {
+ const CItem &item = _items[i];
+ const int parent = item.Parent;
+ if (parent >= 0)
+ {
+ CItem &parentItem = _items[(unsigned)parent];
+ if (numChilds[(unsigned)parent] == 1)
+ if (!item.ThereIsUniqueName || !parentItem.ThereIsUniqueName || !parentItem.ThereAreSubDirs)
+ parentItem.Skip = true;
+ }
+ }
+
+ CUIntVector mainToReduced;
+
+ for (i = 0; i < _items.Size(); i++)
+ {
+ mainToReduced.Add(_items2.Size());
+ const CItem &item = _items[i];
+ if (item.Skip)
+ continue;
+ AString name;
+ int numItems = -1;
+ int parent = item.Parent;
+ if (parent >= 0)
+ numItems = numChilds[(unsigned)parent];
+ AString name2 (item.GetName(numItems));
+ AString characts2 (item.Characts);
+ if (item.KeepName)
+ name = name2;
+
+ while (parent >= 0)
+ {
+ const CItem &item3 = _items[(unsigned)parent];
+ if (!item3.Skip)
+ break;
+ if (item3.KeepName)
+ {
+ AString name3 (item3.GetName(-1));
+ if (name.IsEmpty())
+ name = name3;
+ else
+ name = name3 + '.' + name;
+ }
+ AddSpaceAndString(characts2, item3.Characts);
+ parent = item3.Parent;
+ }
+
+ if (name.IsEmpty())
+ name = name2;
+
+ CItem2 item2;
+ item2.MainIndex = i;
+ item2.Name = name;
+ item2.Characts = characts2;
+ if (parent >= 0)
+ item2.Parent = (int)mainToReduced[(unsigned)parent];
+ _items2.Add(item2);
+ /*
+ CItem2 item2;
+ item2.MainIndex = i;
+ item2.Name = item.Name;
+ item2.Parent = item.Parent;
+ _items2.Add(item2);
+ */
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ Close();
+ {
+ HRESULT res = Open2(inStream, maxCheckStartPosition, callback);
+ if (res == E_NOTIMPL)
+ res = S_FALSE;
+ return res;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+ _totalBufsSize = 0;
+ _methodsMask = 0;
+ _items.Clear();
+ _items2.Clear();
+ _bufs.Clear();
+ _comment.Empty();
+ _headersError = false;
+ _h.Clear();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items2.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items2.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _items[_items2[allFilesMode ? i : indices[i]].MainIndex].Size;
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentTotalSize = 0;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = lps->OutSize = currentTotalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CItem &item = _items[_items2[index].MainIndex];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ currentTotalSize += item.Size;
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ if (testMode || item.IsDir)
+ {
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ int res = NExtract::NOperationResult::kDataError;
+ CMyComPtr<ISequentialInStream> inStream;
+ GetStream(index, &inStream);
+ if (inStream)
+ {
+ RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize == item.Size)
+ res = NExtract::NOperationResult::kOK;
+ }
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ const CItem &item = _items[_items2[index].MainIndex];
+ if (item.IsDir)
+ return S_FALSE;
+ CBufInStream *streamSpec = new CBufInStream;
+ CMyComPtr<IInStream> streamTemp = streamSpec;
+ const CByteBuffer &buf = _bufs[item.BufIndex];
+ if (item.Offset > buf.Size())
+ return S_FALSE;
+ size_t size = buf.Size() - item.Offset;
+ if (size > item.Size)
+ size = item.Size;
+ streamSpec->Init(buf + item.Offset, size, (IInArchive *)this);
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+namespace UEFIc {
+
+static const Byte k_Capsule_Signatures[] =
+{
+ 16, CAPSULE_SIGNATURE,
+ 16, CAPSULE2_SIGNATURE,
+ 16, CAPSULE_UEFI_SIGNATURE
+};
+
+REGISTER_ARC_I_CLS(
+ CHandler(true),
+ "UEFIc", "scap", NULL, 0xD0,
+ k_Capsule_Signatures,
+ 0,
+ NArcInfoFlags::kMultiSignature |
+ NArcInfoFlags::kFindSignature,
+ NULL)
+
+}
+
+namespace UEFIf {
+
+static const Byte k_FFS_Signatures[] =
+{
+ 16, FFS1_SIGNATURE,
+ 16, FFS2_SIGNATURE
+};
+
+
+REGISTER_ARC_I_CLS(
+ CHandler(false),
+ "UEFIf", "uefif", NULL, 0xD1,
+ k_FFS_Signatures,
+ kFfsGuidOffset,
+ NArcInfoFlags::kMultiSignature |
+ NArcInfoFlags::kFindSignature,
+ NULL)
+
+}
+
+}}
diff --git a/CPP/7zip/Archive/VdiHandler.cpp b/CPP/7zip/Archive/VdiHandler.cpp
new file mode 100644
index 0000000..a5a9332
--- /dev/null
+++ b/CPP/7zip/Archive/VdiHandler.cpp
@@ -0,0 +1,438 @@
+// VdiHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NVdi {
+
+static const Byte k_Signature[] = { 0x7F, 0x10, 0xDA, 0xBE };
+
+static const unsigned k_ClusterBits = 20;
+static const UInt32 k_ClusterSize = (UInt32)1 << k_ClusterBits;
+
+
+/*
+VDI_IMAGE_BLOCK_FREE = (~0) // returns any random data
+VDI_IMAGE_BLOCK_ZERO = (~1) // returns zeros
+*/
+
+// static const UInt32 k_ClusterType_Free = 0xffffffff;
+static const UInt32 k_ClusterType_Zero = 0xfffffffe;
+
+#define IS_CLUSTER_ALLOCATED(v) ((UInt32)(v) < k_ClusterType_Zero)
+
+
+// static const UInt32 kDiskType_Dynamic = 1;
+// static const UInt32 kDiskType_Static = 2;
+
+static const char * const kDiskTypes[] =
+{
+ "0"
+ , "Dynamic"
+ , "Static"
+ , "Undo"
+ , "Diff"
+};
+
+
+enum EGuidType
+{
+ k_GuidType_Creat,
+ k_GuidType_Modif,
+ k_GuidType_Link,
+ k_GuidType_PModif
+};
+
+static const unsigned kNumGuids = 4;
+static const char * const kGuidNames[kNumGuids] =
+{
+ "Creat "
+ , "Modif "
+ , "Link "
+ , "PModif"
+};
+
+static bool IsEmptyGuid(const Byte *data)
+{
+ for (unsigned i = 0; i < 16; i++)
+ if (data[i] != 0)
+ return false;
+ return true;
+}
+
+
+
+Z7_class_CHandler_final: public CHandlerImg
+{
+ UInt32 _dataOffset;
+ CByteBuffer _table;
+ UInt64 _phySize;
+ UInt32 _imageType;
+ bool _isArc;
+ bool _unsupported;
+
+ Byte Guids[kNumGuids][16];
+
+ HRESULT Seek2(UInt64 offset)
+ {
+ _posInArc = offset;
+ return InStream_SeekSet(Stream, offset);
+ }
+
+ HRESULT InitAndSeek()
+ {
+ _virtPos = 0;
+ return Seek2(0);
+ }
+
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openCallback) Z7_override;
+
+public:
+ Z7_IFACE_COM7_IMP(IInArchive_Img)
+
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+};
+
+
+Z7_COM7F_IMF(CHandler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= _size)
+ return S_OK;
+ {
+ UInt64 rem = _size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ if (size == 0)
+ return S_OK;
+ }
+
+ {
+ UInt64 cluster = _virtPos >> k_ClusterBits;
+ UInt32 lowBits = (UInt32)_virtPos & (k_ClusterSize - 1);
+ {
+ UInt32 rem = k_ClusterSize - lowBits;
+ if (size > rem)
+ size = rem;
+ }
+
+ cluster <<= 2;
+ if (cluster < _table.Size())
+ {
+ const Byte *p = (const Byte *)_table + (size_t)cluster;
+ const UInt32 v = Get32(p);
+ if (IS_CLUSTER_ALLOCATED(v))
+ {
+ UInt64 offset = _dataOffset + ((UInt64)v << k_ClusterBits);
+ offset += lowBits;
+ if (offset != _posInArc)
+ {
+ RINOK(Seek2(offset))
+ }
+ HRESULT res = Stream->Read(data, size, &size);
+ _posInArc += size;
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return res;
+ }
+ }
+
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+}
+
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize
+};
+
+static const Byte kArcProps[] =
+{
+ kpidHeadersSize,
+ kpidMethod,
+ kpidComment,
+ kpidName
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+ case kpidHeadersSize: prop = _dataOffset; break;
+
+ case kpidMethod:
+ {
+ TYPE_TO_PROP(kDiskTypes, _imageType, prop);
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
+ // if (_headerError) v |= kpv_ErrorFlags_HeadersError;
+ if (!Stream && v == 0 && _isArc)
+ v = kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidComment:
+ {
+ AString s;
+ for (unsigned i = 0; i < kNumGuids; i++)
+ {
+ const Byte *guid = Guids[i];
+ if (!IsEmptyGuid(guid))
+ {
+ s.Add_LF();
+ s += kGuidNames[i];
+ s += " : ";
+ char temp[64];
+ RawLeGuidToString_Braced(guid, temp);
+ MyStringLower_Ascii(temp);
+ s += temp;
+ }
+ }
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidName:
+ {
+ const Byte *guid = Guids[k_GuidType_Creat];
+ if (!IsEmptyGuid(guid))
+ {
+ char temp[64];
+ RawLeGuidToString_Braced(guid, temp);
+ MyStringLower_Ascii(temp);
+ MyStringCat(temp, ".vdi");
+ prop = temp;
+ }
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidSize: prop = _size; break;
+ case kpidPackSize: prop = _phySize - _dataOffset; break;
+ case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback * /* openCallback */)
+{
+ const unsigned kHeaderSize = 512;
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buf, kHeaderSize))
+
+ if (memcmp(buf + 0x40, k_Signature, sizeof(k_Signature)) != 0)
+ return S_FALSE;
+
+ const UInt32 version = Get32(buf + 0x44);
+ if (version >= 0x20000)
+ return S_FALSE;
+ if (version < 0x10000)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+
+ const unsigned kHeaderOffset = 0x48;
+ const unsigned kGuidsOffsets = 0x188;
+ const UInt32 headerSize = Get32(buf + kHeaderOffset);
+ if (headerSize < kGuidsOffsets - kHeaderOffset || headerSize > 0x200 - kHeaderOffset)
+ return S_FALSE;
+
+ _imageType = Get32(buf + 0x4C);
+ // Int32 flags = Get32(buf + 0x50);
+ // Byte Comment[0x100]
+
+ const UInt32 tableOffset = Get32(buf + 0x154);
+ if (tableOffset < 0x200)
+ return S_FALSE;
+
+ _dataOffset = Get32(buf + 0x158);
+
+ // UInt32 geometry[3];
+
+ const UInt32 sectorSize = Get32(buf + 0x168);
+ if (sectorSize != 0x200)
+ return S_FALSE;
+
+ _size = Get64(buf + 0x170);
+ const UInt32 blockSize = Get32(buf + 0x178);
+ const UInt32 totalBlocks = Get32(buf + 0x180);
+ const UInt32 numAllocatedBlocks = Get32(buf + 0x184);
+
+ _isArc = true;
+
+ if (_dataOffset < tableOffset)
+ return S_FALSE;
+
+ if (_imageType > 4)
+ _unsupported = true;
+
+ if (blockSize != k_ClusterSize)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+
+ if (headerSize >= kGuidsOffsets + kNumGuids * 16 - kHeaderOffset)
+ {
+ for (unsigned i = 0; i < kNumGuids; i++)
+ memcpy(Guids[i], buf + kGuidsOffsets + 16 * i, 16);
+
+ if (!IsEmptyGuid(Guids[k_GuidType_Link]) ||
+ !IsEmptyGuid(Guids[k_GuidType_PModif]))
+ _unsupported = true;
+ }
+
+ {
+ UInt64 size2 = (UInt64)totalBlocks << k_ClusterBits;
+ if (size2 < _size)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+ /*
+ if (size2 > _size)
+ _size = size2;
+ */
+ }
+
+ {
+ UInt32 tableReserved = _dataOffset - tableOffset;
+ if ((tableReserved >> 2) < totalBlocks)
+ return S_FALSE;
+ }
+
+ _phySize = _dataOffset + ((UInt64)numAllocatedBlocks << k_ClusterBits);
+
+ const size_t numBytes = (size_t)totalBlocks * 4;
+ if ((numBytes >> 2) != totalBlocks)
+ {
+ _unsupported = true;
+ return E_OUTOFMEMORY;
+ }
+
+ _table.Alloc(numBytes);
+ RINOK(InStream_SeekSet(stream, tableOffset))
+ RINOK(ReadStream_FALSE(stream, _table, numBytes))
+
+ const Byte *data = _table;
+ for (UInt32 i = 0; i < totalBlocks; i++)
+ {
+ const UInt32 v = Get32(data + (size_t)i * 4);
+ if (!IS_CLUSTER_ALLOCATED(v))
+ continue;
+ if (v >= numAllocatedBlocks)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+ }
+
+ Stream = stream;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _table.Free();
+ _phySize = 0;
+ _isArc = false;
+ _unsupported = false;
+
+ for (unsigned i = 0; i < kNumGuids; i++)
+ memset(Guids[i], 0, 16);
+
+ // CHandlerImg:
+ Clear_HandlerImg_Vars();
+ Stream.Release();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ if (_unsupported)
+ return S_FALSE;
+ CMyComPtr<ISequentialInStream> streamTemp = this;
+ RINOK(InitAndSeek())
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+REGISTER_ARC_I(
+ "VDI", "vdi", NULL, 0xC9,
+ k_Signature,
+ 0x40,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/VhdHandler.cpp b/CPP/7zip/Archive/VhdHandler.cpp
new file mode 100644
index 0000000..e5bf997
--- /dev/null
+++ b/CPP/7zip/Archive/VhdHandler.cpp
@@ -0,0 +1,977 @@
+// VhdHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+#define Get64(p) GetBe64(p)
+
+#define G32(_offs_, dest) dest = Get32(p + (_offs_))
+#define G64(_offs_, dest) dest = Get64(p + (_offs_))
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NVhd {
+
+static const unsigned kSignatureSize = 10;
+static const Byte kSignature[kSignatureSize] =
+ { 'c', 'o', 'n', 'e', 'c', 't', 'i', 'x', 0, 0 };
+
+static const UInt32 kUnusedBlock = 0xFFFFFFFF;
+
+static const UInt32 kDiskType_Fixed = 2;
+static const UInt32 kDiskType_Dynamic = 3;
+static const UInt32 kDiskType_Diff = 4;
+
+static const char * const kDiskTypes[] =
+{
+ "0"
+ , "1"
+ , "Fixed"
+ , "Dynamic"
+ , "Differencing"
+};
+
+struct CFooter
+{
+ // UInt32 Features;
+ // UInt32 FormatVersion;
+ UInt64 DataOffset;
+ UInt32 CTime;
+ UInt32 CreatorApp;
+ UInt32 CreatorVersion;
+ UInt32 CreatorHostOS;
+ // UInt64 OriginalSize;
+ UInt64 CurrentSize;
+ UInt32 DiskGeometry;
+ UInt32 Type;
+ Byte Id[16];
+ Byte SavedState;
+
+ bool IsFixed() const { return Type == kDiskType_Fixed; }
+ bool ThereIsDynamic() const { return Type == kDiskType_Dynamic || Type == kDiskType_Diff; }
+ // bool IsSupported() const { return Type == kDiskType_Fixed || Type == kDiskType_Dynamic || Type == kDiskType_Diff; }
+ UInt32 NumCyls() const { return DiskGeometry >> 16; }
+ UInt32 NumHeads() const { return (DiskGeometry >> 8) & 0xFF; }
+ UInt32 NumSectorsPerTrack() const { return DiskGeometry & 0xFF; }
+ void AddTypeString(AString &s) const;
+ bool Parse(const Byte *p);
+};
+
+void CFooter::AddTypeString(AString &s) const
+{
+ if (Type < Z7_ARRAY_SIZE(kDiskTypes))
+ s += kDiskTypes[Type];
+ else
+ s.Add_UInt32(Type);
+}
+
+static bool CheckBlock(const Byte *p, unsigned size, unsigned checkSumOffset, unsigned zeroOffset)
+{
+ UInt32 sum = 0;
+ unsigned i;
+ for (i = 0; i < checkSumOffset; i++)
+ sum += p[i];
+ for (i = checkSumOffset + 4; i < size; i++)
+ sum += p[i];
+ if (~sum != Get32(p + checkSumOffset))
+ return false;
+ for (i = zeroOffset; i < size; i++)
+ if (p[i] != 0)
+ return false;
+ return true;
+}
+
+static const unsigned kSectorSize_Log = 9;
+static const unsigned kSectorSize = 1 << kSectorSize_Log;
+static const unsigned kHeaderSize = 512;
+
+bool CFooter::Parse(const Byte *p)
+{
+ if (memcmp(p, kSignature, kSignatureSize) != 0)
+ return false;
+ // G32(0x08, Features);
+ // G32(0x0C, FormatVersion);
+ G64(0x10, DataOffset);
+ G32(0x18, CTime);
+ G32(0x1C, CreatorApp);
+ G32(0x20, CreatorVersion);
+ G32(0x24, CreatorHostOS);
+ // G64(0x28, OriginalSize);
+ G64(0x30, CurrentSize);
+ G32(0x38, DiskGeometry);
+ G32(0x3C, Type);
+ if (Type < kDiskType_Fixed ||
+ Type > kDiskType_Diff)
+ return false;
+ memcpy(Id, p + 0x44, 16);
+ SavedState = p[0x54];
+ // if (DataOffset > ((UInt64)1 << 62)) return false;
+ // if (CurrentSize > ((UInt64)1 << 62)) return false;
+ return CheckBlock(p, kHeaderSize, 0x40, 0x55);
+}
+
+struct CParentLocatorEntry
+{
+ UInt32 Code;
+ UInt32 DataSpace;
+ UInt32 DataLen;
+ UInt64 DataOffset;
+
+ bool Parse(const Byte *p)
+ {
+ G32(0x00, Code);
+ G32(0x04, DataSpace);
+ G32(0x08, DataLen);
+ G64(0x10, DataOffset);
+ return Get32(p + 0x0C) == 0; // Reserved
+ }
+};
+
+struct CDynHeader
+{
+ // UInt64 DataOffset;
+ UInt64 TableOffset;
+ // UInt32 HeaderVersion;
+ UInt32 NumBlocks;
+ unsigned BlockSizeLog;
+ UInt32 ParentTime;
+ Byte ParentId[16];
+ bool RelativeNameWasUsed;
+ UString ParentName;
+ UString RelativeParentNameFromLocator;
+ CParentLocatorEntry ParentLocators[8];
+
+ bool Parse(const Byte *p);
+ UInt32 NumBitMapSectors() const
+ {
+ UInt32 numSectorsInBlock = (1 << (BlockSizeLog - kSectorSize_Log));
+ return (numSectorsInBlock + kSectorSize * 8 - 1) / (kSectorSize * 8);
+ }
+ void Clear()
+ {
+ RelativeNameWasUsed = false;
+ ParentName.Empty();
+ RelativeParentNameFromLocator.Empty();
+ }
+};
+
+bool CDynHeader::Parse(const Byte *p)
+{
+ if (memcmp(p, "cxsparse", 8) != 0)
+ return false;
+ // G64(0x08, DataOffset);
+ G64(0x10, TableOffset);
+ // G32(0x18, HeaderVersion);
+ G32(0x1C, NumBlocks);
+ {
+ UInt32 blockSize = Get32(p + 0x20);
+ unsigned i;
+ for (i = kSectorSize_Log;; i++)
+ {
+ if (i > 31)
+ return false;
+ if (((UInt32)1 << i) == blockSize)
+ break;
+ }
+ BlockSizeLog = i;
+ }
+ G32(0x38, ParentTime);
+ if (Get32(p + 0x3C) != 0) // reserved
+ return false;
+ memcpy(ParentId, p + 0x28, 16);
+ {
+ const unsigned kNameLen = 256;
+ wchar_t *s = ParentName.GetBuf(kNameLen);
+ unsigned i;
+ for (i = 0; i < kNameLen; i++)
+ {
+ wchar_t c = Get16(p + 0x40 + i * 2);
+ if (c == 0)
+ break;
+ s[i] = c;
+ }
+ s[i] = 0;
+ ParentName.ReleaseBuf_SetLen(i);
+ }
+ for (unsigned i = 0; i < 8; i++)
+ if (!ParentLocators[i].Parse(p + 0x240 + i * 24))
+ return false;
+ return CheckBlock(p, 1024, 0x24, 0x240 + 8 * 24);
+}
+
+Z7_class_CHandler_final: public CHandlerImg
+{
+ UInt64 _posInArcLimit;
+ UInt64 _startOffset;
+ UInt64 _phySize;
+
+ CFooter Footer;
+ CDynHeader Dyn;
+ CRecordVector<UInt32> Bat;
+ CByteBuffer BitMap;
+ UInt32 BitMapTag;
+ UInt32 NumUsedBlocks;
+ CMyComPtr<IInStream> ParentStream;
+ CHandler *Parent;
+ UInt64 NumLevels;
+ UString _errorMessage;
+ // bool _unexpectedEnd;
+
+ void AddErrorMessage(const char *message, const wchar_t *name = NULL)
+ {
+ if (!_errorMessage.IsEmpty())
+ _errorMessage.Add_LF();
+ _errorMessage += message;
+ if (name)
+ _errorMessage += name;
+ }
+
+ void UpdatePhySize(UInt64 value)
+ {
+ if (_phySize < value)
+ _phySize = value;
+ }
+
+ HRESULT Seek2(UInt64 offset);
+ HRESULT InitAndSeek();
+ HRESULT ReadPhy(UInt64 offset, void *data, UInt32 size);
+
+ bool NeedParent() const { return Footer.Type == kDiskType_Diff; }
+ UInt64 GetPackSize() const
+ { return Footer.ThereIsDynamic() ? ((UInt64)NumUsedBlocks << Dyn.BlockSizeLog) : Footer.CurrentSize; }
+
+ UString GetParentSequence() const
+ {
+ const CHandler *p = this;
+ UString res;
+ while (p && p->NeedParent())
+ {
+ if (!res.IsEmpty())
+ res += " -> ";
+ UString mainName;
+ UString anotherName;
+ if (Dyn.RelativeNameWasUsed)
+ {
+ mainName = p->Dyn.RelativeParentNameFromLocator;
+ anotherName = p->Dyn.ParentName;
+ }
+ else
+ {
+ mainName = p->Dyn.ParentName;
+ anotherName = p->Dyn.RelativeParentNameFromLocator;
+ }
+ res += mainName;
+ if (mainName != anotherName && !anotherName.IsEmpty())
+ {
+ res.Add_Space();
+ res += '(';
+ res += anotherName;
+ res += ')';
+ }
+ p = p->Parent;
+ }
+ return res;
+ }
+
+ bool AreParentsOK() const
+ {
+ const CHandler *p = this;
+ while (p->NeedParent())
+ {
+ p = p->Parent;
+ if (!p)
+ return false;
+ }
+ return true;
+ }
+
+ HRESULT Open3();
+ HRESULT Open2(IInStream *stream, CHandler *child, IArchiveOpenCallback *openArchiveCallback, unsigned level);
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCallback) Z7_override
+ {
+ return Open2(stream, NULL, openArchiveCallback, 0);
+ }
+ void CloseAtError() Z7_override;
+
+public:
+ Z7_IFACE_COM7_IMP(IInArchive_Img)
+
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+};
+
+HRESULT CHandler::Seek2(UInt64 offset) { return InStream_SeekSet(Stream, _startOffset + offset); }
+
+HRESULT CHandler::InitAndSeek()
+{
+ if (ParentStream)
+ {
+ RINOK(Parent->InitAndSeek())
+ }
+ _virtPos = _posInArc = 0;
+ BitMapTag = kUnusedBlock;
+ BitMap.Alloc(Dyn.NumBitMapSectors() << kSectorSize_Log);
+ return Seek2(0);
+}
+
+HRESULT CHandler::ReadPhy(UInt64 offset, void *data, UInt32 size)
+{
+ if (offset + size > _posInArcLimit)
+ return S_FALSE;
+ if (offset != _posInArc)
+ {
+ _posInArc = offset;
+ RINOK(Seek2(offset))
+ }
+ HRESULT res = ReadStream_FALSE(Stream, data, size);
+ if (res == S_OK)
+ _posInArc += size;
+ else
+ Reset_PosInArc();
+ return res;
+}
+
+HRESULT CHandler::Open3()
+{
+ // Fixed archive uses only footer
+
+ UInt64 startPos;
+ RINOK(InStream_GetPos(Stream, startPos))
+ _startOffset = startPos;
+ Byte header[kHeaderSize];
+ RINOK(ReadStream_FALSE(Stream, header, kHeaderSize))
+ bool headerIsOK = Footer.Parse(header);
+ _size = Footer.CurrentSize;
+
+ if (headerIsOK && !Footer.ThereIsDynamic())
+ {
+ // fixed archive
+ if (startPos < Footer.CurrentSize)
+ return S_FALSE;
+ _posInArcLimit = Footer.CurrentSize;
+ _phySize = Footer.CurrentSize + kHeaderSize;
+ _startOffset = startPos - Footer.CurrentSize;
+ _posInArc = _phySize;
+ return S_OK;
+ }
+
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(Stream, fileSize))
+ if (fileSize < kHeaderSize)
+ return S_FALSE;
+
+ const UInt32 kDynSize = 1024;
+ Byte buf[kDynSize];
+
+ RINOK(InStream_SeekSet(Stream, fileSize - kHeaderSize))
+ RINOK(ReadStream_FALSE(Stream, buf, kHeaderSize))
+
+ if (!headerIsOK)
+ {
+ if (!Footer.Parse(buf))
+ return S_FALSE;
+ _size = Footer.CurrentSize;
+ if (Footer.ThereIsDynamic())
+ return S_FALSE; // we can't open Dynamic Archive backward.
+ // fixed archive
+ _posInArcLimit = Footer.CurrentSize;
+ _phySize = Footer.CurrentSize + kHeaderSize;
+ _startOffset = fileSize - kHeaderSize - Footer.CurrentSize;
+ _posInArc = _phySize;
+ return S_OK;
+ }
+
+ _phySize = kHeaderSize;
+ _posInArc = fileSize - startPos;
+ _posInArcLimit = _posInArc - kHeaderSize;
+
+ bool headerAndFooterAreEqual = false;
+ if (memcmp(header, buf, kHeaderSize) == 0)
+ {
+ headerAndFooterAreEqual = true;
+ _phySize = fileSize - _startOffset;
+ }
+
+ RINOK(ReadPhy(Footer.DataOffset, buf, kDynSize))
+ if (!Dyn.Parse(buf))
+ return S_FALSE;
+
+ UpdatePhySize(Footer.DataOffset + kDynSize);
+
+ for (int i = 0; i < 8; i++)
+ {
+ const CParentLocatorEntry &locator = Dyn.ParentLocators[i];
+ const UInt32 kNameBufSizeMax = 1024;
+ if (locator.DataLen < kNameBufSizeMax &&
+ locator.DataOffset < _posInArcLimit &&
+ locator.DataOffset + locator.DataLen <= _posInArcLimit)
+ {
+ if (locator.Code == 0x57327275 && (locator.DataLen & 1) == 0)
+ {
+ // "W2ru" locator
+ // Path is encoded as little-endian UTF-16
+ Byte nameBuf[kNameBufSizeMax];
+ UString tempString;
+ unsigned len = (locator.DataLen >> 1);
+ {
+ wchar_t *s = tempString.GetBuf(len);
+ RINOK(ReadPhy(locator.DataOffset, nameBuf, locator.DataLen))
+ unsigned j;
+ for (j = 0; j < len; j++)
+ {
+ wchar_t c = GetUi16(nameBuf + j * 2);
+ if (c == 0)
+ break;
+ s[j] = c;
+ }
+ s[j] = 0;
+ tempString.ReleaseBuf_SetLen(j);
+ }
+ if (tempString[0] == L'.' && tempString[1] == L'\\')
+ tempString.DeleteFrontal(2);
+ Dyn.RelativeParentNameFromLocator = tempString;
+ }
+ }
+ if (locator.DataLen != 0)
+ UpdatePhySize(locator.DataOffset + locator.DataLen);
+ }
+
+ if (Dyn.NumBlocks >= (UInt32)1 << 31)
+ return S_FALSE;
+ if (Footer.CurrentSize == 0)
+ {
+ if (Dyn.NumBlocks != 0)
+ return S_FALSE;
+ }
+ else if (((Footer.CurrentSize - 1) >> Dyn.BlockSizeLog) + 1 != Dyn.NumBlocks)
+ return S_FALSE;
+
+ Bat.ClearAndReserve(Dyn.NumBlocks);
+
+ UInt32 bitmapSize = Dyn.NumBitMapSectors() << kSectorSize_Log;
+
+ while ((UInt32)Bat.Size() < Dyn.NumBlocks)
+ {
+ RINOK(ReadPhy(Dyn.TableOffset + (UInt64)Bat.Size() * 4, buf, kSectorSize))
+ UpdatePhySize(Dyn.TableOffset + kSectorSize);
+ for (UInt32 j = 0; j < kSectorSize; j += 4)
+ {
+ UInt32 v = Get32(buf + j);
+ if (v != kUnusedBlock)
+ {
+ UInt32 blockSize = (UInt32)1 << Dyn.BlockSizeLog;
+ UpdatePhySize(((UInt64)v << kSectorSize_Log) + bitmapSize + blockSize);
+ NumUsedBlocks++;
+ }
+ Bat.AddInReserved(v);
+ if ((UInt32)Bat.Size() >= Dyn.NumBlocks)
+ break;
+ }
+ }
+
+ if (headerAndFooterAreEqual)
+ return S_OK;
+
+ if (_startOffset + _phySize + kHeaderSize > fileSize)
+ {
+ // _unexpectedEnd = true;
+ _posInArcLimit = _phySize;
+ _phySize += kHeaderSize;
+ return S_OK;
+ }
+
+ RINOK(ReadPhy(_phySize, buf, kHeaderSize))
+ if (memcmp(header, buf, kHeaderSize) == 0)
+ {
+ _posInArcLimit = _phySize;
+ _phySize += kHeaderSize;
+ return S_OK;
+ }
+
+ if (_phySize == 0x800)
+ {
+ /* WHY does empty archive contain additional empty sector?
+ We skip that sector and check footer again. */
+ unsigned i;
+ for (i = 0; i < kSectorSize && buf[i] == 0; i++);
+ if (i == kSectorSize)
+ {
+ RINOK(ReadPhy(_phySize + kSectorSize, buf, kHeaderSize))
+ if (memcmp(header, buf, kHeaderSize) == 0)
+ {
+ _phySize += kSectorSize;
+ _posInArcLimit = _phySize;
+ _phySize += kHeaderSize;
+ return S_OK;
+ }
+ }
+ }
+ _posInArcLimit = _phySize;
+ _phySize += kHeaderSize;
+ AddErrorMessage("Can't find footer");
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= Footer.CurrentSize)
+ return S_OK;
+ {
+ const UInt64 rem = Footer.CurrentSize - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+
+ if (Footer.IsFixed())
+ {
+ if (_virtPos > _posInArcLimit)
+ return S_FALSE;
+ {
+ const UInt64 rem = _posInArcLimit - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ HRESULT res = S_OK;
+ if (_virtPos != _posInArc)
+ {
+ _posInArc = _virtPos;
+ res = Seek2(_virtPos);
+ }
+ if (res == S_OK)
+ {
+ UInt32 processedSize2 = 0;
+ res = Stream->Read(data, size, &processedSize2);
+ if (processedSize)
+ *processedSize = processedSize2;
+ _posInArc += processedSize2;
+ }
+ if (res != S_OK)
+ Reset_PosInArc();
+ return res;
+ }
+
+ const UInt32 blockIndex = (UInt32)(_virtPos >> Dyn.BlockSizeLog);
+ if (blockIndex >= Bat.Size())
+ return E_FAIL; // it's some unexpected case
+ const UInt32 blockSectIndex = Bat[blockIndex];
+ const UInt32 blockSize = (UInt32)1 << Dyn.BlockSizeLog;
+ UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
+ size = MyMin(blockSize - offsetInBlock, size);
+
+ HRESULT res = S_OK;
+ if (blockSectIndex == kUnusedBlock)
+ {
+ if (ParentStream)
+ {
+ RINOK(InStream_SeekSet(ParentStream, _virtPos))
+ res = ParentStream->Read(data, size, &size);
+ }
+ else
+ memset(data, 0, size);
+ }
+ else
+ {
+ const UInt64 newPos = (UInt64)blockSectIndex << kSectorSize_Log;
+ if (BitMapTag != blockIndex)
+ {
+ RINOK(ReadPhy(newPos, BitMap, (UInt32)BitMap.Size()))
+ BitMapTag = blockIndex;
+ }
+ RINOK(ReadPhy(newPos + BitMap.Size() + offsetInBlock, data, size))
+ for (UInt32 cur = 0; cur < size;)
+ {
+ const UInt32 rem = MyMin(0x200 - (offsetInBlock & 0x1FF), size - cur);
+ const UInt32 bmi = offsetInBlock >> kSectorSize_Log;
+ if (((BitMap[bmi >> 3] >> (7 - (bmi & 7))) & 1) == 0)
+ {
+ if (ParentStream)
+ {
+ RINOK(InStream_SeekSet(ParentStream, _virtPos + cur))
+ RINOK(ReadStream_FALSE(ParentStream, (Byte *)data + cur, rem))
+ }
+ else
+ {
+ const Byte *p = (const Byte *)data + cur;
+ for (UInt32 i = 0; i < rem; i++)
+ if (p[i] != 0)
+ return S_FALSE;
+ }
+ }
+ offsetInBlock += rem;
+ cur += rem;
+ }
+ }
+ if (processedSize)
+ *processedSize = size;
+ _virtPos += size;
+ return res;
+}
+
+
+enum
+{
+ kpidParent = kpidUserDefined,
+ kpidSavedState
+};
+
+static const CStatProp kArcProps[] =
+{
+ { NULL, kpidOffset, VT_UI8},
+ { NULL, kpidCTime, VT_FILETIME},
+ { NULL, kpidClusterSize, VT_UI8},
+ { NULL, kpidMethod, VT_BSTR},
+ { NULL, kpidNumVolumes, VT_UI4},
+ { NULL, kpidTotalPhySize, VT_UI8},
+ { "Parent", kpidParent, VT_BSTR},
+ { NULL, kpidCreatorApp, VT_BSTR},
+ { NULL, kpidHostOS, VT_BSTR},
+ { "Saved State", kpidSavedState, VT_BOOL},
+ { NULL, kpidId, VT_BSTR}
+ };
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize,
+ kpidCTime
+
+ /*
+ { kpidNumCyls, VT_UI4},
+ { kpidNumHeads, VT_UI4},
+ { kpidSectorsPerTrack, VT_UI4}
+ */
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+// VHD start time: 2000-01-01
+static const UInt64 kVhdTimeStartValue = (UInt64)3600 * 24 * (399 * 365 + 24 * 4);
+
+static void VhdTimeToFileTime(UInt32 vhdTime, NCOM::CPropVariant &prop)
+{
+ FILETIME ft, utc;
+ UInt64 v = (kVhdTimeStartValue + vhdTime) * 10000000;
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+ // specification says that it's UTC time, but Virtual PC 6 writes local time. Why?
+ LocalFileTimeToFileTime(&ft, &utc);
+ prop = utc;
+}
+
+static void StringToAString(char *dest, UInt32 val)
+{
+ for (int i = 24; i >= 0; i -= 8)
+ {
+ const Byte b = (Byte)((val >> i) & 0xFF);
+ if (b < 0x20 || b > 0x7F)
+ break;
+ *dest++ = (char)b;
+ }
+ *dest = 0;
+}
+
+static void ConvertByteToHex(unsigned value, char *s)
+{
+ for (int i = 0; i < 2; i++)
+ {
+ unsigned t = value & 0xF;
+ value >>= 4;
+ s[1 - i] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+ }
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidCTime: VhdTimeToFileTime(Footer.CTime, prop); break;
+ case kpidClusterSize: if (Footer.ThereIsDynamic()) prop = (UInt32)1 << Dyn.BlockSizeLog; break;
+ case kpidShortComment:
+ case kpidMethod:
+ {
+ AString s;
+ Footer.AddTypeString(s);
+ if (NeedParent())
+ {
+ s += " -> ";
+ const CHandler *p = this;
+ while (p && p->NeedParent())
+ p = p->Parent;
+ if (!p)
+ s += '?';
+ else
+ p->Footer.AddTypeString(s);
+ }
+ prop = s;
+ break;
+ }
+ case kpidCreatorApp:
+ {
+ char s[16];
+ StringToAString(s, Footer.CreatorApp);
+ AString res (s);
+ res.Trim();
+ res.Add_Space();
+ res.Add_UInt32(Footer.CreatorVersion >> 16);
+ res.Add_Dot();
+ res.Add_UInt32(Footer.CreatorVersion & 0xFFFF);
+ prop = res;
+ break;
+ }
+ case kpidHostOS:
+ {
+ if (Footer.CreatorHostOS == 0x5769326B)
+ prop = "Windows";
+ else
+ {
+ char s[16];
+ StringToAString(s, Footer.CreatorHostOS);
+ prop = s;
+ }
+ break;
+ }
+ case kpidId:
+ {
+ char s[32 + 4];
+ for (int i = 0; i < 16; i++)
+ ConvertByteToHex(Footer.Id[i], s + i * 2);
+ s[32] = 0;
+ prop = s;
+ break;
+ }
+ case kpidSavedState: prop = Footer.SavedState ? true : false; break;
+ case kpidParent: if (NeedParent()) prop = GetParentSequence(); break;
+ case kpidOffset: prop = _startOffset; break;
+ case kpidPhySize: prop = _phySize; break;
+ case kpidTotalPhySize:
+ {
+ const CHandler *p = this;
+ UInt64 sum = 0;
+ do
+ {
+ sum += p->_phySize;
+ p = p->Parent;
+ }
+ while (p);
+ prop = sum;
+ break;
+ }
+ case kpidNumVolumes: if (NumLevels != 1) prop = (UInt32)NumLevels; break;
+
+ /*
+ case kpidErrorFlags:
+ {
+ UInt32 flags = 0;
+ if (_unexpectedEnd)
+ flags |= kpv_ErrorFlags_UnexpectedEndOfArc;
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ */
+ case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, CHandler *child, IArchiveOpenCallback *openArchiveCallback, unsigned level)
+{
+ Close();
+ Stream = stream;
+ if (level > (1 << 12)) // Maybe we need to increase that limit
+ return S_FALSE;
+
+ RINOK(Open3())
+
+ NumLevels = 1;
+ if (child && memcmp(child->Dyn.ParentId, Footer.Id, 16) != 0)
+ return S_FALSE;
+ if (Footer.Type != kDiskType_Diff)
+ return S_OK;
+
+ bool useRelative;
+ UString name;
+
+ if (!Dyn.RelativeParentNameFromLocator.IsEmpty())
+ {
+ useRelative = true;
+ name = Dyn.RelativeParentNameFromLocator;
+ }
+ else
+ {
+ useRelative = false;
+ name = Dyn.ParentName;
+ }
+
+ Dyn.RelativeNameWasUsed = useRelative;
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpenVolumeCallback,
+ openVolumeCallback, openArchiveCallback)
+
+ if (openVolumeCallback)
+ {
+ CMyComPtr<IInStream> nextStream;
+ HRESULT res = openVolumeCallback->GetStream(name, &nextStream);
+
+ if (res == S_FALSE)
+ {
+ if (useRelative && Dyn.ParentName != Dyn.RelativeParentNameFromLocator)
+ {
+ res = openVolumeCallback->GetStream(Dyn.ParentName, &nextStream);
+ if (res == S_OK)
+ Dyn.RelativeNameWasUsed = false;
+ }
+ }
+
+ if (res != S_OK && res != S_FALSE)
+ return res;
+
+ if (res == S_FALSE || !nextStream)
+ {
+ AddErrorMessage("Missing volume : ", name);
+ return S_OK;
+ }
+
+ Parent = new CHandler;
+ ParentStream = Parent;
+
+ res = Parent->Open2(nextStream, this, openArchiveCallback, level + 1);
+
+ if (res != S_OK)
+ {
+ Parent = NULL;
+ ParentStream.Release();
+ if (res == E_ABORT)
+ return res;
+ if (res != S_FALSE)
+ {
+ // we must show that error code
+ }
+ }
+ if (res == S_OK)
+ {
+ NumLevels = Parent->NumLevels + 1;
+ }
+ }
+ {
+ const CHandler *p = this;
+ while (p->NeedParent())
+ {
+ p = p->Parent;
+ if (!p)
+ {
+ AddErrorMessage("Can't open parent VHD file : ", Dyn.ParentName);
+ break;
+ }
+ }
+ }
+ return S_OK;
+}
+
+
+void CHandler::CloseAtError()
+{
+ // CHandlerImg:
+ Stream.Release();
+ Clear_HandlerImg_Vars();
+
+ _phySize = 0;
+ NumLevels = 0;
+ Bat.Clear();
+ NumUsedBlocks = 0;
+ Parent = NULL;
+ ParentStream.Release();
+ Dyn.Clear();
+ _errorMessage.Empty();
+ // _unexpectedEnd = false;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ CloseAtError();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidSize: prop = Footer.CurrentSize; break;
+ case kpidPackSize: prop = GetPackSize(); break;
+ case kpidCTime: VhdTimeToFileTime(Footer.CTime, prop); break;
+ case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+
+ /*
+ case kpidNumCyls: prop = Footer.NumCyls(); break;
+ case kpidNumHeads: prop = Footer.NumHeads(); break;
+ case kpidSectorsPerTrack: prop = Footer.NumSectorsPerTrack(); break;
+ */
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ if (Footer.IsFixed())
+ {
+ CLimitedInStream *streamSpec = new CLimitedInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->SetStream(Stream);
+ // fixme : check (startOffset = 0)
+ streamSpec->InitAndSeek(_startOffset, Footer.CurrentSize);
+ RINOK(streamSpec->SeekToStart())
+ *stream = streamTemp.Detach();
+ return S_OK;
+ }
+ if (!Footer.ThereIsDynamic() || !AreParentsOK())
+ return S_FALSE;
+ CMyComPtr<ISequentialInStream> streamTemp = this;
+ RINOK(InitAndSeek())
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "VHD", "vhd", NULL, 0xDC,
+ kSignature,
+ 0,
+ NArcInfoFlags::kUseGlobalOffset,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/VhdxHandler.cpp b/CPP/7zip/Archive/VhdxHandler.cpp
new file mode 100644
index 0000000..e3ddedd
--- /dev/null
+++ b/CPP/7zip/Archive/VhdxHandler.cpp
@@ -0,0 +1,2097 @@
+// VhdxHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "HandlerCont.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G32(_offs_, dest) dest = Get32(p + (_offs_))
+#define G64(_offs_, dest) dest = Get64(p + (_offs_))
+
+using namespace NWindows;
+
+
+EXTERN_C_BEGIN
+
+// CRC-32C (Castagnoli) : reversed for poly 0x1EDC6F41
+#define k_Crc32c_Poly 0x82f63b78
+
+static UInt32 g_Crc32c_Table[256];
+
+static void Z7_FASTCALL Crc32c_GenerateTable()
+{
+ UInt32 i;
+ for (i = 0; i < 256; i++)
+ {
+ UInt32 r = i;
+ unsigned j;
+ for (j = 0; j < 8; j++)
+ r = (r >> 1) ^ (k_Crc32c_Poly & ((UInt32)0 - (r & 1)));
+ g_Crc32c_Table[i] = r;
+ }
+}
+
+
+#define CRC32C_INIT_VAL 0xFFFFFFFF
+
+#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);
+static UInt32 Z7_FASTCALL CrcUpdateT1_vhdx(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;
+}
+
+static UInt32 Z7_FASTCALL Crc32c_Calc(const void *data, size_t size)
+{
+ return CrcUpdateT1_vhdx(CRC32C_INIT_VAL, data, size, g_Crc32c_Table) ^ CRC32C_INIT_VAL;
+}
+
+EXTERN_C_END
+
+
+namespace NArchive {
+namespace NVhdx {
+
+static struct C_CRC32c_TableInit { C_CRC32c_TableInit() { Crc32c_GenerateTable(); } } g_CRC32c_TableInit;
+
+static const unsigned kSignatureSize = 8;
+static const Byte kSignature[kSignatureSize] =
+ { 'v', 'h', 'd', 'x', 'f', 'i', 'l', 'e' };
+
+static const unsigned kBitmapSize_Log = 20;
+static const size_t kBitmapSize = (size_t)1 << kBitmapSize_Log;
+
+
+static bool IsZeroArr(const Byte *p, size_t size)
+{
+ for (size_t i = 0; i < size; i++)
+ if (p[i] != 0)
+ return false;
+ return true;
+}
+
+
+#define ValToHex(t) ((char)(((t) < 10) ? ('0' + (t)) : ('a' + ((t) - 10))))
+
+static void AddByteToHex2(unsigned val, UString &s)
+{
+ unsigned t;
+ t = val >> 4;
+ s += ValToHex(t);
+ t = val & 0xF;
+ s += ValToHex(t);
+}
+
+
+static int HexToVal(const wchar_t c)
+{
+ if (c >= '0' && c <= '9') return c - '0';
+ if (c >= 'a' && c <= 'z') return c - 'a' + 10;
+ if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
+ return -1;
+}
+
+static int DecodeFrom2HexChars(const wchar_t *s)
+{
+ const int v0 = HexToVal(s[0]); if (v0 < 0) return -1;
+ const int v1 = HexToVal(s[1]); if (v1 < 0) return -1;
+ return (int)(((unsigned)v0 << 4) | (unsigned)v1);
+}
+
+
+struct CGuid
+{
+ Byte Data[16];
+
+ bool IsZero() const { return IsZeroArr(Data, 16); }
+ bool IsEqualTo(const Byte *a) const { return memcmp(Data, a, 16) == 0; }
+ bool IsEqualTo(const CGuid &g) const { return IsEqualTo(g.Data); }
+ void AddHexToString(UString &s) const;
+
+ void SetFrom(const Byte *p) { memcpy(Data, p, 16); }
+
+ bool ParseFromFormatedHexString(const UString &s)
+ {
+ const unsigned kLen = 16 * 2 + 4 + 2;
+ if (s.Len() != kLen || s[0] != '{' || s[kLen - 1] != '}')
+ return false;
+ unsigned pos = 0;
+ for (unsigned i = 1; i < kLen - 1;)
+ {
+ if (i == 9 || i == 14 || i == 19 || i == 24)
+ {
+ if (s[i] != '-')
+ return false;
+ i++;
+ continue;
+ }
+ const int v = DecodeFrom2HexChars(s.Ptr(i));
+ if (v < 0)
+ return false;
+ unsigned pos2 = pos;
+ if (pos < 8)
+ pos2 ^= (pos < 4 ? 3 : 1);
+ Data[pos2] = (Byte)v;
+ pos++;
+ i += 2;
+ }
+ return true; // pos == 16;
+ }
+};
+
+void CGuid::AddHexToString(UString &s) const
+{
+ for (unsigned i = 0; i < 16; i++)
+ AddByteToHex2(Data[i], s);
+}
+
+
+#define IS_NON_ALIGNED(v) (((v) & 0xFFFFF) != 0)
+
+static const unsigned kHeader_GUID_Index_FileWriteGuid = 0;
+static const unsigned kHeader_GUID_Index_DataWriteGuid = 1;
+static const unsigned kHeader_GUID_Index_LogGuid = 2;
+
+struct CHeader
+{
+ UInt64 SequenceNumber;
+ // UInt16 LogVersion;
+ // UInt16 Version;
+ UInt32 LogLength;
+ UInt64 LogOffset;
+ CGuid Guids[3];
+
+ bool IsEqualTo(const CHeader &h) const
+ {
+ if (SequenceNumber != h.SequenceNumber)
+ return false;
+ if (LogLength != h.LogLength)
+ return false;
+ if (LogOffset != h.LogOffset)
+ return false;
+ for (unsigned i = 0; i < 3; i++)
+ if (!Guids[i].IsEqualTo(h.Guids[i]))
+ return false;
+ return true;
+ }
+
+ bool Parse(Byte *p);
+};
+
+static const unsigned kHeader2Size = 1 << 12;
+
+bool CHeader::Parse(Byte *p)
+{
+ if (Get32(p) != 0x64616568) // "head"
+ return false;
+ const UInt32 crc = Get32(p + 4);
+ SetUi32(p + 4, 0)
+ if (Crc32c_Calc(p, kHeader2Size) != crc)
+ return false;
+ G64(8, SequenceNumber);
+ for (unsigned i = 0; i < 3; i++)
+ Guids[i].SetFrom(p + 0x10 + 0x10 * i);
+ // LogVersion = Get16(p + 0x40);
+ /* LogVersion MUST be set to zero, for known log format
+ but we don't parse log so we ignore it */
+ G32(0x44, LogLength);
+ G64(0x48, LogOffset);
+ if (Get16(p + 0x42) != 1) // Header format Version
+ return false;
+ if (IS_NON_ALIGNED(LogLength))
+ return false;
+ if (IS_NON_ALIGNED(LogOffset))
+ return false;
+ return true;
+ // return IsZeroArr(p + 0x50, kHeader2Size - 0x50);
+}
+
+
+
+static const Byte kBat[16] =
+ { 0x66,0x77,0xC2,0x2D,0x23,0xF6,0x00,0x42,0x9D,0x64,0x11,0x5E,0x9B,0xFD,0x4A,0x08 };
+static const Byte kMetadataRegion[16] =
+ { 0x06,0xA2,0x7C,0x8B,0x90,0x47,0x9A,0x4B,0xB8,0xFE,0x57,0x5F,0x05,0x0F,0x88,0x6E };
+
+struct CRegionEntry
+{
+ // CGuid Guid;
+ UInt64 Offset;
+ UInt32 Len;
+ UInt32 Required;
+
+ UInt64 GetEndPos() const { return Offset + Len; }
+ bool Parse(const Byte *p);
+};
+
+bool CRegionEntry::Parse(const Byte *p)
+{
+ // Guid.SetFrom(p);
+ G64(0x10, Offset);
+ G32(0x18, Len);
+ G32(0x1c, Required);
+ if (IS_NON_ALIGNED(Offset))
+ return false;
+ if (IS_NON_ALIGNED(Len))
+ return false;
+ if (Offset + Len < Offset)
+ return false;
+ return true;
+}
+
+
+struct CRegion
+{
+ bool Bat_Defined;
+ bool Meta_Defined;
+ UInt64 EndPos;
+ UInt64 DataSize;
+
+ CRegionEntry BatEntry;
+ CRegionEntry MetaEntry;
+
+ bool Parse(Byte *p);
+};
+
+
+static const unsigned kRegionSize = 1 << 16;
+static const unsigned kNumRegionEntriesMax = (1 << 11) - 1;
+
+bool CRegion::Parse(Byte *p)
+{
+ Bat_Defined = false;
+ Meta_Defined = false;
+ EndPos = 0;
+ DataSize = 0;
+
+ if (Get32(p) != 0x69676572) // "regi"
+ return false;
+ const UInt32 crc = Get32(p + 4);
+ SetUi32(p + 4, 0)
+ const UInt32 crc_calced = Crc32c_Calc(p, kRegionSize);
+ if (crc_calced != crc)
+ return false;
+
+ const UInt32 EntryCount = Get32(p + 8);
+ if (Get32(p + 12) != 0) // reserved field must be set to 0.
+ return false;
+ if (EntryCount > kNumRegionEntriesMax)
+ return false;
+ for (UInt32 i = 0; i < EntryCount; i++)
+ {
+ CRegionEntry e;
+ const Byte *p2 = p + 0x10 + 0x20 * (size_t)i;
+ if (!e.Parse(p2))
+ return false;
+ DataSize += e.Len;
+ const UInt64 endPos = e.GetEndPos();
+ if (EndPos < endPos)
+ EndPos = endPos;
+ CGuid Guid;
+ Guid.SetFrom(p2);
+ if (Guid.IsEqualTo(kBat))
+ {
+ if (Bat_Defined)
+ return false;
+ BatEntry = e;
+ Bat_Defined = true;
+ }
+ else if (Guid.IsEqualTo(kMetadataRegion))
+ {
+ if (Meta_Defined)
+ return false;
+ MetaEntry = e;
+ Meta_Defined = true;
+ }
+ else
+ {
+ if (e.Required != 0)
+ return false;
+ // it's allowed to ignore unknown non-required region entries
+ }
+ }
+ /*
+ const size_t k = 0x10 + 0x20 * EntryCount;
+ return IsZeroArr(p + k, kRegionSize - k);
+ */
+ return true;
+}
+
+
+
+
+struct CMetaEntry
+{
+ CGuid Guid;
+ UInt32 Offset;
+ UInt32 Len;
+ UInt32 Flags0;
+ // UInt32 Flags1;
+
+ bool IsUser() const { return (Flags0 & 1) != 0; }
+ bool IsVirtualDisk() const { return (Flags0 & 2) != 0; }
+ bool IsRequired() const { return (Flags0 & 4) != 0; }
+
+ bool CheckLimit(size_t regionSize) const
+ {
+ return Offset <= regionSize && Len <= regionSize - Offset;
+ }
+
+ bool Parse(const Byte *p);
+};
+
+
+bool CMetaEntry::Parse(const Byte *p)
+{
+ Guid.SetFrom(p);
+
+ G32(0x10, Offset);
+ G32(0x14, Len);
+ G32(0x18, Flags0);
+ UInt32 Flags1;
+ G32(0x1C, Flags1);
+
+ if (Offset != 0 && Offset < (1 << 16))
+ return false;
+ if (Len > (1 << 20))
+ return false;
+ if (Len == 0 && Offset != 0)
+ return false;
+ if ((Flags0 >> 3) != 0) // Reserved
+ return false;
+ if ((Flags1 & 3) != 0) // Reserved2
+ return false;
+ return true;
+}
+
+
+struct CParentPair
+{
+ UString Key;
+ UString Value;
+};
+
+
+struct CMetaHeader
+{
+ // UInt16 EntryCount;
+ bool Guid_Defined;
+ bool VirtualDiskSize_Defined;
+ bool Locator_Defined;
+
+ unsigned BlockSize_Log;
+ unsigned LogicalSectorSize_Log;
+ unsigned PhysicalSectorSize_Log;
+
+ UInt32 Flags;
+ UInt64 VirtualDiskSize;
+ CGuid Guid;
+ // CGuid LocatorType;
+
+ CObjectVector<CParentPair> ParentPairs;
+
+ int FindParentKey(const char *name) const
+ {
+ FOR_VECTOR (i, ParentPairs)
+ {
+ const CParentPair &pair = ParentPairs[i];
+ if (pair.Key.IsEqualTo(name))
+ return (int)i;
+ }
+ return -1;
+ }
+
+ bool Is_LeaveBlockAllocated() const { return (Flags & 1) != 0; }
+ bool Is_HasParent() const { return (Flags & 2) != 0; }
+
+ void Clear()
+ {
+ Guid_Defined = false;
+ VirtualDiskSize_Defined = false;
+ Locator_Defined = false;
+ BlockSize_Log = 0;
+ LogicalSectorSize_Log = 0;
+ PhysicalSectorSize_Log = 0;
+ Flags = 0;
+ VirtualDiskSize = 0;
+ ParentPairs.Clear();
+ }
+
+ bool Parse(const Byte *p, size_t size);
+};
+
+
+static unsigned GetLogSize(UInt32 size)
+{
+ unsigned k;
+ for (k = 0; k < 32; k++)
+ if (((UInt32)1 << k) == size)
+ return k;
+ return k;
+}
+
+
+static const unsigned kMetadataSize = 8;
+static const Byte kMetadata[kMetadataSize] =
+ { 'm','e','t','a','d','a','t','a' };
+
+static const unsigned k_Num_MetaEntries_Max = (1 << 11) - 1;
+
+static const Byte kFileParameters[16] =
+ { 0x37,0x67,0xa1,0xca,0x36,0xfa,0x43,0x4d,0xb3,0xb6,0x33,0xf0,0xaa,0x44,0xe7,0x6b };
+static const Byte kVirtualDiskSize[16] =
+ { 0x24,0x42,0xa5,0x2f,0x1b,0xcd,0x76,0x48,0xb2,0x11,0x5d,0xbe,0xd8,0x3b,0xf4,0xb8 };
+static const Byte kVirtualDiskID[16] =
+ { 0xab,0x12,0xca,0xbe,0xe6,0xb2,0x23,0x45,0x93,0xef,0xc3,0x09,0xe0,0x00,0xc7,0x46 };
+static const Byte kLogicalSectorSize[16] =
+ { 0x1d,0xbf,0x41,0x81,0x6f,0xa9,0x09,0x47,0xba,0x47,0xf2,0x33,0xa8,0xfa,0xab,0x5f };
+static const Byte kPhysicalSectorSize[16] =
+ { 0xc7,0x48,0xa3,0xcd,0x5d,0x44,0x71,0x44,0x9c,0xc9,0xe9,0x88,0x52,0x51,0xc5,0x56 };
+static const Byte kParentLocator[16] =
+ { 0x2d,0x5f,0xd3,0xa8,0x0b,0xb3,0x4d,0x45,0xab,0xf7,0xd3,0xd8,0x48,0x34,0xab,0x0c };
+
+static bool GetString16(UString &s, const Byte *p, size_t size)
+{
+ s.Empty();
+ if (size & 1)
+ return false;
+ for (size_t i = 0; i < size; i += 2)
+ {
+ const wchar_t c = Get16(p + i);
+ if (c == 0)
+ return false;
+ s += c;
+ }
+ return true;
+}
+
+
+bool CMetaHeader::Parse(const Byte *p, size_t size)
+{
+ if (memcmp(p, kMetadata, kMetadataSize) != 0)
+ return false;
+ if (Get16(p + 8) != 0) // Reserved
+ return false;
+ const UInt32 EntryCount = Get16(p + 10);
+ if (EntryCount > k_Num_MetaEntries_Max)
+ return false;
+ if (!IsZeroArr(p + 12, 20)) // Reserved
+ return false;
+
+ for (unsigned i = 0; i < EntryCount; i++)
+ {
+ CMetaEntry e;
+ if (!e.Parse(p + 32 + 32 * (size_t)i))
+ return false;
+ if (!e.CheckLimit(size))
+ return false;
+ const Byte *p2 = p + e.Offset;
+
+ if (e.Guid.IsEqualTo(kFileParameters))
+ {
+ if (BlockSize_Log != 0)
+ return false;
+ if (e.Len != 8)
+ return false;
+ const UInt32 v = Get32(p2);
+ Flags = Get32(p2 + 4);
+ BlockSize_Log = GetLogSize(v);
+ if (BlockSize_Log < 20 || BlockSize_Log > 28) // specification from 1 MB to 256 MB
+ return false;
+ if ((Flags >> 2) != 0) // reserved
+ return false;
+ }
+ else if (e.Guid.IsEqualTo(kVirtualDiskSize))
+ {
+ if (VirtualDiskSize_Defined)
+ return false;
+ if (e.Len != 8)
+ return false;
+ VirtualDiskSize = Get64(p2);
+ VirtualDiskSize_Defined = true;
+ }
+ else if (e.Guid.IsEqualTo(kVirtualDiskID))
+ {
+ if (e.Len != 16)
+ return false;
+ Guid.SetFrom(p2);
+ Guid_Defined = true;
+ }
+ else if (e.Guid.IsEqualTo(kLogicalSectorSize))
+ {
+ if (LogicalSectorSize_Log != 0)
+ return false;
+ if (e.Len != 4)
+ return false;
+ const UInt32 v = Get32(p2);
+ LogicalSectorSize_Log = GetLogSize(v);
+ if (LogicalSectorSize_Log != 9 && LogicalSectorSize_Log != 12)
+ return false;
+ }
+ else if (e.Guid.IsEqualTo(kPhysicalSectorSize))
+ {
+ if (PhysicalSectorSize_Log != 0)
+ return false;
+ if (e.Len != 4)
+ return false;
+ const UInt32 v = Get32(p2);
+ PhysicalSectorSize_Log = GetLogSize(v);
+ if (PhysicalSectorSize_Log != 9 && PhysicalSectorSize_Log != 12)
+ return false;
+ }
+ else if (e.Guid.IsEqualTo(kParentLocator))
+ {
+ if (Locator_Defined)
+ return false;
+ if (e.Len < 20)
+ return false;
+ // LocatorType.SetFrom(p2);
+ /* Specifies the type of the parent virtual disk.
+ is different for each type: VHDX, VHD or iSCSI.
+ only "B04AEFB7-D19E-4A81-B789-25B8E9445913" (for VHDX) is supported now
+ */
+ Locator_Defined = true;
+ if (Get16(p2 + 16) != 0) // reserved
+ return false;
+ const UInt32 KeyValueCount = Get16(p2 + 18);
+ if (20 + (UInt32)KeyValueCount * 12 > e.Len)
+ return false;
+ for (unsigned k = 0; k < KeyValueCount; k++)
+ {
+ const Byte *p3 = p2 + 20 + (size_t)k * 12;
+ const UInt32 KeyOffset = Get32(p3);
+ const UInt32 ValueOffset = Get32(p3 + 4);
+ const UInt32 KeyLength = Get16(p3 + 8);
+ const UInt32 ValueLength = Get16(p3 + 10);
+ if (KeyOffset > e.Len || KeyLength > e.Len - KeyOffset)
+ return false;
+ if (ValueOffset > e.Len || ValueLength > e.Len - ValueOffset)
+ return false;
+ CParentPair pair;
+ if (!GetString16(pair.Key, p2 + KeyOffset, KeyLength))
+ return false;
+ if (!GetString16(pair.Value, p2 + ValueOffset, ValueLength))
+ return false;
+ ParentPairs.Add(pair);
+ }
+ }
+ else
+ {
+ if (e.IsRequired())
+ return false;
+ // return false; // unknown metadata;
+ }
+ }
+
+ // some properties are required for correct processing
+
+ if (BlockSize_Log == 0)
+ return false;
+ if (LogicalSectorSize_Log == 0)
+ return false;
+ if (!VirtualDiskSize_Defined)
+ return false;
+ if (((UInt32)VirtualDiskSize & ((UInt32)1 << LogicalSectorSize_Log)) != 0)
+ return false;
+
+ // vhdx specification sets limit for 64 TB.
+ // do we need to check over same limit ?
+ const UInt64 kVirtualDiskSize_Max = (UInt64)1 << 46;
+ if (VirtualDiskSize > kVirtualDiskSize_Max)
+ return false;
+
+ return true;
+}
+
+
+
+struct CBat
+{
+ CByteBuffer Data;
+
+ void Clear() { Data.Free(); }
+ UInt64 GetItem(size_t n) const
+ {
+ return Get64(Data + n * 8);
+ }
+};
+
+
+
+Z7_class_CHandler_final: public CHandlerImg
+{
+ UInt64 _phySize;
+
+ CBat Bat;
+ CObjectVector<CByteBuffer> BitMaps;
+
+ unsigned ChunkRatio_Log;
+ size_t ChunkRatio;
+ size_t TotalBatEntries;
+
+ CMetaHeader Meta;
+ CHeader Header;
+
+ UInt32 NumUsedBlocks;
+ UInt32 NumUsedBitMaps;
+ UInt64 HeadersSize;
+
+ UInt32 NumLevels;
+ UInt64 PackSize_Total;
+
+ /*
+ UInt64 NumUsed_1MB_Blocks; // data and bitmaps
+ bool NumUsed_1MB_Blocks_Defined;
+ */
+
+ CMyComPtr<IInStream> ParentStream;
+ CHandler *Parent;
+ UString _errorMessage;
+ UString _creator;
+
+ bool _nonEmptyLog;
+ bool _isDataContiguous;
+ // bool _batOverlap;
+
+ CGuid _parentGuid;
+ bool _parentGuid_IsDefined;
+ UStringVector ParentNames;
+ UString ParentName_Used;
+
+ const CHandler *_child;
+ unsigned _level;
+ bool _isCyclic;
+ bool _isCyclic_or_CyclicParent;
+
+ void AddErrorMessage(const char *message);
+ void AddErrorMessage(const char *message, const wchar_t *name);
+
+ void UpdatePhySize(UInt64 value)
+ {
+ if (_phySize < value)
+ _phySize = value;
+ }
+
+ HRESULT Seek2(UInt64 offset);
+ HRESULT Read_FALSE(Byte *data, size_t size)
+ {
+ return ReadStream_FALSE(Stream, data, size);
+ }
+ HRESULT ReadToBuf_FALSE(CByteBuffer &buf, size_t size)
+ {
+ buf.Alloc(size);
+ return ReadStream_FALSE(Stream, buf, size);
+ }
+
+ void InitSeekPositions();
+ HRESULT ReadPhy(UInt64 offset, void *data, UInt32 size, UInt32 &processed);
+
+ bool IsDiff() const
+ {
+ // here we suppose that only HasParent() flag is mandatory for Diff archive type
+ return Meta.Is_HasParent();
+ // return _parentGuid_IsDefined;
+ }
+
+ void AddTypeString(AString &s) const
+ {
+ if (IsDiff())
+ s += "Differencing";
+ else
+ {
+ if (Meta.Is_LeaveBlockAllocated())
+ s += _isDataContiguous ? "fixed" : "fixed-non-cont";
+ else
+ s += "dynamic";
+ }
+ }
+
+ void AddComment(UString &s) const;
+
+ UInt64 GetPackSize() const
+ {
+ return (UInt64)NumUsedBlocks << Meta.BlockSize_Log;
+ }
+
+ UString GetParentSequence() const
+ {
+ const CHandler *p = this;
+ UString res;
+ while (p && p->IsDiff())
+ {
+ if (!res.IsEmpty())
+ res += " -> ";
+ res += ParentName_Used;
+ p = p->Parent;
+ }
+ return res;
+ }
+
+ bool AreParentsOK() const
+ {
+ if (_isCyclic_or_CyclicParent)
+ return false;
+ const CHandler *p = this;
+ while (p->IsDiff())
+ {
+ p = p->Parent;
+ if (!p)
+ return false;
+ }
+ return true;
+ }
+
+ // bool ParseLog(CByteBuffer &log);
+ bool ParseBat();
+ bool CheckBat();
+
+ HRESULT Open3();
+ HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCallback) Z7_override;
+ HRESULT OpenParent(IArchiveOpenCallback *openArchiveCallback, bool &_parentFileWasOpen);
+ virtual void CloseAtError() Z7_override;
+
+public:
+ Z7_IFACE_COM7_IMP(IInArchive_Img)
+
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ CHandler():
+ _child(NULL),
+ _level(0),
+ _isCyclic(false),
+ _isCyclic_or_CyclicParent(false)
+ {}
+};
+
+
+HRESULT CHandler::Seek2(UInt64 offset)
+{
+ return InStream_SeekSet(Stream, offset);
+}
+
+
+void CHandler::InitSeekPositions()
+{
+ /* (_virtPos) and (_posInArc) is used only in Read() (that calls ReadPhy()).
+ So we must reset these variables before first call of Read() */
+ Reset_VirtPos();
+ Reset_PosInArc();
+ if (ParentStream)
+ Parent->InitSeekPositions();
+}
+
+
+HRESULT CHandler::ReadPhy(UInt64 offset, void *data, UInt32 size, UInt32 &processed)
+{
+ processed = 0;
+ if (offset > _phySize
+ || offset + size > _phySize)
+ {
+ // we don't expect these cases, if (_phySize) was set correctly.
+ return S_FALSE;
+ }
+ if (offset != _posInArc)
+ {
+ const HRESULT res = Seek2(offset);
+ if (res != S_OK)
+ {
+ Reset_PosInArc(); // we don't trust seek_pos in case of error
+ return res;
+ }
+ _posInArc = offset;
+ }
+ {
+ size_t size2 = size;
+ const HRESULT res = ReadStream(Stream, data, &size2);
+ processed = (UInt32)size2;
+ _posInArc += size2;
+ if (res != S_OK)
+ Reset_PosInArc(); // we don't trust seek_pos in case of reading error
+ return res;
+ }
+}
+
+
+#define PAYLOAD_BLOCK_NOT_PRESENT 0
+#define PAYLOAD_BLOCK_UNDEFINED 1
+#define PAYLOAD_BLOCK_ZERO 2
+#define PAYLOAD_BLOCK_UNMAPPED 3
+#define PAYLOAD_BLOCK_FULLY_PRESENT 6
+#define PAYLOAD_BLOCK_PARTIALLY_PRESENT 7
+
+#define SB_BLOCK_NOT_PRESENT 0
+#define SB_BLOCK_PRESENT 6
+
+#define BAT_GET_OFFSET(v) ((v) & ~(UInt64)0xFFFFF)
+#define BAT_GET_STATE(v) ((UInt32)(v) & 7)
+
+/* The log contains only updates to metadata, bat and region tables
+ The log doesn't contain updates to start header, and 2 headers (first 192 KB of file).
+ The log is array of 4 KB blocks and each block has 4-byte signature.
+ So it's possible to scan whole log to find the latest entry sequence (and header for replay).
+*/
+
+/*
+struct CLogEntry
+{
+ UInt32 EntryLength;
+ UInt32 Tail;
+ UInt64 SequenceNumber;
+ CGuid LogGuid;
+ UInt32 DescriptorCount;
+ UInt64 FlushedFileOffset;
+ UInt64 LastFileOffset;
+
+ bool Parse(const Byte *p);
+};
+
+bool CLogEntry::Parse(const Byte *p)
+{
+ G32 (8, EntryLength);
+ G32 (12,Tail);
+ G64 (16, SequenceNumber);
+ G32 (24, DescriptorCount); // it's 32-bit, but specification says 64-bit
+ if (Get32(p + 28) != 0) // reserved
+ return false;
+ LogGuid.SetFrom(p + 32);
+ G64 (48, FlushedFileOffset);
+ G64 (56, LastFileOffset);
+
+ if (SequenceNumber == 0)
+ return false;
+ if ((Tail & 0xfff) != 0)
+ return false;
+ if (IS_NON_ALIGNED(FlushedFileOffset))
+ return false;
+ if (IS_NON_ALIGNED(LastFileOffset))
+ return false;
+ return true;
+}
+
+
+bool CHandler::ParseLog(CByteBuffer &log)
+{
+ CLogEntry lastEntry;
+ lastEntry.SequenceNumber = 0;
+ bool lastEntry_found = false;
+ size_t lastEntry_Offset = 0;
+ for (size_t i = 0; i < log.Size(); i += 1 << 12)
+ {
+ Byte *p = (Byte *)(log + i);
+
+ if (Get32(p) != 0x65676F6C) // "loge"
+ continue;
+ const UInt32 crc = Get32(p + 4);
+
+ CLogEntry e;
+ if (!e.Parse(p))
+ {
+ return false;
+ continue;
+ }
+ const UInt32 entryLength = Get32(p + 8);
+ if (e.EntryLength > log.Size() || (e.EntryLength & 0xFFF) != 0 || e.EntryLength == 0)
+ {
+ return false;
+ continue;
+ }
+ SetUi32(p + 4, 0);
+ const UInt32 crc_calced = Crc32c_Calc(p, entryLength);
+ SetUi32(p + 4, crc); // we must restore crc if we want same data in log
+ if (crc_calced != crc)
+ continue;
+ if (!lastEntry_found || lastEntry.SequenceNumber < e.SequenceNumber)
+ {
+ lastEntry = e;
+ lastEntry_found = true;
+ lastEntry_Offset = i;
+ }
+ }
+
+ return true;
+}
+*/
+
+
+bool CHandler::ParseBat()
+{
+ ChunkRatio_Log = kBitmapSize_Log + 3 + Meta.LogicalSectorSize_Log - Meta.BlockSize_Log;
+ ChunkRatio = (size_t)1 << (ChunkRatio_Log);
+
+ UInt64 totalBatEntries64;
+ const bool isDiff = IsDiff();
+ const UInt32 blockSize = (UInt32)1 << Meta.BlockSize_Log;
+ {
+ const UInt64 up = Meta.VirtualDiskSize + blockSize - 1;
+ if (up < Meta.VirtualDiskSize)
+ return false;
+ const UInt64 numDataBlocks = up >> Meta.BlockSize_Log;
+
+ if (isDiff)
+ {
+ // differencing table must be finished with bitmap entry
+ const UInt64 numBitmaps = (numDataBlocks + ChunkRatio - 1) >> ChunkRatio_Log;
+ totalBatEntries64 = numBitmaps * (ChunkRatio + 1);
+ }
+ else
+ {
+ // we don't need last Bitmap entry
+ totalBatEntries64 = numDataBlocks + ((numDataBlocks - 1) >> ChunkRatio_Log);
+ }
+ }
+
+ if (totalBatEntries64 > Bat.Data.Size() / 8)
+ return false;
+
+ const size_t totalBatEntries = (size_t)totalBatEntries64;
+ TotalBatEntries = totalBatEntries;
+
+ bool isCont = (!isDiff && Meta.Is_LeaveBlockAllocated());
+ UInt64 prevBlockOffset = 0;
+ UInt64 maxBlockOffset = 0;
+
+ size_t remEntries = ChunkRatio + 1;
+
+ size_t i;
+ for (i = 0; i < totalBatEntries; i++)
+ {
+ const UInt64 v = Bat.GetItem(i);
+ if ((v & 0xFFFF8) != 0)
+ return false;
+ const UInt64 offset = BAT_GET_OFFSET(v);
+ const unsigned state = BAT_GET_STATE(v);
+
+ /*
+ UInt64 index64 = v >> 20;
+ printf("\n%7d", i);
+ printf("%10d, ", (unsigned)index64);
+ printf("%4x, ", (unsigned)state);
+ */
+
+ remEntries--;
+ if (remEntries == 0)
+ {
+ // printf(" ========");
+ // printf("\n");
+ remEntries = ChunkRatio + 1;
+ if (state == SB_BLOCK_PRESENT)
+ {
+ isCont = false;
+ if (!isDiff)
+ return false;
+ if (offset == 0)
+ return false;
+ const UInt64 lim = offset + kBitmapSize;
+ if (lim < offset)
+ return false;
+ if (_phySize < lim)
+ _phySize = lim;
+ NumUsedBitMaps++;
+ }
+ else if (state != SB_BLOCK_NOT_PRESENT)
+ return false;
+ }
+ else
+ {
+ if (state == PAYLOAD_BLOCK_FULLY_PRESENT
+ || state == PAYLOAD_BLOCK_PARTIALLY_PRESENT)
+ {
+ if (offset == 0)
+ return false;
+ if (maxBlockOffset < offset)
+ maxBlockOffset = offset;
+
+ if (state == PAYLOAD_BLOCK_PARTIALLY_PRESENT)
+ {
+ isCont = false;
+ if (!isDiff)
+ return false;
+ }
+ else if (isCont)
+ {
+ if (prevBlockOffset != 0 && prevBlockOffset + blockSize != offset)
+ isCont = false;
+ else
+ prevBlockOffset = offset;
+ }
+
+ NumUsedBlocks++;
+ }
+ else if (state == PAYLOAD_BLOCK_UNMAPPED)
+ {
+ isCont = false;
+ // non-empty (offset) is allowed
+ }
+ else if (state == PAYLOAD_BLOCK_NOT_PRESENT
+ || state == PAYLOAD_BLOCK_UNDEFINED
+ || state == PAYLOAD_BLOCK_ZERO)
+ {
+ isCont = false;
+ /* (offset) is reserved and (offset == 0) is expected here,
+ but we ignore (offset) here */
+ // if (offset != 0) return false;
+ }
+ else
+ return false;
+ }
+ }
+
+ _isDataContiguous = isCont;
+
+ if (maxBlockOffset != 0)
+ {
+ const UInt64 lim = maxBlockOffset + blockSize;
+ if (lim < maxBlockOffset)
+ return false;
+ if (_phySize < lim)
+ _phySize = lim;
+ const UInt64 kPhyLimit = (UInt64)1 << 62;
+ if (maxBlockOffset >= kPhyLimit)
+ return false;
+ }
+ return true;
+}
+
+
+bool CHandler::CheckBat()
+{
+ const UInt64 upSize = _phySize + kBitmapSize * 8 - 1;
+ if (upSize < _phySize)
+ return false;
+ const UInt64 useMapSize64 = upSize >> (kBitmapSize_Log + 3);
+ const size_t useMapSize = (size_t)useMapSize64;
+
+ const UInt32 blockSizeMB = (UInt32)1 << (Meta.BlockSize_Log - kBitmapSize_Log);
+
+ // we don't check useMap, if it's too big.
+ if (useMapSize != useMapSize64)
+ return true;
+ if (useMapSize == 0 || useMapSize > ((size_t)1 << 28))
+ return true;
+
+ CByteArr useMap;
+ useMap.Alloc(useMapSize);
+ memset(useMap, 0, useMapSize);
+ // useMap[0] = (Byte)(1 << 0); // first 1 MB is used by headers
+ // we can also update useMap for log, and region data.
+
+ const size_t totalBatEntries = TotalBatEntries;
+ size_t remEntries = ChunkRatio + 1;
+
+ size_t i;
+ for (i = 0; i < totalBatEntries; i++)
+ {
+ const UInt64 v = Bat.GetItem(i);
+ const UInt64 offset = BAT_GET_OFFSET(v);
+ const unsigned state = BAT_GET_STATE(v);
+ const UInt64 index = offset >> kBitmapSize_Log;
+ UInt32 numBlocks = 1;
+ remEntries--;
+ if (remEntries == 0)
+ {
+ remEntries = ChunkRatio + 1;
+ if (state != SB_BLOCK_PRESENT)
+ continue;
+ }
+ else
+ {
+ if (state != PAYLOAD_BLOCK_FULLY_PRESENT &&
+ state != PAYLOAD_BLOCK_PARTIALLY_PRESENT)
+ continue;
+ numBlocks = blockSizeMB;
+ }
+
+ for (unsigned k = 0; k < numBlocks; k++)
+ {
+ const UInt64 index2 = index + k;
+ const unsigned flag = (unsigned)1 << ((unsigned)index2 & 7);
+ const size_t byteIndex = (size_t)(index2 >> 3);
+ if (byteIndex >= useMapSize)
+ return false;
+ const unsigned m = useMap[byteIndex];
+ if (m & flag)
+ return false;
+ useMap[byteIndex] = (Byte)(m | flag);
+ }
+ }
+
+ /*
+ UInt64 num = 0;
+ for (i = 0; i < useMapSize; i++)
+ {
+ Byte b = useMap[i];
+ unsigned t = 0;
+ t += (b & 1); b >>= 1;
+ t += (b & 1); b >>= 1;
+ t += (b & 1); b >>= 1;
+ t += (b & 1); b >>= 1;
+ t += (b & 1); b >>= 1;
+ t += (b & 1); b >>= 1;
+ t += (b & 1); b >>= 1;
+ t += (b & 1);
+ num += t;
+ }
+ NumUsed_1MB_Blocks = num;
+ NumUsed_1MB_Blocks_Defined = true;
+ */
+
+ return true;
+}
+
+
+
+HRESULT CHandler::Open3()
+{
+ {
+ const unsigned kHeaderSize = 512; // + 8
+ Byte header[kHeaderSize];
+
+ RINOK(Read_FALSE(header, kHeaderSize))
+
+ if (memcmp(header, kSignature, kSignatureSize) != 0)
+ return S_FALSE;
+
+ const Byte *p = &header[0];
+ for (unsigned i = kSignatureSize; i < kHeaderSize; i += 2)
+ {
+ const wchar_t c = Get16(p + i);
+ if (c < 0x20 || c > 0x7F)
+ break;
+ _creator += c;
+ }
+ }
+
+ HeadersSize = (UInt32)1 << 20;
+ CHeader headers[2];
+ {
+ Byte header[kHeader2Size];
+ for (unsigned i = 0; i < 2; i++)
+ {
+ RINOK(Seek2((1 << 16) * (1 + i)))
+ RINOK(Read_FALSE(header, kHeader2Size))
+ bool headerIsOK = headers[i].Parse(header);
+ if (!headerIsOK)
+ return S_FALSE;
+ }
+ }
+ unsigned mainIndex;
+ if (headers[0].SequenceNumber > headers[1].SequenceNumber) mainIndex = 0;
+ else if (headers[0].SequenceNumber < headers[1].SequenceNumber) mainIndex = 1;
+ else
+ {
+ /* Disk2vhd v2.02 can create image with 2 full copies of headers.
+ It's violation of VHDX specification:
+ "A header is current if it is the only valid header
+ or if it is valid and its SequenceNumber field is
+ greater than the other header's SequenceNumber".
+ but we support such Disk2vhd archives. */
+ if (!headers[0].IsEqualTo(headers[1]))
+ return S_FALSE;
+ mainIndex = 0;
+ }
+
+ const CHeader &h = headers[mainIndex];
+ Header = h;
+ if (h.LogLength != 0)
+ {
+ HeadersSize += h.LogLength;
+ UpdatePhySize(h.LogOffset + h.LogLength);
+ if (!h.Guids[kHeader_GUID_Index_LogGuid].IsZero())
+ {
+ _nonEmptyLog = true;
+ AddErrorMessage("non-empty LOG was not replayed");
+ /*
+ if (h.LogVersion != 0)
+ AddErrorMessage("unknown LogVresion");
+ else
+ {
+ CByteBuffer log;
+ RINOK(Seek2(h.LogOffset));
+ RINOK(ReadToBuf_FALSE(log, h.LogLength));
+ if (!ParseLog(log))
+ {
+ return S_FALSE;
+ }
+ }
+ */
+ }
+ }
+ CRegion regions[2];
+ int correctRegionIndex = -1;
+
+ {
+ CByteBuffer temp;
+ temp.Alloc(kRegionSize * 2);
+ RINOK(Seek2((1 << 16) * 3))
+ RINOK(Read_FALSE(temp, kRegionSize * 2))
+ unsigned numTables = 1;
+ if (memcmp(temp, temp + kRegionSize, kRegionSize) != 0)
+ {
+ AddErrorMessage("Region tables mismatch");
+ numTables = 2;
+ }
+
+ for (unsigned i = 0; i < numTables; i++)
+ {
+ // RINOK(Seek2((1 << 16) * (3 + i)));
+ // RINOK(Read_FALSE(temp, kRegionSize));
+ if (regions[i].Parse(temp))
+ {
+ if (correctRegionIndex < 0)
+ correctRegionIndex = (int)i;
+ }
+ else
+ {
+ AddErrorMessage("Incorrect region table");
+ }
+ }
+ if (correctRegionIndex < 0)
+ return S_FALSE;
+ /*
+ if (!regions[0].IsEqualTo(regions[1]))
+ return S_FALSE;
+ */
+ }
+
+ // UpdatePhySize((1 << 16) * 5);
+ UpdatePhySize(1 << 20);
+
+ {
+ const CRegion ®ion = regions[correctRegionIndex];
+ HeadersSize += region.DataSize;
+ UpdatePhySize(region.EndPos);
+ {
+ if (!region.Meta_Defined)
+ return S_FALSE;
+ const CRegionEntry &e = region.MetaEntry;
+ if (e.Len == 0)
+ return S_FALSE;
+ {
+ // static const kMetaTableSize = 1 << 16;
+ CByteBuffer temp;
+ {
+ RINOK(Seek2(e.Offset))
+ RINOK(ReadToBuf_FALSE(temp, e.Len))
+ }
+ if (!Meta.Parse(temp, temp.Size()))
+ return S_FALSE;
+ }
+ // UpdatePhySize(e.GetEndPos());
+ }
+ {
+ if (!region.Bat_Defined)
+ return S_FALSE;
+ const CRegionEntry &e = region.BatEntry;
+ if (e.Len == 0)
+ return S_FALSE;
+ // UpdatePhySize(e.GetEndPos());
+ {
+ RINOK(Seek2(e.Offset))
+ RINOK(ReadToBuf_FALSE(Bat.Data, e.Len))
+ }
+ if (!ParseBat())
+ return S_FALSE;
+ if (!CheckBat())
+ {
+ AddErrorMessage("BAT overlap");
+ // _batOverlap = true;
+ // return S_FALSE;
+ }
+ }
+ }
+
+ {
+ // do we need to check "parent_linkage2" also?
+ FOR_VECTOR (i, Meta.ParentPairs)
+ {
+ const CParentPair &pair = Meta.ParentPairs[i];
+ if (pair.Key.IsEqualTo("parent_linkage"))
+ {
+ _parentGuid_IsDefined = _parentGuid.ParseFromFormatedHexString(pair.Value);
+ break;
+ }
+ }
+ }
+
+ {
+ // absolute paths for parent stream can be rejected later in client callback
+ // the order of check by specification:
+ const char * const g_ParentKeys[] =
+ {
+ "relative_path" // "..\..\path2\sub3\parent.vhdx"
+ , "volume_path" // "\\?\Volume{26A21BDA-A627-11D7-9931-806E6F6E6963}\path2\sub3\parent.vhdx")
+ , "absolute_win32_path" // "d:\path2\sub3\parent.vhdx"
+ };
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_ParentKeys); i++)
+ {
+ const int index = Meta.FindParentKey(g_ParentKeys[i]);
+ if (index < 0)
+ continue;
+ ParentNames.Add(Meta.ParentPairs[index].Value);
+ }
+ }
+
+ if (Meta.Is_HasParent())
+ {
+ if (!Meta.Locator_Defined)
+ AddErrorMessage("Parent locator is not defined");
+ else
+ {
+ if (!_parentGuid_IsDefined)
+ AddErrorMessage("Parent GUID is not defined");
+ if (ParentNames.IsEmpty())
+ AddErrorMessage("Parent VHDX file name is not defined");
+ }
+ }
+ else
+ {
+ if (Meta.Locator_Defined)
+ AddErrorMessage("Unexpected parent locator");
+ }
+
+ // here we suppose that and locator can be used only with HasParent flag
+
+ // return S_FALSE;
+
+ _size = Meta.VirtualDiskSize; // CHandlerImg
+
+ // _posInArc = 0;
+ // Reset_PosInArc();
+ // RINOK(InStream_SeekToBegin(Stream))
+
+ return S_OK;
+}
+
+
+/*
+static UInt32 g_NumCalls = 0;
+static UInt32 g_NumCalls2 = 0;
+static struct CCounter { ~CCounter()
+{
+ printf("\nNumCalls = %10u\n", g_NumCalls);
+ printf("NumCalls2 = %10u\n", g_NumCalls2);
+} } g_Counter;
+*/
+
+Z7_COM7F_IMF(CHandler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ // g_NumCalls++;
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= Meta.VirtualDiskSize)
+ return S_OK;
+ {
+ const UInt64 rem = Meta.VirtualDiskSize - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+ const size_t blockIndex = (size_t)(_virtPos >> Meta.BlockSize_Log);
+ const size_t chunkIndex = blockIndex >> ChunkRatio_Log;
+ const size_t chunkRatio = (size_t)1 << ChunkRatio_Log;
+ const size_t blockIndex2 = chunkIndex * (chunkRatio + 1) + (blockIndex & (chunkRatio - 1));
+ const UInt64 blockSectVal = Bat.GetItem(blockIndex2);
+ const UInt64 blockOffset = BAT_GET_OFFSET(blockSectVal);
+ const UInt32 blockState = BAT_GET_STATE(blockSectVal);
+
+ const UInt32 blockSize = (UInt32)1 << Meta.BlockSize_Log;
+ const UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
+ size = MyMin(blockSize - offsetInBlock, size);
+
+ bool needParent = false;
+ bool needRead = false;
+
+ if (blockState == PAYLOAD_BLOCK_FULLY_PRESENT)
+ needRead = true;
+ else if (blockState == PAYLOAD_BLOCK_NOT_PRESENT)
+ {
+ /* for a differencing VHDX: parent virtual disk SHOULD be
+ inspected to determine the associated contents (SPECIFICATION).
+ we suppose that we should not check BitMap.
+ for fixed or dynamic VHDX files: the block contents are undefined and
+ can contain arbitrary data (SPECIFICATION). NTFS::pagefile.sys can use such state. */
+ if (IsDiff())
+ needParent = true;
+ }
+ else if (blockState == PAYLOAD_BLOCK_PARTIALLY_PRESENT)
+ {
+ // only allowed for differencing VHDX files.
+ // associated sector bitmap block MUST be valid
+ if (chunkIndex >= BitMaps.Size())
+ return S_FALSE;
+ // else
+ {
+ const CByteBuffer &bitmap = BitMaps[(unsigned)chunkIndex];
+ const Byte *p = (const Byte *)bitmap;
+ if (!p)
+ return S_FALSE;
+ // else
+ {
+ // g_NumCalls2++;
+ const UInt64 sectorIndex = _virtPos >> Meta.LogicalSectorSize_Log;
+
+ #define BIT_MAP_UNIT_LOG 3 // it's for small block (4 KB)
+ // #define BIT_MAP_UNIT_LOG 5 // speed optimization for large blocks (16 KB)
+
+ const size_t offs = (size_t)(sectorIndex >> 3) &
+ (
+ (kBitmapSize - 1)
+ & ~(((UInt32)1 << (BIT_MAP_UNIT_LOG - 3)) - 1)
+ );
+
+ unsigned sector2 = (unsigned)sectorIndex & ((1 << BIT_MAP_UNIT_LOG) - 1);
+ #if BIT_MAP_UNIT_LOG == 5
+ UInt32 v = GetUi32(p + offs) >> sector2;
+ #else
+ unsigned v = (unsigned)p[offs] >> sector2;
+ #endif
+ // UInt32 v = GetUi32(p + offs) >> sector2;
+ const UInt32 sectorSize = (UInt32)1 << Meta.LogicalSectorSize_Log;
+ const UInt32 offsetInSector = (UInt32)_virtPos & (sectorSize - 1);
+ const unsigned bit = (unsigned)(v & 1);
+ if (bit)
+ needRead = true;
+ else
+ needParent = true; // zero - from the parent VHDX file
+ UInt32 rem = sectorSize - offsetInSector;
+ for (sector2++; sector2 < (1 << BIT_MAP_UNIT_LOG); sector2++)
+ {
+ v >>= 1;
+ if (bit != (v & 1))
+ break;
+ rem += sectorSize;
+ }
+ if (size > rem)
+ size = rem;
+ }
+ }
+ }
+
+ bool needZero = true;
+
+ HRESULT res = S_OK;
+
+ if (needParent)
+ {
+ if (!ParentStream)
+ return S_FALSE;
+ // if (ParentStream)
+ {
+ RINOK(InStream_SeekSet(ParentStream, _virtPos))
+ size_t processed = size;
+ res = ReadStream(ParentStream, (Byte *)data, &processed);
+ size = (UInt32)processed;
+ needZero = false;
+ }
+ }
+ else if (needRead)
+ {
+ UInt32 processed = 0;
+ res = ReadPhy(blockOffset + offsetInBlock, data, size, processed);
+ size = processed;
+ needZero = false;
+ }
+
+ if (needZero)
+ memset(data, 0, size);
+
+ if (processedSize)
+ *processedSize = size;
+
+ _virtPos += size;
+ return res;
+}
+
+
+enum
+{
+ kpidParent = kpidUserDefined
+};
+
+static const CStatProp kArcProps[] =
+{
+ { NULL, kpidClusterSize, VT_UI4},
+ { NULL, kpidSectorSize, VT_UI4},
+ { NULL, kpidMethod, VT_BSTR},
+ { NULL, kpidNumVolumes, VT_UI4},
+ { NULL, kpidTotalPhySize, VT_UI8},
+ { "Parent", kpidParent, VT_BSTR},
+ { NULL, kpidCreatorApp, VT_BSTR},
+ { NULL, kpidComment, VT_BSTR},
+ { NULL, kpidId, VT_BSTR}
+ };
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+
+void CHandler::AddErrorMessage(const char *message)
+{
+ if (!_errorMessage.IsEmpty())
+ _errorMessage.Add_LF();
+ _errorMessage += message;
+}
+
+void CHandler::AddErrorMessage(const char *message, const wchar_t *name)
+{
+ AddErrorMessage(message);
+ _errorMessage += name;
+}
+
+
+static void AddComment_Name(UString &s, const char *name)
+{
+ s += name;
+ s += ": ";
+}
+
+static void AddComment_Bool(UString &s, const char *name, bool val)
+{
+ AddComment_Name(s, name);
+ s += val ? "+" : "-";
+ s.Add_LF();
+}
+
+static void AddComment_UInt64(UString &s, const char *name, UInt64 v, bool showMB = false)
+{
+ AddComment_Name(s, name);
+ s.Add_UInt64(v);
+ if (showMB)
+ {
+ s += " (";
+ s.Add_UInt64(v >> 20);
+ s += " MiB)";
+ }
+ s.Add_LF();
+}
+
+static void AddComment_BlockSize(UString &s, const char *name, unsigned logSize)
+{
+ if (logSize != 0)
+ AddComment_UInt64(s, name, ((UInt64)1 << logSize));
+}
+
+
+void CHandler::AddComment(UString &s) const
+{
+ AddComment_UInt64(s, "VirtualDiskSize", Meta.VirtualDiskSize);
+ AddComment_UInt64(s, "PhysicalSize", _phySize);
+
+ if (!_errorMessage.IsEmpty())
+ {
+ AddComment_Name(s, "Error");
+ s += _errorMessage;
+ s.Add_LF();
+ }
+
+ if (Meta.Guid_Defined)
+ {
+ AddComment_Name(s, "Id");
+ Meta.Guid.AddHexToString(s);
+ s.Add_LF();
+ }
+
+ AddComment_UInt64(s, "SequenceNumber", Header.SequenceNumber);
+ AddComment_UInt64(s, "LogLength", Header.LogLength, true);
+
+ for (unsigned i = 0; i < 3; i++)
+ {
+ const CGuid &g = Header.Guids[i];
+ if (g.IsZero())
+ continue;
+ if (i == 0)
+ s += "FileWrite";
+ else if (i == 1)
+ s += "DataWrite";
+ else
+ s += "Log";
+ AddComment_Name(s, "Guid");
+ g.AddHexToString(s);
+ s.Add_LF();
+ }
+
+ AddComment_Bool(s, "HasParent", Meta.Is_HasParent());
+ AddComment_Bool(s, "Fixed", Meta.Is_LeaveBlockAllocated());
+ if (Meta.Is_LeaveBlockAllocated())
+ AddComment_Bool(s, "DataContiguous", _isDataContiguous);
+
+ AddComment_BlockSize(s, "BlockSize", Meta.BlockSize_Log);
+ AddComment_BlockSize(s, "LogicalSectorSize", Meta.LogicalSectorSize_Log);
+ AddComment_BlockSize(s, "PhysicalSectorSize", Meta.PhysicalSectorSize_Log);
+
+ {
+ const UInt64 packSize = GetPackSize();
+ AddComment_UInt64(s, "PackSize", packSize, true);
+ const UInt64 headersSize = HeadersSize + ((UInt64)NumUsedBitMaps << kBitmapSize_Log);
+ AddComment_UInt64(s, "HeadersSize", headersSize, true);
+ AddComment_UInt64(s, "FreeSpace", _phySize - packSize - headersSize, true);
+ /*
+ if (NumUsed_1MB_Blocks_Defined)
+ AddComment_UInt64(s, "used2", (NumUsed_1MB_Blocks << 20));
+ */
+ }
+
+ if (Meta.ParentPairs.Size() != 0)
+ {
+ s += "Parent:";
+ s.Add_LF();
+ FOR_VECTOR(i, Meta.ParentPairs)
+ {
+ const CParentPair &pair = Meta.ParentPairs[i];
+ s += " ";
+ s += pair.Key;
+ s += ": ";
+ s += pair.Value;
+ s.Add_LF();
+ }
+ s.Add_LF();
+ }
+}
+
+
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidClusterSize: prop = (UInt32)1 << Meta.BlockSize_Log; break;
+ case kpidSectorSize: prop = (UInt32)1 << Meta.LogicalSectorSize_Log; break;
+ case kpidShortComment:
+ case kpidMethod:
+ {
+ AString s;
+ AddTypeString(s);
+ if (IsDiff())
+ {
+ s += " -> ";
+ const CHandler *p = this;
+ while (p && p->IsDiff())
+ p = p->Parent;
+ if (!p)
+ s += '?';
+ else
+ p->AddTypeString(s);
+ }
+ prop = s;
+ break;
+ }
+ case kpidComment:
+ {
+ UString s;
+ {
+ if (NumLevels > 1)
+ {
+ AddComment_UInt64(s, "NumVolumeLevels", NumLevels);
+ AddComment_UInt64(s, "PackSizeTotal", PackSize_Total, true);
+ s += "----";
+ s.Add_LF();
+ }
+
+ const CHandler *p = this;
+ for (;;)
+ {
+ if (p->_level != 0 || p->Parent)
+ AddComment_UInt64(s, "VolumeLevel", p->_level + 1);
+ p->AddComment(s);
+ if (!p->Parent)
+ break;
+ s += "----";
+ s.Add_LF();
+ {
+ s.Add_LF();
+ if (!p->ParentName_Used.IsEmpty())
+ {
+ AddComment_Name(s, "Name");
+ s += p->ParentName_Used;
+ s.Add_LF();
+ }
+ }
+ p = p->Parent;
+ }
+ }
+ prop = s;
+ break;
+ }
+ case kpidCreatorApp:
+ {
+ if (!_creator.IsEmpty())
+ prop = _creator;
+ break;
+ }
+ case kpidId:
+ {
+ if (Meta.Guid_Defined)
+ {
+ UString s;
+ Meta.Guid.AddHexToString(s);
+ prop = s;
+ }
+ break;
+ }
+ case kpidName:
+ {
+ if (Meta.Guid_Defined)
+ {
+ UString s;
+ Meta.Guid.AddHexToString(s);
+ s += ".vhdx";
+ prop = s;
+ }
+ break;
+ }
+ case kpidParent: if (IsDiff()) prop = GetParentSequence(); break;
+ case kpidPhySize: prop = _phySize; break;
+ case kpidTotalPhySize:
+ {
+ const CHandler *p = this;
+ UInt64 sum = 0;
+ do
+ {
+ sum += p->_phySize;
+ p = p->Parent;
+ }
+ while (p);
+ prop = sum;
+ break;
+ }
+ case kpidNumVolumes: if (NumLevels != 1) prop = (UInt32)NumLevels; break;
+ case kpidError:
+ {
+ UString s;
+ const CHandler *p = this;
+ do
+ {
+ if (!p->_errorMessage.IsEmpty())
+ {
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += p->_errorMessage;
+ }
+ p = p->Parent;
+ }
+ while (p);
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCallback)
+{
+ Stream = stream;
+ if (_level >= (1 << 20))
+ return S_FALSE;
+
+ RINOK(Open3())
+
+ NumLevels = 1;
+ PackSize_Total = GetPackSize();
+
+ if (_child)
+ {
+ if (!_child->_parentGuid.IsEqualTo(Header.Guids[kHeader_GUID_Index_DataWriteGuid]))
+ return S_FALSE;
+ const CHandler *child = _child;
+ do
+ {
+ /* We suppose that only FileWriteGuid is unique.
+ Another IDs must be identical in in difference and parent archives. */
+ if (Header.Guids[kHeader_GUID_Index_FileWriteGuid].IsEqualTo(
+ child->Header.Guids[kHeader_GUID_Index_FileWriteGuid])
+ && _phySize == child->_phySize)
+ {
+ _isCyclic = true;
+ _isCyclic_or_CyclicParent = true;
+ AddErrorMessage("Cyclic parent archive was blocked");
+ return S_OK;
+ }
+ child = child->_child;
+ }
+ while (child);
+ }
+
+ if (!Meta.Is_HasParent())
+ return S_OK;
+
+ if (!Meta.Locator_Defined
+ || !_parentGuid_IsDefined
+ || ParentNames.IsEmpty())
+ {
+ return S_OK;
+ }
+
+ ParentName_Used = ParentNames.Front();
+
+ HRESULT res;
+ const unsigned kNumLevelsMax = (1 << 8); // Maybe we need to increase that limit
+ if (_level >= kNumLevelsMax - 1)
+ {
+ AddErrorMessage("Too many parent levels");
+ return S_OK;
+ }
+
+ bool _parentFileWasOpen = false;
+
+ if (!openArchiveCallback)
+ res = S_FALSE;
+ else
+ res = OpenParent(openArchiveCallback, _parentFileWasOpen);
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+
+ if (_parentFileWasOpen)
+ AddErrorMessage("Can't parse parent VHDX file : ", ParentName_Used);
+ else
+ AddErrorMessage("Missing parent VHDX file : ", ParentName_Used);
+ }
+
+
+ return S_OK;
+}
+
+
+HRESULT CHandler::OpenParent(IArchiveOpenCallback *openArchiveCallback, bool &_parentFileWasOpen)
+{
+ _parentFileWasOpen = false;
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpenVolumeCallback,
+ openVolumeCallback, openArchiveCallback)
+ if (!openVolumeCallback)
+ return S_FALSE;
+ {
+ CMyComPtr<IInStream> nextStream;
+ HRESULT res = S_FALSE;
+ UString name;
+
+ FOR_VECTOR (i, ParentNames)
+ {
+ name = ParentNames[i];
+
+ // we remove prefix ".\\', but client already can support any variant
+ if (name[0] == L'.' && name[1] == L'\\')
+ name.DeleteFrontal(2);
+
+ res = openVolumeCallback->GetStream(name, &nextStream);
+
+ if (res == S_OK && nextStream)
+ break;
+
+ if (res != S_OK && res != S_FALSE)
+ return res;
+ }
+
+ if (res == S_FALSE || !nextStream)
+ return S_FALSE;
+
+ ParentName_Used = name;
+ _parentFileWasOpen = true;
+
+ Parent = new CHandler;
+ ParentStream = Parent;
+
+ try
+ {
+ Parent->_level = _level + 1;
+ Parent->_child = this;
+ /* we could call CHandlerImg::Open() here.
+ but we don't need (_imgExt) in (Parent). So we call Open2() here */
+ Parent->Close();
+ res = Parent->Open2(nextStream, openArchiveCallback);
+ }
+ catch(...)
+ {
+ Parent = NULL;
+ ParentStream.Release();
+ res = S_FALSE;
+ throw;
+ }
+
+ if (res != S_OK)
+ {
+ Parent = NULL;
+ ParentStream.Release();
+ if (res == E_ABORT)
+ return res;
+ if (res != S_FALSE)
+ {
+ // we must show that error code
+ }
+ }
+
+ if (res == S_OK)
+ {
+ if (Parent->_isCyclic_or_CyclicParent)
+ _isCyclic_or_CyclicParent = true;
+
+ NumLevels = Parent->NumLevels + 1;
+ PackSize_Total += Parent->GetPackSize();
+
+ // we read BitMaps only if Parent was open
+
+ UInt64 numBytes = (UInt64)NumUsedBitMaps << kBitmapSize_Log;
+ if (openArchiveCallback && numBytes != 0)
+ {
+ RINOK(openArchiveCallback->SetTotal(NULL, &numBytes))
+ }
+ numBytes = 0;
+ for (size_t i = ChunkRatio; i < TotalBatEntries; i += ChunkRatio + 1)
+ {
+ const UInt64 v = Bat.GetItem(i);
+ const UInt64 offset = BAT_GET_OFFSET(v);
+ const unsigned state = BAT_GET_STATE(v);
+
+ CByteBuffer &buf = BitMaps.AddNew();
+ if (state == SB_BLOCK_PRESENT)
+ {
+ if (openArchiveCallback)
+ {
+ RINOK(openArchiveCallback->SetCompleted(NULL, &numBytes))
+ }
+ numBytes += kBitmapSize;
+ buf.Alloc(kBitmapSize);
+ RINOK(Seek2(offset))
+ RINOK(Read_FALSE(buf, kBitmapSize))
+ /*
+ for (unsigned i = 0; i < (1 << 20); i+=4)
+ {
+ UInt32 v = GetUi32(buf + i);
+ if (v != 0 && v != (UInt32)(Int32)-1)
+ printf("\n%7d %8x", i, v);
+ }
+ */
+ }
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+void CHandler::CloseAtError()
+{
+ // CHandlerImg
+ Clear_HandlerImg_Vars();
+ Stream.Release();
+
+ _phySize = 0;
+ Bat.Clear();
+ BitMaps.Clear();
+ NumUsedBlocks = 0;
+ NumUsedBitMaps = 0;
+ HeadersSize = 0;
+ /*
+ NumUsed_1MB_Blocks = 0;
+ NumUsed_1MB_Blocks_Defined = false;
+ */
+
+ Parent = NULL;
+ ParentStream.Release();
+ _errorMessage.Empty();
+ _creator.Empty();
+ _nonEmptyLog = false;
+ _parentGuid_IsDefined = false;
+ _isDataContiguous = false;
+ // _batOverlap = false;
+
+ ParentNames.Clear();
+ ParentName_Used.Empty();
+
+ Meta.Clear();
+
+ ChunkRatio_Log = 0;
+ ChunkRatio = 0;
+ TotalBatEntries = 0;
+ NumLevels = 0;
+ PackSize_Total = 0;
+
+ _isCyclic = false;
+ _isCyclic_or_CyclicParent = false;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ CloseAtError();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidSize: prop = Meta.VirtualDiskSize; break;
+ case kpidPackSize: prop = PackSize_Total; break;
+ case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+ // if some prarent is not OK, we don't create stream
+ if (!AreParentsOK())
+ return S_FALSE;
+ InitSeekPositions();
+ CMyComPtr<ISequentialInStream> streamTemp = this;
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+REGISTER_ARC_I(
+ "VHDX", "vhdx avhdx", NULL, 0xc4,
+ kSignature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/VmdkHandler.cpp b/CPP/7zip/Archive/VmdkHandler.cpp
new file mode 100644
index 0000000..0a6b967
--- /dev/null
+++ b/CPP/7zip/Archive/VmdkHandler.cpp
@@ -0,0 +1,1527 @@
+// VmdkHandler.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/StringToInt.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/ZlibDecoder.h"
+
+#include "HandlerCont.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NVmdk {
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define LE_16(offs, dest) dest = Get16(p + (offs))
+#define LE_32(offs, dest) dest = Get32(p + (offs))
+#define LE_64(offs, dest) dest = Get64(p + (offs))
+
+
+static const Byte k_Signature[] = { 'K', 'D', 'M', 'V' };
+
+static const UInt32 k_Flags_NL = (UInt32)1 << 0;
+// static const UInt32 k_Flags_RGD = (UInt32)1 << 1;
+static const UInt32 k_Flags_ZeroGrain = (UInt32)1 << 2;
+static const UInt32 k_Flags_Compressed = (UInt32)1 << 16;
+static const UInt32 k_Flags_Marker = (UInt32)1 << 17;
+
+static const unsigned k_NumMidBits = 9; // num bits for index in Grain Table
+
+struct CHeader
+{
+ UInt32 flags;
+ UInt32 version;
+
+ UInt64 capacity;
+ UInt64 grainSize;
+ UInt64 descriptorOffset;
+ UInt64 descriptorSize;
+
+ UInt32 numGTEsPerGT;
+ UInt16 algo;
+ // Byte uncleanShutdown;
+ // UInt64 rgdOffset;
+ UInt64 gdOffset;
+ UInt64 overHead;
+
+ bool Is_NL() const { return (flags & k_Flags_NL) != 0; }
+ bool Is_ZeroGrain() const { return (flags & k_Flags_ZeroGrain) != 0; }
+ bool Is_Compressed() const { return (flags & k_Flags_Compressed) != 0; }
+ bool Is_Marker() const { return (flags & k_Flags_Marker) != 0; }
+
+ bool Parse(const Byte *p);
+
+ bool IsSameImageFor(const CHeader &h) const
+ {
+ return flags == h.flags
+ && version == h.version
+ && capacity == h.capacity
+ && grainSize == h.grainSize
+ && algo == h.algo;
+ }
+};
+
+bool CHeader::Parse(const Byte *p)
+{
+ if (memcmp(p, k_Signature, sizeof(k_Signature)) != 0)
+ return false;
+
+ LE_32 (0x04, version);
+ LE_32 (0x08, flags);
+ LE_64 (0x0C, capacity);
+ LE_64 (0x14, grainSize);
+ LE_64 (0x1C, descriptorOffset);
+ LE_64 (0x24, descriptorSize);
+ LE_32 (0x2C, numGTEsPerGT);
+ // LE_64 (0x30, rgdOffset);
+ LE_64 (0x38, gdOffset);
+ LE_64 (0x40, overHead);
+ // uncleanShutdown = buf[0x48];
+ LE_16(0x4D, algo);
+
+ if (Is_NL() && Get32(p + 0x49) != 0x0A0D200A) // do we need Is_NL() check here?
+ return false;
+
+ return (numGTEsPerGT == (1 << k_NumMidBits)) && (version <= 3);
+}
+
+
+enum
+{
+ k_Marker_END_OF_STREAM = 0,
+ k_Marker_GRAIN_TABLE = 1,
+ k_Marker_GRAIN_DIR = 2,
+ k_Marker_FOOTER = 3
+};
+
+struct CMarker
+{
+ UInt64 NumSectors;
+ UInt32 SpecSize; // = 0 for metadata sectors
+ UInt32 Type;
+
+ void Parse(const Byte *p)
+ {
+ LE_64 (0, NumSectors);
+ LE_32 (8, SpecSize);
+ LE_32 (12, Type);
+ }
+};
+
+
+static bool Str_to_ValName(const AString &s, AString &name, AString &val)
+{
+ name.Empty();
+ val.Empty();
+ int qu = s.Find('"');
+ int eq = s.Find('=');
+ if (eq < 0 || (qu >= 0 && eq > qu))
+ return false;
+ name.SetFrom(s.Ptr(), eq);
+ name.Trim();
+ val = s.Ptr(eq + 1);
+ val.Trim();
+ return true;
+}
+
+static inline bool IsSpaceChar(char c)
+{
+ return (c == ' ' || c == '\t');
+}
+
+static const char *SkipSpaces(const char *s)
+{
+ for (;; s++)
+ {
+ char c = *s;
+ if (c == 0 || !IsSpaceChar(c))
+ return s;
+ }
+}
+
+#define SKIP_SPACES(s) s = SkipSpaces(s);
+
+static const char *GetNextWord(const char *s, AString &dest)
+{
+ dest.Empty();
+ SKIP_SPACES(s)
+ const char *start = s;
+ for (;; s++)
+ {
+ char c = *s;
+ if (c == 0 || IsSpaceChar(c))
+ {
+ dest.SetFrom(start, (unsigned)(s - start));
+ return s;
+ }
+ }
+}
+
+static const char *GetNextNumber(const char *s, UInt64 &val)
+{
+ SKIP_SPACES(s)
+ if (*s == 0)
+ return s;
+ const char *end;
+ val = ConvertStringToUInt64(s, &end);
+ char c = *end;
+ if (c != 0 && !IsSpaceChar(c))
+ return NULL;
+ return end;
+}
+
+
+struct CExtentInfo
+{
+ AString Access; // RW, RDONLY, or NOACCESS
+ UInt64 NumSectors; // 512 bytes sectors
+ AString Type; // FLAT, SPARSE, ZERO, VMFS, VMFSSPARSE, VMFSRDM, VMFSRAW
+ AString FileName;
+ UInt64 StartSector; // used for FLAT
+
+ // for VMWare Player 9:
+ // PartitionUUID
+ // DeviceIdentifier
+
+ bool IsType_ZERO() const { return Type == "ZERO"; }
+ // bool IsType_FLAT() const { return Type == "FLAT"; }
+ bool IsType_Flat() const { return Type == "FLAT" || Type == "VMFS" || Type == "VMFSRAW"; }
+
+ bool Parse(const char *s);
+};
+
+bool CExtentInfo::Parse(const char *s)
+{
+ NumSectors = 0;
+ StartSector = 0;
+ Access.Empty();
+ Type.Empty();
+ FileName.Empty();
+
+ s = GetNextWord(s, Access);
+ s = GetNextNumber(s, NumSectors);
+ if (!s)
+ return false;
+ s = GetNextWord(s, Type);
+
+ if (Type.IsEmpty())
+ return false;
+
+ SKIP_SPACES(s)
+
+ if (IsType_ZERO())
+ return (*s == 0);
+
+ if (*s != '\"')
+ return false;
+ s++;
+ {
+ const char *s2 = strchr(s, '\"');
+ if (!s2)
+ return false;
+ FileName.SetFrom(s, (unsigned)(s2 - s));
+ s = s2 + 1;
+ }
+ SKIP_SPACES(s)
+ if (*s == 0)
+ return true;
+
+ s = GetNextNumber(s, StartSector);
+ if (!s)
+ return false;
+ return true;
+ // SKIP_SPACES(s);
+ // return (*s == 0);
+}
+
+
+struct CDescriptor
+{
+ AString CID;
+ AString parentCID;
+ AString createType;
+ // AString encoding; // UTF-8, windows-1252 - default is UTF-8
+
+ CObjectVector<CExtentInfo> Extents;
+
+ static void GetUnicodeName(const AString &s, UString &res)
+ {
+ if (!ConvertUTF8ToUnicode(s, res))
+ MultiByteToUnicodeString2(res, s);
+ }
+
+ void Clear()
+ {
+ CID.Empty();
+ parentCID.Empty();
+ createType.Empty();
+ Extents.Clear();
+ }
+
+ bool IsThere_Parent() const
+ {
+ return !parentCID.IsEmpty() && !parentCID.IsEqualTo_Ascii_NoCase("ffffffff");
+ }
+
+ bool Parse(const Byte *p, size_t size);
+};
+
+
+bool CDescriptor::Parse(const Byte *p, size_t size)
+{
+ Clear();
+
+ AString s;
+ AString name;
+ AString val;
+
+ for (;;)
+ {
+ Byte c = 0;
+ if (size != 0)
+ {
+ size--;
+ c = *p++;
+ }
+ if (c == 0 || c == 0xA || c == 0xD)
+ {
+ if (!s.IsEmpty() && s[0] != '#')
+ {
+ if (Str_to_ValName(s, name, val))
+ {
+ if (name.IsEqualTo_Ascii_NoCase("CID"))
+ CID = val;
+ else if (name.IsEqualTo_Ascii_NoCase("parentCID"))
+ parentCID = val;
+ else if (name.IsEqualTo_Ascii_NoCase("createType"))
+ createType = val;
+ }
+ else
+ {
+ CExtentInfo ei;
+ if (!ei.Parse(s))
+ return false;
+ Extents.Add(ei);
+ }
+ }
+
+ s.Empty();
+ if (c == 0)
+ return true;
+ }
+ else
+ s += (char)c;
+ }
+}
+
+
+struct CExtent
+{
+ bool IsOK;
+ bool IsArc;
+ bool NeedDeflate;
+ bool Unsupported;
+ bool IsZero;
+ bool IsFlat;
+ bool DescriptorOK;
+ bool HeadersError;
+
+ unsigned ClusterBits;
+ UInt32 ZeroSector;
+
+ CObjectVector<CByteBuffer> Tables;
+
+ CMyComPtr<IInStream> Stream;
+ UInt64 PosInArc;
+
+ UInt64 PhySize;
+ UInt64 VirtSize; // from vmdk header of volume
+
+ UInt64 StartOffset; // virtual offset of this extent
+ UInt64 NumBytes; // from main descriptor, if multi-vol
+ UInt64 FlatOffset; // in Stream
+
+ CByteBuffer DescriptorBuf;
+ CDescriptor Descriptor;
+
+ CHeader h;
+
+ UInt64 GetEndOffset() const { return StartOffset + NumBytes; }
+
+ bool IsVmdk() const { return !IsZero && !IsFlat; }
+ // if (IsOK && IsVmdk()), then VMDK header of this extent was read
+
+ CExtent():
+ IsOK(false),
+ IsArc(false),
+ NeedDeflate(false),
+ Unsupported(false),
+ IsZero(false),
+ IsFlat(false),
+ DescriptorOK(false),
+ HeadersError(false),
+
+ ClusterBits(0),
+ ZeroSector(0),
+
+ PosInArc(0),
+
+ PhySize(0),
+ VirtSize(0),
+
+ StartOffset(0),
+ NumBytes(0),
+ FlatOffset(0)
+ {}
+
+
+ HRESULT ReadForHeader(IInStream *stream, UInt64 sector, void *data, size_t numSectors);
+ HRESULT Open3(IInStream *stream, IArchiveOpenCallback *openCallback,
+ unsigned numVols, unsigned volIndex, UInt64 &complexity);
+
+ HRESULT Seek(UInt64 offset)
+ {
+ PosInArc = offset;
+ return InStream_SeekSet(Stream, offset);
+ }
+
+ HRESULT InitAndSeek()
+ {
+ if (Stream)
+ return Seek(0);
+ return S_OK;
+ }
+
+ HRESULT Read(void *data, size_t *size)
+ {
+ HRESULT res = ReadStream(Stream, data, size);
+ PosInArc += *size;
+ return res;
+ }
+};
+
+
+Z7_class_CHandler_final: public CHandlerImg
+{
+ bool _isArc;
+ bool _unsupported;
+ bool _unsupportedSome;
+ bool _headerError;
+ bool _missingVol;
+ bool _isMultiVol;
+ bool _needDeflate;
+
+ UInt64 _cacheCluster;
+ unsigned _cacheExtent;
+ CByteBuffer _cache;
+ CByteBuffer _cacheCompressed;
+
+ unsigned _clusterBitsMax;
+ UInt64 _phySize;
+
+ CObjectVector<CExtent> _extents;
+
+ CBufInStream *_bufInStreamSpec;
+ CMyComPtr<ISequentialInStream> _bufInStream;
+
+ CBufPtrSeqOutStream *_bufOutStreamSpec;
+ CMyComPtr<ISequentialOutStream> _bufOutStream;
+
+ NCompress::NZlib::CDecoder *_zlibDecoderSpec;
+ CMyComPtr<ICompressCoder> _zlibDecoder;
+
+ CByteBuffer _descriptorBuf;
+ CDescriptor _descriptor;
+
+ UString _missingVolName;
+
+ void InitAndSeekMain()
+ {
+ _virtPos = 0;
+ }
+
+ virtual HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openCallback) Z7_override;
+ virtual void CloseAtError() Z7_override;
+public:
+ Z7_IFACE_COM7_IMP(IInArchive_Img)
+
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+};
+
+
+Z7_COM7F_IMF(CHandler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= _size)
+ return S_OK;
+ {
+ UInt64 rem = _size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ if (size == 0)
+ return S_OK;
+ }
+
+ unsigned extentIndex;
+ {
+ unsigned left = 0, right = _extents.Size();
+ for (;;)
+ {
+ unsigned mid = (left + right) / 2;
+ if (mid == left)
+ break;
+ if (_virtPos < _extents[mid].StartOffset)
+ right = mid;
+ else
+ left = mid;
+ }
+ extentIndex = left;
+ }
+
+ CExtent &extent = _extents[extentIndex];
+
+ {
+ const UInt64 vir = _virtPos - extent.StartOffset;
+ if (vir >= extent.NumBytes)
+ {
+ return E_FAIL;
+ /*
+ if (vir > extent.NumBytes)
+ _stream_dataError = true;
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ */
+ }
+
+ {
+ const UInt64 rem = extent.NumBytes - vir;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ if (vir >= extent.VirtSize)
+ {
+ // if vmdk's VirtSize is smaller than VirtSize from main multi-volume descriptor
+ _stream_dataError = true;
+ return S_FALSE;
+ /*
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ */
+ }
+
+ {
+ const UInt64 rem = extent.VirtSize - vir;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ if (extent.IsZero || !extent.IsOK || !extent.Stream || extent.Unsupported)
+ {
+ if (extent.Unsupported)
+ {
+ _stream_unsupportedMethod = true;
+ return S_FALSE;
+ }
+ if (!extent.IsOK || !extent.Stream)
+ {
+ _stream_unavailData = true;
+ return S_FALSE;
+ }
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ if (extent.IsFlat)
+ {
+ UInt64 offset = extent.FlatOffset + vir;
+ if (offset != extent.PosInArc)
+ {
+ RINOK(extent.Seek(offset))
+ }
+ UInt32 size2 = 0;
+ HRESULT res = extent.Stream->Read(data, size, &size2);
+ if (res == S_OK && size2 == 0)
+ {
+ _stream_unavailData = true;
+ /*
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ */
+ }
+ // _stream_PackSize += size2;
+ extent.PosInArc += size2;
+ _virtPos += size2;
+ if (processedSize)
+ *processedSize = size2;
+ return res;
+ }
+ }
+
+
+ for (;;)
+ {
+ const UInt64 vir = _virtPos - extent.StartOffset;
+ const unsigned clusterBits = extent.ClusterBits;
+ const UInt64 cluster = vir >> clusterBits;
+ const size_t clusterSize = (size_t)1 << clusterBits;
+ const size_t lowBits = (size_t)vir & (clusterSize - 1);
+ {
+ size_t rem = clusterSize - lowBits;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ if (extentIndex == _cacheExtent && cluster == _cacheCluster)
+ {
+ memcpy(data, _cache + lowBits, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ const UInt64 high = cluster >> k_NumMidBits;
+
+ if (high < extent.Tables.Size())
+ {
+ const CByteBuffer &table = extent.Tables[(unsigned)high];
+
+ if (table.Size() != 0)
+ {
+ const size_t midBits = (size_t)cluster & ((1 << k_NumMidBits) - 1);
+ const Byte *p = (const Byte *)table + (midBits << 2);
+ const UInt32 v = Get32(p);
+
+ if (v != 0 && v != extent.ZeroSector)
+ {
+ UInt64 offset = (UInt64)v << 9;
+ if (extent.NeedDeflate)
+ {
+ if (offset != extent.PosInArc)
+ {
+ // printf("\n%12x %12x\n", (unsigned)offset, (unsigned)(offset - extent.PosInArc));
+ RINOK(extent.Seek(offset))
+ }
+
+ const size_t kStartSize = 1 << 9;
+ {
+ size_t curSize = kStartSize;
+ RINOK(extent.Read(_cacheCompressed, &curSize))
+ // _stream_PackSize += curSize;
+ if (curSize != kStartSize)
+ return S_FALSE;
+ }
+
+ if (Get64(_cacheCompressed) != (cluster << (clusterBits - 9)))
+ return S_FALSE;
+
+ UInt32 dataSize = Get32(_cacheCompressed + 8);
+ if (dataSize > ((UInt32)1 << 31))
+ return S_FALSE;
+
+ size_t dataSize2 = (size_t)dataSize + 12;
+
+ if (dataSize2 > kStartSize)
+ {
+ dataSize2 = (dataSize2 + 511) & ~(size_t)511;
+ if (dataSize2 > _cacheCompressed.Size())
+ return S_FALSE;
+ size_t curSize = dataSize2 - kStartSize;
+ const size_t curSize2 = curSize;
+ RINOK(extent.Read(_cacheCompressed + kStartSize, &curSize))
+ // _stream_PackSize += curSize;
+ if (curSize != curSize2)
+ return S_FALSE;
+ }
+
+ _bufInStreamSpec->Init(_cacheCompressed + 12, dataSize);
+
+ _cacheCluster = (UInt64)(Int64)-1;
+ _cacheExtent = (unsigned)(int)-1;
+
+ if (_cache.Size() < clusterSize)
+ return E_FAIL;
+ _bufOutStreamSpec->Init(_cache, clusterSize);
+
+ // Do we need to use smaller block than clusterSize for last cluster?
+ const UInt64 blockSize64 = clusterSize;
+ HRESULT res = _zlibDecoder->Code(_bufInStream, _bufOutStream, NULL, &blockSize64, NULL);
+
+ /*
+ if (_bufOutStreamSpec->GetPos() != clusterSize)
+ {
+ _stream_dataError = true;
+ memset(_cache + _bufOutStreamSpec->GetPos(), 0, clusterSize - _bufOutStreamSpec->GetPos());
+ }
+ */
+
+ if (_bufOutStreamSpec->GetPos() != clusterSize
+ || _zlibDecoderSpec->GetInputProcessedSize() != dataSize)
+ {
+ _stream_dataError = true;
+ if (res == S_OK)
+ res = S_FALSE;
+ }
+
+ RINOK(res)
+
+ _cacheCluster = cluster;
+ _cacheExtent = extentIndex;
+
+ continue;
+ /*
+ memcpy(data, _cache + lowBits, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ */
+ }
+ {
+ offset += lowBits;
+ if (offset != extent.PosInArc)
+ {
+ // printf("\n%12x %12x\n", (unsigned)offset, (unsigned)(offset - extent.PosInArc));
+ RINOK(extent.Seek(offset))
+ }
+ UInt32 size2 = 0;
+ HRESULT res = extent.Stream->Read(data, size, &size2);
+ if (res == S_OK && size2 == 0)
+ {
+ _stream_unavailData = true;
+ /*
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ */
+ }
+ extent.PosInArc += size2;
+ // _stream_PackSize += size2;
+ _virtPos += size2;
+ if (processedSize)
+ *processedSize = size2;
+ return res;
+ }
+ }
+ }
+ }
+
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+}
+
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize
+};
+
+static const Byte kArcProps[] =
+{
+ kpidNumVolumes,
+ kpidTotalPhySize,
+ kpidMethod,
+ kpidClusterSize,
+ kpidHeadersSize,
+ kpidId,
+ kpidName,
+ kpidComment
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CExtent *e = NULL;
+ const CDescriptor *desc = NULL;
+
+ if (_isMultiVol)
+ desc = &_descriptor;
+ else if (_extents.Size() == 1)
+ {
+ e = &_extents[0];
+ desc = &e->Descriptor;
+ }
+
+ switch (propID)
+ {
+ case kpidMainSubfile: prop = (UInt32)0; break;
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+ case kpidTotalPhySize:
+ {
+ UInt64 sum = _phySize;
+ if (_isMultiVol)
+ {
+ FOR_VECTOR (i, _extents)
+ sum += _extents[i].PhySize;
+ }
+ prop = sum;
+ break;
+ }
+ case kpidClusterSize: prop = (UInt32)((UInt32)1 << _clusterBitsMax); break;
+ case kpidHeadersSize: if (e) prop = (e->h.overHead << 9); break;
+ case kpidMethod:
+ {
+ AString s;
+
+ if (desc && !desc->createType.IsEmpty())
+ s = desc->createType;
+
+ bool zlib = false;
+ bool marker = false;
+ int algo = -1;
+
+ FOR_VECTOR (i, _extents)
+ {
+ const CExtent &extent = _extents[i];
+ if (!extent.IsOK || !extent.IsVmdk())
+ continue;
+
+ const CHeader &h = extent.h;
+
+ if (h.algo != 0)
+ {
+ if (h.algo == 1)
+ zlib = true;
+ else if (algo != (int)h.algo)
+ {
+ s.Add_Space_if_NotEmpty();
+ s.Add_UInt32(h.algo);
+ algo = h.algo;
+ }
+ }
+
+ if (h.Is_Marker())
+ marker = true;
+ }
+
+ if (zlib)
+ s.Add_OptSpaced("zlib");
+
+ if (marker)
+ s.Add_OptSpaced("Marker");
+
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidComment:
+ {
+ if (e && e->DescriptorBuf.Size() != 0)
+ {
+ AString s;
+ s.SetFrom_CalcLen((const char *)(const Byte *)e->DescriptorBuf, (unsigned)e->DescriptorBuf.Size());
+ if (!s.IsEmpty() && s.Len() <= (1 << 16))
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidId:
+ {
+ if (desc && !desc->CID.IsEmpty())
+ {
+ prop = desc->CID;
+ }
+ break;
+ }
+
+ case kpidName:
+ {
+ if (!_isMultiVol && desc && desc->Extents.Size() == 1)
+ {
+ const CExtentInfo &ei = desc->Extents[0];
+ if (!ei.FileName.IsEmpty())
+ {
+ UString u;
+ CDescriptor::GetUnicodeName(ei.FileName, u);
+ if (!u.IsEmpty())
+ prop = u;
+ }
+ }
+ break;
+ }
+
+ case kpidNumVolumes: if (_isMultiVol) prop = (UInt32)_extents.Size(); break;
+
+ case kpidError:
+ {
+ if (_missingVol || !_missingVolName.IsEmpty())
+ {
+ UString s ("Missing volume : ");
+ if (!_missingVolName.IsEmpty())
+ s += _missingVolName;
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
+ if (_unsupportedSome) v |= kpv_ErrorFlags_UnsupportedMethod;
+ if (_headerError) v |= kpv_ErrorFlags_HeadersError;
+ // if (_missingVol) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ switch (propID)
+ {
+ case kpidSize: prop = _size; break;
+ case kpidPackSize:
+ {
+ UInt64 packSize = 0;
+ FOR_VECTOR (i, _extents)
+ {
+ const CExtent &e = _extents[i];
+ if (!e.IsOK)
+ continue;
+ if (e.IsVmdk() && !_isMultiVol)
+ {
+ UInt64 ov = (e.h.overHead << 9);
+ if (e.PhySize >= ov)
+ packSize += e.PhySize - ov;
+ }
+ else
+ packSize += e.PhySize;
+ }
+ prop = packSize;
+ break;
+ }
+ case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+static int inline GetLog(UInt64 num)
+{
+ for (int i = 0; i < 64; i++)
+ if (((UInt64)1 << i) == num)
+ return i;
+ return -1;
+}
+
+
+HRESULT CExtent::ReadForHeader(IInStream *stream, UInt64 sector, void *data, size_t numSectors)
+{
+ sector <<= 9;
+ RINOK(InStream_SeekSet(stream, sector))
+ size_t size = numSectors << 9;
+ RINOK(ReadStream_FALSE(stream, data, size))
+ UInt64 end = sector + size;
+ if (PhySize < end)
+ PhySize = end;
+ return S_OK;
+}
+
+
+void CHandler::CloseAtError()
+{
+ _extents.Clear();
+ CHandlerImg::CloseAtError();
+}
+
+
+static const char * const kSignature_Descriptor = "# Disk DescriptorFile";
+
+
+HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openCallback)
+{
+ const unsigned kSectoreSize = 512;
+ Byte buf[kSectoreSize];
+ size_t headerSize = kSectoreSize;
+ RINOK(ReadStream(stream, buf, &headerSize))
+
+ if (headerSize < sizeof(k_Signature))
+ return S_FALSE;
+
+ CMyComPtr<IArchiveOpenVolumeCallback> volumeCallback;
+
+ if (memcmp(buf, k_Signature, sizeof(k_Signature)) != 0)
+ {
+ const size_t k_SigDesc_Size = strlen(kSignature_Descriptor);
+ if (headerSize < k_SigDesc_Size)
+ return S_FALSE;
+ if (memcmp(buf, kSignature_Descriptor, k_SigDesc_Size) != 0)
+ return S_FALSE;
+
+ UInt64 endPos;
+ RINOK(InStream_GetSize_SeekToEnd(stream, endPos))
+ if (endPos > (1 << 20))
+ return S_FALSE;
+ const size_t numBytes = (size_t)endPos;
+ _descriptorBuf.Alloc(numBytes);
+ RINOK(InStream_SeekToBegin(stream))
+ RINOK(ReadStream_FALSE(stream, _descriptorBuf, numBytes))
+
+ if (!_descriptor.Parse(_descriptorBuf, _descriptorBuf.Size()))
+ return S_FALSE;
+ _isMultiVol = true;
+ _isArc = true;
+ _phySize = numBytes;
+ if (_descriptor.IsThere_Parent())
+ _unsupported = true;
+
+ if (openCallback)
+ {
+ openCallback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&volumeCallback);
+ }
+ if (!volumeCallback)
+ {
+ _unsupported = true;
+ return E_NOTIMPL;
+ }
+
+ /*
+ UInt64 totalVirtSize = 0;
+ FOR_VECTOR (i, _descriptor.Extents)
+ {
+ const CExtentInfo &ei = _descriptor.Extents[i];
+ if (ei.NumSectors >= ((UInt64)1 << (63 - 9)))
+ return S_FALSE;
+ totalVirtSize += ei.NumSectors;
+ if (totalVirtSize >= ((UInt64)1 << (63 - 9)))
+ return S_FALSE;
+ }
+ totalVirtSize <<= 9;
+ */
+
+ if (_descriptor.Extents.Size() > 1)
+ {
+ const UInt64 numFiles = _descriptor.Extents.Size();
+ RINOK(openCallback->SetTotal(&numFiles, NULL))
+ }
+ }
+
+ UInt64 complexity = 0;
+
+ for (;;)
+ {
+ CExtent *e = NULL;
+ CMyComPtr<IInStream> nextStream;
+
+ if (_isMultiVol)
+ {
+ const unsigned extentIndex = _extents.Size();
+ if (extentIndex >= _descriptor.Extents.Size())
+ break;
+ const CExtentInfo &ei = _descriptor.Extents[extentIndex];
+ e = &_extents.AddNew();
+ e->StartOffset = 0;
+ if (ei.NumSectors >= ((UInt64)1 << (62 - 9)) ||
+ ei.StartSector >= ((UInt64)1 << (62 - 9)))
+ return S_FALSE;
+ e->NumBytes = ei.NumSectors << 9;
+ e->IsZero = ei.IsType_ZERO();
+ if (extentIndex != 0)
+ e->StartOffset = _extents[extentIndex - 1].GetEndOffset();
+ if (e->GetEndOffset() < e->StartOffset)
+ return S_FALSE;
+
+ e->VirtSize = e->NumBytes;
+ if (e->IsZero)
+ {
+ e->IsOK = true;
+ continue;
+ }
+
+ e->IsFlat = ei.IsType_Flat();
+ e->FlatOffset = ei.StartSector << 9;
+
+ UString u;
+ CDescriptor::GetUnicodeName(ei.FileName, u);
+ if (u.IsEmpty())
+ {
+ _missingVol = true;
+ continue;
+ }
+
+ HRESULT result = volumeCallback->GetStream(u, &nextStream);
+
+ if (result != S_OK && result != S_FALSE)
+ return result;
+
+ if (!nextStream || result != S_OK)
+ {
+ if (_missingVolName.IsEmpty())
+ _missingVolName = u;
+ _missingVol = true;
+ continue;
+ }
+
+ if (e->IsFlat)
+ {
+ e->IsOK = true;
+ e->Stream = nextStream;
+ e->PhySize = e->NumBytes;
+ continue;
+ }
+
+ stream = nextStream;
+
+ headerSize = kSectoreSize;
+ RINOK(ReadStream(stream, buf, &headerSize))
+
+ if (headerSize != kSectoreSize)
+ continue;
+ if (memcmp(buf, k_Signature, sizeof(k_Signature)) != 0)
+ continue;
+ }
+ else
+ {
+ if (headerSize != kSectoreSize)
+ return S_FALSE;
+ e = &_extents.AddNew();
+ e->StartOffset = 0;
+ }
+
+ HRESULT res = S_FALSE;
+ if (e->h.Parse(buf))
+ res = e->Open3(stream, openCallback, _isMultiVol ? _descriptor.Extents.Size() : 1, _extents.Size() - 1, complexity);
+
+ if (!_isMultiVol)
+ {
+ _isArc = e->IsArc;
+ _phySize = e->PhySize;
+ _unsupported = e->Unsupported;
+ }
+
+ if (e->Unsupported)
+ _unsupportedSome = true;
+ if (e->HeadersError)
+ _headerError = true;
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ if (!_isMultiVol)
+ return res;
+ continue;
+ }
+
+ e->Stream = stream;
+ e->IsOK = true;
+
+ if (!_isMultiVol)
+ {
+ e->NumBytes = e->VirtSize;
+ break;
+ }
+
+ if (e->NumBytes != e->VirtSize)
+ _headerError = true;
+ }
+
+ if (!_extents.IsEmpty())
+ _size = _extents.Back().GetEndOffset();
+
+ _needDeflate = false;
+ _clusterBitsMax = 0;
+
+ // unsigned numOKs = 0;
+ unsigned numUnsupported = 0;
+
+ FOR_VECTOR (i, _extents)
+ {
+ const CExtent &e = _extents[i];
+ if (e.Unsupported)
+ numUnsupported++;
+ if (!e.IsOK)
+ continue;
+ // numOKs++;
+ if (e.IsVmdk())
+ {
+ if (e.NeedDeflate)
+ _needDeflate = true;
+ if (_clusterBitsMax < e.ClusterBits)
+ _clusterBitsMax = e.ClusterBits;
+ }
+ }
+
+ if (numUnsupported != 0 && numUnsupported == _extents.Size())
+ _unsupported = true;
+
+ return S_OK;
+}
+
+
+HRESULT CExtent::Open3(IInStream *stream, IArchiveOpenCallback *openCallback,
+ unsigned numVols, unsigned volIndex, UInt64 &complexity)
+{
+ if (h.descriptorSize != 0)
+ {
+ if (h.descriptorOffset == 0 ||
+ h.descriptorSize > (1 << 10))
+ return S_FALSE;
+ DescriptorBuf.Alloc((size_t)h.descriptorSize << 9);
+ RINOK(ReadForHeader(stream, h.descriptorOffset, DescriptorBuf, (size_t)h.descriptorSize))
+ if (h.descriptorOffset == 1 && h.Is_Marker() && Get64(DescriptorBuf) == 0)
+ {
+ // We check data as end marker.
+ // and if probably it's footer's copy of header, we don't want to open it.
+ return S_FALSE;
+ }
+
+ DescriptorOK = Descriptor.Parse(DescriptorBuf, DescriptorBuf.Size());
+ if (!DescriptorOK)
+ HeadersError = true;
+ if (Descriptor.IsThere_Parent())
+ Unsupported = true;
+ }
+
+ if (h.gdOffset == (UInt64)(Int64)-1)
+ {
+ // Grain Dir is at end of file
+ UInt64 endPos;
+ RINOK(InStream_GetSize_SeekToEnd(stream, endPos))
+ if ((endPos & 511) != 0)
+ return S_FALSE;
+
+ const size_t kEndSize = 512 * 3;
+ Byte buf2[kEndSize];
+ if (endPos < kEndSize)
+ return S_FALSE;
+ RINOK(InStream_SeekSet(stream, endPos - kEndSize))
+ RINOK(ReadStream_FALSE(stream, buf2, kEndSize))
+
+ CHeader h2;
+ if (!h2.Parse(buf2 + 512))
+ return S_FALSE;
+ if (!h.IsSameImageFor(h2))
+ return S_FALSE;
+
+ h = h2;
+
+ CMarker m;
+ m.Parse(buf2);
+ if (m.NumSectors != 1 || m.SpecSize != 0 || m.Type != k_Marker_FOOTER)
+ return S_FALSE;
+ m.Parse(buf2 + 512 * 2);
+ if (m.NumSectors != 0 || m.SpecSize != 0 || m.Type != k_Marker_END_OF_STREAM)
+ return S_FALSE;
+ PhySize = endPos;
+ }
+
+ const int grainSize_Log = GetLog(h.grainSize);
+ if (grainSize_Log < 3 || grainSize_Log > 30 - 9) // grain size must be >= 4 KB
+ return S_FALSE;
+ if (h.capacity >= ((UInt64)1 << (63 - 9)))
+ return S_FALSE;
+ if (h.overHead >= ((UInt64)1 << (63 - 9)))
+ return S_FALSE;
+
+ IsArc = true;
+ ClusterBits = (9 + (unsigned)grainSize_Log);
+ VirtSize = h.capacity << 9;
+ NeedDeflate = (h.algo >= 1);
+
+ if (h.Is_Compressed() ? (h.algo > 1 || !h.Is_Marker()) : (h.algo != 0))
+ {
+ Unsupported = true;
+ PhySize = 0;
+ return S_FALSE;
+ }
+
+ {
+ const UInt64 overHeadBytes = h.overHead << 9;
+ if (PhySize < overHeadBytes)
+ PhySize = overHeadBytes;
+ }
+
+ ZeroSector = 0;
+ if (h.Is_ZeroGrain())
+ ZeroSector = 1;
+
+ const UInt64 numSectorsPerGde = (UInt64)1 << ((unsigned)grainSize_Log + k_NumMidBits);
+ const UInt64 numGdeEntries = (h.capacity + numSectorsPerGde - 1) >> ((unsigned)grainSize_Log + k_NumMidBits);
+ CByteBuffer table;
+
+ if (numGdeEntries != 0)
+ {
+ if (h.gdOffset == 0)
+ return S_FALSE;
+
+ size_t numSectors = (size_t)((numGdeEntries + ((1 << (9 - 2)) - 1)) >> (9 - 2));
+ size_t t1SizeBytes = numSectors << 9;
+ if ((t1SizeBytes >> 2) < numGdeEntries)
+ return S_FALSE;
+ table.Alloc(t1SizeBytes);
+
+ if (h.Is_Marker())
+ {
+ Byte buf2[1 << 9];
+ if (ReadForHeader(stream, h.gdOffset - 1, buf2, 1) != S_OK)
+ return S_FALSE;
+ {
+ CMarker m;
+ m.Parse(buf2);
+ if (m.Type != k_Marker_GRAIN_DIR
+ || m.NumSectors != numSectors
+ || m.SpecSize != 0)
+ return S_FALSE;
+ }
+ }
+
+ RINOK(ReadForHeader(stream, h.gdOffset, table, numSectors))
+ }
+
+ const size_t clusterSize = (size_t)1 << ClusterBits;
+
+ const UInt64 complexityStart = complexity;
+
+ if (openCallback)
+ {
+ complexity += (UInt64)numGdeEntries << (k_NumMidBits + 2);
+ {
+ const UInt64 numVols2 = numVols;
+ RINOK(openCallback->SetTotal((numVols == 1) ? NULL : &numVols2, &complexity))
+ }
+ if (numVols != 1)
+ {
+ const UInt64 volIndex2 = volIndex;
+ RINOK(openCallback->SetCompleted(numVols == 1 ? NULL : &volIndex2, &complexityStart))
+ }
+ }
+
+ UInt64 lastSector = 0;
+ UInt64 lastVirtCluster = 0;
+ size_t numProcessed_Prev = 0;
+
+ for (size_t i = 0; i < numGdeEntries; i++)
+ {
+ const size_t k_NumSectors = (size_t)1 << (k_NumMidBits - 9 + 2);
+ const size_t k_NumMidItems = (size_t)1 << k_NumMidBits;
+
+ CByteBuffer &buf = Tables.AddNew();
+
+ {
+ const UInt32 v = Get32((const Byte *)table + (size_t)i * 4);
+ if (v == 0 || v == ZeroSector)
+ continue;
+ if (openCallback && (i - numProcessed_Prev) >= 1024)
+ {
+ const UInt64 comp = complexityStart + ((UInt64)i << (k_NumMidBits + 2));
+ const UInt64 volIndex2 = volIndex;
+ RINOK(openCallback->SetCompleted(numVols == 1 ? NULL : &volIndex2, &comp))
+ numProcessed_Prev = i;
+ }
+
+ if (h.Is_Marker())
+ {
+ Byte buf2[1 << 9];
+ if (ReadForHeader(stream, v - 1, buf2, 1) != S_OK)
+ return S_FALSE;
+ {
+ CMarker m;
+ m.Parse(buf2);
+ if (m.Type != k_Marker_GRAIN_TABLE
+ || m.NumSectors != k_NumSectors
+ || m.SpecSize != 0)
+ return S_FALSE;
+ }
+ }
+
+ buf.Alloc(k_NumMidItems * 4);
+ RINOK(ReadForHeader(stream, v, buf, k_NumSectors))
+ }
+
+ for (size_t k = 0; k < k_NumMidItems; k++)
+ {
+ const UInt32 v = Get32((const Byte *)buf + (size_t)k * 4);
+ if (v == 0 || v == ZeroSector)
+ continue;
+ if (v < h.overHead)
+ return S_FALSE;
+ if (lastSector < v)
+ {
+ lastSector = v;
+ if (NeedDeflate)
+ lastVirtCluster = ((UInt64)i << k_NumMidBits) + k;
+ }
+ }
+ }
+
+ if (!NeedDeflate)
+ {
+ UInt64 end = ((UInt64)lastSector << 9) + clusterSize;
+ if (PhySize < end)
+ PhySize = end;
+ }
+ else if (lastSector != 0)
+ {
+ Byte buf[1 << 9];
+ if (ReadForHeader(stream, lastSector, buf, 1) == S_OK)
+ {
+ UInt64 lba = Get64(buf);
+ if (lba == (lastVirtCluster << (ClusterBits - 9)))
+ {
+ UInt32 dataSize = Get32(buf + 8);
+ size_t dataSize2 = (size_t)dataSize + 12;
+ dataSize2 = (dataSize2 + 511) & ~(size_t)511;
+ UInt64 end = ((UInt64)lastSector << 9) + dataSize2;
+ if (PhySize < end)
+ PhySize = end;
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+
+ _cacheCluster = (UInt64)(Int64)-1;
+ _cacheExtent = (unsigned)(int)-1;
+
+ _clusterBitsMax = 0;
+
+ _isArc = false;
+ _unsupported = false;
+ _unsupportedSome = false;
+ _headerError = false;
+ _missingVol = false;
+ _isMultiVol = false;
+ _needDeflate = false;
+
+ _missingVolName.Empty();
+
+ _descriptorBuf.Free();
+ _descriptor.Clear();
+
+ // CHandlerImg:
+ Clear_HandlerImg_Vars();
+ Stream.Release();
+
+ _extents.Clear();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ *stream = NULL;
+
+ if (_unsupported)
+ return S_FALSE;
+
+ ClearStreamVars();
+ // _stream_UsePackSize = true;
+
+ if (_needDeflate)
+ {
+ if (!_bufInStream)
+ {
+ _bufInStreamSpec = new CBufInStream;
+ _bufInStream = _bufInStreamSpec;
+ }
+
+ if (!_bufOutStream)
+ {
+ _bufOutStreamSpec = new CBufPtrSeqOutStream();
+ _bufOutStream = _bufOutStreamSpec;
+ }
+
+ if (!_zlibDecoder)
+ {
+ _zlibDecoderSpec = new NCompress::NZlib::CDecoder;
+ _zlibDecoder = _zlibDecoderSpec;
+ }
+
+ const size_t clusterSize = (size_t)1 << _clusterBitsMax;
+ _cache.AllocAtLeast(clusterSize);
+ _cacheCompressed.AllocAtLeast(clusterSize * 2);
+ }
+
+ FOR_VECTOR (i, _extents)
+ {
+ RINOK(_extents[i].InitAndSeek())
+ }
+
+ CMyComPtr<ISequentialInStream> streamTemp = this;
+ InitAndSeekMain();
+ *stream = streamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+REGISTER_ARC_I(
+ "VMDK", "vmdk", NULL, 0xC8,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/Wim/StdAfx.h b/CPP/7zip/Archive/Wim/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/Wim/WimHandler.cpp b/CPP/7zip/Archive/Wim/WimHandler.cpp
new file mode 100644
index 0000000..7f96dcc
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/WimHandler.cpp
@@ -0,0 +1,1236 @@
+// WimHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+
+#include "../../Common/MethodProps.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "WimHandler.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NWim {
+
+#define FILES_DIR_NAME "[DELETED]"
+
+// #define WIM_DETAILS
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidAttrib,
+ kpidMethod,
+ kpidSolid,
+ kpidShortName,
+ kpidINode,
+ kpidLinks,
+ kpidIsAltStream,
+ kpidNumAltStreams,
+
+ #ifdef WIM_DETAILS
+ , kpidVolume
+ , kpidOffset
+ #endif
+};
+
+enum
+{
+ kpidNumImages = kpidUserDefined,
+ kpidBootImage
+};
+
+static const CStatProp kArcProps[] =
+{
+ { NULL, kpidSize, VT_UI8},
+ { NULL, kpidPackSize, VT_UI8},
+ { NULL, kpidMethod, VT_BSTR},
+ { NULL, kpidClusterSize, VT_UI4},
+ { NULL, kpidCTime, VT_FILETIME},
+ { NULL, kpidMTime, VT_FILETIME},
+ { NULL, kpidComment, VT_BSTR},
+ { NULL, kpidUnpackVer, VT_BSTR},
+ { NULL, kpidIsVolume, VT_BOOL},
+ { NULL, kpidVolume, VT_UI4},
+ { NULL, kpidNumVolumes, VT_UI4},
+ { "Images", kpidNumImages, VT_UI4},
+ { "Boot Image", kpidBootImage, VT_UI4}
+};
+
+
+static const char * const k_Methods[] =
+{
+ "Copy"
+ , "XPress"
+ , "LZX"
+ , "LZMS"
+};
+
+
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_WITH_NAME
+
+static void AddErrorMessage(AString &s, const char *message)
+{
+ if (!s.IsEmpty())
+ s += ". ";
+ s += message;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CImageInfo *image = NULL;
+ if (_xmls.Size() == 1)
+ {
+ const CWimXml &xml = _xmls[0];
+ if (xml.Images.Size() == 1)
+ image = &xml.Images[0];
+ }
+
+ switch (propID)
+ {
+ case kpidPhySize: prop = _phySize; break;
+ case kpidSize: prop = _db.GetUnpackSize(); break;
+ case kpidPackSize: prop = _db.GetPackSize(); break;
+
+ case kpidCTime:
+ if (_xmls.Size() == 1)
+ {
+ const CWimXml &xml = _xmls[0];
+ int index = -1;
+ FOR_VECTOR (i, xml.Images)
+ {
+ const CImageInfo &image2 = xml.Images[i];
+ if (image2.CTimeDefined)
+ if (index < 0 || ::CompareFileTime(&image2.CTime, &xml.Images[index].CTime) < 0)
+ index = (int)i;
+ }
+ if (index >= 0)
+ prop = xml.Images[index].CTime;
+ }
+ break;
+
+ case kpidMTime:
+ if (_xmls.Size() == 1)
+ {
+ const CWimXml &xml = _xmls[0];
+ int index = -1;
+ FOR_VECTOR (i, xml.Images)
+ {
+ const CImageInfo &image2 = xml.Images[i];
+ if (image2.MTimeDefined)
+ if (index < 0 || ::CompareFileTime(&image2.MTime, &xml.Images[index].MTime) > 0)
+ index = (int)i;
+ }
+ if (index >= 0)
+ prop = xml.Images[index].MTime;
+ }
+ break;
+
+ case kpidComment:
+ if (image)
+ {
+ if (_xmlInComments)
+ {
+ UString s;
+ _xmls[0].ToUnicode(s);
+ prop = s;
+ }
+ else if (image->NameDefined)
+ prop = image->Name;
+ }
+ break;
+
+ case kpidUnpackVer:
+ {
+ UInt32 ver1 = _version >> 16;
+ UInt32 ver2 = (_version >> 8) & 0xFF;
+ UInt32 ver3 = (_version) & 0xFF;
+
+ AString res;
+ res.Add_UInt32(ver1);
+ res.Add_Dot();
+ res.Add_UInt32(ver2);
+ if (ver3 != 0)
+ {
+ res.Add_Dot();
+ res.Add_UInt32(ver3);
+ }
+ prop = res;
+ break;
+ }
+
+ case kpidIsVolume:
+ if (_xmls.Size() > 0)
+ {
+ UInt16 volIndex = _xmls[0].VolIndex;
+ if (volIndex < _volumes.Size())
+ prop = (_volumes[volIndex].Header.NumParts > 1);
+ }
+ break;
+ case kpidVolume:
+ if (_xmls.Size() > 0)
+ {
+ UInt16 volIndex = _xmls[0].VolIndex;
+ if (volIndex < _volumes.Size())
+ prop = (UInt32)_volumes[volIndex].Header.PartNumber;
+ }
+ break;
+ case kpidNumVolumes: if (_volumes.Size() > 0) prop = (UInt32)(_volumes.Size() - 1); break;
+
+ case kpidClusterSize:
+ if (_xmls.Size() > 0)
+ {
+ UInt16 volIndex = _xmls[0].VolIndex;
+ if (volIndex < _volumes.Size())
+ {
+ const CHeader &h = _volumes[volIndex].Header;
+ prop = (UInt32)1 << h.ChunkSizeBits;
+ }
+ }
+ break;
+
+ case kpidName:
+ if (_firstVolumeIndex >= 0)
+ {
+ const CHeader &h = _volumes[_firstVolumeIndex].Header;
+ if (GetUi32(h.Guid) != 0)
+ {
+ char temp[64];
+ RawLeGuidToString(h.Guid, temp);
+ temp[8] = 0; // for reduced GUID
+ AString s (temp);
+ const char *ext = ".wim";
+ if (h.NumParts != 1)
+ {
+ s += '_';
+ if (h.PartNumber != 1)
+ s.Add_UInt32(h.PartNumber);
+ ext = ".swm";
+ }
+ s += ext;
+ prop = s;
+ }
+ }
+ break;
+
+ case kpidExtension:
+ if (_firstVolumeIndex >= 0)
+ {
+ const CHeader &h = _volumes[_firstVolumeIndex].Header;
+ if (h.NumParts > 1)
+ {
+ AString s;
+ if (h.PartNumber != 1)
+ {
+ s.Add_UInt32(h.PartNumber);
+ s.Add_Dot();
+ }
+ s += "swm";
+ prop = s;
+ }
+ }
+ break;
+
+ case kpidNumImages: prop = (UInt32)_db.Images.Size(); break;
+ case kpidBootImage: if (_bootIndex != 0) prop = (UInt32)_bootIndex; break;
+
+ case kpidMethod:
+ {
+ UInt32 methodUnknown = 0;
+ UInt32 methodMask = 0;
+ unsigned chunkSizeBits = 0;
+
+ {
+ FOR_VECTOR (i, _xmls)
+ {
+ const CHeader &header = _volumes[_xmls[i].VolIndex].Header;
+ unsigned method = header.GetMethod();
+ if (method < Z7_ARRAY_SIZE(k_Methods))
+ methodMask |= ((UInt32)1 << method);
+ else
+ methodUnknown = method;
+ if (chunkSizeBits < header.ChunkSizeBits)
+ chunkSizeBits = header.ChunkSizeBits;
+ }
+ }
+
+ AString res;
+
+ unsigned numMethods = 0;
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_Methods); i++)
+ {
+ if (methodMask & ((UInt32)1 << i))
+ {
+ res.Add_Space_if_NotEmpty();
+ res += k_Methods[i];
+ numMethods++;
+ }
+ }
+
+ if (methodUnknown != 0)
+ {
+ res.Add_Space_if_NotEmpty();
+ res.Add_UInt32(methodUnknown);
+ numMethods++;
+ }
+
+ if (numMethods == 1 && chunkSizeBits != 0)
+ {
+ res += ':';
+ res.Add_UInt32((UInt32)chunkSizeBits);
+ }
+
+ prop = res;
+ break;
+ }
+
+ case kpidIsTree: prop = true; break;
+ case kpidIsAltStream: prop = _db.ThereAreAltStreams; break;
+ case kpidIsAux: prop = true; break;
+ // WIM uses special prefix to represent deleted items
+ // case kpidIsDeleted: prop = _db.ThereAreDeletedStreams; break;
+ case kpidINode: prop = true; break;
+
+ case kpidErrorFlags:
+ {
+ UInt32 flags = 0;
+ if (!_isArc) flags |= kpv_ErrorFlags_IsNotArc;
+ if (_db.HeadersError) flags |= kpv_ErrorFlags_HeadersError;
+ if (_unsupported) flags |= kpv_ErrorFlags_UnsupportedMethod;
+ prop = flags;
+ break;
+ }
+
+ case kpidWarning:
+ {
+ AString s;
+ if (_xmlError)
+ AddErrorMessage(s, "XML error");
+ if (_db.RefCountError)
+ AddErrorMessage(s, "Some files have incorrect reference count");
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidReadOnly:
+ {
+ bool readOnly = !IsUpdateSupported();
+ if (readOnly)
+ prop = readOnly;
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+static void GetFileTime(const Byte *p, NCOM::CPropVariant &prop)
+{
+ prop.vt = VT_FILETIME;
+ prop.filetime.dwLowDateTime = Get32(p);
+ prop.filetime.dwHighDateTime = Get32(p + 4);
+ prop.Set_FtPrec(k_PropVar_TimePrec_100ns);
+}
+
+
+static void MethodToProp(int method, int chunksSizeBits, NCOM::CPropVariant &prop)
+{
+ if (method >= 0)
+ {
+ char temp[32];
+
+ if ((unsigned)method < Z7_ARRAY_SIZE(k_Methods))
+ MyStringCopy(temp, k_Methods[(unsigned)method]);
+ else
+ ConvertUInt32ToString((UInt32)(unsigned)method, temp);
+
+ if (chunksSizeBits >= 0)
+ {
+ size_t pos = strlen(temp);
+ temp[pos++] = ':';
+ ConvertUInt32ToString((unsigned)chunksSizeBits, temp + pos);
+ }
+
+ prop = temp;
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ if (index < _db.SortedItems.Size())
+ {
+ unsigned realIndex = _db.SortedItems[index];
+ const CItem &item = _db.Items[realIndex];
+ const CStreamInfo *si = NULL;
+ const CVolume *vol = NULL;
+ if (item.StreamIndex >= 0)
+ {
+ si = &_db.DataStreams[item.StreamIndex];
+ vol = &_volumes[si->PartNumber];
+ }
+
+ const CItem *mainItem = &item;
+ if (item.IsAltStream)
+ mainItem = &_db.Items[item.Parent];
+ const Byte *metadata = NULL;
+ if (mainItem->ImageIndex >= 0)
+ metadata = _db.Images[mainItem->ImageIndex].Meta + mainItem->Offset;
+
+ switch (propID)
+ {
+ case kpidPath:
+ if (item.ImageIndex >= 0)
+ _db.GetItemPath(realIndex, _showImageNumber, prop);
+ else
+ {
+ /*
+ while (s.Len() < _nameLenForStreams)
+ s = '0' + s;
+ */
+ /*
+ if (si->Resource.IsFree())
+ s = (AString)("[Free]" STRING_PATH_SEPARATOR) + sz;
+ else
+ */
+ AString s (FILES_DIR_NAME STRING_PATH_SEPARATOR);
+ s.Add_UInt32((UInt32)(Int32)item.StreamIndex);
+ prop = s;
+ }
+ break;
+
+ case kpidName:
+ if (item.ImageIndex >= 0)
+ _db.GetItemName(realIndex, prop);
+ else
+ {
+ char sz[16];
+ ConvertUInt32ToString((UInt32)(Int32)item.StreamIndex, sz);
+ /*
+ AString s = sz;
+ while (s.Len() < _nameLenForStreams)
+ s = '0' + s;
+ */
+ prop = sz;
+ }
+ break;
+
+ case kpidShortName:
+ if (item.ImageIndex >= 0 && !item.IsAltStream)
+ _db.GetShortName(realIndex, prop);
+ break;
+
+ case kpidPackSize:
+ {
+ if (si)
+ {
+ if (!si->Resource.IsSolidSmall())
+ prop = si->Resource.PackSize;
+ else
+ {
+ if (si->Resource.SolidIndex >= 0)
+ {
+ const CSolid &ss = _db.Solids[(unsigned)si->Resource.SolidIndex];
+ if (ss.FirstSmallStream == item.StreamIndex)
+ prop = _db.DataStreams[ss.StreamIndex].Resource.PackSize;
+ }
+ }
+ }
+ else if (!item.IsDir)
+ prop = (UInt64)0;
+
+ break;
+ }
+
+ case kpidSize:
+ {
+ if (si)
+ {
+ if (si->Resource.IsSolid())
+ {
+ if (si->Resource.IsSolidBig())
+ {
+ if (si->Resource.SolidIndex >= 0)
+ {
+ const CSolid &ss = _db.Solids[(unsigned)si->Resource.SolidIndex];
+ prop = ss.UnpackSize;
+ }
+ }
+ else
+ prop = si->Resource.PackSize;
+ }
+ else
+ prop = si->Resource.UnpackSize;
+ }
+ else if (!item.IsDir)
+ prop = (UInt64)0;
+
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir; break;
+ case kpidIsAltStream: prop = item.IsAltStream; break;
+ case kpidNumAltStreams:
+ {
+ if (!item.IsAltStream && mainItem->HasMetadata())
+ {
+ UInt32 dirRecordSize = _db.IsOldVersion ? kDirRecordSizeOld : kDirRecordSize;
+ UInt32 numAltStreams = Get16(metadata + dirRecordSize - 6);
+ if (numAltStreams != 0)
+ {
+ if (!item.IsDir)
+ numAltStreams--;
+ prop = numAltStreams;
+ }
+ }
+ break;
+ }
+
+ case kpidAttrib:
+ if (!item.IsAltStream && mainItem->ImageIndex >= 0)
+ {
+ /*
+ if (fileNameLen == 0 && isDir && !item.HasStream())
+ item.Attrib = 0x10; // some swm archives have system/hidden attributes for root
+ */
+ prop = (UInt32)Get32(metadata + 8);
+ }
+ break;
+ case kpidCTime: if (mainItem->HasMetadata()) GetFileTime(metadata + (_db.IsOldVersion ? 0x18: 0x28), prop); break;
+ case kpidATime: if (mainItem->HasMetadata()) GetFileTime(metadata + (_db.IsOldVersion ? 0x20: 0x30), prop); break;
+ case kpidMTime: if (mainItem->HasMetadata()) GetFileTime(metadata + (_db.IsOldVersion ? 0x28: 0x38), prop); break;
+
+ case kpidINode:
+ if (mainItem->HasMetadata() && !_isOldVersion)
+ {
+ UInt32 attrib = (UInt32)Get32(metadata + 8);
+ if ((attrib & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
+ {
+ // we don't know about that field in OLD WIM format
+ unsigned offset = 0x58; // (_db.IsOldVersion ? 0x30: 0x58);
+ UInt64 val = Get64(metadata + offset);
+ if (val != 0)
+ prop = val;
+ }
+ }
+ break;
+
+ case kpidStreamId:
+ if (item.StreamIndex >= 0)
+ prop = (UInt32)item.StreamIndex;
+ break;
+
+ case kpidMethod:
+ if (si)
+ {
+ const CResource &r = si->Resource;
+ if (r.IsSolid())
+ {
+ if (r.SolidIndex >= 0)
+ {
+ CSolid &ss = _db.Solids[r.SolidIndex];
+ MethodToProp(ss.Method, (int)ss.ChunkSizeBits, prop);
+ }
+ }
+ else
+ {
+ int method = 0;
+ int chunkSizeBits = -1;
+ if (r.IsCompressed())
+ {
+ method = (int)vol->Header.GetMethod();
+ chunkSizeBits = (int)vol->Header.ChunkSizeBits;
+ }
+ MethodToProp(method, chunkSizeBits, prop);
+ }
+ }
+ break;
+
+ case kpidSolid: if (si) prop = si->Resource.IsSolid(); break;
+ case kpidLinks: if (si) prop = (UInt32)si->RefCount; break;
+ #ifdef WIM_DETAILS
+ case kpidVolume: if (si) prop = (UInt32)si->PartNumber; break;
+ case kpidOffset: if (si) prop = (UInt64)si->Resource.Offset; break;
+ #endif
+ }
+ }
+ else
+ {
+ index -= _db.SortedItems.Size();
+ if (index < _numXmlItems)
+ {
+ switch (propID)
+ {
+ case kpidPath:
+ case kpidName: prop = _xmls[index].FileName; break;
+ case kpidIsDir: prop = false; break;
+ case kpidPackSize:
+ case kpidSize: prop = (UInt64)_xmls[index].Data.Size(); break;
+ case kpidMethod: /* prop = k_Method_Copy; */ break;
+ }
+ }
+ else
+ {
+ index -= _numXmlItems;
+ switch (propID)
+ {
+ case kpidPath:
+ case kpidName:
+ if (index < (UInt32)_db.VirtualRoots.Size())
+ prop = _db.Images[_db.VirtualRoots[index]].RootName;
+ else
+ prop = FILES_DIR_NAME;
+ break;
+ case kpidIsDir: prop = true; break;
+ case kpidIsAux: prop = true; break;
+ }
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetRootProp(PROPID propID, PROPVARIANT *value))
+{
+ // COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (_db.Images.Size() != 0 && _db.NumExcludededItems != 0)
+ {
+ const CImage &image = _db.Images[_db.IndexOfUserImage];
+ const CItem &item = _db.Items[image.StartItem];
+ if (!item.IsDir || item.ImageIndex != _db.IndexOfUserImage)
+ return E_FAIL;
+ const Byte *metadata = image.Meta + item.Offset;
+
+ switch (propID)
+ {
+ case kpidIsDir: prop = true; break;
+ case kpidAttrib: prop = (UInt32)Get32(metadata + 8); break;
+ case kpidCTime: GetFileTime(metadata + (_db.IsOldVersion ? 0x18: 0x28), prop); break;
+ case kpidATime: GetFileTime(metadata + (_db.IsOldVersion ? 0x20: 0x30), prop); break;
+ case kpidMTime: GetFileTime(metadata + (_db.IsOldVersion ? 0x28: 0x38), prop); break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ // COM_TRY_END
+}
+
+HRESULT CHandler::GetSecurity(UInt32 realIndex, const void **data, UInt32 *dataSize, UInt32 *propType)
+{
+ const CItem &item = _db.Items[realIndex];
+ if (item.IsAltStream || item.ImageIndex < 0)
+ return S_OK;
+ const CImage &image = _db.Images[item.ImageIndex];
+ const Byte *metadata = image.Meta + item.Offset;
+ UInt32 securityId = Get32(metadata + 0xC);
+ if (securityId == (UInt32)(Int32)-1)
+ return S_OK;
+ if (securityId >= (UInt32)image.SecurOffsets.Size())
+ return E_FAIL;
+ UInt32 offs = image.SecurOffsets[securityId];
+ UInt32 len = image.SecurOffsets[securityId + 1] - offs;
+ const CByteBuffer &buf = image.Meta;
+ if (offs <= buf.Size() && buf.Size() - offs >= len)
+ {
+ *data = buf + offs;
+ *dataSize = len;
+ *propType = NPropDataType::kRaw;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRootRawProp(PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ if (propID == kpidNtSecure && _db.Images.Size() != 0 && _db.NumExcludededItems != 0)
+ {
+ const CImage &image = _db.Images[_db.IndexOfUserImage];
+ const CItem &item = _db.Items[image.StartItem];
+ if (!item.IsDir || item.ImageIndex != _db.IndexOfUserImage)
+ return E_FAIL;
+ return GetSecurity(image.StartItem, data, dataSize, propType);
+ }
+ return S_OK;
+}
+
+static const Byte kRawProps[] =
+{
+ kpidSha1,
+ kpidNtReparse,
+ kpidNtSecure
+};
+
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = Z7_ARRAY_SIZE(kRawProps);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+{
+ *propID = kRawProps[index];
+ *name = NULL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+ if (index >= _db.SortedItems.Size())
+ return S_OK;
+
+ const CItem &item = _db.Items[_db.SortedItems[index]];
+
+ if (item.ImageIndex >= 0)
+ {
+ *parentType = item.IsAltStream ? NParentType::kAltStream : NParentType::kDir;
+ if (item.Parent >= 0)
+ {
+ if (_db.ExludedItem != item.Parent)
+ *parent = (unsigned)_db.Items[item.Parent].IndexInSorted;
+ }
+ else
+ {
+ CImage &image = _db.Images[item.ImageIndex];
+ if (image.VirtualRootIndex >= 0)
+ *parent = _db.SortedItems.Size() + _numXmlItems + (unsigned)image.VirtualRootIndex;
+ }
+ }
+ else
+ *parent = _db.SortedItems.Size() + _numXmlItems + _db.VirtualRoots.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (propID == kpidName)
+ {
+ if (index < _db.SortedItems.Size())
+ {
+ const CItem &item = _db.Items[_db.SortedItems[index]];
+ if (item.ImageIndex < 0)
+ return S_OK;
+ const CImage &image = _db.Images[item.ImageIndex];
+ *propType = NPropDataType::kUtf16z;
+ if (image.NumEmptyRootItems != 0 && item.Parent < 0)
+ {
+ const CByteBuffer &buf = _db.Images[item.ImageIndex].RootNameBuf;
+ *data = (void *)(const Byte *)buf;
+ *dataSize = (UInt32)buf.Size();
+ return S_OK;
+ }
+ const Byte *meta = image.Meta + item.Offset +
+ (item.IsAltStream ?
+ (_isOldVersion ? 0x10 : 0x24) :
+ (_isOldVersion ? kDirRecordSizeOld - 2 : kDirRecordSize - 2));
+ *data = (const void *)(meta + 2);
+ *dataSize = (UInt32)Get16(meta) + 2;
+ return S_OK;
+ }
+ {
+ index -= _db.SortedItems.Size();
+ if (index < _numXmlItems)
+ return S_OK;
+ index -= _numXmlItems;
+ if (index >= (UInt32)_db.VirtualRoots.Size())
+ return S_OK;
+ const CByteBuffer &buf = _db.Images[_db.VirtualRoots[index]].RootNameBuf;
+ *data = (void *)(const Byte *)buf;
+ *dataSize = (UInt32)buf.Size();
+ *propType = NPropDataType::kUtf16z;
+ return S_OK;
+ }
+ }
+
+ if (index >= _db.SortedItems.Size())
+ return S_OK;
+
+ unsigned index2 = _db.SortedItems[index];
+
+ if (propID == kpidNtSecure)
+ {
+ return GetSecurity(index2, data, dataSize, propType);
+ }
+
+ const CItem &item = _db.Items[index2];
+ if (propID == kpidSha1)
+ {
+ if (item.StreamIndex >= 0)
+ *data = _db.DataStreams[item.StreamIndex].Hash;
+ else
+ {
+ if (_isOldVersion)
+ return S_OK;
+ const Byte *sha1 = _db.Images[item.ImageIndex].Meta + item.Offset + (item.IsAltStream ? 0x10 : 0x40);
+ if (IsEmptySha(sha1))
+ return S_OK;
+ *data = sha1;
+ }
+ *dataSize = kHashSize;
+ *propType = NPropDataType::kRaw;
+ return S_OK;
+ }
+
+ if (propID == kpidNtReparse && !_isOldVersion)
+ {
+ // we don't know about Reparse field in OLD WIM format
+
+ if (item.StreamIndex < 0)
+ return S_OK;
+ if (index2 >= _db.ItemToReparse.Size())
+ return S_OK;
+ int reparseIndex = _db.ItemToReparse[index2];
+ if (reparseIndex < 0)
+ return S_OK;
+ const CByteBuffer &buf = _db.ReparseItems[reparseIndex];
+ if (buf.Size() == 0)
+ return S_OK;
+ *data = buf;
+ *dataSize = (UInt32)buf.Size();
+ *propType = NPropDataType::kRaw;
+ return S_OK;
+ }
+
+ return S_OK;
+}
+
+class CVolumeName
+{
+ UString _before;
+ UString _after;
+public:
+ void InitName(const UString &name)
+ {
+ int dotPos = name.ReverseFind_Dot();
+ if (dotPos < 0)
+ dotPos = (int)name.Len();
+ _before.SetFrom(name.Ptr(), (unsigned)dotPos);
+ _after = name.Ptr(dotPos);
+ }
+
+ UString GetNextName(UInt32 index) const
+ {
+ UString s = _before;
+ s.Add_UInt32(index);
+ s += _after;
+ return s;
+ }
+};
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+
+ Close();
+ {
+ CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
+
+ CVolumeName seqName;
+ if (callback)
+ callback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&openVolumeCallback);
+
+ UInt32 numVolumes = 1;
+
+ for (UInt32 i = 1; i <= numVolumes; i++)
+ {
+ CMyComPtr<IInStream> curStream;
+
+ if (i == 1)
+ curStream = inStream;
+ else
+ {
+ if (!openVolumeCallback)
+ continue;
+ const UString fullName = seqName.GetNextName(i);
+ const HRESULT result = openVolumeCallback->GetStream(fullName, &curStream);
+ if (result == S_FALSE)
+ continue;
+ if (result != S_OK)
+ return result;
+ if (!curStream)
+ break;
+ }
+
+ CHeader header;
+ HRESULT res = NWim::ReadHeader(curStream, header, _phySize);
+
+ if (res != S_OK)
+ {
+ if (i != 1 && res == S_FALSE)
+ continue;
+ return res;
+ }
+
+ _isArc = true;
+ _bootIndex = header.BootIndex;
+ _version = header.Version;
+ _isOldVersion = header.IsOldVersion();
+ if (_firstVolumeIndex >= 0)
+ if (!header.AreFromOnArchive(_volumes[_firstVolumeIndex].Header))
+ break;
+ if (_volumes.Size() > header.PartNumber && _volumes[header.PartNumber].Stream)
+ break;
+ CWimXml xml;
+ xml.VolIndex = header.PartNumber;
+ res = _db.OpenXml(curStream, header, xml.Data);
+
+ if (res == S_OK)
+ {
+ if (!xml.Parse())
+ _xmlError = true;
+
+ if (xml.IsEncrypted)
+ {
+ _unsupported = true;
+ return S_FALSE;
+ }
+
+ UInt64 totalFiles = xml.GetTotalFilesAndDirs() + xml.Images.Size();
+ totalFiles += 16 + xml.Images.Size() * 4; // we reserve some additional items
+ if (totalFiles >= ((UInt32)1 << 30))
+ totalFiles = 0;
+ res = _db.Open(curStream, header, (unsigned)totalFiles, callback);
+ }
+
+ if (res != S_OK)
+ {
+ if (i != 1 && res == S_FALSE)
+ continue;
+ return res;
+ }
+
+ while (_volumes.Size() <= header.PartNumber)
+ _volumes.AddNew();
+ CVolume &volume = _volumes[header.PartNumber];
+ volume.Header = header;
+ volume.Stream = curStream;
+
+ _firstVolumeIndex = header.PartNumber;
+
+ if (_xmls.IsEmpty() || xml.Data != _xmls[0].Data)
+ {
+ xml.FileName = '[';
+ xml.FileName.Add_UInt32(xml.VolIndex);
+ xml.FileName += "].xml";
+ _xmls.Add(xml);
+ }
+
+ if (i == 1)
+ {
+ if (header.PartNumber != 1)
+ break;
+ if (!openVolumeCallback)
+ break;
+ numVolumes = header.NumParts;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
+ if (prop.vt != VT_BSTR)
+ break;
+ seqName.InitName(prop.bstrVal);
+ }
+ }
+ }
+
+ RINOK(_db.FillAndCheck(_volumes))
+ int defaultImageIndex = (int)_defaultImageNumber - 1;
+
+ bool showImageNumber = (_db.Images.Size() != 1 && defaultImageIndex < 0);
+ if (!showImageNumber && _set_use_ShowImageNumber)
+ showImageNumber = _set_showImageNumber;
+
+ if (!showImageNumber && _keepMode_ShowImageNumber)
+ showImageNumber = true;
+
+ _showImageNumber = showImageNumber;
+
+ RINOK(_db.GenerateSortedItems(defaultImageIndex, showImageNumber))
+ RINOK(_db.ExtractReparseStreams(_volumes, callback))
+
+ /*
+ wchar_t sz[16];
+ ConvertUInt32ToString(_db.DataStreams.Size(), sz);
+ _nameLenForStreams = MyStringLen(sz);
+ */
+
+ _xmlInComments = !_showImageNumber;
+ _numXmlItems = (_xmlInComments ? 0 : _xmls.Size());
+ _numIgnoreItems = _db.ThereAreDeletedStreams ? 1 : 0;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _firstVolumeIndex = -1;
+ _phySize = 0;
+ _db.Clear();
+ _volumes.Clear();
+ _xmls.Clear();
+ // _nameLenForStreams = 0;
+ _xmlInComments = false;
+ _numXmlItems = 0;
+ _numIgnoreItems = 0;
+ _xmlError = false;
+ _isArc = false;
+ _unsupported = false;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+
+ if (allFilesMode)
+ numItems = _db.SortedItems.Size() + _numXmlItems + _db.VirtualRoots.Size() + _numIgnoreItems;
+ if (numItems == 0)
+ return S_OK;
+
+ UInt32 i;
+ UInt64 totalSize = 0;
+
+ for (i = 0; i < numItems; i++)
+ {
+ UInt32 index = allFilesMode ? i : indices[i];
+ if (index < _db.SortedItems.Size())
+ {
+ int streamIndex = _db.Items[_db.SortedItems[index]].StreamIndex;
+ if (streamIndex >= 0)
+ {
+ const CStreamInfo &si = _db.DataStreams[streamIndex];
+ totalSize += _db.Get_UnpackSize_of_Resource(si.Resource);
+ }
+ }
+ else
+ {
+ index -= _db.SortedItems.Size();
+ if (index < _numXmlItems)
+ totalSize += _xmls[index].Data.Size();
+ }
+ }
+
+ RINOK(extractCallback->SetTotal(totalSize))
+
+ UInt64 currentTotalUnPacked = 0;
+ UInt64 currentItemUnPacked;
+
+ int prevSuccessStreamIndex = -1;
+
+ CUnpacker unpacker;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0;; i++,
+ currentTotalUnPacked += currentItemUnPacked)
+ {
+ currentItemUnPacked = 0;
+
+ lps->InSize = unpacker.TotalPacked;
+ lps->OutSize = currentTotalUnPacked;
+
+ RINOK(lps->SetCur())
+
+ if (i >= numItems)
+ break;
+
+ UInt32 index = allFilesMode ? i : indices[i];
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (index >= _db.SortedItems.Size())
+ {
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ index -= _db.SortedItems.Size();
+ if (index < _numXmlItems)
+ {
+ const CByteBuffer &data = _xmls[index].Data;
+ currentItemUnPacked = data.Size();
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, (const Byte *)data, data.Size()))
+ realOutStream.Release();
+ }
+ }
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const CItem &item = _db.Items[_db.SortedItems[index]];
+ int streamIndex = item.StreamIndex;
+ if (streamIndex < 0)
+ {
+ if (!item.IsDir)
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(!item.IsDir && _db.ItemHasStream(item) ?
+ NExtract::NOperationResult::kDataError :
+ NExtract::NOperationResult::kOK))
+ continue;
+ }
+
+ const CStreamInfo &si = _db.DataStreams[streamIndex];
+ currentItemUnPacked = _db.Get_UnpackSize_of_Resource(si.Resource);
+ // currentItemPacked = _db.Get_PackSize_of_Resource(streamIndex);
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+ Int32 opRes = NExtract::NOperationResult::kOK;
+
+ if (streamIndex != prevSuccessStreamIndex || realOutStream)
+ {
+ Byte digest[kHashSize];
+ const CVolume &vol = _volumes[si.PartNumber];
+ bool needDigest = !si.IsEmptyHash();
+
+ HRESULT res = unpacker.Unpack(vol.Stream, si.Resource, vol.Header, &_db,
+ realOutStream, progress, needDigest ? digest : NULL);
+
+ if (res == S_OK)
+ {
+ if (!needDigest || memcmp(digest, si.Hash, kHashSize) == 0)
+ prevSuccessStreamIndex = streamIndex;
+ else
+ opRes = NExtract::NOperationResult::kCRCError;
+ }
+ else if (res == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (res == E_NOTIMPL)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else
+ return res;
+ }
+
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _db.SortedItems.Size() +
+ _numXmlItems +
+ _db.VirtualRoots.Size() +
+ _numIgnoreItems;
+ return S_OK;
+}
+
+CHandler::CHandler()
+{
+ _keepMode_ShowImageNumber = false;
+ InitDefaults();
+ _xmlError = false;
+}
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ InitDefaults();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ UString name = names[i];
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ const PROPVARIANT &prop = values[i];
+
+ if (name[0] == L'x')
+ {
+ // some clients write 'x' property. So we support it
+ UInt32 level = 0;
+ RINOK(ParsePropToUInt32(name.Ptr(1), prop, level))
+ }
+ else if (name.IsEqualTo("is"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, _set_showImageNumber))
+ _set_use_ShowImageNumber = true;
+ }
+ else if (name.IsEqualTo("im"))
+ {
+ UInt32 image = 9;
+ RINOK(ParsePropToUInt32(L"", prop, image))
+ _defaultImageNumber = (int)image;
+ }
+ else if (name.IsPrefixedBy_Ascii_NoCase("mt"))
+ {
+ }
+ else if (name.IsPrefixedBy_Ascii_NoCase("memuse"))
+ {
+ }
+ else
+ {
+ bool processed = false;
+ RINOK(_timeOptions.Parse(name, prop, processed))
+ if (!processed)
+ return E_INVALIDARG;
+ }
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::KeepModeForNextOpen())
+{
+ _keepMode_ShowImageNumber = _showImageNumber;
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Wim/WimHandler.h b/CPP/7zip/Archive/Wim/WimHandler.h
new file mode 100644
index 0000000..60bb156
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/WimHandler.h
@@ -0,0 +1,93 @@
+// WimHandler.h
+
+#ifndef ZIP7_INC_ARCHIVE_WIM_HANDLER_H
+#define ZIP7_INC_ARCHIVE_WIM_HANDLER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../Common/HandlerOut.h"
+
+#include "WimIn.h"
+
+namespace NArchive {
+namespace NWim {
+
+static const Int32 kNumImagesMaxUpdate = (1 << 10);
+
+Z7_CLASS_IMP_CHandler_IInArchive_5(
+ IArchiveGetRawProps
+ , IArchiveGetRootProps
+ , IArchiveKeepModeForNextOpen
+ , ISetProperties
+ , IOutArchive
+)
+ CDatabase _db;
+ UInt32 _version;
+ bool _isOldVersion;
+ UInt32 _bootIndex;
+
+ CObjectVector<CVolume> _volumes;
+ CObjectVector<CWimXml> _xmls;
+ // unsigned _nameLenForStreams;
+ bool _xmlInComments;
+
+ unsigned _numXmlItems;
+ unsigned _numIgnoreItems;
+
+ bool _xmlError;
+ bool _isArc;
+ bool _unsupported;
+
+ bool _set_use_ShowImageNumber;
+ bool _set_showImageNumber;
+ int _defaultImageNumber;
+
+ bool _showImageNumber;
+
+ bool _keepMode_ShowImageNumber;
+
+ UInt64 _phySize;
+ int _firstVolumeIndex;
+
+ CHandlerTimeOptions _timeOptions;
+
+ void InitDefaults()
+ {
+ _set_use_ShowImageNumber = false;
+ _set_showImageNumber = false;
+ _defaultImageNumber = -1;
+ _timeOptions.Init();
+ }
+
+ bool IsUpdateSupported() const
+ {
+ if (ThereIsError()) return false;
+ if (_db.Images.Size() > kNumImagesMaxUpdate) return false;
+
+ // Solid format is complicated. So we disable updating now.
+ if (!_db.Solids.IsEmpty()) return false;
+
+ if (_volumes.Size() == 0)
+ return true;
+
+ if (_volumes.Size() != 2) return false;
+ if (_volumes[0].Stream) return false;
+ if (_version != k_Version_NonSolid
+ // && _version != k_Version_Solid
+ ) return false;
+
+ return true;
+ }
+
+ bool ThereIsError() const { return _xmlError || _db.ThereIsError(); }
+ HRESULT GetSecurity(UInt32 realIndex, const void **data, UInt32 *dataSize, UInt32 *propType);
+
+ HRESULT GetOutProperty(IArchiveUpdateCallback *callback, UInt32 callbackIndex, Int32 arcIndex, PROPID propID, PROPVARIANT *value);
+ HRESULT GetTime(IArchiveUpdateCallback *callback, UInt32 callbackIndex, Int32 arcIndex, PROPID propID, FILETIME &ft);
+public:
+ CHandler();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Wim/WimHandlerOut.cpp b/CPP/7zip/Archive/Wim/WimHandlerOut.cpp
new file mode 100644
index 0000000..5d9dea2
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/WimHandlerOut.cpp
@@ -0,0 +1,2008 @@
+// WimHandlerOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer2.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/UTFConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+#include "../../Common/UniqBlocks.h"
+
+#include "../../Crypto/RandGen.h"
+#include "../../Crypto/Sha1Cls.h"
+
+#include "WimHandler.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NWim {
+
+static const unsigned k_NumSubVectors_Bits = 12; // must be <= 16
+
+struct CSortedIndex
+{
+ CObjectVector<CUIntVector> Vectors;
+
+ CSortedIndex()
+ {
+ const unsigned k_NumSubVectors = 1 << k_NumSubVectors_Bits;
+ Vectors.ClearAndReserve(k_NumSubVectors);
+ for (unsigned i = 0; i < k_NumSubVectors; i++)
+ Vectors.AddNew();
+ }
+};
+
+static int AddUniqHash(const CStreamInfo *streams, CSortedIndex &sorted2, const Byte *h, int streamIndexForInsert)
+{
+ const unsigned hash = (((unsigned)h[0] << 8) | (unsigned)h[1]) >> (16 - k_NumSubVectors_Bits);
+ CUIntVector &sorted = sorted2.Vectors[hash];
+ unsigned left = 0, right = sorted.Size();
+ while (left != right)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned index = sorted[mid];
+ const Byte *hash2 = streams[index].Hash;
+
+ unsigned i;
+ for (i = 0; i < kHashSize; i++)
+ if (h[i] != hash2[i])
+ break;
+
+ if (i == kHashSize)
+ return (int)index;
+
+ if (h[i] < hash2[i])
+ right = mid;
+ else
+ left = mid + 1;
+ }
+
+ if (streamIndexForInsert != -1)
+ sorted.Insert(left, (unsigned)streamIndexForInsert);
+
+ return -1;
+}
+
+
+struct CAltStream
+{
+ int UpdateIndex;
+ int HashIndex;
+ UInt64 Size;
+ UString Name;
+ bool Skip;
+
+ CAltStream(): UpdateIndex(-1), HashIndex(-1), Skip(false) {}
+};
+
+
+struct CMetaItem
+{
+ int UpdateIndex;
+ int HashIndex;
+
+ UInt64 Size;
+ FILETIME CTime;
+ FILETIME ATime;
+ FILETIME MTime;
+ UInt64 FileID;
+ UInt64 VolID;
+
+ UString Name;
+ UString ShortName;
+
+ UInt32 Attrib;
+ int SecurityId; // -1: means no secutity ID
+ bool IsDir;
+ bool Skip;
+ unsigned NumSkipAltStreams;
+ CObjectVector<CAltStream> AltStreams;
+
+ CByteBuffer Reparse;
+
+ unsigned GetNumAltStreams() const { return AltStreams.Size() - NumSkipAltStreams; }
+ CMetaItem():
+ UpdateIndex(-1)
+ , HashIndex(-1)
+ , Size(0)
+ , FileID(0)
+ , VolID(0)
+ , Attrib(0)
+ , SecurityId(-1)
+ , IsDir(false)
+ , Skip(false)
+ , NumSkipAltStreams(0)
+ {
+ FILETIME_Clear(CTime);
+ FILETIME_Clear(ATime);
+ FILETIME_Clear(MTime);
+ }
+};
+
+
+static int Compare_HardLink_MetaItems(const CMetaItem &a1, const CMetaItem &a2)
+{
+ if (a1.VolID < a2.VolID) return -1;
+ if (a1.VolID > a2.VolID) return 1;
+ if (a1.FileID < a2.FileID) return -1;
+ if (a1.FileID > a2.FileID) return 1;
+ if (a1.Size < a2.Size) return -1;
+ if (a1.Size > a2.Size) return 1;
+ return ::CompareFileTime(&a1.MTime, &a2.MTime);
+}
+
+
+static int AddToHardLinkList(const CObjectVector<CMetaItem> &metaItems, unsigned indexOfItem, CUIntVector &indexes)
+{
+ const CMetaItem &mi = metaItems[indexOfItem];
+ unsigned left = 0, right = indexes.Size();
+ while (left != right)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned index = indexes[mid];
+ const int comp = Compare_HardLink_MetaItems(mi, metaItems[index]);
+ if (comp == 0)
+ return (int)index;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ indexes.Insert(left, indexOfItem);
+ return -1;
+}
+
+
+struct CUpdateItem
+{
+ unsigned CallbackIndex; // index in callback
+
+ int MetaIndex; // index in in MetaItems[]
+
+ int AltStreamIndex; // index in CMetaItem::AltStreams vector
+ // -1: if not alt stream?
+
+ int InArcIndex; // >= 0, if we use OLD Data
+ // -1, if we use NEW Data
+
+ CUpdateItem(): MetaIndex(-1), AltStreamIndex(-1), InArcIndex(-1) {}
+};
+
+
+struct CDir
+{
+ int MetaIndex;
+ CObjectVector<CDir> Dirs;
+ CUIntVector Files; // indexes in MetaItems[]
+
+ CDir(): MetaIndex(-1) {}
+ unsigned GetNumDirs() const;
+ unsigned GetNumFiles() const;
+ UInt64 GetTotalSize(const CObjectVector<CMetaItem> &metaItems) const;
+ bool FindDir(const CObjectVector<CMetaItem> &items, const UString &name, unsigned &index);
+};
+
+/* imagex counts Junctions as files (not as dirs).
+ We suppose that it's not correct */
+
+unsigned CDir::GetNumDirs() const
+{
+ unsigned num = Dirs.Size();
+ FOR_VECTOR (i, Dirs)
+ num += Dirs[i].GetNumDirs();
+ return num;
+}
+
+unsigned CDir::GetNumFiles() const
+{
+ unsigned num = Files.Size();
+ FOR_VECTOR (i, Dirs)
+ num += Dirs[i].GetNumFiles();
+ return num;
+}
+
+UInt64 CDir::GetTotalSize(const CObjectVector<CMetaItem> &metaItems) const
+{
+ UInt64 sum = 0;
+ unsigned i;
+ for (i = 0; i < Files.Size(); i++)
+ sum += metaItems[Files[i]].Size;
+ for (i = 0; i < Dirs.Size(); i++)
+ sum += Dirs[i].GetTotalSize(metaItems);
+ return sum;
+}
+
+bool CDir::FindDir(const CObjectVector<CMetaItem> &items, const UString &name, unsigned &index)
+{
+ unsigned left = 0, right = Dirs.Size();
+ while (left != right)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const int comp = CompareFileNames(name, items[Dirs[mid].MetaIndex].Name);
+ if (comp == 0)
+ {
+ index = mid;
+ return true;
+ }
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ index = left;
+ return false;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *type))
+{
+ *type = NFileTimeType::kWindows;
+ return S_OK;
+}
+
+
+HRESULT CHandler::GetOutProperty(IArchiveUpdateCallback *callback, UInt32 callbackIndex, Int32 arcIndex, PROPID propID, PROPVARIANT *value)
+{
+ if (arcIndex != -1)
+ return GetProperty((UInt32)arcIndex, propID, value);
+ return callback->GetProperty(callbackIndex, propID, value);
+}
+
+
+HRESULT CHandler::GetTime(IArchiveUpdateCallback *callback, UInt32 callbackIndex, Int32 arcIndex, PROPID propID, FILETIME &ft)
+{
+ ft.dwLowDateTime = ft.dwHighDateTime = 0;
+ NCOM::CPropVariant prop;
+ RINOK(GetOutProperty(callback, callbackIndex, arcIndex, propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ ft = prop.filetime;
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+
+static HRESULT GetRootTime(
+ IArchiveGetRootProps *callback,
+ IArchiveGetRootProps *arcRoot,
+ PROPID propID, FILETIME &ft)
+{
+ NCOM::CPropVariant prop;
+ if (callback)
+ {
+ RINOK(callback->GetRootProp(propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ {
+ ft = prop.filetime;
+ return S_OK;
+ }
+ if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ if (arcRoot)
+ {
+ RINOK(arcRoot->GetRootProp(propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ {
+ ft = prop.filetime;
+ return S_OK;
+ }
+ if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+#define Set16(p, d) SetUi16(p, d)
+#define Set32(p, d) SetUi32(p, d)
+#define Set64(p, d) SetUi64(p, d)
+
+void CResource::WriteTo(Byte *p) const
+{
+ Set64(p, PackSize)
+ p[7] = Flags;
+ Set64(p + 8, Offset)
+ Set64(p + 16, UnpackSize)
+}
+
+
+void CHeader::WriteTo(Byte *p) const
+{
+ memcpy(p, kSignature, kSignatureSize);
+ Set32(p + 8, kHeaderSizeMax)
+ Set32(p + 0xC, Version)
+ Set32(p + 0x10, Flags)
+ Set32(p + 0x14, ChunkSize)
+ memcpy(p + 0x18, Guid, 16);
+ Set16(p + 0x28, PartNumber)
+ Set16(p + 0x2A, NumParts)
+ Set32(p + 0x2C, NumImages)
+ OffsetResource.WriteTo(p + 0x30);
+ XmlResource.WriteTo(p + 0x48);
+ MetadataResource.WriteTo(p + 0x60);
+ IntegrityResource.WriteTo(p + 0x7C);
+ Set32(p + 0x78, BootIndex)
+ memset(p + 0x94, 0, 60);
+}
+
+
+void CStreamInfo::WriteTo(Byte *p) const
+{
+ Resource.WriteTo(p);
+ Set16(p + 0x18, PartNumber)
+ Set32(p + 0x1A, RefCount)
+ memcpy(p + 0x1E, Hash, kHashSize);
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CInStreamWithSha1
+ , ISequentialInStream
+)
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt64 _size;
+ // NCrypto::NSha1::CContext _sha;
+ CAlignedBuffer1 _sha;
+ CSha1 *Sha() { return (CSha1 *)(void *)(Byte *)_sha; }
+public:
+ CInStreamWithSha1(): _sha(sizeof(CSha1)) {}
+ void SetStream(ISequentialInStream *stream) { _stream = stream; }
+ void Init()
+ {
+ _size = 0;
+ Sha1_Init(Sha());
+ }
+ void ReleaseStream() { _stream.Release(); }
+ UInt64 GetSize() const { return _size; }
+ void Final(Byte *digest) { Sha1_Final(Sha(), digest); }
+};
+
+Z7_COM7F_IMF(CInStreamWithSha1::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize;
+ const HRESULT result = _stream->Read(data, size, &realProcessedSize);
+ _size += realProcessedSize;
+ Sha1_Update(Sha(), (const Byte *)data, realProcessedSize);
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return result;
+}
+
+
+static void SetFileTimeToMem(Byte *p, const FILETIME &ft)
+{
+ Set32(p, ft.dwLowDateTime)
+ Set32(p + 4, ft.dwHighDateTime)
+}
+
+static size_t WriteItem_Dummy(const CMetaItem &item)
+{
+ if (item.Skip)
+ return 0;
+ unsigned fileNameLen = item.Name.Len() * 2;
+ // we write fileNameLen + 2 + 2 to be same as original WIM.
+ unsigned fileNameLen2 = (fileNameLen == 0 ? 0 : fileNameLen + 2);
+
+ const unsigned shortNameLen = item.ShortName.Len() * 2;
+ const unsigned shortNameLen2 = (shortNameLen == 0 ? 2 : shortNameLen + 4);
+
+ size_t totalLen = ((kDirRecordSize + fileNameLen2 + shortNameLen2 + 6) & ~(unsigned)7);
+ if (item.GetNumAltStreams() != 0)
+ {
+ if (!item.IsDir)
+ {
+ const UInt32 curLen = (((0x26 + 0) + 6) & ~(unsigned)7);
+ totalLen += curLen;
+ }
+ FOR_VECTOR (i, item.AltStreams)
+ {
+ const CAltStream &ss = item.AltStreams[i];
+ if (ss.Skip)
+ continue;
+ fileNameLen = ss.Name.Len() * 2;
+ fileNameLen2 = (fileNameLen == 0 ? 0 : fileNameLen + 2 + 2);
+ const UInt32 curLen = (((0x26 + fileNameLen2) + 6) & ~(unsigned)7);
+ totalLen += curLen;
+ }
+ }
+ return totalLen;
+}
+
+
+static size_t WriteItem(const CStreamInfo *streams, const CMetaItem &item, Byte *p)
+{
+ if (item.Skip)
+ return 0;
+ unsigned fileNameLen = item.Name.Len() * 2;
+ unsigned fileNameLen2 = (fileNameLen == 0 ? 0 : fileNameLen + 2);
+ unsigned shortNameLen = item.ShortName.Len() * 2;
+ unsigned shortNameLen2 = (shortNameLen == 0 ? 2 : shortNameLen + 4);
+
+ size_t totalLen = ((kDirRecordSize + fileNameLen2 + shortNameLen2 + 6) & ~(unsigned)7);
+
+ memset(p, 0, totalLen);
+ Set64(p, totalLen)
+ Set64(p + 8, item.Attrib)
+ Set32(p + 0xC, (UInt32)(Int32)item.SecurityId)
+ SetFileTimeToMem(p + 0x28, item.CTime);
+ SetFileTimeToMem(p + 0x30, item.ATime);
+ SetFileTimeToMem(p + 0x38, item.MTime);
+
+ /* WIM format probably doesn't support hard links to symbolic links.
+ In these cases it just stores symbolic links (REPARSE TAGS).
+ Check it in new versions of WIM software form MS !!!
+ We also follow that scheme */
+
+ if (item.Reparse.Size() != 0)
+ {
+ UInt32 tag = GetUi32(item.Reparse);
+ Set32(p + 0x58, tag)
+ // Set32(p + 0x5C, 0); // probably it's always ZERO
+ }
+ else if (item.FileID != 0)
+ {
+ Set64(p + 0x58, item.FileID)
+ }
+
+ Set16(p + 0x62, (UInt16)shortNameLen)
+ Set16(p + 0x64, (UInt16)fileNameLen)
+ unsigned i;
+ for (i = 0; i * 2 < fileNameLen; i++)
+ Set16(p + kDirRecordSize + i * 2, (UInt16)item.Name[i])
+ for (i = 0; i * 2 < shortNameLen; i++)
+ Set16(p + kDirRecordSize + fileNameLen2 + i * 2, (UInt16)item.ShortName[i])
+
+ if (item.GetNumAltStreams() == 0)
+ {
+ if (item.HashIndex >= 0)
+ memcpy(p + 0x40, streams[item.HashIndex].Hash, kHashSize);
+ }
+ else
+ {
+ Set16(p + 0x60, (UInt16)(item.GetNumAltStreams() + (item.IsDir ? 0 : 1)))
+ p += totalLen;
+
+ if (!item.IsDir)
+ {
+ const UInt32 curLen = (((0x26 + 0) + 6) & ~(unsigned)7);
+ memset(p, 0, curLen);
+ Set64(p, curLen)
+ if (item.HashIndex >= 0)
+ memcpy(p + 0x10, streams[item.HashIndex].Hash, kHashSize);
+ totalLen += curLen;
+ p += curLen;
+ }
+
+ FOR_VECTOR (si, item.AltStreams)
+ {
+ const CAltStream &ss = item.AltStreams[si];
+ if (ss.Skip)
+ continue;
+
+ fileNameLen = ss.Name.Len() * 2;
+ fileNameLen2 = (fileNameLen == 0 ? 0 : fileNameLen + 2 + 2);
+ UInt32 curLen = (((0x26 + fileNameLen2) + 6) & ~(unsigned)7);
+ memset(p, 0, curLen);
+
+ Set64(p, curLen)
+ if (ss.HashIndex >= 0)
+ memcpy(p + 0x10, streams[ss.HashIndex].Hash, kHashSize);
+ Set16(p + 0x24, (UInt16)fileNameLen)
+ for (i = 0; i * 2 < fileNameLen; i++)
+ Set16(p + 0x26 + i * 2, (UInt16)ss.Name[i])
+ totalLen += curLen;
+ p += curLen;
+ }
+ }
+
+ return totalLen;
+}
+
+
+struct CDb
+{
+ CMetaItem DefaultDirItem;
+ const CStreamInfo *Hashes;
+ CObjectVector<CMetaItem> MetaItems;
+ CRecordVector<CUpdateItem> UpdateItems;
+ CUIntVector UpdateIndexes; /* indexes in UpdateItems in order of writing data streams
+ to disk (the order of tree items). */
+
+ size_t WriteTree_Dummy(const CDir &tree) const;
+ void WriteTree(const CDir &tree, Byte *dest, size_t &pos) const;
+ void WriteOrderList(const CDir &tree);
+};
+
+
+size_t CDb::WriteTree_Dummy(const CDir &tree) const
+{
+ unsigned i;
+ size_t pos = 0;
+ for (i = 0; i < tree.Files.Size(); i++)
+ pos += WriteItem_Dummy(MetaItems[tree.Files[i]]);
+ for (i = 0; i < tree.Dirs.Size(); i++)
+ {
+ const CDir &subDir = tree.Dirs[i];
+ pos += WriteItem_Dummy(MetaItems[subDir.MetaIndex]);
+ pos += WriteTree_Dummy(subDir);
+ }
+ return pos + 8;
+}
+
+
+void CDb::WriteTree(const CDir &tree, Byte *dest, size_t &pos) const
+{
+ unsigned i;
+ for (i = 0; i < tree.Files.Size(); i++)
+ pos += WriteItem(Hashes, MetaItems[tree.Files[i]], dest + pos);
+
+ size_t posStart = pos;
+ for (i = 0; i < tree.Dirs.Size(); i++)
+ pos += WriteItem_Dummy(MetaItems[tree.Dirs[i].MetaIndex]);
+
+ Set64(dest + pos, 0)
+
+ pos += 8;
+
+ for (i = 0; i < tree.Dirs.Size(); i++)
+ {
+ const CDir &subDir = tree.Dirs[i];
+ const CMetaItem &metaItem = MetaItems[subDir.MetaIndex];
+ bool needCreateTree = (metaItem.Reparse.Size() == 0)
+ || !subDir.Files.IsEmpty()
+ || !subDir.Dirs.IsEmpty();
+ size_t len = WriteItem(Hashes, metaItem, dest + posStart);
+ posStart += len;
+ if (needCreateTree)
+ {
+ Set64(dest + posStart - len + 0x10, pos) // subdirOffset
+ WriteTree(subDir, dest, pos);
+ }
+ }
+}
+
+
+void CDb::WriteOrderList(const CDir &tree)
+{
+ if (tree.MetaIndex >= 0)
+ {
+ const CMetaItem &mi = MetaItems[tree.MetaIndex];
+ if (mi.UpdateIndex >= 0)
+ UpdateIndexes.Add((unsigned)mi.UpdateIndex);
+ FOR_VECTOR (si, mi.AltStreams)
+ UpdateIndexes.Add((unsigned)mi.AltStreams[si].UpdateIndex);
+ }
+
+ unsigned i;
+ for (i = 0; i < tree.Files.Size(); i++)
+ {
+ const CMetaItem &mi = MetaItems[tree.Files[i]];
+ UpdateIndexes.Add((unsigned)mi.UpdateIndex);
+ FOR_VECTOR (si, mi.AltStreams)
+ UpdateIndexes.Add((unsigned)mi.AltStreams[si].UpdateIndex);
+ }
+
+ for (i = 0; i < tree.Dirs.Size(); i++)
+ WriteOrderList(tree.Dirs[i]);
+}
+
+
+static void AddTag_ToString(AString &s, const char *name, const char *value)
+{
+ s += '<';
+ s += name;
+ s += '>';
+ s += value;
+ s += '<';
+ s += '/';
+ s += name;
+ s += '>';
+}
+
+
+static void AddTagUInt64_ToString(AString &s, const char *name, UInt64 value)
+{
+ char temp[32];
+ ConvertUInt64ToString(value, temp);
+ AddTag_ToString(s, name, temp);
+}
+
+
+static CXmlItem &AddUniqueTag(CXmlItem &parentItem, const char *name)
+{
+ int index = parentItem.FindSubTag(name);
+ if (index < 0)
+ {
+ CXmlItem &subItem = parentItem.SubItems.AddNew();
+ subItem.IsTag = true;
+ subItem.Name = name;
+ return subItem;
+ }
+ CXmlItem &subItem = parentItem.SubItems[index];
+ subItem.SubItems.Clear();
+ return subItem;
+}
+
+
+static void AddTag_UInt64_2(CXmlItem &item, UInt64 value)
+{
+ CXmlItem &subItem = item.SubItems.AddNew();
+ subItem.IsTag = false;
+ char temp[32];
+ ConvertUInt64ToString(value, temp);
+ subItem.Name = temp;
+}
+
+
+static void AddTag_UInt64(CXmlItem &parentItem, const char *name, UInt64 value)
+{
+ AddTag_UInt64_2(AddUniqueTag(parentItem, name), value);
+}
+
+
+static void AddTag_Hex(CXmlItem &item, const char *name, UInt32 value)
+{
+ item.IsTag = true;
+ item.Name = name;
+ char temp[16];
+ temp[0] = '0';
+ temp[1] = 'x';
+ ConvertUInt32ToHex8Digits(value, temp + 2);
+ CXmlItem &subItem = item.SubItems.AddNew();
+ subItem.IsTag = false;
+ subItem.Name = temp;
+}
+
+
+static void AddTag_Time_2(CXmlItem &item, const FILETIME &ft)
+{
+ AddTag_Hex(item.SubItems.AddNew(), "HIGHPART", ft.dwHighDateTime);
+ AddTag_Hex(item.SubItems.AddNew(), "LOWPART", ft.dwLowDateTime);
+}
+
+
+static void AddTag_Time(CXmlItem &parentItem, const char *name, const FILETIME &ft)
+{
+ AddTag_Time_2(AddUniqueTag(parentItem, name), ft);
+}
+
+
+static void AddTag_String_IfEmpty(CXmlItem &parentItem, const char *name, const char *value)
+{
+ int index = parentItem.FindSubTag(name);
+ if (index >= 0)
+ return;
+ CXmlItem &tag = parentItem.SubItems.AddNew();
+ tag.IsTag = true;
+ tag.Name = name;
+ CXmlItem &subItem = tag.SubItems.AddNew();
+ subItem.IsTag = false;
+ subItem.Name = value;
+}
+
+
+void CHeader::SetDefaultFields(bool useLZX)
+{
+ Version = k_Version_NonSolid;
+ Flags = NHeaderFlags::kReparsePointFixup;
+ ChunkSize = 0;
+ if (useLZX)
+ {
+ Flags |= NHeaderFlags::kCompression | NHeaderFlags::kLZX;
+ ChunkSize = kChunkSize;
+ ChunkSizeBits = kChunkSizeBits;
+ }
+ MY_RAND_GEN(Guid, 16);
+ PartNumber = 1;
+ NumParts = 1;
+ NumImages = 1;
+ BootIndex = 0;
+ OffsetResource.Clear();
+ XmlResource.Clear();
+ MetadataResource.Clear();
+ IntegrityResource.Clear();
+}
+
+
+static void AddTrees(CObjectVector<CDir> &trees, CObjectVector<CMetaItem> &metaItems, const CMetaItem &ri, int curTreeIndex)
+{
+ while (curTreeIndex >= (int)trees.Size())
+ trees.AddNew().Dirs.AddNew().MetaIndex = (int)metaItems.Add(ri);
+}
+
+
+#define IS_LETTER_CHAR(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
+
+
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outSeqStream, UInt32 numItems, IArchiveUpdateCallback *callback))
+{
+ COM_TRY_BEGIN
+
+ if (!IsUpdateSupported())
+ return E_NOTIMPL;
+
+ bool isUpdate = (_volumes.Size() != 0);
+ int defaultImageIndex = _defaultImageNumber - 1;
+ bool showImageNumber;
+
+ if (isUpdate)
+ {
+ showImageNumber = _showImageNumber;
+ if (!showImageNumber)
+ defaultImageIndex = _db.IndexOfUserImage;
+ }
+ else
+ {
+ showImageNumber = (_set_use_ShowImageNumber && _set_showImageNumber);
+ if (!showImageNumber)
+ defaultImageIndex = 0;
+ }
+
+ if (defaultImageIndex >= kNumImagesMaxUpdate)
+ return E_NOTIMPL;
+
+ CMyComPtr<IOutStream> outStream;
+ RINOK(outSeqStream->QueryInterface(IID_IOutStream, (void **)&outStream))
+ if (!outStream)
+ return E_NOTIMPL;
+ if (!callback)
+ return E_FAIL;
+
+ CDb db;
+ CObjectVector<CDir> trees;
+
+ CMetaItem ri; // default DIR item
+ FILETIME ftCur;
+ NTime::GetCurUtcFileTime(ftCur);
+ // ri.MTime = ri.ATime = ri.CTime = ftCur;
+ ri.Attrib = FILE_ATTRIBUTE_DIRECTORY;
+ ri.IsDir = true;
+
+
+ // ---------- Detect changed images ----------
+
+ unsigned i;
+ CBoolVector isChangedImage;
+ {
+ CUIntVector numUnchangedItemsInImage;
+ for (i = 0; i < _db.Images.Size(); i++)
+ {
+ numUnchangedItemsInImage.Add(0);
+ isChangedImage.Add(false);
+ }
+
+ for (i = 0; i < numItems; i++)
+ {
+ UInt32 indexInArchive;
+ Int32 newData, newProps;
+ RINOK(callback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive))
+ if (newProps == 0)
+ {
+ if (indexInArchive >= _db.SortedItems.Size())
+ continue;
+ const CItem &item = _db.Items[_db.SortedItems[indexInArchive]];
+ if (newData == 0)
+ {
+ if (item.ImageIndex >= 0)
+ numUnchangedItemsInImage[item.ImageIndex]++;
+ }
+ else
+ {
+ // oldProps & newData. Current version of 7-Zip doesn't use it
+ if (item.ImageIndex >= 0)
+ isChangedImage[item.ImageIndex] = true;
+ }
+ }
+ else if (!showImageNumber)
+ {
+ if (defaultImageIndex >= 0 && defaultImageIndex < (int)isChangedImage.Size())
+ isChangedImage[defaultImageIndex] = true;
+ }
+ else
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidPath, &prop))
+
+ if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ const wchar_t *path = prop.bstrVal;
+ if (!path)
+ return E_INVALIDARG;
+
+ const wchar_t *end;
+ UInt64 val = ConvertStringToUInt64(path, &end);
+ if (end == path)
+ return E_INVALIDARG;
+ if (val == 0 || val > kNumImagesMaxUpdate)
+ return E_INVALIDARG;
+ wchar_t c = *end;
+ if (c != 0 && c != ':' && c != L'/' && c != WCHAR_PATH_SEPARATOR)
+ return E_INVALIDARG;
+ unsigned imageIndex = (unsigned)val - 1;
+ if (imageIndex < _db.Images.Size())
+ isChangedImage[imageIndex] = true;
+ if (_defaultImageNumber > 0 && val != (unsigned)_defaultImageNumber)
+ return E_INVALIDARG;
+ }
+ }
+
+ for (i = 0; i < _db.Images.Size(); i++)
+ if (!isChangedImage[i])
+ isChangedImage[i] = _db.GetNumUserItemsInImage(i) != numUnchangedItemsInImage[i];
+ }
+
+ if (defaultImageIndex >= 0)
+ {
+ for (i = 0; i < _db.Images.Size(); i++)
+ if ((int)i != defaultImageIndex)
+ isChangedImage[i] = false;
+ }
+
+ CMyComPtr<IArchiveGetRawProps> getRawProps;
+ callback->QueryInterface(IID_IArchiveGetRawProps, (void **)&getRawProps);
+
+ CMyComPtr<IArchiveGetRootProps> getRootProps;
+ callback->QueryInterface(IID_IArchiveGetRootProps, (void **)&getRootProps);
+
+ CObjectVector<CUniqBlocks> secureBlocks;
+
+ if (!showImageNumber && (getRootProps || isUpdate) &&
+ (
+ defaultImageIndex >= (int)isChangedImage.Size()
+ || defaultImageIndex < 0 // test it
+ || isChangedImage[defaultImageIndex]
+ ))
+ {
+ // Fill Root Item: Metadata and security
+ CMetaItem rootItem = ri;
+ {
+ const void *data = NULL;
+ UInt32 dataSize = 0;
+ UInt32 propType = 0;
+ if (getRootProps)
+ {
+ RINOK(getRootProps->GetRootRawProp(kpidNtSecure, &data, &dataSize, &propType))
+ }
+ if (dataSize == 0 && isUpdate)
+ {
+ RINOK(GetRootRawProp(kpidNtSecure, &data, &dataSize, &propType))
+ }
+ if (dataSize != 0)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+ while (defaultImageIndex >= (int)secureBlocks.Size())
+ secureBlocks.AddNew();
+ CUniqBlocks &secUniqBlocks = secureBlocks[defaultImageIndex];
+ rootItem.SecurityId = (int)secUniqBlocks.AddUniq((const Byte *)data, dataSize);
+ }
+ }
+
+ IArchiveGetRootProps *thisGetRoot = isUpdate ? this : NULL;
+
+ if (_timeOptions.Write_CTime.Val) RINOK(GetRootTime(getRootProps, thisGetRoot, kpidCTime, rootItem.CTime))
+ if (_timeOptions.Write_ATime.Val) RINOK(GetRootTime(getRootProps, thisGetRoot, kpidATime, rootItem.ATime))
+ if (_timeOptions.Write_MTime.Val) RINOK(GetRootTime(getRootProps, thisGetRoot, kpidMTime, rootItem.MTime))
+
+ {
+ NCOM::CPropVariant prop;
+ if (getRootProps)
+ {
+ RINOK(getRootProps->GetRootProp(kpidAttrib, &prop))
+ if (prop.vt == VT_UI4)
+ rootItem.Attrib = prop.ulVal;
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ if (prop.vt == VT_EMPTY && thisGetRoot)
+ {
+ RINOK(GetRootProp(kpidAttrib, &prop))
+ if (prop.vt == VT_UI4)
+ rootItem.Attrib = prop.ulVal;
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ rootItem.Attrib |= FILE_ATTRIBUTE_DIRECTORY;
+ }
+
+ AddTrees(trees, db.MetaItems, ri, defaultImageIndex);
+ db.MetaItems[trees[defaultImageIndex].Dirs[0].MetaIndex] = rootItem;
+ }
+
+ // ---------- Request Metadata for changed items ----------
+
+ UString fileName;
+
+ for (i = 0; i < numItems; i++)
+ {
+ CUpdateItem ui;
+ UInt32 indexInArchive;
+ Int32 newData, newProps;
+ RINOK(callback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive))
+
+ if (newData == 0 || newProps == 0)
+ {
+ if (indexInArchive >= _db.SortedItems.Size())
+ continue;
+
+ const CItem &item = _db.Items[_db.SortedItems[indexInArchive]];
+
+ if (item.ImageIndex >= 0)
+ {
+ if (!isChangedImage[item.ImageIndex])
+ {
+ if (newData == 0 && newProps == 0)
+ continue;
+ return E_FAIL;
+ }
+ }
+ else
+ {
+ // if deleted item was not renamed, we just skip it
+ if (newProps == 0)
+ continue;
+ if (item.StreamIndex >= 0)
+ {
+ // we don't support property change for SolidBig streams
+ if (_db.DataStreams[item.StreamIndex].Resource.IsSolidBig())
+ return E_NOTIMPL;
+ }
+ }
+
+ if (newData == 0)
+ ui.InArcIndex = (Int32)indexInArchive;
+ }
+
+ // we set arcIndex only if we must use old props
+ const Int32 arcIndex = (newProps ? -1 : (Int32)indexInArchive);
+
+ bool isDir = false;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(GetOutProperty(callback, i, arcIndex, kpidIsDir, &prop))
+ if (prop.vt == VT_BOOL)
+ isDir = (prop.boolVal != VARIANT_FALSE);
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+
+ bool isAltStream = false;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(GetOutProperty(callback, i, arcIndex, kpidIsAltStream, &prop))
+ if (prop.vt == VT_BOOL)
+ isAltStream = (prop.boolVal != VARIANT_FALSE);
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+
+ if (isDir && isAltStream)
+ return E_INVALIDARG;
+
+ UInt64 size = 0;
+ UInt64 iNode = 0;
+
+ if (!isDir)
+ {
+ if (!newData)
+ {
+ NCOM::CPropVariant prop;
+ GetProperty(indexInArchive, kpidINode, &prop);
+ if (prop.vt == VT_UI8)
+ iNode = prop.uhVal.QuadPart;
+ }
+
+ NCOM::CPropVariant prop;
+
+ if (newData)
+ {
+ RINOK(callback->GetProperty(i, kpidSize, &prop))
+ }
+ else
+ {
+ RINOK(GetProperty(indexInArchive, kpidSize, &prop))
+ }
+
+ if (prop.vt == VT_UI8)
+ size = prop.uhVal.QuadPart;
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+
+ {
+ NCOM::CPropVariant propPath;
+ const wchar_t *path = NULL;
+ RINOK(GetOutProperty(callback, i, arcIndex, kpidPath, &propPath))
+ if (propPath.vt == VT_BSTR)
+ path = propPath.bstrVal;
+ else if (propPath.vt != VT_EMPTY)
+ return E_INVALIDARG;
+
+ if (!path)
+ return E_INVALIDARG;
+
+ CDir *curItem = NULL;
+ bool isRootImageDir = false;
+ fileName.Empty();
+
+ int imageIndex;
+
+ if (!showImageNumber)
+ {
+ imageIndex = defaultImageIndex;
+ AddTrees(trees, db.MetaItems, ri, imageIndex);
+ curItem = &trees[imageIndex].Dirs[0];
+ }
+ else
+ {
+ const wchar_t *end;
+ UInt64 val = ConvertStringToUInt64(path, &end);
+ if (end == path)
+ return E_INVALIDARG;
+ if (val == 0 || val > kNumImagesMaxUpdate)
+ return E_INVALIDARG;
+
+ imageIndex = (int)val - 1;
+ if (imageIndex < (int)isChangedImage.Size())
+ if (!isChangedImage[imageIndex])
+ return E_FAIL;
+
+ AddTrees(trees, db.MetaItems, ri, imageIndex);
+ curItem = &trees[imageIndex].Dirs[0];
+ wchar_t c = *end;
+
+ if (c == 0)
+ {
+ if (!isDir || isAltStream)
+ return E_INVALIDARG;
+ ui.MetaIndex = curItem->MetaIndex;
+ isRootImageDir = true;
+ }
+ else if (c == ':')
+ {
+ if (isDir || !isAltStream)
+ return E_INVALIDARG;
+ ui.MetaIndex = curItem->MetaIndex;
+ CAltStream ss;
+ ss.Size = size;
+ ss.Name = end + 1;
+ ss.UpdateIndex = (int)db.UpdateItems.Size();
+ ui.AltStreamIndex = (int)db.MetaItems[ui.MetaIndex].AltStreams.Add(ss);
+ }
+ else if (c == WCHAR_PATH_SEPARATOR || c == L'/')
+ {
+ path = end + 1;
+ if (*path == 0)
+ return E_INVALIDARG;
+ }
+ else
+ return E_INVALIDARG;
+ }
+
+ if (ui.MetaIndex < 0)
+ {
+ for (;;)
+ {
+ wchar_t c = *path++;
+ if (c == 0)
+ break;
+ if (c == WCHAR_PATH_SEPARATOR || c == L'/')
+ {
+ unsigned indexOfDir;
+ if (!curItem->FindDir(db.MetaItems, fileName, indexOfDir))
+ {
+ CDir &dir = curItem->Dirs.InsertNew(indexOfDir);
+ dir.MetaIndex = (int)db.MetaItems.Add(ri);
+ db.MetaItems.Back().Name = fileName;
+ }
+ curItem = &curItem->Dirs[indexOfDir];
+ fileName.Empty();
+ }
+ else
+ {
+ /*
+ #if WCHAR_MAX > 0xffff
+ if (c >= 0x10000)
+ {
+ c -= 0x10000;
+
+ if (c < (1 << 20))
+ {
+ wchar_t c0 = 0xd800 + ((c >> 10) & 0x3FF);
+ fileName += c0;
+ c = 0xdc00 + (c & 0x3FF);
+ }
+ else
+ c = '_'; // we change character unsupported by UTF16
+ }
+ #endif
+ */
+
+ fileName += c;
+ }
+ }
+
+ if (isAltStream)
+ {
+ int colonPos = fileName.Find(L':');
+ if (colonPos < 0)
+ return E_INVALIDARG;
+
+ // we want to support cases of c::substream, where c: is drive name
+ if (colonPos == 1 && fileName[2] == L':' && IS_LETTER_CHAR(fileName[0]))
+ colonPos = 2;
+ const UString mainName = fileName.Left((unsigned)colonPos);
+ unsigned indexOfDir;
+
+ if (mainName.IsEmpty())
+ ui.MetaIndex = curItem->MetaIndex;
+ else if (curItem->FindDir(db.MetaItems, mainName, indexOfDir))
+ ui.MetaIndex = curItem->Dirs[indexOfDir].MetaIndex;
+ else
+ {
+ for (int j = (int)curItem->Files.Size() - 1; j >= 0; j--)
+ {
+ const unsigned metaIndex = curItem->Files[j];
+ const CMetaItem &mi = db.MetaItems[metaIndex];
+ if (CompareFileNames(mainName, mi.Name) == 0)
+ {
+ ui.MetaIndex = (int)metaIndex;
+ break;
+ }
+ }
+ }
+
+ if (ui.MetaIndex >= 0)
+ {
+ CAltStream ss;
+ ss.Size = size;
+ ss.Name = fileName.Ptr(colonPos + 1);
+ ss.UpdateIndex = (int)db.UpdateItems.Size();
+ ui.AltStreamIndex = (int)db.MetaItems[ui.MetaIndex].AltStreams.Add(ss);
+ }
+ }
+ }
+
+
+ if (ui.MetaIndex < 0 || isRootImageDir)
+ {
+ if (!isRootImageDir)
+ {
+ ui.MetaIndex = (int)db.MetaItems.Size();
+ db.MetaItems.AddNew();
+ }
+
+ CMetaItem &mi = db.MetaItems[ui.MetaIndex];
+ mi.Size = size;
+ mi.IsDir = isDir;
+ mi.Name = fileName;
+ mi.UpdateIndex = (int)db.UpdateItems.Size();
+ {
+ NCOM::CPropVariant prop;
+ RINOK(GetOutProperty(callback, i, arcIndex, kpidAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ mi.Attrib = 0;
+ else if (prop.vt == VT_UI4)
+ mi.Attrib = prop.ulVal;
+ else
+ return E_INVALIDARG;
+ if (isDir)
+ mi.Attrib |= FILE_ATTRIBUTE_DIRECTORY;
+ }
+
+ if (arcIndex != -1 || _timeOptions.Write_CTime.Val)
+ RINOK(GetTime(callback, i, arcIndex, kpidCTime, mi.CTime))
+ if (arcIndex != -1 || _timeOptions.Write_ATime.Val)
+ RINOK(GetTime(callback, i, arcIndex, kpidATime, mi.ATime))
+ if (arcIndex != -1 || _timeOptions.Write_MTime.Val)
+ RINOK(GetTime(callback, i, arcIndex, kpidMTime, mi.MTime))
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(GetOutProperty(callback, i, arcIndex, kpidShortName, &prop))
+ if (prop.vt == VT_BSTR)
+ mi.ShortName.SetFromBstr(prop.bstrVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+
+ while (imageIndex >= (int)secureBlocks.Size())
+ secureBlocks.AddNew();
+
+ if (!isAltStream && (getRawProps || arcIndex >= 0))
+ {
+ CUniqBlocks &secUniqBlocks = secureBlocks[imageIndex];
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+
+ data = NULL;
+ dataSize = 0;
+ propType = 0;
+
+ if (arcIndex >= 0)
+ {
+ GetRawProp((UInt32)arcIndex, kpidNtSecure, &data, &dataSize, &propType);
+ }
+ else
+ {
+ getRawProps->GetRawProp(i, kpidNtSecure, &data, &dataSize, &propType);
+ }
+
+ if (dataSize != 0)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+ mi.SecurityId = (int)secUniqBlocks.AddUniq((const Byte *)data, dataSize);
+ }
+
+ data = NULL;
+ dataSize = 0;
+ propType = 0;
+
+ if (arcIndex >= 0)
+ {
+ GetRawProp((UInt32)arcIndex, kpidNtReparse, &data, &dataSize, &propType);
+ }
+ else
+ {
+ getRawProps->GetRawProp(i, kpidNtReparse, &data, &dataSize, &propType);
+ }
+
+ if (dataSize != 0)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+ mi.Reparse.CopyFrom((const Byte *)data, dataSize);
+ }
+ }
+
+ if (!isRootImageDir)
+ {
+ if (isDir)
+ {
+ unsigned indexOfDir;
+ if (curItem->FindDir(db.MetaItems, fileName, indexOfDir))
+ curItem->Dirs[indexOfDir].MetaIndex = ui.MetaIndex;
+ else
+ curItem->Dirs.InsertNew(indexOfDir).MetaIndex = ui.MetaIndex;
+ }
+ else
+ curItem->Files.Add((unsigned)ui.MetaIndex);
+ }
+ }
+
+ }
+
+ if (iNode != 0 && ui.MetaIndex >= 0 && ui.AltStreamIndex < 0)
+ db.MetaItems[ui.MetaIndex].FileID = iNode;
+
+ ui.CallbackIndex = i;
+ db.UpdateItems.Add(ui);
+ }
+
+ unsigned numNewImages = trees.Size();
+ for (i = numNewImages; i < isChangedImage.Size(); i++)
+ if (!isChangedImage[i])
+ numNewImages = i + 1;
+
+ AddTrees(trees, db.MetaItems, ri, (int)numNewImages - 1);
+
+ for (i = 0; i < trees.Size(); i++)
+ if (i >= isChangedImage.Size() || isChangedImage[i])
+ db.WriteOrderList(trees[i]);
+
+
+ UInt64 complexity = 0;
+
+ unsigned numDataStreams = _db.DataStreams.Size();
+ CUIntArr streamsRefs(numDataStreams);
+ for (i = 0; i < numDataStreams; i++)
+ streamsRefs[i] = 0;
+
+ // ---------- Calculate Streams Refs Counts in unchanged images
+
+ for (i = 0; i < _db.Images.Size(); i++)
+ {
+ if (isChangedImage[i])
+ continue;
+ complexity += _db.MetaStreams[i].Resource.PackSize;
+ const CImage &image = _db.Images[i];
+ unsigned endItem = image.StartItem + image.NumItems;
+ for (unsigned k = image.StartItem; k < endItem; k++)
+ {
+ const CItem &item = _db.Items[k];
+ if (item.StreamIndex >= 0)
+ streamsRefs[(unsigned)item.StreamIndex]++;
+ }
+ }
+
+
+ // ---------- Update Streams Refs Counts in changed images
+
+ for (i = 0; i < db.UpdateIndexes.Size(); i++)
+ {
+ const CUpdateItem &ui = db.UpdateItems[db.UpdateIndexes[i]];
+
+ if (ui.InArcIndex >= 0)
+ {
+ if ((unsigned)ui.InArcIndex >= _db.SortedItems.Size())
+ continue;
+ const CItem &item = _db.Items[_db.SortedItems[ui.InArcIndex]];
+ if (item.StreamIndex >= 0)
+ streamsRefs[(unsigned)item.StreamIndex]++;
+ }
+ else
+ {
+ const CMetaItem &mi = db.MetaItems[ui.MetaIndex];
+ UInt64 size;
+ if (ui.AltStreamIndex < 0)
+ size = mi.Size;
+ else
+ size = mi.AltStreams[ui.AltStreamIndex].Size;
+ complexity += size;
+ }
+ }
+
+ // Clear ref counts for SolidBig streams
+
+ for (i = 0; i < _db.DataStreams.Size(); i++)
+ if (_db.DataStreams[i].Resource.IsSolidBig())
+ streamsRefs[i] = 0;
+
+ // Set ref counts for SolidBig streams
+
+ for (i = 0; i < _db.DataStreams.Size(); i++)
+ if (streamsRefs[i] != 0)
+ {
+ const CResource &rs = _db.DataStreams[i].Resource;
+ if (rs.IsSolidSmall())
+ streamsRefs[_db.Solids[rs.SolidIndex].StreamIndex] = 1;
+ }
+
+ for (i = 0; i < _db.DataStreams.Size(); i++)
+ if (streamsRefs[i] != 0)
+ {
+ const CResource &rs = _db.DataStreams[i].Resource;
+ if (!rs.IsSolidSmall())
+ complexity += rs.PackSize;
+ }
+
+ RINOK(callback->SetTotal(complexity))
+ UInt64 totalComplexity = complexity;
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(callback, true);
+
+ complexity = 0;
+
+ // bool useResourceCompression = false;
+ // use useResourceCompression only if CHeader::Flags compression is also set
+
+ CHeader header;
+ header.SetDefaultFields(false);
+
+ if (isUpdate)
+ {
+ const CHeader &srcHeader = _volumes[1].Header;
+ header.Flags = srcHeader.Flags;
+ header.Version = srcHeader.Version;
+ header.ChunkSize = srcHeader.ChunkSize;
+ header.ChunkSizeBits = srcHeader.ChunkSizeBits;
+ }
+
+ CMyComPtr<IStreamSetRestriction> setRestriction;
+ outSeqStream->QueryInterface(IID_IStreamSetRestriction, (void **)&setRestriction);
+ if (setRestriction)
+ RINOK(setRestriction->SetRestriction(0, kHeaderSizeMax))
+
+ {
+ Byte buf[kHeaderSizeMax];
+ header.WriteTo(buf);
+ RINOK(WriteStream(outStream, buf, kHeaderSizeMax))
+ }
+
+ UInt64 curPos = kHeaderSizeMax;
+
+ CInStreamWithSha1 *inShaStreamSpec = new CInStreamWithSha1;
+ CMyComPtr<ISequentialInStream> inShaStream = inShaStreamSpec;
+
+ CLimitedSequentialInStream *inStreamLimitedSpec = NULL;
+ CMyComPtr<ISequentialInStream> inStreamLimited;
+ if (_volumes.Size() == 2)
+ {
+ inStreamLimitedSpec = new CLimitedSequentialInStream;
+ inStreamLimited = inStreamLimitedSpec;
+ inStreamLimitedSpec->SetStream(_volumes[1].Stream);
+ }
+
+
+ CRecordVector<CStreamInfo> streams;
+ CSortedIndex sortedHashes; // indexes to streams, sorted by SHA1
+
+ // ---------- Copy unchanged data streams ----------
+
+ UInt64 solidRunOffset = 0;
+ UInt64 curSolidSize = 0;
+
+ for (i = 0; i < _db.DataStreams.Size(); i++)
+ {
+ const CStreamInfo &siOld = _db.DataStreams[i];
+ const CResource &rs = siOld.Resource;
+
+ const unsigned numRefs = streamsRefs[i];
+
+ if (numRefs == 0)
+ {
+ if (!rs.IsSolidSmall())
+ continue;
+ if (streamsRefs[_db.Solids[rs.SolidIndex].StreamIndex] == 0)
+ continue;
+ }
+
+ lps->InSize = lps->OutSize = complexity;
+ RINOK(lps->SetCur())
+
+ const unsigned streamIndex = streams.Size();
+ CStreamInfo s;
+ s.Resource = rs;
+ s.PartNumber = 1;
+ s.RefCount = numRefs;
+
+ memcpy(s.Hash, siOld.Hash, kHashSize);
+
+ if (rs.IsSolid())
+ {
+ CSolid &ss = _db.Solids[rs.SolidIndex];
+ if (rs.IsSolidSmall())
+ {
+ UInt64 oldOffset = ss.SolidOffset;
+ if (rs.Offset < oldOffset)
+ return E_FAIL;
+ UInt64 relatOffset = rs.Offset - oldOffset;
+ s.Resource.Offset = solidRunOffset + relatOffset;
+ }
+ else
+ {
+ // IsSolidBig
+ solidRunOffset += curSolidSize;
+ curSolidSize = ss.UnpackSize;
+ }
+ }
+ else
+ {
+ solidRunOffset = 0;
+ curSolidSize = 0;
+ }
+
+ if (!rs.IsSolid() || rs.IsSolidSmall())
+ {
+ const int find = AddUniqHash(&streams.Front(), sortedHashes, siOld.Hash, (int)streamIndex);
+ if (find != -1)
+ return E_FAIL; // two streams with same SHA-1
+ }
+
+ if (!rs.IsSolid() || rs.IsSolidBig())
+ {
+ RINOK(InStream_SeekSet(_volumes[siOld.PartNumber].Stream, rs.Offset))
+ inStreamLimitedSpec->Init(rs.PackSize);
+ RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize != rs.PackSize)
+ return E_FAIL;
+ s.Resource.Offset = curPos;
+ curPos += rs.PackSize;
+ lps->ProgressOffset += rs.PackSize;
+ }
+
+ streams.Add(s);
+ }
+
+
+ // ---------- Write new items ----------
+
+ CUIntVector hlIndexes; // sorted indexes for hard link items
+
+ for (i = 0; i < db.UpdateIndexes.Size(); i++)
+ {
+ lps->InSize = lps->OutSize = complexity;
+ RINOK(lps->SetCur())
+ const CUpdateItem &ui = db.UpdateItems[db.UpdateIndexes[i]];
+ CMetaItem &mi = db.MetaItems[ui.MetaIndex];
+ UInt64 size = 0;
+
+ if (ui.AltStreamIndex >= 0)
+ {
+ if (mi.Skip)
+ continue;
+ size = mi.AltStreams[ui.AltStreamIndex].Size;
+ }
+ else
+ {
+ size = mi.Size;
+ if (mi.IsDir)
+ {
+ // we support LINK files here
+ if (mi.Reparse.Size() == 0)
+ continue;
+ }
+ }
+
+ if (ui.InArcIndex >= 0)
+ {
+ // data streams with OLD Data were written already
+ // we just need to find HashIndex in hashes.
+
+ if ((unsigned)ui.InArcIndex >= _db.SortedItems.Size())
+ return E_FAIL;
+
+ const CItem &item = _db.Items[_db.SortedItems[ui.InArcIndex]];
+
+ if (item.StreamIndex < 0)
+ {
+ if (size == 0)
+ continue;
+ // if (_db.ItemHasStream(item))
+ return E_FAIL;
+ }
+
+ // We support empty file (size = 0, but with stream and SHA-1) from old archive
+
+ const CStreamInfo &siOld = _db.DataStreams[item.StreamIndex];
+
+ const int index = AddUniqHash(&streams.Front(), sortedHashes, siOld.Hash, -1);
+ // we must have written that stream already
+ if (index == -1)
+ return E_FAIL;
+
+ if (ui.AltStreamIndex < 0)
+ mi.HashIndex = index;
+ else
+ mi.AltStreams[ui.AltStreamIndex].HashIndex = index;
+
+ continue;
+ }
+
+ CMyComPtr<ISequentialInStream> fileInStream;
+ HRESULT res = callback->GetStream(ui.CallbackIndex, &fileInStream);
+
+ if (res == S_FALSE)
+ {
+ if (ui.AltStreamIndex >= 0)
+ {
+ mi.NumSkipAltStreams++;
+ mi.AltStreams[ui.AltStreamIndex].Skip = true;
+ }
+ else
+ mi.Skip = true;
+ }
+ else
+ {
+ RINOK(res)
+
+ int miIndex = -1;
+
+ if (!fileInStream)
+ {
+ if (!mi.IsDir)
+ return E_INVALIDARG;
+ }
+ else if (ui.AltStreamIndex < 0)
+ {
+ CMyComPtr<IStreamGetProps2> getProps2;
+ fileInStream->QueryInterface(IID_IStreamGetProps2, (void **)&getProps2);
+ if (getProps2)
+ {
+ CStreamFileProps props;
+ if (getProps2->GetProps2(&props) == S_OK)
+ {
+ mi.Attrib = props.Attrib;
+ if (_timeOptions.Write_CTime.Val) mi.CTime = props.CTime;
+ if (_timeOptions.Write_ATime.Val) mi.ATime = props.ATime;
+ if (_timeOptions.Write_MTime.Val) mi.MTime = props.MTime;
+ mi.FileID = props.FileID_Low;
+ if (props.NumLinks <= 1)
+ mi.FileID = 0;
+ mi.VolID = props.VolID;
+ if (mi.FileID != 0)
+ miIndex = AddToHardLinkList(db.MetaItems, (unsigned)ui.MetaIndex, hlIndexes);
+
+ if (props.Size != size && props.Size != (UInt64)(Int64)-1)
+ {
+ const Int64 delta = (Int64)props.Size - (Int64)size;
+ const Int64 newComplexity = (Int64)totalComplexity + delta;
+ if (newComplexity > 0)
+ {
+ totalComplexity = (UInt64)newComplexity;
+ callback->SetTotal(totalComplexity);
+ }
+ mi.Size = props.Size;
+ size = props.Size;
+ }
+ }
+ }
+ }
+
+ if (miIndex >= 0)
+ {
+ mi.HashIndex = db.MetaItems[miIndex].HashIndex;
+ if (mi.HashIndex >= 0)
+ streams[mi.HashIndex].RefCount++;
+ // fix for future: maybe we need to check also that real size is equal to size from IStreamGetProps2
+ }
+ else if (ui.AltStreamIndex < 0 && mi.Reparse.Size() != 0)
+ {
+ if (mi.Reparse.Size() < 8)
+ return E_FAIL;
+ NCrypto::NSha1::CContext sha1;
+ sha1.Init();
+ const size_t packSize = mi.Reparse.Size() - 8;
+ sha1.Update((const Byte *)mi.Reparse + 8, packSize);
+ Byte hash[kHashSize];
+ sha1.Final(hash);
+
+ int index = AddUniqHash(&streams.Front(), sortedHashes, hash, (int)streams.Size());
+
+ if (index != -1)
+ streams[index].RefCount++;
+ else
+ {
+ index = (int)streams.Size();
+ RINOK(WriteStream(outStream, (const Byte *)mi.Reparse + 8, packSize))
+ CStreamInfo s;
+ s.Resource.PackSize = packSize;
+ s.Resource.Offset = curPos;
+ s.Resource.UnpackSize = packSize;
+ s.Resource.Flags = 0; // check it
+ /*
+ if (useResourceCompression)
+ s.Resource.Flags = NResourceFlags::Compressed;
+ */
+ s.PartNumber = 1;
+ s.RefCount = 1;
+ memcpy(s.Hash, hash, kHashSize);
+ curPos += packSize;
+
+ streams.Add(s);
+ }
+
+ mi.HashIndex = index;
+ }
+ else
+ {
+ inShaStreamSpec->SetStream(fileInStream);
+
+ CMyComPtr<IInStream> inSeekStream;
+ fileInStream.QueryInterface(IID_IInStream, (void **)&inSeekStream);
+
+ fileInStream.Release();
+ inShaStreamSpec->Init();
+ UInt64 offsetBlockSize = 0;
+ /*
+ if (useResourceCompression)
+ {
+ for (UInt64 t = kChunkSize; t < size; t += kChunkSize)
+ {
+ Byte buf[8];
+ SetUi32(buf, (UInt32)t);
+ RINOK(WriteStream(outStream, buf, 4));
+ offsetBlockSize += 4;
+ }
+ }
+ */
+
+ // 22.02: we use additional read-only pass to calculate SHA-1
+ bool needWritePass = true;
+ int index = -1;
+
+ if (inSeekStream /* && !sortedHashes.IsEmpty() */)
+ {
+ RINOK(copyCoder->Code(inShaStream, NULL, NULL, NULL, progress))
+ size = copyCoderSpec->TotalSize;
+ if (size == 0)
+ needWritePass = false;
+ else
+ {
+ Byte hash[kHashSize];
+ inShaStreamSpec->Final(hash);
+
+ index = AddUniqHash(&streams.Front(), sortedHashes, hash, -1);
+ if (index != -1)
+ {
+ streams[index].RefCount++;
+ needWritePass = false;
+ }
+ else
+ {
+ RINOK(InStream_SeekToBegin(inSeekStream))
+ inShaStreamSpec->Init();
+ }
+ }
+ }
+
+ if (needWritePass)
+ {
+ RINOK(copyCoder->Code(inShaStream, outStream, NULL, NULL, progress))
+ size = copyCoderSpec->TotalSize;
+ }
+
+ if (size != 0)
+ {
+ if (needWritePass)
+ {
+ Byte hash[kHashSize];
+ const UInt64 packSize = offsetBlockSize + size;
+ inShaStreamSpec->Final(hash);
+
+ index = AddUniqHash(&streams.Front(), sortedHashes, hash, (int)streams.Size());
+
+ if (index != -1)
+ {
+ streams[index].RefCount++;
+ outStream->Seek(-(Int64)packSize, STREAM_SEEK_CUR, &curPos);
+ outStream->SetSize(curPos);
+ }
+ else
+ {
+ index = (int)streams.Size();
+ CStreamInfo s;
+ s.Resource.PackSize = packSize;
+ s.Resource.Offset = curPos;
+ s.Resource.UnpackSize = size;
+ s.Resource.Flags = 0;
+ /*
+ if (useResourceCompression)
+ s.Resource.Flags = NResourceFlags::Compressed;
+ */
+ s.PartNumber = 1;
+ s.RefCount = 1;
+ memcpy(s.Hash, hash, kHashSize);
+ curPos += packSize;
+
+ streams.Add(s);
+ }
+ } // needWritePass
+ if (ui.AltStreamIndex < 0)
+ mi.HashIndex = index;
+ else
+ mi.AltStreams[ui.AltStreamIndex].HashIndex = index;
+ } // (size != 0)
+ }
+ }
+ fileInStream.Release();
+ complexity += size;
+ RINOK(callback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ }
+
+ while (secureBlocks.Size() < numNewImages)
+ secureBlocks.AddNew();
+
+
+
+ // ---------- Write Images ----------
+
+ for (i = 0; i < numNewImages; i++)
+ {
+ lps->InSize = lps->OutSize = complexity;
+ RINOK(lps->SetCur())
+ if (i < isChangedImage.Size() && !isChangedImage[i])
+ {
+ CStreamInfo s = _db.MetaStreams[i];
+
+ RINOK(InStream_SeekSet(_volumes[1].Stream, s.Resource.Offset))
+ inStreamLimitedSpec->Init(s.Resource.PackSize);
+ RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress))
+ if (copyCoderSpec->TotalSize != s.Resource.PackSize)
+ return E_FAIL;
+
+ s.Resource.Offset = curPos;
+ s.PartNumber = 1;
+ s.RefCount = 1;
+ streams.Add(s);
+
+ if (_bootIndex != 0 && _bootIndex == (UInt32)i + 1)
+ {
+ header.MetadataResource = s.Resource;
+ header.BootIndex = _bootIndex;
+ }
+
+ lps->ProgressOffset += s.Resource.PackSize;
+ curPos += s.Resource.PackSize;
+ // printf("\nWrite old image %x\n", i + 1);
+ continue;
+ }
+
+ const CDir &tree = trees[i];
+ const UInt32 kSecuritySize = 8;
+
+ size_t pos = kSecuritySize;
+
+ const CUniqBlocks &secUniqBlocks = secureBlocks[i];
+ const CObjectVector<CByteBuffer> &secBufs = secUniqBlocks.Bufs;
+ pos += (size_t)secUniqBlocks.GetTotalSizeInBytes();
+ pos += secBufs.Size() * 8;
+ pos = (pos + 7) & ~(size_t)7;
+
+ db.DefaultDirItem = ri;
+ pos += db.WriteTree_Dummy(tree);
+
+ CByteArr meta(pos);
+
+ Set32((Byte *)meta + 4, secBufs.Size()) // num security entries
+ pos = kSecuritySize;
+
+ if (secBufs.Size() == 0)
+ {
+ // we can write 0 here only if there is no security data, imageX does it,
+ // but some programs expect size = 8
+ Set32((Byte *)meta, 8) // size of security data
+ // Set32((Byte *)meta, 0);
+ }
+ else
+ {
+ unsigned k;
+ for (k = 0; k < secBufs.Size(); k++, pos += 8)
+ {
+ Set64(meta + pos, secBufs[k].Size())
+ }
+ for (k = 0; k < secBufs.Size(); k++)
+ {
+ const CByteBuffer &buf = secBufs[k];
+ size_t size = buf.Size();
+ if (size != 0)
+ {
+ memcpy(meta + pos, buf, size);
+ pos += size;
+ }
+ }
+ while ((pos & 7) != 0)
+ meta[pos++] = 0;
+ Set32((Byte *)meta, (UInt32)pos) // size of security data
+ }
+
+ db.Hashes = &streams.Front();
+ db.WriteTree(tree, (Byte *)meta, pos);
+
+ {
+ NCrypto::NSha1::CContext sha;
+ sha.Init();
+ sha.Update((const Byte *)meta, pos);
+
+ Byte digest[kHashSize];
+ sha.Final(digest);
+
+ CStreamInfo s;
+ s.Resource.PackSize = pos;
+ s.Resource.Offset = curPos;
+ s.Resource.UnpackSize = pos;
+ s.Resource.Flags = NResourceFlags::kMetadata;
+ s.PartNumber = 1;
+ s.RefCount = 1;
+ memcpy(s.Hash, digest, kHashSize);
+ streams.Add(s);
+
+ if (_bootIndex != 0 && _bootIndex == (UInt32)i + 1)
+ {
+ header.MetadataResource = s.Resource;
+ header.BootIndex = _bootIndex;
+ }
+
+ RINOK(WriteStream(outStream, (const Byte *)meta, pos))
+ meta.Free();
+ curPos += pos;
+ }
+ }
+
+ lps->InSize = lps->OutSize = complexity;
+ RINOK(lps->SetCur())
+
+ header.OffsetResource.UnpackSize = header.OffsetResource.PackSize = (UInt64)streams.Size() * kStreamInfoSize;
+ header.OffsetResource.Offset = curPos;
+ header.OffsetResource.Flags = NResourceFlags::kMetadata;
+
+
+
+ // ---------- Write Streams Info Tables ----------
+
+ for (i = 0; i < streams.Size(); i++)
+ {
+ Byte buf[kStreamInfoSize];
+ streams[i].WriteTo(buf);
+ RINOK(WriteStream(outStream, buf, kStreamInfoSize))
+ curPos += kStreamInfoSize;
+ }
+
+ AString xml ("<WIM>");
+ AddTagUInt64_ToString(xml, "TOTALBYTES", curPos);
+ for (i = 0; i < trees.Size(); i++)
+ {
+ const CDir &tree = trees[i];
+
+ CXmlItem item;
+ if (_xmls.Size() == 1)
+ {
+ const CWimXml &_oldXml = _xmls[0];
+ if (i < _oldXml.Images.Size())
+ {
+ // int ttt = _oldXml.Images[i].ItemIndexInXml;
+ item = _oldXml.Xml.Root.SubItems[_oldXml.Images[i].ItemIndexInXml];
+ }
+ }
+ if (i >= isChangedImage.Size() || isChangedImage[i])
+ {
+ char temp[16];
+ if (item.Name.IsEmpty())
+ {
+ ConvertUInt32ToString(i + 1, temp);
+ item.Name = "IMAGE";
+ item.IsTag = true;
+ CXmlProp &prop = item.Props.AddNew();
+ prop.Name = "INDEX";
+ prop.Value = temp;
+ }
+
+ AddTag_String_IfEmpty(item, "NAME", temp);
+ AddTag_UInt64(item, "DIRCOUNT", tree.GetNumDirs() - 1);
+ AddTag_UInt64(item, "FILECOUNT", tree.GetNumFiles());
+ AddTag_UInt64(item, "TOTALBYTES", tree.GetTotalSize(db.MetaItems));
+
+ AddTag_Time(item, "CREATIONTIME", ftCur);
+ AddTag_Time(item, "LASTMODIFICATIONTIME", ftCur);
+ }
+
+ item.AppendTo(xml);
+ }
+ xml += "</WIM>";
+
+ size_t xmlSize;
+ {
+ UString utf16;
+ if (!ConvertUTF8ToUnicode(xml, utf16))
+ return S_FALSE;
+ xmlSize = ((size_t)utf16.Len() + 1) * 2;
+
+ CByteArr xmlBuf(xmlSize);
+ Set16((Byte *)xmlBuf, 0xFEFF)
+ for (i = 0; i < (unsigned)utf16.Len(); i++)
+ {
+ Set16((Byte *)xmlBuf + 2 + (size_t)i * 2, (UInt16)utf16[i])
+ }
+ RINOK(WriteStream(outStream, (const Byte *)xmlBuf, xmlSize))
+ }
+
+ header.XmlResource.UnpackSize =
+ header.XmlResource.PackSize = xmlSize;
+ header.XmlResource.Offset = curPos;
+ header.XmlResource.Flags = NResourceFlags::kMetadata;
+
+ outStream->Seek(0, STREAM_SEEK_SET, NULL);
+ header.NumImages = trees.Size();
+ {
+ Byte buf[kHeaderSizeMax];
+ header.WriteTo(buf);
+ RINOK(WriteStream(outStream, buf, kHeaderSizeMax))
+ }
+
+ if (setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Archive/Wim/WimIn.cpp b/CPP/7zip/Archive/Wim/WimIn.cpp
new file mode 100644
index 0000000..ff118d8
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/WimIn.cpp
@@ -0,0 +1,1878 @@
+// Archive/WimIn.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/XpressDecoder.h"
+
+#include "../Common/OutStreamWithSha1.h"
+
+#include "WimIn.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+namespace NArchive {
+namespace NWim {
+
+static int inline GetLog(UInt32 num)
+{
+ for (int i = 0; i < 32; i++)
+ if (((UInt32)1 << i) == num)
+ return i;
+ return -1;
+}
+
+
+CUnpacker::~CUnpacker()
+{
+ if (lzmsDecoder)
+ delete lzmsDecoder;
+}
+
+
+HRESULT CUnpacker::UnpackChunk(
+ ISequentialInStream *inStream,
+ unsigned method, unsigned chunkSizeBits,
+ size_t inSize, size_t outSize,
+ ISequentialOutStream *outStream)
+{
+ if (inSize == outSize)
+ {
+ }
+ else if (method == NMethod::kXPRESS)
+ {
+ }
+ else if (method == NMethod::kLZX)
+ {
+ if (!lzxDecoder)
+ {
+ lzxDecoderSpec = new NCompress::NLzx::CDecoder(true);
+ lzxDecoder = lzxDecoderSpec;
+ }
+ }
+ else if (method == NMethod::kLZMS)
+ {
+ if (!lzmsDecoder)
+ lzmsDecoder = new NCompress::NLzms::CDecoder();
+ }
+ else
+ return E_NOTIMPL;
+
+ const size_t chunkSize = (size_t)1 << chunkSizeBits;
+
+ unpackBuf.EnsureCapacity(chunkSize);
+ if (!unpackBuf.Data)
+ return E_OUTOFMEMORY;
+
+ HRESULT res = S_FALSE;
+ size_t unpackedSize = 0;
+
+ if (inSize == outSize)
+ {
+ unpackedSize = outSize;
+ res = ReadStream(inStream, unpackBuf.Data, &unpackedSize);
+ TotalPacked += unpackedSize;
+ }
+ else if (inSize < chunkSize)
+ {
+ packBuf.EnsureCapacity(chunkSize);
+ if (!packBuf.Data)
+ return E_OUTOFMEMORY;
+
+ RINOK(ReadStream_FALSE(inStream, packBuf.Data, inSize))
+
+ TotalPacked += inSize;
+
+ if (method == NMethod::kXPRESS)
+ {
+ res = NCompress::NXpress::Decode(packBuf.Data, inSize, unpackBuf.Data, outSize);
+ if (res == S_OK)
+ unpackedSize = outSize;
+ }
+ else if (method == NMethod::kLZX)
+ {
+ res = lzxDecoderSpec->SetExternalWindow(unpackBuf.Data, chunkSizeBits);
+ if (res != S_OK)
+ return E_NOTIMPL;
+ lzxDecoderSpec->KeepHistoryForNext = false;
+ lzxDecoderSpec->SetKeepHistory(false);
+ res = lzxDecoderSpec->Code(packBuf.Data, inSize, (UInt32)outSize);
+ unpackedSize = lzxDecoderSpec->GetUnpackSize();
+ if (res == S_OK && !lzxDecoderSpec->WasBlockFinished())
+ res = S_FALSE;
+ }
+ else
+ {
+ res = lzmsDecoder->Code(packBuf.Data, inSize, unpackBuf.Data, outSize);
+ unpackedSize = lzmsDecoder->GetUnpackSize();
+ }
+ }
+
+ if (unpackedSize != outSize)
+ {
+ if (res == S_OK)
+ res = S_FALSE;
+
+ if (unpackedSize > outSize)
+ res = S_FALSE;
+ else
+ memset(unpackBuf.Data + unpackedSize, 0, outSize - unpackedSize);
+ }
+
+ if (outStream)
+ {
+ RINOK(WriteStream(outStream, unpackBuf.Data, outSize))
+ }
+
+ return res;
+}
+
+
+HRESULT CUnpacker::Unpack2(
+ IInStream *inStream,
+ const CResource &resource,
+ const CHeader &header,
+ const CDatabase *db,
+ ISequentialOutStream *outStream,
+ ICompressProgressInfo *progress)
+{
+ if (!resource.IsCompressed() && !resource.IsSolid())
+ {
+ if (!copyCoder)
+ {
+ copyCoderSpec = new NCompress::CCopyCoder;
+ copyCoder = copyCoderSpec;
+ }
+
+ CLimitedSequentialInStream *limitedStreamSpec = new CLimitedSequentialInStream();
+ CMyComPtr<ISequentialInStream> limitedStream = limitedStreamSpec;
+ limitedStreamSpec->SetStream(inStream);
+
+ RINOK(InStream_SeekSet(inStream, resource.Offset))
+ if (resource.PackSize != resource.UnpackSize)
+ return S_FALSE;
+
+ limitedStreamSpec->Init(resource.PackSize);
+ TotalPacked += resource.PackSize;
+
+ HRESULT res = copyCoder->Code(limitedStream, outStream, NULL, NULL, progress);
+
+ if (res == S_OK && copyCoderSpec->TotalSize != resource.UnpackSize)
+ res = S_FALSE;
+ return res;
+ }
+
+ if (resource.IsSolid())
+ {
+ if (!db || resource.SolidIndex < 0)
+ return E_NOTIMPL;
+ if (resource.IsCompressed())
+ return E_NOTIMPL;
+
+ const CSolid &ss = db->Solids[resource.SolidIndex];
+
+ const unsigned chunkSizeBits = ss.ChunkSizeBits;
+ const size_t chunkSize = (size_t)1 << chunkSizeBits;
+
+ size_t chunkIndex = 0;
+ UInt64 rem = ss.UnpackSize;
+ size_t offsetInChunk = 0;
+
+ if (resource.IsSolidSmall())
+ {
+ UInt64 offs = resource.Offset;
+ if (offs < ss.SolidOffset)
+ return E_NOTIMPL;
+ offs -= ss.SolidOffset;
+ if (offs > ss.UnpackSize)
+ return E_NOTIMPL;
+ rem = resource.PackSize;
+ if (rem > ss.UnpackSize - offs)
+ return E_NOTIMPL;
+ chunkIndex = (size_t)(offs >> chunkSizeBits);
+ offsetInChunk = (size_t)offs & (chunkSize - 1);
+ }
+
+ UInt64 packProcessed = 0;
+ UInt64 outProcessed = 0;
+
+ if (_solidIndex == resource.SolidIndex && _unpackedChunkIndex == chunkIndex)
+ {
+ size_t cur = chunkSize - offsetInChunk;
+ if (cur > rem)
+ cur = (size_t)rem;
+ RINOK(WriteStream(outStream, unpackBuf.Data + offsetInChunk, cur))
+ outProcessed += cur;
+ rem -= cur;
+ offsetInChunk = 0;
+ chunkIndex++;
+ }
+
+ for (;;)
+ {
+ if (rem == 0)
+ return S_OK;
+
+ const UInt64 offset = ss.Chunks[chunkIndex];
+ const UInt64 packSize = ss.GetChunkPackSize(chunkIndex);
+ const CResource &rs = db->DataStreams[ss.StreamIndex].Resource;
+ RINOK(InStream_SeekSet(inStream, rs.Offset + ss.HeadersSize + offset))
+
+ size_t cur = chunkSize;
+ const UInt64 unpackRem = ss.UnpackSize - ((UInt64)chunkIndex << chunkSizeBits);
+ if (cur > unpackRem)
+ cur = (size_t)unpackRem;
+
+ _solidIndex = -1;
+ _unpackedChunkIndex = 0;
+
+ const HRESULT res = UnpackChunk(inStream, (unsigned)ss.Method, chunkSizeBits, (size_t)packSize, cur, NULL);
+
+ if (res != S_OK)
+ {
+ // We ignore data errors in solid stream. SHA will show what files are bad.
+ if (res != S_FALSE)
+ return res;
+ }
+
+ _solidIndex = resource.SolidIndex;
+ _unpackedChunkIndex = chunkIndex;
+
+ if (cur < offsetInChunk)
+ return E_FAIL;
+
+ cur -= offsetInChunk;
+
+ if (cur > rem)
+ cur = (size_t)rem;
+
+ RINOK(WriteStream(outStream, unpackBuf.Data + offsetInChunk, cur))
+
+ if (progress)
+ {
+ RINOK(progress->SetRatioInfo(&packProcessed, &outProcessed))
+ packProcessed += packSize;
+ outProcessed += cur;
+ }
+
+ rem -= cur;
+ offsetInChunk = 0;
+ chunkIndex++;
+ }
+ }
+
+
+ // ---------- NON Solid ----------
+
+ const UInt64 unpackSize = resource.UnpackSize;
+ if (unpackSize == 0)
+ {
+ if (resource.PackSize == 0)
+ return S_OK;
+ return S_FALSE;
+ }
+
+ if (unpackSize > ((UInt64)1 << 63))
+ return E_NOTIMPL;
+
+ const unsigned chunkSizeBits = header.ChunkSizeBits;
+ const unsigned entrySizeShifts = (resource.UnpackSize < ((UInt64)1 << 32) ? 2 : 3);
+
+ UInt64 baseOffset = resource.Offset;
+ UInt64 packDataSize;
+ size_t numChunks;
+ {
+ const UInt64 numChunks64 = (unpackSize + (((UInt32)1 << chunkSizeBits) - 1)) >> chunkSizeBits;
+ const UInt64 sizesBufSize64 = (numChunks64 - 1) << entrySizeShifts;
+ if (sizesBufSize64 > resource.PackSize)
+ return S_FALSE;
+ packDataSize = resource.PackSize - sizesBufSize64;
+ const size_t sizesBufSize = (size_t)sizesBufSize64;
+ if (sizesBufSize != sizesBufSize64)
+ return E_OUTOFMEMORY;
+ sizesBuf.AllocAtLeast(sizesBufSize);
+ RINOK(InStream_SeekSet(inStream, baseOffset))
+ RINOK(ReadStream_FALSE(inStream, sizesBuf, sizesBufSize))
+ baseOffset += sizesBufSize64;
+ numChunks = (size_t)numChunks64;
+ }
+
+ _solidIndex = -1;
+ _unpackedChunkIndex = 0;
+
+ UInt64 outProcessed = 0;
+ UInt64 offset = 0;
+
+ for (size_t i = 0; i < numChunks; i++)
+ {
+ UInt64 nextOffset = packDataSize;
+
+ if (i + 1 < numChunks)
+ {
+ const Byte *p = (const Byte *)sizesBuf + (i << entrySizeShifts);
+ nextOffset = (entrySizeShifts == 2) ? Get32(p): Get64(p);
+ }
+
+ if (nextOffset < offset)
+ return S_FALSE;
+
+ UInt64 inSize64 = nextOffset - offset;
+ size_t inSize = (size_t)inSize64;
+ if (inSize != inSize64)
+ return S_FALSE;
+
+ RINOK(InStream_SeekSet(inStream, baseOffset + offset))
+
+ if (progress)
+ {
+ RINOK(progress->SetRatioInfo(&offset, &outProcessed))
+ }
+
+ size_t outSize = (size_t)1 << chunkSizeBits;
+ const UInt64 rem = unpackSize - outProcessed;
+ if (outSize > rem)
+ outSize = (size_t)rem;
+
+ RINOK(UnpackChunk(inStream, header.GetMethod(), chunkSizeBits, inSize, outSize, outStream))
+
+ outProcessed += outSize;
+ offset = nextOffset;
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CUnpacker::Unpack(IInStream *inStream, const CResource &resource, const CHeader &header, const CDatabase *db,
+ ISequentialOutStream *outStream, ICompressProgressInfo *progress, Byte *digest)
+{
+ COutStreamWithSha1 *shaStreamSpec = NULL;
+ CMyComPtr<ISequentialOutStream> shaStream;
+
+ // outStream can be NULL, so we use COutStreamWithSha1 even if sha1 is not required
+ // if (digest)
+ {
+ shaStreamSpec = new COutStreamWithSha1();
+ shaStream = shaStreamSpec;
+ shaStreamSpec->SetStream(outStream);
+ shaStreamSpec->Init(digest != NULL);
+ outStream = shaStream;
+ }
+
+ HRESULT res = Unpack2(inStream, resource, header, db, outStream, progress);
+
+ if (digest)
+ shaStreamSpec->Final(digest);
+
+ return res;
+}
+
+
+HRESULT CUnpacker::UnpackData(IInStream *inStream,
+ const CResource &resource, const CHeader &header,
+ const CDatabase *db,
+ CByteBuffer &buf, Byte *digest)
+{
+ // if (resource.IsSolid()) return E_NOTIMPL;
+
+ UInt64 unpackSize64 = resource.UnpackSize;
+ if (db)
+ unpackSize64 = db->Get_UnpackSize_of_Resource(resource);
+
+ size_t size = (size_t)unpackSize64;
+ if (size != unpackSize64)
+ return E_OUTOFMEMORY;
+
+ buf.Alloc(size);
+
+ CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream();
+ CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+ outStreamSpec->Init((Byte *)buf, size);
+
+ return Unpack(inStream, resource, header, db, outStream, NULL, digest);
+}
+
+
+void CResource::Parse(const Byte *p)
+{
+ Flags = p[7];
+ PackSize = Get64(p) & (((UInt64)1 << 56) - 1);
+ Offset = Get64(p + 8);
+ UnpackSize = Get64(p + 16);
+ KeepSolid = false;
+ SolidIndex = -1;
+}
+
+#define GET_RESOURCE(_p_, res) res.ParseAndUpdatePhySize(_p_, phySize)
+
+static inline void ParseStream(bool oldVersion, const Byte *p, CStreamInfo &s)
+{
+ s.Resource.Parse(p);
+ if (oldVersion)
+ {
+ s.PartNumber = 1;
+ s.Id = Get32(p + 24);
+ p += 28;
+ }
+ else
+ {
+ s.PartNumber = Get16(p + 24);
+ p += 26;
+ }
+ s.RefCount = Get32(p);
+ memcpy(s.Hash, p + 4, kHashSize);
+}
+
+
+#define kLongPath "[LongPath]"
+
+void CDatabase::GetShortName(unsigned index, NWindows::NCOM::CPropVariant &name) const
+{
+ const CItem &item = Items[index];
+ const CImage &image = Images[item.ImageIndex];
+ if (item.Parent < 0 && image.NumEmptyRootItems != 0)
+ {
+ name.Clear();
+ return;
+ }
+ const Byte *meta = image.Meta + item.Offset +
+ (IsOldVersion ? kDirRecordSizeOld : kDirRecordSize);
+ UInt32 fileNameLen = Get16(meta - 2);
+ UInt32 shortLen = Get16(meta - 4) / 2;
+ wchar_t *s = name.AllocBstr(shortLen);
+ if (fileNameLen != 0)
+ meta += fileNameLen + 2;
+ for (UInt32 i = 0; i < shortLen; i++)
+ s[i] = Get16(meta + i * 2);
+ s[shortLen] = 0;
+ // empty shortName has no ZERO at the end ?
+}
+
+
+void CDatabase::GetItemName(unsigned index, NWindows::NCOM::CPropVariant &name) const
+{
+ const CItem &item = Items[index];
+ const CImage &image = Images[item.ImageIndex];
+ if (item.Parent < 0 && image.NumEmptyRootItems != 0)
+ {
+ name = image.RootName;
+ return;
+ }
+ const Byte *meta = image.Meta + item.Offset +
+ (item.IsAltStream ?
+ (IsOldVersion ? 0x10 : 0x24) :
+ (IsOldVersion ? kDirRecordSizeOld - 2 : kDirRecordSize - 2));
+ UInt32 len = Get16(meta) / 2;
+ wchar_t *s = name.AllocBstr(len);
+ meta += 2;
+ len++;
+ for (UInt32 i = 0; i < len; i++)
+ s[i] = Get16(meta + i * 2);
+}
+
+
+void CDatabase::GetItemPath(unsigned index1, bool showImageNumber, NWindows::NCOM::CPropVariant &path) const
+{
+ unsigned size = 0;
+ int index = (int)index1;
+ const int imageIndex = Items[index].ImageIndex;
+ const CImage &image = Images[imageIndex];
+
+ unsigned newLevel = 0;
+ bool needColon = false;
+
+ for (;;)
+ {
+ const CItem &item = Items[index];
+ index = item.Parent;
+ if (index >= 0 || image.NumEmptyRootItems == 0)
+ {
+ const Byte *meta = image.Meta + item.Offset;
+ meta += item.IsAltStream ?
+ (IsOldVersion ? 0x10 : 0x24) :
+ (IsOldVersion ? kDirRecordSizeOld - 2 : kDirRecordSize - 2);
+ needColon = item.IsAltStream;
+ size += Get16(meta) / 2;
+ size += newLevel;
+ newLevel = 1;
+ if (size >= ((UInt32)1 << 15))
+ {
+ path = kLongPath;
+ return;
+ }
+ }
+ if (index < 0)
+ break;
+ }
+
+ if (showImageNumber)
+ {
+ size += image.RootName.Len();
+ size += newLevel;
+ }
+ else if (needColon)
+ size++;
+
+ wchar_t *s = path.AllocBstr(size);
+ s[size] = 0;
+
+ if (showImageNumber)
+ {
+ MyStringCopy(s, (const wchar_t *)image.RootName);
+ if (newLevel)
+ s[image.RootName.Len()] = (wchar_t)(needColon ? L':' : WCHAR_PATH_SEPARATOR);
+ }
+ else if (needColon)
+ s[0] = L':';
+
+ index = (int)index1;
+ wchar_t separator = 0;
+
+ for (;;)
+ {
+ const CItem &item = Items[index];
+ index = item.Parent;
+ if (index >= 0 || image.NumEmptyRootItems == 0)
+ {
+ if (separator != 0)
+ s[--size] = separator;
+ const Byte *meta = image.Meta + item.Offset;
+ meta += (item.IsAltStream) ?
+ (IsOldVersion ? 0x10: 0x24) :
+ (IsOldVersion ? kDirRecordSizeOld - 2 : kDirRecordSize - 2);
+ unsigned len = Get16(meta) / 2;
+ size -= len;
+ wchar_t *dest = s + size;
+ meta += 2;
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = Get16(meta + i * 2);
+ if (c == L'/')
+ c = L'_';
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ else if (c == L'\\')
+ c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // 22.00 : WSL scheme
+ #endif
+ dest[i] = c;
+ }
+ }
+ if (index < 0)
+ return;
+ separator = item.IsAltStream ? L':' : WCHAR_PATH_SEPARATOR;
+ }
+}
+
+
+// if (ver <= 1.10), root folder contains real items.
+// if (ver >= 1.12), root folder contains only one folder with empty name.
+
+HRESULT CDatabase::ParseDirItem(size_t pos, int parent)
+{
+ const unsigned align = GetDirAlignMask();
+ if ((pos & align) != 0)
+ return S_FALSE;
+
+ for (unsigned numItems = 0;; numItems++)
+ {
+ if (OpenCallback && (Items.Size() & 0xFFFF) == 0)
+ {
+ UInt64 numFiles = Items.Size();
+ RINOK(OpenCallback->SetCompleted(&numFiles, NULL))
+ }
+
+ const size_t rem = DirSize - pos;
+ if (pos < DirStartOffset || pos > DirSize || rem < 8)
+ return S_FALSE;
+
+ const Byte *p = DirData + pos;
+
+ UInt64 len = Get64(p);
+ if (len == 0)
+ {
+ DirProcessed += 8;
+ return S_OK;
+ }
+
+ if ((len & align) != 0 || rem < len)
+ return S_FALSE;
+
+ DirProcessed += (size_t)len;
+ if (DirProcessed > DirSize)
+ return S_FALSE;
+
+ const unsigned dirRecordSize = IsOldVersion ? kDirRecordSizeOld : kDirRecordSize;
+ if (len < dirRecordSize)
+ return S_FALSE;
+
+ CItem item;
+ UInt32 attrib = Get32(p + 8);
+ item.IsDir = ((attrib & 0x10) != 0);
+ UInt64 subdirOffset = Get64(p + 0x10);
+
+ const UInt32 numAltStreams = Get16(p + dirRecordSize - 6);
+ const UInt32 shortNameLen = Get16(p + dirRecordSize - 4);
+ const UInt32 fileNameLen = Get16(p + dirRecordSize - 2);
+ if ((shortNameLen & 1) != 0 || (fileNameLen & 1) != 0)
+ return S_FALSE;
+ const UInt32 shortNameLen2 = (shortNameLen == 0 ? shortNameLen : shortNameLen + 2);
+ const UInt32 fileNameLen2 = (fileNameLen == 0 ? fileNameLen : fileNameLen + 2);
+ if (((dirRecordSize + fileNameLen2 + shortNameLen2 + align) & ~align) > len)
+ return S_FALSE;
+
+ p += dirRecordSize;
+
+ {
+ if (*(const UInt16 *)(const void *)(p + fileNameLen) != 0)
+ return S_FALSE;
+ for (UInt32 j = 0; j < fileNameLen; j += 2)
+ if (*(const UInt16 *)(const void *)(p + j) == 0)
+ return S_FALSE;
+ }
+
+ // PRF(printf("\n%S", p));
+
+ if (shortNameLen != 0)
+ {
+ // empty shortName has no ZERO at the end ?
+ const Byte *p2 = p + fileNameLen2;
+ if (*(const UInt16 *)(const void *)(p2 + shortNameLen) != 0)
+ return S_FALSE;
+ for (UInt32 j = 0; j < shortNameLen; j += 2)
+ if (*(const UInt16 *)(const void *)(p2 + j) == 0)
+ return S_FALSE;
+ }
+
+ item.Offset = pos;
+ item.Parent = parent;
+ item.ImageIndex = (int)Images.Size() - 1;
+
+ const unsigned prevIndex = Items.Add(item);
+
+ pos += (size_t)len;
+
+ for (UInt32 i = 0; i < numAltStreams; i++)
+ {
+ const size_t rem2 = DirSize - pos;
+ if (pos < DirStartOffset || pos > DirSize || rem2 < 8)
+ return S_FALSE;
+ const Byte *p2 = DirData + pos;
+ const UInt64 len2 = Get64(p2);
+ if ((len2 & align) != 0 || rem2 < len2
+ || len2 < (unsigned)(IsOldVersion ? 0x18 : 0x28))
+ return S_FALSE;
+
+ DirProcessed += (size_t)len2;
+ if (DirProcessed > DirSize)
+ return S_FALSE;
+
+ unsigned extraOffset = 0;
+
+ if (IsOldVersion)
+ extraOffset = 0x10;
+ else
+ {
+ if (Get64(p2 + 8) != 0)
+ return S_FALSE;
+ extraOffset = 0x24;
+ }
+
+ const UInt32 fileNameLen111 = Get16(p2 + extraOffset);
+ if ((fileNameLen111 & 1) != 0)
+ return S_FALSE;
+ /* Probably different versions of ImageX can use different number of
+ additional ZEROs. So we don't use exact check. */
+ const UInt32 fileNameLen222 = (fileNameLen111 == 0 ? fileNameLen111 : fileNameLen111 + 2);
+ if (((extraOffset + 2 + fileNameLen222 + align) & ~align) > len2)
+ return S_FALSE;
+
+ {
+ const Byte *p3 = p2 + extraOffset + 2;
+ if (*(const UInt16 *)(const void *)(p3 + fileNameLen111) != 0)
+ return S_FALSE;
+ for (UInt32 j = 0; j < fileNameLen111; j += 2)
+ if (*(const UInt16 *)(const void *)(p3 + j) == 0)
+ return S_FALSE;
+
+ // PRF(printf("\n %S", p3));
+ }
+
+
+ /* wim uses alt sreams list, if there is at least one alt stream.
+ And alt stream without name is main stream. */
+
+ // Why wimlib writes two alt streams for REPARSE_POINT, with empty second alt stream?
+
+ Byte *prevMeta = DirData + item.Offset;
+
+ if (fileNameLen111 == 0 &&
+ ((attrib & FILE_ATTRIBUTE_REPARSE_POINT) || !item.IsDir)
+ && (IsOldVersion || IsEmptySha(prevMeta + 0x40)))
+ {
+ if (IsOldVersion)
+ memcpy(prevMeta + 0x10, p2 + 8, 4); // It's 32-bit Id
+ else if (!IsEmptySha(p2 + 0x10))
+ {
+ // if (IsEmptySha(prevMeta + 0x40))
+ memcpy(prevMeta + 0x40, p2 + 0x10, kHashSize);
+ // else HeadersError = true;
+ }
+ }
+ else
+ {
+ ThereAreAltStreams = true;
+ CItem item2;
+ item2.Offset = pos;
+ item2.IsAltStream = true;
+ item2.Parent = (int)prevIndex;
+ item2.ImageIndex = (int)Images.Size() - 1;
+ Items.Add(item2);
+ }
+
+ pos += (size_t)len2;
+ }
+
+ if (parent < 0 && numItems == 0 && shortNameLen == 0 && fileNameLen == 0 && item.IsDir)
+ {
+ const Byte *p2 = DirData + pos;
+ if (DirSize - pos >= 8 && Get64(p2) == 0)
+ {
+ CImage &image = Images.Back();
+ image.NumEmptyRootItems = 1;
+
+ if (subdirOffset != 0
+ && DirSize - pos >= 16
+ && Get64(p2 + 8) != 0
+ && pos + 8 < subdirOffset)
+ {
+ // Longhorn.4093 contains hidden files after empty root folder and before items of next folder. Why?
+ // That code shows them. If we want to ignore them, we need to update DirProcessed.
+ // DirProcessed += (size_t)(subdirOffset - (pos + 8));
+ // printf("\ndirOffset = %5d hiddenOffset = %5d\n", (int)subdirOffset, (int)pos + 8);
+ subdirOffset = pos + 8;
+ // return S_FALSE;
+ }
+ }
+ }
+
+ if (item.IsDir && subdirOffset != 0)
+ {
+ RINOK(ParseDirItem((size_t)subdirOffset, (int)prevIndex))
+ }
+ }
+}
+
+
+HRESULT CDatabase::ParseImageDirs(CByteBuffer &buf, int parent)
+{
+ DirData = buf;
+ DirSize = buf.Size();
+ if (DirSize < 8)
+ return S_FALSE;
+ const Byte *p = DirData;
+ size_t pos = 0;
+ CImage &image = Images.Back();
+
+ if (IsOldVersion)
+ {
+ UInt32 numEntries = Get32(p + 4);
+
+ if (numEntries > (1 << 28) ||
+ numEntries > (DirSize >> 3))
+ return S_FALSE;
+
+ UInt32 sum = 8;
+ if (numEntries != 0)
+ sum = numEntries * 8;
+
+ image.SecurOffsets.ClearAndReserve(numEntries + 1);
+ image.SecurOffsets.AddInReserved(sum);
+
+ for (UInt32 i = 0; i < numEntries; i++)
+ {
+ const Byte *pp = p + (size_t)i * 8;
+ UInt32 len = Get32(pp);
+ if (i != 0 && Get32(pp + 4) != 0)
+ return S_FALSE;
+ if (len > DirSize - sum)
+ return S_FALSE;
+ sum += len;
+ if (sum < len)
+ return S_FALSE;
+ image.SecurOffsets.AddInReserved(sum);
+ }
+
+ pos = sum;
+
+ const size_t align = GetDirAlignMask();
+ pos = (pos + align) & ~(size_t)align;
+ }
+ else
+ {
+ UInt32 totalLen = Get32(p);
+ if (totalLen == 0)
+ pos = 8;
+ else
+ {
+ if (totalLen < 8)
+ return S_FALSE;
+ UInt32 numEntries = Get32(p + 4);
+ pos = 8;
+ if (totalLen > DirSize || numEntries > ((totalLen - 8) >> 3))
+ return S_FALSE;
+ UInt32 sum = (UInt32)pos + numEntries * 8;
+ image.SecurOffsets.ClearAndReserve(numEntries + 1);
+ image.SecurOffsets.AddInReserved(sum);
+
+ for (UInt32 i = 0; i < numEntries; i++, pos += 8)
+ {
+ UInt64 len = Get64(p + pos);
+ if (len > totalLen - sum)
+ return S_FALSE;
+ sum += (UInt32)len;
+ image.SecurOffsets.AddInReserved(sum);
+ }
+
+ pos = sum;
+ pos = (pos + 7) & ~(size_t)7;
+ if (pos != (((size_t)totalLen + 7) & ~(size_t)7))
+ return S_FALSE;
+ }
+ }
+
+ if (pos > DirSize)
+ return S_FALSE;
+
+ DirStartOffset = DirProcessed = pos;
+ image.StartItem = Items.Size();
+
+ RINOK(ParseDirItem(pos, parent))
+
+ image.NumItems = Items.Size() - image.StartItem;
+ if (DirProcessed == DirSize)
+ return S_OK;
+
+ /* Original program writes additional 8 bytes (END_OF_ROOT_FOLDER),
+ but the reference to that folder is empty */
+
+ // we can't use DirProcessed - DirStartOffset == 112 check if there is alt stream in root
+ if (DirProcessed == DirSize - 8 && Get64(p + DirSize - 8) != 0)
+ return S_OK;
+
+ // 18.06: we support cases, when some old dism can capture images
+ // where DirProcessed much smaller than DirSize
+ HeadersError = true;
+ return S_OK;
+ // return S_FALSE;
+}
+
+
+HRESULT CHeader::Parse(const Byte *p, UInt64 &phySize)
+{
+ UInt32 headerSize = Get32(p + 8);
+ phySize = headerSize;
+ Version = Get32(p + 0x0C);
+ Flags = Get32(p + 0x10);
+ if (!IsSupported())
+ return S_FALSE;
+
+ {
+ ChunkSize = Get32(p + 0x14);
+ ChunkSizeBits = kChunkSizeBits;
+ if (ChunkSize != 0)
+ {
+ const int log = GetLog(ChunkSize);
+ if (log < 12)
+ return S_FALSE;
+ ChunkSizeBits = (unsigned)log;
+ }
+ }
+
+ _isOldVersion = false;
+ _isNewVersion = false;
+
+ if (IsSolidVersion())
+ _isNewVersion = true;
+ else
+ {
+ if (Version < 0x010900)
+ return S_FALSE;
+ _isOldVersion = (Version <= 0x010A00);
+ // We don't know details about 1.11 version. So we use headerSize to guess exact features.
+ if (Version == 0x010B00 && headerSize == 0x60)
+ _isOldVersion = true;
+ _isNewVersion = (Version >= 0x010D00);
+ }
+
+ unsigned offset;
+
+ if (IsOldVersion())
+ {
+ if (headerSize != 0x60)
+ return S_FALSE;
+ memset(Guid, 0, 16);
+ offset = 0x18;
+ PartNumber = 1;
+ NumParts = 1;
+ }
+ else
+ {
+ if (headerSize < 0x74)
+ return S_FALSE;
+ memcpy(Guid, p + 0x18, 16);
+ PartNumber = Get16(p + 0x28);
+ NumParts = Get16(p + 0x2A);
+ if (PartNumber == 0 || PartNumber > NumParts)
+ return S_FALSE;
+ offset = 0x2C;
+ if (IsNewVersion())
+ {
+ // if (headerSize < 0xD0)
+ if (headerSize != 0xD0)
+ return S_FALSE;
+ NumImages = Get32(p + offset);
+ offset += 4;
+ }
+ }
+
+ GET_RESOURCE(p + offset , OffsetResource);
+ GET_RESOURCE(p + offset + 0x18, XmlResource);
+ GET_RESOURCE(p + offset + 0x30, MetadataResource);
+ BootIndex = 0;
+
+ if (IsNewVersion())
+ {
+ BootIndex = Get32(p + offset + 0x48);
+ GET_RESOURCE(p + offset + 0x4C, IntegrityResource);
+ }
+
+ return S_OK;
+}
+
+
+const Byte kSignature[kSignatureSize] = { 'M', 'S', 'W', 'I', 'M', 0, 0, 0 };
+
+HRESULT ReadHeader(IInStream *inStream, CHeader &h, UInt64 &phySize)
+{
+ Byte p[kHeaderSizeMax];
+ RINOK(ReadStream_FALSE(inStream, p, kHeaderSizeMax))
+ if (memcmp(p, kSignature, kSignatureSize) != 0)
+ return S_FALSE;
+ return h.Parse(p, phySize);
+}
+
+
+static HRESULT ReadStreams(IInStream *inStream, const CHeader &h, CDatabase &db)
+{
+ CByteBuffer offsetBuf;
+
+ CUnpacker unpacker;
+ RINOK(unpacker.UnpackData(inStream, h.OffsetResource, h, NULL, offsetBuf, NULL))
+
+ const size_t streamInfoSize = h.IsOldVersion() ? kStreamInfoSize + 2 : kStreamInfoSize;
+ {
+ const unsigned numItems = (unsigned)(offsetBuf.Size() / streamInfoSize);
+ if ((size_t)numItems * streamInfoSize != offsetBuf.Size())
+ return S_FALSE;
+ const unsigned numItems2 = db.DataStreams.Size() + numItems;
+ if (numItems2 < numItems)
+ return S_FALSE;
+ db.DataStreams.Reserve(numItems2);
+ }
+
+ bool keepSolid = false;
+
+ for (size_t i = 0; i < offsetBuf.Size(); i += streamInfoSize)
+ {
+ CStreamInfo s;
+ ParseStream(h.IsOldVersion(), (const Byte *)offsetBuf + i, s);
+
+ PRF(printf("\n"));
+ PRF(printf(s.Resource.IsMetadata() ? "### META" : " DATA"));
+ PRF(printf(" %2X", s.Resource.Flags));
+ PRF(printf(" %9I64X", s.Resource.Offset));
+ PRF(printf(" %9I64X", s.Resource.PackSize));
+ PRF(printf(" %9I64X", s.Resource.UnpackSize));
+ PRF(printf(" %d", s.RefCount));
+
+ if (s.PartNumber != h.PartNumber)
+ continue;
+
+ if (s.Resource.IsSolid())
+ {
+ s.Resource.KeepSolid = keepSolid;
+ keepSolid = true;
+ }
+ else
+ {
+ s.Resource.KeepSolid = false;
+ keepSolid = false;
+ }
+
+ if (!s.Resource.IsMetadata())
+ db.DataStreams.AddInReserved(s);
+ else
+ {
+ if (s.Resource.IsSolid())
+ return E_NOTIMPL;
+ if (s.RefCount == 0)
+ {
+ // some wims have such (deleted?) metadata stream.
+ // examples: boot.wim in VistaBeta2, WinPE.wim from WAIK.
+ // db.DataStreams.Add(s);
+ // we can show these delete images, if we comment "continue" command;
+ continue;
+ }
+
+ if (s.RefCount > 1)
+ {
+ return S_FALSE;
+ // s.RefCount--;
+ // db.DataStreams.Add(s);
+ }
+
+ db.MetaStreams.Add(s);
+ }
+ }
+
+ PRF(printf("\n"));
+
+ return S_OK;
+}
+
+
+HRESULT CDatabase::OpenXml(IInStream *inStream, const CHeader &h, CByteBuffer &xml)
+{
+ CUnpacker unpacker;
+ return unpacker.UnpackData(inStream, h.XmlResource, h, this, xml, NULL);
+}
+
+static void SetRootNames(CImage &image, unsigned value)
+{
+ wchar_t temp[16];
+ ConvertUInt32ToString(value, temp);
+ image.RootName = temp;
+ image.RootNameBuf.Alloc(image.RootName.Len() * 2 + 2);
+ Byte *p = image.RootNameBuf;
+ unsigned len = image.RootName.Len() + 1;
+ for (unsigned k = 0; k < len; k++)
+ {
+ p[k * 2] = (Byte)temp[k];
+ p[k * 2 + 1] = 0;
+ }
+}
+
+
+HRESULT CDatabase::Open(IInStream *inStream, const CHeader &h, unsigned numItemsReserve, IArchiveOpenCallback *openCallback)
+{
+ OpenCallback = openCallback;
+ IsOldVersion = h.IsOldVersion();
+ IsOldVersion9 = (h.Version == 0x10900);
+
+ RINOK(ReadStreams(inStream, h, *this))
+
+ bool needBootMetadata = !h.MetadataResource.IsEmpty();
+ unsigned numNonDeletedImages = 0;
+
+ CUnpacker unpacker;
+
+ FOR_VECTOR (i, MetaStreams)
+ {
+ const CStreamInfo &si = MetaStreams[i];
+
+ if (h.PartNumber != 1 || si.PartNumber != h.PartNumber)
+ continue;
+
+ const unsigned userImage = Images.Size() + GetStartImageIndex();
+ CImage &image = Images.AddNew();
+ SetRootNames(image, userImage);
+
+ CByteBuffer &metadata = image.Meta;
+ Byte hash[kHashSize];
+
+ RINOK(unpacker.UnpackData(inStream, si.Resource, h, this, metadata, hash))
+
+ if (memcmp(hash, si.Hash, kHashSize) != 0 &&
+ !(h.IsOldVersion() && IsEmptySha(si.Hash)))
+ return S_FALSE;
+
+ image.NumEmptyRootItems = 0;
+
+ if (Items.IsEmpty())
+ Items.ClearAndReserve(numItemsReserve);
+
+ RINOK(ParseImageDirs(metadata, -1))
+
+ if (needBootMetadata)
+ {
+ bool sameRes = (h.MetadataResource.Offset == si.Resource.Offset);
+ if (sameRes)
+ needBootMetadata = false;
+ if (h.IsNewVersion())
+ {
+ if (si.RefCount == 1)
+ {
+ numNonDeletedImages++;
+ bool isBootIndex = (h.BootIndex == numNonDeletedImages);
+ if (sameRes && !isBootIndex)
+ return S_FALSE;
+ if (isBootIndex && !sameRes)
+ return S_FALSE;
+ }
+ }
+ }
+ }
+
+ if (needBootMetadata)
+ return S_FALSE;
+ return S_OK;
+}
+
+
+bool CDatabase::ItemHasStream(const CItem &item) const
+{
+ if (item.ImageIndex < 0)
+ return true;
+ const Byte *meta = Images[item.ImageIndex].Meta + item.Offset;
+ if (IsOldVersion)
+ {
+ // old wim use same field for file_id and dir_offset;
+ if (item.IsDir)
+ return false;
+ meta += (item.IsAltStream ? 0x8 : 0x10);
+ UInt32 id = GetUi32(meta);
+ return id != 0;
+ }
+ meta += (item.IsAltStream ? 0x10 : 0x40);
+ return !IsEmptySha(meta);
+}
+
+
+#define RINOZ(x) { int _tt_ = (x); if (_tt_ != 0) return _tt_; }
+
+static int CompareStreamsByPos(const CStreamInfo *p1, const CStreamInfo *p2, void * /* param */)
+{
+ RINOZ(MyCompare(p1->PartNumber, p2->PartNumber))
+ RINOZ(MyCompare(p1->Resource.Offset, p2->Resource.Offset))
+ return MyCompare(p1->Resource.PackSize, p2->Resource.PackSize);
+}
+
+static int CompareIDs(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const CStreamInfo *streams = (const CStreamInfo *)param;
+ return MyCompare(streams[*p1].Id, streams[*p2].Id);
+}
+
+static int CompareHashRefs(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const CStreamInfo *streams = (const CStreamInfo *)param;
+ return memcmp(streams[*p1].Hash, streams[*p2].Hash, kHashSize);
+}
+
+static int FindId(const CStreamInfo *streams, const CUIntVector &sorted, UInt32 id)
+{
+ unsigned left = 0, right = sorted.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const unsigned streamIndex = sorted[mid];
+ const UInt32 id2 = streams[streamIndex].Id;
+ if (id == id2)
+ return (int)streamIndex;
+ if (id < id2)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+}
+
+static int FindHash(const CStreamInfo *streams, const CUIntVector &sorted, const Byte *hash)
+{
+ unsigned left = 0, right = sorted.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const unsigned streamIndex = sorted[mid];
+ const Byte *hash2 = streams[streamIndex].Hash;
+ unsigned i;
+ for (i = 0; i < kHashSize; i++)
+ if (hash[i] != hash2[i])
+ break;
+ if (i == kHashSize)
+ return (int)streamIndex;
+ if (hash[i] < hash2[i])
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+}
+
+static int CompareItems(const unsigned *a1, const unsigned *a2, void *param)
+{
+ const CRecordVector<CItem> &items = ((CDatabase *)param)->Items;
+ const CItem &i1 = items[*a1];
+ const CItem &i2 = items[*a2];
+
+ if (i1.IsDir != i2.IsDir)
+ return i1.IsDir ? -1 : 1;
+ if (i1.IsAltStream != i2.IsAltStream)
+ return i1.IsAltStream ? 1 : -1;
+ RINOZ(MyCompare(i1.StreamIndex, i2.StreamIndex))
+ RINOZ(MyCompare(i1.ImageIndex, i2.ImageIndex))
+ return MyCompare(i1.Offset, i2.Offset);
+}
+
+
+HRESULT CDatabase::FillAndCheck(const CObjectVector<CVolume> &volumes)
+{
+ CUIntVector sortedByHash;
+ sortedByHash.Reserve(DataStreams.Size());
+ {
+ CByteBuffer sizesBuf;
+
+ for (unsigned iii = 0; iii < DataStreams.Size();)
+ {
+ {
+ const CResource &r = DataStreams[iii].Resource;
+ if (!r.IsSolid())
+ {
+ sortedByHash.AddInReserved(iii++);
+ continue;
+ }
+ }
+
+ UInt64 solidRunOffset = 0;
+ unsigned k;
+ unsigned numSolidsStart = Solids.Size();
+
+ for (k = iii; k < DataStreams.Size(); k++)
+ {
+ CStreamInfo &si = DataStreams[k];
+ CResource &r = si.Resource;
+
+ if (!r.IsSolid())
+ break;
+ if (!r.KeepSolid && k != iii)
+ break;
+
+ if (r.Flags != NResourceFlags::kSolid)
+ return S_FALSE;
+
+ if (!r.IsSolidBig())
+ continue;
+
+ if (!si.IsEmptyHash())
+ return S_FALSE;
+ if (si.RefCount != 1)
+ return S_FALSE;
+
+ r.SolidIndex = (int)Solids.Size();
+
+ CSolid &ss = Solids.AddNew();
+ ss.StreamIndex = k;
+ ss.SolidOffset = solidRunOffset;
+ {
+ const size_t kSolidHeaderSize = 8 + 4 + 4;
+ Byte header[kSolidHeaderSize];
+
+ if (si.PartNumber >= volumes.Size())
+ return S_FALSE;
+
+ const CVolume &vol = volumes[si.PartNumber];
+ IInStream *inStream = vol.Stream;
+ RINOK(InStream_SeekSet(inStream, r.Offset))
+ RINOK(ReadStream_FALSE(inStream, (Byte *)header, kSolidHeaderSize))
+
+ ss.UnpackSize = GetUi64(header);
+
+ if (ss.UnpackSize > ((UInt64)1 << 63))
+ return S_FALSE;
+
+ solidRunOffset += ss.UnpackSize;
+ if (solidRunOffset < ss.UnpackSize)
+ return S_FALSE;
+
+ const UInt32 solidChunkSize = GetUi32(header + 8);
+ const int log = GetLog(solidChunkSize);
+ if (log < 8 || log > 31)
+ return S_FALSE;
+ ss.ChunkSizeBits = (unsigned)log;
+ ss.Method = (Int32)GetUi32(header + 12);
+
+ UInt64 numChunks64 = (ss.UnpackSize + (((UInt32)1 << ss.ChunkSizeBits) - 1)) >> ss.ChunkSizeBits;
+ UInt64 sizesBufSize64 = 4 * numChunks64;
+ ss.HeadersSize = kSolidHeaderSize + sizesBufSize64;
+ size_t sizesBufSize = (size_t)sizesBufSize64;
+ if (sizesBufSize != sizesBufSize64)
+ return E_OUTOFMEMORY;
+ sizesBuf.AllocAtLeast(sizesBufSize);
+
+ RINOK(ReadStream_FALSE(inStream, sizesBuf, sizesBufSize))
+
+ size_t numChunks = (size_t)numChunks64;
+ ss.Chunks.Alloc(numChunks + 1);
+
+ UInt64 offset = 0;
+
+ size_t c;
+ for (c = 0; c < numChunks; c++)
+ {
+ ss.Chunks[c] = offset;
+ UInt32 packSize = GetUi32((const Byte *)sizesBuf + c * 4);
+ offset += packSize;
+ if (offset < packSize)
+ return S_FALSE;
+ }
+ ss.Chunks[c] = offset;
+
+ if (ss.Chunks[0] != 0)
+ return S_FALSE;
+ if (ss.HeadersSize + offset != r.PackSize)
+ return S_FALSE;
+ }
+ }
+
+ unsigned solidLim = k;
+
+ for (k = iii; k < solidLim; k++)
+ {
+ CStreamInfo &si = DataStreams[k];
+ CResource &r = si.Resource;
+
+ if (!r.IsSolidSmall())
+ continue;
+
+ if (si.IsEmptyHash())
+ return S_FALSE;
+
+ unsigned solidIndex;
+ {
+ UInt64 offset = r.Offset;
+ for (solidIndex = numSolidsStart;; solidIndex++)
+ {
+ if (solidIndex == Solids.Size())
+ return S_FALSE;
+ UInt64 unpackSize = Solids[solidIndex].UnpackSize;
+ if (offset < unpackSize)
+ break;
+ offset -= unpackSize;
+ }
+ }
+ CSolid &ss = Solids[solidIndex];
+ if (r.Offset < ss.SolidOffset)
+ return S_FALSE;
+ const UInt64 relat = r.Offset - ss.SolidOffset;
+ if (relat > ss.UnpackSize)
+ return S_FALSE;
+ if (r.PackSize > ss.UnpackSize - relat)
+ return S_FALSE;
+ r.SolidIndex = (int)solidIndex;
+ if (ss.FirstSmallStream < 0)
+ ss.FirstSmallStream = (int)k;
+
+ sortedByHash.AddInReserved(k);
+ // ss.NumRefs++;
+ }
+
+ iii = solidLim;
+ }
+ }
+
+ if (Solids.IsEmpty())
+ {
+ /* We want to check that streams layout is OK.
+ So we need resources sorted by offset.
+ Another code can work with non-sorted streams.
+ NOTE: all WIM programs probably create wim archives with
+ sorted data streams. So it doesn't call Sort() here. */
+
+ {
+ unsigned i;
+ for (i = 1; i < DataStreams.Size(); i++)
+ {
+ const CStreamInfo &s0 = DataStreams[i - 1];
+ const CStreamInfo &s1 = DataStreams[i];
+ if (s0.PartNumber < s1.PartNumber) continue;
+ if (s0.PartNumber > s1.PartNumber) break;
+ if (s0.Resource.Offset < s1.Resource.Offset) continue;
+ if (s0.Resource.Offset > s1.Resource.Offset) break;
+ if (s0.Resource.PackSize > s1.Resource.PackSize) break;
+ }
+
+ if (i < DataStreams.Size())
+ {
+ // return E_FAIL;
+ DataStreams.Sort(CompareStreamsByPos, NULL);
+ }
+ }
+
+ for (unsigned i = 1; i < DataStreams.Size(); i++)
+ {
+ const CStreamInfo &s0 = DataStreams[i - 1];
+ const CStreamInfo &s1 = DataStreams[i];
+ if (s0.PartNumber == s1.PartNumber)
+ if (s0.Resource.GetEndLimit() > s1.Resource.Offset)
+ return S_FALSE;
+ }
+ }
+
+ {
+ {
+ const CStreamInfo *streams = &DataStreams.Front();
+
+ if (IsOldVersion)
+ {
+ sortedByHash.Sort(CompareIDs, (void *)streams);
+
+ for (unsigned i = 1; i < sortedByHash.Size(); i++)
+ if (streams[sortedByHash[i - 1]].Id >=
+ streams[sortedByHash[i]].Id)
+ return S_FALSE;
+ }
+ else
+ {
+ sortedByHash.Sort(CompareHashRefs, (void *)streams);
+
+ if (!sortedByHash.IsEmpty())
+ {
+ if (IsEmptySha(streams[sortedByHash[0]].Hash))
+ HeadersError = true;
+
+ for (unsigned i = 1; i < sortedByHash.Size(); i++)
+ if (memcmp(
+ streams[sortedByHash[i - 1]].Hash,
+ streams[sortedByHash[i]].Hash,
+ kHashSize) >= 0)
+ return S_FALSE;
+ }
+ }
+ }
+
+ FOR_VECTOR (i, Items)
+ {
+ CItem &item = Items[i];
+ item.StreamIndex = -1;
+ const Byte *hash = Images[item.ImageIndex].Meta + item.Offset;
+ if (IsOldVersion)
+ {
+ if (!item.IsDir)
+ {
+ hash += (item.IsAltStream ? 0x8 : 0x10);
+ UInt32 id = GetUi32(hash);
+ if (id != 0)
+ item.StreamIndex = FindId(&DataStreams.Front(), sortedByHash, id);
+ }
+ }
+ /*
+ else if (item.IsDir)
+ {
+ // reparse points can have dirs some dir
+ }
+ */
+ else
+ {
+ hash += (item.IsAltStream ? 0x10 : 0x40);
+ if (!IsEmptySha(hash))
+ {
+ item.StreamIndex = FindHash(&DataStreams.Front(), sortedByHash, hash);
+ }
+ }
+ }
+ }
+ {
+ CUIntVector refCounts;
+ refCounts.ClearAndSetSize(DataStreams.Size());
+ unsigned i;
+
+ for (i = 0; i < DataStreams.Size(); i++)
+ {
+ UInt32 startVal = 0;
+ // const CStreamInfo &s = DataStreams[i];
+ /*
+ if (s.Resource.IsMetadata() && s.PartNumber == 1)
+ startVal = 1;
+ */
+ refCounts[i] = startVal;
+ }
+
+ for (i = 0; i < Items.Size(); i++)
+ {
+ int streamIndex = Items[i].StreamIndex;
+ if (streamIndex >= 0)
+ refCounts[streamIndex]++;
+ }
+
+ for (i = 0; i < DataStreams.Size(); i++)
+ {
+ const CStreamInfo &s = DataStreams[i];
+ if (s.RefCount != refCounts[i]
+ && !s.Resource.IsSolidBig())
+ {
+ /*
+ printf("\ni=%5d si.Ref=%2d realRefs=%2d size=%8d offset=%8x id=%4d ",
+ i, s.RefCount, refCounts[i], (unsigned)s.Resource.UnpackSize, (unsigned)s.Resource.Offset, s.Id);
+ */
+ RefCountError = true;
+ }
+
+ if (refCounts[i] == 0)
+ {
+ const CResource &r = DataStreams[i].Resource;
+ if (!r.IsSolidBig() || Solids[r.SolidIndex].FirstSmallStream < 0)
+ {
+ CItem item;
+ item.Offset = 0;
+ item.StreamIndex = (int)i;
+ item.ImageIndex = -1;
+ Items.Add(item);
+ ThereAreDeletedStreams = true;
+ }
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CDatabase::GenerateSortedItems(int imageIndex, bool showImageNumber)
+{
+ SortedItems.Clear();
+ VirtualRoots.Clear();
+ IndexOfUserImage = imageIndex;
+ NumExcludededItems = 0;
+ ExludedItem = -1;
+
+ if (Images.Size() != 1 && imageIndex < 0)
+ showImageNumber = true;
+
+ unsigned startItem = 0;
+ unsigned endItem = 0;
+
+ if (imageIndex < 0)
+ {
+ endItem = Items.Size();
+ if (Images.Size() == 1)
+ {
+ IndexOfUserImage = 0;
+ const CImage &image = Images[0];
+ if (!showImageNumber)
+ NumExcludededItems = image.NumEmptyRootItems;
+ }
+ }
+ else if ((unsigned)imageIndex < Images.Size())
+ {
+ const CImage &image = Images[imageIndex];
+ startItem = image.StartItem;
+ endItem = startItem + image.NumItems;
+ if (!showImageNumber)
+ NumExcludededItems = image.NumEmptyRootItems;
+ }
+
+ if (NumExcludededItems != 0)
+ {
+ ExludedItem = (int)startItem;
+ startItem += NumExcludededItems;
+ }
+
+ unsigned num = endItem - startItem;
+ SortedItems.ClearAndSetSize(num);
+ unsigned i;
+ for (i = 0; i < num; i++)
+ SortedItems[i] = startItem + i;
+
+ SortedItems.Sort(CompareItems, this);
+ for (i = 0; i < SortedItems.Size(); i++)
+ Items[SortedItems[i]].IndexInSorted = (int)i;
+
+ if (showImageNumber)
+ for (i = 0; i < Images.Size(); i++)
+ {
+ CImage &image = Images[i];
+ if (image.NumEmptyRootItems != 0)
+ continue;
+ image.VirtualRootIndex = (int)VirtualRoots.Size();
+ VirtualRoots.Add(i);
+ }
+
+ return S_OK;
+}
+
+
+static void IntVector_SetMinusOne_IfNeed(CIntVector &v, unsigned size)
+{
+ if (v.Size() == size)
+ return;
+ v.ClearAndSetSize(size);
+ int *vals = &v[0];
+ for (unsigned i = 0; i < size; i++)
+ vals[i] = -1;
+}
+
+
+HRESULT CDatabase::ExtractReparseStreams(const CObjectVector<CVolume> &volumes, IArchiveOpenCallback *openCallback)
+{
+ ItemToReparse.Clear();
+ ReparseItems.Clear();
+
+ // we don't know about Reparse field for OLD WIM format
+ if (IsOldVersion)
+ return S_OK;
+
+ CIntVector streamToReparse;
+ CUnpacker unpacker;
+ UInt64 totalPackedPrev = 0;
+
+ FOR_VECTOR(indexInSorted, SortedItems)
+ {
+ // we use sorted items for faster access
+ unsigned itemIndex = SortedItems[indexInSorted];
+ const CItem &item = Items[itemIndex];
+
+ if (!item.HasMetadata() || item.IsAltStream)
+ continue;
+
+ if (item.ImageIndex < 0)
+ continue;
+
+ const Byte *metadata = Images[item.ImageIndex].Meta + item.Offset;
+
+ const UInt32 attrib = Get32(metadata + 8);
+ if ((attrib & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
+ continue;
+
+ if (item.StreamIndex < 0)
+ continue; // it's ERROR
+
+ const CStreamInfo &si = DataStreams[item.StreamIndex];
+ if (si.Resource.UnpackSize >= (1 << 16))
+ continue; // reparse data can not be larger than 64 KB
+
+ IntVector_SetMinusOne_IfNeed(streamToReparse, DataStreams.Size());
+ IntVector_SetMinusOne_IfNeed(ItemToReparse, Items.Size());
+
+ const unsigned offset = 0x58; // we don't know about Reparse field for OLD WIM format
+ UInt32 tag = Get32(metadata + offset);
+ int reparseIndex = streamToReparse[item.StreamIndex];
+ CByteBuffer buf;
+
+ if (openCallback)
+ {
+ if ((unpacker.TotalPacked - totalPackedPrev) >= ((UInt32)1 << 16))
+ {
+ UInt64 numFiles = Items.Size();
+ RINOK(openCallback->SetCompleted(&numFiles, &unpacker.TotalPacked))
+ totalPackedPrev = unpacker.TotalPacked;
+ }
+ }
+
+ if (reparseIndex >= 0)
+ {
+ const CByteBuffer &reparse = ReparseItems[reparseIndex];
+ if (tag == Get32(reparse))
+ {
+ ItemToReparse[itemIndex] = reparseIndex;
+ continue;
+ }
+ buf = reparse;
+ // we support that strange and unusual situation with different tags and same reparse data.
+ }
+ else
+ {
+ /*
+ if (si.PartNumber >= volumes.Size())
+ continue;
+ */
+ const CVolume &vol = volumes[si.PartNumber];
+ /*
+ if (!vol.Stream)
+ continue;
+ */
+
+ Byte digest[kHashSize];
+ HRESULT res = unpacker.UnpackData(vol.Stream, si.Resource, vol.Header, this, buf, digest);
+
+ if (res == S_FALSE)
+ continue;
+
+ RINOK(res)
+
+ if (memcmp(digest, si.Hash, kHashSize) != 0
+ // && !(h.IsOldVersion() && IsEmptySha(si.Hash))
+ )
+ {
+ // setErrorStatus;
+ continue;
+ }
+ }
+
+ CByteBuffer &reparse = ReparseItems.AddNew();
+ reparse.Alloc(8 + buf.Size());
+ Byte *dest = (Byte *)reparse;
+ SetUi32(dest, tag)
+ SetUi32(dest + 4, (UInt32)buf.Size())
+ if (buf.Size() != 0)
+ memcpy(dest + 8, buf, buf.Size());
+ ItemToReparse[itemIndex] = (int)ReparseItems.Size() - 1;
+ }
+
+ return S_OK;
+}
+
+
+
+static bool ParseNumber64(const AString &s, UInt64 &res)
+{
+ const char *end;
+ if (s.IsPrefixedBy("0x"))
+ {
+ if (s.Len() == 2)
+ return false;
+ res = ConvertHexStringToUInt64(s.Ptr(2), &end);
+ }
+ else
+ {
+ if (s.IsEmpty())
+ return false;
+ res = ConvertStringToUInt64(s, &end);
+ }
+ return *end == 0;
+}
+
+
+static bool ParseNumber32(const AString &s, UInt32 &res)
+{
+ UInt64 res64;
+ if (!ParseNumber64(s, res64) || res64 >= ((UInt64)1 << 32))
+ return false;
+ res = (UInt32)res64;
+ return true;
+}
+
+
+static bool ParseTime(const CXmlItem &item, FILETIME &ft, const char *tag)
+{
+ int index = item.FindSubTag(tag);
+ if (index >= 0)
+ {
+ const CXmlItem &timeItem = item.SubItems[index];
+ UInt32 low = 0, high = 0;
+ if (ParseNumber32(timeItem.GetSubStringForTag("LOWPART"), low) &&
+ ParseNumber32(timeItem.GetSubStringForTag("HIGHPART"), high))
+ {
+ ft.dwLowDateTime = low;
+ ft.dwHighDateTime = high;
+ return true;
+ }
+ }
+ return false;
+}
+
+
+void CImageInfo::Parse(const CXmlItem &item)
+{
+ CTimeDefined = ParseTime(item, CTime, "CREATIONTIME");
+ MTimeDefined = ParseTime(item, MTime, "LASTMODIFICATIONTIME");
+ NameDefined = true;
+ ConvertUTF8ToUnicode(item.GetSubStringForTag("NAME"), Name);
+
+ ParseNumber64(item.GetSubStringForTag("DIRCOUNT"), DirCount);
+ ParseNumber64(item.GetSubStringForTag("FILECOUNT"), FileCount);
+ IndexDefined = ParseNumber32(item.GetPropVal("INDEX"), Index);
+}
+
+void CWimXml::ToUnicode(UString &s)
+{
+ size_t size = Data.Size();
+ if (size < 2 || (size & 1) != 0 || size > (1 << 24))
+ return;
+ const Byte *p = Data;
+ if (Get16(p) != 0xFEFF)
+ return;
+ wchar_t *chars = s.GetBuf((unsigned)(size / 2));
+ for (size_t i = 2; i < size; i += 2)
+ {
+ wchar_t c = Get16(p + i);
+ if (c == 0)
+ break;
+ *chars++ = c;
+ }
+ *chars = 0;
+ s.ReleaseBuf_SetLen((unsigned)(chars - (const wchar_t *)s));
+}
+
+
+bool CWimXml::Parse()
+{
+ IsEncrypted = false;
+ AString utf;
+ {
+ UString s;
+ ToUnicode(s);
+ // if (!ConvertUnicodeToUTF8(s, utf)) return false;
+ ConvertUnicodeToUTF8(s, utf);
+ }
+
+ if (!Xml.Parse(utf))
+ return false;
+ if (Xml.Root.Name != "WIM")
+ return false;
+
+ FOR_VECTOR (i, Xml.Root.SubItems)
+ {
+ const CXmlItem &item = Xml.Root.SubItems[i];
+
+ if (item.IsTagged("IMAGE"))
+ {
+ CImageInfo imageInfo;
+ imageInfo.Parse(item);
+ if (!imageInfo.IndexDefined)
+ return false;
+
+ if (imageInfo.Index != (UInt32)Images.Size() + 1)
+ {
+ // old wim (1.09) uses zero based image index
+ if (imageInfo.Index != (UInt32)Images.Size())
+ return false;
+ }
+
+ imageInfo.ItemIndexInXml = (int)i;
+ Images.Add(imageInfo);
+ }
+
+ if (item.IsTagged("ESD"))
+ {
+ FOR_VECTOR (k, item.SubItems)
+ {
+ const CXmlItem &item2 = item.SubItems[k];
+ if (item2.IsTagged("ENCRYPTED"))
+ IsEncrypted = true;
+ }
+ }
+ }
+
+ return true;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Wim/WimIn.h b/CPP/7zip/Archive/Wim/WimIn.h
new file mode 100644
index 0000000..3de8456
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/WimIn.h
@@ -0,0 +1,659 @@
+// Archive/WimIn.h
+
+#ifndef ZIP7_INC_ARCHIVE_WIM_IN_H
+#define ZIP7_INC_ARCHIVE_WIM_IN_H
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyXml.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Compress/CopyCoder.h"
+#include "../../Compress/LzmsDecoder.h"
+#include "../../Compress/LzxDecoder.h"
+
+#include "../IArchive.h"
+
+namespace NArchive {
+namespace NWim {
+
+/*
+WIM versions:
+hexVer : headerSize : ver
+ : 1.07.01 - 1.08.01 : Longhorn.4001-4015 - another header, no signature, CAB compression
+10900 : 60 : 1.09 : Longhorn.4029-4039 (2003)
+10A00 : 60 : 1.10 : Longhorn.4083 (2004) image starting from 1
+10B00 : ?? : 1.11 : ??
+10C00 : 74 : 1.12 : Longhorn.4093 - VistaBeta1.5112 (2005) - (Multi-Part, SHA1)
+10D00 : D0 : 1.13 : VistaBeta2 - Win10, (NumImages, BootIndex, IntegrityResource)
+00E00 : D0 : 0.14 : LZMS, solid, esd, dism
+*/
+
+const unsigned kDirRecordSizeOld = 62;
+const unsigned kDirRecordSize = 102;
+
+/*
+ There is error in WIM specification about dwReparseTag, dwReparseReserved and liHardLink fields.
+
+ Correct DIRENTRY structure:
+ {
+ hex offset
+ 0 UInt64 Len;
+ 8 UInt32 Attrib;
+ C UInt32 SecurityId;
+
+ 10 UInt64 SubdirOffset; // = 0 for files
+
+ 18 UInt64 unused1; // = 0?
+ 20 UInt64 unused2; // = 0?
+
+ 28 UInt64 CTime;
+ 30 UInt64 ATime;
+ 38 UInt64 MTime;
+
+ 40 Byte Sha1[20];
+
+ 54 UInt32 Unknown1; // is it 0 always?
+
+
+ union
+ {
+ 58 UInt64 NtNodeId;
+ {
+ 58 UInt32 ReparseTag;
+ 5C UInt32 ReparseFlags; // is it 0 always? Check with new imagex.
+ }
+ }
+
+ 60 UInt16 Streams;
+
+ 62 UInt16 ShortNameLen;
+ 64 UInt16 FileNameLen;
+
+ 66 UInt16 Name[];
+ UInt16 ShortName[];
+ }
+
+ // DIRENTRY for WIM_VERSION <= 1.10
+ DIRENTRY_OLD structure:
+ {
+ hex offset
+ 0 UInt64 Len;
+ 8 UInt32 Attrib;
+ C UInt32 SecurityId;
+
+ union
+ {
+ 10 UInt64 SubdirOffset; //
+
+ 10 UInt32 OldWimFileId; // used for files in old WIMs
+ 14 UInt32 OldWimFileId_Reserved; // = 0
+ }
+
+ 18 UInt64 CTime;
+ 20 UInt64 ATime;
+ 28 UInt64 MTime;
+
+ 30 UInt64 Unknown; // NtNodeId ?
+
+ 38 UInt16 Streams;
+ 3A UInt16 ShortNameLen;
+ 3C UInt16 FileNameLen;
+ 3E UInt16 FileName[];
+ UInt16 ShortName[];
+ }
+
+ ALT_STREAM structure:
+ {
+ hex offset
+ 0 UInt64 Len;
+ 8 UInt64 Unused;
+ 10 Byte Sha1[20];
+ 24 UInt16 FileNameLen;
+ 26 UInt16 FileName[];
+ }
+
+ ALT_STREAM_OLD structure:
+ {
+ hex offset
+ 0 UInt64 Len;
+ 8 UInt64 StreamId; // 32-bit value
+ 10 UInt16 FileNameLen;
+ 12 UInt16 FileName[];
+ }
+
+ If item is file (not Directory) and there are alternative streams,
+ there is additional ALT_STREAM item of main "unnamed" stream in Streams array.
+
+*/
+
+
+namespace NResourceFlags
+{
+ // const Byte kFree = 1 << 0;
+ const Byte kMetadata = 1 << 1;
+ const Byte kCompressed = 1 << 2;
+ // const Byte kSpanned = 1 << 3;
+ const Byte kSolid = 1 << 4;
+}
+
+const UInt64 k_SolidBig_Resource_Marker = (UInt64)1 << 32;
+
+struct CResource
+{
+ UInt64 PackSize;
+ UInt64 Offset;
+ UInt64 UnpackSize;
+ Byte Flags;
+ bool KeepSolid;
+ int SolidIndex;
+
+ void Clear()
+ {
+ PackSize = 0;
+ Offset = 0;
+ UnpackSize = 0;
+ Flags = 0;
+ KeepSolid = false;
+ SolidIndex = -1;
+ }
+
+ UInt64 GetEndLimit() const { return Offset + PackSize; }
+ void Parse(const Byte *p);
+ void ParseAndUpdatePhySize(const Byte *p, UInt64 &phySize)
+ {
+ Parse(p);
+ UInt64 v = GetEndLimit();
+ if (phySize < v)
+ phySize = v;
+ }
+
+ void WriteTo(Byte *p) const;
+
+ bool IsMetadata() const { return (Flags & NResourceFlags::kMetadata) != 0; }
+ bool IsCompressed() const { return (Flags & NResourceFlags::kCompressed) != 0; }
+ bool IsSolid() const { return (Flags & NResourceFlags::kSolid) != 0; }
+ bool IsSolidBig() const { return IsSolid() && UnpackSize == k_SolidBig_Resource_Marker; }
+ bool IsSolidSmall() const { return IsSolid() && UnpackSize == 0; }
+
+ bool IsEmpty() const { return (UnpackSize == 0); }
+};
+
+
+struct CSolid
+{
+ unsigned StreamIndex;
+ // unsigned NumRefs;
+ int FirstSmallStream;
+
+ UInt64 SolidOffset;
+
+ UInt64 UnpackSize;
+ int Method;
+ unsigned ChunkSizeBits;
+
+ UInt64 HeadersSize;
+ // size_t NumChunks;
+ CObjArray<UInt64> Chunks; // [NumChunks + 1] (start offset)
+
+ UInt64 GetChunkPackSize(size_t chunkIndex) const { return Chunks[chunkIndex + 1] - Chunks[chunkIndex]; }
+
+ CSolid():
+ FirstSmallStream(-1),
+ // NumRefs(0),
+ Method(-1)
+ {}
+};
+
+
+namespace NHeaderFlags
+{
+ const UInt32 kCompression = 1 << 1;
+ const UInt32 kReadOnly = 1 << 2;
+ const UInt32 kSpanned = 1 << 3;
+ const UInt32 kResourceOnly = 1 << 4;
+ const UInt32 kMetadataOnly = 1 << 5;
+ const UInt32 kWriteInProgress = 1 << 6;
+ const UInt32 kReparsePointFixup = 1 << 7;
+
+ const UInt32 kXPRESS = (UInt32)1 << 17;
+ const UInt32 kLZX = (UInt32)1 << 18;
+ const UInt32 kLZMS = (UInt32)1 << 19;
+ const UInt32 kXPRESS2 = (UInt32)1 << 21; // XPRESS with nonstandard chunk size ?
+
+ const UInt32 kMethodMask = 0xFFFE0000;
+}
+
+
+namespace NMethod
+{
+ const UInt32 kXPRESS = 1;
+ const UInt32 kLZX = 2;
+ const UInt32 kLZMS = 3;
+}
+
+
+const UInt32 k_Version_NonSolid = 0x10D00;
+const UInt32 k_Version_Solid = 0xE00;
+
+const unsigned kHeaderSizeMax = 0xD0;
+const unsigned kSignatureSize = 8;
+extern const Byte kSignature[kSignatureSize];
+
+const unsigned kChunkSizeBits = 15;
+const UInt32 kChunkSize = (UInt32)1 << kChunkSizeBits;
+
+
+struct CHeader
+{
+ UInt32 Version;
+ UInt32 Flags;
+ UInt32 ChunkSize;
+ unsigned ChunkSizeBits;
+ Byte Guid[16];
+ UInt16 PartNumber;
+ UInt16 NumParts;
+ UInt32 NumImages;
+ UInt32 BootIndex;
+
+ bool _isOldVersion; // 1.10-
+ bool _isNewVersion; // 1.13+ or 0.14
+
+ CResource OffsetResource;
+ CResource XmlResource;
+ CResource MetadataResource;
+ CResource IntegrityResource;
+
+ void SetDefaultFields(bool useLZX);
+
+ void WriteTo(Byte *p) const;
+ HRESULT Parse(const Byte *p, UInt64 &phySize);
+
+ bool IsCompressed() const { return (Flags & NHeaderFlags::kCompression) != 0; }
+
+ bool IsSupported() const
+ {
+ return (!IsCompressed()
+ || (Flags & NHeaderFlags::kLZX) != 0
+ || (Flags & NHeaderFlags::kXPRESS) != 0
+ || (Flags & NHeaderFlags::kLZMS) != 0
+ || (Flags & NHeaderFlags::kXPRESS2) != 0);
+ }
+
+ unsigned GetMethod() const
+ {
+ if (!IsCompressed())
+ return 0;
+ UInt32 mask = (Flags & NHeaderFlags::kMethodMask);
+ if (mask == 0) return 0;
+ if (mask == NHeaderFlags::kXPRESS) return NMethod::kXPRESS;
+ if (mask == NHeaderFlags::kLZX) return NMethod::kLZX;
+ if (mask == NHeaderFlags::kLZMS) return NMethod::kLZMS;
+ if (mask == NHeaderFlags::kXPRESS2) return NMethod::kXPRESS;
+ return mask;
+ }
+
+ bool IsOldVersion() const { return _isOldVersion; }
+ bool IsNewVersion() const { return _isNewVersion; }
+ bool IsSolidVersion() const { return (Version == k_Version_Solid); }
+
+ bool AreFromOnArchive(const CHeader &h)
+ {
+ return (memcmp(Guid, h.Guid, sizeof(Guid)) == 0) && (h.NumParts == NumParts);
+ }
+};
+
+
+const unsigned kHashSize = 20;
+
+inline bool IsEmptySha(const Byte *data)
+{
+ for (unsigned i = 0; i < kHashSize; i++)
+ if (data[i] != 0)
+ return false;
+ return true;
+}
+
+const unsigned kStreamInfoSize = 24 + 2 + 4 + kHashSize;
+
+struct CStreamInfo
+{
+ CResource Resource;
+ UInt16 PartNumber; // for NEW WIM format, we set it to 1 for OLD WIM format
+ UInt32 RefCount;
+ UInt32 Id; // for OLD WIM format
+ Byte Hash[kHashSize];
+
+ bool IsEmptyHash() const { return IsEmptySha(Hash); }
+
+ void WriteTo(Byte *p) const;
+};
+
+
+struct CItem
+{
+ size_t Offset;
+ int IndexInSorted;
+ int StreamIndex;
+ int Parent;
+ int ImageIndex; // -1 means that file is unreferenced in Images (deleted item?)
+ bool IsDir;
+ bool IsAltStream;
+
+ bool HasMetadata() const { return ImageIndex >= 0; }
+
+ CItem():
+ IndexInSorted(-1),
+ StreamIndex(-1),
+ Parent(-1),
+ IsDir(false),
+ IsAltStream(false)
+ {}
+};
+
+struct CImage
+{
+ CByteBuffer Meta;
+ CRecordVector<UInt32> SecurOffsets;
+ unsigned StartItem;
+ unsigned NumItems;
+ unsigned NumEmptyRootItems;
+ int VirtualRootIndex; // index in CDatabase::VirtualRoots[]
+ UString RootName;
+ CByteBuffer RootNameBuf;
+
+ CImage(): VirtualRootIndex(-1) {}
+};
+
+
+struct CImageInfo
+{
+ bool CTimeDefined;
+ bool MTimeDefined;
+ bool NameDefined;
+ bool IndexDefined;
+
+ FILETIME CTime;
+ FILETIME MTime;
+ UString Name;
+
+ UInt64 DirCount;
+ UInt64 FileCount;
+ UInt32 Index;
+
+ int ItemIndexInXml;
+
+ UInt64 GetTotalFilesAndDirs() const { return DirCount + FileCount; }
+
+ CImageInfo(): CTimeDefined(false), MTimeDefined(false), NameDefined(false),
+ IndexDefined(false), ItemIndexInXml(-1) {}
+ void Parse(const CXmlItem &item);
+};
+
+
+struct CWimXml
+{
+ CByteBuffer Data;
+ CXml Xml;
+
+ UInt16 VolIndex;
+ CObjectVector<CImageInfo> Images;
+
+ UString FileName;
+ bool IsEncrypted;
+
+ UInt64 GetTotalFilesAndDirs() const
+ {
+ UInt64 sum = 0;
+ FOR_VECTOR (i, Images)
+ sum += Images[i].GetTotalFilesAndDirs();
+ return sum;
+ }
+
+ void ToUnicode(UString &s);
+ bool Parse();
+
+ CWimXml(): IsEncrypted(false) {}
+};
+
+
+struct CVolume
+{
+ CHeader Header;
+ CMyComPtr<IInStream> Stream;
+};
+
+
+class CDatabase
+{
+ Byte *DirData;
+ size_t DirSize;
+ size_t DirProcessed;
+ size_t DirStartOffset;
+ IArchiveOpenCallback *OpenCallback;
+
+ HRESULT ParseDirItem(size_t pos, int parent);
+ HRESULT ParseImageDirs(CByteBuffer &buf, int parent);
+
+public:
+ CRecordVector<CStreamInfo> DataStreams;
+ CRecordVector<CStreamInfo> MetaStreams;
+
+ CObjectVector<CSolid> Solids;
+
+ CRecordVector<CItem> Items;
+ CObjectVector<CByteBuffer> ReparseItems;
+ CIntVector ItemToReparse; // from index_in_Items to index_in_ReparseItems
+ // -1 means no reparse;
+
+ CObjectVector<CImage> Images;
+
+ bool IsOldVersion9;
+ bool IsOldVersion;
+ bool ThereAreDeletedStreams;
+ bool ThereAreAltStreams;
+ bool RefCountError;
+ bool HeadersError;
+
+ unsigned GetStartImageIndex() const { return IsOldVersion9 ? 0 : 1; }
+ unsigned GetDirAlignMask() const { return IsOldVersion9 ? 3 : 7; }
+
+ // User Items can contain all images or just one image from all.
+ CUIntVector SortedItems;
+ int IndexOfUserImage; // -1 : if more than one images was filled to Sorted Items
+
+ unsigned NumExcludededItems;
+ int ExludedItem; // -1 : if there are no exclude items
+ CUIntVector VirtualRoots; // we use them for old 1.10 WIM archives
+
+ bool ThereIsError() const { return RefCountError || HeadersError; }
+
+ unsigned GetNumUserItemsInImage(unsigned imageIndex) const
+ {
+ if (IndexOfUserImage >= 0 && imageIndex != (unsigned)IndexOfUserImage)
+ return 0;
+ if (imageIndex >= Images.Size())
+ return 0;
+ return Images[imageIndex].NumItems - NumExcludededItems;
+ }
+
+ bool ItemHasStream(const CItem &item) const;
+
+ UInt64 Get_UnpackSize_of_Resource(const CResource &r) const
+ {
+ if (!r.IsSolid())
+ return r.UnpackSize;
+ if (r.IsSolidSmall())
+ return r.PackSize;
+ if (r.IsSolidBig() && r.SolidIndex >= 0)
+ return Solids[(unsigned)r.SolidIndex].UnpackSize;
+ return 0;
+ }
+
+ UInt64 Get_PackSize_of_Resource(unsigned streamIndex) const
+ {
+ const CResource &r = DataStreams[streamIndex].Resource;
+ if (!r.IsSolidSmall())
+ return r.PackSize;
+ if (r.SolidIndex >= 0)
+ {
+ const CSolid &ss = Solids[(unsigned)r.SolidIndex];
+ if (ss.FirstSmallStream == (int)streamIndex)
+ return DataStreams[ss.StreamIndex].Resource.PackSize;
+ }
+ return 0;
+ }
+
+ UInt64 GetUnpackSize() const
+ {
+ UInt64 res = 0;
+ FOR_VECTOR (i, DataStreams)
+ res += DataStreams[i].Resource.UnpackSize;
+ return res;
+ }
+
+ UInt64 GetPackSize() const
+ {
+ UInt64 res = 0;
+ FOR_VECTOR (i, DataStreams)
+ res += DataStreams[i].Resource.PackSize;
+ return res;
+ }
+
+ void Clear()
+ {
+ DataStreams.Clear();
+ MetaStreams.Clear();
+ Solids.Clear();
+
+ Items.Clear();
+ ReparseItems.Clear();
+ ItemToReparse.Clear();
+
+ SortedItems.Clear();
+
+ Images.Clear();
+ VirtualRoots.Clear();
+
+ IsOldVersion = false;
+ ThereAreDeletedStreams = false;
+ ThereAreAltStreams = false;
+ RefCountError = false;
+ HeadersError = false;
+ }
+
+ CDatabase():
+ RefCountError(false),
+ HeadersError(false)
+ {}
+
+ void GetShortName(unsigned index, NWindows::NCOM::CPropVariant &res) const;
+ void GetItemName(unsigned index1, NWindows::NCOM::CPropVariant &res) const;
+ void GetItemPath(unsigned index, bool showImageNumber, NWindows::NCOM::CPropVariant &res) const;
+
+ HRESULT OpenXml(IInStream *inStream, const CHeader &h, CByteBuffer &xml);
+ HRESULT Open(IInStream *inStream, const CHeader &h, unsigned numItemsReserve, IArchiveOpenCallback *openCallback);
+ HRESULT FillAndCheck(const CObjectVector<CVolume> &volumes);
+
+ /*
+ imageIndex showImageNumber NumImages
+ * true * Show Image_Number
+ -1 * >1 Show Image_Number
+ -1 false 1 Don't show Image_Number
+ N false * Don't show Image_Number
+ */
+ HRESULT GenerateSortedItems(int imageIndex, bool showImageNumber);
+
+ HRESULT ExtractReparseStreams(const CObjectVector<CVolume> &volumes, IArchiveOpenCallback *openCallback);
+};
+
+HRESULT ReadHeader(IInStream *inStream, CHeader &header, UInt64 &phySize);
+
+
+struct CMidBuf
+{
+ Byte *Data;
+ size_t _size;
+
+ CMidBuf(): Data(NULL), _size(0) {}
+
+ void EnsureCapacity(size_t size)
+ {
+ if (size > _size)
+ {
+ ::MidFree(Data);
+ _size = 0;
+ Data = (Byte *)::MidAlloc(size);
+ if (Data)
+ _size = size;
+ }
+ }
+
+ ~CMidBuf() { ::MidFree(Data); }
+};
+
+
+class CUnpacker
+{
+ NCompress::CCopyCoder *copyCoderSpec;
+ CMyComPtr<ICompressCoder> copyCoder;
+
+ NCompress::NLzx::CDecoder *lzxDecoderSpec;
+ CMyComPtr<IUnknown> lzxDecoder;
+
+ NCompress::NLzms::CDecoder *lzmsDecoder;
+
+ CByteBuffer sizesBuf;
+
+ CMidBuf packBuf;
+ CMidBuf unpackBuf;
+
+ // solid resource
+ int _solidIndex;
+ size_t _unpackedChunkIndex;
+
+ HRESULT UnpackChunk(
+ ISequentialInStream *inStream,
+ unsigned method, unsigned chunkSizeBits,
+ size_t inSize, size_t outSize,
+ ISequentialOutStream *outStream);
+
+ HRESULT Unpack2(
+ IInStream *inStream,
+ const CResource &res,
+ const CHeader &header,
+ const CDatabase *db,
+ ISequentialOutStream *outStream,
+ ICompressProgressInfo *progress);
+
+public:
+ UInt64 TotalPacked;
+
+ CUnpacker():
+ lzmsDecoder(NULL),
+ _solidIndex(-1),
+ _unpackedChunkIndex(0),
+ TotalPacked(0)
+ {}
+ ~CUnpacker();
+
+ HRESULT Unpack(
+ IInStream *inStream,
+ const CResource &res,
+ const CHeader &header,
+ const CDatabase *db,
+ ISequentialOutStream *outStream,
+ ICompressProgressInfo *progress,
+ Byte *digest);
+
+ HRESULT UnpackData(IInStream *inStream,
+ const CResource &resource, const CHeader &header,
+ const CDatabase *db,
+ CByteBuffer &buf, Byte *digest);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Wim/WimRegister.cpp b/CPP/7zip/Archive/Wim/WimRegister.cpp
new file mode 100644
index 0000000..e143f91
--- /dev/null
+++ b/CPP/7zip/Archive/Wim/WimRegister.cpp
@@ -0,0 +1,29 @@
+// WimRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "WimHandler.h"
+
+namespace NArchive {
+namespace NWim {
+
+REGISTER_ARC_IO(
+ "wim", "wim swm esd ppkg", NULL, 0xE6
+ , kSignature, 0
+ , NArcInfoFlags::kAltStreams
+ | NArcInfoFlags::kNtSecure
+ | NArcInfoFlags::kSymLinks
+ | NArcInfoFlags::kHardLinks
+ | NArcInfoFlags::kCTime
+ // | NArcInfoFlags::kCTime_Default
+ | NArcInfoFlags::kATime
+ // | NArcInfoFlags::kATime_Default
+ | NArcInfoFlags::kMTime
+ | NArcInfoFlags::kMTime_Default
+ , TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kWindows)
+ | TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT (NFileTimeType::kWindows)
+ , NULL)
+
+}}
diff --git a/CPP/7zip/Archive/XarHandler.cpp b/CPP/7zip/Archive/XarHandler.cpp
new file mode 100644
index 0000000..c03128f
--- /dev/null
+++ b/CPP/7zip/Archive/XarHandler.cpp
@@ -0,0 +1,730 @@
+// XarHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/MyXml.h"
+#include "../../Common/StringToInt.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/BZip2Decoder.h"
+#include "../Compress/CopyCoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+#include "Common/OutStreamWithSha1.h"
+
+using namespace NWindows;
+
+#define XAR_SHOW_RAW
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+#define Get64(p) GetBe64(p)
+
+namespace NArchive {
+namespace NXar {
+
+static const size_t kXmlSizeMax = ((size_t )1 << 30) - (1 << 14);
+static const size_t kXmlPackSizeMax = kXmlSizeMax;
+
+/*
+#define XAR_CKSUM_NONE 0
+#define XAR_CKSUM_SHA1 1
+#define XAR_CKSUM_MD5 2
+
+static const char * const k_ChecksumAlgos[] =
+{
+ "None"
+ , "SHA-1"
+ , "MD5"
+};
+*/
+
+#define METHOD_NAME_ZLIB "zlib"
+
+
+struct CFile
+{
+ AString Name;
+ AString Method;
+ UInt64 Size;
+ UInt64 PackSize;
+ UInt64 Offset;
+
+ UInt64 CTime;
+ UInt64 MTime;
+ UInt64 ATime;
+ UInt32 Mode;
+
+ AString User;
+ AString Group;
+
+ bool IsDir;
+ bool HasData;
+ bool ModeDefined;
+ bool Sha1IsDefined;
+ // bool packSha1IsDefined;
+
+ Byte Sha1[SHA1_DIGEST_SIZE];
+ // Byte packSha1[SHA1_DIGEST_SIZE];
+
+ int Parent;
+
+ CFile():
+ Size(0), PackSize(0), Offset(0),
+ CTime(0), MTime(0), ATime(0), Mode(0),
+ IsDir(false), HasData(false), ModeDefined(false), Sha1IsDefined(false),
+ /* packSha1IsDefined(false), */
+ Parent(-1)
+ {}
+
+ bool IsCopyMethod() const
+ {
+ return Method.IsEmpty() || Method == "octet-stream";
+ }
+
+ void UpdateTotalPackSize(UInt64 &totalSize) const
+ {
+ UInt64 t = Offset + PackSize;
+ if (totalSize < t)
+ totalSize = t;
+ }
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+ UInt64 _dataStartPos;
+ CMyComPtr<IInStream> _inStream;
+ CByteArr _xml;
+ size_t _xmlLen;
+ CObjectVector<CFile> _files;
+ // UInt32 _checkSumAlgo;
+ UInt64 _phySize;
+ Int32 _mainSubfile;
+ bool _is_pkg;
+
+ HRESULT Open2(IInStream *stream);
+ HRESULT Extract(IInStream *stream);
+};
+
+static const Byte kArcProps[] =
+{
+ kpidSubType,
+ kpidHeadersSize
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidPosixAttrib,
+ kpidUser,
+ kpidGroup,
+ kpidMethod
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+#define PARSE_NUM(_num_, _dest_) \
+ { const char *end; _dest_ = ConvertStringToUInt32(p, &end); \
+ if ((unsigned)(end - p) != _num_) return 0; \
+ p += _num_ + 1; }
+
+static bool ParseUInt64(const CXmlItem &item, const char *name, UInt64 &res)
+{
+ const AString s (item.GetSubStringForTag(name));
+ if (s.IsEmpty())
+ return false;
+ const char *end;
+ res = ConvertStringToUInt64(s, &end);
+ return *end == 0;
+}
+
+static UInt64 ParseTime(const CXmlItem &item, const char *name)
+{
+ const AString s (item.GetSubStringForTag(name));
+ if (s.Len() < 20)
+ return 0;
+ const char *p = s;
+ if (p[ 4] != '-' || p[ 7] != '-' || p[10] != 'T' ||
+ p[13] != ':' || p[16] != ':' || p[19] != 'Z')
+ return 0;
+ UInt32 year, month, day, hour, min, sec;
+ PARSE_NUM(4, year)
+ PARSE_NUM(2, month)
+ PARSE_NUM(2, day)
+ PARSE_NUM(2, hour)
+ PARSE_NUM(2, min)
+ PARSE_NUM(2, sec)
+
+ UInt64 numSecs;
+ if (!NTime::GetSecondsSince1601(year, month, day, hour, min, sec, numSecs))
+ return 0;
+ return numSecs * 10000000;
+}
+
+static int HexToByte(char c)
+{
+ if (c >= '0' && c <= '9') return c - '0';
+ if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+ if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+ return -1;
+}
+
+static bool ParseSha1(const CXmlItem &item, const char *name, Byte *digest)
+{
+ const int index = item.FindSubTag(name);
+ if (index < 0)
+ return false;
+ const CXmlItem &checkItem = item.SubItems[index];
+ const AString style (checkItem.GetPropVal("style"));
+ if (style == "SHA1")
+ {
+ const AString s (checkItem.GetSubString());
+ if (s.Len() != SHA1_DIGEST_SIZE * 2)
+ return false;
+ for (unsigned i = 0; i < s.Len(); i += 2)
+ {
+ const int b0 = HexToByte(s[i]);
+ const int b1 = HexToByte(s[i + 1]);
+ if (b0 < 0 || b1 < 0)
+ return false;
+ digest[i / 2] = (Byte)((b0 << 4) | b1);
+ }
+ return true;
+ }
+ return false;
+}
+
+static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int parent)
+{
+ if (!item.IsTag)
+ return true;
+ if (item.Name == "file")
+ {
+ CFile file;
+ file.Parent = parent;
+ parent = (int)files.Size();
+ file.Name = item.GetSubStringForTag("name");
+ const AString type (item.GetSubStringForTag("type"));
+ if (type == "directory")
+ file.IsDir = true;
+ else if (type == "file")
+ file.IsDir = false;
+ else
+ return false;
+
+ int dataIndex = item.FindSubTag("data");
+ if (dataIndex >= 0 && !file.IsDir)
+ {
+ file.HasData = true;
+ const CXmlItem &dataItem = item.SubItems[dataIndex];
+ if (!ParseUInt64(dataItem, "size", file.Size))
+ return false;
+ if (!ParseUInt64(dataItem, "length", file.PackSize))
+ return false;
+ if (!ParseUInt64(dataItem, "offset", file.Offset))
+ return false;
+ file.Sha1IsDefined = ParseSha1(dataItem, "extracted-checksum", file.Sha1);
+ // file.packSha1IsDefined = ParseSha1(dataItem, "archived-checksum", file.packSha1);
+ int encodingIndex = dataItem.FindSubTag("encoding");
+ if (encodingIndex >= 0)
+ {
+ const CXmlItem &encodingItem = dataItem.SubItems[encodingIndex];
+ if (encodingItem.IsTag)
+ {
+ AString s (encodingItem.GetPropVal("style"));
+ if (!s.IsEmpty())
+ {
+ const AString appl ("application/");
+ if (s.IsPrefixedBy(appl))
+ {
+ s.DeleteFrontal(appl.Len());
+ const AString xx ("x-");
+ if (s.IsPrefixedBy(xx))
+ {
+ s.DeleteFrontal(xx.Len());
+ if (s == "gzip")
+ s = METHOD_NAME_ZLIB;
+ }
+ }
+ file.Method = s;
+ }
+ }
+ }
+ }
+
+ file.CTime = ParseTime(item, "ctime");
+ file.MTime = ParseTime(item, "mtime");
+ file.ATime = ParseTime(item, "atime");
+
+ {
+ const AString s (item.GetSubStringForTag("mode"));
+ if (s[0] == '0')
+ {
+ const char *end;
+ file.Mode = ConvertOctStringToUInt32(s, &end);
+ file.ModeDefined = (*end == 0);
+ }
+ }
+
+ file.User = item.GetSubStringForTag("user");
+ file.Group = item.GetSubStringForTag("group");
+
+ files.Add(file);
+ }
+ FOR_VECTOR (i, item.SubItems)
+ if (!AddItem(item.SubItems[i], files, parent))
+ return false;
+ return true;
+}
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+ const UInt32 kHeaderSize = 0x1C;
+ Byte buf[kHeaderSize];
+ RINOK(ReadStream_FALSE(stream, buf, kHeaderSize))
+ UInt32 size = Get16(buf + 4);
+ // UInt32 ver = Get16(buf + 6); // == 1
+ if (Get32(buf) != 0x78617221 || size != kHeaderSize)
+ return S_FALSE;
+
+ UInt64 packSize = Get64(buf + 8);
+ UInt64 unpackSize = Get64(buf + 0x10);
+
+ // _checkSumAlgo = Get32(buf + 0x18);
+
+ if (packSize >= kXmlPackSizeMax ||
+ unpackSize >= kXmlSizeMax)
+ return S_FALSE;
+
+ _dataStartPos = kHeaderSize + packSize;
+ _phySize = _dataStartPos;
+
+ _xml.Alloc((size_t)unpackSize + 1);
+ _xmlLen = (size_t)unpackSize;
+
+ NCompress::NZlib::CDecoder *zlibCoderSpec = new NCompress::NZlib::CDecoder();
+ CMyComPtr<ICompressCoder> zlibCoder = zlibCoderSpec;
+
+ CLimitedSequentialInStream *inStreamLimSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStreamLim(inStreamLimSpec);
+ inStreamLimSpec->SetStream(stream);
+ inStreamLimSpec->Init(packSize);
+
+ CBufPtrSeqOutStream *outStreamLimSpec = new CBufPtrSeqOutStream;
+ CMyComPtr<ISequentialOutStream> outStreamLim(outStreamLimSpec);
+ outStreamLimSpec->Init(_xml, (size_t)unpackSize);
+
+ RINOK(zlibCoder->Code(inStreamLim, outStreamLim, NULL, NULL, NULL))
+
+ if (outStreamLimSpec->GetPos() != (size_t)unpackSize)
+ return S_FALSE;
+
+ _xml[(size_t)unpackSize] = 0;
+ if (strlen((const char *)(const Byte *)_xml) != unpackSize) return S_FALSE;
+
+ CXml xml;
+ if (!xml.Parse((const char *)(const Byte *)_xml))
+ return S_FALSE;
+
+ if (!xml.Root.IsTagged("xar") || xml.Root.SubItems.Size() != 1)
+ return S_FALSE;
+ const CXmlItem &toc = xml.Root.SubItems[0];
+ if (!toc.IsTagged("toc"))
+ return S_FALSE;
+ if (!AddItem(toc, _files, -1))
+ return S_FALSE;
+
+ UInt64 totalPackSize = 0;
+ unsigned numMainFiles = 0;
+
+ FOR_VECTOR (i, _files)
+ {
+ const CFile &file = _files[i];
+ file.UpdateTotalPackSize(totalPackSize);
+ if (file.Name == "Payload" || file.Name == "Content")
+ {
+ _mainSubfile = (Int32)(int)i;
+ numMainFiles++;
+ }
+ else if (file.Name == "PackageInfo")
+ _is_pkg = true;
+ }
+
+ if (numMainFiles > 1)
+ _mainSubfile = -1;
+
+ _phySize = _dataStartPos + totalPackSize;
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ if (Open2(stream) != S_OK)
+ return S_FALSE;
+ _inStream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _phySize = 0;
+ _inStream.Release();
+ _files.Clear();
+ _xmlLen = 0;
+ _xml.Free();
+ _mainSubfile = -1;
+ _is_pkg = false;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _files.Size()
+ #ifdef XAR_SHOW_RAW
+ + 1
+ #endif
+ ;
+ return S_OK;
+}
+
+static void TimeToProp(UInt64 t, NCOM::CPropVariant &prop)
+{
+ if (t != 0)
+ {
+ FILETIME ft;
+ ft.dwLowDateTime = (UInt32)(t);
+ ft.dwHighDateTime = (UInt32)(t >> 32);
+ prop = ft;
+ }
+}
+
+static void Utf8StringToProp(const AString &s, NCOM::CPropVariant &prop)
+{
+ if (!s.IsEmpty())
+ {
+ UString us;
+ ConvertUTF8ToUnicode(s, us);
+ prop = us;
+ }
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidHeadersSize: prop = _dataStartPos; break;
+ case kpidPhySize: prop = _phySize; break;
+ case kpidMainSubfile: if (_mainSubfile >= 0) prop = (UInt32)_mainSubfile; break;
+ case kpidSubType: if (_is_pkg) prop = "pkg"; break;
+ case kpidExtension: prop = _is_pkg ? "pkg" : "xar"; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ #ifdef XAR_SHOW_RAW
+ if (index == _files.Size())
+ {
+ switch (propID)
+ {
+ case kpidPath: prop = "[TOC].xml"; break;
+ case kpidSize:
+ case kpidPackSize: prop = (UInt64)_xmlLen; break;
+ }
+ }
+ else
+ #endif
+ {
+ const CFile &item = _files[index];
+ switch (propID)
+ {
+ case kpidMethod: Utf8StringToProp(item.Method, prop); break;
+
+ case kpidPath:
+ {
+ AString path;
+ unsigned cur = index;
+ for (;;)
+ {
+ const CFile &item2 = _files[cur];
+ if (!path.IsEmpty())
+ path.InsertAtFront(CHAR_PATH_SEPARATOR);
+ if (item2.Name.IsEmpty())
+ path.Insert(0, "unknown");
+ else
+ path.Insert(0, item2.Name);
+ cur = (unsigned)item2.Parent;
+ if (item2.Parent < 0)
+ break;
+ }
+
+ Utf8StringToProp(path, prop);
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir; break;
+ case kpidSize: if (!item.IsDir) prop = item.Size; break;
+ case kpidPackSize: if (!item.IsDir) prop = item.PackSize; break;
+
+ case kpidMTime: TimeToProp(item.MTime, prop); break;
+ case kpidCTime: TimeToProp(item.CTime, prop); break;
+ case kpidATime: TimeToProp(item.ATime, prop); break;
+ case kpidPosixAttrib:
+ if (item.ModeDefined)
+ {
+ UInt32 mode = item.Mode;
+ if ((mode & MY_LIN_S_IFMT) == 0)
+ mode |= (item.IsDir ? MY_LIN_S_IFDIR : MY_LIN_S_IFREG);
+ prop = mode;
+ }
+ break;
+ case kpidUser: Utf8StringToProp(item.User, prop); break;
+ case kpidGroup: Utf8StringToProp(item.Group, prop); break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _files.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ UInt32 index = (allFilesMode ? i : indices[i]);
+ #ifdef XAR_SHOW_RAW
+ if (index == _files.Size())
+ totalSize += _xmlLen;
+ else
+ #endif
+ totalSize += _files[index].Size;
+ }
+ extractCallback->SetTotal(totalSize);
+
+ UInt64 currentPackTotal = 0;
+ UInt64 currentUnpTotal = 0;
+ UInt64 currentPackSize = 0;
+ UInt64 currentUnpSize = 0;
+
+ const UInt32 kZeroBufSize = (1 << 14);
+ CByteBuffer zeroBuf(kZeroBufSize);
+ memset(zeroBuf, 0, kZeroBufSize);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ NCompress::NZlib::CDecoder *zlibCoderSpec = new NCompress::NZlib::CDecoder();
+ CMyComPtr<ICompressCoder> zlibCoder = zlibCoderSpec;
+
+ NCompress::NBZip2::CDecoder *bzip2CoderSpec = new NCompress::NBZip2::CDecoder();
+ CMyComPtr<ICompressCoder> bzip2Coder = bzip2CoderSpec;
+
+ NCompress::NDeflate::NDecoder::CCOMCoder *deflateCoderSpec = new NCompress::NDeflate::NDecoder::CCOMCoder();
+ CMyComPtr<ICompressCoder> deflateCoder = deflateCoderSpec;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *inStreamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(inStreamSpec);
+ inStreamSpec->SetStream(_inStream);
+
+
+ CLimitedSequentialOutStream *outStreamLimSpec = new CLimitedSequentialOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamLimSpec);
+
+ COutStreamWithSha1 *outStreamSha1Spec = new COutStreamWithSha1;
+ {
+ CMyComPtr<ISequentialOutStream> outStreamSha1(outStreamSha1Spec);
+ outStreamLimSpec->SetStream(outStreamSha1);
+ }
+
+ for (i = 0; i < numItems; i++, currentPackTotal += currentPackSize, currentUnpTotal += currentUnpSize)
+ {
+ lps->InSize = currentPackTotal;
+ lps->OutSize = currentUnpTotal;
+ currentPackSize = 0;
+ currentUnpSize = 0;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (index < _files.Size())
+ {
+ const CFile &item = _files[index];
+ if (item.IsDir)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ continue;
+ }
+ }
+
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ outStreamSha1Spec->SetStream(realOutStream);
+ realOutStream.Release();
+
+ Int32 opRes = NExtract::NOperationResult::kOK;
+ #ifdef XAR_SHOW_RAW
+ if (index == _files.Size())
+ {
+ outStreamSha1Spec->Init(false);
+ outStreamLimSpec->Init(_xmlLen);
+ RINOK(WriteStream(outStream, _xml, _xmlLen))
+ currentPackSize = currentUnpSize = _xmlLen;
+ }
+ else
+ #endif
+ {
+ const CFile &item = _files[index];
+ if (item.HasData)
+ {
+ currentPackSize = item.PackSize;
+ currentUnpSize = item.Size;
+
+ RINOK(InStream_SeekSet(_inStream, _dataStartPos + item.Offset))
+ inStreamSpec->Init(item.PackSize);
+ outStreamSha1Spec->Init(item.Sha1IsDefined);
+ outStreamLimSpec->Init(item.Size);
+ HRESULT res = S_OK;
+
+ ICompressCoder *coder = NULL;
+ if (item.IsCopyMethod())
+ if (item.PackSize == item.Size)
+ coder = copyCoder;
+ else
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (item.Method == METHOD_NAME_ZLIB)
+ coder = zlibCoder;
+ else if (item.Method == "bzip2")
+ coder = bzip2Coder;
+ else
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+
+ if (coder)
+ res = coder->Code(inStream, outStream, NULL, NULL, progress);
+
+ if (res != S_OK)
+ {
+ if (!outStreamLimSpec->IsFinishedOK())
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (res != S_FALSE)
+ return res;
+ if (opRes == NExtract::NOperationResult::kOK)
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+
+ if (opRes == NExtract::NOperationResult::kOK)
+ {
+ if (outStreamLimSpec->IsFinishedOK() &&
+ outStreamSha1Spec->GetSize() == item.Size)
+ {
+ if (!outStreamLimSpec->IsFinishedOK())
+ {
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+ else if (item.Sha1IsDefined)
+ {
+ Byte digest[SHA1_DIGEST_SIZE];
+ outStreamSha1Spec->Final(digest);
+ if (memcmp(digest, item.Sha1, SHA1_DIGEST_SIZE) != 0)
+ opRes = NExtract::NOperationResult::kCRCError;
+ }
+ }
+ else
+ opRes = NExtract::NOperationResult::kDataError;
+ }
+ }
+ }
+ outStreamSha1Spec->ReleaseStream();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ *stream = NULL;
+ COM_TRY_BEGIN
+ #ifdef XAR_SHOW_RAW
+ if (index == _files.Size())
+ {
+ Create_BufInStream_WithNewBuffer(_xml, _xmlLen, stream);
+ return S_OK;
+ }
+ else
+ #endif
+ {
+ const CFile &item = _files[index];
+ if (item.HasData && item.IsCopyMethod() && item.PackSize == item.Size)
+ return CreateLimitedInStream(_inStream, _dataStartPos + item.Offset, item.Size, stream);
+ }
+ return S_FALSE;
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { 'x', 'a', 'r', '!', 0, 0x1C };
+
+REGISTER_ARC_I(
+ "Xar", "xar pkg xip", NULL, 0xE1,
+ k_Signature,
+ 0,
+ 0,
+ NULL)
+
+}}
diff --git a/CPP/7zip/Archive/XzHandler.cpp b/CPP/7zip/Archive/XzHandler.cpp
index 743271a..976817c 100644
--- a/CPP/7zip/Archive/XzHandler.cpp
+++ b/CPP/7zip/Archive/XzHandler.cpp
@@ -1,1308 +1,1443 @@
-// XzHandler.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../../Common/ComTry.h"
-#include "../../Common/Defs.h"
-#include "../../Common/IntToString.h"
-#include "../../Common/MyBuffer.h"
-#include "../../Common/StringToInt.h"
-
-#include "../../Windows/PropVariant.h"
-#include "../../Windows/System.h"
-
-#include "../Common/CWrappers.h"
-#include "../Common/ProgressUtils.h"
-#include "../Common/RegisterArc.h"
-#include "../Common/StreamUtils.h"
-
-#include "../Compress/CopyCoder.h"
-#include "../Compress/XzDecoder.h"
-#include "../Compress/XzEncoder.h"
-
-#include "IArchive.h"
-
-#include "Common/HandlerOut.h"
-
-using namespace NWindows;
-
-namespace NArchive {
-namespace NXz {
-
-#define k_LZMA2_Name "LZMA2"
-
-
-struct CBlockInfo
-{
- unsigned StreamFlags;
- UInt64 PackPos;
- UInt64 PackSize; // pure value from Index record, it doesn't include pad zeros
- UInt64 UnpackPos;
-};
-
-
-class CHandler:
- public IInArchive,
- public IArchiveOpenSeq,
- public IInArchiveGetStream,
- public ISetProperties,
-
- #ifndef EXTRACT_ONLY
- public IOutArchive,
- #endif
-
- public CMyUnknownImp,
-
- #ifndef EXTRACT_ONLY
- public CMultiMethodProps
- #else
- public CCommonMethodProps
- #endif
-{
- CXzStatInfo _stat;
- SRes MainDecodeSRes;
-
- bool _isArc;
- bool _needSeekToStart;
- bool _phySize_Defined;
- bool _firstBlockWasRead;
-
- AString _methodsString;
-
- #ifndef EXTRACT_ONLY
-
- UInt32 _filterId;
-
- UInt64 _numSolidBytes;
-
- void InitXz()
- {
- _filterId = 0;
- _numSolidBytes = XZ_PROPS__BLOCK_SIZE__AUTO;
- }
-
- #endif
-
- void Init()
- {
- #ifndef EXTRACT_ONLY
- InitXz();
- CMultiMethodProps::Init();
- #else
- CCommonMethodProps::InitCommon();
- #endif
- }
-
- HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
-
- HRESULT Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCallback *callback);
-
- HRESULT Decode(NCompress::NXz::CDecoder &decoder,
- ISequentialInStream *seqInStream,
- ISequentialOutStream *outStream,
- ICompressProgressInfo *progress)
- {
- #ifndef _7ZIP_ST
- decoder._numThreads = _numThreads;
- #endif
- decoder._memUsage = _memUsage;
-
- MainDecodeSRes = SZ_OK;
-
- RINOK(decoder.Decode(seqInStream, outStream,
- NULL, // *outSizeLimit
- true, // finishStream
- progress));
-
- _stat = decoder.Stat;
- MainDecodeSRes = decoder.MainDecodeSRes;
-
- _phySize_Defined = true;
- return S_OK;
- }
-
-public:
- MY_QUERYINTERFACE_BEGIN2(IInArchive)
- MY_QUERYINTERFACE_ENTRY(IArchiveOpenSeq)
- MY_QUERYINTERFACE_ENTRY(IInArchiveGetStream)
- MY_QUERYINTERFACE_ENTRY(ISetProperties)
- #ifndef EXTRACT_ONLY
- MY_QUERYINTERFACE_ENTRY(IOutArchive)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- INTERFACE_IInArchive(;)
- STDMETHOD(OpenSeq)(ISequentialInStream *stream);
- STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
- STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
-
- #ifndef EXTRACT_ONLY
- INTERFACE_IOutArchive(;)
- #endif
-
- size_t _blocksArraySize;
- CBlockInfo *_blocks;
- UInt64 _maxBlocksSize;
- CMyComPtr<IInStream> _stream;
- CMyComPtr<ISequentialInStream> _seqStream;
-
- CXzBlock _firstBlock;
-
- CHandler();
- ~CHandler();
-
- HRESULT SeekToPackPos(UInt64 pos)
- {
- return _stream->Seek(pos, STREAM_SEEK_SET, NULL);
- }
-};
-
-
-CHandler::CHandler():
- _blocks(NULL),
- _blocksArraySize(0)
-{
- #ifndef EXTRACT_ONLY
- InitXz();
- #endif
-}
-
-CHandler::~CHandler()
-{
- MyFree(_blocks);
-}
-
-
-static const Byte kProps[] =
-{
- kpidSize,
- kpidPackSize,
- kpidMethod
-};
-
-static const Byte kArcProps[] =
-{
- kpidMethod,
- kpidNumStreams,
- kpidNumBlocks,
- kpidClusterSize,
- kpidCharacts
-};
-
-IMP_IInArchive_Props
-IMP_IInArchive_ArcProps
-
-static inline char GetHex(unsigned value)
-{
- return (char)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
-}
-
-static inline void AddHexToString(AString &s, Byte value)
-{
- s += GetHex(value >> 4);
- s += GetHex(value & 0xF);
-}
-
-static void Lzma2PropToString(AString &s, unsigned prop)
-{
- char c = 0;
- UInt32 size;
- if ((prop & 1) == 0)
- size = prop / 2 + 12;
- else
- {
- c = 'k';
- size = (UInt32)(2 | (prop & 1)) << (prop / 2 + 1);
- if (prop > 17)
- {
- size >>= 10;
- c = 'm';
- }
- }
- s.Add_UInt32(size);
- if (c != 0)
- s += c;
-}
-
-struct CMethodNamePair
-{
- UInt32 Id;
- const char *Name;
-};
-
-static const CMethodNamePair g_NamePairs[] =
-{
- { XZ_ID_Subblock, "SB" },
- { XZ_ID_Delta, "Delta" },
- { XZ_ID_X86, "BCJ" },
- { XZ_ID_PPC, "PPC" },
- { XZ_ID_IA64, "IA64" },
- { XZ_ID_ARM, "ARM" },
- { XZ_ID_ARMT, "ARMT" },
- { XZ_ID_SPARC, "SPARC" },
- { XZ_ID_LZMA2, "LZMA2" }
-};
-
-static void AddMethodString(AString &s, const CXzFilter &f)
-{
- const char *p = NULL;
- for (unsigned i = 0; i < ARRAY_SIZE(g_NamePairs); i++)
- if (g_NamePairs[i].Id == f.id)
- {
- p = g_NamePairs[i].Name;
- break;
- }
- char temp[32];
- if (!p)
- {
- ::ConvertUInt64ToString(f.id, temp);
- p = temp;
- }
-
- s += p;
-
- if (f.propsSize > 0)
- {
- s += ':';
- if (f.id == XZ_ID_LZMA2 && f.propsSize == 1)
- Lzma2PropToString(s, f.props[0]);
- else if (f.id == XZ_ID_Delta && f.propsSize == 1)
- s.Add_UInt32((UInt32)f.props[0] + 1);
- else
- {
- s += '[';
- for (UInt32 bi = 0; bi < f.propsSize; bi++)
- AddHexToString(s, f.props[bi]);
- s += ']';
- }
- }
-}
-
-static const char * const kChecks[] =
-{
- "NoCheck"
- , "CRC32"
- , NULL
- , NULL
- , "CRC64"
- , NULL
- , NULL
- , NULL
- , NULL
- , NULL
- , "SHA256"
- , NULL
- , NULL
- , NULL
- , NULL
- , NULL
-};
-
-static void AddCheckString(AString &s, const CXzs &xzs)
-{
- size_t i;
- UInt32 mask = 0;
- for (i = 0; i < xzs.num; i++)
- mask |= ((UInt32)1 << XzFlags_GetCheckType(xzs.streams[i].flags));
- for (i = 0; i <= XZ_CHECK_MASK; i++)
- if (((mask >> i) & 1) != 0)
- {
- s.Add_Space_if_NotEmpty();
- if (kChecks[i])
- s += kChecks[i];
- else
- {
- s += "Check-";
- s.Add_UInt32((UInt32)i);
- }
- }
-}
-
-STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
-{
- COM_TRY_BEGIN
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidPhySize: if (_phySize_Defined) prop = _stat.InSize; break;
- case kpidNumStreams: if (_stat.NumStreams_Defined) prop = _stat.NumStreams; break;
- case kpidNumBlocks: if (_stat.NumBlocks_Defined) prop = _stat.NumBlocks; break;
- case kpidUnpackSize: if (_stat.UnpackSize_Defined) prop = _stat.OutSize; break;
- case kpidClusterSize: if (_stat.NumBlocks_Defined && _stat.NumBlocks > 1) prop = _maxBlocksSize; break;
- case kpidCharacts:
- if (_firstBlockWasRead)
- {
- AString s;
- if (XzBlock_HasPackSize(&_firstBlock))
- s.Add_OptSpaced("BlockPackSize");
- if (XzBlock_HasUnpackSize(&_firstBlock))
- s.Add_OptSpaced("BlockUnpackSize");
- if (!s.IsEmpty())
- prop = s;
- }
- break;
-
-
- case kpidMethod: if (!_methodsString.IsEmpty()) prop = _methodsString; break;
- case kpidErrorFlags:
- {
- UInt32 v = 0;
- SRes sres = MainDecodeSRes; // _stat.DecodeRes2; //
- if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
- if (/*_stat.UnexpectedEnd */ sres == SZ_ERROR_INPUT_EOF) v |= kpv_ErrorFlags_UnexpectedEnd;
- if (_stat.DataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
- if (/* _stat.HeadersError */ sres == SZ_ERROR_ARCHIVE) v |= kpv_ErrorFlags_HeadersError;
- if (/* _stat.Unsupported */ sres == SZ_ERROR_UNSUPPORTED) v |= kpv_ErrorFlags_UnsupportedMethod;
- if (/* _stat.DataError */ sres == SZ_ERROR_DATA) v |= kpv_ErrorFlags_DataError;
- if (/* _stat.CrcError */ sres == SZ_ERROR_CRC) v |= kpv_ErrorFlags_CrcError;
- if (v != 0)
- prop = v;
- break;
- }
-
- case kpidMainSubfile:
- {
- // debug only, comment it:
- // if (_blocks) prop = (UInt32)0;
- break;
- }
- }
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
-{
- *numItems = 1;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetProperty(UInt32, PROPID propID, PROPVARIANT *value)
-{
- COM_TRY_BEGIN
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidSize: if (_stat.UnpackSize_Defined) prop = _stat.OutSize; break;
- case kpidPackSize: if (_phySize_Defined) prop = _stat.InSize; break;
- case kpidMethod: if (!_methodsString.IsEmpty()) prop = _methodsString; break;
- }
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
-}
-
-
-struct COpenCallbackWrap
-{
- ICompressProgress vt;
- IArchiveOpenCallback *OpenCallback;
- HRESULT Res;
- COpenCallbackWrap(IArchiveOpenCallback *progress);
-};
-
-static SRes OpenCallbackProgress(const ICompressProgress *pp, UInt64 inSize, UInt64 /* outSize */)
-{
- COpenCallbackWrap *p = CONTAINER_FROM_VTBL(pp, COpenCallbackWrap, vt);
- if (p->OpenCallback)
- p->Res = p->OpenCallback->SetCompleted(NULL, &inSize);
- return HRESULT_To_SRes(p->Res, SZ_ERROR_PROGRESS);
-}
-
-COpenCallbackWrap::COpenCallbackWrap(IArchiveOpenCallback *callback)
-{
- vt.Progress = OpenCallbackProgress;
- OpenCallback = callback;
- Res = SZ_OK;
-}
-
-
-struct CXzsCPP
-{
- CXzs p;
- CXzsCPP() { Xzs_Construct(&p); }
- ~CXzsCPP() { Xzs_Free(&p, &g_Alloc); }
-};
-
-#define kInputBufSize ((size_t)1 << 10)
-
-struct CLookToRead2_CPP: public CLookToRead2
-{
- CLookToRead2_CPP()
- {
- buf = NULL;
- LookToRead2_CreateVTable(this,
- True // Lookahead ?
- );
- }
- void Alloc(size_t allocSize)
- {
- buf = (Byte *)MyAlloc(allocSize);
- if (buf)
- this->bufSize = allocSize;
- }
- ~CLookToRead2_CPP()
- {
- MyFree(buf);
- }
-};
-
-
-static HRESULT SRes_to_Open_HRESULT(SRes res)
-{
- switch (res)
- {
- case SZ_OK: return S_OK;
- case SZ_ERROR_MEM: return E_OUTOFMEMORY;
- case SZ_ERROR_PROGRESS: return E_ABORT;
- /*
- case SZ_ERROR_UNSUPPORTED:
- case SZ_ERROR_CRC:
- case SZ_ERROR_DATA:
- case SZ_ERROR_ARCHIVE:
- case SZ_ERROR_NO_ARCHIVE:
- return S_FALSE;
- */
- }
- return S_FALSE;
-}
-
-
-
-HRESULT CHandler::Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCallback *callback)
-{
- _needSeekToStart = true;
-
- {
- CXzStreamFlags st;
- CSeqInStreamWrap inStreamWrap;
-
- inStreamWrap.Init(inStream);
- SRes res = Xz_ReadHeader(&st, &inStreamWrap.vt);
- if (res != SZ_OK)
- return SRes_to_Open_HRESULT(res);
-
- {
- CXzBlock block;
- BoolInt isIndex;
- UInt32 headerSizeRes;
- SRes res2 = XzBlock_ReadHeader(&block, &inStreamWrap.vt, &isIndex, &headerSizeRes);
- if (res2 == SZ_OK && !isIndex)
- {
- _firstBlockWasRead = true;
- _firstBlock = block;
-
- unsigned numFilters = XzBlock_GetNumFilters(&block);
- for (unsigned i = 0; i < numFilters; i++)
- {
- _methodsString.Add_Space_if_NotEmpty();
- AddMethodString(_methodsString, block.filters[i]);
- }
- }
- }
- }
-
- RINOK(inStream->Seek(0, STREAM_SEEK_END, &_stat.InSize));
- if (callback)
- {
- RINOK(callback->SetTotal(NULL, &_stat.InSize));
- }
-
- CSeekInStreamWrap inStreamImp;
-
- inStreamImp.Init(inStream);
-
- CLookToRead2_CPP lookStream;
-
- lookStream.Alloc(kInputBufSize);
-
- if (!lookStream.buf)
- return E_OUTOFMEMORY;
-
- lookStream.realStream = &inStreamImp.vt;
- LookToRead2_Init(&lookStream);
-
- COpenCallbackWrap openWrap(callback);
-
- CXzsCPP xzs;
- Int64 startPosition;
- SRes res = Xzs_ReadBackward(&xzs.p, &lookStream.vt, &startPosition, &openWrap.vt, &g_Alloc);
- if (res == SZ_ERROR_PROGRESS)
- return (openWrap.Res == S_OK) ? E_FAIL : openWrap.Res;
- /*
- if (res == SZ_ERROR_NO_ARCHIVE && xzs.p.num > 0)
- res = SZ_OK;
- */
- if (res == SZ_OK && startPosition == 0)
- {
- _phySize_Defined = true;
-
- _stat.OutSize = Xzs_GetUnpackSize(&xzs.p);
- _stat.UnpackSize_Defined = true;
-
- _stat.NumStreams = xzs.p.num;
- _stat.NumStreams_Defined = true;
-
- _stat.NumBlocks = Xzs_GetNumBlocks(&xzs.p);
- _stat.NumBlocks_Defined = true;
-
- AddCheckString(_methodsString, xzs.p);
-
- const size_t numBlocks = (size_t)_stat.NumBlocks + 1;
- const size_t bytesAlloc = numBlocks * sizeof(CBlockInfo);
-
- if (bytesAlloc / sizeof(CBlockInfo) == _stat.NumBlocks + 1)
- {
- _blocks = (CBlockInfo *)MyAlloc(bytesAlloc);
- if (_blocks)
- {
- unsigned blockIndex = 0;
- UInt64 unpackPos = 0;
-
- for (size_t si = xzs.p.num; si != 0;)
- {
- si--;
- const CXzStream &str = xzs.p.streams[si];
- UInt64 packPos = str.startOffset + XZ_STREAM_HEADER_SIZE;
-
- for (size_t bi = 0; bi < str.numBlocks; bi++)
- {
- const CXzBlockSizes &bs = str.blocks[bi];
- const UInt64 packSizeAligned = bs.totalSize + ((0 - (unsigned)bs.totalSize) & 3);
-
- if (bs.unpackSize != 0)
- {
- if (blockIndex >= _stat.NumBlocks)
- return E_FAIL;
-
- CBlockInfo &block = _blocks[blockIndex++];
- block.StreamFlags = str.flags;
- block.PackSize = bs.totalSize; // packSizeAligned;
- block.PackPos = packPos;
- block.UnpackPos = unpackPos;
- }
- packPos += packSizeAligned;
- unpackPos += bs.unpackSize;
- if (_maxBlocksSize < bs.unpackSize)
- _maxBlocksSize = bs.unpackSize;
- }
- }
-
- /*
- if (blockIndex != _stat.NumBlocks)
- {
- // there are Empty blocks;
- }
- */
- if (_stat.OutSize != unpackPos)
- return E_FAIL;
- CBlockInfo &block = _blocks[blockIndex++];
- block.StreamFlags = 0;
- block.PackSize = 0;
- block.PackPos = 0;
- block.UnpackPos = unpackPos;
- _blocksArraySize = blockIndex;
- }
- }
- }
- else
- {
- res = SZ_OK;
- }
-
- RINOK(SRes_to_Open_HRESULT(res));
- _stream = inStream;
- _seqStream = inStream;
- _isArc = true;
- return S_OK;
-}
-
-
-
-STDMETHODIMP CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *callback)
-{
- COM_TRY_BEGIN
- {
- Close();
- return Open2(inStream, callback);
- }
- COM_TRY_END
-}
-
-STDMETHODIMP CHandler::OpenSeq(ISequentialInStream *stream)
-{
- Close();
- _seqStream = stream;
- _isArc = true;
- _needSeekToStart = false;
- return S_OK;
-}
-
-STDMETHODIMP CHandler::Close()
-{
- XzStatInfo_Clear(&_stat);
-
- _isArc = false;
- _needSeekToStart = false;
- _phySize_Defined = false;
- _firstBlockWasRead = false;
-
- _methodsString.Empty();
- _stream.Release();
- _seqStream.Release();
-
- MyFree(_blocks);
- _blocks = NULL;
- _blocksArraySize = 0;
- _maxBlocksSize = 0;
-
- MainDecodeSRes = SZ_OK;
-
- return S_OK;
-}
-
-
-struct CXzUnpackerCPP2
-{
- Byte *InBuf;
- // Byte *OutBuf;
- CXzUnpacker p;
-
- CXzUnpackerCPP2();
- ~CXzUnpackerCPP2();
-};
-
-CXzUnpackerCPP2::CXzUnpackerCPP2(): InBuf(NULL)
- // , OutBuf(NULL)
-{
- XzUnpacker_Construct(&p, &g_Alloc);
-}
-
-CXzUnpackerCPP2::~CXzUnpackerCPP2()
-{
- XzUnpacker_Free(&p);
- MidFree(InBuf);
- // MidFree(OutBuf);
-}
-
-
-class CInStream:
- public IInStream,
- public CMyUnknownImp
-{
-public:
- UInt64 _virtPos;
- UInt64 Size;
- UInt64 _cacheStartPos;
- size_t _cacheSize;
- CByteBuffer _cache;
- // UInt64 _startPos;
- CXzUnpackerCPP2 xz;
-
- void InitAndSeek()
- {
- _virtPos = 0;
- _cacheStartPos = 0;
- _cacheSize = 0;
- // _startPos = startPos;
- }
-
- CHandler *_handlerSpec;
- CMyComPtr<IUnknown> _handler;
-
- MY_UNKNOWN_IMP1(IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-
- ~CInStream();
-};
-
-
-CInStream::~CInStream()
-{
- // _cache.Free();
-}
-
-
-size_t FindBlock(const CBlockInfo *blocks, size_t numBlocks, UInt64 pos)
-{
- size_t left = 0, right = numBlocks;
- for (;;)
- {
- size_t mid = (left + right) / 2;
- if (mid == left)
- return left;
- if (pos < blocks[mid].UnpackPos)
- right = mid;
- else
- left = mid;
- }
-}
-
-
-
-static HRESULT DecodeBlock(CXzUnpackerCPP2 &xzu,
- ISequentialInStream *seqInStream,
- unsigned streamFlags,
- UInt64 packSize, // pure size from Index record, it doesn't include pad zeros
- size_t unpackSize, Byte *dest
- // , ICompressProgressInfo *progress
- )
-{
- const size_t kInBufSize = (size_t)1 << 16;
-
- XzUnpacker_Init(&xzu.p);
-
- if (!xzu.InBuf)
- {
- xzu.InBuf = (Byte *)MidAlloc(kInBufSize);
- if (!xzu.InBuf)
- return E_OUTOFMEMORY;
- }
-
- xzu.p.streamFlags = (UInt16)streamFlags;
- XzUnpacker_PrepareToRandomBlockDecoding(&xzu.p);
-
- XzUnpacker_SetOutBuf(&xzu.p, dest, unpackSize);
-
- const UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
- UInt64 packRem = packSizeAligned;
-
- UInt32 inSize = 0;
- SizeT inPos = 0;
- SizeT outPos = 0;
-
- HRESULT readRes = S_OK;
-
- for (;;)
- {
- if (inPos == inSize && readRes == S_OK)
- {
- inPos = 0;
- inSize = 0;
- UInt32 rem = kInBufSize;
- if (rem > packRem)
- rem = (UInt32)packRem;
- if (rem != 0)
- readRes = seqInStream->Read(xzu.InBuf, rem, &inSize);
- }
-
- SizeT inLen = inSize - inPos;
- SizeT outLen = unpackSize - outPos;
-
- ECoderStatus status;
-
- SRes res = XzUnpacker_Code(&xzu.p,
- // dest + outPos,
- NULL,
- &outLen,
- xzu.InBuf + inPos, &inLen,
- (inLen == 0), // srcFinished
- CODER_FINISH_END, &status);
-
- // return E_OUTOFMEMORY;
- // res = SZ_ERROR_CRC;
-
- if (res != SZ_OK)
- {
- if (res == SZ_ERROR_CRC)
- return S_FALSE;
- return SResToHRESULT(res);
- }
-
- inPos += inLen;
- outPos += outLen;
-
- packRem -= inLen;
-
- BoolInt blockFinished = XzUnpacker_IsBlockFinished(&xzu.p);
-
- if ((inLen == 0 && outLen == 0) || blockFinished)
- {
- if (packRem != 0 || !blockFinished || unpackSize != outPos)
- return S_FALSE;
- if (XzUnpacker_GetPackSizeForIndex(&xzu.p) != packSize)
- return S_FALSE;
- return S_OK;
- }
- }
-}
-
-
-STDMETHODIMP CInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- COM_TRY_BEGIN
-
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
-
- {
- if (_virtPos >= Size)
- return S_OK; // (Size == _virtPos) ? S_OK: E_FAIL;
- {
- UInt64 rem = Size - _virtPos;
- if (size > rem)
- size = (UInt32)rem;
- }
- }
-
- if (size == 0)
- return S_OK;
-
- if (_virtPos < _cacheStartPos || _virtPos >= _cacheStartPos + _cacheSize)
- {
- size_t bi = FindBlock(_handlerSpec->_blocks, _handlerSpec->_blocksArraySize, _virtPos);
- const CBlockInfo &block = _handlerSpec->_blocks[bi];
- const UInt64 unpackSize = _handlerSpec->_blocks[bi + 1].UnpackPos - block.UnpackPos;
- if (_cache.Size() < unpackSize)
- return E_FAIL;
-
- _cacheSize = 0;
-
- RINOK(_handlerSpec->SeekToPackPos(block.PackPos));
- RINOK(DecodeBlock(xz, _handlerSpec->_seqStream, block.StreamFlags, block.PackSize,
- (size_t)unpackSize, _cache));
- _cacheStartPos = block.UnpackPos;
- _cacheSize = (size_t)unpackSize;
- }
-
- {
- size_t offset = (size_t)(_virtPos - _cacheStartPos);
- size_t rem = _cacheSize - offset;
- if (size > rem)
- size = (UInt32)rem;
- memcpy(data, _cache + offset, size);
- _virtPos += size;
- if (processedSize)
- *processedSize = size;
- return S_OK;
- }
-
- COM_TRY_END
-}
-
-
-STDMETHODIMP CInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END: offset += Size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
-
-
-
-static const UInt64 kMaxBlockSize_for_GetStream = (UInt64)1 << 40;
-
-STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
-{
- COM_TRY_BEGIN
-
- *stream = NULL;
-
- if (index != 0)
- return E_INVALIDARG;
-
- if (!_stat.UnpackSize_Defined
- || _maxBlocksSize == 0 // 18.02
- || _maxBlocksSize > kMaxBlockSize_for_GetStream
- || _maxBlocksSize != (size_t)_maxBlocksSize)
- return S_FALSE;
-
- UInt64 memSize;
- if (!NSystem::GetRamSize(memSize))
- memSize = (UInt64)(sizeof(size_t)) << 28;
- {
- if (_maxBlocksSize > memSize / 4)
- return S_FALSE;
- }
-
- CInStream *spec = new CInStream;
- CMyComPtr<ISequentialInStream> specStream = spec;
- spec->_cache.Alloc((size_t)_maxBlocksSize);
- spec->_handlerSpec = this;
- spec->_handler = (IInArchive *)this;
- spec->Size = _stat.OutSize;
- spec->InitAndSeek();
-
- *stream = specStream.Detach();
- return S_OK;
-
- COM_TRY_END
-}
-
-
-static Int32 Get_Extract_OperationResult(const NCompress::NXz::CDecoder &decoder)
-{
- Int32 opRes;
- SRes sres = decoder.MainDecodeSRes; // decoder.Stat.DecodeRes2;
- if (sres == SZ_ERROR_NO_ARCHIVE) // (!IsArc)
- opRes = NExtract::NOperationResult::kIsNotArc;
- else if (sres == SZ_ERROR_INPUT_EOF) // (UnexpectedEnd)
- opRes = NExtract::NOperationResult::kUnexpectedEnd;
- else if (decoder.Stat.DataAfterEnd)
- opRes = NExtract::NOperationResult::kDataAfterEnd;
- else if (sres == SZ_ERROR_CRC) // (CrcError)
- opRes = NExtract::NOperationResult::kCRCError;
- else if (sres == SZ_ERROR_UNSUPPORTED) // (Unsupported)
- opRes = NExtract::NOperationResult::kUnsupportedMethod;
- else if (sres == SZ_ERROR_ARCHIVE) // (HeadersError)
- opRes = NExtract::NOperationResult::kDataError;
- else if (sres == SZ_ERROR_DATA) // (DataError)
- opRes = NExtract::NOperationResult::kDataError;
- else if (sres != SZ_OK)
- opRes = NExtract::NOperationResult::kDataError;
- else
- opRes = NExtract::NOperationResult::kOK;
- return opRes;
-}
-
-
-
-
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
- Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
- COM_TRY_BEGIN
- if (numItems == 0)
- return S_OK;
- if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
- return E_INVALIDARG;
-
- if (_phySize_Defined)
- extractCallback->SetTotal(_stat.InSize);
-
- UInt64 currentTotalPacked = 0;
- RINOK(extractCallback->SetCompleted(¤tTotalPacked));
- CMyComPtr<ISequentialOutStream> realOutStream;
- Int32 askMode = testMode ?
- NExtract::NAskMode::kTest :
- NExtract::NAskMode::kExtract;
-
- RINOK(extractCallback->GetStream(0, &realOutStream, askMode));
-
- if (!testMode && !realOutStream)
- return S_OK;
-
- extractCallback->PrepareOperation(askMode);
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> lpsRef = lps;
- lps->Init(extractCallback, true);
-
- if (_needSeekToStart)
- {
- if (!_stream)
- return E_FAIL;
- RINOK(_stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
- else
- _needSeekToStart = true;
-
-
- NCompress::NXz::CDecoder decoder;
-
- HRESULT hres = Decode(decoder, _seqStream, realOutStream, lpsRef);
-
- if (!decoder.MainDecodeSRes_wasUsed)
- return hres == S_OK ? E_FAIL : hres;
-
- Int32 opRes = Get_Extract_OperationResult(decoder);
- if (opRes == NExtract::NOperationResult::kOK
- && hres != S_OK)
- opRes = NExtract::NOperationResult::kDataError;
-
- realOutStream.Release();
- return extractCallback->SetOperationResult(opRes);
- COM_TRY_END
-}
-
-
-
-#ifndef EXTRACT_ONLY
-
-STDMETHODIMP CHandler::GetFileTimeType(UInt32 *timeType)
-{
- *timeType = NFileTimeType::kUnix;
- return S_OK;
-}
-
-
-STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
- IArchiveUpdateCallback *updateCallback)
-{
- COM_TRY_BEGIN
-
- if (numItems == 0)
- {
- CSeqOutStreamWrap seqOutStream;
- seqOutStream.Init(outStream);
- SRes res = Xz_EncodeEmpty(&seqOutStream.vt);
- return SResToHRESULT(res);
- }
-
- if (numItems != 1)
- return E_INVALIDARG;
-
- Int32 newData, newProps;
- UInt32 indexInArchive;
- if (!updateCallback)
- return E_FAIL;
- RINOK(updateCallback->GetUpdateItemInfo(0, &newData, &newProps, &indexInArchive));
-
- if (IntToBool(newProps))
- {
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(0, kpidIsDir, &prop));
- if (prop.vt != VT_EMPTY)
- if (prop.vt != VT_BOOL || prop.boolVal != VARIANT_FALSE)
- return E_INVALIDARG;
- }
- }
-
- if (IntToBool(newData))
- {
- UInt64 size;
- {
- NCOM::CPropVariant prop;
- RINOK(updateCallback->GetProperty(0, kpidSize, &prop));
- if (prop.vt != VT_UI8)
- return E_INVALIDARG;
- size = prop.uhVal.QuadPart;
- RINOK(updateCallback->SetTotal(size));
- }
-
- NCompress::NXz::CEncoder *encoderSpec = new NCompress::NXz::CEncoder;
- CMyComPtr<ICompressCoder> encoder = encoderSpec;
-
- CXzProps &xzProps = encoderSpec->xzProps;
- CLzma2EncProps &lzma2Props = xzProps.lzma2Props;
-
- lzma2Props.lzmaProps.level = GetLevel();
-
- xzProps.reduceSize = size;
- /*
- {
- NCOM::CPropVariant prop = (UInt64)size;
- RINOK(encoderSpec->SetCoderProp(NCoderPropID::kReduceSize, prop));
- }
- */
-
- #ifndef _7ZIP_ST
- xzProps.numTotalThreads = _numThreads;
- #endif
-
- xzProps.blockSize = _numSolidBytes;
- if (_numSolidBytes == XZ_PROPS__BLOCK_SIZE__SOLID)
- {
- xzProps.lzma2Props.blockSize = LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID;
- }
-
- RINOK(encoderSpec->SetCheckSize(_crcSize));
-
- {
- CXzFilterProps &filter = xzProps.filterProps;
-
- if (_filterId == XZ_ID_Delta)
- {
- bool deltaDefined = false;
- FOR_VECTOR (j, _filterMethod.Props)
- {
- const CProp &prop = _filterMethod.Props[j];
- if (prop.Id == NCoderPropID::kDefaultProp && prop.Value.vt == VT_UI4)
- {
- UInt32 delta = (UInt32)prop.Value.ulVal;
- if (delta < 1 || delta > 256)
- return E_INVALIDARG;
- filter.delta = delta;
- deltaDefined = true;
- }
- else
- return E_INVALIDARG;
- }
- if (!deltaDefined)
- return E_INVALIDARG;
- }
- filter.id = _filterId;
- }
-
- FOR_VECTOR (i, _methods)
- {
- COneMethodInfo &m = _methods[i];
-
- FOR_VECTOR (j, m.Props)
- {
- const CProp &prop = m.Props[j];
- RINOK(encoderSpec->SetCoderProp(prop.Id, prop.Value));
- }
- }
-
- CMyComPtr<ISequentialInStream> fileInStream;
- RINOK(updateCallback->GetStream(0, &fileInStream));
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(updateCallback, true);
-
- return encoderSpec->Code(fileInStream, outStream, NULL, NULL, progress);
- }
-
- if (indexInArchive != 0)
- return E_INVALIDARG;
-
- CMyComPtr<IArchiveUpdateCallbackFile> opCallback;
- updateCallback->QueryInterface(IID_IArchiveUpdateCallbackFile, (void **)&opCallback);
- if (opCallback)
- {
- RINOK(opCallback->ReportOperation(NEventIndexType::kInArcIndex, 0, NUpdateNotifyOp::kReplicate))
- }
-
- if (_stream)
- {
- if (_phySize_Defined)
- RINOK(updateCallback->SetTotal(_stat.InSize));
- RINOK(_stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(updateCallback, true);
-
- return NCompress::CopyStream(_stream, outStream, progress);
-
- COM_TRY_END
-}
-
-#endif
-
-
-HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
-{
- UString name = nameSpec;
- name.MakeLower_Ascii();
- if (name.IsEmpty())
- return E_INVALIDARG;
-
- #ifndef EXTRACT_ONLY
-
- if (name[0] == L's')
- {
- const wchar_t *s = name.Ptr(1);
- if (*s == 0)
- {
- bool useStr = false;
- bool isSolid;
- switch (value.vt)
- {
- case VT_EMPTY: isSolid = true; break;
- case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
- case VT_BSTR:
- if (!StringToBool(value.bstrVal, isSolid))
- useStr = true;
- break;
- default: return E_INVALIDARG;
- }
- if (!useStr)
- {
- _numSolidBytes = (isSolid ? XZ_PROPS__BLOCK_SIZE__SOLID : XZ_PROPS__BLOCK_SIZE__AUTO);
- return S_OK;
- }
- }
- return ParseSizeString(s, value,
- 0, // percentsBase
- _numSolidBytes) ? S_OK: E_INVALIDARG;
- }
-
- return CMultiMethodProps::SetProperty(name, value);
-
- #else
-
- {
- HRESULT hres;
- if (SetCommonProperty(name, value, hres))
- return hres;
- }
-
- return E_INVALIDARG;
-
- #endif
-}
-
-
-
-STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
-{
- COM_TRY_BEGIN
-
- Init();
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- RINOK(SetProperty(names[i], values[i]));
- }
-
- #ifndef EXTRACT_ONLY
-
- if (!_filterMethod.MethodName.IsEmpty())
- {
- unsigned k;
- for (k = 0; k < ARRAY_SIZE(g_NamePairs); k++)
- {
- const CMethodNamePair &pair = g_NamePairs[k];
- if (StringsAreEqualNoCase_Ascii(_filterMethod.MethodName, pair.Name))
- {
- _filterId = pair.Id;
- break;
- }
- }
- if (k == ARRAY_SIZE(g_NamePairs))
- return E_INVALIDARG;
- }
-
- _methods.DeleteFrontal(GetNumEmptyMethods());
- if (_methods.Size() > 1)
- return E_INVALIDARG;
- if (_methods.Size() == 1)
- {
- AString &methodName = _methods[0].MethodName;
- if (methodName.IsEmpty())
- methodName = k_LZMA2_Name;
- else if (
- !methodName.IsEqualTo_Ascii_NoCase(k_LZMA2_Name)
- && !methodName.IsEqualTo_Ascii_NoCase("xz"))
- return E_INVALIDARG;
- }
-
- #endif
-
- return S_OK;
-
- COM_TRY_END
-}
-
-
-REGISTER_ARC_IO(
- "xz", "xz txz", "* .tar", 0xC,
- XZ_SIG,
- 0,
- NArcInfoFlags::kKeepName,
- NULL)
-
-}}
+// XzHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/Defs.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/StringToInt.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/System.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/XzDecoder.h"
+#include "../Compress/XzEncoder.h"
+
+#include "IArchive.h"
+
+#include "Common/HandlerOut.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NXz {
+
+#define k_LZMA2_Name "LZMA2"
+
+
+struct CBlockInfo
+{
+ unsigned StreamFlags;
+ UInt64 PackPos;
+ UInt64 PackSize; // pure value from Index record, it doesn't include pad zeros
+ UInt64 UnpackPos;
+};
+
+
+Z7_class_CHandler_final:
+ public IInArchive,
+ public IArchiveOpenSeq,
+ public IInArchiveGetStream,
+ public ISetProperties,
+ #ifndef Z7_EXTRACT_ONLY
+ public IOutArchive,
+ #endif
+ public CMyUnknownImp,
+ #ifndef Z7_EXTRACT_ONLY
+ public CMultiMethodProps
+ #else
+ public CCommonMethodProps
+ #endif
+{
+ Z7_COM_QI_BEGIN2(IInArchive)
+ Z7_COM_QI_ENTRY(IArchiveOpenSeq)
+ Z7_COM_QI_ENTRY(IInArchiveGetStream)
+ Z7_COM_QI_ENTRY(ISetProperties)
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_COM_QI_ENTRY(IOutArchive)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IInArchive)
+ Z7_IFACE_COM7_IMP(IArchiveOpenSeq)
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(ISetProperties)
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_IFACE_COM7_IMP(IOutArchive)
+ #endif
+
+ CXzStatInfo _stat; // it's stat from backward parsing
+ CXzStatInfo _stat2; // it's data from forward parsing, if the decoder was called
+ SRes _stat2_decode_SRes;
+ bool _stat_defined;
+ bool _stat2_defined;
+
+ const CXzStatInfo *GetStat() const
+ {
+ if (_stat_defined) return &_stat;
+ if (_stat2_defined) return &_stat2;
+ return NULL;
+ }
+
+ bool _isArc;
+ bool _needSeekToStart;
+ bool _firstBlockWasRead;
+
+ AString _methodsString;
+
+
+ #ifndef Z7_EXTRACT_ONLY
+
+ UInt32 _filterId;
+ UInt64 _numSolidBytes;
+
+ void InitXz()
+ {
+ _filterId = 0;
+ _numSolidBytes = XZ_PROPS_BLOCK_SIZE_AUTO;
+ }
+
+ #endif
+
+
+ void Init()
+ {
+ #ifndef Z7_EXTRACT_ONLY
+ InitXz();
+ CMultiMethodProps::Init();
+ #else
+ CCommonMethodProps::InitCommon();
+ #endif
+ }
+
+ HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
+
+ HRESULT Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCallback *callback);
+
+ HRESULT Decode(NCompress::NXz::CDecoder &decoder,
+ ISequentialInStream *seqInStream,
+ ISequentialOutStream *outStream,
+ ICompressProgressInfo *progress)
+ {
+ #ifndef Z7_ST
+ decoder._numThreads = _numThreads;
+ #endif
+ decoder._memUsage = _memUsage_Decompress;
+
+ HRESULT hres = decoder.Decode(seqInStream, outStream,
+ NULL, // *outSizeLimit
+ true, // finishStream
+ progress);
+
+ if (decoder.MainDecodeSRes_wasUsed
+ && decoder.MainDecodeSRes != SZ_ERROR_MEM
+ && decoder.MainDecodeSRes != SZ_ERROR_UNSUPPORTED)
+ {
+ // if (!_stat2_defined)
+ {
+ _stat2_decode_SRes = decoder.MainDecodeSRes;
+ _stat2 = decoder.Stat;
+ _stat2_defined = true;
+ }
+ }
+
+ return hres;
+ }
+
+public:
+ CBlockInfo *_blocks;
+ size_t _blocksArraySize;
+ UInt64 _maxBlocksSize;
+ CMyComPtr<IInStream> _stream;
+ CMyComPtr<ISequentialInStream> _seqStream;
+
+ CXzBlock _firstBlock;
+
+ CHandler();
+ ~CHandler();
+
+ HRESULT SeekToPackPos(UInt64 pos)
+ {
+ return InStream_SeekSet(_stream, pos);
+ }
+};
+
+
+CHandler::CHandler():
+ _blocks(NULL),
+ _blocksArraySize(0)
+{
+ #ifndef Z7_EXTRACT_ONLY
+ InitXz();
+ #endif
+}
+
+CHandler::~CHandler()
+{
+ MyFree(_blocks);
+}
+
+
+static const Byte kProps[] =
+{
+ kpidSize,
+ kpidPackSize,
+ kpidMethod
+};
+
+static const Byte kArcProps[] =
+{
+ kpidMethod,
+ kpidNumStreams,
+ kpidNumBlocks,
+ kpidClusterSize,
+ kpidCharacts
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+static inline char GetHex(unsigned value)
+{
+ return (char)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
+}
+
+static inline void AddHexToString(AString &s, Byte value)
+{
+ s += GetHex(value >> 4);
+ s += GetHex(value & 0xF);
+}
+
+static void Lzma2PropToString(AString &s, unsigned prop)
+{
+ char c = 0;
+ UInt32 size;
+ if ((prop & 1) == 0)
+ size = prop / 2 + 12;
+ else
+ {
+ c = 'k';
+ size = (UInt32)(2 | (prop & 1)) << (prop / 2 + 1);
+ if (prop > 17)
+ {
+ size >>= 10;
+ c = 'm';
+ }
+ }
+ s.Add_UInt32(size);
+ if (c != 0)
+ s += c;
+}
+
+struct CMethodNamePair
+{
+ UInt32 Id;
+ const char *Name;
+};
+
+static const CMethodNamePair g_NamePairs[] =
+{
+ { XZ_ID_Subblock, "SB" },
+ { XZ_ID_Delta, "Delta" },
+ { XZ_ID_X86, "BCJ" },
+ { XZ_ID_PPC, "PPC" },
+ { XZ_ID_IA64, "IA64" },
+ { XZ_ID_ARM, "ARM" },
+ { XZ_ID_ARMT, "ARMT" },
+ { XZ_ID_SPARC, "SPARC" },
+ { XZ_ID_ARM64, "ARM64" },
+ { XZ_ID_LZMA2, "LZMA2" }
+};
+
+static void AddMethodString(AString &s, const CXzFilter &f)
+{
+ const char *p = NULL;
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_NamePairs); i++)
+ if (g_NamePairs[i].Id == f.id)
+ {
+ p = g_NamePairs[i].Name;
+ break;
+ }
+ char temp[32];
+ if (!p)
+ {
+ ::ConvertUInt64ToString(f.id, temp);
+ p = temp;
+ }
+
+ s += p;
+
+ if (f.propsSize > 0)
+ {
+ s += ':';
+ if (f.id == XZ_ID_LZMA2 && f.propsSize == 1)
+ Lzma2PropToString(s, f.props[0]);
+ else if (f.id == XZ_ID_Delta && f.propsSize == 1)
+ s.Add_UInt32((UInt32)f.props[0] + 1);
+ else if (f.id == XZ_ID_ARM64 && f.propsSize == 1)
+ s.Add_UInt32((UInt32)f.props[0] + 16 + 2);
+ else
+ {
+ s += '[';
+ for (UInt32 bi = 0; bi < f.propsSize; bi++)
+ AddHexToString(s, f.props[bi]);
+ s += ']';
+ }
+ }
+}
+
+static const char * const kChecks[] =
+{
+ "NoCheck"
+ , "CRC32"
+ , NULL
+ , NULL
+ , "CRC64"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "SHA256"
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+};
+
+static void AddCheckString(AString &s, const CXzs &xzs)
+{
+ size_t i;
+ UInt32 mask = 0;
+ for (i = 0; i < xzs.num; i++)
+ mask |= ((UInt32)1 << XzFlags_GetCheckType(xzs.streams[i].flags));
+ for (i = 0; i <= XZ_CHECK_MASK; i++)
+ if (((mask >> i) & 1) != 0)
+ {
+ s.Add_Space_if_NotEmpty();
+ if (kChecks[i])
+ s += kChecks[i];
+ else
+ {
+ s += "Check-";
+ s.Add_UInt32((UInt32)i);
+ }
+ }
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CXzStatInfo *stat = GetStat();
+
+ switch (propID)
+ {
+ case kpidPhySize: if (stat) prop = stat->InSize; break;
+ case kpidNumStreams: if (stat && stat->NumStreams_Defined) prop = stat->NumStreams; break;
+ case kpidNumBlocks: if (stat && stat->NumBlocks_Defined) prop = stat->NumBlocks; break;
+ case kpidUnpackSize: if (stat && stat->UnpackSize_Defined) prop = stat->OutSize; break;
+ case kpidClusterSize: if (_stat_defined && _stat.NumBlocks_Defined && stat->NumBlocks > 1) prop = _maxBlocksSize; break;
+ case kpidCharacts:
+ if (_firstBlockWasRead)
+ {
+ AString s;
+ if (XzBlock_HasPackSize(&_firstBlock))
+ s.Add_OptSpaced("BlockPackSize");
+ if (XzBlock_HasUnpackSize(&_firstBlock))
+ s.Add_OptSpaced("BlockUnpackSize");
+ if (!s.IsEmpty())
+ prop = s;
+ }
+ break;
+
+
+ case kpidMethod: if (!_methodsString.IsEmpty()) prop = _methodsString; break;
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ SRes sres = _stat2_decode_SRes;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (sres == SZ_ERROR_INPUT_EOF) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (_stat2_defined && _stat2.DataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
+ if (sres == SZ_ERROR_ARCHIVE) v |= kpv_ErrorFlags_HeadersError;
+ if (sres == SZ_ERROR_UNSUPPORTED) v |= kpv_ErrorFlags_UnsupportedMethod;
+ if (sres == SZ_ERROR_DATA) v |= kpv_ErrorFlags_DataError;
+ if (sres == SZ_ERROR_CRC) v |= kpv_ErrorFlags_CrcError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidMainSubfile:
+ {
+ // debug only, comment it:
+ // if (_blocks) prop = (UInt32)0;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ const CXzStatInfo *stat = GetStat();
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidSize: if (stat && stat->UnpackSize_Defined) prop = stat->OutSize; break;
+ case kpidPackSize: if (stat) prop = stat->InSize; break;
+ case kpidMethod: if (!_methodsString.IsEmpty()) prop = _methodsString; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+struct COpenCallbackWrap
+{
+ ICompressProgress vt;
+ IArchiveOpenCallback *OpenCallback;
+ HRESULT Res;
+
+ // new clang shows "non-POD" warning for offsetof(), if we use constructor instead of Init()
+ void Init(IArchiveOpenCallback *progress);
+};
+
+static SRes OpenCallbackProgress(ICompressProgressPtr pp, UInt64 inSize, UInt64 /* outSize */)
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(COpenCallbackWrap)
+ if (p->OpenCallback)
+ p->Res = p->OpenCallback->SetCompleted(NULL, &inSize);
+ return HRESULT_To_SRes(p->Res, SZ_ERROR_PROGRESS);
+}
+
+void COpenCallbackWrap::Init(IArchiveOpenCallback *callback)
+{
+ vt.Progress = OpenCallbackProgress;
+ OpenCallback = callback;
+ Res = SZ_OK;
+}
+
+
+struct CXzsCPP
+{
+ CXzs p;
+ CXzsCPP() { Xzs_Construct(&p); }
+ ~CXzsCPP() { Xzs_Free(&p, &g_Alloc); }
+};
+
+#define kInputBufSize ((size_t)1 << 10)
+
+struct CLookToRead2_CPP: public CLookToRead2
+{
+ CLookToRead2_CPP()
+ {
+ buf = NULL;
+ LookToRead2_CreateVTable(this,
+ True // Lookahead ?
+ );
+ }
+ void Alloc(size_t allocSize)
+ {
+ buf = (Byte *)MyAlloc(allocSize);
+ if (buf)
+ this->bufSize = allocSize;
+ }
+ ~CLookToRead2_CPP()
+ {
+ MyFree(buf);
+ }
+};
+
+
+static HRESULT SRes_to_Open_HRESULT(SRes res)
+{
+ switch (res)
+ {
+ case SZ_OK: return S_OK;
+ case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+ case SZ_ERROR_PROGRESS: return E_ABORT;
+ /*
+ case SZ_ERROR_UNSUPPORTED:
+ case SZ_ERROR_CRC:
+ case SZ_ERROR_DATA:
+ case SZ_ERROR_ARCHIVE:
+ case SZ_ERROR_NO_ARCHIVE:
+ return S_FALSE;
+ */
+ }
+ return S_FALSE;
+}
+
+
+
+HRESULT CHandler::Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCallback *callback)
+{
+ _needSeekToStart = true;
+
+ {
+ CXzStreamFlags st;
+ CSeqInStreamWrap inStreamWrap;
+
+ inStreamWrap.Init(inStream);
+
+ SRes res = Xz_ReadHeader(&st, &inStreamWrap.vt);
+
+ if (inStreamWrap.Res != S_OK)
+ return inStreamWrap.Res;
+ if (res != SZ_OK)
+ return SRes_to_Open_HRESULT(res);
+
+ {
+ CXzBlock block;
+ BoolInt isIndex;
+ UInt32 headerSizeRes;
+
+ SRes res2 = XzBlock_ReadHeader(&block, &inStreamWrap.vt, &isIndex, &headerSizeRes);
+
+ if (inStreamWrap.Res != S_OK)
+ return inStreamWrap.Res;
+
+ if (res2 != SZ_OK)
+ {
+ if (res2 == SZ_ERROR_INPUT_EOF)
+ {
+ _stat2_decode_SRes = res2;
+ _stream = inStream;
+ _seqStream = inStream;
+ _isArc = true;
+ return S_OK;
+ }
+
+ if (res2 == SZ_ERROR_ARCHIVE)
+ return S_FALSE;
+ }
+ else if (!isIndex)
+ {
+ _firstBlockWasRead = true;
+ _firstBlock = block;
+
+ unsigned numFilters = XzBlock_GetNumFilters(&block);
+ for (unsigned i = 0; i < numFilters; i++)
+ {
+ _methodsString.Add_Space_if_NotEmpty();
+ AddMethodString(_methodsString, block.filters[i]);
+ }
+ }
+ }
+ }
+
+ RINOK(InStream_GetSize_SeekToEnd(inStream, _stat.InSize))
+ if (callback)
+ {
+ RINOK(callback->SetTotal(NULL, &_stat.InSize))
+ }
+
+ CSeekInStreamWrap inStreamImp;
+
+ inStreamImp.Init(inStream);
+
+ CLookToRead2_CPP lookStream;
+
+ lookStream.Alloc(kInputBufSize);
+
+ if (!lookStream.buf)
+ return E_OUTOFMEMORY;
+
+ lookStream.realStream = &inStreamImp.vt;
+ LookToRead2_INIT(&lookStream)
+
+ COpenCallbackWrap openWrap;
+ openWrap.Init(callback);
+
+ CXzsCPP xzs;
+ Int64 startPosition;
+ SRes res = Xzs_ReadBackward(&xzs.p, &lookStream.vt, &startPosition, &openWrap.vt, &g_Alloc);
+ if (res == SZ_ERROR_PROGRESS)
+ return (openWrap.Res == S_OK) ? E_FAIL : openWrap.Res;
+ /*
+ if (res == SZ_ERROR_NO_ARCHIVE && xzs.p.num > 0)
+ res = SZ_OK;
+ */
+ if (res == SZ_OK && startPosition == 0)
+ {
+ _stat_defined = true;
+
+ _stat.OutSize = Xzs_GetUnpackSize(&xzs.p);
+ _stat.UnpackSize_Defined = true;
+
+ _stat.NumStreams = xzs.p.num;
+ _stat.NumStreams_Defined = true;
+
+ _stat.NumBlocks = Xzs_GetNumBlocks(&xzs.p);
+ _stat.NumBlocks_Defined = true;
+
+ AddCheckString(_methodsString, xzs.p);
+
+ const size_t numBlocks = (size_t)_stat.NumBlocks + 1;
+ const size_t bytesAlloc = numBlocks * sizeof(CBlockInfo);
+
+ if (bytesAlloc / sizeof(CBlockInfo) == _stat.NumBlocks + 1)
+ {
+ _blocks = (CBlockInfo *)MyAlloc(bytesAlloc);
+ if (_blocks)
+ {
+ unsigned blockIndex = 0;
+ UInt64 unpackPos = 0;
+
+ for (size_t si = xzs.p.num; si != 0;)
+ {
+ si--;
+ const CXzStream &str = xzs.p.streams[si];
+ UInt64 packPos = str.startOffset + XZ_STREAM_HEADER_SIZE;
+
+ for (size_t bi = 0; bi < str.numBlocks; bi++)
+ {
+ const CXzBlockSizes &bs = str.blocks[bi];
+ const UInt64 packSizeAligned = bs.totalSize + ((0 - (unsigned)bs.totalSize) & 3);
+
+ if (bs.unpackSize != 0)
+ {
+ if (blockIndex >= _stat.NumBlocks)
+ return E_FAIL;
+
+ CBlockInfo &block = _blocks[blockIndex++];
+ block.StreamFlags = str.flags;
+ block.PackSize = bs.totalSize; // packSizeAligned;
+ block.PackPos = packPos;
+ block.UnpackPos = unpackPos;
+ }
+ packPos += packSizeAligned;
+ unpackPos += bs.unpackSize;
+ if (_maxBlocksSize < bs.unpackSize)
+ _maxBlocksSize = bs.unpackSize;
+ }
+ }
+
+ /*
+ if (blockIndex != _stat.NumBlocks)
+ {
+ // there are Empty blocks;
+ }
+ */
+ if (_stat.OutSize != unpackPos)
+ return E_FAIL;
+ CBlockInfo &block = _blocks[blockIndex++];
+ block.StreamFlags = 0;
+ block.PackSize = 0;
+ block.PackPos = 0;
+ block.UnpackPos = unpackPos;
+ _blocksArraySize = blockIndex;
+ }
+ }
+ }
+ else
+ {
+ res = SZ_OK;
+ }
+
+ RINOK(SRes_to_Open_HRESULT(res))
+
+ _stream = inStream;
+ _seqStream = inStream;
+ _isArc = true;
+ return S_OK;
+}
+
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ return Open2(inStream, callback);
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+{
+ Close();
+ _seqStream = stream;
+ _isArc = true;
+ _needSeekToStart = false;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ XzStatInfo_Clear(&_stat);
+ XzStatInfo_Clear(&_stat2);
+ _stat_defined = false;
+ _stat2_defined = false;
+ _stat2_decode_SRes = SZ_OK;
+
+ _isArc = false;
+ _needSeekToStart = false;
+ _firstBlockWasRead = false;
+
+ _methodsString.Empty();
+ _stream.Release();
+ _seqStream.Release();
+
+ MyFree(_blocks);
+ _blocks = NULL;
+ _blocksArraySize = 0;
+ _maxBlocksSize = 0;
+
+ return S_OK;
+}
+
+
+struct CXzUnpackerCPP2
+{
+ Byte *InBuf;
+ // Byte *OutBuf;
+ CXzUnpacker p;
+
+ CXzUnpackerCPP2();
+ ~CXzUnpackerCPP2();
+};
+
+CXzUnpackerCPP2::CXzUnpackerCPP2(): InBuf(NULL)
+ // , OutBuf(NULL)
+{
+ XzUnpacker_Construct(&p, &g_Alloc);
+}
+
+CXzUnpackerCPP2::~CXzUnpackerCPP2()
+{
+ XzUnpacker_Free(&p);
+ MidFree(InBuf);
+ // MidFree(OutBuf);
+}
+
+
+Z7_CLASS_IMP_COM_1(
+ CInStream
+ , IInStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+
+ UInt64 _virtPos;
+public:
+ UInt64 Size;
+ UInt64 _cacheStartPos;
+ size_t _cacheSize;
+ CByteBuffer _cache;
+ // UInt64 _startPos;
+ CXzUnpackerCPP2 xz;
+
+ void InitAndSeek()
+ {
+ _virtPos = 0;
+ _cacheStartPos = 0;
+ _cacheSize = 0;
+ // _startPos = startPos;
+ }
+
+ CHandler *_handlerSpec;
+ CMyComPtr<IUnknown> _handler;
+
+ // ~CInStream();
+};
+
+/*
+CInStream::~CInStream()
+{
+ // _cache.Free();
+}
+*/
+
+static size_t FindBlock(const CBlockInfo *blocks, size_t numBlocks, UInt64 pos)
+{
+ size_t left = 0, right = numBlocks;
+ for (;;)
+ {
+ size_t mid = (left + right) / 2;
+ if (mid == left)
+ return left;
+ if (pos < blocks[mid].UnpackPos)
+ right = mid;
+ else
+ left = mid;
+ }
+}
+
+
+
+static HRESULT DecodeBlock(CXzUnpackerCPP2 &xzu,
+ ISequentialInStream *seqInStream,
+ unsigned streamFlags,
+ UInt64 packSize, // pure size from Index record, it doesn't include pad zeros
+ size_t unpackSize, Byte *dest
+ // , ICompressProgressInfo *progress
+ )
+{
+ const size_t kInBufSize = (size_t)1 << 16;
+
+ XzUnpacker_Init(&xzu.p);
+
+ if (!xzu.InBuf)
+ {
+ xzu.InBuf = (Byte *)MidAlloc(kInBufSize);
+ if (!xzu.InBuf)
+ return E_OUTOFMEMORY;
+ }
+
+ xzu.p.streamFlags = (UInt16)streamFlags;
+ XzUnpacker_PrepareToRandomBlockDecoding(&xzu.p);
+
+ XzUnpacker_SetOutBuf(&xzu.p, dest, unpackSize);
+
+ const UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
+ UInt64 packRem = packSizeAligned;
+
+ UInt32 inSize = 0;
+ SizeT inPos = 0;
+ SizeT outPos = 0;
+
+ HRESULT readRes = S_OK;
+
+ for (;;)
+ {
+ if (inPos == inSize && readRes == S_OK)
+ {
+ inPos = 0;
+ inSize = 0;
+ UInt32 rem = kInBufSize;
+ if (rem > packRem)
+ rem = (UInt32)packRem;
+ if (rem != 0)
+ readRes = seqInStream->Read(xzu.InBuf, rem, &inSize);
+ }
+
+ SizeT inLen = inSize - inPos;
+ SizeT outLen = unpackSize - outPos;
+
+ ECoderStatus status;
+
+ const SRes res = XzUnpacker_Code(&xzu.p,
+ // dest + outPos,
+ NULL,
+ &outLen,
+ xzu.InBuf + inPos, &inLen,
+ (inLen == 0), // srcFinished
+ CODER_FINISH_END, &status);
+
+ // return E_OUTOFMEMORY;
+ // res = SZ_ERROR_CRC;
+
+ if (res != SZ_OK)
+ {
+ if (res == SZ_ERROR_CRC)
+ return S_FALSE;
+ return SResToHRESULT(res);
+ }
+
+ inPos += inLen;
+ outPos += outLen;
+
+ packRem -= inLen;
+
+ const BoolInt blockFinished = XzUnpacker_IsBlockFinished(&xzu.p);
+
+ if ((inLen == 0 && outLen == 0) || blockFinished)
+ {
+ if (packRem != 0 || !blockFinished || unpackSize != outPos)
+ return S_FALSE;
+ if (XzUnpacker_GetPackSizeForIndex(&xzu.p) != packSize)
+ return S_FALSE;
+ return S_OK;
+ }
+ }
+}
+
+
+Z7_COM7F_IMF(CInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ COM_TRY_BEGIN
+
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+
+ {
+ if (_virtPos >= Size)
+ return S_OK; // (Size == _virtPos) ? S_OK: E_FAIL;
+ {
+ UInt64 rem = Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ }
+
+ if (size == 0)
+ return S_OK;
+
+ if (_virtPos < _cacheStartPos || _virtPos >= _cacheStartPos + _cacheSize)
+ {
+ const size_t bi = FindBlock(_handlerSpec->_blocks, _handlerSpec->_blocksArraySize, _virtPos);
+ const CBlockInfo &block = _handlerSpec->_blocks[bi];
+ const UInt64 unpackSize = _handlerSpec->_blocks[bi + 1].UnpackPos - block.UnpackPos;
+ if (_cache.Size() < unpackSize)
+ return E_FAIL;
+
+ _cacheSize = 0;
+
+ RINOK(_handlerSpec->SeekToPackPos(block.PackPos))
+ RINOK(DecodeBlock(xz, _handlerSpec->_seqStream, block.StreamFlags, block.PackSize,
+ (size_t)unpackSize, _cache))
+ _cacheStartPos = block.UnpackPos;
+ _cacheSize = (size_t)unpackSize;
+ }
+
+ {
+ const size_t offset = (size_t)(_virtPos - _cacheStartPos);
+ const size_t rem = _cacheSize - offset;
+ if (size > rem)
+ size = (UInt32)rem;
+ memcpy(data, _cache + offset, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+
+static const UInt64 kMaxBlockSize_for_GetStream = (UInt64)1 << 40;
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+
+ *stream = NULL;
+
+ if (index != 0)
+ return E_INVALIDARG;
+
+ if (!_stat.UnpackSize_Defined
+ || _maxBlocksSize == 0 // 18.02
+ || _maxBlocksSize > kMaxBlockSize_for_GetStream
+ || _maxBlocksSize != (size_t)_maxBlocksSize)
+ return S_FALSE;
+
+ UInt64 memSize;
+ if (!NSystem::GetRamSize(memSize))
+ memSize = (UInt64)(sizeof(size_t)) << 28;
+ {
+ if (_maxBlocksSize > memSize / 4)
+ return S_FALSE;
+ }
+
+ CInStream *spec = new CInStream;
+ CMyComPtr<ISequentialInStream> specStream = spec;
+ spec->_cache.Alloc((size_t)_maxBlocksSize);
+ spec->_handlerSpec = this;
+ spec->_handler = (IInArchive *)this;
+ spec->Size = _stat.OutSize;
+ spec->InitAndSeek();
+
+ *stream = specStream.Detach();
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+static Int32 Get_Extract_OperationResult(const NCompress::NXz::CDecoder &decoder)
+{
+ Int32 opRes;
+ SRes sres = decoder.MainDecodeSRes;
+ if (sres == SZ_ERROR_NO_ARCHIVE) // (!IsArc)
+ opRes = NExtract::NOperationResult::kIsNotArc;
+ else if (sres == SZ_ERROR_INPUT_EOF) // (UnexpectedEnd)
+ opRes = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (decoder.Stat.DataAfterEnd)
+ opRes = NExtract::NOperationResult::kDataAfterEnd;
+ else if (sres == SZ_ERROR_CRC) // (CrcError)
+ opRes = NExtract::NOperationResult::kCRCError;
+ else if (sres == SZ_ERROR_UNSUPPORTED) // (Unsupported)
+ opRes = NExtract::NOperationResult::kUnsupportedMethod;
+ else if (sres == SZ_ERROR_ARCHIVE) // (HeadersError)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (sres == SZ_ERROR_DATA) // (DataError)
+ opRes = NExtract::NOperationResult::kDataError;
+ else if (sres != SZ_OK)
+ opRes = NExtract::NOperationResult::kDataError;
+ else
+ opRes = NExtract::NOperationResult::kOK;
+ return opRes;
+}
+
+
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ const CXzStatInfo *stat = GetStat();
+
+ if (stat)
+ extractCallback->SetTotal(stat->InSize);
+
+ UInt64 currentTotalPacked = 0;
+ RINOK(extractCallback->SetCompleted(¤tTotalPacked))
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> lpsRef = lps;
+ lps->Init(extractCallback, true);
+
+ if (_needSeekToStart)
+ {
+ if (!_stream)
+ return E_FAIL;
+ RINOK(InStream_SeekToBegin(_stream))
+ }
+ else
+ _needSeekToStart = true;
+
+
+ NCompress::NXz::CDecoder decoder;
+
+ HRESULT hres = Decode(decoder, _seqStream, realOutStream, lpsRef);
+
+ if (!decoder.MainDecodeSRes_wasUsed)
+ return hres == S_OK ? E_FAIL : hres;
+
+ Int32 opRes = Get_Extract_OperationResult(decoder);
+ if (opRes == NExtract::NOperationResult::kOK
+ && hres != S_OK)
+ opRes = NExtract::NOperationResult::kDataError;
+
+ realOutStream.Release();
+ return extractCallback->SetOperationResult(opRes);
+ COM_TRY_END
+}
+
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *timeType))
+{
+ *timeType = GET_FileTimeType_NotDefined_for_GetFileTimeType;
+ // *timeType = NFileTimeType::kUnix;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *updateCallback))
+{
+ COM_TRY_BEGIN
+
+ if (numItems == 0)
+ {
+ CSeqOutStreamWrap seqOutStream;
+ seqOutStream.Init(outStream);
+ SRes res = Xz_EncodeEmpty(&seqOutStream.vt);
+ return SResToHRESULT(res);
+ }
+
+ if (numItems != 1)
+ return E_INVALIDARG;
+
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamSetRestriction,
+ setRestriction, outStream)
+ if (setRestriction)
+ RINOK(setRestriction->SetRestriction(0, 0))
+ }
+
+ Int32 newData, newProps;
+ UInt32 indexInArchive;
+ if (!updateCallback)
+ return E_FAIL;
+ RINOK(updateCallback->GetUpdateItemInfo(0, &newData, &newProps, &indexInArchive))
+
+ if (IntToBool(newProps))
+ {
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidIsDir, &prop))
+ if (prop.vt != VT_EMPTY)
+ if (prop.vt != VT_BOOL || prop.boolVal != VARIANT_FALSE)
+ return E_INVALIDARG;
+ }
+ }
+
+ if (IntToBool(newData))
+ {
+ UInt64 dataSize;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(updateCallback->GetProperty(0, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ dataSize = prop.uhVal.QuadPart;
+ }
+
+ NCompress::NXz::CEncoder *encoderSpec = new NCompress::NXz::CEncoder;
+ CMyComPtr<ICompressCoder> encoder = encoderSpec;
+
+ CXzProps &xzProps = encoderSpec->xzProps;
+ CLzma2EncProps &lzma2Props = xzProps.lzma2Props;
+
+ lzma2Props.lzmaProps.level = GetLevel();
+
+ xzProps.reduceSize = dataSize;
+ /*
+ {
+ NCOM::CPropVariant prop = (UInt64)dataSize;
+ RINOK(encoderSpec->SetCoderProp(NCoderPropID::kReduceSize, prop))
+ }
+ */
+
+ #ifndef Z7_ST
+
+ UInt32 numThreads = _numThreads;
+
+ const UInt32 kNumThreads_Max = 1024;
+ if (numThreads > kNumThreads_Max)
+ numThreads = kNumThreads_Max;
+
+ if (!_numThreads_WasForced
+ && _numThreads >= 1
+ && _memUsage_WasSet)
+ {
+ COneMethodInfo oneMethodInfo;
+ if (!_methods.IsEmpty())
+ oneMethodInfo = _methods[0];
+
+ SetGlobalLevelTo(oneMethodInfo);
+
+ const bool numThreads_WasSpecifiedInMethod = (oneMethodInfo.Get_NumThreads() >= 0);
+ if (!numThreads_WasSpecifiedInMethod)
+ {
+ // here we set the (NCoderPropID::kNumThreads) property in each method, only if there is no such property already
+ CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(oneMethodInfo, numThreads);
+ }
+
+ UInt64 cs = _numSolidBytes;
+ if (cs != XZ_PROPS_BLOCK_SIZE_AUTO)
+ oneMethodInfo.AddProp_BlockSize2(cs);
+ cs = oneMethodInfo.Get_Xz_BlockSize();
+
+ if (cs != XZ_PROPS_BLOCK_SIZE_AUTO &&
+ cs != XZ_PROPS_BLOCK_SIZE_SOLID)
+ {
+ const UInt32 lzmaThreads = oneMethodInfo.Get_Lzma_NumThreads();
+ const UInt32 numBlockThreads_Original = numThreads / lzmaThreads;
+
+ if (numBlockThreads_Original > 1)
+ {
+ UInt32 numBlockThreads = numBlockThreads_Original;
+ {
+ const UInt64 lzmaMemUsage = oneMethodInfo.Get_Lzma_MemUsage(false);
+ for (; numBlockThreads > 1; numBlockThreads--)
+ {
+ UInt64 size = numBlockThreads * (lzmaMemUsage + cs);
+ UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
+ if (cs < ((UInt32)1 << 26)) numPackChunks++;
+ if (cs < ((UInt32)1 << 24)) numPackChunks++;
+ if (cs < ((UInt32)1 << 22)) numPackChunks++;
+ size += numPackChunks * cs;
+ // printf("\nnumBlockThreads = %d, size = %d\n", (unsigned)(numBlockThreads), (unsigned)(size >> 20));
+ if (size <= _memUsage_Compress)
+ break;
+ }
+ }
+ if (numBlockThreads == 0)
+ numBlockThreads = 1;
+ if (numBlockThreads != numBlockThreads_Original)
+ numThreads = numBlockThreads * lzmaThreads;
+ }
+ }
+ }
+ xzProps.numTotalThreads = (int)numThreads;
+
+ #endif // Z7_ST
+
+
+ xzProps.blockSize = _numSolidBytes;
+ if (_numSolidBytes == XZ_PROPS_BLOCK_SIZE_SOLID)
+ {
+ xzProps.lzma2Props.blockSize = LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID;
+ }
+
+ RINOK(encoderSpec->SetCheckSize(_crcSize))
+
+ {
+ CXzFilterProps &filter = xzProps.filterProps;
+
+ if (_filterId == XZ_ID_Delta)
+ {
+ bool deltaDefined = false;
+ FOR_VECTOR (j, _filterMethod.Props)
+ {
+ const CProp &prop = _filterMethod.Props[j];
+ if (prop.Id == NCoderPropID::kDefaultProp && prop.Value.vt == VT_UI4)
+ {
+ UInt32 delta = (UInt32)prop.Value.ulVal;
+ if (delta < 1 || delta > 256)
+ return E_INVALIDARG;
+ filter.delta = delta;
+ deltaDefined = true;
+ }
+ else
+ return E_INVALIDARG;
+ }
+ if (!deltaDefined)
+ return E_INVALIDARG;
+ }
+ filter.id = _filterId;
+ }
+
+ FOR_VECTOR (i, _methods)
+ {
+ COneMethodInfo &m = _methods[i];
+
+ FOR_VECTOR (j, m.Props)
+ {
+ const CProp &prop = m.Props[j];
+ RINOK(encoderSpec->SetCoderProp(prop.Id, prop.Value))
+ }
+ }
+
+ {
+ CMyComPtr<ISequentialInStream> fileInStream;
+ RINOK(updateCallback->GetStream(0, &fileInStream))
+ if (!fileInStream)
+ return S_FALSE;
+ {
+ CMyComPtr<IStreamGetSize> streamGetSize;
+ fileInStream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
+ if (streamGetSize)
+ {
+ UInt64 size;
+ if (streamGetSize->GetSize(&size) == S_OK)
+ dataSize = size;
+ }
+ }
+ RINOK(updateCallback->SetTotal(dataSize))
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+ RINOK(encoder->Code(fileInStream, outStream, NULL, NULL, progress))
+ }
+
+ return updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK);
+ }
+
+ if (indexInArchive != 0)
+ return E_INVALIDARG;
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveUpdateCallbackFile,
+ opCallback, updateCallback)
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(NEventIndexType::kInArcIndex, 0, NUpdateNotifyOp::kReplicate))
+ }
+
+ if (_stream)
+ {
+ const CXzStatInfo *stat = GetStat();
+ if (stat)
+ {
+ RINOK(updateCallback->SetTotal(stat->InSize))
+ }
+ RINOK(InStream_SeekToBegin(_stream))
+ }
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ return NCompress::CopyStream(_stream, outStream, progress);
+
+ COM_TRY_END
+}
+
+#endif
+
+
+HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
+{
+ UString name = nameSpec;
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ #ifndef Z7_EXTRACT_ONLY
+
+ if (name[0] == L's')
+ {
+ const wchar_t *s = name.Ptr(1);
+ if (*s == 0)
+ {
+ bool useStr = false;
+ bool isSolid;
+ switch (value.vt)
+ {
+ case VT_EMPTY: isSolid = true; break;
+ case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
+ case VT_BSTR:
+ if (!StringToBool(value.bstrVal, isSolid))
+ useStr = true;
+ break;
+ default: return E_INVALIDARG;
+ }
+ if (!useStr)
+ {
+ _numSolidBytes = (isSolid ? XZ_PROPS_BLOCK_SIZE_SOLID : XZ_PROPS_BLOCK_SIZE_AUTO);
+ return S_OK;
+ }
+ }
+ return ParseSizeString(s, value,
+ 0, // percentsBase
+ _numSolidBytes) ? S_OK: E_INVALIDARG;
+ }
+
+ return CMultiMethodProps::SetProperty(name, value);
+
+ #else
+
+ {
+ HRESULT hres;
+ if (SetCommonProperty(name, value, hres))
+ return hres;
+ }
+
+ return E_INVALIDARG;
+
+ #endif
+}
+
+
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ COM_TRY_BEGIN
+
+ Init();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ RINOK(SetProperty(names[i], values[i]))
+ }
+
+ #ifndef Z7_EXTRACT_ONLY
+
+ if (!_filterMethod.MethodName.IsEmpty())
+ {
+ unsigned k;
+ for (k = 0; k < Z7_ARRAY_SIZE(g_NamePairs); k++)
+ {
+ const CMethodNamePair &pair = g_NamePairs[k];
+ if (StringsAreEqualNoCase_Ascii(_filterMethod.MethodName, pair.Name))
+ {
+ _filterId = pair.Id;
+ break;
+ }
+ }
+ if (k == Z7_ARRAY_SIZE(g_NamePairs))
+ return E_INVALIDARG;
+ }
+
+ _methods.DeleteFrontal(GetNumEmptyMethods());
+ if (_methods.Size() > 1)
+ return E_INVALIDARG;
+ if (_methods.Size() == 1)
+ {
+ AString &methodName = _methods[0].MethodName;
+ if (methodName.IsEmpty())
+ methodName = k_LZMA2_Name;
+ else if (
+ !methodName.IsEqualTo_Ascii_NoCase(k_LZMA2_Name)
+ && !methodName.IsEqualTo_Ascii_NoCase("xz"))
+ return E_INVALIDARG;
+ }
+
+ #endif
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+REGISTER_ARC_IO(
+ "xz", "xz txz", "* .tar", 0xC,
+ XZ_SIG, 0
+ , NArcInfoFlags::kKeepName
+ , 0
+ , NULL)
+
+}}
diff --git a/CPP/7zip/Archive/XzHandler.h b/CPP/7zip/Archive/XzHandler.h
index 18633fb..4d09954 100644
--- a/CPP/7zip/Archive/XzHandler.h
+++ b/CPP/7zip/Archive/XzHandler.h
@@ -1,11 +1,11 @@
-// XzHandler.h
-
-#ifndef __XZ_HANDLER_H
-#define __XZ_HANDLER_H
-
-namespace NArchive {
-namespace NXz {
-
-}}
-
-#endif
+// XzHandler.h
+
+#ifndef ZIP7_INC_XZ_HANDLER_H
+#define ZIP7_INC_XZ_HANDLER_H
+
+namespace NArchive {
+namespace NXz {
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/ZHandler.cpp b/CPP/7zip/Archive/ZHandler.cpp
new file mode 100644
index 0000000..18e712a
--- /dev/null
+++ b/CPP/7zip/Archive/ZHandler.cpp
@@ -0,0 +1,230 @@
+// ZHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/ZDecoder.h"
+
+#include "Common/DummyOutStream.h"
+
+namespace NArchive {
+namespace NZ {
+
+Z7_CLASS_IMP_CHandler_IInArchive_0
+
+ CMyComPtr<IInStream> _stream;
+ UInt64 _packSize;
+ // UInt64 _unpackSize;
+ // bool _unpackSize_Defined;
+};
+
+static const Byte kProps[] =
+{
+ kpidPackSize
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO_Table
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySizeCantBeDetected: prop = true; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ // case kpidSize: if (_unpackSize_Defined) prop = _unpackSize; break;
+ case kpidPackSize: prop = _packSize; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+/*
+Z7_CLASS_IMP_COM_1(
+ CCompressProgressInfoImp
+ , ICompressProgressInfo
+)
+ CMyComPtr<IArchiveOpenCallback> Callback;
+public:
+ void Init(IArchiveOpenCallback *callback) { Callback = callback; }
+};
+
+Z7_COM7F_IMF(CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ outSize = outSize;
+ if (Callback)
+ {
+ const UInt64 files = 1;
+ return Callback->SetCompleted(&files, inSize);
+ }
+ return S_OK;
+}
+*/
+
+API_FUNC_static_IsArc IsArc_Z(const Byte *p, size_t size)
+{
+ if (size < 3)
+ return k_IsArc_Res_NEED_MORE;
+ if (size > NCompress::NZ::kRecommendedCheckSize)
+ size = NCompress::NZ::kRecommendedCheckSize;
+ if (!NCompress::NZ::CheckStream(p, size))
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+}
+}
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream,
+ const UInt64 * /* maxCheckStartPosition */,
+ IArchiveOpenCallback * /* openCallback */))
+{
+ COM_TRY_BEGIN
+ {
+ // RINOK(InStream_GetPos(stream, _streamStartPosition));
+ Byte buffer[NCompress::NZ::kRecommendedCheckSize];
+ // Byte buffer[1500];
+ size_t size = NCompress::NZ::kRecommendedCheckSize;
+ // size = 700;
+ RINOK(ReadStream(stream, buffer, &size))
+ if (!NCompress::NZ::CheckStream(buffer, size))
+ return S_FALSE;
+
+ UInt64 endPos;
+ RINOK(InStream_GetSize_SeekToEnd(stream, endPos))
+ _packSize = endPos;
+
+ /*
+ bool fullCheck = false;
+ if (fullCheck)
+ {
+ CCompressProgressInfoImp *compressProgressSpec = new CCompressProgressInfoImp;
+ CMyComPtr<ICompressProgressInfo> compressProgress = compressProgressSpec;
+ compressProgressSpec->Init(openCallback);
+
+ NCompress::NZ::CDecoder *decoderSpec = new NCompress::NZ::CDecoder;
+ CMyComPtr<ICompressCoder> decoder = decoderSpec;
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(NULL);
+ outStreamSpec->Init();
+ decoderSpec->SetProp(_prop);
+ if (openCallback)
+ {
+ UInt64 files = 1;
+ RINOK(openCallback->SetTotal(&files, &endPos));
+ }
+ RINOK(InStream_SeekSet(stream, _streamStartPosition + kSignatureSize))
+ HRESULT res = decoder->Code(stream, outStream, NULL, NULL, openCallback ? compressProgress : NULL);
+ if (res != S_OK)
+ return S_FALSE;
+ _packSize = decoderSpec->PackSize;
+ }
+ */
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _packSize = 0;
+ // _unpackSize_Defined = false;
+ _stream.Release();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ if (numItems == 0)
+ return S_OK;
+ if (numItems != (UInt32)(Int32)-1 && (numItems != 1 || indices[0] != 0))
+ return E_INVALIDARG;
+
+ extractCallback->SetTotal(_packSize);
+
+ UInt64 currentTotalPacked = 0;
+
+ RINOK(extractCallback->SetCompleted(¤tTotalPacked))
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+
+ if (!testMode && !realOutStream)
+ return S_OK;
+
+ extractCallback->PrepareOperation(askMode);
+
+ CDummyOutStream *outStreamSpec = new CDummyOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init();
+ realOutStream.Release();
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, true);
+
+ RINOK(InStream_SeekToBegin(_stream))
+
+ NCompress::NZ::CDecoder *decoderSpec = new NCompress::NZ::CDecoder;
+ CMyComPtr<ICompressCoder> decoder = decoderSpec;
+
+ int opRes;
+ {
+ HRESULT result = decoder->Code(_stream, outStream, NULL, NULL, progress);
+ if (result == S_FALSE)
+ opRes = NExtract::NOperationResult::kDataError;
+ else
+ {
+ RINOK(result)
+ opRes = NExtract::NOperationResult::kOK;
+ }
+ }
+ // _unpackSize = outStreamSpec->GetSize();
+ // _unpackSize_Defined = true;
+ outStream.Release();
+ return extractCallback->SetOperationResult(opRes);
+ COM_TRY_END
+}
+
+static const Byte k_Signature[] = { 0x1F, 0x9D };
+
+REGISTER_ARC_I(
+ "Z", "z taz", "* .tar", 5,
+ k_Signature,
+ 0,
+ 0,
+ IsArc_Z)
+
+}}
diff --git a/CPP/7zip/Archive/Zip/StdAfx.h b/CPP/7zip/Archive/Zip/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipAddCommon.cpp b/CPP/7zip/Archive/Zip/ZipAddCommon.cpp
new file mode 100644
index 0000000..8af84b4
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipAddCommon.cpp
@@ -0,0 +1,499 @@
+// ZipAddCommon.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+#include "../../../../C/Alloc.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../ICoder.h"
+#include "../../IPassword.h"
+#include "../../MyVersion.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/LzmaEncoder.h"
+#include "../../Compress/PpmdZip.h"
+#include "../../Compress/XzEncoder.h"
+
+#include "../Common/InStreamWithCRC.h"
+
+#include "ZipAddCommon.h"
+#include "ZipHeader.h"
+
+namespace NArchive {
+namespace NZip {
+
+using namespace NFileHeader;
+
+
+static const unsigned kLzmaPropsSize = 5;
+static const unsigned kLzmaHeaderSize = 4 + kLzmaPropsSize;
+
+Z7_CLASS_IMP_NOQIB_3(
+ CLzmaEncoder
+ , ICompressCoder
+ , ICompressSetCoderProperties
+ , ICompressSetCoderPropertiesOpt
+)
+public:
+ NCompress::NLzma::CEncoder *EncoderSpec;
+ CMyComPtr<ICompressCoder> Encoder;
+ Byte Header[kLzmaHeaderSize];
+};
+
+Z7_COM7F_IMF(CLzmaEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+{
+ if (!Encoder)
+ {
+ EncoderSpec = new NCompress::NLzma::CEncoder;
+ Encoder = EncoderSpec;
+ }
+ CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+ outStreamSpec->Init(Header + 4, kLzmaPropsSize);
+ RINOK(EncoderSpec->SetCoderProperties(propIDs, props, numProps))
+ RINOK(EncoderSpec->WriteCoderProperties(outStream))
+ if (outStreamSpec->GetPos() != kLzmaPropsSize)
+ return E_FAIL;
+ Header[0] = MY_VER_MAJOR;
+ Header[1] = MY_VER_MINOR;
+ Header[2] = kLzmaPropsSize;
+ Header[3] = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CLzmaEncoder::SetCoderPropertiesOpt(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+{
+ return EncoderSpec->SetCoderPropertiesOpt(propIDs, props, numProps);
+}
+
+Z7_COM7F_IMF(CLzmaEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ RINOK(WriteStream(outStream, Header, kLzmaHeaderSize))
+ return Encoder->Code(inStream, outStream, inSize, outSize, progress);
+}
+
+
+CAddCommon::CAddCommon():
+ _copyCoderSpec(NULL),
+ _isLzmaEos(false),
+ _cryptoStreamSpec(NULL),
+ _buf(NULL)
+ {}
+
+void CAddCommon::SetOptions(const CCompressionMethodMode &options)
+{
+ _options = options;
+}
+
+CAddCommon::~CAddCommon()
+{
+ MidFree(_buf);
+}
+
+static const UInt32 kBufSize = ((UInt32)1 << 16);
+
+HRESULT CAddCommon::CalcStreamCRC(ISequentialInStream *inStream, UInt32 &resultCRC)
+{
+ if (!_buf)
+ {
+ _buf = (Byte *)MidAlloc(kBufSize);
+ if (!_buf)
+ return E_OUTOFMEMORY;
+ }
+
+ UInt32 crc = CRC_INIT_VAL;
+ for (;;)
+ {
+ UInt32 processed;
+ RINOK(inStream->Read(_buf, kBufSize, &processed))
+ if (processed == 0)
+ {
+ resultCRC = CRC_GET_DIGEST(crc);
+ return S_OK;
+ }
+ crc = CrcUpdate(crc, _buf, (size_t)processed);
+ }
+}
+
+
+HRESULT CAddCommon::Set_Pre_CompressionResult(bool inSeqMode, bool outSeqMode, UInt64 unpackSize,
+ CCompressingResult &opRes) const
+{
+ // We use Zip64, if unPackSize size is larger than 0xF8000000 to support
+ // cases when compressed size can be about 3% larger than uncompressed size
+
+ const UInt32 kUnpackZip64Limit = 0xF8000000;
+
+ opRes.UnpackSize = unpackSize;
+ opRes.PackSize = (UInt64)1 << 60; // we use big value to force Zip64 mode.
+
+ if (unpackSize < kUnpackZip64Limit)
+ opRes.PackSize = (UInt32)0xFFFFFFFF - 1; // it will not use Zip64 for that size
+
+ if (opRes.PackSize < unpackSize)
+ opRes.PackSize = unpackSize;
+
+ const Byte method = _options.MethodSequence[0];
+
+ if (method == NCompressionMethod::kStore && !_options.Password_Defined)
+ opRes.PackSize = unpackSize;
+
+ opRes.CRC = 0;
+
+ opRes.LzmaEos = false;
+
+ opRes.ExtractVersion = NCompressionMethod::kExtractVersion_Default;
+ opRes.DescriptorMode = outSeqMode;
+
+ if (_options.Password_Defined)
+ {
+ opRes.ExtractVersion = NCompressionMethod::kExtractVersion_ZipCrypto;
+ if (_options.IsAesMode)
+ opRes.ExtractVersion = NCompressionMethod::kExtractVersion_Aes;
+ else
+ {
+ if (inSeqMode)
+ opRes.DescriptorMode = true;
+ }
+ }
+
+ opRes.Method = method;
+ Byte ver = 0;
+
+ switch (method)
+ {
+ case NCompressionMethod::kStore: break;
+ case NCompressionMethod::kDeflate: ver = NCompressionMethod::kExtractVersion_Deflate; break;
+ case NCompressionMethod::kDeflate64: ver = NCompressionMethod::kExtractVersion_Deflate64; break;
+ case NCompressionMethod::kXz : ver = NCompressionMethod::kExtractVersion_Xz; break;
+ case NCompressionMethod::kPPMd : ver = NCompressionMethod::kExtractVersion_PPMd; break;
+ case NCompressionMethod::kBZip2: ver = NCompressionMethod::kExtractVersion_BZip2; break;
+ case NCompressionMethod::kLZMA :
+ {
+ ver = NCompressionMethod::kExtractVersion_LZMA;
+ const COneMethodInfo *oneMethodMain = &_options._methods[0];
+ opRes.LzmaEos = oneMethodMain->Get_Lzma_Eos();
+ break;
+ }
+ }
+ if (opRes.ExtractVersion < ver)
+ opRes.ExtractVersion = ver;
+
+ return S_OK;
+}
+
+
+HRESULT CAddCommon::Compress(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ ISequentialInStream *inStream, IOutStream *outStream,
+ bool inSeqMode, bool outSeqMode,
+ UInt32 fileTime,
+ UInt64 expectedDataSize, bool expectedDataSize_IsConfirmed,
+ ICompressProgressInfo *progress, CCompressingResult &opRes)
+{
+ // opRes.LzmaEos = false;
+
+ if (!inStream)
+ {
+ // We can create empty stream here. But it was already implemented in caller code in 9.33+
+ return E_INVALIDARG;
+ }
+
+ CSequentialInStreamWithCRC *inSecCrcStreamSpec = new CSequentialInStreamWithCRC;
+ CMyComPtr<ISequentialInStream> inCrcStream = inSecCrcStreamSpec;
+
+ CMyComPtr<IInStream> inStream2;
+ if (!inSeqMode)
+ {
+ inStream->QueryInterface(IID_IInStream, (void **)&inStream2);
+ if (!inStream2)
+ {
+ // inSeqMode = true;
+ // inSeqMode must be correct before
+ return E_FAIL;
+ }
+ }
+
+ inSecCrcStreamSpec->SetStream(inStream);
+ inSecCrcStreamSpec->SetFullSize(expectedDataSize_IsConfirmed ? expectedDataSize : (UInt64)(Int64)-1);
+ // inSecCrcStreamSpec->Init();
+
+ unsigned numTestMethods = _options.MethodSequence.Size();
+ // numTestMethods != 0
+
+ bool descriptorMode = outSeqMode;
+
+ // ZipCrypto without descriptor requires additional reading pass for
+ // inStream to calculate CRC for password check field.
+ // The descriptor allows to use ZipCrypto check field without CRC (InfoZip's modification).
+
+ if (!outSeqMode)
+ if (inSeqMode && _options.Password_Defined && !_options.IsAesMode)
+ descriptorMode = true;
+ opRes.DescriptorMode = descriptorMode;
+
+ if (numTestMethods > 1)
+ if (inSeqMode || outSeqMode || !inStream2)
+ numTestMethods = 1;
+
+ UInt32 crc = 0;
+ bool crc_IsCalculated = false;
+
+ CFilterCoder::C_OutStream_Releaser outStreamReleaser;
+ // opRes.ExtractVersion = NCompressionMethod::kExtractVersion_Default;
+
+ for (unsigned i = 0; i < numTestMethods; i++)
+ {
+ inSecCrcStreamSpec->Init();
+
+ if (i != 0)
+ {
+ // if (inStream2)
+ {
+ RINOK(InStream_SeekToBegin(inStream2))
+ }
+ RINOK(outStream->Seek(0, STREAM_SEEK_SET, NULL))
+ RINOK(outStream->SetSize(0))
+ }
+
+ opRes.LzmaEos = false;
+ opRes.ExtractVersion = NCompressionMethod::kExtractVersion_Default;
+
+ const Byte method = _options.MethodSequence[i];
+ if (method == NCompressionMethod::kStore && descriptorMode)
+ {
+ // we still can create descriptor_mode archives with "Store" method, but they are not good for 100%
+ return E_NOTIMPL;
+ }
+
+ bool needCode = true;
+
+ if (_options.Password_Defined)
+ {
+ opRes.ExtractVersion = NCompressionMethod::kExtractVersion_ZipCrypto;
+
+ if (!_cryptoStream)
+ {
+ _cryptoStreamSpec = new CFilterCoder(true);
+ _cryptoStream = _cryptoStreamSpec;
+ }
+
+ if (_options.IsAesMode)
+ {
+ opRes.ExtractVersion = NCompressionMethod::kExtractVersion_Aes;
+ if (!_cryptoStreamSpec->Filter)
+ {
+ _cryptoStreamSpec->Filter = _filterAesSpec = new NCrypto::NWzAes::CEncoder;
+ _filterAesSpec->SetKeyMode(_options.AesKeyMode);
+ RINOK(_filterAesSpec->CryptoSetPassword((const Byte *)(const char *)_options.Password, _options.Password.Len()))
+ }
+ RINOK(_filterAesSpec->WriteHeader(outStream))
+ }
+ else
+ {
+ if (!_cryptoStreamSpec->Filter)
+ {
+ _cryptoStreamSpec->Filter = _filterSpec = new NCrypto::NZip::CEncoder;
+ _filterSpec->CryptoSetPassword((const Byte *)(const char *)_options.Password, _options.Password.Len());
+ }
+
+ UInt32 check;
+
+ if (descriptorMode)
+ {
+ // it's Info-ZIP modification for stream_mode descriptor_mode (bit 3 of the general purpose bit flag is set)
+ check = (fileTime & 0xFFFF);
+ }
+ else
+ {
+ if (!crc_IsCalculated)
+ {
+ RINOK(CalcStreamCRC(inStream, crc))
+ crc_IsCalculated = true;
+ RINOK(InStream_SeekToBegin(inStream2))
+ inSecCrcStreamSpec->Init();
+ }
+ check = (crc >> 16);
+ }
+
+ RINOK(_filterSpec->WriteHeader_Check16(outStream, (UInt16)check))
+ }
+
+ if (method == NCompressionMethod::kStore)
+ {
+ needCode = false;
+ RINOK(_cryptoStreamSpec->Code(inCrcStream, outStream, NULL, NULL, progress))
+ }
+ else
+ {
+ RINOK(_cryptoStreamSpec->SetOutStream(outStream))
+ RINOK(_cryptoStreamSpec->InitEncoder())
+ outStreamReleaser.FilterCoder = _cryptoStreamSpec;
+ }
+ }
+
+ if (needCode)
+ {
+ switch (method)
+ {
+ case NCompressionMethod::kStore:
+ {
+ if (!_copyCoderSpec)
+ {
+ _copyCoderSpec = new NCompress::CCopyCoder;
+ _copyCoder = _copyCoderSpec;
+ }
+ CMyComPtr<ISequentialOutStream> outStreamNew;
+ if (_options.Password_Defined)
+ outStreamNew = _cryptoStream;
+ else
+ outStreamNew = outStream;
+ RINOK(_copyCoder->Code(inCrcStream, outStreamNew, NULL, NULL, progress))
+ break;
+ }
+
+ default:
+ {
+ if (!_compressEncoder)
+ {
+ CLzmaEncoder *_lzmaEncoder = NULL;
+ if (method == NCompressionMethod::kLZMA)
+ {
+ _compressExtractVersion = NCompressionMethod::kExtractVersion_LZMA;
+ _lzmaEncoder = new CLzmaEncoder();
+ _compressEncoder = _lzmaEncoder;
+ }
+ else if (method == NCompressionMethod::kXz)
+ {
+ _compressExtractVersion = NCompressionMethod::kExtractVersion_Xz;
+ NCompress::NXz::CEncoder *encoder = new NCompress::NXz::CEncoder();
+ _compressEncoder = encoder;
+ }
+ else if (method == NCompressionMethod::kPPMd)
+ {
+ _compressExtractVersion = NCompressionMethod::kExtractVersion_PPMd;
+ NCompress::NPpmdZip::CEncoder *encoder = new NCompress::NPpmdZip::CEncoder();
+ _compressEncoder = encoder;
+ }
+ else
+ {
+ CMethodId methodId;
+ switch (method)
+ {
+ case NCompressionMethod::kBZip2:
+ methodId = kMethodId_BZip2;
+ _compressExtractVersion = NCompressionMethod::kExtractVersion_BZip2;
+ break;
+ default:
+ _compressExtractVersion = ((method == NCompressionMethod::kDeflate64) ?
+ NCompressionMethod::kExtractVersion_Deflate64 :
+ NCompressionMethod::kExtractVersion_Deflate);
+ methodId = kMethodId_ZipBase + method;
+ break;
+ }
+ RINOK(CreateCoder_Id(
+ EXTERNAL_CODECS_LOC_VARS
+ methodId, true, _compressEncoder))
+ if (!_compressEncoder)
+ return E_NOTIMPL;
+
+ if (method == NCompressionMethod::kDeflate ||
+ method == NCompressionMethod::kDeflate64)
+ {
+ }
+ else if (method == NCompressionMethod::kBZip2)
+ {
+ }
+ }
+ {
+ CMyComPtr<ICompressSetCoderProperties> setCoderProps;
+ _compressEncoder.QueryInterface(IID_ICompressSetCoderProperties, &setCoderProps);
+ if (setCoderProps)
+ {
+ if (!_options._methods.IsEmpty())
+ {
+ COneMethodInfo *oneMethodMain = &_options._methods[0];
+
+ RINOK(oneMethodMain->SetCoderProps(setCoderProps,
+ _options.DataSizeReduce_Defined ? &_options.DataSizeReduce : NULL))
+ }
+ }
+ }
+ if (method == NCompressionMethod::kLZMA)
+ _isLzmaEos = _lzmaEncoder->EncoderSpec->IsWriteEndMark();
+ }
+
+ if (method == NCompressionMethod::kLZMA)
+ opRes.LzmaEos = _isLzmaEos;
+
+ CMyComPtr<ISequentialOutStream> outStreamNew;
+ if (_options.Password_Defined)
+ outStreamNew = _cryptoStream;
+ else
+ outStreamNew = outStream;
+ if (_compressExtractVersion > opRes.ExtractVersion)
+ opRes.ExtractVersion = _compressExtractVersion;
+
+ {
+ CMyComPtr<ICompressSetCoderPropertiesOpt> optProps;
+ _compressEncoder->QueryInterface(IID_ICompressSetCoderPropertiesOpt, (void **)&optProps);
+ if (optProps)
+ {
+ const PROPID propID = NCoderPropID::kExpectedDataSize;
+ NWindows::NCOM::CPropVariant prop = (UInt64)expectedDataSize;
+ RINOK(optProps->SetCoderPropertiesOpt(&propID, &prop, 1))
+ }
+ }
+
+ try {
+ RINOK(_compressEncoder->Code(inCrcStream, outStreamNew, NULL, NULL, progress))
+ } catch (...) { return E_FAIL; }
+ break;
+ }
+ } // switch end
+
+ if (_options.Password_Defined)
+ {
+ RINOK(_cryptoStreamSpec->OutStreamFinish())
+ }
+ }
+
+ if (_options.Password_Defined)
+ {
+ if (_options.IsAesMode)
+ {
+ RINOK(_filterAesSpec->WriteFooter(outStream))
+ }
+ }
+
+ RINOK(outStream->Seek(0, STREAM_SEEK_CUR, &opRes.PackSize))
+
+ {
+ opRes.CRC = inSecCrcStreamSpec->GetCRC();
+ opRes.UnpackSize = inSecCrcStreamSpec->GetSize();
+ opRes.Method = method;
+ }
+
+ if (!inSecCrcStreamSpec->WasFinished())
+ return E_FAIL;
+
+ if (_options.Password_Defined)
+ {
+ if (opRes.PackSize < opRes.UnpackSize +
+ (_options.IsAesMode ? _filterAesSpec->GetAddPackSize() : NCrypto::NZip::kHeaderSize))
+ break;
+ }
+ else if (opRes.PackSize < opRes.UnpackSize)
+ break;
+ }
+
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipAddCommon.h b/CPP/7zip/Archive/Zip/ZipAddCommon.h
new file mode 100644
index 0000000..051915c
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipAddCommon.h
@@ -0,0 +1,78 @@
+// ZipAddCommon.h
+
+#ifndef ZIP7_INC_ZIP_ADD_COMMON_H
+#define ZIP7_INC_ZIP_ADD_COMMON_H
+
+#include "../../ICoder.h"
+#include "../../IProgress.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/FilterCoder.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../../Crypto/ZipCrypto.h"
+#include "../../Crypto/WzAes.h"
+
+#include "ZipCompressionMode.h"
+
+namespace NArchive {
+namespace NZip {
+
+struct CCompressingResult
+{
+ UInt64 UnpackSize;
+ UInt64 PackSize;
+ UInt32 CRC;
+ UInt16 Method;
+ Byte ExtractVersion;
+ bool DescriptorMode;
+ bool LzmaEos;
+
+ CCompressingResult()
+ {
+ // for GCC:
+ UnpackSize = 0;
+ }
+};
+
+class CAddCommon MY_UNCOPYABLE
+{
+ CCompressionMethodMode _options;
+ NCompress::CCopyCoder *_copyCoderSpec;
+ CMyComPtr<ICompressCoder> _copyCoder;
+
+ CMyComPtr<ICompressCoder> _compressEncoder;
+ Byte _compressExtractVersion;
+ bool _isLzmaEos;
+
+ CFilterCoder *_cryptoStreamSpec;
+ CMyComPtr<ISequentialOutStream> _cryptoStream;
+
+ NCrypto::NZip::CEncoder *_filterSpec;
+ NCrypto::NWzAes::CEncoder *_filterAesSpec;
+
+ Byte *_buf;
+
+ HRESULT CalcStreamCRC(ISequentialInStream *inStream, UInt32 &resultCRC);
+public:
+ // CAddCommon(const CCompressionMethodMode &options);
+ CAddCommon();
+ void SetOptions(const CCompressionMethodMode &options);
+ ~CAddCommon();
+
+ HRESULT Set_Pre_CompressionResult(bool inSeqMode, bool outSeqMode, UInt64 unpackSize,
+ CCompressingResult &opRes) const;
+
+ HRESULT Compress(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ ISequentialInStream *inStream, IOutStream *outStream,
+ bool inSeqMode, bool outSeqMode,
+ UInt32 fileTime,
+ UInt64 expectedDataSize, bool expectedDataSize_IsConfirmed,
+ ICompressProgressInfo *progress, CCompressingResult &opRes);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipCompressionMode.h b/CPP/7zip/Archive/Zip/ZipCompressionMode.h
new file mode 100644
index 0000000..8974261
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipCompressionMode.h
@@ -0,0 +1,62 @@
+// CompressionMode.h
+
+#ifndef ZIP7_INC_ZIP_COMPRESSION_MODE_H
+#define ZIP7_INC_ZIP_COMPRESSION_MODE_H
+
+#include "../../../Common/MyString.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/System.h"
+#endif
+
+#include "../Common/HandlerOut.h"
+
+namespace NArchive {
+namespace NZip {
+
+const CMethodId kMethodId_ZipBase = 0x040100;
+const CMethodId kMethodId_BZip2 = 0x040202;
+
+struct CBaseProps: public CMultiMethodProps
+{
+ bool IsAesMode;
+ Byte AesKeyMode;
+
+ void Init()
+ {
+ CMultiMethodProps::Init();
+
+ IsAesMode = false;
+ AesKeyMode = 3;
+ }
+};
+
+struct CCompressionMethodMode: public CBaseProps
+{
+ CRecordVector<Byte> MethodSequence;
+ AString Password; // _Wipe
+ bool Password_Defined;
+ bool Force_SeqOutMode;
+ bool DataSizeReduce_Defined;
+ UInt64 DataSizeReduce;
+
+ bool IsRealAesMode() const { return Password_Defined && IsAesMode; }
+
+ CCompressionMethodMode()
+ {
+ Password_Defined = false;
+ Force_SeqOutMode = false;
+ DataSizeReduce_Defined = false;
+ DataSizeReduce = 0;
+ }
+
+#ifdef Z7_CPP_IS_SUPPORTED_default
+ CCompressionMethodMode(const CCompressionMethodMode &) = default;
+ CCompressionMethodMode& operator =(const CCompressionMethodMode &) = default;
+#endif
+ ~CCompressionMethodMode() { Password.Wipe_and_Empty(); }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipHandler.cpp b/CPP/7zip/Archive/Zip/ZipHandler.cpp
new file mode 100644
index 0000000..5f022cc
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipHandler.cpp
@@ -0,0 +1,1716 @@
+// ZipHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantUtils.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../IPassword.h"
+
+#include "../../Common/FilterCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#ifdef Z7_EXTERNAL_CODECS
+#ifndef SUPPORT_LZFSE
+#define SUPPORT_LZFSE
+#endif
+#endif
+
+#ifdef SUPPORT_LZFSE
+#include "../../Compress/LzfseDecoder.h"
+#endif
+
+#include "../../Compress/LzmaDecoder.h"
+#include "../../Compress/ImplodeDecoder.h"
+#include "../../Compress/PpmdZip.h"
+#include "../../Compress/ShrinkDecoder.h"
+#include "../../Compress/XzDecoder.h"
+
+#include "../../Crypto/WzAes.h"
+#include "../../Crypto/ZipCrypto.h"
+#include "../../Crypto/ZipStrong.h"
+
+#include "../Common/ItemNameUtils.h"
+#include "../Common/OutStreamWithCRC.h"
+
+
+#include "ZipHandler.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NZip {
+
+static const char * const kHostOS[] =
+{
+ "FAT"
+ , "AMIGA"
+ , "VMS"
+ , "Unix"
+ , "VM/CMS"
+ , "Atari"
+ , "HPFS"
+ , "Macintosh"
+ , "Z-System"
+ , "CP/M"
+ , "TOPS-20"
+ , "NTFS"
+ , "SMS/QDOS"
+ , "Acorn"
+ , "VFAT"
+ , "MVS"
+ , "BeOS"
+ , "Tandem"
+ , "OS/400"
+ , "OS/X"
+};
+
+
+const char * const kMethodNames1[kNumMethodNames1] =
+{
+ "Store"
+ , "Shrink"
+ , "Reduce1"
+ , "Reduce2"
+ , "Reduce3"
+ , "Reduce4"
+ , "Implode"
+ , NULL // "Tokenize"
+ , "Deflate"
+ , "Deflate64"
+ , "PKImploding"
+ , NULL
+ , "BZip2"
+ , NULL
+ , "LZMA"
+ /*
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , NULL
+ , "zstd-pk" // deprecated
+ */
+};
+
+
+const char * const kMethodNames2[kNumMethodNames2] =
+{
+ "zstd"
+ , "MP3"
+ , "xz"
+ , "Jpeg"
+ , "WavPack"
+ , "PPMd"
+ , "LZFSE" // , "WzAES"
+};
+
+#define kMethod_AES "AES"
+#define kMethod_ZipCrypto "ZipCrypto"
+#define kMethod_StrongCrypto "StrongCrypto"
+
+static const char * const kDeflateLevels[4] =
+{
+ "Normal"
+ , "Maximum"
+ , "Fast"
+ , "Fastest"
+};
+
+
+static const CUInt32PCharPair g_HeaderCharacts[] =
+{
+ { 0, "Encrypt" },
+ { 3, "Descriptor" },
+ // { 4, "Enhanced" },
+ // { 5, "Patched" },
+ { 6, kMethod_StrongCrypto },
+ { 11, "UTF8" },
+ { 14, "Alt" }
+};
+
+struct CIdToNamePair
+{
+ unsigned Id;
+ const char *Name;
+};
+
+
+static const CIdToNamePair k_StrongCryptoPairs[] =
+{
+ { NStrongCrypto_AlgId::kDES, "DES" },
+ { NStrongCrypto_AlgId::kRC2old, "RC2a" },
+ { NStrongCrypto_AlgId::k3DES168, "3DES-168" },
+ { NStrongCrypto_AlgId::k3DES112, "3DES-112" },
+ { NStrongCrypto_AlgId::kAES128, "pkAES-128" },
+ { NStrongCrypto_AlgId::kAES192, "pkAES-192" },
+ { NStrongCrypto_AlgId::kAES256, "pkAES-256" },
+ { NStrongCrypto_AlgId::kRC2, "RC2" },
+ { NStrongCrypto_AlgId::kBlowfish, "Blowfish" },
+ { NStrongCrypto_AlgId::kTwofish, "Twofish" },
+ { NStrongCrypto_AlgId::kRC4, "RC4" }
+};
+
+static const char *FindNameForId(const CIdToNamePair *pairs, unsigned num, unsigned id)
+{
+ for (unsigned i = 0; i < num; i++)
+ {
+ const CIdToNamePair &pair = pairs[i];
+ if (id == pair.Id)
+ return pair.Name;
+ }
+ return NULL;
+}
+
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ kpidAttrib,
+ // kpidPosixAttrib,
+ kpidEncrypted,
+ kpidComment,
+ kpidCRC,
+ kpidMethod,
+ kpidCharacts,
+ kpidHostOS,
+ kpidUnpackVer,
+ kpidVolumeIndex,
+ kpidOffset
+ // kpidIsAltStream
+ // , kpidChangeTime // for debug
+ // , 255 // for debug
+};
+
+static const Byte kArcProps[] =
+{
+ kpidEmbeddedStubSize,
+ kpidBit64,
+ kpidComment,
+ kpidCharacts,
+ kpidTotalPhySize,
+ kpidIsVolume,
+ kpidVolumeIndex,
+ kpidNumVolumes
+};
+
+CHandler::CHandler()
+{
+ InitMethodProps();
+}
+
+static AString BytesToString(const CByteBuffer &data)
+{
+ AString s;
+ s.SetFrom_CalcLen((const char *)(const Byte *)data, (unsigned)data.Size());
+ return s;
+}
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidBit64: if (m_Archive.IsZip64) prop = m_Archive.IsZip64; break;
+ case kpidComment: if (m_Archive.ArcInfo.Comment.Size() != 0) prop = MultiByteToUnicodeString(BytesToString(m_Archive.ArcInfo.Comment), CP_ACP); break;
+
+ case kpidPhySize: prop = m_Archive.GetPhySize(); break;
+ case kpidOffset: prop = m_Archive.GetOffset(); break;
+
+ case kpidEmbeddedStubSize:
+ {
+ UInt64 stubSize = m_Archive.GetEmbeddedStubSize();
+ if (stubSize != 0)
+ prop = stubSize;
+ break;
+ }
+
+ case kpidTotalPhySize: if (m_Archive.IsMultiVol) prop = m_Archive.Vols.TotalBytesSize; break;
+ case kpidVolumeIndex: if (m_Archive.IsMultiVol) prop = (UInt32)m_Archive.Vols.StartVolIndex; break;
+ case kpidIsVolume: if (m_Archive.IsMultiVol) prop = true; break;
+ case kpidNumVolumes: if (m_Archive.IsMultiVol) prop = (UInt32)m_Archive.Vols.Streams.Size(); break;
+
+ case kpidCharacts:
+ {
+ AString s;
+
+ if (m_Archive.LocalsWereRead)
+ {
+ s.Add_OptSpaced("Local");
+
+ if (m_Archive.LocalsCenterMerged)
+ s.Add_OptSpaced("Central");
+ }
+
+ if (m_Archive.IsZip64)
+ s.Add_OptSpaced("Zip64");
+
+ if (m_Archive.IsCdUnsorted)
+ s.Add_OptSpaced("Unsorted_CD");
+
+ if (m_Archive.IsApk)
+ s.Add_OptSpaced("apk");
+
+ if (m_Archive.ExtraMinorError)
+ s.Add_OptSpaced("Minor_Extra_ERROR");
+
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidWarningFlags:
+ {
+ UInt32 v = 0;
+ // if (m_Archive.ExtraMinorError) v |= kpv_ErrorFlags_HeadersError;
+ if (m_Archive.HeadersWarning) v |= kpv_ErrorFlags_HeadersError;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+
+ case kpidWarning:
+ {
+ AString s;
+ if (m_Archive.Overflow32bit)
+ s.Add_OptSpaced("32-bit overflow in headers");
+ if (m_Archive.Cd_NumEntries_Overflow_16bit)
+ s.Add_OptSpaced("16-bit overflow for number of files in headers");
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidError:
+ {
+ if (!m_Archive.Vols.MissingName.IsEmpty())
+ {
+ UString s("Missing volume : ");
+ s += m_Archive.Vols.MissingName;
+ prop = s;
+ }
+ break;
+ }
+
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!m_Archive.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+ if (m_Archive.HeadersError) v |= kpv_ErrorFlags_HeadersError;
+ if (m_Archive.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (m_Archive.ArcInfo.Base < 0)
+ {
+ /* We try to support case when we have sfx-zip with embedded stub,
+ but the stream has access only to zip part.
+ In that case we ignore UnavailableStart error.
+ maybe we must show warning in that case. */
+ UInt64 stubSize = m_Archive.GetEmbeddedStubSize();
+ if (stubSize < (UInt64)-m_Archive.ArcInfo.Base)
+ v |= kpv_ErrorFlags_UnavailableStart;
+ }
+ if (m_Archive.NoCentralDir) v |= kpv_ErrorFlags_UnconfirmedStart;
+ prop = v;
+ break;
+ }
+
+ case kpidReadOnly:
+ {
+ if (m_Archive.IsOpen())
+ if (!m_Archive.CanUpdate())
+ prop = true;
+ break;
+ }
+
+ // case kpidIsAltStream: prop = true; break;
+ }
+ return prop.Detach(value);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = m_Items.Size();
+ return S_OK;
+}
+
+
+static bool NtfsUnixTimeToProp(bool fromCentral,
+ const CExtraBlock &extra,
+ unsigned ntfsIndex, unsigned unixIndex, NWindows::NCOM::CPropVariant &prop)
+{
+ {
+ FILETIME ft;
+ if (extra.GetNtfsTime(ntfsIndex, ft))
+ {
+ PropVariant_SetFrom_NtfsTime(prop, ft);
+ return true;
+ }
+ }
+ {
+ UInt32 unixTime = 0;
+ if (!extra.GetUnixTime(fromCentral, unixIndex, unixTime))
+ return false;
+ /*
+ // we allow unixTime == 0
+ if (unixTime == 0)
+ return false;
+ */
+ PropVariant_SetFrom_UnixTime(prop, unixTime);
+ return true;
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ const CItemEx &item = m_Items[index];
+ const CExtraBlock &extra = item.GetMainExtra();
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ UString res;
+ item.GetUnicodeString(res, item.Name, false, _forceCodePage, _specifiedCodePage);
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(res,
+ item.Is_MadeBy_Unix() // useBackslashReplacement
+ );
+ /*
+ if (item.ParentOfAltStream >= 0)
+ {
+ const CItemEx &prevItem = m_Items[item.ParentOfAltStream];
+ UString prevName;
+ prevItem.GetUnicodeString(prevName, prevItem.Name, false, _forceCodePage, _specifiedCodePage);
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(prevName);
+ if (res.IsPrefixedBy(prevName))
+ if (IsString1PrefixedByString2(res.Ptr(prevName.Len()), k_SpecName_NTFS_STREAM))
+ {
+ res.Delete(prevName.Len(), (unsigned)strlen(k_SpecName_NTFS_STREAM));
+ res.Insert(prevName.Len(), L":");
+ }
+ }
+ */
+ prop = res;
+ break;
+ }
+
+ case kpidIsDir: prop = item.IsDir(); break;
+ case kpidSize:
+ {
+ if (!item.IsBadDescriptor())
+ prop = item.Size;
+ break;
+ }
+
+ case kpidPackSize: prop = item.PackSize; break;
+
+ case kpidCTime:
+ NtfsUnixTimeToProp(item.FromCentral, extra,
+ NFileHeader::NNtfsExtra::kCTime,
+ NFileHeader::NUnixTime::kCTime, prop);
+ break;
+
+ case kpidATime:
+ NtfsUnixTimeToProp(item.FromCentral, extra,
+ NFileHeader::NNtfsExtra::kATime,
+ NFileHeader::NUnixTime::kATime, prop);
+ break;
+
+ case kpidMTime:
+ {
+ if (!NtfsUnixTimeToProp(item.FromCentral, extra,
+ NFileHeader::NNtfsExtra::kMTime,
+ NFileHeader::NUnixTime::kMTime, prop))
+ {
+ if (item.Time != 0)
+ PropVariant_SetFrom_DosTime(prop, item.Time);
+ }
+ break;
+ }
+
+ case kpidTimeType:
+ {
+ FILETIME ft;
+ UInt32 unixTime;
+ UInt32 type;
+ if (extra.GetNtfsTime(NFileHeader::NNtfsExtra::kMTime, ft))
+ type = NFileTimeType::kWindows;
+ else if (extra.GetUnixTime(item.FromCentral, NFileHeader::NUnixTime::kMTime, unixTime))
+ type = NFileTimeType::kUnix;
+ else
+ type = NFileTimeType::kDOS;
+ prop = type;
+ break;
+ }
+
+ /*
+ // for debug to get Dos time values:
+ case kpidChangeTime: if (item.Time != 0) PropVariant_SetFrom_DosTime(prop, item.Time); break;
+ // for debug
+ // time difference (dos - utc)
+ case 255:
+ {
+ if (NtfsUnixTimeToProp(item.FromCentral, extra,
+ NFileHeader::NNtfsExtra::kMTime,
+ NFileHeader::NUnixTime::kMTime, prop))
+ {
+ FILETIME localFileTime;
+ if (item.Time != 0 && NTime::DosTime_To_FileTime(item.Time, localFileTime))
+ {
+ UInt64 t1 = FILETIME_To_UInt64(prop.filetime);
+ UInt64 t2 = FILETIME_To_UInt64(localFileTime);
+ prop.Set_Int64(t2 - t1);
+ }
+ }
+ break;
+ }
+ */
+
+ case kpidAttrib: prop = item.GetWinAttrib(); break;
+
+ case kpidPosixAttrib:
+ {
+ UInt32 attrib;
+ if (item.GetPosixAttrib(attrib))
+ prop = attrib;
+ break;
+ }
+
+ case kpidEncrypted: prop = item.IsEncrypted(); break;
+
+ case kpidComment:
+ {
+ if (item.Comment.Size() != 0)
+ {
+ UString res;
+ item.GetUnicodeString(res, BytesToString(item.Comment), true, _forceCodePage, _specifiedCodePage);
+ prop = res;
+ }
+ break;
+ }
+
+ case kpidCRC: if (item.IsThereCrc()) prop = item.Crc; break;
+
+ case kpidMethod:
+ {
+ AString m;
+ bool isWzAes = false;
+ unsigned id = item.Method;
+
+ if (id == NFileHeader::NCompressionMethod::kWzAES)
+ {
+ CWzAesExtra aesField;
+ if (extra.GetWzAes(aesField))
+ {
+ m += kMethod_AES;
+ m.Add_Minus();
+ m.Add_UInt32(((unsigned)aesField.Strength + 1) * 64);
+ id = aesField.Method;
+ isWzAes = true;
+ }
+ }
+
+ if (item.IsEncrypted())
+ if (!isWzAes)
+ {
+ if (item.IsStrongEncrypted())
+ {
+ CStrongCryptoExtra f;
+ f.AlgId = 0;
+ if (extra.GetStrongCrypto(f))
+ {
+ const char *s = FindNameForId(k_StrongCryptoPairs, Z7_ARRAY_SIZE(k_StrongCryptoPairs), f.AlgId);
+ if (s)
+ m += s;
+ else
+ {
+ m += kMethod_StrongCrypto;
+ m += ':';
+ m.Add_UInt32(f.AlgId);
+ }
+ if (f.CertificateIsUsed())
+ m += "-Cert";
+ }
+ else
+ m += kMethod_StrongCrypto;
+ }
+ else
+ m += kMethod_ZipCrypto;
+ }
+
+ m.Add_Space_if_NotEmpty();
+
+ {
+ const char *s = NULL;
+ if (id < kNumMethodNames1)
+ s = kMethodNames1[id];
+ else
+ {
+ int id2 = (int)id - (int)kMethodNames2Start;
+ if (id2 >= 0 && (unsigned)id2 < kNumMethodNames2)
+ s = kMethodNames2[id2];
+ }
+ if (s)
+ m += s;
+ else
+ m.Add_UInt32(id);
+ }
+ {
+ unsigned level = item.GetDeflateLevel();
+ if (level != 0)
+ {
+ if (id == NFileHeader::NCompressionMethod::kLZMA)
+ {
+ if (level & 1)
+ m += ":eos";
+ level &= ~(unsigned)1;
+ }
+ else if (id == NFileHeader::NCompressionMethod::kDeflate)
+ {
+ m += ':';
+ m += kDeflateLevels[level];
+ level = 0;
+ }
+
+ if (level != 0)
+ {
+ m += ":v";
+ m.Add_UInt32(level);
+ }
+ }
+ }
+
+ prop = m;
+ break;
+ }
+
+ case kpidCharacts:
+ {
+ AString s;
+
+ if (item.FromLocal)
+ {
+ s.Add_OptSpaced("Local");
+
+ item.LocalExtra.PrintInfo(s);
+
+ if (item.FromCentral)
+ {
+ s.Add_OptSpaced(":");
+ s.Add_OptSpaced("Central");
+ }
+ }
+
+ if (item.FromCentral)
+ {
+ item.CentralExtra.PrintInfo(s);
+ }
+
+ UInt32 flags = item.Flags;
+ flags &= ~(unsigned)6; // we don't need compression related bits here.
+
+ if (flags != 0)
+ {
+ const AString s2 = FlagsToString(g_HeaderCharacts, Z7_ARRAY_SIZE(g_HeaderCharacts), flags);
+ if (!s2.IsEmpty())
+ {
+ if (!s.IsEmpty())
+ s.Add_OptSpaced(":");
+ s.Add_OptSpaced(s2);
+ }
+ }
+
+ if (item.IsBadDescriptor())
+ s.Add_OptSpaced("Descriptor_ERROR");
+
+ if (!s.IsEmpty())
+ prop = s;
+ break;
+ }
+
+ case kpidHostOS:
+ {
+ if (item.FromCentral)
+ {
+ // 18.06: now we use HostOS only from Central::MadeByVersion
+ const Byte hostOS = item.MadeByVersion.HostOS;
+ TYPE_TO_PROP(kHostOS, hostOS, prop);
+ }
+ break;
+ }
+
+ case kpidUnpackVer:
+ prop = (UInt32)item.ExtractVersion.Version;
+ break;
+
+ case kpidVolumeIndex:
+ prop = item.Disk;
+ break;
+
+ case kpidOffset:
+ prop = item.LocalHeaderPos;
+ break;
+
+ /*
+ case kpidIsAltStream:
+ prop = (bool)(item.ParentOfAltStream >= 0); // item.IsAltStream();
+ break;
+
+ case kpidName:
+ if (item.ParentOfAltStream >= 0)
+ {
+ // extract name of stream here
+ }
+ break;
+ */
+ }
+
+ return prop.Detach(value);
+ COM_TRY_END
+}
+
+
+
+/*
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps)
+{
+ *numProps = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID)
+{
+ UNUSED_VAR(index);
+ *propID = 0;
+ *name = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType)
+{
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+ if (index >= m_Items.Size())
+ return S_OK;
+ const CItemEx &item = m_Items[index];
+
+ if (item.ParentOfAltStream >= 0)
+ {
+ *parentType = NParentType::kAltStream;
+ *parent = item.ParentOfAltStream;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)
+{
+ UNUSED_VAR(index);
+ UNUSED_VAR(propID);
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ return S_OK;
+}
+
+
+void CHandler::MarkAltStreams(CObjectVector<CItemEx> &items)
+{
+ int prevIndex = -1;
+ UString prevName;
+ UString name;
+
+ for (unsigned i = 0; i < items.Size(); i++)
+ {
+ CItemEx &item = m_Items[i];
+ if (item.IsAltStream())
+ {
+ if (prevIndex == -1)
+ continue;
+ if (prevName.IsEmpty())
+ {
+ const CItemEx &prevItem = m_Items[prevIndex];
+ prevItem.GetUnicodeString(prevName, prevItem.Name, false, _forceCodePage, _specifiedCodePage);
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(prevName);
+ }
+ name.Empty();
+ item.GetUnicodeString(name, item.Name, false, _forceCodePage, _specifiedCodePage);
+ NItemName::ReplaceToOsSlashes_Remove_TailSlash(name);
+
+ if (name.IsPrefixedBy(prevName))
+ if (IsString1PrefixedByString2(name.Ptr(prevName.Len()), k_SpecName_NTFS_STREAM))
+ item.ParentOfAltStream = prevIndex;
+ }
+ else
+ {
+ prevIndex = i;
+ prevName.Empty();
+ }
+ }
+}
+*/
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *inStream,
+ const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback))
+{
+ COM_TRY_BEGIN
+ try
+ {
+ Close();
+ m_Archive.Force_ReadLocals_Mode = _force_OpenSeq;
+ // m_Archive.Disable_VolsRead = _force_OpenSeq;
+ // m_Archive.Disable_FindMarker = _force_OpenSeq;
+ HRESULT res = m_Archive.Open(inStream, maxCheckStartPosition, callback, m_Items);
+ if (res != S_OK)
+ {
+ m_Items.Clear();
+ m_Archive.ClearRefs(); // we don't want to clear error flags
+ }
+ // MarkAltStreams(m_Items);
+ return res;
+ }
+ catch(...) { Close(); throw; }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ m_Items.Clear();
+ m_Archive.Close();
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_NOQIB_3(
+ CLzmaDecoder
+ , ICompressCoder
+ , ICompressSetFinishMode
+ , ICompressGetInStreamProcessedSize
+)
+public:
+ NCompress::NLzma::CDecoder *DecoderSpec;
+ CMyComPtr<ICompressCoder> Decoder;
+
+ CLzmaDecoder();
+};
+
+CLzmaDecoder::CLzmaDecoder()
+{
+ DecoderSpec = new NCompress::NLzma::CDecoder;
+ Decoder = DecoderSpec;
+}
+
+static const unsigned kZipLzmaPropsSize = 4 + LZMA_PROPS_SIZE;
+
+Z7_COM7F_IMF(CLzmaDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ Byte buf[kZipLzmaPropsSize];
+ RINOK(ReadStream_FALSE(inStream, buf, kZipLzmaPropsSize))
+ if (buf[2] != LZMA_PROPS_SIZE || buf[3] != 0)
+ return E_NOTIMPL;
+ RINOK(DecoderSpec->SetDecoderProperties2(buf + 4, LZMA_PROPS_SIZE))
+ UInt64 inSize2 = 0;
+ if (inSize)
+ {
+ inSize2 = *inSize;
+ if (inSize2 < kZipLzmaPropsSize)
+ return S_FALSE;
+ inSize2 -= kZipLzmaPropsSize;
+ }
+ return Decoder->Code(inStream, outStream, inSize ? &inSize2 : NULL, outSize, progress);
+}
+
+Z7_COM7F_IMF(CLzmaDecoder::SetFinishMode(UInt32 finishMode))
+{
+ DecoderSpec->FinishStream = (finishMode != 0);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CLzmaDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = DecoderSpec->GetInputProcessedSize() + kZipLzmaPropsSize;
+ return S_OK;
+}
+
+
+
+
+
+
+
+struct CMethodItem
+{
+ unsigned ZipMethod;
+ CMyComPtr<ICompressCoder> Coder;
+};
+
+
+
+class CZipDecoder
+{
+ NCrypto::NZip::CDecoder *_zipCryptoDecoderSpec;
+ NCrypto::NZipStrong::CDecoder *_pkAesDecoderSpec;
+ NCrypto::NWzAes::CDecoder *_wzAesDecoderSpec;
+
+ CMyComPtr<ICompressFilter> _zipCryptoDecoder;
+ CMyComPtr<ICompressFilter> _pkAesDecoder;
+ CMyComPtr<ICompressFilter> _wzAesDecoder;
+
+ CFilterCoder *filterStreamSpec;
+ CMyComPtr<ISequentialInStream> filterStream;
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ CObjectVector<CMethodItem> methodItems;
+
+ CLzmaDecoder *lzmaDecoderSpec;
+public:
+ CZipDecoder():
+ _zipCryptoDecoderSpec(NULL),
+ _pkAesDecoderSpec(NULL),
+ _wzAesDecoderSpec(NULL),
+ filterStreamSpec(NULL),
+ lzmaDecoderSpec(NULL)
+ {}
+
+ HRESULT Decode(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CInArchive &archive, const CItemEx &item,
+ ISequentialOutStream *realOutStream,
+ IArchiveExtractCallback *extractCallback,
+ ICompressProgressInfo *compressProgress,
+ #ifndef Z7_ST
+ UInt32 numThreads, UInt64 memUsage,
+ #endif
+ Int32 &res);
+};
+
+
+static HRESULT SkipStreamData(ISequentialInStream *stream,
+ ICompressProgressInfo *progress, UInt64 packSize, UInt64 unpackSize,
+ bool &thereAreData)
+{
+ thereAreData = false;
+ const size_t kBufSize = 1 << 12;
+ Byte buf[kBufSize];
+ UInt64 prev = packSize;
+ for (;;)
+ {
+ size_t size = kBufSize;
+ RINOK(ReadStream(stream, buf, &size))
+ if (size == 0)
+ return S_OK;
+ thereAreData = true;
+ packSize += size;
+ if ((packSize - prev) >= (1 << 22))
+ {
+ prev = packSize;
+ RINOK(progress->SetRatioInfo(&packSize, &unpackSize))
+ }
+ }
+}
+
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithPadPKCS7
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+ UInt64 _padPos;
+ UInt32 _padSize;
+ bool _padFailure;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+
+ // padSize == 0 means (no_pad Mode)
+ void Init(UInt64 padPos, UInt32 padSize)
+ {
+ _padPos = padPos;
+ _padSize = padSize;
+ _size = 0;
+ _padFailure = false;
+ }
+ UInt64 GetSize() const { return _size; }
+ bool WasPadFailure() const { return _padFailure; }
+};
+
+
+Z7_COM7F_IMF(COutStreamWithPadPKCS7::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 written = 0;
+ HRESULT result = S_OK;
+ if (_size < _padPos)
+ {
+ const UInt64 rem = _padPos - _size;
+ UInt32 num = size;
+ if (num > rem)
+ num = (UInt32)rem;
+ result = _stream->Write(data, num, &written);
+ _size += written;
+ if (processedSize)
+ *processedSize = written;
+ if (_size != _padPos || result != S_OK)
+ return result;
+ size -= written;
+ data = ((const Byte *)data) + written;
+ }
+ _size += size;
+ written += size;
+ if (processedSize)
+ *processedSize = written;
+ if (_padSize != 0)
+ for (; size != 0; size--)
+ {
+ if (*(const Byte *)data != _padSize)
+ _padFailure = true;
+ data = ((const Byte *)data) + 1;
+ }
+ return result;
+}
+
+
+
+HRESULT CZipDecoder::Decode(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CInArchive &archive, const CItemEx &item,
+ ISequentialOutStream *realOutStream,
+ IArchiveExtractCallback *extractCallback,
+ ICompressProgressInfo *compressProgress,
+ #ifndef Z7_ST
+ UInt32 numThreads, UInt64 memUsage,
+ #endif
+ Int32 &res)
+{
+ res = NExtract::NOperationResult::kHeadersError;
+
+ CFilterCoder::C_InStream_Releaser inStreamReleaser;
+ CFilterCoder::C_Filter_Releaser filterReleaser;
+
+ bool needCRC = true;
+ bool wzAesMode = false;
+ bool pkAesMode = false;
+
+ bool badDescriptor = item.IsBadDescriptor();
+ if (badDescriptor)
+ needCRC = false;
+
+
+ unsigned id = item.Method;
+
+ CWzAesExtra aesField;
+ // LZFSE and WinZip's AES use same id - kWzAES.
+
+ if (id == NFileHeader::NCompressionMethod::kWzAES)
+ {
+ if (item.GetMainExtra().GetWzAes(aesField))
+ {
+ if (!item.IsEncrypted())
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ return S_OK;
+ }
+ wzAesMode = true;
+ needCRC = aesField.NeedCrc();
+ }
+ }
+
+ if (!wzAesMode)
+ if (item.IsEncrypted())
+ {
+ if (item.IsStrongEncrypted())
+ {
+ CStrongCryptoExtra f;
+ if (!item.CentralExtra.GetStrongCrypto(f))
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ return S_OK;
+ }
+ pkAesMode = true;
+ }
+ }
+
+ COutStreamWithCRC *outStreamSpec = new COutStreamWithCRC;
+ CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+ outStreamSpec->SetStream(realOutStream);
+ outStreamSpec->Init(needCRC);
+
+ CMyComPtr<ISequentialInStream> packStream;
+
+ CLimitedSequentialInStream *limitedStreamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(limitedStreamSpec);
+
+ {
+ UInt64 packSize = item.PackSize;
+ if (wzAesMode)
+ {
+ if (packSize < NCrypto::NWzAes::kMacSize)
+ return S_OK;
+ packSize -= NCrypto::NWzAes::kMacSize;
+ }
+ RINOK(archive.GetItemStream(item, true, packStream))
+ if (!packStream)
+ {
+ res = NExtract::NOperationResult::kUnavailable;
+ return S_OK;
+ }
+ limitedStreamSpec->SetStream(packStream);
+ limitedStreamSpec->Init(packSize);
+ }
+
+
+ res = NExtract::NOperationResult::kDataError;
+
+ CMyComPtr<ICompressFilter> cryptoFilter;
+
+ if (item.IsEncrypted())
+ {
+ if (wzAesMode)
+ {
+ id = aesField.Method;
+ if (!_wzAesDecoder)
+ {
+ _wzAesDecoderSpec = new NCrypto::NWzAes::CDecoder;
+ _wzAesDecoder = _wzAesDecoderSpec;
+ }
+ cryptoFilter = _wzAesDecoder;
+ if (!_wzAesDecoderSpec->SetKeyMode(aesField.Strength))
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ return S_OK;
+ }
+ }
+ else if (pkAesMode)
+ {
+ if (!_pkAesDecoder)
+ {
+ _pkAesDecoderSpec = new NCrypto::NZipStrong::CDecoder;
+ _pkAesDecoder = _pkAesDecoderSpec;
+ }
+ cryptoFilter = _pkAesDecoder;
+ }
+ else
+ {
+ if (!_zipCryptoDecoder)
+ {
+ _zipCryptoDecoderSpec = new NCrypto::NZip::CDecoder;
+ _zipCryptoDecoder = _zipCryptoDecoderSpec;
+ }
+ cryptoFilter = _zipCryptoDecoder;
+ }
+
+ CMyComPtr<ICryptoSetPassword> cryptoSetPassword;
+ RINOK(cryptoFilter.QueryInterface(IID_ICryptoSetPassword, &cryptoSetPassword))
+ if (!cryptoSetPassword)
+ return E_FAIL;
+
+ if (!getTextPassword)
+ extractCallback->QueryInterface(IID_ICryptoGetTextPassword, (void **)&getTextPassword);
+
+ if (getTextPassword)
+ {
+ CMyComBSTR_Wipe password;
+ RINOK(getTextPassword->CryptoGetTextPassword(&password))
+ AString_Wipe charPassword;
+ if (password)
+ {
+ /*
+ // 22.00: do we need UTF-8 passwords here ?
+ if (item.IsUtf8()) // 22.00
+ {
+ // throw 1;
+ ConvertUnicodeToUTF8((LPCOLESTR)password, charPassword);
+ }
+ else
+ */
+ {
+ UnicodeStringToMultiByte2(charPassword, (LPCOLESTR)password, CP_ACP);
+ }
+ /*
+ if (wzAesMode || pkAesMode)
+ {
+ }
+ else
+ {
+ // PASSWORD encoding for ZipCrypto:
+ // pkzip25 / WinZip / Windows probably use ANSI
+ // 7-Zip < 4.43 creates ZIP archives with OEM encoding in password
+ // 7-Zip >= 4.43 creates ZIP archives only with ASCII characters in password
+ // 7-Zip < 17.00 uses CP_OEMCP for password decoding
+ // 7-Zip >= 17.00 uses CP_ACP for password decoding
+ }
+ */
+ }
+ HRESULT result = cryptoSetPassword->CryptoSetPassword(
+ (const Byte *)(const char *)charPassword, charPassword.Len());
+ if (result != S_OK)
+ {
+ res = NExtract::NOperationResult::kWrongPassword;
+ return S_OK;
+ }
+ }
+ else
+ {
+ res = NExtract::NOperationResult::kWrongPassword;
+ return S_OK;
+ // RINOK(cryptoSetPassword->CryptoSetPassword(NULL, 0));
+ }
+ }
+
+ unsigned m;
+ for (m = 0; m < methodItems.Size(); m++)
+ if (methodItems[m].ZipMethod == id)
+ break;
+
+ if (m == methodItems.Size())
+ {
+ CMethodItem mi;
+ mi.ZipMethod = id;
+ if (id == NFileHeader::NCompressionMethod::kStore)
+ mi.Coder = new NCompress::CCopyCoder;
+ else if (id == NFileHeader::NCompressionMethod::kShrink)
+ mi.Coder = new NCompress::NShrink::CDecoder;
+ else if (id == NFileHeader::NCompressionMethod::kImplode)
+ mi.Coder = new NCompress::NImplode::NDecoder::CCoder;
+ else if (id == NFileHeader::NCompressionMethod::kLZMA)
+ {
+ lzmaDecoderSpec = new CLzmaDecoder;
+ mi.Coder = lzmaDecoderSpec;
+ }
+ else if (id == NFileHeader::NCompressionMethod::kXz)
+ mi.Coder = new NCompress::NXz::CComDecoder;
+ else if (id == NFileHeader::NCompressionMethod::kPPMd)
+ mi.Coder = new NCompress::NPpmdZip::CDecoder(true);
+ #ifdef SUPPORT_LZFSE
+ else if (id == NFileHeader::NCompressionMethod::kWzAES)
+ mi.Coder = new NCompress::NLzfse::CDecoder;
+ #endif
+ else
+ {
+ CMethodId szMethodID;
+ if (id == NFileHeader::NCompressionMethod::kBZip2)
+ szMethodID = kMethodId_BZip2;
+ else
+ {
+ if (id > 0xFF)
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ return S_OK;
+ }
+ szMethodID = kMethodId_ZipBase + (Byte)id;
+ }
+
+ RINOK(CreateCoder_Id(EXTERNAL_CODECS_LOC_VARS szMethodID, false, mi.Coder))
+
+ if (!mi.Coder)
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ return S_OK;
+ }
+ }
+ m = methodItems.Add(mi);
+ }
+
+ const CMethodItem &mi = methodItems[m];
+ ICompressCoder *coder = mi.Coder;
+
+
+ #ifndef Z7_ST
+ {
+ CMyComPtr<ICompressSetCoderMt> setCoderMt;
+ coder->QueryInterface(IID_ICompressSetCoderMt, (void **)&setCoderMt);
+ if (setCoderMt)
+ {
+ RINOK(setCoderMt->SetNumberOfThreads(numThreads))
+ }
+ }
+ // if (memUsage != 0)
+ {
+ CMyComPtr<ICompressSetMemLimit> setMemLimit;
+ coder->QueryInterface(IID_ICompressSetMemLimit, (void **)&setMemLimit);
+ if (setMemLimit)
+ {
+ RINOK(setMemLimit->SetMemLimit(memUsage))
+ }
+ }
+ #endif
+
+ {
+ CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
+ coder->QueryInterface(IID_ICompressSetDecoderProperties2, (void **)&setDecoderProperties);
+ if (setDecoderProperties)
+ {
+ Byte properties = (Byte)item.Flags;
+ RINOK(setDecoderProperties->SetDecoderProperties2(&properties, 1))
+ }
+ }
+
+
+ bool isFullStreamExpected = (!item.HasDescriptor() || item.PackSize != 0);
+ bool needReminderCheck = false;
+
+ bool dataAfterEnd = false;
+ bool truncatedError = false;
+ bool lzmaEosError = false;
+ bool headersError = false;
+ bool padError = false;
+ bool readFromFilter = false;
+
+ const bool useUnpackLimit = (id == NFileHeader::NCompressionMethod::kStore
+ || !item.HasDescriptor()
+ || item.Size >= ((UInt64)1 << 32)
+ || item.LocalExtra.IsZip64
+ || item.CentralExtra.IsZip64
+ );
+
+ {
+ HRESULT result = S_OK;
+ if (item.IsEncrypted())
+ {
+ if (!filterStream)
+ {
+ filterStreamSpec = new CFilterCoder(false);
+ filterStream = filterStreamSpec;
+ }
+
+ filterReleaser.FilterCoder = filterStreamSpec;
+ filterStreamSpec->Filter = cryptoFilter;
+
+ if (wzAesMode)
+ {
+ result = _wzAesDecoderSpec->ReadHeader(inStream);
+ if (result == S_OK)
+ {
+ if (!_wzAesDecoderSpec->Init_and_CheckPassword())
+ {
+ res = NExtract::NOperationResult::kWrongPassword;
+ return S_OK;
+ }
+ }
+ }
+ else if (pkAesMode)
+ {
+ isFullStreamExpected = false;
+ result =_pkAesDecoderSpec->ReadHeader(inStream, item.Crc, item.Size);
+ if (result == S_OK)
+ {
+ bool passwOK;
+ result = _pkAesDecoderSpec->Init_and_CheckPassword(passwOK);
+ if (result == S_OK && !passwOK)
+ {
+ res = NExtract::NOperationResult::kWrongPassword;
+ return S_OK;
+ }
+ }
+ }
+ else
+ {
+ result = _zipCryptoDecoderSpec->ReadHeader(inStream);
+ if (result == S_OK)
+ {
+ _zipCryptoDecoderSpec->Init_BeforeDecode();
+
+ /* Info-ZIP modification to ZipCrypto format:
+ if bit 3 of the general purpose bit flag is set,
+ it uses high byte of 16-bit File Time.
+ Info-ZIP code probably writes 2 bytes of File Time.
+ We check only 1 byte. */
+
+ // UInt32 v1 = GetUi16(_zipCryptoDecoderSpec->_header + NCrypto::NZip::kHeaderSize - 2);
+ // UInt32 v2 = (item.HasDescriptor() ? (item.Time & 0xFFFF) : (item.Crc >> 16));
+
+ Byte v1 = _zipCryptoDecoderSpec->_header[NCrypto::NZip::kHeaderSize - 1];
+ Byte v2 = (Byte)(item.HasDescriptor() ? (item.Time >> 8) : (item.Crc >> 24));
+
+ if (v1 != v2)
+ {
+ res = NExtract::NOperationResult::kWrongPassword;
+ return S_OK;
+ }
+ }
+ }
+ }
+
+ if (result == S_OK)
+ {
+ CMyComPtr<ICompressSetFinishMode> setFinishMode;
+ coder->QueryInterface(IID_ICompressSetFinishMode, (void **)&setFinishMode);
+ if (setFinishMode)
+ {
+ RINOK(setFinishMode->SetFinishMode(BoolToUInt(true)))
+ }
+
+ const UInt64 coderPackSize = limitedStreamSpec->GetRem();
+
+ if (id == NFileHeader::NCompressionMethod::kStore && item.IsEncrypted())
+ {
+ // for debug : we can disable this code (kStore + 50), if we want to test CopyCoder+Filter
+ // here we use filter without CopyCoder
+ readFromFilter = false;
+
+ COutStreamWithPadPKCS7 *padStreamSpec = NULL;
+ CMyComPtr<ISequentialOutStream> padStream;
+ UInt32 padSize = 0;
+
+ if (pkAesMode)
+ {
+ padStreamSpec = new COutStreamWithPadPKCS7;
+ padStream = padStreamSpec;
+ padSize = _pkAesDecoderSpec->GetPadSize((UInt32)item.Size);
+ padStreamSpec->SetStream(outStream);
+ padStreamSpec->Init(item.Size, padSize);
+ }
+
+ // Here we decode minimal required size, including padding
+ const UInt64 expectedSize = item.Size + padSize;
+ UInt64 size = coderPackSize;
+ if (item.Size > coderPackSize)
+ headersError = true;
+ else if (expectedSize != coderPackSize)
+ {
+ headersError = true;
+ if (coderPackSize > expectedSize)
+ size = expectedSize;
+ }
+
+ result = filterStreamSpec->Code(inStream, padStream ?
+ (ISequentialOutStream *)padStream :
+ (ISequentialOutStream *)outStream,
+ NULL, &size, compressProgress);
+
+ if (outStreamSpec->GetSize() != item.Size)
+ truncatedError = true;
+
+ if (pkAesMode)
+ {
+ if (padStreamSpec->GetSize() != size)
+ truncatedError = true;
+ if (padStreamSpec->WasPadFailure())
+ padError = true;
+ }
+ }
+ else
+ {
+ if (item.IsEncrypted())
+ {
+ readFromFilter = true;
+ inStreamReleaser.FilterCoder = filterStreamSpec;
+ RINOK(filterStreamSpec->SetInStream(inStream))
+
+ /* IFilter::Init() does nothing in all zip crypto filters.
+ So we can call any Initialize function in CFilterCoder. */
+
+ RINOK(filterStreamSpec->Init_NoSubFilterInit())
+ // RINOK(filterStreamSpec->SetOutStreamSize(NULL));
+ }
+
+ try {
+ result = coder->Code(readFromFilter ?
+ (ISequentialInStream *)filterStream :
+ (ISequentialInStream *)inStream,
+ outStream,
+ isFullStreamExpected ? &coderPackSize : NULL,
+ // NULL,
+ useUnpackLimit ? &item.Size : NULL,
+ compressProgress);
+ } catch (...) { return E_FAIL; }
+
+ if (result == S_OK)
+ {
+ CMyComPtr<ICompressGetInStreamProcessedSize> getInStreamProcessedSize;
+ coder->QueryInterface(IID_ICompressGetInStreamProcessedSize, (void **)&getInStreamProcessedSize);
+ if (getInStreamProcessedSize && setFinishMode)
+ {
+ UInt64 processed;
+ RINOK(getInStreamProcessedSize->GetInStreamProcessedSize(&processed))
+ if (processed != (UInt64)(Int64)-1)
+ {
+ if (pkAesMode)
+ {
+ const UInt32 padSize = _pkAesDecoderSpec->GetPadSize((UInt32)processed);
+ if (processed + padSize > coderPackSize)
+ truncatedError = true;
+ else if (processed + padSize < coderPackSize)
+ dataAfterEnd = true;
+ else
+ {
+ {
+ // here we check PKCS7 padding data from reminder (it can be inside stream buffer in coder).
+ CMyComPtr<ICompressReadUnusedFromInBuf> readInStream;
+ coder->QueryInterface(IID_ICompressReadUnusedFromInBuf, (void **)&readInStream);
+ // CCopyCoder() for kStore doesn't read data outside of (item.Size)
+ if (readInStream || id == NFileHeader::NCompressionMethod::kStore)
+ {
+ // change pad size, if we support another block size in ZipStrong.
+ // here we request more data to detect error with data after end.
+ const UInt32 kBufSize = NCrypto::NZipStrong::kAesPadAllign + 16;
+ Byte buf[kBufSize];
+ UInt32 processedSize = 0;
+ if (readInStream)
+ {
+ RINOK(readInStream->ReadUnusedFromInBuf(buf, kBufSize, &processedSize))
+ }
+ if (processedSize > padSize)
+ dataAfterEnd = true;
+ else
+ {
+ size_t processedSize2 = kBufSize - processedSize;
+ result = ReadStream(filterStream, buf + processedSize, &processedSize2);
+ if (result == S_OK)
+ {
+ processedSize2 += processedSize;
+ if (processedSize2 > padSize)
+ dataAfterEnd = true;
+ else if (processedSize2 < padSize)
+ truncatedError = true;
+ else
+ for (unsigned i = 0; i < padSize; i++)
+ if (buf[i] != padSize)
+ padError = true;
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ if (processed < coderPackSize)
+ {
+ if (isFullStreamExpected)
+ dataAfterEnd = true;
+ }
+ else if (processed > coderPackSize)
+ {
+ // that case is additional check, that can show the bugs in code (coder)
+ truncatedError = true;
+ }
+ needReminderCheck = isFullStreamExpected;
+ }
+ }
+ }
+ }
+ }
+
+ if (result == S_OK && id == NFileHeader::NCompressionMethod::kLZMA)
+ if (!lzmaDecoderSpec->DecoderSpec->CheckFinishStatus(item.IsLzmaEOS()))
+ lzmaEosError = true;
+ }
+
+ if (result == S_FALSE)
+ return S_OK;
+
+ if (result == E_NOTIMPL)
+ {
+ res = NExtract::NOperationResult::kUnsupportedMethod;
+ return S_OK;
+ }
+
+ RINOK(result)
+ }
+
+ bool crcOK = true;
+ bool authOk = true;
+ if (needCRC)
+ crcOK = (outStreamSpec->GetCRC() == item.Crc);
+
+ if (useUnpackLimit)
+ if (outStreamSpec->GetSize() != item.Size)
+ truncatedError = true;
+
+ if (wzAesMode)
+ {
+ const UInt64 unpackSize = outStreamSpec->GetSize();
+ const UInt64 packSize = limitedStreamSpec->GetSize();
+ bool thereAreData = false;
+ // read to the end from filter or from packed stream
+ if (SkipStreamData(readFromFilter ?
+ (ISequentialInStream *)filterStream :
+ (ISequentialInStream *)inStream,
+ compressProgress, packSize, unpackSize, thereAreData) != S_OK)
+ authOk = false;
+ if (needReminderCheck && thereAreData)
+ dataAfterEnd = true;
+
+ if (limitedStreamSpec->GetRem() != 0)
+ truncatedError = true;
+ else
+ {
+ limitedStreamSpec->Init(NCrypto::NWzAes::kMacSize);
+ if (_wzAesDecoderSpec->CheckMac(inStream, authOk) != S_OK)
+ authOk = false;
+ }
+ }
+
+ res = NExtract::NOperationResult::kCRCError;
+
+ if (crcOK && authOk)
+ {
+ res = NExtract::NOperationResult::kOK;
+
+ if (dataAfterEnd)
+ res = NExtract::NOperationResult::kDataAfterEnd;
+ else if (padError)
+ res = NExtract::NOperationResult::kCRCError;
+ else if (truncatedError)
+ res = NExtract::NOperationResult::kUnexpectedEnd;
+ else if (headersError)
+ res = NExtract::NOperationResult::kHeadersError;
+ else if (lzmaEosError)
+ res = NExtract::NOperationResult::kHeadersError;
+ else if (badDescriptor)
+ res = NExtract::NOperationResult::kUnexpectedEnd;
+
+ // CheckDescriptor() supports only data descriptor with signature and
+ // it doesn't support "old" pkzip's data descriptor without signature.
+ // So we disable that check.
+ /*
+ if (item.HasDescriptor() && archive.CheckDescriptor(item) != S_OK)
+ res = NExtract::NOperationResult::kHeadersError;
+ */
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = m_Items.Size();
+ if (numItems == 0)
+ return S_OK;
+ UInt64 total = 0; // , totalPacked = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CItemEx &item = m_Items[allFilesMode ? i : indices[i]];
+ total += item.Size;
+ // totalPacked += item.PackSize;
+ }
+ RINOK(extractCallback->SetTotal(total))
+
+ CZipDecoder myDecoder;
+ UInt64 cur_Unpacked, cur_Packed;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ for (i = 0;; i++,
+ lps->OutSize += cur_Unpacked,
+ lps->InSize += cur_Packed)
+ {
+ RINOK(lps->SetCur())
+ if (i >= numItems)
+ return S_OK;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ CItemEx item = m_Items[index];
+ cur_Unpacked = item.Size;
+ cur_Packed = item.PackSize;
+
+ const bool isLocalOffsetOK = m_Archive.IsLocalOffsetOK(item);
+ const bool skip = !isLocalOffsetOK && !item.IsDir();
+ const Int32 askMode = skip ?
+ NExtract::NAskMode::kSkip : testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ if (!isLocalOffsetOK)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kUnavailable))
+ continue;
+ }
+
+ bool headersError = false;
+
+ if (!item.FromLocal)
+ {
+ bool isAvail = true;
+ const HRESULT hres = m_Archive.Read_LocalItem_After_CdItem(item, isAvail, headersError);
+ if (hres == S_FALSE)
+ {
+ if (item.IsDir() || realOutStream || testMode)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(
+ isAvail ?
+ NExtract::NOperationResult::kHeadersError :
+ NExtract::NOperationResult::kUnavailable))
+ }
+ continue;
+ }
+ RINOK(hres)
+ }
+
+ if (item.IsDir())
+ {
+ // if (!testMode)
+ {
+ RINOK(extractCallback->PrepareOperation(askMode))
+ realOutStream.Release();
+ RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+ }
+ continue;
+ }
+
+ if (!testMode && !realOutStream)
+ continue;
+
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ Int32 res;
+ const HRESULT hres = myDecoder.Decode(
+ EXTERNAL_CODECS_VARS
+ m_Archive, item, realOutStream, extractCallback,
+ progress,
+ #ifndef Z7_ST
+ _props._numThreads, _props._memUsage_Decompress,
+ #endif
+ res);
+
+ RINOK(hres)
+ realOutStream.Release();
+
+ if (res == NExtract::NOperationResult::kOK && headersError)
+ res = NExtract::NOperationResult::kHeadersError;
+
+ RINOK(extractCallback->SetOperationResult(res))
+ }
+
+ COM_TRY_END
+}
+
+IMPL_ISetCompressCodecsInfo
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipHandler.h b/CPP/7zip/Archive/Zip/ZipHandler.h
new file mode 100644
index 0000000..1f38bff
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipHandler.h
@@ -0,0 +1,94 @@
+// Zip/Handler.h
+
+#ifndef ZIP7_INC_ZIP_HANDLER_H
+#define ZIP7_INC_ZIP_HANDLER_H
+
+#include "../../../Common/DynamicBuffer.h"
+#include "../../ICoder.h"
+#include "../IArchive.h"
+
+#include "../../Common/CreateCoder.h"
+
+#include "ZipCompressionMode.h"
+#include "ZipIn.h"
+
+namespace NArchive {
+namespace NZip {
+
+const unsigned kNumMethodNames1 = NFileHeader::NCompressionMethod::kZstdPk + 1;
+const unsigned kMethodNames2Start = NFileHeader::NCompressionMethod::kZstdWz;
+const unsigned kNumMethodNames2 = NFileHeader::NCompressionMethod::kWzAES + 1 - kMethodNames2Start;
+
+extern const char * const kMethodNames1[kNumMethodNames1];
+extern const char * const kMethodNames2[kNumMethodNames2];
+
+
+class CHandler Z7_final:
+ public IInArchive,
+ // public IArchiveGetRawProps,
+ public IOutArchive,
+ public ISetProperties,
+ Z7_PUBLIC_ISetCompressCodecsInfo_IFEC
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IInArchive)
+ // Z7_COM_QI_ENTRY(IArchiveGetRawProps)
+ Z7_COM_QI_ENTRY(IOutArchive)
+ Z7_COM_QI_ENTRY(ISetProperties)
+ Z7_COM_QI_ENTRY_ISetCompressCodecsInfo_IFEC
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IInArchive)
+ // Z7_IFACE_COM7_IMP(IArchiveGetRawProps)
+ Z7_IFACE_COM7_IMP(IOutArchive)
+ Z7_IFACE_COM7_IMP(ISetProperties)
+ DECL_ISetCompressCodecsInfo
+
+private:
+ CObjectVector<CItemEx> m_Items;
+ CInArchive m_Archive;
+
+ CBaseProps _props;
+ CHandlerTimeOptions TimeOptions;
+
+ int m_MainMethod;
+ bool m_ForceAesMode;
+
+ bool _removeSfxBlock;
+ bool m_ForceLocal;
+ bool m_ForceUtf8;
+ bool _force_SeqOutMode; // for creation
+ bool _force_OpenSeq;
+ bool _forceCodePage;
+ UInt32 _specifiedCodePage;
+
+ DECL_EXTERNAL_CODECS_VARS
+
+ void InitMethodProps()
+ {
+ _props.Init();
+ TimeOptions.Init();
+ TimeOptions.Prec = k_PropVar_TimePrec_0;
+ m_MainMethod = -1;
+ m_ForceAesMode = false;
+ _removeSfxBlock = false;
+ m_ForceLocal = false;
+ m_ForceUtf8 = false;
+ _force_SeqOutMode = false;
+ _force_OpenSeq = false;
+ _forceCodePage = false;
+ _specifiedCodePage = CP_OEMCP;
+ }
+
+ // void MarkAltStreams(CObjectVector<CItemEx> &items);
+
+ HRESULT GetOutProperty(IArchiveUpdateCallback *callback, UInt32 callbackIndex, Int32 arcIndex, PROPID propID, PROPVARIANT *value);
+
+public:
+ CHandler();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipHandlerOut.cpp b/CPP/7zip/Archive/Zip/ZipHandlerOut.cpp
new file mode 100644
index 0000000..19699b5
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipHandlerOut.cpp
@@ -0,0 +1,618 @@
+// ZipHandlerOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../IPassword.h"
+
+#include "../../Common/OutBuffer.h"
+
+#include "../../Crypto/WzAes.h"
+
+#include "../Common/ItemNameUtils.h"
+#include "../Common/ParseProperties.h"
+
+#include "ZipHandler.h"
+#include "ZipUpdate.h"
+
+using namespace NWindows;
+using namespace NCOM;
+using namespace NTime;
+
+namespace NArchive {
+namespace NZip {
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *timeType))
+{
+ *timeType = TimeOptions.Prec;
+ return S_OK;
+}
+
+static bool IsSimpleAsciiString(const wchar_t *s)
+{
+ for (;;)
+ {
+ wchar_t c = *s++;
+ if (c == 0)
+ return true;
+ if (c < 0x20 || c > 0x7F)
+ return false;
+ }
+}
+
+
+static int FindZipMethod(const char *s, const char * const *names, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ {
+ const char *name = names[i];
+ if (name && StringsAreEqualNoCase_Ascii(s, name))
+ return (int)i;
+ }
+ return -1;
+}
+
+static int FindZipMethod(const char *s)
+{
+ int k = FindZipMethod(s, kMethodNames1, kNumMethodNames1);
+ if (k >= 0)
+ return k;
+ k = FindZipMethod(s, kMethodNames2, kNumMethodNames2);
+ if (k >= 0)
+ return (int)kMethodNames2Start + k;
+ return -1;
+}
+
+
+#define COM_TRY_BEGIN2 try {
+#define COM_TRY_END2 } \
+catch(const CSystemException &e) { return e.ErrorCode; } \
+catch(...) { return E_OUTOFMEMORY; }
+
+static HRESULT GetTime(IArchiveUpdateCallback *callback, unsigned index, PROPID propID, FILETIME &filetime)
+{
+ filetime.dwHighDateTime = filetime.dwLowDateTime = 0;
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ filetime = prop.filetime;
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *callback))
+{
+ COM_TRY_BEGIN2
+
+ if (m_Archive.IsOpen())
+ {
+ if (!m_Archive.CanUpdate())
+ return E_NOTIMPL;
+ }
+
+ CObjectVector<CUpdateItem> updateItems;
+ updateItems.ClearAndReserve(numItems);
+
+ bool thereAreAesUpdates = false;
+ UInt64 largestSize = 0;
+ bool largestSizeDefined = false;
+
+ #ifdef _WIN32
+ const UINT oemCP = GetOEMCP();
+ #endif
+
+ UString name;
+ CUpdateItem ui;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ Int32 newData;
+ Int32 newProps;
+ UInt32 indexInArc;
+
+ if (!callback)
+ return E_FAIL;
+
+ RINOK(callback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArc))
+
+ name.Empty();
+ ui.Clear();
+
+ ui.NewProps = IntToBool(newProps);
+ ui.NewData = IntToBool(newData);
+ ui.IndexInArc = (int)indexInArc;
+ ui.IndexInClient = i;
+
+ bool existInArchive = (indexInArc != (UInt32)(Int32)-1);
+ if (existInArchive)
+ {
+ const CItemEx &inputItem = m_Items[indexInArc];
+ if (inputItem.IsAesEncrypted())
+ thereAreAesUpdates = true;
+ if (!IntToBool(newProps))
+ ui.IsDir = inputItem.IsDir();
+ // ui.IsAltStream = inputItem.IsAltStream();
+ }
+
+ if (IntToBool(newProps))
+ {
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.Attrib = 0;
+ else if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ else
+ ui.Attrib = prop.ulVal;
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidPath, &prop))
+ if (prop.vt == VT_EMPTY)
+ {
+ // name.Empty();
+ }
+ else if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ else
+ name = prop.bstrVal;
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidIsDir, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.IsDir = false;
+ else if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ else
+ ui.IsDir = (prop.boolVal != VARIANT_FALSE);
+ }
+
+ /*
+ {
+ bool isAltStream = false;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidIsAltStream, &prop));
+ if (prop.vt == VT_BOOL)
+ isAltStream = (prop.boolVal != VARIANT_FALSE);
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+
+ if (isAltStream)
+ {
+ if (ui.IsDir)
+ return E_INVALIDARG;
+ int delim = name.ReverseFind(L':');
+ if (delim >= 0)
+ {
+ name.Delete(delim, 1);
+ name.Insert(delim, UString(k_SpecName_NTFS_STREAM));
+ ui.IsAltStream = true;
+ }
+ }
+ }
+ */
+
+ // 22.00 : kpidTimeType is useless here : the code was disabled
+ /*
+ {
+ CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidTimeType, &prop));
+ if (prop.vt == VT_UI4)
+ ui.NtfsTime_IsDefined = (prop.ulVal == NFileTimeType::kWindows);
+ else
+ ui.NtfsTime_IsDefined = _Write_NtfsTime;
+ }
+ */
+
+ if (TimeOptions.Write_MTime.Val) RINOK (GetTime (callback, i, kpidMTime, ui.Ntfs_MTime))
+ if (TimeOptions.Write_ATime.Val) RINOK (GetTime (callback, i, kpidATime, ui.Ntfs_ATime))
+ if (TimeOptions.Write_CTime.Val) RINOK (GetTime (callback, i, kpidCTime, ui.Ntfs_CTime))
+
+ if (TimeOptions.Prec != k_PropVar_TimePrec_DOS)
+ {
+ if (TimeOptions.Prec == k_PropVar_TimePrec_Unix ||
+ TimeOptions.Prec == k_PropVar_TimePrec_Base)
+ ui.Write_UnixTime = ! FILETIME_IsZero (ui.Ntfs_MTime);
+ else
+ {
+ /*
+ // if we want to store zero timestamps as zero timestamp, use the following:
+ ui.Write_NtfsTime =
+ _Write_MTime ||
+ _Write_ATime ||
+ _Write_CTime;
+ */
+
+ // We treat zero timestamp as no timestamp
+ ui.Write_NtfsTime =
+ ! FILETIME_IsZero (ui.Ntfs_MTime) ||
+ ! FILETIME_IsZero (ui.Ntfs_ATime) ||
+ ! FILETIME_IsZero (ui.Ntfs_CTime);
+ }
+ }
+
+ /*
+ how 0 in dos time works:
+ win10 explorer extract : some random date 1601-04-25.
+ winrar 6.10 : write time.
+ 7zip : MTime of archive is used
+ how 0 in tar works:
+ winrar 6.10 : 1970
+ 0 in dos field can show that there is no timestamp.
+ we write correct 1970-01-01 in dos field, to support correct extraction in Win10.
+ */
+
+ UtcFileTime_To_LocalDosTime(ui.Ntfs_MTime, ui.Time);
+
+ NItemName::ReplaceSlashes_OsToUnix(name);
+
+ bool needSlash = ui.IsDir;
+ const wchar_t kSlash = L'/';
+ if (!name.IsEmpty())
+ {
+ if (name.Back() == kSlash)
+ {
+ if (!ui.IsDir)
+ return E_INVALIDARG;
+ needSlash = false;
+ }
+ }
+ if (needSlash)
+ name += kSlash;
+
+ const UINT codePage = _forceCodePage ? _specifiedCodePage : CP_OEMCP;
+ bool tryUtf8 = true;
+
+ /*
+ Windows 10 allows users to set UTF-8 in Region Settings via option:
+ "Beta: Use Unicode UTF-8 for worldwide language support"
+ In that case Windows uses CP_UTF8 when we use CP_OEMCP.
+ 21.02 fixed:
+ we set UTF-8 mark for non-latin files for such UTF-8 mode in Windows.
+ we write additional Info-Zip Utf-8 FileName Extra for non-latin names/
+ */
+
+ if ((codePage != CP_UTF8) &&
+ #ifdef _WIN32
+ (m_ForceLocal || !m_ForceUtf8) && (oemCP != CP_UTF8)
+ #else
+ (m_ForceLocal && !m_ForceUtf8)
+ #endif
+ )
+ {
+ bool defaultCharWasUsed;
+ ui.Name = UnicodeStringToMultiByte(name, codePage, '_', defaultCharWasUsed);
+ tryUtf8 = (!m_ForceLocal && (defaultCharWasUsed ||
+ MultiByteToUnicodeString(ui.Name, codePage) != name));
+ }
+
+ const bool isNonLatin = !name.IsAscii();
+
+ if (tryUtf8)
+ {
+ ui.IsUtf8 = isNonLatin;
+ ConvertUnicodeToUTF8(name, ui.Name);
+
+ #ifndef _WIN32
+ if (ui.IsUtf8 && !CheckUTF8_AString(ui.Name))
+ {
+ // if it's non-Windows and there are non-UTF8 characters we clear UTF8-flag
+ ui.IsUtf8 = false;
+ }
+ #endif
+ }
+ else if (isNonLatin)
+ Convert_Unicode_To_UTF8_Buf(name, ui.Name_Utf);
+
+ if (ui.Name.Len() >= (1 << 16)
+ || ui.Name_Utf.Size() >= (1 << 16) - 128)
+ return E_INVALIDARG;
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidComment, &prop))
+ if (prop.vt == VT_EMPTY)
+ {
+ // ui.Comment.Free();
+ }
+ else if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ else
+ {
+ UString s = prop.bstrVal;
+ AString a;
+ if (ui.IsUtf8)
+ ConvertUnicodeToUTF8(s, a);
+ else
+ {
+ bool defaultCharWasUsed;
+ a = UnicodeStringToMultiByte(s, codePage, '_', defaultCharWasUsed);
+ }
+ if (a.Len() >= (1 << 16))
+ return E_INVALIDARG;
+ ui.Comment.CopyFrom((const Byte *)(const char *)a, a.Len());
+ }
+ }
+
+
+ /*
+ if (existInArchive)
+ {
+ const CItemEx &itemInfo = m_Items[indexInArc];
+ // ui.Commented = itemInfo.IsCommented();
+ ui.Commented = false;
+ if (ui.Commented)
+ {
+ ui.CommentRange.Position = itemInfo.GetCommentPosition();
+ ui.CommentRange.Size = itemInfo.CommentSize;
+ }
+ }
+ else
+ ui.Commented = false;
+ */
+ }
+
+
+ if (IntToBool(newData))
+ {
+ UInt64 size = 0;
+ if (!ui.IsDir)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ size = prop.uhVal.QuadPart;
+ if (largestSize < size)
+ largestSize = size;
+ largestSizeDefined = true;
+ }
+ ui.Size = size;
+ }
+
+ updateItems.Add(ui);
+ }
+
+
+ CMyComPtr<ICryptoGetTextPassword2> getTextPassword;
+ {
+ CMyComPtr<IArchiveUpdateCallback> udateCallBack2(callback);
+ udateCallBack2.QueryInterface(IID_ICryptoGetTextPassword2, &getTextPassword);
+ }
+ CCompressionMethodMode options;
+ (CBaseProps &)options = _props;
+ options.DataSizeReduce = largestSize;
+ options.DataSizeReduce_Defined = largestSizeDefined;
+
+ options.Password_Defined = false;
+ options.Password.Wipe_and_Empty();
+ if (getTextPassword)
+ {
+ CMyComBSTR_Wipe password;
+ Int32 passwordIsDefined;
+ RINOK(getTextPassword->CryptoGetTextPassword2(&passwordIsDefined, &password))
+ options.Password_Defined = IntToBool(passwordIsDefined);
+ if (options.Password_Defined)
+ {
+ if (!m_ForceAesMode)
+ options.IsAesMode = thereAreAesUpdates;
+
+ if (!IsSimpleAsciiString(password))
+ return E_INVALIDARG;
+ if (password)
+ UnicodeStringToMultiByte2(options.Password, (LPCOLESTR)password, CP_OEMCP);
+ if (options.IsAesMode)
+ {
+ if (options.Password.Len() > NCrypto::NWzAes::kPasswordSizeMax)
+ return E_INVALIDARG;
+ }
+ }
+ }
+
+
+ int mainMethod = m_MainMethod;
+
+ if (mainMethod < 0)
+ {
+ if (!_props._methods.IsEmpty())
+ {
+ const AString &methodName = _props._methods.Front().MethodName;
+ if (!methodName.IsEmpty())
+ {
+ mainMethod = FindZipMethod(methodName);
+ if (mainMethod < 0)
+ {
+ CMethodId methodId;
+ UInt32 numStreams;
+ bool isFilter;
+ if (FindMethod_Index(EXTERNAL_CODECS_VARS methodName, true,
+ methodId, numStreams, isFilter) < 0)
+ return E_NOTIMPL;
+ if (numStreams != 1)
+ return E_NOTIMPL;
+ if (methodId == kMethodId_BZip2)
+ mainMethod = NFileHeader::NCompressionMethod::kBZip2;
+ else
+ {
+ if (methodId < kMethodId_ZipBase)
+ return E_NOTIMPL;
+ methodId -= kMethodId_ZipBase;
+ if (methodId > 0xFF)
+ return E_NOTIMPL;
+ mainMethod = (int)methodId;
+ }
+ }
+ }
+ }
+ }
+
+ if (mainMethod < 0)
+ mainMethod = (Byte)(((_props.GetLevel() == 0) ?
+ NFileHeader::NCompressionMethod::kStore :
+ NFileHeader::NCompressionMethod::kDeflate));
+ else
+ mainMethod = (Byte)mainMethod;
+
+ options.MethodSequence.Add((Byte)mainMethod);
+
+ if (mainMethod != NFileHeader::NCompressionMethod::kStore)
+ options.MethodSequence.Add(NFileHeader::NCompressionMethod::kStore);
+
+ options.Force_SeqOutMode = _force_SeqOutMode;
+
+ CUpdateOptions uo;
+ uo.Write_MTime = TimeOptions.Write_MTime.Val;
+ uo.Write_ATime = TimeOptions.Write_ATime.Val;
+ uo.Write_CTime = TimeOptions.Write_CTime.Val;
+ /*
+ uo.Write_NtfsTime = _Write_NtfsTime &&
+ (_Write_MTime || _Write_ATime || _Write_CTime);
+ uo.Write_UnixTime = _Write_UnixTime;
+ */
+
+ return Update(
+ EXTERNAL_CODECS_VARS
+ m_Items, updateItems, outStream,
+ m_Archive.IsOpen() ? &m_Archive : NULL, _removeSfxBlock,
+ uo, options, callback);
+
+ COM_TRY_END2
+}
+
+
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ InitMethodProps();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ UString name = names[i];
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ const PROPVARIANT &prop = values[i];
+
+ if (name.IsEqualTo_Ascii_NoCase("em"))
+ {
+ if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ {
+ const wchar_t *m = prop.bstrVal;
+ if (IsString1PrefixedByString2_NoCase_Ascii(m, "aes"))
+ {
+ m += 3;
+ if (StringsAreEqual_Ascii(m, "128"))
+ _props.AesKeyMode = 1;
+ else if (StringsAreEqual_Ascii(m, "192"))
+ _props.AesKeyMode = 2;
+ else if (StringsAreEqual_Ascii(m, "256") || m[0] == 0)
+ _props.AesKeyMode = 3;
+ else
+ return E_INVALIDARG;
+ _props.IsAesMode = true;
+ m_ForceAesMode = true;
+ }
+ else if (StringsAreEqualNoCase_Ascii(m, "ZipCrypto"))
+ {
+ _props.IsAesMode = false;
+ m_ForceAesMode = true;
+ }
+ else
+ return E_INVALIDARG;
+ }
+ }
+
+
+
+ else if (name.IsEqualTo("cl"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, m_ForceLocal))
+ if (m_ForceLocal)
+ m_ForceUtf8 = false;
+ }
+ else if (name.IsEqualTo("cu"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, m_ForceUtf8))
+ if (m_ForceUtf8)
+ m_ForceLocal = false;
+ }
+ else if (name.IsEqualTo("cp"))
+ {
+ UInt32 cp = CP_OEMCP;
+ RINOK(ParsePropToUInt32(L"", prop, cp))
+ _forceCodePage = true;
+ _specifiedCodePage = cp;
+ }
+ else if (name.IsEqualTo("rsfx"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, _removeSfxBlock))
+ }
+ else if (name.IsEqualTo("rws"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, _force_SeqOutMode))
+ }
+ else if (name.IsEqualTo("ros"))
+ {
+ RINOK(PROPVARIANT_to_bool(prop, _force_OpenSeq))
+ }
+ else
+ {
+ if (name.IsEqualTo_Ascii_NoCase("m") && prop.vt == VT_UI4)
+ {
+ UInt32 id = prop.ulVal;
+ if (id > 0xFF)
+ return E_INVALIDARG;
+ m_MainMethod = (int)id;
+ }
+ else
+ {
+ bool processed = false;
+ RINOK(TimeOptions.Parse(name, prop, processed))
+ if (!processed)
+ {
+ RINOK(_props.SetProperty(name, prop))
+ }
+ }
+ // RINOK(_props.MethodInfo.ParseParamsFromPROPVARIANT(name, prop));
+ }
+ }
+
+ _props._methods.DeleteFrontal(_props.GetNumEmptyMethods());
+ if (_props._methods.Size() > 1)
+ return E_INVALIDARG;
+ if (_props._methods.Size() == 1)
+ {
+ const AString &methodName = _props._methods[0].MethodName;
+
+ if (!methodName.IsEmpty())
+ {
+ const char *end;
+ UInt32 id = ConvertStringToUInt32(methodName, &end);
+ if (*end == 0 && id <= 0xFF)
+ m_MainMethod = (int)id;
+ else if (methodName.IsEqualTo_Ascii_NoCase("Copy")) // it's alias for "Store"
+ m_MainMethod = 0;
+ }
+ }
+
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipHeader.h b/CPP/7zip/Archive/Zip/ZipHeader.h
new file mode 100644
index 0000000..038d49d
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipHeader.h
@@ -0,0 +1,201 @@
+// ZipHeader.h
+
+#ifndef ZIP7_INC_ARCHIVE_ZIP_HEADER_H
+#define ZIP7_INC_ARCHIVE_ZIP_HEADER_H
+
+#include "../../../Common/MyTypes.h"
+
+namespace NArchive {
+namespace NZip {
+
+const unsigned kMarkerSize = 4;
+
+namespace NSignature
+{
+ const UInt32 kLocalFileHeader = 0x04034B50;
+ const UInt32 kDataDescriptor = 0x08074B50;
+ const UInt32 kCentralFileHeader = 0x02014B50;
+ const UInt32 kEcd = 0x06054B50;
+ const UInt32 kEcd64 = 0x06064B50;
+ const UInt32 kEcd64Locator = 0x07064B50;
+ const UInt32 kSpan = 0x08074B50;
+ const UInt32 kNoSpan = 0x30304B50; // PK00, replaces kSpan, if there is only 1 segment
+}
+
+const unsigned kLocalHeaderSize = 4 + 26; // including signature
+const unsigned kDataDescriptorSize32 = 4 + 4 + 4 * 2; // including signature
+const unsigned kDataDescriptorSize64 = 4 + 4 + 8 * 2; // including signature
+const unsigned kCentralHeaderSize = 4 + 42; // including signature
+
+const unsigned kEcdSize = 22; // including signature
+const unsigned kEcd64_MainSize = 44;
+const unsigned kEcd64_FullSize = 12 + kEcd64_MainSize;
+const unsigned kEcd64Locator_Size = 20;
+
+namespace NFileHeader
+{
+ namespace NCompressionMethod
+ {
+ enum EType
+ {
+ kStore = 0,
+ kShrink = 1,
+ kReduce1 = 2,
+ kReduce2 = 3,
+ kReduce3 = 4,
+ kReduce4 = 5,
+ kImplode = 6,
+ kTokenize = 7,
+ kDeflate = 8,
+ kDeflate64 = 9,
+ kPKImploding = 10,
+
+ kBZip2 = 12,
+
+ kLZMA = 14,
+
+ kTerse = 18,
+ kLz77 = 19,
+ kZstdPk = 20,
+
+ kZstdWz = 93,
+ kMP3 = 94,
+ kXz = 95,
+ kJpeg = 96,
+ kWavPack = 97,
+ kPPMd = 98,
+ kWzAES = 99
+ };
+
+ const Byte kMadeByProgramVersion = 63;
+
+ const Byte kExtractVersion_Default = 10;
+ const Byte kExtractVersion_Dir = 20;
+ const Byte kExtractVersion_ZipCrypto = 20;
+ const Byte kExtractVersion_Deflate = 20;
+ const Byte kExtractVersion_Deflate64 = 21;
+ const Byte kExtractVersion_Zip64 = 45;
+ const Byte kExtractVersion_BZip2 = 46;
+ const Byte kExtractVersion_Aes = 51;
+ const Byte kExtractVersion_LZMA = 63;
+ const Byte kExtractVersion_PPMd = 63;
+ const Byte kExtractVersion_Xz = 20; // test it
+ }
+
+ namespace NExtraID
+ {
+ enum
+ {
+ kZip64 = 0x01,
+ kNTFS = 0x0A,
+ kUnix0 = 0x0D, // Info-ZIP : (UNIX) PK
+ kStrongEncrypt = 0x17,
+ kIzNtSecurityDescriptor = 0x4453,
+ kUnixTime = 0x5455, // "UT" (time) Info-ZIP
+ kUnix1 = 0x5855, // Info-ZIP
+ kIzUnicodeComment = 0x6375,
+ kIzUnicodeName = 0x7075,
+ kUnix2 = 0x7855, // Info-ZIP
+ kUnixN = 0x7875, // Info-ZIP
+ kWzAES = 0x9901,
+ kApkAlign = 0xD935
+ };
+ }
+
+ namespace NNtfsExtra
+ {
+ const UInt16 kTagTime = 1;
+ enum
+ {
+ kMTime = 0,
+ kATime,
+ kCTime
+ };
+ }
+
+ namespace NUnixTime
+ {
+ enum
+ {
+ kMTime = 0,
+ kATime,
+ kCTime
+ };
+ }
+
+ namespace NUnixExtra
+ {
+ enum
+ {
+ kATime = 0,
+ kMTime
+ };
+ }
+
+ namespace NFlags
+ {
+ const unsigned kEncrypted = 1 << 0;
+ const unsigned kLzmaEOS = 1 << 1;
+ const unsigned kDescriptorUsedMask = 1 << 3;
+ const unsigned kStrongEncrypted = 1 << 6;
+ const unsigned kUtf8 = 1 << 11;
+ const unsigned kAltStream = 1 << 14;
+
+ const unsigned kImplodeDictionarySizeMask = 1 << 1;
+ const unsigned kImplodeLiteralsOnMask = 1 << 2;
+
+ /*
+ const unsigned kDeflateTypeBitStart = 1;
+ const unsigned kNumDeflateTypeBits = 2;
+ const unsigned kNumDeflateTypes = (1 << kNumDeflateTypeBits);
+ const unsigned kDeflateTypeMask = (1 << kNumDeflateTypeBits) - 1;
+ */
+ }
+
+ namespace NHostOS
+ {
+ enum EEnum
+ {
+ kFAT = 0,
+ kAMIGA = 1,
+ kVMS = 2, // VAX/VMS
+ kUnix = 3,
+ kVM_CMS = 4,
+ kAtari = 5, // what if it's a minix filesystem? [cjh]
+ kHPFS = 6, // filesystem used by OS/2 (and NT 3.x)
+ kMac = 7,
+ kZ_System = 8,
+ kCPM = 9,
+ kTOPS20 = 10, // pkzip 2.50 NTFS
+ kNTFS = 11, // filesystem used by Windows NT
+ kQDOS = 12, // SMS/QDOS
+ kAcorn = 13, // Archimedes Acorn RISC OS
+ kVFAT = 14, // filesystem used by Windows 95, NT
+ kMVS = 15,
+ kBeOS = 16, // hybrid POSIX/database filesystem
+ kTandem = 17,
+ kOS400 = 18,
+ kOSX = 19
+ };
+ }
+
+
+ namespace NAmigaAttrib
+ {
+ const UInt32 kIFMT = 06000; // Amiga file type mask
+ const UInt32 kIFDIR = 04000; // Amiga directory
+ const UInt32 kIFREG = 02000; // Amiga regular file
+ const UInt32 kIHIDDEN = 00200; // to be supported in AmigaDOS 3.x
+ const UInt32 kISCRIPT = 00100; // executable script (text command file)
+ const UInt32 kIPURE = 00040; // allow loading into resident memory
+ const UInt32 kIARCHIVE = 00020; // not modified since bit was last set
+ const UInt32 kIREAD = 00010; // can be opened for reading
+ const UInt32 kIWRITE = 00004; // can be opened for writing
+ const UInt32 kIEXECUTE = 00002; // executable image, a loadable runfile
+ const UInt32 kIDELETE = 00001; // can be deleted
+ }
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipIn.cpp b/CPP/7zip/Archive/Zip/ZipIn.cpp
new file mode 100644
index 0000000..4236df7
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipIn.cpp
@@ -0,0 +1,3485 @@
+// Archive/ZipIn.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../Common/DynamicBuffer.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyException.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../IArchive.h"
+
+#include "ZipIn.h"
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+
+#define G16(offs, v) v = Get16(p + (offs))
+#define G32(offs, v) v = Get32(p + (offs))
+#define G64(offs, v) v = Get64(p + (offs))
+
+namespace NArchive {
+namespace NZip {
+
+/* we try to use same size of Buffer (1 << 17) for all tasks.
+ it allow to avoid reallocations and cache clearing. */
+
+static const size_t kSeqBufferSize = (size_t)1 << 17;
+
+/*
+Open()
+{
+ _inBufMode = false;
+ ReadVols()
+ FindCd();
+ TryEcd64()
+ SeekToVol()
+ FindMarker()
+ _inBufMode = true;
+ ReadHeaders()
+ _inBufMode = false;
+ ReadCd()
+ FindCd()
+ TryEcd64()
+ TryReadCd()
+ {
+ SeekToVol();
+ _inBufMode = true;
+ }
+ _inBufMode = true;
+ ReadLocals()
+ ReadCdItem()
+ ....
+}
+FindCd() writes to Buffer without touching (_inBufMode)
+*/
+
+/*
+ if (not defined ZIP_SELF_CHECK) : it reads CD and if error in first pass CD reading, it reads LOCALS-CD-MODE
+ if ( defined ZIP_SELF_CHECK) : it always reads CD and LOCALS-CD-MODE
+ use ZIP_SELF_CHECK to check LOCALS-CD-MODE for any zip archive
+*/
+
+// #define ZIP_SELF_CHECK
+
+
+struct CEcd
+{
+ UInt16 ThisDisk;
+ UInt16 CdDisk;
+ UInt16 NumEntries_in_ThisDisk;
+ UInt16 NumEntries;
+ UInt32 Size;
+ UInt32 Offset;
+ UInt16 CommentSize;
+
+ bool IsEmptyArc() const
+ {
+ return ThisDisk == 0
+ && CdDisk == 0
+ && NumEntries_in_ThisDisk == 0
+ && NumEntries == 0
+ && Size == 0
+ && Offset == 0 // test it
+ ;
+ }
+
+ void Parse(const Byte *p); // (p) doesn't include signature
+};
+
+void CEcd::Parse(const Byte *p)
+{
+ // (p) doesn't include signature
+ G16(0, ThisDisk);
+ G16(2, CdDisk);
+ G16(4, NumEntries_in_ThisDisk);
+ G16(6, NumEntries);
+ G32(8, Size);
+ G32(12, Offset);
+ G16(16, CommentSize);
+}
+
+
+void CCdInfo::ParseEcd32(const Byte *p)
+{
+ IsFromEcd64 = false;
+ // (p) includes signature
+ p += 4;
+ G16(0, ThisDisk);
+ G16(2, CdDisk);
+ G16(4, NumEntries_in_ThisDisk);
+ G16(6, NumEntries);
+ G32(8, Size);
+ G32(12, Offset);
+ G16(16, CommentSize);
+}
+
+void CCdInfo::ParseEcd64e(const Byte *p)
+{
+ IsFromEcd64 = true;
+ // (p) exclude signature
+ G16(0, VersionMade);
+ G16(2, VersionNeedExtract);
+ G32(4, ThisDisk);
+ G32(8, CdDisk);
+
+ G64(12, NumEntries_in_ThisDisk);
+ G64(20, NumEntries);
+ G64(28, Size);
+ G64(36, Offset);
+}
+
+
+struct CLocator
+{
+ UInt32 Ecd64Disk;
+ UInt32 NumDisks;
+ UInt64 Ecd64Offset;
+
+ CLocator(): Ecd64Disk(0), NumDisks(0), Ecd64Offset(0) {}
+
+ void Parse(const Byte *p)
+ {
+ G32(0, Ecd64Disk);
+ G64(4, Ecd64Offset);
+ G32(12, NumDisks);
+ }
+
+ bool IsEmptyArc() const
+ {
+ return Ecd64Disk == 0 && NumDisks == 0 && Ecd64Offset == 0;
+ }
+};
+
+
+
+
+void CInArchive::ClearRefs()
+{
+ StreamRef.Release();
+ Stream = NULL;
+ StartStream = NULL;
+ Callback = NULL;
+
+ Vols.Clear();
+}
+
+void CInArchive::Close()
+{
+ _cnt = 0;
+ DisableBufMode();
+
+ IsArcOpen = false;
+
+ IsArc = false;
+ IsZip64 = false;
+
+ IsApk = false;
+ IsCdUnsorted = false;
+
+ HeadersError = false;
+ HeadersWarning = false;
+ ExtraMinorError = false;
+
+ UnexpectedEnd = false;
+ LocalsWereRead = false;
+ LocalsCenterMerged = false;
+ NoCentralDir = false;
+ Overflow32bit = false;
+ Cd_NumEntries_Overflow_16bit = false;
+
+ MarkerIsFound = false;
+ MarkerIsSafe = false;
+
+ IsMultiVol = false;
+ UseDisk_in_SingleVol = false;
+ EcdVolIndex = 0;
+
+ ArcInfo.Clear();
+
+ ClearRefs();
+}
+
+
+
+HRESULT CInArchive::Seek_SavePos(UInt64 offset)
+{
+ // InitBuf();
+ // if (!Stream) return S_FALSE;
+ return Stream->Seek((Int64)offset, STREAM_SEEK_SET, &_streamPos);
+}
+
+
+/* SeekToVol() will keep the cached mode, if new volIndex is
+ same Vols.StreamIndex volume, and offset doesn't go out of cached region */
+
+HRESULT CInArchive::SeekToVol(int volIndex, UInt64 offset)
+{
+ if (volIndex != Vols.StreamIndex)
+ {
+ if (IsMultiVol && volIndex >= 0)
+ {
+ if ((unsigned)volIndex >= Vols.Streams.Size())
+ return S_FALSE;
+ if (!Vols.Streams[(unsigned)volIndex].Stream)
+ return S_FALSE;
+ Stream = Vols.Streams[(unsigned)volIndex].Stream;
+ }
+ else if (volIndex == -2)
+ {
+ if (!Vols.ZipStream)
+ return S_FALSE;
+ Stream = Vols.ZipStream;
+ }
+ else
+ Stream = StartStream;
+ Vols.StreamIndex = volIndex;
+ }
+ else
+ {
+ if (offset <= _streamPos)
+ {
+ const UInt64 back = _streamPos - offset;
+ if (back <= _bufCached)
+ {
+ _bufPos = _bufCached - (size_t)back;
+ return S_OK;
+ }
+ }
+ }
+ InitBuf();
+ return Seek_SavePos(offset);
+}
+
+
+HRESULT CInArchive::AllocateBuffer(size_t size)
+{
+ if (size <= Buffer.Size())
+ return S_OK;
+ /* in cached mode virtual_pos is not equal to phy_pos (_streamPos)
+ so we change _streamPos and do Seek() to virtual_pos before cache clearing */
+ if (_bufPos != _bufCached)
+ {
+ RINOK(Seek_SavePos(GetVirtStreamPos()))
+ }
+ InitBuf();
+ Buffer.AllocAtLeast(size);
+ if (!Buffer.IsAllocated())
+ return E_OUTOFMEMORY;
+ return S_OK;
+}
+
+// ---------- ReadFromCache ----------
+// reads from cache and from Stream
+// move to next volume can be allowed if (CanStartNewVol) and only before first byte reading
+
+HRESULT CInArchive::ReadFromCache(Byte *data, unsigned size, unsigned &processed)
+{
+ HRESULT result = S_OK;
+ processed = 0;
+
+ for (;;)
+ {
+ if (size == 0)
+ return S_OK;
+
+ const size_t avail = GetAvail();
+
+ if (avail != 0)
+ {
+ unsigned cur = size;
+ if (cur > avail)
+ cur = (unsigned)avail;
+ memcpy(data, (const Byte *)Buffer + _bufPos, cur);
+
+ data += cur;
+ size -= cur;
+ processed += cur;
+
+ _bufPos += cur;
+ _cnt += cur;
+
+ CanStartNewVol = false;
+
+ continue;
+ }
+
+ InitBuf();
+
+ if (_inBufMode)
+ {
+ UInt32 cur = 0;
+ result = Stream->Read(Buffer, (UInt32)Buffer.Size(), &cur);
+ _bufPos = 0;
+ _bufCached = cur;
+ _streamPos += cur;
+ if (cur != 0)
+ CanStartNewVol = false;
+ if (result != S_OK)
+ break;
+ if (cur != 0)
+ continue;
+ }
+ else
+ {
+ size_t cur = size;
+ result = ReadStream(Stream, data, &cur);
+ data += cur;
+ size -= (unsigned)cur;
+ processed += (unsigned)cur;
+ _streamPos += cur;
+ _cnt += cur;
+ if (cur != 0)
+ {
+ CanStartNewVol = false;
+ break;
+ }
+ if (result != S_OK)
+ break;
+ }
+
+ if ( !IsMultiVol
+ || !CanStartNewVol
+ || Vols.StreamIndex < 0
+ || (unsigned)Vols.StreamIndex + 1 >= Vols.Streams.Size())
+ break;
+
+ const CVols::CSubStreamInfo &s = Vols.Streams[(unsigned)Vols.StreamIndex + 1];
+ if (!s.Stream)
+ break;
+ result = s.SeekToStart();
+ if (result != S_OK)
+ break;
+ Vols.StreamIndex++;
+ _streamPos = 0;
+ // Vols.NeedSeek = false;
+
+ Stream = s.Stream;
+ }
+
+ return result;
+}
+
+
+HRESULT CInArchive::ReadFromCache_FALSE(Byte *data, unsigned size)
+{
+ unsigned processed;
+ HRESULT res = ReadFromCache(data, size, processed);
+ if (res == S_OK && size != processed)
+ return S_FALSE;
+ return res;
+}
+
+
+static bool CheckDosTime(UInt32 dosTime)
+{
+ if (dosTime == 0)
+ return true;
+ unsigned month = (dosTime >> 21) & 0xF;
+ unsigned day = (dosTime >> 16) & 0x1F;
+ unsigned hour = (dosTime >> 11) & 0x1F;
+ unsigned min = (dosTime >> 5) & 0x3F;
+ unsigned sec = (dosTime & 0x1F) * 2;
+ if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
+ return false;
+ return true;
+}
+
+API_FUNC_IsArc IsArc_Zip(const Byte *p, size_t size)
+{
+ if (size < 8)
+ return k_IsArc_Res_NEED_MORE;
+ if (p[0] != 'P')
+ return k_IsArc_Res_NO;
+
+ UInt32 sig = Get32(p);
+
+ if (sig == NSignature::kNoSpan || sig == NSignature::kSpan)
+ {
+ p += 4;
+ size -= 4;
+ }
+
+ sig = Get32(p);
+
+ if (sig == NSignature::kEcd64)
+ {
+ if (size < kEcd64_FullSize)
+ return k_IsArc_Res_NEED_MORE;
+
+ const UInt64 recordSize = Get64(p + 4);
+ if ( recordSize < kEcd64_MainSize
+ || recordSize > kEcd64_MainSize + (1 << 20))
+ return k_IsArc_Res_NO;
+ CCdInfo cdInfo;
+ cdInfo.ParseEcd64e(p + 12);
+ if (!cdInfo.IsEmptyArc())
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES; // k_IsArc_Res_YES_2;
+ }
+
+ if (sig == NSignature::kEcd)
+ {
+ if (size < kEcdSize)
+ return k_IsArc_Res_NEED_MORE;
+ CEcd ecd;
+ ecd.Parse(p + 4);
+ // if (ecd.cdSize != 0)
+ if (!ecd.IsEmptyArc())
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES; // k_IsArc_Res_YES_2;
+ }
+
+ if (sig != NSignature::kLocalFileHeader)
+ return k_IsArc_Res_NO;
+
+ if (size < kLocalHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+
+ p += 4;
+
+ {
+ const unsigned kPureHeaderSize = kLocalHeaderSize - 4;
+ unsigned i;
+ for (i = 0; i < kPureHeaderSize && p[i] == 0; i++);
+ if (i == kPureHeaderSize)
+ return k_IsArc_Res_NEED_MORE;
+ }
+
+ /*
+ if (p[0] >= 128) // ExtractVersion.Version;
+ return k_IsArc_Res_NO;
+ */
+
+ // ExtractVersion.Version = p[0];
+ // ExtractVersion.HostOS = p[1];
+ // Flags = Get16(p + 2);
+ // Method = Get16(p + 4);
+ /*
+ // 9.33: some zip archives contain incorrect value in timestamp. So we don't check it now
+ UInt32 dosTime = Get32(p + 6);
+ if (!CheckDosTime(dosTime))
+ return k_IsArc_Res_NO;
+ */
+ // Crc = Get32(p + 10);
+ // PackSize = Get32(p + 14);
+ // Size = Get32(p + 18);
+ const unsigned nameSize = Get16(p + 22);
+ unsigned extraSize = Get16(p + 24);
+ const UInt32 extraOffset = kLocalHeaderSize + (UInt32)nameSize;
+
+ /*
+ // 21.02: fixed. we don't use the following check
+ if (extraOffset + extraSize > (1 << 16))
+ return k_IsArc_Res_NO;
+ */
+
+ p -= 4;
+
+ {
+ size_t rem = size - kLocalHeaderSize;
+ if (rem > nameSize)
+ rem = nameSize;
+ const Byte *p2 = p + kLocalHeaderSize;
+ for (size_t i = 0; i < rem; i++)
+ if (p2[i] == 0)
+ {
+ // we support some "bad" zip archives that contain zeros after name
+ for (size_t k = i + 1; k < rem; k++)
+ if (p2[k] != 0)
+ return k_IsArc_Res_NO;
+ break;
+ /*
+ if (i != nameSize - 1)
+ return k_IsArc_Res_NO;
+ */
+ }
+ }
+
+ if (size < extraOffset)
+ return k_IsArc_Res_NEED_MORE;
+
+ if (extraSize > 0)
+ {
+ p += extraOffset;
+ size -= extraOffset;
+ while (extraSize != 0)
+ {
+ if (extraSize < 4)
+ {
+ // 7-Zip before 9.31 created incorrect WzAES Extra in folder's local headers.
+ // so we return k_IsArc_Res_YES to support such archives.
+ // return k_IsArc_Res_NO; // do we need to support such extra ?
+ return k_IsArc_Res_YES;
+ }
+ if (size < 4)
+ return k_IsArc_Res_NEED_MORE;
+ unsigned dataSize = Get16(p + 2);
+ size -= 4;
+ extraSize -= 4;
+ p += 4;
+ if (dataSize > extraSize)
+ {
+ // It can be error on header.
+ // We want to support such rare case bad archives.
+ // We use additional checks to reduce false-positive probability.
+ if (nameSize == 0
+ || nameSize > (1 << 9)
+ || extraSize > (1 << 9))
+ return k_IsArc_Res_NO;
+ return k_IsArc_Res_YES;
+ }
+ if (dataSize > size)
+ return k_IsArc_Res_NEED_MORE;
+ size -= dataSize;
+ extraSize -= dataSize;
+ p += dataSize;
+ }
+ }
+
+ return k_IsArc_Res_YES;
+}
+
+static UInt32 IsArc_Zip_2(const Byte *p, size_t size, bool isFinal)
+{
+ UInt32 res = IsArc_Zip(p, size);
+ if (res == k_IsArc_Res_NEED_MORE && isFinal)
+ return k_IsArc_Res_NO;
+ return res;
+}
+
+
+
+/* FindPK_4() is allowed to access data up to and including &limit[3].
+ limit[4] access is not allowed.
+ return:
+ (return_ptr < limit) : "PK" was found at (return_ptr)
+ (return_ptr >= limit) : limit was reached or crossed. So no "PK" found before limit
+*/
+Z7_NO_INLINE
+static const Byte *FindPK_4(const Byte *p, const Byte *limit)
+{
+ for (;;)
+ {
+ for (;;)
+ {
+ if (p >= limit)
+ return limit;
+ Byte b = p[1];
+ if (b == 0x4B) { if (p[0] == 0x50) { return p; } p += 1; break; }
+ if (b == 0x50) { if (p[2] == 0x4B) { return p + 1; } p += 2; break; }
+ b = p[3];
+ p += 4;
+ if (b == 0x4B) { if (p[-2]== 0x50) { return p - 2; } p -= 1; break; }
+ if (b == 0x50) { if (p[0] == 0x4B) { return p - 1; } break; }
+ }
+ }
+ /*
+ for (;;)
+ {
+ for (;;)
+ {
+ if (p >= limit)
+ return limit;
+ if (*p++ == 0x50) break;
+ if (*p++ == 0x50) break;
+ if (*p++ == 0x50) break;
+ if (*p++ == 0x50) break;
+ }
+ if (*p == 0x4B)
+ return p - 1;
+ }
+ */
+}
+
+
+/*
+---------- FindMarker ----------
+returns:
+ S_OK:
+ ArcInfo.MarkerVolIndex : volume of marker
+ ArcInfo.MarkerPos : Pos of first signature
+ ArcInfo.MarkerPos2 : Pos of main signature (local item signature in most cases)
+ _streamPos : stream pos
+ _cnt : The number of virtal Bytes after start of search to offset after signature
+ _signature : main signature
+
+ S_FALSE: can't find marker, or there is some non-zip data after marker
+
+ Error code: stream reading error.
+*/
+
+HRESULT CInArchive::FindMarker(const UInt64 *searchLimit)
+{
+ ArcInfo.MarkerPos = GetVirtStreamPos();
+ ArcInfo.MarkerPos2 = ArcInfo.MarkerPos;
+ ArcInfo.MarkerVolIndex = Vols.StreamIndex;
+
+ _cnt = 0;
+
+ CanStartNewVol = false;
+
+ if (searchLimit && *searchLimit == 0)
+ {
+ Byte startBuf[kMarkerSize];
+ RINOK(ReadFromCache_FALSE(startBuf, kMarkerSize))
+
+ UInt32 marker = Get32(startBuf);
+ _signature = marker;
+
+ if ( marker == NSignature::kNoSpan
+ || marker == NSignature::kSpan)
+ {
+ RINOK(ReadFromCache_FALSE(startBuf, kMarkerSize))
+ _signature = Get32(startBuf);
+ }
+
+ if ( _signature != NSignature::kEcd
+ && _signature != NSignature::kEcd64
+ && _signature != NSignature::kLocalFileHeader)
+ return S_FALSE;
+
+ ArcInfo.MarkerPos2 = GetVirtStreamPos() - 4;
+ ArcInfo.IsSpanMode = (marker == NSignature::kSpan);
+
+ // we use weak test in case of (*searchLimit == 0)
+ // since error will be detected later in Open function
+ return S_OK;
+ }
+
+ // zip specification: (_zip_header_size < (1 << 16))
+ // so we need such size to check header
+ const size_t kCheckSize = (size_t)1 << 16;
+ const size_t kBufSize = (size_t)1 << 17; // (kBufSize must be > kCheckSize)
+
+ RINOK(AllocateBuffer(kBufSize))
+
+ _inBufMode = true;
+
+ UInt64 progressPrev = 0;
+
+ for (;;)
+ {
+ RINOK(LookAhead(kBufSize))
+
+ const size_t avail = GetAvail();
+
+ size_t limitPos;
+ // (avail > kBufSize) is possible, if (Buffer.Size() > kBufSize)
+ const bool isFinished = (avail < kBufSize);
+ if (isFinished)
+ {
+ const unsigned kMinAllowed = 4;
+ if (avail <= kMinAllowed)
+ {
+ if ( !IsMultiVol
+ || Vols.StreamIndex < 0
+ || (unsigned)Vols.StreamIndex + 1 >= Vols.Streams.Size())
+ break;
+
+ SkipLookahed(avail);
+
+ const CVols::CSubStreamInfo &s = Vols.Streams[(unsigned)Vols.StreamIndex + 1];
+ if (!s.Stream)
+ break;
+
+ RINOK(s.SeekToStart())
+
+ InitBuf();
+ Vols.StreamIndex++;
+ _streamPos = 0;
+ Stream = s.Stream;
+ continue;
+ }
+ limitPos = avail - kMinAllowed;
+ }
+ else
+ limitPos = (avail - kCheckSize);
+
+ // we don't check at (limitPos) for good fast aligned operations
+
+ if (searchLimit)
+ {
+ if (_cnt > *searchLimit)
+ break;
+ UInt64 rem = *searchLimit - _cnt;
+ if (limitPos > rem)
+ limitPos = (size_t)rem + 1;
+ }
+
+ if (limitPos == 0)
+ break;
+
+ const Byte * const pStart = Buffer + _bufPos;
+ const Byte * p = pStart;
+ const Byte * const limit = pStart + limitPos;
+
+ for (;; p++)
+ {
+ p = FindPK_4(p, limit);
+ if (p >= limit)
+ break;
+ size_t rem = (size_t)(pStart + avail - p);
+ /* 22.02 : we limit check size with kCheckSize to be consistent for
+ any different combination of _bufPos in Buffer and size of Buffer. */
+ if (rem > kCheckSize)
+ rem = kCheckSize;
+ const UInt32 res = IsArc_Zip_2(p, rem, isFinished);
+ if (res != k_IsArc_Res_NO)
+ {
+ if (rem < kMarkerSize)
+ return S_FALSE;
+ _signature = Get32(p);
+ SkipLookahed((size_t)(p - pStart));
+ ArcInfo.MarkerVolIndex = Vols.StreamIndex;
+ ArcInfo.MarkerPos = GetVirtStreamPos();
+ ArcInfo.MarkerPos2 = ArcInfo.MarkerPos;
+ SkipLookahed(4);
+ if ( _signature == NSignature::kNoSpan
+ || _signature == NSignature::kSpan)
+ {
+ if (rem < kMarkerSize * 2)
+ return S_FALSE;
+ ArcInfo.IsSpanMode = (_signature == NSignature::kSpan);
+ _signature = Get32(p + 4);
+ ArcInfo.MarkerPos2 += 4;
+ SkipLookahed(4);
+ }
+ return S_OK;
+ }
+ }
+
+ if (!IsMultiVol && isFinished)
+ break;
+
+ SkipLookahed((size_t)(p - pStart));
+
+ if (Callback && (_cnt - progressPrev) >= ((UInt32)1 << 23))
+ {
+ progressPrev = _cnt;
+ // const UInt64 numFiles64 = 0;
+ RINOK(Callback->SetCompleted(NULL, &_cnt))
+ }
+ }
+
+ return S_FALSE;
+}
+
+
+/*
+---------- IncreaseRealPosition ----------
+moves virtual offset in virtual stream.
+changing to new volumes is allowed
+*/
+
+HRESULT CInArchive::IncreaseRealPosition(UInt64 offset, bool &isFinished)
+{
+ isFinished = false;
+
+ for (;;)
+ {
+ const size_t avail = GetAvail();
+
+ if (offset <= avail)
+ {
+ _bufPos += (size_t)offset;
+ _cnt += offset;
+ return S_OK;
+ }
+
+ _cnt += avail;
+ offset -= avail;
+
+ _bufCached = 0;
+ _bufPos = 0;
+
+ if (!_inBufMode)
+ break;
+
+ CanStartNewVol = true;
+ LookAhead(1);
+
+ if (GetAvail() == 0)
+ return S_OK;
+ }
+
+ // cache is empty
+
+ if (!IsMultiVol)
+ {
+ _cnt += offset;
+ return Stream->Seek((Int64)offset, STREAM_SEEK_CUR, &_streamPos);
+ }
+
+ for (;;)
+ {
+ if (offset == 0)
+ return S_OK;
+
+ if (Vols.StreamIndex < 0)
+ return S_FALSE;
+ if ((unsigned)Vols.StreamIndex >= Vols.Streams.Size())
+ {
+ isFinished = true;
+ return S_OK;
+ }
+ {
+ const CVols::CSubStreamInfo &s = Vols.Streams[(unsigned)Vols.StreamIndex];
+ if (!s.Stream)
+ {
+ isFinished = true;
+ return S_OK;
+ }
+ if (_streamPos > s.Size)
+ return S_FALSE;
+ const UInt64 rem = s.Size - _streamPos;
+ if ((UInt64)offset <= rem)
+ {
+ _cnt += offset;
+ return Stream->Seek((Int64)offset, STREAM_SEEK_CUR, &_streamPos);
+ }
+ RINOK(Seek_SavePos(s.Size))
+ offset -= rem;
+ _cnt += rem;
+ }
+
+ Stream = NULL;
+ _streamPos = 0;
+ Vols.StreamIndex++;
+ if ((unsigned)Vols.StreamIndex >= Vols.Streams.Size())
+ {
+ isFinished = true;
+ return S_OK;
+ }
+ const CVols::CSubStreamInfo &s2 = Vols.Streams[(unsigned)Vols.StreamIndex];
+ if (!s2.Stream)
+ {
+ isFinished = true;
+ return S_OK;
+ }
+ Stream = s2.Stream;
+ RINOK(Seek_SavePos(0))
+ }
+}
+
+
+
+/*
+---------- LookAhead ----------
+Reads data to buffer, if required.
+
+It can read from volumes as long as Buffer.Size().
+But it moves to new volume, only if it's required to provide minRequired bytes in buffer.
+
+in:
+ (minRequired <= Buffer.Size())
+
+return:
+ S_OK : if (GetAvail() < minRequired) after function return, it's end of stream(s) data, or no new volume stream.
+ Error codes: IInStream::Read() error or IInStream::Seek() error for multivol
+*/
+
+HRESULT CInArchive::LookAhead(size_t minRequired)
+{
+ for (;;)
+ {
+ const size_t avail = GetAvail();
+
+ if (minRequired <= avail)
+ return S_OK;
+
+ if (_bufPos != 0)
+ {
+ if (avail != 0)
+ memmove(Buffer, Buffer + _bufPos, avail);
+ _bufPos = 0;
+ _bufCached = avail;
+ }
+
+ const size_t pos = _bufCached;
+ UInt32 processed = 0;
+ HRESULT res = Stream->Read(Buffer + pos, (UInt32)(Buffer.Size() - pos), &processed);
+ _streamPos += processed;
+ _bufCached += processed;
+
+ if (res != S_OK)
+ return res;
+
+ if (processed != 0)
+ continue;
+
+ if ( !IsMultiVol
+ || !CanStartNewVol
+ || Vols.StreamIndex < 0
+ || (unsigned)Vols.StreamIndex + 1 >= Vols.Streams.Size())
+ return S_OK;
+
+ const CVols::CSubStreamInfo &s = Vols.Streams[(unsigned)Vols.StreamIndex + 1];
+ if (!s.Stream)
+ return S_OK;
+
+ RINOK(s.SeekToStart())
+
+ Vols.StreamIndex++;
+ _streamPos = 0;
+ Stream = s.Stream;
+ // Vols.NeedSeek = false;
+ }
+}
+
+
+class CUnexpectEnd {};
+
+
+/*
+---------- SafeRead ----------
+
+reads data of exact size from stream(s)
+
+in:
+ _inBufMode
+ if (CanStartNewVol) it can go to next volume before first byte reading, if there is end of volume data.
+
+in, out:
+ _streamPos : position in Stream
+ Stream
+ Vols : if (IsMultiVol)
+ _cnt
+
+out:
+ (CanStartNewVol == false), if some data was read
+
+return:
+ S_OK : success reading of requested data
+
+exceptions:
+ CSystemException() - stream reading error
+ CUnexpectEnd() : could not read data of requested size
+*/
+
+void CInArchive::SafeRead(Byte *data, unsigned size)
+{
+ unsigned processed;
+ HRESULT result = ReadFromCache(data, size, processed);
+ if (result != S_OK)
+ throw CSystemException(result);
+ if (size != processed)
+ throw CUnexpectEnd();
+}
+
+void CInArchive::ReadBuffer(CByteBuffer &buffer, unsigned size)
+{
+ buffer.Alloc(size);
+ if (size != 0)
+ SafeRead(buffer, size);
+}
+
+// Byte CInArchive::ReadByte () { Byte b; SafeRead(&b, 1); return b; }
+// UInt16 CInArchive::ReadUInt16() { Byte buf[2]; SafeRead(buf, 2); return Get16(buf); }
+UInt32 CInArchive::ReadUInt32() { Byte buf[4]; SafeRead(buf, 4); return Get32(buf); }
+UInt64 CInArchive::ReadUInt64() { Byte buf[8]; SafeRead(buf, 8); return Get64(buf); }
+
+void CInArchive::ReadSignature()
+{
+ CanStartNewVol = true;
+ _signature = ReadUInt32();
+ // CanStartNewVol = false; // it's already changed in SafeRead
+}
+
+
+// we Skip() inside headers only, so no need for stream change in multivol.
+
+void CInArchive::Skip(size_t num)
+{
+ while (num != 0)
+ {
+ const unsigned kBufSize = (size_t)1 << 10;
+ Byte buf[kBufSize];
+ unsigned step = kBufSize;
+ if (step > num)
+ step = (unsigned)num;
+ SafeRead(buf, step);
+ num -= step;
+ }
+}
+
+/*
+HRESULT CInArchive::Callback_Completed(unsigned numFiles)
+{
+ const UInt64 numFiles64 = numFiles;
+ return Callback->SetCompleted(&numFiles64, &_cnt);
+}
+*/
+
+HRESULT CInArchive::Skip64(UInt64 num, unsigned numFiles)
+{
+ if (num == 0)
+ return S_OK;
+
+ for (;;)
+ {
+ size_t step = (size_t)1 << 24;
+ if (step > num)
+ step = (size_t)num;
+ Skip(step);
+ num -= step;
+ if (num == 0)
+ return S_OK;
+ if (Callback)
+ {
+ const UInt64 numFiles64 = numFiles;
+ RINOK(Callback->SetCompleted(&numFiles64, &_cnt))
+ }
+ }
+}
+
+
+bool CInArchive::ReadFileName(unsigned size, AString &s)
+{
+ if (size == 0)
+ {
+ s.Empty();
+ return true;
+ }
+ char *p = s.GetBuf(size);
+ SafeRead((Byte *)p, size);
+ unsigned i = size;
+ do
+ {
+ if (p[i - 1] != 0)
+ break;
+ }
+ while (--i);
+ s.ReleaseBuf_CalcLen(size);
+ return s.Len() == i;
+}
+
+
+#define ZIP64_IS_32_MAX(n) ((n) == 0xFFFFFFFF)
+#define ZIP64_IS_16_MAX(n) ((n) == 0xFFFF)
+
+
+bool CInArchive::ReadExtra(const CLocalItem &item, unsigned extraSize, CExtraBlock &extra,
+ UInt64 &unpackSize, UInt64 &packSize,
+ CItem *cdItem)
+{
+ extra.Clear();
+
+ while (extraSize >= 4)
+ {
+ CExtraSubBlock subBlock;
+ const UInt32 pair = ReadUInt32();
+ subBlock.ID = (pair & 0xFFFF);
+ unsigned size = (unsigned)(pair >> 16);
+ // const unsigned origSize = size;
+
+ extraSize -= 4;
+
+ if (size > extraSize)
+ {
+ // it's error in extra
+ HeadersWarning = true;
+ extra.Error = true;
+ Skip(extraSize);
+ return false;
+ }
+
+ extraSize -= size;
+
+ if (subBlock.ID == NFileHeader::NExtraID::kZip64)
+ {
+ extra.IsZip64 = true;
+ bool isOK = true;
+
+ if (!cdItem
+ && size == 16
+ && !ZIP64_IS_32_MAX(unpackSize)
+ && !ZIP64_IS_32_MAX(packSize))
+ {
+ /* Win10 Explorer's "Send to Zip" for big (3500 MiB) files
+ creates Zip64 Extra in local file header.
+ But if both uncompressed and compressed sizes are smaller than 4 GiB,
+ Win10 doesn't store 0xFFFFFFFF in 32-bit fields as expected by zip specification.
+ 21.04: we ignore these minor errors in Win10 zip archives. */
+ if (ReadUInt64() != unpackSize)
+ isOK = false;
+ if (ReadUInt64() != packSize)
+ isOK = false;
+ size = 0;
+ }
+ else
+ {
+ if (ZIP64_IS_32_MAX(unpackSize))
+ { if (size < 8) isOK = false; else { size -= 8; unpackSize = ReadUInt64(); }}
+
+ if (isOK && ZIP64_IS_32_MAX(packSize))
+ { if (size < 8) isOK = false; else { size -= 8; packSize = ReadUInt64(); }}
+
+ if (cdItem)
+ {
+ if (isOK)
+ {
+ if (ZIP64_IS_32_MAX(cdItem->LocalHeaderPos))
+ { if (size < 8) isOK = false; else { size -= 8; cdItem->LocalHeaderPos = ReadUInt64(); }}
+ /*
+ else if (size == 8)
+ {
+ size -= 8;
+ const UInt64 v = ReadUInt64();
+ // soong_zip, an AOSP tool (written in the Go) writes incorrect value.
+ // we can ignore that minor error here
+ if (v != cdItem->LocalHeaderPos)
+ isOK = false; // ignore error
+ // isOK = false; // force error
+ }
+ */
+ }
+
+ if (isOK && ZIP64_IS_16_MAX(cdItem->Disk))
+ { if (size < 4) isOK = false; else { size -= 4; cdItem->Disk = ReadUInt32(); }}
+ }
+ }
+
+ // we can ignore errors, when some zip archiver still write all fields to zip64 extra in local header
+ // if (&& (cdItem || !isOK || origSize != 8 * 3 + 4 || size != 8 * 1 + 4))
+ if (!isOK || size != 0)
+ {
+ HeadersWarning = true;
+ extra.Error = true;
+ extra.IsZip64_Error = true;
+ }
+ Skip(size);
+ }
+ else
+ {
+ ReadBuffer(subBlock.Data, size);
+ extra.SubBlocks.Add(subBlock);
+ if (subBlock.ID == NFileHeader::NExtraID::kIzUnicodeName)
+ {
+ if (!subBlock.CheckIzUnicode(item.Name))
+ extra.Error = true;
+ }
+ }
+ }
+
+ if (extraSize != 0)
+ {
+ ExtraMinorError = true;
+ extra.MinorError = true;
+ // 7-Zip before 9.31 created incorrect WzAES Extra in folder's local headers.
+ // so we don't return false, but just set warning flag
+ // return false;
+ Skip(extraSize);
+ }
+
+ return true;
+}
+
+
+bool CInArchive::ReadLocalItem(CItemEx &item)
+{
+ item.Disk = 0;
+ if (IsMultiVol && Vols.StreamIndex >= 0)
+ item.Disk = (UInt32)Vols.StreamIndex;
+ const unsigned kPureHeaderSize = kLocalHeaderSize - 4;
+ Byte p[kPureHeaderSize];
+ SafeRead(p, kPureHeaderSize);
+ {
+ unsigned i;
+ for (i = 0; i < kPureHeaderSize && p[i] == 0; i++);
+ if (i == kPureHeaderSize)
+ return false;
+ }
+
+ item.ExtractVersion.Version = p[0];
+ item.ExtractVersion.HostOS = p[1];
+ G16(2, item.Flags);
+ G16(4, item.Method);
+ G32(6, item.Time);
+ G32(10, item.Crc);
+ G32(14, item.PackSize);
+ G32(18, item.Size);
+ const unsigned nameSize = Get16(p + 22);
+ const unsigned extraSize = Get16(p + 24);
+ bool isOkName = ReadFileName(nameSize, item.Name);
+ item.LocalFullHeaderSize = kLocalHeaderSize + (UInt32)nameSize + extraSize;
+ item.DescriptorWasRead = false;
+
+ /*
+ if (item.IsDir())
+ item.Size = 0; // check It
+ */
+
+ if (extraSize > 0)
+ {
+ if (!ReadExtra(item, extraSize, item.LocalExtra, item.Size, item.PackSize, NULL))
+ {
+ /* Most of archives are OK for Extra. But there are some rare cases
+ that have error. And if error in first item, it can't open archive.
+ So we ignore that error */
+ // return false;
+ }
+ }
+
+ if (!CheckDosTime(item.Time))
+ {
+ HeadersWarning = true;
+ // return false;
+ }
+
+ if (item.Name.Len() != nameSize)
+ {
+ // we support some "bad" zip archives that contain zeros after name
+ if (!isOkName)
+ return false;
+ HeadersWarning = true;
+ }
+
+ // return item.LocalFullHeaderSize <= ((UInt32)1 << 16);
+ return true;
+}
+
+
+static bool FlagsAreSame(const CItem &i1, const CItem &i2_cd)
+{
+ if (i1.Method != i2_cd.Method)
+ return false;
+
+ UInt32 mask = i1.Flags ^ i2_cd.Flags;
+ if (mask == 0)
+ return true;
+ switch (i1.Method)
+ {
+ case NFileHeader::NCompressionMethod::kDeflate:
+ mask &= 0x7FF9;
+ break;
+ default:
+ if (i1.Method <= NFileHeader::NCompressionMethod::kImplode)
+ mask &= 0x7FFF;
+ }
+
+ // we can ignore utf8 flag, if name is ascii, or if only cdItem has utf8 flag
+ if (mask & NFileHeader::NFlags::kUtf8)
+ if ((i1.Name.IsAscii() && i2_cd.Name.IsAscii())
+ || (i2_cd.Flags & NFileHeader::NFlags::kUtf8))
+ mask &= ~NFileHeader::NFlags::kUtf8;
+
+ // some bad archive in rare case can use descriptor without descriptor flag in Central Dir
+ // if (i1.HasDescriptor())
+ mask &= ~NFileHeader::NFlags::kDescriptorUsedMask;
+
+ return (mask == 0);
+}
+
+
+// #ifdef _WIN32
+static bool AreEqualPaths_IgnoreSlashes(const char *s1, const char *s2)
+{
+ for (;;)
+ {
+ char c1 = *s1++;
+ char c2 = *s2++;
+ if (c1 == c2)
+ {
+ if (c1 == 0)
+ return true;
+ }
+ else
+ {
+ if (c1 == '\\') c1 = '/';
+ if (c2 == '\\') c2 = '/';
+ if (c1 != c2)
+ return false;
+ }
+ }
+}
+// #endif
+
+
+static bool AreItemsEqual(const CItemEx &localItem, const CItemEx &cdItem)
+{
+ if (!FlagsAreSame(localItem, cdItem))
+ return false;
+ if (!localItem.HasDescriptor())
+ {
+ if (cdItem.PackSize != localItem.PackSize
+ || cdItem.Size != localItem.Size
+ || (cdItem.Crc != localItem.Crc && cdItem.Crc != 0)) // some program writes 0 to crc field in central directory
+ return false;
+ }
+ /* pkzip 2.50 creates incorrect archives. It uses
+ - WIN encoding for name in local header
+ - OEM encoding for name in central header
+ We don't support these strange items. */
+
+ /* if (cdItem.Name.Len() != localItem.Name.Len())
+ return false;
+ */
+ if (cdItem.Name != localItem.Name)
+ {
+ // #ifdef _WIN32
+ // some xap files use backslash in central dir items.
+ // we can ignore such errors in windows, where all slashes are converted to backslashes
+ unsigned hostOs = cdItem.GetHostOS();
+
+ if (hostOs == NFileHeader::NHostOS::kFAT ||
+ hostOs == NFileHeader::NHostOS::kNTFS)
+ {
+ if (!AreEqualPaths_IgnoreSlashes(cdItem.Name, localItem.Name))
+ {
+ // pkzip 2.50 uses DOS encoding in central dir and WIN encoding in local header.
+ // so we ignore that error
+ if (hostOs != NFileHeader::NHostOS::kFAT
+ || cdItem.MadeByVersion.Version < 25
+ || cdItem.MadeByVersion.Version > 40)
+ return false;
+ }
+ }
+ /*
+ else
+ #endif
+ return false;
+ */
+ }
+ return true;
+}
+
+
+HRESULT CInArchive::Read_LocalItem_After_CdItem(CItemEx &item, bool &isAvail, bool &headersError)
+{
+ isAvail = true;
+ headersError = false;
+ if (item.FromLocal)
+ return S_OK;
+ try
+ {
+ UInt64 offset = item.LocalHeaderPos;
+
+ if (IsMultiVol)
+ {
+ if (item.Disk >= Vols.Streams.Size())
+ {
+ isAvail = false;
+ return S_FALSE;
+ }
+ Stream = Vols.Streams[item.Disk].Stream;
+ Vols.StreamIndex = (int)item.Disk;
+ if (!Stream)
+ {
+ isAvail = false;
+ return S_FALSE;
+ }
+ }
+ else
+ {
+ if (UseDisk_in_SingleVol && item.Disk != EcdVolIndex)
+ {
+ isAvail = false;
+ return S_FALSE;
+ }
+ Stream = StreamRef;
+
+ offset = (UInt64)((Int64)offset + ArcInfo.Base);
+ if (ArcInfo.Base < 0 && (Int64)offset < 0)
+ {
+ isAvail = false;
+ return S_FALSE;
+ }
+ }
+
+ _inBufMode = false;
+ RINOK(Seek_SavePos(offset))
+ InitBuf();
+ /*
+ // we can use buf mode with small buffer to reduce
+ // the number of Read() calls in ReadLocalItem()
+ _inBufMode = true;
+ Buffer.Alloc(1 << 10);
+ if (!Buffer.IsAllocated())
+ return E_OUTOFMEMORY;
+ */
+
+ CItemEx localItem;
+ if (ReadUInt32() != NSignature::kLocalFileHeader)
+ return S_FALSE;
+ ReadLocalItem(localItem);
+ if (!AreItemsEqual(localItem, item))
+ return S_FALSE;
+ item.LocalFullHeaderSize = localItem.LocalFullHeaderSize;
+ item.LocalExtra = localItem.LocalExtra;
+ if (item.Crc != localItem.Crc && !localItem.HasDescriptor())
+ {
+ item.Crc = localItem.Crc;
+ headersError = true;
+ }
+ if ((item.Flags ^ localItem.Flags) & NFileHeader::NFlags::kDescriptorUsedMask)
+ {
+ item.Flags = (UInt16)(item.Flags ^ NFileHeader::NFlags::kDescriptorUsedMask);
+ headersError = true;
+ }
+ item.FromLocal = true;
+ }
+ catch(...) { return S_FALSE; }
+ return S_OK;
+}
+
+
+/*
+---------- FindDescriptor ----------
+
+in:
+ _streamPos : position in Stream
+ Stream :
+ Vols : if (IsMultiVol)
+
+action:
+ searches descriptor in input stream(s).
+ sets
+ item.DescriptorWasRead = true;
+ item.Size
+ item.PackSize
+ item.Crc
+ if descriptor was found
+
+out:
+ S_OK:
+ if ( item.DescriptorWasRead) : if descriptor was found
+ if (!item.DescriptorWasRead) : if descriptor was not found : unexpected end of stream(s)
+
+ S_FALSE: if no items or there is just one item with strange properies that doesn't look like real archive.
+
+ another error code: Callback error.
+
+exceptions :
+ CSystemException() : stream reading error
+*/
+
+HRESULT CInArchive::FindDescriptor(CItemEx &item, unsigned numFiles)
+{
+ // const size_t kBufSize = (size_t)1 << 5; // don't increase it too much. It reads data look ahead.
+
+ // Buffer.Alloc(kBufSize);
+ // Byte *buf = Buffer;
+
+ UInt64 packedSize = 0;
+
+ UInt64 progressPrev = _cnt;
+
+ for (;;)
+ {
+ /* appnote specification claims that we must use 64-bit descriptor, if there is zip64 extra.
+ But some old third-party xps archives used 64-bit descriptor without zip64 extra. */
+ // unsigned descriptorSize = kDataDescriptorSize64 + kNextSignatureSize;
+
+ // const unsigned kNextSignatureSize = 0; // we can disable check for next signatuire
+ const unsigned kNextSignatureSize = 4; // we check also for signature for next File headear
+
+ const unsigned descriptorSize4 = item.GetDescriptorSize() + kNextSignatureSize;
+
+ if (descriptorSize4 > Buffer.Size()) return E_FAIL;
+
+ // size_t processedSize;
+ CanStartNewVol = true;
+ RINOK(LookAhead(descriptorSize4))
+ const size_t avail = GetAvail();
+
+ if (avail < descriptorSize4)
+ {
+ // we write to packSize all these available bytes.
+ // later it's simpler to work with such value than with 0
+ // if (item.PackSize == 0)
+ item.PackSize = packedSize + avail;
+ if (item.Method == 0)
+ item.Size = item.PackSize;
+ SkipLookahed(avail);
+ return S_OK;
+ }
+
+ const Byte * const pStart = Buffer + _bufPos;
+ const Byte * p = pStart;
+ const Byte * const limit = pStart + (avail - descriptorSize4);
+
+ for (; p <= limit; p++)
+ {
+ // descriptor signature field is Info-ZIP's extension to pkware Zip specification.
+ // New ZIP specification also allows descriptorSignature.
+
+ p = FindPK_4(p, limit + 1);
+ if (p > limit)
+ break;
+
+ /*
+ if (*p != 0x50)
+ continue;
+ */
+
+ if (Get32(p) != NSignature::kDataDescriptor)
+ continue;
+
+ // we check next signatuire after descriptor
+ // maybe we need check only 2 bytes "PK" instead of 4 bytes, if some another type of header is possible after descriptor
+ const UInt32 sig = Get32(p + descriptorSize4 - kNextSignatureSize);
+ if ( sig != NSignature::kLocalFileHeader
+ && sig != NSignature::kCentralFileHeader)
+ continue;
+
+ const UInt64 packSizeCur = packedSize + (size_t)(p - pStart);
+ if (descriptorSize4 == kDataDescriptorSize64 + kNextSignatureSize) // if (item.LocalExtra.IsZip64)
+ {
+ const UInt64 descriptorPackSize = Get64(p + 8);
+ if (descriptorPackSize != packSizeCur)
+ continue;
+ item.Size = Get64(p + 16);
+ }
+ else
+ {
+ const UInt32 descriptorPackSize = Get32(p + 8);
+ if (descriptorPackSize != (UInt32)packSizeCur)
+ continue;
+ item.Size = Get32(p + 12);
+ // that item.Size can be truncated to 32-bit value here
+ }
+ // We write calculated 64-bit packSize, even if descriptor64 was not used
+ item.PackSize = packSizeCur;
+
+ item.DescriptorWasRead = true;
+ item.Crc = Get32(p + 4);
+
+ const size_t skip = (size_t)(p - pStart) + descriptorSize4 - kNextSignatureSize;
+
+ SkipLookahed(skip);
+
+ return S_OK;
+ }
+
+ const size_t skip = (size_t)(p - pStart);
+ SkipLookahed(skip);
+
+ packedSize += skip;
+
+ if (Callback)
+ if (_cnt - progressPrev >= ((UInt32)1 << 22))
+ {
+ progressPrev = _cnt;
+ const UInt64 numFiles64 = numFiles;
+ RINOK(Callback->SetCompleted(&numFiles64, &_cnt))
+ }
+ }
+}
+
+
+HRESULT CInArchive::CheckDescriptor(const CItemEx &item)
+{
+ if (!item.HasDescriptor())
+ return S_OK;
+
+ // pkzip's version without descriptor signature is not supported
+
+ bool isFinished = false;
+ RINOK(IncreaseRealPosition(item.PackSize, isFinished))
+ if (isFinished)
+ return S_FALSE;
+
+ /*
+ if (!IsMultiVol)
+ {
+ RINOK(Seek_SavePos(ArcInfo.Base + item.GetDataPosition() + item.PackSize));
+ }
+ */
+
+ Byte buf[kDataDescriptorSize64];
+ try
+ {
+ CanStartNewVol = true;
+ SafeRead(buf, item.GetDescriptorSize());
+ }
+ catch (const CSystemException &e) { return e.ErrorCode; }
+ // catch (const CUnexpectEnd &)
+ catch(...)
+ {
+ return S_FALSE;
+ }
+ // RINOK(ReadStream_FALSE(Stream, buf, item.GetDescriptorSize()));
+
+ if (Get32(buf) != NSignature::kDataDescriptor)
+ return S_FALSE;
+ UInt32 crc = Get32(buf + 4);
+ UInt64 packSize, unpackSize;
+
+ if (item.LocalExtra.IsZip64)
+ {
+ packSize = Get64(buf + 8);
+ unpackSize = Get64(buf + 16);
+ }
+ else
+ {
+ packSize = Get32(buf + 8);
+ unpackSize = Get32(buf + 12);
+ }
+
+ if (crc != item.Crc || item.PackSize != packSize || item.Size != unpackSize)
+ return S_FALSE;
+ return S_OK;
+}
+
+
+HRESULT CInArchive::Read_LocalItem_After_CdItem_Full(CItemEx &item)
+{
+ if (item.FromLocal)
+ return S_OK;
+ try
+ {
+ bool isAvail = true;
+ bool headersError = false;
+ RINOK(Read_LocalItem_After_CdItem(item, isAvail, headersError))
+ if (headersError)
+ return S_FALSE;
+ if (item.HasDescriptor())
+ return CheckDescriptor(item);
+ }
+ catch(...) { return S_FALSE; }
+ return S_OK;
+}
+
+
+HRESULT CInArchive::ReadCdItem(CItemEx &item)
+{
+ item.FromCentral = true;
+ Byte p[kCentralHeaderSize - 4];
+ SafeRead(p, kCentralHeaderSize - 4);
+
+ item.MadeByVersion.Version = p[0];
+ item.MadeByVersion.HostOS = p[1];
+ item.ExtractVersion.Version = p[2];
+ item.ExtractVersion.HostOS = p[3];
+ G16(4, item.Flags);
+ G16(6, item.Method);
+ G32(8, item.Time);
+ G32(12, item.Crc);
+ G32(16, item.PackSize);
+ G32(20, item.Size);
+ const unsigned nameSize = Get16(p + 24);
+ const unsigned extraSize = Get16(p + 26);
+ const unsigned commentSize = Get16(p + 28);
+ G16(30, item.Disk);
+ G16(32, item.InternalAttrib);
+ G32(34, item.ExternalAttrib);
+ G32(38, item.LocalHeaderPos);
+ ReadFileName(nameSize, item.Name);
+
+ if (extraSize > 0)
+ ReadExtra(item, extraSize, item.CentralExtra, item.Size, item.PackSize, &item);
+
+ // May be these strings must be deleted
+ /*
+ if (item.IsDir())
+ item.Size = 0;
+ */
+
+ ReadBuffer(item.Comment, commentSize);
+ return S_OK;
+}
+
+
+/*
+TryEcd64()
+ (_inBufMode == false) is expected here
+ so TryEcd64() can't change the Buffer.
+ if (Ecd64 is not covered by cached region),
+ TryEcd64() can change cached region ranges (_bufCached, _bufPos) and _streamPos.
+*/
+
+HRESULT CInArchive::TryEcd64(UInt64 offset, CCdInfo &cdInfo)
+{
+ if (offset >= ((UInt64)1 << 63))
+ return S_FALSE;
+ Byte buf[kEcd64_FullSize];
+
+ RINOK(SeekToVol(Vols.StreamIndex, offset))
+ RINOK(ReadFromCache_FALSE(buf, kEcd64_FullSize))
+
+ if (Get32(buf) != NSignature::kEcd64)
+ return S_FALSE;
+ UInt64 mainSize = Get64(buf + 4);
+ if (mainSize < kEcd64_MainSize || mainSize > ((UInt64)1 << 40))
+ return S_FALSE;
+ cdInfo.ParseEcd64e(buf + 12);
+ return S_OK;
+}
+
+
+/* FindCd() doesn't use previous cached region,
+ but it uses Buffer. So it sets new cached region */
+
+HRESULT CInArchive::FindCd(bool checkOffsetMode)
+{
+ CCdInfo &cdInfo = Vols.ecd;
+
+ UInt64 endPos;
+
+ // There are no useful data in cache in most cases here.
+ // So here we don't use cache data from previous operations .
+
+ InitBuf();
+ RINOK(InStream_GetSize_SeekToEnd(Stream, endPos))
+ _streamPos = endPos;
+
+ // const UInt32 kBufSizeMax2 = ((UInt32)1 << 16) + kEcdSize + kEcd64Locator_Size + kEcd64_FullSize;
+ const size_t kBufSizeMax = ((size_t)1 << 17); // must be larger than kBufSizeMax2
+
+ const size_t bufSize = (endPos < kBufSizeMax) ? (size_t)endPos : kBufSizeMax;
+ if (bufSize < kEcdSize)
+ return S_FALSE;
+ // CByteArr byteBuffer(bufSize);
+
+ RINOK(AllocateBuffer(kBufSizeMax))
+
+ RINOK(Seek_SavePos(endPos - bufSize))
+
+ size_t processed = bufSize;
+ HRESULT res = ReadStream(Stream, Buffer, &processed);
+ _streamPos += processed;
+ _bufCached = processed;
+ _bufPos = 0;
+ _cnt += processed;
+ if (res != S_OK)
+ return res;
+ if (processed != bufSize)
+ return S_FALSE;
+
+
+ for (size_t i = bufSize - kEcdSize + 1;;)
+ {
+ if (i == 0)
+ return S_FALSE;
+
+ const Byte *buf = Buffer;
+
+ for (;;)
+ {
+ i--;
+ if (buf[i] == 0x50)
+ break;
+ if (i == 0)
+ return S_FALSE;
+ }
+
+ if (Get32(buf + i) != NSignature::kEcd)
+ continue;
+
+ cdInfo.ParseEcd32(buf + i);
+
+ if (i >= kEcd64Locator_Size)
+ {
+ const size_t locatorIndex = i - kEcd64Locator_Size;
+ if (Get32(buf + locatorIndex) == NSignature::kEcd64Locator)
+ {
+ CLocator locator;
+ locator.Parse(buf + locatorIndex + 4);
+ UInt32 numDisks = locator.NumDisks;
+ // we ignore the error, where some zip creators use (NumDisks == 0)
+ if (numDisks == 0)
+ numDisks = 1;
+ if ((cdInfo.ThisDisk == numDisks - 1 || ZIP64_IS_16_MAX(cdInfo.ThisDisk))
+ && locator.Ecd64Disk < numDisks)
+ {
+ if (locator.Ecd64Disk != cdInfo.ThisDisk && !ZIP64_IS_16_MAX(cdInfo.ThisDisk))
+ return E_NOTIMPL;
+
+ // Most of the zip64 use fixed size Zip64 ECD
+ // we try relative backward reading.
+
+ UInt64 absEcd64 = endPos - bufSize + i - (kEcd64Locator_Size + kEcd64_FullSize);
+
+ if (locatorIndex >= kEcd64_FullSize)
+ if (checkOffsetMode || absEcd64 == locator.Ecd64Offset)
+ {
+ const Byte *ecd64 = buf + locatorIndex - kEcd64_FullSize;
+ if (Get32(ecd64) == NSignature::kEcd64)
+ {
+ UInt64 mainEcd64Size = Get64(ecd64 + 4);
+ if (mainEcd64Size == kEcd64_MainSize)
+ {
+ cdInfo.ParseEcd64e(ecd64 + 12);
+ ArcInfo.Base = (Int64)(absEcd64 - locator.Ecd64Offset);
+ // ArcInfo.BaseVolIndex = cdInfo.ThisDisk;
+ return S_OK;
+ }
+ }
+ }
+
+ // some zip64 use variable size Zip64 ECD.
+ // we try to use absolute offset from locator.
+
+ if (absEcd64 != locator.Ecd64Offset)
+ {
+ if (TryEcd64(locator.Ecd64Offset, cdInfo) == S_OK)
+ {
+ ArcInfo.Base = 0;
+ // ArcInfo.BaseVolIndex = cdInfo.ThisDisk;
+ return S_OK;
+ }
+ }
+
+ // for variable Zip64 ECD with for archives with offset != 0.
+
+ if (checkOffsetMode
+ && ArcInfo.MarkerPos != 0
+ && ArcInfo.MarkerPos + locator.Ecd64Offset != absEcd64)
+ {
+ if (TryEcd64(ArcInfo.MarkerPos + locator.Ecd64Offset, cdInfo) == S_OK)
+ {
+ ArcInfo.Base = (Int64)ArcInfo.MarkerPos;
+ // ArcInfo.BaseVolIndex = cdInfo.ThisDisk;
+ return S_OK;
+ }
+ }
+ }
+ }
+ }
+
+ // bool isVolMode = (Vols.EndVolIndex != -1);
+ // UInt32 searchDisk = (isVolMode ? Vols.EndVolIndex : 0);
+
+ if (/* searchDisk == thisDisk && */ cdInfo.CdDisk <= cdInfo.ThisDisk)
+ {
+ // if (isVolMode)
+ {
+ if (cdInfo.CdDisk != cdInfo.ThisDisk)
+ return S_OK;
+ }
+
+ UInt64 absEcdPos = endPos - bufSize + i;
+ UInt64 cdEnd = cdInfo.Size + cdInfo.Offset;
+ ArcInfo.Base = 0;
+ // ArcInfo.BaseVolIndex = cdInfo.ThisDisk;
+ if (absEcdPos != cdEnd)
+ {
+ /*
+ if (cdInfo.Offset <= 16 && cdInfo.Size != 0)
+ {
+ // here we support some rare ZIP files with Central directory at the start
+ ArcInfo.Base = 0;
+ }
+ else
+ */
+ ArcInfo.Base = (Int64)(absEcdPos - cdEnd);
+ }
+ return S_OK;
+ }
+ }
+}
+
+
+HRESULT CInArchive::TryReadCd(CObjectVector<CItemEx> &items, const CCdInfo &cdInfo, UInt64 cdOffset, UInt64 cdSize)
+{
+ items.Clear();
+ IsCdUnsorted = false;
+
+ // _startLocalFromCd_Disk = (UInt32)(Int32)-1;
+ // _startLocalFromCd_Offset = (UInt64)(Int64)-1;
+
+ RINOK(SeekToVol(IsMultiVol ? (int)cdInfo.CdDisk : -1, cdOffset))
+
+ _inBufMode = true;
+ _cnt = 0;
+
+ if (Callback)
+ {
+ RINOK(Callback->SetTotal(&cdInfo.NumEntries, IsMultiVol ? &Vols.TotalBytesSize : NULL))
+ }
+ UInt64 numFileExpected = cdInfo.NumEntries;
+ const UInt64 *totalFilesPtr = &numFileExpected;
+ bool isCorrect_NumEntries = (cdInfo.IsFromEcd64 || numFileExpected >= ((UInt32)1 << 16));
+
+ while (_cnt < cdSize)
+ {
+ CanStartNewVol = true;
+ if (ReadUInt32() != NSignature::kCentralFileHeader)
+ return S_FALSE;
+ CanStartNewVol = false;
+ {
+ CItemEx cdItem;
+ RINOK(ReadCdItem(cdItem))
+
+ /*
+ if (cdItem.Disk < _startLocalFromCd_Disk ||
+ cdItem.Disk == _startLocalFromCd_Disk &&
+ cdItem.LocalHeaderPos < _startLocalFromCd_Offset)
+ {
+ _startLocalFromCd_Disk = cdItem.Disk;
+ _startLocalFromCd_Offset = cdItem.LocalHeaderPos;
+ }
+ */
+
+ if (items.Size() > 0 && !IsCdUnsorted)
+ {
+ const CItemEx &prev = items.Back();
+ if (cdItem.Disk < prev.Disk
+ || (cdItem.Disk == prev.Disk &&
+ cdItem.LocalHeaderPos < prev.LocalHeaderPos))
+ IsCdUnsorted = true;
+ }
+
+ items.Add(cdItem);
+ }
+ if (Callback && (items.Size() & 0xFFF) == 0)
+ {
+ const UInt64 numFiles = items.Size();
+
+ if (numFiles > numFileExpected && totalFilesPtr)
+ {
+ if (isCorrect_NumEntries)
+ totalFilesPtr = NULL;
+ else
+ while (numFiles > numFileExpected)
+ numFileExpected += (UInt32)1 << 16;
+ RINOK(Callback->SetTotal(totalFilesPtr, NULL))
+ }
+
+ RINOK(Callback->SetCompleted(&numFiles, &_cnt))
+ }
+ }
+
+ CanStartNewVol = true;
+
+ return (_cnt == cdSize) ? S_OK : S_FALSE;
+}
+
+
+/*
+static int CompareCdItems(void *const *elem1, void *const *elem2, void *)
+{
+ const CItemEx *i1 = *(const CItemEx **)elem1;
+ const CItemEx *i2 = *(const CItemEx **)elem2;
+
+ if (i1->Disk < i2->Disk) return -1;
+ if (i1->Disk > i2->Disk) return 1;
+ if (i1->LocalHeaderPos < i2->LocalHeaderPos) return -1;
+ if (i1->LocalHeaderPos > i2->LocalHeaderPos) return 1;
+ if (i1 < i2) return -1;
+ if (i1 > i2) return 1;
+ return 0;
+}
+*/
+
+HRESULT CInArchive::ReadCd(CObjectVector<CItemEx> &items, UInt32 &cdDisk, UInt64 &cdOffset, UInt64 &cdSize)
+{
+ bool checkOffsetMode = true;
+
+ if (IsMultiVol)
+ {
+ if (Vols.EndVolIndex == -1)
+ return S_FALSE;
+ Stream = Vols.Streams[(unsigned)Vols.EndVolIndex].Stream;
+ if (!Vols.StartIsZip)
+ checkOffsetMode = false;
+ }
+ else
+ Stream = StartStream;
+
+ if (!Vols.ecd_wasRead)
+ {
+ RINOK(FindCd(checkOffsetMode))
+ }
+
+ CCdInfo &cdInfo = Vols.ecd;
+
+ HRESULT res = S_FALSE;
+
+ cdSize = cdInfo.Size;
+ cdOffset = cdInfo.Offset;
+ cdDisk = cdInfo.CdDisk;
+
+ if (!IsMultiVol)
+ {
+ if (cdInfo.ThisDisk != cdInfo.CdDisk)
+ return S_FALSE;
+ }
+
+ const UInt64 base = (IsMultiVol ? 0 : (UInt64)ArcInfo.Base);
+ res = TryReadCd(items, cdInfo, base + cdOffset, cdSize);
+
+ if (res == S_FALSE && !IsMultiVol && base != ArcInfo.MarkerPos)
+ {
+ // do we need that additional attempt to read cd?
+ res = TryReadCd(items, cdInfo, ArcInfo.MarkerPos + cdOffset, cdSize);
+ if (res == S_OK)
+ ArcInfo.Base = (Int64)ArcInfo.MarkerPos;
+ }
+
+ // Some rare case files are unsorted
+ // items.Sort(CompareCdItems, NULL);
+ return res;
+}
+
+
+static int FindItem(const CObjectVector<CItemEx> &items, const CItemEx &item)
+{
+ unsigned left = 0, right = items.Size();
+ for (;;)
+ {
+ if (left >= right)
+ return -1;
+ const unsigned index = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const CItemEx &item2 = items[index];
+ if (item.Disk < item2.Disk)
+ right = index;
+ else if (item.Disk > item2.Disk)
+ left = index + 1;
+ else if (item.LocalHeaderPos == item2.LocalHeaderPos)
+ return (int)index;
+ else if (item.LocalHeaderPos < item2.LocalHeaderPos)
+ right = index;
+ else
+ left = index + 1;
+ }
+}
+
+static bool IsStrangeItem(const CItem &item)
+{
+ return item.Name.Len() > (1 << 14) || item.Method > (1 << 8);
+}
+
+
+
+/*
+ ---------- ReadLocals ----------
+
+in:
+ (_signature == NSignature::kLocalFileHeader)
+ VirtStreamPos : after _signature : position in Stream
+ Stream :
+ Vols : if (IsMultiVol)
+ (_inBufMode == false)
+
+action:
+ it parses local items.
+
+ if ( IsMultiVol) it writes absolute offsets to CItemEx::LocalHeaderPos
+ if (!IsMultiVol) it writes relative (from ArcInfo.Base) offsets to CItemEx::LocalHeaderPos
+ later we can correct CItemEx::LocalHeaderPos values, if
+ some new value for ArcInfo.Base will be detected
+out:
+ S_OK:
+ (_signature != NSignature::kLocalFileHeade)
+ _streamPos : after _signature
+
+ S_FALSE: if no items or there is just one item with strange properies that doesn't look like real archive.
+
+ another error code: stream reading error or Callback error.
+
+ CUnexpectEnd() exception : it's not fatal exception here.
+ It means that reading was interrupted by unexpected end of input stream,
+ but some CItemEx items were parsed OK.
+ We can stop further archive parsing.
+ But we can use all filled CItemEx items.
+*/
+
+HRESULT CInArchive::ReadLocals(CObjectVector<CItemEx> &items)
+{
+ items.Clear();
+
+ UInt64 progressPrev = _cnt;
+
+ if (Callback)
+ {
+ RINOK(Callback->SetTotal(NULL, IsMultiVol ? &Vols.TotalBytesSize : NULL))
+ }
+
+ while (_signature == NSignature::kLocalFileHeader)
+ {
+ CItemEx item;
+
+ item.LocalHeaderPos = GetVirtStreamPos() - 4;
+ if (!IsMultiVol)
+ item.LocalHeaderPos = (UInt64)((Int64)item.LocalHeaderPos - ArcInfo.Base);
+
+ try
+ {
+ ReadLocalItem(item);
+ item.FromLocal = true;
+ bool isFinished = false;
+
+ if (item.HasDescriptor())
+ {
+ RINOK(FindDescriptor(item, items.Size()))
+ isFinished = !item.DescriptorWasRead;
+ }
+ else
+ {
+ if (item.PackSize >= ((UInt64)1 << 62))
+ throw CUnexpectEnd();
+ RINOK(IncreaseRealPosition(item.PackSize, isFinished))
+ }
+
+ items.Add(item);
+
+ if (isFinished)
+ throw CUnexpectEnd();
+
+ ReadSignature();
+ }
+ catch (CUnexpectEnd &)
+ {
+ if (items.IsEmpty() || (items.Size() == 1 && IsStrangeItem(items[0])))
+ return S_FALSE;
+ throw;
+ }
+
+
+ if (Callback)
+ if ((items.Size() & 0xFF) == 0
+ || _cnt - progressPrev >= ((UInt32)1 << 22))
+ {
+ progressPrev = _cnt;
+ const UInt64 numFiles = items.Size();
+ RINOK(Callback->SetCompleted(&numFiles, &_cnt))
+ }
+ }
+
+ if (items.Size() == 1 && _signature != NSignature::kCentralFileHeader)
+ if (IsStrangeItem(items[0]))
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+
+HRESULT CVols::ParseArcName(IArchiveOpenVolumeCallback *volCallback)
+{
+ UString name;
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(volCallback->GetProperty(kpidName, &prop))
+ if (prop.vt != VT_BSTR)
+ return S_OK;
+ name = prop.bstrVal;
+ }
+
+ const int dotPos = name.ReverseFind_Dot();
+ if (dotPos < 0)
+ return S_OK;
+ const UString ext = name.Ptr((unsigned)(dotPos + 1));
+ name.DeleteFrom((unsigned)(dotPos + 1));
+
+ StartVolIndex = (Int32)(-1);
+
+ if (ext.IsEmpty())
+ return S_OK;
+ {
+ wchar_t c = ext[0];
+ IsUpperCase = (c >= 'A' && c <= 'Z');
+ if (ext.IsEqualTo_Ascii_NoCase("zip"))
+ {
+ BaseName = name;
+ StartIsZ = true;
+ StartIsZip = true;
+ return S_OK;
+ }
+ else if (ext.IsEqualTo_Ascii_NoCase("exe"))
+ {
+ /* possible cases:
+ - exe with zip inside
+ - sfx: a.exe, a.z02, a.z03,... , a.zip
+ a.exe is start volume.
+ - zip renamed to exe
+ */
+
+ StartIsExe = true;
+ BaseName = name;
+ StartVolIndex = 0;
+ /* sfx-zip can use both arc.exe and arc.zip
+ We can open arc.zip, if it was requesed to open arc.exe.
+ But it's possible that arc.exe and arc.zip are not parts of same archive.
+ So we can disable such operation */
+
+ // 18.04: we still want to open zip renamed to exe.
+ /*
+ {
+ UString volName = name;
+ volName += IsUpperCase ? "Z01" : "z01";
+ {
+ CMyComPtr<IInStream> stream;
+ HRESULT res2 = volCallback->GetStream(volName, &stream);
+ if (res2 == S_OK)
+ DisableVolsSearch = true;
+ }
+ }
+ */
+ DisableVolsSearch = true;
+ return S_OK;
+ }
+ else if (ext[0] == 'z' || ext[0] == 'Z')
+ {
+ if (ext.Len() < 3)
+ return S_OK;
+ const wchar_t *end = NULL;
+ UInt32 volNum = ConvertStringToUInt32(ext.Ptr(1), &end);
+ if (*end != 0 || volNum < 1 || volNum > ((UInt32)1 << 30))
+ return S_OK;
+ StartVolIndex = (Int32)(volNum - 1);
+ BaseName = name;
+ StartIsZ = true;
+ }
+ else
+ return S_OK;
+ }
+
+ UString volName = BaseName;
+ volName += (IsUpperCase ? "ZIP" : "zip");
+
+ HRESULT res = volCallback->GetStream(volName, &ZipStream);
+
+ if (res == S_FALSE || !ZipStream)
+ {
+ if (MissingName.IsEmpty())
+ {
+ MissingZip = true;
+ MissingName = volName;
+ }
+ return S_OK;
+ }
+
+ return res;
+}
+
+
+HRESULT CInArchive::ReadVols2(IArchiveOpenVolumeCallback *volCallback,
+ unsigned start, int lastDisk, int zipDisk, unsigned numMissingVolsMax, unsigned &numMissingVols)
+{
+ if (Vols.DisableVolsSearch)
+ return S_OK;
+
+ numMissingVols = 0;
+
+ for (unsigned i = start;; i++)
+ {
+ if (lastDisk >= 0 && i >= (unsigned)lastDisk)
+ break;
+
+ if (i < Vols.Streams.Size())
+ if (Vols.Streams[i].Stream)
+ continue;
+
+ CMyComPtr<IInStream> stream;
+
+ if ((int)i == zipDisk)
+ {
+ stream = Vols.ZipStream;
+ }
+ else if ((int)i == Vols.StartVolIndex)
+ {
+ stream = StartStream;
+ }
+ else
+ {
+ UString volName = Vols.BaseName;
+ {
+ volName += (char)(Vols.IsUpperCase ? 'Z' : 'z');
+ unsigned v = i + 1;
+ if (v < 10)
+ volName += '0';
+ volName.Add_UInt32(v);
+ }
+
+ HRESULT res = volCallback->GetStream(volName, &stream);
+ if (res != S_OK && res != S_FALSE)
+ return res;
+ if (res == S_FALSE || !stream)
+ {
+ if (i == 0)
+ {
+ UString volName_exe = Vols.BaseName;
+ volName_exe += (Vols.IsUpperCase ? "EXE" : "exe");
+
+ HRESULT res2 = volCallback->GetStream(volName_exe, &stream);
+ if (res2 != S_OK && res2 != S_FALSE)
+ return res2;
+ res = res2;
+ }
+ }
+ if (res == S_FALSE || !stream)
+ {
+ if (i == 1 && Vols.StartIsExe)
+ return S_OK;
+ if (Vols.MissingName.IsEmpty())
+ Vols.MissingName = volName;
+ numMissingVols++;
+ if (numMissingVols > numMissingVolsMax)
+ return S_OK;
+ if (lastDisk == -1 && numMissingVols != 0)
+ return S_OK;
+ continue;
+ }
+ }
+
+ UInt64 pos, size;
+ RINOK(InStream_GetPos_GetSize(stream, pos, size))
+
+ while (i >= Vols.Streams.Size())
+ Vols.Streams.AddNew();
+
+ CVols::CSubStreamInfo &ss = Vols.Streams[i];
+ Vols.NumVols++;
+ Vols.TotalBytesSize += size;
+
+ ss.Stream = stream;
+ ss.Size = size;
+
+ if ((int)i == zipDisk)
+ {
+ Vols.EndVolIndex = (int)(Vols.Streams.Size() - 1);
+ break;
+ }
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CInArchive::ReadVols()
+{
+ CMyComPtr<IArchiveOpenVolumeCallback> volCallback;
+
+ Callback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&volCallback);
+ if (!volCallback)
+ return S_OK;
+
+ RINOK(Vols.ParseArcName(volCallback))
+
+ // const int startZIndex = Vols.StartVolIndex;
+
+ if (!Vols.StartIsZ)
+ {
+ if (!Vols.StartIsExe)
+ return S_OK;
+ }
+
+ int zipDisk = -1;
+ int cdDisk = -1;
+
+ if (Vols.StartIsZip)
+ Vols.ZipStream = StartStream;
+
+ if (Vols.ZipStream)
+ {
+ Stream = Vols.ZipStream;
+
+ if (Vols.StartIsZip)
+ Vols.StreamIndex = -1;
+ else
+ {
+ Vols.StreamIndex = -2;
+ InitBuf();
+ }
+
+ HRESULT res = FindCd(true);
+
+ CCdInfo &ecd = Vols.ecd;
+ if (res == S_OK)
+ {
+ zipDisk = (int)ecd.ThisDisk;
+ Vols.ecd_wasRead = true;
+
+ // if is not multivol or bad multivol, we return to main single stream code
+ if (ecd.ThisDisk == 0
+ || ecd.ThisDisk >= ((UInt32)1 << 30)
+ || ecd.ThisDisk < ecd.CdDisk)
+ return S_OK;
+
+ cdDisk = (int)ecd.CdDisk;
+ if (Vols.StartVolIndex < 0)
+ Vols.StartVolIndex = (Int32)ecd.ThisDisk;
+ else if ((UInt32)Vols.StartVolIndex >= ecd.ThisDisk)
+ return S_OK;
+
+ // Vols.StartVolIndex = ecd.ThisDisk;
+ // Vols.EndVolIndex = ecd.ThisDisk;
+ unsigned numMissingVols;
+ if (cdDisk != zipDisk)
+ {
+ // get volumes required for cd.
+ RINOK(ReadVols2(volCallback, (unsigned)cdDisk, zipDisk, zipDisk, 0, numMissingVols))
+ if (numMissingVols != 0)
+ {
+ // cdOK = false;
+ }
+ }
+ }
+ else if (res != S_FALSE)
+ return res;
+ }
+
+ if (Vols.StartVolIndex < 0)
+ {
+ // is not mutivol;
+ return S_OK;
+ }
+
+ /*
+ if (!Vols.Streams.IsEmpty())
+ IsMultiVol = true;
+ */
+
+ unsigned numMissingVols;
+
+ if (cdDisk != 0)
+ {
+ // get volumes that were no requested still
+ const unsigned kNumMissingVolsMax = 1 << 12;
+ RINOK(ReadVols2(volCallback, 0, cdDisk < 0 ? -1 : cdDisk, zipDisk, kNumMissingVolsMax, numMissingVols))
+ }
+
+ // if (Vols.StartVolIndex >= 0)
+ {
+ if (Vols.Streams.IsEmpty())
+ if (Vols.StartVolIndex > (1 << 20))
+ return S_OK;
+ if ((unsigned)Vols.StartVolIndex >= Vols.Streams.Size()
+ || !Vols.Streams[(unsigned)Vols.StartVolIndex].Stream)
+ {
+ // we get volumes starting from StartVolIndex, if they we not requested before know the volume index (if FindCd() was ok)
+ RINOK(ReadVols2(volCallback, (unsigned)Vols.StartVolIndex, zipDisk, zipDisk, 0, numMissingVols))
+ }
+ }
+
+ if (Vols.ZipStream)
+ {
+ // if there is no another volumes and volumeIndex is too big, we don't use multivol mode
+ if (Vols.Streams.IsEmpty())
+ if (zipDisk > (1 << 10))
+ return S_OK;
+ if (zipDisk >= 0)
+ {
+ // we create item in Streams for ZipStream, if we know the volume index (if FindCd() was ok)
+ RINOK(ReadVols2(volCallback, (unsigned)zipDisk, zipDisk + 1, zipDisk, 0, numMissingVols))
+ }
+ }
+
+ if (!Vols.Streams.IsEmpty())
+ {
+ IsMultiVol = true;
+ /*
+ if (cdDisk)
+ IsMultiVol = true;
+ */
+ const int startZIndex = Vols.StartVolIndex;
+ if (startZIndex >= 0)
+ {
+ // if all volumes before start volume are OK, we can start parsing from 0
+ // if there are missing volumes before startZIndex, we start parsing in current startZIndex
+ if ((unsigned)startZIndex < Vols.Streams.Size())
+ {
+ for (unsigned i = 0; i <= (unsigned)startZIndex; i++)
+ if (!Vols.Streams[i].Stream)
+ {
+ Vols.StartParsingVol = startZIndex;
+ break;
+ }
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+HRESULT CVols::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+
+ for (;;)
+ {
+ if (StreamIndex < 0)
+ return S_OK;
+ if ((unsigned)StreamIndex >= Streams.Size())
+ return S_OK;
+ const CVols::CSubStreamInfo &s = Streams[(unsigned)StreamIndex];
+ if (!s.Stream)
+ return S_FALSE;
+ if (NeedSeek)
+ {
+ RINOK(s.SeekToStart())
+ NeedSeek = false;
+ }
+ UInt32 realProcessedSize = 0;
+ HRESULT res = s.Stream->Read(data, size, &realProcessedSize);
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ if (res != S_OK)
+ return res;
+ if (realProcessedSize != 0)
+ return res;
+ StreamIndex++;
+ NeedSeek = true;
+ }
+}
+
+Z7_COM7F_IMF(CVolStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ return Vols->Read(data, size, processedSize);
+}
+
+
+
+
+#define COPY_ECD_ITEM_16(n) if (!isZip64 || !ZIP64_IS_16_MAX(ecd. n)) cdInfo. n = ecd. n;
+#define COPY_ECD_ITEM_32(n) if (!isZip64 || !ZIP64_IS_32_MAX(ecd. n)) cdInfo. n = ecd. n;
+
+
+HRESULT CInArchive::ReadHeaders(CObjectVector<CItemEx> &items)
+{
+ // buffer that can be used for cd reading
+ RINOK(AllocateBuffer(kSeqBufferSize))
+
+ // here we can read small records. So we switch off _inBufMode.
+ _inBufMode = false;
+
+ HRESULT res = S_OK;
+
+ bool localsWereRead = false;
+
+ /* we try to open archive with the following modes:
+ 1) CD-MODE : fast mode : we read backward ECD and CD, compare CD items with first Local item.
+ 2) LOCALS-CD-MODE : slow mode, if CD-MODE fails : we sequentially read all Locals and then CD.
+ Then we read sequentially ECD64, Locator, ECD again at the end.
+
+ - in LOCALS-CD-MODE we use use the following
+ variables (with real cd properties) to set Base archive offset
+ and check real cd properties with values from ECD/ECD64.
+ */
+
+ UInt64 cdSize = 0;
+ UInt64 cdRelatOffset = 0;
+ UInt32 cdDisk = 0;
+
+ UInt64 cdAbsOffset = 0; // absolute cd offset, for LOCALS-CD-MODE only.
+
+if (Force_ReadLocals_Mode)
+{
+ IsArc = true;
+ res = S_FALSE; // we will use LOCALS-CD-MODE mode
+}
+else
+{
+ if (!MarkerIsFound || !MarkerIsSafe)
+ {
+ IsArc = true;
+ res = ReadCd(items, cdDisk, cdRelatOffset, cdSize);
+ if (res == S_OK)
+ ReadSignature();
+ else if (res != S_FALSE)
+ return res;
+ }
+ else // (MarkerIsFound && MarkerIsSafe)
+ {
+
+ // _signature must be kLocalFileHeader or kEcd or kEcd64
+
+ SeekToVol(ArcInfo.MarkerVolIndex, ArcInfo.MarkerPos2 + 4);
+
+ CanStartNewVol = false;
+
+ if (_signature == NSignature::kEcd64)
+ {
+ // UInt64 ecd64Offset = GetVirtStreamPos() - 4;
+ IsZip64 = true;
+
+ {
+ const UInt64 recordSize = ReadUInt64();
+ if (recordSize < kEcd64_MainSize)
+ return S_FALSE;
+ if (recordSize >= ((UInt64)1 << 62))
+ return S_FALSE;
+
+ {
+ const unsigned kBufSize = kEcd64_MainSize;
+ Byte buf[kBufSize];
+ SafeRead(buf, kBufSize);
+ CCdInfo cdInfo;
+ cdInfo.ParseEcd64e(buf);
+ if (!cdInfo.IsEmptyArc())
+ return S_FALSE;
+ }
+
+ RINOK(Skip64(recordSize - kEcd64_MainSize, 0))
+ }
+
+ ReadSignature();
+ if (_signature != NSignature::kEcd64Locator)
+ return S_FALSE;
+
+ {
+ const unsigned kBufSize = 16;
+ Byte buf[kBufSize];
+ SafeRead(buf, kBufSize);
+ CLocator locator;
+ locator.Parse(buf);
+ if (!locator.IsEmptyArc())
+ return S_FALSE;
+ }
+
+ ReadSignature();
+ if (_signature != NSignature::kEcd)
+ return S_FALSE;
+ }
+
+ if (_signature == NSignature::kEcd)
+ {
+ // It must be empty archive or backware archive
+ // we don't support backware archive still
+
+ const unsigned kBufSize = kEcdSize - 4;
+ Byte buf[kBufSize];
+ SafeRead(buf, kBufSize);
+ CEcd ecd;
+ ecd.Parse(buf);
+ // if (ecd.cdSize != 0)
+ // Do we need also to support the case where empty zip archive with PK00 uses cdOffset = 4 ??
+ if (!ecd.IsEmptyArc())
+ return S_FALSE;
+
+ ArcInfo.Base = (Int64)ArcInfo.MarkerPos;
+ IsArc = true; // check it: we need more tests?
+
+ RINOK(SeekToVol(ArcInfo.MarkerVolIndex, ArcInfo.MarkerPos2))
+ ReadSignature();
+ }
+ else
+ {
+ CItemEx firstItem;
+ try
+ {
+ try
+ {
+ if (!ReadLocalItem(firstItem))
+ return S_FALSE;
+ }
+ catch(CUnexpectEnd &)
+ {
+ return S_FALSE;
+ }
+
+ IsArc = true;
+ res = ReadCd(items, cdDisk, cdRelatOffset, cdSize);
+ if (res == S_OK)
+ ReadSignature();
+ }
+ catch(CUnexpectEnd &) { res = S_FALSE; }
+
+ if (res != S_FALSE && res != S_OK)
+ return res;
+
+ if (res == S_OK && items.Size() == 0)
+ res = S_FALSE;
+
+ if (res == S_OK)
+ {
+ // we can't read local items here to keep _inBufMode state
+ if ((Int64)ArcInfo.MarkerPos2 < ArcInfo.Base)
+ res = S_FALSE;
+ else
+ {
+ firstItem.LocalHeaderPos = (UInt64)((Int64)ArcInfo.MarkerPos2 - ArcInfo.Base);
+ int index = -1;
+
+ UInt32 min_Disk = (UInt32)(Int32)-1;
+ UInt64 min_LocalHeaderPos = (UInt64)(Int64)-1;
+
+ if (!IsCdUnsorted)
+ index = FindItem(items, firstItem);
+ else
+ {
+ FOR_VECTOR (i, items)
+ {
+ const CItemEx &cdItem = items[i];
+ if (cdItem.Disk == firstItem.Disk
+ && (cdItem.LocalHeaderPos == firstItem.LocalHeaderPos))
+ index = (int)i;
+
+ if (i == 0
+ || cdItem.Disk < min_Disk
+ || (cdItem.Disk == min_Disk && cdItem.LocalHeaderPos < min_LocalHeaderPos))
+ {
+ min_Disk = cdItem.Disk;
+ min_LocalHeaderPos = cdItem.LocalHeaderPos;
+ }
+ }
+ }
+
+ if (index == -1)
+ res = S_FALSE;
+ else if (!AreItemsEqual(firstItem, items[(unsigned)index]))
+ res = S_FALSE;
+ else
+ {
+ ArcInfo.CdWasRead = true;
+ if (IsCdUnsorted)
+ ArcInfo.FirstItemRelatOffset = min_LocalHeaderPos;
+ else
+ ArcInfo.FirstItemRelatOffset = items[0].LocalHeaderPos;
+
+ // ArcInfo.FirstItemRelatOffset = _startLocalFromCd_Offset;
+ }
+ }
+ }
+ }
+ } // (MarkerIsFound && MarkerIsSafe)
+
+} // (!onlyLocalsMode)
+
+
+ CObjectVector<CItemEx> cdItems;
+
+ bool needSetBase = false; // we set needSetBase only for LOCALS_CD_MODE
+ unsigned numCdItems = items.Size();
+
+ #ifdef ZIP_SELF_CHECK
+ res = S_FALSE; // if uncommented, it uses additional LOCALS-CD-MODE mode to check the code
+ #endif
+
+ if (res != S_OK)
+ {
+ // ---------- LOCALS-CD-MODE ----------
+ // CD doesn't match firstItem,
+ // so we clear items and read Locals and CD.
+
+ items.Clear();
+ localsWereRead = true;
+
+ HeadersError = false;
+ HeadersWarning = false;
+ ExtraMinorError = false;
+
+ /* we can use any mode: with buffer and without buffer
+ without buffer : skips packed data : fast for big files : slow for small files
+ with buffer : reads packed data : slow for big files : fast for small files
+ Buffer mode is more effective. */
+ // _inBufMode = false;
+ _inBufMode = true;
+ // we could change the buffer size here, if we want smaller Buffer.
+ // RINOK(ReAllocateBuffer(kSeqBufferSize));
+ // InitBuf()
+
+ ArcInfo.Base = 0;
+
+ if (!Disable_FindMarker)
+ {
+ if (!MarkerIsFound)
+ {
+ if (!IsMultiVol)
+ return S_FALSE;
+ if (Vols.StartParsingVol != 0)
+ return S_FALSE;
+ // if (StartParsingVol == 0) and we didn't find marker, we use default zero marker.
+ // so we suppose that there is no sfx stub
+ RINOK(SeekToVol(0, ArcInfo.MarkerPos2))
+ }
+ else
+ {
+ if (ArcInfo.MarkerPos != 0)
+ {
+ /*
+ If multi-vol or there is (No)Span-marker at start of stream, we set (Base) as 0.
+ In another caes:
+ (No)Span-marker is supposed as false positive. So we set (Base) as main marker (MarkerPos2).
+ The (Base) can be corrected later after ECD reading.
+ But sfx volume with stub and (No)Span-marker in (!IsMultiVol) mode will have incorrect (Base) here.
+ */
+ ArcInfo.Base = (Int64)ArcInfo.MarkerPos2;
+ }
+ RINOK(SeekToVol(ArcInfo.MarkerVolIndex, ArcInfo.MarkerPos2))
+ }
+ }
+ _cnt = 0;
+
+ ReadSignature();
+
+ LocalsWereRead = true;
+
+ RINOK(ReadLocals(items))
+
+ if (_signature != NSignature::kCentralFileHeader)
+ {
+ // GetVirtStreamPos() - 4
+ if (items.IsEmpty())
+ return S_FALSE;
+
+ bool isError = true;
+
+ const UInt32 apkSize = _signature;
+ const unsigned kApkFooterSize = 16 + 8;
+ if (apkSize >= kApkFooterSize && apkSize <= (1 << 20))
+ {
+ if (ReadUInt32() == 0)
+ {
+ CByteBuffer apk;
+ apk.Alloc(apkSize);
+ SafeRead(apk, apkSize);
+ ReadSignature();
+ const Byte *footer = apk + apkSize - kApkFooterSize;
+ if (_signature == NSignature::kCentralFileHeader)
+ if (GetUi64(footer) == apkSize)
+ if (memcmp(footer + 8, "APK Sig Block 42", 16) == 0)
+ {
+ isError = false;
+ IsApk = true;
+ }
+ }
+ }
+
+ if (isError)
+ {
+ NoCentralDir = true;
+ HeadersError = true;
+ return S_OK;
+ }
+ }
+
+ _inBufMode = true;
+
+ cdAbsOffset = GetVirtStreamPos() - 4;
+ cdDisk = (UInt32)Vols.StreamIndex;
+
+ #ifdef ZIP_SELF_CHECK
+ if (!IsMultiVol && _cnt != GetVirtStreamPos() - ArcInfo.MarkerPos2)
+ return E_FAIL;
+ #endif
+
+ const UInt64 processedCnt_start = _cnt;
+
+ for (;;)
+ {
+ CItemEx cdItem;
+
+ RINOK(ReadCdItem(cdItem))
+
+ cdItems.Add(cdItem);
+ if (Callback && (cdItems.Size() & 0xFFF) == 0)
+ {
+ const UInt64 numFiles = items.Size();
+ const UInt64 numBytes = _cnt;
+ RINOK(Callback->SetCompleted(&numFiles, &numBytes))
+ }
+ ReadSignature();
+ if (_signature != NSignature::kCentralFileHeader)
+ break;
+ }
+
+ cdSize = _cnt - processedCnt_start;
+
+ #ifdef ZIP_SELF_CHECK
+ if (!IsMultiVol)
+ {
+ if (_cnt != GetVirtStreamPos() - ArcInfo.MarkerPos2)
+ return E_FAIL;
+ if (cdSize != (GetVirtStreamPos() - 4) - cdAbsOffset)
+ return E_FAIL;
+ }
+ #endif
+
+ needSetBase = true;
+ numCdItems = cdItems.Size();
+ cdRelatOffset = (UInt64)((Int64)cdAbsOffset - ArcInfo.Base);
+
+ if (!cdItems.IsEmpty())
+ {
+ ArcInfo.CdWasRead = true;
+ ArcInfo.FirstItemRelatOffset = cdItems[0].LocalHeaderPos;
+ }
+ }
+
+
+
+ CCdInfo cdInfo;
+ CLocator locator;
+ bool isZip64 = false;
+ const UInt64 ecd64AbsOffset = GetVirtStreamPos() - 4;
+ int ecd64Disk = -1;
+
+ if (_signature == NSignature::kEcd64)
+ {
+ ecd64Disk = Vols.StreamIndex;
+
+ IsZip64 = isZip64 = true;
+
+ {
+ const UInt64 recordSize = ReadUInt64();
+ if (recordSize < kEcd64_MainSize
+ || recordSize >= ((UInt64)1 << 62))
+ {
+ HeadersError = true;
+ return S_OK;
+ }
+
+ {
+ const unsigned kBufSize = kEcd64_MainSize;
+ Byte buf[kBufSize];
+ SafeRead(buf, kBufSize);
+ cdInfo.ParseEcd64e(buf);
+ }
+
+ RINOK(Skip64(recordSize - kEcd64_MainSize, items.Size()))
+ }
+
+
+ ReadSignature();
+
+ if (_signature != NSignature::kEcd64Locator)
+ {
+ HeadersError = true;
+ return S_OK;
+ }
+
+ {
+ const unsigned kBufSize = 16;
+ Byte buf[kBufSize];
+ SafeRead(buf, kBufSize);
+ locator.Parse(buf);
+ // we ignore the error, where some zip creators use (NumDisks == 0)
+ // if (locator.NumDisks == 0) HeadersWarning = true;
+ }
+
+ ReadSignature();
+ }
+
+
+ if (_signature != NSignature::kEcd)
+ {
+ HeadersError = true;
+ return S_OK;
+ }
+
+
+ CanStartNewVol = false;
+
+ // ---------- ECD ----------
+
+ CEcd ecd;
+ {
+ const unsigned kBufSize = kEcdSize - 4;
+ Byte buf[kBufSize];
+ SafeRead(buf, kBufSize);
+ ecd.Parse(buf);
+ }
+
+ COPY_ECD_ITEM_16(ThisDisk)
+ COPY_ECD_ITEM_16(CdDisk)
+ COPY_ECD_ITEM_16(NumEntries_in_ThisDisk)
+ COPY_ECD_ITEM_16(NumEntries)
+ COPY_ECD_ITEM_32(Size)
+ COPY_ECD_ITEM_32(Offset)
+
+ bool cdOK = true;
+
+ if ((UInt32)cdInfo.Size != (UInt32)cdSize)
+ {
+ // return S_FALSE;
+ cdOK = false;
+ }
+
+ if (isZip64)
+ {
+ if (cdInfo.NumEntries != numCdItems
+ || cdInfo.Size != cdSize)
+ {
+ cdOK = false;
+ }
+ }
+
+
+ if (IsMultiVol)
+ {
+ if (cdDisk != cdInfo.CdDisk)
+ HeadersError = true;
+ }
+ else if (needSetBase && cdOK)
+ {
+ const UInt64 oldBase = (UInt64)ArcInfo.Base;
+ // localsWereRead == true
+ // ArcInfo.Base == ArcInfo.MarkerPos2
+ // cdRelatOffset == (cdAbsOffset - ArcInfo.Base)
+
+ if (isZip64)
+ {
+ if (ecd64Disk == Vols.StartVolIndex)
+ {
+ const Int64 newBase = (Int64)ecd64AbsOffset - (Int64)locator.Ecd64Offset;
+ if (newBase <= (Int64)ecd64AbsOffset)
+ {
+ if (!localsWereRead || newBase <= (Int64)ArcInfo.MarkerPos2)
+ {
+ ArcInfo.Base = newBase;
+ cdRelatOffset = (UInt64)((Int64)cdAbsOffset - newBase);
+ }
+ else
+ cdOK = false;
+ }
+ }
+ }
+ else if (numCdItems != 0) // we can't use ecd.Offset in empty archive?
+ {
+ if ((int)cdDisk == Vols.StartVolIndex)
+ {
+ const Int64 newBase = (Int64)cdAbsOffset - (Int64)cdInfo.Offset;
+ if (newBase <= (Int64)cdAbsOffset)
+ {
+ if (!localsWereRead || newBase <= (Int64)ArcInfo.MarkerPos2)
+ {
+ // cd can be more accurate, when it points before Locals
+ // so we change Base and cdRelatOffset
+ ArcInfo.Base = newBase;
+ cdRelatOffset = cdInfo.Offset;
+ }
+ else
+ {
+ // const UInt64 delta = ((UInt64)cdRelatOffset - cdInfo.Offset);
+ const UInt64 delta = ((UInt64)(newBase - ArcInfo.Base));
+ if ((UInt32)delta == 0)
+ {
+ // we set Overflow32bit mode, only if there is (x<<32) offset
+ // between real_CD_offset_from_MarkerPos and CD_Offset_in_ECD.
+ // Base and cdRelatOffset unchanged
+ Overflow32bit = true;
+ }
+ else
+ cdOK = false;
+ }
+ }
+ else
+ cdOK = false;
+ }
+ }
+ // cdRelatOffset = cdAbsOffset - ArcInfo.Base;
+
+ if (localsWereRead)
+ {
+ const UInt64 delta = (UInt64)((Int64)oldBase - ArcInfo.Base);
+ if (delta != 0)
+ {
+ FOR_VECTOR (i, items)
+ items[i].LocalHeaderPos += delta;
+ }
+ }
+ }
+
+ if (!cdOK)
+ HeadersError = true;
+
+ EcdVolIndex = cdInfo.ThisDisk;
+
+ if (!IsMultiVol)
+ {
+ if (EcdVolIndex == 0 && Vols.MissingZip && Vols.StartIsExe)
+ {
+ Vols.MissingName.Empty();
+ Vols.MissingZip = false;
+ }
+
+ if (localsWereRead)
+ {
+ if (EcdVolIndex != 0)
+ {
+ FOR_VECTOR (i, items)
+ items[i].Disk = EcdVolIndex;
+ }
+ }
+
+ UseDisk_in_SingleVol = true;
+ }
+
+ if (isZip64)
+ {
+ if ((cdInfo.ThisDisk == 0 && ecd64AbsOffset != (UInt64)(ArcInfo.Base + (Int64)locator.Ecd64Offset))
+ // || cdInfo.NumEntries_in_ThisDisk != numCdItems
+ || cdInfo.NumEntries != numCdItems
+ || cdInfo.Size != cdSize
+ || (cdInfo.Offset != cdRelatOffset && !items.IsEmpty()))
+ {
+ HeadersError = true;
+ return S_OK;
+ }
+ }
+
+ if (cdOK && !cdItems.IsEmpty())
+ {
+ // ---------- merge Central Directory Items ----------
+
+ CRecordVector<unsigned> items2;
+
+ int nextLocalIndex = 0;
+
+ LocalsCenterMerged = true;
+
+ FOR_VECTOR (i, cdItems)
+ {
+ if (Callback)
+ if ((i & 0x3FFF) == 0)
+ {
+ const UInt64 numFiles64 = items.Size() + items2.Size();
+ RINOK(Callback->SetCompleted(&numFiles64, &_cnt))
+ }
+
+ const CItemEx &cdItem = cdItems[i];
+
+ int index = -1;
+
+ if (nextLocalIndex != -1)
+ {
+ if ((unsigned)nextLocalIndex < items.Size())
+ {
+ CItemEx &item = items[(unsigned)nextLocalIndex];
+ if (item.Disk == cdItem.Disk &&
+ (item.LocalHeaderPos == cdItem.LocalHeaderPos
+ || (Overflow32bit && (UInt32)item.LocalHeaderPos == cdItem.LocalHeaderPos)))
+ index = nextLocalIndex++;
+ else
+ nextLocalIndex = -1;
+ }
+ }
+
+ if (index == -1)
+ index = FindItem(items, cdItem);
+
+ // index = -1;
+
+ if (index == -1)
+ {
+ items2.Add(i);
+ HeadersError = true;
+ continue;
+ }
+
+ CItemEx &item = items[(unsigned)index];
+ if (item.Name != cdItem.Name
+ // || item.Name.Len() != cdItem.Name.Len()
+ || item.PackSize != cdItem.PackSize
+ || item.Size != cdItem.Size
+ // item.ExtractVersion != cdItem.ExtractVersion
+ || !FlagsAreSame(item, cdItem)
+ || item.Crc != cdItem.Crc)
+ {
+ HeadersError = true;
+ continue;
+ }
+
+ // item.Name = cdItem.Name;
+ item.MadeByVersion = cdItem.MadeByVersion;
+ item.CentralExtra = cdItem.CentralExtra;
+ item.InternalAttrib = cdItem.InternalAttrib;
+ item.ExternalAttrib = cdItem.ExternalAttrib;
+ item.Comment = cdItem.Comment;
+ item.FromCentral = cdItem.FromCentral;
+ // 22.02: we force utf8 flag, if central header has utf8 flag
+ if (cdItem.Flags & NFileHeader::NFlags::kUtf8)
+ item.Flags |= NFileHeader::NFlags::kUtf8;
+ }
+
+ FOR_VECTOR (k, items2)
+ items.Add(cdItems[items2[k]]);
+ }
+
+ if (ecd.NumEntries < ecd.NumEntries_in_ThisDisk)
+ HeadersError = true;
+
+ if (ecd.ThisDisk == 0)
+ {
+ // if (isZip64)
+ {
+ if (ecd.NumEntries != ecd.NumEntries_in_ThisDisk)
+ HeadersError = true;
+ }
+ }
+
+ if (isZip64)
+ {
+ if (cdInfo.NumEntries != items.Size()
+ || (ecd.NumEntries != items.Size() && ecd.NumEntries != 0xFFFF))
+ HeadersError = true;
+ }
+ else
+ {
+ // old 7-zip could store 32-bit number of CD items to 16-bit field.
+ // if (ecd.NumEntries != items.Size())
+ if (ecd.NumEntries > items.Size())
+ HeadersError = true;
+
+ if (cdInfo.NumEntries != numCdItems)
+ {
+ if ((UInt16)cdInfo.NumEntries != (UInt16)numCdItems)
+ HeadersError = true;
+ else
+ Cd_NumEntries_Overflow_16bit = true;
+ }
+ }
+
+ ReadBuffer(ArcInfo.Comment, ecd.CommentSize);
+
+ _inBufMode = false;
+
+ // DisableBufMode();
+ // Buffer.Free();
+ /* we can't clear buf varibles. we need them to calculate PhySize of archive */
+
+ if ((UInt16)cdInfo.NumEntries != (UInt16)numCdItems
+ || (UInt32)cdInfo.Size != (UInt32)cdSize
+ || ((UInt32)cdInfo.Offset != (UInt32)cdRelatOffset && !items.IsEmpty()))
+ {
+ // return S_FALSE;
+ HeadersError = true;
+ }
+
+ #ifdef ZIP_SELF_CHECK
+ if (localsWereRead)
+ {
+ const UInt64 endPos = ArcInfo.MarkerPos2 + _cnt;
+ if (endPos != (IsMultiVol ? Vols.TotalBytesSize : ArcInfo.FileEndPos))
+ {
+ // there are some data after the end of archive or error in code;
+ return E_FAIL;
+ }
+ }
+ #endif
+
+ // printf("\nOpen OK");
+ return S_OK;
+}
+
+
+
+HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchLimit,
+ IArchiveOpenCallback *callback, CObjectVector<CItemEx> &items)
+{
+ items.Clear();
+
+ Close();
+
+ UInt64 startPos;
+ RINOK(InStream_GetPos(stream, startPos))
+ RINOK(InStream_GetSize_SeekToEnd(stream, ArcInfo.FileEndPos))
+ _streamPos = ArcInfo.FileEndPos;
+
+ StartStream = stream;
+ Stream = stream;
+ Callback = callback;
+
+ DisableBufMode();
+
+ bool volWasRequested = false;
+
+ if (!Disable_VolsRead)
+ if (callback
+ && (startPos == 0 || !searchLimit || *searchLimit != 0))
+ {
+ // we try to read volumes only if it's first call (offset == 0) or scan is allowed.
+ volWasRequested = true;
+ RINOK(ReadVols())
+ }
+
+ if (Disable_FindMarker)
+ {
+ RINOK(SeekToVol(-1, startPos))
+ StreamRef = stream;
+ Stream = stream;
+ MarkerIsFound = true;
+ MarkerIsSafe = true;
+ ArcInfo.MarkerPos = startPos;
+ ArcInfo.MarkerPos2 = startPos;
+ }
+ else
+ if (IsMultiVol && Vols.StartParsingVol == 0 && (unsigned)Vols.StartParsingVol < Vols.Streams.Size())
+ {
+ // only StartParsingVol = 0 is safe search.
+ RINOK(SeekToVol(0, 0))
+ // if (Stream)
+ {
+ // UInt64 limit = 1 << 22; // for sfx
+ UInt64 limit = 0; // without sfx
+
+ HRESULT res = FindMarker(&limit);
+
+ if (res == S_OK)
+ {
+ MarkerIsFound = true;
+ MarkerIsSafe = true;
+ }
+ else if (res != S_FALSE)
+ return res;
+ }
+ }
+ else
+ {
+ // printf("\nOpen offset = %u\n", (unsigned)startPos);
+ if (IsMultiVol
+ && (unsigned)Vols.StartParsingVol < Vols.Streams.Size()
+ && Vols.Streams[(unsigned)Vols.StartParsingVol].Stream)
+ {
+ RINOK(SeekToVol(Vols.StartParsingVol, Vols.StreamIndex == Vols.StartVolIndex ? startPos : 0))
+ }
+ else
+ {
+ RINOK(SeekToVol(-1, startPos))
+ }
+
+ // UInt64 limit = 1 << 22;
+ // HRESULT res = FindMarker(&limit);
+
+ HRESULT res = FindMarker(searchLimit);
+
+ // const UInt64 curPos = GetVirtStreamPos();
+ const UInt64 curPos = ArcInfo.MarkerPos2 + 4;
+
+ if (res == S_OK)
+ MarkerIsFound = true;
+ else if (!IsMultiVol)
+ {
+ /*
+ // if (startPos != 0), probably CD could be already tested with another call with (startPos == 0).
+ // so we don't want to try to open CD again in that case.
+ if (startPos != 0)
+ return res;
+ // we can try to open CD, if there is no Marker and (startPos == 0).
+ // is it OK to open such files as ZIP, or big number of false positive, when CD can be find in end of file ?
+ */
+ return res;
+ }
+
+ if (ArcInfo.IsSpanMode && !volWasRequested)
+ {
+ RINOK(ReadVols())
+ if (IsMultiVol && MarkerIsFound && ArcInfo.MarkerVolIndex < 0)
+ ArcInfo.MarkerVolIndex = Vols.StartVolIndex;
+ }
+
+ MarkerIsSafe = !IsMultiVol
+ || (ArcInfo.MarkerVolIndex == 0 && ArcInfo.MarkerPos == 0)
+ ;
+
+
+ if (IsMultiVol)
+ {
+ if ((unsigned)Vols.StartVolIndex < Vols.Streams.Size())
+ {
+ Stream = Vols.Streams[(unsigned)Vols.StartVolIndex].Stream;
+ if (Stream)
+ {
+ RINOK(Seek_SavePos(curPos))
+ }
+ else
+ IsMultiVol = false;
+ }
+ else
+ IsMultiVol = false;
+ }
+
+ if (!IsMultiVol)
+ {
+ if (Vols.StreamIndex != -1)
+ {
+ Stream = StartStream;
+ Vols.StreamIndex = -1;
+ InitBuf();
+ RINOK(Seek_SavePos(curPos))
+ }
+
+ ArcInfo.MarkerVolIndex = -1;
+ StreamRef = stream;
+ Stream = stream;
+ }
+ }
+
+
+ if (!IsMultiVol)
+ Vols.ClearRefs();
+
+ {
+ HRESULT res;
+ try
+ {
+ res = ReadHeaders(items);
+ }
+ catch (const CSystemException &e) { res = e.ErrorCode; }
+ catch (const CUnexpectEnd &)
+ {
+ if (items.IsEmpty())
+ return S_FALSE;
+ UnexpectedEnd = true;
+ res = S_OK;
+ }
+ catch (...)
+ {
+ DisableBufMode();
+ throw;
+ }
+
+ if (IsMultiVol)
+ {
+ ArcInfo.FinishPos = ArcInfo.FileEndPos;
+ if ((unsigned)Vols.StreamIndex < Vols.Streams.Size())
+ if (GetVirtStreamPos() < Vols.Streams[(unsigned)Vols.StreamIndex].Size)
+ ArcInfo.ThereIsTail = true;
+ }
+ else
+ {
+ ArcInfo.FinishPos = GetVirtStreamPos();
+ ArcInfo.ThereIsTail = (ArcInfo.FileEndPos > ArcInfo.FinishPos);
+ }
+
+ DisableBufMode();
+
+ IsArcOpen = true;
+ if (!IsMultiVol)
+ Vols.Streams.Clear();
+ return res;
+ }
+}
+
+
+HRESULT CInArchive::GetItemStream(const CItemEx &item, bool seekPackData, CMyComPtr<ISequentialInStream> &stream)
+{
+ stream.Release();
+
+ UInt64 pos = item.LocalHeaderPos;
+ if (seekPackData)
+ pos += item.LocalFullHeaderSize;
+
+ if (!IsMultiVol)
+ {
+ if (UseDisk_in_SingleVol && item.Disk != EcdVolIndex)
+ return S_OK;
+ pos = (UInt64)((Int64)pos + ArcInfo.Base);
+ RINOK(InStream_SeekSet(StreamRef, pos))
+ stream = StreamRef;
+ return S_OK;
+ }
+
+ if (item.Disk >= Vols.Streams.Size())
+ return S_OK;
+
+ IInStream *str2 = Vols.Streams[item.Disk].Stream;
+ if (!str2)
+ return S_OK;
+ RINOK(InStream_SeekSet(str2, pos))
+
+ Vols.NeedSeek = false;
+ Vols.StreamIndex = (int)item.Disk;
+
+ CVolStream *volsStreamSpec = new CVolStream;
+ volsStreamSpec->Vols = &Vols;
+ stream = volsStreamSpec;
+
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipIn.h b/CPP/7zip/Archive/Zip/ZipIn.h
new file mode 100644
index 0000000..bea26dc
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipIn.h
@@ -0,0 +1,449 @@
+// Archive/ZipIn.h
+
+#ifndef ZIP7_INC_ZIP_IN_H
+#define ZIP7_INC_ZIP_IN_H
+
+#include "../../../Common/MyBuffer2.h"
+#include "../../../Common/MyCom.h"
+
+#include "../../Common/StreamUtils.h"
+#include "../../IStream.h"
+
+#include "ZipHeader.h"
+#include "ZipItem.h"
+
+API_FUNC_IsArc IsArc_Zip(const Byte *p, size_t size);
+
+namespace NArchive {
+namespace NZip {
+
+class CItemEx: public CItem
+{
+public:
+ UInt32 LocalFullHeaderSize; // including Name and Extra
+ // int ParentOfAltStream; // -1, if not AltStream
+
+ bool DescriptorWasRead;
+
+ CItemEx():
+ // ParentOfAltStream(-1),
+ DescriptorWasRead(false) {}
+
+ UInt64 GetLocalFullSize() const
+ { return LocalFullHeaderSize + GetPackSizeWithDescriptor(); }
+ UInt64 GetDataPosition() const
+ { return LocalHeaderPos + LocalFullHeaderSize; }
+
+ bool IsBadDescriptor() const
+ {
+ return !FromCentral && FromLocal && HasDescriptor() && !DescriptorWasRead;
+ }
+};
+
+
+struct CInArchiveInfo
+{
+ Int64 Base; /* Base offset of start of archive in stream.
+ Offsets in headers must be calculated from that Base.
+ Base is equal to MarkerPos for normal ZIPs.
+ Base can point to PE stub for some ZIP SFXs.
+ if CentralDir was read,
+ Base can be negative, if start of data is not available,
+ if CentralDirs was not read,
+ Base = ArcInfo.MarkerPos; */
+
+ /* The following *Pos variables contain absolute offsets in Stream */
+
+ UInt64 MarkerPos; /* Pos of first signature, it can point to kSpan/kNoSpan signature
+ = MarkerPos2 in most archives
+ = MarkerPos2 - 4 if there is kSpan/kNoSpan signature */
+ UInt64 MarkerPos2; // Pos of first local item signature in stream
+ UInt64 FinishPos; // Finish pos of archive data in starting volume
+ UInt64 FileEndPos; // Finish pos of stream
+
+ UInt64 FirstItemRelatOffset; /* Relative offset of first local (read from cd) (relative to Base).
+ = 0 in most archives
+ = size of stub for some SFXs */
+
+
+ int MarkerVolIndex;
+
+ bool CdWasRead;
+ bool IsSpanMode;
+ bool ThereIsTail;
+
+ // UInt32 BaseVolIndex;
+
+ CByteBuffer Comment;
+
+
+ CInArchiveInfo():
+ Base(0),
+ MarkerPos(0),
+ MarkerPos2(0),
+ FinishPos(0),
+ FileEndPos(0),
+ FirstItemRelatOffset(0),
+ MarkerVolIndex(-1),
+ CdWasRead(false),
+ IsSpanMode(false),
+ ThereIsTail(false)
+ // BaseVolIndex(0)
+ {}
+
+ void Clear()
+ {
+ // BaseVolIndex = 0;
+ Base = 0;
+ MarkerPos = 0;
+ MarkerPos2 = 0;
+ FinishPos = 0;
+ FileEndPos = 0;
+ MarkerVolIndex = -1;
+ ThereIsTail = false;
+
+ FirstItemRelatOffset = 0;
+
+ CdWasRead = false;
+ IsSpanMode = false;
+
+ Comment.Free();
+ }
+};
+
+
+struct CCdInfo
+{
+ bool IsFromEcd64;
+
+ UInt16 CommentSize;
+
+ // 64
+ UInt16 VersionMade;
+ UInt16 VersionNeedExtract;
+
+ // old zip
+ UInt32 ThisDisk;
+ UInt32 CdDisk;
+ UInt64 NumEntries_in_ThisDisk;
+ UInt64 NumEntries;
+ UInt64 Size;
+ UInt64 Offset;
+
+ CCdInfo() { memset(this, 0, sizeof(*this)); IsFromEcd64 = false; }
+
+ void ParseEcd32(const Byte *p); // (p) includes signature
+ void ParseEcd64e(const Byte *p); // (p) exclude signature
+
+ bool IsEmptyArc() const
+ {
+ return ThisDisk == 0
+ && CdDisk == 0
+ && NumEntries_in_ThisDisk == 0
+ && NumEntries == 0
+ && Size == 0
+ && Offset == 0 // test it
+ ;
+ }
+};
+
+
+struct CVols
+{
+ struct CSubStreamInfo
+ {
+ CMyComPtr<IInStream> Stream;
+ UInt64 Size;
+
+ HRESULT SeekToStart() const { return InStream_SeekToBegin(Stream); }
+
+ CSubStreamInfo(): Size(0) {}
+ };
+
+ CObjectVector<CSubStreamInfo> Streams;
+
+ int StreamIndex; // -1 for StartStream
+ // -2 for ZipStream at multivol detection code
+ // >=0 volume index in multivol
+
+ bool NeedSeek;
+
+ bool DisableVolsSearch;
+ bool StartIsExe; // is .exe
+ bool StartIsZ; // is .zip or .zNN
+ bool StartIsZip; // is .zip
+ bool IsUpperCase;
+ bool MissingZip;
+
+ bool ecd_wasRead;
+
+ Int32 StartVolIndex; // -1, if unknown vol index
+ // = (NN - 1), if StartStream is .zNN
+ // = 0, if start vol is exe
+
+ Int32 StartParsingVol; // if we need local parsing, we must use that stream
+ unsigned NumVols;
+
+ int EndVolIndex; // index of last volume (ecd volume),
+ // -1, if is not multivol
+
+ UString BaseName; // name of archive including '.'
+ UString MissingName;
+
+ CMyComPtr<IInStream> ZipStream;
+
+ CCdInfo ecd;
+
+ UInt64 TotalBytesSize; // for MultiVol only
+
+ void ClearRefs()
+ {
+ Streams.Clear();
+ ZipStream.Release();
+ TotalBytesSize = 0;
+ }
+
+ void Clear()
+ {
+ StreamIndex = -1;
+ NeedSeek = false;
+
+ DisableVolsSearch = false;
+ StartIsExe = false;
+ StartIsZ = false;
+ StartIsZip = false;
+ IsUpperCase = false;
+
+ StartVolIndex = -1;
+ StartParsingVol = 0;
+ NumVols = 0;
+ EndVolIndex = -1;
+
+ BaseName.Empty();
+ MissingName.Empty();
+
+ MissingZip = false;
+ ecd_wasRead = false;
+
+ ClearRefs();
+ }
+
+ HRESULT ParseArcName(IArchiveOpenVolumeCallback *volCallback);
+
+ HRESULT Read(void *data, UInt32 size, UInt32 *processedSize);
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CVolStream
+ , ISequentialInStream
+)
+public:
+ CVols *Vols;
+};
+
+
+class CInArchive
+{
+ CMidBuffer Buffer;
+ size_t _bufPos;
+ size_t _bufCached;
+
+ UInt64 _streamPos;
+ UInt64 _cnt;
+
+ // UInt32 _startLocalFromCd_Disk;
+ // UInt64 _startLocalFromCd_Offset;
+
+ size_t GetAvail() const { return _bufCached - _bufPos; }
+
+ void InitBuf() { _bufPos = 0; _bufCached = 0; }
+ void DisableBufMode() { InitBuf(); _inBufMode = false; }
+
+ void SkipLookahed(size_t skip)
+ {
+ _bufPos += skip;
+ _cnt += skip;
+ }
+
+ HRESULT AllocateBuffer(size_t size);
+
+ UInt64 GetVirtStreamPos() { return _streamPos - _bufCached + _bufPos; }
+
+ bool _inBufMode;
+
+ bool IsArcOpen;
+ bool CanStartNewVol;
+
+ UInt32 _signature;
+
+ CMyComPtr<IInStream> StreamRef;
+ IInStream *Stream;
+ IInStream *StartStream;
+ IArchiveOpenCallback *Callback;
+
+ HRESULT Seek_SavePos(UInt64 offset);
+ HRESULT SeekToVol(int volIndex, UInt64 offset);
+
+ HRESULT ReadFromCache(Byte *data, unsigned size, unsigned &processed);
+ HRESULT ReadFromCache_FALSE(Byte *data, unsigned size);
+
+ HRESULT ReadVols2(IArchiveOpenVolumeCallback *volCallback,
+ unsigned start, int lastDisk, int zipDisk, unsigned numMissingVolsMax, unsigned &numMissingVols);
+ HRESULT ReadVols();
+
+ HRESULT FindMarker(const UInt64 *searchLimit);
+ HRESULT IncreaseRealPosition(UInt64 addValue, bool &isFinished);
+
+ HRESULT LookAhead(size_t minRequiredInBuffer);
+ void SafeRead(Byte *data, unsigned size);
+ void ReadBuffer(CByteBuffer &buffer, unsigned size);
+ // Byte ReadByte();
+ // UInt16 ReadUInt16();
+ UInt32 ReadUInt32();
+ UInt64 ReadUInt64();
+
+ void ReadSignature();
+
+ void Skip(size_t num);
+ HRESULT Skip64(UInt64 num, unsigned numFiles);
+
+ bool ReadFileName(unsigned nameSize, AString &dest);
+
+ bool ReadExtra(const CLocalItem &item, unsigned extraSize, CExtraBlock &extra,
+ UInt64 &unpackSize, UInt64 &packSize, CItem *cdItem);
+ bool ReadLocalItem(CItemEx &item);
+ HRESULT FindDescriptor(CItemEx &item, unsigned numFiles);
+ HRESULT ReadCdItem(CItemEx &item);
+ HRESULT TryEcd64(UInt64 offset, CCdInfo &cdInfo);
+ HRESULT FindCd(bool checkOffsetMode);
+ HRESULT TryReadCd(CObjectVector<CItemEx> &items, const CCdInfo &cdInfo, UInt64 cdOffset, UInt64 cdSize);
+ HRESULT ReadCd(CObjectVector<CItemEx> &items, UInt32 &cdDisk, UInt64 &cdOffset, UInt64 &cdSize);
+ HRESULT ReadLocals(CObjectVector<CItemEx> &localItems);
+
+ HRESULT ReadHeaders(CObjectVector<CItemEx> &items);
+
+ HRESULT GetVolStream(unsigned vol, UInt64 pos, CMyComPtr<ISequentialInStream> &stream);
+
+public:
+ CInArchiveInfo ArcInfo;
+
+ bool IsArc;
+ bool IsZip64;
+
+ bool IsApk;
+ bool IsCdUnsorted;
+
+ bool HeadersError;
+ bool HeadersWarning;
+ bool ExtraMinorError;
+ bool UnexpectedEnd;
+ bool LocalsWereRead;
+ bool LocalsCenterMerged;
+ bool NoCentralDir;
+ bool Overflow32bit; // = true, if zip without Zip64 extension support and it has some fields values truncated to 32-bits.
+ bool Cd_NumEntries_Overflow_16bit; // = true, if no Zip64 and 16-bit ecd:NumEntries was overflowed.
+
+ bool MarkerIsFound;
+ bool MarkerIsSafe;
+
+ bool IsMultiVol;
+ bool UseDisk_in_SingleVol;
+ UInt32 EcdVolIndex;
+
+ CVols Vols;
+
+ bool Force_ReadLocals_Mode;
+ bool Disable_VolsRead;
+ bool Disable_FindMarker;
+
+ CInArchive():
+ IsArcOpen(false),
+ Stream(NULL),
+ StartStream(NULL),
+ Callback(NULL),
+ Force_ReadLocals_Mode(false),
+ Disable_VolsRead(false),
+ Disable_FindMarker(false)
+ {}
+
+ UInt64 GetPhySize() const
+ {
+ if (IsMultiVol)
+ return ArcInfo.FinishPos;
+ else
+ return (UInt64)((Int64)ArcInfo.FinishPos - ArcInfo.Base);
+ }
+
+ UInt64 GetOffset() const
+ {
+ if (IsMultiVol)
+ return 0;
+ else
+ return (UInt64)ArcInfo.Base;
+ }
+
+
+ void ClearRefs();
+ void Close();
+ HRESULT Open(IInStream *stream, const UInt64 *searchLimit, IArchiveOpenCallback *callback, CObjectVector<CItemEx> &items);
+
+ bool IsOpen() const { return IsArcOpen; }
+
+ bool AreThereErrors() const
+ {
+ return HeadersError
+ || UnexpectedEnd
+ || !Vols.MissingName.IsEmpty();
+ }
+
+ bool IsLocalOffsetOK(const CItemEx &item) const
+ {
+ if (item.FromLocal)
+ return true;
+ return (Int64)GetOffset() + (Int64)item.LocalHeaderPos >= 0;
+ }
+
+ UInt64 GetEmbeddedStubSize() const
+ {
+ // it's possible that first item in CD doesn refers to first local item
+ // so FirstItemRelatOffset is not first local item
+
+ if (ArcInfo.CdWasRead)
+ return ArcInfo.FirstItemRelatOffset;
+ if (IsMultiVol)
+ return 0;
+ return (UInt64)((Int64)ArcInfo.MarkerPos2 - ArcInfo.Base);
+ }
+
+
+ HRESULT CheckDescriptor(const CItemEx &item);
+ HRESULT Read_LocalItem_After_CdItem(CItemEx &item, bool &isAvail, bool &headersError);
+ HRESULT Read_LocalItem_After_CdItem_Full(CItemEx &item);
+
+ HRESULT GetItemStream(const CItemEx &item, bool seekPackData, CMyComPtr<ISequentialInStream> &stream);
+
+ IInStream *GetBaseStream() { return StreamRef; }
+
+ bool CanUpdate() const
+ {
+ if (AreThereErrors()
+ || IsMultiVol
+ || ArcInfo.Base < 0
+ || (Int64)ArcInfo.MarkerPos2 < ArcInfo.Base
+ || ArcInfo.ThereIsTail
+ || GetEmbeddedStubSize() != 0
+ || IsApk
+ || IsCdUnsorted)
+ return false;
+
+ // 7-zip probably can update archives with embedded stubs.
+ // we just disable that feature for more safety.
+
+ return true;
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipItem.cpp b/CPP/7zip/Archive/Zip/ZipItem.cpp
new file mode 100644
index 0000000..a77643b
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipItem.cpp
@@ -0,0 +1,462 @@
+// Archive/ZipItem.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyLinux.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariantUtils.h"
+
+#include "../Common/ItemNameUtils.h"
+
+#include "ZipItem.h"
+
+namespace NArchive {
+namespace NZip {
+
+using namespace NFileHeader;
+
+
+/*
+const char *k_SpecName_NTFS_STREAM = "@@NTFS@STREAM@";
+const char *k_SpecName_MAC_RESOURCE_FORK = "@@MAC@RESOURCE-FORK@";
+*/
+
+static const CUInt32PCharPair g_ExtraTypes[] =
+{
+ { NExtraID::kZip64, "Zip64" },
+ { NExtraID::kNTFS, "NTFS" },
+ { NExtraID::kUnix0, "UNIX" },
+ { NExtraID::kStrongEncrypt, "StrongCrypto" },
+ { NExtraID::kUnixTime, "UT" },
+ { NExtraID::kUnix1, "UX" },
+ { NExtraID::kUnix2, "Ux" },
+ { NExtraID::kUnixN, "ux" },
+ { NExtraID::kIzUnicodeComment, "uc" },
+ { NExtraID::kIzUnicodeName, "up" },
+ { NExtraID::kIzNtSecurityDescriptor, "SD" },
+ { NExtraID::kWzAES, "WzAES" },
+ { NExtraID::kApkAlign, "ApkAlign" }
+};
+
+void CExtraSubBlock::PrintInfo(AString &s) const
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_ExtraTypes); i++)
+ {
+ const CUInt32PCharPair &pair = g_ExtraTypes[i];
+ if (pair.Value == ID)
+ {
+ s += pair.Name;
+ if (ID == NExtraID::kUnixTime)
+ {
+ if (Data.Size() >= 1)
+ {
+ s += ':';
+ const Byte flags = Data[0];
+ if (flags & 1) s += 'M';
+ if (flags & 2) s += 'A';
+ if (flags & 4) s += 'C';
+ const UInt32 size = (UInt32)(Data.Size()) - 1;
+ if (size % 4 == 0)
+ {
+ s += ':';
+ s.Add_UInt32(size / 4);
+ }
+ }
+ }
+ /*
+ if (ID == NExtraID::kApkAlign && Data.Size() >= 2)
+ {
+ char sz[32];
+ sz[0] = ':';
+ ConvertUInt32ToHex(GetUi16(Data), sz + 1);
+ s += sz;
+ for (unsigned j = 2; j < Data.Size(); j++)
+ {
+ char sz[32];
+ sz[0] = '-';
+ ConvertUInt32ToHex(Data[j], sz + 1);
+ s += sz;
+ }
+ }
+ */
+ return;
+ }
+ }
+ {
+ char sz[32];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt32ToHex(ID, sz + 2);
+ s += sz;
+ }
+}
+
+
+void CExtraBlock::PrintInfo(AString &s) const
+{
+ if (Error)
+ s.Add_OptSpaced("Extra_ERROR");
+
+ if (MinorError)
+ s.Add_OptSpaced("Minor_Extra_ERROR");
+
+ if (IsZip64 || IsZip64_Error)
+ {
+ s.Add_OptSpaced("Zip64");
+ if (IsZip64_Error)
+ s += "_ERROR";
+ }
+
+ FOR_VECTOR (i, SubBlocks)
+ {
+ s.Add_Space_if_NotEmpty();
+ SubBlocks[i].PrintInfo(s);
+ }
+}
+
+
+bool CExtraSubBlock::ExtractNtfsTime(unsigned index, FILETIME &ft) const
+{
+ ft.dwHighDateTime = ft.dwLowDateTime = 0;
+ UInt32 size = (UInt32)Data.Size();
+ if (ID != NExtraID::kNTFS || size < 32)
+ return false;
+ const Byte *p = (const Byte *)Data;
+ p += 4; // for reserved
+ size -= 4;
+ while (size > 4)
+ {
+ UInt16 tag = GetUi16(p);
+ unsigned attrSize = GetUi16(p + 2);
+ p += 4;
+ size -= 4;
+ if (attrSize > size)
+ attrSize = size;
+
+ if (tag == NNtfsExtra::kTagTime && attrSize >= 24)
+ {
+ p += 8 * index;
+ ft.dwLowDateTime = GetUi32(p);
+ ft.dwHighDateTime = GetUi32(p + 4);
+ return true;
+ }
+ p += attrSize;
+ size -= attrSize;
+ }
+ return false;
+}
+
+bool CExtraSubBlock::Extract_UnixTime(bool isCentral, unsigned index, UInt32 &res) const
+{
+ /* Info-Zip :
+ The central-header extra field contains the modification
+ time only, or no timestamp at all.
+ Size of Data is used to flag its presence or absence
+ If "Flags" indicates that Modtime is present in the local header
+ field, it MUST be present in the central header field, too
+ */
+
+ res = 0;
+ UInt32 size = (UInt32)Data.Size();
+ if (ID != NExtraID::kUnixTime || size < 5)
+ return false;
+ const Byte *p = (const Byte *)Data;
+ const Byte flags = *p++;
+ size--;
+ if (isCentral)
+ {
+ if (index != NUnixTime::kMTime ||
+ (flags & (1 << NUnixTime::kMTime)) == 0 ||
+ size < 4)
+ return false;
+ res = GetUi32(p);
+ return true;
+ }
+ for (unsigned i = 0; i < 3; i++)
+ if ((flags & (1 << i)) != 0)
+ {
+ if (size < 4)
+ return false;
+ if (index == i)
+ {
+ res = GetUi32(p);
+ return true;
+ }
+ p += 4;
+ size -= 4;
+ }
+ return false;
+}
+
+
+// Info-ZIP's abandoned "Unix1 timestamps & owner ID info"
+
+bool CExtraSubBlock::Extract_Unix01_Time(unsigned index, UInt32 &res) const
+{
+ res = 0;
+ const unsigned offset = index * 4;
+ if (Data.Size() < offset + 4)
+ return false;
+ if (ID != NExtraID::kUnix0 &&
+ ID != NExtraID::kUnix1)
+ return false;
+ const Byte *p = (const Byte *)Data + offset;
+ res = GetUi32(p);
+ return true;
+}
+
+/*
+// PKWARE's Unix "extra" is similar to Info-ZIP's abandoned "Unix1 timestamps"
+bool CExtraSubBlock::Extract_Unix_Time(unsigned index, UInt32 &res) const
+{
+ res = 0;
+ const unsigned offset = index * 4;
+ if (ID != NExtraID::kUnix0 || Data.Size() < offset)
+ return false;
+ const Byte *p = (const Byte *)Data + offset;
+ res = GetUi32(p);
+ return true;
+}
+*/
+
+bool CExtraBlock::GetNtfsTime(unsigned index, FILETIME &ft) const
+{
+ FOR_VECTOR (i, SubBlocks)
+ {
+ const CExtraSubBlock &sb = SubBlocks[i];
+ if (sb.ID == NFileHeader::NExtraID::kNTFS)
+ return sb.ExtractNtfsTime(index, ft);
+ }
+ return false;
+}
+
+bool CExtraBlock::GetUnixTime(bool isCentral, unsigned index, UInt32 &res) const
+{
+ {
+ FOR_VECTOR (i, SubBlocks)
+ {
+ const CExtraSubBlock &sb = SubBlocks[i];
+ if (sb.ID == NFileHeader::NExtraID::kUnixTime)
+ return sb.Extract_UnixTime(isCentral, index, res);
+ }
+ }
+
+ switch (index)
+ {
+ case NUnixTime::kMTime: index = NUnixExtra::kMTime; break;
+ case NUnixTime::kATime: index = NUnixExtra::kATime; break;
+ default: return false;
+ }
+
+ {
+ FOR_VECTOR (i, SubBlocks)
+ {
+ const CExtraSubBlock &sb = SubBlocks[i];
+ if (sb.ID == NFileHeader::NExtraID::kUnix0 ||
+ sb.ID == NFileHeader::NExtraID::kUnix1)
+ return sb.Extract_Unix01_Time(index, res);
+ }
+ }
+ return false;
+}
+
+
+bool CLocalItem::IsDir() const
+{
+ return NItemName::HasTailSlash(Name, GetCodePage());
+}
+
+bool CItem::IsDir() const
+{
+ // FIXME: we can check InfoZip UTF-8 name at first.
+ if (NItemName::HasTailSlash(Name, GetCodePage()))
+ return true;
+
+ Byte hostOS = GetHostOS();
+
+ if (Size == 0 && PackSize == 0 && !Name.IsEmpty() && Name.Back() == '\\')
+ {
+ // do we need to use CharPrevExA?
+ // .NET Framework 4.5 : System.IO.Compression::CreateFromDirectory() probably writes backslashes to headers?
+ // so we support that case
+ switch (hostOS)
+ {
+ case NHostOS::kFAT:
+ case NHostOS::kNTFS:
+ case NHostOS::kHPFS:
+ case NHostOS::kVFAT:
+ return true;
+ }
+ }
+
+ if (!FromCentral)
+ return false;
+
+ UInt16 highAttrib = (UInt16)((ExternalAttrib >> 16 ) & 0xFFFF);
+
+ switch (hostOS)
+ {
+ case NHostOS::kAMIGA:
+ switch (highAttrib & NAmigaAttrib::kIFMT)
+ {
+ case NAmigaAttrib::kIFDIR: return true;
+ case NAmigaAttrib::kIFREG: return false;
+ default: return false; // change it throw kUnknownAttributes;
+ }
+ case NHostOS::kFAT:
+ case NHostOS::kNTFS:
+ case NHostOS::kHPFS:
+ case NHostOS::kVFAT:
+ return ((ExternalAttrib & FILE_ATTRIBUTE_DIRECTORY) != 0);
+ case NHostOS::kAtari:
+ case NHostOS::kMac:
+ case NHostOS::kVMS:
+ case NHostOS::kVM_CMS:
+ case NHostOS::kAcorn:
+ case NHostOS::kMVS:
+ return false; // change it throw kUnknownAttributes;
+ case NHostOS::kUnix:
+ return MY_LIN_S_ISDIR(highAttrib);
+ default:
+ return false;
+ }
+}
+
+UInt32 CItem::GetWinAttrib() const
+{
+ UInt32 winAttrib = 0;
+ switch (GetHostOS())
+ {
+ case NHostOS::kFAT:
+ case NHostOS::kNTFS:
+ if (FromCentral)
+ winAttrib = ExternalAttrib;
+ break;
+ case NHostOS::kUnix:
+ // do we need to clear 16 low bits in this case?
+ if (FromCentral)
+ {
+ /*
+ Some programs write posix attributes in high 16 bits of ExternalAttrib
+ Also some programs can write additional marker flag:
+ 0x8000 - p7zip
+ 0x4000 - Zip in MacOS
+ no marker - Info-Zip
+
+ Client code has two options to detect posix field:
+ 1) check 0x8000 marker. In that case we must add 0x8000 marker here.
+ 2) check that high 4 bits (file type bits in posix field) of attributes are not zero.
+ */
+
+ winAttrib = ExternalAttrib & 0xFFFF0000;
+
+ // #ifndef _WIN32
+ winAttrib |= 0x8000; // add posix mode marker
+ // #endif
+ }
+ break;
+ }
+ if (IsDir()) // test it;
+ winAttrib |= FILE_ATTRIBUTE_DIRECTORY;
+ return winAttrib;
+}
+
+bool CItem::GetPosixAttrib(UInt32 &attrib) const
+{
+ // some archivers can store PosixAttrib in high 16 bits even with HostOS=FAT.
+ if (FromCentral && GetHostOS() == NHostOS::kUnix)
+ {
+ attrib = ExternalAttrib >> 16;
+ return (attrib != 0);
+ }
+ attrib = 0;
+ if (IsDir())
+ attrib = MY_LIN_S_IFDIR;
+ return false;
+}
+
+
+bool CExtraSubBlock::CheckIzUnicode(const AString &s) const
+{
+ size_t size = Data.Size();
+ if (size < 1 + 4)
+ return false;
+ const Byte *p = (const Byte *)Data;
+ if (p[0] > 1)
+ return false;
+ if (CrcCalc(s, s.Len()) != GetUi32(p + 1))
+ return false;
+ size -= 5;
+ p += 5;
+ for (size_t i = 0; i < size; i++)
+ if (p[i] == 0)
+ return false;
+ return Check_UTF8_Buf((const char *)(const void *)p, size, false);
+}
+
+
+void CItem::GetUnicodeString(UString &res, const AString &s, bool isComment, bool useSpecifiedCodePage, UINT codePage) const
+{
+ bool isUtf8 = IsUtf8();
+ // bool ignore_Utf8_Errors = true;
+
+ if (!isUtf8)
+ {
+ {
+ const unsigned id = isComment ?
+ NFileHeader::NExtraID::kIzUnicodeComment:
+ NFileHeader::NExtraID::kIzUnicodeName;
+ const CObjectVector<CExtraSubBlock> &subBlocks = GetMainExtra().SubBlocks;
+
+ FOR_VECTOR (i, subBlocks)
+ {
+ const CExtraSubBlock &sb = subBlocks[i];
+ if (sb.ID == id)
+ {
+ if (sb.CheckIzUnicode(s))
+ {
+ // const unsigned kIzUnicodeHeaderSize = 5;
+ if (Convert_UTF8_Buf_To_Unicode(
+ (const char *)(const void *)(const Byte *)sb.Data + 5,
+ sb.Data.Size() - 5, res))
+ return;
+ }
+ break;
+ }
+ }
+ }
+
+ if (useSpecifiedCodePage)
+ isUtf8 = (codePage == CP_UTF8);
+ #ifdef _WIN32
+ else if (GetHostOS() == NFileHeader::NHostOS::kUnix)
+ {
+ /* Some ZIP archives in Unix use UTF-8 encoding without Utf8 flag in header.
+ We try to get name as UTF-8.
+ Do we need to do it in POSIX version also? */
+ isUtf8 = true;
+
+ /* 21.02: we want to ignore UTF-8 errors to support file paths that are mixed
+ of UTF-8 and non-UTF-8 characters. */
+ // ignore_Utf8_Errors = false;
+ // ignore_Utf8_Errors = true;
+ }
+ #endif
+ }
+
+
+ if (isUtf8)
+ {
+ ConvertUTF8ToUnicode(s, res);
+ return;
+ }
+
+ MultiByteToUnicodeString2(res, s, useSpecifiedCodePage ? codePage : GetCodePage());
+}
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipItem.h b/CPP/7zip/Archive/Zip/ZipItem.h
new file mode 100644
index 0000000..4a25de3
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipItem.h
@@ -0,0 +1,356 @@
+// Archive/ZipItem.h
+
+#ifndef ZIP7_INC_ARCHIVE_ZIP_ITEM_H
+#define ZIP7_INC_ARCHIVE_ZIP_ITEM_H
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyString.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "ZipHeader.h"
+
+namespace NArchive {
+namespace NZip {
+
+/*
+extern const char *k_SpecName_NTFS_STREAM;
+extern const char *k_SpecName_MAC_RESOURCE_FORK;
+*/
+
+struct CVersion
+{
+ Byte Version;
+ Byte HostOS;
+};
+
+struct CExtraSubBlock
+{
+ UInt32 ID;
+ CByteBuffer Data;
+
+ bool ExtractNtfsTime(unsigned index, FILETIME &ft) const;
+ bool Extract_UnixTime(bool isCentral, unsigned index, UInt32 &res) const;
+ bool Extract_Unix01_Time(unsigned index, UInt32 &res) const;
+ // bool Extract_Unix_Time(unsigned index, UInt32 &res) const;
+
+ bool CheckIzUnicode(const AString &s) const;
+
+ void PrintInfo(AString &s) const;
+};
+
+const unsigned k_WzAesExtra_Size = 7;
+
+struct CWzAesExtra
+{
+ UInt16 VendorVersion; // 1: AE-1, 2: AE-2,
+ // UInt16 VendorId; // 'A' 'E'
+ Byte Strength; // 1: 128-bit, 2: 192-bit, 3: 256-bit
+ UInt16 Method;
+
+ CWzAesExtra(): VendorVersion(2), Strength(3), Method(0) {}
+
+ bool NeedCrc() const { return (VendorVersion == 1); }
+
+ bool ParseFromSubBlock(const CExtraSubBlock &sb)
+ {
+ if (sb.ID != NFileHeader::NExtraID::kWzAES)
+ return false;
+ if (sb.Data.Size() < k_WzAesExtra_Size)
+ return false;
+ const Byte *p = (const Byte *)sb.Data;
+ VendorVersion = GetUi16(p);
+ if (p[2] != 'A' || p[3] != 'E')
+ return false;
+ Strength = p[4];
+ // 9.31: The BUG was fixed:
+ Method = GetUi16(p + 5);
+ return true;
+ }
+
+ void SetSubBlock(CExtraSubBlock &sb) const
+ {
+ sb.Data.Alloc(k_WzAesExtra_Size);
+ sb.ID = NFileHeader::NExtraID::kWzAES;
+ Byte *p = (Byte *)sb.Data;
+ p[0] = (Byte)VendorVersion;
+ p[1] = (Byte)(VendorVersion >> 8);
+ p[2] = 'A';
+ p[3] = 'E';
+ p[4] = Strength;
+ p[5] = (Byte)Method;
+ p[6] = (Byte)(Method >> 8);
+ }
+};
+
+namespace NStrongCrypto_AlgId
+{
+ const UInt16 kDES = 0x6601;
+ const UInt16 kRC2old = 0x6602;
+ const UInt16 k3DES168 = 0x6603;
+ const UInt16 k3DES112 = 0x6609;
+ const UInt16 kAES128 = 0x660E;
+ const UInt16 kAES192 = 0x660F;
+ const UInt16 kAES256 = 0x6610;
+ const UInt16 kRC2 = 0x6702;
+ const UInt16 kBlowfish = 0x6720;
+ const UInt16 kTwofish = 0x6721;
+ const UInt16 kRC4 = 0x6801;
+}
+
+struct CStrongCryptoExtra
+{
+ UInt16 Format;
+ UInt16 AlgId;
+ UInt16 BitLen;
+ UInt16 Flags;
+
+ bool ParseFromSubBlock(const CExtraSubBlock &sb)
+ {
+ if (sb.ID != NFileHeader::NExtraID::kStrongEncrypt)
+ return false;
+ const Byte *p = (const Byte *)sb.Data;
+ if (sb.Data.Size() < 8)
+ return false;
+ Format = GetUi16(p + 0);
+ AlgId = GetUi16(p + 2);
+ BitLen = GetUi16(p + 4);
+ Flags = GetUi16(p + 6);
+ return (Format == 2);
+ }
+
+ bool CertificateIsUsed() const { return (Flags > 0x0001); }
+};
+
+
+struct CExtraBlock
+{
+ CObjectVector<CExtraSubBlock> SubBlocks;
+ bool Error;
+ bool MinorError;
+ bool IsZip64;
+ bool IsZip64_Error;
+
+ CExtraBlock(): Error(false), MinorError(false), IsZip64(false), IsZip64_Error(false) {}
+
+ void Clear()
+ {
+ SubBlocks.Clear();
+ IsZip64 = false;
+ }
+
+ size_t GetSize() const
+ {
+ size_t res = 0;
+ FOR_VECTOR (i, SubBlocks)
+ res += SubBlocks[i].Data.Size() + 2 + 2;
+ return res;
+ }
+
+ bool GetWzAes(CWzAesExtra &e) const
+ {
+ FOR_VECTOR (i, SubBlocks)
+ if (e.ParseFromSubBlock(SubBlocks[i]))
+ return true;
+ return false;
+ }
+
+ bool HasWzAes() const
+ {
+ CWzAesExtra e;
+ return GetWzAes(e);
+ }
+
+ bool GetStrongCrypto(CStrongCryptoExtra &e) const
+ {
+ FOR_VECTOR (i, SubBlocks)
+ if (e.ParseFromSubBlock(SubBlocks[i]))
+ return true;
+ return false;
+ }
+
+ /*
+ bool HasStrongCrypto() const
+ {
+ CStrongCryptoExtra e;
+ return GetStrongCrypto(e);
+ }
+ */
+
+ bool GetNtfsTime(unsigned index, FILETIME &ft) const;
+ bool GetUnixTime(bool isCentral, unsigned index, UInt32 &res) const;
+
+ void PrintInfo(AString &s) const;
+
+ void RemoveUnknownSubBlocks()
+ {
+ for (unsigned i = SubBlocks.Size(); i != 0;)
+ {
+ i--;
+ switch (SubBlocks[i].ID)
+ {
+ case NFileHeader::NExtraID::kStrongEncrypt:
+ case NFileHeader::NExtraID::kWzAES:
+ break;
+ default:
+ SubBlocks.Delete(i);
+ }
+ }
+ }
+};
+
+
+class CLocalItem
+{
+public:
+ UInt16 Flags;
+ UInt16 Method;
+
+ /*
+ Zip specification doesn't mention that ExtractVersion field uses HostOS subfield.
+ 18.06: 7-Zip now doesn't use ExtractVersion::HostOS to detect codePage
+ */
+
+ CVersion ExtractVersion;
+
+ UInt64 Size;
+ UInt64 PackSize;
+ UInt32 Time;
+ UInt32 Crc;
+
+ UInt32 Disk;
+
+ AString Name;
+
+ CExtraBlock LocalExtra;
+
+ unsigned GetDescriptorSize() const { return LocalExtra.IsZip64 ? kDataDescriptorSize64 : kDataDescriptorSize32; }
+
+ UInt64 GetPackSizeWithDescriptor() const
+ { return PackSize + (HasDescriptor() ? GetDescriptorSize() : 0); }
+
+ bool IsUtf8() const { return (Flags & NFileHeader::NFlags::kUtf8) != 0; }
+ bool IsEncrypted() const { return (Flags & NFileHeader::NFlags::kEncrypted) != 0; }
+ bool IsStrongEncrypted() const { return IsEncrypted() && (Flags & NFileHeader::NFlags::kStrongEncrypted) != 0; }
+ bool IsAesEncrypted() const { return IsEncrypted() && (IsStrongEncrypted() || Method == NFileHeader::NCompressionMethod::kWzAES); }
+ bool IsLzmaEOS() const { return (Flags & NFileHeader::NFlags::kLzmaEOS) != 0; }
+ bool HasDescriptor() const { return (Flags & NFileHeader::NFlags::kDescriptorUsedMask) != 0; }
+ // bool IsAltStream() const { return (Flags & NFileHeader::NFlags::kAltStream) != 0; }
+
+ unsigned GetDeflateLevel() const { return (Flags >> 1) & 3; }
+
+ bool IsDir() const;
+
+ /*
+ void GetUnicodeString(const AString &s, UString &res) const
+ {
+ bool isUtf8 = IsUtf8();
+ if (isUtf8)
+ if (ConvertUTF8ToUnicode(s, res))
+ return;
+ MultiByteToUnicodeString2(res, s, GetCodePage());
+ }
+ */
+
+private:
+
+ void SetFlag(unsigned bitMask, bool enable)
+ {
+ if (enable)
+ Flags = (UInt16)(Flags | bitMask);
+ else
+ Flags = (UInt16)(Flags & ~bitMask);
+ }
+
+public:
+
+ void ClearFlags() { Flags = 0; }
+ void SetEncrypted(bool encrypted) { SetFlag(NFileHeader::NFlags::kEncrypted, encrypted); }
+ void SetUtf8(bool isUtf8) { SetFlag(NFileHeader::NFlags::kUtf8, isUtf8); }
+ // void SetFlag_AltStream(bool isAltStream) { SetFlag(NFileHeader::NFlags::kAltStream, isAltStream); }
+ void SetDescriptorMode(bool useDescriptor) { SetFlag(NFileHeader::NFlags::kDescriptorUsedMask, useDescriptor); }
+
+ UINT GetCodePage() const
+ {
+ if (IsUtf8())
+ return CP_UTF8;
+ return CP_OEMCP;
+ }
+};
+
+
+class CItem: public CLocalItem
+{
+public:
+ CVersion MadeByVersion;
+ UInt16 InternalAttrib;
+ UInt32 ExternalAttrib;
+
+ UInt64 LocalHeaderPos;
+
+ CExtraBlock CentralExtra;
+ CByteBuffer Comment;
+
+ bool FromLocal;
+ bool FromCentral;
+
+ // CItem can be used as CLocalItem. So we must clear unused fields
+ CItem():
+ InternalAttrib(0),
+ ExternalAttrib(0),
+ FromLocal(false),
+ FromCentral(false)
+ {
+ MadeByVersion.Version = 0;
+ MadeByVersion.HostOS = 0;
+ }
+
+ const CExtraBlock &GetMainExtra() const { return *(FromCentral ? &CentralExtra : &LocalExtra); }
+
+ bool IsDir() const;
+ UInt32 GetWinAttrib() const;
+ bool GetPosixAttrib(UInt32 &attrib) const;
+
+ // 18.06: 0 instead of ExtractVersion.HostOS for local item
+ Byte GetHostOS() const { return FromCentral ? MadeByVersion.HostOS : (Byte)0; }
+
+ void GetUnicodeString(UString &res, const AString &s, bool isComment, bool useSpecifiedCodePage, UINT codePage) const;
+
+ bool IsThereCrc() const
+ {
+ if (Method == NFileHeader::NCompressionMethod::kWzAES)
+ {
+ CWzAesExtra aesField;
+ if (GetMainExtra().GetWzAes(aesField))
+ return aesField.NeedCrc();
+ }
+ return (Crc != 0 || !IsDir());
+ }
+
+ bool Is_MadeBy_Unix() const
+ {
+ if (!FromCentral)
+ return false;
+ return (MadeByVersion.HostOS == NFileHeader::NHostOS::kUnix);
+ }
+
+ UINT GetCodePage() const
+ {
+ // 18.06: now we use HostOS only from Central::MadeByVersion
+ if (IsUtf8())
+ return CP_UTF8;
+ if (!FromCentral)
+ return CP_OEMCP;
+ Byte hostOS = MadeByVersion.HostOS;
+ return (UINT)((
+ hostOS == NFileHeader::NHostOS::kFAT
+ || hostOS == NFileHeader::NHostOS::kNTFS
+ || hostOS == NFileHeader::NHostOS::kUnix // do we need it?
+ ) ? CP_OEMCP : CP_ACP);
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipOut.cpp b/CPP/7zip/Archive/Zip/ZipOut.cpp
new file mode 100644
index 0000000..63f1a71
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipOut.cpp
@@ -0,0 +1,420 @@
+// ZipOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/7zCrc.h"
+
+#include "../../../Windows/TimeUtils.h"
+#include "../../Common/OffsetStream.h"
+
+#include "ZipOut.h"
+
+namespace NArchive {
+namespace NZip {
+
+HRESULT COutArchive::ClearRestriction()
+{
+ if (SetRestriction)
+ return SetRestriction->SetRestriction(0, 0);
+ return S_OK;
+}
+
+HRESULT COutArchive::SetRestrictionFromCurrent()
+{
+ if (SetRestriction)
+ return SetRestriction->SetRestriction(m_Base + m_CurPos, (UInt64)(Int64)-1);
+ return S_OK;
+}
+
+HRESULT COutArchive::Create(IOutStream *outStream)
+{
+ m_CurPos = 0;
+ if (!m_OutBuffer.Create(1 << 16))
+ return E_OUTOFMEMORY;
+ m_Stream = outStream;
+ m_OutBuffer.SetStream(outStream);
+ m_OutBuffer.Init();
+
+ return m_Stream->Seek(0, STREAM_SEEK_CUR, &m_Base);
+}
+
+void COutArchive::SeekToCurPos()
+{
+ HRESULT res = m_Stream->Seek((Int64)(m_Base + m_CurPos), STREAM_SEEK_SET, NULL);
+ if (res != S_OK)
+ throw CSystemException(res);
+}
+
+#define DOES_NEED_ZIP64(v) (v >= (UInt32)0xFFFFFFFF)
+// #define DOES_NEED_ZIP64(v) (v >= 0)
+
+
+void COutArchive::WriteBytes(const void *data, size_t size)
+{
+ m_OutBuffer.WriteBytes(data, size);
+ m_CurPos += size;
+}
+
+void COutArchive::Write8(Byte b)
+{
+ m_OutBuffer.WriteByte(b);
+ m_CurPos++;
+}
+
+void COutArchive::Write16(UInt16 val)
+{
+ Write8((Byte)val);
+ Write8((Byte)(val >> 8));
+}
+
+void COutArchive::Write32(UInt32 val)
+{
+ for (int i = 0; i < 4; i++)
+ {
+ Write8((Byte)val);
+ val >>= 8;
+ }
+}
+
+void COutArchive::Write64(UInt64 val)
+{
+ for (int i = 0; i < 8; i++)
+ {
+ Write8((Byte)val);
+ val >>= 8;
+ }
+}
+
+void COutArchive::WriteExtra(const CExtraBlock &extra)
+{
+ FOR_VECTOR (i, extra.SubBlocks)
+ {
+ const CExtraSubBlock &subBlock = extra.SubBlocks[i];
+ Write16((UInt16)subBlock.ID);
+ Write16((UInt16)subBlock.Data.Size());
+ WriteBytes(subBlock.Data, (UInt16)subBlock.Data.Size());
+ }
+}
+
+void COutArchive::WriteCommonItemInfo(const CLocalItem &item, bool isZip64)
+{
+ {
+ Byte ver = item.ExtractVersion.Version;
+ if (isZip64 && ver < NFileHeader::NCompressionMethod::kExtractVersion_Zip64)
+ ver = NFileHeader::NCompressionMethod::kExtractVersion_Zip64;
+ Write8(ver);
+ }
+ Write8(item.ExtractVersion.HostOS);
+ Write16(item.Flags);
+ Write16(item.Method);
+ Write32(item.Time);
+}
+
+
+#define WRITE_32_VAL_SPEC(_v_, _isZip64_) Write32((_isZip64_) ? 0xFFFFFFFF : (UInt32)(_v_));
+
+
+void COutArchive::WriteUtfName(const CItemOut &item)
+{
+ if (item.Name_Utf.Size() == 0)
+ return;
+ Write16(NFileHeader::NExtraID::kIzUnicodeName);
+ Write16((UInt16)(5 + item.Name_Utf.Size()));
+ Write8(1); // (1 = version) of that extra field
+ Write32(CrcCalc(item.Name.Ptr(), item.Name.Len()));
+ WriteBytes(item.Name_Utf, (UInt16)item.Name_Utf.Size());
+}
+
+
+static const unsigned k_Ntfs_ExtraSize = 4 + 2 + 2 + (3 * 8);
+static const unsigned k_UnixTime_ExtraSize = 1 + (1 * 4);
+
+void COutArchive::WriteTimeExtra(const CItemOut &item, bool writeNtfs)
+{
+ if (writeNtfs)
+ {
+ // windows explorer ignores that extra
+ Write16(NFileHeader::NExtraID::kNTFS);
+ Write16(k_Ntfs_ExtraSize);
+ Write32(0); // reserved
+ Write16(NFileHeader::NNtfsExtra::kTagTime);
+ Write16(8 * 3);
+ WriteNtfsTime(item.Ntfs_MTime);
+ WriteNtfsTime(item.Ntfs_ATime);
+ WriteNtfsTime(item.Ntfs_CTime);
+ }
+
+ if (item.Write_UnixTime)
+ {
+ // windows explorer ignores that extra
+ // by specification : should we write to local header also?
+ Write16(NFileHeader::NExtraID::kUnixTime);
+ Write16(k_UnixTime_ExtraSize);
+ const Byte flags = (Byte)((unsigned)1 << NFileHeader::NUnixTime::kMTime);
+ Write8(flags);
+ UInt32 unixTime;
+ NWindows::NTime::FileTime_To_UnixTime(item.Ntfs_MTime, unixTime);
+ Write32(unixTime);
+ }
+}
+
+
+void COutArchive::WriteLocalHeader(CItemOut &item, bool needCheck)
+{
+ m_LocalHeaderPos = m_CurPos;
+ item.LocalHeaderPos = m_CurPos;
+
+ bool isZip64 =
+ DOES_NEED_ZIP64(item.PackSize) ||
+ DOES_NEED_ZIP64(item.Size);
+
+ if (needCheck && m_IsZip64)
+ isZip64 = true;
+
+ // Why don't we write NTFS timestamps to local header?
+ // Probably we want to reduce size of archive?
+ const bool writeNtfs = false; // do not write NTFS timestamp to local header
+ // const bool writeNtfs = item.Write_NtfsTime; // write NTFS time to local header
+ const UInt32 localExtraSize = (UInt32)(
+ (isZip64 ? (4 + 8 + 8): 0)
+ + (writeNtfs ? 4 + k_Ntfs_ExtraSize : 0)
+ + (item.Write_UnixTime ? 4 + k_UnixTime_ExtraSize : 0)
+ + item.Get_UtfName_ExtraSize()
+ + item.LocalExtra.GetSize());
+ if ((UInt16)localExtraSize != localExtraSize)
+ throw CSystemException(E_FAIL);
+ if (needCheck && m_ExtraSize != localExtraSize)
+ throw CSystemException(E_FAIL);
+
+ m_IsZip64 = isZip64;
+ m_ExtraSize = localExtraSize;
+
+ item.LocalExtra.IsZip64 = isZip64;
+
+ Write32(NSignature::kLocalFileHeader);
+
+ WriteCommonItemInfo(item, isZip64);
+
+ Write32(item.HasDescriptor() ? 0 : item.Crc);
+
+ UInt64 packSize = item.PackSize;
+ UInt64 size = item.Size;
+
+ if (item.HasDescriptor())
+ {
+ packSize = 0;
+ size = 0;
+ }
+
+ WRITE_32_VAL_SPEC(packSize, isZip64)
+ WRITE_32_VAL_SPEC(size, isZip64)
+
+ Write16((UInt16)item.Name.Len());
+
+ Write16((UInt16)localExtraSize);
+
+ WriteBytes((const char *)item.Name, (UInt16)item.Name.Len());
+
+ if (isZip64)
+ {
+ Write16(NFileHeader::NExtraID::kZip64);
+ Write16(8 + 8);
+ Write64(size);
+ Write64(packSize);
+ }
+
+ WriteTimeExtra(item, writeNtfs);
+
+ WriteUtfName(item);
+
+ WriteExtra(item.LocalExtra);
+
+ const UInt32 localFileHeaderSize = (UInt32)(m_CurPos - m_LocalHeaderPos);
+ if (needCheck && m_LocalFileHeaderSize != localFileHeaderSize)
+ throw CSystemException(E_FAIL);
+ m_LocalFileHeaderSize = localFileHeaderSize;
+
+ m_OutBuffer.FlushWithCheck();
+}
+
+
+void COutArchive::WriteLocalHeader_Replace(CItemOut &item)
+{
+ m_CurPos = m_LocalHeaderPos + m_LocalFileHeaderSize + item.PackSize;
+
+ if (item.HasDescriptor())
+ {
+ WriteDescriptor(item);
+ m_OutBuffer.FlushWithCheck();
+ return;
+ // we don't replace local header, if we write Descriptor.
+ // so local header with Descriptor flag must be written to local header before.
+ }
+
+ const UInt64 nextPos = m_CurPos;
+ m_CurPos = m_LocalHeaderPos;
+ SeekToCurPos();
+ WriteLocalHeader(item, true);
+ m_CurPos = nextPos;
+ SeekToCurPos();
+}
+
+
+void COutArchive::WriteDescriptor(const CItemOut &item)
+{
+ Byte buf[kDataDescriptorSize64];
+ SetUi32(buf, NSignature::kDataDescriptor)
+ SetUi32(buf + 4, item.Crc)
+ unsigned descriptorSize;
+ if (m_IsZip64)
+ {
+ SetUi64(buf + 8, item.PackSize)
+ SetUi64(buf + 16, item.Size)
+ descriptorSize = kDataDescriptorSize64;
+ }
+ else
+ {
+ SetUi32(buf + 8, (UInt32)item.PackSize)
+ SetUi32(buf + 12, (UInt32)item.Size)
+ descriptorSize = kDataDescriptorSize32;
+ }
+ WriteBytes(buf, descriptorSize);
+}
+
+
+
+void COutArchive::WriteCentralHeader(const CItemOut &item)
+{
+ const bool isUnPack64 = DOES_NEED_ZIP64(item.Size);
+ const bool isPack64 = DOES_NEED_ZIP64(item.PackSize);
+ const bool isPosition64 = DOES_NEED_ZIP64(item.LocalHeaderPos);
+ const bool isZip64 = isPack64 || isUnPack64 || isPosition64;
+
+ Write32(NSignature::kCentralFileHeader);
+ Write8(item.MadeByVersion.Version);
+ Write8(item.MadeByVersion.HostOS);
+
+ WriteCommonItemInfo(item, isZip64);
+ Write32(item.Crc);
+
+ WRITE_32_VAL_SPEC(item.PackSize, isPack64)
+ WRITE_32_VAL_SPEC(item.Size, isUnPack64)
+
+ Write16((UInt16)item.Name.Len());
+
+ const UInt16 zip64ExtraSize = (UInt16)((isUnPack64 ? 8: 0) + (isPack64 ? 8: 0) + (isPosition64 ? 8: 0));
+ const bool writeNtfs = item.Write_NtfsTime;
+ const size_t centralExtraSize =
+ (isZip64 ? 4 + zip64ExtraSize : 0)
+ + (writeNtfs ? 4 + k_Ntfs_ExtraSize : 0)
+ + (item.Write_UnixTime ? 4 + k_UnixTime_ExtraSize : 0)
+ + item.Get_UtfName_ExtraSize()
+ + item.CentralExtra.GetSize();
+
+ const UInt16 centralExtraSize16 = (UInt16)centralExtraSize;
+ if (centralExtraSize16 != centralExtraSize)
+ throw CSystemException(E_FAIL);
+
+ Write16(centralExtraSize16);
+
+ const UInt16 commentSize = (UInt16)item.Comment.Size();
+
+ Write16(commentSize);
+ Write16(0); // DiskNumberStart
+ Write16(item.InternalAttrib);
+ Write32(item.ExternalAttrib);
+ WRITE_32_VAL_SPEC(item.LocalHeaderPos, isPosition64)
+ WriteBytes((const char *)item.Name, item.Name.Len());
+
+ if (isZip64)
+ {
+ Write16(NFileHeader::NExtraID::kZip64);
+ Write16(zip64ExtraSize);
+ if (isUnPack64)
+ Write64(item.Size);
+ if (isPack64)
+ Write64(item.PackSize);
+ if (isPosition64)
+ Write64(item.LocalHeaderPos);
+ }
+
+ WriteTimeExtra(item, writeNtfs);
+ WriteUtfName(item);
+
+ WriteExtra(item.CentralExtra);
+ if (commentSize != 0)
+ WriteBytes(item.Comment, commentSize);
+}
+
+HRESULT COutArchive::WriteCentralDir(const CObjectVector<CItemOut> &items, const CByteBuffer *comment)
+{
+ RINOK(ClearRestriction())
+
+ const UInt64 cdOffset = GetCurPos();
+ FOR_VECTOR (i, items)
+ WriteCentralHeader(items[i]);
+ const UInt64 cd64EndOffset = GetCurPos();
+ const UInt64 cdSize = cd64EndOffset - cdOffset;
+ const bool cdOffset64 = DOES_NEED_ZIP64(cdOffset);
+ const bool cdSize64 = DOES_NEED_ZIP64(cdSize);
+ const bool items64 = items.Size() >= 0xFFFF;
+ const bool isZip64 = (cdOffset64 || cdSize64 || items64);
+
+ // isZip64 = true; // to test Zip64
+
+ if (isZip64)
+ {
+ Write32(NSignature::kEcd64);
+ Write64(kEcd64_MainSize);
+
+ // to test extra block:
+ // const UInt32 extraSize = 1 << 26;
+ // Write64(kEcd64_MainSize + extraSize);
+
+ Write16(45); // made by version
+ Write16(45); // extract version
+ Write32(0); // ThisDiskNumber
+ Write32(0); // StartCentralDirectoryDiskNumber
+ Write64((UInt64)items.Size());
+ Write64((UInt64)items.Size());
+ Write64((UInt64)cdSize);
+ Write64((UInt64)cdOffset);
+
+ // for (UInt32 iii = 0; iii < extraSize; iii++) Write8(1);
+
+ Write32(NSignature::kEcd64Locator);
+ Write32(0); // number of the disk with the start of the zip64 end of central directory
+ Write64(cd64EndOffset);
+ Write32(1); // total number of disks
+ }
+
+ Write32(NSignature::kEcd);
+ Write16(0); // ThisDiskNumber
+ Write16(0); // StartCentralDirectoryDiskNumber
+ Write16((UInt16)(items64 ? 0xFFFF: items.Size()));
+ Write16((UInt16)(items64 ? 0xFFFF: items.Size()));
+
+ WRITE_32_VAL_SPEC(cdSize, cdSize64)
+ WRITE_32_VAL_SPEC(cdOffset, cdOffset64)
+
+ const UInt16 commentSize = (UInt16)(comment ? comment->Size() : 0);
+ Write16((UInt16)commentSize);
+ if (commentSize != 0)
+ WriteBytes((const Byte *)*comment, commentSize);
+ m_OutBuffer.FlushWithCheck();
+ return S_OK;
+}
+
+void COutArchive::CreateStreamForCompressing(CMyComPtr<IOutStream> &outStream)
+{
+ COffsetOutStream *streamSpec = new COffsetOutStream;
+ outStream = streamSpec;
+ streamSpec->Init(m_Stream, m_Base + m_CurPos);
+}
+
+void COutArchive::CreateStreamForCopying(CMyComPtr<ISequentialOutStream> &outStream)
+{
+ outStream = m_Stream;
+}
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipOut.h b/CPP/7zip/Archive/Zip/ZipOut.h
new file mode 100644
index 0000000..e9b2abb
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipOut.h
@@ -0,0 +1,103 @@
+// ZipOut.h
+
+#ifndef ZIP7_INC_ZIP_OUT_H
+#define ZIP7_INC_ZIP_OUT_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../Common/OutBuffer.h"
+
+#include "ZipItem.h"
+
+namespace NArchive {
+namespace NZip {
+
+class CItemOut: public CItem
+{
+public:
+ FILETIME Ntfs_MTime;
+ FILETIME Ntfs_ATime;
+ FILETIME Ntfs_CTime;
+ bool Write_NtfsTime;
+ bool Write_UnixTime;
+
+ // It's possible that NtfsTime is not defined, but there is NtfsTime in Extra.
+
+ CByteBuffer Name_Utf; // for Info-Zip (kIzUnicodeName) Extra
+
+ size_t Get_UtfName_ExtraSize() const
+ {
+ const size_t size = Name_Utf.Size();
+ if (size == 0)
+ return 0;
+ return 4 + 5 + size;
+ }
+
+ CItemOut():
+ Write_NtfsTime(false),
+ Write_UnixTime(false)
+ {}
+};
+
+
+// COutArchive can throw CSystemException and COutBufferException
+
+class COutArchive
+{
+ COutBuffer m_OutBuffer;
+ CMyComPtr<IOutStream> m_Stream;
+
+ UInt64 m_Base; // Base of archive (offset in output Stream)
+ UInt64 m_CurPos; // Curent position in archive (relative from m_Base)
+ UInt64 m_LocalHeaderPos; // LocalHeaderPos (relative from m_Base) for last WriteLocalHeader() call
+
+ UInt32 m_LocalFileHeaderSize;
+ UInt32 m_ExtraSize;
+ bool m_IsZip64;
+
+ void WriteBytes(const void *data, size_t size);
+ void Write8(Byte b);
+ void Write16(UInt16 val);
+ void Write32(UInt32 val);
+ void Write64(UInt64 val);
+ void WriteNtfsTime(const FILETIME &ft)
+ {
+ Write32(ft.dwLowDateTime);
+ Write32(ft.dwHighDateTime);
+ }
+
+ void WriteTimeExtra(const CItemOut &item, bool writeNtfs);
+ void WriteUtfName(const CItemOut &item);
+ void WriteExtra(const CExtraBlock &extra);
+ void WriteCommonItemInfo(const CLocalItem &item, bool isZip64);
+ void WriteCentralHeader(const CItemOut &item);
+
+ void SeekToCurPos();
+public:
+ CMyComPtr<IStreamSetRestriction> SetRestriction;
+
+ HRESULT ClearRestriction();
+ HRESULT SetRestrictionFromCurrent();
+ HRESULT Create(IOutStream *outStream);
+
+ UInt64 GetCurPos() const { return m_CurPos; }
+
+ void MoveCurPos(UInt64 distanceToMove)
+ {
+ m_CurPos += distanceToMove;
+ }
+
+ void WriteLocalHeader(CItemOut &item, bool needCheck = false);
+ void WriteLocalHeader_Replace(CItemOut &item);
+
+ void WriteDescriptor(const CItemOut &item);
+
+ HRESULT WriteCentralDir(const CObjectVector<CItemOut> &items, const CByteBuffer *comment);
+
+ void CreateStreamForCompressing(CMyComPtr<IOutStream> &outStream);
+ void CreateStreamForCopying(CMyComPtr<ISequentialOutStream> &outStream);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/Zip/ZipRegister.cpp b/CPP/7zip/Archive/Zip/ZipRegister.cpp
new file mode 100644
index 0000000..c17a1a3
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipRegister.cpp
@@ -0,0 +1,38 @@
+// ZipRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "ZipHandler.h"
+
+namespace NArchive {
+namespace NZip {
+
+static const Byte k_Signature[] = {
+ 4, 0x50, 0x4B, 0x03, 0x04, // Local
+ 4, 0x50, 0x4B, 0x05, 0x06, // Ecd
+ 4, 0x50, 0x4B, 0x06, 0x06, // Ecd64
+ 6, 0x50, 0x4B, 0x07, 0x08, 0x50, 0x4B, // Span / Descriptor
+ 6, 0x50, 0x4B, 0x30, 0x30, 0x50, 0x4B }; // NoSpan
+
+REGISTER_ARC_IO(
+ "zip", "zip z01 zipx jar xpi odt ods docx xlsx epub ipa apk appx", NULL, 1,
+ k_Signature,
+ 0,
+ NArcInfoFlags::kFindSignature
+ | NArcInfoFlags::kMultiSignature
+ | NArcInfoFlags::kUseGlobalOffset
+ | NArcInfoFlags::kCTime
+ // | NArcInfoFlags::kCTime_Default
+ | NArcInfoFlags::kATime
+ // | NArcInfoFlags::kATime_Default
+ | NArcInfoFlags::kMTime
+ | NArcInfoFlags::kMTime_Default
+ , TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kWindows)
+ | TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kUnix)
+ | TIME_PREC_TO_ARC_FLAGS_MASK (NFileTimeType::kDOS)
+ | TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT (NFileTimeType::kWindows)
+ , IsArc_Zip)
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipUpdate.cpp b/CPP/7zip/Archive/Zip/ZipUpdate.cpp
new file mode 100644
index 0000000..e6d881c
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipUpdate.cpp
@@ -0,0 +1,2027 @@
+// ZipUpdate.cpp
+
+#include "StdAfx.h"
+
+// #define DEBUG_CACHE
+
+#ifdef DEBUG_CACHE
+#include <stdio.h>
+ #define PRF(x) x
+#else
+ #define PRF(x)
+#endif
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/AutoPtr.h"
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/TimeUtils.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/OutMemStream.h"
+#include "../../Common/ProgressUtils.h"
+#ifndef Z7_ST
+#include "../../Common/ProgressMt.h"
+#endif
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+// #include "../../Compress/ZstdEncoderProps.h"
+
+#include "ZipAddCommon.h"
+#include "ZipOut.h"
+#include "ZipUpdate.h"
+
+using namespace NWindows;
+using namespace NSynchronization;
+
+namespace NArchive {
+namespace NZip {
+
+static const Byte kHostOS =
+ #ifdef _WIN32
+ NFileHeader::NHostOS::kFAT;
+ #else
+ NFileHeader::NHostOS::kUnix;
+ #endif
+
+static const Byte kMadeByHostOS = kHostOS;
+
+// 18.06: now we always write zero to high byte of ExtractVersion field.
+// Previous versions of p7zip wrote (NFileHeader::NHostOS::kUnix) there, that is not correct
+static const Byte kExtractHostOS = 0;
+
+static const Byte kMethodForDirectory = NFileHeader::NCompressionMethod::kStore;
+
+
+static void AddAesExtra(CItem &item, Byte aesKeyMode, UInt16 method)
+{
+ CWzAesExtra wzAesField;
+ wzAesField.Strength = aesKeyMode;
+ wzAesField.Method = method;
+ item.Method = NFileHeader::NCompressionMethod::kWzAES;
+ item.Crc = 0;
+ CExtraSubBlock sb;
+ wzAesField.SetSubBlock(sb);
+ item.LocalExtra.SubBlocks.Add(sb);
+ item.CentralExtra.SubBlocks.Add(sb);
+}
+
+
+static void Copy_From_UpdateItem_To_ItemOut(const CUpdateItem &ui, CItemOut &item)
+{
+ item.Name = ui.Name;
+ item.Name_Utf = ui.Name_Utf;
+ item.Comment = ui.Comment;
+ item.SetUtf8(ui.IsUtf8);
+ // item.SetFlag_AltStream(ui.IsAltStream);
+ // item.ExternalAttrib = ui.Attrib;
+ item.Time = ui.Time;
+ item.Ntfs_MTime = ui.Ntfs_MTime;
+ item.Ntfs_ATime = ui.Ntfs_ATime;
+ item.Ntfs_CTime = ui.Ntfs_CTime;
+
+ item.Write_UnixTime = ui.Write_UnixTime;
+ item.Write_NtfsTime = ui.Write_NtfsTime;
+}
+
+static void SetFileHeader(
+ const CCompressionMethodMode &options,
+ const CUpdateItem &ui,
+ bool useDescriptor,
+ CItemOut &item)
+{
+ item.Size = ui.Size;
+ const bool isDir = ui.IsDir;
+
+ item.ClearFlags();
+
+ if (ui.NewProps)
+ {
+ Copy_From_UpdateItem_To_ItemOut(ui, item);
+ // item.SetFlag_AltStream(ui.IsAltStream);
+ item.ExternalAttrib = ui.Attrib;
+ }
+ /*
+ else
+ isDir = item.IsDir();
+ */
+
+ item.MadeByVersion.HostOS = kMadeByHostOS;
+ item.MadeByVersion.Version = NFileHeader::NCompressionMethod::kMadeByProgramVersion;
+
+ item.ExtractVersion.HostOS = kExtractHostOS;
+
+ item.InternalAttrib = 0; // test it
+ item.SetEncrypted(!isDir && options.Password_Defined);
+ item.SetDescriptorMode(useDescriptor);
+
+ if (isDir)
+ {
+ item.ExtractVersion.Version = NFileHeader::NCompressionMethod::kExtractVersion_Dir;
+ item.Method = kMethodForDirectory;
+ item.PackSize = 0;
+ item.Size = 0;
+ item.Crc = 0;
+ }
+
+ item.LocalExtra.Clear();
+ item.CentralExtra.Clear();
+
+ if (isDir)
+ {
+ item.ExtractVersion.Version = NFileHeader::NCompressionMethod::kExtractVersion_Dir;
+ item.Method = kMethodForDirectory;
+ item.PackSize = 0;
+ item.Size = 0;
+ item.Crc = 0;
+ }
+ else if (options.IsRealAesMode())
+ AddAesExtra(item, options.AesKeyMode, (Byte)(options.MethodSequence.IsEmpty() ? 8 : options.MethodSequence[0]));
+}
+
+
+// we call SetItemInfoFromCompressingResult() after SetFileHeader()
+
+static void SetItemInfoFromCompressingResult(const CCompressingResult &compressingResult,
+ bool isAesMode, Byte aesKeyMode, CItem &item)
+{
+ item.ExtractVersion.Version = compressingResult.ExtractVersion;
+ item.Method = compressingResult.Method;
+ if (compressingResult.Method == NFileHeader::NCompressionMethod::kLZMA && compressingResult.LzmaEos)
+ item.Flags |= NFileHeader::NFlags::kLzmaEOS;
+ item.Crc = compressingResult.CRC;
+ item.Size = compressingResult.UnpackSize;
+ item.PackSize = compressingResult.PackSize;
+
+ item.LocalExtra.Clear();
+ item.CentralExtra.Clear();
+
+ if (isAesMode)
+ AddAesExtra(item, aesKeyMode, compressingResult.Method);
+}
+
+
+#ifndef Z7_ST
+
+struct CMtSem
+{
+ NWindows::NSynchronization::CSemaphore Semaphore;
+ NWindows::NSynchronization::CCriticalSection CS;
+ CIntVector Indexes;
+ int Head;
+
+ void ReleaseItem(unsigned index)
+ {
+ {
+ CCriticalSectionLock lock(CS);
+ Indexes[index] = Head;
+ Head = (int)index;
+ }
+ Semaphore.Release();
+ }
+
+ int GetFreeItem()
+ {
+ int i;
+ {
+ CCriticalSectionLock lock(CS);
+ i = Head;
+ Head = Indexes[(unsigned)i];
+ }
+ return i;
+ }
+};
+
+static THREAD_FUNC_DECL CoderThread(void *threadCoderInfo);
+
+struct CThreadInfo
+{
+ DECL_EXTERNAL_CODECS_LOC_VARS_DECL
+
+ NWindows::CThread Thread;
+ NWindows::NSynchronization::CAutoResetEvent CompressEvent;
+ CMtSem *MtSem;
+ unsigned ThreadIndex;
+
+ bool ExitThread;
+
+ CMtCompressProgress *ProgressSpec;
+ CMyComPtr<ICompressProgressInfo> Progress;
+
+ COutMemStream *OutStreamSpec;
+ CMyComPtr<IOutStream> OutStream;
+ CMyComPtr<ISequentialInStream> InStream;
+
+ CAddCommon Coder;
+ HRESULT Result;
+ CCompressingResult CompressingResult;
+
+ bool IsFree;
+ bool InSeqMode;
+ bool OutSeqMode;
+ bool ExpectedDataSize_IsConfirmed;
+
+ UInt32 UpdateIndex;
+ UInt32 FileTime;
+ UInt64 ExpectedDataSize;
+
+ CThreadInfo():
+ MtSem(NULL),
+ ExitThread(false),
+ ProgressSpec(NULL),
+ OutStreamSpec(NULL),
+ IsFree(true),
+ InSeqMode(false),
+ OutSeqMode(false),
+ ExpectedDataSize_IsConfirmed(false),
+ FileTime(0),
+ ExpectedDataSize((UInt64)(Int64)-1)
+ {}
+
+ void SetOptions(const CCompressionMethodMode &options)
+ {
+ Coder.SetOptions(options);
+ }
+
+ HRESULT CreateEvents()
+ {
+ WRes wres = CompressEvent.CreateIfNotCreated_Reset();
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ HRESULT CreateThread()
+ {
+ WRes wres = Thread.Create(CoderThread, this);
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ void WaitAndCode();
+
+ void StopWait_Close()
+ {
+ ExitThread = true;
+ if (OutStreamSpec)
+ OutStreamSpec->StopWriting(E_ABORT);
+ if (CompressEvent.IsCreated())
+ CompressEvent.Set();
+ Thread.Wait_Close();
+ }
+};
+
+void CThreadInfo::WaitAndCode()
+{
+ for (;;)
+ {
+ CompressEvent.Lock();
+ if (ExitThread)
+ return;
+
+ Result = Coder.Compress(
+ EXTERNAL_CODECS_LOC_VARS
+ InStream, OutStream,
+ InSeqMode, OutSeqMode, FileTime, ExpectedDataSize,
+ ExpectedDataSize_IsConfirmed,
+ Progress, CompressingResult);
+
+ if (Result == S_OK && Progress)
+ Result = Progress->SetRatioInfo(&CompressingResult.UnpackSize, &CompressingResult.PackSize);
+
+ MtSem->ReleaseItem(ThreadIndex);
+ }
+}
+
+static THREAD_FUNC_DECL CoderThread(void *threadCoderInfo)
+{
+ ((CThreadInfo *)threadCoderInfo)->WaitAndCode();
+ return 0;
+}
+
+class CThreads
+{
+public:
+ CObjectVector<CThreadInfo> Threads;
+ ~CThreads()
+ {
+ FOR_VECTOR (i, Threads)
+ Threads[i].StopWait_Close();
+ }
+};
+
+struct CMemBlocks2: public CMemLockBlocks
+{
+ bool Skip;
+ bool InSeqMode;
+ bool PreDescriptorMode;
+ bool Finished;
+ CCompressingResult CompressingResult;
+
+ CMemBlocks2(): Skip(false), InSeqMode(false), PreDescriptorMode(false), Finished(false),
+ CompressingResult() {}
+};
+
+class CMemRefs
+{
+public:
+ CMemBlockManagerMt *Manager;
+ CObjectVector<CMemBlocks2> Refs;
+ CMemRefs(CMemBlockManagerMt *manager): Manager(manager) {}
+ ~CMemRefs()
+ {
+ FOR_VECTOR (i, Refs)
+ Refs[i].FreeOpt(Manager);
+ }
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CMtProgressMixer2
+ , ICompressProgressInfo
+)
+ UInt64 ProgressOffset;
+ UInt64 InSizes[2];
+ UInt64 OutSizes[2];
+ CMyComPtr<IProgress> Progress;
+ CMyComPtr<ICompressProgressInfo> RatioProgress;
+ bool _inSizeIsMain;
+public:
+ NWindows::NSynchronization::CCriticalSection CriticalSection;
+ void Create(IProgress *progress, bool inSizeIsMain);
+ void SetProgressOffset(UInt64 progressOffset);
+ void SetProgressOffset_NoLock(UInt64 progressOffset);
+ HRESULT SetRatioInfo(unsigned index, const UInt64 *inSize, const UInt64 *outSize);
+};
+
+void CMtProgressMixer2::Create(IProgress *progress, bool inSizeIsMain)
+{
+ Progress = progress;
+ Progress.QueryInterface(IID_ICompressProgressInfo, &RatioProgress);
+ _inSizeIsMain = inSizeIsMain;
+ ProgressOffset = InSizes[0] = InSizes[1] = OutSizes[0] = OutSizes[1] = 0;
+}
+
+void CMtProgressMixer2::SetProgressOffset_NoLock(UInt64 progressOffset)
+{
+ InSizes[1] = OutSizes[1] = 0;
+ ProgressOffset = progressOffset;
+}
+
+void CMtProgressMixer2::SetProgressOffset(UInt64 progressOffset)
+{
+ CriticalSection.Enter();
+ SetProgressOffset_NoLock(progressOffset);
+ CriticalSection.Leave();
+}
+
+HRESULT CMtProgressMixer2::SetRatioInfo(unsigned index, const UInt64 *inSize, const UInt64 *outSize)
+{
+ NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+ if (index == 0 && RatioProgress)
+ {
+ RINOK(RatioProgress->SetRatioInfo(inSize, outSize))
+ }
+ if (inSize)
+ InSizes[index] = *inSize;
+ if (outSize)
+ OutSizes[index] = *outSize;
+ UInt64 v = ProgressOffset + (_inSizeIsMain ?
+ (InSizes[0] + InSizes[1]) :
+ (OutSizes[0] + OutSizes[1]));
+ return Progress->SetCompleted(&v);
+}
+
+Z7_COM7F_IMF(CMtProgressMixer2::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ return SetRatioInfo(0, inSize, outSize);
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CMtProgressMixer
+ , ICompressProgressInfo
+)
+public:
+ CMtProgressMixer2 *Mixer2;
+ CMyComPtr<ICompressProgressInfo> RatioProgress;
+ void Create(IProgress *progress, bool inSizeIsMain);
+};
+
+void CMtProgressMixer::Create(IProgress *progress, bool inSizeIsMain)
+{
+ Mixer2 = new CMtProgressMixer2;
+ RatioProgress = Mixer2;
+ Mixer2->Create(progress, inSizeIsMain);
+}
+
+Z7_COM7F_IMF(CMtProgressMixer::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ return Mixer2->SetRatioInfo(1, inSize, outSize);
+}
+
+
+#endif
+
+static HRESULT UpdateItemOldData(
+ COutArchive &archive,
+ CInArchive *inArchive,
+ const CItemEx &itemEx,
+ const CUpdateItem &ui,
+ CItemOut &item,
+ /* bool izZip64, */
+ ICompressProgressInfo *progress,
+ IArchiveUpdateCallbackFile *opCallback,
+ UInt64 &complexity)
+{
+ if (opCallback)
+ {
+ RINOK(opCallback->ReportOperation(
+ NEventIndexType::kInArcIndex, (UInt32)ui.IndexInArc,
+ NUpdateNotifyOp::kReplicate))
+ }
+
+ UInt64 rangeSize;
+
+ RINOK(archive.ClearRestriction())
+
+ if (ui.NewProps)
+ {
+ if (item.HasDescriptor())
+ return E_NOTIMPL;
+
+ // we keep ExternalAttrib and some another properties from old archive
+ // item.ExternalAttrib = ui.Attrib;
+ // if we don't change Comment, we keep Comment from OldProperties
+ Copy_From_UpdateItem_To_ItemOut(ui, item);
+ // item.SetFlag_AltStream(ui.IsAltStream);
+
+ item.CentralExtra.RemoveUnknownSubBlocks();
+ item.LocalExtra.RemoveUnknownSubBlocks();
+
+ archive.WriteLocalHeader(item);
+ rangeSize = item.GetPackSizeWithDescriptor();
+ }
+ else
+ {
+ item.LocalHeaderPos = archive.GetCurPos();
+ rangeSize = itemEx.GetLocalFullSize();
+ }
+
+ CMyComPtr<ISequentialInStream> packStream;
+
+ RINOK(inArchive->GetItemStream(itemEx, ui.NewProps, packStream))
+ if (!packStream)
+ return E_NOTIMPL;
+
+ complexity += rangeSize;
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ archive.CreateStreamForCopying(outStream);
+ HRESULT res = NCompress::CopyStream_ExactSize(packStream, outStream, rangeSize, progress);
+ archive.MoveCurPos(rangeSize);
+ return res;
+}
+
+
+static HRESULT WriteDirHeader(COutArchive &archive, const CCompressionMethodMode *options,
+ const CUpdateItem &ui, CItemOut &item)
+{
+ SetFileHeader(*options, ui, false, item);
+ RINOK(archive.ClearRestriction())
+ archive.WriteLocalHeader(item);
+ return S_OK;
+}
+
+
+static void UpdatePropsFromStream(
+ const CUpdateOptions &options,
+ CUpdateItem &item, ISequentialInStream *fileInStream,
+ IArchiveUpdateCallback *updateCallback, UInt64 &totalComplexity)
+{
+ CMyComPtr<IStreamGetProps> getProps;
+ fileInStream->QueryInterface(IID_IStreamGetProps, (void **)&getProps);
+ UInt64 size = (UInt64)(Int64)-1;
+ bool size_WasSet = false;
+
+ if (getProps)
+ {
+ FILETIME cTime, aTime, mTime;
+ UInt32 attrib;
+ if (getProps->GetProps(&size, &cTime, &aTime, &mTime, &attrib) == S_OK)
+ {
+ if (options.Write_MTime)
+ if (!FILETIME_IsZero(mTime))
+ {
+ item.Ntfs_MTime = mTime;
+ NTime::UtcFileTime_To_LocalDosTime(mTime, item.Time);
+ }
+
+ if (options.Write_CTime) if (!FILETIME_IsZero(cTime)) item.Ntfs_CTime = cTime;
+ if (options.Write_ATime) if (!FILETIME_IsZero(aTime)) item.Ntfs_ATime = aTime;
+
+ item.Attrib = attrib;
+ size_WasSet = true;
+ }
+ }
+
+ if (!size_WasSet)
+ {
+ CMyComPtr<IStreamGetSize> streamGetSize;
+ fileInStream->QueryInterface(IID_IStreamGetSize, (void **)&streamGetSize);
+ if (streamGetSize)
+ {
+ if (streamGetSize->GetSize(&size) == S_OK)
+ size_WasSet = true;
+ }
+ }
+
+ if (size_WasSet && size != (UInt64)(Int64)-1)
+ {
+ item.Size_WasSetFromStream = true;
+ if (size != item.Size)
+ {
+ const Int64 newComplexity = (Int64)totalComplexity + ((Int64)size - (Int64)item.Size);
+ if (newComplexity > 0)
+ {
+ totalComplexity = (UInt64)newComplexity;
+ updateCallback->SetTotal(totalComplexity);
+ }
+ item.Size = size;
+ }
+ }
+}
+
+
+/*
+static HRESULT ReportProps(
+ IArchiveUpdateCallbackArcProp *reportArcProp,
+ UInt32 index,
+ const CItemOut &item,
+ bool isAesMode)
+{
+ PROPVARIANT prop;
+ prop.vt = VT_EMPTY;
+ prop.wReserved1 = 0;
+
+ NCOM::PropVarEm_Set_UInt64(&prop, item.Size);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidSize, &prop));
+
+ NCOM::PropVarEm_Set_UInt64(&prop, item.PackSize);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidPackSize, &prop));
+
+ if (!isAesMode)
+ {
+ NCOM::PropVarEm_Set_UInt32(&prop, item.Crc);
+ RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidCRC, &prop));
+ }
+
+ RINOK(reportArcProp->ReportFinished(NEventIndexType::kOutArcIndex, index, NUpdate::NOperationResult::kOK));
+
+ // if (opCallback) RINOK(opCallback->ReportOperation(NEventIndexType::kOutArcIndex, index, NUpdateNotifyOp::kOpFinished))
+
+ return S_OK;
+}
+*/
+
+/*
+struct CTotalStats
+{
+ UInt64 Size;
+ UInt64 PackSize;
+
+ void UpdateWithItem(const CItemOut &item)
+ {
+ Size += item.Size;
+ PackSize += item.PackSize;
+ }
+};
+
+static HRESULT ReportArcProps(IArchiveUpdateCallbackArcProp *reportArcProp,
+ CTotalStats &st)
+{
+ PROPVARIANT prop;
+ prop.vt = VT_EMPTY;
+ prop.wReserved1 = 0;
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt64(&prop, st.Size);
+ RINOK(reportArcProp->ReportProp(
+ NEventIndexType::kArcProp, 0, kpidSize, &prop));
+ }
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt64(&prop, st.PackSize);
+ RINOK(reportArcProp->ReportProp(
+ NEventIndexType::kArcProp, 0, kpidPackSize, &prop));
+ }
+ return S_OK;
+}
+*/
+
+
+static HRESULT Update2St(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ COutArchive &archive,
+ CInArchive *inArchive,
+ const CObjectVector<CItemEx> &inputItems,
+ CObjectVector<CUpdateItem> &updateItems,
+ const CUpdateOptions &updateOptions,
+ const CCompressionMethodMode *options, bool outSeqMode,
+ const CByteBuffer *comment,
+ IArchiveUpdateCallback *updateCallback,
+ UInt64 &totalComplexity,
+ IArchiveUpdateCallbackFile *opCallback
+ // , IArchiveUpdateCallbackArcProp *reportArcProp
+ )
+{
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(updateCallback, true);
+
+ CAddCommon compressor;
+ compressor.SetOptions(*options);
+
+ CObjectVector<CItemOut> items;
+ UInt64 unpackSizeTotal = 0, packSizeTotal = 0;
+
+ FOR_VECTOR (itemIndex, updateItems)
+ {
+ lps->InSize = unpackSizeTotal;
+ lps->OutSize = packSizeTotal;
+ RINOK(lps->SetCur())
+ CUpdateItem &ui = updateItems[itemIndex];
+ CItemEx itemEx;
+ CItemOut item;
+
+ if (!ui.NewProps || !ui.NewData)
+ {
+ // Note: for (ui.NewProps && !ui.NewData) it copies Props from old archive,
+ // But we will rewrite all important properties later. But we can keep some properties like Comment
+ itemEx = inputItems[(unsigned)ui.IndexInArc];
+ if (inArchive->Read_LocalItem_After_CdItem_Full(itemEx) != S_OK)
+ return E_NOTIMPL;
+ (CItem &)item = itemEx;
+ }
+
+ if (ui.NewData)
+ {
+ // bool isDir = ((ui.NewProps) ? ui.IsDir : item.IsDir());
+ bool isDir = ui.IsDir;
+ if (isDir)
+ {
+ RINOK(WriteDirHeader(archive, options, ui, item))
+ }
+ else
+ {
+ CMyComPtr<ISequentialInStream> fileInStream;
+ {
+ HRESULT res = updateCallback->GetStream(ui.IndexInClient, &fileInStream);
+ if (res == S_FALSE)
+ {
+ lps->ProgressOffset += ui.Size;
+ RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ continue;
+ }
+ RINOK(res)
+ if (!fileInStream)
+ return E_INVALIDARG;
+
+ bool inSeqMode = false;
+ if (!inSeqMode)
+ {
+ CMyComPtr<IInStream> inStream2;
+ fileInStream->QueryInterface(IID_IInStream, (void **)&inStream2);
+ inSeqMode = (inStream2 == NULL);
+ }
+ // seqMode = true; // to test seqMode
+
+ UpdatePropsFromStream(updateOptions, ui, fileInStream, updateCallback, totalComplexity);
+
+ CCompressingResult compressingResult;
+
+ RINOK(compressor.Set_Pre_CompressionResult(
+ inSeqMode, outSeqMode,
+ ui.Size,
+ compressingResult))
+
+ SetFileHeader(*options, ui, compressingResult.DescriptorMode, item);
+
+ // file Size can be 64-bit !!!
+
+ SetItemInfoFromCompressingResult(compressingResult, options->IsRealAesMode(), options->AesKeyMode, item);
+
+ RINOK(archive.SetRestrictionFromCurrent())
+ archive.WriteLocalHeader(item);
+
+ CMyComPtr<IOutStream> outStream;
+ archive.CreateStreamForCompressing(outStream);
+
+ RINOK(compressor.Compress(
+ EXTERNAL_CODECS_LOC_VARS
+ fileInStream, outStream,
+ inSeqMode, outSeqMode,
+ ui.Time,
+ ui.Size, ui.Size_WasSetFromStream,
+ progress, compressingResult))
+
+ if (item.HasDescriptor() != compressingResult.DescriptorMode)
+ return E_FAIL;
+
+ SetItemInfoFromCompressingResult(compressingResult, options->IsRealAesMode(), options->AesKeyMode, item);
+
+ archive.WriteLocalHeader_Replace(item);
+ }
+ // if (reportArcProp) RINOK(ReportProps(reportArcProp, ui.IndexInClient, item, options->IsRealAesMode()))
+ RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ unpackSizeTotal += item.Size;
+ packSizeTotal += item.PackSize;
+ }
+ }
+ else
+ {
+ UInt64 complexity = 0;
+ lps->SendRatio = false;
+
+ RINOK(UpdateItemOldData(archive, inArchive, itemEx, ui, item, progress, opCallback, complexity))
+
+ lps->SendRatio = true;
+ lps->ProgressOffset += complexity;
+ }
+
+ items.Add(item);
+ lps->ProgressOffset += kLocalHeaderSize;
+ }
+
+ lps->InSize = unpackSizeTotal;
+ lps->OutSize = packSizeTotal;
+ RINOK(lps->SetCur())
+
+ RINOK(archive.WriteCentralDir(items, comment))
+
+ /*
+ CTotalStats stat;
+ stat.Size = unpackSizeTotal;
+ stat.PackSize = packSizeTotal;
+ if (reportArcProp)
+ RINOK(ReportArcProps(reportArcProp, stat))
+ */
+
+ lps->ProgressOffset += kCentralHeaderSize * updateItems.Size() + 1;
+ return lps->SetCur();
+}
+
+#ifndef Z7_ST
+
+
+static const size_t kBlockSize = 1 << 16;
+// kMemPerThread must be >= kBlockSize
+//
+static const size_t kMemPerThread = (size_t)sizeof(size_t) << 23;
+// static const size_t kMemPerThread = (size_t)sizeof(size_t) << 16; // for debug
+// static const size_t kMemPerThread = (size_t)1 << 16; // for debug
+
+/*
+in:
+ nt_Zip >= 1: the starting maximum number of ZIP threads for search
+out:
+ nt_Zip: calculated number of ZIP threads
+ returns: calculated number of ZSTD threads
+*/
+/*
+static UInt32 CalcThreads_for_ZipZstd(CZstdEncProps *zstdProps,
+ UInt64 memLimit, UInt32 totalThreads,
+ UInt32 &nt_Zip)
+{
+ for (; nt_Zip > 1; nt_Zip--)
+ {
+ UInt64 mem1 = memLimit / nt_Zip;
+ if (mem1 <= kMemPerThread)
+ continue;
+ mem1 -= kMemPerThread;
+ UInt32 n_ZSTD = ZstdEncProps_GetNumThreads_for_MemUsageLimit(
+ zstdProps, mem1, totalThreads / nt_Zip);
+ // we don't allow (nbWorkers == 1) here
+ if (n_ZSTD <= 1)
+ n_ZSTD = 0;
+ zstdProps->nbWorkers = n_ZSTD;
+ mem1 = ZstdEncProps_GetMemUsage(zstdProps);
+ if ((mem1 + kMemPerThread) * nt_Zip <= memLimit)
+ return n_ZSTD;
+ }
+ return ZstdEncProps_GetNumThreads_for_MemUsageLimit(
+ zstdProps, memLimit, totalThreads);
+}
+
+
+static UInt32 SetZstdThreads(
+ const CCompressionMethodMode &options,
+ COneMethodInfo *oneMethodMain,
+ UInt32 numThreads,
+ UInt32 numZipThreads_limit,
+ UInt64 numFilesToCompress,
+ UInt64 numBytesToCompress)
+{
+ NCompress::NZstd::CEncoderProps encoderProps;
+ RINOK(encoderProps.SetFromMethodProps(*oneMethodMain));
+ CZstdEncProps &zstdProps = encoderProps.EncProps;
+ ZstdEncProps_NormalizeFull(&zstdProps);
+ if (oneMethodMain->FindProp(NCoderPropID::kNumThreads) >= 0)
+ {
+ // threads for ZSTD are fixed
+ if (zstdProps.nbWorkers > 1)
+ numThreads /= zstdProps.nbWorkers;
+ if (numThreads > numZipThreads_limit)
+ numThreads = numZipThreads_limit;
+ if (options._memUsage_WasSet
+ && !options._numThreads_WasForced)
+ {
+ const UInt64 mem1 = ZstdEncProps_GetMemUsage(&zstdProps);
+ const UInt64 numZipThreads = options._memUsage_Compress / (mem1 + kMemPerThread);
+ if (numThreads > numZipThreads)
+ numThreads = (UInt32)numZipThreads;
+ }
+ return numThreads;
+ }
+ {
+ // threads for ZSTD are not fixed
+
+ // calculate estimated required number of ZST threads per file size statistics
+ UInt32 t = MY_ZSTDMT_NBWORKERS_MAX;
+ {
+ UInt64 averageNumberOfBlocks = 0;
+ const UInt64 averageSize = numBytesToCompress / numFilesToCompress;
+ const UInt64 jobSize = zstdProps.jobSize;
+ if (jobSize != 0)
+ averageNumberOfBlocks = averageSize / jobSize + 0;
+ if (t > averageNumberOfBlocks)
+ t = (UInt32)averageNumberOfBlocks;
+ }
+ if (t > numThreads)
+ t = numThreads;
+
+ // calculate the nuber of zip threads
+ UInt32 numZipThreads = numThreads;
+ if (t > 1)
+ numZipThreads = numThreads / t;
+ if (numZipThreads > numZipThreads_limit)
+ numZipThreads = numZipThreads_limit;
+ if (numZipThreads < 1)
+ numZipThreads = 1;
+ {
+ // recalculate the number of ZSTD threads via the number of ZIP threads
+ const UInt32 t2 = numThreads / numZipThreads;
+ if (t < t2)
+ t = t2;
+ }
+
+ if (options._memUsage_WasSet
+ && !options._numThreads_WasForced)
+ {
+ t = CalcThreads_for_ZipZstd(&zstdProps,
+ options._memUsage_Compress, numThreads, numZipThreads);
+ numThreads = numZipThreads;
+ }
+ // we don't use (nbWorkers = 1) here
+ if (t <= 1)
+ t = 0;
+ oneMethodMain->AddProp_NumThreads(t);
+ return numThreads;
+ }
+}
+*/
+
+#endif
+
+
+
+
+static HRESULT Update2(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ COutArchive &archive,
+ CInArchive *inArchive,
+ const CObjectVector<CItemEx> &inputItems,
+ CObjectVector<CUpdateItem> &updateItems,
+ const CUpdateOptions &updateOptions,
+ const CCompressionMethodMode &options, bool outSeqMode,
+ const CByteBuffer *comment,
+ IArchiveUpdateCallback *updateCallback)
+{
+ CMyComPtr<IArchiveUpdateCallbackFile> opCallback;
+ updateCallback->QueryInterface(IID_IArchiveUpdateCallbackFile, (void **)&opCallback);
+
+ /*
+ CMyComPtr<IArchiveUpdateCallbackArcProp> reportArcProp;
+ updateCallback->QueryInterface(IID_IArchiveUpdateCallbackArcProp, (void **)&reportArcProp);
+ */
+
+ bool unknownComplexity = false;
+ UInt64 complexity = 0;
+ #ifndef Z7_ST
+ UInt64 numFilesToCompress = 0;
+ UInt64 numBytesToCompress = 0;
+ #endif
+
+ unsigned i;
+
+ for (i = 0; i < updateItems.Size(); i++)
+ {
+ const CUpdateItem &ui = updateItems[i];
+ if (ui.NewData)
+ {
+ if (ui.Size == (UInt64)(Int64)-1)
+ unknownComplexity = true;
+ else
+ complexity += ui.Size;
+ #ifndef Z7_ST
+ numBytesToCompress += ui.Size;
+ numFilesToCompress++;
+ #endif
+ /*
+ if (ui.Commented)
+ complexity += ui.CommentRange.Size;
+ */
+ }
+ else
+ {
+ CItemEx inputItem = inputItems[(unsigned)ui.IndexInArc];
+ if (inArchive->Read_LocalItem_After_CdItem_Full(inputItem) != S_OK)
+ return E_NOTIMPL;
+ complexity += inputItem.GetLocalFullSize();
+ // complexity += inputItem.GetCentralExtraPlusCommentSize();
+ }
+ complexity += kLocalHeaderSize;
+ complexity += kCentralHeaderSize;
+ }
+
+ if (comment)
+ complexity += comment->Size();
+ complexity++; // end of central
+
+ if (!unknownComplexity)
+ updateCallback->SetTotal(complexity);
+
+ UInt64 totalComplexity = complexity;
+
+ CCompressionMethodMode options2 = options;
+
+ if (options2._methods.IsEmpty())
+ {
+ // we need method item, if default method was used
+ options2._methods.AddNew();
+ }
+
+ CAddCommon compressor;
+ compressor.SetOptions(options2);
+
+ complexity = 0;
+
+ const Byte method = options.MethodSequence.Front();
+
+ COneMethodInfo *oneMethodMain = NULL;
+ if (!options2._methods.IsEmpty())
+ oneMethodMain = &options2._methods[0];
+
+ {
+ FOR_VECTOR (mi, options2._methods)
+ {
+ options2.SetGlobalLevelTo(options2._methods[mi]);
+ }
+ }
+
+ if (oneMethodMain)
+ {
+ // appnote recommends to use EOS marker for LZMA.
+ if (method == NFileHeader::NCompressionMethod::kLZMA)
+ oneMethodMain->AddProp_EndMarker_if_NotFound(true);
+ }
+
+
+ #ifndef Z7_ST
+
+ UInt32 numThreads = options._numThreads;
+
+ UInt32 numZipThreads_limit = numThreads;
+ if (numZipThreads_limit > numFilesToCompress)
+ numZipThreads_limit = (UInt32)numFilesToCompress;
+
+ if (numZipThreads_limit > 1)
+ {
+ const unsigned numFiles_OPEN_MAX = NSystem::Get_File_OPEN_MAX_Reduced_for_3_tasks();
+ // printf("\nzip:numFiles_OPEN_MAX =%d\n", (unsigned)numFiles_OPEN_MAX);
+ if (numZipThreads_limit > numFiles_OPEN_MAX)
+ numZipThreads_limit = (UInt32)numFiles_OPEN_MAX;
+ }
+
+ {
+ const UInt32 kNumMaxThreads =
+ #ifdef _WIN32
+ 64; // _WIN32 supports only 64 threads in one group. So no need for more threads here
+ #else
+ 128;
+ #endif
+ if (numThreads > kNumMaxThreads)
+ numThreads = kNumMaxThreads;
+ }
+ /*
+ if (numThreads > MAXIMUM_WAIT_OBJECTS) // is 64 in Windows
+ numThreads = MAXIMUM_WAIT_OBJECTS;
+ */
+
+
+ /*
+ // zstd supports (numThreads == 0);
+ if (numThreads < 1)
+ numThreads = 1;
+ */
+
+ bool mtMode = (numThreads > 1);
+
+ if (numFilesToCompress <= 1)
+ mtMode = false;
+
+ // mtMode = true; // debug: to test mtMode
+
+ if (!mtMode)
+ {
+ // if (oneMethodMain) {
+ /*
+ if (method == NFileHeader::NCompressionMethod::kZstdWz)
+ {
+ if (oneMethodMain->FindProp(NCoderPropID::kNumThreads) < 0)
+ {
+ // numZstdThreads was not forced in oneMethodMain
+ if (numThreads >= 1
+ && options._memUsage_WasSet
+ && !options._numThreads_WasForced)
+ {
+ NCompress::NZstd::CEncoderProps encoderProps;
+ RINOK(encoderProps.SetFromMethodProps(*oneMethodMain))
+ CZstdEncProps &zstdProps = encoderProps.EncProps;
+ ZstdEncProps_NormalizeFull(&zstdProps);
+ numThreads = ZstdEncProps_GetNumThreads_for_MemUsageLimit(
+ &zstdProps, options._memUsage_Compress, numThreads);
+ // we allow (nbWorkers = 1) here.
+ }
+ oneMethodMain->AddProp_NumThreads(numThreads);
+ }
+ } // kZstdWz
+ */
+ // } // oneMethodMain
+
+ FOR_VECTOR (mi, options2._methods)
+ {
+ COneMethodInfo &onem = options2._methods[mi];
+
+ if (onem.FindProp(NCoderPropID::kNumThreads) < 0)
+ {
+ // fixme: we should check the number of threads for xz method also
+ // fixed for 9.31. bzip2 default is just one thread.
+ onem.AddProp_NumThreads(numThreads);
+ }
+ }
+ }
+ else // mtMode
+ {
+ if (method == NFileHeader::NCompressionMethod::kStore && !options.Password_Defined)
+ numThreads = 1;
+
+ if (oneMethodMain)
+ {
+
+ if (method == NFileHeader::NCompressionMethod::kBZip2)
+ {
+ bool fixedNumber;
+ UInt32 numBZip2Threads = oneMethodMain->Get_BZip2_NumThreads(fixedNumber);
+ if (!fixedNumber)
+ {
+ const UInt64 averageSize = numBytesToCompress / numFilesToCompress;
+ const UInt32 blockSize = oneMethodMain->Get_BZip2_BlockSize();
+ const UInt64 averageNumberOfBlocks = averageSize / blockSize + 1;
+ numBZip2Threads = 64;
+ if (numBZip2Threads > averageNumberOfBlocks)
+ numBZip2Threads = (UInt32)averageNumberOfBlocks;
+ if (numBZip2Threads > numThreads)
+ numBZip2Threads = numThreads;
+ oneMethodMain->AddProp_NumThreads(numBZip2Threads);
+ }
+ numThreads /= numBZip2Threads;
+ }
+ else if (method == NFileHeader::NCompressionMethod::kXz)
+ {
+ UInt32 numLzmaThreads = 1;
+ int numXzThreads = oneMethodMain->Get_Xz_NumThreads(numLzmaThreads);
+ if (numXzThreads < 0)
+ {
+ // numXzThreads is unknown
+ const UInt64 averageSize = numBytesToCompress / numFilesToCompress;
+ const UInt64 blockSize = oneMethodMain->Get_Xz_BlockSize();
+ UInt64 averageNumberOfBlocks = 1;
+ if (blockSize != (UInt64)(Int64)-1)
+ averageNumberOfBlocks = averageSize / blockSize + 1;
+ UInt32 t = 256;
+ if (t > averageNumberOfBlocks)
+ t = (UInt32)averageNumberOfBlocks;
+ t *= numLzmaThreads;
+ if (t > numThreads)
+ t = numThreads;
+ oneMethodMain->AddProp_NumThreads(t);
+ numXzThreads = (int)t;
+ }
+ numThreads /= (unsigned)numXzThreads;
+ }
+ /*
+ else if (method == NFileHeader::NCompressionMethod::kZstdWz)
+ {
+ numThreads = SetZstdThreads(options,
+ oneMethodMain, numThreads,
+ numZipThreads_limit,
+ numFilesToCompress, numBytesToCompress);
+ }
+ */
+ else if (
+ method == NFileHeader::NCompressionMethod::kDeflate
+ || method == NFileHeader::NCompressionMethod::kDeflate64
+ || method == NFileHeader::NCompressionMethod::kPPMd)
+ {
+ if (numThreads > 1
+ && options._memUsage_WasSet
+ && !options._numThreads_WasForced)
+ {
+ UInt64 methodMemUsage;
+ if (method == NFileHeader::NCompressionMethod::kPPMd)
+ methodMemUsage = oneMethodMain->Get_Ppmd_MemSize();
+ else
+ methodMemUsage = (4 << 20); // for deflate
+ const UInt64 threadMemUsage = kMemPerThread + methodMemUsage;
+ const UInt64 numThreads64 = options._memUsage_Compress / threadMemUsage;
+ if (numThreads64 < numThreads)
+ numThreads = (UInt32)numThreads64;
+ }
+ }
+ else if (method == NFileHeader::NCompressionMethod::kLZMA)
+ {
+ // we suppose that default LZMA is 2 thread. So we don't change it
+ const UInt32 numLZMAThreads = oneMethodMain->Get_Lzma_NumThreads();
+ numThreads /= numLZMAThreads;
+
+ if (numThreads > 1
+ && options._memUsage_WasSet
+ && !options._numThreads_WasForced)
+ {
+ const UInt64 methodMemUsage = oneMethodMain->Get_Lzma_MemUsage(true);
+ const UInt64 threadMemUsage = kMemPerThread + methodMemUsage;
+ const UInt64 numThreads64 = options._memUsage_Compress / threadMemUsage;
+ if (numThreads64 < numThreads)
+ numThreads = (UInt32)numThreads64;
+ }
+ }
+ } // (oneMethodMain)
+
+ if (numThreads > numZipThreads_limit)
+ numThreads = numZipThreads_limit;
+ if (numThreads <= 1)
+ {
+ mtMode = false;
+ numThreads = 1;
+ }
+ }
+
+ // mtMode = true; // to test mtMode for seqMode
+
+ if (!mtMode)
+ #endif
+ return Update2St(
+ EXTERNAL_CODECS_LOC_VARS
+ archive, inArchive,
+ inputItems, updateItems,
+ updateOptions,
+ &options2, outSeqMode,
+ comment, updateCallback, totalComplexity,
+ opCallback
+ // , reportArcProp
+ );
+
+
+ #ifndef Z7_ST
+
+ /*
+ CTotalStats stat;
+ stat.Size = 0;
+ stat.PackSize = 0;
+ */
+ if (numThreads < 1)
+ numThreads = 1;
+
+ CObjectVector<CItemOut> items;
+
+ CMtProgressMixer *mtProgressMixerSpec = new CMtProgressMixer;
+ CMyComPtr<ICompressProgressInfo> progress = mtProgressMixerSpec;
+ mtProgressMixerSpec->Create(updateCallback, true);
+
+ CMtCompressProgressMixer mtCompressProgressMixer;
+ mtCompressProgressMixer.Init(numThreads, mtProgressMixerSpec->RatioProgress);
+
+ CMemBlockManagerMt memManager(kBlockSize);
+ CMemRefs refs(&memManager);
+
+ CMtSem mtSem;
+ CThreads threads;
+ mtSem.Head = -1;
+ mtSem.Indexes.ClearAndSetSize(numThreads);
+ {
+ WRes wres = mtSem.Semaphore.Create(0, numThreads);
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ CUIntVector threadIndices; // list threads in order of updateItems
+
+ {
+ RINOK(memManager.AllocateSpaceAlways((size_t)numThreads * (kMemPerThread / kBlockSize)))
+ for (i = 0; i < updateItems.Size(); i++)
+ refs.Refs.Add(CMemBlocks2());
+
+ for (i = 0; i < numThreads; i++)
+ {
+ threads.Threads.AddNew();
+ // mtSem.Indexes[i] = -1; // actually we don't use these values
+ }
+
+ for (i = 0; i < numThreads; i++)
+ {
+ CThreadInfo &threadInfo = threads.Threads[i];
+ threadInfo.ThreadIndex = i;
+ threadInfo.SetOptions(options2);
+ #ifdef Z7_EXTERNAL_CODECS
+ threadInfo._externalCodecs = _externalCodecs;
+ #endif
+ RINOK(threadInfo.CreateEvents())
+ threadInfo.OutStreamSpec = new COutMemStream(&memManager);
+ RINOK(threadInfo.OutStreamSpec->CreateEvents(SYNC_WFMO(&memManager.Synchro)))
+ threadInfo.OutStream = threadInfo.OutStreamSpec;
+ threadInfo.ProgressSpec = new CMtCompressProgress();
+ threadInfo.Progress = threadInfo.ProgressSpec;
+ threadInfo.ProgressSpec->Init(&mtCompressProgressMixer, i);
+ threadInfo.MtSem = &mtSem;
+ RINOK(threadInfo.CreateThread())
+ }
+ }
+
+ unsigned mtItemIndex = 0;
+ unsigned itemIndex = 0;
+ int lastRealStreamItemIndex = -1;
+
+
+ while (itemIndex < updateItems.Size())
+ {
+ if (threadIndices.Size() < numThreads && mtItemIndex < updateItems.Size())
+ {
+ // we start ahead the threads for compressing
+ // also we set refs.Refs[itemIndex].SeqMode that is used later
+ // don't move that code block
+
+ CUpdateItem &ui = updateItems[mtItemIndex++];
+ if (!ui.NewData)
+ continue;
+ CItemEx itemEx;
+ CItemOut item;
+
+ if (ui.NewProps)
+ {
+ if (ui.IsDir)
+ continue;
+ }
+ else
+ {
+ itemEx = inputItems[(unsigned)ui.IndexInArc];
+ if (inArchive->Read_LocalItem_After_CdItem_Full(itemEx) != S_OK)
+ return E_NOTIMPL;
+ (CItem &)item = itemEx;
+ if (item.IsDir() != ui.IsDir)
+ return E_NOTIMPL;
+ if (ui.IsDir)
+ continue;
+ }
+
+ CMyComPtr<ISequentialInStream> fileInStream;
+
+ CMemBlocks2 &memRef2 = refs.Refs[mtItemIndex - 1];
+
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(mtProgressMixerSpec->Mixer2->CriticalSection);
+ HRESULT res = updateCallback->GetStream(ui.IndexInClient, &fileInStream);
+ if (res == S_FALSE)
+ {
+ complexity += ui.Size;
+ complexity += kLocalHeaderSize;
+ mtProgressMixerSpec->Mixer2->SetProgressOffset_NoLock(complexity);
+ RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ memRef2.Skip = true;
+ continue;
+ }
+ RINOK(res)
+ if (!fileInStream)
+ return E_INVALIDARG;
+ UpdatePropsFromStream(updateOptions, ui, fileInStream, updateCallback, totalComplexity);
+ RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ }
+
+ UInt32 k;
+ for (k = 0; k < numThreads; k++)
+ if (threads.Threads[k].IsFree)
+ break;
+
+ if (k == numThreads)
+ return E_FAIL;
+ {
+ {
+ CThreadInfo &threadInfo = threads.Threads[k];
+ threadInfo.IsFree = false;
+ threadInfo.InStream = fileInStream;
+
+ bool inSeqMode = false;
+
+ if (!inSeqMode)
+ {
+ CMyComPtr<IInStream> inStream2;
+ fileInStream->QueryInterface(IID_IInStream, (void **)&inStream2);
+ inSeqMode = (inStream2 == NULL);
+ }
+ memRef2.InSeqMode = inSeqMode;
+
+ // !!!!! we must release ref before sending event
+ // BUG was here in v4.43 and v4.44. It could change ref counter in two threads in same time
+ fileInStream.Release();
+
+ threadInfo.OutStreamSpec->Init();
+ threadInfo.ProgressSpec->Reinit();
+
+ threadInfo.UpdateIndex = mtItemIndex - 1;
+ threadInfo.InSeqMode = inSeqMode;
+ threadInfo.OutSeqMode = outSeqMode;
+ threadInfo.FileTime = ui.Time; // FileTime is used for ZipCrypto only in seqMode
+ threadInfo.ExpectedDataSize = ui.Size;
+ threadInfo.ExpectedDataSize_IsConfirmed = ui.Size_WasSetFromStream;
+
+ threadInfo.CompressEvent.Set();
+
+ threadIndices.Add(k);
+ }
+ }
+
+ continue;
+ }
+
+ if (refs.Refs[itemIndex].Skip)
+ {
+ itemIndex++;
+ continue;
+ }
+
+ const CUpdateItem &ui = updateItems[itemIndex];
+
+ CItemEx itemEx;
+ CItemOut item;
+
+ if (!ui.NewProps || !ui.NewData)
+ {
+ itemEx = inputItems[(unsigned)ui.IndexInArc];
+ if (inArchive->Read_LocalItem_After_CdItem_Full(itemEx) != S_OK)
+ return E_NOTIMPL;
+ (CItem &)item = itemEx;
+ }
+
+ if (ui.NewData)
+ {
+ // bool isDir = ((ui.NewProps) ? ui.IsDir : item.IsDir());
+ bool isDir = ui.IsDir;
+
+ if (isDir)
+ {
+ RINOK(WriteDirHeader(archive, &options, ui, item))
+ }
+ else
+ {
+ CMemBlocks2 &memRef = refs.Refs[itemIndex];
+
+ if (memRef.Finished)
+ {
+ if (lastRealStreamItemIndex < (int)itemIndex)
+ lastRealStreamItemIndex = (int)itemIndex;
+
+ SetFileHeader(options, ui, memRef.CompressingResult.DescriptorMode, item);
+
+ // the BUG was fixed in 9.26:
+ // SetItemInfoFromCompressingResult must be after SetFileHeader
+ // to write correct Size.
+
+ SetItemInfoFromCompressingResult(memRef.CompressingResult,
+ options.IsRealAesMode(), options.AesKeyMode, item);
+ RINOK(archive.ClearRestriction())
+ archive.WriteLocalHeader(item);
+ // RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
+ CMyComPtr<ISequentialOutStream> outStream;
+ archive.CreateStreamForCopying(outStream);
+ memRef.WriteToStream(memManager.GetBlockSize(), outStream);
+ // v23: we fixed the bug: we need to write descriptor also
+ if (item.HasDescriptor())
+ {
+ /* that function doesn't rewrite local header, if item.HasDescriptor().
+ it just writes descriptor */
+ archive.WriteLocalHeader_Replace(item);
+ }
+ else
+ archive.MoveCurPos(item.PackSize);
+ memRef.FreeOpt(&memManager);
+ /*
+ if (reportArcProp)
+ {
+ stat.UpdateWithItem(item);
+ RINOK(ReportProps(reportArcProp, ui.IndexInClient, item, options.IsRealAesMode()));
+ }
+ */
+ }
+ else
+ {
+ // current file was not finished
+
+ if (lastRealStreamItemIndex < (int)itemIndex)
+ {
+ // LocalHeader was not written for current itemIndex still
+
+ lastRealStreamItemIndex = (int)itemIndex;
+
+ // thread was started before for that item already, and memRef.SeqMode was set
+
+ CCompressingResult compressingResult;
+ RINOK(compressor.Set_Pre_CompressionResult(
+ memRef.InSeqMode, outSeqMode,
+ ui.Size,
+ compressingResult))
+
+ memRef.PreDescriptorMode = compressingResult.DescriptorMode;
+ SetFileHeader(options, ui, compressingResult.DescriptorMode, item);
+
+ SetItemInfoFromCompressingResult(compressingResult, options.IsRealAesMode(), options.AesKeyMode, item);
+
+ // file Size can be 64-bit !!!
+ RINOK(archive.SetRestrictionFromCurrent())
+ archive.WriteLocalHeader(item);
+ }
+
+ {
+ CThreadInfo &thread = threads.Threads[threadIndices.Front()];
+ if (!thread.OutStreamSpec->WasUnlockEventSent())
+ {
+ CMyComPtr<IOutStream> outStream;
+ archive.CreateStreamForCompressing(outStream);
+ thread.OutStreamSpec->SetOutStream(outStream);
+ thread.OutStreamSpec->SetRealStreamMode();
+ }
+ }
+
+ WRes wres = mtSem.Semaphore.Lock();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+
+ int ti = mtSem.GetFreeItem();
+ if (ti < 0)
+ return E_FAIL;
+
+ CThreadInfo &threadInfo = threads.Threads[(unsigned)ti];
+ threadInfo.InStream.Release();
+ threadInfo.IsFree = true;
+ RINOK(threadInfo.Result)
+
+ unsigned t = 0;
+
+ for (;;)
+ {
+ if (t == threadIndices.Size())
+ return E_FAIL;
+ if (threadIndices[t] == (unsigned)ti)
+ break;
+ t++;
+ }
+ threadIndices.Delete(t);
+
+ if (t == 0)
+ {
+ // if thread for current file was finished.
+ if (threadInfo.UpdateIndex != itemIndex)
+ return E_FAIL;
+
+ if (memRef.PreDescriptorMode != threadInfo.CompressingResult.DescriptorMode)
+ return E_FAIL;
+
+ RINOK(threadInfo.OutStreamSpec->WriteToRealStream())
+ threadInfo.OutStreamSpec->ReleaseOutStream();
+ SetFileHeader(options, ui, threadInfo.CompressingResult.DescriptorMode, item);
+ SetItemInfoFromCompressingResult(threadInfo.CompressingResult,
+ options.IsRealAesMode(), options.AesKeyMode, item);
+
+ archive.WriteLocalHeader_Replace(item);
+
+ /*
+ if (reportArcProp)
+ {
+ stat.UpdateWithItem(item);
+ RINOK(ReportProps(reportArcProp, ui.IndexInClient, item, options.IsRealAesMode()));
+ }
+ */
+ }
+ else
+ {
+ // it's not current file. So we must store information in array
+ CMemBlocks2 &memRef2 = refs.Refs[threadInfo.UpdateIndex];
+ threadInfo.OutStreamSpec->DetachData(memRef2);
+ memRef2.CompressingResult = threadInfo.CompressingResult;
+ // memRef2.SeqMode = threadInfo.SeqMode; // it was set before
+ memRef2.Finished = true;
+ continue;
+ }
+ }
+ }
+ }
+ else
+ {
+ RINOK(UpdateItemOldData(archive, inArchive, itemEx, ui, item, progress, opCallback, complexity))
+ }
+
+ items.Add(item);
+ complexity += kLocalHeaderSize;
+ mtProgressMixerSpec->Mixer2->SetProgressOffset(complexity);
+ itemIndex++;
+ }
+
+ RINOK(mtCompressProgressMixer.SetRatioInfo(0, NULL, NULL))
+
+ RINOK(archive.WriteCentralDir(items, comment))
+
+ /*
+ if (reportArcProp)
+ {
+ RINOK(ReportArcProps(reportArcProp, stat));
+ }
+ */
+
+ complexity += kCentralHeaderSize * updateItems.Size() + 1;
+ mtProgressMixerSpec->Mixer2->SetProgressOffset(complexity);
+ return mtCompressProgressMixer.SetRatioInfo(0, NULL, NULL);
+
+ #endif
+}
+
+/*
+// we need CSeekOutStream, if we need Seek(0, STREAM_SEEK_CUR) for seqential stream
+Z7_CLASS_IMP_COM_1(
+ CSeekOutStream
+ , IOutStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ CMyComPtr<ISequentialOutStream> _seqStream;
+ UInt64 _size;
+public:
+ void Init(ISequentialOutStream *seqStream)
+ {
+ _size = 0;
+ _seqStream = seqStream;
+ }
+};
+
+Z7_COM7F_IMF(CSeekOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize;
+ const HRESULT result = _seqStream->Write(data, size, &realProcessedSize);
+ _size += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return result;
+}
+
+Z7_COM7F_IMF(CSeekOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ if (seekOrigin != STREAM_SEEK_CUR || offset != 0)
+ return E_NOTIMPL;
+ if (newPosition)
+ *newPosition = (UInt64)_size;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CSeekOutStream::SetSize(UInt64 newSize))
+{
+ UNUSED_VAR(newSize)
+ return E_NOTIMPL;
+}
+*/
+
+static const size_t kCacheBlockSize = (1 << 20);
+static const size_t kCacheSize = (kCacheBlockSize << 2);
+static const size_t kCacheMask = (kCacheSize - 1);
+
+Z7_CLASS_IMP_NOQIB_2(
+ CCacheOutStream
+ , IOutStream
+ , IStreamSetRestriction
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ CMyComPtr<IOutStream> _stream;
+ CMyComPtr<ISequentialOutStream> _seqStream;
+ Byte *_cache;
+ UInt64 _virtPos;
+ UInt64 _virtSize;
+ UInt64 _phyPos;
+ UInt64 _phySize; // <= _virtSize
+ UInt64 _cachedPos; // (_cachedPos + _cachedSize) <= _virtSize
+ size_t _cachedSize;
+ HRESULT _hres;
+
+ UInt64 _restrict_begin;
+ UInt64 _restrict_end;
+ UInt64 _restrict_phy; // begin
+ CMyComPtr<IStreamSetRestriction> _setRestriction;
+
+ HRESULT MyWrite(size_t size);
+ HRESULT MyWriteBlock()
+ {
+ return MyWrite(kCacheBlockSize - ((size_t)_cachedPos & (kCacheBlockSize - 1)));
+ }
+ HRESULT WriteNonRestrictedBlocks();
+ HRESULT FlushCache();
+public:
+ CCacheOutStream(): _cache(NULL) {}
+ ~CCacheOutStream();
+ bool Allocate();
+ HRESULT Init(ISequentialOutStream *seqStream, IOutStream *stream, IStreamSetRestriction *setRestriction);
+ HRESULT FinalFlush();
+};
+
+
+bool CCacheOutStream::Allocate()
+{
+ if (!_cache)
+ _cache = (Byte *)::MidAlloc(kCacheSize);
+ return (_cache != NULL);
+}
+
+HRESULT CCacheOutStream::Init(ISequentialOutStream *seqStream, IOutStream *stream, IStreamSetRestriction *setRestriction)
+{
+ _cachedPos = 0;
+ _cachedSize = 0;
+ _hres = S_OK;
+ _restrict_begin = 0;
+ _restrict_end = 0;
+ _restrict_phy = 0;
+ _virtPos = 0;
+ _virtSize = 0;
+ _seqStream = seqStream;
+ _stream = stream;
+ _setRestriction = setRestriction;
+ if (_stream)
+ {
+ RINOK(_stream->Seek(0, STREAM_SEEK_CUR, &_virtPos))
+ RINOK(_stream->Seek(0, STREAM_SEEK_END, &_virtSize))
+ RINOK(_stream->Seek((Int64)_virtPos, STREAM_SEEK_SET, &_virtPos))
+ }
+ _phyPos = _virtPos;
+ _phySize = _virtSize;
+ return S_OK;
+}
+
+
+/* it writes up to (size) bytes from cache.
+ (size > _cachedSize) is allowed */
+
+HRESULT CCacheOutStream::MyWrite(size_t size)
+{
+ PRF(printf("\n-- CCacheOutStream::MyWrite %u\n", (unsigned)size));
+ if (_hres != S_OK)
+ return _hres;
+ while (size != 0 && _cachedSize != 0)
+ {
+ if (_phyPos != _cachedPos)
+ {
+ if (!_stream)
+ return E_FAIL;
+ _hres = _stream->Seek((Int64)_cachedPos, STREAM_SEEK_SET, &_phyPos);
+ RINOK(_hres)
+ if (_phyPos != _cachedPos)
+ {
+ _hres = E_FAIL;
+ return _hres;
+ }
+ }
+ const size_t pos = (size_t)_cachedPos & kCacheMask;
+ size_t curSize = kCacheSize - pos;
+ curSize = MyMin(curSize, _cachedSize);
+ curSize = MyMin(curSize, size);
+ _hres = WriteStream(_seqStream, _cache + pos, curSize);
+ RINOK(_hres)
+ _phyPos += curSize;
+ if (_phySize < _phyPos)
+ _phySize = _phyPos;
+ _cachedPos += curSize;
+ _cachedSize -= curSize;
+ size -= curSize;
+ }
+
+ if (_setRestriction)
+ if (_restrict_begin == _restrict_end || _cachedPos <= _restrict_begin)
+ if (_restrict_phy < _cachedPos)
+ {
+ _restrict_phy = _cachedPos;
+ return _setRestriction->SetRestriction(_cachedPos, (UInt64)(Int64)-1);
+ }
+ return S_OK;
+}
+
+
+HRESULT CCacheOutStream::WriteNonRestrictedBlocks()
+{
+ for (;;)
+ {
+ const size_t size = kCacheBlockSize - ((size_t)_cachedPos & (kCacheBlockSize - 1));
+ if (_cachedSize < size)
+ break;
+ if (_restrict_begin != _restrict_end && _cachedPos + size > _restrict_begin)
+ break;
+ RINOK(MyWrite(size))
+ }
+ return S_OK;
+}
+
+
+HRESULT CCacheOutStream::FlushCache()
+{
+ return MyWrite(_cachedSize);
+}
+
+HRESULT CCacheOutStream::FinalFlush()
+{
+ _restrict_begin = 0;
+ _restrict_end = 0;
+ RINOK(FlushCache())
+ if (_stream && _hres == S_OK)
+ {
+ if (_virtSize != _phySize)
+ {
+ // it's unexpected
+ RINOK(_stream->SetSize(_virtSize))
+ }
+ if (_virtPos != _phyPos)
+ {
+ RINOK(_stream->Seek((Int64)_virtPos, STREAM_SEEK_SET, NULL))
+ }
+ }
+ return S_OK;
+}
+
+
+CCacheOutStream::~CCacheOutStream()
+{
+ ::MidFree(_cache);
+}
+
+
+Z7_COM7F_IMF(CCacheOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ PRF(printf("\n-- CCacheOutStream::Write %u\n", (unsigned)size));
+
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (_hres != S_OK)
+ return _hres;
+
+ if (_cachedSize != 0)
+ if (_virtPos < _cachedPos ||
+ _virtPos > _cachedPos + _cachedSize)
+ {
+ RINOK(FlushCache())
+ }
+
+ // ---------- Writing data to cache ----------
+
+ if (_cachedSize == 0)
+ _cachedPos = _virtPos;
+
+ const size_t pos = (size_t)_virtPos & kCacheMask;
+ size = (UInt32)MyMin((size_t)size, kCacheSize - pos);
+ const UInt64 cachedEnd = _cachedPos + _cachedSize;
+
+ // (_virtPos >= _cachedPos) (_virtPos <= cachedEnd)
+
+ if (_virtPos != cachedEnd)
+ {
+ // _virtPos < cachedEnd
+ // we rewrite only existing data in cache. So _cachedSize will be not changed
+ size = (UInt32)MyMin((size_t)size, (size_t)(cachedEnd - _virtPos));
+ }
+ else
+ {
+ // _virtPos == cachedEnd
+ // so we need to add new data to the end of cache
+ if (_cachedSize == kCacheSize)
+ {
+ // cache is full. So we flush part of cache
+ RINOK(MyWriteBlock())
+ }
+ // _cachedSize != kCacheSize
+ // so we have some space for new data in cache
+ const size_t startPos = (size_t)_cachedPos & kCacheMask;
+ // we don't allow new data to overwrite old start data in cache.
+ if (startPos > pos)
+ size = (UInt32)MyMin((size_t)size, (size_t)(startPos - pos));
+ _cachedSize += size;
+ }
+
+ memcpy(_cache + pos, data, size);
+ if (processedSize)
+ *processedSize = size;
+ _virtPos += size;
+ if (_virtSize < _virtPos)
+ _virtSize = _virtPos;
+ return WriteNonRestrictedBlocks();
+}
+
+
+Z7_COM7F_IMF(CCacheOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ PRF(printf("\n-- CCacheOutStream::Seek seekOrigin=%d Seek =%u\n", seekOrigin, (unsigned)offset));
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += _virtSize; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCacheOutStream::SetSize(UInt64 newSize))
+{
+ if (_hres != S_OK)
+ return _hres;
+ _virtSize = newSize;
+
+ if (newSize <= _cachedPos)
+ {
+ _cachedSize = 0;
+ _cachedPos = newSize;
+ }
+ else
+ {
+ // newSize > _cachedPos
+ const UInt64 offset = newSize - _cachedPos;
+ if (offset <= _cachedSize)
+ {
+ _cachedSize = (size_t)offset;
+ if (_phySize <= newSize)
+ return S_OK;
+ }
+ else
+ {
+ // newSize > _cachedPos + _cachedSize
+ // So we flush cache
+ RINOK(FlushCache())
+ }
+ }
+
+ if (newSize != _phySize)
+ {
+ if (!_stream)
+ return E_NOTIMPL;
+ _hres = _stream->SetSize(newSize);
+ RINOK(_hres)
+ _phySize = newSize;
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCacheOutStream::SetRestriction(UInt64 begin, UInt64 end))
+{
+ PRF(printf("\n============ CCacheOutStream::SetRestriction %u, %u\n", (unsigned)begin, (unsigned)end));
+ _restrict_begin = begin;
+ _restrict_end = end;
+ return WriteNonRestrictedBlocks();
+}
+
+
+
+HRESULT Update(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const CObjectVector<CItemEx> &inputItems,
+ CObjectVector<CUpdateItem> &updateItems,
+ ISequentialOutStream *seqOutStream,
+ CInArchive *inArchive, bool removeSfx,
+ const CUpdateOptions &updateOptions,
+ const CCompressionMethodMode &compressionMethodMode,
+ IArchiveUpdateCallback *updateCallback)
+{
+ /*
+ // it was tested before
+ if (inArchive)
+ {
+ if (!inArchive->CanUpdate())
+ return E_NOTIMPL;
+ }
+ */
+
+ CMyComPtr<IStreamSetRestriction> setRestriction;
+ seqOutStream->QueryInterface(IID_IStreamSetRestriction, (void **)&setRestriction);
+ if (setRestriction)
+ {
+ RINOK(setRestriction->SetRestriction(0, 0))
+ }
+
+ CMyComPtr<IOutStream> outStream;
+ CCacheOutStream *cacheStream;
+ bool outSeqMode;
+
+ {
+ CMyComPtr<IOutStream> outStreamReal;
+
+ if (!compressionMethodMode.Force_SeqOutMode)
+ {
+ seqOutStream->QueryInterface(IID_IOutStream, (void **)&outStreamReal);
+ /*
+ if (!outStreamReal)
+ return E_NOTIMPL;
+ */
+ }
+
+ if (inArchive)
+ {
+ if (!inArchive->IsMultiVol && inArchive->ArcInfo.Base > 0 && !removeSfx)
+ {
+ IInStream *baseStream = inArchive->GetBaseStream();
+ RINOK(InStream_SeekToBegin(baseStream))
+ RINOK(NCompress::CopyStream_ExactSize(baseStream, seqOutStream, (UInt64)inArchive->ArcInfo.Base, NULL))
+ }
+ }
+
+ // bool use_cacheStream = true;
+ // if (use_cacheStream)
+ {
+ cacheStream = new CCacheOutStream();
+ outStream = cacheStream;
+ if (!cacheStream->Allocate())
+ return E_OUTOFMEMORY;
+ RINOK(cacheStream->Init(seqOutStream, outStreamReal, setRestriction))
+ setRestriction.Release();
+ setRestriction = cacheStream;
+ }
+ /*
+ else if (!outStreamReal)
+ {
+ CSeekOutStream *seekOutStream = new CSeekOutStream();
+ outStream = seekOutStream;
+ seekOutStream->Init(seqOutStream);
+ }
+ else
+ outStream = outStreamReal;
+ */
+ outSeqMode = (outStreamReal == NULL);
+ }
+
+ COutArchive outArchive;
+ outArchive.SetRestriction = setRestriction;
+
+ RINOK(outArchive.Create(outStream))
+
+ if (inArchive)
+ {
+ if (!inArchive->IsMultiVol && (Int64)inArchive->ArcInfo.MarkerPos2 > inArchive->ArcInfo.Base)
+ {
+ IInStream *baseStream = inArchive->GetBaseStream();
+ RINOK(InStream_SeekSet(baseStream, (UInt64)inArchive->ArcInfo.Base))
+ const UInt64 embStubSize = (UInt64)((Int64)inArchive->ArcInfo.MarkerPos2 - inArchive->ArcInfo.Base);
+ RINOK(NCompress::CopyStream_ExactSize(baseStream, outStream, embStubSize, NULL))
+ outArchive.MoveCurPos(embStubSize);
+ }
+ }
+
+ RINOK (Update2(
+ EXTERNAL_CODECS_LOC_VARS
+ outArchive, inArchive,
+ inputItems, updateItems,
+ updateOptions,
+ compressionMethodMode, outSeqMode,
+ inArchive ? &inArchive->ArcInfo.Comment : NULL,
+ updateCallback))
+
+ return cacheStream->FinalFlush();
+}
+
+}}
diff --git a/CPP/7zip/Archive/Zip/ZipUpdate.h b/CPP/7zip/Archive/Zip/ZipUpdate.h
new file mode 100644
index 0000000..13ecd9c
--- /dev/null
+++ b/CPP/7zip/Archive/Zip/ZipUpdate.h
@@ -0,0 +1,107 @@
+// ZipUpdate.h
+
+#ifndef ZIP7_INC_ZIP_UPDATE_H
+#define ZIP7_INC_ZIP_UPDATE_H
+
+#include "../../ICoder.h"
+#include "../IArchive.h"
+
+#include "../../Common/CreateCoder.h"
+
+#include "ZipCompressionMode.h"
+#include "ZipIn.h"
+
+namespace NArchive {
+namespace NZip {
+
+/*
+struct CUpdateRange
+{
+ UInt64 Position;
+ UInt64 Size;
+
+ // CUpdateRange() {}
+ CUpdateRange(UInt64 position, UInt64 size): Position(position), Size(size) {}
+};
+*/
+
+struct CUpdateItem
+{
+ bool NewData;
+ bool NewProps;
+ bool IsDir;
+ bool Write_NtfsTime;
+ bool Write_UnixTime;
+ // bool Write_UnixTime_ATime;
+ bool IsUtf8;
+ bool Size_WasSetFromStream;
+ // bool IsAltStream;
+ int IndexInArc;
+ unsigned IndexInClient;
+ UInt32 Attrib;
+ UInt32 Time;
+ UInt64 Size;
+ AString Name;
+ CByteBuffer Name_Utf; // for Info-Zip (kIzUnicodeName) Extra
+ CByteBuffer Comment;
+ // bool Commented;
+ // CUpdateRange CommentRange;
+ FILETIME Ntfs_MTime;
+ FILETIME Ntfs_ATime;
+ FILETIME Ntfs_CTime;
+
+ void Clear()
+ {
+ IsDir = false;
+
+ Write_NtfsTime = false;
+ Write_UnixTime = false;
+
+ IsUtf8 = false;
+ Size_WasSetFromStream = false;
+ // IsAltStream = false;
+ Time = 0;
+ Size = 0;
+ Name.Empty();
+ Name_Utf.Free();
+ Comment.Free();
+
+ FILETIME_Clear(Ntfs_MTime);
+ FILETIME_Clear(Ntfs_ATime);
+ FILETIME_Clear(Ntfs_CTime);
+ }
+
+ CUpdateItem():
+ IsDir(false),
+ Write_NtfsTime(false),
+ Write_UnixTime(false),
+ IsUtf8(false),
+ Size_WasSetFromStream(false),
+ // IsAltStream(false),
+ Time(0),
+ Size(0)
+ {}
+};
+
+
+struct CUpdateOptions
+{
+ bool Write_MTime;
+ bool Write_ATime;
+ bool Write_CTime;
+};
+
+
+HRESULT Update(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const CObjectVector<CItemEx> &inputItems,
+ CObjectVector<CUpdateItem> &updateItems,
+ ISequentialOutStream *seqOutStream,
+ CInArchive *inArchive, bool removeSfx,
+ const CUpdateOptions &updateOptions,
+ const CCompressionMethodMode &compressionMethodMode,
+ IArchiveUpdateCallback *updateCallback);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Archive/makefile b/CPP/7zip/Archive/makefile
new file mode 100644
index 0000000..7512ad5
--- /dev/null
+++ b/CPP/7zip/Archive/makefile
@@ -0,0 +1,23 @@
+DIRS = \
+ 7z\~ \
+ Arj\~ \
+ BZip2\~ \
+ Cab\~ \
+ Chm\~ \
+ Cpio\~ \
+ Deb\~ \
+ GZip\~ \
+ Iso\~ \
+ Lzh\~ \
+ Nsis\~ \
+ Rar\~ \
+ RPM\~ \
+ Split\~ \
+ Tar\~ \
+ Z\~ \
+ Zip\~ \
+
+all: $(DIRS)
+
+$(DIRS):
+!include "../SubBuild.mak"
diff --git a/CPP/7zip/Asm.mak b/CPP/7zip/Asm.mak
index 3ad238a..c4073e8 100644
--- a/CPP/7zip/Asm.mak
+++ b/CPP/7zip/Asm.mak
@@ -1,9 +1,9 @@
-!IFDEF ASM_OBJS
-!IF "$(CPU)" == "ARM"
-$(ASM_OBJS): ../../../../Asm/Arm/$(*B).asm
- $(COMPL_ASM)
-!ELSEIF "$(CPU)" != "IA64" && "$(CPU)" != "MIPS" && "$(CPU)" != "ARM64"
-$(ASM_OBJS): ../../../../Asm/x86/$(*B).asm
- $(COMPL_ASM)
-!ENDIF
-!ENDIF
+!IFDEF ASM_OBJS
+!IF "$(CPU)" == "ARM"
+$(ASM_OBJS): ../../../../Asm/Arm/$(*B).asm
+ $(COMPL_ASM)
+!ELSEIF "$(CPU)" != "IA64" && "$(CPU)" != "MIPS" && "$(CPU)" != "ARM64"
+$(ASM_OBJS): ../../../../Asm/x86/$(*B).asm
+ $(COMPL_ASM)
+!ENDIF
+!ENDIF
diff --git a/CPP/7zip/Bundles/Alone/Alone.dsp b/CPP/7zip/Bundles/Alone/Alone.dsp
new file mode 100644
index 0000000..65c81c4
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/Alone.dsp
@@ -0,0 +1,3234 @@
+# Microsoft Developer Studio Project File - Name="Alone" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Alone - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Alone.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Alone.mak" CFG="Alone - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Alone - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Alone - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "Alone - Win32 ReleaseU" (based on "Win32 (x86) Console Application")
+!MESSAGE "Alone - Win32 DebugU" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MT /W4 /WX /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /FAcs /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7za.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# SUBTRACT CPP /WX
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7za.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "UNICODE" /D "_UNICODE" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7za.exe" /opt:NOWIN98
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7zan.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7za.exe" /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7zan.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Alone - Win32 Release"
+# Name "Alone - Win32 Debug"
+# Name "Alone - Win32 ReleaseU"
+# Name "Alone - Win32 DebugU"
+# Begin Group "Console"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ArError.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\BenchCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\BenchCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\CompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ExtractCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ExtractCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\HashCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\HashCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\List.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\List.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\MainAr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\OpenCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\OpenCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\PercentPrinter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\PercentPrinter.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UpdateCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UpdateCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UserInputUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UserInputUtils.h
+# End Source File
+# End Group
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\AutoPtr.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Buffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CrcReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\LzFindPrepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyException.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyGuidDef.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyLinux.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyUnknown.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha1Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha1Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Init.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Reg.cpp
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Device.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MemBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MemBlocks.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutMemStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutMemStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressMt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterArc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterCodec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Group "BZip2"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Const.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Crc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Crc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Decoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Encoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Encoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Register.cpp
+# End Source File
+# End Group
+# Begin Group "Copy"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Deflate"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Deflate64Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateConst.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateDecoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateEncoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Huffman"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\HuffmanDecoder.h
+# End Source File
+# End Group
+# Begin Group "Implode"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\ImplodeDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ImplodeDecoder.h
+# End Source File
+# End Group
+# Begin Group "LZMA"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# End Group
+# Begin Group "PPMd"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdEncoder.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdZip.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdZip.h
+# End Source File
+# End Group
+# Begin Group "RangeCoder"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\RangeCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\RangeCoderBit.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\RangeCoderBitTree.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\RangeCoderOpt.h
+# End Source File
+# End Group
+# Begin Group "Shrink"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\ShrinkDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ShrinkDecoder.h
+# End Source File
+# End Group
+# Begin Group "BWT"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Mtf8.h
+# End Source File
+# End Group
+# Begin Group "LZX"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzxDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzxDecoder.h
+# End Source File
+# End Group
+# Begin Group "Quantum"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\QuantumDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\QuantumDecoder.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitlDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitlDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitlEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitmDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitmEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ByteSwap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ByteSwap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeltaFilter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzOutWindow.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzOutWindow.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzEncoder.h
+# End Source File
+# End Group
+# Begin Group "Archive"
+
+# PROP Default_Filter ""
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.h
+# End Source File
+# End Group
+# Begin Group "tar"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarUpdate.h
+# End Source File
+# End Group
+# Begin Group "zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipAddCommon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipAddCommon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipItem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipUpdate.h
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderLoader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\FindSignature.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\FindSignature.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.h
+# End Source File
+# End Group
+# Begin Group "cab"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabBlockInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabBlockInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabRegister.cpp
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Archive\Bz2Handler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\DeflateProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\DeflateProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\GzHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\LzmaHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SplitHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\XzHandler.cpp
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveCommandLine.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveCommandLine.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\TempFiles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\TempFiles.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Update.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Update.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateProduce.h
+# End Source File
+# End Group
+# Begin Group "Crypto"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAesRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\HmacSha1.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\HmacSha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAesReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Pbkdf2HmacSha1.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Pbkdf2HmacSha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RandGen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RandGen.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Sha1Cls.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\WzAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\WzAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipCrypto.cpp
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O1
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O1
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipCrypto.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipStrong.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipStrong.h
+# End Source File
+# End Group
+# Begin Group "7-zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IMyUnknown.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\MyVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Group "Xz"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Xz.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Xz.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64Opt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzDec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzEnc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzIn.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\AesOpt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2Enc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BraIA64.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BwtSort.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BwtSort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\HuffEnc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\HuffEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindOpt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7Dec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7Enc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8Dec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8Enc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\RotateDefs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\SwapBytes.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\SwapBytes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/Alone/Alone.dsw b/CPP/7zip/Bundles/Alone/Alone.dsw
new file mode 100644
index 0000000..65eca43
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/Alone.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Alone"=.\Alone.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/Alone/StdAfx.cpp b/CPP/7zip/Bundles/Alone/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Alone/StdAfx.h b/CPP/7zip/Bundles/Alone/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Alone/afxres.h b/CPP/7zip/Bundles/Alone/afxres.h
new file mode 100644
index 0000000..c2fadd4
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/afxres.h
@@ -0,0 +1 @@
+#include <winresrc.h>
diff --git a/CPP/7zip/Bundles/Alone/makefile b/CPP/7zip/Bundles/Alone/makefile
new file mode 100644
index 0000000..bad953a
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/makefile
@@ -0,0 +1,230 @@
+PROG = 7za.exe
+# USE_C_AES = 1
+# USE_C_SHA = 1
+# USE_C_LZFINDOPT = 1
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\ListFileUtils.obj \
+ $O\LzFindPrepare.obj \
+ $O\NewHandler.obj \
+ $O\StdInStream.obj \
+ $O\StdOutStream.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+ $O\XzCrc64Init.obj \
+ $O\XzCrc64Reg.obj \
+ $O\Sha1Reg.obj \
+ $O\Sha256Reg.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileLink.obj \
+ $O\FileName.obj \
+ $O\FileSystem.obj \
+ $O\MemoryLock.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\PropVariantUtils.obj \
+ $O\Registry.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\SystemInfo.obj \
+ $O\TimeUtils.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\FilterCoder.obj \
+ $O\InBuffer.obj \
+ $O\InOutTempBuffer.obj \
+ $O\LimitedStreams.obj \
+ $O\MemBlocks.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\MultiOutStream.obj \
+ $O\OffsetStream.obj \
+ $O\OutBuffer.obj \
+ $O\OutMemStream.obj \
+ $O\ProgressMt.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\Bz2Handler.obj \
+ $O\DeflateProps.obj \
+ $O\GzHandler.obj \
+ $O\LzmaHandler.obj \
+ $O\SplitHandler.obj \
+ $O\XzHandler.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\DummyOutStream.obj \
+ $O\FindSignature.obj \
+ $O\HandlerOut.obj \
+ $O\InStreamWithCRC.obj \
+ $O\ItemNameUtils.obj \
+ $O\MultiStream.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zEncode.obj \
+ $O\7zExtract.obj \
+ $O\7zFolderInStream.obj \
+ $O\7zHandler.obj \
+ $O\7zHandlerOut.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zOut.obj \
+ $O\7zProperties.obj \
+ $O\7zSpecStream.obj \
+ $O\7zUpdate.obj \
+ $O\7zRegister.obj \
+
+CAB_OBJS = \
+ $O\CabBlockInStream.obj \
+ $O\CabHandler.obj \
+ $O\CabHeader.obj \
+ $O\CabIn.obj \
+ $O\CabRegister.obj \
+
+TAR_OBJS = \
+ $O\TarHandler.obj \
+ $O\TarHandlerOut.obj \
+ $O\TarHeader.obj \
+ $O\TarIn.obj \
+ $O\TarOut.obj \
+ $O\TarUpdate.obj \
+ $O\TarRegister.obj \
+
+ZIP_OBJS = \
+ $O\ZipAddCommon.obj \
+ $O\ZipHandler.obj \
+ $O\ZipHandlerOut.obj \
+ $O\ZipIn.obj \
+ $O\ZipItem.obj \
+ $O\ZipOut.obj \
+ $O\ZipUpdate.obj \
+ $O\ZipRegister.obj \
+
+
+COMPRESS_OBJS = \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BitlDecoder.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\BZip2Crc.obj \
+ $O\BZip2Decoder.obj \
+ $O\BZip2Encoder.obj \
+ $O\BZip2Register.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\Deflate64Register.obj \
+ $O\DeflateDecoder.obj \
+ $O\DeflateEncoder.obj \
+ $O\DeflateRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\ImplodeDecoder.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Encoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaEncoder.obj \
+ $O\LzmaRegister.obj \
+ $O\LzOutWindow.obj \
+ $O\LzxDecoder.obj \
+ $O\PpmdDecoder.obj \
+ $O\PpmdEncoder.obj \
+ $O\PpmdRegister.obj \
+ $O\PpmdZip.obj \
+ $O\QuantumDecoder.obj \
+ $O\ShrinkDecoder.obj \
+ $O\XzDecoder.obj \
+ $O\XzEncoder.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\HmacSha1.obj \
+ $O\MyAes.obj \
+ $O\MyAesReg.obj \
+ $O\Pbkdf2HmacSha1.obj \
+ $O\RandGen.obj \
+ $O\WzAes.obj \
+ $O\ZipCrypto.obj \
+ $O\ZipStrong.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bcj2Enc.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\BwtSort.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\HuffEnc.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\Lzma2Enc.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\MtCoder.obj \
+ $O\MtDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+ $O\Ppmd7Enc.obj \
+ $O\Ppmd8.obj \
+ $O\Ppmd8Dec.obj \
+ $O\Ppmd8Enc.obj \
+ $O\Sort.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+ $O\Xz.obj \
+ $O\XzDec.obj \
+ $O\XzEnc.obj \
+ $O\XzIn.obj \
+
+!include "../../UI/Console/Console.mak"
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../Crc64.mak"
+!include "../../LzFindOpt.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha1.mak"
+!include "../../Sha256.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Alone/makefile.gcc b/CPP/7zip/Bundles/Alone/makefile.gcc
new file mode 100644
index 0000000..cb7e828
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/makefile.gcc
@@ -0,0 +1,348 @@
+PROG = 7za
+
+
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+include ../../LzmaDec_gcc.mak
+
+
+LOCAL_FLAGS_ST =
+MT_OBJS =
+
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef ST_MODE
+
+LOCAL_FLAGS_ST = -DZ7_ST
+
+ifdef IS_MINGW
+MT_OBJS = \
+ $O/Threads.o \
+
+endif
+
+else
+
+MT_OBJS = \
+ $O/LzFindMt.o \
+ $O/StreamBinder.o \
+ $O/Synchronization.o \
+ $O/VirtThread.o \
+ $O/MemBlocks.o \
+ $O/OutMemStream.o \
+ $O/ProgressMt.o \
+ $O/Threads.o \
+
+endif
+
+
+
+LOCAL_FLAGS_SYS =
+
+ifdef IS_MINGW
+
+LOCAL_FLAGS_SYS = \
+ -DZ7_LARGE_PAGES \
+ -DZ7_LONG_PATH \
+ -DZ7_DEVICE_FILE \
+
+SYS_OBJS = \
+ $O/FileSystem.o \
+ $O/Registry.o \
+ $O/MemoryLock.o \
+ $O/DLL.o \
+ $O/DllSecur.o \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+
+endif
+
+LOCAL_FLAGS = \
+ $(LOCAL_FLAGS_ST) \
+ $(LOCAL_FLAGS_SYS) \
+
+
+
+CONSOLE_OBJS = \
+ $O/BenchCon.o \
+ $O/ConsoleClose.o \
+ $O/ExtractCallbackConsole.o \
+ $O/HashCon.o \
+ $O/List.o \
+ $O/Main.o \
+ $O/MainAr.o \
+ $O/OpenCallbackConsole.o \
+ $O/PercentPrinter.o \
+ $O/UpdateCallbackConsole.o \
+ $O/UserInputUtils.o \
+
+UI_COMMON_OBJS = \
+ $O/ArchiveCommandLine.o \
+ $O/ArchiveExtractCallback.o \
+ $O/ArchiveOpenCallback.o \
+ $O/Bench.o \
+ $O/DefaultName.o \
+ $O/EnumDirItems.o \
+ $O/Extract.o \
+ $O/ExtractingFilePath.o \
+ $O/HashCalc.o \
+ $O/LoadCodecs.o \
+ $O/OpenArchive.o \
+ $O/PropIDUtils.o \
+ $O/SetProperties.o \
+ $O/SortUtils.o \
+ $O/TempFiles.o \
+ $O/Update.o \
+ $O/UpdateAction.o \
+ $O/UpdateCallback.o \
+ $O/UpdatePair.o \
+ $O/UpdateProduce.o \
+
+COMMON_OBJS = \
+ $O/CommandLineParser.o \
+ $O/CRC.o \
+ $O/CrcReg.o \
+ $O/DynLimBuf.o \
+ $O/IntToString.o \
+ $O/ListFileUtils.o \
+ $O/LzFindPrepare.o \
+ $O/MyString.o \
+ $O/NewHandler.o \
+ $O/StdInStream.o \
+ $O/StdOutStream.o \
+ $O/Sha1Prepare.o \
+ $O/Sha1Reg.o \
+ $O/Sha256Prepare.o \
+ $O/Sha256Reg.o \
+ $O/StringConvert.o \
+ $O/StringToInt.o \
+ $O/UTFConvert.o \
+ $O/MyVector.o \
+ $O/Wildcard.o \
+ $O/XzCrc64Init.o \
+ $O/XzCrc64Reg.o \
+
+
+WIN_OBJS = \
+ $O/ErrorMsg.o \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileIO.o \
+ $O/FileLink.o \
+ $O/FileName.o \
+ $O/PropVariant.o \
+ $O/PropVariantConv.o \
+ $O/PropVariantUtils.o \
+ $O/System.o \
+ $O/SystemInfo.o \
+ $O/TimeUtils.o \
+
+
+7ZIP_COMMON_OBJS = \
+ $O/CreateCoder.o \
+ $O/CWrappers.o \
+ $O/FilePathAutoRename.o \
+ $O/FileStreams.o \
+ $O/InBuffer.o \
+ $O/InOutTempBuffer.o \
+ $O/FilterCoder.o \
+ $O/LimitedStreams.o \
+ $O/MethodId.o \
+ $O/MethodProps.o \
+ $O/MultiOutStream.o \
+ $O/OffsetStream.o \
+ $O/OutBuffer.o \
+ $O/ProgressUtils.o \
+ $O/PropId.o \
+ $O/StreamObjects.o \
+ $O/StreamUtils.o \
+ $O/UniqBlocks.o \
+
+AR_OBJS = \
+ $O/Bz2Handler.o \
+ $O/GzHandler.o \
+ $O/LzmaHandler.o \
+ $O/SplitHandler.o \
+ $O/XzHandler.o \
+
+AR_COMMON_OBJS = \
+ $O/CoderMixer2.o \
+ $O/DummyOutStream.o \
+ $O/HandlerOut.o \
+ $O/InStreamWithCRC.o \
+ $O/ItemNameUtils.o \
+ $O/MultiStream.o \
+ $O/OutStreamWithCRC.o \
+ $O/ParseProperties.o \
+
+7Z_OBJS = \
+ $O/7zCompressionMode.o \
+ $O/7zDecode.o \
+ $O/7zEncode.o \
+ $O/7zExtract.o \
+ $O/7zFolderInStream.o \
+ $O/7zHandler.o \
+ $O/7zHandlerOut.o \
+ $O/7zHeader.o \
+ $O/7zIn.o \
+ $O/7zOut.o \
+ $O/7zProperties.o \
+ $O/7zRegister.o \
+ $O/7zSpecStream.o \
+ $O/7zUpdate.o \
+
+CAB_OBJS = \
+ $O/CabBlockInStream.o \
+ $O/CabHandler.o \
+ $O/CabHeader.o \
+ $O/CabIn.o \
+ $O/CabRegister.o \
+
+TAR_OBJS = \
+ $O/TarHandler.o \
+ $O/TarHandlerOut.o \
+ $O/TarHeader.o \
+ $O/TarIn.o \
+ $O/TarOut.o \
+ $O/TarUpdate.o \
+ $O/TarRegister.o \
+
+ZIP_OBJS = \
+ $O/ZipAddCommon.o \
+ $O/ZipHandler.o \
+ $O/ZipHandlerOut.o \
+ $O/ZipIn.o \
+ $O/ZipItem.o \
+ $O/ZipOut.o \
+ $O/ZipUpdate.o \
+ $O/ZipRegister.o \
+
+COMPRESS_OBJS = \
+ $O/Bcj2Coder.o \
+ $O/Bcj2Register.o \
+ $O/BcjCoder.o \
+ $O/BcjRegister.o \
+ $O/BitlDecoder.o \
+ $O/BranchMisc.o \
+ $O/BranchRegister.o \
+ $O/ByteSwap.o \
+ $O/BZip2Crc.o \
+ $O/BZip2Decoder.o \
+ $O/BZip2Encoder.o \
+ $O/BZip2Register.o \
+ $O/CopyCoder.o \
+ $O/CopyRegister.o \
+ $O/Deflate64Register.o \
+ $O/DeflateDecoder.o \
+ $O/DeflateEncoder.o \
+ $O/DeflateRegister.o \
+ $O/DeltaFilter.o \
+ $O/ImplodeDecoder.o \
+ $O/Lzma2Decoder.o \
+ $O/Lzma2Encoder.o \
+ $O/Lzma2Register.o \
+ $O/LzmaDecoder.o \
+ $O/LzmaEncoder.o \
+ $O/LzmaRegister.o \
+ $O/LzOutWindow.o \
+ $O/LzxDecoder.o \
+ $O/PpmdDecoder.o \
+ $O/PpmdEncoder.o \
+ $O/PpmdRegister.o \
+ $O/PpmdZip.o \
+ $O/QuantumDecoder.o \
+ $O/ShrinkDecoder.o \
+ $O/XzDecoder.o \
+ $O/XzEncoder.o \
+
+CRYPTO_OBJS = \
+ $O/7zAes.o \
+ $O/7zAesRegister.o \
+ $O/HmacSha1.o \
+ $O/MyAes.o \
+ $O/MyAesReg.o \
+ $O/Pbkdf2HmacSha1.o \
+ $O/RandGen.o \
+ $O/WzAes.o \
+ $O/ZipCrypto.o \
+ $O/ZipStrong.o \
+
+C_OBJS = \
+ $O/7zStream.o \
+ $O/Alloc.o \
+ $O/Bcj2.o \
+ $O/Bcj2Enc.o \
+ $O/Bra.o \
+ $O/Bra86.o \
+ $O/BraIA64.o \
+ $O/BwtSort.o \
+ $O/CpuArch.o \
+ $O/Delta.o \
+ $O/HuffEnc.o \
+ $O/LzFind.o \
+ $O/LzFindOpt.o \
+ $O/Lzma2Dec.o \
+ $O/Lzma2DecMt.o \
+ $O/Lzma2Enc.o \
+ $O/LzmaDec.o \
+ $O/LzmaEnc.o \
+ $O/MtCoder.o \
+ $O/MtDec.o \
+ $O/Ppmd7.o \
+ $O/Ppmd7Dec.o \
+ $O/Ppmd7Enc.o \
+ $O/Ppmd8.o \
+ $O/Ppmd8Dec.o \
+ $O/Ppmd8Enc.o \
+ $O/Sort.o \
+ $O/SwapBytes.o \
+ $O/Xz.o \
+ $O/XzDec.o \
+ $O/XzEnc.o \
+ $O/XzIn.o \
+ $O/XzCrc64.o \
+ $O/XzCrc64Opt.o \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+ $O/Aes.o \
+ $O/AesOpt.o \
+ $O/Sha256.o \
+ $O/Sha256Opt.o \
+ $O/Sha1.o \
+ $O/Sha1Opt.o \
+
+OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $(C_OBJS) \
+ $(MT_OBJS) \
+ $(SYS_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(CRYPTO_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(AR_OBJS) \
+ $(AR_COMMON_OBJS) \
+ $(7Z_OBJS) \
+ $(CAB_OBJS) \
+ $(TAR_OBJS) \
+ $(ZIP_OBJS) \
+ $(UI_COMMON_OBJS) \
+ $(CONSOLE_OBJS) \
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/Bundles/Alone/resource.rc b/CPP/7zip/Bundles/Alone/resource.rc
new file mode 100644
index 0000000..c85acaa
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone/resource.rc
@@ -0,0 +1,7 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_APP("7-Zip Standalone Console", "7za")
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "../../UI/Console/Console.manifest"
+#endif
diff --git a/CPP/7zip/Bundles/Alone2/StdAfx.cpp b/CPP/7zip/Bundles/Alone2/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone2/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Alone2/StdAfx.h b/CPP/7zip/Bundles/Alone2/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone2/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Alone2/makefile b/CPP/7zip/Bundles/Alone2/makefile
new file mode 100644
index 0000000..4cb7718
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone2/makefile
@@ -0,0 +1,29 @@
+PROG = 7zz.exe
+# USE_C_AES = 1
+# USE_C_SHA = 1
+CFLAGS = $(CFLAGS) -DZ7_PROG_VARIANT_Z
+
+!include "../Format7zF/Arc.mak"
+!include "../../UI/Console/Console.mak"
+
+COMMON_OBJS = $(COMMON_OBJS) \
+ $O\CommandLineParser.obj \
+ $O\ListFileUtils.obj \
+ $O\StdInStream.obj \
+ $O\StdOutStream.obj \
+
+WIN_OBJS = $(WIN_OBJS) \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileLink.obj \
+ $O\FileSystem.obj \
+ $O\MemoryLock.obj \
+ $O\Registry.obj \
+ $O\SystemInfo.obj \
+
+7ZIP_COMMON_OBJS = $(7ZIP_COMMON_OBJS) \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\MultiOutStream.obj \
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Alone2/makefile.gcc b/CPP/7zip/Bundles/Alone2/makefile.gcc
new file mode 100644
index 0000000..f767b0d
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone2/makefile.gcc
@@ -0,0 +1,109 @@
+PROG = 7zz
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+CONSOLE_VARIANT_FLAGS=-DZ7_PROG_VARIANT_Z
+
+include ../Format7zF/Arc_gcc.mak
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef IS_MINGW
+
+LOCAL_FLAGS_SYS = \
+ -DZ7_LARGE_PAGES \
+ -DZ7_LONG_PATH \
+ -DZ7_DEVICE_FILE \
+
+SYS_OBJS = \
+ $O/FileSystem.o \
+ $O/Registry.o \
+ $O/MemoryLock.o \
+ $O/DLL.o \
+ $O/DllSecur.o \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+
+endif
+
+
+LOCAL_FLAGS = \
+ $(LOCAL_FLAGS_SYS) \
+ $(LOCAL_FLAGS_ST) \
+
+
+UI_COMMON_OBJS = \
+ $O/ArchiveCommandLine.o \
+ $O/ArchiveExtractCallback.o \
+ $O/ArchiveOpenCallback.o \
+ $O/Bench.o \
+ $O/DefaultName.o \
+ $O/EnumDirItems.o \
+ $O/Extract.o \
+ $O/ExtractingFilePath.o \
+ $O/HashCalc.o \
+ $O/LoadCodecs.o \
+ $O/OpenArchive.o \
+ $O/PropIDUtils.o \
+ $O/SetProperties.o \
+ $O/SortUtils.o \
+ $O/TempFiles.o \
+ $O/Update.o \
+ $O/UpdateAction.o \
+ $O/UpdateCallback.o \
+ $O/UpdatePair.o \
+ $O/UpdateProduce.o \
+
+
+CONSOLE_OBJS = \
+ $O/BenchCon.o \
+ $O/ConsoleClose.o \
+ $O/ExtractCallbackConsole.o \
+ $O/HashCon.o \
+ $O/List.o \
+ $O/Main.o \
+ $O/MainAr.o \
+ $O/OpenCallbackConsole.o \
+ $O/PercentPrinter.o \
+ $O/UpdateCallbackConsole.o \
+ $O/UserInputUtils.o \
+
+COMMON_OBJS_2 = \
+ $O/CommandLineParser.o \
+ $O/ListFileUtils.o \
+ $O/StdInStream.o \
+ $O/StdOutStream.o \
+
+WIN_OBJS_2 = \
+ $O/ErrorMsg.o \
+ $O/FileLink.o \
+ $O/SystemInfo.o \
+
+7ZIP_COMMON_OBJS_2 = \
+ $O/FilePathAutoRename.o \
+ $O/FileStreams.o \
+ $O/MultiOutStream.o \
+
+OBJS = \
+ $(ARC_OBJS) \
+ $(SYS_OBJS) \
+ $(COMMON_OBJS_2) \
+ $(WIN_OBJS_2) \
+ $(7ZIP_COMMON_OBJS_2) \
+ $(UI_COMMON_OBJS) \
+ $(CONSOLE_OBJS) \
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/Bundles/Alone2/resource.rc b/CPP/7zip/Bundles/Alone2/resource.rc
new file mode 100644
index 0000000..af24c17
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone2/resource.rc
@@ -0,0 +1,7 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_APP("7-Zip Standalone 2 Console", "7zz")
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "../../UI/Console/Console.manifest"
+#endif
diff --git a/CPP/7zip/Bundles/Alone7z/Alone.dsp b/CPP/7zip/Bundles/Alone7z/Alone.dsp
index e12207d..ef4ec60 100644
--- a/CPP/7zip/Bundles/Alone7z/Alone.dsp
+++ b/CPP/7zip/Bundles/Alone7z/Alone.dsp
@@ -1,1910 +1,2043 @@
-# Microsoft Developer Studio Project File - Name="Alone" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=Alone - Win32 DebugU
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "Alone.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "Alone.mak" CFG="Alone - Win32 DebugU"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "Alone - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "Alone - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE "Alone - Win32 ReleaseU" (based on "Win32 (x86) Console Application")
-!MESSAGE "Alone - Win32 DebugU" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /Gr /MT /W3 /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "_7ZIP_LARGE_PAGES" /D "SUPPORT_DEVICE_FILE" /FAc /Yu"StdAfx.h" /FD /c
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7zr.exe" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /Gr /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "_7ZIP_LARGE_PAGES" /D "SUPPORT_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7zr.exe" /pdbtype:sept
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "ReleaseU"
-# PROP BASE Intermediate_Dir "ReleaseU"
-# PROP BASE Ignore_Export_Lib 0
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "ReleaseU"
-# PROP Intermediate_Dir "ReleaseU"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "EXCLUDE_COM" /D "NO_REGISTRY" /Yu"StdAfx.h" /FD /c
-# ADD CPP /nologo /Gr /MD /W4 /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "UNICODE" /D "_UNICODE" /D "WIN32" /D "_CONSOLE" /D "_7ZIP_LARGE_PAGES" /D "SUPPORT_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7za.exe" /opt:NOWIN98
-# SUBTRACT BASE LINK32 /pdb:none
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7zr.exe" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "DebugU"
-# PROP BASE Intermediate_Dir "DebugU"
-# PROP BASE Ignore_Export_Lib 0
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "DebugU"
-# PROP Intermediate_Dir "DebugU"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "EXCLUDE_COM" /D "NO_REGISTRY" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
-# ADD CPP /nologo /Gr /MDd /W4 /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_CONSOLE" /D "_7ZIP_LARGE_PAGES" /D "SUPPORT_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7za.exe" /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7zr.exe" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "Alone - Win32 Release"
-# Name "Alone - Win32 Debug"
-# Name "Alone - Win32 ReleaseU"
-# Name "Alone - Win32 DebugU"
-# Begin Group "Console"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ArError.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\BenchCon.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\BenchCon.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\CompressionMode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ConsoleClose.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ConsoleClose.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ExtractCallbackConsole.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ExtractCallbackConsole.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\HashCon.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\HashCon.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\List.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\List.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\Main.cpp
-# ADD CPP /D "PROG_VARIANT_R"
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\MainAr.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\OpenCallbackConsole.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\OpenCallbackConsole.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\PercentPrinter.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\PercentPrinter.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\UpdateCallbackConsole.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\UpdateCallbackConsole.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\UserInputUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\UserInputUtils.h
-# End Source File
-# End Group
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\resource.rc
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.cpp
-# ADD CPP /Yc"StdAfx.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.h
-# End Source File
-# End Group
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Common\AutoPtr.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Buffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\ComTry.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CrcReg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Defs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\DynamicBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\ListFileUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\ListFileUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyCom.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyException.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyGuidDef.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyInitGuid.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyUnknown.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Sha256Reg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdInStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdInStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdOutStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdOutStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringToInt.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringToInt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Types.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\UTFConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\UTFConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\XzCrc64Init.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\XzCrc64Reg.cpp
-# End Source File
-# End Group
-# Begin Group "Windows"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Defs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Device.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileLink.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileMapping.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileSystem.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileSystem.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Handle.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\MemoryLock.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\MemoryLock.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Thread.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\TimeUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\TimeUtils.h
-# End Source File
-# End Group
-# Begin Group "7zip Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilePathAutoRename.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilePathAutoRename.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InOutTempBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InOutTempBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LockedStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LockedStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\MethodId.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\MethodId.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\MethodProps.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\MethodProps.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OffsetStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OffsetStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\PropId.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\RegisterArc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\RegisterCodec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\UniqBlocks.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\UniqBlocks.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.h
-# End Source File
-# End Group
-# Begin Group "Compress"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Coder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Coder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\ByteSwap.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\ByteSwap.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\DeltaFilter.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Encoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Encoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaEncoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaEncoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\XzDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\XzDecoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\XzEncoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\XzEncoder.h
-# End Source File
-# End Group
-# Begin Group "Archive"
-
-# PROP Default_Filter ""
-# Begin Group "7z"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zCompressionMode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zCompressionMode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zEncode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zEncode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zExtract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zFolderInStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zFolderInStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandlerOut.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHeader.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHeader.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zItem.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zOut.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zOut.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zProperties.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zProperties.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zSpecStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zSpecStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zUpdate.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zUpdate.h
-# End Source File
-# End Group
-# Begin Group "Archive Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\DummyOutStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\DummyOutStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\HandlerOut.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\HandlerOut.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\InStreamWithCRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\InStreamWithCRC.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\MultiStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\MultiStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ParseProperties.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ParseProperties.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\Archive\IArchive.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\LzmaHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\SplitHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\XzHandler.cpp
-# End Source File
-# End Group
-# Begin Group "UI Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveCommandLine.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveCommandLine.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Bench.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Bench.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\EnumDirItems.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\EnumDirItems.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Extract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Extract.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractingFilePath.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\HashCalc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\HashCalc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Property.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\PropIDUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\PropIDUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\SetProperties.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\SetProperties.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\SortUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\SortUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\TempFiles.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\TempFiles.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Update.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Update.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdateAction.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdateAction.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdateCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdateCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdatePair.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdatePair.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdateProduce.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\UpdateProduce.h
-# End Source File
-# End Group
-# Begin Group "7-zip"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\ICoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\IMyUnknown.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\IPassword.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\IProgress.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\IStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\PropID.h
-# End Source File
-# End Group
-# Begin Group "C"
-
-# PROP Default_Filter ""
-# Begin Group "Xz"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Sha256.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Sha256.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Xz.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Xz.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzCrc64.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzCrc64.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzCrc64Opt.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzDec.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzEnc.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzEnc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\XzIn.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrcOpt.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zStream.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Aes.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Aes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\AesOpt.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2Enc.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra86.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\BraIA64.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\IStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFind.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFindMt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFindMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Compress\Lz\LzHash.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzHash.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Enc.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Enc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaEnc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaEnc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtCoder.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.c
-
-!IF "$(CFG)" == "Alone - Win32 Release"
-
-# ADD CPP /O2
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
-
-# SUBTRACT CPP /YX /Yc /Yu
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Types.h
-# End Source File
-# End Group
-# Begin Group "Crypto"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAes.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAesRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\MyAes.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\MyAes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\RandGen.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\RandGen.h
-# End Source File
-# End Group
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="Alone" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Alone - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Alone.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Alone.mak" CFG="Alone - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Alone - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Alone - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "Alone - Win32 ReleaseU" (based on "Win32 (x86) Console Application")
+!MESSAGE "Alone - Win32 DebugU" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MT /W4 /WX /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /FAcs /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7zr.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gr /MDd /W4 /WX /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7zr.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "UNICODE" /D "_UNICODE" /D "WIN32" /D "_CONSOLE" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7za.exe" /opt:NOWIN98
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\UTIL\7zr.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gr /MDd /W4 /Gm /GX /ZI /Od /I "..\..\..\\" /D "_DEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_CONSOLE" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7za.exe" /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\UTIL\7zr.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Alone - Win32 Release"
+# Name "Alone - Win32 Debug"
+# Name "Alone - Win32 ReleaseU"
+# Name "Alone - Win32 DebugU"
+# Begin Group "Console"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Console\BenchCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\BenchCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\CompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ExtractCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ExtractCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\HashCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\HashCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\List.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\List.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\Main.cpp
+# ADD CPP /D "PROG_VARIANT_R"
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\MainAr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\OpenCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\OpenCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\PercentPrinter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\PercentPrinter.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UpdateCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UpdateCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UserInputUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UserInputUtils.h
+# End Source File
+# End Group
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\AutoPtr.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Buffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CrcReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\LzFindPrepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyException.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyGuidDef.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyUnknown.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Types.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Init.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Reg.cpp
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Device.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterArc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterCodec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ByteSwap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeltaFilter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzEncoder.h
+# End Source File
+# End Group
+# Begin Group "Archive"
+
+# PROP Default_Filter ""
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.h
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\LzmaHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SplitHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\XzHandler.cpp
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveCommandLine.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveCommandLine.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\TempFiles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\TempFiles.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Update.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Update.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateProduce.h
+# End Source File
+# End Group
+# Begin Group "7-zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Group "Xz"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Xz.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Xz.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64Opt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzDec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzEnc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzIn.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\AesOpt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2Enc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BraIA64.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindOpt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compress\Lz\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\RotateDefs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\SwapBytes.c
+
+!IF "$(CFG)" == "Alone - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Alone - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\SwapBytes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Crypto"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAesRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAesReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RandGen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RandGen.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/Alone7z/Alone.dsw b/CPP/7zip/Bundles/Alone7z/Alone.dsw
index 036aab4..65eca43 100644
--- a/CPP/7zip/Bundles/Alone7z/Alone.dsw
+++ b/CPP/7zip/Bundles/Alone7z/Alone.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "Alone"=.\Alone.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Alone"=.\Alone.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/Alone7z/StdAfx.cpp b/CPP/7zip/Bundles/Alone7z/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/Alone7z/StdAfx.cpp
+++ b/CPP/7zip/Bundles/Alone7z/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Alone7z/StdAfx.h b/CPP/7zip/Bundles/Alone7z/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Bundles/Alone7z/StdAfx.h
+++ b/CPP/7zip/Bundles/Alone7z/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Alone7z/makefile b/CPP/7zip/Bundles/Alone7z/makefile
index 4f23c10..1f857c5 100644
--- a/CPP/7zip/Bundles/Alone7z/makefile
+++ b/CPP/7zip/Bundles/Alone7z/makefile
@@ -1,154 +1,163 @@
-PROG = 7zr.exe
-CFLAGS = $(CFLAGS) \
- -DPROG_VARIANT_R \
-
-COMMON_OBJS = \
- $O\CommandLineParser.obj \
- $O\CRC.obj \
- $O\CrcReg.obj \
- $O\IntToString.obj \
- $O\ListFileUtils.obj \
- $O\NewHandler.obj \
- $O\StdInStream.obj \
- $O\StdOutStream.obj \
- $O\MyString.obj \
- $O\Sha256Reg.obj \
- $O\StringConvert.obj \
- $O\StringToInt.obj \
- $O\UTFConvert.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
- $O\XzCrc64Init.obj \
- $O\XzCrc64Reg.obj \
-
-WIN_OBJS = \
- $O\DLL.obj \
- $O\ErrorMsg.obj \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileLink.obj \
- $O\FileName.obj \
- $O\FileSystem.obj \
- $O\MemoryLock.obj \
- $O\PropVariant.obj \
- $O\PropVariantConv.obj \
- $O\Synchronization.obj \
- $O\System.obj \
- $O\TimeUtils.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\CWrappers.obj \
- $O\FilePathAutoRename.obj \
- $O\FileStreams.obj \
- $O\InBuffer.obj \
- $O\InOutTempBuffer.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\MethodId.obj \
- $O\MethodProps.obj \
- $O\OffsetStream.obj \
- $O\OutBuffer.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamBinder.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\UniqBlocks.obj \
- $O\VirtThread.obj \
-
-AR_OBJS = \
- $O\LzmaHandler.obj \
- $O\SplitHandler.obj \
- $O\XzHandler.obj \
-
-AR_COMMON_OBJS = \
- $O\CoderMixer2.obj \
- $O\DummyOutStream.obj \
- $O\HandlerOut.obj \
- $O\InStreamWithCRC.obj \
- $O\ItemNameUtils.obj \
- $O\MultiStream.obj \
- $O\OutStreamWithCRC.obj \
- $O\ParseProperties.obj \
-
-
-7Z_OBJS = \
- $O\7zCompressionMode.obj \
- $O\7zDecode.obj \
- $O\7zEncode.obj \
- $O\7zExtract.obj \
- $O\7zFolderInStream.obj \
- $O\7zHandler.obj \
- $O\7zHandlerOut.obj \
- $O\7zHeader.obj \
- $O\7zIn.obj \
- $O\7zOut.obj \
- $O\7zProperties.obj \
- $O\7zRegister.obj \
- $O\7zSpecStream.obj \
- $O\7zUpdate.obj \
-
-COMPRESS_OBJS = \
- $O\Bcj2Coder.obj \
- $O\Bcj2Register.obj \
- $O\BcjCoder.obj \
- $O\BcjRegister.obj \
- $O\BranchMisc.obj \
- $O\BranchRegister.obj \
- $O\ByteSwap.obj \
- $O\CopyCoder.obj \
- $O\CopyRegister.obj \
- $O\DeltaFilter.obj \
- $O\Lzma2Decoder.obj \
- $O\Lzma2Encoder.obj \
- $O\Lzma2Register.obj \
- $O\LzmaDecoder.obj \
- $O\LzmaEncoder.obj \
- $O\LzmaRegister.obj \
- $O\XzDecoder.obj \
- $O\XzEncoder.obj \
-
-CRYPTO_OBJS = \
- $O\7zAes.obj \
- $O\7zAesRegister.obj \
- $O\MyAes.obj \
- $O\MyAesReg.obj \
- $O\RandGen.obj \
-
-C_OBJS = \
- $O\7zStream.obj \
- $O\Alloc.obj \
- $O\Bcj2.obj \
- $O\Bcj2Enc.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\LzFind.obj \
- $O\LzFindMt.obj \
- $O\Lzma2Dec.obj \
- $O\Lzma2DecMt.obj \
- $O\Lzma2Enc.obj \
- $O\LzmaDec.obj \
- $O\LzmaEnc.obj \
- $O\MtCoder.obj \
- $O\MtDec.obj \
- $O\Sha256.obj \
- $O\Sort.obj \
- $O\Threads.obj \
- $O\Xz.obj \
- $O\XzDec.obj \
- $O\XzEnc.obj \
- $O\XzIn.obj \
-
-!include "../../UI/Console/Console.mak"
-
-!include "../../Aes.mak"
-!include "../../Crc.mak"
-!include "../../Crc64.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = 7zr.exe
+
+# USE_C_AES = 1
+# USE_C_SHA = 1
+
+CFLAGS = $(CFLAGS) -DZ7_PROG_VARIANT_R
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\ListFileUtils.obj \
+ $O\LzFindPrepare.obj \
+ $O\NewHandler.obj \
+ $O\StdInStream.obj \
+ $O\StdOutStream.obj \
+ $O\MyString.obj \
+ $O\Sha256Reg.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+ $O\XzCrc64Init.obj \
+ $O\XzCrc64Reg.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileLink.obj \
+ $O\FileName.obj \
+ $O\FileSystem.obj \
+ $O\MemoryLock.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\Registry.obj \
+ $O\System.obj \
+ $O\SystemInfo.obj \
+ $O\TimeUtils.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\InBuffer.obj \
+ $O\InOutTempBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\MultiOutStream.obj \
+ $O\OffsetStream.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\LzmaHandler.obj \
+ $O\SplitHandler.obj \
+ $O\XzHandler.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\DummyOutStream.obj \
+ $O\HandlerOut.obj \
+ $O\InStreamWithCRC.obj \
+ $O\ItemNameUtils.obj \
+ $O\MultiStream.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zEncode.obj \
+ $O\7zExtract.obj \
+ $O\7zFolderInStream.obj \
+ $O\7zHandler.obj \
+ $O\7zHandlerOut.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zOut.obj \
+ $O\7zProperties.obj \
+ $O\7zRegister.obj \
+ $O\7zSpecStream.obj \
+ $O\7zUpdate.obj \
+
+COMPRESS_OBJS = \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Encoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaEncoder.obj \
+ $O\LzmaRegister.obj \
+ $O\XzDecoder.obj \
+ $O\XzEncoder.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\MyAes.obj \
+ $O\MyAesReg.obj \
+ $O\RandGen.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bcj2Enc.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\Lzma2Enc.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\MtCoder.obj \
+ $O\MtDec.obj \
+ $O\Sort.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+ $O\Xz.obj \
+ $O\XzDec.obj \
+ $O\XzEnc.obj \
+ $O\XzIn.obj \
+
+!include "../../UI/Console/Console.mak"
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../Crc64.mak"
+!include "../../LzFindOpt.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha256.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Alone7z/makefile.gcc b/CPP/7zip/Bundles/Alone7z/makefile.gcc
new file mode 100644
index 0000000..6d92c19
--- /dev/null
+++ b/CPP/7zip/Bundles/Alone7z/makefile.gcc
@@ -0,0 +1,276 @@
+PROG = 7zr
+
+CONSOLE_VARIANT_FLAGS=-DZ7_PROG_VARIANT_R
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+include ../../LzmaDec_gcc.mak
+
+
+LOCAL_FLAGS_ST =
+MT_OBJS =
+
+
+ifdef ST_MODE
+
+LOCAL_FLAGS_ST = -DZ7_ST
+
+ifdef IS_MINGW
+MT_OBJS = \
+ $O/Threads.o \
+
+endif
+
+else
+
+MT_OBJS = \
+ $O/LzFindMt.o \
+ $O/LzFindOpt.o \
+ $O/StreamBinder.o \
+ $O/VirtThread.o \
+ $O/Threads.o \
+
+
+
+endif
+
+
+
+LOCAL_FLAGS_SYS =
+
+ifdef IS_MINGW
+
+LOCAL_FLAGS_SYS = \
+ -DZ7_LARGE_PAGES \
+ -DZ7_LONG_PATH \
+ -DZ7_DEVICE_FILE \
+
+SYS_OBJS = \
+ $O/FileSystem.o \
+ $O/Registry.o \
+ $O/MemoryLock.o \
+ $O/DLL.o \
+ $O/DllSecur.o \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+
+endif
+
+LOCAL_FLAGS = \
+ $(LOCAL_FLAGS_ST) \
+ $(LOCAL_FLAGS_SYS) \
+
+
+CONSOLE_OBJS = \
+ $O/BenchCon.o \
+ $O/ConsoleClose.o \
+ $O/DynLimBuf.o \
+ $O/ExtractCallbackConsole.o \
+ $O/HashCon.o \
+ $O/List.o \
+ $O/Main.o \
+ $O/MainAr.o \
+ $O/OpenCallbackConsole.o \
+ $O/PercentPrinter.o \
+ $O/UpdateCallbackConsole.o \
+ $O/UserInputUtils.o \
+
+UI_COMMON_OBJS = \
+ $O/ArchiveCommandLine.o \
+ $O/ArchiveExtractCallback.o \
+ $O/ArchiveOpenCallback.o \
+ $O/Bench.o \
+ $O/DefaultName.o \
+ $O/EnumDirItems.o \
+ $O/Extract.o \
+ $O/ExtractingFilePath.o \
+ $O/HashCalc.o \
+ $O/LoadCodecs.o \
+ $O/OpenArchive.o \
+ $O/PropIDUtils.o \
+ $O/SetProperties.o \
+ $O/SortUtils.o \
+ $O/TempFiles.o \
+ $O/Update.o \
+ $O/UpdateAction.o \
+ $O/UpdateCallback.o \
+ $O/UpdatePair.o \
+ $O/UpdateProduce.o \
+
+COMMON_OBJS = \
+ $O/CommandLineParser.o \
+ $O/CRC.o \
+ $O/CrcReg.o \
+ $O/IntToString.o \
+ $O/ListFileUtils.o \
+ $O/LzFindPrepare.o \
+ $O/MyString.o \
+ $O/MyVector.o \
+ $O/NewHandler.o \
+ $O/Sha256Prepare.o \
+ $O/Sha256Reg.o \
+ $O/StringConvert.o \
+ $O/StringToInt.o \
+ $O/StdInStream.o \
+ $O/StdOutStream.o \
+ $O/UTFConvert.o \
+ $O/Wildcard.o \
+ $O/XzCrc64Init.o \
+ $O/XzCrc64Reg.o \
+
+WIN_OBJS = \
+ $O/ErrorMsg.o \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileIO.o \
+ $O/FileLink.o \
+ $O/FileName.o \
+ $O/PropVariant.o \
+ $O/PropVariantConv.o \
+ $O/System.o \
+ $O/SystemInfo.o \
+ $O/TimeUtils.o \
+
+7ZIP_COMMON_OBJS = \
+ $O/CreateCoder.o \
+ $O/CWrappers.o \
+ $O/FilePathAutoRename.o \
+ $O/FileStreams.o \
+ $O/InBuffer.o \
+ $O/InOutTempBuffer.o \
+ $O/FilterCoder.o \
+ $O/LimitedStreams.o \
+ $O/MethodId.o \
+ $O/MethodProps.o \
+ $O/MultiOutStream.o \
+ $O/OffsetStream.o \
+ $O/OutBuffer.o \
+ $O/ProgressUtils.o \
+ $O/PropId.o \
+ $O/StreamObjects.o \
+ $O/StreamUtils.o \
+ $O/UniqBlocks.o \
+
+AR_OBJS = \
+ $O/LzmaHandler.o \
+ $O/SplitHandler.o \
+ $O/XzHandler.o \
+
+AR_COMMON_OBJS = \
+ $O/CoderMixer2.o \
+ $O/DummyOutStream.o \
+ $O/HandlerOut.o \
+ $O/InStreamWithCRC.o \
+ $O/ItemNameUtils.o \
+ $O/MultiStream.o \
+ $O/OutStreamWithCRC.o \
+ $O/ParseProperties.o \
+
+7Z_OBJS = \
+ $O/7zCompressionMode.o \
+ $O/7zDecode.o \
+ $O/7zEncode.o \
+ $O/7zExtract.o \
+ $O/7zFolderInStream.o \
+ $O/7zHandler.o \
+ $O/7zHandlerOut.o \
+ $O/7zHeader.o \
+ $O/7zIn.o \
+ $O/7zOut.o \
+ $O/7zProperties.o \
+ $O/7zRegister.o \
+ $O/7zSpecStream.o \
+ $O/7zUpdate.o \
+
+COMPRESS_OBJS = \
+ $O/Bcj2Coder.o \
+ $O/Bcj2Register.o \
+ $O/BcjCoder.o \
+ $O/BcjRegister.o \
+ $O/BranchMisc.o \
+ $O/BranchRegister.o \
+ $O/ByteSwap.o \
+ $O/CopyCoder.o \
+ $O/CopyRegister.o \
+ $O/DeltaFilter.o \
+ $O/Lzma2Decoder.o \
+ $O/Lzma2Encoder.o \
+ $O/Lzma2Register.o \
+ $O/LzmaDecoder.o \
+ $O/LzmaEncoder.o \
+ $O/LzmaRegister.o \
+ $O/XzDecoder.o \
+ $O/XzEncoder.o \
+
+CRYPTO_OBJS = \
+ $O/7zAes.o \
+ $O/7zAesRegister.o \
+ $O/MyAes.o \
+ $O/MyAesReg.o \
+ $O/RandGen.o \
+
+C_OBJS = \
+ $O/7zStream.o \
+ $O/Alloc.o \
+ $O/Bcj2.o \
+ $O/Bcj2Enc.o \
+ $O/Bra.o \
+ $O/Bra86.o \
+ $O/BraIA64.o \
+ $O/CpuArch.o \
+ $O/Delta.o \
+ $O/LzFind.o \
+ $O/Lzma2Dec.o \
+ $O/Lzma2DecMt.o \
+ $O/Lzma2Enc.o \
+ $O/LzmaDec.o \
+ $O/LzmaEnc.o \
+ $O/MtCoder.o \
+ $O/MtDec.o \
+ $O/Sha256.o \
+ $O/Sha256Opt.o \
+ $O/SwapBytes.o \
+ $O/Xz.o \
+ $O/XzDec.o \
+ $O/XzEnc.o \
+ $O/XzIn.o \
+ $O/XzCrc64.o \
+ $O/XzCrc64Opt.o \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+ $O/Aes.o \
+ $O/AesOpt.o \
+
+
+OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $(C_OBJS) \
+ $(MT_OBJS) \
+ $(SYS_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(CRYPTO_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(AR_OBJS) \
+ $(AR_COMMON_OBJS) \
+ $(7Z_OBJS) \
+ $(UI_COMMON_OBJS) \
+ $(CONSOLE_OBJS) \
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/Bundles/Alone7z/resource.rc b/CPP/7zip/Bundles/Alone7z/resource.rc
index 36d70e7..5937850 100644
--- a/CPP/7zip/Bundles/Alone7z/resource.rc
+++ b/CPP/7zip/Bundles/Alone7z/resource.rc
@@ -1,7 +1,7 @@
-#include "../../../../C/7zVersion.rc"
-
-MY_VERSION_INFO_APP("7-Zip Reduced Standalone Console", "7zr")
-
-#ifndef UNDER_CE
-1 24 MOVEABLE PURE "../../UI/Console/Console.manifest"
-#endif
+#include "../../../../C/7zVersion.rc"
+
+MY_VERSION_INFO_APP("7-Zip Reduced Standalone Console", "7zr")
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "../../UI/Console/Console.manifest"
+#endif
diff --git a/CPP/7zip/Bundles/Fm/FM.dsp b/CPP/7zip/Bundles/Fm/FM.dsp
new file mode 100644
index 0000000..402dd2c
--- /dev/null
+++ b/CPP/7zip/Bundles/Fm/FM.dsp
@@ -0,0 +1,2251 @@
+# Microsoft Developer Studio Project File - Name="FM" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=FM - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "FM.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "FM.mak" CFG="FM - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "FM - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 ReleaseU" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 DebugU" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "FM - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS_2" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zFM.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "FM - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS_2" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zFM.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "FM - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS_2" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zFM.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "FM - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS_2" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zFM.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "FM - Win32 Release"
+# Name "FM - Win32 Debug"
+# Name "FM - Win32 ReleaseU"
+# Name "FM - Win32 DebugU"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\7zipLogo.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\add.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ClassDefs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Copy.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Delete.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Extract.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FM.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Move.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Parent.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Properties.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\StdAfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Test.bmp
+# End Source File
+# End Group
+# Begin Group "Archive"
+
+# PROP Default_Filter ""
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\FindSignature.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\FindSignature.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.h
+# End Source File
+# End Group
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# End Group
+# Begin Group "Folders"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\AltStreamsFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\AltStreamsFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FSDrives.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FSDrives.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FSFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FSFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FSFolderCopy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\IFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\NetFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\NetFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RootFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RootFolder.h
+# End Source File
+# End Group
+# Begin Group "Registry"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RegistryAssociations.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RegistryAssociations.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RegistryPlugins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RegistryPlugins.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RegistryUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\RegistryUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ViewSettings.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ViewSettings.h
+# End Source File
+# End Group
+# Begin Group "Panel"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\App.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\App.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\AppState.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\EnumFormatEtc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\EnumFormatEtc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FileFolderPluginOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FileFolderPluginOpen.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Panel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Panel.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelCopy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelCrc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelDrag.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelFolderChange.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelItemOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelKey.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelListNotify.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelOperations.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelSelect.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelSort.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PanelSplitFile.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\VerCtrl.cpp
+# End Source File
+# End Group
+# Begin Group "Dialog"
+
+# PROP Default_Filter ""
+# Begin Group "Options"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\EditPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\EditPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FoldersPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FoldersPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LangPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LangPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MenuPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MenuPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OptionsDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SettingsPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SettingsPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SystemPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SystemPage.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\AboutDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\AboutDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\BrowseDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\BrowseDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ComboDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ComboDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\CopyDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\CopyDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\DialogSize.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\EditDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\EditDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LinkDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LinkDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ListViewDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ListViewDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MessagesDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MessagesDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OverwriteDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OverwriteDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PasswordDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PasswordDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgressDialog2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgressDialog2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SplitDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SplitDialog.h
+# End Source File
+# End Group
+# Begin Group "FM Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\HelpUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\HelpUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LangUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LangUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgramLocation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgramLocation.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\UpdateCallback100.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\UpdateCallback100.h
+# End Source File
+# End Group
+# Begin Group "7-Zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+
+!IF "$(CFG)" == "FM - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+
+!IF "$(CFG)" == "FM - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 ReleaseU"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.c
+
+!IF "$(CFG)" == "FM - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "FM - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\CommandBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Edit.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ImageList.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ProgressBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ReBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Static.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\StatusBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ToolBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Trackbar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Window2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Window2.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\COM.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Device.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Net.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Net.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CrcReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Exception.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\LzFindPrepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha1Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha1Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Types.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Init.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Reg.cpp
+# End Source File
+# End Group
+# Begin Group "UI"
+
+# PROP Default_Filter ""
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\CompressCall.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\CompressCall2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\StdAfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\TempFiles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\TempFiles.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Update.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Update.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\UpdateProduce.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\WorkDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\WorkDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ZipRegistry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "Agent"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\Agent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\Agent.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\AgentOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\AgentProxy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\AgentProxy.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\ArchiveFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\ArchiveFolderOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\ArchiveFolderOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\IFolderArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\UpdateCallbackAgent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Agent\UpdateCallbackAgent.h
+# End Source File
+# End Group
+# Begin Group "Explorer"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\ContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\ContextMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\MyMessages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\MyMessages.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\RegistryContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\RegistryContextMenu.h
+# End Source File
+# End Group
+# Begin Group "GUI"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\BenchmarkDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\BenchmarkDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\BenchmarkDialogRes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\CompressDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\CompressDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\HashGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\HashGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\UpdateCallbackGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\UpdateCallbackGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\UpdateCallbackGUI2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\UpdateCallbackGUI2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\UpdateGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\UpdateGUI.h
+# End Source File
+# End Group
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\7zFM.exe.manifest
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\7zipLogo.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Add2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Copy2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Delete2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Extract2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FilePlugins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FilePlugins.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FM.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Info.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Info2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Move2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MyCom2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MyLoadMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\MyLoadMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PluginInterface.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PluginLoader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PropertyName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PropertyName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SplitUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SplitUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\StringUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\StringUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SysIconUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SysIconUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\Test2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\TextPairs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\TextPairs.h
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/Fm/FM.dsw b/CPP/7zip/Bundles/Fm/FM.dsw
new file mode 100644
index 0000000..1c955d9
--- /dev/null
+++ b/CPP/7zip/Bundles/Fm/FM.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "FM"=.\FM.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/Fm/StdAfx.cpp b/CPP/7zip/Bundles/Fm/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Bundles/Fm/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Fm/StdAfx.h b/CPP/7zip/Bundles/Fm/StdAfx.h
new file mode 100644
index 0000000..4f27255
--- /dev/null
+++ b/CPP/7zip/Bundles/Fm/StdAfx.h
@@ -0,0 +1,6 @@
+// StdAfx.h
+
+#if _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../UI/FileManager/StdAfx.h"
diff --git a/CPP/7zip/Bundles/Fm/makefile b/CPP/7zip/Bundles/Fm/makefile
new file mode 100644
index 0000000..33b5320
--- /dev/null
+++ b/CPP/7zip/Bundles/Fm/makefile
@@ -0,0 +1,84 @@
+PROG = 7zFM.exe
+
+CFLAGS = $(CFLAGS) -DZ7_LARGE_PAGES
+
+!include "../Format7zF/Arc.mak"
+
+!include "../../UI/FileManager/FM.mak"
+
+COMMON_OBJS = $(COMMON_OBJS) \
+ $O\CommandLineParser.obj \
+ $O\Lang.obj \
+ $O\ListFileUtils.obj \
+ $O\Random.obj \
+
+WIN_OBJS = $(WIN_OBJS) \
+ $O\Clipboard.obj \
+ $O\CommonDialog.obj \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileLink.obj \
+ $O\MemoryGlobal.obj \
+ $O\MemoryLock.obj \
+ $O\Menu.obj \
+ $O\ProcessUtils.obj \
+ $O\Registry.obj \
+ $O\ResourceString.obj \
+ $O\SystemInfo.obj \
+ $O\Shell.obj \
+ $O\Window.obj \
+
+WIN_CTRL_OBJS = \
+ $O\ComboBox.obj \
+ $O\Dialog.obj \
+ $O\ListView.obj \
+ $O\PropertyPage.obj \
+ $O\Window2.obj \
+
+7ZIP_COMMON_OBJS = $(7ZIP_COMMON_OBJS) \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\MultiOutStream.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveName.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\Bench.obj \
+ $O\CompressCall2.obj \
+ $O\DefaultName.obj \
+ $O\EnumDirItems.obj \
+ $O\Extract.obj \
+ $O\ExtractingFilePath.obj \
+ $O\HashCalc.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+ $O\PropIDUtils.obj \
+ $O\SetProperties.obj \
+ $O\SortUtils.obj \
+ $O\TempFiles.obj \
+ $O\Update.obj \
+ $O\UpdateAction.obj \
+ $O\UpdateCallback.obj \
+ $O\UpdatePair.obj \
+ $O\UpdateProduce.obj \
+ $O\WorkDir.obj \
+ $O\ZipRegistry.obj \
+
+EXPLORER_OBJS = \
+ $O\ContextMenu.obj \
+ $O\MyMessages.obj \
+ $O\RegistryContextMenu.obj \
+
+GUI_OBJS = \
+ $O\BenchmarkDialog.obj \
+ $O\CompressDialog.obj \
+ $O\ExtractDialog.obj \
+ $O\ExtractGUI.obj \
+ $O\HashGUI.obj \
+ $O\UpdateCallbackGUI.obj \
+ $O\UpdateCallbackGUI2.obj \
+ $O\UpdateGUI.obj \
+
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Fm/resource.rc b/CPP/7zip/Bundles/Fm/resource.rc
new file mode 100644
index 0000000..ebc2f74
--- /dev/null
+++ b/CPP/7zip/Bundles/Fm/resource.rc
@@ -0,0 +1,7 @@
+#include "../../UI/FileManager/resource.rc"
+#include "../../UI/GUI/resource2.rc"
+
+STRINGTABLE
+BEGIN
+ 100 "7z zip rar 001 cab iso xz txz lzma tar cpio bz2 bzip2 tbz2 tbz gz gzip tgz tpz z taz lzh lha rpm deb arj vhd vhdx wim swm esd fat ntfs dmg hfs xar squashfs apfs"
+END
diff --git a/CPP/7zip/Bundles/Format7z/StdAfx.cpp b/CPP/7zip/Bundles/Format7z/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7z/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Format7z/StdAfx.h b/CPP/7zip/Bundles/Format7z/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7z/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Format7z/makefile b/CPP/7zip/Bundles/Format7z/makefile
new file mode 100644
index 0000000..d20a3c1
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7z/makefile
@@ -0,0 +1,147 @@
+PROG = 7za.dll
+DEF_FILE = ../../Archive/Archive2.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_DEFLATE_EXTRACT_ONLY \
+ -DZ7_BZIP2_EXTRACT_ONLY \
+
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\IntToString.obj \
+ $O\LzFindPrepare.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\Sha256Reg.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\InBuffer.obj \
+ $O\InOutTempBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\ArchiveExports.obj \
+ $O\DllExports2.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\HandlerOut.obj \
+ $O\InStreamWithCRC.obj \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zEncode.obj \
+ $O\7zExtract.obj \
+ $O\7zFolderInStream.obj \
+ $O\7zHandler.obj \
+ $O\7zHandlerOut.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zOut.obj \
+ $O\7zProperties.obj \
+ $O\7zSpecStream.obj \
+ $O\7zUpdate.obj \
+ $O\7zRegister.obj \
+
+
+COMPRESS_OBJS = \
+ $O\CodecExports.obj \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BitlDecoder.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\BZip2Crc.obj \
+ $O\BZip2Decoder.obj \
+ $O\BZip2Register.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeflateDecoder.obj \
+ $O\DeflateRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Encoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaEncoder.obj \
+ $O\LzmaRegister.obj \
+ $O\LzOutWindow.obj \
+ $O\PpmdDecoder.obj \
+ $O\PpmdEncoder.obj \
+ $O\PpmdRegister.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\MyAes.obj \
+ $O\MyAesReg.obj \
+ $O\RandGen.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bcj2Enc.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\BwtSort.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\HuffEnc.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\Lzma2Enc.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\MtCoder.obj \
+ $O\MtDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+ $O\Ppmd7Enc.obj \
+ $O\Sort.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../LzFindOpt.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha256.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7z/resource.rc b/CPP/7zip/Bundles/Format7z/resource.rc
new file mode 100644
index 0000000..2f2b42a
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7z/resource.rc
@@ -0,0 +1,5 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_DLL("7z Standalone Plugin", "7za")
+
+101 ICON "../../Archive/Icons/7z.ico"
diff --git a/CPP/7zip/Bundles/Format7zExtract/StdAfx.cpp b/CPP/7zip/Bundles/Format7zExtract/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zExtract/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Format7zExtract/StdAfx.h b/CPP/7zip/Bundles/Format7zExtract/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zExtract/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Format7zExtract/makefile b/CPP/7zip/Bundles/Format7zExtract/makefile
new file mode 100644
index 0000000..4e2ed3e
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zExtract/makefile
@@ -0,0 +1,116 @@
+PROG = 7zxa.dll
+DEF_FILE = ../../Archive/Archive2.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTRACT_ONLY \
+
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\IntToString.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\NewHandler.obj \
+ $O\Sha256Reg.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\PropVariant.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\InBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\ArchiveExports.obj \
+ $O\DllExports2.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\HandlerOut.obj \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zExtract.obj \
+ $O\7zHandler.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zProperties.obj \
+ $O\7zRegister.obj \
+
+
+COMPRESS_OBJS = \
+ $O\CodecExports.obj \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BitlDecoder.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\BZip2Crc.obj \
+ $O\BZip2Decoder.obj \
+ $O\BZip2Register.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeflateDecoder.obj \
+ $O\DeflateRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaRegister.obj \
+ $O\LzOutWindow.obj \
+ $O\PpmdDecoder.obj \
+ $O\PpmdRegister.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\MyAes.obj \
+ $O\MyAesReg.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\LzmaDec.obj \
+ $O\MtDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha256.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7zExtract/resource.rc b/CPP/7zip/Bundles/Format7zExtract/resource.rc
new file mode 100644
index 0000000..6a65461
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zExtract/resource.rc
@@ -0,0 +1,5 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_DLL("7z Standalone Extracting Plugin", "7zxa")
+
+101 ICON "../../Archive/Icons/7z.ico"
diff --git a/CPP/7zip/Bundles/Format7zExtractR/StdAfx.cpp b/CPP/7zip/Bundles/Format7zExtractR/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/Format7zExtractR/StdAfx.cpp
+++ b/CPP/7zip/Bundles/Format7zExtractR/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Format7zExtractR/StdAfx.h b/CPP/7zip/Bundles/Format7zExtractR/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Bundles/Format7zExtractR/StdAfx.h
+++ b/CPP/7zip/Bundles/Format7zExtractR/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Format7zExtractR/makefile b/CPP/7zip/Bundles/Format7zExtractR/makefile
index 3a7f981..50b84d8 100644
--- a/CPP/7zip/Bundles/Format7zExtractR/makefile
+++ b/CPP/7zip/Bundles/Format7zExtractR/makefile
@@ -1,96 +1,98 @@
-PROG = 7zxr.dll
-DEF_FILE = ../../Archive/Archive2.def
-CFLAGS = $(CFLAGS) \
- -DEXTRACT_ONLY \
- -D_NO_CRYPTO
-
-COMMON_OBJS = \
- $O\CRC.obj \
- $O\CrcReg.obj \
- $O\IntToString.obj \
- $O\NewHandler.obj \
- $O\MyString.obj \
- $O\StringConvert.obj \
- $O\StringToInt.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
-
-WIN_OBJS = \
- $O\PropVariant.obj \
- $O\Synchronization.obj \
- $O\System.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\CWrappers.obj \
- $O\InBuffer.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\MethodId.obj \
- $O\MethodProps.obj \
- $O\OutBuffer.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamBinder.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\VirtThread.obj \
-
-AR_OBJS = \
- $O\ArchiveExports.obj \
- $O\DllExports2.obj \
-
-AR_COMMON_OBJS = \
- $O\CoderMixer2.obj \
- $O\HandlerOut.obj \
- $O\ItemNameUtils.obj \
- $O\OutStreamWithCRC.obj \
- $O\ParseProperties.obj \
-
-
-7Z_OBJS = \
- $O\7zCompressionMode.obj \
- $O\7zDecode.obj \
- $O\7zExtract.obj \
- $O\7zHandler.obj \
- $O\7zHeader.obj \
- $O\7zIn.obj \
- $O\7zProperties.obj \
- $O\7zRegister.obj \
-
-
-COMPRESS_OBJS = \
- $O\CodecExports.obj \
- $O\Bcj2Coder.obj \
- $O\Bcj2Register.obj \
- $O\BcjCoder.obj \
- $O\BcjRegister.obj \
- $O\BranchMisc.obj \
- $O\BranchRegister.obj \
- $O\ByteSwap.obj \
- $O\CopyCoder.obj \
- $O\CopyRegister.obj \
- $O\DeltaFilter.obj \
- $O\Lzma2Decoder.obj \
- $O\Lzma2Register.obj \
- $O\LzmaDecoder.obj \
- $O\LzmaRegister.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\Lzma2Dec.obj \
- $O\Lzma2DecMt.obj \
- $O\LzmaDec.obj \
- $O\MtDec.obj \
- $O\Threads.obj \
-
-!include "../../Crc.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = 7zxr.dll
+DEF_FILE = ../../Archive/Archive2.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTRACT_ONLY \
+ -DZ7_NO_CRYPTO
+
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\IntToString.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\PropVariant.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\InBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\ArchiveExports.obj \
+ $O\DllExports2.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\HandlerOut.obj \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zExtract.obj \
+ $O\7zHandler.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zProperties.obj \
+ $O\7zRegister.obj \
+
+
+COMPRESS_OBJS = \
+ $O\CodecExports.obj \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaRegister.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\LzmaDec.obj \
+ $O\MtDec.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+!include "../../LzmaDec.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7zExtractR/resource.rc b/CPP/7zip/Bundles/Format7zExtractR/resource.rc
index dac02a6..149f58c 100644
--- a/CPP/7zip/Bundles/Format7zExtractR/resource.rc
+++ b/CPP/7zip/Bundles/Format7zExtractR/resource.rc
@@ -1,5 +1,5 @@
-#include "../../../../C/7zVersion.rc"
-
-MY_VERSION_INFO_DLL("7z Extracting Reduced Standalone Plugin", "7zxr")
-
-101 ICON "../../Archive/Icons/7z.ico"
+#include "../../../../C/7zVersion.rc"
+
+MY_VERSION_INFO_DLL("7z Extracting Reduced Standalone Plugin", "7zxr")
+
+101 ICON "../../Archive/Icons/7z.ico"
diff --git a/CPP/7zip/Bundles/Format7zF/Arc.mak b/CPP/7zip/Bundles/Format7zF/Arc.mak
new file mode 100644
index 0000000..37b400e
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/Arc.mak
@@ -0,0 +1,297 @@
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\LzFindPrepare.obj \
+ $O\MyMap.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\MyXml.obj \
+ $O\NewHandler.obj \
+ $O\Sha1Reg.obj \
+ $O\Sha256Reg.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\Wildcard.obj \
+ $O\XzCrc64Init.obj \
+ $O\XzCrc64Reg.obj \
+
+WIN_OBJS = \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\PropVariantUtils.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\TimeUtils.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\InBuffer.obj \
+ $O\InOutTempBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\LockedStream.obj \
+ $O\MemBlocks.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\OffsetStream.obj \
+ $O\OutBuffer.obj \
+ $O\OutMemStream.obj \
+ $O\ProgressMt.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\ApfsHandler.obj \
+ $O\ApmHandler.obj \
+ $O\ArHandler.obj \
+ $O\ArjHandler.obj \
+ $O\Base64Handler.obj \
+ $O\Bz2Handler.obj \
+ $O\ComHandler.obj \
+ $O\CpioHandler.obj \
+ $O\CramfsHandler.obj \
+ $O\DeflateProps.obj \
+ $O\DmgHandler.obj \
+ $O\ElfHandler.obj \
+ $O\ExtHandler.obj \
+ $O\FatHandler.obj \
+ $O\FlvHandler.obj \
+ $O\GzHandler.obj \
+ $O\GptHandler.obj \
+ $O\HandlerCont.obj \
+ $O\HfsHandler.obj \
+ $O\IhexHandler.obj \
+ $O\LpHandler.obj \
+ $O\LzhHandler.obj \
+ $O\LzmaHandler.obj \
+ $O\MachoHandler.obj \
+ $O\MbrHandler.obj \
+ $O\MslzHandler.obj \
+ $O\MubHandler.obj \
+ $O\NtfsHandler.obj \
+ $O\PeHandler.obj \
+ $O\PpmdHandler.obj \
+ $O\QcowHandler.obj \
+ $O\RpmHandler.obj \
+ $O\SparseHandler.obj \
+ $O\SplitHandler.obj \
+ $O\SquashfsHandler.obj \
+ $O\SwfHandler.obj \
+ $O\UefiHandler.obj \
+ $O\VdiHandler.obj \
+ $O\VhdHandler.obj \
+ $O\VhdxHandler.obj \
+ $O\VmdkHandler.obj \
+ $O\XarHandler.obj \
+ $O\XzHandler.obj \
+ $O\ZHandler.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\DummyOutStream.obj \
+ $O\FindSignature.obj \
+ $O\InStreamWithCRC.obj \
+ $O\ItemNameUtils.obj \
+ $O\MultiStream.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\OutStreamWithSha1.obj \
+ $O\HandlerOut.obj \
+ $O\ParseProperties.obj \
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zEncode.obj \
+ $O\7zExtract.obj \
+ $O\7zFolderInStream.obj \
+ $O\7zHandler.obj \
+ $O\7zHandlerOut.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zOut.obj \
+ $O\7zProperties.obj \
+ $O\7zSpecStream.obj \
+ $O\7zUpdate.obj \
+ $O\7zRegister.obj \
+
+CAB_OBJS = \
+ $O\CabBlockInStream.obj \
+ $O\CabHandler.obj \
+ $O\CabHeader.obj \
+ $O\CabIn.obj \
+ $O\CabRegister.obj \
+
+CHM_OBJS = \
+ $O\ChmHandler.obj \
+ $O\ChmIn.obj \
+
+ISO_OBJS = \
+ $O\IsoHandler.obj \
+ $O\IsoHeader.obj \
+ $O\IsoIn.obj \
+ $O\IsoRegister.obj \
+
+NSIS_OBJS = \
+ $O\NsisDecode.obj \
+ $O\NsisHandler.obj \
+ $O\NsisIn.obj \
+ $O\NsisRegister.obj \
+
+RAR_OBJS = \
+ $O\RarHandler.obj \
+ $O\Rar5Handler.obj \
+
+TAR_OBJS = \
+ $O\TarHandler.obj \
+ $O\TarHandlerOut.obj \
+ $O\TarHeader.obj \
+ $O\TarIn.obj \
+ $O\TarOut.obj \
+ $O\TarUpdate.obj \
+ $O\TarRegister.obj \
+
+UDF_OBJS = \
+ $O\UdfHandler.obj \
+ $O\UdfIn.obj \
+
+WIM_OBJS = \
+ $O\WimHandler.obj \
+ $O\WimHandlerOut.obj \
+ $O\WimIn.obj \
+ $O\WimRegister.obj \
+
+ZIP_OBJS = \
+ $O\ZipAddCommon.obj \
+ $O\ZipHandler.obj \
+ $O\ZipHandlerOut.obj \
+ $O\ZipIn.obj \
+ $O\ZipItem.obj \
+ $O\ZipOut.obj \
+ $O\ZipUpdate.obj \
+ $O\ZipRegister.obj \
+
+COMPRESS_OBJS = \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BitlDecoder.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\BZip2Crc.obj \
+ $O\BZip2Decoder.obj \
+ $O\BZip2Encoder.obj \
+ $O\BZip2Register.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\Deflate64Register.obj \
+ $O\DeflateDecoder.obj \
+ $O\DeflateEncoder.obj \
+ $O\DeflateRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\ImplodeDecoder.obj \
+ $O\LzfseDecoder.obj \
+ $O\LzhDecoder.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Encoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaEncoder.obj \
+ $O\LzmaRegister.obj \
+ $O\LzmsDecoder.obj \
+ $O\LzOutWindow.obj \
+ $O\LzxDecoder.obj \
+ $O\PpmdDecoder.obj \
+ $O\PpmdEncoder.obj \
+ $O\PpmdRegister.obj \
+ $O\PpmdZip.obj \
+ $O\QuantumDecoder.obj \
+ $O\Rar1Decoder.obj \
+ $O\Rar2Decoder.obj \
+ $O\Rar3Decoder.obj \
+ $O\Rar3Vm.obj \
+ $O\Rar5Decoder.obj \
+ $O\RarCodecsRegister.obj \
+ $O\ShrinkDecoder.obj \
+ $O\XpressDecoder.obj \
+ $O\XzDecoder.obj \
+ $O\XzEncoder.obj \
+ $O\ZlibDecoder.obj \
+ $O\ZlibEncoder.obj \
+ $O\ZDecoder.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\HmacSha1.obj \
+ $O\HmacSha256.obj \
+ $O\MyAes.obj \
+ $O\MyAesReg.obj \
+ $O\Pbkdf2HmacSha1.obj \
+ $O\RandGen.obj \
+ $O\Rar20Crypto.obj \
+ $O\Rar5Aes.obj \
+ $O\RarAes.obj \
+ $O\WzAes.obj \
+ $O\ZipCrypto.obj \
+ $O\ZipStrong.obj \
+
+C_OBJS = \
+ $O\7zBuf2.obj \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bcj2Enc.obj \
+ $O\Blake2s.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\BwtSort.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\HuffEnc.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\Lzma2Enc.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\MtCoder.obj \
+ $O\MtDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+ $O\Ppmd7aDec.obj \
+ $O\Ppmd7Enc.obj \
+ $O\Ppmd8.obj \
+ $O\Ppmd8Dec.obj \
+ $O\Ppmd8Enc.obj \
+ $O\Sort.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+ $O\Xz.obj \
+ $O\XzDec.obj \
+ $O\XzEnc.obj \
+ $O\XzIn.obj \
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../Crc64.mak"
+!include "../../LzFindOpt.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha1.mak"
+!include "../../Sha256.mak"
diff --git a/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak b/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak
new file mode 100644
index 0000000..404d917
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/Arc_gcc.mak
@@ -0,0 +1,379 @@
+include ../../LzmaDec_gcc.mak
+
+LOCAL_FLAGS_ST =
+MT_OBJS =
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef ST_MODE
+
+LOCAL_FLAGS_ST = -DZ7_ST
+
+ifdef IS_MINGW
+MT_OBJS = \
+ $O/Threads.o \
+
+endif
+
+else
+
+MT_OBJS = \
+ $O/LzFindMt.o \
+ $O/LzFindOpt.o \
+ $O/StreamBinder.o \
+ $O/Synchronization.o \
+ $O/VirtThread.o \
+ $O/MemBlocks.o \
+ $O/OutMemStream.o \
+ $O/ProgressMt.o \
+ $O/Threads.o \
+
+endif
+
+
+
+COMMON_OBJS = \
+ $O/CRC.o \
+ $O/CrcReg.o \
+ $O/DynLimBuf.o \
+ $O/IntToString.o \
+ $O/LzFindPrepare.o \
+ $O/MyMap.o \
+ $O/MyString.o \
+ $O/MyVector.o \
+ $O/MyXml.o \
+ $O/NewHandler.o \
+ $O/Sha1Prepare.o \
+ $O/Sha1Reg.o \
+ $O/Sha256Prepare.o \
+ $O/Sha256Reg.o \
+ $O/StringConvert.o \
+ $O/StringToInt.o \
+ $O/UTFConvert.o \
+ $O/Wildcard.o \
+ $O/XzCrc64Init.o \
+ $O/XzCrc64Reg.o \
+
+WIN_OBJS = \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileIO.o \
+ $O/FileName.o \
+ $O/PropVariant.o \
+ $O/PropVariantConv.o \
+ $O/PropVariantUtils.o \
+ $O/System.o \
+ $O/TimeUtils.o \
+
+7ZIP_COMMON_OBJS = \
+ $O/CreateCoder.o \
+ $O/CWrappers.o \
+ $O/InBuffer.o \
+ $O/InOutTempBuffer.o \
+ $O/FilterCoder.o \
+ $O/LimitedStreams.o \
+ $O/LockedStream.o \
+ $O/MethodId.o \
+ $O/MethodProps.o \
+ $O/OffsetStream.o \
+ $O/OutBuffer.o \
+ $O/ProgressUtils.o \
+ $O/PropId.o \
+ $O/StreamObjects.o \
+ $O/StreamUtils.o \
+ $O/UniqBlocks.o \
+
+AR_OBJS = \
+ $O/ApfsHandler.o \
+ $O/ApmHandler.o \
+ $O/ArHandler.o \
+ $O/ArjHandler.o \
+ $O/Base64Handler.o \
+ $O/Bz2Handler.o \
+ $O/ComHandler.o \
+ $O/CpioHandler.o \
+ $O/CramfsHandler.o \
+ $O/DeflateProps.o \
+ $O/DmgHandler.o \
+ $O/ElfHandler.o \
+ $O/ExtHandler.o \
+ $O/FatHandler.o \
+ $O/FlvHandler.o \
+ $O/GzHandler.o \
+ $O/GptHandler.o \
+ $O/HandlerCont.o \
+ $O/HfsHandler.o \
+ $O/IhexHandler.o \
+ $O/LpHandler.o \
+ $O/LzhHandler.o \
+ $O/LzmaHandler.o \
+ $O/MachoHandler.o \
+ $O/MbrHandler.o \
+ $O/MslzHandler.o \
+ $O/MubHandler.o \
+ $O/NtfsHandler.o \
+ $O/PeHandler.o \
+ $O/PpmdHandler.o \
+ $O/QcowHandler.o \
+ $O/RpmHandler.o \
+ $O/SparseHandler.o \
+ $O/SplitHandler.o \
+ $O/SquashfsHandler.o \
+ $O/SwfHandler.o \
+ $O/UefiHandler.o \
+ $O/VdiHandler.o \
+ $O/VhdHandler.o \
+ $O/VhdxHandler.o \
+ $O/VmdkHandler.o \
+ $O/XarHandler.o \
+ $O/XzHandler.o \
+ $O/ZHandler.o \
+
+AR_COMMON_OBJS = \
+ $O/CoderMixer2.o \
+ $O/DummyOutStream.o \
+ $O/FindSignature.o \
+ $O/InStreamWithCRC.o \
+ $O/ItemNameUtils.o \
+ $O/MultiStream.o \
+ $O/OutStreamWithCRC.o \
+ $O/OutStreamWithSha1.o \
+ $O/HandlerOut.o \
+ $O/ParseProperties.o \
+
+
+7Z_OBJS = \
+ $O/7zCompressionMode.o \
+ $O/7zDecode.o \
+ $O/7zEncode.o \
+ $O/7zExtract.o \
+ $O/7zFolderInStream.o \
+ $O/7zHandler.o \
+ $O/7zHandlerOut.o \
+ $O/7zHeader.o \
+ $O/7zIn.o \
+ $O/7zOut.o \
+ $O/7zProperties.o \
+ $O/7zSpecStream.o \
+ $O/7zUpdate.o \
+ $O/7zRegister.o \
+
+CAB_OBJS = \
+ $O/CabBlockInStream.o \
+ $O/CabHandler.o \
+ $O/CabHeader.o \
+ $O/CabIn.o \
+ $O/CabRegister.o \
+
+CHM_OBJS = \
+ $O/ChmHandler.o \
+ $O/ChmIn.o \
+
+ISO_OBJS = \
+ $O/IsoHandler.o \
+ $O/IsoHeader.o \
+ $O/IsoIn.o \
+ $O/IsoRegister.o \
+
+NSIS_OBJS = \
+ $O/NsisDecode.o \
+ $O/NsisHandler.o \
+ $O/NsisIn.o \
+ $O/NsisRegister.o \
+
+ifndef DISABLE_RAR
+RAR_OBJS = \
+ $O/RarHandler.o \
+ $O/Rar5Handler.o \
+
+endif
+
+
+TAR_OBJS = \
+ $O/TarHandler.o \
+ $O/TarHandlerOut.o \
+ $O/TarHeader.o \
+ $O/TarIn.o \
+ $O/TarOut.o \
+ $O/TarUpdate.o \
+ $O/TarRegister.o \
+
+UDF_OBJS = \
+ $O/UdfHandler.o \
+ $O/UdfIn.o \
+
+WIM_OBJS = \
+ $O/WimHandler.o \
+ $O/WimHandlerOut.o \
+ $O/WimIn.o \
+ $O/WimRegister.o \
+
+ZIP_OBJS = \
+ $O/ZipAddCommon.o \
+ $O/ZipHandler.o \
+ $O/ZipHandlerOut.o \
+ $O/ZipIn.o \
+ $O/ZipItem.o \
+ $O/ZipOut.o \
+ $O/ZipUpdate.o \
+ $O/ZipRegister.o \
+
+COMPRESS_OBJS = \
+ $O/Bcj2Coder.o \
+ $O/Bcj2Register.o \
+ $O/BcjCoder.o \
+ $O/BcjRegister.o \
+ $O/BitlDecoder.o \
+ $O/BranchMisc.o \
+ $O/BranchRegister.o \
+ $O/ByteSwap.o \
+ $O/BZip2Crc.o \
+ $O/BZip2Decoder.o \
+ $O/BZip2Encoder.o \
+ $O/BZip2Register.o \
+ $O/CopyCoder.o \
+ $O/CopyRegister.o \
+ $O/Deflate64Register.o \
+ $O/DeflateDecoder.o \
+ $O/DeflateEncoder.o \
+ $O/DeflateRegister.o \
+ $O/DeltaFilter.o \
+ $O/ImplodeDecoder.o \
+ $O/LzfseDecoder.o \
+ $O/LzhDecoder.o \
+ $O/Lzma2Decoder.o \
+ $O/Lzma2Encoder.o \
+ $O/Lzma2Register.o \
+ $O/LzmaDecoder.o \
+ $O/LzmaEncoder.o \
+ $O/LzmaRegister.o \
+ $O/LzmsDecoder.o \
+ $O/LzOutWindow.o \
+ $O/LzxDecoder.o \
+ $O/PpmdDecoder.o \
+ $O/PpmdEncoder.o \
+ $O/PpmdRegister.o \
+ $O/PpmdZip.o \
+ $O/QuantumDecoder.o \
+ $O/ShrinkDecoder.o \
+ $O/XpressDecoder.o \
+ $O/XzDecoder.o \
+ $O/XzEncoder.o \
+ $O/ZlibDecoder.o \
+ $O/ZlibEncoder.o \
+ $O/ZDecoder.o \
+
+ifdef DISABLE_RAR
+DISABLE_RAR_COMPRESS=1
+endif
+
+ifndef DISABLE_RAR_COMPRESS
+COMPRESS_OBJS += \
+ $O/Rar1Decoder.o \
+ $O/Rar2Decoder.o \
+ $O/Rar3Decoder.o \
+ $O/Rar3Vm.o \
+ $O/Rar5Decoder.o \
+ $O/RarCodecsRegister.o \
+
+endif
+
+CRYPTO_OBJS = \
+ $O/7zAes.o \
+ $O/7zAesRegister.o \
+ $O/HmacSha1.o \
+ $O/HmacSha256.o \
+ $O/MyAes.o \
+ $O/MyAesReg.o \
+ $O/Pbkdf2HmacSha1.o \
+ $O/RandGen.o \
+ $O/WzAes.o \
+ $O/ZipCrypto.o \
+ $O/ZipStrong.o \
+
+ifndef DISABLE_RAR
+CRYPTO_OBJS += \
+ $O/Rar20Crypto.o \
+ $O/Rar5Aes.o \
+ $O/RarAes.o \
+
+endif
+
+
+C_OBJS = \
+ $O/7zBuf2.o \
+ $O/7zStream.o \
+ $O/Alloc.o \
+ $O/Bcj2.o \
+ $O/Bcj2Enc.o \
+ $O/Blake2s.o \
+ $O/Bra.o \
+ $O/Bra86.o \
+ $O/BraIA64.o \
+ $O/BwtSort.o \
+ $O/CpuArch.o \
+ $O/Delta.o \
+ $O/HuffEnc.o \
+ $O/LzFind.o \
+ $O/Lzma2Dec.o \
+ $O/Lzma2DecMt.o \
+ $O/Lzma2Enc.o \
+ $O/LzmaDec.o \
+ $O/LzmaEnc.o \
+ $O/MtCoder.o \
+ $O/MtDec.o \
+ $O/Ppmd7.o \
+ $O/Ppmd7Dec.o \
+ $O/Ppmd7aDec.o \
+ $O/Ppmd7Enc.o \
+ $O/Ppmd8.o \
+ $O/Ppmd8Dec.o \
+ $O/Ppmd8Enc.o \
+ $O/Sort.o \
+ $O/Xz.o \
+ $O/XzDec.o \
+ $O/XzEnc.o \
+ $O/XzIn.o \
+ $O/XzCrc64.o \
+ $O/XzCrc64Opt.o \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+ $O/Aes.o \
+ $O/AesOpt.o \
+ $O/Sha256.o \
+ $O/Sha256Opt.o \
+ $O/Sha1.o \
+ $O/Sha1Opt.o \
+ $O/SwapBytes.o \
+
+ARC_OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $(C_OBJS) \
+ $(MT_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(AR_OBJS) \
+ $(AR_COMMON_OBJS) \
+ $(7Z_OBJS) \
+ $(CAB_OBJS) \
+ $(CHM_OBJS) \
+ $(COM_OBJS) \
+ $(ISO_OBJS) \
+ $(NSIS_OBJS) \
+ $(RAR_OBJS) \
+ $(TAR_OBJS) \
+ $(UDF_OBJS) \
+ $(WIM_OBJS) \
+ $(ZIP_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(CRYPTO_OBJS) \
+
+# we need empty line after last line above
diff --git a/CPP/7zip/Bundles/Format7zF/Format7z.dsp b/CPP/7zip/Bundles/Format7zF/Format7z.dsp
new file mode 100644
index 0000000..a0c5d83
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/Format7z.dsp
@@ -0,0 +1,3266 @@
+# Microsoft Developer Studio Project File - Name="7z" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=7z - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Format7z.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Format7z.mak" CFG="7z - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "7z - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "7z - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /D "Z7_EXTERNAL_CODECS" /D "Z7_LARGE_PAGES" /D "Z7_ST_9" /FAcs /Yu"StdAfx.h" /FD /GF /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"C:\Util\7z.dll" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none /debug
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gr /MTd /W4 /WX /Gm /GX /ZI /Od /I "..\..\..\..\SDK" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "MY7Z_EXPORTS" /D "Z7_EXTERNAL_CODECS" /D "Z7_LARGE_PAGES" /D "Z7_ST_9" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"C:\Util\7z.dll" /pdbtype:sept /ignore:4033
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF
+
+# Begin Target
+
+# Name "7z - Win32 Release"
+# Name "7z - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Group "Icons"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\7z.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\arj.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\bz2.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\cab.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\cpio.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\deb.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\dmg.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\fat.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\gz.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\hfs.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\iso.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\lzh.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\lzma.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\ntfs.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\rar.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\rpm.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\split.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\squashfs.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\tar.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\vhd.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\wim.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\xar.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\xz.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\z.ico
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Icons\zip.ico
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Archive\Archive2.def
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ArchiveExports.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CodecExports.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\DllExports2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CrcReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\LzFindPrepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyException.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyLinux.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyMap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyMap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyUnknown.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyXml.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyXml.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha1Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha1Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Reg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Init.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\XzCrc64Reg.cpp
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Group "Bit Coder"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\BitlDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitlDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitlEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitmDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BitmEncoder.h
+# End Source File
+# End Group
+# Begin Group "Rar Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar1Decoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar1Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar2Decoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar3Decoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar3Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar3Vm.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar3Vm.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar5Decoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Rar5Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\RarCodecsRegister.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "BZip2 Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Const.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Crc.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Crc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Decoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Encoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Encoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BZip2Register.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Mtf8.h
+# End Source File
+# End Group
+# Begin Group "Zip Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Deflate64Register.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateConst.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateEncoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeflateRegister.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ImplodeDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ImplodeDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdZip.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdZip.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ShrinkDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ShrinkDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ZlibDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ZlibDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ZlibEncoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ZlibEncoder.h
+# End Source File
+# End Group
+# Begin Group "7z Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ByteSwap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeltaFilter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Encoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdEncoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Cab Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzxDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzxDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\QuantumDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\QuantumDecoder.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Compress\HuffmanDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzfseDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzfseDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzhDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzhDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmsDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmsDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzOutWindow.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzOutWindow.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XpressDecoder.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XpressDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\XzEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ZDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\ZDecoder.h
+# End Source File
+# End Group
+# Begin Group "Crypto"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAesRegister.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\HmacSha1.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\HmacSha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\HmacSha256.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\HmacSha256.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAesReg.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Pbkdf2HmacSha1.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Pbkdf2HmacSha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RandGen.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RandGen.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Rar20Crypto.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Rar20Crypto.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Rar5Aes.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Rar5Aes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RarAes.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\RarAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\Sha1Cls.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\WzAes.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\WzAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipCrypto.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipCrypto.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipStrong.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\ZipStrong.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InOutTempBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MemBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MemBlocks.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodId.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutMemStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutMemStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressMt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterArc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterCodec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Group "xz"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Xz.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /W4
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# ADD CPP /W4 /WX
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Xz.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /W4 /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# ADD CPP /W4 /WX
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzCrc64Opt.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzDec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /W4
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# ADD CPP /W4 /WX
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzEnc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\XzIn.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /W4
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# ADD CPP /W4 /WX
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zBuf2.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2Enc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Blake2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Blake2s.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BraIA64.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BwtSort.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BwtSort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\HuffEnc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\HuffEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindOpt.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Enc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7aDec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7Dec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7Enc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8Dec.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd8Enc.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Precomp.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\RotateDefs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\SwapBytes.c
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\SwapBytes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Archive"
+
+# PROP Default_Filter ""
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zEncode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zFolderInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zSpecStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdate.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zUpdateItem.h
+# End Source File
+# End Group
+# Begin Group "Rar"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\Rar5Handler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\Rar5Handler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\RarHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\RarHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\RarHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\RarItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Rar\RarVol.h
+# End Source File
+# End Group
+# Begin Group "Cab"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabBlockInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabBlockInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Cab\CabRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Chm"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Chm\ChmHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Chm\ChmHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Chm\ChmIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Chm\ChmIn.h
+# End Source File
+# End Group
+# Begin Group "Archive common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\DummyOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\FindSignature.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\FindSignature.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\InStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithSha1.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithSha1.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ParseProperties.h
+# End Source File
+# End Group
+# Begin Group "Iso"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Iso\IsoRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Nsis"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Nsis\NsisRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Tar"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHeader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Tar\TarUpdate.h
+# End Source File
+# End Group
+# Begin Group "Zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipAddCommon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipAddCommon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipCompressionMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipItem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipUpdate.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Zip\ZipUpdate.h
+# End Source File
+# End Group
+# Begin Group "Wim"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Wim\WimHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Wim\WimHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Wim\WimHandlerOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Wim\WimIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Wim\WimIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Wim\WimRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Udf"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Udf\UdfHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Udf\UdfHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Udf\UdfIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Udf\UdfIn.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\Archive\ApfsHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ApmHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ArHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ArjHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Base64Handler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Bz2Handler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ComHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\CpioHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\CramfsHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\DeflateProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\DeflateProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\DmgHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ElfHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ExtHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\FatHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\FlvHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\GptHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\GzHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\HandlerCont.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\HandlerCont.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\HfsHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\HfsHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\IhexHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\LpHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\LzhHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\LzmaHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\MachoHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\MbrHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\MslzHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\MubHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\NtfsHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\PeHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\PpmdHandler.cpp
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\QcowHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\RpmHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SparseHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SplitHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SquashfsHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SwfHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\UefiHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\VdiHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\VhdHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\VhdxHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\VmdkHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\XarHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\XzHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\XzHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\ZHandler.cpp
+# End Source File
+# End Group
+# Begin Group "7zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\MyVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# End Group
+# Begin Group "Asm"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\7zAsm.asm
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\7zCrcOpt.asm
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# Begin Custom Build
+OutDir=.\Release
+InputPath=..\..\..\..\Asm\x86\7zCrcOpt.asm
+InputName=7zCrcOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# Begin Custom Build
+OutDir=.\Debug
+InputPath=..\..\..\..\Asm\x86\7zCrcOpt.asm
+InputName=7zCrcOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -omf -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\AesOpt.asm
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+# Begin Custom Build
+OutDir=.\Release
+InputPath=..\..\..\..\Asm\x86\AesOpt.asm
+InputName=AesOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# PROP Ignore_Default_Tool 1
+# Begin Custom Build
+OutDir=.\Debug
+InputPath=..\..\..\..\Asm\x86\AesOpt.asm
+InputName=AesOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -omf -WX -W3 -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\Sha1Opt.asm
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# Begin Custom Build
+OutDir=.\Release
+InputPath=..\..\..\..\Asm\x86\Sha1Opt.asm
+InputName=Sha1Opt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# Begin Custom Build
+OutDir=.\Debug
+InputPath=..\..\..\..\Asm\x86\Sha1Opt.asm
+InputName=Sha1Opt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -omf -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\Sha256Opt.asm
+
+!IF "$(CFG)" == "7z - Win32 Release"
+
+# Begin Custom Build
+OutDir=.\Release
+InputPath=..\..\..\..\Asm\x86\Sha256Opt.asm
+InputName=Sha256Opt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "7z - Win32 Debug"
+
+# Begin Custom Build
+OutDir=.\Debug
+InputPath=..\..\..\..\Asm\x86\Sha256Opt.asm
+InputName=Sha256Opt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -omf -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/Format7zF/Format7z.dsw b/CPP/7zip/Bundles/Format7zF/Format7z.dsw
new file mode 100644
index 0000000..324dab1
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/Format7z.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "7z"=.\Format7z.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/Format7zF/StdAfx.cpp b/CPP/7zip/Bundles/Format7zF/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Format7zF/StdAfx.h b/CPP/7zip/Bundles/Format7zF/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Format7zF/makefile b/CPP/7zip/Bundles/Format7zF/makefile
new file mode 100644
index 0000000..3487596
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/makefile
@@ -0,0 +1,21 @@
+PROG = 7z.dll
+# USE_C_LZFINDOPT = 1
+DEF_FILE = ../../Archive/Archive2.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTERNAL_CODECS \
+
+!IFNDEF UNDER_CE
+CFLAGS = $(CFLAGS) -DZ7_LARGE_PAGES
+!ENDIF
+
+!include "Arc.mak"
+
+COMPRESS_OBJS = $(COMPRESS_OBJS) \
+ $O\CodecExports.obj \
+
+AR_OBJS = $(AR_OBJS) \
+ $O\ArchiveExports.obj \
+ $O\DllExports2.obj \
+
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7zF/makefile.gcc b/CPP/7zip/Bundles/Format7zF/makefile.gcc
new file mode 100644
index 0000000..fc65795
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/makefile.gcc
@@ -0,0 +1,55 @@
+PROG = 7z
+DEF_FILE = ../../Archive/Archive2.def
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+include Arc_gcc.mak
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+
+ifdef IS_MINGW
+
+LOCAL_FLAGS_WIN = \
+ -DZ7_LARGE_PAGES \
+ $(LOCAL_FLAGS_ST) \
+
+SYS_OBJS = \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+
+endif
+
+LOCAL_FLAGS = \
+ -DZ7_EXTERNAL_CODECS \
+ $(LOCAL_FLAGS_WIN) \
+ $(LOCAL_FLAGS_ST) \
+
+
+COMPRESS_OBJS_2 = \
+ $O/CodecExports.o \
+
+AR_OBJS_2 = \
+ $O/ArchiveExports.o \
+ $O/DllExports2.o \
+
+OBJS = \
+ $(ARC_OBJS) \
+ $(AR_OBJS_2) \
+ $(COMPRESS_OBJS_2) \
+ $(SYS_OBJS) \
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/Bundles/Format7zF/resource.rc b/CPP/7zip/Bundles/Format7zF/resource.rc
new file mode 100644
index 0000000..9c797c1
--- /dev/null
+++ b/CPP/7zip/Bundles/Format7zF/resource.rc
@@ -0,0 +1,38 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_DLL("7z Plugin" , "7z")
+
+
+0 ICON "../../Archive/Icons/7z.ico"
+1 ICON "../../Archive/Icons/zip.ico"
+2 ICON "../../Archive/Icons/bz2.ico"
+3 ICON "../../Archive/Icons/rar.ico"
+4 ICON "../../Archive/Icons/arj.ico"
+5 ICON "../../Archive/Icons/z.ico"
+6 ICON "../../Archive/Icons/lzh.ico"
+7 ICON "../../Archive/Icons/cab.ico"
+8 ICON "../../Archive/Icons/iso.ico"
+9 ICON "../../Archive/Icons/split.ico"
+10 ICON "../../Archive/Icons/rpm.ico"
+11 ICON "../../Archive/Icons/deb.ico"
+12 ICON "../../Archive/Icons/cpio.ico"
+13 ICON "../../Archive/Icons/tar.ico"
+14 ICON "../../Archive/Icons/gz.ico"
+15 ICON "../../Archive/Icons/wim.ico"
+16 ICON "../../Archive/Icons/lzma.ico"
+17 ICON "../../Archive/Icons/dmg.ico"
+18 ICON "../../Archive/Icons/hfs.ico"
+19 ICON "../../Archive/Icons/xar.ico"
+20 ICON "../../Archive/Icons/vhd.ico"
+21 ICON "../../Archive/Icons/fat.ico"
+22 ICON "../../Archive/Icons/ntfs.ico"
+23 ICON "../../Archive/Icons/xz.ico"
+24 ICON "../../Archive/Icons/squashfs.ico"
+25 ICON "../../Archive/Icons/apfs.ico"
+
+
+
+STRINGTABLE
+BEGIN
+ 100 "7z:0 zip:1 rar:3 001:9 cab:7 iso:8 xz:23 txz:23 lzma:16 tar:13 cpio:12 bz2:2 bzip2:2 tbz2:2 tbz:2 gz:14 gzip:14 tgz:14 tpz:14 z:5 taz:5 lzh:6 lha:6 rpm:10 deb:11 arj:4 vhd:20 vhdx:20 wim:15 swm:15 esd:15 fat:21 ntfs:22 dmg:17 hfs:18 xar:19 squashfs:24 apfs:25"
+END
diff --git a/CPP/7zip/Bundles/Format7zR/StdAfx.cpp b/CPP/7zip/Bundles/Format7zR/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/Format7zR/StdAfx.cpp
+++ b/CPP/7zip/Bundles/Format7zR/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/Format7zR/StdAfx.h b/CPP/7zip/Bundles/Format7zR/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Bundles/Format7zR/StdAfx.h
+++ b/CPP/7zip/Bundles/Format7zR/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/Format7zR/makefile b/CPP/7zip/Bundles/Format7zR/makefile
index 6a9dfb9..2449755 100644
--- a/CPP/7zip/Bundles/Format7zR/makefile
+++ b/CPP/7zip/Bundles/Format7zR/makefile
@@ -1,116 +1,120 @@
-PROG = 7zra.dll
-DEF_FILE = ../../Archive/Archive2.def
-CFLAGS = $(CFLAGS) \
- -D_NO_CRYPTO
-
-COMMON_OBJS = \
- $O\CRC.obj \
- $O\CrcReg.obj \
- $O\IntToString.obj \
- $O\NewHandler.obj \
- $O\MyString.obj \
- $O\StringConvert.obj \
- $O\StringToInt.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
-
-WIN_OBJS = \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileName.obj \
- $O\PropVariant.obj \
- $O\Synchronization.obj \
- $O\System.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\CWrappers.obj \
- $O\InBuffer.obj \
- $O\InOutTempBuffer.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\MethodId.obj \
- $O\MethodProps.obj \
- $O\OutBuffer.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamBinder.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\UniqBlocks.obj \
- $O\VirtThread.obj \
-
-AR_OBJS = \
- $O\ArchiveExports.obj \
- $O\DllExports2.obj \
-
-AR_COMMON_OBJS = \
- $O\CoderMixer2.obj \
- $O\HandlerOut.obj \
- $O\InStreamWithCRC.obj \
- $O\ItemNameUtils.obj \
- $O\OutStreamWithCRC.obj \
- $O\ParseProperties.obj \
-
-
-7Z_OBJS = \
- $O\7zCompressionMode.obj \
- $O\7zDecode.obj \
- $O\7zEncode.obj \
- $O\7zExtract.obj \
- $O\7zFolderInStream.obj \
- $O\7zHandler.obj \
- $O\7zHandlerOut.obj \
- $O\7zHeader.obj \
- $O\7zIn.obj \
- $O\7zOut.obj \
- $O\7zProperties.obj \
- $O\7zSpecStream.obj \
- $O\7zUpdate.obj \
- $O\7zRegister.obj \
-
-
-COMPRESS_OBJS = \
- $O\CodecExports.obj \
- $O\Bcj2Coder.obj \
- $O\Bcj2Register.obj \
- $O\BcjCoder.obj \
- $O\BcjRegister.obj \
- $O\BranchMisc.obj \
- $O\BranchRegister.obj \
- $O\ByteSwap.obj \
- $O\CopyCoder.obj \
- $O\CopyRegister.obj \
- $O\DeltaFilter.obj \
- $O\Lzma2Decoder.obj \
- $O\Lzma2Encoder.obj \
- $O\Lzma2Register.obj \
- $O\LzmaDecoder.obj \
- $O\LzmaEncoder.obj \
- $O\LzmaRegister.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\Bcj2.obj \
- $O\Bcj2Enc.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\LzFind.obj \
- $O\LzFindMt.obj \
- $O\Lzma2Dec.obj \
- $O\Lzma2DecMt.obj \
- $O\Lzma2Enc.obj \
- $O\LzmaDec.obj \
- $O\LzmaEnc.obj \
- $O\MtCoder.obj \
- $O\MtDec.obj \
- $O\Threads.obj \
-
-!include "../../Crc.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = 7zra.dll
+DEF_FILE = ../../Archive/Archive2.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_NO_CRYPTO
+
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\IntToString.obj \
+ $O\LzFindPrepare.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\InBuffer.obj \
+ $O\InOutTempBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodId.obj \
+ $O\MethodProps.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+ $O\VirtThread.obj \
+
+AR_OBJS = \
+ $O\ArchiveExports.obj \
+ $O\DllExports2.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\HandlerOut.obj \
+ $O\InStreamWithCRC.obj \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+ $O\ParseProperties.obj \
+
+
+7Z_OBJS = \
+ $O\7zCompressionMode.obj \
+ $O\7zDecode.obj \
+ $O\7zEncode.obj \
+ $O\7zExtract.obj \
+ $O\7zFolderInStream.obj \
+ $O\7zHandler.obj \
+ $O\7zHandlerOut.obj \
+ $O\7zHeader.obj \
+ $O\7zIn.obj \
+ $O\7zOut.obj \
+ $O\7zProperties.obj \
+ $O\7zSpecStream.obj \
+ $O\7zUpdate.obj \
+ $O\7zRegister.obj \
+
+
+COMPRESS_OBJS = \
+ $O\CodecExports.obj \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\ByteSwap.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Encoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaEncoder.obj \
+ $O\LzmaRegister.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bcj2Enc.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\Lzma2Enc.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\MtCoder.obj \
+ $O\MtDec.obj \
+ $O\SwapBytes.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+!include "../../LzFindOpt.mak"
+!include "../../LzmaDec.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/Format7zR/resource.rc b/CPP/7zip/Bundles/Format7zR/resource.rc
index 262125c..a8baa59 100644
--- a/CPP/7zip/Bundles/Format7zR/resource.rc
+++ b/CPP/7zip/Bundles/Format7zR/resource.rc
@@ -1,5 +1,5 @@
-#include "../../../../C/7zVersion.rc"
-
-MY_VERSION_INFO_DLL("7z Reduced Standalone Plugin", "7zr")
-
-101 ICON "../../Archive/Icons/7z.ico"
+#include "../../../../C/7zVersion.rc"
+
+MY_VERSION_INFO_DLL("7z Reduced Standalone Plugin", "7zr")
+
+101 ICON "../../Archive/Icons/7z.ico"
diff --git a/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp b/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp
index f273337..ac1334f 100644
--- a/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp
+++ b/CPP/7zip/Bundles/LzmaCon/LzmaAlone.cpp
@@ -1,799 +1,808 @@
-// LzmaAlone.cpp
-
-#include "StdAfx.h"
-
-#include <stdio.h>
-
-#include "../../../../C/CpuArch.h"
-
-#if (defined(_WIN32) || defined(OS2) || defined(MSDOS)) && !defined(UNDER_CE)
-#include <fcntl.h>
-#include <io.h>
-#define MY_SET_BINARY_MODE(file) _setmode(_fileno(file), O_BINARY)
-#else
-#define MY_SET_BINARY_MODE(file)
-#endif
-
-#include "../../../Common/MyWindows.h"
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../../C/7zVersion.h"
-#include "../../../../C/Alloc.h"
-#include "../../../../C/Lzma86.h"
-
-#include "../../../Windows/NtCheck.h"
-
-#ifndef _7ZIP_ST
-#include "../../../Windows/System.h"
-#endif
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/StringToInt.h"
-
-#include "../../Common/FileStreams.h"
-#include "../../Common/StreamUtils.h"
-
-#include "../../Compress/LzmaDecoder.h"
-#include "../../Compress/LzmaEncoder.h"
-
-#include "../../UI/Console/BenchCon.h"
-#include "../../UI/Console/ConsoleClose.h"
-
-bool g_LargePagesMode = false;
-
-using namespace NCommandLineParser;
-
-static const unsigned kDictSizeLog = 24;
-
-#define kCopyrightString "\nLZMA " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n\n"
-
-static const char * const kHelpString =
- "Usage: lzma <command> [inputFile] [outputFile] [<switches>...]\n"
- "\n"
- "<command>\n"
- " e : Encode file\n"
- " d : Decode file\n"
- " b : Benchmark\n"
- "<switches>\n"
- " -a{N} : set compression mode : [0, 1] : default = 1 (max)\n"
- " -d{N} : set dictionary size : [12, 30] : default = 24 (16 MiB)\n"
- " -fb{N} : set number of fast bytes : [5, 273] : default = 128\n"
- " -mc{N} : set number of cycles for match finder\n"
- " -lc{N} : set number of literal context bits : [0, 8] : default = 3\n"
- " -lp{N} : set number of literal pos bits : [0, 4] : default = 0\n"
- " -pb{N} : set number of pos bits : [0, 4] : default = 2\n"
- " -mf{M} : set match finder: [hc4, bt2, bt3, bt4] : default = bt4\n"
- " -mt{N} : set number of CPU threads\n"
- " -eos : write end of stream marker\n"
- " -si : read data from stdin\n"
- " -so : write data to stdout\n";
-
-
-static const char * const kCantAllocate = "Can not allocate memory";
-static const char * const kReadError = "Read error";
-static const char * const kWriteError = "Write error";
-
-
-namespace NKey {
-enum Enum
-{
- kHelp1 = 0,
- kHelp2,
- kMethod,
- kLevel,
- kAlgo,
- kDict,
- kFb,
- kMc,
- kLc,
- kLp,
- kPb,
- kMatchFinder,
- kMultiThread,
- kEOS,
- kStdIn,
- kStdOut,
- kFilter86
-};
-}
-
-static const CSwitchForm kSwitchForms[] =
-{
- { "?", NSwitchType::kSimple, false },
- { "H", NSwitchType::kSimple, false },
- { "MM", NSwitchType::kString, false, 1 },
- { "X", NSwitchType::kString, false, 1 },
- { "A", NSwitchType::kString, false, 1 },
- { "D", NSwitchType::kString, false, 1 },
- { "FB", NSwitchType::kString, false, 1 },
- { "MC", NSwitchType::kString, false, 1 },
- { "LC", NSwitchType::kString, false, 1 },
- { "LP", NSwitchType::kString, false, 1 },
- { "PB", NSwitchType::kString, false, 1 },
- { "MF", NSwitchType::kString, false, 1 },
- { "MT", NSwitchType::kString, false, 0 },
- { "EOS", NSwitchType::kSimple, false },
- { "SI", NSwitchType::kSimple, false },
- { "SO", NSwitchType::kSimple, false },
- { "F86", NSwitchType::kChar, false, 0, "+" }
-};
-
-
-static void Convert_UString_to_AString(const UString &s, AString &temp)
-{
- int codePage = CP_OEMCP;
- /*
- int g_CodePage = -1;
- int codePage = g_CodePage;
- if (codePage == -1)
- codePage = CP_OEMCP;
- if (codePage == CP_UTF8)
- ConvertUnicodeToUTF8(s, temp);
- else
- */
- UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
-}
-
-static void PrintErr(const char *s)
-{
- fputs(s, stderr);
-}
-
-static void PrintErr_LF(const char *s)
-{
- PrintErr(s);
- fputc('\n', stderr);
-}
-
-
-static void PrintError(const char *s)
-{
- PrintErr("\nERROR: ");
- PrintErr_LF(s);
-}
-
-static void PrintError2(const char *s1, const UString &s2)
-{
- PrintError(s1);
- AString a;
- Convert_UString_to_AString(s2, a);
- PrintErr_LF(a);
-}
-
-static void PrintError_int(const char *s, int code)
-{
- PrintError(s);
- char temp[32];
- ConvertInt64ToString(code, temp);
- PrintErr("Error code = ");
- PrintErr_LF(temp);
-}
-
-
-
-static void Print(const char *s)
-{
- fputs(s, stdout);
-}
-
-static void Print_UInt64(UInt64 v)
-{
- char temp[32];
- ConvertUInt64ToString(v, temp);
- Print(temp);
-}
-
-static void Print_MB(UInt64 v)
-{
- Print_UInt64(v);
- Print(" MiB");
-}
-
-static void Print_Size(const char *s, UInt64 v)
-{
- Print(s);
- Print_UInt64(v);
- Print(" (");
- Print_MB(v >> 20);
- Print(")\n");
-}
-
-static void PrintTitle()
-{
- Print(kCopyrightString);
-}
-
-static void PrintHelp()
-{
- PrintTitle();
- Print(kHelpString);
-}
-
-class CProgressPrint:
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
- UInt64 _size1;
- UInt64 _size2;
-public:
- CProgressPrint(): _size1(0), _size2(0) {}
-
- void ClosePrint();
-
- MY_UNKNOWN_IMP1(ICompressProgressInfo)
-
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-};
-
-#define BACK_STR \
-"\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
-static const char * const kBackSpaces =
-BACK_STR
-" "
-BACK_STR;
-
-
-void CProgressPrint::ClosePrint()
-{
- Print(kBackSpaces);
-}
-
-STDMETHODIMP CProgressPrint::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
- if (NConsoleClose::TestBreakSignal())
- return E_ABORT;
- if (inSize)
- {
- UInt64 v1 = *inSize >> 20;
- UInt64 v2 = _size2;
- if (outSize)
- v2 = *outSize >> 20;
- if (v1 != _size1 || v2 != _size2)
- {
- _size1 = v1;
- _size2 = v2;
- ClosePrint();
- Print_MB(_size1);
- Print(" -> ");
- Print_MB(_size2);
- }
- }
- return S_OK;
-}
-
-
-static void IncorrectCommand()
-{
- throw "Incorrect command";
-}
-
-static UInt32 GetNumber(const wchar_t *s)
-{
- const wchar_t *end;
- UInt32 v = ConvertStringToUInt32(s, &end);
- if (*end != 0)
- IncorrectCommand();
- return v;
-}
-
-static void ParseUInt32(const CParser &parser, unsigned index, UInt32 &res)
-{
- if (parser[index].ThereIs)
- res = GetNumber(parser[index].PostStrings[0]);
-}
-
-
-static int Error_HRESULT(const char *s, HRESULT res)
-{
- if (res == E_ABORT)
- {
- Print("\n\nBreak signaled\n");
- return 255;
- }
-
- PrintError(s);
-
- if (res == E_OUTOFMEMORY)
- {
- PrintErr_LF(kCantAllocate);
- return 8;
- }
- if (res == E_INVALIDARG)
- {
- PrintErr_LF("Ununsupported parameter");
- }
- else
- {
- char temp[32];
- ConvertUInt32ToHex(res, temp);
- PrintErr("Error code = 0x");
- PrintErr_LF(temp);
- }
- return 1;
-}
-
-#define NT_CHECK_FAIL_ACTION PrintError("Unsupported Windows version"); return 1;
-
-static void AddProp(CObjectVector<CProperty> &props2, const char *name, const wchar_t *val)
-{
- CProperty &prop = props2.AddNew();
- prop.Name = name;
- prop.Value = val;
-}
-
-static int main2(int numArgs, const char *args[])
-{
- NT_CHECK
-
- if (numArgs == 1)
- {
- PrintHelp();
- return 0;
- }
-
- /*
- bool unsupportedTypes = (sizeof(Byte) != 1 || sizeof(UInt32) < 4 || sizeof(UInt64) < 8);
- if (unsupportedTypes)
- throw "Unsupported base types. Edit Common/Types.h and recompile";
- */
-
- UStringVector commandStrings;
- for (int i = 1; i < numArgs; i++)
- commandStrings.Add(MultiByteToUnicodeString(args[i]));
-
- CParser parser;
- try
- {
- if (!parser.ParseStrings(kSwitchForms, ARRAY_SIZE(kSwitchForms), commandStrings))
- {
- PrintError2(parser.ErrorMessage, parser.ErrorLine);
- return 1;
- }
- }
- catch(...)
- {
- IncorrectCommand();
- }
-
- if (parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs)
- {
- PrintHelp();
- return 0;
- }
-
- bool stdInMode = parser[NKey::kStdIn].ThereIs;
- bool stdOutMode = parser[NKey::kStdOut].ThereIs;
-
- if (!stdOutMode)
- PrintTitle();
-
- const UStringVector ¶ms = parser.NonSwitchStrings;
-
- unsigned paramIndex = 0;
- if (paramIndex >= params.Size())
- IncorrectCommand();
- const UString &command = params[paramIndex++];
-
- CObjectVector<CProperty> props2;
- bool dictDefined = false;
- UInt32 dict = (UInt32)(Int32)-1;
-
- if (parser[NKey::kDict].ThereIs)
- {
- UInt32 dictLog;
- const UString &s = parser[NKey::kDict].PostStrings[0];
- dictLog = GetNumber(s);
- dict = 1 << dictLog;
- dictDefined = true;
- AddProp(props2, "d", s);
- }
-
- if (parser[NKey::kLevel].ThereIs)
- {
- const UString &s = parser[NKey::kLevel].PostStrings[0];
- /* UInt32 level = */ GetNumber(s);
- AddProp(props2, "x", s);
- }
-
- UString mf ("BT4");
- if (parser[NKey::kMatchFinder].ThereIs)
- mf = parser[NKey::kMatchFinder].PostStrings[0];
-
- UInt32 numThreads = (UInt32)(Int32)-1;
-
- #ifndef _7ZIP_ST
-
- if (parser[NKey::kMultiThread].ThereIs)
- {
- const UString &s = parser[NKey::kMultiThread].PostStrings[0];
- if (s.IsEmpty())
- numThreads = NWindows::NSystem::GetNumberOfProcessors();
- else
- numThreads = GetNumber(s);
- AddProp(props2, "mt", s);
- }
-
- #endif
-
-
- if (parser[NKey::kMethod].ThereIs)
- {
- const UString &s = parser[NKey::kMethod].PostStrings[0];
- if (s.IsEmpty() || s[0] != '=')
- IncorrectCommand();
- AddProp(props2, "m", s.Ptr(1));
- }
-
- if (StringsAreEqualNoCase_Ascii(command, "b"))
- {
- UInt32 numIterations = 1;
- if (paramIndex < params.Size())
- numIterations = GetNumber(params[paramIndex++]);
- if (params.Size() != paramIndex)
- IncorrectCommand();
-
- HRESULT res = BenchCon(props2, numIterations, stdout);
-
- if (res == S_OK)
- return 0;
- return Error_HRESULT("Benchmark error", res);
- }
-
- {
- UInt32 needParams = 3;
- if (stdInMode) needParams--;
- if (stdOutMode) needParams--;
- if (needParams != params.Size())
- IncorrectCommand();
- }
-
- if (numThreads == (UInt32)(Int32)-1)
- numThreads = 1;
-
- bool encodeMode = false;
-
- if (StringsAreEqualNoCase_Ascii(command, "e"))
- encodeMode = true;
- else if (!StringsAreEqualNoCase_Ascii(command, "d"))
- IncorrectCommand();
-
- CMyComPtr<ISequentialInStream> inStream;
- CInFileStream *inStreamSpec = NULL;
-
- if (stdInMode)
- {
- inStream = new CStdInFileStream;
- MY_SET_BINARY_MODE(stdin);
- }
- else
- {
- const UString &inputName = params[paramIndex++];
- inStreamSpec = new CInFileStream;
- inStream = inStreamSpec;
- if (!inStreamSpec->Open(us2fs(inputName)))
- {
- PrintError2("can not open input file", inputName);
- return 1;
- }
- }
-
- CMyComPtr<ISequentialOutStream> outStream;
- COutFileStream *outStreamSpec = NULL;
-
- if (stdOutMode)
- {
- outStream = new CStdOutFileStream;
- MY_SET_BINARY_MODE(stdout);
- }
- else
- {
- const UString &outputName = params[paramIndex++];
- outStreamSpec = new COutFileStream;
- outStream = outStreamSpec;
- if (!outStreamSpec->Create(us2fs(outputName), true))
- {
- PrintError2("can not open output file", outputName);
- return 1;
- }
- }
-
- bool fileSizeDefined = false;
- UInt64 fileSize = 0;
-
- if (inStreamSpec)
- {
- if (!inStreamSpec->File.GetLength(fileSize))
- throw "Can not get file length";
- fileSizeDefined = true;
- if (!stdOutMode)
- Print_Size("Input size: ", fileSize);
- }
-
- if (encodeMode && !dictDefined)
- {
- dict = 1 << kDictSizeLog;
- if (fileSizeDefined)
- {
- unsigned i;
- for (i = 16; i < kDictSizeLog; i++)
- if ((UInt32)((UInt32)1 << i) >= fileSize)
- break;
- dict = (UInt32)1 << i;
- }
- }
-
- if (parser[NKey::kFilter86].ThereIs)
- {
- /* -f86 switch is for x86 filtered mode: BCJ + LZMA.
- It uses modified header format.
- It's not recommended to use -f86 mode now.
- You can use xz format instead, if you want to use filters */
-
- if (parser[NKey::kEOS].ThereIs || stdInMode)
- throw "Can not use stdin in this mode";
-
- size_t inSize = (size_t)fileSize;
-
- if (inSize != fileSize)
- throw "File is too big";
-
- Byte *inBuffer = NULL;
-
- if (inSize != 0)
- {
- inBuffer = (Byte *)MyAlloc((size_t)inSize);
- if (!inBuffer)
- throw kCantAllocate;
- }
-
- if (ReadStream_FAIL(inStream, inBuffer, inSize) != S_OK)
- throw "Can not read";
-
- Byte *outBuffer = NULL;
- size_t outSize;
-
- if (encodeMode)
- {
- // we allocate 105% of original size for output buffer
- UInt64 outSize64 = fileSize / 20 * 21 + (1 << 16);
-
- outSize = (size_t)outSize64;
-
- if (outSize != outSize64)
- throw "File is too big";
-
- if (outSize != 0)
- {
- outBuffer = (Byte *)MyAlloc((size_t)outSize);
- if (!outBuffer)
- throw kCantAllocate;
- }
-
- int res = Lzma86_Encode(outBuffer, &outSize, inBuffer, inSize,
- 5, dict, parser[NKey::kFilter86].PostCharIndex == 0 ? SZ_FILTER_YES : SZ_FILTER_AUTO);
-
- if (res != 0)
- {
- PrintError_int("Encode error", (int)res);
- return 1;
- }
- }
- else
- {
- UInt64 outSize64;
-
- if (Lzma86_GetUnpackSize(inBuffer, inSize, &outSize64) != 0)
- throw "data error";
-
- outSize = (size_t)outSize64;
- if (outSize != outSize64)
- throw "Unpack size is too big";
- if (outSize != 0)
- {
- outBuffer = (Byte *)MyAlloc(outSize);
- if (!outBuffer)
- throw kCantAllocate;
- }
-
- int res = Lzma86_Decode(outBuffer, &outSize, inBuffer, &inSize);
-
- if (inSize != (size_t)fileSize)
- throw "incorrect processed size";
- if (res != 0)
- {
- PrintError_int("Decode error", (int)res);
- return 1;
- }
- }
-
- if (WriteStream(outStream, outBuffer, outSize) != S_OK)
- throw kWriteError;
-
- MyFree(outBuffer);
- MyFree(inBuffer);
- }
- else
- {
-
- CProgressPrint *progressSpec = NULL;
- CMyComPtr<ICompressProgressInfo> progress;
-
- if (!stdOutMode)
- {
- progressSpec = new CProgressPrint;
- progress = progressSpec;
- }
-
- if (encodeMode)
- {
- NCompress::NLzma::CEncoder *encoderSpec = new NCompress::NLzma::CEncoder;
- CMyComPtr<ICompressCoder> encoder = encoderSpec;
-
- UInt32 pb = 2;
- UInt32 lc = 3; // = 0; for 32-bit data
- UInt32 lp = 0; // = 2; for 32-bit data
- UInt32 algo = 1;
- UInt32 fb = 128;
- UInt32 mc = 16 + fb / 2;
- bool mcDefined = false;
-
- bool eos = parser[NKey::kEOS].ThereIs || stdInMode;
-
- ParseUInt32(parser, NKey::kAlgo, algo);
- ParseUInt32(parser, NKey::kFb, fb);
- ParseUInt32(parser, NKey::kLc, lc);
- ParseUInt32(parser, NKey::kLp, lp);
- ParseUInt32(parser, NKey::kPb, pb);
-
- mcDefined = parser[NKey::kMc].ThereIs;
- if (mcDefined)
- mc = GetNumber(parser[NKey::kMc].PostStrings[0]);
-
- const PROPID propIDs[] =
- {
- NCoderPropID::kDictionarySize,
- NCoderPropID::kPosStateBits,
- NCoderPropID::kLitContextBits,
- NCoderPropID::kLitPosBits,
- NCoderPropID::kAlgorithm,
- NCoderPropID::kNumFastBytes,
- NCoderPropID::kMatchFinder,
- NCoderPropID::kEndMarker,
- NCoderPropID::kNumThreads,
- NCoderPropID::kMatchFinderCycles,
- };
-
- const unsigned kNumPropsMax = ARRAY_SIZE(propIDs);
-
- PROPVARIANT props[kNumPropsMax];
- for (int p = 0; p < 6; p++)
- props[p].vt = VT_UI4;
-
- props[0].ulVal = (UInt32)dict;
- props[1].ulVal = (UInt32)pb;
- props[2].ulVal = (UInt32)lc;
- props[3].ulVal = (UInt32)lp;
- props[4].ulVal = (UInt32)algo;
- props[5].ulVal = (UInt32)fb;
-
- props[6].vt = VT_BSTR;
- props[6].bstrVal = const_cast<BSTR>((const wchar_t *)mf);
-
- props[7].vt = VT_BOOL;
- props[7].boolVal = eos ? VARIANT_TRUE : VARIANT_FALSE;
-
- props[8].vt = VT_UI4;
- props[8].ulVal = (UInt32)numThreads;
-
- // it must be last in property list
- props[9].vt = VT_UI4;
- props[9].ulVal = (UInt32)mc;
-
- unsigned numProps = kNumPropsMax;
- if (!mcDefined)
- numProps--;
-
- HRESULT res = encoderSpec->SetCoderProperties(propIDs, props, numProps);
- if (res != S_OK)
- return Error_HRESULT("incorrect encoder properties", res);
-
- if (encoderSpec->WriteCoderProperties(outStream) != S_OK)
- throw kWriteError;
-
- bool fileSizeWasUsed = true;
- if (eos || stdInMode)
- {
- fileSize = (UInt64)(Int64)-1;
- fileSizeWasUsed = false;
- }
-
- {
- Byte temp[8];
- for (int i = 0; i < 8; i++)
- temp[i]= (Byte)(fileSize >> (8 * i));
- if (WriteStream(outStream, temp, 8) != S_OK)
- throw kWriteError;
- }
-
- res = encoder->Code(inStream, outStream, NULL, NULL, progress);
- if (progressSpec)
- progressSpec->ClosePrint();
-
- if (res != S_OK)
- return Error_HRESULT("Encoding error", res);
-
- UInt64 processedSize = encoderSpec->GetInputProcessedSize();
-
- if (fileSizeWasUsed && processedSize != fileSize)
- throw "Incorrect size of processed data";
- }
- else
- {
- NCompress::NLzma::CDecoder *decoderSpec = new NCompress::NLzma::CDecoder;
- CMyComPtr<ICompressCoder> decoder = decoderSpec;
-
- decoderSpec->FinishStream = true;
-
- const unsigned kPropertiesSize = 5;
- Byte header[kPropertiesSize + 8];
-
- if (ReadStream_FALSE(inStream, header, kPropertiesSize + 8) != S_OK)
- throw kReadError;
-
- if (decoderSpec->SetDecoderProperties2(header, kPropertiesSize) != S_OK)
- throw "SetDecoderProperties error";
-
- UInt64 unpackSize = 0;
- for (int i = 0; i < 8; i++)
- unpackSize |= ((UInt64)header[kPropertiesSize + i]) << (8 * i);
-
- bool unpackSizeDefined = (unpackSize != (UInt64)(Int64)-1);
-
- HRESULT res = decoder->Code(inStream, outStream, NULL, unpackSizeDefined ? &unpackSize : NULL, progress);
- if (progressSpec)
- progressSpec->ClosePrint();
-
- if (res != S_OK)
- {
- if (res == S_FALSE)
- {
- PrintError("Decoding error");
- return 1;
- }
- return Error_HRESULT("Decoding error", res);
- }
-
- if (unpackSizeDefined && unpackSize != decoderSpec->GetOutputProcessedSize())
- throw "incorrect uncompressed size in header";
- }
- }
-
- if (outStreamSpec)
- {
- if (!stdOutMode)
- Print_Size("Output size: ", outStreamSpec->ProcessedSize);
- if (outStreamSpec->Close() != S_OK)
- throw "File closing error";
- }
-
- return 0;
-}
-
-int MY_CDECL main(int numArgs, const char *args[])
-{
- NConsoleClose::CCtrlHandlerSetter ctrlHandlerSetter;
-
- try { return main2(numArgs, args); }
- catch (const char *s)
- {
- PrintError(s);
- return 1;
- }
- catch(...)
- {
- PrintError("Unknown Error");
- return 1;
- }
-}
+ // LzmaAlone.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#if (defined(_WIN32) || defined(OS2) || defined(MSDOS)) && !defined(UNDER_CE)
+#include <fcntl.h>
+#include <io.h>
+#define MY_SET_BINARY_MODE(file) _setmode(_fileno(file), O_BINARY)
+#else
+#define MY_SET_BINARY_MODE(file)
+#endif
+
+#include "../../../../C/CpuArch.h"
+#include "../../../../C/7zVersion.h"
+#include "../../../../C/Alloc.h"
+#include "../../../../C/Lzma86.h"
+
+#include "../../../Common/MyWindows.h"
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Windows/NtCheck.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/System.h"
+#endif
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/LzmaDecoder.h"
+#include "../../Compress/LzmaEncoder.h"
+
+#include "../../UI/Console/BenchCon.h"
+#include "../../UI/Console/ConsoleClose.h"
+
+extern
+bool g_LargePagesMode;
+bool g_LargePagesMode = false;
+
+using namespace NCommandLineParser;
+
+static const unsigned kDictSizeLog = 24;
+
+#define kCopyrightString "\nLZMA " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n\n"
+
+static const char * const kHelpString =
+ "Usage: lzma <command> [inputFile] [outputFile] [<switches>...]\n"
+ "\n"
+ "<command>\n"
+ " e : Encode file\n"
+ " d : Decode file\n"
+ " b : Benchmark\n"
+ "<switches>\n"
+ " -a{N} : set compression mode : [0, 1] : default = 1 (max)\n"
+ " -d{N} : set dictionary size : [12, 30] : default = 24 (16 MiB)\n"
+ " -fb{N} : set number of fast bytes : [5, 273] : default = 128\n"
+ " -mc{N} : set number of cycles for match finder\n"
+ " -lc{N} : set number of literal context bits : [0, 8] : default = 3\n"
+ " -lp{N} : set number of literal pos bits : [0, 4] : default = 0\n"
+ " -pb{N} : set number of pos bits : [0, 4] : default = 2\n"
+ " -mf{M} : set match finder: [hc4, bt2, bt3, bt4] : default = bt4\n"
+ " -mt{N} : set number of CPU threads\n"
+ " -eos : write end of stream marker\n"
+ " -si : read data from stdin\n"
+ " -so : write data to stdout\n";
+
+
+static const char * const kCantAllocate = "Cannot allocate memory";
+static const char * const kReadError = "Read error";
+static const char * const kWriteError = "Write error";
+
+
+namespace NKey {
+enum Enum
+{
+ kHelp1 = 0,
+ kHelp2,
+ kMethod,
+ kLevel,
+ kAlgo,
+ kDict,
+ kFb,
+ kMc,
+ kLc,
+ kLp,
+ kPb,
+ kMatchFinder,
+ kMultiThread,
+ kEOS,
+ kStdIn,
+ kStdOut,
+ kFilter86
+};
+}
+
+#define SWFRM_3(t, mu, mi) t, mu, mi, NULL
+
+#define SWFRM_1(t) SWFRM_3(t, false, 0)
+#define SWFRM_SIMPLE SWFRM_1(NSwitchType::kSimple)
+#define SWFRM_STRING SWFRM_1(NSwitchType::kString)
+
+#define SWFRM_STRING_SINGL(mi) SWFRM_3(NSwitchType::kString, false, mi)
+
+static const CSwitchForm kSwitchForms[] =
+{
+ { "?", SWFRM_SIMPLE },
+ { "H", SWFRM_SIMPLE },
+ { "MM", SWFRM_STRING_SINGL(1) },
+ { "X", SWFRM_STRING_SINGL(1) },
+ { "A", SWFRM_STRING_SINGL(1) },
+ { "D", SWFRM_STRING_SINGL(1) },
+ { "FB", SWFRM_STRING_SINGL(1) },
+ { "MC", SWFRM_STRING_SINGL(1) },
+ { "LC", SWFRM_STRING_SINGL(1) },
+ { "LP", SWFRM_STRING_SINGL(1) },
+ { "PB", SWFRM_STRING_SINGL(1) },
+ { "MF", SWFRM_STRING_SINGL(1) },
+ { "MT", SWFRM_STRING },
+ { "EOS", SWFRM_SIMPLE },
+ { "SI", SWFRM_SIMPLE },
+ { "SO", SWFRM_SIMPLE },
+ { "F86", NSwitchType::kChar, false, 0, "+" }
+};
+
+
+static void Convert_UString_to_AString(const UString &s, AString &temp)
+{
+ int codePage = CP_OEMCP;
+ /*
+ int g_CodePage = -1;
+ int codePage = g_CodePage;
+ if (codePage == -1)
+ codePage = CP_OEMCP;
+ if (codePage == CP_UTF8)
+ ConvertUnicodeToUTF8(s, temp);
+ else
+ */
+ UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
+}
+
+static void PrintErr(const char *s)
+{
+ fputs(s, stderr);
+}
+
+static void PrintErr_LF(const char *s)
+{
+ PrintErr(s);
+ fputc('\n', stderr);
+}
+
+
+static void PrintError(const char *s)
+{
+ PrintErr("\nERROR: ");
+ PrintErr_LF(s);
+}
+
+static void PrintError2(const char *s1, const UString &s2)
+{
+ PrintError(s1);
+ AString a;
+ Convert_UString_to_AString(s2, a);
+ PrintErr_LF(a);
+}
+
+static void PrintError_int(const char *s, int code)
+{
+ PrintError(s);
+ char temp[32];
+ ConvertInt64ToString(code, temp);
+ PrintErr("Error code = ");
+ PrintErr_LF(temp);
+}
+
+
+
+static void Print(const char *s)
+{
+ fputs(s, stdout);
+}
+
+static void Print_UInt64(UInt64 v)
+{
+ char temp[32];
+ ConvertUInt64ToString(v, temp);
+ Print(temp);
+}
+
+static void Print_MB(UInt64 v)
+{
+ Print_UInt64(v);
+ Print(" MiB");
+}
+
+static void Print_Size(const char *s, UInt64 v)
+{
+ Print(s);
+ Print_UInt64(v);
+ Print(" (");
+ Print_MB(v >> 20);
+ Print(")\n");
+}
+
+static void PrintTitle()
+{
+ Print(kCopyrightString);
+}
+
+static void PrintHelp()
+{
+ PrintTitle();
+ Print(kHelpString);
+}
+
+
+Z7_CLASS_IMP_COM_1(
+ CProgressPrint,
+ ICompressProgressInfo
+)
+ UInt64 _size1;
+ UInt64 _size2;
+public:
+ CProgressPrint(): _size1(0), _size2(0) {}
+
+ void ClosePrint();
+};
+
+#define BACK_STR \
+"\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
+static const char * const kBackSpaces =
+BACK_STR
+" "
+BACK_STR;
+
+
+void CProgressPrint::ClosePrint()
+{
+ Print(kBackSpaces);
+}
+
+Z7_COM7F_IMF(CProgressPrint::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ if (NConsoleClose::TestBreakSignal())
+ return E_ABORT;
+ if (inSize)
+ {
+ UInt64 v1 = *inSize >> 20;
+ UInt64 v2 = _size2;
+ if (outSize)
+ v2 = *outSize >> 20;
+ if (v1 != _size1 || v2 != _size2)
+ {
+ _size1 = v1;
+ _size2 = v2;
+ ClosePrint();
+ Print_MB(_size1);
+ Print(" -> ");
+ Print_MB(_size2);
+ }
+ }
+ return S_OK;
+}
+
+
+Z7_ATTR_NORETURN
+static void IncorrectCommand()
+{
+ throw "Incorrect command";
+}
+
+static UInt32 GetNumber(const wchar_t *s)
+{
+ const wchar_t *end;
+ UInt32 v = ConvertStringToUInt32(s, &end);
+ if (*end != 0)
+ IncorrectCommand();
+ return v;
+}
+
+static void ParseUInt32(const CParser &parser, unsigned index, UInt32 &res)
+{
+ if (parser[index].ThereIs)
+ res = GetNumber(parser[index].PostStrings[0]);
+}
+
+
+static int Error_HRESULT(const char *s, HRESULT res)
+{
+ if (res == E_ABORT)
+ {
+ Print("\n\nBreak signaled\n");
+ return 255;
+ }
+
+ PrintError(s);
+
+ if (res == E_OUTOFMEMORY)
+ {
+ PrintErr_LF(kCantAllocate);
+ return 8;
+ }
+ if (res == E_INVALIDARG)
+ {
+ PrintErr_LF("Ununsupported parameter");
+ }
+ else
+ {
+ char temp[32];
+ ConvertUInt32ToHex((UInt32)res, temp);
+ PrintErr("Error code = 0x");
+ PrintErr_LF(temp);
+ }
+ return 1;
+}
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION PrintError("Unsupported Windows version"); return 1;
+#endif
+
+static void AddProp(CObjectVector<CProperty> &props2, const char *name, const wchar_t *val)
+{
+ CProperty &prop = props2.AddNew();
+ prop.Name = name;
+ prop.Value = val;
+}
+
+static int main2(int numArgs, const char *args[])
+{
+ NT_CHECK
+
+ if (numArgs == 1)
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ /*
+ bool unsupportedTypes = (sizeof(Byte) != 1 || sizeof(UInt32) < 4 || sizeof(UInt64) < 8);
+ if (unsupportedTypes)
+ throw "Unsupported base types. Edit Common/Types.h and recompile";
+ */
+
+ UStringVector commandStrings;
+ for (int i = 1; i < numArgs; i++)
+ commandStrings.Add(MultiByteToUnicodeString(args[i]));
+
+ CParser parser;
+ try
+ {
+ if (!parser.ParseStrings(kSwitchForms, Z7_ARRAY_SIZE(kSwitchForms), commandStrings))
+ {
+ PrintError2(parser.ErrorMessage, parser.ErrorLine);
+ return 1;
+ }
+ }
+ catch(...)
+ {
+ IncorrectCommand();
+ }
+
+ if (parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs)
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ bool stdInMode = parser[NKey::kStdIn].ThereIs;
+ bool stdOutMode = parser[NKey::kStdOut].ThereIs;
+
+ if (!stdOutMode)
+ PrintTitle();
+
+ const UStringVector ¶ms = parser.NonSwitchStrings;
+
+ unsigned paramIndex = 0;
+ if (paramIndex >= params.Size())
+ IncorrectCommand();
+ const UString &command = params[paramIndex++];
+
+ CObjectVector<CProperty> props2;
+ bool dictDefined = false;
+ UInt32 dict = (UInt32)(Int32)-1;
+
+ if (parser[NKey::kDict].ThereIs)
+ {
+ UInt32 dictLog;
+ const UString &s = parser[NKey::kDict].PostStrings[0];
+ dictLog = GetNumber(s);
+ dict = 1 << dictLog;
+ dictDefined = true;
+ AddProp(props2, "d", s);
+ }
+
+ if (parser[NKey::kLevel].ThereIs)
+ {
+ const UString &s = parser[NKey::kLevel].PostStrings[0];
+ /* UInt32 level = */ GetNumber(s);
+ AddProp(props2, "x", s);
+ }
+
+ UString mf ("BT4");
+ if (parser[NKey::kMatchFinder].ThereIs)
+ mf = parser[NKey::kMatchFinder].PostStrings[0];
+
+ UInt32 numThreads = (UInt32)(Int32)-1;
+
+ #ifndef Z7_ST
+
+ if (parser[NKey::kMultiThread].ThereIs)
+ {
+ const UString &s = parser[NKey::kMultiThread].PostStrings[0];
+ if (s.IsEmpty())
+ numThreads = NWindows::NSystem::GetNumberOfProcessors();
+ else
+ numThreads = GetNumber(s);
+ AddProp(props2, "mt", s);
+ }
+
+ #endif
+
+
+ if (parser[NKey::kMethod].ThereIs)
+ {
+ const UString &s = parser[NKey::kMethod].PostStrings[0];
+ if (s.IsEmpty() || s[0] != '=')
+ IncorrectCommand();
+ AddProp(props2, "m", s.Ptr(1));
+ }
+
+ if (StringsAreEqualNoCase_Ascii(command, "b"))
+ {
+ UInt32 numIterations = 1;
+ if (paramIndex < params.Size())
+ numIterations = GetNumber(params[paramIndex++]);
+ if (params.Size() != paramIndex)
+ IncorrectCommand();
+
+ HRESULT res = BenchCon(props2, numIterations, stdout);
+
+ if (res == S_OK)
+ return 0;
+ return Error_HRESULT("Benchmark error", res);
+ }
+
+ {
+ UInt32 needParams = 3;
+ if (stdInMode) needParams--;
+ if (stdOutMode) needParams--;
+ if (needParams != params.Size())
+ IncorrectCommand();
+ }
+
+ if (numThreads == (UInt32)(Int32)-1)
+ numThreads = 1;
+
+ bool encodeMode = false;
+
+ if (StringsAreEqualNoCase_Ascii(command, "e"))
+ encodeMode = true;
+ else if (!StringsAreEqualNoCase_Ascii(command, "d"))
+ IncorrectCommand();
+
+ CMyComPtr<ISequentialInStream> inStream;
+ CInFileStream *inStreamSpec = NULL;
+
+ if (stdInMode)
+ {
+ inStream = new CStdInFileStream;
+ MY_SET_BINARY_MODE(stdin);
+ }
+ else
+ {
+ const UString &inputName = params[paramIndex++];
+ inStreamSpec = new CInFileStream;
+ inStream = inStreamSpec;
+ if (!inStreamSpec->Open(us2fs(inputName)))
+ {
+ PrintError2("Cannot open input file", inputName);
+ return 1;
+ }
+ }
+
+ CMyComPtr<ISequentialOutStream> outStream;
+ COutFileStream *outStreamSpec = NULL;
+
+ if (stdOutMode)
+ {
+ outStream = new CStdOutFileStream;
+ MY_SET_BINARY_MODE(stdout);
+ }
+ else
+ {
+ const UString &outputName = params[paramIndex++];
+ outStreamSpec = new COutFileStream;
+ outStream = outStreamSpec;
+ if (!outStreamSpec->Create(us2fs(outputName), true))
+ {
+ PrintError2("Cannot open output file", outputName);
+ return 1;
+ }
+ }
+
+ bool fileSizeDefined = false;
+ UInt64 fileSize = 0;
+
+ if (inStreamSpec)
+ {
+ if (!inStreamSpec->GetLength(fileSize))
+ throw "Cannot get file length";
+ fileSizeDefined = true;
+ if (!stdOutMode)
+ Print_Size("Input size: ", fileSize);
+ }
+
+ if (encodeMode && !dictDefined)
+ {
+ dict = 1 << kDictSizeLog;
+ if (fileSizeDefined)
+ {
+ unsigned i;
+ for (i = 16; i < kDictSizeLog; i++)
+ if ((UInt32)((UInt32)1 << i) >= fileSize)
+ break;
+ dict = (UInt32)1 << i;
+ }
+ }
+
+ if (parser[NKey::kFilter86].ThereIs)
+ {
+ /* -f86 switch is for x86 filtered mode: BCJ + LZMA.
+ It uses modified header format.
+ It's not recommended to use -f86 mode now.
+ You can use xz format instead, if you want to use filters */
+
+ if (parser[NKey::kEOS].ThereIs || stdInMode)
+ throw "Cannot use stdin in this mode";
+
+ size_t inSize = (size_t)fileSize;
+
+ if (inSize != fileSize)
+ throw "File is too big";
+
+ Byte *inBuffer = NULL;
+
+ if (inSize != 0)
+ {
+ inBuffer = (Byte *)MyAlloc((size_t)inSize);
+ if (!inBuffer)
+ throw kCantAllocate;
+ }
+
+ if (ReadStream_FAIL(inStream, inBuffer, inSize) != S_OK)
+ throw "Cannot read";
+
+ Byte *outBuffer = NULL;
+ size_t outSize;
+
+ if (encodeMode)
+ {
+ // we allocate 105% of original size for output buffer
+ UInt64 outSize64 = fileSize / 20 * 21 + (1 << 16);
+
+ outSize = (size_t)outSize64;
+
+ if (outSize != outSize64)
+ throw "File is too big";
+
+ if (outSize != 0)
+ {
+ outBuffer = (Byte *)MyAlloc((size_t)outSize);
+ if (!outBuffer)
+ throw kCantAllocate;
+ }
+
+ int res = Lzma86_Encode(outBuffer, &outSize, inBuffer, inSize,
+ 5, dict, parser[NKey::kFilter86].PostCharIndex == 0 ? SZ_FILTER_YES : SZ_FILTER_AUTO);
+
+ if (res != 0)
+ {
+ PrintError_int("Encode error", (int)res);
+ return 1;
+ }
+ }
+ else
+ {
+ UInt64 outSize64;
+
+ if (Lzma86_GetUnpackSize(inBuffer, inSize, &outSize64) != 0)
+ throw "data error";
+
+ outSize = (size_t)outSize64;
+ if (outSize != outSize64)
+ throw "Unpack size is too big";
+ if (outSize != 0)
+ {
+ outBuffer = (Byte *)MyAlloc(outSize);
+ if (!outBuffer)
+ throw kCantAllocate;
+ }
+
+ int res = Lzma86_Decode(outBuffer, &outSize, inBuffer, &inSize);
+
+ if (inSize != (size_t)fileSize)
+ throw "incorrect processed size";
+ if (res != 0)
+ {
+ PrintError_int("Decode error", (int)res);
+ return 1;
+ }
+ }
+
+ if (WriteStream(outStream, outBuffer, outSize) != S_OK)
+ throw kWriteError;
+
+ MyFree(outBuffer);
+ MyFree(inBuffer);
+ }
+ else
+ {
+
+ CProgressPrint *progressSpec = NULL;
+ CMyComPtr<ICompressProgressInfo> progress;
+
+ if (!stdOutMode)
+ {
+ progressSpec = new CProgressPrint;
+ progress = progressSpec;
+ }
+
+ if (encodeMode)
+ {
+ NCompress::NLzma::CEncoder *encoderSpec = new NCompress::NLzma::CEncoder;
+ CMyComPtr<ICompressCoder> encoder = encoderSpec;
+
+ UInt32 pb = 2;
+ UInt32 lc = 3; // = 0; for 32-bit data
+ UInt32 lp = 0; // = 2; for 32-bit data
+ UInt32 algo = 1;
+ UInt32 fb = 128;
+ UInt32 mc = 16 + fb / 2;
+ bool mcDefined = false;
+
+ bool eos = parser[NKey::kEOS].ThereIs || stdInMode;
+
+ ParseUInt32(parser, NKey::kAlgo, algo);
+ ParseUInt32(parser, NKey::kFb, fb);
+ ParseUInt32(parser, NKey::kLc, lc);
+ ParseUInt32(parser, NKey::kLp, lp);
+ ParseUInt32(parser, NKey::kPb, pb);
+
+ mcDefined = parser[NKey::kMc].ThereIs;
+ if (mcDefined)
+ mc = GetNumber(parser[NKey::kMc].PostStrings[0]);
+
+ const PROPID propIDs[] =
+ {
+ NCoderPropID::kDictionarySize,
+ NCoderPropID::kPosStateBits,
+ NCoderPropID::kLitContextBits,
+ NCoderPropID::kLitPosBits,
+ NCoderPropID::kAlgorithm,
+ NCoderPropID::kNumFastBytes,
+ NCoderPropID::kMatchFinder,
+ NCoderPropID::kEndMarker,
+ NCoderPropID::kNumThreads,
+ NCoderPropID::kMatchFinderCycles,
+ };
+
+ const unsigned kNumPropsMax = Z7_ARRAY_SIZE(propIDs);
+
+ PROPVARIANT props[kNumPropsMax];
+ for (int p = 0; p < 6; p++)
+ props[p].vt = VT_UI4;
+
+ props[0].ulVal = (UInt32)dict;
+ props[1].ulVal = (UInt32)pb;
+ props[2].ulVal = (UInt32)lc;
+ props[3].ulVal = (UInt32)lp;
+ props[4].ulVal = (UInt32)algo;
+ props[5].ulVal = (UInt32)fb;
+
+ props[6].vt = VT_BSTR;
+ props[6].bstrVal = const_cast<BSTR>((const wchar_t *)mf);
+
+ props[7].vt = VT_BOOL;
+ props[7].boolVal = eos ? VARIANT_TRUE : VARIANT_FALSE;
+
+ props[8].vt = VT_UI4;
+ props[8].ulVal = (UInt32)numThreads;
+
+ // it must be last in property list
+ props[9].vt = VT_UI4;
+ props[9].ulVal = (UInt32)mc;
+
+ unsigned numProps = kNumPropsMax;
+ if (!mcDefined)
+ numProps--;
+
+ HRESULT res = encoderSpec->SetCoderProperties(propIDs, props, numProps);
+ if (res != S_OK)
+ return Error_HRESULT("incorrect encoder properties", res);
+
+ if (encoderSpec->WriteCoderProperties(outStream) != S_OK)
+ throw kWriteError;
+
+ bool fileSizeWasUsed = true;
+ if (eos || stdInMode)
+ {
+ fileSize = (UInt64)(Int64)-1;
+ fileSizeWasUsed = false;
+ }
+
+ {
+ Byte temp[8];
+ for (int i = 0; i < 8; i++)
+ temp[i]= (Byte)(fileSize >> (8 * i));
+ if (WriteStream(outStream, temp, 8) != S_OK)
+ throw kWriteError;
+ }
+
+ res = encoder->Code(inStream, outStream, NULL, NULL, progress);
+ if (progressSpec)
+ progressSpec->ClosePrint();
+
+ if (res != S_OK)
+ return Error_HRESULT("Encoding error", res);
+
+ UInt64 processedSize = encoderSpec->GetInputProcessedSize();
+
+ if (fileSizeWasUsed && processedSize != fileSize)
+ throw "Incorrect size of processed data";
+ }
+ else
+ {
+ NCompress::NLzma::CDecoder *decoderSpec = new NCompress::NLzma::CDecoder;
+ CMyComPtr<ICompressCoder> decoder = decoderSpec;
+
+ decoderSpec->FinishStream = true;
+
+ const unsigned kPropertiesSize = 5;
+ Byte header[kPropertiesSize + 8];
+
+ if (ReadStream_FALSE(inStream, header, kPropertiesSize + 8) != S_OK)
+ throw kReadError;
+
+ if (decoderSpec->SetDecoderProperties2(header, kPropertiesSize) != S_OK)
+ throw "SetDecoderProperties error";
+
+ UInt64 unpackSize = 0;
+ for (unsigned i = 0; i < 8; i++)
+ unpackSize |= ((UInt64)header[kPropertiesSize + i]) << (8 * i);
+
+ bool unpackSizeDefined = (unpackSize != (UInt64)(Int64)-1);
+
+ HRESULT res = decoder->Code(inStream, outStream, NULL, unpackSizeDefined ? &unpackSize : NULL, progress);
+ if (progressSpec)
+ progressSpec->ClosePrint();
+
+ if (res != S_OK)
+ {
+ if (res == S_FALSE)
+ {
+ PrintError("Decoding error");
+ return 1;
+ }
+ return Error_HRESULT("Decoding error", res);
+ }
+
+ if (unpackSizeDefined && unpackSize != decoderSpec->GetOutputProcessedSize())
+ throw "incorrect uncompressed size in header";
+ }
+ }
+
+ if (outStreamSpec)
+ {
+ if (!stdOutMode)
+ Print_Size("Output size: ", outStreamSpec->ProcessedSize);
+ if (outStreamSpec->Close() != S_OK)
+ throw "File closing error";
+ }
+
+ return 0;
+}
+
+int Z7_CDECL main(int numArgs, const char *args[])
+{
+ NConsoleClose::CCtrlHandlerSetter ctrlHandlerSetter;
+
+ try { return main2(numArgs, args); }
+ catch (const char *s)
+ {
+ PrintError(s);
+ return 1;
+ }
+ catch(...)
+ {
+ PrintError("Unknown Error");
+ return 1;
+ }
+}
diff --git a/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsp b/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsp
index bdc0c3e..5a8911b 100644
--- a/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsp
+++ b/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsp
@@ -1,477 +1,540 @@
-# Microsoft Developer Studio Project File - Name="LzmaCon" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=LzmaCon - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "LzmaCon.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "LzmaCon.mak" CFG="LzmaCon - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "LzmaCon - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "LzmaCon - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "LzmaCon - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /c
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\Util\lzma.exe"
-
-!ELSEIF "$(CFG)" == "LzmaCon - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W4 /WX /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\Util\lzma.exe" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "LzmaCon - Win32 Release"
-# Name "LzmaCon - Win32 Debug"
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\StdAfx.cpp
-# ADD CPP /Yc"StdAfx.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.h
-# End Source File
-# End Group
-# Begin Group "Compress"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaEncoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaEncoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaRegister.cpp
-# End Source File
-# End Group
-# Begin Group "Windows"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Thread.h
-# End Source File
-# End Group
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\ComTry.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CrcReg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Defs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyCom.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyUnknown.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyWindows.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyWindows.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringToInt.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringToInt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Types.h
-# End Source File
-# End Group
-# Begin Group "7zip Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\MethodProps.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\MethodProps.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.h
-# End Source File
-# End Group
-# Begin Group "UI Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Bench.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Bench.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.h
-# End Source File
-# End Group
-# Begin Group "Console"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Console\BenchCon.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\BenchCon.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ConsoleClose.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ConsoleClose.h
-# End Source File
-# End Group
-# Begin Group "C"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrcOpt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zTypes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra86.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\BraIA64.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFind.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFindMt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzFindMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzHash.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma86.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma86Dec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma86Enc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaEnc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaEnc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\LzmaAlone.cpp
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="LzmaCon" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=LzmaCon - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "LzmaCon.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "LzmaCon.mak" CFG="LzmaCon - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "LzmaCon - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "LzmaCon - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "LzmaCon - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\Util\lzma.exe"
+
+!ELSEIF "$(CFG)" == "LzmaCon - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\Util\lzma.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "LzmaCon - Win32 Release"
+# Name "LzmaCon - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaEncoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CrcReg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\LzFindPrepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyLinux.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyUnknown.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Types.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Bench.h
+# End Source File
+# End Group
+# Begin Group "Console"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Console\BenchCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\BenchCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzFindOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzHash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma86.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma86Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma86Enc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaEnc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "7zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\LzmaAlone.cpp
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsw b/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsw
index c6a6662..e62c9d2 100644
--- a/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsw
+++ b/CPP/7zip/Bundles/LzmaCon/LzmaCon.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "LzmaCon"=.\LzmaCon.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "LzmaCon"=.\LzmaCon.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/LzmaCon/StdAfx.cpp b/CPP/7zip/Bundles/LzmaCon/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/LzmaCon/StdAfx.cpp
+++ b/CPP/7zip/Bundles/LzmaCon/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/LzmaCon/StdAfx.h b/CPP/7zip/Bundles/LzmaCon/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Bundles/LzmaCon/StdAfx.h
+++ b/CPP/7zip/Bundles/LzmaCon/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/LzmaCon/makefile b/CPP/7zip/Bundles/LzmaCon/makefile
index 5a50808..f303c31 100644
--- a/CPP/7zip/Bundles/LzmaCon/makefile
+++ b/CPP/7zip/Bundles/LzmaCon/makefile
@@ -1,59 +1,67 @@
-PROG = lzma.exe
-MY_CONSOLE = 1
-
-CURRENT_OBJS = \
- $O\LzmaAlone.obj \
-
-COMPRESS_OBJS = \
- $O\LzmaDecoder.obj \
- $O\LzmaEncoder.obj \
- $O\LzmaRegister.obj \
-
-COMMON_OBJS = \
- $O\CommandLineParser.obj \
- $O\CRC.obj \
- $O\CrcReg.obj \
- $O\IntToString.obj \
- $O\MyString.obj \
- $O\NewHandler.obj \
- $O\StringConvert.obj \
- $O\StringToInt.obj \
- $O\MyVector.obj
-
-WIN_OBJS = \
- $O\FileIO.obj \
- $O\PropVariant.obj \
- $O\System.obj
-
-7ZIP_COMMON_OBJS = \
- $O\CWrappers.obj \
- $O\CreateCoder.obj \
- $O\FileStreams.obj \
- $O\FilterCoder.obj \
- $O\MethodProps.obj \
- $O\OutBuffer.obj \
- $O\StreamUtils.obj \
-
-UI_COMMON_OBJS = \
- $O\Bench.obj \
-
-CONSOLE_OBJS = \
- $O\ConsoleClose.obj \
- $O\BenchCon.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\Bra86.obj \
- $O\CpuArch.obj \
- $O\LzFind.obj \
- $O\LzFindMt.obj \
- $O\Lzma86Dec.obj \
- $O\Lzma86Enc.obj \
- $O\LzmaDec.obj \
- $O\LzmaEnc.obj \
- $O\Threads.obj \
-
-!include "../../Crc.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = lzma.exe
+MY_CONSOLE = 1
+
+# CFLAGS = $(CFLAGS) -DZ7_ST
+
+
+CURRENT_OBJS = \
+ $O\LzmaAlone.obj \
+
+COMPRESS_OBJS = \
+ $O\LzmaDecoder.obj \
+ $O\LzmaEncoder.obj \
+ $O\LzmaRegister.obj \
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\CrcReg.obj \
+ $O\IntToString.obj \
+ $O\LzFindPrepare.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\NewHandler.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\FileIO.obj \
+ $O\PropVariant.obj \
+ $O\Registry.obj \
+ $O\System.obj \
+ $O\SystemInfo.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\FileStreams.obj \
+ $O\FilterCoder.obj \
+ $O\MethodProps.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+
+UI_COMMON_OBJS = \
+ $O\Bench.obj \
+
+CONSOLE_OBJS = \
+ $O\ConsoleClose.obj \
+ $O\BenchCon.obj \
+
+C_OBJS = \
+ $O\Alloc.obj \
+ $O\Bra86.obj \
+ $O\CpuArch.obj \
+ $O\LzFind.obj \
+ $O\LzFindMt.obj \
+ $O\Lzma86Dec.obj \
+ $O\Lzma86Enc.obj \
+ $O\LzmaDec.obj \
+ $O\LzmaEnc.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+!include "../../LzFindOpt.mak"
+!include "../../LzmaDec.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/LzmaCon/makefile.gcc b/CPP/7zip/Bundles/LzmaCon/makefile.gcc
index 3fb5ec2..dd19a0e 100644
--- a/CPP/7zip/Bundles/LzmaCon/makefile.gcc
+++ b/CPP/7zip/Bundles/LzmaCon/makefile.gcc
@@ -1,195 +1,126 @@
-PROG = lzma
-CXX = g++ -O2
-# -Wall -Werror -Wno-delete-non-virtual-dtor
-CXX_C = gcc -O2 -Wall -Werror
-
-ifdef SystemDrive
-IS_MINGW = 1
-endif
-
-ifdef IS_MINGW
-
-RM = del
-CFLAGS = -c
-LIB2 = -loleaut32 -luuid
-LDFLAGS = -s
-
-FILE_IO =FileIO
-FILE_IO_2 =Windows/$(FILE_IO)
-
-MT_FILES = \
- LzFindMt.o \
- Threads.o \
-
-else
-
-RM = rm -f
-CFLAGS = -c -D_7ZIP_ST
-
-FILE_IO =C_FileIO
-FILE_IO_2 =Common/$(FILE_IO)
-
-
-endif
-
-
-OBJS = \
- $(MT_FILES) \
- $(FILE_IO).o \
- LzmaAlone.o \
- Bench.o \
- BenchCon.o \
- ConsoleClose.o \
- LzmaDecoder.o \
- LzmaEncoder.o \
- LzmaRegister.o \
- CreateCoder.o \
- CWrappers.o \
- FileStreams.o \
- FilterCoder.o \
- MethodProps.o \
- StreamUtils.o \
- CommandLineParser.o \
- CRC.o \
- CrcReg.o \
- IntToString.o \
- MyString.o \
- MyVector.o \
- MyWindows.o \
- StringConvert.o \
- StringToInt.o \
- PropVariant.o \
- System.o \
- 7zCrc.o \
- 7zCrcOpt.o \
- Alloc.o \
- Bra86.o \
- CpuArch.o \
- LzFind.o \
- LzmaDec.o \
- LzmaEnc.o \
- Lzma86Dec.o \
- Lzma86Enc.o \
-
-
-all: $(PROG)
-
-$(PROG): $(OBJS)
- $(CXX) -o $(PROG) $(LDFLAGS) $(OBJS) $(LIB2)
-
-LzmaAlone.o: LzmaAlone.cpp
- $(CXX) $(CFLAGS) LzmaAlone.cpp
-
-Bench.o: ../../UI/Common/Bench.cpp
- $(CXX) $(CFLAGS) ../../UI/Common/Bench.cpp
-
-BenchCon.o: ../../UI/Console/BenchCon.cpp
- $(CXX) $(CFLAGS) ../../UI/Console/BenchCon.cpp
-
-ConsoleClose.o: ../../UI/Console/ConsoleClose.cpp
- $(CXX) $(CFLAGS) ../../UI/Console/ConsoleClose.cpp
-
-LzmaDecoder.o: ../../Compress/LzmaDecoder.cpp
- $(CXX) $(CFLAGS) ../../Compress/LzmaDecoder.cpp
-
-LzmaEncoder.o: ../../Compress/LzmaEncoder.cpp
- $(CXX) $(CFLAGS) ../../Compress/LzmaEncoder.cpp
-
-LzmaRegister.o: ../../Compress/LzmaRegister.cpp
- $(CXX) $(CFLAGS) ../../Compress/LzmaRegister.cpp
-
-CreateCoder.o: ../../Common/CreateCoder.cpp
- $(CXX) $(CFLAGS) ../../Common/CreateCoder.cpp
-
-CWrappers.o: ../../Common/CWrappers.cpp
- $(CXX) $(CFLAGS) ../../Common/CWrappers.cpp
-
-FileStreams.o: ../../Common/FileStreams.cpp
- $(CXX) $(CFLAGS) ../../Common/FileStreams.cpp
-
-FilterCoder.o: ../../Common/FilterCoder.cpp
- $(CXX) $(CFLAGS) ../../Common/FilterCoder.cpp
-
-MethodProps.o: ../../Common/MethodProps.cpp
- $(CXX) $(CFLAGS) ../../Common/MethodProps.cpp
-
-StreamUtils.o: ../../Common/StreamUtils.cpp
- $(CXX) $(CFLAGS) ../../Common/StreamUtils.cpp
-
-$(FILE_IO).o: ../../../$(FILE_IO_2).cpp
- $(CXX) $(CFLAGS) ../../../$(FILE_IO_2).cpp
-
-
-CommandLineParser.o: ../../../Common/CommandLineParser.cpp
- $(CXX) $(CFLAGS) ../../../Common/CommandLineParser.cpp
-
-CRC.o: ../../../Common/CRC.cpp
- $(CXX) $(CFLAGS) ../../../Common/CRC.cpp
-
-CrcReg.o: ../../../Common/CrcReg.cpp
- $(CXX) $(CFLAGS) ../../../Common/CrcReg.cpp
-
-IntToString.o: ../../../Common/IntToString.cpp
- $(CXX) $(CFLAGS) ../../../Common/IntToString.cpp
-
-MyString.o: ../../../Common/MyString.cpp
- $(CXX) $(CFLAGS) ../../../Common/MyString.cpp
-
-MyVector.o: ../../../Common/MyVector.cpp
- $(CXX) $(CFLAGS) ../../../Common/MyVector.cpp
-
-MyWindows.o: ../../../Common/MyWindows.cpp
- $(CXX) $(CFLAGS) ../../../Common/MyWindows.cpp
-
-StringConvert.o: ../../../Common/StringConvert.cpp
- $(CXX) $(CFLAGS) ../../../Common/StringConvert.cpp
-
-StringToInt.o: ../../../Common/StringToInt.cpp
- $(CXX) $(CFLAGS) ../../../Common/StringToInt.cpp
-
-PropVariant.o: ../../../Windows/PropVariant.cpp
- $(CXX) $(CFLAGS) ../../../Windows/PropVariant.cpp
-
-System.o: ../../../Windows/System.cpp
- $(CXX) $(CFLAGS) ../../../Windows/System.cpp
-
-7zCrc.o: ../../../../C/7zCrc.c
- $(CXX_C) $(CFLAGS) ../../../../C/7zCrc.c
-
-7zCrcOpt.o: ../../../../C/7zCrcOpt.c
- $(CXX_C) $(CFLAGS) ../../../../C/7zCrcOpt.c
-
-Alloc.o: ../../../../C/Alloc.c
- $(CXX_C) $(CFLAGS) ../../../../C/Alloc.c
-
-Bra86.o: ../../../../C/Bra86.c
- $(CXX_C) $(CFLAGS) ../../../../C/Bra86.c
-
-CpuArch.o: ../../../../C/CpuArch.c
- $(CXX_C) $(CFLAGS) ../../../../C/CpuArch.c
-
-LzFind.o: ../../../../C/LzFind.c
- $(CXX_C) $(CFLAGS) ../../../../C/LzFind.c
-
-ifdef MT_FILES
-LzFindMt.o: ../../../../C/LzFindMt.c
- $(CXX_C) $(CFLAGS) ../../../../C/LzFindMt.c
-
-Threads.o: ../../../../C/Threads.c
- $(CXX_C) $(CFLAGS) ../../../../C/Threads.c
-endif
-
-LzmaDec.o: ../../../../C/LzmaDec.c
- $(CXX_C) $(CFLAGS) ../../../../C/LzmaDec.c
-
-LzmaEnc.o: ../../../../C/LzmaEnc.c
- $(CXX_C) $(CFLAGS) ../../../../C/LzmaEnc.c
-
-Lzma86Dec.o: ../../../../C/Lzma86Dec.c
- $(CXX_C) $(CFLAGS) ../../../../C/Lzma86Dec.c
-
-Lzma86Enc.o: ../../../../C/Lzma86Enc.c
- $(CXX_C) $(CFLAGS) ../../../../C/Lzma86Enc.c
-
-clean:
- -$(RM) $(PROG) $(OBJS)
+PROG = lzma
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+include ../../LzmaDec_gcc.mak
+
+LOCAL_FLAGS_ST =
+MT_OBJS =
+
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef ST_MODE
+
+LOCAL_FLAGS_ST = -DZ7_ST
+
+else
+
+MT_OBJS = \
+ $O/LzFindMt.o \
+ $O/LzFindOpt.o \
+ $O/Synchronization.o \
+ $O/Threads.o \
+
+
+
+endif
+
+
+
+LOCAL_FLAGS_SYS =
+
+ifdef IS_MINGW
+
+SYS_OBJS = \
+ $O/Registry.o \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileName.o \
+ $O/MyWindows.o \
+ $O/TimeUtils.o \
+
+endif
+
+LOCAL_FLAGS = \
+ $(LOCAL_FLAGS_ST) \
+
+
+COMMON_OBJS = \
+ $O/CommandLineParser.o \
+ $O/CRC.o \
+ $O/CrcReg.o \
+ $O/IntToString.o \
+ $O/LzFindPrepare.o \
+ $O/MyString.o \
+ $O/MyVector.o \
+ $O/NewHandler.o \
+ $O/StringConvert.o \
+ $O/StringToInt.o \
+ $O/UTFConvert.o \
+ $O/Wildcard.o \
+
+WIN_OBJS = \
+ $O/FileIO.o \
+ $O/PropVariant.o \
+ $O/System.o \
+ $O/SystemInfo.o \
+
+COMPRESS_OBJS = \
+ $O/LzmaDecoder.o \
+ $O/LzmaEncoder.o \
+ $O/LzmaRegister.o \
+
+CONSOLE_OBJS = \
+ $O/BenchCon.o \
+ $O/ConsoleClose.o \
+
+7ZIP_COMMON_OBJS = \
+ $O/CreateCoder.o \
+ $O/CWrappers.o \
+ $O/FileStreams.o \
+ $O/FilterCoder.o \
+ $O/MethodProps.o \
+ $O/StreamObjects.o \
+ $O/StreamUtils.o \
+
+C_OBJS = \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+ $O/Alloc.o \
+ $O/Bra86.o \
+ $O/CpuArch.o \
+ $O/LzFind.o \
+ $O/LzmaDec.o \
+ $O/LzmaEnc.o \
+ $O/Lzma86Dec.o \
+ $O/Lzma86Enc.o \
+
+OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $(C_OBJS) \
+ $(MT_OBJS) \
+ $(SYS_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(CONSOLE_OBJS) \
+ $O/LzmaAlone.o \
+ $O/Bench.o \
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/Bundles/LzmaCon/resource.rc b/CPP/7zip/Bundles/LzmaCon/resource.rc
index 9b54fa8..43b5073 100644
--- a/CPP/7zip/Bundles/LzmaCon/resource.rc
+++ b/CPP/7zip/Bundles/LzmaCon/resource.rc
@@ -1,3 +1,3 @@
-#include "../../MyVersionInfo.rc"
-
-MY_VERSION_INFO_APP("LZMA", "lzma")
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_APP("LZMA", "lzma")
diff --git a/CPP/7zip/Bundles/LzmaSpec/LzmaSpec.cpp b/CPP/7zip/Bundles/LzmaSpec/LzmaSpec.cpp
deleted file mode 100644
index 67e8dfc..0000000
--- a/CPP/7zip/Bundles/LzmaSpec/LzmaSpec.cpp
+++ /dev/null
@@ -1,715 +0,0 @@
-/* LzmaSpec.cpp -- LZMA Reference Decoder
-2015-06-14 : Igor Pavlov : Public domain */
-
-// This code implements LZMA file decoding according to LZMA specification.
-// This code is not optimized for speed.
-
-#include <stdio.h>
-
-#ifdef _MSC_VER
- #pragma warning(disable : 4710) // function not inlined
- #pragma warning(disable : 4996) // This function or variable may be unsafe
-#endif
-
-typedef unsigned char Byte;
-typedef unsigned short UInt16;
-
-#ifdef _LZMA_UINT32_IS_ULONG
- typedef unsigned long UInt32;
-#else
- typedef unsigned int UInt32;
-#endif
-
-#if defined(_MSC_VER) || defined(__BORLANDC__)
- typedef unsigned __int64 UInt64;
-#else
- typedef unsigned long long int UInt64;
-#endif
-
-
-struct CInputStream
-{
- FILE *File;
- UInt64 Processed;
-
- void Init() { Processed = 0; }
-
- Byte ReadByte()
- {
- int c = getc(File);
- if (c < 0)
- throw "Unexpected end of file";
- Processed++;
- return (Byte)c;
- }
-};
-
-
-struct COutStream
-{
- FILE *File;
- UInt64 Processed;
-
- void Init() { Processed = 0; }
-
- void WriteByte(Byte b)
- {
- if (putc(b, File) == EOF)
- throw "File writing error";
- Processed++;
- }
-};
-
-
-class COutWindow
-{
- Byte *Buf;
- UInt32 Pos;
- UInt32 Size;
- bool IsFull;
-
-public:
- unsigned TotalPos;
- COutStream OutStream;
-
- COutWindow(): Buf(NULL) {}
- ~COutWindow() { delete []Buf; }
-
- void Create(UInt32 dictSize)
- {
- Buf = new Byte[dictSize];
- Pos = 0;
- Size = dictSize;
- IsFull = false;
- TotalPos = 0;
- }
-
- void PutByte(Byte b)
- {
- TotalPos++;
- Buf[Pos++] = b;
- if (Pos == Size)
- {
- Pos = 0;
- IsFull = true;
- }
- OutStream.WriteByte(b);
- }
-
- Byte GetByte(UInt32 dist) const
- {
- return Buf[dist <= Pos ? Pos - dist : Size - dist + Pos];
- }
-
- void CopyMatch(UInt32 dist, unsigned len)
- {
- for (; len > 0; len--)
- PutByte(GetByte(dist));
- }
-
- bool CheckDistance(UInt32 dist) const
- {
- return dist <= Pos || IsFull;
- }
-
- bool IsEmpty() const
- {
- return Pos == 0 && !IsFull;
- }
-};
-
-
-#define kNumBitModelTotalBits 11
-#define kNumMoveBits 5
-
-typedef UInt16 CProb;
-
-#define PROB_INIT_VAL ((1 << kNumBitModelTotalBits) / 2)
-
-#define INIT_PROBS(p) \
- { for (unsigned i = 0; i < sizeof(p) / sizeof(p[0]); i++) p[i] = PROB_INIT_VAL; }
-
-class CRangeDecoder
-{
- UInt32 Range;
- UInt32 Code;
-
- void Normalize();
-
-public:
-
- CInputStream *InStream;
- bool Corrupted;
-
- bool Init();
- bool IsFinishedOK() const { return Code == 0; }
-
- UInt32 DecodeDirectBits(unsigned numBits);
- unsigned DecodeBit(CProb *prob);
-};
-
-bool CRangeDecoder::Init()
-{
- Corrupted = false;
- Range = 0xFFFFFFFF;
- Code = 0;
-
- Byte b = InStream->ReadByte();
-
- for (int i = 0; i < 4; i++)
- Code = (Code << 8) | InStream->ReadByte();
-
- if (b != 0 || Code == Range)
- Corrupted = true;
- return b == 0;
-}
-
-#define kTopValue ((UInt32)1 << 24)
-
-void CRangeDecoder::Normalize()
-{
- if (Range < kTopValue)
- {
- Range <<= 8;
- Code = (Code << 8) | InStream->ReadByte();
- }
-}
-
-UInt32 CRangeDecoder::DecodeDirectBits(unsigned numBits)
-{
- UInt32 res = 0;
- do
- {
- Range >>= 1;
- Code -= Range;
- UInt32 t = 0 - ((UInt32)Code >> 31);
- Code += Range & t;
-
- if (Code == Range)
- Corrupted = true;
-
- Normalize();
- res <<= 1;
- res += t + 1;
- }
- while (--numBits);
- return res;
-}
-
-unsigned CRangeDecoder::DecodeBit(CProb *prob)
-{
- unsigned v = *prob;
- UInt32 bound = (Range >> kNumBitModelTotalBits) * v;
- unsigned symbol;
- if (Code < bound)
- {
- v += ((1 << kNumBitModelTotalBits) - v) >> kNumMoveBits;
- Range = bound;
- symbol = 0;
- }
- else
- {
- v -= v >> kNumMoveBits;
- Code -= bound;
- Range -= bound;
- symbol = 1;
- }
- *prob = (CProb)v;
- Normalize();
- return symbol;
-}
-
-
-unsigned BitTreeReverseDecode(CProb *probs, unsigned numBits, CRangeDecoder *rc)
-{
- unsigned m = 1;
- unsigned symbol = 0;
- for (unsigned i = 0; i < numBits; i++)
- {
- unsigned bit = rc->DecodeBit(&probs[m]);
- m <<= 1;
- m += bit;
- symbol |= (bit << i);
- }
- return symbol;
-}
-
-template <unsigned NumBits>
-class CBitTreeDecoder
-{
- CProb Probs[(unsigned)1 << NumBits];
-
-public:
-
- void Init()
- {
- INIT_PROBS(Probs);
- }
-
- unsigned Decode(CRangeDecoder *rc)
- {
- unsigned m = 1;
- for (unsigned i = 0; i < NumBits; i++)
- m = (m << 1) + rc->DecodeBit(&Probs[m]);
- return m - ((unsigned)1 << NumBits);
- }
-
- unsigned ReverseDecode(CRangeDecoder *rc)
- {
- return BitTreeReverseDecode(Probs, NumBits, rc);
- }
-};
-
-#define kNumPosBitsMax 4
-
-#define kNumStates 12
-#define kNumLenToPosStates 4
-#define kNumAlignBits 4
-#define kStartPosModelIndex 4
-#define kEndPosModelIndex 14
-#define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
-#define kMatchMinLen 2
-
-class CLenDecoder
-{
- CProb Choice;
- CProb Choice2;
- CBitTreeDecoder<3> LowCoder[1 << kNumPosBitsMax];
- CBitTreeDecoder<3> MidCoder[1 << kNumPosBitsMax];
- CBitTreeDecoder<8> HighCoder;
-
-public:
-
- void Init()
- {
- Choice = PROB_INIT_VAL;
- Choice2 = PROB_INIT_VAL;
- HighCoder.Init();
- for (unsigned i = 0; i < (1 << kNumPosBitsMax); i++)
- {
- LowCoder[i].Init();
- MidCoder[i].Init();
- }
- }
-
- unsigned Decode(CRangeDecoder *rc, unsigned posState)
- {
- if (rc->DecodeBit(&Choice) == 0)
- return LowCoder[posState].Decode(rc);
- if (rc->DecodeBit(&Choice2) == 0)
- return 8 + MidCoder[posState].Decode(rc);
- return 16 + HighCoder.Decode(rc);
- }
-};
-
-unsigned UpdateState_Literal(unsigned state)
-{
- if (state < 4) return 0;
- else if (state < 10) return state - 3;
- else return state - 6;
-}
-unsigned UpdateState_Match (unsigned state) { return state < 7 ? 7 : 10; }
-unsigned UpdateState_Rep (unsigned state) { return state < 7 ? 8 : 11; }
-unsigned UpdateState_ShortRep(unsigned state) { return state < 7 ? 9 : 11; }
-
-#define LZMA_DIC_MIN (1 << 12)
-
-class CLzmaDecoder
-{
-public:
- CRangeDecoder RangeDec;
- COutWindow OutWindow;
-
- bool markerIsMandatory;
- unsigned lc, pb, lp;
- UInt32 dictSize;
- UInt32 dictSizeInProperties;
-
- void DecodeProperties(const Byte *properties)
- {
- unsigned d = properties[0];
- if (d >= (9 * 5 * 5))
- throw "Incorrect LZMA properties";
- lc = d % 9;
- d /= 9;
- pb = d / 5;
- lp = d % 5;
- dictSizeInProperties = 0;
- for (int i = 0; i < 4; i++)
- dictSizeInProperties |= (UInt32)properties[i + 1] << (8 * i);
- dictSize = dictSizeInProperties;
- if (dictSize < LZMA_DIC_MIN)
- dictSize = LZMA_DIC_MIN;
- }
-
- CLzmaDecoder(): LitProbs(NULL) {}
- ~CLzmaDecoder() { delete []LitProbs; }
-
- void Create()
- {
- OutWindow.Create(dictSize);
- CreateLiterals();
- }
-
- int Decode(bool unpackSizeDefined, UInt64 unpackSize);
-
-private:
-
- CProb *LitProbs;
-
- void CreateLiterals()
- {
- LitProbs = new CProb[(UInt32)0x300 << (lc + lp)];
- }
-
- void InitLiterals()
- {
- UInt32 num = (UInt32)0x300 << (lc + lp);
- for (UInt32 i = 0; i < num; i++)
- LitProbs[i] = PROB_INIT_VAL;
- }
-
- void DecodeLiteral(unsigned state, UInt32 rep0)
- {
- unsigned prevByte = 0;
- if (!OutWindow.IsEmpty())
- prevByte = OutWindow.GetByte(1);
-
- unsigned symbol = 1;
- unsigned litState = ((OutWindow.TotalPos & ((1 << lp) - 1)) << lc) + (prevByte >> (8 - lc));
- CProb *probs = &LitProbs[(UInt32)0x300 * litState];
-
- if (state >= 7)
- {
- unsigned matchByte = OutWindow.GetByte(rep0 + 1);
- do
- {
- unsigned matchBit = (matchByte >> 7) & 1;
- matchByte <<= 1;
- unsigned bit = RangeDec.DecodeBit(&probs[((1 + matchBit) << 8) + symbol]);
- symbol = (symbol << 1) | bit;
- if (matchBit != bit)
- break;
- }
- while (symbol < 0x100);
- }
- while (symbol < 0x100)
- symbol = (symbol << 1) | RangeDec.DecodeBit(&probs[symbol]);
- OutWindow.PutByte((Byte)(symbol - 0x100));
- }
-
- CBitTreeDecoder<6> PosSlotDecoder[kNumLenToPosStates];
- CBitTreeDecoder<kNumAlignBits> AlignDecoder;
- CProb PosDecoders[1 + kNumFullDistances - kEndPosModelIndex];
-
- void InitDist()
- {
- for (unsigned i = 0; i < kNumLenToPosStates; i++)
- PosSlotDecoder[i].Init();
- AlignDecoder.Init();
- INIT_PROBS(PosDecoders);
- }
-
- unsigned DecodeDistance(unsigned len)
- {
- unsigned lenState = len;
- if (lenState > kNumLenToPosStates - 1)
- lenState = kNumLenToPosStates - 1;
-
- unsigned posSlot = PosSlotDecoder[lenState].Decode(&RangeDec);
- if (posSlot < 4)
- return posSlot;
-
- unsigned numDirectBits = (unsigned)((posSlot >> 1) - 1);
- UInt32 dist = ((2 | (posSlot & 1)) << numDirectBits);
- if (posSlot < kEndPosModelIndex)
- dist += BitTreeReverseDecode(PosDecoders + dist - posSlot, numDirectBits, &RangeDec);
- else
- {
- dist += RangeDec.DecodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;
- dist += AlignDecoder.ReverseDecode(&RangeDec);
- }
- return dist;
- }
-
- CProb IsMatch[kNumStates << kNumPosBitsMax];
- CProb IsRep[kNumStates];
- CProb IsRepG0[kNumStates];
- CProb IsRepG1[kNumStates];
- CProb IsRepG2[kNumStates];
- CProb IsRep0Long[kNumStates << kNumPosBitsMax];
-
- CLenDecoder LenDecoder;
- CLenDecoder RepLenDecoder;
-
- void Init()
- {
- InitLiterals();
- InitDist();
-
- INIT_PROBS(IsMatch);
- INIT_PROBS(IsRep);
- INIT_PROBS(IsRepG0);
- INIT_PROBS(IsRepG1);
- INIT_PROBS(IsRepG2);
- INIT_PROBS(IsRep0Long);
-
- LenDecoder.Init();
- RepLenDecoder.Init();
- }
-};
-
-
-#define LZMA_RES_ERROR 0
-#define LZMA_RES_FINISHED_WITH_MARKER 1
-#define LZMA_RES_FINISHED_WITHOUT_MARKER 2
-
-int CLzmaDecoder::Decode(bool unpackSizeDefined, UInt64 unpackSize)
-{
- if (!RangeDec.Init())
- return LZMA_RES_ERROR;
-
- Init();
-
- UInt32 rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
- unsigned state = 0;
-
- for (;;)
- {
- if (unpackSizeDefined && unpackSize == 0 && !markerIsMandatory)
- if (RangeDec.IsFinishedOK())
- return LZMA_RES_FINISHED_WITHOUT_MARKER;
-
- unsigned posState = OutWindow.TotalPos & ((1 << pb) - 1);
-
- if (RangeDec.DecodeBit(&IsMatch[(state << kNumPosBitsMax) + posState]) == 0)
- {
- if (unpackSizeDefined && unpackSize == 0)
- return LZMA_RES_ERROR;
- DecodeLiteral(state, rep0);
- state = UpdateState_Literal(state);
- unpackSize--;
- continue;
- }
-
- unsigned len;
-
- if (RangeDec.DecodeBit(&IsRep[state]) != 0)
- {
- if (unpackSizeDefined && unpackSize == 0)
- return LZMA_RES_ERROR;
- if (OutWindow.IsEmpty())
- return LZMA_RES_ERROR;
- if (RangeDec.DecodeBit(&IsRepG0[state]) == 0)
- {
- if (RangeDec.DecodeBit(&IsRep0Long[(state << kNumPosBitsMax) + posState]) == 0)
- {
- state = UpdateState_ShortRep(state);
- OutWindow.PutByte(OutWindow.GetByte(rep0 + 1));
- unpackSize--;
- continue;
- }
- }
- else
- {
- UInt32 dist;
- if (RangeDec.DecodeBit(&IsRepG1[state]) == 0)
- dist = rep1;
- else
- {
- if (RangeDec.DecodeBit(&IsRepG2[state]) == 0)
- dist = rep2;
- else
- {
- dist = rep3;
- rep3 = rep2;
- }
- rep2 = rep1;
- }
- rep1 = rep0;
- rep0 = dist;
- }
- len = RepLenDecoder.Decode(&RangeDec, posState);
- state = UpdateState_Rep(state);
- }
- else
- {
- rep3 = rep2;
- rep2 = rep1;
- rep1 = rep0;
- len = LenDecoder.Decode(&RangeDec, posState);
- state = UpdateState_Match(state);
- rep0 = DecodeDistance(len);
- if (rep0 == 0xFFFFFFFF)
- return RangeDec.IsFinishedOK() ?
- LZMA_RES_FINISHED_WITH_MARKER :
- LZMA_RES_ERROR;
-
- if (unpackSizeDefined && unpackSize == 0)
- return LZMA_RES_ERROR;
- if (rep0 >= dictSize || !OutWindow.CheckDistance(rep0))
- return LZMA_RES_ERROR;
- }
- len += kMatchMinLen;
- bool isError = false;
- if (unpackSizeDefined && unpackSize < len)
- {
- len = (unsigned)unpackSize;
- isError = true;
- }
- OutWindow.CopyMatch(rep0 + 1, len);
- unpackSize -= len;
- if (isError)
- return LZMA_RES_ERROR;
- }
-}
-
-static void Print(const char *s)
-{
- fputs(s, stdout);
-}
-
-static void PrintError(const char *s)
-{
- fputs(s, stderr);
-}
-
-
-#define CONVERT_INT_TO_STR(charType, tempSize) \
-
-void ConvertUInt64ToString(UInt64 val, char *s)
-{
- char temp[32];
- unsigned i = 0;
- while (val >= 10)
- {
- temp[i++] = (char)('0' + (unsigned)(val % 10));
- val /= 10;
- }
- *s++ = (char)('0' + (unsigned)val);
- while (i != 0)
- {
- i--;
- *s++ = temp[i];
- }
- *s = 0;
-}
-
-void PrintUInt64(const char *title, UInt64 v)
-{
- Print(title);
- Print(" : ");
- char s[32];
- ConvertUInt64ToString(v, s);
- Print(s);
- Print(" bytes \n");
-}
-
-int main2(int numArgs, const char *args[])
-{
- Print("\nLZMA Reference Decoder 15.00 : Igor Pavlov : Public domain : 2015-04-16\n");
- if (numArgs == 1)
- Print("\nUse: lzmaSpec a.lzma outFile");
-
- if (numArgs != 3)
- throw "you must specify two parameters";
-
- CInputStream inStream;
- inStream.File = fopen(args[1], "rb");
- inStream.Init();
- if (inStream.File == 0)
- throw "Can't open input file";
-
- CLzmaDecoder lzmaDecoder;
- lzmaDecoder.OutWindow.OutStream.File = fopen(args[2], "wb+");
- lzmaDecoder.OutWindow.OutStream.Init();
- if (inStream.File == 0)
- throw "Can't open output file";
-
- Byte header[13];
- int i;
- for (i = 0; i < 13; i++)
- header[i] = inStream.ReadByte();
-
- lzmaDecoder.DecodeProperties(header);
-
- printf("\nlc=%d, lp=%d, pb=%d", lzmaDecoder.lc, lzmaDecoder.lp, lzmaDecoder.pb);
- printf("\nDictionary Size in properties = %u", lzmaDecoder.dictSizeInProperties);
- printf("\nDictionary Size for decoding = %u", lzmaDecoder.dictSize);
-
- UInt64 unpackSize = 0;
- bool unpackSizeDefined = false;
- for (i = 0; i < 8; i++)
- {
- Byte b = header[5 + i];
- if (b != 0xFF)
- unpackSizeDefined = true;
- unpackSize |= (UInt64)b << (8 * i);
- }
-
- lzmaDecoder.markerIsMandatory = !unpackSizeDefined;
-
- Print("\n");
- if (unpackSizeDefined)
- PrintUInt64("Uncompressed Size", unpackSize);
- else
- Print("End marker is expected\n");
- lzmaDecoder.RangeDec.InStream = &inStream;
-
- Print("\n");
-
- lzmaDecoder.Create();
-
- int res = lzmaDecoder.Decode(unpackSizeDefined, unpackSize);
-
- PrintUInt64("Read ", inStream.Processed);
- PrintUInt64("Written ", lzmaDecoder.OutWindow.OutStream.Processed);
-
- if (res == LZMA_RES_ERROR)
- throw "LZMA decoding error";
- else if (res == LZMA_RES_FINISHED_WITHOUT_MARKER)
- Print("Finished without end marker");
- else if (res == LZMA_RES_FINISHED_WITH_MARKER)
- {
- if (unpackSizeDefined)
- {
- if (lzmaDecoder.OutWindow.OutStream.Processed != unpackSize)
- throw "Finished with end marker before than specified size";
- Print("Warning: ");
- }
- Print("Finished with end marker");
- }
- else
- throw "Internal Error";
-
- Print("\n");
-
- if (lzmaDecoder.RangeDec.Corrupted)
- {
- Print("\nWarning: LZMA stream is corrupted\n");
- }
-
- return 0;
-}
-
-
-int
- #ifdef _MSC_VER
- __cdecl
- #endif
-main(int numArgs, const char *args[])
-{
- try { return main2(numArgs, args); }
- catch (const char *s)
- {
- PrintError("\nError:\n");
- PrintError(s);
- PrintError("\n");
- return 1;
- }
- catch(...)
- {
- PrintError("\nError\n");
- return 1;
- }
-}
diff --git a/CPP/7zip/Bundles/SFXCon/SFXCon.dsp b/CPP/7zip/Bundles/SFXCon/SFXCon.dsp
index 8775319..1bb063d 100644
--- a/CPP/7zip/Bundles/SFXCon/SFXCon.dsp
+++ b/CPP/7zip/Bundles/SFXCon/SFXCon.dsp
@@ -1,912 +1,1009 @@
-# Microsoft Developer Studio Project File - Name="SFXCon" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=SFXCon - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "SFXCon.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "SFXCon.mak" CFG="SFXCon - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "SFXCon - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "SFXCon - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "SFXCon - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "EXTRACT_ONLY" /D "_SFX" /D "NO_READ_FROM_CODER" /Yu"StdAfx.h" /FD /c
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\Util\7zCon.exe" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "SFXCon - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /I "..\..\..\..\\" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "EXTRACT_ONLY" /D "_SFX" /D "NO_READ_FROM_CODER" /Yu"StdAfx.h" /FD /GZ /c
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\Util\7zCon.exe" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "SFXCon - Win32 Release"
-# Name "SFXCon - Win32 Debug"
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\resource.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\resource.rc
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.cpp
-# ADD CPP /Yc"StdAfx.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.h
-# End Source File
-# End Group
-# Begin Group "Archive Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\HandlerOut.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\MultiStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\MultiStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
-# End Source File
-# End Group
-# Begin Group "Console"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ConsoleClose.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ConsoleClose.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ExtractCallbackConsole.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\ExtractCallbackConsole.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\List.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\List.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\MainAr.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\OpenCallbackConsole.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\OpenCallbackConsole.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\PercentPrinter.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\PercentPrinter.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\UserInputUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Console\UserInputUtils.h
-# End Source File
-# End Group
-# Begin Group "7z"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zExtract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHeader.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zItem.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\SplitHandler.cpp
-# End Source File
-# End Group
-# Begin Group "Compress"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Coder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\DeltaFilter.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\PpmdDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\PpmdRegister.cpp
-# End Source File
-# End Group
-# Begin Group "Crypto"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAes.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAesRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\MyAes.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\MyAes.h
-# End Source File
-# End Group
-# Begin Group "Windows"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.h
-# End Source File
-# End Group
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdInStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdInStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdOutStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StdOutStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\UTFConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\UTFConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.h
-# End Source File
-# End Group
-# Begin Group "7zip Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilePathAutoRename.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilePathAutoRename.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LockedStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LockedStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OffsetStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OffsetStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\PropId.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\RegisterArc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\RegisterCodec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.h
-# End Source File
-# End Group
-# Begin Group "UI"
-
-# PROP Default_Filter ""
-# Begin Group "UI Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExitCode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Extract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Extract.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractingFilePath.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractMode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\PropIDUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\PropIDUtils.h
-# End Source File
-# End Group
-# End Group
-# Begin Group "C"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrcOpt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Aes.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Aes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\AesOpt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra86.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\BraIA64.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Ppmd7.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Ppmd7.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Ppmd7Dec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Sha256.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Sha256.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\7z.ico
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\IArchive.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\SfxCon.cpp
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="SFXCon" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=SFXCon - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "SFXCon.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "SFXCon.mak" CFG="SFXCon - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "SFXCon - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "SFXCon - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "SFXCon - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_SFX" /D "Z7_NO_READ_FROM_CODER" /FAcs /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\Util\7zCon.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "SFXCon - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /I "..\..\..\..\\" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_SFX" /D "Z7_NO_READ_FROM_CODER" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\Util\7zCon.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "SFXCon - Win32 Release"
+# Name "SFXCon - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\HandlerOut.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# End Group
+# Begin Group "Console"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ConsoleClose.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ExtractCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\ExtractCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\List.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\List.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\MainAr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\OpenCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\OpenCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\PercentPrinter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\PercentPrinter.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UserInputUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Console\UserInputUtils.h
+# End Source File
+# End Group
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SplitHandler.cpp
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeltaFilter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Crypto"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAesRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OffsetStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterArc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterCodec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "UI"
+
+# PROP Default_Filter ""
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\PropIDUtils.h
+# End Source File
+# End Group
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\AesOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BraIA64.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+
+!IF "$(CFG)" == "SFXCon - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "SFXCon - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "7zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7z.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\SfxCon.cpp
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/SFXCon/SFXCon.dsw b/CPP/7zip/Bundles/SFXCon/SFXCon.dsw
index bfbc2b7..27bf7e6 100644
--- a/CPP/7zip/Bundles/SFXCon/SFXCon.dsw
+++ b/CPP/7zip/Bundles/SFXCon/SFXCon.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "SFXCon"=.\SFXCon.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "SFXCon"=.\SFXCon.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/SFXCon/SfxCon.cpp b/CPP/7zip/Bundles/SFXCon/SfxCon.cpp
index 9b34a08..cfce24d 100644
--- a/CPP/7zip/Bundles/SFXCon/SfxCon.cpp
+++ b/CPP/7zip/Bundles/SFXCon/SfxCon.cpp
@@ -1,482 +1,521 @@
-// Main.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/CpuArch.h"
-
-#include "../../../Common/MyWindows.h"
-
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/MyException.h"
-
-#ifdef _WIN32
-#include "../../../Windows/DLL.h"
-#include "../../../Windows/FileDir.h"
-#endif
-#include "../../../Windows/FileName.h"
-
-#include "../../UI/Common/ExitCode.h"
-#include "../../UI/Common/Extract.h"
-
-#include "../../UI/Console/ExtractCallbackConsole.h"
-#include "../../UI/Console/List.h"
-#include "../../UI/Console/OpenCallbackConsole.h"
-
-#include "../../MyVersion.h"
-
-#include "../../../../C/DllSecur.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-using namespace NCommandLineParser;
-
-#ifdef _WIN32
-HINSTANCE g_hInstance = 0;
-#endif
-int g_CodePage = -1;
-extern CStdOutStream *g_StdStream;
-
-static const char * const kCopyrightString =
-"\n7-Zip SFX " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n";
-
-static const int kNumSwitches = 6;
-
-namespace NKey {
-enum Enum
-{
- kHelp1 = 0,
- kHelp2,
- kDisablePercents,
- kYes,
- kPassword,
- kOutputDir
-};
-
-}
-
-namespace NRecursedType {
-enum EEnum
-{
- kRecursed,
- kWildcardOnlyRecursed,
- kNonRecursed
-};
-}
-/*
-static const char kRecursedIDChar = 'R';
-
-namespace NRecursedPostCharIndex {
- enum EEnum
- {
- kWildcardRecursionOnly = 0,
- kNoRecursion = 1
- };
-}
-
-static const char kFileListID = '@';
-static const char kImmediateNameID = '!';
-
-static const char kSomeCludePostStringMinSize = 2; // at least <@|!><N>ame must be
-static const char kSomeCludeAfterRecursedPostStringMinSize = 2; // at least <@|!><N>ame must be
-*/
-static const CSwitchForm kSwitchForms[kNumSwitches] =
-{
- { "?", NSwitchType::kSimple },
- { "H", NSwitchType::kSimple },
- { "BD", NSwitchType::kSimple },
- { "Y", NSwitchType::kSimple },
- { "P", NSwitchType::kString, false, 1 },
- { "O", NSwitchType::kString, false, 1 },
-};
-
-static const int kNumCommandForms = 3;
-
-static const NRecursedType::EEnum kCommandRecursedDefault[kNumCommandForms] =
-{
- NRecursedType::kRecursed
-};
-
-// static const bool kTestExtractRecursedDefault = true;
-// static const bool kAddRecursedDefault = false;
-
-static const char * const kUniversalWildcard = "*";
-static const int kCommandIndex = 0;
-
-static const char * const kHelpString =
- "\nUsage: 7zSFX [<command>] [<switches>...] [<file_name>...]\n"
- "\n"
- "<Commands>\n"
- // " l: List contents of archive\n"
- " t: Test integrity of archive\n"
- " x: eXtract files with full pathname (default)\n"
- "<Switches>\n"
- // " -bd Disable percentage indicator\n"
- " -o{Directory}: set Output directory\n"
- " -p{Password}: set Password\n"
- " -y: assume Yes on all queries\n";
-
-
-// ---------------------------
-// exception messages
-
-static const char * const kUserErrorMessage = "Incorrect command line"; // NExitCode::kUserError
-// static const char * const kIncorrectListFile = "Incorrect wildcard in listfile";
-static const char * const kIncorrectWildcardInCommandLine = "Incorrect wildcard in command line";
-
-// static const CSysString kFileIsNotArchiveMessageBefore = "File \"";
-// static const CSysString kFileIsNotArchiveMessageAfter = "\" is not archive";
-
-// static const char * const kProcessArchiveMessage = " archive: ";
-
-static const char * const kCantFindSFX = " cannot find sfx";
-
-namespace NCommandType
-{
- enum EEnum
- {
- kTest = 0,
- kFullExtract,
- kList
- };
-}
-
-static const char *g_Commands = "txl";
-
-struct CArchiveCommand
-{
- NCommandType::EEnum CommandType;
-
- NRecursedType::EEnum DefaultRecursedType() const;
-};
-
-bool ParseArchiveCommand(const UString &commandString, CArchiveCommand &command)
-{
- UString s = commandString;
- s.MakeLower_Ascii();
- if (s.Len() != 1)
- return false;
- if (s[0] >= 0x80)
- return false;
- int index = FindCharPosInString(g_Commands, (char)s[0]);
- if (index < 0)
- return false;
- command.CommandType = (NCommandType::EEnum)index;
- return true;
-}
-
-NRecursedType::EEnum CArchiveCommand::DefaultRecursedType() const
-{
- return kCommandRecursedDefault[CommandType];
-}
-
-void PrintHelp(void)
-{
- g_StdOut << kHelpString;
-}
-
-static void ShowMessageAndThrowException(const char *message, NExitCode::EEnum code)
-{
- g_StdOut << message << endl;
- throw code;
-}
-
-static void PrintHelpAndExit() // yyy
-{
- PrintHelp();
- ShowMessageAndThrowException(kUserErrorMessage, NExitCode::kUserError);
-}
-
-// ------------------------------------------------------------------
-// filenames functions
-
-static bool AddNameToCensor(NWildcard::CCensor &wildcardCensor,
- const UString &name, bool include, NRecursedType::EEnum type)
-{
- /*
- if (!IsWildcardFilePathLegal(name))
- return false;
- */
- bool isWildcard = DoesNameContainWildcard(name);
- bool recursed = false;
-
- switch (type)
- {
- case NRecursedType::kWildcardOnlyRecursed:
- recursed = isWildcard;
- break;
- case NRecursedType::kRecursed:
- recursed = true;
- break;
- case NRecursedType::kNonRecursed:
- recursed = false;
- break;
- }
- wildcardCensor.AddPreItem(include, name, recursed, true);
- return true;
-}
-
-void AddCommandLineWildcardToCensor(NWildcard::CCensor &wildcardCensor,
- const UString &name, bool include, NRecursedType::EEnum type)
-{
- if (!AddNameToCensor(wildcardCensor, name, include, type))
- ShowMessageAndThrowException(kIncorrectWildcardInCommandLine, NExitCode::kUserError);
-}
-
-
-#ifndef _WIN32
-static void GetArguments(int numArgs, const char *args[], UStringVector &parts)
-{
- parts.Clear();
- for (int i = 0; i < numArgs; i++)
- {
- UString s = MultiByteToUnicodeString(args[i]);
- parts.Add(s);
- }
-}
-#endif
-
-int Main2(
- #ifndef _WIN32
- int numArgs, const char *args[]
- #endif
-)
-{
- #ifdef _WIN32
- // do we need load Security DLLs for console program?
- LoadSecurityDlls();
- #endif
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- SetFileApisToOEM();
- #endif
-
- g_StdOut << kCopyrightString;
-
- UStringVector commandStrings;
- #ifdef _WIN32
- NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
- #else
- GetArguments(numArgs, args, commandStrings);
- #endif
-
- #ifdef _WIN32
-
- FString arcPath;
- {
- FString path;
- NDLL::MyGetModuleFileName(path);
- if (!MyGetFullPathName(path, arcPath))
- {
- g_StdOut << "GetFullPathName Error";
- return NExitCode::kFatalError;
- }
- }
-
- #else
-
- UString arcPath = commandStrings.Front();
-
- #endif
-
- #ifndef UNDER_CE
- if (commandStrings.Size() > 0)
- commandStrings.Delete(0);
- #endif
-
- NCommandLineParser::CParser parser;
-
- try
- {
- if (!parser.ParseStrings(kSwitchForms, kNumSwitches, commandStrings))
- {
- g_StdOut << "Command line error:" << endl
- << parser.ErrorMessage << endl
- << parser.ErrorLine << endl;
- return NExitCode::kUserError;
- }
- }
- catch(...)
- {
- PrintHelpAndExit();
- }
-
- if (parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs)
- {
- PrintHelp();
- return 0;
- }
-
- const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
-
- unsigned curCommandIndex = 0;
-
- CArchiveCommand command;
- if (nonSwitchStrings.IsEmpty())
- command.CommandType = NCommandType::kFullExtract;
- else
- {
- const UString &cmd = nonSwitchStrings[curCommandIndex];
- if (!ParseArchiveCommand(cmd, command))
- {
- g_StdOut << "ERROR: Unknown command:" << endl << cmd << endl;
- return NExitCode::kUserError;
- }
- curCommandIndex = 1;
- }
-
-
- NRecursedType::EEnum recursedType;
- recursedType = command.DefaultRecursedType();
-
- NWildcard::CCensor wildcardCensor;
-
- {
- if (nonSwitchStrings.Size() == curCommandIndex)
- AddCommandLineWildcardToCensor(wildcardCensor, (UString)kUniversalWildcard, true, recursedType);
- for (; curCommandIndex < nonSwitchStrings.Size(); curCommandIndex++)
- {
- const UString &s = nonSwitchStrings[curCommandIndex];
- if (s.IsEmpty())
- throw "Empty file path";
- AddCommandLineWildcardToCensor(wildcardCensor, s, true, recursedType);
- }
- }
-
- bool yesToAll = parser[NKey::kYes].ThereIs;
-
- // NExtractMode::EEnum extractMode;
- // bool isExtractGroupCommand = command.IsFromExtractGroup(extractMode);
-
- bool passwordEnabled = parser[NKey::kPassword].ThereIs;
-
- UString password;
- if (passwordEnabled)
- password = parser[NKey::kPassword].PostStrings[0];
-
- if (!NFind::DoesFileExist(arcPath))
- throw kCantFindSFX;
-
- FString outputDir;
- if (parser[NKey::kOutputDir].ThereIs)
- {
- outputDir = us2fs(parser[NKey::kOutputDir].PostStrings[0]);
- NName::NormalizeDirPathPrefix(outputDir);
- }
-
-
- wildcardCensor.AddPathsToCensor(NWildcard::k_RelatPath);
-
- {
- UStringVector v1, v2;
- v1.Add(fs2us(arcPath));
- v2.Add(fs2us(arcPath));
- const NWildcard::CCensorNode &wildcardCensorHead =
- wildcardCensor.Pairs.Front().Head;
-
- CCodecs *codecs = new CCodecs;
- CMyComPtr<
- #ifdef EXTERNAL_CODECS
- ICompressCodecsInfo
- #else
- IUnknown
- #endif
- > compressCodecsInfo = codecs;
- {
- HRESULT result = codecs->Load();
- if (result != S_OK)
- throw CSystemException(result);
- }
-
- if (command.CommandType != NCommandType::kList)
- {
- CExtractCallbackConsole *ecs = new CExtractCallbackConsole;
- CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
- ecs->Init(g_StdStream, &g_StdErr, g_StdStream);
-
- #ifndef _NO_CRYPTO
- ecs->PasswordIsDefined = passwordEnabled;
- ecs->Password = password;
- #endif
-
- /*
- COpenCallbackConsole openCallback;
- openCallback.Init(g_StdStream, g_StdStream);
-
- #ifndef _NO_CRYPTO
- openCallback.PasswordIsDefined = passwordEnabled;
- openCallback.Password = password;
- #endif
- */
-
- CExtractOptions eo;
- eo.StdOutMode = false;
- eo.YesToAll = yesToAll;
- eo.TestMode = command.CommandType == NCommandType::kTest;
- eo.PathMode = NExtract::NPathMode::kFullPaths;
- eo.OverwriteMode = yesToAll ?
- NExtract::NOverwriteMode::kOverwrite :
- NExtract::NOverwriteMode::kAsk;
- eo.OutputDir = outputDir;
-
- UString errorMessage;
- CDecompressStat stat;
- HRESULT result = Extract(
- codecs, CObjectVector<COpenType>(), CIntVector(),
- v1, v2,
- wildcardCensorHead,
- eo, ecs, ecs,
- // NULL, // hash
- errorMessage, stat);
- if (!errorMessage.IsEmpty())
- {
- (*g_StdStream) << endl << "Error: " << errorMessage;;
- if (result == S_OK)
- result = E_FAIL;
- }
-
- if (ecs->NumArcsWithError != 0 || ecs->NumFileErrors != 0)
- {
- if (ecs->NumArcsWithError != 0)
- (*g_StdStream) << endl << "Archive Errors" << endl;
- if (ecs->NumFileErrors != 0)
- (*g_StdStream) << endl << "Sub items Errors: " << ecs->NumFileErrors << endl;
- return NExitCode::kFatalError;
- }
- if (result != S_OK)
- throw CSystemException(result);
- }
- else
- {
- throw CSystemException(E_NOTIMPL);
-
- /*
- UInt64 numErrors = 0;
- UInt64 numWarnings = 0;
- HRESULT result = ListArchives(
- codecs, CObjectVector<COpenType>(), CIntVector(),
- false, // stdInMode
- v1, v2,
- true, // processAltStreams
- false, // showAltStreams
- wildcardCensorHead,
- true, // enableHeaders
- false, // techMode
- #ifndef _NO_CRYPTO
- passwordEnabled, password,
- #endif
- numErrors, numWarnings);
- if (numErrors > 0)
- {
- g_StdOut << endl << "Errors: " << numErrors;
- return NExitCode::kFatalError;
- }
- if (result != S_OK)
- throw CSystemException(result);
- */
- }
- }
- return 0;
-}
+// Main.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+#include "../../../../C/DllSecur.h"
+
+#include "../../../Common/MyWindows.h"
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/MyException.h"
+
+#ifdef _WIN32
+#include "../../../Windows/DLL.h"
+#else
+#include "../../../Common/StringConvert.h"
+#endif
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+
+#include "../../UI/Common/ExitCode.h"
+#include "../../UI/Common/Extract.h"
+
+#include "../../UI/Console/ExtractCallbackConsole.h"
+#include "../../UI/Console/List.h"
+#include "../../UI/Console/OpenCallbackConsole.h"
+
+#include "../../MyVersion.h"
+
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NCommandLineParser;
+
+#ifdef _WIN32
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance = NULL;
+#endif
+extern
+int g_CodePage;
+int g_CodePage = -1;
+extern CStdOutStream *g_StdStream;
+
+static const char * const kCopyrightString =
+"\n7-Zip SFX " MY_VERSION_CPU " : " MY_COPYRIGHT_DATE "\n";
+
+static const int kNumSwitches = 6;
+
+namespace NKey {
+enum Enum
+{
+ kHelp1 = 0,
+ kHelp2,
+ kDisablePercents,
+ kYes,
+ kPassword,
+ kOutputDir
+};
+
+}
+
+namespace NRecursedType {
+enum EEnum
+{
+ kRecursed,
+ kWildcardOnlyRecursed,
+ kNonRecursed
+};
+}
+/*
+static const char kRecursedIDChar = 'R';
+
+namespace NRecursedPostCharIndex {
+ enum EEnum
+ {
+ kWildcardRecursionOnly = 0,
+ kNoRecursion = 1
+ };
+}
+
+static const char kFileListID = '@';
+static const char kImmediateNameID = '!';
+
+static const char kSomeCludePostStringMinSize = 2; // at least <@|!><N>ame must be
+static const char kSomeCludeAfterRecursedPostStringMinSize = 2; // at least <@|!><N>ame must be
+*/
+
+#define SWFRM_3(t, mu, mi) t, mu, mi, NULL
+#define SWFRM_1(t) SWFRM_3(t, false, 0)
+#define SWFRM_SIMPLE SWFRM_1(NSwitchType::kSimple)
+#define SWFRM_STRING_SINGL(mi) SWFRM_3(NSwitchType::kString, false, mi)
+
+static const CSwitchForm kSwitchForms[kNumSwitches] =
+{
+ { "?", SWFRM_SIMPLE },
+ { "H", SWFRM_SIMPLE },
+ { "BD", SWFRM_SIMPLE },
+ { "Y", SWFRM_SIMPLE },
+ { "P", SWFRM_STRING_SINGL(1) },
+ { "O", SWFRM_STRING_SINGL(1) },
+};
+
+static const int kNumCommandForms = 3;
+
+static const NRecursedType::EEnum kCommandRecursedDefault[kNumCommandForms] =
+{
+ NRecursedType::kRecursed
+};
+
+// static const bool kTestExtractRecursedDefault = true;
+// static const bool kAddRecursedDefault = false;
+
+static const char * const kUniversalWildcard = "*";
+
+static const char * const kHelpString =
+ "\nUsage: 7zSFX [<command>] [<switches>...] [<file_name>...]\n"
+ "\n"
+ "<Commands>\n"
+ // " l: List contents of archive\n"
+ " t: Test integrity of archive\n"
+ " x: eXtract files with full pathname (default)\n"
+ "<Switches>\n"
+ // " -bd Disable percentage indicator\n"
+ " -o{Directory}: set Output directory\n"
+ " -p{Password}: set Password\n"
+ " -y: assume Yes on all queries\n";
+
+
+// ---------------------------
+// exception messages
+
+static const char * const kUserErrorMessage = "Incorrect command line"; // NExitCode::kUserError
+// static const char * const kIncorrectListFile = "Incorrect wildcard in listfile";
+static const char * const kIncorrectWildcardInCommandLine = "Incorrect wildcard in command line";
+
+// static const CSysString kFileIsNotArchiveMessageBefore = "File \"";
+// static const CSysString kFileIsNotArchiveMessageAfter = "\" is not archive";
+
+// static const char * const kProcessArchiveMessage = " archive: ";
+
+static const char * const kCantFindSFX = " cannot find sfx";
+
+namespace NCommandType
+{
+ enum EEnum
+ {
+ kTest = 0,
+ kFullExtract,
+ kList
+ };
+}
+
+static const char *g_Commands = "txl";
+
+struct CArchiveCommand
+{
+ NCommandType::EEnum CommandType;
+
+ NRecursedType::EEnum DefaultRecursedType() const;
+};
+
+static bool ParseArchiveCommand(const UString &commandString, CArchiveCommand &command)
+{
+ UString s = commandString;
+ s.MakeLower_Ascii();
+ if (s.Len() != 1)
+ return false;
+ if (s[0] >= 0x80)
+ return false;
+ int index = FindCharPosInString(g_Commands, (char)s[0]);
+ if (index < 0)
+ return false;
+ command.CommandType = (NCommandType::EEnum)index;
+ return true;
+}
+
+NRecursedType::EEnum CArchiveCommand::DefaultRecursedType() const
+{
+ return kCommandRecursedDefault[CommandType];
+}
+
+static void PrintHelp(void)
+{
+ g_StdOut << kHelpString;
+}
+
+Z7_ATTR_NORETURN
+static void ShowMessageAndThrowException(const char *message, NExitCode::EEnum code)
+{
+ g_StdOut << message << endl;
+ throw code;
+}
+
+Z7_ATTR_NORETURN
+static void PrintHelpAndExit() // yyy
+{
+ PrintHelp();
+ ShowMessageAndThrowException(kUserErrorMessage, NExitCode::kUserError);
+}
+
+// ------------------------------------------------------------------
+// filenames functions
+
+static bool AddNameToCensor(NWildcard::CCensor &wildcardCensor,
+ const UString &name, bool include, NRecursedType::EEnum type)
+{
+ /*
+ if (!IsWildcardFilePathLegal(name))
+ return false;
+ */
+ const bool isWildcard = DoesNameContainWildcard(name);
+ bool recursed = false;
+
+ switch (type)
+ {
+ case NRecursedType::kWildcardOnlyRecursed:
+ recursed = isWildcard;
+ break;
+ case NRecursedType::kRecursed:
+ recursed = true;
+ break;
+ case NRecursedType::kNonRecursed:
+ recursed = false;
+ break;
+ }
+
+ NWildcard::CCensorPathProps props;
+ props.Recursive = recursed;
+ wildcardCensor.AddPreItem(include, name, props);
+ return true;
+}
+
+static void AddCommandLineWildcardToCensor(NWildcard::CCensor &wildcardCensor,
+ const UString &name, bool include, NRecursedType::EEnum type)
+{
+ if (!AddNameToCensor(wildcardCensor, name, include, type))
+ ShowMessageAndThrowException(kIncorrectWildcardInCommandLine, NExitCode::kUserError);
+}
+
+
+#ifndef _WIN32
+static void GetArguments(int numArgs, char *args[], UStringVector &parts)
+{
+ parts.Clear();
+ for (int i = 0; i < numArgs; i++)
+ {
+ UString s = MultiByteToUnicodeString(args[i]);
+ parts.Add(s);
+ }
+}
+#endif
+
+
+int Main2(
+ #ifndef _WIN32
+ int numArgs, char *args[]
+ #endif
+);
+int Main2(
+ #ifndef _WIN32
+ int numArgs, char *args[]
+ #endif
+)
+{
+ #ifdef _WIN32
+ // do we need load Security DLLs for console program?
+ LoadSecurityDlls();
+ #endif
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ SetFileApisToOEM();
+ #endif
+
+ #ifdef ENV_HAVE_LOCALE
+ MY_SetLocale();
+ #endif
+
+ g_StdOut << kCopyrightString;
+
+ UStringVector commandStrings;
+ #ifdef _WIN32
+ NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
+ #else
+ GetArguments(numArgs, args, commandStrings);
+ #endif
+
+ #ifdef _WIN32
+
+ FString arcPath;
+ {
+ FString path;
+ NDLL::MyGetModuleFileName(path);
+ if (!MyGetFullPathName(path, arcPath))
+ {
+ g_StdOut << "GetFullPathName Error";
+ return NExitCode::kFatalError;
+ }
+ }
+
+ #else
+
+ if (commandStrings.IsEmpty())
+ return NExitCode::kFatalError;
+
+ const FString arcPath = us2fs(commandStrings.Front());
+
+ #endif
+
+ #ifndef UNDER_CE
+ if (commandStrings.Size() > 0)
+ commandStrings.Delete(0);
+ #endif
+
+ NCommandLineParser::CParser parser;
+
+ try
+ {
+ if (!parser.ParseStrings(kSwitchForms, kNumSwitches, commandStrings))
+ {
+ g_StdOut << "Command line error:" << endl
+ << parser.ErrorMessage << endl
+ << parser.ErrorLine << endl;
+ return NExitCode::kUserError;
+ }
+ }
+ catch(...)
+ {
+ PrintHelpAndExit();
+ }
+
+ if (parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs)
+ {
+ PrintHelp();
+ return 0;
+ }
+
+ const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
+
+ unsigned curCommandIndex = 0;
+
+ CArchiveCommand command;
+ if (nonSwitchStrings.IsEmpty())
+ command.CommandType = NCommandType::kFullExtract;
+ else
+ {
+ const UString &cmd = nonSwitchStrings[curCommandIndex];
+ if (!ParseArchiveCommand(cmd, command))
+ {
+ g_StdOut << "ERROR: Unknown command:" << endl << cmd << endl;
+ return NExitCode::kUserError;
+ }
+ curCommandIndex = 1;
+ }
+
+
+ NRecursedType::EEnum recursedType;
+ recursedType = command.DefaultRecursedType();
+
+ NWildcard::CCensor wildcardCensor;
+
+ {
+ if (nonSwitchStrings.Size() == curCommandIndex)
+ AddCommandLineWildcardToCensor(wildcardCensor, (UString)kUniversalWildcard, true, recursedType);
+ for (; curCommandIndex < nonSwitchStrings.Size(); curCommandIndex++)
+ {
+ const UString &s = nonSwitchStrings[curCommandIndex];
+ if (s.IsEmpty())
+ throw "Empty file path";
+ AddCommandLineWildcardToCensor(wildcardCensor, s, true, recursedType);
+ }
+ }
+
+ const bool yesToAll = parser[NKey::kYes].ThereIs;
+
+ // NExtractMode::EEnum extractMode;
+ // bool isExtractGroupCommand = command.IsFromExtractGroup(extractMode);
+
+ const bool passwordEnabled = parser[NKey::kPassword].ThereIs;
+
+ UString password;
+ if (passwordEnabled)
+ password = parser[NKey::kPassword].PostStrings[0];
+
+ if (!NFind::DoesFileExist_FollowLink(arcPath))
+ throw kCantFindSFX;
+
+ FString outputDir;
+ if (parser[NKey::kOutputDir].ThereIs)
+ {
+ outputDir = us2fs(parser[NKey::kOutputDir].PostStrings[0]);
+ NName::NormalizeDirPathPrefix(outputDir);
+ }
+
+
+ wildcardCensor.AddPathsToCensor(NWildcard::k_RelatPath);
+
+ {
+ UStringVector v1, v2;
+ v1.Add(fs2us(arcPath));
+ v2.Add(fs2us(arcPath));
+ const NWildcard::CCensorNode &wildcardCensorHead =
+ wildcardCensor.Pairs.Front().Head;
+
+ CCodecs *codecs = new CCodecs;
+ CMyComPtr<
+ #ifdef Z7_EXTERNAL_CODECS
+ ICompressCodecsInfo
+ #else
+ IUnknown
+ #endif
+ > compressCodecsInfo = codecs;
+ {
+ HRESULT result = codecs->Load();
+ if (result != S_OK)
+ throw CSystemException(result);
+ }
+
+ if (command.CommandType != NCommandType::kList)
+ {
+ CExtractCallbackConsole *ecs = new CExtractCallbackConsole;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
+ ecs->Init(g_StdStream, &g_StdErr, g_StdStream);
+
+ #ifndef Z7_NO_CRYPTO
+ ecs->PasswordIsDefined = passwordEnabled;
+ ecs->Password = password;
+ #endif
+
+ /*
+ COpenCallbackConsole openCallback;
+ openCallback.Init(g_StdStream, g_StdStream);
+
+ #ifndef Z7_NO_CRYPTO
+ openCallback.PasswordIsDefined = passwordEnabled;
+ openCallback.Password = password;
+ #endif
+ */
+
+ CExtractOptions eo;
+ eo.StdOutMode = false;
+ eo.YesToAll = yesToAll;
+ eo.TestMode = command.CommandType == NCommandType::kTest;
+ eo.PathMode = NExtract::NPathMode::kFullPaths;
+ eo.OverwriteMode = yesToAll ?
+ NExtract::NOverwriteMode::kOverwrite :
+ NExtract::NOverwriteMode::kAsk;
+ eo.OutputDir = outputDir;
+
+ UString errorMessage;
+ CDecompressStat stat;
+ HRESULT result = Extract(
+ codecs, CObjectVector<COpenType>(), CIntVector(),
+ v1, v2,
+ wildcardCensorHead,
+ eo,
+ ecs, ecs, ecs,
+ // NULL, // hash
+ errorMessage, stat);
+
+ ecs->ClosePercents();
+
+ if (!errorMessage.IsEmpty())
+ {
+ (*g_StdStream) << endl << "Error: " << errorMessage;
+ if (result == S_OK)
+ result = E_FAIL;
+ }
+
+ if ( 0 != ecs->NumCantOpenArcs
+ || 0 != ecs->NumArcsWithError
+ || 0 != ecs->NumFileErrors
+ || 0 != ecs->NumOpenArcErrors)
+ {
+ if (ecs->NumCantOpenArcs != 0)
+ (*g_StdStream) << endl << "Can't open as archive" << endl;
+ if (ecs->NumArcsWithError != 0)
+ (*g_StdStream) << endl << "Archive Errors" << endl;
+ if (ecs->NumFileErrors != 0)
+ (*g_StdStream) << endl << "Sub items Errors: " << ecs->NumFileErrors << endl;
+ if (ecs->NumOpenArcErrors != 0)
+ (*g_StdStream) << endl << "Open Errors: " << ecs->NumOpenArcErrors << endl;
+ return NExitCode::kFatalError;
+ }
+ if (result != S_OK)
+ throw CSystemException(result);
+ }
+ else
+ {
+ throw CSystemException(E_NOTIMPL);
+
+ /*
+ UInt64 numErrors = 0;
+ UInt64 numWarnings = 0;
+ HRESULT result = ListArchives(
+ codecs, CObjectVector<COpenType>(), CIntVector(),
+ false, // stdInMode
+ v1, v2,
+ true, // processAltStreams
+ false, // showAltStreams
+ wildcardCensorHead,
+ true, // enableHeaders
+ false, // techMode
+ #ifndef Z7_NO_CRYPTO
+ passwordEnabled, password,
+ #endif
+ numErrors, numWarnings);
+ if (numErrors > 0)
+ {
+ g_StdOut << endl << "Errors: " << numErrors;
+ return NExitCode::kFatalError;
+ }
+ if (result != S_OK)
+ throw CSystemException(result);
+ */
+ }
+ }
+ return 0;
+}
diff --git a/CPP/7zip/Bundles/SFXCon/StdAfx.cpp b/CPP/7zip/Bundles/SFXCon/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/SFXCon/StdAfx.cpp
+++ b/CPP/7zip/Bundles/SFXCon/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/SFXCon/StdAfx.h b/CPP/7zip/Bundles/SFXCon/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/Bundles/SFXCon/StdAfx.h
+++ b/CPP/7zip/Bundles/SFXCon/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Bundles/SFXCon/makefile b/CPP/7zip/Bundles/SFXCon/makefile
index 811975c..51aaf51 100644
--- a/CPP/7zip/Bundles/SFXCon/makefile
+++ b/CPP/7zip/Bundles/SFXCon/makefile
@@ -1,134 +1,134 @@
-PROG = 7zCon.sfx
-MY_CONSOLE = 1
-MY_FIXED = 1
-
-CFLAGS = $(CFLAGS) \
- -DEXTRACT_ONLY \
- -DNO_READ_FROM_CODER \
- -D_SFX \
-
-CURRENT_OBJS = \
- $O\SfxCon.obj \
-
-CONSOLE_OBJS = \
- $O\ConsoleClose.obj \
- $O\ExtractCallbackConsole.obj \
- $O\List.obj \
- $O\MainAr.obj \
- $O\OpenCallbackConsole.obj \
- $O\PercentPrinter.obj \
- $O\UserInputUtils.obj \
-
-COMMON_OBJS = \
- $O\CommandLineParser.obj \
- $O\CRC.obj \
- $O\IntToString.obj \
- $O\MyString.obj \
- $O\MyVector.obj \
- $O\NewHandler.obj \
- $O\StdInStream.obj \
- $O\StdOutStream.obj \
- $O\StringConvert.obj \
- $O\Wildcard.obj \
- $O\UTFConvert.obj \
-
-WIN_OBJS = \
- $O\DLL.obj \
- $O\ErrorMsg.obj \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileName.obj \
- $O\PropVariant.obj \
- $O\PropVariantConv.obj \
- $O\Synchronization.obj \
- $O\System.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\CWrappers.obj \
- $O\FilePathAutoRename.obj \
- $O\FileStreams.obj \
- $O\InBuffer.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\OutBuffer.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamBinder.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\VirtThread.obj \
-
-UI_COMMON_OBJS = \
- $O\ArchiveExtractCallback.obj \
- $O\ArchiveOpenCallback.obj \
- $O\DefaultName.obj \
- $O\LoadCodecs.obj \
- $O\Extract.obj \
- $O\ExtractingFilePath.obj \
- $O\OpenArchive.obj \
- $O\PropIDUtils.obj \
-
-AR_OBJS = \
- $O\SplitHandler.obj \
-
-AR_COMMON_OBJS = \
- $O\CoderMixer2.obj \
- $O\ItemNameUtils.obj \
- $O\MultiStream.obj \
- $O\OutStreamWithCRC.obj \
-
-
-7Z_OBJS = \
- $O\7zDecode.obj \
- $O\7zExtract.obj \
- $O\7zHandler.obj \
- $O\7zIn.obj \
- $O\7zRegister.obj \
-
-COMPRESS_OBJS = \
- $O\Bcj2Coder.obj \
- $O\Bcj2Register.obj \
- $O\BcjCoder.obj \
- $O\BcjRegister.obj \
- $O\BranchMisc.obj \
- $O\BranchRegister.obj \
- $O\CopyCoder.obj \
- $O\CopyRegister.obj \
- $O\DeltaFilter.obj \
- $O\Lzma2Decoder.obj \
- $O\Lzma2Register.obj \
- $O\LzmaDecoder.obj \
- $O\LzmaRegister.obj \
- $O\PpmdDecoder.obj \
- $O\PpmdRegister.obj \
-
-CRYPTO_OBJS = \
- $O\7zAes.obj \
- $O\7zAesRegister.obj \
- $O\MyAes.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\DllSecur.obj \
- $O\Lzma2Dec.obj \
- $O\Lzma2DecMt.obj \
- $O\LzmaDec.obj \
- $O\MtDec.obj \
- $O\Ppmd7.obj \
- $O\Ppmd7Dec.obj \
- $O\Sha256.obj \
- $O\Threads.obj \
-
-!include "../../Aes.mak"
-!include "../../Crc.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = 7zCon.sfx
+MY_CONSOLE = 1
+MY_FIXED = 1
+
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTRACT_ONLY \
+ -DZ7_NO_READ_FROM_CODER \
+ -DZ7_SFX \
+
+CURRENT_OBJS = \
+ $O\SfxCon.obj \
+
+CONSOLE_OBJS = \
+ $O\ConsoleClose.obj \
+ $O\ExtractCallbackConsole.obj \
+ $O\List.obj \
+ $O\MainAr.obj \
+ $O\OpenCallbackConsole.obj \
+ $O\PercentPrinter.obj \
+ $O\UserInputUtils.obj \
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\IntToString.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\NewHandler.obj \
+ $O\StdInStream.obj \
+ $O\StdOutStream.obj \
+ $O\StringConvert.obj \
+ $O\UTFConvert.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\InBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\VirtThread.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\DefaultName.obj \
+ $O\Extract.obj \
+ $O\ExtractingFilePath.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+ $O\PropIDUtils.obj \
+
+AR_OBJS = \
+ $O\SplitHandler.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\ItemNameUtils.obj \
+ $O\MultiStream.obj \
+ $O\OutStreamWithCRC.obj \
+
+7Z_OBJS = \
+ $O\7zDecode.obj \
+ $O\7zExtract.obj \
+ $O\7zHandler.obj \
+ $O\7zIn.obj \
+ $O\7zRegister.obj \
+
+COMPRESS_OBJS = \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaRegister.obj \
+ $O\PpmdDecoder.obj \
+ $O\PpmdRegister.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\MyAes.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\DllSecur.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\LzmaDec.obj \
+ $O\MtDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+ $O\Threads.obj \
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha256.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/SFXCon/makefile.gcc b/CPP/7zip/Bundles/SFXCon/makefile.gcc
new file mode 100644
index 0000000..9278502
--- /dev/null
+++ b/CPP/7zip/Bundles/SFXCon/makefile.gcc
@@ -0,0 +1,213 @@
+PROG = 7zCon
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+include ../../LzmaDec_gcc.mak
+
+
+LOCAL_FLAGS_ST =
+MT_OBJS =
+
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef ST_MODE
+
+LOCAL_FLAGS_ST = -DZ7_ST
+
+ifdef IS_MINGW
+MT_OBJS = \
+ $O/Threads.o \
+
+endif
+
+else
+
+MT_OBJS = \
+ $O/StreamBinder.o \
+ $O/Synchronization.o \
+ $O/VirtThread.o \
+ $O/Threads.o \
+
+endif
+
+
+
+LOCAL_FLAGS_SYS =
+
+ifdef IS_MINGW
+
+LOCAL_FLAGS_SYS = \
+
+SYS_OBJS = \
+ $O/DLL.o \
+ $O/DllSecur.o \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+
+endif
+
+LOCAL_FLAGS = \
+ $(LOCAL_FLAGS_ST) \
+ $(LOCAL_FLAGS_SYS) \
+ -DZ7_EXTRACT_ONLY \
+ -DZ7_NO_READ_FROM_CODER \
+ -DZ7_SFX \
+
+
+CURRENT_OBJS = \
+ $O/SfxCon.o \
+
+CONSOLE_OBJS = \
+ $O/ConsoleClose.o \
+ $O/ExtractCallbackConsole.o \
+ $O/List.o \
+ $O/MainAr.o \
+ $O/OpenCallbackConsole.o \
+ $O/PercentPrinter.o \
+ $O/UserInputUtils.o \
+
+COMMON_OBJS = \
+ $O/CommandLineParser.o \
+ $O/CRC.o \
+ $O/IntToString.o \
+ $O/MyString.o \
+ $O/MyVector.o \
+ $O/NewHandler.o \
+ $O/Sha256Prepare.o \
+ $O/StdInStream.o \
+ $O/StdOutStream.o \
+ $O/StringConvert.o \
+ $O/UTFConvert.o \
+ $O/Wildcard.o \
+
+WIN_OBJS = \
+ \
+ $O/ErrorMsg.o \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileIO.o \
+ $O/FileName.o \
+ $O/PropVariant.o \
+ $O/PropVariantConv.o \
+ \
+ $O/System.o \
+ $O/TimeUtils.o \
+
+7ZIP_COMMON_OBJS = \
+ $O/CreateCoder.o \
+ $O/CWrappers.o \
+ $O/FilePathAutoRename.o \
+ $O/FileStreams.o \
+ $O/InBuffer.o \
+ $O/FilterCoder.o \
+ $O/LimitedStreams.o \
+ $O/OutBuffer.o \
+ $O/ProgressUtils.o \
+ $O/PropId.o \
+ \
+ $O/StreamObjects.o \
+ $O/StreamUtils.o \
+ \
+
+UI_COMMON_OBJS = \
+ $O/ArchiveExtractCallback.o \
+ $O/ArchiveOpenCallback.o \
+ $O/DefaultName.o \
+ $O/Extract.o \
+ $O/ExtractingFilePath.o \
+ $O/LoadCodecs.o \
+ $O/OpenArchive.o \
+ $O/PropIDUtils.o \
+
+AR_OBJS = \
+ $O/SplitHandler.o \
+
+AR_COMMON_OBJS = \
+ $O/CoderMixer2.o \
+ $O/ItemNameUtils.o \
+ $O/MultiStream.o \
+ $O/OutStreamWithCRC.o \
+
+7Z_OBJS = \
+ $O/7zDecode.o \
+ $O/7zExtract.o \
+ $O/7zHandler.o \
+ $O/7zIn.o \
+ $O/7zRegister.o \
+
+COMPRESS_OBJS = \
+ $O/Bcj2Coder.o \
+ $O/Bcj2Register.o \
+ $O/BcjCoder.o \
+ $O/BcjRegister.o \
+ $O/BranchMisc.o \
+ $O/BranchRegister.o \
+ $O/CopyCoder.o \
+ $O/CopyRegister.o \
+ $O/DeltaFilter.o \
+ $O/Lzma2Decoder.o \
+ $O/Lzma2Register.o \
+ $O/LzmaDecoder.o \
+ $O/LzmaRegister.o \
+ $O/PpmdDecoder.o \
+ $O/PpmdRegister.o \
+
+CRYPTO_OBJS = \
+ $O/7zAes.o \
+ $O/7zAesRegister.o \
+ $O/MyAes.o \
+
+C_OBJS = \
+ $O/7zStream.o \
+ $O/Alloc.o \
+ $O/Bcj2.o \
+ $O/Bra.o \
+ $O/Bra86.o \
+ $O/BraIA64.o \
+ $O/CpuArch.o \
+ $O/Delta.o \
+ $O/Lzma2Dec.o \
+ $O/Lzma2DecMt.o \
+ $O/LzmaDec.o \
+ $O/MtDec.o \
+ $O/Ppmd7.o \
+ $O/Ppmd7Dec.o \
+ $O/Sha256.o \
+ $O/Sha256Opt.o \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+ $O/Aes.o \
+ $O/AesOpt.o \
+
+OBJS = \
+ $(LZMA_DEC_OPT_OBJS) \
+ $(C_OBJS) \
+ $(MT_OBJS) \
+ $(SYS_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(CRYPTO_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(AR_OBJS) \
+ $(AR_COMMON_OBJS) \
+ $(7Z_OBJS) \
+ $(UI_COMMON_OBJS) \
+ $(CONSOLE_OBJS) \
+ $(CURRENT_OBJS) \
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/Bundles/SFXCon/resource.rc b/CPP/7zip/Bundles/SFXCon/resource.rc
index 97882cd..6576212 100644
--- a/CPP/7zip/Bundles/SFXCon/resource.rc
+++ b/CPP/7zip/Bundles/SFXCon/resource.rc
@@ -1,5 +1,9 @@
-#include "../../MyVersionInfo.rc"
-
-MY_VERSION_INFO_APP("7z Console SFX", "7z.sfx")
-
-101 ICON "7z.ico"
\ No newline at end of file
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_APP("7z Console SFX", "7z.sfx")
+
+101 ICON "7z.ico"
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "../../UI/Console/Console.manifest"
+#endif
diff --git a/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.cpp b/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.cpp
index d35a24f..9d632ee 100644
--- a/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.cpp
+++ b/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.cpp
@@ -1,246 +1,246 @@
-// ExtractCallbackSfx.h
-
-#include "StdAfx.h"
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/PropVariant.h"
-
-#include "ExtractCallbackSfx.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static LPCSTR const kCantDeleteFile = "Can not delete output file";
-static LPCSTR const kCantOpenFile = "Can not open output file";
-static LPCSTR const kUnsupportedMethod = "Unsupported Method";
-
-void CExtractCallbackImp::Init(IInArchive *archiveHandler,
- const FString &directoryPath,
- const UString &itemDefaultName,
- const FILETIME &defaultMTime,
- UInt32 defaultAttributes)
-{
- _message.Empty();
- _isCorrupt = false;
- _itemDefaultName = itemDefaultName;
- _defaultMTime = defaultMTime;
- _defaultAttributes = defaultAttributes;
- _archiveHandler = archiveHandler;
- _directoryPath = directoryPath;
- NName::NormalizeDirPathPrefix(_directoryPath);
-}
-
-HRESULT CExtractCallbackImp::Open_CheckBreak()
-{
- #ifndef _NO_PROGRESS
- return ProgressDialog.Sync.ProcessStopAndPause();
- #else
- return S_OK;
- #endif
-}
-
-HRESULT CExtractCallbackImp::Open_SetTotal(const UInt64 * /* numFiles */, const UInt64 * /* numBytes */)
-{
- return S_OK;
-}
-
-HRESULT CExtractCallbackImp::Open_SetCompleted(const UInt64 * /* numFiles */, const UInt64 * /* numBytes */)
-{
- #ifndef _NO_PROGRESS
- return ProgressDialog.Sync.ProcessStopAndPause();
- #else
- return S_OK;
- #endif
-}
-
-HRESULT CExtractCallbackImp::Open_Finished()
-{
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::SetTotal(UInt64 size)
-{
- #ifndef _NO_PROGRESS
- ProgressDialog.Sync.SetProgress(size, 0);
- #endif
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::SetCompleted(const UInt64 *completeValue)
-{
- #ifndef _NO_PROGRESS
- RINOK(ProgressDialog.Sync.ProcessStopAndPause());
- if (completeValue != NULL)
- ProgressDialog.Sync.SetPos(*completeValue);
- #endif
- return S_OK;
-}
-
-void CExtractCallbackImp::CreateComplexDirectory(const UStringVector &dirPathParts)
-{
- FString fullPath = _directoryPath;
- FOR_VECTOR (i, dirPathParts)
- {
- fullPath += us2fs(dirPathParts[i]);
- CreateDir(fullPath);
- fullPath.Add_PathSepar();
- }
-}
-
-STDMETHODIMP CExtractCallbackImp::GetStream(UInt32 index,
- ISequentialOutStream **outStream, Int32 askExtractMode)
-{
- #ifndef _NO_PROGRESS
- if (ProgressDialog.Sync.GetStopped())
- return E_ABORT;
- #endif
- _outFileStream.Release();
-
- UString fullPath;
- {
- NCOM::CPropVariant prop;
- RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop));
- if (prop.vt == VT_EMPTY)
- fullPath = _itemDefaultName;
- else
- {
- if (prop.vt != VT_BSTR)
- return E_FAIL;
- fullPath.SetFromBstr(prop.bstrVal);
- }
- _filePath = fullPath;
- }
-
- if (askExtractMode == NArchive::NExtract::NAskMode::kExtract)
- {
- NCOM::CPropVariant prop;
- RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop));
- if (prop.vt == VT_EMPTY)
- _processedFileInfo.Attributes = _defaultAttributes;
- else
- {
- if (prop.vt != VT_UI4)
- return E_FAIL;
- _processedFileInfo.Attributes = prop.ulVal;
- }
-
- RINOK(_archiveHandler->GetProperty(index, kpidIsDir, &prop));
- _processedFileInfo.IsDir = VARIANT_BOOLToBool(prop.boolVal);
-
- bool isAnti = false;
- {
- NCOM::CPropVariant propTemp;
- RINOK(_archiveHandler->GetProperty(index, kpidIsAnti, &propTemp));
- if (propTemp.vt == VT_BOOL)
- isAnti = VARIANT_BOOLToBool(propTemp.boolVal);
- }
-
- RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop));
- switch (prop.vt)
- {
- case VT_EMPTY: _processedFileInfo.MTime = _defaultMTime; break;
- case VT_FILETIME: _processedFileInfo.MTime = prop.filetime; break;
- default: return E_FAIL;
- }
-
- UStringVector pathParts;
- SplitPathToParts(fullPath, pathParts);
- if (pathParts.IsEmpty())
- return E_FAIL;
-
- UString processedPath = fullPath;
-
- if (!_processedFileInfo.IsDir)
- pathParts.DeleteBack();
- if (!pathParts.IsEmpty())
- {
- if (!isAnti)
- CreateComplexDirectory(pathParts);
- }
-
- FString fullProcessedPath = _directoryPath + us2fs(processedPath);
-
- if (_processedFileInfo.IsDir)
- {
- _diskFilePath = fullProcessedPath;
-
- if (isAnti)
- RemoveDir(_diskFilePath);
- else
- SetDirTime(_diskFilePath, NULL, NULL, &_processedFileInfo.MTime);
- return S_OK;
- }
-
- NFind::CFileInfo fileInfo;
- if (fileInfo.Find(fullProcessedPath))
- {
- if (!DeleteFileAlways(fullProcessedPath))
- {
- _message = kCantDeleteFile;
- return E_FAIL;
- }
- }
-
- if (!isAnti)
- {
- _outFileStreamSpec = new COutFileStream;
- CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
- if (!_outFileStreamSpec->Create(fullProcessedPath, true))
- {
- _message = kCantOpenFile;
- return E_FAIL;
- }
- _outFileStream = outStreamLoc;
- *outStream = outStreamLoc.Detach();
- }
- _diskFilePath = fullProcessedPath;
- }
- else
- {
- *outStream = NULL;
- }
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::PrepareOperation(Int32 askExtractMode)
-{
- _extractMode = (askExtractMode == NArchive::NExtract::NAskMode::kExtract);
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::SetOperationResult(Int32 resultEOperationResult)
-{
- switch (resultEOperationResult)
- {
- case NArchive::NExtract::NOperationResult::kOK:
- break;
-
- default:
- {
- _outFileStream.Release();
- switch (resultEOperationResult)
- {
- case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
- _message = kUnsupportedMethod;
- break;
- default:
- _isCorrupt = true;
- }
- return E_FAIL;
- }
- }
- if (_outFileStream != NULL)
- {
- _outFileStreamSpec->SetMTime(&_processedFileInfo.MTime);
- RINOK(_outFileStreamSpec->Close());
- }
- _outFileStream.Release();
- if (_extractMode)
- SetFileAttrib(_diskFilePath, _processedFileInfo.Attributes);
- return S_OK;
-}
+// ExtractCallbackSfx.h
+
+#include "StdAfx.h"
+
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "ExtractCallbackSfx.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static LPCSTR const kCantDeleteFile = "Cannot delete output file";
+static LPCSTR const kCantOpenFile = "Cannot open output file";
+static LPCSTR const kUnsupportedMethod = "Unsupported Method";
+
+void CExtractCallbackImp::Init(IInArchive *archiveHandler,
+ const FString &directoryPath,
+ const UString &itemDefaultName,
+ const FILETIME &defaultMTime,
+ UInt32 defaultAttributes)
+{
+ _message.Empty();
+ _isCorrupt = false;
+ _itemDefaultName = itemDefaultName;
+ _defaultMTime = defaultMTime;
+ _defaultAttributes = defaultAttributes;
+ _archiveHandler = archiveHandler;
+ _directoryPath = directoryPath;
+ NName::NormalizeDirPathPrefix(_directoryPath);
+}
+
+HRESULT CExtractCallbackImp::Open_CheckBreak()
+{
+ #ifndef _NO_PROGRESS
+ return ProgressDialog.Sync.ProcessStopAndPause();
+ #else
+ return S_OK;
+ #endif
+}
+
+HRESULT CExtractCallbackImp::Open_SetTotal(const UInt64 * /* numFiles */, const UInt64 * /* numBytes */)
+{
+ return S_OK;
+}
+
+HRESULT CExtractCallbackImp::Open_SetCompleted(const UInt64 * /* numFiles */, const UInt64 * /* numBytes */)
+{
+ #ifndef _NO_PROGRESS
+ return ProgressDialog.Sync.ProcessStopAndPause();
+ #else
+ return S_OK;
+ #endif
+}
+
+HRESULT CExtractCallbackImp::Open_Finished()
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetTotal(UInt64 size))
+{
+ #ifndef _NO_PROGRESS
+ ProgressDialog.Sync.SetProgress(size, 0);
+ #endif
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetCompleted(const UInt64 *completeValue))
+{
+ #ifndef _NO_PROGRESS
+ RINOK(ProgressDialog.Sync.ProcessStopAndPause())
+ if (completeValue != NULL)
+ ProgressDialog.Sync.SetPos(*completeValue);
+ #endif
+ return S_OK;
+}
+
+void CExtractCallbackImp::CreateComplexDirectory(const UStringVector &dirPathParts)
+{
+ FString fullPath = _directoryPath;
+ FOR_VECTOR (i, dirPathParts)
+ {
+ fullPath += us2fs(dirPathParts[i]);
+ CreateDir(fullPath);
+ fullPath.Add_PathSepar();
+ }
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::GetStream(UInt32 index,
+ ISequentialOutStream **outStream, Int32 askExtractMode))
+{
+ #ifndef _NO_PROGRESS
+ if (ProgressDialog.Sync.GetStopped())
+ return E_ABORT;
+ #endif
+ _outFileStream.Release();
+
+ UString fullPath;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop))
+ if (prop.vt == VT_EMPTY)
+ fullPath = _itemDefaultName;
+ else
+ {
+ if (prop.vt != VT_BSTR)
+ return E_FAIL;
+ fullPath.SetFromBstr(prop.bstrVal);
+ }
+ _filePath = fullPath;
+ }
+
+ if (askExtractMode == NArchive::NExtract::NAskMode::kExtract)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ _processedFileInfo.Attributes = _defaultAttributes;
+ else
+ {
+ if (prop.vt != VT_UI4)
+ return E_FAIL;
+ _processedFileInfo.Attributes = prop.ulVal;
+ }
+
+ RINOK(_archiveHandler->GetProperty(index, kpidIsDir, &prop))
+ _processedFileInfo.IsDir = VARIANT_BOOLToBool(prop.boolVal);
+
+ bool isAnti = false;
+ {
+ NCOM::CPropVariant propTemp;
+ RINOK(_archiveHandler->GetProperty(index, kpidIsAnti, &propTemp))
+ if (propTemp.vt == VT_BOOL)
+ isAnti = VARIANT_BOOLToBool(propTemp.boolVal);
+ }
+
+ RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop))
+ switch (prop.vt)
+ {
+ case VT_EMPTY: _processedFileInfo.MTime = _defaultMTime; break;
+ case VT_FILETIME: _processedFileInfo.MTime = prop.filetime; break;
+ default: return E_FAIL;
+ }
+
+ UStringVector pathParts;
+ SplitPathToParts(fullPath, pathParts);
+ if (pathParts.IsEmpty())
+ return E_FAIL;
+
+ UString processedPath = fullPath;
+
+ if (!_processedFileInfo.IsDir)
+ pathParts.DeleteBack();
+ if (!pathParts.IsEmpty())
+ {
+ if (!isAnti)
+ CreateComplexDirectory(pathParts);
+ }
+
+ FString fullProcessedPath = _directoryPath + us2fs(processedPath);
+
+ if (_processedFileInfo.IsDir)
+ {
+ _diskFilePath = fullProcessedPath;
+
+ if (isAnti)
+ RemoveDir(_diskFilePath);
+ else
+ SetDirTime(_diskFilePath, NULL, NULL, &_processedFileInfo.MTime);
+ return S_OK;
+ }
+
+ NFind::CFileInfo fileInfo;
+ if (fileInfo.Find(fullProcessedPath))
+ {
+ if (!DeleteFileAlways(fullProcessedPath))
+ {
+ _message = kCantDeleteFile;
+ return E_FAIL;
+ }
+ }
+
+ if (!isAnti)
+ {
+ _outFileStreamSpec = new COutFileStream;
+ CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
+ if (!_outFileStreamSpec->Create(fullProcessedPath, true))
+ {
+ _message = kCantOpenFile;
+ return E_FAIL;
+ }
+ _outFileStream = outStreamLoc;
+ *outStream = outStreamLoc.Detach();
+ }
+ _diskFilePath = fullProcessedPath;
+ }
+ else
+ {
+ *outStream = NULL;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::PrepareOperation(Int32 askExtractMode))
+{
+ _extractMode = (askExtractMode == NArchive::NExtract::NAskMode::kExtract);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetOperationResult(Int32 resultEOperationResult))
+{
+ switch (resultEOperationResult)
+ {
+ case NArchive::NExtract::NOperationResult::kOK:
+ break;
+
+ default:
+ {
+ _outFileStream.Release();
+ switch (resultEOperationResult)
+ {
+ case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
+ _message = kUnsupportedMethod;
+ break;
+ default:
+ _isCorrupt = true;
+ }
+ return E_FAIL;
+ }
+ }
+ if (_outFileStream != NULL)
+ {
+ _outFileStreamSpec->SetMTime(&_processedFileInfo.MTime);
+ RINOK(_outFileStreamSpec->Close())
+ }
+ _outFileStream.Release();
+ if (_extractMode)
+ SetFileAttrib(_diskFilePath, _processedFileInfo.Attributes);
+ return S_OK;
+}
diff --git a/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.h b/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.h
index b7f04e0..b9377ae 100644
--- a/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.h
+++ b/CPP/7zip/Bundles/SFXSetup/ExtractCallbackSfx.h
@@ -1,86 +1,83 @@
-// ExtractCallbackSfx.h
-
-#ifndef __EXTRACT_CALLBACK_SFX_H
-#define __EXTRACT_CALLBACK_SFX_H
-
-#include "resource.h"
-
-#include "../../../Windows/ResourceString.h"
-
-#include "../../Archive/IArchive.h"
-
-#include "../../Common/FileStreams.h"
-#include "../../ICoder.h"
-
-#include "../../UI/FileManager/LangUtils.h"
-
-#ifndef _NO_PROGRESS
-#include "../../UI/FileManager/ProgressDialog.h"
-#endif
-#include "../../UI/Common/ArchiveOpenCallback.h"
-
-class CExtractCallbackImp:
- public IArchiveExtractCallback,
- public IOpenCallbackUI,
- public CMyUnknownImp
-{
-public:
-
- MY_UNKNOWN_IMP
-
- INTERFACE_IArchiveExtractCallback(;)
- INTERFACE_IOpenCallbackUI(;)
-
-private:
- CMyComPtr<IInArchive> _archiveHandler;
- FString _directoryPath;
- UString _filePath;
- FString _diskFilePath;
-
- bool _extractMode;
- struct CProcessedFileInfo
- {
- FILETIME MTime;
- bool IsDir;
- UInt32 Attributes;
- } _processedFileInfo;
-
- COutFileStream *_outFileStreamSpec;
- CMyComPtr<ISequentialOutStream> _outFileStream;
-
- UString _itemDefaultName;
- FILETIME _defaultMTime;
- UInt32 _defaultAttributes;
-
- void CreateComplexDirectory(const UStringVector &dirPathParts);
-public:
- #ifndef _NO_PROGRESS
- CProgressDialog ProgressDialog;
- #endif
-
- bool _isCorrupt;
- UString _message;
-
- void Init(IInArchive *archiveHandler,
- const FString &directoryPath,
- const UString &itemDefaultName,
- const FILETIME &defaultMTime,
- UInt32 defaultAttributes);
-
- #ifndef _NO_PROGRESS
- HRESULT StartProgressDialog(const UString &title, NWindows::CThread &thread)
- {
- ProgressDialog.Create(title, thread, 0);
- {
- ProgressDialog.SetText(LangString(IDS_PROGRESS_EXTRACTING));
- }
-
- ProgressDialog.Show(SW_SHOWNORMAL);
- return S_OK;
- }
- virtual ~CExtractCallbackImp() { ProgressDialog.Destroy(); }
- #endif
-
-};
-
-#endif
+// ExtractCallbackSfx.h
+
+#ifndef ZIP7_INC_EXTRACT_CALLBACK_SFX_H
+#define ZIP7_INC_EXTRACT_CALLBACK_SFX_H
+
+#include "resource.h"
+
+#include "../../../Windows/ResourceString.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../ICoder.h"
+
+#include "../../UI/FileManager/LangUtils.h"
+
+#ifndef _NO_PROGRESS
+#include "../../UI/FileManager/ProgressDialog.h"
+#endif
+#include "../../UI/Common/ArchiveOpenCallback.h"
+
+class CExtractCallbackImp Z7_final:
+ public IArchiveExtractCallback,
+ public IOpenCallbackUI,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IArchiveExtractCallback)
+ Z7_IFACE_IMP(IOpenCallbackUI)
+
+ CMyComPtr<IInArchive> _archiveHandler;
+ FString _directoryPath;
+ UString _filePath;
+ FString _diskFilePath;
+
+ bool _extractMode;
+ struct CProcessedFileInfo
+ {
+ FILETIME MTime;
+ bool IsDir;
+ UInt32 Attributes;
+ } _processedFileInfo;
+
+ COutFileStream *_outFileStreamSpec;
+ CMyComPtr<ISequentialOutStream> _outFileStream;
+
+ UString _itemDefaultName;
+ FILETIME _defaultMTime;
+ UInt32 _defaultAttributes;
+
+ void CreateComplexDirectory(const UStringVector &dirPathParts);
+public:
+ #ifndef _NO_PROGRESS
+ CProgressDialog ProgressDialog;
+ #endif
+
+ bool _isCorrupt;
+ UString _message;
+
+ void Init(IInArchive *archiveHandler,
+ const FString &directoryPath,
+ const UString &itemDefaultName,
+ const FILETIME &defaultMTime,
+ UInt32 defaultAttributes);
+
+ #ifndef _NO_PROGRESS
+ HRESULT StartProgressDialog(const UString &title, NWindows::CThread &thread)
+ {
+ ProgressDialog.Create(title, thread, NULL);
+ {
+ ProgressDialog.SetText(LangString(IDS_PROGRESS_EXTRACTING));
+ }
+
+ ProgressDialog.Show(SW_SHOWNORMAL);
+ return S_OK;
+ }
+ ~CExtractCallbackImp() { ProgressDialog.Destroy(); }
+ #endif
+
+};
+
+#endif
diff --git a/CPP/7zip/Bundles/SFXSetup/ExtractEngine.cpp b/CPP/7zip/Bundles/SFXSetup/ExtractEngine.cpp
index 194e376..73ccff1 100644
--- a/CPP/7zip/Bundles/SFXSetup/ExtractEngine.cpp
+++ b/CPP/7zip/Bundles/SFXSetup/ExtractEngine.cpp
@@ -1,137 +1,135 @@
-// ExtractEngine.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/Thread.h"
-
-#include "../../UI/Common/OpenArchive.h"
-
-#include "../../UI/FileManager/FormatUtils.h"
-#include "../../UI/FileManager/LangUtils.h"
-
-#include "ExtractCallbackSfx.h"
-#include "ExtractEngine.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static LPCSTR const kCantFindArchive = "Can not find archive file";
-static LPCSTR const kCantOpenArchive = "Can not open the file as archive";
-
-struct CThreadExtracting
-{
- CCodecs *Codecs;
- FString FileName;
- FString DestFolder;
-
- CExtractCallbackImp *ExtractCallbackSpec;
- CMyComPtr<IArchiveExtractCallback> ExtractCallback;
-
- CArchiveLink ArchiveLink;
- HRESULT Result;
- UString ErrorMessage;
-
- void Process2()
- {
- NFind::CFileInfo fi;
- if (!fi.Find(FileName))
- {
- ErrorMessage = kCantFindArchive;
- Result = E_FAIL;
- return;
- }
-
- CObjectVector<COpenType> incl;
- CIntVector excl;
- COpenOptions options;
- options.codecs = Codecs;
- options.types = &incl;
- options.excludedFormats = !
- options.filePath = fs2us(FileName);
-
- Result = ArchiveLink.Open2(options, ExtractCallbackSpec);
- if (Result != S_OK)
- {
- ErrorMessage = kCantOpenArchive;
- return;
- }
-
- FString dirPath = DestFolder;
- NName::NormalizeDirPathPrefix(dirPath);
-
- if (!CreateComplexDir(dirPath))
- {
- ErrorMessage = MyFormatNew(IDS_CANNOT_CREATE_FOLDER,
- #ifdef LANG
- 0x02000603,
- #endif
- fs2us(dirPath));
- Result = E_FAIL;
- return;
- }
-
- ExtractCallbackSpec->Init(ArchiveLink.GetArchive(), dirPath, (UString)"Default", fi.MTime, 0);
-
- Result = ArchiveLink.GetArchive()->Extract(0, (UInt32)(Int32)-1 , BoolToInt(false), ExtractCallback);
- }
-
- void Process()
- {
- try
- {
- #ifndef _NO_PROGRESS
- CProgressCloser closer(ExtractCallbackSpec->ProgressDialog);
- #endif
- Process2();
- }
- catch(...) { Result = E_FAIL; }
- }
-
- static THREAD_FUNC_DECL MyThreadFunction(void *param)
- {
- ((CThreadExtracting *)param)->Process();
- return 0;
- }
-};
-
-HRESULT ExtractArchive(CCodecs *codecs, const FString &fileName, const FString &destFolder,
- bool showProgress, bool &isCorrupt, UString &errorMessage)
-{
- isCorrupt = false;
- CThreadExtracting t;
-
- t.Codecs = codecs;
- t.FileName = fileName;
- t.DestFolder = destFolder;
-
- t.ExtractCallbackSpec = new CExtractCallbackImp;
- t.ExtractCallback = t.ExtractCallbackSpec;
-
- #ifndef _NO_PROGRESS
-
- if (showProgress)
- {
- t.ExtractCallbackSpec->ProgressDialog.IconID = IDI_ICON;
- NWindows::CThread thread;
- RINOK(thread.Create(CThreadExtracting::MyThreadFunction, &t));
-
- UString title;
- LangString(IDS_PROGRESS_EXTRACTING, title);
- t.ExtractCallbackSpec->StartProgressDialog(title, thread);
- }
- else
-
- #endif
- {
- t.Process2();
- }
-
- errorMessage = t.ErrorMessage;
- if (errorMessage.IsEmpty())
- errorMessage = t.ExtractCallbackSpec->_message;
- isCorrupt = t.ExtractCallbackSpec->_isCorrupt;
- return t.Result;
-}
+// ExtractEngine.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../UI/Common/OpenArchive.h"
+
+#include "../../UI/FileManager/FormatUtils.h"
+#include "../../UI/FileManager/LangUtils.h"
+
+#include "ExtractCallbackSfx.h"
+#include "ExtractEngine.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static LPCSTR const kCantFindArchive = "Cannot find archive file";
+static LPCSTR const kCantOpenArchive = "Cannot open the file as archive";
+
+struct CThreadExtracting
+{
+ CCodecs *Codecs;
+ FString FileName;
+ FString DestFolder;
+
+ CExtractCallbackImp *ExtractCallbackSpec;
+ CMyComPtr<IArchiveExtractCallback> ExtractCallback;
+
+ CArchiveLink ArchiveLink;
+ HRESULT Result;
+ UString ErrorMessage;
+
+ void Process2()
+ {
+ NFind::CFileInfo fi;
+ if (!fi.Find(FileName))
+ {
+ ErrorMessage = kCantFindArchive;
+ Result = E_FAIL;
+ return;
+ }
+
+ CObjectVector<COpenType> incl;
+ CIntVector excl;
+ COpenOptions options;
+ options.codecs = Codecs;
+ options.types = &incl;
+ options.excludedFormats = !
+ options.filePath = fs2us(FileName);
+
+ Result = ArchiveLink.Open2(options, ExtractCallbackSpec);
+ if (Result != S_OK)
+ {
+ ErrorMessage = kCantOpenArchive;
+ return;
+ }
+
+ FString dirPath = DestFolder;
+ NName::NormalizeDirPathPrefix(dirPath);
+
+ if (!CreateComplexDir(dirPath))
+ {
+ ErrorMessage = MyFormatNew(IDS_CANNOT_CREATE_FOLDER, fs2us(dirPath));
+ Result = E_FAIL;
+ return;
+ }
+
+ ExtractCallbackSpec->Init(ArchiveLink.GetArchive(), dirPath, (UString)"Default", fi.MTime, 0);
+
+ Result = ArchiveLink.GetArchive()->Extract(NULL, (UInt32)(Int32)-1 , BoolToInt(false), ExtractCallback);
+ }
+
+ void Process()
+ {
+ try
+ {
+ #ifndef _NO_PROGRESS
+ CProgressCloser closer(ExtractCallbackSpec->ProgressDialog);
+ #endif
+ Process2();
+ }
+ catch(...) { Result = E_FAIL; }
+ }
+
+ static THREAD_FUNC_DECL MyThreadFunction(void *param)
+ {
+ ((CThreadExtracting *)param)->Process();
+ return 0;
+ }
+};
+
+HRESULT ExtractArchive(CCodecs *codecs, const FString &fileName, const FString &destFolder,
+ bool showProgress, bool &isCorrupt, UString &errorMessage)
+{
+ isCorrupt = false;
+ CThreadExtracting t;
+
+ t.Codecs = codecs;
+ t.FileName = fileName;
+ t.DestFolder = destFolder;
+
+ t.ExtractCallbackSpec = new CExtractCallbackImp;
+ t.ExtractCallback = t.ExtractCallbackSpec;
+
+ #ifndef _NO_PROGRESS
+
+ if (showProgress)
+ {
+ t.ExtractCallbackSpec->ProgressDialog.IconID = IDI_ICON;
+ NWindows::CThread thread;
+ const WRes wres = thread.Create(CThreadExtracting::MyThreadFunction, &t);
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+
+ UString title;
+ LangString(IDS_PROGRESS_EXTRACTING, title);
+ t.ExtractCallbackSpec->StartProgressDialog(title, thread);
+ }
+ else
+
+ #endif
+ {
+ t.Process2();
+ }
+
+ errorMessage = t.ErrorMessage;
+ if (errorMessage.IsEmpty())
+ errorMessage = t.ExtractCallbackSpec->_message;
+ isCorrupt = t.ExtractCallbackSpec->_isCorrupt;
+ return t.Result;
+}
diff --git a/CPP/7zip/Bundles/SFXSetup/ExtractEngine.h b/CPP/7zip/Bundles/SFXSetup/ExtractEngine.h
index 8aa9724..b7f7965 100644
--- a/CPP/7zip/Bundles/SFXSetup/ExtractEngine.h
+++ b/CPP/7zip/Bundles/SFXSetup/ExtractEngine.h
@@ -1,11 +1,11 @@
-// ExtractEngine.h
-
-#ifndef __EXTRACT_ENGINE_H
-#define __EXTRACT_ENGINE_H
-
-#include "../../UI/Common/LoadCodecs.h"
-
-HRESULT ExtractArchive(CCodecs *codecs, const FString &fileName, const FString &destFolder,
- bool showProgress, bool &isCorrupt, UString &errorMessage);
-
-#endif
+// ExtractEngine.h
+
+#ifndef ZIP7_INC_EXTRACT_ENGINE_H
+#define ZIP7_INC_EXTRACT_ENGINE_H
+
+#include "../../UI/Common/LoadCodecs.h"
+
+HRESULT ExtractArchive(CCodecs *codecs, const FString &fileName, const FString &destFolder,
+ bool showProgress, bool &isCorrupt, UString &errorMessage);
+
+#endif
diff --git a/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp b/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
index b1d740e..cf96460 100644
--- a/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
+++ b/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsp
@@ -1,803 +1,864 @@
-# Microsoft Developer Studio Project File - Name="SFXSetup" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Application" 0x0101
-
-CFG=SFXSetup - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "SFXSetup.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "SFXSetup.mak" CFG="SFXSetup - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "SFXSetup - Win32 Release" (based on "Win32 (x86) Application")
-!MESSAGE "SFXSetup - Win32 Debug" (based on "Win32 (x86) Application")
-!MESSAGE "SFXSetup - Win32 ReleaseD" (based on "Win32 (x86) Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "SFXSetup - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /Gz /MT /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "NO_REGISTRY" /D "_SFX" /D "_NO_CRYPTO" /Yu"StdAfx.h" /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
-# ADD LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zS.sfx" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "SFXSetup - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "NO_REGISTRY" /D "_SFX" /D "_NO_CRYPTO" /Yu"StdAfx.h" /FD /GZ /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\UTIL\7zSfxS.exe" /pdbtype:sept
-
-!ELSEIF "$(CFG)" == "SFXSetup - Win32 ReleaseD"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "ReleaseD"
-# PROP BASE Intermediate_Dir "ReleaseD"
-# PROP BASE Ignore_Export_Lib 0
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "ReleaseD"
-# PROP Intermediate_Dir "ReleaseD"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MD /W3 /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "EXCLUDE_COM" /D "NO_REGISTRY" /D "_SFX" /Yu"StdAfx.h" /FD /c
-# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "NO_REGISTRY" /D "_SFX" /D "_NO_CRYPTO" /Yu"StdAfx.h" /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\UTIL\7zWinSR.exe"
-# SUBTRACT BASE LINK32 /debug /nodefaultlib
-# ADD LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zSD.sfx" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ENDIF
-
-# Begin Target
-
-# Name "SFXSetup - Win32 Release"
-# Name "SFXSetup - Win32 Debug"
-# Name "SFXSetup - Win32 ReleaseD"
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\resource.rc
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.cpp
-# ADD CPP /Yc"StdAfx.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.h
-# End Source File
-# End Group
-# Begin Group "Interface"
-
-# PROP Default_Filter ""
-# End Group
-# Begin Group "7z"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zExtract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHeader.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zItem.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zRegister.cpp
-# End Source File
-# End Group
-# Begin Group "Archive Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
-# End Source File
-# End Group
-# Begin Group "Compress"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Coder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\DeltaFilter.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaRegister.cpp
-# End Source File
-# End Group
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\TextConfig.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\TextConfig.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\UTFConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\UTFConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.h
-# End Source File
-# End Group
-# Begin Group "Windows"
-
-# PROP Default_Filter ""
-# Begin Group "Control"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\Dialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\Dialog.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ResourceString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ResourceString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Window.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Window.h
-# End Source File
-# End Group
-# Begin Group "7z Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\PropId.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.h
-# End Source File
-# End Group
-# Begin Group "UI"
-
-# PROP Default_Filter ""
-# Begin Group "Explorer"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Explorer\MyMessages.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Explorer\MyMessages.h
-# End Source File
-# End Group
-# Begin Group "UI Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractMode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.h
-# End Source File
-# End Group
-# End Group
-# Begin Group "File Manager"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\FormatUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\FormatUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\LangUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ProgressDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ProgressDialog.h
-# End Source File
-# End Group
-# Begin Group "C"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrcOpt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra86.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\BraIA64.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\ExtractCallbackSfx.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\ExtractCallbackSfx.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\ExtractEngine.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\ExtractEngine.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\setup.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\SfxSetup.cpp
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="SFXSetup" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=SFXSetup - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "SFXSetup.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "SFXSetup.mak" CFG="SFXSetup - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "SFXSetup - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "SFXSetup - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "SFXSetup - Win32 ReleaseD" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "SFXSetup - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gz /MT /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_SFX" /D "Z7_NO_CRYPTO" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zS.sfx" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "SFXSetup - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_SFX" /D "Z7_NO_CRYPTO" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\UTIL\7zSfxS.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "SFXSetup - Win32 ReleaseD"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseD"
+# PROP BASE Intermediate_Dir "ReleaseD"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseD"
+# PROP Intermediate_Dir "ReleaseD"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_SFX" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_SFX" /D "Z7_NO_CRYPTO" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\UTIL\7zWinSR.exe"
+# SUBTRACT BASE LINK32 /debug /nodefaultlib
+# ADD LINK32 comctl32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zSD.sfx" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF
+
+# Begin Target
+
+# Name "SFXSetup - Win32 Release"
+# Name "SFXSetup - Win32 Debug"
+# Name "SFXSetup - Win32 ReleaseD"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# End Group
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeltaFilter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\TextConfig.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\TextConfig.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "UI"
+
+# PROP Default_Filter ""
+# Begin Group "Explorer"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\MyMessages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\MyMessages.h
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.h
+# End Source File
+# End Group
+# End Group
+# Begin Group "File Manager"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\LangUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgressDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgressDialog.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BraIA64.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "7zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\ExtractCallbackSfx.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractCallbackSfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractEngine.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractEngine.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\setup.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\SfxSetup.cpp
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsw b/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsw
index 2970370..f563b21 100644
--- a/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsw
+++ b/CPP/7zip/Bundles/SFXSetup/SFXSetup.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "SFXSetup"=.\SFXSetup.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "SFXSetup"=.\SFXSetup.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp b/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
index 1705a8d..47d7966 100644
--- a/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
+++ b/CPP/7zip/Bundles/SFXSetup/SfxSetup.cpp
@@ -1,364 +1,368 @@
-// Main.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/MyWindows.h"
-
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/TextConfig.h"
-
-#include "../../../Windows/DLL.h"
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileIO.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/NtCheck.h"
-#include "../../../Windows/ResourceString.h"
-
-#include "../../UI/Explorer/MyMessages.h"
-
-#include "ExtractEngine.h"
-
-#include "../../../../C/DllSecur.h"
-
-#include "resource.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-HINSTANCE g_hInstance;
-
-static CFSTR const kTempDirPrefix = FTEXT("7zS");
-
-#define _SHELL_EXECUTE
-
-static bool ReadDataString(CFSTR fileName, LPCSTR startID,
- LPCSTR endID, AString &stringResult)
-{
- stringResult.Empty();
- NIO::CInFile inFile;
- if (!inFile.Open(fileName))
- return false;
- const int kBufferSize = (1 << 12);
-
- Byte buffer[kBufferSize];
- int signatureStartSize = MyStringLen(startID);
- int signatureEndSize = MyStringLen(endID);
-
- UInt32 numBytesPrev = 0;
- bool writeMode = false;
- UInt64 posTotal = 0;
- for (;;)
- {
- if (posTotal > (1 << 20))
- return (stringResult.IsEmpty());
- UInt32 numReadBytes = kBufferSize - numBytesPrev;
- UInt32 processedSize;
- if (!inFile.Read(buffer + numBytesPrev, numReadBytes, processedSize))
- return false;
- if (processedSize == 0)
- return true;
- UInt32 numBytesInBuffer = numBytesPrev + processedSize;
- UInt32 pos = 0;
- for (;;)
- {
- if (writeMode)
- {
- if (pos > numBytesInBuffer - signatureEndSize)
- break;
- if (memcmp(buffer + pos, endID, signatureEndSize) == 0)
- return true;
- char b = buffer[pos];
- if (b == 0)
- return false;
- stringResult += b;
- pos++;
- }
- else
- {
- if (pos > numBytesInBuffer - signatureStartSize)
- break;
- if (memcmp(buffer + pos, startID, signatureStartSize) == 0)
- {
- writeMode = true;
- pos += signatureStartSize;
- }
- else
- pos++;
- }
- }
- numBytesPrev = numBytesInBuffer - pos;
- posTotal += pos;
- memmove(buffer, buffer + pos, numBytesPrev);
- }
-}
-
-static char kStartID[] = { ',','!','@','I','n','s','t','a','l','l','@','!','U','T','F','-','8','!', 0 };
-static char kEndID[] = { ',','!','@','I','n','s','t','a','l','l','E','n','d','@','!', 0 };
-
-struct CInstallIDInit
-{
- CInstallIDInit()
- {
- kStartID[0] = ';';
- kEndID[0] = ';';
- };
-} g_CInstallIDInit;
-
-
-#define NT_CHECK_FAIL_ACTION ShowErrorMessage(L"Unsupported Windows version"); return 1;
-
-static void ShowErrorMessageSpec(const UString &name)
-{
- UString message = NError::MyFormatMessage(::GetLastError());
- int pos = message.Find(L"%1");
- if (pos >= 0)
- {
- message.Delete(pos, 2);
- message.Insert(pos, name);
- }
- ShowErrorMessage(NULL, message);
-}
-
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
- #ifdef UNDER_CE
- LPWSTR
- #else
- LPSTR
- #endif
- /* lpCmdLine */,int /* nCmdShow */)
-{
- g_hInstance = (HINSTANCE)hInstance;
-
- NT_CHECK
-
- #ifdef _WIN32
- LoadSecurityDlls();
- #endif
-
- // InitCommonControls();
-
- UString archiveName, switches;
- #ifdef _SHELL_EXECUTE
- UString executeFile, executeParameters;
- #endif
- NCommandLineParser::SplitCommandLine(GetCommandLineW(), archiveName, switches);
-
- FString fullPath;
- NDLL::MyGetModuleFileName(fullPath);
-
- switches.Trim();
- bool assumeYes = false;
- if (switches.IsPrefixedBy_Ascii_NoCase("-y"))
- {
- assumeYes = true;
- switches = switches.Ptr(2);
- switches.Trim();
- }
-
- AString config;
- if (!ReadDataString(fullPath, kStartID, kEndID, config))
- {
- if (!assumeYes)
- ShowErrorMessage(L"Can't load config info");
- return 1;
- }
-
- UString dirPrefix ("." STRING_PATH_SEPARATOR);
- UString appLaunched;
- bool showProgress = true;
- if (!config.IsEmpty())
- {
- CObjectVector<CTextConfigPair> pairs;
- if (!GetTextConfig(config, pairs))
- {
- if (!assumeYes)
- ShowErrorMessage(L"Config failed");
- return 1;
- }
- UString friendlyName = GetTextConfigValue(pairs, "Title");
- UString installPrompt = GetTextConfigValue(pairs, "BeginPrompt");
- UString progress = GetTextConfigValue(pairs, "Progress");
- if (progress.IsEqualTo_Ascii_NoCase("no"))
- showProgress = false;
- int index = FindTextConfigItem(pairs, "Directory");
- if (index >= 0)
- dirPrefix = pairs[index].String;
- if (!installPrompt.IsEmpty() && !assumeYes)
- {
- if (MessageBoxW(0, installPrompt, friendlyName, MB_YESNO |
- MB_ICONQUESTION) != IDYES)
- return 0;
- }
- appLaunched = GetTextConfigValue(pairs, "RunProgram");
-
- #ifdef _SHELL_EXECUTE
- executeFile = GetTextConfigValue(pairs, "ExecuteFile");
- executeParameters = GetTextConfigValue(pairs, "ExecuteParameters");
- #endif
- }
-
- CTempDir tempDir;
- if (!tempDir.Create(kTempDirPrefix))
- {
- if (!assumeYes)
- ShowErrorMessage(L"Can not create temp folder archive");
- return 1;
- }
-
- CCodecs *codecs = new CCodecs;
- CMyComPtr<IUnknown> compressCodecsInfo = codecs;
- {
- HRESULT result = codecs->Load();
- if (result != S_OK)
- {
- ShowErrorMessage(L"Can not load codecs");
- return 1;
- }
- }
-
- const FString tempDirPath = tempDir.GetPath();
- // tempDirPath = L"M:\\1\\"; // to test low disk space
- {
- bool isCorrupt = false;
- UString errorMessage;
- HRESULT result = ExtractArchive(codecs, fullPath, tempDirPath, showProgress,
- isCorrupt, errorMessage);
-
- if (result != S_OK)
- {
- if (!assumeYes)
- {
- if (result == S_FALSE || isCorrupt)
- {
- NWindows::MyLoadString(IDS_EXTRACTION_ERROR_MESSAGE, errorMessage);
- result = E_FAIL;
- }
- if (result != E_ABORT)
- {
- if (errorMessage.IsEmpty())
- errorMessage = NError::MyFormatMessage(result);
- ::MessageBoxW(0, errorMessage, NWindows::MyLoadString(IDS_EXTRACTION_ERROR_TITLE), MB_ICONERROR);
- }
- }
- return 1;
- }
- }
-
- #ifndef UNDER_CE
- CCurrentDirRestorer currentDirRestorer;
- if (!SetCurrentDir(tempDirPath))
- return 1;
- #endif
-
- HANDLE hProcess = 0;
-#ifdef _SHELL_EXECUTE
- if (!executeFile.IsEmpty())
- {
- CSysString filePath (GetSystemString(executeFile));
- SHELLEXECUTEINFO execInfo;
- execInfo.cbSize = sizeof(execInfo);
- execInfo.fMask = SEE_MASK_NOCLOSEPROCESS
- #ifndef UNDER_CE
- | SEE_MASK_FLAG_DDEWAIT
- #endif
- ;
- execInfo.hwnd = NULL;
- execInfo.lpVerb = NULL;
- execInfo.lpFile = filePath;
-
- if (!switches.IsEmpty())
- {
- executeParameters.Add_Space_if_NotEmpty();
- executeParameters += switches;
- }
-
- CSysString parametersSys (GetSystemString(executeParameters));
- if (parametersSys.IsEmpty())
- execInfo.lpParameters = NULL;
- else
- execInfo.lpParameters = parametersSys;
-
- execInfo.lpDirectory = NULL;
- execInfo.nShow = SW_SHOWNORMAL;
- execInfo.hProcess = 0;
- /* BOOL success = */ ::ShellExecuteEx(&execInfo);
- UINT32 result = (UINT32)(UINT_PTR)execInfo.hInstApp;
- if (result <= 32)
- {
- if (!assumeYes)
- ShowErrorMessage(L"Can not open file");
- return 1;
- }
- hProcess = execInfo.hProcess;
- }
- else
-#endif
- {
- if (appLaunched.IsEmpty())
- {
- appLaunched = L"setup.exe";
- if (!NFind::DoesFileExist(us2fs(appLaunched)))
- {
- if (!assumeYes)
- ShowErrorMessage(L"Can not find setup.exe");
- return 1;
- }
- }
-
- {
- FString s2 = tempDirPath;
- NName::NormalizeDirPathPrefix(s2);
- appLaunched.Replace(L"%%T" WSTRING_PATH_SEPARATOR, fs2us(s2));
- }
-
- UString appNameForError = appLaunched; // actually we need to rtemove parameters also
-
- appLaunched.Replace(L"%%T", fs2us(tempDirPath));
-
- if (!switches.IsEmpty())
- {
- appLaunched.Add_Space();
- appLaunched += switches;
- }
- STARTUPINFO startupInfo;
- startupInfo.cb = sizeof(startupInfo);
- startupInfo.lpReserved = 0;
- startupInfo.lpDesktop = 0;
- startupInfo.lpTitle = 0;
- startupInfo.dwFlags = 0;
- startupInfo.cbReserved2 = 0;
- startupInfo.lpReserved2 = 0;
-
- PROCESS_INFORMATION processInformation;
-
- CSysString appLaunchedSys (GetSystemString(dirPrefix + appLaunched));
-
- BOOL createResult = CreateProcess(NULL, (LPTSTR)(LPCTSTR)appLaunchedSys,
- NULL, NULL, FALSE, 0, NULL, NULL /*tempDir.GetPath() */,
- &startupInfo, &processInformation);
- if (createResult == 0)
- {
- if (!assumeYes)
- {
- // we print name of exe file, if error message is
- // ERROR_BAD_EXE_FORMAT: "%1 is not a valid Win32 application".
- ShowErrorMessageSpec(appNameForError);
- }
- return 1;
- }
- ::CloseHandle(processInformation.hThread);
- hProcess = processInformation.hProcess;
- }
- if (hProcess != 0)
- {
- WaitForSingleObject(hProcess, INFINITE);
- ::CloseHandle(hProcess);
- }
- return 0;
-}
+// Main.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/DllSecur.h"
+
+#include "../../../Common/MyWindows.h"
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/TextConfig.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "../../UI/Explorer/MyMessages.h"
+
+#include "ExtractEngine.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance;
+
+static CFSTR const kTempDirPrefix = FTEXT("7zS");
+
+#define MY_SHELL_EXECUTE
+
+static bool ReadDataString(CFSTR fileName, LPCSTR startID,
+ LPCSTR endID, AString &stringResult)
+{
+ stringResult.Empty();
+ NIO::CInFile inFile;
+ if (!inFile.Open(fileName))
+ return false;
+ const size_t kBufferSize = (1 << 12);
+
+ Byte buffer[kBufferSize];
+ const unsigned signatureStartSize = MyStringLen(startID);
+ const unsigned signatureEndSize = MyStringLen(endID);
+
+ size_t numBytesPrev = 0;
+ bool writeMode = false;
+ UInt64 posTotal = 0;
+ for (;;)
+ {
+ if (posTotal > (1 << 20))
+ return (stringResult.IsEmpty());
+ const size_t numReadBytes = kBufferSize - numBytesPrev;
+ size_t processedSize;
+ if (!inFile.ReadFull(buffer + numBytesPrev, numReadBytes, processedSize))
+ return false;
+ if (processedSize == 0)
+ return true;
+ const size_t numBytesInBuffer = numBytesPrev + processedSize;
+ UInt32 pos = 0;
+ for (;;)
+ {
+ if (writeMode)
+ {
+ if (pos + signatureEndSize > numBytesInBuffer)
+ break;
+ if (memcmp(buffer + pos, endID, signatureEndSize) == 0)
+ return true;
+ const Byte b = buffer[pos];
+ if (b == 0)
+ return false;
+ stringResult += (char)b;
+ pos++;
+ }
+ else
+ {
+ if (pos + signatureStartSize > numBytesInBuffer)
+ break;
+ if (memcmp(buffer + pos, startID, signatureStartSize) == 0)
+ {
+ writeMode = true;
+ pos += signatureStartSize;
+ }
+ else
+ pos++;
+ }
+ }
+ numBytesPrev = numBytesInBuffer - pos;
+ posTotal += pos;
+ memmove(buffer, buffer + pos, numBytesPrev);
+ }
+}
+
+static char kStartID[] = { ',','!','@','I','n','s','t','a','l','l','@','!','U','T','F','-','8','!', 0 };
+static char kEndID[] = { ',','!','@','I','n','s','t','a','l','l','E','n','d','@','!', 0 };
+
+static struct CInstallIDInit
+{
+ CInstallIDInit()
+ {
+ kStartID[0] = ';';
+ kEndID[0] = ';';
+ }
+} g_CInstallIDInit;
+
+
+#if defined(_WIN32) && defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION ShowErrorMessage(L"Unsupported Windows version"); return 1;
+#endif
+
+static void ShowErrorMessageSpec(const UString &name)
+{
+ UString message = NError::MyFormatMessage(::GetLastError());
+ const int pos = message.Find(L"%1");
+ if (pos >= 0)
+ {
+ message.Delete((unsigned)pos, 2);
+ message.Insert((unsigned)pos, name);
+ }
+ ShowErrorMessage(NULL, message);
+}
+
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ /* lpCmdLine */,int /* nCmdShow */)
+{
+ g_hInstance = (HINSTANCE)hInstance;
+
+ NT_CHECK
+
+ #ifdef _WIN32
+ LoadSecurityDlls();
+ #endif
+
+ // InitCommonControls();
+
+ UString archiveName, switches;
+ #ifdef MY_SHELL_EXECUTE
+ UString executeFile, executeParameters;
+ #endif
+ NCommandLineParser::SplitCommandLine(GetCommandLineW(), archiveName, switches);
+
+ FString fullPath;
+ NDLL::MyGetModuleFileName(fullPath);
+
+ switches.Trim();
+ bool assumeYes = false;
+ if (switches.IsPrefixedBy_Ascii_NoCase("-y"))
+ {
+ assumeYes = true;
+ switches = switches.Ptr(2);
+ switches.Trim();
+ }
+
+ AString config;
+ if (!ReadDataString(fullPath, kStartID, kEndID, config))
+ {
+ if (!assumeYes)
+ ShowErrorMessage(L"Can't load config info");
+ return 1;
+ }
+
+ UString dirPrefix ("." STRING_PATH_SEPARATOR);
+ UString appLaunched;
+ bool showProgress = true;
+ if (!config.IsEmpty())
+ {
+ CObjectVector<CTextConfigPair> pairs;
+ if (!GetTextConfig(config, pairs))
+ {
+ if (!assumeYes)
+ ShowErrorMessage(L"Config failed");
+ return 1;
+ }
+ const UString friendlyName = GetTextConfigValue(pairs, "Title");
+ const UString installPrompt = GetTextConfigValue(pairs, "BeginPrompt");
+ const UString progress = GetTextConfigValue(pairs, "Progress");
+ if (progress.IsEqualTo_Ascii_NoCase("no"))
+ showProgress = false;
+ const int index = FindTextConfigItem(pairs, "Directory");
+ if (index >= 0)
+ dirPrefix = pairs[index].String;
+ if (!installPrompt.IsEmpty() && !assumeYes)
+ {
+ if (MessageBoxW(NULL, installPrompt, friendlyName, MB_YESNO |
+ MB_ICONQUESTION) != IDYES)
+ return 0;
+ }
+ appLaunched = GetTextConfigValue(pairs, "RunProgram");
+
+ #ifdef MY_SHELL_EXECUTE
+ executeFile = GetTextConfigValue(pairs, "ExecuteFile");
+ executeParameters = GetTextConfigValue(pairs, "ExecuteParameters");
+ #endif
+ }
+
+ CTempDir tempDir;
+ if (!tempDir.Create(kTempDirPrefix))
+ {
+ if (!assumeYes)
+ ShowErrorMessage(L"Cannot create temp folder archive");
+ return 1;
+ }
+
+ CCodecs *codecs = new CCodecs;
+ CMyComPtr<IUnknown> compressCodecsInfo = codecs;
+ {
+ const HRESULT result = codecs->Load();
+ if (result != S_OK)
+ {
+ ShowErrorMessage(L"Cannot load codecs");
+ return 1;
+ }
+ }
+
+ const FString tempDirPath = tempDir.GetPath();
+ // tempDirPath = L"M:\\1\\"; // to test low disk space
+ {
+ bool isCorrupt = false;
+ UString errorMessage;
+ HRESULT result = ExtractArchive(codecs, fullPath, tempDirPath, showProgress,
+ isCorrupt, errorMessage);
+
+ if (result != S_OK)
+ {
+ if (!assumeYes)
+ {
+ if (result == S_FALSE || isCorrupt)
+ {
+ NWindows::MyLoadString(IDS_EXTRACTION_ERROR_MESSAGE, errorMessage);
+ result = E_FAIL;
+ }
+ if (result != E_ABORT)
+ {
+ if (errorMessage.IsEmpty())
+ errorMessage = NError::MyFormatMessage(result);
+ ::MessageBoxW(NULL, errorMessage, NWindows::MyLoadString(IDS_EXTRACTION_ERROR_TITLE), MB_ICONERROR);
+ }
+ }
+ return 1;
+ }
+ }
+
+ #ifndef UNDER_CE
+ CCurrentDirRestorer currentDirRestorer;
+ if (!SetCurrentDir(tempDirPath))
+ return 1;
+ #endif
+
+ HANDLE hProcess = NULL;
+#ifdef MY_SHELL_EXECUTE
+ if (!executeFile.IsEmpty())
+ {
+ CSysString filePath (GetSystemString(executeFile));
+ SHELLEXECUTEINFO execInfo;
+ execInfo.cbSize = sizeof(execInfo);
+ execInfo.fMask = SEE_MASK_NOCLOSEPROCESS
+ #ifndef UNDER_CE
+ | SEE_MASK_FLAG_DDEWAIT
+ #endif
+ ;
+ execInfo.hwnd = NULL;
+ execInfo.lpVerb = NULL;
+ execInfo.lpFile = filePath;
+
+ if (!switches.IsEmpty())
+ {
+ executeParameters.Add_Space_if_NotEmpty();
+ executeParameters += switches;
+ }
+
+ const CSysString parametersSys (GetSystemString(executeParameters));
+ if (parametersSys.IsEmpty())
+ execInfo.lpParameters = NULL;
+ else
+ execInfo.lpParameters = parametersSys;
+
+ execInfo.lpDirectory = NULL;
+ execInfo.nShow = SW_SHOWNORMAL;
+ execInfo.hProcess = NULL;
+ /* BOOL success = */ ::ShellExecuteEx(&execInfo);
+ UINT32 result = (UINT32)(UINT_PTR)execInfo.hInstApp;
+ if (result <= 32)
+ {
+ if (!assumeYes)
+ ShowErrorMessage(L"Cannot open file");
+ return 1;
+ }
+ hProcess = execInfo.hProcess;
+ }
+ else
+#endif
+ {
+ if (appLaunched.IsEmpty())
+ {
+ appLaunched = L"setup.exe";
+ if (!NFind::DoesFileExist_FollowLink(us2fs(appLaunched)))
+ {
+ if (!assumeYes)
+ ShowErrorMessage(L"Cannot find setup.exe");
+ return 1;
+ }
+ }
+
+ {
+ FString s2 = tempDirPath;
+ NName::NormalizeDirPathPrefix(s2);
+ appLaunched.Replace(L"%%T" WSTRING_PATH_SEPARATOR, fs2us(s2));
+ }
+
+ const UString appNameForError = appLaunched; // actually we need to rtemove parameters also
+
+ appLaunched.Replace(L"%%T", fs2us(tempDirPath));
+
+ if (!switches.IsEmpty())
+ {
+ appLaunched.Add_Space();
+ appLaunched += switches;
+ }
+ STARTUPINFO startupInfo;
+ startupInfo.cb = sizeof(startupInfo);
+ startupInfo.lpReserved = NULL;
+ startupInfo.lpDesktop = NULL;
+ startupInfo.lpTitle = NULL;
+ startupInfo.dwFlags = 0;
+ startupInfo.cbReserved2 = 0;
+ startupInfo.lpReserved2 = NULL;
+
+ PROCESS_INFORMATION processInformation;
+
+ const CSysString appLaunchedSys (GetSystemString(dirPrefix + appLaunched));
+
+ const BOOL createResult = CreateProcess(NULL,
+ appLaunchedSys.Ptr_non_const(),
+ NULL, NULL, FALSE, 0, NULL, NULL /*tempDir.GetPath() */,
+ &startupInfo, &processInformation);
+ if (createResult == 0)
+ {
+ if (!assumeYes)
+ {
+ // we print name of exe file, if error message is
+ // ERROR_BAD_EXE_FORMAT: "%1 is not a valid Win32 application".
+ ShowErrorMessageSpec(appNameForError);
+ }
+ return 1;
+ }
+ ::CloseHandle(processInformation.hThread);
+ hProcess = processInformation.hProcess;
+ }
+ if (hProcess)
+ {
+ WaitForSingleObject(hProcess, INFINITE);
+ ::CloseHandle(hProcess);
+ }
+ return 0;
+}
diff --git a/CPP/7zip/Bundles/SFXSetup/StdAfx.cpp b/CPP/7zip/Bundles/SFXSetup/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/SFXSetup/StdAfx.cpp
+++ b/CPP/7zip/Bundles/SFXSetup/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/SFXSetup/StdAfx.h b/CPP/7zip/Bundles/SFXSetup/StdAfx.h
index 72410ee..4f27255 100644
--- a/CPP/7zip/Bundles/SFXSetup/StdAfx.h
+++ b/CPP/7zip/Bundles/SFXSetup/StdAfx.h
@@ -1,13 +1,6 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#include <commctrl.h>
-
-// #define printf(x) NO_PRINTF_(x)
-// #define sprintf(x) NO_SPRINTF_(x)
-
-#endif
+// StdAfx.h
+
+#if _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../UI/FileManager/StdAfx.h"
diff --git a/CPP/7zip/Bundles/SFXSetup/makefile b/CPP/7zip/Bundles/SFXSetup/makefile
index b97daad..ea0ece2 100644
--- a/CPP/7zip/Bundles/SFXSetup/makefile
+++ b/CPP/7zip/Bundles/SFXSetup/makefile
@@ -1,117 +1,118 @@
-PROG = 7zS.sfx
-MY_FIXED = 1
-
-CFLAGS = $(CFLAGS) \
- -DNO_REGISTRY \
- -DEXTRACT_ONLY \
- -DNO_READ_FROM_CODER \
- -D_SFX \
- -D_NO_CRYPTO \
-
-CURRENT_OBJS = \
- $O\SfxSetup.obj \
- $O\ExtractCallbackSfx.obj \
- $O\ExtractEngine.obj \
-
-COMMON_OBJS = \
- $O\CommandLineParser.obj \
- $O\CRC.obj \
- $O\IntToString.obj \
- $O\NewHandler.obj \
- $O\MyString.obj \
- $O\StringConvert.obj \
- $O\TextConfig.obj \
- $O\UTFConvert.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
-
-WIN_OBJS = \
- $O\DLL.obj \
- $O\ErrorMsg.obj \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileName.obj \
- $O\PropVariant.obj \
- $O\ResourceString.obj \
- $O\Synchronization.obj \
- $O\System.obj \
- $O\Window.obj \
-
-WIN_CTRL_OBJS = \
- $O\Dialog.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\CWrappers.obj \
- $O\FileStreams.obj \
- $O\InBuffer.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\OutBuffer.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamBinder.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\VirtThread.obj \
-
-UI_COMMON_OBJS = \
- $O\ArchiveOpenCallback.obj \
- $O\DefaultName.obj \
- $O\LoadCodecs.obj \
- $O\OpenArchive.obj \
-
-EXPLORER_OBJS = \
- $O\MyMessages.obj \
-
-FM_OBJS = \
- $O\FormatUtils.obj \
- $O\ProgressDialog.obj \
-
-AR_COMMON_OBJS = \
- $O\CoderMixer2.obj \
- $O\ItemNameUtils.obj \
- $O\OutStreamWithCRC.obj \
-
-7Z_OBJS = \
- $O\7zDecode.obj \
- $O\7zExtract.obj \
- $O\7zHandler.obj \
- $O\7zIn.obj \
- $O\7zRegister.obj \
-
-COMPRESS_OBJS = \
- $O\Bcj2Coder.obj \
- $O\Bcj2Register.obj \
- $O\BcjCoder.obj \
- $O\BcjRegister.obj \
- $O\BranchMisc.obj \
- $O\BranchRegister.obj \
- $O\CopyCoder.obj \
- $O\CopyRegister.obj \
- $O\DeltaFilter.obj \
- $O\Lzma2Decoder.obj \
- $O\Lzma2Register.obj \
- $O\LzmaDecoder.obj \
- $O\LzmaRegister.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\DllSecur.obj \
- $O\Lzma2Dec.obj \
- $O\Lzma2DecMt.obj \
- $O\LzmaDec.obj \
- $O\MtDec.obj \
- $O\Threads.obj \
-
-!include "../../Crc.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = 7zS.sfx
+MY_FIXED = 1
+
+CFLAGS = $(CFLAGS) \
+ -DZ7_NO_REGISTRY \
+ -DZ7_EXTRACT_ONLY \
+ -DZ7_NO_READ_FROM_CODER \
+ -DZ7_SFX \
+ -DZ7_NO_CRYPTO \
+
+CURRENT_OBJS = \
+ $O\SfxSetup.obj \
+ $O\ExtractCallbackSfx.obj \
+ $O\ExtractEngine.obj \
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\IntToString.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\TextConfig.obj \
+ $O\UTFConvert.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\ResourceString.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\Window.obj \
+
+WIN_CTRL_OBJS = \
+ $O\Dialog.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\FileStreams.obj \
+ $O\InBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\VirtThread.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveOpenCallback.obj \
+ $O\DefaultName.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+
+EXPLORER_OBJS = \
+ $O\MyMessages.obj \
+
+FM_OBJS = \
+ $O\FormatUtils.obj \
+ $O\ProgressDialog.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+
+7Z_OBJS = \
+ $O\7zDecode.obj \
+ $O\7zExtract.obj \
+ $O\7zHandler.obj \
+ $O\7zIn.obj \
+ $O\7zRegister.obj \
+
+COMPRESS_OBJS = \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaRegister.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\DllSecur.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\LzmaDec.obj \
+ $O\MtDec.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+!include "../../LzmaDec.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/SFXSetup/resource.h b/CPP/7zip/Bundles/SFXSetup/resource.h
index 533197e..d5f440b 100644
--- a/CPP/7zip/Bundles/SFXSetup/resource.h
+++ b/CPP/7zip/Bundles/SFXSetup/resource.h
@@ -1,6 +1,6 @@
-#define IDI_ICON 1
-
-#define IDS_EXTRACTION_ERROR_TITLE 7
-#define IDS_EXTRACTION_ERROR_MESSAGE 8
-#define IDS_CANNOT_CREATE_FOLDER 3003
-#define IDS_PROGRESS_EXTRACTING 3300
+#define IDI_ICON 1
+
+#define IDS_EXTRACTION_ERROR_TITLE 7
+#define IDS_EXTRACTION_ERROR_MESSAGE 8
+#define IDS_CANNOT_CREATE_FOLDER 3003
+#define IDS_PROGRESS_EXTRACTING 3300
diff --git a/CPP/7zip/Bundles/SFXSetup/resource.rc b/CPP/7zip/Bundles/SFXSetup/resource.rc
index 9e88fd4..47e1b76 100644
--- a/CPP/7zip/Bundles/SFXSetup/resource.rc
+++ b/CPP/7zip/Bundles/SFXSetup/resource.rc
@@ -1,16 +1,16 @@
-#include "../../MyVersionInfo.rc"
-#include "resource.h"
-
-MY_VERSION_INFO_APP("7z Setup SFX", "7zS.sfx")
-
-IDI_ICON ICON "setup.ico"
-
-STRINGTABLE
-BEGIN
- IDS_EXTRACTION_ERROR_TITLE "Extraction Failed"
- IDS_EXTRACTION_ERROR_MESSAGE "File is corrupt"
- IDS_CANNOT_CREATE_FOLDER "Cannot create folder '{0}'"
- IDS_PROGRESS_EXTRACTING "Extracting"
-END
-
-#include "../../UI/FileManager/ProgressDialog.rc"
+#include "../../MyVersionInfo.rc"
+#include "resource.h"
+
+MY_VERSION_INFO_APP("7z Setup SFX", "7zS.sfx")
+
+IDI_ICON ICON "setup.ico"
+
+STRINGTABLE
+BEGIN
+ IDS_EXTRACTION_ERROR_TITLE "Extraction Failed"
+ IDS_EXTRACTION_ERROR_MESSAGE "File is corrupt"
+ IDS_CANNOT_CREATE_FOLDER "Cannot create folder '{0}'"
+ IDS_PROGRESS_EXTRACTING "Extracting"
+END
+
+#include "../../UI/FileManager/ProgressDialog.rc"
diff --git a/CPP/7zip/Bundles/SFXWin/SFXWin.dsp b/CPP/7zip/Bundles/SFXWin/SFXWin.dsp
index 83ec931..65cf0bf 100644
--- a/CPP/7zip/Bundles/SFXWin/SFXWin.dsp
+++ b/CPP/7zip/Bundles/SFXWin/SFXWin.dsp
@@ -1,988 +1,1066 @@
-# Microsoft Developer Studio Project File - Name="SFXWin" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Application" 0x0101
-
-CFG=SFXWin - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "SFXWin.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "SFXWin.mak" CFG="SFXWin - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "SFXWin - Win32 Release" (based on "Win32 (x86) Application")
-!MESSAGE "SFXWin - Win32 Debug" (based on "Win32 (x86) Application")
-!MESSAGE "SFXWin - Win32 ReleaseD" (based on "Win32 (x86) Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "SFXWin - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_SFXWIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "NO_REGISTRY" /D "NO_READ_FROM_CODER" /D "_SFX" /Yu"StdAfx.h" /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7z.sfx" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ELSEIF "$(CFG)" == "SFXWin - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_SFXWIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "NO_REGISTRY" /D "NO_READ_FROM_CODER" /D "_SFX" /Yu"StdAfx.h" /FD /GZ /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zsfx.exe" /pdbtype:sept
-
-!ELSEIF "$(CFG)" == "SFXWin - Win32 ReleaseD"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "SFXWin___Win32_ReleaseD"
-# PROP BASE Intermediate_Dir "SFXWin___Win32_ReleaseD"
-# PROP BASE Ignore_Export_Lib 0
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "SFXWin___Win32_ReleaseD"
-# PROP Intermediate_Dir "SFXWin___Win32_ReleaseD"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /Gz /MT /W3 /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "EXCLUDE_COM" /D "NO_REGISTRY" /D "_SFX" /Yu"StdAfx.h" /FD /c
-# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_SFXWIN32" /D "_WINDOWS" /D "_MBCS" /D "EXTRACT_ONLY" /D "NO_REGISTRY" /D "NO_READ_FROM_CODER" /D "_SFX" /Yu"StdAfx.h" /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7z.sfx" /opt:NOWIN98
-# SUBTRACT BASE LINK32 /pdb:none
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zD.sfx" /opt:NOWIN98
-# SUBTRACT LINK32 /pdb:none
-
-!ENDIF
-
-# Begin Target
-
-# Name "SFXWin - Win32 Release"
-# Name "SFXWin - Win32 Debug"
-# Name "SFXWin - Win32 ReleaseD"
-# Begin Group "Spec"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=.\StdAfx.cpp
-# ADD CPP /Yc"StdAfx.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.h
-# End Source File
-# End Group
-# Begin Group "7z"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zDecode.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zExtract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zHeader.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zIn.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\7z\7zRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\SplitHandler.cpp
-# End Source File
-# End Group
-# Begin Group "Archive Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\CoderMixer2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\ItemNameUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\MultiStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\MultiStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
-# End Source File
-# End Group
-# Begin Group "Compress"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Coder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Bcj2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BcjRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchMisc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\BranchRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\CopyRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\DeltaFilter.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Decoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\Lzma2Register.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\LzmaRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\PpmdDecoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Compress\PpmdRegister.cpp
-# End Source File
-# End Group
-# Begin Group "Crypto"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAes.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\7zAesRegister.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\MyAes.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Crypto\MyAes.h
-# End Source File
-# End Group
-# Begin Group "Dialogs"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\BrowseDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\BrowseDialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ComboDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ComboDialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\OverwriteDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\OverwriteDialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\PasswordDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\PasswordDialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ProgressDialog2.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ProgressDialog2.h
-# End Source File
-# End Group
-# Begin Group "7zip Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CreateCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\CWrappers.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilePathAutoRename.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilePathAutoRename.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FilterCoder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\InBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LimitedStreams.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LockedStream.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\LockedStream.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\OutBuffer.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\ProgressUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\PropId.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamBinder.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamObjects.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\StreamUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\VirtThread.h
-# End Source File
-# End Group
-# Begin Group "File Manager"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ExtractCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\ExtractCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\FormatUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\FormatUtils.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\PropertyName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\PropertyName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\SysIconUtils.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\FileManager\SysIconUtils.h
-# End Source File
-# End Group
-# Begin Group "Windows"
-
-# PROP Default_Filter ""
-# Begin Group "Control"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\ComboBox.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\ComboBox.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\Dialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\Dialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\ListView.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Control\ListView.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\..\Windows\CommonDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\CommonDialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ErrorMsg.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ResourceString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\ResourceString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Shell.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Shell.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Synchronization.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\System.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Window.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\Window.h
-# End Source File
-# End Group
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CommandLineParser.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\CRC.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.h
-# End Source File
-# End Group
-# Begin Group "UI"
-
-# PROP Default_Filter ""
-# Begin Group "UI Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\DefaultName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Extract.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\Extract.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\ExtractingFilePath.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\LoadCodecs.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Common\OpenArchive.h
-# End Source File
-# End Group
-# Begin Group "GUI"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\GUI\ExtractDialog.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\GUI\ExtractDialog.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\GUI\ExtractGUI.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\GUI\ExtractGUI.h
-# End Source File
-# End Group
-# Begin Group "Explorer"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\UI\Explorer\MyMessages.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\UI\Explorer\MyMessages.h
-# End Source File
-# End Group
-# End Group
-# Begin Group "C"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\7zCrcOpt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Aes.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Aes.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\AesOpt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Alloc.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bcj2.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Bra86.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\BraIA64.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\CpuArch.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Delta.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\DllSecur.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2Dec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Lzma2DecMt.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\LzmaDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\MtDec.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Ppmd7.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Ppmd7.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Ppmd7Dec.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Sha256.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.c
-# SUBTRACT CPP /YX /Yc /Yu
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Threads.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\7z.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\7z1.ico
-# End Source File
-# Begin Source File
-
-SOURCE=.\resource.rc
-# End Source File
-# Begin Source File
-
-SOURCE=.\SfxWin.cpp
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="SFXWin" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=SFXWin - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "SFXWin.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "SFXWin.mak" CFG="SFXWin - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "SFXWin - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "SFXWin - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "SFXWin - Win32 ReleaseD" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "SFXWin - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_NO_READ_FROM_CODER" /D "Z7_SFX" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7z.sfx" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "SFXWin - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_NO_READ_FROM_CODER" /D "Z7_SFX" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zsfx.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "SFXWin - Win32 ReleaseD"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "SFXWin___Win32_ReleaseD"
+# PROP BASE Intermediate_Dir "SFXWin___Win32_ReleaseD"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "SFXWin___Win32_ReleaseD"
+# PROP Intermediate_Dir "SFXWin___Win32_ReleaseD"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /Gz /MT /W3 /GX /O1 /I "..\..\..\\" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_SFX" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "Z7_EXTRACT_ONLY" /D "Z7_NO_REGISTRY" /D "Z7_NO_READ_FROM_CODER" /D "Z7_SFX" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7z.sfx" /opt:NOWIN98
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zD.sfx" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF
+
+# Begin Target
+
+# Name "SFXWin - Win32 Release"
+# Name "SFXWin - Win32 Debug"
+# Name "SFXWin - Win32 ReleaseD"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "7z"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zDecode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zExtract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zHeader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zIn.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\7z\7zRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\SplitHandler.cpp
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\CoderMixer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\MultiStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Coder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Bcj2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BcjRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\BranchRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\DeltaFilter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Decoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\Lzma2Register.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\LzmaRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdDecoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\PpmdRegister.cpp
+# End Source File
+# End Group
+# Begin Group "Crypto"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\7zAesRegister.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Crypto\MyAes.h
+# End Source File
+# End Group
+# Begin Group "Dialogs"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\BrowseDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\BrowseDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ComboDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ComboDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OverwriteDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\OverwriteDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PasswordDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PasswordDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgressDialog2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ProgressDialog2.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CWrappers.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\InBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LockedStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\OutBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamBinder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\VirtThread.h
+# End Source File
+# End Group
+# Begin Group "File Manager"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\ExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PropertyName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\PropertyName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SysIconUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\FileManager\SysIconUtils.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Sha256Prepare.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "UI"
+
+# PROP Default_Filter ""
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Common\OpenArchive.h
+# End Source File
+# End Group
+# Begin Group "GUI"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\GUI\ExtractGUI.h
+# End Source File
+# End Group
+# Begin Group "Explorer"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\MyMessages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\UI\Explorer\MyMessages.h
+# End Source File
+# End Group
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zStream.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Aes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\AesOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bcj2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Bra86.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\BraIA64.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Delta.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2Dec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Lzma2DecMt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\LzmaDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\MtDec.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Ppmd7Dec.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sha256Opt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "7zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7z.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\SfxWin.cpp
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/Bundles/SFXWin/SFXWin.dsw b/CPP/7zip/Bundles/SFXWin/SFXWin.dsw
index 6695803..a9926c7 100644
--- a/CPP/7zip/Bundles/SFXWin/SFXWin.dsw
+++ b/CPP/7zip/Bundles/SFXWin/SFXWin.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "SFXWin"=.\SFXWin.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "SFXWin"=.\SFXWin.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/Bundles/SFXWin/SfxWin.cpp b/CPP/7zip/Bundles/SFXWin/SfxWin.cpp
index 5eade1a..3e1880e 100644
--- a/CPP/7zip/Bundles/SFXWin/SfxWin.cpp
+++ b/CPP/7zip/Bundles/SFXWin/SfxWin.cpp
@@ -1,241 +1,254 @@
-// Main.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/MyWindows.h"
-
-#include <Shlwapi.h>
-
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/DLL.h"
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/NtCheck.h"
-#include "../../../Windows/ResourceString.h"
-
-#include "../../ICoder.h"
-#include "../../IPassword.h"
-#include "../../Archive/IArchive.h"
-#include "../../UI/Common/Extract.h"
-#include "../../UI/Common/ExitCode.h"
-#include "../../UI/Explorer/MyMessages.h"
-#include "../../UI/FileManager/MyWindowsNew.h"
-#include "../../UI/GUI/ExtractGUI.h"
-#include "../../UI/GUI/ExtractRes.h"
-
-#include "../../../../C/DllSecur.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-HINSTANCE g_hInstance;
-
-#ifndef UNDER_CE
-
-DWORD g_ComCtl32Version;
-
-static DWORD GetDllVersion(LPCTSTR dllName)
-{
- DWORD dwVersion = 0;
- HINSTANCE hinstDll = LoadLibrary(dllName);
- if (hinstDll)
- {
- DLLGETVERSIONPROC pDllGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hinstDll, "DllGetVersion");
- if (pDllGetVersion)
- {
- DLLVERSIONINFO dvi;
- ZeroMemory(&dvi, sizeof(dvi));
- dvi.cbSize = sizeof(dvi);
- HRESULT hr = (*pDllGetVersion)(&dvi);
- if (SUCCEEDED(hr))
- dwVersion = MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
- }
- FreeLibrary(hinstDll);
- }
- return dwVersion;
-}
-
-#endif
-
-bool g_LVN_ITEMACTIVATE_Support = true;
-
-static const wchar_t * const kUnknownExceptionMessage = L"ERROR: Unknown Error!";
-
-void ErrorMessageForHRESULT(HRESULT res)
-{
- ShowErrorMessage(HResultToMessage(res));
-}
-
-int APIENTRY WinMain2()
-{
- // OleInitialize is required for ProgressBar in TaskBar.
- #ifndef UNDER_CE
- OleInitialize(NULL);
- #endif
-
- #ifndef UNDER_CE
- g_ComCtl32Version = ::GetDllVersion(TEXT("comctl32.dll"));
- g_LVN_ITEMACTIVATE_Support = (g_ComCtl32Version >= MAKELONG(71, 4));
- #endif
-
- UString password;
- bool assumeYes = false;
- bool outputFolderDefined = false;
- FString outputFolder;
- UStringVector commandStrings;
- NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
-
- #ifndef UNDER_CE
- if (commandStrings.Size() > 0)
- commandStrings.Delete(0);
- #endif
-
- FOR_VECTOR (i, commandStrings)
- {
- const UString &s = commandStrings[i];
- if (s.Len() > 1 && s[0] == '-')
- {
- wchar_t c = MyCharLower_Ascii(s[1]);
- if (c == 'y')
- {
- assumeYes = true;
- if (s.Len() != 2)
- {
- ShowErrorMessage(L"Bad command");
- return 1;
- }
- }
- else if (c == 'o')
- {
- outputFolder = us2fs(s.Ptr(2));
- NName::NormalizeDirPathPrefix(outputFolder);
- outputFolderDefined = !outputFolder.IsEmpty();
- }
- else if (c == 'p')
- {
- password = s.Ptr(2);
- }
- }
- }
-
- FString path;
- NDLL::MyGetModuleFileName(path);
-
- FString fullPath;
- if (!MyGetFullPathName(path, fullPath))
- {
- ShowErrorMessage(L"Error 1329484");
- return 1;
- }
-
- CCodecs *codecs = new CCodecs;
- CMyComPtr<IUnknown> compressCodecsInfo = codecs;
- HRESULT result = codecs->Load();
- if (result != S_OK)
- {
- ErrorMessageForHRESULT(result);
- return 1;
- }
-
- // COpenCallbackGUI openCallback;
-
- // openCallback.PasswordIsDefined = !password.IsEmpty();
- // openCallback.Password = password;
-
- CExtractCallbackImp *ecs = new CExtractCallbackImp;
- CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
- ecs->Init();
-
- #ifndef _NO_CRYPTO
- ecs->PasswordIsDefined = !password.IsEmpty();
- ecs->Password = password;
- #endif
-
- CExtractOptions eo;
-
- FString dirPrefix;
- if (!GetOnlyDirPrefix(path, dirPrefix))
- {
- ShowErrorMessage(L"Error 1329485");
- return 1;
- }
-
- eo.OutputDir = outputFolderDefined ? outputFolder : dirPrefix;
- eo.YesToAll = assumeYes;
- eo.OverwriteMode = assumeYes ?
- NExtract::NOverwriteMode::kOverwrite :
- NExtract::NOverwriteMode::kAsk;
- eo.PathMode = NExtract::NPathMode::kFullPaths;
- eo.TestMode = false;
-
- UStringVector v1, v2;
- v1.Add(fs2us(fullPath));
- v2.Add(fs2us(fullPath));
- NWildcard::CCensorNode wildcardCensor;
- wildcardCensor.AddItem(true, L"*", true, true, true, true);
-
- bool messageWasDisplayed = false;
- result = ExtractGUI(codecs,
- CObjectVector<COpenType>(), CIntVector(),
- v1, v2,
- wildcardCensor, eo, (assumeYes ? false: true), messageWasDisplayed, ecs);
-
- if (result == S_OK)
- {
- if (!ecs->IsOK())
- return NExitCode::kFatalError;
- return 0;
- }
- if (result == E_ABORT)
- return NExitCode::kUserBreak;
- if (!messageWasDisplayed)
- {
- if (result == S_FALSE)
- ShowErrorMessage(L"Error in archive");
- else
- ErrorMessageForHRESULT(result);
- }
- if (result == E_OUTOFMEMORY)
- return NExitCode::kMemoryError;
- return NExitCode::kFatalError;
-}
-
-#define NT_CHECK_FAIL_ACTION ShowErrorMessage(L"Unsupported Windows version"); return NExitCode::kFatalError;
-
-int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
- #ifdef UNDER_CE
- LPWSTR
- #else
- LPSTR
- #endif
- /* lpCmdLine */, int /* nCmdShow */)
-{
- g_hInstance = (HINSTANCE)hInstance;
-
- NT_CHECK
-
- try
- {
- #ifdef _WIN32
- LoadSecurityDlls();
- #endif
-
- return WinMain2();
- }
- catch(const CNewException &)
- {
- ErrorMessageForHRESULT(E_OUTOFMEMORY);
- return NExitCode::kMemoryError;
- }
- catch(...)
- {
- ShowErrorMessage(kUnknownExceptionMessage);
- return NExitCode::kFatalError;
- }
-}
+// Main.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlwapi.h>
+#else
+#include <Shlwapi.h>
+#endif
+
+#include "../../../../C/DllSecur.h"
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "../../ICoder.h"
+#include "../../IPassword.h"
+#include "../../Archive/IArchive.h"
+#include "../../UI/Common/Extract.h"
+#include "../../UI/Common/ExitCode.h"
+#include "../../UI/Explorer/MyMessages.h"
+#include "../../UI/FileManager/MyWindowsNew.h"
+#include "../../UI/GUI/ExtractGUI.h"
+#include "../../UI/GUI/ExtractRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance;
+
+#ifndef UNDER_CE
+
+static
+DWORD g_ComCtl32Version;
+
+static DWORD GetDllVersion(LPCTSTR dllName)
+{
+ DWORD dwVersion = 0;
+ const HINSTANCE hinstDll = LoadLibrary(dllName);
+ if (hinstDll)
+ {
+ const
+ DLLGETVERSIONPROC func_DllGetVersion = Z7_GET_PROC_ADDRESS(
+ DLLGETVERSIONPROC, hinstDll, "DllGetVersion");
+ if (func_DllGetVersion)
+ {
+ DLLVERSIONINFO dvi;
+ ZeroMemory(&dvi, sizeof(dvi));
+ dvi.cbSize = sizeof(dvi);
+ const HRESULT hr = func_DllGetVersion(&dvi);
+ if (SUCCEEDED(hr))
+ dwVersion = (DWORD)MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
+ }
+ FreeLibrary(hinstDll);
+ }
+ return dwVersion;
+}
+
+#endif
+
+extern
+bool g_LVN_ITEMACTIVATE_Support;
+bool g_LVN_ITEMACTIVATE_Support = true;
+
+static const wchar_t * const kUnknownExceptionMessage = L"ERROR: Unknown Error!";
+
+static void ErrorMessageForHRESULT(HRESULT res)
+{
+ ShowErrorMessage(HResultToMessage(res));
+}
+
+static int APIENTRY WinMain2()
+{
+ // OleInitialize is required for ProgressBar in TaskBar.
+ #ifndef UNDER_CE
+ OleInitialize(NULL);
+ #endif
+
+ #ifndef UNDER_CE
+ g_ComCtl32Version = ::GetDllVersion(TEXT("comctl32.dll"));
+ g_LVN_ITEMACTIVATE_Support = (g_ComCtl32Version >= MAKELONG(71, 4));
+ #endif
+
+ UString password;
+ bool assumeYes = false;
+ bool outputFolderDefined = false;
+ FString outputFolder;
+ UStringVector commandStrings;
+ NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
+
+ #ifndef UNDER_CE
+ if (commandStrings.Size() > 0)
+ commandStrings.Delete(0);
+ #endif
+
+ FOR_VECTOR (i, commandStrings)
+ {
+ const UString &s = commandStrings[i];
+ if (s.Len() > 1 && s[0] == '-')
+ {
+ const wchar_t c = MyCharLower_Ascii(s[1]);
+ if (c == 'y')
+ {
+ assumeYes = true;
+ if (s.Len() != 2)
+ {
+ ShowErrorMessage(L"Bad command");
+ return 1;
+ }
+ }
+ else if (c == 'o')
+ {
+ outputFolder = us2fs(s.Ptr(2));
+ NName::NormalizeDirPathPrefix(outputFolder);
+ outputFolderDefined = !outputFolder.IsEmpty();
+ }
+ else if (c == 'p')
+ {
+ password = s.Ptr(2);
+ }
+ }
+ }
+
+ FString path;
+ NDLL::MyGetModuleFileName(path);
+
+ FString fullPath;
+ if (!MyGetFullPathName(path, fullPath))
+ {
+ ShowErrorMessage(L"Error 1329484");
+ return 1;
+ }
+
+ CCodecs *codecs = new CCodecs;
+ CMyComPtr<IUnknown> compressCodecsInfo = codecs;
+ HRESULT result = codecs->Load();
+ if (result != S_OK)
+ {
+ ErrorMessageForHRESULT(result);
+ return 1;
+ }
+
+ // COpenCallbackGUI openCallback;
+
+ // openCallback.PasswordIsDefined = !password.IsEmpty();
+ // openCallback.Password = password;
+
+ CExtractCallbackImp *ecs = new CExtractCallbackImp;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
+ ecs->Init();
+
+ #ifndef Z7_NO_CRYPTO
+ ecs->PasswordIsDefined = !password.IsEmpty();
+ ecs->Password = password;
+ #endif
+
+ CExtractOptions eo;
+
+ FString dirPrefix;
+ if (!GetOnlyDirPrefix(path, dirPrefix))
+ {
+ ShowErrorMessage(L"Error 1329485");
+ return 1;
+ }
+
+ eo.OutputDir = outputFolderDefined ? outputFolder : dirPrefix;
+ eo.YesToAll = assumeYes;
+ eo.OverwriteMode = assumeYes ?
+ NExtract::NOverwriteMode::kOverwrite :
+ NExtract::NOverwriteMode::kAsk;
+ eo.PathMode = NExtract::NPathMode::kFullPaths;
+ eo.TestMode = false;
+
+ UStringVector v1, v2;
+ v1.Add(fs2us(fullPath));
+ v2.Add(fs2us(fullPath));
+ NWildcard::CCensorNode wildcardCensor;
+ wildcardCensor.Add_Wildcard();
+
+ bool messageWasDisplayed = false;
+ result = ExtractGUI(codecs,
+ CObjectVector<COpenType>(), CIntVector(),
+ v1, v2,
+ wildcardCensor, eo, (assumeYes ? false: true), messageWasDisplayed, ecs);
+
+ if (result == S_OK)
+ {
+ if (!ecs->IsOK())
+ return NExitCode::kFatalError;
+ return 0;
+ }
+ if (result == E_ABORT)
+ return NExitCode::kUserBreak;
+ if (!messageWasDisplayed)
+ {
+ if (result == S_FALSE)
+ ShowErrorMessage(L"Error in archive");
+ else
+ ErrorMessageForHRESULT(result);
+ }
+ if (result == E_OUTOFMEMORY)
+ return NExitCode::kMemoryError;
+ return NExitCode::kFatalError;
+}
+
+#if defined(_WIN32) && defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION ShowErrorMessage(L"Unsupported Windows version"); return NExitCode::kFatalError;
+#endif
+
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ /* lpCmdLine */, int /* nCmdShow */)
+{
+ g_hInstance = (HINSTANCE)hInstance;
+
+ NT_CHECK
+
+ try
+ {
+ #ifdef _WIN32
+ LoadSecurityDlls();
+ #endif
+
+ return WinMain2();
+ }
+ catch(const CNewException &)
+ {
+ ErrorMessageForHRESULT(E_OUTOFMEMORY);
+ return NExitCode::kMemoryError;
+ }
+ catch(...)
+ {
+ ShowErrorMessage(kUnknownExceptionMessage);
+ return NExitCode::kFatalError;
+ }
+}
diff --git a/CPP/7zip/Bundles/SFXWin/StdAfx.cpp b/CPP/7zip/Bundles/SFXWin/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/Bundles/SFXWin/StdAfx.cpp
+++ b/CPP/7zip/Bundles/SFXWin/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Bundles/SFXWin/StdAfx.h b/CPP/7zip/Bundles/SFXWin/StdAfx.h
index f263ecb..4f27255 100644
--- a/CPP/7zip/Bundles/SFXWin/StdAfx.h
+++ b/CPP/7zip/Bundles/SFXWin/StdAfx.h
@@ -1,14 +1,6 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#include <commctrl.h>
-#include <ShlObj.h>
-
-// #define printf(x) NO_PRINTF_(x)
-// #define sprintf(x) NO_SPRINTF_(x)
-
-#endif
+// StdAfx.h
+
+#if _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../UI/FileManager/StdAfx.h"
diff --git a/CPP/7zip/Bundles/SFXWin/makefile b/CPP/7zip/Bundles/SFXWin/makefile
index 21a67dd..69a8553 100644
--- a/CPP/7zip/Bundles/SFXWin/makefile
+++ b/CPP/7zip/Bundles/SFXWin/makefile
@@ -1,153 +1,156 @@
-PROG = 7z.sfx
-MY_FIXED = 1
-
-CFLAGS = $(CFLAGS) \
- -DNO_REGISTRY \
- -DEXTRACT_ONLY \
- -DNO_READ_FROM_CODER \
- -D_SFX \
-
-!IFDEF UNDER_CE
-LIBS = $(LIBS) ceshell.lib Commctrl.lib
-!ELSE
-LIBS = $(LIBS) comctl32.lib comdlg32.lib
-!ENDIF
-
-CURRENT_OBJS = \
- $O\SfxWin.obj \
-
-GUI_OBJS = \
- $O\ExtractDialog.obj \
- $O\ExtractGUI.obj \
-
-COMMON_OBJS = \
- $O\CRC.obj \
- $O\CommandLineParser.obj \
- $O\IntToString.obj \
- $O\NewHandler.obj \
- $O\MyString.obj \
- $O\StringConvert.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
-
-WIN_OBJS = \
- $O\CommonDialog.obj \
- $O\DLL.obj \
- $O\ErrorMsg.obj \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileName.obj \
- $O\PropVariant.obj \
- $O\PropVariantConv.obj \
- $O\ResourceString.obj \
- $O\Shell.obj \
- $O\Synchronization.obj \
- $O\System.obj \
- $O\Window.obj \
-
-WIN_CTRL_OBJS = \
- $O\ComboBox.obj \
- $O\Dialog.obj \
- $O\ListView.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\CWrappers.obj \
- $O\FilePathAutoRename.obj \
- $O\FileStreams.obj \
- $O\InBuffer.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\OutBuffer.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamBinder.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\VirtThread.obj \
-
-UI_COMMON_OBJS = \
- $O\ArchiveExtractCallback.obj \
- $O\ArchiveOpenCallback.obj \
- $O\DefaultName.obj \
- $O\Extract.obj \
- $O\ExtractingFilePath.obj \
- $O\LoadCodecs.obj \
- $O\OpenArchive.obj \
-
-EXPLORER_OBJS = \
- $O\MyMessages.obj \
-
-FM_OBJS = \
- $O\BrowseDialog.obj \
- $O\ComboDialog.obj \
- $O\ExtractCallback.obj \
- $O\FormatUtils.obj \
- $O\OverwriteDialog.obj \
- $O\PasswordDialog.obj \
- $O\ProgressDialog2.obj \
- $O\PropertyName.obj \
- $O\SysIconUtils.obj \
-
-AR_OBJS = \
- $O\SplitHandler.obj \
-
-AR_COMMON_OBJS = \
- $O\CoderMixer2.obj \
- $O\ItemNameUtils.obj \
- $O\MultiStream.obj \
- $O\OutStreamWithCRC.obj \
-
-7Z_OBJS = \
- $O\7zDecode.obj \
- $O\7zExtract.obj \
- $O\7zHandler.obj \
- $O\7zIn.obj \
- $O\7zRegister.obj \
-
-COMPRESS_OBJS = \
- $O\Bcj2Coder.obj \
- $O\Bcj2Register.obj \
- $O\BcjCoder.obj \
- $O\BcjRegister.obj \
- $O\BranchMisc.obj \
- $O\BranchRegister.obj \
- $O\CopyCoder.obj \
- $O\CopyRegister.obj \
- $O\DeltaFilter.obj \
- $O\Lzma2Decoder.obj \
- $O\Lzma2Register.obj \
- $O\LzmaDecoder.obj \
- $O\LzmaRegister.obj \
- $O\PpmdDecoder.obj \
- $O\PpmdRegister.obj \
-
-CRYPTO_OBJS = \
- $O\7zAes.obj \
- $O\7zAesRegister.obj \
- $O\MyAes.obj \
-
-C_OBJS = \
- $O\Alloc.obj \
- $O\Bcj2.obj \
- $O\Bra.obj \
- $O\Bra86.obj \
- $O\BraIA64.obj \
- $O\CpuArch.obj \
- $O\Delta.obj \
- $O\DllSecur.obj \
- $O\Lzma2Dec.obj \
- $O\Lzma2DecMt.obj \
- $O\LzmaDec.obj \
- $O\MtDec.obj \
- $O\Ppmd7.obj \
- $O\Ppmd7Dec.obj \
- $O\Sha256.obj \
- $O\Threads.obj \
-
-!include "../../Aes.mak"
-!include "../../Crc.mak"
-!include "../../LzmaDec.mak"
-
-!include "../../7zip.mak"
+PROG = 7z.sfx
+MY_FIXED = 1
+
+CFLAGS = $(CFLAGS) \
+ -DZ7_NO_REGISTRY \
+ -DZ7_EXTRACT_ONLY \
+ -DZ7_NO_READ_FROM_CODER \
+ -DZ7_SFX \
+
+!IFDEF UNDER_CE
+LIBS = $(LIBS) ceshell.lib Commctrl.lib
+!ELSE
+LIBS = $(LIBS) comctl32.lib comdlg32.lib
+!ENDIF
+
+CURRENT_OBJS = \
+ $O\SfxWin.obj \
+
+GUI_OBJS = \
+ $O\ExtractDialog.obj \
+ $O\ExtractGUI.obj \
+
+COMMON_OBJS = \
+ $O\CRC.obj \
+ $O\CommandLineParser.obj \
+ $O\IntToString.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\Clipboard.obj \
+ $O\CommonDialog.obj \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\MemoryGlobal.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\ResourceString.obj \
+ $O\Shell.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\Window.obj \
+
+WIN_CTRL_OBJS = \
+ $O\ComboBox.obj \
+ $O\Dialog.obj \
+ $O\ListView.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\CWrappers.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\InBuffer.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\OutBuffer.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamBinder.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\VirtThread.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\DefaultName.obj \
+ $O\Extract.obj \
+ $O\ExtractingFilePath.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+
+EXPLORER_OBJS = \
+ $O\MyMessages.obj \
+
+FM_OBJS = \
+ $O\BrowseDialog.obj \
+ $O\ComboDialog.obj \
+ $O\ExtractCallback.obj \
+ $O\FormatUtils.obj \
+ $O\OverwriteDialog.obj \
+ $O\PasswordDialog.obj \
+ $O\ProgressDialog2.obj \
+ $O\PropertyName.obj \
+ $O\SysIconUtils.obj \
+
+AR_OBJS = \
+ $O\SplitHandler.obj \
+
+AR_COMMON_OBJS = \
+ $O\CoderMixer2.obj \
+ $O\ItemNameUtils.obj \
+ $O\MultiStream.obj \
+ $O\OutStreamWithCRC.obj \
+
+7Z_OBJS = \
+ $O\7zDecode.obj \
+ $O\7zExtract.obj \
+ $O\7zHandler.obj \
+ $O\7zIn.obj \
+ $O\7zRegister.obj \
+
+COMPRESS_OBJS = \
+ $O\Bcj2Coder.obj \
+ $O\Bcj2Register.obj \
+ $O\BcjCoder.obj \
+ $O\BcjRegister.obj \
+ $O\BranchMisc.obj \
+ $O\BranchRegister.obj \
+ $O\CopyCoder.obj \
+ $O\CopyRegister.obj \
+ $O\DeltaFilter.obj \
+ $O\Lzma2Decoder.obj \
+ $O\Lzma2Register.obj \
+ $O\LzmaDecoder.obj \
+ $O\LzmaRegister.obj \
+ $O\PpmdDecoder.obj \
+ $O\PpmdRegister.obj \
+
+CRYPTO_OBJS = \
+ $O\7zAes.obj \
+ $O\7zAesRegister.obj \
+ $O\MyAes.obj \
+
+C_OBJS = \
+ $O\7zStream.obj \
+ $O\Alloc.obj \
+ $O\Bcj2.obj \
+ $O\Bra.obj \
+ $O\Bra86.obj \
+ $O\BraIA64.obj \
+ $O\CpuArch.obj \
+ $O\Delta.obj \
+ $O\DllSecur.obj \
+ $O\Lzma2Dec.obj \
+ $O\Lzma2DecMt.obj \
+ $O\LzmaDec.obj \
+ $O\MtDec.obj \
+ $O\Ppmd7.obj \
+ $O\Ppmd7Dec.obj \
+ $O\Threads.obj \
+
+!include "../../Aes.mak"
+!include "../../Crc.mak"
+!include "../../LzmaDec.mak"
+!include "../../Sha256.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/Bundles/SFXWin/resource.h b/CPP/7zip/Bundles/SFXWin/resource.h
index d9fae1b..30fe203 100644
--- a/CPP/7zip/Bundles/SFXWin/resource.h
+++ b/CPP/7zip/Bundles/SFXWin/resource.h
@@ -1 +1 @@
-#define IDI_ICON 1
+#define IDI_ICON 1
diff --git a/CPP/7zip/Bundles/SFXWin/resource.rc b/CPP/7zip/Bundles/SFXWin/resource.rc
index 3b69b35..3b2217a 100644
--- a/CPP/7zip/Bundles/SFXWin/resource.rc
+++ b/CPP/7zip/Bundles/SFXWin/resource.rc
@@ -1,50 +1,55 @@
-#include "../../MyVersionInfo.rc"
-#include "../../GuiCommon.rc"
-#include "../../UI/GUI/ExtractDialogRes.h"
-#include "../../UI/FileManager/PropertyNameRes.h"
-
-#include "resource.h"
-
-MY_VERSION_INFO_APP("7z SFX", "7z.sfx")
-
-#define xc 240
-#define yc 64
-
-IDI_ICON ICON "7z.ico"
-
-IDD_EXTRACT DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "7-Zip self-extracting archive"
-BEGIN
- LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc, 8
- EDITTEXT IDC_EXTRACT_PATH, m, 21, xc - bxsDots - 12, 14, ES_AUTOHSCROLL
- PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, 20, bxsDots, bys, WS_GROUP
- DEFPUSHBUTTON "Extract", IDOK, bx2, by, bxs, bys, WS_GROUP
- PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
-END
-
-#ifdef UNDER_CE
-
-#undef xc
-#define xc 144
-
-IDD_EXTRACT_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "7-Zip self-extracting archive"
-BEGIN
- LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc - bxsDots - 12, 8
- EDITTEXT IDC_EXTRACT_PATH, m, m + bys + 4, xc, 14, ES_AUTOHSCROLL
- PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, m, bxsDots, bys, WS_GROUP
- DEFPUSHBUTTON "Extract", IDOK, bx2, by, bxs, bys, WS_GROUP
- PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
-END
-
-#endif
-
-#include "../../UI/FileManager/OverwriteDialog.rc"
-#include "../../UI/FileManager/PasswordDialog.rc"
-#include "../../UI/FileManager/ProgressDialog2.rc"
-#include "../../UI/GUI/Extract.rc"
-
-STRINGTABLE DISCARDABLE
-BEGIN
- IDS_PROP_MTIME "Modified"
-END
+#include "../../MyVersionInfo.rc"
+#include "../../GuiCommon.rc"
+#include "../../UI/GUI/ExtractDialogRes.h"
+#include "../../UI/FileManager/PropertyNameRes.h"
+
+#include "resource.h"
+
+MY_VERSION_INFO_APP("7z SFX", "7z.sfx")
+
+#define xc 240
+#define yc 64
+
+IDI_ICON ICON "7z.ico"
+
+IDD_EXTRACT DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "7-Zip self-extracting archive"
+BEGIN
+ LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc, 8
+ EDITTEXT IDC_EXTRACT_PATH, m, 21, xc - bxsDots - 12, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, 20, bxsDots, bys, WS_GROUP
+ DEFPUSHBUTTON "Extract", IDOK, bx2, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+END
+
+#ifdef UNDER_CE
+
+#undef xc
+#define xc 144
+
+IDD_EXTRACT_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "7-Zip self-extracting archive"
+BEGIN
+ LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc - bxsDots - 12, 8
+ EDITTEXT IDC_EXTRACT_PATH, m, m + bys + 4, xc, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, m, bxsDots, bys, WS_GROUP
+ DEFPUSHBUTTON "Extract", IDOK, bx2, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+END
+
+#endif
+
+#include "../../UI/FileManager/OverwriteDialog.rc"
+#include "../../UI/FileManager/PasswordDialog.rc"
+#include "../../UI/FileManager/ProgressDialog2.rc"
+#include "../../UI/GUI/Extract.rc"
+
+STRINGTABLE DISCARDABLE
+BEGIN
+ IDS_PROP_MTIME "Modified"
+END
+
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "../../UI/GUI/7zG.exe.manifest"
+#endif
diff --git a/CPP/7zip/Bundles/makefile b/CPP/7zip/Bundles/makefile
new file mode 100644
index 0000000..0651da5
--- /dev/null
+++ b/CPP/7zip/Bundles/makefile
@@ -0,0 +1,19 @@
+DIRS = \
+ Alone\~ \
+ Alone2\~ \
+ Alone7z\~ \
+ Fm\~ \
+ Format7z\~ \
+ Format7zF\~ \
+ Format7zR\~ \
+ Format7zExtract\~ \
+ Format7zExtractR\~ \
+ LzmaCon\~ \
+ SFXCon\~ \
+ SFXSetup\~ \
+ SFXWin\~ \
+
+all: $(DIRS)
+
+$(DIRS):
+!include "../SubBuild.mak"
diff --git a/CPP/7zip/Common/CWrappers.cpp b/CPP/7zip/Common/CWrappers.cpp
index e726dad..346774e 100644
--- a/CPP/7zip/Common/CWrappers.cpp
+++ b/CPP/7zip/Common/CWrappers.cpp
@@ -1,250 +1,354 @@
-// CWrappers.h
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "CWrappers.h"
-
-#include "StreamUtils.h"
-
-SRes HRESULT_To_SRes(HRESULT res, SRes defaultRes) throw()
-{
- switch (res)
- {
- case S_OK: return SZ_OK;
- case E_OUTOFMEMORY: return SZ_ERROR_MEM;
- case E_INVALIDARG: return SZ_ERROR_PARAM;
- case E_ABORT: return SZ_ERROR_PROGRESS;
- case S_FALSE: return SZ_ERROR_DATA;
- case E_NOTIMPL: return SZ_ERROR_UNSUPPORTED;
- }
- return defaultRes;
-}
-
-
-HRESULT SResToHRESULT(SRes res) throw()
-{
- switch (res)
- {
- case SZ_OK: return S_OK;
-
- case SZ_ERROR_DATA:
- case SZ_ERROR_CRC:
- case SZ_ERROR_INPUT_EOF:
- return S_FALSE;
-
- case SZ_ERROR_MEM: return E_OUTOFMEMORY;
- case SZ_ERROR_PARAM: return E_INVALIDARG;
- case SZ_ERROR_PROGRESS: return E_ABORT;
- case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
- // case SZ_ERROR_OUTPUT_EOF:
- // case SZ_ERROR_READ:
- // case SZ_ERROR_WRITE:
- // case SZ_ERROR_THREAD:
- // case SZ_ERROR_ARCHIVE:
- // case SZ_ERROR_NO_ARCHIVE:
- // return E_FAIL;
- }
- if (res < 0)
- return res;
- return E_FAIL;
-}
-
-
-#define PROGRESS_UNKNOWN_VALUE ((UInt64)(Int64)-1)
-
-#define CONVERT_PR_VAL(x) (x == PROGRESS_UNKNOWN_VALUE ? NULL : &x)
-
-
-static SRes CompressProgress(const ICompressProgress *pp, UInt64 inSize, UInt64 outSize) throw()
-{
- CCompressProgressWrap *p = CONTAINER_FROM_VTBL(pp, CCompressProgressWrap, vt);
- p->Res = p->Progress->SetRatioInfo(CONVERT_PR_VAL(inSize), CONVERT_PR_VAL(outSize));
- return HRESULT_To_SRes(p->Res, SZ_ERROR_PROGRESS);
-}
-
-void CCompressProgressWrap::Init(ICompressProgressInfo *progress) throw()
-{
- vt.Progress = CompressProgress;
- Progress = progress;
- Res = SZ_OK;
-}
-
-static const UInt32 kStreamStepSize = (UInt32)1 << 31;
-
-static SRes MyRead(const ISeqInStream *pp, void *data, size_t *size) throw()
-{
- CSeqInStreamWrap *p = CONTAINER_FROM_VTBL(pp, CSeqInStreamWrap, vt);
- UInt32 curSize = ((*size < kStreamStepSize) ? (UInt32)*size : kStreamStepSize);
- p->Res = (p->Stream->Read(data, curSize, &curSize));
- *size = curSize;
- p->Processed += curSize;
- if (p->Res == S_OK)
- return SZ_OK;
- return HRESULT_To_SRes(p->Res, SZ_ERROR_READ);
-}
-
-static size_t MyWrite(const ISeqOutStream *pp, const void *data, size_t size) throw()
-{
- CSeqOutStreamWrap *p = CONTAINER_FROM_VTBL(pp, CSeqOutStreamWrap, vt);
- if (p->Stream)
- {
- p->Res = WriteStream(p->Stream, data, size);
- if (p->Res != 0)
- return 0;
- }
- else
- p->Res = S_OK;
- p->Processed += size;
- return size;
-}
-
-
-void CSeqInStreamWrap::Init(ISequentialInStream *stream) throw()
-{
- vt.Read = MyRead;
- Stream = stream;
- Processed = 0;
- Res = S_OK;
-}
-
-void CSeqOutStreamWrap::Init(ISequentialOutStream *stream) throw()
-{
- vt.Write = MyWrite;
- Stream = stream;
- Res = SZ_OK;
- Processed = 0;
-}
-
-
-static SRes InStreamWrap_Read(const ISeekInStream *pp, void *data, size_t *size) throw()
-{
- CSeekInStreamWrap *p = CONTAINER_FROM_VTBL(pp, CSeekInStreamWrap, vt);
- UInt32 curSize = ((*size < kStreamStepSize) ? (UInt32)*size : kStreamStepSize);
- p->Res = p->Stream->Read(data, curSize, &curSize);
- *size = curSize;
- return (p->Res == S_OK) ? SZ_OK : SZ_ERROR_READ;
-}
-
-static SRes InStreamWrap_Seek(const ISeekInStream *pp, Int64 *offset, ESzSeek origin) throw()
-{
- CSeekInStreamWrap *p = CONTAINER_FROM_VTBL(pp, CSeekInStreamWrap, vt);
- UInt32 moveMethod;
- switch (origin)
- {
- case SZ_SEEK_SET: moveMethod = STREAM_SEEK_SET; break;
- case SZ_SEEK_CUR: moveMethod = STREAM_SEEK_CUR; break;
- case SZ_SEEK_END: moveMethod = STREAM_SEEK_END; break;
- default: return SZ_ERROR_PARAM;
- }
- UInt64 newPosition;
- p->Res = p->Stream->Seek(*offset, moveMethod, &newPosition);
- *offset = (Int64)newPosition;
- return (p->Res == S_OK) ? SZ_OK : SZ_ERROR_READ;
-}
-
-void CSeekInStreamWrap::Init(IInStream *stream) throw()
-{
- Stream = stream;
- vt.Read = InStreamWrap_Read;
- vt.Seek = InStreamWrap_Seek;
- Res = S_OK;
-}
-
-
-/* ---------- CByteInBufWrap ---------- */
-
-void CByteInBufWrap::Free() throw()
-{
- ::MidFree(Buf);
- Buf = 0;
-}
-
-bool CByteInBufWrap::Alloc(UInt32 size) throw()
-{
- if (Buf == 0 || size != Size)
- {
- Free();
- Lim = Cur = Buf = (Byte *)::MidAlloc((size_t)size);
- Size = size;
- }
- return (Buf != 0);
-}
-
-Byte CByteInBufWrap::ReadByteFromNewBlock() throw()
-{
- if (Res == S_OK)
- {
- UInt32 avail;
- Processed += (Cur - Buf);
- Res = Stream->Read(Buf, Size, &avail);
- Cur = Buf;
- Lim = Buf + avail;
- if (avail != 0)
- return *Cur++;
- }
- Extra = true;
- return 0;
-}
-
-static Byte Wrap_ReadByte(const IByteIn *pp) throw()
-{
- CByteInBufWrap *p = CONTAINER_FROM_VTBL_CLS(pp, CByteInBufWrap, vt);
- if (p->Cur != p->Lim)
- return *p->Cur++;
- return p->ReadByteFromNewBlock();
-}
-
-CByteInBufWrap::CByteInBufWrap(): Buf(0)
-{
- vt.Read = Wrap_ReadByte;
-}
-
-
-/* ---------- CByteOutBufWrap ---------- */
-
-void CByteOutBufWrap::Free() throw()
-{
- ::MidFree(Buf);
- Buf = 0;
-}
-
-bool CByteOutBufWrap::Alloc(size_t size) throw()
-{
- if (Buf == 0 || size != Size)
- {
- Free();
- Buf = (Byte *)::MidAlloc(size);
- Size = size;
- }
- return (Buf != 0);
-}
-
-HRESULT CByteOutBufWrap::Flush() throw()
-{
- if (Res == S_OK)
- {
- size_t size = (Cur - Buf);
- Res = WriteStream(Stream, Buf, size);
- if (Res == S_OK)
- Processed += size;
- Cur = Buf;
- }
- return Res;
-}
-
-static void Wrap_WriteByte(const IByteOut *pp, Byte b) throw()
-{
- CByteOutBufWrap *p = CONTAINER_FROM_VTBL_CLS(pp, CByteOutBufWrap, vt);
- Byte *dest = p->Cur;
- *dest = b;
- p->Cur = ++dest;
- if (dest == p->Lim)
- p->Flush();
-}
-
-CByteOutBufWrap::CByteOutBufWrap() throw(): Buf(0)
-{
- vt.Write = Wrap_WriteByte;
-}
+// CWrappers.c
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "CWrappers.h"
+
+#include "StreamUtils.h"
+
+SRes HRESULT_To_SRes(HRESULT res, SRes defaultRes) throw()
+{
+ switch (res)
+ {
+ case S_OK: return SZ_OK;
+ case E_OUTOFMEMORY: return SZ_ERROR_MEM;
+ case E_INVALIDARG: return SZ_ERROR_PARAM;
+ case E_ABORT: return SZ_ERROR_PROGRESS;
+ case S_FALSE: return SZ_ERROR_DATA;
+ case E_NOTIMPL: return SZ_ERROR_UNSUPPORTED;
+ }
+ return defaultRes;
+}
+
+
+HRESULT SResToHRESULT(SRes res) throw()
+{
+ switch (res)
+ {
+ case SZ_OK: return S_OK;
+
+ case SZ_ERROR_DATA:
+ case SZ_ERROR_CRC:
+ case SZ_ERROR_INPUT_EOF:
+ return S_FALSE;
+
+ case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+ case SZ_ERROR_PARAM: return E_INVALIDARG;
+ case SZ_ERROR_PROGRESS: return E_ABORT;
+ case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
+ // case SZ_ERROR_OUTPUT_EOF:
+ // case SZ_ERROR_READ:
+ // case SZ_ERROR_WRITE:
+ // case SZ_ERROR_THREAD:
+ // case SZ_ERROR_ARCHIVE:
+ // case SZ_ERROR_NO_ARCHIVE:
+ // return E_FAIL;
+ }
+ if (res < 0)
+ return res;
+ return E_FAIL;
+}
+
+
+#define PROGRESS_UNKNOWN_VALUE ((UInt64)(Int64)-1)
+
+#define CONVERT_PR_VAL(x) (x == PROGRESS_UNKNOWN_VALUE ? NULL : &x)
+
+
+static SRes CompressProgress(ICompressProgressPtr pp, UInt64 inSize, UInt64 outSize) throw()
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CCompressProgressWrap)
+ p->Res = p->Progress->SetRatioInfo(CONVERT_PR_VAL(inSize), CONVERT_PR_VAL(outSize));
+ return HRESULT_To_SRes(p->Res, SZ_ERROR_PROGRESS);
+}
+
+void CCompressProgressWrap::Init(ICompressProgressInfo *progress) throw()
+{
+ vt.Progress = CompressProgress;
+ Progress = progress;
+ Res = SZ_OK;
+}
+
+static const UInt32 kStreamStepSize = (UInt32)1 << 31;
+
+static SRes MyRead(ISeqInStreamPtr pp, void *data, size_t *size) throw()
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqInStreamWrap)
+ UInt32 curSize = ((*size < kStreamStepSize) ? (UInt32)*size : kStreamStepSize);
+ p->Res = (p->Stream->Read(data, curSize, &curSize));
+ *size = curSize;
+ p->Processed += curSize;
+ if (p->Res == S_OK)
+ return SZ_OK;
+ return HRESULT_To_SRes(p->Res, SZ_ERROR_READ);
+}
+
+static size_t MyWrite(ISeqOutStreamPtr pp, const void *data, size_t size) throw()
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeqOutStreamWrap)
+ if (p->Stream)
+ {
+ p->Res = WriteStream(p->Stream, data, size);
+ if (p->Res != 0)
+ return 0;
+ }
+ else
+ p->Res = S_OK;
+ p->Processed += size;
+ return size;
+}
+
+
+void CSeqInStreamWrap::Init(ISequentialInStream *stream) throw()
+{
+ vt.Read = MyRead;
+ Stream = stream;
+ Processed = 0;
+ Res = S_OK;
+}
+
+void CSeqOutStreamWrap::Init(ISequentialOutStream *stream) throw()
+{
+ vt.Write = MyWrite;
+ Stream = stream;
+ Res = SZ_OK;
+ Processed = 0;
+}
+
+
+static SRes InStreamWrap_Read(ISeekInStreamPtr pp, void *data, size_t *size) throw()
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeekInStreamWrap)
+ UInt32 curSize = ((*size < kStreamStepSize) ? (UInt32)*size : kStreamStepSize);
+ p->Res = p->Stream->Read(data, curSize, &curSize);
+ *size = curSize;
+ return (p->Res == S_OK) ? SZ_OK : SZ_ERROR_READ;
+}
+
+static SRes InStreamWrap_Seek(ISeekInStreamPtr pp, Int64 *offset, ESzSeek origin) throw()
+{
+ Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CSeekInStreamWrap)
+ UInt32 moveMethod;
+ /* we need (int)origin to eliminate the clang warning:
+ default label in switch which covers all enumeration values
+ [-Wcovered-switch-default */
+ switch ((int)origin)
+ {
+ case SZ_SEEK_SET: moveMethod = STREAM_SEEK_SET; break;
+ case SZ_SEEK_CUR: moveMethod = STREAM_SEEK_CUR; break;
+ case SZ_SEEK_END: moveMethod = STREAM_SEEK_END; break;
+ default: return SZ_ERROR_PARAM;
+ }
+ UInt64 newPosition;
+ p->Res = p->Stream->Seek(*offset, moveMethod, &newPosition);
+ *offset = (Int64)newPosition;
+ return (p->Res == S_OK) ? SZ_OK : SZ_ERROR_READ;
+}
+
+void CSeekInStreamWrap::Init(IInStream *stream) throw()
+{
+ Stream = stream;
+ vt.Read = InStreamWrap_Read;
+ vt.Seek = InStreamWrap_Seek;
+ Res = S_OK;
+}
+
+
+/* ---------- CByteInBufWrap ---------- */
+
+void CByteInBufWrap::Free() throw()
+{
+ ::MidFree(Buf);
+ Buf = NULL;
+}
+
+bool CByteInBufWrap::Alloc(UInt32 size) throw()
+{
+ if (!Buf || size != Size)
+ {
+ Free();
+ Lim = Cur = Buf = (Byte *)::MidAlloc((size_t)size);
+ Size = size;
+ }
+ return (Buf != NULL);
+}
+
+Byte CByteInBufWrap::ReadByteFromNewBlock() throw()
+{
+ if (!Extra && Res == S_OK)
+ {
+ UInt32 avail;
+ Res = Stream->Read(Buf, Size, &avail);
+ Processed += (size_t)(Cur - Buf);
+ Cur = Buf;
+ Lim = Buf + avail;
+ if (avail != 0)
+ return *Cur++;
+ }
+ Extra = true;
+ return 0;
+}
+
+// #pragma GCC diagnostic ignored "-Winvalid-offsetof"
+
+static Byte Wrap_ReadByte(IByteInPtr pp) throw()
+{
+ CByteInBufWrap *p = Z7_CONTAINER_FROM_VTBL_CLS(pp, CByteInBufWrap, vt);
+ // Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CByteInBufWrap)
+ if (p->Cur != p->Lim)
+ return *p->Cur++;
+ return p->ReadByteFromNewBlock();
+}
+
+CByteInBufWrap::CByteInBufWrap() throw(): Buf(NULL)
+{
+ vt.Read = Wrap_ReadByte;
+}
+
+
+
+/* ---------- CByteOutBufWrap ---------- */
+
+/*
+void CLookToSequentialWrap::Free() throw()
+{
+ ::MidFree(BufBase);
+ BufBase = NULL;
+}
+
+bool CLookToSequentialWrap::Alloc(UInt32 size) throw()
+{
+ if (!BufBase || size != Size)
+ {
+ Free();
+ BufBase = (Byte *)::MidAlloc((size_t)size);
+ Size = size;
+ }
+ return (BufBase != NULL);
+}
+*/
+
+/*
+EXTERN_C_BEGIN
+
+void CLookToSequentialWrap_Look(ILookInSeqStreamPtr pp)
+{
+ CLookToSequentialWrap *p = (CLookToSequentialWrap *)pp->Obj;
+
+ if (p->Extra || p->Res != S_OK)
+ return;
+ {
+ UInt32 avail;
+ p->Res = p->Stream->Read(p->BufBase, p->Size, &avail);
+ p->Processed += avail;
+ pp->Buf = p->BufBase;
+ pp->Limit = pp->Buf + avail;
+ if (avail == 0)
+ p->Extra = true;
+ }
+}
+
+EXTERN_C_END
+*/
+
+
+/* ---------- CByteOutBufWrap ---------- */
+
+void CByteOutBufWrap::Free() throw()
+{
+ ::MidFree(Buf);
+ Buf = NULL;
+}
+
+bool CByteOutBufWrap::Alloc(size_t size) throw()
+{
+ if (!Buf || size != Size)
+ {
+ Free();
+ Buf = (Byte *)::MidAlloc(size);
+ Size = size;
+ }
+ return (Buf != NULL);
+}
+
+HRESULT CByteOutBufWrap::Flush() throw()
+{
+ if (Res == S_OK)
+ {
+ const size_t size = (size_t)(Cur - Buf);
+ Res = WriteStream(Stream, Buf, size);
+ if (Res == S_OK)
+ Processed += size;
+ // else throw 11;
+ }
+ Cur = Buf; // reset pointer for later Wrap_WriteByte()
+ return Res;
+}
+
+static void Wrap_WriteByte(IByteOutPtr pp, Byte b) throw()
+{
+ CByteOutBufWrap *p = Z7_CONTAINER_FROM_VTBL_CLS(pp, CByteOutBufWrap, vt);
+ // Z7_CONTAINER_FROM_VTBL_TO_DECL_VAR_pp_vt_p(CByteOutBufWrap)
+ Byte *dest = p->Cur;
+ *dest = b;
+ p->Cur = ++dest;
+ if (dest == p->Lim)
+ p->Flush();
+}
+
+CByteOutBufWrap::CByteOutBufWrap() throw(): Buf(NULL), Size(0)
+{
+ vt.Write = Wrap_WriteByte;
+}
+
+
+/* ---------- CLookOutWrap ---------- */
+
+/*
+void CLookOutWrap::Free() throw()
+{
+ ::MidFree(Buf);
+ Buf = NULL;
+}
+
+bool CLookOutWrap::Alloc(size_t size) throw()
+{
+ if (!Buf || size != Size)
+ {
+ Free();
+ Buf = (Byte *)::MidAlloc(size);
+ Size = size;
+ }
+ return (Buf != NULL);
+}
+
+static size_t LookOutWrap_GetOutBuf(ILookOutStreamPtr pp, void **buf) throw()
+{
+ CLookOutWrap *p = Z7_CONTAINER_FROM_VTBL_CLS(pp, CLookOutWrap, vt);
+ *buf = p->Buf;
+ return p->Size;
+}
+
+static size_t LookOutWrap_Write(ILookOutStreamPtr pp, size_t size) throw()
+{
+ CLookOutWrap *p = Z7_CONTAINER_FROM_VTBL_CLS(pp, CLookOutWrap, vt);
+ if (p->Res == S_OK && size != 0)
+ {
+ p->Res = WriteStream(p->Stream, p->Buf, size);
+ if (p->Res == S_OK)
+ {
+ p->Processed += size;
+ return size;
+ }
+ }
+ return 0;
+}
+
+CLookOutWrap::CLookOutWrap() throw(): Buf(NULL), Size(0)
+{
+ vt.GetOutBuf = LookOutWrap_GetOutBuf;
+ vt.Write = LookOutWrap_Write;
+}
+*/
diff --git a/CPP/7zip/Common/CWrappers.h b/CPP/7zip/Common/CWrappers.h
index f93c98a..6c10a5c 100644
--- a/CPP/7zip/Common/CWrappers.h
+++ b/CPP/7zip/Common/CWrappers.h
@@ -1,120 +1,182 @@
-// CWrappers.h
-
-#ifndef __C_WRAPPERS_H
-#define __C_WRAPPERS_H
-
-#include "../ICoder.h"
-#include "../../Common/MyCom.h"
-
-SRes HRESULT_To_SRes(HRESULT res, SRes defaultRes) throw();
-HRESULT SResToHRESULT(SRes res) throw();
-
-struct CCompressProgressWrap
-{
- ICompressProgress vt;
- ICompressProgressInfo *Progress;
- HRESULT Res;
-
- void Init(ICompressProgressInfo *progress) throw();
-};
-
-
-struct CSeqInStreamWrap
-{
- ISeqInStream vt;
- ISequentialInStream *Stream;
- HRESULT Res;
- UInt64 Processed;
-
- void Init(ISequentialInStream *stream) throw();
-};
-
-
-struct CSeekInStreamWrap
-{
- ISeekInStream vt;
- IInStream *Stream;
- HRESULT Res;
-
- void Init(IInStream *stream) throw();
-};
-
-
-struct CSeqOutStreamWrap
-{
- ISeqOutStream vt;
- ISequentialOutStream *Stream;
- HRESULT Res;
- UInt64 Processed;
-
- void Init(ISequentialOutStream *stream) throw();
-};
-
-
-struct CByteInBufWrap
-{
- IByteIn vt;
- const Byte *Cur;
- const Byte *Lim;
- Byte *Buf;
- UInt32 Size;
- ISequentialInStream *Stream;
- UInt64 Processed;
- bool Extra;
- HRESULT Res;
-
- CByteInBufWrap();
- ~CByteInBufWrap() { Free(); }
- void Free() throw();
- bool Alloc(UInt32 size) throw();
- void Init()
- {
- Lim = Cur = Buf;
- Processed = 0;
- Extra = false;
- Res = S_OK;
- }
- UInt64 GetProcessed() const { return Processed + (Cur - Buf); }
- Byte ReadByteFromNewBlock() throw();
- Byte ReadByte()
- {
- if (Cur != Lim)
- return *Cur++;
- return ReadByteFromNewBlock();
- }
-};
-
-
-struct CByteOutBufWrap
-{
- IByteOut vt;
- Byte *Cur;
- const Byte *Lim;
- Byte *Buf;
- size_t Size;
- ISequentialOutStream *Stream;
- UInt64 Processed;
- HRESULT Res;
-
- CByteOutBufWrap() throw();
- ~CByteOutBufWrap() { Free(); }
- void Free() throw();
- bool Alloc(size_t size) throw();
- void Init()
- {
- Cur = Buf;
- Lim = Buf + Size;
- Processed = 0;
- Res = S_OK;
- }
- UInt64 GetProcessed() const { return Processed + (Cur - Buf); }
- HRESULT Flush() throw();
- void WriteByte(Byte b)
- {
- *Cur++ = b;
- if (Cur == Lim)
- Flush();
- }
-};
-
-#endif
+// CWrappers.h
+
+#ifndef ZIP7_INC_C_WRAPPERS_H
+#define ZIP7_INC_C_WRAPPERS_H
+
+#include "../ICoder.h"
+#include "../../Common/MyCom.h"
+
+SRes HRESULT_To_SRes(HRESULT res, SRes defaultRes) throw();
+HRESULT SResToHRESULT(SRes res) throw();
+
+struct CCompressProgressWrap
+{
+ ICompressProgress vt;
+ ICompressProgressInfo *Progress;
+ HRESULT Res;
+
+ void Init(ICompressProgressInfo *progress) throw();
+};
+
+
+struct CSeqInStreamWrap
+{
+ ISeqInStream vt;
+ ISequentialInStream *Stream;
+ HRESULT Res;
+ UInt64 Processed;
+
+ void Init(ISequentialInStream *stream) throw();
+};
+
+
+struct CSeekInStreamWrap
+{
+ ISeekInStream vt;
+ IInStream *Stream;
+ HRESULT Res;
+
+ void Init(IInStream *stream) throw();
+};
+
+
+struct CSeqOutStreamWrap
+{
+ ISeqOutStream vt;
+ ISequentialOutStream *Stream;
+ HRESULT Res;
+ UInt64 Processed;
+
+ void Init(ISequentialOutStream *stream) throw();
+};
+
+
+struct CByteInBufWrap
+{
+ IByteIn vt;
+ const Byte *Cur;
+ const Byte *Lim;
+ Byte *Buf;
+ UInt32 Size;
+ ISequentialInStream *Stream;
+ UInt64 Processed;
+ bool Extra;
+ HRESULT Res;
+
+ CByteInBufWrap() throw();
+ ~CByteInBufWrap() { Free(); }
+ void Free() throw();
+ bool Alloc(UInt32 size) throw();
+ void Init()
+ {
+ Lim = Cur = Buf;
+ Processed = 0;
+ Extra = false;
+ Res = S_OK;
+ }
+ UInt64 GetProcessed() const { return Processed + (size_t)(Cur - Buf); }
+ Byte ReadByteFromNewBlock() throw();
+ Byte ReadByte()
+ {
+ if (Cur != Lim)
+ return *Cur++;
+ return ReadByteFromNewBlock();
+ }
+};
+
+
+/*
+struct CLookToSequentialWrap
+{
+ Byte *BufBase;
+ UInt32 Size;
+ ISequentialInStream *Stream;
+ UInt64 Processed;
+ bool Extra;
+ HRESULT Res;
+
+ CLookToSequentialWrap(): BufBase(NULL) {}
+ ~CLookToSequentialWrap() { Free(); }
+ void Free() throw();
+ bool Alloc(UInt32 size) throw();
+ void Init()
+ {
+ // Lim = Cur = Buf;
+ Processed = 0;
+ Extra = false;
+ Res = S_OK;
+ }
+ // UInt64 GetProcessed() const { return Processed + (Cur - Buf); }
+
+ Byte ReadByteFromNewBlock() throw();
+ Byte ReadByte()
+ {
+ if (Cur != Lim)
+ return *Cur++;
+ return ReadByteFromNewBlock();
+ }
+};
+
+EXTERN_C_BEGIN
+// void CLookToSequentialWrap_Look(ILookInSeqStream *pp);
+EXTERN_C_END
+*/
+
+
+
+struct CByteOutBufWrap
+{
+ IByteOut vt;
+ Byte *Cur;
+ const Byte *Lim;
+ Byte *Buf;
+ size_t Size;
+ ISequentialOutStream *Stream;
+ UInt64 Processed;
+ HRESULT Res;
+
+ CByteOutBufWrap() throw();
+ ~CByteOutBufWrap() { Free(); }
+ void Free() throw();
+ bool Alloc(size_t size) throw();
+ void Init()
+ {
+ Cur = Buf;
+ Lim = Buf + Size;
+ Processed = 0;
+ Res = S_OK;
+ }
+ UInt64 GetProcessed() const { return Processed + (size_t)(Cur - Buf); }
+ HRESULT Flush() throw();
+ void WriteByte(Byte b)
+ {
+ *Cur++ = b;
+ if (Cur == Lim)
+ Flush();
+ }
+};
+
+
+/*
+struct CLookOutWrap
+{
+ ILookOutStream vt;
+ Byte *Buf;
+ size_t Size;
+ ISequentialOutStream *Stream;
+ UInt64 Processed;
+ HRESULT Res;
+
+ CLookOutWrap() throw();
+ ~CLookOutWrap() { Free(); }
+ void Free() throw();
+ bool Alloc(size_t size) throw();
+ void Init()
+ {
+ Processed = 0;
+ Res = S_OK;
+ }
+};
+*/
+
+#endif
diff --git a/CPP/7zip/Common/CreateCoder.cpp b/CPP/7zip/Common/CreateCoder.cpp
index 5040765..bf7b04e 100644
--- a/CPP/7zip/Common/CreateCoder.cpp
+++ b/CPP/7zip/Common/CreateCoder.cpp
@@ -1,536 +1,548 @@
-// CreateCoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../Windows/Defs.h"
-#include "../../Windows/PropVariant.h"
-
-#include "CreateCoder.h"
-
-#include "FilterCoder.h"
-#include "RegisterCodec.h"
-
-static const unsigned kNumCodecsMax = 64;
-unsigned g_NumCodecs = 0;
-const CCodecInfo *g_Codecs[kNumCodecsMax];
-
-// We use g_ExternalCodecs in other stages.
-/*
-#ifdef EXTERNAL_CODECS
-extern CExternalCodecs g_ExternalCodecs;
-#define CHECK_GLOBAL_CODECS \
- if (!__externalCodecs || !__externalCodecs->IsSet()) __externalCodecs = &g_ExternalCodecs;
-#endif
-*/
-
-#define CHECK_GLOBAL_CODECS
-
-void RegisterCodec(const CCodecInfo *codecInfo) throw()
-{
- if (g_NumCodecs < kNumCodecsMax)
- g_Codecs[g_NumCodecs++] = codecInfo;
-}
-
-static const unsigned kNumHashersMax = 16;
-unsigned g_NumHashers = 0;
-const CHasherInfo *g_Hashers[kNumHashersMax];
-
-void RegisterHasher(const CHasherInfo *hashInfo) throw()
-{
- if (g_NumHashers < kNumHashersMax)
- g_Hashers[g_NumHashers++] = hashInfo;
-}
-
-
-#ifdef EXTERNAL_CODECS
-
-static HRESULT ReadNumberOfStreams(ICompressCodecsInfo *codecsInfo, UInt32 index, PROPID propID, UInt32 &res)
-{
- NWindows::NCOM::CPropVariant prop;
- RINOK(codecsInfo->GetProperty(index, propID, &prop));
- if (prop.vt == VT_EMPTY)
- res = 1;
- else if (prop.vt == VT_UI4)
- res = prop.ulVal;
- else
- return E_INVALIDARG;
- return S_OK;
-}
-
-static HRESULT ReadIsAssignedProp(ICompressCodecsInfo *codecsInfo, UInt32 index, PROPID propID, bool &res)
-{
- NWindows::NCOM::CPropVariant prop;
- RINOK(codecsInfo->GetProperty(index, propID, &prop));
- if (prop.vt == VT_EMPTY)
- res = true;
- else if (prop.vt == VT_BOOL)
- res = VARIANT_BOOLToBool(prop.boolVal);
- else
- return E_INVALIDARG;
- return S_OK;
-}
-
-HRESULT CExternalCodecs::Load()
-{
- Codecs.Clear();
- Hashers.Clear();
-
- if (GetCodecs)
- {
- CCodecInfoEx info;
-
- UString s;
- UInt32 num;
- RINOK(GetCodecs->GetNumMethods(&num));
-
- for (UInt32 i = 0; i < num; i++)
- {
- NWindows::NCOM::CPropVariant prop;
-
- RINOK(GetCodecs->GetProperty(i, NMethodPropID::kID, &prop));
- if (prop.vt != VT_UI8)
- continue; // old Interface
- info.Id = prop.uhVal.QuadPart;
-
- prop.Clear();
-
- info.Name.Empty();
- RINOK(GetCodecs->GetProperty(i, NMethodPropID::kName, &prop));
- if (prop.vt == VT_BSTR)
- info.Name.SetFromWStr_if_Ascii(prop.bstrVal);
- else if (prop.vt != VT_EMPTY)
- continue;
-
- RINOK(ReadNumberOfStreams(GetCodecs, i, NMethodPropID::kPackStreams, info.NumStreams));
- {
- UInt32 numUnpackStreams = 1;
- RINOK(ReadNumberOfStreams(GetCodecs, i, NMethodPropID::kUnpackStreams, numUnpackStreams));
- if (numUnpackStreams != 1)
- continue;
- }
- RINOK(ReadIsAssignedProp(GetCodecs, i, NMethodPropID::kEncoderIsAssigned, info.EncoderIsAssigned));
- RINOK(ReadIsAssignedProp(GetCodecs, i, NMethodPropID::kDecoderIsAssigned, info.DecoderIsAssigned));
-
- Codecs.Add(info);
- }
- }
-
- if (GetHashers)
- {
- UInt32 num = GetHashers->GetNumHashers();
- CHasherInfoEx info;
-
- for (UInt32 i = 0; i < num; i++)
- {
- NWindows::NCOM::CPropVariant prop;
-
- RINOK(GetHashers->GetHasherProp(i, NMethodPropID::kID, &prop));
- if (prop.vt != VT_UI8)
- continue;
- info.Id = prop.uhVal.QuadPart;
-
- prop.Clear();
-
- info.Name.Empty();
- RINOK(GetHashers->GetHasherProp(i, NMethodPropID::kName, &prop));
- if (prop.vt == VT_BSTR)
- info.Name.SetFromWStr_if_Ascii(prop.bstrVal);
- else if (prop.vt != VT_EMPTY)
- continue;
-
- Hashers.Add(info);
- }
- }
-
- return S_OK;
-}
-
-#endif
-
-
-int FindMethod_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const AString &name,
- bool encode,
- CMethodId &methodId,
- UInt32 &numStreams)
-{
- unsigned i;
- for (i = 0; i < g_NumCodecs; i++)
- {
- const CCodecInfo &codec = *g_Codecs[i];
- if ((encode ? codec.CreateEncoder : codec.CreateDecoder)
- && StringsAreEqualNoCase_Ascii(name, codec.Name))
- {
- methodId = codec.Id;
- numStreams = codec.NumStreams;
- return i;
- }
- }
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (__externalCodecs)
- for (i = 0; i < __externalCodecs->Codecs.Size(); i++)
- {
- const CCodecInfoEx &codec = __externalCodecs->Codecs[i];
- if ((encode ? codec.EncoderIsAssigned : codec.DecoderIsAssigned)
- && StringsAreEqualNoCase_Ascii(name, codec.Name))
- {
- methodId = codec.Id;
- numStreams = codec.NumStreams;
- return g_NumCodecs + i;
- }
- }
-
- #endif
-
- return -1;
-}
-
-
-static int FindMethod_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode)
-{
- unsigned i;
- for (i = 0; i < g_NumCodecs; i++)
- {
- const CCodecInfo &codec = *g_Codecs[i];
- if (codec.Id == methodId && (encode ? codec.CreateEncoder : codec.CreateDecoder))
- return i;
- }
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (__externalCodecs)
- for (i = 0; i < __externalCodecs->Codecs.Size(); i++)
- {
- const CCodecInfoEx &codec = __externalCodecs->Codecs[i];
- if (codec.Id == methodId && (encode ? codec.EncoderIsAssigned : codec.DecoderIsAssigned))
- return g_NumCodecs + i;
- }
-
- #endif
-
- return -1;
-}
-
-
-bool FindMethod(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId,
- AString &name)
-{
- name.Empty();
-
- unsigned i;
- for (i = 0; i < g_NumCodecs; i++)
- {
- const CCodecInfo &codec = *g_Codecs[i];
- if (methodId == codec.Id)
- {
- name = codec.Name;
- return true;
- }
- }
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (__externalCodecs)
- for (i = 0; i < __externalCodecs->Codecs.Size(); i++)
- {
- const CCodecInfoEx &codec = __externalCodecs->Codecs[i];
- if (methodId == codec.Id)
- {
- name = codec.Name;
- return true;
- }
- }
-
- #endif
-
- return false;
-}
-
-bool FindHashMethod(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const AString &name,
- CMethodId &methodId)
-{
- unsigned i;
- for (i = 0; i < g_NumHashers; i++)
- {
- const CHasherInfo &codec = *g_Hashers[i];
- if (StringsAreEqualNoCase_Ascii(name, codec.Name))
- {
- methodId = codec.Id;
- return true;
- }
- }
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (__externalCodecs)
- for (i = 0; i < __externalCodecs->Hashers.Size(); i++)
- {
- const CHasherInfoEx &codec = __externalCodecs->Hashers[i];
- if (StringsAreEqualNoCase_Ascii(name, codec.Name))
- {
- methodId = codec.Id;
- return true;
- }
- }
-
- #endif
-
- return false;
-}
-
-void GetHashMethods(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CRecordVector<CMethodId> &methods)
-{
- methods.ClearAndSetSize(g_NumHashers);
- unsigned i;
- for (i = 0; i < g_NumHashers; i++)
- methods[i] = (*g_Hashers[i]).Id;
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (__externalCodecs)
- for (i = 0; i < __externalCodecs->Hashers.Size(); i++)
- methods.Add(__externalCodecs->Hashers[i].Id);
-
- #endif
-}
-
-
-
-HRESULT CreateCoder_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- unsigned i, bool encode,
- CMyComPtr<ICompressFilter> &filter,
- CCreatedCoder &cod)
-{
- cod.IsExternal = false;
- cod.IsFilter = false;
- cod.NumStreams = 1;
-
- if (i < g_NumCodecs)
- {
- const CCodecInfo &codec = *g_Codecs[i];
- // if (codec.Id == methodId)
- {
- if (encode)
- {
- if (codec.CreateEncoder)
- {
- void *p = codec.CreateEncoder();
- if (codec.IsFilter) filter = (ICompressFilter *)p;
- else if (codec.NumStreams == 1) cod.Coder = (ICompressCoder *)p;
- else { cod.Coder2 = (ICompressCoder2 *)p; cod.NumStreams = codec.NumStreams; }
- return S_OK;
- }
- }
- else
- if (codec.CreateDecoder)
- {
- void *p = codec.CreateDecoder();
- if (codec.IsFilter) filter = (ICompressFilter *)p;
- else if (codec.NumStreams == 1) cod.Coder = (ICompressCoder *)p;
- else { cod.Coder2 = (ICompressCoder2 *)p; cod.NumStreams = codec.NumStreams; }
- return S_OK;
- }
- }
- }
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (__externalCodecs)
- {
- i -= g_NumCodecs;
- cod.IsExternal = true;
- if (i < __externalCodecs->Codecs.Size())
- {
- const CCodecInfoEx &codec = __externalCodecs->Codecs[i];
- // if (codec.Id == methodId)
- {
- if (encode)
- {
- if (codec.EncoderIsAssigned)
- {
- if (codec.NumStreams == 1)
- {
- HRESULT res = __externalCodecs->GetCodecs->CreateEncoder(i, &IID_ICompressCoder, (void **)&cod.Coder);
- if (res != S_OK && res != E_NOINTERFACE && res != CLASS_E_CLASSNOTAVAILABLE)
- return res;
- if (cod.Coder)
- return res;
- return __externalCodecs->GetCodecs->CreateEncoder(i, &IID_ICompressFilter, (void **)&filter);
- }
- cod.NumStreams = codec.NumStreams;
- return __externalCodecs->GetCodecs->CreateEncoder(i, &IID_ICompressCoder2, (void **)&cod.Coder2);
- }
- }
- else
- if (codec.DecoderIsAssigned)
- {
- if (codec.NumStreams == 1)
- {
- HRESULT res = __externalCodecs->GetCodecs->CreateDecoder(i, &IID_ICompressCoder, (void **)&cod.Coder);
- if (res != S_OK && res != E_NOINTERFACE && res != CLASS_E_CLASSNOTAVAILABLE)
- return res;
- if (cod.Coder)
- return res;
- return __externalCodecs->GetCodecs->CreateDecoder(i, &IID_ICompressFilter, (void **)&filter);
- }
- cod.NumStreams = codec.NumStreams;
- return __externalCodecs->GetCodecs->CreateDecoder(i, &IID_ICompressCoder2, (void **)&cod.Coder2);
- }
- }
- }
- }
- #endif
-
- return S_OK;
-}
-
-
-HRESULT CreateCoder_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- unsigned index, bool encode,
- CCreatedCoder &cod)
-{
- CMyComPtr<ICompressFilter> filter;
- HRESULT res = CreateCoder_Index(
- EXTERNAL_CODECS_LOC_VARS
- index, encode,
- filter, cod);
-
- if (filter)
- {
- cod.IsFilter = true;
- CFilterCoder *coderSpec = new CFilterCoder(encode);
- cod.Coder = coderSpec;
- coderSpec->Filter = filter;
- }
-
- return res;
-}
-
-
-HRESULT CreateCoder_Id(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CMyComPtr<ICompressFilter> &filter,
- CCreatedCoder &cod)
-{
- int index = FindMethod_Index(EXTERNAL_CODECS_LOC_VARS methodId, encode);
- if (index < 0)
- return S_OK;
- return CreateCoder_Index(EXTERNAL_CODECS_LOC_VARS index, encode, filter, cod);
-}
-
-
-HRESULT CreateCoder_Id(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CCreatedCoder &cod)
-{
- CMyComPtr<ICompressFilter> filter;
- HRESULT res = CreateCoder_Id(
- EXTERNAL_CODECS_LOC_VARS
- methodId, encode,
- filter, cod);
-
- if (filter)
- {
- cod.IsFilter = true;
- CFilterCoder *coderSpec = new CFilterCoder(encode);
- cod.Coder = coderSpec;
- coderSpec->Filter = filter;
- }
-
- return res;
-}
-
-
-HRESULT CreateCoder_Id(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CMyComPtr<ICompressCoder> &coder)
-{
- CCreatedCoder cod;
- HRESULT res = CreateCoder_Id(
- EXTERNAL_CODECS_LOC_VARS
- methodId, encode,
- cod);
- coder = cod.Coder;
- return res;
-}
-
-HRESULT CreateFilter(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CMyComPtr<ICompressFilter> &filter)
-{
- CCreatedCoder cod;
- return CreateCoder_Id(
- EXTERNAL_CODECS_LOC_VARS
- methodId, encode,
- filter, cod);
-}
-
-
-HRESULT CreateHasher(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId,
- AString &name,
- CMyComPtr<IHasher> &hasher)
-{
- name.Empty();
-
- unsigned i;
- for (i = 0; i < g_NumHashers; i++)
- {
- const CHasherInfo &codec = *g_Hashers[i];
- if (codec.Id == methodId)
- {
- hasher = codec.CreateHasher();
- name = codec.Name;
- break;
- }
- }
-
- #ifdef EXTERNAL_CODECS
-
- CHECK_GLOBAL_CODECS
-
- if (!hasher && __externalCodecs)
- for (i = 0; i < __externalCodecs->Hashers.Size(); i++)
- {
- const CHasherInfoEx &codec = __externalCodecs->Hashers[i];
- if (codec.Id == methodId)
- {
- name = codec.Name;
- return __externalCodecs->GetHashers->CreateHasher((UInt32)i, &hasher);
- }
- }
-
- #endif
-
- return S_OK;
-}
+// CreateCoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../Windows/Defs.h"
+#include "../../Windows/PropVariant.h"
+
+#include "CreateCoder.h"
+
+#include "FilterCoder.h"
+#include "RegisterCodec.h"
+
+static const unsigned kNumCodecsMax = 64;
+extern
+unsigned g_NumCodecs;
+unsigned g_NumCodecs = 0;
+extern
+const CCodecInfo *g_Codecs[];
+const CCodecInfo *g_Codecs[kNumCodecsMax];
+
+// We use g_ExternalCodecs in other stages.
+#ifdef Z7_EXTERNAL_CODECS
+/*
+extern CExternalCodecs g_ExternalCodecs;
+#define CHECK_GLOBAL_CODECS \
+ if (!_externalCodecs || !_externalCodecs->IsSet()) _externalCodecs = &g_ExternalCodecs;
+*/
+#define CHECK_GLOBAL_CODECS
+#endif
+
+
+void RegisterCodec(const CCodecInfo *codecInfo) throw()
+{
+ if (g_NumCodecs < kNumCodecsMax)
+ g_Codecs[g_NumCodecs++] = codecInfo;
+}
+
+static const unsigned kNumHashersMax = 16;
+extern
+unsigned g_NumHashers;
+unsigned g_NumHashers = 0;
+extern
+const CHasherInfo *g_Hashers[];
+const CHasherInfo *g_Hashers[kNumHashersMax];
+
+void RegisterHasher(const CHasherInfo *hashInfo) throw()
+{
+ if (g_NumHashers < kNumHashersMax)
+ g_Hashers[g_NumHashers++] = hashInfo;
+}
+
+
+#ifdef Z7_EXTERNAL_CODECS
+
+static HRESULT ReadNumberOfStreams(ICompressCodecsInfo *codecsInfo, UInt32 index, PROPID propID, UInt32 &res)
+{
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(codecsInfo->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_EMPTY)
+ res = 1;
+ else if (prop.vt == VT_UI4)
+ res = prop.ulVal;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+static HRESULT ReadIsAssignedProp(ICompressCodecsInfo *codecsInfo, UInt32 index, PROPID propID, bool &res)
+{
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(codecsInfo->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_EMPTY)
+ res = true;
+ else if (prop.vt == VT_BOOL)
+ res = VARIANT_BOOLToBool(prop.boolVal);
+ else
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+HRESULT CExternalCodecs::Load()
+{
+ Codecs.Clear();
+ Hashers.Clear();
+
+ if (GetCodecs)
+ {
+ CCodecInfoEx info;
+
+ UString s;
+ UInt32 num;
+ RINOK(GetCodecs->GetNumMethods(&num))
+
+ for (UInt32 i = 0; i < num; i++)
+ {
+ NWindows::NCOM::CPropVariant prop;
+
+ RINOK(GetCodecs->GetProperty(i, NMethodPropID::kID, &prop))
+ if (prop.vt != VT_UI8)
+ continue; // old Interface
+ info.Id = prop.uhVal.QuadPart;
+
+ prop.Clear();
+
+ info.Name.Empty();
+ RINOK(GetCodecs->GetProperty(i, NMethodPropID::kName, &prop))
+ if (prop.vt == VT_BSTR)
+ info.Name.SetFromWStr_if_Ascii(prop.bstrVal);
+ else if (prop.vt != VT_EMPTY)
+ continue;
+
+ RINOK(ReadNumberOfStreams(GetCodecs, i, NMethodPropID::kPackStreams, info.NumStreams))
+ {
+ UInt32 numUnpackStreams = 1;
+ RINOK(ReadNumberOfStreams(GetCodecs, i, NMethodPropID::kUnpackStreams, numUnpackStreams))
+ if (numUnpackStreams != 1)
+ continue;
+ }
+ RINOK(ReadIsAssignedProp(GetCodecs, i, NMethodPropID::kEncoderIsAssigned, info.EncoderIsAssigned))
+ RINOK(ReadIsAssignedProp(GetCodecs, i, NMethodPropID::kDecoderIsAssigned, info.DecoderIsAssigned))
+ RINOK(ReadIsAssignedProp(GetCodecs, i, NMethodPropID::kIsFilter, info.IsFilter))
+
+ Codecs.Add(info);
+ }
+ }
+
+ if (GetHashers)
+ {
+ UInt32 num = GetHashers->GetNumHashers();
+ CHasherInfoEx info;
+
+ for (UInt32 i = 0; i < num; i++)
+ {
+ NWindows::NCOM::CPropVariant prop;
+
+ RINOK(GetHashers->GetHasherProp(i, NMethodPropID::kID, &prop))
+ if (prop.vt != VT_UI8)
+ continue;
+ info.Id = prop.uhVal.QuadPart;
+
+ prop.Clear();
+
+ info.Name.Empty();
+ RINOK(GetHashers->GetHasherProp(i, NMethodPropID::kName, &prop))
+ if (prop.vt == VT_BSTR)
+ info.Name.SetFromWStr_if_Ascii(prop.bstrVal);
+ else if (prop.vt != VT_EMPTY)
+ continue;
+
+ Hashers.Add(info);
+ }
+ }
+
+ return S_OK;
+}
+
+#endif
+
+
+int FindMethod_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const AString &name,
+ bool encode,
+ CMethodId &methodId,
+ UInt32 &numStreams,
+ bool &isFilter)
+{
+ unsigned i;
+ for (i = 0; i < g_NumCodecs; i++)
+ {
+ const CCodecInfo &codec = *g_Codecs[i];
+ if ((encode ? codec.CreateEncoder : codec.CreateDecoder)
+ && StringsAreEqualNoCase_Ascii(name, codec.Name))
+ {
+ methodId = codec.Id;
+ numStreams = codec.NumStreams;
+ isFilter = codec.IsFilter;
+ return (int)i;
+ }
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (_externalCodecs)
+ for (i = 0; i < _externalCodecs->Codecs.Size(); i++)
+ {
+ const CCodecInfoEx &codec = _externalCodecs->Codecs[i];
+ if ((encode ? codec.EncoderIsAssigned : codec.DecoderIsAssigned)
+ && StringsAreEqualNoCase_Ascii(name, codec.Name))
+ {
+ methodId = codec.Id;
+ numStreams = codec.NumStreams;
+ isFilter = codec.IsFilter;
+ return (int)(g_NumCodecs + i);
+ }
+ }
+
+ #endif
+
+ return -1;
+}
+
+
+static int FindMethod_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode)
+{
+ unsigned i;
+ for (i = 0; i < g_NumCodecs; i++)
+ {
+ const CCodecInfo &codec = *g_Codecs[i];
+ if (codec.Id == methodId && (encode ? codec.CreateEncoder : codec.CreateDecoder))
+ return (int)i;
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (_externalCodecs)
+ for (i = 0; i < _externalCodecs->Codecs.Size(); i++)
+ {
+ const CCodecInfoEx &codec = _externalCodecs->Codecs[i];
+ if (codec.Id == methodId && (encode ? codec.EncoderIsAssigned : codec.DecoderIsAssigned))
+ return (int)(g_NumCodecs + i);
+ }
+
+ #endif
+
+ return -1;
+}
+
+
+bool FindMethod(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId,
+ AString &name)
+{
+ name.Empty();
+
+ unsigned i;
+ for (i = 0; i < g_NumCodecs; i++)
+ {
+ const CCodecInfo &codec = *g_Codecs[i];
+ if (methodId == codec.Id)
+ {
+ name = codec.Name;
+ return true;
+ }
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (_externalCodecs)
+ for (i = 0; i < _externalCodecs->Codecs.Size(); i++)
+ {
+ const CCodecInfoEx &codec = _externalCodecs->Codecs[i];
+ if (methodId == codec.Id)
+ {
+ name = codec.Name;
+ return true;
+ }
+ }
+
+ #endif
+
+ return false;
+}
+
+bool FindHashMethod(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const AString &name,
+ CMethodId &methodId)
+{
+ unsigned i;
+ for (i = 0; i < g_NumHashers; i++)
+ {
+ const CHasherInfo &codec = *g_Hashers[i];
+ if (StringsAreEqualNoCase_Ascii(name, codec.Name))
+ {
+ methodId = codec.Id;
+ return true;
+ }
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (_externalCodecs)
+ for (i = 0; i < _externalCodecs->Hashers.Size(); i++)
+ {
+ const CHasherInfoEx &codec = _externalCodecs->Hashers[i];
+ if (StringsAreEqualNoCase_Ascii(name, codec.Name))
+ {
+ methodId = codec.Id;
+ return true;
+ }
+ }
+
+ #endif
+
+ return false;
+}
+
+void GetHashMethods(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CRecordVector<CMethodId> &methods)
+{
+ methods.ClearAndSetSize(g_NumHashers);
+ unsigned i;
+ for (i = 0; i < g_NumHashers; i++)
+ methods[i] = (*g_Hashers[i]).Id;
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (_externalCodecs)
+ for (i = 0; i < _externalCodecs->Hashers.Size(); i++)
+ methods.Add(_externalCodecs->Hashers[i].Id);
+
+ #endif
+}
+
+
+
+HRESULT CreateCoder_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ unsigned i, bool encode,
+ CMyComPtr<ICompressFilter> &filter,
+ CCreatedCoder &cod)
+{
+ cod.IsExternal = false;
+ cod.IsFilter = false;
+ cod.NumStreams = 1;
+
+ if (i < g_NumCodecs)
+ {
+ const CCodecInfo &codec = *g_Codecs[i];
+ // if (codec.Id == methodId)
+ {
+ if (encode)
+ {
+ if (codec.CreateEncoder)
+ {
+ void *p = codec.CreateEncoder();
+ if (codec.IsFilter) filter = (ICompressFilter *)p;
+ else if (codec.NumStreams == 1) cod.Coder = (ICompressCoder *)p;
+ else { cod.Coder2 = (ICompressCoder2 *)p; cod.NumStreams = codec.NumStreams; }
+ return S_OK;
+ }
+ }
+ else
+ if (codec.CreateDecoder)
+ {
+ void *p = codec.CreateDecoder();
+ if (codec.IsFilter) filter = (ICompressFilter *)p;
+ else if (codec.NumStreams == 1) cod.Coder = (ICompressCoder *)p;
+ else { cod.Coder2 = (ICompressCoder2 *)p; cod.NumStreams = codec.NumStreams; }
+ return S_OK;
+ }
+ }
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (_externalCodecs)
+ {
+ i -= g_NumCodecs;
+ cod.IsExternal = true;
+ if (i < _externalCodecs->Codecs.Size())
+ {
+ const CCodecInfoEx &codec = _externalCodecs->Codecs[i];
+ // if (codec.Id == methodId)
+ {
+ if (encode)
+ {
+ if (codec.EncoderIsAssigned)
+ {
+ if (codec.NumStreams == 1)
+ {
+ const HRESULT res = _externalCodecs->GetCodecs->CreateEncoder(i, &IID_ICompressCoder, (void **)&cod.Coder);
+ if (res != S_OK && res != E_NOINTERFACE && res != CLASS_E_CLASSNOTAVAILABLE)
+ return res;
+ if (cod.Coder)
+ return res;
+ return _externalCodecs->GetCodecs->CreateEncoder(i, &IID_ICompressFilter, (void **)&filter);
+ }
+ cod.NumStreams = codec.NumStreams;
+ return _externalCodecs->GetCodecs->CreateEncoder(i, &IID_ICompressCoder2, (void **)&cod.Coder2);
+ }
+ }
+ else
+ if (codec.DecoderIsAssigned)
+ {
+ if (codec.NumStreams == 1)
+ {
+ const HRESULT res = _externalCodecs->GetCodecs->CreateDecoder(i, &IID_ICompressCoder, (void **)&cod.Coder);
+ if (res != S_OK && res != E_NOINTERFACE && res != CLASS_E_CLASSNOTAVAILABLE)
+ return res;
+ if (cod.Coder)
+ return res;
+ return _externalCodecs->GetCodecs->CreateDecoder(i, &IID_ICompressFilter, (void **)&filter);
+ }
+ cod.NumStreams = codec.NumStreams;
+ return _externalCodecs->GetCodecs->CreateDecoder(i, &IID_ICompressCoder2, (void **)&cod.Coder2);
+ }
+ }
+ }
+ }
+ #endif
+
+ return S_OK;
+}
+
+
+HRESULT CreateCoder_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ unsigned index, bool encode,
+ CCreatedCoder &cod)
+{
+ CMyComPtr<ICompressFilter> filter;
+ const HRESULT res = CreateCoder_Index(
+ EXTERNAL_CODECS_LOC_VARS
+ index, encode,
+ filter, cod);
+
+ if (filter)
+ {
+ cod.IsFilter = true;
+ CFilterCoder *coderSpec = new CFilterCoder(encode);
+ cod.Coder = coderSpec;
+ coderSpec->Filter = filter;
+ }
+
+ return res;
+}
+
+
+HRESULT CreateCoder_Id(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CMyComPtr<ICompressFilter> &filter,
+ CCreatedCoder &cod)
+{
+ const int index = FindMethod_Index(EXTERNAL_CODECS_LOC_VARS methodId, encode);
+ if (index < 0)
+ return S_OK;
+ return CreateCoder_Index(EXTERNAL_CODECS_LOC_VARS (unsigned)index, encode, filter, cod);
+}
+
+
+HRESULT CreateCoder_Id(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CCreatedCoder &cod)
+{
+ CMyComPtr<ICompressFilter> filter;
+ const HRESULT res = CreateCoder_Id(
+ EXTERNAL_CODECS_LOC_VARS
+ methodId, encode,
+ filter, cod);
+
+ if (filter)
+ {
+ cod.IsFilter = true;
+ CFilterCoder *coderSpec = new CFilterCoder(encode);
+ cod.Coder = coderSpec;
+ coderSpec->Filter = filter;
+ }
+
+ return res;
+}
+
+
+HRESULT CreateCoder_Id(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CMyComPtr<ICompressCoder> &coder)
+{
+ CCreatedCoder cod;
+ const HRESULT res = CreateCoder_Id(
+ EXTERNAL_CODECS_LOC_VARS
+ methodId, encode,
+ cod);
+ coder = cod.Coder;
+ return res;
+}
+
+HRESULT CreateFilter(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CMyComPtr<ICompressFilter> &filter)
+{
+ CCreatedCoder cod;
+ return CreateCoder_Id(
+ EXTERNAL_CODECS_LOC_VARS
+ methodId, encode,
+ filter, cod);
+}
+
+
+HRESULT CreateHasher(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId,
+ AString &name,
+ CMyComPtr<IHasher> &hasher)
+{
+ name.Empty();
+
+ unsigned i;
+ for (i = 0; i < g_NumHashers; i++)
+ {
+ const CHasherInfo &codec = *g_Hashers[i];
+ if (codec.Id == methodId)
+ {
+ hasher = codec.CreateHasher();
+ name = codec.Name;
+ break;
+ }
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CHECK_GLOBAL_CODECS
+
+ if (!hasher && _externalCodecs)
+ for (i = 0; i < _externalCodecs->Hashers.Size(); i++)
+ {
+ const CHasherInfoEx &codec = _externalCodecs->Hashers[i];
+ if (codec.Id == methodId)
+ {
+ name = codec.Name;
+ return _externalCodecs->GetHashers->CreateHasher((UInt32)i, &hasher);
+ }
+ }
+
+ #endif
+
+ return S_OK;
+}
diff --git a/CPP/7zip/Common/CreateCoder.h b/CPP/7zip/Common/CreateCoder.h
index 2105818..709fe83 100644
--- a/CPP/7zip/Common/CreateCoder.h
+++ b/CPP/7zip/Common/CreateCoder.h
@@ -1,192 +1,200 @@
-// CreateCoder.h
-
-#ifndef __CREATE_CODER_H
-#define __CREATE_CODER_H
-
-#include "../../Common/MyCom.h"
-#include "../../Common/MyString.h"
-
-#include "../ICoder.h"
-
-#include "MethodId.h"
-
-/*
- if EXTERNAL_CODECS is not defined, the code supports only codecs that
- are statically linked at compile-time and link-time.
-
- if EXTERNAL_CODECS is defined, the code supports also codecs from another
- executable modules, that can be linked dynamically at run-time:
- - EXE module can use codecs from external DLL files.
- - DLL module can use codecs from external EXE and DLL files.
-
- CExternalCodecs contains information about codecs and interfaces to create them.
-
- The order of codecs:
- 1) Internal codecs
- 2) External codecs
-*/
-
-#ifdef EXTERNAL_CODECS
-
-struct CCodecInfoEx
-{
- CMethodId Id;
- AString Name;
- UInt32 NumStreams;
- bool EncoderIsAssigned;
- bool DecoderIsAssigned;
-
- CCodecInfoEx(): EncoderIsAssigned(false), DecoderIsAssigned(false) {}
-};
-
-struct CHasherInfoEx
-{
- CMethodId Id;
- AString Name;
-};
-
-#define PUBLIC_ISetCompressCodecsInfo public ISetCompressCodecsInfo,
-#define QUERY_ENTRY_ISetCompressCodecsInfo MY_QUERYINTERFACE_ENTRY(ISetCompressCodecsInfo)
-#define DECL_ISetCompressCodecsInfo STDMETHOD(SetCompressCodecsInfo)(ICompressCodecsInfo *compressCodecsInfo);
-#define IMPL_ISetCompressCodecsInfo2(x) \
-STDMETHODIMP x::SetCompressCodecsInfo(ICompressCodecsInfo *compressCodecsInfo) { \
- COM_TRY_BEGIN __externalCodecs.GetCodecs = compressCodecsInfo; return __externalCodecs.Load(); COM_TRY_END }
-#define IMPL_ISetCompressCodecsInfo IMPL_ISetCompressCodecsInfo2(CHandler)
-
-struct CExternalCodecs
-{
- CMyComPtr<ICompressCodecsInfo> GetCodecs;
- CMyComPtr<IHashers> GetHashers;
-
- CObjectVector<CCodecInfoEx> Codecs;
- CObjectVector<CHasherInfoEx> Hashers;
-
- bool IsSet() const { return GetCodecs != NULL || GetHashers != NULL; }
-
- HRESULT Load();
-
- void ClearAndRelease()
- {
- Hashers.Clear();
- Codecs.Clear();
- GetHashers.Release();
- GetCodecs.Release();
- }
-
- ~CExternalCodecs()
- {
- GetHashers.Release();
- GetCodecs.Release();
- }
-};
-
-extern CExternalCodecs g_ExternalCodecs;
-
-#define EXTERNAL_CODECS_VARS2 (__externalCodecs.IsSet() ? &__externalCodecs : &g_ExternalCodecs)
-#define EXTERNAL_CODECS_VARS2_L (&__externalCodecs)
-#define EXTERNAL_CODECS_VARS2_G (&g_ExternalCodecs)
-
-#define DECL_EXTERNAL_CODECS_VARS CExternalCodecs __externalCodecs;
-
-#define EXTERNAL_CODECS_VARS EXTERNAL_CODECS_VARS2,
-#define EXTERNAL_CODECS_VARS_L EXTERNAL_CODECS_VARS2_L,
-#define EXTERNAL_CODECS_VARS_G EXTERNAL_CODECS_VARS2_G,
-
-#define DECL_EXTERNAL_CODECS_LOC_VARS2 const CExternalCodecs *__externalCodecs
-#define EXTERNAL_CODECS_LOC_VARS2 __externalCodecs
-
-#define DECL_EXTERNAL_CODECS_LOC_VARS DECL_EXTERNAL_CODECS_LOC_VARS2,
-#define EXTERNAL_CODECS_LOC_VARS EXTERNAL_CODECS_LOC_VARS2,
-
-#else
-
-#define PUBLIC_ISetCompressCodecsInfo
-#define QUERY_ENTRY_ISetCompressCodecsInfo
-#define DECL_ISetCompressCodecsInfo
-#define IMPL_ISetCompressCodecsInfo
-#define EXTERNAL_CODECS_VARS2
-#define DECL_EXTERNAL_CODECS_VARS
-#define EXTERNAL_CODECS_VARS
-#define EXTERNAL_CODECS_VARS_L
-#define EXTERNAL_CODECS_VARS_G
-#define DECL_EXTERNAL_CODECS_LOC_VARS2
-#define EXTERNAL_CODECS_LOC_VARS2
-#define DECL_EXTERNAL_CODECS_LOC_VARS
-#define EXTERNAL_CODECS_LOC_VARS
-
-#endif
-
-int FindMethod_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const AString &name,
- bool encode,
- CMethodId &methodId,
- UInt32 &numStreams);
-
-bool FindMethod(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId,
- AString &name);
-
-bool FindHashMethod(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const AString &name,
- CMethodId &methodId);
-
-void GetHashMethods(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CRecordVector<CMethodId> &methods);
-
-
-struct CCreatedCoder
-{
- CMyComPtr<ICompressCoder> Coder;
- CMyComPtr<ICompressCoder2> Coder2;
-
- bool IsExternal;
- bool IsFilter; // = true, if Coder was created from filter
- UInt32 NumStreams;
-
- // CCreatedCoder(): IsExternal(false), IsFilter(false), NumStreams(1) {}
-};
-
-
-HRESULT CreateCoder_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- unsigned codecIndex, bool encode,
- CMyComPtr<ICompressFilter> &filter,
- CCreatedCoder &cod);
-
-HRESULT CreateCoder_Index(
- DECL_EXTERNAL_CODECS_LOC_VARS
- unsigned index, bool encode,
- CCreatedCoder &cod);
-
-HRESULT CreateCoder_Id(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CMyComPtr<ICompressFilter> &filter,
- CCreatedCoder &cod);
-
-HRESULT CreateCoder_Id(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CCreatedCoder &cod);
-
-HRESULT CreateCoder_Id(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CMyComPtr<ICompressCoder> &coder);
-
-HRESULT CreateFilter(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId, bool encode,
- CMyComPtr<ICompressFilter> &filter);
-
-HRESULT CreateHasher(
- DECL_EXTERNAL_CODECS_LOC_VARS
- CMethodId methodId,
- AString &name,
- CMyComPtr<IHasher> &hasher);
-
-#endif
+// CreateCoder.h
+
+#ifndef ZIP7_INC_CREATE_CODER_H
+#define ZIP7_INC_CREATE_CODER_H
+
+#include "../../Common/MyCom.h"
+#include "../../Common/MyString.h"
+
+#include "../ICoder.h"
+
+#include "MethodId.h"
+
+/*
+ if Z7_EXTERNAL_CODECS is not defined, the code supports only codecs that
+ are statically linked at compile-time and link-time.
+
+ if Z7_EXTERNAL_CODECS is defined, the code supports also codecs from another
+ executable modules, that can be linked dynamically at run-time:
+ - EXE module can use codecs from external DLL files.
+ - DLL module can use codecs from external EXE and DLL files.
+
+ CExternalCodecs contains information about codecs and interfaces to create them.
+
+ The order of codecs:
+ 1) Internal codecs
+ 2) External codecs
+*/
+
+#ifdef Z7_EXTERNAL_CODECS
+
+struct CCodecInfoEx
+{
+ CMethodId Id;
+ AString Name;
+ UInt32 NumStreams;
+ bool EncoderIsAssigned;
+ bool DecoderIsAssigned;
+ bool IsFilter; // it's unused
+
+ CCodecInfoEx(): EncoderIsAssigned(false), DecoderIsAssigned(false), IsFilter(false) {}
+};
+
+struct CHasherInfoEx
+{
+ CMethodId Id;
+ AString Name;
+};
+
+#define Z7_PUBLIC_ISetCompressCodecsInfo_IFEC \
+ public ISetCompressCodecsInfo,
+#define Z7_COM_QI_ENTRY_ISetCompressCodecsInfo_IFEC \
+ Z7_COM_QI_ENTRY(ISetCompressCodecsInfo)
+#define DECL_ISetCompressCodecsInfo \
+ Z7_COM7F_IMP(SetCompressCodecsInfo(ICompressCodecsInfo *compressCodecsInfo))
+#define IMPL_ISetCompressCodecsInfo2(cls) \
+ Z7_COM7F_IMF(cls::SetCompressCodecsInfo(ICompressCodecsInfo *compressCodecsInfo)) \
+ { COM_TRY_BEGIN _externalCodecs.GetCodecs = compressCodecsInfo; \
+ return _externalCodecs.Load(); COM_TRY_END }
+#define IMPL_ISetCompressCodecsInfo IMPL_ISetCompressCodecsInfo2(CHandler)
+
+struct CExternalCodecs
+{
+ CMyComPtr<ICompressCodecsInfo> GetCodecs;
+ CMyComPtr<IHashers> GetHashers;
+
+ CObjectVector<CCodecInfoEx> Codecs;
+ CObjectVector<CHasherInfoEx> Hashers;
+
+ bool IsSet() const { return GetCodecs != NULL || GetHashers != NULL; }
+
+ HRESULT Load();
+
+ void ClearAndRelease()
+ {
+ Hashers.Clear();
+ Codecs.Clear();
+ GetHashers.Release();
+ GetCodecs.Release();
+ }
+
+ ~CExternalCodecs()
+ {
+ GetHashers.Release();
+ GetCodecs.Release();
+ }
+};
+
+extern CExternalCodecs g_ExternalCodecs;
+
+#define EXTERNAL_CODECS_VARS2 (_externalCodecs.IsSet() ? &_externalCodecs : &g_ExternalCodecs)
+#define EXTERNAL_CODECS_VARS2_L (&_externalCodecs)
+#define EXTERNAL_CODECS_VARS2_G (&g_ExternalCodecs)
+
+#define DECL_EXTERNAL_CODECS_VARS CExternalCodecs _externalCodecs;
+
+#define EXTERNAL_CODECS_VARS EXTERNAL_CODECS_VARS2,
+#define EXTERNAL_CODECS_VARS_L EXTERNAL_CODECS_VARS2_L,
+#define EXTERNAL_CODECS_VARS_G EXTERNAL_CODECS_VARS2_G,
+
+#define DECL_EXTERNAL_CODECS_LOC_VARS2 const CExternalCodecs *_externalCodecs
+#define DECL_EXTERNAL_CODECS_LOC_VARS DECL_EXTERNAL_CODECS_LOC_VARS2,
+#define DECL_EXTERNAL_CODECS_LOC_VARS_DECL DECL_EXTERNAL_CODECS_LOC_VARS2;
+
+#define EXTERNAL_CODECS_LOC_VARS2 _externalCodecs
+#define EXTERNAL_CODECS_LOC_VARS EXTERNAL_CODECS_LOC_VARS2,
+
+#else
+
+#define Z7_PUBLIC_ISetCompressCodecsInfo_IFEC
+#define Z7_COM_QI_ENTRY_ISetCompressCodecsInfo_IFEC
+#define DECL_ISetCompressCodecsInfo
+#define IMPL_ISetCompressCodecsInfo
+#define EXTERNAL_CODECS_VARS2
+#define DECL_EXTERNAL_CODECS_VARS
+#define EXTERNAL_CODECS_VARS
+#define EXTERNAL_CODECS_VARS_L
+#define EXTERNAL_CODECS_VARS_G
+#define DECL_EXTERNAL_CODECS_LOC_VARS2
+#define DECL_EXTERNAL_CODECS_LOC_VARS
+#define DECL_EXTERNAL_CODECS_LOC_VARS_DECL
+#define EXTERNAL_CODECS_LOC_VARS2
+#define EXTERNAL_CODECS_LOC_VARS
+
+#endif
+
+int FindMethod_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const AString &name,
+ bool encode,
+ CMethodId &methodId,
+ UInt32 &numStreams,
+ bool &isFilter);
+
+bool FindMethod(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId,
+ AString &name);
+
+bool FindHashMethod(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const AString &name,
+ CMethodId &methodId);
+
+void GetHashMethods(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CRecordVector<CMethodId> &methods);
+
+
+struct CCreatedCoder
+{
+ CMyComPtr<ICompressCoder> Coder;
+ CMyComPtr<ICompressCoder2> Coder2;
+
+ bool IsExternal;
+ bool IsFilter; // = true, if Coder was created from filter
+ UInt32 NumStreams;
+
+ // CCreatedCoder(): IsExternal(false), IsFilter(false), NumStreams(1) {}
+};
+
+
+HRESULT CreateCoder_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ unsigned codecIndex, bool encode,
+ CMyComPtr<ICompressFilter> &filter,
+ CCreatedCoder &cod);
+
+HRESULT CreateCoder_Index(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ unsigned index, bool encode,
+ CCreatedCoder &cod);
+
+HRESULT CreateCoder_Id(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CMyComPtr<ICompressFilter> &filter,
+ CCreatedCoder &cod);
+
+HRESULT CreateCoder_Id(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CCreatedCoder &cod);
+
+HRESULT CreateCoder_Id(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CMyComPtr<ICompressCoder> &coder);
+
+HRESULT CreateFilter(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId, bool encode,
+ CMyComPtr<ICompressFilter> &filter);
+
+HRESULT CreateHasher(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ CMethodId methodId,
+ AString &name,
+ CMyComPtr<IHasher> &hasher);
+
+#endif
diff --git a/CPP/7zip/Common/FilePathAutoRename.cpp b/CPP/7zip/Common/FilePathAutoRename.cpp
index 84c9e2b..1ebfd72 100644
--- a/CPP/7zip/Common/FilePathAutoRename.cpp
+++ b/CPP/7zip/Common/FilePathAutoRename.cpp
@@ -1,46 +1,46 @@
-// FilePathAutoRename.cpp
-
-#include "StdAfx.h"
-
-#include "../../Windows/FileFind.h"
-
-#include "FilePathAutoRename.h"
-
-using namespace NWindows;
-
-static bool MakeAutoName(const FString &name,
- const FString &extension, UInt32 value, FString &path)
-{
- path = name;
- path.Add_UInt32(value);
- path += extension;
- return NFile::NFind::DoesFileOrDirExist(path);
-}
-
-bool AutoRenamePath(FString &path)
-{
- int dotPos = path.ReverseFind_Dot();
- int slashPos = path.ReverseFind_PathSepar();
-
- FString name = path;
- FString extension;
- if (dotPos > slashPos + 1)
- {
- name.DeleteFrom(dotPos);
- extension = path.Ptr(dotPos);
- }
- name += '_';
-
- FString temp;
-
- UInt32 left = 1, right = ((UInt32)1 << 30);
- while (left != right)
- {
- UInt32 mid = (left + right) / 2;
- if (MakeAutoName(name, extension, mid, temp))
- left = mid + 1;
- else
- right = mid;
- }
- return !MakeAutoName(name, extension, right, path);
-}
+// FilePathAutoRename.cpp
+
+#include "StdAfx.h"
+
+#include "../../Windows/FileFind.h"
+
+#include "FilePathAutoRename.h"
+
+using namespace NWindows;
+
+static bool MakeAutoName(const FString &name,
+ const FString &extension, UInt32 value, FString &path)
+{
+ path = name;
+ path.Add_UInt32(value);
+ path += extension;
+ return NFile::NFind::DoesFileOrDirExist(path);
+}
+
+bool AutoRenamePath(FString &path)
+{
+ int dotPos = path.ReverseFind_Dot();
+ int slashPos = path.ReverseFind_PathSepar();
+
+ FString name = path;
+ FString extension;
+ if (dotPos > slashPos + 1)
+ {
+ name.DeleteFrom((unsigned)dotPos);
+ extension = path.Ptr((unsigned)dotPos);
+ }
+ name += '_';
+
+ FString temp;
+
+ UInt32 left = 1, right = ((UInt32)1 << 30);
+ while (left != right)
+ {
+ UInt32 mid = (left + right) / 2;
+ if (MakeAutoName(name, extension, mid, temp))
+ left = mid + 1;
+ else
+ right = mid;
+ }
+ return !MakeAutoName(name, extension, right, path);
+}
diff --git a/CPP/7zip/Common/FilePathAutoRename.h b/CPP/7zip/Common/FilePathAutoRename.h
index cb2d71b..ac36882 100644
--- a/CPP/7zip/Common/FilePathAutoRename.h
+++ b/CPP/7zip/Common/FilePathAutoRename.h
@@ -1,10 +1,10 @@
-// FilePathAutoRename.h
-
-#ifndef __FILE_PATH_AUTO_RENAME_H
-#define __FILE_PATH_AUTO_RENAME_H
-
-#include "../../Common/MyString.h"
-
-bool AutoRenamePath(FString &fullProcessedPath);
-
-#endif
+// FilePathAutoRename.h
+
+#ifndef ZIP7_INC_FILE_PATH_AUTO_RENAME_H
+#define ZIP7_INC_FILE_PATH_AUTO_RENAME_H
+
+#include "../../Common/MyString.h"
+
+bool AutoRenamePath(FString &fullProcessedPath);
+
+#endif
diff --git a/CPP/7zip/Common/FileStreams.cpp b/CPP/7zip/Common/FileStreams.cpp
index 11c14d2..4298636 100644
--- a/CPP/7zip/Common/FileStreams.cpp
+++ b/CPP/7zip/Common/FileStreams.cpp
@@ -1,475 +1,800 @@
-// FileStreams.cpp
-
-#include "StdAfx.h"
-
-#ifndef _WIN32
-#include <fcntl.h>
-#include <unistd.h>
-#include <errno.h>
-#endif
-
-#ifdef SUPPORT_DEVICE_FILE
-#include "../../../C/Alloc.h"
-#include "../../Common/Defs.h"
-#endif
-
-#include "FileStreams.h"
-
-static inline HRESULT ConvertBoolToHRESULT(bool result)
-{
- #ifdef _WIN32
- if (result)
- return S_OK;
- DWORD lastError = ::GetLastError();
- if (lastError == 0)
- return E_FAIL;
- return HRESULT_FROM_WIN32(lastError);
- #else
- return result ? S_OK: E_FAIL;
- #endif
-}
-
-
-static const UInt32 kClusterSize = 1 << 18;
-CInFileStream::CInFileStream():
- #ifdef SUPPORT_DEVICE_FILE
- VirtPos(0),
- PhyPos(0),
- Buf(0),
- BufSize(0),
- #endif
- SupportHardLinks(false),
- Callback(NULL),
- CallbackRef(0)
-{
-}
-
-CInFileStream::~CInFileStream()
-{
- #ifdef SUPPORT_DEVICE_FILE
- MidFree(Buf);
- #endif
-
- if (Callback)
- Callback->InFileStream_On_Destroy(CallbackRef);
-}
-
-STDMETHODIMP CInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- #ifdef USE_WIN_FILE
-
- #ifdef SUPPORT_DEVICE_FILE
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- if (File.IsDeviceFile)
- {
- if (File.SizeDefined)
- {
- if (VirtPos >= File.Size)
- return VirtPos == File.Size ? S_OK : E_FAIL;
- UInt64 rem = File.Size - VirtPos;
- if (size > rem)
- size = (UInt32)rem;
- }
- for (;;)
- {
- const UInt32 mask = kClusterSize - 1;
- const UInt64 mask2 = ~(UInt64)mask;
- UInt64 alignedPos = VirtPos & mask2;
- if (BufSize > 0 && BufStartPos == alignedPos)
- {
- UInt32 pos = (UInt32)VirtPos & mask;
- if (pos >= BufSize)
- return S_OK;
- UInt32 rem = MyMin(BufSize - pos, size);
- memcpy(data, Buf + pos, rem);
- VirtPos += rem;
- if (processedSize)
- *processedSize += rem;
- return S_OK;
- }
-
- bool useBuf = false;
- if ((VirtPos & mask) != 0 || ((ptrdiff_t)data & mask) != 0 )
- useBuf = true;
- else
- {
- UInt64 end = VirtPos + size;
- if ((end & mask) != 0)
- {
- end &= mask2;
- if (end <= VirtPos)
- useBuf = true;
- else
- size = (UInt32)(end - VirtPos);
- }
- }
- if (!useBuf)
- break;
- if (alignedPos != PhyPos)
- {
- UInt64 realNewPosition;
- bool result = File.Seek(alignedPos, FILE_BEGIN, realNewPosition);
- if (!result)
- return ConvertBoolToHRESULT(result);
- PhyPos = realNewPosition;
- }
-
- BufStartPos = alignedPos;
- UInt32 readSize = kClusterSize;
- if (File.SizeDefined)
- readSize = (UInt32)MyMin(File.Size - PhyPos, (UInt64)kClusterSize);
-
- if (!Buf)
- {
- Buf = (Byte *)MidAlloc(kClusterSize);
- if (!Buf)
- return E_OUTOFMEMORY;
- }
- bool result = File.Read1(Buf, readSize, BufSize);
- if (!result)
- return ConvertBoolToHRESULT(result);
-
- if (BufSize == 0)
- return S_OK;
- PhyPos += BufSize;
- }
-
- if (VirtPos != PhyPos)
- {
- UInt64 realNewPosition;
- bool result = File.Seek(VirtPos, FILE_BEGIN, realNewPosition);
- if (!result)
- return ConvertBoolToHRESULT(result);
- PhyPos = VirtPos = realNewPosition;
- }
- }
- #endif
-
- UInt32 realProcessedSize;
- bool result = File.ReadPart(data, size, realProcessedSize);
- if (processedSize)
- *processedSize = realProcessedSize;
-
- #ifdef SUPPORT_DEVICE_FILE
- VirtPos += realProcessedSize;
- PhyPos += realProcessedSize;
- #endif
-
- if (result)
- return S_OK;
-
- {
- DWORD error = ::GetLastError();
-
- if (Callback)
- return Callback->InFileStream_On_Error(CallbackRef, error);
- if (error == 0)
- return E_FAIL;
-
- return HRESULT_FROM_WIN32(error);
- }
-
- #else
-
- if (processedSize)
- *processedSize = 0;
- ssize_t res = File.Read(data, (size_t)size);
- if (res == -1)
- {
- if (Callback)
- return Callback->InFileStream_On_Error(CallbackRef, E_FAIL);
- return E_FAIL;
- }
- if (processedSize)
- *processedSize = (UInt32)res;
- return S_OK;
-
- #endif
-}
-
-#ifdef UNDER_CE
-STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- size_t s2 = fread(data, 1, size, stdin);
- int error = ferror(stdin);
- if (processedSize)
- *processedSize = s2;
- if (s2 <= size && error == 0)
- return S_OK;
- return E_FAIL;
-}
-#else
-STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- #ifdef _WIN32
-
- DWORD realProcessedSize;
- UInt32 sizeTemp = (1 << 20);
- if (sizeTemp > size)
- sizeTemp = size;
- BOOL res = ::ReadFile(GetStdHandle(STD_INPUT_HANDLE), data, sizeTemp, &realProcessedSize, NULL);
- if (processedSize)
- *processedSize = realProcessedSize;
- if (res == FALSE && GetLastError() == ERROR_BROKEN_PIPE)
- return S_OK;
- return ConvertBoolToHRESULT(res != FALSE);
-
- #else
-
- if (processedSize)
- *processedSize = 0;
- ssize_t res;
- do
- {
- res = read(0, data, (size_t)size);
- }
- while (res < 0 && (errno == EINTR));
- if (res == -1)
- return E_FAIL;
- if (processedSize)
- *processedSize = (UInt32)res;
- return S_OK;
-
- #endif
-}
-
-#endif
-
-STDMETHODIMP CInFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- if (seekOrigin >= 3)
- return STG_E_INVALIDFUNCTION;
-
- #ifdef USE_WIN_FILE
-
- #ifdef SUPPORT_DEVICE_FILE
- if (File.IsDeviceFile && (File.SizeDefined || seekOrigin != STREAM_SEEK_END))
- {
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += VirtPos; break;
- case STREAM_SEEK_END: offset += File.Size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- VirtPos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
- }
- #endif
-
- UInt64 realNewPosition;
- bool result = File.Seek(offset, seekOrigin, realNewPosition);
-
- #ifdef SUPPORT_DEVICE_FILE
- PhyPos = VirtPos = realNewPosition;
- #endif
-
- if (newPosition)
- *newPosition = realNewPosition;
- return ConvertBoolToHRESULT(result);
-
- #else
-
- off_t res = File.Seek((off_t)offset, seekOrigin);
- if (res == -1)
- return E_FAIL;
- if (newPosition)
- *newPosition = (UInt64)res;
- return S_OK;
-
- #endif
-}
-
-STDMETHODIMP CInFileStream::GetSize(UInt64 *size)
-{
- return ConvertBoolToHRESULT(File.GetLength(*size));
-}
-
-#ifdef USE_WIN_FILE
-
-STDMETHODIMP CInFileStream::GetProps(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib)
-{
- BY_HANDLE_FILE_INFORMATION info;
- if (File.GetFileInformation(&info))
- {
- if (size) *size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
- if (cTime) *cTime = info.ftCreationTime;
- if (aTime) *aTime = info.ftLastAccessTime;
- if (mTime) *mTime = info.ftLastWriteTime;
- if (attrib) *attrib = info.dwFileAttributes;
- return S_OK;
- }
- return GetLastError();
-}
-
-STDMETHODIMP CInFileStream::GetProps2(CStreamFileProps *props)
-{
- BY_HANDLE_FILE_INFORMATION info;
- if (File.GetFileInformation(&info))
- {
- props->Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
- props->VolID = info.dwVolumeSerialNumber;
- props->FileID_Low = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
- props->FileID_High = 0;
- props->NumLinks = SupportHardLinks ? info.nNumberOfLinks : 1;
- props->Attrib = info.dwFileAttributes;
- props->CTime = info.ftCreationTime;
- props->ATime = info.ftLastAccessTime;
- props->MTime = info.ftLastWriteTime;
- return S_OK;
- }
- return GetLastError();
-}
-
-#endif
-
-//////////////////////////
-// COutFileStream
-
-HRESULT COutFileStream::Close()
-{
- return ConvertBoolToHRESULT(File.Close());
-}
-
-STDMETHODIMP COutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- #ifdef USE_WIN_FILE
-
- UInt32 realProcessedSize;
- bool result = File.Write(data, size, realProcessedSize);
- ProcessedSize += realProcessedSize;
- if (processedSize)
- *processedSize = realProcessedSize;
- return ConvertBoolToHRESULT(result);
-
- #else
-
- if (processedSize)
- *processedSize = 0;
- ssize_t res = File.Write(data, (size_t)size);
- if (res == -1)
- return E_FAIL;
- if (processedSize)
- *processedSize = (UInt32)res;
- ProcessedSize += res;
- return S_OK;
-
- #endif
-}
-
-STDMETHODIMP COutFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- if (seekOrigin >= 3)
- return STG_E_INVALIDFUNCTION;
-
- #ifdef USE_WIN_FILE
-
- UInt64 realNewPosition;
- bool result = File.Seek(offset, seekOrigin, realNewPosition);
- if (newPosition)
- *newPosition = realNewPosition;
- return ConvertBoolToHRESULT(result);
-
- #else
-
- off_t res = File.Seek((off_t)offset, seekOrigin);
- if (res == -1)
- return E_FAIL;
- if (newPosition)
- *newPosition = (UInt64)res;
- return S_OK;
-
- #endif
-}
-
-STDMETHODIMP COutFileStream::SetSize(UInt64 newSize)
-{
- #ifdef USE_WIN_FILE
-
- UInt64 currentPos;
- if (!File.Seek(0, FILE_CURRENT, currentPos))
- return E_FAIL;
- bool result = File.SetLength(newSize);
- UInt64 currentPos2;
- result = result && File.Seek(currentPos, currentPos2);
- return result ? S_OK : E_FAIL;
-
- #else
-
- return E_FAIL;
-
- #endif
-}
-
-HRESULT COutFileStream::GetSize(UInt64 *size)
-{
- return ConvertBoolToHRESULT(File.GetLength(*size));
-}
-
-#ifdef UNDER_CE
-
-STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- size_t s2 = fwrite(data, 1, size, stdout);
- if (processedSize)
- *processedSize = s2;
- return (s2 == size) ? S_OK : E_FAIL;
-}
-
-#else
-
-STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- #ifdef _WIN32
-
- UInt32 realProcessedSize;
- BOOL res = TRUE;
- if (size > 0)
- {
- // Seems that Windows doesn't like big amounts writing to stdout.
- // So we limit portions by 32KB.
- UInt32 sizeTemp = (1 << 15);
- if (sizeTemp > size)
- sizeTemp = size;
- res = ::WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
- data, sizeTemp, (DWORD *)&realProcessedSize, NULL);
- _size += realProcessedSize;
- size -= realProcessedSize;
- data = (const void *)((const Byte *)data + realProcessedSize);
- if (processedSize)
- *processedSize += realProcessedSize;
- }
- return ConvertBoolToHRESULT(res != FALSE);
-
- #else
-
- ssize_t res;
-
- do
- {
- res = write(1, data, (size_t)size);
- }
- while (res < 0 && (errno == EINTR));
-
- if (res == -1)
- return E_FAIL;
-
- _size += (size_t)res;
- if (processedSize)
- *processedSize = (UInt32)res;
- return S_OK;
-
- #endif
-}
-
-#endif
+// FileStreams.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#ifndef _WIN32
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <grp.h>
+#include <pwd.h>
+
+// for major()/minor():
+#include <sys/types.h>
+#if defined(__FreeBSD__) || defined(BSD) || defined(__APPLE__)
+#else
+#ifndef major
+#include <sys/sysmacros.h>
+#endif
+#endif
+
+#endif // _WIN32
+
+#include "../../Windows/FileFind.h"
+
+#ifdef Z7_DEVICE_FILE
+#include "../../../C/Alloc.h"
+#include "../../Common/Defs.h"
+#endif
+
+#include "../PropID.h"
+
+#include "FileStreams.h"
+
+static inline HRESULT GetLastError_HRESULT()
+{
+ DWORD lastError = ::GetLastError();
+ if (lastError == 0)
+ return E_FAIL;
+ return HRESULT_FROM_WIN32(lastError);
+}
+
+static inline HRESULT ConvertBoolToHRESULT(bool result)
+{
+ if (result)
+ return S_OK;
+ return GetLastError_HRESULT();
+}
+
+
+#ifdef Z7_DEVICE_FILE
+static const UInt32 kClusterSize = 1 << 18;
+#endif
+
+CInFileStream::CInFileStream():
+ #ifdef Z7_DEVICE_FILE
+ VirtPos(0),
+ PhyPos(0),
+ Buf(NULL),
+ BufSize(0),
+ #endif
+ #ifndef _WIN32
+ _uid(0),
+ _gid(0),
+ StoreOwnerId(false),
+ StoreOwnerName(false),
+ #endif
+ _info_WasLoaded(false),
+ SupportHardLinks(false),
+ Callback(NULL),
+ CallbackRef(0)
+{
+}
+
+CInFileStream::~CInFileStream()
+{
+ #ifdef Z7_DEVICE_FILE
+ MidFree(Buf);
+ #endif
+
+ if (Callback)
+ Callback->InFileStream_On_Destroy(this, CallbackRef);
+}
+
+Z7_COM7F_IMF(CInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ #ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+
+ #ifdef Z7_DEVICE_FILE
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (File.IsDeviceFile)
+ {
+ if (File.SizeDefined)
+ {
+ if (VirtPos >= File.Size)
+ return VirtPos == File.Size ? S_OK : E_FAIL;
+ const UInt64 rem = File.Size - VirtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ for (;;)
+ {
+ const UInt32 mask = kClusterSize - 1;
+ const UInt64 mask2 = ~(UInt64)mask;
+ const UInt64 alignedPos = VirtPos & mask2;
+ if (BufSize > 0 && BufStartPos == alignedPos)
+ {
+ const UInt32 pos = (UInt32)VirtPos & mask;
+ if (pos >= BufSize)
+ return S_OK;
+ const UInt32 rem = MyMin(BufSize - pos, size);
+ memcpy(data, Buf + pos, rem);
+ VirtPos += rem;
+ if (processedSize)
+ *processedSize += rem;
+ return S_OK;
+ }
+
+ bool useBuf = false;
+ if ((VirtPos & mask) != 0 || ((size_t)(ptrdiff_t)data & mask) != 0 )
+ useBuf = true;
+ else
+ {
+ UInt64 end = VirtPos + size;
+ if ((end & mask) != 0)
+ {
+ end &= mask2;
+ if (end <= VirtPos)
+ useBuf = true;
+ else
+ size = (UInt32)(end - VirtPos);
+ }
+ }
+ if (!useBuf)
+ break;
+ if (alignedPos != PhyPos)
+ {
+ UInt64 realNewPosition;
+ const bool result = File.Seek((Int64)alignedPos, FILE_BEGIN, realNewPosition);
+ if (!result)
+ return ConvertBoolToHRESULT(result);
+ PhyPos = realNewPosition;
+ }
+
+ BufStartPos = alignedPos;
+ UInt32 readSize = kClusterSize;
+ if (File.SizeDefined)
+ readSize = (UInt32)MyMin(File.Size - PhyPos, (UInt64)kClusterSize);
+
+ if (!Buf)
+ {
+ Buf = (Byte *)MidAlloc(kClusterSize);
+ if (!Buf)
+ return E_OUTOFMEMORY;
+ }
+ const bool result = File.Read1(Buf, readSize, BufSize);
+ if (!result)
+ return ConvertBoolToHRESULT(result);
+
+ if (BufSize == 0)
+ return S_OK;
+ PhyPos += BufSize;
+ }
+
+ if (VirtPos != PhyPos)
+ {
+ UInt64 realNewPosition;
+ bool result = File.Seek((Int64)VirtPos, FILE_BEGIN, realNewPosition);
+ if (!result)
+ return ConvertBoolToHRESULT(result);
+ PhyPos = VirtPos = realNewPosition;
+ }
+ }
+ #endif
+
+ UInt32 realProcessedSize;
+ const bool result = File.ReadPart(data, size, realProcessedSize);
+ if (processedSize)
+ *processedSize = realProcessedSize;
+
+ #ifdef Z7_DEVICE_FILE
+ VirtPos += realProcessedSize;
+ PhyPos += realProcessedSize;
+ #endif
+
+ if (result)
+ return S_OK;
+
+ #else // Z7_FILE_STREAMS_USE_WIN_FILE
+
+ if (processedSize)
+ *processedSize = 0;
+ const ssize_t res = File.read_part(data, (size_t)size);
+ if (res != -1)
+ {
+ if (processedSize)
+ *processedSize = (UInt32)res;
+ return S_OK;
+ }
+ #endif // Z7_FILE_STREAMS_USE_WIN_FILE
+
+ {
+ const DWORD error = ::GetLastError();
+ if (Callback)
+ return Callback->InFileStream_On_Error(CallbackRef, error);
+ if (error == 0)
+ return E_FAIL;
+ return HRESULT_FROM_WIN32(error);
+ }
+}
+
+#ifdef UNDER_CE
+Z7_COM7F_IMF(CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ size_t s2 = fread(data, 1, size, stdin);
+ int error = ferror(stdin);
+ if (processedSize)
+ *processedSize = s2;
+ if (s2 <= size && error == 0)
+ return S_OK;
+ return E_FAIL;
+}
+#else
+Z7_COM7F_IMF(CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ #ifdef _WIN32
+
+ DWORD realProcessedSize;
+ UInt32 sizeTemp = (1 << 20);
+ if (sizeTemp > size)
+ sizeTemp = size;
+ BOOL res = ::ReadFile(GetStdHandle(STD_INPUT_HANDLE), data, sizeTemp, &realProcessedSize, NULL);
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ if (res == FALSE && GetLastError() == ERROR_BROKEN_PIPE)
+ return S_OK;
+ return ConvertBoolToHRESULT(res != FALSE);
+
+ #else
+
+ if (processedSize)
+ *processedSize = 0;
+ ssize_t res;
+ do
+ {
+ res = read(0, data, (size_t)size);
+ }
+ while (res < 0 && (errno == EINTR));
+ if (res == -1)
+ return GetLastError_HRESULT();
+ if (processedSize)
+ *processedSize = (UInt32)res;
+ return S_OK;
+
+ #endif
+}
+
+#endif
+
+Z7_COM7F_IMF(CInFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ if (seekOrigin >= 3)
+ return STG_E_INVALIDFUNCTION;
+
+ #ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+
+ #ifdef Z7_DEVICE_FILE
+ if (File.IsDeviceFile && (File.SizeDefined || seekOrigin != STREAM_SEEK_END))
+ {
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += VirtPos; break;
+ case STREAM_SEEK_END: offset += File.Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ VirtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+ }
+ #endif
+
+ UInt64 realNewPosition = 0;
+ const bool result = File.Seek(offset, seekOrigin, realNewPosition);
+ const HRESULT hres = ConvertBoolToHRESULT(result);
+
+ /* 21.07: new File.Seek() in 21.07 already returns correct (realNewPosition)
+ in case of error. So we don't need additional code below */
+ // if (!result) { realNewPosition = 0; File.GetPosition(realNewPosition); }
+
+ #ifdef Z7_DEVICE_FILE
+ PhyPos = VirtPos = realNewPosition;
+ #endif
+
+ if (newPosition)
+ *newPosition = realNewPosition;
+
+ return hres;
+
+ #else
+
+ const off_t res = File.seek((off_t)offset, (int)seekOrigin);
+ if (res == -1)
+ {
+ const HRESULT hres = GetLastError_HRESULT();
+ if (newPosition)
+ *newPosition = (UInt64)File.seekToCur();
+ return hres;
+ }
+ if (newPosition)
+ *newPosition = (UInt64)res;
+ return S_OK;
+
+ #endif
+}
+
+Z7_COM7F_IMF(CInFileStream::GetSize(UInt64 *size))
+{
+ return ConvertBoolToHRESULT(File.GetLength(*size));
+}
+
+#ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+
+Z7_COM7F_IMF(CInFileStream::GetProps(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib))
+{
+ if (!_info_WasLoaded)
+ {
+ RINOK(ReloadProps())
+ }
+ const BY_HANDLE_FILE_INFORMATION &info = _info;
+ /*
+ BY_HANDLE_FILE_INFORMATION info;
+ if (!File.GetFileInformation(&info))
+ return GetLastError_HRESULT();
+ */
+ {
+ if (size) *size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+ if (cTime) *cTime = info.ftCreationTime;
+ if (aTime) *aTime = info.ftLastAccessTime;
+ if (mTime) *mTime = info.ftLastWriteTime;
+ if (attrib) *attrib = info.dwFileAttributes;
+ return S_OK;
+ }
+}
+
+Z7_COM7F_IMF(CInFileStream::GetProps2(CStreamFileProps *props))
+{
+ if (!_info_WasLoaded)
+ {
+ RINOK(ReloadProps())
+ }
+ const BY_HANDLE_FILE_INFORMATION &info = _info;
+ /*
+ BY_HANDLE_FILE_INFORMATION info;
+ if (!File.GetFileInformation(&info))
+ return GetLastError_HRESULT();
+ */
+ {
+ props->Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+ props->VolID = info.dwVolumeSerialNumber;
+ props->FileID_Low = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
+ props->FileID_High = 0;
+ props->NumLinks = SupportHardLinks ? info.nNumberOfLinks : 1;
+ props->Attrib = info.dwFileAttributes;
+ props->CTime = info.ftCreationTime;
+ props->ATime = info.ftLastAccessTime;
+ props->MTime = info.ftLastWriteTime;
+ return S_OK;
+ }
+}
+
+Z7_COM7F_IMF(CInFileStream::GetProperty(PROPID propID, PROPVARIANT *value))
+{
+ if (!_info_WasLoaded)
+ {
+ RINOK(ReloadProps())
+ }
+
+ if (!_info_WasLoaded)
+ return S_OK;
+
+ NWindows::NCOM::CPropVariant prop;
+
+ #ifdef Z7_DEVICE_FILE
+ if (File.IsDeviceFile)
+ {
+ switch (propID)
+ {
+ case kpidSize:
+ if (File.SizeDefined)
+ prop = File.Size;
+ break;
+ // case kpidAttrib: prop = (UInt32)0; break;
+ case kpidPosixAttrib:
+ {
+ prop = (UInt32)NWindows::NFile::NFind::NAttributes::
+ Get_PosixMode_From_WinAttrib(0);
+ /* GNU TAR by default can't extract file with MY_LIN_S_IFBLK attribute
+ so we don't use MY_LIN_S_IFBLK here */
+ // prop = (UInt32)(MY_LIN_S_IFBLK | 0600); // for debug
+ break;
+ }
+ /*
+ case kpidDeviceMajor:
+ prop = (UInt32)8; // id for SCSI type device (sda)
+ break;
+ case kpidDeviceMinor:
+ prop = (UInt32)0;
+ break;
+ */
+ }
+ }
+ else
+ #endif
+ {
+ switch (propID)
+ {
+ case kpidSize:
+ {
+ const UInt64 size = (((UInt64)_info.nFileSizeHigh) << 32) + _info.nFileSizeLow;
+ prop = size;
+ break;
+ }
+ case kpidAttrib: prop = (UInt32)_info.dwFileAttributes; break;
+ case kpidCTime: PropVariant_SetFrom_FiTime(prop, _info.ftCreationTime); break;
+ case kpidATime: PropVariant_SetFrom_FiTime(prop, _info.ftLastAccessTime); break;
+ case kpidMTime: PropVariant_SetFrom_FiTime(prop, _info.ftLastWriteTime); break;
+ case kpidPosixAttrib:
+ prop = (UInt32)NWindows::NFile::NFind::NAttributes::
+ Get_PosixMode_From_WinAttrib(_info.dwFileAttributes);
+ // | (UInt32)(1 << 21); // for debug
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CInFileStream::ReloadProps())
+{
+ #ifdef Z7_DEVICE_FILE
+ if (File.IsDeviceFile)
+ {
+ memset(&_info, 0, sizeof(_info));
+ if (File.SizeDefined)
+ {
+ _info.nFileSizeHigh = (DWORD)(File.Size >> 32);
+ _info.nFileSizeLow = (DWORD)(File.Size);
+ }
+ _info.nNumberOfLinks = 1;
+ _info_WasLoaded = true;
+ return S_OK;
+ }
+ #endif
+ _info_WasLoaded = File.GetFileInformation(&_info);
+ if (!_info_WasLoaded)
+ return GetLastError_HRESULT();
+ return S_OK;
+}
+
+
+#elif !defined(_WIN32)
+
+Z7_COM7F_IMF(CInFileStream::GetProps(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib))
+{
+ if (!_info_WasLoaded)
+ {
+ RINOK(ReloadProps())
+ }
+ const struct stat &st = _info;
+ /*
+ struct stat st;
+ if (File.my_fstat(&st) != 0)
+ return GetLastError_HRESULT();
+ */
+
+ if (size) *size = (UInt64)st.st_size;
+ if (cTime) FiTime_To_FILETIME (ST_CTIME(st), *cTime);
+ if (aTime) FiTime_To_FILETIME (ST_ATIME(st), *aTime);
+ if (mTime) FiTime_To_FILETIME (ST_MTIME(st), *mTime);
+ if (attrib) *attrib = NWindows::NFile::NFind::Get_WinAttribPosix_From_PosixMode(st.st_mode);
+
+ return S_OK;
+}
+
+// #include <stdio.h>
+
+Z7_COM7F_IMF(CInFileStream::GetProps2(CStreamFileProps *props))
+{
+ if (!_info_WasLoaded)
+ {
+ RINOK(ReloadProps())
+ }
+ const struct stat &st = _info;
+ /*
+ struct stat st;
+ if (File.my_fstat(&st) != 0)
+ return GetLastError_HRESULT();
+ */
+
+ props->Size = (UInt64)st.st_size;
+ /*
+ dev_t stat::st_dev:
+ GCC:Linux long unsigned int : __dev_t
+ Mac: int
+ */
+ props->VolID = (UInt64)(Int64)st.st_dev;
+ props->FileID_Low = st.st_ino;
+ props->FileID_High = 0;
+ props->NumLinks = (UInt32)st.st_nlink; // we reduce to UInt32 from (nlink_t) that is (unsigned long)
+ props->Attrib = NWindows::NFile::NFind::Get_WinAttribPosix_From_PosixMode(st.st_mode);
+
+ FiTime_To_FILETIME (ST_CTIME(st), props->CTime);
+ FiTime_To_FILETIME (ST_ATIME(st), props->ATime);
+ FiTime_To_FILETIME (ST_MTIME(st), props->MTime);
+
+ /*
+ printf("\nGetProps2() NumLinks=%d = st_dev=%d st_ino = %d\n"
+ , (unsigned)(props->NumLinks)
+ , (unsigned)(st.st_dev)
+ , (unsigned)(st.st_ino)
+ );
+ */
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CInFileStream::GetProperty(PROPID propID, PROPVARIANT *value))
+{
+ if (!_info_WasLoaded)
+ {
+ RINOK(ReloadProps())
+ }
+
+ if (!_info_WasLoaded)
+ return S_OK;
+
+ const struct stat &st = _info;
+
+ NWindows::NCOM::CPropVariant prop;
+ {
+ switch (propID)
+ {
+ case kpidSize: prop = (UInt64)st.st_size; break;
+ case kpidAttrib:
+ prop = (UInt32)NWindows::NFile::NFind::Get_WinAttribPosix_From_PosixMode(st.st_mode);
+ break;
+ case kpidCTime: PropVariant_SetFrom_FiTime(prop, ST_CTIME(st)); break;
+ case kpidATime: PropVariant_SetFrom_FiTime(prop, ST_ATIME(st)); break;
+ case kpidMTime: PropVariant_SetFrom_FiTime(prop, ST_MTIME(st)); break;
+ case kpidPosixAttrib: prop = (UInt32)st.st_mode; break;
+
+ #if defined(__APPLE__)
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wsign-conversion"
+ #endif
+
+ case kpidDeviceMajor:
+ {
+ // printf("\nst.st_rdev = %d\n", st.st_rdev);
+ if (S_ISCHR(st.st_mode) ||
+ S_ISBLK(st.st_mode))
+ prop = (UInt32)(major(st.st_rdev)); // + 1000);
+ // prop = (UInt32)12345678; // for debug
+ break;
+ }
+
+ case kpidDeviceMinor:
+ if (S_ISCHR(st.st_mode) ||
+ S_ISBLK(st.st_mode))
+ prop = (UInt32)(minor(st.st_rdev)); // + 100);
+ // prop = (UInt32)(st.st_rdev); // for debug
+ // printf("\nst.st_rdev = %d\n", st.st_rdev);
+ // prop = (UInt32)123456789; // for debug
+ break;
+
+ #if defined(__APPLE__)
+ #pragma GCC diagnostic pop
+ #endif
+
+ /*
+ case kpidDevice:
+ if (S_ISCHR(st.st_mode) ||
+ S_ISBLK(st.st_mode))
+ prop = (UInt64)(st.st_rdev);
+ break;
+ */
+
+ case kpidUserId:
+ {
+ if (StoreOwnerId)
+ prop = (UInt32)st.st_uid;
+ break;
+ }
+ case kpidGroupId:
+ {
+ if (StoreOwnerId)
+ prop = (UInt32)st.st_gid;
+ break;
+ }
+ case kpidUser:
+ {
+ if (StoreOwnerName)
+ {
+ const uid_t uid = st.st_uid;
+ {
+ if (!OwnerName.IsEmpty() && _uid == uid)
+ prop = OwnerName;
+ else
+ {
+ const passwd *pw = getpwuid(uid);
+ if (pw)
+ {
+ // we can use utf-8 here.
+ // prop = pw->pw_name;
+ }
+ }
+ }
+ }
+ break;
+ }
+ case kpidGroup:
+ {
+ if (StoreOwnerName)
+ {
+ const uid_t gid = st.st_gid;
+ {
+ if (!OwnerGroup.IsEmpty() && _gid == gid)
+ prop = OwnerGroup;
+ else
+ {
+ const group *gr = getgrgid(gid);
+ if (gr)
+ {
+ // we can use utf-8 here.
+ // prop = gr->gr_name;
+ }
+ }
+ }
+ }
+ break;
+ }
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CInFileStream::ReloadProps())
+{
+ _info_WasLoaded = (File.my_fstat(&_info) == 0);
+ if (!_info_WasLoaded)
+ return GetLastError_HRESULT();
+ return S_OK;
+}
+
+#endif
+
+
+
+
+//////////////////////////
+// COutFileStream
+
+HRESULT COutFileStream::Close()
+{
+ return ConvertBoolToHRESULT(File.Close());
+}
+
+Z7_COM7F_IMF(COutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ #ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+
+ UInt32 realProcessedSize;
+ const bool result = File.Write(data, size, realProcessedSize);
+ ProcessedSize += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return ConvertBoolToHRESULT(result);
+
+ #else
+
+ if (processedSize)
+ *processedSize = 0;
+ size_t realProcessedSize;
+ const ssize_t res = File.write_full(data, (size_t)size, realProcessedSize);
+ ProcessedSize += realProcessedSize;
+ if (processedSize)
+ *processedSize = (UInt32)realProcessedSize;
+ if (res == -1)
+ return GetLastError_HRESULT();
+ return S_OK;
+
+ #endif
+}
+
+Z7_COM7F_IMF(COutFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ if (seekOrigin >= 3)
+ return STG_E_INVALIDFUNCTION;
+
+ #ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+
+ UInt64 realNewPosition = 0;
+ const bool result = File.Seek(offset, seekOrigin, realNewPosition);
+ if (newPosition)
+ *newPosition = realNewPosition;
+ return ConvertBoolToHRESULT(result);
+
+ #else
+
+ const off_t res = File.seek((off_t)offset, (int)seekOrigin);
+ if (res == -1)
+ return GetLastError_HRESULT();
+ if (newPosition)
+ *newPosition = (UInt64)res;
+ return S_OK;
+
+ #endif
+}
+
+Z7_COM7F_IMF(COutFileStream::SetSize(UInt64 newSize))
+{
+ return ConvertBoolToHRESULT(File.SetLength_KeepPosition(newSize));
+}
+
+HRESULT COutFileStream::GetSize(UInt64 *size)
+{
+ return ConvertBoolToHRESULT(File.GetLength(*size));
+}
+
+#ifdef UNDER_CE
+
+Z7_COM7F_IMF(CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ size_t s2 = fwrite(data, 1, size, stdout);
+ if (processedSize)
+ *processedSize = s2;
+ return (s2 == size) ? S_OK : E_FAIL;
+}
+
+#else
+
+Z7_COM7F_IMF(CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ #ifdef _WIN32
+
+ UInt32 realProcessedSize;
+ BOOL res = TRUE;
+ if (size > 0)
+ {
+ // Seems that Windows doesn't like big amounts writing to stdout.
+ // So we limit portions by 32KB.
+ UInt32 sizeTemp = (1 << 15);
+ if (sizeTemp > size)
+ sizeTemp = size;
+ res = ::WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
+ data, sizeTemp, (DWORD *)&realProcessedSize, NULL);
+ _size += realProcessedSize;
+ size -= realProcessedSize;
+ data = (const void *)((const Byte *)data + realProcessedSize);
+ if (processedSize)
+ *processedSize += realProcessedSize;
+ }
+ return ConvertBoolToHRESULT(res != FALSE);
+
+ #else
+
+ ssize_t res;
+
+ do
+ {
+ res = write(1, data, (size_t)size);
+ }
+ while (res < 0 && (errno == EINTR));
+
+ if (res == -1)
+ return GetLastError_HRESULT();
+
+ _size += (size_t)res;
+ if (processedSize)
+ *processedSize = (UInt32)res;
+ return S_OK;
+
+ #endif
+}
+
+#endif
diff --git a/CPP/7zip/Common/FileStreams.h b/CPP/7zip/Common/FileStreams.h
index a0996f8..7e1b086 100644
--- a/CPP/7zip/Common/FileStreams.h
+++ b/CPP/7zip/Common/FileStreams.h
@@ -1,166 +1,186 @@
-// FileStreams.h
-
-#ifndef __FILE_STREAMS_H
-#define __FILE_STREAMS_H
-
-#ifdef _WIN32
-#define USE_WIN_FILE
-#endif
-
-#include "../../Common/MyString.h"
-
-#ifdef USE_WIN_FILE
-#include "../../Windows/FileIO.h"
-#else
-#include "../../Common/C_FileIO.h"
-#endif
-
-#include "../../Common/MyCom.h"
-
-#include "../IStream.h"
-
-#ifdef _WIN32
-typedef UINT_PTR My_UINT_PTR;
-#else
-typedef UINT My_UINT_PTR;
-#endif
-
-struct IInFileStream_Callback
-{
- virtual HRESULT InFileStream_On_Error(My_UINT_PTR val, DWORD error) = 0;
- virtual void InFileStream_On_Destroy(My_UINT_PTR val) = 0;
-};
-
-class CInFileStream:
- public IInStream,
- public IStreamGetSize,
- #ifdef USE_WIN_FILE
- public IStreamGetProps,
- public IStreamGetProps2,
- #endif
- public CMyUnknownImp
-{
-public:
- #ifdef USE_WIN_FILE
- NWindows::NFile::NIO::CInFile File;
-
- #ifdef SUPPORT_DEVICE_FILE
- UInt64 VirtPos;
- UInt64 PhyPos;
- UInt64 BufStartPos;
- Byte *Buf;
- UInt32 BufSize;
- #endif
-
- #else
- NC::NFile::NIO::CInFile File;
- #endif
-
- bool SupportHardLinks;
-
- IInFileStream_Callback *Callback;
- My_UINT_PTR CallbackRef;
-
- virtual ~CInFileStream();
-
- CInFileStream();
-
- bool Open(CFSTR fileName)
- {
- return File.Open(fileName);
- }
-
- bool OpenShared(CFSTR fileName, bool shareForWrite)
- {
- return File.OpenShared(fileName, shareForWrite);
- }
-
- MY_QUERYINTERFACE_BEGIN2(IInStream)
- MY_QUERYINTERFACE_ENTRY(IStreamGetSize)
- #ifdef USE_WIN_FILE
- MY_QUERYINTERFACE_ENTRY(IStreamGetProps)
- MY_QUERYINTERFACE_ENTRY(IStreamGetProps2)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-
- STDMETHOD(GetSize)(UInt64 *size);
- #ifdef USE_WIN_FILE
- STDMETHOD(GetProps)(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib);
- STDMETHOD(GetProps2)(CStreamFileProps *props);
- #endif
-};
-
-class CStdInFileStream:
- public ISequentialInStream,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP
-
- virtual ~CStdInFileStream() {}
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-class COutFileStream:
- public IOutStream,
- public CMyUnknownImp
-{
-public:
- #ifdef USE_WIN_FILE
- NWindows::NFile::NIO::COutFile File;
- #else
- NC::NFile::NIO::COutFile File;
- #endif
- virtual ~COutFileStream() {}
- bool Create(CFSTR fileName, bool createAlways)
- {
- ProcessedSize = 0;
- return File.Create(fileName, createAlways);
- }
- bool Open(CFSTR fileName, DWORD creationDisposition)
- {
- ProcessedSize = 0;
- return File.Open(fileName, creationDisposition);
- }
-
- HRESULT Close();
-
- UInt64 ProcessedSize;
-
- #ifdef USE_WIN_FILE
- bool SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime)
- {
- return File.SetTime(cTime, aTime, mTime);
- }
- bool SetMTime(const FILETIME *mTime) { return File.SetMTime(mTime); }
- #endif
-
-
- MY_UNKNOWN_IMP1(IOutStream)
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
- STDMETHOD(SetSize)(UInt64 newSize);
-
- HRESULT GetSize(UInt64 *size);
-};
-
-class CStdOutFileStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- UInt64 _size;
-public:
- MY_UNKNOWN_IMP
-
- UInt64 GetSize() const { return _size; }
- CStdOutFileStream(): _size(0) {}
- virtual ~CStdOutFileStream() {}
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-#endif
+// FileStreams.h
+
+#ifndef ZIP7_INC_FILE_STREAMS_H
+#define ZIP7_INC_FILE_STREAMS_H
+
+#ifdef _WIN32
+#define Z7_FILE_STREAMS_USE_WIN_FILE
+#endif
+
+#include "../../Common/MyCom.h"
+#include "../../Common/MyString.h"
+
+#include "../../Windows/FileIO.h"
+
+#include "../IStream.h"
+
+#include "UniqBlocks.h"
+
+
+class CInFileStream;
+
+Z7_PURE_INTERFACES_BEGIN
+DECLARE_INTERFACE(IInFileStream_Callback)
+{
+ virtual HRESULT InFileStream_On_Error(UINT_PTR val, DWORD error) = 0;
+ virtual void InFileStream_On_Destroy(CInFileStream *stream, UINT_PTR val) = 0;
+};
+Z7_PURE_INTERFACES_END
+
+
+/*
+Z7_CLASS_IMP_COM_5(
+ CInFileStream
+ , IInStream
+ , IStreamGetSize
+ , IStreamGetProps
+ , IStreamGetProps2
+ , IStreamGetProp
+)
+*/
+Z7_class_final(CInFileStream) :
+ public IInStream,
+ public IStreamGetSize,
+ public IStreamGetProps,
+ public IStreamGetProps2,
+ public IStreamGetProp,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_5(
+ IInStream,
+ IStreamGetSize,
+ IStreamGetProps,
+ IStreamGetProps2,
+ IStreamGetProp)
+
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+ Z7_IFACE_COM7_IMP(IInStream)
+public:
+ Z7_IFACE_COM7_IMP(IStreamGetSize)
+private:
+ Z7_IFACE_COM7_IMP(IStreamGetProps)
+public:
+ Z7_IFACE_COM7_IMP(IStreamGetProps2)
+ Z7_IFACE_COM7_IMP(IStreamGetProp)
+
+private:
+ NWindows::NFile::NIO::CInFile File;
+public:
+
+ #ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+
+ #ifdef Z7_DEVICE_FILE
+ UInt64 VirtPos;
+ UInt64 PhyPos;
+ UInt64 BufStartPos;
+ Byte *Buf;
+ UInt32 BufSize;
+ #endif
+
+ #endif
+
+ #ifdef _WIN32
+ BY_HANDLE_FILE_INFORMATION _info;
+ #else
+ struct stat _info;
+ UInt32 _uid;
+ UInt32 _gid;
+ UString OwnerName;
+ UString OwnerGroup;
+ bool StoreOwnerId;
+ bool StoreOwnerName;
+ #endif
+
+ bool _info_WasLoaded;
+ bool SupportHardLinks;
+ IInFileStream_Callback *Callback;
+ UINT_PTR CallbackRef;
+
+ CInFileStream();
+ ~CInFileStream();
+
+ void Set_PreserveATime(bool v)
+ {
+ File.PreserveATime = v;
+ }
+
+ bool GetLength(UInt64 &length) const throw()
+ {
+ return File.GetLength(length);
+ }
+
+ bool Open(CFSTR fileName)
+ {
+ _info_WasLoaded = false;
+ return File.Open(fileName);
+ }
+
+ bool OpenShared(CFSTR fileName, bool shareForWrite)
+ {
+ _info_WasLoaded = false;
+ return File.OpenShared(fileName, shareForWrite);
+ }
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CStdInFileStream
+ , ISequentialInStream
+)
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ COutFileStream
+ , IOutStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+public:
+
+ NWindows::NFile::NIO::COutFile File;
+
+ bool Create(CFSTR fileName, bool createAlways)
+ {
+ ProcessedSize = 0;
+ return File.Create(fileName, createAlways);
+ }
+ bool Open(CFSTR fileName, DWORD creationDisposition)
+ {
+ ProcessedSize = 0;
+ return File.Open(fileName, creationDisposition);
+ }
+
+ HRESULT Close();
+
+ UInt64 ProcessedSize;
+
+ bool SetTime(const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+ {
+ return File.SetTime(cTime, aTime, mTime);
+ }
+ bool SetMTime(const CFiTime *mTime) { return File.SetMTime(mTime); }
+
+ bool SeekToBegin_bool()
+ {
+ #ifdef Z7_FILE_STREAMS_USE_WIN_FILE
+ return File.SeekToBegin();
+ #else
+ return File.seekToBegin() == 0;
+ #endif
+ }
+
+ HRESULT GetSize(UInt64 *size);
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CStdOutFileStream
+ , ISequentialOutStream
+)
+ UInt64 _size;
+public:
+ UInt64 GetSize() const { return _size; }
+ CStdOutFileStream(): _size(0) {}
+};
+
+#endif
diff --git a/CPP/7zip/Common/FilterCoder.cpp b/CPP/7zip/Common/FilterCoder.cpp
index d5c7ff0..8d7e0dc 100644
--- a/CPP/7zip/Common/FilterCoder.cpp
+++ b/CPP/7zip/Common/FilterCoder.cpp
@@ -1,435 +1,577 @@
-// FilterCoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/Defs.h"
-
-#include "FilterCoder.h"
-#include "StreamUtils.h"
-
-#ifdef _WIN32
- #define alignedMidBuffer_Alloc g_MidAlloc
-#else
- #define alignedMidBuffer_Alloc g_AlignedAlloc
-#endif
-
-CAlignedMidBuffer::~CAlignedMidBuffer()
-{
- ISzAlloc_Free(&alignedMidBuffer_Alloc, _buf);
-}
-
-void CAlignedMidBuffer::AllocAligned(size_t size)
-{
- ISzAlloc_Free(&alignedMidBuffer_Alloc, _buf);
- _buf = (Byte *)ISzAlloc_Alloc(&alignedMidBuffer_Alloc, size);
-}
-
-/*
- AES filters need 16-bytes alignment for HARDWARE-AES instructions.
- So we call IFilter::Filter(, size), where (size != 16 * N) only for last data block.
-
- AES-CBC filters need data size aligned for 16-bytes.
- So the encoder can add zeros to the end of original stream.
-
- Some filters (BCJ and others) don't process data at the end of stream in some cases.
- So the encoder and decoder write such last bytes without change.
-*/
-
-
-static const UInt32 kBufSize = 1 << 20;
-
-STDMETHODIMP CFilterCoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSize = size; return S_OK; }
-STDMETHODIMP CFilterCoder::SetOutBufSize(UInt32 , UInt32 size) { _outBufSize = size; return S_OK; }
-
-HRESULT CFilterCoder::Alloc()
-{
- UInt32 size = MyMin(_inBufSize, _outBufSize);
- /* minimal bufSize is 16 bytes for AES and IA64 filter.
- bufSize for AES must be aligned for 16 bytes.
- We use (1 << 12) min size to support future aligned filters. */
- const UInt32 kMinSize = 1 << 12;
- size &= ~(UInt32)(kMinSize - 1);
- if (size < kMinSize)
- size = kMinSize;
- if (!_buf || _bufSize != size)
- {
- AllocAligned(size);
- if (!_buf)
- return E_OUTOFMEMORY;
- _bufSize = size;
- }
- return S_OK;
-}
-
-HRESULT CFilterCoder::Init_and_Alloc()
-{
- RINOK(Filter->Init());
- return Alloc();
-}
-
-CFilterCoder::CFilterCoder(bool encodeMode):
- _bufSize(0),
- _inBufSize(kBufSize),
- _outBufSize(kBufSize),
- _encodeMode(encodeMode),
- _outSizeIsDefined(false),
- _outSize(0),
- _nowPos64(0)
- {}
-
-CFilterCoder::~CFilterCoder()
-{
-}
-
-STDMETHODIMP CFilterCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
-{
- RINOK(Init_and_Alloc());
-
- UInt64 nowPos64 = 0;
- bool inputFinished = false;
- UInt32 pos = 0;
-
- while (!outSize || nowPos64 < *outSize)
- {
- UInt32 endPos = pos;
-
- if (!inputFinished)
- {
- size_t processedSize = _bufSize - pos;
- RINOK(ReadStream(inStream, _buf + pos, &processedSize));
- endPos = pos + (UInt32)processedSize;
- inputFinished = (endPos != _bufSize);
- }
-
- pos = Filter->Filter(_buf, endPos);
-
- if (pos > endPos)
- {
- // AES
- if (!inputFinished || pos > _bufSize)
- return E_FAIL;
- if (!_encodeMode)
- return S_FALSE;
-
- do
- _buf[endPos] = 0;
- while (++endPos != pos);
-
- if (pos != Filter->Filter(_buf, pos))
- return E_FAIL;
- }
-
- if (endPos == 0)
- return S_OK;
-
- UInt32 size = (pos != 0 ? pos : endPos);
- if (outSize)
- {
- UInt64 remSize = *outSize - nowPos64;
- if (size > remSize)
- size = (UInt32)remSize;
- }
-
- RINOK(WriteStream(outStream, _buf, size));
- nowPos64 += size;
-
- if (pos == 0)
- return S_OK;
-
- if (progress)
- RINOK(progress->SetRatioInfo(&nowPos64, &nowPos64));
-
- UInt32 i = 0;
- while (pos < endPos)
- _buf[i++] = _buf[pos++];
- pos = i;
- }
-
- return S_OK;
-}
-
-
-
-// ---------- Write to Filter ----------
-
-STDMETHODIMP CFilterCoder::SetOutStream(ISequentialOutStream *outStream)
-{
- _outStream = outStream;
- return S_OK;
-}
-
-STDMETHODIMP CFilterCoder::ReleaseOutStream()
-{
- _outStream.Release();
- return S_OK;
-}
-
-HRESULT CFilterCoder::Flush2()
-{
- while (_convSize != 0)
- {
- UInt32 num = _convSize;
- if (_outSizeIsDefined)
- {
- UInt64 rem = _outSize - _nowPos64;
- if (num > rem)
- num = (UInt32)rem;
- if (num == 0)
- return k_My_HRESULT_WritingWasCut;
- }
-
- UInt32 processed = 0;
- HRESULT res = _outStream->Write(_buf + _convPos, num, &processed);
- if (processed == 0)
- return res != S_OK ? res : E_FAIL;
-
- _convPos += processed;
- _convSize -= processed;
- _nowPos64 += processed;
- RINOK(res);
- }
-
- if (_convPos != 0)
- {
- UInt32 num = _bufPos - _convPos;
- for (UInt32 i = 0; i < num; i++)
- _buf[i] = _buf[_convPos + i];
- _bufPos = num;
- _convPos = 0;
- }
-
- return S_OK;
-}
-
-STDMETHODIMP CFilterCoder::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- while (size != 0)
- {
- RINOK(Flush2());
-
- // _convSize is 0
- // _convPos is 0
- // _bufPos is small
-
- if (_bufPos != _bufSize)
- {
- UInt32 num = MyMin(size, _bufSize - _bufPos);
- memcpy(_buf + _bufPos, data, num);
- size -= num;
- data = (const Byte *)data + num;
- if (processedSize)
- *processedSize += num;
- _bufPos += num;
- if (_bufPos != _bufSize)
- continue;
- }
-
- // _bufPos == _bufSize
- _convSize = Filter->Filter(_buf, _bufPos);
-
- if (_convSize == 0)
- break;
- if (_convSize > _bufPos)
- {
- // that case is not possible.
- _convSize = 0;
- return E_FAIL;
- }
- }
-
- return S_OK;
-}
-
-STDMETHODIMP CFilterCoder::OutStreamFinish()
-{
- for (;;)
- {
- RINOK(Flush2());
- if (_bufPos == 0)
- break;
- _convSize = Filter->Filter(_buf, _bufPos);
- if (_convSize == 0)
- _convSize = _bufPos;
- else if (_convSize > _bufPos)
- {
- // AES
- if (_convSize > _bufSize)
- {
- _convSize = 0;
- return E_FAIL;
- }
- if (!_encodeMode)
- {
- _convSize = 0;
- return S_FALSE;
- }
- for (; _bufPos < _convSize; _bufPos++)
- _buf[_bufPos] = 0;
- _convSize = Filter->Filter(_buf, _bufPos);
- if (_convSize != _bufPos)
- return E_FAIL;
- }
- }
-
- CMyComPtr<IOutStreamFinish> finish;
- _outStream.QueryInterface(IID_IOutStreamFinish, &finish);
- if (finish)
- return finish->OutStreamFinish();
- return S_OK;
-}
-
-// ---------- Init functions ----------
-
-STDMETHODIMP CFilterCoder::InitEncoder()
-{
- InitSpecVars();
- return Init_and_Alloc();
-}
-
-HRESULT CFilterCoder::Init_NoSubFilterInit()
-{
- InitSpecVars();
- return Alloc();
-}
-
-STDMETHODIMP CFilterCoder::SetOutStreamSize(const UInt64 *outSize)
-{
- InitSpecVars();
- if (outSize)
- {
- _outSize = *outSize;
- _outSizeIsDefined = true;
- }
- return Init_and_Alloc();
-}
-
-// ---------- Read from Filter ----------
-
-STDMETHODIMP CFilterCoder::SetInStream(ISequentialInStream *inStream)
-{
- _inStream = inStream;
- return S_OK;
-}
-
-STDMETHODIMP CFilterCoder::ReleaseInStream()
-{
- _inStream.Release();
- return S_OK;
-}
-
-
-STDMETHODIMP CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- while (size != 0)
- {
- if (_convSize != 0)
- {
- if (size > _convSize)
- size = _convSize;
- if (_outSizeIsDefined)
- {
- UInt64 rem = _outSize - _nowPos64;
- if (size > rem)
- size = (UInt32)rem;
- }
- memcpy(data, _buf + _convPos, size);
- _convPos += size;
- _convSize -= size;
- _nowPos64 += size;
- if (processedSize)
- *processedSize = size;
- break;
- }
-
- if (_convPos != 0)
- {
- UInt32 num = _bufPos - _convPos;
- for (UInt32 i = 0; i < num; i++)
- _buf[i] = _buf[_convPos + i];
- _bufPos = num;
- _convPos = 0;
- }
-
- {
- size_t readSize = _bufSize - _bufPos;
- HRESULT res = ReadStream(_inStream, _buf + _bufPos, &readSize);
- _bufPos += (UInt32)readSize;
- RINOK(res);
- }
-
- _convSize = Filter->Filter(_buf, _bufPos);
-
- if (_convSize == 0)
- {
- if (_bufPos == 0)
- break;
- // BCJ
- _convSize = _bufPos;
- continue;
- }
-
- if (_convSize > _bufPos)
- {
- // AES
- if (_convSize > _bufSize)
- return E_FAIL;
- if (!_encodeMode)
- return S_FALSE;
-
- do
- _buf[_bufPos] = 0;
- while (++_bufPos != _convSize);
-
- _convSize = Filter->Filter(_buf, _convSize);
- if (_convSize != _bufPos)
- return E_FAIL;
- }
- }
-
- return S_OK;
-}
-
-
-#ifndef _NO_CRYPTO
-
-STDMETHODIMP CFilterCoder::CryptoSetPassword(const Byte *data, UInt32 size)
- { return _SetPassword->CryptoSetPassword(data, size); }
-
-STDMETHODIMP CFilterCoder::SetKey(const Byte *data, UInt32 size)
- { return _CryptoProperties->SetKey(data, size); }
-
-STDMETHODIMP CFilterCoder::SetInitVector(const Byte *data, UInt32 size)
- { return _CryptoProperties->SetInitVector(data, size); }
-
-#endif
-
-
-#ifndef EXTRACT_ONLY
-
-STDMETHODIMP CFilterCoder::SetCoderProperties(const PROPID *propIDs,
- const PROPVARIANT *properties, UInt32 numProperties)
- { return _SetCoderProperties->SetCoderProperties(propIDs, properties, numProperties); }
-
-STDMETHODIMP CFilterCoder::WriteCoderProperties(ISequentialOutStream *outStream)
- { return _WriteCoderProperties->WriteCoderProperties(outStream); }
-
-/*
-STDMETHODIMP CFilterCoder::ResetSalt()
- { return _CryptoResetSalt->ResetSalt(); }
-*/
-
-STDMETHODIMP CFilterCoder::ResetInitVector()
- { return _CryptoResetInitVector->ResetInitVector(); }
-
-#endif
-
-
-STDMETHODIMP CFilterCoder::SetDecoderProperties2(const Byte *data, UInt32 size)
- { return _SetDecoderProperties2->SetDecoderProperties2(data, size); }
+// FilterCoder.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../Common/Defs.h"
+
+#include "FilterCoder.h"
+#include "StreamUtils.h"
+
+#ifdef _WIN32
+ #define alignedMidBuffer_Alloc g_MidAlloc
+#else
+ #define alignedMidBuffer_Alloc g_AlignedAlloc
+#endif
+
+CAlignedMidBuffer::~CAlignedMidBuffer()
+{
+ ISzAlloc_Free(&alignedMidBuffer_Alloc, _buf);
+}
+
+void CAlignedMidBuffer::AllocAligned(size_t size)
+{
+ ISzAlloc_Free(&alignedMidBuffer_Alloc, _buf);
+ _buf = (Byte *)ISzAlloc_Alloc(&alignedMidBuffer_Alloc, size);
+}
+
+/*
+ AES filters need 16-bytes alignment for HARDWARE-AES instructions.
+ So we call IFilter::Filter(, size), where (size != 16 * N) only for last data block.
+
+ AES-CBC filters need data size aligned for 16-bytes.
+ So the encoder can add zeros to the end of original stream.
+
+ Some filters (BCJ and others) don't process data at the end of stream in some cases.
+ So the encoder and decoder write such last bytes without change.
+
+ Most filters process all data, if we send aligned size to filter.
+ But BCJ filter can process up 4 bytes less than sent size.
+ And ARMT filter can process 2 bytes less than sent size.
+*/
+
+
+static const UInt32 kBufSize = 1 << 21;
+
+Z7_COM7F_IMF(CFilterCoder::SetInBufSize(UInt32 , UInt32 size)) { _inBufSize = size; return S_OK; }
+Z7_COM7F_IMF(CFilterCoder::SetOutBufSize(UInt32 , UInt32 size)) { _outBufSize = size; return S_OK; }
+
+HRESULT CFilterCoder::Alloc()
+{
+ UInt32 size = MyMin(_inBufSize, _outBufSize);
+ /* minimal bufSize is 16 bytes for AES and IA64 filter.
+ bufSize for AES must be aligned for 16 bytes.
+ We use (1 << 12) min size to support future aligned filters. */
+ const UInt32 kMinSize = 1 << 12;
+ size &= ~(UInt32)(kMinSize - 1);
+ if (size < kMinSize)
+ size = kMinSize;
+ // size = (1 << 12); // + 117; // for debug
+ if (!_buf || _bufSize != size)
+ {
+ AllocAligned(size);
+ if (!_buf)
+ return E_OUTOFMEMORY;
+ _bufSize = size;
+ }
+ return S_OK;
+}
+
+HRESULT CFilterCoder::Init_and_Alloc()
+{
+ RINOK(Filter->Init())
+ return Alloc();
+}
+
+CFilterCoder::CFilterCoder(bool encodeMode):
+ _bufSize(0),
+ _inBufSize(kBufSize),
+ _outBufSize(kBufSize),
+ _encodeMode(encodeMode),
+ _outSize_Defined(false),
+ _outSize(0),
+ _nowPos64(0)
+ {}
+
+
+Z7_COM7F_IMF(CFilterCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ RINOK(Init_and_Alloc())
+
+ /*
+ It's expected that BCJ/ARMT filter can process up to 4 bytes less
+ than sent data size. For such BCJ/ARMT cases with non-filtered data we:
+ - write some filtered data to output stream
+ - move non-written data (filtered and non-filtered data) to start of buffer
+ - read more new data from input stream to position after end of non-filtered data
+ - call Filter() for concatenated data in buffer.
+
+ For all cases, even for cases with partial filtering (BCJ/ARMT),
+ we try to keep real/virtual alignment for all operations
+ (memmove, Read(), Filter(), Write()).
+ We use (kAlignSize=64) alignmnent that is larger than (16-bytes)
+ required for AES filter alignment.
+
+ AES-CBC uses 16-bytes blocks, that is simple case for processing here,
+ if we call Filter() for aligned size for all calls except of last call (last block).
+ And now there are no filters that use blocks with non-power2 size,
+ but we try to support such non-power2 filters too here at Code().
+ */
+
+ UInt64 prev = 0;
+ UInt64 nowPos64 = 0;
+ bool inputFinished = false;
+ UInt32 readPos = 0;
+ UInt32 filterPos = 0;
+
+ while (!outSize || nowPos64 < *outSize)
+ {
+ HRESULT hres = S_OK;
+ if (!inputFinished)
+ {
+ size_t processedSize = _bufSize - readPos;
+ /* for AES filters we need at least max(16, kAlignSize) bytes in buffer.
+ But we try to read full buffer to reduce the number of Filter() and Write() calls.
+ */
+ hres = ReadStream(inStream, _buf + readPos, &processedSize);
+ readPos += (UInt32)processedSize;
+ inputFinished = (readPos != _bufSize);
+ if (hres != S_OK)
+ {
+ // do we need to stop encoding after reading error?
+ // if (_encodeMode) return hres;
+ inputFinished = true;
+ }
+ }
+
+ if (readPos == 0)
+ return hres;
+
+ /* we set (needMoreInput = true), if it's block-filter (like AES-CBC)
+ that needs more data for current block filtering:
+ We read full input buffer with Read(), and _bufSize is aligned,
+ So the possible cases when we set (needMoreInput = true) are:
+ 1) decode : filter needs more data after the end of input stream.
+ another cases are possible for non-power2-block-filter,
+ because buffer size is not aligned for filter_non_power2_block_size:
+ 2) decode/encode : filter needs more data from non-finished input stream
+ 3) encode : filter needs more space for zeros after the end of input stream
+ */
+ bool needMoreInput = false;
+
+ while (readPos != filterPos)
+ {
+ /* Filter() is allowed to process part of data.
+ Here we use the loop to filter as max as possible.
+ when we call Filter(data, size):
+ if (size < 16), AES-CTR filter uses internal 16-byte buffer.
+ new (since v23.00) AES-CTR filter allows (size < 16) for non-last block,
+ but it will work less efficiently than calls with aligned (size).
+ We still support old (before v23.00) AES-CTR filters here.
+ We have aligned (size) for AES-CTR, if it's not last block.
+ We have aligned (readPos) for any filter, if (!inputFinished).
+ We also meet the requirements for (data) pointer in Filter() call:
+ {
+ (virtual_stream_offset % aligment_size) == (data_ptr % aligment_size)
+ (aligment_size == 2^N)
+ (aligment_size >= 16)
+ }
+ */
+ const UInt32 cur = Filter->Filter(_buf + filterPos, readPos - filterPos);
+ if (cur == 0)
+ break;
+ const UInt32 f = filterPos + cur;
+ if (cur > readPos - filterPos)
+ {
+ // AES-CBC
+ if (hres != S_OK)
+ break;
+
+ if (!_encodeMode
+ || cur > _bufSize - filterPos
+ || !inputFinished)
+ {
+ /* (cur > _bufSize - filterPos) is unexpected for AES filter, if _bufSize is multiply of 16.
+ But we support this case, if some future filter will use block with non-power2-size.
+ */
+ needMoreInput = true;
+ break;
+ }
+
+ /* (_encodeMode && inputFinished).
+ We add zero bytes as pad in current block after the end of read data. */
+ Byte *buf = _buf;
+ do
+ buf[readPos] = 0;
+ while (++readPos != f);
+ // (readPos) now is (size_of_real_input_data + size_of_zero_pad)
+ if (cur != Filter->Filter(buf + filterPos, cur))
+ return E_FAIL;
+ }
+ filterPos = f;
+ }
+
+ UInt32 size = filterPos;
+ if (hres == S_OK)
+ {
+ /* If we need more Read() or Filter() calls, then we need to Write()
+ some data and move unwritten data to get additional space in buffer.
+ We try to keep alignment for data moves, Read(), Filter() and Write() calls.
+ */
+ const UInt32 kAlignSize = 1 << 6;
+ const UInt32 alignedFiltered = filterPos & ~(kAlignSize - 1);
+ if (inputFinished)
+ {
+ if (!needMoreInput)
+ size = readPos; // for risc/bcj filters in last block we write data after filterPos.
+ else if (_encodeMode)
+ size = alignedFiltered; // for non-power2-block-encode-filter
+ }
+ else
+ size = alignedFiltered;
+ }
+
+ {
+ UInt32 writeSize = size;
+ if (outSize)
+ {
+ const UInt64 rem = *outSize - nowPos64;
+ if (writeSize > rem)
+ writeSize = (UInt32)rem;
+ }
+ RINOK(WriteStream(outStream, _buf, writeSize))
+ nowPos64 += writeSize;
+ }
+
+ if (hres != S_OK)
+ return hres;
+
+ if (inputFinished)
+ {
+ if (readPos == size)
+ return hres;
+ if (!_encodeMode)
+ {
+ // block-decode-filter (AES-CBS) has non-full last block
+ // we don't want unaligned data move for more iterations with this error case.
+ return S_FALSE;
+ }
+ }
+
+ if (size == 0)
+ {
+ // it's unexpected that we have no any move in this iteration.
+ return E_FAIL;
+ }
+ // if (size != 0)
+ {
+ if (filterPos < size)
+ return E_FAIL; // filterPos = 0; else
+ filterPos -= size;
+ readPos -= size;
+ if (readPos != 0)
+ memmove(_buf, _buf + size, readPos);
+ }
+ // printf("\nnowPos64=%x, readPos=%x, filterPos=%x\n", (unsigned)nowPos64, (unsigned)readPos, (unsigned)filterPos);
+
+ if (progress && (nowPos64 - prev) >= (1 << 22))
+ {
+ prev = nowPos64;
+ RINOK(progress->SetRatioInfo(&nowPos64, &nowPos64))
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+// ---------- Write to Filter ----------
+
+Z7_COM7F_IMF(CFilterCoder::SetOutStream(ISequentialOutStream *outStream))
+{
+ _outStream = outStream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFilterCoder::ReleaseOutStream())
+{
+ _outStream.Release();
+ return S_OK;
+}
+
+HRESULT CFilterCoder::Flush2()
+{
+ while (_convSize != 0)
+ {
+ UInt32 num = _convSize;
+ if (_outSize_Defined)
+ {
+ const UInt64 rem = _outSize - _nowPos64;
+ if (num > rem)
+ num = (UInt32)rem;
+ if (num == 0)
+ return k_My_HRESULT_WritingWasCut;
+ }
+
+ UInt32 processed = 0;
+ const HRESULT res = _outStream->Write(_buf + _convPos, num, &processed);
+ if (processed == 0)
+ return res != S_OK ? res : E_FAIL;
+
+ _convPos += processed;
+ _convSize -= processed;
+ _nowPos64 += processed;
+ RINOK(res)
+ }
+
+ const UInt32 convPos = _convPos;
+ if (convPos != 0)
+ {
+ const UInt32 num = _bufPos - convPos;
+ Byte *buf = _buf;
+ for (UInt32 i = 0; i < num; i++)
+ buf[i] = buf[convPos + i];
+ _bufPos = num;
+ _convPos = 0;
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFilterCoder::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ RINOK(Flush2())
+
+ // _convSize is 0
+ // _convPos is 0
+ // _bufPos is small
+
+ if (_bufPos != _bufSize)
+ {
+ UInt32 num = MyMin(size, _bufSize - _bufPos);
+ memcpy(_buf + _bufPos, data, num);
+ size -= num;
+ data = (const Byte *)data + num;
+ if (processedSize)
+ *processedSize += num;
+ _bufPos += num;
+ if (_bufPos != _bufSize)
+ continue;
+ }
+
+ // _bufPos == _bufSize
+ _convSize = Filter->Filter(_buf, _bufPos);
+
+ if (_convSize == 0)
+ break;
+ if (_convSize > _bufPos)
+ {
+ // that case is not possible.
+ _convSize = 0;
+ return E_FAIL;
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFilterCoder::OutStreamFinish())
+{
+ for (;;)
+ {
+ RINOK(Flush2())
+ if (_bufPos == 0)
+ break;
+ const UInt32 convSize = Filter->Filter(_buf, _bufPos);
+ _convSize = convSize;
+ UInt32 bufPos = _bufPos;
+ if (convSize == 0)
+ _convSize = bufPos;
+ else if (convSize > bufPos)
+ {
+ // AES
+ if (convSize > _bufSize)
+ {
+ _convSize = 0;
+ return E_FAIL;
+ }
+ if (!_encodeMode)
+ {
+ _convSize = 0;
+ return S_FALSE;
+ }
+ Byte *buf = _buf;
+ for (; bufPos < convSize; bufPos++)
+ buf[bufPos] = 0;
+ _bufPos = bufPos;
+ _convSize = Filter->Filter(_buf, bufPos);
+ if (_convSize != _bufPos)
+ return E_FAIL;
+ }
+ }
+
+ CMyComPtr<IOutStreamFinish> finish;
+ _outStream.QueryInterface(IID_IOutStreamFinish, &finish);
+ if (finish)
+ return finish->OutStreamFinish();
+ return S_OK;
+}
+
+// ---------- Init functions ----------
+
+Z7_COM7F_IMF(CFilterCoder::InitEncoder())
+{
+ InitSpecVars();
+ return Init_and_Alloc();
+}
+
+HRESULT CFilterCoder::Init_NoSubFilterInit()
+{
+ InitSpecVars();
+ return Alloc();
+}
+
+Z7_COM7F_IMF(CFilterCoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ InitSpecVars();
+ if (outSize)
+ {
+ _outSize = *outSize;
+ _outSize_Defined = true;
+ }
+ return Init_and_Alloc();
+}
+
+// ---------- Read from Filter ----------
+
+Z7_COM7F_IMF(CFilterCoder::SetInStream(ISequentialInStream *inStream))
+{
+ _inStream = inStream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFilterCoder::ReleaseInStream())
+{
+ _inStream.Release();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CFilterCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ while (size != 0)
+ {
+ if (_convSize != 0)
+ {
+ if (size > _convSize)
+ size = _convSize;
+ if (_outSize_Defined)
+ {
+ const UInt64 rem = _outSize - _nowPos64;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ memcpy(data, _buf + _convPos, size);
+ _convPos += size;
+ _convSize -= size;
+ _nowPos64 += size;
+ if (processedSize)
+ *processedSize = size;
+ break;
+ }
+
+ const UInt32 convPos = _convPos;
+ if (convPos != 0)
+ {
+ const UInt32 num = _bufPos - convPos;
+ Byte *buf = _buf;
+ for (UInt32 i = 0; i < num; i++)
+ buf[i] = buf[convPos + i];
+ _bufPos = num;
+ _convPos = 0;
+ }
+
+ {
+ size_t readSize = _bufSize - _bufPos;
+ const HRESULT res = ReadStream(_inStream, _buf + _bufPos, &readSize);
+ _bufPos += (UInt32)readSize;
+ RINOK(res)
+ }
+
+ const UInt32 convSize = Filter->Filter(_buf, _bufPos);
+ _convSize = convSize;
+
+ UInt32 bufPos = _bufPos;
+
+ if (convSize == 0)
+ {
+ if (bufPos == 0)
+ break;
+ // BCJ
+ _convSize = bufPos;
+ continue;
+ }
+
+ if (convSize > bufPos)
+ {
+ // AES
+ if (convSize > _bufSize)
+ return E_FAIL;
+ if (!_encodeMode)
+ return S_FALSE;
+ Byte *buf = _buf;
+ do
+ buf[bufPos] = 0;
+ while (++bufPos != convSize);
+ _bufPos = bufPos;
+ _convSize = Filter->Filter(_buf, convSize);
+ if (_convSize != _bufPos)
+ return E_FAIL;
+ }
+ }
+
+ return S_OK;
+}
+
+
+#ifndef Z7_NO_CRYPTO
+
+Z7_COM7F_IMF(CFilterCoder::CryptoSetPassword(const Byte *data, UInt32 size))
+ { return _setPassword->CryptoSetPassword(data, size); }
+
+Z7_COM7F_IMF(CFilterCoder::SetKey(const Byte *data, UInt32 size))
+ { return _cryptoProperties->SetKey(data, size); }
+
+Z7_COM7F_IMF(CFilterCoder::SetInitVector(const Byte *data, UInt32 size))
+ { return _cryptoProperties->SetInitVector(data, size); }
+
+#endif
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+Z7_COM7F_IMF(CFilterCoder::SetCoderProperties(const PROPID *propIDs,
+ const PROPVARIANT *properties, UInt32 numProperties))
+ { return _setCoderProperties->SetCoderProperties(propIDs, properties, numProperties); }
+
+Z7_COM7F_IMF(CFilterCoder::WriteCoderProperties(ISequentialOutStream *outStream))
+ { return _writeCoderProperties->WriteCoderProperties(outStream); }
+
+Z7_COM7F_IMF(CFilterCoder::SetCoderPropertiesOpt(const PROPID *propIDs,
+ const PROPVARIANT *properties, UInt32 numProperties))
+ { return _setCoderPropertiesOpt->SetCoderPropertiesOpt(propIDs, properties, numProperties); }
+
+/*
+Z7_COM7F_IMF(CFilterCoder::ResetSalt()
+ { return _cryptoResetSalt->ResetSalt(); }
+*/
+
+Z7_COM7F_IMF(CFilterCoder::ResetInitVector())
+ { return _cryptoResetInitVector->ResetInitVector(); }
+
+#endif
+
+
+Z7_COM7F_IMF(CFilterCoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+ { return _setDecoderProperties2->SetDecoderProperties2(data, size); }
diff --git a/CPP/7zip/Common/FilterCoder.h b/CPP/7zip/Common/FilterCoder.h
index bde0e2b..3a588fd 100644
--- a/CPP/7zip/Common/FilterCoder.h
+++ b/CPP/7zip/Common/FilterCoder.h
@@ -1,205 +1,201 @@
-// FilterCoder.h
-
-#ifndef __FILTER_CODER_H
-#define __FILTER_CODER_H
-
-#include "../../../C/Alloc.h"
-
-#include "../../Common/MyCom.h"
-#include "../ICoder.h"
-
-#ifndef _NO_CRYPTO
-#include "../IPassword.h"
-#endif
-
-#define MY_QUERYINTERFACE_ENTRY_AG(i, sub0, sub) else if (iid == IID_ ## i) \
- { if (!sub) RINOK(sub0->QueryInterface(IID_ ## i, (void **)&sub)) \
- *outObject = (void *)(i *)this; }
-
-
-struct CAlignedMidBuffer
-{
- Byte *_buf;
-
- CAlignedMidBuffer(): _buf(NULL) {}
- ~CAlignedMidBuffer();
- void AllocAligned(size_t size);
-};
-
-class CFilterCoder:
- public ICompressCoder,
-
- public ICompressSetOutStreamSize,
- public ICompressInitEncoder,
-
- public ICompressSetInStream,
- public ISequentialInStream,
-
- public ICompressSetOutStream,
- public ISequentialOutStream,
- public IOutStreamFinish,
-
- public ICompressSetBufSize,
-
- #ifndef _NO_CRYPTO
- public ICryptoSetPassword,
- public ICryptoProperties,
- #endif
-
- #ifndef EXTRACT_ONLY
- public ICompressSetCoderProperties,
- public ICompressWriteCoderProperties,
- // public ICryptoResetSalt,
- public ICryptoResetInitVector,
- #endif
-
- public ICompressSetDecoderProperties2,
- public CMyUnknownImp,
- public CAlignedMidBuffer
-{
- UInt32 _bufSize;
- UInt32 _inBufSize;
- UInt32 _outBufSize;
-
- bool _encodeMode;
- bool _outSizeIsDefined;
- UInt64 _outSize;
- UInt64 _nowPos64;
-
- CMyComPtr<ISequentialInStream> _inStream;
- CMyComPtr<ISequentialOutStream> _outStream;
- UInt32 _bufPos;
- UInt32 _convPos; // current pos in buffer for converted data
- UInt32 _convSize; // size of converted data starting from _convPos
-
- void InitSpecVars()
- {
- _bufPos = 0;
- _convPos = 0;
- _convSize = 0;
-
- _outSizeIsDefined = false;
- _outSize = 0;
- _nowPos64 = 0;
- }
-
- HRESULT Alloc();
- HRESULT Init_and_Alloc();
- HRESULT Flush2();
-
- #ifndef _NO_CRYPTO
- CMyComPtr<ICryptoSetPassword> _SetPassword;
- CMyComPtr<ICryptoProperties> _CryptoProperties;
- #endif
-
- #ifndef EXTRACT_ONLY
- CMyComPtr<ICompressSetCoderProperties> _SetCoderProperties;
- CMyComPtr<ICompressWriteCoderProperties> _WriteCoderProperties;
- // CMyComPtr<ICryptoResetSalt> _CryptoResetSalt;
- CMyComPtr<ICryptoResetInitVector> _CryptoResetInitVector;
- #endif
-
- CMyComPtr<ICompressSetDecoderProperties2> _SetDecoderProperties2;
-
-public:
- CMyComPtr<ICompressFilter> Filter;
-
- CFilterCoder(bool encodeMode);
- ~CFilterCoder();
-
- class C_InStream_Releaser
- {
- public:
- CFilterCoder *FilterCoder;
- C_InStream_Releaser(): FilterCoder(NULL) {}
- ~C_InStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseInStream(); }
- };
-
- class C_OutStream_Releaser
- {
- public:
- CFilterCoder *FilterCoder;
- C_OutStream_Releaser(): FilterCoder(NULL) {}
- ~C_OutStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseOutStream(); }
- };
-
- class C_Filter_Releaser
- {
- public:
- CFilterCoder *FilterCoder;
- C_Filter_Releaser(): FilterCoder(NULL) {}
- ~C_Filter_Releaser() { if (FilterCoder) FilterCoder->Filter.Release(); }
- };
-
-
- MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
-
- MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
- MY_QUERYINTERFACE_ENTRY(ICompressInitEncoder)
-
- MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
- MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
-
- MY_QUERYINTERFACE_ENTRY(ICompressSetOutStream)
- MY_QUERYINTERFACE_ENTRY(ISequentialOutStream)
- MY_QUERYINTERFACE_ENTRY(IOutStreamFinish)
-
- MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
-
- #ifndef _NO_CRYPTO
- MY_QUERYINTERFACE_ENTRY_AG(ICryptoSetPassword, Filter, _SetPassword)
- MY_QUERYINTERFACE_ENTRY_AG(ICryptoProperties, Filter, _CryptoProperties)
- #endif
-
- #ifndef EXTRACT_ONLY
- MY_QUERYINTERFACE_ENTRY_AG(ICompressSetCoderProperties, Filter, _SetCoderProperties)
- MY_QUERYINTERFACE_ENTRY_AG(ICompressWriteCoderProperties, Filter, _WriteCoderProperties)
- // MY_QUERYINTERFACE_ENTRY_AG(ICryptoResetSalt, Filter, _CryptoResetSalt)
- MY_QUERYINTERFACE_ENTRY_AG(ICryptoResetInitVector, Filter, _CryptoResetInitVector)
- #endif
-
- MY_QUERYINTERFACE_ENTRY_AG(ICompressSetDecoderProperties2, Filter, _SetDecoderProperties2)
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
-
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
- STDMETHOD(InitEncoder)();
-
- STDMETHOD(SetInStream)(ISequentialInStream *inStream);
- STDMETHOD(ReleaseInStream)();
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-
- STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);
- STDMETHOD(ReleaseOutStream)();
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(OutStreamFinish)();
-
- STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
- STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
-
- #ifndef _NO_CRYPTO
- STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
-
- STDMETHOD(SetKey)(const Byte *data, UInt32 size);
- STDMETHOD(SetInitVector)(const Byte *data, UInt32 size);
- #endif
-
- #ifndef EXTRACT_ONLY
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
- const PROPVARIANT *properties, UInt32 numProperties);
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
- // STDMETHOD(ResetSalt)();
- STDMETHOD(ResetInitVector)();
- #endif
-
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
-
-
- HRESULT Init_NoSubFilterInit();
-};
-
-#endif
+// FilterCoder.h
+
+#ifndef ZIP7_INC_FILTER_CODER_H
+#define ZIP7_INC_FILTER_CODER_H
+
+#include "../../../C/Alloc.h"
+
+#include "../../Common/MyCom.h"
+#include "../ICoder.h"
+
+#ifndef Z7_NO_CRYPTO
+#include "../IPassword.h"
+#endif
+
+#define Z7_COM_QI_ENTRY_AG(i, sub0, sub) else if (iid == IID_ ## i) \
+ { if (!sub) RINOK(sub0->QueryInterface(IID_ ## i, (void **)&sub)) \
+ *outObject = (void *)(i *)this; }
+
+
+struct CAlignedMidBuffer
+{
+ Byte *_buf;
+
+ CAlignedMidBuffer(): _buf(NULL) {}
+ ~CAlignedMidBuffer();
+ void AllocAligned(size_t size);
+};
+
+
+class CFilterCoder Z7_final :
+ public ICompressCoder,
+
+ public ICompressSetOutStreamSize,
+ public ICompressInitEncoder,
+
+ public ICompressSetInStream,
+ public ISequentialInStream,
+
+ public ICompressSetOutStream,
+ public ISequentialOutStream,
+ public IOutStreamFinish,
+
+ public ICompressSetBufSize,
+
+ #ifndef Z7_NO_CRYPTO
+ public ICryptoSetPassword,
+ public ICryptoProperties,
+ #endif
+
+ #ifndef Z7_EXTRACT_ONLY
+ public ICompressSetCoderProperties,
+ public ICompressWriteCoderProperties,
+ public ICompressSetCoderPropertiesOpt,
+ // public ICryptoResetSalt,
+ public ICryptoResetInitVector,
+ #endif
+
+ public ICompressSetDecoderProperties2,
+ public CMyUnknownImp,
+ public CAlignedMidBuffer
+{
+ UInt32 _bufSize;
+ UInt32 _inBufSize;
+ UInt32 _outBufSize;
+
+ bool _encodeMode;
+ bool _outSize_Defined;
+ UInt64 _outSize;
+ UInt64 _nowPos64;
+
+ CMyComPtr<ISequentialInStream> _inStream;
+ CMyComPtr<ISequentialOutStream> _outStream;
+ UInt32 _bufPos;
+ UInt32 _convPos; // current pos in buffer for converted data
+ UInt32 _convSize; // size of converted data starting from _convPos
+
+ void InitSpecVars()
+ {
+ _bufPos = 0;
+ _convPos = 0;
+ _convSize = 0;
+
+ _outSize_Defined = false;
+ _outSize = 0;
+ _nowPos64 = 0;
+ }
+
+ HRESULT Alloc();
+ HRESULT Init_and_Alloc();
+ HRESULT Flush2();
+
+ #ifndef Z7_NO_CRYPTO
+ CMyComPtr<ICryptoSetPassword> _setPassword;
+ CMyComPtr<ICryptoProperties> _cryptoProperties;
+ #endif
+
+ #ifndef Z7_EXTRACT_ONLY
+ CMyComPtr<ICompressSetCoderProperties> _setCoderProperties;
+ CMyComPtr<ICompressWriteCoderProperties> _writeCoderProperties;
+ CMyComPtr<ICompressSetCoderPropertiesOpt> _setCoderPropertiesOpt;
+ // CMyComPtr<ICryptoResetSalt> _cryptoResetSalt;
+ CMyComPtr<ICryptoResetInitVector> _cryptoResetInitVector;
+ #endif
+
+ CMyComPtr<ICompressSetDecoderProperties2> _setDecoderProperties2;
+
+public:
+ CMyComPtr<ICompressFilter> Filter;
+
+ CFilterCoder(bool encodeMode);
+
+ struct C_InStream_Releaser
+ {
+ CFilterCoder *FilterCoder;
+ C_InStream_Releaser(): FilterCoder(NULL) {}
+ ~C_InStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseInStream(); }
+ };
+
+ struct C_OutStream_Releaser
+ {
+ CFilterCoder *FilterCoder;
+ C_OutStream_Releaser(): FilterCoder(NULL) {}
+ ~C_OutStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseOutStream(); }
+ };
+
+ struct C_Filter_Releaser
+ {
+ CFilterCoder *FilterCoder;
+ C_Filter_Releaser(): FilterCoder(NULL) {}
+ ~C_Filter_Releaser() { if (FilterCoder) FilterCoder->Filter.Release(); }
+ };
+
+private:
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ Z7_COM_QI_ENTRY(ICompressInitEncoder)
+
+ Z7_COM_QI_ENTRY(ICompressSetInStream)
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+
+ Z7_COM_QI_ENTRY(ICompressSetOutStream)
+ Z7_COM_QI_ENTRY(ISequentialOutStream)
+ Z7_COM_QI_ENTRY(IOutStreamFinish)
+
+ Z7_COM_QI_ENTRY(ICompressSetBufSize)
+
+ #ifndef Z7_NO_CRYPTO
+ Z7_COM_QI_ENTRY_AG(ICryptoSetPassword, Filter, _setPassword)
+ Z7_COM_QI_ENTRY_AG(ICryptoProperties, Filter, _cryptoProperties)
+ #endif
+
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_COM_QI_ENTRY_AG(ICompressSetCoderProperties, Filter, _setCoderProperties)
+ Z7_COM_QI_ENTRY_AG(ICompressWriteCoderProperties, Filter, _writeCoderProperties)
+ Z7_COM_QI_ENTRY_AG(ICompressSetCoderPropertiesOpt, Filter, _setCoderPropertiesOpt)
+ // Z7_COM_QI_ENTRY_AG(ICryptoResetSalt, Filter, _cryptoResetSalt)
+ Z7_COM_QI_ENTRY_AG(ICryptoResetInitVector, Filter, _cryptoResetInitVector)
+ #endif
+
+ Z7_COM_QI_ENTRY_AG(ICompressSetDecoderProperties2, Filter, _setDecoderProperties2)
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+public:
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ Z7_IFACE_COM7_IMP(ICompressInitEncoder)
+ Z7_IFACE_COM7_IMP(ICompressSetInStream)
+private:
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+public:
+ Z7_IFACE_COM7_IMP(ICompressSetOutStream)
+private:
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+public:
+ Z7_IFACE_COM7_IMP(IOutStreamFinish)
+private:
+
+ Z7_IFACE_COM7_IMP(ICompressSetBufSize)
+
+ #ifndef Z7_NO_CRYPTO
+ Z7_IFACE_COM7_IMP(ICryptoSetPassword)
+ Z7_IFACE_COM7_IMP(ICryptoProperties)
+ #endif
+
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_IFACE_COM7_IMP(ICompressSetCoderProperties)
+ Z7_IFACE_COM7_IMP(ICompressWriteCoderProperties)
+ Z7_IFACE_COM7_IMP(ICompressSetCoderPropertiesOpt)
+ // Z7_IFACE_COM7_IMP(ICryptoResetSalt)
+ Z7_IFACE_COM7_IMP(ICryptoResetInitVector)
+ #endif
+
+public:
+ Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+
+ HRESULT Init_NoSubFilterInit();
+};
+
+#endif
diff --git a/CPP/7zip/Common/InBuffer.cpp b/CPP/7zip/Common/InBuffer.cpp
index 826e98b..b0f222c 100644
--- a/CPP/7zip/Common/InBuffer.cpp
+++ b/CPP/7zip/Common/InBuffer.cpp
@@ -1,163 +1,164 @@
-// InBuffer.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "InBuffer.h"
-
-CInBufferBase::CInBufferBase() throw():
- _buf(0),
- _bufLim(0),
- _bufBase(0),
- _stream(0),
- _processedSize(0),
- _bufSize(0),
- _wasFinished(false),
- NumExtraBytes(0)
-{}
-
-bool CInBuffer::Create(size_t bufSize) throw()
-{
- const unsigned kMinBlockSize = 1;
- if (bufSize < kMinBlockSize)
- bufSize = kMinBlockSize;
- if (_bufBase != 0 && _bufSize == bufSize)
- return true;
- Free();
- _bufSize = bufSize;
- _bufBase = (Byte *)::MidAlloc(bufSize);
- return (_bufBase != 0);
-}
-
-void CInBuffer::Free() throw()
-{
- ::MidFree(_bufBase);
- _bufBase = 0;
-}
-
-void CInBufferBase::Init() throw()
-{
- _processedSize = 0;
- _buf = _bufBase;
- _bufLim = _buf;
- _wasFinished = false;
- #ifdef _NO_EXCEPTIONS
- ErrorCode = S_OK;
- #endif
- NumExtraBytes = 0;
-}
-
-bool CInBufferBase::ReadBlock()
-{
- #ifdef _NO_EXCEPTIONS
- if (ErrorCode != S_OK)
- return false;
- #endif
- if (_wasFinished)
- return false;
- _processedSize += (_buf - _bufBase);
- _buf = _bufBase;
- _bufLim = _bufBase;
- UInt32 processed;
- // FIX_ME: we can improve it to support (_bufSize >= (1 << 32))
- HRESULT result = _stream->Read(_bufBase, (UInt32)_bufSize, &processed);
- #ifdef _NO_EXCEPTIONS
- ErrorCode = result;
- #else
- if (result != S_OK)
- throw CInBufferException(result);
- #endif
- _bufLim = _buf + processed;
- _wasFinished = (processed == 0);
- return !_wasFinished;
-}
-
-bool CInBufferBase::ReadByte_FromNewBlock(Byte &b)
-{
- if (!ReadBlock())
- {
- NumExtraBytes++;
- b = 0xFF;
- return false;
- }
- b = *_buf++;
- return true;
-}
-
-Byte CInBufferBase::ReadByte_FromNewBlock()
-{
- if (!ReadBlock())
- {
- NumExtraBytes++;
- return 0xFF;
- }
- return *_buf++;
-}
-
-size_t CInBufferBase::ReadBytes(Byte *buf, size_t size)
-{
- size_t num = 0;
- for (;;)
- {
- const size_t rem = _bufLim - _buf;
- if (size <= rem)
- {
- if (size != 0)
- {
- memcpy(buf, _buf, size);
- _buf += size;
- num += size;
- }
- return num;
- }
- if (rem != 0)
- {
- memcpy(buf, _buf, rem);
- _buf += rem;
- buf += rem;
- num += rem;
- size -= rem;
- }
- if (!ReadBlock())
- return num;
- }
-
- /*
- if ((size_t)(_bufLim - _buf) >= size)
- {
- const Byte *src = _buf;
- for (size_t i = 0; i < size; i++)
- buf[i] = src[i];
- _buf += size;
- return size;
- }
- for (size_t i = 0; i < size; i++)
- {
- if (_buf >= _bufLim)
- if (!ReadBlock())
- return i;
- buf[i] = *_buf++;
- }
- return size;
- */
-}
-
-size_t CInBufferBase::Skip(size_t size)
-{
- size_t processed = 0;
- for (;;)
- {
- size_t rem = (_bufLim - _buf);
- if (rem >= size)
- {
- _buf += size;
- return processed + size;
- }
- _buf += rem;
- processed += rem;
- size -= rem;
- if (!ReadBlock())
- return processed;
- }
-}
+// InBuffer.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "InBuffer.h"
+
+CInBufferBase::CInBufferBase() throw():
+ _buf(NULL),
+ _bufLim(NULL),
+ _bufBase(NULL),
+ _stream(NULL),
+ _processedSize(0),
+ _bufSize(0),
+ _wasFinished(false),
+ NumExtraBytes(0)
+{}
+
+bool CInBuffer::Create(size_t bufSize) throw()
+{
+ const unsigned kMinBlockSize = 1;
+ if (bufSize < kMinBlockSize)
+ bufSize = kMinBlockSize;
+ if (_bufBase != NULL && _bufSize == bufSize)
+ return true;
+ Free();
+ _bufSize = bufSize;
+ _bufBase = (Byte *)::MidAlloc(bufSize);
+ return (_bufBase != NULL);
+}
+
+void CInBuffer::Free() throw()
+{
+ ::MidFree(_bufBase);
+ _bufBase = NULL;
+}
+
+void CInBufferBase::Init() throw()
+{
+ _processedSize = 0;
+ _buf = _bufBase;
+ _bufLim = _buf;
+ _wasFinished = false;
+ #ifdef Z7_NO_EXCEPTIONS
+ ErrorCode = S_OK;
+ #endif
+ NumExtraBytes = 0;
+}
+
+bool CInBufferBase::ReadBlock()
+{
+ #ifdef Z7_NO_EXCEPTIONS
+ if (ErrorCode != S_OK)
+ return false;
+ #endif
+ if (_wasFinished)
+ return false;
+ _processedSize += (size_t)(_buf - _bufBase);
+ _buf = _bufBase;
+ _bufLim = _bufBase;
+ UInt32 processed;
+ // FIX_ME: we can improve it to support (_bufSize >= (1 << 32))
+ const HRESULT result = _stream->Read(_bufBase, (UInt32)_bufSize, &processed);
+ #ifdef Z7_NO_EXCEPTIONS
+ ErrorCode = result;
+ #else
+ if (result != S_OK)
+ throw CInBufferException(result);
+ #endif
+ _bufLim = _buf + processed;
+ _wasFinished = (processed == 0);
+ return !_wasFinished;
+}
+
+bool CInBufferBase::ReadByte_FromNewBlock(Byte &b)
+{
+ if (!ReadBlock())
+ {
+ // 22.00: we don't increment (NumExtraBytes) here
+ // NumExtraBytes++;
+ b = 0xFF;
+ return false;
+ }
+ b = *_buf++;
+ return true;
+}
+
+Byte CInBufferBase::ReadByte_FromNewBlock()
+{
+ if (!ReadBlock())
+ {
+ NumExtraBytes++;
+ return 0xFF;
+ }
+ return *_buf++;
+}
+
+size_t CInBufferBase::ReadBytes(Byte *buf, size_t size)
+{
+ size_t num = 0;
+ for (;;)
+ {
+ const size_t rem = (size_t)(_bufLim - _buf);
+ if (size <= rem)
+ {
+ if (size != 0)
+ {
+ memcpy(buf, _buf, size);
+ _buf += size;
+ num += size;
+ }
+ return num;
+ }
+ if (rem != 0)
+ {
+ memcpy(buf, _buf, rem);
+ _buf += rem;
+ buf += rem;
+ num += rem;
+ size -= rem;
+ }
+ if (!ReadBlock())
+ return num;
+ }
+
+ /*
+ if ((size_t)(_bufLim - _buf) >= size)
+ {
+ const Byte *src = _buf;
+ for (size_t i = 0; i < size; i++)
+ buf[i] = src[i];
+ _buf += size;
+ return size;
+ }
+ for (size_t i = 0; i < size; i++)
+ {
+ if (_buf >= _bufLim)
+ if (!ReadBlock())
+ return i;
+ buf[i] = *_buf++;
+ }
+ return size;
+ */
+}
+
+size_t CInBufferBase::Skip(size_t size)
+{
+ size_t processed = 0;
+ for (;;)
+ {
+ const size_t rem = (size_t)(_bufLim - _buf);
+ if (rem >= size)
+ {
+ _buf += size;
+ return processed + size;
+ }
+ _buf += rem;
+ processed += rem;
+ size -= rem;
+ if (!ReadBlock())
+ return processed;
+ }
+}
diff --git a/CPP/7zip/Common/InBuffer.h b/CPP/7zip/Common/InBuffer.h
index 76e359a..3aaf797 100644
--- a/CPP/7zip/Common/InBuffer.h
+++ b/CPP/7zip/Common/InBuffer.h
@@ -1,92 +1,109 @@
-// InBuffer.h
-
-#ifndef __IN_BUFFER_H
-#define __IN_BUFFER_H
-
-#include "../../Common/MyException.h"
-#include "../IStream.h"
-
-#ifndef _NO_EXCEPTIONS
-struct CInBufferException: public CSystemException
-{
- CInBufferException(HRESULT errorCode): CSystemException(errorCode) {}
-};
-#endif
-
-class CInBufferBase
-{
-protected:
- Byte *_buf;
- Byte *_bufLim;
- Byte *_bufBase;
-
- ISequentialInStream *_stream;
- UInt64 _processedSize;
- size_t _bufSize; // actually it's number of Bytes for next read. The buf can be larger
- // only up to 32-bits values now are supported!
- bool _wasFinished;
-
- bool ReadBlock();
- bool ReadByte_FromNewBlock(Byte &b);
- Byte ReadByte_FromNewBlock();
-
-public:
- #ifdef _NO_EXCEPTIONS
- HRESULT ErrorCode;
- #endif
- UInt32 NumExtraBytes;
-
- CInBufferBase() throw();
-
- UInt64 GetStreamSize() const { return _processedSize + (_buf - _bufBase); }
- UInt64 GetProcessedSize() const { return _processedSize + NumExtraBytes + (_buf - _bufBase); }
- bool WasFinished() const { return _wasFinished; }
-
- void SetStream(ISequentialInStream *stream) { _stream = stream; }
-
- void SetBuf(Byte *buf, size_t bufSize, size_t end, size_t pos)
- {
- _bufBase = buf;
- _bufSize = bufSize;
- _processedSize = 0;
- _buf = buf + pos;
- _bufLim = buf + end;
- _wasFinished = false;
- #ifdef _NO_EXCEPTIONS
- ErrorCode = S_OK;
- #endif
- NumExtraBytes = 0;
- }
-
- void Init() throw();
-
- MY_FORCE_INLINE
- bool ReadByte(Byte &b)
- {
- if (_buf >= _bufLim)
- return ReadByte_FromNewBlock(b);
- b = *_buf++;
- return true;
- }
-
- MY_FORCE_INLINE
- Byte ReadByte()
- {
- if (_buf >= _bufLim)
- return ReadByte_FromNewBlock();
- return *_buf++;
- }
-
- size_t ReadBytes(Byte *buf, size_t size);
- size_t Skip(size_t size);
-};
-
-class CInBuffer: public CInBufferBase
-{
-public:
- ~CInBuffer() { Free(); }
- bool Create(size_t bufSize) throw(); // only up to 32-bits values now are supported!
- void Free() throw();
-};
-
-#endif
+// InBuffer.h
+
+#ifndef ZIP7_INC_IN_BUFFER_H
+#define ZIP7_INC_IN_BUFFER_H
+
+#include "../../Common/MyException.h"
+#include "../IStream.h"
+
+#ifndef Z7_NO_EXCEPTIONS
+struct CInBufferException: public CSystemException
+{
+ CInBufferException(HRESULT errorCode): CSystemException(errorCode) {}
+};
+#endif
+
+class CInBufferBase
+{
+protected:
+ Byte *_buf;
+ Byte *_bufLim;
+ Byte *_bufBase;
+
+ ISequentialInStream *_stream;
+ UInt64 _processedSize;
+ size_t _bufSize; // actually it's number of Bytes for next read. The buf can be larger
+ // only up to 32-bits values now are supported!
+ bool _wasFinished;
+
+ bool ReadBlock();
+ bool ReadByte_FromNewBlock(Byte &b);
+ Byte ReadByte_FromNewBlock();
+
+public:
+ #ifdef Z7_NO_EXCEPTIONS
+ HRESULT ErrorCode;
+ #endif
+ UInt32 NumExtraBytes;
+
+ CInBufferBase() throw();
+
+ // the size of portion of data in real stream that was already read from this object
+ // it doesn't include unused data in buffer
+ // it doesn't include virtual Extra bytes after the end of real stream data
+ UInt64 GetStreamSize() const { return _processedSize + (size_t)(_buf - _bufBase); }
+
+ // the size of virtual data that was read from this object
+ // it doesn't include unused data in buffers
+ // it includes any virtual Extra bytes after the end of real data
+ UInt64 GetProcessedSize() const { return _processedSize + NumExtraBytes + (size_t)(_buf - _bufBase); }
+
+ bool WasFinished() const { return _wasFinished; }
+
+ void SetStream(ISequentialInStream *stream) { _stream = stream; }
+
+ void SetBuf(Byte *buf, size_t bufSize, size_t end, size_t pos)
+ {
+ _bufBase = buf;
+ _bufSize = bufSize;
+ _processedSize = 0;
+ _buf = buf + pos;
+ _bufLim = buf + end;
+ _wasFinished = false;
+ #ifdef Z7_NO_EXCEPTIONS
+ ErrorCode = S_OK;
+ #endif
+ NumExtraBytes = 0;
+ }
+
+ void Init() throw();
+
+ Z7_FORCE_INLINE
+ bool ReadByte(Byte &b)
+ {
+ if (_buf >= _bufLim)
+ return ReadByte_FromNewBlock(b);
+ b = *_buf++;
+ return true;
+ }
+
+ Z7_FORCE_INLINE
+ bool ReadByte_FromBuf(Byte &b)
+ {
+ if (_buf >= _bufLim)
+ return false;
+ b = *_buf++;
+ return true;
+ }
+
+ Z7_FORCE_INLINE
+ Byte ReadByte()
+ {
+ if (_buf >= _bufLim)
+ return ReadByte_FromNewBlock();
+ return *_buf++;
+ }
+
+ size_t ReadBytes(Byte *buf, size_t size);
+ size_t Skip(size_t size);
+};
+
+class CInBuffer: public CInBufferBase
+{
+public:
+ ~CInBuffer() { Free(); }
+ bool Create(size_t bufSize) throw(); // only up to 32-bits values now are supported!
+ void Free() throw();
+};
+
+#endif
diff --git a/CPP/7zip/Common/InOutTempBuffer.cpp b/CPP/7zip/Common/InOutTempBuffer.cpp
index d83d674..3f7272e 100644
--- a/CPP/7zip/Common/InOutTempBuffer.cpp
+++ b/CPP/7zip/Common/InOutTempBuffer.cpp
@@ -1,127 +1,237 @@
-// InOutTempBuffer.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/7zCrc.h"
-
-#include "../../Common/Defs.h"
-
-#include "InOutTempBuffer.h"
-#include "StreamUtils.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static const size_t kTempBufSize = (1 << 20);
-
-#define kTempFilePrefixString FTEXT("7zt")
-
-CInOutTempBuffer::CInOutTempBuffer(): _buf(NULL) { }
-
-void CInOutTempBuffer::Create()
-{
- if (!_buf)
- _buf = new Byte[kTempBufSize];
-}
-
-CInOutTempBuffer::~CInOutTempBuffer()
-{
- delete []_buf;
-}
-
-void CInOutTempBuffer::InitWriting()
-{
- _bufPos = 0;
- _tempFileCreated = false;
- _size = 0;
- _crc = CRC_INIT_VAL;
-}
-
-bool CInOutTempBuffer::WriteToFile(const void *data, UInt32 size)
-{
- if (size == 0)
- return true;
- if (!_tempFileCreated)
- {
- if (!_tempFile.CreateRandomInTempFolder(kTempFilePrefixString, &_outFile))
- return false;
- _tempFileCreated = true;
- }
- UInt32 processed;
- if (!_outFile.Write(data, size, processed))
- return false;
- _crc = CrcUpdate(_crc, data, processed);
- _size += processed;
- return (processed == size);
-}
-
-bool CInOutTempBuffer::Write(const void *data, UInt32 size)
-{
- if (size == 0)
- return true;
- size_t cur = kTempBufSize - _bufPos;
- if (cur != 0)
- {
- if (cur > size)
- cur = size;
- memcpy(_buf + _bufPos, data, cur);
- _crc = CrcUpdate(_crc, data, cur);
- _bufPos += cur;
- _size += cur;
- size -= (UInt32)cur;
- data = ((const Byte *)data) + cur;
- }
- return WriteToFile(data, size);
-}
-
-HRESULT CInOutTempBuffer::WriteToStream(ISequentialOutStream *stream)
-{
- if (!_outFile.Close())
- return E_FAIL;
-
- UInt64 size = 0;
- UInt32 crc = CRC_INIT_VAL;
-
- if (_bufPos != 0)
- {
- RINOK(WriteStream(stream, _buf, _bufPos));
- crc = CrcUpdate(crc, _buf, _bufPos);
- size += _bufPos;
- }
-
- if (_tempFileCreated)
- {
- NIO::CInFile inFile;
- if (!inFile.Open(_tempFile.GetPath()))
- return E_FAIL;
- while (size < _size)
- {
- UInt32 processed;
- if (!inFile.ReadPart(_buf, kTempBufSize, processed))
- return E_FAIL;
- if (processed == 0)
- break;
- RINOK(WriteStream(stream, _buf, processed));
- crc = CrcUpdate(crc, _buf, processed);
- size += processed;
- }
- }
-
- return (_crc == crc && size == _size) ? S_OK : E_FAIL;
-}
-
-/*
-STDMETHODIMP CSequentialOutTempBufferImp::Write(const void *data, UInt32 size, UInt32 *processed)
-{
- if (!_buf->Write(data, size))
- {
- if (processed)
- *processed = 0;
- return E_FAIL;
- }
- if (processed)
- *processed = size;
- return S_OK;
-}
-*/
+// InOutTempBuffer.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "InOutTempBuffer.h"
+
+#include "StreamUtils.h"
+
+#ifdef USE_InOutTempBuffer_FILE
+
+#include "../../../C/7zCrc.h"
+
+#define kTempFilePrefixString FTEXT("7zt")
+/*
+ Total buffer size limit, if we use temp file scheme:
+ 32-bit: 16 MiB = 1 MiB * 16 buffers
+ 64-bit: 4 GiB = 1 MiB * 4096 buffers
+*/
+static const size_t kNumBufsMax = (size_t)1 << (sizeof(size_t) * 2 - 4);
+
+#endif
+
+static const size_t kBufSize = (size_t)1 << 20;
+
+
+CInOutTempBuffer::CInOutTempBuffer():
+ _size(0),
+ _bufs(NULL),
+ _numBufs(0),
+ _numFilled(0)
+{
+ #ifdef USE_InOutTempBuffer_FILE
+ _tempFile_Created = false;
+ _useMemOnly = false;
+ _crc = CRC_INIT_VAL;
+ #endif
+}
+
+CInOutTempBuffer::~CInOutTempBuffer()
+{
+ for (size_t i = 0; i < _numBufs; i++)
+ MyFree(_bufs[i]);
+ MyFree(_bufs);
+}
+
+
+void *CInOutTempBuffer::GetBuf(size_t index)
+{
+ if (index >= _numBufs)
+ {
+ const size_t num = (_numBufs == 0 ? 16 : _numBufs * 2);
+ void **p = (void **)MyRealloc(_bufs, num * sizeof(void *));
+ if (!p)
+ return NULL;
+ _bufs = p;
+ memset(p + _numBufs, 0, (num - _numBufs) * sizeof(void *));
+ _numBufs = num;
+ }
+
+ void *buf = _bufs[index];
+ if (!buf)
+ {
+ buf = MyAlloc(kBufSize);
+ if (buf)
+ _bufs[index] = buf;
+ }
+ return buf;
+}
+
+
+HRESULT CInOutTempBuffer::Write_HRESULT(const void *data, UInt32 size)
+{
+ if (size == 0)
+ return S_OK;
+
+ #ifdef USE_InOutTempBuffer_FILE
+ if (!_tempFile_Created)
+ #endif
+ for (;;) // loop for additional attemp to allocate memory after file creation error
+ {
+ #ifdef USE_InOutTempBuffer_FILE
+ bool allocError = false;
+ #endif
+
+ for (;;) // loop for writing to buffers
+ {
+ const size_t index = (size_t)(_size / kBufSize);
+
+ #ifdef USE_InOutTempBuffer_FILE
+ if (index >= kNumBufsMax && !_useMemOnly)
+ break;
+ #endif
+
+ void *buf = GetBuf(index);
+ if (!buf)
+ {
+ #ifdef USE_InOutTempBuffer_FILE
+ if (!_useMemOnly)
+ {
+ allocError = true;
+ break;
+ }
+ #endif
+ return E_OUTOFMEMORY;
+ }
+
+ const size_t offset = (size_t)(_size) & (kBufSize - 1);
+ size_t cur = kBufSize - offset;
+ if (cur > size)
+ cur = size;
+ memcpy((Byte *)buf + offset, data, cur);
+ _size += cur;
+ if (index >= _numFilled)
+ _numFilled = index + 1;
+ data = (const void *)((const Byte *)data + cur);
+ size -= (UInt32)cur;
+ if (size == 0)
+ return S_OK;
+ }
+
+ #ifdef USE_InOutTempBuffer_FILE
+ #ifndef _WIN32
+ _outFile.mode_for_Create = 0600; // only owner will have the rights to access this file
+ #endif
+ if (_tempFile.CreateRandomInTempFolder(kTempFilePrefixString, &_outFile))
+ {
+ _tempFile_Created = true;
+ break;
+ }
+ _useMemOnly = true;
+ if (allocError)
+ return GetLastError_noZero_HRESULT();
+ #endif
+ }
+
+ #ifdef USE_InOutTempBuffer_FILE
+ if (!_outFile.WriteFull(data, size))
+ return GetLastError_noZero_HRESULT();
+ _crc = CrcUpdate(_crc, data, size);
+ _size += size;
+ return S_OK;
+ #endif
+}
+
+
+HRESULT CInOutTempBuffer::WriteToStream(ISequentialOutStream *stream)
+{
+ UInt64 rem = _size;
+ // if (rem == 0) return S_OK;
+
+ const size_t numFilled = _numFilled;
+ _numFilled = 0;
+
+ for (size_t i = 0; i < numFilled; i++)
+ {
+ if (rem == 0)
+ return E_FAIL;
+ size_t cur = kBufSize;
+ if (cur > rem)
+ cur = (size_t)rem;
+ RINOK(WriteStream(stream, _bufs[i], cur))
+ rem -= cur;
+ #ifdef USE_InOutTempBuffer_FILE
+ // we will use _bufs[0] later for writing from temp file
+ if (i != 0 || !_tempFile_Created)
+ #endif
+ {
+ MyFree(_bufs[i]);
+ _bufs[i] = NULL;
+ }
+ }
+
+
+ #ifdef USE_InOutTempBuffer_FILE
+
+ if (rem == 0)
+ return _tempFile_Created ? E_FAIL : S_OK;
+
+ if (!_tempFile_Created)
+ return E_FAIL;
+
+ if (!_outFile.Close())
+ return GetLastError_noZero_HRESULT();
+
+ HRESULT hres;
+ void *buf = GetBuf(0); // index
+ if (!buf)
+ hres = E_OUTOFMEMORY;
+ else
+ {
+ NWindows::NFile::NIO::CInFile inFile;
+ if (!inFile.Open(_tempFile.GetPath()))
+ hres = GetLastError_noZero_HRESULT();
+ else
+ {
+ UInt32 crc = CRC_INIT_VAL;
+ for (;;)
+ {
+ size_t processed;
+ if (!inFile.ReadFull(buf, kBufSize, processed))
+ {
+ hres = GetLastError_noZero_HRESULT();
+ break;
+ }
+ if (processed == 0)
+ {
+ // we compare crc without CRC_GET_DIGEST
+ hres = (_crc == crc ? S_OK : E_FAIL);
+ break;
+ }
+ size_t n = processed;
+ if (n > rem)
+ n = (size_t)rem;
+ hres = WriteStream(stream, buf, n);
+ if (hres != S_OK)
+ break;
+ crc = CrcUpdate(crc, buf, n);
+ rem -= n;
+ if (n != processed)
+ {
+ hres = E_FAIL;
+ break;
+ }
+ }
+ }
+ }
+
+ // _tempFile.DisableDeleting(); // for debug
+ _tempFile.Remove();
+ RINOK(hres)
+
+ #endif
+
+ return rem == 0 ? S_OK : E_FAIL;
+}
diff --git a/CPP/7zip/Common/InOutTempBuffer.h b/CPP/7zip/Common/InOutTempBuffer.h
index 4140d28..345c386 100644
--- a/CPP/7zip/Common/InOutTempBuffer.h
+++ b/CPP/7zip/Common/InOutTempBuffer.h
@@ -1,48 +1,45 @@
-// InOutTempBuffer.h
-
-#ifndef __IN_OUT_TEMP_BUFFER_H
-#define __IN_OUT_TEMP_BUFFER_H
-
-#include "../../Common/MyCom.h"
-#include "../../Windows/FileDir.h"
-
-#include "../IStream.h"
-
-class CInOutTempBuffer
-{
- NWindows::NFile::NDir::CTempFile _tempFile;
- NWindows::NFile::NIO::COutFile _outFile;
- Byte *_buf;
- size_t _bufPos;
- UInt64 _size;
- UInt32 _crc;
- bool _tempFileCreated;
-
- bool WriteToFile(const void *data, UInt32 size);
-public:
- CInOutTempBuffer();
- ~CInOutTempBuffer();
- void Create();
-
- void InitWriting();
- bool Write(const void *data, UInt32 size);
-
- HRESULT WriteToStream(ISequentialOutStream *stream);
- UInt64 GetDataSize() const { return _size; }
-};
-
-/*
-class CSequentialOutTempBufferImp:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CInOutTempBuffer *_buf;
-public:
- void Init(CInOutTempBuffer *buffer) { _buf = buffer; }
- MY_UNKNOWN_IMP
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-*/
-
-#endif
+// InOutTempBuffer.h
+
+#ifndef ZIP7_INC_IN_OUT_TEMP_BUFFER_H
+#define ZIP7_INC_IN_OUT_TEMP_BUFFER_H
+
+// #ifdef _WIN32
+#define USE_InOutTempBuffer_FILE
+// #endif
+
+#ifdef USE_InOutTempBuffer_FILE
+#include "../../Windows/FileDir.h"
+#endif
+
+#include "../IStream.h"
+
+class CInOutTempBuffer
+{
+ UInt64 _size;
+ void **_bufs;
+ size_t _numBufs;
+ size_t _numFilled;
+
+ #ifdef USE_InOutTempBuffer_FILE
+
+ bool _tempFile_Created;
+ bool _useMemOnly;
+ UInt32 _crc;
+ // COutFile object must be declared after CTempFile object for correct destructor order
+ NWindows::NFile::NDir::CTempFile _tempFile;
+ NWindows::NFile::NIO::COutFile _outFile;
+
+ #endif
+
+ void *GetBuf(size_t index);
+
+ Z7_CLASS_NO_COPY(CInOutTempBuffer)
+public:
+ CInOutTempBuffer();
+ ~CInOutTempBuffer();
+ HRESULT Write_HRESULT(const void *data, UInt32 size);
+ HRESULT WriteToStream(ISequentialOutStream *stream);
+ UInt64 GetDataSize() const { return _size; }
+};
+
+#endif
diff --git a/CPP/7zip/Common/LimitedStreams.cpp b/CPP/7zip/Common/LimitedStreams.cpp
index fc7e794..664cd0c 100644
--- a/CPP/7zip/Common/LimitedStreams.cpp
+++ b/CPP/7zip/Common/LimitedStreams.cpp
@@ -1,367 +1,393 @@
-// LimitedStreams.cpp
-
-#include "StdAfx.h"
-
-#include <string.h>
-
-#include "LimitedStreams.h"
-
-STDMETHODIMP CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessedSize = 0;
- {
- const UInt64 rem = _size - _pos;
- if (size > rem)
- size = (UInt32)rem;
- }
- HRESULT result = S_OK;
- if (size != 0)
- {
- result = _stream->Read(data, size, &realProcessedSize);
- _pos += realProcessedSize;
- if (realProcessedSize == 0)
- _wasFinished = true;
- }
- if (processedSize)
- *processedSize = realProcessedSize;
- return result;
-}
-
-STDMETHODIMP CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (_virtPos >= _size)
- {
- // 9.31: Fixed. Windows doesn't return error in ReadFile and IStream->Read in that case.
- return S_OK;
- // return (_virtPos == _size) ? S_OK: E_FAIL; // ERROR_HANDLE_EOF
- }
- {
- const UInt64 rem = _size - _virtPos;
- if (size > rem)
- size = (UInt32)rem;
- }
- UInt64 newPos = _startOffset + _virtPos;
- if (newPos != _physPos)
- {
- _physPos = newPos;
- RINOK(SeekToPhys());
- }
- HRESULT res = _stream->Read(data, size, &size);
- if (processedSize)
- *processedSize = size;
- _physPos += size;
- _virtPos += size;
- return res;
-}
-
-STDMETHODIMP CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END: offset += _size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = offset;
- if (newPosition)
- *newPosition = _virtPos;
- return S_OK;
-}
-
-HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream)
-{
- *resStream = 0;
- CLimitedInStream *streamSpec = new CLimitedInStream;
- CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
- streamSpec->SetStream(inStream);
- RINOK(streamSpec->InitAndSeek(pos, size));
- streamSpec->SeekToStart();
- *resStream = streamTemp.Detach();
- return S_OK;
-}
-
-STDMETHODIMP CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (_virtPos >= Size)
- return S_OK;
- {
- UInt64 rem = Size - _virtPos;
- if (size > rem)
- size = (UInt32)rem;
- }
- if (size == 0)
- return S_OK;
-
- if (_curRem == 0)
- {
- const UInt32 blockSize = (UInt32)1 << BlockSizeLog;
- const UInt32 virtBlock = (UInt32)(_virtPos >> BlockSizeLog);
- const UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
- const UInt32 phyBlock = Vector[virtBlock];
-
- UInt64 newPos = StartOffset + ((UInt64)phyBlock << BlockSizeLog) + offsetInBlock;
- if (newPos != _physPos)
- {
- _physPos = newPos;
- RINOK(SeekToPhys());
- }
-
- _curRem = blockSize - offsetInBlock;
-
- for (int i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
- _curRem += (UInt32)1 << BlockSizeLog;
- }
-
- if (size > _curRem)
- size = _curRem;
- HRESULT res = Stream->Read(data, size, &size);
- if (processedSize)
- *processedSize = size;
- _physPos += size;
- _virtPos += size;
- _curRem -= size;
- return res;
-}
-
-STDMETHODIMP CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END: offset += Size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- if (_virtPos != (UInt64)offset)
- _curRem = 0;
- _virtPos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
-
-
-STDMETHODIMP CExtentsStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (_virtPos >= Extents.Back().Virt)
- return S_OK;
- if (size == 0)
- return S_OK;
-
- unsigned left = 0, right = Extents.Size() - 1;
- for (;;)
- {
- unsigned mid = (left + right) / 2;
- if (mid == left)
- break;
- if (_virtPos < Extents[mid].Virt)
- right = mid;
- else
- left = mid;
- }
-
- const CSeekExtent &extent = Extents[left];
- UInt64 phyPos = extent.Phy + (_virtPos - extent.Virt);
- if (_needStartSeek || _phyPos != phyPos)
- {
- _needStartSeek = false;
- _phyPos = phyPos;
- RINOK(SeekToPhys());
- }
-
- UInt64 rem = Extents[left + 1].Virt - _virtPos;
- if (size > rem)
- size = (UInt32)rem;
-
- HRESULT res = Stream->Read(data, size, &size);
- _phyPos += size;
- _virtPos += size;
- if (processedSize)
- *processedSize = size;
- return res;
-}
-
-STDMETHODIMP CExtentsStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END: offset += Extents.Back().Virt; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = offset;
- if (newPosition)
- *newPosition = _virtPos;
- return S_OK;
-}
-
-
-STDMETHODIMP CLimitedSequentialOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- HRESULT result = S_OK;
- if (processedSize)
- *processedSize = 0;
- if (size > _size)
- {
- if (_size == 0)
- {
- _overflow = true;
- if (!_overflowIsAllowed)
- return E_FAIL;
- if (processedSize)
- *processedSize = size;
- return S_OK;
- }
- size = (UInt32)_size;
- }
- if (_stream)
- result = _stream->Write(data, size, &size);
- _size -= size;
- if (processedSize)
- *processedSize = size;
- return result;
-}
-
-
-STDMETHODIMP CTailInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 cur;
- HRESULT res = Stream->Read(data, size, &cur);
- if (processedSize)
- *processedSize = cur;
- _virtPos += cur;
- return res;
-}
-
-STDMETHODIMP CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END:
- {
- UInt64 pos = 0;
- RINOK(Stream->Seek(offset, STREAM_SEEK_END, &pos));
- if (pos < Offset)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = pos - Offset;
- if (newPosition)
- *newPosition = _virtPos;
- return S_OK;
- }
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = offset;
- if (newPosition)
- *newPosition = _virtPos;
- return Stream->Seek(Offset + _virtPos, STREAM_SEEK_SET, NULL);
-}
-
-STDMETHODIMP CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (_virtPos >= _size)
- {
- // 9.31: Fixed. Windows doesn't return error in ReadFile and IStream->Read in that case.
- return S_OK;
- // return (_virtPos == _size) ? S_OK: E_FAIL; // ERROR_HANDLE_EOF
- }
- UInt64 rem = _size - _virtPos;
- if (rem < size)
- size = (UInt32)rem;
-
- UInt64 newPos = _startOffset + _virtPos;
- UInt64 offsetInCache = newPos - _cachePhyPos;
- HRESULT res = S_OK;
- if (newPos >= _cachePhyPos &&
- offsetInCache <= _cacheSize &&
- size <= _cacheSize - (size_t)offsetInCache)
- {
- if (size != 0)
- memcpy(data, _cache + (size_t)offsetInCache, size);
- }
- else
- {
- if (newPos != _physPos)
- {
- _physPos = newPos;
- RINOK(SeekToPhys());
- }
- res = _stream->Read(data, size, &size);
- _physPos += size;
- }
- if (processedSize)
- *processedSize = size;
- _virtPos += size;
- return res;
-}
-
-STDMETHODIMP CLimitedCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END: offset += _size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = offset;
- if (newPosition)
- *newPosition = _virtPos;
- return S_OK;
-}
-
-STDMETHODIMP CTailOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 cur;
- HRESULT res = Stream->Write(data, size, &cur);
- if (processedSize)
- *processedSize = cur;
- _virtPos += cur;
- if (_virtSize < _virtPos)
- _virtSize = _virtPos;
- return res;
-}
-
-STDMETHODIMP CTailOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _virtPos; break;
- case STREAM_SEEK_END: offset += _virtSize; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _virtPos = offset;
- if (newPosition)
- *newPosition = _virtPos;
- return Stream->Seek(Offset + _virtPos, STREAM_SEEK_SET, NULL);
-}
-
-STDMETHODIMP CTailOutStream::SetSize(UInt64 newSize)
-{
- _virtSize = newSize;
- return Stream->SetSize(Offset + newSize);
-}
+// LimitedStreams.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "LimitedStreams.h"
+
+Z7_COM7F_IMF(CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize = 0;
+ {
+ const UInt64 rem = _size - _pos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ HRESULT result = S_OK;
+ if (size != 0)
+ {
+ result = _stream->Read(data, size, &realProcessedSize);
+ _pos += realProcessedSize;
+ if (realProcessedSize == 0)
+ _wasFinished = true;
+ }
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return result;
+}
+
+Z7_COM7F_IMF(CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= _size)
+ {
+ // 9.31: Fixed. Windows doesn't return error in ReadFile and IStream->Read in that case.
+ return S_OK;
+ // return (_virtPos == _size) ? S_OK: E_FAIL; // ERROR_HANDLE_EOF
+ }
+ {
+ const UInt64 rem = _size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ UInt64 newPos = _startOffset + _virtPos;
+ if (newPos != _physPos)
+ {
+ _physPos = newPos;
+ RINOK(SeekToPhys())
+ }
+ HRESULT res = _stream->Read(data, size, &size);
+ if (processedSize)
+ *processedSize = size;
+ _physPos += size;
+ _virtPos += size;
+ return res;
+}
+
+Z7_COM7F_IMF(CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += _size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return S_OK;
+}
+
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream)
+{
+ *resStream = NULL;
+ CLimitedInStream *streamSpec = new CLimitedInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+ streamSpec->SetStream(inStream);
+ RINOK(streamSpec->InitAndSeek(pos, size))
+ streamSpec->SeekToStart();
+ *resStream = streamTemp.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= Size)
+ return S_OK;
+ {
+ UInt64 rem = Size - _virtPos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+
+ if (_curRem == 0)
+ {
+ const UInt32 blockSize = (UInt32)1 << BlockSizeLog;
+ const UInt32 virtBlock = (UInt32)(_virtPos >> BlockSizeLog);
+ const UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
+ const UInt32 phyBlock = Vector[virtBlock];
+
+ UInt64 newPos = StartOffset + ((UInt64)phyBlock << BlockSizeLog) + offsetInBlock;
+ if (newPos != _physPos)
+ {
+ _physPos = newPos;
+ RINOK(SeekToPhys())
+ }
+
+ _curRem = blockSize - offsetInBlock;
+
+ for (unsigned i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
+ _curRem += (UInt32)1 << BlockSizeLog;
+ }
+
+ if (size > _curRem)
+ size = _curRem;
+ HRESULT res = Stream->Read(data, size, &size);
+ if (processedSize)
+ *processedSize = size;
+ _physPos += size;
+ _virtPos += size;
+ _curRem -= size;
+ return res;
+}
+
+Z7_COM7F_IMF(CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ if (_virtPos != (UInt64)offset)
+ _curRem = 0;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CExtentsStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ const UInt64 virt = _virtPos;
+ if (virt >= Extents.Back().Virt)
+ return S_OK;
+ if (size == 0)
+ return S_OK;
+
+ unsigned left = _prevExtentIndex;
+ if (virt < Extents[left].Virt ||
+ virt >= Extents[left + 1].Virt)
+ {
+ left = 0;
+ unsigned right = Extents.Size() - 1;
+ for (;;)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ if (mid == left)
+ break;
+ if (virt < Extents[mid].Virt)
+ right = mid;
+ else
+ left = mid;
+ }
+ _prevExtentIndex = left;
+ }
+
+ {
+ const UInt64 rem = Extents[left + 1].Virt - virt;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ const CSeekExtent &extent = Extents[left];
+
+ if (extent.Is_ZeroFill())
+ {
+ memset(data, 0, size);
+ _virtPos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+
+ {
+ const UInt64 phy = extent.Phy + (virt - extent.Virt);
+ if (_phyPos != phy)
+ {
+ _phyPos = (UInt64)0 - 1; // we don't trust seek_pos in case of error
+ RINOK(InStream_SeekSet(Stream, phy))
+ _phyPos = phy;
+ }
+ }
+
+ const HRESULT res = Stream->Read(data, size, &size);
+ _virtPos += size;
+ if (res == S_OK)
+ _phyPos += size;
+ else
+ _phyPos = (UInt64)0 - 1; // we don't trust seek_pos in case of error
+ if (processedSize)
+ *processedSize = size;
+ return res;
+}
+
+
+Z7_COM7F_IMF(CExtentsStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += Extents.Back().Virt; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CLimitedSequentialOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (processedSize)
+ *processedSize = 0;
+ if (size > _size)
+ {
+ if (_size == 0)
+ {
+ _overflow = true;
+ if (!_overflowIsAllowed)
+ return E_FAIL;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+ size = (UInt32)_size;
+ }
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ _size -= size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+
+Z7_COM7F_IMF(CTailInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 cur;
+ HRESULT res = Stream->Read(data, size, &cur);
+ if (processedSize)
+ *processedSize = cur;
+ _virtPos += cur;
+ return res;
+}
+
+Z7_COM7F_IMF(CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END:
+ {
+ UInt64 pos = 0;
+ RINOK(Stream->Seek(offset, STREAM_SEEK_END, &pos))
+ if (pos < Offset)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = pos - Offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return S_OK;
+ }
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return InStream_SeekSet(Stream, Offset + _virtPos);
+}
+
+Z7_COM7F_IMF(CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (_virtPos >= _size)
+ {
+ // 9.31: Fixed. Windows doesn't return error in ReadFile and IStream->Read in that case.
+ return S_OK;
+ // return (_virtPos == _size) ? S_OK: E_FAIL; // ERROR_HANDLE_EOF
+ }
+ UInt64 rem = _size - _virtPos;
+ if (rem < size)
+ size = (UInt32)rem;
+
+ UInt64 newPos = _startOffset + _virtPos;
+ UInt64 offsetInCache = newPos - _cachePhyPos;
+ HRESULT res = S_OK;
+ if (newPos >= _cachePhyPos &&
+ offsetInCache <= _cacheSize &&
+ size <= _cacheSize - (size_t)offsetInCache)
+ {
+ if (size != 0)
+ memcpy(data, _cache + (size_t)offsetInCache, size);
+ }
+ else
+ {
+ if (newPos != _physPos)
+ {
+ _physPos = newPos;
+ RINOK(SeekToPhys())
+ }
+ res = _stream->Read(data, size, &size);
+ _physPos += size;
+ }
+ if (processedSize)
+ *processedSize = size;
+ _virtPos += size;
+ return res;
+}
+
+Z7_COM7F_IMF(CLimitedCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += _size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CTailOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 cur;
+ HRESULT res = Stream->Write(data, size, &cur);
+ if (processedSize)
+ *processedSize = cur;
+ _virtPos += cur;
+ if (_virtSize < _virtPos)
+ _virtSize = _virtPos;
+ return res;
+}
+
+Z7_COM7F_IMF(CTailOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _virtPos; break;
+ case STREAM_SEEK_END: offset += _virtSize; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _virtPos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = _virtPos;
+ return Stream->Seek((Int64)(Offset + _virtPos), STREAM_SEEK_SET, NULL);
+}
+
+Z7_COM7F_IMF(CTailOutStream::SetSize(UInt64 newSize))
+{
+ _virtSize = newSize;
+ return Stream->SetSize(Offset + newSize);
+}
diff --git a/CPP/7zip/Common/LimitedStreams.h b/CPP/7zip/Common/LimitedStreams.h
index 2e55aa0..69fcdcd 100644
--- a/CPP/7zip/Common/LimitedStreams.h
+++ b/CPP/7zip/Common/LimitedStreams.h
@@ -1,252 +1,221 @@
-// LimitedStreams.h
-
-#ifndef __LIMITED_STREAMS_H
-#define __LIMITED_STREAMS_H
-
-#include "../../Common/MyBuffer.h"
-#include "../../Common/MyCom.h"
-#include "../../Common/MyVector.h"
-#include "../IStream.h"
-
-class CLimitedSequentialInStream:
- public ISequentialInStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialInStream> _stream;
- UInt64 _size;
- UInt64 _pos;
- bool _wasFinished;
-public:
- void SetStream(ISequentialInStream *stream) { _stream = stream; }
- void ReleaseStream() { _stream.Release(); }
- void Init(UInt64 streamSize)
- {
- _size = streamSize;
- _pos = 0;
- _wasFinished = false;
- }
-
- MY_UNKNOWN_IMP1(ISequentialInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- UInt64 GetSize() const { return _pos; }
- UInt64 GetRem() const { return _size - _pos; }
- bool WasFinished() const { return _wasFinished; }
-};
-
-class CLimitedInStream:
- public IInStream,
- public CMyUnknownImp
-{
- CMyComPtr<IInStream> _stream;
- UInt64 _virtPos;
- UInt64 _physPos;
- UInt64 _size;
- UInt64 _startOffset;
-
- HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
-public:
- void SetStream(IInStream *stream) { _stream = stream; }
- HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
- {
- _startOffset = startOffset;
- _physPos = startOffset;
- _virtPos = 0;
- _size = size;
- return SeekToPhys();
- }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-
- HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
-};
-
-HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
-
-class CClusterInStream:
- public IInStream,
- public CMyUnknownImp
-{
- UInt64 _virtPos;
- UInt64 _physPos;
- UInt32 _curRem;
-public:
- unsigned BlockSizeLog;
- UInt64 Size;
- CMyComPtr<IInStream> Stream;
- CRecordVector<UInt32> Vector;
- UInt64 StartOffset;
-
- HRESULT SeekToPhys() { return Stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
-
- HRESULT InitAndSeek()
- {
- _curRem = 0;
- _virtPos = 0;
- _physPos = StartOffset;
- if (Vector.Size() > 0)
- {
- _physPos = StartOffset + (Vector[0] << BlockSizeLog);
- return SeekToPhys();
- }
- return S_OK;
- }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-};
-
-struct CSeekExtent
-{
- UInt64 Phy;
- UInt64 Virt;
-};
-
-class CExtentsStream:
- public IInStream,
- public CMyUnknownImp
-{
- UInt64 _phyPos;
- UInt64 _virtPos;
- bool _needStartSeek;
-
- HRESULT SeekToPhys() { return Stream->Seek(_phyPos, STREAM_SEEK_SET, NULL); }
-
-public:
- CMyComPtr<IInStream> Stream;
- CRecordVector<CSeekExtent> Extents;
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
- void ReleaseStream() { Stream.Release(); }
-
- void Init()
- {
- _virtPos = 0;
- _phyPos = 0;
- _needStartSeek = true;
- }
-};
-
-class CLimitedSequentialOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
- UInt64 _size;
- bool _overflow;
- bool _overflowIsAllowed;
-public:
- MY_UNKNOWN_IMP1(ISequentialOutStream)
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- void SetStream(ISequentialOutStream *stream) { _stream = stream; }
- void ReleaseStream() { _stream.Release(); }
- void Init(UInt64 size, bool overflowIsAllowed = false)
- {
- _size = size;
- _overflow = false;
- _overflowIsAllowed = overflowIsAllowed;
- }
- bool IsFinishedOK() const { return (_size == 0 && !_overflow); }
- UInt64 GetRem() const { return _size; }
-};
-
-
-class CTailInStream:
- public IInStream,
- public CMyUnknownImp
-{
- UInt64 _virtPos;
-public:
- CMyComPtr<IInStream> Stream;
- UInt64 Offset;
-
- void Init()
- {
- _virtPos = 0;
- }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-
- HRESULT SeekToStart() { return Stream->Seek(Offset, STREAM_SEEK_SET, NULL); }
-};
-
-class CLimitedCachedInStream:
- public IInStream,
- public CMyUnknownImp
-{
- CMyComPtr<IInStream> _stream;
- UInt64 _virtPos;
- UInt64 _physPos;
- UInt64 _size;
- UInt64 _startOffset;
-
- const Byte *_cache;
- size_t _cacheSize;
- size_t _cachePhyPos;
-
-
- HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
-public:
- CByteBuffer Buffer;
-
- void SetStream(IInStream *stream) { _stream = stream; }
- void SetCache(size_t cacheSize, size_t cachePos)
- {
- _cache = Buffer;
- _cacheSize = cacheSize;
- _cachePhyPos = cachePos;
- }
-
- HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
- {
- _startOffset = startOffset;
- _physPos = startOffset;
- _virtPos = 0;
- _size = size;
- return SeekToPhys();
- }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-
- HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
-};
-
-class CTailOutStream:
- public IOutStream,
- public CMyUnknownImp
-{
- UInt64 _virtPos;
- UInt64 _virtSize;
-public:
- CMyComPtr<IOutStream> Stream;
- UInt64 Offset;
-
- virtual ~CTailOutStream() {}
-
- MY_UNKNOWN_IMP2(ISequentialOutStream, IOutStream)
-
- void Init()
- {
- _virtPos = 0;
- _virtSize = 0;
- }
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
- STDMETHOD(SetSize)(UInt64 newSize);
-};
-
-#endif
+// LimitedStreams.h
+
+#ifndef ZIP7_INC_LIMITED_STREAMS_H
+#define ZIP7_INC_LIMITED_STREAMS_H
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+#include "../IStream.h"
+
+#include "StreamUtils.h"
+
+Z7_CLASS_IMP_COM_1(
+ CLimitedSequentialInStream
+ , ISequentialInStream
+)
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt64 _size;
+ UInt64 _pos;
+ bool _wasFinished;
+public:
+ void SetStream(ISequentialInStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init(UInt64 streamSize)
+ {
+ _size = streamSize;
+ _pos = 0;
+ _wasFinished = false;
+ }
+ UInt64 GetSize() const { return _pos; }
+ UInt64 GetRem() const { return _size - _pos; }
+ bool WasFinished() const { return _wasFinished; }
+};
+
+
+Z7_CLASS_IMP_IInStream(
+ CLimitedInStream
+)
+ CMyComPtr<IInStream> _stream;
+ UInt64 _virtPos;
+ UInt64 _physPos;
+ UInt64 _size;
+ UInt64 _startOffset;
+
+ HRESULT SeekToPhys() { return InStream_SeekSet(_stream, _physPos); }
+public:
+ void SetStream(IInStream *stream) { _stream = stream; }
+ HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
+ {
+ _startOffset = startOffset;
+ _physPos = startOffset;
+ _virtPos = 0;
+ _size = size;
+ return SeekToPhys();
+ }
+ HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
+};
+
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
+
+
+Z7_CLASS_IMP_IInStream(
+ CClusterInStream
+)
+ UInt64 _virtPos;
+ UInt64 _physPos;
+ UInt32 _curRem;
+public:
+ unsigned BlockSizeLog;
+ UInt64 Size;
+ CMyComPtr<IInStream> Stream;
+ CRecordVector<UInt32> Vector;
+ UInt64 StartOffset;
+
+ HRESULT SeekToPhys() { return InStream_SeekSet(Stream, _physPos); }
+
+ HRESULT InitAndSeek()
+ {
+ _curRem = 0;
+ _virtPos = 0;
+ _physPos = StartOffset;
+ if (Vector.Size() > 0)
+ {
+ _physPos = StartOffset + (Vector[0] << BlockSizeLog);
+ return SeekToPhys();
+ }
+ return S_OK;
+ }
+};
+
+
+
+const UInt64 k_SeekExtent_Phy_Type_ZeroFill = (UInt64)(Int64)-1;
+
+struct CSeekExtent
+{
+ UInt64 Virt;
+ UInt64 Phy;
+
+ void SetAs_ZeroFill() { Phy = k_SeekExtent_Phy_Type_ZeroFill; }
+ bool Is_ZeroFill() const { return Phy == k_SeekExtent_Phy_Type_ZeroFill; }
+};
+
+
+Z7_CLASS_IMP_IInStream(
+ CExtentsStream
+)
+ UInt64 _virtPos;
+ UInt64 _phyPos;
+ unsigned _prevExtentIndex;
+public:
+ CMyComPtr<IInStream> Stream;
+ CRecordVector<CSeekExtent> Extents;
+
+ void ReleaseStream() { Stream.Release(); }
+ void Init()
+ {
+ _virtPos = 0;
+ _phyPos = (UInt64)0 - 1; // we need Seek() for Stream
+ _prevExtentIndex = 0;
+ }
+};
+
+
+
+Z7_CLASS_IMP_COM_1(
+ CLimitedSequentialOutStream
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+ bool _overflow;
+ bool _overflowIsAllowed;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init(UInt64 size, bool overflowIsAllowed = false)
+ {
+ _size = size;
+ _overflow = false;
+ _overflowIsAllowed = overflowIsAllowed;
+ }
+ bool IsFinishedOK() const { return (_size == 0 && !_overflow); }
+ UInt64 GetRem() const { return _size; }
+};
+
+
+Z7_CLASS_IMP_IInStream(
+ CTailInStream
+)
+ UInt64 _virtPos;
+public:
+ CMyComPtr<IInStream> Stream;
+ UInt64 Offset;
+
+ void Init()
+ {
+ _virtPos = 0;
+ }
+ HRESULT SeekToStart() { return InStream_SeekSet(Stream, Offset); }
+};
+
+
+Z7_CLASS_IMP_IInStream(
+ CLimitedCachedInStream
+)
+ CMyComPtr<IInStream> _stream;
+ UInt64 _virtPos;
+ UInt64 _physPos;
+ UInt64 _size;
+ UInt64 _startOffset;
+
+ const Byte *_cache;
+ size_t _cacheSize;
+ size_t _cachePhyPos;
+
+ HRESULT SeekToPhys() { return InStream_SeekSet(_stream, _physPos); }
+public:
+ CByteBuffer Buffer;
+
+ void SetStream(IInStream *stream) { _stream = stream; }
+ void SetCache(size_t cacheSize, size_t cachePos)
+ {
+ _cache = Buffer;
+ _cacheSize = cacheSize;
+ _cachePhyPos = cachePos;
+ }
+
+ HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
+ {
+ _startOffset = startOffset;
+ _physPos = startOffset;
+ _virtPos = 0;
+ _size = size;
+ return SeekToPhys();
+ }
+
+ HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
+};
+
+
+class CTailOutStream Z7_final :
+ public IOutStream,
+ public CMyUnknownImp
+{
+ Z7_IFACES_IMP_UNK_2(ISequentialOutStream, IOutStream)
+
+ UInt64 _virtPos;
+ UInt64 _virtSize;
+public:
+ CMyComPtr<IOutStream> Stream;
+ UInt64 Offset;
+
+ void Init()
+ {
+ _virtPos = 0;
+ _virtSize = 0;
+ }
+};
+
+#endif
diff --git a/CPP/7zip/Common/LockedStream.cpp b/CPP/7zip/Common/LockedStream.cpp
index 1223efe..ca39fb4 100644
--- a/CPP/7zip/Common/LockedStream.cpp
+++ b/CPP/7zip/Common/LockedStream.cpp
@@ -1,3 +1,3 @@
-// LockedStream.cpp
-
-#include "StdAfx.h"
+// LockedStream.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Common/LockedStream.h b/CPP/7zip/Common/LockedStream.h
index 5bf5c85..99ee805 100644
--- a/CPP/7zip/Common/LockedStream.h
+++ b/CPP/7zip/Common/LockedStream.h
@@ -1,6 +1,6 @@
-// LockedStream.h
-
-#ifndef __LOCKED_STREAM_H
-#define __LOCKED_STREAM_H
-
-#endif
+// LockedStream.h
+
+#ifndef ZIP7_INC_LOCKED_STREAM_H
+#define ZIP7_INC_LOCKED_STREAM_H
+
+#endif
diff --git a/CPP/7zip/Common/MemBlocks.cpp b/CPP/7zip/Common/MemBlocks.cpp
new file mode 100644
index 0000000..aa68244
--- /dev/null
+++ b/CPP/7zip/Common/MemBlocks.cpp
@@ -0,0 +1,215 @@
+// MemBlocks.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "MemBlocks.h"
+#include "StreamUtils.h"
+
+bool CMemBlockManager::AllocateSpace_bool(size_t numBlocks)
+{
+ FreeSpace();
+ if (numBlocks == 0)
+ {
+ return true;
+ // return false;
+ }
+ if (_blockSize < sizeof(void *))
+ return false;
+ const size_t totalSize = numBlocks * _blockSize;
+ if (totalSize / _blockSize != numBlocks)
+ return false;
+ _data = ::MidAlloc(totalSize);
+ if (!_data)
+ return false;
+ Byte *p = (Byte *)_data;
+ for (size_t i = 0; i + 1 < numBlocks; i++, p += _blockSize)
+ *(Byte **)(void *)p = (p + _blockSize);
+ *(Byte **)(void *)p = NULL;
+ _headFree = _data;
+ return true;
+}
+
+void CMemBlockManager::FreeSpace()
+{
+ ::MidFree(_data);
+ _data = NULL;
+ _headFree= NULL;
+}
+
+void *CMemBlockManager::AllocateBlock()
+{
+ void *p = _headFree;
+ if (p)
+ _headFree = *(void **)p;
+ return p;
+}
+
+void CMemBlockManager::FreeBlock(void *p)
+{
+ if (!p)
+ return;
+ *(void **)p = _headFree;
+ _headFree = p;
+}
+
+
+// #include <stdio.h>
+
+HRes CMemBlockManagerMt::AllocateSpace(size_t numBlocks, size_t numNoLockBlocks)
+{
+ if (numNoLockBlocks > numBlocks)
+ return E_INVALIDARG;
+ const size_t numLockBlocks = numBlocks - numNoLockBlocks;
+ UInt32 maxCount = (UInt32)numLockBlocks;
+ if (maxCount != numLockBlocks)
+ return E_OUTOFMEMORY;
+ if (!CMemBlockManager::AllocateSpace_bool(numBlocks))
+ return E_OUTOFMEMORY;
+ // we need (maxCount = 1), if we want to create non-use empty Semaphore
+ if (maxCount == 0)
+ maxCount = 1;
+
+ // printf("\n Synchro.Create() \n");
+ WRes wres;
+ #ifndef _WIN32
+ Semaphore.Close();
+ wres = Synchro.Create();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ wres = Semaphore.Create(&Synchro, (UInt32)numLockBlocks, maxCount);
+ #else
+ wres = Semaphore.OptCreateInit((UInt32)numLockBlocks, maxCount);
+ #endif
+
+ return HRESULT_FROM_WIN32(wres);
+}
+
+
+HRes CMemBlockManagerMt::AllocateSpaceAlways(size_t desiredNumberOfBlocks, size_t numNoLockBlocks)
+{
+ // desiredNumberOfBlocks = 0; // for debug
+ if (numNoLockBlocks > desiredNumberOfBlocks)
+ return E_INVALIDARG;
+ for (;;)
+ {
+ // if (desiredNumberOfBlocks == 0) return E_OUTOFMEMORY;
+ HRes hres = AllocateSpace(desiredNumberOfBlocks, numNoLockBlocks);
+ if (hres != E_OUTOFMEMORY)
+ return hres;
+ if (desiredNumberOfBlocks == numNoLockBlocks)
+ return E_OUTOFMEMORY;
+ desiredNumberOfBlocks = numNoLockBlocks + ((desiredNumberOfBlocks - numNoLockBlocks) >> 1);
+ }
+}
+
+void CMemBlockManagerMt::FreeSpace()
+{
+ Semaphore.Close();
+ CMemBlockManager::FreeSpace();
+}
+
+void *CMemBlockManagerMt::AllocateBlock()
+{
+ // Semaphore.Lock();
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ return CMemBlockManager::AllocateBlock();
+}
+
+void CMemBlockManagerMt::FreeBlock(void *p, bool lockMode)
+{
+ if (!p)
+ return;
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ CMemBlockManager::FreeBlock(p);
+ }
+ if (lockMode)
+ Semaphore.Release();
+}
+
+
+
+void CMemBlocks::Free(CMemBlockManagerMt *manager)
+{
+ while (Blocks.Size() > 0)
+ {
+ manager->FreeBlock(Blocks.Back());
+ Blocks.DeleteBack();
+ }
+ TotalSize = 0;
+}
+
+void CMemBlocks::FreeOpt(CMemBlockManagerMt *manager)
+{
+ Free(manager);
+ Blocks.ClearAndFree();
+}
+
+HRESULT CMemBlocks::WriteToStream(size_t blockSize, ISequentialOutStream *outStream) const
+{
+ UInt64 totalSize = TotalSize;
+ for (unsigned blockIndex = 0; totalSize > 0; blockIndex++)
+ {
+ size_t curSize = blockSize;
+ if (curSize > totalSize)
+ curSize = (size_t)totalSize;
+ if (blockIndex >= Blocks.Size())
+ return E_FAIL;
+ RINOK(WriteStream(outStream, Blocks[blockIndex], curSize))
+ totalSize -= curSize;
+ }
+ return S_OK;
+}
+
+
+void CMemLockBlocks::FreeBlock(unsigned index, CMemBlockManagerMt *memManager)
+{
+ memManager->FreeBlock(Blocks[index], LockMode);
+ Blocks[index] = NULL;
+}
+
+void CMemLockBlocks::Free(CMemBlockManagerMt *memManager)
+{
+ while (Blocks.Size() > 0)
+ {
+ FreeBlock(Blocks.Size() - 1, memManager);
+ Blocks.DeleteBack();
+ }
+ TotalSize = 0;
+}
+
+/*
+HRes CMemLockBlocks::SwitchToNoLockMode(CMemBlockManagerMt *memManager)
+{
+ if (LockMode)
+ {
+ if (Blocks.Size() > 0)
+ {
+ RINOK(memManager->ReleaseLockedBlocks(Blocks.Size()));
+ }
+ LockMode = false;
+ }
+ return 0;
+}
+*/
+
+void CMemLockBlocks::Detach(CMemLockBlocks &blocks, CMemBlockManagerMt *memManager)
+{
+ blocks.Free(memManager);
+ blocks.LockMode = LockMode;
+ UInt64 totalSize = 0;
+ const size_t blockSize = memManager->GetBlockSize();
+ FOR_VECTOR (i, Blocks)
+ {
+ if (totalSize < TotalSize)
+ blocks.Blocks.Add(Blocks[i]);
+ else
+ FreeBlock(i, memManager);
+ Blocks[i] = NULL;
+ totalSize += blockSize;
+ }
+ blocks.TotalSize = TotalSize;
+ Free(memManager);
+}
diff --git a/CPP/7zip/Common/MemBlocks.h b/CPP/7zip/Common/MemBlocks.h
new file mode 100644
index 0000000..7c34f21
--- /dev/null
+++ b/CPP/7zip/Common/MemBlocks.h
@@ -0,0 +1,72 @@
+// MemBlocks.h
+
+#ifndef ZIP7_INC_MEM_BLOCKS_H
+#define ZIP7_INC_MEM_BLOCKS_H
+
+#include "../../Common/MyVector.h"
+
+#include "../../Windows/Synchronization.h"
+
+#include "../IStream.h"
+
+class CMemBlockManager
+{
+ void *_data;
+ size_t _blockSize;
+ void *_headFree;
+public:
+ CMemBlockManager(size_t blockSize = (1 << 20)): _data(NULL), _blockSize(blockSize), _headFree(NULL) {}
+ ~CMemBlockManager() { FreeSpace(); }
+
+ bool AllocateSpace_bool(size_t numBlocks);
+ void FreeSpace();
+ size_t GetBlockSize() const { return _blockSize; }
+ void *AllocateBlock();
+ void FreeBlock(void *p);
+};
+
+
+class CMemBlockManagerMt: public CMemBlockManager
+{
+ NWindows::NSynchronization::CCriticalSection _criticalSection;
+public:
+ SYNC_OBJ_DECL(Synchro)
+ NWindows::NSynchronization::CSemaphore_WFMO Semaphore;
+
+ CMemBlockManagerMt(size_t blockSize = (1 << 20)): CMemBlockManager(blockSize) {}
+ ~CMemBlockManagerMt() { FreeSpace(); }
+
+ HRes AllocateSpace(size_t numBlocks, size_t numNoLockBlocks);
+ HRes AllocateSpaceAlways(size_t desiredNumberOfBlocks, size_t numNoLockBlocks = 0);
+ void FreeSpace();
+ void *AllocateBlock();
+ void FreeBlock(void *p, bool lockMode = true);
+ // WRes ReleaseLockedBlocks_WRes(unsigned number) { return Semaphore.Release(number); }
+};
+
+
+class CMemBlocks
+{
+ void Free(CMemBlockManagerMt *manager);
+public:
+ CRecordVector<void *> Blocks;
+ UInt64 TotalSize;
+
+ CMemBlocks(): TotalSize(0) {}
+
+ void FreeOpt(CMemBlockManagerMt *manager);
+ HRESULT WriteToStream(size_t blockSize, ISequentialOutStream *outStream) const;
+};
+
+struct CMemLockBlocks: public CMemBlocks
+{
+ bool LockMode;
+
+ CMemLockBlocks(): LockMode(true) {}
+ void Free(CMemBlockManagerMt *memManager);
+ void FreeBlock(unsigned index, CMemBlockManagerMt *memManager);
+ // HRes SwitchToNoLockMode(CMemBlockManagerMt *memManager);
+ void Detach(CMemLockBlocks &blocks, CMemBlockManagerMt *memManager);
+};
+
+#endif
diff --git a/CPP/7zip/Common/MethodId.cpp b/CPP/7zip/Common/MethodId.cpp
index 9a07e4c..1566c97 100644
--- a/CPP/7zip/Common/MethodId.cpp
+++ b/CPP/7zip/Common/MethodId.cpp
@@ -1,3 +1,3 @@
-// MethodId.cpp
-
-#include "StdAfx.h"
+// MethodId.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Common/MethodId.h b/CPP/7zip/Common/MethodId.h
index 1ba9f49..19b1f10 100644
--- a/CPP/7zip/Common/MethodId.h
+++ b/CPP/7zip/Common/MethodId.h
@@ -1,10 +1,10 @@
-// MethodId.h
-
-#ifndef __7Z_METHOD_ID_H
-#define __7Z_METHOD_ID_H
-
-#include "../../Common/MyTypes.h"
-
-typedef UInt64 CMethodId;
-
-#endif
+// MethodId.h
+
+#ifndef ZIP7_INC_7Z_METHOD_ID_H
+#define ZIP7_INC_7Z_METHOD_ID_H
+
+#include "../../Common/MyTypes.h"
+
+typedef UInt64 CMethodId;
+
+#endif
diff --git a/CPP/7zip/Common/MethodProps.cpp b/CPP/7zip/Common/MethodProps.cpp
index 2134462..fe60f61 100644
--- a/CPP/7zip/Common/MethodProps.cpp
+++ b/CPP/7zip/Common/MethodProps.cpp
@@ -1,509 +1,737 @@
-// MethodProps.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/StringToInt.h"
-
-#include "MethodProps.h"
-
-using namespace NWindows;
-
-bool StringToBool(const wchar_t *s, bool &res)
-{
- if (s[0] == 0 || (s[0] == '+' && s[1] == 0) || StringsAreEqualNoCase_Ascii(s, "ON"))
- {
- res = true;
- return true;
- }
- if ((s[0] == '-' && s[1] == 0) || StringsAreEqualNoCase_Ascii(s, "OFF"))
- {
- res = false;
- return true;
- }
- return false;
-}
-
-HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest)
-{
- switch (prop.vt)
- {
- case VT_EMPTY: dest = true; return S_OK;
- case VT_BOOL: dest = (prop.boolVal != VARIANT_FALSE); return S_OK;
- case VT_BSTR: return StringToBool(prop.bstrVal, dest) ? S_OK : E_INVALIDARG;
- }
- return E_INVALIDARG;
-}
-
-unsigned ParseStringToUInt32(const UString &srcString, UInt32 &number)
-{
- const wchar_t *start = srcString;
- const wchar_t *end;
- number = ConvertStringToUInt32(start, &end);
- return (unsigned)(end - start);
-}
-
-static unsigned ParseStringToUInt64(const UString &srcString, UInt64 &number)
-{
- const wchar_t *start = srcString;
- const wchar_t *end;
- number = ConvertStringToUInt64(start, &end);
- return (unsigned)(end - start);
-}
-
-HRESULT ParsePropToUInt32(const UString &name, const PROPVARIANT &prop, UInt32 &resValue)
-{
- // =VT_UI4
- // =VT_EMPTY
- // {stringUInt32}=VT_EMPTY
-
- if (prop.vt == VT_UI4)
- {
- if (!name.IsEmpty())
- return E_INVALIDARG;
- resValue = prop.ulVal;
- return S_OK;
- }
- if (prop.vt != VT_EMPTY)
- return E_INVALIDARG;
- if (name.IsEmpty())
- return S_OK;
- UInt32 v;
- if (ParseStringToUInt32(name, v) != name.Len())
- return E_INVALIDARG;
- resValue = v;
- return S_OK;
-}
-
-HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads)
-{
- if (name.IsEmpty())
- {
- switch (prop.vt)
- {
- case VT_UI4:
- numThreads = prop.ulVal;
- break;
- default:
- {
- bool val;
- RINOK(PROPVARIANT_to_bool(prop, val));
- numThreads = (val ? defaultNumThreads : 1);
- break;
- }
- }
- return S_OK;
- }
- if (prop.vt != VT_EMPTY)
- return E_INVALIDARG;
- return ParsePropToUInt32(name, prop, numThreads);
-}
-
-
-static HRESULT StringToDictSize(const UString &s, NCOM::CPropVariant &destProp)
-{
- const wchar_t *end;
- UInt32 number = ConvertStringToUInt32(s, &end);
- unsigned numDigits = (unsigned)(end - s.Ptr());
- if (numDigits == 0 || s.Len() > numDigits + 1)
- return E_INVALIDARG;
-
- if (s.Len() == numDigits)
- {
- if (number >= 64)
- return E_INVALIDARG;
- if (number < 32)
- destProp = (UInt32)((UInt32)1 << (unsigned)number);
- else
- destProp = (UInt64)((UInt64)1 << (unsigned)number);
- return S_OK;
- }
-
- unsigned numBits;
-
- switch (MyCharLower_Ascii(s[numDigits]))
- {
- case 'b': destProp = number; return S_OK;
- case 'k': numBits = 10; break;
- case 'm': numBits = 20; break;
- case 'g': numBits = 30; break;
- default: return E_INVALIDARG;
- }
-
- if (number < ((UInt32)1 << (32 - numBits)))
- destProp = (UInt32)(number << numBits);
- else
- destProp = (UInt64)((UInt64)number << numBits);
-
- return S_OK;
-}
-
-
-static HRESULT PROPVARIANT_to_DictSize(const PROPVARIANT &prop, NCOM::CPropVariant &destProp)
-{
- if (prop.vt == VT_UI4)
- {
- UInt32 v = prop.ulVal;
- if (v >= 64)
- return E_INVALIDARG;
- if (v < 32)
- destProp = (UInt32)((UInt32)1 << (unsigned)v);
- else
- destProp = (UInt64)((UInt64)1 << (unsigned)v);
- return S_OK;
- }
- if (prop.vt == VT_BSTR)
- {
- UString s;
- s = prop.bstrVal;
- return StringToDictSize(s, destProp);
- }
- return E_INVALIDARG;
-}
-
-
-void CProps::AddProp32(PROPID propid, UInt32 val)
-{
- CProp &prop = Props.AddNew();
- prop.IsOptional = true;
- prop.Id = propid;
- prop.Value = (UInt32)val;
-}
-
-void CProps::AddPropBool(PROPID propid, bool val)
-{
- CProp &prop = Props.AddNew();
- prop.IsOptional = true;
- prop.Id = propid;
- prop.Value = val;
-}
-
-class CCoderProps
-{
- PROPID *_propIDs;
- NCOM::CPropVariant *_props;
- unsigned _numProps;
- unsigned _numPropsMax;
-public:
- CCoderProps(unsigned numPropsMax)
- {
- _numPropsMax = numPropsMax;
- _numProps = 0;
- _propIDs = new PROPID[numPropsMax];
- _props = new NCOM::CPropVariant[numPropsMax];
- }
- ~CCoderProps()
- {
- delete []_propIDs;
- delete []_props;
- }
- void AddProp(const CProp &prop);
- HRESULT SetProps(ICompressSetCoderProperties *setCoderProperties)
- {
- return setCoderProperties->SetCoderProperties(_propIDs, _props, _numProps);
- }
-};
-
-void CCoderProps::AddProp(const CProp &prop)
-{
- if (_numProps >= _numPropsMax)
- throw 1;
- _propIDs[_numProps] = prop.Id;
- _props[_numProps] = prop.Value;
- _numProps++;
-}
-
-HRESULT CProps::SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const
-{
- CCoderProps coderProps(Props.Size() + (dataSizeReduce ? 1 : 0));
- FOR_VECTOR (i, Props)
- coderProps.AddProp(Props[i]);
- if (dataSizeReduce)
- {
- CProp prop;
- prop.Id = NCoderPropID::kReduceSize;
- prop.Value = *dataSizeReduce;
- coderProps.AddProp(prop);
- }
- return coderProps.SetProps(scp);
-}
-
-
-int CMethodProps::FindProp(PROPID id) const
-{
- for (int i = Props.Size() - 1; i >= 0; i--)
- if (Props[i].Id == id)
- return i;
- return -1;
-}
-
-int CMethodProps::GetLevel() const
-{
- int i = FindProp(NCoderPropID::kLevel);
- if (i < 0)
- return 5;
- if (Props[i].Value.vt != VT_UI4)
- return 9;
- UInt32 level = Props[i].Value.ulVal;
- return level > 9 ? 9 : (int)level;
-}
-
-struct CNameToPropID
-{
- VARTYPE VarType;
- const char *Name;
-};
-
-
-// the following are related to NCoderPropID::EEnum values
-
-static const CNameToPropID g_NameToPropID[] =
-{
- { VT_UI4, "" },
- { VT_UI4, "d" },
- { VT_UI4, "mem" },
- { VT_UI4, "o" },
- { VT_UI4, "c" },
- { VT_UI4, "pb" },
- { VT_UI4, "lc" },
- { VT_UI4, "lp" },
- { VT_UI4, "fb" },
- { VT_BSTR, "mf" },
- { VT_UI4, "mc" },
- { VT_UI4, "pass" },
- { VT_UI4, "a" },
- { VT_UI4, "mt" },
- { VT_BOOL, "eos" },
- { VT_UI4, "x" },
- { VT_UI8, "reduce" },
- { VT_UI8, "expect" },
- { VT_UI4, "b" },
- { VT_UI4, "check" },
- { VT_BSTR, "filter" },
- { VT_UI8, "memuse" }
-};
-
-static int FindPropIdExact(const UString &name)
-{
- for (unsigned i = 0; i < ARRAY_SIZE(g_NameToPropID); i++)
- if (StringsAreEqualNoCase_Ascii(name, g_NameToPropID[i].Name))
- return i;
- return -1;
-}
-
-static bool ConvertProperty(const PROPVARIANT &srcProp, VARTYPE varType, NCOM::CPropVariant &destProp)
-{
- if (varType == srcProp.vt)
- {
- destProp = srcProp;
- return true;
- }
-
- if (varType == VT_UI8 && srcProp.vt == VT_UI4)
- {
- destProp = (UInt64)srcProp.ulVal;
- return true;
- }
-
- if (varType == VT_BOOL)
- {
- bool res;
- if (PROPVARIANT_to_bool(srcProp, res) != S_OK)
- return false;
- destProp = res;
- return true;
- }
- if (srcProp.vt == VT_EMPTY)
- {
- destProp = srcProp;
- return true;
- }
- return false;
-}
-
-static void SplitParams(const UString &srcString, UStringVector &subStrings)
-{
- subStrings.Clear();
- UString s;
- unsigned len = srcString.Len();
- if (len == 0)
- return;
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = srcString[i];
- if (c == L':')
- {
- subStrings.Add(s);
- s.Empty();
- }
- else
- s += c;
- }
- subStrings.Add(s);
-}
-
-static void SplitParam(const UString ¶m, UString &name, UString &value)
-{
- int eqPos = param.Find(L'=');
- if (eqPos >= 0)
- {
- name.SetFrom(param, eqPos);
- value = param.Ptr(eqPos + 1);
- return;
- }
- unsigned i;
- for (i = 0; i < param.Len(); i++)
- {
- wchar_t c = param[i];
- if (c >= L'0' && c <= L'9')
- break;
- }
- name.SetFrom(param, i);
- value = param.Ptr(i);
-}
-
-static bool IsLogSizeProp(PROPID propid)
-{
- switch (propid)
- {
- case NCoderPropID::kDictionarySize:
- case NCoderPropID::kUsedMemorySize:
- case NCoderPropID::kBlockSize:
- case NCoderPropID::kBlockSize2:
- // case NCoderPropID::kReduceSize:
- return true;
- }
- return false;
-}
-
-HRESULT CMethodProps::SetParam(const UString &name, const UString &value)
-{
- int index = FindPropIdExact(name);
- if (index < 0)
- return E_INVALIDARG;
- const CNameToPropID &nameToPropID = g_NameToPropID[(unsigned)index];
- CProp prop;
- prop.Id = index;
-
- if (IsLogSizeProp(prop.Id))
- {
- RINOK(StringToDictSize(value, prop.Value));
- }
- else
- {
- NCOM::CPropVariant propValue;
- if (nameToPropID.VarType == VT_BSTR)
- propValue = value;
- else if (nameToPropID.VarType == VT_BOOL)
- {
- bool res;
- if (!StringToBool(value, res))
- return E_INVALIDARG;
- propValue = res;
- }
- else if (!value.IsEmpty())
- {
- if (nameToPropID.VarType == VT_UI4)
- {
- UInt32 number;
- if (ParseStringToUInt32(value, number) == value.Len())
- propValue = number;
- else
- propValue = value;
- }
- else if (nameToPropID.VarType == VT_UI8)
- {
- UInt64 number;
- if (ParseStringToUInt64(value, number) == value.Len())
- propValue = number;
- else
- propValue = value;
- }
- else
- propValue = value;
- }
- if (!ConvertProperty(propValue, nameToPropID.VarType, prop.Value))
- return E_INVALIDARG;
- }
- Props.Add(prop);
- return S_OK;
-}
-
-HRESULT CMethodProps::ParseParamsFromString(const UString &srcString)
-{
- UStringVector params;
- SplitParams(srcString, params);
- FOR_VECTOR (i, params)
- {
- const UString ¶m = params[i];
- UString name, value;
- SplitParam(param, name, value);
- RINOK(SetParam(name, value));
- }
- return S_OK;
-}
-
-HRESULT CMethodProps::ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value)
-{
- if (realName.Len() == 0)
- {
- // [empty]=method
- return E_INVALIDARG;
- }
- if (value.vt == VT_EMPTY)
- {
- // {realName}=[empty]
- UString name, valueStr;
- SplitParam(realName, name, valueStr);
- return SetParam(name, valueStr);
- }
-
- // {realName}=value
- int index = FindPropIdExact(realName);
- if (index < 0)
- return E_INVALIDARG;
- const CNameToPropID &nameToPropID = g_NameToPropID[(unsigned)index];
- CProp prop;
- prop.Id = index;
-
- if (IsLogSizeProp(prop.Id))
- {
- RINOK(PROPVARIANT_to_DictSize(value, prop.Value));
- }
- else
- {
- if (!ConvertProperty(value, nameToPropID.VarType, prop.Value))
- return E_INVALIDARG;
- }
- Props.Add(prop);
- return S_OK;
-}
-
-HRESULT COneMethodInfo::ParseMethodFromString(const UString &s)
-{
- MethodName.Empty();
- int splitPos = s.Find(L':');
- {
- UString temp = s;
- if (splitPos >= 0)
- temp.DeleteFrom(splitPos);
- if (!temp.IsAscii())
- return E_INVALIDARG;
- MethodName.SetFromWStr_if_Ascii(temp);
- }
- if (splitPos < 0)
- return S_OK;
- PropsString = s.Ptr(splitPos + 1);
- return ParseParamsFromString(PropsString);
-}
-
-HRESULT COneMethodInfo::ParseMethodFromPROPVARIANT(const UString &realName, const PROPVARIANT &value)
-{
- if (!realName.IsEmpty() && !StringsAreEqualNoCase_Ascii(realName, "m"))
- return ParseParamsFromPROPVARIANT(realName, value);
- // -m{N}=method
- if (value.vt != VT_BSTR)
- return E_INVALIDARG;
- UString s;
- s = value.bstrVal;
- return ParseMethodFromString(s);
-}
+// MethodProps.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/StringToInt.h"
+
+#include "MethodProps.h"
+
+using namespace NWindows;
+
+UInt64 Calc_From_Val_Percents(UInt64 val, UInt64 percents)
+{
+ // if (percents == 0) return 0;
+ const UInt64 q = percents / 100;
+ const UInt32 r = (UInt32)(percents % 100);
+ UInt64 res = 0;
+
+ if (q != 0)
+ {
+ if (val > (UInt64)(Int64)-1 / q)
+ return (UInt64)(Int64)-1;
+ res = val * q;
+ }
+
+ if (r != 0)
+ {
+ UInt64 v2;
+ if (val <= (UInt64)(Int64)-1 / r)
+ v2 = val * r / 100;
+ else
+ v2 = val / 100 * r;
+ res += v2;
+ if (res < v2)
+ return (UInt64)(Int64)-1;
+ }
+
+ return res;
+}
+
+
+bool StringToBool(const wchar_t *s, bool &res)
+{
+ if (s[0] == 0 || (s[0] == '+' && s[1] == 0) || StringsAreEqualNoCase_Ascii(s, "ON"))
+ {
+ res = true;
+ return true;
+ }
+ if ((s[0] == '-' && s[1] == 0) || StringsAreEqualNoCase_Ascii(s, "OFF"))
+ {
+ res = false;
+ return true;
+ }
+ return false;
+}
+
+HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest)
+{
+ switch (prop.vt)
+ {
+ case VT_EMPTY: dest = true; return S_OK;
+ case VT_BOOL: dest = (prop.boolVal != VARIANT_FALSE); return S_OK;
+ case VT_BSTR: return StringToBool(prop.bstrVal, dest) ? S_OK : E_INVALIDARG;
+ }
+ return E_INVALIDARG;
+}
+
+unsigned ParseStringToUInt32(const UString &srcString, UInt32 &number)
+{
+ const wchar_t *start = srcString;
+ const wchar_t *end;
+ number = ConvertStringToUInt32(start, &end);
+ return (unsigned)(end - start);
+}
+
+static unsigned ParseStringToUInt64(const UString &srcString, UInt64 &number)
+{
+ const wchar_t *start = srcString;
+ const wchar_t *end;
+ number = ConvertStringToUInt64(start, &end);
+ return (unsigned)(end - start);
+}
+
+HRESULT ParsePropToUInt32(const UString &name, const PROPVARIANT &prop, UInt32 &resValue)
+{
+ // =VT_UI4
+ // =VT_EMPTY : it doesn't change (resValue), and returns S_OK
+ // {stringUInt32}=VT_EMPTY
+
+ if (prop.vt == VT_UI4)
+ {
+ if (!name.IsEmpty())
+ return E_INVALIDARG;
+ resValue = prop.ulVal;
+ return S_OK;
+ }
+ if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ if (name.IsEmpty())
+ return S_OK;
+ UInt32 v;
+ if (ParseStringToUInt32(name, v) != name.Len())
+ return E_INVALIDARG;
+ resValue = v;
+ return S_OK;
+}
+
+
+
+HRESULT ParseMtProp2(const UString &name, const PROPVARIANT &prop, UInt32 &numThreads, bool &force)
+{
+ force = false;
+ UString s;
+ if (name.IsEmpty())
+ {
+ if (prop.vt == VT_UI4)
+ {
+ numThreads = prop.ulVal;
+ force = true;
+ return S_OK;
+ }
+ bool val;
+ HRESULT res = PROPVARIANT_to_bool(prop, val);
+ if (res == S_OK)
+ {
+ if (!val)
+ {
+ numThreads = 1;
+ force = true;
+ }
+ // force = true; for debug
+ // "(VT_BOOL = VARIANT_TRUE)" set "force = false" and doesn't change numThreads
+ return S_OK;
+ }
+ if (prop.vt != VT_BSTR)
+ return res;
+ s.SetFromBstr(prop.bstrVal);
+ if (s.IsEmpty())
+ return E_INVALIDARG;
+ }
+ else
+ {
+ if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ s = name;
+ }
+
+ s.MakeLower_Ascii();
+ const wchar_t *start = s;
+ UInt32 v = numThreads;
+
+ /* we force up, if threads number specified
+ only `d` will force it down */
+ bool force_loc = true;
+ for (;;)
+ {
+ const wchar_t c = *start;
+ if (!c)
+ break;
+ if (c == 'd')
+ {
+ force_loc = false; // force down
+ start++;
+ continue;
+ }
+ if (c == 'u')
+ {
+ force_loc = true; // force up
+ start++;
+ continue;
+ }
+ bool isPercent = false;
+ if (c == 'p')
+ {
+ isPercent = true;
+ start++;
+ }
+ const wchar_t *end;
+ v = ConvertStringToUInt32(start, &end);
+ if (end == start)
+ return E_INVALIDARG;
+ if (isPercent)
+ v = numThreads * v / 100;
+ start = end;
+ }
+
+ numThreads = v;
+ force = force_loc;
+ return S_OK;
+}
+
+
+
+static HRESULT SetLogSizeProp(UInt64 number, NCOM::CPropVariant &destProp)
+{
+ if (number >= 64)
+ return E_INVALIDARG;
+ UInt32 val32;
+ if (number < 32)
+ val32 = (UInt32)1 << (unsigned)number;
+ /*
+ else if (number == 32 && reduce_4GB_to_32bits)
+ val32 = (UInt32)(Int32)-1;
+ */
+ else
+ {
+ destProp = (UInt64)((UInt64)1 << (unsigned)number);
+ return S_OK;
+ }
+ destProp = (UInt32)val32;
+ return S_OK;
+}
+
+
+static HRESULT StringToDictSize(const UString &s, NCOM::CPropVariant &destProp)
+{
+ /* if (reduce_4GB_to_32bits) we can reduce (4 GiB) property to (4 GiB - 1).
+ to fit the value to UInt32 for clients that do not support 64-bit values */
+
+ const wchar_t *end;
+ const UInt64 number = ConvertStringToUInt64(s, &end);
+ const unsigned numDigits = (unsigned)(end - s.Ptr());
+ if (numDigits == 0 || s.Len() > numDigits + 1)
+ return E_INVALIDARG;
+
+ if (s.Len() == numDigits)
+ return SetLogSizeProp(number, destProp);
+
+ unsigned numBits;
+
+ switch (MyCharLower_Ascii(s[numDigits]))
+ {
+ case 'b': numBits = 0; break;
+ case 'k': numBits = 10; break;
+ case 'm': numBits = 20; break;
+ case 'g': numBits = 30; break;
+ default: return E_INVALIDARG;
+ }
+
+ const UInt64 range4g = ((UInt64)1 << (32 - numBits));
+ if (number < range4g)
+ destProp = (UInt32)((UInt32)number << numBits);
+ /*
+ else if (number == range4g && reduce_4GB_to_32bits)
+ destProp = (UInt32)(Int32)-1;
+ */
+ else if (numBits == 0)
+ destProp = (UInt64)number;
+ else if (number >= ((UInt64)1 << (64 - numBits)))
+ return E_INVALIDARG;
+ else
+ destProp = (UInt64)((UInt64)number << numBits);
+ return S_OK;
+}
+
+
+static HRESULT PROPVARIANT_to_DictSize(const PROPVARIANT &prop, NCOM::CPropVariant &destProp)
+{
+ if (prop.vt == VT_UI4)
+ return SetLogSizeProp(prop.ulVal, destProp);
+
+ if (prop.vt == VT_BSTR)
+ {
+ UString s;
+ s = prop.bstrVal;
+ return StringToDictSize(s, destProp);
+ }
+ return E_INVALIDARG;
+}
+
+
+void CProps::AddProp32(PROPID propid, UInt32 val)
+{
+ CProp &prop = Props.AddNew();
+ prop.IsOptional = true;
+ prop.Id = propid;
+ prop.Value = (UInt32)val;
+}
+
+void CProps::AddPropBool(PROPID propid, bool val)
+{
+ CProp &prop = Props.AddNew();
+ prop.IsOptional = true;
+ prop.Id = propid;
+ prop.Value = val;
+}
+
+class CCoderProps
+{
+ PROPID *_propIDs;
+ NCOM::CPropVariant *_props;
+ unsigned _numProps;
+ unsigned _numPropsMax;
+public:
+ CCoderProps(unsigned numPropsMax):
+ _propIDs(NULL),
+ _props(NULL),
+ _numProps(0),
+ _numPropsMax(numPropsMax)
+ {
+ _propIDs = new PROPID[numPropsMax];
+ _props = new NCOM::CPropVariant[numPropsMax];
+ }
+ ~CCoderProps()
+ {
+ delete []_propIDs;
+ delete []_props;
+ }
+ void AddProp(const CProp &prop);
+ HRESULT SetProps(ICompressSetCoderProperties *setCoderProperties)
+ {
+ return setCoderProperties->SetCoderProperties(_propIDs, _props, _numProps);
+ }
+};
+
+void CCoderProps::AddProp(const CProp &prop)
+{
+ if (_numProps >= _numPropsMax)
+ throw 1;
+ _propIDs[_numProps] = prop.Id;
+ _props[_numProps] = prop.Value;
+ _numProps++;
+}
+
+HRESULT CProps::SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const
+{
+ return SetCoderProps_DSReduce_Aff(scp, dataSizeReduce, NULL);
+}
+
+HRESULT CProps::SetCoderProps_DSReduce_Aff(
+ ICompressSetCoderProperties *scp,
+ const UInt64 *dataSizeReduce,
+ const UInt64 *affinity) const
+{
+ CCoderProps coderProps(Props.Size() + (dataSizeReduce ? 1 : 0) + (affinity ? 1 : 0) );
+ FOR_VECTOR (i, Props)
+ coderProps.AddProp(Props[i]);
+ if (dataSizeReduce)
+ {
+ CProp prop;
+ prop.Id = NCoderPropID::kReduceSize;
+ prop.Value = *dataSizeReduce;
+ coderProps.AddProp(prop);
+ }
+ if (affinity)
+ {
+ CProp prop;
+ prop.Id = NCoderPropID::kAffinity;
+ prop.Value = *affinity;
+ coderProps.AddProp(prop);
+ }
+ return coderProps.SetProps(scp);
+}
+
+
+int CMethodProps::FindProp(PROPID id) const
+{
+ for (unsigned i = Props.Size(); i != 0;)
+ if (Props[--i].Id == id)
+ return (int)i;
+ return -1;
+}
+
+unsigned CMethodProps::GetLevel() const
+{
+ int i = FindProp(NCoderPropID::kLevel);
+ if (i < 0)
+ return 5;
+ if (Props[(unsigned)i].Value.vt != VT_UI4)
+ return 9;
+ UInt32 level = Props[(unsigned)i].Value.ulVal;
+ return level > 9 ? 9 : (unsigned)level;
+}
+
+struct CNameToPropID
+{
+ VARTYPE VarType;
+ const char *Name;
+};
+
+
+// the following are related to NCoderPropID::EEnum values
+// NCoderPropID::k_NUM_DEFINED
+static const CNameToPropID g_NameToPropID[] =
+{
+ { VT_UI4, "" },
+ { VT_UI4, "d" },
+ { VT_UI4, "mem" },
+ { VT_UI4, "o" },
+ { VT_UI8, "c" },
+ { VT_UI4, "pb" },
+ { VT_UI4, "lc" },
+ { VT_UI4, "lp" },
+ { VT_UI4, "fb" },
+ { VT_BSTR, "mf" },
+ { VT_UI4, "mc" },
+ { VT_UI4, "pass" },
+ { VT_UI4, "a" },
+ { VT_UI4, "mt" },
+ { VT_BOOL, "eos" },
+ { VT_UI4, "x" },
+ { VT_UI8, "reduce" },
+ { VT_UI8, "expect" },
+ { VT_UI8, "cc" }, // "cc" in v23, "b" in v22.01
+ { VT_UI4, "check" },
+ { VT_BSTR, "filter" },
+ { VT_UI8, "memuse" },
+ { VT_UI8, "aff" },
+ { VT_UI4, "offset" },
+ { VT_UI4, "zhb" }
+ /*
+ ,
+ // { VT_UI4, "zhc" },
+ // { VT_UI4, "zhd" },
+ // { VT_UI4, "zcb" },
+ { VT_UI4, "dc" },
+ { VT_UI4, "zx" },
+ { VT_UI4, "zf" },
+ { VT_UI4, "zmml" },
+ { VT_UI4, "zov" },
+ { VT_BOOL, "zmfr" },
+ { VT_BOOL, "zle" }, // long enable
+ // { VT_UI4, "zldb" },
+ { VT_UI4, "zld" },
+ { VT_UI4, "zlhb" },
+ { VT_UI4, "zlmml" },
+ { VT_UI4, "zlbb" },
+ { VT_UI4, "zlhrb" },
+ { VT_BOOL, "zwus" },
+ { VT_BOOL, "zshp" },
+ { VT_BOOL, "zshs" },
+ { VT_BOOL, "zshe" },
+ { VT_BOOL, "zshg" },
+ { VT_UI4, "zpsm" }
+ */
+ // { VT_UI4, "mcb" }, // mc log version
+ // { VT_UI4, "ztlen" }, // fb ?
+};
+
+/*
+#if defined(static_assert) || (defined(__cplusplus) && __cplusplus >= 200410L) || (defined(_MSC_VER) && _MSC_VER >= 1600)
+
+#if (defined(__cplusplus) && __cplusplus < 201103L) \
+ && defined(__clang__) && __clang_major__ >= 4
+#pragma GCC diagnostic ignored "-Wc11-extensions"
+#endif
+ static_assert(Z7_ARRAY_SIZE(g_NameToPropID) == NCoderPropID::k_NUM_DEFINED,
+ "g_NameToPropID doesn't match NCoderPropID enum");
+#endif
+*/
+
+static int FindPropIdExact(const UString &name)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_NameToPropID); i++)
+ if (StringsAreEqualNoCase_Ascii(name, g_NameToPropID[i].Name))
+ return (int)i;
+ return -1;
+}
+
+static bool ConvertProperty(const PROPVARIANT &srcProp, VARTYPE varType, NCOM::CPropVariant &destProp)
+{
+ if (varType == srcProp.vt)
+ {
+ destProp = srcProp;
+ return true;
+ }
+
+ if (varType == VT_UI8 && srcProp.vt == VT_UI4)
+ {
+ destProp = (UInt64)srcProp.ulVal;
+ return true;
+ }
+
+ if (varType == VT_BOOL)
+ {
+ bool res;
+ if (PROPVARIANT_to_bool(srcProp, res) != S_OK)
+ return false;
+ destProp = res;
+ return true;
+ }
+ if (srcProp.vt == VT_EMPTY)
+ {
+ destProp = srcProp;
+ return true;
+ }
+ return false;
+}
+
+static void SplitParams(const UString &srcString, UStringVector &subStrings)
+{
+ subStrings.Clear();
+ UString s;
+ unsigned len = srcString.Len();
+ if (len == 0)
+ return;
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = srcString[i];
+ if (c == L':')
+ {
+ subStrings.Add(s);
+ s.Empty();
+ }
+ else
+ s += c;
+ }
+ subStrings.Add(s);
+}
+
+static void SplitParam(const UString ¶m, UString &name, UString &value)
+{
+ int eqPos = param.Find(L'=');
+ if (eqPos >= 0)
+ {
+ name.SetFrom(param, (unsigned)eqPos);
+ value = param.Ptr((unsigned)(eqPos + 1));
+ return;
+ }
+ unsigned i;
+ for (i = 0; i < param.Len(); i++)
+ {
+ wchar_t c = param[i];
+ if (c >= L'0' && c <= L'9')
+ break;
+ }
+ name.SetFrom(param, i);
+ value = param.Ptr(i);
+}
+
+static bool IsLogSizeProp(PROPID propid)
+{
+ switch (propid)
+ {
+ case NCoderPropID::kDictionarySize:
+ case NCoderPropID::kUsedMemorySize:
+ case NCoderPropID::kBlockSize:
+ case NCoderPropID::kBlockSize2:
+ /*
+ case NCoderPropID::kChainSize:
+ case NCoderPropID::kLdmWindowSize:
+ */
+ // case NCoderPropID::kReduceSize:
+ return true;
+ }
+ return false;
+}
+
+HRESULT CMethodProps::SetParam(const UString &name, const UString &value)
+{
+ int index = FindPropIdExact(name);
+ if (index < 0)
+ {
+ // 'b' was used as NCoderPropID::kBlockSize2 before v23
+ if (!name.IsEqualTo_Ascii_NoCase("b") || value.Find(L':') >= 0)
+ return E_INVALIDARG;
+ index = NCoderPropID::kBlockSize2;
+ }
+ const CNameToPropID &nameToPropID = g_NameToPropID[(unsigned)index];
+ CProp prop;
+ prop.Id = (unsigned)index;
+
+ if (IsLogSizeProp(prop.Id))
+ {
+ RINOK(StringToDictSize(value, prop.Value))
+ }
+ else
+ {
+ NCOM::CPropVariant propValue;
+ if (nameToPropID.VarType == VT_BSTR)
+ propValue = value;
+ else if (nameToPropID.VarType == VT_BOOL)
+ {
+ bool res;
+ if (!StringToBool(value, res))
+ return E_INVALIDARG;
+ propValue = res;
+ }
+ else if (!value.IsEmpty())
+ {
+ if (nameToPropID.VarType == VT_UI4)
+ {
+ UInt32 number;
+ if (ParseStringToUInt32(value, number) == value.Len())
+ propValue = number;
+ else
+ propValue = value;
+ }
+ else if (nameToPropID.VarType == VT_UI8)
+ {
+ UInt64 number;
+ if (ParseStringToUInt64(value, number) == value.Len())
+ propValue = number;
+ else
+ propValue = value;
+ }
+ else
+ propValue = value;
+ }
+ if (!ConvertProperty(propValue, nameToPropID.VarType, prop.Value))
+ return E_INVALIDARG;
+ }
+ Props.Add(prop);
+ return S_OK;
+}
+
+HRESULT CMethodProps::ParseParamsFromString(const UString &srcString)
+{
+ UStringVector params;
+ SplitParams(srcString, params);
+ FOR_VECTOR (i, params)
+ {
+ const UString ¶m = params[i];
+ UString name, value;
+ SplitParam(param, name, value);
+ RINOK(SetParam(name, value))
+ }
+ return S_OK;
+}
+
+HRESULT CMethodProps::ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value)
+{
+ if (realName.Len() == 0)
+ {
+ // [empty]=method
+ return E_INVALIDARG;
+ }
+ if (value.vt == VT_EMPTY)
+ {
+ // {realName}=[empty]
+ UString name, valueStr;
+ SplitParam(realName, name, valueStr);
+ return SetParam(name, valueStr);
+ }
+
+ // {realName}=value
+ const int index = FindPropIdExact(realName);
+ if (index < 0)
+ return E_INVALIDARG;
+ const CNameToPropID &nameToPropID = g_NameToPropID[(unsigned)index];
+ CProp prop;
+ prop.Id = (unsigned)index;
+
+ if (IsLogSizeProp(prop.Id))
+ {
+ RINOK(PROPVARIANT_to_DictSize(value, prop.Value))
+ }
+ else
+ {
+ if (!ConvertProperty(value, nameToPropID.VarType, prop.Value))
+ return E_INVALIDARG;
+ }
+ Props.Add(prop);
+ return S_OK;
+}
+
+
+static UInt64 GetMemoryUsage_LZMA(UInt32 dict, bool isBt, UInt32 numThreads)
+{
+ UInt32 hs = dict - 1;
+ hs |= (hs >> 1);
+ hs |= (hs >> 2);
+ hs |= (hs >> 4);
+ hs |= (hs >> 8);
+ hs >>= 1;
+ if (hs >= (1 << 24))
+ hs >>= 1;
+ hs |= (1 << 16) - 1;
+ // if (numHashBytes >= 5)
+ if (!isBt)
+ hs |= (256 << 10) - 1;
+ hs++;
+ UInt64 size1 = (UInt64)hs * 4;
+ size1 += (UInt64)dict * 4;
+ if (isBt)
+ size1 += (UInt64)dict * 4;
+ size1 += (2 << 20);
+
+ if (numThreads > 1 && isBt)
+ size1 += (2 << 20) + (4 << 20);
+ return size1;
+}
+
+static const UInt32 kLzmaMaxDictSize = (UInt32)15 << 28;
+
+UInt64 CMethodProps::Get_Lzma_MemUsage(bool addSlidingWindowSize) const
+{
+ const UInt64 dicSize = Get_Lzma_DicSize();
+ const bool isBt = Get_Lzma_MatchFinder_IsBt();
+ const UInt32 dict32 = (dicSize >= kLzmaMaxDictSize ? kLzmaMaxDictSize : (UInt32)dicSize);
+ const UInt32 numThreads = Get_Lzma_NumThreads();
+ UInt64 size = GetMemoryUsage_LZMA(dict32, isBt, numThreads);
+
+ if (addSlidingWindowSize)
+ {
+ const UInt32 kBlockSizeMax = (UInt32)0 - (UInt32)(1 << 16);
+ UInt64 blockSize = (UInt64)dict32 + (1 << 16)
+ + (numThreads > 1 ? (1 << 20) : 0);
+ blockSize += (blockSize >> (blockSize < ((UInt32)1 << 30) ? 1 : 2));
+ if (blockSize >= kBlockSizeMax)
+ blockSize = kBlockSizeMax;
+ size += blockSize;
+ }
+ return size;
+}
+
+
+
+
+HRESULT COneMethodInfo::ParseMethodFromString(const UString &s)
+{
+ MethodName.Empty();
+ int splitPos = s.Find(L':');
+ {
+ UString temp = s;
+ if (splitPos >= 0)
+ temp.DeleteFrom((unsigned)splitPos);
+ if (!temp.IsAscii())
+ return E_INVALIDARG;
+ MethodName.SetFromWStr_if_Ascii(temp);
+ }
+ if (splitPos < 0)
+ return S_OK;
+ PropsString = s.Ptr((unsigned)(splitPos + 1));
+ return ParseParamsFromString(PropsString);
+}
+
+HRESULT COneMethodInfo::ParseMethodFromPROPVARIANT(const UString &realName, const PROPVARIANT &value)
+{
+ if (!realName.IsEmpty() && !StringsAreEqualNoCase_Ascii(realName, "m"))
+ return ParseParamsFromPROPVARIANT(realName, value);
+ // -m{N}=method
+ if (value.vt != VT_BSTR)
+ return E_INVALIDARG;
+ UString s;
+ s = value.bstrVal;
+ return ParseMethodFromString(s);
+}
diff --git a/CPP/7zip/Common/MethodProps.h b/CPP/7zip/Common/MethodProps.h
index c8a3d0d..3c332d6 100644
--- a/CPP/7zip/Common/MethodProps.h
+++ b/CPP/7zip/Common/MethodProps.h
@@ -1,264 +1,345 @@
-// MethodProps.h
-
-#ifndef __7Z_METHOD_PROPS_H
-#define __7Z_METHOD_PROPS_H
-
-#include "../../Common/MyString.h"
-#include "../../Common/Defs.h"
-
-#include "../../Windows/Defs.h"
-
-#include "../../Windows/PropVariant.h"
-
-#include "../ICoder.h"
-
-bool StringToBool(const wchar_t *s, bool &res);
-HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest);
-unsigned ParseStringToUInt32(const UString &srcString, UInt32 &number);
-HRESULT ParsePropToUInt32(const UString &name, const PROPVARIANT &prop, UInt32 &resValue);
-
-HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads);
-
-struct CProp
-{
- PROPID Id;
- bool IsOptional;
- NWindows::NCOM::CPropVariant Value;
- CProp(): IsOptional(false) {}
-};
-
-struct CProps
-{
- CObjectVector<CProp> Props;
-
- void Clear() { Props.Clear(); }
-
- bool AreThereNonOptionalProps() const
- {
- FOR_VECTOR (i, Props)
- if (!Props[i].IsOptional)
- return true;
- return false;
- }
-
- void AddProp32(PROPID propid, UInt32 val);
-
- void AddPropBool(PROPID propid, bool val);
-
- void AddProp_Ascii(PROPID propid, const char *s)
- {
- CProp &prop = Props.AddNew();
- prop.IsOptional = true;
- prop.Id = propid;
- prop.Value = s;
- }
-
- HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const;
-};
-
-class CMethodProps: public CProps
-{
- HRESULT SetParam(const UString &name, const UString &value);
-public:
- int GetLevel() const;
- int Get_NumThreads() const
- {
- int i = FindProp(NCoderPropID::kNumThreads);
- if (i >= 0)
- if (Props[i].Value.vt == VT_UI4)
- return (int)Props[i].Value.ulVal;
- return -1;
- }
-
- bool Get_DicSize(UInt32 &res) const
- {
- res = 0;
- int i = FindProp(NCoderPropID::kDictionarySize);
- if (i >= 0)
- if (Props[i].Value.vt == VT_UI4)
- {
- res = Props[i].Value.ulVal;
- return true;
- }
- return false;
- }
-
- int FindProp(PROPID id) const;
-
- UInt32 Get_Lzma_Algo() const
- {
- int i = FindProp(NCoderPropID::kAlgorithm);
- if (i >= 0)
- if (Props[i].Value.vt == VT_UI4)
- return Props[i].Value.ulVal;
- return GetLevel() >= 5 ? 1 : 0;
- }
-
- UInt32 Get_Lzma_DicSize() const
- {
- int i = FindProp(NCoderPropID::kDictionarySize);
- if (i >= 0)
- if (Props[i].Value.vt == VT_UI4)
- return Props[i].Value.ulVal;
- int level = GetLevel();
- return level <= 5 ? (1 << (level * 2 + 14)) : (level == 6 ? (1 << 25) : (1 << 26));
- }
-
- bool Get_Lzma_Eos() const
- {
- int i = FindProp(NCoderPropID::kEndMarker);
- if (i >= 0)
- {
- const NWindows::NCOM::CPropVariant &val = Props[i].Value;
- if (val.vt == VT_BOOL)
- return VARIANT_BOOLToBool(val.boolVal);
- }
- return false;
- }
-
- bool Are_Lzma_Model_Props_Defined() const
- {
- if (FindProp(NCoderPropID::kPosStateBits) >= 0) return true;
- if (FindProp(NCoderPropID::kLitContextBits) >= 0) return true;
- if (FindProp(NCoderPropID::kLitPosBits) >= 0) return true;
- return false;
- }
-
- UInt32 Get_Lzma_NumThreads() const
- {
- if (Get_Lzma_Algo() == 0)
- return 1;
- int numThreads = Get_NumThreads();
- if (numThreads >= 0)
- return numThreads < 2 ? 1 : 2;
- return 2;
- }
-
- int Get_Xz_NumThreads(UInt32 &lzmaThreads) const
- {
- lzmaThreads = 1;
- int numThreads = Get_NumThreads();
- if (numThreads >= 0 && numThreads <= 1)
- return 1;
- if (Get_Lzma_Algo() != 0)
- lzmaThreads = 2;
- return numThreads;
- }
-
- UInt64 GetProp_BlockSize(PROPID id) const
- {
- int i = FindProp(id);
- if (i >= 0)
- {
- const NWindows::NCOM::CPropVariant &val = Props[i].Value;
- if (val.vt == VT_UI4) { return val.ulVal; }
- if (val.vt == VT_UI8) { return val.uhVal.QuadPart; }
- }
- return 0;
- }
-
- UInt64 Get_Xz_BlockSize() const
- {
- {
- UInt64 blockSize1 = GetProp_BlockSize(NCoderPropID::kBlockSize);
- UInt64 blockSize2 = GetProp_BlockSize(NCoderPropID::kBlockSize2);
- UInt64 minSize = MyMin(blockSize1, blockSize2);
- if (minSize != 0)
- return minSize;
- UInt64 maxSize = MyMax(blockSize1, blockSize2);
- if (maxSize != 0)
- return maxSize;
- }
- const UInt32 kMinSize = (UInt32)1 << 20;
- const UInt32 kMaxSize = (UInt32)1 << 28;
- UInt32 dictSize = Get_Lzma_DicSize();
- UInt64 blockSize = (UInt64)dictSize << 2;
- if (blockSize < kMinSize) blockSize = kMinSize;
- if (blockSize > kMaxSize) blockSize = kMaxSize;
- if (blockSize < dictSize) blockSize = dictSize;
- blockSize += (kMinSize - 1);
- blockSize &= ~(UInt64)(kMinSize - 1);
- return blockSize;
- }
-
-
- UInt32 Get_BZip2_NumThreads(bool &fixedNumber) const
- {
- fixedNumber = false;
- int numThreads = Get_NumThreads();
- if (numThreads >= 0)
- {
- fixedNumber = true;
- if (numThreads < 1) return 1;
- const unsigned kNumBZip2ThreadsMax = 64;
- if (numThreads > kNumBZip2ThreadsMax) return kNumBZip2ThreadsMax;
- return numThreads;
- }
- return 1;
- }
-
- UInt32 Get_BZip2_BlockSize() const
- {
- int i = FindProp(NCoderPropID::kDictionarySize);
- if (i >= 0)
- if (Props[i].Value.vt == VT_UI4)
- {
- UInt32 blockSize = Props[i].Value.ulVal;
- const UInt32 kDicSizeMin = 100000;
- const UInt32 kDicSizeMax = 900000;
- if (blockSize < kDicSizeMin) blockSize = kDicSizeMin;
- if (blockSize > kDicSizeMax) blockSize = kDicSizeMax;
- return blockSize;
- }
- int level = GetLevel();
- return 100000 * (level >= 5 ? 9 : (level >= 1 ? level * 2 - 1: 1));
- }
-
- UInt32 Get_Ppmd_MemSize() const
- {
- int i = FindProp(NCoderPropID::kUsedMemorySize);
- if (i >= 0)
- if (Props[i].Value.vt == VT_UI4)
- return Props[i].Value.ulVal;
- int level = GetLevel();
- return level >= 9 ? (192 << 20) : ((UInt32)1 << (level + 19));
- }
-
- void AddProp_Level(UInt32 level)
- {
- AddProp32(NCoderPropID::kLevel, level);
- }
-
- void AddProp_NumThreads(UInt32 numThreads)
- {
- AddProp32(NCoderPropID::kNumThreads, numThreads);
- }
-
- void AddProp_EndMarker_if_NotFound(bool eos)
- {
- if (FindProp(NCoderPropID::kEndMarker) < 0)
- AddPropBool(NCoderPropID::kEndMarker, eos);
- }
-
- HRESULT ParseParamsFromString(const UString &srcString);
- HRESULT ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
-};
-
-class COneMethodInfo: public CMethodProps
-{
-public:
- AString MethodName;
- UString PropsString;
-
- void Clear()
- {
- CMethodProps::Clear();
- MethodName.Empty();
- PropsString.Empty();
- }
- bool IsEmpty() const { return MethodName.IsEmpty() && Props.IsEmpty(); }
- HRESULT ParseMethodFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
- HRESULT ParseMethodFromString(const UString &s);
-};
-
-#endif
+// MethodProps.h
+
+#ifndef ZIP7_INC_7Z_METHOD_PROPS_H
+#define ZIP7_INC_7Z_METHOD_PROPS_H
+
+#include "../../Common/MyString.h"
+#include "../../Common/Defs.h"
+
+#include "../../Windows/Defs.h"
+
+#include "../../Windows/PropVariant.h"
+
+#include "../ICoder.h"
+
+// UInt64 GetMemoryUsage_LZMA(UInt32 dict, bool isBt, UInt32 numThreads);
+
+inline UInt64 Calc_From_Val_Percents_Less100(UInt64 val, UInt64 percents)
+{
+ if (percents == 0)
+ return 0;
+ if (val <= (UInt64)(Int64)-1 / percents)
+ return val * percents / 100;
+ return val / 100 * percents;
+}
+
+UInt64 Calc_From_Val_Percents(UInt64 val, UInt64 percents);
+
+bool StringToBool(const wchar_t *s, bool &res);
+HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest);
+unsigned ParseStringToUInt32(const UString &srcString, UInt32 &number);
+
+/*
+if (name.IsEmpty() && prop.vt == VT_EMPTY), it doesn't change (resValue) and returns S_OK.
+ So you must set (resValue) for default value before calling */
+HRESULT ParsePropToUInt32(const UString &name, const PROPVARIANT &prop, UInt32 &resValue);
+
+/* input: (numThreads = the_number_of_processors) */
+HRESULT ParseMtProp2(const UString &name, const PROPVARIANT &prop, UInt32 &numThreads, bool &force);
+
+inline HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 numCPUs, UInt32 &numThreads)
+{
+ bool forced = false;
+ numThreads = numCPUs;
+ return ParseMtProp2(name, prop, numThreads, forced);
+}
+
+
+struct CProp
+{
+ PROPID Id;
+ bool IsOptional;
+ NWindows::NCOM::CPropVariant Value;
+ CProp(): IsOptional(false) {}
+};
+
+struct CProps
+{
+ CObjectVector<CProp> Props;
+
+ void Clear() { Props.Clear(); }
+
+ bool AreThereNonOptionalProps() const
+ {
+ FOR_VECTOR (i, Props)
+ if (!Props[i].IsOptional)
+ return true;
+ return false;
+ }
+
+ void AddProp32(PROPID propid, UInt32 val);
+
+ void AddPropBool(PROPID propid, bool val);
+
+ void AddProp_Ascii(PROPID propid, const char *s)
+ {
+ CProp &prop = Props.AddNew();
+ prop.IsOptional = true;
+ prop.Id = propid;
+ prop.Value = s;
+ }
+
+ HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce = NULL) const;
+ HRESULT SetCoderProps_DSReduce_Aff(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce, const UInt64 *affinity) const;
+};
+
+class CMethodProps: public CProps
+{
+ HRESULT SetParam(const UString &name, const UString &value);
+public:
+ unsigned GetLevel() const;
+ int Get_NumThreads() const
+ {
+ const int i = FindProp(NCoderPropID::kNumThreads);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_UI4)
+ return (int)val.ulVal;
+ }
+ return -1;
+ }
+
+ bool Get_DicSize(UInt64 &res) const
+ {
+ res = 0;
+ const int i = FindProp(NCoderPropID::kDictionarySize);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_UI4)
+ {
+ res = val.ulVal;
+ return true;
+ }
+ if (val.vt == VT_UI8)
+ {
+ res = val.uhVal.QuadPart;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ int FindProp(PROPID id) const;
+
+ UInt32 Get_Lzma_Algo() const
+ {
+ int i = FindProp(NCoderPropID::kAlgorithm);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_UI4)
+ return val.ulVal;
+ }
+ return GetLevel() >= 5 ? 1 : 0;
+ }
+
+ UInt64 Get_Lzma_DicSize() const
+ {
+ UInt64 v;
+ if (Get_DicSize(v))
+ return v;
+ const unsigned level = GetLevel();
+ const UInt32 dictSize =
+ ( level <= 3 ? ((UInt32)1 << (level * 2 + 16)) :
+ ( level <= 6 ? ((UInt32)1 << (level + 19)) :
+ ( level <= 7 ? ((UInt32)1 << 25) : ((UInt32)1 << 26)
+ )));
+ return dictSize;
+ }
+
+ bool Get_Lzma_MatchFinder_IsBt() const
+ {
+ const int i = FindProp(NCoderPropID::kMatchFinder);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_BSTR)
+ return ((val.bstrVal[0] | 0x20) != 'h'); // check for "hc"
+ }
+ return GetLevel() >= 5;
+ }
+
+ bool Get_Lzma_Eos() const
+ {
+ const int i = FindProp(NCoderPropID::kEndMarker);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_BOOL)
+ return VARIANT_BOOLToBool(val.boolVal);
+ }
+ return false;
+ }
+
+ bool Are_Lzma_Model_Props_Defined() const
+ {
+ if (FindProp(NCoderPropID::kPosStateBits) >= 0) return true;
+ if (FindProp(NCoderPropID::kLitContextBits) >= 0) return true;
+ if (FindProp(NCoderPropID::kLitPosBits) >= 0) return true;
+ return false;
+ }
+
+ UInt32 Get_Lzma_NumThreads() const
+ {
+ if (Get_Lzma_Algo() == 0)
+ return 1;
+ int numThreads = Get_NumThreads();
+ if (numThreads >= 0)
+ return numThreads < 2 ? 1 : 2;
+ return 2;
+ }
+
+ UInt64 Get_Lzma_MemUsage(bool addSlidingWindowSize) const;
+
+ /* returns -1, if numThreads is unknown */
+ int Get_Xz_NumThreads(UInt32 &lzmaThreads) const
+ {
+ lzmaThreads = 1;
+ int numThreads = Get_NumThreads();
+ if (numThreads >= 0 && numThreads <= 1)
+ return 1;
+ if (Get_Lzma_Algo() != 0)
+ lzmaThreads = 2;
+ return numThreads;
+ }
+
+ UInt64 GetProp_BlockSize(PROPID id) const
+ {
+ const int i = FindProp(id);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_UI4) { return val.ulVal; }
+ if (val.vt == VT_UI8) { return val.uhVal.QuadPart; }
+ }
+ return 0;
+ }
+
+ UInt64 Get_Xz_BlockSize() const
+ {
+ {
+ UInt64 blockSize1 = GetProp_BlockSize(NCoderPropID::kBlockSize);
+ UInt64 blockSize2 = GetProp_BlockSize(NCoderPropID::kBlockSize2);
+ UInt64 minSize = MyMin(blockSize1, blockSize2);
+ if (minSize != 0)
+ return minSize;
+ UInt64 maxSize = MyMax(blockSize1, blockSize2);
+ if (maxSize != 0)
+ return maxSize;
+ }
+ const UInt32 kMinSize = (UInt32)1 << 20;
+ const UInt32 kMaxSize = (UInt32)1 << 28;
+ const UInt64 dictSize = Get_Lzma_DicSize();
+ /* lzma2 code uses fake 4 GiB to calculate ChunkSize. So we do same */
+ UInt64 blockSize = (UInt64)dictSize << 2;
+ if (blockSize < kMinSize) blockSize = kMinSize;
+ if (blockSize > kMaxSize) blockSize = kMaxSize;
+ if (blockSize < dictSize) blockSize = dictSize;
+ blockSize += (kMinSize - 1);
+ blockSize &= ~(UInt64)(kMinSize - 1);
+ return blockSize;
+ }
+
+
+ UInt32 Get_BZip2_NumThreads(bool &fixedNumber) const
+ {
+ fixedNumber = false;
+ int numThreads = Get_NumThreads();
+ if (numThreads >= 0)
+ {
+ fixedNumber = true;
+ if (numThreads < 1) return 1;
+ const unsigned kNumBZip2ThreadsMax = 64;
+ if ((unsigned)numThreads > kNumBZip2ThreadsMax) return kNumBZip2ThreadsMax;
+ return (unsigned)numThreads;
+ }
+ return 1;
+ }
+
+ UInt32 Get_BZip2_BlockSize() const
+ {
+ const int i = FindProp(NCoderPropID::kDictionarySize);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_UI4)
+ {
+ UInt32 blockSize = val.ulVal;
+ const UInt32 kDicSizeMin = 100000;
+ const UInt32 kDicSizeMax = 900000;
+ if (blockSize < kDicSizeMin) blockSize = kDicSizeMin;
+ if (blockSize > kDicSizeMax) blockSize = kDicSizeMax;
+ return blockSize;
+ }
+ }
+ const unsigned level = GetLevel();
+ return 100000 * (level >= 5 ? 9 : (level >= 1 ? level * 2 - 1: 1));
+ }
+
+ UInt64 Get_Ppmd_MemSize() const
+ {
+ const int i = FindProp(NCoderPropID::kUsedMemorySize);
+ if (i >= 0)
+ {
+ const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+ if (val.vt == VT_UI4)
+ return val.ulVal;
+ if (val.vt == VT_UI8)
+ return val.uhVal.QuadPart;
+ }
+ const unsigned level = GetLevel();
+ const UInt32 mem = (UInt32)1 << (level + 19);
+ return mem;
+ }
+
+ void AddProp_Level(UInt32 level)
+ {
+ AddProp32(NCoderPropID::kLevel, level);
+ }
+
+ void AddProp_NumThreads(UInt32 numThreads)
+ {
+ AddProp32(NCoderPropID::kNumThreads, numThreads);
+ }
+
+ void AddProp_EndMarker_if_NotFound(bool eos)
+ {
+ if (FindProp(NCoderPropID::kEndMarker) < 0)
+ AddPropBool(NCoderPropID::kEndMarker, eos);
+ }
+
+ void AddProp_BlockSize2(UInt64 blockSize2)
+ {
+ if (FindProp(NCoderPropID::kBlockSize2) < 0)
+ {
+ CProp &prop = Props.AddNew();
+ prop.IsOptional = true;
+ prop.Id = NCoderPropID::kBlockSize2;
+ prop.Value = blockSize2;
+ }
+ }
+
+ HRESULT ParseParamsFromString(const UString &srcString);
+ HRESULT ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
+};
+
+class COneMethodInfo: public CMethodProps
+{
+public:
+ AString MethodName;
+ UString PropsString;
+
+ void Clear()
+ {
+ CMethodProps::Clear();
+ MethodName.Empty();
+ PropsString.Empty();
+ }
+ bool IsEmpty() const { return MethodName.IsEmpty() && Props.IsEmpty(); }
+ HRESULT ParseMethodFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
+ HRESULT ParseMethodFromString(const UString &s);
+};
+
+#endif
diff --git a/CPP/7zip/Common/MultiOutStream.cpp b/CPP/7zip/Common/MultiOutStream.cpp
new file mode 100644
index 0000000..8efb977
--- /dev/null
+++ b/CPP/7zip/Common/MultiOutStream.cpp
@@ -0,0 +1,849 @@
+// MultiOutStream.cpp
+
+#include "StdAfx.h"
+
+// #define DEBUG_VOLUMES
+
+#ifdef DEBUG_VOLUMES
+#include <stdio.h>
+ #define PRF(x) x;
+#else
+ #define PRF(x)
+#endif
+
+#include "../../Common/ComTry.h"
+
+#include "../../Windows/FileDir.h"
+#include "../../Windows/FileFind.h"
+#include "../../Windows/System.h"
+
+#include "MultiOutStream.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static const unsigned k_NumVols_MAX = k_VectorSizeMax - 1;
+ // 2; // for debug
+
+/*
+#define UPDATE_HRES(hres, x) \
+ { const HRESULT res2 = (x); if (hres == SZ_OK) hres = res2; }
+*/
+
+HRESULT CMultiOutStream::Destruct()
+{
+ COM_TRY_BEGIN
+ HRESULT hres = S_OK;
+ HRESULT hres3 = S_OK;
+
+ while (!Streams.IsEmpty())
+ {
+ try
+ {
+ HRESULT hres2;
+ if (NeedDelete)
+ {
+ /* we could call OptReOpen_and_SetSize() to test that we try to delete correct file,
+ but we cannot guarantee that (RealSize) will be correct after Write() or another failures.
+ And we still want to delete files even for such cases.
+ So we don't check for OptReOpen_and_SetSize() here: */
+ // if (OptReOpen_and_SetSize(Streams.Size() - 1, 0) == S_OK)
+ hres2 = CloseStream_and_DeleteFile(Streams.Size() - 1);
+ }
+ else
+ {
+ hres2 = CloseStream(Streams.Size() - 1);
+ }
+ if (hres == S_OK)
+ hres = hres2;
+ }
+ catch(...)
+ {
+ hres3 = E_OUTOFMEMORY;
+ }
+
+ {
+ /* Stream was released in CloseStream_*() above already, and it was removed from linked list
+ it's some unexpected case, if Stream is still attached here.
+ So the following code is optional: */
+ CVolStream &s = Streams.Back();
+ if (s.Stream)
+ {
+ if (hres3 == S_OK)
+ hres3 = E_FAIL;
+ s.Stream.Detach();
+ /* it will be not failure, even if we call RemoveFromLinkedList()
+ twice for same CVolStream in this Destruct() function */
+ RemoveFromLinkedList(Streams.Size() - 1);
+ }
+ }
+ Streams.DeleteBack();
+ // Delete_LastStream_Records();
+ }
+
+ if (hres == S_OK)
+ hres = hres3;
+ if (hres == S_OK && NumListItems != 0)
+ hres = E_FAIL;
+ return hres;
+ COM_TRY_END
+}
+
+
+CMultiOutStream::~CMultiOutStream()
+{
+ // we try to avoid exception in destructors
+ Destruct();
+}
+
+
+void CMultiOutStream::Init(const CRecordVector<UInt64> &sizes)
+{
+ Streams.Clear();
+ InitLinkedList();
+ Sizes = sizes;
+ NeedDelete = true;
+ MTime_Defined = false;
+ FinalVol_WasReopen = false;
+ NumOpenFiles_AllowedMax = NSystem::Get_File_OPEN_MAX_Reduced_for_3_tasks();
+
+ _streamIndex = 0;
+ _offsetPos = 0;
+ _absPos = 0;
+ _length = 0;
+ _absLimit = (UInt64)(Int64)-1;
+
+ _restrict_Begin = 0;
+ _restrict_End = (UInt64)(Int64)-1;
+ _restrict_Global = 0;
+
+ UInt64 sum = 0;
+ unsigned i = 0;
+ for (i = 0; i < Sizes.Size(); i++)
+ {
+ if (i >= k_NumVols_MAX)
+ {
+ _absLimit = sum;
+ break;
+ }
+ const UInt64 size = Sizes[i];
+ const UInt64 next = sum + size;
+ if (next < sum)
+ break;
+ sum = next;
+ }
+
+ // if (Sizes.IsEmpty()) throw "no volume sizes";
+ const UInt64 size = Sizes.Back();
+ if (size == 0)
+ throw "zero size last volume";
+
+ if (i == Sizes.Size())
+ if ((_absLimit - sum) / size >= (k_NumVols_MAX - i))
+ _absLimit = sum + (k_NumVols_MAX - i) * size;
+}
+
+
+/* IsRestricted():
+ we must call only if volume is full (s.RealSize==VolSize) or finished.
+ the function doesn't use VolSize and it uses s.RealSize instead.
+ it returns true : if stream is restricted, and we can't close that stream
+ it returns false : if there is no restriction, and we can close that stream
+ Note: (RealSize == 0) (empty volume) on restriction bounds are supposed as non-restricted
+*/
+bool CMultiOutStream::IsRestricted(const CVolStream &s) const
+{
+ if (s.Start < _restrict_Global)
+ return true;
+ if (_restrict_Begin == _restrict_End)
+ return false;
+ if (_restrict_Begin <= s.Start)
+ return _restrict_End > s.Start;
+ return _restrict_Begin < s.Start + s.RealSize;
+}
+
+/*
+// this function check also _length and volSize
+bool CMultiOutStream::IsRestricted_for_Close(unsigned index) const
+{
+ const CVolStream &s = Streams[index];
+ if (_length <= s.Start) // we don't close streams after the end, because we still can write them later
+ return true;
+ // (_length > s.Start)
+ const UInt64 volSize = GetVolSize_for_Stream(index);
+ if (volSize == 0)
+ return IsRestricted_Empty(s);
+ if (_length - s.Start < volSize)
+ return true;
+ return IsRestricted(s);
+}
+*/
+
+FString CMultiOutStream::GetFilePath(unsigned index)
+{
+ FString name;
+ name.Add_UInt32(index + 1);
+ while (name.Len() < 3)
+ name.InsertAtFront(FTEXT('0'));
+ name.Insert(0, Prefix);
+ return name;
+}
+
+
+// we close stream, but we still keep item in Streams[] vector
+HRESULT CMultiOutStream::CloseStream(unsigned index)
+{
+ CVolStream &s = Streams[index];
+ if (s.Stream)
+ {
+ RINOK(s.StreamSpec->Close())
+ // the following two commands must be called together:
+ s.Stream.Release();
+ RemoveFromLinkedList(index);
+ }
+ return S_OK;
+}
+
+
+// we close stream and delete file, but we still keep item in Streams[] vector
+HRESULT CMultiOutStream::CloseStream_and_DeleteFile(unsigned index)
+{
+ PRF(printf("\n====== %u, CloseStream_AndDelete \n", index));
+ RINOK(CloseStream(index))
+ FString path = GetFilePath(index);
+ path += Streams[index].Postfix;
+ // we can checki that file exist
+ // if (NFind::DoesFileExist_Raw(path))
+ if (!DeleteFileAlways(path))
+ return GetLastError_noZero_HRESULT();
+ return S_OK;
+}
+
+
+HRESULT CMultiOutStream::CloseStream_and_FinalRename(unsigned index)
+{
+ PRF(printf("\n====== %u, CloseStream_and_FinalRename \n", index));
+ CVolStream &s = Streams[index];
+ // HRESULT res = S_OK;
+ bool mtime_WasSet = false;
+ if (MTime_Defined && s.Stream)
+ {
+ if (s.StreamSpec->SetMTime(&MTime))
+ mtime_WasSet = true;
+ // else res = GetLastError_noZero_HRESULT();
+ }
+
+ RINOK(CloseStream(index))
+ if (s.Postfix.IsEmpty()) // if Postfix is empty, the path is already final
+ return S_OK;
+ const FString path = GetFilePath(index);
+ FString tempPath = path;
+ tempPath += s.Postfix;
+
+ if (MTime_Defined && !mtime_WasSet)
+ {
+ if (!SetDirTime(tempPath, NULL, NULL, &MTime))
+ {
+ // res = GetLastError_noZero_HRESULT();
+ }
+ }
+ if (!MyMoveFile(tempPath, path))
+ return GetLastError_noZero_HRESULT();
+ /* we clear CVolStream::Postfix. So we will not use Temp path
+ anymore for this stream, and we will work only with final path */
+ s.Postfix.Empty();
+ // we can ignore set_mtime error or we can return it
+ return S_OK;
+ // return res;
+}
+
+
+HRESULT CMultiOutStream::PrepareToOpenNew()
+{
+ if (NumListItems < NumOpenFiles_AllowedMax)
+ return S_OK;
+ /* when we create zip archive: in most cases we need only starting
+ data of restricted region for rewriting zip's local header.
+ So here we close latest created volume (from Head), and we try to
+ keep oldest volumes that will be used for header rewriting later. */
+ const int index = Head;
+ if (index == -1)
+ return E_FAIL;
+ PRF(printf("\n== %u, PrepareToOpenNew::CloseStream, NumListItems =%u \n", index, NumListItems));
+ /* we don't expect non-restricted stream here in normal cases (if _restrict_Global was not changed).
+ if there was non-restricted stream, it should be closed before */
+ // if (!IsRestricted_for_Close(index)) return CloseStream_and_FinalRename(index);
+ return CloseStream((unsigned)index);
+}
+
+
+HRESULT CMultiOutStream::CreateNewStream(UInt64 newSize)
+{
+ PRF(printf("\n== %u, CreateNewStream, size =%u \n", Streams.Size(), (unsigned)newSize));
+
+ if (Streams.Size() >= k_NumVols_MAX)
+ return E_INVALIDARG; // E_OUTOFMEMORY
+
+ RINOK(PrepareToOpenNew())
+ CVolStream s;
+ s.StreamSpec = new COutFileStream;
+ s.Stream = s.StreamSpec;
+ const FString path = GetFilePath(Streams.Size());
+
+ if (NFind::DoesFileExist_Raw(path))
+ return HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS);
+ if (!CreateTempFile2(path, false, s.Postfix, &s.StreamSpec->File))
+ return GetLastError_noZero_HRESULT();
+
+ s.Start = GetGlobalOffset_for_NewStream();
+ s.Pos = 0;
+ s.RealSize = 0;
+
+ const unsigned index = Streams.Add(s);
+ InsertToLinkedList(index);
+
+ if (newSize != 0)
+ return s.SetSize2(newSize);
+ return S_OK;
+}
+
+
+HRESULT CMultiOutStream::CreateStreams_If_Required(unsigned streamIndex)
+{
+ // UInt64 lastStreamSize = 0;
+ for (;;)
+ {
+ const unsigned numStreamsBefore = Streams.Size();
+ if (streamIndex < numStreamsBefore)
+ return S_OK;
+ UInt64 newSize;
+ if (streamIndex == numStreamsBefore)
+ {
+ // it's final volume that will be used for real writing.
+ /* SetSize(_offsetPos) is not required,
+ because the file Size will be set later by calling Seek() with Write() */
+ newSize = 0; // lastStreamSize;
+ }
+ else
+ {
+ // it's intermediate volume. So we need full volume size
+ newSize = GetVolSize_for_Stream(numStreamsBefore);
+ }
+
+ RINOK(CreateNewStream(newSize))
+
+ // optional check
+ if (numStreamsBefore + 1 != Streams.Size()) return E_FAIL;
+
+ if (streamIndex != numStreamsBefore)
+ {
+ // it's intermediate volume. So we can close it, if it's non-restricted
+ bool isRestricted;
+ {
+ const CVolStream &s = Streams[numStreamsBefore];
+ if (newSize == 0)
+ isRestricted = IsRestricted_Empty(s);
+ else
+ isRestricted = IsRestricted(s);
+ }
+ if (!isRestricted)
+ {
+ RINOK(CloseStream_and_FinalRename(numStreamsBefore))
+ }
+ }
+ }
+}
+
+
+HRESULT CMultiOutStream::ReOpenStream(unsigned streamIndex)
+{
+ PRF(printf("\n====== %u, ReOpenStream \n", streamIndex));
+ RINOK(PrepareToOpenNew())
+ CVolStream &s = Streams[streamIndex];
+
+ FString path = GetFilePath(streamIndex);
+ path += s.Postfix;
+
+ s.StreamSpec = new COutFileStream;
+ s.Stream = s.StreamSpec;
+ s.Pos = 0;
+
+ HRESULT hres;
+ if (s.StreamSpec->Open(path, OPEN_EXISTING))
+ {
+ if (s.Postfix.IsEmpty())
+ {
+ /* it's unexpected case that we open finished volume.
+ It can mean that the code for restriction is incorrect */
+ FinalVol_WasReopen = true;
+ }
+ UInt64 realSize = 0;
+ hres = s.StreamSpec->GetSize(&realSize);
+ if (hres == S_OK)
+ {
+ if (realSize == s.RealSize)
+ {
+ InsertToLinkedList(streamIndex);
+ return S_OK;
+ }
+ // file size was changed between Close() and ReOpen()
+ // we must release Stream to be consistent with linked list
+ hres = E_FAIL;
+ }
+ }
+ else
+ hres = GetLastError_noZero_HRESULT();
+ s.Stream.Release();
+ s.StreamSpec = NULL;
+ return hres;
+}
+
+
+/* Sets size of stream, if new size is not equal to old size (RealSize).
+ If stream was closed and size change is required, it reopens the stream. */
+
+HRESULT CMultiOutStream::OptReOpen_and_SetSize(unsigned index, UInt64 size)
+{
+ CVolStream &s = Streams[index];
+ if (size == s.RealSize)
+ return S_OK;
+ if (!s.Stream)
+ {
+ RINOK(ReOpenStream(index))
+ }
+ PRF(printf("\n== %u, OptReOpen_and_SetSize, size =%u RealSize = %u\n", index, (unsigned)size, (unsigned)s.RealSize));
+ // comment it to debug tail after data
+ return s.SetSize2(size);
+}
+
+
+/*
+call Normalize_finalMode(false), if _length was changed.
+ for all streams starting after _length:
+ - it sets zero size
+ - it still keeps file open
+ Note: after _length reducing with CMultiOutStream::SetSize() we can
+ have very big number of empty streams at the end of Streams[] list.
+ And Normalize_finalMode() will runs all these empty streams of Streams[] vector.
+ So it can be ineffective, if we call Normalize_finalMode() many
+ times after big reducing of (_length).
+
+call Normalize_finalMode(true) to set final presentations of all streams
+ for all streams starting after _length:
+ - it sets zero size
+ - it removes file
+ - it removes CVolStream object from Streams[] vector
+
+Note: we don't remove zero sized first volume, if (_length == 0)
+*/
+
+HRESULT CMultiOutStream::Normalize_finalMode(bool finalMode)
+{
+ PRF(printf("\n== Normalize_finalMode: _length =%d \n", (unsigned)_length));
+
+ unsigned i = Streams.Size();
+
+ UInt64 offset = 0;
+
+ /* At first we normalize (reduce or increase) the sizes of all existing
+ streams in Streams[] that can be affected by changed _length.
+ And we remove tailing zero-size streams, if (finalMode == true) */
+ while (i != 0)
+ {
+ offset = Streams[--i].Start; // it's last item in Streams[]
+ // we don't want to remove first volume
+ if (offset < _length || i == 0)
+ {
+ const UInt64 volSize = GetVolSize_for_Stream(i);
+ UInt64 size = _length - offset; // (size != 0) here
+ if (size > volSize)
+ size = volSize;
+ RINOK(OptReOpen_and_SetSize(i, size))
+ if (_length - offset <= volSize)
+ return S_OK;
+ // _length - offset > volSize
+ offset += volSize;
+ // _length > offset
+ break;
+ // UPDATE_HRES(res, OptReOpen_and_SetSize(i, size));
+ }
+
+ /* we Set Size of stream to zero even for (finalMode==true), although
+ that stream will be deleted in next commands */
+ // UPDATE_HRES(res, OptReOpen_and_SetSize(i, 0));
+ RINOK(OptReOpen_and_SetSize(i, 0))
+ if (finalMode)
+ {
+ RINOK(CloseStream_and_DeleteFile(i))
+ /* CVolStream::Stream was released above already, and it was
+ removed from linked list. So we don't need to update linked list
+ structure, when we delete last item in Streams[] */
+ Streams.DeleteBack();
+ // Delete_LastStream_Records();
+ }
+ }
+
+ /* now we create new zero-filled streams to cover all data up to _length */
+
+ if (_length == 0)
+ return S_OK;
+
+ // (offset) is start offset of next stream after existing Streams[]
+
+ for (;;)
+ {
+ // _length > offset
+ const UInt64 volSize = GetVolSize_for_Stream(Streams.Size());
+ UInt64 size = _length - offset; // (size != 0) here
+ if (size > volSize)
+ size = volSize;
+ RINOK(CreateNewStream(size))
+ if (_length - offset <= volSize)
+ return S_OK;
+ // _length - offset > volSize)
+ offset += volSize;
+ // _length > offset
+ }
+}
+
+
+HRESULT CMultiOutStream::FinalFlush_and_CloseFiles(unsigned &numTotalVolumesRes)
+{
+ // at first we remove unused zero-sized streams after _length
+ HRESULT res = Normalize_finalMode(true);
+ numTotalVolumesRes = Streams.Size();
+ FOR_VECTOR (i, Streams)
+ {
+ const HRESULT res2 = CloseStream_and_FinalRename(i);
+ if (res == S_OK)
+ res = res2;
+ }
+ if (NumListItems != 0 && res == S_OK)
+ res = E_FAIL;
+ return res;
+}
+
+
+bool CMultiOutStream::SetMTime_Final(const CFiTime &mTime)
+{
+ // we will set mtime only if new value differs from previous
+ if (!FinalVol_WasReopen && MTime_Defined && Compare_FiTime(&MTime, &mTime) == 0)
+ return true;
+ bool res = true;
+ FOR_VECTOR (i, Streams)
+ {
+ CVolStream &s = Streams[i];
+ if (s.Stream)
+ {
+ if (!s.StreamSpec->SetMTime(&mTime))
+ res = false;
+ }
+ else
+ {
+ if (!SetDirTime(GetFilePath(i), NULL, NULL, &mTime))
+ res = false;
+ }
+ }
+ return res;
+}
+
+
+Z7_COM7F_IMF(CMultiOutStream::SetSize(UInt64 newSize))
+{
+ COM_TRY_BEGIN
+ if ((Int64)newSize < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ if (newSize > _absLimit)
+ {
+ /* big seek value was sent to SetSize() or to Seek()+Write().
+ It can mean one of two situations:
+ 1) some incorrect code called it with big seek value.
+ 2) volume size was small, and we have too big number of volumes
+ */
+ /* in Windows SetEndOfFile() can return:
+ ERROR_NEGATIVE_SEEK: for >= (1 << 63)
+ ERROR_INVALID_PARAMETER: for > (16 TiB - 64 KiB)
+ ERROR_DISK_FULL: for <= (16 TiB - 64 KiB)
+ */
+ // return E_FAIL;
+ // return E_OUTOFMEMORY;
+ return E_INVALIDARG;
+ }
+
+ if (newSize > _length)
+ {
+ // we don't expect such case. So we just define global restriction */
+ _restrict_Global = newSize;
+ }
+ else if (newSize < _restrict_Global)
+ _restrict_Global = newSize;
+
+ PRF(printf("\n== SetSize, size =%u \n", (unsigned)newSize));
+
+ _length = newSize;
+ return Normalize_finalMode(false);
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CMultiOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ COM_TRY_BEGIN
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+
+ if (_absPos > _length)
+ {
+ // it create data only up to _absPos.
+ // but we still can need additional new streams, if _absPos at range of volume
+ RINOK(SetSize(_absPos))
+ }
+
+ while (size != 0)
+ {
+ UInt64 volSize;
+ {
+ if (_streamIndex < Sizes.Size() - 1)
+ {
+ volSize = Sizes[_streamIndex];
+ if (_offsetPos >= volSize)
+ {
+ _offsetPos -= volSize;
+ _streamIndex++;
+ continue;
+ }
+ }
+ else
+ {
+ volSize = Sizes[Sizes.Size() - 1];
+ if (_offsetPos >= volSize)
+ {
+ const UInt64 v = _offsetPos / volSize;
+ if (v >= ((UInt32)(Int32)-1) - _streamIndex)
+ return E_INVALIDARG;
+ // throw 202208;
+ _streamIndex += (unsigned)v;
+ _offsetPos -= (unsigned)v * volSize;
+ }
+ if (_streamIndex >= k_NumVols_MAX)
+ return E_INVALIDARG;
+ }
+ }
+
+ // (_offsetPos < volSize) here
+
+ /* we can need to create one or more streams here,
+ vol_size for some streams is allowed to be 0.
+ Also we close some new created streams, if they are non-restricted */
+ // file Size will be set later by calling Seek() with Write()
+
+ /* the case (_absPos > _length) was processed above with SetSize(_absPos),
+ so here it's expected. that we can create optional zero-size streams and then _streamIndex */
+ RINOK(CreateStreams_If_Required(_streamIndex))
+
+ CVolStream &s = Streams[_streamIndex];
+
+ PRF(printf("\n%d, == Write : Pos = %u, RealSize = %u size =%u \n",
+ _streamIndex, (unsigned)s.Pos, (unsigned)s.RealSize, size));
+
+ if (!s.Stream)
+ {
+ RINOK(ReOpenStream(_streamIndex))
+ }
+ if (_offsetPos != s.Pos)
+ {
+ RINOK(s.Stream->Seek((Int64)_offsetPos, STREAM_SEEK_SET, NULL))
+ s.Pos = _offsetPos;
+ }
+
+ UInt32 curSize = size;
+ {
+ const UInt64 rem = volSize - _offsetPos;
+ if (curSize > rem)
+ curSize = (UInt32)rem;
+ }
+ // curSize != 0
+ UInt32 realProcessed = 0;
+
+ HRESULT hres = s.Stream->Write(data, curSize, &realProcessed);
+
+ data = (const void *)((const Byte *)data + realProcessed);
+ size -= realProcessed;
+ s.Pos += realProcessed;
+ _offsetPos += realProcessed;
+ _absPos += realProcessed;
+ if (_length < _absPos)
+ _length = _absPos;
+ if (s.RealSize < _offsetPos)
+ s.RealSize = _offsetPos;
+ if (processedSize)
+ *processedSize += realProcessed;
+
+ if (s.Pos == volSize)
+ {
+ bool isRestricted;
+ if (volSize == 0)
+ isRestricted = IsRestricted_Empty(s);
+ else
+ isRestricted = IsRestricted(s);
+ if (!isRestricted)
+ {
+ const HRESULT res2 = CloseStream_and_FinalRename(_streamIndex);
+ if (hres == S_OK)
+ hres = res2;
+ }
+ _streamIndex++;
+ _offsetPos = 0;
+ }
+
+ RINOK(hres)
+ if (realProcessed == 0 && curSize != 0)
+ return E_FAIL;
+ // break;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CMultiOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ PRF(printf("\n-- Seek seekOrigin=%u Seek =%u\n", seekOrigin, (unsigned)offset));
+
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _absPos; break;
+ case STREAM_SEEK_END: offset += _length; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ if ((UInt64)offset != _absPos)
+ {
+ _absPos = (UInt64)offset;
+ _offsetPos = (UInt64)offset;
+ _streamIndex = 0;
+ }
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+
+// result value will be saturated to (UInt32)(Int32)-1
+
+unsigned CMultiOutStream::GetStreamIndex_for_Offset(UInt64 offset, UInt64 &relOffset) const
+{
+ const unsigned last = Sizes.Size() - 1;
+ for (unsigned i = 0; i < last; i++)
+ {
+ const UInt64 size = Sizes[i];
+ if (offset < size)
+ {
+ relOffset = offset;
+ return i;
+ }
+ offset -= size;
+ }
+ const UInt64 size = Sizes[last];
+ const UInt64 v = offset / size;
+ if (v >= ((UInt32)(Int32)-1) - last)
+ return (UInt32)(Int32)-1; // saturation
+ relOffset = offset - (unsigned)v * size;
+ return last + (unsigned)(v);
+}
+
+
+Z7_COM7F_IMF(CMultiOutStream::SetRestriction(UInt64 begin, UInt64 end))
+{
+ COM_TRY_BEGIN
+
+ // begin = end = 0; // for debug
+
+ PRF(printf("\n==================== CMultiOutStream::SetRestriction %u, %u\n", (unsigned)begin, (unsigned)end));
+ if (begin > end)
+ {
+ // these value are FAILED values.
+ return E_FAIL;
+ // return E_INVALIDARG;
+ /*
+ // or we can ignore error with 3 ways: no change, non-restricted, saturation:
+ end = begin; // non-restricted
+ end = (UInt64)(Int64)-1; // saturation:
+ return S_OK;
+ */
+ }
+ UInt64 b = _restrict_Begin;
+ UInt64 e = _restrict_End;
+ _restrict_Begin = begin;
+ _restrict_End = end;
+
+ if (b == e) // if there were no restriction before
+ return S_OK; // no work to derestrict now.
+
+ /* [b, e) is previous restricted region. So all volumes that
+ intersect that [b, e) region are candidats for derestriction */
+
+ if (begin != end) // if there is new non-empty restricted region
+ {
+ /* Now we will try to reduce or change (b) and (e) bounds
+ to reduce main loop that checks volumes for derestriction.
+ We still use one big derestriction region in main loop, although
+ in some cases we could have two smaller derestriction regions.
+ Also usually restriction region cannot move back from previous start position,
+ so (b <= begin) is expected here for normal cases */
+ if (b == begin) // if same low bounds
+ b = end; // we need to derestrict only after the end of new restricted region
+ if (e == end) // if same high bounds
+ e = begin; // we need to derestrict only before the begin of new restricted region
+ }
+
+ if (b > e) // || b == (UInt64)(Int64)-1
+ return S_OK;
+
+ /* Here we close finished volumes that are not restricted anymore.
+ We close (low number) volumes at first. */
+
+ UInt64 offset;
+ unsigned index = GetStreamIndex_for_Offset(b, offset);
+
+ for (; index < Streams.Size(); index++)
+ {
+ {
+ const CVolStream &s = Streams[index];
+ if (_length <= s.Start)
+ break; // we don't close streams after _length
+ // (_length > s.Start)
+ const UInt64 volSize = GetVolSize_for_Stream(index);
+ if (volSize == 0)
+ {
+ if (e < s.Start)
+ break;
+ // we don't close empty stream, if next byte [s.Start, s.Start] is restricted
+ if (IsRestricted_Empty(s))
+ continue;
+ }
+ else
+ {
+ if (e <= s.Start)
+ break;
+ // we don't close non full streams
+ if (_length - s.Start < volSize)
+ break;
+ // (volSize == s.RealSize) is expected here. So no need to check it
+ // if (volSize != s.RealSize) break;
+ if (IsRestricted(s))
+ continue;
+ }
+ }
+ RINOK(CloseStream_and_FinalRename(index))
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
diff --git a/CPP/7zip/Common/MultiOutStream.h b/CPP/7zip/Common/MultiOutStream.h
new file mode 100644
index 0000000..2fb7811
--- /dev/null
+++ b/CPP/7zip/Common/MultiOutStream.h
@@ -0,0 +1,160 @@
+// MultiOutStream.h
+
+#ifndef ZIP7_INC_MULTI_OUT_STREAM_H
+#define ZIP7_INC_MULTI_OUT_STREAM_H
+
+#include "FileStreams.h"
+
+Z7_CLASS_IMP_COM_2(
+ CMultiOutStream
+ , IOutStream
+ , IStreamSetRestriction
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ Z7_CLASS_NO_COPY(CMultiOutStream)
+
+ struct CVolStream
+ {
+ COutFileStream *StreamSpec;
+ CMyComPtr<IOutStream> Stream;
+ UInt64 Start; // start pos of current Stream in global stream
+ UInt64 Pos; // pos in current Stream
+ UInt64 RealSize;
+ int Next; // next older
+ int Prev; // prev newer
+ AString Postfix;
+
+ HRESULT SetSize2(UInt64 size)
+ {
+ const HRESULT res = Stream->SetSize(size);
+ if (res == SZ_OK)
+ RealSize = size;
+ return res;
+ }
+ };
+
+ unsigned _streamIndex; // (_streamIndex >= Stream.Size()) is allowed in some internal code
+ UInt64 _offsetPos; // offset relative to Streams[_streamIndex] volume. (_offsetPos >= volSize is allowed)
+ UInt64 _absPos;
+ UInt64 _length; // virtual Length
+ UInt64 _absLimit;
+
+ CObjectVector<CVolStream> Streams;
+ CRecordVector<UInt64> Sizes;
+
+ UInt64 _restrict_Begin;
+ UInt64 _restrict_End;
+ UInt64 _restrict_Global;
+
+ unsigned NumOpenFiles_AllowedMax;
+
+ // ----- Double Linked List -----
+
+ unsigned NumListItems;
+ int Head; // newest
+ int Tail; // oldest
+
+ void InitLinkedList()
+ {
+ Head = -1;
+ Tail = -1;
+ NumListItems = 0;
+ }
+
+ void InsertToLinkedList(unsigned index)
+ {
+ {
+ CVolStream &node = Streams[index];
+ node.Next = Head;
+ node.Prev = -1;
+ }
+ if (Head != -1)
+ Streams[(unsigned)Head].Prev = (int)index;
+ else
+ {
+ // if (Tail != -1) throw 1;
+ Tail = (int)index;
+ }
+ Head = (int)index;
+ NumListItems++;
+ }
+
+ void RemoveFromLinkedList(unsigned index)
+ {
+ CVolStream &s = Streams[index];
+ if (s.Next != -1) Streams[(unsigned)s.Next].Prev = s.Prev; else Tail = s.Prev;
+ if (s.Prev != -1) Streams[(unsigned)s.Prev].Next = s.Next; else Head = s.Next;
+ s.Next = -1; // optional
+ s.Prev = -1; // optional
+ NumListItems--;
+ }
+
+ /*
+ void Delete_LastStream_Records()
+ {
+ if (Streams.Back().Stream)
+ RemoveFromLinkedList(Streams.Size() - 1);
+ Streams.DeleteBack();
+ }
+ */
+
+ UInt64 GetVolSize_for_Stream(unsigned i) const
+ {
+ const unsigned last = Sizes.Size() - 1;
+ return Sizes[i < last ? i : last];
+ }
+ UInt64 GetGlobalOffset_for_NewStream() const
+ {
+ return Streams.Size() == 0 ? 0:
+ Streams.Back().Start +
+ GetVolSize_for_Stream(Streams.Size() - 1);
+ }
+ unsigned GetStreamIndex_for_Offset(UInt64 offset, UInt64 &relOffset) const;
+ bool IsRestricted(const CVolStream &s) const;
+ bool IsRestricted_Empty(const CVolStream &s) const
+ {
+ // (s) must be stream that has (VolSize == 0).
+ // we treat empty stream as restricted, if next byte is restricted.
+ if (s.Start < _restrict_Global)
+ return true;
+ return
+ (_restrict_Begin != _restrict_End)
+ && (_restrict_Begin <= s.Start)
+ && (_restrict_Begin == s.Start || _restrict_End > s.Start);
+ }
+ // bool IsRestricted_for_Close(unsigned index) const;
+ FString GetFilePath(unsigned index);
+
+ HRESULT CloseStream(unsigned index);
+ HRESULT CloseStream_and_DeleteFile(unsigned index);
+ HRESULT CloseStream_and_FinalRename(unsigned index);
+
+ HRESULT PrepareToOpenNew();
+ HRESULT CreateNewStream(UInt64 newSize);
+ HRESULT CreateStreams_If_Required(unsigned streamIndex);
+ HRESULT ReOpenStream(unsigned streamIndex);
+ HRESULT OptReOpen_and_SetSize(unsigned index, UInt64 size);
+
+ HRESULT Normalize_finalMode(bool finalMode);
+public:
+ FString Prefix;
+ CFiTime MTime;
+ bool MTime_Defined;
+ bool FinalVol_WasReopen;
+ bool NeedDelete;
+
+ CMultiOutStream() {}
+ ~CMultiOutStream();
+ void Init(const CRecordVector<UInt64> &sizes);
+ bool SetMTime_Final(const CFiTime &mTime);
+ UInt64 GetSize() const { return _length; }
+ /* it makes final flushing, closes open files and renames to final name if required
+ but it still keeps Streams array of all closed files.
+ So we still can delete all files later, if required */
+ HRESULT FinalFlush_and_CloseFiles(unsigned &numTotalVolumesRes);
+ // Destruct object without exceptions
+ HRESULT Destruct();
+};
+
+#endif
diff --git a/CPP/7zip/Common/OffsetStream.cpp b/CPP/7zip/Common/OffsetStream.cpp
index 3b01c7f..a6b005e 100644
--- a/CPP/7zip/Common/OffsetStream.cpp
+++ b/CPP/7zip/Common/OffsetStream.cpp
@@ -1,39 +1,37 @@
-// OffsetStream.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/Defs.h"
-
-#include "OffsetStream.h"
-
-HRESULT COffsetOutStream::Init(IOutStream *stream, UInt64 offset)
-{
- _offset = offset;
- _stream = stream;
- return _stream->Seek(offset, STREAM_SEEK_SET, NULL);
-}
-
-STDMETHODIMP COffsetOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- return _stream->Write(data, size, processedSize);
-}
-
-STDMETHODIMP COffsetOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- UInt64 absoluteNewPosition;
- if (seekOrigin == STREAM_SEEK_SET)
- {
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- offset += _offset;
- }
- HRESULT result = _stream->Seek(offset, seekOrigin, &absoluteNewPosition);
- if (newPosition)
- *newPosition = absoluteNewPosition - _offset;
- return result;
-}
-
-STDMETHODIMP COffsetOutStream::SetSize(UInt64 newSize)
-{
- return _stream->SetSize(_offset + newSize);
-}
+// OffsetStream.cpp
+
+#include "StdAfx.h"
+
+#include "OffsetStream.h"
+
+HRESULT COffsetOutStream::Init(IOutStream *stream, UInt64 offset)
+{
+ _offset = offset;
+ _stream = stream;
+ return _stream->Seek((Int64)offset, STREAM_SEEK_SET, NULL);
+}
+
+Z7_COM7F_IMF(COffsetOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ return _stream->Write(data, size, processedSize);
+}
+
+Z7_COM7F_IMF(COffsetOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ if (seekOrigin == STREAM_SEEK_SET)
+ {
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ offset += _offset;
+ }
+ UInt64 absoluteNewPosition = 0; // =0 for gcc-10
+ const HRESULT result = _stream->Seek(offset, seekOrigin, &absoluteNewPosition);
+ if (newPosition)
+ *newPosition = absoluteNewPosition - _offset;
+ return result;
+}
+
+Z7_COM7F_IMF(COffsetOutStream::SetSize(UInt64 newSize))
+{
+ return _stream->SetSize(_offset + newSize);
+}
diff --git a/CPP/7zip/Common/OffsetStream.h b/CPP/7zip/Common/OffsetStream.h
index ad835f2..9bd554c 100644
--- a/CPP/7zip/Common/OffsetStream.h
+++ b/CPP/7zip/Common/OffsetStream.h
@@ -1,26 +1,22 @@
-// OffsetStream.h
-
-#ifndef __OFFSET_STREAM_H
-#define __OFFSET_STREAM_H
-
-#include "../../Common/MyCom.h"
-
-#include "../IStream.h"
-
-class COffsetOutStream:
- public IOutStream,
- public CMyUnknownImp
-{
- UInt64 _offset;
- CMyComPtr<IOutStream> _stream;
-public:
- HRESULT Init(IOutStream *stream, UInt64 offset);
-
- MY_UNKNOWN_IMP
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
- STDMETHOD(SetSize)(UInt64 newSize);
-};
-
-#endif
+// OffsetStream.h
+
+#ifndef ZIP7_INC_OFFSET_STREAM_H
+#define ZIP7_INC_OFFSET_STREAM_H
+
+#include "../../Common/MyCom.h"
+
+#include "../IStream.h"
+
+Z7_CLASS_IMP_NOQIB_1(
+ COffsetOutStream
+ , IOutStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ CMyComPtr<IOutStream> _stream;
+ UInt64 _offset;
+public:
+ HRESULT Init(IOutStream *stream, UInt64 offset);
+};
+
+#endif
diff --git a/CPP/7zip/Common/OutBuffer.cpp b/CPP/7zip/Common/OutBuffer.cpp
index fb8dc8d..197b376 100644
--- a/CPP/7zip/Common/OutBuffer.cpp
+++ b/CPP/7zip/Common/OutBuffer.cpp
@@ -1,111 +1,111 @@
-// OutBuffer.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "OutBuffer.h"
-
-bool COutBuffer::Create(UInt32 bufSize) throw()
-{
- const UInt32 kMinBlockSize = 1;
- if (bufSize < kMinBlockSize)
- bufSize = kMinBlockSize;
- if (_buf != 0 && _bufSize == bufSize)
- return true;
- Free();
- _bufSize = bufSize;
- _buf = (Byte *)::MidAlloc(bufSize);
- return (_buf != 0);
-}
-
-void COutBuffer::Free() throw()
-{
- ::MidFree(_buf);
- _buf = 0;
-}
-
-void COutBuffer::Init() throw()
-{
- _streamPos = 0;
- _limitPos = _bufSize;
- _pos = 0;
- _processedSize = 0;
- _overDict = false;
- #ifdef _NO_EXCEPTIONS
- ErrorCode = S_OK;
- #endif
-}
-
-UInt64 COutBuffer::GetProcessedSize() const throw()
-{
- UInt64 res = _processedSize + _pos - _streamPos;
- if (_streamPos > _pos)
- res += _bufSize;
- return res;
-}
-
-
-HRESULT COutBuffer::FlushPart() throw()
-{
- // _streamPos < _bufSize
- UInt32 size = (_streamPos >= _pos) ? (_bufSize - _streamPos) : (_pos - _streamPos);
- HRESULT result = S_OK;
- #ifdef _NO_EXCEPTIONS
- result = ErrorCode;
- #endif
- if (_buf2 != 0)
- {
- memcpy(_buf2, _buf + _streamPos, size);
- _buf2 += size;
- }
-
- if (_stream != 0
- #ifdef _NO_EXCEPTIONS
- && (ErrorCode == S_OK)
- #endif
- )
- {
- UInt32 processedSize = 0;
- result = _stream->Write(_buf + _streamPos, size, &processedSize);
- size = processedSize;
- }
- _streamPos += size;
- if (_streamPos == _bufSize)
- _streamPos = 0;
- if (_pos == _bufSize)
- {
- _overDict = true;
- _pos = 0;
- }
- _limitPos = (_streamPos > _pos) ? _streamPos : _bufSize;
- _processedSize += size;
- return result;
-}
-
-HRESULT COutBuffer::Flush() throw()
-{
- #ifdef _NO_EXCEPTIONS
- if (ErrorCode != S_OK)
- return ErrorCode;
- #endif
-
- while (_streamPos != _pos)
- {
- HRESULT result = FlushPart();
- if (result != S_OK)
- return result;
- }
- return S_OK;
-}
-
-void COutBuffer::FlushWithCheck()
-{
- HRESULT result = Flush();
- #ifdef _NO_EXCEPTIONS
- ErrorCode = result;
- #else
- if (result != S_OK)
- throw COutBufferException(result);
- #endif
-}
+// OutBuffer.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "OutBuffer.h"
+
+bool COutBuffer::Create(UInt32 bufSize) throw()
+{
+ const UInt32 kMinBlockSize = 1;
+ if (bufSize < kMinBlockSize)
+ bufSize = kMinBlockSize;
+ if (_buf && _bufSize == bufSize)
+ return true;
+ Free();
+ _bufSize = bufSize;
+ _buf = (Byte *)::MidAlloc(bufSize);
+ return (_buf != NULL);
+}
+
+void COutBuffer::Free() throw()
+{
+ ::MidFree(_buf);
+ _buf = NULL;
+}
+
+void COutBuffer::Init() throw()
+{
+ _streamPos = 0;
+ _limitPos = _bufSize;
+ _pos = 0;
+ _processedSize = 0;
+ _overDict = false;
+ #ifdef Z7_NO_EXCEPTIONS
+ ErrorCode = S_OK;
+ #endif
+}
+
+UInt64 COutBuffer::GetProcessedSize() const throw()
+{
+ UInt64 res = _processedSize + _pos - _streamPos;
+ if (_streamPos > _pos)
+ res += _bufSize;
+ return res;
+}
+
+
+HRESULT COutBuffer::FlushPart() throw()
+{
+ // _streamPos < _bufSize
+ UInt32 size = (_streamPos >= _pos) ? (_bufSize - _streamPos) : (_pos - _streamPos);
+ HRESULT result = S_OK;
+ #ifdef Z7_NO_EXCEPTIONS
+ result = ErrorCode;
+ #endif
+ if (_buf2)
+ {
+ memcpy(_buf2, _buf + _streamPos, size);
+ _buf2 += size;
+ }
+
+ if (_stream
+ #ifdef Z7_NO_EXCEPTIONS
+ && (ErrorCode == S_OK)
+ #endif
+ )
+ {
+ UInt32 processedSize = 0;
+ result = _stream->Write(_buf + _streamPos, size, &processedSize);
+ size = processedSize;
+ }
+ _streamPos += size;
+ if (_streamPos == _bufSize)
+ _streamPos = 0;
+ if (_pos == _bufSize)
+ {
+ _overDict = true;
+ _pos = 0;
+ }
+ _limitPos = (_streamPos > _pos) ? _streamPos : _bufSize;
+ _processedSize += size;
+ return result;
+}
+
+HRESULT COutBuffer::Flush() throw()
+{
+ #ifdef Z7_NO_EXCEPTIONS
+ if (ErrorCode != S_OK)
+ return ErrorCode;
+ #endif
+
+ while (_streamPos != _pos)
+ {
+ const HRESULT result = FlushPart();
+ if (result != S_OK)
+ return result;
+ }
+ return S_OK;
+}
+
+void COutBuffer::FlushWithCheck()
+{
+ const HRESULT result = Flush();
+ #ifdef Z7_NO_EXCEPTIONS
+ ErrorCode = result;
+ #else
+ if (result != S_OK)
+ throw COutBufferException(result);
+ #endif
+}
diff --git a/CPP/7zip/Common/OutBuffer.h b/CPP/7zip/Common/OutBuffer.h
index 2ffb5cd..cef7d50 100644
--- a/CPP/7zip/Common/OutBuffer.h
+++ b/CPP/7zip/Common/OutBuffer.h
@@ -1,66 +1,66 @@
-// OutBuffer.h
-
-#ifndef __OUT_BUFFER_H
-#define __OUT_BUFFER_H
-
-#include "../IStream.h"
-#include "../../Common/MyCom.h"
-#include "../../Common/MyException.h"
-
-#ifndef _NO_EXCEPTIONS
-struct COutBufferException: public CSystemException
-{
- COutBufferException(HRESULT errorCode): CSystemException(errorCode) {}
-};
-#endif
-
-class COutBuffer
-{
-protected:
- Byte *_buf;
- UInt32 _pos;
- UInt32 _limitPos;
- UInt32 _streamPos;
- UInt32 _bufSize;
- ISequentialOutStream *_stream;
- UInt64 _processedSize;
- Byte *_buf2;
- bool _overDict;
-
- HRESULT FlushPart() throw();
-public:
- #ifdef _NO_EXCEPTIONS
- HRESULT ErrorCode;
- #endif
-
- COutBuffer(): _buf(0), _pos(0), _stream(0), _buf2(0) {}
- ~COutBuffer() { Free(); }
-
- bool Create(UInt32 bufSize) throw();
- void Free() throw();
-
- void SetMemStream(Byte *buf) { _buf2 = buf; }
- void SetStream(ISequentialOutStream *stream) { _stream = stream; }
- void Init() throw();
- HRESULT Flush() throw();
- void FlushWithCheck();
-
- void WriteByte(Byte b)
- {
- UInt32 pos = _pos;
- _buf[pos] = b;
- pos++;
- _pos = pos;
- if (pos == _limitPos)
- FlushWithCheck();
- }
- void WriteBytes(const void *data, size_t size)
- {
- for (size_t i = 0; i < size; i++)
- WriteByte(((const Byte *)data)[i]);
- }
-
- UInt64 GetProcessedSize() const throw();
-};
-
-#endif
+// OutBuffer.h
+
+#ifndef ZIP7_INC_OUT_BUFFER_H
+#define ZIP7_INC_OUT_BUFFER_H
+
+#include "../IStream.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyException.h"
+
+#ifndef Z7_NO_EXCEPTIONS
+struct COutBufferException: public CSystemException
+{
+ COutBufferException(HRESULT errorCode): CSystemException(errorCode) {}
+};
+#endif
+
+class COutBuffer
+{
+protected:
+ Byte *_buf;
+ UInt32 _pos;
+ UInt32 _limitPos;
+ UInt32 _streamPos;
+ UInt32 _bufSize;
+ ISequentialOutStream *_stream;
+ UInt64 _processedSize;
+ Byte *_buf2;
+ bool _overDict;
+
+ HRESULT FlushPart() throw();
+public:
+ #ifdef Z7_NO_EXCEPTIONS
+ HRESULT ErrorCode;
+ #endif
+
+ COutBuffer(): _buf(NULL), _pos(0), _stream(NULL), _buf2(NULL) {}
+ ~COutBuffer() { Free(); }
+
+ bool Create(UInt32 bufSize) throw();
+ void Free() throw();
+
+ void SetMemStream(Byte *buf) { _buf2 = buf; }
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void Init() throw();
+ HRESULT Flush() throw();
+ void FlushWithCheck();
+
+ void WriteByte(Byte b)
+ {
+ UInt32 pos = _pos;
+ _buf[pos] = b;
+ pos++;
+ _pos = pos;
+ if (pos == _limitPos)
+ FlushWithCheck();
+ }
+ void WriteBytes(const void *data, size_t size)
+ {
+ for (size_t i = 0; i < size; i++)
+ WriteByte(((const Byte *)data)[i]);
+ }
+
+ UInt64 GetProcessedSize() const throw();
+};
+
+#endif
diff --git a/CPP/7zip/Common/OutMemStream.cpp b/CPP/7zip/Common/OutMemStream.cpp
new file mode 100644
index 0000000..29a2394
--- /dev/null
+++ b/CPP/7zip/Common/OutMemStream.cpp
@@ -0,0 +1,158 @@
+// OutMemStream.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "OutMemStream.h"
+
+void COutMemStream::Free()
+{
+ Blocks.Free(_memManager);
+ Blocks.LockMode = true;
+}
+
+void COutMemStream::Init()
+{
+ WriteToRealStreamEvent.Reset();
+ _unlockEventWasSent = false;
+ _realStreamMode = false;
+ Free();
+ _curBlockPos = 0;
+ _curBlockIndex = 0;
+}
+
+void COutMemStream::DetachData(CMemLockBlocks &blocks)
+{
+ Blocks.Detach(blocks, _memManager);
+ Free();
+}
+
+
+HRESULT COutMemStream::WriteToRealStream()
+{
+ RINOK(Blocks.WriteToStream(_memManager->GetBlockSize(), OutSeqStream))
+ Blocks.Free(_memManager);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(COutMemStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (_realStreamMode)
+ return OutSeqStream->Write(data, size, processedSize);
+ if (processedSize)
+ *processedSize = 0;
+ while (size != 0)
+ {
+ if (_curBlockIndex < Blocks.Blocks.Size())
+ {
+ Byte *p = (Byte *)Blocks.Blocks[_curBlockIndex] + _curBlockPos;
+ size_t curSize = _memManager->GetBlockSize() - _curBlockPos;
+ if (size < curSize)
+ curSize = size;
+ memcpy(p, data, curSize);
+ if (processedSize)
+ *processedSize += (UInt32)curSize;
+ data = (const void *)((const Byte *)data + curSize);
+ size -= (UInt32)curSize;
+ _curBlockPos += curSize;
+
+ const UInt64 pos64 = GetPos();
+ if (pos64 > Blocks.TotalSize)
+ Blocks.TotalSize = pos64;
+ if (_curBlockPos == _memManager->GetBlockSize())
+ {
+ _curBlockIndex++;
+ _curBlockPos = 0;
+ }
+ continue;
+ }
+
+ const NWindows::NSynchronization::CHandle_WFMO events[3] =
+ { StopWritingEvent, WriteToRealStreamEvent, /* NoLockEvent, */ _memManager->Semaphore };
+ const DWORD waitResult = NWindows::NSynchronization::WaitForMultiObj_Any_Infinite(
+ ((Blocks.LockMode /* && _memManager->Semaphore.IsCreated() */) ? 3 : 2), events);
+
+ // printf("\n 1- outMemStream %d\n", waitResult - WAIT_OBJECT_0);
+
+ switch (waitResult)
+ {
+ case (WAIT_OBJECT_0 + 0):
+ return StopWriteResult;
+ case (WAIT_OBJECT_0 + 1):
+ {
+ _realStreamMode = true;
+ RINOK(WriteToRealStream())
+ UInt32 processedSize2;
+ const HRESULT res = OutSeqStream->Write(data, size, &processedSize2);
+ if (processedSize)
+ *processedSize += processedSize2;
+ return res;
+ }
+ case (WAIT_OBJECT_0 + 2):
+ {
+ // it has bug: no write.
+ /*
+ if (!Blocks.SwitchToNoLockMode(_memManager))
+ return E_FAIL;
+ */
+ break;
+ }
+ default:
+ {
+ if (waitResult == WAIT_FAILED)
+ {
+ const DWORD res = ::GetLastError();
+ if (res != 0)
+ return HRESULT_FROM_WIN32(res);
+ }
+ return E_FAIL;
+ }
+ }
+ void *p = _memManager->AllocateBlock();
+ if (!p)
+ return E_FAIL;
+ Blocks.Blocks.Add(p);
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COutMemStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ if (_realStreamMode)
+ {
+ if (!OutStream)
+ return E_FAIL;
+ return OutStream->Seek(offset, seekOrigin, newPosition);
+ }
+ if (seekOrigin == STREAM_SEEK_CUR)
+ {
+ if (offset != 0)
+ return E_NOTIMPL;
+ }
+ else if (seekOrigin == STREAM_SEEK_SET)
+ {
+ if (offset != 0)
+ return E_NOTIMPL;
+ _curBlockIndex = 0;
+ _curBlockPos = 0;
+ }
+ else
+ return E_NOTIMPL;
+ if (newPosition)
+ *newPosition = GetPos();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COutMemStream::SetSize(UInt64 newSize))
+{
+ if (_realStreamMode)
+ {
+ if (!OutStream)
+ return E_FAIL;
+ return OutStream->SetSize(newSize);
+ }
+ Blocks.TotalSize = newSize;
+ return S_OK;
+}
diff --git a/CPP/7zip/Common/OutMemStream.h b/CPP/7zip/Common/OutMemStream.h
new file mode 100644
index 0000000..7fc2dbd
--- /dev/null
+++ b/CPP/7zip/Common/OutMemStream.h
@@ -0,0 +1,104 @@
+// OutMemStream.h
+
+#ifndef ZIP7_INC_OUT_MEM_STREAM_H
+#define ZIP7_INC_OUT_MEM_STREAM_H
+
+#include "../../Common/MyCom.h"
+
+#include "MemBlocks.h"
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutMemStream
+ , IOutStream
+)
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+
+ CMemBlockManagerMt *_memManager;
+ size_t _curBlockPos;
+ unsigned _curBlockIndex;
+ bool _realStreamMode;
+
+ bool _unlockEventWasSent;
+ NWindows::NSynchronization::CAutoResetEvent_WFMO StopWritingEvent;
+ NWindows::NSynchronization::CAutoResetEvent_WFMO WriteToRealStreamEvent;
+ // NWindows::NSynchronization::CAutoResetEvent NoLockEvent;
+
+ HRESULT StopWriteResult;
+ CMemLockBlocks Blocks;
+
+ CMyComPtr<ISequentialOutStream> OutSeqStream;
+ CMyComPtr<IOutStream> OutStream;
+
+ UInt64 GetPos() const { return (UInt64)_curBlockIndex * _memManager->GetBlockSize() + _curBlockPos; }
+
+public:
+
+ HRes CreateEvents(SYNC_PARAM_DECL(synchro))
+ {
+ WRes wres = StopWritingEvent.CreateIfNotCreated_Reset(SYNC_WFMO(synchro));
+ if (wres == 0)
+ wres = WriteToRealStreamEvent.CreateIfNotCreated_Reset(SYNC_WFMO(synchro));
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ void SetOutStream(IOutStream *outStream)
+ {
+ OutStream = outStream;
+ OutSeqStream = outStream;
+ }
+
+ void SetSeqOutStream(ISequentialOutStream *outStream)
+ {
+ OutStream = NULL;
+ OutSeqStream = outStream;
+ }
+
+ void ReleaseOutStream()
+ {
+ OutStream.Release();
+ OutSeqStream.Release();
+ }
+
+ COutMemStream(CMemBlockManagerMt *memManager):
+ _memManager(memManager)
+ {
+ /*
+ #ifndef _WIN32
+ StopWritingEvent._sync =
+ WriteToRealStreamEvent._sync = &memManager->Synchro;
+ #endif
+ */
+ }
+
+ ~COutMemStream() { Free(); }
+ void Free();
+
+ void Init();
+ HRESULT WriteToRealStream();
+
+ void DetachData(CMemLockBlocks &blocks);
+
+ bool WasUnlockEventSent() const { return _unlockEventWasSent; }
+
+ void SetRealStreamMode()
+ {
+ _unlockEventWasSent = true;
+ WriteToRealStreamEvent.Set();
+ }
+
+ /*
+ void SetNoLockMode()
+ {
+ _unlockEventWasSent = true;
+ NoLockEvent.Set();
+ }
+ */
+
+ void StopWriting(HRESULT res)
+ {
+ StopWriteResult = res;
+ StopWritingEvent.Set();
+ }
+};
+
+#endif
diff --git a/CPP/7zip/Common/ProgressMt.cpp b/CPP/7zip/Common/ProgressMt.cpp
new file mode 100644
index 0000000..ee21ab3
--- /dev/null
+++ b/CPP/7zip/Common/ProgressMt.cpp
@@ -0,0 +1,53 @@
+// ProgressMt.h
+
+#include "StdAfx.h"
+
+#include "ProgressMt.h"
+
+void CMtCompressProgressMixer::Init(unsigned numItems, ICompressProgressInfo *progress)
+{
+ NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+ InSizes.Clear();
+ OutSizes.Clear();
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ InSizes.Add(0);
+ OutSizes.Add(0);
+ }
+ TotalInSize = 0;
+ TotalOutSize = 0;
+ _progress = progress;
+}
+
+void CMtCompressProgressMixer::Reinit(unsigned index)
+{
+ NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+ InSizes[index] = 0;
+ OutSizes[index] = 0;
+}
+
+HRESULT CMtCompressProgressMixer::SetRatioInfo(unsigned index, const UInt64 *inSize, const UInt64 *outSize)
+{
+ NWindows::NSynchronization::CCriticalSectionLock lock(CriticalSection);
+ if (inSize)
+ {
+ const UInt64 diff = *inSize - InSizes[index];
+ InSizes[index] = *inSize;
+ TotalInSize += diff;
+ }
+ if (outSize)
+ {
+ const UInt64 diff = *outSize - OutSizes[index];
+ OutSizes[index] = *outSize;
+ TotalOutSize += diff;
+ }
+ if (_progress)
+ return _progress->SetRatioInfo(&TotalInSize, &TotalOutSize);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CMtCompressProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ return _progress->SetRatioInfo(_index, inSize, outSize);
+}
diff --git a/CPP/7zip/Common/ProgressMt.h b/CPP/7zip/Common/ProgressMt.h
new file mode 100644
index 0000000..78c806c
--- /dev/null
+++ b/CPP/7zip/Common/ProgressMt.h
@@ -0,0 +1,43 @@
+// ProgressMt.h
+
+#ifndef ZIP7_INC_PROGRESSMT_H
+#define ZIP7_INC_PROGRESSMT_H
+
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+#include "../../Windows/Synchronization.h"
+
+#include "../ICoder.h"
+#include "../IProgress.h"
+
+class CMtCompressProgressMixer
+{
+ CMyComPtr<ICompressProgressInfo> _progress;
+ CRecordVector<UInt64> InSizes;
+ CRecordVector<UInt64> OutSizes;
+ UInt64 TotalInSize;
+ UInt64 TotalOutSize;
+public:
+ NWindows::NSynchronization::CCriticalSection CriticalSection;
+ void Init(unsigned numItems, ICompressProgressInfo *progress);
+ void Reinit(unsigned index);
+ HRESULT SetRatioInfo(unsigned index, const UInt64 *inSize, const UInt64 *outSize);
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CMtCompressProgress
+ , ICompressProgressInfo
+)
+ unsigned _index;
+ CMtCompressProgressMixer *_progress;
+public:
+ void Init(CMtCompressProgressMixer *progress, unsigned index)
+ {
+ _progress = progress;
+ _index = index;
+ }
+ void Reinit() { _progress->Reinit(_index); }
+};
+
+#endif
diff --git a/CPP/7zip/Common/ProgressUtils.cpp b/CPP/7zip/Common/ProgressUtils.cpp
index 86f1e78..fb81f29 100644
--- a/CPP/7zip/Common/ProgressUtils.cpp
+++ b/CPP/7zip/Common/ProgressUtils.cpp
@@ -1,51 +1,51 @@
-// ProgressUtils.cpp
-
-#include "StdAfx.h"
-
-#include "ProgressUtils.h"
-
-CLocalProgress::CLocalProgress():
- ProgressOffset(0),
- InSize(0),
- OutSize(0),
- SendRatio(true),
- SendProgress(true)
- {}
-
-void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
-{
- _ratioProgress.Release();
- _progress = progress;
- _progress.QueryInterface(IID_ICompressProgressInfo, &_ratioProgress);
- _inSizeIsMain = inSizeIsMain;
-}
-
-STDMETHODIMP CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
- UInt64 inSize2 = InSize;
- UInt64 outSize2 = OutSize;
-
- if (inSize)
- inSize2 += (*inSize);
- if (outSize)
- outSize2 += (*outSize);
-
- if (SendRatio && _ratioProgress)
- {
- RINOK(_ratioProgress->SetRatioInfo(&inSize2, &outSize2));
- }
-
- if (SendProgress)
- {
- inSize2 += ProgressOffset;
- outSize2 += ProgressOffset;
- return _progress->SetCompleted(_inSizeIsMain ? &inSize2 : &outSize2);
- }
-
- return S_OK;
-}
-
-HRESULT CLocalProgress::SetCur()
-{
- return SetRatioInfo(NULL, NULL);
-}
+// ProgressUtils.cpp
+
+#include "StdAfx.h"
+
+#include "ProgressUtils.h"
+
+CLocalProgress::CLocalProgress():
+ SendRatio(true),
+ SendProgress(true),
+ ProgressOffset(0),
+ InSize(0),
+ OutSize(0)
+ {}
+
+void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
+{
+ _ratioProgress.Release();
+ _progress = progress;
+ _progress.QueryInterface(IID_ICompressProgressInfo, &_ratioProgress);
+ _inSizeIsMain = inSizeIsMain;
+}
+
+Z7_COM7F_IMF(CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ UInt64 inSize2 = InSize;
+ UInt64 outSize2 = OutSize;
+
+ if (inSize)
+ inSize2 += (*inSize);
+ if (outSize)
+ outSize2 += (*outSize);
+
+ if (SendRatio && _ratioProgress)
+ {
+ RINOK(_ratioProgress->SetRatioInfo(&inSize2, &outSize2))
+ }
+
+ if (SendProgress)
+ {
+ inSize2 += ProgressOffset;
+ outSize2 += ProgressOffset;
+ return _progress->SetCompleted(_inSizeIsMain ? &inSize2 : &outSize2);
+ }
+
+ return S_OK;
+}
+
+HRESULT CLocalProgress::SetCur()
+{
+ return SetRatioInfo(NULL, NULL);
+}
diff --git a/CPP/7zip/Common/ProgressUtils.h b/CPP/7zip/Common/ProgressUtils.h
index 176e8bb..dad5fcc 100644
--- a/CPP/7zip/Common/ProgressUtils.h
+++ b/CPP/7zip/Common/ProgressUtils.h
@@ -1,35 +1,33 @@
-// ProgressUtils.h
-
-#ifndef __PROGRESS_UTILS_H
-#define __PROGRESS_UTILS_H
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-#include "../IProgress.h"
-
-class CLocalProgress:
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
- CMyComPtr<IProgress> _progress;
- CMyComPtr<ICompressProgressInfo> _ratioProgress;
- bool _inSizeIsMain;
-public:
- UInt64 ProgressOffset;
- UInt64 InSize;
- UInt64 OutSize;
- bool SendRatio;
- bool SendProgress;
-
- CLocalProgress();
-
- void Init(IProgress *progress, bool inSizeIsMain);
- HRESULT SetCur();
-
- MY_UNKNOWN_IMP1(ICompressProgressInfo)
-
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-};
-
-#endif
+// ProgressUtils.h
+
+#ifndef ZIP7_INC_PROGRESS_UTILS_H
+#define ZIP7_INC_PROGRESS_UTILS_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+#include "../IProgress.h"
+
+Z7_CLASS_IMP_COM_1(
+ CLocalProgress
+ , ICompressProgressInfo
+)
+public:
+ bool SendRatio;
+ bool SendProgress;
+private:
+ bool _inSizeIsMain;
+ CMyComPtr<IProgress> _progress;
+ CMyComPtr<ICompressProgressInfo> _ratioProgress;
+public:
+ UInt64 ProgressOffset;
+ UInt64 InSize;
+ UInt64 OutSize;
+
+ CLocalProgress();
+
+ void Init(IProgress *progress, bool inSizeIsMain);
+ HRESULT SetCur();
+};
+
+#endif
diff --git a/CPP/7zip/Common/PropId.cpp b/CPP/7zip/Common/PropId.cpp
index 96f8f05..6117b0e 100644
--- a/CPP/7zip/Common/PropId.cpp
+++ b/CPP/7zip/Common/PropId.cpp
@@ -1,108 +1,117 @@
-// PropId.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/MyWindows.h"
-
-#include "../PropID.h"
-
-// VARTYPE
-const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED] =
-{
- VT_EMPTY,
- VT_UI4,
- VT_UI4,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR,
- VT_BOOL,
- VT_UI8,
- VT_UI8,
- VT_UI4,
- VT_FILETIME,
- VT_FILETIME,
- VT_FILETIME,
- VT_BOOL,
- VT_BOOL,
- VT_BOOL,
- VT_BOOL,
- VT_BOOL,
- VT_UI4,
- VT_UI4,
- VT_BSTR,
- VT_BOOL,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR,
- VT_UI8,
- VT_BSTR,
- VT_UI8,
- VT_BSTR,
- VT_UI8,
- VT_UI8,
- VT_BSTR, // or VT_UI8 kpidUnpackVer
- VT_UI4, // or VT_UI8 kpidVolume
- VT_BOOL,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_UI4,
- VT_BOOL,
- VT_BOOL,
- VT_BSTR,
- VT_UI8,
- VT_UI8,
- VT_UI4, // kpidChecksum
- VT_BSTR,
- VT_UI8,
- VT_BSTR, // or VT_UI8 kpidId
- VT_BSTR,
- VT_BSTR,
- VT_UI4,
- VT_UI4,
- VT_BSTR,
- VT_BSTR,
- VT_UI8,
- VT_UI8,
- VT_UI4,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR, // kpidNtSecure
- VT_BOOL,
- VT_BOOL,
- VT_BOOL,
- VT_BOOL,
- VT_BSTR, // SHA-1
- VT_BSTR, // SHA-256
- VT_BSTR,
- VT_UI8,
- VT_UI4,
- VT_UI4,
- VT_BSTR,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_UI8,
- VT_BSTR,
- VT_BSTR,
- VT_BSTR,
- VT_BOOL,
- VT_BOOL,
- VT_BOOL,
- VT_UI8,
- VT_UI8,
- VT_BSTR, // kpidNtReparse
- VT_BSTR,
- VT_UI8,
- VT_UI8,
- VT_BOOL,
- VT_BSTR,
- VT_BSTR
-};
+// PropId.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyWindows.h"
+
+#include "../PropID.h"
+
+// VARTYPE
+const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED] =
+{
+ VT_EMPTY,
+ VT_UI4,
+ VT_UI4,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BOOL,
+ VT_UI8,
+ VT_UI8,
+ VT_UI4,
+ VT_FILETIME,
+ VT_FILETIME,
+ VT_FILETIME,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BOOL,
+ VT_UI4,
+ VT_UI4,
+ VT_BSTR,
+ VT_BOOL,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_UI8,
+ VT_BSTR,
+ VT_UI8,
+ VT_BSTR,
+ VT_UI8,
+ VT_UI8,
+ VT_BSTR, // or VT_UI8 kpidUnpackVer
+ VT_UI4, // or VT_UI8 kpidVolume
+ VT_BOOL,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_UI4,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BSTR,
+ VT_UI8,
+ VT_UI8,
+ VT_UI4, // kpidChecksum
+ VT_BSTR,
+ VT_UI8,
+ VT_BSTR, // or VT_UI8 kpidId
+ VT_BSTR,
+ VT_BSTR,
+ VT_UI4,
+ VT_UI4,
+ VT_BSTR,
+ VT_BSTR,
+ VT_UI8,
+ VT_UI8,
+ VT_UI4,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR, // kpidNtSecure
+ VT_BOOL,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BSTR, // SHA-1
+ VT_BSTR, // SHA-256
+ VT_BSTR,
+ VT_UI8,
+ VT_UI4,
+ VT_UI4,
+ VT_BSTR,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_UI8,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BOOL,
+ VT_BOOL,
+ VT_BOOL,
+ VT_UI8,
+ VT_UI8,
+ VT_BSTR, // kpidNtReparse
+ VT_BSTR,
+ VT_UI8,
+ VT_UI8,
+ VT_BOOL,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BSTR,
+ VT_BOOL,
+ VT_FILETIME, // kpidChangeTime
+ VT_UI4,
+ VT_UI4,
+ VT_UI4,
+ VT_UI4,
+ VT_UI4,
+ VT_UI4 // kpidDevMinor
+};
diff --git a/CPP/7zip/Common/RegisterArc.h b/CPP/7zip/Common/RegisterArc.h
index 08aa2d4..55c1483 100644
--- a/CPP/7zip/Common/RegisterArc.h
+++ b/CPP/7zip/Common/RegisterArc.h
@@ -1,78 +1,80 @@
-// RegisterArc.h
-
-#ifndef __REGISTER_ARC_H
-#define __REGISTER_ARC_H
-
-#include "../Archive/IArchive.h"
-
-struct CArcInfo
-{
- UInt16 Flags;
- Byte Id;
- Byte SignatureSize;
- UInt16 SignatureOffset;
-
- const Byte *Signature;
- const char *Name;
- const char *Ext;
- const char *AddExt;
-
- Func_CreateInArchive CreateInArchive;
- Func_CreateOutArchive CreateOutArchive;
- Func_IsArc IsArc;
-
- bool IsMultiSignature() const { return (Flags & NArcInfoFlags::kMultiSignature) != 0; }
-};
-
-void RegisterArc(const CArcInfo *arcInfo) throw();
-
-
-#define IMP_CreateArcIn_2(c) \
- static IInArchive *CreateArc() { return new c; }
-
-#define IMP_CreateArcIn IMP_CreateArcIn_2(CHandler())
-
-#ifdef EXTRACT_ONLY
- #define IMP_CreateArcOut
- #define CreateArcOut NULL
-#else
- #define IMP_CreateArcOut static IOutArchive *CreateArcOut() { return new CHandler(); }
-#endif
-
-#define REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
- static const CArcInfo g_ArcInfo = { flags, id, sigSize, offs, sig, n, e, ae, crIn, crOut, isArc } ; \
-
-#define REGISTER_ARC_R(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
- REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
- struct CRegisterArc { CRegisterArc() { RegisterArc(&g_ArcInfo); }}; \
- static CRegisterArc g_RegisterArc;
-
-
-#define REGISTER_ARC_I_CLS(cls, n, e, ae, id, sig, offs, flags, isArc) \
- IMP_CreateArcIn_2(cls) \
- REGISTER_ARC_R(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, NULL, isArc)
-
-#define REGISTER_ARC_I_CLS_NO_SIG(cls, n, e, ae, id, offs, flags, isArc) \
- IMP_CreateArcIn_2(cls) \
- REGISTER_ARC_R(n, e, ae, id, 0, NULL, offs, flags, CreateArc, NULL, isArc)
-
-#define REGISTER_ARC_I(n, e, ae, id, sig, offs, flags, isArc) \
- REGISTER_ARC_I_CLS(CHandler(), n, e, ae, id, sig, offs, flags, isArc)
-
-#define REGISTER_ARC_I_NO_SIG(n, e, ae, id, offs, flags, isArc) \
- REGISTER_ARC_I_CLS_NO_SIG(CHandler(), n, e, ae, id, offs, flags, isArc)
-
-
-#define REGISTER_ARC_IO(n, e, ae, id, sig, offs, flags, isArc) \
- IMP_CreateArcIn \
- IMP_CreateArcOut \
- REGISTER_ARC_R(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, CreateArcOut, isArc)
-
-#define REGISTER_ARC_IO_DECREMENT_SIG(n, e, ae, id, sig, offs, flags, isArc) \
- IMP_CreateArcIn \
- IMP_CreateArcOut \
- REGISTER_ARC_V(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, CreateArcOut, isArc) \
- struct CRegisterArcDecSig { CRegisterArcDecSig() { sig[0]--; RegisterArc(&g_ArcInfo); }}; \
- static CRegisterArcDecSig g_RegisterArc;
-
-#endif
+// RegisterArc.h
+
+#ifndef ZIP7_INC_REGISTER_ARC_H
+#define ZIP7_INC_REGISTER_ARC_H
+
+#include "../Archive/IArchive.h"
+
+struct CArcInfo
+{
+ UInt32 Flags;
+ Byte Id;
+ Byte SignatureSize;
+ UInt16 SignatureOffset;
+
+ const Byte *Signature;
+ const char *Name;
+ const char *Ext;
+ const char *AddExt;
+
+ UInt32 TimeFlags;
+
+ Func_CreateInArchive CreateInArchive;
+ Func_CreateOutArchive CreateOutArchive;
+ Func_IsArc IsArc;
+
+ bool IsMultiSignature() const { return (Flags & NArcInfoFlags::kMultiSignature) != 0; }
+};
+
+void RegisterArc(const CArcInfo *arcInfo) throw();
+
+
+#define IMP_CreateArcIn_2(c) \
+ static IInArchive *CreateArc() { return new c; }
+
+#define IMP_CreateArcIn IMP_CreateArcIn_2(CHandler())
+
+#ifdef Z7_EXTRACT_ONLY
+ #define IMP_CreateArcOut
+ #define CreateArcOut NULL
+#else
+ #define IMP_CreateArcOut static IOutArchive *CreateArcOut() { return new CHandler(); }
+#endif
+
+#define REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, tf, crIn, crOut, isArc) \
+ static const CArcInfo g_ArcInfo = { flags, id, sigSize, offs, sig, n, e, ae, tf, crIn, crOut, isArc } ; \
+
+#define REGISTER_ARC_R(n, e, ae, id, sigSize, sig, offs, flags, tf, crIn, crOut, isArc) \
+ REGISTER_ARC_V (n, e, ae, id, sigSize, sig, offs, flags, tf, crIn, crOut, isArc) \
+ struct CRegisterArc { CRegisterArc() { RegisterArc(&g_ArcInfo); }}; \
+ static CRegisterArc g_RegisterArc;
+
+
+#define REGISTER_ARC_I_CLS(cls, n, e, ae, id, sig, offs, flags, isArc) \
+ IMP_CreateArcIn_2(cls) \
+ REGISTER_ARC_R(n, e, ae, id, Z7_ARRAY_SIZE(sig), sig, offs, flags, 0, CreateArc, NULL, isArc)
+
+#define REGISTER_ARC_I_CLS_NO_SIG(cls, n, e, ae, id, offs, flags, isArc) \
+ IMP_CreateArcIn_2(cls) \
+ REGISTER_ARC_R(n, e, ae, id, 0, NULL, offs, flags, 0, CreateArc, NULL, isArc)
+
+#define REGISTER_ARC_I(n, e, ae, id, sig, offs, flags, isArc) \
+ REGISTER_ARC_I_CLS(CHandler(), n, e, ae, id, sig, offs, flags, isArc)
+
+#define REGISTER_ARC_I_NO_SIG(n, e, ae, id, offs, flags, isArc) \
+ REGISTER_ARC_I_CLS_NO_SIG(CHandler(), n, e, ae, id, offs, flags, isArc)
+
+
+#define REGISTER_ARC_IO(n, e, ae, id, sig, offs, flags, tf, isArc) \
+ IMP_CreateArcIn \
+ IMP_CreateArcOut \
+ REGISTER_ARC_R(n, e, ae, id, Z7_ARRAY_SIZE(sig), sig, offs, flags, tf, CreateArc, CreateArcOut, isArc)
+
+#define REGISTER_ARC_IO_DECREMENT_SIG(n, e, ae, id, sig, offs, flags, tf, isArc) \
+ IMP_CreateArcIn \
+ IMP_CreateArcOut \
+ REGISTER_ARC_V(n, e, ae, id, Z7_ARRAY_SIZE(sig), sig, offs, flags, tf, CreateArc, CreateArcOut, isArc) \
+ struct CRegisterArcDecSig { CRegisterArcDecSig() { sig[0]--; RegisterArc(&g_ArcInfo); }}; \
+ static CRegisterArcDecSig g_RegisterArc;
+
+#endif
diff --git a/CPP/7zip/Common/RegisterCodec.h b/CPP/7zip/Common/RegisterCodec.h
index b566065..cf94998 100644
--- a/CPP/7zip/Common/RegisterCodec.h
+++ b/CPP/7zip/Common/RegisterCodec.h
@@ -1,106 +1,106 @@
-// RegisterCodec.h
-
-#ifndef __REGISTER_CODEC_H
-#define __REGISTER_CODEC_H
-
-#include "../Common/MethodId.h"
-
-#include "../ICoder.h"
-
-typedef void * (*CreateCodecP)();
-
-struct CCodecInfo
-{
- CreateCodecP CreateDecoder;
- CreateCodecP CreateEncoder;
- CMethodId Id;
- const char *Name;
- UInt32 NumStreams;
- bool IsFilter;
-};
-
-void RegisterCodec(const CCodecInfo *codecInfo) throw();
-
-
-#define REGISTER_CODEC_CREATE_2(name, cls, i) static void *name() { return (void *)(i *)(new cls); }
-#define REGISTER_CODEC_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressCoder)
-
-#define REGISTER_CODEC_NAME(x) CRegisterCodec ## x
-#define REGISTER_CODEC_VAR static const CCodecInfo g_CodecInfo =
-
-#define REGISTER_CODEC(x) struct REGISTER_CODEC_NAME(x) { \
- REGISTER_CODEC_NAME(x)() { RegisterCodec(&g_CodecInfo); }}; \
- static REGISTER_CODEC_NAME(x) g_RegisterCodec;
-
-
-#define REGISTER_CODECS_NAME(x) CRegisterCodecs ## x
-#define REGISTER_CODECS_VAR static const CCodecInfo g_CodecsInfo[] =
-
-#define REGISTER_CODECS(x) struct REGISTER_CODECS_NAME(x) { \
- REGISTER_CODECS_NAME(x)() { for (unsigned i = 0; i < ARRAY_SIZE(g_CodecsInfo); i++) \
- RegisterCodec(&g_CodecsInfo[i]); }}; \
- static REGISTER_CODECS_NAME(x) g_RegisterCodecs;
-
-
-#define REGISTER_CODEC_2(x, crDec, crEnc, id, name) \
- REGISTER_CODEC_VAR \
- { crDec, crEnc, id, name, 1, false }; \
- REGISTER_CODEC(x)
-
-
-#ifdef EXTRACT_ONLY
- #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
- REGISTER_CODEC_CREATE(CreateDec, clsDec) \
- REGISTER_CODEC_2(x, CreateDec, NULL, id, name)
-#else
- #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
- REGISTER_CODEC_CREATE(CreateDec, clsDec) \
- REGISTER_CODEC_CREATE(CreateEnc, clsEnc) \
- REGISTER_CODEC_2(x, CreateDec, CreateEnc, id, name)
-#endif
-
-
-
-#define REGISTER_FILTER_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressFilter)
-
-#define REGISTER_FILTER_ITEM(crDec, crEnc, id, name) \
- { crDec, crEnc, id, name, 1, true }
-
-#define REGISTER_FILTER(x, crDec, crEnc, id, name) \
- REGISTER_CODEC_VAR \
- REGISTER_FILTER_ITEM(crDec, crEnc, id, name); \
- REGISTER_CODEC(x)
-
-#ifdef EXTRACT_ONLY
- #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
- REGISTER_FILTER_CREATE(CreateDec, clsDec) \
- REGISTER_FILTER(x, CreateDec, NULL, id, name)
-#else
- #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
- REGISTER_FILTER_CREATE(CreateDec, clsDec) \
- REGISTER_FILTER_CREATE(CreateEnc, clsEnc) \
- REGISTER_FILTER(x, CreateDec, CreateEnc, id, name)
-#endif
-
-
-
-struct CHasherInfo
-{
- IHasher * (*CreateHasher)();
- CMethodId Id;
- const char *Name;
- UInt32 DigestSize;
-};
-
-void RegisterHasher(const CHasherInfo *hasher) throw();
-
-#define REGISTER_HASHER_NAME(x) CRegHasher_ ## x
-
-#define REGISTER_HASHER(cls, id, name, size) \
- STDMETHODIMP_(UInt32) cls::GetDigestSize() throw() { return size; } \
- static IHasher *CreateHasherSpec() { return new cls(); } \
- static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, size }; \
- struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
- static REGISTER_HASHER_NAME(cls) g_RegisterHasher;
-
-#endif
+// RegisterCodec.h
+
+#ifndef ZIP7_INC_REGISTER_CODEC_H
+#define ZIP7_INC_REGISTER_CODEC_H
+
+#include "../Common/MethodId.h"
+
+#include "../ICoder.h"
+
+typedef void * (*CreateCodecP)();
+
+struct CCodecInfo
+{
+ CreateCodecP CreateDecoder;
+ CreateCodecP CreateEncoder;
+ CMethodId Id;
+ const char *Name;
+ UInt32 NumStreams;
+ bool IsFilter;
+};
+
+void RegisterCodec(const CCodecInfo *codecInfo) throw();
+
+
+#define REGISTER_CODEC_CREATE_2(name, cls, i) static void *name() { return (void *)(i *)(new cls); }
+#define REGISTER_CODEC_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressCoder)
+
+#define REGISTER_CODEC_NAME(x) CRegisterCodec ## x
+#define REGISTER_CODEC_VAR(x) static const CCodecInfo g_CodecInfo_ ## x =
+
+#define REGISTER_CODEC(x) struct REGISTER_CODEC_NAME(x) { \
+ REGISTER_CODEC_NAME(x)() { RegisterCodec(&g_CodecInfo_ ## x); }}; \
+ static REGISTER_CODEC_NAME(x) g_RegisterCodec_ ## x;
+
+
+#define REGISTER_CODECS_NAME(x) CRegisterCodecs ## x
+#define REGISTER_CODECS_VAR static const CCodecInfo g_CodecsInfo[] =
+
+#define REGISTER_CODECS(x) struct REGISTER_CODECS_NAME(x) { \
+ REGISTER_CODECS_NAME(x)() { for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_CodecsInfo); i++) \
+ RegisterCodec(&g_CodecsInfo[i]); }}; \
+ static REGISTER_CODECS_NAME(x) g_RegisterCodecs;
+
+
+#define REGISTER_CODEC_2(x, crDec, crEnc, id, name) \
+ REGISTER_CODEC_VAR(x) \
+ { crDec, crEnc, id, name, 1, false }; \
+ REGISTER_CODEC(x)
+
+
+#ifdef Z7_EXTRACT_ONLY
+ #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
+ REGISTER_CODEC_CREATE(CreateDec, clsDec) \
+ REGISTER_CODEC_2(x, CreateDec, NULL, id, name)
+#else
+ #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
+ REGISTER_CODEC_CREATE(CreateDec, clsDec) \
+ REGISTER_CODEC_CREATE(CreateEnc, clsEnc) \
+ REGISTER_CODEC_2(x, CreateDec, CreateEnc, id, name)
+#endif
+
+
+
+#define REGISTER_FILTER_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressFilter)
+
+#define REGISTER_FILTER_ITEM(crDec, crEnc, id, name) \
+ { crDec, crEnc, id, name, 1, true }
+
+#define REGISTER_FILTER(x, crDec, crEnc, id, name) \
+ REGISTER_CODEC_VAR(x) \
+ REGISTER_FILTER_ITEM(crDec, crEnc, id, name); \
+ REGISTER_CODEC(x)
+
+#ifdef Z7_EXTRACT_ONLY
+ #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
+ REGISTER_FILTER_CREATE(x ## _CreateDec, clsDec) \
+ REGISTER_FILTER(x, x ## _CreateDec, NULL, id, name)
+#else
+ #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
+ REGISTER_FILTER_CREATE(x ## _CreateDec, clsDec) \
+ REGISTER_FILTER_CREATE(x ## _CreateEnc, clsEnc) \
+ REGISTER_FILTER(x, x ## _CreateDec, x ## _CreateEnc, id, name)
+#endif
+
+
+
+struct CHasherInfo
+{
+ IHasher * (*CreateHasher)();
+ CMethodId Id;
+ const char *Name;
+ UInt32 DigestSize;
+};
+
+void RegisterHasher(const CHasherInfo *hasher) throw();
+
+#define REGISTER_HASHER_NAME(x) CRegHasher_ ## x
+
+#define REGISTER_HASHER(cls, id, name, size) \
+ Z7_COM7F_IMF2(UInt32, cls::GetDigestSize()) { return size; } \
+ static IHasher *CreateHasherSpec() { return new cls(); } \
+ static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, size }; \
+ struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
+ static REGISTER_HASHER_NAME(cls) g_RegisterHasher;
+
+#endif
diff --git a/CPP/7zip/Common/StdAfx.h b/CPP/7zip/Common/StdAfx.h
index 42a088f..8086655 100644
--- a/CPP/7zip/Common/StdAfx.h
+++ b/CPP/7zip/Common/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Common/StreamBinder.cpp b/CPP/7zip/Common/StreamBinder.cpp
index a6627db..38334af 100644
--- a/CPP/7zip/Common/StreamBinder.cpp
+++ b/CPP/7zip/Common/StreamBinder.cpp
@@ -1,156 +1,151 @@
-// StreamBinder.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/MyCom.h"
-
-#include "StreamBinder.h"
-
-class CBinderInStream:
- public ISequentialInStream,
- public CMyUnknownImp
-{
- CStreamBinder *_binder;
-public:
- MY_UNKNOWN_IMP1(ISequentialInStream)
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- ~CBinderInStream() { _binder->CloseRead(); }
- CBinderInStream(CStreamBinder *binder): _binder(binder) {}
-};
-
-STDMETHODIMP CBinderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
- { return _binder->Read(data, size, processedSize); }
-
-class CBinderOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CStreamBinder *_binder;
-public:
- MY_UNKNOWN_IMP1(ISequentialOutStream)
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- ~CBinderOutStream() { _binder->CloseWrite(); }
- CBinderOutStream(CStreamBinder *binder): _binder(binder) {}
-};
-
-STDMETHODIMP CBinderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
- { return _binder->Write(data, size, processedSize); }
-
-
-
-WRes CStreamBinder::CreateEvents()
-{
- RINOK(_canWrite_Event.Create());
- RINOK(_canRead_Event.Create());
- return _readingWasClosed_Event.Create();
-}
-
-void CStreamBinder::ReInit()
-{
- _canWrite_Event.Reset();
- _canRead_Event.Reset();
- _readingWasClosed_Event.Reset();
-
- // _readingWasClosed = false;
- _readingWasClosed2 = false;
-
- _waitWrite = true;
- _bufSize = 0;
- _buf = NULL;
- ProcessedSize = 0;
- // WritingWasCut = false;
-}
-
-
-void CStreamBinder::CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream)
-{
- // _readingWasClosed = false;
- _readingWasClosed2 = false;
-
- _waitWrite = true;
- _bufSize = 0;
- _buf = NULL;
- ProcessedSize = 0;
- // WritingWasCut = false;
-
- CBinderInStream *inStreamSpec = new CBinderInStream(this);
- CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
- *inStream = inStreamLoc.Detach();
-
- CBinderOutStream *outStreamSpec = new CBinderOutStream(this);
- CMyComPtr<ISequentialOutStream> outStreamLoc(outStreamSpec);
- *outStream = outStreamLoc.Detach();
-}
-
-// (_canRead_Event && _bufSize == 0) means that stream is finished.
-
-HRESULT CStreamBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size != 0)
- {
- if (_waitWrite)
- {
- RINOK(_canRead_Event.Lock());
- _waitWrite = false;
- }
- if (size > _bufSize)
- size = _bufSize;
- if (size != 0)
- {
- memcpy(data, _buf, size);
- _buf = ((const Byte *)_buf) + size;
- ProcessedSize += size;
- if (processedSize)
- *processedSize = size;
- _bufSize -= size;
- if (_bufSize == 0)
- {
- _waitWrite = true;
- _canRead_Event.Reset();
- _canWrite_Event.Set();
- }
- }
- }
- return S_OK;
-}
-
-HRESULT CStreamBinder::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
-
- if (!_readingWasClosed2)
- {
- _buf = data;
- _bufSize = size;
- _canRead_Event.Set();
-
- /*
- _canWrite_Event.Lock();
- if (_readingWasClosed)
- _readingWasClosed2 = true;
- */
-
- HANDLE events[2] = { _canWrite_Event, _readingWasClosed_Event };
- DWORD waitResult = ::WaitForMultipleObjects(2, events, FALSE, INFINITE);
- if (waitResult >= WAIT_OBJECT_0 + 2)
- return E_FAIL;
-
- size -= _bufSize;
- if (size != 0)
- {
- if (processedSize)
- *processedSize = size;
- return S_OK;
- }
- // if (waitResult == WAIT_OBJECT_0 + 1)
- _readingWasClosed2 = true;
- }
-
- // WritingWasCut = true;
- return k_My_HRESULT_WritingWasCut;
-}
+// StreamBinder.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyCom.h"
+
+#include "StreamBinder.h"
+
+Z7_CLASS_IMP_COM_1(
+ CBinderInStream
+ , ISequentialInStream
+)
+ CStreamBinder *_binder;
+public:
+ ~CBinderInStream() { _binder->CloseRead_CallOnce(); }
+ CBinderInStream(CStreamBinder *binder): _binder(binder) {}
+};
+
+Z7_COM7F_IMF(CBinderInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+ { return _binder->Read(data, size, processedSize); }
+
+
+Z7_CLASS_IMP_COM_1(
+ CBinderOutStream
+ , ISequentialOutStream
+)
+ CStreamBinder *_binder;
+public:
+ ~CBinderOutStream() { _binder->CloseWrite(); }
+ CBinderOutStream(CStreamBinder *binder): _binder(binder) {}
+};
+
+Z7_COM7F_IMF(CBinderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+ { return _binder->Write(data, size, processedSize); }
+
+
+static HRESULT Event_Create_or_Reset(NWindows::NSynchronization::CAutoResetEvent &event)
+{
+ const WRes wres = event.CreateIfNotCreated_Reset();
+ return HRESULT_FROM_WIN32(wres);
+}
+
+HRESULT CStreamBinder::Create_ReInit()
+{
+ RINOK(Event_Create_or_Reset(_canRead_Event))
+ // RINOK(Event_Create_or_Reset(_canWrite_Event))
+
+ // _canWrite_Semaphore.Close();
+ // we need at least 3 items of maxCount: 1 for normal unlock in Read(), 2 items for unlock in CloseRead_CallOnce()
+ _canWrite_Semaphore.OptCreateInit(0, 3);
+
+ // _readingWasClosed = false;
+ _readingWasClosed2 = false;
+
+ _waitWrite = true;
+ _bufSize = 0;
+ _buf = NULL;
+ ProcessedSize = 0;
+ // WritingWasCut = false;
+ return S_OK;
+}
+
+
+void CStreamBinder::CreateStreams2(CMyComPtr<ISequentialInStream> &inStream, CMyComPtr<ISequentialOutStream> &outStream)
+{
+ inStream = new CBinderInStream(this);
+ outStream = new CBinderOutStream(this);
+}
+
+// (_canRead_Event && _bufSize == 0) means that stream is finished.
+
+HRESULT CStreamBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size != 0)
+ {
+ if (_waitWrite)
+ {
+ WRes wres = _canRead_Event.Lock();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ _waitWrite = false;
+ }
+ if (size > _bufSize)
+ size = _bufSize;
+ if (size != 0)
+ {
+ memcpy(data, _buf, size);
+ _buf = ((const Byte *)_buf) + size;
+ ProcessedSize += size;
+ if (processedSize)
+ *processedSize = size;
+ _bufSize -= size;
+
+ /*
+ if (_bufSize == 0), then we have read whole buffer
+ we have two ways here:
+ - if we check (_bufSize == 0) here, we unlock Write only after full data Reading - it reduces the number of syncs
+ - if we don't check (_bufSize == 0) here, we unlock Write after partial data Reading
+ */
+ if (_bufSize == 0)
+ {
+ _waitWrite = true;
+ // _canWrite_Event.Set();
+ _canWrite_Semaphore.Release();
+ }
+ }
+ }
+ return S_OK;
+}
+
+
+HRESULT CStreamBinder::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+
+ if (!_readingWasClosed2)
+ {
+ _buf = data;
+ _bufSize = size;
+ _canRead_Event.Set();
+
+ /*
+ _canWrite_Event.Lock();
+ if (_readingWasClosed)
+ _readingWasClosed2 = true;
+ */
+
+ _canWrite_Semaphore.Lock();
+
+ // _bufSize : is remain size that was not read
+ size -= _bufSize;
+
+ // size : is size of data that was read
+ if (size != 0)
+ {
+ // if some data was read, then we report that size and return
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+ }
+ _readingWasClosed2 = true;
+ }
+
+ // WritingWasCut = true;
+ return k_My_HRESULT_WritingWasCut;
+}
diff --git a/CPP/7zip/Common/StreamBinder.h b/CPP/7zip/Common/StreamBinder.h
index f4d4f3b..c0a7079 100644
--- a/CPP/7zip/Common/StreamBinder.h
+++ b/CPP/7zip/Common/StreamBinder.h
@@ -1,60 +1,78 @@
-// StreamBinder.h
-
-#ifndef __STREAM_BINDER_H
-#define __STREAM_BINDER_H
-
-#include "../../Windows/Synchronization.h"
-
-#include "../IStream.h"
-
-/*
-We don't use probably UNSAFE version:
-reader thread:
- _canWrite_Event.Set();
- _readingWasClosed = true
- _canWrite_Event.Set();
-writer thread:
- _canWrite_Event.Wait()
- if (_readingWasClosed)
-Can second call of _canWrite_Event.Set() be executed without memory barrier, if event is already set?
-*/
-
-class CStreamBinder
-{
- NWindows::NSynchronization::CAutoResetEvent _canWrite_Event;
- NWindows::NSynchronization::CManualResetEvent _canRead_Event;
- NWindows::NSynchronization::CManualResetEvent _readingWasClosed_Event;
-
- // bool _readingWasClosed;
- bool _readingWasClosed2;
- // bool WritingWasCut;
- bool _waitWrite;
- UInt32 _bufSize;
- const void *_buf;
-public:
- UInt64 ProcessedSize;
-
- WRes CreateEvents();
- void CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream);
-
- void ReInit();
-
- HRESULT Read(void *data, UInt32 size, UInt32 *processedSize);
- HRESULT Write(const void *data, UInt32 size, UInt32 *processedSize);
-
- void CloseRead()
- {
- _readingWasClosed_Event.Set();
- // _readingWasClosed = true;
- // _canWrite_Event.Set();
- }
-
- void CloseWrite()
- {
- _buf = NULL;
- _bufSize = 0;
- _canRead_Event.Set();
- }
-};
-
-#endif
+// StreamBinder.h
+
+#ifndef ZIP7_INC_STREAM_BINDER_H
+#define ZIP7_INC_STREAM_BINDER_H
+
+#include "../../Windows/Synchronization.h"
+
+#include "../IStream.h"
+
+/*
+We can use one from two code versions here: with Event or with Semaphore to unlock Writer thread
+The difference for cases where Reading must be closed before Writing closing
+
+1) Event Version: _canWrite_Event
+ We call _canWrite_Event.Set() without waiting _canRead_Event in CloseRead() function.
+ The writer thread can get (_readingWasClosed) status in one from two iterations.
+ It's ambiguity of processing flow. But probably it's SAFE to use, if Event functions provide memory barriers.
+ reader thread:
+ _canWrite_Event.Set();
+ _readingWasClosed = true;
+ _canWrite_Event.Set();
+ writer thread:
+ _canWrite_Event.Wait()
+ if (_readingWasClosed)
+
+2) Semaphore Version: _canWrite_Semaphore
+ writer thread always will detect closing of reading in latest iteration after all data processing iterations
+*/
+
+class CStreamBinder
+{
+ NWindows::NSynchronization::CAutoResetEvent _canRead_Event;
+ // NWindows::NSynchronization::CAutoResetEvent _canWrite_Event;
+ NWindows::NSynchronization::CSemaphore _canWrite_Semaphore;
+
+ // bool _readingWasClosed; // set it in reader thread and check it in write thread
+ bool _readingWasClosed2; // use it in writer thread
+ // bool WritingWasCut;
+ bool _waitWrite; // use it in reader thread
+ UInt32 _bufSize;
+ const void *_buf;
+public:
+ UInt64 ProcessedSize; // the size that was read by reader thread
+
+ void CreateStreams2(CMyComPtr<ISequentialInStream> &inStream, CMyComPtr<ISequentialOutStream> &outStream);
+
+ HRESULT Create_ReInit();
+
+ HRESULT Read(void *data, UInt32 size, UInt32 *processedSize);
+ HRESULT Write(const void *data, UInt32 size, UInt32 *processedSize);
+
+ void CloseRead_CallOnce()
+ {
+ // call it only once: for example, in destructor
+
+ /*
+ _readingWasClosed = true;
+ _canWrite_Event.Set();
+ */
+
+ /*
+ We must relase Semaphore only once !!!
+ we must release at least 2 items of Semaphore:
+ one item to unlock partial Write(), if Read() have read some items
+ then additional item to stop writing (_bufSize will be 0)
+ */
+ _canWrite_Semaphore.Release(2);
+ }
+
+ void CloseWrite()
+ {
+ _buf = NULL;
+ _bufSize = 0;
+ _canRead_Event.Set();
+ }
+};
+
+#endif
diff --git a/CPP/7zip/Common/StreamObjects.cpp b/CPP/7zip/Common/StreamObjects.cpp
index 4cd9cc6..b54f423 100644
--- a/CPP/7zip/Common/StreamObjects.cpp
+++ b/CPP/7zip/Common/StreamObjects.cpp
@@ -1,285 +1,290 @@
-// StreamObjects.cpp
-
-#include "StdAfx.h"
-
-#include <stdlib.h>
-
-#include "../../../C/Alloc.h"
-
-#include "StreamObjects.h"
-
-STDMETHODIMP CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- if (_pos >= Buf.Size())
- return S_OK;
- size_t rem = Buf.Size() - (size_t)_pos;
- if (rem > size)
- rem = (size_t)size;
- memcpy(data, (const Byte *)Buf + (size_t)_pos, rem);
- _pos += rem;
- if (processedSize)
- *processedSize = (UInt32)rem;
- return S_OK;
-}
-
-STDMETHODIMP CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _pos; break;
- case STREAM_SEEK_END: offset += Buf.Size(); break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _pos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
-
-STDMETHODIMP CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- if (_pos >= _size)
- return S_OK;
- size_t rem = _size - (size_t)_pos;
- if (rem > size)
- rem = (size_t)size;
- memcpy(data, _data + (size_t)_pos, rem);
- _pos += rem;
- if (processedSize)
- *processedSize = (UInt32)rem;
- return S_OK;
-}
-
-STDMETHODIMP CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _pos; break;
- case STREAM_SEEK_END: offset += _size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _pos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
-
-void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream)
-{
- *stream = NULL;
- CBufInStream *inStreamSpec = new CBufInStream;
- CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
- inStreamSpec->Init((const Byte *)data, size, ref);
- *stream = streamTemp.Detach();
-}
-
-void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream)
-{
- *stream = NULL;
- CBufferInStream *inStreamSpec = new CBufferInStream;
- CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
- inStreamSpec->Buf.CopyFrom((const Byte *)data, size);
- inStreamSpec->Init();
- *stream = streamTemp.Detach();
-}
-
-void CByteDynBuffer::Free() throw()
-{
- free(_buf);
- _buf = 0;
- _capacity = 0;
-}
-
-bool CByteDynBuffer::EnsureCapacity(size_t cap) throw()
-{
- if (cap <= _capacity)
- return true;
- size_t delta;
- if (_capacity > 64)
- delta = _capacity / 4;
- else if (_capacity > 8)
- delta = 16;
- else
- delta = 4;
- cap = MyMax(_capacity + delta, cap);
- Byte *buf = (Byte *)realloc(_buf, cap);
- if (!buf)
- return false;
- _buf = buf;
- _capacity = cap;
- return true;
-}
-
-Byte *CDynBufSeqOutStream::GetBufPtrForWriting(size_t addSize)
-{
- addSize += _size;
- if (addSize < _size)
- return NULL;
- if (!_buffer.EnsureCapacity(addSize))
- return NULL;
- return (Byte *)_buffer + _size;
-}
-
-void CDynBufSeqOutStream::CopyToBuffer(CByteBuffer &dest) const
-{
- dest.CopyFrom((const Byte *)_buffer, _size);
-}
-
-STDMETHODIMP CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- Byte *buf = GetBufPtrForWriting(size);
- if (!buf)
- return E_OUTOFMEMORY;
- memcpy(buf, data, size);
- UpdateSize(size);
- if (processedSize)
- *processedSize = size;
- return S_OK;
-}
-
-STDMETHODIMP CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- size_t rem = _size - _pos;
- if (rem > size)
- rem = (size_t)size;
- if (rem != 0)
- {
- memcpy(_buffer + _pos, data, rem);
- _pos += rem;
- }
- if (processedSize)
- *processedSize = (UInt32)rem;
- return (rem != 0 || size == 0) ? S_OK : E_FAIL;
-}
-
-STDMETHODIMP CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessedSize;
- HRESULT result = _stream->Write(data, size, &realProcessedSize);
- _size += realProcessedSize;
- if (processedSize)
- *processedSize = realProcessedSize;
- return result;
-}
-
-static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
-
-void CCachedInStream::Free() throw()
-{
- MyFree(_tags);
- _tags = 0;
- MidFree(_data);
- _data = 0;
-}
-
-bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw()
-{
- unsigned sizeLog = blockSizeLog + numBlocksLog;
- if (sizeLog >= sizeof(size_t) * 8)
- return false;
- size_t dataSize = (size_t)1 << sizeLog;
- if (_data == 0 || dataSize != _dataSize)
- {
- MidFree(_data);
- _data = (Byte *)MidAlloc(dataSize);
- if (_data == 0)
- return false;
- _dataSize = dataSize;
- }
- if (_tags == 0 || numBlocksLog != _numBlocksLog)
- {
- MyFree(_tags);
- _tags = (UInt64 *)MyAlloc(sizeof(UInt64) << numBlocksLog);
- if (_tags == 0)
- return false;
- _numBlocksLog = numBlocksLog;
- }
- _blockSizeLog = blockSizeLog;
- return true;
-}
-
-void CCachedInStream::Init(UInt64 size) throw()
-{
- _size = size;
- _pos = 0;
- size_t numBlocks = (size_t)1 << _numBlocksLog;
- for (size_t i = 0; i < numBlocks; i++)
- _tags[i] = kEmptyTag;
-}
-
-STDMETHODIMP CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- if (_pos >= _size)
- return S_OK;
-
- {
- UInt64 rem = _size - _pos;
- if (size > rem)
- size = (UInt32)rem;
- }
-
- while (size != 0)
- {
- UInt64 cacheTag = _pos >> _blockSizeLog;
- size_t cacheIndex = (size_t)cacheTag & (((size_t)1 << _numBlocksLog) - 1);
- Byte *p = _data + (cacheIndex << _blockSizeLog);
- if (_tags[cacheIndex] != cacheTag)
- {
- UInt64 remInBlock = _size - (cacheTag << _blockSizeLog);
- size_t blockSize = (size_t)1 << _blockSizeLog;
- if (blockSize > remInBlock)
- blockSize = (size_t)remInBlock;
- RINOK(ReadBlock(cacheTag, p, blockSize));
- _tags[cacheIndex] = cacheTag;
- }
- size_t offset = (size_t)_pos & (((size_t)1 << _blockSizeLog) - 1);
- UInt32 cur = (UInt32)MyMin(((size_t)1 << _blockSizeLog) - offset, (size_t)size);
- memcpy(data, p + offset, cur);
- if (processedSize)
- *processedSize += cur;
- data = (void *)((const Byte *)data + cur);
- _pos += cur;
- size -= cur;
- }
-
- return S_OK;
-}
-
-STDMETHODIMP CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: break;
- case STREAM_SEEK_CUR: offset += _pos; break;
- case STREAM_SEEK_END: offset += _size; break;
- default: return STG_E_INVALIDFUNCTION;
- }
- if (offset < 0)
- return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
- _pos = offset;
- if (newPosition)
- *newPosition = offset;
- return S_OK;
-}
+// StreamObjects.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "StreamObjects.h"
+
+Z7_COM7F_IMF(CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (_pos >= Buf.Size())
+ return S_OK;
+ size_t rem = Buf.Size() - (size_t)_pos;
+ if (rem > size)
+ rem = (size_t)size;
+ memcpy(data, (const Byte *)Buf + (size_t)_pos, rem);
+ _pos += rem;
+ if (processedSize)
+ *processedSize = (UInt32)rem;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _pos; break;
+ case STREAM_SEEK_END: offset += Buf.Size(); break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _pos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (_pos >= _size)
+ return S_OK;
+ size_t rem = _size - (size_t)_pos;
+ if (rem > size)
+ rem = (size_t)size;
+ memcpy(data, _data + (size_t)_pos, rem);
+ _pos += rem;
+ if (processedSize)
+ *processedSize = (UInt32)rem;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _pos; break;
+ case STREAM_SEEK_END: offset += _size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _pos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
+
+void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream)
+{
+ *stream = NULL;
+ CBufInStream *inStreamSpec = new CBufInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
+ inStreamSpec->Init((const Byte *)data, size, ref);
+ *stream = streamTemp.Detach();
+}
+
+void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream)
+{
+ *stream = NULL;
+ CBufferInStream *inStreamSpec = new CBufferInStream;
+ CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
+ inStreamSpec->Buf.CopyFrom((const Byte *)data, size);
+ inStreamSpec->Init();
+ *stream = streamTemp.Detach();
+}
+
+void CByteDynBuffer::Free() throw()
+{
+ MyFree(_buf);
+ _buf = NULL;
+ _capacity = 0;
+}
+
+bool CByteDynBuffer::EnsureCapacity(size_t cap) throw()
+{
+ if (cap <= _capacity)
+ return true;
+ const size_t cap2 = _capacity + _capacity / 4;
+ if (cap < cap2)
+ cap = cap2;
+ Byte *buf = (Byte *)MyRealloc(_buf, cap);
+ if (!buf)
+ return false;
+ _buf = buf;
+ _capacity = cap;
+ return true;
+}
+
+Byte *CDynBufSeqOutStream::GetBufPtrForWriting(size_t addSize)
+{
+ addSize += _size;
+ if (addSize < _size)
+ return NULL;
+ if (!_buffer.EnsureCapacity(addSize))
+ return NULL;
+ return (Byte *)_buffer + _size;
+}
+
+void CDynBufSeqOutStream::CopyToBuffer(CByteBuffer &dest) const
+{
+ dest.CopyFrom((const Byte *)_buffer, _size);
+}
+
+Z7_COM7F_IMF(CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ Byte *buf = GetBufPtrForWriting(size);
+ if (!buf)
+ return E_OUTOFMEMORY;
+ memcpy(buf, data, size);
+ UpdateSize(size);
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ size_t rem = _size - _pos;
+ if (rem > size)
+ rem = (size_t)size;
+ if (rem != 0)
+ {
+ memcpy(_buffer + _pos, data, rem);
+ _pos += rem;
+ }
+ if (processedSize)
+ *processedSize = (UInt32)rem;
+ return (rem != 0 || size == 0) ? S_OK : E_FAIL;
+}
+
+Z7_COM7F_IMF(CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize;
+ HRESULT result = _stream->Write(data, size, &realProcessedSize);
+ _size += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return result;
+}
+
+static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
+
+void CCachedInStream::Free() throw()
+{
+ MyFree(_tags);
+ _tags = NULL;
+ MidFree(_data);
+ _data = NULL;
+}
+
+bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw()
+{
+ unsigned sizeLog = blockSizeLog + numBlocksLog;
+ if (sizeLog >= sizeof(size_t) * 8)
+ return false;
+ size_t dataSize = (size_t)1 << sizeLog;
+ if (!_data || dataSize != _dataSize)
+ {
+ MidFree(_data);
+ _data = (Byte *)MidAlloc(dataSize);
+ if (!_data)
+ return false;
+ _dataSize = dataSize;
+ }
+ if (!_tags || numBlocksLog != _numBlocksLog)
+ {
+ MyFree(_tags);
+ _tags = (UInt64 *)MyAlloc(sizeof(UInt64) << numBlocksLog);
+ if (!_tags)
+ return false;
+ _numBlocksLog = numBlocksLog;
+ }
+ _blockSizeLog = blockSizeLog;
+ return true;
+}
+
+void CCachedInStream::Init(UInt64 size) throw()
+{
+ _size = size;
+ _pos = 0;
+ const size_t numBlocks = (size_t)1 << _numBlocksLog;
+ for (size_t i = 0; i < numBlocks; i++)
+ _tags[i] = kEmptyTag;
+}
+
+Z7_COM7F_IMF(CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (_pos >= _size)
+ return S_OK;
+
+ {
+ const UInt64 rem = _size - _pos;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ while (size != 0)
+ {
+ const UInt64 cacheTag = _pos >> _blockSizeLog;
+ const size_t cacheIndex = (size_t)cacheTag & (((size_t)1 << _numBlocksLog) - 1);
+ Byte *p = _data + (cacheIndex << _blockSizeLog);
+
+ if (_tags[cacheIndex] != cacheTag)
+ {
+ _tags[cacheIndex] = kEmptyTag;
+ const UInt64 remInBlock = _size - (cacheTag << _blockSizeLog);
+ size_t blockSize = (size_t)1 << _blockSizeLog;
+ if (blockSize > remInBlock)
+ blockSize = (size_t)remInBlock;
+
+ RINOK(ReadBlock(cacheTag, p, blockSize))
+
+ _tags[cacheIndex] = cacheTag;
+ }
+
+ const size_t kBlockSize = (size_t)1 << _blockSizeLog;
+ const size_t offset = (size_t)_pos & (kBlockSize - 1);
+ UInt32 cur = size;
+ const size_t rem = kBlockSize - offset;
+ if (cur > rem)
+ cur = (UInt32)rem;
+
+ memcpy(data, p + offset, cur);
+
+ if (processedSize)
+ *processedSize += cur;
+ data = (void *)((const Byte *)data + cur);
+ _pos += cur;
+ size -= cur;
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ switch (seekOrigin)
+ {
+ case STREAM_SEEK_SET: break;
+ case STREAM_SEEK_CUR: offset += _pos; break;
+ case STREAM_SEEK_END: offset += _size; break;
+ default: return STG_E_INVALIDFUNCTION;
+ }
+ if (offset < 0)
+ return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+ _pos = (UInt64)offset;
+ if (newPosition)
+ *newPosition = (UInt64)offset;
+ return S_OK;
+}
diff --git a/CPP/7zip/Common/StreamObjects.h b/CPP/7zip/Common/StreamObjects.h
index c3e0837..2c0ebea 100644
--- a/CPP/7zip/Common/StreamObjects.h
+++ b/CPP/7zip/Common/StreamObjects.h
@@ -1,157 +1,146 @@
-// StreamObjects.h
-
-#ifndef __STREAM_OBJECTS_H
-#define __STREAM_OBJECTS_H
-
-#include "../../Common/MyBuffer.h"
-#include "../../Common/MyCom.h"
-#include "../../Common/MyVector.h"
-
-#include "../IStream.h"
-
-class CBufferInStream:
- public IInStream,
- public CMyUnknownImp
-{
- UInt64 _pos;
-public:
- CByteBuffer Buf;
- void Init() { _pos = 0; }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-};
-
-struct CReferenceBuf:
- public IUnknown,
- public CMyUnknownImp
-{
- CByteBuffer Buf;
- MY_UNKNOWN_IMP
-};
-
-class CBufInStream:
- public IInStream,
- public CMyUnknownImp
-{
- const Byte *_data;
- UInt64 _pos;
- size_t _size;
- CMyComPtr<IUnknown> _ref;
-public:
- void Init(const Byte *data, size_t size, IUnknown *ref = 0)
- {
- _data = data;
- _size = size;
- _pos = 0;
- _ref = ref;
- }
- void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.Size(), ref); }
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-};
-
-void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream);
-void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream);
-inline void Create_BufInStream_WithNewBuffer(const CByteBuffer &buf, ISequentialInStream **stream)
- { Create_BufInStream_WithNewBuffer(buf, buf.Size(), stream); }
-
-class CByteDynBuffer
-{
- size_t _capacity;
- Byte *_buf;
-public:
- CByteDynBuffer(): _capacity(0), _buf(0) {};
- // there is no copy constructor. So don't copy this object.
- ~CByteDynBuffer() { Free(); }
- void Free() throw();
- size_t GetCapacity() const { return _capacity; }
- operator Byte*() const { return _buf; }
- operator const Byte*() const { return _buf; }
- bool EnsureCapacity(size_t capacity) throw();
-};
-
-class CDynBufSeqOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CByteDynBuffer _buffer;
- size_t _size;
-public:
- CDynBufSeqOutStream(): _size(0) {}
- void Init() { _size = 0; }
- size_t GetSize() const { return _size; }
- const Byte *GetBuffer() const { return _buffer; }
- void CopyToBuffer(CByteBuffer &dest) const;
- Byte *GetBufPtrForWriting(size_t addSize);
- void UpdateSize(size_t addSize) { _size += addSize; }
-
- MY_UNKNOWN_IMP1(ISequentialOutStream)
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-class CBufPtrSeqOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- Byte *_buffer;
- size_t _size;
- size_t _pos;
-public:
- void Init(Byte *buffer, size_t size)
- {
- _buffer = buffer;
- _pos = 0;
- _size = size;
- }
- size_t GetPos() const { return _pos; }
-
- MY_UNKNOWN_IMP1(ISequentialOutStream)
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-class CSequentialOutStreamSizeCount:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
- UInt64 _size;
-public:
- void SetStream(ISequentialOutStream *stream) { _stream = stream; }
- void Init() { _size = 0; }
- UInt64 GetSize() const { return _size; }
-
- MY_UNKNOWN_IMP1(ISequentialOutStream)
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-class CCachedInStream:
- public IInStream,
- public CMyUnknownImp
-{
- UInt64 *_tags;
- Byte *_data;
- size_t _dataSize;
- unsigned _blockSizeLog;
- unsigned _numBlocksLog;
- UInt64 _size;
- UInt64 _pos;
-protected:
- virtual HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) = 0;
-public:
- CCachedInStream(): _tags(0), _data(0) {}
- virtual ~CCachedInStream() { Free(); } // the destructor must be virtual (release calls it) !!!
- void Free() throw();
- bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw();
- void Init(UInt64 size) throw();
-
- MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
-};
-
-#endif
+// StreamObjects.h
+
+#ifndef ZIP7_INC_STREAM_OBJECTS_H
+#define ZIP7_INC_STREAM_OBJECTS_H
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+
+#include "../IStream.h"
+
+Z7_CLASS_IMP_IInStream(
+ CBufferInStream
+)
+ UInt64 _pos;
+public:
+ CByteBuffer Buf;
+ void Init() { _pos = 0; }
+};
+
+
+Z7_CLASS_IMP_COM_0(
+ CReferenceBuf
+)
+public:
+ CByteBuffer Buf;
+};
+
+
+Z7_CLASS_IMP_IInStream(
+ CBufInStream
+)
+ const Byte *_data;
+ UInt64 _pos;
+ size_t _size;
+ CMyComPtr<IUnknown> _ref;
+public:
+ void Init(const Byte *data, size_t size, IUnknown *ref = NULL)
+ {
+ _data = data;
+ _size = size;
+ _pos = 0;
+ _ref = ref;
+ }
+ void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.Size(), ref); }
+
+ // Seek() is allowed here. So reading order could be changed
+ bool WasFinished() const { return _pos == _size; }
+};
+
+
+void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream);
+void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream);
+inline void Create_BufInStream_WithNewBuffer(const CByteBuffer &buf, ISequentialInStream **stream)
+ { Create_BufInStream_WithNewBuffer(buf, buf.Size(), stream); }
+
+
+class CByteDynBuffer Z7_final
+{
+ size_t _capacity;
+ Byte *_buf;
+ Z7_CLASS_NO_COPY(CByteDynBuffer)
+public:
+ CByteDynBuffer(): _capacity(0), _buf(NULL) {}
+ // there is no copy constructor. So don't copy this object.
+ ~CByteDynBuffer() { Free(); }
+ void Free() throw();
+ size_t GetCapacity() const { return _capacity; }
+ operator Byte*() const { return _buf; }
+ operator const Byte*() const { return _buf; }
+ bool EnsureCapacity(size_t capacity) throw();
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CDynBufSeqOutStream
+ , ISequentialOutStream
+)
+ CByteDynBuffer _buffer;
+ size_t _size;
+public:
+ CDynBufSeqOutStream(): _size(0) {}
+ void Init() { _size = 0; }
+ size_t GetSize() const { return _size; }
+ const Byte *GetBuffer() const { return _buffer; }
+ void CopyToBuffer(CByteBuffer &dest) const;
+ Byte *GetBufPtrForWriting(size_t addSize);
+ void UpdateSize(size_t addSize) { _size += addSize; }
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CBufPtrSeqOutStream
+ , ISequentialOutStream
+)
+ Byte *_buffer;
+ size_t _size;
+ size_t _pos;
+public:
+ void Init(Byte *buffer, size_t size)
+ {
+ _buffer = buffer;
+ _pos = 0;
+ _size = size;
+ }
+ size_t GetPos() const { return _pos; }
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CSequentialOutStreamSizeCount
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void Init() { _size = 0; }
+ UInt64 GetSize() const { return _size; }
+};
+
+
+class CCachedInStream:
+ public IInStream,
+ public CMyUnknownImp
+{
+ Z7_IFACES_IMP_UNK_2(ISequentialInStream, IInStream)
+
+ UInt64 *_tags;
+ Byte *_data;
+ size_t _dataSize;
+ unsigned _blockSizeLog;
+ unsigned _numBlocksLog;
+ UInt64 _size;
+ UInt64 _pos;
+protected:
+ virtual HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) = 0;
+public:
+ CCachedInStream(): _tags(NULL), _data(NULL) {}
+ virtual ~CCachedInStream() { Free(); } // the destructor must be virtual (Release() calls it) !!!
+ void Free() throw();
+ bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw();
+ void Init(UInt64 size) throw();
+};
+
+#endif
diff --git a/CPP/7zip/Common/StreamUtils.cpp b/CPP/7zip/Common/StreamUtils.cpp
index a79de23..24eed36 100644
--- a/CPP/7zip/Common/StreamUtils.cpp
+++ b/CPP/7zip/Common/StreamUtils.cpp
@@ -1,56 +1,101 @@
-// StreamUtils.cpp
-
-#include "StdAfx.h"
-
-#include "StreamUtils.h"
-
-static const UInt32 kBlockSize = ((UInt32)1 << 31);
-
-HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *processedSize) throw()
-{
- size_t size = *processedSize;
- *processedSize = 0;
- while (size != 0)
- {
- UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
- UInt32 processedSizeLoc;
- HRESULT res = stream->Read(data, curSize, &processedSizeLoc);
- *processedSize += processedSizeLoc;
- data = (void *)((Byte *)data + processedSizeLoc);
- size -= processedSizeLoc;
- RINOK(res);
- if (processedSizeLoc == 0)
- return S_OK;
- }
- return S_OK;
-}
-
-HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw()
-{
- size_t processedSize = size;
- RINOK(ReadStream(stream, data, &processedSize));
- return (size == processedSize) ? S_OK : S_FALSE;
-}
-
-HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw()
-{
- size_t processedSize = size;
- RINOK(ReadStream(stream, data, &processedSize));
- return (size == processedSize) ? S_OK : E_FAIL;
-}
-
-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw()
-{
- while (size != 0)
- {
- UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
- UInt32 processedSizeLoc;
- HRESULT res = stream->Write(data, curSize, &processedSizeLoc);
- data = (const void *)((const Byte *)data + processedSizeLoc);
- size -= processedSizeLoc;
- RINOK(res);
- if (processedSizeLoc == 0)
- return E_FAIL;
- }
- return S_OK;
-}
+// StreamUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyCom.h"
+
+#include "StreamUtils.h"
+
+static const UInt32 kBlockSize = ((UInt32)1 << 31);
+
+
+HRESULT InStream_SeekToBegin(IInStream *stream) throw()
+{
+ return InStream_SeekSet(stream, 0);
+}
+
+
+HRESULT InStream_AtBegin_GetSize(IInStream *stream, UInt64 &sizeRes) throw()
+{
+#ifdef _WIN32
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamGetSize,
+ streamGetSize, stream)
+ if (streamGetSize && streamGetSize->GetSize(&sizeRes) == S_OK)
+ return S_OK;
+ }
+#endif
+ const HRESULT hres = InStream_GetSize_SeekToEnd(stream, sizeRes);
+ const HRESULT hres2 = InStream_SeekToBegin(stream);
+ return hres != S_OK ? hres : hres2;
+}
+
+
+HRESULT InStream_GetPos_GetSize(IInStream *stream, UInt64 &curPosRes, UInt64 &sizeRes) throw()
+{
+ RINOK(InStream_GetPos(stream, curPosRes))
+#ifdef _WIN32
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamGetSize,
+ streamGetSize, stream)
+ if (streamGetSize && streamGetSize->GetSize(&sizeRes) == S_OK)
+ return S_OK;
+ }
+#endif
+ const HRESULT hres = InStream_GetSize_SeekToEnd(stream, sizeRes);
+ const HRESULT hres2 = InStream_SeekSet(stream, curPosRes);
+ return hres != S_OK ? hres : hres2;
+}
+
+
+
+HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *processedSize) throw()
+{
+ size_t size = *processedSize;
+ *processedSize = 0;
+ while (size != 0)
+ {
+ UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
+ UInt32 processedSizeLoc;
+ HRESULT res = stream->Read(data, curSize, &processedSizeLoc);
+ *processedSize += processedSizeLoc;
+ data = (void *)((Byte *)data + processedSizeLoc);
+ size -= processedSizeLoc;
+ RINOK(res)
+ if (processedSizeLoc == 0)
+ return S_OK;
+ }
+ return S_OK;
+}
+
+HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw()
+{
+ size_t processedSize = size;
+ RINOK(ReadStream(stream, data, &processedSize))
+ return (size == processedSize) ? S_OK : S_FALSE;
+}
+
+HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw()
+{
+ size_t processedSize = size;
+ RINOK(ReadStream(stream, data, &processedSize))
+ return (size == processedSize) ? S_OK : E_FAIL;
+}
+
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw()
+{
+ while (size != 0)
+ {
+ UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
+ UInt32 processedSizeLoc;
+ HRESULT res = stream->Write(data, curSize, &processedSizeLoc);
+ data = (const void *)((const Byte *)data + processedSizeLoc);
+ size -= processedSizeLoc;
+ RINOK(res)
+ if (processedSizeLoc == 0)
+ return E_FAIL;
+ }
+ return S_OK;
+}
diff --git a/CPP/7zip/Common/StreamUtils.h b/CPP/7zip/Common/StreamUtils.h
index 799a8b9..35a62ed 100644
--- a/CPP/7zip/Common/StreamUtils.h
+++ b/CPP/7zip/Common/StreamUtils.h
@@ -1,13 +1,31 @@
-// StreamUtils.h
-
-#ifndef __STREAM_UTILS_H
-#define __STREAM_UTILS_H
-
-#include "../IStream.h"
-
-HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *size) throw();
-HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw();
-HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw();
-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw();
-
-#endif
+// StreamUtils.h
+
+#ifndef ZIP7_INC_STREAM_UTILS_H
+#define ZIP7_INC_STREAM_UTILS_H
+
+#include "../IStream.h"
+
+inline HRESULT InStream_SeekSet(IInStream *stream, UInt64 offset) throw()
+ { return stream->Seek((Int64)offset, STREAM_SEEK_SET, NULL); }
+inline HRESULT InStream_GetPos(IInStream *stream, UInt64 &curPosRes) throw()
+ { return stream->Seek(0, STREAM_SEEK_CUR, &curPosRes); }
+inline HRESULT InStream_GetSize_SeekToEnd(IInStream *stream, UInt64 &sizeRes) throw()
+ { return stream->Seek(0, STREAM_SEEK_END, &sizeRes); }
+
+HRESULT InStream_SeekToBegin(IInStream *stream) throw();
+HRESULT InStream_AtBegin_GetSize(IInStream *stream, UInt64 &size) throw();
+HRESULT InStream_GetPos_GetSize(IInStream *stream, UInt64 &curPosRes, UInt64 &sizeRes) throw();
+
+inline HRESULT InStream_GetSize_SeekToBegin(IInStream *stream, UInt64 &sizeRes) throw()
+{
+ RINOK(InStream_SeekToBegin(stream))
+ return InStream_AtBegin_GetSize(stream, sizeRes);
+}
+
+
+HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *size) throw();
+HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw();
+HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw();
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw();
+
+#endif
diff --git a/CPP/7zip/Common/UniqBlocks.cpp b/CPP/7zip/Common/UniqBlocks.cpp
index 5baf1a4..32dc276 100644
--- a/CPP/7zip/Common/UniqBlocks.cpp
+++ b/CPP/7zip/Common/UniqBlocks.cpp
@@ -1,57 +1,57 @@
-// UniqBlocks.cpp
-
-#include "StdAfx.h"
-
-#include <string.h>
-
-#include "UniqBlocks.h"
-
-unsigned CUniqBlocks::AddUniq(const Byte *data, size_t size)
-{
- unsigned left = 0, right = Sorted.Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- unsigned index = Sorted[mid];
- const CByteBuffer &buf = Bufs[index];
- size_t sizeMid = buf.Size();
- if (size < sizeMid)
- right = mid;
- else if (size > sizeMid)
- left = mid + 1;
- else
- {
- if (size == 0)
- return index;
- int cmp = memcmp(data, buf, size);
- if (cmp == 0)
- return index;
- if (cmp < 0)
- right = mid;
- else
- left = mid + 1;
- }
- }
- unsigned index = Bufs.Size();
- Sorted.Insert(left, index);
- Bufs.AddNew().CopyFrom(data, size);
- return index;
-}
-
-UInt64 CUniqBlocks::GetTotalSizeInBytes() const
-{
- UInt64 size = 0;
- FOR_VECTOR (i, Bufs)
- size += Bufs[i].Size();
- return size;
-}
-
-void CUniqBlocks::GetReverseMap()
-{
- unsigned num = Sorted.Size();
- BufIndexToSortedIndex.ClearAndSetSize(num);
- unsigned *p = &BufIndexToSortedIndex[0];
- const unsigned *sorted = &Sorted[0];
- for (unsigned i = 0; i < num; i++)
- p[sorted[i]] = i;
-}
+// UniqBlocks.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "UniqBlocks.h"
+
+unsigned CUniqBlocks::AddUniq(const Byte *data, size_t size)
+{
+ unsigned left = 0, right = Sorted.Size();
+ while (left != right)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned index = Sorted[mid];
+ const CByteBuffer &buf = Bufs[index];
+ const size_t sizeMid = buf.Size();
+ if (size < sizeMid)
+ right = mid;
+ else if (size > sizeMid)
+ left = mid + 1;
+ else
+ {
+ if (size == 0)
+ return index;
+ const int cmp = memcmp(data, buf, size);
+ if (cmp == 0)
+ return index;
+ if (cmp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ }
+ unsigned index = Bufs.Size();
+ Sorted.Insert(left, index);
+ Bufs.AddNew().CopyFrom(data, size);
+ return index;
+}
+
+UInt64 CUniqBlocks::GetTotalSizeInBytes() const
+{
+ UInt64 size = 0;
+ FOR_VECTOR (i, Bufs)
+ size += Bufs[i].Size();
+ return size;
+}
+
+void CUniqBlocks::GetReverseMap()
+{
+ unsigned num = Sorted.Size();
+ BufIndexToSortedIndex.ClearAndSetSize(num);
+ unsigned *p = &BufIndexToSortedIndex[0];
+ const unsigned *sorted = &Sorted[0];
+ for (unsigned i = 0; i < num; i++)
+ p[sorted[i]] = i;
+}
diff --git a/CPP/7zip/Common/UniqBlocks.h b/CPP/7zip/Common/UniqBlocks.h
index d9ec17d..66c7fa2 100644
--- a/CPP/7zip/Common/UniqBlocks.h
+++ b/CPP/7zip/Common/UniqBlocks.h
@@ -1,26 +1,41 @@
-// UniqBlocks.h
-
-#ifndef __UNIQ_BLOCKS_H
-#define __UNIQ_BLOCKS_H
-
-#include "../../Common/MyTypes.h"
-#include "../../Common/MyBuffer.h"
-#include "../../Common/MyVector.h"
-
-struct CUniqBlocks
-{
- CObjectVector<CByteBuffer> Bufs;
- CUIntVector Sorted;
- CUIntVector BufIndexToSortedIndex;
-
- unsigned AddUniq(const Byte *data, size_t size);
- UInt64 GetTotalSizeInBytes() const;
- void GetReverseMap();
-
- bool IsOnlyEmpty() const
- {
- return (Bufs.Size() == 0 || Bufs.Size() == 1 && Bufs[0].Size() == 0);
- }
-};
-
-#endif
+// UniqBlocks.h
+
+#ifndef ZIP7_INC_UNIQ_BLOCKS_H
+#define ZIP7_INC_UNIQ_BLOCKS_H
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyString.h"
+
+struct C_UInt32_UString_Map
+{
+ CRecordVector<UInt32> Numbers;
+ UStringVector Strings;
+
+ void Add_UInt32(const UInt32 n)
+ {
+ Numbers.AddToUniqueSorted(n);
+ }
+ int Find(const UInt32 n)
+ {
+ return Numbers.FindInSorted(n);
+ }
+};
+
+
+struct CUniqBlocks
+{
+ CObjectVector<CByteBuffer> Bufs;
+ CUIntVector Sorted;
+ CUIntVector BufIndexToSortedIndex;
+
+ unsigned AddUniq(const Byte *data, size_t size);
+ UInt64 GetTotalSizeInBytes() const;
+ void GetReverseMap();
+
+ bool IsOnlyEmpty() const
+ {
+ return (Bufs.Size() == 0 || (Bufs.Size() == 1 && Bufs[0].Size() == 0));
+ }
+};
+
+#endif
diff --git a/CPP/7zip/Common/VirtThread.cpp b/CPP/7zip/Common/VirtThread.cpp
index 3cf9acd..3cf7296 100644
--- a/CPP/7zip/Common/VirtThread.cpp
+++ b/CPP/7zip/Common/VirtThread.cpp
@@ -1,48 +1,47 @@
-// VirtThread.cpp
-
-#include "StdAfx.h"
-
-#include "VirtThread.h"
-
-static THREAD_FUNC_DECL CoderThread(void *p)
-{
- for (;;)
- {
- CVirtThread *t = (CVirtThread *)p;
- t->StartEvent.Lock();
- if (t->Exit)
- return 0;
- t->Execute();
- t->FinishedEvent.Set();
- }
-}
-
-WRes CVirtThread::Create()
-{
- RINOK(StartEvent.CreateIfNotCreated());
- RINOK(FinishedEvent.CreateIfNotCreated());
- StartEvent.Reset();
- FinishedEvent.Reset();
- Exit = false;
- if (Thread.IsCreated())
- return S_OK;
- return Thread.Create(CoderThread, this);
-}
-
-void CVirtThread::Start()
-{
- Exit = false;
- StartEvent.Set();
-}
-
-void CVirtThread::WaitThreadFinish()
-{
- Exit = true;
- if (StartEvent.IsCreated())
- StartEvent.Set();
- if (Thread.IsCreated())
- {
- Thread.Wait();
- Thread.Close();
- }
-}
+// VirtThread.cpp
+
+#include "StdAfx.h"
+
+#include "VirtThread.h"
+
+static THREAD_FUNC_DECL CoderThread(void *p)
+{
+ for (;;)
+ {
+ CVirtThread *t = (CVirtThread *)p;
+ t->StartEvent.Lock();
+ if (t->Exit)
+ return THREAD_FUNC_RET_ZERO;
+ t->Execute();
+ t->FinishedEvent.Set();
+ }
+}
+
+WRes CVirtThread::Create()
+{
+ RINOK_WRes(StartEvent.CreateIfNotCreated_Reset())
+ RINOK_WRes(FinishedEvent.CreateIfNotCreated_Reset())
+ // StartEvent.Reset();
+ // FinishedEvent.Reset();
+ Exit = false;
+ if (Thread.IsCreated())
+ return S_OK;
+ return Thread.Create(CoderThread, this);
+}
+
+WRes CVirtThread::Start()
+{
+ Exit = false;
+ return StartEvent.Set();
+}
+
+void CVirtThread::WaitThreadFinish()
+{
+ Exit = true;
+ if (StartEvent.IsCreated())
+ StartEvent.Set();
+ if (Thread.IsCreated())
+ {
+ Thread.Wait_Close();
+ }
+}
diff --git a/CPP/7zip/Common/VirtThread.h b/CPP/7zip/Common/VirtThread.h
index a271103..809b356 100644
--- a/CPP/7zip/Common/VirtThread.h
+++ b/CPP/7zip/Common/VirtThread.h
@@ -1,24 +1,24 @@
-// VirtThread.h
-
-#ifndef __VIRT_THREAD_H
-#define __VIRT_THREAD_H
-
-#include "../../Windows/Synchronization.h"
-#include "../../Windows/Thread.h"
-
-struct CVirtThread
-{
- NWindows::NSynchronization::CAutoResetEvent StartEvent;
- NWindows::NSynchronization::CAutoResetEvent FinishedEvent;
- NWindows::CThread Thread;
- bool Exit;
-
- ~CVirtThread() { WaitThreadFinish(); }
- void WaitThreadFinish(); // call it in destructor of child class !
- WRes Create();
- void Start();
- virtual void Execute() = 0;
- void WaitExecuteFinish() { FinishedEvent.Lock(); }
-};
-
-#endif
+// VirtThread.h
+
+#ifndef ZIP7_INC_VIRT_THREAD_H
+#define ZIP7_INC_VIRT_THREAD_H
+
+#include "../../Windows/Synchronization.h"
+#include "../../Windows/Thread.h"
+
+struct CVirtThread
+{
+ NWindows::NSynchronization::CAutoResetEvent StartEvent;
+ NWindows::NSynchronization::CAutoResetEvent FinishedEvent;
+ NWindows::CThread Thread;
+ bool Exit;
+
+ virtual ~CVirtThread() { WaitThreadFinish(); }
+ void WaitThreadFinish(); // call it in destructor of child class !
+ WRes Create();
+ WRes Start();
+ virtual void Execute() = 0;
+ WRes WaitExecuteFinish() { return FinishedEvent.Lock(); }
+};
+
+#endif
diff --git a/CPP/7zip/Compress/BZip2Const.h b/CPP/7zip/Compress/BZip2Const.h
new file mode 100644
index 0000000..0dfcfe5
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Const.h
@@ -0,0 +1,71 @@
+// Compress/BZip2Const.h
+
+#ifndef ZIP7_INC_COMPRESS_BZIP2_CONST_H
+#define ZIP7_INC_COMPRESS_BZIP2_CONST_H
+
+namespace NCompress {
+namespace NBZip2 {
+
+const Byte kArSig0 = 'B';
+const Byte kArSig1 = 'Z';
+const Byte kArSig2 = 'h';
+const Byte kArSig3 = '0';
+
+const Byte kFinSig0 = 0x17;
+const Byte kFinSig1 = 0x72;
+const Byte kFinSig2 = 0x45;
+const Byte kFinSig3 = 0x38;
+const Byte kFinSig4 = 0x50;
+const Byte kFinSig5 = 0x90;
+
+const Byte kBlockSig0 = 0x31;
+const Byte kBlockSig1 = 0x41;
+const Byte kBlockSig2 = 0x59;
+const Byte kBlockSig3 = 0x26;
+const Byte kBlockSig4 = 0x53;
+const Byte kBlockSig5 = 0x59;
+
+const unsigned kNumOrigBits = 24;
+
+const unsigned kNumTablesBits = 3;
+const unsigned kNumTablesMin = 2;
+const unsigned kNumTablesMax = 6;
+
+const unsigned kNumLevelsBits = 5;
+
+const unsigned kMaxHuffmanLen = 20; // Check it
+
+const unsigned kMaxAlphaSize = 258;
+
+const unsigned kGroupSize = 50;
+
+const unsigned kBlockSizeMultMin = 1;
+const unsigned kBlockSizeMultMax = 9;
+
+const UInt32 kBlockSizeStep = 100000;
+const UInt32 kBlockSizeMax = kBlockSizeMultMax * kBlockSizeStep;
+
+const unsigned kNumSelectorsBits = 15;
+const UInt32 kNumSelectorsMax = (2 + (kBlockSizeMax / kGroupSize));
+
+const unsigned kRleModeRepSize = 4;
+
+/*
+The number of selectors stored in bzip2 block:
+(numSelectors <= 18001) - must work with any decoder.
+(numSelectors == 18002) - works with bzip2 1.0.6 decoder and all derived decoders.
+(numSelectors > 18002)
+ lbzip2 2.5: encoder can write up to (18001 + 7) selectors.
+
+ 7-Zip before 19.03: decoder doesn't support it.
+ 7-Zip 19.03: decoder allows 8 additional selector records for lbzip2 compatibility.
+
+ bzip2 1.0.6: decoder can overflow selector[18002] arrays. But there are another
+ arrays after selector arrays. So the compiled code works.
+ bzip2 1.0.7: decoder doesn't support it.
+ bzip2 1.0.8: decoder allows additional selector records for lbzip2 compatibility.
+*/
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/BZip2Crc.cpp b/CPP/7zip/Compress/BZip2Crc.cpp
new file mode 100644
index 0000000..9639c7b
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Crc.cpp
@@ -0,0 +1,27 @@
+// BZip2Crc.cpp
+
+#include "StdAfx.h"
+
+#include "BZip2Crc.h"
+
+UInt32 CBZip2Crc::Table[256];
+
+static const UInt32 kBZip2CrcPoly = 0x04c11db7; /* AUTODIN II, Ethernet, & FDDI */
+
+void CBZip2Crc::InitTable()
+{
+ for (UInt32 i = 0; i < 256; i++)
+ {
+ UInt32 r = (i << 24);
+ for (unsigned j = 0; j < 8; j++)
+ r = (r << 1) ^ (kBZip2CrcPoly & ((UInt32)0 - (r >> 31)));
+ Table[i] = r;
+ }
+}
+
+static
+class CBZip2CrcTableInit
+{
+public:
+ CBZip2CrcTableInit() { CBZip2Crc::InitTable(); }
+} g_BZip2CrcTableInit;
diff --git a/CPP/7zip/Compress/BZip2Crc.h b/CPP/7zip/Compress/BZip2Crc.h
new file mode 100644
index 0000000..10e147b
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Crc.h
@@ -0,0 +1,31 @@
+// BZip2Crc.h
+
+#ifndef ZIP7_INC_BZIP2_CRC_H
+#define ZIP7_INC_BZIP2_CRC_H
+
+#include "../../Common/MyTypes.h"
+
+class CBZip2Crc
+{
+ UInt32 _value;
+ static UInt32 Table[256];
+public:
+ static void InitTable();
+ CBZip2Crc(UInt32 initVal = 0xFFFFFFFF): _value(initVal) {}
+ void Init(UInt32 initVal = 0xFFFFFFFF) { _value = initVal; }
+ void UpdateByte(Byte b) { _value = Table[(_value >> 24) ^ b] ^ (_value << 8); }
+ void UpdateByte(unsigned b) { _value = Table[(_value >> 24) ^ b] ^ (_value << 8); }
+ UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; }
+};
+
+class CBZip2CombinedCrc
+{
+ UInt32 _value;
+public:
+ CBZip2CombinedCrc(): _value(0) {}
+ void Init() { _value = 0; }
+ void Update(UInt32 v) { _value = ((_value << 1) | (_value >> 31)) ^ v; }
+ UInt32 GetDigest() const { return _value ; }
+};
+
+#endif
diff --git a/CPP/7zip/Compress/BZip2Decoder.cpp b/CPP/7zip/Compress/BZip2Decoder.cpp
new file mode 100644
index 0000000..b28da5f
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Decoder.cpp
@@ -0,0 +1,1797 @@
+// BZip2Decoder.cpp
+
+#include "StdAfx.h"
+
+// #include "CopyCoder.h"
+
+/*
+#include <stdio.h>
+#include "../../../C/CpuTicks.h"
+*/
+#define TICKS_START
+#define TICKS_UPDATE(n)
+
+
+/*
+#define PRIN(s) printf(s "\n"); fflush(stdout);
+#define PRIN_VAL(s, val) printf(s " = %u \n", val); fflush(stdout);
+*/
+
+#define PRIN(s)
+#define PRIN_VAL(s, val)
+
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "BZip2Decoder.h"
+
+
+namespace NCompress {
+namespace NBZip2 {
+
+// #undef NO_INLINE
+#define NO_INLINE Z7_NO_INLINE
+
+#define BZIP2_BYTE_MODE
+
+
+static const UInt32 kInBufSize = (UInt32)1 << 17;
+static const size_t kOutBufSize = (size_t)1 << 20;
+
+static const UInt32 kProgressStep = (UInt32)1 << 16;
+
+
+static const UInt16 kRandNums[512] = {
+ 619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
+ 985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
+ 733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
+ 419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
+ 878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
+ 862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
+ 150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
+ 170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
+ 73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
+ 909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
+ 641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
+ 161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
+ 382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
+ 98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
+ 227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
+ 469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
+ 184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
+ 715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
+ 951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
+ 652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
+ 645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
+ 609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
+ 653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
+ 411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
+ 170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
+ 857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
+ 669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
+ 944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
+ 344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
+ 897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
+ 433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
+ 686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
+ 946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
+ 978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
+ 680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
+ 707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
+ 297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
+ 134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
+ 343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
+ 140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
+ 170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
+ 369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
+ 804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
+ 896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
+ 661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
+ 768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
+ 61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
+ 372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
+ 780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
+ 920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
+ 645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
+ 936, 638
+};
+
+
+
+enum EState
+{
+ STATE_STREAM_SIGNATURE,
+ STATE_BLOCK_SIGNATURE,
+
+ STATE_BLOCK_START,
+ STATE_ORIG_BITS,
+ STATE_IN_USE,
+ STATE_IN_USE2,
+ STATE_NUM_TABLES,
+ STATE_NUM_SELECTORS,
+ STATE_SELECTORS,
+ STATE_LEVELS,
+
+ STATE_BLOCK_SYMBOLS,
+
+ STATE_STREAM_FINISHED
+};
+
+
+#define UPDATE_VAL_2(val) { \
+ val |= (UInt32)(*_buf) << (24 - _numBits); \
+ _numBits += 8; \
+ _buf++; \
+}
+
+#define UPDATE_VAL UPDATE_VAL_2(VAL)
+
+#define READ_BITS(res, num) { \
+ while (_numBits < num) { \
+ if (_buf == _lim) return SZ_OK; \
+ UPDATE_VAL_2(_value) } \
+ res = _value >> (32 - num); \
+ _value <<= num; \
+ _numBits -= num; \
+}
+
+#define READ_BITS_8(res, num) { \
+ if (_numBits < num) { \
+ if (_buf == _lim) return SZ_OK; \
+ UPDATE_VAL_2(_value) } \
+ res = _value >> (32 - num); \
+ _value <<= num; \
+ _numBits -= num; \
+}
+
+#define READ_BIT(res) READ_BITS_8(res, 1)
+
+
+
+#define VAL _value2
+#define BLOCK_SIZE blockSize2
+#define RUN_COUNTER runCounter2
+
+#define LOAD_LOCAL \
+ UInt32 VAL = this->_value; \
+ UInt32 BLOCK_SIZE = this->blockSize; \
+ UInt32 RUN_COUNTER = this->runCounter; \
+
+#define SAVE_LOCAL \
+ this->_value = VAL; \
+ this->blockSize = BLOCK_SIZE; \
+ this->runCounter = RUN_COUNTER; \
+
+
+
+SRes CBitDecoder::ReadByte(int &b)
+{
+ b = -1;
+ READ_BITS_8(b, 8)
+ return SZ_OK;
+}
+
+
+NO_INLINE
+SRes CBase::ReadStreamSignature2()
+{
+ for (;;)
+ {
+ unsigned b;
+ READ_BITS_8(b, 8)
+
+ if ( (state2 == 0 && b != kArSig0)
+ || (state2 == 1 && b != kArSig1)
+ || (state2 == 2 && b != kArSig2)
+ || (state2 == 3 && (b <= kArSig3 || b > kArSig3 + kBlockSizeMultMax)))
+ return SZ_ERROR_DATA;
+ state2++;
+
+ if (state2 == 4)
+ {
+ blockSizeMax = (UInt32)(b - kArSig3) * kBlockSizeStep;
+ CombinedCrc.Init();
+ state = STATE_BLOCK_SIGNATURE;
+ state2 = 0;
+ return SZ_OK;
+ }
+ }
+}
+
+
+bool IsEndSig(const Byte *p) throw()
+{
+ return
+ p[0] == kFinSig0 &&
+ p[1] == kFinSig1 &&
+ p[2] == kFinSig2 &&
+ p[3] == kFinSig3 &&
+ p[4] == kFinSig4 &&
+ p[5] == kFinSig5;
+}
+
+bool IsBlockSig(const Byte *p) throw()
+{
+ return
+ p[0] == kBlockSig0 &&
+ p[1] == kBlockSig1 &&
+ p[2] == kBlockSig2 &&
+ p[3] == kBlockSig3 &&
+ p[4] == kBlockSig4 &&
+ p[5] == kBlockSig5;
+}
+
+
+NO_INLINE
+SRes CBase::ReadBlockSignature2()
+{
+ while (state2 < 10)
+ {
+ unsigned b;
+ READ_BITS_8(b, 8)
+ temp[state2] = (Byte)b;
+ state2++;
+ }
+
+ crc = 0;
+ for (unsigned i = 0; i < 4; i++)
+ {
+ crc <<= 8;
+ crc |= temp[6 + i];
+ }
+
+ if (IsBlockSig(temp))
+ {
+ if (!IsBz)
+ NumStreams++;
+ NumBlocks++;
+ IsBz = true;
+ CombinedCrc.Update(crc);
+ state = STATE_BLOCK_START;
+ return SZ_OK;
+ }
+
+ if (!IsEndSig(temp))
+ return SZ_ERROR_DATA;
+
+ if (!IsBz)
+ NumStreams++;
+ IsBz = true;
+
+ if (_value != 0)
+ MinorError = true;
+
+ AlignToByte();
+
+ state = STATE_STREAM_FINISHED;
+ if (crc != CombinedCrc.GetDigest())
+ {
+ StreamCrcError = true;
+ return SZ_ERROR_DATA;
+ }
+ return SZ_OK;
+}
+
+
+NO_INLINE
+SRes CBase::ReadBlock2()
+{
+ if (state != STATE_BLOCK_SYMBOLS) {
+ PRIN("ReadBlock2")
+
+ if (state == STATE_BLOCK_START)
+ {
+ if (Props.randMode)
+ {
+ READ_BIT(Props.randMode)
+ }
+ state = STATE_ORIG_BITS;
+ // g_Tick = GetCpuTicks();
+ }
+
+ if (state == STATE_ORIG_BITS)
+ {
+ READ_BITS(Props.origPtr, kNumOrigBits)
+ if (Props.origPtr >= blockSizeMax)
+ return SZ_ERROR_DATA;
+ state = STATE_IN_USE;
+ }
+
+ // why original code compares origPtr to (UInt32)(10 + blockSizeMax)) ?
+
+ if (state == STATE_IN_USE)
+ {
+ READ_BITS(state2, 16)
+ state = STATE_IN_USE2;
+ state3 = 0;
+ numInUse = 0;
+ mtf.StartInit();
+ }
+
+ if (state == STATE_IN_USE2)
+ {
+ for (; state3 < 256; state3++)
+ if (state2 & ((UInt32)0x8000 >> (state3 >> 4)))
+ {
+ unsigned b;
+ READ_BIT(b)
+ if (b)
+ mtf.Add(numInUse++, (Byte)state3);
+ }
+ if (numInUse == 0)
+ return SZ_ERROR_DATA;
+ state = STATE_NUM_TABLES;
+ }
+
+
+ if (state == STATE_NUM_TABLES)
+ {
+ READ_BITS_8(numTables, kNumTablesBits)
+ state = STATE_NUM_SELECTORS;
+ if (numTables < kNumTablesMin || numTables > kNumTablesMax)
+ return SZ_ERROR_DATA;
+ }
+
+ if (state == STATE_NUM_SELECTORS)
+ {
+ READ_BITS(numSelectors, kNumSelectorsBits)
+ state = STATE_SELECTORS;
+ state2 = 0x543210;
+ state3 = 0;
+ state4 = 0;
+ // lbzip2 can write small number of additional selectors,
+ // 20.01: we allow big number of selectors here like bzip2-1.0.8
+ if (numSelectors == 0
+ // || numSelectors > kNumSelectorsMax_Decoder
+ )
+ return SZ_ERROR_DATA;
+ }
+
+ if (state == STATE_SELECTORS)
+ {
+ const unsigned kMtfBits = 4;
+ const UInt32 kMtfMask = (1 << kMtfBits) - 1;
+ do
+ {
+ for (;;)
+ {
+ unsigned b;
+ READ_BIT(b)
+ if (!b)
+ break;
+ if (++state4 >= numTables)
+ return SZ_ERROR_DATA;
+ }
+ UInt32 tmp = (state2 >> (kMtfBits * state4)) & kMtfMask;
+ UInt32 mask = ((UInt32)1 << ((state4 + 1) * kMtfBits)) - 1;
+ state4 = 0;
+ state2 = ((state2 << kMtfBits) & mask) | (state2 & ~mask) | tmp;
+ // 20.01: here we keep compatibility with bzip2-1.0.8 decoder:
+ if (state3 < kNumSelectorsMax)
+ selectors[state3] = (Byte)tmp;
+ }
+ while (++state3 < numSelectors);
+
+ // we allowed additional dummy selector records filled above to support lbzip2's archives.
+ // but we still don't allow to use these additional dummy selectors in the code bellow
+ // bzip2 1.0.8 decoder also has similar restriction.
+
+ if (numSelectors > kNumSelectorsMax)
+ numSelectors = kNumSelectorsMax;
+
+ state = STATE_LEVELS;
+ state2 = 0;
+ state3 = 0;
+ }
+
+ if (state == STATE_LEVELS)
+ {
+ do
+ {
+ if (state3 == 0)
+ {
+ READ_BITS_8(state3, kNumLevelsBits)
+ state4 = 0;
+ state5 = 0;
+ }
+ const unsigned alphaSize = numInUse + 2;
+ for (; state4 < alphaSize; state4++)
+ {
+ for (;;)
+ {
+ if (state3 < 1 || state3 > kMaxHuffmanLen)
+ return SZ_ERROR_DATA;
+
+ if (state5 == 0)
+ {
+ unsigned b;
+ READ_BIT(b)
+ if (!b)
+ break;
+ }
+
+ state5 = 1;
+ unsigned b;
+ READ_BIT(b)
+
+ state5 = 0;
+ state3++;
+ state3 -= (b << 1);
+ }
+ lens[state4] = (Byte)state3;
+ state5 = 0;
+ }
+
+ // 19.03: we use Build() instead of BuildFull() to support lbzip2 archives
+ // lbzip2 2.5 can produce dummy tree, where lens[i] = kMaxHuffmanLen
+ // BuildFull() returns error for such tree
+ for (unsigned i = state4; i < kMaxAlphaSize; i++)
+ lens[i] = 0;
+ if (!huffs[state2].Build(lens))
+ /*
+ if (!huffs[state2].BuildFull(lens, state4))
+ */
+ return SZ_ERROR_DATA;
+ state3 = 0;
+ }
+ while (++state2 < numTables);
+
+ {
+ UInt32 *counters = this->Counters;
+ for (unsigned i = 0; i < 256; i++)
+ counters[i] = 0;
+ }
+
+ state = STATE_BLOCK_SYMBOLS;
+
+ groupIndex = 0;
+ groupSize = kGroupSize;
+ runPower = 0;
+ runCounter = 0;
+ blockSize = 0;
+ }
+
+ if (state != STATE_BLOCK_SYMBOLS)
+ return SZ_ERROR_DATA;
+
+ // g_Ticks[3] += GetCpuTicks() - g_Tick;
+
+ }
+
+ {
+ LOAD_LOCAL
+ const CHuffmanDecoder *huff = &huffs[selectors[groupIndex]];
+
+ for (;;)
+ {
+ if (groupSize == 0)
+ {
+ if (++groupIndex >= numSelectors)
+ return SZ_ERROR_DATA;
+ huff = &huffs[selectors[groupIndex]];
+ groupSize = kGroupSize;
+ }
+
+ if (_numBits <= 8 &&
+ _buf != _lim) { UPDATE_VAL
+ if (_buf != _lim) { UPDATE_VAL
+ if (_buf != _lim) { UPDATE_VAL }}}
+
+ UInt32 sym;
+ UInt32 val = VAL >> (32 - kMaxHuffmanLen);
+ if (val >= huff->_limits[kNumTableBits])
+ {
+ if (_numBits <= kMaxHuffmanLen && _buf != _lim) { UPDATE_VAL
+ if (_numBits <= kMaxHuffmanLen && _buf != _lim) { UPDATE_VAL }}
+
+ val = VAL >> (32 - kMaxHuffmanLen);
+ unsigned len;
+ for (len = kNumTableBits + 1; val >= huff->_limits[len]; len++);
+
+ // 19.03: we use that check to support partial trees created Build() for lbzip2 archives
+ if (len > kNumBitsMax)
+ return SZ_ERROR_DATA; // that check is required, if NHuffman::Build() was used instead of BuildFull()
+
+ if (_numBits < len)
+ {
+ SAVE_LOCAL
+ return SZ_OK;
+ }
+ sym = huff->_symbols[huff->_poses[len] + ((val - huff->_limits[(size_t)len - 1]) >> (kNumBitsMax - len))];
+ VAL <<= len;
+ _numBits -= len;
+ }
+ else
+ {
+ sym = huff->_lens[val >> (kMaxHuffmanLen - kNumTableBits)];
+ unsigned len = (sym & NHuffman::kPairLenMask);
+ sym >>= NHuffman::kNumPairLenBits;
+ if (_numBits < len)
+ {
+ SAVE_LOCAL
+ return SZ_OK;
+ }
+ VAL <<= len;
+ _numBits -= len;
+ }
+
+ groupSize--;
+
+ if (sym < 2)
+ {
+ RUN_COUNTER += ((UInt32)(sym + 1) << runPower);
+ runPower++;
+ if (blockSizeMax - BLOCK_SIZE < RUN_COUNTER)
+ return SZ_ERROR_DATA;
+ continue;
+ }
+
+ UInt32 *counters = this->Counters;
+ if (RUN_COUNTER != 0)
+ {
+ UInt32 b = (UInt32)(mtf.Buf[0] & 0xFF);
+ counters[b] += RUN_COUNTER;
+ runPower = 0;
+ #ifdef BZIP2_BYTE_MODE
+ Byte *dest = (Byte *)(&counters[256 + kBlockSizeMax]) + BLOCK_SIZE;
+ const Byte *limit = dest + RUN_COUNTER;
+ BLOCK_SIZE += RUN_COUNTER;
+ RUN_COUNTER = 0;
+ do
+ {
+ dest[0] = (Byte)b;
+ dest[1] = (Byte)b;
+ dest[2] = (Byte)b;
+ dest[3] = (Byte)b;
+ dest += 4;
+ }
+ while (dest < limit);
+ #else
+ UInt32 *dest = &counters[256 + BLOCK_SIZE];
+ const UInt32 *limit = dest + RUN_COUNTER;
+ BLOCK_SIZE += RUN_COUNTER;
+ RUN_COUNTER = 0;
+ do
+ {
+ dest[0] = b;
+ dest[1] = b;
+ dest[2] = b;
+ dest[3] = b;
+ dest += 4;
+ }
+ while (dest < limit);
+ #endif
+ }
+
+ sym -= 1;
+ if (sym < numInUse)
+ {
+ if (BLOCK_SIZE >= blockSizeMax)
+ return SZ_ERROR_DATA;
+
+ // UInt32 b = (UInt32)mtf.GetAndMove((unsigned)sym);
+
+ const unsigned lim = sym >> Z7_MTF_MOVS;
+ const unsigned pos = (sym & Z7_MTF_MASK) << 3;
+ CMtfVar next = mtf.Buf[lim];
+ CMtfVar prev = (next >> pos) & 0xFF;
+
+ #ifdef BZIP2_BYTE_MODE
+ ((Byte *)(counters + 256 + kBlockSizeMax))[BLOCK_SIZE++] = (Byte)prev;
+ #else
+ (counters + 256)[BLOCK_SIZE++] = (UInt32)prev;
+ #endif
+ counters[prev]++;
+
+ CMtfVar *m = mtf.Buf;
+ CMtfVar *mLim = m + lim;
+ if (lim != 0)
+ {
+ do
+ {
+ CMtfVar n0 = *m;
+ *m = (n0 << 8) | prev;
+ prev = (n0 >> (Z7_MTF_MASK << 3));
+ }
+ while (++m != mLim);
+ }
+
+ CMtfVar mask = (((CMtfVar)0x100 << pos) - 1);
+ *mLim = (next & ~mask) | (((next << 8) | prev) & mask);
+ continue;
+ }
+
+ if (sym != numInUse)
+ return SZ_ERROR_DATA;
+ break;
+ }
+
+ // we write additional item that will be read in DecodeBlock1 for prefetching
+ #ifdef BZIP2_BYTE_MODE
+ ((Byte *)(Counters + 256 + kBlockSizeMax))[BLOCK_SIZE] = 0;
+ #else
+ (counters + 256)[BLOCK_SIZE] = 0;
+ #endif
+
+ SAVE_LOCAL
+ Props.blockSize = blockSize;
+ state = STATE_BLOCK_SIGNATURE;
+ state2 = 0;
+
+ PRIN_VAL("origPtr", Props.origPtr);
+ PRIN_VAL("blockSize", Props.blockSize);
+
+ return (Props.origPtr < Props.blockSize) ? SZ_OK : SZ_ERROR_DATA;
+ }
+}
+
+
+NO_INLINE
+static void DecodeBlock1(UInt32 *counters, UInt32 blockSize)
+{
+ {
+ UInt32 sum = 0;
+ for (UInt32 i = 0; i < 256; i++)
+ {
+ const UInt32 v = counters[i];
+ counters[i] = sum;
+ sum += v;
+ }
+ }
+
+ UInt32 *tt = counters + 256;
+ // Compute the T^(-1) vector
+
+ // blockSize--;
+
+ #ifdef BZIP2_BYTE_MODE
+
+ unsigned c = ((const Byte *)(tt + kBlockSizeMax))[0];
+
+ for (UInt32 i = 0; i < blockSize; i++)
+ {
+ unsigned c1 = c;
+ const UInt32 pos = counters[c];
+ c = ((const Byte *)(tt + kBlockSizeMax))[(size_t)i + 1];
+ counters[c1] = pos + 1;
+ tt[pos] = (i << 8) | ((const Byte *)(tt + kBlockSizeMax))[pos];
+ }
+
+ /*
+ // last iteration without next character prefetching
+ {
+ const UInt32 pos = counters[c];
+ counters[c] = pos + 1;
+ tt[pos] = (blockSize << 8) | ((const Byte *)(tt + kBlockSizeMax))[pos];
+ }
+ */
+
+ #else
+
+ unsigned c = (unsigned)(tt[0] & 0xFF);
+
+ for (UInt32 i = 0; i < blockSize; i++)
+ {
+ unsigned c1 = c;
+ const UInt32 pos = counters[c];
+ c = (unsigned)(tt[(size_t)i + 1] & 0xFF);
+ counters[c1] = pos + 1;
+ tt[pos] |= (i << 8);
+ }
+
+ /*
+ {
+ const UInt32 pos = counters[c];
+ counters[c] = pos + 1;
+ tt[pos] |= (blockSize << 8);
+ }
+ */
+
+ #endif
+
+
+ /*
+ for (UInt32 i = 0; i < blockSize; i++)
+ {
+ #ifdef BZIP2_BYTE_MODE
+ const unsigned c = ((const Byte *)(tt + kBlockSizeMax))[i];
+ const UInt32 pos = counters[c]++;
+ tt[pos] = (i << 8) | ((const Byte *)(tt + kBlockSizeMax))[pos];
+ #else
+ const unsigned c = (unsigned)(tt[i] & 0xFF);
+ const UInt32 pos = counters[c]++;
+ tt[pos] |= (i << 8);
+ #endif
+ }
+ */
+}
+
+
+void CSpecState::Init(UInt32 origPtr, unsigned randMode) throw()
+{
+ _tPos = _tt[_tt[origPtr] >> 8];
+ _prevByte = (unsigned)(_tPos & 0xFF);
+ _reps = 0;
+ _randIndex = 0;
+ _randToGo = -1;
+ if (randMode)
+ {
+ _randIndex = 1;
+ _randToGo = kRandNums[0] - 2;
+ }
+ _crc.Init();
+}
+
+
+
+NO_INLINE
+Byte * CSpecState::Decode(Byte *data, size_t size) throw()
+{
+ if (size == 0)
+ return data;
+
+ unsigned prevByte = _prevByte;
+ int reps = _reps;
+ CBZip2Crc crc = _crc;
+ const Byte *lim = data + size;
+
+ while (reps > 0)
+ {
+ reps--;
+ *data++ = (Byte)prevByte;
+ crc.UpdateByte(prevByte);
+ if (data == lim)
+ break;
+ }
+
+ UInt32 tPos = _tPos;
+ UInt32 blockSize = _blockSize;
+ const UInt32 *tt = _tt;
+
+ if (data != lim && blockSize)
+
+ for (;;)
+ {
+ unsigned b = (unsigned)(tPos & 0xFF);
+ tPos = tt[tPos >> 8];
+ blockSize--;
+
+ if (_randToGo >= 0)
+ {
+ if (_randToGo == 0)
+ {
+ b ^= 1;
+ _randToGo = kRandNums[_randIndex];
+ _randIndex++;
+ _randIndex &= 0x1FF;
+ }
+ _randToGo--;
+ }
+
+ if (reps != -(int)kRleModeRepSize)
+ {
+ if (b != prevByte)
+ reps = 0;
+ reps--;
+ prevByte = b;
+ *data++ = (Byte)b;
+ crc.UpdateByte(b);
+ if (data == lim || blockSize == 0)
+ break;
+ continue;
+ }
+
+ reps = (int)b;
+ while (reps)
+ {
+ reps--;
+ *data++ = (Byte)prevByte;
+ crc.UpdateByte(prevByte);
+ if (data == lim)
+ break;
+ }
+ if (data == lim)
+ break;
+ if (blockSize == 0)
+ break;
+ }
+
+ if (blockSize == 1 && reps == -(int)kRleModeRepSize)
+ {
+ unsigned b = (unsigned)(tPos & 0xFF);
+ tPos = tt[tPos >> 8];
+ blockSize--;
+
+ if (_randToGo >= 0)
+ {
+ if (_randToGo == 0)
+ {
+ b ^= 1;
+ _randToGo = kRandNums[_randIndex];
+ _randIndex++;
+ _randIndex &= 0x1FF;
+ }
+ _randToGo--;
+ }
+
+ reps = (int)b;
+ }
+
+ _tPos = tPos;
+ _prevByte = prevByte;
+ _reps = reps;
+ _crc = crc;
+ _blockSize = blockSize;
+
+ return data;
+}
+
+
+HRESULT CDecoder::Flush()
+{
+ if (_writeRes == S_OK)
+ {
+ _writeRes = WriteStream(_outStream, _outBuf, _outPos);
+ _outWritten += _outPos;
+ _outPos = 0;
+ }
+ return _writeRes;
+}
+
+
+NO_INLINE
+HRESULT CDecoder::DecodeBlock(const CBlockProps &props)
+{
+ _calcedBlockCrc = 0;
+ _blockFinished = false;
+
+ CSpecState block;
+
+ block._blockSize = props.blockSize;
+ block._tt = _counters + 256;
+
+ block.Init(props.origPtr, props.randMode);
+
+ for (;;)
+ {
+ Byte *data = _outBuf + _outPos;
+ size_t size = kOutBufSize - _outPos;
+
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _outPosTotal;
+ if (size >= rem)
+ {
+ size = (size_t)rem;
+ if (size == 0)
+ return FinishMode ? S_FALSE : S_OK;
+ }
+ }
+
+ TICKS_START
+ const size_t processed = (size_t)(block.Decode(data, size) - data);
+ TICKS_UPDATE(2)
+
+ _outPosTotal += processed;
+ _outPos += processed;
+
+ if (processed >= size)
+ {
+ RINOK(Flush())
+ }
+
+ if (block.Finished())
+ {
+ _blockFinished = true;
+ _calcedBlockCrc = block._crc.GetDigest();
+ return S_OK;
+ }
+ }
+}
+
+
+CDecoder::CDecoder():
+ _outBuf(NULL),
+ FinishMode(false),
+ _outSizeDefined(false),
+ _counters(NULL),
+ _inBuf(NULL),
+ _inProcessed(0)
+{
+ #ifndef Z7_ST
+ MtMode = false;
+ NeedWaitScout = false;
+ // ScoutRes = S_OK;
+ #endif
+}
+
+
+CDecoder::~CDecoder()
+{
+ PRIN("\n~CDecoder()");
+
+ #ifndef Z7_ST
+
+ if (Thread.IsCreated())
+ {
+ WaitScout();
+
+ _block.StopScout = true;
+
+ PRIN("\nScoutEvent.Set()");
+ ScoutEvent.Set();
+
+ PRIN("\nThread.Wait()()");
+ Thread.Wait_Close();
+ PRIN("\n after Thread.Wait()()");
+
+ // if (ScoutRes != S_OK) throw ScoutRes;
+ }
+
+ #endif
+
+ BigFree(_counters);
+ MidFree(_outBuf);
+ MidFree(_inBuf);
+}
+
+
+HRESULT CDecoder::ReadInput()
+{
+ if (Base._buf != Base._lim || _inputFinished || _inputRes != S_OK)
+ return _inputRes;
+
+ _inProcessed += (size_t)(Base._buf - _inBuf);
+ Base._buf = _inBuf;
+ Base._lim = _inBuf;
+ UInt32 size = 0;
+ _inputRes = Base.InStream->Read(_inBuf, kInBufSize, &size);
+ _inputFinished = (size == 0);
+ Base._lim = _inBuf + size;
+ return _inputRes;
+}
+
+
+void CDecoder::StartNewStream()
+{
+ Base.state = STATE_STREAM_SIGNATURE;
+ Base.state2 = 0;
+ Base.IsBz = false;
+}
+
+
+HRESULT CDecoder::ReadStreamSignature()
+{
+ for (;;)
+ {
+ RINOK(ReadInput())
+ SRes res = Base.ReadStreamSignature2();
+ if (res != SZ_OK)
+ return S_FALSE;
+ if (Base.state == STATE_BLOCK_SIGNATURE)
+ return S_OK;
+ if (_inputFinished)
+ {
+ Base.NeedMoreInput = true;
+ return S_FALSE;
+ }
+ }
+}
+
+
+HRESULT CDecoder::StartRead()
+{
+ StartNewStream();
+ return ReadStreamSignature();
+}
+
+
+HRESULT CDecoder::ReadBlockSignature()
+{
+ for (;;)
+ {
+ RINOK(ReadInput())
+
+ SRes res = Base.ReadBlockSignature2();
+
+ if (Base.state == STATE_STREAM_FINISHED)
+ Base.FinishedPackSize = GetInputProcessedSize();
+ if (res != SZ_OK)
+ return S_FALSE;
+ if (Base.state != STATE_BLOCK_SIGNATURE)
+ return S_OK;
+ if (_inputFinished)
+ {
+ Base.NeedMoreInput = true;
+ return S_FALSE;
+ }
+ }
+}
+
+
+HRESULT CDecoder::ReadBlock()
+{
+ for (;;)
+ {
+ RINOK(ReadInput())
+
+ SRes res = Base.ReadBlock2();
+
+ if (res != SZ_OK)
+ return S_FALSE;
+ if (Base.state == STATE_BLOCK_SIGNATURE)
+ return S_OK;
+ if (_inputFinished)
+ {
+ Base.NeedMoreInput = true;
+ return S_FALSE;
+ }
+ }
+}
+
+
+
+HRESULT CDecoder::DecodeStreams(ICompressProgressInfo *progress)
+{
+ {
+ #ifndef Z7_ST
+ _block.StopScout = false;
+ #endif
+ }
+
+ RINOK(StartRead())
+
+ UInt64 inPrev = 0;
+ UInt64 outPrev = 0;
+
+ {
+ #ifndef Z7_ST
+ CWaitScout_Releaser waitScout_Releaser(this);
+
+ bool useMt = false;
+ #endif
+
+ bool wasFinished = false;
+
+ UInt32 crc = 0;
+ UInt32 nextCrc = 0;
+ HRESULT nextRes = S_OK;
+
+ UInt64 packPos = 0;
+
+ CBlockProps props;
+
+ props.blockSize = 0;
+
+ for (;;)
+ {
+ if (progress)
+ {
+ const UInt64 outCur = GetOutProcessedSize();
+ if (packPos - inPrev >= kProgressStep || outCur - outPrev >= kProgressStep)
+ {
+ RINOK(progress->SetRatioInfo(&packPos, &outCur))
+ inPrev = packPos;
+ outPrev = outCur;
+ }
+ }
+
+ if (props.blockSize == 0)
+ if (wasFinished || nextRes != S_OK)
+ return nextRes;
+
+ if (
+ #ifndef Z7_ST
+ !useMt &&
+ #endif
+ !wasFinished && Base.state == STATE_BLOCK_SIGNATURE)
+ {
+ nextRes = ReadBlockSignature();
+ nextCrc = Base.crc;
+ packPos = GetInputProcessedSize();
+
+ wasFinished = true;
+
+ if (nextRes != S_OK)
+ continue;
+
+ if (Base.state == STATE_STREAM_FINISHED)
+ {
+ if (!Base.DecodeAllStreams)
+ {
+ wasFinished = true;
+ continue;
+ }
+
+ nextRes = StartRead();
+
+ if (Base.NeedMoreInput)
+ {
+ if (Base.state2 == 0)
+ Base.NeedMoreInput = false;
+ wasFinished = true;
+ nextRes = S_OK;
+ continue;
+ }
+
+ if (nextRes != S_OK)
+ continue;
+
+ wasFinished = false;
+ continue;
+ }
+
+ wasFinished = false;
+
+ #ifndef Z7_ST
+ if (MtMode)
+ if (props.blockSize != 0)
+ {
+ // we start multithreading, if next block is big enough.
+ const UInt32 k_Mt_BlockSize_Threshold = (1 << 12); // (1 << 13)
+ if (props.blockSize > k_Mt_BlockSize_Threshold)
+ {
+ if (!Thread.IsCreated())
+ {
+ PRIN("=== MT_MODE");
+ RINOK(CreateThread())
+ }
+ useMt = true;
+ }
+ }
+ #endif
+ }
+
+ if (props.blockSize == 0)
+ {
+ crc = nextCrc;
+
+ #ifndef Z7_ST
+ if (useMt)
+ {
+ PRIN("DecoderEvent.Lock()");
+ {
+ WRes wres = DecoderEvent.Lock();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ NeedWaitScout = false;
+ PRIN("-- DecoderEvent.Lock()");
+ props = _block.Props;
+ nextCrc = _block.NextCrc;
+ if (_block.Crc_Defined)
+ crc = _block.Crc;
+ packPos = _block.PackPos;
+ wasFinished = _block.WasFinished;
+ RINOK(_block.Res)
+ }
+ else
+ #endif
+ {
+ if (Base.state != STATE_BLOCK_START)
+ return E_FAIL;
+
+ TICKS_START
+ Base.Props.randMode = 1;
+ RINOK(ReadBlock())
+ TICKS_UPDATE(0)
+
+ props = Base.Props;
+ continue;
+ }
+ }
+
+ if (props.blockSize != 0)
+ {
+ TICKS_START
+ DecodeBlock1(_counters, props.blockSize);
+ TICKS_UPDATE(1)
+ }
+
+ #ifndef Z7_ST
+ if (useMt && !wasFinished)
+ {
+ /*
+ if (props.blockSize == 0)
+ {
+ // this codes switches back to single-threadMode
+ useMt = false;
+ PRIN("=== ST_MODE");
+ continue;
+ }
+ */
+
+ PRIN("ScoutEvent.Set()");
+ {
+ WRes wres = ScoutEvent.Set();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ NeedWaitScout = true;
+ }
+ #endif
+
+ if (props.blockSize == 0)
+ continue;
+
+ RINOK(DecodeBlock(props))
+
+ if (!_blockFinished)
+ return nextRes;
+
+ props.blockSize = 0;
+ if (_calcedBlockCrc != crc)
+ {
+ BlockCrcError = true;
+ return S_FALSE;
+ }
+ }
+ }
+}
+
+
+
+
+bool CDecoder::CreateInputBufer()
+{
+ if (!_inBuf)
+ {
+ _inBuf = (Byte *)MidAlloc(kInBufSize);
+ if (!_inBuf)
+ return false;
+ Base._buf = _inBuf;
+ Base._lim = _inBuf;
+ }
+ if (!_counters)
+ {
+ const size_t size = (256 + kBlockSizeMax) * sizeof(UInt32)
+ #ifdef BZIP2_BYTE_MODE
+ + kBlockSizeMax
+ #endif
+ + 256;
+ _counters = (UInt32 *)::BigAlloc(size);
+ if (!_counters)
+ return false;
+ Base.Counters = _counters;
+ }
+ return true;
+}
+
+
+void CDecoder::InitOutSize(const UInt64 *outSize)
+{
+ _outPosTotal = 0;
+
+ _outSizeDefined = false;
+ _outSize = 0;
+ if (outSize)
+ {
+ _outSize = *outSize;
+ _outSizeDefined = true;
+ }
+
+ BlockCrcError = false;
+
+ Base.InitNumStreams2();
+}
+
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ /*
+ {
+ RINOK(SetInStream(inStream));
+ RINOK(SetOutStreamSize(outSize));
+
+ RINOK(CopyStream(this, outStream, progress));
+ return ReleaseInStream();
+ }
+ */
+
+ _inputFinished = false;
+ _inputRes = S_OK;
+ _writeRes = S_OK;
+
+ try {
+
+ InitOutSize(outSize);
+
+ // we can request data from InputBuffer after Code().
+ // so we init InputBuffer before any function return.
+
+ InitInputBuffer();
+
+ if (!CreateInputBufer())
+ return E_OUTOFMEMORY;
+
+ if (!_outBuf)
+ {
+ _outBuf = (Byte *)MidAlloc(kOutBufSize);
+ if (!_outBuf)
+ return E_OUTOFMEMORY;
+ }
+
+ Base.InStream = inStream;
+
+ // InitInputBuffer();
+
+ _outStream = outStream;
+ _outWritten = 0;
+ _outPos = 0;
+
+ HRESULT res = DecodeStreams(progress);
+
+ Flush();
+
+ Base.InStream = NULL;
+ _outStream = NULL;
+
+ /*
+ if (res == S_OK)
+ if (FinishMode && inSize && *inSize != GetInputProcessedSize())
+ res = S_FALSE;
+ */
+
+ if (res != S_OK)
+ return res;
+
+ } catch(...) { return E_FAIL; }
+
+ return _writeRes;
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ FinishMode = (finishMode != 0);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = GetInStreamSize();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::ReadUnusedFromInBuf(void *data, UInt32 size, UInt32 *processedSize))
+{
+ Base.AlignToByte();
+ UInt32 i;
+ for (i = 0; i < size; i++)
+ {
+ int b;
+ Base.ReadByte(b);
+ if (b < 0)
+ break;
+ ((Byte *)data)[i] = (Byte)b;
+ }
+ if (processedSize)
+ *processedSize = i;
+ return S_OK;
+}
+
+
+#ifndef Z7_ST
+
+#define PRIN_MT(s) PRIN(" " s)
+
+// #define RINOK_THREAD(x) { WRes __result_ = (x); if (__result_ != 0) return __result_; }
+
+static THREAD_FUNC_DECL RunScout2(void *p) { ((CDecoder *)p)->RunScout(); return 0; }
+
+HRESULT CDecoder::CreateThread()
+{
+ WRes wres = DecoderEvent.CreateIfNotCreated_Reset();
+ if (wres == 0) { wres = ScoutEvent.CreateIfNotCreated_Reset();
+ if (wres == 0) { wres = Thread.Create(RunScout2, this); }}
+ return HRESULT_FROM_WIN32(wres);
+}
+
+void CDecoder::RunScout()
+{
+ for (;;)
+ {
+ {
+ PRIN_MT("ScoutEvent.Lock()")
+ WRes wres = ScoutEvent.Lock();
+ PRIN_MT("-- ScoutEvent.Lock()")
+ if (wres != 0)
+ {
+ // ScoutRes = wres;
+ return;
+ }
+ }
+
+ CBlock &block = _block;
+
+ if (block.StopScout)
+ {
+ // ScoutRes = S_OK;
+ return;
+ }
+
+ block.Res = S_OK;
+ block.WasFinished = false;
+
+ HRESULT res = S_OK;
+
+ try
+ {
+ UInt64 packPos = GetInputProcessedSize();
+
+ block.Props.blockSize = 0;
+ block.Crc_Defined = false;
+ // block.NextCrc_Defined = false;
+ block.NextCrc = 0;
+
+ for (;;)
+ {
+ if (Base.state == STATE_BLOCK_SIGNATURE)
+ {
+ res = ReadBlockSignature();
+
+ if (res != S_OK)
+ break;
+
+ if (block.Props.blockSize == 0)
+ {
+ block.Crc = Base.crc;
+ block.Crc_Defined = true;
+ }
+ else
+ {
+ block.NextCrc = Base.crc;
+ // block.NextCrc_Defined = true;
+ }
+
+ continue;
+ }
+
+ if (Base.state == STATE_BLOCK_START)
+ {
+ if (block.Props.blockSize != 0)
+ break;
+
+ Base.Props.randMode = 1;
+
+ res = ReadBlock();
+
+ PRIN_MT("-- Base.ReadBlock")
+ if (res != S_OK)
+ break;
+ block.Props = Base.Props;
+ continue;
+ }
+
+ if (Base.state == STATE_STREAM_FINISHED)
+ {
+ if (!Base.DecodeAllStreams)
+ {
+ block.WasFinished = true;
+ break;
+ }
+
+ res = StartRead();
+
+ if (Base.NeedMoreInput)
+ {
+ if (Base.state2 == 0)
+ Base.NeedMoreInput = false;
+ block.WasFinished = true;
+ res = S_OK;
+ break;
+ }
+
+ if (res != S_OK)
+ break;
+
+ if (GetInputProcessedSize() - packPos > 0) // kProgressStep
+ break;
+ continue;
+ }
+
+ // throw 1;
+ res = E_FAIL;
+ break;
+ }
+ }
+
+ catch (...) { res = E_FAIL; }
+
+ if (res != S_OK)
+ {
+ PRIN_MT("error")
+ block.Res = res;
+ block.WasFinished = true;
+ }
+
+ block.PackPos = GetInputProcessedSize();
+ PRIN_MT("DecoderEvent.Set()")
+ WRes wres = DecoderEvent.Set();
+ if (wres != 0)
+ {
+ // ScoutRes = wres;
+ return;
+ }
+ }
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetNumberOfThreads(UInt32 numThreads))
+{
+ MtMode = (numThreads > 1);
+
+ #ifndef BZIP2_BYTE_MODE
+ MtMode = false;
+ #endif
+
+ // MtMode = false;
+ return S_OK;
+}
+
+#endif
+
+
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+
+Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
+{
+ Base.InStreamRef = inStream;
+ Base.InStream = inStream;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::ReleaseInStream())
+{
+ Base.InStreamRef.Release();
+ Base.InStream = NULL;
+ return S_OK;
+}
+
+
+
+Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ InitOutSize(outSize);
+
+ InitInputBuffer();
+
+ if (!CreateInputBufer())
+ return E_OUTOFMEMORY;
+
+ // InitInputBuffer();
+
+ StartNewStream();
+
+ _blockFinished = true;
+
+ ErrorResult = S_OK;
+
+ _inputFinished = false;
+ _inputRes = S_OK;
+
+ return S_OK;
+}
+
+
+
+Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ *processedSize = 0;
+
+ try {
+
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+
+ for (;;)
+ {
+ if (Base.state == STATE_STREAM_FINISHED)
+ {
+ if (!Base.DecodeAllStreams)
+ return ErrorResult;
+ StartNewStream();
+ continue;
+ }
+
+ if (Base.state == STATE_STREAM_SIGNATURE)
+ {
+ ErrorResult = ReadStreamSignature();
+
+ if (Base.NeedMoreInput)
+ if (Base.state2 == 0 && Base.NumStreams != 0)
+ {
+ Base.NeedMoreInput = false;
+ ErrorResult = S_OK;
+ return S_OK;
+ }
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+ continue;
+ }
+
+ if (_blockFinished && Base.state == STATE_BLOCK_SIGNATURE)
+ {
+ ErrorResult = ReadBlockSignature();
+
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+
+ continue;
+ }
+
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _outPosTotal;
+ if (size >= rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+
+ if (_blockFinished)
+ {
+ if (Base.state != STATE_BLOCK_START)
+ {
+ ErrorResult = E_FAIL;
+ return ErrorResult;
+ }
+
+ Base.Props.randMode = 1;
+ ErrorResult = ReadBlock();
+
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+
+ DecodeBlock1(_counters, Base.Props.blockSize);
+
+ _spec._blockSize = Base.Props.blockSize;
+ _spec._tt = _counters + 256;
+ _spec.Init(Base.Props.origPtr, Base.Props.randMode);
+
+ _blockFinished = false;
+ }
+
+ {
+ Byte *ptr = _spec.Decode((Byte *)data, size);
+
+ const UInt32 processed = (UInt32)(ptr - (Byte *)data);
+ data = ptr;
+ size -= processed;
+ (*processedSize) += processed;
+ _outPosTotal += processed;
+
+ if (_spec.Finished())
+ {
+ _blockFinished = true;
+ if (Base.crc != _spec._crc.GetDigest())
+ {
+ BlockCrcError = true;
+ ErrorResult = S_FALSE;
+ return ErrorResult;
+ }
+ }
+ }
+ }
+
+ } catch(...) { ErrorResult = S_FALSE; return S_FALSE; }
+}
+
+
+
+// ---------- NSIS ----------
+
+Z7_COM7F_IMF(CNsisDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ *processedSize = 0;
+
+ try {
+
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+
+ if (Base.state == STATE_STREAM_FINISHED)
+ return S_OK;
+
+ if (Base.state == STATE_STREAM_SIGNATURE)
+ {
+ Base.blockSizeMax = 9 * kBlockSizeStep;
+ Base.state = STATE_BLOCK_SIGNATURE;
+ // Base.state2 = 0;
+ }
+
+ for (;;)
+ {
+ if (_blockFinished && Base.state == STATE_BLOCK_SIGNATURE)
+ {
+ ErrorResult = ReadInput();
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+
+ int b;
+ Base.ReadByte(b);
+ if (b < 0)
+ {
+ ErrorResult = S_FALSE;
+ return ErrorResult;
+ }
+
+ if (b == kFinSig0)
+ {
+ /*
+ if (!Base.AreRemainByteBitsEmpty())
+ ErrorResult = S_FALSE;
+ */
+ Base.state = STATE_STREAM_FINISHED;
+ return ErrorResult;
+ }
+
+ if (b != kBlockSig0)
+ {
+ ErrorResult = S_FALSE;
+ return ErrorResult;
+ }
+
+ Base.state = STATE_BLOCK_START;
+ }
+
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _outPosTotal;
+ if (size >= rem)
+ size = (UInt32)rem;
+ }
+ if (size == 0)
+ return S_OK;
+
+ if (_blockFinished)
+ {
+ if (Base.state != STATE_BLOCK_START)
+ {
+ ErrorResult = E_FAIL;
+ return ErrorResult;
+ }
+
+ Base.Props.randMode = 0;
+ ErrorResult = ReadBlock();
+
+ if (ErrorResult != S_OK)
+ return ErrorResult;
+
+ DecodeBlock1(_counters, Base.Props.blockSize);
+
+ _spec._blockSize = Base.Props.blockSize;
+ _spec._tt = _counters + 256;
+ _spec.Init(Base.Props.origPtr, Base.Props.randMode);
+
+ _blockFinished = false;
+ }
+
+ {
+ Byte *ptr = _spec.Decode((Byte *)data, size);
+
+ const UInt32 processed = (UInt32)(ptr - (Byte *)data);
+ data = ptr;
+ size -= processed;
+ (*processedSize) += processed;
+ _outPosTotal += processed;
+
+ if (_spec.Finished())
+ _blockFinished = true;
+ }
+ }
+
+ } catch(...) { ErrorResult = S_FALSE; return S_FALSE; }
+}
+
+#endif
+
+}}
diff --git a/CPP/7zip/Compress/BZip2Decoder.h b/CPP/7zip/Compress/BZip2Decoder.h
new file mode 100644
index 0000000..a8ef700
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Decoder.h
@@ -0,0 +1,389 @@
+// Compress/BZip2Decoder.h
+
+#ifndef ZIP7_INC_COMPRESS_BZIP2_DECODER_H
+#define ZIP7_INC_COMPRESS_BZIP2_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+// #define Z7_NO_READ_FROM_CODER
+// #define Z7_ST
+
+#ifndef Z7_ST
+#include "../../Windows/Synchronization.h"
+#include "../../Windows/Thread.h"
+#endif
+
+#include "../ICoder.h"
+
+#include "BZip2Const.h"
+#include "BZip2Crc.h"
+#include "HuffmanDecoder.h"
+#include "Mtf8.h"
+
+namespace NCompress {
+namespace NBZip2 {
+
+bool IsEndSig(const Byte *p) throw();
+bool IsBlockSig(const Byte *p) throw();
+
+const unsigned kNumTableBits = 9;
+const unsigned kNumBitsMax = kMaxHuffmanLen;
+
+typedef NHuffman::CDecoder<kMaxHuffmanLen, kMaxAlphaSize, kNumTableBits> CHuffmanDecoder;
+
+
+struct CBlockProps
+{
+ UInt32 blockSize;
+ UInt32 origPtr;
+ unsigned randMode;
+
+ CBlockProps(): blockSize(0), origPtr(0), randMode(0) {}
+};
+
+
+struct CBitDecoder
+{
+ unsigned _numBits;
+ UInt32 _value;
+ const Byte *_buf;
+ const Byte *_lim;
+
+ void InitBitDecoder()
+ {
+ _numBits = 0;
+ _value = 0;
+ }
+
+ void AlignToByte()
+ {
+ unsigned bits = _numBits & 7;
+ _numBits -= bits;
+ _value <<= bits;
+ }
+
+ /*
+ bool AreRemainByteBitsEmpty() const
+ {
+ unsigned bits = _numBits & 7;
+ if (bits != 0)
+ return (_value >> (32 - bits)) == 0;
+ return true;
+ }
+ */
+
+ SRes ReadByte(int &b);
+
+ CBitDecoder():
+ _buf(NULL),
+ _lim(NULL)
+ {
+ InitBitDecoder();
+ }
+};
+
+
+// 19.03: we allow additional 8 selectors to support files created by lbzip2.
+const UInt32 kNumSelectorsMax_Decoder = kNumSelectorsMax + 8;
+
+struct CBase: public CBitDecoder
+{
+ unsigned numInUse;
+ UInt32 groupIndex;
+ UInt32 groupSize;
+ unsigned runPower;
+ UInt32 runCounter;
+ UInt32 blockSize;
+
+ UInt32 *Counters;
+ UInt32 blockSizeMax;
+
+ unsigned state;
+ unsigned state2;
+ unsigned state3;
+ unsigned state4;
+ unsigned state5;
+ unsigned numTables;
+ UInt32 numSelectors;
+
+ CBlockProps Props;
+
+private:
+ CMtf8Decoder mtf;
+ Byte selectors[kNumSelectorsMax_Decoder];
+ CHuffmanDecoder huffs[kNumTablesMax];
+
+ Byte lens[kMaxAlphaSize];
+
+ Byte temp[10];
+
+public:
+ UInt32 crc;
+ CBZip2CombinedCrc CombinedCrc;
+
+ bool IsBz;
+ bool StreamCrcError;
+ bool MinorError;
+ bool NeedMoreInput;
+
+ bool DecodeAllStreams;
+
+ UInt64 NumStreams;
+ UInt64 NumBlocks;
+ UInt64 FinishedPackSize;
+
+ ISequentialInStream *InStream;
+
+ #ifndef Z7_NO_READ_FROM_CODER
+ CMyComPtr<ISequentialInStream> InStreamRef;
+ #endif
+
+ CBase():
+ StreamCrcError(false),
+ MinorError(false),
+ NeedMoreInput(false),
+
+ DecodeAllStreams(false),
+
+ NumStreams(0),
+ NumBlocks(0),
+ FinishedPackSize(0)
+ {}
+
+ void InitNumStreams2()
+ {
+ StreamCrcError = false;
+ MinorError = false;
+ NeedMoreInput = 0;
+ NumStreams = 0;
+ NumBlocks = 0;
+ FinishedPackSize = 0;
+ }
+
+ SRes ReadStreamSignature2();
+ SRes ReadBlockSignature2();
+
+ /* ReadBlock2() : Props->randMode:
+ in: need read randMode bit
+ out: randMode status */
+ SRes ReadBlock2();
+};
+
+
+class CSpecState
+{
+ UInt32 _tPos;
+ unsigned _prevByte;
+ int _reps;
+
+public:
+ CBZip2Crc _crc;
+ UInt32 _blockSize;
+ UInt32 *_tt;
+
+ int _randToGo;
+ unsigned _randIndex;
+
+ void Init(UInt32 origPtr, unsigned randMode) throw();
+
+ bool Finished() const { return _reps <= 0 && _blockSize == 0; }
+
+ Byte *Decode(Byte *data, size_t size) throw();
+};
+
+
+
+
+class CDecoder:
+ public ICompressCoder,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize,
+ public ICompressReadUnusedFromInBuf,
+#ifndef Z7_NO_READ_FROM_CODER
+ public ICompressSetInStream,
+ public ICompressSetOutStreamSize,
+ public ISequentialInStream,
+#endif
+#ifndef Z7_ST
+ public ICompressSetCoderMt,
+#endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ Z7_COM_QI_ENTRY(ICompressReadUnusedFromInBuf)
+#ifndef Z7_NO_READ_FROM_CODER
+ Z7_COM_QI_ENTRY(ICompressSetInStream)
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+#endif
+#ifndef Z7_ST
+ Z7_COM_QI_ENTRY(ICompressSetCoderMt)
+#endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ Z7_IFACE_COM7_IMP(ICompressReadUnusedFromInBuf)
+#ifndef Z7_NO_READ_FROM_CODER
+ Z7_IFACE_COM7_IMP(ICompressSetInStream)
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ Z7_IFACE_COM7_IMP_NONFINAL(ISequentialInStream)
+#endif
+public:
+#ifndef Z7_ST
+ Z7_IFACE_COM7_IMP(ICompressSetCoderMt)
+#endif
+
+private:
+ Byte *_outBuf;
+ size_t _outPos;
+ UInt64 _outWritten;
+ ISequentialOutStream *_outStream;
+ HRESULT _writeRes;
+
+protected:
+ HRESULT ErrorResult; // for ISequentialInStream::Read mode only
+
+public:
+
+ UInt32 _calcedBlockCrc;
+ bool _blockFinished;
+ bool BlockCrcError;
+
+ bool FinishMode;
+ bool _outSizeDefined;
+ UInt64 _outSize;
+ UInt64 _outPosTotal;
+
+ CSpecState _spec;
+ UInt32 *_counters;
+
+ #ifndef Z7_ST
+
+ struct CBlock
+ {
+ bool StopScout;
+
+ bool WasFinished;
+ bool Crc_Defined;
+ // bool NextCrc_Defined;
+
+ UInt32 Crc;
+ UInt32 NextCrc;
+ HRESULT Res;
+ UInt64 PackPos;
+
+ CBlockProps Props;
+ };
+
+ CBlock _block;
+
+ bool NeedWaitScout;
+ bool MtMode;
+
+ NWindows::CThread Thread;
+ NWindows::NSynchronization::CAutoResetEvent DecoderEvent;
+ NWindows::NSynchronization::CAutoResetEvent ScoutEvent;
+ // HRESULT ScoutRes;
+
+ Byte MtPad[1 << 7]; // It's pad for Multi-Threading. Must be >= Cache_Line_Size.
+
+
+ void RunScout();
+
+ void WaitScout()
+ {
+ if (NeedWaitScout)
+ {
+ DecoderEvent.Lock();
+ NeedWaitScout = false;
+ }
+ }
+
+ class CWaitScout_Releaser
+ {
+ CDecoder *_decoder;
+ public:
+ CWaitScout_Releaser(CDecoder *decoder): _decoder(decoder) {}
+ ~CWaitScout_Releaser() { _decoder->WaitScout(); }
+ };
+
+ HRESULT CreateThread();
+
+ #endif
+
+ Byte *_inBuf;
+ UInt64 _inProcessed;
+ bool _inputFinished;
+ HRESULT _inputRes;
+
+ CBase Base;
+
+ bool GetCrcError() const { return BlockCrcError || Base.StreamCrcError; }
+
+ void InitOutSize(const UInt64 *outSize);
+
+ bool CreateInputBufer();
+
+ void InitInputBuffer()
+ {
+ // We use InitInputBuffer() before stream init.
+ // So don't read from stream here
+ _inProcessed = 0;
+ Base._buf = _inBuf;
+ Base._lim = _inBuf;
+ Base.InitBitDecoder();
+ }
+
+ UInt64 GetInputProcessedSize() const
+ {
+ // for NSIS case : we need also look the number of bits in bitDecoder
+ return _inProcessed + (size_t)(Base._buf - _inBuf);
+ }
+
+ UInt64 GetInStreamSize() const
+ {
+ return _inProcessed + (size_t)(Base._buf - _inBuf) - (Base._numBits >> 3);
+ }
+
+ UInt64 GetOutProcessedSize() const { return _outWritten + _outPos; }
+
+ HRESULT ReadInput();
+
+ void StartNewStream();
+
+ HRESULT ReadStreamSignature();
+ HRESULT StartRead();
+
+ HRESULT ReadBlockSignature();
+ HRESULT ReadBlock();
+
+ HRESULT Flush();
+ HRESULT DecodeBlock(const CBlockProps &props);
+ HRESULT DecodeStreams(ICompressProgressInfo *progress);
+
+ UInt64 GetNumStreams() const { return Base.NumStreams; }
+ UInt64 GetNumBlocks() const { return Base.NumBlocks; }
+
+ CDecoder();
+ virtual ~CDecoder();
+};
+
+
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+class CNsisDecoder Z7_final: public CDecoder
+{
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+};
+
+#endif
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/BZip2Encoder.cpp b/CPP/7zip/Compress/BZip2Encoder.cpp
new file mode 100644
index 0000000..ef2555a
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Encoder.cpp
@@ -0,0 +1,919 @@
+// BZip2Encoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+#include "../../../C/BwtSort.h"
+#include "../../../C/HuffEnc.h"
+
+#include "BZip2Crc.h"
+#include "BZip2Encoder.h"
+#include "Mtf8.h"
+
+namespace NCompress {
+namespace NBZip2 {
+
+const unsigned kMaxHuffmanLenForEncoding = 16; // it must be < kMaxHuffmanLen = 20
+
+static const UInt32 kBufferSize = (1 << 17);
+static const unsigned kNumHuffPasses = 4;
+
+bool CThreadInfo::Alloc()
+{
+ if (!m_BlockSorterIndex)
+ {
+ m_BlockSorterIndex = (UInt32 *)::BigAlloc(BLOCK_SORT_BUF_SIZE(kBlockSizeMax) * sizeof(UInt32));
+ if (!m_BlockSorterIndex)
+ return false;
+ }
+
+ if (!m_Block)
+ {
+ m_Block = (Byte *)::MidAlloc(kBlockSizeMax * 5 + kBlockSizeMax / 10 + (20 << 10));
+ if (!m_Block)
+ return false;
+ m_MtfArray = m_Block + kBlockSizeMax;
+ m_TempArray = m_MtfArray + kBlockSizeMax * 2 + 2;
+ }
+ return true;
+}
+
+void CThreadInfo::Free()
+{
+ ::BigFree(m_BlockSorterIndex);
+ m_BlockSorterIndex = NULL;
+ ::MidFree(m_Block);
+ m_Block = NULL;
+}
+
+#ifndef Z7_ST
+
+static THREAD_FUNC_DECL MFThread(void *threadCoderInfo)
+{
+ return ((CThreadInfo *)threadCoderInfo)->ThreadFunc();
+}
+
+HRESULT CThreadInfo::Create()
+{
+ WRes wres = StreamWasFinishedEvent.Create();
+ if (wres == 0) { wres = WaitingWasStartedEvent.Create();
+ if (wres == 0) { wres = CanWriteEvent.Create();
+ if (wres == 0)
+ {
+ if (Encoder->_props.Affinity != 0)
+ wres = Thread.Create_With_Affinity(MFThread, this, (CAffinityMask)Encoder->_props.Affinity);
+ else
+ wres = Thread.Create(MFThread, this);
+ }}}
+ return HRESULT_FROM_WIN32(wres);
+}
+
+void CThreadInfo::FinishStream(bool needLeave)
+{
+ Encoder->StreamWasFinished = true;
+ StreamWasFinishedEvent.Set();
+ if (needLeave)
+ Encoder->CS.Leave();
+ Encoder->CanStartWaitingEvent.Lock();
+ WaitingWasStartedEvent.Set();
+}
+
+THREAD_FUNC_RET_TYPE CThreadInfo::ThreadFunc()
+{
+ for (;;)
+ {
+ Encoder->CanProcessEvent.Lock();
+ Encoder->CS.Enter();
+ if (Encoder->CloseThreads)
+ {
+ Encoder->CS.Leave();
+ return 0;
+ }
+ if (Encoder->StreamWasFinished)
+ {
+ FinishStream(true);
+ continue;
+ }
+ HRESULT res = S_OK;
+ bool needLeave = true;
+ try
+ {
+ const UInt32 blockSize = Encoder->ReadRleBlock(m_Block);
+ m_UnpackSize = Encoder->m_InStream.GetProcessedSize();
+ m_BlockIndex = Encoder->NextBlockIndex;
+ if (++Encoder->NextBlockIndex == Encoder->NumThreads)
+ Encoder->NextBlockIndex = 0;
+ if (blockSize == 0)
+ {
+ FinishStream(true);
+ continue;
+ }
+ Encoder->CS.Leave();
+ needLeave = false;
+ res = EncodeBlock3(blockSize);
+ }
+ catch(const CInBufferException &e) { res = e.ErrorCode; }
+ catch(const COutBufferException &e) { res = e.ErrorCode; }
+ catch(...) { res = E_FAIL; }
+ if (res != S_OK)
+ {
+ Encoder->Result = res;
+ FinishStream(needLeave);
+ continue;
+ }
+ }
+}
+
+#endif
+
+void CEncProps::Normalize(int level)
+{
+ if (level < 0) level = 5;
+ if (level > 9) level = 9;
+
+ if (NumPasses == (UInt32)(Int32)-1)
+ NumPasses = (level >= 9 ? 7 : (level >= 7 ? 2 : 1));
+ if (NumPasses < 1) NumPasses = 1;
+ if (NumPasses > kNumPassesMax) NumPasses = kNumPassesMax;
+
+ if (BlockSizeMult == (UInt32)(Int32)-1)
+ BlockSizeMult = (level >= 5 ? 9 : (level >= 1 ? (unsigned)level * 2 - 1: 1));
+ if (BlockSizeMult < kBlockSizeMultMin) BlockSizeMult = kBlockSizeMultMin;
+ if (BlockSizeMult > kBlockSizeMultMax) BlockSizeMult = kBlockSizeMultMax;
+}
+
+CEncoder::CEncoder()
+{
+ _props.Normalize(-1);
+
+ #ifndef Z7_ST
+ ThreadsInfo = NULL;
+ m_NumThreadsPrev = 0;
+ NumThreads = 1;
+ #endif
+}
+
+#ifndef Z7_ST
+CEncoder::~CEncoder()
+{
+ Free();
+}
+
+HRESULT CEncoder::Create()
+{
+ {
+ WRes wres = CanProcessEvent.CreateIfNotCreated_Reset();
+ if (wres == 0) { wres = CanStartWaitingEvent.CreateIfNotCreated_Reset(); }
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+
+ if (ThreadsInfo && m_NumThreadsPrev == NumThreads)
+ return S_OK;
+ try
+ {
+ Free();
+ MtMode = (NumThreads > 1);
+ m_NumThreadsPrev = NumThreads;
+ ThreadsInfo = new CThreadInfo[NumThreads];
+ if (!ThreadsInfo)
+ return E_OUTOFMEMORY;
+ }
+ catch(...) { return E_OUTOFMEMORY; }
+ for (UInt32 t = 0; t < NumThreads; t++)
+ {
+ CThreadInfo &ti = ThreadsInfo[t];
+ ti.Encoder = this;
+ if (MtMode)
+ {
+ HRESULT res = ti.Create();
+ if (res != S_OK)
+ {
+ NumThreads = t;
+ Free();
+ return res;
+ }
+ }
+ }
+ return S_OK;
+}
+
+void CEncoder::Free()
+{
+ if (!ThreadsInfo)
+ return;
+ CloseThreads = true;
+ CanProcessEvent.Set();
+ for (UInt32 t = 0; t < NumThreads; t++)
+ {
+ CThreadInfo &ti = ThreadsInfo[t];
+ if (MtMode)
+ ti.Thread.Wait_Close();
+ ti.Free();
+ }
+ delete []ThreadsInfo;
+ ThreadsInfo = NULL;
+}
+#endif
+
+UInt32 CEncoder::ReadRleBlock(Byte *buffer)
+{
+ UInt32 i = 0;
+ Byte prevByte;
+ if (m_InStream.ReadByte(prevByte))
+ {
+ NumBlocks++;
+ const UInt32 blockSize = _props.BlockSizeMult * kBlockSizeStep - 1;
+ unsigned numReps = 1;
+ buffer[i++] = prevByte;
+ while (i < blockSize) // "- 1" to support RLE
+ {
+ Byte b;
+ if (!m_InStream.ReadByte(b))
+ break;
+ if (b != prevByte)
+ {
+ if (numReps >= kRleModeRepSize)
+ buffer[i++] = (Byte)(numReps - kRleModeRepSize);
+ buffer[i++] = b;
+ numReps = 1;
+ prevByte = b;
+ continue;
+ }
+ numReps++;
+ if (numReps <= kRleModeRepSize)
+ buffer[i++] = b;
+ else if (numReps == kRleModeRepSize + 255)
+ {
+ buffer[i++] = (Byte)(numReps - kRleModeRepSize);
+ numReps = 0;
+ }
+ }
+ // it's to support original BZip2 decoder
+ if (numReps >= kRleModeRepSize)
+ buffer[i++] = (Byte)(numReps - kRleModeRepSize);
+ }
+ return i;
+}
+
+void CThreadInfo::WriteBits2(UInt32 value, unsigned numBits) { m_OutStreamCurrent->WriteBits(value, numBits); }
+void CThreadInfo::WriteByte2(Byte b) { WriteBits2(b, 8); }
+void CThreadInfo::WriteBit2(Byte v) { WriteBits2(v, 1); }
+void CThreadInfo::WriteCrc2(UInt32 v)
+{
+ for (unsigned i = 0; i < 4; i++)
+ WriteByte2(((Byte)(v >> (24 - i * 8))));
+}
+
+void CEncoder::WriteBits(UInt32 value, unsigned numBits) { m_OutStream.WriteBits(value, numBits); }
+void CEncoder::WriteByte(Byte b) { WriteBits(b, 8); }
+// void CEncoder::WriteBit(Byte v) { WriteBits(v, 1); }
+void CEncoder::WriteCrc(UInt32 v)
+{
+ for (unsigned i = 0; i < 4; i++)
+ WriteByte(((Byte)(v >> (24 - i * 8))));
+}
+
+
+// blockSize > 0
+void CThreadInfo::EncodeBlock(const Byte *block, UInt32 blockSize)
+{
+ WriteBit2(0); // Randomised = false
+
+ {
+ UInt32 origPtr = BlockSort(m_BlockSorterIndex, block, blockSize);
+ // if (m_BlockSorterIndex[origPtr] != 0) throw 1;
+ m_BlockSorterIndex[origPtr] = blockSize;
+ WriteBits2(origPtr, kNumOrigBits);
+ }
+
+ CMtf8Encoder mtf;
+ unsigned numInUse = 0;
+ {
+ Byte inUse[256];
+ Byte inUse16[16];
+ UInt32 i;
+ for (i = 0; i < 256; i++)
+ inUse[i] = 0;
+ for (i = 0; i < 16; i++)
+ inUse16[i] = 0;
+ for (i = 0; i < blockSize; i++)
+ inUse[block[i]] = 1;
+ for (i = 0; i < 256; i++)
+ if (inUse[i])
+ {
+ inUse16[i >> 4] = 1;
+ mtf.Buf[numInUse++] = (Byte)i;
+ }
+ for (i = 0; i < 16; i++)
+ WriteBit2(inUse16[i]);
+ for (i = 0; i < 256; i++)
+ if (inUse16[i >> 4])
+ WriteBit2(inUse[i]);
+ }
+ unsigned alphaSize = numInUse + 2;
+
+ Byte *mtfs = m_MtfArray;
+ UInt32 mtfArraySize = 0;
+ UInt32 symbolCounts[kMaxAlphaSize];
+ {
+ for (unsigned i = 0; i < kMaxAlphaSize; i++)
+ symbolCounts[i] = 0;
+ }
+
+ {
+ UInt32 rleSize = 0;
+ UInt32 i = 0;
+ const UInt32 *bsIndex = m_BlockSorterIndex;
+ block--;
+ do
+ {
+ unsigned pos = mtf.FindAndMove(block[bsIndex[i]]);
+ if (pos == 0)
+ rleSize++;
+ else
+ {
+ while (rleSize != 0)
+ {
+ rleSize--;
+ mtfs[mtfArraySize++] = (Byte)(rleSize & 1);
+ symbolCounts[rleSize & 1]++;
+ rleSize >>= 1;
+ }
+ if (pos >= 0xFE)
+ {
+ mtfs[mtfArraySize++] = 0xFF;
+ mtfs[mtfArraySize++] = (Byte)(pos - 0xFE);
+ }
+ else
+ mtfs[mtfArraySize++] = (Byte)(pos + 1);
+ symbolCounts[(size_t)pos + 1]++;
+ }
+ }
+ while (++i < blockSize);
+
+ while (rleSize != 0)
+ {
+ rleSize--;
+ mtfs[mtfArraySize++] = (Byte)(rleSize & 1);
+ symbolCounts[rleSize & 1]++;
+ rleSize >>= 1;
+ }
+
+ if (alphaSize < 256)
+ mtfs[mtfArraySize++] = (Byte)(alphaSize - 1);
+ else
+ {
+ mtfs[mtfArraySize++] = 0xFF;
+ mtfs[mtfArraySize++] = (Byte)(alphaSize - 256);
+ }
+ symbolCounts[(size_t)alphaSize - 1]++;
+ }
+
+ UInt32 numSymbols = 0;
+ {
+ for (unsigned i = 0; i < kMaxAlphaSize; i++)
+ numSymbols += symbolCounts[i];
+ }
+
+ unsigned bestNumTables = kNumTablesMin;
+ UInt32 bestPrice = 0xFFFFFFFF;
+ UInt32 startPos = m_OutStreamCurrent->GetPos();
+ Byte startCurByte = m_OutStreamCurrent->GetCurByte();
+ for (unsigned nt = kNumTablesMin; nt <= kNumTablesMax + 1; nt++)
+ {
+ unsigned numTables;
+
+ if (m_OptimizeNumTables)
+ {
+ m_OutStreamCurrent->SetPos(startPos);
+ m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
+ if (nt <= kNumTablesMax)
+ numTables = nt;
+ else
+ numTables = bestNumTables;
+ }
+ else
+ {
+ if (numSymbols < 200) numTables = 2;
+ else if (numSymbols < 600) numTables = 3;
+ else if (numSymbols < 1200) numTables = 4;
+ else if (numSymbols < 2400) numTables = 5;
+ else numTables = 6;
+ }
+
+ WriteBits2(numTables, kNumTablesBits);
+
+ UInt32 numSelectors = (numSymbols + kGroupSize - 1) / kGroupSize;
+ WriteBits2(numSelectors, kNumSelectorsBits);
+
+ {
+ UInt32 remFreq = numSymbols;
+ unsigned gs = 0;
+ unsigned t = numTables;
+ do
+ {
+ UInt32 tFreq = remFreq / t;
+ unsigned ge = gs;
+ UInt32 aFreq = 0;
+ while (aFreq < tFreq) // && ge < alphaSize)
+ aFreq += symbolCounts[ge++];
+
+ if (ge > gs + 1 && t != numTables && t != 1 && (((numTables - t) & 1) == 1))
+ aFreq -= symbolCounts[--ge];
+
+ Byte *lens = Lens[(size_t)t - 1];
+ unsigned i = 0;
+ do
+ lens[i] = (Byte)((i >= gs && i < ge) ? 0 : 1);
+ while (++i < alphaSize);
+ gs = ge;
+ remFreq -= aFreq;
+ }
+ while (--t != 0);
+ }
+
+
+ for (unsigned pass = 0; pass < kNumHuffPasses; pass++)
+ {
+ {
+ unsigned t = 0;
+ do
+ memset(Freqs[t], 0, sizeof(Freqs[t]));
+ while (++t < numTables);
+ }
+
+ {
+ UInt32 mtfPos = 0;
+ UInt32 g = 0;
+ do
+ {
+ UInt32 symbols[kGroupSize];
+ unsigned i = 0;
+ do
+ {
+ UInt32 symbol = mtfs[mtfPos++];
+ if (symbol >= 0xFF)
+ symbol += mtfs[mtfPos++];
+ symbols[i] = symbol;
+ }
+ while (++i < kGroupSize && mtfPos < mtfArraySize);
+
+ UInt32 bestPrice2 = 0xFFFFFFFF;
+ unsigned t = 0;
+ do
+ {
+ const Byte *lens = Lens[t];
+ UInt32 price = 0;
+ unsigned j = 0;
+ do
+ price += lens[symbols[j]];
+ while (++j < i);
+ if (price < bestPrice2)
+ {
+ m_Selectors[g] = (Byte)t;
+ bestPrice2 = price;
+ }
+ }
+ while (++t < numTables);
+ UInt32 *freqs = Freqs[m_Selectors[g++]];
+ unsigned j = 0;
+ do
+ freqs[symbols[j]]++;
+ while (++j < i);
+ }
+ while (mtfPos < mtfArraySize);
+ }
+
+ unsigned t = 0;
+ do
+ {
+ UInt32 *freqs = Freqs[t];
+ unsigned i = 0;
+ do
+ if (freqs[i] == 0)
+ freqs[i] = 1;
+ while (++i < alphaSize);
+ Huffman_Generate(freqs, Codes[t], Lens[t], kMaxAlphaSize, kMaxHuffmanLenForEncoding);
+ }
+ while (++t < numTables);
+ }
+
+ {
+ Byte mtfSel[kNumTablesMax];
+ {
+ unsigned t = 0;
+ do
+ mtfSel[t] = (Byte)t;
+ while (++t < numTables);
+ }
+
+ UInt32 i = 0;
+ do
+ {
+ Byte sel = m_Selectors[i];
+ unsigned pos;
+ for (pos = 0; mtfSel[pos] != sel; pos++)
+ WriteBit2(1);
+ WriteBit2(0);
+ for (; pos > 0; pos--)
+ mtfSel[pos] = mtfSel[(size_t)pos - 1];
+ mtfSel[0] = sel;
+ }
+ while (++i < numSelectors);
+ }
+
+ {
+ unsigned t = 0;
+ do
+ {
+ const Byte *lens = Lens[t];
+ UInt32 len = lens[0];
+ WriteBits2(len, kNumLevelsBits);
+ unsigned i = 0;
+ do
+ {
+ UInt32 level = lens[i];
+ while (len != level)
+ {
+ WriteBit2(1);
+ if (len < level)
+ {
+ WriteBit2(0);
+ len++;
+ }
+ else
+ {
+ WriteBit2(1);
+ len--;
+ }
+ }
+ WriteBit2(0);
+ }
+ while (++i < alphaSize);
+ }
+ while (++t < numTables);
+ }
+
+ {
+ UInt32 groupSize = 0;
+ UInt32 groupIndex = 0;
+ const Byte *lens = NULL;
+ const UInt32 *codes = NULL;
+ UInt32 mtfPos = 0;
+ do
+ {
+ UInt32 symbol = mtfs[mtfPos++];
+ if (symbol >= 0xFF)
+ symbol += mtfs[mtfPos++];
+ if (groupSize == 0)
+ {
+ groupSize = kGroupSize;
+ unsigned t = m_Selectors[groupIndex++];
+ lens = Lens[t];
+ codes = Codes[t];
+ }
+ groupSize--;
+ m_OutStreamCurrent->WriteBits(codes[symbol], lens[symbol]);
+ }
+ while (mtfPos < mtfArraySize);
+ }
+
+ if (!m_OptimizeNumTables)
+ break;
+ UInt32 price = m_OutStreamCurrent->GetPos() - startPos;
+ if (price <= bestPrice)
+ {
+ if (nt == kNumTablesMax)
+ break;
+ bestPrice = price;
+ bestNumTables = nt;
+ }
+ }
+}
+
+// blockSize > 0
+UInt32 CThreadInfo::EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize)
+{
+ WriteByte2(kBlockSig0);
+ WriteByte2(kBlockSig1);
+ WriteByte2(kBlockSig2);
+ WriteByte2(kBlockSig3);
+ WriteByte2(kBlockSig4);
+ WriteByte2(kBlockSig5);
+
+ CBZip2Crc crc;
+ unsigned numReps = 0;
+ Byte prevByte = block[0];
+ UInt32 i = 0;
+ do
+ {
+ Byte b = block[i];
+ if (numReps == kRleModeRepSize)
+ {
+ for (; b > 0; b--)
+ crc.UpdateByte(prevByte);
+ numReps = 0;
+ continue;
+ }
+ if (prevByte == b)
+ numReps++;
+ else
+ {
+ numReps = 1;
+ prevByte = b;
+ }
+ crc.UpdateByte(b);
+ }
+ while (++i < blockSize);
+ UInt32 crcRes = crc.GetDigest();
+ WriteCrc2(crcRes);
+ EncodeBlock(block, blockSize);
+ return crcRes;
+}
+
+void CThreadInfo::EncodeBlock2(const Byte *block, UInt32 blockSize, UInt32 numPasses)
+{
+ UInt32 numCrcs = m_NumCrcs;
+ bool needCompare = false;
+
+ UInt32 startBytePos = m_OutStreamCurrent->GetBytePos();
+ UInt32 startPos = m_OutStreamCurrent->GetPos();
+ Byte startCurByte = m_OutStreamCurrent->GetCurByte();
+ Byte endCurByte = 0;
+ UInt32 endPos = 0;
+ if (numPasses > 1 && blockSize >= (1 << 10))
+ {
+ UInt32 blockSize0 = blockSize / 2; // ????
+
+ for (; (block[blockSize0] == block[(size_t)blockSize0 - 1]
+ || block[(size_t)blockSize0 - 1] == block[(size_t)blockSize0 - 2])
+ && blockSize0 < blockSize;
+ blockSize0++);
+
+ if (blockSize0 < blockSize)
+ {
+ EncodeBlock2(block, blockSize0, numPasses - 1);
+ EncodeBlock2(block + blockSize0, blockSize - blockSize0, numPasses - 1);
+ endPos = m_OutStreamCurrent->GetPos();
+ endCurByte = m_OutStreamCurrent->GetCurByte();
+ if ((endPos & 7) > 0)
+ WriteBits2(0, 8 - (endPos & 7));
+ m_OutStreamCurrent->SetCurState((startPos & 7), startCurByte);
+ needCompare = true;
+ }
+ }
+
+ UInt32 startBytePos2 = m_OutStreamCurrent->GetBytePos();
+ UInt32 startPos2 = m_OutStreamCurrent->GetPos();
+ UInt32 crcVal = EncodeBlockWithHeaders(block, blockSize);
+ UInt32 endPos2 = m_OutStreamCurrent->GetPos();
+
+ if (needCompare)
+ {
+ UInt32 size2 = endPos2 - startPos2;
+ if (size2 < endPos - startPos)
+ {
+ UInt32 numBytes = m_OutStreamCurrent->GetBytePos() - startBytePos2;
+ Byte *buffer = m_OutStreamCurrent->GetStream();
+ for (UInt32 i = 0; i < numBytes; i++)
+ buffer[startBytePos + i] = buffer[startBytePos2 + i];
+ m_OutStreamCurrent->SetPos(startPos + endPos2 - startPos2);
+ m_NumCrcs = numCrcs;
+ m_CRCs[m_NumCrcs++] = crcVal;
+ }
+ else
+ {
+ m_OutStreamCurrent->SetPos(endPos);
+ m_OutStreamCurrent->SetCurState((endPos & 7), endCurByte);
+ }
+ }
+ else
+ {
+ m_NumCrcs = numCrcs;
+ m_CRCs[m_NumCrcs++] = crcVal;
+ }
+}
+
+HRESULT CThreadInfo::EncodeBlock3(UInt32 blockSize)
+{
+ CMsbfEncoderTemp outStreamTemp;
+ outStreamTemp.SetStream(m_TempArray);
+ outStreamTemp.Init();
+ m_OutStreamCurrent = &outStreamTemp;
+
+ m_NumCrcs = 0;
+
+ EncodeBlock2(m_Block, blockSize, Encoder->_props.NumPasses);
+
+ #ifndef Z7_ST
+ if (Encoder->MtMode)
+ Encoder->ThreadsInfo[m_BlockIndex].CanWriteEvent.Lock();
+ #endif
+ for (UInt32 i = 0; i < m_NumCrcs; i++)
+ Encoder->CombinedCrc.Update(m_CRCs[i]);
+ Encoder->WriteBytes(m_TempArray, outStreamTemp.GetPos(), outStreamTemp.GetCurByte());
+ HRESULT res = S_OK;
+ #ifndef Z7_ST
+ if (Encoder->MtMode)
+ {
+ UInt32 blockIndex = m_BlockIndex + 1;
+ if (blockIndex == Encoder->NumThreads)
+ blockIndex = 0;
+
+ if (Encoder->Progress)
+ {
+ const UInt64 packSize = Encoder->m_OutStream.GetProcessedSize();
+ res = Encoder->Progress->SetRatioInfo(&m_UnpackSize, &packSize);
+ }
+
+ Encoder->ThreadsInfo[blockIndex].CanWriteEvent.Set();
+ }
+ #endif
+ return res;
+}
+
+void CEncoder::WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte)
+{
+ UInt32 bytesSize = (sizeInBits >> 3);
+ for (UInt32 i = 0; i < bytesSize; i++)
+ m_OutStream.WriteBits(data[i], 8);
+ WriteBits(lastByte, (sizeInBits & 7));
+}
+
+
+HRESULT CEncoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
+{
+ NumBlocks = 0;
+ #ifndef Z7_ST
+ Progress = progress;
+ RINOK(Create())
+ for (UInt32 t = 0; t < NumThreads; t++)
+ #endif
+ {
+ #ifndef Z7_ST
+ CThreadInfo &ti = ThreadsInfo[t];
+ if (MtMode)
+ {
+ WRes wres = ti.StreamWasFinishedEvent.Reset();
+ if (wres == 0) { wres = ti.WaitingWasStartedEvent.Reset();
+ if (wres == 0) { wres = ti.CanWriteEvent.Reset(); }}
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ #else
+ CThreadInfo &ti = ThreadsInfo;
+ ti.Encoder = this;
+ #endif
+
+ ti.m_OptimizeNumTables = _props.DoOptimizeNumTables();
+
+ if (!ti.Alloc())
+ return E_OUTOFMEMORY;
+ }
+
+
+ if (!m_InStream.Create(kBufferSize))
+ return E_OUTOFMEMORY;
+ if (!m_OutStream.Create(kBufferSize))
+ return E_OUTOFMEMORY;
+
+
+ m_InStream.SetStream(inStream);
+ m_InStream.Init();
+
+ m_OutStream.SetStream(outStream);
+ m_OutStream.Init();
+
+ CombinedCrc.Init();
+ #ifndef Z7_ST
+ NextBlockIndex = 0;
+ StreamWasFinished = false;
+ CloseThreads = false;
+ CanStartWaitingEvent.Reset();
+ #endif
+
+ WriteByte(kArSig0);
+ WriteByte(kArSig1);
+ WriteByte(kArSig2);
+ WriteByte((Byte)(kArSig3 + _props.BlockSizeMult));
+
+ #ifndef Z7_ST
+
+ if (MtMode)
+ {
+ ThreadsInfo[0].CanWriteEvent.Set();
+ Result = S_OK;
+ CanProcessEvent.Set();
+ UInt32 t;
+ for (t = 0; t < NumThreads; t++)
+ ThreadsInfo[t].StreamWasFinishedEvent.Lock();
+ CanProcessEvent.Reset();
+ CanStartWaitingEvent.Set();
+ for (t = 0; t < NumThreads; t++)
+ ThreadsInfo[t].WaitingWasStartedEvent.Lock();
+ CanStartWaitingEvent.Reset();
+ RINOK(Result)
+ }
+ else
+ #endif
+ {
+ for (;;)
+ {
+ CThreadInfo &ti =
+ #ifndef Z7_ST
+ ThreadsInfo[0];
+ #else
+ ThreadsInfo;
+ #endif
+ UInt32 blockSize = ReadRleBlock(ti.m_Block);
+ if (blockSize == 0)
+ break;
+ RINOK(ti.EncodeBlock3(blockSize))
+ if (progress)
+ {
+ const UInt64 unpackSize = m_InStream.GetProcessedSize();
+ const UInt64 packSize = m_OutStream.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&unpackSize, &packSize))
+ }
+ }
+ }
+ WriteByte(kFinSig0);
+ WriteByte(kFinSig1);
+ WriteByte(kFinSig2);
+ WriteByte(kFinSig3);
+ WriteByte(kFinSig4);
+ WriteByte(kFinSig5);
+
+ WriteCrc(CombinedCrc.GetDigest());
+ RINOK(Flush())
+ if (!m_InStream.WasFinished())
+ return E_FAIL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const COutBufferException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ int level = -1;
+ CEncProps props;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ PROPID propID = propIDs[i];
+
+ if (propID == NCoderPropID::kAffinity)
+ {
+ if (prop.vt == VT_UI8)
+ props.Affinity = prop.uhVal.QuadPart;
+ else
+ return E_INVALIDARG;
+ continue;
+ }
+
+ if (propID >= NCoderPropID::kReduceSize)
+ continue;
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ UInt32 v = (UInt32)prop.ulVal;
+ switch (propID)
+ {
+ case NCoderPropID::kNumPasses: props.NumPasses = v; break;
+ case NCoderPropID::kDictionarySize: props.BlockSizeMult = v / kBlockSizeStep; break;
+ case NCoderPropID::kLevel: level = (int)v; break;
+ case NCoderPropID::kNumThreads:
+ {
+ #ifndef Z7_ST
+ SetNumberOfThreads(v);
+ #endif
+ break;
+ }
+ default: return E_INVALIDARG;
+ }
+ }
+ props.Normalize(level);
+ _props = props;
+ return S_OK;
+}
+
+#ifndef Z7_ST
+Z7_COM7F_IMF(CEncoder::SetNumberOfThreads(UInt32 numThreads))
+{
+ const UInt32 kNumThreadsMax = 64;
+ if (numThreads < 1) numThreads = 1;
+ if (numThreads > kNumThreadsMax) numThreads = kNumThreadsMax;
+ NumThreads = numThreads;
+ return S_OK;
+}
+#endif
+
+}}
diff --git a/CPP/7zip/Compress/BZip2Encoder.h b/CPP/7zip/Compress/BZip2Encoder.h
new file mode 100644
index 0000000..4a04fbd
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Encoder.h
@@ -0,0 +1,247 @@
+// BZip2Encoder.h
+
+#ifndef ZIP7_INC_COMPRESS_BZIP2_ENCODER_H
+#define ZIP7_INC_COMPRESS_BZIP2_ENCODER_H
+
+#include "../../Common/Defs.h"
+#include "../../Common/MyCom.h"
+
+#ifndef Z7_ST
+#include "../../Windows/Synchronization.h"
+#include "../../Windows/Thread.h"
+#endif
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+#include "../Common/OutBuffer.h"
+
+#include "BitmEncoder.h"
+#include "BZip2Const.h"
+#include "BZip2Crc.h"
+
+namespace NCompress {
+namespace NBZip2 {
+
+class CMsbfEncoderTemp
+{
+ UInt32 _pos;
+ unsigned _bitPos;
+ Byte _curByte;
+ Byte *_buf;
+public:
+ void SetStream(Byte *buf) { _buf = buf; }
+ Byte *GetStream() const { return _buf; }
+
+ void Init()
+ {
+ _pos = 0;
+ _bitPos = 8;
+ _curByte = 0;
+ }
+
+ void Flush()
+ {
+ if (_bitPos < 8)
+ WriteBits(0, _bitPos);
+ }
+
+ void WriteBits(UInt32 value, unsigned numBits)
+ {
+ while (numBits > 0)
+ {
+ unsigned numNewBits = MyMin(numBits, _bitPos);
+ numBits -= numNewBits;
+
+ _curByte = (Byte)(_curByte << numNewBits);
+ UInt32 newBits = value >> numBits;
+ _curByte |= Byte(newBits);
+ value -= (newBits << numBits);
+
+ _bitPos -= numNewBits;
+
+ if (_bitPos == 0)
+ {
+ _buf[_pos++] = _curByte;
+ _bitPos = 8;
+ }
+ }
+ }
+
+ UInt32 GetBytePos() const { return _pos ; }
+ UInt32 GetPos() const { return _pos * 8 + (8 - _bitPos); }
+ Byte GetCurByte() const { return _curByte; }
+ void SetPos(UInt32 bitPos)
+ {
+ _pos = bitPos >> 3;
+ _bitPos = 8 - ((unsigned)bitPos & 7);
+ }
+ void SetCurState(unsigned bitPos, Byte curByte)
+ {
+ _bitPos = 8 - bitPos;
+ _curByte = curByte;
+ }
+};
+
+class CEncoder;
+
+const unsigned kNumPassesMax = 10;
+
+class CThreadInfo
+{
+public:
+ Byte *m_Block;
+private:
+ Byte *m_MtfArray;
+ Byte *m_TempArray;
+ UInt32 *m_BlockSorterIndex;
+
+ CMsbfEncoderTemp *m_OutStreamCurrent;
+
+ Byte Lens[kNumTablesMax][kMaxAlphaSize];
+ UInt32 Freqs[kNumTablesMax][kMaxAlphaSize];
+ UInt32 Codes[kNumTablesMax][kMaxAlphaSize];
+
+ Byte m_Selectors[kNumSelectorsMax];
+
+ UInt32 m_CRCs[1 << kNumPassesMax];
+ UInt32 m_NumCrcs;
+
+ void WriteBits2(UInt32 value, unsigned numBits);
+ void WriteByte2(Byte b);
+ void WriteBit2(Byte v);
+ void WriteCrc2(UInt32 v);
+
+ void EncodeBlock(const Byte *block, UInt32 blockSize);
+ UInt32 EncodeBlockWithHeaders(const Byte *block, UInt32 blockSize);
+ void EncodeBlock2(const Byte *block, UInt32 blockSize, UInt32 numPasses);
+public:
+ bool m_OptimizeNumTables;
+ CEncoder *Encoder;
+ #ifndef Z7_ST
+ NWindows::CThread Thread;
+
+ NWindows::NSynchronization::CAutoResetEvent StreamWasFinishedEvent;
+ NWindows::NSynchronization::CAutoResetEvent WaitingWasStartedEvent;
+
+ // it's not member of this thread. We just need one event per thread
+ NWindows::NSynchronization::CAutoResetEvent CanWriteEvent;
+
+private:
+ UInt32 m_BlockIndex;
+ UInt64 m_UnpackSize;
+public:
+ Byte MtPad[1 << 8]; // It's pad for Multi-Threading. Must be >= Cache_Line_Size.
+ HRESULT Create();
+ void FinishStream(bool needLeave);
+ THREAD_FUNC_RET_TYPE ThreadFunc();
+ #endif
+
+ CThreadInfo(): m_Block(NULL), m_BlockSorterIndex(NULL) {}
+ ~CThreadInfo() { Free(); }
+ bool Alloc();
+ void Free();
+
+ HRESULT EncodeBlock3(UInt32 blockSize);
+};
+
+struct CEncProps
+{
+ UInt32 BlockSizeMult;
+ UInt32 NumPasses;
+ UInt64 Affinity;
+
+ CEncProps()
+ {
+ BlockSizeMult = (UInt32)(Int32)-1;
+ NumPasses = (UInt32)(Int32)-1;
+ Affinity = 0;
+ }
+ void Normalize(int level);
+ bool DoOptimizeNumTables() const { return NumPasses > 1; }
+};
+
+class CEncoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetCoderProperties,
+ #ifndef Z7_ST
+ public ICompressSetCoderMt,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetCoderProperties)
+ #ifndef Z7_ST
+ Z7_COM_QI_ENTRY(ICompressSetCoderMt)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetCoderProperties)
+ #ifndef Z7_ST
+ Z7_IFACE_COM7_IMP(ICompressSetCoderMt)
+ #endif
+
+ #ifndef Z7_ST
+ UInt32 m_NumThreadsPrev;
+ #endif
+public:
+ CInBuffer m_InStream;
+ #ifndef Z7_ST
+ Byte MtPad[1 << 8]; // It's pad for Multi-Threading. Must be >= Cache_Line_Size.
+ #endif
+ CBitmEncoder<COutBuffer> m_OutStream;
+ CEncProps _props;
+ CBZip2CombinedCrc CombinedCrc;
+
+ #ifndef Z7_ST
+ CThreadInfo *ThreadsInfo;
+ NWindows::NSynchronization::CManualResetEvent CanProcessEvent;
+ NWindows::NSynchronization::CCriticalSection CS;
+ UInt32 NumThreads;
+ bool MtMode;
+ UInt32 NextBlockIndex;
+
+ bool CloseThreads;
+ bool StreamWasFinished;
+ NWindows::NSynchronization::CManualResetEvent CanStartWaitingEvent;
+
+ HRESULT Result;
+ ICompressProgressInfo *Progress;
+ #else
+ CThreadInfo ThreadsInfo;
+ #endif
+
+ UInt64 NumBlocks;
+
+ UInt64 GetInProcessedSize() const { return m_InStream.GetProcessedSize(); }
+
+ UInt32 ReadRleBlock(Byte *buf);
+ void WriteBytes(const Byte *data, UInt32 sizeInBits, Byte lastByte);
+
+ void WriteBits(UInt32 value, unsigned numBits);
+ void WriteByte(Byte b);
+ // void WriteBit(Byte v);
+ void WriteCrc(UInt32 v);
+
+ #ifndef Z7_ST
+ HRESULT Create();
+ void Free();
+ #endif
+
+public:
+ CEncoder();
+ #ifndef Z7_ST
+ ~CEncoder();
+ #endif
+
+ HRESULT Flush() { return m_OutStream.Flush(); }
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/BZip2Register.cpp b/CPP/7zip/Compress/BZip2Register.cpp
new file mode 100644
index 0000000..83b911d
--- /dev/null
+++ b/CPP/7zip/Compress/BZip2Register.cpp
@@ -0,0 +1,25 @@
+// BZip2Register.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "BZip2Decoder.h"
+#if !defined(Z7_EXTRACT_ONLY) && !defined(Z7_BZIP2_EXTRACT_ONLY)
+#include "BZip2Encoder.h"
+#endif
+
+namespace NCompress {
+namespace NBZip2 {
+
+REGISTER_CODEC_CREATE(CreateDec, CDecoder)
+
+#if !defined(Z7_EXTRACT_ONLY) && !defined(Z7_BZIP2_EXTRACT_ONLY)
+REGISTER_CODEC_CREATE(CreateEnc, CEncoder)
+#else
+#define CreateEnc NULL
+#endif
+
+REGISTER_CODEC_2(BZip2, CreateDec, CreateEnc, 0x40202, "BZip2")
+
+}}
diff --git a/CPP/7zip/Compress/Bcj2Coder.cpp b/CPP/7zip/Compress/Bcj2Coder.cpp
index 4e083bf..27e78b0 100644
--- a/CPP/7zip/Compress/Bcj2Coder.cpp
+++ b/CPP/7zip/Compress/Bcj2Coder.cpp
@@ -1,666 +1,853 @@
-// Bcj2Coder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../Common/StreamUtils.h"
-
-#include "Bcj2Coder.h"
-
-namespace NCompress {
-namespace NBcj2 {
-
-CBaseCoder::CBaseCoder()
-{
- for (int i = 0; i < BCJ2_NUM_STREAMS + 1; i++)
- {
- _bufs[i] = NULL;
- _bufsCurSizes[i] = 0;
- _bufsNewSizes[i] = (1 << 18);
- }
-}
-
-CBaseCoder::~CBaseCoder()
-{
- for (int i = 0; i < BCJ2_NUM_STREAMS + 1; i++)
- ::MidFree(_bufs[i]);
-}
-
-HRESULT CBaseCoder::Alloc(bool allocForOrig)
-{
- unsigned num = allocForOrig ? BCJ2_NUM_STREAMS + 1 : BCJ2_NUM_STREAMS;
- for (unsigned i = 0; i < num; i++)
- {
- UInt32 newSize = _bufsNewSizes[i];
- const UInt32 kMinBufSize = 1;
- if (newSize < kMinBufSize)
- newSize = kMinBufSize;
- if (!_bufs[i] || newSize != _bufsCurSizes[i])
- {
- if (_bufs[i])
- {
- ::MidFree(_bufs[i]);
- _bufs[i] = 0;
- }
- _bufsCurSizes[i] = 0;
- Byte *buf = (Byte *)::MidAlloc(newSize);
- _bufs[i] = buf;
- if (!buf)
- return E_OUTOFMEMORY;
- _bufsCurSizes[i] = newSize;
- }
- }
- return S_OK;
-}
-
-
-
-#ifndef EXTRACT_ONLY
-
-CEncoder::CEncoder(): _relatLim(BCJ2_RELAT_LIMIT) {}
-CEncoder::~CEncoder() {}
-
-STDMETHODIMP CEncoder::SetInBufSize(UInt32, UInt32 size) { _bufsNewSizes[BCJ2_NUM_STREAMS] = size; return S_OK; }
-STDMETHODIMP CEncoder::SetOutBufSize(UInt32 streamIndex, UInt32 size) { _bufsNewSizes[streamIndex] = size; return S_OK; }
-
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
-{
- UInt32 relatLim = BCJ2_RELAT_LIMIT;
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = props[i];
- PROPID propID = propIDs[i];
- if (propID >= NCoderPropID::kReduceSize)
- continue;
- switch (propID)
- {
- /*
- case NCoderPropID::kDefaultProp:
- {
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- UInt32 v = prop.ulVal;
- if (v > 31)
- return E_INVALIDARG;
- relatLim = (UInt32)1 << v;
- break;
- }
- */
- case NCoderPropID::kDictionarySize:
- {
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- relatLim = prop.ulVal;
- if (relatLim > ((UInt32)1 << 31))
- return E_INVALIDARG;
- break;
- }
-
- case NCoderPropID::kNumThreads:
- continue;
- case NCoderPropID::kLevel:
- continue;
-
- default: return E_INVALIDARG;
- }
- }
-
- _relatLim = relatLim;
-
- return S_OK;
-}
-
-
-HRESULT CEncoder::CodeReal(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const * /* outSizes */, UInt32 numOutStreams,
- ICompressProgressInfo *progress)
-{
- if (numInStreams != 1 || numOutStreams != BCJ2_NUM_STREAMS)
- return E_INVALIDARG;
-
- RINOK(Alloc());
-
- UInt32 fileSize_for_Conv = 0;
- if (inSizes && inSizes[0])
- {
- UInt64 inSize = *inSizes[0];
- if (inSize <= BCJ2_FileSize_MAX)
- fileSize_for_Conv = (UInt32)inSize;
- }
-
- CMyComPtr<ICompressGetSubStreamSize> getSubStreamSize;
- inStreams[0]->QueryInterface(IID_ICompressGetSubStreamSize, (void **)&getSubStreamSize);
-
- CBcj2Enc enc;
-
- enc.src = _bufs[BCJ2_NUM_STREAMS];
- enc.srcLim = enc.src;
-
- {
- for (int i = 0; i < BCJ2_NUM_STREAMS; i++)
- {
- enc.bufs[i] = _bufs[i];
- enc.lims[i] = _bufs[i] + _bufsCurSizes[i];
- }
- }
-
- size_t numBytes_in_ReadBuf = 0;
- UInt64 prevProgress = 0;
- UInt64 totalStreamRead = 0; // size read from InputStream
- UInt64 currentInPos = 0; // data that was processed, it doesn't include data in input buffer and data in enc.temp
- UInt64 outSizeRc = 0;
-
- Bcj2Enc_Init(&enc);
-
- enc.fileIp = 0;
- enc.fileSize = fileSize_for_Conv;
-
- enc.relatLimit = _relatLim;
-
- enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
-
- bool needSubSize = false;
- UInt64 subStreamIndex = 0;
- UInt64 subStreamStartPos = 0;
- bool readWasFinished = false;
-
- for (;;)
- {
- if (needSubSize && getSubStreamSize)
- {
- enc.fileIp = 0;
- enc.fileSize = fileSize_for_Conv;
- enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
-
- for (;;)
- {
- UInt64 subStreamSize = 0;
- HRESULT result = getSubStreamSize->GetSubStreamSize(subStreamIndex, &subStreamSize);
- needSubSize = false;
-
- if (result == S_OK)
- {
- UInt64 newEndPos = subStreamStartPos + subStreamSize;
-
- bool isAccurateEnd = (newEndPos < totalStreamRead ||
- (newEndPos <= totalStreamRead && readWasFinished));
-
- if (newEndPos <= currentInPos && isAccurateEnd)
- {
- subStreamStartPos = newEndPos;
- subStreamIndex++;
- continue;
- }
-
- enc.srcLim = _bufs[BCJ2_NUM_STREAMS] + numBytes_in_ReadBuf;
-
- if (isAccurateEnd)
- {
- // data in enc.temp is possible here
- size_t rem = (size_t)(totalStreamRead - newEndPos);
-
- /* Pos_of(enc.src) <= old newEndPos <= newEndPos
- in another case, it's fail in some code */
- if ((size_t)(enc.srcLim - enc.src) < rem)
- return E_FAIL;
-
- enc.srcLim -= rem;
- enc.finishMode = BCJ2_ENC_FINISH_MODE_END_BLOCK;
- }
-
- if (subStreamSize <= BCJ2_FileSize_MAX)
- {
- enc.fileIp = enc.ip + (UInt32)(subStreamStartPos - currentInPos);
- enc.fileSize = (UInt32)subStreamSize;
- }
- break;
- }
-
- if (result == S_FALSE)
- break;
- if (result == E_NOTIMPL)
- {
- getSubStreamSize.Release();
- break;
- }
- return result;
- }
- }
-
- if (readWasFinished && totalStreamRead - currentInPos == Bcj2Enc_Get_InputData_Size(&enc))
- enc.finishMode = BCJ2_ENC_FINISH_MODE_END_STREAM;
-
- Bcj2Enc_Encode(&enc);
-
- currentInPos = totalStreamRead - numBytes_in_ReadBuf + (enc.src - _bufs[BCJ2_NUM_STREAMS]) - enc.tempPos;
-
- if (Bcj2Enc_IsFinished(&enc))
- break;
-
- if (enc.state < BCJ2_NUM_STREAMS)
- {
- size_t curSize = enc.bufs[enc.state] - _bufs[enc.state];
- // printf("Write stream = %2d %6d\n", enc.state, curSize);
- RINOK(WriteStream(outStreams[enc.state], _bufs[enc.state], curSize));
- if (enc.state == BCJ2_STREAM_RC)
- outSizeRc += curSize;
-
- enc.bufs[enc.state] = _bufs[enc.state];
- enc.lims[enc.state] = _bufs[enc.state] + _bufsCurSizes[enc.state];
- }
- else if (enc.state != BCJ2_ENC_STATE_ORIG)
- return E_FAIL;
- else
- {
- needSubSize = true;
-
- if (numBytes_in_ReadBuf != (size_t)(enc.src - _bufs[BCJ2_NUM_STREAMS]))
- {
- enc.srcLim = _bufs[BCJ2_NUM_STREAMS] + numBytes_in_ReadBuf;
- continue;
- }
-
- if (readWasFinished)
- continue;
-
- numBytes_in_ReadBuf = 0;
- enc.src = _bufs[BCJ2_NUM_STREAMS];
- enc.srcLim = _bufs[BCJ2_NUM_STREAMS];
-
- UInt32 curSize = _bufsCurSizes[BCJ2_NUM_STREAMS];
- RINOK(inStreams[0]->Read(_bufs[BCJ2_NUM_STREAMS], curSize, &curSize));
-
- // printf("Read %6d bytes\n", curSize);
- if (curSize == 0)
- {
- readWasFinished = true;
- continue;
- }
-
- numBytes_in_ReadBuf = curSize;
- totalStreamRead += numBytes_in_ReadBuf;
- enc.srcLim = _bufs[BCJ2_NUM_STREAMS] + numBytes_in_ReadBuf;
- }
-
- if (progress && currentInPos - prevProgress >= (1 << 20))
- {
- UInt64 outSize2 = currentInPos + outSizeRc + enc.bufs[BCJ2_STREAM_RC] - enc.bufs[BCJ2_STREAM_RC];
- prevProgress = currentInPos;
- // printf("progress %8d, %8d\n", (int)inSize2, (int)outSize2);
- RINOK(progress->SetRatioInfo(¤tInPos, &outSize2));
- }
- }
-
- for (int i = 0; i < BCJ2_NUM_STREAMS; i++)
- {
- RINOK(WriteStream(outStreams[i], _bufs[i], enc.bufs[i] - _bufs[i]));
- }
-
- // if (currentInPos != subStreamStartPos + subStreamSize) return E_FAIL;
-
- return S_OK;
-}
-
-STDMETHODIMP CEncoder::Code(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
- ICompressProgressInfo *progress)
-{
- try
- {
- return CodeReal(inStreams, inSizes, numInStreams, outStreams, outSizes,numOutStreams, progress);
- }
- catch(...) { return E_FAIL; }
-}
-
-#endif
-
-
-
-
-
-
-STDMETHODIMP CDecoder::SetInBufSize(UInt32 streamIndex, UInt32 size) { _bufsNewSizes[streamIndex] = size; return S_OK; }
-STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _bufsNewSizes[BCJ2_NUM_STREAMS] = size; return S_OK; }
-
-CDecoder::CDecoder(): _finishMode(false), _outSizeDefined(false), _outSize(0)
-{}
-
-STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
-{
- _finishMode = (finishMode != 0);
- return S_OK;
-}
-
-void CDecoder::InitCommon()
-{
- {
- for (int i = 0; i < BCJ2_NUM_STREAMS; i++)
- dec.lims[i] = dec.bufs[i] = _bufs[i];
- }
-
- {
- for (int i = 0; i < BCJ2_NUM_STREAMS; i++)
- {
- _extraReadSizes[i] = 0;
- _inStreamsProcessed[i] = 0;
- _readRes[i] = S_OK;
- }
- }
-
- Bcj2Dec_Init(&dec);
-}
-
-HRESULT CDecoder::Code(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
- ICompressProgressInfo *progress)
-{
- if (numInStreams != BCJ2_NUM_STREAMS || numOutStreams != 1)
- return E_INVALIDARG;
-
- RINOK(Alloc());
-
- InitCommon();
-
- dec.destLim = dec.dest = _bufs[BCJ2_NUM_STREAMS];
-
- UInt64 outSizeProcessed = 0;
- UInt64 prevProgress = 0;
-
- HRESULT res = S_OK;
-
- for (;;)
- {
- if (Bcj2Dec_Decode(&dec) != SZ_OK)
- return S_FALSE;
-
- if (dec.state < BCJ2_NUM_STREAMS)
- {
- size_t totalRead = _extraReadSizes[dec.state];
- {
- Byte *buf = _bufs[dec.state];
- for (size_t i = 0; i < totalRead; i++)
- buf[i] = dec.bufs[dec.state][i];
- dec.lims[dec.state] =
- dec.bufs[dec.state] = buf;
- }
-
- if (_readRes[dec.state] != S_OK)
- {
- res = _readRes[dec.state];
- break;
- }
-
- do
- {
- UInt32 curSize = _bufsCurSizes[dec.state] - (UInt32)totalRead;
- /*
- we want to call Read even even if size is 0
- if (inSizes && inSizes[dec.state])
- {
- UInt64 rem = *inSizes[dec.state] - _inStreamsProcessed[dec.state];
- if (curSize > rem)
- curSize = (UInt32)rem;
- }
- */
-
- HRESULT res2 = inStreams[dec.state]->Read(_bufs[dec.state] + totalRead, curSize, &curSize);
- _readRes[dec.state] = res2;
- if (curSize == 0)
- break;
- _inStreamsProcessed[dec.state] += curSize;
- totalRead += curSize;
- if (res2 != S_OK)
- break;
- }
- while (totalRead < 4 && BCJ2_IS_32BIT_STREAM(dec.state));
-
- if (_readRes[dec.state] != S_OK)
- res = _readRes[dec.state];
-
- if (totalRead == 0)
- break;
-
- // res == S_OK;
-
- if (BCJ2_IS_32BIT_STREAM(dec.state))
- {
- unsigned extraSize = ((unsigned)totalRead & 3);
- _extraReadSizes[dec.state] = extraSize;
- if (totalRead < 4)
- {
- res = (_readRes[dec.state] != S_OK) ? _readRes[dec.state] : S_FALSE;
- break;
- }
- totalRead -= extraSize;
- }
-
- dec.lims[dec.state] = _bufs[dec.state] + totalRead;
- }
- else // if (dec.state <= BCJ2_STATE_ORIG)
- {
- size_t curSize = dec.dest - _bufs[BCJ2_NUM_STREAMS];
- if (curSize != 0)
- {
- outSizeProcessed += curSize;
- RINOK(WriteStream(outStreams[0], _bufs[BCJ2_NUM_STREAMS], curSize));
- }
- dec.dest = _bufs[BCJ2_NUM_STREAMS];
- {
- size_t rem = _bufsCurSizes[BCJ2_NUM_STREAMS];
- if (outSizes && outSizes[0])
- {
- UInt64 outSize = *outSizes[0] - outSizeProcessed;
- if (rem > outSize)
- rem = (size_t)outSize;
- }
- dec.destLim = dec.dest + rem;
- if (rem == 0)
- break;
- }
- }
-
- if (progress)
- {
- const UInt64 outSize2 = outSizeProcessed + (dec.dest - _bufs[BCJ2_NUM_STREAMS]);
- if (outSize2 - prevProgress >= (1 << 22))
- {
- const UInt64 inSize2 = outSize2 + _inStreamsProcessed[BCJ2_STREAM_RC] - (dec.lims[BCJ2_STREAM_RC] - dec.bufs[BCJ2_STREAM_RC]);
- RINOK(progress->SetRatioInfo(&inSize2, &outSize2));
- prevProgress = outSize2;
- }
- }
- }
-
- size_t curSize = dec.dest - _bufs[BCJ2_NUM_STREAMS];
- if (curSize != 0)
- {
- outSizeProcessed += curSize;
- RINOK(WriteStream(outStreams[0], _bufs[BCJ2_NUM_STREAMS], curSize));
- }
-
- if (res != S_OK)
- return res;
-
- if (_finishMode)
- {
- if (!Bcj2Dec_IsFinished(&dec))
- return S_FALSE;
-
- // we still allow the cases when input streams are larger than required for decoding.
- // so the case (dec.state == BCJ2_STATE_ORIG) is also allowed, if MAIN stream is larger than required.
- if (dec.state != BCJ2_STREAM_MAIN &&
- dec.state != BCJ2_DEC_STATE_ORIG)
- return S_FALSE;
-
- if (inSizes)
- {
- for (int i = 0; i < BCJ2_NUM_STREAMS; i++)
- {
- size_t rem = dec.lims[i] - dec.bufs[i] + _extraReadSizes[i];
- /*
- if (rem != 0)
- return S_FALSE;
- */
- if (inSizes[i] && *inSizes[i] != _inStreamsProcessed[i] - rem)
- return S_FALSE;
- }
- }
- }
-
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::SetInStream2(UInt32 streamIndex, ISequentialInStream *inStream)
-{
- _inStreams[streamIndex] = inStream;
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::ReleaseInStream2(UInt32 streamIndex)
-{
- _inStreams[streamIndex].Release();
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
-{
- _outSizeDefined = (outSize != NULL);
- _outSize = 0;
- if (_outSizeDefined)
- _outSize = *outSize;
-
- _outSize_Processed = 0;
-
- HRESULT res = Alloc(false);
-
- InitCommon();
- dec.destLim = dec.dest = NULL;
-
- return res;
-}
-
-
-STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- if (size == 0)
- return S_OK;
-
- UInt32 totalProcessed = 0;
-
- if (_outSizeDefined)
- {
- UInt64 rem = _outSize - _outSize_Processed;
- if (size > rem)
- size = (UInt32)rem;
- }
- dec.dest = (Byte *)data;
- dec.destLim = (const Byte *)data + size;
-
- HRESULT res = S_OK;
-
- for (;;)
- {
- SRes sres = Bcj2Dec_Decode(&dec);
- if (sres != SZ_OK)
- return S_FALSE;
-
- {
- UInt32 curSize = (UInt32)(dec.dest - (Byte *)data);
- if (curSize != 0)
- {
- totalProcessed += curSize;
- if (processedSize)
- *processedSize = totalProcessed;
- data = (void *)((Byte *)data + curSize);
- size -= curSize;
- _outSize_Processed += curSize;
- }
- }
-
- if (dec.state >= BCJ2_NUM_STREAMS)
- break;
-
- {
- size_t totalRead = _extraReadSizes[dec.state];
- {
- Byte *buf = _bufs[dec.state];
- for (size_t i = 0; i < totalRead; i++)
- buf[i] = dec.bufs[dec.state][i];
- dec.lims[dec.state] =
- dec.bufs[dec.state] = buf;
- }
-
- if (_readRes[dec.state] != S_OK)
- return _readRes[dec.state];
-
- do
- {
- UInt32 curSize = _bufsCurSizes[dec.state] - (UInt32)totalRead;
- HRESULT res2 = _inStreams[dec.state]->Read(_bufs[dec.state] + totalRead, curSize, &curSize);
- _readRes[dec.state] = res2;
- if (curSize == 0)
- break;
- _inStreamsProcessed[dec.state] += curSize;
- totalRead += curSize;
- if (res2 != S_OK)
- break;
- }
- while (totalRead < 4 && BCJ2_IS_32BIT_STREAM(dec.state));
-
- if (totalRead == 0)
- {
- if (totalProcessed == 0)
- res = _readRes[dec.state];
- break;
- }
-
- if (BCJ2_IS_32BIT_STREAM(dec.state))
- {
- unsigned extraSize = ((unsigned)totalRead & 3);
- _extraReadSizes[dec.state] = extraSize;
- if (totalRead < 4)
- {
- if (totalProcessed != 0)
- return S_OK;
- return (_readRes[dec.state] != S_OK) ? _readRes[dec.state] : S_FALSE;
- }
- totalRead -= extraSize;
- }
-
- dec.lims[dec.state] = _bufs[dec.state] + totalRead;
- }
- }
-
- if (_finishMode && _outSizeDefined && _outSize == _outSize_Processed)
- {
- if (!Bcj2Dec_IsFinished(&dec))
- return S_FALSE;
-
- if (dec.state != BCJ2_STREAM_MAIN &&
- dec.state != BCJ2_DEC_STATE_ORIG)
- return S_FALSE;
-
- /*
- for (int i = 0; i < BCJ2_NUM_STREAMS; i++)
- if (dec.bufs[i] != dec.lims[i] || _extraReadSizes[i] != 0)
- return S_FALSE;
- */
- }
-
- return res;
-}
-
-
-STDMETHODIMP CDecoder::GetInStreamProcessedSize2(UInt32 streamIndex, UInt64 *value)
-{
- const size_t rem = dec.lims[streamIndex] - dec.bufs[streamIndex] + _extraReadSizes[streamIndex];
- *value = _inStreamsProcessed[streamIndex] - rem;
- return S_OK;
-}
-
-}}
+// Bcj2Coder.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "Bcj2Coder.h"
+
+namespace NCompress {
+namespace NBcj2 {
+
+CBaseCoder::CBaseCoder()
+{
+ for (unsigned i = 0; i < BCJ2_NUM_STREAMS + 1; i++)
+ {
+ _bufs[i] = NULL;
+ _bufsSizes[i] = 0;
+ _bufsSizes_New[i] = (1 << 18);
+ }
+}
+
+CBaseCoder::~CBaseCoder()
+{
+ for (unsigned i = 0; i < BCJ2_NUM_STREAMS + 1; i++)
+ ::MidFree(_bufs[i]);
+}
+
+HRESULT CBaseCoder::Alloc(bool allocForOrig)
+{
+ const unsigned num = allocForOrig ? BCJ2_NUM_STREAMS + 1 : BCJ2_NUM_STREAMS;
+ for (unsigned i = 0; i < num; i++)
+ {
+ UInt32 size = _bufsSizes_New[i];
+ /* buffer sizes for BCJ2_STREAM_CALL and BCJ2_STREAM_JUMP streams
+ must be aligned for 4 */
+ size &= ~(UInt32)3;
+ const UInt32 kMinBufSize = 4;
+ if (size < kMinBufSize)
+ size = kMinBufSize;
+ // size = 4 * 100; // for debug
+ // if (BCJ2_IS_32BIT_STREAM(i) == 1) size = 4 * 1; // for debug
+ if (!_bufs[i] || size != _bufsSizes[i])
+ {
+ if (_bufs[i])
+ {
+ ::MidFree(_bufs[i]);
+ _bufs[i] = NULL;
+ }
+ _bufsSizes[i] = 0;
+ Byte *buf = (Byte *)::MidAlloc(size);
+ if (!buf)
+ return E_OUTOFMEMORY;
+ _bufs[i] = buf;
+ _bufsSizes[i] = size;
+ }
+ }
+ return S_OK;
+}
+
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+CEncoder::CEncoder():
+ _relatLim(BCJ2_ENC_RELAT_LIMIT_DEFAULT)
+ // , _excludeRangeBits(BCJ2_RELAT_EXCLUDE_NUM_BITS)
+ {}
+CEncoder::~CEncoder() {}
+
+Z7_COM7F_IMF(CEncoder::SetInBufSize(UInt32, UInt32 size))
+ { _bufsSizes_New[BCJ2_NUM_STREAMS] = size; return S_OK; }
+Z7_COM7F_IMF(CEncoder::SetOutBufSize(UInt32 streamIndex, UInt32 size))
+ { _bufsSizes_New[streamIndex] = size; return S_OK; }
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+{
+ UInt32 relatLim = BCJ2_ENC_RELAT_LIMIT_DEFAULT;
+ // UInt32 excludeRangeBits = BCJ2_RELAT_EXCLUDE_NUM_BITS;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = props[i];
+ const PROPID propID = propIDs[i];
+ if (propID >= NCoderPropID::kReduceSize
+ // && propID != NCoderPropID::kHashBits
+ )
+ continue;
+ switch (propID)
+ {
+ /*
+ case NCoderPropID::kDefaultProp:
+ {
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ UInt32 v = prop.ulVal;
+ if (v > 31)
+ return E_INVALIDARG;
+ relatLim = (UInt32)1 << v;
+ break;
+ }
+ case NCoderPropID::kHashBits:
+ {
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ UInt32 v = prop.ulVal;
+ if (v > 31)
+ return E_INVALIDARG;
+ excludeRangeBits = v;
+ break;
+ }
+ */
+ case NCoderPropID::kDictionarySize:
+ {
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ relatLim = prop.ulVal;
+ if (relatLim > BCJ2_ENC_RELAT_LIMIT_MAX)
+ return E_INVALIDARG;
+ break;
+ }
+ case NCoderPropID::kNumThreads:
+ case NCoderPropID::kLevel:
+ continue;
+ default: return E_INVALIDARG;
+ }
+ }
+ _relatLim = relatLim;
+ // _excludeRangeBits = excludeRangeBits;
+ return S_OK;
+}
+
+
+HRESULT CEncoder::CodeReal(
+ ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+ ISequentialOutStream * const *outStreams, const UInt64 * const * /* outSizes */, UInt32 numOutStreams,
+ ICompressProgressInfo *progress)
+{
+ if (numInStreams != 1 || numOutStreams != BCJ2_NUM_STREAMS)
+ return E_INVALIDARG;
+
+ RINOK(Alloc())
+
+ CBcj2Enc_ip_unsigned fileSize_minus1 = BCJ2_ENC_FileSizeField_UNLIMITED;
+ if (inSizes && inSizes[0])
+ {
+ const UInt64 inSize = *inSizes[0];
+ #ifdef BCJ2_ENC_FileSize_MAX
+ if (inSize <= BCJ2_ENC_FileSize_MAX)
+ #endif
+ fileSize_minus1 = BCJ2_ENC_GET_FileSizeField_VAL_FROM_FileSize(inSize);
+ }
+
+ Z7_DECL_CMyComPtr_QI_FROM(ICompressGetSubStreamSize, getSubStreamSize, inStreams[0])
+
+ CBcj2Enc enc;
+ enc.src = _bufs[BCJ2_NUM_STREAMS];
+ enc.srcLim = enc.src;
+ {
+ for (unsigned i = 0; i < BCJ2_NUM_STREAMS; i++)
+ {
+ enc.bufs[i] = _bufs[i];
+ enc.lims[i] = _bufs[i] + _bufsSizes[i];
+ }
+ }
+ Bcj2Enc_Init(&enc);
+ enc.fileIp64 = 0;
+ enc.fileSize64_minus1 = fileSize_minus1;
+ enc.relatLimit = _relatLim;
+ // enc.relatExcludeBits = _excludeRangeBits;
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+
+ // Varibales that correspond processed data in input stream:
+ UInt64 inPos_without_Temp = 0; // it doesn't include data in enc.temp[]
+ UInt64 inPos_with_Temp = 0; // it includes data in enc.temp[]
+
+ UInt64 prevProgress = 0;
+ UInt64 totalRead = 0; // size read from input stream
+ UInt64 outSizeRc = 0;
+ UInt64 subStream_Index = 0;
+ UInt64 subStream_StartPos = 0; // global start offset of subStreams[subStream_Index]
+ UInt64 subStream_Size = 0;
+ const Byte *srcLim_Read = _bufs[BCJ2_NUM_STREAMS];
+ bool readWasFinished = false;
+ bool isAccurate = false;
+ bool wasUnknownSize = false;
+
+ for (;;)
+ {
+ if (readWasFinished && enc.srcLim == srcLim_Read)
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_END_STREAM;
+
+ // for debug:
+ // for (int y=0;y<100;y++) { CBcj2Enc enc2 = enc; Bcj2Enc_Encode(&enc2); }
+
+ Bcj2Enc_Encode(&enc);
+
+ inPos_with_Temp = totalRead - (size_t)(srcLim_Read - enc.src);
+ inPos_without_Temp = inPos_with_Temp - Bcj2Enc_Get_AvailInputSize_in_Temp(&enc);
+
+ // if (inPos_without_Temp != enc.ip64) return E_FAIL;
+
+ if (Bcj2Enc_IsFinished(&enc))
+ break;
+
+ if (enc.state < BCJ2_NUM_STREAMS)
+ {
+ if (enc.bufs[enc.state] != enc.lims[enc.state])
+ return E_FAIL;
+ const size_t curSize = (size_t)(enc.bufs[enc.state] - _bufs[enc.state]);
+ // printf("Write stream = %2d %6d\n", enc.state, curSize);
+ RINOK(WriteStream(outStreams[enc.state], _bufs[enc.state], curSize))
+ if (enc.state == BCJ2_STREAM_RC)
+ outSizeRc += curSize;
+ enc.bufs[enc.state] = _bufs[enc.state];
+ enc.lims[enc.state] = _bufs[enc.state] + _bufsSizes[enc.state];
+ }
+ else
+ {
+ if (enc.state != BCJ2_ENC_STATE_ORIG)
+ return E_FAIL;
+ // (enc.state == BCJ2_ENC_STATE_ORIG)
+ if (enc.src != enc.srcLim)
+ return E_FAIL;
+ if (enc.finishMode != BCJ2_ENC_FINISH_MODE_CONTINUE
+ && Bcj2Enc_Get_AvailInputSize_in_Temp(&enc) != 0)
+ return E_FAIL;
+
+ if (enc.src == srcLim_Read)
+ {
+ if (readWasFinished)
+ return E_FAIL;
+ UInt32 curSize = _bufsSizes[BCJ2_NUM_STREAMS];
+ RINOK(inStreams[0]->Read(_bufs[BCJ2_NUM_STREAMS], curSize, &curSize))
+ // printf("Read %6u bytes\n", curSize);
+ if (curSize == 0)
+ readWasFinished = true;
+ totalRead += curSize;
+ enc.src = _bufs[BCJ2_NUM_STREAMS];
+ srcLim_Read = _bufs[BCJ2_NUM_STREAMS] + curSize;
+ }
+ enc.srcLim = srcLim_Read;
+
+ if (getSubStreamSize)
+ {
+ /* we set base default conversions options that will be used,
+ if subStream related options will be not OK */
+ enc.fileIp64 = 0;
+ enc.fileSize64_minus1 = fileSize_minus1;
+ for (;;)
+ {
+ UInt64 nextPos;
+ if (isAccurate)
+ nextPos = subStream_StartPos + subStream_Size;
+ else
+ {
+ const HRESULT hres = getSubStreamSize->GetSubStreamSize(subStream_Index, &subStream_Size);
+ if (hres != S_OK)
+ {
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+ /* if sub-stream size is unknown, we use default settings.
+ We still can recover to normal mode for next sub-stream,
+ if GetSubStreamSize() will return S_OK, when current
+ sub-stream will be finished.
+ */
+ if (hres == S_FALSE)
+ {
+ wasUnknownSize = true;
+ break;
+ }
+ if (hres == E_NOTIMPL)
+ {
+ getSubStreamSize.Release();
+ break;
+ }
+ return hres;
+ }
+ // printf("GetSubStreamSize %6u : %6u \n", (unsigned)subStream_Index, (unsigned)subStream_Size);
+ nextPos = subStream_StartPos + subStream_Size;
+ if ((Int64)subStream_Size == -1)
+ {
+ /* it's not expected, but (-1) can mean unknown size. */
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+ wasUnknownSize = true;
+ break;
+ }
+ if (nextPos < subStream_StartPos)
+ return E_FAIL;
+ isAccurate =
+ (nextPos < totalRead
+ || (nextPos <= totalRead && readWasFinished));
+ }
+
+ /* (nextPos) is estimated end position of current sub_stream.
+ But only (totalRead) and (readWasFinished) values
+ can confirm that this estimated end position is accurate.
+ That end position is accurate, if it can't be changed in
+ further calls of GetSubStreamSize() */
+
+ /* (nextPos < inPos_with_Temp) is unexpected case here, that we
+ can get if from some incorrect ICompressGetSubStreamSize object,
+ where new GetSubStreamSize() call returns smaller size than
+ confirmed by Read() size from previous GetSubStreamSize() call.
+ */
+ if (nextPos < inPos_with_Temp)
+ {
+ if (wasUnknownSize)
+ {
+ /* that case can be complicated for recovering.
+ so we disable sub-streams requesting. */
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+ getSubStreamSize.Release();
+ break;
+ }
+ return E_FAIL; // to stop after failure
+ }
+
+ if (nextPos <= inPos_with_Temp)
+ {
+ // (nextPos == inPos_with_Temp)
+ /* CBcj2Enc encoder requires to finish each [non-empty] block (sub-stream)
+ with BCJ2_ENC_FINISH_MODE_END_BLOCK
+ or with BCJ2_ENC_FINISH_MODE_END_STREAM for last block:
+ And we send data of new block to CBcj2Enc, only if previous block was finished.
+ So we switch to next sub-stream if after Bcj2Enc_Encode() call we have
+ && (enc.finishMode != BCJ2_ENC_FINISH_MODE_CONTINUE)
+ && (nextPos == inPos_with_Temp)
+ && (enc.state == BCJ2_ENC_STATE_ORIG)
+ */
+ if (enc.finishMode != BCJ2_ENC_FINISH_MODE_CONTINUE)
+ {
+ /* subStream_StartPos is increased only here.
+ (subStream_StartPos == inPos_with_Temp) : at start
+ (subStream_StartPos <= inPos_with_Temp) : will be later
+ */
+ subStream_StartPos = nextPos;
+ subStream_Size = 0;
+ wasUnknownSize = false;
+ subStream_Index++;
+ isAccurate = false;
+ // we don't change finishMode here
+ continue;
+ }
+ }
+
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_CONTINUE;
+ /* for (!isAccurate) case:
+ (totalRead <= real_end_of_subStream)
+ so we can use BCJ2_ENC_FINISH_MODE_CONTINUE up to (totalRead)
+ // we don't change settings at the end of substream, if settings were unknown,
+ */
+
+ /* if (wasUnknownSize) then we can't trust size of that sub-stream.
+ so we use default settings instead */
+ if (!wasUnknownSize)
+ #ifdef BCJ2_ENC_FileSize_MAX
+ if (subStream_Size <= BCJ2_ENC_FileSize_MAX)
+ #endif
+ {
+ enc.fileIp64 =
+ (CBcj2Enc_ip_unsigned)(
+ (CBcj2Enc_ip_signed)enc.ip64 +
+ (CBcj2Enc_ip_signed)(subStream_StartPos - inPos_without_Temp));
+ Bcj2Enc_SET_FileSize(&enc, subStream_Size)
+ }
+
+ if (isAccurate)
+ {
+ /* (real_end_of_subStream == nextPos <= totalRead)
+ So we can use BCJ2_ENC_FINISH_MODE_END_BLOCK up to (nextPos). */
+ const size_t rem = (size_t)(totalRead - nextPos);
+ if ((size_t)(enc.srcLim - enc.src) < rem)
+ return E_FAIL;
+ enc.srcLim -= rem;
+ enc.finishMode = BCJ2_ENC_FINISH_MODE_END_BLOCK;
+ }
+
+ break;
+ } // for() loop
+ } // getSubStreamSize
+ }
+
+ if (progress && inPos_without_Temp - prevProgress >= (1 << 22))
+ {
+ prevProgress = inPos_without_Temp;
+ const UInt64 outSize2 = inPos_without_Temp + outSizeRc +
+ (size_t)(enc.bufs[BCJ2_STREAM_RC] - _bufs[BCJ2_STREAM_RC]);
+ // printf("progress %8u, %8u\n", (unsigned)inSize2, (unsigned)outSize2);
+ RINOK(progress->SetRatioInfo(&inPos_without_Temp, &outSize2))
+ }
+ }
+
+ for (unsigned i = 0; i < BCJ2_NUM_STREAMS; i++)
+ {
+ RINOK(WriteStream(outStreams[i], _bufs[i], (size_t)(enc.bufs[i] - _bufs[i])))
+ }
+ // if (inPos_without_Temp != subStream_StartPos + subStream_Size) return E_FAIL;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CEncoder::Code(
+ ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+ ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
+ ICompressProgressInfo *progress))
+{
+ try
+ {
+ return CodeReal(inStreams, inSizes, numInStreams, outStreams, outSizes,numOutStreams, progress);
+ }
+ catch(...) { return E_FAIL; }
+}
+
+#endif
+
+
+
+
+
+
+CDecoder::CDecoder():
+ _finishMode(false)
+#ifndef Z7_NO_READ_FROM_CODER
+ , _outSizeDefined(false)
+ , _outSize(0)
+ , _outSize_Processed(0)
+#endif
+{}
+
+Z7_COM7F_IMF(CDecoder::SetInBufSize(UInt32 streamIndex, UInt32 size))
+ { _bufsSizes_New[streamIndex] = size; return S_OK; }
+Z7_COM7F_IMF(CDecoder::SetOutBufSize(UInt32, UInt32 size))
+ { _bufsSizes_New[BCJ2_NUM_STREAMS] = size; return S_OK; }
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ _finishMode = (finishMode != 0);
+ return S_OK;
+}
+
+void CBaseDecoder::InitCommon()
+{
+ for (unsigned i = 0; i < BCJ2_NUM_STREAMS; i++)
+ {
+ dec.lims[i] = dec.bufs[i] = _bufs[i];
+ _readRes[i] = S_OK;
+ _extraSizes[i] = 0;
+ _readSizes[i] = 0;
+ }
+ Bcj2Dec_Init(&dec);
+}
+
+
+/* call ReadInStream() only after Bcj2Dec_Decode().
+ input requirement:
+ (dec.state < BCJ2_NUM_STREAMS)
+*/
+void CBaseDecoder::ReadInStream(ISequentialInStream *inStream)
+{
+ const unsigned state = dec.state;
+ UInt32 total;
+ {
+ Byte *buf = _bufs[state];
+ const Byte *cur = dec.bufs[state];
+ // if (cur != dec.lims[state]) throw 1; // unexpected case
+ dec.lims[state] =
+ dec.bufs[state] = buf;
+ total = (UInt32)_extraSizes[state];
+ for (UInt32 i = 0; i < total; i++)
+ buf[i] = cur[i];
+ }
+
+ if (_readRes[state] != S_OK)
+ return;
+
+ do
+ {
+ UInt32 curSize = _bufsSizes[state] - total;
+ // if (state == 0) curSize = 0; // for debug
+ // curSize = 7; // for debug
+ /* even if we have reached provided inSizes[state] limit,
+ we call Read() with (curSize != 0), because
+ we want the called handler of stream->Read() could
+ execute required Init/Flushing code even for empty stream.
+ In another way we could call Read() with (curSize == 0) for
+ finished streams, but some Read() handlers can ignore Read(size=0) calls.
+ */
+ const HRESULT hres = inStream->Read(_bufs[state] + total, curSize, &curSize);
+ _readRes[state] = hres;
+ if (curSize == 0)
+ break;
+ _readSizes[state] += curSize;
+ total += curSize;
+ if (hres != S_OK)
+ break;
+ }
+ while (total < 4 && BCJ2_IS_32BIT_STREAM(state));
+
+ /* we exit from decoding loop here, if we can't
+ provide new data for input stream.
+ Usually it's normal exit after full stream decoding. */
+ if (total == 0)
+ return;
+
+ if (BCJ2_IS_32BIT_STREAM(state))
+ {
+ const unsigned extra = ((unsigned)total & 3);
+ _extraSizes[state] = extra;
+ if (total < 4)
+ {
+ if (_readRes[state] == S_OK)
+ _readRes[state] = S_FALSE; // actually it's stream error. So maybe we need another error code.
+ return;
+ }
+ total -= extra;
+ }
+
+ dec.lims[state] += total; // = _bufs[state] + total;
+}
+
+
+Z7_COM7F_IMF(CDecoder::Code(
+ ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+ ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
+ ICompressProgressInfo *progress))
+{
+ if (numInStreams != BCJ2_NUM_STREAMS || numOutStreams != 1)
+ return E_INVALIDARG;
+
+ RINOK(Alloc())
+ InitCommon();
+
+ dec.destLim = dec.dest = _bufs[BCJ2_NUM_STREAMS];
+
+ UInt64 outSizeWritten = 0;
+ UInt64 prevProgress = 0;
+
+ HRESULT hres_Crit = S_OK; // critical hres status (mostly from input stream reading)
+ HRESULT hres_Weak = S_OK; // first non-critical error code from input stream reading
+
+ for (;;)
+ {
+ if (Bcj2Dec_Decode(&dec) != SZ_OK)
+ {
+ /* it's possible only at start (first 5 bytes in RC stream) */
+ hres_Crit = S_FALSE;
+ break;
+ }
+ if (dec.state < BCJ2_NUM_STREAMS)
+ {
+ ReadInStream(inStreams[dec.state]);
+ const unsigned state = dec.state;
+ const HRESULT hres = _readRes[state];
+ if (dec.lims[state] == _bufs[state])
+ {
+ // we break decoding, if there are no new data in input stream
+ hres_Crit = hres;
+ break;
+ }
+ if (hres != S_OK && hres_Weak == S_OK)
+ hres_Weak = hres;
+ }
+ else // (BCJ2_DEC_STATE_ORIG_0 <= state <= BCJ2_STATE_ORIG)
+ {
+ {
+ const size_t curSize = (size_t)(dec.dest - _bufs[BCJ2_NUM_STREAMS]);
+ if (curSize != 0)
+ {
+ outSizeWritten += curSize;
+ RINOK(WriteStream(outStreams[0], _bufs[BCJ2_NUM_STREAMS], curSize))
+ }
+ }
+ {
+ UInt32 rem = _bufsSizes[BCJ2_NUM_STREAMS];
+ if (outSizes && outSizes[0])
+ {
+ const UInt64 outSize = *outSizes[0] - outSizeWritten;
+ if (rem > outSize)
+ rem = (UInt32)outSize;
+ }
+ dec.dest = _bufs[BCJ2_NUM_STREAMS];
+ dec.destLim = dec.dest + rem;
+ /* we exit from decoding loop here,
+ if (outSizes[0]) limit for output stream was reached */
+ if (rem == 0)
+ break;
+ }
+ }
+
+ if (progress)
+ {
+ // here we don't count additional data in dec.temp (up to 4 bytes for output stream)
+ const UInt64 processed = outSizeWritten + (size_t)(dec.dest - _bufs[BCJ2_NUM_STREAMS]);
+ if (processed - prevProgress >= (1 << 24))
+ {
+ prevProgress = processed;
+ const UInt64 inSize = processed +
+ _readSizes[BCJ2_STREAM_RC] - (size_t)(
+ dec.lims[BCJ2_STREAM_RC] -
+ dec.bufs[BCJ2_STREAM_RC]);
+ RINOK(progress->SetRatioInfo(&inSize, &prevProgress))
+ }
+ }
+ }
+
+ {
+ const size_t curSize = (size_t)(dec.dest - _bufs[BCJ2_NUM_STREAMS]);
+ if (curSize != 0)
+ {
+ outSizeWritten += curSize;
+ RINOK(WriteStream(outStreams[0], _bufs[BCJ2_NUM_STREAMS], curSize))
+ }
+ }
+
+ if (hres_Crit == S_OK) hres_Crit = hres_Weak;
+ if (hres_Crit != S_OK) return hres_Crit;
+
+ if (_finishMode)
+ {
+ if (!Bcj2Dec_IsMaybeFinished_code(&dec))
+ return S_FALSE;
+
+ /* here we support two correct ways to finish full stream decoding
+ with one of the following conditions:
+ - the end of input stream MAIN was reached
+ - the end of output stream ORIG was reached
+ Currently 7-Zip/7z code ends with (state == BCJ2_STREAM_MAIN),
+ because the sizes of MAIN and ORIG streams are known and these
+ sizes are stored in 7z archive headers.
+ And Bcj2Dec_Decode() exits with (state == BCJ2_STREAM_MAIN),
+ if both MAIN and ORIG streams have reached buffers limits.
+ But if the size of MAIN stream is not known or if the
+ size of MAIN stream includes some padding after payload data,
+ then we still can correctly finish decoding with
+ (state == BCJ2_DEC_STATE_ORIG), if we know the exact size
+ of output ORIG stream.
+ */
+ if (dec.state != BCJ2_STREAM_MAIN)
+ if (dec.state != BCJ2_DEC_STATE_ORIG)
+ return S_FALSE;
+
+ /* the caller also will know written size.
+ So the following check is optional: */
+ if (outSizes && outSizes[0] && *outSizes[0] != outSizeWritten)
+ return S_FALSE;
+
+ if (inSizes)
+ {
+ for (unsigned i = 0; i < BCJ2_NUM_STREAMS; i++)
+ {
+ /* if (inSizes[i]) is defined, we do full check for processed stream size. */
+ if (inSizes[i] && *inSizes[i] != GetProcessedSize_ForInStream(i))
+ return S_FALSE;
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize2(UInt32 streamIndex, UInt64 *value))
+{
+ *value = GetProcessedSize_ForInStream(streamIndex);
+ return S_OK;
+}
+
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+Z7_COM7F_IMF(CDecoder::SetInStream2(UInt32 streamIndex, ISequentialInStream *inStream))
+{
+ _inStreams[streamIndex] = inStream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::ReleaseInStream2(UInt32 streamIndex))
+{
+ _inStreams[streamIndex].Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ _outSizeDefined = (outSize != NULL);
+ _outSize = 0;
+ if (_outSizeDefined)
+ _outSize = *outSize;
+ _outSize_Processed = 0;
+
+ const HRESULT res = Alloc(false); // allocForOrig
+ InitCommon();
+ dec.destLim = dec.dest = NULL;
+ return res;
+}
+
+
+Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ /* Note the case:
+ The output (ORIG) stream can be empty.
+ But BCJ2_STREAM_RC stream always is not empty.
+ And we want to support full data processing for all streams.
+ We disable check (size == 0) here.
+ So if the caller calls this CDecoder::Read() with (size == 0),
+ we execute required Init/Flushing code in this CDecoder object.
+ Also this CDecoder::Read() function will call Read() for input streams.
+ So the handlers of input streams objects also can do Init/Flushing.
+ */
+ // if (size == 0) return S_OK; // disabled to allow (size == 0) processing
+
+ UInt32 totalProcessed = 0;
+
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _outSize_Processed;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+ dec.dest = (Byte *)data;
+ dec.destLim = (const Byte *)data + size;
+
+ HRESULT res = S_OK;
+
+ for (;;)
+ {
+ if (Bcj2Dec_Decode(&dec) != SZ_OK)
+ return S_FALSE; // this error can be only at start of stream
+ {
+ const UInt32 curSize = (UInt32)(size_t)(dec.dest - (Byte *)data);
+ if (curSize != 0)
+ {
+ data = (void *)((Byte *)data + curSize);
+ size -= curSize;
+ _outSize_Processed += curSize;
+ totalProcessed += curSize;
+ if (processedSize)
+ *processedSize = totalProcessed;
+ }
+ }
+ if (dec.state >= BCJ2_NUM_STREAMS)
+ break;
+ ReadInStream(_inStreams[dec.state]);
+ if (dec.lims[dec.state] == _bufs[dec.state])
+ {
+ /* we break decoding, if there are no new data in input stream.
+ and we ignore error code, if some data were written to output buffer. */
+ if (totalProcessed == 0)
+ res = _readRes[dec.state];
+ break;
+ }
+ }
+
+ if (res == S_OK)
+ if (_finishMode && _outSizeDefined && _outSize == _outSize_Processed)
+ {
+ if (!Bcj2Dec_IsMaybeFinished_code(&dec))
+ return S_FALSE;
+ if (dec.state != BCJ2_STREAM_MAIN)
+ if (dec.state != BCJ2_DEC_STATE_ORIG)
+ return S_FALSE;
+ }
+
+ return res;
+}
+
+#endif
+
+}}
+
+
+/*
+extern "C"
+{
+extern UInt32 bcj2_stats[256 + 2][2];
+}
+
+static class CBcj2Stat
+{
+public:
+ ~CBcj2Stat()
+ {
+ printf("\nBCJ2 stat:");
+ unsigned sums[2] = { 0, 0 };
+ int i;
+ for (i = 2; i < 256 + 2; i++)
+ {
+ sums[0] += bcj2_stats[i][0];
+ sums[1] += bcj2_stats[i][1];
+ }
+ const unsigned sums2 = sums[0] + sums[1];
+ for (int vi = 0; vi < 256 + 3; vi++)
+ {
+ printf("\n");
+ UInt32 n0, n1;
+ if (vi < 4)
+ printf("\n");
+
+ if (vi < 2)
+ i = vi;
+ else if (vi == 2)
+ i = -1;
+ else
+ i = vi - 1;
+
+ if (i < 0)
+ {
+ n0 = sums[0];
+ n1 = sums[1];
+ printf("calls :");
+ }
+ else
+ {
+ if (i == 0)
+ printf("jcc :");
+ else if (i == 1)
+ printf("jump :");
+ else
+ printf("call %02x :", i - 2);
+ n0 = bcj2_stats[i][0];
+ n1 = bcj2_stats[i][1];
+ }
+
+ const UInt32 sum = n0 + n1;
+ printf(" %10u", sum);
+
+ #define PRINT_PERC(val, sum) \
+ { UInt32 _sum = sum; if (_sum == 0) _sum = 1; \
+ printf(" %7.3f %%", (double)((double)val * (double)100 / (double)_sum )); }
+
+ if (i >= 2 || i < 0)
+ {
+ PRINT_PERC(sum, sums2);
+ }
+ else
+ printf("%10s", "");
+
+ printf(" :%10u", n0);
+ PRINT_PERC(n0, sum);
+
+ printf(" :%10u", n1);
+ PRINT_PERC(n1, sum);
+ }
+ printf("\n\n");
+ fflush(stdout);
+ }
+} g_CBcjStat;
+*/
diff --git a/CPP/7zip/Compress/Bcj2Coder.h b/CPP/7zip/Compress/Bcj2Coder.h
index 666bf8c..2ab91bc 100644
--- a/CPP/7zip/Compress/Bcj2Coder.h
+++ b/CPP/7zip/Compress/Bcj2Coder.h
@@ -1,120 +1,127 @@
-// Bcj2Coder.h
-
-#ifndef __COMPRESS_BCJ2_CODER_H
-#define __COMPRESS_BCJ2_CODER_H
-
-#include "../../../C/Bcj2.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NBcj2 {
-
-class CBaseCoder
-{
-protected:
- Byte *_bufs[BCJ2_NUM_STREAMS + 1];
- UInt32 _bufsCurSizes[BCJ2_NUM_STREAMS + 1];
- UInt32 _bufsNewSizes[BCJ2_NUM_STREAMS + 1];
-
- HRESULT Alloc(bool allocForOrig = true);
-public:
- CBaseCoder();
- ~CBaseCoder();
-};
-
-
-#ifndef EXTRACT_ONLY
-
-class CEncoder:
- public ICompressCoder2,
- public ICompressSetCoderProperties,
- public ICompressSetBufSize,
- public CMyUnknownImp,
- public CBaseCoder
-{
- UInt32 _relatLim;
-
- HRESULT CodeReal(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
- ICompressProgressInfo *progress);
-
-public:
- MY_UNKNOWN_IMP3(ICompressCoder2, ICompressSetCoderProperties, ICompressSetBufSize)
-
- STDMETHOD(Code)(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
- ICompressProgressInfo *progress);
-
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
-
- STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
- STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
-
- CEncoder();
- ~CEncoder();
-};
-
-#endif
-
-class CDecoder:
- public ICompressCoder2,
- public ICompressSetFinishMode,
- public ICompressGetInStreamProcessedSize2,
- public ICompressSetInStream2,
- public ISequentialInStream,
- public ICompressSetOutStreamSize,
- public ICompressSetBufSize,
- public CMyUnknownImp,
- public CBaseCoder
-{
- unsigned _extraReadSizes[BCJ2_NUM_STREAMS];
- UInt64 _inStreamsProcessed[BCJ2_NUM_STREAMS];
- HRESULT _readRes[BCJ2_NUM_STREAMS];
- CMyComPtr<ISequentialInStream> _inStreams[BCJ2_NUM_STREAMS];
-
- bool _finishMode;
- bool _outSizeDefined;
- UInt64 _outSize;
- UInt64 _outSize_Processed;
- CBcj2Dec dec;
-
- void InitCommon();
- // HRESULT ReadSpec();
-
-public:
- MY_UNKNOWN_IMP7(
- ICompressCoder2,
- ICompressSetFinishMode,
- ICompressGetInStreamProcessedSize2,
- ICompressSetInStream2,
- ISequentialInStream,
- ICompressSetOutStreamSize,
- ICompressSetBufSize
- );
-
- STDMETHOD(Code)(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
- ICompressProgressInfo *progress);
-
- STDMETHOD(SetFinishMode)(UInt32 finishMode);
- STDMETHOD(GetInStreamProcessedSize2)(UInt32 streamIndex, UInt64 *value);
-
- STDMETHOD(SetInStream2)(UInt32 streamIndex, ISequentialInStream *inStream);
- STDMETHOD(ReleaseInStream2)(UInt32 streamIndex);
-
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
-
- STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
- STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
-
- CDecoder();
-};
-
-}}
-
-#endif
+// Bcj2Coder.h
+
+#ifndef ZIP7_INC_COMPRESS_BCJ2_CODER_H
+#define ZIP7_INC_COMPRESS_BCJ2_CODER_H
+
+#include "../../../C/Bcj2.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NBcj2 {
+
+class CBaseCoder
+{
+protected:
+ Byte *_bufs[BCJ2_NUM_STREAMS + 1];
+ UInt32 _bufsSizes[BCJ2_NUM_STREAMS + 1];
+ UInt32 _bufsSizes_New[BCJ2_NUM_STREAMS + 1];
+
+ HRESULT Alloc(bool allocForOrig = true);
+public:
+ CBaseCoder();
+ ~CBaseCoder();
+};
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+class CEncoder Z7_final:
+ public ICompressCoder2,
+ public ICompressSetCoderProperties,
+ public ICompressSetBufSize,
+ public CMyUnknownImp,
+ public CBaseCoder
+{
+ Z7_IFACES_IMP_UNK_3(
+ ICompressCoder2,
+ ICompressSetCoderProperties,
+ ICompressSetBufSize)
+
+ UInt32 _relatLim;
+ // UInt32 _excludeRangeBits;
+
+ HRESULT CodeReal(
+ ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
+ ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
+ ICompressProgressInfo *progress);
+public:
+ CEncoder();
+ ~CEncoder();
+};
+
+#endif
+
+
+
+class CBaseDecoder: public CBaseCoder
+{
+protected:
+ HRESULT _readRes[BCJ2_NUM_STREAMS];
+ unsigned _extraSizes[BCJ2_NUM_STREAMS];
+ UInt64 _readSizes[BCJ2_NUM_STREAMS];
+
+ CBcj2Dec dec;
+
+ UInt64 GetProcessedSize_ForInStream(unsigned i) const
+ {
+ return _readSizes[i] - ((size_t)(dec.lims[i] - dec.bufs[i]) + _extraSizes[i]);
+ }
+ void InitCommon();
+ void ReadInStream(ISequentialInStream *inStream);
+};
+
+
+class CDecoder Z7_final:
+ public ICompressCoder2,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize2,
+ public ICompressSetBufSize,
+#ifndef Z7_NO_READ_FROM_CODER
+ public ICompressSetInStream2,
+ public ICompressSetOutStreamSize,
+ public ISequentialInStream,
+#endif
+ public CMyUnknownImp,
+ public CBaseDecoder
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder2)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize2)
+ Z7_COM_QI_ENTRY(ICompressSetBufSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_COM_QI_ENTRY(ICompressSetInStream2)
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder2)
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize2)
+ Z7_IFACE_COM7_IMP(ICompressSetBufSize)
+#ifndef Z7_NO_READ_FROM_CODER
+ Z7_IFACE_COM7_IMP(ICompressSetInStream2)
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+#endif
+
+ bool _finishMode;
+
+#ifndef Z7_NO_READ_FROM_CODER
+ bool _outSizeDefined;
+ UInt64 _outSize;
+ UInt64 _outSize_Processed;
+ CMyComPtr<ISequentialInStream> _inStreams[BCJ2_NUM_STREAMS];
+#endif
+
+public:
+ CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Bcj2Register.cpp b/CPP/7zip/Compress/Bcj2Register.cpp
index bce6178..1ce4dec 100644
--- a/CPP/7zip/Compress/Bcj2Register.cpp
+++ b/CPP/7zip/Compress/Bcj2Register.cpp
@@ -1,24 +1,24 @@
-// Bcj2Register.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "Bcj2Coder.h"
-
-namespace NCompress {
-namespace NBcj2 {
-
-REGISTER_CODEC_CREATE_2(CreateCodec, CDecoder(), ICompressCoder2)
-#ifndef EXTRACT_ONLY
-REGISTER_CODEC_CREATE_2(CreateCodecOut, CEncoder(), ICompressCoder2)
-#else
-#define CreateCodecOut NULL
-#endif
-
-REGISTER_CODEC_VAR
- { CreateCodec, CreateCodecOut, 0x303011B, "BCJ2", 4, false };
-
-REGISTER_CODEC(BCJ2)
-
-}}
+// Bcj2Register.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "Bcj2Coder.h"
+
+namespace NCompress {
+namespace NBcj2 {
+
+REGISTER_CODEC_CREATE_2(CreateCodec, CDecoder(), ICompressCoder2)
+#ifndef Z7_EXTRACT_ONLY
+REGISTER_CODEC_CREATE_2(CreateCodecOut, CEncoder(), ICompressCoder2)
+#else
+#define CreateCodecOut NULL
+#endif
+
+REGISTER_CODEC_VAR(BCJ2)
+ { CreateCodec, CreateCodecOut, 0x303011B, "BCJ2", 4, false };
+
+REGISTER_CODEC(BCJ2)
+
+}}
diff --git a/CPP/7zip/Compress/BcjCoder.cpp b/CPP/7zip/Compress/BcjCoder.cpp
index a50360c..0047874 100644
--- a/CPP/7zip/Compress/BcjCoder.cpp
+++ b/CPP/7zip/Compress/BcjCoder.cpp
@@ -1,24 +1,24 @@
-// BcjCoder.cpp
-
-#include "StdAfx.h"
-
-#include "BcjCoder.h"
-
-namespace NCompress {
-namespace NBcj {
-
-STDMETHODIMP CCoder::Init()
-{
- _bufferPos = 0;
- x86_Convert_Init(_prevMask);
- return S_OK;
-}
-
-STDMETHODIMP_(UInt32) CCoder::Filter(Byte *data, UInt32 size)
-{
- UInt32 processed = (UInt32)::x86_Convert(data, size, _bufferPos, &_prevMask, _encode);
- _bufferPos += processed;
- return processed;
-}
-
-}}
+// BcjCoder.cpp
+
+#include "StdAfx.h"
+
+#include "BcjCoder.h"
+
+namespace NCompress {
+namespace NBcj {
+
+Z7_COM7F_IMF(CCoder2::Init())
+{
+ _pc = 0;
+ _state = Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt32, CCoder2::Filter(Byte *data, UInt32 size))
+{
+ const UInt32 processed = (UInt32)(size_t)(_convFunc(data, size, _pc, &_state) - data);
+ _pc += processed;
+ return processed;
+}
+
+}}
diff --git a/CPP/7zip/Compress/BcjCoder.h b/CPP/7zip/Compress/BcjCoder.h
index 475dfe5..734a278 100644
--- a/CPP/7zip/Compress/BcjCoder.h
+++ b/CPP/7zip/Compress/BcjCoder.h
@@ -1,31 +1,37 @@
-// BcjCoder.h
-
-#ifndef __COMPRESS_BCJ_CODER_H
-#define __COMPRESS_BCJ_CODER_H
-
-#include "../../../C/Bra.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NBcj {
-
-class CCoder:
- public ICompressFilter,
- public CMyUnknownImp
-{
- UInt32 _bufferPos;
- UInt32 _prevMask;
- int _encode;
-public:
- MY_UNKNOWN_IMP1(ICompressFilter);
- INTERFACE_ICompressFilter(;)
-
- CCoder(int encode): _bufferPos(0), _encode(encode) { x86_Convert_Init(_prevMask); }
-};
-
-}}
-
-#endif
+// BcjCoder.h
+
+#ifndef ZIP7_INC_COMPRESS_BCJ_CODER_H
+#define ZIP7_INC_COMPRESS_BCJ_CODER_H
+
+#include "../../../C/Bra.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NBcj {
+
+/* CCoder in old versions used another constructor parameter CCoder(int encode).
+ And some code called it as CCoder(0).
+ We have changed constructor parameter type.
+ So we have changed the name of class also to CCoder2. */
+
+Z7_CLASS_IMP_COM_1(
+ CCoder2
+ , ICompressFilter
+)
+ UInt32 _pc;
+ UInt32 _state;
+ z7_Func_BranchConvSt _convFunc;
+public:
+ CCoder2(z7_Func_BranchConvSt convFunc):
+ _pc(0),
+ _state(Z7_BRANCH_CONV_ST_X86_STATE_INIT_VAL),
+ _convFunc(convFunc)
+ {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/BcjRegister.cpp b/CPP/7zip/Compress/BcjRegister.cpp
index 48cc057..0348f64 100644
--- a/CPP/7zip/Compress/BcjRegister.cpp
+++ b/CPP/7zip/Compress/BcjRegister.cpp
@@ -1,17 +1,17 @@
-// BcjRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "BcjCoder.h"
-
-namespace NCompress {
-namespace NBcj {
-
-REGISTER_FILTER_E(BCJ,
- CCoder(false),
- CCoder(true),
- 0x3030103, "BCJ")
-
-}}
+// BcjRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "BcjCoder.h"
+
+namespace NCompress {
+namespace NBcj {
+
+REGISTER_FILTER_E(BCJ,
+ CCoder2(z7_BranchConvSt_X86_Dec),
+ CCoder2(z7_BranchConvSt_X86_Enc),
+ 0x3030103, "BCJ")
+
+}}
diff --git a/CPP/7zip/Compress/BitlDecoder.cpp b/CPP/7zip/Compress/BitlDecoder.cpp
new file mode 100644
index 0000000..876e649
--- /dev/null
+++ b/CPP/7zip/Compress/BitlDecoder.cpp
@@ -0,0 +1,25 @@
+// BitlDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "BitlDecoder.h"
+
+namespace NBitl {
+
+Byte kInvertTable[256];
+
+static
+struct CInverterTableInitializer
+{
+ CInverterTableInitializer()
+ {
+ for (unsigned i = 0; i < 256; i++)
+ {
+ unsigned x = ((i & 0x55) << 1) | ((i & 0xAA) >> 1);
+ x = ((x & 0x33) << 2) | ((x & 0xCC) >> 2);
+ kInvertTable[i] = (Byte)(((x & 0x0F) << 4) | ((x & 0xF0) >> 4));
+ }
+ }
+} g_InverterTableInitializer;
+
+}
diff --git a/CPP/7zip/Compress/BitlDecoder.h b/CPP/7zip/Compress/BitlDecoder.h
new file mode 100644
index 0000000..789ad1f
--- /dev/null
+++ b/CPP/7zip/Compress/BitlDecoder.h
@@ -0,0 +1,172 @@
+// BitlDecoder.h -- the Least Significant Bit of byte is First
+
+#ifndef ZIP7_INC_BITL_DECODER_H
+#define ZIP7_INC_BITL_DECODER_H
+
+#include "../IStream.h"
+
+namespace NBitl {
+
+const unsigned kNumBigValueBits = 8 * 4;
+const unsigned kNumValueBytes = 3;
+const unsigned kNumValueBits = 8 * kNumValueBytes;
+
+const UInt32 kMask = (1 << kNumValueBits) - 1;
+
+extern Byte kInvertTable[256];
+
+/* TInByte must support "Extra Bytes" (bytes that can be read after the end of stream
+ TInByte::ReadByte() returns 0xFF after the end of stream
+ TInByte::NumExtraBytes contains the number "Extra Bytes"
+
+ Bitl decoder can read up to 4 bytes ahead to internal buffer. */
+
+template<class TInByte>
+class CBaseDecoder
+{
+protected:
+ unsigned _bitPos;
+ UInt32 _value;
+ TInByte _stream;
+public:
+ bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+ void SetStream(ISequentialInStream *inStream) { _stream.SetStream(inStream); }
+ void Init()
+ {
+ _stream.Init();
+ _bitPos = kNumBigValueBits;
+ _value = 0;
+ }
+
+ // the size of portion data in real stream that was already read from this object.
+ // it doesn't include unused data in BitStream object buffer (up to 4 bytes)
+ // it doesn't include unused data in TInByte buffers
+ // it doesn't include virtual Extra bytes after the end of real stream data
+ UInt64 GetStreamSize() const
+ {
+ return ExtraBitsWereRead() ?
+ _stream.GetStreamSize():
+ GetProcessedSize();
+ }
+
+ // the size of virtual data that was read from this object.
+ UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
+
+ bool ThereAreDataInBitsBuffer() const { return this->_bitPos != kNumBigValueBits; }
+
+ Z7_FORCE_INLINE
+ void Normalize()
+ {
+ for (; _bitPos >= 8; _bitPos -= 8)
+ _value = ((UInt32)_stream.ReadByte() << (kNumBigValueBits - _bitPos)) | _value;
+ }
+
+ Z7_FORCE_INLINE
+ UInt32 ReadBits(unsigned numBits)
+ {
+ Normalize();
+ UInt32 res = _value & ((1 << numBits) - 1);
+ _bitPos += numBits;
+ _value >>= numBits;
+ return res;
+ }
+
+ bool ExtraBitsWereRead() const
+ {
+ return (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+ }
+
+ bool ExtraBitsWereRead_Fast() const
+ {
+ // full version is not inlined in vc6.
+ // return _stream.NumExtraBytes != 0 && (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+
+ // (_stream.NumExtraBytes > 4) is fast overread detection. It's possible that
+ // it doesn't return true, if small number of extra bits were read.
+ return (_stream.NumExtraBytes > 4);
+ }
+
+ // it must be fixed !!! with extra bits
+ // UInt32 GetNumExtraBytes() const { return _stream.NumExtraBytes; }
+};
+
+template<class TInByte>
+class CDecoder: public CBaseDecoder<TInByte>
+{
+ UInt32 _normalValue;
+
+public:
+ void Init()
+ {
+ CBaseDecoder<TInByte>::Init();
+ _normalValue = 0;
+ }
+
+ Z7_FORCE_INLINE
+ void Normalize()
+ {
+ for (; this->_bitPos >= 8; this->_bitPos -= 8)
+ {
+ Byte b = this->_stream.ReadByte();
+ _normalValue = ((UInt32)b << (kNumBigValueBits - this->_bitPos)) | _normalValue;
+ this->_value = (this->_value << 8) | kInvertTable[b];
+ }
+ }
+
+ Z7_FORCE_INLINE
+ UInt32 GetValue(unsigned numBits)
+ {
+ Normalize();
+ return ((this->_value >> (8 - this->_bitPos)) & kMask) >> (kNumValueBits - numBits);
+ }
+
+ Z7_FORCE_INLINE
+ void MovePos(unsigned numBits)
+ {
+ this->_bitPos += numBits;
+ _normalValue >>= numBits;
+ }
+
+ Z7_FORCE_INLINE
+ UInt32 ReadBits(unsigned numBits)
+ {
+ Normalize();
+ UInt32 res = _normalValue & ((1 << numBits) - 1);
+ MovePos(numBits);
+ return res;
+ }
+
+ void AlignToByte() { MovePos((32 - this->_bitPos) & 7); }
+
+ Z7_FORCE_INLINE
+ Byte ReadDirectByte() { return this->_stream.ReadByte(); }
+
+ Z7_FORCE_INLINE
+ Byte ReadAlignedByte()
+ {
+ if (this->_bitPos == kNumBigValueBits)
+ return this->_stream.ReadByte();
+ Byte b = (Byte)(_normalValue & 0xFF);
+ MovePos(8);
+ return b;
+ }
+
+ // call it only if the object is aligned for byte.
+ Z7_FORCE_INLINE
+ bool ReadAlignedByte_FromBuf(Byte &b)
+ {
+ if (this->_stream.NumExtraBytes != 0)
+ if (this->_stream.NumExtraBytes >= 4
+ || kNumBigValueBits - this->_bitPos <= (this->_stream.NumExtraBytes << 3))
+ return false;
+ if (this->_bitPos == kNumBigValueBits)
+ return this->_stream.ReadByte_FromBuf(b);
+ b = (Byte)(_normalValue & 0xFF);
+ MovePos(8);
+ return true;
+ }
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/Compress/BitlEncoder.h b/CPP/7zip/Compress/BitlEncoder.h
new file mode 100644
index 0000000..67b1428
--- /dev/null
+++ b/CPP/7zip/Compress/BitlEncoder.h
@@ -0,0 +1,56 @@
+// BitlEncoder.h -- the Least Significant Bit of byte is First
+
+#ifndef ZIP7_INC_BITL_ENCODER_H
+#define ZIP7_INC_BITL_ENCODER_H
+
+#include "../Common/OutBuffer.h"
+
+class CBitlEncoder
+{
+ COutBuffer _stream;
+ unsigned _bitPos;
+ Byte _curByte;
+public:
+ bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+ void SetStream(ISequentialOutStream *outStream) { _stream.SetStream(outStream); }
+ // unsigned GetBitPosition() const { return (8 - _bitPos); }
+ UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() + ((8 - _bitPos + 7) >> 3); }
+ void Init()
+ {
+ _stream.Init();
+ _bitPos = 8;
+ _curByte = 0;
+ }
+ HRESULT Flush()
+ {
+ FlushByte();
+ return _stream.Flush();
+ }
+ void FlushByte()
+ {
+ if (_bitPos < 8)
+ _stream.WriteByte(_curByte);
+ _bitPos = 8;
+ _curByte = 0;
+ }
+ void WriteBits(UInt32 value, unsigned numBits)
+ {
+ while (numBits > 0)
+ {
+ if (numBits < _bitPos)
+ {
+ _curByte |= (Byte)((value & ((1 << numBits) - 1)) << (8 - _bitPos));
+ _bitPos -= numBits;
+ return;
+ }
+ numBits -= _bitPos;
+ _stream.WriteByte((Byte)(_curByte | (value << (8 - _bitPos))));
+ value >>= _bitPos;
+ _bitPos = 8;
+ _curByte = 0;
+ }
+ }
+ void WriteByte(Byte b) { _stream.WriteByte(b);}
+};
+
+#endif
diff --git a/CPP/7zip/Compress/BitmDecoder.h b/CPP/7zip/Compress/BitmDecoder.h
new file mode 100644
index 0000000..199a228
--- /dev/null
+++ b/CPP/7zip/Compress/BitmDecoder.h
@@ -0,0 +1,100 @@
+// BitmDecoder.h -- the Most Significant Bit of byte is First
+
+#ifndef ZIP7_INC_BITM_DECODER_H
+#define ZIP7_INC_BITM_DECODER_H
+
+#include "../IStream.h"
+
+namespace NBitm {
+
+const unsigned kNumBigValueBits = 8 * 4;
+const unsigned kNumValueBytes = 3;
+const unsigned kNumValueBits = 8 * kNumValueBytes;
+
+const UInt32 kMask = (1 << kNumValueBits) - 1;
+
+// _bitPos - the number of free bits (high bits in _value)
+// (kNumBigValueBits - _bitPos) = (32 - _bitPos) == the number of ready to read bits (low bits of _value)
+
+template<class TInByte>
+class CDecoder
+{
+ unsigned _bitPos;
+ UInt32 _value;
+ TInByte _stream;
+public:
+ bool Create(UInt32 bufSize) { return _stream.Create(bufSize); }
+ void SetStream(ISequentialInStream *inStream) { _stream.SetStream(inStream);}
+
+ void Init()
+ {
+ _stream.Init();
+ _bitPos = kNumBigValueBits;
+ _value = 0;
+ Normalize();
+ }
+
+ UInt64 GetStreamSize() const { return _stream.GetStreamSize(); }
+ UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() - ((kNumBigValueBits - _bitPos) >> 3); }
+
+ bool ExtraBitsWereRead() const
+ {
+ return (_stream.NumExtraBytes > 4 || kNumBigValueBits - _bitPos < (_stream.NumExtraBytes << 3));
+ }
+
+ bool ExtraBitsWereRead_Fast() const
+ {
+ return (_stream.NumExtraBytes > 4);
+ }
+
+ Z7_FORCE_INLINE
+ void Normalize()
+ {
+ for (; _bitPos >= 8; _bitPos -= 8)
+ _value = (_value << 8) | _stream.ReadByte();
+ }
+
+ Z7_FORCE_INLINE
+ UInt32 GetValue(unsigned numBits) const
+ {
+ // return (_value << _bitPos) >> (kNumBigValueBits - numBits);
+ return ((_value >> (8 - _bitPos)) & kMask) >> (kNumValueBits - numBits);
+ }
+
+ Z7_FORCE_INLINE
+ void MovePos(unsigned numBits)
+ {
+ _bitPos += numBits;
+ Normalize();
+ }
+
+ Z7_FORCE_INLINE
+ UInt32 ReadBits(unsigned numBits)
+ {
+ UInt32 res = GetValue(numBits);
+ MovePos(numBits);
+ return res;
+ }
+
+ /*
+ unsigned ReadBit()
+ {
+ UInt32 res = ((_value >> (8 - _bitPos)) & kMask) >> (kNumValueBits - 1);
+ if (++_bitPos >= 8)
+ {
+ _value = (_value << 8) | _stream.ReadByte();
+ _bitPos -= 8;
+ }
+ return (unsigned)res;
+ }
+ */
+
+ void AlignToByte() { MovePos((kNumBigValueBits - _bitPos) & 7); }
+
+ Z7_FORCE_INLINE
+ UInt32 ReadAlignBits() { return ReadBits((kNumBigValueBits - _bitPos) & 7); }
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/Compress/BitmEncoder.h b/CPP/7zip/Compress/BitmEncoder.h
new file mode 100644
index 0000000..978ee1c
--- /dev/null
+++ b/CPP/7zip/Compress/BitmEncoder.h
@@ -0,0 +1,49 @@
+// BitmEncoder.h -- the Most Significant Bit of byte is First
+
+#ifndef ZIP7_INC_BITM_ENCODER_H
+#define ZIP7_INC_BITM_ENCODER_H
+
+#include "../IStream.h"
+
+template<class TOutByte>
+class CBitmEncoder
+{
+ unsigned _bitPos;
+ Byte _curByte;
+ TOutByte _stream;
+public:
+ bool Create(UInt32 bufferSize) { return _stream.Create(bufferSize); }
+ void SetStream(ISequentialOutStream *outStream) { _stream.SetStream(outStream);}
+ UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() + ((8 - _bitPos + 7) >> 3); }
+ void Init()
+ {
+ _stream.Init();
+ _bitPos = 8;
+ _curByte = 0;
+ }
+ HRESULT Flush()
+ {
+ if (_bitPos < 8)
+ WriteBits(0, _bitPos);
+ return _stream.Flush();
+ }
+ void WriteBits(UInt32 value, unsigned numBits)
+ {
+ while (numBits > 0)
+ {
+ if (numBits < _bitPos)
+ {
+ _curByte = (Byte)(_curByte | (value << (_bitPos -= numBits)));
+ return;
+ }
+ numBits -= _bitPos;
+ UInt32 newBits = (value >> numBits);
+ value -= (newBits << numBits);
+ _stream.WriteByte((Byte)(_curByte | newBits));
+ _bitPos = 8;
+ _curByte = 0;
+ }
+ }
+};
+
+#endif
diff --git a/CPP/7zip/Compress/BranchMisc.cpp b/CPP/7zip/Compress/BranchMisc.cpp
index d5a90f1..d9fec8c 100644
--- a/CPP/7zip/Compress/BranchMisc.cpp
+++ b/CPP/7zip/Compress/BranchMisc.cpp
@@ -1,23 +1,110 @@
-// BranchMisc.cpp
-
-#include "StdAfx.h"
-
-#include "BranchMisc.h"
-
-namespace NCompress {
-namespace NBranch {
-
-STDMETHODIMP CCoder::Init()
-{
- _bufferPos = 0;
- return S_OK;
-}
-
-STDMETHODIMP_(UInt32) CCoder::Filter(Byte *data, UInt32 size)
-{
- UInt32 processed = (UInt32)BraFunc(data, size, _bufferPos, _encode);
- _bufferPos += processed;
- return processed;
-}
-
-}}
+// BranchMisc.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "BranchMisc.h"
+
+namespace NCompress {
+namespace NBranch {
+
+Z7_COM7F_IMF(CCoder::Init())
+{
+ _pc = 0;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF2(UInt32, CCoder::Filter(Byte *data, UInt32 size))
+{
+ const UInt32 processed = (UInt32)(size_t)(BraFunc(data, size, _pc) - data);
+ _pc += processed;
+ return processed;
+}
+
+
+namespace NArm64 {
+
+#ifndef Z7_EXTRACT_ONLY
+
+Z7_COM7F_IMF(CEncoder::Init())
+{
+ _pc = _pc_Init;
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt32, CEncoder::Filter(Byte *data, UInt32 size))
+{
+ const UInt32 processed = (UInt32)(size_t)(Z7_BRANCH_CONV_ENC(ARM64)(data, size, _pc) - data);
+ _pc += processed;
+ return processed;
+}
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+{
+ UInt32 pc = 0;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPID propID = propIDs[i];
+ if (propID == NCoderPropID::kDefaultProp ||
+ propID == NCoderPropID::kBranchOffset)
+ {
+ const PROPVARIANT &prop = props[i];
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ pc = prop.ulVal;
+ if ((pc & 3) != 0)
+ return E_INVALIDARG;
+ }
+ }
+ _pc_Init = pc;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+{
+ if (_pc_Init == 0)
+ return S_OK;
+ Byte buf[4];
+ SetUi32(buf, _pc_Init)
+ return WriteStream(outStream, buf, 4);
+}
+
+#endif
+
+
+Z7_COM7F_IMF(CDecoder::Init())
+{
+ _pc = _pc_Init;
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+{
+ const UInt32 processed = (UInt32)(size_t)(Z7_BRANCH_CONV_DEC(ARM64)(data, size, _pc) - data);
+ _pc += processed;
+ return processed;
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size))
+{
+ UInt32 val = 0;
+ if (size != 0)
+ {
+ if (size != 4)
+ return E_NOTIMPL;
+ val = GetUi32(props);
+ if ((val & 3) != 0)
+ return E_NOTIMPL;
+ }
+ _pc_Init = val;
+ return S_OK;
+}
+
+}
+
+}}
diff --git a/CPP/7zip/Compress/BranchMisc.h b/CPP/7zip/Compress/BranchMisc.h
index 02a56c3..a5793f7 100644
--- a/CPP/7zip/Compress/BranchMisc.h
+++ b/CPP/7zip/Compress/BranchMisc.h
@@ -1,35 +1,57 @@
-// BranchMisc.h
-
-#ifndef __COMPRESS_BRANCH_MISC_H
-#define __COMPRESS_BRANCH_MISC_H
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-EXTERN_C_BEGIN
-
-typedef SizeT (*Func_Bra)(Byte *data, SizeT size, UInt32 ip, int encoding);
-
-EXTERN_C_END
-
-namespace NCompress {
-namespace NBranch {
-
-class CCoder:
- public ICompressFilter,
- public CMyUnknownImp
-{
- UInt32 _bufferPos;
- int _encode;
- Func_Bra BraFunc;
-public:
- MY_UNKNOWN_IMP1(ICompressFilter);
- INTERFACE_ICompressFilter(;)
-
- CCoder(Func_Bra bra, int encode): _bufferPos(0), _encode(encode), BraFunc(bra) {}
-};
-
-}}
-
-#endif
+// BranchMisc.h
+
+#ifndef ZIP7_INC_COMPRESS_BRANCH_MISC_H
+#define ZIP7_INC_COMPRESS_BRANCH_MISC_H
+#include "../../../C/Bra.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NBranch {
+
+Z7_CLASS_IMP_COM_1(
+ CCoder
+ , ICompressFilter
+)
+ UInt32 _pc;
+ z7_Func_BranchConv BraFunc;
+public:
+ CCoder(z7_Func_BranchConv bra): _pc(0), BraFunc(bra) {}
+};
+
+namespace NArm64 {
+
+#ifndef Z7_EXTRACT_ONLY
+
+Z7_CLASS_IMP_COM_3(
+ CEncoder
+ , ICompressFilter
+ , ICompressSetCoderProperties
+ , ICompressWriteCoderProperties
+)
+ UInt32 _pc;
+ UInt32 _pc_Init;
+public:
+ CEncoder(): _pc(0), _pc_Init(0) {}
+};
+
+#endif
+
+Z7_CLASS_IMP_COM_2(
+ CDecoder
+ , ICompressFilter
+ , ICompressSetDecoderProperties2
+)
+ UInt32 _pc;
+ UInt32 _pc_Init;
+public:
+ CDecoder(): _pc(0), _pc_Init(0) {}
+};
+
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/BranchRegister.cpp b/CPP/7zip/Compress/BranchRegister.cpp
index b83c6bc..80fbf60 100644
--- a/CPP/7zip/Compress/BranchRegister.cpp
+++ b/CPP/7zip/Compress/BranchRegister.cpp
@@ -1,41 +1,55 @@
-// BranchRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Bra.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "BranchMisc.h"
-
-namespace NCompress {
-namespace NBranch {
-
-#define CREATE_BRA(n) \
- REGISTER_FILTER_CREATE(CreateBra_Decoder_ ## n, CCoder(n ## _Convert, false)) \
- REGISTER_FILTER_CREATE(CreateBra_Encoder_ ## n, CCoder(n ## _Convert, true)) \
-
-CREATE_BRA(PPC)
-CREATE_BRA(IA64)
-CREATE_BRA(ARM)
-CREATE_BRA(ARMT)
-CREATE_BRA(SPARC)
-
-#define METHOD_ITEM(n, id, name) \
- REGISTER_FILTER_ITEM( \
- CreateBra_Decoder_ ## n, \
- CreateBra_Encoder_ ## n, \
- 0x3030000 + id, name)
-
-REGISTER_CODECS_VAR
-{
- METHOD_ITEM(PPC, 0x205, "PPC"),
- METHOD_ITEM(IA64, 0x401, "IA64"),
- METHOD_ITEM(ARM, 0x501, "ARM"),
- METHOD_ITEM(ARMT, 0x701, "ARMT"),
- METHOD_ITEM(SPARC, 0x805, "SPARC")
-};
-
-REGISTER_CODECS(Branch)
-
-}}
+// BranchRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "BranchMisc.h"
+
+namespace NCompress {
+namespace NBranch {
+
+#ifdef Z7_EXTRACT_ONLY
+#define GET_CREATE_FUNC(x) NULL
+#define CREATE_BRA_E(n)
+#else
+#define GET_CREATE_FUNC(x) x
+#define CREATE_BRA_E(n) \
+ REGISTER_FILTER_CREATE(CreateBra_Encoder_ ## n, CCoder(Z7_BRANCH_CONV_ENC(n)))
+#endif
+
+#define CREATE_BRA(n) \
+ REGISTER_FILTER_CREATE(CreateBra_Decoder_ ## n, CCoder(Z7_BRANCH_CONV_DEC(n))) \
+ CREATE_BRA_E(n)
+
+CREATE_BRA(PPC)
+CREATE_BRA(IA64)
+CREATE_BRA(ARM)
+CREATE_BRA(ARMT)
+CREATE_BRA(SPARC)
+
+#define METHOD_ITEM(n, id, name) \
+ REGISTER_FILTER_ITEM( \
+ CreateBra_Decoder_ ## n, GET_CREATE_FUNC( \
+ CreateBra_Encoder_ ## n), \
+ 0x3030000 + id, name)
+
+REGISTER_CODECS_VAR
+{
+ METHOD_ITEM(PPC, 0x205, "PPC"),
+ METHOD_ITEM(IA64, 0x401, "IA64"),
+ METHOD_ITEM(ARM, 0x501, "ARM"),
+ METHOD_ITEM(ARMT, 0x701, "ARMT"),
+ METHOD_ITEM(SPARC, 0x805, "SPARC")
+};
+
+REGISTER_CODECS(Branch)
+
+namespace NArm64 {
+REGISTER_FILTER_E(ARM64,
+ CDecoder(),
+ CEncoder(),
+ 0xa, "ARM64")
+}
+
+}}
diff --git a/CPP/7zip/Compress/ByteSwap.cpp b/CPP/7zip/Compress/ByteSwap.cpp
index ee103af..cc28d8b 100644
--- a/CPP/7zip/Compress/ByteSwap.cpp
+++ b/CPP/7zip/Compress/ByteSwap.cpp
@@ -1,92 +1,91 @@
-// ByteSwap.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-#include "../Common/RegisterCodec.h"
-
-namespace NCompress {
-namespace NByteSwap {
-
-class CByteSwap2:
- public ICompressFilter,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(ICompressFilter);
- INTERFACE_ICompressFilter(;)
-};
-
-class CByteSwap4:
- public ICompressFilter,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(ICompressFilter);
- INTERFACE_ICompressFilter(;)
-};
-
-STDMETHODIMP CByteSwap2::Init() { return S_OK; }
-
-STDMETHODIMP_(UInt32) CByteSwap2::Filter(Byte *data, UInt32 size)
-{
- const UInt32 kStep = 2;
- if (size < kStep)
- return 0;
- size &= ~(kStep - 1);
-
- const Byte *end = data + (size_t)size;
-
- do
- {
- Byte b0 = data[0];
- data[0] = data[1];
- data[1] = b0;
- data += kStep;
- }
- while (data != end);
-
- return size;
-}
-
-STDMETHODIMP CByteSwap4::Init() { return S_OK; }
-
-STDMETHODIMP_(UInt32) CByteSwap4::Filter(Byte *data, UInt32 size)
-{
- const UInt32 kStep = 4;
- if (size < kStep)
- return 0;
- size &= ~(kStep - 1);
-
- const Byte *end = data + (size_t)size;
-
- do
- {
- Byte b0 = data[0];
- Byte b1 = data[1];
- data[0] = data[3];
- data[1] = data[2];
- data[2] = b1;
- data[3] = b0;
- data += kStep;
- }
- while (data != end);
-
- return size;
-}
-
-REGISTER_FILTER_CREATE(CreateFilter2, CByteSwap2())
-REGISTER_FILTER_CREATE(CreateFilter4, CByteSwap4())
-
-REGISTER_CODECS_VAR
-{
- REGISTER_FILTER_ITEM(CreateFilter2, CreateFilter2, 0x20302, "Swap2"),
- REGISTER_FILTER_ITEM(CreateFilter4, CreateFilter4, 0x20304, "Swap4")
-};
-
-REGISTER_CODECS(ByteSwap)
-
-}}
+// ByteSwap.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/SwapBytes.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+namespace NCompress {
+namespace NByteSwap {
+
+Z7_CLASS_IMP_COM_1(CByteSwap2, ICompressFilter) };
+Z7_CLASS_IMP_COM_1(CByteSwap4, ICompressFilter) };
+
+Z7_COM7F_IMF(CByteSwap2::Init()) { return S_OK; }
+
+Z7_COM7F_IMF2(UInt32, CByteSwap2::Filter(Byte *data, UInt32 size))
+{
+ const UInt32 kMask = 2 - 1;
+ size &= ~kMask;
+ /*
+ if ((unsigned)(ptrdiff_t)data & kMask)
+ {
+ if (size == 0)
+ return 0;
+ const Byte *end = data + (size_t)size;
+ do
+ {
+ const Byte b0 = data[0];
+ data[0] = data[1];
+ data[1] = b0;
+ data += kStep;
+ }
+ while (data != end);
+ }
+ else
+ */
+ z7_SwapBytes2((UInt16 *)(void *)data, size >> 1);
+ return size;
+}
+
+
+Z7_COM7F_IMF(CByteSwap4::Init()) { return S_OK; }
+
+Z7_COM7F_IMF2(UInt32, CByteSwap4::Filter(Byte *data, UInt32 size))
+{
+ const UInt32 kMask = 4 - 1;
+ size &= ~kMask;
+ /*
+ if ((unsigned)(ptrdiff_t)data & kMask)
+ {
+ if (size == 0)
+ return 0;
+ const Byte *end = data + (size_t)size;
+ do
+ {
+ const Byte b0 = data[0];
+ const Byte b1 = data[1];
+ data[0] = data[3];
+ data[1] = data[2];
+ data[2] = b1;
+ data[3] = b0;
+ data += kStep;
+ }
+ while (data != end);
+ }
+ else
+ */
+ z7_SwapBytes4((UInt32 *)(void *)data, size >> 2);
+ return size;
+}
+
+static struct C_SwapBytesPrepare { C_SwapBytesPrepare() { z7_SwapBytesPrepare(); } } g_SwapBytesPrepare;
+
+
+REGISTER_FILTER_CREATE(CreateFilter2, CByteSwap2())
+REGISTER_FILTER_CREATE(CreateFilter4, CByteSwap4())
+
+REGISTER_CODECS_VAR
+{
+ REGISTER_FILTER_ITEM(CreateFilter2, CreateFilter2, 0x20302, "Swap2"),
+ REGISTER_FILTER_ITEM(CreateFilter4, CreateFilter4, 0x20304, "Swap4"),
+};
+
+REGISTER_CODECS(ByteSwap)
+
+}}
diff --git a/CPP/7zip/Compress/Codec.def b/CPP/7zip/Compress/Codec.def
new file mode 100644
index 0000000..e2bc0df
--- /dev/null
+++ b/CPP/7zip/Compress/Codec.def
@@ -0,0 +1,7 @@
+EXPORTS
+ CreateObject PRIVATE
+ GetNumberOfMethods PRIVATE
+ GetMethodProperty PRIVATE
+ CreateDecoder PRIVATE
+ CreateEncoder PRIVATE
+ GetModuleProp PRIVATE
diff --git a/CPP/7zip/Compress/CodecExports.cpp b/CPP/7zip/Compress/CodecExports.cpp
index 7be496c..e37ae14 100644
--- a/CPP/7zip/Compress/CodecExports.cpp
+++ b/CPP/7zip/Compress/CodecExports.cpp
@@ -1,344 +1,378 @@
-// CodecExports.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/CpuArch.h"
-
-#include "../../Common/ComTry.h"
-#include "../../Common/MyCom.h"
-
-#include "../../Windows/Defs.h"
-
-#include "../ICoder.h"
-
-#include "../Common/RegisterCodec.h"
-
-extern unsigned g_NumCodecs;
-extern const CCodecInfo *g_Codecs[];
-
-extern unsigned g_NumHashers;
-extern const CHasherInfo *g_Hashers[];
-
-static void SetPropFromAscii(const char *s, PROPVARIANT *prop) throw()
-{
- UINT len = (UINT)strlen(s);
- BSTR dest = ::SysAllocStringLen(NULL, len);
- if (dest)
- {
- for (UINT i = 0; i <= len; i++)
- dest[i] = (Byte)s[i];
- prop->bstrVal = dest;
- prop->vt = VT_BSTR;
- }
-}
-
-static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value) throw()
-{
- if ((value->bstrVal = ::SysAllocStringByteLen((const char *)&guid, sizeof(guid))) != NULL)
- value->vt = VT_BSTR;
- return S_OK;
-}
-
-static HRESULT MethodToClassID(UInt16 typeId, CMethodId id, PROPVARIANT *value) throw()
-{
- GUID clsId;
- clsId.Data1 = k_7zip_GUID_Data1;
- clsId.Data2 = k_7zip_GUID_Data2;
- clsId.Data3 = typeId;
- SetUi64(clsId.Data4, id);
- return SetPropGUID(clsId, value);
-}
-
-static HRESULT FindCodecClassId(const GUID *clsid, bool isCoder2, bool isFilter, bool &encode, int &index) throw()
-{
- index = -1;
- if (clsid->Data1 != k_7zip_GUID_Data1 ||
- clsid->Data2 != k_7zip_GUID_Data2)
- return S_OK;
-
- encode = true;
-
- if (clsid->Data3 == k_7zip_GUID_Data3_Decoder) encode = false;
- else if (clsid->Data3 != k_7zip_GUID_Data3_Encoder) return S_OK;
-
- UInt64 id = GetUi64(clsid->Data4);
-
- for (unsigned i = 0; i < g_NumCodecs; i++)
- {
- const CCodecInfo &codec = *g_Codecs[i];
-
- if (id != codec.Id
- || (encode ? !codec.CreateEncoder : !codec.CreateDecoder)
- || (isFilter ? !codec.IsFilter : codec.IsFilter))
- continue;
-
- if (codec.NumStreams == 1 ? isCoder2 : !isCoder2)
- return E_NOINTERFACE;
-
- index = i;
- return S_OK;
- }
-
- return S_OK;
-}
-
-static HRESULT CreateCoderMain(unsigned index, bool encode, void **coder)
-{
- COM_TRY_BEGIN
-
- const CCodecInfo &codec = *g_Codecs[index];
-
- void *c;
- if (encode)
- c = codec.CreateEncoder();
- else
- c = codec.CreateDecoder();
-
- if (c)
- {
- IUnknown *unk;
- if (codec.IsFilter)
- unk = (IUnknown *)(ICompressFilter *)c;
- else if (codec.NumStreams != 1)
- unk = (IUnknown *)(ICompressCoder2 *)c;
- else
- unk = (IUnknown *)(ICompressCoder *)c;
- unk->AddRef();
- *coder = c;
- }
- return S_OK;
-
- COM_TRY_END
-}
-
-static HRESULT CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **outObject)
-{
- *outObject = NULL;
-
- const CCodecInfo &codec = *g_Codecs[index];
-
- if (encode ? !codec.CreateEncoder : !codec.CreateDecoder)
- return CLASS_E_CLASSNOTAVAILABLE;
-
- if (codec.IsFilter)
- {
- if (*iid != IID_ICompressFilter) return E_NOINTERFACE;
- }
- else if (codec.NumStreams != 1)
- {
- if (*iid != IID_ICompressCoder2) return E_NOINTERFACE;
- }
- else
- {
- if (*iid != IID_ICompressCoder) return E_NOINTERFACE;
- }
-
- return CreateCoderMain(index, encode, outObject);
-}
-
-STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject)
-{
- return CreateCoder2(false, index, iid, outObject);
-}
-
-STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject)
-{
- return CreateCoder2(true, index, iid, outObject);
-}
-
-STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
-{
- *outObject = NULL;
-
- bool isFilter = false;
- bool isCoder2 = false;
- bool isCoder = (*iid == IID_ICompressCoder) != 0;
- if (!isCoder)
- {
- isFilter = (*iid == IID_ICompressFilter) != 0;
- if (!isFilter)
- {
- isCoder2 = (*iid == IID_ICompressCoder2) != 0;
- if (!isCoder2)
- return E_NOINTERFACE;
- }
- }
-
- bool encode;
- int codecIndex;
- HRESULT res = FindCodecClassId(clsid, isCoder2, isFilter, encode, codecIndex);
- if (res != S_OK)
- return res;
- if (codecIndex < 0)
- return CLASS_E_CLASSNOTAVAILABLE;
-
- return CreateCoderMain(codecIndex, encode, outObject);
-}
-
-STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
-{
- ::VariantClear((VARIANTARG *)value);
- const CCodecInfo &codec = *g_Codecs[codecIndex];
- switch (propID)
- {
- case NMethodPropID::kID:
- value->uhVal.QuadPart = (UInt64)codec.Id;
- value->vt = VT_UI8;
- break;
- case NMethodPropID::kName:
- SetPropFromAscii(codec.Name, value);
- break;
- case NMethodPropID::kDecoder:
- if (codec.CreateDecoder)
- return MethodToClassID(k_7zip_GUID_Data3_Decoder, codec.Id, value);
- break;
- case NMethodPropID::kEncoder:
- if (codec.CreateEncoder)
- return MethodToClassID(k_7zip_GUID_Data3_Encoder, codec.Id, value);
- break;
- case NMethodPropID::kDecoderIsAssigned:
- value->vt = VT_BOOL;
- value->boolVal = BoolToVARIANT_BOOL(codec.CreateDecoder != NULL);
- break;
- case NMethodPropID::kEncoderIsAssigned:
- value->vt = VT_BOOL;
- value->boolVal = BoolToVARIANT_BOOL(codec.CreateEncoder != NULL);
- break;
- case NMethodPropID::kPackStreams:
- if (codec.NumStreams != 1)
- {
- value->vt = VT_UI4;
- value->ulVal = (ULONG)codec.NumStreams;
- }
- break;
- /*
- case NMethodPropID::kIsFilter:
- // if (codec.IsFilter)
- {
- value->vt = VT_BOOL;
- value->boolVal = BoolToVARIANT_BOOL(codec.IsFilter);
- }
- break;
- */
- /*
- case NMethodPropID::kDecoderFlags:
- {
- value->vt = VT_UI4;
- value->ulVal = (ULONG)codec.DecoderFlags;
- }
- break;
- case NMethodPropID::kEncoderFlags:
- {
- value->vt = VT_UI4;
- value->ulVal = (ULONG)codec.EncoderFlags;
- }
- break;
- */
- }
- return S_OK;
-}
-
-STDAPI GetNumberOfMethods(UINT32 *numCodecs)
-{
- *numCodecs = g_NumCodecs;
- return S_OK;
-}
-
-
-// ---------- Hashers ----------
-
-static int FindHasherClassId(const GUID *clsid) throw()
-{
- if (clsid->Data1 != k_7zip_GUID_Data1 ||
- clsid->Data2 != k_7zip_GUID_Data2 ||
- clsid->Data3 != k_7zip_GUID_Data3_Hasher)
- return -1;
- UInt64 id = GetUi64(clsid->Data4);
- for (unsigned i = 0; i < g_NumCodecs; i++)
- if (id == g_Hashers[i]->Id)
- return i;
- return -1;
-}
-
-static HRESULT CreateHasher2(UInt32 index, IHasher **hasher)
-{
- COM_TRY_BEGIN
- *hasher = g_Hashers[index]->CreateHasher();
- if (*hasher)
- (*hasher)->AddRef();
- return S_OK;
- COM_TRY_END
-}
-
-STDAPI CreateHasher(const GUID *clsid, IHasher **outObject)
-{
- COM_TRY_BEGIN
- *outObject = 0;
- int index = FindHasherClassId(clsid);
- if (index < 0)
- return CLASS_E_CLASSNOTAVAILABLE;
- return CreateHasher2(index, outObject);
- COM_TRY_END
-}
-
-STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
-{
- ::VariantClear((VARIANTARG *)value);
- const CHasherInfo &codec = *g_Hashers[codecIndex];
- switch (propID)
- {
- case NMethodPropID::kID:
- value->uhVal.QuadPart = (UInt64)codec.Id;
- value->vt = VT_UI8;
- break;
- case NMethodPropID::kName:
- SetPropFromAscii(codec.Name, value);
- break;
- case NMethodPropID::kEncoder:
- if (codec.CreateHasher)
- return MethodToClassID(k_7zip_GUID_Data3_Hasher, codec.Id, value);
- break;
- case NMethodPropID::kDigestSize:
- value->ulVal = (ULONG)codec.DigestSize;
- value->vt = VT_UI4;
- break;
- }
- return S_OK;
-}
-
-class CHashers:
- public IHashers,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(IHashers)
-
- STDMETHOD_(UInt32, GetNumHashers)();
- STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value);
- STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher);
-};
-
-STDAPI GetHashers(IHashers **hashers)
-{
- COM_TRY_BEGIN
- *hashers = new CHashers;
- if (*hashers)
- (*hashers)->AddRef();
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP_(UInt32) CHashers::GetNumHashers()
-{
- return g_NumHashers;
-}
-
-STDMETHODIMP CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- return ::GetHasherProp(index, propID, value);
-}
-
-STDMETHODIMP CHashers::CreateHasher(UInt32 index, IHasher **hasher)
-{
- return ::CreateHasher2(index, hasher);
-}
+// CodecExports.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/7zVersion.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyCom.h"
+
+#include "../../Windows/Defs.h"
+#include "../../Windows/PropVariant.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+extern unsigned g_NumCodecs;
+extern const CCodecInfo *g_Codecs[];
+
+extern unsigned g_NumHashers;
+extern const CHasherInfo *g_Hashers[];
+
+static void SetPropFromAscii(const char *s, PROPVARIANT *prop) throw()
+{
+ const UINT len = (UINT)strlen(s);
+ BSTR dest = ::SysAllocStringLen(NULL, len);
+ if (dest)
+ {
+ for (UINT i = 0; i <= len; i++)
+ dest[i] = (Byte)s[i];
+ prop->bstrVal = dest;
+ prop->vt = VT_BSTR;
+ }
+}
+
+static inline HRESULT SetPropGUID(const GUID &guid, PROPVARIANT *value) throw()
+{
+ if ((value->bstrVal = ::SysAllocStringByteLen((const char *)&guid, sizeof(guid))) != NULL)
+ value->vt = VT_BSTR;
+ return S_OK;
+}
+
+static HRESULT MethodToClassID(UInt16 typeId, CMethodId id, PROPVARIANT *value) throw()
+{
+ GUID clsId;
+ clsId.Data1 = k_7zip_GUID_Data1;
+ clsId.Data2 = k_7zip_GUID_Data2;
+ clsId.Data3 = typeId;
+ SetUi64(clsId.Data4, id)
+ return SetPropGUID(clsId, value);
+}
+
+static HRESULT FindCodecClassId(const GUID *clsid, bool isCoder2, bool isFilter, bool &encode, int &index) throw()
+{
+ index = -1;
+ if (clsid->Data1 != k_7zip_GUID_Data1 ||
+ clsid->Data2 != k_7zip_GUID_Data2)
+ return S_OK;
+
+ encode = true;
+
+ if (clsid->Data3 == k_7zip_GUID_Data3_Decoder) encode = false;
+ else if (clsid->Data3 != k_7zip_GUID_Data3_Encoder) return S_OK;
+
+ const UInt64 id = GetUi64(clsid->Data4);
+
+ for (unsigned i = 0; i < g_NumCodecs; i++)
+ {
+ const CCodecInfo &codec = *g_Codecs[i];
+
+ if (id != codec.Id
+ || (encode ? !codec.CreateEncoder : !codec.CreateDecoder)
+ || (isFilter ? !codec.IsFilter : codec.IsFilter))
+ continue;
+
+ if (codec.NumStreams == 1 ? isCoder2 : !isCoder2)
+ return E_NOINTERFACE;
+
+ index = (int)i;
+ return S_OK;
+ }
+
+ return S_OK;
+}
+
+/*
+#ifdef __GNUC__
+#ifndef __clang__
+#pragma GCC diagnostic ignored "-Wduplicated-branches"
+#endif
+#endif
+*/
+
+static HRESULT CreateCoderMain(unsigned index, bool encode, void **coder)
+{
+ COM_TRY_BEGIN
+
+ const CCodecInfo &codec = *g_Codecs[index];
+
+ void *c;
+ if (encode)
+ c = codec.CreateEncoder();
+ else
+ c = codec.CreateDecoder();
+
+ if (c)
+ {
+ IUnknown *unk;
+ unk = (IUnknown *)c;
+ /*
+ if (codec.IsFilter)
+ unk = (IUnknown *)(ICompressFilter *)c;
+ else if (codec.NumStreams != 1)
+ unk = (IUnknown *)(ICompressCoder2 *)c;
+ else
+ unk = (IUnknown *)(ICompressCoder *)c;
+ */
+ unk->AddRef();
+ *coder = c;
+ }
+ return S_OK;
+
+ COM_TRY_END
+}
+
+static HRESULT CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **outObject)
+{
+ *outObject = NULL;
+
+ const CCodecInfo &codec = *g_Codecs[index];
+
+ if (encode ? !codec.CreateEncoder : !codec.CreateDecoder)
+ return CLASS_E_CLASSNOTAVAILABLE;
+
+ if (codec.IsFilter)
+ {
+ if (*iid != IID_ICompressFilter) return E_NOINTERFACE;
+ }
+ else if (codec.NumStreams != 1)
+ {
+ if (*iid != IID_ICompressCoder2) return E_NOINTERFACE;
+ }
+ else
+ {
+ if (*iid != IID_ICompressCoder) return E_NOINTERFACE;
+ }
+
+ return CreateCoderMain(index, encode, outObject);
+}
+
+
+STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject);
+STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject)
+{
+ return CreateCoder2(false, index, iid, outObject);
+}
+
+
+STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject);
+STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject)
+{
+ return CreateCoder2(true, index, iid, outObject);
+}
+
+
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
+{
+ *outObject = NULL;
+
+ bool isFilter = false;
+ bool isCoder2 = false;
+ const bool isCoder = (*iid == IID_ICompressCoder) != 0;
+ if (!isCoder)
+ {
+ isFilter = (*iid == IID_ICompressFilter) != 0;
+ if (!isFilter)
+ {
+ isCoder2 = (*iid == IID_ICompressCoder2) != 0;
+ if (!isCoder2)
+ return E_NOINTERFACE;
+ }
+ }
+
+ bool encode;
+ int codecIndex;
+ const HRESULT res = FindCodecClassId(clsid, isCoder2, isFilter, encode, codecIndex);
+ if (res != S_OK)
+ return res;
+ if (codecIndex < 0)
+ return CLASS_E_CLASSNOTAVAILABLE;
+
+ return CreateCoderMain((unsigned)codecIndex, encode, outObject);
+}
+
+
+STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
+STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
+{
+ ::VariantClear((VARIANTARG *)value);
+ const CCodecInfo &codec = *g_Codecs[codecIndex];
+ switch (propID)
+ {
+ case NMethodPropID::kID:
+ value->uhVal.QuadPart = (UInt64)codec.Id;
+ value->vt = VT_UI8;
+ break;
+ case NMethodPropID::kName:
+ SetPropFromAscii(codec.Name, value);
+ break;
+ case NMethodPropID::kDecoder:
+ if (codec.CreateDecoder)
+ return MethodToClassID(k_7zip_GUID_Data3_Decoder, codec.Id, value);
+ break;
+ case NMethodPropID::kEncoder:
+ if (codec.CreateEncoder)
+ return MethodToClassID(k_7zip_GUID_Data3_Encoder, codec.Id, value);
+ break;
+ case NMethodPropID::kDecoderIsAssigned:
+ value->vt = VT_BOOL;
+ value->boolVal = BoolToVARIANT_BOOL(codec.CreateDecoder != NULL);
+ break;
+ case NMethodPropID::kEncoderIsAssigned:
+ value->vt = VT_BOOL;
+ value->boolVal = BoolToVARIANT_BOOL(codec.CreateEncoder != NULL);
+ break;
+ case NMethodPropID::kPackStreams:
+ if (codec.NumStreams != 1)
+ {
+ value->vt = VT_UI4;
+ value->ulVal = (ULONG)codec.NumStreams;
+ }
+ break;
+ case NMethodPropID::kIsFilter:
+ {
+ value->vt = VT_BOOL;
+ value->boolVal = BoolToVARIANT_BOOL(codec.IsFilter);
+ }
+ break;
+ /*
+ case NMethodPropID::kDecoderFlags:
+ {
+ value->vt = VT_UI4;
+ value->ulVal = (ULONG)codec.DecoderFlags;
+ }
+ break;
+ case NMethodPropID::kEncoderFlags:
+ {
+ value->vt = VT_UI4;
+ value->ulVal = (ULONG)codec.EncoderFlags;
+ }
+ break;
+ */
+ }
+ return S_OK;
+}
+
+
+STDAPI GetNumberOfMethods(UInt32 *numCodecs);
+STDAPI GetNumberOfMethods(UInt32 *numCodecs)
+{
+ *numCodecs = g_NumCodecs;
+ return S_OK;
+}
+
+
+// ---------- Hashers ----------
+
+static int FindHasherClassId(const GUID *clsid) throw()
+{
+ if (clsid->Data1 != k_7zip_GUID_Data1 ||
+ clsid->Data2 != k_7zip_GUID_Data2 ||
+ clsid->Data3 != k_7zip_GUID_Data3_Hasher)
+ return -1;
+ const UInt64 id = GetUi64(clsid->Data4);
+ for (unsigned i = 0; i < g_NumCodecs; i++)
+ if (id == g_Hashers[i]->Id)
+ return (int)i;
+ return -1;
+}
+
+static HRESULT CreateHasher2(UInt32 index, IHasher **hasher)
+{
+ COM_TRY_BEGIN
+ *hasher = g_Hashers[index]->CreateHasher();
+ if (*hasher)
+ (*hasher)->AddRef();
+ return S_OK;
+ COM_TRY_END
+}
+
+STDAPI CreateHasher(const GUID *clsid, IHasher **outObject);
+STDAPI CreateHasher(const GUID *clsid, IHasher **outObject)
+{
+ COM_TRY_BEGIN
+ *outObject = NULL;
+ const int index = FindHasherClassId(clsid);
+ if (index < 0)
+ return CLASS_E_CLASSNOTAVAILABLE;
+ return CreateHasher2((UInt32)(unsigned)index, outObject);
+ COM_TRY_END
+}
+
+STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
+STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
+{
+ ::VariantClear((VARIANTARG *)value);
+ const CHasherInfo &codec = *g_Hashers[codecIndex];
+ switch (propID)
+ {
+ case NMethodPropID::kID:
+ value->uhVal.QuadPart = (UInt64)codec.Id;
+ value->vt = VT_UI8;
+ break;
+ case NMethodPropID::kName:
+ SetPropFromAscii(codec.Name, value);
+ break;
+ case NMethodPropID::kEncoder:
+ if (codec.CreateHasher)
+ return MethodToClassID(k_7zip_GUID_Data3_Hasher, codec.Id, value);
+ break;
+ case NMethodPropID::kDigestSize:
+ value->ulVal = (ULONG)codec.DigestSize;
+ value->vt = VT_UI4;
+ break;
+ }
+ return S_OK;
+}
+
+Z7_CLASS_IMP_COM_1(CHashers, IHashers) };
+
+STDAPI GetHashers(IHashers **hashers);
+STDAPI GetHashers(IHashers **hashers)
+{
+ COM_TRY_BEGIN
+ *hashers = new CHashers;
+ if (*hashers)
+ (*hashers)->AddRef();
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF2(UInt32, CHashers::GetNumHashers())
+{
+ return g_NumHashers;
+}
+
+Z7_COM7F_IMF(CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ return ::GetHasherProp(index, propID, value);
+}
+
+Z7_COM7F_IMF(CHashers::CreateHasher(UInt32 index, IHasher **hasher))
+{
+ return ::CreateHasher2(index, hasher);
+}
+
+
+STDAPI GetModuleProp(PROPID propID, PROPVARIANT *value);
+STDAPI GetModuleProp(PROPID propID, PROPVARIANT *value)
+{
+ ::VariantClear((VARIANTARG *)value);
+ switch (propID)
+ {
+ case NModulePropID::kInterfaceType:
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt32(value, NModuleInterfaceType::k_IUnknown_VirtDestructor_ThisModule);
+ break;
+ }
+ case NModulePropID::kVersion:
+ {
+ NWindows::NCOM::PropVarEm_Set_UInt32(value, (MY_VER_MAJOR << 16) | MY_VER_MINOR);
+ break;
+ }
+ }
+ return S_OK;
+}
diff --git a/CPP/7zip/Compress/CopyCoder.cpp b/CPP/7zip/Compress/CopyCoder.cpp
index 89b5237..b779e08 100644
--- a/CPP/7zip/Compress/CopyCoder.cpp
+++ b/CPP/7zip/Compress/CopyCoder.cpp
@@ -1,120 +1,153 @@
-// Compress/CopyCoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "CopyCoder.h"
-
-namespace NCompress {
-
-static const UInt32 kBufSize = 1 << 17;
-
-CCopyCoder::~CCopyCoder()
-{
- ::MidFree(_buf);
-}
-
-STDMETHODIMP CCopyCoder::SetFinishMode(UInt32 /* finishMode */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
- ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 *outSize,
- ICompressProgressInfo *progress)
-{
- if (!_buf)
- {
- _buf = (Byte *)::MidAlloc(kBufSize);
- if (!_buf)
- return E_OUTOFMEMORY;
- }
-
- TotalSize = 0;
-
- for (;;)
- {
- UInt32 size = kBufSize;
- if (outSize && size > *outSize - TotalSize)
- size = (UInt32)(*outSize - TotalSize);
- if (size == 0)
- return S_OK;
-
- HRESULT readRes = inStream->Read(_buf, size, &size);
-
- if (size == 0)
- return readRes;
-
- if (outStream)
- {
- UInt32 pos = 0;
- do
- {
- UInt32 curSize = size - pos;
- HRESULT res = outStream->Write(_buf + pos, curSize, &curSize);
- pos += curSize;
- TotalSize += curSize;
- RINOK(res);
- if (curSize == 0)
- return E_FAIL;
- }
- while (pos < size);
- }
- else
- TotalSize += size;
-
- RINOK(readRes);
-
- if (progress)
- {
- RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize));
- }
- }
-}
-
-STDMETHODIMP CCopyCoder::SetInStream(ISequentialInStream *inStream)
-{
- _inStream = inStream;
- TotalSize = 0;
- return S_OK;
-}
-
-STDMETHODIMP CCopyCoder::ReleaseInStream()
-{
- _inStream.Release();
- return S_OK;
-}
-
-STDMETHODIMP CCopyCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- UInt32 realProcessedSize = 0;
- HRESULT res = _inStream->Read(data, size, &realProcessedSize);
- TotalSize += realProcessedSize;
- if (processedSize)
- *processedSize = realProcessedSize;
- return res;
-}
-
-STDMETHODIMP CCopyCoder::GetInStreamProcessedSize(UInt64 *value)
-{
- *value = TotalSize;
- return S_OK;
-}
-
-HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
-{
- CMyComPtr<ICompressCoder> copyCoder = new CCopyCoder;
- return copyCoder->Code(inStream, outStream, NULL, NULL, progress);
-}
-
-HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress)
-{
- NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
- CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
- RINOK(copyCoder->Code(inStream, outStream, NULL, &size, progress));
- return copyCoderSpec->TotalSize == size ? S_OK : E_FAIL;
-}
-
-}
+// Compress/CopyCoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "CopyCoder.h"
+
+namespace NCompress {
+
+static const UInt32 kBufSize = 1 << 17;
+
+CCopyCoder::~CCopyCoder()
+{
+ ::MidFree(_buf);
+}
+
+Z7_COM7F_IMF(CCopyCoder::SetFinishMode(UInt32 /* finishMode */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CCopyCoder::Code(ISequentialInStream *inStream,
+ ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize,
+ ICompressProgressInfo *progress))
+{
+ if (!_buf)
+ {
+ _buf = (Byte *)::MidAlloc(kBufSize);
+ if (!_buf)
+ return E_OUTOFMEMORY;
+ }
+
+ TotalSize = 0;
+
+ for (;;)
+ {
+ UInt32 size = kBufSize;
+ if (outSize)
+ {
+ const UInt64 rem = *outSize - TotalSize;
+ if (size > rem)
+ {
+ size = (UInt32)rem;
+ if (size == 0)
+ {
+ /* if we enable the following check,
+ we will make one call of Read(_buf, 0) for empty stream */
+ // if (TotalSize != 0)
+ return S_OK;
+ }
+ }
+ }
+
+ HRESULT readRes;
+ {
+ UInt32 pos = 0;
+ do
+ {
+ const UInt32 curSize = size - pos;
+ UInt32 processed = 0;
+ readRes = inStream->Read(_buf + pos, curSize, &processed);
+ if (processed > curSize)
+ return E_FAIL; // internal code failure
+ pos += processed;
+ if (readRes != S_OK || processed == 0)
+ break;
+ }
+ while (pos < kBufSize);
+ size = pos;
+ }
+
+ if (size == 0)
+ return readRes;
+
+ if (outStream)
+ {
+ UInt32 pos = 0;
+ do
+ {
+ const UInt32 curSize = size - pos;
+ UInt32 processed = 0;
+ const HRESULT res = outStream->Write(_buf + pos, curSize, &processed);
+ if (processed > curSize)
+ return E_FAIL; // internal code failure
+ pos += processed;
+ TotalSize += processed;
+ RINOK(res)
+ if (processed == 0)
+ return E_FAIL;
+ }
+ while (pos < size);
+ }
+ else
+ TotalSize += size;
+
+ RINOK(readRes)
+
+ if (size != kBufSize)
+ return S_OK;
+
+ if (progress && (TotalSize & (((UInt32)1 << 22) - 1)) == 0)
+ {
+ RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize))
+ }
+ }
+}
+
+Z7_COM7F_IMF(CCopyCoder::SetInStream(ISequentialInStream *inStream))
+{
+ _inStream = inStream;
+ TotalSize = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CCopyCoder::ReleaseInStream())
+{
+ _inStream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CCopyCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ UInt32 realProcessedSize = 0;
+ HRESULT res = _inStream->Read(data, size, &realProcessedSize);
+ TotalSize += realProcessedSize;
+ if (processedSize)
+ *processedSize = realProcessedSize;
+ return res;
+}
+
+Z7_COM7F_IMF(CCopyCoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = TotalSize;
+ return S_OK;
+}
+
+HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
+{
+ CMyComPtr<ICompressCoder> copyCoder = new CCopyCoder;
+ return copyCoder->Code(inStream, outStream, NULL, NULL, progress);
+}
+
+HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress)
+{
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+ RINOK(copyCoder->Code(inStream, outStream, NULL, &size, progress))
+ return copyCoderSpec->TotalSize == size ? S_OK : E_FAIL;
+}
+
+}
diff --git a/CPP/7zip/Compress/CopyCoder.h b/CPP/7zip/Compress/CopyCoder.h
index b2fa491..cb93e4e 100644
--- a/CPP/7zip/Compress/CopyCoder.h
+++ b/CPP/7zip/Compress/CopyCoder.h
@@ -1,49 +1,34 @@
-// Compress/CopyCoder.h
-
-#ifndef __COMPRESS_COPY_CODER_H
-#define __COMPRESS_COPY_CODER_H
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-
-class CCopyCoder:
- public ICompressCoder,
- public ICompressSetInStream,
- public ISequentialInStream,
- public ICompressSetFinishMode,
- public ICompressGetInStreamProcessedSize,
- public CMyUnknownImp
-{
- Byte *_buf;
- CMyComPtr<ISequentialInStream> _inStream;
-public:
- UInt64 TotalSize;
-
- CCopyCoder(): _buf(0), TotalSize(0) {};
- ~CCopyCoder();
-
- MY_UNKNOWN_IMP5(
- ICompressCoder,
- ICompressSetInStream,
- ISequentialInStream,
- ICompressSetFinishMode,
- ICompressGetInStreamProcessedSize)
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetInStream)(ISequentialInStream *inStream);
- STDMETHOD(ReleaseInStream)();
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(SetFinishMode)(UInt32 finishMode);
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
-};
-
-HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
-HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress);
-
-}
-
-#endif
+// Compress/CopyCoder.h
+
+#ifndef ZIP7_INC_COMPRESS_COPY_CODER_H
+#define ZIP7_INC_COMPRESS_COPY_CODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+
+Z7_CLASS_IMP_COM_5(
+ CCopyCoder
+ , ICompressCoder
+ , ICompressSetInStream
+ , ISequentialInStream
+ , ICompressSetFinishMode
+ , ICompressGetInStreamProcessedSize
+)
+ Byte *_buf;
+ CMyComPtr<ISequentialInStream> _inStream;
+public:
+ UInt64 TotalSize;
+
+ CCopyCoder(): _buf(NULL), TotalSize(0) {}
+ ~CCopyCoder();
+};
+
+HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream *outStream, UInt64 size, ICompressProgressInfo *progress);
+
+}
+
+#endif
diff --git a/CPP/7zip/Compress/CopyRegister.cpp b/CPP/7zip/Compress/CopyRegister.cpp
index 1c59fe0..7141ab5 100644
--- a/CPP/7zip/Compress/CopyRegister.cpp
+++ b/CPP/7zip/Compress/CopyRegister.cpp
@@ -1,15 +1,15 @@
-// CopyRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "CopyCoder.h"
-
-namespace NCompress {
-
-REGISTER_CODEC_CREATE(CreateCodec, CCopyCoder())
-
-REGISTER_CODEC_2(Copy, CreateCodec, CreateCodec, 0, "Copy")
-
-}
+// CopyRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "CopyCoder.h"
+
+namespace NCompress {
+
+REGISTER_CODEC_CREATE(CreateCodec, CCopyCoder())
+
+REGISTER_CODEC_2(Copy, CreateCodec, CreateCodec, 0, "Copy")
+
+}
diff --git a/CPP/7zip/Compress/Deflate64Register.cpp b/CPP/7zip/Compress/Deflate64Register.cpp
new file mode 100644
index 0000000..7f6bae0
--- /dev/null
+++ b/CPP/7zip/Compress/Deflate64Register.cpp
@@ -0,0 +1,25 @@
+// Deflate64Register.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "DeflateDecoder.h"
+#if !defined(Z7_EXTRACT_ONLY) && !defined(Z7_DEFLATE_EXTRACT_ONLY)
+#include "DeflateEncoder.h"
+#endif
+
+namespace NCompress {
+namespace NDeflate {
+
+REGISTER_CODEC_CREATE(CreateDec, NDecoder::CCOMCoder64())
+
+#if !defined(Z7_EXTRACT_ONLY) && !defined(Z7_DEFLATE_EXTRACT_ONLY)
+REGISTER_CODEC_CREATE(CreateEnc, NEncoder::CCOMCoder64())
+#else
+#define CreateEnc NULL
+#endif
+
+REGISTER_CODEC_2(Deflate64, CreateDec, CreateEnc, 0x40109, "Deflate64")
+
+}}
diff --git a/CPP/7zip/Compress/DeflateConst.h b/CPP/7zip/Compress/DeflateConst.h
new file mode 100644
index 0000000..a73d8ff
--- /dev/null
+++ b/CPP/7zip/Compress/DeflateConst.h
@@ -0,0 +1,131 @@
+// DeflateConst.h
+
+#ifndef ZIP7_INC_DEFLATE_CONST_H
+#define ZIP7_INC_DEFLATE_CONST_H
+
+namespace NCompress {
+namespace NDeflate {
+
+const unsigned kNumHuffmanBits = 15;
+
+const UInt32 kHistorySize32 = (1 << 15);
+const UInt32 kHistorySize64 = (1 << 16);
+
+const unsigned kDistTableSize32 = 30;
+const unsigned kDistTableSize64 = 32;
+
+const unsigned kNumLenSymbols32 = 256;
+const unsigned kNumLenSymbols64 = 255; // don't change it. It must be <= 255.
+const unsigned kNumLenSymbolsMax = kNumLenSymbols32;
+
+const unsigned kNumLenSlots = 29;
+
+const unsigned kFixedDistTableSize = 32;
+const unsigned kFixedLenTableSize = 31;
+
+const unsigned kSymbolEndOfBlock = 0x100;
+const unsigned kSymbolMatch = kSymbolEndOfBlock + 1;
+
+const unsigned kMainTableSize = kSymbolMatch + kNumLenSlots;
+const unsigned kFixedMainTableSize = kSymbolMatch + kFixedLenTableSize;
+
+const unsigned kLevelTableSize = 19;
+
+const unsigned kTableDirectLevels = 16;
+const unsigned kTableLevelRepNumber = kTableDirectLevels;
+const unsigned kTableLevel0Number = kTableLevelRepNumber + 1;
+const unsigned kTableLevel0Number2 = kTableLevel0Number + 1;
+
+const unsigned kLevelMask = 0xF;
+
+const Byte kLenStart32[kFixedLenTableSize] =
+ {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224, 255, 0, 0};
+const Byte kLenStart64[kFixedLenTableSize] =
+ {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224, 0, 0, 0};
+
+const Byte kLenDirectBits32[kFixedLenTableSize] =
+ {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0};
+const Byte kLenDirectBits64[kFixedLenTableSize] =
+ {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 16, 0, 0};
+
+const UInt32 kDistStart[kDistTableSize64] =
+ {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,
+ 1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768,49152};
+const Byte kDistDirectBits[kDistTableSize64] =
+ {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14};
+
+const Byte kLevelDirectBits[3] = {2, 3, 7};
+
+const Byte kCodeLengthAlphabetOrder[kLevelTableSize] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+const unsigned kMatchMinLen = 3;
+const unsigned kMatchMaxLen32 = kNumLenSymbols32 + kMatchMinLen - 1; // 256 + 2
+const unsigned kMatchMaxLen64 = kNumLenSymbols64 + kMatchMinLen - 1; // 255 + 2
+const unsigned kMatchMaxLen = kMatchMaxLen32;
+
+const unsigned kFinalBlockFieldSize = 1;
+
+namespace NFinalBlockField
+{
+ enum
+ {
+ kNotFinalBlock = 0,
+ kFinalBlock = 1
+ };
+}
+
+const unsigned kBlockTypeFieldSize = 2;
+
+namespace NBlockType
+{
+ enum
+ {
+ kStored = 0,
+ kFixedHuffman = 1,
+ kDynamicHuffman = 2
+ };
+}
+
+const unsigned kNumLenCodesFieldSize = 5;
+const unsigned kNumDistCodesFieldSize = 5;
+const unsigned kNumLevelCodesFieldSize = 4;
+
+const unsigned kNumLitLenCodesMin = 257;
+const unsigned kNumDistCodesMin = 1;
+const unsigned kNumLevelCodesMin = 4;
+
+const unsigned kLevelFieldSize = 3;
+
+const unsigned kStoredBlockLengthFieldSize = 16;
+
+struct CLevels
+{
+ Byte litLenLevels[kFixedMainTableSize];
+ Byte distLevels[kFixedDistTableSize];
+
+ void SubClear()
+ {
+ unsigned i;
+ for (i = kNumLitLenCodesMin; i < kFixedMainTableSize; i++)
+ litLenLevels[i] = 0;
+ for (i = 0; i < kFixedDistTableSize; i++)
+ distLevels[i] = 0;
+ }
+
+ void SetFixedLevels()
+ {
+ unsigned i = 0;
+
+ for (; i < 144; i++) litLenLevels[i] = 8;
+ for (; i < 256; i++) litLenLevels[i] = 9;
+ for (; i < 280; i++) litLenLevels[i] = 7;
+ for (; i < 288; i++) litLenLevels[i] = 8;
+
+ for (i = 0; i < kFixedDistTableSize; i++) // test it: InfoZip only uses kDistTableSize
+ distLevels[i] = 5;
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/DeflateDecoder.cpp b/CPP/7zip/Compress/DeflateDecoder.cpp
new file mode 100644
index 0000000..017b694
--- /dev/null
+++ b/CPP/7zip/Compress/DeflateDecoder.cpp
@@ -0,0 +1,541 @@
+// DeflateDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "DeflateDecoder.h"
+
+namespace NCompress {
+namespace NDeflate {
+namespace NDecoder {
+
+CCoder::CCoder(bool deflate64Mode):
+ _deflateNSIS(false),
+ _deflate64Mode(deflate64Mode),
+ _keepHistory(false),
+ _needFinishInput(false),
+ _needInitInStream(true),
+ _outSizeDefined(false),
+ _outStartPos(0),
+ ZlibMode(false) {}
+
+UInt32 CCoder::ReadBits(unsigned numBits)
+{
+ return m_InBitStream.ReadBits(numBits);
+}
+
+Byte CCoder::ReadAlignedByte()
+{
+ return m_InBitStream.ReadAlignedByte();
+}
+
+bool CCoder::DecodeLevels(Byte *levels, unsigned numSymbols)
+{
+ unsigned i = 0;
+
+ do
+ {
+ UInt32 sym = m_LevelDecoder.Decode(&m_InBitStream);
+ if (sym < kTableDirectLevels)
+ levels[i++] = (Byte)sym;
+ else
+ {
+ if (sym >= kLevelTableSize)
+ return false;
+
+ unsigned num;
+ unsigned numBits;
+ Byte symbol;
+
+ if (sym == kTableLevelRepNumber)
+ {
+ if (i == 0)
+ return false;
+ numBits = 2;
+ num = 0;
+ symbol = levels[(size_t)i - 1];
+ }
+ else
+ {
+ sym -= kTableLevel0Number;
+ sym <<= 2;
+ numBits = 3 + (unsigned)sym;
+ num = ((unsigned)sym << 1);
+ symbol = 0;
+ }
+
+ num += i + 3 + ReadBits(numBits);
+ if (num > numSymbols)
+ return false;
+ do
+ levels[i++] = symbol;
+ while (i < num);
+ }
+ }
+ while (i < numSymbols);
+
+ return true;
+}
+
+#define RIF(x) { if (!(x)) return false; }
+
+bool CCoder::ReadTables(void)
+{
+ m_FinalBlock = (ReadBits(kFinalBlockFieldSize) == NFinalBlockField::kFinalBlock);
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+ const UInt32 blockType = ReadBits(kBlockTypeFieldSize);
+ if (blockType > NBlockType::kDynamicHuffman)
+ return false;
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+
+ if (blockType == NBlockType::kStored)
+ {
+ m_StoredMode = true;
+ m_InBitStream.AlignToByte();
+ m_StoredBlockSize = ReadAligned_UInt16(); // ReadBits(kStoredBlockLengthFieldSize)
+ if (_deflateNSIS)
+ return true;
+ return (m_StoredBlockSize == (UInt16)~ReadAligned_UInt16());
+ }
+
+ m_StoredMode = false;
+
+ CLevels levels;
+ if (blockType == NBlockType::kFixedHuffman)
+ {
+ levels.SetFixedLevels();
+ _numDistLevels = _deflate64Mode ? kDistTableSize64 : kDistTableSize32;
+ }
+ else
+ {
+ const unsigned numLitLenLevels = ReadBits(kNumLenCodesFieldSize) + kNumLitLenCodesMin;
+ _numDistLevels = ReadBits(kNumDistCodesFieldSize) + kNumDistCodesMin;
+ const unsigned numLevelCodes = ReadBits(kNumLevelCodesFieldSize) + kNumLevelCodesMin;
+
+ if (!_deflate64Mode)
+ if (_numDistLevels > kDistTableSize32)
+ return false;
+
+ Byte levelLevels[kLevelTableSize];
+ for (unsigned i = 0; i < kLevelTableSize; i++)
+ {
+ const unsigned position = kCodeLengthAlphabetOrder[i];
+ if (i < numLevelCodes)
+ levelLevels[position] = (Byte)ReadBits(kLevelFieldSize);
+ else
+ levelLevels[position] = 0;
+ }
+
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+
+ RIF(m_LevelDecoder.Build(levelLevels))
+
+ Byte tmpLevels[kFixedMainTableSize + kFixedDistTableSize];
+ if (!DecodeLevels(tmpLevels, numLitLenLevels + _numDistLevels))
+ return false;
+
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+
+ levels.SubClear();
+ memcpy(levels.litLenLevels, tmpLevels, numLitLenLevels);
+ memcpy(levels.distLevels, tmpLevels + numLitLenLevels, _numDistLevels);
+ }
+ RIF(m_MainDecoder.Build(levels.litLenLevels))
+ return m_DistDecoder.Build(levels.distLevels);
+}
+
+
+HRESULT CCoder::InitInStream(bool needInit)
+{
+ if (needInit)
+ {
+ // for HDD-Windows:
+ // (1 << 15) - best for reading only prefetch
+ // (1 << 22) - best for real reading / writing
+ if (!m_InBitStream.Create(1 << 20))
+ return E_OUTOFMEMORY;
+ m_InBitStream.Init();
+ _needInitInStream = false;
+ }
+ return S_OK;
+}
+
+
+HRESULT CCoder::CodeSpec(UInt32 curSize, bool finishInputStream, UInt32 inputProgressLimit)
+{
+ if (_remainLen == kLenIdFinished)
+ return S_OK;
+
+ if (_remainLen == kLenIdNeedInit)
+ {
+ if (!_keepHistory)
+ if (!m_OutWindowStream.Create(_deflate64Mode ? kHistorySize64: kHistorySize32))
+ return E_OUTOFMEMORY;
+ RINOK(InitInStream(_needInitInStream))
+ m_OutWindowStream.Init(_keepHistory);
+
+ m_FinalBlock = false;
+ _remainLen = 0;
+ _needReadTable = true;
+ }
+
+ while (_remainLen > 0 && curSize > 0)
+ {
+ _remainLen--;
+ const Byte b = m_OutWindowStream.GetByte(_rep0);
+ m_OutWindowStream.PutByte(b);
+ curSize--;
+ }
+
+ UInt64 inputStart = 0;
+ if (inputProgressLimit != 0)
+ inputStart = m_InBitStream.GetProcessedSize();
+
+ while (curSize > 0 || finishInputStream)
+ {
+ if (m_InBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ if (_needReadTable)
+ {
+ if (m_FinalBlock)
+ {
+ _remainLen = kLenIdFinished;
+ break;
+ }
+
+ if (inputProgressLimit != 0)
+ if (m_InBitStream.GetProcessedSize() - inputStart >= inputProgressLimit)
+ return S_OK;
+
+ if (!ReadTables())
+ return S_FALSE;
+ if (m_InBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+ _needReadTable = false;
+ }
+
+ if (m_StoredMode)
+ {
+ if (finishInputStream && curSize == 0 && m_StoredBlockSize != 0)
+ return S_FALSE;
+ /* NSIS version contains some bits in bitl bits buffer.
+ So we must read some first bytes via ReadAlignedByte */
+ for (; m_StoredBlockSize > 0 && curSize > 0 && m_InBitStream.ThereAreDataInBitsBuffer(); m_StoredBlockSize--, curSize--)
+ m_OutWindowStream.PutByte(ReadAlignedByte());
+ for (; m_StoredBlockSize > 0 && curSize > 0; m_StoredBlockSize--, curSize--)
+ m_OutWindowStream.PutByte(m_InBitStream.ReadDirectByte());
+ _needReadTable = (m_StoredBlockSize == 0);
+ continue;
+ }
+
+ while (curSize > 0)
+ {
+ if (m_InBitStream.ExtraBitsWereRead_Fast())
+ return S_FALSE;
+
+ UInt32 sym = m_MainDecoder.Decode(&m_InBitStream);
+
+ if (sym < 0x100)
+ {
+ m_OutWindowStream.PutByte((Byte)sym);
+ curSize--;
+ continue;
+ }
+ else if (sym == kSymbolEndOfBlock)
+ {
+ _needReadTable = true;
+ break;
+ }
+ else if (sym < kMainTableSize)
+ {
+ sym -= kSymbolMatch;
+ UInt32 len;
+ {
+ unsigned numBits;
+ if (_deflate64Mode)
+ {
+ len = kLenStart64[sym];
+ numBits = kLenDirectBits64[sym];
+ }
+ else
+ {
+ len = kLenStart32[sym];
+ numBits = kLenDirectBits32[sym];
+ }
+ len += kMatchMinLen + m_InBitStream.ReadBits(numBits);
+ }
+ UInt32 locLen = len;
+ if (locLen > curSize)
+ locLen = (UInt32)curSize;
+ sym = m_DistDecoder.Decode(&m_InBitStream);
+ if (sym >= _numDistLevels)
+ return S_FALSE;
+ sym = kDistStart[sym] + m_InBitStream.ReadBits(kDistDirectBits[sym]);
+ /*
+ if (sym >= 4)
+ {
+ // sym &= 31;
+ const unsigned numDirectBits = (unsigned)(((sym >> 1) - 1));
+ sym = (2 | (sym & 1)) << numDirectBits;
+ sym += m_InBitStream.ReadBits(numDirectBits);
+ }
+ */
+ if (!m_OutWindowStream.CopyBlock(sym, locLen))
+ return S_FALSE;
+ curSize -= locLen;
+ len -= locLen;
+ if (len != 0)
+ {
+ _remainLen = (Int32)len;
+ _rep0 = sym;
+ break;
+ }
+ }
+ else
+ return S_FALSE;
+ }
+
+ if (finishInputStream && curSize == 0)
+ {
+ if (m_MainDecoder.Decode(&m_InBitStream) != kSymbolEndOfBlock)
+ return S_FALSE;
+ _needReadTable = true;
+ }
+ }
+
+ if (m_InBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+#ifdef Z7_NO_EXCEPTIONS
+
+#define DEFLATE_TRY_BEGIN
+#define DEFLATE_TRY_END(res)
+
+#else
+
+#define DEFLATE_TRY_BEGIN try {
+#define DEFLATE_TRY_END(res) } \
+ catch(const CSystemException &e) { res = e.ErrorCode; } \
+ catch(...) { res = S_FALSE; }
+
+ // catch(const CInBufferException &e) { res = e.ErrorCode; }
+ // catch(const CLzOutWindowException &e) { res = e.ErrorCode; }
+
+#endif
+
+
+HRESULT CCoder::CodeReal(ISequentialOutStream *outStream, ICompressProgressInfo *progress)
+{
+ HRESULT res;
+
+ DEFLATE_TRY_BEGIN
+
+ m_OutWindowStream.SetStream(outStream);
+ CCoderReleaser flusher(this);
+
+ const UInt64 inStart = _needInitInStream ? 0 : m_InBitStream.GetProcessedSize();
+
+ for (;;)
+ {
+ const UInt32 kInputProgressLimit = 1 << 21;
+ UInt32 curSize = 1 << 20;
+ bool finishInputStream = false;
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - GetOutProcessedCur();
+ if (curSize >= rem)
+ {
+ curSize = (UInt32)rem;
+ if (ZlibMode || _needFinishInput)
+ finishInputStream = true;
+ }
+ }
+ if (!finishInputStream && curSize == 0)
+ break;
+
+ RINOK(CodeSpec(curSize, finishInputStream, progress ? kInputProgressLimit : 0))
+
+ if (_remainLen == kLenIdFinished)
+ break;
+
+ if (progress)
+ {
+ const UInt64 inSize = m_InBitStream.GetProcessedSize() - inStart;
+ const UInt64 nowPos64 = GetOutProcessedCur();
+ RINOK(progress->SetRatioInfo(&inSize, &nowPos64))
+ }
+ }
+
+ if (_remainLen == kLenIdFinished && ZlibMode)
+ {
+ m_InBitStream.AlignToByte();
+ for (unsigned i = 0; i < 4; i++)
+ ZlibFooter[i] = ReadAlignedByte();
+ }
+
+ flusher.NeedFlush = false;
+ res = Flush();
+ if (res == S_OK && _remainLen != kLenIdNeedInit && InputEofError())
+ return S_FALSE;
+
+ DEFLATE_TRY_END(res)
+
+ return res;
+}
+
+
+Z7_COM7F_IMF(CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ SetInStream(inStream);
+ SetOutStreamSize(outSize);
+ const HRESULT res = CodeReal(outStream, progress);
+ ReleaseInStream();
+ /*
+ if (res == S_OK)
+ if (_needFinishInput && inSize && *inSize != m_InBitStream.GetProcessedSize())
+ res = S_FALSE;
+ */
+ return res;
+}
+
+
+Z7_COM7F_IMF(CCoder::SetFinishMode(UInt32 finishMode))
+{
+ Set_NeedFinishInput(finishMode != 0);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = m_InBitStream.GetStreamSize();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::ReadUnusedFromInBuf(void *data, UInt32 size, UInt32 *processedSize))
+{
+ AlignToByte();
+ UInt32 i = 0;
+ {
+ for (i = 0; i < size; i++)
+ {
+ if (!m_InBitStream.ReadAlignedByte_FromBuf(((Byte *)data)[i]))
+ break;
+ }
+ }
+ if (processedSize)
+ *processedSize = i;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::SetInStream(ISequentialInStream *inStream))
+{
+ m_InStreamRef = inStream;
+ m_InBitStream.SetStream(inStream);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::ReleaseInStream())
+{
+ m_InStreamRef.Release();
+ return S_OK;
+}
+
+
+void CCoder::SetOutStreamSizeResume(const UInt64 *outSize)
+{
+ _outSizeDefined = (outSize != NULL);
+ _outSize = 0;
+ if (_outSizeDefined)
+ _outSize = *outSize;
+
+ m_OutWindowStream.Init(_keepHistory);
+ _outStartPos = m_OutWindowStream.GetProcessedSize();
+
+ _remainLen = kLenIdNeedInit;
+}
+
+
+Z7_COM7F_IMF(CCoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ /*
+ 18.06:
+ We want to support GetInputProcessedSize() before CCoder::Read()
+ So we call m_InBitStream.Init() even before buffer allocations
+ m_InBitStream.Init() just sets variables to default values
+ But later we will call m_InBitStream.Init() again with real buffer pointers
+ */
+ m_InBitStream.Init();
+ _needInitInStream = true;
+ SetOutStreamSizeResume(outSize);
+ return S_OK;
+}
+
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+Z7_COM7F_IMF(CCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT res;
+
+ if (processedSize)
+ *processedSize = 0;
+ const UInt64 outPos = GetOutProcessedCur();
+
+ bool finishInputStream = false;
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - outPos;
+ if (size >= rem)
+ {
+ size = (UInt32)rem;
+ if (ZlibMode || _needFinishInput)
+ finishInputStream = true;
+ }
+ }
+ if (!finishInputStream && size == 0)
+ return S_OK;
+
+ DEFLATE_TRY_BEGIN
+
+ m_OutWindowStream.SetMemStream((Byte *)data);
+
+ res = CodeSpec(size, finishInputStream);
+
+ DEFLATE_TRY_END(res)
+
+ {
+ const HRESULT res2 = Flush();
+ if (res2 != S_OK)
+ res = res2;
+ }
+
+ if (processedSize)
+ *processedSize = (UInt32)(GetOutProcessedCur() - outPos);
+
+ m_OutWindowStream.SetMemStream(NULL);
+ return res;
+}
+
+#endif
+
+
+HRESULT CCoder::CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ SetOutStreamSizeResume(outSize);
+ return CodeReal(outStream, progress);
+}
+
+}}}
diff --git a/CPP/7zip/Compress/DeflateDecoder.h b/CPP/7zip/Compress/DeflateDecoder.h
new file mode 100644
index 0000000..d31f299
--- /dev/null
+++ b/CPP/7zip/Compress/DeflateDecoder.h
@@ -0,0 +1,153 @@
+// DeflateDecoder.h
+
+#ifndef ZIP7_INC_DEFLATE_DECODER_H
+#define ZIP7_INC_DEFLATE_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitlDecoder.h"
+#include "DeflateConst.h"
+#include "HuffmanDecoder.h"
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NDeflate {
+namespace NDecoder {
+
+const int kLenIdFinished = -1;
+const int kLenIdNeedInit = -2;
+
+class CCoder:
+ public ICompressCoder,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize,
+ public ICompressReadUnusedFromInBuf,
+ public ICompressSetInStream,
+ public ICompressSetOutStreamSize,
+ #ifndef Z7_NO_READ_FROM_CODER
+ public ISequentialInStream,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ Z7_COM_QI_ENTRY(ICompressReadUnusedFromInBuf)
+ Z7_COM_QI_ENTRY(ICompressSetInStream)
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ Z7_IFACE_COM7_IMP(ICompressReadUnusedFromInBuf)
+public:
+ Z7_IFACE_COM7_IMP(ICompressSetInStream)
+private:
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+ #endif
+
+ CLzOutWindow m_OutWindowStream;
+ CMyComPtr<ISequentialInStream> m_InStreamRef;
+ NBitl::CDecoder<CInBuffer> m_InBitStream;
+ NCompress::NHuffman::CDecoder<kNumHuffmanBits, kFixedMainTableSize> m_MainDecoder;
+ NCompress::NHuffman::CDecoder<kNumHuffmanBits, kFixedDistTableSize> m_DistDecoder;
+ NCompress::NHuffman::CDecoder7b<kLevelTableSize> m_LevelDecoder;
+
+ UInt32 m_StoredBlockSize;
+
+ UInt32 _numDistLevels;
+ bool m_FinalBlock;
+ bool m_StoredMode;
+
+ bool _deflateNSIS;
+ bool _deflate64Mode;
+ bool _keepHistory;
+ bool _needFinishInput;
+
+ bool _needInitInStream;
+ bool _needReadTable;
+ Int32 _remainLen;
+ UInt32 _rep0;
+
+ bool _outSizeDefined;
+ UInt64 _outSize;
+ UInt64 _outStartPos;
+
+ void SetOutStreamSizeResume(const UInt64 *outSize);
+ UInt64 GetOutProcessedCur() const { return m_OutWindowStream.GetProcessedSize() - _outStartPos; }
+
+ UInt32 ReadBits(unsigned numBits);
+
+ bool DecodeLevels(Byte *levels, unsigned numSymbols);
+ bool ReadTables();
+
+ HRESULT Flush() { return m_OutWindowStream.Flush(); }
+ class CCoderReleaser
+ {
+ CCoder *_coder;
+ public:
+ bool NeedFlush;
+ CCoderReleaser(CCoder *coder): _coder(coder), NeedFlush(true) {}
+ ~CCoderReleaser()
+ {
+ if (NeedFlush)
+ _coder->Flush();
+ }
+ };
+ friend class CCoderReleaser;
+
+ HRESULT CodeSpec(UInt32 curSize, bool finishInputStream, UInt32 inputProgressLimit = 0);
+public:
+ bool ZlibMode;
+ Byte ZlibFooter[4];
+
+ CCoder(bool deflate64Mode);
+ virtual ~CCoder() {}
+
+ void SetNsisMode(bool nsisMode) { _deflateNSIS = nsisMode; }
+
+ void Set_KeepHistory(bool keepHistory) { _keepHistory = keepHistory; }
+ void Set_NeedFinishInput(bool needFinishInput) { _needFinishInput = needFinishInput; }
+
+ bool IsFinished() const { return _remainLen == kLenIdFinished; }
+ bool IsFinalBlock() const { return m_FinalBlock; }
+
+ HRESULT CodeReal(ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+
+public:
+ HRESULT CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress);
+ HRESULT InitInStream(bool needInit);
+
+ void AlignToByte() { m_InBitStream.AlignToByte(); }
+ Byte ReadAlignedByte();
+ UInt32 ReadAligned_UInt16() // aligned for Byte range
+ {
+ UInt32 v = m_InBitStream.ReadAlignedByte();
+ return v | ((UInt32)m_InBitStream.ReadAlignedByte() << 8);
+ }
+ bool InputEofError() const { return m_InBitStream.ExtraBitsWereRead(); }
+
+ // size of used real data from input stream
+ UInt64 GetStreamSize() const { return m_InBitStream.GetStreamSize(); }
+
+ // size of virtual input stream processed
+ UInt64 GetInputProcessedSize() const { return m_InBitStream.GetProcessedSize(); }
+};
+
+class CCOMCoder : public CCoder { public: CCOMCoder(): CCoder(false) {} };
+class CCOMCoder64 : public CCoder { public: CCOMCoder64(): CCoder(true) {} };
+
+}}}
+
+#endif
diff --git a/CPP/7zip/Compress/DeflateEncoder.cpp b/CPP/7zip/Compress/DeflateEncoder.cpp
new file mode 100644
index 0000000..e277ad6
--- /dev/null
+++ b/CPP/7zip/Compress/DeflateEncoder.cpp
@@ -0,0 +1,1019 @@
+// DeflateEncoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+#include "../../../C/HuffEnc.h"
+
+#include "../../Common/ComTry.h"
+
+#include "../Common/CWrappers.h"
+
+#include "DeflateEncoder.h"
+
+#undef NO_INLINE
+
+#ifdef _MSC_VER
+#define NO_INLINE Z7_NO_INLINE
+#else
+#define NO_INLINE
+#endif
+
+namespace NCompress {
+namespace NDeflate {
+namespace NEncoder {
+
+static const unsigned kNumDivPassesMax = 10; // [0, 16); ratio/speed/ram tradeoff; use big value for better compression ratio.
+static const UInt32 kNumTables = (1 << kNumDivPassesMax);
+
+static const UInt32 kFixedHuffmanCodeBlockSizeMax = (1 << 8); // [0, (1 << 32)); ratio/speed tradeoff; use big value for better compression ratio.
+static const UInt32 kDivideCodeBlockSizeMin = (1 << 7); // [1, (1 << 32)); ratio/speed tradeoff; use small value for better compression ratio.
+static const UInt32 kDivideBlockSizeMin = (1 << 6); // [1, (1 << 32)); ratio/speed tradeoff; use small value for better compression ratio.
+
+static const UInt32 kMaxUncompressedBlockSize = ((1 << 16) - 1) * 1; // [1, (1 << 32))
+static const UInt32 kMatchArraySize = kMaxUncompressedBlockSize * 10; // [kMatchMaxLen * 2, (1 << 32))
+static const UInt32 kMatchArrayLimit = kMatchArraySize - kMatchMaxLen * 4 * sizeof(UInt16);
+static const UInt32 kBlockUncompressedSizeThreshold = kMaxUncompressedBlockSize -
+ kMatchMaxLen - kNumOpts;
+
+// static const unsigned kMaxCodeBitLength = 11;
+static const unsigned kMaxLevelBitLength = 7;
+
+static const Byte kNoLiteralStatPrice = 11;
+static const Byte kNoLenStatPrice = 11;
+static const Byte kNoPosStatPrice = 6;
+
+static Byte g_LenSlots[kNumLenSymbolsMax];
+
+#define kNumLogBits 9 // do not change it
+static Byte g_FastPos[1 << kNumLogBits];
+
+class CFastPosInit
+{
+public:
+ CFastPosInit()
+ {
+ unsigned i;
+ for (i = 0; i < kNumLenSlots; i++)
+ {
+ unsigned c = kLenStart32[i];
+ unsigned j = 1 << kLenDirectBits32[i];
+ for (unsigned k = 0; k < j; k++, c++)
+ g_LenSlots[c] = (Byte)i;
+ }
+
+ const unsigned kFastSlots = kNumLogBits * 2;
+ unsigned c = 0;
+ for (Byte slotFast = 0; slotFast < kFastSlots; slotFast++)
+ {
+ UInt32 k = (1 << kDistDirectBits[slotFast]);
+ for (UInt32 j = 0; j < k; j++, c++)
+ g_FastPos[c] = slotFast;
+ }
+ }
+};
+
+static CFastPosInit g_FastPosInit;
+
+inline UInt32 GetPosSlot(UInt32 pos)
+{
+ /*
+ if (pos < 0x200)
+ return g_FastPos[pos];
+ return g_FastPos[pos >> 8] + 16;
+ */
+ // const unsigned zz = (pos < ((UInt32)1 << (kNumLogBits))) ? 0 : 8;
+ /*
+ const unsigned zz = (kNumLogBits - 1) &
+ ((UInt32)0 - (((((UInt32)1 << kNumLogBits) - 1) - pos) >> 31));
+ */
+ const unsigned zz = (kNumLogBits - 1) &
+ (((((UInt32)1 << kNumLogBits) - 1) - pos) >> (31 - 3));
+ return g_FastPos[pos >> zz] + (zz * 2);
+}
+
+
+void CEncProps::Normalize()
+{
+ int level = Level;
+ if (level < 0) level = 5;
+ Level = level;
+ if (algo < 0) algo = (level < 5 ? 0 : 1);
+ if (fb < 0) fb = (level < 7 ? 32 : (level < 9 ? 64 : 128));
+ if (btMode < 0) btMode = (algo == 0 ? 0 : 1);
+ if (mc == 0) mc = (16 + ((unsigned)fb >> 1));
+ if (numPasses == (UInt32)(Int32)-1) numPasses = (level < 7 ? 1 : (level < 9 ? 3 : 10));
+}
+
+void CCoder::SetProps(const CEncProps *props2)
+{
+ CEncProps props = *props2;
+ props.Normalize();
+
+ m_MatchFinderCycles = props.mc;
+ {
+ unsigned fb = (unsigned)props.fb;
+ if (fb < kMatchMinLen)
+ fb = kMatchMinLen;
+ if (fb > m_MatchMaxLen)
+ fb = m_MatchMaxLen;
+ m_NumFastBytes = fb;
+ }
+ _fastMode = (props.algo == 0);
+ _btMode = (props.btMode != 0);
+
+ m_NumDivPasses = props.numPasses;
+ if (m_NumDivPasses == 0)
+ m_NumDivPasses = 1;
+ if (m_NumDivPasses == 1)
+ m_NumPasses = 1;
+ else if (m_NumDivPasses <= kNumDivPassesMax)
+ m_NumPasses = 2;
+ else
+ {
+ m_NumPasses = 2 + (m_NumDivPasses - kNumDivPassesMax);
+ m_NumDivPasses = kNumDivPassesMax;
+ }
+}
+
+CCoder::CCoder(bool deflate64Mode):
+ m_Values(NULL),
+ m_OnePosMatchesMemory(NULL),
+ m_DistanceMemory(NULL),
+ m_Created(false),
+ m_Deflate64Mode(deflate64Mode),
+ m_Tables(NULL)
+{
+ m_MatchMaxLen = deflate64Mode ? kMatchMaxLen64 : kMatchMaxLen32;
+ m_NumLenCombinations = deflate64Mode ? kNumLenSymbols64 : kNumLenSymbols32;
+ m_LenStart = deflate64Mode ? kLenStart64 : kLenStart32;
+ m_LenDirectBits = deflate64Mode ? kLenDirectBits64 : kLenDirectBits32;
+ {
+ CEncProps props;
+ SetProps(&props);
+ }
+ MatchFinder_Construct(&_lzInWindow);
+}
+
+HRESULT CCoder::Create()
+{
+ // COM_TRY_BEGIN
+ if (!m_Values)
+ {
+ m_Values = (CCodeValue *)MyAlloc((kMaxUncompressedBlockSize) * sizeof(CCodeValue));
+ if (!m_Values)
+ return E_OUTOFMEMORY;
+ }
+ if (!m_Tables)
+ {
+ m_Tables = (CTables *)MyAlloc((kNumTables) * sizeof(CTables));
+ if (!m_Tables)
+ return E_OUTOFMEMORY;
+ }
+
+ if (m_IsMultiPass)
+ {
+ if (!m_OnePosMatchesMemory)
+ {
+ m_OnePosMatchesMemory = (UInt16 *)::MidAlloc(kMatchArraySize * sizeof(UInt16));
+ if (!m_OnePosMatchesMemory)
+ return E_OUTOFMEMORY;
+ }
+ }
+ else
+ {
+ if (!m_DistanceMemory)
+ {
+ m_DistanceMemory = (UInt16 *)MyAlloc((kMatchMaxLen + 2) * 2 * sizeof(UInt16));
+ if (!m_DistanceMemory)
+ return E_OUTOFMEMORY;
+ m_MatchDistances = m_DistanceMemory;
+ }
+ }
+
+ if (!m_Created)
+ {
+ _lzInWindow.btMode = (Byte)(_btMode ? 1 : 0);
+ _lzInWindow.numHashBytes = 3;
+ _lzInWindow.numHashBytes_Min = 3;
+ if (!MatchFinder_Create(&_lzInWindow,
+ m_Deflate64Mode ? kHistorySize64 : kHistorySize32,
+ kNumOpts + kMaxUncompressedBlockSize,
+ m_NumFastBytes, m_MatchMaxLen - m_NumFastBytes, &g_AlignedAlloc))
+ return E_OUTOFMEMORY;
+ if (!m_OutStream.Create(1 << 20))
+ return E_OUTOFMEMORY;
+ }
+ if (m_MatchFinderCycles != 0)
+ _lzInWindow.cutValue = m_MatchFinderCycles;
+ m_Created = true;
+ return S_OK;
+ // COM_TRY_END
+}
+
+HRESULT CCoder::BaseSetEncoderProperties2(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
+{
+ CEncProps props;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ PROPID propID = propIDs[i];
+ if (propID >= NCoderPropID::kReduceSize)
+ continue;
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ UInt32 v = (UInt32)prop.ulVal;
+ switch (propID)
+ {
+ case NCoderPropID::kNumPasses: props.numPasses = v; break;
+ case NCoderPropID::kNumFastBytes: props.fb = (int)v; break;
+ case NCoderPropID::kMatchFinderCycles: props.mc = v; break;
+ case NCoderPropID::kAlgorithm: props.algo = (int)v; break;
+ case NCoderPropID::kLevel: props.Level = (int)v; break;
+ case NCoderPropID::kNumThreads: break;
+ default: return E_INVALIDARG;
+ }
+ }
+ SetProps(&props);
+ return S_OK;
+}
+
+void CCoder::Free()
+{
+ ::MidFree(m_OnePosMatchesMemory); m_OnePosMatchesMemory = NULL;
+ ::MyFree(m_DistanceMemory); m_DistanceMemory = NULL;
+ ::MyFree(m_Values); m_Values = NULL;
+ ::MyFree(m_Tables); m_Tables = NULL;
+}
+
+CCoder::~CCoder()
+{
+ Free();
+ MatchFinder_Free(&_lzInWindow, &g_AlignedAlloc);
+}
+
+NO_INLINE void CCoder::GetMatches()
+{
+ if (m_IsMultiPass)
+ {
+ m_MatchDistances = m_OnePosMatchesMemory + m_Pos;
+ if (m_SecondPass)
+ {
+ m_Pos += *m_MatchDistances + 1;
+ return;
+ }
+ }
+
+ UInt32 distanceTmp[kMatchMaxLen * 2 + 3];
+
+ const UInt32 numPairs = (UInt32)((_btMode ?
+ Bt3Zip_MatchFinder_GetMatches(&_lzInWindow, distanceTmp):
+ Hc3Zip_MatchFinder_GetMatches(&_lzInWindow, distanceTmp)) - distanceTmp);
+
+ *m_MatchDistances = (UInt16)numPairs;
+
+ if (numPairs != 0)
+ {
+ UInt32 i;
+ for (i = 0; i < numPairs; i += 2)
+ {
+ m_MatchDistances[(size_t)i + 1] = (UInt16)distanceTmp[i];
+ m_MatchDistances[(size_t)i + 2] = (UInt16)distanceTmp[(size_t)i + 1];
+ }
+ UInt32 len = distanceTmp[(size_t)numPairs - 2];
+ if (len == m_NumFastBytes && m_NumFastBytes != m_MatchMaxLen)
+ {
+ UInt32 numAvail = Inline_MatchFinder_GetNumAvailableBytes(&_lzInWindow) + 1;
+ const Byte *pby = Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - 1;
+ const Byte *pby2 = pby - (distanceTmp[(size_t)numPairs - 1] + 1);
+ if (numAvail > m_MatchMaxLen)
+ numAvail = m_MatchMaxLen;
+ for (; len < numAvail && pby[len] == pby2[len]; len++);
+ m_MatchDistances[(size_t)i - 1] = (UInt16)len;
+ }
+ }
+ if (m_IsMultiPass)
+ m_Pos += numPairs + 1;
+ if (!m_SecondPass)
+ m_AdditionalOffset++;
+}
+
+void CCoder::MovePos(UInt32 num)
+{
+ if (!m_SecondPass && num > 0)
+ {
+ if (_btMode)
+ Bt3Zip_MatchFinder_Skip(&_lzInWindow, num);
+ else
+ Hc3Zip_MatchFinder_Skip(&_lzInWindow, num);
+ m_AdditionalOffset += num;
+ }
+}
+
+static const UInt32 kIfinityPrice = 0xFFFFFFF;
+
+NO_INLINE UInt32 CCoder::Backward(UInt32 &backRes, UInt32 cur)
+{
+ m_OptimumEndIndex = cur;
+ UInt32 posMem = m_Optimum[cur].PosPrev;
+ UInt16 backMem = m_Optimum[cur].BackPrev;
+ do
+ {
+ UInt32 posPrev = posMem;
+ UInt16 backCur = backMem;
+ backMem = m_Optimum[posPrev].BackPrev;
+ posMem = m_Optimum[posPrev].PosPrev;
+ m_Optimum[posPrev].BackPrev = backCur;
+ m_Optimum[posPrev].PosPrev = (UInt16)cur;
+ cur = posPrev;
+ }
+ while (cur > 0);
+ backRes = m_Optimum[0].BackPrev;
+ m_OptimumCurrentIndex = m_Optimum[0].PosPrev;
+ return m_OptimumCurrentIndex;
+}
+
+NO_INLINE UInt32 CCoder::GetOptimal(UInt32 &backRes)
+{
+ if (m_OptimumEndIndex != m_OptimumCurrentIndex)
+ {
+ UInt32 len = m_Optimum[m_OptimumCurrentIndex].PosPrev - m_OptimumCurrentIndex;
+ backRes = m_Optimum[m_OptimumCurrentIndex].BackPrev;
+ m_OptimumCurrentIndex = m_Optimum[m_OptimumCurrentIndex].PosPrev;
+ return len;
+ }
+ m_OptimumCurrentIndex = m_OptimumEndIndex = 0;
+
+ GetMatches();
+
+ UInt32 lenEnd;
+ {
+ const UInt32 numDistancePairs = m_MatchDistances[0];
+ if (numDistancePairs == 0)
+ return 1;
+ const UInt16 *matchDistances = m_MatchDistances + 1;
+ lenEnd = matchDistances[(size_t)numDistancePairs - 2];
+
+ if (lenEnd > m_NumFastBytes)
+ {
+ backRes = matchDistances[(size_t)numDistancePairs - 1];
+ MovePos(lenEnd - 1);
+ return lenEnd;
+ }
+
+ m_Optimum[1].Price = m_LiteralPrices[*(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - m_AdditionalOffset)];
+ m_Optimum[1].PosPrev = 0;
+
+ m_Optimum[2].Price = kIfinityPrice;
+ m_Optimum[2].PosPrev = 1;
+
+ UInt32 offs = 0;
+
+ for (UInt32 i = kMatchMinLen; i <= lenEnd; i++)
+ {
+ UInt32 distance = matchDistances[(size_t)offs + 1];
+ m_Optimum[i].PosPrev = 0;
+ m_Optimum[i].BackPrev = (UInt16)distance;
+ m_Optimum[i].Price = m_LenPrices[(size_t)i - kMatchMinLen] + m_PosPrices[GetPosSlot(distance)];
+ if (i == matchDistances[offs])
+ offs += 2;
+ }
+ }
+
+ UInt32 cur = 0;
+
+ for (;;)
+ {
+ ++cur;
+ if (cur == lenEnd || cur == kNumOptsBase || m_Pos >= kMatchArrayLimit)
+ return Backward(backRes, cur);
+ GetMatches();
+ const UInt16 *matchDistances = m_MatchDistances + 1;
+ const UInt32 numDistancePairs = m_MatchDistances[0];
+ UInt32 newLen = 0;
+ if (numDistancePairs != 0)
+ {
+ newLen = matchDistances[(size_t)numDistancePairs - 2];
+ if (newLen > m_NumFastBytes)
+ {
+ UInt32 len = Backward(backRes, cur);
+ m_Optimum[cur].BackPrev = matchDistances[(size_t)numDistancePairs - 1];
+ m_OptimumEndIndex = cur + newLen;
+ m_Optimum[cur].PosPrev = (UInt16)m_OptimumEndIndex;
+ MovePos(newLen - 1);
+ return len;
+ }
+ }
+ UInt32 curPrice = m_Optimum[cur].Price;
+ {
+ const UInt32 curAnd1Price = curPrice + m_LiteralPrices[*(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) + cur - m_AdditionalOffset)];
+ COptimal &optimum = m_Optimum[(size_t)cur + 1];
+ if (curAnd1Price < optimum.Price)
+ {
+ optimum.Price = curAnd1Price;
+ optimum.PosPrev = (UInt16)cur;
+ }
+ }
+ if (numDistancePairs == 0)
+ continue;
+ while (lenEnd < cur + newLen)
+ m_Optimum[++lenEnd].Price = kIfinityPrice;
+ UInt32 offs = 0;
+ UInt32 distance = matchDistances[(size_t)offs + 1];
+ curPrice += m_PosPrices[GetPosSlot(distance)];
+ for (UInt32 lenTest = kMatchMinLen; ; lenTest++)
+ {
+ UInt32 curAndLenPrice = curPrice + m_LenPrices[(size_t)lenTest - kMatchMinLen];
+ COptimal &optimum = m_Optimum[cur + lenTest];
+ if (curAndLenPrice < optimum.Price)
+ {
+ optimum.Price = curAndLenPrice;
+ optimum.PosPrev = (UInt16)cur;
+ optimum.BackPrev = (UInt16)distance;
+ }
+ if (lenTest == matchDistances[offs])
+ {
+ offs += 2;
+ if (offs == numDistancePairs)
+ break;
+ curPrice -= m_PosPrices[GetPosSlot(distance)];
+ distance = matchDistances[(size_t)offs + 1];
+ curPrice += m_PosPrices[GetPosSlot(distance)];
+ }
+ }
+ }
+}
+
+UInt32 CCoder::GetOptimalFast(UInt32 &backRes)
+{
+ GetMatches();
+ UInt32 numDistancePairs = m_MatchDistances[0];
+ if (numDistancePairs == 0)
+ return 1;
+ UInt32 lenMain = m_MatchDistances[(size_t)numDistancePairs - 1];
+ backRes = m_MatchDistances[numDistancePairs];
+ MovePos(lenMain - 1);
+ return lenMain;
+}
+
+void CTables::InitStructures()
+{
+ UInt32 i;
+ for (i = 0; i < 256; i++)
+ litLenLevels[i] = 8;
+ litLenLevels[i++] = 13;
+ for (;i < kFixedMainTableSize; i++)
+ litLenLevels[i] = 5;
+ for (i = 0; i < kFixedDistTableSize; i++)
+ distLevels[i] = 5;
+}
+
+NO_INLINE void CCoder::LevelTableDummy(const Byte *levels, unsigned numLevels, UInt32 *freqs)
+{
+ unsigned prevLen = 0xFF;
+ unsigned nextLen = levels[0];
+ unsigned count = 0;
+ unsigned maxCount = 7;
+ unsigned minCount = 4;
+
+ if (nextLen == 0)
+ {
+ maxCount = 138;
+ minCount = 3;
+ }
+
+ for (unsigned n = 0; n < numLevels; n++)
+ {
+ unsigned curLen = nextLen;
+ nextLen = (n < numLevels - 1) ? levels[(size_t)n + 1] : 0xFF;
+ count++;
+ if (count < maxCount && curLen == nextLen)
+ continue;
+
+ if (count < minCount)
+ freqs[curLen] += (UInt32)count;
+ else if (curLen != 0)
+ {
+ if (curLen != prevLen)
+ {
+ freqs[curLen]++;
+ count--;
+ }
+ freqs[kTableLevelRepNumber]++;
+ }
+ else if (count <= 10)
+ freqs[kTableLevel0Number]++;
+ else
+ freqs[kTableLevel0Number2]++;
+
+ count = 0;
+ prevLen = curLen;
+
+ if (nextLen == 0)
+ {
+ maxCount = 138;
+ minCount = 3;
+ }
+ else if (curLen == nextLen)
+ {
+ maxCount = 6;
+ minCount = 3;
+ }
+ else
+ {
+ maxCount = 7;
+ minCount = 4;
+ }
+ }
+}
+
+NO_INLINE void CCoder::WriteBits(UInt32 value, unsigned numBits)
+{
+ m_OutStream.WriteBits(value, numBits);
+}
+
+#define WRITE_HF2(codes, lens, i) m_OutStream.WriteBits(codes[i], lens[i])
+#define WRITE_HF(i) WriteBits(codes[i], lens[i])
+
+NO_INLINE void CCoder::LevelTableCode(const Byte *levels, unsigned numLevels, const Byte *lens, const UInt32 *codes)
+{
+ unsigned prevLen = 0xFF;
+ unsigned nextLen = levels[0];
+ unsigned count = 0;
+ unsigned maxCount = 7;
+ unsigned minCount = 4;
+
+ if (nextLen == 0)
+ {
+ maxCount = 138;
+ minCount = 3;
+ }
+
+ for (unsigned n = 0; n < numLevels; n++)
+ {
+ unsigned curLen = nextLen;
+ nextLen = (n < numLevels - 1) ? levels[(size_t)n + 1] : 0xFF;
+ count++;
+ if (count < maxCount && curLen == nextLen)
+ continue;
+
+ if (count < minCount)
+ for (unsigned i = 0; i < count; i++)
+ WRITE_HF(curLen);
+ else if (curLen != 0)
+ {
+ if (curLen != prevLen)
+ {
+ WRITE_HF(curLen);
+ count--;
+ }
+ WRITE_HF(kTableLevelRepNumber);
+ WriteBits(count - 3, 2);
+ }
+ else if (count <= 10)
+ {
+ WRITE_HF(kTableLevel0Number);
+ WriteBits(count - 3, 3);
+ }
+ else
+ {
+ WRITE_HF(kTableLevel0Number2);
+ WriteBits(count - 11, 7);
+ }
+
+ count = 0;
+ prevLen = curLen;
+
+ if (nextLen == 0)
+ {
+ maxCount = 138;
+ minCount = 3;
+ }
+ else if (curLen == nextLen)
+ {
+ maxCount = 6;
+ minCount = 3;
+ }
+ else
+ {
+ maxCount = 7;
+ minCount = 4;
+ }
+ }
+}
+
+NO_INLINE void CCoder::MakeTables(unsigned maxHuffLen)
+{
+ Huffman_Generate(mainFreqs, mainCodes, m_NewLevels.litLenLevels, kFixedMainTableSize, maxHuffLen);
+ Huffman_Generate(distFreqs, distCodes, m_NewLevels.distLevels, kDistTableSize64, maxHuffLen);
+}
+
+static NO_INLINE UInt32 Huffman_GetPrice(const UInt32 *freqs, const Byte *lens, UInt32 num)
+{
+ UInt32 price = 0;
+ UInt32 i;
+ for (i = 0; i < num; i++)
+ price += lens[i] * freqs[i];
+ return price;
+}
+
+static NO_INLINE UInt32 Huffman_GetPrice_Spec(const UInt32 *freqs, const Byte *lens, UInt32 num, const Byte *extraBits, UInt32 extraBase)
+{
+ return Huffman_GetPrice(freqs, lens, num) +
+ Huffman_GetPrice(freqs + extraBase, extraBits, num - extraBase);
+}
+
+NO_INLINE UInt32 CCoder::GetLzBlockPrice() const
+{
+ return
+ Huffman_GetPrice_Spec(mainFreqs, m_NewLevels.litLenLevels, kFixedMainTableSize, m_LenDirectBits, kSymbolMatch) +
+ Huffman_GetPrice_Spec(distFreqs, m_NewLevels.distLevels, kDistTableSize64, kDistDirectBits, 0);
+}
+
+NO_INLINE void CCoder::TryBlock()
+{
+ memset(mainFreqs, 0, sizeof(mainFreqs));
+ memset(distFreqs, 0, sizeof(distFreqs));
+
+ m_ValueIndex = 0;
+ UInt32 blockSize = BlockSizeRes;
+ BlockSizeRes = 0;
+ for (;;)
+ {
+ if (m_OptimumCurrentIndex == m_OptimumEndIndex)
+ {
+ if (m_Pos >= kMatchArrayLimit
+ || BlockSizeRes >= blockSize
+ || (!m_SecondPass && ((Inline_MatchFinder_GetNumAvailableBytes(&_lzInWindow) == 0) || m_ValueIndex >= m_ValueBlockSize)))
+ break;
+ }
+ UInt32 pos;
+ UInt32 len;
+ if (_fastMode)
+ len = GetOptimalFast(pos);
+ else
+ len = GetOptimal(pos);
+ CCodeValue &codeValue = m_Values[m_ValueIndex++];
+ if (len >= kMatchMinLen)
+ {
+ UInt32 newLen = len - kMatchMinLen;
+ codeValue.Len = (UInt16)newLen;
+ mainFreqs[kSymbolMatch + (size_t)g_LenSlots[newLen]]++;
+ codeValue.Pos = (UInt16)pos;
+ distFreqs[GetPosSlot(pos)]++;
+ }
+ else
+ {
+ Byte b = *(Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow) - m_AdditionalOffset);
+ mainFreqs[b]++;
+ codeValue.SetAsLiteral();
+ codeValue.Pos = b;
+ }
+ m_AdditionalOffset -= len;
+ BlockSizeRes += len;
+ }
+ mainFreqs[kSymbolEndOfBlock]++;
+ m_AdditionalOffset += BlockSizeRes;
+ m_SecondPass = true;
+}
+
+NO_INLINE void CCoder::SetPrices(const CLevels &levels)
+{
+ if (_fastMode)
+ return;
+ UInt32 i;
+ for (i = 0; i < 256; i++)
+ {
+ Byte price = levels.litLenLevels[i];
+ m_LiteralPrices[i] = ((price != 0) ? price : kNoLiteralStatPrice);
+ }
+
+ for (i = 0; i < m_NumLenCombinations; i++)
+ {
+ UInt32 slot = g_LenSlots[i];
+ Byte price = levels.litLenLevels[kSymbolMatch + (size_t)slot];
+ m_LenPrices[i] = (Byte)(((price != 0) ? price : kNoLenStatPrice) + m_LenDirectBits[slot]);
+ }
+
+ for (i = 0; i < kDistTableSize64; i++)
+ {
+ Byte price = levels.distLevels[i];
+ m_PosPrices[i] = (Byte)(((price != 0) ? price: kNoPosStatPrice) + kDistDirectBits[i]);
+ }
+}
+
+static NO_INLINE void Huffman_ReverseBits(UInt32 *codes, const Byte *lens, UInt32 num)
+{
+ for (UInt32 i = 0; i < num; i++)
+ {
+ UInt32 x = codes[i];
+ x = ((x & 0x5555) << 1) | ((x & 0xAAAA) >> 1);
+ x = ((x & 0x3333) << 2) | ((x & 0xCCCC) >> 2);
+ x = ((x & 0x0F0F) << 4) | ((x & 0xF0F0) >> 4);
+ codes[i] = (((x & 0x00FF) << 8) | ((x & 0xFF00) >> 8)) >> (16 - lens[i]);
+ }
+}
+
+NO_INLINE void CCoder::WriteBlock()
+{
+ Huffman_ReverseBits(mainCodes, m_NewLevels.litLenLevels, kFixedMainTableSize);
+ Huffman_ReverseBits(distCodes, m_NewLevels.distLevels, kDistTableSize64);
+
+ for (UInt32 i = 0; i < m_ValueIndex; i++)
+ {
+ const CCodeValue &codeValue = m_Values[i];
+ if (codeValue.IsLiteral())
+ WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, codeValue.Pos);
+ else
+ {
+ UInt32 len = codeValue.Len;
+ UInt32 lenSlot = g_LenSlots[len];
+ WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, kSymbolMatch + lenSlot);
+ m_OutStream.WriteBits(len - m_LenStart[lenSlot], m_LenDirectBits[lenSlot]);
+ UInt32 dist = codeValue.Pos;
+ UInt32 posSlot = GetPosSlot(dist);
+ WRITE_HF2(distCodes, m_NewLevels.distLevels, posSlot);
+ m_OutStream.WriteBits(dist - kDistStart[posSlot], kDistDirectBits[posSlot]);
+ }
+ }
+ WRITE_HF2(mainCodes, m_NewLevels.litLenLevels, kSymbolEndOfBlock);
+}
+
+static UInt32 GetStorePrice(UInt32 blockSize, unsigned bitPosition)
+{
+ UInt32 price = 0;
+ do
+ {
+ UInt32 nextBitPosition = (bitPosition + kFinalBlockFieldSize + kBlockTypeFieldSize) & 7;
+ unsigned numBitsForAlign = nextBitPosition > 0 ? (8 - nextBitPosition): 0;
+ UInt32 curBlockSize = (blockSize < (1 << 16)) ? blockSize : (1 << 16) - 1;
+ price += kFinalBlockFieldSize + kBlockTypeFieldSize + numBitsForAlign + (2 + 2) * 8 + curBlockSize * 8;
+ bitPosition = 0;
+ blockSize -= curBlockSize;
+ }
+ while (blockSize != 0);
+ return price;
+}
+
+void CCoder::WriteStoreBlock(UInt32 blockSize, UInt32 additionalOffset, bool finalBlock)
+{
+ do
+ {
+ UInt32 curBlockSize = (blockSize < (1 << 16)) ? blockSize : (1 << 16) - 1;
+ blockSize -= curBlockSize;
+ WriteBits((finalBlock && (blockSize == 0) ? NFinalBlockField::kFinalBlock: NFinalBlockField::kNotFinalBlock), kFinalBlockFieldSize);
+ WriteBits(NBlockType::kStored, kBlockTypeFieldSize);
+ m_OutStream.FlushByte();
+ WriteBits((UInt16)curBlockSize, kStoredBlockLengthFieldSize);
+ WriteBits((UInt16)~curBlockSize, kStoredBlockLengthFieldSize);
+ const Byte *data = Inline_MatchFinder_GetPointerToCurrentPos(&_lzInWindow)- additionalOffset;
+ for (UInt32 i = 0; i < curBlockSize; i++)
+ m_OutStream.WriteByte(data[i]);
+ additionalOffset -= curBlockSize;
+ }
+ while (blockSize != 0);
+}
+
+NO_INLINE UInt32 CCoder::TryDynBlock(unsigned tableIndex, UInt32 numPasses)
+{
+ CTables &t = m_Tables[tableIndex];
+ BlockSizeRes = t.BlockSizeRes;
+ UInt32 posTemp = t.m_Pos;
+ SetPrices(t);
+
+ for (UInt32 p = 0; p < numPasses; p++)
+ {
+ m_Pos = posTemp;
+ TryBlock();
+ unsigned numHuffBits =
+ (m_ValueIndex > 18000 ? 12 :
+ (m_ValueIndex > 7000 ? 11 :
+ (m_ValueIndex > 2000 ? 10 : 9)));
+ MakeTables(numHuffBits);
+ SetPrices(m_NewLevels);
+ }
+
+ (CLevels &)t = m_NewLevels;
+
+ m_NumLitLenLevels = kMainTableSize;
+ while (m_NumLitLenLevels > kNumLitLenCodesMin && m_NewLevels.litLenLevels[(size_t)m_NumLitLenLevels - 1] == 0)
+ m_NumLitLenLevels--;
+
+ m_NumDistLevels = kDistTableSize64;
+ while (m_NumDistLevels > kNumDistCodesMin && m_NewLevels.distLevels[(size_t)m_NumDistLevels - 1] == 0)
+ m_NumDistLevels--;
+
+ UInt32 levelFreqs[kLevelTableSize];
+ memset(levelFreqs, 0, sizeof(levelFreqs));
+
+ LevelTableDummy(m_NewLevels.litLenLevels, m_NumLitLenLevels, levelFreqs);
+ LevelTableDummy(m_NewLevels.distLevels, m_NumDistLevels, levelFreqs);
+
+ Huffman_Generate(levelFreqs, levelCodes, levelLens, kLevelTableSize, kMaxLevelBitLength);
+
+ m_NumLevelCodes = kNumLevelCodesMin;
+ for (UInt32 i = 0; i < kLevelTableSize; i++)
+ {
+ Byte level = levelLens[kCodeLengthAlphabetOrder[i]];
+ if (level > 0 && i >= m_NumLevelCodes)
+ m_NumLevelCodes = i + 1;
+ m_LevelLevels[i] = level;
+ }
+
+ return GetLzBlockPrice() +
+ Huffman_GetPrice_Spec(levelFreqs, levelLens, kLevelTableSize, kLevelDirectBits, kTableDirectLevels) +
+ kNumLenCodesFieldSize + kNumDistCodesFieldSize + kNumLevelCodesFieldSize +
+ m_NumLevelCodes * kLevelFieldSize + kFinalBlockFieldSize + kBlockTypeFieldSize;
+}
+
+NO_INLINE UInt32 CCoder::TryFixedBlock(unsigned tableIndex)
+{
+ CTables &t = m_Tables[tableIndex];
+ BlockSizeRes = t.BlockSizeRes;
+ m_Pos = t.m_Pos;
+ m_NewLevels.SetFixedLevels();
+ SetPrices(m_NewLevels);
+ TryBlock();
+ return kFinalBlockFieldSize + kBlockTypeFieldSize + GetLzBlockPrice();
+}
+
+NO_INLINE UInt32 CCoder::GetBlockPrice(unsigned tableIndex, unsigned numDivPasses)
+{
+ CTables &t = m_Tables[tableIndex];
+ t.StaticMode = false;
+ UInt32 price = TryDynBlock(tableIndex, m_NumPasses);
+ t.BlockSizeRes = BlockSizeRes;
+ UInt32 numValues = m_ValueIndex;
+ UInt32 posTemp = m_Pos;
+ UInt32 additionalOffsetEnd = m_AdditionalOffset;
+
+ if (m_CheckStatic && m_ValueIndex <= kFixedHuffmanCodeBlockSizeMax)
+ {
+ const UInt32 fixedPrice = TryFixedBlock(tableIndex);
+ t.StaticMode = (fixedPrice < price);
+ if (t.StaticMode)
+ price = fixedPrice;
+ }
+
+ const UInt32 storePrice = GetStorePrice(BlockSizeRes, 0); // bitPosition
+ t.StoreMode = (storePrice <= price);
+ if (t.StoreMode)
+ price = storePrice;
+
+ t.UseSubBlocks = false;
+
+ if (numDivPasses > 1 && numValues >= kDivideCodeBlockSizeMin)
+ {
+ CTables &t0 = m_Tables[(tableIndex << 1)];
+ (CLevels &)t0 = t;
+ t0.BlockSizeRes = t.BlockSizeRes >> 1;
+ t0.m_Pos = t.m_Pos;
+ UInt32 subPrice = GetBlockPrice((tableIndex << 1), numDivPasses - 1);
+
+ UInt32 blockSize2 = t.BlockSizeRes - t0.BlockSizeRes;
+ if (t0.BlockSizeRes >= kDivideBlockSizeMin && blockSize2 >= kDivideBlockSizeMin)
+ {
+ CTables &t1 = m_Tables[(tableIndex << 1) + 1];
+ (CLevels &)t1 = t;
+ t1.BlockSizeRes = blockSize2;
+ t1.m_Pos = m_Pos;
+ m_AdditionalOffset -= t0.BlockSizeRes;
+ subPrice += GetBlockPrice((tableIndex << 1) + 1, numDivPasses - 1);
+ t.UseSubBlocks = (subPrice < price);
+ if (t.UseSubBlocks)
+ price = subPrice;
+ }
+ }
+
+ m_AdditionalOffset = additionalOffsetEnd;
+ m_Pos = posTemp;
+ return price;
+}
+
+void CCoder::CodeBlock(unsigned tableIndex, bool finalBlock)
+{
+ CTables &t = m_Tables[tableIndex];
+ if (t.UseSubBlocks)
+ {
+ CodeBlock((tableIndex << 1), false);
+ CodeBlock((tableIndex << 1) + 1, finalBlock);
+ }
+ else
+ {
+ if (t.StoreMode)
+ WriteStoreBlock(t.BlockSizeRes, m_AdditionalOffset, finalBlock);
+ else
+ {
+ WriteBits((finalBlock ? NFinalBlockField::kFinalBlock: NFinalBlockField::kNotFinalBlock), kFinalBlockFieldSize);
+ if (t.StaticMode)
+ {
+ WriteBits(NBlockType::kFixedHuffman, kBlockTypeFieldSize);
+ TryFixedBlock(tableIndex);
+ unsigned i;
+ const unsigned kMaxStaticHuffLen = 9;
+ for (i = 0; i < kFixedMainTableSize; i++)
+ mainFreqs[i] = (UInt32)1 << (kMaxStaticHuffLen - m_NewLevels.litLenLevels[i]);
+ for (i = 0; i < kFixedDistTableSize; i++)
+ distFreqs[i] = (UInt32)1 << (kMaxStaticHuffLen - m_NewLevels.distLevels[i]);
+ MakeTables(kMaxStaticHuffLen);
+ }
+ else
+ {
+ if (m_NumDivPasses > 1 || m_CheckStatic)
+ TryDynBlock(tableIndex, 1);
+ WriteBits(NBlockType::kDynamicHuffman, kBlockTypeFieldSize);
+ WriteBits(m_NumLitLenLevels - kNumLitLenCodesMin, kNumLenCodesFieldSize);
+ WriteBits(m_NumDistLevels - kNumDistCodesMin, kNumDistCodesFieldSize);
+ WriteBits(m_NumLevelCodes - kNumLevelCodesMin, kNumLevelCodesFieldSize);
+
+ for (UInt32 i = 0; i < m_NumLevelCodes; i++)
+ WriteBits(m_LevelLevels[i], kLevelFieldSize);
+
+ Huffman_ReverseBits(levelCodes, levelLens, kLevelTableSize);
+ LevelTableCode(m_NewLevels.litLenLevels, m_NumLitLenLevels, levelLens, levelCodes);
+ LevelTableCode(m_NewLevels.distLevels, m_NumDistLevels, levelLens, levelCodes);
+ }
+ WriteBlock();
+ }
+ m_AdditionalOffset -= t.BlockSizeRes;
+ }
+}
+
+
+HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */ , const UInt64 * /* outSize */ , ICompressProgressInfo *progress)
+{
+ m_CheckStatic = (m_NumPasses != 1 || m_NumDivPasses != 1);
+ m_IsMultiPass = (m_CheckStatic || (m_NumPasses != 1 || m_NumDivPasses != 1));
+
+ /* we can set stream mode before MatchFinder_Create
+ if default MatchFinder mode was not STREAM_MODE) */
+ // MatchFinder_SET_STREAM_MODE(&_lzInWindow);
+
+ CSeqInStreamWrap _seqInStream;
+ _seqInStream.Init(inStream);
+ MatchFinder_SET_STREAM(&_lzInWindow, &_seqInStream.vt)
+
+ RINOK(Create())
+
+ m_ValueBlockSize = (7 << 10) + (1 << 12) * m_NumDivPasses;
+
+ UInt64 nowPos = 0;
+
+ MatchFinder_Init(&_lzInWindow);
+ m_OutStream.SetStream(outStream);
+ m_OutStream.Init();
+
+ m_OptimumEndIndex = m_OptimumCurrentIndex = 0;
+
+ CTables &t = m_Tables[1];
+ t.m_Pos = 0;
+ t.InitStructures();
+
+ m_AdditionalOffset = 0;
+ do
+ {
+ t.BlockSizeRes = kBlockUncompressedSizeThreshold;
+ m_SecondPass = false;
+ GetBlockPrice(1, m_NumDivPasses);
+ CodeBlock(1, Inline_MatchFinder_GetNumAvailableBytes(&_lzInWindow) == 0);
+ nowPos += m_Tables[1].BlockSizeRes;
+ if (progress != NULL)
+ {
+ UInt64 packSize = m_OutStream.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&nowPos, &packSize))
+ }
+ }
+ while (Inline_MatchFinder_GetNumAvailableBytes(&_lzInWindow) != 0);
+
+ if (_seqInStream.Res != S_OK)
+ return _seqInStream.Res;
+
+ if (_lzInWindow.result != SZ_OK)
+ return SResToHRESULT(_lzInWindow.result);
+ return m_OutStream.Flush();
+}
+
+HRESULT CCoder::BaseCode(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ catch(const COutBufferException &e) { return e.ErrorCode; }
+ catch(...) { return E_FAIL; }
+}
+
+Z7_COM7F_IMF(CCOMCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+ { return BaseCode(inStream, outStream, inSize, outSize, progress); }
+
+Z7_COM7F_IMF(CCOMCoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+ { return BaseSetEncoderProperties2(propIDs, props, numProps); }
+
+Z7_COM7F_IMF(CCOMCoder64::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+ { return BaseCode(inStream, outStream, inSize, outSize, progress); }
+
+Z7_COM7F_IMF(CCOMCoder64::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+ { return BaseSetEncoderProperties2(propIDs, props, numProps); }
+
+}}}
diff --git a/CPP/7zip/Compress/DeflateEncoder.h b/CPP/7zip/Compress/DeflateEncoder.h
new file mode 100644
index 0000000..be181e1
--- /dev/null
+++ b/CPP/7zip/Compress/DeflateEncoder.h
@@ -0,0 +1,203 @@
+// DeflateEncoder.h
+
+#ifndef ZIP7_INC_DEFLATE_ENCODER_H
+#define ZIP7_INC_DEFLATE_ENCODER_H
+
+#include "../../../C/LzFind.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "BitlEncoder.h"
+#include "DeflateConst.h"
+
+namespace NCompress {
+namespace NDeflate {
+namespace NEncoder {
+
+struct CCodeValue
+{
+ UInt16 Len;
+ UInt16 Pos;
+ void SetAsLiteral() { Len = (1 << 15); }
+ bool IsLiteral() const { return (Len >= (1 << 15)); }
+};
+
+struct COptimal
+{
+ UInt32 Price;
+ UInt16 PosPrev;
+ UInt16 BackPrev;
+};
+
+const UInt32 kNumOptsBase = 1 << 12;
+const UInt32 kNumOpts = kNumOptsBase + kMatchMaxLen;
+
+class CCoder;
+
+struct CTables: public CLevels
+{
+ bool UseSubBlocks;
+ bool StoreMode;
+ bool StaticMode;
+ UInt32 BlockSizeRes;
+ UInt32 m_Pos;
+ void InitStructures();
+};
+
+
+struct CEncProps
+{
+ int Level;
+ int algo;
+ int fb;
+ int btMode;
+ UInt32 mc;
+ UInt32 numPasses;
+
+ CEncProps()
+ {
+ Level = -1;
+ mc = 0;
+ algo = fb = btMode = -1;
+ numPasses = (UInt32)(Int32)-1;
+ }
+ void Normalize();
+};
+
+class CCoder
+{
+ CMatchFinder _lzInWindow;
+ CBitlEncoder m_OutStream;
+
+public:
+ CCodeValue *m_Values;
+
+ UInt16 *m_MatchDistances;
+ UInt32 m_NumFastBytes;
+ bool _fastMode;
+ bool _btMode;
+
+ UInt16 *m_OnePosMatchesMemory;
+ UInt16 *m_DistanceMemory;
+
+ UInt32 m_Pos;
+
+ unsigned m_NumPasses;
+ unsigned m_NumDivPasses;
+ bool m_CheckStatic;
+ bool m_IsMultiPass;
+ UInt32 m_ValueBlockSize;
+
+ UInt32 m_NumLenCombinations;
+ UInt32 m_MatchMaxLen;
+ const Byte *m_LenStart;
+ const Byte *m_LenDirectBits;
+
+ bool m_Created;
+ bool m_Deflate64Mode;
+
+ Byte m_LevelLevels[kLevelTableSize];
+ unsigned m_NumLitLenLevels;
+ unsigned m_NumDistLevels;
+ UInt32 m_NumLevelCodes;
+ UInt32 m_ValueIndex;
+
+ bool m_SecondPass;
+ UInt32 m_AdditionalOffset;
+
+ UInt32 m_OptimumEndIndex;
+ UInt32 m_OptimumCurrentIndex;
+
+ Byte m_LiteralPrices[256];
+ Byte m_LenPrices[kNumLenSymbolsMax];
+ Byte m_PosPrices[kDistTableSize64];
+
+ CLevels m_NewLevels;
+ UInt32 mainFreqs[kFixedMainTableSize];
+ UInt32 distFreqs[kDistTableSize64];
+ UInt32 mainCodes[kFixedMainTableSize];
+ UInt32 distCodes[kDistTableSize64];
+ UInt32 levelCodes[kLevelTableSize];
+ Byte levelLens[kLevelTableSize];
+
+ UInt32 BlockSizeRes;
+
+ CTables *m_Tables;
+ COptimal m_Optimum[kNumOpts];
+
+ UInt32 m_MatchFinderCycles;
+
+ void GetMatches();
+ void MovePos(UInt32 num);
+ UInt32 Backward(UInt32 &backRes, UInt32 cur);
+ UInt32 GetOptimal(UInt32 &backRes);
+ UInt32 GetOptimalFast(UInt32 &backRes);
+
+ void LevelTableDummy(const Byte *levels, unsigned numLevels, UInt32 *freqs);
+
+ void WriteBits(UInt32 value, unsigned numBits);
+ void LevelTableCode(const Byte *levels, unsigned numLevels, const Byte *lens, const UInt32 *codes);
+
+ void MakeTables(unsigned maxHuffLen);
+ UInt32 GetLzBlockPrice() const;
+ void TryBlock();
+ UInt32 TryDynBlock(unsigned tableIndex, UInt32 numPasses);
+
+ UInt32 TryFixedBlock(unsigned tableIndex);
+
+ void SetPrices(const CLevels &levels);
+ void WriteBlock();
+
+ HRESULT Create();
+ void Free();
+
+ void WriteStoreBlock(UInt32 blockSize, UInt32 additionalOffset, bool finalBlock);
+ void WriteTables(bool writeMode, bool finalBlock);
+
+ void WriteBlockData(bool writeMode, bool finalBlock);
+
+ UInt32 GetBlockPrice(unsigned tableIndex, unsigned numDivPasses);
+ void CodeBlock(unsigned tableIndex, bool finalBlock);
+
+ void SetProps(const CEncProps *props2);
+public:
+ CCoder(bool deflate64Mode = false);
+ ~CCoder();
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+
+ HRESULT BaseCode(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+
+ HRESULT BaseSetEncoderProperties2(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+};
+
+
+class CCOMCoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetCoderProperties,
+ public CMyUnknownImp,
+ public CCoder
+{
+ Z7_IFACES_IMP_UNK_2(ICompressCoder, ICompressSetCoderProperties)
+public:
+ CCOMCoder(): CCoder(false) {}
+};
+
+class CCOMCoder64 Z7_final:
+ public ICompressCoder,
+ public ICompressSetCoderProperties,
+ public CMyUnknownImp,
+ public CCoder
+{
+ Z7_IFACES_IMP_UNK_2(ICompressCoder, ICompressSetCoderProperties)
+public:
+ CCOMCoder64(): CCoder(true) {}
+};
+
+}}}
+
+#endif
diff --git a/CPP/7zip/Compress/DeflateRegister.cpp b/CPP/7zip/Compress/DeflateRegister.cpp
new file mode 100644
index 0000000..eaedb84
--- /dev/null
+++ b/CPP/7zip/Compress/DeflateRegister.cpp
@@ -0,0 +1,25 @@
+// DeflateRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "DeflateDecoder.h"
+#if !defined(Z7_EXTRACT_ONLY) && !defined(Z7_DEFLATE_EXTRACT_ONLY)
+#include "DeflateEncoder.h"
+#endif
+
+namespace NCompress {
+namespace NDeflate {
+
+REGISTER_CODEC_CREATE(CreateDec, NDecoder::CCOMCoder)
+
+#if !defined(Z7_EXTRACT_ONLY) && !defined(Z7_DEFLATE_EXTRACT_ONLY)
+REGISTER_CODEC_CREATE(CreateEnc, NEncoder::CCOMCoder)
+#else
+#define CreateEnc NULL
+#endif
+
+REGISTER_CODEC_2(Deflate, CreateDec, CreateEnc, 0x40108, "Deflate")
+
+}}
diff --git a/CPP/7zip/Compress/DeltaFilter.cpp b/CPP/7zip/Compress/DeltaFilter.cpp
index cdbd33d..35b77ba 100644
--- a/CPP/7zip/Compress/DeltaFilter.cpp
+++ b/CPP/7zip/Compress/DeltaFilter.cpp
@@ -1,128 +1,126 @@
-// DeltaFilter.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Delta.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-#include "../Common/RegisterCodec.h"
-
-namespace NCompress {
-namespace NDelta {
-
-struct CDelta
-{
- unsigned _delta;
- Byte _state[DELTA_STATE_SIZE];
-
- CDelta(): _delta(1) {}
- void DeltaInit() { Delta_Init(_state); }
-};
-
-
-#ifndef EXTRACT_ONLY
-
-class CEncoder:
- public ICompressFilter,
- public ICompressSetCoderProperties,
- public ICompressWriteCoderProperties,
- CDelta,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP3(ICompressFilter, ICompressSetCoderProperties, ICompressWriteCoderProperties)
- INTERFACE_ICompressFilter(;)
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
-};
-
-STDMETHODIMP CEncoder::Init()
-{
- DeltaInit();
- return S_OK;
-}
-
-STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
-{
- Delta_Encode(_state, _delta, data, size);
- return size;
-}
-
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
-{
- UInt32 delta = _delta;
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = props[i];
- PROPID propID = propIDs[i];
- if (propID >= NCoderPropID::kReduceSize)
- continue;
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- switch (propID)
- {
- case NCoderPropID::kDefaultProp:
- delta = (UInt32)prop.ulVal;
- if (delta < 1 || delta > 256)
- return E_INVALIDARG;
- break;
- case NCoderPropID::kNumThreads: break;
- case NCoderPropID::kLevel: break;
- default: return E_INVALIDARG;
- }
- }
- _delta = delta;
- return S_OK;
-}
-
-STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
-{
- Byte prop = (Byte)(_delta - 1);
- return outStream->Write(&prop, 1, NULL);
-}
-
-#endif
-
-
-class CDecoder:
- public ICompressFilter,
- public ICompressSetDecoderProperties2,
- CDelta,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP2(ICompressFilter, ICompressSetDecoderProperties2)
- INTERFACE_ICompressFilter(;)
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
-};
-
-STDMETHODIMP CDecoder::Init()
-{
- DeltaInit();
- return S_OK;
-}
-
-STDMETHODIMP_(UInt32) CDecoder::Filter(Byte *data, UInt32 size)
-{
- Delta_Decode(_state, _delta, data, size);
- return size;
-}
-
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
-{
- if (size != 1)
- return E_INVALIDARG;
- _delta = (unsigned)props[0] + 1;
- return S_OK;
-}
-
-
-REGISTER_FILTER_E(Delta,
- CDecoder(),
- CEncoder(),
- 3, "Delta")
-
-}}
+// DeltaFilter.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Delta.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+namespace NCompress {
+namespace NDelta {
+
+struct CDelta
+{
+ unsigned _delta;
+ Byte _state[DELTA_STATE_SIZE];
+
+ CDelta(): _delta(1) {}
+ void DeltaInit() { Delta_Init(_state); }
+};
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+class CEncoder Z7_final:
+ public ICompressFilter,
+ public ICompressSetCoderProperties,
+ public ICompressWriteCoderProperties,
+ public CMyUnknownImp,
+ CDelta
+{
+ Z7_IFACES_IMP_UNK_3(
+ ICompressFilter,
+ ICompressSetCoderProperties,
+ ICompressWriteCoderProperties)
+};
+
+Z7_COM7F_IMF(CEncoder::Init())
+{
+ DeltaInit();
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt32, CEncoder::Filter(Byte *data, UInt32 size))
+{
+ Delta_Encode(_state, _delta, data, size);
+ return size;
+}
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+{
+ UInt32 delta = _delta;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = props[i];
+ const PROPID propID = propIDs[i];
+ if (propID >= NCoderPropID::kReduceSize)
+ continue;
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ switch (propID)
+ {
+ case NCoderPropID::kDefaultProp:
+ delta = (UInt32)prop.ulVal;
+ if (delta < 1 || delta > 256)
+ return E_INVALIDARG;
+ break;
+ case NCoderPropID::kNumThreads: break;
+ case NCoderPropID::kLevel: break;
+ default: return E_INVALIDARG;
+ }
+ }
+ _delta = delta;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+{
+ const Byte prop = (Byte)(_delta - 1);
+ return outStream->Write(&prop, 1, NULL);
+}
+
+#endif
+
+
+class CDecoder Z7_final:
+ public ICompressFilter,
+ public ICompressSetDecoderProperties2,
+ public CMyUnknownImp,
+ CDelta
+{
+ Z7_IFACES_IMP_UNK_2(
+ ICompressFilter,
+ ICompressSetDecoderProperties2)
+};
+
+Z7_COM7F_IMF(CDecoder::Init())
+{
+ DeltaInit();
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+{
+ Delta_Decode(_state, _delta, data, size);
+ return size;
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size))
+{
+ if (size != 1)
+ return E_INVALIDARG;
+ _delta = (unsigned)props[0] + 1;
+ return S_OK;
+}
+
+
+REGISTER_FILTER_E(Delta,
+ CDecoder(),
+ CEncoder(),
+ 3, "Delta")
+
+}}
diff --git a/CPP/7zip/Compress/DllExports2Compress.cpp b/CPP/7zip/Compress/DllExports2Compress.cpp
new file mode 100644
index 0000000..a6ff690
--- /dev/null
+++ b/CPP/7zip/Compress/DllExports2Compress.cpp
@@ -0,0 +1,28 @@
+// DllExports2Compress.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyInitGuid.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ /* hInstance */, DWORD /* dwReason */, LPVOID /*lpReserved*/)
+{
+ return TRUE;
+}
+
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
+
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
+{
+ return CreateCoder(clsid, iid, outObject);
+}
diff --git a/CPP/7zip/Compress/DllExportsCompress.cpp b/CPP/7zip/Compress/DllExportsCompress.cpp
new file mode 100644
index 0000000..24749d2
--- /dev/null
+++ b/CPP/7zip/Compress/DllExportsCompress.cpp
@@ -0,0 +1,59 @@
+// DllExportsCompress.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyInitGuid.h"
+
+#include "../ICoder.h"
+
+#include "../Common/RegisterCodec.h"
+
+static const unsigned kNumCodecsMax = 48;
+unsigned g_NumCodecs = 0;
+const CCodecInfo *g_Codecs[kNumCodecsMax];
+void RegisterCodec(const CCodecInfo *codecInfo) throw()
+{
+ if (g_NumCodecs < kNumCodecsMax)
+ g_Codecs[g_NumCodecs++] = codecInfo;
+}
+
+static const unsigned kNumHashersMax = 16;
+unsigned g_NumHashers = 0;
+const CHasherInfo *g_Hashers[kNumHashersMax];
+void RegisterHasher(const CHasherInfo *hashInfo) throw()
+{
+ if (g_NumHashers < kNumHashersMax)
+ g_Hashers[g_NumHashers++] = hashInfo;
+}
+
+#ifdef _WIN32
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ , DWORD /* dwReason */, LPVOID /*lpReserved*/);
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ , DWORD /* dwReason */, LPVOID /*lpReserved*/)
+{
+ return TRUE;
+}
+#endif
+
+STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
+
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject);
+STDAPI CreateObject(const GUID *clsid, const GUID *iid, void **outObject)
+{
+ return CreateCoder(clsid, iid, outObject);
+}
diff --git a/CPP/7zip/Compress/HuffmanDecoder.h b/CPP/7zip/Compress/HuffmanDecoder.h
new file mode 100644
index 0000000..4b8169f
--- /dev/null
+++ b/CPP/7zip/Compress/HuffmanDecoder.h
@@ -0,0 +1,278 @@
+// Compress/HuffmanDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_HUFFMAN_DECODER_H
+#define ZIP7_INC_COMPRESS_HUFFMAN_DECODER_H
+
+#include "../../Common/MyTypes.h"
+
+namespace NCompress {
+namespace NHuffman {
+
+const unsigned kNumPairLenBits = 4;
+const unsigned kPairLenMask = (1 << kNumPairLenBits) - 1;
+
+template <unsigned kNumBitsMax, UInt32 m_NumSymbols, unsigned kNumTableBits = 9>
+class CDecoder
+{
+public:
+ UInt32 _limits[kNumBitsMax + 2];
+ UInt32 _poses[kNumBitsMax + 1];
+ UInt16 _lens[1 << kNumTableBits];
+ UInt16 _symbols[m_NumSymbols];
+
+ bool Build(const Byte *lens) throw()
+ {
+ UInt32 counts[kNumBitsMax + 1];
+
+ unsigned i;
+ for (i = 0; i <= kNumBitsMax; i++)
+ counts[i] = 0;
+
+ UInt32 sym;
+
+ for (sym = 0; sym < m_NumSymbols; sym++)
+ counts[lens[sym]]++;
+
+ const UInt32 kMaxValue = (UInt32)1 << kNumBitsMax;
+
+ _limits[0] = 0;
+
+ UInt32 startPos = 0;
+ UInt32 sum = 0;
+
+ for (i = 1; i <= kNumBitsMax; i++)
+ {
+ const UInt32 cnt = counts[i];
+ startPos += cnt << (kNumBitsMax - i);
+ if (startPos > kMaxValue)
+ return false;
+ _limits[i] = startPos;
+ counts[i] = sum;
+ _poses[i] = sum;
+ sum += cnt;
+ }
+
+ counts[0] = sum;
+ _poses[0] = sum;
+ _limits[kNumBitsMax + 1] = kMaxValue;
+
+ for (sym = 0; sym < m_NumSymbols; sym++)
+ {
+ unsigned len = lens[sym];
+ if (len == 0)
+ continue;
+
+ unsigned offset = counts[len]++;
+ _symbols[offset] = (UInt16)sym;
+
+ if (len <= kNumTableBits)
+ {
+ offset -= _poses[len];
+ UInt32 num = (UInt32)1 << (kNumTableBits - len);
+ UInt16 val = (UInt16)((sym << kNumPairLenBits) | len);
+ UInt16 *dest = _lens + (_limits[(size_t)len - 1] >> (kNumBitsMax - kNumTableBits)) + (offset << (kNumTableBits - len));
+ for (UInt32 k = 0; k < num; k++)
+ dest[k] = val;
+ }
+ }
+
+ return true;
+ }
+
+
+ bool BuildFull(const Byte *lens, UInt32 numSymbols = m_NumSymbols) throw()
+ {
+ UInt32 counts[kNumBitsMax + 1];
+
+ unsigned i;
+ for (i = 0; i <= kNumBitsMax; i++)
+ counts[i] = 0;
+
+ UInt32 sym;
+
+ for (sym = 0; sym < numSymbols; sym++)
+ counts[lens[sym]]++;
+
+ const UInt32 kMaxValue = (UInt32)1 << kNumBitsMax;
+
+ _limits[0] = 0;
+
+ UInt32 startPos = 0;
+ UInt32 sum = 0;
+
+ for (i = 1; i <= kNumBitsMax; i++)
+ {
+ const UInt32 cnt = counts[i];
+ startPos += cnt << (kNumBitsMax - i);
+ if (startPos > kMaxValue)
+ return false;
+ _limits[i] = startPos;
+ counts[i] = sum;
+ _poses[i] = sum;
+ sum += cnt;
+ }
+
+ counts[0] = sum;
+ _poses[0] = sum;
+ _limits[kNumBitsMax + 1] = kMaxValue;
+
+ for (sym = 0; sym < numSymbols; sym++)
+ {
+ unsigned len = lens[sym];
+ if (len == 0)
+ continue;
+
+ unsigned offset = counts[len]++;
+ _symbols[offset] = (UInt16)sym;
+
+ if (len <= kNumTableBits)
+ {
+ offset -= _poses[len];
+ UInt32 num = (UInt32)1 << (kNumTableBits - len);
+ UInt16 val = (UInt16)((sym << kNumPairLenBits) | len);
+ UInt16 *dest = _lens + (_limits[(size_t)len - 1] >> (kNumBitsMax - kNumTableBits)) + (offset << (kNumTableBits - len));
+ for (UInt32 k = 0; k < num; k++)
+ dest[k] = val;
+ }
+ }
+
+ return startPos == kMaxValue;
+ }
+
+
+ template <class TBitDecoder>
+ Z7_FORCE_INLINE
+ UInt32 Decode(TBitDecoder *bitStream) const
+ {
+ UInt32 val = bitStream->GetValue(kNumBitsMax);
+
+ if (val < _limits[kNumTableBits])
+ {
+ UInt32 pair = _lens[val >> (kNumBitsMax - kNumTableBits)];
+ bitStream->MovePos((unsigned)(pair & kPairLenMask));
+ return pair >> kNumPairLenBits;
+ }
+
+ unsigned numBits;
+ for (numBits = kNumTableBits + 1; val >= _limits[numBits]; numBits++);
+
+ if (numBits > kNumBitsMax)
+ return 0xFFFFFFFF;
+
+ bitStream->MovePos(numBits);
+ UInt32 index = _poses[numBits] + ((val - _limits[(size_t)numBits - 1]) >> (kNumBitsMax - numBits));
+ return _symbols[index];
+ }
+
+
+ template <class TBitDecoder>
+ Z7_FORCE_INLINE
+ UInt32 DecodeFull(TBitDecoder *bitStream) const
+ {
+ UInt32 val = bitStream->GetValue(kNumBitsMax);
+
+ if (val < _limits[kNumTableBits])
+ {
+ UInt32 pair = _lens[val >> (kNumBitsMax - kNumTableBits)];
+ bitStream->MovePos((unsigned)(pair & kPairLenMask));
+ return pair >> kNumPairLenBits;
+ }
+
+ unsigned numBits;
+ for (numBits = kNumTableBits + 1; val >= _limits[numBits]; numBits++);
+
+ bitStream->MovePos(numBits);
+ UInt32 index = _poses[numBits] + ((val - _limits[(size_t)numBits - 1]) >> (kNumBitsMax - numBits));
+ return _symbols[index];
+ }
+};
+
+
+
+template <UInt32 m_NumSymbols>
+class CDecoder7b
+{
+ Byte _lens[1 << 7];
+public:
+
+ bool Build(const Byte *lens) throw()
+ {
+ const unsigned kNumBitsMax = 7;
+
+ UInt32 counts[kNumBitsMax + 1];
+ UInt32 _poses[kNumBitsMax + 1];
+ UInt32 _limits[kNumBitsMax + 1];
+
+ unsigned i;
+ for (i = 0; i <= kNumBitsMax; i++)
+ counts[i] = 0;
+
+ UInt32 sym;
+
+ for (sym = 0; sym < m_NumSymbols; sym++)
+ counts[lens[sym]]++;
+
+ const UInt32 kMaxValue = (UInt32)1 << kNumBitsMax;
+
+ _limits[0] = 0;
+
+ UInt32 startPos = 0;
+ UInt32 sum = 0;
+
+ for (i = 1; i <= kNumBitsMax; i++)
+ {
+ const UInt32 cnt = counts[i];
+ startPos += cnt << (kNumBitsMax - i);
+ if (startPos > kMaxValue)
+ return false;
+ _limits[i] = startPos;
+ counts[i] = sum;
+ _poses[i] = sum;
+ sum += cnt;
+ }
+
+ counts[0] = sum;
+ _poses[0] = sum;
+
+ for (sym = 0; sym < m_NumSymbols; sym++)
+ {
+ unsigned len = lens[sym];
+ if (len == 0)
+ continue;
+
+ unsigned offset = counts[len]++;
+
+ {
+ offset -= _poses[len];
+ UInt32 num = (UInt32)1 << (kNumBitsMax - len);
+ Byte val = (Byte)((sym << 3) | len);
+ Byte *dest = _lens + (_limits[(size_t)len - 1]) + (offset << (kNumBitsMax - len));
+ for (UInt32 k = 0; k < num; k++)
+ dest[k] = val;
+ }
+ }
+
+ {
+ UInt32 limit = _limits[kNumBitsMax];
+ UInt32 num = ((UInt32)1 << kNumBitsMax) - limit;
+ Byte *dest = _lens + limit;
+ for (UInt32 k = 0; k < num; k++)
+ dest[k] = (Byte)(0x1F << 3);
+ }
+
+ return true;
+ }
+
+ template <class TBitDecoder>
+ UInt32 Decode(TBitDecoder *bitStream) const
+ {
+ UInt32 val = bitStream->GetValue(7);
+ UInt32 pair = _lens[val];
+ bitStream->MovePos((unsigned)(pair & 0x7));
+ return pair >> 3;
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/ImplodeDecoder.cpp b/CPP/7zip/Compress/ImplodeDecoder.cpp
new file mode 100644
index 0000000..12f2dce
--- /dev/null
+++ b/CPP/7zip/Compress/ImplodeDecoder.cpp
@@ -0,0 +1,258 @@
+// ImplodeDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/Defs.h"
+
+#include "ImplodeDecoder.h"
+
+namespace NCompress {
+namespace NImplode {
+namespace NDecoder {
+
+bool CHuffmanDecoder::Build(const Byte *lens, unsigned numSymbols) throw()
+{
+ unsigned counts[kNumHuffmanBits + 1];
+
+ unsigned i;
+ for (i = 0; i <= kNumHuffmanBits; i++)
+ counts[i] = 0;
+
+ unsigned sym;
+ for (sym = 0; sym < numSymbols; sym++)
+ counts[lens[sym]]++;
+
+ const UInt32 kMaxValue = (UInt32)1 << kNumHuffmanBits;
+
+ // _limits[0] = kMaxValue;
+
+ UInt32 startPos = kMaxValue;
+ UInt32 sum = 0;
+
+ for (i = 1; i <= kNumHuffmanBits; i++)
+ {
+ const UInt32 cnt = counts[i];
+ const UInt32 range = cnt << (kNumHuffmanBits - i);
+ if (startPos < range)
+ return false;
+ startPos -= range;
+ _limits[i] = startPos;
+ _poses[i] = sum;
+ sum += cnt;
+ counts[i] = sum;
+ }
+
+ // counts[0] += sum;
+
+ if (startPos != 0)
+ return false;
+
+ for (sym = 0; sym < numSymbols; sym++)
+ {
+ const unsigned len = lens[sym];
+ if (len != 0)
+ _symbols[--counts[len]] = (Byte)sym;
+ }
+
+ return true;
+}
+
+
+UInt32 CHuffmanDecoder::Decode(CInBit *inStream) const throw()
+{
+ const UInt32 val = inStream->GetValue(kNumHuffmanBits);
+ unsigned numBits;
+ for (numBits = 1; val < _limits[numBits]; numBits++);
+ const UInt32 sym = _symbols[_poses[numBits] + ((val - _limits[numBits]) >> (kNumHuffmanBits - numBits))];
+ inStream->MovePos(numBits);
+ return sym;
+}
+
+
+
+static const unsigned kNumLenDirectBits = 8;
+
+static const unsigned kNumDistDirectBitsSmall = 6;
+static const unsigned kNumDistDirectBitsBig = 7;
+
+static const unsigned kLitTableSize = (1 << 8);
+static const unsigned kDistTableSize = 64;
+static const unsigned kLenTableSize = 64;
+
+static const UInt32 kHistorySize = (1 << kNumDistDirectBitsBig) * kDistTableSize; // 8 KB
+
+
+CCoder::CCoder():
+ _flags(0),
+ _fullStreamMode(false)
+{}
+
+
+bool CCoder::BuildHuff(CHuffmanDecoder &decoder, unsigned numSymbols)
+{
+ Byte levels[kMaxHuffTableSize];
+ unsigned numRecords = (unsigned)_inBitStream.ReadAlignedByte() + 1;
+ unsigned index = 0;
+ do
+ {
+ const unsigned b = (unsigned)_inBitStream.ReadAlignedByte();
+ const Byte level = (Byte)((b & 0xF) + 1);
+ const unsigned rep = ((unsigned)b >> 4) + 1;
+ if (index + rep > numSymbols)
+ return false;
+ for (unsigned j = 0; j < rep; j++)
+ levels[index++] = level;
+ }
+ while (--numRecords);
+
+ if (index != numSymbols)
+ return false;
+ return decoder.Build(levels, numSymbols);
+}
+
+
+HRESULT CCoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ if (!_inBitStream.Create(1 << 18))
+ return E_OUTOFMEMORY;
+ if (!_outWindowStream.Create(kHistorySize << 1)) // 16 KB
+ return E_OUTOFMEMORY;
+ if (!outSize)
+ return E_INVALIDARG;
+
+ _outWindowStream.SetStream(outStream);
+ _outWindowStream.Init(false);
+ _inBitStream.SetStream(inStream);
+ _inBitStream.Init();
+
+ const unsigned numDistDirectBits = (_flags & 2) ?
+ kNumDistDirectBitsBig:
+ kNumDistDirectBitsSmall;
+ const bool literalsOn = ((_flags & 4) != 0);
+ const UInt32 minMatchLen = (literalsOn ? 3 : 2);
+
+ if (literalsOn)
+ if (!BuildHuff(_litDecoder, kLitTableSize))
+ return S_FALSE;
+ if (!BuildHuff(_lenDecoder, kLenTableSize))
+ return S_FALSE;
+ if (!BuildHuff(_distDecoder, kDistTableSize))
+ return S_FALSE;
+
+ UInt64 prevProgress = 0;
+ bool moreOut = false;
+ UInt64 pos = 0, unPackSize = *outSize;
+
+ while (pos < unPackSize)
+ {
+ if (progress && (pos - prevProgress) >= (1 << 18))
+ {
+ const UInt64 packSize = _inBitStream.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &pos))
+ prevProgress = pos;
+ }
+
+ if (_inBitStream.ReadBits(1) != 0)
+ {
+ Byte b;
+ if (literalsOn)
+ {
+ const UInt32 sym = _litDecoder.Decode(&_inBitStream);
+ // if (sym >= kLitTableSize) break;
+ b = (Byte)sym;
+ }
+ else
+ b = (Byte)_inBitStream.ReadBits(8);
+ _outWindowStream.PutByte(b);
+ pos++;
+ }
+ else
+ {
+ const UInt32 lowDistBits = _inBitStream.ReadBits(numDistDirectBits);
+ UInt32 dist = _distDecoder.Decode(&_inBitStream);
+ // if (dist >= kDistTableSize) break;
+ dist = (dist << numDistDirectBits) + lowDistBits;
+ UInt32 len = _lenDecoder.Decode(&_inBitStream);
+ // if (len >= kLenTableSize) break;
+ if (len == kLenTableSize - 1)
+ len += _inBitStream.ReadBits(kNumLenDirectBits);
+ len += minMatchLen;
+
+ {
+ const UInt64 limit = unPackSize - pos;
+ if (len > limit)
+ {
+ moreOut = true;
+ len = (UInt32)limit;
+ }
+ }
+
+ while (dist >= pos && len != 0)
+ {
+ _outWindowStream.PutByte(0);
+ pos++;
+ len--;
+ }
+
+ if (len != 0)
+ {
+ _outWindowStream.CopyBlock(dist, len);
+ pos += len;
+ }
+ }
+ }
+
+ HRESULT res = _outWindowStream.Flush();
+
+ if (res == S_OK)
+ {
+ if (_fullStreamMode)
+ {
+ if (moreOut)
+ res = S_FALSE;
+ if (inSize && *inSize != _inBitStream.GetProcessedSize())
+ res = S_FALSE;
+ }
+ if (pos != unPackSize)
+ res = S_FALSE;
+ }
+
+ return res;
+}
+
+
+Z7_COM7F_IMF(CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ // catch(const CInBufferException &e) { return e.ErrorCode; }
+ // catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(const CSystemException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+
+Z7_COM7F_IMF(CCoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ if (size == 0)
+ return E_NOTIMPL;
+ _flags = data[0];
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::SetFinishMode(UInt32 finishMode))
+{
+ _fullStreamMode = (finishMode != 0);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = _inBitStream.GetProcessedSize();
+ return S_OK;
+}
+
+}}}
diff --git a/CPP/7zip/Compress/ImplodeDecoder.h b/CPP/7zip/Compress/ImplodeDecoder.h
new file mode 100644
index 0000000..ec70045
--- /dev/null
+++ b/CPP/7zip/Compress/ImplodeDecoder.h
@@ -0,0 +1,61 @@
+// ImplodeDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_IMPLODE_DECODER_H
+#define ZIP7_INC_COMPRESS_IMPLODE_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitlDecoder.h"
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NImplode {
+namespace NDecoder {
+
+typedef NBitl::CDecoder<CInBuffer> CInBit;
+
+const unsigned kNumHuffmanBits = 16;
+const unsigned kMaxHuffTableSize = 1 << 8;
+
+class CHuffmanDecoder
+{
+ UInt32 _limits[kNumHuffmanBits + 1];
+ UInt32 _poses[kNumHuffmanBits + 1];
+ Byte _symbols[kMaxHuffTableSize];
+public:
+ bool Build(const Byte *lens, unsigned numSymbols) throw();
+ UInt32 Decode(CInBit *inStream) const throw();
+};
+
+
+Z7_CLASS_IMP_NOQIB_4(
+ CCoder
+ , ICompressCoder
+ , ICompressSetDecoderProperties2
+ , ICompressSetFinishMode
+ , ICompressGetInStreamProcessedSize
+)
+ CLzOutWindow _outWindowStream;
+ CInBit _inBitStream;
+
+ CHuffmanDecoder _litDecoder;
+ CHuffmanDecoder _lenDecoder;
+ CHuffmanDecoder _distDecoder;
+
+ Byte _flags;
+ bool _fullStreamMode;
+
+ bool BuildHuff(CHuffmanDecoder &table, unsigned numSymbols);
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+public:
+ CCoder();
+};
+
+}}}
+
+#endif
diff --git a/CPP/7zip/Compress/ImplodeHuffmanDecoder.cpp b/CPP/7zip/Compress/ImplodeHuffmanDecoder.cpp
new file mode 100644
index 0000000..7d31bb9
--- /dev/null
+++ b/CPP/7zip/Compress/ImplodeHuffmanDecoder.cpp
@@ -0,0 +1,3 @@
+// ImplodeHuffmanDecoder.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/Compress/ImplodeHuffmanDecoder.h b/CPP/7zip/Compress/ImplodeHuffmanDecoder.h
new file mode 100644
index 0000000..dcf8ac6
--- /dev/null
+++ b/CPP/7zip/Compress/ImplodeHuffmanDecoder.h
@@ -0,0 +1,6 @@
+// ImplodeHuffmanDecoder.h
+
+#ifndef ZIP7_INC_IMPLODE_HUFFMAN_DECODER_H
+#define ZIP7_INC_IMPLODE_HUFFMAN_DECODER_H
+
+#endif
diff --git a/CPP/7zip/Compress/LzOutWindow.cpp b/CPP/7zip/Compress/LzOutWindow.cpp
new file mode 100644
index 0000000..aae02eb
--- /dev/null
+++ b/CPP/7zip/Compress/LzOutWindow.cpp
@@ -0,0 +1,14 @@
+// LzOutWindow.cpp
+
+#include "StdAfx.h"
+
+#include "LzOutWindow.h"
+
+void CLzOutWindow::Init(bool solid) throw()
+{
+ if (!solid)
+ COutBuffer::Init();
+ #ifdef Z7_NO_EXCEPTIONS
+ ErrorCode = S_OK;
+ #endif
+}
diff --git a/CPP/7zip/Compress/LzOutWindow.h b/CPP/7zip/Compress/LzOutWindow.h
new file mode 100644
index 0000000..599b124
--- /dev/null
+++ b/CPP/7zip/Compress/LzOutWindow.h
@@ -0,0 +1,102 @@
+// LzOutWindow.h
+
+#ifndef ZIP7_INC_LZ_OUT_WINDOW_H
+#define ZIP7_INC_LZ_OUT_WINDOW_H
+
+#include "../Common/OutBuffer.h"
+
+#ifndef Z7_NO_EXCEPTIONS
+typedef COutBufferException CLzOutWindowException;
+#endif
+
+class CLzOutWindow: public COutBuffer
+{
+public:
+ void Init(bool solid = false) throw();
+
+ // distance >= 0, len > 0,
+ bool CopyBlock(UInt32 distance, UInt32 len)
+ {
+ UInt32 pos = _pos - distance - 1;
+ if (distance >= _pos)
+ {
+ if (!_overDict || distance >= _bufSize)
+ return false;
+ pos += _bufSize;
+ }
+ if (_limitPos - _pos > len && _bufSize - pos > len)
+ {
+ const Byte *src = _buf + pos;
+ Byte *dest = _buf + _pos;
+ _pos += len;
+ do
+ *dest++ = *src++;
+ while (--len != 0);
+ }
+ else do
+ {
+ UInt32 pos2;
+ if (pos == _bufSize)
+ pos = 0;
+ pos2 = _pos;
+ _buf[pos2++] = _buf[pos++];
+ _pos = pos2;
+ if (pos2 == _limitPos)
+ FlushWithCheck();
+ }
+ while (--len != 0);
+ return true;
+ }
+
+ void PutByte(Byte b)
+ {
+ UInt32 pos = _pos;
+ _buf[pos++] = b;
+ _pos = pos;
+ if (pos == _limitPos)
+ FlushWithCheck();
+ }
+
+ void PutBytes(const Byte *data, UInt32 size)
+ {
+ if (size == 0)
+ return;
+ UInt32 pos = _pos;
+ Byte *buf = _buf;
+ buf[pos++] = *data++;
+ size--;
+ for (;;)
+ {
+ UInt32 limitPos = _limitPos;
+ UInt32 rem = limitPos - pos;
+ if (rem == 0)
+ {
+ _pos = pos;
+ FlushWithCheck();
+ pos = _pos;
+ continue;
+ }
+
+ if (size == 0)
+ break;
+
+ if (rem > size)
+ rem = size;
+ size -= rem;
+ do
+ buf[pos++] = *data++;
+ while (--rem);
+ }
+ _pos = pos;
+ }
+
+ Byte GetByte(UInt32 distance) const
+ {
+ UInt32 pos = _pos - distance - 1;
+ if (distance >= _pos)
+ pos += _bufSize;
+ return _buf[pos];
+ }
+};
+
+#endif
diff --git a/CPP/7zip/Compress/LzfseDecoder.cpp b/CPP/7zip/Compress/LzfseDecoder.cpp
new file mode 100644
index 0000000..236d5bd
--- /dev/null
+++ b/CPP/7zip/Compress/LzfseDecoder.cpp
@@ -0,0 +1,942 @@
+// LzfseDecoder.cpp
+
+/*
+This code implements LZFSE data decompressing.
+The code from "LZFSE compression library" was used.
+
+2018 : Igor Pavlov : BSD 3-clause License : the code in this file
+2015-2017 : Apple Inc : BSD 3-clause License : original "LZFSE compression library" code
+
+The code in the "LZFSE compression library" is licensed under the "BSD 3-clause License":
+----
+Copyright (c) 2015-2016, Apple 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. Neither the name of the copyright holder(s) nor the names of any contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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
+COPYRIGHT OWNER OR CONTRIBUTORS 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.
+----
+*/
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#include "../../../C/CpuArch.h"
+
+#include "LzfseDecoder.h"
+
+namespace NCompress {
+namespace NLzfse {
+
+static const Byte kSignature_LZFSE_V1 = 0x31; // '1'
+static const Byte kSignature_LZFSE_V2 = 0x32; // '2'
+
+
+HRESULT CDecoder::GetUInt32(UInt32 &val)
+{
+ Byte b[4];
+ for (unsigned i = 0; i < 4; i++)
+ if (!m_InStream.ReadByte(b[i]))
+ return S_FALSE;
+ val = GetUi32(b);
+ return S_OK;
+}
+
+
+
+HRESULT CDecoder::DecodeUncompressed(UInt32 unpackSize)
+{
+ PRF(printf("\nUncompressed %7u\n", unpackSize));
+
+ const unsigned kBufSize = 1 << 8;
+ Byte buf[kBufSize];
+ for (;;)
+ {
+ if (unpackSize == 0)
+ return S_OK;
+ UInt32 cur = unpackSize;
+ if (cur > kBufSize)
+ cur = kBufSize;
+ UInt32 cur2 = (UInt32)m_InStream.ReadBytes(buf, cur);
+ m_OutWindowStream.PutBytes(buf, cur2);
+ if (cur != cur2)
+ return S_FALSE;
+ }
+}
+
+
+
+HRESULT CDecoder::DecodeLzvn(UInt32 unpackSize, UInt32 packSize)
+{
+ PRF(printf("\nLZVN %7u %7u", unpackSize, packSize));
+
+ UInt32 D = 0;
+
+ for (;;)
+ {
+ if (packSize == 0)
+ return S_FALSE;
+ Byte b;
+ if (!m_InStream.ReadByte(b))
+ return S_FALSE;
+ packSize--;
+
+ UInt32 M;
+ UInt32 L;
+
+ if (b >= 0xE0)
+ {
+ /*
+ large L - 11100000 LLLLLLLL <LITERALS>
+ small L - 1110LLLL <LITERALS>
+
+ large Rep - 11110000 MMMMMMMM
+ small Rep - 1111MMMM
+ */
+
+ M = b & 0xF;
+ if (M == 0)
+ {
+ if (packSize == 0)
+ return S_FALSE;
+ Byte b1;
+ if (!m_InStream.ReadByte(b1))
+ return S_FALSE;
+ packSize--;
+ M = (UInt32)b1 + 16;
+ }
+ L = 0;
+ if ((b & 0x10) == 0)
+ {
+ // Literals only
+ L = M;
+ M = 0;
+ }
+ }
+
+ // ERROR codes
+ else if ((b & 0xF0) == 0x70) // 0111xxxx
+ return S_FALSE;
+ else if ((b & 0xF0) == 0xD0) // 1101xxxx
+ return S_FALSE;
+
+ else
+ {
+ if ((b & 0xE0) == 0xA0)
+ {
+ // medium - 101LLMMM DDDDDDMM DDDDDDDD <LITERALS>
+ if (packSize < 2)
+ return S_FALSE;
+ Byte b1;
+ if (!m_InStream.ReadByte(b1))
+ return S_FALSE;
+ packSize--;
+
+ Byte b2;
+ if (!m_InStream.ReadByte(b2))
+ return S_FALSE;
+ packSize--;
+ L = (((UInt32)b >> 3) & 3);
+ M = (((UInt32)b & 7) << 2) + (b1 & 3);
+ D = ((UInt32)b1 >> 2) + ((UInt32)b2 << 6);
+ }
+ else
+ {
+ L = (UInt32)b >> 6;
+ M = ((UInt32)b >> 3) & 7;
+ if ((b & 0x7) == 6)
+ {
+ // REP - LLMMM110 <LITERALS>
+ if (L == 0)
+ {
+ // spec
+ if (M == 0)
+ break; // EOS
+ if (M <= 2)
+ continue; // NOP
+ return S_FALSE; // UNDEFINED
+ }
+ }
+ else
+ {
+ if (packSize == 0)
+ return S_FALSE;
+ Byte b1;
+ if (!m_InStream.ReadByte(b1))
+ return S_FALSE;
+ packSize--;
+
+ // large - LLMMM111 DDDDDDDD DDDDDDDD <LITERALS>
+ // small - LLMMMDDD DDDDDDDD <LITERALS>
+ D = ((UInt32)b & 7);
+ if (D == 7)
+ {
+ if (packSize == 0)
+ return S_FALSE;
+ Byte b2;
+ if (!m_InStream.ReadByte(b2))
+ return S_FALSE;
+ packSize--;
+ D = b2;
+ }
+ D = (D << 8) + b1;
+ }
+ }
+
+ M += 3;
+ }
+ {
+ for (unsigned i = 0; i < L; i++)
+ {
+ if (packSize == 0 || unpackSize == 0)
+ return S_FALSE;
+ Byte b1;
+ if (!m_InStream.ReadByte(b1))
+ return S_FALSE;
+ packSize--;
+ m_OutWindowStream.PutByte(b1);
+ unpackSize--;
+ }
+ }
+
+ if (M != 0)
+ {
+ if (unpackSize == 0 || D == 0)
+ return S_FALSE;
+ unsigned cur = M;
+ if (cur > unpackSize)
+ cur = (unsigned)unpackSize;
+ if (!m_OutWindowStream.CopyBlock(D - 1, cur))
+ return S_FALSE;
+ unpackSize -= cur;
+ if (cur != M)
+ return S_FALSE;
+ }
+ }
+
+ if (unpackSize != 0)
+ return S_FALSE;
+
+ // LZVN encoder writes 7 additional zero bytes
+ if (packSize != 7)
+ return S_FALSE;
+ do
+ {
+ Byte b;
+ if (!m_InStream.ReadByte(b))
+ return S_FALSE;
+ packSize--;
+ if (b != 0)
+ return S_FALSE;
+ }
+ while (packSize != 0);
+
+ return S_OK;
+}
+
+
+
+// ---------- LZFSE ----------
+
+#define MATCHES_PER_BLOCK 10000
+#define LITERALS_PER_BLOCK (4 * MATCHES_PER_BLOCK)
+
+#define NUM_L_SYMBOLS 20
+#define NUM_M_SYMBOLS 20
+#define NUM_D_SYMBOLS 64
+#define NUM_LIT_SYMBOLS 256
+
+#define NUM_SYMBOLS ( \
+ NUM_L_SYMBOLS + \
+ NUM_M_SYMBOLS + \
+ NUM_D_SYMBOLS + \
+ NUM_LIT_SYMBOLS)
+
+#define NUM_L_STATES (1 << 6)
+#define NUM_M_STATES (1 << 6)
+#define NUM_D_STATES (1 << 8)
+#define NUM_LIT_STATES (1 << 10)
+
+
+typedef UInt32 CFseState;
+
+
+static UInt32 SumFreqs(const UInt16 *freqs, unsigned num)
+{
+ UInt32 sum = 0;
+ for (unsigned i = 0; i < num; i++)
+ sum += (UInt32)freqs[i];
+ return sum;
+}
+
+
+static Z7_FORCE_INLINE unsigned CountZeroBits(UInt32 val, UInt32 mask)
+{
+ for (unsigned i = 0;;)
+ {
+ if (val & mask)
+ return i;
+ i++;
+ mask >>= 1;
+ }
+}
+
+
+static Z7_FORCE_INLINE void InitLitTable(const UInt16 *freqs, UInt32 *table)
+{
+ for (unsigned i = 0; i < NUM_LIT_SYMBOLS; i++)
+ {
+ unsigned f = freqs[i];
+ if (f == 0)
+ continue;
+
+ // 0 < f <= numStates
+ // 0 <= k <= numStatesLog
+ // numStates <= (f<<k) < numStates * 2
+ // 0 < j0 <= f
+ // (f + j0) = next_power_of_2 for f
+ unsigned k = CountZeroBits(f, NUM_LIT_STATES);
+ unsigned j0 = (((unsigned)NUM_LIT_STATES * 2) >> k) - f;
+
+ /*
+ CEntry
+ {
+ Byte k;
+ Byte symbol;
+ UInt16 delta;
+ };
+ */
+
+ UInt32 e = ((UInt32)i << 8) + k;
+ k += 16;
+ UInt32 d = e + ((UInt32)f << k) - ((UInt32)NUM_LIT_STATES << 16);
+ UInt32 step = (UInt32)1 << k;
+
+ unsigned j = 0;
+ do
+ {
+ *table++ = d;
+ d += step;
+ }
+ while (++j < j0);
+
+ e--;
+ step >>= 1;
+
+ for (j = j0; j < f; j++)
+ {
+ *table++ = e;
+ e += step;
+ }
+ }
+}
+
+
+typedef struct
+{
+ Byte totalBits;
+ Byte extraBits;
+ UInt16 delta;
+ UInt32 vbase;
+} CExtraEntry;
+
+
+static void InitExtraDecoderTable(unsigned numStates,
+ unsigned numSymbols,
+ const UInt16 *freqs,
+ const Byte *vbits,
+ CExtraEntry *table)
+{
+ UInt32 vbase = 0;
+
+ for (unsigned i = 0; i < numSymbols; i++)
+ {
+ unsigned f = freqs[i];
+ unsigned extraBits = vbits[i];
+
+ if (f != 0)
+ {
+ unsigned k = CountZeroBits(f, numStates);
+ unsigned j0 = ((2 * numStates) >> k) - f;
+
+ unsigned j = 0;
+ do
+ {
+ CExtraEntry *e = table++;
+ e->totalBits = (Byte)(k + extraBits);
+ e->extraBits = (Byte)extraBits;
+ e->delta = (UInt16)(((f + j) << k) - numStates);
+ e->vbase = vbase;
+ }
+ while (++j < j0);
+
+ f -= j0;
+ k--;
+
+ for (j = 0; j < f; j++)
+ {
+ CExtraEntry *e = table++;
+ e->totalBits = (Byte)(k + extraBits);
+ e->extraBits = (Byte)extraBits;
+ e->delta = (UInt16)(j << k);
+ e->vbase = vbase;
+ }
+ }
+
+ vbase += ((UInt32)1 << extraBits);
+ }
+}
+
+
+static const Byte k_L_extra[NUM_L_SYMBOLS] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 5, 8
+};
+
+static const Byte k_M_extra[NUM_M_SYMBOLS] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5, 8, 11
+};
+
+static const Byte k_D_extra[NUM_D_SYMBOLS] =
+{
+ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
+ 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
+ 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11,
+ 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15
+};
+
+
+
+// ---------- CBitStream ----------
+
+typedef struct
+{
+ UInt32 accum;
+ unsigned numBits; // [0, 31] - Number of valid bits in (accum), other bits are 0
+} CBitStream;
+
+
+static Z7_FORCE_INLINE int FseInStream_Init(CBitStream *s,
+ int n, // [-7, 0], (-n == number_of_unused_bits) in last byte
+ const Byte **pbuf)
+{
+ *pbuf -= 4;
+ s->accum = GetUi32(*pbuf);
+ if (n)
+ {
+ s->numBits = (unsigned)(n + 32);
+ if ((s->accum >> s->numBits) != 0)
+ return -1; // ERROR, encoder should have zeroed the upper bits
+ }
+ else
+ {
+ *pbuf += 1;
+ s->accum >>= 8;
+ s->numBits = 24;
+ }
+ return 0; // OK
+}
+
+
+// 0 <= numBits < 32
+#define mask31(x, numBits) ((x) & (((UInt32)1 << (numBits)) - 1))
+
+#define FseInStream_FLUSH \
+ { const unsigned nbits = (31 - in.numBits) & (unsigned)-8; \
+ if (nbits) { \
+ buf -= (nbits >> 3); \
+ if (buf < buf_check) return S_FALSE; \
+ UInt32 v = GetUi32(buf); \
+ in.accum = (in.accum << nbits) | mask31(v, nbits); \
+ in.numBits += nbits; }}
+
+
+
+static Z7_FORCE_INLINE UInt32 BitStream_Pull(CBitStream *s, unsigned numBits)
+{
+ s->numBits -= numBits;
+ UInt32 v = s->accum >> s->numBits;
+ s->accum = mask31(s->accum, s->numBits);
+ return v;
+}
+
+
+#define DECODE_LIT(dest, pstate) { \
+ UInt32 e = lit_decoder[pstate]; \
+ pstate = (CFseState)((e >> 16) + BitStream_Pull(&in, e & 0xff)); \
+ dest = (Byte)(e >> 8); }
+
+
+static Z7_FORCE_INLINE UInt32 FseDecodeExtra(CFseState *pstate,
+ const CExtraEntry *table,
+ CBitStream *s)
+{
+ const CExtraEntry *e = &table[*pstate];
+ UInt32 v = BitStream_Pull(s, e->totalBits);
+ unsigned extraBits = e->extraBits;
+ *pstate = (CFseState)(e->delta + (v >> extraBits));
+ return e->vbase + mask31(v, extraBits);
+}
+
+
+#define freqs_L (freqs)
+#define freqs_M (freqs_L + NUM_L_SYMBOLS)
+#define freqs_D (freqs_M + NUM_M_SYMBOLS)
+#define freqs_LIT (freqs_D + NUM_D_SYMBOLS)
+
+#define GET_BITS_64(v, offset, num, dest) dest = (UInt32) ((v >> (offset)) & ((1 << (num)) - 1));
+#define GET_BITS_64_Int32(v, offset, num, dest) dest = (Int32)((v >> (offset)) & ((1 << (num)) - 1));
+#define GET_BITS_32(v, offset, num, dest) dest = (CFseState)((v >> (offset)) & ((1 << (num)) - 1));
+
+
+HRESULT CDecoder::DecodeLzfse(UInt32 unpackSize, Byte version)
+{
+ PRF(printf("\nLZFSE-%d %7u", version - '0', unpackSize));
+
+ UInt32 numLiterals;
+ UInt32 litPayloadSize;
+ Int32 literal_bits;
+
+ UInt32 lit_state_0;
+ UInt32 lit_state_1;
+ UInt32 lit_state_2;
+ UInt32 lit_state_3;
+
+ UInt32 numMatches;
+ UInt32 lmdPayloadSize;
+ Int32 lmd_bits;
+
+ CFseState l_state;
+ CFseState m_state;
+ CFseState d_state;
+
+ UInt16 freqs[NUM_SYMBOLS];
+
+ if (version == kSignature_LZFSE_V1)
+ {
+ return E_NOTIMPL;
+ // we need examples to test LZFSE-V1 code
+ /*
+ const unsigned k_v1_SubHeaderSize = 7 * 4 + 7 * 2;
+ const unsigned k_v1_HeaderSize = k_v1_SubHeaderSize + NUM_SYMBOLS * 2;
+ _buffer.AllocAtLeast(k_v1_HeaderSize);
+ if (m_InStream.ReadBytes(_buffer, k_v1_HeaderSize) != k_v1_HeaderSize)
+ return S_FALSE;
+
+ const Byte *buf = _buffer;
+ #define GET_32(offs, dest) dest = GetUi32(buf + offs)
+ #define GET_16(offs, dest) dest = GetUi16(buf + offs)
+
+ UInt32 payload_bytes;
+ GET_32(0, payload_bytes);
+ GET_32(4, numLiterals);
+ GET_32(8, numMatches);
+ GET_32(12, litPayloadSize);
+ GET_32(16, lmdPayloadSize);
+ if (litPayloadSize > (1 << 20) || lmdPayloadSize > (1 << 20))
+ return S_FALSE;
+ GET_32(20, literal_bits);
+ if (literal_bits < -7 || literal_bits > 0)
+ return S_FALSE;
+
+ GET_16(24, lit_state_0);
+ GET_16(26, lit_state_1);
+ GET_16(28, lit_state_2);
+ GET_16(30, lit_state_3);
+
+ GET_32(32, lmd_bits);
+ if (lmd_bits < -7 || lmd_bits > 0)
+ return S_FALSE;
+
+ GET_16(36, l_state);
+ GET_16(38, m_state);
+ GET_16(40, d_state);
+
+ for (unsigned i = 0; i < NUM_SYMBOLS; i++)
+ freqs[i] = GetUi16(buf + k_v1_SubHeaderSize + i * 2);
+ */
+ }
+ else
+ {
+ UInt32 headerSize;
+ {
+ const unsigned kPreHeaderSize = 4 * 2; // signature and upackSize
+ const unsigned kHeaderSize = 8 * 3;
+ Byte temp[kHeaderSize];
+ if (m_InStream.ReadBytes(temp, kHeaderSize) != kHeaderSize)
+ return S_FALSE;
+
+ UInt64 v;
+
+ v = GetUi64(temp);
+ GET_BITS_64(v, 0, 20, numLiterals)
+ GET_BITS_64(v, 20, 20, litPayloadSize)
+ GET_BITS_64(v, 40, 20, numMatches)
+ GET_BITS_64_Int32(v, 60, 3 + 1, literal_bits) // (NumberOfUsedBits - 1)
+ literal_bits -= 7; // (-NumberOfUnusedBits)
+ if (literal_bits > 0)
+ return S_FALSE;
+ // GET_BITS_64(v, 63, 1, unused);
+
+ v = GetUi64(temp + 8);
+ GET_BITS_64(v, 0, 10, lit_state_0)
+ GET_BITS_64(v, 10, 10, lit_state_1)
+ GET_BITS_64(v, 20, 10, lit_state_2)
+ GET_BITS_64(v, 30, 10, lit_state_3)
+ GET_BITS_64(v, 40, 20, lmdPayloadSize)
+ GET_BITS_64_Int32(v, 60, 3 + 1, lmd_bits)
+ lmd_bits -= 7;
+ if (lmd_bits > 0)
+ return S_FALSE;
+ // GET_BITS_64(v, 63, 1, unused)
+
+ UInt32 v32 = GetUi32(temp + 20);
+ // (total header size in bytes; this does not
+ // correspond to a field in the uncompressed header version,
+ // but is required; we wouldn't know the size of the
+ // compresssed header otherwise.
+ GET_BITS_32(v32, 0, 10, l_state)
+ GET_BITS_32(v32, 10, 10, m_state)
+ GET_BITS_32(v32, 20, 10 + 2, d_state)
+ // GET_BITS_64(v, 62, 2, unused)
+
+ headerSize = GetUi32(temp + 16);
+ if (headerSize <= kPreHeaderSize + kHeaderSize)
+ return S_FALSE;
+ headerSize -= kPreHeaderSize + kHeaderSize;
+ }
+
+ // no freqs case is not allowed ?
+ // memset(freqs, 0, sizeof(freqs));
+ // if (headerSize != 0)
+ {
+ static const Byte numBitsTable[32] =
+ {
+ 2, 3, 2, 5, 2, 3, 2, 8, 2, 3, 2, 5, 2, 3, 2, 14,
+ 2, 3, 2, 5, 2, 3, 2, 8, 2, 3, 2, 5, 2, 3, 2, 14
+ };
+
+ static const Byte valueTable[32] =
+ {
+ 0, 2, 1, 4, 0, 3, 1, 8, 0, 2, 1, 5, 0, 3, 1, 24,
+ 0, 2, 1, 6, 0, 3, 1, 8, 0, 2, 1, 7, 0, 3, 1, 24
+ };
+
+ UInt32 accum = 0;
+ unsigned numBits = 0;
+
+ for (unsigned i = 0; i < NUM_SYMBOLS; i++)
+ {
+ while (numBits <= 14 && headerSize != 0)
+ {
+ Byte b;
+ if (!m_InStream.ReadByte(b))
+ return S_FALSE;
+ accum |= (UInt32)b << numBits;
+ numBits += 8;
+ headerSize--;
+ }
+
+ unsigned b = (unsigned)accum & 31;
+ unsigned n = numBitsTable[b];
+ if (numBits < n)
+ return S_FALSE;
+ numBits -= n;
+ UInt32 f = valueTable[b];
+ if (n >= 8)
+ f += ((accum >> 4) & (0x3ff >> (14 - n)));
+ accum >>= n;
+ freqs[i] = (UInt16)f;
+ }
+
+ if (numBits >= 8 || headerSize != 0)
+ return S_FALSE;
+ }
+ }
+
+ PRF(printf(" Literals=%6u Matches=%6u", numLiterals, numMatches));
+
+ if (numLiterals > LITERALS_PER_BLOCK
+ || (numLiterals & 3) != 0
+ || numMatches > MATCHES_PER_BLOCK
+ || lit_state_0 >= NUM_LIT_STATES
+ || lit_state_1 >= NUM_LIT_STATES
+ || lit_state_2 >= NUM_LIT_STATES
+ || lit_state_3 >= NUM_LIT_STATES
+ || l_state >= NUM_L_STATES
+ || m_state >= NUM_M_STATES
+ || d_state >= NUM_D_STATES)
+ return S_FALSE;
+
+ // only full table is allowed ?
+ if ( SumFreqs(freqs_L, NUM_L_SYMBOLS) != NUM_L_STATES
+ || SumFreqs(freqs_M, NUM_M_SYMBOLS) != NUM_M_STATES
+ || SumFreqs(freqs_D, NUM_D_SYMBOLS) != NUM_D_STATES
+ || SumFreqs(freqs_LIT, NUM_LIT_SYMBOLS) != NUM_LIT_STATES)
+ return S_FALSE;
+
+
+ const unsigned kPad = 16;
+
+ // ---------- Decode literals ----------
+
+ {
+ _literals.AllocAtLeast(LITERALS_PER_BLOCK + 16);
+ _buffer.AllocAtLeast(kPad + litPayloadSize);
+ memset(_buffer, 0, kPad);
+
+ if (m_InStream.ReadBytes(_buffer + kPad, litPayloadSize) != litPayloadSize)
+ return S_FALSE;
+
+ UInt32 lit_decoder[NUM_LIT_STATES];
+ InitLitTable(freqs_LIT, lit_decoder);
+
+ const Byte *buf_start = _buffer + kPad;
+ const Byte *buf_check = buf_start - 4;
+ const Byte *buf = buf_start + litPayloadSize;
+ CBitStream in;
+ if (FseInStream_Init(&in, literal_bits, &buf) != 0)
+ return S_FALSE;
+
+ Byte *lit = _literals;
+ const Byte *lit_limit = lit + numLiterals;
+ for (; lit < lit_limit; lit += 4)
+ {
+ FseInStream_FLUSH
+ DECODE_LIT (lit[0], lit_state_0)
+ DECODE_LIT (lit[1], lit_state_1)
+ FseInStream_FLUSH
+ DECODE_LIT (lit[2], lit_state_2)
+ DECODE_LIT (lit[3], lit_state_3)
+ }
+
+ if ((buf_start - buf) * 8 != (int)in.numBits)
+ return S_FALSE;
+ }
+
+
+ // ---------- Decode LMD ----------
+
+ _buffer.AllocAtLeast(kPad + lmdPayloadSize);
+ memset(_buffer, 0, kPad);
+ if (m_InStream.ReadBytes(_buffer + kPad, lmdPayloadSize) != lmdPayloadSize)
+ return S_FALSE;
+
+ CExtraEntry l_decoder[NUM_L_STATES];
+ CExtraEntry m_decoder[NUM_M_STATES];
+ CExtraEntry d_decoder[NUM_D_STATES];
+
+ InitExtraDecoderTable(NUM_L_STATES, NUM_L_SYMBOLS, freqs_L, k_L_extra, l_decoder);
+ InitExtraDecoderTable(NUM_M_STATES, NUM_M_SYMBOLS, freqs_M, k_M_extra, m_decoder);
+ InitExtraDecoderTable(NUM_D_STATES, NUM_D_SYMBOLS, freqs_D, k_D_extra, d_decoder);
+
+ const Byte *buf_start = _buffer + kPad;
+ const Byte *buf_check = buf_start - 4;
+ const Byte *buf = buf_start + lmdPayloadSize;
+ CBitStream in;
+ if (FseInStream_Init(&in, lmd_bits, &buf))
+ return S_FALSE;
+
+ const Byte *lit = _literals;
+ const Byte *lit_limit = lit + numLiterals;
+
+ UInt32 D = 0;
+
+ for (;;)
+ {
+ if (numMatches == 0)
+ break;
+ numMatches--;
+
+ FseInStream_FLUSH
+
+ unsigned L = (unsigned)FseDecodeExtra(&l_state, l_decoder, &in);
+
+ FseInStream_FLUSH
+
+ unsigned M = (unsigned)FseDecodeExtra(&m_state, m_decoder, &in);
+
+ FseInStream_FLUSH
+
+ {
+ UInt32 new_D = FseDecodeExtra(&d_state, d_decoder, &in);
+ if (new_D)
+ D = new_D;
+ }
+
+ if (L != 0)
+ {
+ if (L > (size_t)(lit_limit - lit))
+ return S_FALSE;
+ unsigned cur = L;
+ if (cur > unpackSize)
+ cur = (unsigned)unpackSize;
+ m_OutWindowStream.PutBytes(lit, cur);
+ unpackSize -= cur;
+ lit += cur;
+ if (cur != L)
+ return S_FALSE;
+ }
+
+ if (M != 0)
+ {
+ if (unpackSize == 0 || D == 0)
+ return S_FALSE;
+ unsigned cur = M;
+ if (cur > unpackSize)
+ cur = (unsigned)unpackSize;
+ if (!m_OutWindowStream.CopyBlock(D - 1, cur))
+ return S_FALSE;
+ unpackSize -= cur;
+ if (cur != M)
+ return S_FALSE;
+ }
+ }
+
+ if (unpackSize != 0)
+ return S_FALSE;
+
+ // LZFSE encoder writes 8 additional zero bytes before LMD payload
+ // We test it:
+ if ((size_t)(buf - buf_start) * 8 + in.numBits != 64)
+ return S_FALSE;
+ if (GetUi64(buf_start) != 0)
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ PRF(printf("\n\nLzfseDecoder %7u %7u\n", (unsigned)*outSize, (unsigned)*inSize));
+
+ const UInt32 kLzfseDictSize = 1 << 18;
+ if (!m_OutWindowStream.Create(kLzfseDictSize))
+ return E_OUTOFMEMORY;
+ if (!m_InStream.Create(1 << 18))
+ return E_OUTOFMEMORY;
+
+ m_OutWindowStream.SetStream(outStream);
+ m_OutWindowStream.Init(false);
+ m_InStream.SetStream(inStream);
+ m_InStream.Init();
+
+ CCoderReleaser coderReleaser(this);
+
+ UInt64 prevOut = 0;
+ UInt64 prevIn = 0;
+
+ if (LzvnMode)
+ {
+ if (!outSize || !inSize)
+ return E_NOTIMPL;
+ const UInt64 unpackSize = *outSize;
+ const UInt64 packSize = *inSize;
+ if (unpackSize > (UInt32)(Int32)-1
+ || packSize > (UInt32)(Int32)-1)
+ return S_FALSE;
+ RINOK(DecodeLzvn((UInt32)unpackSize, (UInt32)packSize))
+ }
+ else
+ for (;;)
+ {
+ const UInt64 pos = m_OutWindowStream.GetProcessedSize();
+ const UInt64 packPos = m_InStream.GetProcessedSize();
+
+ if (progress && ((pos - prevOut) >= (1 << 22) || (packPos - prevIn) >= (1 << 22)))
+ {
+ RINOK(progress->SetRatioInfo(&packPos, &pos))
+ prevIn = packPos;
+ prevOut = pos;
+ }
+
+ UInt32 v;
+ RINOK(GetUInt32(v))
+ if ((v & 0xFFFFFF) != 0x787662) // bvx
+ return S_FALSE;
+ v >>= 24;
+
+ if (v == 0x24) // '$', end of stream
+ break;
+
+ UInt32 unpackSize;
+ RINOK(GetUInt32(unpackSize))
+
+ UInt32 cur = unpackSize;
+ if (outSize)
+ {
+ const UInt64 rem = *outSize - pos;
+ if (cur > rem)
+ cur = (UInt32)rem;
+ }
+ unpackSize -= cur;
+
+ HRESULT res;
+ if (v == kSignature_LZFSE_V1 || v == kSignature_LZFSE_V2)
+ res = DecodeLzfse(cur, (Byte)v);
+ else if (v == 0x6E) // 'n'
+ {
+ UInt32 packSize;
+ res = GetUInt32(packSize);
+ if (res == S_OK)
+ res = DecodeLzvn(cur, packSize);
+ }
+ else if (v == 0x2D) // '-'
+ res = DecodeUncompressed(cur);
+ else
+ return E_NOTIMPL;
+
+ if (res != S_OK)
+ return res;
+
+ if (unpackSize != 0)
+ return S_FALSE;
+ }
+
+ coderReleaser.NeedFlush = false;
+ HRESULT res = m_OutWindowStream.Flush();
+ if (res == S_OK)
+ if ((inSize && *inSize != m_InStream.GetProcessedSize())
+ || (outSize && *outSize != m_OutWindowStream.GetProcessedSize()))
+ res = S_FALSE;
+ return res;
+}
+
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return E_OUTOFMEMORY; }
+ // catch(...) { return S_FALSE; }
+}
+
+}}
diff --git a/CPP/7zip/Compress/LzfseDecoder.h b/CPP/7zip/Compress/LzfseDecoder.h
new file mode 100644
index 0000000..b7227dc
--- /dev/null
+++ b/CPP/7zip/Compress/LzfseDecoder.h
@@ -0,0 +1,63 @@
+// LzfseDecoder.h
+
+#ifndef ZIP7_INC_LZFSE_DECODER_H
+#define ZIP7_INC_LZFSE_DECODER_H
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NLzfse {
+
+Z7_CLASS_IMP_NOQIB_1(
+ CDecoder
+ , ICompressCoder
+)
+ CLzOutWindow m_OutWindowStream;
+ CInBuffer m_InStream;
+ CByteBuffer _literals;
+ CByteBuffer _buffer;
+
+ class CCoderReleaser
+ {
+ CDecoder *m_Coder;
+ public:
+ bool NeedFlush;
+ CCoderReleaser(CDecoder *coder): m_Coder(coder), NeedFlush(true) {}
+ ~CCoderReleaser()
+ {
+ if (NeedFlush)
+ m_Coder->m_OutWindowStream.Flush();
+ }
+ };
+ friend class CCoderReleaser;
+
+ HRESULT GetUInt32(UInt32 &val);
+
+ HRESULT DecodeUncompressed(UInt32 unpackSize);
+ HRESULT DecodeLzvn(UInt32 unpackSize, UInt32 packSize);
+ HRESULT DecodeLzfse(UInt32 unpackSize, Byte version);
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+public:
+ bool LzvnMode;
+
+ CDecoder():
+ LzvnMode(false)
+ {}
+
+ // sizes are checked in Code()
+ // UInt64 GetInputProcessedSize() const { return m_InStream.GetProcessedSize(); }
+ // UInt64 GetOutputProcessedSize() const { return m_OutWindowStream.GetProcessedSize(); }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/LzhDecoder.cpp b/CPP/7zip/Compress/LzhDecoder.cpp
new file mode 100644
index 0000000..064bc55
--- /dev/null
+++ b/CPP/7zip/Compress/LzhDecoder.cpp
@@ -0,0 +1,252 @@
+// LzhDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "LzhDecoder.h"
+
+namespace NCompress{
+namespace NLzh {
+namespace NDecoder {
+
+static const UInt32 kWindowSizeMin = 1 << 16;
+
+static bool CheckCodeLens(const Byte *lens, unsigned num)
+{
+ UInt32 sum = 0;
+ for (unsigned i = 0; i < num; i++)
+ {
+ const unsigned len = lens[i];
+ if (len != 0)
+ sum += ((UInt32)1 << (NUM_CODE_BITS - len));
+ }
+ return sum == ((UInt32)1 << NUM_CODE_BITS);
+}
+
+bool CCoder::ReadTP(unsigned num, unsigned numBits, int spec)
+{
+ _symbolT = -1;
+
+ const UInt32 n = _inBitStream.ReadBits(numBits);
+ if (n == 0)
+ {
+ const unsigned s = _inBitStream.ReadBits(numBits);
+ _symbolT = (int)s;
+ return (s < num);
+ }
+
+ if (n > num)
+ return false;
+
+ {
+ Byte lens[NPT];
+ unsigned i;
+ for (i = 0; i < NPT; i++)
+ lens[i] = 0;
+
+ i = 0;
+
+ do
+ {
+ const UInt32 val = _inBitStream.GetValue(16);
+ unsigned c = val >> 13;
+
+ if (c == 7)
+ {
+ UInt32 mask = 1 << 12;
+ while (mask & val)
+ {
+ mask >>= 1;
+ c++;
+ }
+ if (c > 16)
+ return false;
+ }
+
+ _inBitStream.MovePos(c < 7 ? 3 : c - 3);
+ lens[i++] = (Byte)c;
+
+ if (i == (unsigned)spec)
+ i += _inBitStream.ReadBits(2);
+ }
+ while (i < n);
+
+ if (!CheckCodeLens(lens, NPT))
+ return false;
+ return _decoderT.Build(lens);
+ }
+}
+
+static const unsigned NUM_C_BITS = 9;
+
+bool CCoder::ReadC()
+{
+ _symbolC = -1;
+
+ unsigned n = _inBitStream.ReadBits(NUM_C_BITS);
+
+ if (n == 0)
+ {
+ const unsigned s = _inBitStream.ReadBits(NUM_C_BITS);
+ _symbolC = (int)s;
+ return (s < NC);
+ }
+
+ if (n > NC)
+ return false;
+
+ {
+ Byte lens[NC];
+
+ unsigned i = 0;
+
+ do
+ {
+ UInt32 c = (unsigned)_symbolT;
+ if (_symbolT < 0)
+ c = _decoderT.Decode(&_inBitStream);
+
+ if (c <= 2)
+ {
+ if (c == 0)
+ c = 1;
+ else if (c == 1)
+ c = _inBitStream.ReadBits(4) + 3;
+ else
+ c = _inBitStream.ReadBits(NUM_C_BITS) + 20;
+
+ if (i + c > n)
+ return false;
+
+ do
+ lens[i++] = 0;
+ while (--c);
+ }
+ else
+ lens[i++] = (Byte)(c - 2);
+ }
+ while (i < n);
+
+ while (i < NC)
+ lens[i++] = 0;
+
+ if (!CheckCodeLens(lens, NC))
+ return false;
+ return _decoderC.Build(lens);
+ }
+}
+
+HRESULT CCoder::CodeReal(UInt64 rem, ICompressProgressInfo *progress)
+{
+ const unsigned pbit = (DictSize <= (1 << 14) ? 4 : 5);
+
+ UInt32 blockSize = 0;
+
+ while (rem != 0)
+ {
+ if (blockSize == 0)
+ {
+ if (_inBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ if (progress)
+ {
+ const UInt64 packSize = _inBitStream.GetProcessedSize();
+ const UInt64 pos = _outWindow.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &pos))
+ }
+
+ blockSize = _inBitStream.ReadBits(16);
+ if (blockSize == 0)
+ return S_FALSE;
+
+ if (!ReadTP(NT, 5, 3))
+ return S_FALSE;
+ if (!ReadC())
+ return S_FALSE;
+ if (!ReadTP(NP, pbit, -1))
+ return S_FALSE;
+ }
+
+ blockSize--;
+
+ UInt32 number = (unsigned)_symbolC;
+ if (_symbolC < 0)
+ number = _decoderC.Decode(&_inBitStream);
+
+ if (number < 256)
+ {
+ _outWindow.PutByte((Byte)number);
+ rem--;
+ }
+ else
+ {
+ UInt32 len = number - 256 + kMatchMinLen;
+
+ UInt32 dist = (unsigned)_symbolT;
+ if (_symbolT < 0)
+ dist = _decoderT.Decode(&_inBitStream);
+
+ if (dist > 1)
+ {
+ dist--;
+ dist = ((UInt32)1 << dist) + _inBitStream.ReadBits((unsigned)dist);
+ }
+
+ if (dist >= DictSize)
+ return S_FALSE;
+
+ if (len > rem)
+ len = (UInt32)rem;
+
+ if (!_outWindow.CopyBlock(dist, len))
+ return S_FALSE;
+ rem -= len;
+ }
+ }
+
+ if (FinishMode)
+ {
+ if (blockSize != 0)
+ return S_FALSE;
+ if (_inBitStream.ReadAlignBits() != 0)
+ return S_FALSE;
+ }
+
+ if (_inBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try
+ {
+ if (!outSize)
+ return E_INVALIDARG;
+
+ if (!_outWindow.Create(DictSize > kWindowSizeMin ? DictSize : kWindowSizeMin))
+ return E_OUTOFMEMORY;
+ if (!_inBitStream.Create(1 << 17))
+ return E_OUTOFMEMORY;
+
+ _outWindow.SetStream(outStream);
+ _outWindow.Init(false);
+ _inBitStream.SetStream(inStream);
+ _inBitStream.Init();
+
+ CCoderReleaser coderReleaser(this);
+
+ RINOK(CodeReal(*outSize, progress))
+
+ coderReleaser.Disable();
+ return _outWindow.Flush();
+ }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+}}}
diff --git a/CPP/7zip/Compress/LzhDecoder.h b/CPP/7zip/Compress/LzhDecoder.h
new file mode 100644
index 0000000..491212e
--- /dev/null
+++ b/CPP/7zip/Compress/LzhDecoder.h
@@ -0,0 +1,69 @@
+// LzhDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_LZH_DECODER_H
+#define ZIP7_INC_COMPRESS_LZH_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitmDecoder.h"
+#include "HuffmanDecoder.h"
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NLzh {
+namespace NDecoder {
+
+const unsigned kMatchMinLen = 3;
+const unsigned kMatchMaxLen = 256;
+const unsigned NC = (256 + kMatchMaxLen - kMatchMinLen + 1);
+const unsigned NUM_CODE_BITS = 16;
+const unsigned NUM_DIC_BITS_MAX = 25;
+const unsigned NT = (NUM_CODE_BITS + 3);
+const unsigned NP = (NUM_DIC_BITS_MAX + 1);
+const unsigned NPT = NP; // Max(NT, NP)
+
+Z7_CLASS_IMP_NOQIB_1(
+ CCoder
+ , ICompressCoder
+)
+ CLzOutWindow _outWindow;
+ NBitm::CDecoder<CInBuffer> _inBitStream;
+
+ int _symbolT;
+ int _symbolC;
+
+ NHuffman::CDecoder<NUM_CODE_BITS, NPT> _decoderT;
+ NHuffman::CDecoder<NUM_CODE_BITS, NC> _decoderC;
+
+ class CCoderReleaser
+ {
+ CCoder *_coder;
+ public:
+ CCoderReleaser(CCoder *coder): _coder(coder) {}
+ void Disable() { _coder = NULL; }
+ ~CCoderReleaser() { if (_coder) _coder->_outWindow.Flush(); }
+ };
+ friend class CCoderReleaser;
+
+ bool ReadTP(unsigned num, unsigned numBits, int spec);
+ bool ReadC();
+
+ HRESULT CodeReal(UInt64 outSize, ICompressProgressInfo *progress);
+public:
+ UInt32 DictSize;
+ bool FinishMode;
+
+ void SetDictSize(unsigned dictSize) { DictSize = dictSize; }
+
+ CCoder(): DictSize(1 << 16), FinishMode(false) {}
+
+ UInt64 GetInputProcessedSize() const { return _inBitStream.GetProcessedSize(); }
+};
+
+}}}
+
+#endif
diff --git a/CPP/7zip/Compress/Lzma2Decoder.cpp b/CPP/7zip/Compress/Lzma2Decoder.cpp
index bb631c5..eab7800 100644
--- a/CPP/7zip/Compress/Lzma2Decoder.cpp
+++ b/CPP/7zip/Compress/Lzma2Decoder.cpp
@@ -1,265 +1,267 @@
-// Lzma2Decoder.cpp
-
-#include "StdAfx.h"
-
-// #include <stdio.h>
-
-#include "../../../C/Alloc.h"
-// #include "../../../C/CpuTicks.h"
-
-#include "../Common/StreamUtils.h"
-
-#include "Lzma2Decoder.h"
-
-namespace NCompress {
-namespace NLzma2 {
-
-CDecoder::CDecoder():
- _dec(NULL)
- , _inProcessed(0)
- , _prop(0xFF)
- , _finishMode(false)
- , _inBufSize(1 << 20)
- , _outStep(1 << 20)
- #ifndef _7ZIP_ST
- , _tryMt(1)
- , _numThreads(1)
- , _memUsage((UInt64)(sizeof(size_t)) << 28)
- #endif
-{}
-
-CDecoder::~CDecoder()
-{
- if (_dec)
- Lzma2DecMt_Destroy(_dec);
-}
-
-STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSize = size; return S_OK; }
-STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _outStep = size; return S_OK; }
-
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
-{
- if (size != 1)
- return E_NOTIMPL;
- if (prop[0] > 40)
- return E_NOTIMPL;
- _prop = prop[0];
- return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
-{
- _finishMode = (finishMode != 0);
- return S_OK;
-}
-
-
-
-#ifndef _7ZIP_ST
-
-static UInt64 Get_ExpectedBlockSize_From_Dict(UInt32 dictSize)
-{
- const UInt32 kMinSize = (UInt32)1 << 20;
- const UInt32 kMaxSize = (UInt32)1 << 28;
- UInt64 blockSize = (UInt64)dictSize << 2;
- if (blockSize < kMinSize) blockSize = kMinSize;
- if (blockSize > kMaxSize) blockSize = kMaxSize;
- if (blockSize < dictSize) blockSize = dictSize;
- blockSize += (kMinSize - 1);
- blockSize &= ~(UInt64)(kMinSize - 1);
- return blockSize;
-}
-
-#define LZMA2_DIC_SIZE_FROM_PROP_FULL(p) ((p) == 40 ? 0xFFFFFFFF : (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)))
-
-#endif
-
-#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
-
-#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
-
-STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
-{
- _inProcessed = 0;
-
- if (!_dec)
- {
- _dec = Lzma2DecMt_Create(
- // &g_AlignedAlloc,
- &g_Alloc,
- &g_MidAlloc);
- if (!_dec)
- return E_OUTOFMEMORY;
- }
-
- CLzma2DecMtProps props;
- Lzma2DecMtProps_Init(&props);
-
- props.inBufSize_ST = _inBufSize;
- props.outStep_ST = _outStep;
-
- #ifndef _7ZIP_ST
- {
- props.numThreads = 1;
- UInt32 numThreads = _numThreads;
-
- if (_tryMt && numThreads >= 1)
- {
- UInt64 useLimit = _memUsage;
- UInt32 dictSize = LZMA2_DIC_SIZE_FROM_PROP_FULL(_prop);
- UInt64 expectedBlockSize64 = Get_ExpectedBlockSize_From_Dict(dictSize);
- size_t expectedBlockSize = (size_t)expectedBlockSize64;
- size_t inBlockMax = expectedBlockSize + expectedBlockSize / 16;
- if (expectedBlockSize == expectedBlockSize64 && inBlockMax >= expectedBlockSize)
- {
- props.outBlockMax = expectedBlockSize;
- props.inBlockMax = inBlockMax;
- const size_t kOverheadSize = props.inBufSize_MT + (1 << 16);
- UInt64 okThreads = useLimit / (props.outBlockMax + props.inBlockMax + kOverheadSize);
- if (numThreads > okThreads)
- numThreads = (UInt32)okThreads;
- if (numThreads == 0)
- numThreads = 1;
- props.numThreads = numThreads;
- }
- }
- }
- #endif
-
- CSeqInStreamWrap inWrap;
- CSeqOutStreamWrap outWrap;
- CCompressProgressWrap progressWrap;
-
- inWrap.Init(inStream);
- outWrap.Init(outStream);
- progressWrap.Init(progress);
-
- SRes res;
-
- UInt64 inProcessed = 0;
- int isMT = False;
-
- #ifndef _7ZIP_ST
- isMT = _tryMt;
- #endif
-
- // UInt64 cpuTicks = GetCpuTicks();
-
- res = Lzma2DecMt_Decode(_dec, _prop, &props,
- &outWrap.vt, outSize, _finishMode,
- &inWrap.vt,
- &inProcessed,
- &isMT,
- progress ? &progressWrap.vt : NULL);
-
- /*
- cpuTicks = GetCpuTicks() - cpuTicks;
- printf("\n ticks = %10I64u\n", cpuTicks / 1000000);
- */
-
-
- #ifndef _7ZIP_ST
- /* we reset _tryMt, only if p->props.numThreads was changed */
- if (props.numThreads > 1)
- _tryMt = isMT;
- #endif
-
- _inProcessed = inProcessed;
-
- RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
- RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
- RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
-
- if (res == SZ_OK && _finishMode)
- {
- if (inSize && *inSize != inProcessed)
- res = SZ_ERROR_DATA;
- if (outSize && *outSize != outWrap.Processed)
- res = SZ_ERROR_DATA;
- }
-
- return SResToHRESULT(res);
-}
-
-
-STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
-{
- *value = _inProcessed;
- return S_OK;
-}
-
-
-#ifndef _7ZIP_ST
-
-STDMETHODIMP CDecoder::SetNumberOfThreads(UInt32 numThreads)
-{
- _numThreads = numThreads;
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::SetMemLimit(UInt64 memUsage)
-{
- _memUsage = memUsage;
- return S_OK;
-}
-
-#endif
-
-
-#ifndef NO_READ_FROM_CODER
-
-STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
-{
- CLzma2DecMtProps props;
- Lzma2DecMtProps_Init(&props);
- props.inBufSize_ST = _inBufSize;
- props.outStep_ST = _outStep;
-
- _inProcessed = 0;
-
- if (!_dec)
- {
- _dec = Lzma2DecMt_Create(&g_AlignedAlloc, &g_MidAlloc);
- if (!_dec)
- return E_OUTOFMEMORY;
- }
-
- _inWrap.Init(_inStream);
-
- SRes res = Lzma2DecMt_Init(_dec, _prop, &props, outSize, _finishMode, &_inWrap.vt);
-
- if (res != SZ_OK)
- return SResToHRESULT(res);
- return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
-STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
-
-
-STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- size_t size2 = size;
- UInt64 inProcessed = 0;
-
- SRes res = Lzma2DecMt_Read(_dec, (Byte *)data, &size2, &inProcessed);
-
- _inProcessed += inProcessed;
- if (processedSize)
- *processedSize = (UInt32)size2;
- if (res != SZ_OK)
- return SResToHRESULT(res);
- return S_OK;
-}
-
-#endif
-
-}}
+// Lzma2Decoder.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/Alloc.h"
+// #include "../../../C/CpuTicks.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "Lzma2Decoder.h"
+
+namespace NCompress {
+namespace NLzma2 {
+
+CDecoder::CDecoder():
+ _dec(NULL)
+ , _inProcessed(0)
+ , _prop(0xFF)
+ , _finishMode(false)
+ , _inBufSize(1 << 20)
+ , _outStep(1 << 20)
+ #ifndef Z7_ST
+ , _tryMt(1)
+ , _numThreads(1)
+ , _memUsage((UInt64)(sizeof(size_t)) << 28)
+ #endif
+{}
+
+CDecoder::~CDecoder()
+{
+ if (_dec)
+ Lzma2DecMt_Destroy(_dec);
+}
+
+Z7_COM7F_IMF(CDecoder::SetInBufSize(UInt32 , UInt32 size)) { _inBufSize = size; return S_OK; }
+Z7_COM7F_IMF(CDecoder::SetOutBufSize(UInt32 , UInt32 size)) { _outStep = size; return S_OK; }
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size))
+{
+ if (size != 1)
+ return E_NOTIMPL;
+ if (prop[0] > 40)
+ return E_NOTIMPL;
+ _prop = prop[0];
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ _finishMode = (finishMode != 0);
+ return S_OK;
+}
+
+
+
+#ifndef Z7_ST
+
+static UInt64 Get_ExpectedBlockSize_From_Dict(UInt32 dictSize)
+{
+ const UInt32 kMinSize = (UInt32)1 << 20;
+ const UInt32 kMaxSize = (UInt32)1 << 28;
+ UInt64 blockSize = (UInt64)dictSize << 2;
+ if (blockSize < kMinSize) blockSize = kMinSize;
+ if (blockSize > kMaxSize) blockSize = kMaxSize;
+ if (blockSize < dictSize) blockSize = dictSize;
+ blockSize += (kMinSize - 1);
+ blockSize &= ~(UInt64)(kMinSize - 1);
+ return blockSize;
+}
+
+#define LZMA2_DIC_SIZE_FROM_PROP_FULL(p) ((p) == 40 ? 0xFFFFFFFF : (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)))
+
+#endif
+
+#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ _inProcessed = 0;
+
+ if (!_dec)
+ {
+ _dec = Lzma2DecMt_Create(
+ // &g_AlignedAlloc,
+ &g_Alloc,
+ &g_MidAlloc);
+ if (!_dec)
+ return E_OUTOFMEMORY;
+ }
+
+ CLzma2DecMtProps props;
+ Lzma2DecMtProps_Init(&props);
+
+ props.inBufSize_ST = _inBufSize;
+ props.outStep_ST = _outStep;
+
+ #ifndef Z7_ST
+ {
+ props.numThreads = 1;
+ UInt32 numThreads = _numThreads;
+
+ if (_tryMt && numThreads >= 1)
+ {
+ const UInt64 useLimit = _memUsage;
+ const UInt32 dictSize = LZMA2_DIC_SIZE_FROM_PROP_FULL(_prop);
+ const UInt64 expectedBlockSize64 = Get_ExpectedBlockSize_From_Dict(dictSize);
+ const size_t expectedBlockSize = (size_t)expectedBlockSize64;
+ const size_t inBlockMax = expectedBlockSize + expectedBlockSize / 16;
+ if (expectedBlockSize == expectedBlockSize64 && inBlockMax >= expectedBlockSize)
+ {
+ props.outBlockMax = expectedBlockSize;
+ props.inBlockMax = inBlockMax;
+ const size_t kOverheadSize = props.inBufSize_MT + (1 << 16);
+ const UInt64 okThreads = useLimit / (props.outBlockMax + props.inBlockMax + kOverheadSize);
+ if (numThreads > okThreads)
+ numThreads = (UInt32)okThreads;
+ if (numThreads == 0)
+ numThreads = 1;
+ props.numThreads = numThreads;
+ }
+ }
+ }
+ #endif
+
+ CSeqInStreamWrap inWrap;
+ CSeqOutStreamWrap outWrap;
+ CCompressProgressWrap progressWrap;
+
+ inWrap.Init(inStream);
+ outWrap.Init(outStream);
+ progressWrap.Init(progress);
+
+ SRes res;
+
+ UInt64 inProcessed = 0;
+ int isMT = False;
+
+ #ifndef Z7_ST
+ isMT = _tryMt;
+ #endif
+
+ // UInt64 cpuTicks = GetCpuTicks();
+
+ res = Lzma2DecMt_Decode(_dec, _prop, &props,
+ &outWrap.vt, outSize, _finishMode,
+ &inWrap.vt,
+ &inProcessed,
+ &isMT,
+ progress ? &progressWrap.vt : NULL);
+
+ /*
+ cpuTicks = GetCpuTicks() - cpuTicks;
+ printf("\n ticks = %10I64u\n", cpuTicks / 1000000);
+ */
+
+
+ #ifndef Z7_ST
+ /* we reset _tryMt, only if p->props.numThreads was changed */
+ if (props.numThreads > 1)
+ _tryMt = isMT;
+ #endif
+
+ _inProcessed = inProcessed;
+
+ RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+ RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+ RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
+
+ if (res == SZ_OK && _finishMode)
+ {
+ if (inSize && *inSize != inProcessed)
+ res = SZ_ERROR_DATA;
+ if (outSize && *outSize != outWrap.Processed)
+ res = SZ_ERROR_DATA;
+ }
+
+ return SResToHRESULT(res);
+}
+
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = _inProcessed;
+ return S_OK;
+}
+
+
+#ifndef Z7_ST
+
+Z7_COM7F_IMF(CDecoder::SetNumberOfThreads(UInt32 numThreads))
+{
+ _numThreads = numThreads;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::SetMemLimit(UInt64 memUsage))
+{
+ _memUsage = memUsage;
+ return S_OK;
+}
+
+#endif
+
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ CLzma2DecMtProps props;
+ Lzma2DecMtProps_Init(&props);
+ props.inBufSize_ST = _inBufSize;
+ props.outStep_ST = _outStep;
+
+ _inProcessed = 0;
+
+ if (!_dec)
+ {
+ _dec = Lzma2DecMt_Create(&g_AlignedAlloc, &g_MidAlloc);
+ if (!_dec)
+ return E_OUTOFMEMORY;
+ }
+
+ _inWrap.Init(_inStream);
+
+ const SRes res = Lzma2DecMt_Init(_dec, _prop, &props, outSize, _finishMode, &_inWrap.vt);
+
+ if (res != SZ_OK)
+ return SResToHRESULT(res);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
+ { _inStream = inStream; return S_OK; }
+Z7_COM7F_IMF(CDecoder::ReleaseInStream())
+ { _inStream.Release(); return S_OK; }
+
+
+Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ size_t size2 = size;
+ UInt64 inProcessed = 0;
+
+ const SRes res = Lzma2DecMt_Read(_dec, (Byte *)data, &size2, &inProcessed);
+
+ _inProcessed += inProcessed;
+ if (processedSize)
+ *processedSize = (UInt32)size2;
+ if (res != SZ_OK)
+ return SResToHRESULT(res);
+ return S_OK;
+}
+
+#endif
+
+}}
diff --git a/CPP/7zip/Compress/Lzma2Decoder.h b/CPP/7zip/Compress/Lzma2Decoder.h
index b56488e..7ca717e 100644
--- a/CPP/7zip/Compress/Lzma2Decoder.h
+++ b/CPP/7zip/Compress/Lzma2Decoder.h
@@ -1,96 +1,87 @@
-// Lzma2Decoder.h
-
-#ifndef __LZMA2_DECODER_H
-#define __LZMA2_DECODER_H
-
-#include "../../../C/Lzma2DecMt.h"
-
-#include "../Common/CWrappers.h"
-
-namespace NCompress {
-namespace NLzma2 {
-
-class CDecoder:
- public ICompressCoder,
- public ICompressSetDecoderProperties2,
- public ICompressSetFinishMode,
- public ICompressGetInStreamProcessedSize,
- public ICompressSetBufSize,
-
- #ifndef NO_READ_FROM_CODER
- public ICompressSetInStream,
- public ICompressSetOutStreamSize,
- public ISequentialInStream,
- #endif
-
- #ifndef _7ZIP_ST
- public ICompressSetCoderMt,
- public ICompressSetMemLimit,
- #endif
-
- public CMyUnknownImp
-{
- CLzma2DecMtHandle _dec;
- UInt64 _inProcessed;
- Byte _prop;
- int _finishMode;
- UInt32 _inBufSize;
- UInt32 _outStep;
-
-public:
- MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
- MY_QUERYINTERFACE_ENTRY(ICompressSetDecoderProperties2)
- MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
- MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
- MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
-
- #ifndef NO_READ_FROM_CODER
- MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
- MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
- MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
- #endif
-
- #ifndef _7ZIP_ST
- MY_QUERYINTERFACE_ENTRY(ICompressSetCoderMt)
- MY_QUERYINTERFACE_ENTRY(ICompressSetMemLimit)
- #endif
-
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
- STDMETHOD(SetFinishMode)(UInt32 finishMode);
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
- STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
- STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
-
- #ifndef _7ZIP_ST
-private:
- int _tryMt;
- UInt32 _numThreads;
- UInt64 _memUsage;
-public:
- STDMETHOD(SetNumberOfThreads)(UInt32 numThreads);
- STDMETHOD(SetMemLimit)(UInt64 memUsage);
- #endif
-
- #ifndef NO_READ_FROM_CODER
-private:
- CMyComPtr<ISequentialInStream> _inStream;
- CSeqInStreamWrap _inWrap;
-public:
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
- STDMETHOD(SetInStream)(ISequentialInStream *inStream);
- STDMETHOD(ReleaseInStream)();
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- #endif
-
- CDecoder();
- virtual ~CDecoder();
-};
-
-}}
-
-#endif
+// Lzma2Decoder.h
+
+#ifndef ZIP7_INC_LZMA2_DECODER_H
+#define ZIP7_INC_LZMA2_DECODER_H
+
+#include "../../../C/Lzma2DecMt.h"
+
+#include "../Common/CWrappers.h"
+
+namespace NCompress {
+namespace NLzma2 {
+
+class CDecoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetDecoderProperties2,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize,
+ public ICompressSetBufSize,
+ #ifndef Z7_NO_READ_FROM_CODER
+ public ICompressSetInStream,
+ public ICompressSetOutStreamSize,
+ public ISequentialInStream,
+ #endif
+ #ifndef Z7_ST
+ public ICompressSetCoderMt,
+ public ICompressSetMemLimit,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetDecoderProperties2)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ Z7_COM_QI_ENTRY(ICompressSetBufSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_COM_QI_ENTRY(ICompressSetInStream)
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+ #endif
+ #ifndef Z7_ST
+ Z7_COM_QI_ENTRY(ICompressSetCoderMt)
+ Z7_COM_QI_ENTRY(ICompressSetMemLimit)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ Z7_IFACE_COM7_IMP(ICompressSetBufSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ Z7_IFACE_COM7_IMP(ICompressSetInStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+ #endif
+ #ifndef Z7_ST
+ Z7_IFACE_COM7_IMP(ICompressSetCoderMt)
+ Z7_IFACE_COM7_IMP(ICompressSetMemLimit)
+ #endif
+
+ CLzma2DecMtHandle _dec;
+ UInt64 _inProcessed;
+ Byte _prop;
+ int _finishMode;
+ UInt32 _inBufSize;
+ UInt32 _outStep;
+
+ #ifndef Z7_ST
+ int _tryMt;
+ UInt32 _numThreads;
+ UInt64 _memUsage;
+ #endif
+
+ #ifndef Z7_NO_READ_FROM_CODER
+ CMyComPtr<ISequentialInStream> _inStream;
+ CSeqInStreamWrap _inWrap;
+ #endif
+
+public:
+ CDecoder();
+ ~CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Lzma2Encoder.cpp b/CPP/7zip/Compress/Lzma2Encoder.cpp
index 18f7d02..0dc7e23 100644
--- a/CPP/7zip/Compress/Lzma2Encoder.cpp
+++ b/CPP/7zip/Compress/Lzma2Encoder.cpp
@@ -1,122 +1,126 @@
-// Lzma2Encoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../Common/CWrappers.h"
-#include "../Common/StreamUtils.h"
-
-#include "Lzma2Encoder.h"
-
-namespace NCompress {
-
-namespace NLzma {
-
-HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep);
-
-}
-
-namespace NLzma2 {
-
-CEncoder::CEncoder()
-{
- _encoder = NULL;
- _encoder = Lzma2Enc_Create(&g_AlignedAlloc, &g_BigAlloc);
- if (!_encoder)
- throw 1;
-}
-
-CEncoder::~CEncoder()
-{
- if (_encoder)
- Lzma2Enc_Destroy(_encoder);
-}
-
-
-HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props)
-{
- switch (propID)
- {
- case NCoderPropID::kBlockSize:
- {
- if (prop.vt == VT_UI4)
- lzma2Props.blockSize = prop.ulVal;
- else if (prop.vt == VT_UI8)
- lzma2Props.blockSize = prop.uhVal.QuadPart;
- else
- return E_INVALIDARG;
- break;
- }
- case NCoderPropID::kNumThreads:
- if (prop.vt != VT_UI4) return E_INVALIDARG; lzma2Props.numTotalThreads = (int)(prop.ulVal); break;
- default:
- RINOK(NLzma::SetLzmaProp(propID, prop, lzma2Props.lzmaProps));
- }
- return S_OK;
-}
-
-
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
- const PROPVARIANT *coderProps, UInt32 numProps)
-{
- CLzma2EncProps lzma2Props;
- Lzma2EncProps_Init(&lzma2Props);
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- RINOK(SetLzma2Prop(propIDs[i], coderProps[i], lzma2Props));
- }
- return SResToHRESULT(Lzma2Enc_SetProps(_encoder, &lzma2Props));
-}
-
-
-STDMETHODIMP CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
- const PROPVARIANT *coderProps, UInt32 numProps)
-{
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- PROPID propID = propIDs[i];
- if (propID == NCoderPropID::kExpectedDataSize)
- if (prop.vt == VT_UI8)
- Lzma2Enc_SetDataSize(_encoder, prop.uhVal.QuadPart);
- }
- return S_OK;
-}
-
-
-STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
-{
- Byte prop = Lzma2Enc_WriteProperties(_encoder);
- return WriteStream(outStream, &prop, 1);
-}
-
-
-#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
-
-STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
-{
- CSeqInStreamWrap inWrap;
- CSeqOutStreamWrap outWrap;
- CCompressProgressWrap progressWrap;
-
- inWrap.Init(inStream);
- outWrap.Init(outStream);
- progressWrap.Init(progress);
-
- SRes res = Lzma2Enc_Encode2(_encoder,
- &outWrap.vt, NULL, NULL,
- &inWrap.vt, NULL, 0,
- progress ? &progressWrap.vt : NULL);
-
- RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
- RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
- RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
-
- return SResToHRESULT(res);
-}
-
-}}
+// Lzma2Encoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/StreamUtils.h"
+
+#include "Lzma2Encoder.h"
+
+namespace NCompress {
+
+namespace NLzma {
+
+HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep);
+
+}
+
+namespace NLzma2 {
+
+CEncoder::CEncoder()
+{
+ _encoder = NULL;
+ _encoder = Lzma2Enc_Create(&g_AlignedAlloc, &g_BigAlloc);
+ if (!_encoder)
+ throw 1;
+}
+
+CEncoder::~CEncoder()
+{
+ if (_encoder)
+ Lzma2Enc_Destroy(_encoder);
+}
+
+
+HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props);
+HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props)
+{
+ switch (propID)
+ {
+ case NCoderPropID::kBlockSize:
+ {
+ if (prop.vt == VT_UI4)
+ lzma2Props.blockSize = prop.ulVal;
+ else if (prop.vt == VT_UI8)
+ lzma2Props.blockSize = prop.uhVal.QuadPart;
+ else
+ return E_INVALIDARG;
+ break;
+ }
+ case NCoderPropID::kNumThreads:
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ lzma2Props.numTotalThreads = (int)(prop.ulVal);
+ break;
+ default:
+ RINOK(NLzma::SetLzmaProp(propID, prop, lzma2Props.lzmaProps))
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs,
+ const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ CLzma2EncProps lzma2Props;
+ Lzma2EncProps_Init(&lzma2Props);
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ RINOK(SetLzma2Prop(propIDs[i], coderProps[i], lzma2Props))
+ }
+ return SResToHRESULT(Lzma2Enc_SetProps(_encoder, &lzma2Props));
+}
+
+
+Z7_COM7F_IMF(CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
+ const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ const PROPID propID = propIDs[i];
+ if (propID == NCoderPropID::kExpectedDataSize)
+ if (prop.vt == VT_UI8)
+ Lzma2Enc_SetDataSize(_encoder, prop.uhVal.QuadPart);
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+{
+ const Byte prop = Lzma2Enc_WriteProperties(_encoder);
+ return WriteStream(outStream, &prop, 1);
+}
+
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+{
+ CSeqInStreamWrap inWrap;
+ CSeqOutStreamWrap outWrap;
+ CCompressProgressWrap progressWrap;
+
+ inWrap.Init(inStream);
+ outWrap.Init(outStream);
+ progressWrap.Init(progress);
+
+ SRes res = Lzma2Enc_Encode2(_encoder,
+ &outWrap.vt, NULL, NULL,
+ &inWrap.vt, NULL, 0,
+ progress ? &progressWrap.vt : NULL);
+
+ RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
+ RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+ RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+
+ return SResToHRESULT(res);
+}
+
+}}
diff --git a/CPP/7zip/Compress/Lzma2Encoder.h b/CPP/7zip/Compress/Lzma2Encoder.h
index 6539e73..18c29e1 100644
--- a/CPP/7zip/Compress/Lzma2Encoder.h
+++ b/CPP/7zip/Compress/Lzma2Encoder.h
@@ -1,42 +1,30 @@
-// Lzma2Encoder.h
-
-#ifndef __LZMA2_ENCODER_H
-#define __LZMA2_ENCODER_H
-
-#include "../../../C/Lzma2Enc.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NLzma2 {
-
-class CEncoder:
- public ICompressCoder,
- public ICompressSetCoderProperties,
- public ICompressWriteCoderProperties,
- public ICompressSetCoderPropertiesOpt,
- public CMyUnknownImp
-{
- CLzma2EncHandle _encoder;
-public:
- MY_UNKNOWN_IMP4(
- ICompressCoder,
- ICompressSetCoderProperties,
- ICompressWriteCoderProperties,
- ICompressSetCoderPropertiesOpt)
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
- STDMETHOD(SetCoderPropertiesOpt)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
-
- CEncoder();
- virtual ~CEncoder();
-};
-
-}}
-
-#endif
+// Lzma2Encoder.h
+
+#ifndef ZIP7_INC_LZMA2_ENCODER_H
+#define ZIP7_INC_LZMA2_ENCODER_H
+
+#include "../../../C/Lzma2Enc.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NLzma2 {
+
+Z7_CLASS_IMP_COM_4(
+ CEncoder
+ , ICompressCoder
+ , ICompressSetCoderProperties
+ , ICompressWriteCoderProperties
+ , ICompressSetCoderPropertiesOpt
+)
+ CLzma2EncHandle _encoder;
+public:
+ CEncoder();
+ ~CEncoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Lzma2Register.cpp b/CPP/7zip/Compress/Lzma2Register.cpp
index 4367105..fe53346 100644
--- a/CPP/7zip/Compress/Lzma2Register.cpp
+++ b/CPP/7zip/Compress/Lzma2Register.cpp
@@ -1,22 +1,22 @@
-// Lzma2Register.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "Lzma2Decoder.h"
-
-#ifndef EXTRACT_ONLY
-#include "Lzma2Encoder.h"
-#endif
-
-namespace NCompress {
-namespace NLzma2 {
-
-REGISTER_CODEC_E(LZMA2,
- CDecoder(),
- CEncoder(),
- 0x21,
- "LZMA2")
-
-}}
+// Lzma2Register.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "Lzma2Decoder.h"
+
+#ifndef Z7_EXTRACT_ONLY
+#include "Lzma2Encoder.h"
+#endif
+
+namespace NCompress {
+namespace NLzma2 {
+
+REGISTER_CODEC_E(LZMA2,
+ CDecoder(),
+ CEncoder(),
+ 0x21,
+ "LZMA2")
+
+}}
diff --git a/CPP/7zip/Compress/LzmaDecoder.cpp b/CPP/7zip/Compress/LzmaDecoder.cpp
index b6a8d3f..4f05b48 100644
--- a/CPP/7zip/Compress/LzmaDecoder.cpp
+++ b/CPP/7zip/Compress/LzmaDecoder.cpp
@@ -1,343 +1,349 @@
-// LzmaDecoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../Common/StreamUtils.h"
-
-#include "LzmaDecoder.h"
-
-static HRESULT SResToHRESULT(SRes res)
-{
- switch (res)
- {
- case SZ_OK: return S_OK;
- case SZ_ERROR_MEM: return E_OUTOFMEMORY;
- case SZ_ERROR_PARAM: return E_INVALIDARG;
- case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
- case SZ_ERROR_DATA: return S_FALSE;
- }
- return E_FAIL;
-}
-
-namespace NCompress {
-namespace NLzma {
-
-CDecoder::CDecoder():
- _inBuf(NULL),
- _lzmaStatus(LZMA_STATUS_NOT_SPECIFIED),
- FinishStream(false),
- _propsWereSet(false),
- _outSizeDefined(false),
- _outStep(1 << 20),
- _inBufSize(0),
- _inBufSizeNew(1 << 20)
-{
- _inProcessed = 0;
- _inPos = _inLim = 0;
-
- /*
- AlignOffsetAlloc_CreateVTable(&_alloc);
- _alloc.numAlignBits = 7;
- _alloc.offset = 0;
- */
- LzmaDec_Construct(&_state);
-}
-
-CDecoder::~CDecoder()
-{
- LzmaDec_Free(&_state, &g_AlignedAlloc); // &_alloc.vt
- MyFree(_inBuf);
-}
-
-STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSizeNew = size; return S_OK; }
-STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _outStep = size; return S_OK; }
-
-HRESULT CDecoder::CreateInputBuffer()
-{
- if (!_inBuf || _inBufSizeNew != _inBufSize)
- {
- MyFree(_inBuf);
- _inBufSize = 0;
- _inBuf = (Byte *)MyAlloc(_inBufSizeNew);
- if (!_inBuf)
- return E_OUTOFMEMORY;
- _inBufSize = _inBufSizeNew;
- }
- return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
-{
- RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_AlignedAlloc))) // &_alloc.vt
- _propsWereSet = true;
- return CreateInputBuffer();
-}
-
-
-void CDecoder::SetOutStreamSizeResume(const UInt64 *outSize)
-{
- _outSizeDefined = (outSize != NULL);
- _outSize = 0;
- if (_outSizeDefined)
- _outSize = *outSize;
- _outProcessed = 0;
- _lzmaStatus = LZMA_STATUS_NOT_SPECIFIED;
-
- LzmaDec_Init(&_state);
-}
-
-
-STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
-{
- _inProcessed = 0;
- _inPos = _inLim = 0;
- SetOutStreamSizeResume(outSize);
- return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
-{
- FinishStream = (finishMode != 0);
- return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
-{
- *value = _inProcessed;
- return S_OK;
-}
-
-
-HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
-{
- if (!_inBuf || !_propsWereSet)
- return S_FALSE;
-
- const UInt64 startInProgress = _inProcessed;
- SizeT wrPos = _state.dicPos;
- HRESULT readRes = S_OK;
-
- for (;;)
- {
- if (_inPos == _inLim && readRes == S_OK)
- {
- _inPos = _inLim = 0;
- readRes = inStream->Read(_inBuf, _inBufSize, &_inLim);
- }
-
- const SizeT dicPos = _state.dicPos;
- SizeT size;
- {
- SizeT next = _state.dicBufSize;
- if (next - wrPos > _outStep)
- next = wrPos + _outStep;
- size = next - dicPos;
- }
-
- ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
- if (_outSizeDefined)
- {
- const UInt64 rem = _outSize - _outProcessed;
- if (size >= rem)
- {
- size = (SizeT)rem;
- if (FinishStream)
- finishMode = LZMA_FINISH_END;
- }
- }
-
- SizeT inProcessed = _inLim - _inPos;
- ELzmaStatus status;
-
- SRes res = LzmaDec_DecodeToDic(&_state, dicPos + size, _inBuf + _inPos, &inProcessed, finishMode, &status);
-
- _lzmaStatus = status;
- _inPos += (UInt32)inProcessed;
- _inProcessed += inProcessed;
- const SizeT outProcessed = _state.dicPos - dicPos;
- _outProcessed += outProcessed;
-
- // we check for LZMA_STATUS_NEEDS_MORE_INPUT to allow RangeCoder initialization, if (_outSizeDefined && _outSize == 0)
- bool outFinished = (_outSizeDefined && _outProcessed >= _outSize);
-
- bool needStop = (res != 0
- || (inProcessed == 0 && outProcessed == 0)
- || status == LZMA_STATUS_FINISHED_WITH_MARK
- || (outFinished && status != LZMA_STATUS_NEEDS_MORE_INPUT));
-
- if (needStop || outProcessed >= size)
- {
- HRESULT res2 = WriteStream(outStream, _state.dic + wrPos, _state.dicPos - wrPos);
-
- if (_state.dicPos == _state.dicBufSize)
- _state.dicPos = 0;
- wrPos = _state.dicPos;
-
- RINOK(res2);
-
- if (needStop)
- {
- if (res != 0)
- return S_FALSE;
-
- if (status == LZMA_STATUS_FINISHED_WITH_MARK)
- {
- if (FinishStream)
- if (_outSizeDefined && _outSize != _outProcessed)
- return S_FALSE;
- return readRes;
- }
-
- if (outFinished && status != LZMA_STATUS_NEEDS_MORE_INPUT)
- if (!FinishStream || status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
- return readRes;
-
- return S_FALSE;
- }
- }
-
- if (progress)
- {
- const UInt64 inSize = _inProcessed - startInProgress;
- RINOK(progress->SetRatioInfo(&inSize, &_outProcessed));
- }
- }
-}
-
-
-STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
-{
- if (!_inBuf)
- return E_INVALIDARG;
- SetOutStreamSize(outSize);
- HRESULT res = CodeSpec(inStream, outStream, progress);
- if (res == S_OK)
- if (FinishStream && inSize && *inSize != _inProcessed)
- res = S_FALSE;
- return res;
-}
-
-
-#ifndef NO_READ_FROM_CODER
-
-STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
-STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
-
-
-STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
-
- ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
- if (_outSizeDefined)
- {
- const UInt64 rem = _outSize - _outProcessed;
- if (size >= rem)
- {
- size = (UInt32)rem;
- if (FinishStream)
- finishMode = LZMA_FINISH_END;
- }
- }
-
- HRESULT readRes = S_OK;
-
- for (;;)
- {
- if (_inPos == _inLim && readRes == S_OK)
- {
- _inPos = _inLim = 0;
- readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
- }
-
- SizeT inProcessed = _inLim - _inPos;
- SizeT outProcessed = size;
- ELzmaStatus status;
-
- SRes res = LzmaDec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
- _inBuf + _inPos, &inProcessed, finishMode, &status);
-
- _lzmaStatus = status;
- _inPos += (UInt32)inProcessed;
- _inProcessed += inProcessed;
- _outProcessed += outProcessed;
- size -= (UInt32)outProcessed;
- data = (Byte *)data + outProcessed;
- if (processedSize)
- *processedSize += (UInt32)outProcessed;
-
- if (res != 0)
- return S_FALSE;
-
- /*
- if (status == LZMA_STATUS_FINISHED_WITH_MARK)
- return readRes;
-
- if (size == 0 && status != LZMA_STATUS_NEEDS_MORE_INPUT)
- {
- if (FinishStream
- && _outSizeDefined && _outProcessed >= _outSize
- && status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
- return S_FALSE;
- return readRes;
- }
- */
-
- if (inProcessed == 0 && outProcessed == 0)
- return readRes;
- }
-}
-
-
-HRESULT CDecoder::CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress)
-{
- SetOutStreamSizeResume(outSize);
- return CodeSpec(_inStream, outStream, progress);
-}
-
-
-HRESULT CDecoder::ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize)
-{
- RINOK(CreateInputBuffer());
-
- if (processedSize)
- *processedSize = 0;
-
- HRESULT readRes = S_OK;
-
- while (size != 0)
- {
- if (_inPos == _inLim)
- {
- _inPos = _inLim = 0;
- if (readRes == S_OK)
- readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
- if (_inLim == 0)
- break;
- }
-
- UInt32 cur = _inLim - _inPos;
- if (cur > size)
- cur = size;
- memcpy(data, _inBuf + _inPos, cur);
- _inPos += cur;
- _inProcessed += cur;
- size -= cur;
- data = (Byte *)data + cur;
- if (processedSize)
- *processedSize += cur;
- }
-
- return readRes;
-}
-
-#endif
-
-}}
+// LzmaDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "LzmaDecoder.h"
+
+static HRESULT SResToHRESULT(SRes res)
+{
+ switch (res)
+ {
+ case SZ_OK: return S_OK;
+ case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+ case SZ_ERROR_PARAM: return E_INVALIDARG;
+ case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
+ case SZ_ERROR_DATA: return S_FALSE;
+ }
+ return E_FAIL;
+}
+
+namespace NCompress {
+namespace NLzma {
+
+CDecoder::CDecoder():
+ FinishStream(false),
+ _propsWereSet(false),
+ _outSizeDefined(false),
+ _outStep(1 << 20),
+ _inBufSize(0),
+ _inBufSizeNew(1 << 20),
+ _lzmaStatus(LZMA_STATUS_NOT_SPECIFIED),
+ _inBuf(NULL)
+{
+ _inProcessed = 0;
+ _inPos = _inLim = 0;
+
+ /*
+ AlignOffsetAlloc_CreateVTable(&_alloc);
+ _alloc.numAlignBits = 7;
+ _alloc.offset = 0;
+ */
+ LzmaDec_CONSTRUCT(&_state)
+}
+
+CDecoder::~CDecoder()
+{
+ LzmaDec_Free(&_state, &g_AlignedAlloc); // &_alloc.vt
+ MyFree(_inBuf);
+}
+
+Z7_COM7F_IMF(CDecoder::SetInBufSize(UInt32 , UInt32 size))
+ { _inBufSizeNew = size; return S_OK; }
+Z7_COM7F_IMF(CDecoder::SetOutBufSize(UInt32 , UInt32 size))
+ { _outStep = size; return S_OK; }
+
+HRESULT CDecoder::CreateInputBuffer()
+{
+ if (!_inBuf || _inBufSizeNew != _inBufSize)
+ {
+ MyFree(_inBuf);
+ _inBufSize = 0;
+ _inBuf = (Byte *)MyAlloc(_inBufSizeNew);
+ if (!_inBuf)
+ return E_OUTOFMEMORY;
+ _inBufSize = _inBufSizeNew;
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size))
+{
+ RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_AlignedAlloc))) // &_alloc.vt
+ _propsWereSet = true;
+ return CreateInputBuffer();
+}
+
+
+void CDecoder::SetOutStreamSizeResume(const UInt64 *outSize)
+{
+ _outSizeDefined = (outSize != NULL);
+ _outSize = 0;
+ if (_outSizeDefined)
+ _outSize = *outSize;
+ _outProcessed = 0;
+ _lzmaStatus = LZMA_STATUS_NOT_SPECIFIED;
+
+ LzmaDec_Init(&_state);
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ _inProcessed = 0;
+ _inPos = _inLim = 0;
+ SetOutStreamSizeResume(outSize);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ FinishStream = (finishMode != 0);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = _inProcessed;
+ return S_OK;
+}
+
+
+HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
+{
+ if (!_inBuf || !_propsWereSet)
+ return S_FALSE;
+
+ const UInt64 startInProgress = _inProcessed;
+ SizeT wrPos = _state.dicPos;
+ HRESULT readRes = S_OK;
+
+ for (;;)
+ {
+ if (_inPos == _inLim && readRes == S_OK)
+ {
+ _inPos = _inLim = 0;
+ readRes = inStream->Read(_inBuf, _inBufSize, &_inLim);
+ }
+
+ const SizeT dicPos = _state.dicPos;
+ SizeT size;
+ {
+ SizeT next = _state.dicBufSize;
+ if (next - wrPos > _outStep)
+ next = wrPos + _outStep;
+ size = next - dicPos;
+ }
+
+ ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _outProcessed;
+ if (size >= rem)
+ {
+ size = (SizeT)rem;
+ if (FinishStream)
+ finishMode = LZMA_FINISH_END;
+ }
+ }
+
+ SizeT inProcessed = _inLim - _inPos;
+ ELzmaStatus status;
+
+ const SRes res = LzmaDec_DecodeToDic(&_state, dicPos + size, _inBuf + _inPos, &inProcessed, finishMode, &status);
+
+ _lzmaStatus = status;
+ _inPos += (UInt32)inProcessed;
+ _inProcessed += inProcessed;
+ const SizeT outProcessed = _state.dicPos - dicPos;
+ _outProcessed += outProcessed;
+
+ // we check for LZMA_STATUS_NEEDS_MORE_INPUT to allow RangeCoder initialization, if (_outSizeDefined && _outSize == 0)
+ const bool outFinished = (_outSizeDefined && _outProcessed >= _outSize);
+
+ const bool needStop = (res != 0
+ || (inProcessed == 0 && outProcessed == 0)
+ || status == LZMA_STATUS_FINISHED_WITH_MARK
+ || (outFinished && status != LZMA_STATUS_NEEDS_MORE_INPUT));
+
+ if (needStop || outProcessed >= size)
+ {
+ const HRESULT res2 = WriteStream(outStream, _state.dic + wrPos, _state.dicPos - wrPos);
+
+ if (_state.dicPos == _state.dicBufSize)
+ _state.dicPos = 0;
+ wrPos = _state.dicPos;
+
+ RINOK(res2)
+
+ if (needStop)
+ {
+ if (res != 0)
+ {
+ // return SResToHRESULT(res);
+ return S_FALSE;
+ }
+
+ if (status == LZMA_STATUS_FINISHED_WITH_MARK)
+ {
+ if (FinishStream)
+ if (_outSizeDefined && _outSize != _outProcessed)
+ return S_FALSE;
+ return readRes;
+ }
+
+ if (outFinished && status != LZMA_STATUS_NEEDS_MORE_INPUT)
+ if (!FinishStream || status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+ return readRes;
+
+ return S_FALSE;
+ }
+ }
+
+ if (progress)
+ {
+ const UInt64 inSize = _inProcessed - startInProgress;
+ RINOK(progress->SetRatioInfo(&inSize, &_outProcessed))
+ }
+ }
+}
+
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ if (!_inBuf)
+ return E_INVALIDARG;
+ SetOutStreamSize(outSize);
+ HRESULT res = CodeSpec(inStream, outStream, progress);
+ if (res == S_OK)
+ if (FinishStream && inSize && *inSize != _inProcessed)
+ res = S_FALSE;
+ return res;
+}
+
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
+ { _inStream = inStream; return S_OK; }
+Z7_COM7F_IMF(CDecoder::ReleaseInStream())
+ { _inStream.Release(); return S_OK; }
+
+Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+
+ ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _outProcessed;
+ if (size >= rem)
+ {
+ size = (UInt32)rem;
+ if (FinishStream)
+ finishMode = LZMA_FINISH_END;
+ }
+ }
+
+ HRESULT readRes = S_OK;
+
+ for (;;)
+ {
+ if (_inPos == _inLim && readRes == S_OK)
+ {
+ _inPos = _inLim = 0;
+ readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
+ }
+
+ SizeT inProcessed = _inLim - _inPos;
+ SizeT outProcessed = size;
+ ELzmaStatus status;
+
+ const SRes res = LzmaDec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
+ _inBuf + _inPos, &inProcessed, finishMode, &status);
+
+ _lzmaStatus = status;
+ _inPos += (UInt32)inProcessed;
+ _inProcessed += inProcessed;
+ _outProcessed += outProcessed;
+ size -= (UInt32)outProcessed;
+ data = (Byte *)data + outProcessed;
+ if (processedSize)
+ *processedSize += (UInt32)outProcessed;
+
+ if (res != 0)
+ return S_FALSE;
+
+ /*
+ if (status == LZMA_STATUS_FINISHED_WITH_MARK)
+ return readRes;
+
+ if (size == 0 && status != LZMA_STATUS_NEEDS_MORE_INPUT)
+ {
+ if (FinishStream
+ && _outSizeDefined && _outProcessed >= _outSize
+ && status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+ return S_FALSE;
+ return readRes;
+ }
+ */
+
+ if (inProcessed == 0 && outProcessed == 0)
+ return readRes;
+ }
+}
+
+
+HRESULT CDecoder::CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ SetOutStreamSizeResume(outSize);
+ return CodeSpec(_inStream, outStream, progress);
+}
+
+
+HRESULT CDecoder::ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize)
+{
+ RINOK(CreateInputBuffer())
+
+ if (processedSize)
+ *processedSize = 0;
+
+ HRESULT readRes = S_OK;
+
+ while (size != 0)
+ {
+ if (_inPos == _inLim)
+ {
+ _inPos = _inLim = 0;
+ if (readRes == S_OK)
+ readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
+ if (_inLim == 0)
+ break;
+ }
+
+ UInt32 cur = _inLim - _inPos;
+ if (cur > size)
+ cur = size;
+ memcpy(data, _inBuf + _inPos, cur);
+ _inPos += cur;
+ _inProcessed += cur;
+ size -= cur;
+ data = (Byte *)data + cur;
+ if (processedSize)
+ *processedSize += cur;
+ }
+
+ return readRes;
+}
+
+#endif
+
+}}
diff --git a/CPP/7zip/Compress/LzmaDecoder.h b/CPP/7zip/Compress/LzmaDecoder.h
index 08b7c1b..095e76f 100644
--- a/CPP/7zip/Compress/LzmaDecoder.h
+++ b/CPP/7zip/Compress/LzmaDecoder.h
@@ -1,113 +1,113 @@
-// LzmaDecoder.h
-
-#ifndef __LZMA_DECODER_H
-#define __LZMA_DECODER_H
-
-// #include "../../../C/Alloc.h"
-#include "../../../C/LzmaDec.h"
-
-#include "../../Common/MyCom.h"
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NLzma {
-
-class CDecoder:
- public ICompressCoder,
- public ICompressSetDecoderProperties2,
- public ICompressSetFinishMode,
- public ICompressGetInStreamProcessedSize,
- public ICompressSetBufSize,
- #ifndef NO_READ_FROM_CODER
- public ICompressSetInStream,
- public ICompressSetOutStreamSize,
- public ISequentialInStream,
- #endif
- public CMyUnknownImp
-{
- Byte *_inBuf;
- UInt32 _inPos;
- UInt32 _inLim;
-
- ELzmaStatus _lzmaStatus;
-
-public:
- bool FinishStream; // set it before decoding, if you need to decode full LZMA stream
-
-private:
- bool _propsWereSet;
- bool _outSizeDefined;
- UInt64 _outSize;
- UInt64 _inProcessed;
- UInt64 _outProcessed;
-
- UInt32 _outStep;
- UInt32 _inBufSize;
- UInt32 _inBufSizeNew;
-
- // CAlignOffsetAlloc _alloc;
-
- CLzmaDec _state;
-
- HRESULT CreateInputBuffer();
- HRESULT CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
- void SetOutStreamSizeResume(const UInt64 *outSize);
-
-public:
- MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
- MY_QUERYINTERFACE_ENTRY(ICompressSetDecoderProperties2)
- MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
- MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
- MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
- #ifndef NO_READ_FROM_CODER
- MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
- MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
- MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
- STDMETHOD(SetFinishMode)(UInt32 finishMode);
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
- STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
- STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
-
- #ifndef NO_READ_FROM_CODER
-
-private:
- CMyComPtr<ISequentialInStream> _inStream;
-public:
-
- STDMETHOD(SetInStream)(ISequentialInStream *inStream);
- STDMETHOD(ReleaseInStream)();
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-
- HRESULT CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress);
- HRESULT ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize);
-
- #endif
-
- UInt64 GetInputProcessedSize() const { return _inProcessed; }
-
- CDecoder();
- virtual ~CDecoder();
-
- UInt64 GetOutputProcessedSize() const { return _outProcessed; }
-
- bool NeedsMoreInput() const { return _lzmaStatus == LZMA_STATUS_NEEDS_MORE_INPUT; }
-
- bool CheckFinishStatus(bool withEndMark) const
- {
- return _lzmaStatus == (withEndMark ?
- LZMA_STATUS_FINISHED_WITH_MARK :
- LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK);
- }
-};
-
-}}
-
-#endif
+// LzmaDecoder.h
+
+#ifndef ZIP7_INC_LZMA_DECODER_H
+#define ZIP7_INC_LZMA_DECODER_H
+
+// #include "../../../C/Alloc.h"
+#include "../../../C/LzmaDec.h"
+
+#include "../../Common/MyCom.h"
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NLzma {
+
+class CDecoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetDecoderProperties2,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize,
+ public ICompressSetBufSize,
+ #ifndef Z7_NO_READ_FROM_CODER
+ public ICompressSetInStream,
+ public ICompressSetOutStreamSize,
+ public ISequentialInStream,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetDecoderProperties2)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ Z7_COM_QI_ENTRY(ICompressSetBufSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_COM_QI_ENTRY(ICompressSetInStream)
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+public:
+ Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+private:
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ // Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+
+ Z7_IFACE_COM7_IMP(ICompressSetBufSize)
+
+ #ifndef Z7_NO_READ_FROM_CODER
+public:
+ Z7_IFACE_COM7_IMP(ICompressSetInStream)
+private:
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ #else
+ Z7_COM7F_IMF(SetOutStreamSize(const UInt64 *outSize));
+ #endif
+
+public:
+ bool FinishStream; // set it before decoding, if you need to decode full LZMA stream
+private:
+ bool _propsWereSet;
+ bool _outSizeDefined;
+
+ UInt32 _outStep;
+ UInt32 _inBufSize;
+ UInt32 _inBufSizeNew;
+
+ ELzmaStatus _lzmaStatus;
+ UInt32 _inPos;
+ UInt32 _inLim;
+ Byte *_inBuf;
+
+ UInt64 _outSize;
+ UInt64 _inProcessed;
+ UInt64 _outProcessed;
+
+ // CAlignOffsetAlloc _alloc;
+
+ CLzmaDec _state;
+
+ HRESULT CreateInputBuffer();
+ HRESULT CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+ void SetOutStreamSizeResume(const UInt64 *outSize);
+
+ #ifndef Z7_NO_READ_FROM_CODER
+private:
+ CMyComPtr<ISequentialInStream> _inStream;
+public:
+ HRESULT CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress);
+ HRESULT ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize);
+ #endif
+
+public:
+ CDecoder();
+ ~CDecoder();
+
+ UInt64 GetInputProcessedSize() const { return _inProcessed; }
+ UInt64 GetOutputProcessedSize() const { return _outProcessed; }
+ bool NeedsMoreInput() const { return _lzmaStatus == LZMA_STATUS_NEEDS_MORE_INPUT; }
+ bool CheckFinishStatus(bool withEndMark) const
+ {
+ return _lzmaStatus == (withEndMark ?
+ LZMA_STATUS_FINISHED_WITH_MARK :
+ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK);
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/LzmaEncoder.cpp b/CPP/7zip/Compress/LzmaEncoder.cpp
index 3151c3d..08e3ba5 100644
--- a/CPP/7zip/Compress/LzmaEncoder.cpp
+++ b/CPP/7zip/Compress/LzmaEncoder.cpp
@@ -1,182 +1,356 @@
-// LzmaEncoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../Common/CWrappers.h"
-#include "../Common/StreamUtils.h"
-
-#include "LzmaEncoder.h"
-
-namespace NCompress {
-namespace NLzma {
-
-CEncoder::CEncoder()
-{
- _encoder = NULL;
- _encoder = LzmaEnc_Create(&g_AlignedAlloc);
- if (!_encoder)
- throw 1;
-}
-
-CEncoder::~CEncoder()
-{
- if (_encoder)
- LzmaEnc_Destroy(_encoder, &g_AlignedAlloc, &g_BigAlloc);
-}
-
-static inline wchar_t GetUpperChar(wchar_t c)
-{
- if (c >= 'a' && c <= 'z')
- c -= 0x20;
- return c;
-}
-
-static int ParseMatchFinder(const wchar_t *s, int *btMode, int *numHashBytes)
-{
- wchar_t c = GetUpperChar(*s++);
- if (c == L'H')
- {
- if (GetUpperChar(*s++) != L'C')
- return 0;
- int numHashBytesLoc = (int)(*s++ - L'0');
- if (numHashBytesLoc < 4 || numHashBytesLoc > 4)
- return 0;
- if (*s != 0)
- return 0;
- *btMode = 0;
- *numHashBytes = numHashBytesLoc;
- return 1;
- }
-
- if (c != L'B')
- return 0;
- if (GetUpperChar(*s++) != L'T')
- return 0;
- int numHashBytesLoc = (int)(*s++ - L'0');
- if (numHashBytesLoc < 2 || numHashBytesLoc > 4)
- return 0;
- if (*s != 0)
- return 0;
- *btMode = 1;
- *numHashBytes = numHashBytesLoc;
- return 1;
-}
-
-#define SET_PROP_32(_id_, _dest_) case NCoderPropID::_id_: ep._dest_ = v; break;
-
-HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep)
-{
- if (propID == NCoderPropID::kMatchFinder)
- {
- if (prop.vt != VT_BSTR)
- return E_INVALIDARG;
- return ParseMatchFinder(prop.bstrVal, &ep.btMode, &ep.numHashBytes) ? S_OK : E_INVALIDARG;
- }
-
- if (propID > NCoderPropID::kReduceSize)
- return S_OK;
-
- if (propID == NCoderPropID::kReduceSize)
- {
- if (prop.vt == VT_UI8)
- ep.reduceSize = prop.uhVal.QuadPart;
- else
- return E_INVALIDARG;
- return S_OK;
- }
-
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- UInt32 v = prop.ulVal;
- switch (propID)
- {
- case NCoderPropID::kDefaultProp: if (v > 31) return E_INVALIDARG; ep.dictSize = (UInt32)1 << (unsigned)v; break;
- SET_PROP_32(kLevel, level)
- SET_PROP_32(kNumFastBytes, fb)
- SET_PROP_32(kMatchFinderCycles, mc)
- SET_PROP_32(kAlgorithm, algo)
- SET_PROP_32(kDictionarySize, dictSize)
- SET_PROP_32(kPosStateBits, pb)
- SET_PROP_32(kLitPosBits, lp)
- SET_PROP_32(kLitContextBits, lc)
- SET_PROP_32(kNumThreads, numThreads)
- default: return E_INVALIDARG;
- }
- return S_OK;
-}
-
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
- const PROPVARIANT *coderProps, UInt32 numProps)
-{
- CLzmaEncProps props;
- LzmaEncProps_Init(&props);
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- PROPID propID = propIDs[i];
- switch (propID)
- {
- case NCoderPropID::kEndMarker:
- if (prop.vt != VT_BOOL) return E_INVALIDARG; props.writeEndMark = (prop.boolVal != VARIANT_FALSE); break;
- default:
- RINOK(SetLzmaProp(propID, prop, props));
- }
- }
- return SResToHRESULT(LzmaEnc_SetProps(_encoder, &props));
-}
-
-
-STDMETHODIMP CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
- const PROPVARIANT *coderProps, UInt32 numProps)
-{
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- PROPID propID = propIDs[i];
- if (propID == NCoderPropID::kExpectedDataSize)
- if (prop.vt == VT_UI8)
- LzmaEnc_SetDataSize(_encoder, prop.uhVal.QuadPart);
- }
- return S_OK;
-}
-
-
-STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
-{
- Byte props[LZMA_PROPS_SIZE];
- size_t size = LZMA_PROPS_SIZE;
- RINOK(LzmaEnc_WriteProperties(_encoder, props, &size));
- return WriteStream(outStream, props, size);
-}
-
-
-#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
-
-STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
-{
- CSeqInStreamWrap inWrap;
- CSeqOutStreamWrap outWrap;
- CCompressProgressWrap progressWrap;
-
- inWrap.Init(inStream);
- outWrap.Init(outStream);
- progressWrap.Init(progress);
-
- SRes res = LzmaEnc_Encode(_encoder, &outWrap.vt, &inWrap.vt,
- progress ? &progressWrap.vt : NULL, &g_AlignedAlloc, &g_BigAlloc);
-
- _inputProcessed = inWrap.Processed;
-
- RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
- RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
- RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
-
- return SResToHRESULT(res);
-}
-
-}}
+// LzmaEncoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/StreamUtils.h"
+
+#include "LzmaEncoder.h"
+
+// #define LOG_LZMA_THREADS
+
+#ifdef LOG_LZMA_THREADS
+
+#include <stdio.h>
+
+#include "../../Common/IntToString.h"
+#include "../../Windows/TimeUtils.h"
+
+EXTERN_C_BEGIN
+void LzmaEnc_GetLzThreads(CLzmaEncHandle pp, HANDLE lz_threads[2]);
+EXTERN_C_END
+
+#endif
+
+namespace NCompress {
+namespace NLzma {
+
+CEncoder::CEncoder()
+{
+ _encoder = NULL;
+ _encoder = LzmaEnc_Create(&g_AlignedAlloc);
+ if (!_encoder)
+ throw 1;
+}
+
+CEncoder::~CEncoder()
+{
+ if (_encoder)
+ LzmaEnc_Destroy(_encoder, &g_AlignedAlloc, &g_BigAlloc);
+}
+
+static inline wchar_t GetLowCharFast(wchar_t c)
+{
+ return c |= 0x20;
+}
+
+static int ParseMatchFinder(const wchar_t *s, int *btMode, int *numHashBytes)
+{
+ const wchar_t c = GetLowCharFast(*s++);
+ if (c == 'h')
+ {
+ if (GetLowCharFast(*s++) != 'c')
+ return 0;
+ const int num = (int)(*s++ - L'0');
+ if (num < 4 || num > 5)
+ return 0;
+ if (*s != 0)
+ return 0;
+ *btMode = 0;
+ *numHashBytes = num;
+ return 1;
+ }
+
+ if (c != 'b')
+ return 0;
+ {
+ if (GetLowCharFast(*s++) != 't')
+ return 0;
+ const int num = (int)(*s++ - L'0');
+ if (num < 2 || num > 5)
+ return 0;
+ if (*s != 0)
+ return 0;
+ *btMode = 1;
+ *numHashBytes = num;
+ return 1;
+ }
+}
+
+#define SET_PROP_32(_id_, _dest_) case NCoderPropID::_id_: ep._dest_ = (int)v; break;
+#define SET_PROP_32U(_id_, _dest_) case NCoderPropID::_id_: ep._dest_ = v; break;
+
+HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep);
+HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep)
+{
+ if (propID == NCoderPropID::kMatchFinder)
+ {
+ if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+ return ParseMatchFinder(prop.bstrVal, &ep.btMode, &ep.numHashBytes) ? S_OK : E_INVALIDARG;
+ }
+
+ if (propID == NCoderPropID::kAffinity)
+ {
+ if (prop.vt == VT_UI8)
+ ep.affinity = prop.uhVal.QuadPart;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+ }
+
+ if (propID == NCoderPropID::kHashBits)
+ {
+ if (prop.vt == VT_UI4)
+ ep.numHashOutBits = prop.ulVal;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+ }
+
+ if (propID > NCoderPropID::kReduceSize)
+ return S_OK;
+
+ if (propID == NCoderPropID::kReduceSize)
+ {
+ if (prop.vt == VT_UI8)
+ ep.reduceSize = prop.uhVal.QuadPart;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+ }
+
+ if (propID == NCoderPropID::kDictionarySize)
+ {
+ if (prop.vt == VT_UI8)
+ {
+ // 21.03 : we support 64-bit VT_UI8 for dictionary and (dict == 4 GiB)
+ const UInt64 v = prop.uhVal.QuadPart;
+ if (v > ((UInt64)1 << 32))
+ return E_INVALIDARG;
+ UInt32 dict;
+ if (v == ((UInt64)1 << 32))
+ dict = (UInt32)(Int32)-1;
+ else
+ dict = (UInt32)v;
+ ep.dictSize = dict;
+ return S_OK;
+ }
+ }
+
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ const UInt32 v = prop.ulVal;
+ switch (propID)
+ {
+ case NCoderPropID::kDefaultProp:
+ if (v > 32)
+ return E_INVALIDARG;
+ ep.dictSize = (v == 32) ? (UInt32)(Int32)-1 : (UInt32)1 << (unsigned)v;
+ break;
+ SET_PROP_32(kLevel, level)
+ SET_PROP_32(kNumFastBytes, fb)
+ SET_PROP_32U(kMatchFinderCycles, mc)
+ SET_PROP_32(kAlgorithm, algo)
+ SET_PROP_32U(kDictionarySize, dictSize)
+ SET_PROP_32(kPosStateBits, pb)
+ SET_PROP_32(kLitPosBits, lp)
+ SET_PROP_32(kLitContextBits, lc)
+ SET_PROP_32(kNumThreads, numThreads)
+ default: return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs,
+ const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ CLzmaEncProps props;
+ LzmaEncProps_Init(&props);
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ const PROPID propID = propIDs[i];
+ switch (propID)
+ {
+ case NCoderPropID::kEndMarker:
+ if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ props.writeEndMark = (prop.boolVal != VARIANT_FALSE);
+ break;
+ default:
+ RINOK(SetLzmaProp(propID, prop, props))
+ }
+ }
+ return SResToHRESULT(LzmaEnc_SetProps(_encoder, &props));
+}
+
+
+Z7_COM7F_IMF(CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
+ const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ const PROPID propID = propIDs[i];
+ if (propID == NCoderPropID::kExpectedDataSize)
+ if (prop.vt == VT_UI8)
+ LzmaEnc_SetDataSize(_encoder, prop.uhVal.QuadPart);
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+{
+ Byte props[LZMA_PROPS_SIZE];
+ SizeT size = LZMA_PROPS_SIZE;
+ RINOK(LzmaEnc_WriteProperties(_encoder, props, &size))
+ return WriteStream(outStream, props, size);
+}
+
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+
+
+#ifdef LOG_LZMA_THREADS
+
+static inline UInt64 GetTime64(const FILETIME &t) { return ((UInt64)t.dwHighDateTime << 32) | t.dwLowDateTime; }
+
+static void PrintNum(UInt64 val, unsigned numDigits, char c = ' ')
+{
+ char temp[64];
+ char *p = temp + 32;
+ ConvertUInt64ToString(val, p);
+ unsigned len = (unsigned)strlen(p);
+ for (; len < numDigits; len++)
+ *--p = c;
+ printf("%s", p);
+}
+
+static void PrintTime(const char *s, UInt64 val, UInt64 total)
+{
+ printf(" %s :", s);
+ const UInt32 kFreq = 10000000;
+ UInt64 sec = val / kFreq;
+ PrintNum(sec, 6);
+ printf(" .");
+ UInt32 ms = (UInt32)(val - (sec * kFreq)) / (kFreq / 1000);
+ PrintNum(ms, 3, '0');
+
+ while (val > ((UInt64)1 << 56))
+ {
+ val >>= 1;
+ total >>= 1;
+ }
+
+ UInt64 percent = 0;
+ if (total != 0)
+ percent = val * 100 / total;
+ printf(" =");
+ PrintNum(percent, 4);
+ printf("%%");
+}
+
+
+struct CBaseStat
+{
+ UInt64 kernelTime, userTime;
+
+ BOOL Get(HANDLE thread, const CBaseStat *prevStat)
+ {
+ FILETIME creationTimeFT, exitTimeFT, kernelTimeFT, userTimeFT;
+ BOOL res = GetThreadTimes(thread
+ , &creationTimeFT, &exitTimeFT, &kernelTimeFT, &userTimeFT);
+ if (res)
+ {
+ kernelTime = GetTime64(kernelTimeFT);
+ userTime = GetTime64(userTimeFT);
+ if (prevStat)
+ {
+ kernelTime -= prevStat->kernelTime;
+ userTime -= prevStat->userTime;
+ }
+ }
+ return res;
+ }
+};
+
+
+static void PrintStat(HANDLE thread, UInt64 totalTime, const CBaseStat *prevStat)
+{
+ CBaseStat newStat;
+ if (!newStat.Get(thread, prevStat))
+ return;
+
+ PrintTime("K", newStat.kernelTime, totalTime);
+
+ const UInt64 processTime = newStat.kernelTime + newStat.userTime;
+
+ PrintTime("U", newStat.userTime, totalTime);
+ PrintTime("S", processTime, totalTime);
+ printf("\n");
+ // PrintTime("G ", totalTime, totalTime);
+}
+
+#endif
+
+
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+{
+ CSeqInStreamWrap inWrap;
+ CSeqOutStreamWrap outWrap;
+ CCompressProgressWrap progressWrap;
+
+ inWrap.Init(inStream);
+ outWrap.Init(outStream);
+ progressWrap.Init(progress);
+
+ #ifdef LOG_LZMA_THREADS
+
+ FILETIME startTimeFT;
+ NWindows::NTime::GetCurUtcFileTime(startTimeFT);
+ UInt64 totalTime = GetTime64(startTimeFT);
+ CBaseStat oldStat;
+ if (!oldStat.Get(GetCurrentThread(), NULL))
+ return E_FAIL;
+
+ #endif
+
+
+ SRes res = LzmaEnc_Encode(_encoder, &outWrap.vt, &inWrap.vt,
+ progress ? &progressWrap.vt : NULL, &g_AlignedAlloc, &g_BigAlloc);
+
+ _inputProcessed = inWrap.Processed;
+
+ RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
+ RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+ RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+
+
+ #ifdef LOG_LZMA_THREADS
+
+ NWindows::NTime::GetCurUtcFileTime(startTimeFT);
+ totalTime = GetTime64(startTimeFT) - totalTime;
+ HANDLE lz_threads[2];
+ LzmaEnc_GetLzThreads(_encoder, lz_threads);
+ printf("\n");
+ printf("Main: "); PrintStat(GetCurrentThread(), totalTime, &oldStat);
+ printf("Hash: "); PrintStat(lz_threads[0], totalTime, NULL);
+ printf("BinT: "); PrintStat(lz_threads[1], totalTime, NULL);
+ // PrintTime("Total: ", totalTime, totalTime);
+ printf("\n");
+
+ #endif
+
+ return SResToHRESULT(res);
+}
+
+}}
diff --git a/CPP/7zip/Compress/LzmaEncoder.h b/CPP/7zip/Compress/LzmaEncoder.h
index 7b31c66..2836d7d 100644
--- a/CPP/7zip/Compress/LzmaEncoder.h
+++ b/CPP/7zip/Compress/LzmaEncoder.h
@@ -1,46 +1,45 @@
-// LzmaEncoder.h
-
-#ifndef __LZMA_ENCODER_H
-#define __LZMA_ENCODER_H
-
-#include "../../../C/LzmaEnc.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NLzma {
-
-class CEncoder:
- public ICompressCoder,
- public ICompressSetCoderProperties,
- public ICompressWriteCoderProperties,
- public ICompressSetCoderPropertiesOpt,
- public CMyUnknownImp
-{
- CLzmaEncHandle _encoder;
- UInt64 _inputProcessed;
-public:
- MY_UNKNOWN_IMP4(
- ICompressCoder,
- ICompressSetCoderProperties,
- ICompressWriteCoderProperties,
- ICompressSetCoderPropertiesOpt)
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
- STDMETHOD(SetCoderPropertiesOpt)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
-
- CEncoder();
- virtual ~CEncoder();
-
- UInt64 GetInputProcessedSize() const { return _inputProcessed; }
- bool IsWriteEndMark() const { return LzmaEnc_IsWriteEndMark(_encoder) != 0; }
-};
-
-}}
-
-#endif
+// LzmaEncoder.h
+
+#ifndef ZIP7_INC_LZMA_ENCODER_H
+#define ZIP7_INC_LZMA_ENCODER_H
+
+#include "../../../C/LzmaEnc.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NLzma {
+
+class CEncoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetCoderProperties,
+ public ICompressWriteCoderProperties,
+ public ICompressSetCoderPropertiesOpt,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_4(
+ ICompressCoder,
+ ICompressSetCoderProperties,
+ ICompressWriteCoderProperties,
+ ICompressSetCoderPropertiesOpt)
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+public:
+ Z7_IFACE_COM7_IMP(ICompressSetCoderProperties)
+ Z7_IFACE_COM7_IMP(ICompressWriteCoderProperties)
+ Z7_IFACE_COM7_IMP(ICompressSetCoderPropertiesOpt)
+
+ CLzmaEncHandle _encoder;
+ UInt64 _inputProcessed;
+
+ CEncoder();
+ ~CEncoder();
+
+ UInt64 GetInputProcessedSize() const { return _inputProcessed; }
+ bool IsWriteEndMark() const { return LzmaEnc_IsWriteEndMark(_encoder) != 0; }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/LzmaRegister.cpp b/CPP/7zip/Compress/LzmaRegister.cpp
index 4397595..887f7a2 100644
--- a/CPP/7zip/Compress/LzmaRegister.cpp
+++ b/CPP/7zip/Compress/LzmaRegister.cpp
@@ -1,22 +1,22 @@
-// LzmaRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "LzmaDecoder.h"
-
-#ifndef EXTRACT_ONLY
-#include "LzmaEncoder.h"
-#endif
-
-namespace NCompress {
-namespace NLzma {
-
-REGISTER_CODEC_E(LZMA,
- CDecoder(),
- CEncoder(),
- 0x30101,
- "LZMA")
-
-}}
+// LzmaRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "LzmaDecoder.h"
+
+#ifndef Z7_EXTRACT_ONLY
+#include "LzmaEncoder.h"
+#endif
+
+namespace NCompress {
+namespace NLzma {
+
+REGISTER_CODEC_E(LZMA,
+ CDecoder(),
+ CEncoder(),
+ 0x30101,
+ "LZMA")
+
+}}
diff --git a/CPP/7zip/Compress/LzmsDecoder.cpp b/CPP/7zip/Compress/LzmsDecoder.cpp
new file mode 100644
index 0000000..38c0408
--- /dev/null
+++ b/CPP/7zip/Compress/LzmsDecoder.cpp
@@ -0,0 +1,576 @@
+// LzmsDecoder.cpp
+// The code is based on LZMS description from wimlib code
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "LzmsDecoder.h"
+
+namespace NCompress {
+namespace NLzms {
+
+static UInt32 g_PosBases[k_NumPosSyms /* + 1 */];
+
+static Byte g_PosDirectBits[k_NumPosSyms];
+
+static const Byte k_PosRuns[31] =
+{
+ 8, 0, 9, 7, 10, 15, 15, 20, 20, 30, 33, 40, 42, 45, 60, 73,
+ 80, 85, 95, 105, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
+};
+
+static UInt32 g_LenBases[k_NumLenSyms];
+
+static const Byte k_LenDirectBits[k_NumLenSyms] =
+{
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2,
+ 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 6,
+ 7, 8, 9, 10, 16, 30,
+};
+
+static struct CInit
+{
+ CInit()
+ {
+ {
+ unsigned sum = 0;
+ for (unsigned i = 0; i < sizeof(k_PosRuns); i++)
+ {
+ unsigned t = k_PosRuns[i];
+ for (unsigned y = 0; y < t; y++)
+ g_PosDirectBits[sum + y] = (Byte)i;
+ sum += t;
+ }
+ }
+ {
+ UInt32 sum = 1;
+ for (unsigned i = 0; i < k_NumPosSyms; i++)
+ {
+ g_PosBases[i] = sum;
+ sum += (UInt32)1 << g_PosDirectBits[i];
+ }
+ // g_PosBases[k_NumPosSyms] = sum;
+ }
+ {
+ UInt32 sum = 1;
+ for (unsigned i = 0; i < k_NumLenSyms; i++)
+ {
+ g_LenBases[i] = sum;
+ sum += (UInt32)1 << k_LenDirectBits[i];
+ }
+ }
+ }
+} g_Init;
+
+static unsigned GetNumPosSlots(size_t size)
+{
+ if (size < 2)
+ return 0;
+
+ size--;
+
+ if (size >= g_PosBases[k_NumPosSyms - 1])
+ return k_NumPosSyms;
+ unsigned left = 0;
+ unsigned right = k_NumPosSyms;
+ for (;;)
+ {
+ const unsigned m = (left + right) / 2;
+ if (left == m)
+ return m + 1;
+ if (size >= g_PosBases[m])
+ left = m;
+ else
+ right = m;
+ }
+}
+
+
+static const Int32 k_x86_WindowSize = 65535;
+static const Int32 k_x86_TransOffset = 1023;
+
+static const size_t k_x86_HistorySize = (1 << 16);
+
+static void x86_Filter(Byte *data, UInt32 size, Int32 *history)
+{
+ if (size <= 17)
+ return;
+
+ Byte isCode[256];
+ memset(isCode, 0, 256);
+ isCode[0x48] = 1;
+ isCode[0x4C] = 1;
+ isCode[0xE8] = 1;
+ isCode[0xE9] = 1;
+ isCode[0xF0] = 1;
+ isCode[0xFF] = 1;
+
+ {
+ for (size_t i = 0; i < k_x86_HistorySize; i++)
+ history[i] = -(Int32)k_x86_WindowSize - 1;
+ }
+
+ size -= 16;
+ const unsigned kSave = 6;
+ const Byte savedByte = data[(size_t)size + kSave];
+ data[(size_t)size + kSave] = 0xE8;
+ Int32 last_x86_pos = -k_x86_TransOffset - 1;
+
+ // first byte is ignored
+ Int32 i = 0;
+
+ for (;;)
+ {
+ Byte *p = data + (UInt32)i;
+
+ for (;;)
+ {
+ if (isCode[*(++p)]) break;
+ if (isCode[*(++p)]) break;
+ }
+
+ i = (Int32)(p - data);
+ if ((UInt32)i >= size)
+ break;
+
+ UInt32 codeLen;
+
+ Int32 maxTransOffset = k_x86_TransOffset;
+
+ const Byte b = p[0];
+
+ if (b == 0x48)
+ {
+ if (p[1] == 0x8B)
+ {
+ if ((p[2] & 0xF7) != 0x5)
+ continue;
+ // MOV RAX / RCX, [RIP + disp32]
+ }
+ else if (p[1] == 0x8D) // LEA
+ {
+ if ((p[2] & 0x7) != 0x5)
+ continue;
+ // LEA R**, []
+ }
+ else
+ continue;
+ codeLen = 3;
+ }
+ else if (b == 0x4C)
+ {
+ if (p[1] != 0x8D || (p[2] & 0x7) != 0x5)
+ continue;
+ // LEA R*, []
+ codeLen = 3;
+ }
+ else if (b == 0xE8)
+ {
+ // CALL
+ codeLen = 1;
+ maxTransOffset /= 2;
+ }
+ else if (b == 0xE9)
+ {
+ // JUMP
+ i += 4;
+ continue;
+ }
+ else if (b == 0xF0)
+ {
+ if (p[1] != 0x83 || p[2] != 0x05)
+ continue;
+ // LOCK ADD [RIP + disp32], imm8
+ // LOCK ADD [disp32], imm8
+ codeLen = 3;
+ }
+ else
+ // if (b == 0xFF)
+ {
+ if (p[1] != 0x15)
+ continue;
+ // CALL [RIP + disp32];
+ // CALL [disp32];
+ codeLen = 2;
+ }
+
+ Int32 *target;
+ {
+ Byte *p2 = p + codeLen;
+ UInt32 n = GetUi32(p2);
+ if (i - last_x86_pos <= maxTransOffset)
+ {
+ n = (UInt32)((Int32)n - i);
+ SetUi32(p2, n)
+ }
+ target = history + (((UInt32)i + n) & 0xFFFF);
+ }
+
+ i += (Int32)(codeLen + sizeof(UInt32) - 1);
+
+ if (i - *target <= k_x86_WindowSize)
+ last_x86_pos = i;
+ *target = i;
+ }
+
+ data[(size_t)size + kSave] = savedByte;
+}
+
+
+
+// static const int kLenIdNeedInit = -2;
+
+CDecoder::CDecoder():
+ _x86_history(NULL)
+{
+}
+
+CDecoder::~CDecoder()
+{
+ ::MidFree(_x86_history);
+}
+
+// #define RIF(x) { if (!(x)) return false; }
+
+#define LIMIT_CHECK if (_bs._buf < _rc.cur) return S_FALSE;
+// #define LIMIT_CHECK
+
+#define READ_BITS_CHECK(numDirectBits) \
+ if (_bs._buf < _rc.cur) return S_FALSE; \
+ if ((size_t)(_bs._buf - _rc.cur) < (numDirectBits >> 3)) return S_FALSE;
+
+
+#define HUFF_DEC(sym, pp) \
+ sym = pp.DecodeFull(&_bs); \
+ pp.Freqs[sym]++; \
+ if (--pp.RebuildRem == 0) pp.Rebuild();
+
+
+HRESULT CDecoder::CodeReal(const Byte *in, size_t inSize, Byte *_win, size_t outSize)
+{
+ // size_t inSizeT = (size_t)(inSize);
+ // Byte *_win;
+ // size_t _pos;
+ _pos = 0;
+
+ CBitDecoder _bs;
+ CRangeDecoder _rc;
+
+ if (inSize < 8 || (inSize & 1) != 0)
+ return S_FALSE;
+ _rc.Init(in, inSize);
+ if (_rc.code >= _rc.range)
+ return S_FALSE;
+ _bs.Init(in, inSize);
+
+ {
+ {
+ {
+ for (unsigned i = 0 ; i < k_NumReps + 1; i++)
+ _reps[i] = i + 1;
+ }
+
+ {
+ for (unsigned i = 0 ; i < k_NumReps + 1; i++)
+ _deltaReps[i] = i + 1;
+ }
+
+ mainState = 0;
+ matchState = 0;
+
+ { for (size_t i = 0; i < k_NumMainProbs; i++) mainProbs[i].Init(); }
+ { for (size_t i = 0; i < k_NumMatchProbs; i++) matchProbs[i].Init(); }
+
+ {
+ for (size_t k = 0; k < k_NumReps; k++)
+ {
+ lzRepStates[k] = 0;
+ for (size_t i = 0; i < k_NumRepProbs; i++)
+ lzRepProbs[k][i].Init();
+ }
+ }
+ {
+ for (size_t k = 0; k < k_NumReps; k++)
+ {
+ deltaRepStates[k] = 0;
+ for (size_t i = 0; i < k_NumRepProbs; i++)
+ deltaRepProbs[k][i].Init();
+ }
+ }
+
+ m_LitDecoder.Init();
+ m_LenDecoder.Init();
+ m_PowerDecoder.Init();
+ unsigned numPosSyms = GetNumPosSlots(outSize);
+ if (numPosSyms < 2)
+ numPosSyms = 2;
+ m_PosDecoder.Init(numPosSyms);
+ m_DeltaDecoder.Init(numPosSyms);
+ }
+ }
+
+ {
+ unsigned prevType = 0;
+
+ while (_pos < outSize)
+ {
+ if (_rc.Decode(&mainState, k_NumMainProbs, mainProbs) == 0)
+ {
+ UInt32 number;
+ HUFF_DEC(number, m_LitDecoder)
+ LIMIT_CHECK
+ _win[_pos++] = (Byte)number;
+ prevType = 0;
+ }
+ else if (_rc.Decode(&matchState, k_NumMatchProbs, matchProbs) == 0)
+ {
+ UInt32 distance;
+
+ if (_rc.Decode(&lzRepStates[0], k_NumRepProbs, lzRepProbs[0]) == 0)
+ {
+ UInt32 number;
+ HUFF_DEC(number, m_PosDecoder)
+ LIMIT_CHECK
+
+ const unsigned numDirectBits = g_PosDirectBits[number];
+ distance = g_PosBases[number];
+ READ_BITS_CHECK(numDirectBits)
+ distance += _bs.ReadBits32(numDirectBits);
+ // LIMIT_CHECK
+ _reps[3] = _reps[2];
+ _reps[2] = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = distance;
+ }
+ else
+ {
+ if (_rc.Decode(&lzRepStates[1], k_NumRepProbs, lzRepProbs[1]) == 0)
+ {
+ if (prevType != 1)
+ distance = _reps[0];
+ else
+ {
+ distance = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = distance;
+ }
+ }
+ else if (_rc.Decode(&lzRepStates[2], k_NumRepProbs, lzRepProbs[2]) == 0)
+ {
+ if (prevType != 1)
+ {
+ distance = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = distance;
+ }
+ else
+ {
+ distance = _reps[2];
+ _reps[2] = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = distance;
+ }
+ }
+ else
+ {
+ if (prevType != 1)
+ {
+ distance = _reps[2];
+ _reps[2] = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = distance;
+ }
+ else
+ {
+ distance = _reps[3];
+ _reps[3] = _reps[2];
+ _reps[2] = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = distance;
+ }
+ }
+ }
+
+ UInt32 lenSlot;
+ HUFF_DEC(lenSlot, m_LenDecoder)
+ LIMIT_CHECK
+
+ UInt32 len = g_LenBases[lenSlot];
+ {
+ const unsigned numDirectBits = k_LenDirectBits[lenSlot];
+ READ_BITS_CHECK(numDirectBits)
+ len += _bs.ReadBits32(numDirectBits);
+ }
+ // LIMIT_CHECK
+
+ if (len > outSize - _pos)
+ return S_FALSE;
+
+ if (distance > _pos)
+ return S_FALSE;
+
+ Byte *dest = _win + _pos;
+ const Byte *src = dest - distance;
+ _pos += len;
+ do
+ *dest++ = *src++;
+ while (--len);
+
+ prevType = 1;
+ }
+ else
+ {
+ UInt64 distance;
+
+ UInt32 power;
+ UInt32 distance32;
+
+ if (_rc.Decode(&deltaRepStates[0], k_NumRepProbs, deltaRepProbs[0]) == 0)
+ {
+ HUFF_DEC(power, m_PowerDecoder)
+ LIMIT_CHECK
+
+ UInt32 number;
+ HUFF_DEC(number, m_DeltaDecoder)
+ LIMIT_CHECK
+
+ const unsigned numDirectBits = g_PosDirectBits[number];
+ distance32 = g_PosBases[number];
+ READ_BITS_CHECK(numDirectBits)
+ distance32 += _bs.ReadBits32(numDirectBits);
+ // LIMIT_CHECK
+
+ distance = ((UInt64)power << 32) | distance32;
+
+ _deltaReps[3] = _deltaReps[2];
+ _deltaReps[2] = _deltaReps[1];
+ _deltaReps[1] = _deltaReps[0];
+ _deltaReps[0] = distance;
+ }
+ else
+ {
+ if (_rc.Decode(&deltaRepStates[1], k_NumRepProbs, deltaRepProbs[1]) == 0)
+ {
+ if (prevType != 2)
+ distance = _deltaReps[0];
+ else
+ {
+ distance = _deltaReps[1];
+ _deltaReps[1] = _deltaReps[0];
+ _deltaReps[0] = distance;
+ }
+ }
+ else if (_rc.Decode(&deltaRepStates[2], k_NumRepProbs, deltaRepProbs[2]) == 0)
+ {
+ if (prevType != 2)
+ {
+ distance = _deltaReps[1];
+ _deltaReps[1] = _deltaReps[0];
+ _deltaReps[0] = distance;
+ }
+ else
+ {
+ distance = _deltaReps[2];
+ _deltaReps[2] = _deltaReps[1];
+ _deltaReps[1] = _deltaReps[0];
+ _deltaReps[0] = distance;
+ }
+ }
+ else
+ {
+ if (prevType != 2)
+ {
+ distance = _deltaReps[2];
+ _deltaReps[2] = _deltaReps[1];
+ _deltaReps[1] = _deltaReps[0];
+ _deltaReps[0] = distance;
+ }
+ else
+ {
+ distance = _deltaReps[3];
+ _deltaReps[3] = _deltaReps[2];
+ _deltaReps[2] = _deltaReps[1];
+ _deltaReps[1] = _deltaReps[0];
+ _deltaReps[0] = distance;
+ }
+ }
+ distance32 = (UInt32)_deltaReps[0] & 0xFFFFFFFF;
+ power = (UInt32)(_deltaReps[0] >> 32);
+ }
+
+ const UInt32 dist = (distance32 << power);
+
+ UInt32 lenSlot;
+ HUFF_DEC(lenSlot, m_LenDecoder)
+ LIMIT_CHECK
+
+ UInt32 len = g_LenBases[lenSlot];
+ {
+ unsigned numDirectBits = k_LenDirectBits[lenSlot];
+ READ_BITS_CHECK(numDirectBits)
+ len += _bs.ReadBits32(numDirectBits);
+ }
+ // LIMIT_CHECK
+
+ if (len > outSize - _pos)
+ return S_FALSE;
+
+ size_t span = (size_t)1 << power;
+ if ((UInt64)dist + span > _pos)
+ return S_FALSE;
+ Byte *dest = _win + _pos - span;
+ const Byte *src = dest - dist;
+ _pos += len;
+ do
+ {
+ *(dest + span) = (Byte)(*(dest) + *(src + span) - *(src));
+ src++;
+ dest++;
+ }
+ while (--len);
+
+ prevType = 2;
+ }
+ }
+ }
+
+ _rc.Normalize();
+ if (_rc.code != 0)
+ return S_FALSE;
+ if (_rc.cur > _bs._buf
+ || (_rc.cur == _bs._buf && _bs._bitPos != 0))
+ return S_FALSE;
+
+ /*
+ int delta = (int)(_bs._buf - _rc.cur);
+ if (_bs._bitPos != 0)
+ delta--;
+ if ((delta & 1))
+ delta--;
+ printf("%d ", delta);
+ */
+
+ return S_OK;
+}
+
+HRESULT CDecoder::Code(const Byte *in, size_t inSize, Byte *out, size_t outSize)
+{
+ if (!_x86_history)
+ {
+ _x86_history = (Int32 *)::MidAlloc(sizeof(Int32) * k_x86_HistorySize);
+ if (!_x86_history)
+ return E_OUTOFMEMORY;
+ }
+ HRESULT res;
+ // try
+ {
+ res = CodeReal(in, inSize, out, outSize);
+ }
+ // catch (...) { res = S_FALSE; }
+ x86_Filter(out, (UInt32)_pos, _x86_history);
+ return res;
+}
+
+}}
diff --git a/CPP/7zip/Compress/LzmsDecoder.h b/CPP/7zip/Compress/LzmsDecoder.h
new file mode 100644
index 0000000..e173c97
--- /dev/null
+++ b/CPP/7zip/Compress/LzmsDecoder.h
@@ -0,0 +1,271 @@
+// LzmsDecoder.h
+// The code is based on LZMS description from wimlib code
+
+#ifndef ZIP7_INC_LZMS_DECODER_H
+#define ZIP7_INC_LZMS_DECODER_H
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#define PRF(x) x
+#else
+// #define PRF(x)
+#endif
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/HuffEnc.h"
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "HuffmanDecoder.h"
+
+namespace NCompress {
+namespace NLzms {
+
+class CBitDecoder
+{
+public:
+ const Byte *_buf;
+ unsigned _bitPos;
+
+ void Init(const Byte *buf, size_t size) throw()
+ {
+ _buf = buf + size;
+ _bitPos = 0;
+ }
+
+ UInt32 GetValue(unsigned numBits) const
+ {
+ UInt32 v = ((UInt32)_buf[-1] << 16) | ((UInt32)_buf[-2] << 8) | (UInt32)_buf[-3];
+ v >>= (24 - numBits - _bitPos);
+ return v & ((1 << numBits) - 1);
+ }
+
+ void MovePos(unsigned numBits)
+ {
+ _bitPos += numBits;
+ _buf -= (_bitPos >> 3);
+ _bitPos &= 7;
+ }
+
+ UInt32 ReadBits32(unsigned numBits)
+ {
+ UInt32 mask = (((UInt32)1 << numBits) - 1);
+ numBits += _bitPos;
+ const Byte *buf = _buf;
+ UInt32 v = GetUi32(buf - 4);
+ if (numBits > 32)
+ {
+ v <<= (numBits - 32);
+ v |= (UInt32)buf[-5] >> (40 - numBits);
+ }
+ else
+ v >>= (32 - numBits);
+ _buf = buf - (numBits >> 3);
+ _bitPos = numBits & 7;
+ return v & mask;
+ }
+};
+
+
+const unsigned k_NumLitSyms = 256;
+const unsigned k_NumLenSyms = 54;
+const unsigned k_NumPosSyms = 799;
+const unsigned k_NumPowerSyms = 8;
+
+const unsigned k_NumProbBits = 6;
+const unsigned k_ProbLimit = 1 << k_NumProbBits;
+const unsigned k_InitialProb = 48;
+const UInt32 k_InitialHist = 0x55555555;
+
+const unsigned k_NumReps = 3;
+
+const unsigned k_NumMainProbs = 16;
+const unsigned k_NumMatchProbs = 32;
+const unsigned k_NumRepProbs = 64;
+
+const unsigned k_NumHuffmanBits = 15;
+
+template <UInt32 m_NumSyms, UInt32 m_RebuildFreq, unsigned numTableBits>
+class CHuffDecoder: public NCompress::NHuffman::CDecoder<k_NumHuffmanBits, m_NumSyms, numTableBits>
+{
+public:
+ UInt32 RebuildRem;
+ UInt32 NumSyms;
+ UInt32 Freqs[m_NumSyms];
+
+ void Generate() throw()
+ {
+ UInt32 vals[m_NumSyms];
+ Byte levels[m_NumSyms];
+
+ // We need to check that our algorithm is OK, when optimal Huffman tree uses more than 15 levels !!!
+ Huffman_Generate(Freqs, vals, levels, NumSyms, k_NumHuffmanBits);
+
+ /*
+ for (UInt32 i = NumSyms; i < m_NumSyms; i++)
+ levels[i] = 0;
+ */
+ this->BuildFull(levels, NumSyms);
+ }
+
+ void Rebuild() throw()
+ {
+ Generate();
+ RebuildRem = m_RebuildFreq;
+ UInt32 num = NumSyms;
+ for (UInt32 i = 0; i < num; i++)
+ Freqs[i] = (Freqs[i] >> 1) + 1;
+ }
+
+public:
+ void Init(UInt32 numSyms = m_NumSyms) throw()
+ {
+ RebuildRem = m_RebuildFreq;
+ NumSyms = numSyms;
+ for (UInt32 i = 0; i < numSyms; i++)
+ Freqs[i] = 1;
+ // for (; i < m_NumSyms; i++) Freqs[i] = 0;
+ Generate();
+ }
+};
+
+
+struct CProbEntry
+{
+ UInt32 Prob;
+ UInt64 Hist;
+
+ void Init()
+ {
+ Prob = k_InitialProb;
+ Hist = k_InitialHist;
+ }
+
+ UInt32 GetProb() const throw()
+ {
+ UInt32 prob = Prob;
+ if (prob == 0)
+ prob = 1;
+ else if (prob == k_ProbLimit)
+ prob = k_ProbLimit - 1;
+ return prob;
+ }
+
+ void Update(unsigned bit) throw()
+ {
+ Prob += (UInt32)((Int32)(Hist >> (k_ProbLimit - 1)) - (Int32)bit);
+ Hist = (Hist << 1) | bit;
+ }
+};
+
+
+struct CRangeDecoder
+{
+ UInt32 range;
+ UInt32 code;
+ const Byte *cur;
+ // const Byte *end;
+
+ void Init(const Byte *data, size_t /* size */) throw()
+ {
+ range = 0xFFFFFFFF;
+ code = (((UInt32)GetUi16(data)) << 16) | GetUi16(data + 2);
+ cur = data + 4;
+ // end = data + size;
+ }
+
+ void Normalize()
+ {
+ if (range <= 0xFFFF)
+ {
+ range <<= 16;
+ code <<= 16;
+ // if (cur >= end) throw 1;
+ code |= GetUi16(cur);
+ cur += 2;
+ }
+ }
+
+ unsigned Decode(UInt32 *state, UInt32 numStates, struct CProbEntry *probs)
+ {
+ UInt32 st = *state;
+ CProbEntry *entry = &probs[st];
+ st = (st << 1) & (numStates - 1);
+
+ UInt32 prob = entry->GetProb();
+
+ if (range <= 0xFFFF)
+ {
+ range <<= 16;
+ code <<= 16;
+ // if (cur >= end) throw 1;
+ code |= GetUi16(cur);
+ cur += 2;
+ }
+
+ UInt32 bound = (range >> k_NumProbBits) * prob;
+
+ if (code < bound)
+ {
+ range = bound;
+ *state = st;
+ entry->Update(0);
+ return 0;
+ }
+ else
+ {
+ range -= bound;
+ code -= bound;
+ *state = st | 1;
+ entry->Update(1);
+ return 1;
+ }
+ }
+};
+
+
+class CDecoder
+{
+ // CRangeDecoder _rc;
+ // CBitDecoder _bs;
+ size_t _pos;
+
+ UInt32 _reps[k_NumReps + 1];
+ UInt64 _deltaReps[k_NumReps + 1];
+
+ UInt32 mainState;
+ UInt32 matchState;
+ UInt32 lzRepStates[k_NumReps];
+ UInt32 deltaRepStates[k_NumReps];
+
+ struct CProbEntry mainProbs[k_NumMainProbs];
+ struct CProbEntry matchProbs[k_NumMatchProbs];
+
+ struct CProbEntry lzRepProbs[k_NumReps][k_NumRepProbs];
+ struct CProbEntry deltaRepProbs[k_NumReps][k_NumRepProbs];
+
+ CHuffDecoder<k_NumLitSyms, 1024, 9> m_LitDecoder;
+ CHuffDecoder<k_NumPosSyms, 1024, 9> m_PosDecoder;
+ CHuffDecoder<k_NumLenSyms, 512, 8> m_LenDecoder;
+ CHuffDecoder<k_NumPowerSyms, 512, 6> m_PowerDecoder;
+ CHuffDecoder<k_NumPosSyms, 1024, 9> m_DeltaDecoder;
+
+ Int32 *_x86_history;
+
+ HRESULT CodeReal(const Byte *in, size_t inSize, Byte *out, size_t outSize);
+public:
+ CDecoder();
+ ~CDecoder();
+
+ HRESULT Code(const Byte *in, size_t inSize, Byte *out, size_t outSize);
+ size_t GetUnpackSize() const { return _pos; }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Lzx.h b/CPP/7zip/Compress/Lzx.h
new file mode 100644
index 0000000..2532088
--- /dev/null
+++ b/CPP/7zip/Compress/Lzx.h
@@ -0,0 +1,59 @@
+// Lzx.h
+
+#ifndef ZIP7_INC_COMPRESS_LZX_H
+#define ZIP7_INC_COMPRESS_LZX_H
+
+#include "../../Common/MyTypes.h"
+
+namespace NCompress {
+namespace NLzx {
+
+const unsigned kBlockType_NumBits = 3;
+const unsigned kBlockType_Verbatim = 1;
+const unsigned kBlockType_Aligned = 2;
+const unsigned kBlockType_Uncompressed = 3;
+
+const unsigned kNumHuffmanBits = 16;
+const unsigned kNumReps = 3;
+
+const unsigned kNumLenSlots = 8;
+const unsigned kMatchMinLen = 2;
+const unsigned kNumLenSymbols = 249;
+const unsigned kMatchMaxLen = kMatchMinLen + (kNumLenSlots - 1) + kNumLenSymbols - 1;
+
+const unsigned kNumAlignLevelBits = 3;
+const unsigned kNumAlignBits = 3;
+const unsigned kAlignTableSize = 1 << kNumAlignBits;
+
+const unsigned kNumPosSlots = 50;
+const unsigned kNumPosLenSlots = kNumPosSlots * kNumLenSlots;
+
+const unsigned kMainTableSize = 256 + kNumPosLenSlots;
+const unsigned kLevelTableSize = 20;
+const unsigned kMaxTableSize = kMainTableSize;
+
+const unsigned kNumLevelBits = 4;
+
+const unsigned kLevelSym_Zero1 = 17;
+const unsigned kLevelSym_Zero2 = 18;
+const unsigned kLevelSym_Same = 19;
+
+const unsigned kLevelSym_Zero1_Start = 4;
+const unsigned kLevelSym_Zero1_NumBits = 4;
+
+const unsigned kLevelSym_Zero2_Start = kLevelSym_Zero1_Start + (1 << kLevelSym_Zero1_NumBits);
+const unsigned kLevelSym_Zero2_NumBits = 5;
+
+const unsigned kLevelSym_Same_NumBits = 1;
+const unsigned kLevelSym_Same_Start = 4;
+
+const unsigned kNumDictBits_Min = 15;
+const unsigned kNumDictBits_Max = 21;
+const UInt32 kDictSize_Max = (UInt32)1 << kNumDictBits_Max;
+
+const unsigned kNumLinearPosSlotBits = 17;
+const unsigned kNumPowerPosSlots = 38;
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/LzxDecoder.cpp b/CPP/7zip/Compress/LzxDecoder.cpp
new file mode 100644
index 0000000..b50d863
--- /dev/null
+++ b/CPP/7zip/Compress/LzxDecoder.cpp
@@ -0,0 +1,529 @@
+// LzxDecoder.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#include "../../../C/Alloc.h"
+
+#include "LzxDecoder.h"
+
+namespace NCompress {
+namespace NLzx {
+
+static void x86_Filter(Byte *data, UInt32 size, UInt32 processedSize, UInt32 translationSize)
+{
+ const UInt32 kResidue = 10;
+ if (size <= kResidue)
+ return;
+ size -= kResidue;
+
+ const Byte save = data[(size_t)size + 4];
+ data[(size_t)size + 4] = 0xE8;
+
+ for (UInt32 i = 0;;)
+ {
+ Byte *p = data + i;
+ for (;;)
+ {
+ if (*p++ == 0xE8) break;
+ if (*p++ == 0xE8) break;
+ if (*p++ == 0xE8) break;
+ if (*p++ == 0xE8) break;
+ }
+
+ i = (UInt32)(p - data);
+
+ if (i > size)
+ break;
+ {
+ Int32 v = (Int32)GetUi32(p);
+ Int32 pos = (Int32)((Int32)1 - (Int32)(processedSize + i));
+ i += 4;
+ if (v >= pos && v < (Int32)translationSize)
+ {
+ v += (v >= 0 ? pos : (Int32)translationSize);
+ SetUi32(p, (UInt32)v)
+ }
+ }
+ }
+
+ data[(size_t)size + 4] = save;
+}
+
+
+CDecoder::CDecoder(bool wimMode):
+ _win(NULL),
+ _skipByte(false),
+ _unpackBlockSize(0),
+ KeepHistoryForNext(true),
+ NeedAlloc(true),
+ _keepHistory(false),
+ _wimMode(wimMode),
+ _numDictBits(15),
+ _x86_buf(NULL),
+ _x86_translationSize(0),
+ _unpackedData(NULL)
+{
+}
+
+CDecoder::~CDecoder()
+{
+ if (NeedAlloc)
+ ::MidFree(_win);
+ ::MidFree(_x86_buf);
+}
+
+HRESULT CDecoder::Flush()
+{
+ if (_x86_translationSize != 0)
+ {
+ Byte *destData = _win + _writePos;
+ const UInt32 curSize = _pos - _writePos;
+ if (KeepHistoryForNext)
+ {
+ if (!_x86_buf)
+ {
+ // we must change it to support another chunk sizes
+ const size_t kChunkSize = (size_t)1 << 15;
+ if (curSize > kChunkSize)
+ return E_NOTIMPL;
+ _x86_buf = (Byte *)::MidAlloc(kChunkSize);
+ if (!_x86_buf)
+ return E_OUTOFMEMORY;
+ }
+ memcpy(_x86_buf, destData, curSize);
+ _unpackedData = _x86_buf;
+ destData = _x86_buf;
+ }
+ x86_Filter(destData, (UInt32)curSize, _x86_processedSize, _x86_translationSize);
+ _x86_processedSize += (UInt32)curSize;
+ if (_x86_processedSize >= ((UInt32)1 << 30))
+ _x86_translationSize = 0;
+ }
+
+ return S_OK;
+}
+
+
+UInt32 CDecoder::ReadBits(unsigned numBits) { return _bitStream.ReadBitsSmall(numBits); }
+
+#define RIF(x) { if (!(x)) return false; }
+
+bool CDecoder::ReadTable(Byte *levels, unsigned numSymbols)
+{
+ {
+ Byte levels2[kLevelTableSize];
+ for (unsigned i = 0; i < kLevelTableSize; i++)
+ levels2[i] = (Byte)ReadBits(kNumLevelBits);
+ RIF(_levelDecoder.Build(levels2))
+ }
+
+ unsigned i = 0;
+ do
+ {
+ UInt32 sym = _levelDecoder.Decode(&_bitStream);
+ if (sym <= kNumHuffmanBits)
+ {
+ int delta = (int)levels[i] - (int)sym;
+ delta += (delta < 0) ? (kNumHuffmanBits + 1) : 0;
+ levels[i++] = (Byte)delta;
+ continue;
+ }
+
+ unsigned num;
+ Byte symbol;
+
+ if (sym < kLevelSym_Same)
+ {
+ sym -= kLevelSym_Zero1;
+ num = kLevelSym_Zero1_Start + ((unsigned)sym << kLevelSym_Zero1_NumBits) +
+ (unsigned)ReadBits(kLevelSym_Zero1_NumBits + sym);
+ symbol = 0;
+ }
+ else if (sym == kLevelSym_Same)
+ {
+ num = kLevelSym_Same_Start + (unsigned)ReadBits(kLevelSym_Same_NumBits);
+ sym = _levelDecoder.Decode(&_bitStream);
+ if (sym > kNumHuffmanBits)
+ return false;
+ int delta = (int)levels[i] - (int)sym;
+ delta += (delta < 0) ? (kNumHuffmanBits + 1) : 0;
+ symbol = (Byte)delta;
+ }
+ else
+ return false;
+
+ const unsigned limit = i + num;
+ if (limit > numSymbols)
+ return false;
+
+ do
+ levels[i++] = symbol;
+ while (i < limit);
+ }
+ while (i < numSymbols);
+
+ return true;
+}
+
+
+bool CDecoder::ReadTables(void)
+{
+ {
+ if (_skipByte)
+ {
+ if (_bitStream.DirectReadByte() != 0)
+ return false;
+ }
+
+ _bitStream.NormalizeBig();
+
+ const unsigned blockType = (unsigned)ReadBits(kBlockType_NumBits);
+ if (blockType > kBlockType_Uncompressed)
+ return false;
+
+ _unpackBlockSize = (1 << 15);
+ if (!_wimMode || ReadBits(1) == 0)
+ {
+ _unpackBlockSize = ReadBits(16);
+ // wimlib supports chunks larger than 32KB (unsupported my MS wim).
+ if (!_wimMode || _numDictBits >= 16)
+ {
+ _unpackBlockSize <<= 8;
+ _unpackBlockSize |= ReadBits(8);
+ }
+ }
+
+ PRF(printf("\nBlockSize = %6d %s ", _unpackBlockSize, (_pos & 1) ? "@@@" : " "));
+
+ _isUncompressedBlock = (blockType == kBlockType_Uncompressed);
+
+ _skipByte = false;
+
+ if (_isUncompressedBlock)
+ {
+ _skipByte = ((_unpackBlockSize & 1) != 0);
+
+ PRF(printf(" UncompressedBlock "));
+ if (_unpackBlockSize & 1)
+ {
+ PRF(printf(" ######### "));
+ }
+
+ if (!_bitStream.PrepareUncompressed())
+ return false;
+ if (_bitStream.GetRem() < kNumReps * 4)
+ return false;
+
+ for (unsigned i = 0; i < kNumReps; i++)
+ {
+ const UInt32 rep = _bitStream.ReadUInt32();
+ if (rep > _winSize)
+ return false;
+ _reps[i] = rep;
+ }
+
+ return true;
+ }
+
+ _numAlignBits = 64;
+
+ if (blockType == kBlockType_Aligned)
+ {
+ Byte levels[kAlignTableSize];
+ _numAlignBits = kNumAlignBits;
+ for (unsigned i = 0; i < kAlignTableSize; i++)
+ levels[i] = (Byte)ReadBits(kNumAlignLevelBits);
+ RIF(_alignDecoder.Build(levels))
+ }
+ }
+
+ RIF(ReadTable(_mainLevels, 256))
+ RIF(ReadTable(_mainLevels + 256, _numPosLenSlots))
+ unsigned end = 256 + _numPosLenSlots;
+ memset(_mainLevels + end, 0, kMainTableSize - end);
+ RIF(_mainDecoder.Build(_mainLevels))
+ RIF(ReadTable(_lenLevels, kNumLenSymbols))
+ return _lenDecoder.Build(_lenLevels);
+}
+
+
+HRESULT CDecoder::CodeSpec(UInt32 curSize)
+{
+ if (!_keepHistory || !_isUncompressedBlock)
+ _bitStream.NormalizeBig();
+
+ if (!_keepHistory)
+ {
+ _skipByte = false;
+ _unpackBlockSize = 0;
+
+ memset(_mainLevels, 0, kMainTableSize);
+ memset(_lenLevels, 0, kNumLenSymbols);
+
+ {
+ _x86_translationSize = 12000000;
+ if (!_wimMode)
+ {
+ _x86_translationSize = 0;
+ if (ReadBits(1) != 0)
+ {
+ UInt32 v = ReadBits(16) << 16;
+ v |= ReadBits(16);
+ _x86_translationSize = v;
+ }
+ }
+
+ _x86_processedSize = 0;
+ }
+
+ _reps[0] = 1;
+ _reps[1] = 1;
+ _reps[2] = 1;
+ }
+
+ while (curSize > 0)
+ {
+ if (_bitStream.WasExtraReadError_Fast())
+ return S_FALSE;
+
+ if (_unpackBlockSize == 0)
+ {
+ if (!ReadTables())
+ return S_FALSE;
+ continue;
+ }
+
+ UInt32 next = _unpackBlockSize;
+ if (next > curSize)
+ next = curSize;
+
+ if (_isUncompressedBlock)
+ {
+ const size_t rem = _bitStream.GetRem();
+ if (rem == 0)
+ return S_FALSE;
+ if (next > rem)
+ next = (UInt32)rem;
+ _bitStream.CopyTo(_win + _pos, next);
+ _pos += next;
+ curSize -= next;
+ _unpackBlockSize -= next;
+
+ /* we don't know where skipByte can be placed, if it's end of chunk:
+ 1) in current chunk - there are such cab archives, if chunk is last
+ 2) in next chunk - are there such archives ? */
+
+ if (_skipByte
+ && _unpackBlockSize == 0
+ && curSize == 0
+ && _bitStream.IsOneDirectByteLeft())
+ {
+ _skipByte = false;
+ if (_bitStream.DirectReadByte() != 0)
+ return S_FALSE;
+ }
+
+ continue;
+ }
+
+ curSize -= next;
+ _unpackBlockSize -= next;
+
+ Byte *win = _win;
+
+ while (next > 0)
+ {
+ if (_bitStream.WasExtraReadError_Fast())
+ return S_FALSE;
+
+ UInt32 sym = _mainDecoder.Decode(&_bitStream);
+
+ if (sym < 256)
+ {
+ win[_pos++] = (Byte)sym;
+ next--;
+ continue;
+ }
+ {
+ sym -= 256;
+ if (sym >= _numPosLenSlots)
+ return S_FALSE;
+ const UInt32 posSlot = sym / kNumLenSlots;
+ const UInt32 lenSlot = sym % kNumLenSlots;
+ UInt32 len = kMatchMinLen + lenSlot;
+
+ if (lenSlot == kNumLenSlots - 1)
+ {
+ UInt32 lenTemp = _lenDecoder.Decode(&_bitStream);
+ if (lenTemp >= kNumLenSymbols)
+ return S_FALSE;
+ len = kMatchMinLen + kNumLenSlots - 1 + lenTemp;
+ }
+
+ UInt32 dist;
+
+ if (posSlot < kNumReps)
+ {
+ dist = _reps[posSlot];
+ _reps[posSlot] = _reps[0];
+ _reps[0] = dist;
+ }
+ else
+ {
+ unsigned numDirectBits;
+
+ if (posSlot < kNumPowerPosSlots)
+ {
+ numDirectBits = (unsigned)(posSlot >> 1) - 1;
+ dist = ((2 | (posSlot & 1)) << numDirectBits);
+ }
+ else
+ {
+ numDirectBits = kNumLinearPosSlotBits;
+ dist = ((posSlot - 0x22) << kNumLinearPosSlotBits);
+ }
+
+ if (numDirectBits >= _numAlignBits)
+ {
+ dist += (_bitStream.ReadBitsSmall(numDirectBits - kNumAlignBits) << kNumAlignBits);
+ const UInt32 alignTemp = _alignDecoder.Decode(&_bitStream);
+ if (alignTemp >= kAlignTableSize)
+ return S_FALSE;
+ dist += alignTemp;
+ }
+ else
+ dist += _bitStream.ReadBitsBig(numDirectBits);
+
+ dist -= kNumReps - 1;
+ _reps[2] = _reps[1];
+ _reps[1] = _reps[0];
+ _reps[0] = dist;
+ }
+
+ if (len > next)
+ return S_FALSE;
+
+ if (dist > _pos && !_overDict)
+ return S_FALSE;
+
+ Byte *dest = win + _pos;
+ const UInt32 mask = (_winSize - 1);
+ UInt32 srcPos = (_pos - dist) & mask;
+
+ next -= len;
+
+ if (len > _winSize - srcPos)
+ {
+ _pos += len;
+ do
+ {
+ *dest++ = win[srcPos++];
+ srcPos &= mask;
+ }
+ while (--len);
+ }
+ else
+ {
+ const ptrdiff_t src = (ptrdiff_t)srcPos - (ptrdiff_t)_pos;
+ _pos += len;
+ const Byte *lim = dest + len;
+ *(dest) = *(dest + src);
+ dest++;
+ do
+ *(dest) = *(dest + src);
+ while (++dest != lim);
+ }
+ }
+ }
+ }
+
+ if (!_bitStream.WasFinishedOK())
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+HRESULT CDecoder::Code(const Byte *inData, size_t inSize, UInt32 outSize)
+{
+ if (!_keepHistory)
+ {
+ _pos = 0;
+ _overDict = false;
+ }
+ else if (_pos == _winSize)
+ {
+ _pos = 0;
+ _overDict = true;
+ }
+
+ _writePos = _pos;
+ _unpackedData = _win + _pos;
+
+ if (outSize > _winSize - _pos)
+ return S_FALSE;
+
+ PRF(printf("\ninSize = %d", inSize));
+ if ((inSize & 1) != 0)
+ {
+ PRF(printf(" ---------"));
+ }
+
+ if (inSize < 1)
+ return S_FALSE;
+
+ _bitStream.Init(inData, inSize);
+
+ const HRESULT res = CodeSpec(outSize);
+ const HRESULT res2 = Flush();
+ return (res == S_OK ? res2 : res);
+}
+
+
+HRESULT CDecoder::SetParams2(unsigned numDictBits)
+{
+ _numDictBits = numDictBits;
+ if (numDictBits < kNumDictBits_Min || numDictBits > kNumDictBits_Max)
+ return E_INVALIDARG;
+ const unsigned numPosSlots = (numDictBits < 20) ?
+ numDictBits * 2 :
+ 34 + ((unsigned)1 << (numDictBits - 17));
+ _numPosLenSlots = numPosSlots * kNumLenSlots;
+ return S_OK;
+}
+
+
+HRESULT CDecoder::SetParams_and_Alloc(unsigned numDictBits)
+{
+ RINOK(SetParams2(numDictBits))
+
+ const UInt32 newWinSize = (UInt32)1 << numDictBits;
+
+ if (NeedAlloc)
+ {
+ if (!_win || newWinSize != _winSize)
+ {
+ ::MidFree(_win);
+ _winSize = 0;
+ _win = (Byte *)::MidAlloc(newWinSize);
+ if (!_win)
+ return E_OUTOFMEMORY;
+ }
+ }
+
+ _winSize = (UInt32)newWinSize;
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Compress/LzxDecoder.h b/CPP/7zip/Compress/LzxDecoder.h
new file mode 100644
index 0000000..ab114e5
--- /dev/null
+++ b/CPP/7zip/Compress/LzxDecoder.h
@@ -0,0 +1,243 @@
+// LzxDecoder.h
+
+#ifndef ZIP7_INC_LZX_DECODER_H
+#define ZIP7_INC_LZX_DECODER_H
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/MyCom.h"
+
+#include "HuffmanDecoder.h"
+#include "Lzx.h"
+
+namespace NCompress {
+namespace NLzx {
+
+class CBitDecoder
+{
+ unsigned _bitPos;
+ UInt32 _value;
+ const Byte *_buf;
+ const Byte *_bufLim;
+ UInt32 _extraSize;
+public:
+
+ void Init(const Byte *data, size_t size)
+ {
+ _buf = data;
+ _bufLim = data + size - 1;
+ _bitPos = 0;
+ _extraSize = 0;
+ }
+
+ size_t GetRem() const { return (size_t)(_bufLim + 1 - _buf); }
+ bool WasExtraReadError_Fast() const { return _extraSize > 4; }
+
+ bool WasFinishedOK() const
+ {
+ if (_buf != _bufLim + 1)
+ return false;
+ if ((_bitPos >> 4) * 2 != _extraSize)
+ return false;
+ unsigned numBits = _bitPos & 15;
+ return (((_value >> (_bitPos - numBits)) & (((UInt32)1 << numBits) - 1)) == 0);
+ }
+
+ void NormalizeSmall()
+ {
+ if (_bitPos <= 16)
+ {
+ UInt32 val;
+ if (_buf >= _bufLim)
+ {
+ val = 0xFFFF;
+ _extraSize += 2;
+ }
+ else
+ {
+ val = GetUi16(_buf);
+ _buf += 2;
+ }
+ _value = (_value << 16) | val;
+ _bitPos += 16;
+ }
+ }
+
+ void NormalizeBig()
+ {
+ if (_bitPos <= 16)
+ {
+ {
+ UInt32 val;
+ if (_buf >= _bufLim)
+ {
+ val = 0xFFFF;
+ _extraSize += 2;
+ }
+ else
+ {
+ val = GetUi16(_buf);
+ _buf += 2;
+ }
+ _value = (_value << 16) | val;
+ _bitPos += 16;
+ }
+ if (_bitPos <= 16)
+ {
+ UInt32 val;
+ if (_buf >= _bufLim)
+ {
+ val = 0xFFFF;
+ _extraSize += 2;
+ }
+ else
+ {
+ val = GetUi16(_buf);
+ _buf += 2;
+ }
+ _value = (_value << 16) | val;
+ _bitPos += 16;
+ }
+ }
+ }
+
+ UInt32 GetValue(unsigned numBits) const
+ {
+ return (_value >> (_bitPos - numBits)) & (((UInt32)1 << numBits) - 1);
+ }
+
+ void MovePos(unsigned numBits)
+ {
+ _bitPos -= numBits;
+ NormalizeSmall();
+ }
+
+ UInt32 ReadBitsSmall(unsigned numBits)
+ {
+ _bitPos -= numBits;
+ UInt32 val = (_value >> _bitPos) & (((UInt32)1 << numBits) - 1);
+ NormalizeSmall();
+ return val;
+ }
+
+ UInt32 ReadBitsBig(unsigned numBits)
+ {
+ _bitPos -= numBits;
+ UInt32 val = (_value >> _bitPos) & (((UInt32)1 << numBits) - 1);
+ NormalizeBig();
+ return val;
+ }
+
+ bool PrepareUncompressed()
+ {
+ if (_extraSize != 0)
+ return false;
+ unsigned numBits = _bitPos - 16;
+ if (((_value >> 16) & (((UInt32)1 << numBits) - 1)) != 0)
+ return false;
+ _buf -= 2;
+ _bitPos = 0;
+ return true;
+ }
+
+ UInt32 ReadUInt32()
+ {
+ UInt32 v = GetUi32(_buf);
+ _buf += 4;
+ return v;
+ }
+
+ void CopyTo(Byte *dest, size_t size)
+ {
+ memcpy(dest, _buf, size);
+ _buf += size;
+ }
+
+ bool IsOneDirectByteLeft() const { return _buf == _bufLim && _extraSize == 0; }
+
+ Byte DirectReadByte()
+ {
+ if (_buf > _bufLim)
+ {
+ _extraSize++;
+ return 0xFF;
+ }
+ return *_buf++;
+ }
+};
+
+
+Z7_CLASS_IMP_COM_0(
+ CDecoder
+)
+ CBitDecoder _bitStream;
+ Byte *_win;
+ UInt32 _pos;
+ UInt32 _winSize;
+
+ bool _overDict;
+ bool _isUncompressedBlock;
+ bool _skipByte;
+ unsigned _numAlignBits;
+
+ UInt32 _reps[kNumReps];
+ UInt32 _numPosLenSlots;
+ UInt32 _unpackBlockSize;
+
+public:
+ bool KeepHistoryForNext;
+ bool NeedAlloc;
+private:
+ bool _keepHistory;
+ bool _wimMode;
+ unsigned _numDictBits;
+ UInt32 _writePos;
+
+ Byte *_x86_buf;
+ UInt32 _x86_translationSize;
+ UInt32 _x86_processedSize;
+
+ Byte *_unpackedData;
+
+ NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> _mainDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kNumLenSymbols> _lenDecoder;
+ NHuffman::CDecoder7b<kAlignTableSize> _alignDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize, 7> _levelDecoder;
+
+ Byte _mainLevels[kMainTableSize];
+ Byte _lenLevels[kNumLenSymbols];
+
+ HRESULT Flush();
+
+ UInt32 ReadBits(unsigned numBits);
+ bool ReadTable(Byte *levels, unsigned numSymbols);
+ bool ReadTables();
+
+ HRESULT CodeSpec(UInt32 size);
+ HRESULT SetParams2(unsigned numDictBits);
+public:
+ CDecoder(bool wimMode = false);
+ ~CDecoder();
+
+ HRESULT SetExternalWindow(Byte *win, unsigned numDictBits)
+ {
+ NeedAlloc = false;
+ _win = win;
+ _winSize = (UInt32)1 << numDictBits;
+ return SetParams2(numDictBits);
+ }
+
+ void SetKeepHistory(bool keepHistory) { _keepHistory = keepHistory; }
+
+ HRESULT SetParams_and_Alloc(unsigned numDictBits);
+
+ HRESULT Code(const Byte *inData, size_t inSize, UInt32 outSize);
+
+ bool WasBlockFinished() const { return _unpackBlockSize == 0; }
+ const Byte *GetUnpackData() const { return _unpackedData; }
+ UInt32 GetUnpackSize() const { return _pos - _writePos; }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Mtf8.h b/CPP/7zip/Compress/Mtf8.h
new file mode 100644
index 0000000..1b44d00
--- /dev/null
+++ b/CPP/7zip/Compress/Mtf8.h
@@ -0,0 +1,212 @@
+// Mtf8.h
+
+#ifndef ZIP7_INC_COMPRESS_MTF8_H
+#define ZIP7_INC_COMPRESS_MTF8_H
+
+#include "../../../C/CpuArch.h"
+
+namespace NCompress {
+
+struct CMtf8Encoder
+{
+ Byte Buf[256];
+
+ unsigned FindAndMove(Byte v) throw()
+ {
+ size_t pos;
+ for (pos = 0; Buf[pos] != v; pos++);
+ const unsigned resPos = (unsigned)pos;
+ for (; pos >= 8; pos -= 8)
+ {
+ Buf[pos] = Buf[pos - 1];
+ Buf[pos - 1] = Buf[pos - 2];
+ Buf[pos - 2] = Buf[pos - 3];
+ Buf[pos - 3] = Buf[pos - 4];
+ Buf[pos - 4] = Buf[pos - 5];
+ Buf[pos - 5] = Buf[pos - 6];
+ Buf[pos - 6] = Buf[pos - 7];
+ Buf[pos - 7] = Buf[pos - 8];
+ }
+ for (; pos != 0; pos--)
+ Buf[pos] = Buf[pos - 1];
+ Buf[0] = v;
+ return resPos;
+ }
+};
+
+/*
+struct CMtf8Decoder
+{
+ Byte Buf[256];
+
+ void StartInit() { memset(Buf, 0, sizeof(Buf)); }
+ void Add(unsigned pos, Byte val) { Buf[pos] = val; }
+ Byte GetHead() const { return Buf[0]; }
+ Byte GetAndMove(unsigned pos)
+ {
+ Byte res = Buf[pos];
+ for (; pos >= 8; pos -= 8)
+ {
+ Buf[pos] = Buf[pos - 1];
+ Buf[pos - 1] = Buf[pos - 2];
+ Buf[pos - 2] = Buf[pos - 3];
+ Buf[pos - 3] = Buf[pos - 4];
+ Buf[pos - 4] = Buf[pos - 5];
+ Buf[pos - 5] = Buf[pos - 6];
+ Buf[pos - 6] = Buf[pos - 7];
+ Buf[pos - 7] = Buf[pos - 8];
+ }
+ for (; pos > 0; pos--)
+ Buf[pos] = Buf[pos - 1];
+ Buf[0] = res;
+ return res;
+ }
+};
+*/
+
+#ifdef MY_CPU_64BIT
+ typedef UInt64 CMtfVar;
+ #define Z7_MTF_MOVS 3
+#else
+ typedef UInt32 CMtfVar;
+ #define Z7_MTF_MOVS 2
+#endif
+
+#define Z7_MTF_MASK ((1 << Z7_MTF_MOVS) - 1)
+
+
+struct CMtf8Decoder
+{
+ CMtfVar Buf[256 >> Z7_MTF_MOVS];
+
+ void StartInit() { memset(Buf, 0, sizeof(Buf)); }
+ void Add(unsigned pos, Byte val) { Buf[pos >> Z7_MTF_MOVS] |= ((CMtfVar)val << ((pos & Z7_MTF_MASK) << 3)); }
+ Byte GetHead() const { return (Byte)Buf[0]; }
+
+ Z7_FORCE_INLINE
+ Byte GetAndMove(unsigned pos) throw()
+ {
+ const UInt32 lim = ((UInt32)pos >> Z7_MTF_MOVS);
+ pos = (pos & Z7_MTF_MASK) << 3;
+ CMtfVar prev = (Buf[lim] >> pos) & 0xFF;
+
+ UInt32 i = 0;
+
+
+ /*
+ if ((lim & 1) != 0)
+ {
+ CMtfVar next = Buf[0];
+ Buf[0] = (next << 8) | prev;
+ prev = (next >> (Z7_MTF_MASK << 3));
+ i = 1;
+ lim -= 1;
+ }
+ for (; i < lim; i += 2)
+ {
+ CMtfVar n0 = Buf[i];
+ CMtfVar n1 = Buf[i + 1];
+ Buf[i ] = (n0 << 8) | prev;
+ Buf[i + 1] = (n1 << 8) | (n0 >> (Z7_MTF_MASK << 3));
+ prev = (n1 >> (Z7_MTF_MASK << 3));
+ }
+ */
+
+ for (; i < lim; i++)
+ {
+ const CMtfVar n0 = Buf[i];
+ Buf[i ] = (n0 << 8) | prev;
+ prev = (n0 >> (Z7_MTF_MASK << 3));
+ }
+
+
+ const CMtfVar next = Buf[i];
+ const CMtfVar mask = (((CMtfVar)0x100 << pos) - 1);
+ Buf[i] = (next & ~mask) | (((next << 8) | prev) & mask);
+ return (Byte)Buf[0];
+ }
+};
+
+/*
+const int kSmallSize = 64;
+class CMtf8Decoder
+{
+ Byte SmallBuffer[kSmallSize];
+ int SmallSize;
+ int Counts[16];
+ int Size;
+public:
+ Byte Buf[256];
+
+ Byte GetHead() const
+ {
+ if (SmallSize > 0)
+ return SmallBuffer[kSmallSize - SmallSize];
+ return Buf[0];
+ }
+
+ void Init(int size)
+ {
+ Size = size;
+ SmallSize = 0;
+ for (int i = 0; i < 16; i++)
+ {
+ Counts[i] = ((size >= 16) ? 16 : size);
+ size -= Counts[i];
+ }
+ }
+
+ void Add(unsigned pos, Byte val)
+ {
+ Buf[pos] = val;
+ }
+
+ Byte GetAndMove(int pos)
+ {
+ if (pos < SmallSize)
+ {
+ Byte *p = SmallBuffer + kSmallSize - SmallSize;
+ Byte res = p[pos];
+ for (; pos > 0; pos--)
+ p[pos] = p[pos - 1];
+ SmallBuffer[kSmallSize - SmallSize] = res;
+ return res;
+ }
+ if (SmallSize == kSmallSize)
+ {
+ int i = Size - 1;
+ int g = 16;
+ do
+ {
+ g--;
+ int offset = (g << 4);
+ for (int t = Counts[g] - 1; t >= 0; t--, i--)
+ Buf[i] = Buf[offset + t];
+ }
+ while (g != 0);
+
+ for (i = kSmallSize - 1; i >= 0; i--)
+ Buf[i] = SmallBuffer[i];
+ Init(Size);
+ }
+ pos -= SmallSize;
+ int g;
+ for (g = 0; pos >= Counts[g]; g++)
+ pos -= Counts[g];
+ int offset = (g << 4);
+ Byte res = Buf[offset + pos];
+ for (pos; pos < 16 - 1; pos++)
+ Buf[offset + pos] = Buf[offset + pos + 1];
+
+ SmallSize++;
+ SmallBuffer[kSmallSize - SmallSize] = res;
+
+ Counts[g]--;
+ return res;
+ }
+};
+*/
+
+}
+
+#endif
diff --git a/CPP/7zip/Compress/PpmdDecoder.cpp b/CPP/7zip/Compress/PpmdDecoder.cpp
index 4820c0a..1238df6 100644
--- a/CPP/7zip/Compress/PpmdDecoder.cpp
+++ b/CPP/7zip/Compress/PpmdDecoder.cpp
@@ -1,170 +1,218 @@
-// PpmdDecoder.cpp
-// 2009-03-11 : Igor Pavlov : Public domain
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-#include "../../../C/CpuArch.h"
-
-#include "../Common/StreamUtils.h"
-
-#include "PpmdDecoder.h"
-
-namespace NCompress {
-namespace NPpmd {
-
-static const UInt32 kBufSize = (1 << 20);
-
-enum
-{
- kStatus_NeedInit,
- kStatus_Normal,
- kStatus_Finished,
- kStatus_Error
-};
-
-CDecoder::~CDecoder()
-{
- ::MidFree(_outBuf);
- Ppmd7_Free(&_ppmd, &g_BigAlloc);
-}
-
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
-{
- if (size < 5)
- return E_INVALIDARG;
- _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 E_NOTIMPL;
- if (!_inStream.Alloc(1 << 20))
- return E_OUTOFMEMORY;
- if (!Ppmd7_Alloc(&_ppmd, memSize, &g_BigAlloc))
- return E_OUTOFMEMORY;
- return S_OK;
-}
-
-HRESULT CDecoder::CodeSpec(Byte *memStream, UInt32 size)
-{
- switch (_status)
- {
- case kStatus_Finished: return S_OK;
- case kStatus_Error: return S_FALSE;
- case kStatus_NeedInit:
- _inStream.Init();
- if (!Ppmd7z_RangeDec_Init(&_rangeDec))
- {
- _status = kStatus_Error;
- return S_FALSE;
- }
- _status = kStatus_Normal;
- Ppmd7_Init(&_ppmd, _order);
- break;
- }
- if (_outSizeDefined)
- {
- const UInt64 rem = _outSize - _processedSize;
- if (size > rem)
- size = (UInt32)rem;
- }
-
- UInt32 i;
- int sym = 0;
- for (i = 0; i != size; i++)
- {
- sym = Ppmd7_DecodeSymbol(&_ppmd, &_rangeDec.vt);
- if (_inStream.Extra || sym < 0)
- break;
- memStream[i] = (Byte)sym;
- }
-
- _processedSize += i;
- if (_inStream.Extra)
- {
- _status = kStatus_Error;
- return _inStream.Res;
- }
- if (sym < 0)
- _status = (sym < -1) ? kStatus_Error : kStatus_Finished;
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
-{
- if (!_outBuf)
- {
- _outBuf = (Byte *)::MidAlloc(kBufSize);
- if (!_outBuf)
- return E_OUTOFMEMORY;
- }
-
- _inStream.Stream = inStream;
- SetOutStreamSize(outSize);
-
- do
- {
- const UInt64 startPos = _processedSize;
- HRESULT res = CodeSpec(_outBuf, kBufSize);
- size_t processed = (size_t)(_processedSize - startPos);
- RINOK(WriteStream(outStream, _outBuf, processed));
- RINOK(res);
- if (_status == kStatus_Finished)
- break;
- if (progress)
- {
- UInt64 inSize = _inStream.GetProcessed();
- RINOK(progress->SetRatioInfo(&inSize, &_processedSize));
- }
- }
- while (!_outSizeDefined || _processedSize < _outSize);
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
-{
- _outSizeDefined = (outSize != NULL);
- if (_outSizeDefined)
- _outSize = *outSize;
- _processedSize = 0;
- _status = kStatus_NeedInit;
- return S_OK;
-}
-
-
-STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
-{
- *value = _inStream.GetProcessed();
- return S_OK;
-}
-
-#ifndef NO_READ_FROM_CODER
-
-STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)
-{
- InSeqStream = inStream;
- _inStream.Stream = inStream;
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::ReleaseInStream()
-{
- InSeqStream.Release();
- return S_OK;
-}
-
-STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- const UInt64 startPos = _processedSize;
- HRESULT res = CodeSpec((Byte *)data, size);
- if (processedSize)
- *processedSize = (UInt32)(_processedSize - startPos);
- return res;
-}
-
-#endif
-
-}}
+// PpmdDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "PpmdDecoder.h"
+
+namespace NCompress {
+namespace NPpmd {
+
+static const UInt32 kBufSize = (1 << 16);
+
+enum
+{
+ kStatus_NeedInit,
+ kStatus_Normal,
+ kStatus_Finished_With_Mark,
+ kStatus_Error
+};
+
+CDecoder::~CDecoder()
+{
+ ::MidFree(_outBuf);
+ Ppmd7_Free(&_ppmd, &g_BigAlloc);
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size))
+{
+ if (size < 5)
+ return E_INVALIDARG;
+ _order = props[0];
+ const 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 E_NOTIMPL;
+ if (!_inStream.Alloc(1 << 20))
+ return E_OUTOFMEMORY;
+ if (!Ppmd7_Alloc(&_ppmd, memSize, &g_BigAlloc))
+ return E_OUTOFMEMORY;
+ return S_OK;
+}
+
+#define MY_rangeDec _ppmd.rc.dec
+
+#define CHECK_EXTRA_ERROR \
+ if (_inStream.Extra) { \
+ _status = kStatus_Error; \
+ return (_res = (_inStream.Res != SZ_OK ? _inStream.Res: S_FALSE)); }
+
+
+HRESULT CDecoder::CodeSpec(Byte *memStream, UInt32 size)
+{
+ if (_res != S_OK)
+ return _res;
+
+ switch (_status)
+ {
+ case kStatus_Finished_With_Mark: return S_OK;
+ case kStatus_Error: return S_FALSE;
+ case kStatus_NeedInit:
+ _inStream.Init();
+ if (!Ppmd7z_RangeDec_Init(&MY_rangeDec))
+ {
+ _status = kStatus_Error;
+ return (_res = S_FALSE);
+ }
+ CHECK_EXTRA_ERROR
+ _status = kStatus_Normal;
+ Ppmd7_Init(&_ppmd, _order);
+ break;
+ }
+
+ if (_outSizeDefined)
+ {
+ const UInt64 rem = _outSize - _processedSize;
+ if (size > rem)
+ size = (UInt32)rem;
+ }
+
+ int sym = 0;
+ {
+ Byte *buf = memStream;
+ const Byte *lim = buf + size;
+ for (; buf != lim; buf++)
+ {
+ sym = Ppmd7z_DecodeSymbol(&_ppmd);
+ if (_inStream.Extra || sym < 0)
+ break;
+ *buf = (Byte)sym;
+ }
+ /*
+ buf = Ppmd7z_DecodeSymbols(&_ppmd, buf, lim);
+ sym = _ppmd.LastSymbol;
+ */
+ _processedSize += (size_t)(buf - memStream);
+ }
+
+ CHECK_EXTRA_ERROR
+
+ if (sym >= 0)
+ {
+ if (!FinishStream
+ || !_outSizeDefined
+ || _outSize != _processedSize
+ || MY_rangeDec.Code == 0)
+ return S_OK;
+ /*
+ // We can decode additional End Marker here:
+ sym = Ppmd7z_DecodeSymbol(&_ppmd);
+ CHECK_EXTRA_ERROR
+ */
+ }
+
+ if (sym != PPMD7_SYM_END || MY_rangeDec.Code != 0)
+ {
+ _status = kStatus_Error;
+ return (_res = S_FALSE);
+ }
+
+ _status = kStatus_Finished_With_Mark;
+ return S_OK;
+}
+
+
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ if (!_outBuf)
+ {
+ _outBuf = (Byte *)::MidAlloc(kBufSize);
+ if (!_outBuf)
+ return E_OUTOFMEMORY;
+ }
+
+ _inStream.Stream = inStream;
+ SetOutStreamSize(outSize);
+
+ do
+ {
+ const UInt64 startPos = _processedSize;
+ const HRESULT res = CodeSpec(_outBuf, kBufSize);
+ const size_t processed = (size_t)(_processedSize - startPos);
+ RINOK(WriteStream(outStream, _outBuf, processed))
+ RINOK(res)
+ if (_status == kStatus_Finished_With_Mark)
+ break;
+ if (progress)
+ {
+ const UInt64 inProcessed = _inStream.GetProcessed();
+ RINOK(progress->SetRatioInfo(&inProcessed, &_processedSize))
+ }
+ }
+ while (!_outSizeDefined || _processedSize < _outSize);
+
+ if (FinishStream && inSize && *inSize != _inStream.GetProcessed())
+ return S_FALSE;
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+{
+ _outSizeDefined = (outSize != NULL);
+ if (_outSizeDefined)
+ _outSize = *outSize;
+ _processedSize = 0;
+ _status = kStatus_NeedInit;
+ _res = SZ_OK;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ FinishStream = (finishMode != 0);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = _inStream.GetProcessed();
+ return S_OK;
+}
+
+#ifndef Z7_NO_READ_FROM_CODER
+
+Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
+{
+ InSeqStream = inStream;
+ _inStream.Stream = inStream;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::ReleaseInStream())
+{
+ InSeqStream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ const UInt64 startPos = _processedSize;
+ const HRESULT res = CodeSpec((Byte *)data, size);
+ if (processedSize)
+ *processedSize = (UInt32)(_processedSize - startPos);
+ return res;
+}
+
+#endif
+
+}}
diff --git a/CPP/7zip/Compress/PpmdDecoder.h b/CPP/7zip/Compress/PpmdDecoder.h
index 3c2f493..22e5bd4 100644
--- a/CPP/7zip/Compress/PpmdDecoder.h
+++ b/CPP/7zip/Compress/PpmdDecoder.h
@@ -1,86 +1,87 @@
-// PpmdDecoder.h
-// 2009-03-11 : Igor Pavlov : Public domain
-
-#ifndef __COMPRESS_PPMD_DECODER_H
-#define __COMPRESS_PPMD_DECODER_H
-
-#include "../../../C/Ppmd7.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../Common/CWrappers.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NPpmd {
-
-class CDecoder :
- public ICompressCoder,
- public ICompressSetDecoderProperties2,
- public ICompressGetInStreamProcessedSize,
- #ifndef NO_READ_FROM_CODER
- public ICompressSetInStream,
- public ICompressSetOutStreamSize,
- public ISequentialInStream,
- #endif
- public CMyUnknownImp
-{
- Byte *_outBuf;
- CPpmd7z_RangeDec _rangeDec;
- CByteInBufWrap _inStream;
- CPpmd7 _ppmd;
-
- Byte _order;
- bool _outSizeDefined;
- int _status;
- UInt64 _outSize;
- UInt64 _processedSize;
-
- HRESULT CodeSpec(Byte *memStream, UInt32 size);
-
-public:
-
- #ifndef NO_READ_FROM_CODER
- CMyComPtr<ISequentialInStream> InSeqStream;
- #endif
-
- MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
- MY_QUERYINTERFACE_ENTRY(ICompressSetDecoderProperties2)
- // MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
- MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
- #ifndef NO_READ_FROM_CODER
- MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
- MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
- MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
-
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
-
- #ifndef NO_READ_FROM_CODER
- STDMETHOD(SetInStream)(ISequentialInStream *inStream);
- STDMETHOD(ReleaseInStream)();
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
- #endif
-
- CDecoder(): _outBuf(NULL), _outSizeDefined(false)
- {
- Ppmd7z_RangeDec_CreateVTable(&_rangeDec);
- _rangeDec.Stream = &_inStream.vt;
- Ppmd7_Construct(&_ppmd);
- }
-
- ~CDecoder();
-};
-
-}}
-
-#endif
+// PpmdDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_PPMD_DECODER_H
+#define ZIP7_INC_COMPRESS_PPMD_DECODER_H
+
+#include "../../../C/Ppmd7.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/CWrappers.h"
+
+namespace NCompress {
+namespace NPpmd {
+
+class CDecoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetDecoderProperties2,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize,
+ #ifndef Z7_NO_READ_FROM_CODER
+ public ICompressSetInStream,
+ public ICompressSetOutStreamSize,
+ public ISequentialInStream,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetDecoderProperties2)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_COM_QI_ENTRY(ICompressSetInStream)
+ Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
+ Z7_COM_QI_ENTRY(ISequentialInStream)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ #ifndef Z7_NO_READ_FROM_CODER
+ Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
+ Z7_IFACE_COM7_IMP(ICompressSetInStream)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+ #else
+ Z7_COM7F_IMF(SetOutStreamSize(const UInt64 *outSize));
+ #endif
+
+ Byte *_outBuf;
+ CByteInBufWrap _inStream;
+ CPpmd7 _ppmd;
+
+ Byte _order;
+ bool FinishStream;
+ bool _outSizeDefined;
+ HRESULT _res;
+ int _status;
+ UInt64 _outSize;
+ UInt64 _processedSize;
+
+ HRESULT CodeSpec(Byte *memStream, UInt32 size);
+
+public:
+
+ #ifndef Z7_NO_READ_FROM_CODER
+ CMyComPtr<ISequentialInStream> InSeqStream;
+ #endif
+
+ CDecoder():
+ _outBuf(NULL),
+ FinishStream(false),
+ _outSizeDefined(false)
+ {
+ Ppmd7_Construct(&_ppmd);
+ _ppmd.rc.dec.Stream = &_inStream.vt;
+ }
+
+ ~CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/PpmdEncoder.cpp b/CPP/7zip/Compress/PpmdEncoder.cpp
index 0aef701..2dfca6d 100644
--- a/CPP/7zip/Compress/PpmdEncoder.cpp
+++ b/CPP/7zip/Compress/PpmdEncoder.cpp
@@ -1,152 +1,193 @@
-// PpmdEncoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-#include "../../../C/CpuArch.h"
-
-#include "../Common/StreamUtils.h"
-
-#include "PpmdEncoder.h"
-
-namespace NCompress {
-namespace NPpmd {
-
-static const UInt32 kBufSize = (1 << 20);
-
-static const Byte kOrders[10] = { 3, 4, 4, 5, 5, 6, 8, 16, 24, 32 };
-
-void CEncProps::Normalize(int level)
-{
- if (level < 0) level = 5;
- if (level > 9) level = 9;
- if (MemSize == (UInt32)(Int32)-1)
- MemSize = level >= 9 ? ((UInt32)192 << 20) : ((UInt32)1 << (level + 19));
- const unsigned kMult = 16;
- if (MemSize / kMult > ReduceSize)
- {
- for (unsigned i = 16; i <= 31; i++)
- {
- UInt32 m = (UInt32)1 << i;
- if (ReduceSize <= m / kMult)
- {
- if (MemSize > m)
- MemSize = m;
- break;
- }
- }
- }
- if (Order == -1) Order = kOrders[(unsigned)level];
-}
-
-CEncoder::CEncoder():
- _inBuf(NULL)
-{
- _props.Normalize(-1);
- _rangeEnc.Stream = &_outStream.vt;
- Ppmd7_Construct(&_ppmd);
-}
-
-CEncoder::~CEncoder()
-{
- ::MidFree(_inBuf);
- Ppmd7_Free(&_ppmd, &g_BigAlloc);
-}
-
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
-{
- int level = -1;
- CEncProps props;
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- PROPID propID = propIDs[i];
- if (propID > NCoderPropID::kReduceSize)
- continue;
- if (propID == NCoderPropID::kReduceSize)
- {
- if (prop.vt == VT_UI8 && prop.uhVal.QuadPart < (UInt32)(Int32)-1)
- props.ReduceSize = (UInt32)prop.uhVal.QuadPart;
- continue;
- }
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- UInt32 v = (UInt32)prop.ulVal;
- switch (propID)
- {
- case NCoderPropID::kUsedMemorySize:
- if (v < (1 << 16) || v > PPMD7_MAX_MEM_SIZE || (v & 3) != 0)
- return E_INVALIDARG;
- props.MemSize = v;
- break;
- case NCoderPropID::kOrder:
- if (v < 2 || v > 32)
- return E_INVALIDARG;
- props.Order = (Byte)v;
- break;
- case NCoderPropID::kNumThreads: break;
- case NCoderPropID::kLevel: level = (int)v; break;
- default: return E_INVALIDARG;
- }
- }
- props.Normalize(level);
- _props = props;
- return S_OK;
-}
-
-STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
-{
- const UInt32 kPropSize = 5;
- Byte props[kPropSize];
- props[0] = (Byte)_props.Order;
- SetUi32(props + 1, _props.MemSize);
- return WriteStream(outStream, props, kPropSize);
-}
-
-HRESULT CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
-{
- if (!_inBuf)
- {
- _inBuf = (Byte *)::MidAlloc(kBufSize);
- if (!_inBuf)
- return E_OUTOFMEMORY;
- }
- if (!_outStream.Alloc(1 << 20))
- return E_OUTOFMEMORY;
- if (!Ppmd7_Alloc(&_ppmd, _props.MemSize, &g_BigAlloc))
- return E_OUTOFMEMORY;
-
- _outStream.Stream = outStream;
- _outStream.Init();
-
- Ppmd7z_RangeEnc_Init(&_rangeEnc);
- Ppmd7_Init(&_ppmd, _props.Order);
-
- UInt64 processed = 0;
- for (;;)
- {
- UInt32 size;
- RINOK(inStream->Read(_inBuf, kBufSize, &size));
- if (size == 0)
- {
- // We don't write EndMark in PPMD-7z.
- // Ppmd7_EncodeSymbol(&_ppmd, &_rangeEnc, -1);
- Ppmd7z_RangeEnc_FlushData(&_rangeEnc);
- return _outStream.Flush();
- }
- for (UInt32 i = 0; i < size; i++)
- {
- Ppmd7_EncodeSymbol(&_ppmd, &_rangeEnc, _inBuf[i]);
- RINOK(_outStream.Res);
- }
- processed += size;
- if (progress)
- {
- UInt64 outSize = _outStream.GetProcessed();
- RINOK(progress->SetRatioInfo(&processed, &outSize));
- }
- }
-}
-
-}}
+// PpmdEncoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "PpmdEncoder.h"
+
+namespace NCompress {
+namespace NPpmd {
+
+static const UInt32 kBufSize = (1 << 20);
+
+static const Byte kOrders[10] = { 3, 4, 4, 5, 5, 6, 8, 16, 24, 32 };
+
+void CEncProps::Normalize(int level)
+{
+ if (level < 0) level = 5;
+ if (level > 9) level = 9;
+ if (MemSize == (UInt32)(Int32)-1)
+ MemSize = (UInt32)1 << (level + 19);
+ const unsigned kMult = 16;
+ if (MemSize / kMult > ReduceSize)
+ {
+ for (unsigned i = 16; i < 32; i++)
+ {
+ UInt32 m = (UInt32)1 << i;
+ if (ReduceSize <= m / kMult)
+ {
+ if (MemSize > m)
+ MemSize = m;
+ break;
+ }
+ }
+ }
+ if (Order == -1) Order = kOrders[(unsigned)level];
+}
+
+CEncoder::CEncoder():
+ _inBuf(NULL)
+{
+ _props.Normalize(-1);
+ Ppmd7_Construct(&_ppmd);
+ _ppmd.rc.enc.Stream = &_outStream.vt;
+}
+
+CEncoder::~CEncoder()
+{
+ ::MidFree(_inBuf);
+ Ppmd7_Free(&_ppmd, &g_BigAlloc);
+}
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ int level = -1;
+ CEncProps props;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ const PROPID propID = propIDs[i];
+ if (propID > NCoderPropID::kReduceSize)
+ continue;
+ if (propID == NCoderPropID::kReduceSize)
+ {
+ if (prop.vt == VT_UI8 && prop.uhVal.QuadPart < (UInt32)(Int32)-1)
+ props.ReduceSize = (UInt32)prop.uhVal.QuadPart;
+ continue;
+ }
+
+ if (propID == NCoderPropID::kUsedMemorySize)
+ {
+ // here we have selected (4 GiB - 1 KiB) as replacement for (4 GiB) MEM_SIZE.
+ const UInt32 kPpmd_Default_4g = (UInt32)0 - ((UInt32)1 << 10);
+ UInt32 v;
+ if (prop.vt == VT_UI8)
+ {
+ // 21.03 : we support 64-bit values (for 4 GiB value)
+ const UInt64 v64 = prop.uhVal.QuadPart;
+ if (v64 > ((UInt64)1 << 32))
+ return E_INVALIDARG;
+ if (v64 == ((UInt64)1 << 32))
+ v = kPpmd_Default_4g;
+ else
+ v = (UInt32)v64;
+ }
+ else if (prop.vt == VT_UI4)
+ v = (UInt32)prop.ulVal;
+ else
+ return E_INVALIDARG;
+ if (v > PPMD7_MAX_MEM_SIZE)
+ v = kPpmd_Default_4g;
+
+ /* here we restrict MEM_SIZE for Encoder.
+ It's for better performance of encoding and decoding.
+ The Decoder still supports more MEM_SIZE values. */
+ if (v < ((UInt32)1 << 16) || (v & 3) != 0)
+ return E_INVALIDARG;
+ // if (v < PPMD7_MIN_MEM_SIZE) return E_INVALIDARG; // (1 << 11)
+ /*
+ Supported MEM_SIZE range :
+ [ (1 << 11) , 0xFFFFFFFF - 12 * 3 ] - current 7-Zip's Ppmd7 constants
+ [ 1824 , 0xFFFFFFFF ] - real limits of Ppmd7 code
+ */
+ props.MemSize = v;
+ continue;
+ }
+
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ const UInt32 v = (UInt32)prop.ulVal;
+ switch (propID)
+ {
+ case NCoderPropID::kOrder:
+ if (v < 2 || v > 32)
+ return E_INVALIDARG;
+ props.Order = (Byte)v;
+ break;
+ case NCoderPropID::kNumThreads: break;
+ case NCoderPropID::kLevel: level = (int)v; break;
+ default: return E_INVALIDARG;
+ }
+ }
+ props.Normalize(level);
+ _props = props;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+{
+ const UInt32 kPropSize = 5;
+ Byte props[kPropSize];
+ props[0] = (Byte)_props.Order;
+ SetUi32(props + 1, _props.MemSize)
+ return WriteStream(outStream, props, kPropSize);
+}
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+{
+ if (!_inBuf)
+ {
+ _inBuf = (Byte *)::MidAlloc(kBufSize);
+ if (!_inBuf)
+ return E_OUTOFMEMORY;
+ }
+ if (!_outStream.Alloc(1 << 20))
+ return E_OUTOFMEMORY;
+ if (!Ppmd7_Alloc(&_ppmd, _props.MemSize, &g_BigAlloc))
+ return E_OUTOFMEMORY;
+
+ _outStream.Stream = outStream;
+ _outStream.Init();
+
+ Ppmd7z_Init_RangeEnc(&_ppmd);
+ Ppmd7_Init(&_ppmd, (unsigned)_props.Order);
+
+ UInt64 processed = 0;
+ for (;;)
+ {
+ UInt32 size;
+ RINOK(inStream->Read(_inBuf, kBufSize, &size))
+ if (size == 0)
+ {
+ // We don't write EndMark in PPMD-7z.
+ // Ppmd7z_EncodeSymbol(&_ppmd, -1);
+ Ppmd7z_Flush_RangeEnc(&_ppmd);
+ return _outStream.Flush();
+ }
+ const Byte *buf = _inBuf;
+ const Byte *lim = buf + size;
+ /*
+ for (; buf < lim; buf++)
+ {
+ Ppmd7z_EncodeSymbol(&_ppmd, *buf);
+ RINOK(_outStream.Res);
+ }
+ */
+
+ Ppmd7z_EncodeSymbols(&_ppmd, buf, lim);
+ RINOK(_outStream.Res)
+
+ processed += size;
+ if (progress)
+ {
+ const UInt64 outSize = _outStream.GetProcessed();
+ RINOK(progress->SetRatioInfo(&processed, &outSize))
+ }
+ }
+}
+
+}}
diff --git a/CPP/7zip/Compress/PpmdEncoder.h b/CPP/7zip/Compress/PpmdEncoder.h
index cdb0352..057cccb 100644
--- a/CPP/7zip/Compress/PpmdEncoder.h
+++ b/CPP/7zip/Compress/PpmdEncoder.h
@@ -1,58 +1,49 @@
-// PpmdEncoder.h
-
-#ifndef __COMPRESS_PPMD_ENCODER_H
-#define __COMPRESS_PPMD_ENCODER_H
-
-#include "../../../C/Ppmd7.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-#include "../Common/CWrappers.h"
-
-namespace NCompress {
-namespace NPpmd {
-
-struct CEncProps
-{
- UInt32 MemSize;
- UInt32 ReduceSize;
- int Order;
-
- CEncProps()
- {
- MemSize = (UInt32)(Int32)-1;
- ReduceSize = (UInt32)(Int32)-1;
- Order = -1;
- }
- void Normalize(int level);
-};
-
-class CEncoder :
- public ICompressCoder,
- public ICompressSetCoderProperties,
- public ICompressWriteCoderProperties,
- public CMyUnknownImp
-{
- Byte *_inBuf;
- CByteOutBufWrap _outStream;
- CPpmd7z_RangeEnc _rangeEnc;
- CPpmd7 _ppmd;
- CEncProps _props;
-public:
- MY_UNKNOWN_IMP3(
- ICompressCoder,
- ICompressSetCoderProperties,
- ICompressWriteCoderProperties)
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
- CEncoder();
- ~CEncoder();
-};
-
-}}
-
-#endif
+// PpmdEncoder.h
+
+#ifndef ZIP7_INC_COMPRESS_PPMD_ENCODER_H
+#define ZIP7_INC_COMPRESS_PPMD_ENCODER_H
+
+#include "../../../C/Ppmd7.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/CWrappers.h"
+
+namespace NCompress {
+namespace NPpmd {
+
+struct CEncProps
+{
+ UInt32 MemSize;
+ UInt32 ReduceSize;
+ int Order;
+
+ CEncProps()
+ {
+ MemSize = (UInt32)(Int32)-1;
+ ReduceSize = (UInt32)(Int32)-1;
+ Order = -1;
+ }
+ void Normalize(int level);
+};
+
+Z7_CLASS_IMP_COM_3(
+ CEncoder
+ , ICompressCoder
+ , ICompressSetCoderProperties
+ , ICompressWriteCoderProperties
+)
+ Byte *_inBuf;
+ CByteOutBufWrap _outStream;
+ CPpmd7 _ppmd;
+ CEncProps _props;
+public:
+ CEncoder();
+ ~CEncoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/PpmdRegister.cpp b/CPP/7zip/Compress/PpmdRegister.cpp
index c748696..fb5619c 100644
--- a/CPP/7zip/Compress/PpmdRegister.cpp
+++ b/CPP/7zip/Compress/PpmdRegister.cpp
@@ -1,22 +1,22 @@
-// PpmdRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "PpmdDecoder.h"
-
-#ifndef EXTRACT_ONLY
-#include "PpmdEncoder.h"
-#endif
-
-namespace NCompress {
-namespace NPpmd {
-
-REGISTER_CODEC_E(PPMD,
- CDecoder(),
- CEncoder(),
- 0x30401,
- "PPMD")
-
-}}
+// PpmdRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "PpmdDecoder.h"
+
+#ifndef Z7_EXTRACT_ONLY
+#include "PpmdEncoder.h"
+#endif
+
+namespace NCompress {
+namespace NPpmd {
+
+REGISTER_CODEC_E(PPMD,
+ CDecoder(),
+ CEncoder(),
+ 0x30401,
+ "PPMD")
+
+}}
diff --git a/CPP/7zip/Compress/PpmdZip.cpp b/CPP/7zip/Compress/PpmdZip.cpp
new file mode 100644
index 0000000..5039131
--- /dev/null
+++ b/CPP/7zip/Compress/PpmdZip.cpp
@@ -0,0 +1,300 @@
+// PpmdZip.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../Common/RegisterCodec.h"
+#include "../Common/StreamUtils.h"
+
+#include "PpmdZip.h"
+
+namespace NCompress {
+namespace NPpmdZip {
+
+CDecoder::CDecoder(bool fullFileMode):
+ _fullFileMode(fullFileMode)
+{
+ Ppmd8_Construct(&_ppmd);
+ _ppmd.Stream.In = &_inStream.vt;
+}
+
+CDecoder::~CDecoder()
+{
+ Ppmd8_Free(&_ppmd, &g_BigAlloc);
+}
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ // try {
+
+ if (!_outStream.Alloc())
+ return E_OUTOFMEMORY;
+ if (!_inStream.Alloc(1 << 20))
+ return E_OUTOFMEMORY;
+
+ _inStream.Stream = inStream;
+ _inStream.Init();
+
+ {
+ Byte buf[2];
+ for (int i = 0; i < 2; i++)
+ buf[i] = _inStream.ReadByte();
+ if (_inStream.Extra)
+ return S_FALSE;
+
+ const UInt32 val = GetUi16(buf);
+ const unsigned order = (val & 0xF) + 1;
+ const UInt32 mem = ((val >> 4) & 0xFF) + 1;
+ const unsigned restor = (val >> 12);
+ if (order < 2 || restor > 2)
+ return S_FALSE;
+
+ #ifndef PPMD8_FREEZE_SUPPORT
+ if (restor == 2)
+ return E_NOTIMPL;
+ #endif
+
+ if (!Ppmd8_Alloc(&_ppmd, mem << 20, &g_BigAlloc))
+ return E_OUTOFMEMORY;
+
+ if (!Ppmd8_Init_RangeDec(&_ppmd))
+ return S_FALSE;
+ Ppmd8_Init(&_ppmd, order, restor);
+ }
+
+ bool wasFinished = false;
+ UInt64 processedSize = 0;
+
+ for (;;)
+ {
+ size_t size = kBufSize;
+ if (outSize)
+ {
+ const UInt64 rem = *outSize - processedSize;
+ if (size > rem)
+ {
+ size = (size_t)rem;
+ if (size == 0)
+ break;
+ }
+ }
+
+ int sym;
+ Byte *buf = _outStream.Buf;
+ const Byte *lim = buf + size;
+
+ do
+ {
+ sym = Ppmd8_DecodeSymbol(&_ppmd);
+ if (_inStream.Extra || sym < 0)
+ break;
+ *buf++ = (Byte)sym;
+ }
+ while (buf != lim);
+
+ const size_t cur = (size_t)(buf - _outStream.Buf);
+ processedSize += cur;
+
+ RINOK(WriteStream(outStream, _outStream.Buf, cur))
+
+ RINOK(_inStream.Res)
+ if (_inStream.Extra)
+ return S_FALSE;
+
+ if (sym < 0)
+ {
+ if (sym != -1)
+ return S_FALSE;
+ wasFinished = true;
+ break;
+ }
+
+ if (progress)
+ {
+ const UInt64 inProccessed = _inStream.GetProcessed();
+ RINOK(progress->SetRatioInfo(&inProccessed, &processedSize))
+ }
+ }
+
+ RINOK(_inStream.Res)
+
+ if (_fullFileMode)
+ {
+ if (!wasFinished)
+ {
+ const int res = Ppmd8_DecodeSymbol(&_ppmd);
+ RINOK(_inStream.Res)
+ if (_inStream.Extra || res != -1)
+ return S_FALSE;
+ }
+ if (!Ppmd8_RangeDec_IsFinishedOK(&_ppmd))
+ return S_FALSE;
+
+ if (inSize && *inSize != _inStream.GetProcessed())
+ return S_FALSE;
+ }
+
+ return S_OK;
+
+ // } catch (...) { return E_FAIL; }
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ _fullFileMode = (finishMode != 0);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = _inStream.GetProcessed();
+ return S_OK;
+}
+
+
+
+// ---------- Encoder ----------
+
+void CEncProps::Normalize(int level)
+{
+ if (level < 0) level = 5;
+ if (level == 0) level = 1;
+ if (level > 9) level = 9;
+ if (MemSizeMB == (UInt32)(Int32)-1)
+ MemSizeMB = 1 << (level - 1);
+ const unsigned kMult = 16;
+ for (UInt32 m = 1; m < MemSizeMB; m <<= 1)
+ if (ReduceSize <= (m << 20) / kMult)
+ {
+ MemSizeMB = m;
+ break;
+ }
+ if (Order == -1) Order = 3 + level;
+ if (Restor == -1)
+ Restor = level < 7 ?
+ PPMD8_RESTORE_METHOD_RESTART :
+ PPMD8_RESTORE_METHOD_CUT_OFF;
+}
+
+CEncoder::~CEncoder()
+{
+ Ppmd8_Free(&_ppmd, &g_BigAlloc);
+}
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ int level = -1;
+ CEncProps props;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ const PROPID propID = propIDs[i];
+ if (propID > NCoderPropID::kReduceSize)
+ continue;
+ if (propID == NCoderPropID::kReduceSize)
+ {
+ props.ReduceSize = (UInt32)(Int32)-1;
+ if (prop.vt == VT_UI8 && prop.uhVal.QuadPart < (UInt32)(Int32)-1)
+ props.ReduceSize = (UInt32)prop.uhVal.QuadPart;
+ continue;
+ }
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ const UInt32 v = (UInt32)prop.ulVal;
+ switch (propID)
+ {
+ case NCoderPropID::kUsedMemorySize:
+ if (v < (1 << 20) || v > (1 << 28))
+ return E_INVALIDARG;
+ props.MemSizeMB = v >> 20;
+ break;
+ case NCoderPropID::kOrder:
+ if (v < PPMD8_MIN_ORDER || v > PPMD8_MAX_ORDER)
+ return E_INVALIDARG;
+ props.Order = (Byte)v;
+ break;
+ case NCoderPropID::kNumThreads: break;
+ case NCoderPropID::kLevel: level = (int)v; break;
+ case NCoderPropID::kAlgorithm:
+ if (v >= PPMD8_RESTORE_METHOD_UNSUPPPORTED)
+ return E_INVALIDARG;
+ props.Restor = (int)v;
+ break;
+ default: return E_INVALIDARG;
+ }
+ }
+ props.Normalize(level);
+ _props = props;
+ return S_OK;
+}
+
+CEncoder::CEncoder()
+{
+ _props.Normalize(-1);
+ _ppmd.Stream.Out = &_outStream.vt;
+ Ppmd8_Construct(&_ppmd);
+}
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+{
+ if (!_inStream.Alloc())
+ return E_OUTOFMEMORY;
+ if (!_outStream.Alloc(1 << 20))
+ return E_OUTOFMEMORY;
+ if (!Ppmd8_Alloc(&_ppmd, _props.MemSizeMB << 20, &g_BigAlloc))
+ return E_OUTOFMEMORY;
+
+ _outStream.Stream = outStream;
+ _outStream.Init();
+
+ Ppmd8_Init_RangeEnc(&_ppmd)
+ Ppmd8_Init(&_ppmd, (unsigned)_props.Order, (unsigned)_props.Restor);
+
+ {
+ const UInt32 val = (UInt32)(((unsigned)_props.Order - 1) + ((_props.MemSizeMB - 1) << 4) + ((unsigned)_props.Restor << 12));
+ _outStream.WriteByte((Byte)(val & 0xFF));
+ _outStream.WriteByte((Byte)(val >> 8));
+ }
+ RINOK(_outStream.Res)
+
+ UInt64 processed = 0;
+ for (;;)
+ {
+ UInt32 size;
+ RINOK(inStream->Read(_inStream.Buf, kBufSize, &size))
+ if (size == 0)
+ {
+ Ppmd8_EncodeSymbol(&_ppmd, -1);
+ Ppmd8_Flush_RangeEnc(&_ppmd);
+ return _outStream.Flush();
+ }
+
+ processed += size;
+ const Byte *buf = _inStream.Buf;
+ const Byte *lim = buf + size;
+ do
+ {
+ Ppmd8_EncodeSymbol(&_ppmd, *buf);
+ if (_outStream.Res != S_OK)
+ break;
+ }
+ while (++buf != lim);
+
+ RINOK(_outStream.Res)
+
+ if (progress)
+ {
+ const UInt64 outProccessed = _outStream.GetProcessed();
+ RINOK(progress->SetRatioInfo(&processed, &outProccessed))
+ }
+ }
+}
+
+
+
+
+}}
diff --git a/CPP/7zip/Compress/PpmdZip.h b/CPP/7zip/Compress/PpmdZip.h
new file mode 100644
index 0000000..a23d008
--- /dev/null
+++ b/CPP/7zip/Compress/PpmdZip.h
@@ -0,0 +1,85 @@
+// PpmdZip.h
+
+#ifndef ZIP7_INC_COMPRESS_PPMD_ZIP_H
+#define ZIP7_INC_COMPRESS_PPMD_ZIP_H
+
+#include "../../../C/Alloc.h"
+#include "../../../C/Ppmd8.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/CWrappers.h"
+
+namespace NCompress {
+namespace NPpmdZip {
+
+static const UInt32 kBufSize = (1 << 20);
+
+struct CBuf
+{
+ Byte *Buf;
+
+ CBuf(): Buf(NULL) {}
+ ~CBuf() { ::MidFree(Buf); }
+ bool Alloc()
+ {
+ if (!Buf)
+ Buf = (Byte *)::MidAlloc(kBufSize);
+ return (Buf != NULL);
+ }
+};
+
+
+Z7_CLASS_IMP_NOQIB_3(
+ CDecoder
+ , ICompressCoder
+ , ICompressSetFinishMode
+ , ICompressGetInStreamProcessedSize
+)
+ CByteInBufWrap _inStream;
+ CBuf _outStream;
+ CPpmd8 _ppmd;
+ bool _fullFileMode;
+public:
+ CDecoder(bool fullFileMode = true);
+ ~CDecoder();
+};
+
+
+struct CEncProps
+{
+ UInt32 MemSizeMB;
+ UInt32 ReduceSize;
+ int Order;
+ int Restor;
+
+ CEncProps()
+ {
+ MemSizeMB = (UInt32)(Int32)-1;
+ ReduceSize = (UInt32)(Int32)-1;
+ Order = -1;
+ Restor = -1;
+ }
+ void Normalize(int level);
+};
+
+
+Z7_CLASS_IMP_NOQIB_2(
+ CEncoder
+ , ICompressCoder
+ , ICompressSetCoderProperties
+)
+ CByteOutBufWrap _outStream;
+ CBuf _inStream;
+ CPpmd8 _ppmd;
+ CEncProps _props;
+public:
+ CEncoder();
+ ~CEncoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/QuantumDecoder.cpp b/CPP/7zip/Compress/QuantumDecoder.cpp
new file mode 100644
index 0000000..16ef0fc
--- /dev/null
+++ b/CPP/7zip/Compress/QuantumDecoder.cpp
@@ -0,0 +1,195 @@
+// QuantumDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/Defs.h"
+
+#include "QuantumDecoder.h"
+
+namespace NCompress {
+namespace NQuantum {
+
+static const unsigned kNumLenSymbols = 27;
+static const unsigned kMatchMinLen = 3;
+static const unsigned kNumSimplePosSlots = 4;
+static const unsigned kNumSimpleLenSlots = 6;
+
+static const UInt16 kUpdateStep = 8;
+static const UInt16 kFreqSumMax = 3800;
+static const unsigned kReorderCountStart = 4;
+static const unsigned kReorderCount = 50;
+
+void CModelDecoder::Init(unsigned numItems)
+{
+ NumItems = numItems;
+ ReorderCount = kReorderCountStart;
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ Freqs[i] = (UInt16)(numItems - i);
+ Vals[i] = (Byte)i;
+ }
+ Freqs[numItems] = 0;
+}
+
+unsigned CModelDecoder::Decode(CRangeDecoder *rc)
+{
+ const UInt32 threshold = rc->GetThreshold(Freqs[0]);
+ unsigned i;
+ for (i = 1; Freqs[i] > threshold; i++);
+
+ rc->Decode(Freqs[i], Freqs[(size_t)i - 1], Freqs[0]);
+ const unsigned res = Vals[--i];
+
+ do
+ Freqs[i] = (UInt16)(Freqs[i] + kUpdateStep);
+ while (i--);
+
+ if (Freqs[0] > kFreqSumMax)
+ {
+ if (--ReorderCount == 0)
+ {
+ ReorderCount = kReorderCount;
+ for (i = 0; i < NumItems; i++)
+ Freqs[i] = (UInt16)(((Freqs[i] - Freqs[(size_t)i + 1]) + 1) >> 1);
+ for (i = 0; i < NumItems - 1; i++)
+ for (unsigned j = i + 1; j < NumItems; j++)
+ if (Freqs[i] < Freqs[j])
+ {
+ const UInt16 tmpFreq = Freqs[i];
+ const Byte tmpVal = Vals[i];
+ Freqs[i] = Freqs[j];
+ Vals[i] = Vals[j];
+ Freqs[j] = tmpFreq;
+ Vals[j] = tmpVal;
+ }
+
+ do
+ Freqs[i] = (UInt16)(Freqs[i] + Freqs[(size_t)i + 1]);
+ while (i--);
+ }
+ else
+ {
+ i = NumItems - 1;
+ do
+ {
+ Freqs[i] = (UInt16)(Freqs[i] >> 1);
+ if (Freqs[i] <= Freqs[(size_t)i + 1])
+ Freqs[i] = (UInt16)(Freqs[(size_t)i + 1] + 1);
+ }
+ while (i--);
+ }
+ }
+
+ return res;
+}
+
+
+void CDecoder::Init()
+{
+ m_Selector.Init(kNumSelectors);
+ unsigned i;
+ for (i = 0; i < kNumLitSelectors; i++)
+ m_Literals[i].Init(kNumLitSymbols);
+ const unsigned numItems = (_numDictBits == 0 ? 1 : (_numDictBits << 1));
+ const unsigned kNumPosSymbolsMax[kNumMatchSelectors] = { 24, 36, 42 };
+ for (i = 0; i < kNumMatchSelectors; i++)
+ m_PosSlot[i].Init(MyMin(numItems, kNumPosSymbolsMax[i]));
+ m_LenSlot.Init(kNumLenSymbols);
+}
+
+
+HRESULT CDecoder::CodeSpec(const Byte *inData, size_t inSize, UInt32 outSize)
+{
+ if (inSize < 2)
+ return S_FALSE;
+
+ CRangeDecoder rc;
+ rc.Stream.SetStreamAndInit(inData, inSize);
+ rc.Init();
+
+ while (outSize != 0)
+ {
+ if (rc.Stream.WasExtraRead())
+ return S_FALSE;
+
+ unsigned selector = m_Selector.Decode(&rc);
+
+ if (selector < kNumLitSelectors)
+ {
+ const Byte b = (Byte)((selector << (8 - kNumLitSelectorBits)) + m_Literals[selector].Decode(&rc));
+ _outWindow.PutByte(b);
+ outSize--;
+ }
+ else
+ {
+ selector -= kNumLitSelectors;
+ unsigned len = selector + kMatchMinLen;
+
+ if (selector == 2)
+ {
+ unsigned lenSlot = m_LenSlot.Decode(&rc);
+ if (lenSlot >= kNumSimpleLenSlots)
+ {
+ lenSlot -= 2;
+ const unsigned numDirectBits = (unsigned)(lenSlot >> 2);
+ len += ((4 | (lenSlot & 3)) << numDirectBits) - 2;
+ if (numDirectBits < 6)
+ len += rc.Stream.ReadBits(numDirectBits);
+ }
+ else
+ len += lenSlot;
+ }
+
+ UInt32 dist = m_PosSlot[selector].Decode(&rc);
+
+ if (dist >= kNumSimplePosSlots)
+ {
+ unsigned numDirectBits = (unsigned)((dist >> 1) - 1);
+ dist = ((2 | (dist & 1)) << numDirectBits) + rc.Stream.ReadBits(numDirectBits);
+ }
+
+ unsigned locLen = len;
+ if (len > outSize)
+ locLen = (unsigned)outSize;
+ if (!_outWindow.CopyBlock(dist, locLen))
+ return S_FALSE;
+ outSize -= locLen;
+ len -= locLen;
+ if (len != 0)
+ return S_FALSE;
+ }
+ }
+
+ return rc.Finish() ? S_OK : S_FALSE;
+}
+
+HRESULT CDecoder::Code(const Byte *inData, size_t inSize,
+ ISequentialOutStream *outStream, UInt32 outSize,
+ bool keepHistory)
+{
+ try
+ {
+ _outWindow.SetStream(outStream);
+ _outWindow.Init(keepHistory);
+ if (!keepHistory)
+ Init();
+
+ const HRESULT res = CodeSpec(inData, inSize, outSize);
+ const HRESULT res2 = _outWindow.Flush();
+ return res != S_OK ? res : res2;
+ }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+HRESULT CDecoder::SetParams(unsigned numDictBits)
+{
+ if (numDictBits > 21)
+ return E_INVALIDARG;
+ _numDictBits = numDictBits;
+ if (!_outWindow.Create((UInt32)1 << _numDictBits))
+ return E_OUTOFMEMORY;
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Compress/QuantumDecoder.h b/CPP/7zip/Compress/QuantumDecoder.h
new file mode 100644
index 0000000..925989a
--- /dev/null
+++ b/CPP/7zip/Compress/QuantumDecoder.h
@@ -0,0 +1,169 @@
+// QuantumDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_QUANTUM_DECODER_H
+#define ZIP7_INC_COMPRESS_QUANTUM_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NQuantum {
+
+class CBitDecoder
+{
+ UInt32 Value;
+ bool _extra;
+ const Byte *_buf;
+ const Byte *_bufLim;
+public:
+ void SetStreamAndInit(const Byte *inData, size_t inSize)
+ {
+ _buf = inData;
+ _bufLim = inData + inSize;
+ Value = 0x10000;
+ _extra = false;
+ }
+
+ bool WasExtraRead() const { return _extra; }
+
+ bool WasFinishedOK() const
+ {
+ return !_extra && _buf == _bufLim;
+ }
+
+ UInt32 ReadBit()
+ {
+ if (Value >= 0x10000)
+ {
+ Byte b;
+ if (_buf >= _bufLim)
+ {
+ b = 0xFF;
+ _extra = true;
+ }
+ else
+ b = *_buf++;
+ Value = 0x100 | b;
+ }
+ UInt32 res = (Value >> 7) & 1;
+ Value <<= 1;
+ return res;
+ }
+
+ UInt32 ReadStart16Bits()
+ {
+ // we use check for extra read in another code.
+ UInt32 val = ((UInt32)*_buf << 8) | _buf[1];
+ _buf += 2;
+ return val;
+ }
+
+ UInt32 ReadBits(unsigned numBits) // numBits > 0
+ {
+ UInt32 res = 0;
+ do
+ res = (res << 1) | ReadBit();
+ while (--numBits);
+ return res;
+ }
+};
+
+
+class CRangeDecoder
+{
+ UInt32 Low;
+ UInt32 Range;
+ UInt32 Code;
+public:
+ CBitDecoder Stream;
+
+ void Init()
+ {
+ Low = 0;
+ Range = 0x10000;
+ Code = Stream.ReadStart16Bits();
+ }
+
+ bool Finish()
+ {
+ // do all streams use these two bits at end?
+ if (Stream.ReadBit() != 0) return false;
+ if (Stream.ReadBit() != 0) return false;
+ return Stream.WasFinishedOK();
+ }
+
+ UInt32 GetThreshold(UInt32 total) const
+ {
+ return ((Code + 1) * total - 1) / Range; // & 0xFFFF is not required;
+ }
+
+ void Decode(UInt32 start, UInt32 end, UInt32 total)
+ {
+ UInt32 high = Low + end * Range / total - 1;
+ UInt32 offset = start * Range / total;
+ Code -= offset;
+ Low += offset;
+ for (;;)
+ {
+ if ((Low & 0x8000) != (high & 0x8000))
+ {
+ if ((Low & 0x4000) == 0 || (high & 0x4000) != 0)
+ break;
+ Low &= 0x3FFF;
+ high |= 0x4000;
+ }
+ Low = (Low << 1) & 0xFFFF;
+ high = ((high << 1) | 1) & 0xFFFF;
+ Code = ((Code << 1) | Stream.ReadBit());
+ }
+ Range = high - Low + 1;
+ }
+};
+
+
+const unsigned kNumLitSelectorBits = 2;
+const unsigned kNumLitSelectors = (1 << kNumLitSelectorBits);
+const unsigned kNumLitSymbols = 1 << (8 - kNumLitSelectorBits);
+const unsigned kNumMatchSelectors = 3;
+const unsigned kNumSelectors = kNumLitSelectors + kNumMatchSelectors;
+const unsigned kNumSymbolsMax = kNumLitSymbols; // 64
+
+
+class CModelDecoder
+{
+ unsigned NumItems;
+ unsigned ReorderCount;
+ UInt16 Freqs[kNumSymbolsMax + 1];
+ Byte Vals[kNumSymbolsMax];
+public:
+ void Init(unsigned numItems);
+ unsigned Decode(CRangeDecoder *rc);
+};
+
+
+Z7_CLASS_IMP_COM_0(
+ CDecoder
+)
+ CLzOutWindow _outWindow;
+ unsigned _numDictBits;
+
+ CModelDecoder m_Selector;
+ CModelDecoder m_Literals[kNumLitSelectors];
+ CModelDecoder m_PosSlot[kNumMatchSelectors];
+ CModelDecoder m_LenSlot;
+
+ void Init();
+ HRESULT CodeSpec(const Byte *inData, size_t inSize, UInt32 outSize);
+public:
+ HRESULT Code(const Byte *inData, size_t inSize,
+ ISequentialOutStream *outStream, UInt32 outSize,
+ bool keepHistory);
+ HRESULT SetParams(unsigned numDictBits);
+
+ CDecoder(): _numDictBits(0) {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Rar1Decoder.cpp b/CPP/7zip/Compress/Rar1Decoder.cpp
new file mode 100644
index 0000000..050cde2
--- /dev/null
+++ b/CPP/7zip/Compress/Rar1Decoder.cpp
@@ -0,0 +1,518 @@
+// Rar1Decoder.cpp
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#include "StdAfx.h"
+
+#include "Rar1Decoder.h"
+
+namespace NCompress {
+namespace NRar1 {
+
+static const unsigned kNumBits = 12;
+
+static const Byte kShortLen1[16 * 3] =
+{
+ 0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0,0,
+ 1,3,4,4,5,6,7,8,8,4,4,5,6,6,0,0,
+ 1,4,4,4,5,6,7,8,8,4,4,5,6,6,4,0
+};
+
+static const Byte kShortLen2[16 * 3] =
+{
+ 0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0,0,
+ 2,3,3,3,4,4,5,6,6,4,4,5,6,6,0,0,
+ 2,3,3,4,4,4,5,6,6,4,4,5,6,6,4,0
+};
+
+static const Byte PosL1[kNumBits + 1] = { 0,0,2,1,2,2,4,5,4,4,8,0,224 };
+static const Byte PosL2[kNumBits + 1] = { 0,0,0,5,2,2,4,5,4,4,8,2,220 };
+
+static const Byte PosHf0[kNumBits + 1] = { 0,0,0,0,8,8,8,9,0,0,0,0,224 };
+static const Byte PosHf1[kNumBits + 1] = { 0,0,0,0,0,4,40,16,16,4,0,47,130 };
+static const Byte PosHf2[kNumBits + 1] = { 0,0,0,0,0,2,5,46,64,116,24,0,0 };
+static const Byte PosHf3[kNumBits + 1] = { 0,0,0,0,0,0,2,14,202,33,6,0,0 };
+static const Byte PosHf4[kNumBits + 1] = { 0,0,0,0,0,0,0,0,255,2,0,0,0 };
+
+static const UInt32 kHistorySize = (1 << 16);
+
+CDecoder::CDecoder():
+ _isSolid(false),
+ _solidAllowed(false)
+ {}
+
+UInt32 CDecoder::ReadBits(unsigned numBits) { return m_InBitStream.ReadBits(numBits); }
+
+HRESULT CDecoder::CopyBlock(UInt32 distance, UInt32 len)
+{
+ if (len == 0)
+ return S_FALSE;
+ if (m_UnpackSize < len)
+ return S_FALSE;
+ m_UnpackSize -= len;
+ return m_OutWindowStream.CopyBlock(distance, len) ? S_OK : S_FALSE;
+}
+
+
+UInt32 CDecoder::DecodeNum(const Byte *numTab)
+{
+ /*
+ {
+ // we can check that tables are correct
+ UInt32 sum = 0;
+ for (unsigned i = 0; i <= kNumBits; i++)
+ sum += ((UInt32)numTab[i] << (kNumBits - i));
+ if (sum != (1 << kNumBits))
+ throw 111;
+ }
+ */
+
+ UInt32 val = m_InBitStream.GetValue(kNumBits);
+ UInt32 sum = 0;
+ unsigned i = 2;
+
+ for (;;)
+ {
+ const UInt32 num = numTab[i];
+ const UInt32 cur = num << (kNumBits - i);
+ if (val < cur)
+ break;
+ i++;
+ val -= cur;
+ sum += num;
+ }
+ m_InBitStream.MovePos(i);
+ return ((val >> (kNumBits - i)) + sum);
+}
+
+
+HRESULT CDecoder::ShortLZ()
+{
+ NumHuf = 0;
+
+ if (LCount == 2)
+ {
+ if (ReadBits(1))
+ return CopyBlock(LastDist, LastLength);
+ LCount = 0;
+ }
+
+ UInt32 bitField = m_InBitStream.GetValue(8);
+
+ UInt32 len, dist;
+ {
+ const Byte *xors = (AvrLn1 < 37) ? kShortLen1 : kShortLen2;
+ const Byte *lens = xors + 16 + Buf60;
+ for (len = 0; ((bitField ^ xors[len]) >> (8 - lens[len])) != 0; len++);
+ m_InBitStream.MovePos(lens[len]);
+ }
+
+ if (len >= 9)
+ {
+ if (len == 9)
+ {
+ LCount++;
+ return CopyBlock(LastDist, LastLength);
+ }
+
+ LCount = 0;
+
+ if (len == 14)
+ {
+ len = DecodeNum(PosL2) + 5;
+ dist = 0x8000 + ReadBits(15) - 1;
+ LastLength = len;
+ LastDist = dist;
+ return CopyBlock(dist, len);
+ }
+
+ const UInt32 saveLen = len;
+ dist = m_RepDists[(m_RepDistPtr - (len - 9)) & 3];
+
+ len = DecodeNum(PosL1);
+
+ if (len == 0xff && saveLen == 10)
+ {
+ Buf60 ^= 16;
+ return S_OK;
+ }
+ if (dist >= 256)
+ {
+ len++;
+ if (dist >= MaxDist3 - 1)
+ len++;
+ }
+ }
+ else
+ {
+ LCount = 0;
+ AvrLn1 += len;
+ AvrLn1 -= AvrLn1 >> 4;
+
+ unsigned distancePlace = DecodeNum(PosHf2) & 0xff;
+
+ dist = ChSetA[distancePlace];
+
+ if (distancePlace != 0)
+ {
+ PlaceA[dist]--;
+ UInt32 lastDistance = ChSetA[(size_t)distancePlace - 1];
+ PlaceA[lastDistance]++;
+ ChSetA[distancePlace] = lastDistance;
+ ChSetA[(size_t)distancePlace - 1] = dist;
+ }
+ }
+
+ m_RepDists[m_RepDistPtr++] = dist;
+ m_RepDistPtr &= 3;
+ len += 2;
+ LastLength = len;
+ LastDist = dist;
+ return CopyBlock(dist, len);
+}
+
+
+HRESULT CDecoder::LongLZ()
+{
+ UInt32 len;
+ UInt32 dist;
+ UInt32 distancePlace, newDistancePlace;
+ UInt32 oldAvr2, oldAvr3;
+
+ NumHuf = 0;
+ Nlzb += 16;
+ if (Nlzb > 0xff)
+ {
+ Nlzb = 0x90;
+ Nhfb >>= 1;
+ }
+ oldAvr2 = AvrLn2;
+
+ if (AvrLn2 >= 64)
+ len = DecodeNum(AvrLn2 < 122 ? PosL1 : PosL2);
+ else
+ {
+ UInt32 bitField = m_InBitStream.GetValue(16);
+ if (bitField < 0x100)
+ {
+ len = bitField;
+ m_InBitStream.MovePos(16);
+ }
+ else
+ {
+ for (len = 0; ((bitField << len) & 0x8000) == 0; len++);
+
+ m_InBitStream.MovePos(len + 1);
+ }
+ }
+
+ AvrLn2 += len;
+ AvrLn2 -= AvrLn2 >> 5;
+
+ {
+ const Byte *tab;
+ if (AvrPlcB >= 0x2900) tab = PosHf2;
+ else if (AvrPlcB >= 0x0700) tab = PosHf1;
+ else tab = PosHf0;
+ distancePlace = DecodeNum(tab); // [0, 256]
+ }
+
+ AvrPlcB += distancePlace;
+ AvrPlcB -= AvrPlcB >> 8;
+
+ distancePlace &= 0xff;
+
+ for (;;)
+ {
+ dist = ChSetB[distancePlace];
+ newDistancePlace = NToPlB[dist++ & 0xff]++;
+ if (dist & 0xff)
+ break;
+ CorrHuff(ChSetB,NToPlB);
+ }
+
+ ChSetB[distancePlace] = ChSetB[newDistancePlace];
+ ChSetB[newDistancePlace] = dist;
+
+ dist = ((dist & 0xff00) >> 1) | ReadBits(7);
+
+ oldAvr3 = AvrLn3;
+
+ if (len != 1 && len != 4)
+ {
+ if (len == 0 && dist <= MaxDist3)
+ {
+ AvrLn3++;
+ AvrLn3 -= AvrLn3 >> 8;
+ }
+ else if (AvrLn3 > 0)
+ AvrLn3--;
+ }
+
+ len += 3;
+
+ if (dist >= MaxDist3)
+ len++;
+ if (dist <= 256)
+ len += 8;
+
+ if (oldAvr3 > 0xb0 || (AvrPlc >= 0x2a00 && oldAvr2 < 0x40))
+ MaxDist3 = 0x7f00;
+ else
+ MaxDist3 = 0x2001;
+
+ m_RepDists[m_RepDistPtr++] = --dist;
+ m_RepDistPtr &= 3;
+ LastLength = len;
+ LastDist = dist;
+
+ return CopyBlock(dist, len);
+}
+
+
+HRESULT CDecoder::HuffDecode()
+{
+ UInt32 curByte, newBytePlace;
+ UInt32 len;
+ UInt32 dist;
+ unsigned bytePlace;
+ {
+ const Byte *tab;
+
+ if (AvrPlc >= 0x7600) tab = PosHf4;
+ else if (AvrPlc >= 0x5e00) tab = PosHf3;
+ else if (AvrPlc >= 0x3600) tab = PosHf2;
+ else if (AvrPlc >= 0x0e00) tab = PosHf1;
+ else tab = PosHf0;
+
+ bytePlace = DecodeNum(tab); // [0, 256]
+ }
+
+ if (StMode)
+ {
+ if (bytePlace == 0)
+ {
+ if (ReadBits(1))
+ {
+ NumHuf = 0;
+ StMode = false;
+ return S_OK;
+ }
+ len = ReadBits(1) + 3;
+ dist = DecodeNum(PosHf2);
+ dist = (dist << 5) | ReadBits(5);
+ if (dist == 0)
+ return S_FALSE;
+ return CopyBlock(dist - 1, len);
+ }
+ bytePlace--; // bytePlace is [0, 255]
+ }
+ else if (NumHuf++ >= 16 && FlagsCnt == 0)
+ StMode = true;
+
+ bytePlace &= 0xff;
+ AvrPlc += bytePlace;
+ AvrPlc -= AvrPlc >> 8;
+ Nhfb += 16;
+
+ if (Nhfb > 0xff)
+ {
+ Nhfb = 0x90;
+ Nlzb >>= 1;
+ }
+
+ m_UnpackSize--;
+ m_OutWindowStream.PutByte((Byte)(ChSet[bytePlace] >> 8));
+
+ for (;;)
+ {
+ curByte = ChSet[bytePlace];
+ newBytePlace = NToPl[curByte++ & 0xff]++;
+ if ((curByte & 0xff) <= 0xa1)
+ break;
+ CorrHuff(ChSet, NToPl);
+ }
+
+ ChSet[bytePlace] = ChSet[newBytePlace];
+ ChSet[newBytePlace] = curByte;
+ return S_OK;
+}
+
+
+void CDecoder::GetFlagsBuf()
+{
+ UInt32 flags, newFlagsPlace;
+ const UInt32 flagsPlace = DecodeNum(PosHf2); // [0, 256]
+
+ if (flagsPlace >= Z7_ARRAY_SIZE(ChSetC))
+ return;
+
+ for (;;)
+ {
+ flags = ChSetC[flagsPlace];
+ FlagBuf = flags >> 8;
+ newFlagsPlace = NToPlC[flags++ & 0xff]++;
+ if ((flags & 0xff) != 0)
+ break;
+ CorrHuff(ChSetC, NToPlC);
+ }
+
+ ChSetC[flagsPlace] = ChSetC[newFlagsPlace];
+ ChSetC[newFlagsPlace] = flags;
+}
+
+
+void CDecoder::CorrHuff(UInt32 *CharSet, UInt32 *NumToPlace)
+{
+ int i;
+ for (i = 7; i >= 0; i--)
+ for (unsigned j = 0; j < 32; j++, CharSet++)
+ *CharSet = (*CharSet & ~(UInt32)0xff) | (unsigned)i;
+ memset(NumToPlace, 0, sizeof(NToPl));
+ for (i = 6; i >= 0; i--)
+ NumToPlace[i] = (7 - (unsigned)i) * 32;
+}
+
+
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo * /* progress */)
+{
+ if (!inSize || !outSize)
+ return E_INVALIDARG;
+
+ if (_isSolid && !_solidAllowed)
+ return S_FALSE;
+
+ _solidAllowed = false;
+
+ if (!m_OutWindowStream.Create(kHistorySize))
+ return E_OUTOFMEMORY;
+ if (!m_InBitStream.Create(1 << 20))
+ return E_OUTOFMEMORY;
+
+ m_UnpackSize = *outSize;
+
+ m_OutWindowStream.SetStream(outStream);
+ m_OutWindowStream.Init(_isSolid);
+ m_InBitStream.SetStream(inStream);
+ m_InBitStream.Init();
+
+ // InitData
+
+ FlagsCnt = 0;
+ FlagBuf = 0;
+ StMode = false;
+ LCount = 0;
+
+ if (!_isSolid)
+ {
+ AvrPlcB = AvrLn1 = AvrLn2 = AvrLn3 = NumHuf = Buf60 = 0;
+ AvrPlc = 0x3500;
+ MaxDist3 = 0x2001;
+ Nhfb = Nlzb = 0x80;
+
+ {
+ // InitStructures
+ for (unsigned i = 0; i < kNumRepDists; i++)
+ m_RepDists[i] = 0;
+ m_RepDistPtr = 0;
+ LastLength = 0;
+ LastDist = 0;
+ }
+
+ // InitHuff
+
+ for (UInt32 i = 0; i < 256; i++)
+ {
+ Place[i] = PlaceA[i] = PlaceB[i] = i;
+ UInt32 c = (~i + 1) & 0xff;
+ PlaceC[i] = c;
+ ChSet[i] = ChSetB[i] = i << 8;
+ ChSetA[i] = i;
+ ChSetC[i] = c << 8;
+ }
+ memset(NToPl, 0, sizeof(NToPl));
+ memset(NToPlB, 0, sizeof(NToPlB));
+ memset(NToPlC, 0, sizeof(NToPlC));
+ CorrHuff(ChSetB, NToPlB);
+ }
+
+ if (m_UnpackSize > 0)
+ {
+ GetFlagsBuf();
+ FlagsCnt = 8;
+ }
+
+ while (m_UnpackSize != 0)
+ {
+ if (!StMode)
+ {
+ if (--FlagsCnt < 0)
+ {
+ GetFlagsBuf();
+ FlagsCnt = 7;
+ }
+
+ if (FlagBuf & 0x80)
+ {
+ FlagBuf <<= 1;
+ if (Nlzb > Nhfb)
+ {
+ RINOK(LongLZ())
+ continue;
+ }
+ }
+ else
+ {
+ FlagBuf <<= 1;
+
+ if (--FlagsCnt < 0)
+ {
+ GetFlagsBuf();
+ FlagsCnt = 7;
+ }
+
+ if ((FlagBuf & 0x80) == 0)
+ {
+ FlagBuf <<= 1;
+ RINOK(ShortLZ())
+ continue;
+ }
+
+ FlagBuf <<= 1;
+
+ if (Nlzb <= Nhfb)
+ {
+ RINOK(LongLZ())
+ continue;
+ }
+ }
+ }
+
+ RINOK(HuffDecode())
+ }
+
+ _solidAllowed = true;
+ return m_OutWindowStream.Flush();
+}
+
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ if (size < 1)
+ return E_INVALIDARG;
+ _isSolid = ((data[0] & 1) != 0);
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Compress/Rar1Decoder.h b/CPP/7zip/Compress/Rar1Decoder.h
new file mode 100644
index 0000000..6d0e31d
--- /dev/null
+++ b/CPP/7zip/Compress/Rar1Decoder.h
@@ -0,0 +1,71 @@
+// Rar1Decoder.h
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#ifndef ZIP7_INC_COMPRESS_RAR1_DECODER_H
+#define ZIP7_INC_COMPRESS_RAR1_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitmDecoder.h"
+#include "HuffmanDecoder.h"
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NRar1 {
+
+const UInt32 kNumRepDists = 4;
+
+Z7_CLASS_IMP_COM_2(
+ CDecoder
+ , ICompressCoder
+ , ICompressSetDecoderProperties2
+)
+ CLzOutWindow m_OutWindowStream;
+ NBitm::CDecoder<CInBuffer> m_InBitStream;
+
+ UInt64 m_UnpackSize;
+
+ UInt32 LastDist;
+ UInt32 LastLength;
+
+ UInt32 m_RepDistPtr;
+ UInt32 m_RepDists[kNumRepDists];
+
+ bool _isSolid;
+ bool _solidAllowed;
+
+ bool StMode;
+ int FlagsCnt;
+ UInt32 FlagBuf, AvrPlc, AvrPlcB, AvrLn1, AvrLn2, AvrLn3;
+ unsigned Buf60, NumHuf, LCount;
+ UInt32 Nhfb, Nlzb, MaxDist3;
+
+ UInt32 ChSet[256], ChSetA[256], ChSetB[256], ChSetC[256];
+ UInt32 Place[256], PlaceA[256], PlaceB[256], PlaceC[256];
+ UInt32 NToPl[256], NToPlB[256], NToPlC[256];
+
+ UInt32 ReadBits(unsigned numBits);
+ HRESULT CopyBlock(UInt32 distance, UInt32 len);
+ UInt32 DecodeNum(const Byte *numTab);
+ HRESULT ShortLZ();
+ HRESULT LongLZ();
+ HRESULT HuffDecode();
+ void GetFlagsBuf();
+ void CorrHuff(UInt32 *CharSet, UInt32 *NumToPlace);
+ void OldUnpWriteBuf();
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+
+public:
+ CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Rar2Decoder.cpp b/CPP/7zip/Compress/Rar2Decoder.cpp
new file mode 100644
index 0000000..92404b6
--- /dev/null
+++ b/CPP/7zip/Compress/Rar2Decoder.cpp
@@ -0,0 +1,441 @@
+// Rar2Decoder.cpp
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#include "StdAfx.h"
+
+#include <stdlib.h>
+
+#include "Rar2Decoder.h"
+
+namespace NCompress {
+namespace NRar2 {
+
+namespace NMultimedia {
+
+#define my_abs(x) (unsigned)abs(x)
+
+Byte CFilter::Decode(int &channelDelta, Byte deltaByte)
+{
+ D4 = D3;
+ D3 = D2;
+ D2 = LastDelta - D1;
+ D1 = LastDelta;
+ const int predictedValue = ((8 * LastChar + K1 * D1 + K2 * D2 + K3 * D3 + K4 * D4 + K5 * channelDelta) >> 3);
+
+ const Byte realValue = (Byte)(predictedValue - deltaByte);
+
+ {
+ const int i = ((int)(signed char)deltaByte) << 3;
+
+ Dif[0] += my_abs(i);
+ Dif[1] += my_abs(i - D1);
+ Dif[2] += my_abs(i + D1);
+ Dif[3] += my_abs(i - D2);
+ Dif[4] += my_abs(i + D2);
+ Dif[5] += my_abs(i - D3);
+ Dif[6] += my_abs(i + D3);
+ Dif[7] += my_abs(i - D4);
+ Dif[8] += my_abs(i + D4);
+ Dif[9] += my_abs(i - channelDelta);
+ Dif[10] += my_abs(i + channelDelta);
+ }
+
+ channelDelta = LastDelta = (signed char)(realValue - LastChar);
+ LastChar = realValue;
+
+ if (((++ByteCount) & 0x1F) == 0)
+ {
+ UInt32 minDif = Dif[0];
+ UInt32 numMinDif = 0;
+ Dif[0] = 0;
+
+ for (unsigned i = 1; i < Z7_ARRAY_SIZE(Dif); i++)
+ {
+ if (Dif[i] < minDif)
+ {
+ minDif = Dif[i];
+ numMinDif = i;
+ }
+ Dif[i] = 0;
+ }
+
+ switch (numMinDif)
+ {
+ case 1: if (K1 >= -16) K1--; break;
+ case 2: if (K1 < 16) K1++; break;
+ case 3: if (K2 >= -16) K2--; break;
+ case 4: if (K2 < 16) K2++; break;
+ case 5: if (K3 >= -16) K3--; break;
+ case 6: if (K3 < 16) K3++; break;
+ case 7: if (K4 >= -16) K4--; break;
+ case 8: if (K4 < 16) K4++; break;
+ case 9: if (K5 >= -16) K5--; break;
+ case 10:if (K5 < 16) K5++; break;
+ }
+ }
+
+ return realValue;
+}
+}
+
+static const UInt32 kHistorySize = 1 << 20;
+
+// static const UInt32 kWindowReservSize = (1 << 22) + 256;
+
+CDecoder::CDecoder():
+ _isSolid(false),
+ _solidAllowed(false),
+ m_TablesOK(false)
+{
+}
+
+void CDecoder::InitStructures()
+{
+ m_MmFilter.Init();
+ for (unsigned i = 0; i < kNumRepDists; i++)
+ m_RepDists[i] = 0;
+ m_RepDistPtr = 0;
+ m_LastLength = 0;
+ memset(m_LastLevels, 0, kMaxTableSize);
+}
+
+UInt32 CDecoder::ReadBits(unsigned numBits) { return m_InBitStream.ReadBits(numBits); }
+
+#define RIF(x) { if (!(x)) return false; }
+
+bool CDecoder::ReadTables(void)
+{
+ m_TablesOK = false;
+
+ Byte levelLevels[kLevelTableSize];
+ Byte lens[kMaxTableSize];
+
+ m_AudioMode = (ReadBits(1) == 1);
+
+ if (ReadBits(1) == 0)
+ memset(m_LastLevels, 0, kMaxTableSize);
+
+ unsigned numLevels;
+
+ if (m_AudioMode)
+ {
+ m_NumChannels = ReadBits(2) + 1;
+ if (m_MmFilter.CurrentChannel >= m_NumChannels)
+ m_MmFilter.CurrentChannel = 0;
+ numLevels = m_NumChannels * kMMTableSize;
+ }
+ else
+ numLevels = kHeapTablesSizesSum;
+
+ unsigned i;
+ for (i = 0; i < kLevelTableSize; i++)
+ levelLevels[i] = (Byte)ReadBits(4);
+ RIF(m_LevelDecoder.Build(levelLevels))
+
+ i = 0;
+
+ do
+ {
+ const UInt32 sym = m_LevelDecoder.Decode(&m_InBitStream);
+ if (sym < kTableDirectLevels)
+ {
+ lens[i] = (Byte)((sym + m_LastLevels[i]) & kLevelMask);
+ i++;
+ }
+ else
+ {
+ if (sym == kTableLevelRepNumber)
+ {
+ unsigned num = ReadBits(2) + 3;
+ if (i == 0)
+ return false;
+ num += i;
+ if (num > numLevels)
+ {
+ // return false;
+ num = numLevels; // original unRAR
+ }
+ const Byte v = lens[(size_t)i - 1];
+ do
+ lens[i++] = v;
+ while (i < num);
+ }
+ else
+ {
+ unsigned num;
+ if (sym == kTableLevel0Number)
+ num = ReadBits(3) + 3;
+ else if (sym == kTableLevel0Number2)
+ num = ReadBits(7) + 11;
+ else
+ return false;
+ num += i;
+ if (num > numLevels)
+ {
+ // return false;
+ num = numLevels; // original unRAR
+ }
+ do
+ lens[i++] = 0;
+ while (i < num);
+ }
+ }
+ }
+ while (i < numLevels);
+
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+
+ if (m_AudioMode)
+ for (i = 0; i < m_NumChannels; i++)
+ {
+ RIF(m_MMDecoders[i].Build(&lens[i * kMMTableSize]))
+ }
+ else
+ {
+ RIF(m_MainDecoder.Build(&lens[0]))
+ RIF(m_DistDecoder.Build(&lens[kMainTableSize]))
+ RIF(m_LenDecoder.Build(&lens[kMainTableSize + kDistTableSize]))
+ }
+
+ memcpy(m_LastLevels, lens, kMaxTableSize);
+
+ m_TablesOK = true;
+
+ return true;
+}
+
+bool CDecoder::ReadLastTables()
+{
+ // it differs a little from pure RAR sources;
+ // UInt64 ttt = m_InBitStream.GetProcessedSize() + 2;
+ // + 2 works for: return 0xFF; in CInBuffer::ReadByte.
+ if (m_InBitStream.GetProcessedSize() + 7 <= m_PackSize) // test it: probably incorrect;
+ // if (m_InBitStream.GetProcessedSize() + 2 <= m_PackSize) // test it: probably incorrect;
+ {
+ if (m_AudioMode)
+ {
+ const UInt32 symbol = m_MMDecoders[m_MmFilter.CurrentChannel].Decode(&m_InBitStream);
+ if (symbol == 256)
+ return ReadTables();
+ if (symbol >= kMMTableSize)
+ return false;
+ }
+ else
+ {
+ const UInt32 sym = m_MainDecoder.Decode(&m_InBitStream);
+ if (sym == kReadTableNumber)
+ return ReadTables();
+ if (sym >= kMainTableSize)
+ return false;
+ }
+ }
+ return true;
+}
+
+
+bool CDecoder::DecodeMm(UInt32 pos)
+{
+ while (pos-- != 0)
+ {
+ const UInt32 symbol = m_MMDecoders[m_MmFilter.CurrentChannel].Decode(&m_InBitStream);
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+ if (symbol >= 256)
+ return symbol == 256;
+ /*
+ Byte byPredict = m_Predictor.Predict();
+ Byte byReal = (Byte)(byPredict - (Byte)symbol);
+ m_Predictor.Update(byReal, byPredict);
+ */
+ const Byte byReal = m_MmFilter.Decode((Byte)symbol);
+ m_OutWindowStream.PutByte(byReal);
+ if (++m_MmFilter.CurrentChannel == m_NumChannels)
+ m_MmFilter.CurrentChannel = 0;
+ }
+ return true;
+}
+
+bool CDecoder::DecodeLz(Int32 pos)
+{
+ while (pos > 0)
+ {
+ UInt32 sym = m_MainDecoder.Decode(&m_InBitStream);
+ if (m_InBitStream.ExtraBitsWereRead())
+ return false;
+ UInt32 length, distance;
+ if (sym < 256)
+ {
+ m_OutWindowStream.PutByte(Byte(sym));
+ pos--;
+ continue;
+ }
+ else if (sym >= kMatchNumber)
+ {
+ if (sym >= kMainTableSize)
+ return false;
+ sym -= kMatchNumber;
+ length = kNormalMatchMinLen + UInt32(kLenStart[sym]) +
+ m_InBitStream.ReadBits(kLenDirectBits[sym]);
+ sym = m_DistDecoder.Decode(&m_InBitStream);
+ if (sym >= kDistTableSize)
+ return false;
+ distance = kDistStart[sym] + m_InBitStream.ReadBits(kDistDirectBits[sym]);
+ if (distance >= kDistLimit3)
+ {
+ length += 2 - ((distance - kDistLimit4) >> 31);
+ // length++;
+ // if (distance >= kDistLimit4)
+ // length++;
+ }
+ }
+ else if (sym == kRepBothNumber)
+ {
+ length = m_LastLength;
+ if (length == 0)
+ return false;
+ distance = m_RepDists[(m_RepDistPtr + 4 - 1) & 3];
+ }
+ else if (sym < kLen2Number)
+ {
+ distance = m_RepDists[(m_RepDistPtr - (sym - kRepNumber + 1)) & 3];
+ sym = m_LenDecoder.Decode(&m_InBitStream);
+ if (sym >= kLenTableSize)
+ return false;
+ length = 2 + kLenStart[sym] + m_InBitStream.ReadBits(kLenDirectBits[sym]);
+ if (distance >= kDistLimit2)
+ {
+ length++;
+ if (distance >= kDistLimit3)
+ {
+ length += 2 - ((distance - kDistLimit4) >> 31);
+ // length++;
+ // if (distance >= kDistLimit4)
+ // length++;
+ }
+ }
+ }
+ else if (sym < kReadTableNumber)
+ {
+ sym -= kLen2Number;
+ distance = kLen2DistStarts[sym] +
+ m_InBitStream.ReadBits(kLen2DistDirectBits[sym]);
+ length = 2;
+ }
+ else // (sym == kReadTableNumber)
+ return true;
+
+ m_RepDists[m_RepDistPtr++ & 3] = distance;
+ m_LastLength = length;
+ if (!m_OutWindowStream.CopyBlock(distance, length))
+ return false;
+ pos -= length;
+ }
+ return true;
+}
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ if (!inSize || !outSize)
+ return E_INVALIDARG;
+
+ if (_isSolid && !_solidAllowed)
+ return S_FALSE;
+ _solidAllowed = false;
+
+ if (!m_OutWindowStream.Create(kHistorySize))
+ return E_OUTOFMEMORY;
+ if (!m_InBitStream.Create(1 << 20))
+ return E_OUTOFMEMORY;
+
+ m_PackSize = *inSize;
+
+ UInt64 pos = 0, unPackSize = *outSize;
+
+ m_OutWindowStream.SetStream(outStream);
+ m_OutWindowStream.Init(_isSolid);
+ m_InBitStream.SetStream(inStream);
+ m_InBitStream.Init();
+
+ // CCoderReleaser coderReleaser(this);
+ if (!_isSolid)
+ {
+ InitStructures();
+ if (unPackSize == 0)
+ {
+ if (m_InBitStream.GetProcessedSize() + 2 <= m_PackSize) // test it: probably incorrect;
+ if (!ReadTables())
+ return S_FALSE;
+ _solidAllowed = true;
+ return S_OK;
+ }
+ ReadTables();
+ }
+
+ if (!m_TablesOK)
+ return S_FALSE;
+
+ const UInt64 startPos = m_OutWindowStream.GetProcessedSize();
+ while (pos < unPackSize)
+ {
+ UInt32 blockSize = 1 << 20;
+ if (blockSize > unPackSize - pos)
+ blockSize = (UInt32)(unPackSize - pos);
+ UInt64 blockStartPos = m_OutWindowStream.GetProcessedSize();
+ if (m_AudioMode)
+ {
+ if (!DecodeMm(blockSize))
+ return S_FALSE;
+ }
+ else
+ {
+ if (!DecodeLz((Int32)blockSize))
+ return S_FALSE;
+ }
+
+ if (m_InBitStream.ExtraBitsWereRead())
+ return S_FALSE;
+
+ const UInt64 globalPos = m_OutWindowStream.GetProcessedSize();
+ pos = globalPos - blockStartPos;
+ if (pos < blockSize)
+ if (!ReadTables())
+ return S_FALSE;
+ pos = globalPos - startPos;
+ if (progress)
+ {
+ const UInt64 packSize = m_InBitStream.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &pos))
+ }
+ }
+ if (pos > unPackSize)
+ return S_FALSE;
+
+ if (!ReadLastTables())
+ return S_FALSE;
+
+ _solidAllowed = true;
+
+ return m_OutWindowStream.Flush();
+}
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ if (size < 1)
+ return E_INVALIDARG;
+ _isSolid = ((data[0] & 1) != 0);
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Compress/Rar2Decoder.h b/CPP/7zip/Compress/Rar2Decoder.h
new file mode 100644
index 0000000..d77bfc1
--- /dev/null
+++ b/CPP/7zip/Compress/Rar2Decoder.h
@@ -0,0 +1,164 @@
+// Rar2Decoder.h
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#ifndef ZIP7_INC_COMPRESS_RAR2_DECODER_H
+#define ZIP7_INC_COMPRESS_RAR2_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitmDecoder.h"
+#include "HuffmanDecoder.h"
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NRar2 {
+
+const unsigned kNumRepDists = 4;
+const unsigned kDistTableSize = 48;
+
+const unsigned kMMTableSize = 256 + 1;
+
+const UInt32 kMainTableSize = 298;
+const UInt32 kLenTableSize = 28;
+
+const UInt32 kDistTableStart = kMainTableSize;
+const UInt32 kLenTableStart = kDistTableStart + kDistTableSize;
+
+const UInt32 kHeapTablesSizesSum = kMainTableSize + kDistTableSize + kLenTableSize;
+
+const UInt32 kLevelTableSize = 19;
+
+const UInt32 kMMTablesSizesSum = kMMTableSize * 4;
+
+const UInt32 kMaxTableSize = kMMTablesSizesSum;
+
+const UInt32 kTableDirectLevels = 16;
+const UInt32 kTableLevelRepNumber = kTableDirectLevels;
+const UInt32 kTableLevel0Number = kTableLevelRepNumber + 1;
+const UInt32 kTableLevel0Number2 = kTableLevel0Number + 1;
+
+const UInt32 kLevelMask = 0xF;
+
+
+const UInt32 kRepBothNumber = 256;
+const UInt32 kRepNumber = kRepBothNumber + 1;
+const UInt32 kLen2Number = kRepNumber + 4;
+
+const UInt32 kLen2NumNumbers = 8;
+const UInt32 kReadTableNumber = kLen2Number + kLen2NumNumbers;
+const UInt32 kMatchNumber = kReadTableNumber + 1;
+
+const Byte kLenStart [kLenTableSize] = {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
+const Byte kLenDirectBits[kLenTableSize] = {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5};
+
+const UInt32 kDistStart [kDistTableSize] = {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768U,49152U,65536,98304,131072,196608,262144,327680,393216,458752,524288,589824,655360,720896,786432,851968,917504,983040};
+const Byte kDistDirectBits[kDistTableSize] = {0,0,0,0,1,1,2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16};
+
+const Byte kLevelDirectBits[kLevelTableSize] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7};
+
+const Byte kLen2DistStarts[kLen2NumNumbers]={0,4,8,16,32,64,128,192};
+const Byte kLen2DistDirectBits[kLen2NumNumbers]={2,2,3, 4, 5, 6, 6, 6};
+
+const UInt32 kDistLimit2 = 0x101 - 1;
+const UInt32 kDistLimit3 = 0x2000 - 1;
+const UInt32 kDistLimit4 = 0x40000 - 1;
+
+const UInt32 kMatchMaxLen = 255 + 2;
+const UInt32 kMatchMaxLenMax = 255 + 5;
+const UInt32 kNormalMatchMinLen = 3;
+
+namespace NMultimedia {
+
+struct CFilter
+{
+ int K1,K2,K3,K4,K5;
+ int D1,D2,D3,D4;
+ int LastDelta;
+ UInt32 Dif[11];
+ UInt32 ByteCount;
+ int LastChar;
+
+ Byte Decode(int &channelDelta, Byte delta);
+
+ void Init() { memset(this, 0, sizeof(*this)); }
+
+};
+
+const unsigned kNumChanelsMax = 4;
+
+class CFilter2
+{
+public:
+ CFilter m_Filters[kNumChanelsMax];
+ int m_ChannelDelta;
+ unsigned CurrentChannel;
+
+ void Init() { memset(this, 0, sizeof(*this)); }
+ Byte Decode(Byte delta)
+ {
+ return m_Filters[CurrentChannel].Decode(m_ChannelDelta, delta);
+ }
+
+};
+
+}
+
+typedef NBitm::CDecoder<CInBuffer> CBitDecoder;
+
+const unsigned kNumHuffmanBits = 15;
+
+Z7_CLASS_IMP_NOQIB_2(
+ CDecoder
+ , ICompressCoder
+ , ICompressSetDecoderProperties2
+)
+ CLzOutWindow m_OutWindowStream;
+ CBitDecoder m_InBitStream;
+
+ UInt32 m_RepDistPtr;
+ UInt32 m_RepDists[kNumRepDists];
+
+ UInt32 m_LastLength;
+
+ bool _isSolid;
+ bool _solidAllowed;
+ bool m_TablesOK;
+ bool m_AudioMode;
+
+ NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> m_MainDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kDistTableSize> m_DistDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kLenTableSize> m_LenDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kMMTableSize> m_MMDecoders[NMultimedia::kNumChanelsMax];
+ NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize> m_LevelDecoder;
+
+ UInt64 m_PackSize;
+
+ unsigned m_NumChannels;
+ NMultimedia::CFilter2 m_MmFilter;
+
+ Byte m_LastLevels[kMaxTableSize];
+
+
+ void InitStructures();
+ UInt32 ReadBits(unsigned numBits);
+ bool ReadTables();
+ bool ReadLastTables();
+
+ bool DecodeMm(UInt32 pos);
+ bool DecodeLz(Int32 pos);
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+
+public:
+ CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Rar3Decoder.cpp b/CPP/7zip/Compress/Rar3Decoder.cpp
new file mode 100644
index 0000000..a4943ad
--- /dev/null
+++ b/CPP/7zip/Compress/Rar3Decoder.cpp
@@ -0,0 +1,935 @@
+// Rar3Decoder.cpp
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+/* This code uses Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "Rar3Decoder.h"
+
+namespace NCompress {
+namespace NRar3 {
+
+static const UInt32 kNumAlignReps = 15;
+
+static const UInt32 kSymbolReadTable = 256;
+static const UInt32 kSymbolRep = 259;
+
+static const Byte kDistDirectBits[kDistTableSize] =
+ {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14,15,15,
+ 16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+ 18,18,18,18,18,18,18,18,18,18,18,18};
+
+static const Byte kLen2DistStarts[kNumLen2Symbols] = {0,4,8,16,32,64,128,192};
+static const Byte kLen2DistDirectBits[kNumLen2Symbols] = {2,2,3, 4, 5, 6, 6, 6};
+
+static const UInt32 kDistLimit3 = 0x2000 - 2;
+static const UInt32 kDistLimit4 = 0x40000 - 2;
+
+static const UInt32 kNormalMatchMinLen = 3;
+
+static const UInt32 kVmDataSizeMax = 1 << 16;
+static const UInt32 kVmCodeSizeMax = 1 << 16;
+
+extern "C" {
+
+static Byte Wrap_ReadByte(IByteInPtr pp) throw()
+{
+ CByteIn *p = Z7_CONTAINER_FROM_VTBL_CLS(pp, CByteIn, IByteIn_obj);
+ return p->BitDecoder.Stream.ReadByte();
+}
+
+static Byte Wrap_ReadBits8(IByteInPtr pp) throw()
+{
+ CByteIn *p = Z7_CONTAINER_FROM_VTBL_CLS(pp, CByteIn, IByteIn_obj);
+ return (Byte)p->BitDecoder.ReadByteFromAligned();
+}
+
+}
+
+
+CDecoder::CDecoder():
+ _window(NULL),
+ _winPos(0),
+ _wrPtr(0),
+ _lzSize(0),
+ _writtenFileSize(0),
+ _vmData(NULL),
+ _vmCode(NULL),
+ _isSolid(false),
+ _solidAllowed(false)
+{
+ Ppmd7_Construct(&_ppmd);
+
+ UInt32 start = 0;
+ for (UInt32 i = 0; i < kDistTableSize; i++)
+ {
+ kDistStart[i] = start;
+ start += ((UInt32)1 << kDistDirectBits[i]);
+ }
+}
+
+CDecoder::~CDecoder()
+{
+ InitFilters();
+ ::MidFree(_vmData);
+ ::MidFree(_window);
+ Ppmd7_Free(&_ppmd, &g_BigAlloc);
+}
+
+HRESULT CDecoder::WriteDataToStream(const Byte *data, UInt32 size)
+{
+ return WriteStream(_outStream, data, size);
+}
+
+HRESULT CDecoder::WriteData(const Byte *data, UInt32 size)
+{
+ HRESULT res = S_OK;
+ if (_writtenFileSize < _unpackSize)
+ {
+ UInt32 curSize = size;
+ UInt64 remain = _unpackSize - _writtenFileSize;
+ if (remain < curSize)
+ curSize = (UInt32)remain;
+ res = WriteDataToStream(data, curSize);
+ }
+ _writtenFileSize += size;
+ return res;
+}
+
+HRESULT CDecoder::WriteArea(UInt32 startPtr, UInt32 endPtr)
+{
+ if (startPtr <= endPtr)
+ return WriteData(_window + startPtr, endPtr - startPtr);
+ RINOK(WriteData(_window + startPtr, kWindowSize - startPtr))
+ return WriteData(_window, endPtr);
+}
+
+void CDecoder::ExecuteFilter(unsigned tempFilterIndex, NVm::CBlockRef &outBlockRef)
+{
+ CTempFilter *tempFilter = _tempFilters[tempFilterIndex];
+ tempFilter->InitR[6] = (UInt32)_writtenFileSize;
+ NVm::SetValue32(&tempFilter->GlobalData[0x24], (UInt32)_writtenFileSize);
+ NVm::SetValue32(&tempFilter->GlobalData[0x28], (UInt32)(_writtenFileSize >> 32));
+ CFilter *filter = _filters[tempFilter->FilterIndex];
+ if (!filter->IsSupported)
+ _unsupportedFilter = true;
+ if (!_vm.Execute(filter, tempFilter, outBlockRef, filter->GlobalData))
+ _unsupportedFilter = true;
+ delete tempFilter;
+ _tempFilters[tempFilterIndex] = NULL;
+ _numEmptyTempFilters++;
+}
+
+HRESULT CDecoder::WriteBuf()
+{
+ UInt32 writtenBorder = _wrPtr;
+ UInt32 writeSize = (_winPos - writtenBorder) & kWindowMask;
+ FOR_VECTOR (i, _tempFilters)
+ {
+ CTempFilter *filter = _tempFilters[i];
+ if (!filter)
+ continue;
+ if (filter->NextWindow)
+ {
+ filter->NextWindow = false;
+ continue;
+ }
+ UInt32 blockStart = filter->BlockStart;
+ UInt32 blockSize = filter->BlockSize;
+ if (((blockStart - writtenBorder) & kWindowMask) < writeSize)
+ {
+ if (writtenBorder != blockStart)
+ {
+ RINOK(WriteArea(writtenBorder, blockStart))
+ writtenBorder = blockStart;
+ writeSize = (_winPos - writtenBorder) & kWindowMask;
+ }
+ if (blockSize <= writeSize)
+ {
+ UInt32 blockEnd = (blockStart + blockSize) & kWindowMask;
+ if (blockStart < blockEnd || blockEnd == 0)
+ _vm.SetMemory(0, _window + blockStart, blockSize);
+ else
+ {
+ UInt32 tailSize = kWindowSize - blockStart;
+ _vm.SetMemory(0, _window + blockStart, tailSize);
+ _vm.SetMemory(tailSize, _window, blockEnd);
+ }
+ NVm::CBlockRef outBlockRef;
+ ExecuteFilter(i, outBlockRef);
+ while (i + 1 < _tempFilters.Size())
+ {
+ CTempFilter *nextFilter = _tempFilters[i + 1];
+ if (!nextFilter
+ || nextFilter->BlockStart != blockStart
+ || nextFilter->BlockSize != outBlockRef.Size
+ || nextFilter->NextWindow)
+ break;
+ _vm.SetMemory(0, _vm.GetDataPointer(outBlockRef.Offset), outBlockRef.Size);
+ ExecuteFilter(++i, outBlockRef);
+ }
+ WriteDataToStream(_vm.GetDataPointer(outBlockRef.Offset), outBlockRef.Size);
+ _writtenFileSize += outBlockRef.Size;
+ writtenBorder = blockEnd;
+ writeSize = (_winPos - writtenBorder) & kWindowMask;
+ }
+ else
+ {
+ for (unsigned j = i; j < _tempFilters.Size(); j++)
+ {
+ CTempFilter *filter2 = _tempFilters[j];
+ if (filter2 && filter2->NextWindow)
+ filter2->NextWindow = false;
+ }
+ _wrPtr = writtenBorder;
+ return S_OK; // check it
+ }
+ }
+ }
+
+ _wrPtr = _winPos;
+ return WriteArea(writtenBorder, _winPos);
+}
+
+void CDecoder::InitFilters()
+{
+ _lastFilter = 0;
+ _numEmptyTempFilters = 0;
+ unsigned i;
+ for (i = 0; i < _tempFilters.Size(); i++)
+ delete _tempFilters[i];
+ _tempFilters.Clear();
+ for (i = 0; i < _filters.Size(); i++)
+ delete _filters[i];
+ _filters.Clear();
+}
+
+static const unsigned MAX_UNPACK_FILTERS = 8192;
+
+bool CDecoder::AddVmCode(UInt32 firstByte, UInt32 codeSize)
+{
+ CMemBitDecoder inp;
+ inp.Init(_vmData, codeSize);
+
+ UInt32 filterIndex;
+
+ if (firstByte & 0x80)
+ {
+ filterIndex = inp.ReadEncodedUInt32();
+ if (filterIndex == 0)
+ InitFilters();
+ else
+ filterIndex--;
+ }
+ else
+ filterIndex = _lastFilter;
+
+ if (filterIndex > (UInt32)_filters.Size())
+ return false;
+ _lastFilter = filterIndex;
+ bool newFilter = (filterIndex == (UInt32)_filters.Size());
+
+ CFilter *filter;
+ if (newFilter)
+ {
+ // check if too many filters
+ if (filterIndex > MAX_UNPACK_FILTERS)
+ return false;
+ filter = new CFilter;
+ _filters.Add(filter);
+ }
+ else
+ {
+ filter = _filters[filterIndex];
+ filter->ExecCount++;
+ }
+
+ if (_numEmptyTempFilters != 0)
+ {
+ unsigned num = _tempFilters.Size();
+ CTempFilter **tempFilters = &_tempFilters.Front();
+
+ unsigned w = 0;
+ for (unsigned i = 0; i < num; i++)
+ {
+ CTempFilter *tf = tempFilters[i];
+ if (tf)
+ tempFilters[w++] = tf;
+ }
+
+ _tempFilters.DeleteFrom(w);
+ _numEmptyTempFilters = 0;
+ }
+
+ if (_tempFilters.Size() > MAX_UNPACK_FILTERS)
+ return false;
+ CTempFilter *tempFilter = new CTempFilter;
+ _tempFilters.Add(tempFilter);
+ tempFilter->FilterIndex = filterIndex;
+
+ UInt32 blockStart = inp.ReadEncodedUInt32();
+ if (firstByte & 0x40)
+ blockStart += 258;
+ tempFilter->BlockStart = (blockStart + _winPos) & kWindowMask;
+ if (firstByte & 0x20)
+ filter->BlockSize = inp.ReadEncodedUInt32();
+ tempFilter->BlockSize = filter->BlockSize;
+ tempFilter->NextWindow = _wrPtr != _winPos && ((_wrPtr - _winPos) & kWindowMask) <= blockStart;
+
+ memset(tempFilter->InitR, 0, sizeof(tempFilter->InitR));
+ tempFilter->InitR[3] = NVm::kGlobalOffset;
+ tempFilter->InitR[4] = tempFilter->BlockSize;
+ tempFilter->InitR[5] = filter->ExecCount;
+ if (firstByte & 0x10)
+ {
+ UInt32 initMask = inp.ReadBits(NVm::kNumGpRegs);
+ for (unsigned i = 0; i < NVm::kNumGpRegs; i++)
+ if (initMask & (1 << i))
+ tempFilter->InitR[i] = inp.ReadEncodedUInt32();
+ }
+
+ bool isOK = true;
+ if (newFilter)
+ {
+ UInt32 vmCodeSize = inp.ReadEncodedUInt32();
+ if (vmCodeSize >= kVmCodeSizeMax || vmCodeSize == 0)
+ return false;
+ for (UInt32 i = 0; i < vmCodeSize; i++)
+ _vmCode[i] = (Byte)inp.ReadBits(8);
+ isOK = filter->PrepareProgram(_vmCode, vmCodeSize);
+ }
+
+ {
+ Byte *globalData = &tempFilter->GlobalData[0];
+ for (unsigned i = 0; i < NVm::kNumGpRegs; i++)
+ NVm::SetValue32(&globalData[i * 4], tempFilter->InitR[i]);
+ NVm::SetValue32(&globalData[NVm::NGlobalOffset::kBlockSize], tempFilter->BlockSize);
+ NVm::SetValue32(&globalData[NVm::NGlobalOffset::kBlockPos], 0); // It was commented. why?
+ NVm::SetValue32(&globalData[NVm::NGlobalOffset::kExecCount], filter->ExecCount);
+ }
+
+ if (firstByte & 8)
+ {
+ UInt32 dataSize = inp.ReadEncodedUInt32();
+ if (dataSize > NVm::kGlobalSize - NVm::kFixedGlobalSize)
+ return false;
+ CRecordVector<Byte> &globalData = tempFilter->GlobalData;
+ unsigned requiredSize = (unsigned)(dataSize + NVm::kFixedGlobalSize);
+ if (globalData.Size() < requiredSize)
+ globalData.ChangeSize_KeepData(requiredSize);
+ Byte *dest = &globalData[NVm::kFixedGlobalSize];
+ for (UInt32 i = 0; i < dataSize; i++)
+ dest[i] = (Byte)inp.ReadBits(8);
+ }
+
+ return isOK;
+}
+
+bool CDecoder::ReadVmCodeLZ()
+{
+ UInt32 firstByte = ReadBits(8);
+ UInt32 len = (firstByte & 7) + 1;
+ if (len == 7)
+ len = ReadBits(8) + 7;
+ else if (len == 8)
+ len = ReadBits(16);
+ if (len > kVmDataSizeMax)
+ return false;
+ for (UInt32 i = 0; i < len; i++)
+ _vmData[i] = (Byte)ReadBits(8);
+ return AddVmCode(firstByte, len);
+}
+
+
+// int CDecoder::DecodePpmSymbol() { return Ppmd7a_DecodeSymbol(&_ppmd); }
+#define DecodePpmSymbol() Ppmd7a_DecodeSymbol(&_ppmd)
+
+
+bool CDecoder::ReadVmCodePPM()
+{
+ const int firstByte = DecodePpmSymbol();
+ if (firstByte < 0)
+ return false;
+ UInt32 len = (firstByte & 7) + 1;
+ if (len == 7)
+ {
+ const int b1 = DecodePpmSymbol();
+ if (b1 < 0)
+ return false;
+ len = (unsigned)b1 + 7;
+ }
+ else if (len == 8)
+ {
+ const int b1 = DecodePpmSymbol();
+ if (b1 < 0)
+ return false;
+ const int b2 = DecodePpmSymbol();
+ if (b2 < 0)
+ return false;
+ len = (unsigned)b1 * 256 + (unsigned)b2;
+ }
+ if (len > kVmDataSizeMax)
+ return false;
+ if (InputEofError_Fast())
+ return false;
+ for (UInt32 i = 0; i < len; i++)
+ {
+ const int b = DecodePpmSymbol();
+ if (b < 0)
+ return false;
+ _vmData[i] = (Byte)b;
+ }
+ return AddVmCode((unsigned)firstByte, len);
+}
+
+#define RIF(x) { if (!(x)) return S_FALSE; }
+
+UInt32 CDecoder::ReadBits(unsigned numBits) { return m_InBitStream.BitDecoder.ReadBits(numBits); }
+
+// ---------- PPM ----------
+
+HRESULT CDecoder::InitPPM()
+{
+ unsigned maxOrder = (unsigned)ReadBits(7);
+
+ const bool reset = ((maxOrder & 0x20) != 0);
+ UInt32 maxMB = 0;
+ if (reset)
+ maxMB = (Byte)Wrap_ReadBits8(&m_InBitStream.IByteIn_obj);
+ else
+ {
+ if (PpmError || !Ppmd7_WasAllocated(&_ppmd))
+ return S_FALSE;
+ }
+ if (maxOrder & 0x40)
+ PpmEscChar = (Byte)Wrap_ReadBits8(&m_InBitStream.IByteIn_obj);
+
+ _ppmd.rc.dec.Stream = &m_InBitStream.IByteIn_obj;
+ m_InBitStream.IByteIn_obj.Read = Wrap_ReadBits8;
+
+ Ppmd7a_RangeDec_Init(&_ppmd.rc.dec);
+
+ m_InBitStream.IByteIn_obj.Read = Wrap_ReadByte;
+
+ if (reset)
+ {
+ PpmError = true;
+ maxOrder = (maxOrder & 0x1F) + 1;
+ if (maxOrder > 16)
+ maxOrder = 16 + (maxOrder - 16) * 3;
+ if (maxOrder == 1)
+ {
+ Ppmd7_Free(&_ppmd, &g_BigAlloc);
+ return S_FALSE;
+ }
+ if (!Ppmd7_Alloc(&_ppmd, (maxMB + 1) << 20, &g_BigAlloc))
+ return E_OUTOFMEMORY;
+ Ppmd7_Init(&_ppmd, maxOrder);
+ PpmError = false;
+ }
+ return S_OK;
+}
+
+
+HRESULT CDecoder::DecodePPM(Int32 num, bool &keepDecompressing)
+{
+ keepDecompressing = false;
+ if (PpmError)
+ return S_FALSE;
+ do
+ {
+ if (((_wrPtr - _winPos) & kWindowMask) < 260 && _wrPtr != _winPos)
+ {
+ RINOK(WriteBuf())
+ if (_writtenFileSize > _unpackSize)
+ {
+ keepDecompressing = false;
+ return S_OK;
+ }
+ }
+ if (InputEofError_Fast())
+ return false;
+ const int c = DecodePpmSymbol();
+ if (c < 0)
+ {
+ PpmError = true;
+ return S_FALSE;
+ }
+ if (c == PpmEscChar)
+ {
+ const int nextCh = DecodePpmSymbol();
+ if (nextCh < 0)
+ {
+ PpmError = true;
+ return S_FALSE;
+ }
+ if (nextCh == 0)
+ return ReadTables(keepDecompressing);
+ if (nextCh == 2 || nextCh == -1)
+ return S_OK;
+ if (nextCh == 3)
+ {
+ if (!ReadVmCodePPM())
+ {
+ PpmError = true;
+ return S_FALSE;
+ }
+ continue;
+ }
+ if (nextCh == 4 || nextCh == 5)
+ {
+ UInt32 dist = 0;
+ UInt32 len = 4;
+ if (nextCh == 4)
+ {
+ for (int i = 0; i < 3; i++)
+ {
+ const int c2 = DecodePpmSymbol();
+ if (c2 < 0)
+ {
+ PpmError = true;
+ return S_FALSE;
+ }
+ dist = (dist << 8) + (Byte)c2;
+ }
+ dist++;
+ len += 28;
+ }
+ const int c2 = DecodePpmSymbol();
+ if (c2 < 0)
+ {
+ PpmError = true;
+ return S_FALSE;
+ }
+ len += (unsigned)c2;
+ if (dist >= _lzSize)
+ return S_FALSE;
+ CopyBlock(dist, len);
+ num -= (Int32)len;
+ continue;
+ }
+ }
+ PutByte((Byte)c);
+ num--;
+ }
+ while (num >= 0);
+ keepDecompressing = true;
+ return S_OK;
+}
+
+// ---------- LZ ----------
+
+HRESULT CDecoder::ReadTables(bool &keepDecompressing)
+{
+ keepDecompressing = true;
+ m_InBitStream.BitDecoder.AlignToByte();
+ if (ReadBits(1) != 0)
+ {
+ _lzMode = false;
+ return InitPPM();
+ }
+
+ TablesRead = false;
+ TablesOK = false;
+
+ _lzMode = true;
+ PrevAlignBits = 0;
+ PrevAlignCount = 0;
+
+ Byte levelLevels[kLevelTableSize];
+ Byte lens[kTablesSizesSum];
+
+ if (ReadBits(1) == 0)
+ memset(m_LastLevels, 0, kTablesSizesSum);
+
+ unsigned i;
+
+ for (i = 0; i < kLevelTableSize; i++)
+ {
+ const UInt32 len = ReadBits(4);
+ if (len == 15)
+ {
+ UInt32 zeroCount = ReadBits(4);
+ if (zeroCount != 0)
+ {
+ zeroCount += 2;
+ while (zeroCount-- > 0 && i < kLevelTableSize)
+ levelLevels[i++]=0;
+ i--;
+ continue;
+ }
+ }
+ levelLevels[i] = (Byte)len;
+ }
+
+ RIF(m_LevelDecoder.Build(levelLevels))
+
+ i = 0;
+
+ do
+ {
+ const UInt32 sym = m_LevelDecoder.Decode(&m_InBitStream.BitDecoder);
+ if (sym < 16)
+ {
+ lens[i] = Byte((sym + m_LastLevels[i]) & 15);
+ i++;
+ }
+ else if (sym > kLevelTableSize)
+ return S_FALSE;
+ else
+ {
+ unsigned num = ((sym - 16) & 1) * 4;
+ num += num + 3 + (unsigned)ReadBits(num + 3);
+ num += i;
+ if (num > kTablesSizesSum)
+ num = kTablesSizesSum;
+ Byte v = 0;
+ if (sym < 16 + 2)
+ {
+ if (i == 0)
+ return S_FALSE;
+ v = lens[(size_t)i - 1];
+ }
+ do
+ lens[i++] = v;
+ while (i < num);
+ }
+ }
+ while (i < kTablesSizesSum);
+
+ if (InputEofError())
+ return S_FALSE;
+
+ TablesRead = true;
+
+ // original code has check here:
+ /*
+ if (InAddr > ReadTop)
+ {
+ keepDecompressing = false;
+ return true;
+ }
+ */
+
+ RIF(m_MainDecoder.Build(&lens[0]))
+ RIF(m_DistDecoder.Build(&lens[kMainTableSize]))
+ RIF(m_AlignDecoder.Build(&lens[kMainTableSize + kDistTableSize]))
+ RIF(m_LenDecoder.Build(&lens[kMainTableSize + kDistTableSize + kAlignTableSize]))
+
+ memcpy(m_LastLevels, lens, kTablesSizesSum);
+
+ TablesOK = true;
+
+ return S_OK;
+}
+
+/*
+class CCoderReleaser
+{
+ CDecoder *m_Coder;
+public:
+ CCoderReleaser(CDecoder *coder): m_Coder(coder) {}
+ ~CCoderReleaser()
+ {
+ m_Coder->ReleaseStreams();
+ }
+};
+*/
+
+HRESULT CDecoder::ReadEndOfBlock(bool &keepDecompressing)
+{
+ if (ReadBits(1) == 0)
+ {
+ // new file
+ keepDecompressing = false;
+ TablesRead = (ReadBits(1) == 0);
+ return S_OK;
+ }
+ TablesRead = false;
+ return ReadTables(keepDecompressing);
+}
+
+
+HRESULT CDecoder::DecodeLZ(bool &keepDecompressing)
+{
+ UInt32 rep0 = _reps[0];
+ UInt32 rep1 = _reps[1];
+ UInt32 rep2 = _reps[2];
+ UInt32 rep3 = _reps[3];
+ UInt32 len = _lastLength;
+ for (;;)
+ {
+ if (((_wrPtr - _winPos) & kWindowMask) < 260 && _wrPtr != _winPos)
+ {
+ RINOK(WriteBuf())
+ if (_writtenFileSize > _unpackSize)
+ {
+ keepDecompressing = false;
+ return S_OK;
+ }
+ }
+
+ if (InputEofError_Fast())
+ return S_FALSE;
+
+ UInt32 sym = m_MainDecoder.Decode(&m_InBitStream.BitDecoder);
+ if (sym < 256)
+ {
+ PutByte((Byte)sym);
+ continue;
+ }
+ else if (sym == kSymbolReadTable)
+ {
+ RINOK(ReadEndOfBlock(keepDecompressing))
+ break;
+ }
+ else if (sym == 257)
+ {
+ if (!ReadVmCodeLZ())
+ return S_FALSE;
+ continue;
+ }
+ else if (sym == 258)
+ {
+ if (len == 0)
+ return S_FALSE;
+ }
+ else if (sym < kSymbolRep + 4)
+ {
+ if (sym != kSymbolRep)
+ {
+ UInt32 dist;
+ if (sym == kSymbolRep + 1)
+ dist = rep1;
+ else
+ {
+ if (sym == kSymbolRep + 2)
+ dist = rep2;
+ else
+ {
+ dist = rep3;
+ rep3 = rep2;
+ }
+ rep2 = rep1;
+ }
+ rep1 = rep0;
+ rep0 = dist;
+ }
+
+ const UInt32 sym2 = m_LenDecoder.Decode(&m_InBitStream.BitDecoder);
+ if (sym2 >= kLenTableSize)
+ return S_FALSE;
+ len = 2 + sym2;
+ if (sym2 >= 8)
+ {
+ unsigned num = (sym2 >> 2) - 1;
+ len = 2 + ((4 + (sym2 & 3)) << num) + m_InBitStream.BitDecoder.ReadBits_upto8(num);
+ }
+ }
+ else
+ {
+ rep3 = rep2;
+ rep2 = rep1;
+ rep1 = rep0;
+ if (sym < 271)
+ {
+ sym -= 263;
+ rep0 = kLen2DistStarts[sym] + m_InBitStream.BitDecoder.ReadBits_upto8(kLen2DistDirectBits[sym]);
+ len = 2;
+ }
+ else if (sym < 299)
+ {
+ sym -= 271;
+ len = kNormalMatchMinLen + sym;
+ if (sym >= 8)
+ {
+ const unsigned num = (sym >> 2) - 1;
+ len = kNormalMatchMinLen + ((4 + (sym & 3)) << num) + m_InBitStream.BitDecoder.ReadBits_upto8(num);
+ }
+ const UInt32 sym2 = m_DistDecoder.Decode(&m_InBitStream.BitDecoder);
+ if (sym2 >= kDistTableSize)
+ return S_FALSE;
+ rep0 = kDistStart[sym2];
+ unsigned numBits = kDistDirectBits[sym2];
+ if (sym2 >= (kNumAlignBits * 2) + 2)
+ {
+ if (numBits > kNumAlignBits)
+ rep0 += (m_InBitStream.BitDecoder.ReadBits(numBits - kNumAlignBits) << kNumAlignBits);
+ if (PrevAlignCount > 0)
+ {
+ PrevAlignCount--;
+ rep0 += PrevAlignBits;
+ }
+ else
+ {
+ const UInt32 sym3 = m_AlignDecoder.Decode(&m_InBitStream.BitDecoder);
+ if (sym3 < (1 << kNumAlignBits))
+ {
+ rep0 += sym3;
+ PrevAlignBits = sym3;
+ }
+ else if (sym3 == (1 << kNumAlignBits))
+ {
+ PrevAlignCount = kNumAlignReps;
+ rep0 += PrevAlignBits;
+ }
+ else
+ return S_FALSE;
+ }
+ }
+ else
+ rep0 += m_InBitStream.BitDecoder.ReadBits_upto8(numBits);
+ len += ((UInt32)(kDistLimit4 - rep0) >> 31) + ((UInt32)(kDistLimit3 - rep0) >> 31);
+ }
+ else
+ return S_FALSE;
+ }
+ if (rep0 >= _lzSize)
+ return S_FALSE;
+ CopyBlock(rep0, len);
+ }
+ _reps[0] = rep0;
+ _reps[1] = rep1;
+ _reps[2] = rep2;
+ _reps[3] = rep3;
+ _lastLength = len;
+
+ return S_OK;
+}
+
+
+HRESULT CDecoder::CodeReal(ICompressProgressInfo *progress)
+{
+ _writtenFileSize = 0;
+ _unsupportedFilter = false;
+
+ if (!_isSolid)
+ {
+ _lzSize = 0;
+ _winPos = 0;
+ _wrPtr = 0;
+ for (unsigned i = 0; i < kNumReps; i++)
+ _reps[i] = 0;
+ _lastLength = 0;
+ memset(m_LastLevels, 0, kTablesSizesSum);
+ TablesRead = false;
+ PpmEscChar = 2;
+ PpmError = true;
+ InitFilters();
+ // _errorMode = false;
+ }
+
+ /*
+ if (_errorMode)
+ return S_FALSE;
+ */
+
+ if (!_isSolid || !TablesRead)
+ {
+ bool keepDecompressing;
+ RINOK(ReadTables(keepDecompressing))
+ if (!keepDecompressing)
+ {
+ _solidAllowed = true;
+ return S_OK;
+ }
+ }
+
+ for (;;)
+ {
+ bool keepDecompressing;
+ if (_lzMode)
+ {
+ if (!TablesOK)
+ return S_FALSE;
+ RINOK(DecodeLZ(keepDecompressing))
+ }
+ else
+ {
+ RINOK(DecodePPM(1 << 18, keepDecompressing))
+ }
+
+ if (InputEofError())
+ return S_FALSE;
+
+ const UInt64 packSize = m_InBitStream.BitDecoder.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &_writtenFileSize))
+ if (!keepDecompressing)
+ break;
+ }
+
+ _solidAllowed = true;
+
+ RINOK(WriteBuf())
+ const UInt64 packSize = m_InBitStream.BitDecoder.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &_writtenFileSize))
+ if (_writtenFileSize < _unpackSize)
+ return S_FALSE;
+
+ if (_unsupportedFilter)
+ return E_NOTIMPL;
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try
+ {
+ if (!inSize)
+ return E_INVALIDARG;
+
+ if (_isSolid && !_solidAllowed)
+ return S_FALSE;
+ _solidAllowed = false;
+
+ if (!_vmData)
+ {
+ _vmData = (Byte *)::MidAlloc(kVmDataSizeMax + kVmCodeSizeMax);
+ if (!_vmData)
+ return E_OUTOFMEMORY;
+ _vmCode = _vmData + kVmDataSizeMax;
+ }
+
+ if (!_window)
+ {
+ _window = (Byte *)::MidAlloc(kWindowSize);
+ if (!_window)
+ return E_OUTOFMEMORY;
+ }
+ if (!m_InBitStream.BitDecoder.Create(1 << 20))
+ return E_OUTOFMEMORY;
+ if (!_vm.Create())
+ return E_OUTOFMEMORY;
+
+
+ m_InBitStream.BitDecoder.SetStream(inStream);
+ m_InBitStream.BitDecoder.Init();
+ _outStream = outStream;
+
+ // CCoderReleaser coderReleaser(this);
+ _unpackSize = outSize ? *outSize : (UInt64)(Int64)-1;
+ return CodeReal(progress);
+ }
+ catch(const CInBufferException &e) { /* _errorMode = true; */ return e.ErrorCode; }
+ catch(...) { /* _errorMode = true; */ return S_FALSE; }
+ // CNewException is possible here. But probably CNewException is caused
+ // by error in data stream.
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ if (size < 1)
+ return E_INVALIDARG;
+ _isSolid = ((data[0] & 1) != 0);
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Compress/Rar3Decoder.h b/CPP/7zip/Compress/Rar3Decoder.h
new file mode 100644
index 0000000..4711052
--- /dev/null
+++ b/CPP/7zip/Compress/Rar3Decoder.h
@@ -0,0 +1,275 @@
+// Rar3Decoder.h
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+/* This code uses Carryless rangecoder (1999): Dmitry Subbotin : Public domain */
+
+#ifndef ZIP7_INC_COMPRESS_RAR3_DECODER_H
+#define ZIP7_INC_COMPRESS_RAR3_DECODER_H
+
+#include "../../../C/Ppmd7.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitmDecoder.h"
+#include "HuffmanDecoder.h"
+#include "Rar3Vm.h"
+
+namespace NCompress {
+namespace NRar3 {
+
+const UInt32 kWindowSize = 1 << 22;
+const UInt32 kWindowMask = (kWindowSize - 1);
+
+const UInt32 kNumReps = 4;
+const UInt32 kNumLen2Symbols = 8;
+const UInt32 kLenTableSize = 28;
+const UInt32 kMainTableSize = 256 + 1 + 1 + 1 + kNumReps + kNumLen2Symbols + kLenTableSize;
+const UInt32 kDistTableSize = 60;
+
+const unsigned kNumAlignBits = 4;
+const UInt32 kAlignTableSize = (1 << kNumAlignBits) + 1;
+
+const UInt32 kLevelTableSize = 20;
+
+const UInt32 kTablesSizesSum = kMainTableSize + kDistTableSize + kAlignTableSize + kLenTableSize;
+
+class CBitDecoder
+{
+ UInt32 _value;
+ unsigned _bitPos;
+public:
+ CInBuffer Stream;
+
+ bool Create(UInt32 bufSize) { return Stream.Create(bufSize); }
+ void SetStream(ISequentialInStream *inStream) { Stream.SetStream(inStream);}
+
+ void Init()
+ {
+ Stream.Init();
+ _bitPos = 0;
+ _value = 0;
+ }
+
+ bool ExtraBitsWereRead() const
+ {
+ return (Stream.NumExtraBytes > 4 || _bitPos < (Stream.NumExtraBytes << 3));
+ }
+
+ UInt64 GetProcessedSize() const { return Stream.GetProcessedSize() - (_bitPos >> 3); }
+
+ void AlignToByte()
+ {
+ _bitPos &= ~(unsigned)7;
+ _value = _value & ((1 << _bitPos) - 1);
+ }
+
+ UInt32 GetValue(unsigned numBits)
+ {
+ if (_bitPos < numBits)
+ {
+ _bitPos += 8;
+ _value = (_value << 8) | Stream.ReadByte();
+ if (_bitPos < numBits)
+ {
+ _bitPos += 8;
+ _value = (_value << 8) | Stream.ReadByte();
+ }
+ }
+ return _value >> (_bitPos - numBits);
+ }
+
+ void MovePos(unsigned numBits)
+ {
+ _bitPos -= numBits;
+ _value = _value & ((1 << _bitPos) - 1);
+ }
+
+ UInt32 ReadBits(unsigned numBits)
+ {
+ UInt32 res = GetValue(numBits);
+ MovePos(numBits);
+ return res;
+ }
+
+ UInt32 ReadBits_upto8(unsigned numBits)
+ {
+ if (_bitPos < numBits)
+ {
+ _bitPos += 8;
+ _value = (_value << 8) | Stream.ReadByte();
+ }
+ _bitPos -= numBits;
+ UInt32 res = _value >> _bitPos;
+ _value = _value & ((1 << _bitPos) - 1);
+ return res;
+ }
+
+ Byte ReadByteFromAligned()
+ {
+ if (_bitPos == 0)
+ return Stream.ReadByte();
+ unsigned bitsPos = _bitPos - 8;
+ Byte b = (Byte)(_value >> bitsPos);
+ _value = _value & ((1 << bitsPos) - 1);
+ _bitPos = bitsPos;
+ return b;
+ }
+};
+
+
+struct CByteIn
+{
+ IByteIn IByteIn_obj;
+ CBitDecoder BitDecoder;
+};
+
+
+struct CFilter: public NVm::CProgram
+{
+ CRecordVector<Byte> GlobalData;
+ UInt32 BlockStart;
+ UInt32 BlockSize;
+ UInt32 ExecCount;
+
+ CFilter(): BlockStart(0), BlockSize(0), ExecCount(0) {}
+};
+
+struct CTempFilter: public NVm::CProgramInitState
+{
+ UInt32 BlockStart;
+ UInt32 BlockSize;
+ bool NextWindow;
+
+ UInt32 FilterIndex;
+
+ CTempFilter()
+ {
+ // all filters must contain at least FixedGlobal block
+ AllocateEmptyFixedGlobal();
+ }
+};
+
+const unsigned kNumHuffmanBits = 15;
+
+Z7_CLASS_IMP_NOQIB_2(
+ CDecoder
+ , ICompressCoder
+ , ICompressSetDecoderProperties2
+)
+ CByteIn m_InBitStream;
+ Byte *_window;
+ UInt32 _winPos;
+ UInt32 _wrPtr;
+ UInt64 _lzSize;
+ UInt64 _unpackSize;
+ UInt64 _writtenFileSize; // if it's > _unpackSize, then _unpackSize only written
+ ISequentialOutStream *_outStream;
+ NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> m_MainDecoder;
+ UInt32 kDistStart[kDistTableSize];
+ NHuffman::CDecoder<kNumHuffmanBits, kDistTableSize> m_DistDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kAlignTableSize> m_AlignDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kLenTableSize> m_LenDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize> m_LevelDecoder;
+
+ UInt32 _reps[kNumReps];
+ UInt32 _lastLength;
+
+ Byte m_LastLevels[kTablesSizesSum];
+
+ Byte *_vmData;
+ Byte *_vmCode;
+ NVm::CVm _vm;
+ CRecordVector<CFilter *> _filters;
+ CRecordVector<CTempFilter *> _tempFilters;
+ unsigned _numEmptyTempFilters;
+ UInt32 _lastFilter;
+
+ bool _isSolid;
+ bool _solidAllowed;
+ // bool _errorMode;
+
+ bool _lzMode;
+ bool _unsupportedFilter;
+
+ UInt32 PrevAlignBits;
+ UInt32 PrevAlignCount;
+
+ bool TablesRead;
+ bool TablesOK;
+
+ CPpmd7 _ppmd;
+ int PpmEscChar;
+ bool PpmError;
+
+ HRESULT WriteDataToStream(const Byte *data, UInt32 size);
+ HRESULT WriteData(const Byte *data, UInt32 size);
+ HRESULT WriteArea(UInt32 startPtr, UInt32 endPtr);
+ void ExecuteFilter(unsigned tempFilterIndex, NVm::CBlockRef &outBlockRef);
+ HRESULT WriteBuf();
+
+ void InitFilters();
+ bool AddVmCode(UInt32 firstByte, UInt32 codeSize);
+ bool ReadVmCodeLZ();
+ bool ReadVmCodePPM();
+
+ UInt32 ReadBits(unsigned numBits);
+
+ HRESULT InitPPM();
+ // int DecodePpmSymbol();
+ HRESULT DecodePPM(Int32 num, bool &keepDecompressing);
+
+ HRESULT ReadTables(bool &keepDecompressing);
+ HRESULT ReadEndOfBlock(bool &keepDecompressing);
+ HRESULT DecodeLZ(bool &keepDecompressing);
+ HRESULT CodeReal(ICompressProgressInfo *progress);
+
+ bool InputEofError() const { return m_InBitStream.BitDecoder.ExtraBitsWereRead(); }
+ bool InputEofError_Fast() const { return (m_InBitStream.BitDecoder.Stream.NumExtraBytes > 2); }
+
+ void CopyBlock(UInt32 dist, UInt32 len)
+ {
+ _lzSize += len;
+ UInt32 pos = (_winPos - dist - 1) & kWindowMask;
+ Byte *window = _window;
+ UInt32 winPos = _winPos;
+ if (kWindowSize - winPos > len && kWindowSize - pos > len)
+ {
+ const Byte *src = window + pos;
+ Byte *dest = window + winPos;
+ _winPos += len;
+ do
+ *dest++ = *src++;
+ while (--len != 0);
+ return;
+ }
+ do
+ {
+ window[winPos] = window[pos];
+ winPos = (winPos + 1) & kWindowMask;
+ pos = (pos + 1) & kWindowMask;
+ }
+ while (--len != 0);
+ _winPos = winPos;
+ }
+
+ void PutByte(Byte b)
+ {
+ const UInt32 wp = _winPos;
+ _window[wp] = b;
+ _winPos = (wp + 1) & kWindowMask;
+ _lzSize++;
+ }
+
+public:
+ CDecoder();
+ ~CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/Rar3Vm.cpp b/CPP/7zip/Compress/Rar3Vm.cpp
new file mode 100644
index 0000000..9b728ef
--- /dev/null
+++ b/CPP/7zip/Compress/Rar3Vm.cpp
@@ -0,0 +1,1153 @@
+// Rar3Vm.cpp
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+/*
+Note:
+ Due to performance considerations Rar VM may set Flags C incorrectly
+ for some operands (SHL x, 0, ... ).
+ Check implementation of concrete VM command
+ to see if it sets flags right.
+*/
+
+#include "StdAfx.h"
+
+#include <stdlib.h>
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/Alloc.h"
+
+#include "../../Common/Defs.h"
+
+#include "Rar3Vm.h"
+
+namespace NCompress {
+namespace NRar3 {
+
+UInt32 CMemBitDecoder::ReadBits(unsigned numBits)
+{
+ UInt32 res = 0;
+ for (;;)
+ {
+ const unsigned b = _bitPos < _bitSize ? (unsigned)_data[_bitPos >> 3] : 0;
+ const unsigned avail = (unsigned)(8 - (_bitPos & 7));
+ if (numBits <= avail)
+ {
+ _bitPos += numBits;
+ return res | ((b >> (avail - numBits)) & ((1 << numBits) - 1));
+ }
+ numBits -= avail;
+ res |= (UInt32)(b & ((1 << avail) - 1)) << numBits;
+ _bitPos += avail;
+ }
+}
+
+UInt32 CMemBitDecoder::ReadBit() { return ReadBits(1); }
+
+UInt32 CMemBitDecoder::ReadEncodedUInt32()
+{
+ const unsigned v = (unsigned)ReadBits(2);
+ UInt32 res = ReadBits(4u << v);
+ if (v == 1 && res < 16)
+ res = 0xFFFFFF00 | (res << 4) | ReadBits(4);
+ return res;
+}
+
+namespace NVm {
+
+static const UInt32 kStackRegIndex = kNumRegs - 1;
+
+#ifdef Z7_RARVM_VM_ENABLE
+
+#if defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40400) \
+ || defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30000)
+// enumeration values not explicitly handled in switch
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+
+static const UInt32 FLAG_C = 1;
+static const UInt32 FLAG_Z = 2;
+static const UInt32 FLAG_S = 0x80000000;
+
+static const Byte CF_OP0 = 0;
+static const Byte CF_OP1 = 1;
+static const Byte CF_OP2 = 2;
+static const Byte CF_OPMASK = 3;
+static const Byte CF_BYTEMODE = 4;
+static const Byte CF_JUMP = 8;
+static const Byte CF_PROC = 16;
+static const Byte CF_USEFLAGS = 32;
+static const Byte CF_CHFLAGS = 64;
+
+static const Byte kCmdFlags[]=
+{
+ /* CMD_MOV */ CF_OP2 | CF_BYTEMODE,
+ /* CMD_CMP */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_ADD */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_SUB */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_JZ */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_JNZ */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_INC */ CF_OP1 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_DEC */ CF_OP1 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_JMP */ CF_OP1 | CF_JUMP,
+ /* CMD_XOR */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_AND */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_OR */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_TEST */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_JS */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_JNS */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_JB */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_JBE */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_JA */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_JAE */ CF_OP1 | CF_JUMP | CF_USEFLAGS,
+ /* CMD_PUSH */ CF_OP1,
+ /* CMD_POP */ CF_OP1,
+ /* CMD_CALL */ CF_OP1 | CF_PROC,
+ /* CMD_RET */ CF_OP0 | CF_PROC,
+ /* CMD_NOT */ CF_OP1 | CF_BYTEMODE,
+ /* CMD_SHL */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_SHR */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_SAR */ CF_OP2 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_NEG */ CF_OP1 | CF_BYTEMODE | CF_CHFLAGS,
+ /* CMD_PUSHA */ CF_OP0,
+ /* CMD_POPA */ CF_OP0,
+ /* CMD_PUSHF */ CF_OP0 | CF_USEFLAGS,
+ /* CMD_POPF */ CF_OP0 | CF_CHFLAGS,
+ /* CMD_MOVZX */ CF_OP2,
+ /* CMD_MOVSX */ CF_OP2,
+ /* CMD_XCHG */ CF_OP2 | CF_BYTEMODE,
+ /* CMD_MUL */ CF_OP2 | CF_BYTEMODE,
+ /* CMD_DIV */ CF_OP2 | CF_BYTEMODE,
+ /* CMD_ADC */ CF_OP2 | CF_BYTEMODE | CF_USEFLAGS | CF_CHFLAGS ,
+ /* CMD_SBB */ CF_OP2 | CF_BYTEMODE | CF_USEFLAGS | CF_CHFLAGS ,
+ /* CMD_PRINT */ CF_OP0
+};
+
+#endif
+
+
+CVm::CVm(): Mem(NULL) {}
+
+bool CVm::Create()
+{
+ if (!Mem)
+ Mem = (Byte *)::MyAlloc(kSpaceSize + 4);
+ return (Mem != NULL);
+}
+
+CVm::~CVm()
+{
+ ::MyFree(Mem);
+}
+
+// CVm::Execute can change CProgram object: it clears progarm if VM returns error.
+
+bool CVm::Execute(CProgram *prg, const CProgramInitState *initState,
+ CBlockRef &outBlockRef, CRecordVector<Byte> &outGlobalData)
+{
+ memcpy(R, initState->InitR, sizeof(initState->InitR));
+ R[kStackRegIndex] = kSpaceSize;
+ R[kNumRegs] = 0;
+ Flags = 0;
+
+ const UInt32 globalSize = MyMin((UInt32)initState->GlobalData.Size(), kGlobalSize);
+ if (globalSize != 0)
+ memcpy(Mem + kGlobalOffset, &initState->GlobalData[0], globalSize);
+ UInt32 staticSize = MyMin((UInt32)prg->StaticData.Size(), kGlobalSize - globalSize);
+ if (staticSize != 0)
+ memcpy(Mem + kGlobalOffset + globalSize, &prg->StaticData[0], staticSize);
+
+ bool res = true;
+
+ #ifdef Z7_RARVM_STANDARD_FILTERS
+ if (prg->StandardFilterIndex >= 0)
+ res = ExecuteStandardFilter((unsigned)prg->StandardFilterIndex);
+ else
+ #endif
+ {
+ #ifdef Z7_RARVM_VM_ENABLE
+ res = ExecuteCode(prg);
+ if (!res)
+ {
+ prg->Commands.Clear();
+ prg->Commands.Add(CCommand());
+ prg->Commands.Back().OpCode = CMD_RET;
+ }
+ #else
+ res = false;
+ #endif
+ }
+
+ UInt32 newBlockPos = GetFixedGlobalValue32(NGlobalOffset::kBlockPos) & kSpaceMask;
+ UInt32 newBlockSize = GetFixedGlobalValue32(NGlobalOffset::kBlockSize) & kSpaceMask;
+ if (newBlockPos + newBlockSize >= kSpaceSize)
+ newBlockPos = newBlockSize = 0;
+ outBlockRef.Offset = newBlockPos;
+ outBlockRef.Size = newBlockSize;
+
+ outGlobalData.Clear();
+ UInt32 dataSize = GetFixedGlobalValue32(NGlobalOffset::kGlobalMemOutSize);
+ dataSize = MyMin(dataSize, kGlobalSize - kFixedGlobalSize);
+ if (dataSize != 0)
+ {
+ dataSize += kFixedGlobalSize;
+ outGlobalData.ClearAndSetSize(dataSize);
+ memcpy(&outGlobalData[0], Mem + kGlobalOffset, dataSize);
+ }
+
+ return res;
+}
+
+#ifdef Z7_RARVM_VM_ENABLE
+
+#define SET_IP(IP) \
+ if ((IP) >= numCommands) return true; \
+ if (--maxOpCount <= 0) return false; \
+ cmd = commands + (IP);
+
+#define GET_FLAG_S_B(res) (((res) & 0x80) ? FLAG_S : 0)
+#define SET_IP_OP1 { const UInt32 val = GetOperand32(&cmd->Op1); SET_IP(val) }
+#define FLAGS_UPDATE_SZ Flags = res == 0 ? FLAG_Z : res & FLAG_S
+#define FLAGS_UPDATE_SZ_B Flags = (res & 0xFF) == 0 ? FLAG_Z : GET_FLAG_S_B(res)
+
+UInt32 CVm::GetOperand32(const COperand *op) const
+{
+ switch (op->Type)
+ {
+ case OP_TYPE_REG: return R[op->Data];
+ case OP_TYPE_REGMEM: return GetValue32(&Mem[(op->Base + R[op->Data]) & kSpaceMask]);
+ default: return op->Data;
+ }
+}
+
+void CVm::SetOperand32(const COperand *op, UInt32 val)
+{
+ switch (op->Type)
+ {
+ case OP_TYPE_REG: R[op->Data] = val; return;
+ case OP_TYPE_REGMEM: SetValue32(&Mem[(op->Base + R[op->Data]) & kSpaceMask], val); return;
+ default: break;
+ }
+}
+
+Byte CVm::GetOperand8(const COperand *op) const
+{
+ switch (op->Type)
+ {
+ case OP_TYPE_REG: return (Byte)R[op->Data];
+ case OP_TYPE_REGMEM: return Mem[(op->Base + R[op->Data]) & kSpaceMask];
+ default: return (Byte)op->Data;
+ }
+}
+
+void CVm::SetOperand8(const COperand *op, Byte val)
+{
+ switch (op->Type)
+ {
+ case OP_TYPE_REG: R[op->Data] = (R[op->Data] & 0xFFFFFF00) | val; return;
+ case OP_TYPE_REGMEM: Mem[(op->Base + R[op->Data]) & kSpaceMask] = val; return;
+ default: break;
+ }
+}
+
+UInt32 CVm::GetOperand(bool byteMode, const COperand *op) const
+{
+ if (byteMode)
+ return GetOperand8(op);
+ return GetOperand32(op);
+}
+
+void CVm::SetOperand(bool byteMode, const COperand *op, UInt32 val)
+{
+ if (byteMode)
+ SetOperand8(op, (Byte)(val & 0xFF));
+ else
+ SetOperand32(op, val);
+}
+
+bool CVm::ExecuteCode(const CProgram *prg)
+{
+ Int32 maxOpCount = 25000000;
+ const CCommand *commands = &prg->Commands[0];
+ const CCommand *cmd = commands;
+ const UInt32 numCommands = prg->Commands.Size();
+ if (numCommands == 0)
+ return false;
+
+ for (;;)
+ {
+ switch (cmd->OpCode)
+ {
+ case CMD_MOV:
+ SetOperand32(&cmd->Op1, GetOperand32(&cmd->Op2));
+ break;
+ case CMD_MOVB:
+ SetOperand8(&cmd->Op1, GetOperand8(&cmd->Op2));
+ break;
+ case CMD_CMP:
+ {
+ const UInt32 v1 = GetOperand32(&cmd->Op1);
+ const UInt32 res = v1 - GetOperand32(&cmd->Op2);
+ Flags = res == 0 ? FLAG_Z : (res > v1) | (res & FLAG_S);
+ }
+ break;
+ case CMD_CMPB:
+ {
+ const Byte v1 = GetOperand8(&cmd->Op1);
+ const Byte res = (Byte)((v1 - GetOperand8(&cmd->Op2)) & 0xFF);
+ Flags = res == 0 ? FLAG_Z : (res > v1) | GET_FLAG_S_B(res);
+ }
+ break;
+ case CMD_ADD:
+ {
+ const UInt32 v1 = GetOperand32(&cmd->Op1);
+ const UInt32 res = v1 + GetOperand32(&cmd->Op2);
+ SetOperand32(&cmd->Op1, res);
+ Flags = (res < v1) | (res == 0 ? FLAG_Z : (res & FLAG_S));
+ }
+ break;
+ case CMD_ADDB:
+ {
+ const Byte v1 = GetOperand8(&cmd->Op1);
+ const Byte res = (Byte)((v1 + GetOperand8(&cmd->Op2)) & 0xFF);
+ SetOperand8(&cmd->Op1, (Byte)res);
+ Flags = (res < v1) | (res == 0 ? FLAG_Z : GET_FLAG_S_B(res));
+ }
+ break;
+ case CMD_ADC:
+ {
+ const UInt32 v1 = GetOperand(cmd->ByteMode, &cmd->Op1);
+ const UInt32 FC = (Flags & FLAG_C);
+ UInt32 res = v1 + GetOperand(cmd->ByteMode, &cmd->Op2) + FC;
+ if (cmd->ByteMode)
+ res &= 0xFF;
+ SetOperand(cmd->ByteMode, &cmd->Op1, res);
+ Flags = (res < v1 || (res == v1 && FC)) | (res == 0 ? FLAG_Z : (res & FLAG_S));
+ }
+ break;
+ case CMD_SUB:
+ {
+ const UInt32 v1 = GetOperand32(&cmd->Op1);
+ const UInt32 res = v1 - GetOperand32(&cmd->Op2);
+ SetOperand32(&cmd->Op1, res);
+ Flags = res == 0 ? FLAG_Z : (res > v1) | (res & FLAG_S);
+ }
+ break;
+ case CMD_SUBB:
+ {
+ const UInt32 v1 = GetOperand8(&cmd->Op1);
+ const UInt32 res = v1 - GetOperand8(&cmd->Op2);
+ SetOperand8(&cmd->Op1, (Byte)res);
+ Flags = res == 0 ? FLAG_Z : (res > v1) | (res & FLAG_S);
+ }
+ break;
+ case CMD_SBB:
+ {
+ const UInt32 v1 = GetOperand(cmd->ByteMode, &cmd->Op1);
+ const UInt32 FC = (Flags & FLAG_C);
+ UInt32 res = v1 - GetOperand(cmd->ByteMode, &cmd->Op2) - FC;
+ // Flags = res == 0 ? FLAG_Z : (res > v1 || res == v1 && FC) | (res & FLAG_S);
+ if (cmd->ByteMode)
+ res &= 0xFF;
+ SetOperand(cmd->ByteMode, &cmd->Op1, res);
+ Flags = (res > v1 || (res == v1 && FC)) | (res == 0 ? FLAG_Z : (res & FLAG_S));
+ }
+ break;
+ case CMD_INC:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) + 1;
+ SetOperand32(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ;
+ }
+ break;
+ case CMD_INCB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) + 1);
+ SetOperand8(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ_B;
+ }
+ break;
+ case CMD_DEC:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) - 1;
+ SetOperand32(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ;
+ }
+ break;
+ case CMD_DECB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) - 1);
+ SetOperand8(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ_B;
+ }
+ break;
+ case CMD_XOR:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) ^ GetOperand32(&cmd->Op2);
+ SetOperand32(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ;
+ }
+ break;
+ case CMD_XORB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) ^ GetOperand8(&cmd->Op2));
+ SetOperand8(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ_B;
+ }
+ break;
+ case CMD_AND:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) & GetOperand32(&cmd->Op2);
+ SetOperand32(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ;
+ }
+ break;
+ case CMD_ANDB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) & GetOperand8(&cmd->Op2));
+ SetOperand8(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ_B;
+ }
+ break;
+ case CMD_OR:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) | GetOperand32(&cmd->Op2);
+ SetOperand32(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ;
+ }
+ break;
+ case CMD_ORB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) | GetOperand8(&cmd->Op2));
+ SetOperand8(&cmd->Op1, res);
+ FLAGS_UPDATE_SZ_B;
+ }
+ break;
+ case CMD_TEST:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) & GetOperand32(&cmd->Op2);
+ FLAGS_UPDATE_SZ;
+ }
+ break;
+ case CMD_TESTB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) & GetOperand8(&cmd->Op2));
+ FLAGS_UPDATE_SZ_B;
+ }
+ break;
+ case CMD_NOT:
+ SetOperand(cmd->ByteMode, &cmd->Op1, ~GetOperand(cmd->ByteMode, &cmd->Op1));
+ break;
+ case CMD_NEG:
+ {
+ const UInt32 res = 0 - GetOperand32(&cmd->Op1);
+ SetOperand32(&cmd->Op1, res);
+ Flags = res == 0 ? FLAG_Z : FLAG_C | (res & FLAG_S);
+ }
+ break;
+ case CMD_NEGB:
+ {
+ const Byte res = (Byte)(0 - GetOperand8(&cmd->Op1));
+ SetOperand8(&cmd->Op1, res);
+ Flags = res == 0 ? FLAG_Z : FLAG_C | GET_FLAG_S_B(res);
+ }
+ break;
+
+ case CMD_SHL:
+ {
+ const UInt32 v1 = GetOperand32(&cmd->Op1);
+ const int v2 = (int)GetOperand32(&cmd->Op2);
+ const UInt32 res = v1 << v2;
+ SetOperand32(&cmd->Op1, res);
+ Flags = (res == 0 ? FLAG_Z : (res & FLAG_S)) | ((v1 << (v2 - 1)) & 0x80000000 ? FLAG_C : 0);
+ }
+ break;
+ case CMD_SHLB:
+ {
+ const Byte v1 = GetOperand8(&cmd->Op1);
+ const int v2 = (int)GetOperand8(&cmd->Op2);
+ const Byte res = (Byte)(v1 << v2);
+ SetOperand8(&cmd->Op1, res);
+ Flags = (res == 0 ? FLAG_Z : GET_FLAG_S_B(res)) | ((v1 << (v2 - 1)) & 0x80 ? FLAG_C : 0);
+ }
+ break;
+ case CMD_SHR:
+ {
+ const UInt32 v1 = GetOperand32(&cmd->Op1);
+ const int v2 = (int)GetOperand32(&cmd->Op2);
+ const UInt32 res = v1 >> v2;
+ SetOperand32(&cmd->Op1, res);
+ Flags = (res == 0 ? FLAG_Z : (res & FLAG_S)) | ((v1 >> (v2 - 1)) & FLAG_C);
+ }
+ break;
+ case CMD_SHRB:
+ {
+ const Byte v1 = GetOperand8(&cmd->Op1);
+ const int v2 = (int)GetOperand8(&cmd->Op2);
+ const Byte res = (Byte)(v1 >> v2);
+ SetOperand8(&cmd->Op1, res);
+ Flags = (res == 0 ? FLAG_Z : GET_FLAG_S_B(res)) | ((v1 >> (v2 - 1)) & FLAG_C);
+ }
+ break;
+ case CMD_SAR:
+ {
+ const UInt32 v1 = GetOperand32(&cmd->Op1);
+ const int v2 = (int)GetOperand32(&cmd->Op2);
+ const UInt32 res = UInt32(((Int32)v1) >> v2);
+ SetOperand32(&cmd->Op1, res);
+ Flags= (res == 0 ? FLAG_Z : (res & FLAG_S)) | ((v1 >> (v2 - 1)) & FLAG_C);
+ }
+ break;
+ case CMD_SARB:
+ {
+ const Byte v1 = GetOperand8(&cmd->Op1);
+ const int v2 = (int)GetOperand8(&cmd->Op2);
+ const Byte res = (Byte)(((signed char)v1) >> v2);
+ SetOperand8(&cmd->Op1, res);
+ Flags= (res == 0 ? FLAG_Z : GET_FLAG_S_B(res)) | ((v1 >> (v2 - 1)) & FLAG_C);
+ }
+ break;
+
+ case CMD_JMP:
+ SET_IP_OP1
+ continue;
+ case CMD_JZ:
+ if ((Flags & FLAG_Z) != 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JNZ:
+ if ((Flags & FLAG_Z) == 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JS:
+ if ((Flags & FLAG_S) != 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JNS:
+ if ((Flags & FLAG_S) == 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JB:
+ if ((Flags & FLAG_C) != 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JBE:
+ if ((Flags & (FLAG_C | FLAG_Z)) != 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JA:
+ if ((Flags & (FLAG_C | FLAG_Z)) == 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+ case CMD_JAE:
+ if ((Flags & FLAG_C) == 0)
+ {
+ SET_IP_OP1
+ continue;
+ }
+ break;
+
+ case CMD_PUSH:
+ R[kStackRegIndex] -= 4;
+ SetValue32(&Mem[R[kStackRegIndex] & kSpaceMask], GetOperand32(&cmd->Op1));
+ break;
+ case CMD_POP:
+ SetOperand32(&cmd->Op1, GetValue32(&Mem[R[kStackRegIndex] & kSpaceMask]));
+ R[kStackRegIndex] += 4;
+ break;
+ case CMD_CALL:
+ R[kStackRegIndex] -= 4;
+ SetValue32(&Mem[R[kStackRegIndex] & kSpaceMask], (UInt32)(cmd - commands + 1));
+ SET_IP_OP1
+ continue;
+
+ case CMD_PUSHA:
+ {
+ for (UInt32 i = 0, SP = R[kStackRegIndex] - 4; i < kNumRegs; i++, SP -= 4)
+ SetValue32(&Mem[SP & kSpaceMask], R[i]);
+ R[kStackRegIndex] -= kNumRegs * 4;
+ }
+ break;
+ case CMD_POPA:
+ {
+ for (UInt32 i = 0, SP = R[kStackRegIndex]; i < kNumRegs; i++, SP += 4)
+ R[kStackRegIndex - i] = GetValue32(&Mem[SP & kSpaceMask]);
+ }
+ break;
+ case CMD_PUSHF:
+ R[kStackRegIndex] -= 4;
+ SetValue32(&Mem[R[kStackRegIndex]&kSpaceMask], Flags);
+ break;
+ case CMD_POPF:
+ Flags = GetValue32(&Mem[R[kStackRegIndex] & kSpaceMask]);
+ R[kStackRegIndex] += 4;
+ break;
+
+ case CMD_MOVZX:
+ SetOperand32(&cmd->Op1, GetOperand8(&cmd->Op2));
+ break;
+ case CMD_MOVSX:
+ SetOperand32(&cmd->Op1, (UInt32)(Int32)(signed char)GetOperand8(&cmd->Op2));
+ break;
+ case CMD_XCHG:
+ {
+ const UInt32 v1 = GetOperand(cmd->ByteMode, &cmd->Op1);
+ SetOperand(cmd->ByteMode, &cmd->Op1, GetOperand(cmd->ByteMode, &cmd->Op2));
+ SetOperand(cmd->ByteMode, &cmd->Op2, v1);
+ }
+ break;
+ case CMD_MUL:
+ {
+ const UInt32 res = GetOperand32(&cmd->Op1) * GetOperand32(&cmd->Op2);
+ SetOperand32(&cmd->Op1, res);
+ }
+ break;
+ case CMD_MULB:
+ {
+ const Byte res = (Byte)(GetOperand8(&cmd->Op1) * GetOperand8(&cmd->Op2));
+ SetOperand8(&cmd->Op1, res);
+ }
+ break;
+ case CMD_DIV:
+ {
+ const UInt32 divider = GetOperand(cmd->ByteMode, &cmd->Op2);
+ if (divider != 0)
+ {
+ const UInt32 res = GetOperand(cmd->ByteMode, &cmd->Op1) / divider;
+ SetOperand(cmd->ByteMode, &cmd->Op1, res);
+ }
+ }
+ break;
+
+ case CMD_RET:
+ {
+ if (R[kStackRegIndex] >= kSpaceSize)
+ return true;
+ const UInt32 ip = GetValue32(&Mem[R[kStackRegIndex] & kSpaceMask]);
+ SET_IP(ip)
+ R[kStackRegIndex] += 4;
+ continue;
+ }
+ case CMD_PRINT:
+ break;
+ }
+ cmd++;
+ --maxOpCount;
+ }
+}
+
+//////////////////////////////////////////////////////
+// Read program
+
+static void DecodeArg(CMemBitDecoder &inp, COperand &op, bool byteMode)
+{
+ if (inp.ReadBit())
+ {
+ op.Type = OP_TYPE_REG;
+ op.Data = inp.ReadBits(kNumRegBits);
+ }
+ else if (inp.ReadBit() == 0)
+ {
+ op.Type = OP_TYPE_INT;
+ if (byteMode)
+ op.Data = inp.ReadBits(8);
+ else
+ op.Data = inp.ReadEncodedUInt32();
+ }
+ else
+ {
+ op.Type = OP_TYPE_REGMEM;
+ if (inp.ReadBit() == 0)
+ {
+ op.Data = inp.ReadBits(kNumRegBits);
+ op.Base = 0;
+ }
+ else
+ {
+ if (inp.ReadBit() == 0)
+ op.Data = inp.ReadBits(kNumRegBits);
+ else
+ op.Data = kNumRegs;
+ op.Base = inp.ReadEncodedUInt32();
+ }
+ }
+}
+
+void CProgram::ReadProgram(const Byte *code, UInt32 codeSize)
+{
+ CMemBitDecoder inp;
+ inp.Init(code, codeSize);
+
+ StaticData.Clear();
+
+ if (inp.ReadBit())
+ {
+ const UInt32 dataSize = inp.ReadEncodedUInt32() + 1;
+ for (UInt32 i = 0; inp.Avail() && i < dataSize; i++)
+ StaticData.Add((Byte)inp.ReadBits(8));
+ }
+
+ while (inp.Avail())
+ {
+ Commands.Add(CCommand());
+ CCommand *cmd = &Commands.Back();
+
+ unsigned opCode;
+ if (inp.ReadBit() == 0)
+ opCode = inp.ReadBits(3);
+ else
+ opCode = 8 + inp.ReadBits(5);
+ cmd->OpCode = (ECommand)opCode;
+ const unsigned cmdFlags = kCmdFlags[opCode];
+ if (cmdFlags & CF_BYTEMODE)
+ cmd->ByteMode = (inp.ReadBit()) ? true : false;
+ else
+ cmd->ByteMode = 0;
+
+ const unsigned opNum = (cmdFlags & CF_OPMASK);
+
+ if (opNum)
+ {
+ DecodeArg(inp, cmd->Op1, cmd->ByteMode);
+ if (opNum == 2)
+ DecodeArg(inp, cmd->Op2, cmd->ByteMode);
+ else
+ {
+ if (cmd->Op1.Type == OP_TYPE_INT && (cmdFlags & (CF_JUMP | CF_PROC)))
+ {
+ Int32 dist = (Int32)cmd->Op1.Data;
+ if (dist >= 256)
+ dist -= 256;
+ else
+ {
+ if (dist >= 136)
+ dist -= 264;
+ else if (dist >= 16)
+ dist -= 8;
+ else if (dist >= 8)
+ dist -= 16;
+ dist += Commands.Size() - 1;
+ }
+ cmd->Op1.Data = (UInt32)dist;
+ }
+ }
+ }
+
+ if (cmd->ByteMode)
+ {
+ switch (cmd->OpCode)
+ {
+ case CMD_MOV: cmd->OpCode = CMD_MOVB; break;
+ case CMD_CMP: cmd->OpCode = CMD_CMPB; break;
+ case CMD_ADD: cmd->OpCode = CMD_ADDB; break;
+ case CMD_SUB: cmd->OpCode = CMD_SUBB; break;
+ case CMD_INC: cmd->OpCode = CMD_INCB; break;
+ case CMD_DEC: cmd->OpCode = CMD_DECB; break;
+ case CMD_XOR: cmd->OpCode = CMD_XORB; break;
+ case CMD_AND: cmd->OpCode = CMD_ANDB; break;
+ case CMD_OR: cmd->OpCode = CMD_ORB; break;
+ case CMD_TEST: cmd->OpCode = CMD_TESTB; break;
+ case CMD_NEG: cmd->OpCode = CMD_NEGB; break;
+ case CMD_SHL: cmd->OpCode = CMD_SHLB; break;
+ case CMD_SHR: cmd->OpCode = CMD_SHRB; break;
+ case CMD_SAR: cmd->OpCode = CMD_SARB; break;
+ case CMD_MUL: cmd->OpCode = CMD_MULB; break;
+ default: break;
+ }
+ }
+ }
+}
+
+#endif
+
+
+#ifdef Z7_RARVM_STANDARD_FILTERS
+
+enum EStandardFilter
+{
+ SF_E8,
+ SF_E8E9,
+ SF_ITANIUM,
+ SF_RGB,
+ SF_AUDIO,
+ SF_DELTA
+ // SF_UPCASE
+};
+
+static const struct CStandardFilterSignature
+{
+ UInt32 Length;
+ UInt32 CRC;
+ EStandardFilter Type;
+}
+kStdFilters[]=
+{
+ { 53, 0xad576887, SF_E8 },
+ { 57, 0x3cd7e57e, SF_E8E9 },
+ { 120, 0x3769893f, SF_ITANIUM },
+ { 29, 0x0e06077d, SF_DELTA },
+ { 149, 0x1c2c5dc8, SF_RGB },
+ { 216, 0xbc85e701, SF_AUDIO }
+ // { 40, 0x46b9c560, SF_UPCASE }
+};
+
+static int FindStandardFilter(const Byte *code, UInt32 codeSize)
+{
+ // return -1; // for debug VM execution
+ const UInt32 crc = CrcCalc(code, codeSize);
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kStdFilters); i++)
+ {
+ const CStandardFilterSignature &sfs = kStdFilters[i];
+ if (sfs.CRC == crc && sfs.Length == codeSize)
+ return (int)i;
+ }
+ return -1;
+}
+
+#endif
+
+
+bool CProgram::PrepareProgram(const Byte *code, UInt32 codeSize)
+{
+ IsSupported = false;
+
+ #ifdef Z7_RARVM_VM_ENABLE
+ Commands.Clear();
+ #endif
+
+ #ifdef Z7_RARVM_STANDARD_FILTERS
+ StandardFilterIndex = -1;
+ #endif
+
+ bool isOK = false;
+
+ Byte xorSum = 0;
+ for (UInt32 i = 0; i < codeSize; i++)
+ xorSum ^= code[i];
+
+ if (xorSum == 0 && codeSize != 0)
+ {
+ IsSupported = true;
+ isOK = true;
+ #ifdef Z7_RARVM_STANDARD_FILTERS
+ StandardFilterIndex = FindStandardFilter(code, codeSize);
+ if (StandardFilterIndex >= 0)
+ return true;
+ #endif
+
+ #ifdef Z7_RARVM_VM_ENABLE
+ ReadProgram(code + 1, codeSize - 1);
+ #else
+ IsSupported = false;
+ #endif
+ }
+
+ #ifdef Z7_RARVM_VM_ENABLE
+ Commands.Add(CCommand());
+ Commands.Back().OpCode = CMD_RET;
+ #endif
+
+ return isOK;
+}
+
+void CVm::SetMemory(UInt32 pos, const Byte *data, UInt32 dataSize)
+{
+ if (pos < kSpaceSize && data != Mem + pos)
+ memmove(Mem + pos, data, MyMin(dataSize, kSpaceSize - pos));
+}
+
+#ifdef Z7_RARVM_STANDARD_FILTERS
+
+static void E8E9Decode(Byte *data, UInt32 dataSize, UInt32 fileOffset, bool e9)
+{
+ if (dataSize <= 4)
+ return;
+ dataSize -= 4;
+ const UInt32 kFileSize = 0x1000000;
+ const Byte cmpMask = (Byte)(e9 ? 0xFE : 0xFF);
+ for (UInt32 curPos = 0; curPos < dataSize;)
+ {
+ curPos++;
+ if (((*data++) & cmpMask) == 0xE8)
+ {
+ UInt32 offset = curPos + fileOffset;
+ UInt32 addr = GetValue32(data);
+ if (addr < kFileSize)
+ SetValue32(data, addr - offset);
+ else if ((addr & 0x80000000) != 0 && ((addr + offset) & 0x80000000) == 0)
+ SetValue32(data, addr + kFileSize);
+ data += 4;
+ curPos += 4;
+ }
+ }
+}
+
+
+static void ItaniumDecode(Byte *data, UInt32 dataSize, UInt32 fileOffset)
+{
+ if (dataSize <= 21)
+ return;
+ fileOffset >>= 4;
+ dataSize -= 21;
+ dataSize += 15;
+ dataSize >>= 4;
+ dataSize += fileOffset;
+ do
+ {
+ unsigned m = ((UInt32)0x334B0000 >> (data[0] & 0x1E)) & 3;
+ if (m)
+ {
+ m++;
+ do
+ {
+ Byte *p = data + ((size_t)m * 5 - 8);
+ if (((p[3] >> m) & 15) == 5)
+ {
+ const UInt32 kMask = 0xFFFFF;
+ // UInt32 raw = ((UInt32)p[0]) | ((UInt32)p[1] << 8) | ((UInt32)p[2] << 16);
+ UInt32 raw = GetUi32(p);
+ UInt32 v = raw >> m;
+ v -= fileOffset;
+ v &= kMask;
+ raw &= ~(kMask << m);
+ raw |= (v << m);
+ // p[0] = (Byte)raw; p[1] = (Byte)(raw >> 8); p[2] = (Byte)(raw >> 16);
+ SetUi32(p, raw)
+ }
+ }
+ while (++m <= 4);
+ }
+ data += 16;
+ }
+ while (++fileOffset != dataSize);
+}
+
+
+static void DeltaDecode(Byte *data, UInt32 dataSize, UInt32 numChannels)
+{
+ UInt32 srcPos = 0;
+ const UInt32 border = dataSize * 2;
+ for (UInt32 curChannel = 0; curChannel < numChannels; curChannel++)
+ {
+ Byte prevByte = 0;
+ for (UInt32 destPos = dataSize + curChannel; destPos < border; destPos += numChannels)
+ data[destPos] = (prevByte = (Byte)(prevByte - data[srcPos++]));
+ }
+}
+
+static void RgbDecode(Byte *srcData, UInt32 dataSize, UInt32 width, UInt32 posR)
+{
+ Byte *destData = srcData + dataSize;
+ const UInt32 kNumChannels = 3;
+
+ for (UInt32 curChannel = 0; curChannel < kNumChannels; curChannel++)
+ {
+ Byte prevByte = 0;
+
+ for (UInt32 i = curChannel; i < dataSize; i += kNumChannels)
+ {
+ unsigned int predicted;
+ if (i < width)
+ predicted = prevByte;
+ else
+ {
+ const unsigned int upperLeftByte = destData[i - width];
+ const unsigned int upperByte = destData[i - width + 3];
+ predicted = prevByte + upperByte - upperLeftByte;
+ const int pa = abs((int)(predicted - prevByte));
+ const int pb = abs((int)(predicted - upperByte));
+ const int pc = abs((int)(predicted - upperLeftByte));
+ if (pa <= pb && pa <= pc)
+ predicted = prevByte;
+ else
+ if (pb <= pc)
+ predicted = upperByte;
+ else
+ predicted = upperLeftByte;
+ }
+ destData[i] = prevByte = (Byte)(predicted - *(srcData++));
+ }
+ }
+ if (dataSize < 3)
+ return;
+ const UInt32 border = dataSize - 2;
+ for (UInt32 i = posR; i < border; i += 3)
+ {
+ const Byte g = destData[i + 1];
+ destData[i ] = (Byte)(destData[i ] + g);
+ destData[i + 2] = (Byte)(destData[i + 2] + g);
+ }
+}
+
+#define my_abs(x) (unsigned)abs(x)
+
+static void AudioDecode(Byte *srcData, UInt32 dataSize, UInt32 numChannels)
+{
+ Byte *destData = srcData + dataSize;
+ for (UInt32 curChannel = 0; curChannel < numChannels; curChannel++)
+ {
+ UInt32 prevByte = 0, prevDelta = 0, dif[7];
+ Int32 D1 = 0, D2 = 0, D3;
+ Int32 K1 = 0, K2 = 0, K3 = 0;
+ memset(dif, 0, sizeof(dif));
+
+ for (UInt32 i = curChannel, byteCount = 0; i < dataSize; i += numChannels, byteCount++)
+ {
+ D3 = D2;
+ D2 = (Int32)prevDelta - D1;
+ D1 = (Int32)prevDelta;
+
+ UInt32 predicted = (UInt32)((Int32)(8 * prevByte) + K1 * D1 + K2 * D2 + K3 * D3);
+ predicted = (predicted >> 3) & 0xFF;
+
+ const UInt32 curByte = *(srcData++);
+
+ predicted -= curByte;
+ destData[i] = (Byte)predicted;
+ prevDelta = (UInt32)(Int32)(signed char)(predicted - prevByte);
+ prevByte = predicted;
+
+ const Int32 D = ((Int32)(signed char)curByte) << 3;
+
+ dif[0] += my_abs(D);
+ dif[1] += my_abs(D - D1);
+ dif[2] += my_abs(D + D1);
+ dif[3] += my_abs(D - D2);
+ dif[4] += my_abs(D + D2);
+ dif[5] += my_abs(D - D3);
+ dif[6] += my_abs(D + D3);
+
+ if ((byteCount & 0x1F) == 0)
+ {
+ UInt32 minDif = dif[0], numMinDif = 0;
+ dif[0] = 0;
+ for (unsigned j = 1; j < Z7_ARRAY_SIZE(dif); j++)
+ {
+ if (dif[j] < minDif)
+ {
+ minDif = dif[j];
+ numMinDif = j;
+ }
+ dif[j] = 0;
+ }
+ switch (numMinDif)
+ {
+ case 1: if (K1 >= -16) K1--; break;
+ case 2: if (K1 < 16) K1++; break;
+ case 3: if (K2 >= -16) K2--; break;
+ case 4: if (K2 < 16) K2++; break;
+ case 5: if (K3 >= -16) K3--; break;
+ case 6: if (K3 < 16) K3++; break;
+ }
+ }
+ }
+ }
+}
+
+/*
+static UInt32 UpCaseDecode(Byte *data, UInt32 dataSize)
+{
+ UInt32 srcPos = 0, destPos = dataSize;
+ while (srcPos < dataSize)
+ {
+ Byte curByte = data[srcPos++];
+ if (curByte == 2 && (curByte = data[srcPos++]) != 2)
+ curByte -= 32;
+ data[destPos++] = curByte;
+ }
+ return destPos - dataSize;
+}
+*/
+
+bool CVm::ExecuteStandardFilter(unsigned filterIndex)
+{
+ const UInt32 dataSize = R[4];
+ if (dataSize >= kGlobalOffset)
+ return false;
+ EStandardFilter filterType = kStdFilters[filterIndex].Type;
+
+ switch (filterType)
+ {
+ case SF_E8:
+ case SF_E8E9:
+ E8E9Decode(Mem, dataSize, R[6], (filterType == SF_E8E9));
+ break;
+
+ case SF_ITANIUM:
+ ItaniumDecode(Mem, dataSize, R[6]);
+ break;
+
+ case SF_DELTA:
+ {
+ if (dataSize >= kGlobalOffset / 2)
+ return false;
+ const UInt32 numChannels = R[0];
+ if (numChannels == 0 || numChannels > 1024) // unrar 5.5.5
+ return false;
+ SetBlockPos(dataSize);
+ DeltaDecode(Mem, dataSize, numChannels);
+ break;
+ }
+
+ case SF_RGB:
+ {
+ if (dataSize >= kGlobalOffset / 2 || dataSize < 3) // unrar 5.5.5
+ return false;
+ const UInt32 width = R[0];
+ const UInt32 posR = R[1];
+ if (width < 3 || width - 3 > dataSize || posR > 2) // unrar 5.5.5
+ return false;
+ SetBlockPos(dataSize);
+ RgbDecode(Mem, dataSize, width, posR);
+ break;
+ }
+
+ case SF_AUDIO:
+ {
+ if (dataSize >= kGlobalOffset / 2)
+ return false;
+ const UInt32 numChannels = R[0];
+ if (numChannels == 0 || numChannels > 128) // unrar 5.5.5
+ return false;
+ SetBlockPos(dataSize);
+ AudioDecode(Mem, dataSize, numChannels);
+ break;
+ }
+
+ /*
+ case SF_UPCASE:
+ if (dataSize >= kGlobalOffset / 2)
+ return false;
+ UInt32 destSize = UpCaseDecode(Mem, dataSize);
+ SetBlockSize(destSize);
+ SetBlockPos(dataSize);
+ break;
+ */
+ }
+ return true;
+}
+
+#endif
+
+}}}
diff --git a/CPP/7zip/Compress/Rar3Vm.h b/CPP/7zip/Compress/Rar3Vm.h
new file mode 100644
index 0000000..fde7e95
--- /dev/null
+++ b/CPP/7zip/Compress/Rar3Vm.h
@@ -0,0 +1,195 @@
+// Rar3Vm.h
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#ifndef ZIP7_INC_COMPRESS_RAR3_VM_H
+#define ZIP7_INC_COMPRESS_RAR3_VM_H
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/MyVector.h"
+
+#define Z7_RARVM_STANDARD_FILTERS
+// #define Z7_RARVM_VM_ENABLE
+
+namespace NCompress {
+namespace NRar3 {
+
+class CMemBitDecoder
+{
+ const Byte *_data;
+ UInt32 _bitSize;
+ UInt32 _bitPos;
+public:
+ void Init(const Byte *data, UInt32 byteSize)
+ {
+ _data = data;
+ _bitSize = (byteSize << 3);
+ _bitPos = 0;
+ }
+ UInt32 ReadBits(unsigned numBits);
+ UInt32 ReadBit();
+ bool Avail() const { return (_bitPos < _bitSize); }
+
+ UInt32 ReadEncodedUInt32();
+};
+
+namespace NVm {
+
+inline UInt32 GetValue32(const void *addr) { return GetUi32(addr); }
+inline void SetValue32(void *addr, UInt32 value) { SetUi32(addr, value) }
+
+const unsigned kNumRegBits = 3;
+const UInt32 kNumRegs = 1 << kNumRegBits;
+const UInt32 kNumGpRegs = kNumRegs - 1;
+
+const UInt32 kSpaceSize = 0x40000;
+const UInt32 kSpaceMask = kSpaceSize - 1;
+const UInt32 kGlobalOffset = 0x3C000;
+const UInt32 kGlobalSize = 0x2000;
+const UInt32 kFixedGlobalSize = 64;
+
+namespace NGlobalOffset
+{
+ const UInt32 kBlockSize = 0x1C;
+ const UInt32 kBlockPos = 0x20;
+ const UInt32 kExecCount = 0x2C;
+ const UInt32 kGlobalMemOutSize = 0x30;
+}
+
+
+#ifdef Z7_RARVM_VM_ENABLE
+
+enum ECommand
+{
+ CMD_MOV, CMD_CMP, CMD_ADD, CMD_SUB, CMD_JZ, CMD_JNZ, CMD_INC, CMD_DEC,
+ CMD_JMP, CMD_XOR, CMD_AND, CMD_OR, CMD_TEST, CMD_JS, CMD_JNS, CMD_JB,
+ CMD_JBE, CMD_JA, CMD_JAE, CMD_PUSH, CMD_POP, CMD_CALL, CMD_RET, CMD_NOT,
+ CMD_SHL, CMD_SHR, CMD_SAR, CMD_NEG, CMD_PUSHA,CMD_POPA, CMD_PUSHF,CMD_POPF,
+ CMD_MOVZX,CMD_MOVSX,CMD_XCHG, CMD_MUL, CMD_DIV, CMD_ADC, CMD_SBB, CMD_PRINT,
+
+ CMD_MOVB, CMD_CMPB, CMD_ADDB, CMD_SUBB, CMD_INCB, CMD_DECB,
+ CMD_XORB, CMD_ANDB, CMD_ORB, CMD_TESTB,CMD_NEGB,
+ CMD_SHLB, CMD_SHRB, CMD_SARB, CMD_MULB
+};
+
+enum EOpType {OP_TYPE_REG, OP_TYPE_INT, OP_TYPE_REGMEM, OP_TYPE_NONE};
+
+// Addr in COperand object can link (point) to CVm object!!!
+
+struct COperand
+{
+ EOpType Type;
+ UInt32 Data;
+ UInt32 Base;
+ COperand(): Type(OP_TYPE_NONE), Data(0), Base(0) {}
+};
+
+struct CCommand
+{
+ ECommand OpCode;
+ bool ByteMode;
+ COperand Op1, Op2;
+};
+
+#endif
+
+
+struct CBlockRef
+{
+ UInt32 Offset;
+ UInt32 Size;
+};
+
+
+class CProgram
+{
+ #ifdef Z7_RARVM_VM_ENABLE
+ void ReadProgram(const Byte *code, UInt32 codeSize);
+public:
+ CRecordVector<CCommand> Commands;
+ #endif
+
+public:
+ #ifdef Z7_RARVM_STANDARD_FILTERS
+ int StandardFilterIndex;
+ #endif
+
+ bool IsSupported;
+ CRecordVector<Byte> StaticData;
+
+ bool PrepareProgram(const Byte *code, UInt32 codeSize);
+};
+
+
+struct CProgramInitState
+{
+ UInt32 InitR[kNumGpRegs];
+ CRecordVector<Byte> GlobalData;
+
+ void AllocateEmptyFixedGlobal()
+ {
+ GlobalData.ClearAndSetSize(NVm::kFixedGlobalSize);
+ memset(&GlobalData[0], 0, NVm::kFixedGlobalSize);
+ }
+};
+
+
+class CVm
+{
+ static UInt32 GetValue(bool byteMode, const void *addr)
+ {
+ if (byteMode)
+ return(*(const Byte *)addr);
+ else
+ return GetUi32(addr);
+ }
+
+ static void SetValue(bool byteMode, void *addr, UInt32 value)
+ {
+ if (byteMode)
+ *(Byte *)addr = (Byte)value;
+ else
+ SetUi32(addr, value)
+ }
+
+ UInt32 GetFixedGlobalValue32(UInt32 globalOffset) { return GetValue(false, &Mem[kGlobalOffset + globalOffset]); }
+
+ void SetBlockSize(UInt32 v) { SetValue(&Mem[kGlobalOffset + NGlobalOffset::kBlockSize], v); }
+ void SetBlockPos(UInt32 v) { SetValue(&Mem[kGlobalOffset + NGlobalOffset::kBlockPos], v); }
+public:
+ static void SetValue(void *addr, UInt32 value) { SetValue(false, addr, value); }
+
+private:
+
+ #ifdef Z7_RARVM_VM_ENABLE
+ UInt32 GetOperand32(const COperand *op) const;
+ void SetOperand32(const COperand *op, UInt32 val);
+ Byte GetOperand8(const COperand *op) const;
+ void SetOperand8(const COperand *op, Byte val);
+ UInt32 GetOperand(bool byteMode, const COperand *op) const;
+ void SetOperand(bool byteMode, const COperand *op, UInt32 val);
+ bool ExecuteCode(const CProgram *prg);
+ #endif
+
+ #ifdef Z7_RARVM_STANDARD_FILTERS
+ bool ExecuteStandardFilter(unsigned filterIndex);
+ #endif
+
+ Byte *Mem;
+ UInt32 R[kNumRegs + 1]; // R[kNumRegs] = 0 always (speed optimization)
+ UInt32 Flags;
+
+public:
+ CVm();
+ ~CVm();
+ bool Create();
+ void SetMemory(UInt32 pos, const Byte *data, UInt32 dataSize);
+ bool Execute(CProgram *prg, const CProgramInitState *initState,
+ CBlockRef &outBlockRef, CRecordVector<Byte> &outGlobalData);
+ const Byte *GetDataPointer(UInt32 offset) const { return Mem + offset; }
+};
+
+#endif
+
+}}}
diff --git a/CPP/7zip/Compress/Rar5Decoder.cpp b/CPP/7zip/Compress/Rar5Decoder.cpp
new file mode 100644
index 0000000..e55d7de
--- /dev/null
+++ b/CPP/7zip/Compress/Rar5Decoder.cpp
@@ -0,0 +1,980 @@
+// Rar5Decoder.cpp
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../Common/StreamUtils.h"
+
+#include "Rar5Decoder.h"
+
+namespace NCompress {
+namespace NRar5 {
+
+static const size_t kInputBufSize = 1 << 20;
+
+void CBitDecoder::Prepare2() throw()
+{
+ const unsigned kSize = 16;
+ if (_buf > _bufLim)
+ return;
+
+ size_t rem = (size_t)(_bufLim - _buf);
+ if (rem != 0)
+ memmove(_bufBase, _buf, rem);
+
+ _bufLim = _bufBase + rem;
+ _processedSize += (size_t)(_buf - _bufBase);
+ _buf = _bufBase;
+
+ if (!_wasFinished)
+ {
+ UInt32 processed = (UInt32)(kInputBufSize - rem);
+ _hres = _stream->Read(_bufLim, (UInt32)processed, &processed);
+ _bufLim += processed;
+ _wasFinished = (processed == 0);
+ if (_hres != S_OK)
+ {
+ _wasFinished = true;
+ // throw CInBufferException(result);
+ }
+ }
+
+ rem = (size_t)(_bufLim - _buf);
+ _bufCheck = _buf;
+ if (rem < kSize)
+ memset(_bufLim, 0xFF, kSize - rem);
+ else
+ _bufCheck = _bufLim - kSize;
+
+ SetCheck2();
+}
+
+
+enum FilterType
+{
+ FILTER_DELTA = 0,
+ FILTER_E8,
+ FILTER_E8E9,
+ FILTER_ARM
+};
+
+static const size_t kWriteStep = (size_t)1 << 22;
+
+CDecoder::CDecoder():
+ _isSolid(false),
+ _solidAllowed(false),
+ _wasInit(false),
+ _dictSizeLog(0),
+ _window(NULL),
+ _winPos(0),
+ _lzSize(0),
+ _lzEnd(0),
+ _writtenFileSize(0),
+ _winSizeAllocated(0),
+ _inputBuf(NULL)
+{
+}
+
+CDecoder::~CDecoder()
+{
+ ::MidFree(_window);
+ ::MidFree(_inputBuf);
+}
+
+HRESULT CDecoder::WriteData(const Byte *data, size_t size)
+{
+ HRESULT res = S_OK;
+ if (!_unpackSize_Defined || _writtenFileSize < _unpackSize)
+ {
+ size_t cur = size;
+ if (_unpackSize_Defined)
+ {
+ const UInt64 rem = _unpackSize - _writtenFileSize;
+ if (cur > rem)
+ cur = (size_t)rem;
+ }
+ res = WriteStream(_outStream, data, cur);
+ if (res != S_OK)
+ _writeError = true;
+ }
+ _writtenFileSize += size;
+ return res;
+}
+
+HRESULT CDecoder::ExecuteFilter(const CFilter &f)
+{
+ bool useDest = false;
+
+ Byte *data = _filterSrc;
+ UInt32 dataSize = f.Size;
+
+ // printf("\nType = %d offset = %9d size = %5d", f.Type, (unsigned)(f.Start - _lzFileStart), dataSize);
+
+ switch (f.Type)
+ {
+ case FILTER_E8:
+ case FILTER_E8E9:
+ {
+ // printf(" FILTER_E8");
+ if (dataSize > 4)
+ {
+ dataSize -= 4;
+ const UInt32 fileOffset = (UInt32)(f.Start - _lzFileStart);
+
+ const UInt32 kFileSize = (UInt32)1 << 24;
+ const Byte cmpMask = (Byte)(f.Type == FILTER_E8 ? 0xFF : 0xFE);
+
+ for (UInt32 curPos = 0; curPos < dataSize;)
+ {
+ curPos++;
+ if (((*data++) & cmpMask) == 0xE8)
+ {
+ const UInt32 offset = (curPos + fileOffset) & (kFileSize - 1);
+ const UInt32 addr = GetUi32(data);
+
+ if (addr < kFileSize)
+ {
+ SetUi32(data, addr - offset)
+ }
+ else if (addr > ((UInt32)0xFFFFFFFF - offset)) // (addr > ~(offset))
+ {
+ SetUi32(data, addr + kFileSize)
+ }
+
+ data += 4;
+ curPos += 4;
+ }
+ }
+ }
+ break;
+ }
+
+ case FILTER_ARM:
+ {
+ if (dataSize >= 4)
+ {
+ dataSize -= 4;
+ const UInt32 fileOffset = (UInt32)(f.Start - _lzFileStart);
+
+ for (UInt32 curPos = 0; curPos <= dataSize; curPos += 4)
+ {
+ Byte *d = data + curPos;
+ if (d[3] == 0xEB)
+ {
+ UInt32 offset = d[0] | ((UInt32)d[1] << 8) | ((UInt32)d[2] << 16);
+ offset -= (fileOffset + curPos) >> 2;
+ d[0] = (Byte)offset;
+ d[1] = (Byte)(offset >> 8);
+ d[2] = (Byte)(offset >> 16);
+ }
+ }
+ }
+ break;
+ }
+
+ case FILTER_DELTA:
+ {
+ // printf(" channels = %d", f.Channels);
+ _filterDst.AllocAtLeast(dataSize);
+ if (!_filterDst.IsAllocated())
+ return E_OUTOFMEMORY;
+
+ Byte *dest = _filterDst;
+ const UInt32 numChannels = f.Channels;
+
+ for (UInt32 curChannel = 0; curChannel < numChannels; curChannel++)
+ {
+ Byte prevByte = 0;
+ for (UInt32 destPos = curChannel; destPos < dataSize; destPos += numChannels)
+ dest[destPos] = (prevByte = (Byte)(prevByte - *data++));
+ }
+ useDest = true;
+ break;
+ }
+
+ default:
+ _unsupportedFilter = true;
+ memset(_filterSrc, 0, f.Size);
+ // return S_OK; // unrar
+ }
+
+ return WriteData(useDest ?
+ (const Byte *)_filterDst :
+ (const Byte *)_filterSrc,
+ f.Size);
+}
+
+
+HRESULT CDecoder::WriteBuf()
+{
+ DeleteUnusedFilters();
+
+ for (unsigned i = 0; i < _filters.Size();)
+ {
+ const CFilter &f = _filters[i];
+
+ const UInt64 blockStart = f.Start;
+
+ const size_t lzAvail = (size_t)(_lzSize - _lzWritten);
+ if (lzAvail == 0)
+ break;
+
+ if (blockStart > _lzWritten)
+ {
+ const UInt64 rem = blockStart - _lzWritten;
+ size_t size = lzAvail;
+ if (size > rem)
+ size = (size_t)rem;
+ if (size != 0)
+ {
+ RINOK(WriteData(_window + _winPos - lzAvail, size))
+ _lzWritten += size;
+ }
+ continue;
+ }
+
+ const UInt32 blockSize = f.Size;
+ size_t offset = (size_t)(_lzWritten - blockStart);
+ if (offset == 0)
+ {
+ _filterSrc.AllocAtLeast(blockSize);
+ if (!_filterSrc.IsAllocated())
+ return E_OUTOFMEMORY;
+ }
+
+ const size_t blockRem = (size_t)blockSize - offset;
+ size_t size = lzAvail;
+ if (size > blockRem)
+ size = blockRem;
+ memcpy(_filterSrc + offset, _window + _winPos - lzAvail, size);
+ _lzWritten += size;
+ offset += size;
+ if (offset != blockSize)
+ return S_OK;
+
+ _numUnusedFilters = ++i;
+ RINOK(ExecuteFilter(f))
+ }
+
+ DeleteUnusedFilters();
+
+ if (!_filters.IsEmpty())
+ return S_OK;
+
+ const size_t lzAvail = (size_t)(_lzSize - _lzWritten);
+ RINOK(WriteData(_window + _winPos - lzAvail, lzAvail))
+ _lzWritten += lzAvail;
+ return S_OK;
+}
+
+
+static UInt32 ReadUInt32(CBitDecoder &bi)
+{
+ const unsigned numBytes = bi.ReadBits9fix(2) + 1;
+ UInt32 v = 0;
+ for (unsigned i = 0; i < numBytes; i++)
+ v += ((UInt32)bi.ReadBits9fix(8) << (i * 8));
+ return v;
+}
+
+
+static const unsigned MAX_UNPACK_FILTERS = 8192;
+
+HRESULT CDecoder::AddFilter(CBitDecoder &_bitStream)
+{
+ DeleteUnusedFilters();
+
+ if (_filters.Size() >= MAX_UNPACK_FILTERS)
+ {
+ RINOK(WriteBuf())
+ DeleteUnusedFilters();
+ if (_filters.Size() >= MAX_UNPACK_FILTERS)
+ {
+ _unsupportedFilter = true;
+ InitFilters();
+ }
+ }
+
+ _bitStream.Prepare();
+
+ CFilter f;
+ const UInt32 blockStart = ReadUInt32(_bitStream);
+ f.Size = ReadUInt32(_bitStream);
+
+ if (f.Size > ((UInt32)1 << 22))
+ {
+ _unsupportedFilter = true;
+ f.Size = 0; // unrar 5.5.5
+ }
+
+ f.Type = (Byte)_bitStream.ReadBits9fix(3);
+ f.Channels = 0;
+ if (f.Type == FILTER_DELTA)
+ f.Channels = (Byte)(_bitStream.ReadBits9fix(5) + 1);
+ f.Start = _lzSize + blockStart;
+
+ if (f.Start < _filterEnd)
+ _unsupportedFilter = true;
+ else
+ {
+ _filterEnd = f.Start + f.Size;
+ if (f.Size != 0)
+ _filters.Add(f);
+ }
+
+ return S_OK;
+}
+
+
+#define RIF(x) { if (!(x)) return S_FALSE; }
+
+HRESULT CDecoder::ReadTables(CBitDecoder &_bitStream)
+{
+ if (_progress)
+ {
+ const UInt64 packSize = _bitStream.GetProcessedSize();
+ RINOK(_progress->SetRatioInfo(&packSize, &_writtenFileSize))
+ }
+
+ _bitStream.AlignToByte();
+ _bitStream.Prepare();
+
+ {
+ const unsigned flags = _bitStream.ReadByteInAligned();
+ unsigned checkSum = _bitStream.ReadByteInAligned();
+ checkSum ^= flags;
+ const unsigned num = (flags >> 3) & 3;
+ if (num == 3)
+ return S_FALSE;
+ UInt32 blockSize = _bitStream.ReadByteInAligned();
+ checkSum ^= blockSize;
+
+ if (num != 0)
+ {
+ unsigned b = _bitStream.ReadByteInAligned();
+ checkSum ^= b;
+ blockSize += (UInt32)b << 8;
+ if (num > 1)
+ {
+ b = _bitStream.ReadByteInAligned();
+ checkSum ^= b;
+ blockSize += (UInt32)b << 16;
+ }
+ }
+
+ if (checkSum != 0x5A)
+ return S_FALSE;
+
+ unsigned blockSizeBits7 = (flags & 7) + 1;
+ blockSize += (blockSizeBits7 >> 3);
+ if (blockSize == 0)
+ return S_FALSE;
+ blockSize--;
+ blockSizeBits7 &= 7;
+
+ _bitStream._blockEndBits7 = (Byte)blockSizeBits7;
+ _bitStream._blockEnd = _bitStream.GetProcessedSize_Round() + blockSize;
+
+ _bitStream.SetCheck2();
+
+ _isLastBlock = ((flags & 0x40) != 0);
+
+ if ((flags & 0x80) == 0)
+ {
+ if (!_tableWasFilled)
+ if (blockSize != 0 || blockSizeBits7 != 0)
+ return S_FALSE;
+ return S_OK;
+ }
+
+ _tableWasFilled = false;
+ }
+
+ {
+ Byte lens2[kLevelTableSize];
+
+ for (unsigned i = 0; i < kLevelTableSize;)
+ {
+ _bitStream.Prepare();
+ const unsigned len = (unsigned)_bitStream.ReadBits9fix(4);
+ if (len == 15)
+ {
+ unsigned num = (unsigned)_bitStream.ReadBits9fix(4);
+ if (num != 0)
+ {
+ num += 2;
+ num += i;
+ if (num > kLevelTableSize)
+ num = kLevelTableSize;
+ do
+ lens2[i++] = 0;
+ while (i < num);
+ continue;
+ }
+ }
+ lens2[i++] = (Byte)len;
+ }
+
+ if (_bitStream.IsBlockOverRead())
+ return S_FALSE;
+
+ RIF(m_LevelDecoder.Build(lens2))
+ }
+
+ Byte lens[kTablesSizesSum];
+ unsigned i = 0;
+
+ do
+ {
+ if (_bitStream._buf >= _bitStream._bufCheck2)
+ {
+ if (_bitStream._buf >= _bitStream._bufCheck)
+ _bitStream.Prepare();
+ if (_bitStream.IsBlockOverRead())
+ return S_FALSE;
+ }
+
+ const UInt32 sym = m_LevelDecoder.Decode(&_bitStream);
+
+ if (sym < 16)
+ lens[i++] = (Byte)sym;
+ else if (sym > kLevelTableSize)
+ return S_FALSE;
+ else
+ {
+ unsigned num = ((sym - 16) & 1) * 4;
+ num += num + 3 + (unsigned)_bitStream.ReadBits9(num + 3);
+ num += i;
+ if (num > kTablesSizesSum)
+ num = kTablesSizesSum;
+ Byte v = 0;
+ if (sym < 16 + 2)
+ {
+ if (i == 0)
+ return S_FALSE;
+ v = lens[(size_t)i - 1];
+ }
+ do
+ lens[i++] = v;
+ while (i < num);
+ }
+ }
+ while (i < kTablesSizesSum);
+
+ if (_bitStream.IsBlockOverRead())
+ return S_FALSE;
+ if (_bitStream.InputEofError())
+ return S_FALSE;
+
+ RIF(m_MainDecoder.Build(&lens[0]))
+ RIF(m_DistDecoder.Build(&lens[kMainTableSize]))
+ RIF(m_AlignDecoder.Build(&lens[kMainTableSize + kDistTableSize]))
+ RIF(m_LenDecoder.Build(&lens[kMainTableSize + kDistTableSize + kAlignTableSize]))
+
+ _useAlignBits = false;
+ // _useAlignBits = true;
+ for (i = 0; i < kAlignTableSize; i++)
+ if (lens[kMainTableSize + kDistTableSize + (size_t)i] != kNumAlignBits)
+ {
+ _useAlignBits = true;
+ break;
+ }
+
+ _tableWasFilled = true;
+ return S_OK;
+}
+
+
+static inline unsigned SlotToLen(CBitDecoder &_bitStream, unsigned slot)
+{
+ if (slot < 8)
+ return slot + 2;
+ const unsigned numBits = (slot >> 2) - 1;
+ return 2 + ((4 | (slot & 3)) << numBits) + _bitStream.ReadBits9(numBits);
+}
+
+
+static const UInt32 kSymbolRep = 258;
+// static const unsigned kMaxMatchLen = 0x1001 + 3;
+
+HRESULT CDecoder::DecodeLZ()
+{
+ CBitDecoder _bitStream;
+ _bitStream._stream = _inStream;
+ _bitStream._bufBase = _inputBuf;
+ _bitStream.Init();
+
+ UInt32 rep0 = _reps[0];
+
+ UInt32 remLen = 0;
+
+ size_t limit;
+ {
+ size_t rem = _winSize - _winPos;
+ if (rem > kWriteStep)
+ rem = kWriteStep;
+ limit = _winPos + rem;
+ }
+
+ for (;;)
+ {
+ if (_winPos >= limit)
+ {
+ RINOK(WriteBuf())
+ if (_unpackSize_Defined && _writtenFileSize > _unpackSize)
+ break; // return S_FALSE;
+
+ {
+ size_t rem = _winSize - _winPos;
+
+ if (rem == 0)
+ {
+ _winPos = 0;
+ rem = _winSize;
+ }
+ if (rem > kWriteStep)
+ rem = kWriteStep;
+ limit = _winPos + rem;
+ }
+
+ if (remLen != 0)
+ {
+ size_t winPos = _winPos;
+ const size_t winMask = _winMask;
+ size_t pos = (winPos - (size_t)rep0 - 1) & winMask;
+
+ Byte *win = _window;
+ do
+ {
+ if (winPos >= limit)
+ break;
+ win[winPos] = win[pos];
+ winPos++;
+ pos = (pos + 1) & winMask;
+ }
+ while (--remLen != 0);
+
+ _lzSize += winPos - _winPos;
+ _winPos = winPos;
+ continue;
+ }
+ }
+
+ if (_bitStream._buf >= _bitStream._bufCheck2)
+ {
+ if (_bitStream.InputEofError())
+ break; // return S_FALSE;
+ if (_bitStream._buf >= _bitStream._bufCheck)
+ _bitStream.Prepare2();
+
+ const UInt64 processed = _bitStream.GetProcessedSize_Round();
+ if (processed >= _bitStream._blockEnd)
+ {
+ if (processed > _bitStream._blockEnd)
+ break; // return S_FALSE;
+ {
+ const unsigned bits7 = _bitStream.GetProcessedBits7();
+ if (bits7 > _bitStream._blockEndBits7)
+ break; // return S_FALSE;
+ if (bits7 == _bitStream._blockEndBits7)
+ {
+ if (_isLastBlock)
+ {
+ _reps[0] = rep0;
+
+ if (_bitStream.InputEofError())
+ break;
+
+ /*
+ // packSize can be 15 bytes larger for encrypted archive
+ if (_packSize_Defined && _packSize < _bitStream.GetProcessedSize())
+ break;
+ */
+
+ return _bitStream._hres;
+ // break;
+ }
+ RINOK(ReadTables(_bitStream))
+ continue;
+ }
+ }
+ }
+
+ // that check is not required, but it can help, if there is BUG in another code
+ if (!_tableWasFilled)
+ break; // return S_FALSE;
+ }
+
+ const UInt32 sym = m_MainDecoder.Decode(&_bitStream);
+
+ if (sym < 256)
+ {
+ size_t winPos = _winPos;
+ _window[winPos] = (Byte)sym;
+ _winPos = winPos + 1;
+ _lzSize++;
+ continue;
+ }
+
+ UInt32 len;
+
+ if (sym < kSymbolRep + kNumReps)
+ {
+ if (sym >= kSymbolRep)
+ {
+ if (sym != kSymbolRep)
+ {
+ UInt32 dist;
+ if (sym == kSymbolRep + 1)
+ dist = _reps[1];
+ else
+ {
+ if (sym == kSymbolRep + 2)
+ dist = _reps[2];
+ else
+ {
+ dist = _reps[3];
+ _reps[3] = _reps[2];
+ }
+ _reps[2] = _reps[1];
+ }
+ _reps[1] = rep0;
+ rep0 = dist;
+ }
+
+ const UInt32 sym2 = m_LenDecoder.Decode(&_bitStream);
+ if (sym2 >= kLenTableSize)
+ break; // return S_FALSE;
+ len = SlotToLen(_bitStream, sym2);
+ }
+ else
+ {
+ if (sym == 256)
+ {
+ RINOK(AddFilter(_bitStream))
+ continue;
+ }
+ else // if (sym == 257)
+ {
+ len = _lastLen;
+ // if (len = 0), we ignore that symbol, like original unRAR code, but it can mean error in stream.
+ // if (len == 0) return S_FALSE;
+ if (len == 0)
+ continue;
+ }
+ }
+ }
+ else if (sym >= kMainTableSize)
+ break; // return S_FALSE;
+ else
+ {
+ _reps[3] = _reps[2];
+ _reps[2] = _reps[1];
+ _reps[1] = rep0;
+ len = SlotToLen(_bitStream, sym - (kSymbolRep + kNumReps));
+
+ rep0 = m_DistDecoder.Decode(&_bitStream);
+
+ if (rep0 >= 4)
+ {
+ if (rep0 >= _numCorrectDistSymbols)
+ break; // return S_FALSE;
+ const unsigned numBits = (rep0 >> 1) - 1;
+ rep0 = (2 | (rep0 & 1)) << numBits;
+
+ if (numBits < kNumAlignBits)
+ rep0 += _bitStream.ReadBits9(numBits);
+ else
+ {
+ len += (numBits >= 7);
+ len += (numBits >= 12);
+ len += (numBits >= 17);
+
+ if (_useAlignBits)
+ {
+ // if (numBits > kNumAlignBits)
+ rep0 += (_bitStream.ReadBits32(numBits - kNumAlignBits) << kNumAlignBits);
+ const UInt32 a = m_AlignDecoder.Decode(&_bitStream);
+ if (a >= kAlignTableSize)
+ break; // return S_FALSE;
+ rep0 += a;
+ }
+ else
+ rep0 += _bitStream.ReadBits32(numBits);
+ }
+ }
+ }
+
+ _lastLen = len;
+
+ if (rep0 >= _lzSize)
+ _lzError = true;
+
+ {
+ UInt32 lenCur = len;
+ size_t winPos = _winPos;
+ size_t pos = (winPos - (size_t)rep0 - 1) & _winMask;
+ {
+ const size_t rem = limit - winPos;
+ // size_t rem = _winSize - winPos;
+
+ if (lenCur > rem)
+ {
+ lenCur = (UInt32)rem;
+ remLen = len - lenCur;
+ }
+ }
+
+ Byte *win = _window;
+ _lzSize += lenCur;
+ _winPos = winPos + lenCur;
+ if (_winSize - pos >= lenCur)
+ {
+ const Byte *src = win + pos;
+ Byte *dest = win + winPos;
+ do
+ *dest++ = *src++;
+ while (--lenCur != 0);
+ }
+ else
+ {
+ do
+ {
+ win[winPos] = win[pos];
+ winPos++;
+ pos = (pos + 1) & _winMask;
+ }
+ while (--lenCur != 0);
+ }
+ }
+ }
+
+ if (_bitStream._hres != S_OK)
+ return _bitStream._hres;
+
+ return S_FALSE;
+}
+
+
+HRESULT CDecoder::CodeReal()
+{
+ _unsupportedFilter = false;
+ _lzError = false;
+ _writeError = false;
+
+ if (!_isSolid || !_wasInit)
+ {
+ size_t clearSize = _winSize;
+ if (_lzSize < _winSize)
+ clearSize = (size_t)_lzSize;
+ memset(_window, 0, clearSize);
+
+ _wasInit = true;
+ _lzSize = 0;
+ _lzWritten = 0;
+ _winPos = 0;
+
+ for (unsigned i = 0; i < kNumReps; i++)
+ _reps[i] = (UInt32)0 - 1;
+
+ _lastLen = 0;
+ _tableWasFilled = false;
+ }
+
+ _isLastBlock = false;
+
+ InitFilters();
+
+ _filterEnd = 0;
+ _writtenFileSize = 0;
+
+ _lzFileStart = _lzSize;
+ _lzWritten = _lzSize;
+
+ HRESULT res = DecodeLZ();
+
+ HRESULT res2 = S_OK;
+ if (!_writeError && res != E_OUTOFMEMORY)
+ res2 = WriteBuf();
+
+ /*
+ if (res == S_OK)
+ if (InputEofError())
+ res = S_FALSE;
+ */
+
+ if (res == S_OK)
+ {
+ _solidAllowed = true;
+ res = res2;
+ }
+
+ if (res == S_OK && _unpackSize_Defined && _writtenFileSize != _unpackSize)
+ return S_FALSE;
+ return res;
+}
+
+
+// Original unRAR claims that maximum possible filter block size is (1 << 16) now,
+// and (1 << 17) is minimum win size required to support filter.
+// Original unRAR uses (1 << 18) for "extra safety and possible filter area size expansion"
+// We can use any win size.
+
+static const unsigned kWinSize_Log_Min = 17;
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try
+ {
+ if (_isSolid && !_solidAllowed)
+ return S_FALSE;
+ _solidAllowed = false;
+
+ if (_dictSizeLog >= sizeof(size_t) * 8)
+ return E_NOTIMPL;
+
+ if (!_isSolid)
+ _lzEnd = 0;
+ else
+ {
+ if (_lzSize < _lzEnd)
+ {
+ if (_window)
+ {
+ UInt64 rem = _lzEnd - _lzSize;
+ if (rem >= _winSize)
+ memset(_window, 0, _winSize);
+ else
+ {
+ const size_t pos = (size_t)_lzSize & _winSize;
+ size_t rem2 = _winSize - pos;
+ if (rem2 > rem)
+ rem2 = (size_t)rem;
+ memset(_window + pos, 0, rem2);
+ rem -= rem2;
+ memset(_window, 0, (size_t)rem);
+ }
+ }
+ _lzEnd &= ((((UInt64)1) << 33) - 1);
+ _lzSize = _lzEnd;
+ _winPos = (size_t)(_lzSize & _winSize);
+ }
+ _lzEnd = _lzSize;
+ }
+
+ size_t newSize;
+ {
+ unsigned newSizeLog = _dictSizeLog;
+ if (newSizeLog < kWinSize_Log_Min)
+ newSizeLog = kWinSize_Log_Min;
+ newSize = (size_t)1 << newSizeLog;
+ _numCorrectDistSymbols = newSizeLog * 2;
+ }
+
+ // If dictionary was reduced, we use allocated dictionary block
+ // for compatibility with original unRAR decoder.
+
+ if (_window && newSize < _winSizeAllocated)
+ _winSize = _winSizeAllocated;
+ else if (!_window || _winSize != newSize)
+ {
+ if (!_isSolid)
+ {
+ ::MidFree(_window);
+ _window = NULL;
+ _winSizeAllocated = 0;
+ }
+
+ Byte *win;
+
+ {
+ win = (Byte *)::MidAlloc(newSize);
+ if (!win)
+ return E_OUTOFMEMORY;
+ memset(win, 0, newSize);
+ }
+
+ if (_isSolid && _window)
+ {
+ // original unRAR claims:
+ // "Archiving code guarantees that win size does not grow in the same solid stream",
+ // but the original unRAR decoder still supports such grow case.
+
+ Byte *winOld = _window;
+ const size_t oldSize = _winSize;
+ const size_t newMask = newSize - 1;
+ const size_t oldMask = _winSize - 1;
+ const size_t winPos = _winPos;
+ for (size_t i = 1; i <= oldSize; i++)
+ win[(winPos - i) & newMask] = winOld[(winPos - i) & oldMask];
+ ::MidFree(_window);
+ }
+
+ _window = win;
+ _winSizeAllocated = newSize;
+ _winSize = newSize;
+ }
+
+ _winMask = _winSize - 1;
+ _winPos &= _winMask;
+
+ if (!_inputBuf)
+ {
+ _inputBuf = (Byte *)::MidAlloc(kInputBufSize);
+ if (!_inputBuf)
+ return E_OUTOFMEMORY;
+ }
+
+ _inStream = inStream;
+ _outStream = outStream;
+
+ /*
+ _packSize = 0;
+ _packSize_Defined = (inSize != NULL);
+ if (_packSize_Defined)
+ _packSize = *inSize;
+ */
+
+ _unpackSize = 0;
+ _unpackSize_Defined = (outSize != NULL);
+ if (_unpackSize_Defined)
+ _unpackSize = *outSize;
+
+ if ((Int64)_unpackSize >= 0)
+ _lzEnd += _unpackSize;
+ else
+ _lzEnd = 0;
+
+ _progress = progress;
+
+ const HRESULT res = CodeReal();
+
+ if (res != S_OK)
+ return res;
+ if (_lzError)
+ return S_FALSE;
+ if (_unsupportedFilter)
+ return E_NOTIMPL;
+ return S_OK;
+ }
+ // catch(const CInBufferException &e) { return e.ErrorCode; }
+ // catch(...) { return S_FALSE; }
+ catch(...) { return E_OUTOFMEMORY; }
+ // CNewException is possible here. But probably CNewException is caused
+ // by error in data stream.
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ if (size != 2)
+ return E_NOTIMPL;
+ _dictSizeLog = (Byte)((data[0] & 0xF) + 17);
+ _isSolid = ((data[1] & 1) != 0);
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Compress/Rar5Decoder.h b/CPP/7zip/Compress/Rar5Decoder.h
new file mode 100644
index 0000000..daf05dd
--- /dev/null
+++ b/CPP/7zip/Compress/Rar5Decoder.h
@@ -0,0 +1,299 @@
+// Rar5Decoder.h
+// According to unRAR license, this code may not be used to develop
+// a program that creates RAR archives
+
+#ifndef ZIP7_INC_COMPRESS_RAR5_DECODER_H
+#define ZIP7_INC_COMPRESS_RAR5_DECODER_H
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/MyBuffer2.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyException.h"
+#include "../../Common/MyVector.h"
+
+#include "../ICoder.h"
+
+#include "HuffmanDecoder.h"
+
+namespace NCompress {
+namespace NRar5 {
+
+/*
+struct CInBufferException: public CSystemException
+{
+ CInBufferException(HRESULT errorCode): CSystemException(errorCode) {}
+};
+*/
+
+class CBitDecoder
+{
+public:
+ const Byte *_buf;
+ unsigned _bitPos;
+ bool _wasFinished;
+ Byte _blockEndBits7;
+ const Byte *_bufCheck2;
+ const Byte *_bufCheck;
+ Byte *_bufLim;
+ Byte *_bufBase;
+
+ UInt64 _processedSize;
+ UInt64 _blockEnd;
+
+ ISequentialInStream *_stream;
+ HRESULT _hres;
+
+ void SetCheck2()
+ {
+ _bufCheck2 = _bufCheck;
+ if (_bufCheck > _buf)
+ {
+ UInt64 processed = GetProcessedSize_Round();
+ if (_blockEnd < processed)
+ _bufCheck2 = _buf;
+ else
+ {
+ const UInt64 delta = _blockEnd - processed;
+ if ((size_t)(_bufCheck - _buf) > delta)
+ _bufCheck2 = _buf + (size_t)delta;
+ }
+ }
+ }
+
+ bool IsBlockOverRead() const
+ {
+ const UInt64 v = GetProcessedSize_Round();
+ if (v < _blockEnd)
+ return false;
+ if (v > _blockEnd)
+ return true;
+ return _bitPos > _blockEndBits7;
+ }
+
+ /*
+ CBitDecoder() throw():
+ _buf(0),
+ _bufLim(0),
+ _bufBase(0),
+ _stream(0),
+ _processedSize(0),
+ _wasFinished(false)
+ {}
+ */
+
+ void Init() throw()
+ {
+ _blockEnd = 0;
+ _blockEndBits7 = 0;
+
+ _bitPos = 0;
+ _processedSize = 0;
+ _buf = _bufBase;
+ _bufLim = _bufBase;
+ _bufCheck = _buf;
+ _bufCheck2 = _buf;
+ _wasFinished = false;
+ }
+
+ void Prepare2() throw();
+
+ void Prepare() throw()
+ {
+ if (_buf >= _bufCheck)
+ Prepare2();
+ }
+
+ bool ExtraBitsWereRead() const
+ {
+ return _buf >= _bufLim && (_buf > _bufLim || _bitPos != 0);
+ }
+
+ bool InputEofError() const { return ExtraBitsWereRead(); }
+
+ unsigned GetProcessedBits7() const { return _bitPos; }
+ UInt64 GetProcessedSize_Round() const { return _processedSize + (size_t)(_buf - _bufBase); }
+ UInt64 GetProcessedSize() const { return _processedSize + (size_t)(_buf - _bufBase) + ((_bitPos + 7) >> 3); }
+
+ void AlignToByte()
+ {
+ _buf += (_bitPos + 7) >> 3;
+ _bitPos = 0;
+ }
+
+ Byte ReadByteInAligned()
+ {
+ return *_buf++;
+ }
+
+ UInt32 GetValue(unsigned numBits) const
+ {
+ UInt32 v = ((UInt32)_buf[0] << 16) | ((UInt32)_buf[1] << 8) | (UInt32)_buf[2];
+ v >>= (24 - numBits - _bitPos);
+ return v & ((1 << numBits) - 1);
+ }
+
+ void MovePos(unsigned numBits)
+ {
+ _bitPos += numBits;
+ _buf += (_bitPos >> 3);
+ _bitPos &= 7;
+ }
+
+ UInt32 ReadBits9(unsigned numBits)
+ {
+ const Byte *buf = _buf;
+ UInt32 v = ((UInt32)buf[0] << 8) | (UInt32)buf[1];
+ v &= ((UInt32)0xFFFF >> _bitPos);
+ numBits += _bitPos;
+ v >>= (16 - numBits);
+ _buf = buf + (numBits >> 3);
+ _bitPos = numBits & 7;
+ return v;
+ }
+
+ UInt32 ReadBits9fix(unsigned numBits)
+ {
+ const Byte *buf = _buf;
+ UInt32 v = ((UInt32)buf[0] << 8) | (UInt32)buf[1];
+ const UInt32 mask = ((1 << numBits) - 1);
+ numBits += _bitPos;
+ v >>= (16 - numBits);
+ _buf = buf + (numBits >> 3);
+ _bitPos = numBits & 7;
+ return v & mask;
+ }
+
+ UInt32 ReadBits32(unsigned numBits)
+ {
+ const UInt32 mask = ((1 << numBits) - 1);
+ numBits += _bitPos;
+ const Byte *buf = _buf;
+ UInt32 v = GetBe32(buf);
+ if (numBits > 32)
+ {
+ v <<= (numBits - 32);
+ v |= (UInt32)buf[4] >> (40 - numBits);
+ }
+ else
+ v >>= (32 - numBits);
+ _buf = buf + (numBits >> 3);
+ _bitPos = numBits & 7;
+ return v & mask;
+ }
+};
+
+
+struct CFilter
+{
+ Byte Type;
+ Byte Channels;
+ UInt32 Size;
+ UInt64 Start;
+};
+
+
+const unsigned kNumReps = 4;
+const unsigned kLenTableSize = 11 * 4;
+const unsigned kMainTableSize = 256 + 1 + 1 + kNumReps + kLenTableSize;
+const unsigned kDistTableSize = 64;
+const unsigned kNumAlignBits = 4;
+const unsigned kAlignTableSize = (1 << kNumAlignBits);
+const unsigned kLevelTableSize = 20;
+const unsigned kTablesSizesSum = kMainTableSize + kDistTableSize + kAlignTableSize + kLenTableSize;
+
+const unsigned kNumHuffmanBits = 15;
+
+Z7_CLASS_IMP_NOQIB_2(
+ CDecoder
+ , ICompressCoder
+ , ICompressSetDecoderProperties2
+)
+ bool _useAlignBits;
+ bool _isLastBlock;
+ bool _unpackSize_Defined;
+ // bool _packSize_Defined;
+
+ bool _unsupportedFilter;
+ bool _lzError;
+ bool _writeError;
+
+ bool _isSolid;
+ bool _solidAllowed;
+ bool _tableWasFilled;
+ bool _wasInit;
+
+ Byte _dictSizeLog;
+
+ // CBitDecoder _bitStream;
+ Byte *_window;
+ size_t _winPos;
+ size_t _winSize;
+ size_t _winMask;
+
+ UInt64 _lzSize;
+
+ unsigned _numCorrectDistSymbols;
+ unsigned _numUnusedFilters;
+
+ UInt64 _lzWritten;
+ UInt64 _lzFileStart;
+ UInt64 _unpackSize;
+ // UInt64 _packSize;
+ UInt64 _lzEnd;
+ UInt64 _writtenFileSize;
+ size_t _winSizeAllocated;
+
+ UInt32 _reps[kNumReps];
+ UInt32 _lastLen;
+
+ UInt64 _filterEnd;
+ CMidBuffer _filterSrc;
+ CMidBuffer _filterDst;
+
+ CRecordVector<CFilter> _filters;
+
+ ISequentialInStream *_inStream;
+ ISequentialOutStream *_outStream;
+ ICompressProgressInfo *_progress;
+ Byte *_inputBuf;
+
+ NHuffman::CDecoder<kNumHuffmanBits, kMainTableSize> m_MainDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kDistTableSize> m_DistDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kAlignTableSize> m_AlignDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kLenTableSize> m_LenDecoder;
+ NHuffman::CDecoder<kNumHuffmanBits, kLevelTableSize> m_LevelDecoder;
+
+
+ void InitFilters()
+ {
+ _numUnusedFilters = 0;
+ _filters.Clear();
+ }
+
+ void DeleteUnusedFilters()
+ {
+ if (_numUnusedFilters != 0)
+ {
+ _filters.DeleteFrontal(_numUnusedFilters);
+ _numUnusedFilters = 0;
+ }
+ }
+
+ HRESULT WriteData(const Byte *data, size_t size);
+ HRESULT ExecuteFilter(const CFilter &f);
+ HRESULT WriteBuf();
+ HRESULT AddFilter(CBitDecoder &_bitStream);
+
+ HRESULT ReadTables(CBitDecoder &_bitStream);
+ HRESULT DecodeLZ();
+ HRESULT CodeReal();
+
+public:
+ CDecoder();
+ ~CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/RarCodecsRegister.cpp b/CPP/7zip/Compress/RarCodecsRegister.cpp
new file mode 100644
index 0000000..e1bc3d9
--- /dev/null
+++ b/CPP/7zip/Compress/RarCodecsRegister.cpp
@@ -0,0 +1,33 @@
+// RarCodecsRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "Rar1Decoder.h"
+#include "Rar2Decoder.h"
+#include "Rar3Decoder.h"
+#include "Rar5Decoder.h"
+
+namespace NCompress {
+
+#define CREATE_CODEC(x) REGISTER_CODEC_CREATE(CreateCodec ## x, NRar ## x::CDecoder())
+
+CREATE_CODEC(1)
+CREATE_CODEC(2)
+CREATE_CODEC(3)
+CREATE_CODEC(5)
+
+#define RAR_CODEC(x, name) { CreateCodec ## x, NULL, 0x40300 + x, "Rar" name, 1, false }
+
+REGISTER_CODECS_VAR
+{
+ RAR_CODEC(1, "1"),
+ RAR_CODEC(2, "2"),
+ RAR_CODEC(3, "3"),
+ RAR_CODEC(5, "5"),
+};
+
+REGISTER_CODECS(Rar)
+
+}
diff --git a/CPP/7zip/Compress/ShrinkDecoder.cpp b/CPP/7zip/Compress/ShrinkDecoder.cpp
new file mode 100644
index 0000000..c8e2083
--- /dev/null
+++ b/CPP/7zip/Compress/ShrinkDecoder.cpp
@@ -0,0 +1,244 @@
+// ShrinkDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/InBuffer.h"
+#include "../Common/OutBuffer.h"
+
+#include "BitlDecoder.h"
+#include "ShrinkDecoder.h"
+
+namespace NCompress {
+namespace NShrink {
+
+static const UInt32 kEmpty = 256; // kNumItems;
+static const UInt32 kBufferSize = (1 << 18);
+static const unsigned kNumMinBits = 9;
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+ NBitl::CBaseDecoder<CInBuffer> inBuffer;
+ COutBuffer outBuffer;
+
+ if (!inBuffer.Create(kBufferSize))
+ return E_OUTOFMEMORY;
+ if (!outBuffer.Create(kBufferSize))
+ return E_OUTOFMEMORY;
+
+ inBuffer.SetStream(inStream);
+ inBuffer.Init();
+
+ outBuffer.SetStream(outStream);
+ outBuffer.Init();
+
+ {
+ for (unsigned i = 0; i < kNumItems; i++)
+ _parents[i] = kEmpty;
+ }
+
+ UInt64 outPrev = 0, inPrev = 0;
+ unsigned numBits = kNumMinBits;
+ unsigned head = 257;
+ int lastSym = -1;
+ Byte lastChar = 0;
+ bool moreOut = false;
+
+ HRESULT res = S_FALSE;
+
+ for (;;)
+ {
+ _inProcessed = inBuffer.GetProcessedSize();
+ const UInt64 nowPos = outBuffer.GetProcessedSize();
+
+ bool eofCheck = false;
+
+ if (outSize && nowPos >= *outSize)
+ {
+ if (!_fullStreamMode || moreOut)
+ {
+ res = S_OK;
+ break;
+ }
+ eofCheck = true;
+ // Is specSym(=256) allowed after end of stream ?
+ // Do we need to read it here ?
+ }
+
+ if (progress)
+ {
+ if (nowPos - outPrev >= (1 << 20) || _inProcessed - inPrev >= (1 << 20))
+ {
+ outPrev = nowPos;
+ inPrev = _inProcessed;
+ res = progress->SetRatioInfo(&_inProcessed, &nowPos);
+ if (res != SZ_OK)
+ {
+ // break;
+ return res;
+ }
+ }
+ }
+
+ UInt32 sym = inBuffer.ReadBits(numBits);
+
+ if (inBuffer.ExtraBitsWereRead())
+ {
+ res = S_OK;
+ break;
+ }
+
+ if (sym == 256)
+ {
+ sym = inBuffer.ReadBits(numBits);
+
+ if (inBuffer.ExtraBitsWereRead())
+ break;
+
+ if (sym == 1)
+ {
+ if (numBits >= kNumMaxBits)
+ break;
+ numBits++;
+ continue;
+ }
+ if (sym != 2)
+ {
+ break;
+ // continue; // info-zip just ignores such code
+ }
+ {
+ /*
+ ---------- Free leaf nodes ----------
+ Note : that code can mark _parents[lastSym] as free, and next
+ inserted node will be Orphan in that case.
+ */
+
+ unsigned i;
+ for (i = 256; i < kNumItems; i++)
+ _stack[i] = 0;
+ for (i = 257; i < kNumItems; i++)
+ {
+ unsigned par = _parents[i];
+ if (par != kEmpty)
+ _stack[par] = 1;
+ }
+ for (i = 257; i < kNumItems; i++)
+ if (_stack[i] == 0)
+ _parents[i] = kEmpty;
+ head = 257;
+ continue;
+ }
+ }
+
+ if (eofCheck)
+ {
+ // It's can be error case.
+ // That error can be detected later in (*inSize != _inProcessed) check.
+ res = S_OK;
+ break;
+ }
+
+ bool needPrev = false;
+ if (head < kNumItems && lastSym >= 0)
+ {
+ while (head < kNumItems && _parents[head] != kEmpty)
+ head++;
+ if (head < kNumItems)
+ {
+ /*
+ if (head == lastSym), it updates Orphan to self-linked Orphan and creates two problems:
+ 1) we must check _stack[i++] overflow in code that walks tree nodes.
+ 2) self-linked node can not be removed. So such self-linked nodes can occupy all _parents items.
+ */
+ needPrev = true;
+ _parents[head] = (UInt16)lastSym;
+ _suffixes[head] = (Byte)lastChar;
+ head++;
+ }
+ }
+
+ lastSym = (int)sym;
+ unsigned cur = sym;
+ unsigned i = 0;
+
+ while (cur >= 256)
+ {
+ _stack[i++] = _suffixes[cur];
+ cur = _parents[cur];
+ // don't change that code:
+ // Orphan Check and self-linked Orphan check (_stack overflow check);
+ if (cur == kEmpty || i >= kNumItems)
+ break;
+ }
+
+ if (cur == kEmpty || i >= kNumItems)
+ break;
+
+ _stack[i++] = (Byte)cur;
+ lastChar = (Byte)cur;
+
+ if (needPrev)
+ _suffixes[(size_t)head - 1] = (Byte)cur;
+
+ if (outSize)
+ {
+ const UInt64 limit = *outSize - nowPos;
+ if (i > limit)
+ {
+ moreOut = true;
+ i = (unsigned)limit;
+ }
+ }
+
+ do
+ outBuffer.WriteByte(_stack[--i]);
+ while (i);
+ }
+
+ RINOK(outBuffer.Flush())
+
+ if (res == S_OK)
+ if (_fullStreamMode)
+ {
+ if (moreOut)
+ res = S_FALSE;
+ const UInt64 nowPos = outBuffer.GetProcessedSize();
+ if (outSize && *outSize != nowPos)
+ res = S_FALSE;
+ if (inSize && *inSize != _inProcessed)
+ res = S_FALSE;
+ }
+
+ return res;
+}
+
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ // catch(const CInBufferException &e) { return e.ErrorCode; }
+ // catch(const COutBufferException &e) { return e.ErrorCode; }
+ catch(const CSystemException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+
+Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+{
+ _fullStreamMode = (finishMode != 0);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = _inProcessed;
+ return S_OK;
+}
+
+
+}}
diff --git a/CPP/7zip/Compress/ShrinkDecoder.h b/CPP/7zip/Compress/ShrinkDecoder.h
new file mode 100644
index 0000000..5e7f78f
--- /dev/null
+++ b/CPP/7zip/Compress/ShrinkDecoder.h
@@ -0,0 +1,35 @@
+// ShrinkDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_SHRINK_DECODER_H
+#define ZIP7_INC_COMPRESS_SHRINK_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NShrink {
+
+const unsigned kNumMaxBits = 13;
+const unsigned kNumItems = 1 << kNumMaxBits;
+
+Z7_CLASS_IMP_NOQIB_3(
+ CDecoder
+ , ICompressCoder
+ , ICompressSetFinishMode
+ , ICompressGetInStreamProcessedSize
+)
+ bool _fullStreamMode;
+ UInt64 _inProcessed;
+
+ UInt16 _parents[kNumItems];
+ Byte _suffixes[kNumItems];
+ Byte _stack[kNumItems];
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/StdAfx.h b/CPP/7zip/Compress/StdAfx.h
index 42a088f..8086655 100644
--- a/CPP/7zip/Compress/StdAfx.h
+++ b/CPP/7zip/Compress/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Compress/XpressDecoder.cpp b/CPP/7zip/Compress/XpressDecoder.cpp
new file mode 100644
index 0000000..8816a12
--- /dev/null
+++ b/CPP/7zip/Compress/XpressDecoder.cpp
@@ -0,0 +1,131 @@
+// XpressDecoder.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "HuffmanDecoder.h"
+#include "XpressDecoder.h"
+
+namespace NCompress {
+namespace NXpress {
+
+struct CBitStream
+{
+ UInt32 Value;
+ unsigned BitPos;
+
+ UInt32 GetValue(unsigned numBits) const
+ {
+ return (Value >> (BitPos - numBits)) & ((1 << numBits) - 1);
+ }
+
+ void MovePos(unsigned numBits)
+ {
+ BitPos -= numBits;
+ }
+};
+
+#define BIT_STREAM_NORMALIZE \
+ if (bs.BitPos < 16) { \
+ if (in >= lim) return S_FALSE; \
+ bs.Value = (bs.Value << 16) | GetUi16(in); \
+ in += 2; bs.BitPos += 16; }
+
+static const unsigned kNumHuffBits = 15;
+static const unsigned kNumLenBits = 4;
+static const unsigned kLenMask = (1 << kNumLenBits) - 1;
+static const unsigned kNumPosSlots = 16;
+static const unsigned kNumSyms = 256 + (kNumPosSlots << kNumLenBits);
+
+HRESULT Decode(const Byte *in, size_t inSize, Byte *out, size_t outSize)
+{
+ NCompress::NHuffman::CDecoder<kNumHuffBits, kNumSyms> huff;
+
+ if (inSize < kNumSyms / 2 + 4)
+ return S_FALSE;
+ {
+ Byte levels[kNumSyms];
+ for (unsigned i = 0; i < kNumSyms / 2; i++)
+ {
+ const Byte b = in[i];
+ levels[(size_t)i * 2] = (Byte)(b & 0xF);
+ levels[(size_t)i * 2 + 1] = (Byte)(b >> 4);
+ }
+ if (!huff.BuildFull(levels))
+ return S_FALSE;
+ }
+
+
+ CBitStream bs;
+
+ const Byte *lim = in + inSize - 1;
+
+ in += kNumSyms / 2;
+ bs.Value = ((UInt32)GetUi16(in) << 16) | GetUi16(in + 2);
+ in += 4;
+ bs.BitPos = 32;
+
+ size_t pos = 0;
+
+ for (;;)
+ {
+ // printf("\n%d", pos);
+ UInt32 sym = huff.DecodeFull(&bs);
+ // printf(" sym = %d", sym);
+ BIT_STREAM_NORMALIZE
+
+ if (pos >= outSize)
+ return (sym == 256 && in == lim + 1) ? S_OK : S_FALSE;
+
+ if (sym < 256)
+ out[pos++] = (Byte)sym;
+ else
+ {
+ sym -= 256;
+ UInt32 dist = sym >> kNumLenBits;
+ UInt32 len = sym & kLenMask;
+
+ if (len == kLenMask)
+ {
+ if (in > lim)
+ return S_FALSE;
+ len = *in++;
+ if (len == 0xFF)
+ {
+ if (in >= lim)
+ return S_FALSE;
+ len = GetUi16(in);
+ in += 2;
+ }
+ else
+ len += kLenMask;
+ }
+
+ bs.BitPos -= dist;
+ dist = (UInt32)1 << dist;
+ dist += ((bs.Value >> bs.BitPos) & (dist - 1));
+
+ BIT_STREAM_NORMALIZE
+
+ if (len + 3 > outSize - pos)
+ return S_FALSE;
+ if (dist > pos)
+ return S_FALSE;
+
+ Byte *dest = out + pos;
+ const Byte *src = dest - dist;
+ pos += len + 3;
+ len += 1;
+ *dest++ = *src++;
+ *dest++ = *src++;
+ do
+ *dest++ = *src++;
+ while (--len);
+ }
+ }
+}
+
+}}
diff --git a/CPP/7zip/Compress/XpressDecoder.h b/CPP/7zip/Compress/XpressDecoder.h
new file mode 100644
index 0000000..aaa5b25
--- /dev/null
+++ b/CPP/7zip/Compress/XpressDecoder.h
@@ -0,0 +1,15 @@
+// XpressDecoder.h
+
+#ifndef ZIP7_INC_XPRESS_DECODER_H
+#define ZIP7_INC_XPRESS_DECODER_H
+
+#include "../../Common/MyWindows.h"
+
+namespace NCompress {
+namespace NXpress {
+
+HRESULT Decode(const Byte *in, size_t inSize, Byte *out, size_t outSize);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/XzDecoder.cpp b/CPP/7zip/Compress/XzDecoder.cpp
index 4fcd09f..420bd71 100644
--- a/CPP/7zip/Compress/XzDecoder.cpp
+++ b/CPP/7zip/Compress/XzDecoder.cpp
@@ -1,150 +1,150 @@
-// XzDecoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../Common/CWrappers.h"
-
-#include "XzDecoder.h"
-
-namespace NCompress {
-namespace NXz {
-
-#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
-
-#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
-
-static HRESULT SResToHRESULT_Code(SRes res) throw()
-{
- if (res < 0)
- return res;
- switch (res)
- {
- case SZ_OK: return S_OK;
- case SZ_ERROR_MEM: return E_OUTOFMEMORY;
- case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
- }
- return S_FALSE;
-}
-
-
-HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
- const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *progress)
-{
- MainDecodeSRes = S_OK;
- MainDecodeSRes_wasUsed = false;
- XzStatInfo_Clear(&Stat);
-
- if (!xz)
- {
- xz = XzDecMt_Create(&g_Alloc, &g_MidAlloc);
- if (!xz)
- return E_OUTOFMEMORY;
- }
-
- CXzDecMtProps props;
- XzDecMtProps_Init(&props);
-
- int isMT = False;
-
- #ifndef _7ZIP_ST
- {
- props.numThreads = 1;
- UInt32 numThreads = _numThreads;
-
- if (_tryMt && numThreads > 1)
- {
- size_t memUsage = (size_t)_memUsage;
- if (memUsage != _memUsage)
- memUsage = (size_t)0 - 1;
- props.memUseMax = memUsage;
- isMT = (numThreads > 1);
- }
-
- props.numThreads = numThreads;
- }
- #endif
-
- CSeqInStreamWrap inWrap;
- CSeqOutStreamWrap outWrap;
- CCompressProgressWrap progressWrap;
-
- inWrap.Init(seqInStream);
- outWrap.Init(outStream);
- progressWrap.Init(progress);
-
- SRes res = XzDecMt_Decode(xz,
- &props,
- outSizeLimit, finishStream,
- &outWrap.vt,
- &inWrap.vt,
- &Stat,
- &isMT,
- progress ? &progressWrap.vt : NULL);
-
- MainDecodeSRes = res;
-
- #ifndef _7ZIP_ST
- // _tryMt = isMT;
- #endif
-
- RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
- RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
- RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
-
- // return E_OUTOFMEMORY;
-
- MainDecodeSRes_wasUsed = true;
-
- if (res == SZ_OK && finishStream)
- {
- /*
- if (inSize && *inSize != Stat.PhySize)
- res = SZ_ERROR_DATA;
- */
- if (outSizeLimit && *outSizeLimit != outWrap.Processed)
- res = SZ_ERROR_DATA;
- }
-
- return SResToHRESULT_Code(res);
-}
-
-
-HRESULT CComDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
-{
- return Decode(inStream, outStream, outSize, _finishStream, progress);
-}
-
-STDMETHODIMP CComDecoder::SetFinishMode(UInt32 finishMode)
-{
- _finishStream = (finishMode != 0);
- return S_OK;
-}
-
-STDMETHODIMP CComDecoder::GetInStreamProcessedSize(UInt64 *value)
-{
- *value = Stat.InSize;
- return S_OK;
-}
-
-#ifndef _7ZIP_ST
-
-STDMETHODIMP CComDecoder::SetNumberOfThreads(UInt32 numThreads)
-{
- _numThreads = numThreads;
- return S_OK;
-}
-
-STDMETHODIMP CComDecoder::SetMemLimit(UInt64 memUsage)
-{
- _memUsage = memUsage;
- return S_OK;
-}
-
-#endif
-
-}}
+// XzDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/CWrappers.h"
+
+#include "XzDecoder.h"
+
+namespace NCompress {
+namespace NXz {
+
+#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+static HRESULT SResToHRESULT_Code(SRes res) throw()
+{
+ if (res < 0)
+ return res;
+ switch (res)
+ {
+ case SZ_OK: return S_OK;
+ case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+ case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
+ }
+ return S_FALSE;
+}
+
+
+HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
+ const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *progress)
+{
+ MainDecodeSRes = SZ_OK;
+ MainDecodeSRes_wasUsed = false;
+ XzStatInfo_Clear(&Stat);
+
+ if (!xz)
+ {
+ xz = XzDecMt_Create(&g_Alloc, &g_MidAlloc);
+ if (!xz)
+ return E_OUTOFMEMORY;
+ }
+
+ CXzDecMtProps props;
+ XzDecMtProps_Init(&props);
+
+ int isMT = False;
+
+ #ifndef Z7_ST
+ {
+ props.numThreads = 1;
+ const UInt32 numThreads = _numThreads;
+
+ if (_tryMt && numThreads > 1)
+ {
+ size_t memUsage = (size_t)_memUsage;
+ if (memUsage != _memUsage)
+ memUsage = (size_t)0 - 1;
+ props.memUseMax = memUsage;
+ isMT = (numThreads > 1);
+ }
+
+ props.numThreads = numThreads;
+ }
+ #endif
+
+ CSeqInStreamWrap inWrap;
+ CSeqOutStreamWrap outWrap;
+ CCompressProgressWrap progressWrap;
+
+ inWrap.Init(seqInStream);
+ outWrap.Init(outStream);
+ progressWrap.Init(progress);
+
+ SRes res = XzDecMt_Decode(xz,
+ &props,
+ outSizeLimit, finishStream,
+ &outWrap.vt,
+ &inWrap.vt,
+ &Stat,
+ &isMT,
+ progress ? &progressWrap.vt : NULL);
+
+ MainDecodeSRes = res;
+
+ #ifndef Z7_ST
+ // _tryMt = isMT;
+ #endif
+
+ RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+ RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+ RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
+
+ // return E_OUTOFMEMORY; // for debug check
+
+ MainDecodeSRes_wasUsed = true;
+
+ if (res == SZ_OK && finishStream)
+ {
+ /*
+ if (inSize && *inSize != Stat.PhySize)
+ res = SZ_ERROR_DATA;
+ */
+ if (outSizeLimit && *outSizeLimit != outWrap.Processed)
+ res = SZ_ERROR_DATA;
+ }
+
+ return SResToHRESULT_Code(res);
+}
+
+
+Z7_COM7F_IMF(CComDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ return Decode(inStream, outStream, outSize, _finishStream, progress);
+}
+
+Z7_COM7F_IMF(CComDecoder::SetFinishMode(UInt32 finishMode))
+{
+ _finishStream = (finishMode != 0);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CComDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+ *value = Stat.InSize;
+ return S_OK;
+}
+
+#ifndef Z7_ST
+
+Z7_COM7F_IMF(CComDecoder::SetNumberOfThreads(UInt32 numThreads))
+{
+ _numThreads = numThreads;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CComDecoder::SetMemLimit(UInt64 memUsage))
+{
+ _memUsage = memUsage;
+ return S_OK;
+}
+
+#endif
+
+}}
diff --git a/CPP/7zip/Compress/XzDecoder.h b/CPP/7zip/Compress/XzDecoder.h
index 76694ee..40ed4f5 100644
--- a/CPP/7zip/Compress/XzDecoder.h
+++ b/CPP/7zip/Compress/XzDecoder.h
@@ -1,92 +1,86 @@
-// XzDecoder.h
-
-#ifndef __XZ_DECODER_H
-#define __XZ_DECODER_H
-
-#include "../../../C/Xz.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NXz {
-
-struct CDecoder
-{
- CXzDecMtHandle xz;
- int _tryMt;
- UInt32 _numThreads;
- UInt64 _memUsage;
-
- SRes MainDecodeSRes; // it's not HRESULT
- bool MainDecodeSRes_wasUsed;
- CXzStatInfo Stat;
-
- CDecoder():
- xz(NULL),
- _tryMt(True),
- _numThreads(1),
- _memUsage((UInt64)(sizeof(size_t)) << 28),
- MainDecodeSRes(SZ_OK),
- MainDecodeSRes_wasUsed(false)
- {}
-
- ~CDecoder()
- {
- if (xz)
- XzDecMt_Destroy(xz);
- }
-
- /* Decode() can return ERROR code only if there is progress or stream error.
- Decode() returns S_OK in case of xz decoding error, but DecodeRes and CStatInfo contain error information */
- HRESULT Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
- const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *compressProgress);
-};
-
-
-class CComDecoder:
- public ICompressCoder,
- public ICompressSetFinishMode,
- public ICompressGetInStreamProcessedSize,
-
- #ifndef _7ZIP_ST
- public ICompressSetCoderMt,
- public ICompressSetMemLimit,
- #endif
-
- public CMyUnknownImp,
- public CDecoder
-{
- bool _finishStream;
-
-public:
- MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
-
- MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
- MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
-
- #ifndef _7ZIP_ST
- MY_QUERYINTERFACE_ENTRY(ICompressSetCoderMt)
- MY_QUERYINTERFACE_ENTRY(ICompressSetMemLimit)
- #endif
-
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetFinishMode)(UInt32 finishMode);
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
-
- #ifndef _7ZIP_ST
- STDMETHOD(SetNumberOfThreads)(UInt32 numThreads);
- STDMETHOD(SetMemLimit)(UInt64 memUsage);
- #endif
-
- CComDecoder(): _finishStream(false) {}
-};
-
-}}
-
-#endif
+// XzDecoder.h
+
+#ifndef ZIP7_INC_XZ_DECODER_H
+#define ZIP7_INC_XZ_DECODER_H
+
+#include "../../../C/Xz.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NXz {
+
+struct CDecoder
+{
+ CXzDecMtHandle xz;
+ int _tryMt;
+ UInt32 _numThreads;
+ UInt64 _memUsage;
+
+ SRes MainDecodeSRes; // it's not HRESULT
+ bool MainDecodeSRes_wasUsed;
+ CXzStatInfo Stat;
+
+ CDecoder():
+ xz(NULL),
+ _tryMt(True),
+ _numThreads(1),
+ _memUsage((UInt64)(sizeof(size_t)) << 28),
+ MainDecodeSRes(SZ_OK),
+ MainDecodeSRes_wasUsed(false)
+ {}
+
+ ~CDecoder()
+ {
+ if (xz)
+ XzDecMt_Destroy(xz);
+ }
+
+ /* Decode() can return S_OK, if there is data after good xz streams, and that data is not new xz stream.
+ check also (Stat.DataAfterEnd) flag */
+
+ HRESULT Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
+ const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *compressProgress);
+};
+
+
+class CComDecoder Z7_final:
+ public ICompressCoder,
+ public ICompressSetFinishMode,
+ public ICompressGetInStreamProcessedSize,
+ #ifndef Z7_ST
+ public ICompressSetCoderMt,
+ public ICompressSetMemLimit,
+ #endif
+ public CMyUnknownImp,
+ public CDecoder
+{
+ Z7_COM_QI_BEGIN2(ICompressCoder)
+ Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+ Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ #ifndef Z7_ST
+ Z7_COM_QI_ENTRY(ICompressSetCoderMt)
+ Z7_COM_QI_ENTRY(ICompressSetMemLimit)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressCoder)
+ Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+ Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ #ifndef Z7_ST
+ Z7_IFACE_COM7_IMP(ICompressSetCoderMt)
+ Z7_IFACE_COM7_IMP(ICompressSetMemLimit)
+ #endif
+
+ bool _finishStream;
+
+public:
+ CComDecoder(): _finishStream(false) {}
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/XzEncoder.cpp b/CPP/7zip/Compress/XzEncoder.cpp
index 458a928..33f0bde 100644
--- a/CPP/7zip/Compress/XzEncoder.cpp
+++ b/CPP/7zip/Compress/XzEncoder.cpp
@@ -1,245 +1,243 @@
-// XzEncoder.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Alloc.h"
-
-#include "../../Common/MyString.h"
-#include "../../Common/StringToInt.h"
-
-#include "../Common/CWrappers.h"
-#include "../Common/StreamUtils.h"
-
-#include "XzEncoder.h"
-
-namespace NCompress {
-
-namespace NLzma2 {
-
-HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props);
-
-}
-
-namespace NXz {
-
-void CEncoder::InitCoderProps()
-{
- XzProps_Init(&xzProps);
-}
-
-CEncoder::CEncoder()
-{
- XzProps_Init(&xzProps);
- _encoder = NULL;
- _encoder = XzEnc_Create(&g_Alloc, &g_BigAlloc);
- if (!_encoder)
- throw 1;
-}
-
-CEncoder::~CEncoder()
-{
- if (_encoder)
- XzEnc_Destroy(_encoder);
-}
-
-
-struct CMethodNamePair
-{
- UInt32 Id;
- const char *Name;
-};
-
-static const CMethodNamePair g_NamePairs[] =
-{
- { XZ_ID_Delta, "Delta" },
- { XZ_ID_X86, "BCJ" },
- { XZ_ID_PPC, "PPC" },
- { XZ_ID_IA64, "IA64" },
- { XZ_ID_ARM, "ARM" },
- { XZ_ID_ARMT, "ARMT" },
- { XZ_ID_SPARC, "SPARC" }
- // { XZ_ID_LZMA2, "LZMA2" }
-};
-
-static int FilterIdFromName(const wchar_t *name)
-{
- for (unsigned i = 0; i < ARRAY_SIZE(g_NamePairs); i++)
- {
- const CMethodNamePair &pair = g_NamePairs[i];
- if (StringsAreEqualNoCase_Ascii(name, pair.Name))
- return (int)pair.Id;
- }
- return -1;
-}
-
-
-HRESULT CEncoder::SetCheckSize(UInt32 checkSizeInBytes)
-{
- unsigned id;
- switch (checkSizeInBytes)
- {
- case 0: id = XZ_CHECK_NO; break;
- case 4: id = XZ_CHECK_CRC32; break;
- case 8: id = XZ_CHECK_CRC64; break;
- case 32: id = XZ_CHECK_SHA256; break;
- default: return E_INVALIDARG;
- }
- xzProps.checkId = id;
- return S_OK;
-}
-
-
-HRESULT CEncoder::SetCoderProp(PROPID propID, const PROPVARIANT &prop)
-{
- if (propID == NCoderPropID::kNumThreads)
- {
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- xzProps.numTotalThreads = (int)(prop.ulVal);
- return S_OK;
- }
-
- if (propID == NCoderPropID::kCheckSize)
- {
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- return SetCheckSize(prop.ulVal);
- }
-
- if (propID == NCoderPropID::kBlockSize2)
- {
- if (prop.vt == VT_UI4)
- xzProps.blockSize = prop.ulVal;
- else if (prop.vt == VT_UI8)
- xzProps.blockSize = prop.uhVal.QuadPart;
- else
- return E_INVALIDARG;
- return S_OK;
- }
-
- if (propID == NCoderPropID::kReduceSize)
- {
- if (prop.vt == VT_UI8)
- xzProps.reduceSize = prop.uhVal.QuadPart;
- else
- return E_INVALIDARG;
- return S_OK;
- }
-
- if (propID == NCoderPropID::kFilter)
- {
- if (prop.vt == VT_UI4)
- {
- UInt32 id32 = prop.ulVal;
- if (id32 == XZ_ID_Delta)
- return E_INVALIDARG;
- xzProps.filterProps.id = prop.ulVal;
- }
- else
- {
- if (prop.vt != VT_BSTR)
- return E_INVALIDARG;
-
- const wchar_t *name = prop.bstrVal;
- const wchar_t *end;
-
- UInt32 id32 = ConvertStringToUInt32(name, &end);
-
- if (end != name)
- name = end;
- else
- {
- if (IsString1PrefixedByString2_NoCase_Ascii(name, "Delta"))
- {
- name += 5; // strlen("Delta");
- id32 = XZ_ID_Delta;
- }
- else
- {
- int filterId = FilterIdFromName(prop.bstrVal);
- if (filterId < 0 /* || filterId == XZ_ID_LZMA2 */)
- return E_INVALIDARG;
- id32 = filterId;
- }
- }
-
- if (id32 == XZ_ID_Delta)
- {
- wchar_t c = *name;
- if (c != '-' && c != ':')
- return E_INVALIDARG;
- name++;
- UInt32 delta = ConvertStringToUInt32(name, &end);
- if (end == name || *end != 0 || delta == 0 || delta > 256)
- return E_INVALIDARG;
- xzProps.filterProps.delta = delta;
- }
-
- xzProps.filterProps.id = id32;
- }
-
- return S_OK;
- }
-
- return NLzma2::SetLzma2Prop(propID, prop, xzProps.lzma2Props);
-}
-
-
-STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
- const PROPVARIANT *coderProps, UInt32 numProps)
-{
- XzProps_Init(&xzProps);
-
- for (UInt32 i = 0; i < numProps; i++)
- {
- RINOK(SetCoderProp(propIDs[i], coderProps[i]));
- }
-
- return S_OK;
- // return SResToHRESULT(XzEnc_SetProps(_encoder, &xzProps));
-}
-
-
-STDMETHODIMP CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
- const PROPVARIANT *coderProps, UInt32 numProps)
-{
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- PROPID propID = propIDs[i];
- if (propID == NCoderPropID::kExpectedDataSize)
- if (prop.vt == VT_UI8)
- XzEnc_SetDataSize(_encoder, prop.uhVal.QuadPart);
- }
- return S_OK;
-}
-
-
-#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
- if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
-
-STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
-{
- CSeqInStreamWrap inWrap;
- CSeqOutStreamWrap outWrap;
- CCompressProgressWrap progressWrap;
-
- inWrap.Init(inStream);
- outWrap.Init(outStream);
- progressWrap.Init(progress);
-
- SRes res = XzEnc_SetProps(_encoder, &xzProps);
- if (res == SZ_OK)
- res = XzEnc_Encode(_encoder, &outWrap.vt, &inWrap.vt, progress ? &progressWrap.vt : NULL);
-
- // SRes res = Xz_Encode(&outWrap.vt, &inWrap.vt, &xzProps, progress ? &progressWrap.vt : NULL);
-
- RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
- RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
- RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
-
- return SResToHRESULT(res);
-}
-
-}}
+// XzEncoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../../Common/MyString.h"
+#include "../../Common/StringToInt.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/StreamUtils.h"
+
+#include "XzEncoder.h"
+
+namespace NCompress {
+
+namespace NLzma2 {
+HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props);
+}
+
+namespace NXz {
+
+void CEncoder::InitCoderProps()
+{
+ XzProps_Init(&xzProps);
+}
+
+CEncoder::CEncoder()
+{
+ XzProps_Init(&xzProps);
+ _encoder = NULL;
+ _encoder = XzEnc_Create(&g_Alloc, &g_BigAlloc);
+ if (!_encoder)
+ throw 1;
+}
+
+CEncoder::~CEncoder()
+{
+ if (_encoder)
+ XzEnc_Destroy(_encoder);
+}
+
+
+struct CMethodNamePair
+{
+ UInt32 Id;
+ const char *Name;
+};
+
+static const CMethodNamePair g_NamePairs[] =
+{
+ { XZ_ID_Delta, "Delta" },
+ { XZ_ID_X86, "BCJ" },
+ { XZ_ID_PPC, "PPC" },
+ { XZ_ID_IA64, "IA64" },
+ { XZ_ID_ARM, "ARM" },
+ { XZ_ID_ARMT, "ARMT" },
+ { XZ_ID_SPARC, "SPARC" }
+ // { XZ_ID_LZMA2, "LZMA2" }
+};
+
+static int FilterIdFromName(const wchar_t *name)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_NamePairs); i++)
+ {
+ const CMethodNamePair &pair = g_NamePairs[i];
+ if (StringsAreEqualNoCase_Ascii(name, pair.Name))
+ return (int)pair.Id;
+ }
+ return -1;
+}
+
+
+HRESULT CEncoder::SetCheckSize(UInt32 checkSizeInBytes)
+{
+ unsigned id;
+ switch (checkSizeInBytes)
+ {
+ case 0: id = XZ_CHECK_NO; break;
+ case 4: id = XZ_CHECK_CRC32; break;
+ case 8: id = XZ_CHECK_CRC64; break;
+ case 32: id = XZ_CHECK_SHA256; break;
+ default: return E_INVALIDARG;
+ }
+ xzProps.checkId = id;
+ return S_OK;
+}
+
+
+HRESULT CEncoder::SetCoderProp(PROPID propID, const PROPVARIANT &prop)
+{
+ if (propID == NCoderPropID::kNumThreads)
+ {
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ xzProps.numTotalThreads = (int)(prop.ulVal);
+ return S_OK;
+ }
+
+ if (propID == NCoderPropID::kCheckSize)
+ {
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ return SetCheckSize(prop.ulVal);
+ }
+
+ if (propID == NCoderPropID::kBlockSize2)
+ {
+ if (prop.vt == VT_UI4)
+ xzProps.blockSize = prop.ulVal;
+ else if (prop.vt == VT_UI8)
+ xzProps.blockSize = prop.uhVal.QuadPart;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+ }
+
+ if (propID == NCoderPropID::kReduceSize)
+ {
+ if (prop.vt == VT_UI8)
+ xzProps.reduceSize = prop.uhVal.QuadPart;
+ else
+ return E_INVALIDARG;
+ return S_OK;
+ }
+
+ if (propID == NCoderPropID::kFilter)
+ {
+ if (prop.vt == VT_UI4)
+ {
+ const UInt32 id32 = prop.ulVal;
+ if (id32 == XZ_ID_Delta)
+ return E_INVALIDARG;
+ xzProps.filterProps.id = prop.ulVal;
+ }
+ else
+ {
+ if (prop.vt != VT_BSTR)
+ return E_INVALIDARG;
+
+ const wchar_t *name = prop.bstrVal;
+ const wchar_t *end;
+
+ UInt32 id32 = ConvertStringToUInt32(name, &end);
+
+ if (end != name)
+ name = end;
+ else
+ {
+ if (IsString1PrefixedByString2_NoCase_Ascii(name, "Delta"))
+ {
+ name += 5; // strlen("Delta");
+ id32 = XZ_ID_Delta;
+ }
+ else
+ {
+ const int filterId = FilterIdFromName(prop.bstrVal);
+ if (filterId < 0 /* || filterId == XZ_ID_LZMA2 */)
+ return E_INVALIDARG;
+ id32 = (unsigned)filterId;
+ }
+ }
+
+ if (id32 == XZ_ID_Delta)
+ {
+ const wchar_t c = *name;
+ if (c != '-' && c != ':')
+ return E_INVALIDARG;
+ name++;
+ const UInt32 delta = ConvertStringToUInt32(name, &end);
+ if (end == name || *end != 0 || delta == 0 || delta > 256)
+ return E_INVALIDARG;
+ xzProps.filterProps.delta = delta;
+ }
+
+ xzProps.filterProps.id = id32;
+ }
+
+ return S_OK;
+ }
+
+ return NLzma2::SetLzma2Prop(propID, prop, xzProps.lzma2Props);
+}
+
+
+Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs,
+ const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ XzProps_Init(&xzProps);
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ RINOK(SetCoderProp(propIDs[i], coderProps[i]))
+ }
+
+ return S_OK;
+ // return SResToHRESULT(XzEnc_SetProps(_encoder, &xzProps));
+}
+
+
+Z7_COM7F_IMF(CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
+ const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ const PROPID propID = propIDs[i];
+ if (propID == NCoderPropID::kExpectedDataSize)
+ if (prop.vt == VT_UI8)
+ XzEnc_SetDataSize(_encoder, prop.uhVal.QuadPart);
+ }
+ return S_OK;
+}
+
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+ if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+{
+ CSeqInStreamWrap inWrap;
+ CSeqOutStreamWrap outWrap;
+ CCompressProgressWrap progressWrap;
+
+ inWrap.Init(inStream);
+ outWrap.Init(outStream);
+ progressWrap.Init(progress);
+
+ SRes res = XzEnc_SetProps(_encoder, &xzProps);
+ if (res == SZ_OK)
+ res = XzEnc_Encode(_encoder, &outWrap.vt, &inWrap.vt, progress ? &progressWrap.vt : NULL);
+
+ // SRes res = Xz_Encode(&outWrap.vt, &inWrap.vt, &xzProps, progress ? &progressWrap.vt : NULL);
+
+ RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
+ RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+ RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+
+ return SResToHRESULT(res);
+}
+
+}}
diff --git a/CPP/7zip/Compress/XzEncoder.h b/CPP/7zip/Compress/XzEncoder.h
index 79d81f7..434f582 100644
--- a/CPP/7zip/Compress/XzEncoder.h
+++ b/CPP/7zip/Compress/XzEncoder.h
@@ -1,46 +1,35 @@
-// XzEncoder.h
-
-#ifndef __XZ_ENCODER_H
-#define __XZ_ENCODER_H
-
-#include "../../../C/XzEnc.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCompress {
-namespace NXz {
-
-
-class CEncoder:
- public ICompressCoder,
- public ICompressSetCoderProperties,
- public ICompressSetCoderPropertiesOpt,
- public CMyUnknownImp
-{
- CXzEncHandle _encoder;
-public:
- CXzProps xzProps;
-
- MY_UNKNOWN_IMP3(
- ICompressCoder,
- ICompressSetCoderProperties,
- ICompressSetCoderPropertiesOpt)
-
- void InitCoderProps();
- HRESULT SetCheckSize(UInt32 checkSizeInBytes);
- HRESULT SetCoderProp(PROPID propID, const PROPVARIANT &prop);
-
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
- STDMETHOD(SetCoderPropertiesOpt)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
-
- CEncoder();
- virtual ~CEncoder();
-};
-
-}}
-
-#endif
+// XzEncoder.h
+
+#ifndef ZIP7_INC_XZ_ENCODER_H
+#define ZIP7_INC_XZ_ENCODER_H
+
+#include "../../../C/XzEnc.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NXz {
+
+Z7_CLASS_IMP_COM_3(
+ CEncoder
+ , ICompressCoder
+ , ICompressSetCoderProperties
+ , ICompressSetCoderPropertiesOpt
+)
+ CXzEncHandle _encoder;
+public:
+ CXzProps xzProps;
+
+ void InitCoderProps();
+ HRESULT SetCheckSize(UInt32 checkSizeInBytes);
+ HRESULT SetCoderProp(PROPID propID, const PROPVARIANT &prop);
+
+ CEncoder();
+ ~CEncoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/ZDecoder.cpp b/CPP/7zip/Compress/ZDecoder.cpp
new file mode 100644
index 0000000..07c5fe5
--- /dev/null
+++ b/CPP/7zip/Compress/ZDecoder.cpp
@@ -0,0 +1,237 @@
+// ZDecoder.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/InBuffer.h"
+#include "../Common/OutBuffer.h"
+
+#include "ZDecoder.h"
+
+namespace NCompress {
+namespace NZ {
+
+static const UInt32 kBufferSize = (1 << 20);
+static const Byte kNumBitsMask = 0x1F;
+static const Byte kBlockModeMask = 0x80;
+static const unsigned kNumMinBits = 9;
+static const unsigned kNumMaxBits = 16;
+
+void CDecoder::Free()
+{
+ MyFree(_parents); _parents = NULL;
+ MyFree(_suffixes); _suffixes = NULL;
+ MyFree(_stack); _stack = NULL;
+}
+
+CDecoder::~CDecoder() { Free(); }
+
+HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
+{
+ CInBuffer inBuffer;
+ COutBuffer outBuffer;
+
+ PackSize = 0;
+
+ if (!inBuffer.Create(kBufferSize))
+ return E_OUTOFMEMORY;
+ inBuffer.SetStream(inStream);
+ inBuffer.Init();
+
+ if (!outBuffer.Create(kBufferSize))
+ return E_OUTOFMEMORY;
+ outBuffer.SetStream(outStream);
+ outBuffer.Init();
+
+ Byte buf[kNumMaxBits + 4];
+ {
+ if (inBuffer.ReadBytes(buf, 3) < 3)
+ return S_FALSE;
+ if (buf[0] != 0x1F || buf[1] != 0x9D)
+ return S_FALSE;
+ }
+ Byte prop = buf[2];
+
+ if ((prop & 0x60) != 0)
+ return S_FALSE;
+ const unsigned maxbits = prop & kNumBitsMask;
+ if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
+ return S_FALSE;
+ const UInt32 numItems = 1 << maxbits;
+ // Speed optimization: blockSymbol can contain unused velue.
+
+ if (maxbits != _numMaxBits || !_parents || !_suffixes || !_stack)
+ {
+ Free();
+ _parents = (UInt16 *)MyAlloc(numItems * sizeof(UInt16)); if (!_parents) return E_OUTOFMEMORY;
+ _suffixes = (Byte *)MyAlloc(numItems * sizeof(Byte)); if (!_suffixes) return E_OUTOFMEMORY;
+ _stack = (Byte *)MyAlloc(numItems * sizeof(Byte)); if (!_stack) return E_OUTOFMEMORY;
+ _numMaxBits = maxbits;
+ }
+
+ UInt64 prevPos = 0;
+ const UInt32 blockSymbol = ((prop & kBlockModeMask) != 0) ? 256 : ((UInt32)1 << kNumMaxBits);
+ unsigned numBits = kNumMinBits;
+ UInt32 head = (blockSymbol == 256) ? 257 : 256;
+ bool needPrev = false;
+ unsigned bitPos = 0;
+ unsigned numBufBits = 0;
+
+ _parents[256] = 0; // virus protection
+ _suffixes[256] = 0;
+ HRESULT res = S_OK;
+
+ for (;;)
+ {
+ if (numBufBits == bitPos)
+ {
+ numBufBits = (unsigned)inBuffer.ReadBytes(buf, numBits) * 8;
+ bitPos = 0;
+ const UInt64 nowPos = outBuffer.GetProcessedSize();
+ if (progress && nowPos - prevPos >= (1 << 13))
+ {
+ prevPos = nowPos;
+ const UInt64 packSize = inBuffer.GetProcessedSize();
+ RINOK(progress->SetRatioInfo(&packSize, &nowPos))
+ }
+ }
+ const unsigned bytePos = bitPos >> 3;
+ UInt32 symbol = buf[bytePos] | ((UInt32)buf[(size_t)bytePos + 1] << 8) | ((UInt32)buf[(size_t)bytePos + 2] << 16);
+ symbol >>= (bitPos & 7);
+ symbol &= (1 << numBits) - 1;
+ bitPos += numBits;
+ if (bitPos > numBufBits)
+ break;
+ if (symbol >= head)
+ {
+ res = S_FALSE;
+ break;
+ }
+ if (symbol == blockSymbol)
+ {
+ numBufBits = bitPos = 0;
+ numBits = kNumMinBits;
+ head = 257;
+ needPrev = false;
+ continue;
+ }
+ UInt32 cur = symbol;
+ unsigned i = 0;
+ while (cur >= 256)
+ {
+ _stack[i++] = _suffixes[cur];
+ cur = _parents[cur];
+ }
+ _stack[i++] = (Byte)cur;
+ if (needPrev)
+ {
+ _suffixes[(size_t)head - 1] = (Byte)cur;
+ if (symbol == head - 1)
+ _stack[0] = (Byte)cur;
+ }
+ do
+ outBuffer.WriteByte((_stack[--i]));
+ while (i > 0);
+ if (head < numItems)
+ {
+ needPrev = true;
+ _parents[head++] = (UInt16)symbol;
+ if (head > ((UInt32)1 << numBits))
+ {
+ if (numBits < maxbits)
+ {
+ numBufBits = bitPos = 0;
+ numBits++;
+ }
+ }
+ }
+ else
+ needPrev = false;
+ }
+ PackSize = inBuffer.GetProcessedSize();
+ const HRESULT res2 = outBuffer.Flush();
+ return (res == S_OK) ? res2 : res;
+}
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
+ catch(const CInBufferException &e) { return e.ErrorCode; }
+ catch(const COutBufferException &e) { return e.ErrorCode; }
+ catch(...) { return S_FALSE; }
+}
+
+bool CheckStream(const Byte *data, size_t size)
+{
+ if (size < 3)
+ return false;
+ if (data[0] != 0x1F || data[1] != 0x9D)
+ return false;
+ const Byte prop = data[2];
+ if ((prop & 0x60) != 0)
+ return false;
+ const unsigned maxbits = prop & kNumBitsMask;
+ if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
+ return false;
+ const UInt32 numItems = 1 << maxbits;
+ const UInt32 blockSymbol = ((prop & kBlockModeMask) != 0) ? 256 : ((UInt32)1 << kNumMaxBits);
+ unsigned numBits = kNumMinBits;
+ UInt32 head = (blockSymbol == 256) ? 257 : 256;
+ unsigned bitPos = 0;
+ unsigned numBufBits = 0;
+ Byte buf[kNumMaxBits + 4];
+ data += 3;
+ size -= 3;
+ // printf("\n\n");
+ for (;;)
+ {
+ if (numBufBits == bitPos)
+ {
+ const unsigned num = (numBits < size) ? numBits : (unsigned)size;
+ memcpy(buf, data, num);
+ data += num;
+ size -= num;
+ numBufBits = num * 8;
+ bitPos = 0;
+ }
+ const unsigned bytePos = bitPos >> 3;
+ UInt32 symbol = buf[bytePos] | ((UInt32)buf[bytePos + 1] << 8) | ((UInt32)buf[bytePos + 2] << 16);
+ symbol >>= (bitPos & 7);
+ symbol &= (1 << numBits) - 1;
+ bitPos += numBits;
+ if (bitPos > numBufBits)
+ {
+ // printf(" OK", symbol);
+ return true;
+ }
+ // printf("%3X ", symbol);
+ if (symbol >= head)
+ return false;
+ if (symbol == blockSymbol)
+ {
+ numBufBits = bitPos = 0;
+ numBits = kNumMinBits;
+ head = 257;
+ continue;
+ }
+ if (head < numItems)
+ {
+ head++;
+ if (head > ((UInt32)1 << numBits))
+ {
+ if (numBits < maxbits)
+ {
+ numBufBits = bitPos = 0;
+ numBits++;
+ }
+ }
+ }
+ }
+}
+
+}}
diff --git a/CPP/7zip/Compress/ZDecoder.h b/CPP/7zip/Compress/ZDecoder.h
new file mode 100644
index 0000000..390b013
--- /dev/null
+++ b/CPP/7zip/Compress/ZDecoder.h
@@ -0,0 +1,49 @@
+// ZDecoder.h
+
+#ifndef ZIP7_INC_COMPRESS_Z_DECODER_H
+#define ZIP7_INC_COMPRESS_Z_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NZ {
+
+// Z decoder decodes Z data stream, including 3 bytes of header.
+
+Z7_CLASS_IMP_COM_1(
+ CDecoder
+ , ICompressCoder
+)
+ UInt16 *_parents;
+ Byte *_suffixes;
+ Byte *_stack;
+ unsigned _numMaxBits;
+
+public:
+ CDecoder(): _parents(NULL), _suffixes(NULL), _stack(NULL), /* _prop(0), */ _numMaxBits(0) {}
+ ~CDecoder();
+ void Free();
+ UInt64 PackSize;
+
+ HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+};
+
+/*
+ There is no end_of_payload_marker in Z stream.
+ Z decoder stops decoding, if it reaches end of input stream.
+
+ CheckStream function:
+ (size) must be at least 3 bytes (size of Z header).
+ if (size) is larger than size of real Z stream in (data), CheckStream can return false.
+*/
+
+const unsigned kRecommendedCheckSize = 64;
+
+bool CheckStream(const Byte *data, size_t size);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/ZlibDecoder.cpp b/CPP/7zip/Compress/ZlibDecoder.cpp
new file mode 100644
index 0000000..a066932
--- /dev/null
+++ b/CPP/7zip/Compress/ZlibDecoder.cpp
@@ -0,0 +1,95 @@
+// ZlibDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "ZlibDecoder.h"
+
+namespace NCompress {
+namespace NZlib {
+
+#define DEFLATE_TRY_BEGIN try {
+#define DEFLATE_TRY_END } catch(...) { return S_FALSE; }
+
+#define ADLER_MOD 65521
+#define ADLER_LOOP_MAX 5550
+
+UInt32 Adler32_Update(UInt32 adler, const Byte *buf, size_t size);
+UInt32 Adler32_Update(UInt32 adler, const Byte *buf, size_t size)
+{
+ UInt32 a = adler & 0xFFFF;
+ UInt32 b = (adler >> 16) & 0xFFFF;
+ while (size > 0)
+ {
+ const unsigned curSize = (size > ADLER_LOOP_MAX) ? ADLER_LOOP_MAX : (unsigned )size;
+ unsigned i;
+ for (i = 0; i < curSize; i++)
+ {
+ a += buf[i];
+ b += a;
+ }
+ buf += curSize;
+ size -= curSize;
+ a %= ADLER_MOD;
+ b %= ADLER_MOD;
+ }
+ return (b << 16) + a;
+}
+
+Z7_COM7F_IMF(COutStreamWithAdler::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ _adler = Adler32_Update(_adler, (const Byte *)data, size);
+ _size += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+ DEFLATE_TRY_BEGIN
+ if (!AdlerStream)
+ AdlerStream = AdlerSpec = new COutStreamWithAdler;
+ if (!DeflateDecoder)
+ {
+ DeflateDecoderSpec = new NDeflate::NDecoder::CCOMCoder;
+ DeflateDecoderSpec->ZlibMode = true;
+ DeflateDecoder = DeflateDecoderSpec;
+ }
+
+ if (inSize && *inSize < 2)
+ return S_FALSE;
+ Byte buf[2];
+ RINOK(ReadStream_FALSE(inStream, buf, 2))
+ if (!IsZlib(buf))
+ return S_FALSE;
+
+ AdlerSpec->SetStream(outStream);
+ AdlerSpec->Init();
+
+ UInt64 inSize2 = 0;
+ if (inSize)
+ inSize2 = *inSize - 2;
+
+ const HRESULT res = DeflateDecoder->Code(inStream, AdlerStream, inSize ? &inSize2 : NULL, outSize, progress);
+ AdlerSpec->ReleaseStream();
+
+ if (res == S_OK)
+ {
+ const Byte *p = DeflateDecoderSpec->ZlibFooter;
+ const UInt32 adler = GetBe32(p);
+ if (adler != AdlerSpec->GetAdler())
+ return S_FALSE;
+ }
+ return res;
+ DEFLATE_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Compress/ZlibDecoder.h b/CPP/7zip/Compress/ZlibDecoder.h
new file mode 100644
index 0000000..1dc5c67
--- /dev/null
+++ b/CPP/7zip/Compress/ZlibDecoder.h
@@ -0,0 +1,71 @@
+// ZlibDecoder.h
+
+#ifndef ZIP7_INC_ZLIB_DECODER_H
+#define ZIP7_INC_ZLIB_DECODER_H
+
+#include "DeflateDecoder.h"
+
+namespace NCompress {
+namespace NZlib {
+
+const UInt32 ADLER_INIT_VAL = 1;
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithAdler
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt32 _adler;
+ UInt64 _size;
+public:
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init() { _adler = ADLER_INIT_VAL; _size = 0; }
+ UInt32 GetAdler() const { return _adler; }
+ UInt64 GetSize() const { return _size; }
+};
+
+Z7_CLASS_IMP_NOQIB_1(
+ CDecoder
+ , ICompressCoder
+)
+ COutStreamWithAdler *AdlerSpec;
+ CMyComPtr<ISequentialOutStream> AdlerStream;
+ NCompress::NDeflate::NDecoder::CCOMCoder *DeflateDecoderSpec;
+ CMyComPtr<ICompressCoder> DeflateDecoder;
+public:
+ UInt64 GetInputProcessedSize() const { return DeflateDecoderSpec->GetInputProcessedSize() + 2; }
+ UInt64 GetOutputProcessedSize() const { return AdlerSpec->GetSize(); }
+};
+
+static bool inline IsZlib(const Byte *p)
+{
+ if ((p[0] & 0xF) != 8) // method
+ return false;
+ if (((unsigned)p[0] >> 4) > 7) // logar_window_size minus 8.
+ return false;
+ if ((p[1] & 0x20) != 0) // dictPresent
+ return false;
+ if ((((UInt32)p[0] << 8) + p[1]) % 31 != 0)
+ return false;
+ return true;
+}
+
+// IsZlib_3bytes checks 2 bytes of zlib header and starting byte of Deflate stream
+
+static bool inline IsZlib_3bytes(const Byte *p)
+{
+ if (!IsZlib(p))
+ return false;
+ const unsigned val = p[2];
+ const unsigned blockType = (val >> 1) & 0x3;
+ if (blockType == 3) // unsupported block type for deflate
+ return false;
+ if (blockType == NCompress::NDeflate::NBlockType::kStored && (val >> 3) != 0)
+ return false;
+ return true;
+}
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/ZlibEncoder.cpp b/CPP/7zip/Compress/ZlibEncoder.cpp
new file mode 100644
index 0000000..3670d30
--- /dev/null
+++ b/CPP/7zip/Compress/ZlibEncoder.cpp
@@ -0,0 +1,61 @@
+// ZlibEncoder.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "ZlibEncoder.h"
+
+namespace NCompress {
+namespace NZlib {
+
+#define DEFLATE_TRY_BEGIN try {
+#define DEFLATE_TRY_END } catch(...) { return S_FALSE; }
+
+UInt32 Adler32_Update(UInt32 adler, const Byte *buf, size_t size);
+
+Z7_COM7F_IMF(CInStreamWithAdler::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ const HRESULT result = _stream->Read(data, size, &size);
+ _adler = Adler32_Update(_adler, (const Byte *)data, size);
+ _size += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+void CEncoder::Create()
+{
+ if (!DeflateEncoder)
+ DeflateEncoder = DeflateEncoderSpec = new NDeflate::NEncoder::CCOMCoder;
+}
+
+Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+ const UInt64 *inSize, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+{
+ DEFLATE_TRY_BEGIN
+ if (!AdlerStream)
+ AdlerStream = AdlerSpec = new CInStreamWithAdler;
+ Create();
+
+ {
+ Byte buf[2] = { 0x78, 0xDA };
+ RINOK(WriteStream(outStream, buf, 2))
+ }
+
+ AdlerSpec->SetStream(inStream);
+ AdlerSpec->Init();
+ const HRESULT res = DeflateEncoder->Code(AdlerStream, outStream, inSize, NULL, progress);
+ AdlerSpec->ReleaseStream();
+
+ RINOK(res)
+
+ {
+ const UInt32 a = AdlerSpec->GetAdler();
+ const Byte buf[4] = { (Byte)(a >> 24), (Byte)(a >> 16), (Byte)(a >> 8), (Byte)(a) };
+ return WriteStream(outStream, buf, 4);
+ }
+ DEFLATE_TRY_END
+}
+
+}}
diff --git a/CPP/7zip/Compress/ZlibEncoder.h b/CPP/7zip/Compress/ZlibEncoder.h
new file mode 100644
index 0000000..484a307
--- /dev/null
+++ b/CPP/7zip/Compress/ZlibEncoder.h
@@ -0,0 +1,42 @@
+// ZlibEncoder.h
+
+#ifndef ZIP7_INC_ZLIB_ENCODER_H
+#define ZIP7_INC_ZLIB_ENCODER_H
+
+#include "DeflateEncoder.h"
+
+namespace NCompress {
+namespace NZlib {
+
+Z7_CLASS_IMP_NOQIB_1(
+ CInStreamWithAdler
+ , ISequentialInStream
+)
+ CMyComPtr<ISequentialInStream> _stream;
+ UInt32 _adler;
+ UInt64 _size;
+public:
+ void SetStream(ISequentialInStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init() { _adler = 1; _size = 0; } // ADLER_INIT_VAL
+ UInt32 GetAdler() const { return _adler; }
+ UInt64 GetSize() const { return _size; }
+};
+
+Z7_CLASS_IMP_NOQIB_1(
+ CEncoder
+ , ICompressCoder
+)
+ CInStreamWithAdler *AdlerSpec;
+ CMyComPtr<ISequentialInStream> AdlerStream;
+ CMyComPtr<ICompressCoder> DeflateEncoder;
+public:
+ NCompress::NDeflate::NEncoder::CCOMCoder *DeflateEncoderSpec;
+
+ void Create();
+ UInt64 GetInputProcessedSize() const { return AdlerSpec->GetSize(); }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Compress/makefile b/CPP/7zip/Compress/makefile
new file mode 100644
index 0000000..e981319
--- /dev/null
+++ b/CPP/7zip/Compress/makefile
@@ -0,0 +1,7 @@
+DIRS = \
+ LZMA_Alone\~ \
+
+all: $(DIRS)
+
+$(DIRS):
+!include "../SubBuild.mak"
diff --git a/CPP/7zip/Crc.mak b/CPP/7zip/Crc.mak
index 66b35c1..815142d 100644
--- a/CPP/7zip/Crc.mak
+++ b/CPP/7zip/Crc.mak
@@ -1,8 +1,8 @@
-C_OBJS = $(C_OBJS) \
- $O\7zCrc.obj
-!IF "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
-C_OBJS = $(C_OBJS) \
-!ELSE
-ASM_OBJS = $(ASM_OBJS) \
-!ENDIF
- $O\7zCrcOpt.obj
+C_OBJS = $(C_OBJS) \
+ $O\7zCrc.obj
+!IF "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+!ENDIF
+ $O\7zCrcOpt.obj
diff --git a/CPP/7zip/Crc64.mak b/CPP/7zip/Crc64.mak
index 6df9b40..d58a483 100644
--- a/CPP/7zip/Crc64.mak
+++ b/CPP/7zip/Crc64.mak
@@ -1,8 +1,8 @@
-C_OBJS = $(C_OBJS) \
- $O\XzCrc64.obj
-!IF "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
-C_OBJS = $(C_OBJS) \
-!ELSE
-ASM_OBJS = $(ASM_OBJS) \
-!ENDIF
- $O\XzCrc64Opt.obj
+C_OBJS = $(C_OBJS) \
+ $O\XzCrc64.obj
+!IF "$(PLATFORM)" == "ia64" || "$(PLATFORM)" == "mips" || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+!ENDIF
+ $O\XzCrc64Opt.obj
diff --git a/CPP/7zip/Crypto/7zAes.cpp b/CPP/7zip/Crypto/7zAes.cpp
index 55e40f3..6b1c648 100644
--- a/CPP/7zip/Crypto/7zAes.cpp
+++ b/CPP/7zip/Crypto/7zAes.cpp
@@ -1,280 +1,317 @@
-// 7zAes.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/Sha256.h"
-
-#include "../../Common/ComTry.h"
-
-#ifndef _7ZIP_ST
-#include "../../Windows/Synchronization.h"
-#endif
-
-#include "../Common/StreamUtils.h"
-
-#include "7zAes.h"
-#include "MyAes.h"
-
-#ifndef EXTRACT_ONLY
-#include "RandGen.h"
-#endif
-
-namespace NCrypto {
-namespace N7z {
-
-static const unsigned k_NumCyclesPower_Supported_MAX = 24;
-
-bool CKeyInfo::IsEqualTo(const CKeyInfo &a) const
-{
- if (SaltSize != a.SaltSize || NumCyclesPower != a.NumCyclesPower)
- return false;
- for (unsigned i = 0; i < SaltSize; i++)
- if (Salt[i] != a.Salt[i])
- return false;
- return (Password == a.Password);
-}
-
-void CKeyInfo::CalcKey()
-{
- if (NumCyclesPower == 0x3F)
- {
- unsigned pos;
- for (pos = 0; pos < SaltSize; pos++)
- Key[pos] = Salt[pos];
- for (unsigned i = 0; i < Password.Size() && pos < kKeySize; i++)
- Key[pos++] = Password[i];
- for (; pos < kKeySize; pos++)
- Key[pos] = 0;
- }
- else
- {
- size_t bufSize = 8 + SaltSize + Password.Size();
- CObjArray<Byte> buf(bufSize);
- memcpy(buf, Salt, SaltSize);
- memcpy(buf + SaltSize, Password, Password.Size());
-
- CSha256 sha;
- Sha256_Init(&sha);
-
- Byte *ctr = buf + SaltSize + Password.Size();
-
- for (unsigned i = 0; i < 8; i++)
- ctr[i] = 0;
-
- UInt64 numRounds = (UInt64)1 << NumCyclesPower;
-
- do
- {
- Sha256_Update(&sha, buf, bufSize);
- for (unsigned i = 0; i < 8; i++)
- if (++(ctr[i]) != 0)
- break;
- }
- while (--numRounds != 0);
-
- Sha256_Final(&sha, Key);
- }
-}
-
-bool CKeyInfoCache::GetKey(CKeyInfo &key)
-{
- FOR_VECTOR (i, Keys)
- {
- const CKeyInfo &cached = Keys[i];
- if (key.IsEqualTo(cached))
- {
- for (unsigned j = 0; j < kKeySize; j++)
- key.Key[j] = cached.Key[j];
- if (i != 0)
- Keys.MoveToFront(i);
- return true;
- }
- }
- return false;
-}
-
-void CKeyInfoCache::FindAndAdd(const CKeyInfo &key)
-{
- FOR_VECTOR (i, Keys)
- {
- const CKeyInfo &cached = Keys[i];
- if (key.IsEqualTo(cached))
- {
- if (i != 0)
- Keys.MoveToFront(i);
- return;
- }
- }
- Add(key);
-}
-
-void CKeyInfoCache::Add(const CKeyInfo &key)
-{
- if (Keys.Size() >= Size)
- Keys.DeleteBack();
- Keys.Insert(0, key);
-}
-
-static CKeyInfoCache g_GlobalKeyCache(32);
-
-#ifndef _7ZIP_ST
- static NWindows::NSynchronization::CCriticalSection g_GlobalKeyCacheCriticalSection;
- #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_GlobalKeyCacheCriticalSection);
-#else
- #define MT_LOCK
-#endif
-
-CBase::CBase():
- _cachedKeys(16),
- _ivSize(0)
-{
- for (unsigned i = 0; i < sizeof(_iv); i++)
- _iv[i] = 0;
-}
-
-void CBase::PrepareKey()
-{
- // BCJ2 threads use same password. So we use long lock.
- MT_LOCK
-
- bool finded = false;
- if (!_cachedKeys.GetKey(_key))
- {
- finded = g_GlobalKeyCache.GetKey(_key);
- if (!finded)
- _key.CalcKey();
- _cachedKeys.Add(_key);
- }
- if (!finded)
- g_GlobalKeyCache.FindAndAdd(_key);
-}
-
-#ifndef EXTRACT_ONLY
-
-/*
-STDMETHODIMP CEncoder::ResetSalt()
-{
- _key.SaltSize = 4;
- g_RandomGenerator.Generate(_key.Salt, _key.SaltSize);
- return S_OK;
-}
-*/
-
-STDMETHODIMP CEncoder::ResetInitVector()
-{
- for (unsigned i = 0; i < sizeof(_iv); i++)
- _iv[i] = 0;
- _ivSize = 16;
- MY_RAND_GEN(_iv, _ivSize);
- return S_OK;
-}
-
-STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
-{
- Byte props[2 + sizeof(_key.Salt) + sizeof(_iv)];
- unsigned propsSize = 1;
-
- props[0] = (Byte)(_key.NumCyclesPower
- | (_key.SaltSize == 0 ? 0 : (1 << 7))
- | (_ivSize == 0 ? 0 : (1 << 6)));
-
- if (_key.SaltSize != 0 || _ivSize != 0)
- {
- props[1] = (Byte)(
- ((_key.SaltSize == 0 ? 0 : _key.SaltSize - 1) << 4)
- | (_ivSize == 0 ? 0 : _ivSize - 1));
- memcpy(props + 2, _key.Salt, _key.SaltSize);
- propsSize = 2 + _key.SaltSize;
- memcpy(props + propsSize, _iv, _ivSize);
- propsSize += _ivSize;
- }
-
- return WriteStream(outStream, props, propsSize);
-}
-
-CEncoder::CEncoder()
-{
- // _key.SaltSize = 4; g_RandomGenerator.Generate(_key.Salt, _key.SaltSize);
- // _key.NumCyclesPower = 0x3F;
- _key.NumCyclesPower = 19;
- _aesFilter = new CAesCbcEncoder(kKeySize);
-}
-
-#endif
-
-CDecoder::CDecoder()
-{
- _aesFilter = new CAesCbcDecoder(kKeySize);
-}
-
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
-{
- _key.ClearProps();
-
- _ivSize = 0;
- unsigned i;
- for (i = 0; i < sizeof(_iv); i++)
- _iv[i] = 0;
-
- if (size == 0)
- return S_OK;
-
- Byte b0 = data[0];
-
- _key.NumCyclesPower = b0 & 0x3F;
- if ((b0 & 0xC0) == 0)
- return size == 1 ? S_OK : E_INVALIDARG;
-
- if (size <= 1)
- return E_INVALIDARG;
-
- Byte b1 = data[1];
-
- unsigned saltSize = ((b0 >> 7) & 1) + (b1 >> 4);
- unsigned ivSize = ((b0 >> 6) & 1) + (b1 & 0x0F);
-
- if (size != 2 + saltSize + ivSize)
- return E_INVALIDARG;
- _key.SaltSize = saltSize;
- data += 2;
- for (i = 0; i < saltSize; i++)
- _key.Salt[i] = *data++;
- for (i = 0; i < ivSize; i++)
- _iv[i] = *data++;
- return (_key.NumCyclesPower <= k_NumCyclesPower_Supported_MAX
- || _key.NumCyclesPower == 0x3F) ? S_OK : E_NOTIMPL;
-}
-
-
-STDMETHODIMP CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size)
-{
- COM_TRY_BEGIN
-
- _key.Password.CopyFrom(data, (size_t)size);
- return S_OK;
-
- COM_TRY_END
-}
-
-STDMETHODIMP CBaseCoder::Init()
-{
- COM_TRY_BEGIN
-
- PrepareKey();
- CMyComPtr<ICryptoProperties> cp;
- RINOK(_aesFilter.QueryInterface(IID_ICryptoProperties, &cp));
- if (!cp)
- return E_FAIL;
- RINOK(cp->SetKey(_key.Key, kKeySize));
- RINOK(cp->SetInitVector(_iv, sizeof(_iv)));
- return _aesFilter->Init();
-
- COM_TRY_END
-}
-
-STDMETHODIMP_(UInt32) CBaseCoder::Filter(Byte *data, UInt32 size)
-{
- return _aesFilter->Filter(data, size);
-}
-
-}}
+// 7zAes.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/Sha256.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer2.h"
+
+#ifndef Z7_ST
+#include "../../Windows/Synchronization.h"
+#endif
+
+#include "../Common/StreamUtils.h"
+
+#include "7zAes.h"
+#include "MyAes.h"
+
+#ifndef Z7_EXTRACT_ONLY
+#include "RandGen.h"
+#endif
+
+namespace NCrypto {
+namespace N7z {
+
+static const unsigned k_NumCyclesPower_Supported_MAX = 24;
+
+bool CKeyInfo::IsEqualTo(const CKeyInfo &a) const
+{
+ if (SaltSize != a.SaltSize || NumCyclesPower != a.NumCyclesPower)
+ return false;
+ for (unsigned i = 0; i < SaltSize; i++)
+ if (Salt[i] != a.Salt[i])
+ return false;
+ return (Password == a.Password);
+}
+
+void CKeyInfo::CalcKey()
+{
+ if (NumCyclesPower == 0x3F)
+ {
+ unsigned pos;
+ for (pos = 0; pos < SaltSize; pos++)
+ Key[pos] = Salt[pos];
+ for (unsigned i = 0; i < Password.Size() && pos < kKeySize; i++)
+ Key[pos++] = Password[i];
+ for (; pos < kKeySize; pos++)
+ Key[pos] = 0;
+ }
+ else
+ {
+ const unsigned kUnrPow = 6;
+ const UInt32 numUnroll = (UInt32)1 << (NumCyclesPower <= kUnrPow ? (unsigned)NumCyclesPower : kUnrPow);
+
+ const size_t bufSize = 8 + SaltSize + Password.Size();
+ const size_t unrollSize = bufSize * numUnroll;
+
+ // MY_ALIGN (16)
+ // CSha256 sha;
+ CAlignedBuffer sha(sizeof(CSha256) + unrollSize + bufSize * 2);
+ Byte *buf = sha + sizeof(CSha256);
+
+ memcpy(buf, Salt, SaltSize);
+ memcpy(buf + SaltSize, Password, Password.Size());
+ memset(buf + bufSize - 8, 0, 8);
+
+ Sha256_Init((CSha256 *)(void *)(Byte *)sha);
+
+ {
+ {
+ Byte *dest = buf;
+ for (UInt32 i = 1; i < numUnroll; i++)
+ {
+ dest += bufSize;
+ memcpy(dest, buf, bufSize);
+ }
+ }
+
+ const UInt32 numRounds = (UInt32)1 << NumCyclesPower;
+ UInt32 r = 0;
+ do
+ {
+ Byte *dest = buf + bufSize - 8;
+ UInt32 i = r;
+ r += numUnroll;
+ do
+ {
+ SetUi32(dest, i) i++; dest += bufSize;
+ // SetUi32(dest, i) i++; dest += bufSize;
+ }
+ while (i < r);
+ Sha256_Update((CSha256 *)(void *)(Byte *)sha, buf, unrollSize);
+ }
+ while (r < numRounds);
+ }
+ /*
+ UInt64 numRounds = (UInt64)1 << NumCyclesPower;
+
+ do
+ {
+ Sha256_Update((CSha256 *)(Byte *)sha, buf, bufSize);
+ for (unsigned i = 0; i < 8; i++)
+ if (++(ctr[i]) != 0)
+ break;
+ }
+ while (--numRounds != 0);
+ */
+
+ Sha256_Final((CSha256 *)(void *)(Byte *)sha, Key);
+ memset(sha, 0, sha.Size());
+ }
+}
+
+bool CKeyInfoCache::GetKey(CKeyInfo &key)
+{
+ FOR_VECTOR (i, Keys)
+ {
+ const CKeyInfo &cached = Keys[i];
+ if (key.IsEqualTo(cached))
+ {
+ for (unsigned j = 0; j < kKeySize; j++)
+ key.Key[j] = cached.Key[j];
+ if (i != 0)
+ Keys.MoveToFront(i);
+ return true;
+ }
+ }
+ return false;
+}
+
+void CKeyInfoCache::FindAndAdd(const CKeyInfo &key)
+{
+ FOR_VECTOR (i, Keys)
+ {
+ const CKeyInfo &cached = Keys[i];
+ if (key.IsEqualTo(cached))
+ {
+ if (i != 0)
+ Keys.MoveToFront(i);
+ return;
+ }
+ }
+ Add(key);
+}
+
+void CKeyInfoCache::Add(const CKeyInfo &key)
+{
+ if (Keys.Size() >= Size)
+ Keys.DeleteBack();
+ Keys.Insert(0, key);
+}
+
+static CKeyInfoCache g_GlobalKeyCache(32);
+
+#ifndef Z7_ST
+ static NWindows::NSynchronization::CCriticalSection g_GlobalKeyCacheCriticalSection;
+ #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_GlobalKeyCacheCriticalSection);
+#else
+ #define MT_LOCK
+#endif
+
+CBase::CBase():
+ _cachedKeys(16),
+ _ivSize(0)
+{
+ for (unsigned i = 0; i < sizeof(_iv); i++)
+ _iv[i] = 0;
+}
+
+void CBase::PrepareKey()
+{
+ // BCJ2 threads use same password. So we use long lock.
+ MT_LOCK
+
+ bool finded = false;
+ if (!_cachedKeys.GetKey(_key))
+ {
+ finded = g_GlobalKeyCache.GetKey(_key);
+ if (!finded)
+ _key.CalcKey();
+ _cachedKeys.Add(_key);
+ }
+ if (!finded)
+ g_GlobalKeyCache.FindAndAdd(_key);
+}
+
+#ifndef Z7_EXTRACT_ONLY
+
+/*
+Z7_COM7F_IMF(CEncoder::ResetSalt())
+{
+ _key.SaltSize = 4;
+ g_RandomGenerator.Generate(_key.Salt, _key.SaltSize);
+ return S_OK;
+}
+*/
+
+Z7_COM7F_IMF(CEncoder::ResetInitVector())
+{
+ for (unsigned i = 0; i < sizeof(_iv); i++)
+ _iv[i] = 0;
+ _ivSize = 16;
+ MY_RAND_GEN(_iv, _ivSize);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+{
+ Byte props[2 + sizeof(_key.Salt) + sizeof(_iv)];
+ unsigned propsSize = 1;
+
+ props[0] = (Byte)(_key.NumCyclesPower
+ | (_key.SaltSize == 0 ? 0 : (1 << 7))
+ | (_ivSize == 0 ? 0 : (1 << 6)));
+
+ if (_key.SaltSize != 0 || _ivSize != 0)
+ {
+ props[1] = (Byte)(
+ ((_key.SaltSize == 0 ? 0 : _key.SaltSize - 1) << 4)
+ | (_ivSize == 0 ? 0 : _ivSize - 1));
+ memcpy(props + 2, _key.Salt, _key.SaltSize);
+ propsSize = 2 + _key.SaltSize;
+ memcpy(props + propsSize, _iv, _ivSize);
+ propsSize += _ivSize;
+ }
+
+ return WriteStream(outStream, props, propsSize);
+}
+
+CEncoder::CEncoder()
+{
+ // _key.SaltSize = 4; g_RandomGenerator.Generate(_key.Salt, _key.SaltSize);
+ // _key.NumCyclesPower = 0x3F;
+ _key.NumCyclesPower = 19;
+ _aesFilter = new CAesCbcEncoder(kKeySize);
+}
+
+#endif
+
+CDecoder::CDecoder()
+{
+ _aesFilter = new CAesCbcDecoder(kKeySize);
+}
+
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ _key.ClearProps();
+
+ _ivSize = 0;
+ unsigned i;
+ for (i = 0; i < sizeof(_iv); i++)
+ _iv[i] = 0;
+
+ if (size == 0)
+ return S_OK;
+
+ Byte b0 = data[0];
+
+ _key.NumCyclesPower = b0 & 0x3F;
+ if ((b0 & 0xC0) == 0)
+ return size == 1 ? S_OK : E_INVALIDARG;
+
+ if (size <= 1)
+ return E_INVALIDARG;
+
+ Byte b1 = data[1];
+
+ unsigned saltSize = ((b0 >> 7) & 1) + (b1 >> 4);
+ unsigned ivSize = ((b0 >> 6) & 1) + (b1 & 0x0F);
+
+ if (size != 2 + saltSize + ivSize)
+ return E_INVALIDARG;
+ _key.SaltSize = saltSize;
+ data += 2;
+ for (i = 0; i < saltSize; i++)
+ _key.Salt[i] = *data++;
+ for (i = 0; i < ivSize; i++)
+ _iv[i] = *data++;
+ return (_key.NumCyclesPower <= k_NumCyclesPower_Supported_MAX
+ || _key.NumCyclesPower == 0x3F) ? S_OK : E_NOTIMPL;
+}
+
+
+Z7_COM7F_IMF(CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size))
+{
+ COM_TRY_BEGIN
+
+ _key.Password.Wipe();
+ _key.Password.CopyFrom(data, (size_t)size);
+ return S_OK;
+
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CBaseCoder::Init())
+{
+ COM_TRY_BEGIN
+
+ PrepareKey();
+ CMyComPtr<ICryptoProperties> cp;
+ RINOK(_aesFilter.QueryInterface(IID_ICryptoProperties, &cp))
+ if (!cp)
+ return E_FAIL;
+ RINOK(cp->SetKey(_key.Key, kKeySize))
+ RINOK(cp->SetInitVector(_iv, sizeof(_iv)))
+ return _aesFilter->Init();
+
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF2(UInt32, CBaseCoder::Filter(Byte *data, UInt32 size))
+{
+ return _aesFilter->Filter(data, size);
+}
+
+}}
diff --git a/CPP/7zip/Crypto/7zAes.h b/CPP/7zip/Crypto/7zAes.h
index 5a09436..8f7bf03 100644
--- a/CPP/7zip/Crypto/7zAes.h
+++ b/CPP/7zip/Crypto/7zAes.h
@@ -1,118 +1,130 @@
-// 7zAes.h
-
-#ifndef __CRYPTO_7Z_AES_H
-#define __CRYPTO_7Z_AES_H
-
-#include "../../Common/MyBuffer.h"
-#include "../../Common/MyCom.h"
-#include "../../Common/MyVector.h"
-
-#include "../ICoder.h"
-#include "../IPassword.h"
-
-namespace NCrypto {
-namespace N7z {
-
-const unsigned kKeySize = 32;
-const unsigned kSaltSizeMax = 16;
-const unsigned kIvSizeMax = 16; // AES_BLOCK_SIZE;
-
-class CKeyInfo
-{
-public:
- unsigned NumCyclesPower;
- unsigned SaltSize;
- Byte Salt[kSaltSizeMax];
- CByteBuffer Password;
- Byte Key[kKeySize];
-
- bool IsEqualTo(const CKeyInfo &a) const;
- void CalcKey();
-
- CKeyInfo() { ClearProps(); }
- void ClearProps()
- {
- NumCyclesPower = 0;
- SaltSize = 0;
- for (unsigned i = 0; i < sizeof(Salt); i++)
- Salt[i] = 0;
- }
-};
-
-class CKeyInfoCache
-{
- unsigned Size;
- CObjectVector<CKeyInfo> Keys;
-public:
- CKeyInfoCache(unsigned size): Size(size) {}
- bool GetKey(CKeyInfo &key);
- void Add(const CKeyInfo &key);
- void FindAndAdd(const CKeyInfo &key);
-};
-
-class CBase
-{
- CKeyInfoCache _cachedKeys;
-protected:
- CKeyInfo _key;
- Byte _iv[kIvSizeMax];
- unsigned _ivSize;
-
- void PrepareKey();
- CBase();
-};
-
-class CBaseCoder:
- public ICompressFilter,
- public ICryptoSetPassword,
- public CMyUnknownImp,
- public CBase
-{
-protected:
- CMyComPtr<ICompressFilter> _aesFilter;
-
-public:
- INTERFACE_ICompressFilter(;)
-
- STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
-};
-
-#ifndef EXTRACT_ONLY
-
-class CEncoder:
- public CBaseCoder,
- public ICompressWriteCoderProperties,
- // public ICryptoResetSalt,
- public ICryptoResetInitVector
-{
-public:
- MY_UNKNOWN_IMP4(
- ICompressFilter,
- ICryptoSetPassword,
- ICompressWriteCoderProperties,
- // ICryptoResetSalt,
- ICryptoResetInitVector)
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
- // STDMETHOD(ResetSalt)();
- STDMETHOD(ResetInitVector)();
- CEncoder();
-};
-
-#endif
-
-class CDecoder:
- public CBaseCoder,
- public ICompressSetDecoderProperties2
-{
-public:
- MY_UNKNOWN_IMP3(
- ICompressFilter,
- ICryptoSetPassword,
- ICompressSetDecoderProperties2)
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
- CDecoder();
-};
-
-}}
-
-#endif
+// 7zAes.h
+
+#ifndef ZIP7_INC_CRYPTO_7Z_AES_H
+#define ZIP7_INC_CRYPTO_7Z_AES_H
+
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+namespace NCrypto {
+namespace N7z {
+
+const unsigned kKeySize = 32;
+const unsigned kSaltSizeMax = 16;
+const unsigned kIvSizeMax = 16; // AES_BLOCK_SIZE;
+
+class CKeyInfo
+{
+public:
+ unsigned NumCyclesPower;
+ unsigned SaltSize;
+ Byte Salt[kSaltSizeMax];
+ CByteBuffer Password;
+ Byte Key[kKeySize];
+
+ bool IsEqualTo(const CKeyInfo &a) const;
+ void CalcKey();
+
+ CKeyInfo() { ClearProps(); }
+ void ClearProps()
+ {
+ NumCyclesPower = 0;
+ SaltSize = 0;
+ for (unsigned i = 0; i < sizeof(Salt); i++)
+ Salt[i] = 0;
+ }
+
+ void Wipe()
+ {
+ Password.Wipe();
+ NumCyclesPower = 0;
+ SaltSize = 0;
+ Z7_memset_0_ARRAY(Salt);
+ Z7_memset_0_ARRAY(Key);
+ }
+
+#ifdef Z7_CPP_IS_SUPPORTED_default
+ CKeyInfo(const CKeyInfo &) = default;
+#endif
+ ~CKeyInfo() { Wipe(); }
+};
+
+class CKeyInfoCache
+{
+ unsigned Size;
+ CObjectVector<CKeyInfo> Keys;
+public:
+ CKeyInfoCache(unsigned size): Size(size) {}
+ bool GetKey(CKeyInfo &key);
+ void Add(const CKeyInfo &key);
+ void FindAndAdd(const CKeyInfo &key);
+};
+
+class CBase
+{
+ CKeyInfoCache _cachedKeys;
+protected:
+ CKeyInfo _key;
+ Byte _iv[kIvSizeMax];
+ unsigned _ivSize;
+
+ void PrepareKey();
+ CBase();
+};
+
+class CBaseCoder:
+ public ICompressFilter,
+ public ICryptoSetPassword,
+ public CMyUnknownImp,
+ public CBase
+{
+ Z7_IFACE_COM7_IMP(ICompressFilter)
+ Z7_IFACE_COM7_IMP(ICryptoSetPassword)
+protected:
+ virtual ~CBaseCoder() {}
+ CMyComPtr<ICompressFilter> _aesFilter;
+};
+
+#ifndef Z7_EXTRACT_ONLY
+
+class CEncoder Z7_final:
+ public CBaseCoder,
+ public ICompressWriteCoderProperties,
+ // public ICryptoResetSalt,
+ public ICryptoResetInitVector
+{
+ Z7_COM_UNKNOWN_IMP_4(
+ ICompressFilter,
+ ICryptoSetPassword,
+ ICompressWriteCoderProperties,
+ // ICryptoResetSalt,
+ ICryptoResetInitVector)
+ Z7_IFACE_COM7_IMP(ICompressWriteCoderProperties)
+ // Z7_IFACE_COM7_IMP(ICryptoResetSalt)
+ Z7_IFACE_COM7_IMP(ICryptoResetInitVector)
+public:
+ CEncoder();
+};
+
+#endif
+
+class CDecoder Z7_final:
+ public CBaseCoder,
+ public ICompressSetDecoderProperties2
+{
+ Z7_COM_UNKNOWN_IMP_3(
+ ICompressFilter,
+ ICryptoSetPassword,
+ ICompressSetDecoderProperties2)
+ Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+public:
+ CDecoder();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/7zAesRegister.cpp b/CPP/7zip/Crypto/7zAesRegister.cpp
index c0b2060..69d0890 100644
--- a/CPP/7zip/Crypto/7zAesRegister.cpp
+++ b/CPP/7zip/Crypto/7zAesRegister.cpp
@@ -1,17 +1,17 @@
-// 7zAesRegister.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "7zAes.h"
-
-namespace NCrypto {
-namespace N7z {
-
-REGISTER_FILTER_E(7zAES,
- CDecoder(),
- CEncoder(),
- 0x6F10701, "7zAES")
-
-}}
+// 7zAesRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "7zAes.h"
+
+namespace NCrypto {
+namespace N7z {
+
+REGISTER_FILTER_E(SzAES,
+ CDecoder,
+ CEncoder,
+ 0x6F10701, "7zAES")
+
+}}
diff --git a/CPP/7zip/Crypto/Codec.def b/CPP/7zip/Crypto/Codec.def
new file mode 100644
index 0000000..ebf73a3
--- /dev/null
+++ b/CPP/7zip/Crypto/Codec.def
@@ -0,0 +1,4 @@
+EXPORTS
+ CreateObject PRIVATE
+ GetNumberOfMethods PRIVATE
+ GetMethodProperty PRIVATE
diff --git a/CPP/7zip/Crypto/HmacSha1.cpp b/CPP/7zip/Crypto/HmacSha1.cpp
new file mode 100644
index 0000000..30b1a8f
--- /dev/null
+++ b/CPP/7zip/Crypto/HmacSha1.cpp
@@ -0,0 +1,94 @@
+// HmacSha1.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "HmacSha1.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+void CHmac::SetKey(const Byte *key, size_t keySize)
+{
+ MY_ALIGN (16)
+ UInt32 temp[SHA1_NUM_BLOCK_WORDS];
+ size_t i;
+
+ for (i = 0; i < SHA1_NUM_BLOCK_WORDS; i++)
+ temp[i] = 0;
+
+ if (keySize > kBlockSize)
+ {
+ _sha.Init();
+ _sha.Update(key, keySize);
+ _sha.Final((Byte *)temp);
+ }
+ else
+ memcpy(temp, key, keySize);
+
+ for (i = 0; i < SHA1_NUM_BLOCK_WORDS; i++)
+ temp[i] ^= 0x36363636;
+
+ _sha.Init();
+ _sha.Update((const Byte *)temp, kBlockSize);
+
+ for (i = 0; i < SHA1_NUM_BLOCK_WORDS; i++)
+ temp[i] ^= 0x36363636 ^ 0x5C5C5C5C;
+
+ _sha2.Init();
+ _sha2.Update((const Byte *)temp, kBlockSize);
+}
+
+
+void CHmac::Final(Byte *mac)
+{
+ _sha.Final(mac);
+ _sha2.Update(mac, kDigestSize);
+ _sha2.Final(mac);
+}
+
+
+void CHmac::GetLoopXorDigest1(void *mac, UInt32 numIteration)
+{
+ MY_ALIGN (16) UInt32 block [SHA1_NUM_BLOCK_WORDS];
+ MY_ALIGN (16) UInt32 block2[SHA1_NUM_BLOCK_WORDS];
+ MY_ALIGN (16) UInt32 mac2 [SHA1_NUM_BLOCK_WORDS];
+
+ _sha. PrepareBlock((Byte *)block, SHA1_DIGEST_SIZE);
+ _sha2.PrepareBlock((Byte *)block2, SHA1_DIGEST_SIZE);
+
+ block[0] = ((const UInt32 *)mac)[0];
+ block[1] = ((const UInt32 *)mac)[1];
+ block[2] = ((const UInt32 *)mac)[2];
+ block[3] = ((const UInt32 *)mac)[3];
+ block[4] = ((const UInt32 *)mac)[4];
+
+ mac2[0] = block[0];
+ mac2[1] = block[1];
+ mac2[2] = block[2];
+ mac2[3] = block[3];
+ mac2[4] = block[4];
+
+ for (UInt32 i = 0; i < numIteration; i++)
+ {
+ _sha. GetBlockDigest((const Byte *)block, (Byte *)block2);
+ _sha2.GetBlockDigest((const Byte *)block2, (Byte *)block);
+
+ mac2[0] ^= block[0];
+ mac2[1] ^= block[1];
+ mac2[2] ^= block[2];
+ mac2[3] ^= block[3];
+ mac2[4] ^= block[4];
+ }
+
+ ((UInt32 *)mac)[0] = mac2[0];
+ ((UInt32 *)mac)[1] = mac2[1];
+ ((UInt32 *)mac)[2] = mac2[2];
+ ((UInt32 *)mac)[3] = mac2[3];
+ ((UInt32 *)mac)[4] = mac2[4];
+}
+
+}}
diff --git a/CPP/7zip/Crypto/HmacSha1.h b/CPP/7zip/Crypto/HmacSha1.h
new file mode 100644
index 0000000..a36c78e
--- /dev/null
+++ b/CPP/7zip/Crypto/HmacSha1.h
@@ -0,0 +1,31 @@
+// HmacSha1.h
+// Implements HMAC-SHA-1 (RFC2104, FIPS-198)
+
+#ifndef ZIP7_INC_CRYPTO_HMAC_SHA1_H
+#define ZIP7_INC_CRYPTO_HMAC_SHA1_H
+
+#include "Sha1Cls.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+// Use: SetKey(key, keySize); for () Update(data, size); FinalFull(mac);
+
+class CHmac
+{
+ CContext _sha;
+ CContext _sha2;
+public:
+ void SetKey(const Byte *key, size_t keySize);
+ void Update(const Byte *data, size_t dataSize) { _sha.Update(data, dataSize); }
+
+ // Final() : mac is recommended to be aligned for 4 bytes
+ // GetLoopXorDigest1() : mac is required to be aligned for 4 bytes
+ // The caller can use: UInt32 mac[NSha1::kNumDigestWords] and typecast to (Byte *) and (void *);
+ void Final(Byte *mac);
+ void GetLoopXorDigest1(void *mac, UInt32 numIteration);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/HmacSha256.cpp b/CPP/7zip/Crypto/HmacSha256.cpp
new file mode 100644
index 0000000..56f8ede
--- /dev/null
+++ b/CPP/7zip/Crypto/HmacSha256.cpp
@@ -0,0 +1,53 @@
+// HmacSha256.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "HmacSha256.h"
+
+namespace NCrypto {
+namespace NSha256 {
+
+void CHmac::SetKey(const Byte *key, size_t keySize)
+{
+ MY_ALIGN (16)
+ UInt32 temp[SHA256_NUM_BLOCK_WORDS];
+ size_t i;
+
+ for (i = 0; i < SHA256_NUM_BLOCK_WORDS; i++)
+ temp[i] = 0;
+
+ if (keySize > kBlockSize)
+ {
+ Sha256_Init(&_sha);
+ Sha256_Update(&_sha, key, keySize);
+ Sha256_Final(&_sha, (Byte *)temp);
+ }
+ else
+ memcpy(temp, key, keySize);
+
+ for (i = 0; i < SHA256_NUM_BLOCK_WORDS; i++)
+ temp[i] ^= 0x36363636;
+
+ Sha256_Init(&_sha);
+ Sha256_Update(&_sha, (const Byte *)temp, kBlockSize);
+
+ for (i = 0; i < SHA256_NUM_BLOCK_WORDS; i++)
+ temp[i] ^= 0x36363636 ^ 0x5C5C5C5C;
+
+ Sha256_Init(&_sha2);
+ Sha256_Update(&_sha2, (const Byte *)temp, kBlockSize);
+}
+
+
+void CHmac::Final(Byte *mac)
+{
+ Sha256_Final(&_sha, mac);
+ Sha256_Update(&_sha2, mac, SHA256_DIGEST_SIZE);
+ Sha256_Final(&_sha2, mac);
+}
+
+}}
diff --git a/CPP/7zip/Crypto/HmacSha256.h b/CPP/7zip/Crypto/HmacSha256.h
new file mode 100644
index 0000000..4039c0c
--- /dev/null
+++ b/CPP/7zip/Crypto/HmacSha256.h
@@ -0,0 +1,27 @@
+// HmacSha256.h
+// Implements HMAC-SHA-256 (RFC2104, FIPS-198)
+
+#ifndef ZIP7_INC_CRYPTO_HMAC_SHA256_H
+#define ZIP7_INC_CRYPTO_HMAC_SHA256_H
+
+#include "../../../C/Sha256.h"
+
+namespace NCrypto {
+namespace NSha256 {
+
+const unsigned kBlockSize = SHA256_BLOCK_SIZE;
+const unsigned kDigestSize = SHA256_DIGEST_SIZE;
+
+class CHmac
+{
+ CSha256 _sha;
+ CSha256 _sha2;
+public:
+ void SetKey(const Byte *key, size_t keySize);
+ void Update(const Byte *data, size_t dataSize) { Sha256_Update(&_sha, data, dataSize); }
+ void Final(Byte *mac);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/MyAes.cpp b/CPP/7zip/Crypto/MyAes.cpp
index 1d399d7..6abc388 100644
--- a/CPP/7zip/Crypto/MyAes.cpp
+++ b/CPP/7zip/Crypto/MyAes.cpp
@@ -1,112 +1,246 @@
-// Crypto/MyAes.cpp
-
-#include "StdAfx.h"
-
-#include "../../../C/CpuArch.h"
-
-#include "MyAes.h"
-
-namespace NCrypto {
-
-static struct CAesTabInit { CAesTabInit() { AesGenTables();} } g_AesTabInit;
-
-CAesCbcCoder::CAesCbcCoder(bool encodeMode, unsigned keySize):
- _keySize(keySize),
- _keyIsSet(false),
- _encodeMode(encodeMode)
-{
- _offset = ((0 - (unsigned)(ptrdiff_t)_aes) & 0xF) / sizeof(UInt32);
- memset(_iv, 0, AES_BLOCK_SIZE);
- SetFunctions(0);
-}
-
-STDMETHODIMP CAesCbcCoder::Init()
-{
- AesCbc_Init(_aes + _offset, _iv);
- return _keyIsSet ? S_OK : E_FAIL;
-}
-
-STDMETHODIMP_(UInt32) CAesCbcCoder::Filter(Byte *data, UInt32 size)
-{
- if (!_keyIsSet)
- return 0;
- if (size == 0)
- return 0;
- if (size < AES_BLOCK_SIZE)
- return AES_BLOCK_SIZE;
- size >>= 4;
- _codeFunc(_aes + _offset, data, size);
- return size << 4;
-}
-
-STDMETHODIMP CAesCbcCoder::SetKey(const Byte *data, UInt32 size)
-{
- if ((size & 0x7) != 0 || size < 16 || size > 32)
- return E_INVALIDARG;
- if (_keySize != 0 && size != _keySize)
- return E_INVALIDARG;
- AES_SET_KEY_FUNC setKeyFunc = _encodeMode ? Aes_SetKey_Enc : Aes_SetKey_Dec;
- setKeyFunc(_aes + _offset + 4, data, size);
- _keyIsSet = true;
- return S_OK;
-}
-
-STDMETHODIMP CAesCbcCoder::SetInitVector(const Byte *data, UInt32 size)
-{
- if (size != AES_BLOCK_SIZE)
- return E_INVALIDARG;
- memcpy(_iv, data, size);
- CAesCbcCoder::Init(); // don't call virtual function here !!!
- return S_OK;
-}
-
-EXTERN_C_BEGIN
-
-void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
-void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);
-
-EXTERN_C_END
-
-bool CAesCbcCoder::SetFunctions(UInt32 algo)
-{
- _codeFunc = _encodeMode ?
- g_AesCbc_Encode :
- g_AesCbc_Decode;
- if (algo == 1)
- {
- _codeFunc = _encodeMode ?
- AesCbc_Encode:
- AesCbc_Decode;
- }
- if (algo == 2)
- {
- #ifdef MY_CPU_X86_OR_AMD64
- if (g_AesCbc_Encode != AesCbc_Encode_Intel)
- #endif
- return false;
- }
- return true;
-}
-
-STDMETHODIMP CAesCbcCoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
-{
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- if (propIDs[i] == NCoderPropID::kDefaultProp)
- {
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- if (!SetFunctions(prop.ulVal))
- return E_NOTIMPL;
- }
- }
- return S_OK;
-}
-
-}
+// Crypto/MyAes.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "MyAes.h"
+
+namespace NCrypto {
+
+static struct CAesTabInit { CAesTabInit() { AesGenTables();} } g_AesTabInit;
+
+CAesCoder::CAesCoder(
+ // bool encodeMode,
+ unsigned keySize
+ // , bool ctrMode
+ ):
+ _keyIsSet(false),
+ // _encodeMode(encodeMode),
+ // _ctrMode(ctrMode),
+ _keySize(keySize),
+ // _ctrPos(0), // _ctrPos =0 will be set in Init()
+ _aes(AES_NUM_IVMRK_WORDS * 4 + AES_BLOCK_SIZE * 2)
+{
+ // _offset = ((0 - (unsigned)(ptrdiff_t)_aes) & 0xF) / sizeof(UInt32);
+ memset(_iv, 0, AES_BLOCK_SIZE);
+ /*
+ // we can use the following code to test 32-bit overflow case for AES-CTR
+ for (unsigned i = 0; i < 16; i++) _iv[i] = (Byte)(i + 1);
+ _iv[0] = 0xFE; _iv[1] = _iv[2] = _iv[3] = 0xFF;
+ */
+}
+
+Z7_COM7F_IMF(CAesCoder::Init())
+{
+ _ctrPos = 0;
+ AesCbc_Init(Aes(), _iv);
+ return _keyIsSet ? S_OK : E_NOTIMPL; // E_FAIL
+}
+
+Z7_COM7F_IMF2(UInt32, CAesCoder::Filter(Byte *data, UInt32 size))
+{
+ if (!_keyIsSet)
+ return 0;
+ if (size < AES_BLOCK_SIZE)
+ {
+ if (size == 0)
+ return 0;
+ return AES_BLOCK_SIZE;
+ }
+ size >>= 4;
+ // (data) must be aligned for 16-bytes here
+ _codeFunc(Aes(), data, size);
+ return size << 4;
+}
+
+
+Z7_COM7F_IMF(CAesCoder::SetKey(const Byte *data, UInt32 size))
+{
+ if ((size & 0x7) != 0 || size < 16 || size > 32)
+ return E_INVALIDARG;
+ if (_keySize != 0 && size != _keySize)
+ return E_INVALIDARG;
+ _setKeyFunc(Aes() + 4, data, size);
+ _keyIsSet = true;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAesCoder::SetInitVector(const Byte *data, UInt32 size))
+{
+ if (size != AES_BLOCK_SIZE)
+ return E_INVALIDARG;
+ memcpy(_iv, data, size);
+ /* we allow SetInitVector() call before SetKey() call.
+ so we ignore possible error in Init() here */
+ CAesCoder::Init(); // don't call virtual function here !!!
+ return S_OK;
+}
+
+
+#ifndef Z7_SFX
+
+/*
+Z7_COM7F_IMF(CAesCtrCoder::Init())
+{
+ _ctrPos = 0;
+ return CAesCoder::Init();
+}
+*/
+
+Z7_COM7F_IMF2(UInt32, CAesCtrCoder::Filter(Byte *data, UInt32 size))
+{
+ if (!_keyIsSet)
+ return 0;
+ if (size == 0)
+ return 0;
+
+ if (_ctrPos != 0)
+ {
+ /* Optimized caller will not call here */
+ const Byte *ctr = (Byte *)(Aes() + AES_NUM_IVMRK_WORDS);
+ unsigned num = 0;
+ for (unsigned i = _ctrPos; i != AES_BLOCK_SIZE; i++)
+ {
+ if (num == size)
+ {
+ _ctrPos = i;
+ return num;
+ }
+ data[num++] ^= ctr[i];
+ }
+ _ctrPos = 0;
+ /* if (num < size) {
+ we can filter more data with _codeFunc().
+ But it's supposed that the caller can work correctly,
+ even if we do only partial filtering here.
+ So we filter data only for current 16-byte block. }
+ */
+ /*
+ size -= num;
+ size >>= 4;
+ // (data) must be aligned for 16-bytes here
+ _codeFunc(Aes(), data + num, size);
+ return num + (size << 4);
+ */
+ return num;
+ }
+
+ if (size < AES_BLOCK_SIZE)
+ {
+ /* The good optimized caller can call here only in last Filter() call.
+ But we support also non-optimized callers,
+ where another Filter() calls are allowed after this call.
+ */
+ Byte *ctr = (Byte *)(Aes() + AES_NUM_IVMRK_WORDS);
+ memset(ctr, 0, AES_BLOCK_SIZE);
+ memcpy(ctr, data, size);
+ _codeFunc(Aes(), ctr, 1);
+ memcpy(data, ctr, size);
+ _ctrPos = size;
+ return size;
+ }
+
+ size >>= 4;
+ // (data) must be aligned for 16-bytes here
+ _codeFunc(Aes(), data, size);
+ return size << 4;
+}
+
+#endif // Z7_SFX
+
+
+#ifndef Z7_EXTRACT_ONLY
+
+#ifdef MY_CPU_X86_OR_AMD64
+ #define USE_HW_AES
+#elif defined(MY_CPU_ARM_OR_ARM64) && defined(MY_CPU_LE)
+ #if defined(__clang__)
+ #if (__clang_major__ >= 8) // fix that check
+ #define USE_HW_AES
+ #endif
+ #elif defined(__GNUC__)
+ #if (__GNUC__ >= 6) // fix that check
+ #define USE_HW_AES
+ #endif
+ #elif defined(_MSC_VER)
+ #if _MSC_VER >= 1910
+ #define USE_HW_AES
+ #endif
+ #endif
+#endif
+
+#ifdef USE_HW_AES
+ #define SET_AES_FUNC_2(f2) \
+ if (algo == 2) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW) \
+ { f = f2; }
+ #ifdef MY_CPU_X86_OR_AMD64
+ #define SET_AES_FUNC_23(f2, f3) \
+ SET_AES_FUNC_2(f2) \
+ if (algo == 3) if (g_Aes_SupportedFunctions_Flags & k_Aes_SupportedFunctions_HW_256) \
+ { f = f3; }
+ #else // MY_CPU_X86_OR_AMD64
+ #define SET_AES_FUNC_23(f2, f3) \
+ SET_AES_FUNC_2(f2)
+ #endif // MY_CPU_X86_OR_AMD64
+#else // USE_HW_AES
+ #define SET_AES_FUNC_23(f2, f3)
+#endif // USE_HW_AES
+
+#define SET_AES_FUNCS(c, f0, f1, f2, f3) \
+ bool c::SetFunctions(UInt32 algo) { \
+ _codeFunc = f0; if (algo < 1) return true; \
+ AES_CODE_FUNC f = NULL; \
+ if (algo == 1) { f = f1; } \
+ SET_AES_FUNC_23(f2, f3) \
+ if (f) { _codeFunc = f; return true; } \
+ return false; }
+
+
+
+#ifndef Z7_SFX
+SET_AES_FUNCS(
+ CAesCtrCoder,
+ g_AesCtr_Code,
+ AesCtr_Code,
+ AesCtr_Code_HW,
+ AesCtr_Code_HW_256)
+#endif
+
+SET_AES_FUNCS(
+ CAesCbcEncoder,
+ g_AesCbc_Encode,
+ AesCbc_Encode,
+ AesCbc_Encode_HW,
+ AesCbc_Encode_HW)
+
+SET_AES_FUNCS(
+ CAesCbcDecoder,
+ g_AesCbc_Decode,
+ AesCbc_Decode,
+ AesCbc_Decode_HW,
+ AesCbc_Decode_HW_256)
+
+Z7_COM7F_IMF(CAesCoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ UInt32 algo = 0;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ if (propIDs[i] == NCoderPropID::kDefaultProp)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ if (prop.ulVal > 3)
+ return E_NOTIMPL;
+ algo = prop.ulVal;
+ }
+ }
+ if (!SetFunctions(algo))
+ return E_NOTIMPL;
+ return S_OK;
+}
+
+#endif // Z7_EXTRACT_ONLY
+
+}
diff --git a/CPP/7zip/Crypto/MyAes.h b/CPP/7zip/Crypto/MyAes.h
index 8d5ed98..a3c1c27 100644
--- a/CPP/7zip/Crypto/MyAes.h
+++ b/CPP/7zip/Crypto/MyAes.h
@@ -1,57 +1,122 @@
-// Crypto/MyAes.h
-
-#ifndef __CRYPTO_MY_AES_H
-#define __CRYPTO_MY_AES_H
-
-#include "../../../C/Aes.h"
-
-#include "../../Common/MyCom.h"
-
-#include "../ICoder.h"
-
-namespace NCrypto {
-
-class CAesCbcCoder:
- public ICompressFilter,
- public ICryptoProperties,
- public ICompressSetCoderProperties,
- public CMyUnknownImp
-{
- AES_CODE_FUNC _codeFunc;
- unsigned _offset;
- unsigned _keySize;
- bool _keyIsSet;
- bool _encodeMode;
- UInt32 _aes[AES_NUM_IVMRK_WORDS + 3];
- Byte _iv[AES_BLOCK_SIZE];
-
- bool SetFunctions(UInt32 algo);
-
-public:
- CAesCbcCoder(bool encodeMode, unsigned keySize);
-
- virtual ~CAesCbcCoder() {}; // we need virtual destructor for derived classes
-
- MY_UNKNOWN_IMP3(ICompressFilter, ICryptoProperties, ICompressSetCoderProperties)
-
- INTERFACE_ICompressFilter(;)
-
- STDMETHOD(SetKey)(const Byte *data, UInt32 size);
- STDMETHOD(SetInitVector)(const Byte *data, UInt32 size);
-
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
-};
-
-struct CAesCbcEncoder: public CAesCbcCoder
-{
- CAesCbcEncoder(unsigned keySize = 0): CAesCbcCoder(true, keySize) {}
-};
-
-struct CAesCbcDecoder: public CAesCbcCoder
-{
- CAesCbcDecoder(unsigned keySize = 0): CAesCbcCoder(false, keySize) {}
-};
-
-}
-
-#endif
+// Crypto/MyAes.h
+
+#ifndef ZIP7_INC_CRYPTO_MY_AES_H
+#define ZIP7_INC_CRYPTO_MY_AES_H
+
+#include "../../../C/Aes.h"
+
+#include "../../Common/MyBuffer2.h"
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCrypto {
+
+#ifdef Z7_EXTRACT_ONLY
+#define Z7_IFACEN_IAesCoderSetFunctions(x)
+#else
+#define Z7_IFACEN_IAesCoderSetFunctions(x) \
+ virtual bool SetFunctions(UInt32 algo) x
+#endif
+
+
+class CAesCoder:
+ public ICompressFilter,
+ public ICryptoProperties,
+ #ifndef Z7_EXTRACT_ONLY
+ public ICompressSetCoderProperties,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(ICompressFilter)
+ Z7_COM_QI_ENTRY(ICryptoProperties)
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_COM_QI_ENTRY(ICompressSetCoderProperties)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+public:
+ Z7_IFACE_COM7_IMP_NONFINAL(ICompressFilter)
+ Z7_IFACE_COM7_IMP(ICryptoProperties)
+private:
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_IFACE_COM7_IMP(ICompressSetCoderProperties)
+ #endif
+
+protected:
+ bool _keyIsSet;
+ // bool _encodeMode;
+ // bool _ctrMode;
+ // unsigned _offset;
+ unsigned _keySize;
+ unsigned _ctrPos; // we need _ctrPos here for Init() / SetInitVector()
+ AES_CODE_FUNC _codeFunc;
+ AES_SET_KEY_FUNC _setKeyFunc;
+private:
+ // UInt32 _aes[AES_NUM_IVMRK_WORDS + 3];
+ CAlignedBuffer1 _aes;
+
+ Byte _iv[AES_BLOCK_SIZE];
+
+ // UInt32 *Aes() { return _aes + _offset; }
+protected:
+ UInt32 *Aes() { return (UInt32 *)(void *)(Byte *)_aes; }
+
+ Z7_IFACE_PURE(IAesCoderSetFunctions)
+
+public:
+ CAesCoder(
+ // bool encodeMode,
+ unsigned keySize
+ // , bool ctrMode
+ );
+ virtual ~CAesCoder() {} // we need virtual destructor for derived classes
+ void SetKeySize(unsigned size) { _keySize = size; }
+};
+
+
+#ifndef Z7_EXTRACT_ONLY
+struct CAesCbcEncoder: public CAesCoder
+{
+ CAesCbcEncoder(unsigned keySize = 0): CAesCoder(keySize)
+ {
+ _setKeyFunc = Aes_SetKey_Enc;
+ _codeFunc = g_AesCbc_Encode;
+ }
+ Z7_IFACE_IMP(IAesCoderSetFunctions)
+};
+#endif
+
+struct CAesCbcDecoder: public CAesCoder
+{
+ CAesCbcDecoder(unsigned keySize = 0): CAesCoder(keySize)
+ {
+ _setKeyFunc = Aes_SetKey_Dec;
+ _codeFunc = g_AesCbc_Decode;
+ }
+ Z7_IFACE_IMP(IAesCoderSetFunctions)
+};
+
+#ifndef Z7_SFX
+struct CAesCtrCoder: public CAesCoder
+{
+private:
+ // unsigned _ctrPos;
+ // Z7_IFACE_COM7_IMP(ICompressFilter)
+ // Z7_COM7F_IMP(Init())
+ Z7_COM7F_IMP2(UInt32, Filter(Byte *data, UInt32 size))
+public:
+ CAesCtrCoder(unsigned keySize = 0): CAesCoder(keySize)
+ {
+ _ctrPos = 0;
+ _setKeyFunc = Aes_SetKey_Enc;
+ _codeFunc = g_AesCtr_Code;
+ }
+ Z7_IFACE_IMP(IAesCoderSetFunctions)
+};
+#endif
+
+}
+
+#endif
diff --git a/CPP/7zip/Crypto/MyAesReg.cpp b/CPP/7zip/Crypto/MyAesReg.cpp
index 3427ad6..e2b4f72 100644
--- a/CPP/7zip/Crypto/MyAesReg.cpp
+++ b/CPP/7zip/Crypto/MyAesReg.cpp
@@ -1,16 +1,29 @@
-// MyAesReg.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/RegisterCodec.h"
-
-#include "MyAes.h"
-
-namespace NCrypto {
-
-REGISTER_FILTER_E(AES256CBC,
- CAesCbcDecoder(32),
- CAesCbcEncoder(32),
- 0x6F00181, "AES256CBC")
-
-}
+// MyAesReg.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "MyAes.h"
+
+namespace NCrypto {
+
+#ifndef Z7_SFX
+
+#define REGISTER_AES_2(name, nameString, keySize) \
+ REGISTER_FILTER_E(name, \
+ CAesCbcDecoder(keySize), \
+ CAesCbcEncoder(keySize), \
+ 0x6F00100 | ((keySize - 16) * 8) | (/* isCtr */ 0 ? 4 : 1), \
+ nameString) \
+
+#define REGISTER_AES(name, nameString) \
+ /* REGISTER_AES_2(AES128 ## name, "AES128" nameString, 16) */ \
+ /* REGISTER_AES_2(AES192 ## name, "AES192" nameString, 24) */ \
+ REGISTER_AES_2(AES256 ## name, "AES256" nameString, 32) \
+
+REGISTER_AES(CBC, "CBC")
+
+#endif
+
+}
diff --git a/CPP/7zip/Crypto/Pbkdf2HmacSha1.cpp b/CPP/7zip/Crypto/Pbkdf2HmacSha1.cpp
new file mode 100644
index 0000000..3d9e4c1
--- /dev/null
+++ b/CPP/7zip/Crypto/Pbkdf2HmacSha1.cpp
@@ -0,0 +1,48 @@
+// Pbkdf2HmacSha1.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "HmacSha1.h"
+#include "Pbkdf2HmacSha1.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+void Pbkdf2Hmac(const Byte *pwd, size_t pwdSize,
+ const Byte *salt, size_t saltSize,
+ UInt32 numIterations,
+ Byte *key, size_t keySize)
+{
+ MY_ALIGN (16)
+ CHmac baseCtx;
+ baseCtx.SetKey(pwd, pwdSize);
+
+ for (UInt32 i = 1; keySize != 0; i++)
+ {
+ MY_ALIGN (16)
+ CHmac ctx;
+ ctx = baseCtx;
+ ctx.Update(salt, saltSize);
+
+ MY_ALIGN (16)
+ UInt32 u[kNumDigestWords];
+ SetBe32(u, i)
+
+ ctx.Update((const Byte *)u, 4);
+ ctx.Final((Byte *)u);
+
+ ctx = baseCtx;
+ ctx.GetLoopXorDigest1((void *)u, numIterations - 1);
+
+ const unsigned curSize = (keySize < kDigestSize) ? (unsigned)keySize : kDigestSize;
+ memcpy(key, (const Byte *)u, curSize);
+ key += curSize;
+ keySize -= curSize;
+ }
+}
+
+}}
diff --git a/CPP/7zip/Crypto/Pbkdf2HmacSha1.h b/CPP/7zip/Crypto/Pbkdf2HmacSha1.h
new file mode 100644
index 0000000..89cbe41
--- /dev/null
+++ b/CPP/7zip/Crypto/Pbkdf2HmacSha1.h
@@ -0,0 +1,19 @@
+// Pbkdf2HmacSha1.h
+// Password-Based Key Derivation Function (RFC 2898, PKCS #5) based on HMAC-SHA-1
+
+#ifndef ZIP7_INC_CRYPTO_PBKDF2_HMAC_SHA1_H
+#define ZIP7_INC_CRYPTO_PBKDF2_HMAC_SHA1_H
+
+#include <stddef.h>
+
+#include "../../Common/MyTypes.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+void Pbkdf2Hmac(const Byte *pwd, size_t pwdSize, const Byte *salt, size_t saltSize,
+ UInt32 numIterations, Byte *key, size_t keySize);
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/RandGen.cpp b/CPP/7zip/Crypto/RandGen.cpp
index 791275f..05a6c06 100644
--- a/CPP/7zip/Crypto/RandGen.cpp
+++ b/CPP/7zip/Crypto/RandGen.cpp
@@ -1,233 +1,241 @@
-// RandGen.cpp
-
-#include "StdAfx.h"
-
-#include "RandGen.h"
-
-#ifndef USE_STATIC_SYSTEM_RAND
-
-#ifndef _7ZIP_ST
-#include "../../Windows/Synchronization.h"
-#endif
-
-
-#ifdef _WIN32
-
-#ifdef _WIN64
-#define USE_STATIC_RtlGenRandom
-#endif
-
-#ifdef USE_STATIC_RtlGenRandom
-
-#include <ntsecapi.h>
-
-EXTERN_C_BEGIN
-#ifndef RtlGenRandom
- #define RtlGenRandom SystemFunction036
- BOOLEAN WINAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
-#endif
-EXTERN_C_END
-
-#else
-EXTERN_C_BEGIN
-typedef BOOLEAN (WINAPI * Func_RtlGenRandom)(PVOID RandomBuffer, ULONG RandomBufferLength);
-EXTERN_C_END
-#endif
-
-
-#else
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#define USE_POSIX_TIME
-#define USE_POSIX_TIME2
-#endif
-
-#ifdef USE_POSIX_TIME
-#include <time.h>
-#ifdef USE_POSIX_TIME2
-#include <sys/time.h>
-#endif
-#endif
-
-// The seed and first generated data block depend from processID,
-// theadID, timer and system random generator, if available.
-// Other generated data blocks depend from previous state
-
-#define HASH_UPD(x) Sha256_Update(&hash, (const Byte *)&x, sizeof(x));
-
-void CRandomGenerator::Init()
-{
- CSha256 hash;
- Sha256_Init(&hash);
-
- unsigned numIterations = 1000;
-
- {
- #ifndef UNDER_CE
- const unsigned kNumIterations_Small = 100;
- const unsigned kBufSize = 32;
- Byte buf[kBufSize];
- #endif
-
- #ifdef _WIN32
-
- DWORD w = ::GetCurrentProcessId();
- HASH_UPD(w);
- w = ::GetCurrentThreadId();
- HASH_UPD(w);
-
- #ifdef UNDER_CE
- /*
- if (CeGenRandom(kBufSize, buf))
- {
- numIterations = kNumIterations_Small;
- Sha256_Update(&hash, buf, kBufSize);
- }
- */
- #elif defined(USE_STATIC_RtlGenRandom)
- if (RtlGenRandom(buf, kBufSize))
- {
- numIterations = kNumIterations_Small;
- Sha256_Update(&hash, buf, kBufSize);
- }
- #else
- {
- HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
- if (hModule)
- {
- // SystemFunction036() is real name of RtlGenRandom() function
- Func_RtlGenRandom my_RtlGenRandom = (Func_RtlGenRandom)GetProcAddress(hModule, "SystemFunction036");
- if (my_RtlGenRandom)
- {
- if (my_RtlGenRandom(buf, kBufSize))
- {
- numIterations = kNumIterations_Small;
- Sha256_Update(&hash, buf, kBufSize);
- }
- }
- ::FreeLibrary(hModule);
- }
- }
- #endif
-
- #else
-
- pid_t pid = getpid();
- HASH_UPD(pid);
- pid = getppid();
- HASH_UPD(pid);
-
- {
- int f = open("/dev/urandom", O_RDONLY);
- unsigned numBytes = kBufSize;
- if (f >= 0)
- {
- do
- {
- int n = read(f, buf, numBytes);
- if (n <= 0)
- break;
- Sha256_Update(&hash, buf, n);
- numBytes -= n;
- }
- while (numBytes);
- close(f);
- if (numBytes == 0)
- numIterations = kNumIterations_Small;
- }
- }
- /*
- {
- int n = getrandom(buf, kBufSize, 0);
- if (n > 0)
- {
- Sha256_Update(&hash, buf, n);
- if (n == kBufSize)
- numIterations = kNumIterations_Small;
- }
- }
- */
-
- #endif
- }
-
- #ifdef _DEBUG
- numIterations = 2;
- #endif
-
- do
- {
- #ifdef _WIN32
- LARGE_INTEGER v;
- if (::QueryPerformanceCounter(&v))
- HASH_UPD(v.QuadPart);
- #endif
-
- #ifdef USE_POSIX_TIME
- #ifdef USE_POSIX_TIME2
- timeval v;
- if (gettimeofday(&v, 0) == 0)
- {
- HASH_UPD(v.tv_sec);
- HASH_UPD(v.tv_usec);
- }
- #endif
- time_t v2 = time(NULL);
- HASH_UPD(v2);
- #endif
-
- #ifdef _WIN32
- DWORD tickCount = ::GetTickCount();
- HASH_UPD(tickCount);
- #endif
-
- for (unsigned j = 0; j < 100; j++)
- {
- Sha256_Final(&hash, _buff);
- Sha256_Init(&hash);
- Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
- }
- }
- while (--numIterations);
-
- Sha256_Final(&hash, _buff);
- _needInit = false;
-}
-
-#ifndef _7ZIP_ST
- static NWindows::NSynchronization::CCriticalSection g_CriticalSection;
- #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
-#else
- #define MT_LOCK
-#endif
-
-void CRandomGenerator::Generate(Byte *data, unsigned size)
-{
- MT_LOCK
-
- if (_needInit)
- Init();
- while (size != 0)
- {
- CSha256 hash;
-
- Sha256_Init(&hash);
- Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
- Sha256_Final(&hash, _buff);
-
- Sha256_Init(&hash);
- UInt32 salt = 0xF672ABD1;
- HASH_UPD(salt);
- Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
- Byte buff[SHA256_DIGEST_SIZE];
- Sha256_Final(&hash, buff);
- for (unsigned i = 0; i < SHA256_DIGEST_SIZE && size != 0; i++, size--)
- *data++ = buff[i];
- }
-}
-
-CRandomGenerator g_RandomGenerator;
-
-#endif
+// RandGen.cpp
+
+#include "StdAfx.h"
+
+#include "RandGen.h"
+
+#ifndef USE_STATIC_SYSTEM_RAND
+
+#ifndef Z7_ST
+#include "../../Windows/Synchronization.h"
+#endif
+
+
+#ifdef _WIN32
+
+#ifdef _WIN64
+#define USE_STATIC_RtlGenRandom
+#endif
+
+#ifdef USE_STATIC_RtlGenRandom
+
+// #include <NTSecAPI.h>
+
+EXTERN_C_BEGIN
+#ifndef RtlGenRandom
+ #define RtlGenRandom SystemFunction036
+ BOOLEAN WINAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
+#endif
+EXTERN_C_END
+
+#else
+EXTERN_C_BEGIN
+typedef BOOLEAN (WINAPI * Func_RtlGenRandom)(PVOID RandomBuffer, ULONG RandomBufferLength);
+EXTERN_C_END
+#endif
+
+
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#define USE_POSIX_TIME
+#define USE_POSIX_TIME2
+#endif
+
+#ifdef USE_POSIX_TIME
+#include <time.h>
+#ifdef USE_POSIX_TIME2
+#include <sys/time.h>
+#endif
+#endif
+
+// The seed and first generated data block depend from processID,
+// theadID, timer and system random generator, if available.
+// Other generated data blocks depend from previous state
+
+#define HASH_UPD(x) Sha256_Update(&hash, (const Byte *)&x, sizeof(x));
+
+void CRandomGenerator::Init()
+{
+ MY_ALIGN (16)
+ CSha256 hash;
+ Sha256_Init(&hash);
+
+ unsigned numIterations = 1000;
+
+ {
+ #ifndef UNDER_CE
+ const unsigned kNumIterations_Small = 100;
+ const unsigned kBufSize = 32;
+ MY_ALIGN (16)
+ Byte buf[kBufSize];
+ #endif
+
+ #ifdef _WIN32
+
+ DWORD w = ::GetCurrentProcessId();
+ HASH_UPD(w)
+ w = ::GetCurrentThreadId();
+ HASH_UPD(w)
+
+ #ifdef UNDER_CE
+ /*
+ if (CeGenRandom(kBufSize, buf))
+ {
+ numIterations = kNumIterations_Small;
+ Sha256_Update(&hash, buf, kBufSize);
+ }
+ */
+ #elif defined(USE_STATIC_RtlGenRandom)
+ if (RtlGenRandom(buf, kBufSize))
+ {
+ numIterations = kNumIterations_Small;
+ Sha256_Update(&hash, buf, kBufSize);
+ }
+ #else
+ {
+ const HMODULE hModule = ::LoadLibrary(TEXT("advapi32.dll"));
+ if (hModule)
+ {
+ // SystemFunction036() is real name of RtlGenRandom() function
+ const
+ Func_RtlGenRandom
+ my_RtlGenRandom = Z7_GET_PROC_ADDRESS(
+ Func_RtlGenRandom, hModule, "SystemFunction036");
+ if (my_RtlGenRandom)
+ {
+ if (my_RtlGenRandom(buf, kBufSize))
+ {
+ numIterations = kNumIterations_Small;
+ Sha256_Update(&hash, buf, kBufSize);
+ }
+ }
+ ::FreeLibrary(hModule);
+ }
+ }
+ #endif
+
+ #else
+
+ pid_t pid = getpid();
+ HASH_UPD(pid)
+ pid = getppid();
+ HASH_UPD(pid)
+
+ {
+ int f = open("/dev/urandom", O_RDONLY);
+ unsigned numBytes = kBufSize;
+ if (f >= 0)
+ {
+ do
+ {
+ ssize_t n = read(f, buf, numBytes);
+ if (n <= 0)
+ break;
+ Sha256_Update(&hash, buf, (size_t)n);
+ numBytes -= (unsigned)n;
+ }
+ while (numBytes);
+ close(f);
+ if (numBytes == 0)
+ numIterations = kNumIterations_Small;
+ }
+ }
+ /*
+ {
+ int n = getrandom(buf, kBufSize, 0);
+ if (n > 0)
+ {
+ Sha256_Update(&hash, buf, n);
+ if (n == kBufSize)
+ numIterations = kNumIterations_Small;
+ }
+ }
+ */
+
+ #endif
+ }
+
+ #ifdef _DEBUG
+ numIterations = 2;
+ #endif
+
+ do
+ {
+ #ifdef _WIN32
+ LARGE_INTEGER v;
+ if (::QueryPerformanceCounter(&v))
+ HASH_UPD(v.QuadPart)
+ #endif
+
+ #ifdef USE_POSIX_TIME
+ #ifdef USE_POSIX_TIME2
+ timeval v;
+ if (gettimeofday(&v, NULL) == 0)
+ {
+ HASH_UPD(v.tv_sec)
+ HASH_UPD(v.tv_usec)
+ }
+ #endif
+ const time_t v2 = time(NULL);
+ HASH_UPD(v2)
+ #endif
+
+ #ifdef _WIN32
+ const DWORD tickCount = ::GetTickCount();
+ HASH_UPD(tickCount)
+ #endif
+
+ for (unsigned j = 0; j < 100; j++)
+ {
+ Sha256_Final(&hash, _buff);
+ Sha256_Init(&hash);
+ Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
+ }
+ }
+ while (--numIterations);
+
+ Sha256_Final(&hash, _buff);
+ _needInit = false;
+}
+
+#ifndef Z7_ST
+ static NWindows::NSynchronization::CCriticalSection g_CriticalSection;
+ #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+ #define MT_LOCK
+#endif
+
+void CRandomGenerator::Generate(Byte *data, unsigned size)
+{
+ MT_LOCK
+
+ if (_needInit)
+ Init();
+ while (size != 0)
+ {
+ MY_ALIGN (16)
+ CSha256 hash;
+
+ Sha256_Init(&hash);
+ Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
+ Sha256_Final(&hash, _buff);
+
+ Sha256_Init(&hash);
+ UInt32 salt = 0xF672ABD1;
+ HASH_UPD(salt)
+ Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
+ MY_ALIGN (16)
+ Byte buff[SHA256_DIGEST_SIZE];
+ Sha256_Final(&hash, buff);
+ for (unsigned i = 0; i < SHA256_DIGEST_SIZE && size != 0; i++, size--)
+ *data++ = buff[i];
+ }
+}
+
+MY_ALIGN (16)
+CRandomGenerator g_RandomGenerator;
+
+#endif
diff --git a/CPP/7zip/Crypto/RandGen.h b/CPP/7zip/Crypto/RandGen.h
index dc5a338..3bd69ec 100644
--- a/CPP/7zip/Crypto/RandGen.h
+++ b/CPP/7zip/Crypto/RandGen.h
@@ -1,40 +1,41 @@
-// RandGen.h
-
-#ifndef __CRYPTO_RAND_GEN_H
-#define __CRYPTO_RAND_GEN_H
-
-#include "../../../C/Sha256.h"
-
-#ifdef _WIN64
-// #define USE_STATIC_SYSTEM_RAND
-#endif
-
-#ifdef USE_STATIC_SYSTEM_RAND
-
-#ifdef _WIN32
-#include <ntsecapi.h>
-#define MY_RAND_GEN(data, size) RtlGenRandom(data, size)
-#else
-#define MY_RAND_GEN(data, size) getrandom(data, size, 0)
-#endif
-
-#else
-
-class CRandomGenerator
-{
- Byte _buff[SHA256_DIGEST_SIZE];
- bool _needInit;
-
- void Init();
-public:
- CRandomGenerator(): _needInit(true) {};
- void Generate(Byte *data, unsigned size);
-};
-
-extern CRandomGenerator g_RandomGenerator;
-
-#define MY_RAND_GEN(data, size) g_RandomGenerator.Generate(data, size)
-
-#endif
-
-#endif
+// RandGen.h
+
+#ifndef ZIP7_INC_CRYPTO_RAND_GEN_H
+#define ZIP7_INC_CRYPTO_RAND_GEN_H
+
+#include "../../../C/Sha256.h"
+
+#ifdef _WIN64
+// #define USE_STATIC_SYSTEM_RAND
+#endif
+
+#ifdef USE_STATIC_SYSTEM_RAND
+
+#ifdef _WIN32
+#include <ntsecapi.h>
+#define MY_RAND_GEN(data, size) RtlGenRandom(data, size)
+#else
+#define MY_RAND_GEN(data, size) getrandom(data, size, 0)
+#endif
+
+#else
+
+class CRandomGenerator
+{
+ Byte _buff[SHA256_DIGEST_SIZE];
+ bool _needInit;
+
+ void Init();
+public:
+ CRandomGenerator(): _needInit(true) {}
+ void Generate(Byte *data, unsigned size);
+};
+
+MY_ALIGN (16)
+extern CRandomGenerator g_RandomGenerator;
+
+#define MY_RAND_GEN(data, size) g_RandomGenerator.Generate(data, size)
+
+#endif
+
+#endif
diff --git a/CPP/7zip/Crypto/Rar20Crypto.cpp b/CPP/7zip/Crypto/Rar20Crypto.cpp
new file mode 100644
index 0000000..8e55763
--- /dev/null
+++ b/CPP/7zip/Crypto/Rar20Crypto.cpp
@@ -0,0 +1,130 @@
+// Crypto/Rar20Crypto.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/RotateDefs.h"
+
+#include "Rar20Crypto.h"
+
+namespace NCrypto {
+namespace NRar2 {
+
+static const unsigned kNumRounds = 32;
+
+static const Byte g_InitSubstTable[256] = {
+ 215, 19,149, 35, 73,197,192,205,249, 28, 16,119, 48,221, 2, 42,
+ 232, 1,177,233, 14, 88,219, 25,223,195,244, 90, 87,239,153,137,
+ 255,199,147, 70, 92, 66,246, 13,216, 40, 62, 29,217,230, 86, 6,
+ 71, 24,171,196,101,113,218,123, 93, 91,163,178,202, 67, 44,235,
+ 107,250, 75,234, 49,167,125,211, 83,114,157,144, 32,193,143, 36,
+ 158,124,247,187, 89,214,141, 47,121,228, 61,130,213,194,174,251,
+ 97,110, 54,229,115, 57,152, 94,105,243,212, 55,209,245, 63, 11,
+ 164,200, 31,156, 81,176,227, 21, 76, 99,139,188,127, 17,248, 51,
+ 207,120,189,210, 8,226, 41, 72,183,203,135,165,166, 60, 98, 7,
+ 122, 38,155,170, 69,172,252,238, 39,134, 59,128,236, 27,240, 80,
+ 131, 3, 85,206,145, 79,154,142,159,220,201,133, 74, 64, 20,129,
+ 224,185,138,103,173,182, 43, 34,254, 82,198,151,231,180, 58, 10,
+ 118, 26,102, 12, 50,132, 22,191,136,111,162,179, 45, 4,148,108,
+ 161, 56, 78,126,242,222, 15,175,146, 23, 33,241,181,190, 77,225,
+ 0, 46,169,186, 68, 95,237, 65, 53,208,253,168, 9, 18,100, 52,
+ 116,184,160, 96,109, 37, 30,106,140,104,150, 5,204,117,112, 84
+};
+
+void CData::UpdateKeys(const Byte *data)
+{
+ for (unsigned i = 0; i < 16; i += 4)
+ for (unsigned j = 0; j < 4; j++)
+ Keys[j] ^= g_CrcTable[data[i + j]];
+}
+
+static inline void Swap(Byte &b1, Byte &b2)
+{
+ Byte b = b1;
+ b1 = b2;
+ b2 = b;
+}
+
+void CData::SetPassword(const Byte *data, unsigned size)
+{
+ Keys[0] = 0xD3A3B879L;
+ Keys[1] = 0x3F6D12F7L;
+ Keys[2] = 0x7515A235L;
+ Keys[3] = 0xA4E7F123L;
+
+ Byte psw[128];
+ Z7_memset_0_ARRAY(psw);
+ if (size != 0)
+ {
+ if (size >= sizeof(psw))
+ size = sizeof(psw) - 1;
+ memcpy(psw, data, size);
+ }
+
+ memcpy(SubstTable, g_InitSubstTable, sizeof(SubstTable));
+
+ for (unsigned j = 0; j < 256; j++)
+ for (unsigned i = 0; i < size; i += 2)
+ {
+ unsigned n1 = (Byte)g_CrcTable[(psw[i] - j) & 0xFF];
+ unsigned n2 = (Byte)g_CrcTable[(psw[(size_t)i + 1] + j) & 0xFF];
+ for (unsigned k = 1; (n1 & 0xFF) != n2; n1++, k++)
+ Swap(SubstTable[n1 & 0xFF], SubstTable[(n1 + i + k) & 0xFF]);
+ }
+
+ for (unsigned i = 0; i < size; i += 16)
+ EncryptBlock(psw + i);
+}
+
+void CData::CryptBlock(Byte *buf, bool encrypt)
+{
+ Byte inBuf[16];
+ UInt32 A, B, C, D;
+
+ A = GetUi32(buf + 0) ^ Keys[0];
+ B = GetUi32(buf + 4) ^ Keys[1];
+ C = GetUi32(buf + 8) ^ Keys[2];
+ D = GetUi32(buf + 12) ^ Keys[3];
+
+ if (!encrypt)
+ memcpy(inBuf, buf, sizeof(inBuf));
+
+ for (unsigned i = 0; i < kNumRounds; i++)
+ {
+ UInt32 key = Keys[(encrypt ? i : (kNumRounds - 1 - i)) & 3];
+ UInt32 TA = A ^ SubstLong((C + rotlFixed(D, 11)) ^ key);
+ UInt32 TB = B ^ SubstLong((D ^ rotlFixed(C, 17)) + key);
+ A = C; C = TA;
+ B = D; D = TB;
+ }
+
+ SetUi32(buf + 0, C ^ Keys[0])
+ SetUi32(buf + 4, D ^ Keys[1])
+ SetUi32(buf + 8, A ^ Keys[2])
+ SetUi32(buf + 12, B ^ Keys[3])
+
+ UpdateKeys(encrypt ? buf : inBuf);
+}
+
+Z7_COM7F_IMF(CDecoder::Init())
+{
+ return S_OK;
+}
+
+static const UInt32 kBlockSize = 16;
+
+Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+{
+ if (size == 0)
+ return 0;
+ if (size < kBlockSize)
+ return kBlockSize;
+ size -= kBlockSize;
+ UInt32 i;
+ for (i = 0; i <= size; i += kBlockSize)
+ DecryptBlock(data + i);
+ return i;
+}
+
+}}
diff --git a/CPP/7zip/Crypto/Rar20Crypto.h b/CPP/7zip/Crypto/Rar20Crypto.h
new file mode 100644
index 0000000..8550718
--- /dev/null
+++ b/CPP/7zip/Crypto/Rar20Crypto.h
@@ -0,0 +1,54 @@
+// Crypto/Rar20Crypto.h
+
+#ifndef ZIP7_INC_CRYPTO_RAR20_CRYPTO_H
+#define ZIP7_INC_CRYPTO_RAR20_CRYPTO_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCrypto {
+namespace NRar2 {
+
+/* ICompressFilter::Init() does nothing for this filter.
+ Call SetPassword() to initialize filter. */
+
+class CData
+{
+ Byte SubstTable[256];
+ UInt32 Keys[4];
+
+ UInt32 SubstLong(UInt32 t) const
+ {
+ return (UInt32)SubstTable[(unsigned)t & 255]
+ | ((UInt32)SubstTable[(unsigned)(t >> 8) & 255] << 8)
+ | ((UInt32)SubstTable[(unsigned)(t >> 16) & 255] << 16)
+ | ((UInt32)SubstTable[(unsigned)(t >> 24) ] << 24);
+ }
+ void UpdateKeys(const Byte *data);
+ void CryptBlock(Byte *buf, bool encrypt);
+public:
+ ~CData() { Wipe(); }
+ void Wipe()
+ {
+ Z7_memset_0_ARRAY(SubstTable);
+ Z7_memset_0_ARRAY(Keys);
+ }
+
+ void EncryptBlock(Byte *buf) { CryptBlock(buf, true); }
+ void DecryptBlock(Byte *buf) { CryptBlock(buf, false); }
+ void SetPassword(const Byte *password, unsigned passwordLen);
+};
+
+class CDecoder Z7_final:
+ public ICompressFilter,
+ public CMyUnknownImp,
+ public CData
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(ICompressFilter)
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/Rar5Aes.cpp b/CPP/7zip/Crypto/Rar5Aes.cpp
new file mode 100644
index 0000000..26c6100
--- /dev/null
+++ b/CPP/7zip/Crypto/Rar5Aes.cpp
@@ -0,0 +1,265 @@
+// Crypto/Rar5Aes.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#ifndef Z7_ST
+#include "../../Windows/Synchronization.h"
+#endif
+
+#include "Rar5Aes.h"
+#include "HmacSha256.h"
+
+namespace NCrypto {
+namespace NRar5 {
+
+static const unsigned kNumIterationsLog_Max = 24;
+
+static const unsigned kPswCheckCsumSize = 4;
+static const unsigned kCheckSize = kPswCheckSize + kPswCheckCsumSize;
+
+CKey::CKey():
+ _needCalc(true),
+ _numIterationsLog(0)
+{
+ for (unsigned i = 0; i < sizeof(_salt); i++)
+ _salt[i] = 0;
+}
+
+CDecoder::CDecoder(): CAesCbcDecoder(kAesKeySize) {}
+
+static unsigned ReadVarInt(const Byte *p, unsigned maxSize, UInt64 *val)
+{
+ *val = 0;
+
+ for (unsigned i = 0; i < maxSize && i < 10;)
+ {
+ Byte b = p[i];
+ *val |= (UInt64)(b & 0x7F) << (7 * i);
+ i++;
+ if ((b & 0x80) == 0)
+ return i;
+ }
+ return 0;
+}
+
+HRESULT CDecoder::SetDecoderProps(const Byte *p, unsigned size, bool includeIV, bool isService)
+{
+ UInt64 Version;
+
+ unsigned num = ReadVarInt(p, size, &Version);
+ if (num == 0)
+ return E_NOTIMPL;
+ p += num;
+ size -= num;
+
+ if (Version != 0)
+ return E_NOTIMPL;
+
+ num = ReadVarInt(p, size, &Flags);
+ if (num == 0)
+ return E_NOTIMPL;
+ p += num;
+ size -= num;
+
+ bool isCheck = IsThereCheck();
+ if (size != 1 + kSaltSize + (includeIV ? AES_BLOCK_SIZE : 0) + (unsigned)(isCheck ? kCheckSize : 0))
+ return E_NOTIMPL;
+
+ if (_numIterationsLog != p[0])
+ {
+ _numIterationsLog = p[0];
+ _needCalc = true;
+ }
+
+ p++;
+
+ if (memcmp(_salt, p, kSaltSize) != 0)
+ {
+ memcpy(_salt, p, kSaltSize);
+ _needCalc = true;
+ }
+
+ p += kSaltSize;
+
+ if (includeIV)
+ {
+ memcpy(_iv, p, AES_BLOCK_SIZE);
+ p += AES_BLOCK_SIZE;
+ }
+
+ _canCheck = true;
+
+ if (isCheck)
+ {
+ memcpy(_check, p, kPswCheckSize);
+ CSha256 sha;
+ Byte digest[SHA256_DIGEST_SIZE];
+ Sha256_Init(&sha);
+ Sha256_Update(&sha, _check, kPswCheckSize);
+ Sha256_Final(&sha, digest);
+ _canCheck = (memcmp(digest, p + kPswCheckSize, kPswCheckCsumSize) == 0);
+ if (_canCheck && isService)
+ {
+ // There was bug in RAR 5.21- : PswCheck field in service records ("QO") contained zeros.
+ // so we disable password checking for such bad records.
+ _canCheck = false;
+ for (unsigned i = 0; i < kPswCheckSize; i++)
+ if (p[i] != 0)
+ {
+ _canCheck = true;
+ break;
+ }
+ }
+ }
+
+ return (_numIterationsLog <= kNumIterationsLog_Max ? S_OK : E_NOTIMPL);
+}
+
+
+void CDecoder::SetPassword(const Byte *data, size_t size)
+{
+ if (size != _password.Size() || memcmp(data, _password, size) != 0)
+ {
+ _needCalc = true;
+ _password.Wipe();
+ _password.CopyFrom(data, size);
+ }
+}
+
+
+Z7_COM7F_IMF(CDecoder::Init())
+{
+ CalcKey_and_CheckPassword();
+ RINOK(SetKey(_key, kAesKeySize))
+ RINOK(SetInitVector(_iv, AES_BLOCK_SIZE))
+ return CAesCoder::Init();
+}
+
+
+UInt32 CDecoder::Hmac_Convert_Crc32(UInt32 crc) const
+{
+ MY_ALIGN (16)
+ NSha256::CHmac ctx;
+ ctx.SetKey(_hashKey, NSha256::kDigestSize);
+ UInt32 v;
+ SetUi32(&v, crc)
+ ctx.Update((const Byte *)&v, 4);
+ MY_ALIGN (16)
+ UInt32 h[SHA256_NUM_DIGEST_WORDS];
+ ctx.Final((Byte *)h);
+ crc = 0;
+ for (unsigned i = 0; i < SHA256_NUM_DIGEST_WORDS; i++)
+ crc ^= (UInt32)GetUi32(h + i);
+ return crc;
+}
+
+
+void CDecoder::Hmac_Convert_32Bytes(Byte *data) const
+{
+ MY_ALIGN (16)
+ NSha256::CHmac ctx;
+ ctx.SetKey(_hashKey, NSha256::kDigestSize);
+ ctx.Update(data, NSha256::kDigestSize);
+ ctx.Final(data);
+}
+
+
+static CKey g_Key;
+
+#ifndef Z7_ST
+ static NWindows::NSynchronization::CCriticalSection g_GlobalKeyCacheCriticalSection;
+ #define MT_LOCK NWindows::NSynchronization::CCriticalSectionLock lock(g_GlobalKeyCacheCriticalSection);
+#else
+ #define MT_LOCK
+#endif
+
+bool CDecoder::CalcKey_and_CheckPassword()
+{
+ if (_needCalc)
+ {
+ {
+ MT_LOCK
+ if (!g_Key._needCalc && IsKeyEqualTo(g_Key))
+ {
+ CopyCalcedKeysFrom(g_Key);
+ _needCalc = false;
+ }
+ }
+
+ if (_needCalc)
+ {
+ Byte pswCheck[SHA256_DIGEST_SIZE];
+
+ {
+ // Pbkdf HMAC-SHA-256
+
+ MY_ALIGN (16)
+ NSha256::CHmac baseCtx;
+ baseCtx.SetKey(_password, _password.Size());
+
+ NSha256::CHmac ctx = baseCtx;
+ ctx.Update(_salt, sizeof(_salt));
+
+ MY_ALIGN (16)
+ Byte u[NSha256::kDigestSize];
+ MY_ALIGN (16)
+ Byte key[NSha256::kDigestSize];
+
+ u[0] = 0;
+ u[1] = 0;
+ u[2] = 0;
+ u[3] = 1;
+
+ ctx.Update(u, 4);
+ ctx.Final(u);
+
+ memcpy(key, u, NSha256::kDigestSize);
+
+ UInt32 numIterations = ((UInt32)1 << _numIterationsLog) - 1;
+
+ for (unsigned i = 0; i < 3; i++)
+ {
+ UInt32 j = numIterations;
+
+ for (; j != 0; j--)
+ {
+ ctx = baseCtx;
+ ctx.Update(u, NSha256::kDigestSize);
+ ctx.Final(u);
+ for (unsigned s = 0; s < NSha256::kDigestSize; s++)
+ key[s] ^= u[s];
+ }
+
+ // RAR uses additional iterations for additional keys
+ memcpy((i == 0 ? _key : (i == 1 ? _hashKey : pswCheck)), key, NSha256::kDigestSize);
+ numIterations = 16;
+ }
+ }
+
+ {
+ unsigned i;
+
+ for (i = 0; i < kPswCheckSize; i++)
+ _check_Calced[i] = pswCheck[i];
+
+ for (i = kPswCheckSize; i < SHA256_DIGEST_SIZE; i++)
+ _check_Calced[i & (kPswCheckSize - 1)] ^= pswCheck[i];
+ }
+
+ _needCalc = false;
+
+ {
+ MT_LOCK
+ g_Key = *this;
+ }
+ }
+ }
+
+ if (IsThereCheck() && _canCheck)
+ return (memcmp(_check_Calced, _check, kPswCheckSize) == 0);
+ return true;
+}
+
+}}
diff --git a/CPP/7zip/Crypto/Rar5Aes.h b/CPP/7zip/Crypto/Rar5Aes.h
new file mode 100644
index 0000000..3cd7992
--- /dev/null
+++ b/CPP/7zip/Crypto/Rar5Aes.h
@@ -0,0 +1,98 @@
+// Crypto/Rar5Aes.h
+
+#ifndef ZIP7_INC_CRYPTO_RAR5_AES_H
+#define ZIP7_INC_CRYPTO_RAR5_AES_H
+
+#include "../../../C/Sha256.h"
+
+#include "../../Common/MyBuffer.h"
+
+#include "MyAes.h"
+
+namespace NCrypto {
+namespace NRar5 {
+
+const unsigned kSaltSize = 16;
+const unsigned kPswCheckSize = 8;
+const unsigned kAesKeySize = 32;
+
+namespace NCryptoFlags
+{
+ const unsigned kPswCheck = 1 << 0;
+ const unsigned kUseMAC = 1 << 1;
+}
+
+struct CKey
+{
+ bool _needCalc;
+
+ unsigned _numIterationsLog;
+ Byte _salt[kSaltSize];
+ CByteBuffer _password;
+
+ Byte _key[kAesKeySize];
+ Byte _check_Calced[kPswCheckSize];
+ Byte _hashKey[SHA256_DIGEST_SIZE];
+
+ void CopyCalcedKeysFrom(const CKey &k)
+ {
+ memcpy(_key, k._key, sizeof(_key));
+ memcpy(_check_Calced, k._check_Calced, sizeof(_check_Calced));
+ memcpy(_hashKey, k._hashKey, sizeof(_hashKey));
+ }
+
+ bool IsKeyEqualTo(const CKey &key)
+ {
+ return (_numIterationsLog == key._numIterationsLog
+ && memcmp(_salt, key._salt, sizeof(_salt)) == 0
+ && _password == key._password);
+ }
+
+ CKey();
+
+ void Wipe()
+ {
+ _password.Wipe();
+ Z7_memset_0_ARRAY(_salt);
+ Z7_memset_0_ARRAY(_key);
+ Z7_memset_0_ARRAY(_check_Calced);
+ Z7_memset_0_ARRAY(_hashKey);
+ }
+
+#ifdef Z7_CPP_IS_SUPPORTED_default
+ // CKey(const CKey &) = default;
+ CKey& operator =(const CKey &) = default;
+#endif
+ ~CKey() { Wipe(); }
+};
+
+
+class CDecoder Z7_final:
+ public CAesCbcDecoder,
+ public CKey
+{
+ Byte _check[kPswCheckSize];
+ bool _canCheck;
+ UInt64 Flags;
+
+ bool IsThereCheck() const { return ((Flags & NCryptoFlags::kPswCheck) != 0); }
+public:
+ Byte _iv[AES_BLOCK_SIZE];
+
+ CDecoder();
+
+ Z7_COM7F_IMP(Init())
+
+ void SetPassword(const Byte *data, size_t size);
+ HRESULT SetDecoderProps(const Byte *data, unsigned size, bool includeIV, bool isService);
+
+ bool CalcKey_and_CheckPassword();
+
+ bool UseMAC() const { return (Flags & NCryptoFlags::kUseMAC) != 0; }
+ UInt32 Hmac_Convert_Crc32(UInt32 crc) const;
+ void Hmac_Convert_32Bytes(Byte *data) const;
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/RarAes.cpp b/CPP/7zip/Crypto/RarAes.cpp
new file mode 100644
index 0000000..878ea3a
--- /dev/null
+++ b/CPP/7zip/Crypto/RarAes.cpp
@@ -0,0 +1,194 @@
+// Crypto/RarAes.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/RotateDefs.h"
+
+#include "RarAes.h"
+#include "Sha1Cls.h"
+
+namespace NCrypto {
+namespace NRar3 {
+
+CDecoder::CDecoder():
+ CAesCbcDecoder(kAesKeySize),
+ _thereIsSalt(false),
+ _needCalc(true)
+ // _rar350Mode(false)
+{
+ for (unsigned i = 0; i < sizeof(_salt); i++)
+ _salt[i] = 0;
+}
+
+HRESULT CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
+{
+ bool prev = _thereIsSalt;
+ _thereIsSalt = false;
+ if (size == 0)
+ {
+ if (!_needCalc && prev)
+ _needCalc = true;
+ return S_OK;
+ }
+ if (size < 8)
+ return E_INVALIDARG;
+ _thereIsSalt = true;
+ bool same = false;
+ if (_thereIsSalt == prev)
+ {
+ same = true;
+ if (_thereIsSalt)
+ {
+ for (unsigned i = 0; i < sizeof(_salt); i++)
+ if (_salt[i] != data[i])
+ {
+ same = false;
+ break;
+ }
+ }
+ }
+ for (unsigned i = 0; i < sizeof(_salt); i++)
+ _salt[i] = data[i];
+ if (!_needCalc && !same)
+ _needCalc = true;
+ return S_OK;
+}
+
+static const unsigned kPasswordLen_Bytes_MAX = 127 * 2;
+
+void CDecoder::SetPassword(const Byte *data, unsigned size)
+{
+ if (size > kPasswordLen_Bytes_MAX)
+ size = kPasswordLen_Bytes_MAX;
+ bool same = false;
+ if (size == _password.Size())
+ {
+ same = true;
+ for (UInt32 i = 0; i < size; i++)
+ if (data[i] != _password[i])
+ {
+ same = false;
+ break;
+ }
+ }
+ if (!_needCalc && !same)
+ _needCalc = true;
+ _password.Wipe();
+ _password.CopyFrom(data, (size_t)size);
+}
+
+Z7_COM7F_IMF(CDecoder::Init())
+{
+ CalcKey();
+ RINOK(SetKey(_key, kAesKeySize))
+ RINOK(SetInitVector(_iv, AES_BLOCK_SIZE))
+ return CAesCoder::Init();
+}
+
+
+// if (password_size_in_bytes + SaltSize > 64),
+// the original rar code updates password_with_salt buffer
+// with some generated data from SHA1 code.
+
+// #define RAR_SHA1_REDUCE
+
+#ifdef RAR_SHA1_REDUCE
+ #define kNumW 16
+ #define WW(i) W[(i)&15]
+#else
+ #define kNumW 80
+ #define WW(i) W[i]
+#endif
+
+static void UpdatePswDataSha1(Byte *data)
+{
+ UInt32 W[kNumW];
+ size_t i;
+
+ for (i = 0; i < SHA1_NUM_BLOCK_WORDS; i++)
+ W[i] = GetBe32(data + i * 4);
+
+ for (i = 16; i < 80; i++)
+ {
+ WW(i) = rotlFixed(WW((i)-3) ^ WW((i)-8) ^ WW((i)-14) ^ WW((i)-16), 1);
+ }
+
+ for (i = 0; i < SHA1_NUM_BLOCK_WORDS; i++)
+ {
+ SetUi32(data + i * 4, W[kNumW - SHA1_NUM_BLOCK_WORDS + i])
+ }
+}
+
+
+void CDecoder::CalcKey()
+{
+ if (!_needCalc)
+ return;
+
+ const unsigned kSaltSize = 8;
+
+ Byte buf[kPasswordLen_Bytes_MAX + kSaltSize];
+
+ if (_password.Size() != 0)
+ memcpy(buf, _password, _password.Size());
+
+ size_t rawSize = _password.Size();
+
+ if (_thereIsSalt)
+ {
+ memcpy(buf + rawSize, _salt, kSaltSize);
+ rawSize += kSaltSize;
+ }
+
+ MY_ALIGN (16)
+ NSha1::CContext sha;
+ sha.Init();
+
+ MY_ALIGN (16)
+ Byte digest[NSha1::kDigestSize];
+ // rar reverts hash for sha.
+ const UInt32 kNumRounds = ((UInt32)1 << 18);
+ UInt32 pos = 0;
+ UInt32 i;
+ for (i = 0; i < kNumRounds; i++)
+ {
+ sha.Update(buf, rawSize);
+ // if (_rar350Mode)
+ {
+ const UInt32 kBlockSize = 64;
+ const UInt32 endPos = (pos + (UInt32)rawSize) & ~(kBlockSize - 1);
+ if (endPos > pos + kBlockSize)
+ {
+ UInt32 curPos = pos & ~(kBlockSize - 1);
+ curPos += kBlockSize;
+ do
+ {
+ UpdatePswDataSha1(buf + (curPos - pos));
+ curPos += kBlockSize;
+ }
+ while (curPos != endPos);
+ }
+ }
+ pos += (UInt32)rawSize;
+ Byte pswNum[3] = { (Byte)i, (Byte)(i >> 8), (Byte)(i >> 16) };
+ sha.Update(pswNum, 3);
+ pos += 3;
+ if (i % (kNumRounds / 16) == 0)
+ {
+ MY_ALIGN (16)
+ NSha1::CContext shaTemp = sha;
+ shaTemp.Final(digest);
+ _iv[i / (kNumRounds / 16)] = (Byte)digest[4 * 4 + 3];
+ }
+ }
+
+ sha.Final(digest);
+ for (i = 0; i < 4; i++)
+ for (unsigned j = 0; j < 4; j++)
+ _key[i * 4 + j] = (digest[i * 4 + 3 - j]);
+
+ _needCalc = false;
+}
+
+}}
diff --git a/CPP/7zip/Crypto/RarAes.h b/CPP/7zip/Crypto/RarAes.h
new file mode 100644
index 0000000..d3c104c
--- /dev/null
+++ b/CPP/7zip/Crypto/RarAes.h
@@ -0,0 +1,54 @@
+// Crypto/RarAes.h
+
+#ifndef ZIP7_INC_CRYPTO_RAR_AES_H
+#define ZIP7_INC_CRYPTO_RAR_AES_H
+
+#include "../../../C/Aes.h"
+
+#include "../../Common/MyBuffer.h"
+
+#include "../IPassword.h"
+
+#include "MyAes.h"
+
+namespace NCrypto {
+namespace NRar3 {
+
+const unsigned kAesKeySize = 16;
+
+class CDecoder Z7_final:
+ public CAesCbcDecoder
+{
+ Byte _salt[8];
+ bool _thereIsSalt;
+ bool _needCalc;
+ // bool _rar350Mode;
+
+ CByteBuffer _password;
+
+ Byte _key[kAesKeySize];
+ Byte _iv[AES_BLOCK_SIZE];
+
+ void CalcKey();
+public:
+ Z7_COM7F_IMP(Init())
+
+ void SetPassword(const Byte *data, unsigned size);
+ HRESULT SetDecoderProperties2(const Byte *data, UInt32 size);
+
+ CDecoder();
+
+ ~CDecoder() Z7_DESTRUCTOR_override { Wipe(); }
+ void Wipe()
+ {
+ _password.Wipe();
+ Z7_memset_0_ARRAY(_salt);
+ Z7_memset_0_ARRAY(_key);
+ Z7_memset_0_ARRAY(_iv);
+ }
+ // void SetRar350Mode(bool rar350Mode) { _rar350Mode = rar350Mode; }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/Sha1Cls.h b/CPP/7zip/Crypto/Sha1Cls.h
new file mode 100644
index 0000000..56ae040
--- /dev/null
+++ b/CPP/7zip/Crypto/Sha1Cls.h
@@ -0,0 +1,37 @@
+// Crypto/Sha1Cls.h
+
+#ifndef ZIP7_INC_CRYPTO_SHA1_CLS_H
+#define ZIP7_INC_CRYPTO_SHA1_CLS_H
+
+#include "../../../C/Sha1.h"
+
+namespace NCrypto {
+namespace NSha1 {
+
+const unsigned kNumBlockWords = SHA1_NUM_BLOCK_WORDS;
+const unsigned kNumDigestWords = SHA1_NUM_DIGEST_WORDS;
+
+const unsigned kBlockSize = SHA1_BLOCK_SIZE;
+const unsigned kDigestSize = SHA1_DIGEST_SIZE;
+
+class CContext
+{
+ CSha1 _s;
+
+public:
+ void Init() throw() { Sha1_Init(&_s); }
+ void Update(const Byte *data, size_t size) throw() { Sha1_Update(&_s, data, size); }
+ void Final(Byte *digest) throw() { Sha1_Final(&_s, digest); }
+ void PrepareBlock(Byte *block, unsigned size) const throw()
+ {
+ Sha1_PrepareBlock(&_s, block, size);
+ }
+ void GetBlockDigest(const Byte *blockData, Byte *destDigest) const throw()
+ {
+ Sha1_GetBlockDigest(&_s, blockData, destDigest);
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/StdAfx.h b/CPP/7zip/Crypto/StdAfx.h
index 42a088f..8086655 100644
--- a/CPP/7zip/Crypto/StdAfx.h
+++ b/CPP/7zip/Crypto/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/Crypto/WzAes.cpp b/CPP/7zip/Crypto/WzAes.cpp
new file mode 100644
index 0000000..3f2adab
--- /dev/null
+++ b/CPP/7zip/Crypto/WzAes.cpp
@@ -0,0 +1,231 @@
+// Crypto/WzAes.cpp
+/*
+This code implements Brian Gladman's scheme
+specified in "A Password Based File Encryption Utility".
+
+Note: you must include MyAes.cpp to project to initialize AES tables
+*/
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "Pbkdf2HmacSha1.h"
+#include "RandGen.h"
+#include "WzAes.h"
+
+namespace NCrypto {
+namespace NWzAes {
+
+const unsigned kAesKeySizeMax = 32;
+
+static const UInt32 kNumKeyGenIterations = 1000;
+
+Z7_COM7F_IMF(CBaseCoder::CryptoSetPassword(const Byte *data, UInt32 size))
+{
+ if (size > kPasswordSizeMax)
+ return E_INVALIDARG;
+ _key.Password.Wipe();
+ _key.Password.CopyFrom(data, (size_t)size);
+ return S_OK;
+}
+
+void CBaseCoder::Init2()
+{
+ _hmacOverCalc = 0;
+ const unsigned dkSizeMax32 = (2 * kAesKeySizeMax + kPwdVerifSize + 3) / 4;
+ Byte dk[dkSizeMax32 * 4];
+
+ const unsigned keySize = _key.GetKeySize();
+ const unsigned dkSize = 2 * keySize + ((kPwdVerifSize + 3) & ~(unsigned)3);
+
+ // for (unsigned ii = 0; ii < 1000; ii++)
+ {
+ NSha1::Pbkdf2Hmac(
+ _key.Password, _key.Password.Size(),
+ _key.Salt, _key.GetSaltSize(),
+ kNumKeyGenIterations,
+ dk, dkSize);
+ }
+
+ Hmac()->SetKey(dk + keySize, keySize);
+ memcpy(_key.PwdVerifComputed, dk + 2 * keySize, kPwdVerifSize);
+
+ // Aes_SetKey_Enc(_aes.Aes() + 8, dk, keySize);
+ // AesCtr2_Init(&_aes);
+ _aesCoderSpec->SetKeySize(keySize);
+ if (_aesCoderSpec->SetKey(dk, keySize) != S_OK) throw 2;
+ if (_aesCoderSpec->Init() != S_OK) throw 3;
+}
+
+Z7_COM7F_IMF(CBaseCoder::Init())
+{
+ return S_OK;
+}
+
+HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream)
+{
+ unsigned saltSize = _key.GetSaltSize();
+ MY_RAND_GEN(_key.Salt, saltSize);
+ Init2();
+ RINOK(WriteStream(outStream, _key.Salt, saltSize))
+ return WriteStream(outStream, _key.PwdVerifComputed, kPwdVerifSize);
+}
+
+HRESULT CEncoder::WriteFooter(ISequentialOutStream *outStream)
+{
+ MY_ALIGN (16)
+ UInt32 mac[NSha1::kNumDigestWords];
+ Hmac()->Final((Byte *)mac);
+ return WriteStream(outStream, mac, kMacSize);
+}
+
+/*
+Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size))
+{
+ if (size != 1)
+ return E_INVALIDARG;
+ _key.Init();
+ return SetKeyMode(data[0]) ? S_OK : E_INVALIDARG;
+}
+*/
+
+HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream)
+{
+ const unsigned saltSize = _key.GetSaltSize();
+ const unsigned extraSize = saltSize + kPwdVerifSize;
+ Byte temp[kSaltSizeMax + kPwdVerifSize];
+ RINOK(ReadStream_FAIL(inStream, temp, extraSize))
+ unsigned i;
+ for (i = 0; i < saltSize; i++)
+ _key.Salt[i] = temp[i];
+ for (i = 0; i < kPwdVerifSize; i++)
+ _pwdVerifFromArchive[i] = temp[saltSize + i];
+ return S_OK;
+}
+
+static inline bool CompareArrays(const Byte *p1, const Byte *p2, unsigned size)
+{
+ for (unsigned i = 0; i < size; i++)
+ if (p1[i] != p2[i])
+ return false;
+ return true;
+}
+
+bool CDecoder::Init_and_CheckPassword()
+{
+ Init2();
+ return CompareArrays(_key.PwdVerifComputed, _pwdVerifFromArchive, kPwdVerifSize);
+}
+
+HRESULT CDecoder::CheckMac(ISequentialInStream *inStream, bool &isOK)
+{
+ isOK = false;
+ MY_ALIGN (16)
+ Byte mac1[kMacSize];
+ RINOK(ReadStream_FAIL(inStream, mac1, kMacSize))
+ MY_ALIGN (16)
+ UInt32 mac2[NSha1::kNumDigestWords];
+ Hmac()->Final((Byte *)mac2);
+ isOK = CompareArrays(mac1, (const Byte *)mac2, kMacSize);
+ if (_hmacOverCalc)
+ isOK = false;
+ return S_OK;
+}
+
+/*
+
+CAesCtr2::CAesCtr2():
+ aes((4 + AES_NUM_IVMRK_WORDS) * 4)
+{
+ // offset = ((0 - (unsigned)(ptrdiff_t)aes) & 0xF) / sizeof(UInt32);
+ // first 16 bytes are buffer for last block data.
+ // so the ivAES is aligned for (Align + 16).
+}
+
+void AesCtr2_Init(CAesCtr2 *p)
+{
+ UInt32 *ctr = p->Aes() + 4;
+ unsigned i;
+ for (i = 0; i < 4; i++)
+ ctr[i] = 0;
+ p->pos = AES_BLOCK_SIZE;
+}
+
+// (size != 16 * N) is allowed only for last call
+
+void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size)
+{
+ unsigned pos = p->pos;
+ UInt32 *buf32 = p->Aes();
+ if (size == 0)
+ return;
+
+ if (pos != AES_BLOCK_SIZE)
+ {
+ const Byte *buf = (const Byte *)buf32;
+ do
+ *data++ ^= buf[pos++];
+ while (--size != 0 && pos != AES_BLOCK_SIZE);
+ }
+
+ // (size == 0 || pos == AES_BLOCK_SIZE)
+
+ if (size >= 16)
+ {
+ SizeT size2 = size >> 4;
+ g_AesCtr_Code(buf32 + 4, data, size2);
+ size2 <<= 4;
+ data += size2;
+ size -= size2;
+ // (pos == AES_BLOCK_SIZE)
+ }
+
+ // (size < 16)
+
+ if (size != 0)
+ {
+ unsigned j;
+ const Byte *buf;
+ for (j = 0; j < 4; j++)
+ buf32[j] = 0;
+ g_AesCtr_Code(buf32 + 4, (Byte *)buf32, 1);
+ buf = (const Byte *)buf32;
+ pos = 0;
+ do
+ *data++ ^= buf[pos++];
+ while (--size != 0);
+ }
+
+ p->pos = pos;
+}
+*/
+
+/* (size != 16 * N) is allowed only for last Filter() call */
+
+Z7_COM7F_IMF2(UInt32, CEncoder::Filter(Byte *data, UInt32 size))
+{
+ // AesCtr2_Code(&_aes, data, size);
+ size = _aesCoder->Filter(data, size);
+ Hmac()->Update(data, size);
+ return size;
+}
+
+Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+{
+ if (size >= 16)
+ size &= ~(UInt32)15;
+ if (_hmacOverCalc < size)
+ {
+ Hmac()->Update(data + _hmacOverCalc, size - _hmacOverCalc);
+ _hmacOverCalc = size;
+ }
+ // AesCtr2_Code(&_aes, data, size);
+ size = _aesCoder->Filter(data, size);
+ _hmacOverCalc -= size;
+ return size;
+}
+
+}}
diff --git a/CPP/7zip/Crypto/WzAes.h b/CPP/7zip/Crypto/WzAes.h
new file mode 100644
index 0000000..113ec81
--- /dev/null
+++ b/CPP/7zip/Crypto/WzAes.h
@@ -0,0 +1,161 @@
+// Crypto/WzAes.h
+/*
+This code implements Brian Gladman's scheme
+specified in "A Password Based File Encryption Utility":
+ - AES encryption (128,192,256-bit) in Counter (CTR) mode.
+ - HMAC-SHA1 authentication for encrypted data (10 bytes)
+ - Keys are derived by PPKDF2(RFC2898)-HMAC-SHA1 from ASCII password and
+ Salt (saltSize = aesKeySize / 2).
+ - 2 bytes contain Password Verifier's Code
+*/
+
+#ifndef ZIP7_INC_CRYPTO_WZ_AES_H
+#define ZIP7_INC_CRYPTO_WZ_AES_H
+
+#include "../../Common/MyBuffer.h"
+
+#include "../IPassword.h"
+
+#include "HmacSha1.h"
+#include "MyAes.h"
+
+namespace NCrypto {
+namespace NWzAes {
+
+/* ICompressFilter::Init() does nothing for this filter.
+
+ Call to init:
+ Encoder:
+ CryptoSetPassword();
+ WriteHeader();
+ Decoder:
+ [CryptoSetPassword();]
+ ReadHeader();
+ [CryptoSetPassword();] Init_and_CheckPassword();
+ [CryptoSetPassword();] Init_and_CheckPassword();
+*/
+
+const UInt32 kPasswordSizeMax = 99; // 128;
+
+const unsigned kSaltSizeMax = 16;
+const unsigned kPwdVerifSize = 2;
+const unsigned kMacSize = 10;
+
+enum EKeySizeMode
+{
+ kKeySizeMode_AES128 = 1,
+ kKeySizeMode_AES192 = 2,
+ kKeySizeMode_AES256 = 3
+};
+
+struct CKeyInfo
+{
+ EKeySizeMode KeySizeMode;
+ Byte Salt[kSaltSizeMax];
+ Byte PwdVerifComputed[kPwdVerifSize];
+
+ CByteBuffer Password;
+
+ unsigned GetKeySize() const { return (8 * KeySizeMode + 8); }
+ unsigned GetSaltSize() const { return (4 * KeySizeMode + 4); }
+ unsigned GetNumSaltWords() const { return (KeySizeMode + 1); }
+
+ CKeyInfo(): KeySizeMode(kKeySizeMode_AES256) {}
+
+ void Wipe()
+ {
+ Password.Wipe();
+ Z7_memset_0_ARRAY(Salt);
+ Z7_memset_0_ARRAY(PwdVerifComputed);
+ }
+
+ ~CKeyInfo() { Wipe(); }
+};
+
+/*
+struct CAesCtr2
+{
+ unsigned pos;
+ CAlignedBuffer aes;
+ UInt32 *Aes() { return (UInt32 *)(Byte *)aes; }
+
+ // unsigned offset;
+ // UInt32 aes[4 + AES_NUM_IVMRK_WORDS + 3];
+ // UInt32 *Aes() { return aes + offset; }
+ CAesCtr2();
+};
+
+void AesCtr2_Init(CAesCtr2 *p);
+void AesCtr2_Code(CAesCtr2 *p, Byte *data, SizeT size);
+*/
+
+class CBaseCoder:
+ public ICompressFilter,
+ public ICryptoSetPassword,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1(ICryptoSetPassword)
+ Z7_COM7F_IMP(Init())
+public:
+ Z7_IFACE_COM7_IMP(ICryptoSetPassword)
+protected:
+ CKeyInfo _key;
+
+ // NSha1::CHmac _hmac;
+ // NSha1::CHmac *Hmac() { return &_hmac; }
+ CAlignedBuffer1 _hmacBuf;
+ UInt32 _hmacOverCalc;
+
+ NSha1::CHmac *Hmac() { return (NSha1::CHmac *)(void *)(Byte *)_hmacBuf; }
+
+ // CAesCtr2 _aes;
+ CAesCoder *_aesCoderSpec;
+ CMyComPtr<ICompressFilter> _aesCoder;
+ CBaseCoder():
+ _hmacBuf(sizeof(NSha1::CHmac))
+ {
+ _aesCoderSpec = new CAesCtrCoder(32);
+ _aesCoder = _aesCoderSpec;
+ }
+
+ void Init2();
+public:
+ unsigned GetHeaderSize() const { return _key.GetSaltSize() + kPwdVerifSize; }
+ unsigned GetAddPackSize() const { return GetHeaderSize() + kMacSize; }
+
+ bool SetKeyMode(unsigned mode)
+ {
+ if (mode < kKeySizeMode_AES128 || mode > kKeySizeMode_AES256)
+ return false;
+ _key.KeySizeMode = (EKeySizeMode)mode;
+ return true;
+ }
+
+ virtual ~CBaseCoder() {}
+};
+
+class CEncoder Z7_final:
+ public CBaseCoder
+{
+ Z7_COM7F_IMP2(UInt32, Filter(Byte *data, UInt32 size))
+public:
+ HRESULT WriteHeader(ISequentialOutStream *outStream);
+ HRESULT WriteFooter(ISequentialOutStream *outStream);
+};
+
+class CDecoder Z7_final:
+ public CBaseCoder
+ // public ICompressSetDecoderProperties2
+{
+ Byte _pwdVerifFromArchive[kPwdVerifSize];
+ Z7_COM7F_IMP2(UInt32, Filter(Byte *data, UInt32 size))
+public:
+ // Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+ HRESULT ReadHeader(ISequentialInStream *inStream);
+ bool Init_and_CheckPassword();
+ HRESULT CheckMac(ISequentialInStream *inStream, bool &isOK);
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/ZipCrypto.cpp b/CPP/7zip/Crypto/ZipCrypto.cpp
new file mode 100644
index 0000000..047e2bd
--- /dev/null
+++ b/CPP/7zip/Crypto/ZipCrypto.cpp
@@ -0,0 +1,114 @@
+// Crypto/ZipCrypto.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "RandGen.h"
+#include "ZipCrypto.h"
+
+namespace NCrypto {
+namespace NZip {
+
+#define UPDATE_KEYS(b) { \
+ key0 = CRC_UPDATE_BYTE(key0, b); \
+ key1 = (key1 + (key0 & 0xFF)) * 0x8088405 + 1; \
+ key2 = CRC_UPDATE_BYTE(key2, (Byte)(key1 >> 24)); } \
+
+#define DECRYPT_BYTE_1 UInt32 temp = key2 | 2;
+#define DECRYPT_BYTE_2 ((Byte)((temp * (temp ^ 1)) >> 8))
+
+Z7_COM7F_IMF(CCipher::CryptoSetPassword(const Byte *data, UInt32 size))
+{
+ UInt32 key0 = 0x12345678;
+ UInt32 key1 = 0x23456789;
+ UInt32 key2 = 0x34567890;
+
+ for (UInt32 i = 0; i < size; i++)
+ UPDATE_KEYS(data[i])
+
+ KeyMem0 = key0;
+ KeyMem1 = key1;
+ KeyMem2 = key2;
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CCipher::Init())
+{
+ return S_OK;
+}
+
+HRESULT CEncoder::WriteHeader_Check16(ISequentialOutStream *outStream, UInt16 crc)
+{
+ Byte h[kHeaderSize];
+
+ /* PKZIP before 2.0 used 2 byte CRC check.
+ PKZIP 2.0+ used 1 byte CRC check. It's more secure.
+ We also use 1 byte CRC. */
+
+ MY_RAND_GEN(h, kHeaderSize - 1);
+ // h[kHeaderSize - 2] = (Byte)(crc);
+ h[kHeaderSize - 1] = (Byte)(crc >> 8);
+
+ RestoreKeys();
+ Filter(h, kHeaderSize);
+ return WriteStream(outStream, h, kHeaderSize);
+}
+
+Z7_COM7F_IMF2(UInt32, CEncoder::Filter(Byte *data, UInt32 size))
+{
+ UInt32 key0 = this->Key0;
+ UInt32 key1 = this->Key1;
+ UInt32 key2 = this->Key2;
+
+ for (UInt32 i = 0; i < size; i++)
+ {
+ Byte b = data[i];
+ DECRYPT_BYTE_1
+ data[i] = (Byte)(b ^ DECRYPT_BYTE_2);
+ UPDATE_KEYS(b)
+ }
+
+ this->Key0 = key0;
+ this->Key1 = key1;
+ this->Key2 = key2;
+
+ return size;
+}
+
+HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream)
+{
+ return ReadStream_FAIL(inStream, _header, kHeaderSize);
+}
+
+void CDecoder::Init_BeforeDecode()
+{
+ RestoreKeys();
+ Filter(_header, kHeaderSize);
+}
+
+Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+{
+ UInt32 key0 = this->Key0;
+ UInt32 key1 = this->Key1;
+ UInt32 key2 = this->Key2;
+
+ for (UInt32 i = 0; i < size; i++)
+ {
+ DECRYPT_BYTE_1
+ Byte b = (Byte)(data[i] ^ DECRYPT_BYTE_2);
+ UPDATE_KEYS(b)
+ data[i] = b;
+ }
+
+ this->Key0 = key0;
+ this->Key1 = key1;
+ this->Key2 = key2;
+
+ return size;
+}
+
+}}
diff --git a/CPP/7zip/Crypto/ZipCrypto.h b/CPP/7zip/Crypto/ZipCrypto.h
new file mode 100644
index 0000000..485470e
--- /dev/null
+++ b/CPP/7zip/Crypto/ZipCrypto.h
@@ -0,0 +1,80 @@
+// Crypto/ZipCrypto.h
+
+#ifndef ZIP7_INC_CRYPTO_ZIP_CRYPTO_H
+#define ZIP7_INC_CRYPTO_ZIP_CRYPTO_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+#include "../IPassword.h"
+
+namespace NCrypto {
+namespace NZip {
+
+const unsigned kHeaderSize = 12;
+
+/* ICompressFilter::Init() does nothing for this filter.
+ Call to init:
+ Encoder:
+ CryptoSetPassword();
+ WriteHeader();
+ Decoder:
+ [CryptoSetPassword();]
+ ReadHeader();
+ [CryptoSetPassword();] Init_and_GetCrcByte();
+ [CryptoSetPassword();] Init_and_GetCrcByte();
+*/
+
+class CCipher:
+ public ICompressFilter,
+ public ICryptoSetPassword,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1(ICryptoSetPassword)
+ Z7_COM7F_IMP(Init())
+public:
+ Z7_IFACE_COM7_IMP(ICryptoSetPassword)
+protected:
+ UInt32 Key0;
+ UInt32 Key1;
+ UInt32 Key2;
+
+ UInt32 KeyMem0;
+ UInt32 KeyMem1;
+ UInt32 KeyMem2;
+
+ void RestoreKeys()
+ {
+ Key0 = KeyMem0;
+ Key1 = KeyMem1;
+ Key2 = KeyMem2;
+ }
+
+public:
+ virtual ~CCipher()
+ {
+ Key0 = KeyMem0 =
+ Key1 = KeyMem1 =
+ Key2 = KeyMem2 = 0;
+ }
+};
+
+class CEncoder Z7_final: public CCipher
+{
+ Z7_COM7F_IMP2(UInt32, Filter(Byte *data, UInt32 size))
+public:
+ HRESULT WriteHeader_Check16(ISequentialOutStream *outStream, UInt16 crc);
+};
+
+class CDecoder Z7_final: public CCipher
+{
+ Z7_COM7F_IMP2(UInt32, Filter(Byte *data, UInt32 size))
+public:
+ Byte _header[kHeaderSize];
+ HRESULT ReadHeader(ISequentialInStream *inStream);
+ void Init_BeforeDecode();
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/Crypto/ZipStrong.cpp b/CPP/7zip/Crypto/ZipStrong.cpp
new file mode 100644
index 0000000..59698d8
--- /dev/null
+++ b/CPP/7zip/Crypto/ZipStrong.cpp
@@ -0,0 +1,264 @@
+// Crypto/ZipStrong.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/CpuArch.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "Sha1Cls.h"
+#include "ZipStrong.h"
+
+namespace NCrypto {
+namespace NZipStrong {
+
+static const UInt16 kAES128 = 0x660E;
+
+/*
+ DeriveKey() function is similar to CryptDeriveKey() from Windows.
+ New version of MSDN contains the following condition in CryptDeriveKey() description:
+ "If the hash is not a member of the SHA-2 family and the required key is for either 3DES or AES".
+ Now we support ZipStrong for AES only. And it uses SHA1.
+ Our DeriveKey() code is equal to CryptDeriveKey() in Windows for such conditions: (SHA1 + AES).
+ if (method != AES && method != 3DES), probably we need another code.
+*/
+
+static void DeriveKey2(const Byte *digest, Byte c, Byte *dest)
+{
+ MY_ALIGN (16)
+ Byte buf[64];
+ memset(buf, c, 64);
+ for (unsigned i = 0; i < NSha1::kDigestSize; i++)
+ buf[i] ^= digest[i];
+ MY_ALIGN (16)
+ NSha1::CContext sha;
+ sha.Init();
+ sha.Update(buf, 64);
+ sha.Final(dest);
+}
+
+static void DeriveKey(NSha1::CContext &sha, Byte *key)
+{
+ MY_ALIGN (16)
+ Byte digest[NSha1::kDigestSize];
+ sha.Final(digest);
+ MY_ALIGN (16)
+ Byte temp[NSha1::kDigestSize * 2];
+ DeriveKey2(digest, 0x36, temp);
+ DeriveKey2(digest, 0x5C, temp + NSha1::kDigestSize);
+ memcpy(key, temp, 32);
+}
+
+void CKeyInfo::SetPassword(const Byte *data, UInt32 size)
+{
+ MY_ALIGN (16)
+ NSha1::CContext sha;
+ sha.Init();
+ sha.Update(data, size);
+ DeriveKey(sha, MasterKey);
+}
+
+
+
+CDecoder::CDecoder()
+{
+ CAesCbcDecoder *d = new CAesCbcDecoder();
+ _cbcDecoder = d;
+ _aesFilter = d;
+}
+
+Z7_COM7F_IMF(CDecoder::CryptoSetPassword(const Byte *data, UInt32 size))
+{
+ _key.SetPassword(data, size);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CDecoder::Init())
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+{
+ return _aesFilter->Filter(data, size);
+}
+
+
+HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream, UInt32 crc, UInt64 unpackSize)
+{
+ Byte temp[4];
+ RINOK(ReadStream_FALSE(inStream, temp, 2))
+ _ivSize = GetUi16(temp);
+ if (_ivSize == 0)
+ {
+ memset(_iv, 0, 16);
+ SetUi32(_iv + 0, crc)
+ SetUi64(_iv + 4, unpackSize)
+ _ivSize = 12;
+ }
+ else if (_ivSize == 16)
+ {
+ RINOK(ReadStream_FALSE(inStream, _iv, _ivSize))
+ }
+ else
+ return E_NOTIMPL;
+ RINOK(ReadStream_FALSE(inStream, temp, 4))
+ _remSize = GetUi32(temp);
+ // const UInt32 kAlign = 16;
+ if (_remSize < 16 || _remSize > (1 << 18))
+ return E_NOTIMPL;
+ if (_remSize > _bufAligned.Size())
+ {
+ _bufAligned.AllocAtLeast(_remSize);
+ if (!(Byte *)_bufAligned)
+ return E_OUTOFMEMORY;
+ }
+ return ReadStream_FALSE(inStream, _bufAligned, _remSize);
+}
+
+HRESULT CDecoder::Init_and_CheckPassword(bool &passwOK)
+{
+ passwOK = false;
+ if (_remSize < 16)
+ return E_NOTIMPL;
+ Byte *p = _bufAligned;
+ const unsigned format = GetUi16(p);
+ if (format != 3)
+ return E_NOTIMPL;
+ unsigned algId = GetUi16(p + 2);
+ if (algId < kAES128)
+ return E_NOTIMPL;
+ algId -= kAES128;
+ if (algId > 2)
+ return E_NOTIMPL;
+ const unsigned bitLen = GetUi16(p + 4);
+ const unsigned flags = GetUi16(p + 6);
+ if (algId * 64 + 128 != bitLen)
+ return E_NOTIMPL;
+ _key.KeySize = 16 + algId * 8;
+ const bool cert = ((flags & 2) != 0);
+
+ if ((flags & 0x4000) != 0)
+ {
+ // Use 3DES for rd data
+ return E_NOTIMPL;
+ }
+
+ if (cert)
+ {
+ return E_NOTIMPL;
+ }
+ else
+ {
+ if ((flags & 1) == 0)
+ return E_NOTIMPL;
+ }
+
+ UInt32 rdSize = GetUi16(p + 8);
+
+ if (rdSize + 16 > _remSize)
+ return E_NOTIMPL;
+
+ const unsigned kPadSize = kAesPadAllign; // is equal to blockSize of cipher for rd
+
+ /*
+ if (cert)
+ {
+ if ((rdSize & 0x7) != 0)
+ return E_NOTIMPL;
+ }
+ else
+ */
+ {
+ // PKCS7 padding
+ if (rdSize < kPadSize)
+ return E_NOTIMPL;
+ if ((rdSize & (kPadSize - 1)) != 0)
+ return E_NOTIMPL;
+ }
+
+ memmove(p, p + 10, rdSize);
+ const Byte *p2 = p + rdSize + 10;
+ UInt32 reserved = GetUi32(p2);
+ p2 += 4;
+
+ /*
+ if (cert)
+ {
+ UInt32 numRecipients = reserved;
+
+ if (numRecipients == 0)
+ return E_NOTIMPL;
+
+ {
+ UInt32 hashAlg = GetUi16(p2);
+ hashAlg = hashAlg;
+ UInt32 hashSize = GetUi16(p2 + 2);
+ hashSize = hashSize;
+ p2 += 4;
+
+ reserved = reserved;
+ // return E_NOTIMPL;
+
+ for (unsigned r = 0; r < numRecipients; r++)
+ {
+ UInt32 specSize = GetUi16(p2);
+ p2 += 2;
+ p2 += specSize;
+ }
+ }
+ }
+ else
+ */
+ {
+ if (reserved != 0)
+ return E_NOTIMPL;
+ }
+
+ UInt32 validSize = GetUi16(p2);
+ p2 += 2;
+ const size_t validOffset = (size_t)(p2 - p);
+ if ((validSize & 0xF) != 0 || validOffset + validSize != _remSize)
+ return E_NOTIMPL;
+
+ {
+ RINOK(_cbcDecoder->SetKey(_key.MasterKey, _key.KeySize))
+ RINOK(_cbcDecoder->SetInitVector(_iv, 16))
+ // SetInitVector() calls also Init()
+ RINOK(_cbcDecoder->Init()) // it's optional
+ Filter(p, rdSize);
+
+ rdSize -= kPadSize;
+ for (unsigned i = 0; i < kPadSize; i++)
+ if (p[(size_t)rdSize + i] != kPadSize)
+ return S_OK; // passwOK = false;
+ }
+
+ MY_ALIGN (16)
+ Byte fileKey[32];
+ MY_ALIGN (16)
+ NSha1::CContext sha;
+ sha.Init();
+ sha.Update(_iv, _ivSize);
+ sha.Update(p, rdSize);
+ DeriveKey(sha, fileKey);
+
+ RINOK(_cbcDecoder->SetKey(fileKey, _key.KeySize))
+ RINOK(_cbcDecoder->SetInitVector(_iv, 16))
+ // SetInitVector() calls also Init()
+ RINOK(_cbcDecoder->Init()) // it's optional
+
+ memmove(p, p + validOffset, validSize);
+ Filter(p, validSize);
+
+ if (validSize < 4)
+ return E_NOTIMPL;
+ validSize -= 4;
+ if (GetUi32(p + validSize) != CrcCalc(p, validSize))
+ return S_OK;
+ passwOK = true;
+ return S_OK;
+}
+
+}}
diff --git a/CPP/7zip/Crypto/ZipStrong.h b/CPP/7zip/Crypto/ZipStrong.h
new file mode 100644
index 0000000..a2b5cdd
--- /dev/null
+++ b/CPP/7zip/Crypto/ZipStrong.h
@@ -0,0 +1,73 @@
+// Crypto/ZipStrong.h
+
+#ifndef ZIP7_INC_CRYPTO_ZIP_STRONG_H
+#define ZIP7_INC_CRYPTO_ZIP_STRONG_H
+
+#include "../../Common/MyBuffer2.h"
+
+#include "../IPassword.h"
+
+#include "MyAes.h"
+
+namespace NCrypto {
+namespace NZipStrong {
+
+/* ICompressFilter::Init() does nothing for this filter.
+ Call to init:
+ Decoder:
+ [CryptoSetPassword();]
+ ReadHeader();
+ [CryptoSetPassword();] Init_and_CheckPassword();
+ [CryptoSetPassword();] Init_and_CheckPassword();
+*/
+
+struct CKeyInfo
+{
+ Byte MasterKey[32];
+ UInt32 KeySize;
+
+ void SetPassword(const Byte *data, UInt32 size);
+
+ void Wipe()
+ {
+ Z7_memset_0_ARRAY(MasterKey);
+ }
+};
+
+
+const unsigned kAesPadAllign = AES_BLOCK_SIZE;
+
+Z7_CLASS_IMP_COM_2(
+ CDecoder
+ , ICompressFilter
+ , ICryptoSetPassword
+)
+ CAesCbcDecoder *_cbcDecoder;
+ CMyComPtr<ICompressFilter> _aesFilter;
+ CKeyInfo _key;
+ CAlignedBuffer _bufAligned;
+
+ UInt32 _ivSize;
+ Byte _iv[16];
+ UInt32 _remSize;
+public:
+ HRESULT ReadHeader(ISequentialInStream *inStream, UInt32 crc, UInt64 unpackSize);
+ HRESULT Init_and_CheckPassword(bool &passwOK);
+ UInt32 GetPadSize(UInt32 packSize32) const
+ {
+ // Padding is to align to blockSize of cipher.
+ // Change it, if is not AES
+ return kAesPadAllign - (packSize32 & (kAesPadAllign - 1));
+ }
+ CDecoder();
+ ~CDecoder() { Wipe(); }
+ void Wipe()
+ {
+ Z7_memset_0_ARRAY(_iv);
+ _key.Wipe();
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/7zip/GuiCommon.rc b/CPP/7zip/GuiCommon.rc
index 565ee70..b67409b 100644
--- a/CPP/7zip/GuiCommon.rc
+++ b/CPP/7zip/GuiCommon.rc
@@ -1,84 +1,84 @@
-#include <windows.h>
-
-// #include <winnt.h>
-// #include <WinUser.h>
-
-// for Windows CE:
-#include <CommCtrl.h>
-
-
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-
-#undef m
-#undef bxs
-#undef bys
-#undef bxsDots
-#undef y
-#undef xc
-#undef yc
-#undef xs
-#undef ys
-#undef bx
-#undef bx1
-#undef bx2
-#undef bx3
-#undef by
-#undef by1
-#undef by2
-#undef by3
-#undef gSpace
-#undef gSize
-#undef marg2
-#undef marg3
-
-#undef MY_DIALOG
-#undef MY_RESIZE_DIALOG
-#undef MY_PAGE
-
-#define m 8
-#define bxs 64
-#define bys 16
-#define bxsDots 20
-
-#define xs (xc + m + m)
-#define ys (yc + m + m)
-
-#define bx1 (xs - m - bxs)
-#define bx2 (bx1 - m - bxs)
-#define bx3 (bx2 - m - bxs)
-#define bx bx1
-
-#define by1 (ys - m - bys)
-#define by2 (by1 - m - bys)
-#define by by1
-
-
-#define MY_MODAL_DIALOG_STYLE STYLE DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU
-
-#define MY_MODAL_RESIZE_DIALOG_STYLE MY_MODAL_DIALOG_STYLE | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX | WS_THICKFRAME
-
-#define MY_PAGE_STYLE STYLE WS_CHILD | WS_DISABLED | WS_CAPTION
-
-#define MY_FONT FONT 8, "MS Shell Dlg"
-
-#define SMALL_PAGE_SIZE_X 120
-
-// #define MY_DIALOG DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-// #define MY_RESIZE_DIALOG DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
-#define MY_PAGE DIALOG 0, 0, xs, ys MY_PAGE_STYLE MY_FONT
-
-#define OK_CANCEL \
- DEFPUSHBUTTON "OK", IDOK, bx2, by, bxs, bys \
- PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
-
-#define MY_BUTTON__CLOSE \
- DEFPUSHBUTTON "&Close", IDCLOSE, bx1, by, bxs, bys
-
-
-#define MY_COMBO CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
-#define MY_COMBO_SORTED MY_COMBO | CBS_SORT
-#define MY_COMBO_WITH_EDIT CBS_DROPDOWN | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP
-
-#define MY_CHECKBOX "Button", BS_AUTOCHECKBOX | WS_TABSTOP
-
-#define MY_TEXT_NOPREFIX 8, SS_NOPREFIX
+#include <windows.h>
+
+// #include <winnt.h>
+// #include <WinUser.h>
+
+// for Windows CE:
+#include <CommCtrl.h>
+
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+#undef m
+#undef bxs
+#undef bys
+#undef bxsDots
+#undef y
+#undef xc
+#undef yc
+#undef xs
+#undef ys
+#undef bx
+#undef bx1
+#undef bx2
+#undef bx3
+#undef by
+#undef by1
+#undef by2
+#undef by3
+#undef gSpace
+#undef gSize
+#undef marg2
+#undef marg3
+
+#undef MY_DIALOG
+#undef MY_RESIZE_DIALOG
+#undef MY_PAGE
+
+#define m 8
+#define bxs 64
+#define bys 16
+#define bxsDots 20
+
+#define xs (xc + m + m)
+#define ys (yc + m + m)
+
+#define bx1 (xs - m - bxs)
+#define bx2 (bx1 - m - bxs)
+#define bx3 (bx2 - m - bxs)
+#define bx bx1
+
+#define by1 (ys - m - bys)
+#define by2 (by1 - m - bys)
+#define by by1
+
+
+#define MY_MODAL_DIALOG_STYLE STYLE DS_MODALFRAME | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU
+
+#define MY_MODAL_RESIZE_DIALOG_STYLE MY_MODAL_DIALOG_STYLE | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX | WS_THICKFRAME
+
+#define MY_PAGE_STYLE STYLE WS_CHILD | WS_DISABLED | WS_CAPTION
+
+#define MY_FONT FONT 8, "MS Shell Dlg"
+
+#define SMALL_PAGE_SIZE_X 120
+
+// #define MY_DIALOG DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+// #define MY_RESIZE_DIALOG DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+#define MY_PAGE DIALOG 0, 0, xs, ys MY_PAGE_STYLE MY_FONT
+
+#define OK_CANCEL \
+ DEFPUSHBUTTON "OK", IDOK, bx2, by, bxs, bys \
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+
+#define MY_BUTTON__CLOSE \
+ DEFPUSHBUTTON "&Close", IDCLOSE, bx1, by, bxs, bys
+
+
+#define MY_COMBO CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
+#define MY_COMBO_SORTED MY_COMBO | CBS_SORT
+#define MY_COMBO_WITH_EDIT CBS_DROPDOWN | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP
+
+#define MY_CHECKBOX "Button", BS_AUTOCHECKBOX | WS_TABSTOP
+
+#define MY_TEXT_NOPREFIX 8, SS_NOPREFIX
diff --git a/CPP/7zip/Guid.txt b/CPP/7zip/Guid.txt
index e5e0612..eee28f7 100644
--- a/CPP/7zip/Guid.txt
+++ b/CPP/7zip/Guid.txt
@@ -1,220 +1,237 @@
-{23170F69-40C1-278A-0000-00yy00xx0000}
-
-00 IProgress.h
-
- 05 IProgress
- // 050002 IProgress2
-
-01 IFolderArchive.h
-
- // 05 IArchiveFolder // old
- // 06 IInFolderArchive // old
- 07 IFileExtractCallback.h::IFolderArchiveExtractCallback
- 08 IFileExtractCallback.h::IFolderArchiveExtractCallback2
- // 0A IOutFolderArchive
- 0B IFolderArchiveUpdateCallback
- 0C Agent.h::IArchiveFolderInternal
- 0D IArchiveFolder
- 0E IInFolderArchive
- 0F IOutFolderArchive
- 10 IFolderArchiveUpdateCallback2
- 11 IFolderScanProgress
-
- 20 IFileExtractCallback.h::IGetProp
- 30 IFileExtractCallback.h::IFolderExtractToStreamCallback
-
-03 IStream.h
-
- 01 ISequentialInStream
- 02 ISequentialOutStream
- 03 IInStream
- 04 IOutStream
- 06 IStreamGetSize
- 07 IOutStreamFinish
- 08 IStreamGetProps
- 09 IStreamGetProps2
-
-
-04 ICoder.h
-
- 04 ICompressProgressInfo
- 05 ICompressCoder
- 18 ICompressCoder2
- 1F ICompressSetCoderPropertiesOpt
- 20 ICompressSetCoderProperties
- 21 ICompressSetDecoderProperties //
- 22 ICompressSetDecoderProperties2
- 23 ICompressWriteCoderProperties
- 24 ICompressGetInStreamProcessedSize
- 25 ICompressSetCoderMt
- 26 ICompressSetFinishMode
- 27 ICompressGetInStreamProcessedSize2
- 28 ICompressSetMemLimit
-
- 30 ICompressGetSubStreamSize
- 31 ICompressSetInStream
- 32 ICompressSetOutStream
-// 33 ICompressSetInStreamSize
- 34 ICompressSetOutStreamSize
- 35 ICompressSetBufSize
- 36 ICompressInitEncoder
- 37 ICompressSetInStream2
-// 38 ICompressSetOutStream2
-// 39 SetInStreamSize2
-// 3A SetOutStreamSize2
-
- 40 ICompressFilter
- 60 ICompressCodecsInfo
- 61 ISetCompressCodecsInfo
- 80 ICryptoProperties
- 88 ICryptoResetSalt
- 8C ICryptoResetInitVector
- 90 ICryptoSetPassword
- A0 ICryptoSetCRC
- C0 IHasher
- C1 IHashers
-
-
-05 IPassword.h
-
- 10 ICryptoGetTextPassword
- 11 ICryptoGetTextPassword2
-
-
-06 IArchive.h
-
- 03 ISetProperties
- 04 IArchiveKeepModeForNextOpen
- 05 IArchiveAllowTail
-
- 10 IArchiveOpenCallback
-
- 20 IArchiveExtractCallback
- 21 IArchiveExtractCallbackMessage
-
- 30 IArchiveOpenVolumeCallback
- 40 IInArchiveGetStream
- 50 IArchiveOpenSetSubArchiveName
- 60 IInArchive
- 61 IArchiveOpenSeq
- 70 IArchiveGetRawProps
- 71 IArchiveGetRootProps
-
- 80 IArchiveUpdateCallback
- 82 IArchiveUpdateCallback2
- 83 IArchiveUpdateCallbackFile
-
- A0 IOutArchive
-
-
-
-08 IFolder.h
-
- 00 IFolderFolder
- 01 IEnumProperties
- 02 IFolderGetTypeID
- 03 IFolderGetPath
- 04 IFolderWasChanged
- 05 // IFolderReload
- 06 // IFolderOperations old
- 07 IFolderGetSystemIconIndex
- 08 IFolderGetItemFullSize
- 09 IFolderClone
- 0A IFolderSetFlatMode
- 0B IFolderOperationsExtractCallback
- 0C //
- 0D //
- 0E IFolderProperties
- 0F
- 10 IFolderArcProps
- 11 IGetFolderArcProps
- 12 // IFolderOperations
- 13 IFolderOperations
- 14 IFolderCalcItemFullSize
- 15 IFolderCompare
- 16 IFolderGetItemName
- 17 IFolderAltStreams
-
-
-09 IFolder.h :: FOLDER_MANAGER_INTERFACE
-
- 00 - 04 // old IFolderManager
- 05 IFolderManager
-
-
-// 0A PluginInterface.h
- 00 IInitContextMenu
- 01 IPluginOptionsCallback
- 02 IPluginOptions
-
-
-Handler GUIDs:
-
-{23170F69-40C1-278A-1000-000110xx0000}
-
- 01 Zip
- 02 BZip2
- 03 Rar
- 04 Arj
- 05 Z
- 06 Lzh
- 07 7z
- 08 Cab
- 09 Nsis
- 0A lzma
- 0B lzma86
- 0C xz
- 0D ppmd
-
- C6 COFF
- C7 Ext
- C8 VMDK
- C9 VDI
- CA Qcow
- CB GPT
- CC Rar5
- CD IHex
- CE Hxs
- CF TE
- D0 UEFIc
- D1 UEFIs
- D2 SquashFS
- D3 CramFS
- D4 APM
- D5 Mslz
- D6 Flv
- D7 Swf
- D8 Swfc
- D9 Ntfs
- DA Fat
- DB Mbr
- DC Vhd
- DD Pe
- DE Elf
- DF Mach-O
- E0 Udf
- E1 Xar
- E2 Mub
- E3 Hfs
- E4 Dmg
- E5 Compound
- E6 Wim
- E7 Iso
- E8
- E9 Chm
- EA Split
- EB Rpm
- EC Deb
- ED Cpio
- EE Tar
- EF GZip
-
-{23170F69-40C1-278A-1000-000100020000} ContextMenu.h::CZipContextMenu
-
-// {23170F69-40C1-278A-1000-000100030000} // CAgentArchiveHandler
-// {23170F69-40C1-278B- old codecs clsids
-// {23170F69-40C1-278D-1000-000100020000} OptionsDialog.h::CLSID_CSevenZipOptions
-
-{23170F69-40C1-2790-id} Codec Decoders
-{23170F69-40C1-2791-id} Codec Encoders
-{23170F69-40C1-2792-id} Hashers
+{23170F69-40C1-278A-0000-00yy00xx0000}
+
+00 IProgress.h
+
+ 05 IProgress
+ // 050002 IProgress2
+
+01 IFolderArchive.h
+
+ // 05 IArchiveFolder // old
+ // 06 IInFolderArchive // old
+ 07 IFileExtractCallback.h::IFolderArchiveExtractCallback
+ 08 IFileExtractCallback.h::IFolderArchiveExtractCallback2
+ // 0A IOutFolderArchive
+ 0B IFolderArchiveUpdateCallback
+ 0C Agent.h::IArchiveFolderInternal
+ 0D IArchiveFolder
+ 0E IInFolderArchive
+ 0F IOutFolderArchive
+ 10 IFolderArchiveUpdateCallback2
+ 11 IFolderScanProgress
+ 12 IFolderSetZoneIdMode
+
+ 20 IFileExtractCallback.h::IGetProp
+ 30 IFileExtractCallback.h::IFolderExtractToStreamCallback (old)
+ 31 IFileExtractCallback.h::IFolderExtractToStreamCallback (new 21.04)
+
+03 IStream.h
+
+ 01 ISequentialInStream
+ 02 ISequentialOutStream
+ 03 IInStream
+ 04 IOutStream
+
+ 06 IStreamGetSize
+ 07 IOutStreamFinish
+ 08 IStreamGetProps
+ 09 IStreamGetProps2
+ 0A IStreamGetProp
+
+ 10 IStreamSetRestriction
+
+
+04 ICoder.h
+
+ 04 ICompressProgressInfo
+ 05 ICompressCoder
+ 18 ICompressCoder2
+ 1F ICompressSetCoderPropertiesOpt
+ 20 ICompressSetCoderProperties
+ 21 ICompressSetDecoderProperties //
+ 22 ICompressSetDecoderProperties2
+ 23 ICompressWriteCoderProperties
+ 24 ICompressGetInStreamProcessedSize
+ 25 ICompressSetCoderMt
+ 26 ICompressSetFinishMode
+ 27 ICompressGetInStreamProcessedSize2
+ 28 ICompressSetMemLimit
+ 29 ICompressReadUnusedFromInBuf
+
+ 30 ICompressGetSubStreamSize
+ 31 ICompressSetInStream
+ 32 ICompressSetOutStream
+// 33 ICompressSetInStreamSize
+ 34 ICompressSetOutStreamSize
+ 35 ICompressSetBufSize
+ 36 ICompressInitEncoder
+ 37 ICompressSetInStream2
+// 38 ICompressSetOutStream2
+// 39 SetInStreamSize2
+// 3A SetOutStreamSize2
+
+ 40 ICompressFilter
+ 60 ICompressCodecsInfo
+ 61 ISetCompressCodecsInfo
+ 80 ICryptoProperties
+ 88 ICryptoResetSalt
+ 8C ICryptoResetInitVector
+ 90 ICryptoSetPassword
+ A0 ICryptoSetCRC
+ C0 IHasher
+ C1 IHashers
+
+
+05 IPassword.h
+
+ 10 ICryptoGetTextPassword
+ 11 ICryptoGetTextPassword2
+
+
+06 IArchive.h
+
+ 03 ISetProperties
+ 04 IArchiveKeepModeForNextOpen
+ 05 IArchiveAllowTail
+
+ 10 IArchiveOpenCallback
+
+ 20 IArchiveExtractCallback
+ 21 IArchiveExtractCallbackMessage (deprecated in v23)
+ 22 IArchiveExtractCallbackMessage2 (new in v23)
+
+ 30 IArchiveOpenVolumeCallback
+ 40 IInArchiveGetStream
+ 50 IArchiveOpenSetSubArchiveName
+ 60 IInArchive
+ 61 IArchiveOpenSeq
+ 70 IArchiveGetRawProps
+ 71 IArchiveGetRootProps
+
+ 80 IArchiveUpdateCallback
+ 82 IArchiveUpdateCallback2
+ 83 IArchiveUpdateCallbackFile
+ 84 IArchiveGetDiskProperty
+ 85 IArchiveUpdateCallbackArcProp (Reserved)
+
+
+ A0 IOutArchive
+
+
+
+08 IFolder.h
+
+ 00 IFolderFolder
+ 01 IEnumProperties
+ 02 IFolderGetTypeID
+ 03 IFolderGetPath
+ 04 IFolderWasChanged
+ 05 // IFolderReload
+ 06 // IFolderOperations old
+ 07 IFolderGetSystemIconIndex
+ 08 IFolderGetItemFullSize
+ 09 IFolderClone
+ 0A IFolderSetFlatMode
+ 0B IFolderOperationsExtractCallback
+ 0C //
+ 0D //
+ 0E IFolderProperties
+ 0F
+ 10 IFolderArcProps
+ 11 IGetFolderArcProps
+ 12 // IFolderOperations
+ 13 IFolderOperations
+ 14 IFolderCalcItemFullSize
+ 15 IFolderCompare
+ 16 IFolderGetItemName
+ 17 IFolderAltStreams
+
+
+09 IFolder.h :: FOLDER_MANAGER_INTERFACE
+
+ 00 - 04 // old IFolderManager
+ 05 IFolderManager
+
+
+// 0A PluginInterface.h
+ 00 IInitContextMenu
+ 01 IPluginOptionsCallback
+ 02 IPluginOptions
+
+
+Handler GUIDs:
+
+{23170F69-40C1-278A-1000-000110xx0000}
+
+ 01 Zip
+ 02 BZip2
+ 03 Rar
+ 04 Arj
+ 05 Z
+ 06 Lzh
+ 07 7z
+ 08 Cab
+ 09 Nsis
+ 0A lzma
+ 0B lzma86
+ 0C xz
+ 0D ppmd
+
+ C0 AVB
+ C1 LP
+ C2 Sparse
+ C3 APFS
+ C4 Vhdx
+ C5 Base64
+ C6 COFF
+ C7 Ext
+ C8 VMDK
+ C9 VDI
+ CA Qcow
+ CB GPT
+ CC Rar5
+ CD IHex
+ CE Hxs
+ CF TE
+ D0 UEFIc
+ D1 UEFIs
+ D2 SquashFS
+ D3 CramFS
+ D4 APM
+ D5 Mslz
+ D6 Flv
+ D7 Swf
+ D8 Swfc
+ D9 Ntfs
+ DA Fat
+ DB Mbr
+ DC Vhd
+ DD Pe
+ DE Elf
+ DF Mach-O
+ E0 Udf
+ E1 Xar
+ E2 Mub
+ E3 Hfs
+ E4 Dmg
+ E5 Compound
+ E6 Wim
+ E7 Iso
+ E8
+ E9 Chm
+ EA Split
+ EB Rpm
+ EC Deb
+ ED Cpio
+ EE Tar
+ EF GZip
+
+{23170F69-40C1-278A-1000-000100020000} ContextMenu.h::CZipContextMenu
+
+// {23170F69-40C1-278A-1000-000100030000} // CAgentArchiveHandler
+// {23170F69-40C1-278B- old codecs clsids
+// {23170F69-40C1-278D-1000-000100020000} OptionsDialog.h::CLSID_CSevenZipOptions
+
+{23170F69-40C1-2790-id} Codec Decoders
+{23170F69-40C1-2791-id} Codec Encoders
+{23170F69-40C1-2792-id} Hashers
diff --git a/CPP/7zip/ICoder.h b/CPP/7zip/ICoder.h
index 54b2476..aec2834 100644
--- a/CPP/7zip/ICoder.h
+++ b/CPP/7zip/ICoder.h
@@ -1,399 +1,477 @@
-// ICoder.h
-
-#ifndef __ICODER_H
-#define __ICODER_H
-
-#include "IStream.h"
-
-#define CODER_INTERFACE(i, x) DECL_INTERFACE(i, 4, x)
-
-CODER_INTERFACE(ICompressProgressInfo, 0x04)
-{
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) PURE;
-
- /* (inSize) can be NULL, if unknown
- (outSize) can be NULL, if unknown
-
- returns:
- S_OK
- E_ABORT : Break by user
- another error codes
- */
-};
-
-CODER_INTERFACE(ICompressCoder, 0x05)
-{
- STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
- const UInt64 *inSize, const UInt64 *outSize,
- ICompressProgressInfo *progress) PURE;
-};
-
-CODER_INTERFACE(ICompressCoder2, 0x18)
-{
- STDMETHOD(Code)(ISequentialInStream * const *inStreams, const UInt64 * const *inSizes, UInt32 numInStreams,
- ISequentialOutStream * const *outStreams, const UInt64 * const *outSizes, UInt32 numOutStreams,
- ICompressProgressInfo *progress) PURE;
-};
-
-/*
- ICompressCoder::Code
- ICompressCoder2::Code
-
- returns:
- S_OK : OK
- S_FALSE : data error (for decoders)
- E_OUTOFMEMORY : memory allocation error
- E_NOTIMPL : unsupported encoding method (for decoders)
- another error code : some error. For example, it can be error code received from inStream or outStream function.
-
- Parameters:
- (inStream != NULL)
- (outStream != NULL)
-
- if (inSize != NULL)
- {
- Encoders in 7-Zip ignore (inSize).
- Decoder can use (*inSize) to check that stream was decoded correctly.
- Some decoder in 7-Zip check it, if (full_decoding mode was set via ICompressSetFinishMode)
- }
-
- If it's required to limit the reading from input stream (inStream), it can
- be done with ISequentialInStream implementation.
-
- if (outSize != NULL)
- {
- Encoders in 7-Zip ignore (outSize).
- Decoder unpacks no more than (*outSize) bytes.
- }
-
- (progress == NULL) is allowed.
-
-
- Decoding with Code() function
- -----------------------------
-
- You can request some interfaces before decoding
- - ICompressSetDecoderProperties2
- - ICompressSetFinishMode
-
- If you need to decode full stream:
- {
- 1) try to set full_decoding mode with ICompressSetFinishMode::SetFinishMode(1);
- 2) call the Code() function with specified (inSize) and (outSize), if these sizes are known.
- }
-
- If you need to decode only part of stream:
- {
- 1) try to set partial_decoding mode with ICompressSetFinishMode::SetFinishMode(0);
- 2) Call the Code() function with specified (inSize = NULL) and specified (outSize).
- }
-
- Encoding with Code() function
- -----------------------------
-
- You can request some interfaces :
- - ICompressSetCoderProperties - use it before encoding to set properties
- - ICompressWriteCoderProperties - use it before or after encoding to request encoded properties.
-
- ICompressCoder2 is used when (numInStreams != 1 || numOutStreams != 1)
- The rules are similar to ICompressCoder rules
-*/
-
-
-namespace NCoderPropID
-{
- enum EEnum
- {
- kDefaultProp = 0,
- kDictionarySize, // VT_UI4
- kUsedMemorySize, // VT_UI4
- kOrder, // VT_UI4
- kBlockSize, // VT_UI4 or VT_UI8
- kPosStateBits, // VT_UI4
- kLitContextBits, // VT_UI4
- kLitPosBits, // VT_UI4
- kNumFastBytes, // VT_UI4
- kMatchFinder, // VT_BSTR
- kMatchFinderCycles, // VT_UI4
- kNumPasses, // VT_UI4
- kAlgorithm, // VT_UI4
- kNumThreads, // VT_UI4
- kEndMarker, // VT_BOOL
- kLevel, // VT_UI4
- kReduceSize, // VT_UI8 : it's estimated size of largest data stream that will be compressed
- // encoder can use this value to reduce dictionary size and allocate data buffers
-
- kExpectedDataSize, // VT_UI8 : for ICompressSetCoderPropertiesOpt :
- // it's estimated size of current data stream
- // real data size can differ from that size
- // encoder can use this value to optimize encoder initialization
-
- kBlockSize2, // VT_UI4 or VT_UI8
- kCheckSize, // VT_UI4 : size of digest in bytes
- kFilter, // VT_BSTR
- kMemUse // VT_UI8
- };
-}
-
-CODER_INTERFACE(ICompressSetCoderPropertiesOpt, 0x1F)
-{
- STDMETHOD(SetCoderPropertiesOpt)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps) PURE;
-};
-
-CODER_INTERFACE(ICompressSetCoderProperties, 0x20)
-{
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps) PURE;
-};
-
-/*
-CODER_INTERFACE(ICompressSetCoderProperties, 0x21)
-{
- STDMETHOD(SetDecoderProperties)(ISequentialInStream *inStream) PURE;
-};
-*/
-
-CODER_INTERFACE(ICompressSetDecoderProperties2, 0x22)
-{
- /* returns:
- S_OK
- E_NOTIMP : unsupported properties
- E_INVALIDARG : incorrect (or unsupported) properties
- E_OUTOFMEMORY : memory allocation error
- */
- STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size) PURE;
-};
-
-CODER_INTERFACE(ICompressWriteCoderProperties, 0x23)
-{
- STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream) PURE;
-};
-
-CODER_INTERFACE(ICompressGetInStreamProcessedSize, 0x24)
-{
- STDMETHOD(GetInStreamProcessedSize)(UInt64 *value) PURE;
-};
-
-CODER_INTERFACE(ICompressSetCoderMt, 0x25)
-{
- STDMETHOD(SetNumberOfThreads)(UInt32 numThreads) PURE;
-};
-
-CODER_INTERFACE(ICompressSetFinishMode, 0x26)
-{
- STDMETHOD(SetFinishMode)(UInt32 finishMode) PURE;
-
- /* finishMode:
- 0 : partial decoding is allowed. It's default mode for ICompressCoder::Code(), if (outSize) is defined.
- 1 : full decoding. The stream must be finished at the end of decoding. */
-};
-
-CODER_INTERFACE(ICompressGetInStreamProcessedSize2, 0x27)
-{
- STDMETHOD(GetInStreamProcessedSize2)(UInt32 streamIndex, UInt64 *value) PURE;
-};
-
-CODER_INTERFACE(ICompressSetMemLimit, 0x28)
-{
- STDMETHOD(SetMemLimit)(UInt64 memUsage) PURE;
-};
-
-
-
-CODER_INTERFACE(ICompressGetSubStreamSize, 0x30)
-{
- STDMETHOD(GetSubStreamSize)(UInt64 subStream, UInt64 *value) PURE;
-
- /* returns:
- S_OK : (*value) contains the size or estimated size (can be incorrect size)
- S_FALSE : size is undefined
- E_NOTIMP : the feature is not implemented
-
- Let's (read_size) is size of data that was already read by ISequentialInStream::Read().
- The caller should call GetSubStreamSize() after each Read() and check sizes:
- if (start_of_subStream + *value < read_size)
- {
- // (*value) is correct, and it's allowed to call GetSubStreamSize() for next subStream:
- start_of_subStream += *value;
- subStream++;
- }
- */
-};
-
-CODER_INTERFACE(ICompressSetInStream, 0x31)
-{
- STDMETHOD(SetInStream)(ISequentialInStream *inStream) PURE;
- STDMETHOD(ReleaseInStream)() PURE;
-};
-
-CODER_INTERFACE(ICompressSetOutStream, 0x32)
-{
- STDMETHOD(SetOutStream)(ISequentialOutStream *outStream) PURE;
- STDMETHOD(ReleaseOutStream)() PURE;
-};
-
-/*
-CODER_INTERFACE(ICompressSetInStreamSize, 0x33)
-{
- STDMETHOD(SetInStreamSize)(const UInt64 *inSize) PURE;
-};
-*/
-
-CODER_INTERFACE(ICompressSetOutStreamSize, 0x34)
-{
- STDMETHOD(SetOutStreamSize)(const UInt64 *outSize) PURE;
-
- /* That function initializes decoder structures.
- Call this function only for stream version of decoder.
- if (outSize == NULL), then output size is unknown
- if (outSize != NULL), then the decoder must stop decoding after (*outSize) bytes. */
-};
-
-CODER_INTERFACE(ICompressSetBufSize, 0x35)
-{
- STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size) PURE;
- STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size) PURE;
-};
-
-CODER_INTERFACE(ICompressInitEncoder, 0x36)
-{
- STDMETHOD(InitEncoder)() PURE;
-
- /* That function initializes encoder structures.
- Call this function only for stream version of encoder. */
-};
-
-CODER_INTERFACE(ICompressSetInStream2, 0x37)
-{
- STDMETHOD(SetInStream2)(UInt32 streamIndex, ISequentialInStream *inStream) PURE;
- STDMETHOD(ReleaseInStream2)(UInt32 streamIndex) PURE;
-};
-
-/*
-CODER_INTERFACE(ICompressSetOutStream2, 0x38)
-{
- STDMETHOD(SetOutStream2)(UInt32 streamIndex, ISequentialOutStream *outStream) PURE;
- STDMETHOD(ReleaseOutStream2)(UInt32 streamIndex) PURE;
-};
-
-CODER_INTERFACE(ICompressSetInStreamSize2, 0x39)
-{
- STDMETHOD(SetInStreamSize2)(UInt32 streamIndex, const UInt64 *inSize) PURE;
-};
-*/
-
-
-/*
- ICompressFilter
- Filter() converts as most as possible bytes
- returns: (outSize):
- if (outSize <= size) : Filter have converted outSize bytes
- if (outSize > size) : Filter have not converted anything.
- and it needs at least outSize bytes to convert one block
- (it's for crypto block algorithms).
-*/
-
-#define INTERFACE_ICompressFilter(x) \
- STDMETHOD(Init)() x; \
- STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size) x; \
-
-CODER_INTERFACE(ICompressFilter, 0x40)
-{
- INTERFACE_ICompressFilter(PURE);
-};
-
-
-CODER_INTERFACE(ICompressCodecsInfo, 0x60)
-{
- STDMETHOD(GetNumMethods)(UInt32 *numMethods) PURE;
- STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value) PURE;
- STDMETHOD(CreateDecoder)(UInt32 index, const GUID *iid, void **coder) PURE;
- STDMETHOD(CreateEncoder)(UInt32 index, const GUID *iid, void **coder) PURE;
-};
-
-CODER_INTERFACE(ISetCompressCodecsInfo, 0x61)
-{
- STDMETHOD(SetCompressCodecsInfo)(ICompressCodecsInfo *compressCodecsInfo) PURE;
-};
-
-CODER_INTERFACE(ICryptoProperties, 0x80)
-{
- STDMETHOD(SetKey)(const Byte *data, UInt32 size) PURE;
- STDMETHOD(SetInitVector)(const Byte *data, UInt32 size) PURE;
-};
-
-/*
-CODER_INTERFACE(ICryptoResetSalt, 0x88)
-{
- STDMETHOD(ResetSalt)() PURE;
-};
-*/
-
-CODER_INTERFACE(ICryptoResetInitVector, 0x8C)
-{
- STDMETHOD(ResetInitVector)() PURE;
-
- /* Call ResetInitVector() only for encoding.
- Call ResetInitVector() before encoding and before WriteCoderProperties().
- Crypto encoder can create random IV in that function. */
-};
-
-CODER_INTERFACE(ICryptoSetPassword, 0x90)
-{
- STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size) PURE;
-};
-
-CODER_INTERFACE(ICryptoSetCRC, 0xA0)
-{
- STDMETHOD(CryptoSetCRC)(UInt32 crc) PURE;
-};
-
-
-namespace NMethodPropID
-{
- enum EEnum
- {
- kID,
- kName,
- kDecoder,
- kEncoder,
- kPackStreams,
- kUnpackStreams,
- kDescription,
- kDecoderIsAssigned,
- kEncoderIsAssigned,
- kDigestSize
- };
-}
-
-
-#define INTERFACE_IHasher(x) \
- STDMETHOD_(void, Init)() throw() x; \
- STDMETHOD_(void, Update)(const void *data, UInt32 size) throw() x; \
- STDMETHOD_(void, Final)(Byte *digest) throw() x; \
- STDMETHOD_(UInt32, GetDigestSize)() throw() x; \
-
-CODER_INTERFACE(IHasher, 0xC0)
-{
- INTERFACE_IHasher(PURE)
-};
-
-CODER_INTERFACE(IHashers, 0xC1)
-{
- STDMETHOD_(UInt32, GetNumHashers)() PURE;
- STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value) PURE;
- STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher) PURE;
-};
-
-extern "C"
-{
- typedef HRESULT (WINAPI *Func_GetNumberOfMethods)(UInt32 *numMethods);
- typedef HRESULT (WINAPI *Func_GetMethodProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
- typedef HRESULT (WINAPI *Func_CreateDecoder)(UInt32 index, const GUID *iid, void **outObject);
- typedef HRESULT (WINAPI *Func_CreateEncoder)(UInt32 index, const GUID *iid, void **outObject);
-
- typedef HRESULT (WINAPI *Func_GetHashers)(IHashers **hashers);
-
- typedef HRESULT (WINAPI *Func_SetCodecs)(ICompressCodecsInfo *compressCodecsInfo);
-}
-
-#endif
+// ICoder.h
+
+#ifndef ZIP7_INC_ICODER_H
+#define ZIP7_INC_ICODER_H
+
+#include "IStream.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACE_CONSTR_CODER(i, n) \
+ Z7_DECL_IFACE_7ZIP(i, 4, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACEM_ICompressProgressInfo(x) \
+ x(SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+Z7_IFACE_CONSTR_CODER(ICompressProgressInfo, 0x04)
+ /*
+ SetRatioInfo()
+ (inSize) can be NULL, if unknown
+ (outSize) can be NULL, if unknown
+ returns:
+ S_OK
+ E_ABORT : Break by user
+ another error codes
+ */
+
+#define Z7_IFACEM_ICompressCoder(x) \
+ x(Code(ISequentialInStream *inStream, ISequentialOutStream *outStream, \
+ const UInt64 *inSize, const UInt64 *outSize, \
+ ICompressProgressInfo *progress))
+Z7_IFACE_CONSTR_CODER(ICompressCoder, 0x05)
+
+#define Z7_IFACEM_ICompressCoder2(x) \
+ x(Code(ISequentialInStream * const *inStreams, const UInt64 *const *inSizes, UInt32 numInStreams, \
+ ISequentialOutStream *const *outStreams, const UInt64 *const *outSizes, UInt32 numOutStreams, \
+ ICompressProgressInfo *progress))
+Z7_IFACE_CONSTR_CODER(ICompressCoder2, 0x18)
+
+/*
+ ICompressCoder::Code
+ ICompressCoder2::Code
+
+ returns:
+ S_OK : OK
+ S_FALSE : data error (for decoders)
+ E_OUTOFMEMORY : memory allocation error
+ E_NOTIMPL : unsupported encoding method (for decoders)
+ another error code : some error. For example, it can be error code received from inStream or outStream function.
+
+ Parameters:
+ (inStream != NULL)
+ (outStream != NULL)
+
+ if (inSize != NULL)
+ {
+ Encoders in 7-Zip ignore (inSize).
+ Decoder can use (*inSize) to check that stream was decoded correctly.
+ Some decoders in 7-Zip check it, if (full_decoding mode was set via ICompressSetFinishMode)
+ }
+
+ If it's required to limit the reading from input stream (inStream), it can
+ be done with ISequentialInStream implementation.
+
+ if (outSize != NULL)
+ {
+ Encoders in 7-Zip ignore (outSize).
+ Decoder unpacks no more than (*outSize) bytes.
+ }
+
+ (progress == NULL) is allowed.
+
+
+ Decoding with Code() function
+ -----------------------------
+
+ You can request some interfaces before decoding
+ - ICompressSetDecoderProperties2
+ - ICompressSetFinishMode
+
+ If you need to decode full stream:
+ {
+ 1) try to set full_decoding mode with ICompressSetFinishMode::SetFinishMode(1);
+ 2) call the Code() function with specified (inSize) and (outSize), if these sizes are known.
+ }
+
+ If you need to decode only part of stream:
+ {
+ 1) try to set partial_decoding mode with ICompressSetFinishMode::SetFinishMode(0);
+ 2) Call the Code() function with specified (inSize = NULL) and specified (outSize).
+ }
+
+ Encoding with Code() function
+ -----------------------------
+
+ You can request some interfaces :
+ - ICompressSetCoderProperties - use it before encoding to set properties
+ - ICompressWriteCoderProperties - use it before or after encoding to request encoded properties.
+
+ ICompressCoder2 is used when (numInStreams != 1 || numOutStreams != 1)
+ The rules are similar to ICompressCoder rules
+*/
+
+
+namespace NCoderPropID
+{
+ enum EEnum
+ {
+ kDefaultProp = 0,
+ kDictionarySize, // VT_UI4
+ kUsedMemorySize, // VT_UI4
+ kOrder, // VT_UI4
+ kBlockSize, // VT_UI4 or VT_UI8
+ kPosStateBits, // VT_UI4
+ kLitContextBits, // VT_UI4
+ kLitPosBits, // VT_UI4
+ kNumFastBytes, // VT_UI4
+ kMatchFinder, // VT_BSTR
+ kMatchFinderCycles, // VT_UI4
+ kNumPasses, // VT_UI4
+ kAlgorithm, // VT_UI4
+ kNumThreads, // VT_UI4
+ kEndMarker, // VT_BOOL
+ kLevel, // VT_UI4
+ kReduceSize, // VT_UI8 : it's estimated size of largest data stream that will be compressed
+ // encoder can use this value to reduce dictionary size and allocate data buffers
+
+ kExpectedDataSize, // VT_UI8 : for ICompressSetCoderPropertiesOpt :
+ // it's estimated size of current data stream
+ // real data size can differ from that size
+ // encoder can use this value to optimize encoder initialization
+
+ kBlockSize2, // VT_UI4 or VT_UI8
+ kCheckSize, // VT_UI4 : size of digest in bytes
+ kFilter, // VT_BSTR
+ kMemUse, // VT_UI8
+ kAffinity, // VT_UI8
+ kBranchOffset, // VT_UI4
+ kHashBits, // VT_UI4
+ /*
+ // kHash3Bits, // VT_UI4
+ // kHash2Bits, // VT_UI4
+ // kChainBits, // VT_UI4
+ kChainSize, // VT_UI4
+ kNativeLevel, // VT_UI4
+ kFast, // VT_UI4
+ kMinMatch, // VT_UI4 The minimum slen is 3 and the maximum is 7.
+ kOverlapLog, // VT_UI4 The minimum ovlog is 0 and the maximum is 9. (default: 6)
+ kRowMatchFinder, // VT_BOOL
+ kLdmEnable, // VT_BOOL
+ // kLdmWindowSizeLog, // VT_UI4
+ kLdmWindowSize, // VT_UI4
+ kLdmHashLog, // VT_UI4 The minimum ldmhlog is 6 and the maximum is 26 (default: 20).
+ kLdmMinMatchLength, // VT_UI4 The minimum ldmslen is 4 and the maximum is 4096 (default: 64).
+ kLdmBucketSizeLog, // VT_UI4 The minimum ldmblog is 0 and the maximum is 8 (default: 3).
+ kLdmHashRateLog, // VT_UI4 The default value is wlog - ldmhlog.
+ kWriteUnpackSizeFlag, // VT_BOOL
+ kUsePledged, // VT_BOOL
+ kUseSizeHintPledgedForSmall, // VT_BOOL
+ kUseSizeHintForEach, // VT_BOOL
+ kUseSizeHintGlobal, // VT_BOOL
+ kParamSelectMode, // VT_UI4
+ // kSearchLog, // VT_UI4 The minimum slog is 1 and the maximum is 26
+ // kTargetLen, // VT_UI4 The minimum tlen is 0 and the maximum is 999.
+ */
+ k_NUM_DEFINED
+ };
+}
+
+#define Z7_IFACEM_ICompressSetCoderPropertiesOpt(x) \
+ x(SetCoderPropertiesOpt(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+Z7_IFACE_CONSTR_CODER(ICompressSetCoderPropertiesOpt, 0x1F)
+
+
+#define Z7_IFACEM_ICompressSetCoderProperties(x) \
+ x(SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+Z7_IFACE_CONSTR_CODER(ICompressSetCoderProperties, 0x20)
+
+/*
+#define Z7_IFACEM_ICompressSetDecoderProperties(x) \
+ x(SetDecoderProperties(ISequentialInStream *inStream))
+Z7_IFACE_CONSTR_CODER(ICompressSetDecoderProperties, 0x21)
+*/
+
+#define Z7_IFACEM_ICompressSetDecoderProperties2(x) \
+ x(SetDecoderProperties2(const Byte *data, UInt32 size))
+Z7_IFACE_CONSTR_CODER(ICompressSetDecoderProperties2, 0x22)
+ /* returns:
+ S_OK
+ E_NOTIMP : unsupported properties
+ E_INVALIDARG : incorrect (or unsupported) properties
+ E_OUTOFMEMORY : memory allocation error
+ */
+
+
+#define Z7_IFACEM_ICompressWriteCoderProperties(x) \
+ x(WriteCoderProperties(ISequentialOutStream *outStream))
+Z7_IFACE_CONSTR_CODER(ICompressWriteCoderProperties, 0x23)
+
+#define Z7_IFACEM_ICompressGetInStreamProcessedSize(x) \
+ x(GetInStreamProcessedSize(UInt64 *value))
+Z7_IFACE_CONSTR_CODER(ICompressGetInStreamProcessedSize, 0x24)
+
+#define Z7_IFACEM_ICompressSetCoderMt(x) \
+ x(SetNumberOfThreads(UInt32 numThreads))
+Z7_IFACE_CONSTR_CODER(ICompressSetCoderMt, 0x25)
+
+#define Z7_IFACEM_ICompressSetFinishMode(x) \
+ x(SetFinishMode(UInt32 finishMode))
+Z7_IFACE_CONSTR_CODER(ICompressSetFinishMode, 0x26)
+ /* finishMode:
+ 0 : partial decoding is allowed. It's default mode for ICompressCoder::Code(), if (outSize) is defined.
+ 1 : full decoding. The stream must be finished at the end of decoding. */
+
+#define Z7_IFACEM_ICompressGetInStreamProcessedSize2(x) \
+ x(GetInStreamProcessedSize2(UInt32 streamIndex, UInt64 *value))
+Z7_IFACE_CONSTR_CODER(ICompressGetInStreamProcessedSize2, 0x27)
+
+#define Z7_IFACEM_ICompressSetMemLimit(x) \
+ x(SetMemLimit(UInt64 memUsage))
+Z7_IFACE_CONSTR_CODER(ICompressSetMemLimit, 0x28)
+
+
+/*
+ ICompressReadUnusedFromInBuf is supported by ICoder object
+ call ReadUnusedFromInBuf() after ICoder::Code(inStream, ...).
+ ICoder::Code(inStream, ...) decodes data, and the ICoder object is allowed
+ to read from inStream to internal buffers more data than minimal data required for decoding.
+ So we can call ReadUnusedFromInBuf() from same ICoder object to read unused input
+ data from the internal buffer.
+ in ReadUnusedFromInBuf(): the Coder is not allowed to use (ISequentialInStream *inStream) object, that was sent to ICoder::Code().
+*/
+#define Z7_IFACEM_ICompressReadUnusedFromInBuf(x) \
+ x(ReadUnusedFromInBuf(void *data, UInt32 size, UInt32 *processedSize))
+Z7_IFACE_CONSTR_CODER(ICompressReadUnusedFromInBuf, 0x29)
+
+
+#define Z7_IFACEM_ICompressGetSubStreamSize(x) \
+ x(GetSubStreamSize(UInt64 subStream, UInt64 *value))
+Z7_IFACE_CONSTR_CODER(ICompressGetSubStreamSize, 0x30)
+ /* returns:
+ S_OK : (*value) contains the size or estimated size (can be incorrect size)
+ S_FALSE : size is undefined
+ E_NOTIMP : the feature is not implemented
+ Let's (read_size) is size of data that was already read by ISequentialInStream::Read().
+ The caller should call GetSubStreamSize() after each Read() and check sizes:
+ if (start_of_subStream + *value < read_size)
+ {
+ // (*value) is correct, and it's allowed to call GetSubStreamSize() for next subStream:
+ start_of_subStream += *value;
+ subStream++;
+ }
+ */
+
+#define Z7_IFACEM_ICompressSetInStream(x) \
+ x(SetInStream(ISequentialInStream *inStream)) \
+ x(ReleaseInStream())
+Z7_IFACE_CONSTR_CODER(ICompressSetInStream, 0x31)
+
+#define Z7_IFACEM_ICompressSetOutStream(x) \
+ x(SetOutStream(ISequentialOutStream *outStream)) \
+ x(ReleaseOutStream())
+Z7_IFACE_CONSTR_CODER(ICompressSetOutStream, 0x32)
+
+/*
+#define Z7_IFACEM_ICompressSetInStreamSize(x) \
+ x(SetInStreamSize(const UInt64 *inSize)) \
+Z7_IFACE_CONSTR_CODER(ICompressSetInStreamSize, 0x33)
+*/
+
+#define Z7_IFACEM_ICompressSetOutStreamSize(x) \
+ x(SetOutStreamSize(const UInt64 *outSize))
+Z7_IFACE_CONSTR_CODER(ICompressSetOutStreamSize, 0x34)
+ /* That function initializes decoder structures.
+ Call this function only for stream version of decoder.
+ if (outSize == NULL), then output size is unknown
+ if (outSize != NULL), then the decoder must stop decoding after (*outSize) bytes. */
+
+#define Z7_IFACEM_ICompressSetBufSize(x) \
+ x(SetInBufSize(UInt32 streamIndex, UInt32 size)) \
+ x(SetOutBufSize(UInt32 streamIndex, UInt32 size))
+
+Z7_IFACE_CONSTR_CODER(ICompressSetBufSize, 0x35)
+
+#define Z7_IFACEM_ICompressInitEncoder(x) \
+ x(InitEncoder())
+Z7_IFACE_CONSTR_CODER(ICompressInitEncoder, 0x36)
+ /* That function initializes encoder structures.
+ Call this function only for stream version of encoder. */
+
+#define Z7_IFACEM_ICompressSetInStream2(x) \
+ x(SetInStream2(UInt32 streamIndex, ISequentialInStream *inStream)) \
+ x(ReleaseInStream2(UInt32 streamIndex))
+Z7_IFACE_CONSTR_CODER(ICompressSetInStream2, 0x37)
+
+/*
+#define Z7_IFACEM_ICompressSetOutStream2(x) \
+ x(SetOutStream2(UInt32 streamIndex, ISequentialOutStream *outStream))
+ x(ReleaseOutStream2(UInt32 streamIndex))
+Z7_IFACE_CONSTR_CODER(ICompressSetOutStream2, 0x38)
+
+#define Z7_IFACEM_ICompressSetInStreamSize2(x) \
+ x(SetInStreamSize2(UInt32 streamIndex, const UInt64 *inSize))
+Z7_IFACE_CONSTR_CODER(ICompressSetInStreamSize2, 0x39)
+*/
+
+/*
+#define Z7_IFACEM_ICompressInSubStreams(x) \
+ x(GetNextInSubStream(UInt64 *streamIndexRes, ISequentialInStream **stream))
+Z7_IFACE_CONSTR_CODER(ICompressInSubStreams, 0x3A)
+
+#define Z7_IFACEM_ICompressOutSubStreams(x) \
+ x(GetNextOutSubStream(UInt64 *streamIndexRes, ISequentialOutStream **stream))
+Z7_IFACE_CONSTR_CODER(ICompressOutSubStreams, 0x3B)
+*/
+
+/*
+ ICompressFilter
+ Filter(Byte *data, UInt32 size)
+ (size)
+ converts as most as possible bytes required for fast processing.
+ Some filters have (smallest_fast_block).
+ For example, (smallest_fast_block == 16) for AES CBC/CTR filters.
+ If data stream is not finished, caller must call Filter() for larger block:
+ where (size >= smallest_fast_block).
+ if (size >= smallest_fast_block)
+ {
+ The filter can leave some bytes at the end of data without conversion:
+ if there are data alignment reasons or speed reasons.
+ The caller can read additional data from stream and call Filter() again.
+ }
+ If data stream was finished, caller can call Filter() for (size < smallest_fast_block)
+
+ (data) parameter:
+ Some filters require alignment for any Filter() call:
+ 1) (stream_offset % alignment_size) == (data % alignment_size)
+ 2) (alignment_size == 2^N)
+ where (stream_offset) - is the number of bytes that were already filtered before.
+ The callers of Filter() are required to meet these requirements.
+ (alignment_size) can be different:
+ 16 : for AES filters
+ 4 or 2 : for some branch convert filters
+ 1 : for another filters
+ (alignment_size >= 16) is enough for all current filters of 7-Zip.
+ But the caller can use larger (alignment_size).
+ Recommended alignment for (data) of Filter() call is (alignment_size == 64).
+ Also it's recommended to use aligned value for (size):
+ (size % alignment_size == 0),
+ if it's not last call of Filter() for current stream.
+
+ returns: (outSize):
+ if (outSize == 0) : Filter have not converted anything.
+ So the caller can stop processing, if data stream was finished.
+ if (outSize <= size) : Filter have converted outSize bytes
+ if (outSize > size) : Filter have not converted anything.
+ and it needs at least outSize bytes to convert one block
+ (it's for crypto block algorithms).
+*/
+
+#define Z7_IFACEM_ICompressFilter(x) \
+ x(Init()) \
+ x##2(UInt32, Filter(Byte *data, UInt32 size))
+Z7_IFACE_CONSTR_CODER(ICompressFilter, 0x40)
+
+
+#define Z7_IFACEM_ICompressCodecsInfo(x) \
+ x(GetNumMethods(UInt32 *numMethods)) \
+ x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+ x(CreateDecoder(UInt32 index, const GUID *iid, void* *coder)) \
+ x(CreateEncoder(UInt32 index, const GUID *iid, void* *coder))
+Z7_IFACE_CONSTR_CODER(ICompressCodecsInfo, 0x60)
+
+#define Z7_IFACEM_ISetCompressCodecsInfo(x) \
+ x(SetCompressCodecsInfo(ICompressCodecsInfo *compressCodecsInfo))
+Z7_IFACE_CONSTR_CODER(ISetCompressCodecsInfo, 0x61)
+
+#define Z7_IFACEM_ICryptoProperties(x) \
+ x(SetKey(const Byte *data, UInt32 size)) \
+ x(SetInitVector(const Byte *data, UInt32 size))
+Z7_IFACE_CONSTR_CODER(ICryptoProperties, 0x80)
+
+/*
+ x(ResetSalt())
+Z7_IFACE_CONSTR_CODER(ICryptoResetSalt, 0x88)
+*/
+
+#define Z7_IFACEM_ICryptoResetInitVector(x) \
+ x(ResetInitVector())
+Z7_IFACE_CONSTR_CODER(ICryptoResetInitVector, 0x8C)
+ /* Call ResetInitVector() only for encoding.
+ Call ResetInitVector() before encoding and before WriteCoderProperties().
+ Crypto encoder can create random IV in that function. */
+
+#define Z7_IFACEM_ICryptoSetPassword(x) \
+ x(CryptoSetPassword(const Byte *data, UInt32 size))
+Z7_IFACE_CONSTR_CODER(ICryptoSetPassword, 0x90)
+
+#define Z7_IFACEM_ICryptoSetCRC(x) \
+ x(CryptoSetCRC(UInt32 crc))
+Z7_IFACE_CONSTR_CODER(ICryptoSetCRC, 0xA0)
+
+
+namespace NMethodPropID
+{
+ enum EEnum
+ {
+ kID,
+ kName,
+ kDecoder,
+ kEncoder,
+ kPackStreams,
+ kUnpackStreams,
+ kDescription,
+ kDecoderIsAssigned,
+ kEncoderIsAssigned,
+ kDigestSize,
+ kIsFilter
+ };
+}
+
+namespace NModuleInterfaceType
+{
+ /*
+ virtual destructor in IUnknown:
+ - no : 7-Zip (Windows)
+ - no : 7-Zip (Linux) (v23) in default mode
+ - yes : p7zip
+ - yes : 7-Zip (Linux) before v23
+ - yes : 7-Zip (Linux) (v23), if Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN is defined
+ */
+ const UInt32 k_IUnknown_VirtDestructor_No = 0;
+ const UInt32 k_IUnknown_VirtDestructor_Yes = 1;
+ const UInt32 k_IUnknown_VirtDestructor_ThisModule =
+ #if !defined(_WIN32) && defined(Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN)
+ k_IUnknown_VirtDestructor_Yes;
+ #else
+ k_IUnknown_VirtDestructor_No;
+ #endif
+}
+
+namespace NModulePropID
+{
+ enum EEnum
+ {
+ kInterfaceType, // VT_UI4
+ kVersion // VT_UI4
+ };
+}
+
+
+#define Z7_IFACEM_IHasher(x) \
+ x##2(void, Init()) \
+ x##2(void, Update(const void *data, UInt32 size)) \
+ x##2(void, Final(Byte *digest)) \
+ x##2(UInt32, GetDigestSize())
+Z7_IFACE_CONSTR_CODER(IHasher, 0xC0)
+
+#define Z7_IFACEM_IHashers(x) \
+ x##2(UInt32, GetNumHashers()) \
+ x(GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+ x(CreateHasher(UInt32 index, IHasher **hasher))
+Z7_IFACE_CONSTR_CODER(IHashers, 0xC1)
+
+extern "C"
+{
+ typedef HRESULT (WINAPI *Func_GetNumberOfMethods)(UInt32 *numMethods);
+ typedef HRESULT (WINAPI *Func_GetMethodProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
+ typedef HRESULT (WINAPI *Func_CreateDecoder)(UInt32 index, const GUID *iid, void **outObject);
+ typedef HRESULT (WINAPI *Func_CreateEncoder)(UInt32 index, const GUID *iid, void **outObject);
+
+ typedef HRESULT (WINAPI *Func_GetHashers)(IHashers **hashers);
+
+ typedef HRESULT (WINAPI *Func_SetCodecs)(ICompressCodecsInfo *compressCodecsInfo);
+ typedef HRESULT (WINAPI *Func_GetModuleProp)(PROPID propID, PROPVARIANT *value);
+}
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/IDecl.h b/CPP/7zip/IDecl.h
index 5a34b0e..c4d4541 100644
--- a/CPP/7zip/IDecl.h
+++ b/CPP/7zip/IDecl.h
@@ -1,28 +1,76 @@
-// IDecl.h
-
-#ifndef __IDECL_H
-#define __IDECL_H
-
-#include "../Common/MyUnknown.h"
-
-#define k_7zip_GUID_Data1 0x23170F69
-#define k_7zip_GUID_Data2 0x40C1
-
-#define k_7zip_GUID_Data3_Common 0x278A
-
-#define k_7zip_GUID_Data3_Decoder 0x2790
-#define k_7zip_GUID_Data3_Encoder 0x2791
-#define k_7zip_GUID_Data3_Hasher 0x2792
-
-
-#define DECL_INTERFACE_SUB(i, base, groupId, subId) \
- DEFINE_GUID(IID_ ## i, \
- k_7zip_GUID_Data1, \
- k_7zip_GUID_Data2, \
- k_7zip_GUID_Data3_Common, \
- 0, 0, 0, (groupId), 0, (subId), 0, 0); \
- struct i: public base
-
-#define DECL_INTERFACE(i, groupId, subId) DECL_INTERFACE_SUB(i, IUnknown, groupId, subId)
-
-#endif
+// IDecl.h
+
+#ifndef ZIP7_INC_IDECL_H
+#define ZIP7_INC_IDECL_H
+
+#include "../Common/Common.h"
+#include "../Common/MyUnknown.h"
+
+#define k_7zip_GUID_Data1 0x23170F69
+#define k_7zip_GUID_Data2 0x40C1
+
+#define k_7zip_GUID_Data3_Common 0x278A
+
+#define k_7zip_GUID_Data3_Decoder 0x2790
+#define k_7zip_GUID_Data3_Encoder 0x2791
+#define k_7zip_GUID_Data3_Hasher 0x2792
+
+#define Z7_DECL_IFACE_7ZIP_SUB(i, _base, groupId, subId) \
+ Z7_DEFINE_GUID(IID_ ## i, \
+ k_7zip_GUID_Data1, \
+ k_7zip_GUID_Data2, \
+ k_7zip_GUID_Data3_Common, \
+ 0, 0, 0, (groupId), 0, (subId), 0, 0); \
+ struct Z7_DECLSPEC_NOVTABLE i: public _base
+
+#define Z7_DECL_IFACE_7ZIP(i, groupId, subId) \
+ Z7_DECL_IFACE_7ZIP_SUB(i, IUnknown, groupId, subId)
+
+
+#ifdef COM_DECLSPEC_NOTHROW
+#define Z7_COMWF_B COM_DECLSPEC_NOTHROW STDMETHODIMP
+#define Z7_COMWF_B_(t) COM_DECLSPEC_NOTHROW STDMETHODIMP_(t)
+#else
+#define Z7_COMWF_B STDMETHODIMP
+#define Z7_COMWF_B_(t) STDMETHODIMP_(t)
+#endif
+
+#if defined(_MSC_VER) && !defined(COM_DECLSPEC_NOTHROW)
+#define Z7_COM7F_B __declspec(nothrow) STDMETHODIMP
+#define Z7_COM7F_B_(t) __declspec(nothrow) STDMETHODIMP_(t)
+#else
+#define Z7_COM7F_B Z7_COMWF_B
+#define Z7_COM7F_B_(t) Z7_COMWF_B_(t)
+#endif
+
+// #define Z7_COM7F_E Z7_noexcept
+#define Z7_COM7F_E throw()
+#define Z7_COM7F_EO Z7_COM7F_E Z7_override
+#define Z7_COM7F_EOF Z7_COM7F_EO Z7_final
+#define Z7_COM7F_IMF(f) Z7_COM7F_B f Z7_COM7F_E
+#define Z7_COM7F_IMF2(t, f) Z7_COM7F_B_(t) f Z7_COM7F_E
+
+#define Z7_COM7F_PURE(f) virtual Z7_COM7F_IMF(f) =0;
+#define Z7_COM7F_PURE2(t, f) virtual Z7_COM7F_IMF2(t, f) =0;
+#define Z7_COM7F_IMP(f) Z7_COM7F_IMF(f) Z7_override Z7_final;
+#define Z7_COM7F_IMP2(t, f) Z7_COM7F_IMF2(t, f) Z7_override Z7_final;
+#define Z7_COM7F_IMP_NONFINAL(f) Z7_COM7F_IMF(f) Z7_override;
+#define Z7_COM7F_IMP_NONFINAL2(t, f) Z7_COM7F_IMF2(t, f) Z7_override;
+
+#define Z7_IFACE_PURE(name) Z7_IFACEN_ ## name(=0;)
+#define Z7_IFACE_IMP(name) Z7_IFACEN_ ## name(Z7_override Z7_final;)
+
+#define Z7_IFACE_COM7_PURE(name) Z7_IFACEM_ ## name(Z7_COM7F_PURE)
+#define Z7_IFACE_COM7_IMP(name) Z7_IFACEM_ ## name(Z7_COM7F_IMP)
+#define Z7_IFACE_COM7_IMP_NONFINAL(name) Z7_IFACEM_ ## name(Z7_COM7F_IMP_NONFINAL)
+
+
+#define Z7_IFACE_DECL_PURE(name) \
+ DECLARE_INTERFACE(name) \
+ { Z7_IFACE_PURE(name) };
+
+#define Z7_IFACE_DECL_PURE_(name, baseiface) \
+ DECLARE_INTERFACE_(name, baseiface) \
+ { Z7_IFACE_PURE(name) };
+
+#endif
diff --git a/CPP/7zip/IPassword.h b/CPP/7zip/IPassword.h
index e366007..689f08c 100644
--- a/CPP/7zip/IPassword.h
+++ b/CPP/7zip/IPassword.h
@@ -1,23 +1,54 @@
-// IPassword.h
-
-#ifndef __IPASSWORD_H
-#define __IPASSWORD_H
-
-#include "../Common/MyTypes.h"
-#include "../Common/MyUnknown.h"
-
-#include "IDecl.h"
-
-#define PASSWORD_INTERFACE(i, x) DECL_INTERFACE(i, 5, x)
-
-PASSWORD_INTERFACE(ICryptoGetTextPassword, 0x10)
-{
- STDMETHOD(CryptoGetTextPassword)(BSTR *password) PURE;
-};
-
-PASSWORD_INTERFACE(ICryptoGetTextPassword2, 0x11)
-{
- STDMETHOD(CryptoGetTextPassword2)(Int32 *passwordIsDefined, BSTR *password) PURE;
-};
-
-#endif
+// IPassword.h
+
+#ifndef ZIP7_INC_IPASSWORD_H
+#define ZIP7_INC_IPASSWORD_H
+
+#include "../Common/MyTypes.h"
+
+#include "IDecl.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACE_CONSTR_PASSWORD(i, n) \
+ Z7_DECL_IFACE_7ZIP(i, 5, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+/*
+How to use output parameter (BSTR *password):
+
+in: The caller is required to set BSTR value as NULL (no string).
+ The callee (in 7-Zip code) ignores the input value stored in BSTR variable,
+
+out: The callee rewrites BSTR variable (*password) with new allocated string pointer.
+ The caller must free BSTR string with function SysFreeString();
+*/
+
+#define Z7_IFACEM_ICryptoGetTextPassword(x) \
+ x(CryptoGetTextPassword(BSTR *password))
+Z7_IFACE_CONSTR_PASSWORD(ICryptoGetTextPassword, 0x10)
+
+
+/*
+CryptoGetTextPassword2()
+in:
+ The caller is required to set BSTR value as NULL (no string).
+ The caller is not required to set (*passwordIsDefined) value.
+
+out:
+ Return code: != S_OK : error code
+ Return code: S_OK : success
+
+ if (*passwordIsDefined == 1), the variable (*password) contains password string
+
+ if (*passwordIsDefined == 0), the password is not defined,
+ but the callee still could set (*password) to some allocated string, for example, as empty string.
+
+ The caller must free BSTR string with function SysFreeString()
+*/
+
+#define Z7_IFACEM_ICryptoGetTextPassword2(x) \
+ x(CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+Z7_IFACE_CONSTR_PASSWORD(ICryptoGetTextPassword2, 0x11)
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/IProgress.h b/CPP/7zip/IProgress.h
index d54529c..6714983 100644
--- a/CPP/7zip/IProgress.h
+++ b/CPP/7zip/IProgress.h
@@ -1,19 +1,20 @@
-// IProgress.h
-
-#ifndef __IPROGRESS_H
-#define __IPROGRESS_H
-
-#include "../Common/MyTypes.h"
-
-#include "IDecl.h"
-
-#define INTERFACE_IProgress(x) \
- STDMETHOD(SetTotal)(UInt64 total) x; \
- STDMETHOD(SetCompleted)(const UInt64 *completeValue) x; \
-
-DECL_INTERFACE(IProgress, 0, 5)
-{
- INTERFACE_IProgress(PURE)
-};
-
-#endif
+// IProgress.h
+
+#ifndef ZIP7_INC_IPROGRESS_H
+#define ZIP7_INC_IPROGRESS_H
+
+#include "../Common/MyTypes.h"
+
+#include "IDecl.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACEM_IProgress(x) \
+ x(SetTotal(UInt64 total)) \
+ x(SetCompleted(const UInt64 *completeValue)) \
+
+Z7_DECL_IFACE_7ZIP(IProgress, 0, 5)
+ { Z7_IFACE_COM7_PURE(IProgress) };
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/IStream.h b/CPP/7zip/IStream.h
index 436e919..4a58bc9 100644
--- a/CPP/7zip/IStream.h
+++ b/CPP/7zip/IStream.h
@@ -1,127 +1,207 @@
-// IStream.h
-
-#ifndef __ISTREAM_H
-#define __ISTREAM_H
-
-#include "../Common/MyTypes.h"
-#include "../Common/MyWindows.h"
-
-#include "IDecl.h"
-
-#define STREAM_INTERFACE_SUB(i, base, x) DECL_INTERFACE_SUB(i, base, 3, x)
-#define STREAM_INTERFACE(i, x) STREAM_INTERFACE_SUB(i, IUnknown, x)
-
-STREAM_INTERFACE(ISequentialInStream, 0x01)
-{
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;
-
- /*
- The requirement for caller: (processedSize != NULL).
- The callee can allow (processedSize == NULL) for compatibility reasons.
-
- if (size == 0), this function returns S_OK and (*processedSize) is set to 0.
-
- if (size != 0)
- {
- Partial read is allowed: (*processedSize <= avail_size && *processedSize <= size),
- where (avail_size) is the size of remaining bytes in stream.
- If (avail_size != 0), this function must read at least 1 byte: (*processedSize > 0).
- You must call Read() in loop, if you need to read exact amount of data.
- }
-
- If seek pointer before Read() call was changed to position past the end of stream:
- if (seek_pointer >= stream_size), this function returns S_OK and (*processedSize) is set to 0.
-
- ERROR CASES:
- If the function returns error code, then (*processedSize) is size of
- data written to (data) buffer (it can be data before error or data with errors).
- The recommended way for callee to work with reading errors:
- 1) write part of data before error to (data) buffer and return S_OK.
- 2) return error code for further calls of Read().
- */
-};
-
-STREAM_INTERFACE(ISequentialOutStream, 0x02)
-{
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;
-
- /*
- The requirement for caller: (processedSize != NULL).
- The callee can allow (processedSize == NULL) for compatibility reasons.
-
- if (size != 0)
- {
- Partial write is allowed: (*processedSize <= size),
- but this function must write at least 1 byte: (*processedSize > 0).
- You must call Write() in loop, if you need to write exact amount of data.
- }
-
- ERROR CASES:
- If the function returns error code, then (*processedSize) is size of
- data written from (data) buffer.
- */
-};
-
-#ifdef __HRESULT_FROM_WIN32
-#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
-#else
-#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
-#endif
-
-/* Seek() Function
- If you seek before the beginning of the stream, Seek() function returns error code:
- Recommended error code is __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK).
- or STG_E_INVALIDFUNCTION
-
- It is allowed to seek past the end of the stream.
-
-
- if Seek() returns error, then the value of *newPosition is undefined.
-*/
-
-STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)
-{
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
-};
-
-STREAM_INTERFACE_SUB(IOutStream, ISequentialOutStream, 0x04)
-{
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
- STDMETHOD(SetSize)(UInt64 newSize) PURE;
-};
-
-STREAM_INTERFACE(IStreamGetSize, 0x06)
-{
- STDMETHOD(GetSize)(UInt64 *size) PURE;
-};
-
-STREAM_INTERFACE(IOutStreamFinish, 0x07)
-{
- STDMETHOD(OutStreamFinish)() PURE;
-};
-
-
-STREAM_INTERFACE(IStreamGetProps, 0x08)
-{
- STDMETHOD(GetProps)(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib) PURE;
-};
-
-struct CStreamFileProps
-{
- UInt64 Size;
- UInt64 VolID;
- UInt64 FileID_Low;
- UInt64 FileID_High;
- UInt32 NumLinks;
- UInt32 Attrib;
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
-};
-
-STREAM_INTERFACE(IStreamGetProps2, 0x09)
-{
- STDMETHOD(GetProps2)(CStreamFileProps *props) PURE;
-};
-
-#endif
+// IStream.h
+
+#ifndef ZIP7_INC_ISTREAM_H
+#define ZIP7_INC_ISTREAM_H
+
+#include "../Common/MyTypes.h"
+#include "../Common/MyWindows.h"
+
+#include "IDecl.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACE_CONSTR_STREAM_SUB(i, base, n) \
+ Z7_DECL_IFACE_7ZIP_SUB(i, base, 3, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACE_CONSTR_STREAM(i, n) \
+ Z7_IFACE_CONSTR_STREAM_SUB(i, IUnknown, n)
+
+
+/*
+ISequentialInStream::Read()
+ The requirement for caller: (processedSize != NULL).
+ The callee can allow (processedSize == NULL) for compatibility reasons.
+
+ if (size == 0), this function returns S_OK and (*processedSize) is set to 0.
+
+ if (size != 0)
+ {
+ Partial read is allowed: (*processedSize <= avail_size && *processedSize <= size),
+ where (avail_size) is the size of remaining bytes in stream.
+ If (avail_size != 0), this function must read at least 1 byte: (*processedSize > 0).
+ You must call Read() in loop, if you need to read exact amount of data.
+ }
+
+ If seek pointer before Read() call was changed to position past the end of stream:
+ if (seek_pointer >= stream_size), this function returns S_OK and (*processedSize) is set to 0.
+
+ ERROR CASES:
+ If the function returns error code, then (*processedSize) is size of
+ data written to (data) buffer (it can be data before error or data with errors).
+ The recommended way for callee to work with reading errors:
+ 1) write part of data before error to (data) buffer and return S_OK.
+ 2) return error code for further calls of Read().
+*/
+#define Z7_IFACEM_ISequentialInStream(x) \
+ x(Read(void *data, UInt32 size, UInt32 *processedSize))
+Z7_IFACE_CONSTR_STREAM(ISequentialInStream, 0x01)
+
+
+/*
+ISequentialOutStream::Write()
+ The requirement for caller: (processedSize != NULL).
+ The callee can allow (processedSize == NULL) for compatibility reasons.
+
+ if (size != 0)
+ {
+ Partial write is allowed: (*processedSize <= size),
+ but this function must write at least 1 byte: (*processedSize > 0).
+ You must call Write() in loop, if you need to write exact amount of data.
+ }
+
+ ERROR CASES:
+ If the function returns error code, then (*processedSize) is size of
+ data written from (data) buffer.
+*/
+#define Z7_IFACEM_ISequentialOutStream(x) \
+ x(Write(const void *data, UInt32 size, UInt32 *processedSize))
+Z7_IFACE_CONSTR_STREAM(ISequentialOutStream, 0x02)
+
+
+#ifdef _WIN32
+
+#ifdef __HRESULT_FROM_WIN32
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
+#else
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
+#endif
+
+#else
+
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK MY_E_ERROR_NEGATIVE_SEEK
+
+#endif
+
+
+/*
+IInStream::Seek() / IOutStream::Seek()
+ If you seek to position before the beginning of the stream,
+ Seek() function returns error code:
+ Recommended error code is __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK).
+ or STG_E_INVALIDFUNCTION
+ It is allowed to seek past the end of the stream.
+ if Seek() returns error, then the value of *newPosition is undefined.
+*/
+
+#define Z7_IFACEM_IInStream(x) \
+ x(Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+Z7_IFACE_CONSTR_STREAM_SUB(IInStream, ISequentialInStream, 0x03)
+
+#define Z7_IFACEM_IOutStream(x) \
+ x(Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)) \
+ x(SetSize(UInt64 newSize))
+Z7_IFACE_CONSTR_STREAM_SUB(IOutStream, ISequentialOutStream, 0x04)
+
+#define Z7_IFACEM_IStreamGetSize(x) \
+ x(GetSize(UInt64 *size))
+Z7_IFACE_CONSTR_STREAM(IStreamGetSize, 0x06)
+
+#define Z7_IFACEM_IOutStreamFinish(x) \
+ x(OutStreamFinish())
+Z7_IFACE_CONSTR_STREAM(IOutStreamFinish, 0x07)
+
+#define Z7_IFACEM_IStreamGetProps(x) \
+ x(GetProps(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib))
+Z7_IFACE_CONSTR_STREAM(IStreamGetProps, 0x08)
+
+
+struct CStreamFileProps
+{
+ UInt64 Size;
+ UInt64 VolID;
+ UInt64 FileID_Low;
+ UInt64 FileID_High;
+ UInt32 NumLinks;
+ UInt32 Attrib;
+ FILETIME CTime;
+ FILETIME ATime;
+ FILETIME MTime;
+};
+
+
+#define Z7_IFACEM_IStreamGetProps2(x) \
+ x(GetProps2(CStreamFileProps *props))
+Z7_IFACE_CONSTR_STREAM(IStreamGetProps2, 0x09)
+
+#define Z7_IFACEM_IStreamGetProp(x) \
+ x(GetProperty(PROPID propID, PROPVARIANT *value)) \
+ x(ReloadProps())
+Z7_IFACE_CONSTR_STREAM(IStreamGetProp, 0x0a)
+
+
+/*
+IStreamSetRestriction::SetRestriction(UInt64 begin, UInt64 end)
+
+ It sets region of data in output stream that is restricted.
+ For restricted region it's expected (or allowed)
+ to change data with different calls of Write()/SetSize().
+ Another regions of output stream will be supposed as non-restricted:
+ - The callee usually doesn't flush the data in restricted region.
+ - The callee usually can flush data from non-restricted region.
+
+inputs:
+
+ (begin > end) is not allowed, and returns E_FAIL;
+
+ if (begin == end)
+ {
+ it means that there is no region restriction for flushing.
+ The callee is allowed to flush already written data and
+ is allowed to flush all data in future calls of
+ ISequentialOutStream::Write(), but before next call of SetRestriction().
+ The pair of values (begin == 0 && end == 0) is recommended to
+ remove all restrictions.
+ }
+
+ if (begin < end)
+ {
+ it means that callee must NOT to flush any data in region [begin, end).
+ The caller is allowed to Seek() to that region and rewrite the
+ data in that restriction region.
+ if (end == (UInt64(Int64)-1)
+ {
+ there is no upper bound for restricted region.
+ So non-restricted region will be [0, begin) in that case
+ }
+
+ Note: it's not expected that some already written region was marked as
+ non-restricted by old call SetRestriction() and later the part of
+ that region was marked as restricted with new call SetRestriction().
+ For example, for different calls with non-empty restricted regions:
+ (begin_new >= begin_old) is expected :
+ {
+ SetRestriction(begin_old, ...)
+ ...
+ SetRestriction(begin_new, ...)
+ }
+ }
+
+ returns:
+ - if (begin > end) it return ERROR code (E_FAIL)
+ - S_OK : if no errors.
+ - Also the call of SetRestriction() can initiate the flushing of already written data.
+ So it can return the result of that flushing.
+
+ Note: IOutStream::SetSize() also can change the data.
+ So it's not expected the call
+ IOutStream::SetSize() to unrestricted already written region.
+*/
+
+#define Z7_IFACEM_IStreamSetRestriction(x) \
+ x(SetRestriction(UInt64 begin, UInt64 end)) \
+
+Z7_IFACE_CONSTR_STREAM(IStreamSetRestriction, 0x10)
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/LzFindOpt.mak b/CPP/7zip/LzFindOpt.mak
new file mode 100644
index 0000000..169e10f
--- /dev/null
+++ b/CPP/7zip/LzFindOpt.mak
@@ -0,0 +1,7 @@
+!IF defined(USE_C_LZFINDOPT) || "$(PLATFORM)" != "x64"
+C_OBJS = $(C_OBJS) \
+ $O\LzFindOpt.obj
+!ELSE
+ASM_OBJS = $(ASM_OBJS) \
+ $O\LzFindOpt.obj
+!ENDIF
diff --git a/CPP/7zip/LzmaDec.mak b/CPP/7zip/LzmaDec.mak
index 9aa3086..3beb505 100644
--- a/CPP/7zip/LzmaDec.mak
+++ b/CPP/7zip/LzmaDec.mak
@@ -1,5 +1,7 @@
-!IF "$(PLATFORM)" == "x64"
-CFLAGS_C_SPEC = -D_LZMA_DEC_OPT
-ASM_OBJS = $(ASM_OBJS) \
- $O\LzmaDecOpt.obj
-!ENDIF
+!IF "$(PLATFORM)" == "x64"
+!IFNDEF NO_ASM
+CFLAGS_C_SPEC = -DZ7_LZMA_DEC_OPT
+ASM_OBJS = $(ASM_OBJS) \
+ $O\LzmaDecOpt.obj
+!ENDIF
+!ENDIF
diff --git a/CPP/7zip/LzmaDec_gcc.mak b/CPP/7zip/LzmaDec_gcc.mak
new file mode 100644
index 0000000..51924f5
--- /dev/null
+++ b/CPP/7zip/LzmaDec_gcc.mak
@@ -0,0 +1,14 @@
+ifdef USE_ASM
+ifdef IS_X64
+USE_LZMA_DEC_ASM=1
+endif
+ifdef IS_ARM64
+USE_LZMA_DEC_ASM=1
+endif
+endif
+
+ifdef USE_LZMA_DEC_ASM
+
+LZMA_DEC_OPT_OBJS= $O/LzmaDecOpt.o
+
+endif
diff --git a/CPP/7zip/MyVersion.h b/CPP/7zip/MyVersion.h
index 0d50f94..8f52a12 100644
--- a/CPP/7zip/MyVersion.h
+++ b/CPP/7zip/MyVersion.h
@@ -1,2 +1,2 @@
-#define USE_COPYRIGHT_CR
-#include "../../C/7zVersion.h"
+#define USE_COPYRIGHT_CR
+#include "../../C/7zVersion.h"
diff --git a/CPP/7zip/MyVersionInfo.rc b/CPP/7zip/MyVersionInfo.rc
index eddf893..fc63d79 100644
--- a/CPP/7zip/MyVersionInfo.rc
+++ b/CPP/7zip/MyVersionInfo.rc
@@ -1,2 +1,2 @@
-#include "MyVersion.h"
-#include "..\..\C\7zVersion.rc"
+#include "MyVersion.h"
+#include "../../C/7zVersion.rc"
diff --git a/CPP/7zip/PropID.h b/CPP/7zip/PropID.h
index 126af67..e074794 100644
--- a/CPP/7zip/PropID.h
+++ b/CPP/7zip/PropID.h
@@ -1,127 +1,178 @@
-// PropID.h
-
-#ifndef __7ZIP_PROP_ID_H
-#define __7ZIP_PROP_ID_H
-
-#include "../Common/MyTypes.h"
-
-enum
-{
- kpidNoProperty = 0,
- kpidMainSubfile,
- kpidHandlerItemIndex,
- kpidPath,
- kpidName,
- kpidExtension,
- kpidIsDir,
- kpidSize,
- kpidPackSize,
- kpidAttrib,
- kpidCTime,
- kpidATime,
- kpidMTime,
- kpidSolid,
- kpidCommented,
- kpidEncrypted,
- kpidSplitBefore,
- kpidSplitAfter,
- kpidDictionarySize,
- kpidCRC,
- kpidType,
- kpidIsAnti,
- kpidMethod,
- kpidHostOS,
- kpidFileSystem,
- kpidUser,
- kpidGroup,
- kpidBlock,
- kpidComment,
- kpidPosition,
- kpidPrefix,
- kpidNumSubDirs,
- kpidNumSubFiles,
- kpidUnpackVer,
- kpidVolume,
- kpidIsVolume,
- kpidOffset,
- kpidLinks,
- kpidNumBlocks,
- kpidNumVolumes,
- kpidTimeType,
- kpidBit64,
- kpidBigEndian,
- kpidCpu,
- kpidPhySize,
- kpidHeadersSize,
- kpidChecksum,
- kpidCharacts,
- kpidVa,
- kpidId,
- kpidShortName,
- kpidCreatorApp,
- kpidSectorSize,
- kpidPosixAttrib,
- kpidSymLink,
- kpidError,
- kpidTotalSize,
- kpidFreeSpace,
- kpidClusterSize,
- kpidVolumeName,
- kpidLocalName,
- kpidProvider,
- kpidNtSecure,
- kpidIsAltStream,
- kpidIsAux,
- kpidIsDeleted,
- kpidIsTree,
- kpidSha1,
- kpidSha256,
- kpidErrorType,
- kpidNumErrors,
- kpidErrorFlags,
- kpidWarningFlags,
- kpidWarning,
- kpidNumStreams,
- kpidNumAltStreams,
- kpidAltStreamsSize,
- kpidVirtualSize,
- kpidUnpackSize,
- kpidTotalPhySize,
- kpidVolumeIndex,
- kpidSubType,
- kpidShortComment,
- kpidCodePage,
- kpidIsNotArcType,
- kpidPhySizeCantBeDetected,
- kpidZerosTailIsAllowed,
- kpidTailSize,
- kpidEmbeddedStubSize,
- kpidNtReparse,
- kpidHardLink,
- kpidINode,
- kpidStreamId,
- kpidReadOnly,
- kpidOutName,
- kpidCopyLink,
-
- kpid_NUM_DEFINED,
-
- kpidUserDefined = 0x10000
-};
-
-extern const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED]; // VARTYPE
-
-const UInt32 kpv_ErrorFlags_IsNotArc = 1 << 0;
-const UInt32 kpv_ErrorFlags_HeadersError = 1 << 1;
-const UInt32 kpv_ErrorFlags_EncryptedHeadersError = 1 << 2;
-const UInt32 kpv_ErrorFlags_UnavailableStart = 1 << 3;
-const UInt32 kpv_ErrorFlags_UnconfirmedStart = 1 << 4;
-const UInt32 kpv_ErrorFlags_UnexpectedEnd = 1 << 5;
-const UInt32 kpv_ErrorFlags_DataAfterEnd = 1 << 6;
-const UInt32 kpv_ErrorFlags_UnsupportedMethod = 1 << 7;
-const UInt32 kpv_ErrorFlags_UnsupportedFeature = 1 << 8;
-const UInt32 kpv_ErrorFlags_DataError = 1 << 9;
-const UInt32 kpv_ErrorFlags_CrcError = 1 << 10;
-// const UInt32 kpv_ErrorFlags_Unsupported = 1 << 11;
-
-#endif
+// PropID.h
+
+#ifndef ZIP7_INC_7ZIP_PROP_ID_H
+#define ZIP7_INC_7ZIP_PROP_ID_H
+
+#include "../Common/MyTypes.h"
+
+enum
+{
+ kpidNoProperty = 0,
+ kpidMainSubfile,
+ kpidHandlerItemIndex,
+ kpidPath,
+ kpidName,
+ kpidExtension,
+ kpidIsDir,
+ kpidSize,
+ kpidPackSize,
+ kpidAttrib,
+ kpidCTime,
+ kpidATime,
+ kpidMTime,
+ kpidSolid,
+ kpidCommented,
+ kpidEncrypted,
+ kpidSplitBefore,
+ kpidSplitAfter,
+ kpidDictionarySize,
+ kpidCRC,
+ kpidType,
+ kpidIsAnti,
+ kpidMethod,
+ kpidHostOS,
+ kpidFileSystem,
+ kpidUser,
+ kpidGroup,
+ kpidBlock,
+ kpidComment,
+ kpidPosition,
+ kpidPrefix,
+ kpidNumSubDirs,
+ kpidNumSubFiles,
+ kpidUnpackVer,
+ kpidVolume,
+ kpidIsVolume,
+ kpidOffset,
+ kpidLinks,
+ kpidNumBlocks,
+ kpidNumVolumes,
+ kpidTimeType,
+ kpidBit64,
+ kpidBigEndian,
+ kpidCpu,
+ kpidPhySize,
+ kpidHeadersSize,
+ kpidChecksum,
+ kpidCharacts,
+ kpidVa,
+ kpidId,
+ kpidShortName,
+ kpidCreatorApp,
+ kpidSectorSize,
+ kpidPosixAttrib,
+ kpidSymLink,
+ kpidError,
+ kpidTotalSize,
+ kpidFreeSpace,
+ kpidClusterSize,
+ kpidVolumeName,
+ kpidLocalName,
+ kpidProvider,
+ kpidNtSecure,
+ kpidIsAltStream,
+ kpidIsAux,
+ kpidIsDeleted,
+ kpidIsTree,
+ kpidSha1,
+ kpidSha256,
+ kpidErrorType,
+ kpidNumErrors,
+ kpidErrorFlags,
+ kpidWarningFlags,
+ kpidWarning,
+ kpidNumStreams,
+ kpidNumAltStreams,
+ kpidAltStreamsSize,
+ kpidVirtualSize,
+ kpidUnpackSize,
+ kpidTotalPhySize,
+ kpidVolumeIndex,
+ kpidSubType,
+ kpidShortComment,
+ kpidCodePage,
+ kpidIsNotArcType,
+ kpidPhySizeCantBeDetected,
+ kpidZerosTailIsAllowed,
+ kpidTailSize,
+ kpidEmbeddedStubSize,
+ kpidNtReparse,
+ kpidHardLink,
+ kpidINode,
+ kpidStreamId,
+ kpidReadOnly,
+ kpidOutName,
+ kpidCopyLink,
+ kpidArcFileName,
+ kpidIsHash,
+ kpidChangeTime,
+ kpidUserId,
+ kpidGroupId,
+ kpidDeviceMajor,
+ kpidDeviceMinor,
+ kpidDevMajor,
+ kpidDevMinor,
+
+ kpid_NUM_DEFINED,
+
+ kpidUserDefined = 0x10000
+};
+
+extern const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED]; // VARTYPE
+
+const UInt32 kpv_ErrorFlags_IsNotArc = 1 << 0;
+const UInt32 kpv_ErrorFlags_HeadersError = 1 << 1;
+const UInt32 kpv_ErrorFlags_EncryptedHeadersError = 1 << 2;
+const UInt32 kpv_ErrorFlags_UnavailableStart = 1 << 3;
+const UInt32 kpv_ErrorFlags_UnconfirmedStart = 1 << 4;
+const UInt32 kpv_ErrorFlags_UnexpectedEnd = 1 << 5;
+const UInt32 kpv_ErrorFlags_DataAfterEnd = 1 << 6;
+const UInt32 kpv_ErrorFlags_UnsupportedMethod = 1 << 7;
+const UInt32 kpv_ErrorFlags_UnsupportedFeature = 1 << 8;
+const UInt32 kpv_ErrorFlags_DataError = 1 << 9;
+const UInt32 kpv_ErrorFlags_CrcError = 1 << 10;
+// const UInt32 kpv_ErrorFlags_Unsupported = 1 << 11;
+
+/*
+linux ctime :
+ file metadata was last changed.
+ changing the file modification time
+ counts as a metadata change, so will also have the side effect of updating the ctime.
+
+PROPVARIANT for timestamps in 7-Zip:
+{
+ vt = VT_FILETIME
+ wReserved1: set precision level
+ 0 : base value (backward compatibility value)
+ only filetime is used (7 digits precision).
+ wReserved2 and wReserved3 can contain random data
+ 1 : Unix (1 sec)
+ 2 : DOS (2 sec)
+ 3 : High Precision (1 ns)
+ 16 - 3 : (reserved) = 1 day
+ 16 - 2 : (reserved) = 1 hour
+ 16 - 1 : (reserved) = 1 minute
+ 16 + 0 : 1 sec (0 digits after point)
+ 16 + (1,2,3,4,5,6,7,8,9) : set subsecond precision level :
+ (number of decimal digits after point)
+ 16 + 9 : 1 ns (9 digits after point)
+ wReserved2 = ns % 100 : if (8 or 9 digits pecision)
+ = 0 : if not (8 or 9 digits pecision)
+ wReserved3 = 0;
+ filetime
+}
+
+NOTE: TAR-PAX archives created by GNU TAR don't keep
+ whole information about original level of precision,
+ and timestamp are stored in reduced form, where tail zero
+ digits after point are removed.
+ So 7-Zip can return different precision levels for different items for such TAR archives.
+*/
+
+/*
+TimePrec returned by IOutArchive::GetFileTimeType()
+is used only for updating, when we compare MTime timestamp
+from archive with timestamp from directory.
+*/
+
+#endif
diff --git a/CPP/7zip/Sha1.mak b/CPP/7zip/Sha1.mak
new file mode 100644
index 0000000..1b5f605
--- /dev/null
+++ b/CPP/7zip/Sha1.mak
@@ -0,0 +1,13 @@
+COMMON_OBJS = $(COMMON_OBJS) \
+ $O\Sha1Prepare.obj
+
+C_OBJS = $(C_OBJS) \
+ $O\Sha1.obj
+
+!IF defined(USE_C_SHA) || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+ $O\Sha1Opt.obj
+!ELSEIF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+ASM_OBJS = $(ASM_OBJS) \
+ $O\Sha1Opt.obj
+!ENDIF
diff --git a/CPP/7zip/Sha256.mak b/CPP/7zip/Sha256.mak
new file mode 100644
index 0000000..0bdbcb6
--- /dev/null
+++ b/CPP/7zip/Sha256.mak
@@ -0,0 +1,13 @@
+COMMON_OBJS = $(COMMON_OBJS) \
+ $O\Sha256Prepare.obj
+
+C_OBJS = $(C_OBJS) \
+ $O\Sha256.obj
+
+!IF defined(USE_C_SHA) || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
+C_OBJS = $(C_OBJS) \
+ $O\Sha256Opt.obj
+!ELSEIF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+ASM_OBJS = $(ASM_OBJS) \
+ $O\Sha256Opt.obj
+!ENDIF
diff --git a/CPP/7zip/SubBuild.mak b/CPP/7zip/SubBuild.mak
index 0c49d3b..f86ce43 100644
--- a/CPP/7zip/SubBuild.mak
+++ b/CPP/7zip/SubBuild.mak
@@ -1,3 +1,3 @@
- cd $(@D)
- $(MAKE) -nologo $(TARGETS)
- cd ..
+ cd $(@D)
+ $(MAKE) -nologo $(TARGETS)
+ cd ..
diff --git a/CPP/7zip/UI/Agent/Agent.cpp b/CPP/7zip/UI/Agent/Agent.cpp
new file mode 100644
index 0000000..6761b28
--- /dev/null
+++ b/CPP/7zip/UI/Agent/Agent.cpp
@@ -0,0 +1,1966 @@
+// Agent.cpp
+
+#include "StdAfx.h"
+
+#include <wchar.h>
+
+#include "../../../../C/Sort.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "../Common/ArchiveExtractCallback.h"
+#include "../FileManager/RegistryUtils.h"
+
+#include "Agent.h"
+
+using namespace NWindows;
+
+CCodecs *g_CodecsObj;
+
+static const bool k_keepEmptyDirPrefixes =
+ false; // 22.00
+ // true; // 21.07
+
+#ifdef Z7_EXTERNAL_CODECS
+ extern
+ CExternalCodecs g_ExternalCodecs;
+ CExternalCodecs g_ExternalCodecs;
+ extern
+ const CExternalCodecs *g_ExternalCodecs_Ptr;
+ const CExternalCodecs *g_ExternalCodecs_Ptr;
+ static CCodecs::CReleaser g_CodecsReleaser;
+#else
+ extern
+ CMyComPtr<IUnknown> g_CodecsRef;
+ CMyComPtr<IUnknown> g_CodecsRef;
+#endif
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+void FreeGlobalCodecs()
+{
+ MT_LOCK
+
+ #ifdef Z7_EXTERNAL_CODECS
+ if (g_CodecsObj)
+ {
+ g_CodecsObj->CloseLibs();
+ }
+ g_CodecsReleaser.Set(NULL);
+ g_CodecsObj = NULL;
+ g_ExternalCodecs.ClearAndRelease();
+ g_ExternalCodecs_Ptr = NULL;
+ #else
+ g_CodecsRef.Release();
+ #endif
+}
+
+HRESULT LoadGlobalCodecs()
+{
+ MT_LOCK
+
+ if (g_CodecsObj)
+ return S_OK;
+
+ g_CodecsObj = new CCodecs;
+
+ #ifdef Z7_EXTERNAL_CODECS
+ g_ExternalCodecs.GetCodecs = g_CodecsObj;
+ g_ExternalCodecs.GetHashers = g_CodecsObj;
+ g_CodecsReleaser.Set(g_CodecsObj);
+ #else
+ g_CodecsRef.Release();
+ g_CodecsRef = g_CodecsObj;
+ #endif
+
+ RINOK(g_CodecsObj->Load())
+ if (g_CodecsObj->Formats.IsEmpty())
+ {
+ FreeGlobalCodecs();
+ return E_NOTIMPL;
+ }
+
+ Codecs_AddHashArcHandler(g_CodecsObj);
+
+ #ifdef Z7_EXTERNAL_CODECS
+ RINOK(g_ExternalCodecs.Load())
+ g_ExternalCodecs_Ptr = &g_ExternalCodecs;
+ #endif
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetAgentFolder(CAgentFolder **agentFolder))
+{
+ *agentFolder = this;
+ return S_OK;
+}
+
+void CAgentFolder::LoadFolder(unsigned proxyDirIndex)
+{
+ CProxyItem item;
+ item.DirIndex = proxyDirIndex;
+
+ if (_proxy2)
+ {
+ const CProxyDir2 &dir = _proxy2->Dirs[proxyDirIndex];
+ FOR_VECTOR (i, dir.Items)
+ {
+ item.Index = i;
+ _items.Add(item);
+ const CProxyFile2 &file = _proxy2->Files[dir.Items[i]];
+ if (file.DirIndex != -1)
+ LoadFolder((unsigned)file.DirIndex);
+ if (_loadAltStreams && file.AltDirIndex != -1)
+ LoadFolder((unsigned)file.AltDirIndex);
+ }
+ return;
+ }
+
+ const CProxyDir &dir = _proxy->Dirs[proxyDirIndex];
+ unsigned i;
+ for (i = 0; i < dir.SubDirs.Size(); i++)
+ {
+ item.Index = i;
+ _items.Add(item);
+ LoadFolder(dir.SubDirs[i]);
+ }
+
+ unsigned start = dir.SubDirs.Size();
+ for (i = 0; i < dir.SubFiles.Size(); i++)
+ {
+ item.Index = start + i;
+ _items.Add(item);
+ }
+}
+
+Z7_COM7F_IMF(CAgentFolder::LoadItems())
+{
+ if (!_agentSpec->_archiveLink.IsOpen)
+ return E_FAIL;
+ _items.Clear();
+ if (_flatMode)
+ {
+ LoadFolder(_proxyDirIndex);
+ if (_proxy2 && _loadAltStreams)
+ {
+ if (_proxyDirIndex == k_Proxy2_RootDirIndex)
+ LoadFolder(k_Proxy2_AltRootDirIndex);
+ }
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetNumberOfItems(UInt32 *numItems))
+{
+ if (_flatMode)
+ *numItems = _items.Size();
+ else if (_proxy2)
+ *numItems = _proxy2->Dirs[_proxyDirIndex].Items.Size();
+ else
+ {
+ const CProxyDir *dir = &_proxy->Dirs[_proxyDirIndex];
+ *numItems = dir->SubDirs.Size() + dir->SubFiles.Size();
+ }
+ return S_OK;
+}
+
+#define SET_realIndex_AND_dir \
+ unsigned realIndex; const CProxyDir *dir; \
+ if (_flatMode) { const CProxyItem &item = _items[index]; dir = &_proxy->Dirs[item.DirIndex]; realIndex = item.Index; } \
+ else { dir = &_proxy->Dirs[_proxyDirIndex]; realIndex = index; }
+
+#define SET_realIndex_AND_dir_2 \
+ unsigned realIndex; const CProxyDir2 *dir; \
+ if (_flatMode) { const CProxyItem &item = _items[index]; dir = &_proxy2->Dirs[item.DirIndex]; realIndex = item.Index; } \
+ else { dir = &_proxy2->Dirs[_proxyDirIndex]; realIndex = index; }
+
+UString CAgentFolder::GetName(UInt32 index) const
+{
+ if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ return _proxy2->Files[dir->Items[realIndex]].Name;
+ }
+ SET_realIndex_AND_dir
+ if (realIndex < dir->SubDirs.Size())
+ return _proxy->Dirs[dir->SubDirs[realIndex]].Name;
+ return _proxy->Files[dir->SubFiles[realIndex - dir->SubDirs.Size()]].Name;
+}
+
+void CAgentFolder::GetPrefix(UInt32 index, UString &prefix) const
+{
+ if (!_flatMode)
+ {
+ prefix.Empty();
+ return;
+ }
+
+ const CProxyItem &item = _items[index];
+ unsigned proxyIndex = item.DirIndex;
+
+ if (_proxy2)
+ {
+ // that code is unused. 7-Zip gets prefix via GetItemPrefix() .
+
+ unsigned len = 0;
+ while (proxyIndex != _proxyDirIndex && proxyIndex >= k_Proxy2_NumRootDirs)
+ {
+ const CProxyFile2 &file = _proxy2->Files[(unsigned)_proxy2->Dirs[proxyIndex].ArcIndex];
+ len += file.NameLen + 1;
+ proxyIndex = (file.Parent == -1) ? 0 : (unsigned)_proxy2->Files[(unsigned)file.Parent].GetDirIndex(file.IsAltStream);
+ }
+
+ wchar_t *p = prefix.GetBuf_SetEnd(len) + len;
+ proxyIndex = item.DirIndex;
+ while (proxyIndex != _proxyDirIndex && proxyIndex >= k_Proxy2_NumRootDirs)
+ {
+ const CProxyFile2 &file = _proxy2->Files[(unsigned)_proxy2->Dirs[proxyIndex].ArcIndex];
+ p--;
+ *p = WCHAR_PATH_SEPARATOR;
+ p -= file.NameLen;
+ wmemcpy(p, file.Name, file.NameLen);
+ proxyIndex = (file.Parent == -1) ? 0 : (unsigned)_proxy2->Files[(unsigned)file.Parent].GetDirIndex(file.IsAltStream);
+ }
+ }
+ else
+ {
+ unsigned len = 0;
+ while (proxyIndex != _proxyDirIndex)
+ {
+ const CProxyDir *dir = &_proxy->Dirs[proxyIndex];
+ len += dir->NameLen + 1;
+ proxyIndex = (unsigned)dir->ParentDir;
+ }
+
+ wchar_t *p = prefix.GetBuf_SetEnd(len) + len;
+ proxyIndex = item.DirIndex;
+ while (proxyIndex != _proxyDirIndex)
+ {
+ const CProxyDir *dir = &_proxy->Dirs[proxyIndex];
+ p--;
+ *p = WCHAR_PATH_SEPARATOR;
+ p -= dir->NameLen;
+ wmemcpy(p, dir->Name, dir->NameLen);
+ proxyIndex = (unsigned)dir->ParentDir;
+ }
+ }
+}
+
+UString CAgentFolder::GetFullPrefix(UInt32 index) const
+{
+ unsigned foldIndex = _proxyDirIndex;
+
+ if (_flatMode)
+ foldIndex = _items[index].DirIndex;
+
+ if (_proxy2)
+ return _proxy2->Dirs[foldIndex].PathPrefix;
+ else
+ return _proxy->GetDirPath_as_Prefix(foldIndex);
+}
+
+Z7_COM7F_IMF2(UInt64, CAgentFolder::GetItemSize(UInt32 index))
+{
+ unsigned arcIndex;
+ if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ arcIndex = dir->Items[realIndex];
+ const CProxyFile2 &item = _proxy2->Files[arcIndex];
+ if (item.IsDir())
+ {
+ const CProxyDir2 &itemFolder = _proxy2->Dirs[item.DirIndex];
+ if (!_flatMode)
+ return itemFolder.Size;
+ }
+ }
+ else
+ {
+ SET_realIndex_AND_dir
+ if (realIndex < dir->SubDirs.Size())
+ {
+ const CProxyDir &item = _proxy->Dirs[dir->SubDirs[realIndex]];
+ if (!_flatMode)
+ return item.Size;
+ if (!item.IsLeaf())
+ return 0;
+ arcIndex = (unsigned)item.ArcIndex;
+ }
+ else
+ {
+ arcIndex = dir->SubFiles[realIndex - dir->SubDirs.Size()];
+ }
+ }
+ NCOM::CPropVariant prop;
+ _agentSpec->GetArchive()->GetProperty(arcIndex, kpidSize, &prop);
+ if (prop.vt == VT_UI8)
+ return prop.uhVal.QuadPart;
+ else
+ return 0;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ if (propID == kpidPrefix)
+ {
+ if (_flatMode)
+ {
+ UString prefix;
+ GetPrefix(index, prefix);
+ prop = prefix;
+ }
+ }
+ else if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ unsigned arcIndex = dir->Items[realIndex];
+ const CProxyFile2 &item = _proxy2->Files[arcIndex];
+ /*
+ if (propID == kpidNumAltStreams)
+ {
+ if (item.AltDirIndex != -1)
+ prop = _proxy2->Dirs[item.AltDirIndex].Items.Size();
+ }
+ else
+ */
+ if (!item.IsDir())
+ {
+ switch (propID)
+ {
+ case kpidIsDir: prop = false; break;
+ case kpidName: prop = item.Name; break;
+ default: return _agentSpec->GetArchive()->GetProperty(arcIndex, propID, value);
+ }
+ }
+ else
+ {
+ const CProxyDir2 &itemFolder = _proxy2->Dirs[item.DirIndex];
+ if (!_flatMode && propID == kpidSize)
+ prop = itemFolder.Size;
+ else if (!_flatMode && propID == kpidPackSize)
+ prop = itemFolder.PackSize;
+ else switch (propID)
+ {
+ case kpidIsDir: prop = true; break;
+ case kpidNumSubDirs: prop = itemFolder.NumSubDirs; break;
+ case kpidNumSubFiles: prop = itemFolder.NumSubFiles; break;
+ case kpidName: prop = item.Name; break;
+ case kpidCRC:
+ {
+ // if (itemFolder.IsLeaf)
+ if (!item.Ignore)
+ {
+ RINOK(_agentSpec->GetArchive()->GetProperty(arcIndex, propID, value))
+ }
+ if (itemFolder.CrcIsDefined && value->vt == VT_EMPTY)
+ prop = itemFolder.Crc;
+ break;
+ }
+ default:
+ // if (itemFolder.IsLeaf)
+ if (!item.Ignore)
+ return _agentSpec->GetArchive()->GetProperty(arcIndex, propID, value);
+ }
+ }
+ }
+ else
+ {
+ SET_realIndex_AND_dir
+ if (realIndex < dir->SubDirs.Size())
+ {
+ const CProxyDir &item = _proxy->Dirs[dir->SubDirs[realIndex]];
+ if (!_flatMode && propID == kpidSize)
+ prop = item.Size;
+ else if (!_flatMode && propID == kpidPackSize)
+ prop = item.PackSize;
+ else
+ switch (propID)
+ {
+ case kpidIsDir: prop = true; break;
+ case kpidNumSubDirs: prop = item.NumSubDirs; break;
+ case kpidNumSubFiles: prop = item.NumSubFiles; break;
+ case kpidName: prop = item.Name; break;
+ case kpidCRC:
+ {
+ if (item.IsLeaf())
+ {
+ RINOK(_agentSpec->GetArchive()->GetProperty((unsigned)item.ArcIndex, propID, value))
+ }
+ if (item.CrcIsDefined && value->vt == VT_EMPTY)
+ prop = item.Crc;
+ break;
+ }
+ default:
+ if (item.IsLeaf())
+ return _agentSpec->GetArchive()->GetProperty((unsigned)item.ArcIndex, propID, value);
+ }
+ }
+ else
+ {
+ unsigned arcIndex = dir->SubFiles[realIndex - dir->SubDirs.Size()];
+ switch (propID)
+ {
+ case kpidIsDir: prop = false; break;
+ case kpidName: prop = _proxy->Files[arcIndex].Name; break;
+ default:
+ return _agentSpec->GetArchive()->GetProperty(arcIndex, propID, value);
+ }
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+static UInt64 GetUInt64Prop(IInArchive *archive, UInt32 index, PROPID propID)
+{
+ NCOM::CPropVariant prop;
+ if (archive->GetProperty(index, propID, &prop) != S_OK)
+ throw 111233443;
+ UInt64 v = 0;
+ if (ConvertPropVariantToUInt64(prop, v))
+ return v;
+ return 0;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetItemName(UInt32 index, const wchar_t **name, unsigned *len))
+{
+ if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ unsigned arcIndex = dir->Items[realIndex];
+ const CProxyFile2 &item = _proxy2->Files[arcIndex];
+ *name = item.Name;
+ *len = item.NameLen;
+ return S_OK;
+ }
+ else
+ {
+ SET_realIndex_AND_dir
+ if (realIndex < dir->SubDirs.Size())
+ {
+ const CProxyDir &item = _proxy->Dirs[dir->SubDirs[realIndex]];
+ *name = item.Name;
+ *len = item.NameLen;
+ return S_OK;
+ }
+ else
+ {
+ const CProxyFile &item = _proxy->Files[dir->SubFiles[realIndex - dir->SubDirs.Size()]];
+ *name = item.Name;
+ *len = item.NameLen;
+ return S_OK;
+ }
+ }
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetItemPrefix(UInt32 index, const wchar_t **name, unsigned *len))
+{
+ *name = NULL;
+ *len = 0;
+ if (!_flatMode)
+ return S_OK;
+
+ if (_proxy2)
+ {
+ const CProxyItem &item = _items[index];
+ const UString &s = _proxy2->Dirs[item.DirIndex].PathPrefix;
+ unsigned baseLen = _proxy2->Dirs[_proxyDirIndex].PathPrefix.Len();
+ if (baseLen <= s.Len())
+ {
+ *name = (const wchar_t *)s + baseLen;
+ *len = s.Len() - baseLen;
+ }
+ else
+ {
+ return E_FAIL;
+ // throw 111l;
+ }
+ }
+ return S_OK;
+}
+
+static int CompareRawProps(IArchiveGetRawProps *rawProps, unsigned arcIndex1, unsigned arcIndex2, PROPID propID)
+{
+ // if (propID == kpidSha1)
+ if (rawProps)
+ {
+ const void *p1, *p2;
+ UInt32 size1, size2;
+ UInt32 propType1, propType2;
+ const HRESULT res1 = rawProps->GetRawProp(arcIndex1, propID, &p1, &size1, &propType1);
+ const HRESULT res2 = rawProps->GetRawProp(arcIndex2, propID, &p2, &size2, &propType2);
+ if (res1 == S_OK && res2 == S_OK)
+ {
+ for (UInt32 i = 0; i < size1 && i < size2; i++)
+ {
+ const Byte b1 = ((const Byte *)p1)[i];
+ const Byte b2 = ((const Byte *)p2)[i];
+ if (b1 < b2) return -1;
+ if (b1 > b2) return 1;
+ }
+ if (size1 < size2) return -1;
+ if (size1 > size2) return 1;
+ return 0;
+ }
+ }
+ return 0;
+}
+
+// returns pointer to extension including '.'
+
+static const wchar_t *GetExtension(const wchar_t *name)
+{
+ for (const wchar_t *dotPtr = NULL;; name++)
+ {
+ wchar_t c = *name;
+ if (c == 0)
+ return dotPtr ? dotPtr : name;
+ if (c == '.')
+ dotPtr = name;
+ }
+}
+
+
+int CAgentFolder::CompareItems3(UInt32 index1, UInt32 index2, PROPID propID)
+{
+ NCOM::CPropVariant prop1, prop2;
+ // Name must be first property
+ GetProperty(index1, propID, &prop1);
+ GetProperty(index2, propID, &prop2);
+ if (prop1.vt != prop2.vt)
+ return MyCompare(prop1.vt, prop2.vt);
+ if (prop1.vt == VT_BSTR)
+ return MyStringCompareNoCase(prop1.bstrVal, prop2.bstrVal);
+ return prop1.Compare(prop2);
+}
+
+
+int CAgentFolder::CompareItems2(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw)
+{
+ unsigned realIndex1, realIndex2;
+ const CProxyDir2 *dir1, *dir2;
+
+ if (_flatMode)
+ {
+ const CProxyItem &item1 = _items[index1];
+ const CProxyItem &item2 = _items[index2];
+ dir1 = &_proxy2->Dirs[item1.DirIndex];
+ dir2 = &_proxy2->Dirs[item2.DirIndex];
+ realIndex1 = item1.Index;
+ realIndex2 = item2.Index;
+ }
+ else
+ {
+ dir2 = dir1 = &_proxy2->Dirs[_proxyDirIndex];
+ realIndex1 = index1;
+ realIndex2 = index2;
+ }
+
+ UInt32 arcIndex1;
+ UInt32 arcIndex2;
+ bool isDir1, isDir2;
+ arcIndex1 = dir1->Items[realIndex1];
+ arcIndex2 = dir2->Items[realIndex2];
+ const CProxyFile2 &prox1 = _proxy2->Files[arcIndex1];
+ const CProxyFile2 &prox2 = _proxy2->Files[arcIndex2];
+
+ if (propID == kpidName)
+ {
+ return CompareFileNames_ForFolderList(prox1.Name, prox2.Name);
+ }
+
+ if (propID == kpidPrefix)
+ {
+ if (!_flatMode)
+ return 0;
+ return CompareFileNames_ForFolderList(
+ _proxy2->Dirs[_items[index1].DirIndex].PathPrefix,
+ _proxy2->Dirs[_items[index2].DirIndex].PathPrefix);
+ }
+
+ if (propID == kpidExtension)
+ {
+ return CompareFileNames_ForFolderList(
+ GetExtension(prox1.Name),
+ GetExtension(prox2.Name));
+ }
+
+ isDir1 = prox1.IsDir();
+ isDir2 = prox2.IsDir();
+
+ if (propID == kpidIsDir)
+ {
+ if (isDir1 == isDir2)
+ return 0;
+ return isDir1 ? -1 : 1;
+ }
+
+ const CProxyDir2 *proxFolder1 = NULL;
+ const CProxyDir2 *proxFolder2 = NULL;
+ if (isDir1) proxFolder1 = &_proxy2->Dirs[prox1.DirIndex];
+ if (isDir2) proxFolder2 = &_proxy2->Dirs[prox2.DirIndex];
+
+ if (propID == kpidNumSubDirs)
+ {
+ UInt32 n1 = 0;
+ UInt32 n2 = 0;
+ if (isDir1) n1 = proxFolder1->NumSubDirs;
+ if (isDir2) n2 = proxFolder2->NumSubDirs;
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidNumSubFiles)
+ {
+ UInt32 n1 = 0;
+ UInt32 n2 = 0;
+ if (isDir1) n1 = proxFolder1->NumSubFiles;
+ if (isDir2) n2 = proxFolder2->NumSubFiles;
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidSize)
+ {
+ UInt64 n1, n2;
+ if (isDir1)
+ n1 = _flatMode ? 0 : proxFolder1->Size;
+ else
+ n1 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex1, kpidSize);
+ if (isDir2)
+ n2 = _flatMode ? 0 : proxFolder2->Size;
+ else
+ n2 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex2, kpidSize);
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidPackSize)
+ {
+ UInt64 n1, n2;
+ if (isDir1)
+ n1 = _flatMode ? 0 : proxFolder1->PackSize;
+ else
+ n1 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex1, kpidPackSize);
+ if (isDir2)
+ n2 = _flatMode ? 0 : proxFolder2->PackSize;
+ else
+ n2 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex2, kpidPackSize);
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidCRC)
+ {
+ UInt64 n1, n2;
+ if (!isDir1 || !prox1.Ignore)
+ n1 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex1, kpidCRC);
+ else
+ n1 = proxFolder1->Crc;
+ if (!isDir2 || !prox2.Ignore)
+ n2 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex2, kpidCRC);
+ else
+ n2 = proxFolder2->Crc;
+ return MyCompare(n1, n2);
+ }
+
+ if (propIsRaw)
+ return CompareRawProps(_agentSpec->_archiveLink.GetArchiveGetRawProps(), arcIndex1, arcIndex2, propID);
+
+ return CompareItems3(index1, index2, propID);
+}
+
+
+Z7_COM7F_IMF2(Int32, CAgentFolder::CompareItems(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw))
+{
+ try {
+ if (_proxy2)
+ return CompareItems2(index1, index2, propID, propIsRaw);
+
+ unsigned realIndex1, realIndex2;
+ const CProxyDir *dir1, *dir2;
+
+ if (_flatMode)
+ {
+ const CProxyItem &item1 = _items[index1];
+ const CProxyItem &item2 = _items[index2];
+ dir1 = &_proxy->Dirs[item1.DirIndex];
+ dir2 = &_proxy->Dirs[item2.DirIndex];
+ realIndex1 = item1.Index;
+ realIndex2 = item2.Index;
+ }
+ else
+ {
+ dir2 = dir1 = &_proxy->Dirs[_proxyDirIndex];
+ realIndex1 = index1;
+ realIndex2 = index2;
+ }
+
+ if (propID == kpidPrefix)
+ {
+ if (!_flatMode)
+ return 0;
+ UString prefix1, prefix2;
+ GetPrefix(index1, prefix1);
+ GetPrefix(index2, prefix2);
+ return CompareFileNames_ForFolderList(prefix1, prefix2);
+ }
+
+ UInt32 arcIndex1;
+ UInt32 arcIndex2;
+
+ const CProxyDir *proxFolder1 = NULL;
+ const CProxyDir *proxFolder2 = NULL;
+
+ if (realIndex1 < dir1->SubDirs.Size())
+ {
+ proxFolder1 = &_proxy->Dirs[dir1->SubDirs[realIndex1]];
+ arcIndex1 = (unsigned)proxFolder1->ArcIndex;
+ }
+ else
+ arcIndex1 = dir1->SubFiles[realIndex1 - dir1->SubDirs.Size()];
+
+ if (realIndex2 < dir2->SubDirs.Size())
+ {
+ proxFolder2 = &_proxy->Dirs[dir2->SubDirs[realIndex2]];
+ arcIndex2 = (unsigned)proxFolder2->ArcIndex;
+ }
+ else
+ arcIndex2 = dir2->SubFiles[realIndex2 - dir2->SubDirs.Size()];
+
+ if (propID == kpidName)
+ return CompareFileNames_ForFolderList(
+ proxFolder1 ? proxFolder1->Name : _proxy->Files[arcIndex1].Name,
+ proxFolder2 ? proxFolder2->Name : _proxy->Files[arcIndex2].Name);
+
+ if (propID == kpidExtension)
+ return CompareFileNames_ForFolderList(
+ GetExtension(proxFolder1 ? proxFolder1->Name : _proxy->Files[arcIndex1].Name),
+ GetExtension(proxFolder2 ? proxFolder2->Name : _proxy->Files[arcIndex2].Name));
+
+ if (propID == kpidIsDir)
+ {
+ if (proxFolder1)
+ return proxFolder2 ? 0 : -1;
+ return proxFolder2 ? 1 : 0;
+ }
+
+ if (propID == kpidNumSubDirs)
+ {
+ UInt32 n1 = 0;
+ UInt32 n2 = 0;
+ if (proxFolder1) n1 = proxFolder1->NumSubDirs;
+ if (proxFolder2) n2 = proxFolder2->NumSubDirs;
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidNumSubFiles)
+ {
+ UInt32 n1 = 0;
+ UInt32 n2 = 0;
+ if (proxFolder1) n1 = proxFolder1->NumSubFiles;
+ if (proxFolder2) n2 = proxFolder2->NumSubFiles;
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidSize)
+ {
+ UInt64 n1, n2;
+ if (proxFolder1)
+ n1 = _flatMode ? 0 : proxFolder1->Size;
+ else
+ n1 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex1, kpidSize);
+ if (proxFolder2)
+ n2 = _flatMode ? 0 : proxFolder2->Size;
+ else
+ n2 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex2, kpidSize);
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidPackSize)
+ {
+ UInt64 n1, n2;
+ if (proxFolder1)
+ n1 = _flatMode ? 0 : proxFolder1->PackSize;
+ else
+ n1 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex1, kpidPackSize);
+ if (proxFolder2)
+ n2 = _flatMode ? 0 : proxFolder2->PackSize;
+ else
+ n2 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex2, kpidPackSize);
+ return MyCompare(n1, n2);
+ }
+
+ if (propID == kpidCRC)
+ {
+ UInt64 n1, n2;
+ if (proxFolder1 && !proxFolder1->IsLeaf())
+ n1 = proxFolder1->Crc;
+ else
+ n1 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex1, kpidCRC);
+ if (proxFolder2 && !proxFolder2->IsLeaf())
+ n2 = proxFolder2->Crc;
+ else
+ n2 = GetUInt64Prop(_agentSpec->GetArchive(), arcIndex2, kpidCRC);
+ return MyCompare(n1, n2);
+ }
+
+ if (propIsRaw)
+ {
+ bool isVirt1 = (proxFolder1 && !proxFolder1->IsLeaf());
+ bool isVirt2 = (proxFolder2 && !proxFolder2->IsLeaf());
+ if (isVirt1)
+ return isVirt2 ? 0 : -1;
+ if (isVirt2)
+ return 1;
+ return CompareRawProps(_agentSpec->_archiveLink.GetArchiveGetRawProps(), arcIndex1, arcIndex2, propID);
+ }
+
+ return CompareItems3(index1, index2, propID);
+
+ } catch(...) { return 0; }
+}
+
+
+HRESULT CAgentFolder::BindToFolder_Internal(unsigned proxyDirIndex, IFolderFolder **resultFolder)
+{
+ /*
+ CMyComPtr<IFolderFolder> parentFolder;
+
+ if (_proxy2)
+ {
+ const CProxyDir2 &dir = _proxy2->Dirs[proxyDirIndex];
+ int par = _proxy2->GetParentFolderOfFile(dir.ArcIndex);
+ if (par != (int)_proxyDirIndex)
+ {
+ RINOK(BindToFolder_Internal(par, &parentFolder));
+ }
+ else
+ parentFolder = this;
+ }
+ else
+ {
+ const CProxyDir &dir = _proxy->Dirs[proxyDirIndex];
+ if (dir.Parent != (int)_proxyDirIndex)
+ {
+ RINOK(BindToFolder_Internal(dir.Parent, &parentFolder));
+ }
+ else
+ parentFolder = this;
+ }
+ */
+ CAgentFolder *folderSpec = new CAgentFolder;
+ CMyComPtr<IFolderFolder> agentFolder = folderSpec;
+ folderSpec->Init(_proxy, _proxy2, proxyDirIndex, /* parentFolder, */ _agentSpec);
+ *resultFolder = agentFolder.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgentFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder))
+{
+ COM_TRY_BEGIN
+ if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ const unsigned arcIndex = dir->Items[realIndex];
+ const CProxyFile2 &item = _proxy2->Files[arcIndex];
+ if (!item.IsDir())
+ return E_INVALIDARG;
+ return BindToFolder_Internal((unsigned)item.DirIndex, resultFolder);
+ }
+ SET_realIndex_AND_dir
+ if (realIndex >= (UInt32)dir->SubDirs.Size())
+ return E_INVALIDARG;
+ return BindToFolder_Internal(dir->SubDirs[realIndex], resultFolder);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder))
+{
+ COM_TRY_BEGIN
+ if (_proxy2)
+ {
+ const int index = _proxy2->FindItem(_proxyDirIndex, name, true);
+ if (index == -1)
+ return E_INVALIDARG;
+ return BindToFolder_Internal((unsigned)_proxy2->Files[_proxy2->Dirs[_proxyDirIndex].Items[index]].DirIndex, resultFolder);
+ }
+ const int index = _proxy->FindSubDir(_proxyDirIndex, name);
+ if (index == -1)
+ return E_INVALIDARG;
+ return BindToFolder_Internal((unsigned)index, resultFolder);
+ COM_TRY_END
+}
+
+
+
+// ---------- IFolderAltStreams ----------
+
+HRESULT CAgentFolder::BindToAltStreams_Internal(unsigned proxyDirIndex, IFolderFolder **resultFolder)
+{
+ *resultFolder = NULL;
+ if (!_proxy2)
+ return S_OK;
+
+ /*
+ CMyComPtr<IFolderFolder> parentFolder;
+
+ int par = _proxy2->GetParentFolderOfFile(_proxy2->Dirs[proxyDirIndex].ArcIndex);
+ if (par != (int)_proxyDirIndex)
+ {
+ RINOK(BindToFolder_Internal(par, &parentFolder));
+ if (!parentFolder)
+ return S_OK;
+ }
+ else
+ parentFolder = this;
+ */
+
+ CAgentFolder *folderSpec = new CAgentFolder;
+ CMyComPtr<IFolderFolder> agentFolder = folderSpec;
+ folderSpec->Init(_proxy, _proxy2, proxyDirIndex, /* parentFolder, */ _agentSpec);
+ *resultFolder = agentFolder.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgentFolder::BindToAltStreams(UInt32 index, IFolderFolder **resultFolder))
+{
+ COM_TRY_BEGIN
+
+ *resultFolder = NULL;
+
+ if (!_proxy2)
+ return S_OK;
+
+ if (_proxy2->IsAltDir(_proxyDirIndex))
+ return S_OK;
+
+ {
+ if (index == (UInt32)(Int32)-1)
+ {
+ unsigned altDirIndex;
+ // IFolderFolder *parentFolder;
+
+ if (_proxyDirIndex == k_Proxy2_RootDirIndex)
+ {
+ altDirIndex = k_Proxy2_AltRootDirIndex;
+ // parentFolder = this; // we want to use Root dir as parent for alt root
+ }
+ else
+ {
+ const unsigned arcIndex = (unsigned)_proxy2->Dirs[_proxyDirIndex].ArcIndex;
+ const CProxyFile2 &item = _proxy2->Files[arcIndex];
+ if (item.AltDirIndex == -1)
+ return S_OK;
+ altDirIndex = (unsigned)item.AltDirIndex;
+ // parentFolder = _parentFolder;
+ }
+
+ CAgentFolder *folderSpec = new CAgentFolder;
+ CMyComPtr<IFolderFolder> agentFolder = folderSpec;
+ folderSpec->Init(_proxy, _proxy2, altDirIndex, /* parentFolder, */ _agentSpec);
+ *resultFolder = agentFolder.Detach();
+ return S_OK;
+ }
+
+ SET_realIndex_AND_dir_2
+ const unsigned arcIndex = dir->Items[realIndex];
+ const CProxyFile2 &item = _proxy2->Files[arcIndex];
+ if (item.AltDirIndex == -1)
+ return S_OK;
+ return BindToAltStreams_Internal((unsigned)item.AltDirIndex, resultFolder);
+ }
+
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::BindToAltStreams(const wchar_t *name, IFolderFolder **resultFolder))
+{
+ COM_TRY_BEGIN
+
+ *resultFolder = NULL;
+
+ if (!_proxy2)
+ return S_OK;
+
+ if (_proxy2->IsAltDir(_proxyDirIndex))
+ return S_OK;
+
+ if (name[0] == 0)
+ return BindToAltStreams((UInt32)(Int32)-1, resultFolder);
+
+ {
+ const CProxyDir2 &dir = _proxy2->Dirs[_proxyDirIndex];
+ FOR_VECTOR (i, dir.Items)
+ {
+ const CProxyFile2 &file = _proxy2->Files[dir.Items[i]];
+ if (file.AltDirIndex != -1)
+ if (CompareFileNames(file.Name, name) == 0)
+ return BindToAltStreams_Internal((unsigned)file.AltDirIndex, resultFolder);
+ }
+ return E_INVALIDARG;
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::AreAltStreamsSupported(UInt32 index, Int32 *isSupported))
+{
+ *isSupported = BoolToInt(false);
+
+ if (!_proxy2)
+ return S_OK;
+
+ if (_proxy2->IsAltDir(_proxyDirIndex))
+ return S_OK;
+
+ unsigned arcIndex;
+
+ if (index == (UInt32)(Int32)-1)
+ {
+ if (_proxyDirIndex == k_Proxy2_RootDirIndex)
+ {
+ *isSupported = BoolToInt(true);
+ return S_OK;
+ }
+ arcIndex = (unsigned)_proxy2->Dirs[_proxyDirIndex].ArcIndex;
+ }
+ else
+ {
+ SET_realIndex_AND_dir_2
+ arcIndex = dir->Items[realIndex];
+ }
+
+ if (_proxy2->Files[arcIndex].AltDirIndex != -1)
+ *isSupported = BoolToInt(true);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CAgentFolder::BindToParentFolder(IFolderFolder **resultFolder))
+{
+ COM_TRY_BEGIN
+ /*
+ CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+ *resultFolder = parentFolder.Detach();
+ */
+ *resultFolder = NULL;
+
+ unsigned proxyDirIndex;
+
+ if (_proxy2)
+ {
+ if (_proxyDirIndex == k_Proxy2_RootDirIndex)
+ return S_OK;
+ if (_proxyDirIndex == k_Proxy2_AltRootDirIndex)
+ proxyDirIndex = k_Proxy2_RootDirIndex;
+ else
+ {
+ const CProxyDir2 &fold = _proxy2->Dirs[_proxyDirIndex];
+ const CProxyFile2 &file = _proxy2->Files[(unsigned)fold.ArcIndex];
+ const int parentIndex = file.Parent;
+ if (parentIndex == -1)
+ proxyDirIndex = k_Proxy2_RootDirIndex;
+ else
+ proxyDirIndex = (unsigned)_proxy2->Files[(unsigned)parentIndex].DirIndex;
+ }
+ }
+ else
+ {
+ const int parent = _proxy->Dirs[_proxyDirIndex].ParentDir;
+ if (parent == -1)
+ return S_OK;
+ proxyDirIndex = (unsigned)parent;
+ }
+
+ CAgentFolder *folderSpec = new CAgentFolder;
+ CMyComPtr<IFolderFolder> agentFolder = folderSpec;
+ folderSpec->Init(_proxy, _proxy2, proxyDirIndex, /* parentFolder, */ _agentSpec);
+ *resultFolder = agentFolder.Detach();
+
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IInArchiveGetStream,
+ getStream, _agentSpec->GetArchive())
+ if (!getStream)
+ return S_OK;
+
+ UInt32 arcIndex;
+ if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ arcIndex = dir->Items[realIndex];
+ }
+ else
+ {
+ SET_realIndex_AND_dir
+
+ if (realIndex < dir->SubDirs.Size())
+ {
+ const CProxyDir &item = _proxy->Dirs[dir->SubDirs[realIndex]];
+ if (!item.IsLeaf())
+ return S_OK;
+ arcIndex = (unsigned)item.ArcIndex;
+ }
+ else
+ arcIndex = dir->SubFiles[realIndex - dir->SubDirs.Size()];
+ }
+ return getStream->GetStream(arcIndex, stream);
+}
+
+// static const unsigned k_FirstOptionalProp = 2;
+
+static const PROPID kProps[] =
+{
+ kpidNumSubDirs,
+ kpidNumSubFiles,
+
+ // kpidNumAltStreams,
+ kpidPrefix
+};
+
+struct CArchiveItemPropertyTemp
+{
+ UString Name;
+ PROPID ID;
+ VARTYPE Type;
+};
+
+Z7_COM7F_IMF(CAgentFolder::GetNumberOfProperties(UInt32 *numProps))
+{
+ COM_TRY_BEGIN
+ RINOK(_agentSpec->GetArchive()->GetNumberOfProperties(numProps))
+ *numProps += Z7_ARRAY_SIZE(kProps);
+ if (!_flatMode)
+ (*numProps)--;
+ /*
+ if (!_agentSpec->ThereIsAltStreamProp)
+ (*numProps)--;
+ */
+ /*
+ bool thereIsPathProp = _proxy2 ?
+ _agentSpec->_proxy2->ThereIsPathProp :
+ _agentSpec->_proxy->ThereIsPathProp;
+ */
+
+ // if there is kpidPath, we change kpidPath to kpidName
+ // if there is no kpidPath, we add kpidName.
+ if (!_agentSpec->ThereIsPathProp)
+ (*numProps)++;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType))
+{
+ COM_TRY_BEGIN
+ UInt32 numProps;
+ _agentSpec->GetArchive()->GetNumberOfProperties(&numProps);
+
+ /*
+ bool thereIsPathProp = _proxy2 ?
+ _agentSpec->_proxy2->ThereIsPathProp :
+ _agentSpec->_proxy->ThereIsPathProp;
+ */
+
+ if (!_agentSpec->ThereIsPathProp)
+ {
+ if (index == 0)
+ {
+ *propID = kpidName;
+ *varType = VT_BSTR;
+ *name = NULL;
+ return S_OK;
+ }
+ index--;
+ }
+
+ if (index < numProps)
+ {
+ RINOK(_agentSpec->GetArchive()->GetPropertyInfo(index, name, propID, varType))
+ if (*propID == kpidPath)
+ *propID = kpidName;
+ }
+ else
+ {
+ index -= numProps;
+ /*
+ if (index >= k_FirstOptionalProp)
+ {
+ if (!_agentSpec->ThereIsAltStreamProp)
+ index++;
+ }
+ */
+ *propID = kProps[index];
+ *varType = k7z_PROPID_To_VARTYPE[(unsigned)*propID];
+ *name = NULL;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+static const PROPID kFolderProps[] =
+{
+ kpidSize,
+ kpidPackSize,
+ kpidNumSubDirs,
+ kpidNumSubFiles,
+ kpidCRC
+};
+
+Z7_COM7F_IMF(CAgentFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+
+ NWindows::NCOM::CPropVariant prop;
+
+ if (propID == kpidReadOnly)
+ {
+ if (_agentSpec->Is_Attrib_ReadOnly())
+ prop = true;
+ else
+ prop = _agentSpec->IsThere_ReadOnlyArc();
+ }
+ else if (propID == kpidIsHash)
+ {
+ prop = _agentSpec->_isHashHandler;
+ }
+ else if (_proxy2)
+ {
+ const CProxyDir2 &dir = _proxy2->Dirs[_proxyDirIndex];
+ if (propID == kpidName)
+ {
+ if (dir.ArcIndex != -1)
+ prop = _proxy2->Files[(unsigned)dir.ArcIndex].Name;
+ }
+ else if (propID == kpidPath)
+ {
+ bool isAltStreamFolder = false;
+ prop = _proxy2->GetDirPath_as_Prefix(_proxyDirIndex, isAltStreamFolder);
+ }
+ else switch (propID)
+ {
+ case kpidSize: prop = dir.Size; break;
+ case kpidPackSize: prop = dir.PackSize; break;
+ case kpidNumSubDirs: prop = dir.NumSubDirs; break;
+ case kpidNumSubFiles: prop = dir.NumSubFiles; break;
+ // case kpidName: prop = dir.Name; break;
+ // case kpidPath: prop = _proxy2->GetFullPathPrefix(_proxyDirIndex); break;
+ case kpidType: prop = UString("7-Zip.") + _agentSpec->ArchiveType; break;
+ case kpidCRC: if (dir.CrcIsDefined) { prop = dir.Crc; } break;
+ }
+
+ }
+ else
+ {
+ const CProxyDir &dir = _proxy->Dirs[_proxyDirIndex];
+ switch (propID)
+ {
+ case kpidSize: prop = dir.Size; break;
+ case kpidPackSize: prop = dir.PackSize; break;
+ case kpidNumSubDirs: prop = dir.NumSubDirs; break;
+ case kpidNumSubFiles: prop = dir.NumSubFiles; break;
+ case kpidName: prop = dir.Name; break;
+ case kpidPath: prop = _proxy->GetDirPath_as_Prefix(_proxyDirIndex); break;
+ case kpidType: prop = UString("7-Zip.") + _agentSpec->ArchiveType; break;
+ case kpidCRC: if (dir.CrcIsDefined) prop = dir.Crc; break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetNumberOfFolderProperties(UInt32 *numProps))
+{
+ *numProps = Z7_ARRAY_SIZE(kFolderProps);
+ return S_OK;
+}
+
+IMP_IFolderFolder_GetProp(
+ CAgentFolder::GetFolderPropertyInfo,
+ kFolderProps)
+
+Z7_COM7F_IMF(CAgentFolder::GetParent(UInt32 /* index */, UInt32 * /* parent */, UInt32 * /* parentType */))
+{
+ return E_FAIL;
+}
+
+
+Z7_COM7F_IMF(CAgentFolder::GetNumRawProps(UInt32 *numProps))
+{
+ IArchiveGetRawProps *rawProps = _agentSpec->_archiveLink.GetArchiveGetRawProps();
+ if (rawProps)
+ return rawProps->GetNumRawProps(numProps);
+ *numProps = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+{
+ IArchiveGetRawProps *rawProps = _agentSpec->_archiveLink.GetArchiveGetRawProps();
+ if (rawProps)
+ return rawProps->GetRawPropInfo(index, name, propID);
+ return E_FAIL;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ IArchiveGetRawProps *rawProps = _agentSpec->_archiveLink.GetArchiveGetRawProps();
+ if (rawProps)
+ {
+ unsigned arcIndex;
+ if (_proxy2)
+ {
+ SET_realIndex_AND_dir_2
+ arcIndex = dir->Items[realIndex];
+ }
+ else
+ {
+ SET_realIndex_AND_dir
+ if (realIndex < dir->SubDirs.Size())
+ {
+ const CProxyDir &item = _proxy->Dirs[dir->SubDirs[realIndex]];
+ if (!item.IsLeaf())
+ {
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ return S_OK;
+ }
+ arcIndex = (unsigned)item.ArcIndex;
+ }
+ else
+ arcIndex = dir->SubFiles[realIndex - dir->SubDirs.Size()];
+ }
+ return rawProps->GetRawProp(arcIndex, propID, data, dataSize, propType);
+ }
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgentFolder::GetFolderArcProps(IFolderArcProps **object))
+{
+ CMyComPtr<IFolderArcProps> temp = _agentSpec;
+ *object = temp.Detach();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CAgentFolder::SetFlatMode(Int32 flatMode))
+{
+ _flatMode = IntToBool(flatMode);
+ return S_OK;
+}
+
+
+int CAgentFolder::GetRealIndex(unsigned index) const
+{
+ if (!_flatMode)
+ {
+ if (_proxy2)
+ return (int)_proxy2->GetRealIndex(_proxyDirIndex, index);
+ else
+ return _proxy->GetRealIndex(_proxyDirIndex, index);
+ }
+ {
+ const CProxyItem &item = _items[index];
+ if (_proxy2)
+ {
+ const CProxyDir2 *dir = &_proxy2->Dirs[item.DirIndex];
+ return (int)dir->Items[item.Index];
+ }
+ else
+ {
+ const CProxyDir *dir = &_proxy->Dirs[item.DirIndex];
+ const unsigned realIndex = item.Index;
+ if (realIndex < dir->SubDirs.Size())
+ {
+ const CProxyDir &f = _proxy->Dirs[dir->SubDirs[realIndex]];
+ if (!f.IsLeaf())
+ return -1;
+ return f.ArcIndex;
+ }
+ return (int)dir->SubFiles[realIndex - dir->SubDirs.Size()];
+ }
+ }
+}
+
+void CAgentFolder::GetRealIndices(const UInt32 *indices, UInt32 numItems, bool includeAltStreams, bool includeFolderSubItemsInFlatMode, CUIntVector &realIndices) const
+{
+ if (!_flatMode)
+ {
+ if (_proxy2)
+ _proxy2->GetRealIndices(_proxyDirIndex, indices, numItems, includeAltStreams, realIndices);
+ else
+ _proxy->GetRealIndices(_proxyDirIndex, indices, numItems, realIndices);
+ return;
+ }
+
+ realIndices.Clear();
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ const CProxyItem &item = _items[indices[i]];
+ if (_proxy2)
+ {
+ const CProxyDir2 *dir = &_proxy2->Dirs[item.DirIndex];
+ _proxy2->AddRealIndices_of_ArcItem(dir->Items[item.Index], includeAltStreams, realIndices);
+ continue;
+ }
+ UInt32 arcIndex;
+ {
+ const CProxyDir *dir = &_proxy->Dirs[item.DirIndex];
+ unsigned realIndex = item.Index;
+ if (realIndex < dir->SubDirs.Size())
+ {
+ if (includeFolderSubItemsInFlatMode)
+ {
+ _proxy->AddRealIndices(dir->SubDirs[realIndex], realIndices);
+ continue;
+ }
+ const CProxyDir &f = _proxy->Dirs[dir->SubDirs[realIndex]];
+ if (!f.IsLeaf())
+ continue;
+ arcIndex = (unsigned)f.ArcIndex;
+ }
+ else
+ arcIndex = dir->SubFiles[realIndex - dir->SubDirs.Size()];
+ }
+ realIndices.Add(arcIndex);
+ }
+
+ HeapSort(&realIndices.Front(), realIndices.Size());
+}
+
+Z7_COM7F_IMF(CAgentFolder::Extract(const UInt32 *indices,
+ UInt32 numItems,
+ Int32 includeAltStreams,
+ Int32 replaceAltStreamColon,
+ NExtract::NPathMode::EEnum pathMode,
+ NExtract::NOverwriteMode::EEnum overwriteMode,
+ const wchar_t *path,
+ Int32 testMode,
+ IFolderArchiveExtractCallback *extractCallback2))
+{
+ COM_TRY_BEGIN
+
+ if (!testMode && _agentSpec->_isHashHandler)
+ return E_NOTIMPL;
+
+ CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
+ CMyComPtr<IArchiveExtractCallback> extractCallback = extractCallbackSpec;
+ UStringVector pathParts;
+ bool isAltStreamFolder = false;
+ if (_proxy2)
+ _proxy2->GetDirPathParts(_proxyDirIndex, pathParts, isAltStreamFolder);
+ else
+ _proxy->GetDirPathParts(_proxyDirIndex, pathParts);
+
+ /*
+ if (_flatMode)
+ pathMode = NExtract::NPathMode::kNoPathnames;
+ */
+
+ extractCallbackSpec->InitForMulti(
+ false, // multiArchives
+ pathMode,
+ overwriteMode,
+ _zoneMode,
+ k_keepEmptyDirPrefixes);
+
+ if (extractCallback2)
+ extractCallback2->SetTotal(_agentSpec->GetArc().GetEstmatedPhySize());
+
+ FString pathU;
+ if (path)
+ {
+ pathU = us2fs(path);
+ if (!pathU.IsEmpty())
+ if (!NFile::NName::IsAltStreamPrefixWithColon(pathU))
+ {
+ NFile::NName::NormalizeDirPathPrefix(pathU);
+ NFile::NDir::CreateComplexDir(pathU);
+ }
+ }
+
+ CExtractNtOptions extractNtOptions;
+ extractNtOptions.AltStreams.Val = IntToBool(includeAltStreams); // change it!!!
+ extractNtOptions.AltStreams.Def = true;
+
+ extractNtOptions.ReplaceColonForAltStream = IntToBool(replaceAltStreamColon);
+
+ extractCallbackSpec->InitBeforeNewArchive();
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (_zoneMode != NExtract::NZoneIdMode::kNone)
+ {
+ ReadZoneFile_Of_BaseFile(us2fs(_agentSpec->_archiveFilePath), extractCallbackSpec->ZoneBuf);
+ }
+ #endif
+
+ extractCallbackSpec->Init(
+ extractNtOptions,
+ NULL, &_agentSpec->GetArc(),
+ extractCallback2,
+ false, // stdOutMode
+ IntToBool(testMode),
+ pathU,
+ pathParts, isAltStreamFolder,
+ (UInt64)(Int64)-1);
+
+ if (_proxy2)
+ extractCallbackSpec->SetBaseParentFolderIndex((unsigned)_proxy2->Dirs[_proxyDirIndex].ArcIndex);
+
+ // do we need another base folder for subfolders ?
+ extractCallbackSpec->DirPathPrefix_for_HashFiles = _agentSpec->_hashBaseFolderPrefix;
+
+ CUIntVector realIndices;
+ GetRealIndices(indices, numItems, IntToBool(includeAltStreams),
+ false, // includeFolderSubItemsInFlatMode
+ realIndices); //
+
+ #ifdef SUPPORT_LINKS
+
+ if (!testMode)
+ {
+ RINOK(extractCallbackSpec->PrepareHardLinks(&realIndices))
+ }
+
+ #endif
+
+ {
+ CArchiveExtractCallback_Closer ecsCloser(extractCallbackSpec);
+
+ HRESULT res = _agentSpec->GetArchive()->Extract(&realIndices.Front(),
+ realIndices.Size(), testMode, extractCallback);
+
+ HRESULT res2 = ecsCloser.Close();
+ if (res == S_OK)
+ res = res2;
+ return res;
+ }
+
+ COM_TRY_END
+}
+
+/////////////////////////////////////////
+// CAgent
+
+CAgent::CAgent():
+ _proxy(NULL),
+ _proxy2(NULL),
+ _updatePathPrefix_is_AltFolder(false),
+ _isDeviceFile(false),
+ _isHashHandler(false)
+{
+}
+
+CAgent::~CAgent()
+{
+ if (_proxy)
+ delete _proxy;
+ if (_proxy2)
+ delete _proxy2;
+}
+
+bool CAgent::CanUpdate() const
+{
+ // FAR plugin uses empty agent to create new archive !!!
+ if (_archiveLink.Arcs.Size() == 0)
+ return true;
+ if (_isDeviceFile)
+ return false;
+ if (_archiveLink.Arcs.Size() != 1)
+ return false;
+ if (_archiveLink.Arcs[0].ErrorInfo.ThereIsTail)
+ return false;
+ return true;
+}
+
+Z7_COM7F_IMF(CAgent::Open(
+ IInStream *inStream,
+ const wchar_t *filePath,
+ const wchar_t *arcFormat,
+ BSTR *archiveType,
+ IArchiveOpenCallback *openArchiveCallback))
+{
+ COM_TRY_BEGIN
+ _archiveFilePath = filePath;
+ _hashBaseFolderPrefix.Empty();
+ _attrib = 0;
+ _isDeviceFile = false;
+ _isHashHandler = false;
+ NFile::NFind::CFileInfo fi;
+ if (!inStream)
+ {
+ if (!fi.Find(us2fs(_archiveFilePath)))
+ return GetLastError_noZero_HRESULT();
+ if (fi.IsDir())
+ return E_FAIL;
+ _attrib = fi.Attrib;
+ _isDeviceFile = fi.IsDevice;
+ FString dirPrefix, fileName;
+ if (NFile::NDir::GetFullPathAndSplit(us2fs(_archiveFilePath), dirPrefix, fileName))
+ {
+ NFile::NName::NormalizeDirPathPrefix(dirPrefix);
+ _hashBaseFolderPrefix = dirPrefix;
+ }
+ }
+ CArcInfoEx archiverInfo0, archiverInfo1;
+
+ RINOK(LoadGlobalCodecs())
+
+ CObjectVector<COpenType> types;
+ if (!ParseOpenTypes(*g_CodecsObj, arcFormat, types))
+ return S_FALSE;
+
+ /*
+ CObjectVector<COptionalOpenProperties> optProps;
+ if (Read_ShowDeleted())
+ {
+ COptionalOpenProperties &optPair = optProps.AddNew();
+ optPair.FormatName = "ntfs";
+ // optPair.Props.AddNew().Name = "LS";
+ optPair.Props.AddNew().Name = "LD";
+ }
+ */
+
+ COpenOptions options;
+ options.props = NULL;
+ options.codecs = g_CodecsObj;
+ options.types = &types;
+ CIntVector exl;
+ options.excludedFormats = &exl;
+ options.stdInMode = false;
+ options.stream = inStream;
+ options.filePath = _archiveFilePath;
+ options.callback = openArchiveCallback;
+
+ HRESULT res = _archiveLink.Open(options);
+
+ if (!_archiveLink.Arcs.IsEmpty())
+ {
+ CArc &arc = _archiveLink.Arcs.Back();
+ if (!inStream)
+ {
+ arc.MTime.Set_From_FiTime(fi.MTime);
+ arc.MTime.Def = !fi.IsDevice;
+ }
+
+ ArchiveType = GetTypeOfArc(arc);
+ if (archiveType)
+ {
+ RINOK(StringToBstr(ArchiveType, archiveType))
+ }
+
+ if (arc.IsHashHandler(options))
+ _isHashHandler = true;
+ }
+
+ return res;
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CAgent::ReOpen(IArchiveOpenCallback *openArchiveCallback))
+{
+ COM_TRY_BEGIN
+ if (_proxy2)
+ {
+ delete _proxy2;
+ _proxy2 = NULL;
+ }
+ if (_proxy)
+ {
+ delete _proxy;
+ _proxy = NULL;
+ }
+
+ CObjectVector<COpenType> incl;
+ CIntVector exl;
+
+ COpenOptions options;
+ options.props = NULL;
+ options.codecs = g_CodecsObj;
+ options.types = &incl;
+ options.excludedFormats = &exl;
+ options.stdInMode = false;
+ options.filePath = _archiveFilePath;
+ options.callback = openArchiveCallback;
+
+ RINOK(_archiveLink.ReOpen(options))
+ return ReadItems();
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgent::Close())
+{
+ COM_TRY_BEGIN
+ return _archiveLink.Close();
+ COM_TRY_END
+}
+
+/*
+Z7_COM7F_IMF(CAgent::EnumProperties(IEnumSTATPROPSTG **EnumProperties)
+{
+ return _archive->EnumProperties(EnumProperties);
+}
+*/
+
+HRESULT CAgent::ReadItems()
+{
+ if (_proxy || _proxy2)
+ return S_OK;
+
+ const CArc &arc = GetArc();
+ bool useProxy2 = (arc.GetRawProps && arc.IsTree);
+
+ // useProxy2 = false;
+
+ if (useProxy2)
+ _proxy2 = new CProxyArc2();
+ else
+ _proxy = new CProxyArc();
+
+ {
+ ThereIsPathProp = false;
+ // ThereIsAltStreamProp = false;
+ UInt32 numProps;
+ arc.Archive->GetNumberOfProperties(&numProps);
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE varType;
+ RINOK(arc.Archive->GetPropertyInfo(i, &name, &propID, &varType))
+ if (propID == kpidPath)
+ ThereIsPathProp = true;
+ /*
+ if (propID == kpidIsAltStream)
+ ThereIsAltStreamProp = true;
+ */
+ }
+ }
+
+ if (_proxy2)
+ return _proxy2->Load(GetArc(), NULL);
+ return _proxy->Load(GetArc(), NULL);
+}
+
+Z7_COM7F_IMF(CAgent::BindToRootFolder(IFolderFolder **resultFolder))
+{
+ COM_TRY_BEGIN
+ if (!_archiveLink.Arcs.IsEmpty())
+ {
+ RINOK(ReadItems())
+ }
+ CAgentFolder *folderSpec = new CAgentFolder;
+ CMyComPtr<IFolderFolder> rootFolder = folderSpec;
+ folderSpec->Init(_proxy, _proxy2, k_Proxy_RootDirIndex, /* NULL, */ this);
+ *resultFolder = rootFolder.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgent::Extract(
+ NExtract::NPathMode::EEnum pathMode,
+ NExtract::NOverwriteMode::EEnum overwriteMode,
+ const wchar_t *path,
+ Int32 testMode,
+ IFolderArchiveExtractCallback *extractCallback2))
+{
+ COM_TRY_BEGIN
+
+ if (!testMode && _isHashHandler)
+ return E_NOTIMPL;
+
+ CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
+ CMyComPtr<IArchiveExtractCallback> extractCallback = extractCallbackSpec;
+ extractCallbackSpec->InitForMulti(
+ false, // multiArchives
+ pathMode,
+ overwriteMode,
+ NExtract::NZoneIdMode::kNone,
+ k_keepEmptyDirPrefixes);
+
+ CExtractNtOptions extractNtOptions;
+ extractNtOptions.AltStreams.Val = true; // change it!!!
+ extractNtOptions.AltStreams.Def = true; // change it!!!
+ extractNtOptions.ReplaceColonForAltStream = false; // change it!!!
+
+ extractCallbackSpec->Init(
+ extractNtOptions,
+ NULL, &GetArc(),
+ extractCallback2,
+ false, // stdOutMode
+ IntToBool(testMode),
+ us2fs(path),
+ UStringVector(), false,
+ (UInt64)(Int64)-1);
+
+ extractCallbackSpec->DirPathPrefix_for_HashFiles = _hashBaseFolderPrefix;
+
+ #ifdef SUPPORT_LINKS
+
+ if (!testMode)
+ {
+ RINOK(extractCallbackSpec->PrepareHardLinks(NULL)) // NULL means all items
+ }
+
+ #endif
+
+ return GetArchive()->Extract(NULL, (UInt32)(Int32)-1, testMode, extractCallback);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgent::GetNumberOfProperties(UInt32 *numProps))
+{
+ COM_TRY_BEGIN
+ return GetArchive()->GetNumberOfProperties(numProps);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgent::GetPropertyInfo(UInt32 index,
+ BSTR *name, PROPID *propID, VARTYPE *varType))
+{
+ COM_TRY_BEGIN
+ RINOK(GetArchive()->GetPropertyInfo(index, name, propID, varType))
+ if (*propID == kpidPath)
+ *propID = kpidName;
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgent::GetArcNumLevels(UInt32 *numLevels))
+{
+ *numLevels = _archiveLink.Arcs.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgent::GetArcProp(UInt32 level, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ if (level > (UInt32)_archiveLink.Arcs.Size())
+ return E_INVALIDARG;
+ if (level == (UInt32)_archiveLink.Arcs.Size())
+ {
+ switch (propID)
+ {
+ case kpidPath:
+ if (!_archiveLink.NonOpen_ArcPath.IsEmpty())
+ prop = _archiveLink.NonOpen_ArcPath;
+ break;
+ case kpidErrorType:
+ if (_archiveLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
+ prop = g_CodecsObj->Formats[_archiveLink.NonOpen_ErrorInfo.ErrorFormatIndex].Name;
+ break;
+ case kpidErrorFlags:
+ {
+ UInt32 flags = _archiveLink.NonOpen_ErrorInfo.GetErrorFlags();
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ case kpidWarningFlags:
+ {
+ UInt32 flags = _archiveLink.NonOpen_ErrorInfo.GetWarningFlags();
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ }
+ }
+ else
+ {
+ const CArc &arc = _archiveLink.Arcs[level];
+ switch (propID)
+ {
+ case kpidType: prop = GetTypeOfArc(arc); break;
+ case kpidPath: prop = arc.Path; break;
+ case kpidErrorType:
+ if (arc.ErrorInfo.ErrorFormatIndex >= 0)
+ prop = g_CodecsObj->Formats[arc.ErrorInfo.ErrorFormatIndex].Name;
+ break;
+ case kpidErrorFlags:
+ {
+ const UInt32 flags = arc.ErrorInfo.GetErrorFlags();
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ case kpidWarningFlags:
+ {
+ const UInt32 flags = arc.ErrorInfo.GetWarningFlags();
+ if (flags != 0)
+ prop = flags;
+ break;
+ }
+ case kpidOffset:
+ {
+ const Int64 v = arc.GetGlobalOffset();
+ if (v != 0)
+ prop.Set_Int64(v);
+ break;
+ }
+ case kpidTailSize:
+ {
+ if (arc.ErrorInfo.TailSize != 0)
+ prop = arc.ErrorInfo.TailSize;
+ break;
+ }
+ default: return arc.Archive->GetArchiveProperty(propID, value);
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgent::GetArcNumProps(UInt32 level, UInt32 *numProps))
+{
+ return _archiveLink.Arcs[level].Archive->GetNumberOfArchiveProperties(numProps);
+}
+
+Z7_COM7F_IMF(CAgent::GetArcPropInfo(UInt32 level, UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType))
+{
+ return _archiveLink.Arcs[level].Archive->GetArchivePropertyInfo(index, name, propID, varType);
+}
+
+// MainItemProperty
+Z7_COM7F_IMF(CAgent::GetArcProp2(UInt32 level, PROPID propID, PROPVARIANT *value))
+{
+ return _archiveLink.Arcs[level - 1].Archive->GetProperty(_archiveLink.Arcs[level].SubfileIndex, propID, value);
+}
+
+Z7_COM7F_IMF(CAgent::GetArcNumProps2(UInt32 level, UInt32 *numProps))
+{
+ return _archiveLink.Arcs[level - 1].Archive->GetNumberOfProperties(numProps);
+}
+
+Z7_COM7F_IMF(CAgent::GetArcPropInfo2(UInt32 level, UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType))
+{
+ return _archiveLink.Arcs[level - 1].Archive->GetPropertyInfo(index, name, propID, varType);
+}
diff --git a/CPP/7zip/UI/Agent/Agent.h b/CPP/7zip/UI/Agent/Agent.h
new file mode 100644
index 0000000..ea81aa8
--- /dev/null
+++ b/CPP/7zip/UI/Agent/Agent.h
@@ -0,0 +1,353 @@
+// Agent/Agent.h
+
+#ifndef ZIP7_INC_AGENT_AGENT_H
+#define ZIP7_INC_AGENT_AGENT_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../Common/LoadCodecs.h"
+#include "../Common/OpenArchive.h"
+#include "../Common/UpdateAction.h"
+
+#include "../FileManager/IFolder.h"
+
+#include "AgentProxy.h"
+#include "IFolderArchive.h"
+
+extern CCodecs *g_CodecsObj;
+HRESULT LoadGlobalCodecs();
+void FreeGlobalCodecs();
+
+class CAgentFolder;
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACEM_IArchiveFolderInternal(x) \
+ x(GetAgentFolder(CAgentFolder **agentFolder))
+Z7_IFACE_CONSTR_FOLDERARC(IArchiveFolderInternal, 0xC)
+
+Z7_PURE_INTERFACES_END
+
+struct CProxyItem
+{
+ unsigned DirIndex;
+ unsigned Index;
+};
+
+class CAgent;
+
+enum AGENT_OP
+{
+ AGENT_OP_Uni,
+ AGENT_OP_Delete,
+ AGENT_OP_CreateFolder,
+ AGENT_OP_Rename,
+ AGENT_OP_CopyFromFile,
+ AGENT_OP_Comment
+};
+
+class CAgentFolder Z7_final:
+ public IFolderFolder,
+ public IFolderAltStreams,
+ public IFolderProperties,
+ public IArchiveGetRawProps,
+ public IGetFolderArcProps,
+ public IFolderCompare,
+ public IFolderGetItemName,
+ public IArchiveFolder,
+ public IArchiveFolderInternal,
+ public IInArchiveGetStream,
+ public IFolderSetZoneIdMode,
+ public IFolderOperations,
+ public IFolderSetFlatMode,
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IFolderFolder)
+ Z7_COM_QI_ENTRY(IFolderAltStreams)
+ Z7_COM_QI_ENTRY(IFolderProperties)
+ Z7_COM_QI_ENTRY(IArchiveGetRawProps)
+ Z7_COM_QI_ENTRY(IGetFolderArcProps)
+ Z7_COM_QI_ENTRY(IFolderCompare)
+ Z7_COM_QI_ENTRY(IFolderGetItemName)
+ Z7_COM_QI_ENTRY(IArchiveFolder)
+ Z7_COM_QI_ENTRY(IArchiveFolderInternal)
+ Z7_COM_QI_ENTRY(IInArchiveGetStream)
+ Z7_COM_QI_ENTRY(IFolderSetZoneIdMode)
+ Z7_COM_QI_ENTRY(IFolderOperations)
+ Z7_COM_QI_ENTRY(IFolderSetFlatMode)
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IFolderFolder)
+ Z7_IFACE_COM7_IMP(IFolderAltStreams)
+ Z7_IFACE_COM7_IMP(IFolderProperties)
+ Z7_IFACE_COM7_IMP(IArchiveGetRawProps)
+ Z7_IFACE_COM7_IMP(IGetFolderArcProps)
+ Z7_IFACE_COM7_IMP(IFolderCompare)
+ Z7_IFACE_COM7_IMP(IFolderGetItemName)
+ Z7_IFACE_COM7_IMP(IArchiveFolder)
+ Z7_IFACE_COM7_IMP(IArchiveFolderInternal)
+ Z7_IFACE_COM7_IMP(IInArchiveGetStream)
+ Z7_IFACE_COM7_IMP(IFolderSetZoneIdMode)
+ Z7_IFACE_COM7_IMP(IFolderOperations)
+ Z7_IFACE_COM7_IMP(IFolderSetFlatMode)
+
+ void LoadFolder(unsigned proxyDirIndex);
+public:
+ HRESULT BindToFolder_Internal(unsigned proxyDirIndex, IFolderFolder **resultFolder);
+ HRESULT BindToAltStreams_Internal(unsigned proxyDirIndex, IFolderFolder **resultFolder);
+ int GetRealIndex(unsigned index) const;
+ void GetRealIndices(const UInt32 *indices, UInt32 numItems,
+ bool includeAltStreams, bool includeFolderSubItemsInFlatMode, CUIntVector &realIndices) const;
+
+ int CompareItems3(UInt32 index1, UInt32 index2, PROPID propID);
+ int CompareItems2(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw);
+
+ CAgentFolder():
+ _proxyDirIndex(0),
+ _isAltStreamFolder(false),
+ _flatMode(false),
+ _loadAltStreams(false) // _loadAltStreams alt streams works in flat mode, but we don't use it now
+ , _zoneMode(NExtract::NZoneIdMode::kNone)
+ /* , _replaceAltStreamCharsMode(0) */
+ {}
+
+ void Init(const CProxyArc *proxy, const CProxyArc2 *proxy2,
+ unsigned proxyDirIndex,
+ /* IFolderFolder *parentFolder, */
+ CAgent *agent)
+ {
+ _proxy = proxy;
+ _proxy2 = proxy2;
+ _proxyDirIndex = proxyDirIndex;
+ _isAltStreamFolder = false;
+ if (_proxy2)
+ _isAltStreamFolder = _proxy2->IsAltDir(proxyDirIndex);
+ // _parentFolder = parentFolder;
+ _agent = (IInFolderArchive *)agent;
+ _agentSpec = agent;
+ }
+
+ void GetPathParts(UStringVector &pathParts, bool &isAltStreamFolder);
+ HRESULT CommonUpdateOperation(
+ AGENT_OP operation,
+ bool moveMode,
+ const wchar_t *newItemName,
+ const NUpdateArchive::CActionSet *actionSet,
+ const UInt32 *indices, UInt32 numItems,
+ IProgress *progress);
+
+
+ void GetPrefix(UInt32 index, UString &prefix) const;
+ UString GetName(UInt32 index) const;
+ UString GetFullPrefix(UInt32 index) const; // relative too root folder of archive
+
+public:
+ const CProxyArc *_proxy;
+ const CProxyArc2 *_proxy2;
+ unsigned _proxyDirIndex;
+ bool _isAltStreamFolder;
+ // CMyComPtr<IFolderFolder> _parentFolder;
+ CMyComPtr<IInFolderArchive> _agent;
+ CAgent *_agentSpec;
+
+ CRecordVector<CProxyItem> _items;
+ bool _flatMode;
+ bool _loadAltStreams; // in Flat mode
+ // Int32 _replaceAltStreamCharsMode;
+ NExtract::NZoneIdMode::EEnum _zoneMode;
+};
+
+class CAgent Z7_final:
+ public IInFolderArchive,
+ public IFolderArcProps,
+ #ifndef Z7_EXTRACT_ONLY
+ public IOutFolderArchive,
+ public ISetProperties,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IInFolderArchive)
+ Z7_COM_QI_ENTRY(IFolderArcProps)
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_COM_QI_ENTRY(IOutFolderArchive)
+ Z7_COM_QI_ENTRY(ISetProperties)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IInFolderArchive)
+ Z7_IFACE_COM7_IMP(IFolderArcProps)
+
+ #ifndef Z7_EXTRACT_ONLY
+ Z7_IFACE_COM7_IMP(ISetProperties)
+
+public:
+ Z7_IFACE_COM7_IMP(IOutFolderArchive)
+ HRESULT CommonUpdate(ISequentialOutStream *outArchiveStream,
+ unsigned numUpdateItems, IArchiveUpdateCallback *updateCallback);
+
+ HRESULT CreateFolder(ISequentialOutStream *outArchiveStream,
+ const wchar_t *folderName, IFolderArchiveUpdateCallback *updateCallback100);
+
+ HRESULT RenameItem(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems, const wchar_t *newItemName,
+ IFolderArchiveUpdateCallback *updateCallback100);
+
+ HRESULT CommentItem(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems, const wchar_t *newItemName,
+ IFolderArchiveUpdateCallback *updateCallback100);
+
+ HRESULT UpdateOneFile(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems, const wchar_t *diskFilePath,
+ IFolderArchiveUpdateCallback *updateCallback100);
+ #endif
+
+private:
+ HRESULT ReadItems();
+
+public:
+ CProxyArc *_proxy;
+ CProxyArc2 *_proxy2;
+ CArchiveLink _archiveLink;
+
+ bool ThereIsPathProp;
+ // bool ThereIsAltStreamProp;
+
+ UString ArchiveType;
+
+ FStringVector _names;
+ FString _folderPrefix; // for new files from disk
+
+ bool _updatePathPrefix_is_AltFolder;
+ UString _updatePathPrefix;
+ CAgentFolder *_agentFolder;
+
+ UString _archiveFilePath;
+ DWORD _attrib;
+ bool _isDeviceFile;
+ bool _isHashHandler;
+ FString _hashBaseFolderPrefix;
+
+ #ifndef Z7_EXTRACT_ONLY
+ CObjectVector<UString> m_PropNames;
+ CObjectVector<NWindows::NCOM::CPropVariant> m_PropValues;
+ #endif
+
+ CAgent();
+ ~CAgent();
+
+ const CArc &GetArc() const { return _archiveLink.Arcs.Back(); }
+ IInArchive *GetArchive() const { if ( _archiveLink.Arcs.IsEmpty()) return NULL; return GetArc().Archive; }
+ bool CanUpdate() const;
+
+ bool Is_Attrib_ReadOnly() const
+ {
+ return _attrib != INVALID_FILE_ATTRIBUTES && (_attrib & FILE_ATTRIBUTE_READONLY);
+ }
+
+ bool IsThere_ReadOnlyArc() const
+ {
+ FOR_VECTOR (i, _archiveLink.Arcs)
+ {
+ const CArc &arc = _archiveLink.Arcs[i];
+ if (arc.FormatIndex < 0
+ || arc.IsReadOnly
+ || !g_CodecsObj->Formats[arc.FormatIndex].UpdateEnabled)
+ return true;
+ }
+ return false;
+ }
+
+ UString GetTypeOfArc(const CArc &arc) const
+ {
+ if (arc.FormatIndex < 0)
+ return UString("Parser");
+ return g_CodecsObj->GetFormatNamePtr(arc.FormatIndex);
+ }
+
+ UString GetErrorMessage() const
+ {
+ UString s;
+ for (int i = (int)_archiveLink.Arcs.Size() - 1; i >= 0; i--)
+ {
+ const CArc &arc = _archiveLink.Arcs[i];
+
+ UString s2;
+ if (arc.ErrorInfo.ErrorFormatIndex >= 0)
+ {
+ if (arc.ErrorInfo.ErrorFormatIndex == arc.FormatIndex)
+ s2 += "Warning: The archive is open with offset";
+ else
+ {
+ s2 += "Cannot open the file as [";
+ s2 += g_CodecsObj->GetFormatNamePtr(arc.ErrorInfo.ErrorFormatIndex);
+ s2 += "] archive";
+ }
+ }
+
+ if (!arc.ErrorInfo.ErrorMessage.IsEmpty())
+ {
+ if (!s2.IsEmpty())
+ s2.Add_LF();
+ s2 += "\n[";
+ s2 += GetTypeOfArc(arc);
+ s2 += "]: ";
+ s2 += arc.ErrorInfo.ErrorMessage;
+ }
+
+ if (!s2.IsEmpty())
+ {
+ if (!s.IsEmpty())
+ s += "--------------------\n";
+ s += arc.Path;
+ s.Add_LF();
+ s += s2;
+ s.Add_LF();
+ }
+ }
+ return s;
+ }
+
+ void KeepModeForNextOpen() { _archiveLink.KeepModeForNextOpen(); }
+};
+
+
+// #ifdef NEW_FOLDER_INTERFACE
+
+struct CCodecIcons
+{
+ struct CIconPair
+ {
+ UString Ext;
+ int IconIndex;
+ };
+ CObjectVector<CIconPair> IconPairs;
+
+ // void Clear() { IconPairs.Clear(); }
+ void LoadIcons(HMODULE m);
+ bool FindIconIndex(const UString &ext, int &iconIndex) const;
+};
+
+
+Z7_CLASS_IMP_COM_1(
+ CArchiveFolderManager
+ , IFolderManager
+)
+ CObjectVector<CCodecIcons> CodecIconsVector;
+ CCodecIcons InternalIcons;
+ bool WasLoaded;
+
+ void LoadFormats();
+ // int FindFormat(const UString &type);
+public:
+ CArchiveFolderManager():
+ WasLoaded(false)
+ {}
+};
+
+// #endif
+
+#endif
diff --git a/CPP/7zip/UI/Agent/AgentOut.cpp b/CPP/7zip/UI/Agent/AgentOut.cpp
new file mode 100644
index 0000000..b5a25a3
--- /dev/null
+++ b/CPP/7zip/UI/Agent/AgentOut.cpp
@@ -0,0 +1,725 @@
+// AgentOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "../../Archive/Common/ItemNameUtils.h"
+
+#include "Agent.h"
+#include "UpdateCallbackAgent.h"
+
+using namespace NWindows;
+using namespace NCOM;
+
+Z7_COM7F_IMF(CAgent::SetFolder(IFolderFolder *folder))
+{
+ _updatePathPrefix.Empty();
+ _updatePathPrefix_is_AltFolder = false;
+ _agentFolder = NULL;
+
+ if (!folder)
+ return S_OK;
+
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveFolderInternal,
+ afi, folder)
+ if (afi)
+ {
+ RINOK(afi->GetAgentFolder(&_agentFolder))
+ }
+ if (!_agentFolder)
+ return E_FAIL;
+ }
+
+ if (_proxy2)
+ _updatePathPrefix = _proxy2->GetDirPath_as_Prefix(_agentFolder->_proxyDirIndex, _updatePathPrefix_is_AltFolder);
+ else
+ _updatePathPrefix = _proxy->GetDirPath_as_Prefix(_agentFolder->_proxyDirIndex);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAgent::SetFiles(const wchar_t *folderPrefix,
+ const wchar_t * const *names, UInt32 numNames))
+{
+ _folderPrefix = us2fs(folderPrefix);
+ _names.ClearAndReserve(numNames);
+ for (UInt32 i = 0; i < numNames; i++)
+ _names.AddInReserved(us2fs(names[i]));
+ return S_OK;
+}
+
+static HRESULT EnumerateArchiveItems(CAgent *agent,
+ const CProxyDir &item,
+ const UString &prefix,
+ CObjectVector<CArcItem> &arcItems)
+{
+ unsigned i;
+
+ for (i = 0; i < item.SubFiles.Size(); i++)
+ {
+ unsigned arcIndex = item.SubFiles[i];
+ const CProxyFile &fileItem = agent->_proxy->Files[arcIndex];
+ CArcItem ai;
+ RINOK(agent->GetArc().GetItem_MTime(arcIndex, ai.MTime))
+ RINOK(agent->GetArc().GetItem_Size(arcIndex, ai.Size, ai.Size_Defined))
+ ai.IsDir = false;
+ ai.Name = prefix + fileItem.Name;
+ ai.Censored = true; // test it
+ ai.IndexInServer = arcIndex;
+ arcItems.Add(ai);
+ }
+
+ for (i = 0; i < item.SubDirs.Size(); i++)
+ {
+ const CProxyDir &dirItem = agent->_proxy->Dirs[item.SubDirs[i]];
+ UString fullName = prefix + dirItem.Name;
+ if (dirItem.IsLeaf())
+ {
+ CArcItem ai;
+ RINOK(agent->GetArc().GetItem_MTime((unsigned)dirItem.ArcIndex, ai.MTime))
+ ai.IsDir = true;
+ ai.Size_Defined = false;
+ ai.Name = fullName;
+ ai.Censored = true; // test it
+ ai.IndexInServer = (unsigned)dirItem.ArcIndex;
+ arcItems.Add(ai);
+ }
+ RINOK(EnumerateArchiveItems(agent, dirItem, fullName + WCHAR_PATH_SEPARATOR, arcItems))
+ }
+
+ return S_OK;
+}
+
+static HRESULT EnumerateArchiveItems2(const CAgent *agent,
+ unsigned dirIndex,
+ const UString &prefix,
+ CObjectVector<CArcItem> &arcItems)
+{
+ const CProxyDir2 &dir = agent->_proxy2->Dirs[dirIndex];
+ FOR_VECTOR (i, dir.Items)
+ {
+ unsigned arcIndex = dir.Items[i];
+ const CProxyFile2 &file = agent->_proxy2->Files[arcIndex];
+ CArcItem ai;
+ ai.IndexInServer = arcIndex;
+ ai.Name = prefix + file.Name;
+ ai.Censored = true; // test it
+ RINOK(agent->GetArc().GetItem_MTime(arcIndex, ai.MTime))
+ ai.IsDir = file.IsDir();
+ ai.Size_Defined = false;
+ ai.IsAltStream = file.IsAltStream;
+ if (!ai.IsDir)
+ {
+ RINOK(agent->GetArc().GetItem_Size(arcIndex, ai.Size, ai.Size_Defined))
+ ai.IsDir = false;
+ }
+ arcItems.Add(ai);
+
+ if (file.AltDirIndex != -1)
+ {
+ RINOK(EnumerateArchiveItems2(agent, (unsigned)file.AltDirIndex, ai.Name + L':', arcItems))
+ }
+
+ if (ai.IsDir)
+ {
+ RINOK(EnumerateArchiveItems2(agent, (unsigned)file.DirIndex, ai.Name + WCHAR_PATH_SEPARATOR, arcItems))
+ }
+ }
+ return S_OK;
+}
+
+struct CAgUpCallbackImp Z7_final: public IUpdateProduceCallback
+{
+ const CObjectVector<CArcItem> *_arcItems;
+ IFolderArchiveUpdateCallback *_callback;
+
+ CAgUpCallbackImp(const CObjectVector<CArcItem> *a,
+ IFolderArchiveUpdateCallback *callback): _arcItems(a), _callback(callback) {}
+ HRESULT ShowDeleteFile(unsigned arcIndex) Z7_override;
+};
+
+HRESULT CAgUpCallbackImp::ShowDeleteFile(unsigned arcIndex)
+{
+ return _callback->DeleteOperation((*_arcItems)[arcIndex].Name);
+}
+
+
+static void SetInArchiveInterfaces(CAgent *agent, CArchiveUpdateCallback *upd)
+{
+ if (agent->_archiveLink.Arcs.IsEmpty())
+ return;
+ const CArc &arc = agent->GetArc();
+ upd->Arc = &arc;
+ upd->Archive = arc.Archive;
+
+ upd->ArcFileName = ExtractFileNameFromPath(arc.Path);
+}
+
+struct CDirItemsCallback_AgentOut Z7_final: public IDirItemsCallback
+{
+ CMyComPtr<IFolderScanProgress> FolderScanProgress;
+ IFolderArchiveUpdateCallback *FolderArchiveUpdateCallback;
+ HRESULT ErrorCode;
+
+ CDirItemsCallback_AgentOut(): FolderArchiveUpdateCallback(NULL), ErrorCode(S_OK) {}
+
+ HRESULT ScanError(const FString &name, DWORD systemError) Z7_override
+ {
+ const HRESULT hres = HRESULT_FROM_WIN32(systemError);
+ if (FolderArchiveUpdateCallback)
+ return FolderScanProgress->ScanError(fs2us(name), hres);
+ ErrorCode = hres;
+ return ErrorCode;
+ }
+
+ HRESULT ScanProgress(const CDirItemsStat &st, const FString &path, bool isDir) Z7_override
+ {
+ if (FolderScanProgress)
+ return FolderScanProgress->ScanProgress(st.NumDirs, st.NumFiles + st.NumAltStreams,
+ st.GetTotalBytes(), fs2us(path), BoolToInt(isDir));
+ if (FolderArchiveUpdateCallback)
+ return FolderArchiveUpdateCallback->SetNumFiles(st.NumFiles);
+ return S_OK;
+ }
+};
+
+
+Z7_COM7F_IMF(CAgent::DoOperation(
+ FStringVector *requestedPaths,
+ FStringVector *processedPaths,
+ CCodecs *codecs,
+ int formatIndex,
+ ISequentialOutStream *outArchiveStream,
+ const Byte *stateActions,
+ const wchar_t *sfxModule,
+ IFolderArchiveUpdateCallback *updateCallback100))
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+
+ NUpdateArchive::CActionSet actionSet;
+ {
+ for (unsigned i = 0; i < NUpdateArchive::NPairState::kNumValues; i++)
+ actionSet.StateActions[i] = (NUpdateArchive::NPairAction::EEnum)stateActions[i];
+ }
+
+ CDirItemsCallback_AgentOut enumCallback;
+ if (updateCallback100)
+ {
+ enumCallback.FolderArchiveUpdateCallback = updateCallback100;
+ updateCallback100->QueryInterface(IID_IFolderScanProgress, (void **)&enumCallback.FolderScanProgress);
+ }
+
+ CDirItems dirItems;
+ dirItems.Callback = &enumCallback;
+
+ {
+ FString folderPrefix = _folderPrefix;
+ if (!NFile::NName::IsAltStreamPrefixWithColon(fs2us(folderPrefix)))
+ NFile::NName::NormalizeDirPathPrefix(folderPrefix);
+
+ RINOK(dirItems.EnumerateItems2(folderPrefix, _updatePathPrefix, _names, requestedPaths))
+
+ if (_updatePathPrefix_is_AltFolder)
+ {
+ FOR_VECTOR(i, dirItems.Items)
+ {
+ CDirItem &item = dirItems.Items[i];
+ if (item.IsDir())
+ return E_NOTIMPL;
+ item.IsAltStream = true;
+ }
+ }
+ }
+
+ CMyComPtr<IOutArchive> outArchive;
+
+ if (GetArchive())
+ {
+ RINOK(GetArchive()->QueryInterface(IID_IOutArchive, (void **)&outArchive))
+ }
+ else
+ {
+ if (formatIndex < 0)
+ return E_FAIL;
+ RINOK(codecs->CreateOutArchive((unsigned)formatIndex, outArchive))
+
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
+ outArchive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
+ if (setCompressCodecsInfo)
+ {
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs))
+ }
+ }
+ #endif
+ }
+
+ NFileTimeType::EEnum fileTimeType = NFileTimeType::kNotDefined;
+ UInt32 value;
+ RINOK(outArchive->GetFileTimeType(&value))
+ // we support any future fileType here.
+ // 22.00:
+ fileTimeType = (NFileTimeType::EEnum)value;
+ /*
+ switch (value)
+ {
+ case NFileTimeType::kWindows:
+ case NFileTimeType::kDOS:
+ case NFileTimeType::kUnix:
+ fileTimeType = NFileTimeType::EEnum(value);
+ break;
+ default:
+ {
+ return E_FAIL;
+ }
+ }
+ */
+
+
+ CObjectVector<CArcItem> arcItems;
+ if (GetArchive())
+ {
+ RINOK(ReadItems())
+ if (_proxy2)
+ {
+ RINOK(EnumerateArchiveItems2(this, k_Proxy2_RootDirIndex, L"", arcItems))
+ RINOK(EnumerateArchiveItems2(this, k_Proxy2_AltRootDirIndex, L":", arcItems))
+ }
+ else
+ {
+ RINOK(EnumerateArchiveItems(this, _proxy->Dirs[0], L"", arcItems))
+ }
+ }
+
+ CRecordVector<CUpdatePair2> updatePairs2;
+
+ {
+ CRecordVector<CUpdatePair> updatePairs;
+ GetUpdatePairInfoList(dirItems, arcItems, fileTimeType, updatePairs);
+ CAgUpCallbackImp upCallback(&arcItems, updateCallback100);
+ UpdateProduce(updatePairs, actionSet, updatePairs2, &upCallback);
+ }
+
+ UInt32 numFiles = 0;
+ {
+ FOR_VECTOR (i, updatePairs2)
+ if (updatePairs2[i].NewData)
+ numFiles++;
+ }
+
+ if (updateCallback100)
+ {
+ RINOK(updateCallback100->SetNumFiles(numFiles))
+ }
+
+ CUpdateCallbackAgent updateCallbackAgent;
+ updateCallbackAgent.SetCallback(updateCallback100);
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec );
+
+ updateCallbackSpec->DirItems = &dirItems;
+ updateCallbackSpec->ArcItems = &arcItems;
+ updateCallbackSpec->UpdatePairs = &updatePairs2;
+
+ SetInArchiveInterfaces(this, updateCallbackSpec);
+
+ updateCallbackSpec->Callback = &updateCallbackAgent;
+
+ CByteBuffer processedItems;
+ if (processedPaths)
+ {
+ unsigned num = dirItems.Items.Size();
+ processedItems.Alloc(num);
+ for (unsigned i = 0; i < num; i++)
+ processedItems[i] = 0;
+ updateCallbackSpec->ProcessedItemsStatuses = processedItems;
+ }
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ISetProperties,
+ setProperties, outArchive)
+ if (setProperties)
+ {
+ if (m_PropNames.Size() == 0)
+ {
+ RINOK(setProperties->SetProperties(NULL, NULL, 0))
+ }
+ else
+ {
+ CRecordVector<const wchar_t *> names;
+ FOR_VECTOR (i, m_PropNames)
+ names.Add((const wchar_t *)m_PropNames[i]);
+
+ CPropVariant *propValues = new CPropVariant[m_PropValues.Size()];
+ try
+ {
+ FOR_VECTOR (i, m_PropValues)
+ propValues[i] = m_PropValues[i];
+ RINOK(setProperties->SetProperties(&names.Front(), propValues, names.Size()))
+ }
+ catch(...)
+ {
+ delete []propValues;
+ return E_FAIL;
+ }
+ delete []propValues;
+ }
+ }
+ m_PropNames.Clear();
+ m_PropValues.Clear();
+
+ if (sfxModule != NULL)
+ {
+ CInFileStream *sfxStreamSpec = new CInFileStream;
+ CMyComPtr<IInStream> sfxStream(sfxStreamSpec);
+ if (!sfxStreamSpec->Open(us2fs(sfxModule)))
+ return E_FAIL;
+ // throw "Can't open sfx module";
+ RINOK(NCompress::CopyStream(sfxStream, outArchiveStream, NULL))
+ }
+
+ HRESULT res = outArchive->UpdateItems(outArchiveStream, updatePairs2.Size(), updateCallback);
+ if (res == S_OK && processedPaths)
+ {
+ {
+ /* OutHandler for 7z archives doesn't report compression operation for empty files.
+ So we must include these files manually */
+ FOR_VECTOR(i, updatePairs2)
+ {
+ const CUpdatePair2 &up = updatePairs2[i];
+ if (up.DirIndex != -1 && up.NewData)
+ {
+ const CDirItem &di = dirItems.Items[(unsigned)up.DirIndex];
+ if (!di.IsDir() && di.Size == 0)
+ processedItems[(unsigned)up.DirIndex] = 1;
+ }
+ }
+ }
+
+ FOR_VECTOR (i, dirItems.Items)
+ if (processedItems[i] != 0)
+ processedPaths->Add(dirItems.GetPhyPath(i));
+ }
+ return res;
+}
+
+Z7_COM7F_IMF(CAgent::DoOperation2(
+ FStringVector *requestedPaths,
+ FStringVector *processedPaths,
+ ISequentialOutStream *outArchiveStream,
+ const Byte *stateActions, const wchar_t *sfxModule, IFolderArchiveUpdateCallback *updateCallback100))
+{
+ return DoOperation(requestedPaths, processedPaths, g_CodecsObj, -1, outArchiveStream, stateActions, sfxModule, updateCallback100);
+}
+
+HRESULT CAgent::CommonUpdate(ISequentialOutStream *outArchiveStream,
+ unsigned numUpdateItems, IArchiveUpdateCallback *updateCallback)
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+ CMyComPtr<IOutArchive> outArchive;
+ RINOK(GetArchive()->QueryInterface(IID_IOutArchive, (void **)&outArchive))
+ return outArchive->UpdateItems(outArchiveStream, numUpdateItems, updateCallback);
+}
+
+Z7_COM7F_IMF(CAgent::DeleteItems(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems,
+ IFolderArchiveUpdateCallback *updateCallback100))
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+ CRecordVector<CUpdatePair2> updatePairs;
+ CUpdateCallbackAgent updateCallbackAgent;
+ updateCallbackAgent.SetCallback(updateCallback100);
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ CUIntVector realIndices;
+ _agentFolder->GetRealIndices(indices, numItems,
+ true, // includeAltStreams
+ false, // includeFolderSubItemsInFlatMode, we don't want to delete subItems in Flat Mode
+ realIndices);
+ unsigned curIndex = 0;
+ UInt32 numItemsInArchive;
+ RINOK(GetArchive()->GetNumberOfItems(&numItemsInArchive))
+
+ UString deletePath;
+
+ for (UInt32 i = 0; i < numItemsInArchive; i++)
+ {
+ if (curIndex < realIndices.Size())
+ if (realIndices[curIndex] == i)
+ {
+ RINOK(GetArc().GetItem_Path2(i, deletePath))
+ RINOK(updateCallback100->DeleteOperation(deletePath))
+
+ curIndex++;
+ continue;
+ }
+ CUpdatePair2 up2;
+ up2.SetAs_NoChangeArcItem(i);
+ updatePairs.Add(up2);
+ }
+ updateCallbackSpec->UpdatePairs = &updatePairs;
+
+ SetInArchiveInterfaces(this, updateCallbackSpec);
+
+ updateCallbackSpec->Callback = &updateCallbackAgent;
+ return CommonUpdate(outArchiveStream, updatePairs.Size(), updateCallback);
+}
+
+HRESULT CAgent::CreateFolder(ISequentialOutStream *outArchiveStream,
+ const wchar_t *folderName, IFolderArchiveUpdateCallback *updateCallback100)
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+ CRecordVector<CUpdatePair2> updatePairs;
+ CDirItems dirItems;
+ CUpdateCallbackAgent updateCallbackAgent;
+ updateCallbackAgent.SetCallback(updateCallback100);
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ UInt32 numItemsInArchive;
+ RINOK(GetArchive()->GetNumberOfItems(&numItemsInArchive))
+ for (UInt32 i = 0; i < numItemsInArchive; i++)
+ {
+ CUpdatePair2 up2;
+ up2.SetAs_NoChangeArcItem(i);
+ updatePairs.Add(up2);
+ }
+ CUpdatePair2 up2;
+ up2.NewData = up2.NewProps = true;
+ up2.UseArcProps = false;
+ up2.DirIndex = 0;
+
+ updatePairs.Add(up2);
+
+ updatePairs.ReserveDown();
+
+ CDirItem di;
+
+ di.Attrib = FILE_ATTRIBUTE_DIRECTORY;
+ di.Size = 0;
+ bool isAltStreamFolder = false;
+ if (_proxy2)
+ di.Name = _proxy2->GetDirPath_as_Prefix(_agentFolder->_proxyDirIndex, isAltStreamFolder);
+ else
+ di.Name = _proxy->GetDirPath_as_Prefix(_agentFolder->_proxyDirIndex);
+ di.Name += folderName;
+
+ FILETIME ft;
+ NTime::GetCurUtcFileTime(ft);
+ di.CTime = di.ATime = di.MTime = ft;
+
+ dirItems.Items.Add(di);
+
+ updateCallbackSpec->Callback = &updateCallbackAgent;
+ updateCallbackSpec->DirItems = &dirItems;
+ updateCallbackSpec->UpdatePairs = &updatePairs;
+
+ SetInArchiveInterfaces(this, updateCallbackSpec);
+
+ return CommonUpdate(outArchiveStream, updatePairs.Size(), updateCallback);
+}
+
+
+HRESULT CAgent::RenameItem(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems, const wchar_t *newItemName,
+ IFolderArchiveUpdateCallback *updateCallback100)
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+ if (numItems != 1)
+ return E_INVALIDARG;
+ if (!_archiveLink.IsOpen)
+ return E_FAIL;
+ CRecordVector<CUpdatePair2> updatePairs;
+ CUpdateCallbackAgent updateCallbackAgent;
+ updateCallbackAgent.SetCallback(updateCallback100);
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ CUIntVector realIndices;
+ _agentFolder->GetRealIndices(indices, numItems,
+ true, // includeAltStreams
+ true, // includeFolderSubItemsInFlatMode
+ realIndices);
+
+ const UInt32 ind0 = indices[0];
+ const int mainRealIndex = _agentFolder->GetRealIndex(ind0);
+ const UString fullPrefix = _agentFolder->GetFullPrefix(ind0);
+ UString name = _agentFolder->GetName(ind0);
+ // 22.00 : we normalize name
+ NArchive::NItemName::NormalizeSlashes_in_FileName_for_OsPath(name);
+ const UString oldItemPath = fullPrefix + name;
+ const UString newItemPath = fullPrefix + newItemName;
+
+ UStringVector newNames;
+
+ unsigned curIndex = 0;
+ UInt32 numItemsInArchive;
+ RINOK(GetArchive()->GetNumberOfItems(&numItemsInArchive))
+
+ for (UInt32 i = 0; i < numItemsInArchive; i++)
+ {
+ CUpdatePair2 up2;
+ up2.SetAs_NoChangeArcItem(i);
+ if (curIndex < realIndices.Size())
+ if (realIndices[curIndex] == i)
+ {
+ up2.NewProps = true;
+ RINOK(GetArc().IsItem_Anti(i, up2.IsAnti)) // it must work without that line too.
+
+ UString oldFullPath;
+ RINOK(GetArc().GetItem_Path2(i, oldFullPath))
+
+ if (!IsPath1PrefixedByPath2(oldFullPath, oldItemPath))
+ return E_INVALIDARG;
+
+ up2.NewNameIndex = (int)newNames.Add(newItemPath + oldFullPath.Ptr(oldItemPath.Len()));
+ up2.IsMainRenameItem = (mainRealIndex == (int)i);
+ curIndex++;
+ }
+ updatePairs.Add(up2);
+ }
+
+ updateCallbackSpec->Callback = &updateCallbackAgent;
+ updateCallbackSpec->UpdatePairs = &updatePairs;
+ updateCallbackSpec->NewNames = &newNames;
+
+ SetInArchiveInterfaces(this, updateCallbackSpec);
+
+ return CommonUpdate(outArchiveStream, updatePairs.Size(), updateCallback);
+}
+
+
+HRESULT CAgent::CommentItem(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems, const wchar_t *newItemName,
+ IFolderArchiveUpdateCallback *updateCallback100)
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+ if (numItems != 1)
+ return E_INVALIDARG;
+ if (!_archiveLink.IsOpen)
+ return E_FAIL;
+
+ CRecordVector<CUpdatePair2> updatePairs;
+ CUpdateCallbackAgent updateCallbackAgent;
+ updateCallbackAgent.SetCallback(updateCallback100);
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ const int mainRealIndex = _agentFolder->GetRealIndex(indices[0]);
+
+ if (mainRealIndex < 0)
+ return E_NOTIMPL;
+
+ UInt32 numItemsInArchive;
+ RINOK(GetArchive()->GetNumberOfItems(&numItemsInArchive))
+
+ UString newName = newItemName;
+
+ for (UInt32 i = 0; i < numItemsInArchive; i++)
+ {
+ CUpdatePair2 up2;
+ up2.SetAs_NoChangeArcItem(i);
+ if ((int)i == mainRealIndex)
+ up2.NewProps = true;
+ updatePairs.Add(up2);
+ }
+
+ updateCallbackSpec->Callback = &updateCallbackAgent;
+ updateCallbackSpec->UpdatePairs = &updatePairs;
+ updateCallbackSpec->CommentIndex = mainRealIndex;
+ updateCallbackSpec->Comment = &newName;
+
+ SetInArchiveInterfaces(this, updateCallbackSpec);
+
+ return CommonUpdate(outArchiveStream, updatePairs.Size(), updateCallback);
+}
+
+
+
+HRESULT CAgent::UpdateOneFile(ISequentialOutStream *outArchiveStream,
+ const UInt32 *indices, UInt32 numItems, const wchar_t *diskFilePath,
+ IFolderArchiveUpdateCallback *updateCallback100)
+{
+ if (!CanUpdate())
+ return E_NOTIMPL;
+ CRecordVector<CUpdatePair2> updatePairs;
+ CDirItems dirItems;
+ CUpdateCallbackAgent updateCallbackAgent;
+ updateCallbackAgent.SetCallback(updateCallback100);
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ UInt32 realIndex;
+ {
+ CUIntVector realIndices;
+ _agentFolder->GetRealIndices(indices, numItems,
+ false, // includeAltStreams // we update only main stream of file
+ false, // includeFolderSubItemsInFlatMode
+ realIndices);
+ if (realIndices.Size() != 1)
+ return E_FAIL;
+ realIndex = realIndices[0];
+ }
+
+ {
+ FStringVector filePaths;
+ filePaths.Add(us2fs(diskFilePath));
+ dirItems.EnumerateItems2(FString(), UString(), filePaths, NULL);
+ if (dirItems.Items.Size() != 1)
+ return E_FAIL;
+ }
+
+ UInt32 numItemsInArchive;
+ RINOK(GetArchive()->GetNumberOfItems(&numItemsInArchive))
+ for (UInt32 i = 0; i < numItemsInArchive; i++)
+ {
+ CUpdatePair2 up2;
+ up2.SetAs_NoChangeArcItem(i);
+ if (realIndex == i)
+ {
+ up2.DirIndex = 0;
+ up2.NewData = true;
+ up2.NewProps = true;
+ up2.UseArcProps = false;
+ }
+ updatePairs.Add(up2);
+ }
+ updateCallbackSpec->DirItems = &dirItems;
+ updateCallbackSpec->Callback = &updateCallbackAgent;
+ updateCallbackSpec->UpdatePairs = &updatePairs;
+
+ SetInArchiveInterfaces(this, updateCallbackSpec);
+
+ updateCallbackSpec->KeepOriginalItemNames = true;
+ return CommonUpdate(outArchiveStream, updatePairs.Size(), updateCallback);
+}
+
+Z7_COM7F_IMF(CAgent::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ m_PropNames.Clear();
+ m_PropValues.Clear();
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ m_PropNames.Add(names[i]);
+ m_PropValues.Add(values[i]);
+ }
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Agent/AgentProxy.cpp b/CPP/7zip/UI/Agent/AgentProxy.cpp
new file mode 100644
index 0000000..df9f315
--- /dev/null
+++ b/CPP/7zip/UI/Agent/AgentProxy.cpp
@@ -0,0 +1,752 @@
+// AgentProxy.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+#ifdef _WIN32
+#include <wchar.h>
+#else
+#include <ctype.h>
+#endif
+
+#include "../../../../C/Sort.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/UTFConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../Archive/Common/ItemNameUtils.h"
+
+#include "AgentProxy.h"
+
+using namespace NWindows;
+
+int CProxyArc::FindSubDir(unsigned dirIndex, const wchar_t *name, unsigned &insertPos) const
+{
+ const CRecordVector<unsigned> &subDirs = Dirs[dirIndex].SubDirs;
+ unsigned left = 0, right = subDirs.Size();
+ for (;;)
+ {
+ if (left == right)
+ {
+ insertPos = left;
+ return -1;
+ }
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned dirIndex2 = subDirs[mid];
+ const int comp = CompareFileNames(name, Dirs[dirIndex2].Name);
+ if (comp == 0)
+ return (int)dirIndex2;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+}
+
+int CProxyArc::FindSubDir(unsigned dirIndex, const wchar_t *name) const
+{
+ unsigned insertPos;
+ return FindSubDir(dirIndex, name, insertPos);
+}
+
+static const wchar_t *AllocStringAndCopy(const wchar_t *s, size_t len)
+{
+ wchar_t *p = new wchar_t[len + 1];
+ MyStringCopy(p, s);
+ return p;
+}
+
+static const wchar_t *AllocStringAndCopy(const UString &s)
+{
+ return AllocStringAndCopy(s, s.Len());
+}
+
+unsigned CProxyArc::AddDir(unsigned dirIndex, int arcIndex, const UString &name)
+{
+ unsigned insertPos;
+ int subDirIndex = FindSubDir(dirIndex, name, insertPos);
+ if (subDirIndex != -1)
+ {
+ if (arcIndex != -1)
+ {
+ CProxyDir &item = Dirs[(unsigned)subDirIndex];
+ if (item.ArcIndex == -1)
+ item.ArcIndex = arcIndex;
+ }
+ return (unsigned)subDirIndex;
+ }
+ subDirIndex = (int)Dirs.Size();
+ Dirs[dirIndex].SubDirs.Insert(insertPos, (unsigned)subDirIndex);
+ CProxyDir &item = Dirs.AddNew();
+
+ item.NameLen = name.Len();
+ item.Name = AllocStringAndCopy(name);
+
+ item.ArcIndex = arcIndex;
+ item.ParentDir = (int)dirIndex;
+ return (unsigned)subDirIndex;
+}
+
+void CProxyDir::Clear()
+{
+ SubDirs.Clear();
+ SubFiles.Clear();
+}
+
+void CProxyArc::GetDirPathParts(unsigned dirIndex, UStringVector &pathParts) const
+{
+ pathParts.Clear();
+ // while (dirIndex != -1)
+ for (;;)
+ {
+ const CProxyDir &dir = Dirs[dirIndex];
+ dirIndex = (unsigned)dir.ParentDir;
+ if (dir.ParentDir == -1)
+ break;
+ pathParts.Insert(0, dir.Name);
+ // 22.00: we normalize name
+ NArchive::NItemName::NormalizeSlashes_in_FileName_for_OsPath(pathParts[0]);
+ }
+}
+
+UString CProxyArc::GetDirPath_as_Prefix(unsigned dirIndex) const
+{
+ UString s;
+ // while (dirIndex != -1)
+ for (;;)
+ {
+ const CProxyDir &dir = Dirs[dirIndex];
+ dirIndex = (unsigned)dir.ParentDir;
+ if (dir.ParentDir == -1)
+ break;
+ s.InsertAtFront(WCHAR_PATH_SEPARATOR);
+ s.Insert(0, dir.Name);
+ // 22.00: we normalize name
+ NArchive::NItemName::NormalizeSlashes_in_FileName_for_OsPath(s.GetBuf(), MyStringLen(dir.Name));
+ }
+ return s;
+}
+
+void CProxyArc::AddRealIndices(unsigned dirIndex, CUIntVector &realIndices) const
+{
+ const CProxyDir &dir = Dirs[dirIndex];
+ if (dir.IsLeaf())
+ realIndices.Add((unsigned)dir.ArcIndex);
+ unsigned i;
+ for (i = 0; i < dir.SubDirs.Size(); i++)
+ AddRealIndices(dir.SubDirs[i], realIndices);
+ for (i = 0; i < dir.SubFiles.Size(); i++)
+ realIndices.Add(dir.SubFiles[i]);
+}
+
+int CProxyArc::GetRealIndex(unsigned dirIndex, unsigned index) const
+{
+ const CProxyDir &dir = Dirs[dirIndex];
+ unsigned numDirItems = dir.SubDirs.Size();
+ if (index < numDirItems)
+ {
+ const CProxyDir &f = Dirs[dir.SubDirs[index]];
+ if (f.IsLeaf())
+ return f.ArcIndex;
+ return -1;
+ }
+ return (int)dir.SubFiles[index - numDirItems];
+}
+
+void CProxyArc::GetRealIndices(unsigned dirIndex, const UInt32 *indices, UInt32 numItems, CUIntVector &realIndices) const
+{
+ const CProxyDir &dir = Dirs[dirIndex];
+ realIndices.Clear();
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ UInt32 index = indices[i];
+ unsigned numDirItems = dir.SubDirs.Size();
+ if (index < numDirItems)
+ AddRealIndices(dir.SubDirs[index], realIndices);
+ else
+ realIndices.Add(dir.SubFiles[index - numDirItems]);
+ }
+ HeapSort(&realIndices.Front(), realIndices.Size());
+}
+
+///////////////////////////////////////////////
+// CProxyArc
+
+static bool GetSize(IInArchive *archive, UInt32 index, PROPID propID, UInt64 &size)
+{
+ size = 0;
+ NCOM::CPropVariant prop;
+ if (archive->GetProperty(index, propID, &prop) != S_OK)
+ throw 20120228;
+ return ConvertPropVariantToUInt64(prop, size);
+}
+
+void CProxyArc::CalculateSizes(unsigned dirIndex, IInArchive *archive)
+{
+ CProxyDir &dir = Dirs[dirIndex];
+ dir.Size = dir.PackSize = 0;
+ dir.NumSubDirs = dir.SubDirs.Size();
+ dir.NumSubFiles = dir.SubFiles.Size();
+ dir.CrcIsDefined = true;
+ dir.Crc = 0;
+
+ unsigned i;
+
+ for (i = 0; i < dir.SubFiles.Size(); i++)
+ {
+ UInt32 index = (UInt32)dir.SubFiles[i];
+ UInt64 size, packSize;
+ bool sizeDefined = GetSize(archive, index, kpidSize, size);
+ dir.Size += size;
+ GetSize(archive, index, kpidPackSize, packSize);
+ dir.PackSize += packSize;
+ {
+ NCOM::CPropVariant prop;
+ if (archive->GetProperty(index, kpidCRC, &prop) == S_OK)
+ {
+ if (prop.vt == VT_UI4)
+ dir.Crc += prop.ulVal;
+ else if (prop.vt != VT_EMPTY || size != 0 || !sizeDefined)
+ dir.CrcIsDefined = false;
+ }
+ else
+ dir.CrcIsDefined = false;
+ }
+ }
+
+ for (i = 0; i < dir.SubDirs.Size(); i++)
+ {
+ unsigned subDirIndex = dir.SubDirs[i];
+ CalculateSizes(subDirIndex, archive);
+ CProxyDir &f = Dirs[subDirIndex];
+ dir.Size += f.Size;
+ dir.PackSize += f.PackSize;
+ dir.NumSubFiles += f.NumSubFiles;
+ dir.NumSubDirs += f.NumSubDirs;
+ dir.Crc += f.Crc;
+ if (!f.CrcIsDefined)
+ dir.CrcIsDefined = false;
+ }
+}
+
+HRESULT CProxyArc::Load(const CArc &arc, IProgress *progress)
+{
+ // DWORD tickCount = GetTickCount(); for (int ttt = 0; ttt < 1; ttt++) {
+
+ Files.Free();
+ Dirs.Clear();
+
+ Dirs.AddNew();
+ IInArchive *archive = arc.Archive;
+
+ UInt32 numItems;
+ RINOK(archive->GetNumberOfItems(&numItems))
+
+ if (progress)
+ RINOK(progress->SetTotal(numItems))
+
+ Files.Alloc(numItems);
+
+ UString path;
+ UString name;
+ NCOM::CPropVariant prop;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ if (progress && (i & 0xFFFF) == 0)
+ {
+ const UInt64 currentItemIndex = i;
+ RINOK(progress->SetCompleted(¤tItemIndex))
+ }
+
+ const wchar_t *s = NULL;
+ unsigned len = 0;
+ bool isPtrName = false;
+
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ wchar_t separatorChar = WCHAR_PATH_SEPARATOR;
+ #endif
+
+ #if defined(MY_CPU_LE) && defined(_WIN32)
+ // it works only if (sizeof(wchar_t) == 2)
+ if (arc.GetRawProps)
+ {
+ const void *p;
+ UInt32 size;
+ UInt32 propType;
+ if (arc.GetRawProps->GetRawProp(i, kpidPath, &p, &size, &propType) == S_OK
+ && propType == NPropDataType::kUtf16z
+ && size > 2)
+ {
+ // is (size <= 2), it's empty name, and we call default arc.GetItemPath();
+ len = size / 2 - 1;
+ s = (const wchar_t *)p;
+ isPtrName = true;
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ separatorChar = L'/'; // 0
+ #endif
+ }
+ }
+ if (!s)
+ #endif
+ {
+ prop.Clear();
+ RINOK(arc.Archive->GetProperty(i, kpidPath, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ s = prop.bstrVal;
+ len = ::SysStringLen(prop.bstrVal);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ if (len == 0)
+ {
+ RINOK(arc.GetItem_DefaultPath(i, path))
+ len = path.Len();
+ s = path;
+ }
+
+ /*
+ RINOK(arc.GetItemPath(i, path));
+ len = path.Len();
+ s = path;
+ */
+ }
+
+ unsigned curItem = 0;
+
+ /*
+ if (arc.Ask_Deleted)
+ {
+ bool isDeleted = false;
+ RINOK(Archive_IsItem_Deleted(archive, i, isDeleted));
+ if (isDeleted)
+ curItem = AddDirSubItem(curItem, (UInt32)(Int32)-1, false, L"[DELETED]");
+ }
+ */
+
+ unsigned namePos = 0;
+
+ unsigned numLevels = 0;
+
+ for (unsigned j = 0; j < len; j++)
+ {
+ const wchar_t c = s[j];
+ if (c == L'/'
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ || (c == separatorChar)
+ #endif
+ )
+ {
+ const unsigned kLevelLimit = 1 << 10;
+ if (numLevels <= kLevelLimit)
+ {
+ if (numLevels == kLevelLimit)
+ name = "[LONG_PATH]";
+ else
+ name.SetFrom(s + namePos, j - namePos);
+ // 22.00: we can normalize dir here
+ // NArchive::NItemName::NormalizeSlashes_in_FileName_for_OsPath(name);
+ curItem = AddDir(curItem, -1, name);
+ }
+ namePos = j + 1;
+ numLevels++;
+ }
+ }
+
+ /*
+ that code must be implemeted to hide alt streams in list.
+ if (arc.Ask_AltStreams)
+ {
+ bool isAltStream;
+ RINOK(Archive_IsItem_AltStream(archive, i, isAltStream));
+ if (isAltStream)
+ {
+
+ }
+ }
+ */
+
+ bool isDir;
+ RINOK(Archive_IsItem_Dir(archive, i, isDir))
+
+ CProxyFile &f = Files[i];
+
+ f.NameLen = len - namePos;
+ s += namePos;
+
+ if (isPtrName)
+ f.Name = s;
+ else
+ {
+ f.Name = AllocStringAndCopy(s, f.NameLen);
+ f.NeedDeleteName = true;
+ }
+
+ if (isDir)
+ {
+ name = s;
+ // 22.00: we can normalize dir here
+ // NArchive::NItemName::NormalizeSlashes_in_FileName_for_OsPath(name);
+ AddDir(curItem, (int)i, name);
+ }
+ else
+ Dirs[curItem].SubFiles.Add(i);
+ }
+
+ CalculateSizes(0, archive);
+
+ // } char s[128]; sprintf(s, "Load archive: %7d ms", GetTickCount() - tickCount); OutputDebugStringA(s);
+
+ return S_OK;
+}
+
+
+
+// ---------- for Tree-mode archive ----------
+
+void CProxyArc2::GetDirPathParts(unsigned dirIndex, UStringVector &pathParts, bool &isAltStreamDir) const
+{
+ pathParts.Clear();
+
+ isAltStreamDir = false;
+
+ if (dirIndex == k_Proxy2_RootDirIndex)
+ return;
+ if (dirIndex == k_Proxy2_AltRootDirIndex)
+ {
+ isAltStreamDir = true;
+ return;
+ }
+
+ while (dirIndex >= k_Proxy2_NumRootDirs)
+ {
+ const CProxyDir2 &dir = Dirs[dirIndex];
+ const CProxyFile2 &file = Files[(unsigned)dir.ArcIndex];
+ if (pathParts.IsEmpty() && (int)dirIndex == file.AltDirIndex)
+ isAltStreamDir = true;
+ pathParts.Insert(0, file.Name);
+ const int par = file.Parent;
+ if (par == -1)
+ break;
+ dirIndex = (unsigned)Files[(unsigned)par].DirIndex;
+ // if ((int)dirIndex == -1) break;
+ }
+}
+
+bool CProxyArc2::IsAltDir(unsigned dirIndex) const
+{
+ if (dirIndex == k_Proxy2_RootDirIndex)
+ return false;
+ if (dirIndex == k_Proxy2_AltRootDirIndex)
+ return true;
+ const CProxyDir2 &dir = Dirs[dirIndex];
+ const CProxyFile2 &file = Files[(unsigned)dir.ArcIndex];
+ return ((int)dirIndex == file.AltDirIndex);
+}
+
+UString CProxyArc2::GetDirPath_as_Prefix(unsigned dirIndex, bool &isAltStreamDir) const
+{
+ isAltStreamDir = false;
+ const CProxyDir2 &dir = Dirs[dirIndex];
+ if (dirIndex == k_Proxy2_AltRootDirIndex)
+ isAltStreamDir = true;
+ else if (dirIndex >= k_Proxy2_NumRootDirs)
+ {
+ const CProxyFile2 &file = Files[(unsigned)dir.ArcIndex];
+ isAltStreamDir = ((int)dirIndex == file.AltDirIndex);
+ }
+ return dir.PathPrefix;
+}
+
+void CProxyArc2::AddRealIndices_of_ArcItem(unsigned arcIndex, bool includeAltStreams, CUIntVector &realIndices) const
+{
+ realIndices.Add(arcIndex);
+ const CProxyFile2 &file = Files[arcIndex];
+ if (file.DirIndex != -1)
+ AddRealIndices_of_Dir((unsigned)file.DirIndex, includeAltStreams, realIndices);
+ if (includeAltStreams && file.AltDirIndex != -1)
+ AddRealIndices_of_Dir((unsigned)file.AltDirIndex, includeAltStreams, realIndices);
+}
+
+void CProxyArc2::AddRealIndices_of_Dir(unsigned dirIndex, bool includeAltStreams, CUIntVector &realIndices) const
+{
+ const CRecordVector<unsigned> &subFiles = Dirs[dirIndex].Items;
+ FOR_VECTOR (i, subFiles)
+ {
+ AddRealIndices_of_ArcItem(subFiles[i], includeAltStreams, realIndices);
+ }
+}
+
+unsigned CProxyArc2::GetRealIndex(unsigned dirIndex, unsigned index) const
+{
+ return Dirs[dirIndex].Items[index];
+}
+
+void CProxyArc2::GetRealIndices(unsigned dirIndex, const UInt32 *indices, UInt32 numItems, bool includeAltStreams, CUIntVector &realIndices) const
+{
+ const CProxyDir2 &dir = Dirs[dirIndex];
+ realIndices.Clear();
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ AddRealIndices_of_ArcItem(dir.Items[indices[i]], includeAltStreams, realIndices);
+ }
+ HeapSort(&realIndices.Front(), realIndices.Size());
+}
+
+void CProxyArc2::CalculateSizes(unsigned dirIndex, IInArchive *archive)
+{
+ CProxyDir2 &dir = Dirs[dirIndex];
+ dir.Size = dir.PackSize = 0;
+ dir.NumSubDirs = 0; // dir.SubDirs.Size();
+ dir.NumSubFiles = 0; // dir.Files.Size();
+ dir.CrcIsDefined = true;
+ dir.Crc = 0;
+
+ FOR_VECTOR (i, dir.Items)
+ {
+ UInt32 index = dir.Items[i];
+ UInt64 size, packSize;
+ bool sizeDefined = GetSize(archive, index, kpidSize, size);
+ dir.Size += size;
+ GetSize(archive, index, kpidPackSize, packSize);
+ dir.PackSize += packSize;
+ {
+ NCOM::CPropVariant prop;
+ if (archive->GetProperty(index, kpidCRC, &prop) == S_OK)
+ {
+ if (prop.vt == VT_UI4)
+ dir.Crc += prop.ulVal;
+ else if (prop.vt != VT_EMPTY || size != 0 || !sizeDefined)
+ dir.CrcIsDefined = false;
+ }
+ else
+ dir.CrcIsDefined = false;
+ }
+
+ const CProxyFile2 &subFile = Files[index];
+ if (subFile.DirIndex == -1)
+ {
+ dir.NumSubFiles++;
+ }
+ else
+ {
+ // 22.00: we normalize name
+ UString s = subFile.Name;
+ NArchive::NItemName::NormalizeSlashes_in_FileName_for_OsPath(s);
+ dir.NumSubDirs++;
+ CProxyDir2 &f = Dirs[subFile.DirIndex];
+ f.PathPrefix = dir.PathPrefix + s + WCHAR_PATH_SEPARATOR;
+ CalculateSizes((unsigned)subFile.DirIndex, archive);
+ dir.Size += f.Size;
+ dir.PackSize += f.PackSize;
+ dir.NumSubFiles += f.NumSubFiles;
+ dir.NumSubDirs += f.NumSubDirs;
+ dir.Crc += f.Crc;
+ if (!f.CrcIsDefined)
+ dir.CrcIsDefined = false;
+ }
+
+ if (subFile.AltDirIndex == -1)
+ {
+ // dir.NumSubFiles++;
+ }
+ else
+ {
+ // dir.NumSubDirs++;
+ CProxyDir2 &f = Dirs[subFile.AltDirIndex];
+ f.PathPrefix = dir.PathPrefix + subFile.Name + L':';
+ CalculateSizes((unsigned)subFile.AltDirIndex, archive);
+ }
+ }
+}
+
+
+bool CProxyArc2::IsThere_SubDir(unsigned dirIndex, const UString &name) const
+{
+ const CRecordVector<unsigned> &subFiles = Dirs[dirIndex].Items;
+ FOR_VECTOR (i, subFiles)
+ {
+ const CProxyFile2 &file = Files[subFiles[i]];
+ if (file.IsDir())
+ if (CompareFileNames(name, file.Name) == 0)
+ return true;
+ }
+ return false;
+}
+
+HRESULT CProxyArc2::Load(const CArc &arc, IProgress *progress)
+{
+ if (!arc.GetRawProps)
+ return E_FAIL;
+
+ // DWORD tickCount = GetTickCount(); for (int ttt = 0; ttt < 1; ttt++) {
+
+ Dirs.Clear();
+ Files.Free();
+
+ IInArchive *archive = arc.Archive;
+
+ UInt32 numItems;
+ RINOK(archive->GetNumberOfItems(&numItems))
+ if (progress)
+ RINOK(progress->SetTotal(numItems))
+ UString fileName;
+
+
+ {
+ // Dirs[0] - root dir
+ /* CProxyDir2 &dir = */ Dirs.AddNew();
+ }
+
+ {
+ // Dirs[1] - for alt streams of root dir
+ CProxyDir2 &dir = Dirs.AddNew();
+ dir.PathPrefix = ':';
+ }
+
+ Files.Alloc(numItems);
+
+ UString tempUString;
+ AString tempAString;
+
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ if (progress && (i & 0xFFFFF) == 0)
+ {
+ UInt64 currentItemIndex = i;
+ RINOK(progress->SetCompleted(¤tItemIndex))
+ }
+
+ CProxyFile2 &file = Files[i];
+
+ const void *p;
+ UInt32 size;
+ UInt32 propType;
+ RINOK(arc.GetRawProps->GetRawProp(i, kpidName, &p, &size, &propType))
+
+ #ifdef MY_CPU_LE
+ if (p && propType == PROP_DATA_TYPE_wchar_t_PTR_Z_LE)
+ {
+ file.Name = (const wchar_t *)p;
+ file.NameLen = 0;
+ if (size >= sizeof(wchar_t))
+ file.NameLen = size / sizeof(wchar_t) - 1;
+ }
+ else
+ #endif
+ if (p && propType == NPropDataType::kUtf8z)
+ {
+ tempAString = (const char *)p;
+ ConvertUTF8ToUnicode(tempAString, tempUString);
+ file.NameLen = tempUString.Len();
+ file.Name = AllocStringAndCopy(tempUString);
+ file.NeedDeleteName = true;
+ }
+ else
+ {
+ NCOM::CPropVariant prop;
+ RINOK(arc.Archive->GetProperty(i, kpidName, &prop))
+ const wchar_t *s;
+ if (prop.vt == VT_BSTR)
+ s = prop.bstrVal;
+ else if (prop.vt == VT_EMPTY)
+ s = L"[Content]";
+ else
+ return E_FAIL;
+ file.NameLen = MyStringLen(s);
+ file.Name = AllocStringAndCopy(s, file.NameLen);
+ file.NeedDeleteName = true;
+ }
+
+ UInt32 parent = (UInt32)(Int32)-1;
+ UInt32 parentType = 0;
+ RINOK(arc.GetRawProps->GetParent(i, &parent, &parentType))
+ file.Parent = (Int32)parent;
+
+ if (arc.Ask_Deleted)
+ {
+ bool isDeleted = false;
+ RINOK(Archive_IsItem_Deleted(archive, i, isDeleted))
+ if (isDeleted)
+ {
+ // continue;
+ // curItem = AddDirSubItem(curItem, (UInt32)(Int32)-1, false, L"[DELETED]");
+ }
+ }
+
+ bool isDir;
+ RINOK(Archive_IsItem_Dir(archive, i, isDir))
+
+ if (isDir)
+ {
+ file.DirIndex = (int)Dirs.Size();
+ CProxyDir2 &dir = Dirs.AddNew();
+ dir.ArcIndex = (int)i;
+ }
+ if (arc.Ask_AltStream)
+ RINOK(Archive_IsItem_AltStream(archive, i, file.IsAltStream))
+ }
+
+ for (i = 0; i < numItems; i++)
+ {
+ CProxyFile2 &file = Files[i];
+ int dirIndex;
+
+ if (file.IsAltStream)
+ {
+ if (file.Parent == -1)
+ dirIndex = k_Proxy2_AltRootDirIndex;
+ else
+ {
+ int &folderIndex2 = Files[(unsigned)file.Parent].AltDirIndex;
+ if (folderIndex2 == -1)
+ {
+ folderIndex2 = (int)Dirs.Size();
+ CProxyDir2 &dir = Dirs.AddNew();
+ dir.ArcIndex = file.Parent;
+ }
+ dirIndex = folderIndex2;
+ }
+ }
+ else
+ {
+ if (file.Parent == -1)
+ dirIndex = k_Proxy2_RootDirIndex;
+ else
+ {
+ dirIndex = Files[(unsigned)file.Parent].DirIndex;
+ if (dirIndex == -1)
+ return E_FAIL;
+ }
+ }
+
+ Dirs[dirIndex].Items.Add(i);
+ }
+
+ for (i = 0; i < k_Proxy2_NumRootDirs; i++)
+ CalculateSizes(i, archive);
+
+ // } char s[128]; sprintf(s, "Load archive: %7d ms", GetTickCount() - tickCount); OutputDebugStringA(s);
+
+ return S_OK;
+}
+
+int CProxyArc2::FindItem(unsigned dirIndex, const wchar_t *name, bool foldersOnly) const
+{
+ const CProxyDir2 &dir = Dirs[dirIndex];
+ FOR_VECTOR (i, dir.Items)
+ {
+ const CProxyFile2 &file = Files[dir.Items[i]];
+ if (foldersOnly && file.DirIndex == -1)
+ continue;
+ if (CompareFileNames(file.Name, name) == 0)
+ return (int)i;
+ }
+ return -1;
+}
diff --git a/CPP/7zip/UI/Agent/AgentProxy.h b/CPP/7zip/UI/Agent/AgentProxy.h
new file mode 100644
index 0000000..c24dd91
--- /dev/null
+++ b/CPP/7zip/UI/Agent/AgentProxy.h
@@ -0,0 +1,162 @@
+// AgentProxy.h
+
+#ifndef ZIP7_INC_AGENT_PROXY_H
+#define ZIP7_INC_AGENT_PROXY_H
+
+#include "../Common/OpenArchive.h"
+
+struct CProxyFile
+{
+ const wchar_t *Name;
+ unsigned NameLen;
+ bool NeedDeleteName;
+
+ CProxyFile(): Name(NULL), NameLen(0), NeedDeleteName(false) {}
+ ~CProxyFile() { if (NeedDeleteName) delete [](wchar_t *)(void *)Name; } // delete [](wchar_t *)Name;
+};
+
+const unsigned k_Proxy_RootDirIndex = 0;
+
+struct CProxyDir
+{
+ const wchar_t *Name;
+ unsigned NameLen;
+
+ int ArcIndex; // index in proxy->Files[] ; -1 if there is no item for that folder
+ int ParentDir; // index in proxy->Dirs[] ; -1 for root folder; ;
+ CRecordVector<unsigned> SubDirs;
+ CRecordVector<unsigned> SubFiles;
+
+ UInt64 Size;
+ UInt64 PackSize;
+ UInt32 Crc;
+ UInt32 NumSubDirs;
+ UInt32 NumSubFiles;
+ bool CrcIsDefined;
+
+ CProxyDir(): Name(NULL), NameLen(0), ParentDir(-1) {}
+ ~CProxyDir() { delete [](wchar_t *)(void *)Name; }
+
+ void Clear();
+ bool IsLeaf() const { return ArcIndex != -1; }
+};
+
+class CProxyArc
+{
+ int FindSubDir(unsigned dirIndex, const wchar_t *name, unsigned &insertPos) const;
+
+ void CalculateSizes(unsigned dirIndex, IInArchive *archive);
+ unsigned AddDir(unsigned dirIndex, int arcIndex, const UString &name);
+public:
+ CObjectVector<CProxyDir> Dirs; // Dirs[0] - root
+ CObjArray<CProxyFile> Files; // all items from archive in same order
+
+ // returns index in Dirs[], or -1,
+ int FindSubDir(unsigned dirIndex, const wchar_t *name) const;
+
+ void GetDirPathParts(unsigned dirIndex, UStringVector &pathParts) const;
+ // returns full path of Dirs[dirIndex], including back slash
+ UString GetDirPath_as_Prefix(unsigned dirIndex) const;
+
+ // AddRealIndices DOES ADD also item represented by dirIndex (if it's Leaf)
+ void AddRealIndices(unsigned dirIndex, CUIntVector &realIndices) const;
+ int GetRealIndex(unsigned dirIndex, unsigned index) const;
+ void GetRealIndices(unsigned dirIndex, const UInt32 *indices, UInt32 numItems, CUIntVector &realIndices) const;
+
+ HRESULT Load(const CArc &arc, IProgress *progress);
+};
+
+
+// ---------- for Tree-mode archive ----------
+
+struct CProxyFile2
+{
+ int DirIndex; // >= 0 for dir. (index in ProxyArchive2->Dirs)
+ int AltDirIndex; // >= 0 if there are alt streams. (index in ProxyArchive2->Dirs)
+ int Parent; // >= 0 if there is parent. (index in archive and in ProxyArchive2->Files)
+ const wchar_t *Name;
+ unsigned NameLen;
+ bool NeedDeleteName;
+ bool Ignore;
+ bool IsAltStream;
+
+ int GetDirIndex(bool forAltStreams) const { return forAltStreams ? AltDirIndex : DirIndex; }
+
+ bool IsDir() const { return DirIndex != -1; }
+ CProxyFile2():
+ DirIndex(-1), AltDirIndex(-1), Parent(-1),
+ Name(NULL), NameLen(0),
+ NeedDeleteName(false),
+ Ignore(false),
+ IsAltStream(false)
+ {}
+ ~CProxyFile2()
+ {
+ if (NeedDeleteName)
+ delete [](wchar_t *)(void *)Name;
+ }
+};
+
+struct CProxyDir2
+{
+ int ArcIndex; // = -1 for root folders, index in proxy->Files[]
+ CRecordVector<unsigned> Items;
+ UString PathPrefix;
+ UInt64 Size;
+ UInt64 PackSize;
+ bool CrcIsDefined;
+ UInt32 Crc;
+ UInt32 NumSubDirs;
+ UInt32 NumSubFiles;
+
+ CProxyDir2(): ArcIndex(-1) {}
+ void AddFileSubItem(UInt32 index, const UString &name);
+ void Clear();
+};
+
+const unsigned k_Proxy2_RootDirIndex = k_Proxy_RootDirIndex;
+const unsigned k_Proxy2_AltRootDirIndex = 1;
+const unsigned k_Proxy2_NumRootDirs = 2;
+
+class CProxyArc2
+{
+ void CalculateSizes(unsigned dirIndex, IInArchive *archive);
+ // AddRealIndices_of_Dir DOES NOT ADD item itself represented by dirIndex
+ void AddRealIndices_of_Dir(unsigned dirIndex, bool includeAltStreams, CUIntVector &realIndices) const;
+public:
+ CObjectVector<CProxyDir2> Dirs; // Dirs[0] - root folder
+ // Dirs[1] - for alt streams of root dir
+ CObjArray<CProxyFile2> Files; // all items from archive in same order
+
+ bool IsThere_SubDir(unsigned dirIndex, const UString &name) const;
+
+ void GetDirPathParts(unsigned dirIndex, UStringVector &pathParts, bool &isAltStreamDir) const;
+ UString GetDirPath_as_Prefix(unsigned dirIndex, bool &isAltStreamDir) const;
+ bool IsAltDir(unsigned dirIndex) const;
+
+ // AddRealIndices_of_ArcItem DOES ADD item and subItems
+ void AddRealIndices_of_ArcItem(unsigned arcIndex, bool includeAltStreams, CUIntVector &realIndices) const;
+ unsigned GetRealIndex(unsigned dirIndex, unsigned index) const;
+ void GetRealIndices(unsigned dirIndex, const UInt32 *indices, UInt32 numItems, bool includeAltStreams, CUIntVector &realIndices) const;
+
+ HRESULT Load(const CArc &arc, IProgress *progress);
+
+ int GetParentDirOfFile(UInt32 arcIndex) const
+ {
+ const CProxyFile2 &file = Files[arcIndex];
+
+ if (file.Parent == -1)
+ return file.IsAltStream ?
+ k_Proxy2_AltRootDirIndex :
+ k_Proxy2_RootDirIndex;
+
+ const CProxyFile2 &parentFile = Files[file.Parent];
+ return file.IsAltStream ?
+ parentFile.AltDirIndex :
+ parentFile.DirIndex;
+ }
+
+ int FindItem(unsigned dirIndex, const wchar_t *name, bool foldersOnly) const;
+};
+
+#endif
diff --git a/CPP/7zip/UI/Agent/ArchiveFolder.cpp b/CPP/7zip/UI/Agent/ArchiveFolder.cpp
new file mode 100644
index 0000000..89b20dc
--- /dev/null
+++ b/CPP/7zip/UI/Agent/ArchiveFolder.cpp
@@ -0,0 +1,51 @@
+// Agent/ArchiveFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../Common/ArchiveExtractCallback.h"
+
+#include "Agent.h"
+
+/*
+Z7_COM7F_IMF(CAgentFolder::SetReplaceAltStreamCharsMode(Int32 replaceAltStreamCharsMode))
+{
+ _replaceAltStreamCharsMode = replaceAltStreamCharsMode;
+ return S_OK;
+}
+*/
+
+Z7_COM7F_IMF(CAgentFolder::SetZoneIdMode(NExtract::NZoneIdMode::EEnum zoneMode))
+{
+ _zoneMode = zoneMode;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CAgentFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+ Int32 includeAltStreams, Int32 replaceAltStreamCharsMode,
+ const wchar_t *path, IFolderOperationsExtractCallback *callback))
+{
+ if (moveMode)
+ return E_NOTIMPL;
+ COM_TRY_BEGIN
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback2;
+ {
+ CMyComPtr<IFolderOperationsExtractCallback> callbackWrap = callback;
+ RINOK(callbackWrap.QueryInterface(IID_IFolderArchiveExtractCallback, &extractCallback2))
+ }
+ NExtract::NPathMode::EEnum pathMode;
+ if (!_flatMode)
+ pathMode = NExtract::NPathMode::kCurPaths;
+ else
+ pathMode = (_proxy2 && _loadAltStreams) ?
+ NExtract::NPathMode::kNoPathsAlt :
+ NExtract::NPathMode::kNoPaths;
+
+ return Extract(indices, numItems,
+ includeAltStreams, replaceAltStreamCharsMode,
+ pathMode, NExtract::NOverwriteMode::kAsk,
+ path, BoolToInt(false), extractCallback2);
+ COM_TRY_END
+}
diff --git a/CPP/7zip/UI/Agent/ArchiveFolderOpen.cpp b/CPP/7zip/UI/Agent/ArchiveFolderOpen.cpp
new file mode 100644
index 0000000..3fa027d
--- /dev/null
+++ b/CPP/7zip/UI/Agent/ArchiveFolderOpen.cpp
@@ -0,0 +1,231 @@
+// Agent/ArchiveFolderOpen.cpp
+
+#include "StdAfx.h"
+
+// #ifdef NEW_FOLDER_INTERFACE
+
+#include "../../../Common/StringToInt.h"
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "Agent.h"
+
+extern HINSTANCE g_hInstance;
+static const UINT kIconTypesResId = 100;
+
+void CCodecIcons::LoadIcons(HMODULE m)
+{
+ IconPairs.Clear();
+ UString iconTypes;
+ NWindows::MyLoadString(m, kIconTypesResId, iconTypes);
+ UStringVector pairs;
+ SplitString(iconTypes, pairs);
+ FOR_VECTOR (i, pairs)
+ {
+ const UString &s = pairs[i];
+ int pos = s.Find(L':');
+ CIconPair iconPair;
+ iconPair.IconIndex = -1;
+ if (pos < 0)
+ pos = (int)s.Len();
+ else
+ {
+ const UString num = s.Ptr((unsigned)pos + 1);
+ if (!num.IsEmpty())
+ {
+ const wchar_t *end;
+ iconPair.IconIndex = (int)ConvertStringToUInt32(num, &end);
+ if (*end != 0)
+ continue;
+ }
+ }
+ iconPair.Ext = s.Left((unsigned)pos);
+ IconPairs.Add(iconPair);
+ }
+}
+
+bool CCodecIcons::FindIconIndex(const UString &ext, int &iconIndex) const
+{
+ iconIndex = -1;
+ FOR_VECTOR (i, IconPairs)
+ {
+ const CIconPair &pair = IconPairs[i];
+ if (ext.IsEqualTo_NoCase(pair.Ext))
+ {
+ iconIndex = pair.IconIndex;
+ return true;
+ }
+ }
+ return false;
+}
+
+
+void CArchiveFolderManager::LoadFormats()
+{
+ if (WasLoaded)
+ return;
+
+ LoadGlobalCodecs();
+
+ #ifdef Z7_EXTERNAL_CODECS
+ CodecIconsVector.Clear();
+ FOR_VECTOR (i, g_CodecsObj->Libs)
+ {
+ CCodecIcons &ci = CodecIconsVector.AddNew();
+ ci.LoadIcons(g_CodecsObj->Libs[i].Lib.Get_HMODULE());
+ }
+ #endif
+ InternalIcons.LoadIcons(g_hInstance);
+ WasLoaded = true;
+}
+
+/*
+int CArchiveFolderManager::FindFormat(const UString &type)
+{
+ FOR_VECTOR (i, g_CodecsObj->Formats)
+ if (type.IsEqualTo_NoCase(g_CodecsObj->Formats[i].Name))
+ return (int)i;
+ return -1;
+}
+*/
+
+Z7_COM7F_IMF(CArchiveFolderManager::OpenFolderFile(IInStream *inStream,
+ const wchar_t *filePath, const wchar_t *arcFormat,
+ IFolderFolder **resultFolder, IProgress *progress))
+{
+ CMyComPtr<IArchiveOpenCallback> openArchiveCallback;
+ if (progress)
+ {
+ CMyComPtr<IProgress> progressWrapper = progress;
+ progressWrapper.QueryInterface(IID_IArchiveOpenCallback, &openArchiveCallback);
+ }
+ CAgent *agent = new CAgent();
+ CMyComPtr<IInFolderArchive> archive = agent;
+
+ const HRESULT res = archive->Open(inStream, filePath, arcFormat, NULL, openArchiveCallback);
+
+ if (res != S_OK)
+ {
+ if (res != S_FALSE)
+ return res;
+ /* 20.01: we create folder even for Non-Open cases, if there is NonOpen_ErrorInfo information.
+ So we can get error information from that IFolderFolder later. */
+ if (!agent->_archiveLink.NonOpen_ErrorInfo.IsThereErrorOrWarning())
+ return res;
+ }
+
+ RINOK(archive->BindToRootFolder(resultFolder))
+ return res;
+}
+
+/*
+HRESULT CAgent::FolderReOpen(
+ IArchiveOpenCallback *openArchiveCallback)
+{
+ return ReOpenArchive(_archive, _archiveFilePath);
+}
+*/
+
+
+/*
+Z7_COM7F_IMF(CArchiveFolderManager::GetExtensions(const wchar_t *type, BSTR *extensions))
+{
+ *extensions = 0;
+ int formatIndex = FindFormat(type);
+ if (formatIndex < 0)
+ return E_INVALIDARG;
+ // Exts[0].Ext;
+ return StringToBstr(g_CodecsObj.Formats[formatIndex].GetAllExtensions(), extensions);
+}
+*/
+
+static void AddIconExt(const CCodecIcons &lib, UString &dest)
+{
+ FOR_VECTOR (i, lib.IconPairs)
+ {
+ dest.Add_Space_if_NotEmpty();
+ dest += lib.IconPairs[i].Ext;
+ }
+}
+
+
+Z7_COM7F_IMF(CArchiveFolderManager::GetExtensions(BSTR *extensions))
+{
+ *extensions = NULL;
+ LoadFormats();
+ UString res;
+
+ #ifdef Z7_EXTERNAL_CODECS
+ /*
+ FOR_VECTOR (i, g_CodecsObj->Libs)
+ AddIconExt(g_CodecsObj->Libs[i].CodecIcons, res);
+ */
+ FOR_VECTOR (i, CodecIconsVector)
+ AddIconExt(CodecIconsVector[i], res);
+ #endif
+
+ AddIconExt(
+ // g_CodecsObj->
+ InternalIcons, res);
+
+ return StringToBstr(res, extensions);
+}
+
+
+Z7_COM7F_IMF(CArchiveFolderManager::GetIconPath(const wchar_t *ext, BSTR *iconPath, Int32 *iconIndex))
+{
+ *iconPath = NULL;
+ *iconIndex = 0;
+ LoadFormats();
+
+ #ifdef Z7_EXTERNAL_CODECS
+ // FOR_VECTOR (i, g_CodecsObj->Libs)
+ FOR_VECTOR (i, CodecIconsVector)
+ {
+ int ii;
+ if (CodecIconsVector[i].FindIconIndex(ext, ii))
+ {
+ const CCodecLib &lib = g_CodecsObj->Libs[i];
+ *iconIndex = ii;
+ return StringToBstr(fs2us(lib.Path), iconPath);
+ }
+ }
+ #endif
+
+ int ii;
+ if (InternalIcons.FindIconIndex(ext, ii))
+ {
+ FString path;
+ if (NWindows::NDLL::MyGetModuleFileName(path))
+ {
+ *iconIndex = ii;
+ return StringToBstr(fs2us(path), iconPath);
+ }
+ }
+ return S_OK;
+}
+
+/*
+Z7_COM7F_IMF(CArchiveFolderManager::GetTypes(BSTR *types))
+{
+ LoadFormats();
+ UString typesStrings;
+ FOR_VECTOR(i, g_CodecsObj.Formats)
+ {
+ const CArcInfoEx &ai = g_CodecsObj.Formats[i];
+ if (ai.AssociateExts.Size() == 0)
+ continue;
+ if (i != 0)
+ typesStrings.Add_Space();
+ typesStrings += ai.Name;
+ }
+ return StringToBstr(typesStrings, types);
+}
+Z7_COM7F_IMF(CArchiveFolderManager::CreateFolderFile(const wchar_t * type,
+ const wchar_t * filePath, IProgress progress))
+{
+ return E_NOTIMPL;
+}
+*/
+
+// #endif
diff --git a/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp b/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp
new file mode 100644
index 0000000..0189224
--- /dev/null
+++ b/CPP/7zip/UI/Agent/ArchiveFolderOut.cpp
@@ -0,0 +1,386 @@
+// ArchiveFolderOut.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../../Windows/FileDir.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/LimitedStreams.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../Common/WorkDir.h"
+
+#include "Agent.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+void CAgentFolder::GetPathParts(UStringVector &pathParts, bool &isAltStreamFolder)
+{
+ if (_proxy2)
+ _proxy2->GetDirPathParts(_proxyDirIndex, pathParts, isAltStreamFolder);
+ else
+ _proxy->GetDirPathParts(_proxyDirIndex, pathParts);
+}
+
+static bool Delete_EmptyFolder_And_EmptySubFolders(const FString &path)
+{
+ {
+ const FString pathPrefix = path + FCHAR_PATH_SEPARATOR;
+ CObjectVector<FString> names;
+ {
+ NFind::CDirEntry fileInfo;
+ NFind::CEnumerator enumerator;
+ enumerator.SetDirPrefix(pathPrefix);
+ for (;;)
+ {
+ bool found;
+ if (!enumerator.Next(fileInfo, found))
+ return false;
+ if (!found)
+ break;
+ if (fileInfo.IsDir())
+ names.Add(fileInfo.Name);
+ }
+ }
+ bool res = true;
+ FOR_VECTOR (i, names)
+ {
+ if (!Delete_EmptyFolder_And_EmptySubFolders(pathPrefix + names[i]))
+ res = false;
+ }
+ if (!res)
+ return false;
+ }
+ // we clear read-only attrib to remove read-only dir
+ if (!SetFileAttrib(path, 0))
+ return false;
+ return RemoveDir(path);
+}
+
+HRESULT CAgentFolder::CommonUpdateOperation(
+ AGENT_OP operation,
+ bool moveMode,
+ const wchar_t *newItemName,
+ const NUpdateArchive::CActionSet *actionSet,
+ const UInt32 *indices, UInt32 numItems,
+ IProgress *progress)
+{
+ if (moveMode && _agentSpec->_isHashHandler)
+ return E_NOTIMPL;
+
+ if (!_agentSpec->CanUpdate())
+ return E_NOTIMPL;
+
+ CMyComPtr<IFolderArchiveUpdateCallback> updateCallback100;
+ if (progress)
+ progress->QueryInterface(IID_IFolderArchiveUpdateCallback, (void **)&updateCallback100);
+
+ try
+ {
+
+ RINOK(_agentSpec->SetFolder(this))
+
+ // ---------- Save FolderItem ----------
+
+ UStringVector pathParts;
+ bool isAltStreamFolder = false;
+ GetPathParts(pathParts, isAltStreamFolder);
+
+ FStringVector requestedPaths;
+ FStringVector processedPaths;
+
+ CWorkDirTempFile tempFile;
+ RINOK(tempFile.CreateTempFile(us2fs(_agentSpec->_archiveFilePath)))
+ {
+ CMyComPtr<IOutStream> tailStream;
+ const CArc &arc = *_agentSpec->_archiveLink.GetArc();
+
+ if (arc.ArcStreamOffset == 0)
+ tailStream = tempFile.OutStream;
+ else
+ {
+ if (arc.Offset < 0)
+ return E_NOTIMPL;
+ RINOK(arc.InStream->Seek(0, STREAM_SEEK_SET, NULL))
+ RINOK(NCompress::CopyStream_ExactSize(arc.InStream, tempFile.OutStream, arc.ArcStreamOffset, NULL))
+ CTailOutStream *tailStreamSpec = new CTailOutStream;
+ tailStream = tailStreamSpec;
+ tailStreamSpec->Stream = tempFile.OutStream;
+ tailStreamSpec->Offset = arc.ArcStreamOffset;
+ tailStreamSpec->Init();
+ }
+
+ HRESULT result;
+
+ switch ((int)operation)
+ {
+ case AGENT_OP_Delete:
+ result = _agentSpec->DeleteItems(tailStream, indices, numItems, updateCallback100);
+ break;
+ case AGENT_OP_CreateFolder:
+ result = _agentSpec->CreateFolder(tailStream, newItemName, updateCallback100);
+ break;
+ case AGENT_OP_Rename:
+ result = _agentSpec->RenameItem(tailStream, indices, numItems, newItemName, updateCallback100);
+ break;
+ case AGENT_OP_Comment:
+ result = _agentSpec->CommentItem(tailStream, indices, numItems, newItemName, updateCallback100);
+ break;
+ case AGENT_OP_CopyFromFile:
+ result = _agentSpec->UpdateOneFile(tailStream, indices, numItems, newItemName, updateCallback100);
+ break;
+ case AGENT_OP_Uni:
+ {
+ Byte actionSetByte[NUpdateArchive::NPairState::kNumValues];
+ for (unsigned i = 0; i < NUpdateArchive::NPairState::kNumValues; i++)
+ actionSetByte[i] = (Byte)actionSet->StateActions[i];
+ result = _agentSpec->DoOperation2(
+ moveMode ? &requestedPaths : NULL,
+ moveMode ? &processedPaths : NULL,
+ tailStream, actionSetByte, NULL, updateCallback100);
+ break;
+ }
+ default:
+ return E_FAIL;
+ }
+
+ RINOK(result)
+ }
+
+ _agentSpec->KeepModeForNextOpen();
+ _agent->Close();
+
+ // before 9.26: if there was error for MoveToOriginal archive was closed.
+ // now: we reopen archive after close
+
+ // m_FolderItem = NULL;
+
+ const HRESULT res = tempFile.MoveToOriginal(true);
+
+ // RINOK(res);
+ if (res == S_OK)
+ {
+ if (moveMode)
+ {
+ unsigned i;
+ for (i = 0; i < processedPaths.Size(); i++)
+ {
+ DeleteFileAlways(processedPaths[i]);
+ }
+ for (i = 0; i < requestedPaths.Size(); i++)
+ {
+ const FString &fs = requestedPaths[i];
+ if (NFind::DoesDirExist(fs))
+ Delete_EmptyFolder_And_EmptySubFolders(fs);
+ }
+ }
+ }
+
+ {
+ CMyComPtr<IArchiveOpenCallback> openCallback;
+ if (updateCallback100)
+ updateCallback100->QueryInterface(IID_IArchiveOpenCallback, (void **)&openCallback);
+ RINOK(_agent->ReOpen(openCallback))
+ }
+
+ // CAgent::ReOpen() deletes _proxy and _proxy2
+ _items.Clear();
+ _proxy = NULL;
+ _proxy2 = NULL;
+ _proxyDirIndex = k_Proxy_RootDirIndex;
+ _isAltStreamFolder = false;
+
+
+ // ---------- Restore FolderItem ----------
+
+ CMyComPtr<IFolderFolder> archiveFolder;
+ RINOK(_agent->BindToRootFolder(&archiveFolder))
+
+ // CAgent::BindToRootFolder() changes _proxy and _proxy2
+ _proxy = _agentSpec->_proxy;
+ _proxy2 = _agentSpec->_proxy2;
+
+ if (_proxy)
+ {
+ FOR_VECTOR (i, pathParts)
+ {
+ const int next = _proxy->FindSubDir(_proxyDirIndex, pathParts[i]);
+ if (next == -1)
+ break;
+ _proxyDirIndex = (unsigned)next;
+ }
+ }
+
+ if (_proxy2)
+ {
+ if (pathParts.IsEmpty() && isAltStreamFolder)
+ {
+ _proxyDirIndex = k_Proxy2_AltRootDirIndex;
+ }
+ else FOR_VECTOR (i, pathParts)
+ {
+ const bool dirOnly = (i + 1 < pathParts.Size() || !isAltStreamFolder);
+ const int index = _proxy2->FindItem(_proxyDirIndex, pathParts[i], dirOnly);
+ if (index == -1)
+ break;
+
+ const CProxyFile2 &file = _proxy2->Files[_proxy2->Dirs[_proxyDirIndex].Items[index]];
+
+ if (dirOnly)
+ _proxyDirIndex = (unsigned)file.DirIndex;
+ else
+ {
+ if (file.AltDirIndex != -1)
+ _proxyDirIndex = (unsigned)file.AltDirIndex;
+ break;
+ }
+ }
+ }
+
+ /*
+ if (pathParts.IsEmpty() && isAltStreamFolder)
+ {
+ CMyComPtr<IFolderAltStreams> folderAltStreams;
+ archiveFolder.QueryInterface(IID_IFolderAltStreams, &folderAltStreams);
+ if (folderAltStreams)
+ {
+ CMyComPtr<IFolderFolder> newFolder;
+ folderAltStreams->BindToAltStreams((UInt32)(Int32)-1, &newFolder);
+ if (newFolder)
+ archiveFolder = newFolder;
+ }
+ }
+
+ FOR_VECTOR (i, pathParts)
+ {
+ CMyComPtr<IFolderFolder> newFolder;
+
+ if (isAltStreamFolder && i == pathParts.Size() - 1)
+ {
+ CMyComPtr<IFolderAltStreams> folderAltStreams;
+ archiveFolder.QueryInterface(IID_IFolderAltStreams, &folderAltStreams);
+ if (folderAltStreams)
+ folderAltStreams->BindToAltStreams(pathParts[i], &newFolder);
+ }
+ else
+ archiveFolder->BindToFolder(pathParts[i], &newFolder);
+
+ if (!newFolder)
+ break;
+ archiveFolder = newFolder;
+ }
+
+ CMyComPtr<IArchiveFolderInternal> archiveFolderInternal;
+ RINOK(archiveFolder.QueryInterface(IID_IArchiveFolderInternal, &archiveFolderInternal));
+ CAgentFolder *agentFolder;
+ RINOK(archiveFolderInternal->GetAgentFolder(&agentFolder));
+ _proxyDirIndex = agentFolder->_proxyDirIndex;
+ // _parentFolder = agentFolder->_parentFolder;
+ */
+
+ if (_proxy2)
+ _isAltStreamFolder = _proxy2->IsAltDir(_proxyDirIndex);
+
+ return res;
+
+ }
+ catch(const UString &s)
+ {
+ if (updateCallback100)
+ {
+ UString s2 ("Error: ");
+ s2 += s;
+ RINOK(updateCallback100->UpdateErrorMessage(s2))
+ return E_FAIL;
+ }
+ throw;
+ }
+}
+
+
+Z7_COM7F_IMF(CAgentFolder::CopyFrom(Int32 moveMode,
+ const wchar_t *fromFolderPath, /* test it */
+ const wchar_t * const *itemsPaths,
+ UInt32 numItems,
+ IProgress *progress))
+{
+ COM_TRY_BEGIN
+ {
+ RINOK(_agentSpec->SetFiles(fromFolderPath, itemsPaths, numItems))
+ return CommonUpdateOperation(AGENT_OP_Uni, (moveMode != 0), NULL,
+ &NUpdateArchive::k_ActionSet_Add,
+ NULL, 0, progress);
+ }
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::CopyFromFile(UInt32 destIndex, const wchar_t *itemPath, IProgress *progress))
+{
+ COM_TRY_BEGIN
+ return CommonUpdateOperation(AGENT_OP_CopyFromFile, false, itemPath,
+ &NUpdateArchive::k_ActionSet_Add,
+ &destIndex, 1, progress);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::Delete(const UInt32 *indices, UInt32 numItems, IProgress *progress))
+{
+ COM_TRY_BEGIN
+ return CommonUpdateOperation(AGENT_OP_Delete, false, NULL,
+ &NUpdateArchive::k_ActionSet_Delete, indices, numItems, progress);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::CreateFolder(const wchar_t *name, IProgress *progress))
+{
+ COM_TRY_BEGIN
+
+ if (_isAltStreamFolder)
+ return E_NOTIMPL;
+
+ if (_proxy2)
+ {
+ if (_proxy2->IsThere_SubDir(_proxyDirIndex, name))
+ return ERROR_ALREADY_EXISTS;
+ }
+ else
+ {
+ if (_proxy->FindSubDir(_proxyDirIndex, name) != -1)
+ return ERROR_ALREADY_EXISTS;
+ }
+
+ return CommonUpdateOperation(AGENT_OP_CreateFolder, false, name, NULL, NULL, 0, progress);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::Rename(UInt32 index, const wchar_t *newName, IProgress *progress))
+{
+ COM_TRY_BEGIN
+ return CommonUpdateOperation(AGENT_OP_Rename, false, newName, NULL,
+ &index, 1, progress);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAgentFolder::CreateFile(const wchar_t * /* name */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CAgentFolder::SetProperty(UInt32 index, PROPID propID,
+ const PROPVARIANT *value, IProgress *progress))
+{
+ COM_TRY_BEGIN
+ if (propID != kpidComment || value->vt != VT_BSTR)
+ return E_NOTIMPL;
+ if (!_agentSpec || !_agentSpec->GetTypeOfArc(_agentSpec->GetArc()).IsEqualTo_Ascii_NoCase("zip"))
+ return E_NOTIMPL;
+
+ return CommonUpdateOperation(AGENT_OP_Comment, false, value->bstrVal, NULL,
+ &index, 1, progress);
+ COM_TRY_END
+}
diff --git a/CPP/7zip/UI/Agent/IFolderArchive.h b/CPP/7zip/UI/Agent/IFolderArchive.h
new file mode 100644
index 0000000..55f1423
--- /dev/null
+++ b/CPP/7zip/UI/Agent/IFolderArchive.h
@@ -0,0 +1,107 @@
+// IFolderArchive.h
+
+#ifndef ZIP7_INC_IFOLDER_ARCHIVE_H
+#define ZIP7_INC_IFOLDER_ARCHIVE_H
+
+#include "../../../Common/MyString.h"
+
+#include "../../Archive/IArchive.h"
+#include "../../UI/Common/LoadCodecs.h"
+#include "../../UI/FileManager/IFolder.h"
+
+#include "../Common/ExtractMode.h"
+#include "../Common/IFileExtractCallback.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+/* ---------- IArchiveFolder ----------
+IArchiveFolder is implemented by CAgentFolder (Agent/Agent.h)
+IArchiveFolder is used by:
+ - FileManager/PanelCopy.cpp
+ CPanel::CopyTo(), if (options->testMode)
+ - FAR/PluginRead.cpp
+ CPlugin::ExtractFiles
+*/
+
+#define Z7_IFACEM_IArchiveFolder(x) \
+ x(Extract(const UInt32 *indices, UInt32 numItems, \
+ Int32 includeAltStreams, \
+ Int32 replaceAltStreamCharsMode, \
+ NExtract::NPathMode::EEnum pathMode, \
+ NExtract::NOverwriteMode::EEnum overwriteMode, \
+ const wchar_t *path, Int32 testMode, \
+ IFolderArchiveExtractCallback *extractCallback2)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IArchiveFolder, 0x0D)
+
+
+/* ---------- IInFolderArchive ----------
+IInFolderArchive is implemented by CAgent (Agent/Agent.h)
+IInFolderArchive Is used by FAR/Plugin
+*/
+
+#define Z7_IFACEM_IInFolderArchive(x) \
+ x(Open(IInStream *inStream, const wchar_t *filePath, const wchar_t *arcFormat, BSTR *archiveTypeRes, IArchiveOpenCallback *openArchiveCallback)) \
+ x(ReOpen(IArchiveOpenCallback *openArchiveCallback)) \
+ x(Close()) \
+ x(GetNumberOfProperties(UInt32 *numProperties)) \
+ x(GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ x(BindToRootFolder(IFolderFolder **resultFolder)) \
+ x(Extract(NExtract::NPathMode::EEnum pathMode, \
+ NExtract::NOverwriteMode::EEnum overwriteMode, const wchar_t *path, \
+ Int32 testMode, IFolderArchiveExtractCallback *extractCallback2)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IInFolderArchive, 0x0E)
+
+#define Z7_IFACEM_IFolderArchiveUpdateCallback(x) \
+ x(CompressOperation(const wchar_t *name)) \
+ x(DeleteOperation(const wchar_t *name)) \
+ x(OperationResult(Int32 opRes)) \
+ x(UpdateErrorMessage(const wchar_t *message)) \
+ x(SetNumFiles(UInt64 numFiles)) \
+
+Z7_IFACE_CONSTR_FOLDERARC_SUB(IFolderArchiveUpdateCallback, IProgress, 0x0B)
+
+#define Z7_IFACEM_IOutFolderArchive(x) \
+ x(SetFolder(IFolderFolder *folder)) \
+ x(SetFiles(const wchar_t *folderPrefix, const wchar_t * const *names, UInt32 numNames)) \
+ x(DeleteItems(ISequentialOutStream *outArchiveStream, \
+ const UInt32 *indices, UInt32 numItems, IFolderArchiveUpdateCallback *updateCallback)) \
+ x(DoOperation( \
+ FStringVector *requestedPaths, \
+ FStringVector *processedPaths, \
+ CCodecs *codecs, int index, \
+ ISequentialOutStream *outArchiveStream, const Byte *stateActions, const wchar_t *sfxModule, \
+ IFolderArchiveUpdateCallback *updateCallback)) \
+ x(DoOperation2( \
+ FStringVector *requestedPaths, \
+ FStringVector *processedPaths, \
+ ISequentialOutStream *outArchiveStream, const Byte *stateActions, const wchar_t *sfxModule, \
+ IFolderArchiveUpdateCallback *updateCallback)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IOutFolderArchive, 0x0F)
+
+
+#define Z7_IFACEM_IFolderArchiveUpdateCallback2(x) \
+ x(OpenFileError(const wchar_t *path, HRESULT errorCode)) \
+ x(ReadingFileError(const wchar_t *path, HRESULT errorCode)) \
+ x(ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *path)) \
+ x(ReportUpdateOperation(UInt32 notifyOp, const wchar_t *path, Int32 isDir)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderArchiveUpdateCallback2, 0x10)
+
+
+#define Z7_IFACEM_IFolderScanProgress(x) \
+ x(ScanError(const wchar_t *path, HRESULT errorCode)) \
+ x(ScanProgress(UInt64 numFolders, UInt64 numFiles, UInt64 totalSize, const wchar_t *path, Int32 isDir)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderScanProgress, 0x11)
+
+
+#define Z7_IFACEM_IFolderSetZoneIdMode(x) \
+ x(SetZoneIdMode(NExtract::NZoneIdMode::EEnum zoneMode)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderSetZoneIdMode, 0x12)
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/UI/Agent/StdAfx.h b/CPP/7zip/UI/Agent/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/UI/Agent/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/UI/Agent/UpdateCallbackAgent.cpp b/CPP/7zip/UI/Agent/UpdateCallbackAgent.cpp
new file mode 100644
index 0000000..8299902
--- /dev/null
+++ b/CPP/7zip/UI/Agent/UpdateCallbackAgent.cpp
@@ -0,0 +1,208 @@
+// UpdateCallbackAgent.h
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/ErrorMsg.h"
+
+#include "UpdateCallbackAgent.h"
+
+using namespace NWindows;
+
+void CUpdateCallbackAgent::SetCallback(IFolderArchiveUpdateCallback *callback)
+{
+ Callback = callback;
+ _compressProgress.Release();
+ Callback2.Release();
+ if (Callback)
+ {
+ Callback.QueryInterface(IID_ICompressProgressInfo, &_compressProgress);
+ Callback.QueryInterface(IID_IFolderArchiveUpdateCallback2, &Callback2);
+ }
+}
+
+HRESULT CUpdateCallbackAgent::SetNumItems(const CArcToDoStat &stat)
+{
+ if (Callback)
+ return Callback->SetNumFiles(stat.Get_NumDataItems_Total());
+ return S_OK;
+}
+
+
+HRESULT CUpdateCallbackAgent::WriteSfx(const wchar_t * /* name */, UInt64 /* size */)
+{
+ return S_OK;
+}
+
+
+HRESULT CUpdateCallbackAgent::SetTotal(UINT64 size)
+{
+ if (Callback)
+ return Callback->SetTotal(size);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackAgent::SetCompleted(const UINT64 *completeValue)
+{
+ if (Callback)
+ return Callback->SetCompleted(completeValue);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackAgent::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+ if (_compressProgress)
+ return _compressProgress->SetRatioInfo(inSize, outSize);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackAgent::CheckBreak()
+{
+ return S_OK;
+}
+
+/*
+HRESULT CUpdateCallbackAgent::Finalize()
+{
+ return S_OK;
+}
+*/
+
+HRESULT CUpdateCallbackAgent::OpenFileError(const FString &path, DWORD systemError)
+{
+ const HRESULT hres = HRESULT_FROM_WIN32(systemError);
+ // if (systemError == ERROR_SHARING_VIOLATION)
+ {
+ if (Callback2)
+ {
+ RINOK(Callback2->OpenFileError(fs2us(path), hres))
+ return S_FALSE;
+ }
+
+ if (Callback)
+ {
+ UString s ("WARNING: ");
+ s += NError::MyFormatMessage(systemError);
+ s += ": ";
+ s += fs2us(path);
+ RINOK(Callback->UpdateErrorMessage(s))
+ return S_FALSE;
+ }
+ }
+ // FailedFiles.Add(name);
+ return hres;
+}
+
+HRESULT CUpdateCallbackAgent::ReadingFileError(const FString &path, DWORD systemError)
+{
+ const HRESULT hres = HRESULT_FROM_WIN32(systemError);
+
+ // if (systemError == ERROR_SHARING_VIOLATION)
+ {
+ if (Callback2)
+ {
+ RINOK(Callback2->ReadingFileError(fs2us(path), hres))
+ }
+ else if (Callback)
+ {
+ UString s ("ERROR: ");
+ s += NError::MyFormatMessage(systemError);
+ s += ": ";
+ s += fs2us(path);
+ RINOK(Callback->UpdateErrorMessage(s))
+ }
+ }
+ // FailedFiles.Add(name);
+ return hres;
+}
+
+HRESULT CUpdateCallbackAgent::GetStream(const wchar_t *name, bool isDir, bool /* isAnti */, UInt32 mode)
+{
+ if (Callback2)
+ return Callback2->ReportUpdateOperation(mode, name, BoolToInt(isDir));
+ if (Callback)
+ return Callback->CompressOperation(name);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackAgent::SetOperationResult(Int32 operationResult)
+{
+ if (Callback)
+ return Callback->OperationResult(operationResult);
+ return S_OK;
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s);
+
+HRESULT CUpdateCallbackAgent::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name)
+{
+ if (Callback2)
+ {
+ return Callback2->ReportExtractResult(opRes, isEncrypted, name);
+ }
+ /*
+ if (mode != NArchive::NExtract::NOperationResult::kOK)
+ {
+ Int32 encrypted = 0;
+ UString s;
+ SetExtractErrorMessage(mode, encrypted, name, s);
+ // ProgressDialog->Sync.AddError_Message(s);
+ }
+ */
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackAgent::ReportUpdateOperation(UInt32 op, const wchar_t *name, bool isDir)
+{
+ if (Callback2)
+ {
+ return Callback2->ReportUpdateOperation(op, name, BoolToInt(isDir));
+ }
+ return S_OK;
+}
+
+/*
+HRESULT CUpdateCallbackAgent::SetPassword(const UString &
+ #ifndef Z7_NO_CRYPTO
+ password
+ #endif
+ )
+{
+ #ifndef Z7_NO_CRYPTO
+ PasswordIsDefined = true;
+ Password = password;
+ #endif
+ return S_OK;
+}
+*/
+
+HRESULT CUpdateCallbackAgent::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
+{
+ *password = NULL;
+ *passwordIsDefined = BoolToInt(false);
+ if (!_cryptoGetTextPassword)
+ {
+ if (!Callback)
+ return S_OK;
+ Callback.QueryInterface(IID_ICryptoGetTextPassword2, &_cryptoGetTextPassword);
+ if (!_cryptoGetTextPassword)
+ return S_OK;
+ }
+ return _cryptoGetTextPassword->CryptoGetTextPassword2(passwordIsDefined, password);
+}
+
+HRESULT CUpdateCallbackAgent::CryptoGetTextPassword(BSTR *password)
+{
+ *password = NULL;
+ CMyComPtr<ICryptoGetTextPassword> getTextPassword;
+ Callback.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
+ if (!getTextPassword)
+ return E_NOTIMPL;
+ return getTextPassword->CryptoGetTextPassword(password);
+}
+
+HRESULT CUpdateCallbackAgent::ShowDeleteFile(const wchar_t *name, bool /* isDir */)
+{
+ return Callback->DeleteOperation(name);
+}
diff --git a/CPP/7zip/UI/Agent/UpdateCallbackAgent.h b/CPP/7zip/UI/Agent/UpdateCallbackAgent.h
new file mode 100644
index 0000000..179ce98
--- /dev/null
+++ b/CPP/7zip/UI/Agent/UpdateCallbackAgent.h
@@ -0,0 +1,22 @@
+// UpdateCallbackAgent.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK_AGENT_H
+#define ZIP7_INC_UPDATE_CALLBACK_AGENT_H
+
+#include "../Common/UpdateCallback.h"
+
+#include "IFolderArchive.h"
+
+class CUpdateCallbackAgent Z7_final: public IUpdateCallbackUI
+{
+ Z7_IFACE_IMP(IUpdateCallbackUI)
+
+ CMyComPtr<ICryptoGetTextPassword2> _cryptoGetTextPassword;
+ CMyComPtr<IFolderArchiveUpdateCallback> Callback;
+ CMyComPtr<IFolderArchiveUpdateCallback2> Callback2;
+ CMyComPtr<ICompressProgressInfo> _compressProgress;
+public:
+ void SetCallback(IFolderArchiveUpdateCallback *callback);
+};
+
+#endif
diff --git a/CPP/7zip/UI/Client7z/Client7z.cpp b/CPP/7zip/UI/Client7z/Client7z.cpp
index 9a06cdc..121a2f1 100644
--- a/CPP/7zip/UI/Client7z/Client7z.cpp
+++ b/CPP/7zip/UI/Client7z/Client7z.cpp
@@ -1,993 +1,1122 @@
-// Client7z.cpp
-
-#include "StdAfx.h"
-
-#include <stdio.h>
-
-#include "../../../Common/MyWindows.h"
-
-#include "../../../Common/Defs.h"
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/DLL.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/NtCheck.h"
-#include "../../../Windows/PropVariant.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#include "../../Common/FileStreams.h"
-
-#include "../../Archive/IArchive.h"
-
-#include "../../IPassword.h"
-#include "../../../../C/7zVersion.h"
-
-#ifdef _WIN32
-HINSTANCE g_hInstance = 0;
-#endif
-
-// Tou can find the list of all GUIDs in Guid.txt file.
-// use another CLSIDs, if you want to support other formats (zip, rar, ...).
-// {23170F69-40C1-278A-1000-000110070000}
-
-DEFINE_GUID(CLSID_CFormat7z,
- 0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x07, 0x00, 0x00);
-DEFINE_GUID(CLSID_CFormatXz,
- 0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x0C, 0x00, 0x00);
-
-#define CLSID_Format CLSID_CFormat7z
-// #define CLSID_Format CLSID_CFormatXz
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-#define kDllName "7z.dll"
-
-static const char * const kCopyrightString =
- "\n"
- "7-Zip"
- " (" kDllName " client)"
- " " MY_VERSION
- " : " MY_COPYRIGHT_DATE
- "\n";
-
-static const char * const kHelpString =
-"Usage: 7zcl.exe [a | l | x] archive.7z [fileName ...]\n"
-"Examples:\n"
-" 7zcl.exe a archive.7z f1.txt f2.txt : compress two files to archive.7z\n"
-" 7zcl.exe l archive.7z : List contents of archive.7z\n"
-" 7zcl.exe x archive.7z : eXtract files from archive.7z\n";
-
-
-static void Convert_UString_to_AString(const UString &s, AString &temp)
-{
- int codePage = CP_OEMCP;
- /*
- int g_CodePage = -1;
- int codePage = g_CodePage;
- if (codePage == -1)
- codePage = CP_OEMCP;
- if (codePage == CP_UTF8)
- ConvertUnicodeToUTF8(s, temp);
- else
- */
- UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
-}
-
-static FString CmdStringToFString(const char *s)
-{
- return us2fs(GetUnicodeString(s));
-}
-
-static void Print(const char *s)
-{
- fputs(s, stdout);
-}
-
-static void Print(const AString &s)
-{
- Print(s.Ptr());
-}
-
-static void Print(const UString &s)
-{
- AString as;
- Convert_UString_to_AString(s, as);
- Print(as);
-}
-
-static void Print(const wchar_t *s)
-{
- Print(UString(s));
-}
-
-static void PrintNewLine()
-{
- Print("\n");
-}
-
-static void PrintStringLn(const char *s)
-{
- Print(s);
- PrintNewLine();
-}
-
-static void PrintError(const char *message)
-{
- Print("Error: ");
- PrintNewLine();
- Print(message);
- PrintNewLine();
-}
-
-static void PrintError(const char *message, const FString &name)
-{
- PrintError(message);
- Print(name);
-}
-
-
-static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)
-{
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, propID, &prop));
- if (prop.vt == VT_BOOL)
- result = VARIANT_BOOLToBool(prop.boolVal);
- else if (prop.vt == VT_EMPTY)
- result = false;
- else
- return E_FAIL;
- return S_OK;
-}
-
-static HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result)
-{
- return IsArchiveItemProp(archive, index, kpidIsDir, result);
-}
-
-
-static const wchar_t * const kEmptyFileAlias = L"[Content]";
-
-
-//////////////////////////////////////////////////////////////
-// Archive Open callback class
-
-
-class CArchiveOpenCallback:
- public IArchiveOpenCallback,
- public ICryptoGetTextPassword,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
-
- STDMETHOD(SetTotal)(const UInt64 *files, const UInt64 *bytes);
- STDMETHOD(SetCompleted)(const UInt64 *files, const UInt64 *bytes);
-
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
-
- bool PasswordIsDefined;
- UString Password;
-
- CArchiveOpenCallback() : PasswordIsDefined(false) {}
-};
-
-STDMETHODIMP CArchiveOpenCallback::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveOpenCallback::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveOpenCallback::CryptoGetTextPassword(BSTR *password)
-{
- if (!PasswordIsDefined)
- {
- // You can ask real password here from user
- // Password = GetPassword(OutStream);
- // PasswordIsDefined = true;
- PrintError("Password is not defined");
- return E_ABORT;
- }
- return StringToBstr(Password, password);
-}
-
-
-
-static const char * const kIncorrectCommand = "incorrect command";
-
-//////////////////////////////////////////////////////////////
-// Archive Extracting callback class
-
-static const char * const kTestingString = "Testing ";
-static const char * const kExtractingString = "Extracting ";
-static const char * const kSkippingString = "Skipping ";
-
-static const char * const kUnsupportedMethod = "Unsupported Method";
-static const char * const kCRCFailed = "CRC Failed";
-static const char * const kDataError = "Data Error";
-static const char * const kUnavailableData = "Unavailable data";
-static const char * const kUnexpectedEnd = "Unexpected end of data";
-static const char * const kDataAfterEnd = "There are some data after the end of the payload data";
-static const char * const kIsNotArc = "Is not archive";
-static const char * const kHeadersError = "Headers Error";
-
-
-class CArchiveExtractCallback:
- public IArchiveExtractCallback,
- public ICryptoGetTextPassword,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
-
- // IProgress
- STDMETHOD(SetTotal)(UInt64 size);
- STDMETHOD(SetCompleted)(const UInt64 *completeValue);
-
- // IArchiveExtractCallback
- STDMETHOD(GetStream)(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode);
- STDMETHOD(PrepareOperation)(Int32 askExtractMode);
- STDMETHOD(SetOperationResult)(Int32 resultEOperationResult);
-
- // ICryptoGetTextPassword
- STDMETHOD(CryptoGetTextPassword)(BSTR *aPassword);
-
-private:
- CMyComPtr<IInArchive> _archiveHandler;
- FString _directoryPath; // Output directory
- UString _filePath; // name inside arcvhive
- FString _diskFilePath; // full path to file on disk
- bool _extractMode;
- struct CProcessedFileInfo
- {
- FILETIME MTime;
- UInt32 Attrib;
- bool isDir;
- bool AttribDefined;
- bool MTimeDefined;
- } _processedFileInfo;
-
- COutFileStream *_outFileStreamSpec;
- CMyComPtr<ISequentialOutStream> _outFileStream;
-
-public:
- void Init(IInArchive *archiveHandler, const FString &directoryPath);
-
- UInt64 NumErrors;
- bool PasswordIsDefined;
- UString Password;
-
- CArchiveExtractCallback() : PasswordIsDefined(false) {}
-};
-
-void CArchiveExtractCallback::Init(IInArchive *archiveHandler, const FString &directoryPath)
-{
- NumErrors = 0;
- _archiveHandler = archiveHandler;
- _directoryPath = directoryPath;
- NName::NormalizeDirPathPrefix(_directoryPath);
-}
-
-STDMETHODIMP CArchiveExtractCallback::SetTotal(UInt64 /* size */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveExtractCallback::SetCompleted(const UInt64 * /* completeValue */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveExtractCallback::GetStream(UInt32 index,
- ISequentialOutStream **outStream, Int32 askExtractMode)
-{
- *outStream = 0;
- _outFileStream.Release();
-
- {
- // Get Name
- NCOM::CPropVariant prop;
- RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop));
-
- UString fullPath;
- if (prop.vt == VT_EMPTY)
- fullPath = kEmptyFileAlias;
- else
- {
- if (prop.vt != VT_BSTR)
- return E_FAIL;
- fullPath = prop.bstrVal;
- }
- _filePath = fullPath;
- }
-
- if (askExtractMode != NArchive::NExtract::NAskMode::kExtract)
- return S_OK;
-
- {
- // Get Attrib
- NCOM::CPropVariant prop;
- RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop));
- if (prop.vt == VT_EMPTY)
- {
- _processedFileInfo.Attrib = 0;
- _processedFileInfo.AttribDefined = false;
- }
- else
- {
- if (prop.vt != VT_UI4)
- return E_FAIL;
- _processedFileInfo.Attrib = prop.ulVal;
- _processedFileInfo.AttribDefined = true;
- }
- }
-
- RINOK(IsArchiveItemFolder(_archiveHandler, index, _processedFileInfo.isDir));
-
- {
- // Get Modified Time
- NCOM::CPropVariant prop;
- RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop));
- _processedFileInfo.MTimeDefined = false;
- switch (prop.vt)
- {
- case VT_EMPTY:
- // _processedFileInfo.MTime = _utcMTimeDefault;
- break;
- case VT_FILETIME:
- _processedFileInfo.MTime = prop.filetime;
- _processedFileInfo.MTimeDefined = true;
- break;
- default:
- return E_FAIL;
- }
-
- }
- {
- // Get Size
- NCOM::CPropVariant prop;
- RINOK(_archiveHandler->GetProperty(index, kpidSize, &prop));
- UInt64 newFileSize;
- /* bool newFileSizeDefined = */ ConvertPropVariantToUInt64(prop, newFileSize);
- }
-
-
- {
- // Create folders for file
- int slashPos = _filePath.ReverseFind_PathSepar();
- if (slashPos >= 0)
- CreateComplexDir(_directoryPath + us2fs(_filePath.Left(slashPos)));
- }
-
- FString fullProcessedPath = _directoryPath + us2fs(_filePath);
- _diskFilePath = fullProcessedPath;
-
- if (_processedFileInfo.isDir)
- {
- CreateComplexDir(fullProcessedPath);
- }
- else
- {
- NFind::CFileInfo fi;
- if (fi.Find(fullProcessedPath))
- {
- if (!DeleteFileAlways(fullProcessedPath))
- {
- PrintError("Can not delete output file", fullProcessedPath);
- return E_ABORT;
- }
- }
-
- _outFileStreamSpec = new COutFileStream;
- CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
- if (!_outFileStreamSpec->Open(fullProcessedPath, CREATE_ALWAYS))
- {
- PrintError("Can not open output file", fullProcessedPath);
- return E_ABORT;
- }
- _outFileStream = outStreamLoc;
- *outStream = outStreamLoc.Detach();
- }
- return S_OK;
-}
-
-STDMETHODIMP CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode)
-{
- _extractMode = false;
- switch (askExtractMode)
- {
- case NArchive::NExtract::NAskMode::kExtract: _extractMode = true; break;
- };
- switch (askExtractMode)
- {
- case NArchive::NExtract::NAskMode::kExtract: Print(kExtractingString); break;
- case NArchive::NExtract::NAskMode::kTest: Print(kTestingString); break;
- case NArchive::NExtract::NAskMode::kSkip: Print(kSkippingString); break;
- };
- Print(_filePath);
- return S_OK;
-}
-
-STDMETHODIMP CArchiveExtractCallback::SetOperationResult(Int32 operationResult)
-{
- switch (operationResult)
- {
- case NArchive::NExtract::NOperationResult::kOK:
- break;
- default:
- {
- NumErrors++;
- Print(" : ");
- const char *s = NULL;
- switch (operationResult)
- {
- case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
- s = kUnsupportedMethod;
- break;
- case NArchive::NExtract::NOperationResult::kCRCError:
- s = kCRCFailed;
- break;
- case NArchive::NExtract::NOperationResult::kDataError:
- s = kDataError;
- break;
- case NArchive::NExtract::NOperationResult::kUnavailable:
- s = kUnavailableData;
- break;
- case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
- s = kUnexpectedEnd;
- break;
- case NArchive::NExtract::NOperationResult::kDataAfterEnd:
- s = kDataAfterEnd;
- break;
- case NArchive::NExtract::NOperationResult::kIsNotArc:
- s = kIsNotArc;
- break;
- case NArchive::NExtract::NOperationResult::kHeadersError:
- s = kHeadersError;
- break;
- }
- if (s)
- {
- Print("Error : ");
- Print(s);
- }
- else
- {
- char temp[16];
- ConvertUInt32ToString(operationResult, temp);
- Print("Error #");
- Print(temp);
- }
- }
- }
-
- if (_outFileStream)
- {
- if (_processedFileInfo.MTimeDefined)
- _outFileStreamSpec->SetMTime(&_processedFileInfo.MTime);
- RINOK(_outFileStreamSpec->Close());
- }
- _outFileStream.Release();
- if (_extractMode && _processedFileInfo.AttribDefined)
- SetFileAttrib_PosixHighDetect(_diskFilePath, _processedFileInfo.Attrib);
- PrintNewLine();
- return S_OK;
-}
-
-
-STDMETHODIMP CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password)
-{
- if (!PasswordIsDefined)
- {
- // You can ask real password here from user
- // Password = GetPassword(OutStream);
- // PasswordIsDefined = true;
- PrintError("Password is not defined");
- return E_ABORT;
- }
- return StringToBstr(Password, password);
-}
-
-
-
-//////////////////////////////////////////////////////////////
-// Archive Creating callback class
-
-struct CDirItem
-{
- UInt64 Size;
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
- UString Name;
- FString FullPath;
- UInt32 Attrib;
-
- bool isDir() const { return (Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 ; }
-};
-
-class CArchiveUpdateCallback:
- public IArchiveUpdateCallback2,
- public ICryptoGetTextPassword2,
- public CMyUnknownImp
-{
-public:
- MY_UNKNOWN_IMP2(IArchiveUpdateCallback2, ICryptoGetTextPassword2)
-
- // IProgress
- STDMETHOD(SetTotal)(UInt64 size);
- STDMETHOD(SetCompleted)(const UInt64 *completeValue);
-
- // IUpdateCallback2
- STDMETHOD(GetUpdateItemInfo)(UInt32 index,
- Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive);
- STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
- STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **inStream);
- STDMETHOD(SetOperationResult)(Int32 operationResult);
- STDMETHOD(GetVolumeSize)(UInt32 index, UInt64 *size);
- STDMETHOD(GetVolumeStream)(UInt32 index, ISequentialOutStream **volumeStream);
-
- STDMETHOD(CryptoGetTextPassword2)(Int32 *passwordIsDefined, BSTR *password);
-
-public:
- CRecordVector<UInt64> VolumesSizes;
- UString VolName;
- UString VolExt;
-
- FString DirPrefix;
- const CObjectVector<CDirItem> *DirItems;
-
- bool PasswordIsDefined;
- UString Password;
- bool AskPassword;
-
- bool m_NeedBeClosed;
-
- FStringVector FailedFiles;
- CRecordVector<HRESULT> FailedCodes;
-
- CArchiveUpdateCallback(): PasswordIsDefined(false), AskPassword(false), DirItems(0) {};
-
- ~CArchiveUpdateCallback() { Finilize(); }
- HRESULT Finilize();
-
- void Init(const CObjectVector<CDirItem> *dirItems)
- {
- DirItems = dirItems;
- m_NeedBeClosed = false;
- FailedFiles.Clear();
- FailedCodes.Clear();
- }
-};
-
-STDMETHODIMP CArchiveUpdateCallback::SetTotal(UInt64 /* size */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::SetCompleted(const UInt64 * /* completeValue */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 /* index */,
- Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive)
-{
- if (newData)
- *newData = BoolToInt(true);
- if (newProperties)
- *newProperties = BoolToInt(true);
- if (indexInArchive)
- *indexInArchive = (UInt32)(Int32)-1;
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- NCOM::CPropVariant prop;
-
- if (propID == kpidIsAnti)
- {
- prop = false;
- prop.Detach(value);
- return S_OK;
- }
-
- {
- const CDirItem &dirItem = (*DirItems)[index];
- switch (propID)
- {
- case kpidPath: prop = dirItem.Name; break;
- case kpidIsDir: prop = dirItem.isDir(); break;
- case kpidSize: prop = dirItem.Size; break;
- case kpidAttrib: prop = dirItem.Attrib; break;
- case kpidCTime: prop = dirItem.CTime; break;
- case kpidATime: prop = dirItem.ATime; break;
- case kpidMTime: prop = dirItem.MTime; break;
- }
- }
- prop.Detach(value);
- return S_OK;
-}
-
-HRESULT CArchiveUpdateCallback::Finilize()
-{
- if (m_NeedBeClosed)
- {
- PrintNewLine();
- m_NeedBeClosed = false;
- }
- return S_OK;
-}
-
-static void GetStream2(const wchar_t *name)
-{
- Print("Compressing ");
- if (name[0] == 0)
- name = kEmptyFileAlias;
- Print(name);
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream)
-{
- RINOK(Finilize());
-
- const CDirItem &dirItem = (*DirItems)[index];
- GetStream2(dirItem.Name);
-
- if (dirItem.isDir())
- return S_OK;
-
- {
- CInFileStream *inStreamSpec = new CInFileStream;
- CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
- FString path = DirPrefix + dirItem.FullPath;
- if (!inStreamSpec->Open(path))
- {
- DWORD sysError = ::GetLastError();
- FailedCodes.Add(sysError);
- FailedFiles.Add(path);
- // if (systemError == ERROR_SHARING_VIOLATION)
- {
- PrintNewLine();
- PrintError("WARNING: can't open file");
- // Print(NError::MyFormatMessageW(systemError));
- return S_FALSE;
- }
- // return sysError;
- }
- *inStream = inStreamLoc.Detach();
- }
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::SetOperationResult(Int32 /* operationResult */)
-{
- m_NeedBeClosed = true;
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size)
-{
- if (VolumesSizes.Size() == 0)
- return S_FALSE;
- if (index >= (UInt32)VolumesSizes.Size())
- index = VolumesSizes.Size() - 1;
- *size = VolumesSizes[index];
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream)
-{
- wchar_t temp[16];
- ConvertUInt32ToString(index + 1, temp);
- UString res = temp;
- while (res.Len() < 2)
- res.InsertAtFront(L'0');
- UString fileName = VolName;
- fileName += '.';
- fileName += res;
- fileName += VolExt;
- COutFileStream *streamSpec = new COutFileStream;
- CMyComPtr<ISequentialOutStream> streamLoc(streamSpec);
- if (!streamSpec->Create(us2fs(fileName), false))
- return ::GetLastError();
- *volumeStream = streamLoc.Detach();
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
-{
- if (!PasswordIsDefined)
- {
- if (AskPassword)
- {
- // You can ask real password here from user
- // Password = GetPassword(OutStream);
- // PasswordIsDefined = true;
- PrintError("Password is not defined");
- return E_ABORT;
- }
- }
- *passwordIsDefined = BoolToInt(PasswordIsDefined);
- return StringToBstr(Password, password);
-}
-
-
-// Main function
-
-#define NT_CHECK_FAIL_ACTION PrintError("Unsupported Windows version"); return 1;
-
-int MY_CDECL main(int numArgs, const char *args[])
-{
- NT_CHECK
-
- PrintStringLn(kCopyrightString);
-
- if (numArgs < 2)
- {
- PrintStringLn(kHelpString);
- return 0;
- }
-
- if (numArgs < 3)
- {
- PrintError(kIncorrectCommand);
- return 1;
- }
-
-
- NDLL::CLibrary lib;
- if (!lib.Load(NDLL::GetModuleDirPrefix() + FTEXT(kDllName)))
- {
- PrintError("Can not load 7-zip library");
- return 1;
- }
-
- Func_CreateObject createObjectFunc = (Func_CreateObject)lib.GetProc("CreateObject");
- if (!createObjectFunc)
- {
- PrintError("Can not get CreateObject");
- return 1;
- }
-
- char c;
- {
- AString command (args[1]);
- if (command.Len() != 1)
- {
- PrintError(kIncorrectCommand);
- return 1;
- }
- c = (char)MyCharLower_Ascii(command[0]);
- }
-
- FString archiveName = CmdStringToFString(args[2]);
-
- if (c == 'a')
- {
- // create archive command
- if (numArgs < 4)
- {
- PrintError(kIncorrectCommand);
- return 1;
- }
- CObjectVector<CDirItem> dirItems;
- {
- int i;
- for (i = 3; i < numArgs; i++)
- {
- CDirItem di;
- FString name = CmdStringToFString(args[i]);
-
- NFind::CFileInfo fi;
- if (!fi.Find(name))
- {
- PrintError("Can't find file", name);
- return 1;
- }
-
- di.Attrib = fi.Attrib;
- di.Size = fi.Size;
- di.CTime = fi.CTime;
- di.ATime = fi.ATime;
- di.MTime = fi.MTime;
- di.Name = fs2us(name);
- di.FullPath = name;
- dirItems.Add(di);
- }
- }
-
- COutFileStream *outFileStreamSpec = new COutFileStream;
- CMyComPtr<IOutStream> outFileStream = outFileStreamSpec;
- if (!outFileStreamSpec->Create(archiveName, false))
- {
- PrintError("can't create archive file");
- return 1;
- }
-
- CMyComPtr<IOutArchive> outArchive;
- if (createObjectFunc(&CLSID_Format, &IID_IOutArchive, (void **)&outArchive) != S_OK)
- {
- PrintError("Can not get class object");
- return 1;
- }
-
- CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
- CMyComPtr<IArchiveUpdateCallback2> updateCallback(updateCallbackSpec);
- updateCallbackSpec->Init(&dirItems);
- // updateCallbackSpec->PasswordIsDefined = true;
- // updateCallbackSpec->Password = L"1";
-
- /*
- {
- const wchar_t *names[] =
- {
- L"s",
- L"x"
- };
- const unsigned kNumProps = ARRAY_SIZE(names);
- NCOM::CPropVariant values[kNumProps] =
- {
- false, // solid mode OFF
- (UInt32)9 // compression level = 9 - ultra
- };
- CMyComPtr<ISetProperties> setProperties;
- outArchive->QueryInterface(IID_ISetProperties, (void **)&setProperties);
- if (!setProperties)
- {
- PrintError("ISetProperties unsupported");
- return 1;
- }
- RINOK(setProperties->SetProperties(names, values, kNumProps));
- }
- */
-
- HRESULT result = outArchive->UpdateItems(outFileStream, dirItems.Size(), updateCallback);
-
- updateCallbackSpec->Finilize();
-
- if (result != S_OK)
- {
- PrintError("Update Error");
- return 1;
- }
-
- FOR_VECTOR (i, updateCallbackSpec->FailedFiles)
- {
- PrintNewLine();
- PrintError("Error for file", updateCallbackSpec->FailedFiles[i]);
- }
-
- if (updateCallbackSpec->FailedFiles.Size() != 0)
- return 1;
- }
- else
- {
- if (numArgs != 3)
- {
- PrintError(kIncorrectCommand);
- return 1;
- }
-
- bool listCommand;
-
- if (c == 'l')
- listCommand = true;
- else if (c == 'x')
- listCommand = false;
- else
- {
- PrintError(kIncorrectCommand);
- return 1;
- }
-
- CMyComPtr<IInArchive> archive;
- if (createObjectFunc(&CLSID_Format, &IID_IInArchive, (void **)&archive) != S_OK)
- {
- PrintError("Can not get class object");
- return 1;
- }
-
- CInFileStream *fileSpec = new CInFileStream;
- CMyComPtr<IInStream> file = fileSpec;
-
- if (!fileSpec->Open(archiveName))
- {
- PrintError("Can not open archive file", archiveName);
- return 1;
- }
-
- {
- CArchiveOpenCallback *openCallbackSpec = new CArchiveOpenCallback;
- CMyComPtr<IArchiveOpenCallback> openCallback(openCallbackSpec);
- openCallbackSpec->PasswordIsDefined = false;
- // openCallbackSpec->PasswordIsDefined = true;
- // openCallbackSpec->Password = L"1";
-
- const UInt64 scanSize = 1 << 23;
- if (archive->Open(file, &scanSize, openCallback) != S_OK)
- {
- PrintError("Can not open file as archive", archiveName);
- return 1;
- }
- }
-
- if (listCommand)
- {
- // List command
- UInt32 numItems = 0;
- archive->GetNumberOfItems(&numItems);
- for (UInt32 i = 0; i < numItems; i++)
- {
- {
- // Get uncompressed size of file
- NCOM::CPropVariant prop;
- archive->GetProperty(i, kpidSize, &prop);
- char s[32];
- ConvertPropVariantToShortString(prop, s);
- Print(s);
- Print(" ");
- }
- {
- // Get name of file
- NCOM::CPropVariant prop;
- archive->GetProperty(i, kpidPath, &prop);
- if (prop.vt == VT_BSTR)
- Print(prop.bstrVal);
- else if (prop.vt != VT_EMPTY)
- Print("ERROR!");
- }
- PrintNewLine();
- }
- }
- else
- {
- // Extract command
- CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
- CMyComPtr<IArchiveExtractCallback> extractCallback(extractCallbackSpec);
- extractCallbackSpec->Init(archive, FString()); // second parameter is output folder path
- extractCallbackSpec->PasswordIsDefined = false;
- // extractCallbackSpec->PasswordIsDefined = true;
- // extractCallbackSpec->Password = "1";
-
- /*
- const wchar_t *names[] =
- {
- L"mt",
- L"mtf"
- };
- const unsigned kNumProps = sizeof(names) / sizeof(names[0]);
- NCOM::CPropVariant values[kNumProps] =
- {
- (UInt32)1,
- false
- };
- CMyComPtr<ISetProperties> setProperties;
- archive->QueryInterface(IID_ISetProperties, (void **)&setProperties);
- if (setProperties)
- setProperties->SetProperties(names, values, kNumProps);
- */
-
- HRESULT result = archive->Extract(NULL, (UInt32)(Int32)(-1), false, extractCallback);
-
- if (result != S_OK)
- {
- PrintError("Extract Error");
- return 1;
- }
- }
- }
-
- return 0;
-}
+// Client7z.cpp
+
+#include "StdAfx.h"
+
+#include <stdio.h>
+
+#include "../../../Common/MyWindows.h"
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "../../IPassword.h"
+#include "../../../../C/7zVersion.h"
+
+#ifdef _WIN32
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance = NULL;
+#endif
+
+// You can find full list of all GUIDs supported by 7-Zip in Guid.txt file.
+// 7z format GUID: {23170F69-40C1-278A-1000-000110070000}
+
+#define DEFINE_GUID_ARC(name, id) Z7_DEFINE_GUID(name, \
+ 0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, id, 0x00, 0x00);
+
+enum
+{
+ kId_Zip = 1,
+ kId_BZip2 = 2,
+ kId_7z = 7,
+ kId_Xz = 0xC,
+ kId_Tar = 0xEE,
+ kId_GZip = 0xEF
+};
+
+// use another id, if you want to support other formats (zip, Xz, ...).
+// DEFINE_GUID_ARC (CLSID_Format, kId_Zip)
+// DEFINE_GUID_ARC (CLSID_Format, kId_BZip2)
+// DEFINE_GUID_ARC (CLSID_Format, kId_Xz)
+// DEFINE_GUID_ARC (CLSID_Format, kId_Tar)
+// DEFINE_GUID_ARC (CLSID_Format, kId_GZip)
+DEFINE_GUID_ARC (CLSID_Format, kId_7z)
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+#ifdef _WIN32
+#define kDllName "7z.dll"
+#else
+#define kDllName "7z.so"
+#endif
+
+static const char * const kCopyrightString =
+ "\n"
+ "7-Zip"
+ " (" kDllName " client)"
+ " " MY_VERSION
+ " : " MY_COPYRIGHT_DATE
+ "\n";
+
+static const char * const kHelpString =
+"Usage: 7zcl.exe [a | l | x] archive.7z [fileName ...]\n"
+"Examples:\n"
+" 7zcl.exe a archive.7z f1.txt f2.txt : compress two files to archive.7z\n"
+" 7zcl.exe l archive.7z : List contents of archive.7z\n"
+" 7zcl.exe x archive.7z : eXtract files from archive.7z\n";
+
+
+static void Convert_UString_to_AString(const UString &s, AString &temp)
+{
+ int codePage = CP_OEMCP;
+ /*
+ int g_CodePage = -1;
+ int codePage = g_CodePage;
+ if (codePage == -1)
+ codePage = CP_OEMCP;
+ if (codePage == CP_UTF8)
+ ConvertUnicodeToUTF8(s, temp);
+ else
+ */
+ UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
+}
+
+static FString CmdStringToFString(const char *s)
+{
+ return us2fs(GetUnicodeString(s));
+}
+
+static void Print(const char *s)
+{
+ fputs(s, stdout);
+}
+
+static void Print(const AString &s)
+{
+ Print(s.Ptr());
+}
+
+static void Print(const UString &s)
+{
+ AString as;
+ Convert_UString_to_AString(s, as);
+ Print(as);
+}
+
+static void Print(const wchar_t *s)
+{
+ Print(UString(s));
+}
+
+static void PrintNewLine()
+{
+ Print("\n");
+}
+
+static void PrintStringLn(const char *s)
+{
+ Print(s);
+ PrintNewLine();
+}
+
+static void PrintError(const char *message)
+{
+ Print("Error: ");
+ PrintNewLine();
+ Print(message);
+ PrintNewLine();
+}
+
+static void PrintError(const char *message, const FString &name)
+{
+ PrintError(message);
+ Print(name);
+}
+
+
+static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)
+{
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_BOOL)
+ result = VARIANT_BOOLToBool(prop.boolVal);
+ else if (prop.vt == VT_EMPTY)
+ result = false;
+ else
+ return E_FAIL;
+ return S_OK;
+}
+
+static HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result)
+{
+ return IsArchiveItemProp(archive, index, kpidIsDir, result);
+}
+
+
+static const wchar_t * const kEmptyFileAlias = L"[Content]";
+
+
+//////////////////////////////////////////////////////////////
+// Archive Open callback class
+
+
+class CArchiveOpenCallback Z7_final:
+ public IArchiveOpenCallback,
+ public ICryptoGetTextPassword,
+ public CMyUnknownImp
+{
+ Z7_IFACES_IMP_UNK_2(IArchiveOpenCallback, ICryptoGetTextPassword)
+public:
+
+ bool PasswordIsDefined;
+ UString Password;
+
+ CArchiveOpenCallback() : PasswordIsDefined(false) {}
+};
+
+Z7_COM7F_IMF(CArchiveOpenCallback::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveOpenCallback::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveOpenCallback::CryptoGetTextPassword(BSTR *password))
+{
+ if (!PasswordIsDefined)
+ {
+ // You can ask real password here from user
+ // Password = GetPassword(OutStream);
+ // PasswordIsDefined = true;
+ PrintError("Password is not defined");
+ return E_ABORT;
+ }
+ return StringToBstr(Password, password);
+}
+
+
+
+static const char * const kIncorrectCommand = "incorrect command";
+
+//////////////////////////////////////////////////////////////
+// Archive Extracting callback class
+
+static const char * const kTestingString = "Testing ";
+static const char * const kExtractingString = "Extracting ";
+static const char * const kSkippingString = "Skipping ";
+static const char * const kReadingString = "Reading ";
+
+static const char * const kUnsupportedMethod = "Unsupported Method";
+static const char * const kCRCFailed = "CRC Failed";
+static const char * const kDataError = "Data Error";
+static const char * const kUnavailableData = "Unavailable data";
+static const char * const kUnexpectedEnd = "Unexpected end of data";
+static const char * const kDataAfterEnd = "There are some data after the end of the payload data";
+static const char * const kIsNotArc = "Is not archive";
+static const char * const kHeadersError = "Headers Error";
+
+
+struct CArcTime
+{
+ FILETIME FT;
+ UInt16 Prec;
+ Byte Ns100;
+ bool Def;
+
+ CArcTime()
+ {
+ Clear();
+ }
+
+ void Clear()
+ {
+ FT.dwHighDateTime = FT.dwLowDateTime = 0;
+ Prec = 0;
+ Ns100 = 0;
+ Def = false;
+ }
+
+ bool IsZero() const
+ {
+ return FT.dwLowDateTime == 0 && FT.dwHighDateTime == 0 && Ns100 == 0;
+ }
+
+ int GetNumDigits() const
+ {
+ if (Prec == k_PropVar_TimePrec_Unix ||
+ Prec == k_PropVar_TimePrec_DOS)
+ return 0;
+ if (Prec == k_PropVar_TimePrec_HighPrec)
+ return 9;
+ if (Prec == k_PropVar_TimePrec_0)
+ return 7;
+ int digits = (int)Prec - (int)k_PropVar_TimePrec_Base;
+ if (digits < 0)
+ digits = 0;
+ return digits;
+ }
+
+ void Write_To_FiTime(CFiTime &dest) const
+ {
+ #ifdef _WIN32
+ dest = FT;
+ #else
+ if (FILETIME_To_timespec(FT, dest))
+ if ((Prec == k_PropVar_TimePrec_Base + 8 ||
+ Prec == k_PropVar_TimePrec_Base + 9)
+ && Ns100 != 0)
+ {
+ dest.tv_nsec += Ns100;
+ }
+ #endif
+ }
+
+ void Set_From_Prop(const PROPVARIANT &prop)
+ {
+ FT = prop.filetime;
+ unsigned prec = 0;
+ unsigned ns100 = 0;
+ const unsigned prec_Temp = prop.wReserved1;
+ if (prec_Temp != 0
+ && prec_Temp <= k_PropVar_TimePrec_1ns
+ && prop.wReserved3 == 0)
+ {
+ const unsigned ns100_Temp = prop.wReserved2;
+ if (ns100_Temp < 100)
+ {
+ ns100 = ns100_Temp;
+ prec = prec_Temp;
+ }
+ }
+ Prec = (UInt16)prec;
+ Ns100 = (Byte)ns100;
+ Def = true;
+ }
+};
+
+
+
+class CArchiveExtractCallback Z7_final:
+ public IArchiveExtractCallback,
+ public ICryptoGetTextPassword,
+ public CMyUnknownImp
+{
+ Z7_IFACES_IMP_UNK_2(IArchiveExtractCallback, ICryptoGetTextPassword)
+ Z7_IFACE_COM7_IMP(IProgress)
+
+ CMyComPtr<IInArchive> _archiveHandler;
+ FString _directoryPath; // Output directory
+ UString _filePath; // name inside arcvhive
+ FString _diskFilePath; // full path to file on disk
+ bool _extractMode;
+ struct CProcessedFileInfo
+ {
+ CArcTime MTime;
+ UInt32 Attrib;
+ bool isDir;
+ bool Attrib_Defined;
+ } _processedFileInfo;
+
+ COutFileStream *_outFileStreamSpec;
+ CMyComPtr<ISequentialOutStream> _outFileStream;
+
+public:
+ void Init(IInArchive *archiveHandler, const FString &directoryPath);
+
+ UInt64 NumErrors;
+ bool PasswordIsDefined;
+ UString Password;
+
+ CArchiveExtractCallback() : PasswordIsDefined(false) {}
+};
+
+void CArchiveExtractCallback::Init(IInArchive *archiveHandler, const FString &directoryPath)
+{
+ NumErrors = 0;
+ _archiveHandler = archiveHandler;
+ _directoryPath = directoryPath;
+ NName::NormalizeDirPathPrefix(_directoryPath);
+}
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetTotal(UInt64 /* size */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetCompleted(const UInt64 * /* completeValue */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index,
+ ISequentialOutStream **outStream, Int32 askExtractMode))
+{
+ *outStream = NULL;
+ _outFileStream.Release();
+
+ {
+ // Get Name
+ NCOM::CPropVariant prop;
+ RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop))
+
+ UString fullPath;
+ if (prop.vt == VT_EMPTY)
+ fullPath = kEmptyFileAlias;
+ else
+ {
+ if (prop.vt != VT_BSTR)
+ return E_FAIL;
+ fullPath = prop.bstrVal;
+ }
+ _filePath = fullPath;
+ }
+
+ if (askExtractMode != NArchive::NExtract::NAskMode::kExtract)
+ return S_OK;
+
+ {
+ // Get Attrib
+ NCOM::CPropVariant prop;
+ RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop))
+ if (prop.vt == VT_EMPTY)
+ {
+ _processedFileInfo.Attrib = 0;
+ _processedFileInfo.Attrib_Defined = false;
+ }
+ else
+ {
+ if (prop.vt != VT_UI4)
+ return E_FAIL;
+ _processedFileInfo.Attrib = prop.ulVal;
+ _processedFileInfo.Attrib_Defined = true;
+ }
+ }
+
+ RINOK(IsArchiveItemFolder(_archiveHandler, index, _processedFileInfo.isDir))
+
+ {
+ _processedFileInfo.MTime.Clear();
+ // Get Modified Time
+ NCOM::CPropVariant prop;
+ RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop))
+ switch (prop.vt)
+ {
+ case VT_EMPTY:
+ // _processedFileInfo.MTime = _utcMTimeDefault;
+ break;
+ case VT_FILETIME:
+ _processedFileInfo.MTime.Set_From_Prop(prop);
+ break;
+ default:
+ return E_FAIL;
+ }
+
+ }
+ {
+ // Get Size
+ NCOM::CPropVariant prop;
+ RINOK(_archiveHandler->GetProperty(index, kpidSize, &prop))
+ UInt64 newFileSize;
+ /* bool newFileSizeDefined = */ ConvertPropVariantToUInt64(prop, newFileSize);
+ }
+
+
+ {
+ // Create folders for file
+ int slashPos = _filePath.ReverseFind_PathSepar();
+ if (slashPos >= 0)
+ CreateComplexDir(_directoryPath + us2fs(_filePath.Left(slashPos)));
+ }
+
+ FString fullProcessedPath = _directoryPath + us2fs(_filePath);
+ _diskFilePath = fullProcessedPath;
+
+ if (_processedFileInfo.isDir)
+ {
+ CreateComplexDir(fullProcessedPath);
+ }
+ else
+ {
+ NFind::CFileInfo fi;
+ if (fi.Find(fullProcessedPath))
+ {
+ if (!DeleteFileAlways(fullProcessedPath))
+ {
+ PrintError("Cannot delete output file", fullProcessedPath);
+ return E_ABORT;
+ }
+ }
+
+ _outFileStreamSpec = new COutFileStream;
+ CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
+ if (!_outFileStreamSpec->Open(fullProcessedPath, CREATE_ALWAYS))
+ {
+ PrintError("Cannot open output file", fullProcessedPath);
+ return E_ABORT;
+ }
+ _outFileStream = outStreamLoc;
+ *outStream = outStreamLoc.Detach();
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode))
+{
+ _extractMode = false;
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract: _extractMode = true; break;
+ }
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract: Print(kExtractingString); break;
+ case NArchive::NExtract::NAskMode::kTest: Print(kTestingString); break;
+ case NArchive::NExtract::NAskMode::kSkip: Print(kSkippingString); break;
+ case NArchive::NExtract::NAskMode::kReadExternal: Print(kReadingString); break;
+ default:
+ Print("??? "); break;
+ }
+ Print(_filePath);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 operationResult))
+{
+ switch (operationResult)
+ {
+ case NArchive::NExtract::NOperationResult::kOK:
+ break;
+ default:
+ {
+ NumErrors++;
+ Print(" : ");
+ const char *s = NULL;
+ switch (operationResult)
+ {
+ case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
+ s = kUnsupportedMethod;
+ break;
+ case NArchive::NExtract::NOperationResult::kCRCError:
+ s = kCRCFailed;
+ break;
+ case NArchive::NExtract::NOperationResult::kDataError:
+ s = kDataError;
+ break;
+ case NArchive::NExtract::NOperationResult::kUnavailable:
+ s = kUnavailableData;
+ break;
+ case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
+ s = kUnexpectedEnd;
+ break;
+ case NArchive::NExtract::NOperationResult::kDataAfterEnd:
+ s = kDataAfterEnd;
+ break;
+ case NArchive::NExtract::NOperationResult::kIsNotArc:
+ s = kIsNotArc;
+ break;
+ case NArchive::NExtract::NOperationResult::kHeadersError:
+ s = kHeadersError;
+ break;
+ }
+ if (s)
+ {
+ Print("Error : ");
+ Print(s);
+ }
+ else
+ {
+ char temp[16];
+ ConvertUInt32ToString((UInt32)operationResult, temp);
+ Print("Error #");
+ Print(temp);
+ }
+ }
+ }
+
+ if (_outFileStream)
+ {
+ if (_processedFileInfo.MTime.Def)
+ {
+ CFiTime ft;
+ _processedFileInfo.MTime.Write_To_FiTime(ft);
+ _outFileStreamSpec->SetMTime(&ft);
+ }
+ RINOK(_outFileStreamSpec->Close())
+ }
+ _outFileStream.Release();
+ if (_extractMode && _processedFileInfo.Attrib_Defined)
+ SetFileAttrib_PosixHighDetect(_diskFilePath, _processedFileInfo.Attrib);
+ PrintNewLine();
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password))
+{
+ if (!PasswordIsDefined)
+ {
+ // You can ask real password here from user
+ // Password = GetPassword(OutStream);
+ // PasswordIsDefined = true;
+ PrintError("Password is not defined");
+ return E_ABORT;
+ }
+ return StringToBstr(Password, password);
+}
+
+
+
+//////////////////////////////////////////////////////////////
+// Archive Creating callback class
+
+struct CDirItem: public NWindows::NFile::NFind::CFileInfoBase
+{
+ UString Path_For_Handler;
+ FString FullPath; // for filesystem
+
+ CDirItem(const NWindows::NFile::NFind::CFileInfo &fi):
+ CFileInfoBase(fi)
+ {}
+};
+
+class CArchiveUpdateCallback Z7_final:
+ public IArchiveUpdateCallback2,
+ public ICryptoGetTextPassword2,
+ public CMyUnknownImp
+{
+ Z7_IFACES_IMP_UNK_2(IArchiveUpdateCallback2, ICryptoGetTextPassword2)
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IArchiveUpdateCallback)
+
+public:
+ CRecordVector<UInt64> VolumesSizes;
+ UString VolName;
+ UString VolExt;
+
+ FString DirPrefix;
+ const CObjectVector<CDirItem> *DirItems;
+
+ bool PasswordIsDefined;
+ UString Password;
+ bool AskPassword;
+
+ bool m_NeedBeClosed;
+
+ FStringVector FailedFiles;
+ CRecordVector<HRESULT> FailedCodes;
+
+ CArchiveUpdateCallback():
+ DirItems(NULL),
+ PasswordIsDefined(false),
+ AskPassword(false)
+ {}
+
+ ~CArchiveUpdateCallback() { Finilize(); }
+ HRESULT Finilize();
+
+ void Init(const CObjectVector<CDirItem> *dirItems)
+ {
+ DirItems = dirItems;
+ m_NeedBeClosed = false;
+ FailedFiles.Clear();
+ FailedCodes.Clear();
+ }
+};
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetTotal(UInt64 /* size */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetCompleted(const UInt64 * /* completeValue */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 /* index */,
+ Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive))
+{
+ if (newData)
+ *newData = BoolToInt(true);
+ if (newProperties)
+ *newProperties = BoolToInt(true);
+ if (indexInArchive)
+ *indexInArchive = (UInt32)(Int32)-1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+
+ if (propID == kpidIsAnti)
+ {
+ prop = false;
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ {
+ const CDirItem &di = (*DirItems)[index];
+ switch (propID)
+ {
+ case kpidPath: prop = di.Path_For_Handler; break;
+ case kpidIsDir: prop = di.IsDir(); break;
+ case kpidSize: prop = di.Size; break;
+ case kpidCTime: PropVariant_SetFrom_FiTime(prop, di.CTime); break;
+ case kpidATime: PropVariant_SetFrom_FiTime(prop, di.ATime); break;
+ case kpidMTime: PropVariant_SetFrom_FiTime(prop, di.MTime); break;
+ case kpidAttrib: prop = (UInt32)di.GetWinAttrib(); break;
+ case kpidPosixAttrib: prop = (UInt32)di.GetPosixAttrib(); break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+HRESULT CArchiveUpdateCallback::Finilize()
+{
+ if (m_NeedBeClosed)
+ {
+ PrintNewLine();
+ m_NeedBeClosed = false;
+ }
+ return S_OK;
+}
+
+static void GetStream2(const wchar_t *name)
+{
+ Print("Compressing ");
+ if (name[0] == 0)
+ name = kEmptyFileAlias;
+ Print(name);
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream))
+{
+ RINOK(Finilize())
+
+ const CDirItem &dirItem = (*DirItems)[index];
+ GetStream2(dirItem.Path_For_Handler);
+
+ if (dirItem.IsDir())
+ return S_OK;
+
+ {
+ CInFileStream *inStreamSpec = new CInFileStream;
+ CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
+ FString path = DirPrefix + dirItem.FullPath;
+ if (!inStreamSpec->Open(path))
+ {
+ const DWORD sysError = ::GetLastError();
+ FailedCodes.Add(HRESULT_FROM_WIN32(sysError));
+ FailedFiles.Add(path);
+ // if (systemError == ERROR_SHARING_VIOLATION)
+ {
+ PrintNewLine();
+ PrintError("WARNING: can't open file");
+ // Print(NError::MyFormatMessageW(systemError));
+ return S_FALSE;
+ }
+ // return sysError;
+ }
+ *inStream = inStreamLoc.Detach();
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetOperationResult(Int32 /* operationResult */))
+{
+ m_NeedBeClosed = true;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size))
+{
+ if (VolumesSizes.Size() == 0)
+ return S_FALSE;
+ if (index >= (UInt32)VolumesSizes.Size())
+ index = VolumesSizes.Size() - 1;
+ *size = VolumesSizes[index];
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream))
+{
+ wchar_t temp[16];
+ ConvertUInt32ToString(index + 1, temp);
+ UString res = temp;
+ while (res.Len() < 2)
+ res.InsertAtFront(L'0');
+ UString fileName = VolName;
+ fileName.Add_Dot();
+ fileName += res;
+ fileName += VolExt;
+ COutFileStream *streamSpec = new COutFileStream;
+ CMyComPtr<ISequentialOutStream> streamLoc(streamSpec);
+ if (!streamSpec->Create(us2fs(fileName), false))
+ return GetLastError_noZero_HRESULT();
+ *volumeStream = streamLoc.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+{
+ if (!PasswordIsDefined)
+ {
+ if (AskPassword)
+ {
+ // You can ask real password here from user
+ // Password = GetPassword(OutStream);
+ // PasswordIsDefined = true;
+ PrintError("Password is not defined");
+ return E_ABORT;
+ }
+ }
+ *passwordIsDefined = BoolToInt(PasswordIsDefined);
+ return StringToBstr(Password, password);
+}
+
+
+// Main function
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION PrintError("Unsupported Windows version"); return 1;
+#endif
+
+int Z7_CDECL main(int numArgs, const char *args[])
+{
+ NT_CHECK
+
+ #ifdef ENV_HAVE_LOCALE
+ MY_SetLocale();
+ #endif
+
+ PrintStringLn(kCopyrightString);
+
+ if (numArgs < 2)
+ {
+ PrintStringLn(kHelpString);
+ return 0;
+ }
+
+ FString dllPrefix;
+
+ #ifdef _WIN32
+ dllPrefix = NDLL::GetModuleDirPrefix();
+ #else
+ {
+ AString s (args[0]);
+ int sep = s.ReverseFind_PathSepar();
+ s.DeleteFrom(sep + 1);
+ dllPrefix = s;
+ }
+ #endif
+
+ NDLL::CLibrary lib;
+ if (!lib.Load(dllPrefix + FTEXT(kDllName)))
+ {
+ PrintError("Cannot load 7-zip library");
+ return 1;
+ }
+
+ Func_CreateObject
+ f_CreateObject = Z7_GET_PROC_ADDRESS(
+ Func_CreateObject, lib.Get_HMODULE(),
+ "CreateObject");
+ if (!f_CreateObject)
+ {
+ PrintError("Cannot get CreateObject");
+ return 1;
+ }
+
+ char c = 0;
+ UString password;
+ bool passwordIsDefined = false;
+ CObjectVector<FString> params;
+
+ for (int curCmd = 1; curCmd < numArgs; curCmd++)
+ {
+ AString a(args[curCmd]);
+
+ if (!a.IsEmpty())
+ {
+ if (a[0] == '-')
+ {
+ if (!passwordIsDefined && a[1] == 'p')
+ {
+ password = GetUnicodeString(a.Ptr(2));
+ passwordIsDefined = true;
+ continue;
+ }
+ }
+ else
+ {
+ if (c)
+ {
+ params.Add(CmdStringToFString(a));
+ continue;
+ }
+ if (a.Len() == 1)
+ {
+ c = (char)MyCharLower_Ascii(a[0]);
+ continue;
+ }
+ }
+ }
+ {
+ PrintError(kIncorrectCommand);
+ return 1;
+ }
+ }
+
+ if (!c || params.Size() < 1)
+ {
+ PrintError(kIncorrectCommand);
+ return 1;
+ }
+
+ const FString &archiveName = params[0];
+
+ if (c == 'a')
+ {
+ // create archive command
+ if (params.Size() < 2)
+ {
+ PrintError(kIncorrectCommand);
+ return 1;
+ }
+ CObjectVector<CDirItem> dirItems;
+ {
+ unsigned i;
+ for (i = 1; i < params.Size(); i++)
+ {
+ const FString &name = params[i];
+
+ NFind::CFileInfo fi;
+ if (!fi.Find(name))
+ {
+ PrintError("Can't find file", name);
+ return 1;
+ }
+
+ CDirItem di(fi);
+
+ di.Path_For_Handler = fs2us(name);
+ di.FullPath = name;
+ dirItems.Add(di);
+ }
+ }
+
+ COutFileStream *outFileStreamSpec = new COutFileStream;
+ CMyComPtr<IOutStream> outFileStream = outFileStreamSpec;
+ if (!outFileStreamSpec->Create(archiveName, false))
+ {
+ PrintError("can't create archive file");
+ return 1;
+ }
+
+ CMyComPtr<IOutArchive> outArchive;
+ if (f_CreateObject(&CLSID_Format, &IID_IOutArchive, (void **)&outArchive) != S_OK)
+ {
+ PrintError("Cannot get class object");
+ return 1;
+ }
+
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback2> updateCallback(updateCallbackSpec);
+ updateCallbackSpec->Init(&dirItems);
+ updateCallbackSpec->PasswordIsDefined = passwordIsDefined;
+ updateCallbackSpec->Password = password;
+
+ /*
+ {
+ const wchar_t *names[] =
+ {
+ L"m",
+ L"s",
+ L"x"
+ };
+ const unsigned kNumProps = Z7_ARRAY_SIZE(names);
+ NCOM::CPropVariant values[kNumProps] =
+ {
+ L"lzma",
+ false, // solid mode OFF
+ (UInt32)9 // compression level = 9 - ultra
+ };
+ CMyComPtr<ISetProperties> setProperties;
+ outArchive->QueryInterface(IID_ISetProperties, (void **)&setProperties);
+ if (!setProperties)
+ {
+ PrintError("ISetProperties unsupported");
+ return 1;
+ }
+ if (setProperties->SetProperties(names, values, kNumProps) != S_OK)
+ {
+ PrintError("SetProperties() error");
+ return 1;
+ }
+ }
+ */
+
+ HRESULT result = outArchive->UpdateItems(outFileStream, dirItems.Size(), updateCallback);
+
+ updateCallbackSpec->Finilize();
+
+ if (result != S_OK)
+ {
+ PrintError("Update Error");
+ return 1;
+ }
+
+ FOR_VECTOR (i, updateCallbackSpec->FailedFiles)
+ {
+ PrintNewLine();
+ PrintError("Error for file", updateCallbackSpec->FailedFiles[i]);
+ }
+
+ if (updateCallbackSpec->FailedFiles.Size() != 0)
+ return 1;
+ }
+ else
+ {
+ if (params.Size() != 1)
+ {
+ PrintError(kIncorrectCommand);
+ return 1;
+ }
+
+ bool listCommand;
+
+ if (c == 'l')
+ listCommand = true;
+ else if (c == 'x')
+ listCommand = false;
+ else
+ {
+ PrintError(kIncorrectCommand);
+ return 1;
+ }
+
+ CMyComPtr<IInArchive> archive;
+ if (f_CreateObject(&CLSID_Format, &IID_IInArchive, (void **)&archive) != S_OK)
+ {
+ PrintError("Cannot get class object");
+ return 1;
+ }
+
+ CInFileStream *fileSpec = new CInFileStream;
+ CMyComPtr<IInStream> file = fileSpec;
+
+ if (!fileSpec->Open(archiveName))
+ {
+ PrintError("Cannot open archive file", archiveName);
+ return 1;
+ }
+
+ {
+ CArchiveOpenCallback *openCallbackSpec = new CArchiveOpenCallback;
+ CMyComPtr<IArchiveOpenCallback> openCallback(openCallbackSpec);
+ openCallbackSpec->PasswordIsDefined = passwordIsDefined;
+ openCallbackSpec->Password = password;
+
+ const UInt64 scanSize = 1 << 23;
+ if (archive->Open(file, &scanSize, openCallback) != S_OK)
+ {
+ PrintError("Cannot open file as archive", archiveName);
+ return 1;
+ }
+ }
+
+ if (listCommand)
+ {
+ // List command
+ UInt32 numItems = 0;
+ archive->GetNumberOfItems(&numItems);
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ {
+ // Get uncompressed size of file
+ NCOM::CPropVariant prop;
+ archive->GetProperty(i, kpidSize, &prop);
+ char s[32];
+ ConvertPropVariantToShortString(prop, s);
+ Print(s);
+ Print(" ");
+ }
+ {
+ // Get name of file
+ NCOM::CPropVariant prop;
+ archive->GetProperty(i, kpidPath, &prop);
+ if (prop.vt == VT_BSTR)
+ Print(prop.bstrVal);
+ else if (prop.vt != VT_EMPTY)
+ Print("ERROR!");
+ }
+ PrintNewLine();
+ }
+ }
+ else
+ {
+ // Extract command
+ CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
+ CMyComPtr<IArchiveExtractCallback> extractCallback(extractCallbackSpec);
+ extractCallbackSpec->Init(archive, FString()); // second parameter is output folder path
+ extractCallbackSpec->PasswordIsDefined = passwordIsDefined;
+ extractCallbackSpec->Password = password;
+
+ /*
+ const wchar_t *names[] =
+ {
+ L"mt",
+ L"mtf"
+ };
+ const unsigned kNumProps = sizeof(names) / sizeof(names[0]);
+ NCOM::CPropVariant values[kNumProps] =
+ {
+ (UInt32)1,
+ false
+ };
+ CMyComPtr<ISetProperties> setProperties;
+ archive->QueryInterface(IID_ISetProperties, (void **)&setProperties);
+ if (setProperties)
+ {
+ if (setProperties->SetProperties(names, values, kNumProps) != S_OK)
+ {
+ PrintError("SetProperties() error");
+ return 1;
+ }
+ }
+ */
+
+ HRESULT result = archive->Extract(NULL, (UInt32)(Int32)(-1), false, extractCallback);
+
+ if (result != S_OK)
+ {
+ PrintError("Extract Error");
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
diff --git a/CPP/7zip/UI/Client7z/Client7z.dsp b/CPP/7zip/UI/Client7z/Client7z.dsp
index d9ec4ca..d46300f 100644
--- a/CPP/7zip/UI/Client7z/Client7z.dsp
+++ b/CPP/7zip/UI/Client7z/Client7z.dsp
@@ -1,235 +1,327 @@
-# Microsoft Developer Studio Project File - Name="Client7z" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=Client7z - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "Client7z.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "Client7z.mak" CFG="Client7z - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "Client7z - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "Client7z - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "Client7z - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
-# ADD CPP /nologo /MD /W4 /WX /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
-# ADD BASE RSC /l 0x419 /d "NDEBUG"
-# ADD RSC /l 0x419 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"Release/7zcl.exe"
-
-!ELSEIF "$(CFG)" == "Client7z - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
-# ADD CPP /nologo /MDd /W4 /WX /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
-# ADD BASE RSC /l 0x419 /d "_DEBUG"
-# ADD RSC /l 0x419 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"Debug/7zcl.exe" /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "Client7z - Win32 Release"
-# Name "Client7z - Win32 Debug"
-# Begin Group "Spec"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=.\resource.rc
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.cpp
-# ADD CPP /Yc"stdafx.h"
-# End Source File
-# Begin Source File
-
-SOURCE=.\StdAfx.h
-# End Source File
-# End Group
-# Begin Group "Windows"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\DLL.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileDir.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileFind.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileIO.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\FileName.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariant.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Windows\PropVariantConv.h
-# End Source File
-# End Group
-# Begin Group "Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\IntToString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyString.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\MyVector.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\NewHandler.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\StringConvert.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\Common\Wildcard.h
-# End Source File
-# End Group
-# Begin Group "7zip Common"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\Common\FileStreams.h
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\Client7z.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\C\Sort.h
-# End Source File
-# End Target
-# End Project
+# Microsoft Developer Studio Project File - Name="Client7z" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Client7z - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Client7z.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Client7z.mak" CFG="Client7z - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Client7z - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Client7z - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Client7z - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /MD /W4 /WX /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"Release/7zcl.exe"
+
+!ELSEIF "$(CFG)" == "Client7z - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"Debug/7zcl.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Client7z - Win32 Release"
+# Name "Client7z - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"stdafx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyLinux.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "7zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zVersion.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# End Group
+# Begin Group "7zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\Client7z.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/Client7z/Client7z.dsw b/CPP/7zip/UI/Client7z/Client7z.dsw
index 4c26851..598a6d3 100644
--- a/CPP/7zip/UI/Client7z/Client7z.dsw
+++ b/CPP/7zip/UI/Client7z/Client7z.dsw
@@ -1,29 +1,29 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "Client7z"=.\Client7z.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Client7z"=.\Client7z.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/Client7z/StdAfx.cpp b/CPP/7zip/UI/Client7z/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/UI/Client7z/StdAfx.cpp
+++ b/CPP/7zip/UI/Client7z/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/Client7z/StdAfx.h b/CPP/7zip/UI/Client7z/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/UI/Client7z/StdAfx.h
+++ b/CPP/7zip/UI/Client7z/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/UI/Client7z/makefile b/CPP/7zip/UI/Client7z/makefile
index 9f68f16..988701e 100644
--- a/CPP/7zip/UI/Client7z/makefile
+++ b/CPP/7zip/UI/Client7z/makefile
@@ -1,28 +1,28 @@
-PROG = 7zcl.exe
-MY_CONSOLE = 1
-
-CURRENT_OBJS = \
- $O\Client7z.obj \
-
-COMMON_OBJS = \
- $O\IntToString.obj \
- $O\NewHandler.obj \
- $O\MyString.obj \
- $O\StringConvert.obj \
- $O\StringToInt.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
-
-WIN_OBJS = \
- $O\DLL.obj \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileName.obj \
- $O\PropVariant.obj \
- $O\PropVariantConv.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\FileStreams.obj \
-
-!include "../../7zip.mak"
+PROG = 7zcl.exe
+MY_CONSOLE = 1
+
+CURRENT_OBJS = \
+ $O\Client7z.obj \
+
+COMMON_OBJS = \
+ $O\IntToString.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\FileStreams.obj \
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Client7z/makefile.gcc b/CPP/7zip/UI/Client7z/makefile.gcc
new file mode 100644
index 0000000..3f97205
--- /dev/null
+++ b/CPP/7zip/UI/Client7z/makefile.gcc
@@ -0,0 +1,69 @@
+PROG = 7zcl
+IS_NOT_STANDALONE = 1
+
+# IS_X64 = 1
+
+
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+
+ifdef IS_MINGW
+
+SYS_OBJS = \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+ $O/TimeUtils.o \
+
+endif
+
+
+LOCAL_FLAGS = \
+
+
+CURRENT_OBJS = \
+ $O/Client7z.o \
+
+COMMON_OBJS = \
+ $O/IntToString.o \
+ $O/MyString.o \
+ $O/MyVector.o \
+ $O/NewHandler.o \
+ $O/StringConvert.o \
+ $O/StringToInt.o \
+ $O/UTFConvert.o \
+ $O/Wildcard.o \
+
+WIN_OBJS = \
+ $O/DLL.o \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileIO.o \
+ $O/FileName.o \
+ $O/PropVariant.o \
+ $O/PropVariantConv.o \
+
+7ZIP_COMMON_OBJS = \
+ $O/FileStreams.o \
+
+
+OBJS = \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(SYS_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(CURRENT_OBJS) \
+
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/UI/Client7z/resource.rc b/CPP/7zip/UI/Client7z/resource.rc
index 701a783..462df6f 100644
--- a/CPP/7zip/UI/Client7z/resource.rc
+++ b/CPP/7zip/UI/Client7z/resource.rc
@@ -1,3 +1,3 @@
-#include "../../MyVersionInfo.rc"
-
-MY_VERSION_INFO_APP("7-Zip client" , "7zcl")
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_APP("7-Zip client" , "7zcl")
diff --git a/CPP/7zip/UI/Common/ArchiveCommandLine.cpp b/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
index 35dbd74..2bdbc41 100644
--- a/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
+++ b/CPP/7zip/UI/Common/ArchiveCommandLine.cpp
@@ -1,1295 +1,1700 @@
-// ArchiveCommandLine.cpp
-
-#include "StdAfx.h"
-#undef printf
-#undef sprintf
-
-#ifdef _WIN32
-#ifndef UNDER_CE
-#include <io.h>
-#endif
-#else
-// for isatty()
-#include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#ifdef _7ZIP_LARGE_PAGES
-#include "../../../../C/Alloc.h"
-#endif
-
-#include "../../../Common/ListFileUtils.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/StringToInt.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileName.h"
-#ifdef _WIN32
-#include "../../../Windows/FileMapping.h"
-#include "../../../Windows/MemoryLock.h"
-#include "../../../Windows/Synchronization.h"
-#endif
-
-#include "ArchiveCommandLine.h"
-#include "EnumDirItems.h"
-#include "Update.h"
-#include "UpdateAction.h"
-
-extern bool g_CaseSensitive;
-extern bool g_PathTrailReplaceMode;
-
-#ifdef _7ZIP_LARGE_PAGES
-bool g_LargePagesMode = false;
-#endif
-
-#ifdef UNDER_CE
-
-#define MY_IS_TERMINAL(x) false;
-
-#else
-
-#if _MSC_VER >= 1400
-#define MY_isatty_fileno(x) _isatty(_fileno(x))
-#else
-#define MY_isatty_fileno(x) isatty(fileno(x))
-#endif
-
-#define MY_IS_TERMINAL(x) (MY_isatty_fileno(x) != 0);
-
-#endif
-
-using namespace NCommandLineParser;
-using namespace NWindows;
-using namespace NFile;
-
-static bool StringToUInt32(const wchar_t *s, UInt32 &v)
-{
- if (*s == 0)
- return false;
- const wchar_t *end;
- v = ConvertStringToUInt32(s, &end);
- return *end == 0;
-}
-
-
-int g_CodePage = -1;
-
-namespace NKey {
-enum Enum
-{
- kHelp1 = 0,
- kHelp2,
- kHelp3,
-
- kDisableHeaders,
- kDisablePercents,
- kShowTime,
- kLogLevel,
-
- kOutStream,
- kErrStream,
- kPercentStream,
-
- kYes,
-
- kShowDialog,
- kOverwrite,
-
- kArchiveType,
- kExcludedArcType,
-
- kProperty,
- kOutputDir,
- kWorkingDir,
-
- kInclude,
- kExclude,
- kArInclude,
- kArExclude,
- kNoArName,
-
- kUpdate,
- kVolume,
- kRecursed,
-
- kAffinity,
- kSfx,
- kEmail,
- kHash,
-
- kStdIn,
- kStdOut,
-
- kLargePages,
- kListfileCharSet,
- kConsoleCharSet,
- kTechMode,
-
- kShareForWrite,
- kStopAfterOpenError,
- kCaseSensitive,
- kArcNameMode,
-
- kDisableWildcardParsing,
- kElimDup,
- kFullPathMode,
-
- kHardLinks,
- kSymLinks,
- kNtSecurity,
-
- kAltStreams,
- kReplaceColonForAltStream,
- kWriteToAltStreamIfColon,
-
- kNameTrailReplace,
-
- kDeleteAfterCompressing,
- kSetArcMTime
-
- #ifndef _NO_CRYPTO
- , kPassword
- #endif
-};
-
-}
-
-
-static const wchar_t kRecursedIDChar = 'r';
-static const char * const kRecursedPostCharSet = "0-";
-
-static const char * const k_ArcNameMode_PostCharSet = "sea";
-
-static const char * const k_Stream_PostCharSet = "012";
-
-static inline const EArcNameMode ParseArcNameMode(int postCharIndex)
-{
- switch (postCharIndex)
- {
- case 1: return k_ArcNameMode_Exact;
- case 2: return k_ArcNameMode_Add;
- default: return k_ArcNameMode_Smart;
- }
-}
-
-namespace NRecursedPostCharIndex {
- enum EEnum
- {
- kWildcardRecursionOnly = 0,
- kNoRecursion = 1
- };
-}
-
-static const char kImmediateNameID = '!';
-static const char kMapNameID = '#';
-static const char kFileListID = '@';
-
-static const char kSomeCludePostStringMinSize = 2; // at least <@|!><N>ame must be
-static const char kSomeCludeAfterRecursedPostStringMinSize = 2; // at least <@|!><N>ame must be
-
-static const char * const kOverwritePostCharSet = "asut";
-
-static const NExtract::NOverwriteMode::EEnum k_OverwriteModes[] =
-{
- NExtract::NOverwriteMode::kOverwrite,
- NExtract::NOverwriteMode::kSkip,
- NExtract::NOverwriteMode::kRename,
- NExtract::NOverwriteMode::kRenameExisting
-};
-
-static const CSwitchForm kSwitchForms[] =
-{
- { "?" },
- { "h" },
- { "-help" },
-
- { "ba" },
- { "bd" },
- { "bt" },
- { "bb", NSwitchType::kString, false, 0 },
-
- { "bso", NSwitchType::kChar, false, 1, k_Stream_PostCharSet },
- { "bse", NSwitchType::kChar, false, 1, k_Stream_PostCharSet },
- { "bsp", NSwitchType::kChar, false, 1, k_Stream_PostCharSet },
-
- { "y" },
-
- { "ad" },
- { "ao", NSwitchType::kChar, false, 1, kOverwritePostCharSet},
-
- { "t", NSwitchType::kString, false, 1 },
- { "stx", NSwitchType::kString, true, 1 },
-
- { "m", NSwitchType::kString, true, 1 },
- { "o", NSwitchType::kString, false, 1 },
- { "w", NSwitchType::kString },
-
- { "i", NSwitchType::kString, true, kSomeCludePostStringMinSize},
- { "x", NSwitchType::kString, true, kSomeCludePostStringMinSize},
- { "ai", NSwitchType::kString, true, kSomeCludePostStringMinSize},
- { "ax", NSwitchType::kString, true, kSomeCludePostStringMinSize},
- { "an" },
-
- { "u", NSwitchType::kString, true, 1},
- { "v", NSwitchType::kString, true, 1},
- { "r", NSwitchType::kChar, false, 0, kRecursedPostCharSet },
-
- { "stm", NSwitchType::kString },
- { "sfx", NSwitchType::kString },
- { "seml", NSwitchType::kString, false, 0},
- { "scrc", NSwitchType::kString, true, 0 },
-
- { "si", NSwitchType::kString },
- { "so" },
-
- { "slp", NSwitchType::kString },
- { "scs", NSwitchType::kString },
- { "scc", NSwitchType::kString },
- { "slt" },
-
- { "ssw" },
- { "sse" },
- { "ssc", NSwitchType::kMinus },
- { "sa", NSwitchType::kChar, false, 1, k_ArcNameMode_PostCharSet },
-
- { "spd" },
- { "spe", NSwitchType::kMinus },
- { "spf", NSwitchType::kString, false, 0 },
-
- { "snh", NSwitchType::kMinus },
- { "snl", NSwitchType::kMinus },
- { "sni" },
-
- { "sns", NSwitchType::kMinus },
- { "snr" },
- { "snc" },
-
- { "snt", NSwitchType::kMinus },
-
- { "sdel" },
- { "stl" }
-
- #ifndef _NO_CRYPTO
- , { "p", NSwitchType::kString }
- #endif
-};
-
-static const char * const kUniversalWildcard = "*";
-static const unsigned kMinNonSwitchWords = 1;
-static const unsigned kCommandIndex = 0;
-
-// static const char * const kUserErrorMessage = "Incorrect command line";
-static const char * const kCannotFindListFile = "Cannot find listfile";
-static const char * const kIncorrectListFile = "Incorrect item in listfile.\nCheck charset encoding and -scs switch.";
-static const char * const kTerminalOutError = "I won't write compressed data to a terminal";
-static const char * const kSameTerminalError = "I won't write data and program's messages to same stream";
-static const char * const kEmptyFilePath = "Empty file path";
-
-bool CArcCommand::IsFromExtractGroup() const
-{
- switch (CommandType)
- {
- case NCommandType::kTest:
- case NCommandType::kExtract:
- case NCommandType::kExtractFull:
- return true;
- }
- return false;
-}
-
-NExtract::NPathMode::EEnum CArcCommand::GetPathMode() const
-{
- switch (CommandType)
- {
- case NCommandType::kTest:
- case NCommandType::kExtractFull:
- return NExtract::NPathMode::kFullPaths;
- }
- return NExtract::NPathMode::kNoPaths;
-}
-
-bool CArcCommand::IsFromUpdateGroup() const
-{
- switch (CommandType)
- {
- case NCommandType::kAdd:
- case NCommandType::kUpdate:
- case NCommandType::kDelete:
- case NCommandType::kRename:
- return true;
- }
- return false;
-}
-
-static NRecursedType::EEnum GetRecursedTypeFromIndex(int index)
-{
- switch (index)
- {
- case NRecursedPostCharIndex::kWildcardRecursionOnly:
- return NRecursedType::kWildcardOnlyRecursed;
- case NRecursedPostCharIndex::kNoRecursion:
- return NRecursedType::kNonRecursed;
- default:
- return NRecursedType::kRecursed;
- }
-}
-
-static const char *g_Commands = "audtexlbih";
-
-static bool ParseArchiveCommand(const UString &commandString, CArcCommand &command)
-{
- UString s (commandString);
- s.MakeLower_Ascii();
- if (s.Len() == 1)
- {
- if (s[0] > 0x7F)
- return false;
- int index = FindCharPosInString(g_Commands, (char)s[0]);
- if (index < 0)
- return false;
- command.CommandType = (NCommandType::EEnum)index;
- return true;
- }
- if (s.Len() == 2 && s[0] == 'r' && s[1] == 'n')
- {
- command.CommandType = (NCommandType::kRename);
- return true;
- }
- return false;
-}
-
-// ------------------------------------------------------------------
-// filenames functions
-
-static void AddNameToCensor(NWildcard::CCensor &censor,
- const UString &name, bool include, NRecursedType::EEnum type, bool wildcardMatching)
-{
- bool recursed = false;
-
- switch (type)
- {
- case NRecursedType::kWildcardOnlyRecursed:
- recursed = DoesNameContainWildcard(name);
- break;
- case NRecursedType::kRecursed:
- recursed = true;
- break;
- }
- censor.AddPreItem(include, name, recursed, wildcardMatching);
-}
-
-static void AddRenamePair(CObjectVector<CRenamePair> *renamePairs,
- const UString &oldName, const UString &newName, NRecursedType::EEnum type,
- bool wildcardMatching)
-{
- CRenamePair &pair = renamePairs->AddNew();
- pair.OldName = oldName;
- pair.NewName = newName;
- pair.RecursedType = type;
- pair.WildcardParsing = wildcardMatching;
-
- if (!pair.Prepare())
- {
- UString val;
- val += pair.OldName;
- val.Add_LF();
- val += pair.NewName;
- val.Add_LF();
- if (type == NRecursedType::kRecursed)
- val += "-r";
- else if (type == NRecursedType::kWildcardOnlyRecursed)
- val += "-r0";
- throw CArcCmdLineException("Unsupported rename command:", val);
- }
-}
-
-static void AddToCensorFromListFile(
- CObjectVector<CRenamePair> *renamePairs,
- NWildcard::CCensor &censor,
- LPCWSTR fileName, bool include, NRecursedType::EEnum type, bool wildcardMatching, Int32 codePage)
-{
- UStringVector names;
- if (!NFind::DoesFileExist(us2fs(fileName)))
- throw CArcCmdLineException(kCannotFindListFile, fileName);
- DWORD lastError = 0;
- if (!ReadNamesFromListFile2(us2fs(fileName), names, codePage, lastError))
- {
- if (lastError != 0)
- {
- UString m;
- m = "The file operation error for listfile";
- m.Add_LF();
- m += NError::MyFormatMessage(lastError);
- throw CArcCmdLineException(m, fileName);
- }
- throw CArcCmdLineException(kIncorrectListFile, fileName);
- }
- if (renamePairs)
- {
- if ((names.Size() & 1) != 0)
- throw CArcCmdLineException(kIncorrectListFile, fileName);
- for (unsigned i = 0; i < names.Size(); i += 2)
- {
- // change type !!!!
- AddRenamePair(renamePairs, names[i], names[i + 1], type, wildcardMatching);
- }
- }
- else
- FOR_VECTOR (i, names)
- AddNameToCensor(censor, names[i], include, type, wildcardMatching);
-}
-
-static void AddToCensorFromNonSwitchesStrings(
- CObjectVector<CRenamePair> *renamePairs,
- unsigned startIndex,
- NWildcard::CCensor &censor,
- const UStringVector &nonSwitchStrings,
- int stopSwitchIndex,
- NRecursedType::EEnum type,
- bool wildcardMatching,
- bool thereAreSwitchIncludes, Int32 codePage)
-{
- if ((renamePairs || nonSwitchStrings.Size() == startIndex) && !thereAreSwitchIncludes)
- AddNameToCensor(censor, UString(kUniversalWildcard), true, type,
- true // wildcardMatching
- );
-
- int oldIndex = -1;
-
- if (stopSwitchIndex < 0)
- stopSwitchIndex = nonSwitchStrings.Size();
-
- for (unsigned i = startIndex; i < nonSwitchStrings.Size(); i++)
- {
- const UString &s = nonSwitchStrings[i];
- if (s.IsEmpty())
- throw CArcCmdLineException(kEmptyFilePath);
- if (i < (unsigned)stopSwitchIndex && s[0] == kFileListID)
- AddToCensorFromListFile(renamePairs, censor, s.Ptr(1), true, type, wildcardMatching, codePage);
- else if (renamePairs)
- {
- if (oldIndex == -1)
- oldIndex = i;
- else
- {
- // NRecursedType::EEnum type is used for global wildcard (-i! switches)
- AddRenamePair(renamePairs, nonSwitchStrings[oldIndex], s, NRecursedType::kNonRecursed, wildcardMatching);
- // AddRenamePair(renamePairs, nonSwitchStrings[oldIndex], s, type);
- oldIndex = -1;
- }
- }
- else
- AddNameToCensor(censor, s, true, type, wildcardMatching);
- }
-
- if (oldIndex != -1)
- {
- throw CArcCmdLineException("There is no second file name for rename pair:", nonSwitchStrings[oldIndex]);
- }
-}
-
-#ifdef _WIN32
-
-struct CEventSetEnd
-{
- UString Name;
-
- CEventSetEnd(const wchar_t *name): Name(name) {}
- ~CEventSetEnd()
- {
- NSynchronization::CManualResetEvent event;
- if (event.Open(EVENT_MODIFY_STATE, false, GetSystemString(Name)) == 0)
- event.Set();
- }
-};
-
-static const char * const k_IncorrectMapCommand = "Incorrect Map command";
-
-static const char *ParseMapWithPaths(
- NWildcard::CCensor &censor,
- const UString &s2, bool include,
- NRecursedType::EEnum commonRecursedType,
- bool wildcardMatching)
-{
- UString s (s2);
- int pos = s.Find(L':');
- if (pos < 0)
- return k_IncorrectMapCommand;
- int pos2 = s.Find(L':', pos + 1);
- if (pos2 < 0)
- return k_IncorrectMapCommand;
-
- CEventSetEnd eventSetEnd((const wchar_t *)s + ((unsigned)pos2 + 1));
- s.DeleteFrom(pos2);
- UInt32 size;
- if (!StringToUInt32(s.Ptr(pos + 1), size)
- || size < sizeof(wchar_t)
- || size > ((UInt32)1 << 31)
- || size % sizeof(wchar_t) != 0)
- return "Unsupported Map data size";
-
- s.DeleteFrom(pos);
- CFileMapping map;
- if (map.Open(FILE_MAP_READ, GetSystemString(s)) != 0)
- return "Can not open mapping";
- LPVOID data = map.Map(FILE_MAP_READ, 0, size);
- if (!data)
- return "MapViewOfFile error";
- CFileUnmapper unmapper(data);
-
- UString name;
- const wchar_t *p = (const wchar_t *)data;
- if (*p != 0) // data format marker
- return "Unsupported Map data";
- UInt32 numChars = size / sizeof(wchar_t);
- for (UInt32 i = 1; i < numChars; i++)
- {
- wchar_t c = p[i];
- if (c == 0)
- {
- // MessageBoxW(0, name, L"7-Zip", 0);
- AddNameToCensor(censor, name, include, commonRecursedType, wildcardMatching);
- name.Empty();
- }
- else
- name += c;
- }
- if (!name.IsEmpty())
- return "Map data error";
-
- return NULL;
-}
-
-#endif
-
-static void AddSwitchWildcardsToCensor(
- NWildcard::CCensor &censor,
- const UStringVector &strings, bool include,
- NRecursedType::EEnum commonRecursedType,
- bool wildcardMatching,
- Int32 codePage)
-{
- const char *errorMessage = NULL;
- unsigned i;
- for (i = 0; i < strings.Size(); i++)
- {
- const UString &name = strings[i];
- NRecursedType::EEnum recursedType;
- unsigned pos = 0;
-
- if (name.Len() < kSomeCludePostStringMinSize)
- {
- errorMessage = "Too short switch";
- break;
- }
-
- if (::MyCharLower_Ascii(name[pos]) == kRecursedIDChar)
- {
- pos++;
- wchar_t c = name[pos];
- int index = -1;
- if (c <= 0x7F)
- index = FindCharPosInString(kRecursedPostCharSet, (char)c);
- recursedType = GetRecursedTypeFromIndex(index);
- if (index >= 0)
- pos++;
- }
- else
- recursedType = commonRecursedType;
-
- if (name.Len() < pos + kSomeCludeAfterRecursedPostStringMinSize)
- {
- errorMessage = "Too short switch";
- break;
- }
-
- const UString tail = name.Ptr(pos + 1);
-
- if (name[pos] == kImmediateNameID)
- AddNameToCensor(censor, tail, include, recursedType, wildcardMatching);
- else if (name[pos] == kFileListID)
- AddToCensorFromListFile(NULL, censor, tail, include, recursedType, wildcardMatching, codePage);
- #ifdef _WIN32
- else if (name[pos] == kMapNameID)
- {
- errorMessage = ParseMapWithPaths(censor, tail, include, recursedType, wildcardMatching);
- if (errorMessage)
- break;
- }
- #endif
- else
- {
- errorMessage = "Incorrect wildcard type marker";
- break;
- }
- }
- if (i != strings.Size())
- throw CArcCmdLineException(errorMessage, strings[i]);
-}
-
-/*
-static NUpdateArchive::NPairAction::EEnum GetUpdatePairActionType(int i)
-{
- switch (i)
- {
- case NUpdateArchive::NPairAction::kIgnore: return NUpdateArchive::NPairAction::kIgnore;
- case NUpdateArchive::NPairAction::kCopy: return NUpdateArchive::NPairAction::kCopy;
- case NUpdateArchive::NPairAction::kCompress: return NUpdateArchive::NPairAction::kCompress;
- case NUpdateArchive::NPairAction::kCompressAsAnti: return NUpdateArchive::NPairAction::kCompressAsAnti;
- }
- throw 98111603;
-}
-*/
-
-static const char * const kUpdatePairStateIDSet = "pqrxyzw";
-static const int kUpdatePairStateNotSupportedActions[] = {2, 2, 1, -1, -1, -1, -1};
-
-static const unsigned kNumUpdatePairActions = 4;
-static const char * const kUpdateIgnoreItselfPostStringID = "-";
-static const wchar_t kUpdateNewArchivePostCharID = '!';
-
-
-static bool ParseUpdateCommandString2(const UString &command,
- NUpdateArchive::CActionSet &actionSet, UString &postString)
-{
- for (unsigned i = 0; i < command.Len();)
- {
- wchar_t c = MyCharLower_Ascii(command[i]);
- int statePos = FindCharPosInString(kUpdatePairStateIDSet, (char)c);
- if (c > 0x7F || statePos < 0)
- {
- postString = command.Ptr(i);
- return true;
- }
- i++;
- if (i >= command.Len())
- return false;
- c = command[i];
- if (c < '0' || c >= '0' + kNumUpdatePairActions)
- return false;
- unsigned actionPos = c - '0';
- actionSet.StateActions[(unsigned)statePos] = (NUpdateArchive::NPairAction::EEnum)(actionPos);
- if (kUpdatePairStateNotSupportedActions[(unsigned)statePos] == (int)actionPos)
- return false;
- i++;
- }
- postString.Empty();
- return true;
-}
-
-static void ParseUpdateCommandString(CUpdateOptions &options,
- const UStringVector &updatePostStrings,
- const NUpdateArchive::CActionSet &defaultActionSet)
-{
- const char *errorMessage = "incorrect update switch command";
- unsigned i;
- for (i = 0; i < updatePostStrings.Size(); i++)
- {
- const UString &updateString = updatePostStrings[i];
- if (updateString.IsEqualTo(kUpdateIgnoreItselfPostStringID))
- {
- if (options.UpdateArchiveItself)
- {
- options.UpdateArchiveItself = false;
- options.Commands.Delete(0);
- }
- }
- else
- {
- NUpdateArchive::CActionSet actionSet = defaultActionSet;
-
- UString postString;
- if (!ParseUpdateCommandString2(updateString, actionSet, postString))
- break;
- if (postString.IsEmpty())
- {
- if (options.UpdateArchiveItself)
- options.Commands[0].ActionSet = actionSet;
- }
- else
- {
- if (postString[0] != kUpdateNewArchivePostCharID)
- break;
- CUpdateArchiveCommand uc;
- UString archivePath = postString.Ptr(1);
- if (archivePath.IsEmpty())
- break;
- uc.UserArchivePath = archivePath;
- uc.ActionSet = actionSet;
- options.Commands.Add(uc);
- }
- }
- }
- if (i != updatePostStrings.Size())
- throw CArcCmdLineException(errorMessage, updatePostStrings[i]);
-}
-
-bool ParseComplexSize(const wchar_t *s, UInt64 &result);
-
-static void SetAddCommandOptions(
- NCommandType::EEnum commandType,
- const CParser &parser,
- CUpdateOptions &options)
-{
- NUpdateArchive::CActionSet defaultActionSet;
- switch (commandType)
- {
- case NCommandType::kAdd:
- defaultActionSet = NUpdateArchive::k_ActionSet_Add;
- break;
- case NCommandType::kDelete:
- defaultActionSet = NUpdateArchive::k_ActionSet_Delete;
- break;
- default:
- defaultActionSet = NUpdateArchive::k_ActionSet_Update;
- }
-
- options.UpdateArchiveItself = true;
-
- options.Commands.Clear();
- CUpdateArchiveCommand updateMainCommand;
- updateMainCommand.ActionSet = defaultActionSet;
- options.Commands.Add(updateMainCommand);
- if (parser[NKey::kUpdate].ThereIs)
- ParseUpdateCommandString(options, parser[NKey::kUpdate].PostStrings,
- defaultActionSet);
- if (parser[NKey::kWorkingDir].ThereIs)
- {
- const UString &postString = parser[NKey::kWorkingDir].PostStrings[0];
- if (postString.IsEmpty())
- NDir::MyGetTempPath(options.WorkingDir);
- else
- options.WorkingDir = us2fs(postString);
- }
- options.SfxMode = parser[NKey::kSfx].ThereIs;
- if (options.SfxMode)
- options.SfxModule = us2fs(parser[NKey::kSfx].PostStrings[0]);
-
- if (parser[NKey::kVolume].ThereIs)
- {
- const UStringVector &sv = parser[NKey::kVolume].PostStrings;
- FOR_VECTOR (i, sv)
- {
- UInt64 size;
- if (!ParseComplexSize(sv[i], size) || size == 0)
- throw CArcCmdLineException("Incorrect volume size:", sv[i]);
- options.VolumesSizes.Add(size);
- }
- }
-}
-
-static void SetMethodOptions(const CParser &parser, CObjectVector<CProperty> &properties)
-{
- if (parser[NKey::kProperty].ThereIs)
- {
- FOR_VECTOR (i, parser[NKey::kProperty].PostStrings)
- {
- CProperty prop;
- prop.Name = parser[NKey::kProperty].PostStrings[i];
- int index = prop.Name.Find(L'=');
- if (index >= 0)
- {
- prop.Value = prop.Name.Ptr(index + 1);
- prop.Name.DeleteFrom(index);
- }
- properties.Add(prop);
- }
- }
-}
-
-
-static inline void SetStreamMode(const CSwitchResult &sw, unsigned &res)
-{
- if (sw.ThereIs)
- res = sw.PostCharIndex;
-}
-
-
-void CArcCmdLineParser::Parse1(const UStringVector &commandStrings,
- CArcCmdLineOptions &options)
-{
- if (!parser.ParseStrings(kSwitchForms, ARRAY_SIZE(kSwitchForms), commandStrings))
- throw CArcCmdLineException(parser.ErrorMessage, parser.ErrorLine);
-
- options.IsInTerminal = MY_IS_TERMINAL(stdin);
- options.IsStdOutTerminal = MY_IS_TERMINAL(stdout);
- options.IsStdErrTerminal = MY_IS_TERMINAL(stderr);
-
- options.HelpMode = parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs || parser[NKey::kHelp3].ThereIs;
-
- options.StdInMode = parser[NKey::kStdIn].ThereIs;
- options.StdOutMode = parser[NKey::kStdOut].ThereIs;
- options.EnableHeaders = !parser[NKey::kDisableHeaders].ThereIs;
- options.TechMode = parser[NKey::kTechMode].ThereIs;
- options.ShowTime = parser[NKey::kShowTime].ThereIs;
-
- if (parser[NKey::kDisablePercents].ThereIs
- || options.StdOutMode
- || !options.IsStdOutTerminal)
- options.Number_for_Percents = k_OutStream_disabled;
-
- if (options.StdOutMode)
- options.Number_for_Out = k_OutStream_disabled;
-
- SetStreamMode(parser[NKey::kOutStream], options.Number_for_Out);
- SetStreamMode(parser[NKey::kErrStream], options.Number_for_Errors);
- SetStreamMode(parser[NKey::kPercentStream], options.Number_for_Percents);
-
- if (parser[NKey::kLogLevel].ThereIs)
- {
- const UString &s = parser[NKey::kLogLevel].PostStrings[0];
- if (s.IsEmpty())
- options.LogLevel = 1;
- else
- {
- UInt32 v;
- if (!StringToUInt32(s, v))
- throw CArcCmdLineException("Unsupported switch postfix -bb", s);
- options.LogLevel = (unsigned)v;
- }
- }
-
- if (parser[NKey::kCaseSensitive].ThereIs)
- {
- g_CaseSensitive = !parser[NKey::kCaseSensitive].WithMinus;
- options.CaseSensitiveChange = true;
- options.CaseSensitive = g_CaseSensitive;
- }
-
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- NSecurity::EnablePrivilege_SymLink();
- #endif
-
- // options.LargePages = false;
-
- if (parser[NKey::kLargePages].ThereIs)
- {
- unsigned slp = 0;
- const UString &s = parser[NKey::kLargePages].PostStrings[0];
- if (s.IsEmpty())
- slp = 1;
- else if (s != L"-")
- {
- if (!StringToUInt32(s, slp))
- throw CArcCmdLineException("Unsupported switch postfix for -slp", s);
- }
-
- #ifdef _7ZIP_LARGE_PAGES
- if (slp >
- #ifndef UNDER_CE
- (unsigned)NSecurity::Get_LargePages_RiskLevel()
- #else
- 0
- #endif
- )
- {
- SetLargePageSize();
- // note: this process also can inherit that Privilege from parent process
- g_LargePagesMode =
- #if defined(_WIN32) && !defined(UNDER_CE)
- NSecurity::EnablePrivilege_LockMemory();
- #else
- true;
- #endif
- }
- #endif
- }
-
-
- #ifndef UNDER_CE
-
- if (parser[NKey::kAffinity].ThereIs)
- {
- const UString &s = parser[NKey::kAffinity].PostStrings[0];
- if (!s.IsEmpty())
- {
- UInt32 v = 0;
- AString a;
- a.SetFromWStr_if_Ascii(s);
- if (!a.IsEmpty())
- {
- const char *end;
- v = ConvertHexStringToUInt32(a, &end);
- if (*end != 0)
- a.Empty();
- }
- if (a.IsEmpty())
- throw CArcCmdLineException("Unsupported switch postfix -stm", s);
-
- #ifdef _WIN32
- SetProcessAffinityMask(GetCurrentProcess(), v);
- #endif
- }
- }
-
- #endif
-}
-
-struct CCodePagePair
-{
- const char *Name;
- Int32 CodePage;
-};
-
-static const unsigned kNumByteOnlyCodePages = 3;
-
-static const CCodePagePair g_CodePagePairs[] =
-{
- { "utf-8", CP_UTF8 },
- { "win", CP_ACP },
- { "dos", CP_OEMCP },
- { "utf-16le", MY__CP_UTF16 },
- { "utf-16be", MY__CP_UTF16BE }
-};
-
-static Int32 FindCharset(const NCommandLineParser::CParser &parser, unsigned keyIndex,
- bool byteOnlyCodePages, Int32 defaultVal)
-{
- if (!parser[keyIndex].ThereIs)
- return defaultVal;
-
- UString name (parser[keyIndex].PostStrings.Back());
- UInt32 v;
- if (StringToUInt32(name, v))
- if (v < ((UInt32)1 << 16))
- return (Int32)v;
- name.MakeLower_Ascii();
- unsigned num = byteOnlyCodePages ? kNumByteOnlyCodePages : ARRAY_SIZE(g_CodePagePairs);
- for (unsigned i = 0;; i++)
- {
- if (i == num) // to disable warnings from different compilers
- throw CArcCmdLineException("Unsupported charset:", name);
- const CCodePagePair &pair = g_CodePagePairs[i];
- if (name.IsEqualTo(pair.Name))
- return pair.CodePage;
- }
-}
-
-
-static void SetBoolPair(NCommandLineParser::CParser &parser, unsigned switchID, CBoolPair &bp)
-{
- bp.Def = parser[switchID].ThereIs;
- if (bp.Def)
- bp.Val = !parser[switchID].WithMinus;
-}
-
-void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
-{
- const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
- const unsigned numNonSwitchStrings = nonSwitchStrings.Size();
- if (numNonSwitchStrings < kMinNonSwitchWords)
- throw CArcCmdLineException("The command must be specified");
-
- if (!ParseArchiveCommand(nonSwitchStrings[kCommandIndex], options.Command))
- throw CArcCmdLineException("Unsupported command:", nonSwitchStrings[kCommandIndex]);
-
- if (parser[NKey::kHash].ThereIs)
- options.HashMethods = parser[NKey::kHash].PostStrings;
-
- if (parser[NKey::kElimDup].ThereIs)
- {
- options.ExtractOptions.ElimDup.Def = true;
- options.ExtractOptions.ElimDup.Val = !parser[NKey::kElimDup].WithMinus;
- }
-
- NWildcard::ECensorPathMode censorPathMode = NWildcard::k_RelatPath;
- bool fullPathMode = parser[NKey::kFullPathMode].ThereIs;
- if (fullPathMode)
- {
- censorPathMode = NWildcard::k_AbsPath;
- const UString &s = parser[NKey::kFullPathMode].PostStrings[0];
- if (!s.IsEmpty())
- {
- if (s == L"2")
- censorPathMode = NWildcard::k_FullPath;
- else
- throw CArcCmdLineException("Unsupported -spf:", s);
- }
- }
-
- if (parser[NKey::kNameTrailReplace].ThereIs)
- g_PathTrailReplaceMode = !parser[NKey::kNameTrailReplace].WithMinus;
-
- NRecursedType::EEnum recursedType;
- if (parser[NKey::kRecursed].ThereIs)
- recursedType = GetRecursedTypeFromIndex(parser[NKey::kRecursed].PostCharIndex);
- else
- recursedType = NRecursedType::kNonRecursed;
-
- bool wildcardMatching = true;
- if (parser[NKey::kDisableWildcardParsing].ThereIs)
- wildcardMatching = false;
-
- g_CodePage = FindCharset(parser, NKey::kConsoleCharSet, true, -1);
- Int32 codePage = FindCharset(parser, NKey::kListfileCharSet, false, CP_UTF8);
-
- bool thereAreSwitchIncludes = false;
-
- if (parser[NKey::kInclude].ThereIs)
- {
- thereAreSwitchIncludes = true;
- AddSwitchWildcardsToCensor(options.Censor,
- parser[NKey::kInclude].PostStrings, true, recursedType, wildcardMatching, codePage);
- }
-
- if (parser[NKey::kExclude].ThereIs)
- AddSwitchWildcardsToCensor(options.Censor,
- parser[NKey::kExclude].PostStrings, false, recursedType, wildcardMatching, codePage);
-
- unsigned curCommandIndex = kCommandIndex + 1;
- bool thereIsArchiveName = !parser[NKey::kNoArName].ThereIs &&
- options.Command.CommandType != NCommandType::kBenchmark &&
- options.Command.CommandType != NCommandType::kInfo &&
- options.Command.CommandType != NCommandType::kHash;
-
- bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
- bool isExtractOrList = isExtractGroupCommand || options.Command.CommandType == NCommandType::kList;
- bool isRename = options.Command.CommandType == NCommandType::kRename;
-
- if ((isExtractOrList || isRename) && options.StdInMode)
- thereIsArchiveName = false;
-
- if (parser[NKey::kArcNameMode].ThereIs)
- options.UpdateOptions.ArcNameMode = ParseArcNameMode(parser[NKey::kArcNameMode].PostCharIndex);
-
- if (thereIsArchiveName)
- {
- if (curCommandIndex >= numNonSwitchStrings)
- throw CArcCmdLineException("Cannot find archive name");
- options.ArchiveName = nonSwitchStrings[curCommandIndex++];
- if (options.ArchiveName.IsEmpty())
- throw CArcCmdLineException("Archive name cannot by empty");
- #ifdef _WIN32
- // options.ArchiveName.Replace(L'/', WCHAR_PATH_SEPARATOR);
- #endif
- }
-
- AddToCensorFromNonSwitchesStrings(isRename ? &options.UpdateOptions.RenamePairs : NULL,
- curCommandIndex, options.Censor,
- nonSwitchStrings, parser.StopSwitchIndex,
- recursedType, wildcardMatching,
- thereAreSwitchIncludes, codePage);
-
- options.YesToAll = parser[NKey::kYes].ThereIs;
-
-
- #ifndef _NO_CRYPTO
- options.PasswordEnabled = parser[NKey::kPassword].ThereIs;
- if (options.PasswordEnabled)
- options.Password = parser[NKey::kPassword].PostStrings[0];
- #endif
-
- options.ShowDialog = parser[NKey::kShowDialog].ThereIs;
-
- if (parser[NKey::kArchiveType].ThereIs)
- options.ArcType = parser[NKey::kArchiveType].PostStrings[0];
-
- options.ExcludedArcTypes = parser[NKey::kExcludedArcType].PostStrings;
-
- SetMethodOptions(parser, options.Properties);
-
- if (parser[NKey::kNtSecurity].ThereIs) options.NtSecurity.SetTrueTrue();
-
- SetBoolPair(parser, NKey::kAltStreams, options.AltStreams);
- SetBoolPair(parser, NKey::kHardLinks, options.HardLinks);
- SetBoolPair(parser, NKey::kSymLinks, options.SymLinks);
-
- if (isExtractOrList)
- {
- CExtractOptionsBase &eo = options.ExtractOptions;
-
- {
- CExtractNtOptions &nt = eo.NtOptions;
- nt.NtSecurity = options.NtSecurity;
-
- nt.AltStreams = options.AltStreams;
- if (!options.AltStreams.Def)
- nt.AltStreams.Val = true;
-
- nt.HardLinks = options.HardLinks;
- if (!options.HardLinks.Def)
- nt.HardLinks.Val = true;
-
- nt.SymLinks = options.SymLinks;
- if (!options.SymLinks.Def)
- nt.SymLinks.Val = true;
-
- nt.ReplaceColonForAltStream = parser[NKey::kReplaceColonForAltStream].ThereIs;
- nt.WriteToAltStreamIfColon = parser[NKey::kWriteToAltStreamIfColon].ThereIs;
- }
-
- options.Censor.AddPathsToCensor(NWildcard::k_AbsPath);
- options.Censor.ExtendExclude();
-
- // are there paths that look as non-relative (!Prefix.IsEmpty())
- if (!options.Censor.AllAreRelative())
- throw CArcCmdLineException("Cannot use absolute pathnames for this command");
-
- NWildcard::CCensor &arcCensor = options.arcCensor;
-
- if (parser[NKey::kArInclude].ThereIs)
- AddSwitchWildcardsToCensor(arcCensor, parser[NKey::kArInclude].PostStrings, true, NRecursedType::kNonRecursed, wildcardMatching, codePage);
- if (parser[NKey::kArExclude].ThereIs)
- AddSwitchWildcardsToCensor(arcCensor, parser[NKey::kArExclude].PostStrings, false, NRecursedType::kNonRecursed, wildcardMatching, codePage);
-
- if (thereIsArchiveName)
- AddNameToCensor(arcCensor, options.ArchiveName, true, NRecursedType::kNonRecursed, wildcardMatching);
-
- arcCensor.AddPathsToCensor(NWildcard::k_RelatPath);
-
- #ifdef _WIN32
- ConvertToLongNames(arcCensor);
- #endif
-
- arcCensor.ExtendExclude();
-
- if (options.StdInMode)
- options.ArcName_for_StdInMode = parser[NKey::kStdIn].PostStrings.Front();
-
- if (isExtractGroupCommand)
- {
- if (options.StdOutMode)
- {
- if (
- options.Number_for_Percents == k_OutStream_stdout
- // || options.Number_for_Out == k_OutStream_stdout
- // || options.Number_for_Errors == k_OutStream_stdout
- ||
- (
- (options.IsStdOutTerminal && options.IsStdErrTerminal)
- &&
- (
- options.Number_for_Percents != k_OutStream_disabled
- // || options.Number_for_Out != k_OutStream_disabled
- // || options.Number_for_Errors != k_OutStream_disabled
- )
- )
- )
- throw CArcCmdLineException(kSameTerminalError);
- }
-
- if (parser[NKey::kOutputDir].ThereIs)
- {
- eo.OutputDir = us2fs(parser[NKey::kOutputDir].PostStrings[0]);
- NFile::NName::NormalizeDirPathPrefix(eo.OutputDir);
- }
-
- eo.OverwriteMode = NExtract::NOverwriteMode::kAsk;
- if (parser[NKey::kOverwrite].ThereIs)
- {
- eo.OverwriteMode = k_OverwriteModes[(unsigned)parser[NKey::kOverwrite].PostCharIndex];
- eo.OverwriteMode_Force = true;
- }
- else if (options.YesToAll)
- {
- eo.OverwriteMode = NExtract::NOverwriteMode::kOverwrite;
- eo.OverwriteMode_Force = true;
- }
- }
-
- eo.PathMode = options.Command.GetPathMode();
- if (censorPathMode == NWildcard::k_AbsPath)
- {
- eo.PathMode = NExtract::NPathMode::kAbsPaths;
- eo.PathMode_Force = true;
- }
- else if (censorPathMode == NWildcard::k_FullPath)
- {
- eo.PathMode = NExtract::NPathMode::kFullPaths;
- eo.PathMode_Force = true;
- }
- }
- else if (options.Command.IsFromUpdateGroup())
- {
- if (parser[NKey::kArInclude].ThereIs)
- throw CArcCmdLineException("-ai switch is not supported for this command");
-
- CUpdateOptions &updateOptions = options.UpdateOptions;
-
- SetAddCommandOptions(options.Command.CommandType, parser, updateOptions);
-
- updateOptions.MethodMode.Properties = options.Properties;
-
- if (parser[NKey::kShareForWrite].ThereIs)
- updateOptions.OpenShareForWrite = true;
- if (parser[NKey::kStopAfterOpenError].ThereIs)
- updateOptions.StopAfterOpenError = true;
-
- updateOptions.PathMode = censorPathMode;
-
- updateOptions.AltStreams = options.AltStreams;
- updateOptions.NtSecurity = options.NtSecurity;
- updateOptions.HardLinks = options.HardLinks;
- updateOptions.SymLinks = options.SymLinks;
-
- updateOptions.EMailMode = parser[NKey::kEmail].ThereIs;
- if (updateOptions.EMailMode)
- {
- updateOptions.EMailAddress = parser[NKey::kEmail].PostStrings.Front();
- if (updateOptions.EMailAddress.Len() > 0)
- if (updateOptions.EMailAddress[0] == L'.')
- {
- updateOptions.EMailRemoveAfter = true;
- updateOptions.EMailAddress.Delete(0);
- }
- }
-
- updateOptions.StdOutMode = options.StdOutMode;
- updateOptions.StdInMode = options.StdInMode;
-
- updateOptions.DeleteAfterCompressing = parser[NKey::kDeleteAfterCompressing].ThereIs;
- updateOptions.SetArcMTime = parser[NKey::kSetArcMTime].ThereIs;
-
- if (updateOptions.StdOutMode && updateOptions.EMailMode)
- throw CArcCmdLineException("stdout mode and email mode cannot be combined");
-
- if (updateOptions.StdOutMode)
- {
- if (options.IsStdOutTerminal)
- throw CArcCmdLineException(kTerminalOutError);
-
- if (options.Number_for_Percents == k_OutStream_stdout
- || options.Number_for_Out == k_OutStream_stdout
- || options.Number_for_Errors == k_OutStream_stdout)
- throw CArcCmdLineException(kSameTerminalError);
- }
-
- if (updateOptions.StdInMode)
- updateOptions.StdInFileName = parser[NKey::kStdIn].PostStrings.Front();
-
- if (options.Command.CommandType == NCommandType::kRename)
- if (updateOptions.Commands.Size() != 1)
- throw CArcCmdLineException("Only one archive can be created with rename command");
- }
- else if (options.Command.CommandType == NCommandType::kBenchmark)
- {
- options.NumIterations = 1;
- if (curCommandIndex < numNonSwitchStrings)
- {
- if (!StringToUInt32(nonSwitchStrings[curCommandIndex], options.NumIterations))
- throw CArcCmdLineException("Incorrect Number of benmchmark iterations", nonSwitchStrings[curCommandIndex]);
- curCommandIndex++;
- }
- }
- else if (options.Command.CommandType == NCommandType::kHash)
- {
- options.Censor.AddPathsToCensor(censorPathMode);
- options.Censor.ExtendExclude();
-
- CHashOptions &hashOptions = options.HashOptions;
- hashOptions.PathMode = censorPathMode;
- hashOptions.Methods = options.HashMethods;
- if (parser[NKey::kShareForWrite].ThereIs)
- hashOptions.OpenShareForWrite = true;
- hashOptions.StdInMode = options.StdInMode;
- hashOptions.AltStreamsMode = options.AltStreams.Val;
- }
- else if (options.Command.CommandType == NCommandType::kInfo)
- {
- }
- else
- throw 20150919;
-}
+// ArchiveCommandLine.cpp
+
+#include "StdAfx.h"
+#undef printf
+#undef sprintf
+
+#ifdef _WIN32
+#ifndef UNDER_CE
+#include <io.h>
+#endif
+#else
+// for isatty()
+#include <unistd.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef Z7_LARGE_PAGES
+#include "../../../../C/Alloc.h"
+#endif
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/ListFileUtils.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/System.h"
+#ifdef _WIN32
+#include "../../../Windows/FileMapping.h"
+#include "../../../Windows/MemoryLock.h"
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "ArchiveCommandLine.h"
+#include "EnumDirItems.h"
+#include "Update.h"
+#include "UpdateAction.h"
+
+extern bool g_CaseSensitive;
+extern bool g_PathTrailReplaceMode;
+
+#ifdef Z7_LARGE_PAGES
+extern
+bool g_LargePagesMode;
+bool g_LargePagesMode = false;
+#endif
+
+/*
+#ifdef ENV_HAVE_LSTAT
+EXTERN_C_BEGIN
+extern int global_use_lstat;
+EXTERN_C_END
+#endif
+*/
+
+#ifdef UNDER_CE
+
+#define MY_IS_TERMINAL(x) false;
+
+#else
+
+// #define MY_isatty_fileno(x) (isatty(fileno(x)))
+// #define MY_IS_TERMINAL(x) (MY_isatty_fileno(x) != 0);
+static inline bool MY_IS_TERMINAL(FILE *x)
+{
+ return (
+ #if defined(_MSC_VER) && (_MSC_VER >= 1400)
+ _isatty(_fileno(x))
+ #else
+ isatty(fileno(x))
+ #endif
+ != 0);
+}
+
+#endif
+
+using namespace NCommandLineParser;
+using namespace NWindows;
+using namespace NFile;
+
+static bool StringToUInt32(const wchar_t *s, UInt32 &v)
+{
+ if (*s == 0)
+ return false;
+ const wchar_t *end;
+ v = ConvertStringToUInt32(s, &end);
+ return *end == 0;
+}
+
+
+namespace NKey {
+enum Enum
+{
+ kHelp1 = 0,
+ kHelp2,
+ kHelp3,
+
+ kDisableHeaders,
+ kDisablePercents,
+ kShowTime,
+ kLogLevel,
+
+ kOutStream,
+ kErrStream,
+ kPercentStream,
+
+ kYes,
+
+ kShowDialog,
+ kOverwrite,
+
+ kArchiveType,
+ kExcludedArcType,
+
+ kProperty,
+ kOutputDir,
+ kWorkingDir,
+
+ kInclude,
+ kExclude,
+ kArInclude,
+ kArExclude,
+ kNoArName,
+
+ kUpdate,
+ kVolume,
+ kRecursed,
+
+ kAffinity,
+ kSfx,
+ kEmail,
+ kHash,
+ // kHashGenFile,
+ kHashDir,
+
+ kStdIn,
+ kStdOut,
+
+ kLargePages,
+ kListfileCharSet,
+ kConsoleCharSet,
+ kTechMode,
+ kListFields,
+
+ kPreserveATime,
+ kShareForWrite,
+ kStopAfterOpenError,
+ kCaseSensitive,
+ kArcNameMode,
+
+ kUseSlashMark,
+ kDisableWildcardParsing,
+ kElimDup,
+ kFullPathMode,
+
+ kHardLinks,
+ kSymLinks_AllowDangerous,
+ kSymLinks,
+ kNtSecurity,
+
+ kStoreOwnerId,
+ kStoreOwnerName,
+
+ kZoneFile,
+ kAltStreams,
+ kReplaceColonForAltStream,
+ kWriteToAltStreamIfColon,
+
+ kNameTrailReplace,
+
+ kDeleteAfterCompressing,
+ kSetArcMTime
+
+ #ifndef Z7_NO_CRYPTO
+ , kPassword
+ #endif
+};
+
+}
+
+
+static const wchar_t kRecursedIDChar = 'r';
+static const char * const kRecursedPostCharSet = "0-";
+
+static const char * const k_ArcNameMode_PostCharSet = "sea";
+
+static const char * const k_Stream_PostCharSet = "012";
+
+static inline EArcNameMode ParseArcNameMode(int postCharIndex)
+{
+ switch (postCharIndex)
+ {
+ case 1: return k_ArcNameMode_Exact;
+ case 2: return k_ArcNameMode_Add;
+ default: return k_ArcNameMode_Smart;
+ }
+}
+
+namespace NRecursedPostCharIndex {
+ enum EEnum
+ {
+ kWildcardRecursionOnly = 0,
+ kNoRecursion = 1
+ };
+}
+
+// static const char
+#define kImmediateNameID '!'
+#ifdef _WIN32
+#define kMapNameID '#'
+#endif
+#define kFileListID '@'
+
+static const Byte kSomeCludePostStringMinSize = 2; // at least <@|!><N>ame must be
+static const Byte kSomeCludeAfterRecursedPostStringMinSize = 2; // at least <@|!><N>ame must be
+
+static const char * const kOverwritePostCharSet = "asut";
+
+static const NExtract::NOverwriteMode::EEnum k_OverwriteModes[] =
+{
+ NExtract::NOverwriteMode::kOverwrite,
+ NExtract::NOverwriteMode::kSkip,
+ NExtract::NOverwriteMode::kRename,
+ NExtract::NOverwriteMode::kRenameExisting
+};
+
+
+
+#define SWFRM_3(t, mu, mi) t, mu, mi, NULL
+
+#define SWFRM_1(t) SWFRM_3(t, false, 0)
+#define SWFRM_SIMPLE SWFRM_1(NSwitchType::kSimple)
+#define SWFRM_MINUS SWFRM_1(NSwitchType::kMinus)
+#define SWFRM_STRING SWFRM_1(NSwitchType::kString)
+
+#define SWFRM_STRING_SINGL(mi) SWFRM_3(NSwitchType::kString, false, mi)
+#define SWFRM_STRING_MULT(mi) SWFRM_3(NSwitchType::kString, true, mi)
+
+
+static const CSwitchForm kSwitchForms[] =
+{
+ { "?", SWFRM_SIMPLE },
+ { "h", SWFRM_SIMPLE },
+ { "-help", SWFRM_SIMPLE },
+
+ { "ba", SWFRM_SIMPLE },
+ { "bd", SWFRM_SIMPLE },
+ { "bt", SWFRM_SIMPLE },
+ { "bb", SWFRM_STRING_SINGL(0) },
+
+ { "bso", NSwitchType::kChar, false, 1, k_Stream_PostCharSet },
+ { "bse", NSwitchType::kChar, false, 1, k_Stream_PostCharSet },
+ { "bsp", NSwitchType::kChar, false, 1, k_Stream_PostCharSet },
+
+ { "y", SWFRM_SIMPLE },
+
+ { "ad", SWFRM_SIMPLE },
+ { "ao", NSwitchType::kChar, false, 1, kOverwritePostCharSet},
+
+ { "t", SWFRM_STRING_SINGL(1) },
+ { "stx", SWFRM_STRING_MULT(1) },
+
+ { "m", SWFRM_STRING_MULT(1) },
+ { "o", SWFRM_STRING_SINGL(1) },
+ { "w", SWFRM_STRING },
+
+ { "i", SWFRM_STRING_MULT(kSomeCludePostStringMinSize) },
+ { "x", SWFRM_STRING_MULT(kSomeCludePostStringMinSize) },
+ { "ai", SWFRM_STRING_MULT(kSomeCludePostStringMinSize) },
+ { "ax", SWFRM_STRING_MULT(kSomeCludePostStringMinSize) },
+ { "an", SWFRM_SIMPLE },
+
+ { "u", SWFRM_STRING_MULT(1) },
+ { "v", SWFRM_STRING_MULT(1) },
+ { "r", NSwitchType::kChar, false, 0, kRecursedPostCharSet },
+
+ { "stm", SWFRM_STRING },
+ { "sfx", SWFRM_STRING },
+ { "seml", SWFRM_STRING_SINGL(0) },
+ { "scrc", SWFRM_STRING_MULT(0) },
+ // { "scrf", SWFRM_STRING_SINGL(1) },
+ { "shd", SWFRM_STRING_SINGL(1) },
+
+ { "si", SWFRM_STRING },
+ { "so", SWFRM_SIMPLE },
+
+ { "slp", SWFRM_STRING },
+ { "scs", SWFRM_STRING },
+ { "scc", SWFRM_STRING },
+ { "slt", SWFRM_SIMPLE },
+ { "slf", SWFRM_STRING_SINGL(1) },
+
+ { "ssp", SWFRM_SIMPLE },
+ { "ssw", SWFRM_SIMPLE },
+ { "sse", SWFRM_SIMPLE },
+ { "ssc", SWFRM_MINUS },
+ { "sa", NSwitchType::kChar, false, 1, k_ArcNameMode_PostCharSet },
+
+ { "spm", SWFRM_STRING_SINGL(0) },
+ { "spd", SWFRM_SIMPLE },
+ { "spe", SWFRM_MINUS },
+ { "spf", SWFRM_STRING_SINGL(0) },
+
+ { "snh", SWFRM_MINUS },
+ { "snld", SWFRM_MINUS },
+ { "snl", SWFRM_MINUS },
+ { "sni", SWFRM_SIMPLE },
+
+ { "snoi", SWFRM_MINUS },
+ { "snon", SWFRM_MINUS },
+
+ { "snz", SWFRM_STRING_SINGL(0) },
+ { "sns", SWFRM_MINUS },
+ { "snr", SWFRM_SIMPLE },
+ { "snc", SWFRM_SIMPLE },
+
+ { "snt", SWFRM_MINUS },
+
+ { "sdel", SWFRM_SIMPLE },
+ { "stl", SWFRM_SIMPLE }
+
+ #ifndef Z7_NO_CRYPTO
+ , { "p", SWFRM_STRING }
+ #endif
+};
+
+static const char * const kUniversalWildcard = "*";
+static const unsigned kMinNonSwitchWords = 1;
+static const unsigned kCommandIndex = 0;
+
+// static const char * const kUserErrorMessage = "Incorrect command line";
+// static const char * const kCannotFindListFile = "Cannot find listfile";
+static const char * const kIncorrectListFile = "Incorrect item in listfile.\nCheck charset encoding and -scs switch.";
+static const char * const kTerminalOutError = "I won't write compressed data to a terminal";
+static const char * const kSameTerminalError = "I won't write data and program's messages to same stream";
+static const char * const kEmptyFilePath = "Empty file path";
+
+bool CArcCommand::IsFromExtractGroup() const
+{
+ switch ((int)CommandType)
+ {
+ case NCommandType::kTest:
+ case NCommandType::kExtract:
+ case NCommandType::kExtractFull:
+ return true;
+ default:
+ return false;
+ }
+}
+
+NExtract::NPathMode::EEnum CArcCommand::GetPathMode() const
+{
+ switch ((int)CommandType)
+ {
+ case NCommandType::kTest:
+ case NCommandType::kExtractFull:
+ return NExtract::NPathMode::kFullPaths;
+ default:
+ return NExtract::NPathMode::kNoPaths;
+ }
+}
+
+bool CArcCommand::IsFromUpdateGroup() const
+{
+ switch ((int)CommandType)
+ {
+ case NCommandType::kAdd:
+ case NCommandType::kUpdate:
+ case NCommandType::kDelete:
+ case NCommandType::kRename:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static NRecursedType::EEnum GetRecursedTypeFromIndex(int index)
+{
+ switch (index)
+ {
+ case NRecursedPostCharIndex::kWildcardRecursionOnly:
+ return NRecursedType::kWildcardOnlyRecursed;
+ case NRecursedPostCharIndex::kNoRecursion:
+ return NRecursedType::kNonRecursed;
+ default:
+ return NRecursedType::kRecursed;
+ }
+}
+
+static const char *g_Commands = "audtexlbih";
+
+static bool ParseArchiveCommand(const UString &commandString, CArcCommand &command)
+{
+ UString s (commandString);
+ s.MakeLower_Ascii();
+ if (s.Len() == 1)
+ {
+ if (s[0] > 0x7F)
+ return false;
+ int index = FindCharPosInString(g_Commands, (char)s[0]);
+ if (index < 0)
+ return false;
+ command.CommandType = (NCommandType::EEnum)index;
+ return true;
+ }
+ if (s.Len() == 2 && s[0] == 'r' && s[1] == 'n')
+ {
+ command.CommandType = (NCommandType::kRename);
+ return true;
+ }
+ return false;
+}
+
+// ------------------------------------------------------------------
+// filenames functions
+
+struct CNameOption
+{
+ bool Include;
+ bool WildcardMatching;
+ Byte MarkMode;
+ NRecursedType::EEnum RecursedType;
+
+ CNameOption():
+ Include(true),
+ WildcardMatching(true),
+ MarkMode(NWildcard::kMark_FileOrDir),
+ RecursedType(NRecursedType::kNonRecursed)
+ {}
+};
+
+
+static void AddNameToCensor(NWildcard::CCensor &censor,
+ const CNameOption &nop, const UString &name)
+{
+ bool recursed = false;
+
+ switch ((int)nop.RecursedType)
+ {
+ case NRecursedType::kWildcardOnlyRecursed:
+ recursed = DoesNameContainWildcard(name);
+ break;
+ case NRecursedType::kRecursed:
+ recursed = true;
+ break;
+ default:
+ break;
+ }
+
+ NWildcard::CCensorPathProps props;
+ props.Recursive = recursed;
+ props.WildcardMatching = nop.WildcardMatching;
+ props.MarkMode = nop.MarkMode;
+ censor.AddPreItem(nop.Include, name, props);
+}
+
+static void AddRenamePair(CObjectVector<CRenamePair> *renamePairs,
+ const UString &oldName, const UString &newName, NRecursedType::EEnum type,
+ bool wildcardMatching)
+{
+ CRenamePair &pair = renamePairs->AddNew();
+ pair.OldName = oldName;
+ pair.NewName = newName;
+ pair.RecursedType = type;
+ pair.WildcardParsing = wildcardMatching;
+
+ if (!pair.Prepare())
+ {
+ UString val;
+ val += pair.OldName;
+ val.Add_LF();
+ val += pair.NewName;
+ val.Add_LF();
+ if (type == NRecursedType::kRecursed)
+ val += "-r";
+ else if (type == NRecursedType::kWildcardOnlyRecursed)
+ val += "-r0";
+ throw CArcCmdLineException("Unsupported rename command:", val);
+ }
+}
+
+static void AddToCensorFromListFile(
+ CObjectVector<CRenamePair> *renamePairs,
+ NWildcard::CCensor &censor,
+ const CNameOption &nop, LPCWSTR fileName, UInt32 codePage)
+{
+ UStringVector names;
+ /*
+ if (!NFind::DoesFileExist_FollowLink(us2fs(fileName)))
+ throw CArcCmdLineException(kCannotFindListFile, fileName);
+ */
+ DWORD lastError = 0;
+ if (!ReadNamesFromListFile2(us2fs(fileName), names, codePage, lastError))
+ {
+ if (lastError != 0)
+ {
+ UString m;
+ m = "The file operation error for listfile";
+ m.Add_LF();
+ m += NError::MyFormatMessage(lastError);
+ throw CArcCmdLineException(m, fileName);
+ }
+ throw CArcCmdLineException(kIncorrectListFile, fileName);
+ }
+ if (renamePairs)
+ {
+ if ((names.Size() & 1) != 0)
+ throw CArcCmdLineException(kIncorrectListFile, fileName);
+ for (unsigned i = 0; i < names.Size(); i += 2)
+ {
+ // change type !!!!
+ AddRenamePair(renamePairs, names[i], names[i + 1], nop.RecursedType, nop.WildcardMatching);
+ }
+ }
+ else
+ FOR_VECTOR (i, names)
+ AddNameToCensor(censor, nop, names[i]);
+}
+
+static void AddToCensorFromNonSwitchesStrings(
+ CObjectVector<CRenamePair> *renamePairs,
+ unsigned startIndex,
+ NWildcard::CCensor &censor,
+ const UStringVector &nonSwitchStrings,
+ int stopSwitchIndex,
+ const CNameOption &nop,
+ bool thereAreSwitchIncludes, UInt32 codePage)
+{
+ // another default
+ if ((renamePairs || nonSwitchStrings.Size() == startIndex) && !thereAreSwitchIncludes)
+ {
+ /* for rename command: -i switch sets the mask for archive item reading.
+ if (thereAreSwitchIncludes), { we don't use UniversalWildcard. }
+ also for non-rename command: we set UniversalWildcard, only if there are no nonSwitches. */
+ // we use default fileds in (CNameOption) for UniversalWildcard.
+ CNameOption nop2;
+ // recursive mode is not important for UniversalWildcard (*)
+ // nop2.RecursedType = nop.RecursedType; // we don't need it
+ /*
+ nop2.RecursedType = NRecursedType::kNonRecursed;
+ nop2.Include = true;
+ nop2.WildcardMatching = true;
+ nop2.MarkMode = NWildcard::kMark_FileOrDir;
+ */
+ AddNameToCensor(censor, nop2, UString(kUniversalWildcard));
+ }
+
+ int oldIndex = -1;
+
+ if (stopSwitchIndex < 0)
+ stopSwitchIndex = (int)nonSwitchStrings.Size();
+
+ for (unsigned i = startIndex; i < nonSwitchStrings.Size(); i++)
+ {
+ const UString &s = nonSwitchStrings[i];
+ if (s.IsEmpty())
+ throw CArcCmdLineException(kEmptyFilePath);
+ if (i < (unsigned)stopSwitchIndex && s[0] == kFileListID)
+ AddToCensorFromListFile(renamePairs, censor, nop, s.Ptr(1), codePage);
+ else if (renamePairs)
+ {
+ if (oldIndex == -1)
+ oldIndex = (int)i;
+ else
+ {
+ // NRecursedType::EEnum type is used for global wildcard (-i! switches)
+ AddRenamePair(renamePairs, nonSwitchStrings[(unsigned)oldIndex], s, NRecursedType::kNonRecursed, nop.WildcardMatching);
+ // AddRenamePair(renamePairs, nonSwitchStrings[oldIndex], s, type);
+ oldIndex = -1;
+ }
+ }
+ else
+ AddNameToCensor(censor, nop, s);
+ }
+
+ if (oldIndex != -1)
+ {
+ throw CArcCmdLineException("There is no second file name for rename pair:", nonSwitchStrings[(unsigned)oldIndex]);
+ }
+}
+
+#ifdef _WIN32
+
+struct CEventSetEnd
+{
+ UString Name;
+
+ CEventSetEnd(const wchar_t *name): Name(name) {}
+ ~CEventSetEnd()
+ {
+ NSynchronization::CManualResetEvent event;
+ if (event.Open(EVENT_MODIFY_STATE, false, GetSystemString(Name)) == 0)
+ event.Set();
+ }
+};
+
+static const char * const k_IncorrectMapCommand = "Incorrect Map command";
+
+static const char *ParseMapWithPaths(
+ NWildcard::CCensor &censor,
+ const UString &s2,
+ const CNameOption &nop)
+{
+ UString s (s2);
+ int pos = s.Find(L':');
+ if (pos < 0)
+ return k_IncorrectMapCommand;
+ int pos2 = s.Find(L':', (unsigned)(pos + 1));
+ if (pos2 < 0)
+ return k_IncorrectMapCommand;
+
+ CEventSetEnd eventSetEnd((const wchar_t *)s + (unsigned)(pos2 + 1));
+ s.DeleteFrom((unsigned)pos2);
+ UInt32 size;
+ if (!StringToUInt32(s.Ptr((unsigned)(pos + 1)), size)
+ || size < sizeof(wchar_t)
+ || size > ((UInt32)1 << 31)
+ || size % sizeof(wchar_t) != 0)
+ return "Unsupported Map data size";
+
+ s.DeleteFrom((unsigned)pos);
+ CFileMapping map;
+ if (map.Open(FILE_MAP_READ, GetSystemString(s)) != 0)
+ return "Cannot open mapping";
+ LPVOID data = map.Map(FILE_MAP_READ, 0, size);
+ if (!data)
+ return "MapViewOfFile error";
+ CFileUnmapper unmapper(data);
+
+ UString name;
+ const wchar_t *p = (const wchar_t *)data;
+ if (*p != 0) // data format marker
+ return "Unsupported Map data";
+ UInt32 numChars = size / sizeof(wchar_t);
+ for (UInt32 i = 1; i < numChars; i++)
+ {
+ wchar_t c = p[i];
+ if (c == 0)
+ {
+ // MessageBoxW(0, name, L"7-Zip", 0);
+ AddNameToCensor(censor, nop, name);
+ name.Empty();
+ }
+ else
+ name += c;
+ }
+ if (!name.IsEmpty())
+ return "Map data error";
+
+ return NULL;
+}
+
+#endif
+
+static void AddSwitchWildcardsToCensor(
+ NWildcard::CCensor &censor,
+ const UStringVector &strings,
+ const CNameOption &nop,
+ UInt32 codePage)
+{
+ const char *errorMessage = NULL;
+ unsigned i;
+ for (i = 0; i < strings.Size(); i++)
+ {
+ const UString &name = strings[i];
+ unsigned pos = 0;
+
+ if (name.Len() < kSomeCludePostStringMinSize)
+ {
+ errorMessage = "Too short switch";
+ break;
+ }
+
+ if (!nop.Include)
+ {
+ if (name.IsEqualTo_Ascii_NoCase("td"))
+ {
+ censor.ExcludeDirItems = true;
+ continue;
+ }
+ if (name.IsEqualTo_Ascii_NoCase("tf"))
+ {
+ censor.ExcludeFileItems = true;
+ continue;
+ }
+ }
+
+ CNameOption nop2 = nop;
+
+ bool type_WasUsed = false;
+ bool recursed_WasUsed = false;
+ bool matching_WasUsed = false;
+ bool error = false;
+
+ for (;;)
+ {
+ wchar_t c = ::MyCharLower_Ascii(name[pos]);
+ if (c == kRecursedIDChar)
+ {
+ if (recursed_WasUsed)
+ {
+ error = true;
+ break;
+ }
+ recursed_WasUsed = true;
+ pos++;
+ c = name[pos];
+ int index = -1;
+ if (c <= 0x7F)
+ index = FindCharPosInString(kRecursedPostCharSet, (char)c);
+ nop2.RecursedType = GetRecursedTypeFromIndex(index);
+ if (index >= 0)
+ {
+ pos++;
+ continue;
+ }
+ }
+
+ if (c == 'w')
+ {
+ if (matching_WasUsed)
+ {
+ error = true;
+ break;
+ }
+ matching_WasUsed = true;
+ nop2.WildcardMatching = true;
+ pos++;
+ if (name[pos] == '-')
+ {
+ nop2.WildcardMatching = false;
+ pos++;
+ }
+ }
+ else if (c == 'm')
+ {
+ if (type_WasUsed)
+ {
+ error = true;
+ break;
+ }
+ type_WasUsed = true;
+ pos++;
+ nop2.MarkMode = NWildcard::kMark_StrictFile;
+ c = name[pos];
+ if (c == '-')
+ {
+ nop2.MarkMode = NWildcard::kMark_FileOrDir;
+ pos++;
+ }
+ else if (c == '2')
+ {
+ nop2.MarkMode = NWildcard::kMark_StrictFile_IfWildcard;
+ pos++;
+ }
+ }
+ else
+ break;
+ }
+
+ if (error)
+ {
+ errorMessage = "inorrect switch";
+ break;
+ }
+
+ if (name.Len() < pos + kSomeCludeAfterRecursedPostStringMinSize)
+ {
+ errorMessage = "Too short switch";
+ break;
+ }
+
+ const UString tail = name.Ptr(pos + 1);
+
+ const wchar_t c = name[pos];
+
+ if (c == kImmediateNameID)
+ AddNameToCensor(censor, nop2, tail);
+ else if (c == kFileListID)
+ AddToCensorFromListFile(NULL, censor, nop2, tail, codePage);
+ #ifdef _WIN32
+ else if (c == kMapNameID)
+ {
+ errorMessage = ParseMapWithPaths(censor, tail, nop2);
+ if (errorMessage)
+ break;
+ }
+ #endif
+ else
+ {
+ errorMessage = "Incorrect wildcard type marker";
+ break;
+ }
+ }
+
+ if (i != strings.Size())
+ throw CArcCmdLineException(errorMessage, strings[i]);
+}
+
+/*
+static NUpdateArchive::NPairAction::EEnum GetUpdatePairActionType(int i)
+{
+ switch (i)
+ {
+ case NUpdateArchive::NPairAction::kIgnore: return NUpdateArchive::NPairAction::kIgnore;
+ case NUpdateArchive::NPairAction::kCopy: return NUpdateArchive::NPairAction::kCopy;
+ case NUpdateArchive::NPairAction::kCompress: return NUpdateArchive::NPairAction::kCompress;
+ case NUpdateArchive::NPairAction::kCompressAsAnti: return NUpdateArchive::NPairAction::kCompressAsAnti;
+ }
+ throw 98111603;
+}
+*/
+
+static const char * const kUpdatePairStateIDSet = "pqrxyzw";
+static const int kUpdatePairStateNotSupportedActions[] = {2, 2, 1, -1, -1, -1, -1};
+
+static const unsigned kNumUpdatePairActions = 4;
+static const char * const kUpdateIgnoreItselfPostStringID = "-";
+static const wchar_t kUpdateNewArchivePostCharID = '!';
+
+
+static bool ParseUpdateCommandString2(const UString &command,
+ NUpdateArchive::CActionSet &actionSet, UString &postString)
+{
+ for (unsigned i = 0; i < command.Len();)
+ {
+ wchar_t c = MyCharLower_Ascii(command[i]);
+ int statePos = FindCharPosInString(kUpdatePairStateIDSet, (char)c);
+ if (c > 0x7F || statePos < 0)
+ {
+ postString = command.Ptr(i);
+ return true;
+ }
+ i++;
+ if (i >= command.Len())
+ return false;
+ c = command[i];
+ if (c < '0' || c >= (wchar_t)('0' + kNumUpdatePairActions))
+ return false;
+ unsigned actionPos = (unsigned)(c - '0');
+ actionSet.StateActions[(unsigned)statePos] = (NUpdateArchive::NPairAction::EEnum)(actionPos);
+ if (kUpdatePairStateNotSupportedActions[(unsigned)statePos] == (int)actionPos)
+ return false;
+ i++;
+ }
+ postString.Empty();
+ return true;
+}
+
+static void ParseUpdateCommandString(CUpdateOptions &options,
+ const UStringVector &updatePostStrings,
+ const NUpdateArchive::CActionSet &defaultActionSet)
+{
+ const char *errorMessage = "incorrect update switch command";
+ unsigned i;
+ for (i = 0; i < updatePostStrings.Size(); i++)
+ {
+ const UString &updateString = updatePostStrings[i];
+ if (updateString.IsEqualTo(kUpdateIgnoreItselfPostStringID))
+ {
+ if (options.UpdateArchiveItself)
+ {
+ options.UpdateArchiveItself = false;
+ options.Commands.Delete(0);
+ }
+ }
+ else
+ {
+ NUpdateArchive::CActionSet actionSet = defaultActionSet;
+
+ UString postString;
+ if (!ParseUpdateCommandString2(updateString, actionSet, postString))
+ break;
+ if (postString.IsEmpty())
+ {
+ if (options.UpdateArchiveItself)
+ options.Commands[0].ActionSet = actionSet;
+ }
+ else
+ {
+ if (postString[0] != kUpdateNewArchivePostCharID)
+ break;
+ CUpdateArchiveCommand uc;
+ UString archivePath = postString.Ptr(1);
+ if (archivePath.IsEmpty())
+ break;
+ uc.UserArchivePath = archivePath;
+ uc.ActionSet = actionSet;
+ options.Commands.Add(uc);
+ }
+ }
+ }
+ if (i != updatePostStrings.Size())
+ throw CArcCmdLineException(errorMessage, updatePostStrings[i]);
+}
+
+bool ParseComplexSize(const wchar_t *s, UInt64 &result);
+
+static void SetAddCommandOptions(
+ NCommandType::EEnum commandType,
+ const CParser &parser,
+ CUpdateOptions &options)
+{
+ NUpdateArchive::CActionSet defaultActionSet;
+ switch ((int)commandType)
+ {
+ case NCommandType::kAdd:
+ defaultActionSet = NUpdateArchive::k_ActionSet_Add;
+ break;
+ case NCommandType::kDelete:
+ defaultActionSet = NUpdateArchive::k_ActionSet_Delete;
+ break;
+ default:
+ defaultActionSet = NUpdateArchive::k_ActionSet_Update;
+ }
+
+ options.UpdateArchiveItself = true;
+
+ options.Commands.Clear();
+ CUpdateArchiveCommand updateMainCommand;
+ updateMainCommand.ActionSet = defaultActionSet;
+ options.Commands.Add(updateMainCommand);
+ if (parser[NKey::kUpdate].ThereIs)
+ ParseUpdateCommandString(options, parser[NKey::kUpdate].PostStrings,
+ defaultActionSet);
+ if (parser[NKey::kWorkingDir].ThereIs)
+ {
+ const UString &postString = parser[NKey::kWorkingDir].PostStrings[0];
+ if (postString.IsEmpty())
+ NDir::MyGetTempPath(options.WorkingDir);
+ else
+ options.WorkingDir = us2fs(postString);
+ }
+ options.SfxMode = parser[NKey::kSfx].ThereIs;
+ if (options.SfxMode)
+ options.SfxModule = us2fs(parser[NKey::kSfx].PostStrings[0]);
+
+ if (parser[NKey::kVolume].ThereIs)
+ {
+ const UStringVector &sv = parser[NKey::kVolume].PostStrings;
+ FOR_VECTOR (i, sv)
+ {
+ UInt64 size;
+ if (!ParseComplexSize(sv[i], size))
+ throw CArcCmdLineException("Incorrect volume size:", sv[i]);
+ if (i == sv.Size() - 1 && size == 0)
+ throw CArcCmdLineException("zero size last volume is not allowed");
+ options.VolumesSizes.Add(size);
+ }
+ }
+}
+
+static void SetMethodOptions(const CParser &parser, CObjectVector<CProperty> &properties)
+{
+ if (parser[NKey::kProperty].ThereIs)
+ {
+ FOR_VECTOR (i, parser[NKey::kProperty].PostStrings)
+ {
+ CProperty prop;
+ prop.Name = parser[NKey::kProperty].PostStrings[i];
+ int index = prop.Name.Find(L'=');
+ if (index >= 0)
+ {
+ prop.Value = prop.Name.Ptr((unsigned)(index + 1));
+ prop.Name.DeleteFrom((unsigned)index);
+ }
+ properties.Add(prop);
+ }
+ }
+}
+
+
+static inline void SetStreamMode(const CSwitchResult &sw, unsigned &res)
+{
+ if (sw.ThereIs)
+ res = (unsigned)sw.PostCharIndex;
+}
+
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+static void PrintHex(UString &s, UInt64 v)
+{
+ char temp[32];
+ ConvertUInt64ToHex(v, temp);
+ s += temp;
+}
+#endif
+
+
+void CArcCmdLineParser::Parse1(const UStringVector &commandStrings,
+ CArcCmdLineOptions &options)
+{
+ Parse1Log.Empty();
+ if (!parser.ParseStrings(kSwitchForms, Z7_ARRAY_SIZE(kSwitchForms), commandStrings))
+ throw CArcCmdLineException(parser.ErrorMessage, parser.ErrorLine);
+
+ options.IsInTerminal = MY_IS_TERMINAL(stdin);
+ options.IsStdOutTerminal = MY_IS_TERMINAL(stdout);
+ options.IsStdErrTerminal = MY_IS_TERMINAL(stderr);
+
+ options.HelpMode = parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs || parser[NKey::kHelp3].ThereIs;
+
+ options.StdInMode = parser[NKey::kStdIn].ThereIs;
+ options.StdOutMode = parser[NKey::kStdOut].ThereIs;
+ options.EnableHeaders = !parser[NKey::kDisableHeaders].ThereIs;
+ if (parser[NKey::kListFields].ThereIs)
+ {
+ const UString &s = parser[NKey::kListFields].PostStrings[0];
+ options.ListFields = GetAnsiString(s);
+ }
+ options.TechMode = parser[NKey::kTechMode].ThereIs;
+ options.ShowTime = parser[NKey::kShowTime].ThereIs;
+
+ if (parser[NKey::kDisablePercents].ThereIs
+ || options.StdOutMode
+ || !options.IsStdOutTerminal)
+ options.Number_for_Percents = k_OutStream_disabled;
+
+ if (options.StdOutMode)
+ options.Number_for_Out = k_OutStream_disabled;
+
+ SetStreamMode(parser[NKey::kOutStream], options.Number_for_Out);
+ SetStreamMode(parser[NKey::kErrStream], options.Number_for_Errors);
+ SetStreamMode(parser[NKey::kPercentStream], options.Number_for_Percents);
+
+ if (parser[NKey::kLogLevel].ThereIs)
+ {
+ const UString &s = parser[NKey::kLogLevel].PostStrings[0];
+ if (s.IsEmpty())
+ options.LogLevel = 1;
+ else
+ {
+ UInt32 v;
+ if (!StringToUInt32(s, v))
+ throw CArcCmdLineException("Unsupported switch postfix -bb", s);
+ options.LogLevel = (unsigned)v;
+ }
+ }
+
+ if (parser[NKey::kCaseSensitive].ThereIs)
+ {
+ options.CaseSensitive =
+ g_CaseSensitive = !parser[NKey::kCaseSensitive].WithMinus;
+ options.CaseSensitive_Change = true;
+ }
+
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ NSecurity::EnablePrivilege_SymLink();
+ #endif
+
+ // options.LargePages = false;
+
+ if (parser[NKey::kLargePages].ThereIs)
+ {
+ UInt32 slp = 0;
+ const UString &s = parser[NKey::kLargePages].PostStrings[0];
+ if (s.IsEmpty())
+ slp = 1;
+ else if (s != L"-")
+ {
+ if (!StringToUInt32(s, slp))
+ throw CArcCmdLineException("Unsupported switch postfix for -slp", s);
+ }
+
+ #ifdef Z7_LARGE_PAGES
+ if (slp >
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ (unsigned)NSecurity::Get_LargePages_RiskLevel()
+ #else
+ 0
+ #endif
+ )
+ {
+ #ifdef _WIN32 // change it !
+ SetLargePageSize();
+ #endif
+ // note: this process also can inherit that Privilege from parent process
+ g_LargePagesMode =
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ NSecurity::EnablePrivilege_LockMemory();
+ #else
+ true;
+ #endif
+ }
+ #endif
+ }
+
+
+ #ifndef UNDER_CE
+
+ if (parser[NKey::kAffinity].ThereIs)
+ {
+ const UString &s = parser[NKey::kAffinity].PostStrings[0];
+ if (!s.IsEmpty())
+ {
+ AString a;
+ a.SetFromWStr_if_Ascii(s);
+ Parse1Log += "Set process affinity mask: ";
+
+ #ifdef _WIN32
+
+ UInt64 v = 0;
+ {
+ const char *end;
+ v = ConvertHexStringToUInt64(a, &end);
+ if (*end != 0)
+ a.Empty();
+ }
+ if (a.IsEmpty())
+ throw CArcCmdLineException("Unsupported switch postfix -stm", s);
+
+ {
+ #ifndef _WIN64
+ if (v >= ((UInt64)1 << 32))
+ throw CArcCmdLineException("unsupported value -stm", s);
+ #endif
+ {
+ PrintHex(Parse1Log, v);
+ if (!SetProcessAffinityMask(GetCurrentProcess(), (DWORD_PTR)v))
+ {
+ DWORD lastError = GetLastError();
+ Parse1Log += " : ERROR : ";
+ Parse1Log += NError::MyFormatMessage(lastError);
+ }
+ }
+ }
+
+ #else // _WIN32
+
+ {
+ Parse1Log += a;
+ NSystem::CProcessAffinity aff;
+ aff.CpuZero();
+ for (unsigned i = 0; i < a.Len(); i++)
+ {
+ char c = a[i];
+ unsigned v;
+ if (c >= '0' && c <= '9') v = (unsigned)(c - '0');
+ else if (c >= 'A' && c <= 'F') v = 10 + (unsigned)(c - 'A');
+ else if (c >= 'a' && c <= 'f') v = 10 + (unsigned)(c - 'a');
+ else
+ throw CArcCmdLineException("Unsupported switch postfix -stm", s);
+ for (unsigned k = 0; k < 4; k++)
+ {
+ const unsigned cpu = (a.Len() - 1 - i) * 4 + k;
+ if (v & ((unsigned)1 << k))
+ aff.CpuSet(cpu);
+ }
+ }
+
+ if (!aff.SetProcAffinity())
+ {
+ DWORD lastError = GetLastError();
+ Parse1Log += " : ERROR : ";
+ Parse1Log += NError::MyFormatMessage(lastError);
+ }
+ }
+ #endif // _WIN32
+
+ Parse1Log.Add_LF();
+ }
+ }
+
+ #endif
+}
+
+
+
+struct CCodePagePair
+{
+ const char *Name;
+ UInt32 CodePage;
+};
+
+static const unsigned kNumByteOnlyCodePages = 3;
+
+static const CCodePagePair g_CodePagePairs[] =
+{
+ { "utf-8", CP_UTF8 },
+ { "win", CP_ACP },
+ { "dos", CP_OEMCP },
+ { "utf-16le", Z7_WIN_CP_UTF16 },
+ { "utf-16be", Z7_WIN_CP_UTF16BE }
+};
+
+static Int32 FindCharset(const NCommandLineParser::CParser &parser, unsigned keyIndex,
+ bool byteOnlyCodePages, Int32 defaultVal)
+{
+ if (!parser[keyIndex].ThereIs)
+ return defaultVal;
+
+ UString name (parser[keyIndex].PostStrings.Back());
+ UInt32 v;
+ if (StringToUInt32(name, v))
+ if (v < ((UInt32)1 << 16))
+ return (Int32)v;
+ name.MakeLower_Ascii();
+ const unsigned num = byteOnlyCodePages ? kNumByteOnlyCodePages : Z7_ARRAY_SIZE(g_CodePagePairs);
+ for (unsigned i = 0;; i++)
+ {
+ if (i == num) // to disable warnings from different compilers
+ throw CArcCmdLineException("Unsupported charset:", name);
+ const CCodePagePair &pair = g_CodePagePairs[i];
+ if (name.IsEqualTo(pair.Name))
+ return (Int32)pair.CodePage;
+ }
+}
+
+
+static void SetBoolPair(NCommandLineParser::CParser &parser, unsigned switchID, CBoolPair &bp)
+{
+ bp.Def = parser[switchID].ThereIs;
+ if (bp.Def)
+ bp.Val = !parser[switchID].WithMinus;
+}
+
+void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)
+{
+ const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
+ const unsigned numNonSwitchStrings = nonSwitchStrings.Size();
+ if (numNonSwitchStrings < kMinNonSwitchWords)
+ throw CArcCmdLineException("The command must be specified");
+
+ if (!ParseArchiveCommand(nonSwitchStrings[kCommandIndex], options.Command))
+ throw CArcCmdLineException("Unsupported command:", nonSwitchStrings[kCommandIndex]);
+
+ if (parser[NKey::kHash].ThereIs)
+ options.HashMethods = parser[NKey::kHash].PostStrings;
+
+ /*
+ if (parser[NKey::kHashGenFile].ThereIs)
+ {
+ const UString &s = parser[NKey::kHashGenFile].PostStrings[0];
+ for (unsigned i = 0 ; i < s.Len();)
+ {
+ const wchar_t c = s[i++];
+ if (!options.HashOptions.ParseFlagCharOption(c, true))
+ {
+ if (c != '=')
+ throw CArcCmdLineException("Unsupported hash mode switch:", s);
+ options.HashOptions.HashFilePath = s.Ptr(i);
+ break;
+ }
+ }
+ }
+ */
+
+ if (parser[NKey::kHashDir].ThereIs)
+ options.ExtractOptions.HashDir = parser[NKey::kHashDir].PostStrings[0];
+
+ if (parser[NKey::kElimDup].ThereIs)
+ {
+ options.ExtractOptions.ElimDup.Def = true;
+ options.ExtractOptions.ElimDup.Val = !parser[NKey::kElimDup].WithMinus;
+ }
+
+ NWildcard::ECensorPathMode censorPathMode = NWildcard::k_RelatPath;
+ bool fullPathMode = parser[NKey::kFullPathMode].ThereIs;
+ if (fullPathMode)
+ {
+ censorPathMode = NWildcard::k_AbsPath;
+ const UString &s = parser[NKey::kFullPathMode].PostStrings[0];
+ if (!s.IsEmpty())
+ {
+ if (s == L"2")
+ censorPathMode = NWildcard::k_FullPath;
+ else
+ throw CArcCmdLineException("Unsupported -spf:", s);
+ }
+ }
+
+ if (parser[NKey::kNameTrailReplace].ThereIs)
+ g_PathTrailReplaceMode = !parser[NKey::kNameTrailReplace].WithMinus;
+
+ CNameOption nop;
+
+ if (parser[NKey::kRecursed].ThereIs)
+ nop.RecursedType = GetRecursedTypeFromIndex(parser[NKey::kRecursed].PostCharIndex);
+
+ if (parser[NKey::kDisableWildcardParsing].ThereIs)
+ nop.WildcardMatching = false;
+
+ if (parser[NKey::kUseSlashMark].ThereIs)
+ {
+ const UString &s = parser[NKey::kUseSlashMark].PostStrings[0];
+ if (s.IsEmpty())
+ nop.MarkMode = NWildcard::kMark_StrictFile;
+ else if (s.IsEqualTo_Ascii_NoCase("-"))
+ nop.MarkMode = NWildcard::kMark_FileOrDir;
+ else if (s.IsEqualTo_Ascii_NoCase("2"))
+ nop.MarkMode = NWildcard::kMark_StrictFile_IfWildcard;
+ else
+ throw CArcCmdLineException("Unsupported -spm:", s);
+ }
+
+
+ options.ConsoleCodePage = FindCharset(parser, NKey::kConsoleCharSet, true, -1);
+
+ UInt32 codePage = (UInt32)FindCharset(parser, NKey::kListfileCharSet, false, CP_UTF8);
+
+ bool thereAreSwitchIncludes = false;
+
+ if (parser[NKey::kInclude].ThereIs)
+ {
+ thereAreSwitchIncludes = true;
+ nop.Include = true;
+ AddSwitchWildcardsToCensor(options.Censor,
+ parser[NKey::kInclude].PostStrings, nop, codePage);
+ }
+
+ if (parser[NKey::kExclude].ThereIs)
+ {
+ nop.Include = false;
+ AddSwitchWildcardsToCensor(options.Censor,
+ parser[NKey::kExclude].PostStrings, nop, codePage);
+ }
+
+ unsigned curCommandIndex = kCommandIndex + 1;
+ bool thereIsArchiveName = !parser[NKey::kNoArName].ThereIs &&
+ options.Command.CommandType != NCommandType::kBenchmark &&
+ options.Command.CommandType != NCommandType::kInfo &&
+ options.Command.CommandType != NCommandType::kHash;
+
+ const bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
+ const bool isExtractOrList = isExtractGroupCommand || options.Command.CommandType == NCommandType::kList;
+ const bool isRename = options.Command.CommandType == NCommandType::kRename;
+
+ if ((isExtractOrList || isRename) && options.StdInMode)
+ thereIsArchiveName = false;
+
+ if (parser[NKey::kArcNameMode].ThereIs)
+ options.UpdateOptions.ArcNameMode = ParseArcNameMode(parser[NKey::kArcNameMode].PostCharIndex);
+
+ if (thereIsArchiveName)
+ {
+ if (curCommandIndex >= numNonSwitchStrings)
+ throw CArcCmdLineException("Cannot find archive name");
+ options.ArchiveName = nonSwitchStrings[curCommandIndex++];
+ if (options.ArchiveName.IsEmpty())
+ throw CArcCmdLineException("Archive name cannot by empty");
+ #ifdef _WIN32
+ // options.ArchiveName.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+ }
+
+ nop.Include = true;
+ AddToCensorFromNonSwitchesStrings(isRename ? &options.UpdateOptions.RenamePairs : NULL,
+ curCommandIndex, options.Censor,
+ nonSwitchStrings, parser.StopSwitchIndex,
+ nop,
+ thereAreSwitchIncludes, codePage);
+
+ options.YesToAll = parser[NKey::kYes].ThereIs;
+
+
+ #ifndef Z7_NO_CRYPTO
+ options.PasswordEnabled = parser[NKey::kPassword].ThereIs;
+ if (options.PasswordEnabled)
+ options.Password = parser[NKey::kPassword].PostStrings[0];
+ #endif
+
+ options.ShowDialog = parser[NKey::kShowDialog].ThereIs;
+
+ if (parser[NKey::kArchiveType].ThereIs)
+ options.ArcType = parser[NKey::kArchiveType].PostStrings[0];
+
+ options.ExcludedArcTypes = parser[NKey::kExcludedArcType].PostStrings;
+
+ SetMethodOptions(parser, options.Properties);
+
+ if (parser[NKey::kNtSecurity].ThereIs) options.NtSecurity.SetTrueTrue();
+
+ SetBoolPair(parser, NKey::kAltStreams, options.AltStreams);
+ SetBoolPair(parser, NKey::kHardLinks, options.HardLinks);
+ SetBoolPair(parser, NKey::kSymLinks, options.SymLinks);
+
+ SetBoolPair(parser, NKey::kStoreOwnerId, options.StoreOwnerId);
+ SetBoolPair(parser, NKey::kStoreOwnerName, options.StoreOwnerName);
+
+ CBoolPair symLinks_AllowDangerous;
+ SetBoolPair(parser, NKey::kSymLinks_AllowDangerous, symLinks_AllowDangerous);
+
+
+ /*
+ bool supportSymLink = options.SymLinks.Val;
+
+ if (!options.SymLinks.Def)
+ {
+ if (isExtractOrList)
+ supportSymLink = true;
+ else
+ supportSymLink = false;
+ }
+
+ #ifdef ENV_HAVE_LSTAT
+ if (supportSymLink)
+ global_use_lstat = 1;
+ else
+ global_use_lstat = 0;
+ #endif
+ */
+
+
+ if (isExtractOrList)
+ {
+ CExtractOptionsBase &eo = options.ExtractOptions;
+
+ eo.ExcludeDirItems = options.Censor.ExcludeDirItems;
+ eo.ExcludeFileItems = options.Censor.ExcludeFileItems;
+
+ {
+ CExtractNtOptions &nt = eo.NtOptions;
+ nt.NtSecurity = options.NtSecurity;
+
+ nt.AltStreams = options.AltStreams;
+ if (!options.AltStreams.Def)
+ nt.AltStreams.Val = true;
+
+ nt.HardLinks = options.HardLinks;
+ if (!options.HardLinks.Def)
+ nt.HardLinks.Val = true;
+
+ nt.SymLinks = options.SymLinks;
+ if (!options.SymLinks.Def)
+ nt.SymLinks.Val = true;
+
+ nt.SymLinks_AllowDangerous = symLinks_AllowDangerous;
+
+ nt.ReplaceColonForAltStream = parser[NKey::kReplaceColonForAltStream].ThereIs;
+ nt.WriteToAltStreamIfColon = parser[NKey::kWriteToAltStreamIfColon].ThereIs;
+
+ nt.ExtractOwner = options.StoreOwnerId.Val; // StoreOwnerName
+
+ if (parser[NKey::kPreserveATime].ThereIs)
+ nt.PreserveATime = true;
+ if (parser[NKey::kShareForWrite].ThereIs)
+ nt.OpenShareForWrite = true;
+ }
+
+ if (parser[NKey::kZoneFile].ThereIs)
+ {
+ eo.ZoneMode = NExtract::NZoneIdMode::kAll;
+ const UString &s = parser[NKey::kZoneFile].PostStrings[0];
+ if (!s.IsEmpty())
+ {
+ if (s == L"0") eo.ZoneMode = NExtract::NZoneIdMode::kNone;
+ else if (s == L"1") eo.ZoneMode = NExtract::NZoneIdMode::kAll;
+ else if (s == L"2") eo.ZoneMode = NExtract::NZoneIdMode::kOffice;
+ else
+ throw CArcCmdLineException("Unsupported -snz:", s);
+ }
+ }
+
+ options.Censor.AddPathsToCensor(NWildcard::k_AbsPath);
+ options.Censor.ExtendExclude();
+
+ // are there paths that look as non-relative (!Prefix.IsEmpty())
+ if (!options.Censor.AllAreRelative())
+ throw CArcCmdLineException("Cannot use absolute pathnames for this command");
+
+ NWildcard::CCensor &arcCensor = options.arcCensor;
+
+ CNameOption nopArc;
+ // nopArc.RecursedType = NRecursedType::kNonRecursed; // default: we don't want recursing for archives, if -r specified
+ // is it OK, external switches can disable WildcardMatching and MarcMode for arc.
+ nopArc.WildcardMatching = nop.WildcardMatching;
+ nopArc.MarkMode = nop.MarkMode;
+
+ if (parser[NKey::kArInclude].ThereIs)
+ {
+ nopArc.Include = true;
+ AddSwitchWildcardsToCensor(arcCensor, parser[NKey::kArInclude].PostStrings, nopArc, codePage);
+ }
+ if (parser[NKey::kArExclude].ThereIs)
+ {
+ nopArc.Include = false;
+ AddSwitchWildcardsToCensor(arcCensor, parser[NKey::kArExclude].PostStrings, nopArc, codePage);
+ }
+
+ if (thereIsArchiveName)
+ {
+ nopArc.Include = true;
+ AddNameToCensor(arcCensor, nopArc, options.ArchiveName);
+ }
+
+ arcCensor.AddPathsToCensor(NWildcard::k_RelatPath);
+
+ #ifdef _WIN32
+ ConvertToLongNames(arcCensor);
+ #endif
+
+ arcCensor.ExtendExclude();
+
+ if (options.StdInMode)
+ options.ArcName_for_StdInMode = parser[NKey::kStdIn].PostStrings.Front();
+
+ if (isExtractGroupCommand)
+ {
+ if (options.StdOutMode)
+ {
+ if (
+ options.Number_for_Percents == k_OutStream_stdout
+ // || options.Number_for_Out == k_OutStream_stdout
+ // || options.Number_for_Errors == k_OutStream_stdout
+ ||
+ (
+ (options.IsStdOutTerminal && options.IsStdErrTerminal)
+ &&
+ (
+ options.Number_for_Percents != k_OutStream_disabled
+ // || options.Number_for_Out != k_OutStream_disabled
+ // || options.Number_for_Errors != k_OutStream_disabled
+ )
+ )
+ )
+ throw CArcCmdLineException(kSameTerminalError);
+ }
+
+ if (parser[NKey::kOutputDir].ThereIs)
+ {
+ eo.OutputDir = us2fs(parser[NKey::kOutputDir].PostStrings[0]);
+ #ifdef _WIN32
+ NFile::NName::NormalizeDirSeparators(eo.OutputDir);
+ #endif
+ NFile::NName::NormalizeDirPathPrefix(eo.OutputDir);
+ }
+
+ eo.OverwriteMode = NExtract::NOverwriteMode::kAsk;
+ if (parser[NKey::kOverwrite].ThereIs)
+ {
+ eo.OverwriteMode = k_OverwriteModes[(unsigned)parser[NKey::kOverwrite].PostCharIndex];
+ eo.OverwriteMode_Force = true;
+ }
+ else if (options.YesToAll)
+ {
+ eo.OverwriteMode = NExtract::NOverwriteMode::kOverwrite;
+ eo.OverwriteMode_Force = true;
+ }
+ }
+
+ eo.PathMode = options.Command.GetPathMode();
+ if (censorPathMode == NWildcard::k_AbsPath)
+ {
+ eo.PathMode = NExtract::NPathMode::kAbsPaths;
+ eo.PathMode_Force = true;
+ }
+ else if (censorPathMode == NWildcard::k_FullPath)
+ {
+ eo.PathMode = NExtract::NPathMode::kFullPaths;
+ eo.PathMode_Force = true;
+ }
+ }
+ else if (options.Command.IsFromUpdateGroup())
+ {
+ if (parser[NKey::kArInclude].ThereIs)
+ throw CArcCmdLineException("-ai switch is not supported for this command");
+
+ CUpdateOptions &updateOptions = options.UpdateOptions;
+
+ SetAddCommandOptions(options.Command.CommandType, parser, updateOptions);
+
+ updateOptions.MethodMode.Properties = options.Properties;
+
+ if (parser[NKey::kPreserveATime].ThereIs)
+ updateOptions.PreserveATime = true;
+ if (parser[NKey::kShareForWrite].ThereIs)
+ updateOptions.OpenShareForWrite = true;
+ if (parser[NKey::kStopAfterOpenError].ThereIs)
+ updateOptions.StopAfterOpenError = true;
+
+ updateOptions.PathMode = censorPathMode;
+
+ updateOptions.AltStreams = options.AltStreams;
+ updateOptions.NtSecurity = options.NtSecurity;
+ updateOptions.HardLinks = options.HardLinks;
+ updateOptions.SymLinks = options.SymLinks;
+
+ updateOptions.StoreOwnerId = options.StoreOwnerId;
+ updateOptions.StoreOwnerName = options.StoreOwnerName;
+
+ updateOptions.EMailMode = parser[NKey::kEmail].ThereIs;
+ if (updateOptions.EMailMode)
+ {
+ updateOptions.EMailAddress = parser[NKey::kEmail].PostStrings.Front();
+ if (updateOptions.EMailAddress.Len() > 0)
+ if (updateOptions.EMailAddress[0] == L'.')
+ {
+ updateOptions.EMailRemoveAfter = true;
+ updateOptions.EMailAddress.Delete(0);
+ }
+ }
+
+ updateOptions.StdOutMode = options.StdOutMode;
+ updateOptions.StdInMode = options.StdInMode;
+
+ updateOptions.DeleteAfterCompressing = parser[NKey::kDeleteAfterCompressing].ThereIs;
+ updateOptions.SetArcMTime = parser[NKey::kSetArcMTime].ThereIs;
+
+ if (updateOptions.StdOutMode && updateOptions.EMailMode)
+ throw CArcCmdLineException("stdout mode and email mode cannot be combined");
+
+ if (updateOptions.StdOutMode)
+ {
+ if (options.IsStdOutTerminal)
+ throw CArcCmdLineException(kTerminalOutError);
+
+ if (options.Number_for_Percents == k_OutStream_stdout
+ || options.Number_for_Out == k_OutStream_stdout
+ || options.Number_for_Errors == k_OutStream_stdout)
+ throw CArcCmdLineException(kSameTerminalError);
+ }
+
+ if (updateOptions.StdInMode)
+ updateOptions.StdInFileName = parser[NKey::kStdIn].PostStrings.Front();
+
+ if (options.Command.CommandType == NCommandType::kRename)
+ if (updateOptions.Commands.Size() != 1)
+ throw CArcCmdLineException("Only one archive can be created with rename command");
+ }
+ else if (options.Command.CommandType == NCommandType::kBenchmark)
+ {
+ options.NumIterations = 1;
+ options.NumIterations_Defined = false;
+ if (curCommandIndex < numNonSwitchStrings)
+ {
+ if (!StringToUInt32(nonSwitchStrings[curCommandIndex], options.NumIterations))
+ throw CArcCmdLineException("Incorrect number of benchmark iterations", nonSwitchStrings[curCommandIndex]);
+ curCommandIndex++;
+ options.NumIterations_Defined = true;
+ }
+ }
+ else if (options.Command.CommandType == NCommandType::kHash)
+ {
+ options.Censor.AddPathsToCensor(censorPathMode);
+ options.Censor.ExtendExclude();
+
+ CHashOptions &hashOptions = options.HashOptions;
+ hashOptions.PathMode = censorPathMode;
+ hashOptions.Methods = options.HashMethods;
+ // hashOptions.HashFilePath = options.HashFilePath;
+ if (parser[NKey::kPreserveATime].ThereIs)
+ hashOptions.PreserveATime = true;
+ if (parser[NKey::kShareForWrite].ThereIs)
+ hashOptions.OpenShareForWrite = true;
+ hashOptions.StdInMode = options.StdInMode;
+ hashOptions.AltStreamsMode = options.AltStreams.Val;
+ hashOptions.SymLinks = options.SymLinks;
+ }
+ else if (options.Command.CommandType == NCommandType::kInfo)
+ {
+ }
+ else
+ throw 20150919;
+}
+
+
+
+#ifndef _WIN32
+
+static AString g_ModuleDirPrefix;
+
+void Set_ModuleDirPrefix_From_ProgArg0(const char *s);
+void Set_ModuleDirPrefix_From_ProgArg0(const char *s)
+{
+ AString a (s);
+ int sep = a.ReverseFind_PathSepar();
+ a.DeleteFrom((unsigned)(sep + 1));
+ g_ModuleDirPrefix = a;
+}
+
+namespace NWindows {
+namespace NDLL {
+
+FString GetModuleDirPrefix();
+FString GetModuleDirPrefix()
+{
+ FString s;
+
+ s = fas2fs(g_ModuleDirPrefix);
+ if (s.IsEmpty())
+ s = FTEXT(".") FSTRING_PATH_SEPARATOR;
+ return s;
+ /*
+ setenv("_7ZIP_HOME_DIR", "/test/", 0);
+ const char *home = getenv("_7ZIP_HOME_DIR");
+ if (home)
+ s = home;
+ else
+ s = FTEXT(".") FSTRING_PATH_SEPARATOR;
+ return s;
+ */
+}
+
+}}
+
+#endif // ! _WIN32
diff --git a/CPP/7zip/UI/Common/ArchiveCommandLine.h b/CPP/7zip/UI/Common/ArchiveCommandLine.h
index bba3c98..9e375b5 100644
--- a/CPP/7zip/UI/Common/ArchiveCommandLine.h
+++ b/CPP/7zip/UI/Common/ArchiveCommandLine.h
@@ -1,136 +1,160 @@
-// ArchiveCommandLine.h
-
-#ifndef __ARCHIVE_COMMAND_LINE_H
-#define __ARCHIVE_COMMAND_LINE_H
-
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/Wildcard.h"
-
-#include "EnumDirItems.h"
-
-#include "Extract.h"
-#include "HashCalc.h"
-#include "Update.h"
-
-typedef CMessagePathException CArcCmdLineException;
-
-namespace NCommandType { enum EEnum
-{
- kAdd = 0,
- kUpdate,
- kDelete,
- kTest,
- kExtract,
- kExtractFull,
- kList,
- kBenchmark,
- kInfo,
- kHash,
- kRename
-};}
-
-struct CArcCommand
-{
- NCommandType::EEnum CommandType;
-
- bool IsFromExtractGroup() const;
- bool IsFromUpdateGroup() const;
- bool IsTestCommand() const { return CommandType == NCommandType::kTest; }
- NExtract::NPathMode::EEnum GetPathMode() const;
-};
-
-enum
-{
- k_OutStream_disabled = 0,
- k_OutStream_stdout = 1,
- k_OutStream_stderr = 2
-};
-
-struct CArcCmdLineOptions
-{
- bool HelpMode;
-
- // bool LargePages;
- bool CaseSensitiveChange;
- bool CaseSensitive;
-
- bool IsInTerminal;
- bool IsStdOutTerminal;
- bool IsStdErrTerminal;
- bool StdInMode;
- bool StdOutMode;
- bool EnableHeaders;
-
- bool YesToAll;
- bool ShowDialog;
- NWildcard::CCensor Censor;
-
- CArcCommand Command;
- UString ArchiveName;
-
- #ifndef _NO_CRYPTO
- bool PasswordEnabled;
- UString Password;
- #endif
-
- bool TechMode;
- bool ShowTime;
-
- UStringVector HashMethods;
-
- bool AppendName;
- // UStringVector ArchivePathsSorted;
- // UStringVector ArchivePathsFullSorted;
- NWildcard::CCensor arcCensor;
- UString ArcName_for_StdInMode;
-
- CObjectVector<CProperty> Properties;
-
- CExtractOptionsBase ExtractOptions;
-
- CBoolPair NtSecurity;
- CBoolPair AltStreams;
- CBoolPair HardLinks;
- CBoolPair SymLinks;
-
- CUpdateOptions UpdateOptions;
- CHashOptions HashOptions;
- UString ArcType;
- UStringVector ExcludedArcTypes;
-
- unsigned Number_for_Out;
- unsigned Number_for_Errors;
- unsigned Number_for_Percents;
- unsigned LogLevel;
-
- // bool IsOutAllowed() const { return Number_for_Out != k_OutStream_disabled; }
-
- // Benchmark
- UInt32 NumIterations;
-
- CArcCmdLineOptions():
- // LargePages(false),
- CaseSensitiveChange(false),
- CaseSensitive(false),
-
- StdInMode(false),
- StdOutMode(false),
-
- Number_for_Out(k_OutStream_stdout),
- Number_for_Errors(k_OutStream_stderr),
- Number_for_Percents(k_OutStream_stdout),
-
- LogLevel(0)
- {
- };
-};
-
-class CArcCmdLineParser
-{
- NCommandLineParser::CParser parser;
-public:
- void Parse1(const UStringVector &commandStrings, CArcCmdLineOptions &options);
- void Parse2(CArcCmdLineOptions &options);
-};
-
-#endif
+// ArchiveCommandLine.h
+
+#ifndef ZIP7_INC_ARCHIVE_COMMAND_LINE_H
+#define ZIP7_INC_ARCHIVE_COMMAND_LINE_H
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/Wildcard.h"
+
+#include "EnumDirItems.h"
+
+#include "Extract.h"
+#include "HashCalc.h"
+#include "Update.h"
+
+typedef CMessagePathException CArcCmdLineException;
+
+namespace NCommandType { enum EEnum
+{
+ kAdd = 0,
+ kUpdate,
+ kDelete,
+ kTest,
+ kExtract,
+ kExtractFull,
+ kList,
+ kBenchmark,
+ kInfo,
+ kHash,
+ kRename
+};}
+
+struct CArcCommand
+{
+ NCommandType::EEnum CommandType;
+
+ bool IsFromExtractGroup() const;
+ bool IsFromUpdateGroup() const;
+ bool IsTestCommand() const { return CommandType == NCommandType::kTest; }
+ NExtract::NPathMode::EEnum GetPathMode() const;
+};
+
+enum
+{
+ k_OutStream_disabled = 0,
+ k_OutStream_stdout = 1,
+ k_OutStream_stderr = 2
+};
+
+struct CArcCmdLineOptions
+{
+ bool HelpMode;
+
+ // bool LargePages;
+ bool CaseSensitive_Change;
+ bool CaseSensitive;
+
+ bool IsInTerminal;
+ bool IsStdOutTerminal;
+ bool IsStdErrTerminal;
+ bool StdInMode;
+ bool StdOutMode;
+ bool EnableHeaders;
+
+ bool YesToAll;
+ bool ShowDialog;
+ bool TechMode;
+ bool ShowTime;
+
+ CBoolPair NtSecurity;
+ CBoolPair AltStreams;
+ CBoolPair HardLinks;
+ CBoolPair SymLinks;
+
+ CBoolPair StoreOwnerId;
+ CBoolPair StoreOwnerName;
+
+ AString ListFields;
+
+ int ConsoleCodePage;
+
+ NWildcard::CCensor Censor;
+
+ CArcCommand Command;
+ UString ArchiveName;
+
+ #ifndef Z7_NO_CRYPTO
+ bool PasswordEnabled;
+ UString Password;
+ #endif
+
+ UStringVector HashMethods;
+ // UString HashFilePath;
+
+ // bool AppendName;
+ // UStringVector ArchivePathsSorted;
+ // UStringVector ArchivePathsFullSorted;
+ NWildcard::CCensor arcCensor;
+ UString ArcName_for_StdInMode;
+
+ CObjectVector<CProperty> Properties;
+
+ CExtractOptionsBase ExtractOptions;
+
+ CUpdateOptions UpdateOptions;
+ CHashOptions HashOptions;
+ UString ArcType;
+ UStringVector ExcludedArcTypes;
+
+ unsigned Number_for_Out;
+ unsigned Number_for_Errors;
+ unsigned Number_for_Percents;
+ unsigned LogLevel;
+
+ // bool IsOutAllowed() const { return Number_for_Out != k_OutStream_disabled; }
+
+ // Benchmark
+ UInt32 NumIterations;
+ bool NumIterations_Defined;
+
+ CArcCmdLineOptions():
+ HelpMode(false),
+ // LargePages(false),
+ CaseSensitive_Change(false),
+ CaseSensitive(false),
+
+ IsInTerminal(false),
+ IsStdOutTerminal(false),
+ IsStdErrTerminal(false),
+
+ StdInMode(false),
+ StdOutMode(false),
+
+ EnableHeaders(false),
+
+ YesToAll(false),
+ ShowDialog(false),
+ TechMode(false),
+ ShowTime(false),
+
+ ConsoleCodePage(-1),
+
+ Number_for_Out(k_OutStream_stdout),
+ Number_for_Errors(k_OutStream_stderr),
+ Number_for_Percents(k_OutStream_stdout),
+
+ LogLevel(0)
+ {
+ }
+};
+
+class CArcCmdLineParser
+{
+ NCommandLineParser::CParser parser;
+public:
+ UString Parse1Log;
+ void Parse1(const UStringVector &commandStrings, CArcCmdLineOptions &options);
+ void Parse2(CArcCmdLineOptions &options);
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp b/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
index aae08ad..4b0cbed 100644
--- a/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
+++ b/CPP/7zip/UI/Common/ArchiveExtractCallback.cpp
@@ -1,1715 +1,2592 @@
-// ArchiveExtractCallback.cpp
-
-#include "StdAfx.h"
-
-#undef sprintf
-#undef printf
-
-// #include <stdio.h>
-// #include "../../../../C/CpuTicks.h"
-
-#include "../../../../C/Alloc.h"
-#include "../../../../C/CpuArch.h"
-
-
-#include "../../../Common/ComTry.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/PropVariant.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#if defined(_WIN32) && !defined(UNDER_CE) && !defined(_SFX)
-#define _USE_SECURITY_CODE
-#include "../../../Windows/SecurityUtils.h"
-#endif
-
-#include "../../Common/FilePathAutoRename.h"
-// #include "../../Common/StreamUtils.h"
-
-#include "../Common/ExtractingFilePath.h"
-#include "../Common/PropIDUtils.h"
-
-#include "ArchiveExtractCallback.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static const char * const kCantAutoRename = "Can not create file with auto name";
-static const char * const kCantRenameFile = "Can not rename existing file";
-static const char * const kCantDeleteOutputFile = "Can not delete output file";
-static const char * const kCantDeleteOutputDir = "Can not delete output folder";
-static const char * const kCantCreateHardLink = "Can not create hard link";
-static const char * const kCantCreateSymLink = "Can not create symbolic link";
-static const char * const kCantOpenOutFile = "Can not open output file";
-static const char * const kCantSetFileLen = "Can not set length for output file";
-
-
-#ifndef _SFX
-
-STDMETHODIMP COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- HRESULT result = S_OK;
- if (_stream)
- result = _stream->Write(data, size, &size);
- if (_calculate)
- _hash->Update(data, size);
- _size += size;
- if (processedSize)
- *processedSize = size;
- return result;
-}
-
-#endif
-
-#ifdef _USE_SECURITY_CODE
-bool InitLocalPrivileges()
-{
- NSecurity::CAccessToken token;
- if (!token.OpenProcessToken(GetCurrentProcess(),
- TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES))
- return false;
-
- TOKEN_PRIVILEGES tp;
-
- tp.PrivilegeCount = 1;
- tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
-
- if (!::LookupPrivilegeValue(NULL, SE_SECURITY_NAME, &tp.Privileges[0].Luid))
- return false;
- if (!token.AdjustPrivileges(&tp))
- return false;
- return (GetLastError() == ERROR_SUCCESS);
-}
-#endif
-
-#ifdef SUPPORT_LINKS
-
-int CHardLinkNode::Compare(const CHardLinkNode &a) const
-{
- if (StreamId < a.StreamId) return -1;
- if (StreamId > a.StreamId) return 1;
- return MyCompare(INode, a.INode);
-}
-
-static HRESULT Archive_Get_HardLinkNode(IInArchive *archive, UInt32 index, CHardLinkNode &h, bool &defined)
-{
- h.INode = 0;
- h.StreamId = (UInt64)(Int64)-1;
- defined = false;
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidINode, &prop));
- if (!ConvertPropVariantToUInt64(prop, h.INode))
- return S_OK;
- }
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidStreamId, &prop));
- ConvertPropVariantToUInt64(prop, h.StreamId);
- }
- defined = true;
- return S_OK;
-}
-
-
-HRESULT CArchiveExtractCallback::PrepareHardLinks(const CRecordVector<UInt32> *realIndices)
-{
- _hardLinks.Clear();
-
- if (!_arc->Ask_INode)
- return S_OK;
-
- IInArchive *archive = _arc->Archive;
- CRecordVector<CHardLinkNode> &hardIDs = _hardLinks.IDs;
-
- {
- UInt32 numItems;
- if (realIndices)
- numItems = realIndices->Size();
- else
- {
- RINOK(archive->GetNumberOfItems(&numItems));
- }
-
- for (UInt32 i = 0; i < numItems; i++)
- {
- CHardLinkNode h;
- bool defined;
- UInt32 realIndex = realIndices ? (*realIndices)[i] : i;
-
- RINOK(Archive_Get_HardLinkNode(archive, realIndex, h, defined));
- if (defined)
- {
- bool isAltStream = false;
- RINOK(Archive_IsItem_AltStream(archive, realIndex, isAltStream));
- if (!isAltStream)
- hardIDs.Add(h);
- }
- }
- }
-
- hardIDs.Sort2();
-
- {
- // wee keep only items that have 2 or more items
- unsigned k = 0;
- unsigned numSame = 1;
- for (unsigned i = 1; i < hardIDs.Size(); i++)
- {
- if (hardIDs[i].Compare(hardIDs[i - 1]) != 0)
- numSame = 1;
- else if (++numSame == 2)
- {
- if (i - 1 != k)
- hardIDs[k] = hardIDs[i - 1];
- k++;
- }
- }
- hardIDs.DeleteFrom(k);
- }
-
- _hardLinks.PrepareLinks();
- return S_OK;
-}
-
-#endif
-
-CArchiveExtractCallback::CArchiveExtractCallback():
- _arc(NULL),
- WriteCTime(true),
- WriteATime(true),
- WriteMTime(true),
- _multiArchives(false)
-{
- LocalProgressSpec = new CLocalProgress();
- _localProgress = LocalProgressSpec;
-
- #ifdef _USE_SECURITY_CODE
- _saclEnabled = InitLocalPrivileges();
- #endif
-}
-
-void CArchiveExtractCallback::Init(
- const CExtractNtOptions &ntOptions,
- const NWildcard::CCensorNode *wildcardCensor,
- const CArc *arc,
- IFolderArchiveExtractCallback *extractCallback2,
- bool stdOutMode, bool testMode,
- const FString &directoryPath,
- const UStringVector &removePathParts, bool removePartsForAltStreams,
- UInt64 packSize)
-{
- ClearExtractedDirsInfo();
- _outFileStream.Release();
-
- #ifdef SUPPORT_LINKS
- _hardLinks.Clear();
- #endif
-
- #ifdef SUPPORT_ALT_STREAMS
- _renamedFiles.Clear();
- #endif
-
- _ntOptions = ntOptions;
- _wildcardCensor = wildcardCensor;
-
- _stdOutMode = stdOutMode;
- _testMode = testMode;
-
- // _progressTotal = 0;
- // _progressTotal_Defined = false;
-
- _packTotal = packSize;
- _progressTotal = packSize;
- _progressTotal_Defined = true;
-
- _extractCallback2 = extractCallback2;
- _compressProgress.Release();
- _extractCallback2.QueryInterface(IID_ICompressProgressInfo, &_compressProgress);
- _extractCallback2.QueryInterface(IID_IArchiveExtractCallbackMessage, &_callbackMessage);
- _extractCallback2.QueryInterface(IID_IFolderArchiveExtractCallback2, &_folderArchiveExtractCallback2);
-
- #ifndef _SFX
-
- _extractCallback2.QueryInterface(IID_IFolderExtractToStreamCallback, &ExtractToStreamCallback);
- if (ExtractToStreamCallback)
- {
- Int32 useStreams = 0;
- if (ExtractToStreamCallback->UseExtractToStream(&useStreams) != S_OK)
- useStreams = 0;
- if (useStreams == 0)
- ExtractToStreamCallback.Release();
- }
-
- #endif
-
- LocalProgressSpec->Init(extractCallback2, true);
- LocalProgressSpec->SendProgress = false;
-
- _removePathParts = removePathParts;
- _removePartsForAltStreams = removePartsForAltStreams;
-
- #ifndef _SFX
- _baseParentFolder = (UInt32)(Int32)-1;
- _use_baseParentFolder_mode = false;
- #endif
-
- _arc = arc;
- _dirPathPrefix = directoryPath;
- _dirPathPrefix_Full = directoryPath;
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (!NName::IsAltPathPrefix(_dirPathPrefix))
- #endif
- {
- NName::NormalizeDirPathPrefix(_dirPathPrefix);
- NDir::MyGetFullPathName(directoryPath, _dirPathPrefix_Full);
- NName::NormalizeDirPathPrefix(_dirPathPrefix_Full);
- }
-}
-
-STDMETHODIMP CArchiveExtractCallback::SetTotal(UInt64 size)
-{
- COM_TRY_BEGIN
- _progressTotal = size;
- _progressTotal_Defined = true;
- if (!_multiArchives && _extractCallback2)
- return _extractCallback2->SetTotal(size);
- return S_OK;
- COM_TRY_END
-}
-
-static void NormalizeVals(UInt64 &v1, UInt64 &v2)
-{
- const UInt64 kMax = (UInt64)1 << 31;
- while (v1 > kMax)
- {
- v1 >>= 1;
- v2 >>= 1;
- }
-}
-
-static UInt64 MyMultDiv64(UInt64 unpCur, UInt64 unpTotal, UInt64 packTotal)
-{
- NormalizeVals(packTotal, unpTotal);
- NormalizeVals(unpCur, unpTotal);
- if (unpTotal == 0)
- unpTotal = 1;
- return unpCur * packTotal / unpTotal;
-}
-
-STDMETHODIMP CArchiveExtractCallback::SetCompleted(const UInt64 *completeValue)
-{
- COM_TRY_BEGIN
-
- if (!_extractCallback2)
- return S_OK;
-
- UInt64 packCur;
- if (_multiArchives)
- {
- packCur = LocalProgressSpec->InSize;
- if (completeValue && _progressTotal_Defined)
- packCur += MyMultDiv64(*completeValue, _progressTotal, _packTotal);
- completeValue = &packCur;
- }
- return _extractCallback2->SetCompleted(completeValue);
-
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveExtractCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
- COM_TRY_BEGIN
- return _localProgress->SetRatioInfo(inSize, outSize);
- COM_TRY_END
-}
-
-void CArchiveExtractCallback::CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath)
-{
- bool isAbsPath = false;
-
- if (!dirPathParts.IsEmpty())
- {
- const UString &s = dirPathParts[0];
- if (s.IsEmpty())
- isAbsPath = true;
- #if defined(_WIN32) && !defined(UNDER_CE)
- else
- {
- if (NName::IsDrivePath2(s))
- isAbsPath = true;
- }
- #endif
- }
-
- if (_pathMode == NExtract::NPathMode::kAbsPaths && isAbsPath)
- fullPath.Empty();
- else
- fullPath = _dirPathPrefix;
-
- FOR_VECTOR (i, dirPathParts)
- {
- if (i != 0)
- fullPath.Add_PathSepar();
- const UString &s = dirPathParts[i];
- fullPath += us2fs(s);
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (_pathMode == NExtract::NPathMode::kAbsPaths)
- if (i == 0 && s.Len() == 2 && NName::IsDrivePath2(s))
- continue;
- #endif
- CreateDir(fullPath);
- }
-}
-
-HRESULT CArchiveExtractCallback::GetTime(UInt32 index, PROPID propID, FILETIME &filetime, bool &filetimeIsDefined)
-{
- filetimeIsDefined = false;
- filetime.dwLowDateTime = 0;
- filetime.dwHighDateTime = 0;
- NCOM::CPropVariant prop;
- RINOK(_arc->Archive->GetProperty(index, propID, &prop));
- if (prop.vt == VT_FILETIME)
- {
- filetime = prop.filetime;
- filetimeIsDefined = (filetime.dwHighDateTime != 0 || filetime.dwLowDateTime != 0);
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-HRESULT CArchiveExtractCallback::GetUnpackSize()
-{
- return _arc->GetItemSize(_index, _curSize, _curSizeDefined);
-}
-
-static void AddPathToMessage(UString &s, const FString &path)
-{
- s += " : ";
- s += fs2us(path);
-}
-
-HRESULT CArchiveExtractCallback::SendMessageError(const char *message, const FString &path)
-{
- UString s (message);
- AddPathToMessage(s, path);
- return _extractCallback2->MessageError(s);
-}
-
-HRESULT CArchiveExtractCallback::SendMessageError_with_LastError(const char *message, const FString &path)
-{
- DWORD errorCode = GetLastError();
- UString s (message);
- if (errorCode != 0)
- {
- s += " : ";
- s += NError::MyFormatMessage(errorCode);
- }
- AddPathToMessage(s, path);
- return _extractCallback2->MessageError(s);
-}
-
-HRESULT CArchiveExtractCallback::SendMessageError2(const char *message, const FString &path1, const FString &path2)
-{
- UString s (message);
- AddPathToMessage(s, path1);
- AddPathToMessage(s, path2);
- return _extractCallback2->MessageError(s);
-}
-
-#ifndef _SFX
-
-STDMETHODIMP CGetProp::GetProp(PROPID propID, PROPVARIANT *value)
-{
- /*
- if (propID == kpidName)
- {
- COM_TRY_BEGIN
- NCOM::CPropVariant prop = Name;
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
- }
- */
- return Arc->Archive->GetProperty(IndexInArc, propID, value);
-}
-
-#endif
-
-
-#ifdef SUPPORT_LINKS
-
-static UString GetDirPrefixOf(const UString &src)
-{
- UString s (src);
- if (!s.IsEmpty())
- {
- if (IsPathSepar(s.Back()))
- s.DeleteBack();
- int pos = s.ReverseFind_PathSepar();
- s.DeleteFrom(pos + 1);
- }
- return s;
-}
-
-#endif
-
-
-bool IsSafePath(const UString &path)
-{
- if (NName::IsAbsolutePath(path))
- return false;
-
- UStringVector parts;
- SplitPathToParts(path, parts);
- unsigned level = 0;
-
- FOR_VECTOR (i, parts)
- {
- const UString &s = parts[i];
- if (s.IsEmpty())
- {
- if (i == 0)
- return false;
- continue;
- }
- if (s == L".")
- continue;
- if (s == L"..")
- {
- if (level == 0)
- return false;
- level--;
- }
- else
- level++;
- }
-
- return level > 0;
-}
-
-
-bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include)
-{
- bool found = false;
-
- if (node.CheckPathVect(item.PathParts, !item.MainIsDir, include))
- {
- if (!include)
- return true;
-
- #ifdef SUPPORT_ALT_STREAMS
- if (!item.IsAltStream)
- return true;
- #endif
-
- found = true;
- }
-
- #ifdef SUPPORT_ALT_STREAMS
-
- if (!item.IsAltStream)
- return false;
-
- UStringVector pathParts2 = item.PathParts;
- if (pathParts2.IsEmpty())
- pathParts2.AddNew();
- UString &back = pathParts2.Back();
- back += ':';
- back += item.AltStreamName;
- bool include2;
-
- if (node.CheckPathVect(pathParts2,
- true, // isFile,
- include2))
- {
- include = include2;
- return true;
- }
-
- #endif
-
- return found;
-}
-
-bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item)
-{
- bool include;
- if (CensorNode_CheckPath2(node, item, include))
- return include;
- return false;
-}
-
-static FString MakePath_from_2_Parts(const FString &prefix, const FString &path)
-{
- FString s (prefix);
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (!path.IsEmpty() && path[0] == ':' && !prefix.IsEmpty() && IsPathSepar(prefix.Back()))
- {
- if (!NName::IsDriveRootPath_SuperAllowed(prefix))
- s.DeleteBack();
- }
- #endif
- s += path;
- return s;
-}
-
-
-/*
-#ifdef SUPPORT_LINKS
-
-struct CTempMidBuffer
-{
- void *Buf;
-
- CTempMidBuffer(size_t size): Buf(NULL) { Buf = ::MidAlloc(size); }
- ~CTempMidBuffer() { ::MidFree(Buf); }
-};
-
-HRESULT CArchiveExtractCallback::MyCopyFile(ISequentialOutStream *outStream)
-{
- const size_t kBufSize = 1 << 16;
- CTempMidBuffer buf(kBufSize);
- if (!buf.Buf)
- return E_OUTOFMEMORY;
-
- NIO::CInFile inFile;
- NIO::COutFile outFile;
-
- if (!inFile.Open(_CopyFile_Path))
- return SendMessageError_with_LastError("Open error", _CopyFile_Path);
-
- for (;;)
- {
- UInt32 num;
-
- if (!inFile.Read(buf.Buf, kBufSize, num))
- return SendMessageError_with_LastError("Read error", _CopyFile_Path);
-
- if (num == 0)
- return S_OK;
-
-
- RINOK(WriteStream(outStream, buf.Buf, num));
- }
-}
-
-#endif
-*/
-
-
-STDMETHODIMP CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode)
-{
- COM_TRY_BEGIN
-
- *outStream = NULL;
-
- #ifndef _SFX
- if (_hashStream)
- _hashStreamSpec->ReleaseStream();
- _hashStreamWasUsed = false;
- #endif
-
- _outFileStream.Release();
-
- _encrypted = false;
- _position = 0;
- _isSplit = false;
-
- _curSize = 0;
- _curSizeDefined = false;
- _fileLengthWasSet = false;
- _index = index;
-
- _diskFilePath.Empty();
-
- // _fi.Clear();
-
- #ifdef SUPPORT_LINKS
- // _CopyFile_Path.Empty();
- linkPath.Empty();
- #endif
-
- IInArchive *archive = _arc->Archive;
-
- #ifndef _SFX
- _item._use_baseParentFolder_mode = _use_baseParentFolder_mode;
- if (_use_baseParentFolder_mode)
- {
- _item._baseParentFolder = _baseParentFolder;
- if (_pathMode == NExtract::NPathMode::kFullPaths ||
- _pathMode == NExtract::NPathMode::kAbsPaths)
- _item._baseParentFolder = -1;
- }
- #endif
-
- #ifdef SUPPORT_ALT_STREAMS
- _item.WriteToAltStreamIfColon = _ntOptions.WriteToAltStreamIfColon;
- #endif
-
- RINOK(_arc->GetItem(index, _item));
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidPosition, &prop));
- if (prop.vt != VT_EMPTY)
- {
- if (prop.vt != VT_UI8)
- return E_FAIL;
- _position = prop.uhVal.QuadPart;
- _isSplit = true;
- }
- }
-
- #ifdef SUPPORT_LINKS
-
- // bool isCopyLink = false;
- bool isHardLink = false;
- bool isJunction = false;
- bool isRelative = false;
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidHardLink, &prop));
- if (prop.vt == VT_BSTR)
- {
- isHardLink = true;
- // isCopyLink = false;
- isRelative = false; // RAR5, TAR: hard links are from root folder of archive
- linkPath.SetFromBstr(prop.bstrVal);
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- }
-
- /*
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidCopyLink, &prop));
- if (prop.vt == VT_BSTR)
- {
- isHardLink = false;
- isCopyLink = true;
- isRelative = false; // RAR5: copy links are from root folder of archive
- linkPath.SetFromBstr(prop.bstrVal);
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- }
- */
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidSymLink, &prop));
- if (prop.vt == VT_BSTR)
- {
- isHardLink = false;
- // isCopyLink = false;
- isRelative = true; // RAR5, TAR: symbolic links can be relative
- linkPath.SetFromBstr(prop.bstrVal);
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- }
-
-
- bool isOkReparse = false;
-
- if (linkPath.IsEmpty() && _arc->GetRawProps)
- {
- const void *data;
- UInt32 dataSize;
- UInt32 propType;
-
- _arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType);
-
- if (dataSize != 0)
- {
- if (propType != NPropDataType::kRaw)
- return E_FAIL;
- UString s;
- CReparseAttr reparse;
- DWORD errorCode = 0;
- isOkReparse = reparse.Parse((const Byte *)data, dataSize, errorCode);
- if (isOkReparse)
- {
- isHardLink = false;
- // isCopyLink = false;
- linkPath = reparse.GetPath();
- isJunction = reparse.IsMountPoint();
- isRelative = reparse.IsRelative();
- #ifndef _WIN32
- linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
- #endif
- }
- }
- }
-
- if (!linkPath.IsEmpty())
- {
- #ifdef _WIN32
- linkPath.Replace(L'/', WCHAR_PATH_SEPARATOR);
- #endif
-
- // rar5 uses "\??\" prefix for absolute links
- if (linkPath.IsPrefixedBy(WSTRING_PATH_SEPARATOR L"??" WSTRING_PATH_SEPARATOR))
- {
- isRelative = false;
- linkPath.DeleteFrontal(4);
- }
-
- for (;;)
- // while (NName::IsAbsolutePath(linkPath))
- {
- unsigned n = NName::GetRootPrefixSize(linkPath);
- if (n == 0)
- break;
- isRelative = false;
- linkPath.DeleteFrontal(n);
- }
- }
-
- if (!linkPath.IsEmpty() && !isRelative && _removePathParts.Size() != 0)
- {
- UStringVector pathParts;
- SplitPathToParts(linkPath, pathParts);
- bool badPrefix = false;
- FOR_VECTOR (i, _removePathParts)
- {
- if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
- {
- badPrefix = true;
- break;
- }
- }
- if (!badPrefix)
- pathParts.DeleteFrontal(_removePathParts.Size());
- linkPath = MakePathFromParts(pathParts);
- }
-
- #endif
-
- RINOK(Archive_GetItemBoolProp(archive, index, kpidEncrypted, _encrypted));
-
- RINOK(GetUnpackSize());
-
- #ifdef SUPPORT_ALT_STREAMS
-
- if (!_ntOptions.AltStreams.Val && _item.IsAltStream)
- return S_OK;
-
- #endif
-
-
- UStringVector &pathParts = _item.PathParts;
-
- if (_wildcardCensor)
- {
- if (!CensorNode_CheckPath(*_wildcardCensor, _item))
- return S_OK;
- }
-
- #ifndef _SFX
- if (_use_baseParentFolder_mode)
- {
- if (!pathParts.IsEmpty())
- {
- unsigned numRemovePathParts = 0;
-
- #ifdef SUPPORT_ALT_STREAMS
- if (_pathMode == NExtract::NPathMode::kNoPathsAlt && _item.IsAltStream)
- numRemovePathParts = pathParts.Size();
- else
- #endif
- if (_pathMode == NExtract::NPathMode::kNoPaths ||
- _pathMode == NExtract::NPathMode::kNoPathsAlt)
- numRemovePathParts = pathParts.Size() - 1;
- pathParts.DeleteFrontal(numRemovePathParts);
- }
- }
- else
- #endif
- {
- if (pathParts.IsEmpty())
- {
- if (_item.IsDir)
- return S_OK;
- /*
- #ifdef SUPPORT_ALT_STREAMS
- if (!_item.IsAltStream)
- #endif
- return E_FAIL;
- */
- }
-
- unsigned numRemovePathParts = 0;
-
- switch (_pathMode)
- {
- case NExtract::NPathMode::kFullPaths:
- case NExtract::NPathMode::kCurPaths:
- {
- if (_removePathParts.IsEmpty())
- break;
- bool badPrefix = false;
-
- if (pathParts.Size() < _removePathParts.Size())
- badPrefix = true;
- else
- {
- if (pathParts.Size() == _removePathParts.Size())
- {
- if (_removePartsForAltStreams)
- {
- #ifdef SUPPORT_ALT_STREAMS
- if (!_item.IsAltStream)
- #endif
- badPrefix = true;
- }
- else
- {
- if (!_item.MainIsDir)
- badPrefix = true;
- }
- }
-
- if (!badPrefix)
- FOR_VECTOR (i, _removePathParts)
- {
- if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
- {
- badPrefix = true;
- break;
- }
- }
- }
-
- if (badPrefix)
- {
- if (askExtractMode == NArchive::NExtract::NAskMode::kExtract && !_testMode)
- return E_FAIL;
- }
- else
- numRemovePathParts = _removePathParts.Size();
- break;
- }
-
- case NExtract::NPathMode::kNoPaths:
- {
- if (!pathParts.IsEmpty())
- numRemovePathParts = pathParts.Size() - 1;
- break;
- }
- case NExtract::NPathMode::kNoPathsAlt:
- {
- #ifdef SUPPORT_ALT_STREAMS
- if (_item.IsAltStream)
- numRemovePathParts = pathParts.Size();
- else
- #endif
- if (!pathParts.IsEmpty())
- numRemovePathParts = pathParts.Size() - 1;
- break;
- }
- /*
- case NExtract::NPathMode::kFullPaths:
- case NExtract::NPathMode::kAbsPaths:
- break;
- */
- }
-
- pathParts.DeleteFrontal(numRemovePathParts);
- }
-
- #ifndef _SFX
-
- if (ExtractToStreamCallback)
- {
- if (!GetProp)
- {
- GetProp_Spec = new CGetProp;
- GetProp = GetProp_Spec;
- }
- GetProp_Spec->Arc = _arc;
- GetProp_Spec->IndexInArc = index;
- UString name (MakePathFromParts(pathParts));
-
- #ifdef SUPPORT_ALT_STREAMS
- if (_item.IsAltStream)
- {
- if (!pathParts.IsEmpty() || (!_removePartsForAltStreams && _pathMode != NExtract::NPathMode::kNoPathsAlt))
- name += ':';
- name += _item.AltStreamName;
- }
- #endif
-
- return ExtractToStreamCallback->GetStream7(name, BoolToInt(_item.IsDir), outStream, askExtractMode, GetProp);
- }
-
- #endif
-
- CMyComPtr<ISequentialOutStream> outStreamLoc;
-
-if (askExtractMode == NArchive::NExtract::NAskMode::kExtract && !_testMode)
-{
- if (_stdOutMode)
- {
- outStreamLoc = new CStdOutFileStream;
- }
- else
- {
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidAttrib, &prop));
- if (prop.vt == VT_UI4)
- {
- _fi.Attrib = prop.ulVal;
- _fi.AttribDefined = true;
- }
- else if (prop.vt == VT_EMPTY)
- _fi.AttribDefined = false;
- else
- return E_FAIL;
- }
-
- RINOK(GetTime(index, kpidCTime, _fi.CTime, _fi.CTimeDefined));
- RINOK(GetTime(index, kpidATime, _fi.ATime, _fi.ATimeDefined));
- RINOK(GetTime(index, kpidMTime, _fi.MTime, _fi.MTimeDefined));
-
- bool isAnti = false;
- RINOK(_arc->IsItemAnti(index, isAnti));
-
- #ifdef SUPPORT_ALT_STREAMS
- if (!_item.IsAltStream
- || !pathParts.IsEmpty()
- || !(_removePartsForAltStreams || _pathMode == NExtract::NPathMode::kNoPathsAlt))
- #endif
- Correct_FsPath(_pathMode == NExtract::NPathMode::kAbsPaths, _keepAndReplaceEmptyDirPrefixes, pathParts, _item.MainIsDir);
-
- #ifdef SUPPORT_ALT_STREAMS
-
- if (_item.IsAltStream)
- {
- UString s (_item.AltStreamName);
- Correct_AltStream_Name(s);
- bool needColon = true;
-
- if (pathParts.IsEmpty())
- {
- pathParts.AddNew();
- if (_removePartsForAltStreams || _pathMode == NExtract::NPathMode::kNoPathsAlt)
- needColon = false;
- }
- else if (_pathMode == NExtract::NPathMode::kAbsPaths &&
- NWildcard::GetNumPrefixParts_if_DrivePath(pathParts) == pathParts.Size())
- pathParts.AddNew();
-
- UString &name = pathParts.Back();
- if (needColon)
- name += (char)(_ntOptions.ReplaceColonForAltStream ? '_' : ':');
- name += s;
- }
-
- #endif
-
- UString processedPath (MakePathFromParts(pathParts));
-
- if (!isAnti)
- {
- if (!_item.IsDir)
- {
- if (!pathParts.IsEmpty())
- pathParts.DeleteBack();
- }
-
- if (!pathParts.IsEmpty())
- {
- FString fullPathNew;
- CreateComplexDirectory(pathParts, fullPathNew);
-
- if (_item.IsDir)
- {
- CDirPathTime &pt = _extractedFolders.AddNew();
-
- pt.CTime = _fi.CTime;
- pt.CTimeDefined = (WriteCTime && _fi.CTimeDefined);
-
- pt.ATime = _fi.ATime;
- pt.ATimeDefined = (WriteATime && _fi.ATimeDefined);
-
- pt.MTimeDefined = false;
-
- if (WriteMTime)
- {
- if (_fi.MTimeDefined)
- {
- pt.MTime = _fi.MTime;
- pt.MTimeDefined = true;
- }
- else if (_arc->MTimeDefined)
- {
- pt.MTime = _arc->MTime;
- pt.MTimeDefined = true;
- }
- }
-
- pt.Path = fullPathNew;
-
- pt.SetDirTime();
- }
- }
- }
-
-
- FString fullProcessedPath (us2fs(processedPath));
- if (_pathMode != NExtract::NPathMode::kAbsPaths
- || !NName::IsAbsolutePath(processedPath))
- {
- fullProcessedPath = MakePath_from_2_Parts(_dirPathPrefix, fullProcessedPath);
- }
-
- #ifdef SUPPORT_ALT_STREAMS
-
- if (_item.IsAltStream && _item.ParentIndex != (UInt32)(Int32)-1)
- {
- int renIndex = _renamedFiles.FindInSorted(CIndexToPathPair(_item.ParentIndex));
- if (renIndex >= 0)
- {
- const CIndexToPathPair &pair = _renamedFiles[renIndex];
- fullProcessedPath = pair.Path;
- fullProcessedPath += ':';
- UString s (_item.AltStreamName);
- Correct_AltStream_Name(s);
- fullProcessedPath += us2fs(s);
- }
- }
-
- #endif
-
- bool isRenamed = false;
-
- if (_item.IsDir)
- {
- _diskFilePath = fullProcessedPath;
- if (isAnti)
- RemoveDir(_diskFilePath);
- #ifdef SUPPORT_LINKS
- if (linkPath.IsEmpty())
- #endif
- return S_OK;
- }
- else if (!_isSplit)
- {
-
- // ----- Is file (not split) -----
- NFind::CFileInfo fileInfo;
- if (fileInfo.Find(fullProcessedPath))
- {
- switch (_overwriteMode)
- {
- case NExtract::NOverwriteMode::kSkip:
- return S_OK;
- case NExtract::NOverwriteMode::kAsk:
- {
- int slashPos = fullProcessedPath.ReverseFind_PathSepar();
- FString realFullProcessedPath (fullProcessedPath.Left(slashPos + 1) + fileInfo.Name);
-
- Int32 overwriteResult;
- RINOK(_extractCallback2->AskOverwrite(
- fs2us(realFullProcessedPath), &fileInfo.MTime, &fileInfo.Size, _item.Path,
- _fi.MTimeDefined ? &_fi.MTime : NULL,
- _curSizeDefined ? &_curSize : NULL,
- &overwriteResult))
-
- switch (overwriteResult)
- {
- case NOverwriteAnswer::kCancel: return E_ABORT;
- case NOverwriteAnswer::kNo: return S_OK;
- case NOverwriteAnswer::kNoToAll: _overwriteMode = NExtract::NOverwriteMode::kSkip; return S_OK;
- case NOverwriteAnswer::kYes: break;
- case NOverwriteAnswer::kYesToAll: _overwriteMode = NExtract::NOverwriteMode::kOverwrite; break;
- case NOverwriteAnswer::kAutoRename: _overwriteMode = NExtract::NOverwriteMode::kRename; break;
- default:
- return E_FAIL;
- }
- }
- }
- if (_overwriteMode == NExtract::NOverwriteMode::kRename)
- {
- if (!AutoRenamePath(fullProcessedPath))
- {
- RINOK(SendMessageError(kCantAutoRename, fullProcessedPath));
- return E_FAIL;
- }
- isRenamed = true;
- }
- else if (_overwriteMode == NExtract::NOverwriteMode::kRenameExisting)
- {
- FString existPath (fullProcessedPath);
- if (!AutoRenamePath(existPath))
- {
- RINOK(SendMessageError(kCantAutoRename, fullProcessedPath));
- return E_FAIL;
- }
- // MyMoveFile can raname folders. So it's OK to use it for folders too
- if (!MyMoveFile(fullProcessedPath, existPath))
- {
- RINOK(SendMessageError2(kCantRenameFile, existPath, fullProcessedPath));
- return E_FAIL;
- }
- }
- else
- {
- if (fileInfo.IsDir())
- {
- // do we need to delete all files in folder?
- if (!RemoveDir(fullProcessedPath))
- {
- RINOK(SendMessageError_with_LastError(kCantDeleteOutputDir, fullProcessedPath));
- return S_OK;
- }
- }
- else
- {
- bool needDelete = true;
- if (needDelete)
- {
- if (NFind::DoesFileExist(fullProcessedPath))
- if (!DeleteFileAlways(fullProcessedPath))
- if (GetLastError() != ERROR_FILE_NOT_FOUND)
- {
- RINOK(SendMessageError_with_LastError(kCantDeleteOutputFile, fullProcessedPath));
- return S_OK;
- // return E_FAIL;
- }
- }
- }
- }
- }
- else // not Find(fullProcessedPath)
- {
- // we need to clear READ-ONLY of parent before creating alt stream
- #if defined(_WIN32) && !defined(UNDER_CE)
- int colonPos = NName::FindAltStreamColon(fullProcessedPath);
- if (colonPos >= 0 && fullProcessedPath[(unsigned)colonPos + 1] != 0)
- {
- FString parentFsPath (fullProcessedPath);
- parentFsPath.DeleteFrom(colonPos);
- NFind::CFileInfo parentFi;
- if (parentFi.Find(parentFsPath))
- {
- if (parentFi.IsReadOnly())
- SetFileAttrib(parentFsPath, parentFi.Attrib & ~FILE_ATTRIBUTE_READONLY);
- }
- }
- #endif
- }
- // ----- END of code for Is file (not split) -----
-
- }
- _diskFilePath = fullProcessedPath;
-
-
- if (!isAnti)
- {
- #ifdef SUPPORT_LINKS
-
- if (!linkPath.IsEmpty())
- {
- #ifndef UNDER_CE
-
- UString relatPath;
- if (isRelative)
- relatPath = GetDirPrefixOf(_item.Path);
- relatPath += linkPath;
-
- if (!IsSafePath(relatPath))
- {
- RINOK(SendMessageError("Dangerous link path was ignored", us2fs(relatPath)));
- }
- else
- {
- FString existPath;
- if (isHardLink /* || isCopyLink */ || !isRelative)
- {
- if (!NName::GetFullPath(_dirPathPrefix_Full, us2fs(relatPath), existPath))
- {
- RINOK(SendMessageError("Incorrect path", us2fs(relatPath)));
- }
- }
- else
- {
- existPath = us2fs(linkPath);
- }
-
- if (!existPath.IsEmpty())
- {
- if (isHardLink /* || isCopyLink */)
- {
- // if (isHardLink)
- {
- if (!MyCreateHardLink(fullProcessedPath, existPath))
- {
- RINOK(SendMessageError2(kCantCreateHardLink, fullProcessedPath, existPath));
- // return S_OK;
- }
- }
- /*
- else
- {
- NFind::CFileInfo fi;
- if (!fi.Find(existPath))
- {
- RINOK(SendMessageError2("Can not find the file for copying", existPath, fullProcessedPath));
- }
- else
- {
- if (_curSizeDefined && _curSize == fi.Size)
- _CopyFile_Path = existPath;
- else
- {
- RINOK(SendMessageError2("File size collision for file copying", existPath, fullProcessedPath));
- }
-
- // RINOK(MyCopyFile(existPath, fullProcessedPath));
- }
- }
- */
- }
- else if (_ntOptions.SymLinks.Val)
- {
- // bool isSymLink = true; // = false for junction
- if (_item.IsDir && !isRelative)
- {
- // if it's before Vista we use Junction Point
- // isJunction = true;
- // convertToAbs = true;
- }
-
- CByteBuffer data;
- if (FillLinkData(data, fs2us(existPath), !isJunction))
- {
- CReparseAttr attr;
- DWORD errorCode = 0;
- if (!attr.Parse(data, data.Size(), errorCode))
- {
- RINOK(SendMessageError("Internal error for symbolic link file", us2fs(_item.Path)));
- // return E_FAIL;
- }
- else
- if (!NFile::NIO::SetReparseData(fullProcessedPath, _item.IsDir, data, (DWORD)data.Size()))
- {
- RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath));
- }
- }
- }
- }
- }
-
- #endif
- }
-
- if (linkPath.IsEmpty() /* || !_CopyFile_Path.IsEmpty() */)
- #endif // SUPPORT_LINKS
- {
- bool needWriteFile = true;
-
- #ifdef SUPPORT_LINKS
- if (!_hardLinks.IDs.IsEmpty() && !_item.IsAltStream)
- {
- CHardLinkNode h;
- bool defined;
- RINOK(Archive_Get_HardLinkNode(archive, index, h, defined));
- if (defined)
- {
- {
- int linkIndex = _hardLinks.IDs.FindInSorted2(h);
- if (linkIndex >= 0)
- {
- FString &hl = _hardLinks.Links[linkIndex];
- if (hl.IsEmpty())
- hl = fullProcessedPath;
- else
- {
- if (!MyCreateHardLink(fullProcessedPath, hl))
- {
- RINOK(SendMessageError2(kCantCreateHardLink, fullProcessedPath, hl));
- return S_OK;
- }
- needWriteFile = false;
- }
- }
- }
- }
- }
- #endif
-
- if (needWriteFile)
- {
- _outFileStreamSpec = new COutFileStream;
- CMyComPtr<ISequentialOutStream> outStreamLoc2(_outFileStreamSpec);
- if (!_outFileStreamSpec->Open(fullProcessedPath, _isSplit ? OPEN_ALWAYS: CREATE_ALWAYS))
- {
- // if (::GetLastError() != ERROR_FILE_EXISTS || !isSplit)
- {
- RINOK(SendMessageError_with_LastError(kCantOpenOutFile, fullProcessedPath));
- return S_OK;
- }
- }
-
- if (_ntOptions.PreAllocateOutFile && !_isSplit && _curSizeDefined && _curSize > (1 << 12))
- {
- // UInt64 ticks = GetCpuTicks();
- bool res = _outFileStreamSpec->File.SetLength(_curSize);
- _fileLengthWasSet = res;
-
- // ticks = GetCpuTicks() - ticks;
- // printf("\nticks = %10d\n", (unsigned)ticks);
- if (!res)
- {
- RINOK(SendMessageError_with_LastError(kCantSetFileLen, fullProcessedPath));
- }
-
- /*
- _outFileStreamSpec->File.Close();
- ticks = GetCpuTicks() - ticks;
- printf("\nticks = %10d\n", (unsigned)ticks);
- return S_FALSE;
- */
-
- /*
- File.SetLength() on FAT (xp64): is fast, but then File.Close() can be slow,
- if we don't write any data.
- File.SetLength() for remote share file (exFAT) can be slow in some cases,
- and the Windows can return "network error" after 1 minute,
- while remote file still can grow.
- We need some way to detect such bad cases and disable PreAllocateOutFile mode.
- */
-
- res = _outFileStreamSpec->File.SeekToBegin();
- if (!res)
- {
- RINOK(SendMessageError_with_LastError("Can not seek to begin of file", fullProcessedPath));
- }
- }
-
- #ifdef SUPPORT_ALT_STREAMS
- if (isRenamed && !_item.IsAltStream)
- {
- CIndexToPathPair pair(index, fullProcessedPath);
- unsigned oldSize = _renamedFiles.Size();
- unsigned insertIndex = _renamedFiles.AddToUniqueSorted(pair);
- if (oldSize == _renamedFiles.Size())
- _renamedFiles[insertIndex].Path = fullProcessedPath;
- }
- #endif
-
- if (_isSplit)
- {
- RINOK(_outFileStreamSpec->Seek(_position, STREAM_SEEK_SET, NULL));
- }
-
- _outFileStream = outStreamLoc2;
- }
- }
- }
-
- outStreamLoc = _outFileStream;
- }
-}
-
- #ifndef _SFX
-
- if (_hashStream)
- {
- if (askExtractMode == NArchive::NExtract::NAskMode::kExtract ||
- askExtractMode == NArchive::NExtract::NAskMode::kTest)
- {
- _hashStreamSpec->SetStream(outStreamLoc);
- outStreamLoc = _hashStream;
- _hashStreamSpec->Init(true);
- _hashStreamWasUsed = true;
- }
- }
-
- #endif
-
-
- if (outStreamLoc)
- {
- /*
- #ifdef SUPPORT_LINKS
-
- if (!_CopyFile_Path.IsEmpty())
- {
- RINOK(PrepareOperation(askExtractMode));
- RINOK(MyCopyFile(outStreamLoc));
- return SetOperationResult(NArchive::NExtract::NOperationResult::kOK);
- }
-
- if (isCopyLink && _testMode)
- return S_OK;
-
- #endif
- */
-
- *outStream = outStreamLoc.Detach();
- }
-
- return S_OK;
-
- COM_TRY_END
-}
-
-
-STDMETHODIMP CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode)
-{
- COM_TRY_BEGIN
-
- #ifndef _SFX
- if (ExtractToStreamCallback)
- return ExtractToStreamCallback->PrepareOperation7(askExtractMode);
- #endif
-
- _extractMode = false;
-
- switch (askExtractMode)
- {
- case NArchive::NExtract::NAskMode::kExtract:
- if (_testMode)
- askExtractMode = NArchive::NExtract::NAskMode::kTest;
- else
- _extractMode = true;
- break;
- };
-
- return _extractCallback2->PrepareOperation(_item.Path, BoolToInt(_item.IsDir),
- askExtractMode, _isSplit ? &_position: 0);
-
- COM_TRY_END
-}
-
-
-HRESULT CArchiveExtractCallback::CloseFile()
-{
- if (!_outFileStream)
- return S_OK;
-
- HRESULT hres = S_OK;
- _outFileStreamSpec->SetTime(
- (WriteCTime && _fi.CTimeDefined) ? &_fi.CTime : NULL,
- (WriteATime && _fi.ATimeDefined) ? &_fi.ATime : NULL,
- (WriteMTime && _fi.MTimeDefined) ? &_fi.MTime : (_arc->MTimeDefined ? &_arc->MTime : NULL));
-
- const UInt64 processedSize = _outFileStreamSpec->ProcessedSize;
- if (_fileLengthWasSet && _curSize > processedSize)
- {
- bool res = _outFileStreamSpec->File.SetLength(processedSize);
- _fileLengthWasSet = res;
- if (!res)
- hres = SendMessageError_with_LastError(kCantSetFileLen, us2fs(_item.Path));
- }
- _curSize = processedSize;
- _curSizeDefined = true;
- RINOK(_outFileStreamSpec->Close());
- _outFileStream.Release();
- return hres;
-}
-
-
-STDMETHODIMP CArchiveExtractCallback::SetOperationResult(Int32 opRes)
-{
- COM_TRY_BEGIN
-
- #ifndef _SFX
- if (ExtractToStreamCallback)
- return ExtractToStreamCallback->SetOperationResult7(opRes, BoolToInt(_encrypted));
- #endif
-
- #ifndef _SFX
-
- if (_hashStreamWasUsed)
- {
- _hashStreamSpec->_hash->Final(_item.IsDir,
- #ifdef SUPPORT_ALT_STREAMS
- _item.IsAltStream
- #else
- false
- #endif
- , _item.Path);
- _curSize = _hashStreamSpec->GetSize();
- _curSizeDefined = true;
- _hashStreamSpec->ReleaseStream();
- _hashStreamWasUsed = false;
- }
-
- #endif
-
- RINOK(CloseFile());
-
- #ifdef _USE_SECURITY_CODE
- if (!_stdOutMode && _extractMode && _ntOptions.NtSecurity.Val && _arc->GetRawProps)
- {
- const void *data;
- UInt32 dataSize;
- UInt32 propType;
- _arc->GetRawProps->GetRawProp(_index, kpidNtSecure, &data, &dataSize, &propType);
- if (dataSize != 0)
- {
- if (propType != NPropDataType::kRaw)
- return E_FAIL;
- if (CheckNtSecure((const Byte *)data, dataSize))
- {
- SECURITY_INFORMATION securInfo = DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION;
- if (_saclEnabled)
- securInfo |= SACL_SECURITY_INFORMATION;
- ::SetFileSecurityW(fs2us(_diskFilePath), securInfo, (PSECURITY_DESCRIPTOR)(void *)data);
- }
- }
- }
- #endif
-
- if (!_curSizeDefined)
- GetUnpackSize();
-
- if (_curSizeDefined)
- {
- #ifdef SUPPORT_ALT_STREAMS
- if (_item.IsAltStream)
- AltStreams_UnpackSize += _curSize;
- else
- #endif
- UnpackSize += _curSize;
- }
-
- if (_item.IsDir)
- NumFolders++;
- #ifdef SUPPORT_ALT_STREAMS
- else if (_item.IsAltStream)
- NumAltStreams++;
- #endif
- else
- NumFiles++;
-
- if (!_stdOutMode && _extractMode && _fi.AttribDefined)
- SetFileAttrib_PosixHighDetect(_diskFilePath, _fi.Attrib);
-
- RINOK(_extractCallback2->SetOperationResult(opRes, BoolToInt(_encrypted)));
-
- return S_OK;
-
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveExtractCallback::ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes)
-{
- if (_folderArchiveExtractCallback2)
- {
- bool isEncrypted = false;
- UString s;
-
- if (indexType == NArchive::NEventIndexType::kInArcIndex && index != (UInt32)(Int32)-1)
- {
- CReadArcItem item;
- RINOK(_arc->GetItem(index, item));
- s = item.Path;
- RINOK(Archive_GetItemBoolProp(_arc->Archive, index, kpidEncrypted, isEncrypted));
- }
- else
- {
- s = '#';
- s.Add_UInt32(index);
- // if (indexType == NArchive::NEventIndexType::kBlockIndex) {}
- }
-
- return _folderArchiveExtractCallback2->ReportExtractResult(opRes, isEncrypted, s);
- }
-
- return S_OK;
-}
-
-
-STDMETHODIMP CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password)
-{
- COM_TRY_BEGIN
- if (!_cryptoGetTextPassword)
- {
- RINOK(_extractCallback2.QueryInterface(IID_ICryptoGetTextPassword,
- &_cryptoGetTextPassword));
- }
- return _cryptoGetTextPassword->CryptoGetTextPassword(password);
- COM_TRY_END
-}
-
-
-void CDirPathSortPair::SetNumSlashes(const FChar *s)
-{
- for (unsigned numSlashes = 0;;)
- {
- FChar c = *s++;
- if (c == 0)
- {
- Len = numSlashes;
- return;
- }
- if (IS_PATH_SEPAR(c))
- numSlashes++;
- }
-}
-
-
-bool CDirPathTime::SetDirTime()
-{
- return NDir::SetDirTime(Path,
- CTimeDefined ? &CTime : NULL,
- ATimeDefined ? &ATime : NULL,
- MTimeDefined ? &MTime : NULL);
-}
-
-
-HRESULT CArchiveExtractCallback::SetDirsTimes()
-{
- if (!_arc)
- return S_OK;
-
- CRecordVector<CDirPathSortPair> pairs;
- pairs.ClearAndSetSize(_extractedFolders.Size());
- unsigned i;
-
- for (i = 0; i < _extractedFolders.Size(); i++)
- {
- CDirPathSortPair &pair = pairs[i];
- pair.Index = i;
- pair.SetNumSlashes(_extractedFolders[i].Path);
- }
-
- pairs.Sort2();
-
- for (i = 0; i < pairs.Size(); i++)
- {
- _extractedFolders[pairs[i].Index].SetDirTime();
- // if (!) return GetLastError();
- }
-
- ClearExtractedDirsInfo();
- return S_OK;
-}
-
-
-HRESULT CArchiveExtractCallback::CloseArc()
-{
- HRESULT res = CloseFile();
- HRESULT res2 = SetDirsTimes();
- if (res == S_OK)
- res = res2;
- _arc = NULL;
- return res;
-}
+// ArchiveExtractCallback.cpp
+
+#include "StdAfx.h"
+
+#undef sprintf
+#undef printf
+
+// #include <stdio.h>
+// #include "../../../../C/CpuTicks.h"
+
+#include "../../../../C/Alloc.h"
+#include "../../../../C/CpuArch.h"
+
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+#define Z7_USE_SECURITY_CODE
+#include "../../../Windows/SecurityUtils.h"
+#endif
+
+#include "../../Common/FilePathAutoRename.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../Common/ExtractingFilePath.h"
+#include "../Common/PropIDUtils.h"
+
+#include "ArchiveExtractCallback.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static const char * const kCantAutoRename = "Cannot create file with auto name";
+static const char * const kCantRenameFile = "Cannot rename existing file";
+static const char * const kCantDeleteOutputFile = "Cannot delete output file";
+static const char * const kCantDeleteOutputDir = "Cannot delete output folder";
+static const char * const kCantOpenOutFile = "Cannot open output file";
+static const char * const kCantOpenInFile = "Cannot open input file";
+static const char * const kCantSetFileLen = "Cannot set length for output file";
+#ifdef SUPPORT_LINKS
+static const char * const kCantCreateHardLink = "Cannot create hard link";
+static const char * const kCantCreateSymLink = "Cannot create symbolic link";
+#endif
+
+#ifndef Z7_SFX
+
+Z7_COM7F_IMF(COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ HRESULT result = S_OK;
+ if (_stream)
+ result = _stream->Write(data, size, &size);
+ if (_calculate)
+ _hash->Update(data, size);
+ _size += size;
+ if (processedSize)
+ *processedSize = size;
+ return result;
+}
+
+#endif // Z7_SFX
+
+
+#ifdef Z7_USE_SECURITY_CODE
+bool InitLocalPrivileges();
+bool InitLocalPrivileges()
+{
+ NSecurity::CAccessToken token;
+ if (!token.OpenProcessToken(GetCurrentProcess(),
+ TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES))
+ return false;
+
+ TOKEN_PRIVILEGES tp;
+
+ tp.PrivilegeCount = 1;
+ tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+ if (!::LookupPrivilegeValue(NULL, SE_SECURITY_NAME, &tp.Privileges[0].Luid))
+ return false;
+ if (!token.AdjustPrivileges(&tp))
+ return false;
+ return (GetLastError() == ERROR_SUCCESS);
+}
+#endif // Z7_USE_SECURITY_CODE
+
+
+
+#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+
+static const char * const kOfficeExtensions =
+ " doc dot wbk"
+ " docx docm dotx dotm docb wll wwl"
+ " xls xlt xlm"
+ " xlsx xlsm xltx xltm xlsb xla xlam"
+ " ppt pot pps ppa ppam"
+ " pptx pptm potx potm ppam ppsx ppsm sldx sldm"
+ " ";
+
+static bool FindExt2(const char *p, const UString &name)
+{
+ const int pathPos = name.ReverseFind_PathSepar();
+ const int dotPos = name.ReverseFind_Dot();
+ if (dotPos < 0
+ || dotPos < pathPos
+ || dotPos == (int)name.Len() - 1)
+ return false;
+
+ AString s;
+ for (unsigned pos = (unsigned)(dotPos + 1);; pos++)
+ {
+ const wchar_t c = name[pos];
+ if (c <= 0)
+ break;
+ if (c >= 0x80)
+ return false;
+ s += (char)MyCharLower_Ascii((char)c);
+ }
+ for (unsigned i = 0; p[i] != 0;)
+ {
+ unsigned j;
+ for (j = i; p[j] != ' '; j++);
+ if (s.Len() == j - i && memcmp(p + i, (const char *)s, s.Len()) == 0)
+ return true;
+ i = j + 1;
+ }
+ return false;
+}
+
+
+static const FChar * const k_ZoneId_StreamName = FTEXT(":Zone.Identifier");
+
+void ReadZoneFile_Of_BaseFile(CFSTR fileName2, CByteBuffer &buf)
+{
+ FString fileName (fileName2);
+ fileName += k_ZoneId_StreamName;
+
+ buf.Free();
+ NIO::CInFile file;
+ if (!file.Open(fileName))
+ return;
+ UInt64 fileSize;
+ if (!file.GetLength(fileSize))
+ return;
+ if (fileSize == 0 || fileSize >= ((UInt32)1 << 16))
+ return;
+ buf.Alloc((size_t)fileSize);
+ size_t processed;
+ if (file.ReadFull(buf, (size_t)fileSize, processed) && processed == fileSize)
+ return;
+ buf.Free();
+}
+
+static bool WriteZoneFile(CFSTR fileName, const CByteBuffer &buf)
+{
+ NIO::COutFile file;
+ if (!file.Create(fileName, true))
+ return false;
+ return file.WriteFull(buf, buf.Size());
+}
+
+#endif
+
+
+#ifdef SUPPORT_LINKS
+
+int CHardLinkNode::Compare(const CHardLinkNode &a) const
+{
+ if (StreamId < a.StreamId) return -1;
+ if (StreamId > a.StreamId) return 1;
+ return MyCompare(INode, a.INode);
+}
+
+static HRESULT Archive_Get_HardLinkNode(IInArchive *archive, UInt32 index, CHardLinkNode &h, bool &defined)
+{
+ h.INode = 0;
+ h.StreamId = (UInt64)(Int64)-1;
+ defined = false;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidINode, &prop))
+ if (!ConvertPropVariantToUInt64(prop, h.INode))
+ return S_OK;
+ }
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidStreamId, &prop))
+ ConvertPropVariantToUInt64(prop, h.StreamId);
+ }
+ defined = true;
+ return S_OK;
+}
+
+
+HRESULT CArchiveExtractCallback::PrepareHardLinks(const CRecordVector<UInt32> *realIndices)
+{
+ _hardLinks.Clear();
+
+ if (!_arc->Ask_INode)
+ return S_OK;
+
+ IInArchive *archive = _arc->Archive;
+ CRecordVector<CHardLinkNode> &hardIDs = _hardLinks.IDs;
+
+ {
+ UInt32 numItems;
+ if (realIndices)
+ numItems = realIndices->Size();
+ else
+ {
+ RINOK(archive->GetNumberOfItems(&numItems))
+ }
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ CHardLinkNode h;
+ bool defined;
+ const UInt32 realIndex = realIndices ? (*realIndices)[i] : i;
+
+ RINOK(Archive_Get_HardLinkNode(archive, realIndex, h, defined))
+ if (defined)
+ {
+ bool isAltStream = false;
+ RINOK(Archive_IsItem_AltStream(archive, realIndex, isAltStream))
+ if (!isAltStream)
+ {
+ bool isDir = false;
+ RINOK(Archive_IsItem_Dir(archive, realIndex, isDir))
+ if (!isDir)
+ hardIDs.Add(h);
+ }
+ }
+ }
+ }
+
+ hardIDs.Sort2();
+
+ {
+ // we keep only items that have 2 or more items
+ unsigned k = 0;
+ unsigned numSame = 1;
+ for (unsigned i = 1; i < hardIDs.Size(); i++)
+ {
+ if (hardIDs[i].Compare(hardIDs[i - 1]) != 0)
+ numSame = 1;
+ else if (++numSame == 2)
+ {
+ if (i - 1 != k)
+ hardIDs[k] = hardIDs[i - 1];
+ k++;
+ }
+ }
+ hardIDs.DeleteFrom(k);
+ }
+
+ _hardLinks.PrepareLinks();
+ return S_OK;
+}
+
+#endif // SUPPORT_LINKS
+
+
+CArchiveExtractCallback::CArchiveExtractCallback():
+ _arc(NULL),
+ Write_CTime(true),
+ Write_ATime(true),
+ Write_MTime(true),
+ _multiArchives(false)
+{
+ LocalProgressSpec = new CLocalProgress();
+ _localProgress = LocalProgressSpec;
+
+ #ifdef Z7_USE_SECURITY_CODE
+ _saclEnabled = InitLocalPrivileges();
+ #endif
+}
+
+
+void CArchiveExtractCallback::InitBeforeNewArchive()
+{
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ ZoneBuf.Free();
+ #endif
+}
+
+void CArchiveExtractCallback::Init(
+ const CExtractNtOptions &ntOptions,
+ const NWildcard::CCensorNode *wildcardCensor,
+ const CArc *arc,
+ IFolderArchiveExtractCallback *extractCallback2,
+ bool stdOutMode, bool testMode,
+ const FString &directoryPath,
+ const UStringVector &removePathParts, bool removePartsForAltStreams,
+ UInt64 packSize)
+{
+ ClearExtractedDirsInfo();
+ _outFileStream.Release();
+ _bufPtrSeqOutStream.Release();
+
+ #ifdef SUPPORT_LINKS
+ _hardLinks.Clear();
+ #endif
+
+ #ifdef SUPPORT_ALT_STREAMS
+ _renamedFiles.Clear();
+ #endif
+
+ _ntOptions = ntOptions;
+ _wildcardCensor = wildcardCensor;
+
+ _stdOutMode = stdOutMode;
+ _testMode = testMode;
+
+ // _progressTotal = 0;
+ // _progressTotal_Defined = false;
+
+ _packTotal = packSize;
+ _progressTotal = packSize;
+ _progressTotal_Defined = true;
+
+ _extractCallback2 = extractCallback2;
+
+ /*
+ _compressProgress.Release();
+ _extractCallback2.QueryInterface(IID_ICompressProgressInfo, &_compressProgress);
+
+ _callbackMessage.Release();
+ _extractCallback2.QueryInterface(IID_IArchiveExtractCallbackMessage2, &_callbackMessage);
+ */
+
+ _folderArchiveExtractCallback2.Release();
+ _extractCallback2.QueryInterface(IID_IFolderArchiveExtractCallback2, &_folderArchiveExtractCallback2);
+
+ #ifndef Z7_SFX
+
+ ExtractToStreamCallback.Release();
+ _extractCallback2.QueryInterface(IID_IFolderExtractToStreamCallback, &ExtractToStreamCallback);
+ if (ExtractToStreamCallback)
+ {
+ Int32 useStreams = 0;
+ if (ExtractToStreamCallback->UseExtractToStream(&useStreams) != S_OK)
+ useStreams = 0;
+ if (useStreams == 0)
+ ExtractToStreamCallback.Release();
+ }
+
+ #endif
+
+ LocalProgressSpec->Init(extractCallback2, true);
+ LocalProgressSpec->SendProgress = false;
+
+ _removePathParts = removePathParts;
+ _removePartsForAltStreams = removePartsForAltStreams;
+
+ #ifndef Z7_SFX
+ _baseParentFolder = (UInt32)(Int32)-1;
+ _use_baseParentFolder_mode = false;
+ #endif
+
+ _arc = arc;
+ _dirPathPrefix = directoryPath;
+ _dirPathPrefix_Full = directoryPath;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (!NName::IsAltPathPrefix(_dirPathPrefix))
+ #endif
+ {
+ NName::NormalizeDirPathPrefix(_dirPathPrefix);
+ NDir::MyGetFullPathName(directoryPath, _dirPathPrefix_Full);
+ NName::NormalizeDirPathPrefix(_dirPathPrefix_Full);
+ }
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetTotal(UInt64 size))
+{
+ COM_TRY_BEGIN
+ _progressTotal = size;
+ _progressTotal_Defined = true;
+ if (!_multiArchives && _extractCallback2)
+ return _extractCallback2->SetTotal(size);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+static void NormalizeVals(UInt64 &v1, UInt64 &v2)
+{
+ const UInt64 kMax = (UInt64)1 << 31;
+ while (v1 > kMax)
+ {
+ v1 >>= 1;
+ v2 >>= 1;
+ }
+}
+
+
+static UInt64 MyMultDiv64(UInt64 unpCur, UInt64 unpTotal, UInt64 packTotal)
+{
+ NormalizeVals(packTotal, unpTotal);
+ NormalizeVals(unpCur, unpTotal);
+ if (unpTotal == 0)
+ unpTotal = 1;
+ return unpCur * packTotal / unpTotal;
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetCompleted(const UInt64 *completeValue))
+{
+ COM_TRY_BEGIN
+
+ if (!_extractCallback2)
+ return S_OK;
+
+ UInt64 packCur;
+ if (_multiArchives)
+ {
+ packCur = LocalProgressSpec->InSize;
+ if (completeValue && _progressTotal_Defined)
+ packCur += MyMultDiv64(*completeValue, _progressTotal, _packTotal);
+ completeValue = &packCur;
+ }
+ return _extractCallback2->SetCompleted(completeValue);
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ COM_TRY_BEGIN
+ return _localProgress->SetRatioInfo(inSize, outSize);
+ COM_TRY_END
+}
+
+
+void CArchiveExtractCallback::CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath)
+{
+ // we use (_item.IsDir) in this function
+
+ bool isAbsPath = false;
+
+ if (!dirPathParts.IsEmpty())
+ {
+ const UString &s = dirPathParts[0];
+ if (s.IsEmpty())
+ isAbsPath = true;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ else
+ {
+ if (NName::IsDrivePath2(s))
+ isAbsPath = true;
+ }
+ #endif
+ }
+
+ if (_pathMode == NExtract::NPathMode::kAbsPaths && isAbsPath)
+ fullPath.Empty();
+ else
+ fullPath = _dirPathPrefix;
+
+ FOR_VECTOR (i, dirPathParts)
+ {
+ if (i != 0)
+ fullPath.Add_PathSepar();
+ const UString &s = dirPathParts[i];
+ fullPath += us2fs(s);
+
+ const bool isFinalDir = (i == dirPathParts.Size() - 1 && _item.IsDir);
+
+ if (fullPath.IsEmpty())
+ {
+ if (isFinalDir)
+ _itemFailure = true;
+ continue;
+ }
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (_pathMode == NExtract::NPathMode::kAbsPaths)
+ if (i == 0 && s.Len() == 2 && NName::IsDrivePath2(s))
+ {
+ if (isFinalDir)
+ {
+ // we don't want to call SetAttrib() for root drive path
+ _itemFailure = true;
+ }
+ continue;
+ }
+ #endif
+
+ // bool res =
+ CreateDir(fullPath);
+ // if (!res)
+ if (isFinalDir)
+ {
+ if (!NFile::NFind::DoesDirExist(fullPath))
+ {
+ _itemFailure = true;
+ SendMessageError("Cannot create folder", fullPath);
+ // SendMessageError_with_LastError()
+ }
+ }
+ }
+}
+
+
+HRESULT CArchiveExtractCallback::GetTime(UInt32 index, PROPID propID, CArcTime &ft)
+{
+ ft.Clear();
+ NCOM::CPropVariant prop;
+ RINOK(_arc->Archive->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ ft.Set_From_Prop(prop);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+
+HRESULT CArchiveExtractCallback::GetUnpackSize()
+{
+ return _arc->GetItem_Size(_index, _curSize, _curSize_Defined);
+}
+
+static void AddPathToMessage(UString &s, const FString &path)
+{
+ s += " : ";
+ s += fs2us(path);
+}
+
+HRESULT CArchiveExtractCallback::SendMessageError(const char *message, const FString &path)
+{
+ UString s (message);
+ AddPathToMessage(s, path);
+ return _extractCallback2->MessageError(s);
+}
+
+HRESULT CArchiveExtractCallback::SendMessageError_with_LastError(const char *message, const FString &path)
+{
+ DWORD errorCode = GetLastError();
+ if (errorCode == 0)
+ errorCode = (DWORD)E_FAIL;
+ UString s (message);
+ {
+ s += " : ";
+ s += NError::MyFormatMessage(errorCode);
+ }
+ AddPathToMessage(s, path);
+ return _extractCallback2->MessageError(s);
+}
+
+HRESULT CArchiveExtractCallback::SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2)
+{
+ UString s (message);
+ if (errorCode != 0)
+ {
+ s += " : ";
+ s += NError::MyFormatMessage(errorCode);
+ }
+ AddPathToMessage(s, path1);
+ AddPathToMessage(s, path2);
+ return _extractCallback2->MessageError(s);
+}
+
+#ifndef Z7_SFX
+
+Z7_COM7F_IMF(CGetProp::GetProp(PROPID propID, PROPVARIANT *value))
+{
+ /*
+ if (propID == kpidName)
+ {
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop = Name;
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+ }
+ */
+ return Arc->Archive->GetProperty(IndexInArc, propID, value);
+}
+
+#endif // Z7_SFX
+
+
+#ifdef SUPPORT_LINKS
+
+static UString GetDirPrefixOf(const UString &src)
+{
+ UString s (src);
+ if (!s.IsEmpty())
+ {
+ if (IsPathSepar(s.Back()))
+ s.DeleteBack();
+ int pos = s.ReverseFind_PathSepar();
+ s.DeleteFrom((unsigned)(pos + 1));
+ }
+ return s;
+}
+
+#endif // SUPPORT_LINKS
+
+struct CLinkLevelsInfo
+{
+ bool IsAbsolute;
+ int LowLevel;
+ int FinalLevel;
+
+ void Parse(const UString &path);
+};
+
+void CLinkLevelsInfo::Parse(const UString &path)
+{
+ IsAbsolute = NName::IsAbsolutePath(path);
+
+ LowLevel = 0;
+ FinalLevel = 0;
+
+ UStringVector parts;
+ SplitPathToParts(path, parts);
+ int level = 0;
+
+ FOR_VECTOR (i, parts)
+ {
+ const UString &s = parts[i];
+ if (s.IsEmpty())
+ {
+ if (i == 0)
+ IsAbsolute = true;
+ continue;
+ }
+ if (s == L".")
+ continue;
+ if (s == L"..")
+ {
+ level--;
+ if (LowLevel > level)
+ LowLevel = level;
+ }
+ else
+ level++;
+ }
+
+ FinalLevel = level;
+}
+
+
+bool IsSafePath(const UString &path);
+bool IsSafePath(const UString &path)
+{
+ CLinkLevelsInfo levelsInfo;
+ levelsInfo.Parse(path);
+ return !levelsInfo.IsAbsolute
+ && levelsInfo.LowLevel >= 0
+ && levelsInfo.FinalLevel > 0;
+}
+
+
+bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include);
+bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include)
+{
+ bool found = false;
+
+ // CheckPathVect() doesn't check path to Parent nodes
+ if (node.CheckPathVect(item.PathParts, !item.MainIsDir, include))
+ {
+ if (!include)
+ return true;
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (!item.IsAltStream)
+ return true;
+ #endif
+
+ found = true;
+ }
+
+ #ifdef SUPPORT_ALT_STREAMS
+
+ if (!item.IsAltStream)
+ return false;
+
+ UStringVector pathParts2 = item.PathParts;
+ if (pathParts2.IsEmpty())
+ pathParts2.AddNew();
+ UString &back = pathParts2.Back();
+ back += ':';
+ back += item.AltStreamName;
+ bool include2;
+
+ if (node.CheckPathVect(pathParts2,
+ true, // isFile,
+ include2))
+ {
+ include = include2;
+ return true;
+ }
+
+ #endif // SUPPORT_ALT_STREAMS
+
+ return found;
+}
+
+
+bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item)
+{
+ bool include;
+ if (CensorNode_CheckPath2(node, item, include))
+ return include;
+ return false;
+}
+
+
+static FString MakePath_from_2_Parts(const FString &prefix, const FString &path)
+{
+ FString s (prefix);
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (!path.IsEmpty() && path[0] == ':' && !prefix.IsEmpty() && IsPathSepar(prefix.Back()))
+ {
+ if (!NName::IsDriveRootPath_SuperAllowed(prefix))
+ s.DeleteBack();
+ }
+ #endif
+ s += path;
+ return s;
+}
+
+
+
+#ifdef SUPPORT_LINKS
+
+/*
+struct CTempMidBuffer
+{
+ void *Buf;
+
+ CTempMidBuffer(size_t size): Buf(NULL) { Buf = ::MidAlloc(size); }
+ ~CTempMidBuffer() { ::MidFree(Buf); }
+};
+
+HRESULT CArchiveExtractCallback::MyCopyFile(ISequentialOutStream *outStream)
+{
+ const size_t kBufSize = 1 << 16;
+ CTempMidBuffer buf(kBufSize);
+ if (!buf.Buf)
+ return E_OUTOFMEMORY;
+
+ NIO::CInFile inFile;
+ NIO::COutFile outFile;
+
+ if (!inFile.Open(_copyFile_Path))
+ return SendMessageError_with_LastError("Open error", _copyFile_Path);
+
+ for (;;)
+ {
+ UInt32 num;
+
+ if (!inFile.Read(buf.Buf, kBufSize, num))
+ return SendMessageError_with_LastError("Read error", _copyFile_Path);
+
+ if (num == 0)
+ return S_OK;
+
+
+ RINOK(WriteStream(outStream, buf.Buf, num));
+ }
+}
+*/
+
+
+HRESULT CArchiveExtractCallback::ReadLink()
+{
+ IInArchive *archive = _arc->Archive;
+ const UInt32 index = _index;
+ _link.Clear();
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidHardLink, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ _link.isHardLink = true;
+ // _link.isCopyLink = false;
+ _link.isRelative = false; // RAR5, TAR: hard links are from root folder of archive
+ _link.linkPath.SetFromBstr(prop.bstrVal);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ }
+
+ /*
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidCopyLink, &prop));
+ if (prop.vt == VT_BSTR)
+ {
+ _link.isHardLink = false;
+ _link.isCopyLink = true;
+ _link.isRelative = false; // RAR5: copy links are from root folder of archive
+ _link.linkPath.SetFromBstr(prop.bstrVal);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ }
+ */
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidSymLink, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ _link.isHardLink = false;
+ // _link.isCopyLink = false;
+ _link.isRelative = true; // RAR5, TAR: symbolic links can be relative
+ _link.linkPath.SetFromBstr(prop.bstrVal);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ }
+
+ NtReparse_Data = NULL;
+ NtReparse_Size = 0;
+
+ if (_link.linkPath.IsEmpty() && _arc->GetRawProps)
+ {
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+
+ _arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType);
+
+ // if (dataSize == 1234567) // for debug: unpacking without reparse
+ if (dataSize != 0)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+
+ // 21.06: we need kpidNtReparse in linux for wim archives created in Windows
+ // #ifdef _WIN32
+
+ NtReparse_Data = data;
+ NtReparse_Size = dataSize;
+
+ CReparseAttr reparse;
+ bool isOkReparse = reparse.Parse((const Byte *)data, dataSize);
+ if (isOkReparse)
+ {
+ _link.isHardLink = false;
+ // _link.isCopyLink = false;
+ _link.linkPath = reparse.GetPath();
+ _link.isJunction = reparse.IsMountPoint();
+
+ if (reparse.IsSymLink_WSL())
+ {
+ _link.isWSL = true;
+ _link.isRelative = reparse.IsRelative_WSL();
+ }
+ else
+ _link.isRelative = reparse.IsRelative_Win();
+
+ // const AString s = GetAnsiString(_link.linkPath);
+ // printf("\n_link.linkPath: %s\n", s.Ptr());
+
+ #ifndef _WIN32
+ _link.linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
+ #endif
+ }
+ // #endif
+ }
+ }
+
+ if (_link.linkPath.IsEmpty())
+ return S_OK;
+
+ {
+ #ifdef _WIN32
+ _link.linkPath.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+
+ // rar5 uses "\??\" prefix for absolute links
+ if (_link.linkPath.IsPrefixedBy(WSTRING_PATH_SEPARATOR L"??" WSTRING_PATH_SEPARATOR))
+ {
+ _link.isRelative = false;
+ _link.linkPath.DeleteFrontal(4);
+ }
+
+ for (;;)
+ // while (NName::IsAbsolutePath(linkPath))
+ {
+ unsigned n = NName::GetRootPrefixSize(_link.linkPath);
+ if (n == 0)
+ break;
+ _link.isRelative = false;
+ _link.linkPath.DeleteFrontal(n);
+ }
+ }
+
+ if (_link.linkPath.IsEmpty())
+ return S_OK;
+
+ if (!_link.isRelative && _removePathParts.Size() != 0)
+ {
+ UStringVector pathParts;
+ SplitPathToParts(_link.linkPath, pathParts);
+ bool badPrefix = false;
+ FOR_VECTOR (i, _removePathParts)
+ {
+ if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
+ {
+ badPrefix = true;
+ break;
+ }
+ }
+ if (!badPrefix)
+ pathParts.DeleteFrontal(_removePathParts.Size());
+ _link.linkPath = MakePathFromParts(pathParts);
+ }
+
+ /*
+ if (!_link.linkPath.IsEmpty())
+ {
+ printf("\n_link %s to -> %s\n", GetOemString(_item.Path).Ptr(), GetOemString(_link.linkPath).Ptr());
+ }
+ */
+
+ return S_OK;
+}
+
+#endif // SUPPORT_LINKS
+
+
+#ifndef _WIN32
+
+static HRESULT GetOwner(IInArchive *archive,
+ UInt32 index, UInt32 pidName, UInt32 pidId, COwnerInfo &res)
+{
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, pidId, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ res.Id_Defined = true;
+ res.Id = prop.ulVal; // for debug
+ // res.Id++; // for debug
+ // if (pidId == kpidGroupId) res.Id += 7; // for debug
+ // res.Id = 0; // for debug
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ {
+ NWindows::NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, pidName, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ const UString s = prop.bstrVal;
+ ConvertUnicodeToUTF8(s, res.Name);
+ }
+ else if (prop.vt == VT_UI4)
+ {
+ res.Id_Defined = true;
+ res.Id = prop.ulVal;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ }
+ return S_OK;
+}
+
+#endif
+
+
+HRESULT CArchiveExtractCallback::Read_fi_Props()
+{
+ IInArchive *archive = _arc->Archive;
+ const UInt32 index = _index;
+
+ _fi.Attrib_Defined = false;
+
+ #ifndef _WIN32
+ _fi.Owner.Clear();
+ _fi.Group.Clear();
+ #endif
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidPosixAttrib, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ _fi.SetFromPosixAttrib(prop.ulVal);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidAttrib, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ _fi.Attrib = prop.ulVal;
+ _fi.Attrib_Defined = true;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ }
+
+ RINOK(GetTime(index, kpidCTime, _fi.CTime))
+ RINOK(GetTime(index, kpidATime, _fi.ATime))
+ RINOK(GetTime(index, kpidMTime, _fi.MTime))
+
+ #ifndef _WIN32
+ if (_ntOptions.ExtractOwner)
+ {
+ // SendMessageError_with_LastError("_ntOptions.ExtractOwner", _diskFilePath);
+ GetOwner(archive, index, kpidUser, kpidUserId, _fi.Owner);
+ GetOwner(archive, index, kpidGroup, kpidGroupId, _fi.Group);
+ }
+ #endif
+
+ return S_OK;
+}
+
+
+
+void CArchiveExtractCallback::CorrectPathParts()
+{
+ UStringVector &pathParts = _item.PathParts;
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (!_item.IsAltStream
+ || !pathParts.IsEmpty()
+ || !(_removePartsForAltStreams || _pathMode == NExtract::NPathMode::kNoPathsAlt))
+ #endif
+ Correct_FsPath(_pathMode == NExtract::NPathMode::kAbsPaths, _keepAndReplaceEmptyDirPrefixes, pathParts, _item.MainIsDir);
+
+ #ifdef SUPPORT_ALT_STREAMS
+
+ if (_item.IsAltStream)
+ {
+ UString s (_item.AltStreamName);
+ Correct_AltStream_Name(s);
+ bool needColon = true;
+
+ if (pathParts.IsEmpty())
+ {
+ pathParts.AddNew();
+ if (_removePartsForAltStreams || _pathMode == NExtract::NPathMode::kNoPathsAlt)
+ needColon = false;
+ }
+ #ifdef _WIN32
+ else if (_pathMode == NExtract::NPathMode::kAbsPaths &&
+ NWildcard::GetNumPrefixParts_if_DrivePath(pathParts) == pathParts.Size())
+ pathParts.AddNew();
+ #endif
+
+ UString &name = pathParts.Back();
+ if (needColon)
+ name += (char)(_ntOptions.ReplaceColonForAltStream ? '_' : ':');
+ name += s;
+ }
+
+ #endif // SUPPORT_ALT_STREAMS
+}
+
+
+void CArchiveExtractCallback::GetFiTimesCAM(CFiTimesCAM &pt)
+{
+ pt.CTime_Defined = false;
+ pt.ATime_Defined = false;
+ pt.MTime_Defined = false;
+
+ if (Write_MTime)
+ {
+ if (_fi.MTime.Def)
+ {
+ _fi.MTime.Write_To_FiTime(pt.MTime);
+ pt.MTime_Defined = true;
+ }
+ else if (_arc->MTime.Def)
+ {
+ _arc->MTime.Write_To_FiTime(pt.MTime);
+ pt.MTime_Defined = true;
+ }
+ }
+
+ if (Write_CTime && _fi.CTime.Def)
+ {
+ _fi.CTime.Write_To_FiTime(pt.CTime);
+ pt.CTime_Defined = true;
+ }
+
+ if (Write_ATime && _fi.ATime.Def)
+ {
+ _fi.ATime.Write_To_FiTime(pt.ATime);
+ pt.ATime_Defined = true;
+ }
+}
+
+
+void CArchiveExtractCallback::CreateFolders()
+{
+ // 21.04 : we don't change original (_item.PathParts) here
+ UStringVector pathParts = _item.PathParts;
+
+ if (!pathParts.IsEmpty())
+ {
+ /* v23: if we extract symlink, and we know that it links to dir:
+ Linux: we don't create dir item (symlink_from_path) here.
+ Windows: SetReparseData() will create dir item, if it doesn't exist,
+ but if we create dir item here, it's not problem. */
+ if (!_item.IsDir
+ #ifdef SUPPORT_LINKS
+ #ifndef WIN32
+ || !_link.linkPath.IsEmpty()
+ #endif
+ #endif
+ )
+ pathParts.DeleteBack();
+ }
+
+ if (pathParts.IsEmpty())
+ return;
+
+ FString fullPathNew;
+ CreateComplexDirectory(pathParts, fullPathNew);
+
+ if (!_item.IsDir)
+ return;
+
+ if (_itemFailure)
+ return;
+
+ CDirPathTime pt;
+ GetFiTimesCAM(pt);
+
+ if (pt.IsSomeTimeDefined())
+ {
+ pt.Path = fullPathNew;
+ pt.SetDirTime();
+ _extractedFolders.Add(pt);
+ }
+}
+
+
+
+/*
+ CheckExistFile(fullProcessedPath)
+ it can change: fullProcessedPath, _isRenamed, _overwriteMode
+ (needExit = true) means that we must exit GetStream() even for S_OK result.
+*/
+
+HRESULT CArchiveExtractCallback::CheckExistFile(FString &fullProcessedPath, bool &needExit)
+{
+ needExit = true; // it was set already before
+
+ NFind::CFileInfo fileInfo;
+
+ if (fileInfo.Find(fullProcessedPath))
+ {
+ if (_overwriteMode == NExtract::NOverwriteMode::kSkip)
+ return S_OK;
+
+ if (_overwriteMode == NExtract::NOverwriteMode::kAsk)
+ {
+ const int slashPos = fullProcessedPath.ReverseFind_PathSepar();
+ const FString realFullProcessedPath = fullProcessedPath.Left((unsigned)(slashPos + 1)) + fileInfo.Name;
+
+ /* (fileInfo) can be symbolic link.
+ we can show final file properties here. */
+
+ FILETIME ft1;
+ FiTime_To_FILETIME(fileInfo.MTime, ft1);
+
+ Int32 overwriteResult;
+ RINOK(_extractCallback2->AskOverwrite(
+ fs2us(realFullProcessedPath), &ft1, &fileInfo.Size, _item.Path,
+ _fi.MTime.Def ? &_fi.MTime.FT : NULL,
+ _curSize_Defined ? &_curSize : NULL,
+ &overwriteResult))
+
+ switch (overwriteResult)
+ {
+ case NOverwriteAnswer::kCancel:
+ return E_ABORT;
+ case NOverwriteAnswer::kNo:
+ return S_OK;
+ case NOverwriteAnswer::kNoToAll:
+ _overwriteMode = NExtract::NOverwriteMode::kSkip;
+ return S_OK;
+
+ case NOverwriteAnswer::kYes:
+ break;
+ case NOverwriteAnswer::kYesToAll:
+ _overwriteMode = NExtract::NOverwriteMode::kOverwrite;
+ break;
+ case NOverwriteAnswer::kAutoRename:
+ _overwriteMode = NExtract::NOverwriteMode::kRename;
+ break;
+ default:
+ return E_FAIL;
+ }
+ } // NExtract::NOverwriteMode::kAsk
+
+ if (_overwriteMode == NExtract::NOverwriteMode::kRename)
+ {
+ if (!AutoRenamePath(fullProcessedPath))
+ {
+ RINOK(SendMessageError(kCantAutoRename, fullProcessedPath))
+ return E_FAIL;
+ }
+ _isRenamed = true;
+ }
+ else if (_overwriteMode == NExtract::NOverwriteMode::kRenameExisting)
+ {
+ FString existPath (fullProcessedPath);
+ if (!AutoRenamePath(existPath))
+ {
+ RINOK(SendMessageError(kCantAutoRename, fullProcessedPath))
+ return E_FAIL;
+ }
+ // MyMoveFile can rename folders. So it's OK to use it for folders too
+ if (!MyMoveFile(fullProcessedPath, existPath))
+ {
+ HRESULT errorCode = GetLastError_noZero_HRESULT();
+ RINOK(SendMessageError2(errorCode, kCantRenameFile, existPath, fullProcessedPath))
+ return E_FAIL;
+ }
+ }
+ else // not Rename*
+ {
+ if (fileInfo.IsDir())
+ {
+ // do we need to delete all files in folder?
+ if (!RemoveDir(fullProcessedPath))
+ {
+ RINOK(SendMessageError_with_LastError(kCantDeleteOutputDir, fullProcessedPath))
+ return S_OK;
+ }
+ }
+ else // fileInfo is not Dir
+ {
+ if (NFind::DoesFileExist_Raw(fullProcessedPath))
+ if (!DeleteFileAlways(fullProcessedPath))
+ if (GetLastError() != ERROR_FILE_NOT_FOUND) // check it in linux
+ {
+ RINOK(SendMessageError_with_LastError(kCantDeleteOutputFile, fullProcessedPath))
+ return S_OK;
+ // return E_FAIL;
+ }
+ } // fileInfo is not Dir
+ } // not Rename*
+ }
+ else // not Find(fullProcessedPath)
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // we need to clear READ-ONLY of parent before creating alt stream
+ int colonPos = NName::FindAltStreamColon(fullProcessedPath);
+ if (colonPos >= 0 && fullProcessedPath[(unsigned)colonPos + 1] != 0)
+ {
+ FString parentFsPath (fullProcessedPath);
+ parentFsPath.DeleteFrom((unsigned)colonPos);
+ NFind::CFileInfo parentFi;
+ if (parentFi.Find(parentFsPath))
+ {
+ if (parentFi.IsReadOnly())
+ SetFileAttrib(parentFsPath, parentFi.Attrib & ~(DWORD)FILE_ATTRIBUTE_READONLY);
+ }
+ }
+ #endif // defined(_WIN32) && !defined(UNDER_CE)
+ }
+
+ needExit = false;
+ return S_OK;
+}
+
+
+
+
+
+
+HRESULT CArchiveExtractCallback::GetExtractStream(CMyComPtr<ISequentialOutStream> &outStreamLoc, bool &needExit)
+{
+ needExit = true;
+
+ RINOK(Read_fi_Props())
+
+ #ifdef SUPPORT_LINKS
+ IInArchive *archive = _arc->Archive;
+ #endif
+
+ const UInt32 index = _index;
+
+ bool isAnti = false;
+ RINOK(_arc->IsItem_Anti(index, isAnti))
+
+ CorrectPathParts();
+ UString processedPath (MakePathFromParts(_item.PathParts));
+
+ if (!isAnti)
+ {
+ // 21.04: CreateFolders doesn't change (_item.PathParts)
+ CreateFolders();
+ }
+
+ FString fullProcessedPath (us2fs(processedPath));
+ if (_pathMode != NExtract::NPathMode::kAbsPaths
+ || !NName::IsAbsolutePath(processedPath))
+ {
+ fullProcessedPath = MakePath_from_2_Parts(_dirPathPrefix, fullProcessedPath);
+ }
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (_item.IsAltStream && _item.ParentIndex != (UInt32)(Int32)-1)
+ {
+ const int renIndex = _renamedFiles.FindInSorted(CIndexToPathPair(_item.ParentIndex));
+ if (renIndex != -1)
+ {
+ const CIndexToPathPair &pair = _renamedFiles[(unsigned)renIndex];
+ fullProcessedPath = pair.Path;
+ fullProcessedPath += ':';
+ UString s (_item.AltStreamName);
+ Correct_AltStream_Name(s);
+ fullProcessedPath += us2fs(s);
+ }
+ }
+ #endif // SUPPORT_ALT_STREAMS
+
+ if (_item.IsDir)
+ {
+ _diskFilePath = fullProcessedPath;
+ if (isAnti)
+ RemoveDir(_diskFilePath);
+ #ifdef SUPPORT_LINKS
+ if (_link.linkPath.IsEmpty())
+ #endif
+ {
+ if (!isAnti)
+ SetAttrib();
+ return S_OK;
+ }
+ }
+ else if (!_isSplit)
+ {
+ RINOK(CheckExistFile(fullProcessedPath, needExit))
+ if (needExit)
+ return S_OK;
+ needExit = true;
+ }
+
+ _diskFilePath = fullProcessedPath;
+
+
+ if (isAnti)
+ {
+ needExit = false;
+ return S_OK;
+ }
+
+ // not anti
+
+ #ifdef SUPPORT_LINKS
+
+ if (!_link.linkPath.IsEmpty())
+ {
+ #ifndef UNDER_CE
+ {
+ bool linkWasSet = false;
+ RINOK(SetFromLinkPath(fullProcessedPath, _link, linkWasSet))
+ if (linkWasSet)
+ {
+ _isSymLinkCreated = _link.IsSymLink();
+ SetAttrib();
+ // printf("\nlinkWasSet %s\n", GetAnsiString(_diskFilePath));
+ }
+ }
+ #endif // UNDER_CE
+
+ // if (_copyFile_Path.IsEmpty())
+ {
+ needExit = false;
+ return S_OK;
+ }
+ }
+
+ if (!_hardLinks.IDs.IsEmpty() && !_item.IsAltStream && !_item.IsDir)
+ {
+ CHardLinkNode h;
+ bool defined;
+ RINOK(Archive_Get_HardLinkNode(archive, index, h, defined))
+ if (defined)
+ {
+ const int linkIndex = _hardLinks.IDs.FindInSorted2(h);
+ if (linkIndex != -1)
+ {
+ FString &hl = _hardLinks.Links[(unsigned)linkIndex];
+ if (hl.IsEmpty())
+ hl = fullProcessedPath;
+ else
+ {
+ if (!MyCreateHardLink(fullProcessedPath, hl))
+ {
+ HRESULT errorCode = GetLastError_noZero_HRESULT();
+ RINOK(SendMessageError2(errorCode, kCantCreateHardLink, fullProcessedPath, hl))
+ return S_OK;
+ }
+
+ // printf("\nHard linkWasSet Archive_Get_HardLinkNode %s\n", GetAnsiString(_diskFilePath));
+ // _needSetAttrib = true; // do we need to set attribute ?
+ SetAttrib();
+ needExit = false;
+ return S_OK;
+ }
+ }
+ }
+ }
+
+ #endif // SUPPORT_LINKS
+
+
+ // ---------- CREATE WRITE FILE -----
+
+ _outFileStreamSpec = new COutFileStream;
+ CMyComPtr<IOutStream> outFileStream_Loc(_outFileStreamSpec);
+
+ if (!_outFileStreamSpec->Open(fullProcessedPath, _isSplit ? OPEN_ALWAYS: CREATE_ALWAYS))
+ {
+ // if (::GetLastError() != ERROR_FILE_EXISTS || !isSplit)
+ {
+ RINOK(SendMessageError_with_LastError(kCantOpenOutFile, fullProcessedPath))
+ return S_OK;
+ }
+ }
+
+ _needSetAttrib = true;
+
+ bool is_SymLink_in_Data = false;
+
+ if (_curSize_Defined && _curSize > 0 && _curSize < (1 << 12))
+ {
+ if (_fi.IsLinuxSymLink())
+ {
+ is_SymLink_in_Data = true;
+ _is_SymLink_in_Data_Linux = true;
+ }
+ else if (_fi.IsReparse())
+ {
+ is_SymLink_in_Data = true;
+ _is_SymLink_in_Data_Linux = false;
+ }
+ }
+
+ if (is_SymLink_in_Data)
+ {
+ _outMemBuf.Alloc((size_t)_curSize);
+ _bufPtrSeqOutStream_Spec = new CBufPtrSeqOutStream;
+ _bufPtrSeqOutStream = _bufPtrSeqOutStream_Spec;
+ _bufPtrSeqOutStream_Spec->Init(_outMemBuf, _outMemBuf.Size());
+ outStreamLoc = _bufPtrSeqOutStream;
+ }
+ else // not reprase
+ {
+ if (_ntOptions.PreAllocateOutFile && !_isSplit && _curSize_Defined && _curSize > (1 << 12))
+ {
+ // UInt64 ticks = GetCpuTicks();
+ _fileLength_that_WasSet = _curSize;
+ bool res = _outFileStreamSpec->File.SetLength(_curSize);
+ _fileLength_WasSet = res;
+
+ // ticks = GetCpuTicks() - ticks;
+ // printf("\nticks = %10d\n", (unsigned)ticks);
+ if (!res)
+ {
+ RINOK(SendMessageError_with_LastError(kCantSetFileLen, fullProcessedPath))
+ }
+
+ /*
+ _outFileStreamSpec->File.Close();
+ ticks = GetCpuTicks() - ticks;
+ printf("\nticks = %10d\n", (unsigned)ticks);
+ return S_FALSE;
+ */
+
+ /*
+ File.SetLength() on FAT (xp64): is fast, but then File.Close() can be slow,
+ if we don't write any data.
+ File.SetLength() for remote share file (exFAT) can be slow in some cases,
+ and the Windows can return "network error" after 1 minute,
+ while remote file still can grow.
+ We need some way to detect such bad cases and disable PreAllocateOutFile mode.
+ */
+
+ res = _outFileStreamSpec->SeekToBegin_bool();
+ if (!res)
+ {
+ RINOK(SendMessageError_with_LastError("Cannot seek to begin of file", fullProcessedPath))
+ }
+ } // PreAllocateOutFile
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (_isRenamed && !_item.IsAltStream)
+ {
+ CIndexToPathPair pair(index, fullProcessedPath);
+ unsigned oldSize = _renamedFiles.Size();
+ unsigned insertIndex = _renamedFiles.AddToUniqueSorted(pair);
+ if (oldSize == _renamedFiles.Size())
+ _renamedFiles[insertIndex].Path = fullProcessedPath;
+ }
+ #endif // SUPPORT_ALT_STREAMS
+
+ if (_isSplit)
+ {
+ RINOK(outFileStream_Loc->Seek((Int64)_position, STREAM_SEEK_SET, NULL))
+ }
+ outStreamLoc = outFileStream_Loc;
+ } // if not reprase
+
+ _outFileStream = outFileStream_Loc;
+
+ needExit = false;
+ return S_OK;
+}
+
+
+
+HRESULT CArchiveExtractCallback::GetItem(UInt32 index)
+{
+ #ifndef Z7_SFX
+ _item._use_baseParentFolder_mode = _use_baseParentFolder_mode;
+ if (_use_baseParentFolder_mode)
+ {
+ _item._baseParentFolder = (int)_baseParentFolder;
+ if (_pathMode == NExtract::NPathMode::kFullPaths ||
+ _pathMode == NExtract::NPathMode::kAbsPaths)
+ _item._baseParentFolder = -1;
+ }
+ #endif // Z7_SFX
+
+ #ifdef SUPPORT_ALT_STREAMS
+ _item.WriteToAltStreamIfColon = _ntOptions.WriteToAltStreamIfColon;
+ #endif
+
+ return _arc->GetItem(index, _item);
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode))
+{
+ COM_TRY_BEGIN
+
+ *outStream = NULL;
+
+ #ifndef Z7_SFX
+ if (_hashStream)
+ _hashStreamSpec->ReleaseStream();
+ _hashStreamWasUsed = false;
+ #endif
+
+ _outFileStream.Release();
+ _bufPtrSeqOutStream.Release();
+
+ _encrypted = false;
+ _position = 0;
+ _isSplit = false;
+
+ _curSize = 0;
+ _curSize_Defined = false;
+ _fileLength_WasSet = false;
+ _fileLength_that_WasSet = 0;
+ _index = index;
+
+ _diskFilePath.Empty();
+
+ _isRenamed = false;
+
+ // _fi.Clear();
+
+ // _is_SymLink_in_Data = false;
+ _is_SymLink_in_Data_Linux = false;
+
+ _needSetAttrib = false;
+ _isSymLinkCreated = false;
+ _itemFailure = false;
+
+ #ifdef SUPPORT_LINKS
+ // _copyFile_Path.Empty();
+ _link.Clear();
+ #endif
+
+ _extractMode = false;
+
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract:
+ if (_testMode)
+ {
+ // askExtractMode = NArchive::NExtract::NAskMode::kTest;
+ }
+ else
+ _extractMode = true;
+ break;
+ }
+
+
+ IInArchive *archive = _arc->Archive;
+
+ RINOK(GetItem(index))
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidPosition, &prop))
+ if (prop.vt != VT_EMPTY)
+ {
+ if (prop.vt != VT_UI8)
+ return E_FAIL;
+ _position = prop.uhVal.QuadPart;
+ _isSplit = true;
+ }
+ }
+
+ #ifdef SUPPORT_LINKS
+ RINOK(ReadLink())
+ #endif // SUPPORT_LINKS
+
+
+ RINOK(Archive_GetItemBoolProp(archive, index, kpidEncrypted, _encrypted))
+
+ RINOK(GetUnpackSize())
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (!_ntOptions.AltStreams.Val && _item.IsAltStream)
+ return S_OK;
+ #endif // SUPPORT_ALT_STREAMS
+
+ // we can change (_item.PathParts) in this function
+ UStringVector &pathParts = _item.PathParts;
+
+ if (_wildcardCensor)
+ {
+ if (!CensorNode_CheckPath(*_wildcardCensor, _item))
+ return S_OK;
+ }
+
+ #ifndef Z7_SFX
+ if (_use_baseParentFolder_mode)
+ {
+ if (!pathParts.IsEmpty())
+ {
+ unsigned numRemovePathParts = 0;
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (_pathMode == NExtract::NPathMode::kNoPathsAlt && _item.IsAltStream)
+ numRemovePathParts = pathParts.Size();
+ else
+ #endif
+ if (_pathMode == NExtract::NPathMode::kNoPaths ||
+ _pathMode == NExtract::NPathMode::kNoPathsAlt)
+ numRemovePathParts = pathParts.Size() - 1;
+ pathParts.DeleteFrontal(numRemovePathParts);
+ }
+ }
+ else
+ #endif // Z7_SFX
+ {
+ if (pathParts.IsEmpty())
+ {
+ if (_item.IsDir)
+ return S_OK;
+ /*
+ #ifdef SUPPORT_ALT_STREAMS
+ if (!_item.IsAltStream)
+ #endif
+ return E_FAIL;
+ */
+ }
+
+ unsigned numRemovePathParts = 0;
+
+ switch (_pathMode)
+ {
+ case NExtract::NPathMode::kFullPaths:
+ case NExtract::NPathMode::kCurPaths:
+ {
+ if (_removePathParts.IsEmpty())
+ break;
+ bool badPrefix = false;
+
+ if (pathParts.Size() < _removePathParts.Size())
+ badPrefix = true;
+ else
+ {
+ if (pathParts.Size() == _removePathParts.Size())
+ {
+ if (_removePartsForAltStreams)
+ {
+ #ifdef SUPPORT_ALT_STREAMS
+ if (!_item.IsAltStream)
+ #endif
+ badPrefix = true;
+ }
+ else
+ {
+ if (!_item.MainIsDir)
+ badPrefix = true;
+ }
+ }
+
+ if (!badPrefix)
+ FOR_VECTOR (i, _removePathParts)
+ {
+ if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
+ {
+ badPrefix = true;
+ break;
+ }
+ }
+ }
+
+ if (badPrefix)
+ {
+ if (askExtractMode == NArchive::NExtract::NAskMode::kExtract && !_testMode)
+ return E_FAIL;
+ }
+ else
+ numRemovePathParts = _removePathParts.Size();
+ break;
+ }
+
+ case NExtract::NPathMode::kNoPaths:
+ {
+ if (!pathParts.IsEmpty())
+ numRemovePathParts = pathParts.Size() - 1;
+ break;
+ }
+ case NExtract::NPathMode::kNoPathsAlt:
+ {
+ #ifdef SUPPORT_ALT_STREAMS
+ if (_item.IsAltStream)
+ numRemovePathParts = pathParts.Size();
+ else
+ #endif
+ if (!pathParts.IsEmpty())
+ numRemovePathParts = pathParts.Size() - 1;
+ break;
+ }
+ case NExtract::NPathMode::kAbsPaths:
+ // default:
+ break;
+ }
+
+ pathParts.DeleteFrontal(numRemovePathParts);
+ }
+
+
+ #ifndef Z7_SFX
+
+ if (ExtractToStreamCallback)
+ {
+ if (!GetProp)
+ {
+ GetProp_Spec = new CGetProp;
+ GetProp = GetProp_Spec;
+ }
+ GetProp_Spec->Arc = _arc;
+ GetProp_Spec->IndexInArc = index;
+ UString name (MakePathFromParts(pathParts));
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (_item.IsAltStream)
+ {
+ if (!pathParts.IsEmpty() || (!_removePartsForAltStreams && _pathMode != NExtract::NPathMode::kNoPathsAlt))
+ name += ':';
+ name += _item.AltStreamName;
+ }
+ #endif
+
+ return ExtractToStreamCallback->GetStream7(name, BoolToInt(_item.IsDir), outStream, askExtractMode, GetProp);
+ }
+
+ #endif // Z7_SFX
+
+
+ CMyComPtr<ISequentialOutStream> outStreamLoc;
+
+ if (askExtractMode == NArchive::NExtract::NAskMode::kExtract && !_testMode)
+ {
+ if (_stdOutMode)
+ outStreamLoc = new CStdOutFileStream;
+ else
+ {
+ bool needExit = true;
+ RINOK(GetExtractStream(outStreamLoc, needExit))
+ if (needExit)
+ return S_OK;
+ }
+ }
+
+ #ifndef Z7_SFX
+ if (_hashStream)
+ {
+ if (askExtractMode == NArchive::NExtract::NAskMode::kExtract ||
+ askExtractMode == NArchive::NExtract::NAskMode::kTest)
+ {
+ _hashStreamSpec->SetStream(outStreamLoc);
+ outStreamLoc = _hashStream;
+ _hashStreamSpec->Init(true);
+ _hashStreamWasUsed = true;
+ }
+ }
+ #endif // Z7_SFX
+
+ if (outStreamLoc)
+ {
+ /*
+ #ifdef SUPPORT_LINKS
+ if (!_copyFile_Path.IsEmpty())
+ {
+ RINOK(PrepareOperation(askExtractMode));
+ RINOK(MyCopyFile(outStreamLoc));
+ return SetOperationResult(NArchive::NExtract::NOperationResult::kOK);
+ }
+ if (_link.isCopyLink && _testMode)
+ return S_OK;
+ #endif
+ */
+ *outStream = outStreamLoc.Detach();
+ }
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+
+
+
+
+
+
+
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode))
+{
+ COM_TRY_BEGIN
+
+ #ifndef Z7_SFX
+ if (ExtractToStreamCallback)
+ return ExtractToStreamCallback->PrepareOperation7(askExtractMode);
+ #endif
+
+ _extractMode = false;
+
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract:
+ if (_testMode)
+ askExtractMode = NArchive::NExtract::NAskMode::kTest;
+ else
+ _extractMode = true;
+ break;
+ }
+
+ return _extractCallback2->PrepareOperation(_item.Path, BoolToInt(_item.IsDir),
+ askExtractMode, _isSplit ? &_position: NULL);
+
+ COM_TRY_END
+}
+
+
+
+
+
+HRESULT CArchiveExtractCallback::CloseFile()
+{
+ if (!_outFileStream)
+ return S_OK;
+
+ HRESULT hres = S_OK;
+
+ const UInt64 processedSize = _outFileStreamSpec->ProcessedSize;
+ if (_fileLength_WasSet && _fileLength_that_WasSet > processedSize)
+ {
+ const bool res = _outFileStreamSpec->File.SetLength(processedSize);
+ _fileLength_WasSet = res;
+ if (!res)
+ {
+ const HRESULT hres2 = SendMessageError_with_LastError(kCantSetFileLen, us2fs(_item.Path));
+ if (hres == S_OK)
+ hres = hres2;
+ }
+ }
+
+ _curSize = processedSize;
+ _curSize_Defined = true;
+
+ #if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+ if (ZoneBuf.Size() != 0
+ && !_item.IsAltStream)
+ {
+ // if (NFind::DoesFileExist_Raw(tempFilePath))
+ if (ZoneMode != NExtract::NZoneIdMode::kOffice ||
+ FindExt2(kOfficeExtensions, fs2us(_diskFilePath)))
+ {
+ // we must write zone file before setting of timestamps
+ const FString path = _diskFilePath + k_ZoneId_StreamName;
+ if (!WriteZoneFile(path, ZoneBuf))
+ {
+ // we can't write it in FAT
+ // SendMessageError_with_LastError("Can't write Zone.Identifier stream", path);
+ }
+ }
+ }
+ #endif
+
+ CFiTimesCAM t;
+ GetFiTimesCAM(t);
+
+ // #ifdef _WIN32
+ if (t.IsSomeTimeDefined())
+ _outFileStreamSpec->SetTime(
+ t.CTime_Defined ? &t.CTime : NULL,
+ t.ATime_Defined ? &t.ATime : NULL,
+ t.MTime_Defined ? &t.MTime : NULL);
+ // #endif
+
+ RINOK(_outFileStreamSpec->Close())
+ _outFileStream.Release();
+ return hres;
+}
+
+
+#ifdef SUPPORT_LINKS
+
+
+HRESULT CArchiveExtractCallback::SetFromLinkPath(
+ const FString &fullProcessedPath,
+ const CLinkInfo &linkInfo,
+ bool &linkWasSet)
+{
+ linkWasSet = false;
+ if (!_ntOptions.SymLinks.Val && !linkInfo.isHardLink)
+ return S_OK;
+
+ UString relatPath;
+
+ /* if (linkInfo.isRelative)
+ linkInfo.linkPath is final link path that must be stored to file link field
+ else
+ linkInfo.linkPath is path from root of archive. So we must add _dirPathPrefix_Full before linkPath.
+ */
+
+ if (linkInfo.isRelative)
+ relatPath = GetDirPrefixOf(_item.Path);
+ relatPath += linkInfo.linkPath;
+
+ if (!IsSafePath(relatPath))
+ {
+ return SendMessageError2(
+ 0, // errorCode
+ "Dangerous link path was ignored",
+ us2fs(_item.Path),
+ us2fs(linkInfo.linkPath)); // us2fs(relatPath)
+ }
+
+ FString existPath;
+ if (linkInfo.isHardLink /* || linkInfo.IsCopyLink */ || !linkInfo.isRelative)
+ {
+ if (!NName::GetFullPath(_dirPathPrefix_Full, us2fs(relatPath), existPath))
+ {
+ RINOK(SendMessageError("Incorrect path", us2fs(relatPath)))
+ }
+ }
+ else
+ {
+ existPath = us2fs(linkInfo.linkPath);
+ // printf("\nlinkPath = : %s\n", GetOemString(linkInfo.linkPath).Ptr());
+ }
+
+ if (existPath.IsEmpty())
+ return SendMessageError("Empty link", fullProcessedPath);
+
+ if (linkInfo.isHardLink /* || linkInfo.IsCopyLink */)
+ {
+ // if (linkInfo.isHardLink)
+ {
+ if (!MyCreateHardLink(fullProcessedPath, existPath))
+ {
+ const HRESULT errorCode = GetLastError_noZero_HRESULT();
+ RINOK(SendMessageError2(errorCode, kCantCreateHardLink, fullProcessedPath, existPath))
+ }
+ linkWasSet = true;
+ return S_OK;
+ }
+ /*
+ // IsCopyLink
+ {
+ NFind::CFileInfo fi;
+ if (!fi.Find(existPath))
+ {
+ RINOK(SendMessageError2("Cannot find the file for copying", existPath, fullProcessedPath));
+ }
+ else
+ {
+ if (_curSize_Defined && _curSize == fi.Size)
+ _copyFile_Path = existPath;
+ else
+ {
+ RINOK(SendMessageError2("File size collision for file copying", existPath, fullProcessedPath));
+ }
+ // RINOK(MyCopyFile(existPath, fullProcessedPath));
+ }
+ }
+ */
+ }
+
+ // is Symbolic link
+
+ /*
+ if (_item.IsDir && !isRelative)
+ {
+ // Windows before Vista doesn't support symbolic links.
+ // we could convert such symbolic links to Junction Points
+ // isJunction = true;
+ // convertToAbs = true;
+ }
+ */
+
+ if (!_ntOptions.SymLinks_AllowDangerous.Val)
+ {
+ #ifdef _WIN32
+ if (_item.IsDir)
+ #endif
+ if (linkInfo.isRelative)
+ {
+ CLinkLevelsInfo levelsInfo;
+ levelsInfo.Parse(linkInfo.linkPath);
+ if (levelsInfo.FinalLevel < 1 || levelsInfo.IsAbsolute)
+ {
+ return SendMessageError2(
+ 0, // errorCode
+ "Dangerous symbolic link path was ignored",
+ us2fs(_item.Path),
+ us2fs(linkInfo.linkPath));
+ }
+ }
+ }
+
+
+ #ifdef _WIN32
+
+ CByteBuffer data;
+ // printf("\nFillLinkData(): %s\n", GetOemString(existPath).Ptr());
+ if (!FillLinkData(data, fs2us(existPath), !linkInfo.isJunction, linkInfo.isWSL))
+ return SendMessageError("Cannot fill link data", us2fs(_item.Path));
+
+ /*
+ if (NtReparse_Size != data.Size() || memcmp(NtReparse_Data, data, data.Size()) != 0)
+ {
+ SendMessageError("reconstructed Reparse is different", fs2us(existPath));
+ }
+ */
+
+ CReparseAttr attr;
+ if (!attr.Parse(data, data.Size()))
+ {
+ RINOK(SendMessageError("Internal error for symbolic link file", us2fs(_item.Path)))
+ return S_OK;
+ }
+ if (!NFile::NIO::SetReparseData(fullProcessedPath, _item.IsDir, data, (DWORD)data.Size()))
+ {
+ RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
+ return S_OK;
+ }
+ linkWasSet = true;
+
+ return S_OK;
+
+
+ #else // ! _WIN32
+
+ if (!NFile::NIO::SetSymLink(fullProcessedPath, existPath))
+ {
+ RINOK(SendMessageError_with_LastError(kCantCreateSymLink, fullProcessedPath))
+ return S_OK;
+ }
+ linkWasSet = true;
+
+ return S_OK;
+
+ #endif // ! _WIN32
+}
+
+
+bool CLinkInfo::Parse(const Byte *data, size_t dataSize, bool isLinuxData)
+{
+ Clear();
+ // this->isLinux = isLinuxData;
+
+ if (isLinuxData)
+ {
+ isJunction = false;
+ isHardLink = false;
+ AString utf;
+ if (dataSize >= (1 << 12))
+ return false;
+ utf.SetFrom_CalcLen((const char *)data, (unsigned)dataSize);
+ UString u;
+ if (!ConvertUTF8ToUnicode(utf, u))
+ return false;
+ linkPath = u;
+
+ // in linux symbolic data: we expect that linux separator '/' is used
+ // if windows link was created, then we also must use linux separator
+ if (u.IsEmpty())
+ return false;
+ const wchar_t c = u[0];
+ isRelative = !IS_PATH_SEPAR(c);
+ return true;
+ }
+
+ CReparseAttr reparse;
+ if (!reparse.Parse(data, dataSize))
+ return false;
+ isHardLink = false;
+ // isCopyLink = false;
+ linkPath = reparse.GetPath();
+ isJunction = reparse.IsMountPoint();
+
+ if (reparse.IsSymLink_WSL())
+ {
+ isWSL = true;
+ isRelative = reparse.IsRelative_WSL();
+ }
+ else
+ isRelative = reparse.IsRelative_Win();
+
+ // FIXME !!!
+ #ifndef _WIN32
+ linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
+ #endif
+
+ return true;
+}
+
+#endif // SUPPORT_LINKS
+
+
+HRESULT CArchiveExtractCallback::CloseReparseAndFile()
+{
+ HRESULT res = S_OK;
+
+ #ifdef SUPPORT_LINKS
+
+ size_t reparseSize = 0;
+ bool repraseMode = false;
+ bool needSetReparse = false;
+ CLinkInfo linkInfo;
+
+ if (_bufPtrSeqOutStream)
+ {
+ repraseMode = true;
+ reparseSize = _bufPtrSeqOutStream_Spec->GetPos();
+ if (_curSize_Defined && reparseSize == _outMemBuf.Size())
+ {
+ /*
+ CReparseAttr reparse;
+ DWORD errorCode = 0;
+ needSetReparse = reparse.Parse(_outMemBuf, reparseSize, errorCode);
+ if (needSetReparse)
+ {
+ UString linkPath = reparse.GetPath();
+ #ifndef _WIN32
+ linkPath.Replace(L'\\', WCHAR_PATH_SEPARATOR);
+ #endif
+ }
+ */
+ needSetReparse = linkInfo.Parse(_outMemBuf, reparseSize, _is_SymLink_in_Data_Linux);
+ if (!needSetReparse)
+ res = SendMessageError_with_LastError("Incorrect reparse stream", us2fs(_item.Path));
+ }
+ else
+ {
+ res = SendMessageError_with_LastError("Unknown reparse stream", us2fs(_item.Path));
+ }
+ if (!needSetReparse && _outFileStream)
+ {
+ const HRESULT res2 = WriteStream(_outFileStream, _outMemBuf, reparseSize);
+ if (res == S_OK)
+ res = res2;
+ }
+ _bufPtrSeqOutStream.Release();
+ }
+
+ #endif // SUPPORT_LINKS
+
+
+ const HRESULT res2 = CloseFile();
+
+ if (res == S_OK)
+ res = res2;
+
+ RINOK(res)
+
+ #ifdef SUPPORT_LINKS
+ if (repraseMode)
+ {
+ _curSize = reparseSize;
+ _curSize_Defined = true;
+
+ #ifdef SUPPORT_LINKS
+ if (needSetReparse)
+ {
+ // in Linux : we must delete empty file before symbolic link creation
+ // in Windows : we can create symbolic link even without file deleting
+ if (!DeleteFileAlways(_diskFilePath))
+ {
+ RINOK(SendMessageError_with_LastError("can't delete file", _diskFilePath))
+ }
+ {
+ /*
+ // for DEBUG ONLY: we can extract sym links as WSL links
+ // to eliminate (non-admin) errors for sym links.
+ #ifdef _WIN32
+ if (!linkInfo.isHardLink && !linkInfo.isJunction)
+ linkInfo.isWSL = true;
+ #endif
+ */
+ bool linkWasSet = false;
+ RINOK(SetFromLinkPath(_diskFilePath, linkInfo, linkWasSet))
+ if (linkWasSet)
+ _isSymLinkCreated = linkInfo.IsSymLink();
+ else
+ _needSetAttrib = false;
+ }
+ /*
+ if (!NFile::NIO::SetReparseData(_diskFilePath, _item.IsDir, ))
+ {
+ res = SendMessageError_with_LastError(kCantCreateSymLink, _diskFilePath);
+ }
+ */
+ }
+ #endif
+ }
+ #endif
+ return res;
+}
+
+
+void CArchiveExtractCallback::SetAttrib()
+{
+ #ifndef _WIN32
+ // Linux now doesn't support permissions for symlinks
+ if (_isSymLinkCreated)
+ return;
+ #endif
+
+ if (_itemFailure
+ || _diskFilePath.IsEmpty()
+ || _stdOutMode
+ || !_extractMode)
+ return;
+
+ #ifndef _WIN32
+ if (_fi.Owner.Id_Defined &&
+ _fi.Group.Id_Defined)
+ {
+ if (my_chown(_diskFilePath, _fi.Owner.Id, _fi.Group.Id) != 0)
+ {
+ SendMessageError_with_LastError("Cannot set owner", _diskFilePath);
+ }
+ }
+ #endif
+
+ if (_fi.Attrib_Defined)
+ {
+ // const AString s = GetAnsiString(_diskFilePath);
+ // printf("\nSetFileAttrib_PosixHighDetect: %s: hex:%x\n", s.Ptr(), _fi.Attrib);
+ bool res = SetFileAttrib_PosixHighDetect(_diskFilePath, _fi.Attrib);
+ if (!res)
+ {
+ // do we need error message here in Windows and in posix?
+ SendMessageError_with_LastError("Cannot set file attribute", _diskFilePath);
+ }
+ }
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 opRes))
+{
+ COM_TRY_BEGIN
+
+ // printf("\nCArchiveExtractCallback::SetOperationResult: %d %s\n", opRes, GetAnsiString(_diskFilePath));
+
+ #ifndef Z7_SFX
+ if (ExtractToStreamCallback)
+ {
+ GetUnpackSize();
+ return ExtractToStreamCallback->SetOperationResult8(opRes, BoolToInt(_encrypted), _curSize);
+ }
+ #endif
+
+ #ifndef Z7_SFX
+
+ if (_hashStreamWasUsed)
+ {
+ _hashStreamSpec->_hash->Final(_item.IsDir,
+ #ifdef SUPPORT_ALT_STREAMS
+ _item.IsAltStream
+ #else
+ false
+ #endif
+ , _item.Path);
+ _curSize = _hashStreamSpec->GetSize();
+ _curSize_Defined = true;
+ _hashStreamSpec->ReleaseStream();
+ _hashStreamWasUsed = false;
+ }
+
+ #endif // Z7_SFX
+
+ RINOK(CloseReparseAndFile())
+
+ #ifdef Z7_USE_SECURITY_CODE
+ if (!_stdOutMode && _extractMode && _ntOptions.NtSecurity.Val && _arc->GetRawProps)
+ {
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+ _arc->GetRawProps->GetRawProp(_index, kpidNtSecure, &data, &dataSize, &propType);
+ if (dataSize != 0)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+ if (CheckNtSecure((const Byte *)data, dataSize))
+ {
+ SECURITY_INFORMATION securInfo = DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION;
+ if (_saclEnabled)
+ securInfo |= SACL_SECURITY_INFORMATION;
+ ::SetFileSecurityW(fs2us(_diskFilePath), securInfo, (PSECURITY_DESCRIPTOR)(void *)(const Byte *)(data));
+ }
+ }
+ }
+ #endif // Z7_USE_SECURITY_CODE
+
+ if (!_curSize_Defined)
+ GetUnpackSize();
+
+ if (_curSize_Defined)
+ {
+ #ifdef SUPPORT_ALT_STREAMS
+ if (_item.IsAltStream)
+ AltStreams_UnpackSize += _curSize;
+ else
+ #endif
+ UnpackSize += _curSize;
+ }
+
+ if (_item.IsDir)
+ NumFolders++;
+ #ifdef SUPPORT_ALT_STREAMS
+ else if (_item.IsAltStream)
+ NumAltStreams++;
+ #endif
+ else
+ NumFiles++;
+
+ if (_needSetAttrib)
+ SetAttrib();
+
+ RINOK(_extractCallback2->SetOperationResult(opRes, BoolToInt(_encrypted)))
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes))
+{
+ if (_folderArchiveExtractCallback2)
+ {
+ bool isEncrypted = false;
+ UString s;
+
+ if (indexType == NArchive::NEventIndexType::kInArcIndex && index != (UInt32)(Int32)-1)
+ {
+ CReadArcItem item;
+ RINOK(_arc->GetItem(index, item))
+ s = item.Path;
+ RINOK(Archive_GetItemBoolProp(_arc->Archive, index, kpidEncrypted, isEncrypted))
+ }
+ else
+ {
+ s = '#';
+ s.Add_UInt32(index);
+ // if (indexType == NArchive::NEventIndexType::kBlockIndex) {}
+ }
+
+ return _folderArchiveExtractCallback2->ReportExtractResult(opRes, isEncrypted, s);
+ }
+
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password))
+{
+ COM_TRY_BEGIN
+ if (!_cryptoGetTextPassword)
+ {
+ RINOK(_extractCallback2.QueryInterface(IID_ICryptoGetTextPassword,
+ &_cryptoGetTextPassword))
+ }
+ return _cryptoGetTextPassword->CryptoGetTextPassword(password);
+ COM_TRY_END
+}
+
+
+// ---------- HASH functions ----------
+
+FString CArchiveExtractCallback::Hash_GetFullFilePath()
+{
+ // this function changes _item.PathParts.
+ CorrectPathParts();
+ const UStringVector &pathParts = _item.PathParts;
+ const UString processedPath (MakePathFromParts(pathParts));
+ FString fullProcessedPath (us2fs(processedPath));
+ if (_pathMode != NExtract::NPathMode::kAbsPaths
+ || !NName::IsAbsolutePath(processedPath))
+ {
+ fullProcessedPath = MakePath_from_2_Parts(
+ DirPathPrefix_for_HashFiles,
+ // _dirPathPrefix,
+ fullProcessedPath);
+ }
+ return fullProcessedPath;
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::GetDiskProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (propID == kpidSize)
+ {
+ RINOK(GetItem(index))
+ const FString fullProcessedPath = Hash_GetFullFilePath();
+ NFile::NFind::CFileInfo fi;
+ if (fi.Find_FollowLink(fullProcessedPath))
+ if (!fi.IsDir())
+ prop = (UInt64)fi.Size;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::GetStream2(UInt32 index, ISequentialInStream **inStream, UInt32 mode))
+{
+ COM_TRY_BEGIN
+ *inStream = NULL;
+ // if (index != _index) return E_FAIL;
+ if (mode != NUpdateNotifyOp::kHashRead)
+ return E_FAIL;
+
+ RINOK(GetItem(index))
+ const FString fullProcessedPath = Hash_GetFullFilePath();
+
+ CInFileStream *inStreamSpec = new CInFileStream;
+ CMyComPtr<ISequentialInStream> inStreamRef = inStreamSpec;
+ inStreamSpec->Set_PreserveATime(_ntOptions.PreserveATime);
+ if (!inStreamSpec->OpenShared(fullProcessedPath, _ntOptions.OpenShareForWrite))
+ {
+ RINOK(SendMessageError_with_LastError(kCantOpenInFile, fullProcessedPath))
+ return S_OK;
+ }
+ *inStream = inStreamRef.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CArchiveExtractCallback::ReportOperation(
+ UInt32 /* indexType */, UInt32 /* index */, UInt32 /* op */))
+{
+ // COM_TRY_BEGIN
+ return S_OK;
+ // COM_TRY_END
+}
+
+
+// ------------ After Extracting functions ------------
+
+void CDirPathSortPair::SetNumSlashes(const FChar *s)
+{
+ for (unsigned numSlashes = 0;;)
+ {
+ FChar c = *s++;
+ if (c == 0)
+ {
+ Len = numSlashes;
+ return;
+ }
+ if (IS_PATH_SEPAR(c))
+ numSlashes++;
+ }
+}
+
+
+bool CDirPathTime::SetDirTime() const
+{
+ return NDir::SetDirTime(Path,
+ CTime_Defined ? &CTime : NULL,
+ ATime_Defined ? &ATime : NULL,
+ MTime_Defined ? &MTime : NULL);
+}
+
+
+HRESULT CArchiveExtractCallback::SetDirsTimes()
+{
+ if (!_arc)
+ return S_OK;
+
+ CRecordVector<CDirPathSortPair> pairs;
+ pairs.ClearAndSetSize(_extractedFolders.Size());
+ unsigned i;
+
+ for (i = 0; i < _extractedFolders.Size(); i++)
+ {
+ CDirPathSortPair &pair = pairs[i];
+ pair.Index = i;
+ pair.SetNumSlashes(_extractedFolders[i].Path);
+ }
+
+ pairs.Sort2();
+
+ HRESULT res = S_OK;
+
+ for (i = 0; i < pairs.Size(); i++)
+ {
+ const CDirPathTime &dpt = _extractedFolders[pairs[i].Index];
+ if (!dpt.SetDirTime())
+ {
+ // result = E_FAIL;
+ // do we need error message here in Windows and in posix?
+ // SendMessageError_with_LastError("Cannot set directory time", dpt.Path);
+ }
+ }
+
+ /*
+ #ifndef _WIN32
+ for (i = 0; i < _delayedSymLinks.Size(); i++)
+ {
+ const CDelayedSymLink &link = _delayedSymLinks[i];
+ if (!link.Create())
+ {
+ if (res == S_OK)
+ res = GetLastError_noZero_HRESULT();
+ // res = E_FAIL;
+ // do we need error message here in Windows and in posix?
+ SendMessageError_with_LastError("Cannot create Symbolic Link", link._source);
+ }
+ }
+ #endif // _WIN32
+ */
+
+ ClearExtractedDirsInfo();
+ return res;
+}
+
+
+HRESULT CArchiveExtractCallback::CloseArc()
+{
+ HRESULT res = CloseReparseAndFile();
+ const HRESULT res2 = SetDirsTimes();
+ if (res == S_OK)
+ res = res2;
+ _arc = NULL;
+ return res;
+}
diff --git a/CPP/7zip/UI/Common/ArchiveExtractCallback.h b/CPP/7zip/UI/Common/ArchiveExtractCallback.h
index af38f13..5ed20f3 100644
--- a/CPP/7zip/UI/Common/ArchiveExtractCallback.h
+++ b/CPP/7zip/UI/Common/ArchiveExtractCallback.h
@@ -1,403 +1,584 @@
-// ArchiveExtractCallback.h
-
-#ifndef __ARCHIVE_EXTRACT_CALLBACK_H
-#define __ARCHIVE_EXTRACT_CALLBACK_H
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../IPassword.h"
-
-#include "../../Common/FileStreams.h"
-#include "../../Common/ProgressUtils.h"
-
-#include "../../Archive/IArchive.h"
-
-#include "ExtractMode.h"
-#include "IFileExtractCallback.h"
-#include "OpenArchive.h"
-
-#include "HashCalc.h"
-
-#ifndef _SFX
-
-class COutStreamWithHash:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- CMyComPtr<ISequentialOutStream> _stream;
- UInt64 _size;
- bool _calculate;
-public:
- IHashCalc *_hash;
-
- MY_UNKNOWN_IMP
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- void SetStream(ISequentialOutStream *stream) { _stream = stream; }
- void ReleaseStream() { _stream.Release(); }
- void Init(bool calculate = true)
- {
- InitCRC();
- _size = 0;
- _calculate = calculate;
- }
- void EnableCalc(bool calculate) { _calculate = calculate; }
- void InitCRC() { _hash->InitForNewFile(); }
- UInt64 GetSize() const { return _size; }
-};
-
-#endif
-
-struct CExtractNtOptions
-{
- CBoolPair NtSecurity;
- CBoolPair SymLinks;
- CBoolPair HardLinks;
- CBoolPair AltStreams;
- bool ReplaceColonForAltStream;
- bool WriteToAltStreamIfColon;
-
- bool PreAllocateOutFile;
-
- CExtractNtOptions():
- ReplaceColonForAltStream(false),
- WriteToAltStreamIfColon(false)
- {
- SymLinks.Val = true;
- HardLinks.Val = true;
- AltStreams.Val = true;
-
- PreAllocateOutFile =
- #ifdef _WIN32
- true;
- #else
- false;
- #endif
- }
-};
-
-#ifndef _SFX
-
-class CGetProp:
- public IGetProp,
- public CMyUnknownImp
-{
-public:
- const CArc *Arc;
- UInt32 IndexInArc;
- // UString Name; // relative path
-
- MY_UNKNOWN_IMP1(IGetProp)
- INTERFACE_IGetProp(;)
-};
-
-#endif
-
-#ifndef _SFX
-#ifndef UNDER_CE
-
-#define SUPPORT_LINKS
-
-#endif
-#endif
-
-
-#ifdef SUPPORT_LINKS
-
-struct CHardLinkNode
-{
- UInt64 StreamId;
- UInt64 INode;
-
- int Compare(const CHardLinkNode &a) const;
-};
-
-class CHardLinks
-{
-public:
- CRecordVector<CHardLinkNode> IDs;
- CObjectVector<FString> Links;
-
- void Clear()
- {
- IDs.Clear();
- Links.Clear();
- }
-
- void PrepareLinks()
- {
- while (Links.Size() < IDs.Size())
- Links.AddNew();
- }
-};
-
-#endif
-
-#ifdef SUPPORT_ALT_STREAMS
-
-struct CIndexToPathPair
-{
- UInt32 Index;
- FString Path;
-
- CIndexToPathPair(UInt32 index): Index(index) {}
- CIndexToPathPair(UInt32 index, const FString &path): Index(index), Path(path) {}
-
- int Compare(const CIndexToPathPair &pair) const
- {
- return MyCompare(Index, pair.Index);
- }
-};
-
-#endif
-
-
-
-struct CDirPathTime
-{
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
-
- bool CTimeDefined;
- bool ATimeDefined;
- bool MTimeDefined;
-
- FString Path;
-
- bool SetDirTime();
-};
-
-
-
-class CArchiveExtractCallback:
- public IArchiveExtractCallback,
- public IArchiveExtractCallbackMessage,
- public ICryptoGetTextPassword,
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
- const CArc *_arc;
- CExtractNtOptions _ntOptions;
-
- const NWildcard::CCensorNode *_wildcardCensor; // we need wildcard for single pass mode (stdin)
- CMyComPtr<IFolderArchiveExtractCallback> _extractCallback2;
- CMyComPtr<ICompressProgressInfo> _compressProgress;
- CMyComPtr<ICryptoGetTextPassword> _cryptoGetTextPassword;
- CMyComPtr<IArchiveExtractCallbackMessage> _callbackMessage;
- CMyComPtr<IFolderArchiveExtractCallback2> _folderArchiveExtractCallback2;
-
- FString _dirPathPrefix;
- FString _dirPathPrefix_Full;
- NExtract::NPathMode::EEnum _pathMode;
- NExtract::NOverwriteMode::EEnum _overwriteMode;
- bool _keepAndReplaceEmptyDirPrefixes; // replace them to "_";
-
- #ifndef _SFX
-
- CMyComPtr<IFolderExtractToStreamCallback> ExtractToStreamCallback;
- CGetProp *GetProp_Spec;
- CMyComPtr<IGetProp> GetProp;
-
- #endif
-
- CReadArcItem _item;
- FString _diskFilePath;
- UInt64 _position;
- bool _isSplit;
-
- bool _extractMode;
-
- bool WriteCTime;
- bool WriteATime;
- bool WriteMTime;
-
- bool _encrypted;
-
- struct CProcessedFileInfo
- {
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
- UInt32 Attrib;
-
- bool CTimeDefined;
- bool ATimeDefined;
- bool MTimeDefined;
- bool AttribDefined;
- } _fi;
-
- UInt32 _index;
- UInt64 _curSize;
- bool _curSizeDefined;
- bool _fileLengthWasSet;
- COutFileStream *_outFileStreamSpec;
- CMyComPtr<ISequentialOutStream> _outFileStream;
-
- #ifndef _SFX
-
- COutStreamWithHash *_hashStreamSpec;
- CMyComPtr<ISequentialOutStream> _hashStream;
- bool _hashStreamWasUsed;
-
- #endif
-
- bool _removePartsForAltStreams;
- UStringVector _removePathParts;
-
- #ifndef _SFX
- bool _use_baseParentFolder_mode;
- UInt32 _baseParentFolder;
- #endif
-
- bool _stdOutMode;
- bool _testMode;
- bool _multiArchives;
-
- CMyComPtr<ICompressProgressInfo> _localProgress;
- UInt64 _packTotal;
-
- UInt64 _progressTotal;
- bool _progressTotal_Defined;
-
- CObjectVector<CDirPathTime> _extractedFolders;
-
- #if defined(_WIN32) && !defined(UNDER_CE) && !defined(_SFX)
- bool _saclEnabled;
- #endif
-
- void CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath);
- HRESULT GetTime(UInt32 index, PROPID propID, FILETIME &filetime, bool &filetimeIsDefined);
- HRESULT GetUnpackSize();
-
- HRESULT SendMessageError(const char *message, const FString &path);
- HRESULT SendMessageError_with_LastError(const char *message, const FString &path);
- HRESULT SendMessageError2(const char *message, const FString &path1, const FString &path2);
-
-public:
-
- CLocalProgress *LocalProgressSpec;
-
- UInt64 NumFolders;
- UInt64 NumFiles;
- UInt64 NumAltStreams;
- UInt64 UnpackSize;
- UInt64 AltStreams_UnpackSize;
-
- MY_UNKNOWN_IMP3(IArchiveExtractCallbackMessage, ICryptoGetTextPassword, ICompressProgressInfo)
-
- INTERFACE_IArchiveExtractCallback(;)
- INTERFACE_IArchiveExtractCallbackMessage(;)
-
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
-
- CArchiveExtractCallback();
-
- void InitForMulti(bool multiArchives,
- NExtract::NPathMode::EEnum pathMode,
- NExtract::NOverwriteMode::EEnum overwriteMode,
- bool keepAndReplaceEmptyDirPrefixes)
- {
- _multiArchives = multiArchives;
- _pathMode = pathMode;
- _overwriteMode = overwriteMode;
- _keepAndReplaceEmptyDirPrefixes = keepAndReplaceEmptyDirPrefixes;
- NumFolders = NumFiles = NumAltStreams = UnpackSize = AltStreams_UnpackSize = 0;
- }
-
- #ifndef _SFX
-
- void SetHashMethods(IHashCalc *hash)
- {
- if (!hash)
- return;
- _hashStreamSpec = new COutStreamWithHash;
- _hashStream = _hashStreamSpec;
- _hashStreamSpec->_hash = hash;
- }
-
- #endif
-
- void Init(
- const CExtractNtOptions &ntOptions,
- const NWildcard::CCensorNode *wildcardCensor,
- const CArc *arc,
- IFolderArchiveExtractCallback *extractCallback2,
- bool stdOutMode, bool testMode,
- const FString &directoryPath,
- const UStringVector &removePathParts, bool removePartsForAltStreams,
- UInt64 packSize);
-
-
- #ifdef SUPPORT_LINKS
-
-private:
- CHardLinks _hardLinks;
- UString linkPath;
-
- // FString _CopyFile_Path;
- // HRESULT MyCopyFile(ISequentialOutStream *outStream);
-
-public:
- // call PrepareHardLinks() after Init()
- HRESULT PrepareHardLinks(const CRecordVector<UInt32> *realIndices); // NULL means all items
-
- #endif
-
-
- #ifdef SUPPORT_ALT_STREAMS
- CObjectVector<CIndexToPathPair> _renamedFiles;
- #endif
-
- // call it after Init()
-
- #ifndef _SFX
- void SetBaseParentFolderIndex(UInt32 indexInArc)
- {
- _baseParentFolder = indexInArc;
- _use_baseParentFolder_mode = true;
- }
- #endif
-
- HRESULT CloseArc();
-
-private:
- void ClearExtractedDirsInfo()
- {
- _extractedFolders.Clear();
- }
-
- HRESULT CloseFile();
- HRESULT SetDirsTimes();
-};
-
-
-struct CArchiveExtractCallback_Closer
-{
- CArchiveExtractCallback *_ref;
-
- CArchiveExtractCallback_Closer(CArchiveExtractCallback *ref): _ref(ref) {}
-
- HRESULT Close()
- {
- HRESULT res = S_OK;
- if (_ref)
- {
- res = _ref->CloseArc();
- _ref = NULL;
- }
- return res;
- }
-
- ~CArchiveExtractCallback_Closer()
- {
- Close();
- }
-};
-
-
-bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item);
-
-#endif
+// ArchiveExtractCallback.h
+
+#ifndef ZIP7_INC_ARCHIVE_EXTRACT_CALLBACK_H
+#define ZIP7_INC_ARCHIVE_EXTRACT_CALLBACK_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyLinux.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../IPassword.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "ExtractMode.h"
+#include "IFileExtractCallback.h"
+#include "OpenArchive.h"
+
+#include "HashCalc.h"
+
+#ifndef Z7_SFX
+
+Z7_CLASS_IMP_NOQIB_1(
+ COutStreamWithHash
+ , ISequentialOutStream
+)
+ CMyComPtr<ISequentialOutStream> _stream;
+ UInt64 _size;
+ bool _calculate;
+public:
+ IHashCalc *_hash;
+
+ void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+ void ReleaseStream() { _stream.Release(); }
+ void Init(bool calculate = true)
+ {
+ InitCRC();
+ _size = 0;
+ _calculate = calculate;
+ }
+ void EnableCalc(bool calculate) { _calculate = calculate; }
+ void InitCRC() { _hash->InitForNewFile(); }
+ UInt64 GetSize() const { return _size; }
+};
+
+#endif
+
+struct CExtractNtOptions
+{
+ CBoolPair NtSecurity;
+ CBoolPair SymLinks;
+ CBoolPair SymLinks_AllowDangerous;
+ CBoolPair HardLinks;
+ CBoolPair AltStreams;
+ bool ReplaceColonForAltStream;
+ bool WriteToAltStreamIfColon;
+
+ bool ExtractOwner;
+
+ bool PreAllocateOutFile;
+
+ // used for hash arcs only, when we open external files
+ bool PreserveATime;
+ bool OpenShareForWrite;
+
+ CExtractNtOptions():
+ ReplaceColonForAltStream(false),
+ WriteToAltStreamIfColon(false),
+ ExtractOwner(false),
+ PreserveATime(false),
+ OpenShareForWrite(false)
+ {
+ SymLinks.Val = true;
+ SymLinks_AllowDangerous.Val = false;
+ HardLinks.Val = true;
+ AltStreams.Val = true;
+
+ PreAllocateOutFile =
+ #ifdef _WIN32
+ true;
+ #else
+ false;
+ #endif
+ }
+};
+
+#ifndef Z7_SFX
+
+Z7_CLASS_IMP_COM_1(
+ CGetProp
+ , IGetProp
+)
+public:
+ UInt32 IndexInArc;
+ const CArc *Arc;
+ // UString Name; // relative path
+};
+
+#endif
+
+#ifndef Z7_SFX
+#ifndef UNDER_CE
+
+#define SUPPORT_LINKS
+
+#endif
+#endif
+
+
+#ifdef SUPPORT_LINKS
+
+struct CHardLinkNode
+{
+ UInt64 StreamId;
+ UInt64 INode;
+
+ int Compare(const CHardLinkNode &a) const;
+};
+
+class CHardLinks
+{
+public:
+ CRecordVector<CHardLinkNode> IDs;
+ CObjectVector<FString> Links;
+
+ void Clear()
+ {
+ IDs.Clear();
+ Links.Clear();
+ }
+
+ void PrepareLinks()
+ {
+ while (Links.Size() < IDs.Size())
+ Links.AddNew();
+ }
+};
+
+#endif
+
+#ifdef SUPPORT_ALT_STREAMS
+
+struct CIndexToPathPair
+{
+ UInt32 Index;
+ FString Path;
+
+ CIndexToPathPair(UInt32 index): Index(index) {}
+ CIndexToPathPair(UInt32 index, const FString &path): Index(index), Path(path) {}
+
+ int Compare(const CIndexToPathPair &pair) const
+ {
+ return MyCompare(Index, pair.Index);
+ }
+};
+
+#endif
+
+
+
+struct CFiTimesCAM
+{
+ CFiTime CTime;
+ CFiTime ATime;
+ CFiTime MTime;
+
+ bool CTime_Defined;
+ bool ATime_Defined;
+ bool MTime_Defined;
+
+ bool IsSomeTimeDefined() const
+ {
+ return
+ CTime_Defined |
+ ATime_Defined |
+ MTime_Defined;
+ }
+};
+
+struct CDirPathTime: public CFiTimesCAM
+{
+ FString Path;
+
+ bool SetDirTime() const;
+};
+
+
+#ifdef SUPPORT_LINKS
+
+struct CLinkInfo
+{
+ // bool isCopyLink;
+ bool isHardLink;
+ bool isJunction;
+ bool isRelative;
+ bool isWSL;
+ UString linkPath;
+
+ bool IsSymLink() const { return !isHardLink; }
+
+ CLinkInfo():
+ // IsCopyLink(false),
+ isHardLink(false),
+ isJunction(false),
+ isRelative(false),
+ isWSL(false)
+ {}
+
+ void Clear()
+ {
+ // IsCopyLink = false;
+ isHardLink = false;
+ isJunction = false;
+ isRelative = false;
+ isWSL = false;
+ linkPath.Empty();
+ }
+
+ bool Parse(const Byte *data, size_t dataSize, bool isLinuxData);
+};
+
+#endif // SUPPORT_LINKS
+
+
+#ifndef _WIN32
+
+struct COwnerInfo
+{
+ bool Id_Defined;
+ UInt32 Id;
+ AString Name;
+
+ void Clear()
+ {
+ Id_Defined = false;
+ Id = 0;
+ Name.Empty();
+ }
+};
+
+#endif
+
+
+class CArchiveExtractCallback Z7_final:
+ public IArchiveExtractCallback,
+ public IArchiveExtractCallbackMessage2,
+ public ICryptoGetTextPassword,
+ public ICompressProgressInfo,
+ public IArchiveUpdateCallbackFile,
+ public IArchiveGetDiskProperty,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_5(
+ /* IArchiveExtractCallback, */
+ IArchiveExtractCallbackMessage2,
+ ICryptoGetTextPassword,
+ ICompressProgressInfo,
+ IArchiveUpdateCallbackFile,
+ IArchiveGetDiskProperty)
+
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IArchiveExtractCallback)
+ Z7_IFACE_COM7_IMP(IArchiveExtractCallbackMessage2)
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ Z7_IFACE_COM7_IMP(ICompressProgressInfo)
+ Z7_IFACE_COM7_IMP(IArchiveUpdateCallbackFile)
+ Z7_IFACE_COM7_IMP(IArchiveGetDiskProperty)
+
+ const CArc *_arc;
+ CExtractNtOptions _ntOptions;
+
+ bool _isSplit;
+
+ bool _extractMode;
+
+ bool Write_CTime;
+ bool Write_ATime;
+ bool Write_MTime;
+ bool _keepAndReplaceEmptyDirPrefixes; // replace them to "_";
+
+ bool _encrypted;
+
+ // bool _is_SymLink_in_Data;
+ bool _is_SymLink_in_Data_Linux; // false = WIN32, true = LINUX
+
+ bool _needSetAttrib;
+ bool _isSymLinkCreated;
+ bool _itemFailure;
+
+ bool _curSize_Defined;
+ bool _fileLength_WasSet;
+
+ bool _removePartsForAltStreams;
+
+ bool _stdOutMode;
+ bool _testMode;
+ bool _multiArchives;
+
+ NExtract::NPathMode::EEnum _pathMode;
+ NExtract::NOverwriteMode::EEnum _overwriteMode;
+
+ const NWildcard::CCensorNode *_wildcardCensor; // we need wildcard for single pass mode (stdin)
+ CMyComPtr<IFolderArchiveExtractCallback> _extractCallback2;
+ // CMyComPtr<ICompressProgressInfo> _compressProgress;
+ // CMyComPtr<IArchiveExtractCallbackMessage2> _callbackMessage;
+ CMyComPtr<IFolderArchiveExtractCallback2> _folderArchiveExtractCallback2;
+ CMyComPtr<ICryptoGetTextPassword> _cryptoGetTextPassword;
+
+ FString _dirPathPrefix;
+ FString _dirPathPrefix_Full;
+
+ #ifndef Z7_SFX
+
+ CMyComPtr<IFolderExtractToStreamCallback> ExtractToStreamCallback;
+ CGetProp *GetProp_Spec;
+ CMyComPtr<IGetProp> GetProp;
+
+ #endif
+
+ CReadArcItem _item;
+ FString _diskFilePath;
+ UInt64 _position;
+
+ struct CProcessedFileInfo
+ {
+ CArcTime CTime;
+ CArcTime ATime;
+ CArcTime MTime;
+ UInt32 Attrib;
+ bool Attrib_Defined;
+
+ #ifndef _WIN32
+ COwnerInfo Owner;
+ COwnerInfo Group;
+ #endif
+
+ bool IsReparse() const
+ {
+ return (Attrib_Defined && (Attrib & FILE_ATTRIBUTE_REPARSE_POINT) != 0);
+ }
+
+ bool IsLinuxSymLink() const
+ {
+ return (Attrib_Defined && MY_LIN_S_ISLNK(Attrib >> 16));
+ }
+
+ void SetFromPosixAttrib(UInt32 a)
+ {
+ // here we set only part of combined attribute required by SetFileAttrib() call
+ #ifdef _WIN32
+ // Windows sets FILE_ATTRIBUTE_NORMAL, if we try to set 0 as attribute.
+ Attrib = MY_LIN_S_ISDIR(a) ?
+ FILE_ATTRIBUTE_DIRECTORY :
+ FILE_ATTRIBUTE_ARCHIVE;
+ if ((a & 0222) == 0) // (& S_IWUSR) in p7zip
+ Attrib |= FILE_ATTRIBUTE_READONLY;
+ // 22.00 : we need type bits for (MY_LIN_S_IFLNK) for IsLinuxSymLink()
+ a &= MY_LIN_S_IFMT;
+ if (a == MY_LIN_S_IFLNK)
+ Attrib |= (a << 16);
+ #else
+ Attrib = (a << 16) | FILE_ATTRIBUTE_UNIX_EXTENSION;
+ #endif
+ Attrib_Defined = true;
+ }
+ } _fi;
+
+ UInt32 _index;
+ UInt64 _curSize;
+ UInt64 _fileLength_that_WasSet;
+
+ COutFileStream *_outFileStreamSpec;
+ CMyComPtr<ISequentialOutStream> _outFileStream;
+
+ CByteBuffer _outMemBuf;
+ CBufPtrSeqOutStream *_bufPtrSeqOutStream_Spec;
+ CMyComPtr<ISequentialOutStream> _bufPtrSeqOutStream;
+
+
+ #ifndef Z7_SFX
+
+ COutStreamWithHash *_hashStreamSpec;
+ CMyComPtr<ISequentialOutStream> _hashStream;
+ bool _hashStreamWasUsed;
+
+ bool _use_baseParentFolder_mode;
+ UInt32 _baseParentFolder;
+ #endif
+
+ UStringVector _removePathParts;
+
+ CMyComPtr<ICompressProgressInfo> _localProgress;
+ UInt64 _packTotal;
+
+ UInt64 _progressTotal;
+ bool _progressTotal_Defined;
+
+ CObjectVector<CDirPathTime> _extractedFolders;
+
+ #ifndef _WIN32
+ // CObjectVector<NWindows::NFile::NDir::CDelayedSymLink> _delayedSymLinks;
+ #endif
+
+ #if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+ bool _saclEnabled;
+ #endif
+
+ void CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath);
+ HRESULT GetTime(UInt32 index, PROPID propID, CArcTime &ft);
+ HRESULT GetUnpackSize();
+
+ FString Hash_GetFullFilePath();
+
+ void SetAttrib();
+
+public:
+ HRESULT SendMessageError(const char *message, const FString &path);
+ HRESULT SendMessageError_with_LastError(const char *message, const FString &path);
+ HRESULT SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2);
+
+public:
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ NExtract::NZoneIdMode::EEnum ZoneMode;
+ CByteBuffer ZoneBuf;
+ #endif
+
+ CLocalProgress *LocalProgressSpec;
+
+ UInt64 NumFolders;
+ UInt64 NumFiles;
+ UInt64 NumAltStreams;
+ UInt64 UnpackSize;
+ UInt64 AltStreams_UnpackSize;
+
+ FString DirPathPrefix_for_HashFiles;
+
+ CArchiveExtractCallback();
+
+ void InitForMulti(bool multiArchives,
+ NExtract::NPathMode::EEnum pathMode,
+ NExtract::NOverwriteMode::EEnum overwriteMode,
+ NExtract::NZoneIdMode::EEnum zoneMode,
+ bool keepAndReplaceEmptyDirPrefixes)
+ {
+ _multiArchives = multiArchives;
+ _pathMode = pathMode;
+ _overwriteMode = overwriteMode;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ ZoneMode = zoneMode;
+ #else
+ UNUSED_VAR(zoneMode)
+ #endif
+ _keepAndReplaceEmptyDirPrefixes = keepAndReplaceEmptyDirPrefixes;
+ NumFolders = NumFiles = NumAltStreams = UnpackSize = AltStreams_UnpackSize = 0;
+ }
+
+ #ifndef Z7_SFX
+
+ void SetHashMethods(IHashCalc *hash)
+ {
+ if (!hash)
+ return;
+ _hashStreamSpec = new COutStreamWithHash;
+ _hashStream = _hashStreamSpec;
+ _hashStreamSpec->_hash = hash;
+ }
+
+ #endif
+
+ void InitBeforeNewArchive();
+
+ void Init(
+ const CExtractNtOptions &ntOptions,
+ const NWildcard::CCensorNode *wildcardCensor,
+ const CArc *arc,
+ IFolderArchiveExtractCallback *extractCallback2,
+ bool stdOutMode, bool testMode,
+ const FString &directoryPath,
+ const UStringVector &removePathParts, bool removePartsForAltStreams,
+ UInt64 packSize);
+
+
+ #ifdef SUPPORT_LINKS
+
+private:
+ CHardLinks _hardLinks;
+ CLinkInfo _link;
+
+ // FString _copyFile_Path;
+ // HRESULT MyCopyFile(ISequentialOutStream *outStream);
+ HRESULT Link(const FString &fullProcessedPath);
+ HRESULT ReadLink();
+
+public:
+ // call PrepareHardLinks() after Init()
+ HRESULT PrepareHardLinks(const CRecordVector<UInt32> *realIndices); // NULL means all items
+
+ #endif
+
+
+ #ifdef SUPPORT_ALT_STREAMS
+ CObjectVector<CIndexToPathPair> _renamedFiles;
+ #endif
+
+ // call it after Init()
+
+ #ifndef Z7_SFX
+ void SetBaseParentFolderIndex(UInt32 indexInArc)
+ {
+ _baseParentFolder = indexInArc;
+ _use_baseParentFolder_mode = true;
+ }
+ #endif
+
+ HRESULT CloseArc();
+
+private:
+ void ClearExtractedDirsInfo()
+ {
+ _extractedFolders.Clear();
+ #ifndef _WIN32
+ // _delayedSymLinks.Clear();
+ #endif
+ }
+
+ HRESULT Read_fi_Props();
+ void CorrectPathParts();
+ void GetFiTimesCAM(CFiTimesCAM &pt);
+ void CreateFolders();
+
+ bool _isRenamed;
+ HRESULT CheckExistFile(FString &fullProcessedPath, bool &needExit);
+ HRESULT GetExtractStream(CMyComPtr<ISequentialOutStream> &outStreamLoc, bool &needExit);
+ HRESULT GetItem(UInt32 index);
+
+ HRESULT CloseFile();
+ HRESULT CloseReparseAndFile();
+ HRESULT CloseReparseAndFile2();
+ HRESULT SetDirsTimes();
+
+ const void *NtReparse_Data;
+ UInt32 NtReparse_Size;
+
+ #ifdef SUPPORT_LINKS
+ HRESULT SetFromLinkPath(
+ const FString &fullProcessedPath,
+ const CLinkInfo &linkInfo,
+ bool &linkWasSet);
+ #endif
+};
+
+
+struct CArchiveExtractCallback_Closer
+{
+ CArchiveExtractCallback *_ref;
+
+ CArchiveExtractCallback_Closer(CArchiveExtractCallback *ref): _ref(ref) {}
+
+ HRESULT Close()
+ {
+ HRESULT res = S_OK;
+ if (_ref)
+ {
+ res = _ref->CloseArc();
+ _ref = NULL;
+ }
+ return res;
+ }
+
+ ~CArchiveExtractCallback_Closer()
+ {
+ Close();
+ }
+};
+
+
+bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item);
+
+void ReadZoneFile_Of_BaseFile(CFSTR fileName2, CByteBuffer &buf);
+
+#endif
diff --git a/CPP/7zip/UI/Common/ArchiveName.cpp b/CPP/7zip/UI/Common/ArchiveName.cpp
index b07d46c..1c0c3a8 100644
--- a/CPP/7zip/UI/Common/ArchiveName.cpp
+++ b/CPP/7zip/UI/Common/ArchiveName.cpp
@@ -1,155 +1,176 @@
-// ArchiveName.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileName.h"
-
-#include "ExtractingFilePath.h"
-#include "ArchiveName.h"
-
-using namespace NWindows;
-using namespace NFile;
-
-static UString CreateArchiveName(const NFind::CFileInfo &fi, bool keepName)
-{
- FString resultName = fi.Name;
- if (!fi.IsDir() && !keepName)
- {
- int dotPos = resultName.ReverseFind_Dot();
- if (dotPos > 0)
- {
- FString archiveName2 = resultName.Left(dotPos);
- if (archiveName2.ReverseFind_Dot() < 0)
- resultName = archiveName2;
- }
- }
- return Get_Correct_FsFile_Name(fs2us(resultName));
-}
-
-static FString CreateArchiveName2(const FString &path, bool fromPrev, bool keepName)
-{
- FString resultName ("Archive");
- if (fromPrev)
- {
- FString dirPrefix;
- if (NDir::GetOnlyDirPrefix(path, dirPrefix))
- {
- if (!dirPrefix.IsEmpty() && IsPathSepar(dirPrefix.Back()))
- {
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (NName::IsDriveRootPath_SuperAllowed(dirPrefix))
- resultName = dirPrefix[dirPrefix.Len() - 3]; // only letter
- else
- #endif
- {
- dirPrefix.DeleteBack();
- NFind::CFileInfo fi;
- if (fi.Find(dirPrefix))
- resultName = fi.Name;
- }
- }
- }
- }
- else
- {
- NFind::CFileInfo fi;
- if (fi.Find(path))
- {
- resultName = fi.Name;
- if (!fi.IsDir() && !keepName)
- {
- int dotPos = resultName.ReverseFind_Dot();
- if (dotPos > 0)
- {
- FString name2 = resultName.Left(dotPos);
- if (name2.ReverseFind_Dot() < 0)
- resultName = name2;
- }
- }
- }
- }
- return resultName;
-}
-
-
-UString CreateArchiveName(const UStringVector &paths, const NFind::CFileInfo *fi)
-{
- bool keepName = false;
- /*
- if (paths.Size() == 1)
- {
- const UString &name = paths[0];
- if (name.Len() > 4)
- if (CompareFileNames(name.RightPtr(4), L".tar") == 0)
- keepName = true;
- }
- */
-
- UString name;
- if (fi)
- name = CreateArchiveName(*fi, keepName);
- else
- {
- if (paths.IsEmpty())
- return L"archive";
- bool fromPrev = (paths.Size() > 1);
- name = Get_Correct_FsFile_Name(fs2us(CreateArchiveName2(us2fs(paths.Front()), fromPrev, keepName)));
- }
-
- UStringVector names;
-
- {
- FOR_VECTOR (i, paths)
- {
- NFind::CFileInfo fi2;
- const NFind::CFileInfo *fp;
- if (fi && paths.Size() == 1)
- fp = fi;
- else
- {
- if (!fi2.Find(us2fs(paths[i])))
- continue;
- fp = &fi2;
- }
- names.Add(fs2us(fp->Name));
- }
- }
-
- UString postfix;
- UInt32 index = 1;
-
- for (;;)
- {
- // we don't want cases when we include archive to itself.
- // so we find first available name for archive
- const UString name2 = name + postfix;
- const UString name2_zip = name2 + L".zip";
- const UString name2_7z = name2 + L".7z";
- const UString name2_tar = name2 + L".tar";
- const UString name2_wim = name2 + L".wim";
-
- unsigned i = 0;
-
- for (i = 0; i < names.Size(); i++)
- {
- const UString &fname = names[i];
- if ( 0 == CompareFileNames(fname, name2_zip)
- || 0 == CompareFileNames(fname, name2_7z)
- || 0 == CompareFileNames(fname, name2_tar)
- || 0 == CompareFileNames(fname, name2_wim))
- break;
- }
-
- if (i == names.Size())
- break;
- index++;
- postfix = "_";
- postfix.Add_UInt32(index);
- }
-
- name += postfix;
- return name;
-}
+// ArchiveName.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Sort.h"
+
+#include "../../../Common/Wildcard.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+
+#include "ArchiveName.h"
+#include "ExtractingFilePath.h"
+
+using namespace NWindows;
+using namespace NFile;
+
+
+static const char *g_ArcExts =
+ "7z"
+ "\0" "zip"
+ "\0" "tar"
+ "\0" "wim"
+ "\0";
+
+static const char *g_HashExts =
+ "sha256"
+ "\0";
+
+
+UString CreateArchiveName(
+ const UStringVector &paths,
+ bool isHash,
+ const NFind::CFileInfo *fi,
+ UString &baseName)
+{
+ bool keepName = isHash;
+ /*
+ if (paths.Size() == 1)
+ {
+ const UString &name = paths[0];
+ if (name.Len() > 4)
+ if (CompareFileNames(name.RightPtr(4), L".tar") == 0)
+ keepName = true;
+ }
+ */
+
+ UString name ("Archive");
+ NFind::CFileInfo fi3;
+ if (paths.Size() > 1)
+ fi = NULL;
+ if (!fi && paths.Size() != 0)
+ {
+ const UString &path = paths.Front();
+ if (paths.Size() == 1)
+ {
+ if (fi3.Find(us2fs(path)))
+ fi = &fi3;
+ }
+ else
+ {
+ // we try to use name of parent folder
+ FString dirPrefix;
+ if (NDir::GetOnlyDirPrefix(us2fs(path), dirPrefix))
+ {
+ if (!dirPrefix.IsEmpty() && IsPathSepar(dirPrefix.Back()))
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (NName::IsDriveRootPath_SuperAllowed(dirPrefix))
+ {
+ if (path != fs2us(dirPrefix))
+ name = dirPrefix[dirPrefix.Len() - 3]; // only letter
+ }
+ else
+ #endif
+ {
+ dirPrefix.DeleteBack();
+ if (!dirPrefix.IsEmpty())
+ {
+ const int slash = dirPrefix.ReverseFind_PathSepar();
+ if (slash >= 0 && slash != (int)dirPrefix.Len() - 1)
+ name = dirPrefix.Ptr(slash + 1);
+ else if (fi3.Find(dirPrefix))
+ name = fs2us(fi3.Name);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (fi)
+ {
+ name = fs2us(fi->Name);
+ if (!fi->IsDir() && !keepName)
+ {
+ const int dotPos = name.Find(L'.');
+ if (dotPos > 0 && name.Find(L'.', (unsigned)dotPos + 1) < 0)
+ name.DeleteFrom((unsigned)dotPos);
+ }
+ }
+ name = Get_Correct_FsFile_Name(name);
+
+ CRecordVector<UInt32> ids;
+ bool simple_IsAllowed = true;
+ // for (int y = 0; y < 10000; y++) // for debug
+ {
+ // ids.Clear();
+ UString n;
+
+ FOR_VECTOR (i, paths)
+ {
+ const UString &a = paths[i];
+ const int slash = a.ReverseFind_PathSepar();
+ // if (name.Len() >= a.Len() - slash + 1) continue;
+ const wchar_t *s = a.Ptr(slash + 1);
+ if (!IsPath1PrefixedByPath2(s, name))
+ continue;
+ s += name.Len();
+ const char *exts = isHash ? g_HashExts : g_ArcExts;
+
+ for (;;)
+ {
+ const char *ext = exts;
+ const unsigned len = MyStringLen(ext);
+ if (len == 0)
+ break;
+ exts += len + 1;
+ n = s;
+ if (n.Len() <= len)
+ continue;
+ if (!StringsAreEqualNoCase_Ascii(n.RightPtr(len), ext))
+ continue;
+ n.DeleteFrom(n.Len() - len);
+ if (n.Back() != '.')
+ continue;
+ n.DeleteBack();
+ if (n.IsEmpty())
+ {
+ simple_IsAllowed = false;
+ break;
+ }
+ if (n.Len() < 2)
+ continue;
+ if (n[0] != '_')
+ continue;
+ const wchar_t *end;
+ const UInt32 v = ConvertStringToUInt32(n.Ptr(1), &end);
+ if (*end != 0)
+ continue;
+ ids.Add(v);
+ break;
+ }
+ }
+ }
+
+ baseName = name;
+ if (!simple_IsAllowed)
+ {
+ HeapSort(&ids.Front(), ids.Size());
+ UInt32 v = 2;
+ const unsigned num = ids.Size();
+ for (unsigned i = 0; i < num; i++)
+ {
+ const UInt32 id = ids[i];
+ if (id > v)
+ break;
+ if (id == v)
+ v = id + 1;
+ }
+ name += '_';
+ name.Add_UInt32(v);
+ }
+ return name;
+}
diff --git a/CPP/7zip/UI/Common/ArchiveName.h b/CPP/7zip/UI/Common/ArchiveName.h
index ce2d192..9b6b7fe 100644
--- a/CPP/7zip/UI/Common/ArchiveName.h
+++ b/CPP/7zip/UI/Common/ArchiveName.h
@@ -1,10 +1,16 @@
-// ArchiveName.h
-
-#ifndef __ARCHIVE_NAME_H
-#define __ARCHIVE_NAME_H
-
-#include "../../../Windows/FileFind.h"
-
-UString CreateArchiveName(const UStringVector &paths, const NWindows::NFile::NFind::CFileInfo *fi = NULL);
-
-#endif
+// ArchiveName.h
+
+#ifndef ZIP7_INC_ARCHIVE_NAME_H
+#define ZIP7_INC_ARCHIVE_NAME_H
+
+#include "../../../Windows/FileFind.h"
+
+/* (fi != NULL) only if (paths.Size() == 1) */
+
+UString CreateArchiveName(
+ const UStringVector &paths,
+ bool isHash,
+ const NWindows::NFile::NFind::CFileInfo *fi,
+ UString &baseName);
+
+#endif
diff --git a/CPP/7zip/UI/Common/ArchiveOpenCallback.cpp b/CPP/7zip/UI/Common/ArchiveOpenCallback.cpp
index fd8f9f8..4e5f1f5 100644
--- a/CPP/7zip/UI/Common/ArchiveOpenCallback.cpp
+++ b/CPP/7zip/UI/Common/ArchiveOpenCallback.cpp
@@ -1,161 +1,393 @@
-// ArchiveOpenCallback.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/ComTry.h"
-
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/PropVariant.h"
-
-#include "../../Common/FileStreams.h"
-
-#include "ArchiveOpenCallback.h"
-
-using namespace NWindows;
-
-STDMETHODIMP COpenCallbackImp::SetTotal(const UInt64 *files, const UInt64 *bytes)
-{
- COM_TRY_BEGIN
- if (ReOpenCallback)
- return ReOpenCallback->SetTotal(files, bytes);
- if (!Callback)
- return S_OK;
- return Callback->Open_SetTotal(files, bytes);
- COM_TRY_END
-}
-
-STDMETHODIMP COpenCallbackImp::SetCompleted(const UInt64 *files, const UInt64 *bytes)
-{
- COM_TRY_BEGIN
- if (ReOpenCallback)
- return ReOpenCallback->SetCompleted(files, bytes);
- if (!Callback)
- return S_OK;
- return Callback->Open_SetCompleted(files, bytes);
- COM_TRY_END
-}
-
-STDMETHODIMP COpenCallbackImp::GetProperty(PROPID propID, PROPVARIANT *value)
-{
- COM_TRY_BEGIN
- NCOM::CPropVariant prop;
- if (_subArchiveMode)
- switch (propID)
- {
- case kpidName: prop = _subArchiveName; break;
- // case kpidSize: prop = _subArchiveSize; break; // we don't use it now
- }
- else
- switch (propID)
- {
- case kpidName: prop = _fileInfo.Name; break;
- case kpidIsDir: prop = _fileInfo.IsDir(); break;
- case kpidSize: prop = _fileInfo.Size; break;
- case kpidAttrib: prop = (UInt32)_fileInfo.Attrib; break;
- case kpidCTime: prop = _fileInfo.CTime; break;
- case kpidATime: prop = _fileInfo.ATime; break;
- case kpidMTime: prop = _fileInfo.MTime; break;
- }
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
-}
-
-struct CInFileStreamVol: public CInFileStream
-{
- int FileNameIndex;
- COpenCallbackImp *OpenCallbackImp;
- CMyComPtr<IArchiveOpenCallback> OpenCallbackRef;
-
- ~CInFileStreamVol()
- {
- if (OpenCallbackRef)
- OpenCallbackImp->FileNames_WasUsed[FileNameIndex] = false;
- }
-};
-
-
-// from ArchiveExtractCallback.cpp
-bool IsSafePath(const UString &path);
-
-STDMETHODIMP COpenCallbackImp::GetStream(const wchar_t *name, IInStream **inStream)
-{
- COM_TRY_BEGIN
- *inStream = NULL;
-
- if (_subArchiveMode)
- return S_FALSE;
- if (Callback)
- {
- RINOK(Callback->Open_CheckBreak());
- }
-
- UString name2 = name;
-
-
- #ifndef _SFX
-
- #ifdef _WIN32
- name2.Replace(L'/', WCHAR_PATH_SEPARATOR);
- #endif
-
- // if (!allowAbsVolPaths)
- if (!IsSafePath(name2))
- return S_FALSE;
-
- // #ifdef _WIN32
- // we don't want to support wildcards in names here here
- if (name2.Find(L'?') >= 0 ||
- name2.Find(L'*') >= 0)
- return S_FALSE;
- // #endif
-
- #endif
-
-
- FString fullPath;
- if (!NFile::NName::GetFullPath(_folderPrefix, us2fs(name2), fullPath))
- return S_FALSE;
- if (!_fileInfo.Find(fullPath))
- return S_FALSE;
- if (_fileInfo.IsDir())
- return S_FALSE;
- CInFileStreamVol *inFile = new CInFileStreamVol;
- CMyComPtr<IInStream> inStreamTemp = inFile;
- if (!inFile->Open(fullPath))
- {
- DWORD lastError = ::GetLastError();
- if (lastError == 0)
- return E_FAIL;
- return HRESULT_FROM_WIN32(lastError);
- }
-
- FileSizes.Add(_fileInfo.Size);
- FileNames.Add(name2);
- inFile->FileNameIndex = FileNames_WasUsed.Add(true);
- inFile->OpenCallbackImp = this;
- inFile->OpenCallbackRef = this;
- // TotalSize += _fileInfo.Size;
- *inStream = inStreamTemp.Detach();
- return S_OK;
- COM_TRY_END
-}
-
-#ifndef _NO_CRYPTO
-STDMETHODIMP COpenCallbackImp::CryptoGetTextPassword(BSTR *password)
-{
- COM_TRY_BEGIN
- if (ReOpenCallback)
- {
- CMyComPtr<ICryptoGetTextPassword> getTextPassword;
- ReOpenCallback.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
- if (getTextPassword)
- return getTextPassword->CryptoGetTextPassword(password);
- }
- if (!Callback)
- return E_NOTIMPL;
- PasswordWasAsked = true;
- return Callback->Open_CryptoGetTextPassword(password);
- COM_TRY_END
-}
-#endif
+// ArchiveOpenCallback.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/System.h"
+
+#include "../../Common/StreamUtils.h"
+
+#include "ArchiveOpenCallback.h"
+
+// #define DEBUG_VOLUMES
+
+#ifdef DEBUG_VOLUMES
+#include <stdio.h>
+#endif
+
+
+#ifdef DEBUG_VOLUMES
+ #define PRF(x) x
+#else
+ #define PRF(x)
+#endif
+
+using namespace NWindows;
+
+HRESULT COpenCallbackImp::Init2(const FString &folderPrefix, const FString &fileName)
+{
+ Volumes.Init();
+ FileNames.Clear();
+ FileNames_WasUsed.Clear();
+ FileSizes.Clear();
+ _subArchiveMode = false;
+ // TotalSize = 0;
+ PasswordWasAsked = false;
+ _folderPrefix = folderPrefix;
+ if (!_fileInfo.Find_FollowLink(_folderPrefix + fileName))
+ {
+ // throw 20121118;
+ return GetLastError_noZero_HRESULT();
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COpenCallbackImp::SetSubArchiveName(const wchar_t *name))
+{
+ _subArchiveMode = true;
+ _subArchiveName = name;
+ // TotalSize = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COpenCallbackImp::SetTotal(const UInt64 *files, const UInt64 *bytes))
+{
+ COM_TRY_BEGIN
+ if (ReOpenCallback)
+ return ReOpenCallback->SetTotal(files, bytes);
+ if (!Callback)
+ return S_OK;
+ return Callback->Open_SetTotal(files, bytes);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(COpenCallbackImp::SetCompleted(const UInt64 *files, const UInt64 *bytes))
+{
+ COM_TRY_BEGIN
+ if (ReOpenCallback)
+ return ReOpenCallback->SetCompleted(files, bytes);
+ if (!Callback)
+ return S_OK;
+ return Callback->Open_SetCompleted(files, bytes);
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(COpenCallbackImp::GetProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ if (_subArchiveMode)
+ switch (propID)
+ {
+ case kpidName: prop = _subArchiveName; break;
+ // case kpidSize: prop = _subArchiveSize; break; // we don't use it now
+ }
+ else
+ switch (propID)
+ {
+ case kpidName: prop = fs2us(_fileInfo.Name); break;
+ case kpidIsDir: prop = _fileInfo.IsDir(); break;
+ case kpidSize: prop = _fileInfo.Size; break;
+ case kpidAttrib: prop = (UInt32)_fileInfo.GetWinAttrib(); break;
+ case kpidPosixAttrib: prop = (UInt32)_fileInfo.GetPosixAttrib(); break;
+ case kpidCTime: PropVariant_SetFrom_FiTime(prop, _fileInfo.CTime); break;
+ case kpidATime: PropVariant_SetFrom_FiTime(prop, _fileInfo.ATime); break;
+ case kpidMTime: PropVariant_SetFrom_FiTime(prop, _fileInfo.MTime); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+// ---------- CInFileStreamVol ----------
+
+Z7_CLASS_IMP_COM_2(
+ CInFileStreamVol
+ , IInStream
+ , IStreamGetSize
+)
+ Z7_IFACE_COM7_IMP(ISequentialInStream)
+public:
+ unsigned FileIndex;
+ COpenCallbackImp *OpenCallbackImp;
+ CMyComPtr<IArchiveOpenCallback> OpenCallbackRef;
+
+ HRESULT EnsureOpen()
+ {
+ return OpenCallbackImp->Volumes.EnsureOpen(FileIndex);
+ }
+
+ ~CInFileStreamVol()
+ {
+ if (OpenCallbackRef)
+ OpenCallbackImp->AtCloseFile(FileIndex);
+ }
+};
+
+
+void CMultiStreams::InsertToList(unsigned index)
+{
+ {
+ CSubStream &s = Streams[index];
+ s.Next = Head;
+ s.Prev = -1;
+ }
+ if (Head != -1)
+ Streams[(unsigned)Head].Prev = (int)index;
+ else
+ {
+ // if (Tail != -1) throw 1;
+ Tail = (int)index;
+ }
+ Head = (int)index;
+ NumListItems++;
+}
+
+// s must bee in List
+void CMultiStreams::RemoveFromList(CSubStream &s)
+{
+ if (s.Next != -1) Streams[(unsigned)s.Next].Prev = s.Prev; else Tail = s.Prev;
+ if (s.Prev != -1) Streams[(unsigned)s.Prev].Next = s.Next; else Head = s.Next;
+ s.Next = -1; // optional
+ s.Prev = -1; // optional
+ NumListItems--;
+}
+
+void CMultiStreams::CloseFile(unsigned index)
+{
+ CSubStream &s = Streams[index];
+ if (s.Stream)
+ {
+ s.Stream.Release();
+ RemoveFromList(s);
+ // s.InFile->Close();
+ // s.IsOpen = false;
+ #ifdef DEBUG_VOLUMES
+ static int numClosing = 0;
+ numClosing++;
+ printf("\nCloseFile %u, total_closes = %u, num_open_files = %u\n", index, numClosing, NumListItems);
+ #endif
+ }
+}
+
+void CMultiStreams::Init()
+{
+ Head = -1;
+ Tail = -1;
+ NumListItems = 0;
+ Streams.Clear();
+}
+
+CMultiStreams::CMultiStreams():
+ Head(-1),
+ Tail(-1),
+ NumListItems(0)
+{
+ NumOpenFiles_AllowedMax = NSystem::Get_File_OPEN_MAX_Reduced_for_3_tasks();
+ PRF(printf("\nNumOpenFiles_Limit = %u\n", NumOpenFiles_AllowedMax));
+}
+
+
+HRESULT CMultiStreams::PrepareToOpenNew()
+{
+ if (NumListItems < NumOpenFiles_AllowedMax)
+ return S_OK;
+ if (Tail == -1)
+ return E_FAIL;
+ CMultiStreams::CSubStream &tailStream = Streams[(unsigned)Tail];
+ RINOK(InStream_GetPos(tailStream.Stream, tailStream.LocalPos))
+ CloseFile((unsigned)Tail);
+ return S_OK;
+}
+
+
+HRESULT CMultiStreams::EnsureOpen(unsigned index)
+{
+ CMultiStreams::CSubStream &s = Streams[index];
+ if (s.Stream)
+ {
+ if ((int)index != Head)
+ {
+ RemoveFromList(s);
+ InsertToList(index);
+ }
+ }
+ else
+ {
+ RINOK(PrepareToOpenNew())
+ {
+ CInFileStream *inFile = new CInFileStream;
+ CMyComPtr<IInStream> inStreamTemp = inFile;
+ if (!inFile->Open(s.Path))
+ return GetLastError_noZero_HRESULT();
+ s.FileSpec = inFile;
+ s.Stream = s.FileSpec;
+ InsertToList(index);
+ }
+ // s.IsOpen = true;
+ if (s.LocalPos != 0)
+ {
+ RINOK(s.Stream->Seek((Int64)s.LocalPos, STREAM_SEEK_SET, &s.LocalPos))
+ }
+ #ifdef DEBUG_VOLUMES
+ static int numOpens = 0;
+ numOpens++;
+ printf("\n-- %u, ReOpen, total_reopens = %u, num_open_files = %u\n", index, numOpens, NumListItems);
+ #endif
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CInFileStreamVol::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ RINOK(EnsureOpen())
+ CMultiStreams::CSubStream &s = OpenCallbackImp->Volumes.Streams[FileIndex];
+ PRF(printf("\n== %u, Read =%u \n", FileIndex, size));
+ return s.Stream->Read(data, size, processedSize);
+}
+
+Z7_COM7F_IMF(CInFileStreamVol::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+{
+ // if (seekOrigin >= 3) return STG_E_INVALIDFUNCTION;
+ RINOK(EnsureOpen())
+ CMultiStreams::CSubStream &s = OpenCallbackImp->Volumes.Streams[FileIndex];
+ PRF(printf("\n-- %u, Seek seekOrigin=%u Seek =%u\n", FileIndex, seekOrigin, (unsigned)offset));
+ return s.Stream->Seek(offset, seekOrigin, newPosition);
+}
+
+Z7_COM7F_IMF(CInFileStreamVol::GetSize(UInt64 *size))
+{
+ RINOK(EnsureOpen())
+ CMultiStreams::CSubStream &s = OpenCallbackImp->Volumes.Streams[FileIndex];
+ return s.FileSpec->GetSize(size);
+}
+
+
+// from ArchiveExtractCallback.cpp
+bool IsSafePath(const UString &path);
+
+Z7_COM7F_IMF(COpenCallbackImp::GetStream(const wchar_t *name, IInStream **inStream))
+{
+ COM_TRY_BEGIN
+ *inStream = NULL;
+
+ if (_subArchiveMode)
+ return S_FALSE;
+ if (Callback)
+ {
+ RINOK(Callback->Open_CheckBreak())
+ }
+
+ UString name2 = name;
+
+
+ #ifndef Z7_SFX
+
+ #ifdef _WIN32
+ name2.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+
+ // if (!allowAbsVolPaths)
+ if (!IsSafePath(name2))
+ return S_FALSE;
+
+ #ifdef _WIN32
+ /* WIN32 allows wildcards in Find() function
+ and doesn't allow wildcard in File.Open()
+ so we can work without the following wildcard check here */
+ if (name2.Find(L'*') >= 0)
+ return S_FALSE;
+ {
+ unsigned startPos = 0;
+ if (name2.IsPrefixedBy_Ascii_NoCase("\\\\?\\"))
+ startPos = 3;
+ if (name2.Find(L'?', startPos) >= 0)
+ return S_FALSE;
+ }
+ #endif
+
+ #endif
+
+
+ FString fullPath;
+ if (!NFile::NName::GetFullPath(_folderPrefix, us2fs(name2), fullPath))
+ return S_FALSE;
+ if (!_fileInfo.Find_FollowLink(fullPath))
+ return S_FALSE;
+ if (_fileInfo.IsDir())
+ return S_FALSE;
+
+ CMultiStreams::CSubStream s;
+
+ {
+ CInFileStream *inFile = new CInFileStream;
+ CMyComPtr<IInStream> inStreamTemp = inFile;
+ if (!inFile->Open(fullPath))
+ return GetLastError_noZero_HRESULT();
+ RINOK(Volumes.PrepareToOpenNew())
+ s.FileSpec = inFile;
+ s.Stream = s.FileSpec;
+ s.Path = fullPath;
+ // s.Size = _fileInfo.Size;
+ // s.IsOpen = true;
+ }
+
+ const unsigned fileIndex = Volumes.Streams.Add(s);
+ Volumes.InsertToList(fileIndex);
+
+ FileSizes.Add(_fileInfo.Size);
+ FileNames.Add(name2);
+ FileNames_WasUsed.Add(true);
+
+ CInFileStreamVol *inFile = new CInFileStreamVol;
+ CMyComPtr<IInStream> inStreamTemp = inFile;
+ inFile->FileIndex = fileIndex;
+ inFile->OpenCallbackImp = this;
+ inFile->OpenCallbackRef = this;
+ // TotalSize += _fileInfo.Size;
+ *inStream = inStreamTemp.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+
+#ifndef Z7_NO_CRYPTO
+Z7_COM7F_IMF(COpenCallbackImp::CryptoGetTextPassword(BSTR *password))
+{
+ COM_TRY_BEGIN
+ if (ReOpenCallback)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ICryptoGetTextPassword,
+ getTextPassword, ReOpenCallback)
+ if (getTextPassword)
+ return getTextPassword->CryptoGetTextPassword(password);
+ }
+ if (!Callback)
+ return E_NOTIMPL;
+ PasswordWasAsked = true;
+ return Callback->Open_CryptoGetTextPassword(password);
+ COM_TRY_END
+}
+#endif
+
+// IProgress
+Z7_COM7F_IMF(COpenCallbackImp::SetTotal(const UInt64 /* total */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COpenCallbackImp::SetCompleted(const UInt64 * /* completed */))
+{
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Common/ArchiveOpenCallback.h b/CPP/7zip/UI/Common/ArchiveOpenCallback.h
index 7f7548f..4e44c9d 100644
--- a/CPP/7zip/UI/Common/ArchiveOpenCallback.h
+++ b/CPP/7zip/UI/Common/ArchiveOpenCallback.h
@@ -1,112 +1,181 @@
-// ArchiveOpenCallback.h
-
-#ifndef __ARCHIVE_OPEN_CALLBACK_H
-#define __ARCHIVE_OPEN_CALLBACK_H
-
-#include "../../../Common/MyCom.h"
-
-#include "../../../Windows/FileFind.h"
-
-#ifndef _NO_CRYPTO
-#include "../../IPassword.h"
-#endif
-#include "../../Archive/IArchive.h"
-
-#ifdef _NO_CRYPTO
-
-#define INTERFACE_IOpenCallbackUI_Crypto(x)
-
-#else
-
-#define INTERFACE_IOpenCallbackUI_Crypto(x) \
- virtual HRESULT Open_CryptoGetTextPassword(BSTR *password) x; \
- /* virtual HRESULT Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password) x; */ \
- /* virtual bool Open_WasPasswordAsked() x; */ \
- /* virtual void Open_Clear_PasswordWasAsked_Flag() x; */ \
-
-#endif
-
-#define INTERFACE_IOpenCallbackUI(x) \
- virtual HRESULT Open_CheckBreak() x; \
- virtual HRESULT Open_SetTotal(const UInt64 *files, const UInt64 *bytes) x; \
- virtual HRESULT Open_SetCompleted(const UInt64 *files, const UInt64 *bytes) x; \
- virtual HRESULT Open_Finished() x; \
- INTERFACE_IOpenCallbackUI_Crypto(x)
-
-struct IOpenCallbackUI
-{
- INTERFACE_IOpenCallbackUI(=0)
-};
-
-class COpenCallbackImp:
- public IArchiveOpenCallback,
- public IArchiveOpenVolumeCallback,
- public IArchiveOpenSetSubArchiveName,
- #ifndef _NO_CRYPTO
- public ICryptoGetTextPassword,
- #endif
- public CMyUnknownImp
-{
-public:
- MY_QUERYINTERFACE_BEGIN2(IArchiveOpenVolumeCallback)
- MY_QUERYINTERFACE_ENTRY(IArchiveOpenSetSubArchiveName)
- #ifndef _NO_CRYPTO
- MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- INTERFACE_IArchiveOpenCallback(;)
- INTERFACE_IArchiveOpenVolumeCallback(;)
-
- #ifndef _NO_CRYPTO
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
- #endif
-
- STDMETHOD(SetSubArchiveName(const wchar_t *name))
- {
- _subArchiveMode = true;
- _subArchiveName = name;
- // TotalSize = 0;
- return S_OK;
- }
-
-private:
- FString _folderPrefix;
- NWindows::NFile::NFind::CFileInfo _fileInfo;
- bool _subArchiveMode;
- UString _subArchiveName;
-
-public:
- UStringVector FileNames;
- CBoolVector FileNames_WasUsed;
- CRecordVector<UInt64> FileSizes;
-
- bool PasswordWasAsked;
-
- IOpenCallbackUI *Callback;
- CMyComPtr<IArchiveOpenCallback> ReOpenCallback;
- // UInt64 TotalSize;
-
- COpenCallbackImp(): Callback(NULL), _subArchiveMode(false) {}
-
- void Init(const FString &folderPrefix, const FString &fileName)
- {
- _folderPrefix = folderPrefix;
- if (!_fileInfo.Find(_folderPrefix + fileName))
- throw 20121118;
- FileNames.Clear();
- FileNames_WasUsed.Clear();
- FileSizes.Clear();
- _subArchiveMode = false;
- // TotalSize = 0;
- PasswordWasAsked = false;
- }
-
- bool SetSecondFileInfo(CFSTR newName)
- {
- return _fileInfo.Find(newName) && !_fileInfo.IsDir();
- }
-};
-
-#endif
+// ArchiveOpenCallback.h
+
+#ifndef ZIP7_INC_ARCHIVE_OPEN_CALLBACK_H
+#define ZIP7_INC_ARCHIVE_OPEN_CALLBACK_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../Common/FileStreams.h"
+
+#ifndef Z7_NO_CRYPTO
+#include "../../IPassword.h"
+#endif
+#include "../../Archive/IArchive.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#ifdef Z7_NO_CRYPTO
+
+#define Z7_IFACEM_IOpenCallbackUI_Crypto(x)
+
+#else
+
+#define Z7_IFACEM_IOpenCallbackUI_Crypto(x) \
+ virtual HRESULT Open_CryptoGetTextPassword(BSTR *password) x \
+ /* virtual HRESULT Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password) x */ \
+ /* virtual bool Open_WasPasswordAsked() x */ \
+ /* virtual void Open_Clear_PasswordWasAsked_Flag() x */ \
+
+#endif
+
+#define Z7_IFACEN_IOpenCallbackUI(x) \
+ virtual HRESULT Open_CheckBreak() x \
+ virtual HRESULT Open_SetTotal(const UInt64 *files, const UInt64 *bytes) x \
+ virtual HRESULT Open_SetCompleted(const UInt64 *files, const UInt64 *bytes) x \
+ virtual HRESULT Open_Finished() x \
+ Z7_IFACEM_IOpenCallbackUI_Crypto(x)
+
+Z7_IFACE_DECL_PURE(IOpenCallbackUI)
+
+Z7_PURE_INTERFACES_END
+
+
+class CMultiStreams Z7_final
+{
+public:
+ struct CSubStream
+ {
+ CMyComPtr<IInStream> Stream;
+ CInFileStream *FileSpec;
+ FString Path;
+ // UInt64 Size;
+ UInt64 LocalPos;
+ int Next; // next older
+ int Prev; // prev newer
+ // bool IsOpen;
+
+ CSubStream():
+ FileSpec(NULL),
+ // Size(0),
+ LocalPos(0),
+ Next(-1),
+ Prev(-1)
+ // IsOpen(false)
+ {}
+ };
+
+ CObjectVector<CSubStream> Streams;
+private:
+ // we must use critical section here, if we want to access from different volumnes simultaneously
+ int Head; // newest
+ int Tail; // oldest
+ unsigned NumListItems;
+ unsigned NumOpenFiles_AllowedMax;
+public:
+
+ CMultiStreams();
+ void Init();
+ HRESULT PrepareToOpenNew();
+ void InsertToList(unsigned index);
+ void RemoveFromList(CSubStream &s);
+ void CloseFile(unsigned index);
+ HRESULT EnsureOpen(unsigned index);
+};
+
+
+/*
+ We need COpenCallbackImp class for multivolume processing.
+ Also we use it as proxy from COM interfaces (IArchiveOpenCallback) to internal (IOpenCallbackUI) interfaces.
+ If archive is multivolume:
+ COpenCallbackImp object will exist after Open stage.
+ COpenCallbackImp object will be deleted when last reference
+ from each volume object (CInFileStreamVol) will be closed (when archive will be closed).
+*/
+
+class COpenCallbackImp Z7_final:
+ public IArchiveOpenCallback,
+ public IArchiveOpenVolumeCallback,
+ public IArchiveOpenSetSubArchiveName,
+ #ifndef Z7_NO_CRYPTO
+ public ICryptoGetTextPassword,
+ #endif
+ public IProgress, // IProgress is used for 7zFM
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IArchiveOpenCallback)
+ Z7_COM_QI_ENTRY(IArchiveOpenVolumeCallback)
+ Z7_COM_QI_ENTRY(IArchiveOpenSetSubArchiveName)
+ #ifndef Z7_NO_CRYPTO
+ Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+ #endif
+ // Z7_COM_QI_ENTRY(IProgress) // the code doesn't require it
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IArchiveOpenCallback)
+ Z7_IFACE_COM7_IMP(IArchiveOpenVolumeCallback)
+ Z7_IFACE_COM7_IMP(IProgress)
+public:
+ Z7_IFACE_COM7_IMP(IArchiveOpenSetSubArchiveName)
+private:
+ #ifndef Z7_NO_CRYPTO
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ #endif
+
+ bool _subArchiveMode;
+
+public:
+ bool PasswordWasAsked;
+ UStringVector FileNames;
+ CBoolVector FileNames_WasUsed;
+ CRecordVector<UInt64> FileSizes;
+
+ void AtCloseFile(unsigned fileIndex)
+ {
+ FileNames_WasUsed[fileIndex] = false;
+ Volumes.CloseFile(fileIndex);
+ }
+
+ /* we have two ways to Callback from this object
+ 1) IArchiveOpenCallback * ReOpenCallback - for ReOpen function, when IOpenCallbackUI is not available
+ 2) IOpenCallbackUI *Callback - for usual callback
+ we can't transfer IOpenCallbackUI pointer via internal interface,
+ so we use ReOpenCallback to callback without IOpenCallbackUI.
+ */
+
+ /* we use Callback/ReOpenCallback only at Open stage.
+ So the CMyComPtr reference counter is not required,
+ and we don't want additional reference to unused object,
+ if COpenCallbackImp is not closed
+ */
+ IArchiveOpenCallback *ReOpenCallback;
+ // CMyComPtr<IArchiveOpenCallback> ReOpenCallback;
+ IOpenCallbackUI *Callback;
+ // CMyComPtr<IUnknown> Callback_Ref;
+
+private:
+ FString _folderPrefix;
+ UString _subArchiveName;
+ NWindows::NFile::NFind::CFileInfo _fileInfo;
+
+public:
+ CMultiStreams Volumes;
+
+ // UInt64 TotalSize;
+
+ COpenCallbackImp():
+ _subArchiveMode(false),
+ ReOpenCallback(NULL),
+ Callback(NULL) {}
+
+ HRESULT Init2(const FString &folderPrefix, const FString &fileName);
+
+ bool SetSecondFileInfo(CFSTR newName)
+ {
+ return _fileInfo.Find_FollowLink(newName) && !_fileInfo.IsDir();
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/Bench.cpp b/CPP/7zip/UI/Common/Bench.cpp
index 3fb0758..5da9783 100644
--- a/CPP/7zip/UI/Common/Bench.cpp
+++ b/CPP/7zip/UI/Common/Bench.cpp
@@ -1,3618 +1,4872 @@
-// Bench.cpp
-
-#include "StdAfx.h"
-
-#include <stdio.h>
-
-#ifndef _WIN32
-#define USE_POSIX_TIME
-#define USE_POSIX_TIME2
-#endif
-
-#ifdef USE_POSIX_TIME
-#include <time.h>
-#ifdef USE_POSIX_TIME2
-#include <sys/time.h>
-#endif
-#endif
-
-#ifdef _WIN32
-#define USE_ALLOCA
-#endif
-
-#ifdef USE_ALLOCA
-#ifdef _WIN32
-#include <malloc.h>
-#else
-#include <stdlib.h>
-#endif
-#endif
-
-#include "../../../../C/7zCrc.h"
-#include "../../../../C/CpuArch.h"
-
-#ifndef _7ZIP_ST
-#include "../../../Windows/Synchronization.h"
-#include "../../../Windows/Thread.h"
-#endif
-
-#if defined(_WIN32) || defined(UNIX_USE_WIN_FILE)
-#define USE_WIN_FILE
-#endif
-
-#ifdef USE_WIN_FILE
-#include "../../../Windows/FileIO.h"
-#endif
-
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/MyBuffer2.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/StringToInt.h"
-
-#include "../../Common/MethodProps.h"
-#include "../../Common/StreamUtils.h"
-
-#include "Bench.h"
-
-using namespace NWindows;
-
-static const UInt32 k_LZMA = 0x030101;
-
-static const UInt64 kComplexInCommands = (UInt64)1 <<
- #ifdef UNDER_CE
- 31;
- #else
- 34;
- #endif
-
-static const UInt32 kComplexInSeconds = 4;
-
-static void SetComplexCommands(UInt32 complexInSeconds,
- bool isSpecifiedFreq, UInt64 cpuFreq, UInt64 &complexInCommands)
-{
- complexInCommands = kComplexInCommands;
- const UInt64 kMinFreq = (UInt64)1000000 * 4;
- const UInt64 kMaxFreq = (UInt64)1000000 * 20000;
- if (cpuFreq < kMinFreq && !isSpecifiedFreq)
- cpuFreq = kMinFreq;
- if (cpuFreq < kMaxFreq || isSpecifiedFreq)
- {
- if (complexInSeconds != 0)
- complexInCommands = complexInSeconds * cpuFreq;
- else
- complexInCommands = cpuFreq >> 2;
- }
-}
-
-static const unsigned kNumHashDictBits = 17;
-static const UInt32 kFilterUnpackSize = (48 << 10);
-
-static const unsigned kOldLzmaDictBits = 30;
-
-static const UInt32 kAdditionalSize = (1 << 16);
-static const UInt32 kCompressedAdditionalSize = (1 << 10);
-static const UInt32 kMaxLzmaPropSize = 5;
-
-
-
-#define ALLOC_WITH_HRESULT(_buffer_, _size_) \
- (_buffer_)->Alloc(_size_); \
- if (!(_buffer_)->IsAllocated()) return E_OUTOFMEMORY;
-
-
-class CBaseRandomGenerator
-{
- UInt32 A1;
- UInt32 A2;
- UInt32 Salt;
-public:
- CBaseRandomGenerator(UInt32 salt = 0): Salt(salt) { Init(); }
- void Init() { A1 = 362436069; A2 = 521288629;}
- UInt32 GetRnd()
- {
- return Salt ^
- (
- ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) +
- ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)) )
- );
- }
-};
-
-
-class CBenchRandomGenerator: public CAlignedBuffer
-{
- static UInt32 GetVal(UInt32 &res, unsigned numBits)
- {
- UInt32 val = res & (((UInt32)1 << numBits) - 1);
- res >>= numBits;
- return val;
- }
-
- static UInt32 GetLen(UInt32 &r)
- {
- UInt32 len = GetVal(r, 2);
- return GetVal(r, 1 + len);
- }
-
-public:
-
- void GenerateSimpleRandom(UInt32 salt)
- {
- CBaseRandomGenerator rg(salt);
- const size_t bufSize = Size();
- Byte *buf = (Byte *)*this;
- for (size_t i = 0; i < bufSize; i++)
- buf[i] = (Byte)rg.GetRnd();
- }
-
- void GenerateLz(unsigned dictBits, UInt32 salt)
- {
- CBaseRandomGenerator rg(salt);
- UInt32 pos = 0;
- UInt32 rep0 = 1;
- const size_t bufSize = Size();
- Byte *buf = (Byte *)*this;
- unsigned posBits = 1;
-
- while (pos < bufSize)
- {
- UInt32 r = rg.GetRnd();
- if (GetVal(r, 1) == 0 || pos < 1024)
- buf[pos++] = (Byte)(r & 0xFF);
- else
- {
- UInt32 len;
- len = 1 + GetLen(r);
-
- if (GetVal(r, 3) != 0)
- {
- len += GetLen(r);
-
- while (((UInt32)1 << posBits) < pos)
- posBits++;
-
- unsigned numBitsMax = dictBits;
- if (numBitsMax > posBits)
- numBitsMax = posBits;
-
- const unsigned kAddBits = 6;
- unsigned numLogBits = 5;
- if (numBitsMax <= (1 << 4) - 1 + kAddBits)
- numLogBits = 4;
-
- for (;;)
- {
- UInt32 ppp = GetVal(r, numLogBits) + kAddBits;
- r = rg.GetRnd();
- if (ppp > numBitsMax)
- continue;
- rep0 = GetVal(r, ppp);
- if (rep0 < pos)
- break;
- r = rg.GetRnd();
- }
- rep0++;
- }
-
- {
- UInt32 rem = (UInt32)bufSize - pos;
- if (len > rem)
- len = rem;
- }
- Byte *dest = buf + pos;
- const Byte *src = dest - rep0;
- pos += len;
- for (UInt32 i = 0; i < len; i++)
- *dest++ = *src++;
- }
- }
- }
-};
-
-
-class CBenchmarkInStream:
- public ISequentialInStream,
- public CMyUnknownImp
-{
- const Byte *Data;
- size_t Pos;
- size_t Size;
-public:
- MY_UNKNOWN_IMP
- void Init(const Byte *data, size_t size)
- {
- Data = data;
- Size = size;
- Pos = 0;
- }
- STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CBenchmarkInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
- size_t remain = Size - Pos;
- UInt32 kMaxBlockSize = (1 << 20);
- if (size > kMaxBlockSize)
- size = kMaxBlockSize;
- if (size > remain)
- size = (UInt32)remain;
- for (UInt32 i = 0; i < size; i++)
- ((Byte *)data)[i] = Data[Pos + i];
- Pos += size;
- if (processedSize)
- *processedSize = size;
- return S_OK;
-}
-
-class CBenchmarkOutStream:
- public ISequentialOutStream,
- public CAlignedBuffer,
- public CMyUnknownImp
-{
- // bool _overflow;
-public:
- size_t Pos;
- bool RealCopy;
- bool CalcCrc;
- UInt32 Crc;
-
- // CBenchmarkOutStream(): _overflow(false) {}
- void Init(bool realCopy, bool calcCrc)
- {
- Crc = CRC_INIT_VAL;
- RealCopy = realCopy;
- CalcCrc = calcCrc;
- // _overflow = false;
- Pos = 0;
- }
-
- // void Print() { printf("\n%8d %8d\n", (unsigned)BufferSize, (unsigned)Pos); }
-
- MY_UNKNOWN_IMP
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CBenchmarkOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- size_t curSize = Size() - Pos;
- if (curSize > size)
- curSize = size;
- if (curSize != 0)
- {
- if (RealCopy)
- memcpy(((Byte *)*this) + Pos, data, curSize);
- if (CalcCrc)
- Crc = CrcUpdate(Crc, data, curSize);
- Pos += curSize;
- }
- if (processedSize)
- *processedSize = (UInt32)curSize;
- if (curSize != size)
- {
- // _overflow = true;
- return E_FAIL;
- }
- return S_OK;
-}
-
-class CCrcOutStream:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
-public:
- bool CalcCrc;
- UInt32 Crc;
- MY_UNKNOWN_IMP
-
- CCrcOutStream(): CalcCrc(true) {};
- void Init() { Crc = CRC_INIT_VAL; }
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP CCrcOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (CalcCrc)
- Crc = CrcUpdate(Crc, data, size);
- if (processedSize)
- *processedSize = size;
- return S_OK;
-}
-
-static UInt64 GetTimeCount()
-{
- #ifdef USE_POSIX_TIME
- #ifdef USE_POSIX_TIME2
- timeval v;
- if (gettimeofday(&v, 0) == 0)
- return (UInt64)(v.tv_sec) * 1000000 + v.tv_usec;
- return (UInt64)time(NULL) * 1000000;
- #else
- return time(NULL);
- #endif
- #else
- /*
- LARGE_INTEGER value;
- if (::QueryPerformanceCounter(&value))
- return value.QuadPart;
- */
- return GetTickCount();
- #endif
-}
-
-static UInt64 GetFreq()
-{
- #ifdef USE_POSIX_TIME
- #ifdef USE_POSIX_TIME2
- return 1000000;
- #else
- return 1;
- #endif
- #else
- /*
- LARGE_INTEGER value;
- if (::QueryPerformanceFrequency(&value))
- return value.QuadPart;
- */
- return 1000;
- #endif
-}
-
-#ifdef USE_POSIX_TIME
-
-struct CUserTime
-{
- UInt64 Sum;
- clock_t Prev;
-
- void Init()
- {
- Prev = clock();
- Sum = 0;
- }
-
- UInt64 GetUserTime()
- {
- clock_t v = clock();
- Sum += v - Prev;
- Prev = v;
- return Sum;
- }
-};
-
-#else
-
-static inline UInt64 GetTime64(const FILETIME &t) { return ((UInt64)t.dwHighDateTime << 32) | t.dwLowDateTime; }
-UInt64 GetWinUserTime()
-{
- FILETIME creationTime, exitTime, kernelTime, userTime;
- if (
- #ifdef UNDER_CE
- ::GetThreadTimes(::GetCurrentThread()
- #else
- ::GetProcessTimes(::GetCurrentProcess()
- #endif
- , &creationTime, &exitTime, &kernelTime, &userTime) != 0)
- return GetTime64(userTime) + GetTime64(kernelTime);
- return (UInt64)GetTickCount() * 10000;
-}
-
-struct CUserTime
-{
- UInt64 StartTime;
-
- void Init() { StartTime = GetWinUserTime(); }
- UInt64 GetUserTime() { return GetWinUserTime() - StartTime; }
-};
-
-#endif
-
-static UInt64 GetUserFreq()
-{
- #ifdef USE_POSIX_TIME
- return CLOCKS_PER_SEC;
- #else
- return 10000000;
- #endif
-}
-
-class CBenchProgressStatus
-{
- #ifndef _7ZIP_ST
- NSynchronization::CCriticalSection CS;
- #endif
-public:
- HRESULT Res;
- bool EncodeMode;
- void SetResult(HRESULT res)
- {
- #ifndef _7ZIP_ST
- NSynchronization::CCriticalSectionLock lock(CS);
- #endif
- Res = res;
- }
- HRESULT GetResult()
- {
- #ifndef _7ZIP_ST
- NSynchronization::CCriticalSectionLock lock(CS);
- #endif
- return Res;
- }
-};
-
-struct CBenchInfoCalc
-{
- CBenchInfo BenchInfo;
- CUserTime UserTime;
-
- void SetStartTime();
- void SetFinishTime(CBenchInfo &dest);
-};
-
-void CBenchInfoCalc::SetStartTime()
-{
- BenchInfo.GlobalFreq = GetFreq();
- BenchInfo.UserFreq = GetUserFreq();
- BenchInfo.GlobalTime = ::GetTimeCount();
- BenchInfo.UserTime = 0;
- UserTime.Init();
-}
-
-void CBenchInfoCalc::SetFinishTime(CBenchInfo &dest)
-{
- dest = BenchInfo;
- dest.GlobalTime = ::GetTimeCount() - BenchInfo.GlobalTime;
- dest.UserTime = UserTime.GetUserTime();
-}
-
-class CBenchProgressInfo:
- public ICompressProgressInfo,
- public CMyUnknownImp,
- public CBenchInfoCalc
-{
-public:
- CBenchProgressStatus *Status;
- IBenchCallback *Callback;
-
- CBenchProgressInfo(): Callback(NULL) {}
- MY_UNKNOWN_IMP
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-};
-
-STDMETHODIMP CBenchProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
- HRESULT res = Status->GetResult();
- if (res != S_OK)
- return res;
- if (!Callback)
- return res;
- CBenchInfo info;
- SetFinishTime(info);
- if (Status->EncodeMode)
- {
- info.UnpackSize = BenchInfo.UnpackSize + *inSize;
- info.PackSize = BenchInfo.PackSize + *outSize;
- res = Callback->SetEncodeResult(info, false);
- }
- else
- {
- info.PackSize = BenchInfo.PackSize + *inSize;
- info.UnpackSize = BenchInfo.UnpackSize + *outSize;
- res = Callback->SetDecodeResult(info, false);
- }
- if (res != S_OK)
- Status->SetResult(res);
- return res;
-}
-
-static const unsigned kSubBits = 8;
-
-static UInt32 GetLogSize(UInt32 size)
-{
- for (unsigned i = kSubBits; i < 32; i++)
- for (UInt32 j = 0; j < (1 << kSubBits); j++)
- if (size <= (((UInt32)1) << i) + (j << (i - kSubBits)))
- return (i << kSubBits) + j;
- return (32 << kSubBits);
-}
-
-static void NormalizeVals(UInt64 &v1, UInt64 &v2)
-{
- while (v1 > 1000000)
- {
- v1 >>= 1;
- v2 >>= 1;
- }
-}
-
-UInt64 CBenchInfo::GetUsage() const
-{
- UInt64 userTime = UserTime;
- UInt64 userFreq = UserFreq;
- UInt64 globalTime = GlobalTime;
- UInt64 globalFreq = GlobalFreq;
- NormalizeVals(userTime, userFreq);
- NormalizeVals(globalFreq, globalTime);
- if (userFreq == 0)
- userFreq = 1;
- if (globalTime == 0)
- globalTime = 1;
- return userTime * globalFreq * 1000000 / userFreq / globalTime;
-}
-
-UInt64 CBenchInfo::GetRatingPerUsage(UInt64 rating) const
-{
- UInt64 userTime = UserTime;
- UInt64 userFreq = UserFreq;
- UInt64 globalTime = GlobalTime;
- UInt64 globalFreq = GlobalFreq;
- NormalizeVals(userFreq, userTime);
- NormalizeVals(globalTime, globalFreq);
- if (globalFreq == 0)
- globalFreq = 1;
- if (userTime == 0)
- userTime = 1;
- return userFreq * globalTime / globalFreq * rating / userTime;
-}
-
-static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime, UInt64 freq)
-{
- UInt64 elTime = elapsedTime;
- NormalizeVals(freq, elTime);
- if (elTime == 0)
- elTime = 1;
- return value * freq / elTime;
-}
-
-UInt64 CBenchInfo::GetSpeed(UInt64 numCommands) const
-{
- return MyMultDiv64(numCommands, GlobalTime, GlobalFreq);
-}
-
-struct CBenchProps
-{
- bool LzmaRatingMode;
-
- UInt32 EncComplex;
- UInt32 DecComplexCompr;
- UInt32 DecComplexUnc;
-
- CBenchProps(): LzmaRatingMode(false) {}
- void SetLzmaCompexity();
-
- UInt64 GeComprCommands(UInt64 unpackSize)
- {
- return unpackSize * EncComplex;
- }
-
- UInt64 GeDecomprCommands(UInt64 packSize, UInt64 unpackSize)
- {
- return (packSize * DecComplexCompr + unpackSize * DecComplexUnc);
- }
-
- UInt64 GetCompressRating(UInt32 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size);
- UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt64 inSize, UInt64 numIterations);
-};
-
-void CBenchProps::SetLzmaCompexity()
-{
- EncComplex = 1200;
- DecComplexUnc = 4;
- DecComplexCompr = 190;
- LzmaRatingMode = true;
-}
-
-UInt64 CBenchProps::GetCompressRating(UInt32 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size)
-{
- if (dictSize < (1 << kBenchMinDicLogSize))
- dictSize = (1 << kBenchMinDicLogSize);
- UInt64 encComplex = EncComplex;
- if (LzmaRatingMode)
- {
- UInt64 t = GetLogSize(dictSize) - (kBenchMinDicLogSize << kSubBits);
- encComplex = 870 + ((t * t * 5) >> (2 * kSubBits));
- }
- UInt64 numCommands = (UInt64)size * encComplex;
- return MyMultDiv64(numCommands, elapsedTime, freq);
-}
-
-UInt64 CBenchProps::GetDecompressRating(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt64 inSize, UInt64 numIterations)
-{
- UInt64 numCommands = (inSize * DecComplexCompr + outSize * DecComplexUnc) * numIterations;
- return MyMultDiv64(numCommands, elapsedTime, freq);
-}
-
-UInt64 GetCompressRating(UInt32 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size)
-{
- CBenchProps props;
- props.SetLzmaCompexity();
- return props.GetCompressRating(dictSize, elapsedTime, freq, size);
-}
-
-UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt64 inSize, UInt64 numIterations)
-{
- CBenchProps props;
- props.SetLzmaCompexity();
- return props.GetDecompressRating(elapsedTime, freq, outSize, inSize, numIterations);
-}
-
-
-
-
-#ifndef _7ZIP_ST
-struct CBenchSyncCommon
-{
- bool ExitMode;
- NSynchronization::CManualResetEvent StartEvent;
-
- CBenchSyncCommon(): ExitMode(false) {}
-};
-#endif
-
-
-struct CEncoderInfo;
-
-struct CEncoderInfo
-{
- #ifndef _7ZIP_ST
- NWindows::CThread thread[2];
- NSynchronization::CManualResetEvent ReadyEvent;
- UInt32 NumDecoderSubThreads;
- CBenchSyncCommon *Common;
- #endif
-
- CMyComPtr<ICompressCoder> _encoder;
- CMyComPtr<ICompressFilter> _encoderFilter;
- CBenchProgressInfo *progressInfoSpec[2];
- CMyComPtr<ICompressProgressInfo> progressInfo[2];
- UInt64 NumIterations;
-
- UInt32 Salt;
-
- #ifdef USE_ALLOCA
- size_t AllocaSize;
- #endif
-
- Byte _key[32];
- Byte _iv[16];
- Byte _psw[16];
- bool CheckCrc_Enc;
- bool CheckCrc_Dec;
-
- struct CDecoderInfo
- {
- CEncoderInfo *Encoder;
- UInt32 DecoderIndex;
- bool CallbackMode;
-
- #ifdef USE_ALLOCA
- size_t AllocaSize;
- #endif
- };
- CDecoderInfo decodersInfo[2];
-
- CMyComPtr<ICompressCoder> _decoders[2];
- CMyComPtr<ICompressFilter> _decoderFilter;
-
- HRESULT Results[2];
- CBenchmarkOutStream *outStreamSpec;
- CMyComPtr<ISequentialOutStream> outStream;
- IBenchCallback *callback;
- IBenchPrintCallback *printCallback;
- UInt32 crc;
- size_t kBufferSize;
- size_t compressedSize;
- const Byte *uncompressedDataPtr;
-
- const Byte *fileData;
- CBenchRandomGenerator rg;
-
- CAlignedBuffer rgCopy; // it must be 16-byte aligned !!!
- CBenchmarkOutStream *propStreamSpec;
- CMyComPtr<ISequentialOutStream> propStream;
-
- unsigned generateDictBits;
- COneMethodInfo _method;
-
- // for decode
- size_t _uncompressedDataSize;
-
- HRESULT Generate();
- HRESULT Encode();
- HRESULT Decode(UInt32 decoderIndex);
-
- CEncoderInfo():
- #ifndef _7ZIP_ST
- Common(NULL),
- #endif
- Salt(0),
- fileData(NULL),
- CheckCrc_Enc(true),
- CheckCrc_Dec(true),
- outStreamSpec(NULL), callback(NULL), printCallback(NULL), propStreamSpec(NULL) {}
-
- #ifndef _7ZIP_ST
-
- static THREAD_FUNC_DECL EncodeThreadFunction(void *param)
- {
- HRESULT res;
- CEncoderInfo *encoder = (CEncoderInfo *)param;
- try
- {
- #ifdef USE_ALLOCA
- alloca(encoder->AllocaSize);
- #endif
-
- res = encoder->Encode();
- }
- catch(...)
- {
- res = E_FAIL;
- }
- encoder->Results[0] = res;
- if (res != S_OK)
- encoder->progressInfoSpec[0]->Status->SetResult(res);
- encoder->ReadyEvent.Set();
- return 0;
- }
-
- static THREAD_FUNC_DECL DecodeThreadFunction(void *param)
- {
- CDecoderInfo *decoder = (CDecoderInfo *)param;
-
- #ifdef USE_ALLOCA
- alloca(decoder->AllocaSize);
- #endif
-
- CEncoderInfo *encoder = decoder->Encoder;
- encoder->Results[decoder->DecoderIndex] = encoder->Decode(decoder->DecoderIndex);
- return 0;
- }
-
- HRESULT CreateEncoderThread()
- {
- WRes res = 0;
- if (!ReadyEvent.IsCreated())
- res = ReadyEvent.Create();
- if (res == 0)
- res = thread[0].Create(EncodeThreadFunction, this);
- return HRESULT_FROM_WIN32(res);
- }
-
- HRESULT CreateDecoderThread(unsigned index, bool callbackMode
- #ifdef USE_ALLOCA
- , size_t allocaSize
- #endif
- )
- {
- CDecoderInfo &decoder = decodersInfo[index];
- decoder.DecoderIndex = index;
- decoder.Encoder = this;
-
- #ifdef USE_ALLOCA
- decoder.AllocaSize = allocaSize;
- #endif
-
- decoder.CallbackMode = callbackMode;
- return thread[index].Create(DecodeThreadFunction, &decoder);
- }
-
- #endif
-};
-
-
-HRESULT CEncoderInfo::Generate()
-{
- const COneMethodInfo &method = _method;
-
- // we need extra space, if input data is already compressed
- const size_t kCompressedBufferSize =
- kCompressedAdditionalSize +
- kBufferSize + kBufferSize / 16;
- // kBufferSize / 2;
-
- if (kCompressedBufferSize < kBufferSize)
- return E_FAIL;
-
- uncompressedDataPtr = fileData;
-
- if (!fileData)
- {
- ALLOC_WITH_HRESULT(&rg, kBufferSize);
-
- // DWORD ttt = GetTickCount();
- if (generateDictBits == 0)
- rg.GenerateSimpleRandom(Salt);
- else
- rg.GenerateLz(generateDictBits, Salt);
- // printf("\n%d\n ", GetTickCount() - ttt);
-
- crc = CrcCalc((const Byte *)rg, rg.Size());
- uncompressedDataPtr = (const Byte *)rg;
- }
-
- if (_encoderFilter)
- {
- ALLOC_WITH_HRESULT(&rgCopy, kBufferSize);
- }
-
-
- if (!outStream)
- {
- outStreamSpec = new CBenchmarkOutStream;
- outStream = outStreamSpec;
- }
-
- ALLOC_WITH_HRESULT(outStreamSpec, kCompressedBufferSize)
-
- if (!propStream)
- {
- propStreamSpec = new CBenchmarkOutStream;
- propStream = propStreamSpec;
- }
- ALLOC_WITH_HRESULT(propStreamSpec, kMaxLzmaPropSize);
- propStreamSpec->Init(true, false);
-
-
- CMyComPtr<IUnknown> coder;
- if (_encoderFilter)
- coder = _encoderFilter;
- else
- coder = _encoder;
- {
- CMyComPtr<ICompressSetCoderProperties> scp;
- coder.QueryInterface(IID_ICompressSetCoderProperties, &scp);
- if (scp)
- {
- UInt64 reduceSize = kBufferSize;
- RINOK(method.SetCoderProps(scp, &reduceSize));
- }
- else
- {
- if (method.AreThereNonOptionalProps())
- return E_INVALIDARG;
- }
-
- CMyComPtr<ICompressWriteCoderProperties> writeCoderProps;
- coder.QueryInterface(IID_ICompressWriteCoderProperties, &writeCoderProps);
- if (writeCoderProps)
- {
- RINOK(writeCoderProps->WriteCoderProperties(propStream));
- }
-
- {
- CMyComPtr<ICryptoSetPassword> sp;
- coder.QueryInterface(IID_ICryptoSetPassword, &sp);
- if (sp)
- {
- RINOK(sp->CryptoSetPassword(_psw, sizeof(_psw)));
-
- // we must call encoding one time to calculate password key for key cache.
- // it must be after WriteCoderProperties!
- Byte temp[16];
- memset(temp, 0, sizeof(temp));
-
- if (_encoderFilter)
- {
- _encoderFilter->Init();
- _encoderFilter->Filter(temp, sizeof(temp));
- }
- else
- {
- CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
- CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
- inStreamSpec->Init(temp, sizeof(temp));
-
- CCrcOutStream *crcStreamSpec = new CCrcOutStream;
- CMyComPtr<ISequentialOutStream> crcStream = crcStreamSpec;
- crcStreamSpec->Init();
-
- RINOK(_encoder->Code(inStream, crcStream, 0, 0, NULL));
- }
- }
- }
- }
-
- return S_OK;
-}
-
-
-static void My_FilterBench(ICompressFilter *filter, Byte *data, size_t size)
-{
- while (size != 0)
- {
- UInt32 cur = (UInt32)1 << 31;
- if (cur > size)
- cur = (UInt32)size;
- UInt32 processed = filter->Filter(data, cur);
- data += processed;
- // if (processed > size) (in AES filter), we must fill last block with zeros.
- // but it is not important for benchmark. So we just copy that data without filtering.
- if (processed > size || processed == 0)
- break;
- size -= processed;
- }
-}
-
-
-HRESULT CEncoderInfo::Encode()
-{
- RINOK(Generate());
-
- #ifndef _7ZIP_ST
- if (Common)
- {
- Results[0] = S_OK;
- WRes wres = ReadyEvent.Set();
- if (wres == 0)
- wres = Common->StartEvent.Lock();
- if (wres != 0)
- return HRESULT_FROM_WIN32(wres);
- if (Common->ExitMode)
- return S_OK;
- }
- else
- #endif
- {
- CBenchProgressInfo *bpi = progressInfoSpec[0];
- bpi->SetStartTime();
- }
-
-
- CBenchInfo &bi = progressInfoSpec[0]->BenchInfo;
- bi.UnpackSize = 0;
- bi.PackSize = 0;
- CMyComPtr<ICryptoProperties> cp;
- CMyComPtr<IUnknown> coder;
- if (_encoderFilter)
- coder = _encoderFilter;
- else
- coder = _encoder;
- coder.QueryInterface(IID_ICryptoProperties, &cp);
- CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
- CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
- UInt64 prev = 0;
-
- UInt32 crcPrev = 0;
-
- if (cp)
- {
- RINOK(cp->SetKey(_key, sizeof(_key)));
- RINOK(cp->SetInitVector(_iv, sizeof(_iv)));
- }
-
- for (UInt64 i = 0; i < NumIterations; i++)
- {
- if (printCallback && bi.UnpackSize - prev > (1 << 20))
- {
- RINOK(printCallback->CheckBreak());
- prev = bi.UnpackSize;
- }
-
- bool isLast = (i == NumIterations - 1);
- bool calcCrc = ((isLast || (i & 0x7F) == 0 || CheckCrc_Enc) && NumIterations != 1);
- outStreamSpec->Init(isLast, calcCrc);
-
- if (_encoderFilter)
- {
- memcpy((Byte *)rgCopy, uncompressedDataPtr, kBufferSize);
- _encoderFilter->Init();
- My_FilterBench(_encoderFilter, (Byte *)rgCopy, kBufferSize);
- RINOK(WriteStream(outStream, (const Byte *)rgCopy, kBufferSize));
- }
- else
- {
- inStreamSpec->Init(uncompressedDataPtr, kBufferSize);
- RINOK(_encoder->Code(inStream, outStream, NULL, NULL, progressInfo[0]));
- }
-
- // outStreamSpec->Print();
-
- UInt32 crcNew = CRC_GET_DIGEST(outStreamSpec->Crc);
- if (i == 0)
- crcPrev = crcNew;
- else if (calcCrc && crcPrev != crcNew)
- return E_FAIL;
-
- compressedSize = outStreamSpec->Pos;
- bi.UnpackSize += kBufferSize;
- bi.PackSize += compressedSize;
- }
-
- _encoder.Release();
- _encoderFilter.Release();
- return S_OK;
-}
-
-
-HRESULT CEncoderInfo::Decode(UInt32 decoderIndex)
-{
- CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
- CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
- CMyComPtr<ICompressCoder> &decoder = _decoders[decoderIndex];
- CMyComPtr<IUnknown> coder;
- if (_decoderFilter)
- {
- if (decoderIndex != 0)
- return E_FAIL;
- coder = _decoderFilter;
- }
- else
- coder = decoder;
-
- CMyComPtr<ICompressSetDecoderProperties2> setDecProps;
- coder.QueryInterface(IID_ICompressSetDecoderProperties2, &setDecProps);
- if (!setDecProps && propStreamSpec->Pos != 0)
- return E_FAIL;
-
- CCrcOutStream *crcOutStreamSpec = new CCrcOutStream;
- CMyComPtr<ISequentialOutStream> crcOutStream = crcOutStreamSpec;
-
- CBenchProgressInfo *pi = progressInfoSpec[decoderIndex];
- pi->BenchInfo.UnpackSize = 0;
- pi->BenchInfo.PackSize = 0;
-
- #ifndef _7ZIP_ST
- {
- CMyComPtr<ICompressSetCoderMt> setCoderMt;
- coder.QueryInterface(IID_ICompressSetCoderMt, &setCoderMt);
- if (setCoderMt)
- {
- RINOK(setCoderMt->SetNumberOfThreads(NumDecoderSubThreads));
- }
- }
- #endif
-
- CMyComPtr<ICompressSetCoderProperties> scp;
- coder.QueryInterface(IID_ICompressSetCoderProperties, &scp);
- if (scp)
- {
- UInt64 reduceSize = _uncompressedDataSize;
- RINOK(_method.SetCoderProps(scp, &reduceSize));
- }
-
- CMyComPtr<ICryptoProperties> cp;
- coder.QueryInterface(IID_ICryptoProperties, &cp);
-
- if (setDecProps)
- {
- RINOK(setDecProps->SetDecoderProperties2((const Byte *)*propStreamSpec, (UInt32)propStreamSpec->Pos));
- }
-
- {
- CMyComPtr<ICryptoSetPassword> sp;
- coder.QueryInterface(IID_ICryptoSetPassword, &sp);
- if (sp)
- {
- RINOK(sp->CryptoSetPassword(_psw, sizeof(_psw)));
- }
- }
-
- UInt64 prev = 0;
-
- if (cp)
- {
- RINOK(cp->SetKey(_key, sizeof(_key)));
- RINOK(cp->SetInitVector(_iv, sizeof(_iv)));
- }
-
- for (UInt64 i = 0; i < NumIterations; i++)
- {
- if (printCallback && pi->BenchInfo.UnpackSize - prev > (1 << 20))
- {
- RINOK(printCallback->CheckBreak());
- prev = pi->BenchInfo.UnpackSize;
- }
-
- inStreamSpec->Init((const Byte *)*outStreamSpec, compressedSize);
- crcOutStreamSpec->Init();
-
- UInt64 outSize = kBufferSize;
- crcOutStreamSpec->CalcCrc = ((i & 0x7F) == 0 || CheckCrc_Dec);
-
- if (_decoderFilter)
- {
- if (compressedSize > rgCopy.Size())
- return E_FAIL;
- memcpy((Byte *)rgCopy, (const Byte *)*outStreamSpec, compressedSize);
- _decoderFilter->Init();
- My_FilterBench(_decoderFilter, (Byte *)rgCopy, compressedSize);
- RINOK(WriteStream(crcOutStream, (const Byte *)rgCopy, compressedSize));
- }
- else
- {
- RINOK(decoder->Code(inStream, crcOutStream, 0, &outSize, progressInfo[decoderIndex]));
- }
-
- if (crcOutStreamSpec->CalcCrc && CRC_GET_DIGEST(crcOutStreamSpec->Crc) != crc)
- return S_FALSE;
- pi->BenchInfo.UnpackSize += kBufferSize;
- pi->BenchInfo.PackSize += compressedSize;
- }
-
- decoder.Release();
- _decoderFilter.Release();
- return S_OK;
-}
-
-
-static const UInt32 kNumThreadsMax = (1 << 12);
-
-struct CBenchEncoders
-{
- CEncoderInfo *encoders;
- CBenchEncoders(UInt32 num): encoders(NULL) { encoders = new CEncoderInfo[num]; }
- ~CBenchEncoders() { delete []encoders; }
-};
-
-
-static UInt64 GetNumIterations(UInt64 numCommands, UInt64 complexInCommands)
-{
- if (numCommands < (1 << 4))
- numCommands = (1 << 4);
- UInt64 res = complexInCommands / numCommands;
- return (res == 0 ? 1 : res);
-}
-
-
-
-#ifndef _7ZIP_ST
-
-// ---------- CBenchThreadsFlusher ----------
-
-struct CBenchThreadsFlusher
-{
- CBenchEncoders *EncodersSpec;
- CBenchSyncCommon Common;
- unsigned NumThreads;
- bool NeedClose;
-
- CBenchThreadsFlusher(): NumThreads(0), NeedClose(false) {}
-
- ~CBenchThreadsFlusher()
- {
- StartAndWait(true);
- }
-
- WRes StartAndWait(bool exitMode = false);
-};
-
-
-WRes CBenchThreadsFlusher::StartAndWait(bool exitMode)
-{
- if (!NeedClose)
- return 0;
-
- Common.ExitMode = exitMode;
- WRes res = Common.StartEvent.Set();
-
- for (unsigned i = 0; i < NumThreads; i++)
- {
- NWindows::CThread &t = EncodersSpec->encoders[i].thread[0];
- if (t.IsCreated())
- {
- WRes res2 = t.Wait();
- if (res2 == 0)
- res2 = t.Close();
- if (res == S_OK)
- res = res2;
- }
- }
- NeedClose = false;
- return res;
-}
-
-#endif
-
-
-
-static HRESULT MethodBench(
- DECL_EXTERNAL_CODECS_LOC_VARS
- UInt64 complexInCommands,
- bool
- #ifndef _7ZIP_ST
- oldLzmaBenchMode
- #endif
- ,
- UInt32
- #ifndef _7ZIP_ST
- numThreads
- #endif
- ,
- const COneMethodInfo &method2,
- size_t uncompressedDataSize,
- const Byte *fileData,
- unsigned generateDictBits,
-
- IBenchPrintCallback *printCallback,
- IBenchCallback *callback,
- CBenchProps *benchProps)
-{
- COneMethodInfo method = method2;
- UInt64 methodId;
- UInt32 numStreams;
- int codecIndex = FindMethod_Index(
- EXTERNAL_CODECS_LOC_VARS
- method.MethodName, true,
- methodId, numStreams);
- if (codecIndex < 0)
- return E_NOTIMPL;
- if (numStreams != 1)
- return E_INVALIDARG;
-
- UInt32 numEncoderThreads = 1;
- UInt32 numSubDecoderThreads = 1;
-
- #ifndef _7ZIP_ST
- numEncoderThreads = numThreads;
-
- if (oldLzmaBenchMode && methodId == k_LZMA)
- {
- if (numThreads == 1 && method.Get_NumThreads() < 0)
- method.AddProp_NumThreads(1);
- const UInt32 numLzmaThreads = method.Get_Lzma_NumThreads();
- if (numThreads > 1 && numLzmaThreads > 1)
- {
- numEncoderThreads = numThreads / 2;
- numSubDecoderThreads = 2;
- }
- }
-
- bool mtEncMode = (numEncoderThreads > 1);
- #endif
-
- CBenchEncoders encodersSpec(numEncoderThreads);
- CEncoderInfo *encoders = encodersSpec.encoders;
-
- UInt32 i;
-
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
- encoder.callback = (i == 0) ? callback : 0;
- encoder.printCallback = printCallback;
-
- {
- CCreatedCoder cod;
- RINOK(CreateCoder_Index(EXTERNAL_CODECS_LOC_VARS codecIndex, true, encoder._encoderFilter, cod));
- encoder._encoder = cod.Coder;
- if (!encoder._encoder && !encoder._encoderFilter)
- return E_NOTIMPL;
- }
-
- encoder.CheckCrc_Enc = (benchProps->EncComplex) > 30 ;
- encoder.CheckCrc_Dec = (benchProps->DecComplexCompr + benchProps->DecComplexUnc) > 30 ;
-
- memset(encoder._iv, 0, sizeof(encoder._iv));
- memset(encoder._key, 0, sizeof(encoder._key));
- memset(encoder._psw, 0, sizeof(encoder._psw));
-
- for (UInt32 j = 0; j < numSubDecoderThreads; j++)
- {
- CCreatedCoder cod;
- CMyComPtr<ICompressCoder> &decoder = encoder._decoders[j];
- RINOK(CreateCoder_Id(EXTERNAL_CODECS_LOC_VARS methodId, false, encoder._decoderFilter, cod));
- decoder = cod.Coder;
- if (!encoder._decoderFilter && !decoder)
- return E_NOTIMPL;
- }
- }
-
- UInt32 crc = 0;
- if (fileData)
- crc = CrcCalc(fileData, uncompressedDataSize);
-
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
- encoder._method = method;
- encoder.generateDictBits = generateDictBits;
- encoder._uncompressedDataSize = uncompressedDataSize;
- encoder.kBufferSize = uncompressedDataSize;
- encoder.fileData = fileData;
- encoder.crc = crc;
- }
-
- CBenchProgressStatus status;
- status.Res = S_OK;
- status.EncodeMode = true;
-
- #ifndef _7ZIP_ST
- CBenchThreadsFlusher encoderFlusher;
- if (mtEncMode)
- {
- WRes wres = encoderFlusher.Common.StartEvent.Create();
- if (wres != 0)
- return HRESULT_FROM_WIN32(wres);
- encoderFlusher.NumThreads = numEncoderThreads;
- encoderFlusher.EncodersSpec = &encodersSpec;
- encoderFlusher.NeedClose = true;
- }
- #endif
-
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
- encoder.NumIterations = GetNumIterations(benchProps->GeComprCommands(uncompressedDataSize), complexInCommands);
- encoder.Salt = g_CrcTable[i & 0xFF];
- encoder.Salt ^= (g_CrcTable[(i >> 8) & 0xFF] << 3);
- // (g_CrcTable[0] == 0), and (encoder.Salt == 0) for first thread
- // printf(" %8x", encoder.Salt);
-
- for (int j = 0; j < 2; j++)
- {
- CBenchProgressInfo *spec = new CBenchProgressInfo;
- encoder.progressInfoSpec[j] = spec;
- encoder.progressInfo[j] = spec;
- spec->Status = &status;
- }
-
- if (i == 0)
- {
- CBenchProgressInfo *bpi = encoder.progressInfoSpec[0];
- bpi->Callback = callback;
- bpi->BenchInfo.NumIterations = numEncoderThreads;
- }
-
- #ifndef _7ZIP_ST
- if (mtEncMode)
- {
- #ifdef USE_ALLOCA
- encoder.AllocaSize = (i * 16 * 21) & 0x7FF;
- #endif
-
- encoder.Common = &encoderFlusher.Common;
- RINOK(encoder.CreateEncoderThread())
- }
- #endif
- }
-
- if (printCallback)
- {
- RINOK(printCallback->CheckBreak());
- }
-
- #ifndef _7ZIP_ST
- if (mtEncMode)
- {
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
- WRes wres = encoder.ReadyEvent.Lock();
- if (wres != 0)
- return HRESULT_FROM_WIN32(wres);
- RINOK(encoder.Results[0]);
- }
-
- CBenchProgressInfo *bpi = encoders[0].progressInfoSpec[0];
- bpi->SetStartTime();
-
- WRes wres = encoderFlusher.StartAndWait();
- if (status.Res == 0 && wres != 0)
- return HRESULT_FROM_WIN32(wres);
- }
- else
- #endif
- {
- RINOK(encoders[0].Encode());
- }
-
- RINOK(status.Res);
-
- CBenchInfo info;
-
- encoders[0].progressInfoSpec[0]->SetFinishTime(info);
- info.UnpackSize = 0;
- info.PackSize = 0;
- info.NumIterations = encoders[0].NumIterations;
-
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
- info.UnpackSize += encoder.kBufferSize;
- info.PackSize += encoder.compressedSize;
- // printf("\n%7d\n", encoder.compressedSize);
- }
-
- RINOK(callback->SetEncodeResult(info, true));
-
-
-
-
- // ---------- Decode ----------
-
- status.Res = S_OK;
- status.EncodeMode = false;
-
- UInt32 numDecoderThreads = numEncoderThreads * numSubDecoderThreads;
-
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
-
- if (i == 0)
- {
- encoder.NumIterations = GetNumIterations(benchProps->GeDecomprCommands(encoder.compressedSize, encoder.kBufferSize), complexInCommands);
- CBenchProgressInfo *bpi = encoder.progressInfoSpec[0];
- bpi->Callback = callback;
- bpi->BenchInfo.NumIterations = numDecoderThreads;
- bpi->SetStartTime();
- }
- else
- encoder.NumIterations = encoders[0].NumIterations;
-
- #ifndef _7ZIP_ST
- {
- int numSubThreads = method.Get_NumThreads();
- encoder.NumDecoderSubThreads = (numSubThreads <= 0) ? 1 : numSubThreads;
- }
- if (numDecoderThreads > 1)
- {
- for (UInt32 j = 0; j < numSubDecoderThreads; j++)
- {
- HRESULT res = encoder.CreateDecoderThread(j, (i == 0 && j == 0)
- #ifdef USE_ALLOCA
- , ((i * numSubDecoderThreads + j) * 16 * 21) & 0x7FF
- #endif
- );
- RINOK(res);
- }
- }
- else
- #endif
- {
- RINOK(encoder.Decode(0));
- }
- }
-
- #ifndef _7ZIP_ST
- HRESULT res = S_OK;
- if (numDecoderThreads > 1)
- for (i = 0; i < numEncoderThreads; i++)
- for (UInt32 j = 0; j < numSubDecoderThreads; j++)
- {
- CEncoderInfo &encoder = encoders[i];
- encoder.thread[j].Wait();
- if (encoder.Results[j] != S_OK)
- res = encoder.Results[j];
- }
- RINOK(res);
- #endif
-
- RINOK(status.Res);
- encoders[0].progressInfoSpec[0]->SetFinishTime(info);
-
- #ifndef _7ZIP_ST
- #ifdef UNDER_CE
- if (numDecoderThreads > 1)
- for (i = 0; i < numEncoderThreads; i++)
- for (UInt32 j = 0; j < numSubDecoderThreads; j++)
- {
- FILETIME creationTime, exitTime, kernelTime, userTime;
- if (::GetThreadTimes(encoders[i].thread[j], &creationTime, &exitTime, &kernelTime, &userTime) != 0)
- info.UserTime += GetTime64(userTime) + GetTime64(kernelTime);
- }
- #endif
- #endif
-
- info.UnpackSize = 0;
- info.PackSize = 0;
- info.NumIterations = numSubDecoderThreads * encoders[0].NumIterations;
-
- for (i = 0; i < numEncoderThreads; i++)
- {
- CEncoderInfo &encoder = encoders[i];
- info.UnpackSize += encoder.kBufferSize;
- info.PackSize += encoder.compressedSize;
- }
-
- RINOK(callback->SetDecodeResult(info, false));
- RINOK(callback->SetDecodeResult(info, true));
-
- return S_OK;
-}
-
-
-static inline UInt64 GetLZMAUsage(bool multiThread, UInt32 dictionary)
-{
- UInt32 hs = dictionary - 1;
- hs |= (hs >> 1);
- hs |= (hs >> 2);
- hs |= (hs >> 4);
- hs |= (hs >> 8);
- hs >>= 1;
- hs |= 0xFFFF;
- if (hs > (1 << 24))
- hs >>= 1;
- hs++;
- return ((hs + (1 << 16)) + (UInt64)dictionary * 2) * 4 + (UInt64)dictionary * 3 / 2 +
- (1 << 20) + (multiThread ? (6 << 20) : 0);
-}
-
-UInt64 GetBenchMemoryUsage(UInt32 numThreads, UInt32 dictionary, bool totalBench)
-{
- const UInt32 kBufferSize = dictionary;
- const UInt32 kCompressedBufferSize = kBufferSize; // / 2;
- bool lzmaMt = (totalBench || numThreads > 1);
- UInt32 numBigThreads = numThreads;
- if (!totalBench && lzmaMt)
- numBigThreads /= 2;
- return ((UInt64)kBufferSize + kCompressedBufferSize +
- GetLZMAUsage(lzmaMt, dictionary) + (2 << 20)) * numBigThreads;
-}
-
-static HRESULT CrcBig(const void *data, UInt32 size, UInt64 numIterations,
- const UInt32 *checkSum, IHasher *hf,
- IBenchPrintCallback *callback)
-{
- Byte hash[64];
- UInt64 i;
- for (i = 0; i < sizeof(hash); i++)
- hash[i] = 0;
- for (i = 0; i < numIterations; i++)
- {
- if (callback && (i & 0xFF) == 0)
- {
- RINOK(callback->CheckBreak());
- }
- hf->Init();
- hf->Update(data, size);
- hf->Final(hash);
- UInt32 hashSize = hf->GetDigestSize();
- if (hashSize > sizeof(hash))
- return S_FALSE;
- UInt32 sum = 0;
- for (UInt32 j = 0; j < hashSize; j += 4)
- sum ^= GetUi32(hash + j);
- if (checkSum && sum != *checkSum)
- {
- return S_FALSE;
- }
- }
- return S_OK;
-}
-
-UInt32 g_BenchCpuFreqTemp = 1;
-
-#define YY1 sum += val; sum ^= val;
-#define YY3 YY1 YY1 YY1 YY1
-#define YY5 YY3 YY3 YY3 YY3
-#define YY7 YY5 YY5 YY5 YY5
-static const UInt32 kNumFreqCommands = 128;
-
-EXTERN_C_BEGIN
-
-static UInt32 CountCpuFreq(UInt32 sum, UInt32 num, UInt32 val)
-{
- for (UInt32 i = 0; i < num; i++)
- {
- YY7
- }
- return sum;
-}
-
-EXTERN_C_END
-
-
-#ifndef _7ZIP_ST
-
-struct CFreqInfo
-{
- NWindows::CThread Thread;
- IBenchPrintCallback *Callback;
- HRESULT CallbackRes;
- UInt32 ValRes;
- UInt32 Size;
- UInt64 NumIterations;
-
- void Wait()
- {
- Thread.Wait();
- Thread.Close();
- }
-};
-
-static THREAD_FUNC_DECL FreqThreadFunction(void *param)
-{
- CFreqInfo *p = (CFreqInfo *)param;
-
- UInt32 sum = g_BenchCpuFreqTemp;
- for (UInt64 k = p->NumIterations; k > 0; k--)
- {
- p->CallbackRes = p->Callback->CheckBreak();
- if (p->CallbackRes != S_OK)
- return 0;
- sum = CountCpuFreq(sum, p->Size, g_BenchCpuFreqTemp);
- }
- p->ValRes = sum;
- return 0;
-}
-
-struct CFreqThreads
-{
- CFreqInfo *Items;
- UInt32 NumThreads;
-
- CFreqThreads(): Items(NULL), NumThreads(0) {}
- void WaitAll()
- {
- for (UInt32 i = 0; i < NumThreads; i++)
- Items[i].Wait();
- NumThreads = 0;
- }
- ~CFreqThreads()
- {
- WaitAll();
- delete []Items;
- }
-};
-
-struct CCrcInfo
-{
- NWindows::CThread Thread;
- IBenchPrintCallback *Callback;
- HRESULT CallbackRes;
-
- const Byte *Data;
- UInt32 Size;
- UInt64 NumIterations;
- bool CheckSumDefined;
- UInt32 CheckSum;
- CMyComPtr<IHasher> Hasher;
- HRESULT Res;
-
- #ifdef USE_ALLOCA
- size_t AllocaSize;
- #endif
-
- void Wait()
- {
- Thread.Wait();
- Thread.Close();
- }
-};
-
-static THREAD_FUNC_DECL CrcThreadFunction(void *param)
-{
- CCrcInfo *p = (CCrcInfo *)param;
-
- #ifdef USE_ALLOCA
- alloca(p->AllocaSize);
- #endif
-
- p->Res = CrcBig(p->Data, p->Size, p->NumIterations,
- p->CheckSumDefined ? &p->CheckSum : NULL, p->Hasher,
- p->Callback);
- return 0;
-}
-
-struct CCrcThreads
-{
- CCrcInfo *Items;
- UInt32 NumThreads;
-
- CCrcThreads(): Items(NULL), NumThreads(0) {}
- void WaitAll()
- {
- for (UInt32 i = 0; i < NumThreads; i++)
- Items[i].Wait();
- NumThreads = 0;
- }
- ~CCrcThreads()
- {
- WaitAll();
- delete []Items;
- }
-};
-
-#endif
-
-static UInt32 CrcCalc1(const Byte *buf, size_t size)
-{
- UInt32 crc = CRC_INIT_VAL;;
- for (size_t i = 0; i < size; i++)
- crc = CRC_UPDATE_BYTE(crc, buf[i]);
- return CRC_GET_DIGEST(crc);
-}
-
-static void RandGen(Byte *buf, size_t size, CBaseRandomGenerator &RG)
-{
- for (size_t i = 0; i < size; i++)
- buf[i] = (Byte)RG.GetRnd();
-}
-
-static UInt32 RandGenCrc(Byte *buf, size_t size, CBaseRandomGenerator &RG)
-{
- RandGen(buf, size, RG);
- return CrcCalc1(buf, size);
-}
-
-bool CrcInternalTest()
-{
- CAlignedBuffer buffer;
- const size_t kBufferSize0 = (1 << 8);
- const size_t kBufferSize1 = (1 << 10);
- const unsigned kCheckSize = (1 << 5);
- buffer.Alloc(kBufferSize0 + kBufferSize1);
- if (!buffer.IsAllocated())
- return false;
- Byte *buf = (Byte *)buffer;
- size_t i;
- for (i = 0; i < kBufferSize0; i++)
- buf[i] = (Byte)i;
- UInt32 crc1 = CrcCalc1(buf, kBufferSize0);
- if (crc1 != 0x29058C73)
- return false;
- CBaseRandomGenerator RG;
- RandGen(buf + kBufferSize0, kBufferSize1, RG);
- for (i = 0; i < kBufferSize0 + kBufferSize1 - kCheckSize; i++)
- for (unsigned j = 0; j < kCheckSize; j++)
- if (CrcCalc1(buf + i, j) != CrcCalc(buf + i, j))
- return false;
- return true;
-}
-
-struct CBenchMethod
-{
- unsigned Weight;
- unsigned DictBits;
- UInt32 EncComplex;
- UInt32 DecComplexCompr;
- UInt32 DecComplexUnc;
- const char *Name;
-};
-
-static const CBenchMethod g_Bench[] =
-{
- { 40, 17, 357, 145, 20, "LZMA:x1" },
- { 80, 24, 1220, 145, 20, "LZMA:x5:mt1" },
- { 80, 24, 1220, 145, 20, "LZMA:x5:mt2" },
-
- { 10, 16, 124, 40, 14, "Deflate:x1" },
- { 20, 16, 376, 40, 14, "Deflate:x5" },
- { 10, 16, 1082, 40, 14, "Deflate:x7" },
- { 10, 17, 422, 40, 14, "Deflate64:x5" },
-
- { 10, 15, 590, 69, 69, "BZip2:x1" },
- { 20, 19, 815, 122, 122, "BZip2:x5" },
- { 10, 19, 815, 122, 122, "BZip2:x5:mt2" },
- { 10, 19, 2530, 122, 122, "BZip2:x7" },
-
- { 10, 18, 1010, 0, 1150, "PPMD:x1" },
- { 10, 22, 1655, 0, 1830, "PPMD:x5" },
-
- { 2, 0, 6, 0, 6, "Delta:4" },
- { 2, 0, 4, 0, 4, "BCJ" },
-
- { 10, 0, 24, 0, 24, "AES256CBC:1" },
- { 2, 0, 8, 0, 2, "AES256CBC:2" }
-};
-
-struct CBenchHash
-{
- unsigned Weight;
- UInt32 Complex;
- UInt32 CheckSum;
- const char *Name;
-};
-
-static const CBenchHash g_Hash[] =
-{
- { 1, 1820, 0x8F8FEDAB, "CRC32:1" },
- { 10, 558, 0x8F8FEDAB, "CRC32:4" },
- { 10, 339, 0x8F8FEDAB, "CRC32:8" },
- { 10, 512, 0xDF1C17CC, "CRC64" },
- { 10, 5100, 0x2D79FF2E, "SHA256" },
- { 10, 2340, 0x4C25132B, "SHA1" },
- { 2, 5500, 0xE084E913, "BLAKE2sp" }
-};
-
-struct CTotalBenchRes
-{
- // UInt64 NumIterations1; // for Usage
- UInt64 NumIterations2; // for Rating / RPU
-
- UInt64 Rating;
- UInt64 Usage;
- UInt64 RPU;
-
- void Init() { /* NumIterations1 = 0; */ NumIterations2 = 0; Rating = 0; Usage = 0; RPU = 0; }
-
- void SetSum(const CTotalBenchRes &r1, const CTotalBenchRes &r2)
- {
- Rating = (r1.Rating + r2.Rating);
- Usage = (r1.Usage + r2.Usage);
- RPU = (r1.RPU + r2.RPU);
- // NumIterations1 = (r1.NumIterations1 + r2.NumIterations1);
- NumIterations2 = (r1.NumIterations2 + r2.NumIterations2);
- }
-};
-
-static void PrintNumber(IBenchPrintCallback &f, UInt64 value, unsigned size)
-{
- char s[128];
- unsigned startPos = (unsigned)sizeof(s) - 32;
- memset(s, ' ', startPos);
- ConvertUInt64ToString(value, s + startPos);
- // if (withSpace)
- {
- startPos--;
- size++;
- }
- unsigned len = (unsigned)strlen(s + startPos);
- if (size > len)
- {
- startPos -= (size - len);
- if (startPos < 0)
- startPos = 0;
- }
- f.Print(s + startPos);
-}
-
-static const unsigned kFieldSize_Name = 12;
-static const unsigned kFieldSize_SmallName = 4;
-static const unsigned kFieldSize_Speed = 9;
-static const unsigned kFieldSize_Usage = 5;
-static const unsigned kFieldSize_RU = 6;
-static const unsigned kFieldSize_Rating = 6;
-static const unsigned kFieldSize_EU = 5;
-static const unsigned kFieldSize_Effec = 5;
-
-static const unsigned kFieldSize_TotalSize = 4 + kFieldSize_Speed + kFieldSize_Usage + kFieldSize_RU + kFieldSize_Rating;
-static const unsigned kFieldSize_EUAndEffec = 2 + kFieldSize_EU + kFieldSize_Effec;
-
-
-static void PrintRating(IBenchPrintCallback &f, UInt64 rating, unsigned size)
-{
- PrintNumber(f, (rating + 500000) / 1000000, size);
-}
-
-
-static void PrintPercents(IBenchPrintCallback &f, UInt64 val, UInt64 divider, unsigned size)
-{
- PrintNumber(f, (val * 100 + divider / 2) / divider, size);
-}
-
-static void PrintChars(IBenchPrintCallback &f, char c, unsigned size)
-{
- char s[256];
- memset(s, (Byte)c, size);
- s[size] = 0;
- f.Print(s);
-}
-
-static void PrintSpaces(IBenchPrintCallback &f, unsigned size)
-{
- PrintChars(f, ' ', size);
-}
-
-static void PrintResults(IBenchPrintCallback &f, UInt64 usage, UInt64 rpu, UInt64 rating, bool showFreq, UInt64 cpuFreq)
-{
- PrintNumber(f, (usage + 5000) / 10000, kFieldSize_Usage);
- PrintRating(f, rpu, kFieldSize_RU);
- PrintRating(f, rating, kFieldSize_Rating);
- if (showFreq)
- {
- if (cpuFreq == 0)
- PrintSpaces(f, kFieldSize_EUAndEffec);
- else
- {
- UInt64 ddd = cpuFreq * usage / 100;
- if (ddd == 0)
- ddd = 1;
- PrintPercents(f, (rating * 10000), ddd, kFieldSize_EU);
- PrintPercents(f, rating, cpuFreq, kFieldSize_Effec);
- }
- }
-}
-
-static void PrintResults(IBenchPrintCallback *f,
- const CBenchInfo &info,
- unsigned weight,
- UInt64 rating,
- bool showFreq, UInt64 cpuFreq,
- CTotalBenchRes *res)
-{
- UInt64 speed = info.GetSpeed(info.UnpackSize * info.NumIterations);
- if (f)
- {
- if (speed != 0)
- PrintNumber(*f, speed / 1024, kFieldSize_Speed);
- else
- PrintSpaces(*f, 1 + kFieldSize_Speed);
- }
- UInt64 usage = info.GetUsage();
- UInt64 rpu = info.GetRatingPerUsage(rating);
- if (f)
- {
- PrintResults(*f, usage, rpu, rating, showFreq, cpuFreq);
- }
-
- if (res)
- {
- // res->NumIterations1++;
- res->NumIterations2 += weight;
- res->RPU += (rpu * weight);
- res->Rating += (rating * weight);
- res->Usage += (usage * weight);
- }
-}
-
-static void PrintTotals(IBenchPrintCallback &f, bool showFreq, UInt64 cpuFreq, const CTotalBenchRes &res)
-{
- PrintSpaces(f, 1 + kFieldSize_Speed);
- // UInt64 numIterations1 = res.NumIterations1; if (numIterations1 == 0) numIterations1 = 1;
- UInt64 numIterations2 = res.NumIterations2; if (numIterations2 == 0) numIterations2 = 1;
- PrintResults(f, res.Usage / numIterations2, res.RPU / numIterations2, res.Rating / numIterations2, showFreq, cpuFreq);
-}
-
-
-static void PrintHex(AString &s, UInt64 v)
-{
- char temp[32];
- ConvertUInt64ToHex(v, temp);
- s += temp;
-}
-
-AString GetProcessThreadsInfo(const NSystem::CProcessAffinity &ti)
-{
- AString s;
- // s.Add_UInt32(ti.numProcessThreads);
- if (ti.processAffinityMask != ti.systemAffinityMask)
- {
- // if (ti.numProcessThreads != ti.numSysThreads)
- {
- s += " / ";
- s.Add_UInt32(ti.GetNumSystemThreads());
- }
- s += " : ";
- PrintHex(s, ti.processAffinityMask);
- s += " / ";
- PrintHex(s, ti.systemAffinityMask);
- }
- return s;
-}
-
-
-static void PrintSize(AString &s, UInt64 v)
-{
- char c = 0;
- if ((v & 0x3FF) == 0) { v >>= 10; c = 'K';
- if ((v & 0x3FF) == 0) { v >>= 10; c = 'M';
- if ((v & 0x3FF) == 0) { v >>= 10; c = 'G';
- if ((v & 0x3FF) == 0) { v >>= 10; c = 'T';
- }}}}
- else
- {
- PrintHex(s, v);
- return;
- }
- char temp[32];
- ConvertUInt64ToString(v, temp);
- s += temp;
- if (c)
- s += c;
-}
-
-
-#ifdef _7ZIP_LARGE_PAGES
-
-extern bool g_LargePagesMode;
-
-extern "C"
-{
- extern SIZE_T g_LargePageSize;
-}
-
-void Add_LargePages_String(AString &s)
-{
- if (g_LargePagesMode || g_LargePageSize != 0)
- {
- s += " (LP-";
- PrintSize(s, g_LargePageSize);
- #ifdef MY_CPU_X86_OR_AMD64
- if (CPU_IsSupported_PageGB())
- s += "-1G";
- #endif
- if (!g_LargePagesMode)
- s += "-NA";
- s += ")";
- }
-}
-
-#endif
-
-
-
-static void PrintRequirements(IBenchPrintCallback &f, const char *sizeString,
- bool size_Defined, UInt64 size, const char *threadsString, UInt32 numThreads)
-{
- f.Print("RAM ");
- f.Print(sizeString);
- if (size_Defined)
- PrintNumber(f, (size >> 20), 6);
- else
- f.Print(" ?");
- f.Print(" MB");
-
- #ifdef _7ZIP_LARGE_PAGES
- {
- AString s;
- Add_LargePages_String(s);
- f.Print(s);
- }
- #endif
-
- f.Print(", # ");
- f.Print(threadsString);
- PrintNumber(f, numThreads, 3);
-}
-
-
-
-struct CBenchCallbackToPrint: public IBenchCallback
-{
- CBenchProps BenchProps;
- CTotalBenchRes EncodeRes;
- CTotalBenchRes DecodeRes;
- IBenchPrintCallback *_file;
- UInt32 DictSize;
-
- bool Use2Columns;
- unsigned NameFieldSize;
-
- bool ShowFreq;
- UInt64 CpuFreq;
-
- unsigned EncodeWeight;
- unsigned DecodeWeight;
-
- CBenchCallbackToPrint():
- Use2Columns(false),
- NameFieldSize(0),
- ShowFreq(false),
- CpuFreq(0),
- EncodeWeight(1),
- DecodeWeight(1)
- {}
-
- void Init() { EncodeRes.Init(); DecodeRes.Init(); }
- void Print(const char *s);
- void NewLine();
-
- HRESULT SetFreq(bool showFreq, UInt64 cpuFreq);
- HRESULT SetEncodeResult(const CBenchInfo &info, bool final);
- HRESULT SetDecodeResult(const CBenchInfo &info, bool final);
-};
-
-HRESULT CBenchCallbackToPrint::SetFreq(bool showFreq, UInt64 cpuFreq)
-{
- ShowFreq = showFreq;
- CpuFreq = cpuFreq;
- return S_OK;
-}
-
-HRESULT CBenchCallbackToPrint::SetEncodeResult(const CBenchInfo &info, bool final)
-{
- RINOK(_file->CheckBreak());
- if (final)
- {
- UInt64 rating = BenchProps.GetCompressRating(DictSize, info.GlobalTime, info.GlobalFreq, info.UnpackSize * info.NumIterations);
- PrintResults(_file, info,
- EncodeWeight, rating,
- ShowFreq, CpuFreq, &EncodeRes);
- if (!Use2Columns)
- _file->NewLine();
- }
- return S_OK;
-}
-
-static const char * const kSep = " | ";
-
-HRESULT CBenchCallbackToPrint::SetDecodeResult(const CBenchInfo &info, bool final)
-{
- RINOK(_file->CheckBreak());
- if (final)
- {
- UInt64 rating = BenchProps.GetDecompressRating(info.GlobalTime, info.GlobalFreq, info.UnpackSize, info.PackSize, info.NumIterations);
- if (Use2Columns)
- _file->Print(kSep);
- else
- PrintSpaces(*_file, NameFieldSize);
- CBenchInfo info2 = info;
- info2.UnpackSize *= info2.NumIterations;
- info2.PackSize *= info2.NumIterations;
- info2.NumIterations = 1;
- PrintResults(_file, info2,
- DecodeWeight, rating,
- ShowFreq, CpuFreq, &DecodeRes);
- }
- return S_OK;
-}
-
-void CBenchCallbackToPrint::Print(const char *s)
-{
- _file->Print(s);
-}
-
-void CBenchCallbackToPrint::NewLine()
-{
- _file->NewLine();
-}
-
-void PrintLeft(IBenchPrintCallback &f, const char *s, unsigned size)
-{
- f.Print(s);
- int numSpaces = size - MyStringLen(s);
- if (numSpaces > 0)
- PrintSpaces(f, numSpaces);
-}
-
-void PrintRight(IBenchPrintCallback &f, const char *s, unsigned size)
-{
- int numSpaces = size - MyStringLen(s);
- if (numSpaces > 0)
- PrintSpaces(f, numSpaces);
- f.Print(s);
-}
-
-static HRESULT TotalBench(
- DECL_EXTERNAL_CODECS_LOC_VARS
- UInt64 complexInCommands,
- UInt32 numThreads,
- bool forceUnpackSize,
- size_t unpackSize,
- const Byte *fileData,
- IBenchPrintCallback *printCallback, CBenchCallbackToPrint *callback)
-{
- for (unsigned i = 0; i < ARRAY_SIZE(g_Bench); i++)
- {
- const CBenchMethod &bench = g_Bench[i];
- PrintLeft(*callback->_file, bench.Name, kFieldSize_Name);
- callback->BenchProps.DecComplexUnc = bench.DecComplexUnc;
- callback->BenchProps.DecComplexCompr = bench.DecComplexCompr;
- callback->BenchProps.EncComplex = bench.EncComplex;
-
- COneMethodInfo method;
- NCOM::CPropVariant propVariant;
- propVariant = bench.Name;
- RINOK(method.ParseMethodFromPROPVARIANT(UString(), propVariant));
-
- size_t unpackSize2 = unpackSize;
- if (!forceUnpackSize && bench.DictBits == 0)
- unpackSize2 = kFilterUnpackSize;
-
- callback->EncodeWeight = bench.Weight;
- callback->DecodeWeight = bench.Weight;
-
- HRESULT res = MethodBench(
- EXTERNAL_CODECS_LOC_VARS
- complexInCommands,
- false, numThreads, method,
- unpackSize2, fileData,
- bench.DictBits,
- printCallback, callback, &callback->BenchProps);
-
- if (res == E_NOTIMPL)
- {
- // callback->Print(" ---");
- // we need additional empty line as line for decompression results
- if (!callback->Use2Columns)
- callback->NewLine();
- }
- else
- {
- RINOK(res);
- }
-
- callback->NewLine();
- }
- return S_OK;
-}
-
-
-static HRESULT FreqBench(
- UInt64 complexInCommands,
- UInt32 numThreads,
- IBenchPrintCallback *_file,
- bool showFreq,
- UInt64 specifiedFreq,
- UInt64 &cpuFreq,
- UInt32 &res)
-{
- res = 0;
- cpuFreq = 0;
-
- UInt32 bufferSize = 1 << 20;
- UInt32 complexity = kNumFreqCommands;
- if (numThreads == 0)
- numThreads = 1;
-
- #ifdef _7ZIP_ST
- numThreads = 1;
- #endif
-
- UInt32 bsize = (bufferSize == 0 ? 1 : bufferSize);
- UInt64 numIterations = complexInCommands / complexity / bsize;
- if (numIterations == 0)
- numIterations = 1;
-
- CBenchInfoCalc progressInfoSpec;
-
- #ifndef _7ZIP_ST
- CFreqThreads threads;
- if (numThreads > 1)
- {
- threads.Items = new CFreqInfo[numThreads];
- UInt32 i;
- for (i = 0; i < numThreads; i++)
- {
- CFreqInfo &info = threads.Items[i];
- info.Callback = _file;
- info.CallbackRes = S_OK;
- info.NumIterations = numIterations;
- info.Size = bufferSize;
- }
- progressInfoSpec.SetStartTime();
- for (i = 0; i < numThreads; i++)
- {
- CFreqInfo &info = threads.Items[i];
- RINOK(info.Thread.Create(FreqThreadFunction, &info));
- threads.NumThreads++;
- }
- threads.WaitAll();
- for (i = 0; i < numThreads; i++)
- {
- RINOK(threads.Items[i].CallbackRes);
- }
- }
- else
- #endif
- {
- progressInfoSpec.SetStartTime();
- UInt32 sum = g_BenchCpuFreqTemp;
- for (UInt64 k = numIterations; k > 0; k--)
- {
- RINOK(_file->CheckBreak());
- sum = CountCpuFreq(sum, bufferSize, g_BenchCpuFreqTemp);
- }
- res += sum;
- }
-
- CBenchInfo info;
- progressInfoSpec.SetFinishTime(info);
-
- info.UnpackSize = 0;
- info.PackSize = 0;
- info.NumIterations = 1;
-
- if (_file)
- {
- {
- UInt64 numCommands = (UInt64)numIterations * bufferSize * numThreads * complexity;
- UInt64 rating = info.GetSpeed(numCommands);
- cpuFreq = rating / numThreads;
- PrintResults(_file, info,
- 0, // weight
- rating,
- showFreq, showFreq ? (specifiedFreq != 0 ? specifiedFreq : cpuFreq) : 0, NULL);
- }
- RINOK(_file->CheckBreak());
- }
-
- return S_OK;
-}
-
-
-
-static HRESULT CrcBench(
- DECL_EXTERNAL_CODECS_LOC_VARS
- UInt64 complexInCommands,
- UInt32 numThreads, UInt32 bufferSize,
- UInt64 &speed,
- UInt32 complexity, unsigned benchWeight,
- const UInt32 *checkSum,
- const COneMethodInfo &method,
- IBenchPrintCallback *_file,
- CTotalBenchRes *encodeRes,
- bool showFreq, UInt64 cpuFreq)
-{
- if (numThreads == 0)
- numThreads = 1;
-
- #ifdef _7ZIP_ST
- numThreads = 1;
- #endif
-
- const AString &methodName = method.MethodName;
- // methodName.RemoveChar(L'-');
- CMethodId hashID;
- if (!FindHashMethod(
- EXTERNAL_CODECS_LOC_VARS
- methodName, hashID))
- return E_NOTIMPL;
-
- CAlignedBuffer buffer;
- size_t totalSize = (size_t)bufferSize * numThreads;
- if (totalSize / numThreads != bufferSize)
- return E_OUTOFMEMORY;
- ALLOC_WITH_HRESULT(&buffer, totalSize)
-
- Byte *buf = (Byte *)buffer;
- CBaseRandomGenerator RG;
- UInt32 bsize = (bufferSize == 0 ? 1 : bufferSize);
- UInt64 numIterations = complexInCommands * 256 / complexity / bsize;
- if (numIterations == 0)
- numIterations = 1;
-
- CBenchInfoCalc progressInfoSpec;
-
- #ifndef _7ZIP_ST
- CCrcThreads threads;
- if (numThreads > 1)
- {
- threads.Items = new CCrcInfo[numThreads];
-
- UInt32 i;
- for (i = 0; i < numThreads; i++)
- {
- CCrcInfo &info = threads.Items[i];
- AString name;
- RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS hashID, name, info.Hasher));
- if (!info.Hasher)
- return E_NOTIMPL;
- CMyComPtr<ICompressSetCoderProperties> scp;
- info.Hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
- if (scp)
- {
- UInt64 reduceSize = 1;
- RINOK(method.SetCoderProps(scp, &reduceSize));
- }
-
- Byte *data = buf + (size_t)bufferSize * i;
- info.Callback = _file;
- info.Data = data;
- info.NumIterations = numIterations;
- info.Size = bufferSize;
- /* info.Crc = */ RandGenCrc(data, bufferSize, RG);
- info.CheckSumDefined = false;
- if (checkSum)
- {
- info.CheckSum = *checkSum;
- info.CheckSumDefined = (checkSum && (i == 0));
- }
-
- #ifdef USE_ALLOCA
- info.AllocaSize = (i * 16 * 21) & 0x7FF;
- #endif
- }
-
- progressInfoSpec.SetStartTime();
-
- for (i = 0; i < numThreads; i++)
- {
- CCrcInfo &info = threads.Items[i];
- RINOK(info.Thread.Create(CrcThreadFunction, &info));
- threads.NumThreads++;
- }
- threads.WaitAll();
- for (i = 0; i < numThreads; i++)
- {
- RINOK(threads.Items[i].Res);
- }
- }
- else
- #endif
- {
- /* UInt32 crc = */ RandGenCrc(buf, bufferSize, RG);
- progressInfoSpec.SetStartTime();
- CMyComPtr<IHasher> hasher;
- AString name;
- RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS hashID, name, hasher));
- if (!hasher)
- return E_NOTIMPL;
- CMyComPtr<ICompressSetCoderProperties> scp;
- hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
- if (scp)
- {
- UInt64 reduceSize = 1;
- RINOK(method.SetCoderProps(scp, &reduceSize));
- }
- RINOK(CrcBig(buf, bufferSize, numIterations, checkSum, hasher, _file));
- }
-
- CBenchInfo info;
- progressInfoSpec.SetFinishTime(info);
-
- UInt64 unpSize = numIterations * bufferSize;
- UInt64 unpSizeThreads = unpSize * numThreads;
- info.UnpackSize = unpSizeThreads;
- info.PackSize = unpSizeThreads;
- info.NumIterations = 1;
-
- if (_file)
- {
- {
- UInt64 numCommands = unpSizeThreads * complexity / 256;
- UInt64 rating = info.GetSpeed(numCommands);
- PrintResults(_file, info,
- benchWeight, rating,
- showFreq, cpuFreq, encodeRes);
- }
- RINOK(_file->CheckBreak());
- }
-
- speed = info.GetSpeed(unpSizeThreads);
-
- return S_OK;
-}
-
-static HRESULT TotalBench_Hash(
- DECL_EXTERNAL_CODECS_LOC_VARS
- UInt64 complexInCommands,
- UInt32 numThreads, UInt32 bufSize,
- IBenchPrintCallback *printCallback, CBenchCallbackToPrint *callback,
- CTotalBenchRes *encodeRes,
- bool showFreq, UInt64 cpuFreq)
-{
- for (unsigned i = 0; i < ARRAY_SIZE(g_Hash); i++)
- {
- const CBenchHash &bench = g_Hash[i];
- PrintLeft(*callback->_file, bench.Name, kFieldSize_Name);
- // callback->BenchProps.DecComplexUnc = bench.DecComplexUnc;
- // callback->BenchProps.DecComplexCompr = bench.DecComplexCompr;
- // callback->BenchProps.EncComplex = bench.EncComplex;
-
- COneMethodInfo method;
- NCOM::CPropVariant propVariant;
- propVariant = bench.Name;
- RINOK(method.ParseMethodFromPROPVARIANT(UString(), propVariant));
-
- UInt64 speed;
- HRESULT res = CrcBench(
- EXTERNAL_CODECS_LOC_VARS
- complexInCommands,
- numThreads, bufSize,
- speed,
- bench.Complex, bench.Weight,
- &bench.CheckSum, method,
- printCallback, encodeRes, showFreq, cpuFreq);
- if (res == E_NOTIMPL)
- {
- // callback->Print(" ---");
- }
- else
- {
- RINOK(res);
- }
- callback->NewLine();
- }
- return S_OK;
-}
-
-struct CTempValues
-{
- UInt64 *Values;
- CTempValues(UInt32 num) { Values = new UInt64[num]; }
- ~CTempValues() { delete []Values; }
-};
-
-static void ParseNumberString(const UString &s, NCOM::CPropVariant &prop)
-{
- const wchar_t *end;
- UInt64 result = ConvertStringToUInt64(s, &end);
- if (*end != 0 || s.IsEmpty())
- prop = s;
- else if (result <= (UInt32)0xFFFFFFFF)
- prop = (UInt32)result;
- else
- prop = result;
-}
-
-static UInt32 GetNumThreadsNext(unsigned i, UInt32 numThreads)
-{
- if (i < 2)
- return i + 1;
- i -= 1;
- UInt32 num = (UInt32)(2 + (i & 1)) << (i >> 1);
- return (num <= numThreads) ? num : numThreads;
-}
-
-static bool AreSameMethodNames(const char *fullName, const char *shortName)
-{
- return StringsAreEqualNoCase_Ascii(fullName, shortName);
-}
-
-
-#ifdef MY_CPU_X86_OR_AMD64
-
-static void PrintCpuChars(AString &s, UInt32 v)
-{
- for (int j = 0; j < 4; j++)
- {
- Byte b = (Byte)(v & 0xFF);
- v >>= 8;
- if (b == 0)
- break;
- s += (char)b;
- }
-}
-
-static void x86cpuid_to_String(const Cx86cpuid &c, AString &s)
-{
- s.Empty();
-
- UInt32 maxFunc2 = 0;
- UInt32 t[3];
-
- MyCPUID(0x80000000, &maxFunc2, &t[0], &t[1], &t[2]);
-
- bool fullNameIsAvail = (maxFunc2 >= 0x80000004);
-
- if (!fullNameIsAvail)
- {
- for (int i = 0; i < 3; i++)
- PrintCpuChars(s, c.vendor[i]);
- }
- else
- {
- for (int i = 0; i < 3; i++)
- {
- UInt32 d[4] = { 0 };
- MyCPUID(0x80000002 + i, &d[0], &d[1], &d[2], &d[3]);
- for (int j = 0; j < 4; j++)
- PrintCpuChars(s, d[j]);
- }
- }
-
- s.Add_Space_if_NotEmpty();
- {
- char temp[32];
- ConvertUInt32ToHex(c.ver, temp);
- s += '(';
- s += temp;
- s += ')';
- }
-}
-
-#endif
-
-
-
-static const char * const k_PROCESSOR_ARCHITECTURE[] =
-{
- "x86" // "INTEL"
- , "MIPS"
- , "ALPHA"
- , "PPC"
- , "SHX"
- , "ARM"
- , "IA64"
- , "ALPHA64"
- , "MSIL"
- , "x64" // "AMD64"
- , "IA32_ON_WIN64"
- , "NEUTRAL"
- , "ARM64"
- , "ARM32_ON_WIN64"
-};
-
-#define MY__PROCESSOR_ARCHITECTURE_INTEL 0
-#define MY__PROCESSOR_ARCHITECTURE_AMD64 9
-
-
-#define MY__PROCESSOR_INTEL_PENTIUM 586
-#define MY__PROCESSOR_AMD_X8664 8664
-
-/*
-static const CUInt32PCharPair k_PROCESSOR[] =
-{
- { 2200, "IA64" },
- { 8664, "x64" }
-};
-
-#define PROCESSOR_INTEL_386 386
-#define PROCESSOR_INTEL_486 486
-#define PROCESSOR_INTEL_PENTIUM 586
-#define PROCESSOR_INTEL_860 860
-#define PROCESSOR_INTEL_IA64 2200
-#define PROCESSOR_AMD_X8664 8664
-#define PROCESSOR_MIPS_R2000 2000
-#define PROCESSOR_MIPS_R3000 3000
-#define PROCESSOR_MIPS_R4000 4000
-#define PROCESSOR_ALPHA_21064 21064
-#define PROCESSOR_PPC_601 601
-#define PROCESSOR_PPC_603 603
-#define PROCESSOR_PPC_604 604
-#define PROCESSOR_PPC_620 620
-#define PROCESSOR_HITACHI_SH3 10003
-#define PROCESSOR_HITACHI_SH3E 10004
-#define PROCESSOR_HITACHI_SH4 10005
-#define PROCESSOR_MOTOROLA_821 821
-#define PROCESSOR_SHx_SH3 103
-#define PROCESSOR_SHx_SH4 104
-#define PROCESSOR_STRONGARM 2577 // 0xA11
-#define PROCESSOR_ARM720 1824 // 0x720
-#define PROCESSOR_ARM820 2080 // 0x820
-#define PROCESSOR_ARM920 2336 // 0x920
-#define PROCESSOR_ARM_7TDMI 70001
-#define PROCESSOR_OPTIL 18767 // 0x494f
-*/
-
-#ifdef _WIN32
-
-static const char * const k_PF[] =
-{
- "FP_ERRATA"
- , "FP_EMU"
- , "CMPXCHG"
- , "MMX"
- , "PPC_MOVEMEM_64BIT"
- , "ALPHA_BYTE"
- , "SSE"
- , "3DNOW"
- , "RDTSC"
- , "PAE"
- , "SSE2"
- , "SSE_DAZ"
- , "NX"
- , "SSE3"
- , "CMPXCHG16B"
- , "CMP8XCHG16"
- , "CHANNELS"
- , "XSAVE"
- , "ARM_VFP_32"
- , "ARM_NEON"
- , "L2AT"
- , "VIRT_FIRMWARE"
- , "RDWRFSGSBASE"
- , "FASTFAIL"
- , "ARM_DIVIDE"
- , "ARM_64BIT_LOADSTORE_ATOMIC"
- , "ARM_EXTERNAL_CACHE"
- , "ARM_FMAC"
- , "RDRAND"
- , "ARM_V8"
- , "ARM_V8_CRYPTO"
- , "ARM_V8_CRC32"
- , "RDTSCP"
-};
-
-#endif
-
-
-
-
-static void PrintPage(AString &s, UInt32 v)
-{
- if ((v & 0x3FF) == 0)
- {
- s.Add_UInt32(v >> 10);
- s += "K";
- }
- else
- s.Add_UInt32(v >> 10);
-}
-
-static AString TypeToString2(const char * const table[], unsigned num, UInt32 value)
-{
- char sz[16];
- const char *p = NULL;
- if (value < num)
- p = table[value];
- if (!p)
- {
- ConvertUInt32ToString(value, sz);
- p = sz;
- }
- return (AString)p;
-}
-
-#ifdef _WIN32
-
-static void SysInfo_To_String(AString &s, const SYSTEM_INFO &si)
-{
- s += TypeToString2(k_PROCESSOR_ARCHITECTURE, ARRAY_SIZE(k_PROCESSOR_ARCHITECTURE), si.wProcessorArchitecture);
-
- if (!( si.wProcessorArchitecture == MY__PROCESSOR_ARCHITECTURE_INTEL && si.dwProcessorType == MY__PROCESSOR_INTEL_PENTIUM
- || si.wProcessorArchitecture == MY__PROCESSOR_ARCHITECTURE_AMD64 && si.dwProcessorType == MY__PROCESSOR_AMD_X8664))
- {
- s += " ";
- // s += TypePairToString(k_PROCESSOR, ARRAY_SIZE(k_PROCESSOR), si.dwProcessorType);
- s.Add_UInt32(si.dwProcessorType);
- }
- s += " ";
- PrintHex(s, si.wProcessorLevel);
- s += ".";
- PrintHex(s, si.wProcessorRevision);
- if ((UInt64)si.dwActiveProcessorMask + 1 != ((UInt64)1 << si.dwNumberOfProcessors))
- if ((UInt64)si.dwActiveProcessorMask + 1 != 0 || si.dwNumberOfProcessors != sizeof(UInt64) * 8)
- {
- s += " act:";
- PrintHex(s, si.dwActiveProcessorMask);
- }
- s += " cpus:";
- s.Add_UInt32(si.dwNumberOfProcessors);
- if (si.dwPageSize != 1 << 12)
- {
- s += " page:";
- PrintPage(s, si.dwPageSize);
- }
- if (si.dwAllocationGranularity != 1 << 16)
- {
- s += " gran:";
- PrintPage(s, si.dwAllocationGranularity);
- }
- s += " ";
-
- DWORD_PTR minAdd = (DWORD_PTR)si.lpMinimumApplicationAddress;
- UInt64 maxSize = (UInt64)(DWORD_PTR)si.lpMaximumApplicationAddress + 1;
- const UInt32 kReserveSize = ((UInt32)1 << 16);
- if (minAdd != kReserveSize)
- {
- PrintSize(s, minAdd);
- s += "-";
- }
- else
- {
- if ((maxSize & (kReserveSize - 1)) == 0)
- maxSize += kReserveSize;
- }
- PrintSize(s, maxSize);
-}
-
-#ifndef _WIN64
-typedef VOID (WINAPI *Func_GetNativeSystemInfo)(LPSYSTEM_INFO lpSystemInfo);
-#endif
-
-#endif
-
-void GetSysInfo(AString &s1, AString &s2)
-{
- s1.Empty();
- s2.Empty();
-
- #ifdef _WIN32
- SYSTEM_INFO si;
- GetSystemInfo(&si);
- {
- SysInfo_To_String(s1, si);
- // s += " : ";
- }
-
- #if !defined(_WIN64) && !defined(UNDER_CE)
- Func_GetNativeSystemInfo fn_GetNativeSystemInfo = (Func_GetNativeSystemInfo)GetProcAddress(
- GetModuleHandleA("kernel32.dll"), "GetNativeSystemInfo");
- if (fn_GetNativeSystemInfo)
- {
- SYSTEM_INFO si2;
- fn_GetNativeSystemInfo(&si2);
- // if (memcmp(&si, &si2, sizeof(si)) != 0)
- {
- // s += " - ";
- SysInfo_To_String(s2, si2);
- }
- }
- #endif
- #endif
-}
-
-
-void GetCpuName(AString &s)
-{
- s.Empty();
-
- #ifdef MY_CPU_X86_OR_AMD64
- {
- Cx86cpuid cpuid;
- if (x86cpuid_CheckAndRead(&cpuid))
- {
- AString s2;
- x86cpuid_to_String(cpuid, s2);
- s += s2;
- }
- else
- {
- #ifdef MY_CPU_AMD64
- s += "x64";
- #else
- s += "x86";
- #endif
- }
- }
- #else
-
- #ifdef MY_CPU_LE
- s += "LE";
- #elif defined(MY_CPU_BE)
- s += "BE";
- #endif
-
- #endif
-
- #ifdef _7ZIP_LARGE_PAGES
- Add_LargePages_String(s);
- #endif
-}
-
-
-void GetCpuFeatures(AString &s)
-{
- s.Empty();
-
- #ifdef _WIN32
- const unsigned kNumFeatures_Extra = 32; // we check also for unknown features
- const unsigned kNumFeatures = ARRAY_SIZE(k_PF) + kNumFeatures_Extra;
- for (unsigned i = 0; i < kNumFeatures; i++)
- {
- if (IsProcessorFeaturePresent(i))
- {
- s.Add_Space_if_NotEmpty();
- s += TypeToString2(k_PF, ARRAY_SIZE(k_PF), i);
- }
- }
- #endif
-}
-
-
-#ifdef _WIN32
-#ifndef UNDER_CE
-
-typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
-
-static BOOL My_RtlGetVersion(OSVERSIONINFOEXW *vi)
-{
- HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
- if (!ntdll)
- return FALSE;
- Func_RtlGetVersion func = (Func_RtlGetVersion)GetProcAddress(ntdll, "RtlGetVersion");
- if (!func)
- return FALSE;
- func(vi);
- return TRUE;
-}
-
-#endif
-#endif
-
-
-HRESULT Bench(
- DECL_EXTERNAL_CODECS_LOC_VARS
- IBenchPrintCallback *printCallback,
- IBenchCallback *benchCallback,
- // IBenchFreqCallback *freqCallback,
- const CObjectVector<CProperty> &props,
- UInt32 numIterations,
- bool multiDict)
-{
- if (!CrcInternalTest())
- return E_FAIL;
-
- UInt32 numCPUs = 1;
- UInt64 ramSize = (UInt64)(sizeof(size_t)) << 29;
-
- NSystem::CProcessAffinity threadsInfo;
- threadsInfo.InitST();
-
- #ifndef _7ZIP_ST
-
- if (threadsInfo.Get() && threadsInfo.processAffinityMask != 0)
- numCPUs = threadsInfo.GetNumProcessThreads();
- else
- numCPUs = NSystem::GetNumberOfProcessors();
-
- #endif
-
- bool ramSize_Defined = NSystem::GetRamSize(ramSize);
-
- UInt32 numThreadsSpecified = numCPUs;
-
- UInt32 testTime = kComplexInSeconds;
-
- UInt64 specifiedFreq = 0;
-
- bool multiThreadTests = false;
-
- COneMethodInfo method;
-
- CAlignedBuffer fileDataBuffer;
-
- {
- unsigned i;
- for (i = 0; i < props.Size(); i++)
- {
- const CProperty &property = props[i];
- UString name (property.Name);
- name.MakeLower_Ascii();
-
- if (name.IsEqualTo("file"))
- {
- if (property.Value.IsEmpty())
- return E_INVALIDARG;
-
- #ifdef USE_WIN_FILE
-
- NFile::NIO::CInFile file;
- if (!file.Open(us2fs(property.Value)))
- return E_INVALIDARG;
- UInt64 len;
- if (!file.GetLength(len))
- return E_FAIL;
- if (len >= ((UInt32)1 << 31) || len == 0)
- return E_INVALIDARG;
- ALLOC_WITH_HRESULT(&fileDataBuffer, (size_t)len);
- UInt32 processedSize;
- file.Read((Byte *)fileDataBuffer, (UInt32)len, processedSize);
- if (processedSize != len)
- return E_FAIL;
- if (printCallback)
- {
- printCallback->Print("file size =");
- PrintNumber(*printCallback, len, 0);
- printCallback->NewLine();
- }
- continue;
-
- #else
-
- return E_NOTIMPL;
-
- #endif
- }
-
- NCOM::CPropVariant propVariant;
- if (!property.Value.IsEmpty())
- ParseNumberString(property.Value, propVariant);
-
- if (name.IsEqualTo("time"))
- {
- RINOK(ParsePropToUInt32(UString(), propVariant, testTime));
- continue;
- }
-
- if (name.IsEqualTo("freq"))
- {
- UInt32 freq32 = 0;
- RINOK(ParsePropToUInt32(UString(), propVariant, freq32));
- if (freq32 == 0)
- return E_INVALIDARG;
- specifiedFreq = (UInt64)freq32 * 1000000;
-
- if (printCallback)
- {
- printCallback->Print("freq=");
- PrintNumber(*printCallback, freq32, 0);
- printCallback->NewLine();
- }
-
- continue;
- }
-
- if (name.IsPrefixedBy_Ascii_NoCase("mt"))
- {
- UString s = name.Ptr(2);
- if (s.IsEqualTo("*")
- || s.IsEmpty() && propVariant.vt == VT_BSTR && StringsAreEqual_Ascii(propVariant.bstrVal, "*"))
- {
- multiThreadTests = true;
- continue;
- }
- #ifndef _7ZIP_ST
- RINOK(ParseMtProp(s, propVariant, numCPUs, numThreadsSpecified));
- #endif
- continue;
- }
-
- RINOK(method.ParseMethodFromPROPVARIANT(name, propVariant));
- }
- }
-
- if (printCallback)
- {
- #ifdef _WIN32
- #ifndef UNDER_CE
- {
- AString s;
- // OSVERSIONINFO vi;
- OSVERSIONINFOEXW vi;
- vi.dwOSVersionInfoSize = sizeof(vi);
- // if (::GetVersionEx(&vi))
- if (My_RtlGetVersion(&vi))
- {
- s += "Windows";
- if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
- s.Add_UInt32(vi.dwPlatformId);
- s += " "; s.Add_UInt32(vi.dwMajorVersion);
- s += "."; s.Add_UInt32(vi.dwMinorVersion);
- s += " "; s.Add_UInt32(vi.dwBuildNumber);
- // s += " "; s += GetAnsiString(vi.szCSDVersion);
- }
- printCallback->Print(s);
- printCallback->NewLine();
- }
- #endif
- #endif
-
- {
- AString s1, s2;
- GetSysInfo(s1, s2);
- if (!s1.IsEmpty() || !s2.IsEmpty())
- {
- printCallback->Print(s1);
- if (s1 != s2 && !s2.IsEmpty())
- {
- printCallback->Print(" - ");
- printCallback->Print(s2);
- }
- printCallback->NewLine();
- }
- }
- {
- AString s;
- GetCpuFeatures(s);
- if (!s.IsEmpty())
- {
- printCallback->Print(s);
- printCallback->NewLine();
- }
- }
- {
- AString s;
- GetCpuName(s);
- if (!s.IsEmpty())
- {
- printCallback->Print(s);
- printCallback->NewLine();
- }
- }
- }
-
- if (printCallback)
- {
- printCallback->Print("CPU Freq:");
- }
-
- UInt64 complexInCommands = kComplexInCommands;
-
- if (printCallback /* || freqCallback */)
- {
- UInt64 numMilCommands = 1 << 6;
- if (specifiedFreq != 0)
- {
- while (numMilCommands > 1 && specifiedFreq < (numMilCommands * 1000000))
- numMilCommands >>= 1;
- }
-
- for (int jj = 0;; jj++)
- {
- if (printCallback)
- RINOK(printCallback->CheckBreak());
-
- UInt64 start = ::GetTimeCount();
- UInt32 sum = (UInt32)start;
- sum = CountCpuFreq(sum, (UInt32)(numMilCommands * 1000000 / kNumFreqCommands), g_BenchCpuFreqTemp);
- if (sum == 0xF1541213)
- if (printCallback)
- printCallback->Print("");
- const UInt64 realDelta = ::GetTimeCount() - start;
- start = realDelta;
- if (start == 0)
- start = 1;
- UInt64 freq = GetFreq();
- // mips is constant in some compilers
- const UInt64 mipsVal = numMilCommands * freq / start;
- if (printCallback)
- {
- if (realDelta == 0)
- {
- printCallback->Print(" -");
- }
- else
- {
- // PrintNumber(*printCallback, start, 0);
- PrintNumber(*printCallback, mipsVal, 5);
- }
- }
- /*
- if (freqCallback)
- freqCallback->AddCpuFreq(mipsVal);
- */
-
- if (jj >= 3)
- {
- SetComplexCommands(testTime, false, mipsVal * 1000000, complexInCommands);
- if (jj >= 8 || start >= freq)
- break;
- // break; // change it
- numMilCommands <<= 1;
- }
- }
- }
-
- if (printCallback)
- {
- printCallback->NewLine();
- printCallback->NewLine();
- PrintRequirements(*printCallback, "size: ", ramSize_Defined, ramSize, "CPU hardware threads:", numCPUs);
- printCallback->Print(GetProcessThreadsInfo(threadsInfo));
- printCallback->NewLine();
- }
-
- if (numThreadsSpecified < 1 || numThreadsSpecified > kNumThreadsMax)
- return E_INVALIDARG;
-
- UInt32 dict;
- bool dictIsDefined = method.Get_DicSize(dict);
-
- if (method.MethodName.IsEmpty())
- method.MethodName = "LZMA";
-
- if (benchCallback)
- {
- CBenchProps benchProps;
- benchProps.SetLzmaCompexity();
- UInt32 dictSize = method.Get_Lzma_DicSize();
- UInt32 uncompressedDataSize = kAdditionalSize + dictSize;
- return MethodBench(
- EXTERNAL_CODECS_LOC_VARS
- complexInCommands,
- true, numThreadsSpecified,
- method,
- uncompressedDataSize, (const Byte *)fileDataBuffer,
- kOldLzmaDictBits, printCallback, benchCallback, &benchProps);
- }
-
- AString methodName (method.MethodName);
- if (methodName.IsEqualTo_Ascii_NoCase("CRC"))
- methodName = "crc32";
- method.MethodName = methodName;
- CMethodId hashID;
-
- if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS methodName, hashID))
- {
- if (!printCallback)
- return S_FALSE;
- IBenchPrintCallback &f = *printCallback;
- if (!dictIsDefined)
- dict = (1 << 24);
-
-
- // methhodName.RemoveChar(L'-');
- UInt32 complexity = 10000;
- const UInt32 *checkSum = NULL;
- {
- unsigned i;
- for (i = 0; i < ARRAY_SIZE(g_Hash); i++)
- {
- const CBenchHash &h = g_Hash[i];
- AString benchMethod (h.Name);
- AString benchProps;
- int propPos = benchMethod.Find(':');
- if (propPos >= 0)
- {
- benchProps = benchMethod.Ptr(propPos + 1);
- benchMethod.DeleteFrom(propPos);
- }
-
- if (AreSameMethodNames(benchMethod, methodName))
- {
- if (benchProps.IsEmpty()
- || benchMethod.IsEqualTo_Ascii_NoCase("crc32") && benchProps == "8" && method.PropsString.IsEmpty()
- || method.PropsString.IsPrefixedBy_Ascii_NoCase(benchProps))
- {
- complexity = h.Complex;
- checkSum = &h.CheckSum;
- if (method.PropsString.IsEqualTo_Ascii_NoCase(benchProps))
- break;
- }
- }
- }
- if (i == ARRAY_SIZE(g_Hash))
- return E_NOTIMPL;
- }
-
- f.NewLine();
- f.Print("Size");
- const unsigned kFieldSize_CrcSpeed = 6;
- unsigned numThreadsTests = 0;
- for (;;)
- {
- UInt32 t = GetNumThreadsNext(numThreadsTests, numThreadsSpecified);
- PrintNumber(f, t, kFieldSize_CrcSpeed);
- numThreadsTests++;
- if (t >= numThreadsSpecified)
- break;
- }
- f.NewLine();
- f.NewLine();
- CTempValues speedTotals(numThreadsTests);
- {
- for (unsigned ti = 0; ti < numThreadsTests; ti++)
- speedTotals.Values[ti] = 0;
- }
-
- UInt64 numSteps = 0;
- for (UInt32 i = 0; i < numIterations; i++)
- {
- for (unsigned pow = 10; pow < 32; pow++)
- {
- UInt32 bufSize = (UInt32)1 << pow;
- if (bufSize > dict)
- break;
- char s[16];
- ConvertUInt32ToString(pow, s);
- unsigned pos = MyStringLen(s);
- s[pos++] = ':';
- s[pos++] = ' ';
- s[pos] = 0;
- f.Print(s);
-
- for (unsigned ti = 0; ti < numThreadsTests; ti++)
- {
- RINOK(f.CheckBreak());
- UInt32 t = GetNumThreadsNext(ti, numThreadsSpecified);
- UInt64 speed = 0;
- RINOK(CrcBench(EXTERNAL_CODECS_LOC_VARS complexInCommands,
- t, bufSize, speed,
- complexity,
- 1, // benchWeight,
- (pow == kNumHashDictBits) ? checkSum : NULL, method, NULL, NULL, false, 0));
- PrintNumber(f, (speed >> 20), kFieldSize_CrcSpeed);
- speedTotals.Values[ti] += speed;
- }
- f.NewLine();
- numSteps++;
- }
- }
- if (numSteps != 0)
- {
- f.NewLine();
- f.Print("Avg:");
- for (unsigned ti = 0; ti < numThreadsTests; ti++)
- {
- PrintNumber(f, ((speedTotals.Values[ti] / numSteps) >> 20), kFieldSize_CrcSpeed);
- }
- f.NewLine();
- }
- return S_OK;
- }
-
- bool use2Columns = false;
-
- bool totalBenchMode = (method.MethodName.IsEqualTo_Ascii_NoCase("*"));
- bool onlyHashBench = false;
- if (method.MethodName.IsEqualTo_Ascii_NoCase("hash"))
- {
- onlyHashBench = true;
- totalBenchMode = true;
- }
-
- // ---------- Threads loop ----------
- for (unsigned threadsPassIndex = 0; threadsPassIndex < 3; threadsPassIndex++)
- {
-
- UInt32 numThreads = numThreadsSpecified;
-
- if (!multiThreadTests)
- {
- if (threadsPassIndex != 0)
- break;
- }
- else
- {
- numThreads = 1;
- if (threadsPassIndex != 0)
- {
- if (numCPUs < 2)
- break;
- numThreads = numCPUs;
- if (threadsPassIndex == 1)
- {
- if (numCPUs >= 4)
- numThreads = numCPUs / 2;
- }
- else if (numCPUs < 4)
- break;
- }
- }
-
- CBenchCallbackToPrint callback;
- callback.Init();
- callback._file = printCallback;
-
- IBenchPrintCallback &f = *printCallback;
-
- if (threadsPassIndex > 0)
- {
- f.NewLine();
- f.NewLine();
- }
-
- if (!dictIsDefined)
- {
- const unsigned dicSizeLog_Main = (totalBenchMode ? 24 : 25);
- unsigned dicSizeLog = dicSizeLog_Main;
-
- #ifdef UNDER_CE
- dicSizeLog = (UInt64)1 << 20;
- #endif
-
- if (ramSize_Defined)
- for (; dicSizeLog > kBenchMinDicLogSize; dicSizeLog--)
- if (GetBenchMemoryUsage(numThreads, ((UInt32)1 << dicSizeLog), totalBenchMode) + (8 << 20) <= ramSize)
- break;
-
- dict = (UInt32)1 << dicSizeLog;
-
- if (totalBenchMode && dicSizeLog != dicSizeLog_Main)
- {
- f.Print("Dictionary reduced to: ");
- PrintNumber(f, dicSizeLog, 1);
- f.NewLine();
- }
- }
-
- PrintRequirements(f, "usage:", true, GetBenchMemoryUsage(numThreads, dict, totalBenchMode), "Benchmark threads: ", numThreads);
- f.NewLine();
-
- f.NewLine();
-
- if (totalBenchMode)
- {
- callback.NameFieldSize = kFieldSize_Name;
- use2Columns = false;
- }
- else
- {
- callback.NameFieldSize = kFieldSize_SmallName;
- use2Columns = true;
- }
- callback.Use2Columns = use2Columns;
-
- bool showFreq = false;
- UInt64 cpuFreq = 0;
-
- if (totalBenchMode)
- {
- showFreq = true;
- }
-
- unsigned fileldSize = kFieldSize_TotalSize;
- if (showFreq)
- fileldSize += kFieldSize_EUAndEffec;
-
- if (use2Columns)
- {
- PrintSpaces(f, callback.NameFieldSize);
- PrintRight(f, "Compressing", fileldSize);
- f.Print(kSep);
- PrintRight(f, "Decompressing", fileldSize);
- }
- f.NewLine();
- PrintLeft(f, totalBenchMode ? "Method" : "Dict", callback.NameFieldSize);
-
- int j;
-
- for (j = 0; j < 2; j++)
- {
- PrintRight(f, "Speed", kFieldSize_Speed + 1);
- PrintRight(f, "Usage", kFieldSize_Usage + 1);
- PrintRight(f, "R/U", kFieldSize_RU + 1);
- PrintRight(f, "Rating", kFieldSize_Rating + 1);
- if (showFreq)
- {
- PrintRight(f, "E/U", kFieldSize_EU + 1);
- PrintRight(f, "Effec", kFieldSize_Effec + 1);
- }
- if (!use2Columns)
- break;
- if (j == 0)
- f.Print(kSep);
- }
-
- f.NewLine();
- PrintSpaces(f, callback.NameFieldSize);
-
- for (j = 0; j < 2; j++)
- {
- PrintRight(f, "KiB/s", kFieldSize_Speed + 1);
- PrintRight(f, "%", kFieldSize_Usage + 1);
- PrintRight(f, "MIPS", kFieldSize_RU + 1);
- PrintRight(f, "MIPS", kFieldSize_Rating + 1);
- if (showFreq)
- {
- PrintRight(f, "%", kFieldSize_EU + 1);
- PrintRight(f, "%", kFieldSize_Effec + 1);
- }
- if (!use2Columns)
- break;
- if (j == 0)
- f.Print(kSep);
- }
-
- f.NewLine();
- f.NewLine();
-
- if (specifiedFreq != 0)
- cpuFreq = specifiedFreq;
-
-
- if (totalBenchMode)
- {
- for (UInt32 i = 0; i < numIterations; i++)
- {
- if (i != 0)
- printCallback->NewLine();
- HRESULT res;
-
- const unsigned kNumCpuTests = 3;
- for (unsigned freqTest = 0; freqTest < kNumCpuTests; freqTest++)
- {
- PrintLeft(f, "CPU", kFieldSize_Name);
- UInt32 resVal;
- RINOK(FreqBench(complexInCommands, numThreads, printCallback,
- (freqTest == kNumCpuTests - 1 || specifiedFreq != 0), // showFreq
- specifiedFreq,
- cpuFreq, resVal));
- callback.NewLine();
-
- if (specifiedFreq != 0)
- cpuFreq = specifiedFreq;
-
- if (freqTest == kNumCpuTests - 1)
- SetComplexCommands(testTime, specifiedFreq != 0, cpuFreq, complexInCommands);
- }
- callback.NewLine();
-
- callback.SetFreq(true, cpuFreq);
-
- if (!onlyHashBench)
- {
- res = TotalBench(EXTERNAL_CODECS_LOC_VARS
- complexInCommands, numThreads,
- dictIsDefined || fileDataBuffer.IsAllocated(), // forceUnpackSize
- fileDataBuffer.IsAllocated() ? fileDataBuffer.Size() : dict,
- (const Byte *)fileDataBuffer,
- printCallback, &callback);
- RINOK(res);
- }
-
- res = TotalBench_Hash(EXTERNAL_CODECS_LOC_VARS complexInCommands, numThreads,
- 1 << kNumHashDictBits, printCallback, &callback, &callback.EncodeRes, true, cpuFreq);
- RINOK(res);
-
- callback.NewLine();
- {
- PrintLeft(f, "CPU", kFieldSize_Name);
- UInt32 resVal;
- UInt64 cpuFreqLastTemp = cpuFreq;
- RINOK(FreqBench(complexInCommands, numThreads, printCallback,
- specifiedFreq != 0, // showFreq
- specifiedFreq,
- cpuFreqLastTemp, resVal));
- callback.NewLine();
- }
- }
- }
- else
- {
- bool needSetComplexity = true;
- if (!methodName.IsEqualTo_Ascii_NoCase("LZMA"))
- {
- unsigned i;
- for (i = 0; i < ARRAY_SIZE(g_Bench); i++)
- {
- const CBenchMethod &h = g_Bench[i];
- AString benchMethod (h.Name);
- AString benchProps;
- int propPos = benchMethod.Find(':');
- if (propPos >= 0)
- {
- benchProps = benchMethod.Ptr(propPos + 1);
- benchMethod.DeleteFrom(propPos);
- }
-
- if (AreSameMethodNames(benchMethod, methodName))
- {
- if (benchProps.IsEmpty()
- || benchProps == "x5" && method.PropsString.IsEmpty()
- || method.PropsString.IsPrefixedBy_Ascii_NoCase(benchProps))
- {
- callback.BenchProps.EncComplex = h.EncComplex;
- callback.BenchProps.DecComplexCompr = h.DecComplexCompr;
- callback.BenchProps.DecComplexUnc = h.DecComplexUnc;;
- needSetComplexity = false;
- break;
- }
- }
- }
- if (i == ARRAY_SIZE(g_Bench))
- return E_NOTIMPL;
- }
- if (needSetComplexity)
- callback.BenchProps.SetLzmaCompexity();
-
- for (unsigned i = 0; i < numIterations; i++)
- {
- const unsigned kStartDicLog = 22;
- unsigned pow = (dict < ((UInt32)1 << kStartDicLog)) ? kBenchMinDicLogSize : kStartDicLog;
- if (!multiDict)
- pow = 31;
- while (((UInt32)1 << pow) > dict && pow > 0)
- pow--;
- for (; ((UInt32)1 << pow) <= dict; pow++)
- {
- char s[16];
- ConvertUInt32ToString(pow, s);
- unsigned pos = MyStringLen(s);
- s[pos++] = ':';
- s[pos] = 0;
- PrintLeft(f, s, kFieldSize_SmallName);
- callback.DictSize = (UInt32)1 << pow;
-
- COneMethodInfo method2 = method;
-
- if (StringsAreEqualNoCase_Ascii(method2.MethodName, "LZMA"))
- {
- // We add dictionary size property.
- // method2 can have two different dictionary size properties.
- // And last property is main.
- NCOM::CPropVariant propVariant = (UInt32)pow;
- RINOK(method2.ParseMethodFromPROPVARIANT((UString)"d", propVariant));
- }
-
- size_t uncompressedDataSize;
- if (fileDataBuffer.IsAllocated())
- {
- uncompressedDataSize = fileDataBuffer.Size();
- }
- else
- {
- uncompressedDataSize = callback.DictSize;
- if (uncompressedDataSize >= (1 << 18))
- uncompressedDataSize += kAdditionalSize;
- }
-
- HRESULT res = MethodBench(
- EXTERNAL_CODECS_LOC_VARS
- complexInCommands,
- true, numThreads,
- method2,
- uncompressedDataSize, (const Byte *)fileDataBuffer,
- kOldLzmaDictBits, printCallback, &callback, &callback.BenchProps);
- f.NewLine();
- RINOK(res);
- if (!multiDict)
- break;
- }
- }
- }
-
- PrintChars(f, '-', callback.NameFieldSize + fileldSize);
-
- if (use2Columns)
- {
- f.Print(kSep);
- PrintChars(f, '-', fileldSize);
- }
-
- f.NewLine();
-
- if (use2Columns)
- {
- PrintLeft(f, "Avr:", callback.NameFieldSize);
- PrintTotals(f, showFreq, cpuFreq, callback.EncodeRes);
- f.Print(kSep);
- PrintTotals(f, showFreq, cpuFreq, callback.DecodeRes);
- f.NewLine();
- }
-
- PrintLeft(f, "Tot:", callback.NameFieldSize);
- CTotalBenchRes midRes;
- midRes.SetSum(callback.EncodeRes, callback.DecodeRes);
- PrintTotals(f, showFreq, cpuFreq, midRes);
- f.NewLine();
-
- }
- return S_OK;
-}
+// Bench.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+// #include <stdio.h>
+
+#ifndef _WIN32
+
+#define USE_POSIX_TIME
+#define USE_POSIX_TIME2
+#endif // _WIN32
+
+#ifdef USE_POSIX_TIME
+#include <time.h>
+#include <unistd.h>
+#ifdef USE_POSIX_TIME2
+#include <sys/time.h>
+#include <sys/times.h>
+#endif
+#endif // USE_POSIX_TIME
+
+#ifdef _WIN32
+#define USE_ALLOCA
+#endif
+
+#ifdef USE_ALLOCA
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <stdlib.h>
+#endif
+#endif
+
+#include "../../../../C/7zCrc.h"
+#include "../../../../C/RotateDefs.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Thread.h"
+#endif
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/SystemInfo.h"
+
+#include "../../../Common/MyBuffer2.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../Common/MethodProps.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "Bench.h"
+
+using namespace NWindows;
+
+#ifndef Z7_ST
+static const UInt32 k_LZMA = 0x030101;
+#endif
+
+static const UInt64 kComplexInCommands = (UInt64)1 <<
+ #ifdef UNDER_CE
+ 31;
+ #else
+ 34;
+ #endif
+
+static const UInt32 kComplexInMs = 4000;
+
+static void SetComplexCommandsMs(UInt32 complexInMs,
+ bool isSpecifiedFreq, UInt64 cpuFreq, UInt64 &complexInCommands)
+{
+ complexInCommands = kComplexInCommands;
+ const UInt64 kMinFreq = (UInt64)1000000 * 4;
+ const UInt64 kMaxFreq = (UInt64)1000000 * 20000;
+ if (cpuFreq < kMinFreq && !isSpecifiedFreq)
+ cpuFreq = kMinFreq;
+ if (cpuFreq < kMaxFreq || isSpecifiedFreq)
+ {
+ if (complexInMs != 0)
+ complexInCommands = complexInMs * cpuFreq / 1000;
+ else
+ complexInCommands = cpuFreq >> 2;
+ }
+}
+
+// const UInt64 kBenchmarkUsageMult = 1000000; // for debug
+static const unsigned kBenchmarkUsageMultBits = 16;
+static const UInt64 kBenchmarkUsageMult = 1 << kBenchmarkUsageMultBits;
+
+UInt64 Benchmark_GetUsage_Percents(UInt64 usage)
+{
+ return (100 * usage + kBenchmarkUsageMult / 2) / kBenchmarkUsageMult;
+}
+
+static const unsigned kNumHashDictBits = 17;
+static const UInt32 kFilterUnpackSize = (47 << 10); // + 5; // for test
+
+static const unsigned kOldLzmaDictBits = 32;
+
+// static const size_t kAdditionalSize = (size_t)1 << 32; // for debug
+static const size_t kAdditionalSize = (size_t)1 << 16;
+static const UInt32 kCompressedAdditionalSize = (1 << 10);
+
+static const UInt32 kMaxMethodPropSize = (1 << 6);
+
+
+#define ALLOC_WITH_HRESULT(_buffer_, _size_) \
+ { (_buffer_)->Alloc(_size_); \
+ if (_size_ && !(_buffer_)->IsAllocated()) return E_OUTOFMEMORY; }
+
+
+class CBaseRandomGenerator
+{
+ UInt32 A1;
+ UInt32 A2;
+ UInt32 Salt;
+public:
+ CBaseRandomGenerator(UInt32 salt = 0): Salt(salt) { Init(); }
+ void Init() { A1 = 362436069; A2 = 521288629;}
+ Z7_FORCE_INLINE
+ UInt32 GetRnd()
+ {
+ return Salt ^
+ (
+ ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) +
+ ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)) )
+ );
+ }
+};
+
+
+Z7_NO_INLINE
+static void RandGen(Byte *buf, size_t size)
+{
+ CBaseRandomGenerator RG;
+ const size_t size4 = size & ~((size_t)3);
+ size_t i;
+ for (i = 0; i < size4; i += 4)
+ {
+ const UInt32 v = RG.GetRnd();
+ SetUi32(buf + i, v)
+ }
+ UInt32 v = RG.GetRnd();
+ for (; i < size; i++)
+ {
+ buf[i] = (Byte)v;
+ v >>= 8;
+ }
+}
+
+
+class CBenchRandomGenerator: public CMidAlignedBuffer
+{
+ static UInt32 GetVal(UInt32 &res, unsigned numBits)
+ {
+ UInt32 val = res & (((UInt32)1 << numBits) - 1);
+ res >>= numBits;
+ return val;
+ }
+
+ static UInt32 GetLen(UInt32 &r)
+ {
+ UInt32 len = GetVal(r, 2);
+ return GetVal(r, 1 + len);
+ }
+
+public:
+
+ void GenerateSimpleRandom(UInt32 salt)
+ {
+ CBaseRandomGenerator rg(salt);
+ const size_t bufSize = Size();
+ Byte *buf = (Byte *)*this;
+ for (size_t i = 0; i < bufSize; i++)
+ buf[i] = (Byte)rg.GetRnd();
+ }
+
+ void GenerateLz(unsigned dictBits, UInt32 salt)
+ {
+ CBaseRandomGenerator rg(salt);
+ size_t pos = 0;
+ size_t rep0 = 1;
+ const size_t bufSize = Size();
+ Byte *buf = (Byte *)*this;
+ unsigned posBits = 1;
+
+ // printf("\n dictBits = %d\n", (UInt32)dictBits);
+ // printf("\n bufSize = 0x%p\n", (const void *)bufSize);
+
+ while (pos < bufSize)
+ {
+ /*
+ if (pos >= ((UInt32)1 << 31))
+ printf(" %x\n", pos);
+ */
+ UInt32 r = rg.GetRnd();
+ if (GetVal(r, 1) == 0 || pos < 1024)
+ buf[pos++] = (Byte)(r & 0xFF);
+ else
+ {
+ UInt32 len;
+ len = 1 + GetLen(r);
+
+ if (GetVal(r, 3) != 0)
+ {
+ len += GetLen(r);
+
+ while (((size_t)1 << posBits) < pos)
+ posBits++;
+
+ unsigned numBitsMax = dictBits;
+ if (numBitsMax > posBits)
+ numBitsMax = posBits;
+
+ const unsigned kAddBits = 6;
+ unsigned numLogBits = 5;
+ if (numBitsMax <= (1 << 4) - 1 + kAddBits)
+ numLogBits = 4;
+
+ for (;;)
+ {
+ const UInt32 ppp = GetVal(r, numLogBits) + kAddBits;
+ r = rg.GetRnd();
+ if (ppp > numBitsMax)
+ continue;
+ // rep0 = GetVal(r, ppp);
+ rep0 = r & (((size_t)1 << ppp) - 1);
+ if (rep0 < pos)
+ break;
+ r = rg.GetRnd();
+ }
+ rep0++;
+ }
+
+ // len *= 300; // for debug
+ {
+ const size_t rem = bufSize - pos;
+ if (len > rem)
+ len = (UInt32)rem;
+ }
+ Byte *dest = buf + pos;
+ const Byte *src = dest - rep0;
+ pos += len;
+ for (UInt32 i = 0; i < len; i++)
+ *dest++ = *src++;
+ }
+ }
+ // printf("\n CRC = %x\n", CrcCalc(buf, bufSize));
+ }
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CBenchmarkInStream
+ , ISequentialInStream
+)
+ const Byte *Data;
+ size_t Pos;
+ size_t Size;
+public:
+ void Init(const Byte *data, size_t size)
+ {
+ Data = data;
+ Size = size;
+ Pos = 0;
+ }
+ bool WasFinished() const { return Pos == Size; }
+};
+
+Z7_COM7F_IMF(CBenchmarkInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+{
+ const UInt32 kMaxBlockSize = (1 << 20);
+ if (size > kMaxBlockSize)
+ size = kMaxBlockSize;
+ const size_t remain = Size - Pos;
+ if (size > remain)
+ size = (UInt32)remain;
+
+ if (size != 0)
+ memcpy(data, Data + Pos, size);
+
+ Pos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+}
+
+
+class CBenchmarkOutStream Z7_final:
+ public ISequentialOutStream,
+ public CMyUnknownImp,
+ public CMidAlignedBuffer
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(ISequentialOutStream)
+ // bool _overflow;
+public:
+ size_t Pos;
+ bool RealCopy;
+ bool CalcCrc;
+ UInt32 Crc;
+
+ // CBenchmarkOutStream(): _overflow(false) {}
+ void Init(bool realCopy, bool calcCrc)
+ {
+ Crc = CRC_INIT_VAL;
+ RealCopy = realCopy;
+ CalcCrc = calcCrc;
+ // _overflow = false;
+ Pos = 0;
+ }
+
+ void InitCrc()
+ {
+ Crc = CRC_INIT_VAL;
+ }
+
+ void Calc(const void *data, size_t size)
+ {
+ Crc = CrcUpdate(Crc, data, size);
+ }
+
+ size_t GetPos() const { return Pos; }
+
+ // void Print() { printf("\n%8d %8d\n", (unsigned)BufferSize, (unsigned)Pos); }
+};
+
+Z7_COM7F_IMF(CBenchmarkOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ size_t curSize = Size() - Pos;
+ if (curSize > size)
+ curSize = size;
+ if (curSize != 0)
+ {
+ if (RealCopy)
+ memcpy(((Byte *)*this) + Pos, data, curSize);
+ if (CalcCrc)
+ Calc(data, curSize);
+ Pos += curSize;
+ }
+ if (processedSize)
+ *processedSize = (UInt32)curSize;
+ if (curSize != size)
+ {
+ // _overflow = true;
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CCrcOutStream
+ , ISequentialOutStream
+)
+public:
+ bool CalcCrc;
+ UInt32 Crc;
+ UInt64 Pos;
+
+ CCrcOutStream(): CalcCrc(true) {}
+ void Init() { Crc = CRC_INIT_VAL; Pos = 0; }
+ void Calc(const void *data, size_t size)
+ {
+ Crc = CrcUpdate(Crc, data, size);
+ }
+};
+
+Z7_COM7F_IMF(CCrcOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (CalcCrc)
+ Calc(data, size);
+ Pos += size;
+ if (processedSize)
+ *processedSize = size;
+ return S_OK;
+}
+
+// #include "../../../../C/My_sys_time.h"
+
+static UInt64 GetTimeCount()
+{
+ #ifdef USE_POSIX_TIME
+ #ifdef USE_POSIX_TIME2
+ timeval v;
+ if (gettimeofday(&v, NULL) == 0)
+ return (UInt64)(v.tv_sec) * 1000000 + (UInt64)v.tv_usec;
+ return (UInt64)time(NULL) * 1000000;
+ #else
+ return time(NULL);
+ #endif
+ #else
+ LARGE_INTEGER value;
+ if (::QueryPerformanceCounter(&value))
+ return (UInt64)value.QuadPart;
+ return GetTickCount();
+ #endif
+}
+
+static UInt64 GetFreq()
+{
+ #ifdef USE_POSIX_TIME
+ #ifdef USE_POSIX_TIME2
+ return 1000000;
+ #else
+ return 1;
+ #endif
+ #else
+ LARGE_INTEGER value;
+ if (::QueryPerformanceFrequency(&value))
+ return (UInt64)value.QuadPart;
+ return 1000;
+ #endif
+}
+
+
+#ifdef USE_POSIX_TIME
+
+struct CUserTime
+{
+ UInt64 Sum;
+ clock_t Prev;
+
+ void Init()
+ {
+ // Prev = clock();
+ Sum = 0;
+ Prev = 0;
+ Update();
+ Sum = 0;
+ }
+
+ void Update()
+ {
+ tms t;
+ /* clock_t res = */ times(&t);
+ clock_t newVal = t.tms_utime + t.tms_stime;
+ Sum += (UInt64)(newVal - Prev);
+ Prev = newVal;
+
+ /*
+ clock_t v = clock();
+ if (v != -1)
+ {
+ Sum += v - Prev;
+ Prev = v;
+ }
+ */
+ }
+ UInt64 GetUserTime()
+ {
+ Update();
+ return Sum;
+ }
+};
+
+#else
+
+
+struct CUserTime
+{
+ bool UseTick;
+ DWORD Prev_Tick;
+ UInt64 Prev;
+ UInt64 Sum;
+
+ void Init()
+ {
+ UseTick = false;
+ Prev_Tick = 0;
+ Prev = 0;
+ Sum = 0;
+ Update();
+ Sum = 0;
+ }
+ UInt64 GetUserTime()
+ {
+ Update();
+ return Sum;
+ }
+ void Update();
+};
+
+static inline UInt64 GetTime64(const FILETIME &t) { return ((UInt64)t.dwHighDateTime << 32) | t.dwLowDateTime; }
+
+void CUserTime::Update()
+{
+ DWORD new_Tick = GetTickCount();
+ FILETIME creationTime, exitTime, kernelTime, userTime;
+ if (!UseTick &&
+ #ifdef UNDER_CE
+ ::GetThreadTimes(::GetCurrentThread()
+ #else
+ ::GetProcessTimes(::GetCurrentProcess()
+ #endif
+ , &creationTime, &exitTime, &kernelTime, &userTime))
+ {
+ UInt64 newVal = GetTime64(userTime) + GetTime64(kernelTime);
+ Sum += newVal - Prev;
+ Prev = newVal;
+ }
+ else
+ {
+ UseTick = true;
+ Sum += (UInt64)(new_Tick - (DWORD)Prev_Tick) * 10000;
+ }
+ Prev_Tick = new_Tick;
+}
+
+
+#endif
+
+static UInt64 GetUserFreq()
+{
+ #ifdef USE_POSIX_TIME
+ // return CLOCKS_PER_SEC;
+ return (UInt64)sysconf(_SC_CLK_TCK);
+ #else
+ return 10000000;
+ #endif
+}
+
+class CBenchProgressStatus Z7_final
+{
+ #ifndef Z7_ST
+ NSynchronization::CCriticalSection CS;
+ #endif
+public:
+ HRESULT Res;
+ bool EncodeMode;
+ void SetResult(HRESULT res)
+ {
+ #ifndef Z7_ST
+ NSynchronization::CCriticalSectionLock lock(CS);
+ #endif
+ Res = res;
+ }
+ HRESULT GetResult()
+ {
+ #ifndef Z7_ST
+ NSynchronization::CCriticalSectionLock lock(CS);
+ #endif
+ return Res;
+ }
+};
+
+struct CBenchInfoCalc
+{
+ CBenchInfo BenchInfo;
+ CUserTime UserTime;
+
+ void SetStartTime();
+ void SetFinishTime(CBenchInfo &dest);
+};
+
+void CBenchInfoCalc::SetStartTime()
+{
+ BenchInfo.GlobalFreq = GetFreq();
+ BenchInfo.UserFreq = GetUserFreq();
+ BenchInfo.GlobalTime = ::GetTimeCount();
+ BenchInfo.UserTime = 0;
+ UserTime.Init();
+}
+
+void CBenchInfoCalc::SetFinishTime(CBenchInfo &dest)
+{
+ dest = BenchInfo;
+ dest.GlobalTime = ::GetTimeCount() - BenchInfo.GlobalTime;
+ dest.UserTime = UserTime.GetUserTime();
+}
+
+class CBenchProgressInfo Z7_final:
+ public ICompressProgressInfo,
+ public CMyUnknownImp,
+ public CBenchInfoCalc
+{
+ Z7_COM_UNKNOWN_IMP_0
+ Z7_IFACE_COM7_IMP(ICompressProgressInfo)
+public:
+ CBenchProgressStatus *Status;
+ IBenchCallback *Callback;
+
+ CBenchProgressInfo(): Callback(NULL) {}
+};
+
+
+Z7_COM7F_IMF(CBenchProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ HRESULT res = Status->GetResult();
+ if (res != S_OK)
+ return res;
+ if (!Callback)
+ return res;
+
+ /*
+ static UInt64 inSizePrev = 0;
+ static UInt64 outSizePrev = 0;
+ UInt64 delta1 = 0, delta2 = 0, val1 = 0, val2 = 0;
+ if (inSize) { val1 = *inSize; delta1 = val1 - inSizePrev; inSizePrev = val1; }
+ if (outSize) { val2 = *outSize; delta2 = val2 - outSizePrev; outSizePrev = val2; }
+ UInt64 percents = delta2 * 1000;
+ if (delta1 != 0)
+ percents /= delta1;
+ printf("=== %7d %7d %7d %7d ratio = %4d\n",
+ (unsigned)(val1 >> 10), (unsigned)(delta1 >> 10),
+ (unsigned)(val2 >> 10), (unsigned)(delta2 >> 10),
+ (unsigned)percents);
+ */
+
+ CBenchInfo info;
+ SetFinishTime(info);
+ if (Status->EncodeMode)
+ {
+ info.UnpackSize = BenchInfo.UnpackSize + *inSize;
+ info.PackSize = BenchInfo.PackSize + *outSize;
+ res = Callback->SetEncodeResult(info, false);
+ }
+ else
+ {
+ info.PackSize = BenchInfo.PackSize + *inSize;
+ info.UnpackSize = BenchInfo.UnpackSize + *outSize;
+ res = Callback->SetDecodeResult(info, false);
+ }
+ if (res != S_OK)
+ Status->SetResult(res);
+ return res;
+}
+
+static const unsigned kSubBits = 8;
+
+static unsigned GetLogSize(UInt64 size)
+{
+ unsigned i = 0;
+ for (;;)
+ {
+ i++; size >>= 1; if (size == 0) break;
+ }
+ return i;
+}
+
+
+static UInt32 GetLogSize_Sub(UInt64 size)
+{
+ if (size <= 1)
+ return 0;
+ const unsigned i = GetLogSize(size) - 1;
+ UInt32 v;
+ if (i <= kSubBits)
+ v = (UInt32)(size) << (kSubBits - i);
+ else
+ v = (UInt32)(size >> (i - kSubBits));
+ return ((UInt32)i << kSubBits) + (v & (((UInt32)1 << kSubBits) - 1));
+}
+
+
+static UInt64 Get_UInt64_from_double(double v)
+{
+ const UInt64 kMaxVal = (UInt64)1 << 62;
+ if (v > (double)(Int64)kMaxVal)
+ return kMaxVal;
+ return (UInt64)v;
+}
+
+static UInt64 MyMultDiv64(UInt64 m1, UInt64 m2, UInt64 d)
+{
+ if (d == 0)
+ d = 1;
+ const double v =
+ (double)(Int64)m1 *
+ (double)(Int64)m2 /
+ (double)(Int64)d;
+ return Get_UInt64_from_double(v);
+ /*
+ unsigned n1 = GetLogSize(m1);
+ unsigned n2 = GetLogSize(m2);
+ while (n1 + n2 > 64)
+ {
+ if (n1 >= n2)
+ {
+ m1 >>= 1;
+ n1--;
+ }
+ else
+ {
+ m2 >>= 1;
+ n2--;
+ }
+ d >>= 1;
+ }
+
+ if (d == 0)
+ d = 1;
+ return m1 * m2 / d;
+ */
+}
+
+
+UInt64 CBenchInfo::GetUsage() const
+{
+ UInt64 userTime = UserTime;
+ UInt64 userFreq = UserFreq;
+ UInt64 globalTime = GlobalTime;
+ UInt64 globalFreq = GlobalFreq;
+
+ if (userFreq == 0)
+ userFreq = 1;
+ if (globalTime == 0)
+ globalTime = 1;
+
+ const double v =
+ ((double)(Int64)userTime / (double)(Int64)userFreq)
+ * ((double)(Int64)globalFreq / (double)(Int64)globalTime)
+ * (double)(Int64)kBenchmarkUsageMult;
+ return Get_UInt64_from_double(v);
+ /*
+ return MyMultDiv64(
+ MyMultDiv64(kBenchmarkUsageMult, userTime, userFreq),
+ globalFreq, globalTime);
+ */
+}
+
+
+UInt64 CBenchInfo::GetRatingPerUsage(UInt64 rating) const
+{
+ if (UserTime == 0)
+ {
+ return 0;
+ // userTime = 1;
+ }
+ UInt64 globalFreq = GlobalFreq;
+ if (globalFreq == 0)
+ globalFreq = 1;
+
+ const double v =
+ ((double)(Int64)GlobalTime / (double)(Int64)globalFreq)
+ * ((double)(Int64)UserFreq / (double)(Int64)UserTime)
+ * (double)(Int64)rating;
+ return Get_UInt64_from_double(v);
+ /*
+ return MyMultDiv64(
+ MyMultDiv64(rating, UserFreq, UserTime),
+ GlobalTime, globalFreq);
+ */
+}
+
+
+UInt64 CBenchInfo::GetSpeed(UInt64 numUnits) const
+{
+ return MyMultDiv64(numUnits, GlobalFreq, GlobalTime);
+}
+
+static UInt64 GetNumCommands_from_Size_and_Complexity(UInt64 size, Int32 complexity)
+{
+ return complexity >= 0 ?
+ size * (UInt32)complexity :
+ size / (UInt32)(-complexity);
+}
+
+struct CBenchProps
+{
+ bool LzmaRatingMode;
+
+ Int32 EncComplex;
+ Int32 DecComplexCompr;
+ Int32 DecComplexUnc;
+
+ unsigned KeySize;
+
+ CBenchProps():
+ LzmaRatingMode(false),
+ KeySize(0)
+ {}
+
+ void SetLzmaCompexity();
+
+ UInt64 GetNumCommands_Enc(UInt64 unpackSize) const
+ {
+ const UInt32 kMinSize = 100;
+ if (unpackSize < kMinSize)
+ unpackSize = kMinSize;
+ return GetNumCommands_from_Size_and_Complexity(unpackSize, EncComplex);
+ }
+
+ UInt64 GetNumCommands_Dec(UInt64 packSize, UInt64 unpackSize) const
+ {
+ return
+ GetNumCommands_from_Size_and_Complexity(packSize, DecComplexCompr) +
+ GetNumCommands_from_Size_and_Complexity(unpackSize, DecComplexUnc);
+ }
+
+ UInt64 GetRating_Enc(UInt64 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size) const;
+ UInt64 GetRating_Dec(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt64 inSize, UInt64 numIterations) const;
+};
+
+void CBenchProps::SetLzmaCompexity()
+{
+ EncComplex = 1200;
+ DecComplexUnc = 4;
+ DecComplexCompr = 190;
+ LzmaRatingMode = true;
+}
+
+UInt64 CBenchProps::GetRating_Enc(UInt64 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size) const
+{
+ if (dictSize < (1 << kBenchMinDicLogSize))
+ dictSize = (1 << kBenchMinDicLogSize);
+ Int32 encComplex = EncComplex;
+ if (LzmaRatingMode)
+ {
+ /*
+ for (UInt64 uu = 0; uu < (UInt64)0xf << 60;)
+ {
+ unsigned rr = GetLogSize_Sub(uu);
+ printf("\n%16I64x , log = %4x", uu, rr);
+ uu += 1;
+ uu += uu / 50;
+ }
+ */
+ // throw 1;
+ const UInt32 t = GetLogSize_Sub(dictSize) - (kBenchMinDicLogSize << kSubBits);
+ encComplex = 870 + ((t * t * 5) >> (2 * kSubBits));
+ }
+ const UInt64 numCommands = GetNumCommands_from_Size_and_Complexity(size, encComplex);
+ return MyMultDiv64(numCommands, freq, elapsedTime);
+}
+
+UInt64 CBenchProps::GetRating_Dec(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt64 inSize, UInt64 numIterations) const
+{
+ const UInt64 numCommands = GetNumCommands_Dec(inSize, outSize) * numIterations;
+ return MyMultDiv64(numCommands, freq, elapsedTime);
+}
+
+
+
+UInt64 CBenchInfo::GetRating_LzmaEnc(UInt64 dictSize) const
+{
+ CBenchProps props;
+ props.SetLzmaCompexity();
+ return props.GetRating_Enc(dictSize, GlobalTime, GlobalFreq, UnpackSize * NumIterations);
+}
+
+UInt64 CBenchInfo::GetRating_LzmaDec() const
+{
+ CBenchProps props;
+ props.SetLzmaCompexity();
+ return props.GetRating_Dec(GlobalTime, GlobalFreq, UnpackSize, PackSize, NumIterations);
+}
+
+
+#ifndef Z7_ST
+
+#define NUM_CPU_LEVELS_MAX 3
+
+struct CAffinityMode
+{
+ unsigned NumBundleThreads;
+ unsigned NumLevels;
+ unsigned NumCoreThreads;
+ unsigned NumCores;
+ // unsigned DivideNum;
+ UInt32 Sizes[NUM_CPU_LEVELS_MAX];
+
+ void SetLevels(unsigned numCores, unsigned numCoreThreads);
+ DWORD_PTR GetAffinityMask(UInt32 bundleIndex, CCpuSet *cpuSet) const;
+ bool NeedAffinity() const { return NumBundleThreads != 0; }
+
+ WRes CreateThread_WithAffinity(NWindows::CThread &thread, THREAD_FUNC_TYPE startAddress, LPVOID parameter, UInt32 bundleIndex) const
+ {
+ if (NeedAffinity())
+ {
+ CCpuSet cpuSet;
+ GetAffinityMask(bundleIndex, &cpuSet);
+ return thread.Create_With_CpuSet(startAddress, parameter, &cpuSet);
+ }
+ return thread.Create(startAddress, parameter);
+ }
+
+ CAffinityMode():
+ NumBundleThreads(0),
+ NumLevels(0),
+ NumCoreThreads(1)
+ // DivideNum(1)
+ {}
+};
+
+void CAffinityMode::SetLevels(unsigned numCores, unsigned numCoreThreads)
+{
+ NumCores = numCores;
+ NumCoreThreads = numCoreThreads;
+ NumLevels = 0;
+ if (numCoreThreads == 0 || numCores == 0 || numCores % numCoreThreads != 0)
+ return;
+ UInt32 c = numCores / numCoreThreads;
+ UInt32 c2 = 1;
+ while ((c & 1) == 0)
+ {
+ c >>= 1;
+ c2 <<= 1;
+ }
+ if (c2 != 1)
+ Sizes[NumLevels++] = c2;
+ if (c != 1)
+ Sizes[NumLevels++] = c;
+ if (numCoreThreads != 1)
+ Sizes[NumLevels++] = numCoreThreads;
+ if (NumLevels == 0)
+ Sizes[NumLevels++] = 1;
+
+ /*
+ printf("\n Cores:");
+ for (unsigned i = 0; i < NumLevels; i++)
+ {
+ printf(" %d", Sizes[i]);
+ }
+ printf("\n");
+ */
+}
+
+
+DWORD_PTR CAffinityMode::GetAffinityMask(UInt32 bundleIndex, CCpuSet *cpuSet) const
+{
+ CpuSet_Zero(cpuSet);
+
+ if (NumLevels == 0)
+ return 0;
+
+ // printf("\n%2d", bundleIndex);
+
+ /*
+ UInt32 low = 0;
+ if (DivideNum != 1)
+ {
+ low = bundleIndex % DivideNum;
+ bundleIndex /= DivideNum;
+ }
+ */
+
+ UInt32 numGroups = NumCores / NumBundleThreads;
+ UInt32 m = bundleIndex % numGroups;
+ UInt32 v = 0;
+ for (unsigned i = 0; i < NumLevels; i++)
+ {
+ UInt32 size = Sizes[i];
+ while ((size & 1) == 0)
+ {
+ v *= 2;
+ v |= (m & 1);
+ m >>= 1;
+ size >>= 1;
+ }
+ v *= size;
+ v += m % size;
+ m /= size;
+ }
+
+ // UInt32 nb = NumBundleThreads / DivideNum;
+ UInt32 nb = NumBundleThreads;
+
+ DWORD_PTR mask = ((DWORD_PTR)1 << nb) - 1;
+ // v += low;
+ mask <<= v;
+
+ // printf(" %2d %8x \n ", v, (unsigned)mask);
+ #ifdef _WIN32
+ *cpuSet = mask;
+ #else
+ {
+ for (unsigned k = 0; k < nb; k++)
+ CpuSet_Set(cpuSet, v + k);
+ }
+ #endif
+
+ return mask;
+}
+
+
+struct CBenchSyncCommon
+{
+ bool ExitMode;
+ NSynchronization::CManualResetEvent StartEvent;
+
+ CBenchSyncCommon(): ExitMode(false) {}
+};
+
+#endif
+
+
+
+enum E_CheckCrcMode
+{
+ k_CheckCrcMode_Never = 0,
+ k_CheckCrcMode_Always = 1,
+ k_CheckCrcMode_FirstPass = 2
+};
+
+class CEncoderInfo;
+
+class CEncoderInfo Z7_final
+{
+ Z7_CLASS_NO_COPY(CEncoderInfo)
+
+public:
+
+ #ifndef Z7_ST
+ NWindows::CThread thread[2];
+ NSynchronization::CManualResetEvent ReadyEvent;
+ UInt32 NumDecoderSubThreads;
+ CBenchSyncCommon *Common;
+ UInt32 EncoderIndex;
+ UInt32 NumEncoderInternalThreads;
+ CAffinityMode AffinityMode;
+ bool IsGlobalMtMode; // if more than one benchmark encoder threads
+ #endif
+
+ CMyComPtr<ICompressCoder> _encoder;
+ CMyComPtr<ICompressFilter> _encoderFilter;
+ CBenchProgressInfo *progressInfoSpec[2];
+ CMyComPtr<ICompressProgressInfo> progressInfo[2];
+ UInt64 NumIterations;
+
+ UInt32 Salt;
+
+ #ifdef USE_ALLOCA
+ size_t AllocaSize;
+ #endif
+
+ unsigned KeySize;
+ Byte _key[32];
+ Byte _iv[16];
+
+ HRESULT Set_Key_and_IV(ICryptoProperties *cp)
+ {
+ RINOK(cp->SetKey(_key, KeySize))
+ return cp->SetInitVector(_iv, sizeof(_iv));
+ }
+
+ Byte _psw[16];
+
+ bool CheckCrc_Enc; /* = 1, if we want to check packed data crcs after each pass
+ used for filter and usual coders */
+ bool UseRealData_Enc; /* = 1, if we want to use only original data for each pass
+ used only for filter */
+ E_CheckCrcMode CheckCrcMode_Dec;
+
+ struct CDecoderInfo
+ {
+ CEncoderInfo *Encoder;
+ UInt32 DecoderIndex;
+ bool CallbackMode;
+
+ #ifdef USE_ALLOCA
+ size_t AllocaSize;
+ #endif
+ };
+ CDecoderInfo decodersInfo[2];
+
+ CMyComPtr<ICompressCoder> _decoders[2];
+ CMyComPtr<ICompressFilter> _decoderFilter;
+
+ HRESULT Results[2];
+ CBenchmarkOutStream *outStreamSpec;
+ CMyComPtr<ISequentialOutStream> outStream;
+ IBenchCallback *callback;
+ IBenchPrintCallback *printCallback;
+ UInt32 crc;
+ size_t kBufferSize;
+ size_t compressedSize;
+ const Byte *uncompressedDataPtr;
+
+ const Byte *fileData;
+ CBenchRandomGenerator rg;
+
+ CMidAlignedBuffer rgCopy; // it must be 16-byte aligned !!!
+
+ // CBenchmarkOutStream *propStreamSpec;
+ Byte propsData[kMaxMethodPropSize];
+ CBufPtrSeqOutStream *propStreamSpec;
+ CMyComPtr<ISequentialOutStream> propStream;
+
+ unsigned generateDictBits;
+ COneMethodInfo _method;
+
+ // for decode
+ size_t _uncompressedDataSize;
+
+ HRESULT Generate();
+ HRESULT Encode();
+ HRESULT Decode(UInt32 decoderIndex);
+
+ CEncoderInfo():
+ #ifndef Z7_ST
+ Common(NULL),
+ IsGlobalMtMode(true),
+ #endif
+ Salt(0),
+ KeySize(0),
+ CheckCrc_Enc(true),
+ UseRealData_Enc(true),
+ CheckCrcMode_Dec(k_CheckCrcMode_Always),
+ outStreamSpec(NULL),
+ callback(NULL),
+ printCallback(NULL),
+ fileData(NULL),
+ propStreamSpec(NULL)
+ {}
+
+ #ifndef Z7_ST
+
+ static THREAD_FUNC_DECL EncodeThreadFunction(void *param)
+ {
+ HRESULT res;
+ CEncoderInfo *encoder = (CEncoderInfo *)param;
+ try
+ {
+ #ifdef USE_ALLOCA
+ alloca(encoder->AllocaSize);
+ #endif
+
+ res = encoder->Encode();
+ }
+ catch(...)
+ {
+ res = E_FAIL;
+ }
+ encoder->Results[0] = res;
+ if (res != S_OK)
+ encoder->progressInfoSpec[0]->Status->SetResult(res);
+ encoder->ReadyEvent.Set();
+ return THREAD_FUNC_RET_ZERO;
+ }
+
+ static THREAD_FUNC_DECL DecodeThreadFunction(void *param)
+ {
+ CDecoderInfo *decoder = (CDecoderInfo *)param;
+
+ #ifdef USE_ALLOCA
+ alloca(decoder->AllocaSize);
+ #endif
+
+ CEncoderInfo *encoder = decoder->Encoder;
+ encoder->Results[decoder->DecoderIndex] = encoder->Decode(decoder->DecoderIndex);
+ return THREAD_FUNC_RET_ZERO;
+ }
+
+ HRESULT CreateEncoderThread()
+ {
+ WRes res = 0;
+ if (!ReadyEvent.IsCreated())
+ res = ReadyEvent.Create();
+ if (res == 0)
+ res = AffinityMode.CreateThread_WithAffinity(thread[0], EncodeThreadFunction, this,
+ EncoderIndex);
+ return HRESULT_FROM_WIN32(res);
+ }
+
+ HRESULT CreateDecoderThread(unsigned index, bool callbackMode
+ #ifdef USE_ALLOCA
+ , size_t allocaSize
+ #endif
+ )
+ {
+ CDecoderInfo &decoder = decodersInfo[index];
+ decoder.DecoderIndex = index;
+ decoder.Encoder = this;
+
+ #ifdef USE_ALLOCA
+ decoder.AllocaSize = allocaSize;
+ #endif
+
+ decoder.CallbackMode = callbackMode;
+
+ WRes res = AffinityMode.CreateThread_WithAffinity(thread[index], DecodeThreadFunction, &decoder,
+ // EncoderIndex * NumEncoderInternalThreads + index
+ EncoderIndex
+ );
+
+ return HRESULT_FROM_WIN32(res);
+ }
+
+ #endif
+};
+
+
+
+
+static size_t GetBenchCompressedSize(size_t bufferSize)
+{
+ return kCompressedAdditionalSize + bufferSize + bufferSize / 16;
+ // kBufferSize / 2;
+}
+
+
+HRESULT CEncoderInfo::Generate()
+{
+ const COneMethodInfo &method = _method;
+
+ // we need extra space, if input data is already compressed
+ const size_t kCompressedBufferSize = _encoderFilter ?
+ kBufferSize :
+ GetBenchCompressedSize(kBufferSize);
+
+ if (kCompressedBufferSize < kBufferSize)
+ return E_FAIL;
+
+ uncompressedDataPtr = fileData;
+ if (fileData)
+ {
+ #if !defined(Z7_ST)
+ if (IsGlobalMtMode)
+ {
+ /* we copy the data to local buffer of thread to eliminate
+ using of shared buffer by different threads */
+ ALLOC_WITH_HRESULT(&rg, kBufferSize)
+ memcpy((Byte *)rg, fileData, kBufferSize);
+ uncompressedDataPtr = (const Byte *)rg;
+ }
+ #endif
+ }
+ else
+ {
+ ALLOC_WITH_HRESULT(&rg, kBufferSize)
+ // DWORD ttt = GetTickCount();
+ if (generateDictBits == 0)
+ rg.GenerateSimpleRandom(Salt);
+ else
+ {
+ if (generateDictBits >= sizeof(size_t) * 8
+ && kBufferSize > ((size_t)1 << (sizeof(size_t) * 8 - 1)))
+ return E_INVALIDARG;
+ rg.GenerateLz(generateDictBits, Salt);
+ // return E_ABORT; // for debug
+ }
+ // printf("\n%d\n ", GetTickCount() - ttt);
+
+ crc = CrcCalc((const Byte *)rg, rg.Size());
+ uncompressedDataPtr = (const Byte *)rg;
+ }
+
+ if (!outStream)
+ {
+ outStreamSpec = new CBenchmarkOutStream;
+ outStream = outStreamSpec;
+ }
+
+ ALLOC_WITH_HRESULT(outStreamSpec, kCompressedBufferSize)
+
+ if (_encoderFilter)
+ {
+ /* we try to reduce the number of memcpy() in main encoding loop.
+ so we copy data to temp buffers here */
+ ALLOC_WITH_HRESULT(&rgCopy, kBufferSize)
+ memcpy((Byte *)*outStreamSpec, uncompressedDataPtr, kBufferSize);
+ memcpy((Byte *)rgCopy, uncompressedDataPtr, kBufferSize);
+ }
+
+ if (!propStream)
+ {
+ propStreamSpec = new CBufPtrSeqOutStream; // CBenchmarkOutStream;
+ propStream = propStreamSpec;
+ }
+ // ALLOC_WITH_HRESULT_2(propStreamSpec, kMaxMethodPropSize);
+ // propStreamSpec->Init(true, false);
+ propStreamSpec->Init(propsData, sizeof(propsData));
+
+
+ CMyComPtr<IUnknown> coder;
+ if (_encoderFilter)
+ coder = _encoderFilter;
+ else
+ coder = _encoder;
+ {
+ CMyComPtr<ICompressSetCoderProperties> scp;
+ coder.QueryInterface(IID_ICompressSetCoderProperties, &scp);
+ if (scp)
+ {
+ const UInt64 reduceSize = kBufferSize;
+
+ /* in posix new thread uses same affinity as parent thread,
+ so we don't need to send affinity to coder in posix */
+ UInt64 affMask;
+ #if !defined(Z7_ST) && defined(_WIN32)
+ {
+ CCpuSet cpuSet;
+ affMask = AffinityMode.GetAffinityMask(EncoderIndex, &cpuSet);
+ }
+ #else
+ affMask = 0;
+ #endif
+ // affMask <<= 3; // debug line: to test no affinity in coder;
+ // affMask = 0;
+
+ RINOK(method.SetCoderProps_DSReduce_Aff(scp, &reduceSize, (affMask != 0 ? &affMask : NULL)))
+ }
+ else
+ {
+ if (method.AreThereNonOptionalProps())
+ return E_INVALIDARG;
+ }
+
+ CMyComPtr<ICompressWriteCoderProperties> writeCoderProps;
+ coder.QueryInterface(IID_ICompressWriteCoderProperties, &writeCoderProps);
+ if (writeCoderProps)
+ {
+ RINOK(writeCoderProps->WriteCoderProperties(propStream))
+ }
+
+ {
+ CMyComPtr<ICryptoSetPassword> sp;
+ coder.QueryInterface(IID_ICryptoSetPassword, &sp);
+ if (sp)
+ {
+ RINOK(sp->CryptoSetPassword(_psw, sizeof(_psw)))
+
+ // we must call encoding one time to calculate password key for key cache.
+ // it must be after WriteCoderProperties!
+ Byte temp[16];
+ memset(temp, 0, sizeof(temp));
+
+ if (_encoderFilter)
+ {
+ _encoderFilter->Init();
+ _encoderFilter->Filter(temp, sizeof(temp));
+ }
+ else
+ {
+ CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
+ CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
+ inStreamSpec->Init(temp, sizeof(temp));
+
+ CCrcOutStream *crcStreamSpec = new CCrcOutStream;
+ CMyComPtr<ISequentialOutStream> crcStream = crcStreamSpec;
+ crcStreamSpec->Init();
+
+ RINOK(_encoder->Code(inStream, crcStream, NULL, NULL, NULL))
+ }
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+
+static void My_FilterBench(ICompressFilter *filter, Byte *data, size_t size, UInt32 *crc)
+{
+ while (size != 0)
+ {
+ UInt32 cur = crc ? 1 << 17 : 1 << 24;
+ if (cur > size)
+ cur = (UInt32)size;
+ UInt32 processed = filter->Filter(data, cur);
+ /* if (processed > size) (in AES filter), we must fill last block with zeros.
+ but it is not important for benchmark. So we just copy that data without filtering.
+ if (processed == 0) then filter can't process more */
+ if (processed > size || processed == 0)
+ processed = (UInt32)size;
+ if (crc)
+ *crc = CrcUpdate(*crc, data, processed);
+ data += processed;
+ size -= processed;
+ }
+}
+
+
+HRESULT CEncoderInfo::Encode()
+{
+ // printf("\nCEncoderInfo::Generate\n");
+
+ RINOK(Generate())
+
+ // printf("\n2222\n");
+
+ #ifndef Z7_ST
+ if (Common)
+ {
+ Results[0] = S_OK;
+ WRes wres = ReadyEvent.Set();
+ if (wres == 0)
+ wres = Common->StartEvent.Lock();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ if (Common->ExitMode)
+ return S_OK;
+ }
+ else
+ #endif
+ {
+ CBenchProgressInfo *bpi = progressInfoSpec[0];
+ bpi->SetStartTime();
+ }
+
+
+ CBenchInfo &bi = progressInfoSpec[0]->BenchInfo;
+ bi.UnpackSize = 0;
+ bi.PackSize = 0;
+ CMyComPtr<ICryptoProperties> cp;
+ CMyComPtr<IUnknown> coder;
+ if (_encoderFilter)
+ coder = _encoderFilter;
+ else
+ coder = _encoder;
+ coder.QueryInterface(IID_ICryptoProperties, &cp);
+ CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
+ CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
+
+ if (cp)
+ {
+ RINOK(Set_Key_and_IV(cp))
+ }
+
+ compressedSize = 0;
+ if (_encoderFilter)
+ compressedSize = kBufferSize;
+
+ // CBenchmarkOutStream *outStreamSpec = this->outStreamSpec;
+ UInt64 prev = 0;
+
+ const UInt32 mask = (CheckCrc_Enc ? 0 : 0xFFFF);
+ const bool useCrc = (mask < NumIterations);
+ bool crcPrev_defined = false;
+ UInt32 crcPrev = 0;
+
+ bool useRealData_Enc = UseRealData_Enc;
+ bool data_Was_Changed = false;
+ if (useRealData_Enc)
+ {
+ /* we want memcpy() for each iteration including first iteration.
+ So results will be equal for different number of iterations */
+ data_Was_Changed = true;
+ }
+
+ const UInt64 numIterations = NumIterations;
+ UInt64 i = numIterations;
+ // printCallback->NewLine();
+
+ while (i != 0)
+ {
+ i--;
+ if (printCallback && bi.UnpackSize - prev >= (1 << 26))
+ {
+ prev = bi.UnpackSize;
+ RINOK(printCallback->CheckBreak())
+ }
+
+ /*
+ CBenchInfo info;
+ progressInfoSpec[0]->SetStartTime();
+ */
+
+ bool calcCrc = false;
+ if (useCrc)
+ calcCrc = (((UInt32)i & mask) == 0);
+
+ if (_encoderFilter)
+ {
+ Byte *filterData = rgCopy;
+ if (i == numIterations - 1 || calcCrc || useRealData_Enc)
+ {
+ filterData = (Byte *)*outStreamSpec;
+ if (data_Was_Changed)
+ memcpy(filterData, uncompressedDataPtr, kBufferSize);
+ data_Was_Changed = true;
+ }
+ _encoderFilter->Init();
+ if (calcCrc)
+ outStreamSpec->InitCrc();
+ My_FilterBench(_encoderFilter, filterData, kBufferSize,
+ calcCrc ? &outStreamSpec->Crc : NULL);
+ }
+ else
+ {
+ outStreamSpec->Init(true, calcCrc); // write real data for speed consistency at any number of iterations
+ inStreamSpec->Init(uncompressedDataPtr, kBufferSize);
+ RINOK(_encoder->Code(inStream, outStream, NULL, NULL, progressInfo[0]))
+ if (!inStreamSpec->WasFinished())
+ return E_FAIL;
+ if (compressedSize != outStreamSpec->Pos)
+ {
+ if (compressedSize != 0)
+ return E_FAIL;
+ compressedSize = outStreamSpec->Pos;
+ }
+ }
+
+ // outStreamSpec->Print();
+
+ if (calcCrc)
+ {
+ const UInt32 crc2 = CRC_GET_DIGEST(outStreamSpec->Crc);
+ if (crcPrev_defined && crcPrev != crc2)
+ return E_FAIL;
+ crcPrev = crc2;
+ crcPrev_defined = true;
+ }
+
+ bi.UnpackSize += kBufferSize;
+ bi.PackSize += compressedSize;
+
+ /*
+ {
+ progressInfoSpec[0]->SetFinishTime(info);
+ info.UnpackSize = 0;
+ info.PackSize = 0;
+ info.NumIterations = 1;
+
+ info.UnpackSize = kBufferSize;
+ info.PackSize = compressedSize;
+ // printf("\n%7d\n", encoder.compressedSize);
+
+ RINOK(callback->SetEncodeResult(info, true))
+ printCallback->NewLine();
+ }
+ */
+
+ }
+
+ _encoder.Release();
+ _encoderFilter.Release();
+ return S_OK;
+}
+
+
+HRESULT CEncoderInfo::Decode(UInt32 decoderIndex)
+{
+ CBenchmarkInStream *inStreamSpec = new CBenchmarkInStream;
+ CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
+ CMyComPtr<ICompressCoder> &decoder = _decoders[decoderIndex];
+ CMyComPtr<IUnknown> coder;
+ if (_decoderFilter)
+ {
+ if (decoderIndex != 0)
+ return E_FAIL;
+ coder = _decoderFilter;
+ }
+ else
+ coder = decoder;
+
+ CMyComPtr<ICompressSetDecoderProperties2> setDecProps;
+ coder.QueryInterface(IID_ICompressSetDecoderProperties2, &setDecProps);
+ if (!setDecProps && propStreamSpec->GetPos() != 0)
+ return E_FAIL;
+
+ CCrcOutStream *crcOutStreamSpec = new CCrcOutStream;
+ CMyComPtr<ISequentialOutStream> crcOutStream = crcOutStreamSpec;
+
+ CBenchProgressInfo *pi = progressInfoSpec[decoderIndex];
+ pi->BenchInfo.UnpackSize = 0;
+ pi->BenchInfo.PackSize = 0;
+
+ #ifndef Z7_ST
+ {
+ CMyComPtr<ICompressSetCoderMt> setCoderMt;
+ coder.QueryInterface(IID_ICompressSetCoderMt, &setCoderMt);
+ if (setCoderMt)
+ {
+ RINOK(setCoderMt->SetNumberOfThreads(NumDecoderSubThreads))
+ }
+ }
+ #endif
+
+ CMyComPtr<ICompressSetCoderProperties> scp;
+ coder.QueryInterface(IID_ICompressSetCoderProperties, &scp);
+ if (scp)
+ {
+ const UInt64 reduceSize = _uncompressedDataSize;
+ RINOK(_method.SetCoderProps(scp, &reduceSize))
+ }
+
+ CMyComPtr<ICryptoProperties> cp;
+ coder.QueryInterface(IID_ICryptoProperties, &cp);
+
+ if (setDecProps)
+ {
+ RINOK(setDecProps->SetDecoderProperties2(
+ /* (const Byte *)*propStreamSpec, */
+ propsData,
+ (UInt32)propStreamSpec->GetPos()))
+ }
+
+ {
+ CMyComPtr<ICryptoSetPassword> sp;
+ coder.QueryInterface(IID_ICryptoSetPassword, &sp);
+ if (sp)
+ {
+ RINOK(sp->CryptoSetPassword(_psw, sizeof(_psw)))
+ }
+ }
+
+ UInt64 prev = 0;
+
+ if (cp)
+ {
+ RINOK(Set_Key_and_IV(cp))
+ }
+
+ CMyComPtr<ICompressSetFinishMode> setFinishMode;
+
+ if (_decoderFilter)
+ {
+ if (compressedSize > rgCopy.Size())
+ return E_FAIL;
+ }
+ else
+ {
+ decoder->QueryInterface(IID_ICompressSetFinishMode, (void **)&setFinishMode);
+ }
+
+ const UInt64 numIterations = NumIterations;
+ const E_CheckCrcMode checkCrcMode = CheckCrcMode_Dec;
+
+ for (UInt64 i = 0; i < numIterations; i++)
+ {
+ if (printCallback && pi->BenchInfo.UnpackSize - prev >= (1 << 26))
+ {
+ RINOK(printCallback->CheckBreak())
+ prev = pi->BenchInfo.UnpackSize;
+ }
+
+ const UInt64 outSize = kBufferSize;
+ bool calcCrc = (checkCrcMode != k_CheckCrcMode_Never);
+
+ crcOutStreamSpec->Init();
+
+ if (_decoderFilter)
+ {
+ Byte *filterData = (Byte *)*outStreamSpec;
+ if (calcCrc)
+ {
+ calcCrc = (i == 0);
+ if (checkCrcMode == k_CheckCrcMode_Always)
+ {
+ calcCrc = true;
+ memcpy((Byte *)rgCopy, (const Byte *)*outStreamSpec, compressedSize);
+ filterData = rgCopy;
+ }
+ }
+ _decoderFilter->Init();
+ My_FilterBench(_decoderFilter, filterData, compressedSize,
+ calcCrc ? &crcOutStreamSpec->Crc : NULL);
+ }
+ else
+ {
+ crcOutStreamSpec->CalcCrc = calcCrc;
+ inStreamSpec->Init((const Byte *)*outStreamSpec, compressedSize);
+
+ if (setFinishMode)
+ {
+ RINOK(setFinishMode->SetFinishMode(BoolToUInt(true)))
+ }
+
+ RINOK(decoder->Code(inStream, crcOutStream, NULL, &outSize, progressInfo[decoderIndex]))
+
+ if (setFinishMode)
+ {
+ if (!inStreamSpec->WasFinished())
+ return S_FALSE;
+
+ CMyComPtr<ICompressGetInStreamProcessedSize> getInStreamProcessedSize;
+ decoder.QueryInterface(IID_ICompressGetInStreamProcessedSize, (void **)&getInStreamProcessedSize);
+
+ if (getInStreamProcessedSize)
+ {
+ UInt64 processed;
+ RINOK(getInStreamProcessedSize->GetInStreamProcessedSize(&processed))
+ if (processed != compressedSize)
+ return S_FALSE;
+ }
+ }
+
+ if (crcOutStreamSpec->Pos != outSize)
+ return S_FALSE;
+ }
+
+ if (calcCrc && CRC_GET_DIGEST(crcOutStreamSpec->Crc) != crc)
+ return S_FALSE;
+
+ pi->BenchInfo.UnpackSize += kBufferSize;
+ pi->BenchInfo.PackSize += compressedSize;
+ }
+
+ decoder.Release();
+ _decoderFilter.Release();
+ return S_OK;
+}
+
+
+static const UInt32 kNumThreadsMax = (1 << 12);
+
+struct CBenchEncoders
+{
+ CEncoderInfo *encoders;
+ CBenchEncoders(UInt32 num): encoders(NULL) { encoders = new CEncoderInfo[num]; }
+ ~CBenchEncoders() { delete []encoders; }
+};
+
+
+static UInt64 GetNumIterations(UInt64 numCommands, UInt64 complexInCommands)
+{
+ if (numCommands < (1 << 4))
+ numCommands = (1 << 4);
+ UInt64 res = complexInCommands / numCommands;
+ return (res == 0 ? 1 : res);
+}
+
+
+
+#ifndef Z7_ST
+
+// ---------- CBenchThreadsFlusher ----------
+
+struct CBenchThreadsFlusher
+{
+ CBenchEncoders *EncodersSpec;
+ CBenchSyncCommon Common;
+ unsigned NumThreads;
+ bool NeedClose;
+
+ CBenchThreadsFlusher(): NumThreads(0), NeedClose(false) {}
+
+ ~CBenchThreadsFlusher()
+ {
+ StartAndWait(true);
+ }
+
+ WRes StartAndWait(bool exitMode = false);
+};
+
+
+WRes CBenchThreadsFlusher::StartAndWait(bool exitMode)
+{
+ if (!NeedClose)
+ return 0;
+
+ Common.ExitMode = exitMode;
+ WRes res = Common.StartEvent.Set();
+
+ for (unsigned i = 0; i < NumThreads; i++)
+ {
+ NWindows::CThread &t = EncodersSpec->encoders[i].thread[0];
+ if (t.IsCreated())
+ {
+ WRes res2 = t.Wait_Close();
+ if (res == 0)
+ res = res2;
+ }
+ }
+ NeedClose = false;
+ return res;
+}
+
+#endif // Z7_ST
+
+
+
+static void SetPseudoRand(Byte *data, size_t size, UInt32 startValue)
+{
+ for (size_t i = 0; i < size; i++)
+ {
+ data[i] = (Byte)startValue;
+ startValue++;
+ }
+}
+
+
+
+static HRESULT MethodBench(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ UInt64 complexInCommands,
+ #ifndef Z7_ST
+ bool oldLzmaBenchMode,
+ UInt32 numThreads,
+ const CAffinityMode *affinityMode,
+ #endif
+ const COneMethodInfo &method2,
+ size_t uncompressedDataSize,
+ const Byte *fileData,
+ unsigned generateDictBits,
+
+ IBenchPrintCallback *printCallback,
+ IBenchCallback *callback,
+ CBenchProps *benchProps)
+{
+ COneMethodInfo method = method2;
+ UInt64 methodId;
+ UInt32 numStreams;
+ bool isFilter;
+ const int codecIndex = FindMethod_Index(
+ EXTERNAL_CODECS_LOC_VARS
+ method.MethodName, true,
+ methodId, numStreams, isFilter);
+ if (codecIndex < 0)
+ return E_NOTIMPL;
+ if (numStreams != 1)
+ return E_INVALIDARG;
+
+ UInt32 numEncoderThreads = 1;
+ UInt32 numSubDecoderThreads = 1;
+
+ #ifndef Z7_ST
+ numEncoderThreads = numThreads;
+
+ if (oldLzmaBenchMode)
+ if (methodId == k_LZMA)
+ {
+ if (numThreads == 1 && method.Get_NumThreads() < 0)
+ method.AddProp_NumThreads(1);
+ const UInt32 numLzmaThreads = method.Get_Lzma_NumThreads();
+ if (numThreads > 1 && numLzmaThreads > 1)
+ {
+ numEncoderThreads = (numThreads + 1) / 2; // 20.03
+ numSubDecoderThreads = 2;
+ }
+ }
+
+ const bool mtEncMode = (numEncoderThreads > 1) || affinityMode->NeedAffinity();
+
+ #endif
+
+ CBenchEncoders encodersSpec(numEncoderThreads);
+ CEncoderInfo *encoders = encodersSpec.encoders;
+
+ UInt32 i;
+
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ CEncoderInfo &encoder = encoders[i];
+ encoder.callback = (i == 0) ? callback : NULL;
+ encoder.printCallback = printCallback;
+
+ #ifndef Z7_ST
+ encoder.EncoderIndex = i;
+ encoder.NumEncoderInternalThreads = numSubDecoderThreads;
+ encoder.AffinityMode = *affinityMode;
+
+ /*
+ if (numSubDecoderThreads > 1)
+ if (encoder.AffinityMode.NeedAffinity()
+ && encoder.AffinityMode.NumBundleThreads == 1)
+ {
+ // if old LZMA benchmark uses two threads in coder, we increase (NumBundleThreads) for old LZMA benchmark uses two threads instead of one
+ if (encoder.AffinityMode.NumBundleThreads * 2 <= encoder.AffinityMode.NumCores)
+ encoder.AffinityMode.NumBundleThreads *= 2;
+ }
+ */
+
+ #endif
+
+ {
+ CCreatedCoder cod;
+ RINOK(CreateCoder_Index(EXTERNAL_CODECS_LOC_VARS (unsigned)codecIndex, true, encoder._encoderFilter, cod))
+ encoder._encoder = cod.Coder;
+ if (!encoder._encoder && !encoder._encoderFilter)
+ return E_NOTIMPL;
+ }
+
+ SetPseudoRand(encoder._iv, sizeof(encoder._iv), 17);
+ SetPseudoRand(encoder._key, sizeof(encoder._key), 51);
+ SetPseudoRand(encoder._psw, sizeof(encoder._psw), 123);
+
+ for (UInt32 j = 0; j < numSubDecoderThreads; j++)
+ {
+ CCreatedCoder cod;
+ CMyComPtr<ICompressCoder> &decoder = encoder._decoders[j];
+ RINOK(CreateCoder_Id(EXTERNAL_CODECS_LOC_VARS methodId, false, encoder._decoderFilter, cod))
+ decoder = cod.Coder;
+ if (!encoder._decoderFilter && !decoder)
+ return E_NOTIMPL;
+ }
+
+ encoder.UseRealData_Enc =
+ encoder.CheckCrc_Enc = (benchProps->EncComplex) > 30;
+
+ encoder.CheckCrcMode_Dec = k_CheckCrcMode_Always;
+ if (benchProps->DecComplexCompr +
+ benchProps->DecComplexUnc <= 30)
+ encoder.CheckCrcMode_Dec =
+ k_CheckCrcMode_FirstPass; // for filters
+ // k_CheckCrcMode_Never; // for debug
+ // k_CheckCrcMode_Always; // for debug
+ if (fileData)
+ {
+ encoder.UseRealData_Enc = true;
+ encoder.CheckCrcMode_Dec = k_CheckCrcMode_Always;
+ }
+ }
+
+ UInt32 crc = 0;
+ if (fileData)
+ crc = CrcCalc(fileData, uncompressedDataSize);
+
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ CEncoderInfo &encoder = encoders[i];
+ encoder._method = method;
+ encoder.generateDictBits = generateDictBits;
+ encoder._uncompressedDataSize = uncompressedDataSize;
+ encoder.kBufferSize = uncompressedDataSize;
+ encoder.fileData = fileData;
+ encoder.crc = crc;
+ }
+
+ CBenchProgressStatus status;
+ status.Res = S_OK;
+ status.EncodeMode = true;
+
+ #ifndef Z7_ST
+ CBenchThreadsFlusher encoderFlusher;
+ if (mtEncMode)
+ {
+ WRes wres = encoderFlusher.Common.StartEvent.Create();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ encoderFlusher.NumThreads = numEncoderThreads;
+ encoderFlusher.EncodersSpec = &encodersSpec;
+ encoderFlusher.NeedClose = true;
+ }
+ #endif
+
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ CEncoderInfo &encoder = encoders[i];
+ encoder.NumIterations = GetNumIterations(benchProps->GetNumCommands_Enc(uncompressedDataSize), complexInCommands);
+ // encoder.NumIterations = 3;
+ encoder.Salt = g_CrcTable[i & 0xFF];
+ encoder.Salt ^= (g_CrcTable[(i >> 8) & 0xFF] << 3);
+ // (g_CrcTable[0] == 0), and (encoder.Salt == 0) for first thread
+ // printf(" %8x", encoder.Salt);
+
+ encoder.KeySize = benchProps->KeySize;
+
+ for (int j = 0; j < 2; j++)
+ {
+ CBenchProgressInfo *spec = new CBenchProgressInfo;
+ encoder.progressInfoSpec[j] = spec;
+ encoder.progressInfo[j] = spec;
+ spec->Status = &status;
+ }
+
+ if (i == 0)
+ {
+ CBenchProgressInfo *bpi = encoder.progressInfoSpec[0];
+ bpi->Callback = callback;
+ bpi->BenchInfo.NumIterations = numEncoderThreads;
+ }
+
+ #ifndef Z7_ST
+ if (mtEncMode)
+ {
+ #ifdef USE_ALLOCA
+ encoder.AllocaSize = (i * 16 * 21) & 0x7FF;
+ #endif
+
+ encoder.Common = &encoderFlusher.Common;
+ encoder.IsGlobalMtMode = numEncoderThreads > 1;
+ RINOK(encoder.CreateEncoderThread())
+ }
+ #endif
+ }
+
+ if (printCallback)
+ {
+ RINOK(printCallback->CheckBreak())
+ }
+
+ #ifndef Z7_ST
+ if (mtEncMode)
+ {
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ CEncoderInfo &encoder = encoders[i];
+ const WRes wres = encoder.ReadyEvent.Lock();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ RINOK(encoder.Results[0])
+ }
+
+ CBenchProgressInfo *bpi = encoders[0].progressInfoSpec[0];
+ bpi->SetStartTime();
+
+ const WRes wres = encoderFlusher.StartAndWait();
+ if (status.Res == 0 && wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ else
+ #endif
+ {
+ RINOK(encoders[0].Encode())
+ }
+
+ RINOK(status.Res)
+
+ CBenchInfo info;
+
+ encoders[0].progressInfoSpec[0]->SetFinishTime(info);
+ info.UnpackSize = 0;
+ info.PackSize = 0;
+ info.NumIterations = encoders[0].NumIterations;
+
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ const CEncoderInfo &encoder = encoders[i];
+ info.UnpackSize += encoder.kBufferSize;
+ info.PackSize += encoder.compressedSize;
+ // printf("\n%7d\n", encoder.compressedSize);
+ }
+
+ RINOK(callback->SetEncodeResult(info, true))
+
+
+
+
+ // ---------- Decode ----------
+
+ status.Res = S_OK;
+ status.EncodeMode = false;
+
+ const UInt32 numDecoderThreads = numEncoderThreads * numSubDecoderThreads;
+ #ifndef Z7_ST
+ const bool mtDecoderMode = (numDecoderThreads > 1) || affinityMode->NeedAffinity();
+ #endif
+
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ CEncoderInfo &encoder = encoders[i];
+
+ /*
+ #ifndef Z7_ST
+ // encoder.affinityMode = *affinityMode;
+ if (encoder.NumEncoderInternalThreads != 1)
+ encoder.AffinityMode.DivideNum = encoder.NumEncoderInternalThreads;
+ #endif
+ */
+
+
+ if (i == 0)
+ {
+ encoder.NumIterations = GetNumIterations(
+ benchProps->GetNumCommands_Dec(
+ encoder.compressedSize,
+ encoder.kBufferSize),
+ complexInCommands);
+ CBenchProgressInfo *bpi = encoder.progressInfoSpec[0];
+ bpi->Callback = callback;
+ bpi->BenchInfo.NumIterations = numDecoderThreads;
+ bpi->SetStartTime();
+ }
+ else
+ encoder.NumIterations = encoders[0].NumIterations;
+
+ #ifndef Z7_ST
+ {
+ int numSubThreads = method.Get_NumThreads();
+ encoder.NumDecoderSubThreads = (numSubThreads <= 0) ? 1 : (unsigned)numSubThreads;
+ }
+ if (mtDecoderMode)
+ {
+ for (UInt32 j = 0; j < numSubDecoderThreads; j++)
+ {
+ const HRESULT res = encoder.CreateDecoderThread(j, (i == 0 && j == 0)
+ #ifdef USE_ALLOCA
+ , ((i * numSubDecoderThreads + j) * 16 * 21) & 0x7FF
+ #endif
+ );
+ RINOK(res)
+ }
+ }
+ else
+ #endif
+ {
+ RINOK(encoder.Decode(0))
+ }
+ }
+
+ #ifndef Z7_ST
+ if (mtDecoderMode)
+ {
+ WRes wres = 0;
+ HRESULT res = S_OK;
+ for (i = 0; i < numEncoderThreads; i++)
+ for (UInt32 j = 0; j < numSubDecoderThreads; j++)
+ {
+ CEncoderInfo &encoder = encoders[i];
+ const WRes wres2 = encoder.thread[j].
+ // Wait(); // later we can get thread times from thread in UNDER_CE
+ Wait_Close();
+ if (wres == 0 && wres2 != 0)
+ wres = wres2;
+ const HRESULT res2 = encoder.Results[j];
+ if (res == 0 && res2 != 0)
+ res = res2;
+ }
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ RINOK(res)
+ }
+ #endif // Z7_ST
+
+ RINOK(status.Res)
+ encoders[0].progressInfoSpec[0]->SetFinishTime(info);
+
+ /*
+ #ifndef Z7_ST
+ #ifdef UNDER_CE
+ if (mtDecoderMode)
+ for (i = 0; i < numEncoderThreads; i++)
+ for (UInt32 j = 0; j < numSubDecoderThreads; j++)
+ {
+ FILETIME creationTime, exitTime, kernelTime, userTime;
+ if (::GetThreadTimes(encoders[i].thread[j], &creationTime, &exitTime, &kernelTime, &userTime) != 0)
+ info.UserTime += GetTime64(userTime) + GetTime64(kernelTime);
+ }
+ #endif
+ #endif
+ */
+
+ info.UnpackSize = 0;
+ info.PackSize = 0;
+ info.NumIterations = numSubDecoderThreads * encoders[0].NumIterations;
+
+ for (i = 0; i < numEncoderThreads; i++)
+ {
+ const CEncoderInfo &encoder = encoders[i];
+ info.UnpackSize += encoder.kBufferSize;
+ info.PackSize += encoder.compressedSize;
+ }
+
+ // RINOK(callback->SetDecodeResult(info, false)) // why we called before 21.03 ??
+ RINOK(callback->SetDecodeResult(info, true))
+
+ return S_OK;
+}
+
+
+
+static inline UInt64 GetDictSizeFromLog(unsigned dictSizeLog)
+{
+ /*
+ if (dictSizeLog < 32)
+ return (UInt32)1 << dictSizeLog;
+ else
+ return (UInt32)(Int32)-1;
+ */
+ return (UInt64)1 << dictSizeLog;
+}
+
+
+// it's limit of current LZMA implementation that can be changed later
+#define kLzmaMaxDictSize ((UInt32)15 << 28)
+
+static inline UInt64 GetLZMAUsage(bool multiThread, int btMode, UInt64 dict)
+{
+ if (dict == 0)
+ dict = 1;
+ if (dict > kLzmaMaxDictSize)
+ dict = kLzmaMaxDictSize;
+ UInt32 hs = (UInt32)dict - 1;
+ hs |= (hs >> 1);
+ hs |= (hs >> 2);
+ hs |= (hs >> 4);
+ hs |= (hs >> 8);
+ hs >>= 1;
+ hs |= 0xFFFF;
+ if (hs > (1 << 24))
+ hs >>= 1;
+ hs++;
+ hs += (1 << 16);
+
+ const UInt32 kBlockSizeMax = (UInt32)0 - (UInt32)(1 << 16);
+ UInt64 blockSize = (UInt64)dict + (1 << 16)
+ + (multiThread ? (1 << 20) : 0);
+ blockSize += (blockSize >> (blockSize < ((UInt32)1 << 30) ? 1 : 2));
+ if (blockSize >= kBlockSizeMax)
+ blockSize = kBlockSizeMax;
+
+ UInt64 son = (UInt64)dict;
+ if (btMode)
+ son *= 2;
+ const UInt64 v = (hs + son) * 4 + blockSize +
+ (1 << 20) + (multiThread ? (6 << 20) : 0);
+
+ // printf("\nGetLZMAUsage = %d\n", (UInt32)(v >> 20));
+ // printf("\nblockSize = %d\n", (UInt32)(blockSize >> 20));
+ return v;
+}
+
+
+UInt64 GetBenchMemoryUsage(UInt32 numThreads, int level, UInt64 dictionary, bool totalBench)
+{
+ const size_t kBufferSize = (size_t)dictionary + kAdditionalSize;
+ const UInt64 kCompressedBufferSize = GetBenchCompressedSize(kBufferSize); // / 2;
+ if (level < 0)
+ level = 5;
+ const int algo = (level < 5 ? 0 : 1);
+ const int btMode = (algo == 0 ? 0 : 1);
+
+ UInt32 numBigThreads = numThreads;
+ bool lzmaMt = (totalBench || (numThreads > 1 && btMode));
+ if (btMode)
+ {
+ if (!totalBench && lzmaMt)
+ numBigThreads /= 2;
+ }
+ return ((UInt64)kBufferSize + kCompressedBufferSize +
+ GetLZMAUsage(lzmaMt, btMode, dictionary) + (2 << 20)) * numBigThreads;
+}
+
+static UInt64 GetBenchMemoryUsage_Hash(UInt32 numThreads, UInt64 dictionary)
+{
+ // dictionary += (dictionary >> 9); // for page tables (virtual memory)
+ return (UInt64)(dictionary + (1 << 15)) * numThreads + (2 << 20);
+}
+
+
+// ---------- CRC and HASH ----------
+
+struct CCrcInfo_Base
+{
+ CMidAlignedBuffer Buffer;
+ const Byte *Data;
+ size_t Size;
+ bool CreateLocalBuf;
+ UInt32 CheckSum_Res;
+
+ CCrcInfo_Base(): CreateLocalBuf(true), CheckSum_Res(0) {}
+
+ HRESULT Generate(const Byte *data, size_t size);
+ HRESULT CrcProcess(UInt64 numIterations,
+ const UInt32 *checkSum, IHasher *hf,
+ IBenchPrintCallback *callback);
+};
+
+
+HRESULT CCrcInfo_Base::Generate(const Byte *data, size_t size)
+{
+ Size = size;
+ Data = data;
+ if (!data || CreateLocalBuf)
+ {
+ ALLOC_WITH_HRESULT(&Buffer, size)
+ Data = Buffer;
+ }
+ if (!data)
+ RandGen(Buffer, size);
+ else if (CreateLocalBuf && size != 0)
+ memcpy(Buffer, data, size);
+ return S_OK;
+}
+
+
+HRESULT CCrcInfo_Base::CrcProcess(UInt64 numIterations,
+ const UInt32 *checkSum, IHasher *hf,
+ IBenchPrintCallback *callback)
+{
+ MY_ALIGN(16)
+ Byte hash[64];
+ memset(hash, 0, sizeof(hash));
+
+ CheckSum_Res = 0;
+
+ const UInt32 hashSize = hf->GetDigestSize();
+ if (hashSize > sizeof(hash))
+ return S_FALSE;
+
+ const Byte *buf = Data;
+ const size_t size = Size;
+ UInt32 checkSum_Prev = 0;
+
+ UInt64 prev = 0;
+ UInt64 cur = 0;
+
+ for (UInt64 i = 0; i < numIterations; i++)
+ {
+ hf->Init();
+ size_t pos = 0;
+ do
+ {
+ const size_t rem = size - pos;
+ const UInt32 kStep = ((UInt32)1 << 31);
+ const UInt32 curSize = (rem < kStep) ? (UInt32)rem : kStep;
+ hf->Update(buf + pos, curSize);
+ pos += curSize;
+ }
+ while (pos != size);
+
+ hf->Final(hash);
+ UInt32 sum = 0;
+ for (UInt32 j = 0; j < hashSize; j += 4)
+ {
+ sum = rotlFixed(sum, 11);
+ sum += GetUi32(hash + j);
+ }
+ if (checkSum)
+ {
+ if (sum != *checkSum)
+ return S_FALSE;
+ }
+ else
+ {
+ checkSum_Prev = sum;
+ checkSum = &checkSum_Prev;
+ }
+ if (callback)
+ {
+ cur += size;
+ if (cur - prev >= ((UInt32)1 << 30))
+ {
+ prev = cur;
+ RINOK(callback->CheckBreak())
+ }
+ }
+ }
+ CheckSum_Res = checkSum_Prev;
+ return S_OK;
+}
+
+extern
+UInt32 g_BenchCpuFreqTemp; // we need non-static variavble to disable compiler optimization
+UInt32 g_BenchCpuFreqTemp = 1;
+
+#define YY1 sum += val; sum ^= val;
+#define YY3 YY1 YY1 YY1 YY1
+#define YY5 YY3 YY3 YY3 YY3
+#define YY7 YY5 YY5 YY5 YY5
+static const UInt32 kNumFreqCommands = 128;
+
+EXTERN_C_BEGIN
+
+static UInt32 CountCpuFreq(UInt32 sum, UInt32 num, UInt32 val)
+{
+ for (UInt32 i = 0; i < num; i++)
+ {
+ YY7
+ }
+ return sum;
+}
+
+EXTERN_C_END
+
+
+#ifndef Z7_ST
+
+struct CBaseThreadInfo
+{
+ NWindows::CThread Thread;
+ IBenchPrintCallback *Callback;
+ HRESULT CallbackRes;
+
+ WRes Wait_If_Created()
+ {
+ if (!Thread.IsCreated())
+ return 0;
+ return Thread.Wait_Close();
+ }
+};
+
+struct CFreqInfo: public CBaseThreadInfo
+{
+ UInt32 ValRes;
+ UInt32 Size;
+ UInt64 NumIterations;
+};
+
+static THREAD_FUNC_DECL FreqThreadFunction(void *param)
+{
+ CFreqInfo *p = (CFreqInfo *)param;
+
+ UInt32 sum = g_BenchCpuFreqTemp;
+ for (UInt64 k = p->NumIterations; k > 0; k--)
+ {
+ if (p->Callback)
+ {
+ p->CallbackRes = p->Callback->CheckBreak();
+ if (p->CallbackRes != S_OK)
+ break;
+ }
+ sum = CountCpuFreq(sum, p->Size, g_BenchCpuFreqTemp);
+ }
+ p->ValRes = sum;
+ return THREAD_FUNC_RET_ZERO;
+}
+
+struct CFreqThreads
+{
+ CFreqInfo *Items;
+ UInt32 NumThreads;
+
+ CFreqThreads(): Items(NULL), NumThreads(0) {}
+
+ WRes WaitAll()
+ {
+ WRes wres = 0;
+ for (UInt32 i = 0; i < NumThreads; i++)
+ {
+ WRes wres2 = Items[i].Wait_If_Created();
+ if (wres == 0 && wres2 != 0)
+ wres = wres2;
+ }
+ NumThreads = 0;
+ return wres;
+ }
+
+ ~CFreqThreads()
+ {
+ WaitAll();
+ delete []Items;
+ }
+};
+
+
+static THREAD_FUNC_DECL CrcThreadFunction(void *param);
+
+struct CCrcInfo: public CBaseThreadInfo
+{
+ const Byte *Data;
+ size_t Size;
+ UInt64 NumIterations;
+ bool CheckSumDefined;
+ UInt32 CheckSum;
+ CMyComPtr<IHasher> Hasher;
+ HRESULT Res;
+ UInt32 CheckSum_Res;
+
+ #ifndef Z7_ST
+ NSynchronization::CManualResetEvent ReadyEvent;
+ UInt32 ThreadIndex;
+ CBenchSyncCommon *Common;
+ CAffinityMode AffinityMode;
+ #endif
+
+ // we want to call CCrcInfo_Base::Buffer.Free() in main thread.
+ // so we uses non-local CCrcInfo_Base.
+ CCrcInfo_Base crcib;
+
+ HRESULT CreateThread()
+ {
+ WRes res = 0;
+ if (!ReadyEvent.IsCreated())
+ res = ReadyEvent.Create();
+ if (res == 0)
+ res = AffinityMode.CreateThread_WithAffinity(Thread, CrcThreadFunction, this,
+ ThreadIndex);
+ return HRESULT_FROM_WIN32(res);
+ }
+
+ #ifdef USE_ALLOCA
+ size_t AllocaSize;
+ #endif
+
+ void Process();
+
+ CCrcInfo(): Res(E_FAIL) {}
+};
+
+static const bool k_Crc_CreateLocalBuf_For_File = true; // for total BW test
+// static const bool k_Crc_CreateLocalBuf_For_File = false; // for shared memory read test
+
+void CCrcInfo::Process()
+{
+ crcib.CreateLocalBuf = k_Crc_CreateLocalBuf_For_File;
+ // we can use additional Generate() passes to reduce some time effects for new page allocation
+ // for (unsigned y = 0; y < 10; y++)
+ Res = crcib.Generate(Data, Size);
+
+ // if (Common)
+ {
+ WRes wres = ReadyEvent.Set();
+ if (wres != 0)
+ {
+ if (Res == 0)
+ Res = HRESULT_FROM_WIN32(wres);
+ return;
+ }
+ if (Res != 0)
+ return;
+
+ wres = Common->StartEvent.Lock();
+
+ if (wres != 0)
+ {
+ Res = HRESULT_FROM_WIN32(wres);
+ return;
+ }
+ if (Common->ExitMode)
+ return;
+ }
+
+ Res = crcib.CrcProcess(NumIterations,
+ CheckSumDefined ? &CheckSum : NULL, Hasher,
+ Callback);
+ CheckSum_Res = crcib.CheckSum_Res;
+ /*
+ We don't want to include the time of slow CCrcInfo_Base::Buffer.Free()
+ to time of benchmark. So we don't free Buffer here
+ */
+ // crcib.Buffer.Free();
+}
+
+
+static THREAD_FUNC_DECL CrcThreadFunction(void *param)
+{
+ CCrcInfo *p = (CCrcInfo *)param;
+
+ #ifdef USE_ALLOCA
+ alloca(p->AllocaSize);
+ #endif
+ p->Process();
+ return THREAD_FUNC_RET_ZERO;
+}
+
+
+struct CCrcThreads
+{
+ CCrcInfo *Items;
+ unsigned NumThreads;
+ CBenchSyncCommon Common;
+ bool NeedClose;
+
+ CCrcThreads(): Items(NULL), NumThreads(0), NeedClose(false) {}
+
+ WRes StartAndWait(bool exitMode = false);
+
+ ~CCrcThreads()
+ {
+ StartAndWait(true);
+ delete []Items;
+ }
+};
+
+
+WRes CCrcThreads::StartAndWait(bool exitMode)
+{
+ if (!NeedClose)
+ return 0;
+
+ Common.ExitMode = exitMode;
+ WRes wres = Common.StartEvent.Set();
+
+ for (unsigned i = 0; i < NumThreads; i++)
+ {
+ WRes wres2 = Items[i].Wait_If_Created();
+ if (wres == 0 && wres2 != 0)
+ wres = wres2;
+ }
+ NumThreads = 0;
+ NeedClose = false;
+ return wres;
+}
+
+#endif
+
+
+static UInt32 CrcCalc1(const Byte *buf, size_t size)
+{
+ UInt32 crc = CRC_INIT_VAL;
+ for (size_t i = 0; i < size; i++)
+ crc = CRC_UPDATE_BYTE(crc, buf[i]);
+ return CRC_GET_DIGEST(crc);
+}
+
+/*
+static UInt32 RandGenCrc(Byte *buf, size_t size, CBaseRandomGenerator &RG)
+{
+ RandGen(buf, size, RG);
+ return CrcCalc1(buf, size);
+}
+*/
+
+static bool CrcInternalTest()
+{
+ CAlignedBuffer buffer;
+ const size_t kBufferSize0 = (1 << 8);
+ const size_t kBufferSize1 = (1 << 10);
+ const unsigned kCheckSize = (1 << 5);
+ buffer.Alloc(kBufferSize0 + kBufferSize1);
+ if (!buffer.IsAllocated())
+ return false;
+ Byte *buf = (Byte *)buffer;
+ size_t i;
+ for (i = 0; i < kBufferSize0; i++)
+ buf[i] = (Byte)i;
+ UInt32 crc1 = CrcCalc1(buf, kBufferSize0);
+ if (crc1 != 0x29058C73)
+ return false;
+ RandGen(buf + kBufferSize0, kBufferSize1);
+ for (i = 0; i < kBufferSize0 + kBufferSize1 - kCheckSize; i++)
+ for (unsigned j = 0; j < kCheckSize; j++)
+ if (CrcCalc1(buf + i, j) != CrcCalc(buf + i, j))
+ return false;
+ return true;
+}
+
+struct CBenchMethod
+{
+ unsigned Weight;
+ unsigned DictBits;
+ Int32 EncComplex;
+ Int32 DecComplexCompr;
+ Int32 DecComplexUnc;
+ const char *Name;
+ // unsigned KeySize;
+};
+
+// #define USE_SW_CMPLX
+
+#ifdef USE_SW_CMPLX
+#define CMPLX(x) ((x) * 1000)
+#else
+#define CMPLX(x) (x)
+#endif
+
+static const CBenchMethod g_Bench[] =
+{
+ // { 40, 17, 357, 145, 20, "LZMA:x1" },
+ // { 20, 18, 360, 145, 20, "LZMA2:x1:mt2" },
+
+ { 20, 18, 360, 145, 20, "LZMA:x1" },
+ { 20, 22, 600, 145, 20, "LZMA:x3" },
+
+ { 80, 24, 1220, 145, 20, "LZMA:x5:mt1" },
+ { 80, 24, 1220, 145, 20, "LZMA:x5:mt2" },
+
+ { 10, 16, 124, 40, 14, "Deflate:x1" },
+ { 20, 16, 376, 40, 14, "Deflate:x5" },
+ { 10, 16, 1082, 40, 14, "Deflate:x7" },
+ { 10, 17, 422, 40, 14, "Deflate64:x5" },
+
+ { 10, 15, 590, 69, 69, "BZip2:x1" },
+ { 20, 19, 815, 122, 122, "BZip2:x5" },
+ { 10, 19, 815, 122, 122, "BZip2:x5:mt2" },
+ { 10, 19, 2530, 122, 122, "BZip2:x7" },
+
+ // { 10, 18, 1010, 0, 1150, "PPMDZip:x1" },
+ { 10, 18, 1010, 0, 1150, "PPMD:x1" },
+ // { 10, 22, 1655, 0, 1830, "PPMDZip:x5" },
+ { 10, 22, 1655, 0, 1830, "PPMD:x5" },
+
+ // { 2, 0, -16, 0, -16, "Swap2" },
+ { 2, 0, -16, 0, -16, "Swap4" },
+
+ // { 2, 0, 3, 0, 4, "Delta:1" },
+ // { 2, 0, 3, 0, 4, "Delta:2" },
+ // { 2, 0, 3, 0, 4, "Delta:3" },
+ { 2, 0, 3, 0, 4, "Delta:4" },
+ // { 2, 0, 3, 0, 4, "Delta:8" },
+ // { 2, 0, 3, 0, 4, "Delta:32" },
+
+ { 2, 0, 2, 0, 2, "BCJ" },
+ { 2, 0, 1, 0, 1, "ARM64" },
+
+ // { 10, 0, 18, 0, 18, "AES128CBC:1" },
+ // { 10, 0, 21, 0, 21, "AES192CBC:1" },
+ { 10, 0, 24, 0, 24, "AES256CBC:1" },
+
+ // { 10, 0, 18, 0, 18, "AES128CTR:1" },
+ // { 10, 0, 21, 0, 21, "AES192CTR:1" },
+ // { 10, 0, 24, 0, 24, "AES256CTR:1" },
+ // { 2, 0, CMPLX(6), 0, CMPLX(1), "AES128CBC:2" },
+ // { 2, 0, CMPLX(7), 0, CMPLX(1), "AES192CBC:2" },
+ { 2, 0, CMPLX(8), 0, CMPLX(1), "AES256CBC:2" },
+
+ // { 2, 0, CMPLX(1), 0, CMPLX(1), "AES128CTR:2" },
+ // { 2, 0, CMPLX(1), 0, CMPLX(1), "AES192CTR:2" },
+ // { 2, 0, CMPLX(1), 0, CMPLX(1), "AES256CTR:2" },
+
+ // { 1, 0, CMPLX(6), 0, CMPLX(1), "AES128CBC:3" },
+ // { 1, 0, CMPLX(7), 0, CMPLX(1), "AES192CBC:3" },
+ { 1, 0, CMPLX(8), 0, CMPLX(1), "AES256CBC:3" }
+
+ // { 1, 0, CMPLX(1), 0, CMPLX(1), "AES128CTR:3" },
+ // { 1, 0, CMPLX(1), 0, CMPLX(1), "AES192CTR:3" },
+ // { 1, 0, CMPLX(1), 0, CMPLX(1), "AES256CTR:3" },
+};
+
+struct CBenchHash
+{
+ unsigned Weight;
+ UInt32 Complex;
+ UInt32 CheckSum;
+ const char *Name;
+};
+
+// #define ARM_CRC_MUL 100
+#define ARM_CRC_MUL 1
+
+#define k_Hash_Complex_Mult 256
+
+static const CBenchHash g_Hash[] =
+{
+ // { 1, 1820, 0x21e207bb, "CRC32:1" },
+ // { 10, 558, 0x21e207bb, "CRC32:4" },
+ { 20, 339, 0x21e207bb, "CRC32:8" } ,
+ { 2, 128 *ARM_CRC_MUL, 0x21e207bb, "CRC32:32" },
+ { 2, 64 *ARM_CRC_MUL, 0x21e207bb, "CRC32:64" },
+ { 10, 512, 0x41b901d1, "CRC64" },
+
+ { 10, 5100, 0x7913ba03, "SHA256:1" },
+ { 2, CMPLX((32 * 4 + 1) * 4 + 4), 0x7913ba03, "SHA256:2" },
+
+ { 10, 2340, 0xff769021, "SHA1:1" },
+ { 2, CMPLX((20 * 6 + 1) * 4 + 4), 0xff769021, "SHA1:2" },
+
+ { 2, 5500, 0x85189d02, "BLAKE2sp" }
+};
+
+static void PrintNumber(IBenchPrintCallback &f, UInt64 value, unsigned size)
+{
+ char s[128];
+ unsigned startPos = (unsigned)sizeof(s) - 32;
+ memset(s, ' ', startPos);
+ ConvertUInt64ToString(value, s + startPos);
+ // if (withSpace)
+ {
+ startPos--;
+ size++;
+ }
+ unsigned len = (unsigned)strlen(s + startPos);
+ if (size > len)
+ {
+ size -= len;
+ if (startPos < size)
+ startPos = 0;
+ else
+ startPos -= size;
+ }
+ f.Print(s + startPos);
+}
+
+static const unsigned kFieldSize_Name = 12;
+static const unsigned kFieldSize_SmallName = 4;
+static const unsigned kFieldSize_Speed = 9;
+static const unsigned kFieldSize_Usage = 5;
+static const unsigned kFieldSize_RU = 6;
+static const unsigned kFieldSize_Rating = 6;
+static const unsigned kFieldSize_EU = 5;
+static const unsigned kFieldSize_Effec = 5;
+static const unsigned kFieldSize_CrcSpeed = 8;
+
+
+static const unsigned kFieldSize_TotalSize = 4 + kFieldSize_Speed + kFieldSize_Usage + kFieldSize_RU + kFieldSize_Rating;
+static const unsigned kFieldSize_EUAndEffec = 2 + kFieldSize_EU + kFieldSize_Effec;
+
+
+static void PrintRating(IBenchPrintCallback &f, UInt64 rating, unsigned size)
+{
+ PrintNumber(f, (rating + 500000) / 1000000, size);
+}
+
+
+static void PrintPercents(IBenchPrintCallback &f, UInt64 val, UInt64 divider, unsigned size)
+{
+ UInt64 v = 0;
+ if (divider != 0)
+ v = (val * 100 + divider / 2) / divider;
+ PrintNumber(f, v, size);
+}
+
+static void PrintChars(IBenchPrintCallback &f, char c, unsigned size)
+{
+ char s[256];
+ memset(s, (Byte)c, size);
+ s[size] = 0;
+ f.Print(s);
+}
+
+static void PrintSpaces(IBenchPrintCallback &f, unsigned size)
+{
+ PrintChars(f, ' ', size);
+}
+
+static void PrintUsage(IBenchPrintCallback &f, UInt64 usage, unsigned size)
+{
+ PrintNumber(f, Benchmark_GetUsage_Percents(usage), size);
+}
+
+static void PrintResults(IBenchPrintCallback &f, UInt64 usage, UInt64 rpu, UInt64 rating, bool showFreq, UInt64 cpuFreq)
+{
+ PrintUsage(f, usage, kFieldSize_Usage);
+ PrintRating(f, rpu, kFieldSize_RU);
+ PrintRating(f, rating, kFieldSize_Rating);
+ if (showFreq)
+ {
+ if (cpuFreq == 0)
+ PrintSpaces(f, kFieldSize_EUAndEffec);
+ else
+ {
+ PrintPercents(f, rating, cpuFreq * usage / kBenchmarkUsageMult, kFieldSize_EU);
+ PrintPercents(f, rating, cpuFreq, kFieldSize_Effec);
+ }
+ }
+}
+
+
+void CTotalBenchRes::Generate_From_BenchInfo(const CBenchInfo &info)
+{
+ Speed = info.GetUnpackSizeSpeed();
+ Usage = info.GetUsage();
+ RPU = info.GetRatingPerUsage(Rating);
+}
+
+void CTotalBenchRes::Mult_For_Weight(unsigned weight)
+{
+ NumIterations2 *= weight;
+ RPU *= weight;
+ Rating *= weight;
+ Usage *= weight;
+ Speed *= weight;
+}
+
+void CTotalBenchRes::Update_With_Res(const CTotalBenchRes &r)
+{
+ Rating += r.Rating;
+ Usage += r.Usage;
+ RPU += r.RPU;
+ Speed += r.Speed;
+ // NumIterations1 = (r1.NumIterations1 + r2.NumIterations1);
+ NumIterations2 += r.NumIterations2;
+}
+
+static void PrintResults(IBenchPrintCallback *f,
+ const CBenchInfo &info,
+ unsigned weight,
+ UInt64 rating,
+ bool showFreq, UInt64 cpuFreq,
+ CTotalBenchRes *res)
+{
+ CTotalBenchRes t;
+ t.Rating = rating;
+ t.NumIterations2 = 1;
+ t.Generate_From_BenchInfo(info);
+
+ if (f)
+ {
+ if (t.Speed != 0)
+ PrintNumber(*f, t.Speed / 1024, kFieldSize_Speed);
+ else
+ PrintSpaces(*f, 1 + kFieldSize_Speed);
+ }
+ if (f)
+ {
+ PrintResults(*f, t.Usage, t.RPU, rating, showFreq, cpuFreq);
+ }
+
+ if (res)
+ {
+ // res->NumIterations1++;
+ t.Mult_For_Weight(weight);
+ res->Update_With_Res(t);
+ }
+}
+
+static void PrintTotals(IBenchPrintCallback &f,
+ bool showFreq, UInt64 cpuFreq, bool showSpeed, const CTotalBenchRes &res)
+{
+ const UInt64 numIterations2 = res.NumIterations2 ? res.NumIterations2 : 1;
+ const UInt64 speed = res.Speed / numIterations2;
+ if (showSpeed && speed != 0)
+ PrintNumber(f, speed / 1024, kFieldSize_Speed);
+ else
+ PrintSpaces(f, 1 + kFieldSize_Speed);
+
+ // PrintSpaces(f, 1 + kFieldSize_Speed);
+ // UInt64 numIterations1 = res.NumIterations1; if (numIterations1 == 0) numIterations1 = 1;
+ PrintResults(f, res.Usage / numIterations2, res.RPU / numIterations2, res.Rating / numIterations2, showFreq, cpuFreq);
+}
+
+
+static void PrintHex(AString &s, UInt64 v)
+{
+ char temp[32];
+ ConvertUInt64ToHex(v, temp);
+ s += temp;
+}
+
+AString GetProcessThreadsInfo(const NSystem::CProcessAffinity &ti)
+{
+ AString s;
+ // s.Add_UInt32(ti.numProcessThreads);
+ unsigned numSysThreads = ti.GetNumSystemThreads();
+ if (ti.GetNumProcessThreads() != numSysThreads)
+ {
+ // if (ti.numProcessThreads != ti.numSysThreads)
+ {
+ s += " / ";
+ s.Add_UInt32(numSysThreads);
+ }
+ s += " : ";
+ #ifdef _WIN32
+ PrintHex(s, ti.processAffinityMask);
+ s += " / ";
+ PrintHex(s, ti.systemAffinityMask);
+ #else
+ unsigned i = (numSysThreads + 3) & ~(unsigned)3;
+ if (i == 0)
+ i = 4;
+ for (; i >= 4; )
+ {
+ i -= 4;
+ unsigned val = 0;
+ for (unsigned k = 0; k < 4; k++)
+ {
+ const unsigned bit = (ti.IsCpuSet(i + k) ? 1 : 0);
+ val += (bit << k);
+ }
+ PrintHex(s, val);
+ }
+ #endif
+ }
+ return s;
+}
+
+
+#ifdef Z7_LARGE_PAGES
+
+#ifdef _WIN32
+extern bool g_LargePagesMode;
+extern "C"
+{
+ extern SIZE_T g_LargePageSize;
+}
+#endif
+
+void Add_LargePages_String(AString &s)
+{
+ #ifdef _WIN32
+ if (g_LargePagesMode || g_LargePageSize != 0)
+ {
+ s.Add_OptSpaced("(LP-");
+ PrintSize_KMGT_Or_Hex(s, g_LargePageSize);
+ #ifdef MY_CPU_X86_OR_AMD64
+ if (CPU_IsSupported_PageGB())
+ s += "-1G";
+ #endif
+ if (!g_LargePagesMode)
+ s += "-NA";
+ s += ")";
+ }
+ #else
+ s += "";
+ #endif
+}
+
+#endif
+
+
+
+static void PrintRequirements(IBenchPrintCallback &f, const char *sizeString,
+ bool size_Defined, UInt64 size, const char *threadsString, UInt32 numThreads)
+{
+ f.Print("RAM ");
+ f.Print(sizeString);
+ if (size_Defined)
+ PrintNumber(f, (size >> 20), 6);
+ else
+ f.Print(" ?");
+ f.Print(" MB");
+
+ #ifdef Z7_LARGE_PAGES
+ {
+ AString s;
+ Add_LargePages_String(s);
+ f.Print(s);
+ }
+ #endif
+
+ f.Print(", # ");
+ f.Print(threadsString);
+ PrintNumber(f, numThreads, 3);
+}
+
+
+
+struct CBenchCallbackToPrint Z7_final: public IBenchCallback
+{
+ bool NeedPrint;
+ bool Use2Columns;
+ bool ShowFreq;
+ unsigned NameFieldSize;
+
+ unsigned EncodeWeight;
+ unsigned DecodeWeight;
+
+ UInt64 CpuFreq;
+ UInt64 DictSize;
+
+ IBenchPrintCallback *_file;
+ CBenchProps BenchProps;
+ CTotalBenchRes EncodeRes;
+ CTotalBenchRes DecodeRes;
+
+ CBenchInfo BenchInfo_Results[2];
+
+ CBenchCallbackToPrint():
+ NeedPrint(true),
+ Use2Columns(false),
+ ShowFreq(false),
+ NameFieldSize(0),
+ EncodeWeight(1),
+ DecodeWeight(1),
+ CpuFreq(0)
+ {}
+
+ void Init() { EncodeRes.Init(); DecodeRes.Init(); }
+ void Print(const char *s);
+ void NewLine();
+
+ HRESULT SetFreq(bool showFreq, UInt64 cpuFreq);
+ HRESULT SetEncodeResult(const CBenchInfo &info, bool final) Z7_override;
+ HRESULT SetDecodeResult(const CBenchInfo &info, bool final) Z7_override;
+};
+
+HRESULT CBenchCallbackToPrint::SetFreq(bool showFreq, UInt64 cpuFreq)
+{
+ ShowFreq = showFreq;
+ CpuFreq = cpuFreq;
+ return S_OK;
+}
+
+HRESULT CBenchCallbackToPrint::SetEncodeResult(const CBenchInfo &info, bool final)
+{
+ RINOK(_file->CheckBreak())
+ if (final)
+ BenchInfo_Results[0] = info;
+ if (final)
+ if (NeedPrint)
+ {
+ const UInt64 rating = BenchProps.GetRating_Enc(DictSize, info.GlobalTime, info.GlobalFreq, info.UnpackSize * info.NumIterations);
+ PrintResults(_file, info,
+ EncodeWeight, rating,
+ ShowFreq, CpuFreq, &EncodeRes);
+ if (!Use2Columns)
+ _file->NewLine();
+ }
+ return S_OK;
+}
+
+static const char * const kSep = " | ";
+
+HRESULT CBenchCallbackToPrint::SetDecodeResult(const CBenchInfo &info, bool final)
+{
+ RINOK(_file->CheckBreak())
+ if (final)
+ BenchInfo_Results[1] = info;
+ if (final)
+ if (NeedPrint)
+ {
+ const UInt64 rating = BenchProps.GetRating_Dec(info.GlobalTime, info.GlobalFreq, info.UnpackSize, info.PackSize, info.NumIterations);
+ if (Use2Columns)
+ _file->Print(kSep);
+ else
+ PrintSpaces(*_file, NameFieldSize);
+ CBenchInfo info2 = info;
+ info2.UnpackSize *= info2.NumIterations;
+ info2.PackSize *= info2.NumIterations;
+ info2.NumIterations = 1;
+ PrintResults(_file, info2,
+ DecodeWeight, rating,
+ ShowFreq, CpuFreq, &DecodeRes);
+ }
+ return S_OK;
+}
+
+void CBenchCallbackToPrint::Print(const char *s)
+{
+ _file->Print(s);
+}
+
+void CBenchCallbackToPrint::NewLine()
+{
+ _file->NewLine();
+}
+
+static void PrintLeft(IBenchPrintCallback &f, const char *s, unsigned size)
+{
+ f.Print(s);
+ int numSpaces = (int)size - (int)MyStringLen(s);
+ if (numSpaces > 0)
+ PrintSpaces(f, (unsigned)numSpaces);
+}
+
+static void PrintRight(IBenchPrintCallback &f, const char *s, unsigned size)
+{
+ int numSpaces = (int)size - (int)MyStringLen(s);
+ if (numSpaces > 0)
+ PrintSpaces(f, (unsigned)numSpaces);
+ f.Print(s);
+}
+
+
+static bool DoesWildcardMatchName_NoCase(const AString &mask, const char *name)
+{
+ UString wildc = GetUnicodeString(mask);
+ UString bname = GetUnicodeString(name);
+ wildc.MakeLower_Ascii();
+ bname.MakeLower_Ascii();
+ return DoesWildcardMatchName(wildc, bname);
+}
+
+
+static HRESULT TotalBench(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const COneMethodInfo &methodMask,
+ UInt64 complexInCommands,
+ #ifndef Z7_ST
+ UInt32 numThreads,
+ const CAffinityMode *affinityMode,
+ #endif
+ bool forceUnpackSize,
+ size_t unpackSize,
+ const Byte *fileData,
+ IBenchPrintCallback *printCallback, CBenchCallbackToPrint *callback)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Bench); i++)
+ {
+ const CBenchMethod &bench = g_Bench[i];
+ if (!DoesWildcardMatchName_NoCase(methodMask.MethodName, bench.Name))
+ continue;
+ PrintLeft(*callback->_file, bench.Name, kFieldSize_Name);
+ {
+ unsigned keySize = 32;
+ if (IsString1PrefixedByString2(bench.Name, "AES128")) keySize = 16;
+ else if (IsString1PrefixedByString2(bench.Name, "AES192")) keySize = 24;
+ callback->BenchProps.KeySize = keySize;
+ }
+ callback->BenchProps.DecComplexUnc = bench.DecComplexUnc;
+ callback->BenchProps.DecComplexCompr = bench.DecComplexCompr;
+ callback->BenchProps.EncComplex = bench.EncComplex;
+
+ COneMethodInfo method;
+ NCOM::CPropVariant propVariant;
+ propVariant = bench.Name;
+ RINOK(method.ParseMethodFromPROPVARIANT(UString(), propVariant))
+
+ size_t unpackSize2 = unpackSize;
+ if (!forceUnpackSize && bench.DictBits == 0)
+ unpackSize2 = kFilterUnpackSize;
+
+ callback->EncodeWeight = bench.Weight;
+ callback->DecodeWeight = bench.Weight;
+
+ const HRESULT res = MethodBench(
+ EXTERNAL_CODECS_LOC_VARS
+ complexInCommands,
+ #ifndef Z7_ST
+ false, numThreads, affinityMode,
+ #endif
+ method,
+ unpackSize2, fileData,
+ bench.DictBits,
+ printCallback, callback, &callback->BenchProps);
+
+ if (res == E_NOTIMPL)
+ {
+ // callback->Print(" ---");
+ // we need additional empty line as line for decompression results
+ if (!callback->Use2Columns)
+ callback->NewLine();
+ }
+ else
+ {
+ RINOK(res)
+ }
+
+ callback->NewLine();
+ }
+ return S_OK;
+}
+
+
+struct CFreqBench
+{
+ // in:
+ UInt64 complexInCommands;
+ UInt32 numThreads;
+ bool showFreq;
+ UInt64 specifiedFreq;
+
+ // out:
+ UInt64 CpuFreqRes;
+ UInt64 UsageRes;
+ UInt32 res;
+
+ CFreqBench()
+ {}
+
+ HRESULT FreqBench(IBenchPrintCallback *_file
+ #ifndef Z7_ST
+ , const CAffinityMode *affinityMode
+ #endif
+ );
+};
+
+
+HRESULT CFreqBench::FreqBench(IBenchPrintCallback *_file
+ #ifndef Z7_ST
+ , const CAffinityMode *affinityMode
+ #endif
+ )
+{
+ res = 0;
+ CpuFreqRes = 0;
+ UsageRes = 0;
+
+ if (numThreads == 0)
+ numThreads = 1;
+
+ #ifdef Z7_ST
+ numThreads = 1;
+ #endif
+
+ const UInt32 complexity = kNumFreqCommands;
+ UInt64 numIterations = complexInCommands / complexity;
+ UInt32 numIterations2 = 1 << 30;
+ if (numIterations > numIterations2)
+ numIterations /= numIterations2;
+ else
+ {
+ numIterations2 = (UInt32)numIterations;
+ numIterations = 1;
+ }
+
+ CBenchInfoCalc progressInfoSpec;
+
+ #ifndef Z7_ST
+
+ bool mtMode = (numThreads > 1) || affinityMode->NeedAffinity();
+
+ if (mtMode)
+ {
+ CFreqThreads threads;
+ threads.Items = new CFreqInfo[numThreads];
+ UInt32 i;
+ for (i = 0; i < numThreads; i++)
+ {
+ CFreqInfo &info = threads.Items[i];
+ info.Callback = _file;
+ info.CallbackRes = S_OK;
+ info.NumIterations = numIterations;
+ info.Size = numIterations2;
+ }
+ progressInfoSpec.SetStartTime();
+ for (i = 0; i < numThreads; i++)
+ {
+ // Sleep(10);
+ CFreqInfo &info = threads.Items[i];
+ WRes wres = affinityMode->CreateThread_WithAffinity(info.Thread, FreqThreadFunction, &info, i);
+ if (info.Thread.IsCreated())
+ threads.NumThreads++;
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ }
+ WRes wres = threads.WaitAll();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ for (i = 0; i < numThreads; i++)
+ {
+ RINOK(threads.Items[i].CallbackRes)
+ }
+ }
+ else
+ #endif
+ {
+ progressInfoSpec.SetStartTime();
+ UInt32 sum = g_BenchCpuFreqTemp;
+ for (UInt64 k = numIterations; k > 0; k--)
+ {
+ sum = CountCpuFreq(sum, numIterations2, g_BenchCpuFreqTemp);
+ if (_file)
+ {
+ RINOK(_file->CheckBreak())
+ }
+ }
+ res += sum;
+ }
+
+ if (res == 0x12345678)
+ if (_file)
+ {
+ RINOK(_file->CheckBreak())
+ }
+
+ CBenchInfo info;
+ progressInfoSpec.SetFinishTime(info);
+
+ info.UnpackSize = 0;
+ info.PackSize = 0;
+ info.NumIterations = 1;
+
+ const UInt64 numCommands = (UInt64)numIterations * numIterations2 * numThreads * complexity;
+ const UInt64 rating = info.GetSpeed(numCommands);
+ CpuFreqRes = rating / numThreads;
+ UsageRes = info.GetUsage();
+
+ if (_file)
+ {
+ PrintResults(_file, info,
+ 0, // weight
+ rating,
+ showFreq, showFreq ? (specifiedFreq != 0 ? specifiedFreq : CpuFreqRes) : 0, NULL);
+ RINOK(_file->CheckBreak())
+ }
+
+ return S_OK;
+}
+
+
+
+static HRESULT CrcBench(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ UInt64 complexInCommands,
+ UInt32 numThreads,
+ const size_t bufferSize,
+ const Byte *fileData,
+
+ UInt64 &speed,
+ UInt64 &usage,
+
+ UInt32 complexity, unsigned benchWeight,
+ const UInt32 *checkSum,
+ const COneMethodInfo &method,
+ IBenchPrintCallback *_file,
+ #ifndef Z7_ST
+ const CAffinityMode *affinityMode,
+ #endif
+ bool showRating,
+ CTotalBenchRes *encodeRes,
+ bool showFreq, UInt64 cpuFreq)
+{
+ if (numThreads == 0)
+ numThreads = 1;
+
+ #ifdef Z7_ST
+ numThreads = 1;
+ #endif
+
+ const AString &methodName = method.MethodName;
+ // methodName.RemoveChar(L'-');
+ CMethodId hashID;
+ if (!FindHashMethod(
+ EXTERNAL_CODECS_LOC_VARS
+ methodName, hashID))
+ return E_NOTIMPL;
+
+ /*
+ // if will generate random data in each thread, instead of global data
+ CMidAlignedBuffer buffer;
+ if (!fileData)
+ {
+ ALLOC_WITH_HRESULT(&buffer, bufferSize)
+ RandGen(buffer, bufferSize);
+ fileData = buffer;
+ }
+ */
+
+ const size_t bsize = (bufferSize == 0 ? 1 : bufferSize);
+ UInt64 numIterations = complexInCommands * k_Hash_Complex_Mult / complexity / bsize;
+ if (numIterations == 0)
+ numIterations = 1;
+
+ CBenchInfoCalc progressInfoSpec;
+ CBenchInfo info;
+
+ #ifndef Z7_ST
+ bool mtEncMode = (numThreads > 1) || affinityMode->NeedAffinity();
+
+ if (mtEncMode)
+ {
+ CCrcThreads threads;
+ threads.Items = new CCrcInfo[numThreads];
+ {
+ WRes wres = threads.Common.StartEvent.Create();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ threads.NeedClose = true;
+ }
+
+ UInt32 i;
+ for (i = 0; i < numThreads; i++)
+ {
+ CCrcInfo &ci = threads.Items[i];
+ AString name;
+ RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS hashID, name, ci.Hasher))
+ if (!ci.Hasher)
+ return E_NOTIMPL;
+ CMyComPtr<ICompressSetCoderProperties> scp;
+ ci.Hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
+ if (scp)
+ {
+ RINOK(method.SetCoderProps(scp))
+ }
+
+ ci.Callback = _file;
+ ci.Data = fileData;
+ ci.NumIterations = numIterations;
+ ci.Size = bufferSize;
+ ci.CheckSumDefined = false;
+ if (checkSum)
+ {
+ ci.CheckSum = *checkSum;
+ ci.CheckSumDefined = true;
+ }
+
+ #ifdef USE_ALLOCA
+ ci.AllocaSize = (i * 16 * 21) & 0x7FF;
+ #endif
+ }
+
+ for (i = 0; i < numThreads; i++)
+ {
+ CCrcInfo &ci = threads.Items[i];
+ ci.ThreadIndex = i;
+ ci.Common = &threads.Common;
+ ci.AffinityMode = *affinityMode;
+ HRESULT hres = ci.CreateThread();
+ if (ci.Thread.IsCreated())
+ threads.NumThreads++;
+ if (hres != 0)
+ return hres;
+ }
+
+ for (i = 0; i < numThreads; i++)
+ {
+ CCrcInfo &ci = threads.Items[i];
+ WRes wres = ci.ReadyEvent.Lock();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ RINOK(ci.Res)
+ }
+
+ progressInfoSpec.SetStartTime();
+
+ WRes wres = threads.StartAndWait();
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+
+ progressInfoSpec.SetFinishTime(info);
+
+ for (i = 0; i < numThreads; i++)
+ {
+ RINOK(threads.Items[i].Res)
+ if (i != 0)
+ if (threads.Items[i].CheckSum_Res !=
+ threads.Items[i - 1].CheckSum_Res)
+ return S_FALSE;
+ }
+ }
+ else
+ #endif
+ {
+ CMyComPtr<IHasher> hasher;
+ AString name;
+ RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS hashID, name, hasher))
+ if (!hasher)
+ return E_NOTIMPL;
+ CMyComPtr<ICompressSetCoderProperties> scp;
+ hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
+ if (scp)
+ {
+ RINOK(method.SetCoderProps(scp))
+ }
+ CCrcInfo_Base crcib;
+ crcib.CreateLocalBuf = false;
+ RINOK(crcib.Generate(fileData, bufferSize))
+ progressInfoSpec.SetStartTime();
+ RINOK(crcib.CrcProcess(numIterations, checkSum, hasher, _file))
+ progressInfoSpec.SetFinishTime(info);
+ }
+
+
+ UInt64 unpSize = numIterations * bufferSize;
+ UInt64 unpSizeThreads = unpSize * numThreads;
+ info.UnpackSize = unpSizeThreads;
+ info.PackSize = unpSizeThreads;
+ info.NumIterations = 1;
+
+ if (_file)
+ {
+ if (showRating)
+ {
+ UInt64 unpSizeThreads2 = unpSizeThreads;
+ if (unpSizeThreads2 == 0)
+ unpSizeThreads2 = numIterations * 1 * numThreads;
+ const UInt64 numCommands = unpSizeThreads2 * complexity / 256;
+ const UInt64 rating = info.GetSpeed(numCommands);
+ PrintResults(_file, info,
+ benchWeight, rating,
+ showFreq, cpuFreq, encodeRes);
+ }
+ RINOK(_file->CheckBreak())
+ }
+
+ speed = info.GetSpeed(unpSizeThreads);
+ usage = info.GetUsage();
+
+ return S_OK;
+}
+
+
+
+static HRESULT TotalBench_Hash(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const COneMethodInfo &methodMask,
+ UInt64 complexInCommands,
+ UInt32 numThreads,
+ size_t bufSize,
+ const Byte *fileData,
+ IBenchPrintCallback *printCallback, CBenchCallbackToPrint *callback,
+ #ifndef Z7_ST
+ const CAffinityMode *affinityMode,
+ #endif
+ CTotalBenchRes *encodeRes,
+ bool showFreq, UInt64 cpuFreq)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Hash); i++)
+ {
+ const CBenchHash &bench = g_Hash[i];
+ if (!DoesWildcardMatchName_NoCase(methodMask.MethodName, bench.Name))
+ continue;
+ PrintLeft(*callback->_file, bench.Name, kFieldSize_Name);
+ // callback->BenchProps.DecComplexUnc = bench.DecComplexUnc;
+ // callback->BenchProps.DecComplexCompr = bench.DecComplexCompr;
+ // callback->BenchProps.EncComplex = bench.EncComplex;
+
+ COneMethodInfo method;
+ NCOM::CPropVariant propVariant;
+ propVariant = bench.Name;
+ RINOK(method.ParseMethodFromPROPVARIANT(UString(), propVariant))
+
+ UInt64 speed, usage;
+
+ const HRESULT res = CrcBench(
+ EXTERNAL_CODECS_LOC_VARS
+ complexInCommands,
+ numThreads, bufSize, fileData,
+ speed, usage,
+ bench.Complex, bench.Weight,
+ (!fileData && bufSize == (1 << kNumHashDictBits)) ? &bench.CheckSum : NULL,
+ method,
+ printCallback,
+ #ifndef Z7_ST
+ affinityMode,
+ #endif
+ true, // showRating
+ encodeRes, showFreq, cpuFreq);
+ if (res == E_NOTIMPL)
+ {
+ // callback->Print(" ---");
+ }
+ else
+ {
+ RINOK(res)
+ }
+ callback->NewLine();
+ }
+ return S_OK;
+}
+
+struct CTempValues
+{
+ UInt64 *Values;
+ CTempValues(): Values(NULL) {}
+ void Alloc(UInt32 num) { Values = new UInt64[num]; }
+ ~CTempValues() { delete []Values; }
+};
+
+static void ParseNumberString(const UString &s, NCOM::CPropVariant &prop)
+{
+ const wchar_t *end;
+ UInt64 result = ConvertStringToUInt64(s, &end);
+ if (*end != 0 || s.IsEmpty())
+ prop = s;
+ else if (result <= (UInt32)0xFFFFFFFF)
+ prop = (UInt32)result;
+ else
+ prop = result;
+}
+
+
+static bool AreSameMethodNames(const char *fullName, const char *shortName)
+{
+ return StringsAreEqualNoCase_Ascii(fullName, shortName);
+}
+
+
+
+
+static void Print_Usage_and_Threads(IBenchPrintCallback &f, UInt64 usage, UInt32 threads)
+{
+ PrintRequirements(f, "usage:", true, usage, "Benchmark threads: ", threads);
+}
+
+
+static void Print_Delimiter(IBenchPrintCallback &f)
+{
+ f.Print(" |");
+}
+
+static void Print_Pow(IBenchPrintCallback &f, unsigned pow)
+{
+ char s[16];
+ ConvertUInt32ToString(pow, s);
+ unsigned pos = MyStringLen(s);
+ s[pos++] = ':';
+ s[pos] = 0;
+ PrintLeft(f, s, kFieldSize_SmallName); // 4
+}
+
+static void Bench_BW_Print_Usage_Speed(IBenchPrintCallback &f,
+ UInt64 usage, UInt64 speed)
+{
+ PrintUsage(f, usage, kFieldSize_Usage);
+ PrintNumber(f, speed / 1000000, kFieldSize_CrcSpeed);
+}
+
+
+HRESULT Bench(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ IBenchPrintCallback *printCallback,
+ IBenchCallback *benchCallback,
+ const CObjectVector<CProperty> &props,
+ UInt32 numIterations,
+ bool multiDict,
+ IBenchFreqCallback *freqCallback)
+{
+ if (!CrcInternalTest())
+ return E_FAIL;
+
+ UInt32 numCPUs = 1;
+ UInt64 ramSize = (UInt64)(sizeof(size_t)) << 29;
+
+ NSystem::CProcessAffinity threadsInfo;
+ threadsInfo.InitST();
+
+ #ifndef Z7_ST
+
+ if (threadsInfo.Get() && threadsInfo.GetNumProcessThreads() != 0)
+ numCPUs = threadsInfo.GetNumProcessThreads();
+ else
+ numCPUs = NSystem::GetNumberOfProcessors();
+
+ #endif
+
+ // numCPUs = 24;
+ /*
+ {
+ DWORD_PTR mask = (1 << 0);
+ DWORD_PTR old = SetThreadAffinityMask(GetCurrentThread(), mask);
+ old = old;
+ DWORD_PTR old2 = SetThreadAffinityMask(GetCurrentThread(), mask);
+ old2 = old2;
+ return 0;
+ }
+ */
+
+ bool ramSize_Defined = NSystem::GetRamSize(ramSize);
+
+ UInt32 numThreadsSpecified = numCPUs;
+ bool needSetComplexity = false;
+ UInt32 testTimeMs = kComplexInMs;
+ UInt32 startDicLog = 22;
+ bool startDicLog_Defined = false;
+ UInt64 specifiedFreq = 0;
+ bool multiThreadTests = false;
+ UInt64 complexInCommands = kComplexInCommands;
+ UInt32 numThreads_Start = 1;
+
+ #ifndef Z7_ST
+ CAffinityMode affinityMode;
+ #endif
+
+
+ COneMethodInfo method;
+
+ CMidAlignedBuffer fileDataBuffer;
+ bool use_fileData = false;
+ bool isFixedDict = false;
+
+ {
+ unsigned i;
+
+ if (printCallback)
+ {
+ for (i = 0; i < props.Size(); i++)
+ {
+ const CProperty &property = props[i];
+ printCallback->Print(" ");
+ printCallback->Print(GetAnsiString(property.Name));
+ if (!property.Value.IsEmpty())
+ {
+ printCallback->Print("=");
+ printCallback->Print(GetAnsiString(property.Value));
+ }
+ }
+ if (!props.IsEmpty())
+ printCallback->NewLine();
+ }
+
+
+ for (i = 0; i < props.Size(); i++)
+ {
+ const CProperty &property = props[i];
+ UString name (property.Name);
+ name.MakeLower_Ascii();
+
+ if (name.IsEqualTo("file"))
+ {
+ if (property.Value.IsEmpty())
+ return E_INVALIDARG;
+
+ NFile::NIO::CInFile file;
+ if (!file.Open(us2fs(property.Value)))
+ return GetLastError_noZero_HRESULT();
+ size_t len;
+ {
+ UInt64 len64;
+ if (!file.GetLength(len64))
+ return GetLastError_noZero_HRESULT();
+ if (printCallback)
+ {
+ printCallback->Print("file size =");
+ PrintNumber(*printCallback, len64, 0);
+ printCallback->NewLine();
+ }
+ len = (size_t)len64;
+ if (len != len64)
+ return E_INVALIDARG;
+ }
+
+ // (len == 0) is allowed. Also it's allowed if Alloc(0) returns NULL here
+
+ ALLOC_WITH_HRESULT(&fileDataBuffer, len)
+ use_fileData = true;
+
+ {
+ size_t processed;
+ if (!file.ReadFull((Byte *)fileDataBuffer, len, processed))
+ return GetLastError_noZero_HRESULT();
+ if (processed != len)
+ return E_FAIL;
+ }
+ continue;
+ }
+
+ NCOM::CPropVariant propVariant;
+ if (!property.Value.IsEmpty())
+ ParseNumberString(property.Value, propVariant);
+
+ if (name.IsEqualTo("time"))
+ {
+ RINOK(ParsePropToUInt32(UString(), propVariant, testTimeMs))
+ needSetComplexity = true;
+ testTimeMs *= 1000;
+ continue;
+ }
+
+ if (name.IsEqualTo("timems"))
+ {
+ RINOK(ParsePropToUInt32(UString(), propVariant, testTimeMs))
+ needSetComplexity = true;
+ continue;
+ }
+
+ if (name.IsEqualTo("tic"))
+ {
+ UInt32 v;
+ RINOK(ParsePropToUInt32(UString(), propVariant, v))
+ if (v >= 64)
+ return E_INVALIDARG;
+ complexInCommands = (UInt64)1 << v;
+ continue;
+ }
+
+ const bool isCurrent_fixedDict = name.IsEqualTo("df");
+ if (isCurrent_fixedDict)
+ isFixedDict = true;
+ if (isCurrent_fixedDict || name.IsEqualTo("ds"))
+ {
+ RINOK(ParsePropToUInt32(UString(), propVariant, startDicLog))
+ if (startDicLog > 32)
+ return E_INVALIDARG;
+ startDicLog_Defined = true;
+ continue;
+ }
+
+ if (name.IsEqualTo("mts"))
+ {
+ RINOK(ParsePropToUInt32(UString(), propVariant, numThreads_Start))
+ continue;
+ }
+
+ if (name.IsEqualTo("af"))
+ {
+ UInt32 bundle;
+ RINOK(ParsePropToUInt32(UString(), propVariant, bundle))
+ if (bundle > 0 && bundle < numCPUs)
+ {
+ #ifndef Z7_ST
+ affinityMode.SetLevels(numCPUs, 2);
+ affinityMode.NumBundleThreads = bundle;
+ #endif
+ }
+ continue;
+ }
+
+ if (name.IsEqualTo("freq"))
+ {
+ UInt32 freq32 = 0;
+ RINOK(ParsePropToUInt32(UString(), propVariant, freq32))
+ if (freq32 == 0)
+ return E_INVALIDARG;
+ specifiedFreq = (UInt64)freq32 * 1000000;
+
+ if (printCallback)
+ {
+ printCallback->Print("freq=");
+ PrintNumber(*printCallback, freq32, 0);
+ printCallback->NewLine();
+ }
+
+ continue;
+ }
+
+ if (name.IsPrefixedBy_Ascii_NoCase("mt"))
+ {
+ const UString s = name.Ptr(2);
+ if (s.IsEqualTo("*")
+ || (s.IsEmpty()
+ && propVariant.vt == VT_BSTR
+ && StringsAreEqual_Ascii(propVariant.bstrVal, "*")))
+ {
+ multiThreadTests = true;
+ continue;
+ }
+ #ifndef Z7_ST
+ RINOK(ParseMtProp(s, propVariant, numCPUs, numThreadsSpecified))
+ #endif
+ continue;
+ }
+
+ RINOK(method.ParseMethodFromPROPVARIANT(name, propVariant))
+ }
+ }
+
+ if (printCallback)
+ {
+ AString s;
+
+ #ifndef _WIN32
+ s += "Compiler: ";
+ GetCompiler(s);
+ printCallback->Print(s);
+ printCallback->NewLine();
+ s.Empty();
+ #endif
+
+ GetSystemInfoText(s);
+ printCallback->Print(s);
+ printCallback->NewLine();
+ }
+
+ if (printCallback)
+ {
+ printCallback->Print("1T CPU Freq (MHz):");
+ }
+
+ if (printCallback || freqCallback)
+ {
+ UInt64 numMilCommands = 1 << 6;
+ if (specifiedFreq != 0)
+ {
+ while (numMilCommands > 1 && specifiedFreq < (numMilCommands * 1000000))
+ numMilCommands >>= 1;
+ }
+
+ for (int jj = 0;; jj++)
+ {
+ if (printCallback)
+ RINOK(printCallback->CheckBreak())
+
+ UInt64 start = ::GetTimeCount();
+ UInt32 sum = (UInt32)start;
+ sum = CountCpuFreq(sum, (UInt32)(numMilCommands * 1000000 / kNumFreqCommands), g_BenchCpuFreqTemp);
+ if (sum == 0xF1541213)
+ if (printCallback)
+ printCallback->Print("");
+ const UInt64 realDelta = ::GetTimeCount() - start;
+ start = realDelta;
+ if (start == 0)
+ start = 1;
+ if (start > (UInt64)1 << 61)
+ start = 1;
+ const UInt64 freq = GetFreq();
+ // mips is constant in some compilers
+ const UInt64 hz = MyMultDiv64(numMilCommands * 1000000, freq, start);
+ const UInt64 mipsVal = numMilCommands * freq / start;
+ if (printCallback)
+ {
+ if (realDelta == 0)
+ {
+ printCallback->Print(" -");
+ }
+ else
+ {
+ // PrintNumber(*printCallback, start, 0);
+ PrintNumber(*printCallback, mipsVal, 5);
+ }
+ }
+ if (freqCallback)
+ {
+ RINOK(freqCallback->AddCpuFreq(1, hz, kBenchmarkUsageMult))
+ }
+
+ if (jj >= 1)
+ {
+ bool needStop = (numMilCommands >= (1 <<
+ #ifdef _DEBUG
+ 7
+ #else
+ 11
+ #endif
+ ));
+ if (start >= freq * 16)
+ {
+ printCallback->Print(" (Cmplx)");
+ if (!freqCallback) // we don't want complexity change for old gui lzma benchmark
+ {
+ needSetComplexity = true;
+ }
+ needStop = true;
+ }
+ if (needSetComplexity)
+ SetComplexCommandsMs(testTimeMs, false, mipsVal * 1000000, complexInCommands);
+ if (needStop)
+ break;
+ numMilCommands <<= 1;
+ }
+ }
+ if (freqCallback)
+ {
+ RINOK(freqCallback->FreqsFinished(1))
+ }
+ }
+
+ if (numThreadsSpecified >= 2)
+ if (printCallback || freqCallback)
+ {
+ if (printCallback)
+ printCallback->NewLine();
+
+ /* it can show incorrect frequency for HT threads.
+ so we reduce freq test to (numCPUs / 2) */
+
+ UInt32 numThreads = numThreadsSpecified >= numCPUs / 2 ? numCPUs / 2: numThreadsSpecified;
+ if (numThreads < 1)
+ numThreads = 1;
+
+ if (printCallback)
+ {
+ char s[128];
+ ConvertUInt64ToString(numThreads, s);
+ printCallback->Print(s);
+ printCallback->Print("T CPU Freq (MHz):");
+ }
+ UInt64 numMilCommands = 1 <<
+ #ifdef _DEBUG
+ 7;
+ #else
+ 10;
+ #endif
+
+ if (specifiedFreq != 0)
+ {
+ while (numMilCommands > 1 && specifiedFreq < (numMilCommands * 1000000))
+ numMilCommands >>= 1;
+ }
+
+ // for (int jj = 0;; jj++)
+ for (;;)
+ {
+ if (printCallback)
+ RINOK(printCallback->CheckBreak())
+
+ {
+ // PrintLeft(f, "CPU", kFieldSize_Name);
+
+ // UInt32 resVal;
+
+ CFreqBench fb;
+ fb.complexInCommands = numMilCommands * 1000000;
+ fb.numThreads = numThreads;
+ // showFreq;
+ // fb.showFreq = (freqTest == kNumCpuTests - 1 || specifiedFreq != 0);
+ fb.showFreq = true;
+ fb.specifiedFreq = 1;
+
+ const HRESULT res = fb.FreqBench(NULL /* printCallback */
+ #ifndef Z7_ST
+ , &affinityMode
+ #endif
+ );
+ RINOK(res)
+
+ if (freqCallback)
+ {
+ RINOK(freqCallback->AddCpuFreq(numThreads, fb.CpuFreqRes, fb.UsageRes))
+ }
+
+ if (printCallback)
+ {
+ /*
+ if (realDelta == 0)
+ {
+ printCallback->Print(" -");
+ }
+ else
+ */
+ {
+ // PrintNumber(*printCallback, start, 0);
+ PrintUsage(*printCallback, fb.UsageRes, 3);
+ printCallback->Print("%");
+ PrintNumber(*printCallback, fb.CpuFreqRes / 1000000, 0);
+ printCallback->Print(" ");
+
+ // PrintNumber(*printCallback, fb.UsageRes, 5);
+ }
+ }
+ }
+ // if (jj >= 1)
+ {
+ const bool needStop = (numMilCommands >= (1 <<
+ #ifdef _DEBUG
+ 7
+ #else
+ 11
+ #endif
+ ));
+ if (needStop)
+ break;
+ numMilCommands <<= 1;
+ }
+ }
+ if (freqCallback)
+ {
+ RINOK(freqCallback->FreqsFinished(numThreads))
+ }
+ }
+
+
+ if (printCallback)
+ {
+ printCallback->NewLine();
+ printCallback->NewLine();
+ PrintRequirements(*printCallback, "size: ", ramSize_Defined, ramSize, "CPU hardware threads:", numCPUs);
+ printCallback->Print(GetProcessThreadsInfo(threadsInfo));
+ printCallback->NewLine();
+ }
+
+ if (numThreadsSpecified < 1 || numThreadsSpecified > kNumThreadsMax)
+ return E_INVALIDARG;
+
+ UInt64 dict = (UInt64)1 << startDicLog;
+ const bool dictIsDefined = (isFixedDict || method.Get_DicSize(dict));
+
+ const unsigned level = method.GetLevel();
+
+ AString &methodName = method.MethodName;
+ const AString original_MethodName = methodName;
+ if (methodName.IsEmpty())
+ methodName = "LZMA";
+
+ if (benchCallback)
+ {
+ CBenchProps benchProps;
+ benchProps.SetLzmaCompexity();
+ const UInt64 dictSize = method.Get_Lzma_DicSize();
+
+ size_t uncompressedDataSize;
+ if (use_fileData)
+ {
+ uncompressedDataSize = fileDataBuffer.Size();
+ }
+ else
+ {
+ uncompressedDataSize = kAdditionalSize + (size_t)dictSize;
+ if (uncompressedDataSize < dictSize)
+ return E_INVALIDARG;
+ }
+
+ return MethodBench(
+ EXTERNAL_CODECS_LOC_VARS
+ complexInCommands,
+ #ifndef Z7_ST
+ true, numThreadsSpecified,
+ &affinityMode,
+ #endif
+ method,
+ uncompressedDataSize, (const Byte *)fileDataBuffer,
+ kOldLzmaDictBits, printCallback, benchCallback, &benchProps);
+ }
+
+ if (methodName.IsEqualTo_Ascii_NoCase("CRC"))
+ methodName = "crc32";
+
+ CMethodId hashID;
+ const bool isHashMethod = FindHashMethod(EXTERNAL_CODECS_LOC_VARS methodName, hashID);
+ int codecIndex = -1;
+ bool isFilter = false;
+ if (!isHashMethod)
+ {
+ UInt32 numStreams;
+ codecIndex = FindMethod_Index(EXTERNAL_CODECS_LOC_VARS original_MethodName,
+ true, // encode
+ hashID, numStreams, isFilter);
+ // we can allow non filter for BW tests
+ if (!isFilter) codecIndex = -1;
+ }
+
+ CBenchCallbackToPrint callback;
+ callback.Init();
+ callback._file = printCallback;
+
+ if (isHashMethod || codecIndex != -1)
+ {
+ if (!printCallback)
+ return S_FALSE;
+ IBenchPrintCallback &f = *printCallback;
+
+ UInt64 dict64 = dict;
+ if (!dictIsDefined)
+ dict64 = (1 << 27);
+ if (use_fileData)
+ {
+ if (!dictIsDefined)
+ dict64 = fileDataBuffer.Size();
+ else if (dict64 > fileDataBuffer.Size())
+ dict64 = fileDataBuffer.Size();
+ }
+
+ for (;;)
+ {
+ const int index = method.FindProp(NCoderPropID::kDictionarySize);
+ if (index < 0)
+ break;
+ method.Props.Delete((unsigned)index);
+ }
+
+ // methodName.RemoveChar(L'-');
+ Int32 complexity = 16 * k_Hash_Complex_Mult; // for unknown hash method
+ const UInt32 *checkSum = NULL;
+ int benchIndex = -1;
+
+ if (isHashMethod)
+ {
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Hash); i++)
+ {
+ const CBenchHash &h = g_Hash[i];
+ AString benchMethod (h.Name);
+ AString benchProps;
+ const int propPos = benchMethod.Find(':');
+ if (propPos >= 0)
+ {
+ benchProps = benchMethod.Ptr((unsigned)(propPos + 1));
+ benchMethod.DeleteFrom((unsigned)propPos);
+ }
+
+ if (AreSameMethodNames(benchMethod, methodName))
+ {
+ const bool sameProps = method.PropsString.IsEqualTo_Ascii_NoCase(benchProps);
+ /*
+ bool isMainMethod = method.PropsString.IsEmpty();
+ if (isMainMethod)
+ isMainMethod = !checkSum
+ || (benchMethod.IsEqualTo_Ascii_NoCase("crc32") && benchProps.IsEqualTo_Ascii_NoCase("8"));
+ if (sameProps || isMainMethod)
+ */
+ {
+ complexity = (Int32)h.Complex;
+ checkSum = &h.CheckSum;
+ if (sameProps)
+ break;
+ /*
+ if property. is not specified, we use the complexity
+ for latest fastest method (crc32:64)
+ */
+ }
+ }
+ }
+ // if (!checkSum) return E_NOTIMPL;
+ }
+ else
+ {
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Bench); i++)
+ {
+ const CBenchMethod &bench = g_Bench[i];
+ AString benchMethod (bench.Name);
+ AString benchProps;
+ const int propPos = benchMethod.Find(':');
+ if (propPos >= 0)
+ {
+ benchProps = benchMethod.Ptr((unsigned)(propPos + 1));
+ benchMethod.DeleteFrom((unsigned)propPos);
+ }
+
+ if (AreSameMethodNames(benchMethod, methodName))
+ {
+ const bool sameProps = method.PropsString.IsEqualTo_Ascii_NoCase(benchProps);
+ // bool isMainMethod = method.PropsString.IsEmpty();
+ // if (sameProps || isMainMethod)
+ {
+ benchIndex = (int)i;
+ if (sameProps)
+ break;
+ }
+ }
+ }
+ // if (benchIndex < 0) return E_NOTIMPL;
+ }
+
+ {
+ /* we count usage only for crc and filter. non-filters are not supported */
+ UInt64 usage = (1 << 20);
+ UInt64 bufSize = dict64;
+ UInt32 numBlocks = isHashMethod ? 1 : 3;
+ if (use_fileData)
+ {
+ usage += fileDataBuffer.Size();
+ if (bufSize > fileDataBuffer.Size())
+ bufSize = fileDataBuffer.Size();
+ if (isHashMethod)
+ {
+ numBlocks = 0;
+ #ifndef Z7_ST
+ if (numThreadsSpecified != 1)
+ numBlocks = (k_Crc_CreateLocalBuf_For_File ? 1 : 0);
+ #endif
+ }
+ }
+ usage += numThreadsSpecified * bufSize * numBlocks;
+ Print_Usage_and_Threads(f, usage, numThreadsSpecified);
+ }
+
+ CUIntVector numThreadsVector;
+ {
+ unsigned nt = numThreads_Start;
+ for (;;)
+ {
+ if (nt > numThreadsSpecified)
+ break;
+ numThreadsVector.Add(nt);
+ const unsigned next = nt * 2;
+ const UInt32 ntHalf= numThreadsSpecified / 2;
+ if (ntHalf > nt && ntHalf < next)
+ numThreadsVector.Add(ntHalf);
+ if (numThreadsSpecified > nt && numThreadsSpecified < next)
+ numThreadsVector.Add(numThreadsSpecified);
+ nt = next;
+ }
+ }
+
+ unsigned numColumns = isHashMethod ? 1 : 2;
+ CTempValues speedTotals;
+ CTempValues usageTotals;
+ {
+ const unsigned numItems = numThreadsVector.Size() * numColumns;
+ speedTotals.Alloc(numItems);
+ usageTotals.Alloc(numItems);
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ speedTotals.Values[i] = 0;
+ usageTotals.Values[i] = 0;
+ }
+ }
+
+ f.NewLine();
+ for (unsigned line = 0; line < 3; line++)
+ {
+ f.NewLine();
+ f.Print(line == 0 ? "THRD" : line == 1 ? " " : "Size");
+ FOR_VECTOR (ti, numThreadsVector)
+ {
+ if (ti != 0)
+ Print_Delimiter(f);
+ if (line == 0)
+ {
+ PrintSpaces(f, (kFieldSize_CrcSpeed + kFieldSize_Usage + 2) * (numColumns - 1));
+ PrintNumber(f, numThreadsVector[ti], 1 + kFieldSize_Usage + kFieldSize_CrcSpeed);
+ }
+ else
+ {
+ for (unsigned c = 0; c < numColumns; c++)
+ {
+ PrintRight(f, line == 1 ? "Usage" : "%", kFieldSize_Usage + 1);
+ PrintRight(f, line == 1 ? "BW" : "MB/s", kFieldSize_CrcSpeed + 1);
+ }
+ }
+ }
+ }
+ f.NewLine();
+
+ UInt64 numSteps = 0;
+
+ // for (UInt32 iter = 0; iter < numIterations; iter++)
+ // {
+ unsigned pow = 10; // kNumHashDictBits
+ if (startDicLog_Defined)
+ pow = startDicLog;
+
+ // #define NUM_SUB_BITS 2
+ // pow <<= NUM_SUB_BITS;
+ for (;; pow++)
+ {
+ const UInt64 bufSize = (UInt64)1 << pow;
+ // UInt64 bufSize = (UInt64)1 << (pow >> NUM_SUB_BITS);
+ // bufSize += ((UInt64)pow & ((1 << NUM_SUB_BITS) - 1)) << ((pow >> NUM_SUB_BITS) - NUM_SUB_BITS);
+
+ size_t dataSize = fileDataBuffer.Size();
+ if (dataSize > bufSize || !use_fileData)
+ dataSize = (size_t)bufSize;
+
+ for (UInt32 iter = 0; iter < numIterations; iter++)
+ {
+ Print_Pow(f, pow);
+ // PrintNumber(f, bufSize >> 10, 4);
+
+ FOR_VECTOR (ti, numThreadsVector)
+ {
+ RINOK(f.CheckBreak())
+ const UInt32 numThreads = numThreadsVector[ti];
+ if (isHashMethod)
+ {
+ UInt64 speed = 0;
+ UInt64 usage = 0;
+ const HRESULT res = CrcBench(EXTERNAL_CODECS_LOC_VARS complexInCommands,
+ numThreads,
+ dataSize, (const Byte *)fileDataBuffer,
+ speed, usage,
+ (UInt32)complexity,
+ 1, // benchWeight,
+ (pow == kNumHashDictBits && !use_fileData) ? checkSum : NULL,
+ method,
+ &f,
+ #ifndef Z7_ST
+ &affinityMode,
+ #endif
+ false, // showRating
+ NULL, false, 0);
+ RINOK(res)
+
+ if (ti != 0)
+ Print_Delimiter(f);
+
+ Bench_BW_Print_Usage_Speed(f, usage, speed);
+ speedTotals.Values[ti] += speed;
+ usageTotals.Values[ti] += usage;
+ }
+ else
+ {
+ {
+ unsigned keySize = 32;
+ if (IsString1PrefixedByString2(methodName, "AES128")) keySize = 16;
+ else if (IsString1PrefixedByString2(methodName, "AES192")) keySize = 24;
+ callback.BenchProps.KeySize = keySize;
+ }
+
+ COneMethodInfo method2 = method;
+ unsigned bench_DictBits;
+
+ if (benchIndex >= 0)
+ {
+ const CBenchMethod &bench = g_Bench[benchIndex];
+ callback.BenchProps.EncComplex = bench.EncComplex;
+ callback.BenchProps.DecComplexUnc = bench.DecComplexUnc;
+ callback.BenchProps.DecComplexCompr = bench.DecComplexCompr;
+ bench_DictBits = bench.DictBits;
+ // bench_DictBits = kOldLzmaDictBits; = 32 default : for debug
+ }
+ else
+ {
+ bench_DictBits = kOldLzmaDictBits; // = 32 default
+ if (isFilter)
+ {
+ const unsigned k_UnknownCoderComplexity = 4;
+ callback.BenchProps.EncComplex = k_UnknownCoderComplexity;
+ callback.BenchProps.DecComplexUnc = k_UnknownCoderComplexity;
+ }
+ else
+ {
+ callback.BenchProps.EncComplex = 1 << 10;
+ callback.BenchProps.DecComplexUnc = 1 << 6;
+ }
+ callback.BenchProps.DecComplexCompr = 0;
+ }
+ callback.NeedPrint = false;
+
+ if (StringsAreEqualNoCase_Ascii(method2.MethodName, "LZMA"))
+ {
+ const NCOM::CPropVariant propVariant = (UInt32)pow;
+ RINOK(method2.ParseMethodFromPROPVARIANT((UString)"d", propVariant))
+ }
+
+ const HRESULT res = MethodBench(
+ EXTERNAL_CODECS_LOC_VARS
+ complexInCommands,
+ #ifndef Z7_ST
+ false, // oldLzmaBenchMode
+ numThreadsVector[ti],
+ &affinityMode,
+ #endif
+ method2,
+ dataSize, (const Byte *)fileDataBuffer,
+ bench_DictBits,
+ printCallback,
+ &callback,
+ &callback.BenchProps);
+ RINOK(res)
+
+ if (ti != 0)
+ Print_Delimiter(f);
+
+ for (unsigned i = 0; i < 2; i++)
+ {
+ const CBenchInfo &bi = callback.BenchInfo_Results[i];
+ const UInt64 usage = bi.GetUsage();
+ const UInt64 speed = bi.GetUnpackSizeSpeed();
+ usageTotals.Values[ti * 2 + i] += usage;
+ speedTotals.Values[ti * 2 + i] += speed;
+ Bench_BW_Print_Usage_Speed(f, usage, speed);
+ }
+ }
+ }
+
+ f.NewLine();
+ numSteps++;
+ }
+ if (dataSize >= dict64)
+ break;
+ }
+
+ if (numSteps != 0)
+ {
+ f.Print("Avg:");
+ for (unsigned ti = 0; ti < numThreadsVector.Size(); ti++)
+ {
+ if (ti != 0)
+ Print_Delimiter(f);
+ for (unsigned i = 0; i < numColumns; i++)
+ Bench_BW_Print_Usage_Speed(f,
+ usageTotals.Values[ti * numColumns + i] / numSteps,
+ speedTotals.Values[ti * numColumns + i] / numSteps);
+ }
+ f.NewLine();
+ }
+
+ return S_OK;
+ }
+
+ bool use2Columns = false;
+
+ bool totalBenchMode = false;
+ bool onlyHashBench = false;
+ if (methodName.IsEqualTo_Ascii_NoCase("hash"))
+ {
+ onlyHashBench = true;
+ methodName = "*";
+ totalBenchMode = true;
+ }
+ else if (methodName.Find('*') >= 0)
+ totalBenchMode = true;
+
+ // ---------- Threads loop ----------
+ for (unsigned threadsPassIndex = 0; threadsPassIndex < 3; threadsPassIndex++)
+ {
+
+ UInt32 numThreads = numThreadsSpecified;
+
+ if (!multiThreadTests)
+ {
+ if (threadsPassIndex != 0)
+ break;
+ }
+ else
+ {
+ numThreads = 1;
+ if (threadsPassIndex != 0)
+ {
+ if (numCPUs < 2)
+ break;
+ numThreads = numCPUs;
+ if (threadsPassIndex == 1)
+ {
+ if (numCPUs >= 4)
+ numThreads = numCPUs / 2;
+ }
+ else if (numCPUs < 4)
+ break;
+ }
+ }
+
+ IBenchPrintCallback &f = *printCallback;
+
+ if (threadsPassIndex > 0)
+ {
+ f.NewLine();
+ f.NewLine();
+ }
+
+ if (!dictIsDefined && !onlyHashBench)
+ {
+ const unsigned dicSizeLog_Main = (totalBenchMode ? 24 : 25);
+ unsigned dicSizeLog = dicSizeLog_Main;
+
+ #ifdef UNDER_CE
+ dicSizeLog = (UInt64)1 << 20;
+ #endif
+
+ if (ramSize_Defined)
+ for (; dicSizeLog > kBenchMinDicLogSize; dicSizeLog--)
+ if (GetBenchMemoryUsage(numThreads, (int)level, ((UInt64)1 << dicSizeLog), totalBenchMode) + (8 << 20) <= ramSize)
+ break;
+
+ dict = (UInt64)1 << dicSizeLog;
+
+ if (totalBenchMode && dicSizeLog != dicSizeLog_Main)
+ {
+ f.Print("Dictionary reduced to: ");
+ PrintNumber(f, dicSizeLog, 1);
+ f.NewLine();
+ }
+ }
+
+ Print_Usage_and_Threads(f,
+ onlyHashBench ?
+ GetBenchMemoryUsage_Hash(numThreads, dict) :
+ GetBenchMemoryUsage(numThreads, (int)level, dict, totalBenchMode),
+ numThreads);
+
+ f.NewLine();
+
+ f.NewLine();
+
+ if (totalBenchMode)
+ {
+ callback.NameFieldSize = kFieldSize_Name;
+ use2Columns = false;
+ }
+ else
+ {
+ callback.NameFieldSize = kFieldSize_SmallName;
+ use2Columns = true;
+ }
+ callback.Use2Columns = use2Columns;
+
+ bool showFreq = false;
+ UInt64 cpuFreq = 0;
+
+ if (totalBenchMode)
+ {
+ showFreq = true;
+ }
+
+ unsigned fileldSize = kFieldSize_TotalSize;
+ if (showFreq)
+ fileldSize += kFieldSize_EUAndEffec;
+
+ if (use2Columns)
+ {
+ PrintSpaces(f, callback.NameFieldSize);
+ PrintRight(f, "Compressing", fileldSize);
+ f.Print(kSep);
+ PrintRight(f, "Decompressing", fileldSize);
+ }
+ f.NewLine();
+ PrintLeft(f, totalBenchMode ? "Method" : "Dict", callback.NameFieldSize);
+
+ int j;
+
+ for (j = 0; j < 2; j++)
+ {
+ PrintRight(f, "Speed", kFieldSize_Speed + 1);
+ PrintRight(f, "Usage", kFieldSize_Usage + 1);
+ PrintRight(f, "R/U", kFieldSize_RU + 1);
+ PrintRight(f, "Rating", kFieldSize_Rating + 1);
+ if (showFreq)
+ {
+ PrintRight(f, "E/U", kFieldSize_EU + 1);
+ PrintRight(f, "Effec", kFieldSize_Effec + 1);
+ }
+ if (!use2Columns)
+ break;
+ if (j == 0)
+ f.Print(kSep);
+ }
+
+ f.NewLine();
+ PrintSpaces(f, callback.NameFieldSize);
+
+ for (j = 0; j < 2; j++)
+ {
+ PrintRight(f, "KiB/s", kFieldSize_Speed + 1);
+ PrintRight(f, "%", kFieldSize_Usage + 1);
+ PrintRight(f, "MIPS", kFieldSize_RU + 1);
+ PrintRight(f, "MIPS", kFieldSize_Rating + 1);
+ if (showFreq)
+ {
+ PrintRight(f, "%", kFieldSize_EU + 1);
+ PrintRight(f, "%", kFieldSize_Effec + 1);
+ }
+ if (!use2Columns)
+ break;
+ if (j == 0)
+ f.Print(kSep);
+ }
+
+ f.NewLine();
+ f.NewLine();
+
+ if (specifiedFreq != 0)
+ cpuFreq = specifiedFreq;
+
+ // bool showTotalSpeed = false;
+
+ if (totalBenchMode)
+ {
+ for (UInt32 i = 0; i < numIterations; i++)
+ {
+ if (i != 0)
+ printCallback->NewLine();
+
+ const unsigned kNumCpuTests = 3;
+ for (unsigned freqTest = 0; freqTest < kNumCpuTests; freqTest++)
+ {
+ PrintLeft(f, "CPU", kFieldSize_Name);
+
+ // UInt32 resVal;
+
+ CFreqBench fb;
+ fb.complexInCommands = complexInCommands;
+ fb.numThreads = numThreads;
+ // showFreq;
+ fb.showFreq = (freqTest == kNumCpuTests - 1 || specifiedFreq != 0);
+ fb.specifiedFreq = specifiedFreq;
+
+ const HRESULT res = fb.FreqBench(printCallback
+ #ifndef Z7_ST
+ , &affinityMode
+ #endif
+ );
+ RINOK(res)
+
+ cpuFreq = fb.CpuFreqRes;
+ callback.NewLine();
+
+ if (specifiedFreq != 0)
+ cpuFreq = specifiedFreq;
+
+ if (testTimeMs >= 1000)
+ if (freqTest == kNumCpuTests - 1)
+ {
+ // SetComplexCommandsMs(testTimeMs, specifiedFreq != 0, cpuFreq, complexInCommands);
+ }
+ }
+ callback.NewLine();
+
+ // return S_OK; // change it
+
+ callback.SetFreq(true, cpuFreq);
+
+ if (!onlyHashBench)
+ {
+ size_t dataSize = (size_t)dict;
+ if (use_fileData)
+ {
+ dataSize = fileDataBuffer.Size();
+ if (dictIsDefined && dataSize > dict)
+ dataSize = (size_t)dict;
+ }
+
+ const HRESULT res = TotalBench(EXTERNAL_CODECS_LOC_VARS
+ method, complexInCommands,
+ #ifndef Z7_ST
+ numThreads,
+ &affinityMode,
+ #endif
+ dictIsDefined || use_fileData, // forceUnpackSize
+ dataSize,
+ (const Byte *)fileDataBuffer,
+ printCallback, &callback);
+ RINOK(res)
+ }
+
+ {
+ size_t dataSize = (size_t)1 << kNumHashDictBits;
+ if (dictIsDefined)
+ {
+ dataSize = (size_t)dict;
+ if (dataSize != dict)
+ return E_OUTOFMEMORY;
+ }
+ if (use_fileData)
+ {
+ dataSize = fileDataBuffer.Size();
+ if (dictIsDefined && dataSize > dict)
+ dataSize = (size_t)dict;
+ }
+
+ const HRESULT res = TotalBench_Hash(EXTERNAL_CODECS_LOC_VARS
+ method, complexInCommands,
+ numThreads,
+ dataSize, (const Byte *)fileDataBuffer,
+ printCallback, &callback,
+ #ifndef Z7_ST
+ &affinityMode,
+ #endif
+ &callback.EncodeRes, true, cpuFreq);
+ RINOK(res)
+ }
+
+ callback.NewLine();
+ {
+ PrintLeft(f, "CPU", kFieldSize_Name);
+
+ CFreqBench fb;
+ fb.complexInCommands = complexInCommands;
+ fb.numThreads = numThreads;
+ // showFreq;
+ fb.showFreq = (specifiedFreq != 0);
+ fb.specifiedFreq = specifiedFreq;
+
+ const HRESULT res = fb.FreqBench(printCallback
+ #ifndef Z7_ST
+ , &affinityMode
+ #endif
+ );
+ RINOK(res)
+ callback.NewLine();
+ }
+ }
+ }
+ else
+ {
+ needSetComplexity = true;
+ if (!methodName.IsEqualTo_Ascii_NoCase("LZMA"))
+ {
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(g_Bench); i++)
+ {
+ const CBenchMethod &h = g_Bench[i];
+ AString benchMethod (h.Name);
+ AString benchProps;
+ const int propPos = benchMethod.Find(':');
+ if (propPos >= 0)
+ {
+ benchProps = benchMethod.Ptr((unsigned)(propPos + 1));
+ benchMethod.DeleteFrom((unsigned)propPos);
+ }
+
+ if (AreSameMethodNames(benchMethod, methodName))
+ {
+ if (benchProps.IsEmpty()
+ || (benchProps == "x5" && method.PropsString.IsEmpty())
+ || method.PropsString.IsPrefixedBy_Ascii_NoCase(benchProps))
+ {
+ callback.BenchProps.EncComplex = h.EncComplex;
+ callback.BenchProps.DecComplexCompr = h.DecComplexCompr;
+ callback.BenchProps.DecComplexUnc = h.DecComplexUnc;
+ needSetComplexity = false;
+ break;
+ }
+ }
+ }
+ /*
+ if (i == Z7_ARRAY_SIZE(g_Bench))
+ return E_NOTIMPL;
+ */
+ }
+ if (needSetComplexity)
+ callback.BenchProps.SetLzmaCompexity();
+
+ if (startDicLog < kBenchMinDicLogSize)
+ startDicLog = kBenchMinDicLogSize;
+
+ for (unsigned i = 0; i < numIterations; i++)
+ {
+ unsigned pow = (dict < GetDictSizeFromLog(startDicLog)) ? kBenchMinDicLogSize : (unsigned)startDicLog;
+ if (!multiDict)
+ pow = 32;
+ while (GetDictSizeFromLog(pow) > dict && pow > 0)
+ pow--;
+ for (; GetDictSizeFromLog(pow) <= dict; pow++)
+ {
+ Print_Pow(f, pow);
+ callback.DictSize = (UInt64)1 << pow;
+
+ COneMethodInfo method2 = method;
+
+ if (StringsAreEqualNoCase_Ascii(method2.MethodName, "LZMA"))
+ {
+ // We add dictionary size property.
+ // method2 can have two different dictionary size properties.
+ // And last property is main.
+ NCOM::CPropVariant propVariant = (UInt32)pow;
+ RINOK(method2.ParseMethodFromPROPVARIANT((UString)"d", propVariant))
+ }
+
+ size_t uncompressedDataSize;
+ if (use_fileData)
+ {
+ uncompressedDataSize = fileDataBuffer.Size();
+ }
+ else
+ {
+ uncompressedDataSize = (size_t)callback.DictSize;
+ if (uncompressedDataSize != callback.DictSize)
+ return E_OUTOFMEMORY;
+ if (uncompressedDataSize >= (1 << 18))
+ uncompressedDataSize += kAdditionalSize;
+ }
+
+ const HRESULT res = MethodBench(
+ EXTERNAL_CODECS_LOC_VARS
+ complexInCommands,
+ #ifndef Z7_ST
+ true, numThreads,
+ &affinityMode,
+ #endif
+ method2,
+ uncompressedDataSize, (const Byte *)fileDataBuffer,
+ kOldLzmaDictBits, printCallback, &callback, &callback.BenchProps);
+ f.NewLine();
+ RINOK(res)
+ if (!multiDict)
+ break;
+ }
+ }
+ }
+
+ PrintChars(f, '-', callback.NameFieldSize + fileldSize);
+
+ if (use2Columns)
+ {
+ f.Print(kSep);
+ PrintChars(f, '-', fileldSize);
+ }
+
+ f.NewLine();
+
+ if (use2Columns)
+ {
+ PrintLeft(f, "Avr:", callback.NameFieldSize);
+ PrintTotals(f, showFreq, cpuFreq, !totalBenchMode, callback.EncodeRes);
+ f.Print(kSep);
+ PrintTotals(f, showFreq, cpuFreq, !totalBenchMode, callback.DecodeRes);
+ f.NewLine();
+ }
+
+ PrintLeft(f, "Tot:", callback.NameFieldSize);
+ CTotalBenchRes midRes;
+ midRes = callback.EncodeRes;
+ midRes.Update_With_Res(callback.DecodeRes);
+
+ // midRes.SetSum(callback.EncodeRes, callback.DecodeRes);
+ PrintTotals(f, showFreq, cpuFreq, false, midRes);
+ f.NewLine();
+
+ }
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Common/Bench.h b/CPP/7zip/UI/Common/Bench.h
index 1d052aa..313676d 100644
--- a/CPP/7zip/UI/Common/Bench.h
+++ b/CPP/7zip/UI/Common/Bench.h
@@ -1,77 +1,121 @@
-// Bench.h
-
-#ifndef __7ZIP_BENCH_H
-#define __7ZIP_BENCH_H
-
-#include "../../../Windows/System.h"
-
-#include "../../Common/CreateCoder.h"
-#include "../../UI/Common/Property.h"
-
-struct CBenchInfo
-{
- UInt64 GlobalTime;
- UInt64 GlobalFreq;
- UInt64 UserTime;
- UInt64 UserFreq;
- UInt64 UnpackSize;
- UInt64 PackSize;
- UInt64 NumIterations;
-
- CBenchInfo(): NumIterations(0) {}
- UInt64 GetUsage() const;
- UInt64 GetRatingPerUsage(UInt64 rating) const;
- UInt64 GetSpeed(UInt64 numCommands) const;
-};
-
-struct IBenchCallback
-{
- virtual HRESULT SetFreq(bool showFreq, UInt64 cpuFreq) = 0;
- virtual HRESULT SetEncodeResult(const CBenchInfo &info, bool final) = 0;
- virtual HRESULT SetDecodeResult(const CBenchInfo &info, bool final) = 0;
-};
-
-UInt64 GetCompressRating(UInt32 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size);
-UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt64 inSize, UInt64 numIterations);
-
-const unsigned kBenchMinDicLogSize = 18;
-
-UInt64 GetBenchMemoryUsage(UInt32 numThreads, UInt32 dictionary, bool totalBench = false);
-
-struct IBenchPrintCallback
-{
- virtual void Print(const char *s) = 0;
- virtual void NewLine() = 0;
- virtual HRESULT CheckBreak() = 0;
-};
-
-/*
-struct IBenchFreqCallback
-{
- virtual void AddCpuFreq(UInt64 freq) = 0;
-};
-*/
-
-HRESULT Bench(
- DECL_EXTERNAL_CODECS_LOC_VARS
- IBenchPrintCallback *printCallback,
- IBenchCallback *benchCallback,
- // IBenchFreqCallback *freqCallback,
- const CObjectVector<CProperty> &props,
- UInt32 numIterations,
- bool multiDict
- );
-
-AString GetProcessThreadsInfo(const NWindows::NSystem::CProcessAffinity &ti);
-
-void GetSysInfo(AString &s1, AString &s2);
-void GetCpuName(AString &s);
-void GetCpuFeatures(AString &s);
-
-#ifdef _7ZIP_LARGE_PAGES
-void Add_LargePages_String(AString &s);
-#else
-// #define Add_LargePages_String
-#endif
-
-#endif
+// Bench.h
+
+#ifndef ZIP7_INC_7ZIP_BENCH_H
+#define ZIP7_INC_7ZIP_BENCH_H
+
+#include "../../../Windows/System.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../UI/Common/Property.h"
+
+UInt64 Benchmark_GetUsage_Percents(UInt64 usage);
+
+struct CBenchInfo
+{
+ UInt64 GlobalTime;
+ UInt64 GlobalFreq;
+ UInt64 UserTime;
+ UInt64 UserFreq;
+ UInt64 UnpackSize;
+ UInt64 PackSize;
+ UInt64 NumIterations;
+
+ /*
+ during Code(): we track benchInfo only from one thread (theads with index[0])
+ NumIterations means number of threads
+ UnpackSize and PackSize are total sizes of all iterations of current thread
+ after Code():
+ NumIterations means the number of Iterations
+ UnpackSize and PackSize are total sizes of all threads
+ */
+
+ CBenchInfo(): NumIterations(0) {}
+
+ UInt64 GetUsage() const;
+ UInt64 GetRatingPerUsage(UInt64 rating) const;
+ UInt64 GetSpeed(UInt64 numUnits) const;
+ UInt64 GetUnpackSizeSpeed() const { return GetSpeed(UnpackSize * NumIterations); }
+
+ UInt64 Get_UnpackSize_Full() const { return UnpackSize * NumIterations; }
+
+ UInt64 GetRating_LzmaEnc(UInt64 dictSize) const;
+ UInt64 GetRating_LzmaDec() const;
+};
+
+
+struct CTotalBenchRes
+{
+ // UInt64 NumIterations1; // for Usage
+ UInt64 NumIterations2; // for Rating / RPU
+
+ UInt64 Rating;
+ UInt64 Usage;
+ UInt64 RPU;
+ UInt64 Speed;
+
+ void Init() { /* NumIterations1 = 0; */ NumIterations2 = 0; Rating = 0; Usage = 0; RPU = 0; Speed = 0; }
+
+ void SetSum(const CTotalBenchRes &r1, const CTotalBenchRes &r2)
+ {
+ Rating = (r1.Rating + r2.Rating);
+ Usage = (r1.Usage + r2.Usage);
+ RPU = (r1.RPU + r2.RPU);
+ Speed = (r1.Speed + r2.Speed);
+ // NumIterations1 = (r1.NumIterations1 + r2.NumIterations1);
+ NumIterations2 = (r1.NumIterations2 + r2.NumIterations2);
+ }
+
+ void Generate_From_BenchInfo(const CBenchInfo &info);
+ void Mult_For_Weight(unsigned weight);
+ void Update_With_Res(const CTotalBenchRes &r);
+};
+
+
+const unsigned kBenchMinDicLogSize = 18;
+
+UInt64 GetBenchMemoryUsage(UInt32 numThreads, int level, UInt64 dictionary, bool totalBench);
+
+Z7_PURE_INTERFACES_BEGIN
+DECLARE_INTERFACE(IBenchCallback)
+{
+ // virtual HRESULT SetFreq(bool showFreq, UInt64 cpuFreq) = 0;
+ virtual HRESULT SetEncodeResult(const CBenchInfo &info, bool final) = 0;
+ virtual HRESULT SetDecodeResult(const CBenchInfo &info, bool final) = 0;
+};
+
+DECLARE_INTERFACE(IBenchPrintCallback)
+{
+ virtual void Print(const char *s) = 0;
+ virtual void NewLine() = 0;
+ virtual HRESULT CheckBreak() = 0;
+};
+
+DECLARE_INTERFACE(IBenchFreqCallback)
+{
+ virtual HRESULT AddCpuFreq(unsigned numThreads, UInt64 freq, UInt64 usage) = 0;
+ virtual HRESULT FreqsFinished(unsigned numThreads) = 0;
+};
+Z7_PURE_INTERFACES_END
+
+HRESULT Bench(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ IBenchPrintCallback *printCallback,
+ IBenchCallback *benchCallback,
+ const CObjectVector<CProperty> &props,
+ UInt32 numIterations,
+ bool multiDict,
+ IBenchFreqCallback *freqCallback = NULL);
+
+AString GetProcessThreadsInfo(const NWindows::NSystem::CProcessAffinity &ti);
+
+void GetSysInfo(AString &s1, AString &s2);
+void GetCpuName(AString &s);
+void AddCpuFeatures(AString &s);
+
+#ifdef Z7_LARGE_PAGES
+void Add_LargePages_String(AString &s);
+#else
+// #define Add_LargePages_String
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/Common/CompressCall.cpp b/CPP/7zip/UI/Common/CompressCall.cpp
new file mode 100644
index 0000000..42bae2a
--- /dev/null
+++ b/CPP/7zip/UI/Common/CompressCall.cpp
@@ -0,0 +1,343 @@
+// CompressCall.cpp
+
+#include "StdAfx.h"
+
+#include <wchar.h>
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyCom.h"
+#include "../../../Common/Random.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileMapping.h"
+#include "../../../Windows/MemoryLock.h"
+#include "../../../Windows/ProcessUtils.h"
+#include "../../../Windows/Synchronization.h"
+
+#include "../FileManager/RegistryUtils.h"
+
+#include "CompressCall.h"
+
+using namespace NWindows;
+
+#define MY_TRY_BEGIN try {
+
+#define MY_TRY_FINISH } \
+ catch(...) { ErrorMessageHRESULT(E_FAIL); return E_FAIL; }
+
+#define MY_TRY_FINISH_VOID } \
+ catch(...) { ErrorMessageHRESULT(E_FAIL); }
+
+#define k7zGui "7zG.exe"
+
+// 21.07 : we can disable wildcard
+// #define ISWITCH_NO_WILDCARD_POSTFIX "w-"
+#define ISWITCH_NO_WILDCARD_POSTFIX
+
+#define kShowDialogSwitch " -ad"
+#define kEmailSwitch " -seml."
+#define kArchiveTypeSwitch " -t"
+#define kIncludeSwitch " -i" ISWITCH_NO_WILDCARD_POSTFIX
+#define kArcIncludeSwitches " -an -ai" ISWITCH_NO_WILDCARD_POSTFIX
+#define kHashIncludeSwitches kIncludeSwitch
+#define kStopSwitchParsing " --"
+
+extern HWND g_HWND;
+
+UString GetQuotedString(const UString &s)
+{
+ UString s2 ('\"');
+ s2 += s;
+ s2 += '\"';
+ return s2;
+}
+
+static void ErrorMessage(LPCWSTR message)
+{
+ MessageBoxW(g_HWND, message, L"7-Zip", MB_ICONERROR | MB_OK);
+}
+
+static void ErrorMessageHRESULT(HRESULT res, LPCWSTR s = NULL)
+{
+ UString s2 = NError::MyFormatMessage(res);
+ if (s)
+ {
+ s2.Add_LF();
+ s2 += s;
+ }
+ ErrorMessage(s2);
+}
+
+static HRESULT Call7zGui(const UString ¶ms,
+ // LPCWSTR curDir,
+ bool waitFinish,
+ NSynchronization::CBaseEvent *event)
+{
+ UString imageName = fs2us(NWindows::NDLL::GetModuleDirPrefix());
+ imageName += k7zGui;
+
+ CProcess process;
+ const WRes wres = process.Create(imageName, params, NULL); // curDir);
+ if (wres != 0)
+ {
+ const HRESULT hres = HRESULT_FROM_WIN32(wres);
+ ErrorMessageHRESULT(hres, imageName);
+ return hres;
+ }
+ if (waitFinish)
+ process.Wait();
+ else if (event != NULL)
+ {
+ HANDLE handles[] = { process, *event };
+ ::WaitForMultipleObjects(Z7_ARRAY_SIZE(handles), handles, FALSE, INFINITE);
+ }
+ return S_OK;
+}
+
+static void AddLagePagesSwitch(UString ¶ms)
+{
+ if (ReadLockMemoryEnable())
+ #ifndef UNDER_CE
+ if (NSecurity::Get_LargePages_RiskLevel() == 0)
+ #endif
+ params += " -slp";
+}
+
+class CRandNameGenerator
+{
+ CRandom _random;
+public:
+ CRandNameGenerator() { _random.Init(); }
+ void GenerateName(UString &s, const char *prefix)
+ {
+ s += prefix;
+ s.Add_UInt32((UInt32)(unsigned)_random.Generate());
+ }
+};
+
+static HRESULT CreateMap(const UStringVector &names,
+ CFileMapping &fileMapping, NSynchronization::CManualResetEvent &event,
+ UString ¶ms)
+{
+ size_t totalSize = 1;
+ {
+ FOR_VECTOR (i, names)
+ totalSize += (names[i].Len() + 1);
+ }
+ totalSize *= sizeof(wchar_t);
+
+ CRandNameGenerator random;
+
+ UString mappingName;
+ for (;;)
+ {
+ random.GenerateName(mappingName, "7zMap");
+ const WRes wres = fileMapping.Create(PAGE_READWRITE, totalSize, GetSystemString(mappingName));
+ if (fileMapping.IsCreated() && wres == 0)
+ break;
+ if (wres != ERROR_ALREADY_EXISTS)
+ return HRESULT_FROM_WIN32(wres);
+ fileMapping.Close();
+ }
+
+ UString eventName;
+ for (;;)
+ {
+ random.GenerateName(eventName, "7zEvent");
+ const WRes wres = event.CreateWithName(false, GetSystemString(eventName));
+ if (event.IsCreated() && wres == 0)
+ break;
+ if (wres != ERROR_ALREADY_EXISTS)
+ return HRESULT_FROM_WIN32(wres);
+ event.Close();
+ }
+
+ params += '#';
+ params += mappingName;
+ params += ':';
+ char temp[32];
+ ConvertUInt64ToString(totalSize, temp);
+ params += temp;
+
+ params += ':';
+ params += eventName;
+
+ LPVOID data = fileMapping.Map(FILE_MAP_WRITE, 0, totalSize);
+ if (!data)
+ return E_FAIL;
+ CFileUnmapper unmapper(data);
+ {
+ wchar_t *cur = (wchar_t *)data;
+ *cur++ = 0; // it means wchar_t strings (UTF-16 in WIN32)
+ FOR_VECTOR (i, names)
+ {
+ const UString &s = names[i];
+ const unsigned len = s.Len() + 1;
+ wmemcpy(cur, (const wchar_t *)s, len);
+ cur += len;
+ }
+ }
+ return S_OK;
+}
+
+HRESULT CompressFiles(
+ const UString &arcPathPrefix,
+ const UString &arcName,
+ const UString &arcType,
+ bool addExtension,
+ const UStringVector &names,
+ bool email, bool showDialog, bool waitFinish)
+{
+ MY_TRY_BEGIN
+ UString params ('a');
+
+ CFileMapping fileMapping;
+ NSynchronization::CManualResetEvent event;
+ params += kIncludeSwitch;
+ RINOK(CreateMap(names, fileMapping, event, params))
+
+ if (!arcType.IsEmpty())
+ {
+ params += kArchiveTypeSwitch;
+ params += arcType;
+ }
+
+ if (email)
+ params += kEmailSwitch;
+
+ if (showDialog)
+ params += kShowDialogSwitch;
+
+ AddLagePagesSwitch(params);
+
+ if (arcName.IsEmpty())
+ params += " -an";
+
+ if (addExtension)
+ params += " -saa";
+ else
+ params += " -sae";
+
+ params += kStopSwitchParsing;
+ params.Add_Space();
+
+ if (!arcName.IsEmpty())
+ {
+ params += GetQuotedString(
+ // #ifdef UNDER_CE
+ arcPathPrefix +
+ // #endif
+ arcName);
+ }
+
+ return Call7zGui(params,
+ // (arcPathPrefix.IsEmpty()? 0: (LPCWSTR)arcPathPrefix),
+ waitFinish, &event);
+ MY_TRY_FINISH
+}
+
+static void ExtractGroupCommand(const UStringVector &arcPaths, UString ¶ms, bool isHash)
+{
+ AddLagePagesSwitch(params);
+ params += (isHash ? kHashIncludeSwitches : kArcIncludeSwitches);
+ CFileMapping fileMapping;
+ NSynchronization::CManualResetEvent event;
+ HRESULT result = CreateMap(arcPaths, fileMapping, event, params);
+ if (result == S_OK)
+ result = Call7zGui(params, false, &event);
+ if (result != S_OK)
+ ErrorMessageHRESULT(result);
+}
+
+void ExtractArchives(const UStringVector &arcPaths, const UString &outFolder, bool showDialog, bool elimDup, UInt32 writeZone)
+{
+ MY_TRY_BEGIN
+ UString params ('x');
+ if (!outFolder.IsEmpty())
+ {
+ params += " -o";
+ params += GetQuotedString(outFolder);
+ }
+ if (elimDup)
+ params += " -spe";
+ if (writeZone != (UInt32)(Int32)-1)
+ {
+ params += " -snz";
+ params.Add_UInt32(writeZone);
+ }
+ if (showDialog)
+ params += kShowDialogSwitch;
+ ExtractGroupCommand(arcPaths, params, false);
+ MY_TRY_FINISH_VOID
+}
+
+
+void TestArchives(const UStringVector &arcPaths, bool hashMode)
+{
+ MY_TRY_BEGIN
+ UString params ('t');
+ if (hashMode)
+ {
+ params += kArchiveTypeSwitch;
+ params += "hash";
+ }
+ ExtractGroupCommand(arcPaths, params, false);
+ MY_TRY_FINISH_VOID
+}
+
+
+void CalcChecksum(const UStringVector &paths,
+ const UString &methodName,
+ const UString &arcPathPrefix,
+ const UString &arcFileName)
+{
+ MY_TRY_BEGIN
+
+ if (!arcFileName.IsEmpty())
+ {
+ CompressFiles(
+ arcPathPrefix,
+ arcFileName,
+ UString("hash"),
+ false, // addExtension,
+ paths,
+ false, // email,
+ false, // showDialog,
+ false // waitFinish
+ );
+ return;
+ }
+
+ UString params ('h');
+ if (!methodName.IsEmpty())
+ {
+ params += " -scrc";
+ params += methodName;
+ /*
+ if (!arcFileName.IsEmpty())
+ {
+ // not used alternate method of generating file
+ params += " -scrf=";
+ params += GetQuotedString(arcPathPrefix + arcFileName);
+ }
+ */
+ }
+ ExtractGroupCommand(paths, params, true);
+ MY_TRY_FINISH_VOID
+}
+
+void Benchmark(bool totalMode)
+{
+ MY_TRY_BEGIN
+ UString params ('b');
+ if (totalMode)
+ params += " -mm=*";
+ AddLagePagesSwitch(params);
+ const HRESULT result = Call7zGui(params, false, NULL);
+ if (result != S_OK)
+ ErrorMessageHRESULT(result);
+ MY_TRY_FINISH_VOID
+}
diff --git a/CPP/7zip/UI/Common/CompressCall.h b/CPP/7zip/UI/Common/CompressCall.h
new file mode 100644
index 0000000..f2da163
--- /dev/null
+++ b/CPP/7zip/UI/Common/CompressCall.h
@@ -0,0 +1,28 @@
+// CompressCall.h
+
+#ifndef ZIP7_INC_COMPRESS_CALL_H
+#define ZIP7_INC_COMPRESS_CALL_H
+
+#include "../../../Common/MyString.h"
+
+UString GetQuotedString(const UString &s);
+
+HRESULT CompressFiles(
+ const UString &arcPathPrefix,
+ const UString &arcName,
+ const UString &arcType,
+ bool addExtension,
+ const UStringVector &names,
+ bool email, bool showDialog, bool waitFinish);
+
+void ExtractArchives(const UStringVector &arcPaths, const UString &outFolder, bool showDialog, bool elimDup, UInt32 writeZone);
+void TestArchives(const UStringVector &arcPaths, bool hashMode = false);
+
+void CalcChecksum(const UStringVector &paths,
+ const UString &methodName,
+ const UString &arcPathPrefix,
+ const UString &arcFileName);
+
+void Benchmark(bool totalMode);
+
+#endif
diff --git a/CPP/7zip/UI/Common/CompressCall2.cpp b/CPP/7zip/UI/Common/CompressCall2.cpp
new file mode 100644
index 0000000..21eb472
--- /dev/null
+++ b/CPP/7zip/UI/Common/CompressCall2.cpp
@@ -0,0 +1,327 @@
+// CompressCall2.cpp
+
+#include "StdAfx.h"
+
+#ifndef Z7_EXTERNAL_CODECS
+
+#include "../../../Common/MyException.h"
+
+#include "../../UI/Common/EnumDirItems.h"
+
+#include "../../UI/FileManager/LangUtils.h"
+
+#include "../../UI/GUI/BenchmarkDialog.h"
+#include "../../UI/GUI/ExtractGUI.h"
+#include "../../UI/GUI/UpdateGUI.h"
+#include "../../UI/GUI/HashGUI.h"
+
+#include "../../UI/GUI/ExtractRes.h"
+
+#include "CompressCall.h"
+
+extern HWND g_HWND;
+
+#define MY_TRY_BEGIN HRESULT result; try {
+#define MY_TRY_FINISH } \
+ catch(CSystemException &e) { result = e.ErrorCode; } \
+ catch(UString &s) { ErrorMessage(s); result = E_FAIL; } \
+ catch(...) { result = E_FAIL; } \
+ if (result != S_OK && result != E_ABORT) \
+ ErrorMessageHRESULT(result);
+
+static void ThrowException_if_Error(HRESULT res)
+{
+ if (res != S_OK)
+ throw CSystemException(res);
+}
+
+#ifdef Z7_EXTERNAL_CODECS
+
+#define CREATE_CODECS \
+ CCodecs *codecs = new CCodecs; \
+ CMyComPtr<ICompressCodecsInfo> compressCodecsInfo = codecs; \
+ ThrowException_if_Error(codecs->Load()); \
+ Codecs_AddHashArcHandler(codecs);
+
+#define LOAD_EXTERNAL_CODECS \
+ CExternalCodecs _externalCodecs; \
+ _externalCodecs.GetCodecs = codecs; \
+ _externalCodecs.GetHashers = codecs; \
+ ThrowException_if_Error(_externalCodecs.Load());
+
+#else
+
+#define CREATE_CODECS \
+ CCodecs *codecs = new CCodecs; \
+ CMyComPtr<IUnknown> compressCodecsInfo = codecs; \
+ ThrowException_if_Error(codecs->Load()); \
+ Codecs_AddHashArcHandler(codecs);
+
+#define LOAD_EXTERNAL_CODECS
+
+#endif
+
+
+
+
+UString GetQuotedString(const UString &s)
+{
+ UString s2 ('\"');
+ s2 += s;
+ s2 += '\"';
+ return s2;
+}
+
+static void ErrorMessage(LPCWSTR message)
+{
+ MessageBoxW(g_HWND, message, L"7-Zip", MB_ICONERROR);
+}
+
+static void ErrorMessageHRESULT(HRESULT res)
+{
+ ErrorMessage(HResultToMessage(res));
+}
+
+static void ErrorLangMessage(UINT resourceID)
+{
+ ErrorMessage(LangString(resourceID));
+}
+
+HRESULT CompressFiles(
+ const UString &arcPathPrefix,
+ const UString &arcName,
+ const UString &arcType,
+ bool addExtension,
+ const UStringVector &names,
+ bool email, bool showDialog, bool /* waitFinish */)
+{
+ MY_TRY_BEGIN
+
+ CREATE_CODECS
+
+ CUpdateCallbackGUI callback;
+
+ callback.Init();
+
+ CUpdateOptions uo;
+ uo.EMailMode = email;
+ uo.SetActionCommand_Add();
+
+ uo.ArcNameMode = (addExtension ? k_ArcNameMode_Add : k_ArcNameMode_Exact);
+
+ CObjectVector<COpenType> formatIndices;
+ if (!ParseOpenTypes(*codecs, arcType, formatIndices))
+ {
+ ErrorLangMessage(IDS_UNSUPPORTED_ARCHIVE_TYPE);
+ return E_FAIL;
+ }
+ const UString arcPath = arcPathPrefix + arcName;
+ if (!uo.InitFormatIndex(codecs, formatIndices, arcPath) ||
+ !uo.SetArcPath(codecs, arcPath))
+ {
+ ErrorLangMessage(IDS_UPDATE_NOT_SUPPORTED);
+ return E_FAIL;
+ }
+
+ NWildcard::CCensor censor;
+ FOR_VECTOR (i, names)
+ {
+ censor.AddPreItem_NoWildcard(names[i]);
+ }
+
+ bool messageWasDisplayed = false;
+
+ result = UpdateGUI(codecs,
+ formatIndices, arcPath,
+ censor, uo, showDialog, messageWasDisplayed, &callback, g_HWND);
+
+ if (result != S_OK)
+ {
+ if (result != E_ABORT && messageWasDisplayed)
+ return E_FAIL;
+ throw CSystemException(result);
+ }
+ if (callback.FailedFiles.Size() > 0)
+ {
+ if (!messageWasDisplayed)
+ throw CSystemException(E_FAIL);
+ return E_FAIL;
+ }
+
+ MY_TRY_FINISH
+ return S_OK;
+}
+
+
+static HRESULT ExtractGroupCommand(const UStringVector &arcPaths,
+ bool showDialog, CExtractOptions &eo, const char *kType = NULL)
+{
+ MY_TRY_BEGIN
+
+ CREATE_CODECS
+
+ CExtractCallbackImp *ecs = new CExtractCallbackImp;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
+
+ ecs->Init();
+
+ // eo.CalcCrc = options.CalcCrc;
+
+ UStringVector arcPathsSorted;
+ UStringVector arcFullPathsSorted;
+ {
+ NWildcard::CCensor arcCensor;
+ FOR_VECTOR (i, arcPaths)
+ {
+ arcCensor.AddPreItem_NoWildcard(arcPaths[i]);
+ }
+ arcCensor.AddPathsToCensor(NWildcard::k_RelatPath);
+ CDirItemsStat st;
+ EnumerateDirItemsAndSort(arcCensor, NWildcard::k_RelatPath, UString(),
+ arcPathsSorted, arcFullPathsSorted,
+ st,
+ NULL // &scan: change it!!!!
+ );
+ }
+
+ CObjectVector<COpenType> formatIndices;
+ if (kType)
+ {
+ if (!ParseOpenTypes(*codecs, UString(kType), formatIndices))
+ {
+ throw CSystemException(E_INVALIDARG);
+ // ErrorLangMessage(IDS_UNSUPPORTED_ARCHIVE_TYPE);
+ // return E_INVALIDARG;
+ }
+ }
+
+ NWildcard::CCensor censor;
+ {
+ censor.AddPreItem_Wildcard();
+ }
+
+ censor.AddPathsToCensor(NWildcard::k_RelatPath);
+
+ bool messageWasDisplayed = false;
+
+ ecs->MultiArcMode = (arcPathsSorted.Size() > 1);
+
+ result = ExtractGUI(codecs,
+ formatIndices, CIntVector(),
+ arcPathsSorted, arcFullPathsSorted,
+ censor.Pairs.Front().Head, eo, NULL, showDialog, messageWasDisplayed, ecs, g_HWND);
+
+ if (result != S_OK)
+ {
+ if (result != E_ABORT && messageWasDisplayed)
+ return E_FAIL;
+ throw CSystemException(result);
+ }
+ return ecs->IsOK() ? S_OK : E_FAIL;
+
+ MY_TRY_FINISH
+ return result;
+}
+
+void ExtractArchives(const UStringVector &arcPaths, const UString &outFolder,
+ bool showDialog, bool elimDup, UInt32 writeZone)
+{
+ CExtractOptions eo;
+ eo.OutputDir = us2fs(outFolder);
+ eo.TestMode = false;
+ eo.ElimDup.Val = elimDup;
+ eo.ElimDup.Def = elimDup;
+ if (writeZone != (UInt32)(Int32)-1)
+ eo.ZoneMode = (NExtract::NZoneIdMode::EEnum)writeZone;
+ ExtractGroupCommand(arcPaths, showDialog, eo);
+}
+
+void TestArchives(const UStringVector &arcPaths, bool hashMode)
+{
+ CExtractOptions eo;
+ eo.TestMode = true;
+ ExtractGroupCommand(arcPaths,
+ true, // showDialog
+ eo,
+ hashMode ? "hash" : NULL);
+}
+
+void CalcChecksum(const UStringVector &paths,
+ const UString &methodName,
+ const UString &arcPathPrefix,
+ const UString &arcFileName)
+{
+ MY_TRY_BEGIN
+
+ if (!arcFileName.IsEmpty())
+ {
+ CompressFiles(
+ arcPathPrefix,
+ arcFileName,
+ UString("hash"),
+ false, // addExtension,
+ paths,
+ false, // email,
+ false, // showDialog,
+ false // waitFinish
+ );
+ return;
+ }
+
+ CREATE_CODECS
+ LOAD_EXTERNAL_CODECS
+
+ NWildcard::CCensor censor;
+ FOR_VECTOR (i, paths)
+ {
+ censor.AddPreItem_NoWildcard(paths[i]);
+ }
+
+ censor.AddPathsToCensor(NWildcard::k_RelatPath);
+ bool messageWasDisplayed = false;
+
+ CHashOptions options;
+ options.Methods.Add(methodName);
+
+ /*
+ if (!arcFileName.IsEmpty())
+ options.HashFilePath = arcPathPrefix + arcFileName;
+ */
+
+ result = HashCalcGUI(EXTERNAL_CODECS_VARS_L censor, options, messageWasDisplayed);
+ if (result != S_OK)
+ {
+ if (result != E_ABORT && messageWasDisplayed)
+ return; // E_FAIL;
+ throw CSystemException(result);
+ }
+
+ MY_TRY_FINISH
+ return; // result;
+}
+
+void Benchmark(bool totalMode)
+{
+ MY_TRY_BEGIN
+
+ CREATE_CODECS
+ LOAD_EXTERNAL_CODECS
+
+ CObjectVector<CProperty> props;
+ if (totalMode)
+ {
+ CProperty prop;
+ prop.Name = "m";
+ prop.Value = "*";
+ props.Add(prop);
+ }
+ result = Benchmark(
+ EXTERNAL_CODECS_VARS_L
+ props,
+ k_NumBenchIterations_Default,
+ g_HWND);
+
+ MY_TRY_FINISH
+}
+
+#endif
diff --git a/CPP/7zip/UI/Common/DefaultName.cpp b/CPP/7zip/UI/Common/DefaultName.cpp
index 0c13e9e..8c34ffc 100644
--- a/CPP/7zip/UI/Common/DefaultName.cpp
+++ b/CPP/7zip/UI/Common/DefaultName.cpp
@@ -1,37 +1,37 @@
-// DefaultName.cpp
-
-#include "StdAfx.h"
-
-#include "DefaultName.h"
-
-static UString GetDefaultName3(const UString &fileName,
- const UString &extension, const UString &addSubExtension)
-{
- const unsigned extLen = extension.Len();
- const unsigned fileNameLen = fileName.Len();
-
- if (fileNameLen > extLen + 1)
- {
- const unsigned dotPos = fileNameLen - (extLen + 1);
- if (fileName[dotPos] == '.')
- if (extension.IsEqualTo_NoCase(fileName.Ptr(dotPos + 1)))
- return fileName.Left(dotPos) + addSubExtension;
- }
-
- int dotPos = fileName.ReverseFind_Dot();
- if (dotPos > 0)
- return fileName.Left(dotPos) + addSubExtension;
-
- if (addSubExtension.IsEmpty())
- return fileName + L'~';
- else
- return fileName + addSubExtension;
-}
-
-UString GetDefaultName2(const UString &fileName,
- const UString &extension, const UString &addSubExtension)
-{
- UString name = GetDefaultName3(fileName, extension, addSubExtension);
- name.TrimRight();
- return name;
-}
+// DefaultName.cpp
+
+#include "StdAfx.h"
+
+#include "DefaultName.h"
+
+static UString GetDefaultName3(const UString &fileName,
+ const UString &extension, const UString &addSubExtension)
+{
+ const unsigned extLen = extension.Len();
+ const unsigned fileNameLen = fileName.Len();
+
+ if (fileNameLen > extLen + 1)
+ {
+ const unsigned dotPos = fileNameLen - (extLen + 1);
+ if (fileName[dotPos] == '.')
+ if (extension.IsEqualTo_NoCase(fileName.Ptr(dotPos + 1)))
+ return fileName.Left(dotPos) + addSubExtension;
+ }
+
+ int dotPos = fileName.ReverseFind_Dot();
+ if (dotPos > 0)
+ return fileName.Left((unsigned)dotPos) + addSubExtension;
+
+ if (addSubExtension.IsEmpty())
+ return fileName + L'~';
+ else
+ return fileName + addSubExtension;
+}
+
+UString GetDefaultName2(const UString &fileName,
+ const UString &extension, const UString &addSubExtension)
+{
+ UString name = GetDefaultName3(fileName, extension, addSubExtension);
+ name.TrimRight();
+ return name;
+}
diff --git a/CPP/7zip/UI/Common/DefaultName.h b/CPP/7zip/UI/Common/DefaultName.h
index 4484c3b..46f6e9e 100644
--- a/CPP/7zip/UI/Common/DefaultName.h
+++ b/CPP/7zip/UI/Common/DefaultName.h
@@ -1,11 +1,11 @@
-// DefaultName.h
-
-#ifndef __DEFAULT_NAME_H
-#define __DEFAULT_NAME_H
-
-#include "../../../Common/MyString.h"
-
-UString GetDefaultName2(const UString &fileName,
- const UString &extension, const UString &addSubExtension);
-
-#endif
+// DefaultName.h
+
+#ifndef ZIP7_INC_DEFAULT_NAME_H
+#define ZIP7_INC_DEFAULT_NAME_H
+
+#include "../../../Common/MyString.h"
+
+UString GetDefaultName2(const UString &fileName,
+ const UString &extension, const UString &addSubExtension);
+
+#endif
diff --git a/CPP/7zip/UI/Common/DirItem.h b/CPP/7zip/UI/Common/DirItem.h
index 47485be..ae84937 100644
--- a/CPP/7zip/UI/Common/DirItem.h
+++ b/CPP/7zip/UI/Common/DirItem.h
@@ -1,190 +1,404 @@
-// DirItem.h
-
-#ifndef __DIR_ITEM_H
-#define __DIR_ITEM_H
-
-#include "../../../Common/MyString.h"
-
-#include "../../../Windows/FileFind.h"
-
-#include "../../Common/UniqBlocks.h"
-
-#include "../../Archive/IArchive.h"
-
-struct CDirItemsStat
-{
- UInt64 NumDirs;
- UInt64 NumFiles;
- UInt64 NumAltStreams;
- UInt64 FilesSize;
- UInt64 AltStreamsSize;
-
- UInt64 NumErrors;
-
- // UInt64 Get_NumItems() const { return NumDirs + NumFiles + NumAltStreams; }
- UInt64 Get_NumDataItems() const { return NumFiles + NumAltStreams; }
- UInt64 GetTotalBytes() const { return FilesSize + AltStreamsSize; }
-
- bool IsEmpty() const { return
- 0 == NumDirs
- && 0 == NumFiles
- && 0 == NumAltStreams
- && 0 == FilesSize
- && 0 == AltStreamsSize
- && 0 == NumErrors; }
-
- CDirItemsStat():
- NumDirs(0),
- NumFiles(0),
- NumAltStreams(0),
- FilesSize(0),
- AltStreamsSize(0),
- NumErrors(0)
- {}
-};
-
-
-struct CDirItemsStat2: public CDirItemsStat
-{
- UInt64 Anti_NumDirs;
- UInt64 Anti_NumFiles;
- UInt64 Anti_NumAltStreams;
-
- // UInt64 Get_NumItems() const { return Anti_NumDirs + Anti_NumFiles + Anti_NumAltStreams + CDirItemsStat::Get_NumItems(); }
- UInt64 Get_NumDataItems2() const { return Anti_NumFiles + Anti_NumAltStreams + CDirItemsStat::Get_NumDataItems(); }
-
- bool IsEmpty() const { return CDirItemsStat::IsEmpty()
- && 0 == Anti_NumDirs
- && 0 == Anti_NumFiles
- && 0 == Anti_NumAltStreams; }
-
- CDirItemsStat2():
- Anti_NumDirs(0),
- Anti_NumFiles(0),
- Anti_NumAltStreams(0)
- {}
-};
-
-
-
-#define INTERFACE_IDirItemsCallback(x) \
- virtual HRESULT ScanError(const FString &path, DWORD systemError) x; \
- virtual HRESULT ScanProgress(const CDirItemsStat &st, const FString &path, bool isDir) x; \
-
-struct IDirItemsCallback
-{
- INTERFACE_IDirItemsCallback(=0)
-};
-
-struct CDirItem
-{
- UInt64 Size;
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
- UString Name;
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- // UString ShortName;
- CByteBuffer ReparseData;
- CByteBuffer ReparseData2; // fixed (reduced) absolute links
-
- bool AreReparseData() const { return ReparseData.Size() != 0 || ReparseData2.Size() != 0; }
- #endif
-
- UInt32 Attrib;
- int PhyParent;
- int LogParent;
- int SecureIndex;
-
- bool IsAltStream;
-
- CDirItem(): PhyParent(-1), LogParent(-1), SecureIndex(-1), IsAltStream(false) {}
- bool IsDir() const { return (Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 ; }
-};
-
-class CDirItems
-{
- UStringVector Prefixes;
- CIntVector PhyParents;
- CIntVector LogParents;
-
- UString GetPrefixesPath(const CIntVector &parents, int index, const UString &name) const;
-
- HRESULT EnumerateDir(int phyParent, int logParent, const FString &phyPrefix);
-
-public:
- CObjectVector<CDirItem> Items;
-
- bool SymLinks;
-
- bool ScanAltStreams;
-
- CDirItemsStat Stat;
-
- #ifndef UNDER_CE
- HRESULT SetLinkInfo(CDirItem &dirItem, const NWindows::NFile::NFind::CFileInfo &fi,
- const FString &phyPrefix);
- #endif
-
-
- #if defined(_WIN32) && !defined(UNDER_CE)
-
- CUniqBlocks SecureBlocks;
- CByteBuffer TempSecureBuf;
- bool _saclEnabled;
- bool ReadSecure;
-
- HRESULT AddSecurityItem(const FString &path, int &secureIndex);
-
- #endif
-
- IDirItemsCallback *Callback;
-
- CDirItems();
-
- void AddDirFileInfo(int phyParent, int logParent, int secureIndex,
- const NWindows::NFile::NFind::CFileInfo &fi);
-
- HRESULT AddError(const FString &path, DWORD errorCode);
- HRESULT AddError(const FString &path);
-
- HRESULT ScanProgress(const FString &path);
-
- // unsigned GetNumFolders() const { return Prefixes.Size(); }
- FString GetPhyPath(unsigned index) const;
- UString GetLogPath(unsigned index) const;
-
- unsigned AddPrefix(int phyParent, int logParent, const UString &prefix);
- void DeleteLastPrefix();
-
- HRESULT EnumerateItems2(
- const FString &phyPrefix,
- const UString &logPrefix,
- const FStringVector &filePaths,
- FStringVector *requestedPaths);
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- void FillFixedReparse();
- #endif
-
- void ReserveDown();
-};
-
-struct CArcItem
-{
- UInt64 Size;
- FILETIME MTime;
- UString Name;
- bool IsDir;
- bool IsAltStream;
- bool SizeDefined;
- bool MTimeDefined;
- bool Censored;
- UInt32 IndexInServer;
- int TimeType;
-
- CArcItem(): IsDir(false), IsAltStream(false), SizeDefined(false), MTimeDefined(false), Censored(false), TimeType(-1) {}
-};
-
-#endif
+// DirItem.h
+
+#ifndef ZIP7_INC_DIR_ITEM_H
+#define ZIP7_INC_DIR_ITEM_H
+
+#ifdef _WIN32
+#include "../../../Common/MyLinux.h"
+#endif
+
+#include "../../../Common/MyString.h"
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/UniqBlocks.h"
+
+#include "../../Archive/IArchive.h"
+
+struct CDirItemsStat
+{
+ UInt64 NumDirs;
+ UInt64 NumFiles;
+ UInt64 NumAltStreams;
+ UInt64 FilesSize;
+ UInt64 AltStreamsSize;
+
+ UInt64 NumErrors;
+
+ // UInt64 Get_NumItems() const { return NumDirs + NumFiles + NumAltStreams; }
+ UInt64 Get_NumDataItems() const { return NumFiles + NumAltStreams; }
+ UInt64 GetTotalBytes() const { return FilesSize + AltStreamsSize; }
+
+ bool IsEmpty() const { return
+ 0 == NumDirs
+ && 0 == NumFiles
+ && 0 == NumAltStreams
+ && 0 == FilesSize
+ && 0 == AltStreamsSize
+ && 0 == NumErrors; }
+
+ CDirItemsStat():
+ NumDirs(0),
+ NumFiles(0),
+ NumAltStreams(0),
+ FilesSize(0),
+ AltStreamsSize(0),
+ NumErrors(0)
+ {}
+};
+
+
+struct CDirItemsStat2: public CDirItemsStat
+{
+ UInt64 Anti_NumDirs;
+ UInt64 Anti_NumFiles;
+ UInt64 Anti_NumAltStreams;
+
+ // UInt64 Get_NumItems() const { return Anti_NumDirs + Anti_NumFiles + Anti_NumAltStreams + CDirItemsStat::Get_NumItems(); }
+ UInt64 Get_NumDataItems2() const { return Anti_NumFiles + Anti_NumAltStreams + CDirItemsStat::Get_NumDataItems(); }
+
+ bool IsEmpty() const { return CDirItemsStat::IsEmpty()
+ && 0 == Anti_NumDirs
+ && 0 == Anti_NumFiles
+ && 0 == Anti_NumAltStreams; }
+
+ CDirItemsStat2():
+ Anti_NumDirs(0),
+ Anti_NumFiles(0),
+ Anti_NumAltStreams(0)
+ {}
+};
+
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACEN_IDirItemsCallback(x) \
+ virtual HRESULT ScanError(const FString &path, DWORD systemError) x \
+ virtual HRESULT ScanProgress(const CDirItemsStat &st, const FString &path, bool isDir) x \
+
+Z7_IFACE_DECL_PURE(IDirItemsCallback)
+
+Z7_PURE_INTERFACES_END
+
+
+struct CArcTime
+{
+ FILETIME FT;
+ UInt16 Prec;
+ Byte Ns100;
+ bool Def;
+
+ CArcTime()
+ {
+ Clear();
+ }
+
+ void Clear()
+ {
+ FT.dwHighDateTime = FT.dwLowDateTime = 0;
+ Prec = 0;
+ Ns100 = 0;
+ Def = false;
+ }
+
+ bool IsZero() const
+ {
+ return FT.dwLowDateTime == 0 && FT.dwHighDateTime == 0 && Ns100 == 0;
+ }
+
+ int CompareWith(const CArcTime &a) const
+ {
+ const int res = CompareFileTime(&FT, &a.FT);
+ if (res != 0)
+ return res;
+ if (Ns100 < a.Ns100) return -1;
+ if (Ns100 > a.Ns100) return 1;
+ return 0;
+ }
+
+ UInt64 Get_FILETIME_as_UInt64() const
+ {
+ return (((UInt64)FT.dwHighDateTime) << 32) + FT.dwLowDateTime;
+ }
+
+ UInt32 Get_DosTime() const
+ {
+ FILETIME ft2 = FT;
+ if ((Prec == k_PropVar_TimePrec_Base + 8 ||
+ Prec == k_PropVar_TimePrec_Base + 9)
+ && Ns100 != 0)
+ {
+ UInt64 u64 = Get_FILETIME_as_UInt64();
+ // we round up even small (ns < 100ns) as FileTimeToDosTime()
+ if (u64 % 20000000 == 0)
+ {
+ u64++;
+ ft2.dwHighDateTime = (DWORD)(u64 >> 32);
+ ft2.dwHighDateTime = (DWORD)u64;
+ }
+ }
+ // FileTimeToDosTime() is expected to round up in Windows
+ UInt32 dosTime;
+ // we use simplified code with utctime->dos.
+ // do we need local time instead here?
+ NWindows::NTime::FileTime_To_DosTime(ft2, dosTime);
+ return dosTime;
+ }
+
+ int GetNumDigits() const
+ {
+ if (Prec == k_PropVar_TimePrec_Unix ||
+ Prec == k_PropVar_TimePrec_DOS)
+ return 0;
+ if (Prec == k_PropVar_TimePrec_HighPrec)
+ return 9;
+ if (Prec == k_PropVar_TimePrec_0)
+ return 7;
+ int digits = (int)Prec - (int)k_PropVar_TimePrec_Base;
+ if (digits < 0)
+ digits = 0;
+ return digits;
+ }
+
+ void Write_To_FiTime(CFiTime &dest) const
+ {
+ #ifdef _WIN32
+ dest = FT;
+ #else
+ if (FILETIME_To_timespec(FT, dest))
+ if ((Prec == k_PropVar_TimePrec_Base + 8 ||
+ Prec == k_PropVar_TimePrec_Base + 9)
+ && Ns100 != 0)
+ {
+ dest.tv_nsec += Ns100;
+ }
+ #endif
+ }
+
+ // (Def) is not set
+ void Set_From_FILETIME(const FILETIME &ft)
+ {
+ FT = ft;
+ // Prec = k_PropVar_TimePrec_CompatNTFS;
+ Prec = k_PropVar_TimePrec_Base + 7;
+ Ns100 = 0;
+ }
+
+ // (Def) is not set
+ // it set full form precision: k_PropVar_TimePrec_Base + numDigits
+ void Set_From_FiTime(const CFiTime &ts)
+ {
+ #ifdef _WIN32
+ FT = ts;
+ Prec = k_PropVar_TimePrec_Base + 7;
+ // Prec = k_PropVar_TimePrec_Base; // for debug
+ // Prec = 0; // for debug
+ Ns100 = 0;
+ #else
+ unsigned ns100;
+ FiTime_To_FILETIME_ns100(ts, FT, ns100);
+ Ns100 = (Byte)ns100;
+ Prec = k_PropVar_TimePrec_Base + 9;
+ #endif
+ }
+
+ void Set_From_Prop(const PROPVARIANT &prop)
+ {
+ FT = prop.filetime;
+ unsigned prec = 0;
+ unsigned ns100 = 0;
+ const unsigned prec_Temp = prop.wReserved1;
+ if (prec_Temp != 0
+ && prec_Temp <= k_PropVar_TimePrec_1ns
+ && prop.wReserved3 == 0)
+ {
+ const unsigned ns100_Temp = prop.wReserved2;
+ if (ns100_Temp < 100)
+ {
+ ns100 = ns100_Temp;
+ prec = prec_Temp;
+ }
+ }
+ Prec = (UInt16)prec;
+ Ns100 = (Byte)ns100;
+ Def = true;
+ }
+};
+
+
+struct CDirItem: public NWindows::NFile::NFind::CFileInfoBase
+{
+ UString Name;
+
+ #ifndef UNDER_CE
+ CByteBuffer ReparseData;
+
+ #ifdef _WIN32
+ // UString ShortName;
+ CByteBuffer ReparseData2; // fixed (reduced) absolute links for WIM format
+ bool AreReparseData() const { return ReparseData.Size() != 0 || ReparseData2.Size() != 0; }
+ #else
+ bool AreReparseData() const { return ReparseData.Size() != 0; }
+ #endif // _WIN32
+
+ #endif // !UNDER_CE
+
+ void Copy_From_FileInfoBase(const NWindows::NFile::NFind::CFileInfoBase &fi)
+ {
+ (NWindows::NFile::NFind::CFileInfoBase &)*this = fi;
+ }
+
+ int PhyParent;
+ int LogParent;
+ int SecureIndex;
+
+ #ifdef _WIN32
+ #else
+ int OwnerNameIndex;
+ int OwnerGroupIndex;
+ #endif
+
+ CDirItem():
+ PhyParent(-1)
+ , LogParent(-1)
+ , SecureIndex(-1)
+ #ifdef _WIN32
+ #else
+ , OwnerNameIndex(-1)
+ , OwnerGroupIndex(-1)
+ #endif
+ {
+ }
+
+
+ CDirItem(const NWindows::NFile::NFind::CFileInfo &fi,
+ int phyParent, int logParent, int secureIndex):
+ CFileInfoBase(fi)
+ , Name(fs2us(fi.Name))
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // , ShortName(fs2us(fi.ShortName))
+ #endif
+ , PhyParent(phyParent)
+ , LogParent(logParent)
+ , SecureIndex(secureIndex)
+ #ifdef _WIN32
+ #else
+ , OwnerNameIndex(-1)
+ , OwnerGroupIndex(-1)
+ #endif
+ {}
+};
+
+
+
+class CDirItems
+{
+ UStringVector Prefixes;
+ CIntVector PhyParents;
+ CIntVector LogParents;
+
+ UString GetPrefixesPath(const CIntVector &parents, int index, const UString &name) const;
+
+ HRESULT EnumerateDir(int phyParent, int logParent, const FString &phyPrefix);
+
+public:
+ CObjectVector<CDirItem> Items;
+
+ bool SymLinks;
+ bool ScanAltStreams;
+ bool ExcludeDirItems;
+ bool ExcludeFileItems;
+ bool ShareForWrite;
+
+ /* it must be called after anotrher checks */
+ bool CanIncludeItem(bool isDir) const
+ {
+ return isDir ? !ExcludeDirItems : !ExcludeFileItems;
+ }
+
+
+ CDirItemsStat Stat;
+
+ #if !defined(UNDER_CE)
+ HRESULT SetLinkInfo(CDirItem &dirItem, const NWindows::NFile::NFind::CFileInfo &fi,
+ const FString &phyPrefix);
+ #endif
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+
+ CUniqBlocks SecureBlocks;
+ CByteBuffer TempSecureBuf;
+ bool _saclEnabled;
+ bool ReadSecure;
+
+ HRESULT AddSecurityItem(const FString &path, int &secureIndex);
+ HRESULT FillFixedReparse();
+
+ #endif
+
+ #ifndef _WIN32
+
+ C_UInt32_UString_Map OwnerNameMap;
+ C_UInt32_UString_Map OwnerGroupMap;
+ bool StoreOwnerName;
+
+ HRESULT FillDeviceSizes();
+
+ #endif
+
+ IDirItemsCallback *Callback;
+
+ CDirItems();
+
+ void AddDirFileInfo(int phyParent, int logParent, int secureIndex,
+ const NWindows::NFile::NFind::CFileInfo &fi);
+
+ HRESULT AddError(const FString &path, DWORD errorCode);
+ HRESULT AddError(const FString &path);
+
+ HRESULT ScanProgress(const FString &path);
+
+ // unsigned GetNumFolders() const { return Prefixes.Size(); }
+ FString GetPhyPath(unsigned index) const;
+ UString GetLogPath(unsigned index) const;
+
+ unsigned AddPrefix(int phyParent, int logParent, const UString &prefix);
+ void DeleteLastPrefix();
+
+ // HRESULT EnumerateOneDir(const FString &phyPrefix, CObjectVector<NWindows::NFile::NFind::CDirEntry> &files);
+ HRESULT EnumerateOneDir(const FString &phyPrefix, CObjectVector<NWindows::NFile::NFind::CFileInfo> &files);
+
+ HRESULT EnumerateItems2(
+ const FString &phyPrefix,
+ const UString &logPrefix,
+ const FStringVector &filePaths,
+ FStringVector *requestedPaths);
+
+ void ReserveDown();
+};
+
+
+
+
+struct CArcItem
+{
+ UInt64 Size;
+ UString Name;
+ CArcTime MTime; // it can be mtime of archive file, if MTime is not defined for item in archive
+ bool IsDir;
+ bool IsAltStream;
+ bool Size_Defined;
+ bool Censored;
+ UInt32 IndexInServer;
+
+ CArcItem():
+ IsDir(false),
+ IsAltStream(false),
+ Size_Defined(false),
+ Censored(false)
+ {}
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/EnumDirItems.cpp b/CPP/7zip/UI/Common/EnumDirItems.cpp
index 2c941e1..d536c47 100644
--- a/CPP/7zip/UI/Common/EnumDirItems.cpp
+++ b/CPP/7zip/UI/Common/EnumDirItems.cpp
@@ -1,1096 +1,1656 @@
-// EnumDirItems.cpp
-
-#include "StdAfx.h"
-
-#include <wchar.h>
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileIO.h"
-#include "../../../Windows/FileName.h"
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-#define _USE_SECURITY_CODE
-#include "../../../Windows/SecurityUtils.h"
-#endif
-
-#include "EnumDirItems.h"
-#include "SortUtils.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NName;
-
-void CDirItems::AddDirFileInfo(int phyParent, int logParent, int secureIndex,
- const NFind::CFileInfo &fi)
-{
- CDirItem di;
- di.Size = fi.Size;
- di.CTime = fi.CTime;
- di.ATime = fi.ATime;
- di.MTime = fi.MTime;
- di.Attrib = fi.Attrib;
- di.IsAltStream = fi.IsAltStream;
- di.PhyParent = phyParent;
- di.LogParent = logParent;
- di.SecureIndex = secureIndex;
- di.Name = fs2us(fi.Name);
- #if defined(_WIN32) && !defined(UNDER_CE)
- // di.ShortName = fs2us(fi.ShortName);
- #endif
- Items.Add(di);
-
- if (fi.IsDir())
- Stat.NumDirs++;
- else if (fi.IsAltStream)
- {
- Stat.NumAltStreams++;
- Stat.AltStreamsSize += fi.Size;
- }
- else
- {
- Stat.NumFiles++;
- Stat.FilesSize += fi.Size;
- }
-}
-
-HRESULT CDirItems::AddError(const FString &path, DWORD errorCode)
-{
- Stat.NumErrors++;
- if (Callback)
- return Callback->ScanError(path, errorCode);
- return S_OK;
-}
-
-HRESULT CDirItems::AddError(const FString &path)
-{
- return AddError(path, ::GetLastError());
-}
-
-static const unsigned kScanProgressStepMask = (1 << 12) - 1;
-
-HRESULT CDirItems::ScanProgress(const FString &dirPath)
-{
- if (Callback)
- return Callback->ScanProgress(Stat, dirPath, true);
- return S_OK;
-}
-
-UString CDirItems::GetPrefixesPath(const CIntVector &parents, int index, const UString &name) const
-{
- UString path;
- unsigned len = name.Len();
-
- int i;
- for (i = index; i >= 0; i = parents[i])
- len += Prefixes[i].Len();
-
- wchar_t *p = path.GetBuf_SetEnd(len) + len;
-
- p -= name.Len();
- wmemcpy(p, (const wchar_t *)name, name.Len());
-
- for (i = index; i >= 0; i = parents[i])
- {
- const UString &s = Prefixes[i];
- p -= s.Len();
- wmemcpy(p, (const wchar_t *)s, s.Len());
- }
-
- return path;
-}
-
-FString CDirItems::GetPhyPath(unsigned index) const
-{
- const CDirItem &di = Items[index];
- return us2fs(GetPrefixesPath(PhyParents, di.PhyParent, di.Name));
-}
-
-UString CDirItems::GetLogPath(unsigned index) const
-{
- const CDirItem &di = Items[index];
- return GetPrefixesPath(LogParents, di.LogParent, di.Name);
-}
-
-void CDirItems::ReserveDown()
-{
- Prefixes.ReserveDown();
- PhyParents.ReserveDown();
- LogParents.ReserveDown();
- Items.ReserveDown();
-}
-
-unsigned CDirItems::AddPrefix(int phyParent, int logParent, const UString &prefix)
-{
- PhyParents.Add(phyParent);
- LogParents.Add(logParent);
- return Prefixes.Add(prefix);
-}
-
-void CDirItems::DeleteLastPrefix()
-{
- PhyParents.DeleteBack();
- LogParents.DeleteBack();
- Prefixes.DeleteBack();
-}
-
-bool InitLocalPrivileges();
-
-CDirItems::CDirItems():
- SymLinks(false),
- ScanAltStreams(false)
- #ifdef _USE_SECURITY_CODE
- , ReadSecure(false)
- #endif
- , Callback(NULL)
-{
- #ifdef _USE_SECURITY_CODE
- _saclEnabled = InitLocalPrivileges();
- #endif
-}
-
-#ifdef _USE_SECURITY_CODE
-
-HRESULT CDirItems::AddSecurityItem(const FString &path, int &secureIndex)
-{
- secureIndex = -1;
-
- SECURITY_INFORMATION securInfo =
- DACL_SECURITY_INFORMATION |
- GROUP_SECURITY_INFORMATION |
- OWNER_SECURITY_INFORMATION;
- if (_saclEnabled)
- securInfo |= SACL_SECURITY_INFORMATION;
-
- DWORD errorCode = 0;
- DWORD secureSize;
-
- BOOL res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
-
- if (res)
- {
- if (secureSize == 0)
- return S_OK;
- if (secureSize > TempSecureBuf.Size())
- errorCode = ERROR_INVALID_FUNCTION;
- }
- else
- {
- errorCode = GetLastError();
- if (errorCode == ERROR_INSUFFICIENT_BUFFER)
- {
- if (secureSize <= TempSecureBuf.Size())
- errorCode = ERROR_INVALID_FUNCTION;
- else
- {
- TempSecureBuf.Alloc(secureSize);
- res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
- if (res)
- {
- if (secureSize != TempSecureBuf.Size())
- errorCode = ERROR_INVALID_FUNCTION;;
- }
- else
- errorCode = GetLastError();
- }
- }
- }
-
- if (res)
- {
- secureIndex = SecureBlocks.AddUniq(TempSecureBuf, secureSize);
- return S_OK;
- }
-
- if (errorCode == 0)
- errorCode = ERROR_INVALID_FUNCTION;
- return AddError(path, errorCode);
-}
-
-#endif
-
-HRESULT CDirItems::EnumerateDir(int phyParent, int logParent, const FString &phyPrefix)
-{
- RINOK(ScanProgress(phyPrefix));
-
- NFind::CEnumerator enumerator;
- enumerator.SetDirPrefix(phyPrefix);
- for (unsigned ttt = 0; ; ttt++)
- {
- NFind::CFileInfo fi;
- bool found;
- if (!enumerator.Next(fi, found))
- {
- return AddError(phyPrefix);
- }
- if (!found)
- return S_OK;
-
- int secureIndex = -1;
- #ifdef _USE_SECURITY_CODE
- if (ReadSecure)
- {
- RINOK(AddSecurityItem(phyPrefix + fi.Name, secureIndex));
- }
- #endif
-
- AddDirFileInfo(phyParent, logParent, secureIndex, fi);
-
- if (Callback && (ttt & kScanProgressStepMask) == kScanProgressStepMask)
- {
- RINOK(ScanProgress(phyPrefix));
- }
-
- if (fi.IsDir())
- {
- const FString name2 = fi.Name + FCHAR_PATH_SEPARATOR;
- unsigned parent = AddPrefix(phyParent, logParent, fs2us(name2));
- RINOK(EnumerateDir(parent, parent, phyPrefix + name2));
- }
- }
-}
-
-HRESULT CDirItems::EnumerateItems2(
- const FString &phyPrefix,
- const UString &logPrefix,
- const FStringVector &filePaths,
- FStringVector *requestedPaths)
-{
- int phyParent = phyPrefix.IsEmpty() ? -1 : AddPrefix(-1, -1, fs2us(phyPrefix));
- int logParent = logPrefix.IsEmpty() ? -1 : AddPrefix(-1, -1, logPrefix);
-
- FOR_VECTOR (i, filePaths)
- {
- const FString &filePath = filePaths[i];
- NFind::CFileInfo fi;
- const FString phyPath = phyPrefix + filePath;
- if (!fi.Find(phyPath))
- {
- RINOK(AddError(phyPath));
- continue;
- }
- if (requestedPaths)
- requestedPaths->Add(phyPath);
-
- int delimiter = filePath.ReverseFind_PathSepar();
- FString phyPrefixCur;
- int phyParentCur = phyParent;
- if (delimiter >= 0)
- {
- phyPrefixCur.SetFrom(filePath, delimiter + 1);
- phyParentCur = AddPrefix(phyParent, logParent, fs2us(phyPrefixCur));
- }
-
- int secureIndex = -1;
- #ifdef _USE_SECURITY_CODE
- if (ReadSecure)
- {
- RINOK(AddSecurityItem(phyPath, secureIndex));
- }
- #endif
-
- AddDirFileInfo(phyParentCur, logParent, secureIndex, fi);
-
- if (fi.IsDir())
- {
- const FString name2 = fi.Name + FCHAR_PATH_SEPARATOR;
- unsigned parent = AddPrefix(phyParentCur, logParent, fs2us(name2));
- RINOK(EnumerateDir(parent, parent, phyPrefix + phyPrefixCur + name2));
- }
- }
-
- ReserveDown();
- return S_OK;
-}
-
-
-
-
-
-
-static HRESULT EnumerateDirItems(
- const NWildcard::CCensorNode &curNode,
- int phyParent, int logParent, const FString &phyPrefix,
- const UStringVector &addArchivePrefix,
- CDirItems &dirItems,
- bool enterToSubFolders);
-
-static HRESULT EnumerateDirItems_Spec(
- const NWildcard::CCensorNode &curNode,
- int phyParent, int logParent, const FString &curFolderName,
- const FString &phyPrefix,
- const UStringVector &addArchivePrefix,
- CDirItems &dirItems,
- bool enterToSubFolders)
-{
- const FString name2 = curFolderName + FCHAR_PATH_SEPARATOR;
- unsigned parent = dirItems.AddPrefix(phyParent, logParent, fs2us(name2));
- unsigned numItems = dirItems.Items.Size();
- HRESULT res = EnumerateDirItems(
- curNode, parent, parent, phyPrefix + name2,
- addArchivePrefix, dirItems, enterToSubFolders);
- if (numItems == dirItems.Items.Size())
- dirItems.DeleteLastPrefix();
- return res;
-}
-
-#ifndef UNDER_CE
-
-#ifdef _WIN32
-
-static HRESULT EnumerateAltStreams(
- const NFind::CFileInfo &fi,
- const NWildcard::CCensorNode &curNode,
- int phyParent, int logParent, const FString &fullPath,
- const UStringVector &addArchivePrefix, // prefix from curNode
- bool addAllItems,
- CDirItems &dirItems)
-{
- NFind::CStreamEnumerator enumerator(fullPath);
- for (;;)
- {
- NFind::CStreamInfo si;
- bool found;
- if (!enumerator.Next(si, found))
- {
- return dirItems.AddError(fullPath + FTEXT(":*")); // , (DWORD)E_FAIL
- }
- if (!found)
- return S_OK;
- if (si.IsMainStream())
- continue;
- UStringVector addArchivePrefixNew = addArchivePrefix;
- UString reducedName = si.GetReducedName();
- addArchivePrefixNew.Back() += reducedName;
- if (curNode.CheckPathToRoot(false, addArchivePrefixNew, true))
- continue;
- if (!addAllItems)
- if (!curNode.CheckPathToRoot(true, addArchivePrefixNew, true))
- continue;
-
- NFind::CFileInfo fi2 = fi;
- fi2.Name += us2fs(reducedName);
- fi2.Size = si.Size;
- fi2.Attrib &= ~FILE_ATTRIBUTE_DIRECTORY;
- fi2.IsAltStream = true;
- dirItems.AddDirFileInfo(phyParent, logParent, -1, fi2);
- }
-}
-
-#endif
-
-HRESULT CDirItems::SetLinkInfo(CDirItem &dirItem, const NFind::CFileInfo &fi,
- const FString &phyPrefix)
-{
- if (!SymLinks || !fi.HasReparsePoint())
- return S_OK;
- const FString path = phyPrefix + fi.Name;
- CByteBuffer &buf = dirItem.ReparseData;
- DWORD res = 0;
- if (NIO::GetReparseData(path, buf))
- {
- CReparseAttr attr;
- if (attr.Parse(buf, buf.Size(), res))
- return S_OK;
- // we ignore unknown reparse points
- if (res != ERROR_INVALID_REPARSE_DATA)
- res = 0;
- }
- else
- {
- res = ::GetLastError();
- if (res == 0)
- res = ERROR_INVALID_FUNCTION;
- }
-
- buf.Free();
- if (res == 0)
- return S_OK;
- return AddError(path, res);
-}
-
-#endif
-
-static HRESULT EnumerateForItem(
- NFind::CFileInfo &fi,
- const NWildcard::CCensorNode &curNode,
- int phyParent, int logParent, const FString &phyPrefix,
- const UStringVector &addArchivePrefix, // prefix from curNode
- CDirItems &dirItems,
- bool enterToSubFolders)
-{
- const UString name = fs2us(fi.Name);
- bool enterToSubFolders2 = enterToSubFolders;
- UStringVector addArchivePrefixNew = addArchivePrefix;
- addArchivePrefixNew.Add(name);
- {
- UStringVector addArchivePrefixNewTemp(addArchivePrefixNew);
- if (curNode.CheckPathToRoot(false, addArchivePrefixNewTemp, !fi.IsDir()))
- return S_OK;
- }
- int dirItemIndex = -1;
-
- bool addAllSubStreams = false;
-
- if (curNode.CheckPathToRoot(true, addArchivePrefixNew, !fi.IsDir()))
- {
- int secureIndex = -1;
- #ifdef _USE_SECURITY_CODE
- if (dirItems.ReadSecure)
- {
- RINOK(dirItems.AddSecurityItem(phyPrefix + fi.Name, secureIndex));
- }
- #endif
-
- dirItemIndex = dirItems.Items.Size();
- dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
- if (fi.IsDir())
- enterToSubFolders2 = true;
-
- addAllSubStreams = true;
- }
-
- #ifndef UNDER_CE
- if (dirItems.ScanAltStreams)
- {
- RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
- phyPrefix + fi.Name,
- addArchivePrefixNew,
- addAllSubStreams,
- dirItems));
- }
-
- if (dirItemIndex >= 0)
- {
- CDirItem &dirItem = dirItems.Items[dirItemIndex];
- RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix));
- if (dirItem.ReparseData.Size() != 0)
- return S_OK;
- }
- #endif
-
- if (!fi.IsDir())
- return S_OK;
-
- const NWildcard::CCensorNode *nextNode = 0;
- if (addArchivePrefix.IsEmpty())
- {
- int index = curNode.FindSubNode(name);
- if (index >= 0)
- nextNode = &curNode.SubNodes[index];
- }
- if (!enterToSubFolders2 && nextNode == 0)
- return S_OK;
-
- addArchivePrefixNew = addArchivePrefix;
- if (nextNode == 0)
- {
- nextNode = &curNode;
- addArchivePrefixNew.Add(name);
- }
-
- return EnumerateDirItems_Spec(
- *nextNode, phyParent, logParent, fi.Name, phyPrefix,
- addArchivePrefixNew,
- dirItems,
- enterToSubFolders2);
-}
-
-
-static bool CanUseFsDirect(const NWildcard::CCensorNode &curNode)
-{
- FOR_VECTOR (i, curNode.IncludeItems)
- {
- const NWildcard::CItem &item = curNode.IncludeItems[i];
- if (item.Recursive || item.PathParts.Size() != 1)
- return false;
- const UString &name = item.PathParts.Front();
- /*
- if (name.IsEmpty())
- return false;
- */
-
- /* Windows doesn't support file name with wildcard
- But if another system supports file name with wildcard,
- and wildcard mode is disabled, we can ignore wildcard in name */
- /*
- if (!item.WildcardParsing)
- continue;
- */
- if (DoesNameContainWildcard(name))
- return false;
- }
- return true;
-}
-
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-static bool IsVirtualFsFolder(const FString &prefix, const UString &name)
-{
- UString s = fs2us(prefix);
- s += name;
- s.Add_PathSepar();
- return IsPathSepar(s[0]) && GetRootPrefixSize(s) == 0;
-}
-
-#endif
-
-static HRESULT EnumerateDirItems(
- const NWildcard::CCensorNode &curNode,
- int phyParent, int logParent, const FString &phyPrefix,
- const UStringVector &addArchivePrefix, // prefix from curNode
- CDirItems &dirItems,
- bool enterToSubFolders)
-{
- if (!enterToSubFolders)
- if (curNode.NeedCheckSubDirs())
- enterToSubFolders = true;
-
- RINOK(dirItems.ScanProgress(phyPrefix));
-
- // try direct_names case at first
- if (addArchivePrefix.IsEmpty() && !enterToSubFolders)
- {
- if (CanUseFsDirect(curNode))
- {
- // all names are direct (no wildcards)
- // so we don't need file_system's dir enumerator
- CRecordVector<bool> needEnterVector;
- unsigned i;
-
- for (i = 0; i < curNode.IncludeItems.Size(); i++)
- {
- const NWildcard::CItem &item = curNode.IncludeItems[i];
- const UString &name = item.PathParts.Front();
- FString fullPath = phyPrefix + us2fs(name);
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- bool needAltStreams = true;
- #endif
-
- #ifdef _USE_SECURITY_CODE
- bool needSecurity = true;
- #endif
-
- if (phyPrefix.IsEmpty())
- {
- if (!item.ForFile)
- {
- /* we don't like some names for alt streams inside archive:
- ":sname" for "\"
- "c:::sname" for "C:\"
- So we ignore alt streams for these cases */
- if (name.IsEmpty())
- {
- #if defined(_WIN32) && !defined(UNDER_CE)
- needAltStreams = false;
- #endif
-
- /*
- // do we need to ignore security info for "\\" folder ?
- #ifdef _USE_SECURITY_CODE
- needSecurity = false;
- #endif
- */
-
- fullPath = CHAR_PATH_SEPARATOR;
- }
- #if defined(_WIN32) && !defined(UNDER_CE)
- else if (item.IsDriveItem())
- {
- needAltStreams = false;
- fullPath.Add_PathSepar();
- }
- #endif
- }
- }
-
- NFind::CFileInfo fi;
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (IsVirtualFsFolder(phyPrefix, name))
- {
- fi.SetAsDir();
- fi.Name = us2fs(name);
- }
- else
- #endif
- if (!fi.Find(fullPath))
- {
- RINOK(dirItems.AddError(fullPath));
- continue;
- }
-
- bool isDir = fi.IsDir();
- if (isDir && !item.ForDir || !isDir && !item.ForFile)
- {
- RINOK(dirItems.AddError(fullPath, (DWORD)E_FAIL));
- continue;
- }
- {
- UStringVector pathParts;
- pathParts.Add(fs2us(fi.Name));
- if (curNode.CheckPathToRoot(false, pathParts, !isDir))
- continue;
- }
-
- int secureIndex = -1;
- #ifdef _USE_SECURITY_CODE
- if (needSecurity && dirItems.ReadSecure)
- {
- RINOK(dirItems.AddSecurityItem(fullPath, secureIndex));
- }
- #endif
-
- dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
-
- #ifndef UNDER_CE
- {
- CDirItem &dirItem = dirItems.Items.Back();
- RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix));
- if (dirItem.ReparseData.Size() != 0)
- {
- if (fi.IsAltStream)
- dirItems.Stat.AltStreamsSize -= fi.Size;
- else
- dirItems.Stat.FilesSize -= fi.Size;
- continue;
- }
- }
- #endif
-
-
- #ifndef UNDER_CE
- if (needAltStreams && dirItems.ScanAltStreams)
- {
- UStringVector pathParts;
- pathParts.Add(fs2us(fi.Name));
- RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
- fullPath, pathParts,
- true, /* addAllSubStreams */
- dirItems));
- }
- #endif
-
- if (!isDir)
- continue;
-
- UStringVector addArchivePrefixNew;
- const NWildcard::CCensorNode *nextNode = 0;
- int index = curNode.FindSubNode(name);
- if (index >= 0)
- {
- for (int t = needEnterVector.Size(); t <= index; t++)
- needEnterVector.Add(true);
- needEnterVector[index] = false;
- nextNode = &curNode.SubNodes[index];
- }
- else
- {
- nextNode = &curNode;
- addArchivePrefixNew.Add(name); // don't change it to fi.Name. It's for shortnames support
- }
-
- RINOK(EnumerateDirItems_Spec(*nextNode, phyParent, logParent, fi.Name, phyPrefix,
- addArchivePrefixNew, dirItems, true));
- }
-
- for (i = 0; i < curNode.SubNodes.Size(); i++)
- {
- if (i < needEnterVector.Size())
- if (!needEnterVector[i])
- continue;
- const NWildcard::CCensorNode &nextNode = curNode.SubNodes[i];
- FString fullPath = phyPrefix + us2fs(nextNode.Name);
- NFind::CFileInfo fi;
-
- if (phyPrefix.IsEmpty())
- {
- {
- if (nextNode.Name.IsEmpty())
- fullPath = CHAR_PATH_SEPARATOR;
- #ifdef _WIN32
- else if (NWildcard::IsDriveColonName(nextNode.Name))
- fullPath.Add_PathSepar();
- #endif
- }
- }
-
- // we don't want to call fi.Find() for root folder or virtual folder
- if (phyPrefix.IsEmpty() && nextNode.Name.IsEmpty()
- #if defined(_WIN32) && !defined(UNDER_CE)
- || IsVirtualFsFolder(phyPrefix, nextNode.Name)
- #endif
- )
- {
- fi.SetAsDir();
- fi.Name = us2fs(nextNode.Name);
- }
- else
- {
- if (!fi.Find(fullPath))
- {
- if (!nextNode.AreThereIncludeItems())
- continue;
- RINOK(dirItems.AddError(fullPath));
- continue;
- }
-
- if (!fi.IsDir())
- {
- RINOK(dirItems.AddError(fullPath, (DWORD)E_FAIL));
- continue;
- }
- }
-
- RINOK(EnumerateDirItems_Spec(nextNode, phyParent, logParent, fi.Name, phyPrefix,
- UStringVector(), dirItems, false));
- }
-
- return S_OK;
- }
- }
-
- #ifdef _WIN32
- #ifndef UNDER_CE
-
- // scan drives, if wildcard is "*:\"
-
- if (phyPrefix.IsEmpty() && curNode.IncludeItems.Size() > 0)
- {
- unsigned i;
- for (i = 0; i < curNode.IncludeItems.Size(); i++)
- {
- const NWildcard::CItem &item = curNode.IncludeItems[i];
- if (item.PathParts.Size() < 1)
- break;
- const UString &name = item.PathParts.Front();
- if (name.Len() != 2 || name[1] != ':')
- break;
- if (item.PathParts.Size() == 1)
- if (item.ForFile || !item.ForDir)
- break;
- if (NWildcard::IsDriveColonName(name))
- continue;
- if (name[0] != '*' && name[0] != '?')
- break;
- }
- if (i == curNode.IncludeItems.Size())
- {
- FStringVector driveStrings;
- NFind::MyGetLogicalDriveStrings(driveStrings);
- for (i = 0; i < driveStrings.Size(); i++)
- {
- FString driveName = driveStrings[i];
- if (driveName.Len() < 3 || driveName.Back() != '\\')
- return E_FAIL;
- driveName.DeleteBack();
- NFind::CFileInfo fi;
- fi.SetAsDir();
- fi.Name = driveName;
-
- RINOK(EnumerateForItem(fi, curNode, phyParent, logParent, phyPrefix,
- addArchivePrefix, dirItems, enterToSubFolders));
- }
- return S_OK;
- }
- }
-
- #endif
- #endif
-
- NFind::CEnumerator enumerator;
- enumerator.SetDirPrefix(phyPrefix);
-
- for (unsigned ttt = 0; ; ttt++)
- {
- NFind::CFileInfo fi;
- bool found;
- if (!enumerator.Next(fi, found))
- {
- RINOK(dirItems.AddError(phyPrefix));
- break;
- }
- if (!found)
- break;
-
- if (dirItems.Callback && (ttt & kScanProgressStepMask) == kScanProgressStepMask)
- {
- RINOK(dirItems.ScanProgress(phyPrefix));
- }
-
- RINOK(EnumerateForItem(fi, curNode, phyParent, logParent, phyPrefix,
- addArchivePrefix, dirItems, enterToSubFolders));
- }
-
- return S_OK;
-}
-
-HRESULT EnumerateItems(
- const NWildcard::CCensor &censor,
- const NWildcard::ECensorPathMode pathMode,
- const UString &addPathPrefix,
- CDirItems &dirItems)
-{
- FOR_VECTOR (i, censor.Pairs)
- {
- const NWildcard::CPair &pair = censor.Pairs[i];
- int phyParent = pair.Prefix.IsEmpty() ? -1 : dirItems.AddPrefix(-1, -1, pair.Prefix);
- int logParent = -1;
-
- if (pathMode == NWildcard::k_AbsPath)
- logParent = phyParent;
- else
- {
- if (!addPathPrefix.IsEmpty())
- logParent = dirItems.AddPrefix(-1, -1, addPathPrefix);
- }
-
- RINOK(EnumerateDirItems(pair.Head, phyParent, logParent, us2fs(pair.Prefix), UStringVector(),
- dirItems,
- false // enterToSubFolders
- ));
- }
- dirItems.ReserveDown();
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- dirItems.FillFixedReparse();
- #endif
-
- return S_OK;
-}
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-void CDirItems::FillFixedReparse()
-{
- /* imagex/WIM reduces absolute pathes in links (raparse data),
- if we archive non root folder. We do same thing here */
-
- if (!SymLinks)
- return;
-
- FOR_VECTOR(i, Items)
- {
- CDirItem &item = Items[i];
- if (item.ReparseData.Size() == 0)
- continue;
-
- CReparseAttr attr;
- DWORD errorCode = 0;
- if (!attr.Parse(item.ReparseData, item.ReparseData.Size(), errorCode))
- continue;
- if (attr.IsRelative())
- continue;
-
- const UString &link = attr.GetPath();
- if (!IsDrivePath(link))
- continue;
- // maybe we need to support networks paths also ?
-
- FString fullPathF;
- if (!NDir::MyGetFullPathName(GetPhyPath(i), fullPathF))
- continue;
- UString fullPath = fs2us(fullPathF);
- const UString logPath = GetLogPath(i);
- if (logPath.Len() >= fullPath.Len())
- continue;
- if (CompareFileNames(logPath, fullPath.RightPtr(logPath.Len())) != 0)
- continue;
-
- const UString prefix = fullPath.Left(fullPath.Len() - logPath.Len());
- if (!IsPathSepar(prefix.Back()))
- continue;
-
- unsigned rootPrefixSize = GetRootPrefixSize(prefix);
- if (rootPrefixSize == 0)
- continue;
- if (rootPrefixSize == prefix.Len())
- continue; // simple case: paths are from root
-
- if (link.Len() <= prefix.Len())
- continue;
-
- if (CompareFileNames(link.Left(prefix.Len()), prefix) != 0)
- continue;
-
- UString newLink = prefix.Left(rootPrefixSize);
- newLink += link.Ptr(prefix.Len());
-
- CByteBuffer data;
- if (!FillLinkData(data, newLink, attr.IsSymLink()))
- continue;
- item.ReparseData2 = data;
- }
-}
-
-#endif
-
-
-
-static const char * const kCannotFindArchive = "Cannot find archive";
-
-HRESULT EnumerateDirItemsAndSort(
- NWildcard::CCensor &censor,
- NWildcard::ECensorPathMode censorPathMode,
- const UString &addPathPrefix,
- UStringVector &sortedPaths,
- UStringVector &sortedFullPaths,
- CDirItemsStat &st,
- IDirItemsCallback *callback)
-{
- FStringVector paths;
-
- {
- CDirItems dirItems;
- dirItems.Callback = callback;
- {
- HRESULT res = EnumerateItems(censor, censorPathMode, addPathPrefix, dirItems);
- st = dirItems.Stat;
- RINOK(res);
- }
-
- FOR_VECTOR (i, dirItems.Items)
- {
- const CDirItem &dirItem = dirItems.Items[i];
- if (!dirItem.IsDir())
- paths.Add(dirItems.GetPhyPath(i));
- }
- }
-
- if (paths.Size() == 0)
- {
- // return S_OK;
- throw CMessagePathException(kCannotFindArchive);
- }
-
- UStringVector fullPaths;
-
- unsigned i;
-
- for (i = 0; i < paths.Size(); i++)
- {
- FString fullPath;
- NFile::NDir::MyGetFullPathName(paths[i], fullPath);
- fullPaths.Add(fs2us(fullPath));
- }
-
- CUIntVector indices;
- SortFileNames(fullPaths, indices);
- sortedPaths.ClearAndReserve(indices.Size());
- sortedFullPaths.ClearAndReserve(indices.Size());
-
- for (i = 0; i < indices.Size(); i++)
- {
- unsigned index = indices[i];
- sortedPaths.AddInReserved(fs2us(paths[index]));
- sortedFullPaths.AddInReserved(fullPaths[index]);
- if (i > 0 && CompareFileNames(sortedFullPaths[i], sortedFullPaths[i - 1]) == 0)
- throw CMessagePathException("Duplicate archive path:", sortedFullPaths[i]);
- }
-
- return S_OK;
-}
-
-
-
-
-#ifdef _WIN32
-
-// This code converts all short file names to long file names.
-
-static void ConvertToLongName(const UString &prefix, UString &name)
-{
- if (name.IsEmpty() || DoesNameContainWildcard(name))
- return;
- NFind::CFileInfo fi;
- const FString path (us2fs(prefix + name));
- #ifndef UNDER_CE
- if (NFile::NName::IsDevicePath(path))
- return;
- #endif
- if (fi.Find(path))
- name = fs2us(fi.Name);
-}
-
-static void ConvertToLongNames(const UString &prefix, CObjectVector<NWildcard::CItem> &items)
-{
- FOR_VECTOR (i, items)
- {
- NWildcard::CItem &item = items[i];
- if (item.Recursive || item.PathParts.Size() != 1)
- continue;
- if (prefix.IsEmpty() && item.IsDriveItem())
- continue;
- ConvertToLongName(prefix, item.PathParts.Front());
- }
-}
-
-static void ConvertToLongNames(const UString &prefix, NWildcard::CCensorNode &node)
-{
- ConvertToLongNames(prefix, node.IncludeItems);
- ConvertToLongNames(prefix, node.ExcludeItems);
- unsigned i;
- for (i = 0; i < node.SubNodes.Size(); i++)
- {
- UString &name = node.SubNodes[i].Name;
- if (prefix.IsEmpty() && NWildcard::IsDriveColonName(name))
- continue;
- ConvertToLongName(prefix, name);
- }
- // mix folders with same name
- for (i = 0; i < node.SubNodes.Size(); i++)
- {
- NWildcard::CCensorNode &nextNode1 = node.SubNodes[i];
- for (unsigned j = i + 1; j < node.SubNodes.Size();)
- {
- const NWildcard::CCensorNode &nextNode2 = node.SubNodes[j];
- if (nextNode1.Name.IsEqualTo_NoCase(nextNode2.Name))
- {
- nextNode1.IncludeItems += nextNode2.IncludeItems;
- nextNode1.ExcludeItems += nextNode2.ExcludeItems;
- node.SubNodes.Delete(j);
- }
- else
- j++;
- }
- }
- for (i = 0; i < node.SubNodes.Size(); i++)
- {
- NWildcard::CCensorNode &nextNode = node.SubNodes[i];
- ConvertToLongNames(prefix + nextNode.Name + WCHAR_PATH_SEPARATOR, nextNode);
- }
-}
-
-void ConvertToLongNames(NWildcard::CCensor &censor)
-{
- FOR_VECTOR (i, censor.Pairs)
- {
- NWildcard::CPair &pair = censor.Pairs[i];
- ConvertToLongNames(pair.Prefix, pair.Head);
- }
-}
-
-#endif
-
-
-CMessagePathException::CMessagePathException(const char *a, const wchar_t *u)
-{
- (*this) += a;
- if (u)
- {
- Add_LF();
- (*this) += u;
- }
-}
-
-CMessagePathException::CMessagePathException(const wchar_t *a, const wchar_t *u)
-{
- (*this) += a;
- if (u)
- {
- Add_LF();
- (*this) += u;
- }
-}
+// EnumDirItems.cpp
+
+#include "StdAfx.h"
+
+#include <wchar.h>
+// #include <stdio.h>
+
+#ifndef _WIN32
+#include <grp.h>
+#include <pwd.h>
+#include "../../../Common/UTFConvert.h"
+#endif
+
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+#define Z7_USE_SECURITY_CODE
+#include "../../../Windows/SecurityUtils.h"
+#endif
+
+#include "EnumDirItems.h"
+#include "SortUtils.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+
+static bool FindFile_KeepDots(NFile::NFind::CFileInfo &fi, const FString &path, bool followLink)
+{
+ const bool res = fi.Find(path, followLink);
+ if (!res)
+ return res;
+ if (path.IsEmpty())
+ return res;
+ // we keep name "." and "..", if it's without tail slash
+ const FChar *p = path.RightPtr(1);
+ if (*p != '.')
+ return res;
+ if (p != path.Ptr())
+ {
+ FChar c = p[-1];
+ if (!IS_PATH_SEPAR(c))
+ {
+ if (c != '.')
+ return res;
+ p--;
+ if (p != path.Ptr())
+ {
+ c = p[-1];
+ if (!IS_PATH_SEPAR(c))
+ return res;
+ }
+ }
+ }
+ fi.Name = p;
+ return res;
+}
+
+
+void CDirItems::AddDirFileInfo(int phyParent, int logParent, int secureIndex,
+ const NFind::CFileInfo &fi)
+{
+ /*
+ CDirItem di(fi);
+ di.PhyParent = phyParent;
+ di.LogParent = logParent;
+ di.SecureIndex = secureIndex;
+ Items.Add(di);
+ */
+ VECTOR_ADD_NEW_OBJECT (Items, CDirItem(fi, phyParent, logParent, secureIndex))
+
+ if (fi.IsDir())
+ Stat.NumDirs++;
+ #ifdef _WIN32
+ else if (fi.IsAltStream)
+ {
+ Stat.NumAltStreams++;
+ Stat.AltStreamsSize += fi.Size;
+ }
+ #endif
+ else
+ {
+ Stat.NumFiles++;
+ Stat.FilesSize += fi.Size;
+ }
+}
+
+// (DWORD)E_FAIL
+#define DI_DEFAULT_ERROR ERROR_INVALID_FUNCTION
+
+HRESULT CDirItems::AddError(const FString &path, DWORD errorCode)
+{
+ if (errorCode == 0)
+ errorCode = DI_DEFAULT_ERROR;
+ Stat.NumErrors++;
+ if (Callback)
+ return Callback->ScanError(path, errorCode);
+ return S_OK;
+}
+
+HRESULT CDirItems::AddError(const FString &path)
+{
+ return AddError(path, ::GetLastError());
+}
+
+static const unsigned kScanProgressStepMask = (1 << 12) - 1;
+
+HRESULT CDirItems::ScanProgress(const FString &dirPath)
+{
+ if (Callback)
+ return Callback->ScanProgress(Stat, dirPath, true);
+ return S_OK;
+}
+
+UString CDirItems::GetPrefixesPath(const CIntVector &parents, int index, const UString &name) const
+{
+ UString path;
+ unsigned len = name.Len();
+
+ int i;
+ for (i = index; i >= 0; i = parents[(unsigned)i])
+ len += Prefixes[(unsigned)i].Len();
+
+ wchar_t *p = path.GetBuf_SetEnd(len) + len;
+
+ p -= name.Len();
+ wmemcpy(p, (const wchar_t *)name, name.Len());
+
+ for (i = index; i >= 0; i = parents[(unsigned)i])
+ {
+ const UString &s = Prefixes[(unsigned)i];
+ p -= s.Len();
+ wmemcpy(p, (const wchar_t *)s, s.Len());
+ }
+
+ return path;
+}
+
+FString CDirItems::GetPhyPath(unsigned index) const
+{
+ const CDirItem &di = Items[index];
+ return us2fs(GetPrefixesPath(PhyParents, di.PhyParent, di.Name));
+}
+
+UString CDirItems::GetLogPath(unsigned index) const
+{
+ const CDirItem &di = Items[index];
+ return GetPrefixesPath(LogParents, di.LogParent, di.Name);
+}
+
+void CDirItems::ReserveDown()
+{
+ Prefixes.ReserveDown();
+ PhyParents.ReserveDown();
+ LogParents.ReserveDown();
+ Items.ReserveDown();
+}
+
+unsigned CDirItems::AddPrefix(int phyParent, int logParent, const UString &prefix)
+{
+ PhyParents.Add(phyParent);
+ LogParents.Add(logParent);
+ return Prefixes.Add(prefix);
+}
+
+void CDirItems::DeleteLastPrefix()
+{
+ PhyParents.DeleteBack();
+ LogParents.DeleteBack();
+ Prefixes.DeleteBack();
+}
+
+bool InitLocalPrivileges();
+
+CDirItems::CDirItems():
+ SymLinks(false),
+ ScanAltStreams(false)
+ , ExcludeDirItems(false)
+ , ExcludeFileItems(false)
+ , ShareForWrite(false)
+ #ifdef Z7_USE_SECURITY_CODE
+ , ReadSecure(false)
+ #endif
+ #ifndef _WIN32
+ , StoreOwnerName(false)
+ #endif
+ , Callback(NULL)
+{
+ #ifdef Z7_USE_SECURITY_CODE
+ _saclEnabled = InitLocalPrivileges();
+ #endif
+}
+
+
+#ifdef Z7_USE_SECURITY_CODE
+
+HRESULT CDirItems::AddSecurityItem(const FString &path, int &secureIndex)
+{
+ secureIndex = -1;
+
+ SECURITY_INFORMATION securInfo =
+ DACL_SECURITY_INFORMATION |
+ GROUP_SECURITY_INFORMATION |
+ OWNER_SECURITY_INFORMATION;
+ if (_saclEnabled)
+ securInfo |= SACL_SECURITY_INFORMATION;
+
+ DWORD errorCode = 0;
+ DWORD secureSize;
+
+ BOOL res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(void *)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
+
+ if (res)
+ {
+ if (secureSize == 0)
+ return S_OK;
+ if (secureSize > TempSecureBuf.Size())
+ errorCode = ERROR_INVALID_FUNCTION;
+ }
+ else
+ {
+ errorCode = GetLastError();
+ if (errorCode == ERROR_INSUFFICIENT_BUFFER)
+ {
+ if (secureSize <= TempSecureBuf.Size())
+ errorCode = ERROR_INVALID_FUNCTION;
+ else
+ {
+ TempSecureBuf.Alloc(secureSize);
+ res = ::GetFileSecurityW(fs2us(path), securInfo, (PSECURITY_DESCRIPTOR)(void *)(Byte *)TempSecureBuf, (DWORD)TempSecureBuf.Size(), &secureSize);
+ if (res)
+ {
+ if (secureSize != TempSecureBuf.Size())
+ errorCode = ERROR_INVALID_FUNCTION;
+ }
+ else
+ errorCode = GetLastError();
+ }
+ }
+ }
+
+ if (res)
+ {
+ secureIndex = (int)SecureBlocks.AddUniq(TempSecureBuf, secureSize);
+ return S_OK;
+ }
+
+ return AddError(path, errorCode);
+}
+
+#endif // Z7_USE_SECURITY_CODE
+
+
+HRESULT CDirItems::EnumerateOneDir(const FString &phyPrefix, CObjectVector<NFind::CFileInfo> &files)
+{
+ NFind::CEnumerator enumerator;
+ // printf("\n enumerator.SetDirPrefix(phyPrefix) \n");
+
+ enumerator.SetDirPrefix(phyPrefix);
+
+ #ifdef _WIN32
+
+ NFind::CFileInfo fi;
+
+ for (unsigned ttt = 0; ; ttt++)
+ {
+ bool found;
+ if (!enumerator.Next(fi, found))
+ return AddError(phyPrefix);
+ if (!found)
+ return S_OK;
+ files.Add(fi);
+ if (Callback && (ttt & kScanProgressStepMask) == kScanProgressStepMask)
+ {
+ RINOK(ScanProgress(phyPrefix))
+ }
+ }
+
+ #else // _WIN32
+
+ // enumerator.SolveLinks = !SymLinks;
+
+ CObjectVector<NFind::CDirEntry> entries;
+
+ for (unsigned ttt = 0; ; ttt++)
+ {
+ bool found;
+ NFind::CDirEntry de;
+ if (!enumerator.Next(de, found))
+ {
+ return AddError(phyPrefix);
+ }
+ if (!found)
+ break;
+ entries.Add(de);
+ }
+
+ FOR_VECTOR(i, entries)
+ {
+ const NFind::CDirEntry &de = entries[i];
+ NFind::CFileInfo fi;
+ if (!enumerator.Fill_FileInfo(de, fi, !SymLinks))
+ // if (!fi.Find_AfterEnumerator(path))
+ {
+ const FString path = phyPrefix + de.Name;
+ {
+ RINOK(AddError(path))
+ continue;
+ }
+ }
+
+ files.Add(fi);
+
+ if (Callback && (i & kScanProgressStepMask) == kScanProgressStepMask)
+ {
+ RINOK(ScanProgress(phyPrefix))
+ }
+ }
+
+ return S_OK;
+
+ #endif // _WIN32
+}
+
+
+
+
+HRESULT CDirItems::EnumerateDir(int phyParent, int logParent, const FString &phyPrefix)
+{
+ RINOK(ScanProgress(phyPrefix))
+
+ CObjectVector<NFind::CFileInfo> files;
+ RINOK(EnumerateOneDir(phyPrefix, files))
+
+ FOR_VECTOR (i, files)
+ {
+ #ifdef _WIN32
+ const NFind::CFileInfo &fi = files[i];
+ #else
+ const NFind::CFileInfo &fi = files[i];
+ /*
+ NFind::CFileInfo fi;
+ {
+ const NFind::CDirEntry &di = files[i];
+ const FString path = phyPrefix + di.Name;
+ if (!fi.Find_AfterEnumerator(path))
+ {
+ RINOK(AddError(path));
+ continue;
+ }
+ fi.Name = di.Name;
+ }
+ */
+ #endif
+
+ if (CanIncludeItem(fi.IsDir()))
+ {
+ int secureIndex = -1;
+ #ifdef Z7_USE_SECURITY_CODE
+ if (ReadSecure)
+ {
+ RINOK(AddSecurityItem(phyPrefix + fi.Name, secureIndex))
+ }
+ #endif
+ AddDirFileInfo(phyParent, logParent, secureIndex, fi);
+ }
+
+ if (Callback && (i & kScanProgressStepMask) == kScanProgressStepMask)
+ {
+ RINOK(ScanProgress(phyPrefix))
+ }
+
+ if (fi.IsDir())
+ {
+ const FString name2 = fi.Name + FCHAR_PATH_SEPARATOR;
+ unsigned parent = AddPrefix(phyParent, logParent, fs2us(name2));
+ RINOK(EnumerateDir((int)parent, (int)parent, phyPrefix + name2))
+ }
+ }
+ return S_OK;
+}
+
+
+/*
+EnumerateItems2()
+ const FStringVector &filePaths - are path without tail slashes.
+ All dir prefixes of filePaths will be not stores in logical paths
+fix it: we can scan AltStream also.
+*/
+
+#ifdef _WIN32
+// #define FOLLOW_LINK_PARAM
+// #define FOLLOW_LINK_PARAM2
+#define FOLLOW_LINK_PARAM , (!SymLinks)
+#define FOLLOW_LINK_PARAM2 , (!dirItems.SymLinks)
+#else
+#define FOLLOW_LINK_PARAM , (!SymLinks)
+#define FOLLOW_LINK_PARAM2 , (!dirItems.SymLinks)
+#endif
+
+HRESULT CDirItems::EnumerateItems2(
+ const FString &phyPrefix,
+ const UString &logPrefix,
+ const FStringVector &filePaths,
+ FStringVector *requestedPaths)
+{
+ const int phyParent = phyPrefix.IsEmpty() ? -1 : (int)AddPrefix(-1, -1, fs2us(phyPrefix));
+ const int logParent = logPrefix.IsEmpty() ? -1 : (int)AddPrefix(-1, -1, logPrefix);
+
+ #ifdef _WIN32
+ const bool phyPrefix_isAltStreamPrefix =
+ NFile::NName::IsAltStreamPrefixWithColon(fs2us(phyPrefix));
+ #endif
+
+ FOR_VECTOR (i, filePaths)
+ {
+ const FString &filePath = filePaths[i];
+ NFind::CFileInfo fi;
+ const FString phyPath = phyPrefix + filePath;
+ if (!FindFile_KeepDots(fi, phyPath FOLLOW_LINK_PARAM))
+ {
+ RINOK(AddError(phyPath))
+ continue;
+ }
+ if (requestedPaths)
+ requestedPaths->Add(phyPath);
+
+ const int delimiter = filePath.ReverseFind_PathSepar();
+ FString phyPrefixCur;
+ int phyParentCur = phyParent;
+ if (delimiter >= 0)
+ {
+ phyPrefixCur.SetFrom(filePath, (unsigned)(delimiter + 1));
+ phyParentCur = (int)AddPrefix(phyParent, logParent, fs2us(phyPrefixCur));
+ }
+
+ if (CanIncludeItem(fi.IsDir()))
+ {
+ int secureIndex = -1;
+ #ifdef Z7_USE_SECURITY_CODE
+ if (ReadSecure)
+ {
+ RINOK(AddSecurityItem(phyPath, secureIndex))
+ }
+ #endif
+ #ifdef _WIN32
+ if (phyPrefix_isAltStreamPrefix && fi.IsAltStream)
+ {
+ const int pos = fi.Name.Find(FChar(':'));
+ if (pos >= 0)
+ fi.Name.DeleteFrontal((unsigned)pos + 1);
+ }
+ #endif
+ AddDirFileInfo(phyParentCur, logParent, secureIndex, fi);
+ }
+
+ if (fi.IsDir())
+ {
+ const FString name2 = fi.Name + FCHAR_PATH_SEPARATOR;
+ const unsigned parent = AddPrefix(phyParentCur, logParent, fs2us(name2));
+ RINOK(EnumerateDir((int)parent, (int)parent, phyPrefix + phyPrefixCur + name2))
+ }
+ }
+
+ ReserveDown();
+ return S_OK;
+}
+
+
+
+
+static HRESULT EnumerateDirItems(
+ const NWildcard::CCensorNode &curNode,
+ const int phyParent, const int logParent,
+ const FString &phyPrefix,
+ const UStringVector &addParts, // additional parts from curNode
+ CDirItems &dirItems,
+ bool enterToSubFolders);
+
+
+/* EnumerateDirItems_Spec()
+ adds new Dir item prefix, and enumerates dir items,
+ then it can remove that Dir item prefix, if there are no items in that dir.
+*/
+
+
+/*
+ EnumerateDirItems_Spec()
+ it's similar to EnumerateDirItems, but phyPrefix doesn't include (curFolderName)
+*/
+
+static HRESULT EnumerateDirItems_Spec(
+ const NWildcard::CCensorNode &curNode,
+ const int phyParent, const int logParent, const FString &curFolderName,
+ const FString &phyPrefix, // without (curFolderName)
+ const UStringVector &addParts, // (curNode + addParts) includes (curFolderName)
+ CDirItems &dirItems,
+ bool enterToSubFolders)
+{
+ const FString name2 = curFolderName + FCHAR_PATH_SEPARATOR;
+ const unsigned parent = dirItems.AddPrefix(phyParent, logParent, fs2us(name2));
+ const unsigned numItems = dirItems.Items.Size();
+ HRESULT res = EnumerateDirItems(
+ curNode, (int)parent, (int)parent, phyPrefix + name2,
+ addParts, dirItems, enterToSubFolders);
+ if (numItems == dirItems.Items.Size())
+ dirItems.DeleteLastPrefix();
+ return res;
+}
+
+
+#ifndef UNDER_CE
+
+#ifdef _WIN32
+
+static HRESULT EnumerateAltStreams(
+ const NFind::CFileInfo &fi,
+ const NWildcard::CCensorNode &curNode,
+ const int phyParent, const int logParent,
+ const FString &phyPath, // with (fi.Name), without tail slash for folders
+ const UStringVector &addParts, // with (fi.Name), prefix parts from curNode
+ bool addAllSubStreams,
+ CDirItems &dirItems)
+{
+ // we don't use (ExcludeFileItems) rules for AltStreams
+ // if (dirItems.ExcludeFileItems) return S_OK;
+
+ NFind::CStreamEnumerator enumerator(phyPath);
+ for (;;)
+ {
+ NFind::CStreamInfo si;
+ bool found;
+ if (!enumerator.Next(si, found))
+ {
+ return dirItems.AddError(phyPath + FTEXT(":*")); // , (DWORD)E_FAIL
+ }
+ if (!found)
+ return S_OK;
+ if (si.IsMainStream())
+ continue;
+ UStringVector parts = addParts;
+ const UString reducedName = si.GetReducedName();
+ parts.Back() += reducedName;
+ if (curNode.CheckPathToRoot(false, parts, true))
+ continue;
+ if (!addAllSubStreams)
+ if (!curNode.CheckPathToRoot(true, parts, true))
+ continue;
+
+ NFind::CFileInfo fi2 = fi;
+ fi2.Name += us2fs(reducedName);
+ fi2.Size = si.Size;
+ fi2.Attrib &= ~(DWORD)(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+ fi2.IsAltStream = true;
+ dirItems.AddDirFileInfo(phyParent, logParent, -1, fi2);
+ }
+}
+
+#endif // _WIN32
+
+
+/* We get Reparse data and parse it.
+ If there is Reparse error, we free dirItem.Reparse data.
+ Do we need to work with empty reparse data?
+*/
+
+HRESULT CDirItems::SetLinkInfo(CDirItem &dirItem, const NFind::CFileInfo &fi,
+ const FString &phyPrefix)
+{
+ if (!SymLinks)
+ return S_OK;
+
+ #ifdef _WIN32
+ if (!fi.HasReparsePoint() || fi.IsAltStream)
+ #else // _WIN32
+ if (!fi.IsPosixLink())
+ #endif // _WIN32
+ return S_OK;
+
+ const FString path = phyPrefix + fi.Name;
+ CByteBuffer &buf = dirItem.ReparseData;
+ if (NIO::GetReparseData(path, buf))
+ {
+ // if (dirItem.ReparseData.Size() != 0)
+ Stat.FilesSize -= fi.Size;
+ return S_OK;
+ }
+
+ DWORD res = ::GetLastError();
+ buf.Free();
+ return AddError(path, res);
+}
+
+#endif // UNDER_CE
+
+
+
+static HRESULT EnumerateForItem(
+ const NFind::CFileInfo &fi,
+ const NWildcard::CCensorNode &curNode,
+ const int phyParent, const int logParent, const FString &phyPrefix,
+ const UStringVector &addParts, // additional parts from curNode, without (fi.Name)
+ CDirItems &dirItems,
+ bool enterToSubFolders)
+{
+ const UString name = fs2us(fi.Name);
+ UStringVector newParts = addParts;
+ newParts.Add(name);
+
+ // check the path in exclude rules
+ if (curNode.CheckPathToRoot(false, newParts, !fi.IsDir()))
+ return S_OK;
+
+ #if !defined(UNDER_CE)
+ int dirItemIndex = -1;
+ #if defined(_WIN32)
+ bool addAllSubStreams = false;
+ bool needAltStreams = true;
+ #endif // _WIN32
+ #endif // !defined(UNDER_CE)
+
+ // check the path in inlcude rules
+ if (curNode.CheckPathToRoot(true, newParts, !fi.IsDir()))
+ {
+ #if !defined(UNDER_CE)
+ // dirItemIndex = (int)dirItems.Items.Size();
+ #if defined(_WIN32)
+ // we will not check include rules for substreams.
+ addAllSubStreams = true;
+ #endif // _WIN32
+ #endif // !defined(UNDER_CE)
+
+ if (dirItems.CanIncludeItem(fi.IsDir()))
+ {
+ int secureIndex = -1;
+ #ifdef Z7_USE_SECURITY_CODE
+ if (dirItems.ReadSecure)
+ {
+ RINOK(dirItems.AddSecurityItem(phyPrefix + fi.Name, secureIndex))
+ }
+ #endif
+ #if !defined(UNDER_CE)
+ dirItemIndex = (int)dirItems.Items.Size();
+ #endif // !defined(UNDER_CE)
+ dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
+ }
+ else
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ needAltStreams = false;
+ #endif
+ }
+
+ if (fi.IsDir())
+ enterToSubFolders = true;
+ }
+
+ #if !defined(UNDER_CE)
+
+ // we don't scan AltStreams for link files
+
+ if (dirItemIndex >= 0)
+ {
+ CDirItem &dirItem = dirItems.Items[(unsigned)dirItemIndex];
+ RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix))
+ if (dirItem.ReparseData.Size() != 0)
+ return S_OK;
+ }
+
+ #if defined(_WIN32)
+ if (needAltStreams && dirItems.ScanAltStreams)
+ {
+ RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
+ phyPrefix + fi.Name, // with (fi.Name)
+ newParts, // with (fi.Name)
+ addAllSubStreams,
+ dirItems))
+ }
+ #endif
+
+ #endif // !defined(UNDER_CE)
+
+
+ #ifndef _WIN32
+ if (!fi.IsPosixLink()) // posix link can follow to dir
+ #endif
+ if (!fi.IsDir())
+ return S_OK;
+
+ const NWildcard::CCensorNode *nextNode = NULL;
+
+ if (addParts.IsEmpty())
+ {
+ int index = curNode.FindSubNode(name);
+ if (index >= 0)
+ {
+ nextNode = &curNode.SubNodes[(unsigned)index];
+ newParts.Clear();
+ }
+ }
+
+ if (!nextNode)
+ {
+ if (!enterToSubFolders)
+ return S_OK;
+
+ #ifndef _WIN32
+ if (fi.IsPosixLink())
+ {
+ // here we can try to resolve posix link
+ // if the link to dir, then can we follow it
+ return S_OK; // we don't follow posix link
+ }
+ #else
+ if (dirItems.SymLinks && fi.HasReparsePoint())
+ {
+ /* 20.03: in SymLinks mode: we don't enter to directory that
+ has reparse point and has no CCensorNode
+ NOTE: (curNode and parent nodes) still can have wildcard rules
+ to include some items of target directory (of reparse point),
+ but we ignore these rules here.
+ */
+ return S_OK;
+ }
+ #endif
+ nextNode = &curNode;
+ }
+
+ return EnumerateDirItems_Spec(
+ *nextNode, phyParent, logParent, fi.Name,
+ phyPrefix, // without (fi.Name)
+ newParts, // relative to (*nextNode). (*nextNode + newParts) includes (fi.Name)
+ dirItems,
+ enterToSubFolders);
+}
+
+
+static bool CanUseFsDirect(const NWildcard::CCensorNode &curNode)
+{
+ FOR_VECTOR (i, curNode.IncludeItems)
+ {
+ const NWildcard::CItem &item = curNode.IncludeItems[i];
+ if (item.Recursive || item.PathParts.Size() != 1)
+ return false;
+ const UString &name = item.PathParts.Front();
+ /*
+ if (name.IsEmpty())
+ return false;
+ */
+
+ /* Windows doesn't support file name with wildcard
+ But if another system supports file name with wildcard,
+ and wildcard mode is disabled, we can ignore wildcard in name
+ */
+ /*
+ #ifndef _WIN32
+ if (!item.WildcardParsing)
+ continue;
+ #endif
+ */
+ if (DoesNameContainWildcard(name))
+ return false;
+ }
+ return true;
+}
+
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+static bool IsVirtualFsFolder(const FString &prefix, const UString &name)
+{
+ UString s = fs2us(prefix);
+ s += name;
+ s.Add_PathSepar();
+ // it returns (true) for non real FS folder path like - "\\SERVER\"
+ return IsPathSepar(s[0]) && GetRootPrefixSize(s) == 0;
+}
+
+#endif
+
+
+
+static HRESULT EnumerateDirItems(
+ const NWildcard::CCensorNode &curNode,
+ const int phyParent, const int logParent, const FString &phyPrefix,
+ const UStringVector &addParts, // prefix from curNode including
+ CDirItems &dirItems,
+ bool enterToSubFolders)
+{
+ if (!enterToSubFolders)
+ {
+ /* if there are IncludeItems censor rules that affect items in subdirs,
+ then we will enter to all subfolders */
+ if (curNode.NeedCheckSubDirs())
+ enterToSubFolders = true;
+ }
+
+ RINOK(dirItems.ScanProgress(phyPrefix))
+
+ // try direct_names case at first
+ if (addParts.IsEmpty() && !enterToSubFolders)
+ {
+ if (CanUseFsDirect(curNode))
+ {
+ // all names are direct (no wildcards)
+ // so we don't need file_system's dir enumerator
+ CRecordVector<bool> needEnterVector;
+ unsigned i;
+
+ for (i = 0; i < curNode.IncludeItems.Size(); i++)
+ {
+ const NWildcard::CItem &item = curNode.IncludeItems[i];
+ const UString &name = item.PathParts.Front();
+ FString fullPath = phyPrefix + us2fs(name);
+
+ /*
+ // not possible now
+ if (!item.ForDir && !item.ForFile)
+ {
+ RINOK(dirItems.AddError(fullPath, ERROR_INVALID_PARAMETER));
+ continue;
+ }
+ */
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ bool needAltStreams = true;
+ #endif
+
+ #ifdef Z7_USE_SECURITY_CODE
+ bool needSecurity = true;
+ #endif
+
+ if (phyPrefix.IsEmpty())
+ {
+ if (!item.ForFile)
+ {
+ /* we don't like some names for alt streams inside archive:
+ ":sname" for "\"
+ "c:::sname" for "C:\"
+ So we ignore alt streams for these cases */
+ if (name.IsEmpty())
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ needAltStreams = false;
+ #endif
+
+ /*
+ // do we need to ignore security info for "\\" folder ?
+ #ifdef Z7_USE_SECURITY_CODE
+ needSecurity = false;
+ #endif
+ */
+
+ fullPath = CHAR_PATH_SEPARATOR;
+ }
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ else if (item.IsDriveItem())
+ {
+ needAltStreams = false;
+ fullPath.Add_PathSepar();
+ }
+ #endif
+ }
+ }
+
+ NFind::CFileInfo fi;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (IsVirtualFsFolder(phyPrefix, name))
+ {
+ fi.SetAsDir();
+ fi.Name = us2fs(name);
+ }
+ else
+ #endif
+ if (!FindFile_KeepDots(fi, fullPath FOLLOW_LINK_PARAM2))
+ {
+ RINOK(dirItems.AddError(fullPath))
+ continue;
+ }
+
+ /*
+ #ifdef _WIN32
+ #define MY_ERROR_IS_DIR ERROR_FILE_NOT_FOUND
+ #define MY_ERROR_NOT_DIR DI_DEFAULT_ERROR
+ #else
+ #define MY_ERROR_IS_DIR EISDIR
+ #define MY_ERROR_NOT_DIR ENOTDIR
+ #endif
+ */
+
+ const bool isDir = fi.IsDir();
+ if (isDir ? !item.ForDir : !item.ForFile)
+ {
+ // RINOK(dirItems.AddError(fullPath, isDir ? MY_ERROR_IS_DIR: MY_ERROR_NOT_DIR));
+ RINOK(dirItems.AddError(fullPath, DI_DEFAULT_ERROR))
+ continue;
+ }
+ {
+ UStringVector pathParts;
+ pathParts.Add(fs2us(fi.Name));
+ if (curNode.CheckPathToRoot(false, pathParts, !isDir))
+ continue;
+ }
+
+
+ if (dirItems.CanIncludeItem(fi.IsDir()))
+ {
+ int secureIndex = -1;
+ #ifdef Z7_USE_SECURITY_CODE
+ if (needSecurity && dirItems.ReadSecure)
+ {
+ RINOK(dirItems.AddSecurityItem(fullPath, secureIndex))
+ }
+ #endif
+
+ dirItems.AddDirFileInfo(phyParent, logParent, secureIndex, fi);
+
+ // we don't scan AltStreams for link files
+
+ #if !defined(UNDER_CE)
+ {
+ CDirItem &dirItem = dirItems.Items.Back();
+ RINOK(dirItems.SetLinkInfo(dirItem, fi, phyPrefix))
+ if (dirItem.ReparseData.Size() != 0)
+ continue;
+ }
+
+ #if defined(_WIN32)
+ if (needAltStreams && dirItems.ScanAltStreams)
+ {
+ UStringVector pathParts;
+ pathParts.Add(fs2us(fi.Name));
+ RINOK(EnumerateAltStreams(fi, curNode, phyParent, logParent,
+ fullPath, // including (name)
+ pathParts, // including (fi.Name)
+ true, /* addAllSubStreams */
+ dirItems))
+ }
+ #endif // defined(_WIN32)
+
+ #endif // !defined(UNDER_CE)
+ }
+
+
+ #ifndef _WIN32
+ if (!fi.IsPosixLink()) // posix link can follow to dir
+ #endif
+ if (!isDir)
+ continue;
+
+ UStringVector newParts;
+ const NWildcard::CCensorNode *nextNode = NULL;
+ int index = curNode.FindSubNode(name);
+ if (index >= 0)
+ {
+ for (int t = (int)needEnterVector.Size(); t <= index; t++)
+ needEnterVector.Add(true);
+ needEnterVector[(unsigned)index] = false;
+ nextNode = &curNode.SubNodes[(unsigned)index];
+ }
+ else
+ {
+ #ifndef _WIN32
+ if (fi.IsPosixLink())
+ {
+ // here we can try to resolve posix link
+ // if the link to dir, then can we follow it
+ continue; // we don't follow posix link
+ }
+ #else
+ if (dirItems.SymLinks)
+ {
+ if (fi.HasReparsePoint())
+ {
+ /* 20.03: in SymLinks mode: we don't enter to directory that
+ has reparse point and has no CCensorNode */
+ continue;
+ }
+ }
+ #endif
+ nextNode = &curNode;
+ newParts.Add(name); // don't change it to fi.Name. It's for shortnames support
+ }
+
+ RINOK(EnumerateDirItems_Spec(*nextNode, phyParent, logParent, fi.Name, phyPrefix,
+ newParts, dirItems, true))
+ }
+
+ for (i = 0; i < curNode.SubNodes.Size(); i++)
+ {
+ if (i < needEnterVector.Size())
+ if (!needEnterVector[i])
+ continue;
+ const NWildcard::CCensorNode &nextNode = curNode.SubNodes[i];
+ FString fullPath = phyPrefix + us2fs(nextNode.Name);
+ NFind::CFileInfo fi;
+
+ if (nextNode.Name.IsEmpty())
+ {
+ if (phyPrefix.IsEmpty())
+ fullPath = CHAR_PATH_SEPARATOR;
+ }
+ #ifdef _WIN32
+ else if(phyPrefix.IsEmpty()
+ || (phyPrefix.Len() == NName::kSuperPathPrefixSize
+ && IsSuperPath(phyPrefix)))
+ {
+ if (NWildcard::IsDriveColonName(nextNode.Name))
+ fullPath.Add_PathSepar();
+ }
+ #endif
+
+ // we don't want to call fi.Find() for root folder or virtual folder
+ if ((phyPrefix.IsEmpty() && nextNode.Name.IsEmpty())
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ || IsVirtualFsFolder(phyPrefix, nextNode.Name)
+ #endif
+ )
+ {
+ fi.SetAsDir();
+ fi.Name = us2fs(nextNode.Name);
+ }
+ else
+ {
+ if (!FindFile_KeepDots(fi, fullPath FOLLOW_LINK_PARAM2))
+ {
+ if (!nextNode.AreThereIncludeItems())
+ continue;
+ RINOK(dirItems.AddError(fullPath))
+ continue;
+ }
+
+ if (!fi.IsDir())
+ {
+ RINOK(dirItems.AddError(fullPath, DI_DEFAULT_ERROR))
+ continue;
+ }
+ }
+
+ RINOK(EnumerateDirItems_Spec(nextNode, phyParent, logParent, fi.Name, phyPrefix,
+ UStringVector(), dirItems, false))
+ }
+
+ return S_OK;
+ }
+ }
+
+ #ifdef _WIN32
+ #ifndef UNDER_CE
+
+ // scan drives, if wildcard is "*:\"
+
+ if (phyPrefix.IsEmpty() && curNode.IncludeItems.Size() > 0)
+ {
+ unsigned i;
+ for (i = 0; i < curNode.IncludeItems.Size(); i++)
+ {
+ const NWildcard::CItem &item = curNode.IncludeItems[i];
+ if (item.PathParts.Size() < 1)
+ break;
+ const UString &name = item.PathParts.Front();
+ if (name.Len() != 2 || name[1] != ':')
+ break;
+ if (item.PathParts.Size() == 1)
+ if (item.ForFile || !item.ForDir)
+ break;
+ if (NWildcard::IsDriveColonName(name))
+ continue;
+ if (name[0] != '*' && name[0] != '?')
+ break;
+ }
+ if (i == curNode.IncludeItems.Size())
+ {
+ FStringVector driveStrings;
+ NFind::MyGetLogicalDriveStrings(driveStrings);
+ for (i = 0; i < driveStrings.Size(); i++)
+ {
+ FString driveName = driveStrings[i];
+ if (driveName.Len() < 3 || driveName.Back() != '\\')
+ return E_FAIL;
+ driveName.DeleteBack();
+ NFind::CFileInfo fi;
+ fi.SetAsDir();
+ fi.Name = driveName;
+
+ RINOK(EnumerateForItem(fi, curNode, phyParent, logParent, phyPrefix,
+ addParts, dirItems, enterToSubFolders))
+ }
+ return S_OK;
+ }
+ }
+
+ #endif
+ #endif
+
+
+ CObjectVector<NFind::CFileInfo> files;
+
+ // for (int y = 0; y < 1; y++)
+ {
+ // files.Clear();
+ RINOK(dirItems.EnumerateOneDir(phyPrefix, files))
+ /*
+ FOR_VECTOR (i, files)
+ {
+ #ifdef _WIN32
+ // const NFind::CFileInfo &fi = files[i];
+ #else
+ NFind::CFileInfo &fi = files[i];
+ {
+ const NFind::CFileInfo &di = files[i];
+ const FString path = phyPrefix + di.Name;
+ if (!fi.Find_AfterEnumerator(path))
+ {
+ RINOK(dirItems.AddError(path));
+ continue;
+ }
+ fi.Name = di.Name;
+ }
+ #endif
+
+ }
+ */
+ }
+
+ FOR_VECTOR (i, files)
+ {
+ #ifdef _WIN32
+ const NFind::CFileInfo &fi = files[i];
+ #else
+ const NFind::CFileInfo &fi = files[i];
+ /*
+ NFind::CFileInfo fi;
+ {
+ const NFind::CDirEntry &di = files[i];
+ const FString path = phyPrefix + di.Name;
+ if (!fi.Find_AfterEnumerator(path))
+ {
+ RINOK(dirItems.AddError(path));
+ continue;
+ }
+ fi.Name = di.Name;
+ }
+ */
+ #endif
+
+ RINOK(EnumerateForItem(fi, curNode, phyParent, logParent, phyPrefix,
+ addParts, dirItems, enterToSubFolders))
+ if (dirItems.Callback && (i & kScanProgressStepMask) == kScanProgressStepMask)
+ {
+ RINOK(dirItems.ScanProgress(phyPrefix))
+ }
+ }
+
+ return S_OK;
+}
+
+
+
+
+HRESULT EnumerateItems(
+ const NWildcard::CCensor &censor,
+ const NWildcard::ECensorPathMode pathMode,
+ const UString &addPathPrefix, // prefix that will be added to Logical Path
+ CDirItems &dirItems)
+{
+ FOR_VECTOR (i, censor.Pairs)
+ {
+ const NWildcard::CPair &pair = censor.Pairs[i];
+ const int phyParent = pair.Prefix.IsEmpty() ? -1 : (int)dirItems.AddPrefix(-1, -1, pair.Prefix);
+ int logParent = -1;
+
+ if (pathMode == NWildcard::k_AbsPath)
+ logParent = phyParent;
+ else
+ {
+ if (!addPathPrefix.IsEmpty())
+ logParent = (int)dirItems.AddPrefix(-1, -1, addPathPrefix);
+ }
+
+ RINOK(EnumerateDirItems(pair.Head, phyParent, logParent, us2fs(pair.Prefix), UStringVector(),
+ dirItems,
+ false // enterToSubFolders
+ ))
+ }
+ dirItems.ReserveDown();
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ RINOK(dirItems.FillFixedReparse())
+ #endif
+
+ #ifndef _WIN32
+ RINOK(dirItems.FillDeviceSizes())
+ #endif
+
+ return S_OK;
+}
+
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+HRESULT CDirItems::FillFixedReparse()
+{
+ FOR_VECTOR(i, Items)
+ {
+ CDirItem &item = Items[i];
+
+ if (!SymLinks)
+ {
+ // continue; // for debug
+ if (!item.Has_Attrib_ReparsePoint())
+ continue;
+
+ // if (item.IsDir()) continue;
+
+ const FString phyPath = GetPhyPath(i);
+
+ NFind::CFileInfo fi;
+ if (fi.Fill_From_ByHandleFileInfo(phyPath)) // item.IsDir()
+ {
+ item.Size = fi.Size;
+ item.CTime = fi.CTime;
+ item.ATime = fi.ATime;
+ item.MTime = fi.MTime;
+ item.Attrib = fi.Attrib;
+ continue;
+ }
+
+ /*
+ // we request properties of target file instead of properies of symbolic link
+ // here we also can manually parse unsupported links (like WSL links)
+ NIO::CInFile inFile;
+ if (inFile.Open(phyPath))
+ {
+ BY_HANDLE_FILE_INFORMATION info;
+ if (inFile.GetFileInformation(&info))
+ {
+ // Stat.FilesSize doesn't contain item.Size already
+ // Stat.FilesSize -= item.Size;
+ item.Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+ Stat.FilesSize += item.Size;
+ item.CTime = info.ftCreationTime;
+ item.ATime = info.ftLastAccessTime;
+ item.MTime = info.ftLastWriteTime;
+ item.Attrib = info.dwFileAttributes;
+ continue;
+ }
+ }
+ */
+
+ RINOK(AddError(phyPath))
+ continue;
+ }
+
+ // (SymLinks == true) here
+
+ if (item.ReparseData.Size() == 0)
+ continue;
+
+ // if (item.Size == 0)
+ {
+ // 20.03: we use Reparse Data instead of real data
+ item.Size = item.ReparseData.Size();
+ }
+
+ CReparseAttr attr;
+ if (!attr.Parse(item.ReparseData, item.ReparseData.Size()))
+ {
+ const FString phyPath = GetPhyPath(i);
+ AddError(phyPath, attr.ErrorCode);
+ continue;
+ }
+
+ /* imagex/WIM reduces absolute paths in links (raparse data),
+ if we archive non root folder. We do same thing here */
+
+ bool isWSL = false;
+ if (attr.IsSymLink_WSL())
+ {
+ // isWSL = true;
+ // we don't change WSL symlinks
+ continue;
+ }
+ else
+ {
+ if (attr.IsRelative_Win())
+ continue;
+ }
+
+ const UString &link = attr.GetPath();
+ if (!IsDrivePath(link))
+ continue;
+ // maybe we need to support networks paths also ?
+
+ FString fullPathF;
+ if (!NDir::MyGetFullPathName(GetPhyPath(i), fullPathF))
+ continue;
+ const UString fullPath = fs2us(fullPathF);
+ const UString logPath = GetLogPath(i);
+ if (logPath.Len() >= fullPath.Len())
+ continue;
+ if (CompareFileNames(logPath, fullPath.RightPtr(logPath.Len())) != 0)
+ continue;
+
+ const UString prefix = fullPath.Left(fullPath.Len() - logPath.Len());
+ if (!IsPathSepar(prefix.Back()))
+ continue;
+
+ const unsigned rootPrefixSize = GetRootPrefixSize(prefix);
+ if (rootPrefixSize == 0)
+ continue;
+ if (rootPrefixSize == prefix.Len())
+ continue; // simple case: paths are from root
+
+ if (link.Len() <= prefix.Len())
+ continue;
+
+ if (CompareFileNames(link.Left(prefix.Len()), prefix) != 0)
+ continue;
+
+ UString newLink = prefix.Left(rootPrefixSize);
+ newLink += link.Ptr(prefix.Len());
+
+ CByteBuffer data;
+ bool isSymLink = !attr.IsMountPoint();
+ if (!FillLinkData(data, newLink, isSymLink, isWSL))
+ continue;
+ item.ReparseData2 = data;
+ }
+ return S_OK;
+}
+
+#endif
+
+
+#ifndef _WIN32
+
+HRESULT CDirItems::FillDeviceSizes()
+{
+ {
+ FOR_VECTOR (i, Items)
+ {
+ CDirItem &item = Items[i];
+
+ if (S_ISBLK(item.mode) && item.Size == 0)
+ {
+ const FString phyPath = GetPhyPath(i);
+ NIO::CInFile inFile;
+ inFile.PreserveATime = true;
+ if (inFile.OpenShared(phyPath, ShareForWrite)) // fixme: OpenShared ??
+ {
+ UInt64 size = 0;
+ if (inFile.GetLength(size))
+ item.Size = size;
+ }
+ }
+ if (StoreOwnerName)
+ {
+ OwnerNameMap.Add_UInt32(item.uid);
+ OwnerGroupMap.Add_UInt32(item.gid);
+ }
+ }
+ }
+
+ if (StoreOwnerName)
+ {
+ UString u;
+ AString a;
+ {
+ FOR_VECTOR (i, OwnerNameMap.Numbers)
+ {
+ // 200K/sec speed
+ u.Empty();
+ const passwd *pw = getpwuid(OwnerNameMap.Numbers[i]);
+ // printf("\ngetpwuid=%s\n", pw->pw_name);
+ if (pw)
+ {
+ a = pw->pw_name;
+ ConvertUTF8ToUnicode(a, u);
+ }
+ OwnerNameMap.Strings.Add(u);
+ }
+ }
+ {
+ FOR_VECTOR (i, OwnerGroupMap.Numbers)
+ {
+ u.Empty();
+ const group *gr = getgrgid(OwnerGroupMap.Numbers[i]);
+ if (gr)
+ {
+ // printf("\ngetgrgid %d %s\n", OwnerGroupMap.Numbers[i], gr->gr_name);
+ a = gr->gr_name;
+ ConvertUTF8ToUnicode(a, u);
+ }
+ OwnerGroupMap.Strings.Add(u);
+ }
+ }
+
+ FOR_VECTOR (i, Items)
+ {
+ CDirItem &item = Items[i];
+ {
+ const int index = OwnerNameMap.Find(item.uid);
+ if (index < 0) throw 1;
+ item.OwnerNameIndex = index;
+ }
+ {
+ const int index = OwnerGroupMap.Find(item.gid);
+ if (index < 0) throw 1;
+ item.OwnerGroupIndex = index;
+ }
+ }
+ }
+
+
+ // if (NeedOwnerNames)
+ {
+ /*
+ {
+ for (unsigned i = 0 ; i < 10000; i++)
+ {
+ const passwd *pw = getpwuid(i);
+ if (pw)
+ {
+ UString u;
+ ConvertUTF8ToUnicode(AString(pw->pw_name), u);
+ OwnerNameMap.Add(i, u);
+ OwnerNameMap.Add(i, u);
+ OwnerNameMap.Add(i, u);
+ }
+ const group *gr = getgrgid(i);
+ if (gr)
+ {
+ // we can use utf-8 here.
+ UString u;
+ ConvertUTF8ToUnicode(AString(gr->gr_name), u);
+ OwnerGroupMap.Add(i, u);
+ }
+ }
+ }
+ */
+ /*
+ {
+ FOR_VECTOR (i, OwnerNameMap.Strings)
+ {
+ AString s;
+ ConvertUnicodeToUTF8(OwnerNameMap.Strings[i], s);
+ printf("\n%5d %s", (unsigned)OwnerNameMap.Numbers[i], s.Ptr());
+ }
+ }
+ {
+ printf("\n\n=========Groups\n");
+ FOR_VECTOR (i, OwnerGroupMap.Strings)
+ {
+ AString s;
+ ConvertUnicodeToUTF8(OwnerGroupMap.Strings[i], s);
+ printf("\n%5d %s", (unsigned)OwnerGroupMap.Numbers[i], s.Ptr());
+ }
+ }
+ */
+ }
+ /*
+ for (unsigned i = 0 ; i < 100000000; i++)
+ {
+ // const passwd *pw = getpwuid(1000);
+ // pw = pw;
+ int pos = OwnerNameMap.Find(1000);
+ if (pos < 0 - (int)i)
+ throw 1;
+ }
+ */
+
+ return S_OK;
+}
+
+#endif
+
+
+
+static const char * const kCannotFindArchive = "Cannot find archive";
+
+HRESULT EnumerateDirItemsAndSort(
+ NWildcard::CCensor &censor,
+ NWildcard::ECensorPathMode censorPathMode,
+ const UString &addPathPrefix,
+ UStringVector &sortedPaths,
+ UStringVector &sortedFullPaths,
+ CDirItemsStat &st,
+ IDirItemsCallback *callback)
+{
+ FStringVector paths;
+
+ {
+ CDirItems dirItems;
+ dirItems.Callback = callback;
+ {
+ HRESULT res = EnumerateItems(censor, censorPathMode, addPathPrefix, dirItems);
+ st = dirItems.Stat;
+ RINOK(res)
+ }
+
+ FOR_VECTOR (i, dirItems.Items)
+ {
+ const CDirItem &dirItem = dirItems.Items[i];
+ if (!dirItem.IsDir())
+ paths.Add(dirItems.GetPhyPath(i));
+ }
+ }
+
+ if (paths.Size() == 0)
+ {
+ // return S_OK;
+ throw CMessagePathException(kCannotFindArchive);
+ }
+
+ UStringVector fullPaths;
+
+ unsigned i;
+
+ for (i = 0; i < paths.Size(); i++)
+ {
+ FString fullPath;
+ NFile::NDir::MyGetFullPathName(paths[i], fullPath);
+ fullPaths.Add(fs2us(fullPath));
+ }
+
+ CUIntVector indices;
+ SortFileNames(fullPaths, indices);
+ sortedPaths.ClearAndReserve(indices.Size());
+ sortedFullPaths.ClearAndReserve(indices.Size());
+
+ for (i = 0; i < indices.Size(); i++)
+ {
+ unsigned index = indices[i];
+ sortedPaths.AddInReserved(fs2us(paths[index]));
+ sortedFullPaths.AddInReserved(fullPaths[index]);
+ if (i > 0 && CompareFileNames(sortedFullPaths[i], sortedFullPaths[i - 1]) == 0)
+ throw CMessagePathException("Duplicate archive path:", sortedFullPaths[i]);
+ }
+
+ return S_OK;
+}
+
+
+
+
+#ifdef _WIN32
+
+static bool IsDotsName(const wchar_t *s)
+{
+ return s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0));
+}
+
+// This code converts all short file names to long file names.
+
+static void ConvertToLongName(const UString &prefix, UString &name)
+{
+ if (name.IsEmpty()
+ || DoesNameContainWildcard(name)
+ || IsDotsName(name))
+ return;
+ NFind::CFileInfo fi;
+ const FString path (us2fs(prefix + name));
+ #ifndef UNDER_CE
+ if (NFile::NName::IsDevicePath(path))
+ return;
+ #endif
+ if (fi.Find(path))
+ name = fs2us(fi.Name);
+}
+
+static void ConvertToLongNames(const UString &prefix, CObjectVector<NWildcard::CItem> &items)
+{
+ FOR_VECTOR (i, items)
+ {
+ NWildcard::CItem &item = items[i];
+ if (item.Recursive || item.PathParts.Size() != 1)
+ continue;
+ if (prefix.IsEmpty() && item.IsDriveItem())
+ continue;
+ ConvertToLongName(prefix, item.PathParts.Front());
+ }
+}
+
+static void ConvertToLongNames(const UString &prefix, NWildcard::CCensorNode &node)
+{
+ ConvertToLongNames(prefix, node.IncludeItems);
+ ConvertToLongNames(prefix, node.ExcludeItems);
+ unsigned i;
+ for (i = 0; i < node.SubNodes.Size(); i++)
+ {
+ UString &name = node.SubNodes[i].Name;
+ if (prefix.IsEmpty() && NWildcard::IsDriveColonName(name))
+ continue;
+ ConvertToLongName(prefix, name);
+ }
+ // mix folders with same name
+ for (i = 0; i < node.SubNodes.Size(); i++)
+ {
+ NWildcard::CCensorNode &nextNode1 = node.SubNodes[i];
+ for (unsigned j = i + 1; j < node.SubNodes.Size();)
+ {
+ const NWildcard::CCensorNode &nextNode2 = node.SubNodes[j];
+ if (nextNode1.Name.IsEqualTo_NoCase(nextNode2.Name))
+ {
+ nextNode1.IncludeItems += nextNode2.IncludeItems;
+ nextNode1.ExcludeItems += nextNode2.ExcludeItems;
+ node.SubNodes.Delete(j);
+ }
+ else
+ j++;
+ }
+ }
+ for (i = 0; i < node.SubNodes.Size(); i++)
+ {
+ NWildcard::CCensorNode &nextNode = node.SubNodes[i];
+ ConvertToLongNames(prefix + nextNode.Name + WCHAR_PATH_SEPARATOR, nextNode);
+ }
+}
+
+void ConvertToLongNames(NWildcard::CCensor &censor)
+{
+ FOR_VECTOR (i, censor.Pairs)
+ {
+ NWildcard::CPair &pair = censor.Pairs[i];
+ ConvertToLongNames(pair.Prefix, pair.Head);
+ }
+}
+
+#endif
+
+
+CMessagePathException::CMessagePathException(const char *a, const wchar_t *u)
+{
+ (*this) += a;
+ if (u)
+ {
+ Add_LF();
+ (*this) += u;
+ }
+}
+
+CMessagePathException::CMessagePathException(const wchar_t *a, const wchar_t *u)
+{
+ (*this) += a;
+ if (u)
+ {
+ Add_LF();
+ (*this) += u;
+ }
+}
diff --git a/CPP/7zip/UI/Common/EnumDirItems.h b/CPP/7zip/UI/Common/EnumDirItems.h
index ae1d226..24f1c8b 100644
--- a/CPP/7zip/UI/Common/EnumDirItems.h
+++ b/CPP/7zip/UI/Common/EnumDirItems.h
@@ -1,42 +1,38 @@
-// EnumDirItems.h
-
-#ifndef __ENUM_DIR_ITEMS_H
-#define __ENUM_DIR_ITEMS_H
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileFind.h"
-
-#include "DirItem.h"
-
-void AddDirFileInfo(int phyParent, int logParent, int secureIndex,
- const NWindows::NFile::NFind::CFileInfo &fi, CObjectVector<CDirItem> &dirItems);
-
-HRESULT EnumerateItems(
- const NWildcard::CCensor &censor,
- NWildcard::ECensorPathMode pathMode,
- const UString &addPathPrefix,
- CDirItems &dirItems);
-
-
-struct CMessagePathException: public UString
-{
- CMessagePathException(const char *a, const wchar_t *u = NULL);
- CMessagePathException(const wchar_t *a, const wchar_t *u = NULL);
-};
-
-
-HRESULT EnumerateDirItemsAndSort(
- NWildcard::CCensor &censor,
- NWildcard::ECensorPathMode pathMode,
- const UString &addPathPrefix,
- UStringVector &sortedPaths,
- UStringVector &sortedFullPaths,
- CDirItemsStat &st,
- IDirItemsCallback *callback);
-
-#ifdef _WIN32
-void ConvertToLongNames(NWildcard::CCensor &censor);
-#endif
-
-#endif
+// EnumDirItems.h
+
+#ifndef ZIP7_INC_ENUM_DIR_ITEMS_H
+#define ZIP7_INC_ENUM_DIR_ITEMS_H
+
+#include "../../../Common/Wildcard.h"
+
+#include "DirItem.h"
+
+
+HRESULT EnumerateItems(
+ const NWildcard::CCensor &censor,
+ NWildcard::ECensorPathMode pathMode,
+ const UString &addPathPrefix,
+ CDirItems &dirItems);
+
+
+struct CMessagePathException: public UString
+{
+ CMessagePathException(const char *a, const wchar_t *u = NULL);
+ CMessagePathException(const wchar_t *a, const wchar_t *u = NULL);
+};
+
+
+HRESULT EnumerateDirItemsAndSort(
+ NWildcard::CCensor &censor,
+ NWildcard::ECensorPathMode pathMode,
+ const UString &addPathPrefix,
+ UStringVector &sortedPaths,
+ UStringVector &sortedFullPaths,
+ CDirItemsStat &st,
+ IDirItemsCallback *callback);
+
+#ifdef _WIN32
+void ConvertToLongNames(NWildcard::CCensor &censor);
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/Common/ExitCode.h b/CPP/7zip/UI/Common/ExitCode.h
index d03ec6d..2d7b029 100644
--- a/CPP/7zip/UI/Common/ExitCode.h
+++ b/CPP/7zip/UI/Common/ExitCode.h
@@ -1,27 +1,27 @@
-// ExitCode.h
-
-#ifndef __EXIT_CODE_H
-#define __EXIT_CODE_H
-
-namespace NExitCode {
-
-enum EEnum {
-
- kSuccess = 0, // Successful operation
- kWarning = 1, // Non fatal error(s) occurred
- kFatalError = 2, // A fatal error occurred
- // kCRCError = 3, // A CRC error occurred when unpacking
- // kLockedArchive = 4, // Attempt to modify an archive previously locked
- // kWriteError = 5, // Write to disk error
- // kOpenError = 6, // Open file error
- kUserError = 7, // Command line option error
- kMemoryError = 8, // Not enough memory for operation
- // kCreateFileError = 9, // Create file error
-
- kUserBreak = 255 // User stopped the process
-
-};
-
-}
-
-#endif
+// ExitCode.h
+
+#ifndef ZIP7_INC_EXIT_CODE_H
+#define ZIP7_INC_EXIT_CODE_H
+
+namespace NExitCode {
+
+enum EEnum {
+
+ kSuccess = 0, // Successful operation
+ kWarning = 1, // Non fatal error(s) occurred
+ kFatalError = 2, // A fatal error occurred
+ // kCRCError = 3, // A CRC error occurred when unpacking
+ // kLockedArchive = 4, // Attempt to modify an archive previously locked
+ // kWriteError = 5, // Write to disk error
+ // kOpenError = 6, // Open file error
+ kUserError = 7, // Command line option error
+ kMemoryError = 8, // Not enough memory for operation
+ // kCreateFileError = 9, // Create file error
+
+ kUserBreak = 255 // User stopped the process
+
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Common/Extract.cpp b/CPP/7zip/UI/Common/Extract.cpp
index 2cb2c9b..34b4871 100644
--- a/CPP/7zip/UI/Common/Extract.cpp
+++ b/CPP/7zip/UI/Common/Extract.cpp
@@ -1,482 +1,570 @@
-// Extract.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/Sort.h"
-
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/PropVariant.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#include "../Common/ExtractingFilePath.h"
-
-#include "Extract.h"
-#include "SetProperties.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static HRESULT DecompressArchive(
- CCodecs *codecs,
- const CArchiveLink &arcLink,
- UInt64 packSize,
- const NWildcard::CCensorNode &wildcardCensor,
- const CExtractOptions &options,
- bool calcCrc,
- IExtractCallbackUI *callback,
- CArchiveExtractCallback *ecs,
- UString &errorMessage,
- UInt64 &stdInProcessed)
-{
- const CArc &arc = arcLink.Arcs.Back();
- stdInProcessed = 0;
- IInArchive *archive = arc.Archive;
- CRecordVector<UInt32> realIndices;
-
- UStringVector removePathParts;
-
- FString outDir = options.OutputDir;
- UString replaceName = arc.DefaultName;
-
- if (arcLink.Arcs.Size() > 1)
- {
- // Most "pe" archives have same name of archive subfile "[0]" or ".rsrc_1".
- // So it extracts different archives to one folder.
- // We will use top level archive name
- const CArc &arc0 = arcLink.Arcs[0];
- if (StringsAreEqualNoCase_Ascii(codecs->Formats[arc0.FormatIndex].Name, "pe"))
- replaceName = arc0.DefaultName;
- }
-
- outDir.Replace(FString("*"), us2fs(Get_Correct_FsFile_Name(replaceName)));
-
- bool elimIsPossible = false;
- UString elimPrefix; // only pure name without dir delimiter
- FString outDirReduced = outDir;
-
- if (options.ElimDup.Val && options.PathMode != NExtract::NPathMode::kAbsPaths)
- {
- UString dirPrefix;
- SplitPathToParts_Smart(fs2us(outDir), dirPrefix, elimPrefix);
- if (!elimPrefix.IsEmpty())
- {
- if (IsPathSepar(elimPrefix.Back()))
- elimPrefix.DeleteBack();
- if (!elimPrefix.IsEmpty())
- {
- outDirReduced = us2fs(dirPrefix);
- elimIsPossible = true;
- }
- }
- }
-
- bool allFilesAreAllowed = wildcardCensor.AreAllAllowed();
-
- if (!options.StdInMode)
- {
- UInt32 numItems;
- RINOK(archive->GetNumberOfItems(&numItems));
-
- CReadArcItem item;
-
- for (UInt32 i = 0; i < numItems; i++)
- {
- if (elimIsPossible || !allFilesAreAllowed)
- {
- RINOK(arc.GetItem(i, item));
- }
- else
- {
- #ifdef SUPPORT_ALT_STREAMS
- item.IsAltStream = false;
- if (!options.NtOptions.AltStreams.Val && arc.Ask_AltStream)
- {
- RINOK(Archive_IsItem_AltStream(arc.Archive, i, item.IsAltStream));
- }
- #endif
- }
-
- #ifdef SUPPORT_ALT_STREAMS
- if (!options.NtOptions.AltStreams.Val && item.IsAltStream)
- continue;
- #endif
-
- if (elimIsPossible)
- {
- const UString &s =
- #ifdef SUPPORT_ALT_STREAMS
- item.MainPath;
- #else
- item.Path;
- #endif
- if (!IsPath1PrefixedByPath2(s, elimPrefix))
- elimIsPossible = false;
- else
- {
- wchar_t c = s[elimPrefix.Len()];
- if (c == 0)
- {
- if (!item.MainIsDir)
- elimIsPossible = false;
- }
- else if (!IsPathSepar(c))
- elimIsPossible = false;
- }
- }
-
- if (!allFilesAreAllowed)
- {
- if (!CensorNode_CheckPath(wildcardCensor, item))
- continue;
- }
-
- realIndices.Add(i);
- }
-
- if (realIndices.Size() == 0)
- {
- callback->ThereAreNoFiles();
- return callback->ExtractResult(S_OK);
- }
- }
-
- if (elimIsPossible)
- {
- removePathParts.Add(elimPrefix);
- // outDir = outDirReduced;
- }
-
- #ifdef _WIN32
- // GetCorrectFullFsPath doesn't like "..".
- // outDir.TrimRight();
- // outDir = GetCorrectFullFsPath(outDir);
- #endif
-
- if (outDir.IsEmpty())
- outDir = "." STRING_PATH_SEPARATOR;
- /*
- #ifdef _WIN32
- else if (NName::IsAltPathPrefix(outDir)) {}
- #endif
- */
- else if (!CreateComplexDir(outDir))
- {
- HRESULT res = ::GetLastError();
- if (res == S_OK)
- res = E_FAIL;
- errorMessage = "Can not create output directory: ";
- errorMessage += fs2us(outDir);
- return res;
- }
-
- ecs->Init(
- options.NtOptions,
- options.StdInMode ? &wildcardCensor : NULL,
- &arc,
- callback,
- options.StdOutMode, options.TestMode,
- outDir,
- removePathParts, false,
- packSize);
-
-
- #ifdef SUPPORT_LINKS
-
- if (!options.StdInMode &&
- !options.TestMode &&
- options.NtOptions.HardLinks.Val)
- {
- RINOK(ecs->PrepareHardLinks(&realIndices));
- }
-
- #endif
-
-
- HRESULT result;
- Int32 testMode = (options.TestMode && !calcCrc) ? 1: 0;
-
- CArchiveExtractCallback_Closer ecsCloser(ecs);
-
- if (options.StdInMode)
- {
- result = archive->Extract(NULL, (UInt32)(Int32)-1, testMode, ecs);
- NCOM::CPropVariant prop;
- if (archive->GetArchiveProperty(kpidPhySize, &prop) == S_OK)
- ConvertPropVariantToUInt64(prop, stdInProcessed);
- }
- else
- result = archive->Extract(&realIndices.Front(), realIndices.Size(), testMode, ecs);
-
- HRESULT res2 = ecsCloser.Close();
- if (result == S_OK)
- result = res2;
-
- return callback->ExtractResult(result);
-}
-
-/* v9.31: BUG was fixed:
- Sorted list for file paths was sorted with case insensitive compare function.
- But FindInSorted function did binary search via case sensitive compare function */
-
-int Find_FileName_InSortedVector(const UStringVector &fileName, const UString &name)
-{
- unsigned left = 0, right = fileName.Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const UString &midValue = fileName[mid];
- int compare = CompareFileNames(name, midValue);
- if (compare == 0)
- return mid;
- if (compare < 0)
- right = mid;
- else
- left = mid + 1;
- }
- return -1;
-}
-
-HRESULT Extract(
- CCodecs *codecs,
- const CObjectVector<COpenType> &types,
- const CIntVector &excludedFormats,
- UStringVector &arcPaths, UStringVector &arcPathsFull,
- const NWildcard::CCensorNode &wildcardCensor,
- const CExtractOptions &options,
- IOpenCallbackUI *openCallback,
- IExtractCallbackUI *extractCallback,
- #ifndef _SFX
- IHashCalc *hash,
- #endif
- UString &errorMessage,
- CDecompressStat &st)
-{
- st.Clear();
- UInt64 totalPackSize = 0;
- CRecordVector<UInt64> arcSizes;
-
- unsigned numArcs = options.StdInMode ? 1 : arcPaths.Size();
-
- unsigned i;
-
- for (i = 0; i < numArcs; i++)
- {
- NFind::CFileInfo fi;
- fi.Size = 0;
- if (!options.StdInMode)
- {
- const FString &arcPath = us2fs(arcPaths[i]);
- if (!fi.Find(arcPath))
- throw "there is no such archive";
- if (fi.IsDir())
- throw "can't decompress folder";
- }
- arcSizes.Add(fi.Size);
- totalPackSize += fi.Size;
- }
-
- CBoolArr skipArcs(numArcs);
- for (i = 0; i < numArcs; i++)
- skipArcs[i] = false;
-
- CArchiveExtractCallback *ecs = new CArchiveExtractCallback;
- CMyComPtr<IArchiveExtractCallback> ec(ecs);
- bool multi = (numArcs > 1);
- ecs->InitForMulti(multi, options.PathMode, options.OverwriteMode,
- false // keepEmptyDirParts
- );
- #ifndef _SFX
- ecs->SetHashMethods(hash);
- #endif
-
- if (multi)
- {
- RINOK(extractCallback->SetTotal(totalPackSize));
- }
-
- UInt64 totalPackProcessed = 0;
- bool thereAreNotOpenArcs = false;
-
- for (i = 0; i < numArcs; i++)
- {
- if (skipArcs[i])
- continue;
-
- const UString &arcPath = arcPaths[i];
- NFind::CFileInfo fi;
- if (options.StdInMode)
- {
- fi.Size = 0;
- fi.Attrib = 0;
- }
- else
- {
- if (!fi.Find(us2fs(arcPath)) || fi.IsDir())
- throw "there is no such archive";
- }
-
- /*
- #ifndef _NO_CRYPTO
- openCallback->Open_Clear_PasswordWasAsked_Flag();
- #endif
- */
-
- RINOK(extractCallback->BeforeOpen(arcPath, options.TestMode));
- CArchiveLink arcLink;
-
- CObjectVector<COpenType> types2 = types;
- /*
- #ifndef _SFX
- if (types.IsEmpty())
- {
- int pos = arcPath.ReverseFind(L'.');
- if (pos >= 0)
- {
- UString s = arcPath.Ptr(pos + 1);
- int index = codecs->FindFormatForExtension(s);
- if (index >= 0 && s == L"001")
- {
- s = arcPath.Left(pos);
- pos = s.ReverseFind(L'.');
- if (pos >= 0)
- {
- int index2 = codecs->FindFormatForExtension(s.Ptr(pos + 1));
- if (index2 >= 0) // && s.CompareNoCase(L"rar") != 0
- {
- types2.Add(index2);
- types2.Add(index);
- }
- }
- }
- }
- }
- #endif
- */
-
- COpenOptions op;
- #ifndef _SFX
- op.props = &options.Properties;
- #endif
- op.codecs = codecs;
- op.types = &types2;
- op.excludedFormats = &excludedFormats;
- op.stdInMode = options.StdInMode;
- op.stream = NULL;
- op.filePath = arcPath;
-
- HRESULT result = arcLink.Open_Strict(op, openCallback);
-
- if (result == E_ABORT)
- return result;
-
- // arcLink.Set_ErrorsText();
- RINOK(extractCallback->OpenResult(codecs, arcLink, arcPath, result));
-
- if (result != S_OK)
- {
- thereAreNotOpenArcs = true;
- if (!options.StdInMode)
- {
- NFind::CFileInfo fi2;
- if (fi2.Find(us2fs(arcPath)))
- if (!fi2.IsDir())
- totalPackProcessed += fi2.Size;
- }
- continue;
- }
-
- if (!options.StdInMode)
- {
- // numVolumes += arcLink.VolumePaths.Size();
- // arcLink.VolumesSize;
-
- // totalPackSize -= DeleteUsedFileNamesFromList(arcLink, i + 1, arcPaths, arcPathsFull, &arcSizes);
- // numArcs = arcPaths.Size();
- if (arcLink.VolumePaths.Size() != 0)
- {
- Int64 correctionSize = arcLink.VolumesSize;
- FOR_VECTOR (v, arcLink.VolumePaths)
- {
- int index = Find_FileName_InSortedVector(arcPathsFull, arcLink.VolumePaths[v]);
- if (index >= 0)
- {
- if ((unsigned)index > i)
- {
- skipArcs[(unsigned)index] = true;
- correctionSize -= arcSizes[(unsigned)index];
- }
- }
- }
- if (correctionSize != 0)
- {
- Int64 newPackSize = (Int64)totalPackSize + correctionSize;
- if (newPackSize < 0)
- newPackSize = 0;
- totalPackSize = newPackSize;
- RINOK(extractCallback->SetTotal(totalPackSize));
- }
- }
- }
-
- /*
- // Now openCallback and extractCallback use same object. So we don't need to send password.
-
- #ifndef _NO_CRYPTO
- bool passwordIsDefined;
- UString password;
- RINOK(openCallback->Open_GetPasswordIfAny(passwordIsDefined, password));
- if (passwordIsDefined)
- {
- RINOK(extractCallback->SetPassword(password));
- }
- #endif
- */
-
- CArc &arc = arcLink.Arcs.Back();
- arc.MTimeDefined = (!options.StdInMode && !fi.IsDevice);
- arc.MTime = fi.MTime;
-
- UInt64 packProcessed;
- bool calcCrc =
- #ifndef _SFX
- (hash != NULL);
- #else
- false;
- #endif
-
- RINOK(DecompressArchive(
- codecs,
- arcLink,
- fi.Size + arcLink.VolumesSize,
- wildcardCensor,
- options,
- calcCrc,
- extractCallback, ecs, errorMessage, packProcessed));
-
- if (!options.StdInMode)
- packProcessed = fi.Size + arcLink.VolumesSize;
- totalPackProcessed += packProcessed;
- ecs->LocalProgressSpec->InSize += packProcessed;
- ecs->LocalProgressSpec->OutSize = ecs->UnpackSize;
- if (!errorMessage.IsEmpty())
- return E_FAIL;
- }
-
- if (multi || thereAreNotOpenArcs)
- {
- RINOK(extractCallback->SetTotal(totalPackSize));
- RINOK(extractCallback->SetCompleted(&totalPackProcessed));
- }
-
- st.NumFolders = ecs->NumFolders;
- st.NumFiles = ecs->NumFiles;
- st.NumAltStreams = ecs->NumAltStreams;
- st.UnpackSize = ecs->UnpackSize;
- st.AltStreams_UnpackSize = ecs->AltStreams_UnpackSize;
- st.NumArchives = arcPaths.Size();
- st.PackSize = ecs->LocalProgressSpec->InSize;
- return S_OK;
-}
+// Extract.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Sort.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../Common/ExtractingFilePath.h"
+#include "../Common/HashCalc.h"
+
+#include "Extract.h"
+#include "SetProperties.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+
+static void SetErrorMessage(const char *message,
+ const FString &path, HRESULT errorCode,
+ UString &s)
+{
+ s = message;
+ s += " : ";
+ s += NError::MyFormatMessage(errorCode);
+ s += " : ";
+ s += fs2us(path);
+}
+
+
+static HRESULT DecompressArchive(
+ CCodecs *codecs,
+ const CArchiveLink &arcLink,
+ UInt64 packSize,
+ const NWildcard::CCensorNode &wildcardCensor,
+ const CExtractOptions &options,
+ bool calcCrc,
+ IExtractCallbackUI *callback,
+ IFolderArchiveExtractCallback *callbackFAE,
+ CArchiveExtractCallback *ecs,
+ UString &errorMessage,
+ UInt64 &stdInProcessed)
+{
+ const CArc &arc = arcLink.Arcs.Back();
+ stdInProcessed = 0;
+ IInArchive *archive = arc.Archive;
+ CRecordVector<UInt32> realIndices;
+
+ UStringVector removePathParts;
+
+ FString outDir = options.OutputDir;
+ UString replaceName = arc.DefaultName;
+
+ if (arcLink.Arcs.Size() > 1)
+ {
+ // Most "pe" archives have same name of archive subfile "[0]" or ".rsrc_1".
+ // So it extracts different archives to one folder.
+ // We will use top level archive name
+ const CArc &arc0 = arcLink.Arcs[0];
+ if (arc0.FormatIndex >= 0 && StringsAreEqualNoCase_Ascii(codecs->Formats[(unsigned)arc0.FormatIndex].Name, "pe"))
+ replaceName = arc0.DefaultName;
+ }
+
+ outDir.Replace(FString("*"), us2fs(Get_Correct_FsFile_Name(replaceName)));
+
+ bool elimIsPossible = false;
+ UString elimPrefix; // only pure name without dir delimiter
+ FString outDirReduced = outDir;
+
+ if (options.ElimDup.Val && options.PathMode != NExtract::NPathMode::kAbsPaths)
+ {
+ UString dirPrefix;
+ SplitPathToParts_Smart(fs2us(outDir), dirPrefix, elimPrefix);
+ if (!elimPrefix.IsEmpty())
+ {
+ if (IsPathSepar(elimPrefix.Back()))
+ elimPrefix.DeleteBack();
+ if (!elimPrefix.IsEmpty())
+ {
+ outDirReduced = us2fs(dirPrefix);
+ elimIsPossible = true;
+ }
+ }
+ }
+
+ const bool allFilesAreAllowed = wildcardCensor.AreAllAllowed();
+
+ if (!options.StdInMode)
+ {
+ UInt32 numItems;
+ RINOK(archive->GetNumberOfItems(&numItems))
+
+ CReadArcItem item;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ if (elimIsPossible
+ || !allFilesAreAllowed
+ || options.ExcludeDirItems
+ || options.ExcludeFileItems)
+ {
+ RINOK(arc.GetItem(i, item))
+ if (item.IsDir ? options.ExcludeDirItems : options.ExcludeFileItems)
+ continue;
+ }
+ else
+ {
+ #ifdef SUPPORT_ALT_STREAMS
+ item.IsAltStream = false;
+ if (!options.NtOptions.AltStreams.Val && arc.Ask_AltStream)
+ {
+ RINOK(Archive_IsItem_AltStream(arc.Archive, i, item.IsAltStream))
+ }
+ #endif
+ }
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (!options.NtOptions.AltStreams.Val && item.IsAltStream)
+ continue;
+ #endif
+
+ if (elimIsPossible)
+ {
+ const UString &s =
+ #ifdef SUPPORT_ALT_STREAMS
+ item.MainPath;
+ #else
+ item.Path;
+ #endif
+ if (!IsPath1PrefixedByPath2(s, elimPrefix))
+ elimIsPossible = false;
+ else
+ {
+ wchar_t c = s[elimPrefix.Len()];
+ if (c == 0)
+ {
+ if (!item.MainIsDir)
+ elimIsPossible = false;
+ }
+ else if (!IsPathSepar(c))
+ elimIsPossible = false;
+ }
+ }
+
+ if (!allFilesAreAllowed)
+ {
+ if (!CensorNode_CheckPath(wildcardCensor, item))
+ continue;
+ }
+
+ realIndices.Add(i);
+ }
+
+ if (realIndices.Size() == 0)
+ {
+ callback->ThereAreNoFiles();
+ return callback->ExtractResult(S_OK);
+ }
+ }
+
+ if (elimIsPossible)
+ {
+ removePathParts.Add(elimPrefix);
+ // outDir = outDirReduced;
+ }
+
+ #ifdef _WIN32
+ // GetCorrectFullFsPath doesn't like "..".
+ // outDir.TrimRight();
+ // outDir = GetCorrectFullFsPath(outDir);
+ #endif
+
+ if (outDir.IsEmpty())
+ outDir = "." STRING_PATH_SEPARATOR;
+ /*
+ #ifdef _WIN32
+ else if (NName::IsAltPathPrefix(outDir)) {}
+ #endif
+ */
+ else if (!CreateComplexDir(outDir))
+ {
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ SetErrorMessage("Cannot create output directory", outDir, res, errorMessage);
+ return res;
+ }
+
+ ecs->Init(
+ options.NtOptions,
+ options.StdInMode ? &wildcardCensor : NULL,
+ &arc,
+ callbackFAE,
+ options.StdOutMode, options.TestMode,
+ outDir,
+ removePathParts, false,
+ packSize);
+
+
+ #ifdef SUPPORT_LINKS
+
+ if (!options.StdInMode &&
+ !options.TestMode &&
+ options.NtOptions.HardLinks.Val)
+ {
+ RINOK(ecs->PrepareHardLinks(&realIndices))
+ }
+
+ #endif
+
+
+ HRESULT result;
+ const Int32 testMode = (options.TestMode && !calcCrc) ? 1: 0;
+
+ CArchiveExtractCallback_Closer ecsCloser(ecs);
+
+ if (options.StdInMode)
+ {
+ result = archive->Extract(NULL, (UInt32)(Int32)-1, testMode, ecs);
+ NCOM::CPropVariant prop;
+ if (archive->GetArchiveProperty(kpidPhySize, &prop) == S_OK)
+ ConvertPropVariantToUInt64(prop, stdInProcessed);
+ }
+ else
+ result = archive->Extract(&realIndices.Front(), realIndices.Size(), testMode, ecs);
+
+ const HRESULT res2 = ecsCloser.Close();
+ if (result == S_OK)
+ result = res2;
+
+ return callback->ExtractResult(result);
+}
+
+/* v9.31: BUG was fixed:
+ Sorted list for file paths was sorted with case insensitive compare function.
+ But FindInSorted function did binary search via case sensitive compare function */
+
+int Find_FileName_InSortedVector(const UStringVector &fileNames, const UString &name);
+int Find_FileName_InSortedVector(const UStringVector &fileNames, const UString &name)
+{
+ unsigned left = 0, right = fileNames.Size();
+ while (left != right)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const UString &midVal = fileNames[mid];
+ const int comp = CompareFileNames(name, midVal);
+ if (comp == 0)
+ return (int)mid;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+}
+
+
+
+HRESULT Extract(
+ // DECL_EXTERNAL_CODECS_LOC_VARS
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &types,
+ const CIntVector &excludedFormats,
+ UStringVector &arcPaths, UStringVector &arcPathsFull,
+ const NWildcard::CCensorNode &wildcardCensor,
+ const CExtractOptions &options,
+ IOpenCallbackUI *openCallback,
+ IExtractCallbackUI *extractCallback,
+ IFolderArchiveExtractCallback *faeCallback,
+ #ifndef Z7_SFX
+ IHashCalc *hash,
+ #endif
+ UString &errorMessage,
+ CDecompressStat &st)
+{
+ st.Clear();
+ UInt64 totalPackSize = 0;
+ CRecordVector<UInt64> arcSizes;
+
+ unsigned numArcs = options.StdInMode ? 1 : arcPaths.Size();
+
+ unsigned i;
+
+ for (i = 0; i < numArcs; i++)
+ {
+ NFind::CFileInfo fi;
+ fi.Size = 0;
+ if (!options.StdInMode)
+ {
+ const FString arcPath = us2fs(arcPaths[i]);
+ if (!fi.Find_FollowLink(arcPath))
+ {
+ const HRESULT errorCode = GetLastError_noZero_HRESULT();
+ SetErrorMessage("Cannot find archive file", arcPath, errorCode, errorMessage);
+ return errorCode;
+ }
+ if (fi.IsDir())
+ {
+ HRESULT errorCode = E_FAIL;
+ SetErrorMessage("The item is a directory", arcPath, errorCode, errorMessage);
+ return errorCode;
+ }
+ }
+ arcSizes.Add(fi.Size);
+ totalPackSize += fi.Size;
+ }
+
+ CBoolArr skipArcs(numArcs);
+ for (i = 0; i < numArcs; i++)
+ skipArcs[i] = false;
+
+ CArchiveExtractCallback *ecs = new CArchiveExtractCallback;
+ CMyComPtr<IArchiveExtractCallback> ec(ecs);
+
+ const bool multi = (numArcs > 1);
+
+ ecs->InitForMulti(multi,
+ options.PathMode,
+ options.OverwriteMode,
+ options.ZoneMode,
+ false // keepEmptyDirParts
+ );
+ #ifndef Z7_SFX
+ ecs->SetHashMethods(hash);
+ #endif
+
+ if (multi)
+ {
+ RINOK(faeCallback->SetTotal(totalPackSize))
+ }
+
+ UInt64 totalPackProcessed = 0;
+ bool thereAreNotOpenArcs = false;
+
+ for (i = 0; i < numArcs; i++)
+ {
+ if (skipArcs[i])
+ continue;
+
+ ecs->InitBeforeNewArchive();
+
+ const UString &arcPath = arcPaths[i];
+ NFind::CFileInfo fi;
+ if (options.StdInMode)
+ {
+ // do we need ctime and mtime?
+ fi.ClearBase();
+ fi.Size = 0; // (UInt64)(Int64)-1;
+ fi.SetAsFile();
+ // NTime::GetCurUtc_FiTime(fi.MTime);
+ // fi.CTime = fi.ATime = fi.MTime;
+ }
+ else
+ {
+ if (!fi.Find_FollowLink(us2fs(arcPath)) || fi.IsDir())
+ {
+ const HRESULT errorCode = GetLastError_noZero_HRESULT();
+ SetErrorMessage("Cannot find archive file", us2fs(arcPath), errorCode, errorMessage);
+ return errorCode;
+ }
+ }
+
+ /*
+ #ifndef Z7_NO_CRYPTO
+ openCallback->Open_Clear_PasswordWasAsked_Flag();
+ #endif
+ */
+
+ RINOK(extractCallback->BeforeOpen(arcPath, options.TestMode))
+ CArchiveLink arcLink;
+
+ CObjectVector<COpenType> types2 = types;
+ /*
+ #ifndef Z7_SFX
+ if (types.IsEmpty())
+ {
+ int pos = arcPath.ReverseFind(L'.');
+ if (pos >= 0)
+ {
+ UString s = arcPath.Ptr(pos + 1);
+ int index = codecs->FindFormatForExtension(s);
+ if (index >= 0 && s == L"001")
+ {
+ s = arcPath.Left(pos);
+ pos = s.ReverseFind(L'.');
+ if (pos >= 0)
+ {
+ int index2 = codecs->FindFormatForExtension(s.Ptr(pos + 1));
+ if (index2 >= 0) // && s.CompareNoCase(L"rar") != 0
+ {
+ types2.Add(index2);
+ types2.Add(index);
+ }
+ }
+ }
+ }
+ }
+ #endif
+ */
+
+ COpenOptions op;
+ #ifndef Z7_SFX
+ op.props = &options.Properties;
+ #endif
+ op.codecs = codecs;
+ op.types = &types2;
+ op.excludedFormats = &excludedFormats;
+ op.stdInMode = options.StdInMode;
+ op.stream = NULL;
+ op.filePath = arcPath;
+
+ HRESULT result = arcLink.Open_Strict(op, openCallback);
+
+ if (result == E_ABORT)
+ return result;
+
+ // arcLink.Set_ErrorsText();
+ RINOK(extractCallback->OpenResult(codecs, arcLink, arcPath, result))
+
+ if (result != S_OK)
+ {
+ thereAreNotOpenArcs = true;
+ if (!options.StdInMode)
+ totalPackProcessed += fi.Size;
+ continue;
+ }
+
+ #if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
+ if (options.ZoneMode != NExtract::NZoneIdMode::kNone
+ && !options.StdInMode)
+ {
+ ReadZoneFile_Of_BaseFile(us2fs(arcPath), ecs->ZoneBuf);
+ }
+ #endif
+
+
+ if (arcLink.Arcs.Size() != 0)
+ {
+ if (arcLink.GetArc()->IsHashHandler(op))
+ {
+ if (!options.TestMode)
+ {
+ /* real Extracting to files is possible.
+ But user can think that hash archive contains real files.
+ So we block extracting here. */
+ // v23.00 : we don't break process.
+ RINOK(extractCallback->OpenResult(codecs, arcLink, arcPath, E_NOTIMPL))
+ thereAreNotOpenArcs = true;
+ if (!options.StdInMode)
+ totalPackProcessed += fi.Size;
+ continue;
+ // return E_NOTIMPL; // before v23
+ }
+ FString dirPrefix = us2fs(options.HashDir);
+ if (dirPrefix.IsEmpty())
+ {
+ if (!NFile::NDir::GetOnlyDirPrefix(us2fs(arcPath), dirPrefix))
+ {
+ // return GetLastError_noZero_HRESULT();
+ }
+ }
+ if (!dirPrefix.IsEmpty())
+ NName::NormalizeDirPathPrefix(dirPrefix);
+ ecs->DirPathPrefix_for_HashFiles = dirPrefix;
+ }
+ }
+
+ if (!options.StdInMode)
+ {
+ // numVolumes += arcLink.VolumePaths.Size();
+ // arcLink.VolumesSize;
+
+ // totalPackSize -= DeleteUsedFileNamesFromList(arcLink, i + 1, arcPaths, arcPathsFull, &arcSizes);
+ // numArcs = arcPaths.Size();
+ if (arcLink.VolumePaths.Size() != 0)
+ {
+ Int64 correctionSize = (Int64)arcLink.VolumesSize;
+ FOR_VECTOR (v, arcLink.VolumePaths)
+ {
+ int index = Find_FileName_InSortedVector(arcPathsFull, arcLink.VolumePaths[v]);
+ if (index >= 0)
+ {
+ if ((unsigned)index > i)
+ {
+ skipArcs[(unsigned)index] = true;
+ correctionSize -= arcSizes[(unsigned)index];
+ }
+ }
+ }
+ if (correctionSize != 0)
+ {
+ Int64 newPackSize = (Int64)totalPackSize + correctionSize;
+ if (newPackSize < 0)
+ newPackSize = 0;
+ totalPackSize = (UInt64)newPackSize;
+ RINOK(faeCallback->SetTotal(totalPackSize))
+ }
+ }
+ }
+
+ /*
+ // Now openCallback and extractCallback use same object. So we don't need to send password.
+
+ #ifndef Z7_NO_CRYPTO
+ bool passwordIsDefined;
+ UString password;
+ RINOK(openCallback->Open_GetPasswordIfAny(passwordIsDefined, password))
+ if (passwordIsDefined)
+ {
+ RINOK(extractCallback->SetPassword(password))
+ }
+ #endif
+ */
+
+ CArc &arc = arcLink.Arcs.Back();
+ arc.MTime.Def = !options.StdInMode
+ #ifdef _WIN32
+ && !fi.IsDevice
+ #endif
+ ;
+ if (arc.MTime.Def)
+ arc.MTime.Set_From_FiTime(fi.MTime);
+
+ UInt64 packProcessed;
+ const bool calcCrc =
+ #ifndef Z7_SFX
+ (hash != NULL);
+ #else
+ false;
+ #endif
+
+ RINOK(DecompressArchive(
+ codecs,
+ arcLink,
+ fi.Size + arcLink.VolumesSize,
+ wildcardCensor,
+ options,
+ calcCrc,
+ extractCallback, faeCallback, ecs,
+ errorMessage, packProcessed))
+
+ if (!options.StdInMode)
+ packProcessed = fi.Size + arcLink.VolumesSize;
+ totalPackProcessed += packProcessed;
+ ecs->LocalProgressSpec->InSize += packProcessed;
+ ecs->LocalProgressSpec->OutSize = ecs->UnpackSize;
+ if (!errorMessage.IsEmpty())
+ return E_FAIL;
+ }
+
+ if (multi || thereAreNotOpenArcs)
+ {
+ RINOK(faeCallback->SetTotal(totalPackSize))
+ RINOK(faeCallback->SetCompleted(&totalPackProcessed))
+ }
+
+ st.NumFolders = ecs->NumFolders;
+ st.NumFiles = ecs->NumFiles;
+ st.NumAltStreams = ecs->NumAltStreams;
+ st.UnpackSize = ecs->UnpackSize;
+ st.AltStreams_UnpackSize = ecs->AltStreams_UnpackSize;
+ st.NumArchives = arcPaths.Size();
+ st.PackSize = ecs->LocalProgressSpec->InSize;
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Common/Extract.h b/CPP/7zip/UI/Common/Extract.h
index 9c806be..b20f607 100644
--- a/CPP/7zip/UI/Common/Extract.h
+++ b/CPP/7zip/UI/Common/Extract.h
@@ -1,94 +1,106 @@
-// Extract.h
-
-#ifndef __EXTRACT_H
-#define __EXTRACT_H
-
-#include "../../../Windows/FileFind.h"
-
-#include "../../Archive/IArchive.h"
-
-#include "ArchiveExtractCallback.h"
-#include "ArchiveOpenCallback.h"
-#include "ExtractMode.h"
-#include "Property.h"
-
-#include "../Common/LoadCodecs.h"
-
-struct CExtractOptionsBase
-{
- CBoolPair ElimDup;
-
- bool PathMode_Force;
- bool OverwriteMode_Force;
- NExtract::NPathMode::EEnum PathMode;
- NExtract::NOverwriteMode::EEnum OverwriteMode;
-
- FString OutputDir;
- CExtractNtOptions NtOptions;
-
- CExtractOptionsBase():
- PathMode_Force(false),
- OverwriteMode_Force(false),
- PathMode(NExtract::NPathMode::kFullPaths),
- OverwriteMode(NExtract::NOverwriteMode::kAsk)
- {}
-};
-
-struct CExtractOptions: public CExtractOptionsBase
-{
- bool StdInMode;
- bool StdOutMode;
- bool YesToAll;
- bool TestMode;
-
- // bool ShowDialog;
- // bool PasswordEnabled;
- // UString Password;
- #ifndef _SFX
- CObjectVector<CProperty> Properties;
- #endif
-
- #ifdef EXTERNAL_CODECS
- CCodecs *Codecs;
- #endif
-
- CExtractOptions():
- TestMode(false),
- StdInMode(false),
- StdOutMode(false),
- YesToAll(false)
- {}
-};
-
-struct CDecompressStat
-{
- UInt64 NumArchives;
- UInt64 UnpackSize;
- UInt64 AltStreams_UnpackSize;
- UInt64 PackSize;
- UInt64 NumFolders;
- UInt64 NumFiles;
- UInt64 NumAltStreams;
-
- void Clear()
- {
- NumArchives = UnpackSize = AltStreams_UnpackSize = PackSize = NumFolders = NumFiles = NumAltStreams = 0;
- }
-};
-
-HRESULT Extract(
- CCodecs *codecs,
- const CObjectVector<COpenType> &types,
- const CIntVector &excludedFormats,
- UStringVector &archivePaths, UStringVector &archivePathsFull,
- const NWildcard::CCensorNode &wildcardCensor,
- const CExtractOptions &options,
- IOpenCallbackUI *openCallback,
- IExtractCallbackUI *extractCallback,
- #ifndef _SFX
- IHashCalc *hash,
- #endif
- UString &errorMessage,
- CDecompressStat &st);
-
-#endif
+// Extract.h
+
+#ifndef ZIP7_INC_EXTRACT_H
+#define ZIP7_INC_EXTRACT_H
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "ArchiveExtractCallback.h"
+#include "ArchiveOpenCallback.h"
+#include "ExtractMode.h"
+#include "Property.h"
+
+#include "../Common/LoadCodecs.h"
+
+struct CExtractOptionsBase
+{
+ CBoolPair ElimDup;
+
+ bool ExcludeDirItems;
+ bool ExcludeFileItems;
+
+ bool PathMode_Force;
+ bool OverwriteMode_Force;
+ NExtract::NPathMode::EEnum PathMode;
+ NExtract::NOverwriteMode::EEnum OverwriteMode;
+ NExtract::NZoneIdMode::EEnum ZoneMode;
+
+ FString OutputDir;
+ CExtractNtOptions NtOptions;
+ UString HashDir;
+
+ CExtractOptionsBase():
+ ExcludeDirItems(false),
+ ExcludeFileItems(false),
+ PathMode_Force(false),
+ OverwriteMode_Force(false),
+ PathMode(NExtract::NPathMode::kFullPaths),
+ OverwriteMode(NExtract::NOverwriteMode::kAsk),
+ ZoneMode(NExtract::NZoneIdMode::kNone)
+ {}
+};
+
+struct CExtractOptions: public CExtractOptionsBase
+{
+ bool StdInMode;
+ bool StdOutMode;
+ bool YesToAll;
+ bool TestMode;
+
+ // bool ShowDialog;
+ // bool PasswordEnabled;
+ // UString Password;
+ #ifndef Z7_SFX
+ CObjectVector<CProperty> Properties;
+ #endif
+
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ CCodecs *Codecs;
+ #endif
+ */
+
+ CExtractOptions():
+ StdInMode(false),
+ StdOutMode(false),
+ YesToAll(false),
+ TestMode(false)
+ {}
+};
+
+struct CDecompressStat
+{
+ UInt64 NumArchives;
+ UInt64 UnpackSize;
+ UInt64 AltStreams_UnpackSize;
+ UInt64 PackSize;
+ UInt64 NumFolders;
+ UInt64 NumFiles;
+ UInt64 NumAltStreams;
+
+ void Clear()
+ {
+ NumArchives = UnpackSize = AltStreams_UnpackSize = PackSize = NumFolders = NumFiles = NumAltStreams = 0;
+ }
+};
+
+HRESULT Extract(
+ // DECL_EXTERNAL_CODECS_LOC_VARS
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &types,
+ const CIntVector &excludedFormats,
+ UStringVector &archivePaths, UStringVector &archivePathsFull,
+ const NWildcard::CCensorNode &wildcardCensor,
+ const CExtractOptions &options,
+ IOpenCallbackUI *openCallback,
+ IExtractCallbackUI *extractCallback,
+ IFolderArchiveExtractCallback *faeCallback,
+ #ifndef Z7_SFX
+ IHashCalc *hash,
+ #endif
+ UString &errorMessage,
+ CDecompressStat &st);
+
+#endif
diff --git a/CPP/7zip/UI/Common/ExtractMode.h b/CPP/7zip/UI/Common/ExtractMode.h
index c28b7cc..6e38f26 100644
--- a/CPP/7zip/UI/Common/ExtractMode.h
+++ b/CPP/7zip/UI/Common/ExtractMode.h
@@ -1,34 +1,44 @@
-// ExtractMode.h
-
-#ifndef __EXTRACT_MODE_H
-#define __EXTRACT_MODE_H
-
-namespace NExtract {
-
-namespace NPathMode
-{
- enum EEnum
- {
- kFullPaths,
- kCurPaths,
- kNoPaths,
- kAbsPaths,
- kNoPathsAlt // alt streams must be extracted without name of base file
- };
-}
-
-namespace NOverwriteMode
-{
- enum EEnum
- {
- kAsk,
- kOverwrite,
- kSkip,
- kRename,
- kRenameExisting
- };
-}
-
-}
-
-#endif
+// ExtractMode.h
+
+#ifndef ZIP7_INC_EXTRACT_MODE_H
+#define ZIP7_INC_EXTRACT_MODE_H
+
+namespace NExtract {
+
+namespace NPathMode
+{
+ enum EEnum
+ {
+ kFullPaths,
+ kCurPaths,
+ kNoPaths,
+ kAbsPaths,
+ kNoPathsAlt // alt streams must be extracted without name of base file
+ };
+}
+
+namespace NOverwriteMode
+{
+ enum EEnum
+ {
+ kAsk,
+ kOverwrite,
+ kSkip,
+ kRename,
+ kRenameExisting
+ };
+}
+
+namespace NZoneIdMode
+{
+ enum EEnum
+ {
+ kNone,
+ kAll,
+ kOffice
+ };
+}
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Common/ExtractingFilePath.cpp b/CPP/7zip/UI/Common/ExtractingFilePath.cpp
index 13665de..88da4ad 100644
--- a/CPP/7zip/UI/Common/ExtractingFilePath.cpp
+++ b/CPP/7zip/UI/Common/ExtractingFilePath.cpp
@@ -1,280 +1,296 @@
-// ExtractingFilePath.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileName.h"
-
-#include "ExtractingFilePath.h"
-
-bool g_PathTrailReplaceMode =
- #ifdef _WIN32
- true
- #else
- false
- #endif
- ;
-
-
-static void ReplaceIncorrectChars(UString &s)
-{
- {
- for (unsigned i = 0; i < s.Len(); i++)
- {
- wchar_t c = s[i];
- if (
- #ifdef _WIN32
- c == ':' || c == '*' || c == '?' || c < 0x20 || c == '<' || c == '>' || c == '|' || c == '"'
- || c == '/'
- // || c == 0x202E // RLO
- ||
- #endif
- c == WCHAR_PATH_SEPARATOR)
- s.ReplaceOneCharAtPos(i, '_');
- }
- }
-
- if (g_PathTrailReplaceMode)
- {
- /*
- // if (g_PathTrailReplaceMode == 1)
- {
- if (!s.IsEmpty())
- {
- wchar_t c = s.Back();
- if (c == '.' || c == ' ')
- {
- // s += (wchar_t)(0x9c); // STRING TERMINATOR
- s += (wchar_t)'_';
- }
- }
- }
- else
- */
- {
- unsigned i;
- for (i = s.Len(); i != 0;)
- {
- wchar_t c = s[i - 1];
- if (c != '.' && c != ' ')
- break;
- i--;
- s.ReplaceOneCharAtPos(i, '_');
- // s.ReplaceOneCharAtPos(i, (c == ' ' ? (wchar_t)(0x2423) : (wchar_t)0x00B7));
- }
- /*
- if (g_PathTrailReplaceMode > 1 && i != s.Len())
- {
- s.DeleteFrom(i);
- }
- */
- }
- }
-}
-
-#ifdef _WIN32
-
-/* WinXP-64 doesn't support ':', '\\' and '/' symbols in name of alt stream.
- But colon in postfix ":$DATA" is allowed.
- WIN32 functions don't allow empty alt stream name "name:" */
-
-void Correct_AltStream_Name(UString &s)
-{
- unsigned len = s.Len();
- const unsigned kPostfixSize = 6;
- if (s.Len() >= kPostfixSize
- && StringsAreEqualNoCase_Ascii(s.RightPtr(kPostfixSize), ":$DATA"))
- len -= kPostfixSize;
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = s[i];
- if (c == ':' || c == '\\' || c == '/'
- || c == 0x202E // RLO
- )
- s.ReplaceOneCharAtPos(i, '_');
- }
- if (s.IsEmpty())
- s = '_';
-}
-
-static const unsigned g_ReservedWithNum_Index = 4;
-
-static const char * const g_ReservedNames[] =
-{
- "CON", "PRN", "AUX", "NUL",
- "COM", "LPT"
-};
-
-static bool IsSupportedName(const UString &name)
-{
- for (unsigned i = 0; i < ARRAY_SIZE(g_ReservedNames); i++)
- {
- const char *reservedName = g_ReservedNames[i];
- unsigned len = MyStringLen(reservedName);
- if (name.Len() < len)
- continue;
- if (!name.IsPrefixedBy_Ascii_NoCase(reservedName))
- continue;
- if (i >= g_ReservedWithNum_Index)
- {
- wchar_t c = name[len];
- if (c < L'0' || c > L'9')
- continue;
- len++;
- }
- for (;;)
- {
- wchar_t c = name[len++];
- if (c == 0 || c == '.')
- return false;
- if (c != ' ')
- break;
- }
- }
- return true;
-}
-
-static void CorrectUnsupportedName(UString &name)
-{
- if (!IsSupportedName(name))
- name.InsertAtFront(L'_');
-}
-
-#endif
-
-static void Correct_PathPart(UString &s)
-{
- // "." and ".."
- if (s.IsEmpty())
- return;
-
- if (s[0] == '.' && (s[1] == 0 || s[1] == '.' && s[2] == 0))
- s.Empty();
- #ifdef _WIN32
- else
- ReplaceIncorrectChars(s);
- #endif
-}
-
-// static const char * const k_EmptyReplaceName = "[]";
-static const char k_EmptyReplaceName = '_';
-
-UString Get_Correct_FsFile_Name(const UString &name)
-{
- UString res = name;
- Correct_PathPart(res);
-
- #ifdef _WIN32
- CorrectUnsupportedName(res);
- #endif
-
- if (res.IsEmpty())
- res = k_EmptyReplaceName;
- return res;
-}
-
-
-void Correct_FsPath(bool absIsAllowed, bool keepAndReplaceEmptyPrefixes, UStringVector &parts, bool isDir)
-{
- unsigned i = 0;
-
- if (absIsAllowed)
- {
- #if defined(_WIN32) && !defined(UNDER_CE)
- bool isDrive = false;
- #endif
-
- if (parts[0].IsEmpty())
- {
- i = 1;
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (parts.Size() > 1 && parts[1].IsEmpty())
- {
- i = 2;
- if (parts.Size() > 2 && parts[2] == L"?")
- {
- i = 3;
- if (parts.Size() > 3 && NWindows::NFile::NName::IsDrivePath2(parts[3]))
- {
- isDrive = true;
- i = 4;
- }
- }
- }
- #endif
- }
- #if defined(_WIN32) && !defined(UNDER_CE)
- else if (NWindows::NFile::NName::IsDrivePath2(parts[0]))
- {
- isDrive = true;
- i = 1;
- }
-
- if (isDrive)
- {
- // we convert "c:name" to "c:\name", if absIsAllowed path.
- UString &ds = parts[i - 1];
- if (ds.Len() > 2)
- {
- parts.Insert(i, ds.Ptr(2));
- ds.DeleteFrom(2);
- }
- }
- #endif
- }
-
- if (i != 0)
- keepAndReplaceEmptyPrefixes = false;
-
- for (; i < parts.Size();)
- {
- UString &s = parts[i];
-
- Correct_PathPart(s);
-
- if (s.IsEmpty())
- {
- if (!keepAndReplaceEmptyPrefixes)
- if (isDir || i != parts.Size() - 1)
- {
- parts.Delete(i);
- continue;
- }
- s = k_EmptyReplaceName;
- }
- else
- {
- keepAndReplaceEmptyPrefixes = false;
- #ifdef _WIN32
- CorrectUnsupportedName(s);
- #endif
- }
-
- i++;
- }
-
- if (!isDir)
- {
- if (parts.IsEmpty())
- parts.Add((UString)k_EmptyReplaceName);
- else
- {
- UString &s = parts.Back();
- if (s.IsEmpty())
- s = k_EmptyReplaceName;
- }
- }
-}
-
-UString MakePathFromParts(const UStringVector &parts)
-{
- UString s;
- FOR_VECTOR (i, parts)
- {
- if (i != 0)
- s.Add_PathSepar();
- s += parts[i];
- }
- return s;
-}
+// ExtractingFilePath.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileName.h"
+
+#include "ExtractingFilePath.h"
+
+extern
+bool g_PathTrailReplaceMode;
+bool g_PathTrailReplaceMode =
+ #ifdef _WIN32
+ true
+ #else
+ false
+ #endif
+ ;
+
+
+#ifdef _WIN32
+static void ReplaceIncorrectChars(UString &s)
+{
+ {
+ for (unsigned i = 0; i < s.Len(); i++)
+ {
+ wchar_t c = s[i];
+ if (
+ #ifdef _WIN32
+ c == ':' || c == '*' || c == '?' || c < 0x20 || c == '<' || c == '>' || c == '|' || c == '"'
+ || c == '/'
+ // || c == 0x202E // RLO
+ ||
+ #endif
+ c == WCHAR_PATH_SEPARATOR)
+ {
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ // 22.00 : WSL replacement for backslash
+ if (c == WCHAR_PATH_SEPARATOR)
+ c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT;
+ else
+ #endif
+ c = '_';
+ s.ReplaceOneCharAtPos(i,
+ c
+ // (wchar_t)(0xf000 + c) // 21.02 debug: WSL encoding for unsupported characters
+ );
+ }
+ }
+ }
+
+ if (g_PathTrailReplaceMode)
+ {
+ /*
+ // if (g_PathTrailReplaceMode == 1)
+ {
+ if (!s.IsEmpty())
+ {
+ wchar_t c = s.Back();
+ if (c == '.' || c == ' ')
+ {
+ // s += (wchar_t)(0x9c); // STRING TERMINATOR
+ s += (wchar_t)'_';
+ }
+ }
+ }
+ else
+ */
+ {
+ unsigned i;
+ for (i = s.Len(); i != 0;)
+ {
+ wchar_t c = s[i - 1];
+ if (c != '.' && c != ' ')
+ break;
+ i--;
+ s.ReplaceOneCharAtPos(i, '_');
+ // s.ReplaceOneCharAtPos(i, (c == ' ' ? (wchar_t)(0x2423) : (wchar_t)0x00B7));
+ }
+ /*
+ if (g_PathTrailReplaceMode > 1 && i != s.Len())
+ {
+ s.DeleteFrom(i);
+ }
+ */
+ }
+ }
+}
+#endif
+
+/* WinXP-64 doesn't support ':', '\\' and '/' symbols in name of alt stream.
+ But colon in postfix ":$DATA" is allowed.
+ WIN32 functions don't allow empty alt stream name "name:" */
+
+void Correct_AltStream_Name(UString &s)
+{
+ unsigned len = s.Len();
+ const unsigned kPostfixSize = 6;
+ if (s.Len() >= kPostfixSize
+ && StringsAreEqualNoCase_Ascii(s.RightPtr(kPostfixSize), ":$DATA"))
+ len -= kPostfixSize;
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = s[i];
+ if (c == ':' || c == '\\' || c == '/'
+ || c == 0x202E // RLO
+ )
+ s.ReplaceOneCharAtPos(i, '_');
+ }
+ if (s.IsEmpty())
+ s = '_';
+}
+
+#ifdef _WIN32
+
+static const unsigned g_ReservedWithNum_Index = 4;
+
+static const char * const g_ReservedNames[] =
+{
+ "CON", "PRN", "AUX", "NUL",
+ "COM", "LPT"
+};
+
+static bool IsSupportedName(const UString &name)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_ReservedNames); i++)
+ {
+ const char *reservedName = g_ReservedNames[i];
+ unsigned len = MyStringLen(reservedName);
+ if (name.Len() < len)
+ continue;
+ if (!name.IsPrefixedBy_Ascii_NoCase(reservedName))
+ continue;
+ if (i >= g_ReservedWithNum_Index)
+ {
+ wchar_t c = name[len];
+ if (c < L'0' || c > L'9')
+ continue;
+ len++;
+ }
+ for (;;)
+ {
+ wchar_t c = name[len++];
+ if (c == 0 || c == '.')
+ return false;
+ if (c != ' ')
+ break;
+ }
+ }
+ return true;
+}
+
+static void CorrectUnsupportedName(UString &name)
+{
+ if (!IsSupportedName(name))
+ name.InsertAtFront(L'_');
+}
+
+#endif
+
+static void Correct_PathPart(UString &s)
+{
+ // "." and ".."
+ if (s.IsEmpty())
+ return;
+
+ if (s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
+ s.Empty();
+ #ifdef _WIN32
+ else
+ ReplaceIncorrectChars(s);
+ #endif
+}
+
+// static const char * const k_EmptyReplaceName = "[]";
+static const char k_EmptyReplaceName = '_';
+
+UString Get_Correct_FsFile_Name(const UString &name)
+{
+ UString res = name;
+ Correct_PathPart(res);
+
+ #ifdef _WIN32
+ CorrectUnsupportedName(res);
+ #endif
+
+ if (res.IsEmpty())
+ res = k_EmptyReplaceName;
+ return res;
+}
+
+
+void Correct_FsPath(bool absIsAllowed, bool keepAndReplaceEmptyPrefixes, UStringVector &parts, bool isDir)
+{
+ unsigned i = 0;
+
+ if (absIsAllowed)
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ bool isDrive = false;
+ #endif
+
+ if (parts[0].IsEmpty())
+ {
+ i = 1;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (parts.Size() > 1 && parts[1].IsEmpty())
+ {
+ i = 2;
+ if (parts.Size() > 2 && parts[2] == L"?")
+ {
+ i = 3;
+ if (parts.Size() > 3 && NWindows::NFile::NName::IsDrivePath2(parts[3]))
+ {
+ isDrive = true;
+ i = 4;
+ }
+ }
+ }
+ #endif
+ }
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ else if (NWindows::NFile::NName::IsDrivePath2(parts[0]))
+ {
+ isDrive = true;
+ i = 1;
+ }
+
+ if (isDrive)
+ {
+ // we convert "c:name" to "c:\name", if absIsAllowed path.
+ UString &ds = parts[i - 1];
+ if (ds.Len() > 2)
+ {
+ parts.Insert(i, ds.Ptr(2));
+ ds.DeleteFrom(2);
+ }
+ }
+ #endif
+ }
+
+ if (i != 0)
+ keepAndReplaceEmptyPrefixes = false;
+
+ for (; i < parts.Size();)
+ {
+ UString &s = parts[i];
+
+ Correct_PathPart(s);
+
+ if (s.IsEmpty())
+ {
+ if (!keepAndReplaceEmptyPrefixes)
+ if (isDir || i != parts.Size() - 1)
+ {
+ parts.Delete(i);
+ continue;
+ }
+ s = k_EmptyReplaceName;
+ }
+ else
+ {
+ keepAndReplaceEmptyPrefixes = false;
+ #ifdef _WIN32
+ CorrectUnsupportedName(s);
+ #endif
+ }
+
+ i++;
+ }
+
+ if (!isDir)
+ {
+ if (parts.IsEmpty())
+ parts.Add((UString)k_EmptyReplaceName);
+ else
+ {
+ UString &s = parts.Back();
+ if (s.IsEmpty())
+ s = k_EmptyReplaceName;
+ }
+ }
+}
+
+UString MakePathFromParts(const UStringVector &parts)
+{
+ UString s;
+ FOR_VECTOR (i, parts)
+ {
+ if (i != 0)
+ s.Add_PathSepar();
+ s += parts[i];
+ }
+ return s;
+}
diff --git a/CPP/7zip/UI/Common/ExtractingFilePath.h b/CPP/7zip/UI/Common/ExtractingFilePath.h
index 12eb0ba..bb1732f 100644
--- a/CPP/7zip/UI/Common/ExtractingFilePath.h
+++ b/CPP/7zip/UI/Common/ExtractingFilePath.h
@@ -1,31 +1,31 @@
-// ExtractingFilePath.h
-
-#ifndef __EXTRACTING_FILE_PATH_H
-#define __EXTRACTING_FILE_PATH_H
-
-#include "../../../Common/MyString.h"
-
-#ifdef _WIN32
-void Correct_AltStream_Name(UString &s);
-#endif
-
-// replaces unsuported characters, and replaces "." , ".." and "" to "[]"
-UString Get_Correct_FsFile_Name(const UString &name);
-
-/*
- Correct_FsPath() corrects path parts to prepare it for File System operations.
- It also corrects empty path parts like "\\\\":
- - frontal empty path parts : it removes them or changes them to "_"
- - another empty path parts : it removes them
- if (absIsAllowed && path is absolute) : it removes empty path parts after start absolute path prefix marker
- else
- {
- if (!keepAndReplaceEmptyPrefixes) : it removes empty path parts
- if ( keepAndReplaceEmptyPrefixes) : it changes each empty frontal path part to "_"
- }
-*/
-void Correct_FsPath(bool absIsAllowed, bool keepAndReplaceEmptyPrefixes, UStringVector &parts, bool isDir);
-
-UString MakePathFromParts(const UStringVector &parts);
-
-#endif
+// ExtractingFilePath.h
+
+#ifndef ZIP7_INC_EXTRACTING_FILE_PATH_H
+#define ZIP7_INC_EXTRACTING_FILE_PATH_H
+
+#include "../../../Common/MyString.h"
+
+// #ifdef _WIN32
+void Correct_AltStream_Name(UString &s);
+// #endif
+
+// replaces unsuported characters, and replaces "." , ".." and "" to "[]"
+UString Get_Correct_FsFile_Name(const UString &name);
+
+/*
+ Correct_FsPath() corrects path parts to prepare it for File System operations.
+ It also corrects empty path parts like "\\\\":
+ - frontal empty path parts : it removes them or changes them to "_"
+ - another empty path parts : it removes them
+ if (absIsAllowed && path is absolute) : it removes empty path parts after start absolute path prefix marker
+ else
+ {
+ if (!keepAndReplaceEmptyPrefixes) : it removes empty path parts
+ if ( keepAndReplaceEmptyPrefixes) : it changes each empty frontal path part to "_"
+ }
+*/
+void Correct_FsPath(bool absIsAllowed, bool keepAndReplaceEmptyPrefixes, UStringVector &parts, bool isDir);
+
+UString MakePathFromParts(const UStringVector &parts);
+
+#endif
diff --git a/CPP/7zip/UI/Common/HashCalc.cpp b/CPP/7zip/UI/Common/HashCalc.cpp
index 822018d..94c8a06 100644
--- a/CPP/7zip/UI/Common/HashCalc.cpp
+++ b/CPP/7zip/UI/Common/HashCalc.cpp
@@ -1,347 +1,2110 @@
-// HashCalc.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/Alloc.h"
-
-#include "../../../Common/StringToInt.h"
-
-#include "../../Common/FileStreams.h"
-#include "../../Common/StreamUtils.h"
-
-#include "EnumDirItems.h"
-#include "HashCalc.h"
-
-using namespace NWindows;
-
-class CHashMidBuf
-{
- void *_data;
-public:
- CHashMidBuf(): _data(0) {}
- operator void *() { return _data; }
- bool Alloc(size_t size)
- {
- if (_data != 0)
- return false;
- _data = ::MidAlloc(size);
- return _data != 0;
- }
- ~CHashMidBuf() { ::MidFree(_data); }
-};
-
-static const char * const k_DefaultHashMethod = "CRC32";
-
-HRESULT CHashBundle::SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVector &hashMethods)
-{
- UStringVector names = hashMethods;
- if (names.IsEmpty())
- names.Add(UString(k_DefaultHashMethod));
-
- CRecordVector<CMethodId> ids;
- CObjectVector<COneMethodInfo> methods;
-
- unsigned i;
- for (i = 0; i < names.Size(); i++)
- {
- COneMethodInfo m;
- RINOK(m.ParseMethodFromString(names[i]));
-
- if (m.MethodName.IsEmpty())
- m.MethodName = k_DefaultHashMethod;
-
- if (m.MethodName == "*")
- {
- CRecordVector<CMethodId> tempMethods;
- GetHashMethods(EXTERNAL_CODECS_LOC_VARS tempMethods);
- methods.Clear();
- ids.Clear();
- FOR_VECTOR (t, tempMethods)
- {
- unsigned index = ids.AddToUniqueSorted(tempMethods[t]);
- if (ids.Size() != methods.Size())
- methods.Insert(index, m);
- }
- break;
- }
- else
- {
- // m.MethodName.RemoveChar(L'-');
- CMethodId id;
- if (!FindHashMethod(EXTERNAL_CODECS_LOC_VARS m.MethodName, id))
- return E_NOTIMPL;
- unsigned index = ids.AddToUniqueSorted(id);
- if (ids.Size() != methods.Size())
- methods.Insert(index, m);
- }
- }
-
- for (i = 0; i < ids.Size(); i++)
- {
- CMyComPtr<IHasher> hasher;
- AString name;
- RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS ids[i], name, hasher));
- if (!hasher)
- throw "Can't create hasher";
- const COneMethodInfo &m = methods[i];
- {
- CMyComPtr<ICompressSetCoderProperties> scp;
- hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
- if (scp)
- RINOK(m.SetCoderProps(scp, NULL));
- }
- UInt32 digestSize = hasher->GetDigestSize();
- if (digestSize > k_HashCalc_DigestSize_Max)
- return E_NOTIMPL;
- CHasherState &h = Hashers.AddNew();
- h.Hasher = hasher;
- h.Name = name;
- h.DigestSize = digestSize;
- for (unsigned k = 0; k < k_HashCalc_NumGroups; k++)
- memset(h.Digests[k], 0, digestSize);
- }
-
- return S_OK;
-}
-
-void CHashBundle::InitForNewFile()
-{
- CurSize = 0;
- FOR_VECTOR (i, Hashers)
- {
- CHasherState &h = Hashers[i];
- h.Hasher->Init();
- memset(h.Digests[k_HashCalc_Index_Current], 0, h.DigestSize);
- }
-}
-
-void CHashBundle::Update(const void *data, UInt32 size)
-{
- CurSize += size;
- FOR_VECTOR (i, Hashers)
- Hashers[i].Hasher->Update(data, size);
-}
-
-void CHashBundle::SetSize(UInt64 size)
-{
- CurSize = size;
-}
-
-static void AddDigests(Byte *dest, const Byte *src, UInt32 size)
-{
- unsigned next = 0;
- for (UInt32 i = 0; i < size; i++)
- {
- next += (unsigned)dest[i] + (unsigned)src[i];
- dest[i] = (Byte)next;
- next >>= 8;
- }
-}
-
-void CHashBundle::Final(bool isDir, bool isAltStream, const UString &path)
-{
- if (isDir)
- NumDirs++;
- else if (isAltStream)
- {
- NumAltStreams++;
- AltStreamsSize += CurSize;
- }
- else
- {
- NumFiles++;
- FilesSize += CurSize;
- }
-
- Byte pre[16];
- memset(pre, 0, sizeof(pre));
- if (isDir)
- pre[0] = 1;
-
- FOR_VECTOR (i, Hashers)
- {
- CHasherState &h = Hashers[i];
- if (!isDir)
- {
- h.Hasher->Final(h.Digests[0]);
- if (!isAltStream)
- AddDigests(h.Digests[k_HashCalc_Index_DataSum], h.Digests[0], h.DigestSize);
- }
-
- h.Hasher->Init();
- h.Hasher->Update(pre, sizeof(pre));
- h.Hasher->Update(h.Digests[0], h.DigestSize);
-
- for (unsigned k = 0; k < path.Len(); k++)
- {
- wchar_t c = path[k];
- Byte temp[2] = { (Byte)(c & 0xFF), (Byte)((c >> 8) & 0xFF) };
- h.Hasher->Update(temp, 2);
- }
-
- Byte tempDigest[k_HashCalc_DigestSize_Max];
- h.Hasher->Final(tempDigest);
- if (!isAltStream)
- AddDigests(h.Digests[k_HashCalc_Index_NamesSum], tempDigest, h.DigestSize);
- AddDigests(h.Digests[k_HashCalc_Index_StreamsSum], tempDigest, h.DigestSize);
- }
-}
-
-
-HRESULT HashCalc(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const NWildcard::CCensor &censor,
- const CHashOptions &options,
- AString &errorInfo,
- IHashCallbackUI *callback)
-{
- CDirItems dirItems;
- dirItems.Callback = callback;
-
- if (options.StdInMode)
- {
- CDirItem di;
- di.Size = (UInt64)(Int64)-1;
- di.Attrib = 0;
- di.MTime.dwLowDateTime = 0;
- di.MTime.dwHighDateTime = 0;
- di.CTime = di.ATime = di.MTime;
- dirItems.Items.Add(di);
- }
- else
- {
- RINOK(callback->StartScanning());
- dirItems.ScanAltStreams = options.AltStreamsMode;
-
- HRESULT res = EnumerateItems(censor,
- options.PathMode,
- UString(),
- dirItems);
-
- if (res != S_OK)
- {
- if (res != E_ABORT)
- errorInfo = "Scanning error";
- return res;
- }
- RINOK(callback->FinishScanning(dirItems.Stat));
- }
-
- unsigned i;
- CHashBundle hb;
- RINOK(hb.SetMethods(EXTERNAL_CODECS_LOC_VARS options.Methods));
- // hb.Init();
-
- hb.NumErrors = dirItems.Stat.NumErrors;
-
- if (options.StdInMode)
- {
- RINOK(callback->SetNumFiles(1));
- }
- else
- {
- RINOK(callback->SetTotal(dirItems.Stat.GetTotalBytes()));
- }
-
- const UInt32 kBufSize = 1 << 15;
- CHashMidBuf buf;
- if (!buf.Alloc(kBufSize))
- return E_OUTOFMEMORY;
-
- UInt64 completeValue = 0;
-
- RINOK(callback->BeforeFirstFile(hb));
-
- for (i = 0; i < dirItems.Items.Size(); i++)
- {
- CMyComPtr<ISequentialInStream> inStream;
- UString path;
- bool isDir = false;
- bool isAltStream = false;
- if (options.StdInMode)
- {
- inStream = new CStdInFileStream;
- }
- else
- {
- CInFileStream *inStreamSpec = new CInFileStream;
- inStream = inStreamSpec;
- const CDirItem &dirItem = dirItems.Items[i];
- isDir = dirItem.IsDir();
- isAltStream = dirItem.IsAltStream;
- path = dirItems.GetLogPath(i);
- if (!isDir)
- {
- FString phyPath = dirItems.GetPhyPath(i);
- if (!inStreamSpec->OpenShared(phyPath, options.OpenShareForWrite))
- {
- HRESULT res = callback->OpenFileError(phyPath, ::GetLastError());
- hb.NumErrors++;
- if (res != S_FALSE)
- return res;
- continue;
- }
- }
- }
- RINOK(callback->GetStream(path, isDir));
- UInt64 fileSize = 0;
-
- hb.InitForNewFile();
- if (!isDir)
- {
- for (UInt32 step = 0;; step++)
- {
- if ((step & 0xFF) == 0)
- RINOK(callback->SetCompleted(&completeValue));
- UInt32 size;
- RINOK(inStream->Read(buf, kBufSize, &size));
- if (size == 0)
- break;
- hb.Update(buf, size);
- fileSize += size;
- completeValue += size;
- }
- }
- hb.Final(isDir, isAltStream, path);
- RINOK(callback->SetOperationResult(fileSize, hb, !isDir));
- RINOK(callback->SetCompleted(&completeValue));
- }
- return callback->AfterLastFile(hb);
-}
-
-
-static inline char GetHex(unsigned v)
-{
- return (char)((v < 10) ? ('0' + v) : ('A' + (v - 10)));
-}
-
-void AddHashHexToString(char *dest, const Byte *data, UInt32 size)
-{
- dest[size * 2] = 0;
-
- if (!data)
- {
- for (UInt32 i = 0; i < size; i++)
- {
- dest[0] = ' ';
- dest[1] = ' ';
- dest += 2;
- }
- return;
- }
-
- int step = 2;
- if (size <= 8)
- {
- step = -2;
- dest += size * 2 - 2;
- }
-
- for (UInt32 i = 0; i < size; i++)
- {
- unsigned b = data[i];
- dest[0] = GetHex((b >> 4) & 0xF);
- dest[1] = GetHex(b & 0xF);
- dest += step;
- }
-}
+// HashCalc.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Alloc.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/DynLimBuf.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamObjects.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Archive/Common/ItemNameUtils.h"
+#include "../../Archive/IArchive.h"
+
+#include "EnumDirItems.h"
+#include "HashCalc.h"
+
+using namespace NWindows;
+
+#ifdef Z7_EXTERNAL_CODECS
+extern const CExternalCodecs *g_ExternalCodecs_Ptr;
+#endif
+
+class CHashMidBuf
+{
+ void *_data;
+public:
+ CHashMidBuf(): _data(NULL) {}
+ operator void *() { return _data; }
+ bool Alloc(size_t size)
+ {
+ if (_data)
+ return false;
+ _data = ::MidAlloc(size);
+ return _data != NULL;
+ }
+ ~CHashMidBuf() { ::MidFree(_data); }
+};
+
+static const char * const k_DefaultHashMethod = "CRC32";
+
+HRESULT CHashBundle::SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVector &hashMethods)
+{
+ UStringVector names = hashMethods;
+ if (names.IsEmpty())
+ names.Add(UString(k_DefaultHashMethod));
+
+ CRecordVector<CMethodId> ids;
+ CObjectVector<COneMethodInfo> methods;
+
+ unsigned i;
+ for (i = 0; i < names.Size(); i++)
+ {
+ COneMethodInfo m;
+ RINOK(m.ParseMethodFromString(names[i]))
+
+ if (m.MethodName.IsEmpty())
+ m.MethodName = k_DefaultHashMethod;
+
+ if (m.MethodName == "*")
+ {
+ CRecordVector<CMethodId> tempMethods;
+ GetHashMethods(EXTERNAL_CODECS_LOC_VARS tempMethods);
+ methods.Clear();
+ ids.Clear();
+ FOR_VECTOR (t, tempMethods)
+ {
+ unsigned index = ids.AddToUniqueSorted(tempMethods[t]);
+ if (ids.Size() != methods.Size())
+ methods.Insert(index, m);
+ }
+ break;
+ }
+ else
+ {
+ // m.MethodName.RemoveChar(L'-');
+ CMethodId id;
+ if (!FindHashMethod(EXTERNAL_CODECS_LOC_VARS m.MethodName, id))
+ return E_NOTIMPL;
+ unsigned index = ids.AddToUniqueSorted(id);
+ if (ids.Size() != methods.Size())
+ methods.Insert(index, m);
+ }
+ }
+
+ for (i = 0; i < ids.Size(); i++)
+ {
+ CMyComPtr<IHasher> hasher;
+ AString name;
+ RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS ids[i], name, hasher))
+ if (!hasher)
+ throw "Can't create hasher";
+ const COneMethodInfo &m = methods[i];
+ {
+ CMyComPtr<ICompressSetCoderProperties> scp;
+ hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
+ if (scp)
+ RINOK(m.SetCoderProps(scp, NULL))
+ }
+ const UInt32 digestSize = hasher->GetDigestSize();
+ if (digestSize > k_HashCalc_DigestSize_Max)
+ return E_NOTIMPL;
+ CHasherState &h = Hashers.AddNew();
+ h.DigestSize = digestSize;
+ h.Hasher = hasher;
+ h.Name = name;
+ for (unsigned k = 0; k < k_HashCalc_NumGroups; k++)
+ h.InitDigestGroup(k);
+ }
+
+ return S_OK;
+}
+
+void CHashBundle::InitForNewFile()
+{
+ CurSize = 0;
+ FOR_VECTOR (i, Hashers)
+ {
+ CHasherState &h = Hashers[i];
+ h.Hasher->Init();
+ h.InitDigestGroup(k_HashCalc_Index_Current);
+ }
+}
+
+void CHashBundle::Update(const void *data, UInt32 size)
+{
+ CurSize += size;
+ FOR_VECTOR (i, Hashers)
+ Hashers[i].Hasher->Update(data, size);
+}
+
+void CHashBundle::SetSize(UInt64 size)
+{
+ CurSize = size;
+}
+
+static void AddDigests(Byte *dest, const Byte *src, UInt32 size)
+{
+ unsigned next = 0;
+ /*
+ // we could use big-endian addition for sha-1 and sha-256
+ // but another hashers are little-endian
+ if (size > 8)
+ {
+ for (unsigned i = size; i != 0;)
+ {
+ i--;
+ next += (unsigned)dest[i] + (unsigned)src[i];
+ dest[i] = (Byte)next;
+ next >>= 8;
+ }
+ }
+ else
+ */
+ {
+ for (unsigned i = 0; i < size; i++)
+ {
+ next += (unsigned)dest[i] + (unsigned)src[i];
+ dest[i] = (Byte)next;
+ next >>= 8;
+ }
+ }
+
+ // we use little-endian to store extra bytes
+ dest += k_HashCalc_DigestSize_Max;
+ for (unsigned i = 0; i < k_HashCalc_ExtraSize; i++)
+ {
+ next += (unsigned)dest[i];
+ dest[i] = (Byte)next;
+ next >>= 8;
+ }
+}
+
+void CHasherState::AddDigest(unsigned groupIndex, const Byte *data)
+{
+ NumSums[groupIndex]++;
+ AddDigests(Digests[groupIndex], data, DigestSize);
+}
+
+void CHashBundle::Final(bool isDir, bool isAltStream, const UString &path)
+{
+ if (isDir)
+ NumDirs++;
+ else if (isAltStream)
+ {
+ NumAltStreams++;
+ AltStreamsSize += CurSize;
+ }
+ else
+ {
+ NumFiles++;
+ FilesSize += CurSize;
+ }
+
+ Byte pre[16];
+ memset(pre, 0, sizeof(pre));
+ if (isDir)
+ pre[0] = 1;
+
+ FOR_VECTOR (i, Hashers)
+ {
+ CHasherState &h = Hashers[i];
+ if (!isDir)
+ {
+ h.Hasher->Final(h.Digests[0]); // k_HashCalc_Index_Current
+ if (!isAltStream)
+ h.AddDigest(k_HashCalc_Index_DataSum, h.Digests[0]);
+ }
+
+ h.Hasher->Init();
+ h.Hasher->Update(pre, sizeof(pre));
+ h.Hasher->Update(h.Digests[0], h.DigestSize);
+
+ for (unsigned k = 0; k < path.Len(); k++)
+ {
+ wchar_t c = path[k];
+
+ // 21.04: we want same hash for linux and windows paths
+ #if CHAR_PATH_SEPARATOR != '/'
+ if (c == CHAR_PATH_SEPARATOR)
+ c = '/';
+ // if (c == (wchar_t)('\\' + 0xf000)) c = '\\'; // to debug WSL
+ // if (c > 0xf000 && c < 0xf080) c -= 0xf000; // to debug WSL
+ #endif
+
+ Byte temp[2] = { (Byte)(c & 0xFF), (Byte)((c >> 8) & 0xFF) };
+ h.Hasher->Update(temp, 2);
+ }
+
+ Byte tempDigest[k_HashCalc_DigestSize_Max];
+ h.Hasher->Final(tempDigest);
+ if (!isAltStream)
+ h.AddDigest(k_HashCalc_Index_NamesSum, tempDigest);
+ h.AddDigest(k_HashCalc_Index_StreamsSum, tempDigest);
+ }
+}
+
+
+static void CSum_Name_OriginalToEscape(const AString &src, AString &dest)
+{
+ dest.Empty();
+ for (unsigned i = 0; i < src.Len();)
+ {
+ char c = src[i++];
+ if (c == '\n')
+ {
+ dest += '\\';
+ c = 'n';
+ }
+ else if (c == '\\')
+ dest += '\\';
+ dest += c;
+ }
+}
+
+
+static bool CSum_Name_EscapeToOriginal(const char *s, AString &dest)
+{
+ bool isOK = true;
+ dest.Empty();
+ for (;;)
+ {
+ char c = *s++;
+ if (c == 0)
+ break;
+ if (c == '\\')
+ {
+ const char c1 = *s;
+ if (c1 == 'n')
+ {
+ c = '\n';
+ s++;
+ }
+ else if (c1 == '\\')
+ {
+ c = c1;
+ s++;
+ }
+ else
+ {
+ // original md5sum returns NULL for such bad strings
+ isOK = false;
+ }
+ }
+ dest += c;
+ }
+ return isOK;
+}
+
+
+
+static void SetSpacesAndNul(char *s, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ s[i] = ' ';
+ s[num] = 0;
+}
+
+static const unsigned kHashColumnWidth_Min = 4 * 2;
+
+static unsigned GetColumnWidth(unsigned digestSize)
+{
+ const unsigned width = digestSize * 2;
+ return width < kHashColumnWidth_Min ? kHashColumnWidth_Min: width;
+}
+
+
+static void AddHashResultLine(
+ AString &_s,
+ // bool showHash,
+ // UInt64 fileSize, bool showSize,
+ const CObjectVector<CHasherState> &hashers
+ // unsigned digestIndex, = k_HashCalc_Index_Current
+ )
+{
+ FOR_VECTOR (i, hashers)
+ {
+ const CHasherState &h = hashers[i];
+ char s[k_HashCalc_DigestSize_Max * 2 + 64];
+ s[0] = 0;
+ // if (showHash)
+ HashHexToString(s, h.Digests[k_HashCalc_Index_Current], h.DigestSize);
+ const unsigned pos = (unsigned)strlen(s);
+ const int numSpaces = (int)GetColumnWidth(h.DigestSize) - (int)pos;
+ if (numSpaces > 0)
+ SetSpacesAndNul(s + pos, (unsigned)numSpaces);
+ if (i != 0)
+ _s.Add_Space();
+ _s += s;
+ }
+
+ /*
+ if (showSize)
+ {
+ _s.Add_Space();
+ static const unsigned kSizeField_Len = 13; // same as in HashCon.cpp
+ char s[kSizeField_Len + 32];
+ char *p = s;
+ SetSpacesAndNul(s, kSizeField_Len);
+ p = s + kSizeField_Len;
+ ConvertUInt64ToString(fileSize, p);
+ int numSpaces = (int)kSizeField_Len - (int)strlen(p);
+ if (numSpaces > 0)
+ p -= (unsigned)numSpaces;
+ _s += p;
+ }
+ */
+}
+
+
+static void Add_LF(CDynLimBuf &hashFileString, const CHashOptionsLocal &options)
+{
+ hashFileString += (char)(options.HashMode_Zero.Val ? 0 : '\n');
+}
+
+
+
+
+static void WriteLine(CDynLimBuf &hashFileString,
+ const CHashOptionsLocal &options,
+ const UString &path2,
+ bool isDir,
+ const AString &methodName,
+ const AString &hashesString)
+{
+ if (options.HashMode_OnlyHash.Val)
+ {
+ hashFileString += hashesString;
+ Add_LF(hashFileString, options);
+ return;
+ }
+
+ UString path = path2;
+
+ bool isBin = false;
+ const bool zeroMode = options.HashMode_Zero.Val;
+ const bool tagMode = options.HashMode_Tag.Val;
+
+#if CHAR_PATH_SEPARATOR != '/'
+ path.Replace(WCHAR_PATH_SEPARATOR, L'/');
+ // path.Replace((wchar_t)('\\' + 0xf000), L'\\'); // to debug WSL
+#endif
+
+ AString utf8;
+ ConvertUnicodeToUTF8(path, utf8);
+
+ AString esc;
+ CSum_Name_OriginalToEscape(utf8, esc);
+
+ if (!zeroMode)
+ {
+ if (esc != utf8)
+ {
+ /* Original md5sum writes escape in that case.
+ We do same for compatibility with original md5sum. */
+ hashFileString += '\\';
+ }
+ }
+
+ if (isDir && !esc.IsEmpty() && esc.Back() != '/')
+ esc += '/';
+
+ if (tagMode)
+ {
+ if (!methodName.IsEmpty())
+ {
+ hashFileString += methodName;
+ hashFileString += ' ';
+ }
+ hashFileString += '(';
+ hashFileString += esc;
+ hashFileString += ')';
+ hashFileString += " = ";
+ }
+
+ hashFileString += hashesString;
+
+ if (!tagMode)
+ {
+ hashFileString += ' ';
+ hashFileString += (char)(isBin ? '*' : ' ');
+ hashFileString += esc;
+ }
+
+ Add_LF(hashFileString, options);
+}
+
+
+
+static void WriteLine(CDynLimBuf &hashFileString,
+ const CHashOptionsLocal &options,
+ const UString &path,
+ bool isDir,
+ const CHashBundle &hb)
+{
+ AString methodName;
+ if (!hb.Hashers.IsEmpty())
+ methodName = hb.Hashers[0].Name;
+
+ AString hashesString;
+ AddHashResultLine(hashesString, hb.Hashers);
+ WriteLine(hashFileString, options, path, isDir, methodName, hashesString);
+}
+
+
+HRESULT HashCalc(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const NWildcard::CCensor &censor,
+ const CHashOptions &options,
+ AString &errorInfo,
+ IHashCallbackUI *callback)
+{
+ CDirItems dirItems;
+ dirItems.Callback = callback;
+
+ if (options.StdInMode)
+ {
+ CDirItem di;
+ di.Size = (UInt64)(Int64)-1;
+ di.SetAsFile();
+ dirItems.Items.Add(di);
+ }
+ else
+ {
+ RINOK(callback->StartScanning())
+
+ dirItems.SymLinks = options.SymLinks.Val;
+ dirItems.ScanAltStreams = options.AltStreamsMode;
+ dirItems.ExcludeDirItems = censor.ExcludeDirItems;
+ dirItems.ExcludeFileItems = censor.ExcludeFileItems;
+
+ dirItems.ShareForWrite = options.OpenShareForWrite;
+
+ HRESULT res = EnumerateItems(censor,
+ options.PathMode,
+ UString(),
+ dirItems);
+
+ if (res != S_OK)
+ {
+ if (res != E_ABORT)
+ errorInfo = "Scanning error";
+ return res;
+ }
+ RINOK(callback->FinishScanning(dirItems.Stat))
+ }
+
+ unsigned i;
+ CHashBundle hb;
+ RINOK(hb.SetMethods(EXTERNAL_CODECS_LOC_VARS options.Methods))
+ // hb.Init();
+
+ hb.NumErrors = dirItems.Stat.NumErrors;
+
+ UInt64 totalSize = 0;
+ if (options.StdInMode)
+ {
+ RINOK(callback->SetNumFiles(1))
+ }
+ else
+ {
+ totalSize = dirItems.Stat.GetTotalBytes();
+ RINOK(callback->SetTotal(totalSize))
+ }
+
+ const UInt32 kBufSize = 1 << 15;
+ CHashMidBuf buf;
+ if (!buf.Alloc(kBufSize))
+ return E_OUTOFMEMORY;
+
+ UInt64 completeValue = 0;
+
+ RINOK(callback->BeforeFirstFile(hb))
+
+ /*
+ CDynLimBuf hashFileString((size_t)1 << 31);
+ const bool needGenerate = !options.HashFilePath.IsEmpty();
+ */
+
+ for (i = 0; i < dirItems.Items.Size(); i++)
+ {
+ CMyComPtr<ISequentialInStream> inStream;
+ UString path;
+ bool isDir = false;
+ bool isAltStream = false;
+
+ if (options.StdInMode)
+ {
+ inStream = new CStdInFileStream;
+ }
+ else
+ {
+ path = dirItems.GetLogPath(i);
+ const CDirItem &di = dirItems.Items[i];
+ #ifdef _WIN32
+ isAltStream = di.IsAltStream;
+ #endif
+
+ #ifndef UNDER_CE
+ // if (di.AreReparseData())
+ if (di.ReparseData.Size() != 0)
+ {
+ CBufInStream *inStreamSpec = new CBufInStream();
+ inStream = inStreamSpec;
+ inStreamSpec->Init(di.ReparseData, di.ReparseData.Size());
+ }
+ else
+ #endif
+ {
+ CInFileStream *inStreamSpec = new CInFileStream;
+ inStreamSpec->Set_PreserveATime(options.PreserveATime);
+ inStream = inStreamSpec;
+ isDir = di.IsDir();
+ if (!isDir)
+ {
+ const FString phyPath = dirItems.GetPhyPath(i);
+ if (!inStreamSpec->OpenShared(phyPath, options.OpenShareForWrite))
+ {
+ HRESULT res = callback->OpenFileError(phyPath, ::GetLastError());
+ hb.NumErrors++;
+ if (res != S_FALSE)
+ return res;
+ continue;
+ }
+ if (!options.StdInMode)
+ {
+ UInt64 curSize = 0;
+ if (inStreamSpec->GetSize(&curSize) == S_OK)
+ {
+ if (curSize > di.Size)
+ {
+ totalSize += curSize - di.Size;
+ RINOK(callback->SetTotal(totalSize))
+ // printf("\ntotal = %d MiB\n", (unsigned)(totalSize >> 20));
+ }
+ }
+ }
+ // inStreamSpec->ReloadProps();
+ }
+ }
+ }
+
+ RINOK(callback->GetStream(path, isDir))
+ UInt64 fileSize = 0;
+
+ hb.InitForNewFile();
+
+ if (!isDir)
+ {
+ for (UInt32 step = 0;; step++)
+ {
+ if ((step & 0xFF) == 0)
+ {
+ // printf("\ncompl = %d\n", (unsigned)(completeValue >> 20));
+ RINOK(callback->SetCompleted(&completeValue))
+ }
+ UInt32 size;
+ RINOK(inStream->Read(buf, kBufSize, &size))
+ if (size == 0)
+ break;
+ hb.Update(buf, size);
+ fileSize += size;
+ completeValue += size;
+ }
+ }
+
+ hb.Final(isDir, isAltStream, path);
+
+ /*
+ if (needGenerate
+ && (options.HashMode_Dirs.Val || !isDir))
+ {
+ WriteLine(hashFileString,
+ options,
+ path, // change it
+ isDir,
+ hb);
+
+ if (hashFileString.IsError())
+ return E_OUTOFMEMORY;
+ }
+ */
+
+ RINOK(callback->SetOperationResult(fileSize, hb, !isDir))
+ RINOK(callback->SetCompleted(&completeValue))
+ }
+
+ /*
+ if (needGenerate)
+ {
+ NFile::NIO::COutFile file;
+ if (!file.Create(us2fs(options.HashFilePath), true)) // createAlways
+ return GetLastError_noZero_HRESULT();
+ if (!file.WriteFull(hashFileString, hashFileString.Len()))
+ return GetLastError_noZero_HRESULT();
+ }
+ */
+
+ return callback->AfterLastFile(hb);
+}
+
+
+static inline char GetHex_Upper(unsigned v)
+{
+ return (char)((v < 10) ? ('0' + v) : ('A' + (v - 10)));
+}
+
+static inline char GetHex_Lower(unsigned v)
+{
+ return (char)((v < 10) ? ('0' + v) : ('a' + (v - 10)));
+}
+
+void HashHexToString(char *dest, const Byte *data, UInt32 size)
+{
+ dest[size * 2] = 0;
+
+ if (!data)
+ {
+ for (UInt32 i = 0; i < size; i++)
+ {
+ dest[0] = ' ';
+ dest[1] = ' ';
+ dest += 2;
+ }
+ return;
+ }
+
+ if (size <= 8)
+ {
+ dest += size * 2;
+ for (UInt32 i = 0; i < size; i++)
+ {
+ const unsigned b = data[i];
+ dest -= 2;
+ dest[0] = GetHex_Upper((b >> 4) & 0xF);
+ dest[1] = GetHex_Upper(b & 0xF);
+ }
+ }
+ else
+ {
+ for (UInt32 i = 0; i < size; i++)
+ {
+ const unsigned b = data[i];
+ dest[0] = GetHex_Lower((b >> 4) & 0xF);
+ dest[1] = GetHex_Lower(b & 0xF);
+ dest += 2;
+ }
+ }
+}
+
+void CHasherState::WriteToString(unsigned digestIndex, char *s) const
+{
+ HashHexToString(s, Digests[digestIndex], DigestSize);
+
+ if (digestIndex != 0 && NumSums[digestIndex] != 1)
+ {
+ unsigned numExtraBytes = GetNumExtraBytes_for_Group(digestIndex);
+ if (numExtraBytes > 4)
+ numExtraBytes = 8;
+ else // if (numExtraBytes >= 0)
+ numExtraBytes = 4;
+ // if (numExtraBytes != 0)
+ {
+ s += strlen(s);
+ *s++ = '-';
+ // *s = 0;
+ HashHexToString(s, GetExtraData_for_Group(digestIndex), numExtraBytes);
+ }
+ }
+}
+
+
+
+// ---------- Hash Handler ----------
+
+namespace NHash {
+
+static size_t ParseHexString(const char *s, Byte *dest) throw()
+{
+ size_t num;
+ for (num = 0;; num++, s += 2)
+ {
+ unsigned c = (Byte)s[0];
+ unsigned v0;
+ if (c >= '0' && c <= '9') v0 = (c - '0');
+ else if (c >= 'A' && c <= 'F') v0 = 10 + (c - 'A');
+ else if (c >= 'a' && c <= 'f') v0 = 10 + (c - 'a');
+ else
+ return num;
+ c = (Byte)s[1];
+ unsigned v1;
+ if (c >= '0' && c <= '9') v1 = (c - '0');
+ else if (c >= 'A' && c <= 'F') v1 = 10 + (c - 'A');
+ else if (c >= 'a' && c <= 'f') v1 = 10 + (c - 'a');
+ else
+ return num;
+ if (dest)
+ dest[num] = (Byte)(v1 | (v0 << 4));
+ }
+}
+
+
+#define IsWhite(c) ((c) == ' ' || (c) == '\t')
+
+bool CHashPair::IsDir() const
+{
+ if (Name.IsEmpty() || Name.Back() != '/')
+ return false;
+ // here we expect that Dir items contain only zeros or no Hash
+ for (size_t i = 0; i < Hash.Size(); i++)
+ if (Hash[i] != 0)
+ return false;
+ return true;
+}
+
+
+bool CHashPair::ParseCksum(const char *s)
+{
+ const char *end;
+
+ const UInt32 crc = ConvertStringToUInt32(s, &end);
+ if (*end != ' ')
+ return false;
+ end++;
+
+ const UInt64 size = ConvertStringToUInt64(end, &end);
+ if (*end != ' ')
+ return false;
+ end++;
+
+ Name = end;
+
+ Hash.Alloc(4);
+ SetBe32(Hash, crc)
+
+ Size_from_Arc = size;
+ Size_from_Arc_Defined = true;
+
+ return true;
+}
+
+
+
+static const char *SkipWhite(const char *s)
+{
+ while (IsWhite(*s))
+ s++;
+ return s;
+}
+
+static const char * const k_CsumMethodNames[] =
+{
+ "sha256"
+ , "sha224"
+// , "sha512/224"
+// , "sha512/256"
+ , "sha512"
+ , "sha384"
+ , "sha1"
+ , "md5"
+ , "blake2b"
+ , "crc64"
+ , "crc32"
+ , "cksum"
+};
+
+static UString GetMethod_from_FileName(const UString &name)
+{
+ AString s;
+ ConvertUnicodeToUTF8(name, s);
+ const int dotPos = s.ReverseFind_Dot();
+ const char *src = s.Ptr();
+ bool isExtension = false;
+ if (dotPos >= 0)
+ {
+ isExtension = true;
+ src = s.Ptr(dotPos + 1);
+ }
+ const char *m = "";
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(k_CsumMethodNames); i++)
+ {
+ m = k_CsumMethodNames[i];
+ if (isExtension)
+ {
+ if (StringsAreEqual_Ascii(src, m))
+ break;
+ }
+ else if (IsString1PrefixedByString2_NoCase_Ascii(src, m))
+ if (StringsAreEqual_Ascii(src + strlen(m), "sums"))
+ break;
+ }
+ UString res;
+ if (i != Z7_ARRAY_SIZE(k_CsumMethodNames))
+ res = m;
+ return res;
+}
+
+
+bool CHashPair::Parse(const char *s)
+{
+ // here we keep compatibility with original md5sum / shasum
+ bool escape = false;
+
+ s = SkipWhite(s);
+
+ if (*s == '\\')
+ {
+ s++;
+ escape = true;
+ }
+
+ // const char *kMethod = GetMethod_from_FileName(s);
+ // if (kMethod)
+ if (ParseHexString(s, NULL) < 4)
+ {
+ // BSD-style checksum line
+ {
+ const char *s2 = s;
+ for (; *s2 != 0; s2++)
+ {
+ const char c = *s2;
+ if (c == 0)
+ return false;
+ if (c == ' ' || c == '(')
+ break;
+ }
+ Method.SetFrom(s, (unsigned)(s2 - s));
+ s = s2;
+ }
+ IsBSD = true;
+ if (*s == ' ')
+ s++;
+ if (*s != '(')
+ return false;
+ s++;
+ {
+ const char *s2 = s;
+ for (; *s2 != 0; s2++)
+ {}
+ for (;;)
+ {
+ s2--;
+ if (s2 < s)
+ return false;
+ if (*s2 == ')')
+ break;
+ }
+ Name.SetFrom(s, (unsigned)(s2 - s));
+ s = s2 + 1;
+ }
+
+ s = SkipWhite(s);
+ if (*s != '=')
+ return false;
+ s++;
+ s = SkipWhite(s);
+ }
+
+ {
+ const size_t num = ParseHexString(s, NULL);
+ Hash.Alloc(num);
+ ParseHexString(s, Hash);
+ const size_t numChars = num * 2;
+ HashString.SetFrom(s, (unsigned)numChars);
+ s += numChars;
+ }
+
+ if (IsBSD)
+ {
+ if (*s != 0)
+ return false;
+ if (escape)
+ {
+ const AString temp (Name);
+ return CSum_Name_EscapeToOriginal(temp, Name);
+ }
+ return true;
+ }
+
+ if (*s == 0)
+ return true;
+
+ if (*s != ' ')
+ return false;
+ s++;
+ const char c = *s;
+ if (c != ' '
+ && c != '*'
+ && c != 'U' // shasum Universal
+ && c != '^' // shasum 0/1
+ )
+ return false;
+ Mode = c;
+ s++;
+ if (escape)
+ return CSum_Name_EscapeToOriginal(s, Name);
+ Name = s;
+ return true;
+}
+
+
+static bool GetLine(CByteBuffer &buf, bool zeroMode, bool cr_lf_Mode, size_t &posCur, AString &s)
+{
+ s.Empty();
+ size_t pos = posCur;
+ const Byte *p = buf;
+ unsigned numDigits = 0;
+ for (; pos < buf.Size(); pos++)
+ {
+ const Byte b = p[pos];
+ if (b == 0)
+ {
+ numDigits = 1;
+ break;
+ }
+ if (zeroMode)
+ continue;
+ if (b == 0x0a)
+ {
+ numDigits = 1;
+ break;
+ }
+ if (!cr_lf_Mode)
+ continue;
+ if (b == 0x0d)
+ {
+ if (pos + 1 >= buf.Size())
+ {
+ numDigits = 1;
+ break;
+ // return false;
+ }
+ if (p[pos + 1] == 0x0a)
+ {
+ numDigits = 2;
+ break;
+ }
+ }
+ }
+ s.SetFrom((const char *)(p + posCur), (unsigned)(pos - posCur));
+ posCur = pos + numDigits;
+ return true;
+}
+
+
+static bool Is_CR_LF_Data(const Byte *buf, size_t size)
+{
+ bool isCrLf = false;
+ for (size_t i = 0; i < size;)
+ {
+ const Byte b = buf[i];
+ if (b == 0x0a)
+ return false;
+ if (b == 0x0d)
+ {
+ if (i == size - 1)
+ return false;
+ if (buf[i + 1] != 0x0a)
+ return false;
+ isCrLf = true;
+ i += 2;
+ }
+ else
+ i++;
+ }
+ return isCrLf;
+}
+
+
+static const Byte kArcProps[] =
+{
+ // kpidComment,
+ kpidCharacts
+};
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidPackSize,
+ kpidMethod
+};
+
+static const Byte kRawProps[] =
+{
+ kpidChecksum
+};
+
+
+Z7_COM7F_IMF(CHandler::GetParent(UInt32 /* index */ , UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = Z7_ARRAY_SIZE(kRawProps);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+{
+ *propID = kRawProps[index];
+ *name = NULL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (propID == kpidChecksum)
+ {
+ const CHashPair &hp = HashPairs[index];
+ if (hp.Hash.Size() > 0)
+ {
+ *data = hp.Hash;
+ *dataSize = (UInt32)hp.Hash.Size();
+ *propType = NPropDataType::kRaw;
+ }
+ return S_OK;
+ }
+
+ return S_OK;
+}
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = HashPairs.Size();
+ return S_OK;
+}
+
+static void Add_OptSpace_String(UString &dest, const char *src)
+{
+ dest.Add_Space_if_NotEmpty();
+ dest += src;
+}
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
+ /*
+ case kpidErrorFlags:
+ {
+ UInt32 v = 0;
+ if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+ // if (_sres == k_Base64_RES_NeedMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
+ if (v != 0)
+ prop = v;
+ break;
+ }
+ */
+ case kpidCharacts:
+ {
+ UString s;
+ if (_hashSize_Defined)
+ {
+ s.Add_Space_if_NotEmpty();
+ s.Add_UInt32(_hashSize * 8);
+ s += "-bit";
+ }
+ if (!_nameExtenstion.IsEmpty())
+ {
+ s.Add_Space_if_NotEmpty();
+ s += _nameExtenstion;
+ }
+ if (_is_PgpMethod)
+ {
+ Add_OptSpace_String(s, "PGP");
+ if (!_pgpMethod.IsEmpty())
+ {
+ s += ":";
+ s += _pgpMethod;
+ }
+ }
+ if (_is_ZeroMode)
+ Add_OptSpace_String(s, "ZERO");
+ if (_are_there_Tags)
+ Add_OptSpace_String(s, "TAG");
+ if (_are_there_Dirs)
+ Add_OptSpace_String(s, "DIRS");
+ prop = s;
+ break;
+ }
+
+ case kpidReadOnly:
+ {
+ if (_isArc)
+ if (!CanUpdate())
+ prop = true;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ // COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ CHashPair &hp = HashPairs[index];
+ switch (propID)
+ {
+ case kpidIsDir:
+ {
+ prop = hp.IsDir();
+ break;
+ }
+ case kpidPath:
+ {
+ UString path;
+ hp.Get_UString_Path(path);
+
+ NArchive::NItemName::ReplaceToOsSlashes_Remove_TailSlash(path,
+ true); // useBackslashReplacement
+
+ prop = path;
+ break;
+ }
+ case kpidSize:
+ {
+ // client needs processed size of last file
+ if (hp.Size_from_Disk_Defined)
+ prop = (UInt64)hp.Size_from_Disk;
+ else if (hp.Size_from_Arc_Defined)
+ prop = (UInt64)hp.Size_from_Arc;
+ break;
+ }
+ case kpidPackSize:
+ {
+ prop = (UInt64)hp.Hash.Size();
+ break;
+ }
+ case kpidMethod:
+ {
+ if (!hp.Method.IsEmpty())
+ prop = hp.Method;
+ break;
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ // COM_TRY_END
+}
+
+
+static HRESULT ReadStream_to_Buf(IInStream *stream, CByteBuffer &buf, IArchiveOpenCallback *openCallback)
+{
+ buf.Free();
+ UInt64 len;
+ RINOK(InStream_AtBegin_GetSize(stream, len))
+ if (len == 0 || len >= ((UInt64)1 << 31))
+ return S_FALSE;
+ buf.Alloc((size_t)len);
+ UInt64 pos = 0;
+ // return ReadStream_FALSE(stream, buf, (size_t)len);
+ for (;;)
+ {
+ const UInt32 kBlockSize = ((UInt32)1 << 24);
+ const UInt32 curSize = (len < kBlockSize) ? (UInt32)len : kBlockSize;
+ UInt32 processedSizeLoc;
+ RINOK(stream->Read((Byte *)buf + pos, curSize, &processedSizeLoc))
+ if (processedSizeLoc == 0)
+ return E_FAIL;
+ len -= processedSizeLoc;
+ pos += processedSizeLoc;
+ if (len == 0)
+ return S_OK;
+ if (openCallback)
+ {
+ const UInt64 files = 0;
+ RINOK(openCallback->SetCompleted(&files, &pos))
+ }
+ }
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *openCallback))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+
+ CByteBuffer buf;
+ RINOK(ReadStream_to_Buf(stream, buf, openCallback))
+
+ CObjectVector<CHashPair> &pairs = HashPairs;
+
+ bool zeroMode = false;
+ bool cr_lf_Mode = false;
+ {
+ for (size_t i = 0; i < buf.Size(); i++)
+ if (buf[i] == 0)
+ {
+ zeroMode = true;
+ break;
+ }
+ }
+ _is_ZeroMode = zeroMode;
+ if (!zeroMode)
+ cr_lf_Mode = Is_CR_LF_Data(buf, buf.Size());
+
+ if (openCallback)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpenVolumeCallback,
+ openVolumeCallback, openCallback)
+ if (openVolumeCallback)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(openVolumeCallback->GetProperty(kpidName, &prop))
+ if (prop.vt == VT_BSTR)
+ _nameExtenstion = GetMethod_from_FileName(prop.bstrVal);
+ }
+ }
+
+ bool cksumMode = false;
+ if (_nameExtenstion.IsEqualTo_Ascii_NoCase("cksum"))
+ cksumMode = true;
+ _is_CksumMode = cksumMode;
+
+ size_t pos = 0;
+ AString s;
+ bool minusMode = false;
+ unsigned numLines = 0;
+
+ while (pos < buf.Size())
+ {
+ if (!GetLine(buf, zeroMode, cr_lf_Mode, pos, s))
+ return S_FALSE;
+ numLines++;
+ if (s.IsEmpty())
+ continue;
+
+ if (s.IsPrefixedBy_Ascii_NoCase("; "))
+ {
+ if (numLines != 1)
+ return S_FALSE;
+ // comment line of FileVerifier++
+ continue;
+ }
+
+ if (s.IsPrefixedBy_Ascii_NoCase("-----"))
+ {
+ if (minusMode)
+ break; // end of pgp mode
+ minusMode = true;
+ if (s.IsPrefixedBy_Ascii_NoCase("-----BEGIN PGP SIGNED MESSAGE"))
+ {
+ if (_is_PgpMethod)
+ return S_FALSE;
+ if (!GetLine(buf, zeroMode, cr_lf_Mode, pos, s))
+ return S_FALSE;
+ const char *kStart = "Hash: ";
+ if (!s.IsPrefixedBy_Ascii_NoCase(kStart))
+ return S_FALSE;
+ _pgpMethod = s.Ptr((unsigned)strlen(kStart));
+ _is_PgpMethod = true;
+ }
+ continue;
+ }
+
+ CHashPair pair;
+ pair.FullLine = s;
+ if (cksumMode)
+ {
+ if (!pair.ParseCksum(s))
+ return S_FALSE;
+ }
+ else if (!pair.Parse(s))
+ return S_FALSE;
+ pairs.Add(pair);
+ }
+
+ {
+ unsigned hashSize = 0;
+ bool hashSize_Dismatch = false;
+ for (unsigned i = 0; i < HashPairs.Size(); i++)
+ {
+ const CHashPair &hp = HashPairs[i];
+ if (i == 0)
+ hashSize = (unsigned)hp.Hash.Size();
+ else
+ if (hashSize != hp.Hash.Size())
+ hashSize_Dismatch = true;
+
+ if (hp.IsBSD)
+ _are_there_Tags = true;
+ if (!_are_there_Dirs && hp.IsDir())
+ _are_there_Dirs = true;
+ }
+ if (!hashSize_Dismatch && hashSize != 0)
+ {
+ _hashSize = hashSize;
+ _hashSize_Defined = true;
+ }
+ }
+
+ _phySize = buf.Size();
+ _isArc = true;
+ return S_OK;
+ }
+ COM_TRY_END
+}
+
+
+void CHandler::ClearVars()
+{
+ _phySize = 0;
+ _isArc = false;
+ _is_CksumMode = false;
+ _is_PgpMethod = false;
+ _is_ZeroMode = false;
+ _are_there_Tags = false;
+ _are_there_Dirs = false;
+ _hashSize_Defined = false;
+ _hashSize = 0;
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ ClearVars();
+ _nameExtenstion.Empty();
+ _pgpMethod.Empty();
+ HashPairs.Clear();
+ return S_OK;
+}
+
+
+static bool CheckDigests(const Byte *a, const Byte *b, size_t size)
+{
+ if (size <= 8)
+ {
+ /* we use reversed order for one digest, when text representation
+ uses big-order for crc-32 and crc-64 */
+ for (size_t i = 0; i < size; i++)
+ if (a[i] != b[size - 1 - i])
+ return false;
+ return true;
+ }
+ {
+ for (size_t i = 0; i < size; i++)
+ if (a[i] != b[i])
+ return false;
+ return true;
+ }
+}
+
+
+static void AddDefaultMethod(UStringVector &methods, unsigned size)
+{
+ const char *m = NULL;
+ if (size == 32) m = "sha256";
+ else if (size == 20) m = "sha1";
+ else if (size == 16) m = "md5";
+ else if (size == 8) m = "crc64";
+ else if (size == 4) m = "crc32";
+ else
+ return;
+ #ifdef Z7_EXTERNAL_CODECS
+ const CExternalCodecs *_externalCodecs = g_ExternalCodecs_Ptr;
+ #endif
+ CMethodId id;
+ if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS
+ AString(m), id))
+ methods.Add(UString(m));
+}
+
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+
+ /*
+ if (testMode == 0)
+ return E_NOTIMPL;
+ */
+
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = HashPairs.Size();
+ if (numItems == 0)
+ return S_OK;
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CExternalCodecs *_externalCodecs = g_ExternalCodecs_Ptr;
+ #endif
+
+ CHashBundle hb_Glob;
+ // UStringVector methods = options.Methods;
+ UStringVector methods;
+
+ if (methods.IsEmpty() && !_nameExtenstion.IsEmpty())
+ {
+ AString utf;
+ ConvertUnicodeToUTF8(_nameExtenstion, utf);
+ CMethodId id;
+ if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS utf, id))
+ methods.Add(_nameExtenstion);
+ }
+
+ if (methods.IsEmpty() && !_pgpMethod.IsEmpty())
+ {
+ CMethodId id;
+ if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS _pgpMethod, id))
+ methods.Add(UString(_pgpMethod));
+ }
+
+ if (methods.IsEmpty() && _pgpMethod.IsEmpty() && _hashSize_Defined)
+ AddDefaultMethod(methods, _hashSize);
+
+ RINOK(hb_Glob.SetMethods(
+ EXTERNAL_CODECS_LOC_VARS
+ methods))
+
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveUpdateCallbackFile,
+ updateCallbackFile, extractCallback)
+ if (!updateCallbackFile)
+ return E_NOTIMPL;
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveGetDiskProperty,
+ GetDiskProperty, extractCallback)
+ if (GetDiskProperty)
+ {
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CHashPair &hp = HashPairs[index];
+ if (hp.IsDir())
+ continue;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(GetDiskProperty->GetDiskProperty(index, kpidSize, &prop))
+ if (prop.vt != VT_UI8)
+ continue;
+ totalSize += prop.uhVal.QuadPart;
+ }
+ }
+ RINOK(extractCallback->SetTotal(totalSize))
+ // RINOK(Hash_SetTotalUnpacked->Hash_SetTotalUnpacked(indices, numItems));
+ }
+ }
+
+ const UInt32 kBufSize = 1 << 15;
+ CHashMidBuf buf;
+ if (!buf.Alloc(kBufSize))
+ return E_OUTOFMEMORY;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+ lps->InSize = lps->OutSize = 0;
+
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ RINOK(lps->SetCur())
+ const UInt32 index = allFilesMode ? i : indices[i];
+
+ CHashPair &hp = HashPairs[index];
+
+ UString path;
+ hp.Get_UString_Path(path);
+
+ CMyComPtr<ISequentialInStream> inStream;
+ const bool isDir = hp.IsDir();
+ if (!isDir)
+ {
+ RINOK(updateCallbackFile->GetStream2(index, &inStream, NUpdateNotifyOp::kHashRead))
+ if (!inStream)
+ {
+ continue; // we have shown error in GetStream2()
+ }
+ // askMode = NArchive::NExtract::NAskMode::kSkip;
+ }
+
+ Int32 askMode = testMode ?
+ NArchive::NExtract::NAskMode::kTest :
+ NArchive::NExtract::NAskMode::kExtract;
+
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+
+ /* PrepareOperation() can expect kExtract to set
+ Attrib and security of output file */
+ askMode = NArchive::NExtract::NAskMode::kReadExternal;
+
+ extractCallback->PrepareOperation(askMode);
+
+ const bool isAltStream = false;
+
+ UInt64 fileSize = 0;
+
+ CHashBundle hb_Loc;
+
+ CHashBundle *hb_Use = &hb_Glob;
+
+ HRESULT res_SetMethods = S_OK;
+
+ UStringVector methods_loc;
+
+ if (!hp.Method.IsEmpty())
+ {
+ hb_Use = &hb_Loc;
+ CMethodId id;
+ if (FindHashMethod(EXTERNAL_CODECS_LOC_VARS hp.Method, id))
+ {
+ methods_loc.Add(UString(hp.Method));
+ RINOK(hb_Loc.SetMethods(
+ EXTERNAL_CODECS_LOC_VARS
+ methods_loc))
+ }
+ else
+ res_SetMethods = E_NOTIMPL;
+ }
+ else if (methods.IsEmpty())
+ {
+ AddDefaultMethod(methods_loc, (unsigned)hp.Hash.Size());
+ if (!methods_loc.IsEmpty())
+ {
+ hb_Use = &hb_Loc;
+ RINOK(hb_Loc.SetMethods(
+ EXTERNAL_CODECS_LOC_VARS
+ methods_loc))
+ }
+ }
+
+ const bool isSupportedMode = hp.IsSupportedMode();
+ hb_Use->InitForNewFile();
+
+ if (inStream)
+ {
+ for (UInt32 step = 0;; step++)
+ {
+ if ((step & 0xFF) == 0)
+ {
+ RINOK(progress->SetRatioInfo(NULL, &fileSize))
+ }
+ UInt32 size;
+ RINOK(inStream->Read(buf, kBufSize, &size))
+ if (size == 0)
+ break;
+ hb_Use->Update(buf, size);
+ if (realOutStream)
+ {
+ RINOK(WriteStream(realOutStream, buf, size))
+ }
+ fileSize += size;
+ }
+
+ hp.Size_from_Disk = fileSize;
+ hp.Size_from_Disk_Defined = true;
+ }
+
+ realOutStream.Release();
+ inStream.Release();
+
+ lps->InSize += hp.Hash.Size();
+ lps->OutSize += fileSize;
+
+ hb_Use->Final(isDir, isAltStream, path);
+
+ Int32 opRes = NArchive::NExtract::NOperationResult::kUnsupportedMethod;
+ if (isSupportedMode
+ && res_SetMethods != E_NOTIMPL
+ && hb_Use->Hashers.Size() > 0
+ )
+ {
+ const CHasherState &hs = hb_Use->Hashers[0];
+ if (hs.DigestSize == hp.Hash.Size())
+ {
+ opRes = NArchive::NExtract::NOperationResult::kCRCError;
+ if (CheckDigests(hp.Hash, hs.Digests[0], hs.DigestSize))
+ if (!hp.Size_from_Arc_Defined || hp.Size_from_Arc == fileSize)
+ opRes = NArchive::NExtract::NOperationResult::kOK;
+ }
+ }
+
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return lps->SetCur();
+
+ COM_TRY_END
+}
+
+
+// ---------- UPDATE ----------
+
+struct CUpdateItem
+{
+ int IndexInArc;
+ unsigned IndexInClient;
+ UInt64 Size;
+ bool NewData;
+ bool NewProps;
+ bool IsDir;
+ UString Path;
+
+ CUpdateItem(): Size(0), IsDir(false) {}
+};
+
+
+static HRESULT GetPropString(IArchiveUpdateCallback *callback, UInt32 index, PROPID propId,
+ UString &res,
+ bool convertSlash)
+{
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(index, propId, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ res = prop.bstrVal;
+ if (convertSlash)
+ NArchive::NItemName::ReplaceSlashes_OsToUnix(res);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::GetFileTimeType(UInt32 *type))
+{
+ *type = NFileTimeType::kUnix;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numItems,
+ IArchiveUpdateCallback *callback))
+{
+ COM_TRY_BEGIN
+
+ if (_isArc && !CanUpdate())
+ return E_NOTIMPL;
+
+ /*
+ Z7_DECL_CMyComPtr_QI_FROM(IArchiveUpdateCallbackArcProp,
+ reportArcProp, callback)
+ */
+
+ CObjectVector<CUpdateItem> updateItems;
+
+ UInt64 complexity = 0;
+
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ CUpdateItem ui;
+ Int32 newData;
+ Int32 newProps;
+ UInt32 indexInArc;
+
+ if (!callback)
+ return E_FAIL;
+
+ RINOK(callback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArc))
+
+ ui.NewProps = IntToBool(newProps);
+ ui.NewData = IntToBool(newData);
+ ui.IndexInArc = (int)indexInArc;
+ ui.IndexInClient = i;
+ if (IntToBool(newProps))
+ {
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidIsDir, &prop))
+ if (prop.vt == VT_EMPTY)
+ ui.IsDir = false;
+ else if (prop.vt != VT_BOOL)
+ return E_INVALIDARG;
+ else
+ ui.IsDir = (prop.boolVal != VARIANT_FALSE);
+ }
+
+ RINOK(GetPropString(callback, i, kpidPath, ui.Path,
+ true)) // convertSlash
+ /*
+ if (ui.IsDir && !ui.Name.IsEmpty() && ui.Name.Back() != '/')
+ ui.Name += '/';
+ */
+ }
+
+ if (IntToBool(newData))
+ {
+ NCOM::CPropVariant prop;
+ RINOK(callback->GetProperty(i, kpidSize, &prop))
+ if (prop.vt == VT_UI8)
+ {
+ ui.Size = prop.uhVal.QuadPart;
+ complexity += ui.Size;
+ }
+ else if (prop.vt == VT_EMPTY)
+ ui.Size = (UInt64)(Int64)-1;
+ else
+ return E_INVALIDARG;
+ }
+
+ updateItems.Add(ui);
+ }
+
+ if (complexity != 0)
+ {
+ RINOK(callback->SetTotal(complexity))
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CExternalCodecs *_externalCodecs = g_ExternalCodecs_Ptr;
+ #endif
+
+ CHashBundle hb;
+ UStringVector methods;
+ if (!_methods.IsEmpty())
+ {
+ FOR_VECTOR(k, _methods)
+ {
+ methods.Add(_methods[k]);
+ }
+ }
+ else if (_crcSize_WasSet)
+ {
+ AddDefaultMethod(methods, _crcSize);
+ }
+ else
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveGetRootProps,
+ getRootProps, callback)
+ if (getRootProps)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(getRootProps->GetRootProp(kpidArcFileName, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ const UString method = GetMethod_from_FileName(prop.bstrVal);
+ if (!method.IsEmpty())
+ methods.Add(method);
+ }
+ }
+ }
+
+ RINOK(hb.SetMethods(EXTERNAL_CODECS_LOC_VARS methods))
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(callback, true);
+
+ const UInt32 kBufSize = 1 << 15;
+ CHashMidBuf buf;
+ if (!buf.Alloc(kBufSize))
+ return E_OUTOFMEMORY;
+
+ CDynLimBuf hashFileString((size_t)1 << 31);
+
+ CHashOptionsLocal options = _options;
+
+ if (_isArc)
+ {
+ if (!options.HashMode_Zero.Def && _is_ZeroMode)
+ options.HashMode_Zero.Val = true;
+ if (!options.HashMode_Tag.Def && _are_there_Tags)
+ options.HashMode_Tag.Val = true;
+ if (!options.HashMode_Dirs.Def && _are_there_Dirs)
+ options.HashMode_Dirs.Val = true;
+ }
+ if (options.HashMode_OnlyHash.Val && updateItems.Size() != 1)
+ options.HashMode_OnlyHash.Val = false;
+
+ lps->OutSize = 0;
+ complexity = 0;
+
+ for (i = 0; i < updateItems.Size(); i++)
+ {
+ lps->InSize = complexity;
+ RINOK(lps->SetCur())
+
+ const CUpdateItem &ui = updateItems[i];
+
+ /*
+ CHashPair item;
+ if (!ui.NewProps)
+ item = HashPairs[(unsigned)ui.IndexInArc];
+ */
+
+ if (ui.NewData)
+ {
+ UInt64 currentComplexity = ui.Size;
+ UInt64 fileSize = 0;
+
+ CMyComPtr<ISequentialInStream> fileInStream;
+ bool needWrite = true;
+ {
+ HRESULT res = callback->GetStream(ui.IndexInClient, &fileInStream);
+
+ if (res == S_FALSE)
+ needWrite = false;
+ else
+ {
+ RINOK(res)
+
+ if (fileInStream)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamGetSize,
+ streamGetSize, fileInStream)
+ if (streamGetSize)
+ {
+ UInt64 size;
+ if (streamGetSize->GetSize(&size) == S_OK)
+ currentComplexity = size;
+ }
+ /*
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IStreamGetProps,
+ getProps, fileInStream)
+ if (getProps)
+ {
+ FILETIME mTime;
+ UInt64 size2;
+ if (getProps->GetProps(&size2, NULL, NULL, &mTime, NULL) == S_OK)
+ {
+ currentComplexity = size2;
+ // item.MTime = NWindows::NTime::FileTimeToUnixTime64(mTime);;
+ }
+ }
+ */
+ }
+ else
+ {
+ currentComplexity = 0;
+ }
+ }
+ }
+
+ hb.InitForNewFile();
+ const bool isDir = ui.IsDir;
+
+ if (needWrite && fileInStream && !isDir)
+ {
+ for (UInt32 step = 0;; step++)
+ {
+ if ((step & 0xFF) == 0)
+ {
+ RINOK(progress->SetRatioInfo(&fileSize, NULL))
+ // RINOK(callback->SetCompleted(&completeValue));
+ }
+ UInt32 size;
+ RINOK(fileInStream->Read(buf, kBufSize, &size))
+ if (size == 0)
+ break;
+ hb.Update(buf, size);
+ fileSize += size;
+ }
+ currentComplexity = fileSize;
+ }
+
+ fileInStream.Release();
+ const bool isAltStream = false;
+ hb.Final(isDir, isAltStream, ui.Path);
+
+ if (options.HashMode_Dirs.Val || !isDir)
+ {
+ if (!hb.Hashers.IsEmpty())
+ lps->OutSize += hb.Hashers[0].DigestSize;
+ WriteLine(hashFileString,
+ options,
+ ui.Path,
+ isDir,
+ hb);
+ if (hashFileString.IsError())
+ return E_OUTOFMEMORY;
+ }
+
+ complexity += currentComplexity;
+
+ /*
+ if (reportArcProp)
+ {
+ PROPVARIANT prop;
+ prop.vt = VT_EMPTY;
+ prop.wReserved1 = 0;
+
+ NCOM::PropVarEm_Set_UInt64(&prop, fileSize);
+ RINOK(reportArcProp->ReportProp(NArchive::NEventIndexType::kOutArcIndex, ui.IndexInClient, kpidSize, &prop));
+
+ for (unsigned k = 0; k < hb.Hashers.Size(); k++)
+ {
+ const CHasherState &hs = hb.Hashers[k];
+
+ if (hs.DigestSize == 4 && hs.Name.IsEqualTo_Ascii_NoCase("crc32"))
+ {
+ NCOM::PropVarEm_Set_UInt32(&prop, GetUi32(hs.Digests[k_HashCalc_Index_Current]));
+ RINOK(reportArcProp->ReportProp(NArchive::NEventIndexType::kOutArcIndex, ui.IndexInClient, kpidCRC, &prop));
+ }
+ else
+ {
+ RINOK(reportArcProp->ReportRawProp(NArchive::NEventIndexType::kOutArcIndex, ui.IndexInClient,
+ kpidChecksum, hs.Digests[k_HashCalc_Index_Current],
+ hs.DigestSize, NPropDataType::kRaw));
+ }
+ RINOK(reportArcProp->ReportFinished(NArchive::NEventIndexType::kOutArcIndex, ui.IndexInClient, NArchive::NUpdate::NOperationResult::kOK));
+ }
+ }
+ */
+ RINOK(callback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK))
+ }
+ else
+ {
+ // old data
+ const CHashPair &existItem = HashPairs[(unsigned)ui.IndexInArc];
+ if (ui.NewProps)
+ {
+ WriteLine(hashFileString,
+ options,
+ ui.Path,
+ ui.IsDir,
+ existItem.Method, existItem.HashString
+ );
+ }
+ else
+ {
+ hashFileString += existItem.FullLine;
+ Add_LF(hashFileString, options);
+ }
+ }
+ if (hashFileString.IsError())
+ return E_OUTOFMEMORY;
+ }
+
+ RINOK(WriteStream(outStream, hashFileString, hashFileString.Len()))
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+
+HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
+{
+ UString name = nameSpec;
+ name.MakeLower_Ascii();
+ if (name.IsEmpty())
+ return E_INVALIDARG;
+
+ if (name.IsEqualTo("m")) // "hm" hash method
+ {
+ // COneMethodInfo omi;
+ // RINOK(omi.ParseMethodFromPROPVARIANT(L"", value));
+ // _methods.Add(omi.MethodName); // change it. use omi.PropsString
+ if (value.vt != VT_BSTR)
+ return E_INVALIDARG;
+ UString s (value.bstrVal);
+ _methods.Add(s);
+ return S_OK;
+ }
+
+ if (name.IsEqualTo("flags"))
+ {
+ if (value.vt != VT_BSTR)
+ return E_INVALIDARG;
+ if (!_options.ParseString(value.bstrVal))
+ return E_INVALIDARG;
+ return S_OK;
+ }
+
+ if (name.IsPrefixedBy_Ascii_NoCase("crc"))
+ {
+ name.Delete(0, 3);
+ _crcSize = 4;
+ _crcSize_WasSet = true;
+ return ParsePropToUInt32(name, value, _crcSize);
+ }
+
+ // common properties
+ if (name.IsPrefixedBy_Ascii_NoCase("mt")
+ || name.IsPrefixedBy_Ascii_NoCase("memuse"))
+ return S_OK;
+
+ return E_INVALIDARG;
+}
+
+
+Z7_COM7F_IMF(CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+{
+ COM_TRY_BEGIN
+
+ InitProps();
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ RINOK(SetProperty(names[i], values[i]))
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+CHandler::CHandler()
+{
+ ClearVars();
+ InitProps();
+}
+
+}
+
+
+
+static IInArchive *CreateHashHandler_In() { return new NHash::CHandler; }
+static IOutArchive *CreateHashHandler_Out() { return new NHash::CHandler; }
+
+void Codecs_AddHashArcHandler(CCodecs *codecs)
+{
+ {
+ CArcInfoEx item;
+
+ item.Name = "Hash";
+ item.CreateInArchive = CreateHashHandler_In;
+ item.CreateOutArchive = CreateHashHandler_Out;
+ item.IsArcFunc = NULL;
+ item.Flags =
+ NArcInfoFlags::kKeepName
+ | NArcInfoFlags::kStartOpen
+ | NArcInfoFlags::kByExtOnlyOpen
+ // | NArcInfoFlags::kPureStartOpen
+ | NArcInfoFlags::kHashHandler
+ ;
+
+ // ubuntu uses "SHA256SUMS" file
+ item.AddExts(UString (
+ "sha256 sha512 sha224 sha384 sha1 sha md5"
+ // "b2sum"
+ " crc32 crc64"
+ " asc"
+ " cksum"
+ ),
+ UString());
+
+ item.UpdateEnabled = (item.CreateOutArchive != NULL);
+ item.SignatureOffset = 0;
+ // item.Version = MY_VER_MIX;
+ item.NewInterface = true;
+
+ item.Signatures.AddNew().CopyFrom(NULL, 0);
+
+ codecs->Formats.Add(item);
+ }
+}
diff --git a/CPP/7zip/UI/Common/HashCalc.h b/CPP/7zip/UI/Common/HashCalc.h
index 524bd3b..0b527c1 100644
--- a/CPP/7zip/UI/Common/HashCalc.h
+++ b/CPP/7zip/UI/Common/HashCalc.h
@@ -1,110 +1,328 @@
-// HashCalc.h
-
-#ifndef __HASH_CALC_H
-#define __HASH_CALC_H
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../Common/CreateCoder.h"
-#include "../../Common/MethodProps.h"
-
-#include "DirItem.h"
-
-const unsigned k_HashCalc_DigestSize_Max = 64;
-
-const unsigned k_HashCalc_NumGroups = 4;
-
-enum
-{
- k_HashCalc_Index_Current,
- k_HashCalc_Index_DataSum,
- k_HashCalc_Index_NamesSum,
- k_HashCalc_Index_StreamsSum
-};
-
-struct CHasherState
-{
- CMyComPtr<IHasher> Hasher;
- AString Name;
- UInt32 DigestSize;
- Byte Digests[k_HashCalc_NumGroups][k_HashCalc_DigestSize_Max];
-};
-
-struct IHashCalc
-{
- virtual void InitForNewFile() = 0;
- virtual void Update(const void *data, UInt32 size) = 0;
- virtual void SetSize(UInt64 size) = 0;
- virtual void Final(bool isDir, bool isAltStream, const UString &path) = 0;
-};
-
-struct CHashBundle: public IHashCalc
-{
- CObjectVector<CHasherState> Hashers;
-
- UInt64 NumDirs;
- UInt64 NumFiles;
- UInt64 NumAltStreams;
- UInt64 FilesSize;
- UInt64 AltStreamsSize;
- UInt64 NumErrors;
-
- UInt64 CurSize;
-
- UString MainName;
- UString FirstFileName;
-
- HRESULT SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVector &methods);
-
- // void Init() {}
- CHashBundle()
- {
- NumDirs = NumFiles = NumAltStreams = FilesSize = AltStreamsSize = NumErrors = 0;
- }
-
- void InitForNewFile();
- void Update(const void *data, UInt32 size);
- void SetSize(UInt64 size);
- void Final(bool isDir, bool isAltStream, const UString &path);
-};
-
-#define INTERFACE_IHashCallbackUI(x) \
- INTERFACE_IDirItemsCallback(x) \
- virtual HRESULT StartScanning() x; \
- virtual HRESULT FinishScanning(const CDirItemsStat &st) x; \
- virtual HRESULT SetNumFiles(UInt64 numFiles) x; \
- virtual HRESULT SetTotal(UInt64 size) x; \
- virtual HRESULT SetCompleted(const UInt64 *completeValue) x; \
- virtual HRESULT CheckBreak() x; \
- virtual HRESULT BeforeFirstFile(const CHashBundle &hb) x; \
- virtual HRESULT GetStream(const wchar_t *name, bool isFolder) x; \
- virtual HRESULT OpenFileError(const FString &path, DWORD systemError) x; \
- virtual HRESULT SetOperationResult(UInt64 fileSize, const CHashBundle &hb, bool showHash) x; \
- virtual HRESULT AfterLastFile(CHashBundle &hb) x; \
-
-struct IHashCallbackUI: public IDirItemsCallback
-{
- INTERFACE_IHashCallbackUI(=0)
-};
-
-struct CHashOptions
-{
- UStringVector Methods;
- bool OpenShareForWrite;
- bool StdInMode;
- bool AltStreamsMode;
- NWildcard::ECensorPathMode PathMode;
-
- CHashOptions(): StdInMode(false), OpenShareForWrite(false), AltStreamsMode(false), PathMode(NWildcard::k_RelatPath) {};
-};
-
-HRESULT HashCalc(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const NWildcard::CCensor &censor,
- const CHashOptions &options,
- AString &errorInfo,
- IHashCallbackUI *callback);
-
-void AddHashHexToString(char *dest, const Byte *data, UInt32 size);
-
-#endif
+// HashCalc.h
+
+#ifndef ZIP7_INC_HASH_CALC_H
+#define ZIP7_INC_HASH_CALC_H
+
+#include "../../../Common/UTFConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../Common/CreateCoder.h"
+#include "../../Common/MethodProps.h"
+
+#include "DirItem.h"
+#include "IFileExtractCallback.h"
+
+const unsigned k_HashCalc_DigestSize_Max = 64;
+const unsigned k_HashCalc_ExtraSize = 8;
+const unsigned k_HashCalc_NumGroups = 4;
+
+/*
+ if (size <= 8) : upper case : reversed byte order : it shows 32-bit/64-bit number, if data contains little-endian number
+ if (size > 8) : lower case : original byte order (as big-endian byte sequence)
+*/
+void HashHexToString(char *dest, const Byte *data, UInt32 size);
+
+enum
+{
+ k_HashCalc_Index_Current,
+ k_HashCalc_Index_DataSum,
+ k_HashCalc_Index_NamesSum,
+ k_HashCalc_Index_StreamsSum
+};
+
+struct CHasherState
+{
+ CMyComPtr<IHasher> Hasher;
+ AString Name;
+ UInt32 DigestSize;
+ UInt64 NumSums[k_HashCalc_NumGroups];
+ Byte Digests[k_HashCalc_NumGroups][k_HashCalc_DigestSize_Max + k_HashCalc_ExtraSize];
+
+ void InitDigestGroup(unsigned groupIndex)
+ {
+ NumSums[groupIndex] = 0;
+ memset(Digests[groupIndex], 0, sizeof(Digests[groupIndex]));
+ }
+
+ const Byte *GetExtraData_for_Group(unsigned groupIndex) const
+ {
+ return Digests[groupIndex] + k_HashCalc_DigestSize_Max;
+ }
+
+ unsigned GetNumExtraBytes_for_Group(unsigned groupIndex) const
+ {
+ const Byte *p = GetExtraData_for_Group(groupIndex);
+ // we use little-endian to read extra bytes
+ for (unsigned i = k_HashCalc_ExtraSize; i != 0; i--)
+ if (p[i - 1] != 0)
+ return i;
+ return 0;
+ }
+
+ void AddDigest(unsigned groupIndex, const Byte *data);
+
+ void WriteToString(unsigned digestIndex, char *s) const;
+};
+
+
+Z7_PURE_INTERFACES_BEGIN
+
+
+DECLARE_INTERFACE(IHashCalc)
+{
+ virtual void InitForNewFile() = 0;
+ virtual void Update(const void *data, UInt32 size) = 0;
+ virtual void SetSize(UInt64 size) = 0;
+ virtual void Final(bool isDir, bool isAltStream, const UString &path) = 0;
+};
+
+Z7_PURE_INTERFACES_END
+
+struct CHashBundle Z7_final: public IHashCalc
+{
+ CObjectVector<CHasherState> Hashers;
+
+ UInt64 NumDirs;
+ UInt64 NumFiles;
+ UInt64 NumAltStreams;
+ UInt64 FilesSize;
+ UInt64 AltStreamsSize;
+ UInt64 NumErrors;
+
+ UInt64 CurSize;
+
+ UString MainName;
+ UString FirstFileName;
+
+ HRESULT SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVector &methods);
+
+ // void Init() {}
+ CHashBundle()
+ {
+ NumDirs = NumFiles = NumAltStreams = FilesSize = AltStreamsSize = NumErrors = 0;
+ }
+
+ void InitForNewFile() Z7_override;
+ void Update(const void *data, UInt32 size) Z7_override;
+ void SetSize(UInt64 size) Z7_override;
+ void Final(bool isDir, bool isAltStream, const UString &path) Z7_override;
+};
+
+Z7_PURE_INTERFACES_BEGIN
+
+// INTERFACE_IDirItemsCallback(x)
+
+#define Z7_IFACEN_IHashCallbackUI(x) \
+ virtual HRESULT StartScanning() x \
+ virtual HRESULT FinishScanning(const CDirItemsStat &st) x \
+ virtual HRESULT SetNumFiles(UInt64 numFiles) x \
+ virtual HRESULT SetTotal(UInt64 size) x \
+ virtual HRESULT SetCompleted(const UInt64 *completeValue) x \
+ virtual HRESULT CheckBreak() x \
+ virtual HRESULT BeforeFirstFile(const CHashBundle &hb) x \
+ virtual HRESULT GetStream(const wchar_t *name, bool isFolder) x \
+ virtual HRESULT OpenFileError(const FString &path, DWORD systemError) x \
+ virtual HRESULT SetOperationResult(UInt64 fileSize, const CHashBundle &hb, bool showHash) x \
+ virtual HRESULT AfterLastFile(CHashBundle &hb) x \
+
+Z7_IFACE_DECL_PURE_(IHashCallbackUI, IDirItemsCallback)
+
+Z7_PURE_INTERFACES_END
+
+
+struct CHashOptionsLocal
+{
+ CBoolPair HashMode_Zero;
+ CBoolPair HashMode_Tag;
+ CBoolPair HashMode_Dirs;
+ CBoolPair HashMode_OnlyHash;
+
+ void Init_HashOptionsLocal()
+ {
+ HashMode_Zero.Init();
+ HashMode_Tag.Init();
+ HashMode_Dirs.Init();
+ HashMode_OnlyHash.Init();
+ // HashMode_Dirs = true; // for debug
+ }
+
+ CHashOptionsLocal()
+ {
+ Init_HashOptionsLocal();
+ }
+
+ bool ParseFlagCharOption(wchar_t c, bool val)
+ {
+ c = MyCharLower_Ascii(c);
+ if (c == 'z') HashMode_Zero.SetVal_as_Defined(val);
+ else if (c == 't') HashMode_Tag.SetVal_as_Defined(val);
+ else if (c == 'd') HashMode_Dirs.SetVal_as_Defined(val);
+ else if (c == 'h') HashMode_OnlyHash.SetVal_as_Defined(val);
+ else return false;
+ return true;
+ }
+
+ bool ParseString(const UString &s)
+ {
+ for (unsigned i = 0; i < s.Len();)
+ {
+ const wchar_t c = s[i++];
+ bool val = true;
+ if (i < s.Len())
+ {
+ const wchar_t next = s[i];
+ if (next == '-')
+ {
+ val = false;
+ i++;
+ }
+ }
+ if (!ParseFlagCharOption(c, val))
+ return false;
+ }
+ return true;
+ }
+};
+
+
+struct CHashOptions
+ // : public CHashOptionsLocal
+{
+ UStringVector Methods;
+ // UString HashFilePath;
+
+ bool PreserveATime;
+ bool OpenShareForWrite;
+ bool StdInMode;
+ bool AltStreamsMode;
+ CBoolPair SymLinks;
+
+ NWildcard::ECensorPathMode PathMode;
+
+ CHashOptions():
+ PreserveATime(false),
+ OpenShareForWrite(false),
+ StdInMode(false),
+ AltStreamsMode(false),
+ PathMode(NWildcard::k_RelatPath) {}
+};
+
+
+HRESULT HashCalc(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const NWildcard::CCensor &censor,
+ const CHashOptions &options,
+ AString &errorInfo,
+ IHashCallbackUI *callback);
+
+
+
+#ifndef Z7_SFX
+
+namespace NHash {
+
+struct CHashPair
+{
+ CByteBuffer Hash;
+ char Mode;
+ bool IsBSD;
+ bool Size_from_Arc_Defined;
+ bool Size_from_Disk_Defined;
+ AString Method;
+ AString Name;
+
+ AString FullLine;
+ AString HashString;
+ // unsigned HashLengthInBits;
+
+ // AString MethodName;
+ UInt64 Size_from_Arc;
+ UInt64 Size_from_Disk;
+
+ bool IsDir() const;
+
+ void Get_UString_Path(UString &path) const
+ {
+ path.Empty();
+ if (!ConvertUTF8ToUnicode(Name, path))
+ return;
+ }
+
+ bool ParseCksum(const char *s);
+ bool Parse(const char *s);
+
+ bool IsSupportedMode() const
+ {
+ return Mode != 'U' && Mode != '^';
+ }
+
+ CHashPair():
+ Mode(0)
+ , IsBSD(false)
+ , Size_from_Arc_Defined(false)
+ , Size_from_Disk_Defined(false)
+ // , HashLengthInBits(0)
+ , Size_from_Arc(0)
+ , Size_from_Disk(0)
+ {}
+};
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_3(
+ IArchiveGetRawProps,
+ /* public IGetArchiveHashHandler, */
+ IOutArchive,
+ ISetProperties
+)
+ bool _isArc;
+ UInt64 _phySize;
+ CObjectVector<CHashPair> HashPairs;
+ UString _nameExtenstion;
+ // UString _method_fromName;
+ AString _pgpMethod;
+ bool _is_CksumMode;
+ bool _is_PgpMethod;
+ bool _is_ZeroMode;
+ bool _are_there_Tags;
+ bool _are_there_Dirs;
+ bool _hashSize_Defined;
+ unsigned _hashSize;
+
+ bool _crcSize_WasSet;
+ UInt32 _crcSize;
+ UStringVector _methods;
+
+ void ClearVars();
+
+ void InitProps()
+ {
+ _crcSize_WasSet = false;
+ _crcSize = 4;
+ _methods.Clear();
+ _options.Init_HashOptionsLocal();
+ }
+
+ CHashOptionsLocal _options;
+
+ bool CanUpdate() const
+ {
+ if (!_isArc || _is_PgpMethod || _is_CksumMode)
+ return false;
+ return true;
+
+ }
+
+ HRESULT SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value);
+
+public:
+ CHandler();
+};
+
+}
+
+void Codecs_AddHashArcHandler(CCodecs *codecs);
+
+#endif
+
+
+#endif
diff --git a/CPP/7zip/UI/Common/IFileExtractCallback.h b/CPP/7zip/UI/Common/IFileExtractCallback.h
index 3f554ef..dd5c0d7 100644
--- a/CPP/7zip/UI/Common/IFileExtractCallback.h
+++ b/CPP/7zip/UI/Common/IFileExtractCallback.h
@@ -1,114 +1,112 @@
-// IFileExtractCallback.h
-
-#ifndef __I_FILE_EXTRACT_CALLBACK_H
-#define __I_FILE_EXTRACT_CALLBACK_H
-
-#include "../../../Common/MyString.h"
-
-#include "../../IDecl.h"
-
-#include "LoadCodecs.h"
-#include "OpenArchive.h"
-
-namespace NOverwriteAnswer
-{
- enum EEnum
- {
- kYes,
- kYesToAll,
- kNo,
- kNoToAll,
- kAutoRename,
- kCancel
- };
-}
-
-
-/* ---------- IFolderArchiveExtractCallback ----------
-is implemented by
- Console/ExtractCallbackConsole.h CExtractCallbackConsole
- FileManager/ExtractCallback.h CExtractCallbackImp
- FAR/ExtractEngine.cpp CExtractCallBackImp: (QueryInterface is not supported)
-
-IID_IFolderArchiveExtractCallback is requested by:
- - Agent/ArchiveFolder.cpp
- CAgentFolder::CopyTo(..., IFolderOperationsExtractCallback *callback)
- is sent to IArchiveFolder::Extract()
-
- - FileManager/PanelCopy.cpp
- CPanel::CopyTo(), if (options->testMode)
- is sent to IArchiveFolder::Extract()
-
- IFolderArchiveExtractCallback is used by Common/ArchiveExtractCallback.cpp
-*/
-
-#define INTERFACE_IFolderArchiveExtractCallback(x) \
- STDMETHOD(AskOverwrite)( \
- const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize, \
- const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize, \
- Int32 *answer) x; \
- STDMETHOD(PrepareOperation)(const wchar_t *name, Int32 isFolder, Int32 askExtractMode, const UInt64 *position) x; \
- STDMETHOD(MessageError)(const wchar_t *message) x; \
- STDMETHOD(SetOperationResult)(Int32 opRes, Int32 encrypted) x; \
-
-DECL_INTERFACE_SUB(IFolderArchiveExtractCallback, IProgress, 0x01, 0x07)
-{
- INTERFACE_IFolderArchiveExtractCallback(PURE)
-};
-
-#define INTERFACE_IFolderArchiveExtractCallback2(x) \
- STDMETHOD(ReportExtractResult)(Int32 opRes, Int32 encrypted, const wchar_t *name) x; \
-
-DECL_INTERFACE_SUB(IFolderArchiveExtractCallback2, IUnknown, 0x01, 0x08)
-{
- INTERFACE_IFolderArchiveExtractCallback2(PURE)
-};
-
-/* ---------- IExtractCallbackUI ----------
-is implemented by
- Console/ExtractCallbackConsole.h CExtractCallbackConsole
- FileManager/ExtractCallback.h CExtractCallbackImp
-*/
-
-#ifdef _NO_CRYPTO
- #define INTERFACE_IExtractCallbackUI_Crypto(x)
-#else
- #define INTERFACE_IExtractCallbackUI_Crypto(x) \
- virtual HRESULT SetPassword(const UString &password) x;
-#endif
-
-#define INTERFACE_IExtractCallbackUI(x) \
- virtual HRESULT BeforeOpen(const wchar_t *name, bool testMode) x; \
- virtual HRESULT OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result) x; \
- virtual HRESULT ThereAreNoFiles() x; \
- virtual HRESULT ExtractResult(HRESULT result) x; \
- INTERFACE_IExtractCallbackUI_Crypto(x)
-
-struct IExtractCallbackUI: IFolderArchiveExtractCallback
-{
- INTERFACE_IExtractCallbackUI(PURE)
-};
-
-
-
-#define INTERFACE_IGetProp(x) \
- STDMETHOD(GetProp)(PROPID propID, PROPVARIANT *value) x; \
-
-DECL_INTERFACE_SUB(IGetProp, IUnknown, 0x01, 0x20)
-{
- INTERFACE_IGetProp(PURE)
-};
-
-#define INTERFACE_IFolderExtractToStreamCallback(x) \
- STDMETHOD(UseExtractToStream)(Int32 *res) x; \
- STDMETHOD(GetStream7)(const wchar_t *name, Int32 isDir, ISequentialOutStream **outStream, Int32 askExtractMode, IGetProp *getProp) x; \
- STDMETHOD(PrepareOperation7)(Int32 askExtractMode) x; \
- STDMETHOD(SetOperationResult7)(Int32 resultEOperationResult, Int32 encrypted) x; \
-
-DECL_INTERFACE_SUB(IFolderExtractToStreamCallback, IUnknown, 0x01, 0x30)
-{
- INTERFACE_IFolderExtractToStreamCallback(PURE)
-};
-
-
-#endif
+// IFileExtractCallback.h
+
+#ifndef ZIP7_INC_I_FILE_EXTRACT_CALLBACK_H
+#define ZIP7_INC_I_FILE_EXTRACT_CALLBACK_H
+
+#include "../../../Common/MyString.h"
+
+#include "../../IDecl.h"
+
+#include "LoadCodecs.h"
+#include "OpenArchive.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACE_CONSTR_FOLDERARC_SUB(i, base, n) \
+ Z7_DECL_IFACE_7ZIP_SUB(i, base, 1, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACE_CONSTR_FOLDERARC(i, n) \
+ Z7_IFACE_CONSTR_FOLDERARC_SUB(i, IUnknown, n)
+
+namespace NOverwriteAnswer
+{
+ enum EEnum
+ {
+ kYes,
+ kYesToAll,
+ kNo,
+ kNoToAll,
+ kAutoRename,
+ kCancel
+ };
+}
+
+
+/* ---------- IFolderArchiveExtractCallback ----------
+is implemented by
+ Console/ExtractCallbackConsole.h CExtractCallbackConsole
+ FileManager/ExtractCallback.h CExtractCallbackImp
+ FAR/ExtractEngine.cpp CExtractCallBackImp: (QueryInterface is not supported)
+
+IID_IFolderArchiveExtractCallback is requested by:
+ - Agent/ArchiveFolder.cpp
+ CAgentFolder::CopyTo(..., IFolderOperationsExtractCallback *callback)
+ is sent to IArchiveFolder::Extract()
+
+ - FileManager/PanelCopy.cpp
+ CPanel::CopyTo(), if (options->testMode)
+ is sent to IArchiveFolder::Extract()
+
+ IFolderArchiveExtractCallback is used by Common/ArchiveExtractCallback.cpp
+*/
+
+#define Z7_IFACEM_IFolderArchiveExtractCallback(x) \
+ x(AskOverwrite( \
+ const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize, \
+ const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize, \
+ Int32 *answer)) \
+ x(PrepareOperation(const wchar_t *name, Int32 isFolder, Int32 askExtractMode, const UInt64 *position)) \
+ x(MessageError(const wchar_t *message)) \
+ x(SetOperationResult(Int32 opRes, Int32 encrypted)) \
+
+Z7_IFACE_CONSTR_FOLDERARC_SUB(IFolderArchiveExtractCallback, IProgress, 0x07)
+
+#define Z7_IFACEM_IFolderArchiveExtractCallback2(x) \
+ x(ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderArchiveExtractCallback2, 0x08)
+
+/* ---------- IExtractCallbackUI ----------
+is implemented by
+ Console/ExtractCallbackConsole.h CExtractCallbackConsole
+ FileManager/ExtractCallback.h CExtractCallbackImp
+*/
+
+#ifdef Z7_NO_CRYPTO
+ #define Z7_IFACEM_IExtractCallbackUI_Crypto(px)
+#else
+ #define Z7_IFACEM_IExtractCallbackUI_Crypto(px) \
+ virtual HRESULT SetPassword(const UString &password) px
+#endif
+
+#define Z7_IFACEN_IExtractCallbackUI(px) \
+ virtual HRESULT BeforeOpen(const wchar_t *name, bool testMode) px \
+ virtual HRESULT OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result) px \
+ virtual HRESULT ThereAreNoFiles() px \
+ virtual HRESULT ExtractResult(HRESULT result) px \
+ Z7_IFACEM_IExtractCallbackUI_Crypto(px)
+
+// IExtractCallbackUI - is non-COM interface
+// IFolderArchiveExtractCallback - is COM interface
+// Z7_IFACE_DECL_PURE_(IExtractCallbackUI, IFolderArchiveExtractCallback)
+Z7_IFACE_DECL_PURE(IExtractCallbackUI)
+
+
+
+#define Z7_IFACEM_IGetProp(x) \
+ x(GetProp(PROPID propID, PROPVARIANT *value)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IGetProp, 0x20)
+
+#define Z7_IFACEM_IFolderExtractToStreamCallback(x) \
+ x(UseExtractToStream(Int32 *res)) \
+ x(GetStream7(const wchar_t *name, Int32 isDir, ISequentialOutStream **outStream, Int32 askExtractMode, IGetProp *getProp)) \
+ x(PrepareOperation7(Int32 askExtractMode)) \
+ x(SetOperationResult8(Int32 resultEOperationResult, Int32 encrypted, UInt64 size)) \
+
+Z7_IFACE_CONSTR_FOLDERARC(IFolderExtractToStreamCallback, 0x31)
+
+Z7_PURE_INTERFACES_END
+
+#endif
diff --git a/CPP/7zip/UI/Common/LoadCodecs.cpp b/CPP/7zip/UI/Common/LoadCodecs.cpp
index d31e05f..5a65bdc 100644
--- a/CPP/7zip/UI/Common/LoadCodecs.cpp
+++ b/CPP/7zip/UI/Common/LoadCodecs.cpp
@@ -1,1074 +1,1333 @@
-// LoadCodecs.cpp
-
-/*
-EXTERNAL_CODECS
----------------
- CCodecs::Load() tries to detect the directory with plugins.
- It stops the checking, if it can find any of the following items:
- - 7z.dll file
- - "Formats" subdir
- - "Codecs" subdir
- The order of check:
- 1) directory of client executable
- 2) WIN32: directory for REGISTRY item [HKEY_*\Software\7-Zip\Path**]
- The order for HKEY_* : Path** :
- - HKEY_CURRENT_USER : PathXX
- - HKEY_LOCAL_MACHINE : PathXX
- - HKEY_CURRENT_USER : Path
- - HKEY_LOCAL_MACHINE : Path
- PathXX is Path32 in 32-bit code
- PathXX is Path64 in 64-bit code
-
-
-EXPORT_CODECS
--------------
- if (EXTERNAL_CODECS) is defined, then the code exports internal
- codecs of client from CCodecs object to external plugins.
- 7-Zip doesn't use that feature. 7-Zip uses the scheme:
- - client application without internal plugins.
- - 7z.dll module contains all (or almost all) plugins.
- 7z.dll can use codecs from another plugins, if required.
-*/
-
-
-#include "StdAfx.h"
-
-#include "../../../../C/7zVersion.h"
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/StringToInt.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/PropVariant.h"
-
-#include "LoadCodecs.h"
-
-using namespace NWindows;
-
-#ifdef NEW_FOLDER_INTERFACE
-#include "../../../Common/StringToInt.h"
-#endif
-
-#include "../../ICoder.h"
-#include "../../Common/RegisterArc.h"
-
-#ifdef EXTERNAL_CODECS
-
-// #define EXPORT_CODECS
-
-#endif
-
-#ifdef NEW_FOLDER_INTERFACE
-extern HINSTANCE g_hInstance;
-#include "../../../Windows/ResourceString.h"
-static const UINT kIconTypesResId = 100;
-#endif
-
-#ifdef EXTERNAL_CODECS
-
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/DLL.h"
-
-#ifdef _WIN32
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/Registry.h"
-#endif
-
-using namespace NFile;
-
-
-#define kCodecsFolderName FTEXT("Codecs")
-#define kFormatsFolderName FTEXT("Formats")
-
-
-static CFSTR const kMainDll =
- // #ifdef _WIN32
- FTEXT("7z.dll");
- // #else
- // FTEXT("7z.so");
- // #endif
-
-
-#ifdef _WIN32
-
-static LPCTSTR const kRegistryPath = TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-zip");
-static LPCWSTR const kProgramPathValue = L"Path";
-static LPCWSTR const kProgramPath2Value = L"Path"
- #ifdef _WIN64
- L"64";
- #else
- L"32";
- #endif
-
-static bool ReadPathFromRegistry(HKEY baseKey, LPCWSTR value, FString &path)
-{
- NRegistry::CKey key;
- if (key.Open(baseKey, kRegistryPath, KEY_READ) == ERROR_SUCCESS)
- {
- UString pathU;
- if (key.QueryValue(value, pathU) == ERROR_SUCCESS)
- {
- path = us2fs(pathU);
- NName::NormalizeDirPathPrefix(path);
- return NFind::DoesFileExist(path + kMainDll);
- }
- }
- return false;
-}
-
-#endif // _WIN32
-
-#endif // EXTERNAL_CODECS
-
-
-static const unsigned kNumArcsMax = 64;
-static unsigned g_NumArcs = 0;
-static const CArcInfo *g_Arcs[kNumArcsMax];
-
-void RegisterArc(const CArcInfo *arcInfo) throw()
-{
- if (g_NumArcs < kNumArcsMax)
- {
- g_Arcs[g_NumArcs] = arcInfo;
- g_NumArcs++;
- }
-}
-
-static void SplitString(const UString &srcString, UStringVector &destStrings)
-{
- destStrings.Clear();
- UString s;
- unsigned len = srcString.Len();
- if (len == 0)
- return;
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = srcString[i];
- if (c == L' ')
- {
- if (!s.IsEmpty())
- {
- destStrings.Add(s);
- s.Empty();
- }
- }
- else
- s += c;
- }
- if (!s.IsEmpty())
- destStrings.Add(s);
-}
-
-int CArcInfoEx::FindExtension(const UString &ext) const
-{
- FOR_VECTOR (i, Exts)
- if (ext.IsEqualTo_NoCase(Exts[i].Ext))
- return i;
- return -1;
-}
-
-void CArcInfoEx::AddExts(const UString &ext, const UString &addExt)
-{
- UStringVector exts, addExts;
- SplitString(ext, exts);
- SplitString(addExt, addExts);
- FOR_VECTOR (i, exts)
- {
- CArcExtInfo extInfo;
- extInfo.Ext = exts[i];
- if (i < addExts.Size())
- {
- extInfo.AddExt = addExts[i];
- if (extInfo.AddExt == L"*")
- extInfo.AddExt.Empty();
- }
- Exts.Add(extInfo);
- }
-}
-
-#ifndef _SFX
-
-static bool ParseSignatures(const Byte *data, unsigned size, CObjectVector<CByteBuffer> &signatures)
-{
- signatures.Clear();
- while (size > 0)
- {
- unsigned len = *data++;
- size--;
- if (len > size)
- return false;
- signatures.AddNew().CopyFrom(data, len);
- data += len;
- size -= len;
- }
- return true;
-}
-
-#endif // _SFX
-
-#ifdef EXTERNAL_CODECS
-
-static FString GetBaseFolderPrefixFromRegistry()
-{
- FString moduleFolderPrefix = NDLL::GetModuleDirPrefix();
- #ifdef _WIN32
- if (!NFind::DoesFileExist(moduleFolderPrefix + kMainDll) &&
- !NFind::DoesDirExist(moduleFolderPrefix + kCodecsFolderName) &&
- !NFind::DoesDirExist(moduleFolderPrefix + kFormatsFolderName))
- {
- FString path;
- if (ReadPathFromRegistry(HKEY_CURRENT_USER, kProgramPath2Value, path)) return path;
- if (ReadPathFromRegistry(HKEY_LOCAL_MACHINE, kProgramPath2Value, path)) return path;
- if (ReadPathFromRegistry(HKEY_CURRENT_USER, kProgramPathValue, path)) return path;
- if (ReadPathFromRegistry(HKEY_LOCAL_MACHINE, kProgramPathValue, path)) return path;
- }
- #endif
- return moduleFolderPrefix;
-}
-
-
-static HRESULT GetCoderClass(Func_GetMethodProperty getMethodProperty, UInt32 index,
- PROPID propId, CLSID &clsId, bool &isAssigned)
-{
- NCOM::CPropVariant prop;
- isAssigned = false;
- RINOK(getMethodProperty(index, propId, &prop));
- if (prop.vt == VT_BSTR)
- {
- if (::SysStringByteLen(prop.bstrVal) != sizeof(GUID))
- return E_FAIL;
- isAssigned = true;
- clsId = *(const GUID *)prop.bstrVal;
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-HRESULT CCodecs::LoadCodecs()
-{
- CCodecLib &lib = Libs.Back();
-
- lib.CreateDecoder = (Func_CreateDecoder)lib.Lib.GetProc("CreateDecoder");
- lib.CreateEncoder = (Func_CreateEncoder)lib.Lib.GetProc("CreateEncoder");
- lib.GetMethodProperty = (Func_GetMethodProperty)lib.Lib.GetProc("GetMethodProperty");
-
- if (lib.GetMethodProperty)
- {
- UInt32 numMethods = 1;
- Func_GetNumberOfMethods getNumberOfMethods = (Func_GetNumberOfMethods)lib.Lib.GetProc("GetNumberOfMethods");
- if (getNumberOfMethods)
- {
- RINOK(getNumberOfMethods(&numMethods));
- }
- for (UInt32 i = 0; i < numMethods; i++)
- {
- CDllCodecInfo info;
- info.LibIndex = Libs.Size() - 1;
- info.CodecIndex = i;
- RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kEncoder, info.Encoder, info.EncoderIsAssigned));
- RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kDecoder, info.Decoder, info.DecoderIsAssigned));
- Codecs.Add(info);
- }
- }
-
- Func_GetHashers getHashers = (Func_GetHashers)lib.Lib.GetProc("GetHashers");
- if (getHashers)
- {
- RINOK(getHashers(&lib.ComHashers));
- if (lib.ComHashers)
- {
- UInt32 numMethods = lib.ComHashers->GetNumHashers();
- for (UInt32 i = 0; i < numMethods; i++)
- {
- CDllHasherInfo info;
- info.LibIndex = Libs.Size() - 1;
- info.HasherIndex = i;
- Hashers.Add(info);
- }
- }
- }
-
- return S_OK;
-}
-
-static HRESULT GetProp(
- Func_GetHandlerProperty getProp,
- Func_GetHandlerProperty2 getProp2,
- UInt32 index, PROPID propID, NCOM::CPropVariant &prop)
-{
- if (getProp2)
- return getProp2(index, propID, &prop);;
- return getProp(propID, &prop);
-}
-
-static HRESULT GetProp_Bool(
- Func_GetHandlerProperty getProp,
- Func_GetHandlerProperty2 getProp2,
- UInt32 index, PROPID propID, bool &res)
-{
- res = false;
- NCOM::CPropVariant prop;
- RINOK(GetProp(getProp, getProp2, index, propID, prop));
- if (prop.vt == VT_BOOL)
- res = VARIANT_BOOLToBool(prop.boolVal);
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-static HRESULT GetProp_UInt32(
- Func_GetHandlerProperty getProp,
- Func_GetHandlerProperty2 getProp2,
- UInt32 index, PROPID propID, UInt32 &res, bool &defined)
-{
- res = 0;
- defined = false;
- NCOM::CPropVariant prop;
- RINOK(GetProp(getProp, getProp2, index, propID, prop));
- if (prop.vt == VT_UI4)
- {
- res = prop.ulVal;
- defined = true;
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-static HRESULT GetProp_String(
- Func_GetHandlerProperty getProp,
- Func_GetHandlerProperty2 getProp2,
- UInt32 index, PROPID propID, UString &res)
-{
- res.Empty();
- NCOM::CPropVariant prop;
- RINOK(GetProp(getProp, getProp2, index, propID, prop));
- if (prop.vt == VT_BSTR)
- res.SetFromBstr(prop.bstrVal);
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-static HRESULT GetProp_RawData(
- Func_GetHandlerProperty getProp,
- Func_GetHandlerProperty2 getProp2,
- UInt32 index, PROPID propID, CByteBuffer &bb)
-{
- bb.Free();
- NCOM::CPropVariant prop;
- RINOK(GetProp(getProp, getProp2, index, propID, prop));
- if (prop.vt == VT_BSTR)
- {
- UINT len = ::SysStringByteLen(prop.bstrVal);
- bb.CopyFrom((const Byte *)prop.bstrVal, len);
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-static const UInt32 kArcFlagsPars[] =
-{
- NArchive::NHandlerPropID::kKeepName, NArcInfoFlags::kKeepName,
- NArchive::NHandlerPropID::kAltStreams, NArcInfoFlags::kAltStreams,
- NArchive::NHandlerPropID::kNtSecure, NArcInfoFlags::kNtSecure
-};
-
-HRESULT CCodecs::LoadFormats()
-{
- const NDLL::CLibrary &lib = Libs.Back().Lib;
-
- Func_GetHandlerProperty getProp = NULL;
- Func_GetHandlerProperty2 getProp2 = (Func_GetHandlerProperty2)lib.GetProc("GetHandlerProperty2");
- Func_GetIsArc getIsArc = (Func_GetIsArc)lib.GetProc("GetIsArc");
-
- UInt32 numFormats = 1;
-
- if (getProp2)
- {
- Func_GetNumberOfFormats getNumberOfFormats = (Func_GetNumberOfFormats)lib.GetProc("GetNumberOfFormats");
- if (getNumberOfFormats)
- {
- RINOK(getNumberOfFormats(&numFormats));
- }
- }
- else
- {
- getProp = (Func_GetHandlerProperty)lib.GetProc("GetHandlerProperty");
- if (!getProp)
- return S_OK;
- }
-
- for (UInt32 i = 0; i < numFormats; i++)
- {
- CArcInfoEx item;
- item.LibIndex = Libs.Size() - 1;
- item.FormatIndex = i;
-
- RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kName, item.Name));
-
- {
- NCOM::CPropVariant prop;
- if (GetProp(getProp, getProp2, i, NArchive::NHandlerPropID::kClassID, prop) != S_OK)
- continue;
- if (prop.vt != VT_BSTR)
- continue;
- if (::SysStringByteLen(prop.bstrVal) != sizeof(GUID))
- return E_FAIL;
- item.ClassID = *(const GUID *)prop.bstrVal;
- prop.Clear();
- }
-
- UString ext, addExt;
- RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kExtension, ext));
- RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kAddExtension, addExt));
- item.AddExts(ext, addExt);
-
- GetProp_Bool(getProp, getProp2, i, NArchive::NHandlerPropID::kUpdate, item.UpdateEnabled);
- bool flags_Defined = false;
- RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kFlags, item.Flags, flags_Defined));
- item.NewInterface = flags_Defined;
- if (!flags_Defined) // && item.UpdateEnabled
- {
- // support for DLL version before 9.31:
- for (unsigned j = 0; j < ARRAY_SIZE(kArcFlagsPars); j += 2)
- {
- bool val = false;
- GetProp_Bool(getProp, getProp2, i, kArcFlagsPars[j], val);
- if (val)
- item.Flags |= kArcFlagsPars[j + 1];
- }
- }
-
- CByteBuffer sig;
- RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kSignature, sig));
- if (sig.Size() != 0)
- item.Signatures.Add(sig);
- else
- {
- RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kMultiSignature, sig));
- ParseSignatures(sig, (unsigned)sig.Size(), item.Signatures);
- }
-
- bool signatureOffset_Defined;
- RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kSignatureOffset, item.SignatureOffset, signatureOffset_Defined));
-
- // bool version_Defined;
- // RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kVersion, item.Version, version_Defined));
-
- if (getIsArc)
- getIsArc(i, &item.IsArcFunc);
-
- Formats.Add(item);
- }
- return S_OK;
-}
-
-#ifdef _7ZIP_LARGE_PAGES
-extern "C"
-{
- extern SIZE_T g_LargePageSize;
-}
-#endif
-
-HRESULT CCodecs::LoadDll(const FString &dllPath, bool needCheckDll, bool *loadedOK)
-{
- if (loadedOK)
- *loadedOK = false;
-
- if (needCheckDll)
- {
- NDLL::CLibrary lib;
- if (!lib.LoadEx(dllPath, LOAD_LIBRARY_AS_DATAFILE))
- return S_OK;
- }
-
- Libs.AddNew();
- CCodecLib &lib = Libs.Back();
- lib.Path = dllPath;
- bool used = false;
- HRESULT res = S_OK;
-
- if (lib.Lib.Load(dllPath))
- {
- if (loadedOK)
- *loadedOK = true;
- #ifdef NEW_FOLDER_INTERFACE
- lib.LoadIcons();
- #endif
-
- #ifdef _7ZIP_LARGE_PAGES
- if (g_LargePageSize != 0)
- {
- Func_SetLargePageMode setLargePageMode = (Func_SetLargePageMode)lib.Lib.GetProc("SetLargePageMode");
- if (setLargePageMode)
- setLargePageMode();
- }
- #endif
-
- if (CaseSensitiveChange)
- {
- Func_SetCaseSensitive setCaseSensitive = (Func_SetCaseSensitive)lib.Lib.GetProc("SetCaseSensitive");
- if (setCaseSensitive)
- setCaseSensitive(CaseSensitive ? 1 : 0);
- }
-
- lib.CreateObject = (Func_CreateObject)lib.Lib.GetProc("CreateObject");
- {
- unsigned startSize = Codecs.Size() + Hashers.Size();
- res = LoadCodecs();
- used = (startSize != Codecs.Size() + Hashers.Size());
- if (res == S_OK && lib.CreateObject)
- {
- startSize = Formats.Size();
- res = LoadFormats();
- if (startSize != Formats.Size())
- used = true;
- }
- }
- }
-
- if (!used)
- Libs.DeleteBack();
-
- return res;
-}
-
-HRESULT CCodecs::LoadDllsFromFolder(const FString &folderPrefix)
-{
- NFile::NFind::CEnumerator enumerator;
- enumerator.SetDirPrefix(folderPrefix);
- NFile::NFind::CFileInfo fi;
- while (enumerator.Next(fi))
- {
- if (fi.IsDir())
- continue;
- RINOK(LoadDll(folderPrefix + fi.Name, true));
- }
- return S_OK;
-}
-
-void CCodecs::CloseLibs()
-{
- // OutputDebugStringA("~CloseLibs start");
- /*
- WIN32: FreeLibrary() (CLibrary::Free()) function doesn't work as expected,
- if it's called from another FreeLibrary() call.
- So we need to call FreeLibrary() before global destructors.
-
- Also we free global links from DLLs to object of this module before CLibrary::Free() call.
- */
-
- FOR_VECTOR(i, Libs)
- {
- const CCodecLib &lib = Libs[i];
- if (lib.SetCodecs)
- lib.SetCodecs(NULL);
- }
-
- // OutputDebugStringA("~CloseLibs after SetCodecs");
- Libs.Clear();
- // OutputDebugStringA("~CloseLibs end");
-}
-
-#endif // EXTERNAL_CODECS
-
-
-HRESULT CCodecs::Load()
-{
- #ifdef NEW_FOLDER_INTERFACE
- InternalIcons.LoadIcons(g_hInstance);
- #endif
-
- Formats.Clear();
-
- #ifdef EXTERNAL_CODECS
- MainDll_ErrorPath.Empty();
- Codecs.Clear();
- Hashers.Clear();
- #endif
-
- for (UInt32 i = 0; i < g_NumArcs; i++)
- {
- const CArcInfo &arc = *g_Arcs[i];
- CArcInfoEx item;
-
- item.Name = arc.Name;
- item.CreateInArchive = arc.CreateInArchive;
- item.IsArcFunc = arc.IsArc;
- item.Flags = arc.Flags;
-
- {
- UString e, ae;
- if (arc.Ext)
- e = arc.Ext;
- if (arc.AddExt)
- ae = arc.AddExt;
- item.AddExts(e, ae);
- }
-
- #ifndef _SFX
-
- item.CreateOutArchive = arc.CreateOutArchive;
- item.UpdateEnabled = (arc.CreateOutArchive != NULL);
- item.SignatureOffset = arc.SignatureOffset;
- // item.Version = MY_VER_MIX;
- item.NewInterface = true;
-
- if (arc.IsMultiSignature())
- ParseSignatures(arc.Signature, arc.SignatureSize, item.Signatures);
- else
- item.Signatures.AddNew().CopyFrom(arc.Signature, arc.SignatureSize);
-
- #endif
-
- Formats.Add(item);
- }
-
- #ifdef EXTERNAL_CODECS
- const FString baseFolder = GetBaseFolderPrefixFromRegistry();
- {
- bool loadedOK;
- RINOK(LoadDll(baseFolder + kMainDll, false, &loadedOK));
- if (!loadedOK)
- MainDll_ErrorPath = kMainDll;
- }
- RINOK(LoadDllsFromFolder(baseFolder + kCodecsFolderName FSTRING_PATH_SEPARATOR));
- RINOK(LoadDllsFromFolder(baseFolder + kFormatsFolderName FSTRING_PATH_SEPARATOR));
-
- NeedSetLibCodecs = true;
-
- if (Libs.Size() == 0)
- NeedSetLibCodecs = false;
- else if (Libs.Size() == 1)
- {
- // we don't need to set ISetCompressCodecsInfo, if all arcs and codecs are in one external module.
- #ifndef EXPORT_CODECS
- if (g_NumArcs == 0)
- NeedSetLibCodecs = false;
- #endif
- }
-
- if (NeedSetLibCodecs)
- {
- /* 15.00: now we call global function in DLL: SetCompressCodecsInfo(c)
- old versions called only ISetCompressCodecsInfo::SetCompressCodecsInfo(c) for each archive handler */
-
- FOR_VECTOR(i, Libs)
- {
- CCodecLib &lib = Libs[i];
- lib.SetCodecs = (Func_SetCodecs)lib.Lib.GetProc("SetCodecs");
- if (lib.SetCodecs)
- {
- RINOK(lib.SetCodecs(this));
- }
- }
- }
-
- #endif
-
- return S_OK;
-}
-
-#ifndef _SFX
-
-int CCodecs::FindFormatForArchiveName(const UString &arcPath) const
-{
- int dotPos = arcPath.ReverseFind_Dot();
- if (dotPos <= arcPath.ReverseFind_PathSepar())
- return -1;
- const UString ext = arcPath.Ptr(dotPos + 1);
- if (ext.IsEmpty())
- return -1;
- if (ext.IsEqualTo_Ascii_NoCase("exe"))
- return -1;
- FOR_VECTOR (i, Formats)
- {
- const CArcInfoEx &arc = Formats[i];
- /*
- if (!arc.UpdateEnabled)
- continue;
- */
- if (arc.FindExtension(ext) >= 0)
- return i;
- }
- return -1;
-}
-
-int CCodecs::FindFormatForExtension(const UString &ext) const
-{
- if (ext.IsEmpty())
- return -1;
- FOR_VECTOR (i, Formats)
- if (Formats[i].FindExtension(ext) >= 0)
- return i;
- return -1;
-}
-
-int CCodecs::FindFormatForArchiveType(const UString &arcType) const
-{
- FOR_VECTOR (i, Formats)
- if (Formats[i].Name.IsEqualTo_NoCase(arcType))
- return i;
- return -1;
-}
-
-bool CCodecs::FindFormatForArchiveType(const UString &arcType, CIntVector &formatIndices) const
-{
- formatIndices.Clear();
- for (unsigned pos = 0; pos < arcType.Len();)
- {
- int pos2 = arcType.Find(L'.', pos);
- if (pos2 < 0)
- pos2 = arcType.Len();
- const UString name = arcType.Mid(pos, pos2 - pos);
- if (name.IsEmpty())
- return false;
- int index = FindFormatForArchiveType(name);
- if (index < 0 && name != L"*")
- {
- formatIndices.Clear();
- return false;
- }
- formatIndices.Add(index);
- pos = pos2 + 1;
- }
- return true;
-}
-
-#endif // _SFX
-
-
-#ifdef NEW_FOLDER_INTERFACE
-
-void CCodecIcons::LoadIcons(HMODULE m)
-{
- UString iconTypes;
- MyLoadString(m, kIconTypesResId, iconTypes);
- UStringVector pairs;
- SplitString(iconTypes, pairs);
- FOR_VECTOR (i, pairs)
- {
- const UString &s = pairs[i];
- int pos = s.Find(L':');
- CIconPair iconPair;
- iconPair.IconIndex = -1;
- if (pos < 0)
- pos = s.Len();
- else
- {
- UString num = s.Ptr(pos + 1);
- if (!num.IsEmpty())
- {
- const wchar_t *end;
- iconPair.IconIndex = ConvertStringToUInt32(num, &end);
- if (*end != 0)
- continue;
- }
- }
- iconPair.Ext = s.Left(pos);
- IconPairs.Add(iconPair);
- }
-}
-
-bool CCodecIcons::FindIconIndex(const UString &ext, int &iconIndex) const
-{
- iconIndex = -1;
- FOR_VECTOR (i, IconPairs)
- {
- const CIconPair &pair = IconPairs[i];
- if (ext.IsEqualTo_NoCase(pair.Ext))
- {
- iconIndex = pair.IconIndex;
- return true;
- }
- }
- return false;
-}
-
-#endif // NEW_FOLDER_INTERFACE
-
-
-#ifdef EXTERNAL_CODECS
-
-// #define EXPORT_CODECS
-
-#ifdef EXPORT_CODECS
-
-extern unsigned g_NumCodecs;
-STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject);
-STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject);
-STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
-#define NUM_EXPORT_CODECS g_NumCodecs
-
-extern unsigned g_NumHashers;
-STDAPI CreateHasher(UInt32 index, IHasher **hasher);
-STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
-#define NUM_EXPORT_HASHERS g_NumHashers
-
-#else // EXPORT_CODECS
-
-#define NUM_EXPORT_CODECS 0
-#define NUM_EXPORT_HASHERS 0
-
-#endif // EXPORT_CODECS
-
-STDMETHODIMP CCodecs::GetNumMethods(UInt32 *numMethods)
-{
- *numMethods = NUM_EXPORT_CODECS
- #ifdef EXTERNAL_CODECS
- + Codecs.Size()
- #endif
- ;
- return S_OK;
-}
-
-STDMETHODIMP CCodecs::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumCodecs)
- return GetMethodProperty(index, propID, value);
- #endif
-
- #ifdef EXTERNAL_CODECS
- const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
-
- if (propID == NMethodPropID::kDecoderIsAssigned ||
- propID == NMethodPropID::kEncoderIsAssigned)
- {
- NCOM::CPropVariant prop;
- prop = (bool)((propID == NMethodPropID::kDecoderIsAssigned) ?
- ci.DecoderIsAssigned :
- ci.EncoderIsAssigned);
- prop.Detach(value);
- return S_OK;
- }
- const CCodecLib &lib = Libs[ci.LibIndex];
- return lib.GetMethodProperty(ci.CodecIndex, propID, value);
- #else
- return E_FAIL;
- #endif
-}
-
-STDMETHODIMP CCodecs::CreateDecoder(UInt32 index, const GUID *iid, void **coder)
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumCodecs)
- return CreateDecoder(index, iid, coder);
- #endif
-
- #ifdef EXTERNAL_CODECS
- const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
- if (ci.DecoderIsAssigned)
- {
- const CCodecLib &lib = Libs[ci.LibIndex];
- if (lib.CreateDecoder)
- return lib.CreateDecoder(ci.CodecIndex, iid, (void **)coder);
- if (lib.CreateObject)
- return lib.CreateObject(&ci.Decoder, iid, (void **)coder);
- }
- return S_OK;
- #else
- return E_FAIL;
- #endif
-}
-
-STDMETHODIMP CCodecs::CreateEncoder(UInt32 index, const GUID *iid, void **coder)
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumCodecs)
- return CreateEncoder(index, iid, coder);
- #endif
-
- #ifdef EXTERNAL_CODECS
- const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
- if (ci.EncoderIsAssigned)
- {
- const CCodecLib &lib = Libs[ci.LibIndex];
- if (lib.CreateEncoder)
- return lib.CreateEncoder(ci.CodecIndex, iid, (void **)coder);
- if (lib.CreateObject)
- return lib.CreateObject(&ci.Encoder, iid, (void **)coder);
- }
- return S_OK;
- #else
- return E_FAIL;
- #endif
-}
-
-
-STDMETHODIMP_(UInt32) CCodecs::GetNumHashers()
-{
- return NUM_EXPORT_HASHERS
- #ifdef EXTERNAL_CODECS
- + Hashers.Size()
- #endif
- ;
-}
-
-STDMETHODIMP CCodecs::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumHashers)
- return ::GetHasherProp(index, propID, value);
- #endif
-
- #ifdef EXTERNAL_CODECS
- const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
- return Libs[ci.LibIndex].ComHashers->GetHasherProp(ci.HasherIndex, propID, value);
- #else
- return E_FAIL;
- #endif
-}
-
-STDMETHODIMP CCodecs::CreateHasher(UInt32 index, IHasher **hasher)
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumHashers)
- return CreateHasher(index, hasher);
- #endif
- #ifdef EXTERNAL_CODECS
- const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
- return Libs[ci.LibIndex].ComHashers->CreateHasher(ci.HasherIndex, hasher);
- #else
- return E_FAIL;
- #endif
-}
-
-int CCodecs::GetCodec_LibIndex(UInt32 index) const
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumCodecs)
- return -1;
- #endif
-
- #ifdef EXTERNAL_CODECS
- const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
- return ci.LibIndex;
- #else
- return -1;
- #endif
-}
-
-int CCodecs::GetHasherLibIndex(UInt32 index)
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumHashers)
- return -1;
- #endif
-
- #ifdef EXTERNAL_CODECS
- const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
- return ci.LibIndex;
- #else
- return -1;
- #endif
-}
-
-bool CCodecs::GetCodec_DecoderIsAssigned(UInt32 index) const
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumCodecs)
- {
- NCOM::CPropVariant prop;
- if (GetProperty(index, NMethodPropID::kDecoderIsAssigned, &prop) == S_OK)
- {
- if (prop.vt == VT_BOOL)
- return VARIANT_BOOLToBool(prop.boolVal);
- }
- return false;
- }
- #endif
-
- #ifdef EXTERNAL_CODECS
- return Codecs[index - NUM_EXPORT_CODECS].DecoderIsAssigned;
- #else
- return false;
- #endif
-}
-
-bool CCodecs::GetCodec_EncoderIsAssigned(UInt32 index) const
-{
- #ifdef EXPORT_CODECS
- if (index < g_NumCodecs)
- {
- NCOM::CPropVariant prop;
- if (GetProperty(index, NMethodPropID::kEncoderIsAssigned, &prop) == S_OK)
- {
- if (prop.vt == VT_BOOL)
- return VARIANT_BOOLToBool(prop.boolVal);
- }
- return false;
- }
- #endif
-
- #ifdef EXTERNAL_CODECS
- return Codecs[index - NUM_EXPORT_CODECS].EncoderIsAssigned;
- #else
- return false;
- #endif
-}
-
-UInt32 CCodecs::GetCodec_NumStreams(UInt32 index)
-{
- NCOM::CPropVariant prop;
- RINOK(GetProperty(index, NMethodPropID::kPackStreams, &prop));
- if (prop.vt == VT_UI4)
- return (UInt32)prop.ulVal;
- if (prop.vt == VT_EMPTY)
- return 1;
- return 0;
-}
-
-HRESULT CCodecs::GetCodec_Id(UInt32 index, UInt64 &id)
-{
- NCOM::CPropVariant prop;
- RINOK(GetProperty(index, NMethodPropID::kID, &prop));
- if (prop.vt != VT_UI8)
- return E_INVALIDARG;
- id = prop.uhVal.QuadPart;
- return S_OK;
-}
-
-AString CCodecs::GetCodec_Name(UInt32 index)
-{
- AString s;
- NCOM::CPropVariant prop;
- if (GetProperty(index, NMethodPropID::kName, &prop) == S_OK)
- if (prop.vt == VT_BSTR)
- s.SetFromWStr_if_Ascii(prop.bstrVal);
- return s;
-}
-
-UInt64 CCodecs::GetHasherId(UInt32 index)
-{
- NCOM::CPropVariant prop;
- if (GetHasherProp(index, NMethodPropID::kID, &prop) != S_OK)
- return 0;
- if (prop.vt != VT_UI8)
- return 0;
- return prop.uhVal.QuadPart;
-}
-
-AString CCodecs::GetHasherName(UInt32 index)
-{
- AString s;
- NCOM::CPropVariant prop;
- if (GetHasherProp(index, NMethodPropID::kName, &prop) == S_OK)
- if (prop.vt == VT_BSTR)
- s.SetFromWStr_if_Ascii(prop.bstrVal);
- return s;
-}
-
-UInt32 CCodecs::GetHasherDigestSize(UInt32 index)
-{
- NCOM::CPropVariant prop;
- RINOK(GetHasherProp(index, NMethodPropID::kDigestSize, &prop));
- if (prop.vt != VT_UI4)
- return 0;
- return prop.ulVal;
-}
-
-#endif // EXTERNAL_CODECS
+// LoadCodecs.cpp
+
+/*
+Z7_EXTERNAL_CODECS
+---------------
+ CCodecs::Load() tries to detect the directory with plugins.
+ It stops the checking, if it can find any of the following items:
+ - 7z.dll file
+ - "Formats" subdir
+ - "Codecs" subdir
+ The order of check:
+ 1) directory of client executable
+ 2) WIN32: directory for REGISTRY item [HKEY_*\Software\7-Zip\Path**]
+ The order for HKEY_* : Path** :
+ - HKEY_CURRENT_USER : PathXX
+ - HKEY_LOCAL_MACHINE : PathXX
+ - HKEY_CURRENT_USER : Path
+ - HKEY_LOCAL_MACHINE : Path
+ PathXX is Path32 in 32-bit code
+ PathXX is Path64 in 64-bit code
+
+
+EXPORT_CODECS
+-------------
+ if (Z7_EXTERNAL_CODECS) is defined, then the code exports internal
+ codecs of client from CCodecs object to external plugins.
+ 7-Zip doesn't use that feature. 7-Zip uses the scheme:
+ - client application without internal plugins.
+ - 7z.dll module contains all (or almost all) plugins.
+ 7z.dll can use codecs from another plugins, if required.
+*/
+
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "LoadCodecs.h"
+
+#include "../../ICoder.h"
+#include "../../Common/RegisterArc.h"
+#include "../../Common/RegisterCodec.h"
+
+#ifdef Z7_EXTERNAL_CODECS
+// #define EXPORT_CODECS
+#endif
+
+#ifdef Z7_EXTERNAL_CODECS
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/DLL.h"
+
+#ifdef _WIN32
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Registry.h"
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+
+
+#define kCodecsFolderName FTEXT("Codecs")
+#define kFormatsFolderName FTEXT("Formats")
+
+
+static CFSTR const kMainDll =
+ #ifdef _WIN32
+ FTEXT("7z.dll");
+ #else
+ FTEXT("7z.so");
+ #endif
+
+
+#ifdef _WIN32
+
+static LPCTSTR const kRegistryPath = TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-zip");
+static LPCWSTR const kProgramPathValue = L"Path";
+static LPCWSTR const kProgramPath2Value = L"Path"
+ #ifdef _WIN64
+ L"64";
+ #else
+ L"32";
+ #endif
+
+static bool ReadPathFromRegistry(HKEY baseKey, LPCWSTR value, FString &path)
+{
+ NRegistry::CKey key;
+ if (key.Open(baseKey, kRegistryPath, KEY_READ) == ERROR_SUCCESS)
+ {
+ UString pathU;
+ if (key.QueryValue(value, pathU) == ERROR_SUCCESS)
+ {
+ path = us2fs(pathU);
+ NName::NormalizeDirPathPrefix(path);
+ return NFind::DoesFileExist_Raw(path + kMainDll);
+ }
+ }
+ return false;
+}
+
+#endif // _WIN32
+
+#endif // Z7_EXTERNAL_CODECS
+
+
+static const unsigned kNumArcsMax = 72;
+static unsigned g_NumArcs = 0;
+static const CArcInfo *g_Arcs[kNumArcsMax];
+
+void RegisterArc(const CArcInfo *arcInfo) throw()
+{
+ if (g_NumArcs < kNumArcsMax)
+ {
+ g_Arcs[g_NumArcs] = arcInfo;
+ g_NumArcs++;
+ }
+ // else throw 1;
+}
+
+/*
+static void SplitString(const UString &srcString, UStringVector &destStrings)
+{
+ destStrings.Clear();
+ UString s;
+ unsigned len = srcString.Len();
+ if (len == 0)
+ return;
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = srcString[i];
+ if (c == L' ')
+ {
+ if (!s.IsEmpty())
+ {
+ destStrings.Add(s);
+ s.Empty();
+ }
+ }
+ else
+ s += c;
+ }
+ if (!s.IsEmpty())
+ destStrings.Add(s);
+}
+*/
+
+int CArcInfoEx::FindExtension(const UString &ext) const
+{
+ FOR_VECTOR (i, Exts)
+ if (ext.IsEqualTo_NoCase(Exts[i].Ext))
+ return (int)i;
+ return -1;
+}
+
+void CArcInfoEx::AddExts(const UString &ext, const UString &addExt)
+{
+ UStringVector exts, addExts;
+ SplitString(ext, exts);
+ SplitString(addExt, addExts);
+ FOR_VECTOR (i, exts)
+ {
+ CArcExtInfo extInfo;
+ extInfo.Ext = exts[i];
+ if (i < addExts.Size())
+ {
+ extInfo.AddExt = addExts[i];
+ if (extInfo.AddExt == L"*")
+ extInfo.AddExt.Empty();
+ }
+ Exts.Add(extInfo);
+ }
+}
+
+#ifndef Z7_SFX
+
+static bool ParseSignatures(const Byte *data, unsigned size, CObjectVector<CByteBuffer> &signatures)
+{
+ signatures.Clear();
+ while (size != 0)
+ {
+ const unsigned len = *data++;
+ size--;
+ if (len > size)
+ return false;
+ signatures.AddNew().CopyFrom(data, len);
+ data += len;
+ size -= len;
+ }
+ return true;
+}
+
+#endif // Z7_SFX
+
+// #include <stdio.h>
+
+#ifdef Z7_EXTERNAL_CODECS
+
+static FString GetBaseFolderPrefixFromRegistry()
+{
+ FString moduleFolderPrefix = NDLL::GetModuleDirPrefix();
+
+ #ifdef _WIN32
+ if ( !NFind::DoesFileOrDirExist(moduleFolderPrefix + kMainDll)
+ && !NFind::DoesFileOrDirExist(moduleFolderPrefix + kCodecsFolderName)
+ && !NFind::DoesFileOrDirExist(moduleFolderPrefix + kFormatsFolderName))
+ {
+ FString path;
+ if (ReadPathFromRegistry(HKEY_CURRENT_USER, kProgramPath2Value, path)) return path;
+ if (ReadPathFromRegistry(HKEY_LOCAL_MACHINE, kProgramPath2Value, path)) return path;
+ if (ReadPathFromRegistry(HKEY_CURRENT_USER, kProgramPathValue, path)) return path;
+ if (ReadPathFromRegistry(HKEY_LOCAL_MACHINE, kProgramPathValue, path)) return path;
+ }
+ #endif
+
+ // printf("\nmoduleFolderPrefix = %s\n", (const char *)GetAnsiString(moduleFolderPrefix));
+ return moduleFolderPrefix;
+}
+
+
+static HRESULT GetCoderClass(Func_GetMethodProperty getMethodProperty, UInt32 index,
+ PROPID propId, CLSID &clsId, bool &isAssigned)
+{
+ NCOM::CPropVariant prop;
+ isAssigned = false;
+ RINOK(getMethodProperty(index, propId, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ if (::SysStringByteLen(prop.bstrVal) != sizeof(GUID))
+ return E_FAIL;
+ isAssigned = true;
+ clsId = *(const GUID *)(const void *)prop.bstrVal;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+
+static HRESULT GetMethodBoolProp(Func_GetMethodProperty getMethodProperty, UInt32 index,
+ PROPID propId, bool &resVal, bool &isAssigned)
+{
+ NCOM::CPropVariant prop;
+ resVal = false;
+ isAssigned = false;
+ RINOK(getMethodProperty(index, propId, &prop))
+ if (prop.vt == VT_BOOL)
+ {
+ isAssigned = true;
+ resVal = VARIANT_BOOLToBool(prop.boolVal);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+
+#define MY_GET_FUNC(dest, type, lib, func) \
+ dest = Z7_GET_PROC_ADDRESS(type, lib.Get_HMODULE(), func);
+// #define MY_GET_FUNC(dest, type, func) dest = (type)(func);
+
+#define MY_GET_FUNC_LOC(dest, type, lib, func) \
+ type dest; MY_GET_FUNC(dest, type, lib, func)
+
+HRESULT CCodecs::LoadCodecs()
+{
+ CCodecLib &lib = Libs.Back();
+
+ MY_GET_FUNC (lib.CreateDecoder, Func_CreateDecoder, lib.Lib, "CreateDecoder")
+ MY_GET_FUNC (lib.CreateEncoder, Func_CreateEncoder, lib.Lib, "CreateEncoder")
+ MY_GET_FUNC (lib.GetMethodProperty, Func_GetMethodProperty, lib.Lib, "GetMethodProperty")
+
+ if (lib.GetMethodProperty)
+ {
+ UInt32 numMethods = 1;
+ MY_GET_FUNC_LOC (getNumberOfMethods, Func_GetNumberOfMethods, lib.Lib, "GetNumberOfMethods")
+ if (getNumberOfMethods)
+ {
+ RINOK(getNumberOfMethods(&numMethods))
+ }
+ for (UInt32 i = 0; i < numMethods; i++)
+ {
+ CDllCodecInfo info;
+ info.LibIndex = Libs.Size() - 1;
+ info.CodecIndex = i;
+ RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kEncoder, info.Encoder, info.EncoderIsAssigned))
+ RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kDecoder, info.Decoder, info.DecoderIsAssigned))
+ RINOK(GetMethodBoolProp(lib.GetMethodProperty, i, NMethodPropID::kIsFilter, info.IsFilter, info.IsFilter_Assigned))
+ Codecs.Add(info);
+ }
+ }
+
+ MY_GET_FUNC_LOC (getHashers, Func_GetHashers, lib.Lib, "GetHashers")
+ if (getHashers)
+ {
+ RINOK(getHashers(&lib.ComHashers))
+ if (lib.ComHashers)
+ {
+ UInt32 numMethods = lib.ComHashers->GetNumHashers();
+ for (UInt32 i = 0; i < numMethods; i++)
+ {
+ CDllHasherInfo info;
+ info.LibIndex = Libs.Size() - 1;
+ info.HasherIndex = i;
+ Hashers.Add(info);
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+static HRESULT GetProp(
+ Func_GetHandlerProperty getProp,
+ Func_GetHandlerProperty2 getProp2,
+ UInt32 index, PROPID propID, NCOM::CPropVariant &prop)
+{
+ if (getProp2)
+ return getProp2(index, propID, &prop);
+ return getProp(propID, &prop);
+}
+
+static HRESULT GetProp_Bool(
+ Func_GetHandlerProperty getProp,
+ Func_GetHandlerProperty2 getProp2,
+ UInt32 index, PROPID propID, bool &res)
+{
+ res = false;
+ NCOM::CPropVariant prop;
+ RINOK(GetProp(getProp, getProp2, index, propID, prop))
+ if (prop.vt == VT_BOOL)
+ res = VARIANT_BOOLToBool(prop.boolVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+static HRESULT GetProp_UInt32(
+ Func_GetHandlerProperty getProp,
+ Func_GetHandlerProperty2 getProp2,
+ UInt32 index, PROPID propID, UInt32 &res, bool &defined)
+{
+ res = 0;
+ defined = false;
+ NCOM::CPropVariant prop;
+ RINOK(GetProp(getProp, getProp2, index, propID, prop))
+ if (prop.vt == VT_UI4)
+ {
+ res = prop.ulVal;
+ defined = true;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+static HRESULT GetProp_String(
+ Func_GetHandlerProperty getProp,
+ Func_GetHandlerProperty2 getProp2,
+ UInt32 index, PROPID propID, UString &res)
+{
+ res.Empty();
+ NCOM::CPropVariant prop;
+ RINOK(GetProp(getProp, getProp2, index, propID, prop))
+ if (prop.vt == VT_BSTR)
+ res.SetFromBstr(prop.bstrVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+static HRESULT GetProp_RawData(
+ Func_GetHandlerProperty getProp,
+ Func_GetHandlerProperty2 getProp2,
+ UInt32 index, PROPID propID, CByteBuffer &bb)
+{
+ bb.Free();
+ NCOM::CPropVariant prop;
+ RINOK(GetProp(getProp, getProp2, index, propID, prop))
+ if (prop.vt == VT_BSTR)
+ {
+ UINT len = ::SysStringByteLen(prop.bstrVal);
+ bb.CopyFrom((const Byte *)prop.bstrVal, len);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+static const UInt32 kArcFlagsPars[] =
+{
+ NArchive::NHandlerPropID::kKeepName, NArcInfoFlags::kKeepName,
+ NArchive::NHandlerPropID::kAltStreams, NArcInfoFlags::kAltStreams,
+ NArchive::NHandlerPropID::kNtSecure, NArcInfoFlags::kNtSecure
+};
+
+HRESULT CCodecs::LoadFormats()
+{
+ const NDLL::CLibrary &lib = Libs.Back().Lib;
+
+ Func_GetHandlerProperty getProp = NULL;
+ MY_GET_FUNC_LOC (getProp2, Func_GetHandlerProperty2, lib, "GetHandlerProperty2")
+ MY_GET_FUNC_LOC (getIsArc, Func_GetIsArc, lib, "GetIsArc")
+
+ UInt32 numFormats = 1;
+
+ if (getProp2)
+ {
+ MY_GET_FUNC_LOC (getNumberOfFormats, Func_GetNumberOfFormats, lib, "GetNumberOfFormats")
+ if (getNumberOfFormats)
+ {
+ RINOK(getNumberOfFormats(&numFormats))
+ }
+ }
+ else
+ {
+ MY_GET_FUNC (getProp, Func_GetHandlerProperty, lib, "GetHandlerProperty")
+ if (!getProp)
+ return S_OK;
+ }
+
+ for (UInt32 i = 0; i < numFormats; i++)
+ {
+ CArcInfoEx item;
+ item.LibIndex = (int)(Libs.Size() - 1);
+ item.FormatIndex = i;
+
+ RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kName, item.Name))
+
+ {
+ NCOM::CPropVariant prop;
+ if (GetProp(getProp, getProp2, i, NArchive::NHandlerPropID::kClassID, prop) != S_OK)
+ continue;
+ if (prop.vt != VT_BSTR)
+ continue;
+ if (::SysStringByteLen(prop.bstrVal) != sizeof(GUID))
+ return E_FAIL;
+ item.ClassID = *(const GUID *)(const void *)prop.bstrVal;
+ prop.Clear();
+ }
+
+ UString ext, addExt;
+ RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kExtension, ext))
+ RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kAddExtension, addExt))
+ item.AddExts(ext, addExt);
+
+ GetProp_Bool(getProp, getProp2, i, NArchive::NHandlerPropID::kUpdate, item.UpdateEnabled);
+ bool flags_Defined = false;
+ RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kFlags, item.Flags, flags_Defined))
+ item.NewInterface = flags_Defined;
+ if (!flags_Defined) // && item.UpdateEnabled
+ {
+ // support for DLL version before 9.31:
+ for (unsigned j = 0; j < Z7_ARRAY_SIZE(kArcFlagsPars); j += 2)
+ {
+ bool val = false;
+ GetProp_Bool(getProp, getProp2, i, kArcFlagsPars[j], val);
+ if (val)
+ item.Flags |= kArcFlagsPars[j + 1];
+ }
+ }
+
+ {
+ bool defined = false;
+ RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kTimeFlags, item.TimeFlags, defined))
+ }
+
+ CByteBuffer sig;
+ RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kSignature, sig))
+ if (sig.Size() != 0)
+ item.Signatures.Add(sig);
+ else
+ {
+ RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kMultiSignature, sig))
+ ParseSignatures(sig, (unsigned)sig.Size(), item.Signatures);
+ }
+
+ bool signatureOffset_Defined;
+ RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kSignatureOffset, item.SignatureOffset, signatureOffset_Defined))
+
+ // bool version_Defined;
+ // RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kVersion, item.Version, version_Defined));
+
+ if (getIsArc)
+ getIsArc(i, &item.IsArcFunc);
+
+ Formats.Add(item);
+ }
+ return S_OK;
+}
+
+#ifdef Z7_LARGE_PAGES
+extern "C"
+{
+ extern SIZE_T g_LargePageSize;
+}
+#endif
+
+
+void CCodecs::AddLastError(const FString &path)
+{
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ CCodecError &error = Errors.AddNew();
+ error.Path = path;
+ error.ErrorCode = res;
+}
+
+
+static bool IsSupportedDll(CCodecLib &lib)
+{
+ MY_GET_FUNC_LOC (
+ f_GetModuleProp,
+ Func_GetModuleProp, lib.Lib,
+ "GetModuleProp")
+ /* p7zip and 7-Zip before v23 used virtual destructor in IUnknown,
+ if _WIN32 is not defined */
+ UInt32 flags =
+ #ifdef _WIN32
+ NModuleInterfaceType::k_IUnknown_VirtDestructor_No;
+ #else
+ NModuleInterfaceType::k_IUnknown_VirtDestructor_Yes;
+ #endif
+ if (f_GetModuleProp)
+ {
+ {
+ NCOM::CPropVariant prop;
+ if (f_GetModuleProp(NModulePropID::kInterfaceType, &prop) == S_OK)
+ {
+ if (prop.vt == VT_UI4)
+ flags = prop.ulVal;
+ else if (prop.vt != VT_EMPTY)
+ return false;
+ }
+ }
+ {
+ NCOM::CPropVariant prop;
+ if (f_GetModuleProp(NModulePropID::kVersion, &prop) == S_OK)
+ {
+ if (prop.vt == VT_UI4)
+ lib.Version = prop.ulVal;
+ }
+ }
+ }
+ if (
+ flags
+ // (flags & NModuleFlags::kMask)
+ != NModuleInterfaceType::k_IUnknown_VirtDestructor_ThisModule)
+ return false;
+ return true;
+}
+
+
+HRESULT CCodecs::LoadDll(const FString &dllPath, bool needCheckDll, bool *loadedOK)
+{
+ if (loadedOK)
+ *loadedOK = false;
+
+ // needCheckDll = 1;
+
+ #ifdef _WIN32
+ if (needCheckDll)
+ {
+ NDLL::CLibrary lib;
+ if (!lib.LoadEx(dllPath, LOAD_LIBRARY_AS_DATAFILE))
+ {
+ /* if is not win32
+ // %1 is not a valid Win32 application.
+ // #define ERROR_BAD_EXE_FORMAT 193L
+ */
+ // return GetLastError_noZero_HRESULT();
+ const DWORD lastError = GetLastError();
+ if (lastError != ERROR_BAD_EXE_FORMAT)
+ {
+ CCodecError &error = Errors.AddNew();
+ error.Path = dllPath;
+ error.Message = "cannot load file as datafile library";
+ error.ErrorCode = HRESULT_FROM_WIN32(lastError);
+ }
+ return S_OK;
+ }
+ }
+ #else
+ UNUSED_VAR(needCheckDll)
+ #endif
+
+ Libs.AddNew();
+ CCodecLib &lib = Libs.Back();
+ lib.Path = dllPath;
+ bool used = false;
+ // HRESULT res = S_OK;
+
+ if (lib.Lib.Load(dllPath))
+ {
+ if (!IsSupportedDll(lib))
+ {
+ CCodecError &error = Errors.AddNew();
+ error.Path = dllPath;
+ error.Message = "the module is not compatible with program";
+ }
+ else
+ {
+ if (loadedOK)
+ *loadedOK = true;
+ /*
+ #ifdef NEW_FOLDER_INTERFACE
+ lib.LoadIcons();
+ #endif
+ */
+
+ /*
+ {
+ MY_GET_FUNC_LOC (_libStartup, Func_libStartup, lib.Lib, "LibStartup")
+ if (_libStartup)
+ {
+ HRESULT res = _libStartup();
+ if (res != 0)
+ {
+ CCodecError &error = Errors.AddNew();
+ error.Path = dllPath;
+ error.ErrorCode = res;
+ }
+ }
+ }
+ */
+
+ #ifdef Z7_LARGE_PAGES
+ if (g_LargePageSize != 0)
+ {
+ MY_GET_FUNC_LOC (setLargePageMode, Func_SetLargePageMode, lib.Lib, "SetLargePageMode")
+ if (setLargePageMode)
+ setLargePageMode();
+ }
+ #endif
+
+ if (CaseSensitive_Change)
+ {
+ MY_GET_FUNC_LOC (setCaseSensitive, Func_SetCaseSensitive, lib.Lib, "SetCaseSensitive")
+ if (setCaseSensitive)
+ setCaseSensitive(CaseSensitive ? 1 : 0);
+ }
+
+ /*
+ {
+ MY_GET_FUNC_LOC (setClientVersion, Func_SetClientVersion, lib.Lib, "SetClientVersion")
+ if (setClientVersion)
+ {
+ // const UInt32 kVersion = (MY_VER_MAJOR << 16) | MY_VER_MINOR;
+ setClientVersion(g_ClientVersion);
+ }
+ }
+ */
+
+
+ MY_GET_FUNC (lib.CreateObject, Func_CreateObject, lib.Lib, "CreateObject")
+ {
+ unsigned startSize = Codecs.Size() + Hashers.Size();
+ HRESULT res = LoadCodecs();
+ if (startSize != Codecs.Size() + Hashers.Size())
+ used = true;
+ if (res == S_OK && lib.CreateObject)
+ {
+ startSize = Formats.Size();
+ res = LoadFormats();
+ if (startSize != Formats.Size())
+ used = true;
+ }
+ if (res != S_OK)
+ {
+ CCodecError &error = Errors.AddNew();
+ error.Path = dllPath;
+ error.ErrorCode = res;
+ }
+ }
+ // plugins can use non-7-zip dlls, so we silently ignore non7zip DLLs
+ /*
+ if (!used)
+ {
+ CCodecError &error = Errors.AddNew();
+ error.Path = dllPath;
+ error.Message = "no 7-Zip code";
+ }
+ */
+ }
+ }
+ else
+ {
+ AddLastError(dllPath);
+ }
+
+ if (!used)
+ Libs.DeleteBack();
+
+ return S_OK;
+}
+
+HRESULT CCodecs::LoadDllsFromFolder(const FString &folderPath)
+{
+ if (!NFile::NFind::DoesDirExist_FollowLink(folderPath))
+ // if (!NFile::NFind::DoesDirExist(folderPath))
+ {
+ // AddLastError(folderPath);
+ return S_OK;
+ }
+
+ FString folderPrefix = folderPath;
+ folderPrefix.Add_PathSepar();
+
+ NFile::NFind::CEnumerator enumerator;
+ enumerator.SetDirPrefix(folderPrefix);
+ NFile::NFind::CDirEntry fi;
+ for (;;)
+ {
+ bool found;
+ if (!enumerator.Next(fi, found))
+ {
+ // it can be wrong Symbolic link to folder here
+ AddLastError(folderPath);
+ break;
+ // return GetLastError_noZero_HRESULT();
+ }
+ if (!found)
+ break;
+ #ifdef _WIN32
+ if (fi.IsDir())
+ continue;
+ #else
+ if (enumerator.DirEntry_IsDir(fi, true)) // followLink
+ continue;
+ #endif
+
+ RINOK(LoadDll(folderPrefix + fi.Name, true))
+ }
+ return S_OK;
+}
+
+void CCodecs::CloseLibs()
+{
+ // OutputDebugStringA("~CloseLibs start");
+ /*
+ WIN32: FreeLibrary() (CLibrary::Free()) function doesn't work as expected,
+ if it's called from another FreeLibrary() call.
+ So we need to call FreeLibrary() before global destructors.
+
+ Also we free global links from DLLs to object of this module before CLibrary::Free() call.
+ */
+
+ FOR_VECTOR(i, Libs)
+ {
+ const CCodecLib &lib = Libs[i];
+ if (lib.SetCodecs)
+ lib.SetCodecs(NULL);
+ }
+
+ // OutputDebugStringA("~CloseLibs after SetCodecs");
+ Libs.Clear();
+ // OutputDebugStringA("~CloseLibs end");
+}
+
+#endif // Z7_EXTERNAL_CODECS
+
+
+HRESULT CCodecs::Load()
+{
+ /*
+ #ifdef NEW_FOLDER_INTERFACE
+ InternalIcons.LoadIcons(g_hInstance);
+ #endif
+ */
+
+ Formats.Clear();
+
+ #ifdef Z7_EXTERNAL_CODECS
+ Errors.Clear();
+ MainDll_ErrorPath.Empty();
+ Codecs.Clear();
+ Hashers.Clear();
+ #endif
+
+ for (UInt32 i = 0; i < g_NumArcs; i++)
+ {
+ const CArcInfo &arc = *g_Arcs[i];
+ CArcInfoEx item;
+
+ item.Name = arc.Name;
+ item.CreateInArchive = arc.CreateInArchive;
+ item.IsArcFunc = arc.IsArc;
+ item.Flags = arc.Flags;
+
+ {
+ UString e, ae;
+ if (arc.Ext)
+ e = arc.Ext;
+ if (arc.AddExt)
+ ae = arc.AddExt;
+ item.AddExts(e, ae);
+ }
+
+ #ifndef Z7_SFX
+
+ item.CreateOutArchive = arc.CreateOutArchive;
+ item.UpdateEnabled = (arc.CreateOutArchive != NULL);
+ item.SignatureOffset = arc.SignatureOffset;
+ // item.Version = MY_VER_MIX;
+ item.NewInterface = true;
+
+ if (arc.IsMultiSignature())
+ ParseSignatures(arc.Signature, arc.SignatureSize, item.Signatures);
+ else
+ {
+ if (arc.SignatureSize != 0) // 21.04
+ item.Signatures.AddNew().CopyFrom(arc.Signature, arc.SignatureSize);
+ }
+
+ #endif
+
+ Formats.Add(item);
+ }
+
+ // printf("\nLoad codecs \n");
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const FString baseFolder = GetBaseFolderPrefixFromRegistry();
+ {
+ bool loadedOK;
+ RINOK(LoadDll(baseFolder + kMainDll, false, &loadedOK))
+ if (!loadedOK)
+ MainDll_ErrorPath = kMainDll;
+ }
+ RINOK(LoadDllsFromFolder(baseFolder + kCodecsFolderName))
+ RINOK(LoadDllsFromFolder(baseFolder + kFormatsFolderName))
+
+ NeedSetLibCodecs = true;
+
+ if (Libs.Size() == 0)
+ NeedSetLibCodecs = false;
+ else if (Libs.Size() == 1)
+ {
+ // we don't need to set ISetCompressCodecsInfo, if all arcs and codecs are in one external module.
+ #ifndef EXPORT_CODECS
+ if (g_NumArcs == 0)
+ NeedSetLibCodecs = false;
+ #endif
+ }
+
+ if (NeedSetLibCodecs)
+ {
+ /* 15.00: now we call global function in DLL: SetCompressCodecsInfo(c)
+ old versions called only ISetCompressCodecsInfo::SetCompressCodecsInfo(c) for each archive handler */
+
+ FOR_VECTOR(i, Libs)
+ {
+ CCodecLib &lib = Libs[i];
+ MY_GET_FUNC (lib.SetCodecs, Func_SetCodecs, lib.Lib, "SetCodecs")
+ if (lib.SetCodecs)
+ {
+ RINOK(lib.SetCodecs(this))
+ }
+ }
+ }
+
+ #endif
+
+ // we sort Formats to get fixed order of Formats after compilation.
+ Formats.Sort();
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+int CCodecs::FindFormatForArchiveName(const UString &arcPath) const
+{
+ int dotPos = arcPath.ReverseFind_Dot();
+ if (dotPos <= arcPath.ReverseFind_PathSepar())
+ return -1;
+ const UString ext = arcPath.Ptr((unsigned)(dotPos + 1));
+ if (ext.IsEmpty())
+ return -1;
+ if (ext.IsEqualTo_Ascii_NoCase("exe"))
+ return -1;
+ FOR_VECTOR (i, Formats)
+ {
+ const CArcInfoEx &arc = Formats[i];
+ /*
+ if (!arc.UpdateEnabled)
+ continue;
+ */
+ if (arc.FindExtension(ext) >= 0)
+ return (int)i;
+ }
+ return -1;
+}
+
+int CCodecs::FindFormatForExtension(const UString &ext) const
+{
+ if (ext.IsEmpty())
+ return -1;
+ FOR_VECTOR (i, Formats)
+ if (Formats[i].FindExtension(ext) >= 0)
+ return (int)i;
+ return -1;
+}
+
+int CCodecs::FindFormatForArchiveType(const UString &arcType) const
+{
+ FOR_VECTOR (i, Formats)
+ if (Formats[i].Name.IsEqualTo_NoCase(arcType))
+ return (int)i;
+ return -1;
+}
+
+bool CCodecs::FindFormatForArchiveType(const UString &arcType, CIntVector &formatIndices) const
+{
+ formatIndices.Clear();
+ for (unsigned pos = 0; pos < arcType.Len();)
+ {
+ int pos2 = arcType.Find(L'.', pos);
+ if (pos2 < 0)
+ pos2 = (int)arcType.Len();
+ const UString name = arcType.Mid(pos, (unsigned)pos2 - pos);
+ if (name.IsEmpty())
+ return false;
+ int index = FindFormatForArchiveType(name);
+ if (index < 0 && name != L"*")
+ {
+ formatIndices.Clear();
+ return false;
+ }
+ formatIndices.Add(index);
+ pos = (unsigned)pos2 + 1;
+ }
+ return true;
+}
+
+#endif // Z7_SFX
+
+
+#ifdef Z7_EXTERNAL_CODECS
+
+// #define EXPORT_CODECS
+
+#ifdef EXPORT_CODECS
+
+extern unsigned g_NumCodecs;
+STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject);
+STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject);
+STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
+#define NUM_EXPORT_CODECS g_NumCodecs
+
+extern unsigned g_NumHashers;
+STDAPI CreateHasher(UInt32 index, IHasher **hasher);
+STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
+#define NUM_EXPORT_HASHERS g_NumHashers
+
+#else // EXPORT_CODECS
+
+#define NUM_EXPORT_CODECS 0
+#define NUM_EXPORT_HASHERS 0
+
+#endif // EXPORT_CODECS
+
+Z7_COM7F_IMF(CCodecs::GetNumMethods(UInt32 *numMethods))
+{
+ *numMethods = NUM_EXPORT_CODECS
+ #ifdef Z7_EXTERNAL_CODECS
+ + Codecs.Size()
+ #endif
+ ;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CCodecs::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ return GetMethodProperty(index, propID, value);
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
+
+ if (propID == NMethodPropID::kDecoderIsAssigned ||
+ propID == NMethodPropID::kEncoderIsAssigned)
+ {
+ NCOM::CPropVariant prop;
+ prop = (bool)((propID == NMethodPropID::kDecoderIsAssigned) ?
+ ci.DecoderIsAssigned :
+ ci.EncoderIsAssigned);
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ if (propID == NMethodPropID::kIsFilter && ci.IsFilter_Assigned)
+ {
+ NCOM::CPropVariant prop;
+ prop = (bool)ci.IsFilter;
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ const CCodecLib &lib = Libs[ci.LibIndex];
+ return lib.GetMethodProperty(ci.CodecIndex, propID, value);
+ #else
+ return E_FAIL;
+ #endif
+}
+
+Z7_COM7F_IMF(CCodecs::CreateDecoder(UInt32 index, const GUID *iid, void **coder))
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ return CreateDecoder(index, iid, coder);
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
+ if (ci.DecoderIsAssigned)
+ {
+ const CCodecLib &lib = Libs[ci.LibIndex];
+ if (lib.CreateDecoder)
+ return lib.CreateDecoder(ci.CodecIndex, iid, (void **)coder);
+ if (lib.CreateObject)
+ return lib.CreateObject(&ci.Decoder, iid, (void **)coder);
+ }
+ return S_OK;
+ #else
+ return E_FAIL;
+ #endif
+}
+
+Z7_COM7F_IMF(CCodecs::CreateEncoder(UInt32 index, const GUID *iid, void **coder))
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ return CreateEncoder(index, iid, coder);
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
+ if (ci.EncoderIsAssigned)
+ {
+ const CCodecLib &lib = Libs[ci.LibIndex];
+ if (lib.CreateEncoder)
+ return lib.CreateEncoder(ci.CodecIndex, iid, (void **)coder);
+ if (lib.CreateObject)
+ return lib.CreateObject(&ci.Encoder, iid, (void **)coder);
+ }
+ return S_OK;
+ #else
+ return E_FAIL;
+ #endif
+}
+
+
+Z7_COM7F_IMF2(UInt32, CCodecs::GetNumHashers())
+{
+ return NUM_EXPORT_HASHERS
+ #ifdef Z7_EXTERNAL_CODECS
+ + Hashers.Size()
+ #endif
+ ;
+}
+
+Z7_COM7F_IMF(CCodecs::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumHashers)
+ return ::GetHasherProp(index, propID, value);
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
+ return Libs[ci.LibIndex].ComHashers->GetHasherProp(ci.HasherIndex, propID, value);
+ #else
+ return E_FAIL;
+ #endif
+}
+
+Z7_COM7F_IMF(CCodecs::CreateHasher(UInt32 index, IHasher **hasher))
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumHashers)
+ return CreateHasher(index, hasher);
+ #endif
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
+ return Libs[ci.LibIndex].ComHashers->CreateHasher(ci.HasherIndex, hasher);
+ #else
+ return E_FAIL;
+ #endif
+}
+
+int CCodecs::GetCodec_LibIndex(UInt32 index) const
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ return -1;
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
+ return (int)ci.LibIndex;
+ #else
+ return -1;
+ #endif
+}
+
+int CCodecs::GetHasherLibIndex(UInt32 index)
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumHashers)
+ return -1;
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
+ return (int)ci.LibIndex;
+ #else
+ return -1;
+ #endif
+}
+
+bool CCodecs::GetCodec_DecoderIsAssigned(UInt32 index) const
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ {
+ NCOM::CPropVariant prop;
+ if (GetProperty(index, NMethodPropID::kDecoderIsAssigned, &prop) == S_OK)
+ {
+ if (prop.vt == VT_BOOL)
+ return VARIANT_BOOLToBool(prop.boolVal);
+ }
+ return false;
+ }
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ return Codecs[index - NUM_EXPORT_CODECS].DecoderIsAssigned;
+ #else
+ return false;
+ #endif
+}
+
+
+bool CCodecs::GetCodec_EncoderIsAssigned(UInt32 index) const
+{
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ {
+ NCOM::CPropVariant prop;
+ if (GetProperty(index, NMethodPropID::kEncoderIsAssigned, &prop) == S_OK)
+ {
+ if (prop.vt == VT_BOOL)
+ return VARIANT_BOOLToBool(prop.boolVal);
+ }
+ return false;
+ }
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ return Codecs[index - NUM_EXPORT_CODECS].EncoderIsAssigned;
+ #else
+ return false;
+ #endif
+}
+
+
+bool CCodecs::GetCodec_IsFilter(UInt32 index, bool &isAssigned) const
+{
+ isAssigned = false;
+ #ifdef EXPORT_CODECS
+ if (index < g_NumCodecs)
+ {
+ NCOM::CPropVariant prop;
+ if (GetProperty(index, NMethodPropID::kIsFilter, &prop) == S_OK)
+ {
+ if (prop.vt == VT_BOOL)
+ {
+ isAssigned = true;
+ return VARIANT_BOOLToBool(prop.boolVal);
+ }
+ }
+ return false;
+ }
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ const CDllCodecInfo &c = Codecs[index - NUM_EXPORT_CODECS];
+ isAssigned = c.IsFilter_Assigned;
+ return c.IsFilter;
+ }
+ #else
+ return false;
+ #endif
+}
+
+
+UInt32 CCodecs::GetCodec_NumStreams(UInt32 index)
+{
+ NCOM::CPropVariant prop;
+ if (GetProperty(index, NMethodPropID::kPackStreams, &prop) != S_OK)
+ return 0;
+ if (prop.vt == VT_UI4)
+ return (UInt32)prop.ulVal;
+ if (prop.vt == VT_EMPTY)
+ return 1;
+ return 0;
+}
+
+HRESULT CCodecs::GetCodec_Id(UInt32 index, UInt64 &id)
+{
+ NCOM::CPropVariant prop;
+ RINOK(GetProperty(index, NMethodPropID::kID, &prop))
+ if (prop.vt != VT_UI8)
+ return E_INVALIDARG;
+ id = prop.uhVal.QuadPart;
+ return S_OK;
+}
+
+AString CCodecs::GetCodec_Name(UInt32 index)
+{
+ AString s;
+ NCOM::CPropVariant prop;
+ if (GetProperty(index, NMethodPropID::kName, &prop) == S_OK)
+ if (prop.vt == VT_BSTR)
+ s.SetFromWStr_if_Ascii(prop.bstrVal);
+ return s;
+}
+
+UInt64 CCodecs::GetHasherId(UInt32 index)
+{
+ NCOM::CPropVariant prop;
+ if (GetHasherProp(index, NMethodPropID::kID, &prop) != S_OK)
+ return 0;
+ if (prop.vt != VT_UI8)
+ return 0;
+ return prop.uhVal.QuadPart;
+}
+
+AString CCodecs::GetHasherName(UInt32 index)
+{
+ AString s;
+ NCOM::CPropVariant prop;
+ if (GetHasherProp(index, NMethodPropID::kName, &prop) == S_OK)
+ if (prop.vt == VT_BSTR)
+ s.SetFromWStr_if_Ascii(prop.bstrVal);
+ return s;
+}
+
+UInt32 CCodecs::GetHasherDigestSize(UInt32 index)
+{
+ NCOM::CPropVariant prop;
+ if (GetHasherProp(index, NMethodPropID::kDigestSize, &prop) != S_OK)
+ return 0;
+ if (prop.vt != VT_UI4)
+ return 0;
+ return prop.ulVal;
+}
+
+void CCodecs::GetCodecsErrorMessage(UString &s)
+{
+ s.Empty();
+ FOR_VECTOR (i, Errors)
+ {
+ const CCodecError &ce = Errors[i];
+ s += "Codec Load Error: ";
+ s += fs2us(ce.Path);
+ if (ce.ErrorCode != 0)
+ {
+ s += " : ";
+ s += NWindows::NError::MyFormatMessage(ce.ErrorCode);
+ }
+ if (!ce.Message.IsEmpty())
+ {
+ s += " : ";
+ s += ce.Message;
+ }
+ s.Add_LF();
+ }
+}
+
+#endif // Z7_EXTERNAL_CODECS
+
+#ifndef Z7_SFX
+
+extern unsigned g_NumCodecs;
+extern const CCodecInfo *g_Codecs[];
+
+void CCodecs::Get_CodecsInfoUser_Vector(CObjectVector<CCodecInfoUser> &v)
+{
+ v.Clear();
+ {
+ for (unsigned i = 0; i < g_NumCodecs; i++)
+ {
+ const CCodecInfo &cod = *g_Codecs[i];
+ CCodecInfoUser &u = v.AddNew();
+ u.EncoderIsAssigned = (cod.CreateEncoder != NULL);
+ u.DecoderIsAssigned = (cod.CreateDecoder != NULL);
+ u.IsFilter_Assigned = true;
+ u.IsFilter = cod.IsFilter;
+ u.NumStreams = cod.NumStreams;
+ u.Name = cod.Name;
+ }
+ }
+
+
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ UInt32 numMethods;
+ if (GetNumMethods(&numMethods) == S_OK)
+ for (UInt32 j = 0; j < numMethods; j++)
+ {
+ CCodecInfoUser &u = v.AddNew();
+ u.EncoderIsAssigned = GetCodec_EncoderIsAssigned(j);
+ u.DecoderIsAssigned = GetCodec_DecoderIsAssigned(j);
+ u.IsFilter = GetCodec_IsFilter(j, u.IsFilter_Assigned);
+ u.NumStreams = GetCodec_NumStreams(j);
+ u.Name = GetCodec_Name(j);
+ }
+ }
+ #endif
+}
+
+#endif
diff --git a/CPP/7zip/UI/Common/LoadCodecs.h b/CPP/7zip/UI/Common/LoadCodecs.h
index 9ba36d3..a81bb5c 100644
--- a/CPP/7zip/UI/Common/LoadCodecs.h
+++ b/CPP/7zip/UI/Common/LoadCodecs.h
@@ -1,424 +1,482 @@
-// LoadCodecs.h
-
-#ifndef __LOAD_CODECS_H
-#define __LOAD_CODECS_H
-
-/*
-Client application uses LoadCodecs.* to load plugins to
-CCodecs object, that contains 3 lists of plugins:
- 1) Formats - internal and external archive handlers
- 2) Codecs - external codecs
- 3) Hashers - external hashers
-
-EXTERNAL_CODECS
----------------
-
- if EXTERNAL_CODECS is defined, then the code tries to load external
- plugins from DLL files (shared libraries).
-
- There are two types of executables in 7-Zip:
-
- 1) Executable that uses external plugins must be compiled
- with EXTERNAL_CODECS defined:
- - 7z.exe, 7zG.exe, 7zFM.exe
-
- Note: EXTERNAL_CODECS is used also in CPP/7zip/Common/CreateCoder.h
- that code is used in plugin module (7z.dll).
-
- 2) Standalone modules are compiled without EXTERNAL_CODECS:
- - SFX modules: 7z.sfx, 7zCon.sfx
- - standalone versions of console 7-Zip: 7za.exe, 7zr.exe
-
- if EXTERNAL_CODECS is defined, CCodecs class implements interfaces:
- - ICompressCodecsInfo : for Codecs
- - IHashers : for Hashers
-
- The client application can send CCodecs object to each plugin module.
- And plugin module can use ICompressCodecsInfo or IHashers interface to access
- another plugins.
-
- There are 2 ways to send (ICompressCodecsInfo * compressCodecsInfo) to plugin
- 1) for old versions:
- a) request ISetCompressCodecsInfo from created archive handler.
- b) call ISetCompressCodecsInfo::SetCompressCodecsInfo(compressCodecsInfo)
- 2) for new versions:
- a) request "SetCodecs" function from DLL file
- b) call SetCodecs(compressCodecsInfo) function from DLL file
-*/
-
-#include "../../../Common/MyBuffer.h"
-#include "../../../Common/MyCom.h"
-#include "../../../Common/MyString.h"
-#include "../../../Common/ComTry.h"
-
-#ifdef EXTERNAL_CODECS
-#include "../../../Windows/DLL.h"
-#endif
-
-#include "../../ICoder.h"
-
-#include "../../Archive/IArchive.h"
-
-
-#ifdef EXTERNAL_CODECS
-
-struct CDllCodecInfo
-{
- unsigned LibIndex;
- UInt32 CodecIndex;
- bool EncoderIsAssigned;
- bool DecoderIsAssigned;
- CLSID Encoder;
- CLSID Decoder;
-};
-
-struct CDllHasherInfo
-{
- unsigned LibIndex;
- UInt32 HasherIndex;
-};
-
-#endif
-
-struct CArcExtInfo
-{
- UString Ext;
- UString AddExt;
-
- CArcExtInfo() {}
- CArcExtInfo(const UString &ext): Ext(ext) {}
- CArcExtInfo(const UString &ext, const UString &addExt): Ext(ext), AddExt(addExt) {}
-};
-
-
-struct CArcInfoEx
-{
- UInt32 Flags;
-
- Func_CreateInArchive CreateInArchive;
- Func_IsArc IsArcFunc;
-
- UString Name;
- CObjectVector<CArcExtInfo> Exts;
-
- #ifndef _SFX
- Func_CreateOutArchive CreateOutArchive;
- bool UpdateEnabled;
- bool NewInterface;
- // UInt32 Version;
- UInt32 SignatureOffset;
- CObjectVector<CByteBuffer> Signatures;
- #ifdef NEW_FOLDER_INTERFACE
- UStringVector AssociateExts;
- #endif
- #endif
-
- #ifdef EXTERNAL_CODECS
- int LibIndex;
- UInt32 FormatIndex;
- CLSID ClassID;
- #endif
-
- bool Flags_KeepName() const { return (Flags & NArcInfoFlags::kKeepName) != 0; }
- bool Flags_FindSignature() const { return (Flags & NArcInfoFlags::kFindSignature) != 0; }
-
- bool Flags_AltStreams() const { return (Flags & NArcInfoFlags::kAltStreams) != 0; }
- bool Flags_NtSecure() const { return (Flags & NArcInfoFlags::kNtSecure) != 0; }
- bool Flags_SymLinks() const { return (Flags & NArcInfoFlags::kSymLinks) != 0; }
- bool Flags_HardLinks() const { return (Flags & NArcInfoFlags::kHardLinks) != 0; }
-
- bool Flags_UseGlobalOffset() const { return (Flags & NArcInfoFlags::kUseGlobalOffset) != 0; }
- bool Flags_StartOpen() const { return (Flags & NArcInfoFlags::kStartOpen) != 0; }
- bool Flags_BackwardOpen() const { return (Flags & NArcInfoFlags::kBackwardOpen) != 0; }
- bool Flags_PreArc() const { return (Flags & NArcInfoFlags::kPreArc) != 0; }
- bool Flags_PureStartOpen() const { return (Flags & NArcInfoFlags::kPureStartOpen) != 0; }
-
- UString GetMainExt() const
- {
- if (Exts.IsEmpty())
- return UString();
- return Exts[0].Ext;
- }
- int FindExtension(const UString &ext) const;
-
- /*
- UString GetAllExtensions() const
- {
- UString s;
- for (int i = 0; i < Exts.Size(); i++)
- {
- if (i > 0)
- s += ' ';
- s += Exts[i].Ext;
- }
- return s;
- }
- */
-
- void AddExts(const UString &ext, const UString &addExt);
-
- bool IsSplit() const { return StringsAreEqualNoCase_Ascii(Name, "Split"); }
- // bool IsRar() const { return StringsAreEqualNoCase_Ascii(Name, "Rar"); }
-
- CArcInfoEx():
- Flags(0),
- CreateInArchive(NULL),
- IsArcFunc(NULL)
- #ifndef _SFX
- , CreateOutArchive(NULL)
- , UpdateEnabled(false)
- , NewInterface(false)
- // , Version(0)
- , SignatureOffset(0)
- #endif
- #ifdef EXTERNAL_CODECS
- , LibIndex(-1)
- #endif
- {}
-};
-
-#ifdef NEW_FOLDER_INTERFACE
-
-struct CCodecIcons
-{
- struct CIconPair
- {
- UString Ext;
- int IconIndex;
- };
- CObjectVector<CIconPair> IconPairs;
-
- void LoadIcons(HMODULE m);
- bool FindIconIndex(const UString &ext, int &iconIndex) const;
-};
-
-#endif
-
-#ifdef EXTERNAL_CODECS
-
-struct CCodecLib
- #ifdef NEW_FOLDER_INTERFACE
- : public CCodecIcons
- #endif
-{
- NWindows::NDLL::CLibrary Lib;
- FString Path;
-
- Func_CreateObject CreateObject;
- Func_GetMethodProperty GetMethodProperty;
- Func_CreateDecoder CreateDecoder;
- Func_CreateEncoder CreateEncoder;
- Func_SetCodecs SetCodecs;
-
- CMyComPtr<IHashers> ComHashers;
-
- #ifdef NEW_FOLDER_INTERFACE
- void LoadIcons() { CCodecIcons::LoadIcons((HMODULE)Lib); }
- #endif
-
- CCodecLib():
- CreateObject(NULL),
- GetMethodProperty(NULL),
- CreateDecoder(NULL),
- CreateEncoder(NULL),
- SetCodecs(NULL)
- {}
-};
-
-#endif
-
-
-class CCodecs:
- #ifdef EXTERNAL_CODECS
- public ICompressCodecsInfo,
- public IHashers,
- #else
- public IUnknown,
- #endif
- public CMyUnknownImp
-{
- CLASS_NO_COPY(CCodecs);
-public:
- #ifdef EXTERNAL_CODECS
-
- CObjectVector<CCodecLib> Libs;
- FString MainDll_ErrorPath;
-
- void CloseLibs();
-
- class CReleaser
- {
- CLASS_NO_COPY(CReleaser);
-
- /* CCodecsReleaser object releases CCodecs links.
- 1) CCodecs is COM object that is deleted when all links to that object will be released/
- 2) CCodecs::Libs[i] can hold (ICompressCodecsInfo *) link to CCodecs object itself.
- To break that reference loop, we must close all CCodecs::Libs in CCodecsReleaser desttructor. */
-
- CCodecs *_codecs;
-
- public:
- CReleaser(): _codecs(NULL) {}
- void Set(CCodecs *codecs) { _codecs = codecs; }
- ~CReleaser() { if (_codecs) _codecs->CloseLibs(); }
- };
-
- bool NeedSetLibCodecs; // = false, if we don't need to set codecs for archive handler via ISetCompressCodecsInfo
-
- HRESULT LoadCodecs();
- HRESULT LoadFormats();
- HRESULT LoadDll(const FString &path, bool needCheckDll, bool *loadedOK = NULL);
- HRESULT LoadDllsFromFolder(const FString &folderPrefix);
-
- HRESULT CreateArchiveHandler(const CArcInfoEx &ai, bool outHandler, void **archive) const
- {
- return Libs[ai.LibIndex].CreateObject(&ai.ClassID, outHandler ? &IID_IOutArchive : &IID_IInArchive, (void **)archive);
- }
-
- #endif
-
- #ifdef NEW_FOLDER_INTERFACE
- CCodecIcons InternalIcons;
- #endif
-
- CObjectVector<CArcInfoEx> Formats;
-
- #ifdef EXTERNAL_CODECS
- CRecordVector<CDllCodecInfo> Codecs;
- CRecordVector<CDllHasherInfo> Hashers;
- #endif
-
- bool CaseSensitiveChange;
- bool CaseSensitive;
-
- CCodecs():
- #ifdef EXTERNAL_CODECS
- NeedSetLibCodecs(true),
- #endif
- CaseSensitiveChange(false),
- CaseSensitive(false)
- {}
-
- ~CCodecs()
- {
- // OutputDebugStringA("~CCodecs");
- }
-
- const wchar_t *GetFormatNamePtr(int formatIndex) const
- {
- return formatIndex < 0 ? L"#" : (const wchar_t *)Formats[formatIndex].Name;
- }
-
- HRESULT Load();
-
- #ifndef _SFX
- int FindFormatForArchiveName(const UString &arcPath) const;
- int FindFormatForExtension(const UString &ext) const;
- int FindFormatForArchiveType(const UString &arcType) const;
- bool FindFormatForArchiveType(const UString &arcType, CIntVector &formatIndices) const;
- #endif
-
- #ifdef EXTERNAL_CODECS
-
- MY_UNKNOWN_IMP2(ICompressCodecsInfo, IHashers)
-
- STDMETHOD(GetNumMethods)(UInt32 *numMethods);
- STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
- STDMETHOD(CreateDecoder)(UInt32 index, const GUID *iid, void **coder);
- STDMETHOD(CreateEncoder)(UInt32 index, const GUID *iid, void **coder);
-
- STDMETHOD_(UInt32, GetNumHashers)();
- STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value);
- STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher);
-
- #else
-
- MY_UNKNOWN_IMP
-
- #endif // EXTERNAL_CODECS
-
-
- #ifdef EXTERNAL_CODECS
-
- int GetCodec_LibIndex(UInt32 index) const;
- bool GetCodec_DecoderIsAssigned(UInt32 index) const;
- bool GetCodec_EncoderIsAssigned(UInt32 index) const;
- UInt32 GetCodec_NumStreams(UInt32 index);
- HRESULT GetCodec_Id(UInt32 index, UInt64 &id);
- AString GetCodec_Name(UInt32 index);
-
- int GetHasherLibIndex(UInt32 index);
- UInt64 GetHasherId(UInt32 index);
- AString GetHasherName(UInt32 index);
- UInt32 GetHasherDigestSize(UInt32 index);
-
- #endif
-
- HRESULT CreateInArchive(unsigned formatIndex, CMyComPtr<IInArchive> &archive) const
- {
- const CArcInfoEx &ai = Formats[formatIndex];
- #ifdef EXTERNAL_CODECS
- if (ai.LibIndex < 0)
- #endif
- {
- COM_TRY_BEGIN
- archive = ai.CreateInArchive();
- return S_OK;
- COM_TRY_END
- }
- #ifdef EXTERNAL_CODECS
- return CreateArchiveHandler(ai, false, (void **)&archive);
- #endif
- }
-
- #ifndef _SFX
-
- HRESULT CreateOutArchive(unsigned formatIndex, CMyComPtr<IOutArchive> &archive) const
- {
- const CArcInfoEx &ai = Formats[formatIndex];
- #ifdef EXTERNAL_CODECS
- if (ai.LibIndex < 0)
- #endif
- {
- COM_TRY_BEGIN
- archive = ai.CreateOutArchive();
- return S_OK;
- COM_TRY_END
- }
-
- #ifdef EXTERNAL_CODECS
- return CreateArchiveHandler(ai, true, (void **)&archive);
- #endif
- }
-
- int FindOutFormatFromName(const UString &name) const
- {
- FOR_VECTOR (i, Formats)
- {
- const CArcInfoEx &arc = Formats[i];
- if (!arc.UpdateEnabled)
- continue;
- if (arc.Name.IsEqualTo_NoCase(name))
- return i;
- }
- return -1;
- }
-
- #endif // _SFX
-};
-
-#ifdef EXTERNAL_CODECS
- #define CREATE_CODECS_OBJECT \
- CCodecs *codecs = new CCodecs; \
- CExternalCodecs __externalCodecs; \
- __externalCodecs.GetCodecs = codecs; \
- __externalCodecs.GetHashers = codecs; \
- CCodecs::CReleaser codecsReleaser; \
- codecsReleaser.Set(codecs);
-#else
- #define CREATE_CODECS_OBJECT \
- CCodecs *codecs = new CCodecs; \
- CMyComPtr<IUnknown> __codecsRef = codecs;
-#endif
-
-#endif
+// LoadCodecs.h
+
+#ifndef ZIP7_INC_LOAD_CODECS_H
+#define ZIP7_INC_LOAD_CODECS_H
+
+/*
+Client application uses LoadCodecs.* to load plugins to
+CCodecs object, that contains 3 lists of plugins:
+ 1) Formats - internal and external archive handlers
+ 2) Codecs - external codecs
+ 3) Hashers - external hashers
+
+Z7_EXTERNAL_CODECS
+---------------
+
+ if Z7_EXTERNAL_CODECS is defined, then the code tries to load external
+ plugins from DLL files (shared libraries).
+
+ There are two types of executables in 7-Zip:
+
+ 1) Executable that uses external plugins must be compiled
+ with Z7_EXTERNAL_CODECS defined:
+ - 7z.exe, 7zG.exe, 7zFM.exe
+
+ Note: Z7_EXTERNAL_CODECS is used also in CPP/7zip/Common/CreateCoder.h
+ that code is used in plugin module (7z.dll).
+
+ 2) Standalone modules are compiled without Z7_EXTERNAL_CODECS:
+ - SFX modules: 7z.sfx, 7zCon.sfx
+ - standalone versions of console 7-Zip: 7za.exe, 7zr.exe
+
+ if Z7_EXTERNAL_CODECS is defined, CCodecs class implements interfaces:
+ - ICompressCodecsInfo : for Codecs
+ - IHashers : for Hashers
+
+ The client application can send CCodecs object to each plugin module.
+ And plugin module can use ICompressCodecsInfo or IHashers interface to access
+ another plugins.
+
+ There are 2 ways to send (ICompressCodecsInfo * compressCodecsInfo) to plugin
+ 1) for old versions:
+ a) request ISetCompressCodecsInfo from created archive handler.
+ b) call ISetCompressCodecsInfo::SetCompressCodecsInfo(compressCodecsInfo)
+ 2) for new versions:
+ a) request "SetCodecs" function from DLL file
+ b) call SetCodecs(compressCodecsInfo) function from DLL file
+*/
+
+#include "../../../Common/MyBuffer.h"
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyString.h"
+#include "../../../Common/ComTry.h"
+
+#ifdef Z7_EXTERNAL_CODECS
+#include "../../../Windows/DLL.h"
+#endif
+
+#include "../../ICoder.h"
+
+#include "../../Archive/IArchive.h"
+
+
+#ifdef Z7_EXTERNAL_CODECS
+
+struct CDllCodecInfo
+{
+ unsigned LibIndex;
+ UInt32 CodecIndex;
+ bool EncoderIsAssigned;
+ bool DecoderIsAssigned;
+ bool IsFilter;
+ bool IsFilter_Assigned;
+ CLSID Encoder;
+ CLSID Decoder;
+};
+
+struct CDllHasherInfo
+{
+ unsigned LibIndex;
+ UInt32 HasherIndex;
+};
+
+#endif
+
+struct CArcExtInfo
+{
+ UString Ext;
+ UString AddExt;
+
+ CArcExtInfo() {}
+ CArcExtInfo(const UString &ext): Ext(ext) {}
+ CArcExtInfo(const UString &ext, const UString &addExt): Ext(ext), AddExt(addExt) {}
+};
+
+
+struct CArcInfoEx
+{
+ UInt32 Flags;
+ UInt32 TimeFlags;
+
+ Func_CreateInArchive CreateInArchive;
+ Func_IsArc IsArcFunc;
+
+ UString Name;
+ CObjectVector<CArcExtInfo> Exts;
+
+ #ifndef Z7_SFX
+ Func_CreateOutArchive CreateOutArchive;
+ bool UpdateEnabled;
+ bool NewInterface;
+ // UInt32 Version;
+ UInt32 SignatureOffset;
+ CObjectVector<CByteBuffer> Signatures;
+ /*
+ #ifdef NEW_FOLDER_INTERFACE
+ UStringVector AssociateExts;
+ #endif
+ */
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+ int LibIndex;
+ UInt32 FormatIndex;
+ CLSID ClassID;
+ #endif
+
+ int Compare(const CArcInfoEx &a) const
+ {
+ const int res = Name.Compare(a.Name);
+ if (res != 0)
+ return res;
+ #ifdef Z7_EXTERNAL_CODECS
+ return MyCompare(LibIndex, a.LibIndex);
+ #else
+ return 0;
+ #endif
+ /*
+ if (LibIndex < a.LibIndex) return -1;
+ if (LibIndex > a.LibIndex) return 1;
+ return 0;
+ */
+ }
+
+ bool Flags_KeepName() const { return (Flags & NArcInfoFlags::kKeepName) != 0; }
+ bool Flags_FindSignature() const { return (Flags & NArcInfoFlags::kFindSignature) != 0; }
+
+ bool Flags_AltStreams() const { return (Flags & NArcInfoFlags::kAltStreams) != 0; }
+ bool Flags_NtSecurity() const { return (Flags & NArcInfoFlags::kNtSecure) != 0; }
+ bool Flags_SymLinks() const { return (Flags & NArcInfoFlags::kSymLinks) != 0; }
+ bool Flags_HardLinks() const { return (Flags & NArcInfoFlags::kHardLinks) != 0; }
+
+ bool Flags_UseGlobalOffset() const { return (Flags & NArcInfoFlags::kUseGlobalOffset) != 0; }
+ bool Flags_StartOpen() const { return (Flags & NArcInfoFlags::kStartOpen) != 0; }
+ bool Flags_BackwardOpen() const { return (Flags & NArcInfoFlags::kBackwardOpen) != 0; }
+ bool Flags_PreArc() const { return (Flags & NArcInfoFlags::kPreArc) != 0; }
+ bool Flags_PureStartOpen() const { return (Flags & NArcInfoFlags::kPureStartOpen) != 0; }
+ bool Flags_ByExtOnlyOpen() const { return (Flags & NArcInfoFlags::kByExtOnlyOpen) != 0; }
+ bool Flags_HashHandler() const { return (Flags & NArcInfoFlags::kHashHandler) != 0; }
+
+ bool Flags_CTime() const { return (Flags & NArcInfoFlags::kCTime) != 0; }
+ bool Flags_ATime() const { return (Flags & NArcInfoFlags::kATime) != 0; }
+ bool Flags_MTime() const { return (Flags & NArcInfoFlags::kMTime) != 0; }
+
+ bool Flags_CTime_Default() const { return (Flags & NArcInfoFlags::kCTime_Default) != 0; }
+ bool Flags_ATime_Default() const { return (Flags & NArcInfoFlags::kATime_Default) != 0; }
+ bool Flags_MTime_Default() const { return (Flags & NArcInfoFlags::kMTime_Default) != 0; }
+
+ UInt32 Get_TimePrecFlags() const
+ {
+ return (TimeFlags >> NArcInfoTimeFlags::kTime_Prec_Mask_bit_index) &
+ (((UInt32)1 << NArcInfoTimeFlags::kTime_Prec_Mask_num_bits) - 1);
+ }
+
+ UInt32 Get_DefaultTimePrec() const
+ {
+ return (TimeFlags >> NArcInfoTimeFlags::kTime_Prec_Default_bit_index) &
+ (((UInt32)1 << NArcInfoTimeFlags::kTime_Prec_Default_num_bits) - 1);
+ }
+
+
+ UString GetMainExt() const
+ {
+ if (Exts.IsEmpty())
+ return UString();
+ return Exts[0].Ext;
+ }
+ int FindExtension(const UString &ext) const;
+
+ bool Is_7z() const { return Name.IsEqualTo_Ascii_NoCase("7z"); }
+ bool Is_Split() const { return Name.IsEqualTo_Ascii_NoCase("Split"); }
+ bool Is_Xz() const { return Name.IsEqualTo_Ascii_NoCase("xz"); }
+ bool Is_BZip2() const { return Name.IsEqualTo_Ascii_NoCase("bzip2"); }
+ bool Is_GZip() const { return Name.IsEqualTo_Ascii_NoCase("gzip"); }
+ bool Is_Tar() const { return Name.IsEqualTo_Ascii_NoCase("tar"); }
+ bool Is_Zip() const { return Name.IsEqualTo_Ascii_NoCase("zip"); }
+ bool Is_Rar() const { return Name.IsEqualTo_Ascii_NoCase("rar"); }
+ bool Is_Zstd() const { return Name.IsEqualTo_Ascii_NoCase("zstd"); }
+
+ /*
+ UString GetAllExtensions() const
+ {
+ UString s;
+ for (int i = 0; i < Exts.Size(); i++)
+ {
+ if (i > 0)
+ s.Add_Space();
+ s += Exts[i].Ext;
+ }
+ return s;
+ }
+ */
+
+ void AddExts(const UString &ext, const UString &addExt);
+
+
+ CArcInfoEx():
+ Flags(0),
+ TimeFlags(0),
+ CreateInArchive(NULL),
+ IsArcFunc(NULL)
+ #ifndef Z7_SFX
+ , CreateOutArchive(NULL)
+ , UpdateEnabled(false)
+ , NewInterface(false)
+ // , Version(0)
+ , SignatureOffset(0)
+ #endif
+ #ifdef Z7_EXTERNAL_CODECS
+ , LibIndex(-1)
+ #endif
+ {}
+};
+
+
+#ifdef Z7_EXTERNAL_CODECS
+
+struct CCodecLib
+{
+ NWindows::NDLL::CLibrary Lib;
+ FString Path;
+
+ Func_CreateObject CreateObject;
+ Func_GetMethodProperty GetMethodProperty;
+ Func_CreateDecoder CreateDecoder;
+ Func_CreateEncoder CreateEncoder;
+ Func_SetCodecs SetCodecs;
+
+ CMyComPtr<IHashers> ComHashers;
+
+ UInt32 Version;
+
+ /*
+ #ifdef NEW_FOLDER_INTERFACE
+ CCodecIcons CodecIcons;
+ void LoadIcons() { CodecIcons.LoadIcons((HMODULE)Lib); }
+ #endif
+ */
+
+ CCodecLib():
+ CreateObject(NULL),
+ GetMethodProperty(NULL),
+ CreateDecoder(NULL),
+ CreateEncoder(NULL),
+ SetCodecs(NULL),
+ Version(0)
+ {}
+};
+
+#endif
+
+struct CCodecError
+{
+ FString Path;
+ HRESULT ErrorCode;
+ AString Message;
+ CCodecError(): ErrorCode(0) {}
+};
+
+
+struct CCodecInfoUser
+{
+ // unsigned LibIndex;
+ // UInt32 CodecIndex;
+ // UInt64 id;
+ bool EncoderIsAssigned;
+ bool DecoderIsAssigned;
+ bool IsFilter;
+ bool IsFilter_Assigned;
+ UInt32 NumStreams;
+ AString Name;
+};
+
+
+class CCodecs Z7_final:
+ #ifdef Z7_EXTERNAL_CODECS
+ public ICompressCodecsInfo,
+ public IHashers,
+ #else
+ public IUnknown,
+ #endif
+ public CMyUnknownImp
+{
+#ifdef Z7_EXTERNAL_CODECS
+ Z7_IFACES_IMP_UNK_2(ICompressCodecsInfo, IHashers)
+#else
+ Z7_COM_UNKNOWN_IMP_0
+#endif // Z7_EXTERNAL_CODECS
+
+ Z7_CLASS_NO_COPY(CCodecs)
+public:
+ #ifdef Z7_EXTERNAL_CODECS
+
+ CObjectVector<CCodecLib> Libs;
+ FString MainDll_ErrorPath;
+ CObjectVector<CCodecError> Errors;
+
+ void AddLastError(const FString &path);
+ void CloseLibs();
+
+ class CReleaser
+ {
+ Z7_CLASS_NO_COPY(CReleaser)
+
+ /* CCodecsReleaser object releases CCodecs links.
+ 1) CCodecs is COM object that is deleted when all links to that object will be released/
+ 2) CCodecs::Libs[i] can hold (ICompressCodecsInfo *) link to CCodecs object itself.
+ To break that reference loop, we must close all CCodecs::Libs in CCodecsReleaser desttructor. */
+
+ CCodecs *_codecs;
+
+ public:
+ CReleaser(): _codecs(NULL) {}
+ void Set(CCodecs *codecs) { _codecs = codecs; }
+ ~CReleaser() { if (_codecs) _codecs->CloseLibs(); }
+ };
+
+ bool NeedSetLibCodecs; // = false, if we don't need to set codecs for archive handler via ISetCompressCodecsInfo
+
+ HRESULT LoadCodecs();
+ HRESULT LoadFormats();
+ HRESULT LoadDll(const FString &path, bool needCheckDll, bool *loadedOK = NULL);
+ HRESULT LoadDllsFromFolder(const FString &folderPrefix);
+
+ HRESULT CreateArchiveHandler(const CArcInfoEx &ai, bool outHandler, void **archive) const
+ {
+ return Libs[(unsigned)ai.LibIndex].CreateObject(&ai.ClassID, outHandler ? &IID_IOutArchive : &IID_IInArchive, (void **)archive);
+ }
+
+ #endif
+
+ /*
+ #ifdef NEW_FOLDER_INTERFACE
+ CCodecIcons InternalIcons;
+ #endif
+ */
+
+ CObjectVector<CArcInfoEx> Formats;
+
+ #ifdef Z7_EXTERNAL_CODECS
+ CRecordVector<CDllCodecInfo> Codecs;
+ CRecordVector<CDllHasherInfo> Hashers;
+ #endif
+
+ bool CaseSensitive_Change;
+ bool CaseSensitive;
+
+ CCodecs():
+ #ifdef Z7_EXTERNAL_CODECS
+ NeedSetLibCodecs(true),
+ #endif
+ CaseSensitive_Change(false),
+ CaseSensitive(false)
+ {}
+
+ ~CCodecs()
+ {
+ // OutputDebugStringA("~CCodecs");
+ }
+
+ const wchar_t *GetFormatNamePtr(int formatIndex) const
+ {
+ return formatIndex < 0 ? L"#" : (const wchar_t *)Formats[(unsigned)formatIndex].Name;
+ }
+
+ HRESULT Load();
+
+ #ifndef Z7_SFX
+ int FindFormatForArchiveName(const UString &arcPath) const;
+ int FindFormatForExtension(const UString &ext) const;
+ int FindFormatForArchiveType(const UString &arcType) const;
+ bool FindFormatForArchiveType(const UString &arcType, CIntVector &formatIndices) const;
+ #endif
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ int GetCodec_LibIndex(UInt32 index) const;
+ bool GetCodec_DecoderIsAssigned(UInt32 index) const;
+ bool GetCodec_EncoderIsAssigned(UInt32 index) const;
+ bool GetCodec_IsFilter(UInt32 index, bool &isAssigned) const;
+ UInt32 GetCodec_NumStreams(UInt32 index);
+ HRESULT GetCodec_Id(UInt32 index, UInt64 &id);
+ AString GetCodec_Name(UInt32 index);
+
+ int GetHasherLibIndex(UInt32 index);
+ UInt64 GetHasherId(UInt32 index);
+ AString GetHasherName(UInt32 index);
+ UInt32 GetHasherDigestSize(UInt32 index);
+
+ void GetCodecsErrorMessage(UString &s);
+
+ #endif
+
+ HRESULT CreateInArchive(unsigned formatIndex, CMyComPtr<IInArchive> &archive) const
+ {
+ const CArcInfoEx &ai = Formats[formatIndex];
+ #ifdef Z7_EXTERNAL_CODECS
+ if (ai.LibIndex < 0)
+ #endif
+ {
+ COM_TRY_BEGIN
+ archive = ai.CreateInArchive();
+ return S_OK;
+ COM_TRY_END
+ }
+ #ifdef Z7_EXTERNAL_CODECS
+ return CreateArchiveHandler(ai, false, (void **)&archive);
+ #endif
+ }
+
+ #ifndef Z7_SFX
+
+ HRESULT CreateOutArchive(unsigned formatIndex, CMyComPtr<IOutArchive> &archive) const
+ {
+ const CArcInfoEx &ai = Formats[formatIndex];
+ #ifdef Z7_EXTERNAL_CODECS
+ if (ai.LibIndex < 0)
+ #endif
+ {
+ COM_TRY_BEGIN
+ archive = ai.CreateOutArchive();
+ return S_OK;
+ COM_TRY_END
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+ return CreateArchiveHandler(ai, true, (void **)&archive);
+ #endif
+ }
+
+ int FindOutFormatFromName(const UString &name) const
+ {
+ FOR_VECTOR (i, Formats)
+ {
+ const CArcInfoEx &arc = Formats[i];
+ if (!arc.UpdateEnabled)
+ continue;
+ if (arc.Name.IsEqualTo_NoCase(name))
+ return (int)i;
+ }
+ return -1;
+ }
+
+ void Get_CodecsInfoUser_Vector(CObjectVector<CCodecInfoUser> &v);
+
+ #endif // Z7_SFX
+};
+
+#ifdef Z7_EXTERNAL_CODECS
+ #define CREATE_CODECS_OBJECT \
+ CCodecs *codecs = new CCodecs; \
+ CExternalCodecs _externalCodecs; \
+ _externalCodecs.GetCodecs = codecs; \
+ _externalCodecs.GetHashers = codecs; \
+ CCodecs::CReleaser codecsReleaser; \
+ codecsReleaser.Set(codecs);
+#else
+ #define CREATE_CODECS_OBJECT \
+ CCodecs *codecs = new CCodecs; \
+ CMyComPtr<IUnknown> _codecsRef = codecs;
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/Common/OpenArchive.cpp b/CPP/7zip/UI/Common/OpenArchive.cpp
index d72454c..a501b86 100644
--- a/CPP/7zip/UI/Common/OpenArchive.cpp
+++ b/CPP/7zip/UI/Common/OpenArchive.cpp
@@ -1,3553 +1,3695 @@
-// OpenArchive.cpp
-
-#include "StdAfx.h"
-
-// #define SHOW_DEBUG_INFO
-
-#ifdef SHOW_DEBUG_INFO
-#include <stdio.h>
-#endif
-
-#include "../../../../C/CpuArch.h"
-
-#include "../../../Common/ComTry.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/StringToInt.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-
-#include "../../Common/FileStreams.h"
-#include "../../Common/LimitedStreams.h"
-#include "../../Common/ProgressUtils.h"
-#include "../../Common/StreamUtils.h"
-
-#include "../../Compress/CopyCoder.h"
-
-#include "DefaultName.h"
-#include "OpenArchive.h"
-
-#ifndef _SFX
-#include "SetProperties.h"
-#endif
-
-#ifdef SHOW_DEBUG_INFO
-#define PRF(x) x
-#else
-#define PRF(x)
-#endif
-
-// increase it, if you need to support larger SFX stubs
-static const UInt64 kMaxCheckStartPosition = 1 << 23;
-
-/*
-Open:
- - formatIndex >= 0 (exact Format)
- 1) Open with main type. Archive handler is allowed to use archive start finder.
- Warning, if there is tail.
-
- - formatIndex = -1 (Parser:0) (default)
- - same as #1 but doesn't return Parser
-
- - formatIndex = -2 (#1)
- - file has supported extension (like a.7z)
- Open with that main type (only starting from start of file).
- - open OK:
- - if there is no tail - return OK
- - if there is tail:
- - archive is not "Self Exe" - return OK with Warning, that there is tail
- - archive is "Self Exe"
- ignore "Self Exe" stub, and tries to open tail
- - tail can be open as archive - shows that archive and stub size property.
- - tail can't be open as archive - shows Parser ???
- - open FAIL:
- Try to open with all other types from offset 0 only.
- If some open type is OK and physical archive size is uequal or larger
- than file size, then return that archive with warning that can not be open as [extension type].
- If extension was EXE, it will try to open as unknown_extension case
- - file has unknown extension (like a.hhh)
- It tries to open via parser code.
- - if there is full archive or tail archive and unknown block or "Self Exe"
- at front, it shows tail archive and stub size property.
- - in another cases, if there is some archive inside file, it returns parser/
- - in another cases, it retuens S_FALSE
-
-
- - formatIndex = -3 (#2)
- - same as #1, but
- - stub (EXE) + archive is open in Parser
-
- - formatIndex = -4 (#3)
- - returns only Parser. skip full file archive. And show other sub-archives
-
- - formatIndex = -5 (#4)
- - returns only Parser. skip full file archive. And show other sub-archives for each byte pos
-
-*/
-
-
-
-
-using namespace NWindows;
-
-/*
-#ifdef _SFX
-#define OPEN_PROPS_PARAM
-#else
-#define OPEN_PROPS_PARAM , props
-#endif
-*/
-
-/*
-CArc::~CArc()
-{
- GetRawProps.Release();
- Archive.Release();
- printf("\nCArc::~CArc()\n");
-}
-*/
-
-#ifndef _SFX
-
-namespace NArchive {
-namespace NParser {
-
-struct CParseItem
-{
- UInt64 Offset;
- UInt64 Size;
- // UInt64 OkSize;
- UString Name;
- UString Extension;
- FILETIME FileTime;
- UString Comment;
- UString ArcType;
-
- bool FileTime_Defined;
- bool UnpackSize_Defined;
- bool NumSubDirs_Defined;
- bool NumSubFiles_Defined;
-
- bool IsSelfExe;
- bool IsNotArcType;
-
- UInt64 UnpackSize;
- UInt64 NumSubDirs;
- UInt64 NumSubFiles;
-
- int FormatIndex;
-
- bool LenIsUnknown;
-
- CParseItem():
- LenIsUnknown(false),
- FileTime_Defined(false),
- UnpackSize_Defined(false),
- NumSubFiles_Defined(false),
- NumSubDirs_Defined(false),
- IsSelfExe(false),
- IsNotArcType(false)
- // OkSize(0)
- {}
-
- /*
- bool IsEqualTo(const CParseItem &item) const
- {
- return Offset == item.Offset && Size == item.Size;
- }
- */
-
- void NormalizeOffset()
- {
- if ((Int64)Offset < 0)
- {
- Size += Offset;
- // OkSize += Offset;
- Offset = 0;
- }
- }
-};
-
-class CHandler:
- public IInArchive,
- public IInArchiveGetStream,
- public CMyUnknownImp
-{
-public:
- CObjectVector<CParseItem> _items;
- UInt64 _maxEndOffset;
- CMyComPtr<IInStream> _stream;
-
- MY_UNKNOWN_IMP2(
- IInArchive,
- IInArchiveGetStream)
-
- INTERFACE_IInArchive(;)
- STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
-
- UInt64 GetLastEnd() const
- {
- if (_items.IsEmpty())
- return 0;
- const CParseItem &back = _items.Back();
- return back.Offset + back.Size;
- }
-
- void AddUnknownItem(UInt64 next);
- int FindInsertPos(const CParseItem &item) const;
- void AddItem(const CParseItem &item);
-
- CHandler(): _maxEndOffset(0) {}
-};
-
-int CHandler::FindInsertPos(const CParseItem &item) const
-{
- unsigned left = 0, right = _items.Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const CParseItem & midItem = _items[mid];
- if (item.Offset < midItem.Offset)
- right = mid;
- else if (item.Offset > midItem.Offset)
- left = mid + 1;
- else if (item.Size < midItem.Size)
- right = mid;
- else if (item.Size > midItem.Size)
- left = mid + 1;
- else
- {
- left = mid + 1;
- // return -1;
- }
- }
- return left;
-}
-
-void CHandler::AddUnknownItem(UInt64 next)
-{
- /*
- UInt64 prevEnd = 0;
- if (!_items.IsEmpty())
- {
- const CParseItem &back = _items.Back();
- prevEnd = back.Offset + back.Size;
- }
- */
- if (_maxEndOffset < next)
- {
- CParseItem item2;
- item2.Offset = _maxEndOffset;
- item2.Size = next - _maxEndOffset;
- _maxEndOffset = next;
- _items.Add(item2);
- }
- else if (_maxEndOffset > next && !_items.IsEmpty())
- {
- CParseItem &back = _items.Back();
- if (back.LenIsUnknown)
- {
- back.Size = next - back.Offset;
- _maxEndOffset = next;
- }
- }
-}
-
-void CHandler::AddItem(const CParseItem &item)
-{
- AddUnknownItem(item.Offset);
- int pos = FindInsertPos(item);
- if (pos >= 0)
- {
- _items.Insert(pos, item);
- UInt64 next = item.Offset + item.Size;
- if (_maxEndOffset < next)
- _maxEndOffset = next;
- }
-}
-
-/*
-static const CStatProp kProps[] =
-{
- { NULL, kpidPath, VT_BSTR},
- { NULL, kpidSize, VT_UI8},
- { NULL, kpidMTime, VT_FILETIME},
- { NULL, kpidType, VT_BSTR},
- { NULL, kpidComment, VT_BSTR},
- { NULL, kpidOffset, VT_UI8},
- { NULL, kpidUnpackSize, VT_UI8},
-// { NULL, kpidNumSubDirs, VT_UI8},
-};
-*/
-
-static const Byte kProps[] =
-{
- kpidPath,
- kpidSize,
- kpidMTime,
- kpidType,
- kpidComment,
- kpidOffset,
- kpidUnpackSize
-};
-
-IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO
-
-STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* openArchiveCallback */)
-{
- COM_TRY_BEGIN
- {
- Close();
- _stream = stream;
- }
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CHandler::Close()
-{
- _items.Clear();
- _stream.Release();
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
-{
- *numItems = _items.Size();
- return S_OK;
-}
-
-STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- COM_TRY_BEGIN
- NCOM::CPropVariant prop;
-
- const CParseItem &item = _items[index];
-
- switch (propID)
- {
- case kpidPath:
- {
- char sz[32];
- ConvertUInt32ToString(index + 1, sz);
- UString s(sz);
- if (!item.Name.IsEmpty())
- {
- s += '.';
- s += item.Name;
- }
- if (!item.Extension.IsEmpty())
- {
- s += '.';
- s += item.Extension;
- }
- prop = s; break;
- }
- case kpidSize:
- case kpidPackSize: prop = item.Size; break;
- case kpidOffset: prop = item.Offset; break;
- case kpidUnpackSize: if (item.UnpackSize_Defined) prop = item.UnpackSize; break;
- case kpidNumSubFiles: if (item.NumSubFiles_Defined) prop = item.NumSubFiles; break;
- case kpidNumSubDirs: if (item.NumSubDirs_Defined) prop = item.NumSubDirs; break;
- case kpidMTime: if (item.FileTime_Defined) prop = item.FileTime; break;
- case kpidComment: if (!item.Comment.IsEmpty()) prop = item.Comment; break;
- case kpidType: if (!item.ArcType.IsEmpty()) prop = item.ArcType; break;
- }
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
-}
-
-HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,
- Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
- COM_TRY_BEGIN
-
- bool allFilesMode = (numItems == (UInt32)(Int32)-1);
- if (allFilesMode)
- numItems = _items.Size();
- if (_stream && numItems == 0)
- return S_OK;
- UInt64 totalSize = 0;
- UInt32 i;
- for (i = 0; i < numItems; i++)
- totalSize += _items[allFilesMode ? i : indices[i]].Size;
- extractCallback->SetTotal(totalSize);
-
- totalSize = 0;
-
- CLocalProgress *lps = new CLocalProgress;
- CMyComPtr<ICompressProgressInfo> progress = lps;
- lps->Init(extractCallback, false);
-
- CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
- CMyComPtr<ISequentialInStream> inStream(streamSpec);
- streamSpec->SetStream(_stream);
-
- CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
- CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
-
- NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
- CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-
- for (i = 0; i < numItems; i++)
- {
- lps->InSize = totalSize;
- lps->OutSize = totalSize;
- RINOK(lps->SetCur());
- CMyComPtr<ISequentialOutStream> realOutStream;
- Int32 askMode = testMode ?
- NExtract::NAskMode::kTest :
- NExtract::NAskMode::kExtract;
- Int32 index = allFilesMode ? i : indices[i];
- const CParseItem &item = _items[index];
-
- RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
- UInt64 unpackSize = item.Size;
- totalSize += unpackSize;
- bool skipMode = false;
- if (!testMode && !realOutStream)
- continue;
- RINOK(extractCallback->PrepareOperation(askMode));
-
- outStreamSpec->SetStream(realOutStream);
- realOutStream.Release();
- outStreamSpec->Init(skipMode ? 0 : unpackSize, true);
-
- Int32 opRes = NExtract::NOperationResult::kOK;
- RINOK(_stream->Seek(item.Offset, STREAM_SEEK_SET, NULL));
- streamSpec->Init(unpackSize);
- RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
-
- if (outStreamSpec->GetRem() != 0)
- opRes = NExtract::NOperationResult::kDataError;
- outStreamSpec->ReleaseStream();
- RINOK(extractCallback->SetOperationResult(opRes));
- }
-
- return S_OK;
-
- COM_TRY_END
-}
-
-
-STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
-{
- COM_TRY_BEGIN
- const CParseItem &item = _items[index];
- return CreateLimitedInStream(_stream, item.Offset, item.Size, stream);
- COM_TRY_END
-}
-
-}}
-
-#endif
-
-HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bool &result) throw()
-{
- NCOM::CPropVariant prop;
- result = false;
- RINOK(arc->GetProperty(index, propID, &prop));
- if (prop.vt == VT_BOOL)
- result = VARIANT_BOOLToBool(prop.boolVal);
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-HRESULT Archive_IsItem_Dir(IInArchive *arc, UInt32 index, bool &result) throw()
-{
- return Archive_GetItemBoolProp(arc, index, kpidIsDir, result);
-}
-
-HRESULT Archive_IsItem_Aux(IInArchive *arc, UInt32 index, bool &result) throw()
-{
- return Archive_GetItemBoolProp(arc, index, kpidIsAux, result);
-}
-
-HRESULT Archive_IsItem_AltStream(IInArchive *arc, UInt32 index, bool &result) throw()
-{
- return Archive_GetItemBoolProp(arc, index, kpidIsAltStream, result);
-}
-
-HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &result) throw()
-{
- return Archive_GetItemBoolProp(arc, index, kpidIsDeleted, result);
-}
-
-static HRESULT Archive_GetArcBoolProp(IInArchive *arc, PROPID propid, bool &result) throw()
-{
- NCOM::CPropVariant prop;
- result = false;
- RINOK(arc->GetArchiveProperty(propid, &prop));
- if (prop.vt == VT_BOOL)
- result = VARIANT_BOOLToBool(prop.boolVal);
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-static HRESULT Archive_GetArcProp_UInt(IInArchive *arc, PROPID propid, UInt64 &result, bool &defined)
-{
- defined = false;
- NCOM::CPropVariant prop;
- RINOK(arc->GetArchiveProperty(propid, &prop));
- switch (prop.vt)
- {
- case VT_UI4: result = prop.ulVal; defined = true; break;
- case VT_I4: result = (Int64)prop.lVal; defined = true; break;
- case VT_UI8: result = (UInt64)prop.uhVal.QuadPart; defined = true; break;
- case VT_I8: result = (UInt64)prop.hVal.QuadPart; defined = true; break;
- case VT_EMPTY: break;
- default: return E_FAIL;
- }
- return S_OK;
-}
-
-static HRESULT Archive_GetArcProp_Int(IInArchive *arc, PROPID propid, Int64 &result, bool &defined)
-{
- defined = false;
- NCOM::CPropVariant prop;
- RINOK(arc->GetArchiveProperty(propid, &prop));
- switch (prop.vt)
- {
- case VT_UI4: result = prop.ulVal; defined = true; break;
- case VT_I4: result = prop.lVal; defined = true; break;
- case VT_UI8: result = (Int64)prop.uhVal.QuadPart; defined = true; break;
- case VT_I8: result = (Int64)prop.hVal.QuadPart; defined = true; break;
- case VT_EMPTY: break;
- default: return E_FAIL;
- }
- return S_OK;
-}
-
-#ifndef _SFX
-
-HRESULT CArc::GetItemPathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const
-{
- if (!GetRawProps)
- return E_FAIL;
- if (index == parent)
- return S_OK;
- UInt32 curIndex = index;
-
- UString s;
-
- bool prevWasAltStream = false;
-
- for (;;)
- {
- #ifdef MY_CPU_LE
- const void *p;
- UInt32 size;
- UInt32 propType;
- RINOK(GetRawProps->GetRawProp(curIndex, kpidName, &p, &size, &propType));
- if (p && propType == PROP_DATA_TYPE_wchar_t_PTR_Z_LE)
- s = (const wchar_t *)p;
- else
- #endif
- {
- NCOM::CPropVariant prop;
- RINOK(Archive->GetProperty(curIndex, kpidName, &prop));
- if (prop.vt == VT_BSTR && prop.bstrVal)
- s.SetFromBstr(prop.bstrVal);
- else if (prop.vt == VT_EMPTY)
- s.Empty();
- else
- return E_FAIL;
- }
-
- UInt32 curParent = (UInt32)(Int32)-1;
- UInt32 parentType = 0;
- RINOK(GetRawProps->GetParent(curIndex, &curParent, &parentType));
-
- // 18.06: fixed : we don't want to split name to parts
- /*
- if (parentType != NParentType::kAltStream)
- {
- for (;;)
- {
- int pos = s.ReverseFind_PathSepar();
- if (pos < 0)
- {
- break;
- }
- parts.Insert(0, s.Ptr(pos + 1));
- s.DeleteFrom(pos);
- }
- }
- */
-
- parts.Insert(0, s);
-
- if (prevWasAltStream)
- {
- {
- UString &s2 = parts[parts.Size() - 2];
- s2 += ':';
- s2 += parts.Back();
- }
- parts.DeleteBack();
- }
-
- if (parent == curParent)
- return S_OK;
-
- prevWasAltStream = false;
- if (parentType == NParentType::kAltStream)
- prevWasAltStream = true;
-
- if (curParent == (UInt32)(Int32)-1)
- return E_FAIL;
- curIndex = curParent;
- }
-}
-
-#endif
-
-HRESULT CArc::GetItemPath(UInt32 index, UString &result) const
-{
- #ifdef MY_CPU_LE
- if (GetRawProps)
- {
- const void *p;
- UInt32 size;
- UInt32 propType;
- if (!IsTree)
- {
- if (GetRawProps->GetRawProp(index, kpidPath, &p, &size, &propType) == S_OK &&
- propType == NPropDataType::kUtf16z)
- {
- unsigned len = size / 2 - 1;
- wchar_t *s = result.GetBuf(len);
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = GetUi16(p);
- p = (const void *)((const Byte *)p + 2);
- #if WCHAR_PATH_SEPARATOR != L'/'
- if (c == L'/')
- c = WCHAR_PATH_SEPARATOR;
- #endif
- *s++ = c;
- }
- *s = 0;
- result.ReleaseBuf_SetLen(len);
- if (len != 0)
- return S_OK;
- }
- }
- /*
- else if (GetRawProps->GetRawProp(index, kpidName, &p, &size, &propType) == S_OK &&
- p && propType == NPropDataType::kUtf16z)
- {
- size -= 2;
- UInt32 totalSize = size;
- bool isOK = false;
-
- {
- UInt32 index2 = index;
- for (;;)
- {
- UInt32 parent = (UInt32)(Int32)-1;
- UInt32 parentType = 0;
- if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
- break;
- if (parent == (UInt32)(Int32)-1)
- {
- if (parentType != 0)
- totalSize += 2;
- isOK = true;
- break;
- }
- index2 = parent;
- UInt32 size2;
- const void *p2;
- if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK &&
- p2 && propType == NPropDataType::kUtf16z)
- break;
- totalSize += size2;
- }
- }
-
- if (isOK)
- {
- wchar_t *sz = result.GetBuf_SetEnd(totalSize / 2);
- UInt32 pos = totalSize - size;
- memcpy((Byte *)sz + pos, p, size);
- UInt32 index2 = index;
- for (;;)
- {
- UInt32 parent = (UInt32)(Int32)-1;
- UInt32 parentType = 0;
- if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
- break;
- if (parent == (UInt32)(Int32)-1)
- {
- if (parentType != 0)
- sz[pos / 2 - 1] = L':';
- break;
- }
- index2 = parent;
- UInt32 size2;
- const void *p2;
- if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK)
- break;
- pos -= size2;
- memcpy((Byte *)sz + pos, p2, size2);
- sz[(pos + size2 - 2) / 2] = (parentType == 0) ? WCHAR_PATH_SEPARATOR : L':';
- }
- #ifdef _WIN32
- // result.Replace(L'/', WCHAR_PATH_SEPARATOR);
- #endif
- return S_OK;
- }
- }
- */
- }
- #endif
-
- {
- NCOM::CPropVariant prop;
- RINOK(Archive->GetProperty(index, kpidPath, &prop));
- if (prop.vt == VT_BSTR && prop.bstrVal)
- result.SetFromBstr(prop.bstrVal);
- else if (prop.vt == VT_EMPTY)
- result.Empty();
- else
- return E_FAIL;
- }
-
- if (result.IsEmpty())
- return GetDefaultItemPath(index, result);
- return S_OK;
-}
-
-HRESULT CArc::GetDefaultItemPath(UInt32 index, UString &result) const
-{
- result.Empty();
- bool isDir;
- RINOK(Archive_IsItem_Dir(Archive, index, isDir));
- if (!isDir)
- {
- result = DefaultName;
- NCOM::CPropVariant prop;
- RINOK(Archive->GetProperty(index, kpidExtension, &prop));
- if (prop.vt == VT_BSTR)
- {
- result += '.';
- result += prop.bstrVal;
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- }
- return S_OK;
-}
-
-HRESULT CArc::GetItemPath2(UInt32 index, UString &result) const
-{
- RINOK(GetItemPath(index, result));
- if (Ask_Deleted)
- {
- bool isDeleted = false;
- RINOK(Archive_IsItem_Deleted(Archive, index, isDeleted));
- if (isDeleted)
- result.Insert(0, L"[DELETED]" WSTRING_PATH_SEPARATOR);
- }
- return S_OK;
-}
-
-#ifdef SUPPORT_ALT_STREAMS
-
-int FindAltStreamColon_in_Path(const wchar_t *path)
-{
- unsigned i = 0;
- int colonPos = -1;
- for (;; i++)
- {
- wchar_t c = path[i];
- if (c == 0)
- return colonPos;
- if (c == ':')
- {
- if (colonPos < 0)
- colonPos = i;
- continue;
- }
- if (c == WCHAR_PATH_SEPARATOR)
- colonPos = -1;
- }
-}
-
-#endif
-
-HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
-{
- #ifdef SUPPORT_ALT_STREAMS
- item.IsAltStream = false;
- item.AltStreamName.Empty();
- item.MainPath.Empty();
- #endif
-
- item.IsDir = false;
- item.Path.Empty();
- item.ParentIndex = (UInt32)(Int32)-1;
-
- item.PathParts.Clear();
-
- RINOK(Archive_IsItem_Dir(Archive, index, item.IsDir));
- item.MainIsDir = item.IsDir;
-
- RINOK(GetItemPath2(index, item.Path));
-
- #ifndef _SFX
- UInt32 mainIndex = index;
- #endif
-
- #ifdef SUPPORT_ALT_STREAMS
-
- item.MainPath = item.Path;
- if (Ask_AltStream)
- {
- RINOK(Archive_IsItem_AltStream(Archive, index, item.IsAltStream));
- }
-
- bool needFindAltStream = false;
-
- if (item.IsAltStream)
- {
- needFindAltStream = true;
- if (GetRawProps)
- {
- UInt32 parentType = 0;
- UInt32 parentIndex;
- RINOK(GetRawProps->GetParent(index, &parentIndex, &parentType));
- if (parentType == NParentType::kAltStream)
- {
- NCOM::CPropVariant prop;
- RINOK(Archive->GetProperty(index, kpidName, &prop));
- if (prop.vt == VT_BSTR && prop.bstrVal)
- item.AltStreamName.SetFromBstr(prop.bstrVal);
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- else
- {
- // item.IsAltStream = false;
- }
- /*
- if (item.AltStreamName.IsEmpty())
- item.IsAltStream = false;
- */
-
- needFindAltStream = false;
- item.ParentIndex = parentIndex;
- mainIndex = parentIndex;
-
- if (parentIndex == (UInt32)(Int32)-1)
- {
- item.MainPath.Empty();
- item.MainIsDir = true;
- }
- else
- {
- RINOK(GetItemPath2(parentIndex, item.MainPath));
- RINOK(Archive_IsItem_Dir(Archive, parentIndex, item.MainIsDir));
- }
- }
- }
- }
-
- if (item.WriteToAltStreamIfColon || needFindAltStream)
- {
- /* Good handler must support GetRawProps::GetParent for alt streams.
- So the following code currently is not used */
- int colon = FindAltStreamColon_in_Path(item.Path);
- if (colon >= 0)
- {
- item.MainPath.DeleteFrom(colon);
- item.AltStreamName = item.Path.Ptr(colon + 1);
- item.MainIsDir = (colon == 0 || IsPathSepar(item.Path[(unsigned)colon - 1]));
- item.IsAltStream = true;
- }
- }
-
- #endif
-
- #ifndef _SFX
- if (item._use_baseParentFolder_mode)
- {
- RINOK(GetItemPathToParent(mainIndex, item._baseParentFolder, item.PathParts));
-
- #ifdef SUPPORT_ALT_STREAMS
- if ((item.WriteToAltStreamIfColon || needFindAltStream) && !item.PathParts.IsEmpty())
- {
- int colon;
- {
- UString &s = item.PathParts.Back();
- colon = FindAltStreamColon_in_Path(s);
- if (colon >= 0)
- {
- item.AltStreamName = s.Ptr(colon + 1);
- item.MainIsDir = (colon == 0 || IsPathSepar(s[(unsigned)colon - 1]));
- item.IsAltStream = true;
- s.DeleteFrom(colon);
- }
- }
- if (colon == 0)
- item.PathParts.DeleteBack();
- }
- #endif
-
- }
- else
- #endif
- SplitPathToParts(
- #ifdef SUPPORT_ALT_STREAMS
- item.MainPath
- #else
- item.Path
- #endif
- , item.PathParts);
-
- return S_OK;
-}
-
-#ifndef _SFX
-
-static HRESULT Archive_GetItem_Size(IInArchive *archive, UInt32 index, UInt64 &size, bool &defined)
-{
- NCOM::CPropVariant prop;
- defined = false;
- size = 0;
- RINOK(archive->GetProperty(index, kpidSize, &prop));
- switch (prop.vt)
- {
- case VT_UI1: size = prop.bVal; break;
- case VT_UI2: size = prop.uiVal; break;
- case VT_UI4: size = prop.ulVal; break;
- case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
- case VT_EMPTY: return S_OK;
- default: return E_FAIL;
- }
- defined = true;
- return S_OK;
-}
-
-#endif
-
-HRESULT CArc::GetItemSize(UInt32 index, UInt64 &size, bool &defined) const
-{
- NCOM::CPropVariant prop;
- defined = false;
- size = 0;
- RINOK(Archive->GetProperty(index, kpidSize, &prop));
- switch (prop.vt)
- {
- case VT_UI1: size = prop.bVal; break;
- case VT_UI2: size = prop.uiVal; break;
- case VT_UI4: size = prop.ulVal; break;
- case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
- case VT_EMPTY: return S_OK;
- default: return E_FAIL;
- }
- defined = true;
- return S_OK;
-}
-
-HRESULT CArc::GetItemMTime(UInt32 index, FILETIME &ft, bool &defined) const
-{
- NCOM::CPropVariant prop;
- defined = false;
- ft.dwHighDateTime = ft.dwLowDateTime = 0;
- RINOK(Archive->GetProperty(index, kpidMTime, &prop));
- if (prop.vt == VT_FILETIME)
- {
- ft = prop.filetime;
- defined = true;
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- else if (MTimeDefined)
- {
- ft = MTime;
- defined = true;
- }
- return S_OK;
-}
-
-#ifndef _SFX
-
-static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
-{
- for (size_t i = 0; i < size; i++)
- if (p1[i] != p2[i])
- return false;
- return true;
-}
-
-static void MakeCheckOrder(CCodecs *codecs,
- CIntVector &orderIndices, unsigned numTypes, CIntVector &orderIndices2,
- const Byte *data, size_t dataSize)
-{
- for (unsigned i = 0; i < numTypes; i++)
- {
- int index = orderIndices[i];
- if (index < 0)
- continue;
- const CArcInfoEx &ai = codecs->Formats[(unsigned)index];
- if (ai.SignatureOffset != 0)
- {
- orderIndices2.Add(index);
- orderIndices[i] = -1;
- continue;
- }
-
- const CObjectVector<CByteBuffer> &sigs = ai.Signatures;
- FOR_VECTOR (k, sigs)
- {
- const CByteBuffer &sig = sigs[k];
- if (sig.Size() == 0 && dataSize == 0 ||
- sig.Size() != 0 && sig.Size() <= dataSize &&
- TestSignature(data, sig, sig.Size()))
- {
- orderIndices2.Add(index);
- orderIndices[i] = -1;
- break;
- }
- }
- }
-}
-
-#endif
-
-#ifdef UNDER_CE
- static const unsigned kNumHashBytes = 1;
- #define HASH_VAL(buf) ((buf)[0])
-#else
- static const unsigned kNumHashBytes = 2;
- // #define HASH_VAL(buf) ((buf)[0] | ((UInt32)(buf)[1] << 8))
- #define HASH_VAL(buf) GetUi16(buf)
-#endif
-
-
-#ifndef _SFX
-
-static bool IsExeExt(const UString &ext)
-{
- return ext.IsEqualTo_Ascii_NoCase("exe");
-}
-
-static const char * const k_PreArcFormats[] =
-{
- "pe"
- , "elf"
- , "macho"
- , "mub"
- , "te"
-};
-
-static bool IsNameFromList(const UString &s, const char * const names[], size_t num)
-{
- for (unsigned i = 0; i < num; i++)
- if (StringsAreEqualNoCase_Ascii(s, names[i]))
- return true;
- return false;
-}
-
-
-static bool IsPreArcFormat(const CArcInfoEx &ai)
-{
- if (ai.Flags_PreArc())
- return true;
- return IsNameFromList(ai.Name, k_PreArcFormats, ARRAY_SIZE(k_PreArcFormats));
-}
-
-static const char * const k_Formats_with_simple_signuature[] =
-{
- "7z"
- , "xz"
- , "rar"
- , "bzip2"
- , "gzip"
- , "cab"
- , "wim"
- , "rpm"
- , "vhd"
- , "xar"
-};
-
-static bool IsNewStyleSignature(const CArcInfoEx &ai)
-{
- // if (ai.Version >= 0x91F)
- if (ai.NewInterface)
- return true;
- return IsNameFromList(ai.Name, k_Formats_with_simple_signuature, ARRAY_SIZE(k_Formats_with_simple_signuature));
-}
-
-class CArchiveOpenCallback_Offset:
- public IArchiveOpenCallback,
- public IArchiveOpenVolumeCallback,
- #ifndef _NO_CRYPTO
- public ICryptoGetTextPassword,
- #endif
- public CMyUnknownImp
-{
-public:
- CMyComPtr<IArchiveOpenCallback> Callback;
- CMyComPtr<IArchiveOpenVolumeCallback> OpenVolumeCallback;
- UInt64 Files;
- UInt64 Offset;
-
- #ifndef _NO_CRYPTO
- CMyComPtr<ICryptoGetTextPassword> GetTextPassword;
- #endif
-
- MY_QUERYINTERFACE_BEGIN2(IArchiveOpenCallback)
- MY_QUERYINTERFACE_ENTRY(IArchiveOpenVolumeCallback)
- #ifndef _NO_CRYPTO
- MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- INTERFACE_IArchiveOpenCallback(;)
- INTERFACE_IArchiveOpenVolumeCallback(;)
- #ifndef _NO_CRYPTO
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
- #endif
-};
-
-#ifndef _NO_CRYPTO
-STDMETHODIMP CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password)
-{
- COM_TRY_BEGIN
- if (GetTextPassword)
- return GetTextPassword->CryptoGetTextPassword(password);
- return E_NOTIMPL;
- COM_TRY_END
-}
-#endif
-
-STDMETHODIMP CArchiveOpenCallback_Offset::SetTotal(const UInt64 *, const UInt64 *)
-{
- return S_OK;
-}
-
-STDMETHODIMP CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UInt64 *bytes)
-{
- if (!Callback)
- return S_OK;
- UInt64 value = Offset;
- if (bytes)
- value += *bytes;
- return Callback->SetCompleted(&Files, &value);
-}
-
-STDMETHODIMP CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT *value)
-{
- if (OpenVolumeCallback)
- return OpenVolumeCallback->GetProperty(propID, value);
- NCOM::PropVariant_Clear(value);
- return S_OK;
- // return E_NOTIMPL;
-}
-
-STDMETHODIMP CArchiveOpenCallback_Offset::GetStream(const wchar_t *name, IInStream **inStream)
-{
- if (OpenVolumeCallback)
- return OpenVolumeCallback->GetStream(name, inStream);
- return S_FALSE;
-}
-
-#endif
-
-
-UInt32 GetOpenArcErrorFlags(const NCOM::CPropVariant &prop, bool *isDefinedProp)
-{
- if (isDefinedProp != NULL)
- *isDefinedProp = false;
-
- switch (prop.vt)
- {
- case VT_UI8: if (isDefinedProp) *isDefinedProp = true; return (UInt32)prop.uhVal.QuadPart;
- case VT_UI4: if (isDefinedProp) *isDefinedProp = true; return prop.ulVal;
- case VT_EMPTY: return 0;
- default: throw 151199;
- }
-}
-
-void CArcErrorInfo::ClearErrors()
-{
- // ErrorFormatIndex = -1; // we don't need to clear ErrorFormatIndex here !!!
-
- ThereIsTail = false;
- UnexpecedEnd = false;
- IgnoreTail = false;
- // NonZerosTail = false;
- ErrorFlags_Defined = false;
- ErrorFlags = 0;
- WarningFlags = 0;
- TailSize = 0;
-
- ErrorMessage.Empty();
- WarningMessage.Empty();
-}
-
-HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes)
-{
- // OkPhySize_Defined = false;
- PhySizeDefined = false;
- PhySize = 0;
- Offset = 0;
- AvailPhySize = FileSize - startPos;
-
- ErrorInfo.ClearErrors();
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidErrorFlags, &prop));
- ErrorInfo.ErrorFlags = GetOpenArcErrorFlags(prop, &ErrorInfo.ErrorFlags_Defined);
- }
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidWarningFlags, &prop));
- ErrorInfo.WarningFlags = GetOpenArcErrorFlags(prop);
- }
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidError, &prop));
- if (prop.vt != VT_EMPTY)
- ErrorInfo.ErrorMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown error");
- }
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidWarning, &prop));
- if (prop.vt != VT_EMPTY)
- ErrorInfo.WarningMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown warning");
- }
-
- if (openRes == S_OK || ErrorInfo.IsArc_After_NonOpen())
- {
- RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, PhySize, PhySizeDefined));
- /*
- RINOK(Archive_GetArcProp_UInt(archive, kpidOkPhySize, OkPhySize, OkPhySize_Defined));
- if (!OkPhySize_Defined)
- {
- OkPhySize_Defined = PhySizeDefined;
- OkPhySize = PhySize;
- }
- */
-
- bool offsetDefined;
- RINOK(Archive_GetArcProp_Int(archive, kpidOffset, Offset, offsetDefined));
-
- Int64 globalOffset = startPos + Offset;
- AvailPhySize = FileSize - globalOffset;
- if (PhySizeDefined)
- {
- UInt64 endPos = globalOffset + PhySize;
- if (endPos < FileSize)
- {
- AvailPhySize = PhySize;
- ErrorInfo.ThereIsTail = true;
- ErrorInfo.TailSize = FileSize - endPos;
- }
- else if (endPos > FileSize)
- ErrorInfo.UnexpecedEnd = true;
- }
- }
-
- return S_OK;
-}
-
-/*
-static PrintNumber(const char *s, int n)
-{
- char temp[100];
- sprintf(temp, "%s %d", s, n);
- OutputDebugStringA(temp);
-}
-*/
-
-HRESULT CArc::PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyComPtr<IInArchive> &archive)
-{
- // OutputDebugStringA("a1");
- // PrintNumber("formatIndex", formatIndex);
-
- RINOK(op.codecs->CreateInArchive(formatIndex, archive));
- // OutputDebugStringA("a2");
- if (!archive)
- return S_OK;
-
- #ifdef EXTERNAL_CODECS
- if (op.codecs->NeedSetLibCodecs)
- {
- const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
- if (ai.LibIndex >= 0 ?
- !op.codecs->Libs[ai.LibIndex].SetCodecs :
- !op.codecs->Libs.IsEmpty())
- {
- CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
- archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
- if (setCompressCodecsInfo)
- {
- RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(op.codecs));
- }
- }
- }
- #endif
-
-
- #ifndef _SFX
-
- const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
-
- // OutputDebugStringW(ai.Name);
- // OutputDebugStringA("a3");
-
- if (ai.Flags_PreArc())
- {
- /* we notify parsers that extract executables, that they don't need
- to open archive, if there is tail after executable (for SFX cases) */
- CMyComPtr<IArchiveAllowTail> allowTail;
- archive.QueryInterface(IID_IArchiveAllowTail, (void **)&allowTail);
- if (allowTail)
- allowTail->AllowTail(BoolToInt(true));
- }
-
- if (op.props)
- {
- /*
- FOR_VECTOR (y, op.props)
- {
- const COptionalOpenProperties &optProps = (*op.props)[y];
- if (optProps.FormatName.IsEmpty() || optProps.FormatName.CompareNoCase(ai.Name) == 0)
- {
- RINOK(SetProperties(archive, optProps.Props));
- break;
- }
- }
- */
- RINOK(SetProperties(archive, *op.props));
- }
-
- #endif
- return S_OK;
-}
-
-#ifndef _SFX
-
-static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NArchive::NParser::CParseItem &pi)
-{
- pi.Extension = ai.GetMainExt();
- pi.FileTime_Defined = false;
- pi.ArcType = ai.Name;
-
- RINOK(Archive_GetArcBoolProp(archive, kpidIsNotArcType, pi.IsNotArcType));
-
- // RINOK(Archive_GetArcBoolProp(archive, kpidIsSelfExe, pi.IsSelfExe));
- pi.IsSelfExe = ai.Flags_PreArc();
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidMTime, &prop));
- if (prop.vt == VT_FILETIME)
- {
- pi.FileTime_Defined = true;
- pi.FileTime = prop.filetime;
- }
- }
-
- if (!pi.FileTime_Defined)
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidCTime, &prop));
- if (prop.vt == VT_FILETIME)
- {
- pi.FileTime_Defined = true;
- pi.FileTime = prop.filetime;
- }
- }
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidName, &prop));
- if (prop.vt == VT_BSTR)
- {
- pi.Name.SetFromBstr(prop.bstrVal);
- pi.Extension.Empty();
- }
- else
- {
- RINOK(archive->GetArchiveProperty(kpidExtension, &prop));
- if (prop.vt == VT_BSTR)
- pi.Extension.SetFromBstr(prop.bstrVal);
- }
- }
-
- {
- NCOM::CPropVariant prop;
- RINOK(archive->GetArchiveProperty(kpidShortComment, &prop));
- if (prop.vt == VT_BSTR)
- pi.Comment.SetFromBstr(prop.bstrVal);
- }
-
-
- UInt32 numItems;
- RINOK(archive->GetNumberOfItems(&numItems));
-
- // pi.NumSubFiles = numItems;
- // RINOK(Archive_GetArcProp_UInt(archive, kpidUnpackSize, pi.UnpackSize, pi.UnpackSize_Defined));
- // if (!pi.UnpackSize_Defined)
- {
- pi.NumSubFiles = 0;
- pi.NumSubDirs = 0;
- pi.UnpackSize = 0;
- for (UInt32 i = 0; i < numItems; i++)
- {
- UInt64 size = 0;
- bool defined = false;
- Archive_GetItem_Size(archive, i, size, defined);
- if (defined)
- {
- pi.UnpackSize_Defined = true;
- pi.UnpackSize += size;
- }
-
- bool isDir = false;
- Archive_IsItem_Dir(archive, i, isDir);
- if (isDir)
- pi.NumSubDirs++;
- else
- pi.NumSubFiles++;
- }
- if (pi.NumSubDirs != 0)
- pi.NumSubDirs_Defined = true;
- pi.NumSubFiles_Defined = true;
- }
-
- return S_OK;
-}
-
-#endif
-
-HRESULT CArc::CheckZerosTail(const COpenOptions &op, UInt64 offset)
-{
- if (!op.stream)
- return S_OK;
- RINOK(op.stream->Seek(offset, STREAM_SEEK_SET, NULL));
- const UInt32 kBufSize = 1 << 11;
- Byte buf[kBufSize];
-
- for (;;)
- {
- UInt32 processed = 0;
- RINOK(op.stream->Read(buf, kBufSize, &processed));
- if (processed == 0)
- {
- // ErrorInfo.NonZerosTail = false;
- ErrorInfo.IgnoreTail = true;
- return S_OK;
- }
- for (size_t i = 0; i < processed; i++)
- {
- if (buf[i] != 0)
- {
- // ErrorInfo.IgnoreTail = false;
- // ErrorInfo.NonZerosTail = true;
- return S_OK;
- }
- }
- }
-}
-
-#ifndef _SFX
-
-class CExtractCallback_To_OpenCallback:
- public IArchiveExtractCallback,
- public ICompressProgressInfo,
- public CMyUnknownImp
-{
-public:
- CMyComPtr<IArchiveOpenCallback> Callback;
- UInt64 Files;
- UInt64 Offset;
-
- MY_UNKNOWN_IMP2(IArchiveExtractCallback, ICompressProgressInfo)
- INTERFACE_IArchiveExtractCallback(;)
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
- void Init(IArchiveOpenCallback *callback)
- {
- Callback = callback;
- Files = 0;
- Offset = 0;
- }
-};
-
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetTotal(UInt64 /* size */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetCompleted(const UInt64 * /* completeValue */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
-{
- if (Callback)
- {
- UInt64 value = Offset;
- if (inSize)
- value += *inSize;
- return Callback->SetCompleted(&Files, &value);
- }
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallback_To_OpenCallback::GetStream(UInt32 /* index */, ISequentialOutStream **outStream, Int32 /* askExtractMode */)
-{
- *outStream = 0;
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallback_To_OpenCallback::PrepareOperation(Int32 /* askExtractMode */)
-{
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallback_To_OpenCallback::SetOperationResult(Int32 /* operationResult */)
-{
- return S_OK;
-}
-
-static HRESULT OpenArchiveSpec(IInArchive *archive, bool needPhySize,
- IInStream *stream, const UInt64 *maxCheckStartPosition,
- IArchiveOpenCallback *openCallback,
- IArchiveExtractCallback *extractCallback)
-{
- /*
- if (needPhySize)
- {
- CMyComPtr<IArchiveOpen2> open2;
- archive->QueryInterface(IID_IArchiveOpen2, (void **)&open2);
- if (open2)
- return open2->ArcOpen2(stream, kOpenFlags_RealPhySize, openCallback);
- }
- */
- RINOK(archive->Open(stream, maxCheckStartPosition, openCallback));
- if (needPhySize)
- {
- bool phySize_Defined = false;
- UInt64 phySize = 0;
- RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, phySize, phySize_Defined));
- if (phySize_Defined)
- return S_OK;
-
- bool phySizeCantBeDetected = false;;
- RINOK(Archive_GetArcBoolProp(archive, kpidPhySizeCantBeDetected, phySizeCantBeDetected));
-
- if (!phySizeCantBeDetected)
- {
- RINOK(archive->Extract(0, (UInt32)(Int32)-1, BoolToInt(true), extractCallback));
- }
- }
- return S_OK;
-}
-
-static int FindFormatForArchiveType(CCodecs *codecs, CIntVector orderIndices, const char *name)
-{
- FOR_VECTOR (i, orderIndices)
- if (StringsAreEqualNoCase_Ascii(codecs->Formats[orderIndices[i]].Name, name))
- return i;
- return -1;
-}
-
-#endif
-
-HRESULT CArc::OpenStream2(const COpenOptions &op)
-{
- // fprintf(stdout, "\nOpen: %S", Path); fflush(stdout);
-
- Archive.Release();
- GetRawProps.Release();
- GetRootProps.Release();
-
- ErrorInfo.ClearErrors();
- ErrorInfo.ErrorFormatIndex = -1;
-
- IsParseArc = false;
- ArcStreamOffset = 0;
-
- // OutputDebugStringA("1");
- // OutputDebugStringW(Path);
-
- const UString fileName = ExtractFileNameFromPath(Path);
- UString extension;
- {
- int dotPos = fileName.ReverseFind_Dot();
- if (dotPos >= 0)
- extension = fileName.Ptr(dotPos + 1);
- }
-
- CIntVector orderIndices;
-
- bool searchMarkerInHandler = false;
- #ifdef _SFX
- searchMarkerInHandler = true;
- #endif
-
- CBoolArr isMainFormatArr(op.codecs->Formats.Size());
- {
- FOR_VECTOR(i, op.codecs->Formats)
- isMainFormatArr[i] = false;
- }
-
- UInt64 maxStartOffset =
- op.openType.MaxStartOffset_Defined ?
- op.openType.MaxStartOffset :
- kMaxCheckStartPosition;
-
- #ifndef _SFX
- bool isUnknownExt = false;
- #endif
-
- bool isForced = false;
- unsigned numMainTypes = 0;
- int formatIndex = op.openType.FormatIndex;
-
- if (formatIndex >= 0)
- {
- isForced = true;
- orderIndices.Add(formatIndex);
- numMainTypes = 1;
- isMainFormatArr[(unsigned)formatIndex] = true;
-
- searchMarkerInHandler = true;
- }
- else
- {
- unsigned numFinded = 0;
- #ifndef _SFX
- bool isPrearcExt = false;
- #endif
-
- {
- #ifndef _SFX
-
- bool isZip = false;
- bool isRar = false;
-
- const wchar_t c = extension[0];
- if (c == 'z' || c == 'Z' || c == 'r' || c == 'R')
- {
- bool isNumber = false;
- for (unsigned k = 1;; k++)
- {
- const wchar_t d = extension[k];
- if (d == 0)
- break;
- if (d < '0' || d > '9')
- {
- isNumber = false;
- break;
- }
- isNumber = true;
- }
- if (isNumber)
- if (c == 'z' || c == 'Z')
- isZip = true;
- else
- isRar = true;
- }
-
- #endif
-
- FOR_VECTOR (i, op.codecs->Formats)
- {
- const CArcInfoEx &ai = op.codecs->Formats[i];
-
- if (IgnoreSplit || !op.openType.CanReturnArc)
- if (ai.IsSplit())
- continue;
- if (op.excludedFormats->FindInSorted(i) >= 0)
- continue;
-
- #ifndef _SFX
- if (IsPreArcFormat(ai))
- isPrearcExt = true;
- #endif
-
- if (ai.FindExtension(extension) >= 0
- #ifndef _SFX
- || isZip && StringsAreEqualNoCase_Ascii(ai.Name, "zip")
- || isRar && StringsAreEqualNoCase_Ascii(ai.Name, "rar")
- #endif
- )
- {
- // PrintNumber("orderIndices.Insert", i);
- orderIndices.Insert(numFinded++, i);
- isMainFormatArr[i] = true;
- }
- else
- orderIndices.Add(i);
- }
- }
-
- if (!op.stream)
- {
- if (numFinded != 1)
- return E_NOTIMPL;
- orderIndices.DeleteFrom(1);
- }
- // PrintNumber("numFinded", numFinded );
-
- /*
- if (op.openOnlySpecifiedByExtension)
- {
- if (numFinded != 0 && !IsExeExt(extension))
- orderIndices.DeleteFrom(numFinded);
- }
- */
-
- #ifndef _SFX
-
- if (op.stream && orderIndices.Size() >= 2)
- {
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
- CByteBuffer byteBuffer;
- CIntVector orderIndices2;
- if (numFinded == 0 || IsExeExt(extension))
- {
- // signature search was here
- }
- else if (extension.IsEqualTo("000") || extension.IsEqualTo("001"))
- {
- int i = FindFormatForArchiveType(op.codecs, orderIndices, "rar");
- if (i >= 0)
- {
- const size_t kBufSize = (1 << 10);
- byteBuffer.Alloc(kBufSize);
- size_t processedSize = kBufSize;
- RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
- if (processedSize >= 16)
- {
- const Byte *buf = byteBuffer;
- const Byte kRarHeader[] = { 0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 };
- if (TestSignature(buf, kRarHeader, 7) && buf[9] == 0x73 && (buf[10] & 1) != 0)
- {
- orderIndices2.Add(orderIndices[i]);
- orderIndices[i] = -1;
- if (i >= (int)numFinded)
- numFinded++;
- }
- }
- }
- }
- else
- {
- const size_t kBufSize = (1 << 10);
- byteBuffer.Alloc(kBufSize);
- size_t processedSize = kBufSize;
- RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
- if (processedSize == 0)
- return S_FALSE;
-
- /*
- check type order:
- 1) matched extension, no signuature
- 2) matched extension, matched signuature
- // 3) no signuature
- // 4) matched signuature
- */
-
- MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, NULL, 0);
- MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, byteBuffer, processedSize);
- // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, NULL, 0);
- // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, byteBuffer, processedSize);
- }
-
- FOR_VECTOR (i, orderIndices)
- {
- int val = orderIndices[i];
- if (val != -1)
- orderIndices2.Add(val);
- }
- orderIndices = orderIndices2;
- }
-
- if (orderIndices.Size() >= 2)
- {
- int iIso = FindFormatForArchiveType(op.codecs, orderIndices, "iso");
- int iUdf = FindFormatForArchiveType(op.codecs, orderIndices, "udf");
- if (iUdf > iIso && iIso >= 0)
- {
- int isoIndex = orderIndices[iIso];
- int udfIndex = orderIndices[iUdf];
- orderIndices[iUdf] = isoIndex;
- orderIndices[iIso] = udfIndex;
- }
- }
-
- numMainTypes = numFinded;
- isUnknownExt = (numMainTypes == 0) || isPrearcExt;
-
- #else // _SFX
-
- numMainTypes = orderIndices.Size();
-
- // we need correct numMainTypes for mutlivolume SFX (if some volume is missing)
- if (numFinded != 0)
- numMainTypes = numFinded;
-
- #endif
- }
-
- UInt64 fileSize = 0;
- if (op.stream)
- {
- RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
- FileSize = fileSize;
-
-
- #ifndef _SFX
-
- CBoolArr skipFrontalFormat(op.codecs->Formats.Size());
- {
- FOR_VECTOR(i, op.codecs->Formats)
- skipFrontalFormat[i] = false;
- }
-
- #endif
-
- const COpenType &mode = op.openType;
-
-
-
-
-
- if (mode.CanReturnArc)
- {
- // ---------- OPEN main type by extenssion ----------
-
- unsigned numCheckTypes = orderIndices.Size();
- if (formatIndex >= 0)
- numCheckTypes = numMainTypes;
-
- for (unsigned i = 0; i < numCheckTypes; i++)
- {
- FormatIndex = orderIndices[i];
-
- bool exactOnly = false;
-
- #ifndef _SFX
-
- const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
- // OutputDebugStringW(ai.Name);
- if (i >= numMainTypes)
- {
- if (!ai.Flags_BackwardOpen()
- // && !ai.Flags_PureStartOpen()
- )
- continue;
- exactOnly = true;
- }
-
- #endif
-
- // Some handlers do not set total bytes. So we set it here
- if (op.callback)
- RINOK(op.callback->SetTotal(NULL, &fileSize));
-
- if (op.stream)
- {
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
-
- CMyComPtr<IInArchive> archive;
-
- RINOK(PrepareToOpen(op, FormatIndex, archive));
- if (!archive)
- continue;
-
- HRESULT result;
- if (op.stream)
- {
- UInt64 searchLimit = (!exactOnly && searchMarkerInHandler) ? maxStartOffset: 0;
- result = archive->Open(op.stream, &searchLimit, op.callback);
- }
- else
- {
- CMyComPtr<IArchiveOpenSeq> openSeq;
- archive.QueryInterface(IID_IArchiveOpenSeq, (void **)&openSeq);
- if (!openSeq)
- return E_NOTIMPL;
- result = openSeq->OpenSeq(op.seqStream);
- }
-
- RINOK(ReadBasicProps(archive, 0, result));
-
- if (result == S_FALSE)
- {
- bool isArc = ErrorInfo.IsArc_After_NonOpen();
-
- #ifndef _SFX
- // if it's archive, we allow another open attempt for parser
- if (!mode.CanReturnParser || !isArc)
- skipFrontalFormat[(unsigned)FormatIndex] = true;
- #endif
-
- if (exactOnly)
- continue;
-
- if (i == 0 && numMainTypes == 1)
- {
- // we set NonOpenErrorInfo, only if there is only one main format (defined by extension).
- ErrorInfo.ErrorFormatIndex = FormatIndex;
- NonOpen_ErrorInfo = ErrorInfo;
-
- if (!mode.CanReturnParser && isArc)
- {
- // if (formatIndex < 0 && !searchMarkerInHandler)
- {
- // if bad archive was detected, we don't need additional open attempts
- #ifndef _SFX
- if (!IsPreArcFormat(ai) /* || !mode.SkipSfxStub */)
- #endif
- return S_FALSE;
- }
- }
- }
-
- /*
- #ifndef _SFX
- if (IsExeExt(extension) || ai.Flags_PreArc())
- {
- // openOnlyFullArc = false;
- // canReturnTailArc = true;
- // limitSignatureSearch = true;
- }
- #endif
- */
-
- continue;
- }
-
- RINOK(result);
-
- #ifndef _SFX
-
- bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
- const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
-
- bool thereIsTail = ErrorInfo.ThereIsTail;
- if (thereIsTail && mode.ZerosTailIsAllowed)
- {
- RINOK(CheckZerosTail(op, Offset + PhySize));
- if (ErrorInfo.IgnoreTail)
- thereIsTail = false;
- }
-
- if (Offset > 0)
- {
- if (exactOnly
- || !searchMarkerInHandler
- || !specFlags.CanReturn_NonStart()
- || (mode.MaxStartOffset_Defined && (UInt64)Offset > mode.MaxStartOffset))
- continue;
- }
- if (thereIsTail)
- {
- if (Offset > 0)
- {
- if (!specFlags.CanReturnMid)
- continue;
- }
- else if (!specFlags.CanReturnFrontal)
- continue;
- }
-
- if (Offset > 0 || thereIsTail)
- {
- if (formatIndex < 0)
- {
- if (IsPreArcFormat(ai))
- {
- // openOnlyFullArc = false;
- // canReturnTailArc = true;
- /*
- if (mode.SkipSfxStub)
- limitSignatureSearch = true;
- */
- // if (mode.SkipSfxStub)
- {
- // skipFrontalFormat[FormatIndex] = true;
- continue;
- }
- }
- }
- }
-
- #endif
-
- Archive = archive;
- return S_OK;
- }
- }
-
-
-
- #ifndef _SFX
-
- if (!op.stream)
- return S_FALSE;
-
- if (formatIndex >= 0 && !mode.CanReturnParser)
- {
- if (mode.MaxStartOffset_Defined)
- {
- if (mode.MaxStartOffset == 0)
- return S_FALSE;
- }
- else
- {
- const CArcInfoEx &ai = op.codecs->Formats[(unsigned)formatIndex];
- if (ai.FindExtension(extension) >= 0)
- {
- if (ai.Flags_FindSignature() && searchMarkerInHandler)
- return S_FALSE;
- }
- }
- }
-
- NArchive::NParser::CHandler *handlerSpec = new NArchive::NParser::CHandler;
- CMyComPtr<IInArchive> handler = handlerSpec;
-
- CExtractCallback_To_OpenCallback *extractCallback_To_OpenCallback_Spec = new CExtractCallback_To_OpenCallback;
- CMyComPtr<IArchiveExtractCallback> extractCallback_To_OpenCallback = extractCallback_To_OpenCallback_Spec;
- extractCallback_To_OpenCallback_Spec->Init(op.callback);
-
- {
- // ---------- Check all possible START archives ----------
- // this code is better for full file archives than Parser's code.
-
- CByteBuffer byteBuffer;
- bool endOfFile = false;
- size_t processedSize;
- {
- size_t bufSize = 1 << 20; // it must be larger than max signature offset or IsArcFunc offset ((1 << 19) + x for UDF)
- if (bufSize > fileSize)
- {
- bufSize = (size_t)fileSize;
- endOfFile = true;
- }
- byteBuffer.Alloc(bufSize);
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
- processedSize = bufSize;
- RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
- if (processedSize == 0)
- return S_FALSE;
- if (processedSize < bufSize)
- endOfFile = true;
- }
- CUIntVector sortedFormats;
-
- unsigned i;
-
- int splitIndex = -1;
-
- for (i = 0; i < orderIndices.Size(); i++)
- {
- unsigned form = orderIndices[i];
- if (skipFrontalFormat[form])
- continue;
- const CArcInfoEx &ai = op.codecs->Formats[form];
- if (ai.IsSplit())
- {
- splitIndex = form;
- continue;
- }
-
- if (ai.IsArcFunc)
- {
- UInt32 isArcRes = ai.IsArcFunc(byteBuffer, processedSize);
- if (isArcRes == k_IsArc_Res_NO)
- continue;
- if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
- continue;
- // if (isArcRes == k_IsArc_Res_YES_LOW_PROB) continue;
- sortedFormats.Insert(0, form);
- continue;
- }
-
- bool isNewStyleSignature = IsNewStyleSignature(ai);
- bool needCheck = !isNewStyleSignature
- || ai.Signatures.IsEmpty()
- || ai.Flags_PureStartOpen()
- || ai.Flags_StartOpen()
- || ai.Flags_BackwardOpen();
-
- if (isNewStyleSignature && !ai.Signatures.IsEmpty())
- {
- unsigned k;
- for (k = 0; k < ai.Signatures.Size(); k++)
- {
- const CByteBuffer &sig = ai.Signatures[k];
- UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
- if (processedSize < signatureEnd)
- {
- if (!endOfFile)
- needCheck = true;
- }
- else if (memcmp(sig, byteBuffer + ai.SignatureOffset, sig.Size()) == 0)
- break;
- }
- if (k != ai.Signatures.Size())
- {
- sortedFormats.Insert(0, form);
- continue;
- }
- }
- if (needCheck)
- sortedFormats.Add(form);
- }
-
- if (splitIndex >= 0)
- sortedFormats.Insert(0, splitIndex);
-
- for (i = 0; i < sortedFormats.Size(); i++)
- {
- FormatIndex = sortedFormats[i];
- const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
-
- if (op.callback)
- RINOK(op.callback->SetTotal(NULL, &fileSize));
-
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-
- CMyComPtr<IInArchive> archive;
- RINOK(PrepareToOpen(op, FormatIndex, archive));
- if (!archive)
- continue;
-
- PRF(printf("\nSorted Open %S", (const wchar_t *)ai.Name));
- HRESULT result;
- {
- UInt64 searchLimit = 0;
- /*
- if (mode.CanReturnArc)
- result = archive->Open(op.stream, &searchLimit, op.callback);
- else
- */
- result = OpenArchiveSpec(archive, !mode.CanReturnArc, op.stream, &searchLimit, op.callback, extractCallback_To_OpenCallback);
- }
-
- if (result == S_FALSE)
- {
- skipFrontalFormat[(unsigned)FormatIndex] = true;
- // FIXME: maybe we must use LenIsUnknown.
- // printf(" OpenForSize Error");
- continue;
- }
- RINOK(result);
-
- RINOK(ReadBasicProps(archive, 0, result));
-
- if (Offset > 0)
- {
- continue; // good handler doesn't return such Offset > 0
- // but there are some cases like false prefixed PK00 archive, when
- // we can support it?
- }
-
- NArchive::NParser::CParseItem pi;
- pi.Offset = Offset;
- pi.Size = AvailPhySize;
-
- // bool needScan = false;
-
- if (!PhySizeDefined)
- {
- // it's for Z format
- pi.LenIsUnknown = true;
- // needScan = true;
- // phySize = arcRem;
- // nextNeedCheckStartOpen = false;
- }
-
- /*
- if (OkPhySize_Defined)
- pi.OkSize = pi.OkPhySize;
- else
- pi.OkSize = pi.Size;
- */
-
- pi.NormalizeOffset();
- // printf(" phySize = %8d", (unsigned)phySize);
-
-
- if (mode.CanReturnArc)
- {
- bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
- const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
- bool openCur = false;
-
- if (!ErrorInfo.ThereIsTail)
- openCur = true;
- else
- {
- if (mode.ZerosTailIsAllowed)
- {
- RINOK(CheckZerosTail(op, Offset + PhySize));
- if (ErrorInfo.IgnoreTail)
- openCur = true;
- }
- if (!openCur)
- {
- openCur = specFlags.CanReturnFrontal;
- if (formatIndex < 0) // format is not forced
- {
- if (IsPreArcFormat(ai))
- {
- // if (mode.SkipSfxStub)
- {
- openCur = false;
- }
- }
- }
- }
- }
-
- if (openCur)
- {
- InStream = op.stream;
- Archive = archive;
- return S_OK;
- }
- }
-
- skipFrontalFormat[(unsigned)FormatIndex] = true;
-
-
- // if (!mode.CanReturnArc)
- /*
- if (!ErrorInfo.ThereIsTail)
- continue;
- */
- if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
- continue;
-
- // printf("\nAdd offset = %d", (int)pi.Offset);
- RINOK(ReadParseItemProps(archive, ai, pi));
- handlerSpec->AddItem(pi);
- }
- }
-
-
-
-
-
- // ---------- PARSER ----------
-
- CUIntVector arc2sig; // formatIndex to signatureIndex
- CUIntVector sig2arc; // signatureIndex to formatIndex;
- {
- unsigned sum = 0;
- FOR_VECTOR (i, op.codecs->Formats)
- {
- arc2sig.Add(sum);
- const CObjectVector<CByteBuffer> &sigs = op.codecs->Formats[i].Signatures;
- sum += sigs.Size();
- FOR_VECTOR (k, sigs)
- sig2arc.Add(i);
- }
- }
-
- {
- const size_t kBeforeSize = 1 << 16;
- const size_t kAfterSize = 1 << 20;
- const size_t kBufSize = 1 << 22; // it must be more than kBeforeSize + kAfterSize
-
- const UInt32 kNumVals = (UInt32)1 << (kNumHashBytes * 8);
- CByteArr hashBuffer(kNumVals);
- Byte *hash = hashBuffer;
- memset(hash, 0xFF, kNumVals);
- Byte prevs[256];
- memset(prevs, 0xFF, sizeof(prevs));
- if (sig2arc.Size() >= 0xFF)
- return S_FALSE;
-
- CUIntVector difficultFormats;
- CBoolArr difficultBools(256);
- {
- for (unsigned i = 0; i < 256; i++)
- difficultBools[i] = false;
- }
-
- bool thereAreHandlersForSearch = false;
-
- // UInt32 maxSignatureEnd = 0;
-
- FOR_VECTOR (i, orderIndices)
- {
- int index = orderIndices[i];
- if (index < 0)
- continue;
- const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
- bool isDifficult = false;
- // if (ai.Version < 0x91F) // we don't use parser with old DLL (before 9.31)
- if (!ai.NewInterface)
- isDifficult = true;
- else
- {
- if (ai.Flags_StartOpen())
- isDifficult = true;
- FOR_VECTOR (k, ai.Signatures)
- {
- const CByteBuffer &sig = ai.Signatures[k];
- /*
- UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
- if (maxSignatureEnd < signatureEnd)
- maxSignatureEnd = signatureEnd;
- */
- if (sig.Size() < kNumHashBytes)
- {
- isDifficult = true;
- continue;
- }
- thereAreHandlersForSearch = true;
- UInt32 v = HASH_VAL(sig);
- unsigned sigIndex = arc2sig[(unsigned)index] + k;
- prevs[sigIndex] = hash[v];
- hash[v] = (Byte)sigIndex;
- }
- }
- if (isDifficult)
- {
- difficultFormats.Add(index);
- difficultBools[(unsigned)index] = true;
- }
- }
-
- if (!thereAreHandlersForSearch)
- {
- // openOnlyFullArc = true;
- // canReturnTailArc = true;
- }
-
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
-
- CLimitedCachedInStream *limitedStreamSpec = new CLimitedCachedInStream;
- CMyComPtr<IInStream> limitedStream = limitedStreamSpec;
- limitedStreamSpec->SetStream(op.stream);
-
- CArchiveOpenCallback_Offset *openCallback_Offset_Spec = NULL;
- CMyComPtr<IArchiveOpenCallback> openCallback_Offset;
- if (op.callback)
- {
- openCallback_Offset_Spec = new CArchiveOpenCallback_Offset;
- openCallback_Offset = openCallback_Offset_Spec;
- openCallback_Offset_Spec->Callback = op.callback;
- openCallback_Offset_Spec->Callback.QueryInterface(IID_IArchiveOpenVolumeCallback, &openCallback_Offset_Spec->OpenVolumeCallback);
- #ifndef _NO_CRYPTO
- openCallback_Offset_Spec->Callback.QueryInterface(IID_ICryptoGetTextPassword, &openCallback_Offset_Spec->GetTextPassword);
- #endif
- }
-
- if (op.callback)
- RINOK(op.callback->SetTotal(NULL, &fileSize));
-
- CByteBuffer &byteBuffer = limitedStreamSpec->Buffer;
- byteBuffer.Alloc(kBufSize);
-
- UInt64 callbackPrev = 0;
- bool needCheckStartOpen = true; // = true, if we need to test all archives types for current pos.
-
- bool endOfFile = false;
- UInt64 bufPhyPos = 0;
- size_t bytesInBuf = 0;
- // UInt64 prevPos = 0;
-
- // ---------- Main Scan Loop ----------
-
- UInt64 pos = 0;
-
- if (!mode.EachPos && handlerSpec->_items.Size() == 1)
- {
- NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
- if (!pi.LenIsUnknown && pi.Offset == 0)
- pos = pi.Size;
- }
-
- for (;;)
- {
- // printf("\nPos = %d", (int)pos);
- UInt64 posInBuf = pos - bufPhyPos;
-
- // if (pos > ((UInt64)1 << 35)) break;
-
- if (!endOfFile)
- {
- if (bytesInBuf < kBufSize)
- {
- size_t processedSize = kBufSize - bytesInBuf;
- // printf("\nRead ask = %d", (unsigned)processedSize);
- UInt64 seekPos = bufPhyPos + bytesInBuf;
- RINOK(op.stream->Seek(bufPhyPos + bytesInBuf, STREAM_SEEK_SET, NULL));
- RINOK(ReadStream(op.stream, byteBuffer + bytesInBuf, &processedSize));
- // printf(" processed = %d", (unsigned)processedSize);
- if (processedSize == 0)
- {
- fileSize = seekPos;
- endOfFile = true;
- }
- else
- {
- bytesInBuf += processedSize;
- limitedStreamSpec->SetCache(processedSize, (size_t)bufPhyPos);
- }
- continue;
- }
-
- if (bytesInBuf < posInBuf)
- {
- UInt64 skipSize = posInBuf - bytesInBuf;
- if (skipSize <= kBeforeSize)
- {
- size_t keepSize = (size_t)(kBeforeSize - skipSize);
- // printf("\nmemmove skip = %d", (int)keepSize);
- memmove(byteBuffer, byteBuffer + bytesInBuf - keepSize, keepSize);
- bytesInBuf = keepSize;
- bufPhyPos = pos - keepSize;
- continue;
- }
- // printf("\nSkip %d", (int)(skipSize - kBeforeSize));
- // RINOK(op.stream->Seek(skipSize - kBeforeSize, STREAM_SEEK_CUR, NULL));
- bytesInBuf = 0;
- bufPhyPos = pos - kBeforeSize;
- continue;
- }
-
- if (bytesInBuf - posInBuf < kAfterSize)
- {
- size_t beg = (size_t)posInBuf - kBeforeSize;
- // printf("\nmemmove for after beg = %d", (int)beg);
- memmove(byteBuffer, byteBuffer + beg, bytesInBuf - beg);
- bufPhyPos += beg;
- bytesInBuf -= beg;
- continue;
- }
- }
-
- if (bytesInBuf <= (size_t)posInBuf)
- break;
-
- bool useOffsetCallback = false;
- if (openCallback_Offset)
- {
- openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
- openCallback_Offset_Spec->Offset = pos;
-
- useOffsetCallback = (!op.openType.CanReturnArc || handlerSpec->_items.Size() > 1);
-
- if (pos >= callbackPrev + (1 << 23))
- {
- RINOK(openCallback_Offset_Spec->SetCompleted(NULL, NULL));
- callbackPrev = pos;
- }
- }
-
- {
- UInt64 endPos = bufPhyPos + bytesInBuf;
- if (fileSize < endPos)
- {
- FileSize = fileSize; // why ????
- fileSize = endPos;
- }
- }
-
- size_t availSize = bytesInBuf - (size_t)posInBuf;
- if (availSize < kNumHashBytes)
- break;
- size_t scanSize = availSize -
- ((availSize >= kAfterSize) ? kAfterSize : kNumHashBytes);
-
- {
- /*
- UInt64 scanLimit = openOnlyFullArc ?
- maxSignatureEnd :
- op.openType.ScanSize + maxSignatureEnd;
- */
- if (!mode.CanReturnParser)
- {
- if (pos > maxStartOffset)
- break;
- UInt64 remScan = maxStartOffset - pos;
- if (scanSize > remScan)
- scanSize = (size_t)remScan;
- }
- }
-
- scanSize++;
-
- const Byte *buf = byteBuffer + (size_t)posInBuf;
- const Byte *bufLimit = buf + scanSize;
- size_t ppp = 0;
-
- if (!needCheckStartOpen)
- {
- for (; buf < bufLimit && hash[HASH_VAL(buf)] == 0xFF; buf++);
- ppp = buf - (byteBuffer + (size_t)posInBuf);
- pos += ppp;
- if (buf == bufLimit)
- continue;
- }
-
- UInt32 v = HASH_VAL(buf);
- bool nextNeedCheckStartOpen = true;
- unsigned i = hash[v];
- unsigned indexOfDifficult = 0;
-
- // ---------- Open Loop for Current Pos ----------
- bool wasOpen = false;
-
- for (;;)
- {
- unsigned index;
- bool isDifficult;
- if (needCheckStartOpen && indexOfDifficult < difficultFormats.Size())
- {
- index = difficultFormats[indexOfDifficult++];
- isDifficult = true;
- }
- else
- {
- if (i == 0xFF)
- break;
- index = sig2arc[i];
- unsigned sigIndex = i - arc2sig[index];
- i = prevs[i];
- if (needCheckStartOpen && difficultBools[index])
- continue;
- const CArcInfoEx &ai = op.codecs->Formats[index];
-
- if (pos < ai.SignatureOffset)
- continue;
-
- /*
- if (openOnlyFullArc)
- if (pos != ai.SignatureOffset)
- continue;
- */
-
- const CByteBuffer &sig = ai.Signatures[sigIndex];
-
- if (ppp + sig.Size() > availSize
- || !TestSignature(buf, sig, sig.Size()))
- continue;
- // printf("\nSignature OK: %10S %8x %5d", (const wchar_t *)ai.Name, (int)pos, (int)(pos - prevPos));
- // prevPos = pos;
- isDifficult = false;
- }
-
- const CArcInfoEx &ai = op.codecs->Formats[index];
-
-
- if ((isDifficult && pos == 0) || ai.SignatureOffset == pos)
- {
- // we don't check same archive second time */
- if (skipFrontalFormat[index])
- continue;
- }
-
- UInt64 startArcPos = pos;
- if (!isDifficult)
- {
- if (pos < ai.SignatureOffset)
- continue;
- startArcPos = pos - ai.SignatureOffset;
- /*
- // we don't need the check for Z files
- if (startArcPos < handlerSpec->GetLastEnd())
- continue;
- */
- }
-
- if (ai.IsArcFunc && startArcPos >= bufPhyPos)
- {
- size_t offsetInBuf = (size_t)(startArcPos - bufPhyPos);
- if (offsetInBuf < bytesInBuf)
- {
- UInt32 isArcRes = ai.IsArcFunc(byteBuffer + offsetInBuf, bytesInBuf - offsetInBuf);
- if (isArcRes == k_IsArc_Res_NO)
- continue;
- if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
- continue;
- /*
- if (isArcRes == k_IsArc_Res_YES_LOW_PROB)
- {
- // if (pos != ai.SignatureOffset)
- continue;
- }
- */
- }
- // printf("\nIsArc OK: %S", (const wchar_t *)ai.Name);
- }
-
- /*
- if (pos == 67109888)
- pos = pos;
- */
- PRF(printf("\npos = %9I64d : %S", pos, (const wchar_t *)ai.Name));
-
- bool isMainFormat = isMainFormatArr[index];
- const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
-
- CMyComPtr<IInArchive> archive;
- RINOK(PrepareToOpen(op, index, archive));
- if (!archive)
- return E_FAIL;
-
- // OutputDebugStringW(ai.Name);
-
- UInt64 rem = fileSize - startArcPos;
-
- UInt64 arcStreamOffset = 0;
-
- if (ai.Flags_UseGlobalOffset())
- {
- limitedStreamSpec->InitAndSeek(0, fileSize);
- limitedStream->Seek(startArcPos, STREAM_SEEK_SET, NULL);
- }
- else
- {
- limitedStreamSpec->InitAndSeek(startArcPos, rem);
- arcStreamOffset = startArcPos;
- }
-
- UInt64 maxCheckStartPosition = 0;
-
- if (openCallback_Offset)
- {
- openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
- openCallback_Offset_Spec->Offset = startArcPos;
- }
-
- // HRESULT result = archive->Open(limitedStream, &maxCheckStartPosition, openCallback_Offset);
- extractCallback_To_OpenCallback_Spec->Files = 0;
- extractCallback_To_OpenCallback_Spec->Offset = startArcPos;
-
- HRESULT result = OpenArchiveSpec(archive, true, limitedStream, &maxCheckStartPosition,
- useOffsetCallback ? (IArchiveOpenCallback *)openCallback_Offset : (IArchiveOpenCallback *)op.callback,
- extractCallback_To_OpenCallback);
-
- RINOK(ReadBasicProps(archive, ai.Flags_UseGlobalOffset() ? 0 : startArcPos, result));
-
- bool isOpen = false;
- if (result == S_FALSE)
- {
- if (!mode.CanReturnParser)
- {
- if (formatIndex < 0 && ErrorInfo.IsArc_After_NonOpen())
- {
- ErrorInfo.ErrorFormatIndex = index;
- NonOpen_ErrorInfo = ErrorInfo;
- // if archive was detected, we don't need additional open attempts
- return S_FALSE;
- }
- continue;
- }
- if (!ErrorInfo.IsArc_After_NonOpen() || !PhySizeDefined || PhySize == 0)
- continue;
- }
- else
- {
- isOpen = true;
- RINOK(result);
- PRF(printf(" OK "));
- }
-
- // fprintf(stderr, "\n %8X %S", startArcPos, Path);
- // printf("\nOpen OK: %S", ai.Name);
-
-
- NArchive::NParser::CParseItem pi;
- pi.Offset = startArcPos;
-
- if (ai.Flags_UseGlobalOffset())
- pi.Offset = Offset;
- else if (Offset != 0)
- return E_FAIL;
- UInt64 arcRem = FileSize - pi.Offset;
- UInt64 phySize = arcRem;
- bool phySizeDefined = PhySizeDefined;
- if (phySizeDefined)
- {
- if (pi.Offset + PhySize > FileSize)
- {
- // ErrorInfo.ThereIsTail = true;
- PhySize = FileSize - pi.Offset;
- }
- phySize = PhySize;
- }
- if (phySize == 0 || (UInt64)phySize > ((UInt64)1 << 63))
- return E_FAIL;
-
- /*
- if (!ai.UseGlobalOffset)
- {
- if (phySize > arcRem)
- {
- ThereIsTail = true;
- phySize = arcRem;
- }
- }
- */
-
- bool needScan = false;
-
-
- if (isOpen && !phySizeDefined)
- {
- // it's for Z format
- pi.LenIsUnknown = true;
- needScan = true;
- phySize = arcRem;
- nextNeedCheckStartOpen = false;
- }
-
- pi.Size = phySize;
- /*
- if (OkPhySize_Defined)
- pi.OkSize = OkPhySize;
- */
- pi.NormalizeOffset();
- // printf(" phySize = %8d", (unsigned)phySize);
-
- /*
- if (needSkipFullArc)
- if (pi.Offset == 0 && phySizeDefined && pi.Size >= fileSize)
- continue;
- */
- if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
- {
- // it's possible for dmg archives
- if (!mode.CanReturnArc)
- continue;
- }
-
- if (mode.EachPos)
- pos++;
- else if (needScan)
- {
- pos++;
- /*
- if (!OkPhySize_Defined)
- pos++;
- else
- pos = pi.Offset + pi.OkSize;
- */
- }
- else
- pos = pi.Offset + pi.Size;
-
-
- RINOK(ReadParseItemProps(archive, ai, pi));
-
- if (pi.Offset < startArcPos && !mode.EachPos /* && phySizeDefined */)
- {
- /* It's for DMG format.
- This code deletes all previous items that are included to current item */
-
- while (!handlerSpec->_items.IsEmpty())
- {
- {
- const NArchive::NParser::CParseItem &back = handlerSpec->_items.Back();
- if (back.Offset < pi.Offset)
- break;
- if (back.Offset + back.Size > pi.Offset + pi.Size)
- break;
- }
- handlerSpec->_items.DeleteBack();
- }
- }
-
-
- if (isOpen && mode.CanReturnArc && phySizeDefined)
- {
- // if (pi.Offset + pi.Size >= fileSize)
- bool openCur = false;
-
- bool thereIsTail = ErrorInfo.ThereIsTail;
- if (thereIsTail && mode.ZerosTailIsAllowed)
- {
- RINOK(CheckZerosTail(op, arcStreamOffset + Offset + PhySize));
- if (ErrorInfo.IgnoreTail)
- thereIsTail = false;
- }
-
- if (pi.Offset != 0)
- {
- if (!pi.IsNotArcType)
- if (thereIsTail)
- openCur = specFlags.CanReturnMid;
- else
- openCur = specFlags.CanReturnTail;
- }
- else
- {
- if (!thereIsTail)
- openCur = true;
- else
- openCur = specFlags.CanReturnFrontal;
-
-
- if (formatIndex >= -2)
- openCur = true;
- }
- if (formatIndex < 0 && pi.IsSelfExe /* && mode.SkipSfxStub */)
- openCur = false;
-
- // We open file as SFX, if there is front archive or first archive is "Self Executable"
- if (!openCur && !pi.IsSelfExe && !thereIsTail &&
- (!pi.IsNotArcType || pi.Offset == 0))
- {
- if (handlerSpec->_items.IsEmpty())
- {
- if (specFlags.CanReturnTail)
- openCur = true;
- }
- else if (handlerSpec->_items.Size() == 1)
- {
- if (handlerSpec->_items[0].IsSelfExe)
- {
- if (mode.SpecUnknownExt.CanReturnTail)
- openCur = true;
- }
- }
- }
-
- if (openCur)
- {
- InStream = op.stream;
- Archive = archive;
- FormatIndex = index;
- ArcStreamOffset = arcStreamOffset;
- return S_OK;
- }
- }
-
- /*
- if (openOnlyFullArc)
- {
- ErrorInfo.ClearErrors();
- return S_FALSE;
- }
- */
-
- pi.FormatIndex = index;
-
- // printf("\nAdd offset = %d", (int)pi.Offset);
- handlerSpec->AddItem(pi);
- wasOpen = true;
- break;
- }
- // ---------- End of Open Loop for Current Pos ----------
-
- if (!wasOpen)
- pos++;
- needCheckStartOpen = (nextNeedCheckStartOpen && wasOpen);
- }
- // ---------- End of Main Scan Loop ----------
-
- /*
- if (handlerSpec->_items.Size() == 1)
- {
- const NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
- if (pi.Size == fileSize && pi.Offset == 0)
- {
- Archive = archive;
- FormatIndex2 = pi.FormatIndex;
- return S_OK;
- }
- }
- */
-
- if (mode.CanReturnParser)
- {
- bool returnParser = (handlerSpec->_items.Size() == 1); // it's possible if fileSize was not correct at start of parsing
- handlerSpec->AddUnknownItem(fileSize);
- if (handlerSpec->_items.Size() == 0)
- return S_FALSE;
- if (returnParser || handlerSpec->_items.Size() != 1)
- {
- // return S_FALSE;
- handlerSpec->_stream = op.stream;
- Archive = handler;
- ErrorInfo.ClearErrors();
- IsParseArc = true;
- FormatIndex = -1; // It's parser
- Offset = 0;
- return S_OK;
- }
- }
- }
-
- #endif
-
- if (!Archive)
- return S_FALSE;
- return S_OK;
-}
-
-HRESULT CArc::OpenStream(const COpenOptions &op)
-{
- RINOK(OpenStream2(op));
- // PrintNumber("op.formatIndex 3", op.formatIndex);
-
- if (Archive)
- {
- GetRawProps.Release();
- GetRootProps.Release();
- Archive->QueryInterface(IID_IArchiveGetRawProps, (void **)&GetRawProps);
- Archive->QueryInterface(IID_IArchiveGetRootProps, (void **)&GetRootProps);
-
- RINOK(Archive_GetArcBoolProp(Archive, kpidIsTree, IsTree));
- RINOK(Archive_GetArcBoolProp(Archive, kpidIsDeleted, Ask_Deleted));
- RINOK(Archive_GetArcBoolProp(Archive, kpidIsAltStream, Ask_AltStream));
- RINOK(Archive_GetArcBoolProp(Archive, kpidIsAux, Ask_Aux));
- RINOK(Archive_GetArcBoolProp(Archive, kpidINode, Ask_INode));
- RINOK(Archive_GetArcBoolProp(Archive, kpidReadOnly, IsReadOnly));
-
- const UString fileName = ExtractFileNameFromPath(Path);
- UString extension;
- {
- int dotPos = fileName.ReverseFind_Dot();
- if (dotPos >= 0)
- extension = fileName.Ptr(dotPos + 1);
- }
-
- DefaultName.Empty();
- if (FormatIndex >= 0)
- {
- const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
- if (ai.Exts.Size() == 0)
- DefaultName = GetDefaultName2(fileName, UString(), UString());
- else
- {
- int subExtIndex = ai.FindExtension(extension);
- if (subExtIndex < 0)
- subExtIndex = 0;
- const CArcExtInfo &extInfo = ai.Exts[subExtIndex];
- DefaultName = GetDefaultName2(fileName, extInfo.Ext, extInfo.AddExt);
- }
- }
- }
-
- return S_OK;
-}
-
-#ifdef _SFX
-
-#ifdef _WIN32
- #define k_ExeExt ".exe"
- static const unsigned k_ExeExt_Len = 4;
-#else
- #define k_ExeExt ""
- static const unsigned k_ExeExt_Len = 0;
-#endif
-
-#endif
-
-HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
-{
- CMyComPtr<IInStream> fileStream;
- CMyComPtr<ISequentialInStream> seqStream;
- CInFileStream *fileStreamSpec = NULL;
-
- if (op.stdInMode)
- {
- seqStream = new CStdInFileStream;
- op.seqStream = seqStream;
- }
- else if (!op.stream)
- {
- fileStreamSpec = new CInFileStream;
- fileStream = fileStreamSpec;
- Path = filePath;
- if (!fileStreamSpec->Open(us2fs(Path)))
- {
- return GetLastError();
- }
- op.stream = fileStream;
- #ifdef _SFX
- IgnoreSplit = true;
- #endif
- }
-
- /*
- if (callback)
- {
- UInt64 fileSize;
- RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
- RINOK(op.callback->SetTotal(NULL, &fileSize))
- }
- */
-
- HRESULT res = OpenStream(op);
- IgnoreSplit = false;
-
- #ifdef _SFX
-
- if (res != S_FALSE
- || !fileStreamSpec
- || !op.callbackSpec
- || NonOpen_ErrorInfo.IsArc_After_NonOpen())
- return res;
-
- {
- if (filePath.Len() > k_ExeExt_Len
- && StringsAreEqualNoCase_Ascii(filePath.RightPtr(k_ExeExt_Len), k_ExeExt))
- {
- const UString path2 = filePath.Left(filePath.Len() - k_ExeExt_Len);
- FOR_VECTOR (i, op.codecs->Formats)
- {
- const CArcInfoEx &ai = op.codecs->Formats[i];
- if (ai.IsSplit())
- continue;
- UString path3 = path2;
- path3 += '.';
- path3 += ai.GetMainExt(); // "7z" for SFX.
- Path = path3;
- Path += ".001";
- bool isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
- if (!isOk)
- {
- Path = path3;
- isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
- }
- if (isOk)
- {
- if (fileStreamSpec->Open(us2fs(Path)))
- {
- op.stream = fileStream;
- NonOpen_ErrorInfo.ClearErrors_Full();
- if (OpenStream(op) == S_OK)
- return S_OK;
- }
- }
- }
- }
- }
-
- #endif
-
- return res;
-}
-
-void CArchiveLink::KeepModeForNextOpen()
-{
- for (unsigned i = Arcs.Size(); i != 0;)
- {
- i--;
- CMyComPtr<IArchiveKeepModeForNextOpen> keep;
- Arcs[i].Archive->QueryInterface(IID_IArchiveKeepModeForNextOpen, (void **)&keep);
- if (keep)
- keep->KeepModeForNextOpen();
- }
-}
-
-HRESULT CArchiveLink::Close()
-{
- for (unsigned i = Arcs.Size(); i != 0;)
- {
- i--;
- RINOK(Arcs[i].Close());
- }
- IsOpen = false;
- // ErrorsText.Empty();
- return S_OK;
-}
-
-void CArchiveLink::Release()
-{
- // NonOpenErrorFormatIndex = -1;
- NonOpen_ErrorInfo.ClearErrors();
- NonOpen_ArcPath.Empty();
- while (!Arcs.IsEmpty())
- Arcs.DeleteBack();
-}
-
-/*
-void CArchiveLink::Set_ErrorsText()
-{
- FOR_VECTOR(i, Arcs)
- {
- const CArc &arc = Arcs[i];
- if (!arc.ErrorFlagsText.IsEmpty())
- {
- if (!ErrorsText.IsEmpty())
- ErrorsText.Add_LF();
- ErrorsText += GetUnicodeString(arc.ErrorFlagsText);
- }
- if (!arc.ErrorMessage.IsEmpty())
- {
- if (!ErrorsText.IsEmpty())
- ErrorsText.Add_LF();
- ErrorsText += arc.ErrorMessage;
- }
-
- if (!arc.WarningMessage.IsEmpty())
- {
- if (!ErrorsText.IsEmpty())
- ErrorsText.Add_LF();
- ErrorsText += arc.WarningMessage;
- }
- }
-}
-*/
-
-HRESULT CArchiveLink::Open(COpenOptions &op)
-{
- Release();
- if (op.types->Size() >= 32)
- return E_NOTIMPL;
-
- HRESULT resSpec;
-
- for (;;)
- {
- resSpec = S_OK;
-
- op.openType = COpenType();
- if (op.types->Size() >= 1)
- {
- COpenType latest;
- if (Arcs.Size() < op.types->Size())
- latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
- else
- {
- latest = (*op.types)[0];
- if (!latest.Recursive)
- break;
- }
- op.openType = latest;
- }
- else if (Arcs.Size() >= 32)
- break;
-
- /*
- op.formatIndex = -1;
- if (op.types->Size() >= 1)
- {
- int latest;
- if (Arcs.Size() < op.types->Size())
- latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
- else
- {
- latest = (*op.types)[0];
- if (latest != -2 && latest != -3)
- break;
- }
- if (latest >= 0)
- op.formatIndex = latest;
- else if (latest == -1 || latest == -2)
- {
- // default
- }
- else if (latest == -3)
- op.formatIndex = -2;
- else
- op.formatIndex = latest + 2;
- }
- else if (Arcs.Size() >= 32)
- break;
- */
-
- if (Arcs.IsEmpty())
- {
- CArc arc;
- arc.filePath = op.filePath;
- arc.Path = op.filePath;
- arc.SubfileIndex = (UInt32)(Int32)-1;
- HRESULT result = arc.OpenStreamOrFile(op);
- if (result != S_OK)
- {
- if (result == S_FALSE)
- {
- NonOpen_ErrorInfo = arc.NonOpen_ErrorInfo;
- // NonOpenErrorFormatIndex = arc.ErrorFormatIndex;
- NonOpen_ArcPath = arc.Path;
- }
- return result;
- }
- Arcs.Add(arc);
- continue;
- }
-
- // PrintNumber("op.formatIndex 11", op.formatIndex);
-
- const CArc &arc = Arcs.Back();
-
- if (op.types->Size() > Arcs.Size())
- resSpec = E_NOTIMPL;
-
- UInt32 mainSubfile;
- {
- NCOM::CPropVariant prop;
- RINOK(arc.Archive->GetArchiveProperty(kpidMainSubfile, &prop));
- if (prop.vt == VT_UI4)
- mainSubfile = prop.ulVal;
- else
- break;
- UInt32 numItems;
- RINOK(arc.Archive->GetNumberOfItems(&numItems));
- if (mainSubfile >= numItems)
- break;
- }
-
-
- CMyComPtr<IInArchiveGetStream> getStream;
- if (arc.Archive->QueryInterface(IID_IInArchiveGetStream, (void **)&getStream) != S_OK || !getStream)
- break;
-
- CMyComPtr<ISequentialInStream> subSeqStream;
- if (getStream->GetStream(mainSubfile, &subSeqStream) != S_OK || !subSeqStream)
- break;
-
- CMyComPtr<IInStream> subStream;
- if (subSeqStream.QueryInterface(IID_IInStream, &subStream) != S_OK || !subStream)
- break;
-
- CArc arc2;
- RINOK(arc.GetItemPath(mainSubfile, arc2.Path));
-
- bool zerosTailIsAllowed;
- RINOK(Archive_GetItemBoolProp(arc.Archive, mainSubfile, kpidZerosTailIsAllowed, zerosTailIsAllowed));
-
-
- if (op.callback)
- {
- CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;
- op.callback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);
- if (setSubArchiveName)
- setSubArchiveName->SetSubArchiveName(arc2.Path);
- }
-
- arc2.SubfileIndex = mainSubfile;
-
- // CIntVector incl;
- CIntVector excl;
-
- COpenOptions op2;
- #ifndef _SFX
- op2.props = op.props;
- #endif
- op2.codecs = op.codecs;
- // op2.types = &incl;
- op2.openType = op.openType;
- op2.openType.ZerosTailIsAllowed = zerosTailIsAllowed;
- op2.excludedFormats = !
- op2.stdInMode = false;
- op2.stream = subStream;
- op2.filePath = arc2.Path;
- op2.callback = op.callback;
- op2.callbackSpec = op.callbackSpec;
-
-
- HRESULT result = arc2.OpenStream(op2);
- resSpec = (op.types->Size() == 0 ? S_OK : S_FALSE);
- if (result == S_FALSE)
- {
- NonOpen_ErrorInfo = arc2.ErrorInfo;
- NonOpen_ArcPath = arc2.Path;
- break;
- }
- RINOK(result);
- RINOK(arc.GetItemMTime(mainSubfile, arc2.MTime, arc2.MTimeDefined));
- Arcs.Add(arc2);
- }
- IsOpen = !Arcs.IsEmpty();
- return resSpec;
-}
-
-HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
-{
- VolumesSize = 0;
- COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
- CMyComPtr<IArchiveOpenCallback> callback = openCallbackSpec;
- openCallbackSpec->Callback = callbackUI;
-
- FString prefix, name;
-
- if (!op.stream && !op.stdInMode)
- {
- NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), prefix, name);
- openCallbackSpec->Init(prefix, name);
- }
- else
- {
- openCallbackSpec->SetSubArchiveName(op.filePath);
- }
-
- op.callback = callback;
- op.callbackSpec = openCallbackSpec;
-
- HRESULT res = Open(op);
-
- PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
- // Password = openCallbackSpec->Password;
-
- RINOK(res);
- // VolumePaths.Add(fs2us(prefix + name));
-
- FOR_VECTOR (i, openCallbackSpec->FileNames_WasUsed)
- {
- if (openCallbackSpec->FileNames_WasUsed[i])
- {
- VolumePaths.Add(fs2us(prefix) + openCallbackSpec->FileNames[i]);
- VolumesSize += openCallbackSpec->FileSizes[i];
- }
- }
- // VolumesSize = openCallbackSpec->TotalSize;
- return S_OK;
-}
-
-HRESULT CArc::ReOpen(const COpenOptions &op)
-{
- ErrorInfo.ClearErrors();
- ErrorInfo.ErrorFormatIndex = -1;
-
- UInt64 fileSize = 0;
- if (op.stream)
- {
- RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
- RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
- }
- FileSize = fileSize;
-
- CMyComPtr<IInStream> stream2;
- Int64 globalOffset = GetGlobalOffset();
- if (globalOffset <= 0)
- stream2 = op.stream;
- else
- {
- CTailInStream *tailStreamSpec = new CTailInStream;
- stream2 = tailStreamSpec;
- tailStreamSpec->Stream = op.stream;
- tailStreamSpec->Offset = globalOffset;
- tailStreamSpec->Init();
- RINOK(tailStreamSpec->SeekToStart());
- }
-
- // There are archives with embedded STUBs (like ZIP), so we must support signature scanning
- // But for another archives we can use 0 here. So the code can be fixed !!!
- UInt64 maxStartPosition = kMaxCheckStartPosition;
- HRESULT res = Archive->Open(stream2, &maxStartPosition, op.callback);
-
- if (res == S_OK)
- {
- RINOK(ReadBasicProps(Archive, globalOffset, res));
- ArcStreamOffset = globalOffset;
- if (ArcStreamOffset != 0)
- InStream = op.stream;
- }
- return res;
-}
-
-HRESULT CArchiveLink::Open3(COpenOptions &op, IOpenCallbackUI *callbackUI)
-{
- HRESULT res = Open2(op, callbackUI);
- if (callbackUI)
- {
- RINOK(callbackUI->Open_Finished());
- }
- return res;
-}
-
-HRESULT CArchiveLink::ReOpen(COpenOptions &op)
-{
- if (Arcs.Size() > 1)
- return E_NOTIMPL;
-
- CObjectVector<COpenType> inc;
- CIntVector excl;
-
- op.types = &inc;
- op.excludedFormats = !
- op.stdInMode = false;
- op.stream = NULL;
- if (Arcs.Size() == 0) // ???
- return Open2(op, NULL);
-
- COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
- CMyComPtr<IArchiveOpenCallback> openCallbackNew = openCallbackSpec;
-
- openCallbackSpec->Callback = NULL;
- openCallbackSpec->ReOpenCallback = op.callback;
- {
- FString dirPrefix, fileName;
- NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), dirPrefix, fileName);
- openCallbackSpec->Init(dirPrefix, fileName);
- }
-
-
- CInFileStream *fileStreamSpec = new CInFileStream;
- CMyComPtr<IInStream> stream(fileStreamSpec);
- if (!fileStreamSpec->Open(us2fs(op.filePath)))
- return GetLastError();
- op.stream = stream;
-
- CArc &arc = Arcs[0];
- HRESULT res = arc.ReOpen(op);
-
- PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
- // Password = openCallbackSpec->Password;
-
- IsOpen = (res == S_OK);
- return res;
-}
-
-#ifndef _SFX
-
-bool ParseComplexSize(const wchar_t *s, UInt64 &result)
-{
- result = 0;
- const wchar_t *end;
- UInt64 number = ConvertStringToUInt64(s, &end);
- if (end == s)
- return false;
- if (*end == 0)
- {
- result = number;
- return true;
- }
- if (end[1] != 0)
- return false;
- unsigned numBits;
- switch (MyCharLower_Ascii(*end))
- {
- case 'b': result = number; return true;
- case 'k': numBits = 10; break;
- case 'm': numBits = 20; break;
- case 'g': numBits = 30; break;
- case 't': numBits = 40; break;
- default: return false;
- }
- if (number >= ((UInt64)1 << (64 - numBits)))
- return false;
- result = number << numBits;
- return true;
-}
-
-static bool ParseTypeParams(const UString &s, COpenType &type)
-{
- if (s[0] == 0)
- return true;
- if (s[1] == 0)
- {
- switch ((unsigned)(Byte)s[0])
- {
- case 'e': type.EachPos = true; return true;
- case 'a': type.CanReturnArc = true; return true;
- case 'r': type.Recursive = true; return true;
- }
- return false;
- }
- if (s[0] == 's')
- {
- UInt64 result;
- if (!ParseComplexSize(s.Ptr(1), result))
- return false;
- type.MaxStartOffset = result;
- type.MaxStartOffset_Defined = true;
- return true;
- }
-
- return false;
-}
-
-bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
-{
- int pos2 = s.Find(L':');
-
- {
- UString name;
- if (pos2 < 0)
- {
- name = s;
- pos2 = s.Len();
- }
- else
- {
- name = s.Left(pos2);
- pos2++;
- }
-
- int index = codecs.FindFormatForArchiveType(name);
- type.Recursive = false;
-
- if (index < 0)
- {
- if (name[0] == '*')
- {
- if (name[1] != 0)
- return false;
- }
- else if (name[0] == '#')
- {
- if (name[1] != 0)
- return false;
- type.CanReturnArc = false;
- type.CanReturnParser = true;
- }
- else
- return false;
- }
-
- type.FormatIndex = index;
-
- }
-
- for (unsigned i = pos2; i < s.Len();)
- {
- int next = s.Find(L':', i);
- if (next < 0)
- next = s.Len();
- const UString name = s.Mid(i, next - i);
- if (name.IsEmpty())
- return false;
- if (!ParseTypeParams(name, type))
- return false;
- i = next + 1;
- }
-
- return true;
-}
-
-bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types)
-{
- types.Clear();
- for (unsigned pos = 0; pos < s.Len();)
- {
- int pos2 = s.Find(L'.', pos);
- if (pos2 < 0)
- pos2 = s.Len();
- UString name = s.Mid(pos, pos2 - pos);
- if (name.IsEmpty())
- return false;
- COpenType type;
- if (!ParseType(codecs, name, type))
- return false;
- types.Add(type);
- pos = pos2 + 1;
- }
- return true;
-}
-
-#endif
+// OpenArchive.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/UTFConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "DefaultName.h"
+#include "OpenArchive.h"
+
+#ifndef Z7_SFX
+#include "SetProperties.h"
+#endif
+
+#ifndef Z7_SFX
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+#endif
+
+// increase it, if you need to support larger SFX stubs
+static const UInt64 kMaxCheckStartPosition = 1 << 23;
+
+/*
+Open:
+ - formatIndex >= 0 (exact Format)
+ 1) Open with main type. Archive handler is allowed to use archive start finder.
+ Warning, if there is tail.
+
+ - formatIndex = -1 (Parser:0) (default)
+ - same as #1 but doesn't return Parser
+
+ - formatIndex = -2 (#1)
+ - file has supported extension (like a.7z)
+ Open with that main type (only starting from start of file).
+ - open OK:
+ - if there is no tail - return OK
+ - if there is tail:
+ - archive is not "Self Exe" - return OK with Warning, that there is tail
+ - archive is "Self Exe"
+ ignore "Self Exe" stub, and tries to open tail
+ - tail can be open as archive - shows that archive and stub size property.
+ - tail can't be open as archive - shows Parser ???
+ - open FAIL:
+ Try to open with all other types from offset 0 only.
+ If some open type is OK and physical archive size is uequal or larger
+ than file size, then return that archive with warning that cannot be open as [extension type].
+ If extension was EXE, it will try to open as unknown_extension case
+ - file has unknown extension (like a.hhh)
+ It tries to open via parser code.
+ - if there is full archive or tail archive and unknown block or "Self Exe"
+ at front, it shows tail archive and stub size property.
+ - in another cases, if there is some archive inside file, it returns parser/
+ - in another cases, it retuens S_FALSE
+
+
+ - formatIndex = -3 (#2)
+ - same as #1, but
+ - stub (EXE) + archive is open in Parser
+
+ - formatIndex = -4 (#3)
+ - returns only Parser. skip full file archive. And show other sub-archives
+
+ - formatIndex = -5 (#4)
+ - returns only Parser. skip full file archive. And show other sub-archives for each byte pos
+
+*/
+
+
+
+
+using namespace NWindows;
+
+/*
+#ifdef Z7_SFX
+#define OPEN_PROPS_PARAM
+#else
+#define OPEN_PROPS_PARAM , props
+#endif
+*/
+
+/*
+CArc::~CArc()
+{
+ GetRawProps.Release();
+ Archive.Release();
+ printf("\nCArc::~CArc()\n");
+}
+*/
+
+#ifndef Z7_SFX
+
+namespace NArchive {
+namespace NParser {
+
+struct CParseItem
+{
+ UInt64 Offset;
+ UInt64 Size;
+ // UInt64 OkSize;
+ UString Name;
+ UString Extension;
+ FILETIME FileTime;
+ UString Comment;
+ UString ArcType;
+
+ bool FileTime_Defined;
+ bool UnpackSize_Defined;
+ bool NumSubDirs_Defined;
+ bool NumSubFiles_Defined;
+
+ bool IsSelfExe;
+ bool IsNotArcType;
+
+ UInt64 UnpackSize;
+ UInt64 NumSubDirs;
+ UInt64 NumSubFiles;
+
+ int FormatIndex;
+
+ bool LenIsUnknown;
+
+ CParseItem():
+ // OkSize(0),
+ FileTime_Defined(false),
+ UnpackSize_Defined(false),
+ NumSubDirs_Defined(false),
+ NumSubFiles_Defined(false),
+ IsSelfExe(false),
+ IsNotArcType(false),
+ LenIsUnknown(false)
+ {}
+
+ /*
+ bool IsEqualTo(const CParseItem &item) const
+ {
+ return Offset == item.Offset && Size == item.Size;
+ }
+ */
+
+ void NormalizeOffset()
+ {
+ if ((Int64)Offset < 0)
+ {
+ Size += Offset;
+ // OkSize += Offset;
+ Offset = 0;
+ }
+ }
+};
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+ IInArchiveGetStream
+)
+public:
+ CObjectVector<CParseItem> _items;
+ UInt64 _maxEndOffset;
+ CMyComPtr<IInStream> _stream;
+
+ UInt64 GetLastEnd() const
+ {
+ if (_items.IsEmpty())
+ return 0;
+ const CParseItem &back = _items.Back();
+ return back.Offset + back.Size;
+ }
+
+ void AddUnknownItem(UInt64 next);
+ int FindInsertPos(const CParseItem &item) const;
+ void AddItem(const CParseItem &item);
+
+ CHandler(): _maxEndOffset(0) {}
+};
+
+int CHandler::FindInsertPos(const CParseItem &item) const
+{
+ unsigned left = 0, right = _items.Size();
+ while (left != right)
+ {
+ const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const CParseItem &midItem = _items[mid];
+ if (item.Offset < midItem.Offset)
+ right = mid;
+ else if (item.Offset > midItem.Offset)
+ left = mid + 1;
+ else if (item.Size < midItem.Size)
+ right = mid;
+ /*
+ else if (item.Size > midItem.Size)
+ left = mid + 1;
+ */
+ else
+ {
+ left = mid + 1;
+ // return -1;
+ }
+ }
+ return (int)left;
+}
+
+void CHandler::AddUnknownItem(UInt64 next)
+{
+ /*
+ UInt64 prevEnd = 0;
+ if (!_items.IsEmpty())
+ {
+ const CParseItem &back = _items.Back();
+ prevEnd = back.Offset + back.Size;
+ }
+ */
+ if (_maxEndOffset < next)
+ {
+ CParseItem item2;
+ item2.Offset = _maxEndOffset;
+ item2.Size = next - _maxEndOffset;
+ _maxEndOffset = next;
+ _items.Add(item2);
+ }
+ else if (_maxEndOffset > next && !_items.IsEmpty())
+ {
+ CParseItem &back = _items.Back();
+ if (back.LenIsUnknown)
+ {
+ back.Size = next - back.Offset;
+ _maxEndOffset = next;
+ }
+ }
+}
+
+void CHandler::AddItem(const CParseItem &item)
+{
+ AddUnknownItem(item.Offset);
+ const int pos = FindInsertPos(item);
+ if (pos != -1)
+ {
+ _items.Insert((unsigned)pos, item);
+ UInt64 next = item.Offset + item.Size;
+ if (_maxEndOffset < next)
+ _maxEndOffset = next;
+ }
+}
+
+/*
+static const CStatProp kProps[] =
+{
+ { NULL, kpidPath, VT_BSTR},
+ { NULL, kpidSize, VT_UI8},
+ { NULL, kpidMTime, VT_FILETIME},
+ { NULL, kpidType, VT_BSTR},
+ { NULL, kpidComment, VT_BSTR},
+ { NULL, kpidOffset, VT_UI8},
+ { NULL, kpidUnpackSize, VT_UI8},
+// { NULL, kpidNumSubDirs, VT_UI8},
+};
+*/
+
+static const Byte kProps[] =
+{
+ kpidPath,
+ kpidSize,
+ kpidMTime,
+ kpidType,
+ kpidComment,
+ kpidOffset,
+ kpidUnpackSize
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps_NO
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* openArchiveCallback */))
+{
+ COM_TRY_BEGIN
+ {
+ Close();
+ _stream = stream;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+ _items.Clear();
+ _stream.Release();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+
+ const CParseItem &item = _items[index];
+
+ switch (propID)
+ {
+ case kpidPath:
+ {
+ char sz[32];
+ ConvertUInt32ToString(index + 1, sz);
+ UString s(sz);
+ if (!item.Name.IsEmpty())
+ {
+ s.Add_Dot();
+ s += item.Name;
+ }
+ if (!item.Extension.IsEmpty())
+ {
+ s.Add_Dot();
+ s += item.Extension;
+ }
+ prop = s; break;
+ }
+ case kpidSize:
+ case kpidPackSize: prop = item.Size; break;
+ case kpidOffset: prop = item.Offset; break;
+ case kpidUnpackSize: if (item.UnpackSize_Defined) prop = item.UnpackSize; break;
+ case kpidNumSubFiles: if (item.NumSubFiles_Defined) prop = item.NumSubFiles; break;
+ case kpidNumSubDirs: if (item.NumSubDirs_Defined) prop = item.NumSubDirs; break;
+ case kpidMTime: if (item.FileTime_Defined) prop = item.FileTime; break;
+ case kpidComment: if (!item.Comment.IsEmpty()) prop = item.Comment; break;
+ case kpidType: if (!item.ArcType.IsEmpty()) prop = item.ArcType; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+ Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+ COM_TRY_BEGIN
+
+ const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+ if (allFilesMode)
+ numItems = _items.Size();
+ if (_stream && numItems == 0)
+ return S_OK;
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ totalSize += _items[allFilesMode ? i : indices[i]].Size;
+ extractCallback->SetTotal(totalSize);
+
+ totalSize = 0;
+
+ CLocalProgress *lps = new CLocalProgress;
+ CMyComPtr<ICompressProgressInfo> progress = lps;
+ lps->Init(extractCallback, false);
+
+ CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
+ CMyComPtr<ISequentialInStream> inStream(streamSpec);
+ streamSpec->SetStream(_stream);
+
+ CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
+ CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+
+ NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+ CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+ for (i = 0; i < numItems; i++)
+ {
+ lps->InSize = totalSize;
+ lps->OutSize = totalSize;
+ RINOK(lps->SetCur())
+ CMyComPtr<ISequentialOutStream> realOutStream;
+ const Int32 askMode = testMode ?
+ NExtract::NAskMode::kTest :
+ NExtract::NAskMode::kExtract;
+ const UInt32 index = allFilesMode ? i : indices[i];
+ const CParseItem &item = _items[index];
+
+ RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+ UInt64 unpackSize = item.Size;
+ totalSize += unpackSize;
+ bool skipMode = false;
+ if (!testMode && !realOutStream)
+ continue;
+ RINOK(extractCallback->PrepareOperation(askMode))
+
+ outStreamSpec->SetStream(realOutStream);
+ realOutStream.Release();
+ outStreamSpec->Init(skipMode ? 0 : unpackSize, true);
+
+ Int32 opRes = NExtract::NOperationResult::kOK;
+ RINOK(InStream_SeekSet(_stream, item.Offset))
+ streamSpec->Init(unpackSize);
+ RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+
+ if (outStreamSpec->GetRem() != 0)
+ opRes = NExtract::NOperationResult::kDataError;
+ outStreamSpec->ReleaseStream();
+ RINOK(extractCallback->SetOperationResult(opRes))
+ }
+
+ return S_OK;
+
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+ COM_TRY_BEGIN
+ const CParseItem &item = _items[index];
+ return CreateLimitedInStream(_stream, item.Offset, item.Size, stream);
+ COM_TRY_END
+}
+
+}}
+
+#endif
+
+HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bool &result) throw()
+{
+ NCOM::CPropVariant prop;
+ result = false;
+ RINOK(arc->GetProperty(index, propID, &prop))
+ if (prop.vt == VT_BOOL)
+ result = VARIANT_BOOLToBool(prop.boolVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+HRESULT Archive_IsItem_Dir(IInArchive *arc, UInt32 index, bool &result) throw()
+{
+ return Archive_GetItemBoolProp(arc, index, kpidIsDir, result);
+}
+
+HRESULT Archive_IsItem_Aux(IInArchive *arc, UInt32 index, bool &result) throw()
+{
+ return Archive_GetItemBoolProp(arc, index, kpidIsAux, result);
+}
+
+HRESULT Archive_IsItem_AltStream(IInArchive *arc, UInt32 index, bool &result) throw()
+{
+ return Archive_GetItemBoolProp(arc, index, kpidIsAltStream, result);
+}
+
+HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &result) throw()
+{
+ return Archive_GetItemBoolProp(arc, index, kpidIsDeleted, result);
+}
+
+static HRESULT Archive_GetArcProp_Bool(IInArchive *arc, PROPID propid, bool &result) throw()
+{
+ NCOM::CPropVariant prop;
+ result = false;
+ RINOK(arc->GetArchiveProperty(propid, &prop))
+ if (prop.vt == VT_BOOL)
+ result = VARIANT_BOOLToBool(prop.boolVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+static HRESULT Archive_GetArcProp_UInt(IInArchive *arc, PROPID propid, UInt64 &result, bool &defined)
+{
+ defined = false;
+ NCOM::CPropVariant prop;
+ RINOK(arc->GetArchiveProperty(propid, &prop))
+ switch (prop.vt)
+ {
+ case VT_UI4: result = prop.ulVal; break;
+ case VT_I4: result = (UInt64)(Int64)prop.lVal; break;
+ case VT_UI8: result = (UInt64)prop.uhVal.QuadPart; break;
+ case VT_I8: result = (UInt64)prop.hVal.QuadPart; break;
+ case VT_EMPTY: return S_OK;
+ default: return E_FAIL;
+ }
+ defined = true;
+ return S_OK;
+}
+
+static HRESULT Archive_GetArcProp_Int(IInArchive *arc, PROPID propid, Int64 &result, bool &defined)
+{
+ defined = false;
+ NCOM::CPropVariant prop;
+ RINOK(arc->GetArchiveProperty(propid, &prop))
+ switch (prop.vt)
+ {
+ case VT_UI4: result = prop.ulVal; break;
+ case VT_I4: result = prop.lVal; break;
+ case VT_UI8: result = (Int64)prop.uhVal.QuadPart; break;
+ case VT_I8: result = (Int64)prop.hVal.QuadPart; break;
+ case VT_EMPTY: return S_OK;
+ default: return E_FAIL;
+ }
+ defined = true;
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+HRESULT CArc::GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const
+{
+ if (!GetRawProps)
+ return E_FAIL;
+ if (index == parent)
+ return S_OK;
+ UInt32 curIndex = index;
+
+ UString s;
+
+ bool prevWasAltStream = false;
+
+ for (;;)
+ {
+ #ifdef MY_CPU_LE
+ const void *p;
+ UInt32 size;
+ UInt32 propType;
+ RINOK(GetRawProps->GetRawProp(curIndex, kpidName, &p, &size, &propType))
+ if (p && propType == PROP_DATA_TYPE_wchar_t_PTR_Z_LE)
+ s = (const wchar_t *)p;
+ else
+ #endif
+ {
+ NCOM::CPropVariant prop;
+ RINOK(Archive->GetProperty(curIndex, kpidName, &prop))
+ if (prop.vt == VT_BSTR && prop.bstrVal)
+ s.SetFromBstr(prop.bstrVal);
+ else if (prop.vt == VT_EMPTY)
+ s.Empty();
+ else
+ return E_FAIL;
+ }
+
+ UInt32 curParent = (UInt32)(Int32)-1;
+ UInt32 parentType = 0;
+ RINOK(GetRawProps->GetParent(curIndex, &curParent, &parentType))
+
+ // 18.06: fixed : we don't want to split name to parts
+ /*
+ if (parentType != NParentType::kAltStream)
+ {
+ for (;;)
+ {
+ int pos = s.ReverseFind_PathSepar();
+ if (pos < 0)
+ {
+ break;
+ }
+ parts.Insert(0, s.Ptr(pos + 1));
+ s.DeleteFrom(pos);
+ }
+ }
+ */
+
+ parts.Insert(0, s);
+
+ if (prevWasAltStream)
+ {
+ {
+ UString &s2 = parts[parts.Size() - 2];
+ s2 += ':';
+ s2 += parts.Back();
+ }
+ parts.DeleteBack();
+ }
+
+ if (parent == curParent)
+ return S_OK;
+
+ prevWasAltStream = false;
+ if (parentType == NParentType::kAltStream)
+ prevWasAltStream = true;
+
+ if (curParent == (UInt32)(Int32)-1)
+ return E_FAIL;
+ curIndex = curParent;
+ }
+}
+
+#endif
+
+
+
+HRESULT CArc::GetItem_Path(UInt32 index, UString &result) const
+{
+ #ifdef MY_CPU_LE
+ if (GetRawProps)
+ {
+ const void *p;
+ UInt32 size;
+ UInt32 propType;
+ if (!IsTree)
+ {
+ if (GetRawProps->GetRawProp(index, kpidPath, &p, &size, &propType) == S_OK &&
+ propType == NPropDataType::kUtf16z)
+ {
+ unsigned len = size / 2 - 1;
+ // (len) doesn't include null terminator
+
+ /*
+ #if WCHAR_MAX > 0xffff
+ len = (unsigned)Utf16LE__Get_Num_WCHARs(p, len);
+
+ wchar_t *s = result.GetBuf(len);
+ wchar_t *sEnd = Utf16LE__To_WCHARs_Sep(p, len, s);
+ if (s + len != sEnd) return E_FAIL;
+ *sEnd = 0;
+
+ #else
+ */
+
+ wchar_t *s = result.GetBuf(len);
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = GetUi16(p);
+ p = (const void *)((const Byte *)p + 2);
+
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ if (c == L'/')
+ c = WCHAR_PATH_SEPARATOR;
+ else if (c == L'\\')
+ c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
+ #endif
+
+ *s++ = c;
+ }
+ *s = 0;
+
+ // #endif
+
+ result.ReleaseBuf_SetLen(len);
+
+ Convert_UnicodeEsc16_To_UnicodeEscHigh(result);
+ if (len != 0)
+ return S_OK;
+ }
+ }
+ /*
+ else if (GetRawProps->GetRawProp(index, kpidName, &p, &size, &propType) == S_OK &&
+ p && propType == NPropDataType::kUtf16z)
+ {
+ size -= 2;
+ UInt32 totalSize = size;
+ bool isOK = false;
+
+ {
+ UInt32 index2 = index;
+ for (;;)
+ {
+ UInt32 parent = (UInt32)(Int32)-1;
+ UInt32 parentType = 0;
+ if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
+ break;
+ if (parent == (UInt32)(Int32)-1)
+ {
+ if (parentType != 0)
+ totalSize += 2;
+ isOK = true;
+ break;
+ }
+ index2 = parent;
+ UInt32 size2;
+ const void *p2;
+ if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK &&
+ p2 && propType == NPropDataType::kUtf16z)
+ break;
+ totalSize += size2;
+ }
+ }
+
+ if (isOK)
+ {
+ wchar_t *sz = result.GetBuf_SetEnd(totalSize / 2);
+ UInt32 pos = totalSize - size;
+ memcpy((Byte *)sz + pos, p, size);
+ UInt32 index2 = index;
+ for (;;)
+ {
+ UInt32 parent = (UInt32)(Int32)-1;
+ UInt32 parentType = 0;
+ if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
+ break;
+ if (parent == (UInt32)(Int32)-1)
+ {
+ if (parentType != 0)
+ sz[pos / 2 - 1] = L':';
+ break;
+ }
+ index2 = parent;
+ UInt32 size2;
+ const void *p2;
+ if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK)
+ break;
+ pos -= size2;
+ memcpy((Byte *)sz + pos, p2, size2);
+ sz[(pos + size2 - 2) / 2] = (parentType == 0) ? WCHAR_PATH_SEPARATOR : L':';
+ }
+ #ifdef _WIN32
+ // result.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+ return S_OK;
+ }
+ }
+ */
+ }
+ #endif
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(Archive->GetProperty(index, kpidPath, &prop))
+ if (prop.vt == VT_BSTR && prop.bstrVal)
+ result.SetFromBstr(prop.bstrVal);
+ else if (prop.vt == VT_EMPTY)
+ result.Empty();
+ else
+ return E_FAIL;
+ }
+
+ if (result.IsEmpty())
+ return GetItem_DefaultPath(index, result);
+
+ Convert_UnicodeEsc16_To_UnicodeEscHigh(result);
+ return S_OK;
+}
+
+HRESULT CArc::GetItem_DefaultPath(UInt32 index, UString &result) const
+{
+ result.Empty();
+ bool isDir;
+ RINOK(Archive_IsItem_Dir(Archive, index, isDir))
+ if (!isDir)
+ {
+ result = DefaultName;
+ NCOM::CPropVariant prop;
+ RINOK(Archive->GetProperty(index, kpidExtension, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ result.Add_Dot();
+ result += prop.bstrVal;
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+HRESULT CArc::GetItem_Path2(UInt32 index, UString &result) const
+{
+ RINOK(GetItem_Path(index, result))
+ if (Ask_Deleted)
+ {
+ bool isDeleted = false;
+ RINOK(Archive_IsItem_Deleted(Archive, index, isDeleted))
+ if (isDeleted)
+ result.Insert(0, L"[DELETED]" WSTRING_PATH_SEPARATOR);
+ }
+ return S_OK;
+}
+
+#ifdef SUPPORT_ALT_STREAMS
+
+int FindAltStreamColon_in_Path(const wchar_t *path)
+{
+ unsigned i = 0;
+ int colonPos = -1;
+ for (;; i++)
+ {
+ wchar_t c = path[i];
+ if (c == 0)
+ return colonPos;
+ if (c == ':')
+ {
+ if (colonPos < 0)
+ colonPos = (int)i;
+ continue;
+ }
+ if (c == WCHAR_PATH_SEPARATOR)
+ colonPos = -1;
+ }
+}
+
+#endif
+
+HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
+{
+ #ifdef SUPPORT_ALT_STREAMS
+ item.IsAltStream = false;
+ item.AltStreamName.Empty();
+ item.MainPath.Empty();
+ #endif
+
+ item.IsDir = false;
+ item.Path.Empty();
+ item.ParentIndex = (UInt32)(Int32)-1;
+
+ item.PathParts.Clear();
+
+ RINOK(Archive_IsItem_Dir(Archive, index, item.IsDir))
+ item.MainIsDir = item.IsDir;
+
+ RINOK(GetItem_Path2(index, item.Path))
+
+ #ifndef Z7_SFX
+ UInt32 mainIndex = index;
+ #endif
+
+ #ifdef SUPPORT_ALT_STREAMS
+
+ item.MainPath = item.Path;
+ if (Ask_AltStream)
+ {
+ RINOK(Archive_IsItem_AltStream(Archive, index, item.IsAltStream))
+ }
+
+ bool needFindAltStream = false;
+
+ if (item.IsAltStream)
+ {
+ needFindAltStream = true;
+ if (GetRawProps)
+ {
+ UInt32 parentType = 0;
+ UInt32 parentIndex;
+ RINOK(GetRawProps->GetParent(index, &parentIndex, &parentType))
+ if (parentType == NParentType::kAltStream)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(Archive->GetProperty(index, kpidName, &prop))
+ if (prop.vt == VT_BSTR && prop.bstrVal)
+ item.AltStreamName.SetFromBstr(prop.bstrVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ else
+ {
+ // item.IsAltStream = false;
+ }
+ /*
+ if (item.AltStreamName.IsEmpty())
+ item.IsAltStream = false;
+ */
+
+ needFindAltStream = false;
+ item.ParentIndex = parentIndex;
+ mainIndex = parentIndex;
+
+ if (parentIndex == (UInt32)(Int32)-1)
+ {
+ item.MainPath.Empty();
+ item.MainIsDir = true;
+ }
+ else
+ {
+ RINOK(GetItem_Path2(parentIndex, item.MainPath))
+ RINOK(Archive_IsItem_Dir(Archive, parentIndex, item.MainIsDir))
+ }
+ }
+ }
+ }
+
+ if (item.WriteToAltStreamIfColon || needFindAltStream)
+ {
+ /* Good handler must support GetRawProps::GetParent for alt streams.
+ So the following code currently is not used */
+ int colon = FindAltStreamColon_in_Path(item.Path);
+ if (colon >= 0)
+ {
+ item.MainPath.DeleteFrom((unsigned)colon);
+ item.AltStreamName = item.Path.Ptr((unsigned)(colon + 1));
+ item.MainIsDir = (colon == 0 || IsPathSepar(item.Path[(unsigned)colon - 1]));
+ item.IsAltStream = true;
+ }
+ }
+
+ #endif
+
+ #ifndef Z7_SFX
+ if (item._use_baseParentFolder_mode)
+ {
+ RINOK(GetItem_PathToParent(mainIndex, (unsigned)item._baseParentFolder, item.PathParts))
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if ((item.WriteToAltStreamIfColon || needFindAltStream) && !item.PathParts.IsEmpty())
+ {
+ int colon;
+ {
+ UString &s = item.PathParts.Back();
+ colon = FindAltStreamColon_in_Path(s);
+ if (colon >= 0)
+ {
+ item.AltStreamName = s.Ptr((unsigned)(colon + 1));
+ item.MainIsDir = (colon == 0 || IsPathSepar(s[(unsigned)colon - 1]));
+ item.IsAltStream = true;
+ s.DeleteFrom((unsigned)colon);
+ }
+ }
+ if (colon == 0)
+ item.PathParts.DeleteBack();
+ }
+ #endif
+
+ }
+ else
+ #endif
+ SplitPathToParts(
+ #ifdef SUPPORT_ALT_STREAMS
+ item.MainPath
+ #else
+ item.Path
+ #endif
+ , item.PathParts);
+
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+static HRESULT Archive_GetItem_Size(IInArchive *archive, UInt32 index, UInt64 &size, bool &defined)
+{
+ NCOM::CPropVariant prop;
+ defined = false;
+ size = 0;
+ RINOK(archive->GetProperty(index, kpidSize, &prop))
+ switch (prop.vt)
+ {
+ case VT_UI1: size = prop.bVal; break;
+ case VT_UI2: size = prop.uiVal; break;
+ case VT_UI4: size = prop.ulVal; break;
+ case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
+ case VT_EMPTY: return S_OK;
+ default: return E_FAIL;
+ }
+ defined = true;
+ return S_OK;
+}
+
+#endif
+
+HRESULT CArc::GetItem_Size(UInt32 index, UInt64 &size, bool &defined) const
+{
+ NCOM::CPropVariant prop;
+ defined = false;
+ size = 0;
+ RINOK(Archive->GetProperty(index, kpidSize, &prop))
+ switch (prop.vt)
+ {
+ case VT_UI1: size = prop.bVal; break;
+ case VT_UI2: size = prop.uiVal; break;
+ case VT_UI4: size = prop.ulVal; break;
+ case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
+ case VT_EMPTY: return S_OK;
+ default: return E_FAIL;
+ }
+ defined = true;
+ return S_OK;
+}
+
+HRESULT CArc::GetItem_MTime(UInt32 index, CArcTime &at) const
+{
+ at.Clear();
+ NCOM::CPropVariant prop;
+ RINOK(Archive->GetProperty(index, kpidMTime, &prop))
+
+ if (prop.vt == VT_FILETIME)
+ {
+ /*
+ // for debug
+ if (FILETIME_IsZero(prop.at) && MTime.Def)
+ {
+ at = MTime;
+ return S_OK;
+ }
+ */
+ at.Set_From_Prop(prop);
+ if (at.Prec == 0)
+ {
+ // (at.Prec == 0) before version 22.
+ // so kpidTimeType is required for that code
+ prop.Clear();
+ RINOK(Archive->GetProperty(index, kpidTimeType, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ UInt32 val = prop.ulVal;
+ if (val == NFileTimeType::kWindows)
+ val = k_PropVar_TimePrec_100ns;
+ /*
+ else if (val > k_PropVar_TimePrec_1ns)
+ {
+ val = k_PropVar_TimePrec_100ns;
+ // val = k_PropVar_TimePrec_1ns;
+ // return E_FAIL; // for debug
+ }
+ */
+ at.Prec = (UInt16)val;
+ }
+ }
+ return S_OK;
+ }
+
+ if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ if (MTime.Def)
+ at = MTime;
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
+{
+ for (size_t i = 0; i < size; i++)
+ if (p1[i] != p2[i])
+ return false;
+ return true;
+}
+
+
+static void MakeCheckOrder(CCodecs *codecs,
+ CIntVector &orderIndices, unsigned numTypes, CIntVector &orderIndices2,
+ const Byte *data, size_t dataSize)
+{
+ for (unsigned i = 0; i < numTypes; i++)
+ {
+ const int index = orderIndices[i];
+ if (index < 0)
+ continue;
+ const CArcInfoEx &ai = codecs->Formats[(unsigned)index];
+ if (ai.SignatureOffset == 0)
+ {
+ if (ai.Signatures.IsEmpty())
+ {
+ if (dataSize != 0) // 21.04: no Signature means Empty Signature
+ continue;
+ }
+ else
+ {
+ unsigned k;
+ const CObjectVector<CByteBuffer> &sigs = ai.Signatures;
+ for (k = 0; k < sigs.Size(); k++)
+ {
+ const CByteBuffer &sig = sigs[k];
+ if (sig.Size() <= dataSize && TestSignature(data, sig, sig.Size()))
+ break;
+ }
+ if (k == sigs.Size())
+ continue;
+ }
+ }
+ orderIndices2.Add(index);
+ orderIndices[i] = -1;
+ }
+}
+
+#ifdef UNDER_CE
+ static const unsigned kNumHashBytes = 1;
+ #define HASH_VAL(buf) ((buf)[0])
+#else
+ static const unsigned kNumHashBytes = 2;
+ // #define HASH_VAL(buf) ((buf)[0] | ((UInt32)(buf)[1] << 8))
+ #define HASH_VAL(buf) GetUi16(buf)
+#endif
+
+static bool IsExeExt(const UString &ext)
+{
+ return ext.IsEqualTo_Ascii_NoCase("exe");
+}
+
+static const char * const k_PreArcFormats[] =
+{
+ "pe"
+ , "elf"
+ , "macho"
+ , "mub"
+ , "te"
+};
+
+static bool IsNameFromList(const UString &s, const char * const names[], size_t num)
+{
+ for (unsigned i = 0; i < num; i++)
+ if (StringsAreEqualNoCase_Ascii(s, names[i]))
+ return true;
+ return false;
+}
+
+
+static bool IsPreArcFormat(const CArcInfoEx &ai)
+{
+ if (ai.Flags_PreArc())
+ return true;
+ return IsNameFromList(ai.Name, k_PreArcFormats, Z7_ARRAY_SIZE(k_PreArcFormats));
+}
+
+static const char * const k_Formats_with_simple_signuature[] =
+{
+ "7z"
+ , "xz"
+ , "rar"
+ , "bzip2"
+ , "gzip"
+ , "cab"
+ , "wim"
+ , "rpm"
+ , "vhd"
+ , "xar"
+};
+
+static bool IsNewStyleSignature(const CArcInfoEx &ai)
+{
+ // if (ai.Version >= 0x91F)
+ if (ai.NewInterface)
+ return true;
+ return IsNameFromList(ai.Name, k_Formats_with_simple_signuature, Z7_ARRAY_SIZE(k_Formats_with_simple_signuature));
+}
+
+
+
+class CArchiveOpenCallback_Offset Z7_final:
+ public IArchiveOpenCallback,
+ public IArchiveOpenVolumeCallback,
+ #ifndef Z7_NO_CRYPTO
+ public ICryptoGetTextPassword,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IArchiveOpenCallback)
+ Z7_COM_QI_ENTRY(IArchiveOpenVolumeCallback)
+ #ifndef Z7_NO_CRYPTO
+ Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IArchiveOpenCallback)
+ Z7_IFACE_COM7_IMP(IArchiveOpenVolumeCallback)
+ #ifndef Z7_NO_CRYPTO
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ #endif
+
+public:
+ CMyComPtr<IArchiveOpenCallback> Callback;
+ CMyComPtr<IArchiveOpenVolumeCallback> OpenVolumeCallback;
+ UInt64 Files;
+ UInt64 Offset;
+
+ #ifndef Z7_NO_CRYPTO
+ CMyComPtr<ICryptoGetTextPassword> GetTextPassword;
+ #endif
+};
+
+#ifndef Z7_NO_CRYPTO
+Z7_COM7F_IMF(CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password))
+{
+ COM_TRY_BEGIN
+ if (GetTextPassword)
+ return GetTextPassword->CryptoGetTextPassword(password);
+ return E_NOTIMPL;
+ COM_TRY_END
+}
+#endif
+
+Z7_COM7F_IMF(CArchiveOpenCallback_Offset::SetTotal(const UInt64 *, const UInt64 *))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UInt64 *bytes))
+{
+ if (!Callback)
+ return S_OK;
+ UInt64 value = Offset;
+ if (bytes)
+ value += *bytes;
+ return Callback->SetCompleted(&Files, &value);
+}
+
+Z7_COM7F_IMF(CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT *value))
+{
+ if (OpenVolumeCallback)
+ return OpenVolumeCallback->GetProperty(propID, value);
+ NCOM::PropVariant_Clear(value);
+ return S_OK;
+ // return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CArchiveOpenCallback_Offset::GetStream(const wchar_t *name, IInStream **inStream))
+{
+ if (OpenVolumeCallback)
+ return OpenVolumeCallback->GetStream(name, inStream);
+ return S_FALSE;
+}
+
+#endif
+
+
+UInt32 GetOpenArcErrorFlags(const NCOM::CPropVariant &prop, bool *isDefinedProp)
+{
+ if (isDefinedProp != NULL)
+ *isDefinedProp = false;
+
+ switch (prop.vt)
+ {
+ case VT_UI8: if (isDefinedProp) *isDefinedProp = true; return (UInt32)prop.uhVal.QuadPart;
+ case VT_UI4: if (isDefinedProp) *isDefinedProp = true; return prop.ulVal;
+ case VT_EMPTY: return 0;
+ default: throw 151199;
+ }
+}
+
+void CArcErrorInfo::ClearErrors()
+{
+ // ErrorFormatIndex = -1; // we don't need to clear ErrorFormatIndex here !!!
+
+ ThereIsTail = false;
+ UnexpecedEnd = false;
+ IgnoreTail = false;
+ // NonZerosTail = false;
+ ErrorFlags_Defined = false;
+ ErrorFlags = 0;
+ WarningFlags = 0;
+ TailSize = 0;
+
+ ErrorMessage.Empty();
+ WarningMessage.Empty();
+}
+
+HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes)
+{
+ // OkPhySize_Defined = false;
+ PhySize_Defined = false;
+ PhySize = 0;
+ Offset = 0;
+ AvailPhySize = FileSize - startPos;
+
+ ErrorInfo.ClearErrors();
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidErrorFlags, &prop))
+ ErrorInfo.ErrorFlags = GetOpenArcErrorFlags(prop, &ErrorInfo.ErrorFlags_Defined);
+ }
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidWarningFlags, &prop))
+ ErrorInfo.WarningFlags = GetOpenArcErrorFlags(prop);
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidError, &prop))
+ if (prop.vt != VT_EMPTY)
+ ErrorInfo.ErrorMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown error");
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidWarning, &prop))
+ if (prop.vt != VT_EMPTY)
+ ErrorInfo.WarningMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown warning");
+ }
+
+ if (openRes == S_OK || ErrorInfo.IsArc_After_NonOpen())
+ {
+ RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, PhySize, PhySize_Defined))
+ /*
+ RINOK(Archive_GetArcProp_UInt(archive, kpidOkPhySize, OkPhySize, OkPhySize_Defined));
+ if (!OkPhySize_Defined)
+ {
+ OkPhySize_Defined = PhySize_Defined;
+ OkPhySize = PhySize;
+ }
+ */
+
+ bool offsetDefined;
+ RINOK(Archive_GetArcProp_Int(archive, kpidOffset, Offset, offsetDefined))
+
+ Int64 globalOffset = (Int64)startPos + Offset;
+ AvailPhySize = (UInt64)((Int64)FileSize - globalOffset);
+ if (PhySize_Defined)
+ {
+ UInt64 endPos = (UInt64)(globalOffset + (Int64)PhySize);
+ if (endPos < FileSize)
+ {
+ AvailPhySize = PhySize;
+ ErrorInfo.ThereIsTail = true;
+ ErrorInfo.TailSize = FileSize - endPos;
+ }
+ else if (endPos > FileSize)
+ ErrorInfo.UnexpecedEnd = true;
+ }
+ }
+
+ return S_OK;
+}
+
+/*
+static void PrintNumber(const char *s, int n)
+{
+ char temp[100];
+ sprintf(temp, "%s %d", s, n);
+ // OutputDebugStringA(temp);
+ printf(temp);
+}
+*/
+
+HRESULT CArc::PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyComPtr<IInArchive> &archive)
+{
+ // OutputDebugStringA("a1");
+ // PrintNumber("formatIndex", formatIndex);
+
+ RINOK(op.codecs->CreateInArchive(formatIndex, archive))
+ // OutputDebugStringA("a2");
+ if (!archive)
+ return S_OK;
+
+ #ifdef Z7_EXTERNAL_CODECS
+ if (op.codecs->NeedSetLibCodecs)
+ {
+ const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
+ if (ai.LibIndex >= 0 ?
+ !op.codecs->Libs[(unsigned)ai.LibIndex].SetCodecs :
+ !op.codecs->Libs.IsEmpty())
+ {
+ CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
+ archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
+ if (setCompressCodecsInfo)
+ {
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(op.codecs))
+ }
+ }
+ }
+ #endif
+
+
+ #ifndef Z7_SFX
+
+ const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
+
+ // OutputDebugStringW(ai.Name);
+ // OutputDebugStringA("a3");
+
+ if (ai.Flags_PreArc())
+ {
+ /* we notify parsers that extract executables, that they don't need
+ to open archive, if there is tail after executable (for SFX cases) */
+ CMyComPtr<IArchiveAllowTail> allowTail;
+ archive.QueryInterface(IID_IArchiveAllowTail, (void **)&allowTail);
+ if (allowTail)
+ allowTail->AllowTail(BoolToInt(true));
+ }
+
+ if (op.props)
+ {
+ /*
+ FOR_VECTOR (y, op.props)
+ {
+ const COptionalOpenProperties &optProps = (*op.props)[y];
+ if (optProps.FormatName.IsEmpty() || optProps.FormatName.CompareNoCase(ai.Name) == 0)
+ {
+ RINOK(SetProperties(archive, optProps.Props));
+ break;
+ }
+ }
+ */
+ RINOK(SetProperties(archive, *op.props))
+ }
+
+ #endif
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NArchive::NParser::CParseItem &pi)
+{
+ pi.Extension = ai.GetMainExt();
+ pi.FileTime_Defined = false;
+ pi.ArcType = ai.Name;
+
+ RINOK(Archive_GetArcProp_Bool(archive, kpidIsNotArcType, pi.IsNotArcType))
+
+ // RINOK(Archive_GetArcProp_Bool(archive, kpidIsSelfExe, pi.IsSelfExe));
+ pi.IsSelfExe = ai.Flags_PreArc();
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidMTime, &prop))
+ if (prop.vt == VT_FILETIME)
+ {
+ pi.FileTime_Defined = true;
+ pi.FileTime = prop.filetime;
+ }
+ }
+
+ if (!pi.FileTime_Defined)
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidCTime, &prop))
+ if (prop.vt == VT_FILETIME)
+ {
+ pi.FileTime_Defined = true;
+ pi.FileTime = prop.filetime;
+ }
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidName, &prop))
+ if (prop.vt == VT_BSTR)
+ {
+ pi.Name.SetFromBstr(prop.bstrVal);
+ pi.Extension.Empty();
+ }
+ else
+ {
+ RINOK(archive->GetArchiveProperty(kpidExtension, &prop))
+ if (prop.vt == VT_BSTR)
+ pi.Extension.SetFromBstr(prop.bstrVal);
+ }
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(kpidShortComment, &prop))
+ if (prop.vt == VT_BSTR)
+ pi.Comment.SetFromBstr(prop.bstrVal);
+ }
+
+
+ UInt32 numItems;
+ RINOK(archive->GetNumberOfItems(&numItems))
+
+ // pi.NumSubFiles = numItems;
+ // RINOK(Archive_GetArcProp_UInt(archive, kpidUnpackSize, pi.UnpackSize, pi.UnpackSize_Defined));
+ // if (!pi.UnpackSize_Defined)
+ {
+ pi.NumSubFiles = 0;
+ pi.NumSubDirs = 0;
+ pi.UnpackSize = 0;
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ UInt64 size = 0;
+ bool defined = false;
+ Archive_GetItem_Size(archive, i, size, defined);
+ if (defined)
+ {
+ pi.UnpackSize_Defined = true;
+ pi.UnpackSize += size;
+ }
+
+ bool isDir = false;
+ Archive_IsItem_Dir(archive, i, isDir);
+ if (isDir)
+ pi.NumSubDirs++;
+ else
+ pi.NumSubFiles++;
+ }
+ if (pi.NumSubDirs != 0)
+ pi.NumSubDirs_Defined = true;
+ pi.NumSubFiles_Defined = true;
+ }
+
+ return S_OK;
+}
+
+#endif
+
+HRESULT CArc::CheckZerosTail(const COpenOptions &op, UInt64 offset)
+{
+ if (!op.stream)
+ return S_OK;
+ RINOK(InStream_SeekSet(op.stream, offset))
+ const UInt32 kBufSize = 1 << 11;
+ Byte buf[kBufSize];
+
+ for (;;)
+ {
+ UInt32 processed = 0;
+ RINOK(op.stream->Read(buf, kBufSize, &processed))
+ if (processed == 0)
+ {
+ // ErrorInfo.NonZerosTail = false;
+ ErrorInfo.IgnoreTail = true;
+ return S_OK;
+ }
+ for (size_t i = 0; i < processed; i++)
+ {
+ if (buf[i] != 0)
+ {
+ // ErrorInfo.IgnoreTail = false;
+ // ErrorInfo.NonZerosTail = true;
+ return S_OK;
+ }
+ }
+ }
+}
+
+
+
+#ifndef Z7_SFX
+
+Z7_CLASS_IMP_COM_2(
+ CExtractCallback_To_OpenCallback
+ , IArchiveExtractCallback
+ , ICompressProgressInfo
+)
+ Z7_IFACE_COM7_IMP(IProgress)
+public:
+ CMyComPtr<IArchiveOpenCallback> Callback;
+ UInt64 Files;
+ UInt64 Offset;
+
+ void Init(IArchiveOpenCallback *callback)
+ {
+ Callback = callback;
+ Files = 0;
+ Offset = 0;
+ }
+};
+
+Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetTotal(UInt64 /* size */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetCompleted(const UInt64 * /* completeValue */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+{
+ if (Callback)
+ {
+ UInt64 value = Offset;
+ if (inSize)
+ value += *inSize;
+ return Callback->SetCompleted(&Files, &value);
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::GetStream(UInt32 /* index */, ISequentialOutStream **outStream, Int32 /* askExtractMode */))
+{
+ *outStream = NULL;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::PrepareOperation(Int32 /* askExtractMode */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetOperationResult(Int32 /* operationResult */))
+{
+ return S_OK;
+}
+
+
+static HRESULT OpenArchiveSpec(IInArchive *archive, bool needPhySize,
+ IInStream *stream, const UInt64 *maxCheckStartPosition,
+ IArchiveOpenCallback *openCallback,
+ IArchiveExtractCallback *extractCallback)
+{
+ /*
+ if (needPhySize)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpen2,
+ open2, archive)
+ if (open2)
+ return open2->ArcOpen2(stream, kOpenFlags_RealPhySize, openCallback);
+ }
+ */
+ RINOK(archive->Open(stream, maxCheckStartPosition, openCallback))
+ if (needPhySize)
+ {
+ bool phySize_Defined = false;
+ UInt64 phySize = 0;
+ RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, phySize, phySize_Defined))
+ if (phySize_Defined)
+ return S_OK;
+
+ bool phySizeCantBeDetected = false;
+ RINOK(Archive_GetArcProp_Bool(archive, kpidPhySizeCantBeDetected, phySizeCantBeDetected))
+
+ if (!phySizeCantBeDetected)
+ {
+ PRF(printf("\n-- !phySize_Defined after Open, call archive->Extract()"));
+ // It's for bzip2/gz and some xz archives, where Open operation doesn't know phySize.
+ // But the Handler will know phySize after full archive testing.
+ RINOK(archive->Extract(NULL, (UInt32)(Int32)-1, BoolToInt(true), extractCallback))
+ PRF(printf("\n-- OK"));
+ }
+ }
+ return S_OK;
+}
+
+
+
+static int FindFormatForArchiveType(CCodecs *codecs, CIntVector orderIndices, const char *name)
+{
+ FOR_VECTOR (i, orderIndices)
+ {
+ int oi = orderIndices[i];
+ if (oi >= 0)
+ if (StringsAreEqualNoCase_Ascii(codecs->Formats[(unsigned)oi].Name, name))
+ return (int)i;
+ }
+ return -1;
+}
+
+#endif
+
+HRESULT CArc::OpenStream2(const COpenOptions &op)
+{
+ // fprintf(stdout, "\nOpen: %S", Path); fflush(stdout);
+
+ Archive.Release();
+ GetRawProps.Release();
+ GetRootProps.Release();
+
+ ErrorInfo.ClearErrors();
+ ErrorInfo.ErrorFormatIndex = -1;
+
+ IsParseArc = false;
+ ArcStreamOffset = 0;
+
+ // OutputDebugStringA("1");
+ // OutputDebugStringW(Path);
+
+ const UString fileName = ExtractFileNameFromPath(Path);
+ UString extension;
+ {
+ const int dotPos = fileName.ReverseFind_Dot();
+ if (dotPos >= 0)
+ extension = fileName.Ptr((unsigned)(dotPos + 1));
+ }
+
+ CIntVector orderIndices;
+
+ bool searchMarkerInHandler = false;
+ #ifdef Z7_SFX
+ searchMarkerInHandler = true;
+ #endif
+
+ CBoolArr isMainFormatArr(op.codecs->Formats.Size());
+ {
+ FOR_VECTOR(i, op.codecs->Formats)
+ isMainFormatArr[i] = false;
+ }
+
+ const UInt64 maxStartOffset =
+ op.openType.MaxStartOffset_Defined ?
+ op.openType.MaxStartOffset :
+ kMaxCheckStartPosition;
+
+ #ifndef Z7_SFX
+ bool isUnknownExt = false;
+ #endif
+
+ #ifndef Z7_SFX
+ bool isForced = false;
+ #endif
+
+ unsigned numMainTypes = 0;
+ const int formatIndex = op.openType.FormatIndex;
+
+ if (formatIndex >= 0)
+ {
+ #ifndef Z7_SFX
+ isForced = true;
+ #endif
+ orderIndices.Add(formatIndex);
+ numMainTypes = 1;
+ isMainFormatArr[(unsigned)formatIndex] = true;
+
+ searchMarkerInHandler = true;
+ }
+ else
+ {
+ unsigned numFinded = 0;
+ #ifndef Z7_SFX
+ bool isPrearcExt = false;
+ #endif
+
+ {
+ #ifndef Z7_SFX
+
+ bool isZip = false;
+ bool isRar = false;
+
+ const wchar_t c = extension[0];
+ if (c == 'z' || c == 'Z' || c == 'r' || c == 'R')
+ {
+ bool isNumber = false;
+ for (unsigned k = 1;; k++)
+ {
+ const wchar_t d = extension[k];
+ if (d == 0)
+ break;
+ if (d < '0' || d > '9')
+ {
+ isNumber = false;
+ break;
+ }
+ isNumber = true;
+ }
+ if (isNumber)
+ {
+ if (c == 'z' || c == 'Z')
+ isZip = true;
+ else
+ isRar = true;
+ }
+ }
+
+ #endif
+
+ FOR_VECTOR (i, op.codecs->Formats)
+ {
+ const CArcInfoEx &ai = op.codecs->Formats[i];
+
+ if (IgnoreSplit || !op.openType.CanReturnArc)
+ if (ai.Is_Split())
+ continue;
+ if (op.excludedFormats->FindInSorted((int)i) >= 0)
+ continue;
+
+ #ifndef Z7_SFX
+ if (IsPreArcFormat(ai))
+ isPrearcExt = true;
+ #endif
+
+ if (ai.FindExtension(extension) >= 0
+ #ifndef Z7_SFX
+ || (isZip && ai.Is_Zip())
+ || (isRar && ai.Is_Rar())
+ #endif
+ )
+ {
+ // PrintNumber("orderIndices.Insert", i);
+ orderIndices.Insert(numFinded++, (int)i);
+ isMainFormatArr[i] = true;
+ }
+ else
+ orderIndices.Add((int)i);
+ }
+ }
+
+ if (!op.stream)
+ {
+ if (numFinded != 1)
+ return E_NOTIMPL;
+ orderIndices.DeleteFrom(1);
+ }
+ // PrintNumber("numFinded", numFinded );
+
+ /*
+ if (op.openOnlySpecifiedByExtension)
+ {
+ if (numFinded != 0 && !IsExeExt(extension))
+ orderIndices.DeleteFrom(numFinded);
+ }
+ */
+
+ #ifndef Z7_SFX
+
+ if (op.stream && orderIndices.Size() >= 2)
+ {
+ RINOK(InStream_SeekToBegin(op.stream))
+ CByteBuffer byteBuffer;
+ CIntVector orderIndices2;
+ if (numFinded == 0 || IsExeExt(extension))
+ {
+ // signature search was here
+ }
+ else if (extension.IsEqualTo("000") || extension.IsEqualTo("001"))
+ {
+ const int i = FindFormatForArchiveType(op.codecs, orderIndices, "rar");
+ if (i >= 0)
+ {
+ const size_t kBufSize = (1 << 10);
+ byteBuffer.Alloc(kBufSize);
+ size_t processedSize = kBufSize;
+ RINOK(ReadStream(op.stream, byteBuffer, &processedSize))
+ if (processedSize >= 16)
+ {
+ const Byte *buf = byteBuffer;
+ const Byte kRarHeader[] = { 0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 };
+ if (TestSignature(buf, kRarHeader, 7) && buf[9] == 0x73 && (buf[10] & 1) != 0)
+ {
+ orderIndices2.Add(orderIndices[(unsigned)i]);
+ orderIndices[(unsigned)i] = -1;
+ if (i >= (int)numFinded)
+ numFinded++;
+ }
+ }
+ }
+ }
+ else
+ {
+ const size_t kBufSize = (1 << 10);
+ byteBuffer.Alloc(kBufSize);
+ size_t processedSize = kBufSize;
+ RINOK(ReadStream(op.stream, byteBuffer, &processedSize))
+ if (processedSize == 0)
+ return S_FALSE;
+
+ /*
+ check type order:
+ 0) matched_extension && Backward
+ 1) matched_extension && (no_signuature || SignatureOffset != 0)
+ 2) matched_extension && (matched_signature)
+ // 3) no signuature
+ // 4) matched signuature
+ */
+ // we move index from orderIndices to orderIndices2 for priority handlers.
+
+ for (unsigned i = 0; i < numFinded; i++)
+ {
+ const int index = orderIndices[i];
+ if (index < 0)
+ continue;
+ const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
+ if (ai.Flags_BackwardOpen())
+ {
+ // backward doesn't need start signatures
+ orderIndices2.Add(index);
+ orderIndices[i] = -1;
+ }
+ }
+
+ MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, NULL, 0);
+ MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, byteBuffer, processedSize);
+ // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, NULL, 0);
+ // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, byteBuffer, processedSize);
+ }
+
+ FOR_VECTOR (i, orderIndices)
+ {
+ const int val = orderIndices[i];
+ if (val != -1)
+ orderIndices2.Add(val);
+ }
+ orderIndices = orderIndices2;
+ }
+
+ if (orderIndices.Size() >= 2)
+ {
+ const int iIso = FindFormatForArchiveType(op.codecs, orderIndices, "iso");
+ const int iUdf = FindFormatForArchiveType(op.codecs, orderIndices, "udf");
+ if (iUdf > iIso && iIso >= 0)
+ {
+ const int isoIndex = orderIndices[(unsigned)iIso];
+ const int udfIndex = orderIndices[(unsigned)iUdf];
+ orderIndices[(unsigned)iUdf] = isoIndex;
+ orderIndices[(unsigned)iIso] = udfIndex;
+ }
+ }
+
+ numMainTypes = numFinded;
+ isUnknownExt = (numMainTypes == 0) || isPrearcExt;
+
+ #else // Z7_SFX
+
+ numMainTypes = orderIndices.Size();
+
+ // we need correct numMainTypes for mutlivolume SFX (if some volume is missing)
+ if (numFinded != 0)
+ numMainTypes = numFinded;
+
+ #endif
+ }
+
+ UInt64 fileSize = 0;
+ if (op.stream)
+ {
+ RINOK(InStream_GetSize_SeekToBegin(op.stream, fileSize))
+ }
+ FileSize = fileSize;
+
+
+ #ifndef Z7_SFX
+
+ CBoolArr skipFrontalFormat(op.codecs->Formats.Size());
+ {
+ FOR_VECTOR(i, op.codecs->Formats)
+ skipFrontalFormat[i] = false;
+ }
+
+ #endif
+
+ const COpenType &mode = op.openType;
+
+
+
+
+
+ if (mode.CanReturnArc)
+ {
+ // ---------- OPEN main type by extenssion ----------
+
+ unsigned numCheckTypes = orderIndices.Size();
+ if (formatIndex >= 0)
+ numCheckTypes = numMainTypes;
+
+ for (unsigned i = 0; i < numCheckTypes; i++)
+ {
+ FormatIndex = orderIndices[i];
+
+ // orderIndices[] item cannot be negative here
+
+ bool exactOnly = false;
+
+ #ifndef Z7_SFX
+
+ const CArcInfoEx &ai = op.codecs->Formats[(unsigned)FormatIndex];
+ // OutputDebugStringW(ai.Name);
+ if (i >= numMainTypes)
+ {
+ // here we allow mismatched extension only for backward handlers
+ if (!ai.Flags_BackwardOpen()
+ // && !ai.Flags_PureStartOpen()
+ )
+ continue;
+ exactOnly = true;
+ }
+
+ #endif
+
+ // Some handlers do not set total bytes. So we set it here
+ if (op.callback)
+ RINOK(op.callback->SetTotal(NULL, &fileSize))
+
+ if (op.stream)
+ {
+ RINOK(InStream_SeekToBegin(op.stream))
+ }
+
+ CMyComPtr<IInArchive> archive;
+
+ RINOK(PrepareToOpen(op, (unsigned)FormatIndex, archive))
+ if (!archive)
+ continue;
+
+ HRESULT result;
+ if (op.stream)
+ {
+ UInt64 searchLimit = (!exactOnly && searchMarkerInHandler) ? maxStartOffset: 0;
+ result = archive->Open(op.stream, &searchLimit, op.callback);
+ }
+ else
+ {
+ CMyComPtr<IArchiveOpenSeq> openSeq;
+ archive.QueryInterface(IID_IArchiveOpenSeq, (void **)&openSeq);
+ if (!openSeq)
+ return E_NOTIMPL;
+ result = openSeq->OpenSeq(op.seqStream);
+ }
+
+ RINOK(ReadBasicProps(archive, 0, result))
+
+ if (result == S_FALSE)
+ {
+ bool isArc = ErrorInfo.IsArc_After_NonOpen();
+
+ #ifndef Z7_SFX
+ // if it's archive, we allow another open attempt for parser
+ if (!mode.CanReturnParser || !isArc)
+ skipFrontalFormat[(unsigned)FormatIndex] = true;
+ #endif
+
+ if (exactOnly)
+ continue;
+
+ if (i == 0 && numMainTypes == 1)
+ {
+ // we set NonOpenErrorInfo, only if there is only one main format (defined by extension).
+ ErrorInfo.ErrorFormatIndex = FormatIndex;
+ NonOpen_ErrorInfo = ErrorInfo;
+
+ if (!mode.CanReturnParser && isArc)
+ {
+ // if (formatIndex < 0 && !searchMarkerInHandler)
+ {
+ // if bad archive was detected, we don't need additional open attempts
+ #ifndef Z7_SFX
+ if (!IsPreArcFormat(ai) /* || !mode.SkipSfxStub */)
+ #endif
+ return S_FALSE;
+ }
+ }
+ }
+
+ /*
+ #ifndef Z7_SFX
+ if (IsExeExt(extension) || ai.Flags_PreArc())
+ {
+ // openOnlyFullArc = false;
+ // canReturnTailArc = true;
+ // limitSignatureSearch = true;
+ }
+ #endif
+ */
+
+ continue;
+ }
+
+ RINOK(result)
+
+ #ifndef Z7_SFX
+
+ bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
+ const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
+
+ bool thereIsTail = ErrorInfo.ThereIsTail;
+ if (thereIsTail && mode.ZerosTailIsAllowed)
+ {
+ RINOK(CheckZerosTail(op, (UInt64)(Offset + (Int64)PhySize)))
+ if (ErrorInfo.IgnoreTail)
+ thereIsTail = false;
+ }
+
+ if (Offset > 0)
+ {
+ if (exactOnly
+ || !searchMarkerInHandler
+ || !specFlags.CanReturn_NonStart()
+ || (mode.MaxStartOffset_Defined && (UInt64)Offset > mode.MaxStartOffset))
+ continue;
+ }
+ if (thereIsTail)
+ {
+ if (Offset > 0)
+ {
+ if (!specFlags.CanReturnMid)
+ continue;
+ }
+ else if (!specFlags.CanReturnFrontal)
+ continue;
+ }
+
+ if (Offset > 0 || thereIsTail)
+ {
+ if (formatIndex < 0)
+ {
+ if (IsPreArcFormat(ai))
+ {
+ // openOnlyFullArc = false;
+ // canReturnTailArc = true;
+ /*
+ if (mode.SkipSfxStub)
+ limitSignatureSearch = true;
+ */
+ // if (mode.SkipSfxStub)
+ {
+ // skipFrontalFormat[FormatIndex] = true;
+ continue;
+ }
+ }
+ }
+ }
+
+ #endif
+
+ Archive = archive;
+ return S_OK;
+ }
+ }
+
+
+
+ #ifndef Z7_SFX
+
+ if (!op.stream)
+ return S_FALSE;
+
+ if (formatIndex >= 0 && !mode.CanReturnParser)
+ {
+ if (mode.MaxStartOffset_Defined)
+ {
+ if (mode.MaxStartOffset == 0)
+ return S_FALSE;
+ }
+ else
+ {
+ const CArcInfoEx &ai = op.codecs->Formats[(unsigned)formatIndex];
+ if (ai.FindExtension(extension) >= 0)
+ {
+ if (ai.Flags_FindSignature() && searchMarkerInHandler)
+ return S_FALSE;
+ }
+ }
+ }
+
+ NArchive::NParser::CHandler *handlerSpec = new NArchive::NParser::CHandler;
+ CMyComPtr<IInArchive> handler = handlerSpec;
+
+ CExtractCallback_To_OpenCallback *extractCallback_To_OpenCallback_Spec = new CExtractCallback_To_OpenCallback;
+ CMyComPtr<IArchiveExtractCallback> extractCallback_To_OpenCallback = extractCallback_To_OpenCallback_Spec;
+ extractCallback_To_OpenCallback_Spec->Init(op.callback);
+
+ {
+ // ---------- Check all possible START archives ----------
+ // this code is better for full file archives than Parser's code.
+
+ CByteBuffer byteBuffer;
+ bool endOfFile = false;
+ size_t processedSize;
+ {
+ size_t bufSize = 1 << 20; // it must be larger than max signature offset or IsArcFunc offset ((1 << 19) + x for UDF)
+ if (bufSize > fileSize)
+ {
+ bufSize = (size_t)fileSize;
+ endOfFile = true;
+ }
+ byteBuffer.Alloc(bufSize);
+ RINOK(InStream_SeekToBegin(op.stream))
+ processedSize = bufSize;
+ RINOK(ReadStream(op.stream, byteBuffer, &processedSize))
+ if (processedSize == 0)
+ return S_FALSE;
+ if (processedSize < bufSize)
+ endOfFile = true;
+ }
+ CUIntVector sortedFormats;
+
+ unsigned i;
+
+ int splitIndex = -1;
+
+ for (i = 0; i < orderIndices.Size(); i++)
+ {
+ // orderIndices[] item cannot be negative here
+ unsigned form = (unsigned)orderIndices[i];
+ if (skipFrontalFormat[form])
+ continue;
+
+ const CArcInfoEx &ai = op.codecs->Formats[form];
+
+ if (ai.Is_Split())
+ {
+ splitIndex = (int)form;
+ continue;
+ }
+
+ if (ai.Flags_ByExtOnlyOpen())
+ continue;
+
+ if (ai.IsArcFunc)
+ {
+ UInt32 isArcRes = ai.IsArcFunc(byteBuffer, processedSize);
+ if (isArcRes == k_IsArc_Res_NO)
+ continue;
+ if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
+ continue;
+ // if (isArcRes == k_IsArc_Res_YES_LOW_PROB) continue;
+ sortedFormats.Insert(0, form);
+ continue;
+ }
+
+ const bool isNewStyleSignature = IsNewStyleSignature(ai);
+ bool needCheck = !isNewStyleSignature
+ || ai.Signatures.IsEmpty()
+ || ai.Flags_PureStartOpen()
+ || ai.Flags_StartOpen()
+ || ai.Flags_BackwardOpen();
+
+ if (isNewStyleSignature && !ai.Signatures.IsEmpty())
+ {
+ unsigned k;
+ for (k = 0; k < ai.Signatures.Size(); k++)
+ {
+ const CByteBuffer &sig = ai.Signatures[k];
+ if (processedSize < ai.SignatureOffset + sig.Size())
+ {
+ if (!endOfFile)
+ needCheck = true;
+ }
+ else if (TestSignature(sig, byteBuffer + ai.SignatureOffset, sig.Size()))
+ break;
+ }
+ if (k != ai.Signatures.Size())
+ {
+ sortedFormats.Insert(0, form);
+ continue;
+ }
+ }
+ if (needCheck)
+ sortedFormats.Add(form);
+ }
+
+ if (splitIndex >= 0)
+ sortedFormats.Insert(0, (unsigned)splitIndex);
+
+ for (i = 0; i < sortedFormats.Size(); i++)
+ {
+ FormatIndex = (int)sortedFormats[i];
+ const CArcInfoEx &ai = op.codecs->Formats[(unsigned)FormatIndex];
+
+ if (op.callback)
+ RINOK(op.callback->SetTotal(NULL, &fileSize))
+
+ RINOK(InStream_SeekToBegin(op.stream))
+
+ CMyComPtr<IInArchive> archive;
+ RINOK(PrepareToOpen(op, (unsigned)FormatIndex, archive))
+ if (!archive)
+ continue;
+
+ PRF(printf("\nSorted Open %S", (const wchar_t *)ai.Name));
+ HRESULT result;
+ {
+ UInt64 searchLimit = 0;
+ /*
+ if (mode.CanReturnArc)
+ result = archive->Open(op.stream, &searchLimit, op.callback);
+ else
+ */
+ // if (!CanReturnArc), it's ParserMode, and we need phy size
+ result = OpenArchiveSpec(archive,
+ !mode.CanReturnArc, // needPhySize
+ op.stream, &searchLimit, op.callback, extractCallback_To_OpenCallback);
+ }
+
+ if (result == S_FALSE)
+ {
+ skipFrontalFormat[(unsigned)FormatIndex] = true;
+ // FIXME: maybe we must use LenIsUnknown.
+ // printf(" OpenForSize Error");
+ continue;
+ }
+ RINOK(result)
+
+ RINOK(ReadBasicProps(archive, 0, result))
+
+ if (Offset > 0)
+ {
+ continue; // good handler doesn't return such Offset > 0
+ // but there are some cases like false prefixed PK00 archive, when
+ // we can support it?
+ }
+
+ NArchive::NParser::CParseItem pi;
+ pi.Offset = (UInt64)Offset;
+ pi.Size = AvailPhySize;
+
+ // bool needScan = false;
+
+ if (!PhySize_Defined)
+ {
+ // it's for Z format
+ pi.LenIsUnknown = true;
+ // needScan = true;
+ // phySize = arcRem;
+ // nextNeedCheckStartOpen = false;
+ }
+
+ /*
+ if (OkPhySize_Defined)
+ pi.OkSize = pi.OkPhySize;
+ else
+ pi.OkSize = pi.Size;
+ */
+
+ pi.NormalizeOffset();
+ // printf(" phySize = %8d", (unsigned)phySize);
+
+
+ if (mode.CanReturnArc)
+ {
+ const bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
+ const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
+ bool openCur = false;
+
+ if (!ErrorInfo.ThereIsTail)
+ openCur = true;
+ else
+ {
+ if (mode.ZerosTailIsAllowed)
+ {
+ RINOK(CheckZerosTail(op, (UInt64)(Offset + (Int64)PhySize)))
+ if (ErrorInfo.IgnoreTail)
+ openCur = true;
+ }
+ if (!openCur)
+ {
+ openCur = specFlags.CanReturnFrontal;
+ if (formatIndex < 0) // format is not forced
+ {
+ if (IsPreArcFormat(ai))
+ {
+ // if (mode.SkipSfxStub)
+ {
+ openCur = false;
+ }
+ }
+ }
+ }
+ }
+
+ if (openCur)
+ {
+ InStream = op.stream;
+ Archive = archive;
+ return S_OK;
+ }
+ }
+
+ skipFrontalFormat[(unsigned)FormatIndex] = true;
+
+
+ // if (!mode.CanReturnArc)
+ /*
+ if (!ErrorInfo.ThereIsTail)
+ continue;
+ */
+ if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
+ continue;
+
+ // printf("\nAdd offset = %d", (int)pi.Offset);
+ RINOK(ReadParseItemProps(archive, ai, pi))
+ handlerSpec->AddItem(pi);
+ }
+ }
+
+
+
+
+
+ // ---------- PARSER ----------
+
+ CUIntVector arc2sig; // formatIndex to signatureIndex
+ CUIntVector sig2arc; // signatureIndex to formatIndex;
+ {
+ unsigned sum = 0;
+ FOR_VECTOR (i, op.codecs->Formats)
+ {
+ arc2sig.Add(sum);
+ const CObjectVector<CByteBuffer> &sigs = op.codecs->Formats[i].Signatures;
+ sum += sigs.Size();
+ FOR_VECTOR (k, sigs)
+ sig2arc.Add(i);
+ }
+ }
+
+ {
+ const size_t kBeforeSize = 1 << 16;
+ const size_t kAfterSize = 1 << 20;
+ const size_t kBufSize = 1 << 22; // it must be more than kBeforeSize + kAfterSize
+
+ const UInt32 kNumVals = (UInt32)1 << (kNumHashBytes * 8);
+ CByteArr hashBuffer(kNumVals);
+ Byte *hash = hashBuffer;
+ memset(hash, 0xFF, kNumVals);
+ Byte prevs[256];
+ memset(prevs, 0xFF, sizeof(prevs));
+ if (sig2arc.Size() >= 0xFF)
+ return S_FALSE;
+
+ CUIntVector difficultFormats;
+ CBoolArr difficultBools(256);
+ {
+ for (unsigned i = 0; i < 256; i++)
+ difficultBools[i] = false;
+ }
+
+ bool thereAreHandlersForSearch = false;
+
+ // UInt32 maxSignatureEnd = 0;
+
+ FOR_VECTOR (i, orderIndices)
+ {
+ int index = orderIndices[i];
+ if (index < 0)
+ continue;
+ const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
+ if (ai.Flags_ByExtOnlyOpen())
+ continue;
+ bool isDifficult = false;
+ // if (ai.Version < 0x91F) // we don't use parser with old DLL (before 9.31)
+ if (!ai.NewInterface)
+ isDifficult = true;
+ else
+ {
+ if (ai.Flags_StartOpen())
+ isDifficult = true;
+ FOR_VECTOR (k, ai.Signatures)
+ {
+ const CByteBuffer &sig = ai.Signatures[k];
+ /*
+ UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
+ if (maxSignatureEnd < signatureEnd)
+ maxSignatureEnd = signatureEnd;
+ */
+ if (sig.Size() < kNumHashBytes)
+ {
+ isDifficult = true;
+ continue;
+ }
+ thereAreHandlersForSearch = true;
+ UInt32 v = HASH_VAL(sig);
+ unsigned sigIndex = arc2sig[(unsigned)index] + k;
+ prevs[sigIndex] = hash[v];
+ hash[v] = (Byte)sigIndex;
+ }
+ }
+ if (isDifficult)
+ {
+ difficultFormats.Add((unsigned)index);
+ difficultBools[(unsigned)index] = true;
+ }
+ }
+
+ if (!thereAreHandlersForSearch)
+ {
+ // openOnlyFullArc = true;
+ // canReturnTailArc = true;
+ }
+
+ RINOK(InStream_SeekToBegin(op.stream))
+
+ CLimitedCachedInStream *limitedStreamSpec = new CLimitedCachedInStream;
+ CMyComPtr<IInStream> limitedStream = limitedStreamSpec;
+ limitedStreamSpec->SetStream(op.stream);
+
+ CArchiveOpenCallback_Offset *openCallback_Offset_Spec = NULL;
+ CMyComPtr<IArchiveOpenCallback> openCallback_Offset;
+ if (op.callback)
+ {
+ openCallback_Offset_Spec = new CArchiveOpenCallback_Offset;
+ openCallback_Offset = openCallback_Offset_Spec;
+ openCallback_Offset_Spec->Callback = op.callback;
+ openCallback_Offset_Spec->Callback.QueryInterface(IID_IArchiveOpenVolumeCallback, &openCallback_Offset_Spec->OpenVolumeCallback);
+ #ifndef Z7_NO_CRYPTO
+ openCallback_Offset_Spec->Callback.QueryInterface(IID_ICryptoGetTextPassword, &openCallback_Offset_Spec->GetTextPassword);
+ #endif
+ }
+
+ if (op.callback)
+ RINOK(op.callback->SetTotal(NULL, &fileSize))
+
+ CByteBuffer &byteBuffer = limitedStreamSpec->Buffer;
+ byteBuffer.Alloc(kBufSize);
+
+ UInt64 callbackPrev = 0;
+ bool needCheckStartOpen = true; // = true, if we need to test all archives types for current pos.
+
+ bool endOfFile = false;
+ UInt64 bufPhyPos = 0;
+ size_t bytesInBuf = 0;
+ // UInt64 prevPos = 0;
+
+ // ---------- Main Scan Loop ----------
+
+ UInt64 pos = 0;
+
+ if (!mode.EachPos && handlerSpec->_items.Size() == 1)
+ {
+ NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
+ if (!pi.LenIsUnknown && pi.Offset == 0)
+ pos = pi.Size;
+ }
+
+ for (;;)
+ {
+ // printf("\nPos = %d", (int)pos);
+ UInt64 posInBuf = pos - bufPhyPos;
+
+ // if (pos > ((UInt64)1 << 35)) break;
+
+ if (!endOfFile)
+ {
+ if (bytesInBuf < kBufSize)
+ {
+ size_t processedSize = kBufSize - bytesInBuf;
+ // printf("\nRead ask = %d", (unsigned)processedSize);
+ UInt64 seekPos = bufPhyPos + bytesInBuf;
+ RINOK(InStream_SeekSet(op.stream, bufPhyPos + bytesInBuf))
+ RINOK(ReadStream(op.stream, byteBuffer + bytesInBuf, &processedSize))
+ // printf(" processed = %d", (unsigned)processedSize);
+ if (processedSize == 0)
+ {
+ fileSize = seekPos;
+ endOfFile = true;
+ }
+ else
+ {
+ bytesInBuf += processedSize;
+ limitedStreamSpec->SetCache(processedSize, (size_t)bufPhyPos);
+ }
+ continue;
+ }
+
+ if (bytesInBuf < posInBuf)
+ {
+ UInt64 skipSize = posInBuf - bytesInBuf;
+ if (skipSize <= kBeforeSize)
+ {
+ size_t keepSize = (size_t)(kBeforeSize - skipSize);
+ // printf("\nmemmove skip = %d", (int)keepSize);
+ memmove(byteBuffer, byteBuffer + bytesInBuf - keepSize, keepSize);
+ bytesInBuf = keepSize;
+ bufPhyPos = pos - keepSize;
+ continue;
+ }
+ // printf("\nSkip %d", (int)(skipSize - kBeforeSize));
+ // RINOK(op.stream->Seek(skipSize - kBeforeSize, STREAM_SEEK_CUR, NULL));
+ bytesInBuf = 0;
+ bufPhyPos = pos - kBeforeSize;
+ continue;
+ }
+
+ if (bytesInBuf - posInBuf < kAfterSize)
+ {
+ size_t beg = (size_t)posInBuf - kBeforeSize;
+ // printf("\nmemmove for after beg = %d", (int)beg);
+ memmove(byteBuffer, byteBuffer + beg, bytesInBuf - beg);
+ bufPhyPos += beg;
+ bytesInBuf -= beg;
+ continue;
+ }
+ }
+
+ if (bytesInBuf <= (size_t)posInBuf)
+ break;
+
+ bool useOffsetCallback = false;
+ if (openCallback_Offset)
+ {
+ openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
+ openCallback_Offset_Spec->Offset = pos;
+
+ useOffsetCallback = (!op.openType.CanReturnArc || handlerSpec->_items.Size() > 1);
+
+ if (pos >= callbackPrev + (1 << 23))
+ {
+ RINOK(openCallback_Offset->SetCompleted(NULL, NULL))
+ callbackPrev = pos;
+ }
+ }
+
+ {
+ UInt64 endPos = bufPhyPos + bytesInBuf;
+ if (fileSize < endPos)
+ {
+ FileSize = fileSize; // why ????
+ fileSize = endPos;
+ }
+ }
+
+ const size_t availSize = bytesInBuf - (size_t)posInBuf;
+ if (availSize < kNumHashBytes)
+ break;
+ size_t scanSize = availSize -
+ ((availSize >= kAfterSize) ? kAfterSize : kNumHashBytes);
+
+ {
+ /*
+ UInt64 scanLimit = openOnlyFullArc ?
+ maxSignatureEnd :
+ op.openType.ScanSize + maxSignatureEnd;
+ */
+ if (!mode.CanReturnParser)
+ {
+ if (pos > maxStartOffset)
+ break;
+ UInt64 remScan = maxStartOffset - pos;
+ if (scanSize > remScan)
+ scanSize = (size_t)remScan;
+ }
+ }
+
+ scanSize++;
+
+ const Byte *buf = byteBuffer + (size_t)posInBuf;
+ const Byte *bufLimit = buf + scanSize;
+ size_t ppp = 0;
+
+ if (!needCheckStartOpen)
+ {
+ for (; buf < bufLimit && hash[HASH_VAL(buf)] == 0xFF; buf++);
+ ppp = (size_t)(buf - (byteBuffer + (size_t)posInBuf));
+ pos += ppp;
+ if (buf == bufLimit)
+ continue;
+ }
+
+ UInt32 v = HASH_VAL(buf);
+ bool nextNeedCheckStartOpen = true;
+ unsigned i = hash[v];
+ unsigned indexOfDifficult = 0;
+
+ // ---------- Open Loop for Current Pos ----------
+ bool wasOpen = false;
+
+ for (;;)
+ {
+ unsigned index;
+ bool isDifficult;
+ if (needCheckStartOpen && indexOfDifficult < difficultFormats.Size())
+ {
+ index = difficultFormats[indexOfDifficult++];
+ isDifficult = true;
+ }
+ else
+ {
+ if (i == 0xFF)
+ break;
+ index = sig2arc[i];
+ unsigned sigIndex = i - arc2sig[index];
+ i = prevs[i];
+ if (needCheckStartOpen && difficultBools[index])
+ continue;
+ const CArcInfoEx &ai = op.codecs->Formats[index];
+
+ if (pos < ai.SignatureOffset)
+ continue;
+
+ /*
+ if (openOnlyFullArc)
+ if (pos != ai.SignatureOffset)
+ continue;
+ */
+
+ const CByteBuffer &sig = ai.Signatures[sigIndex];
+
+ if (ppp + sig.Size() > availSize
+ || !TestSignature(buf, sig, sig.Size()))
+ continue;
+ // printf("\nSignature OK: %10S %8x %5d", (const wchar_t *)ai.Name, (int)pos, (int)(pos - prevPos));
+ // prevPos = pos;
+ isDifficult = false;
+ }
+
+ const CArcInfoEx &ai = op.codecs->Formats[index];
+
+
+ if ((isDifficult && pos == 0) || ai.SignatureOffset == pos)
+ {
+ // we don't check same archive second time */
+ if (skipFrontalFormat[index])
+ continue;
+ }
+
+ UInt64 startArcPos = pos;
+ if (!isDifficult)
+ {
+ if (pos < ai.SignatureOffset)
+ continue;
+ startArcPos = pos - ai.SignatureOffset;
+ /*
+ // we don't need the check for Z files
+ if (startArcPos < handlerSpec->GetLastEnd())
+ continue;
+ */
+ }
+
+ if (ai.IsArcFunc && startArcPos >= bufPhyPos)
+ {
+ const size_t offsetInBuf = (size_t)(startArcPos - bufPhyPos);
+ if (offsetInBuf < bytesInBuf)
+ {
+ const UInt32 isArcRes = ai.IsArcFunc(byteBuffer + offsetInBuf, bytesInBuf - offsetInBuf);
+ if (isArcRes == k_IsArc_Res_NO)
+ continue;
+ if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
+ continue;
+ /*
+ if (isArcRes == k_IsArc_Res_YES_LOW_PROB)
+ {
+ // if (pos != ai.SignatureOffset)
+ continue;
+ }
+ */
+ }
+ // printf("\nIsArc OK: %S", (const wchar_t *)ai.Name);
+ }
+
+ PRF(printf("\npos = %9I64d : %S", pos, (const wchar_t *)ai.Name));
+
+ const bool isMainFormat = isMainFormatArr[index];
+ const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
+
+ CMyComPtr<IInArchive> archive;
+ RINOK(PrepareToOpen(op, index, archive))
+ if (!archive)
+ return E_FAIL;
+
+ // OutputDebugStringW(ai.Name);
+
+ const UInt64 rem = fileSize - startArcPos;
+
+ UInt64 arcStreamOffset = 0;
+
+ if (ai.Flags_UseGlobalOffset())
+ {
+ RINOK(limitedStreamSpec->InitAndSeek(0, fileSize))
+ RINOK(InStream_SeekSet(limitedStream, startArcPos))
+ }
+ else
+ {
+ RINOK(limitedStreamSpec->InitAndSeek(startArcPos, rem))
+ arcStreamOffset = startArcPos;
+ }
+
+ UInt64 maxCheckStartPosition = 0;
+
+ if (openCallback_Offset)
+ {
+ openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
+ openCallback_Offset_Spec->Offset = startArcPos;
+ }
+
+ // HRESULT result = archive->Open(limitedStream, &maxCheckStartPosition, openCallback_Offset);
+ extractCallback_To_OpenCallback_Spec->Files = 0;
+ extractCallback_To_OpenCallback_Spec->Offset = startArcPos;
+
+ HRESULT result = OpenArchiveSpec(archive,
+ true, // needPhySize
+ limitedStream, &maxCheckStartPosition,
+ useOffsetCallback ? (IArchiveOpenCallback *)openCallback_Offset : (IArchiveOpenCallback *)op.callback,
+ extractCallback_To_OpenCallback);
+
+ RINOK(ReadBasicProps(archive, ai.Flags_UseGlobalOffset() ? 0 : startArcPos, result))
+
+ bool isOpen = false;
+
+ if (result == S_FALSE)
+ {
+ if (!mode.CanReturnParser)
+ {
+ if (formatIndex < 0 && ErrorInfo.IsArc_After_NonOpen())
+ {
+ ErrorInfo.ErrorFormatIndex = (int)index;
+ NonOpen_ErrorInfo = ErrorInfo;
+ // if archive was detected, we don't need additional open attempts
+ return S_FALSE;
+ }
+ continue;
+ }
+ if (!ErrorInfo.IsArc_After_NonOpen() || !PhySize_Defined || PhySize == 0)
+ continue;
+ }
+ else
+ {
+ if (PhySize_Defined && PhySize == 0)
+ {
+ PRF(printf(" phySize_Defined && PhySize == 0 "));
+ // we skip that epmty archive case with unusual unexpected (PhySize == 0) from Code function.
+ continue;
+ }
+ isOpen = true;
+ RINOK(result)
+ PRF(printf(" OK "));
+ }
+
+ // fprintf(stderr, "\n %8X %S", startArcPos, Path);
+ // printf("\nOpen OK: %S", ai.Name);
+
+
+ NArchive::NParser::CParseItem pi;
+ pi.Offset = startArcPos;
+
+ if (ai.Flags_UseGlobalOffset())
+ pi.Offset = (UInt64)Offset;
+ else if (Offset != 0)
+ return E_FAIL;
+
+ const UInt64 arcRem = FileSize - pi.Offset;
+ UInt64 phySize = arcRem;
+ const bool phySize_Defined = PhySize_Defined;
+ if (phySize_Defined)
+ {
+ if (pi.Offset + PhySize > FileSize)
+ {
+ // ErrorInfo.ThereIsTail = true;
+ PhySize = FileSize - pi.Offset;
+ }
+ phySize = PhySize;
+ }
+ if (phySize == 0 || (UInt64)phySize > ((UInt64)1 << 63))
+ return E_FAIL;
+
+ /*
+ if (!ai.UseGlobalOffset)
+ {
+ if (phySize > arcRem)
+ {
+ ThereIsTail = true;
+ phySize = arcRem;
+ }
+ }
+ */
+
+ bool needScan = false;
+
+
+ if (isOpen && !phySize_Defined)
+ {
+ // it's for Z format, or bzip2,gz,xz with phySize that was not detected
+ pi.LenIsUnknown = true;
+ needScan = true;
+ phySize = arcRem;
+ nextNeedCheckStartOpen = false;
+ }
+
+ pi.Size = phySize;
+ /*
+ if (OkPhySize_Defined)
+ pi.OkSize = OkPhySize;
+ */
+ pi.NormalizeOffset();
+ // printf(" phySize = %8d", (unsigned)phySize);
+
+ /*
+ if (needSkipFullArc)
+ if (pi.Offset == 0 && phySize_Defined && pi.Size >= fileSize)
+ continue;
+ */
+ if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
+ {
+ // it's possible for dmg archives
+ if (!mode.CanReturnArc)
+ continue;
+ }
+
+ if (mode.EachPos)
+ pos++;
+ else if (needScan)
+ {
+ pos++;
+ /*
+ if (!OkPhySize_Defined)
+ pos++;
+ else
+ pos = pi.Offset + pi.OkSize;
+ */
+ }
+ else
+ pos = pi.Offset + pi.Size;
+
+
+ RINOK(ReadParseItemProps(archive, ai, pi))
+
+ if (pi.Offset < startArcPos && !mode.EachPos /* && phySize_Defined */)
+ {
+ /* It's for DMG format.
+ This code deletes all previous items that are included to current item */
+
+ while (!handlerSpec->_items.IsEmpty())
+ {
+ {
+ const NArchive::NParser::CParseItem &back = handlerSpec->_items.Back();
+ if (back.Offset < pi.Offset)
+ break;
+ if (back.Offset + back.Size > pi.Offset + pi.Size)
+ break;
+ }
+ handlerSpec->_items.DeleteBack();
+ }
+ }
+
+
+ if (isOpen && mode.CanReturnArc && phySize_Defined)
+ {
+ // if (pi.Offset + pi.Size >= fileSize)
+ bool openCur = false;
+
+ bool thereIsTail = ErrorInfo.ThereIsTail;
+ if (thereIsTail && mode.ZerosTailIsAllowed)
+ {
+ RINOK(CheckZerosTail(op, (UInt64)((Int64)arcStreamOffset + Offset + (Int64)PhySize)))
+ if (ErrorInfo.IgnoreTail)
+ thereIsTail = false;
+ }
+
+ if (pi.Offset != 0)
+ {
+ if (!pi.IsNotArcType)
+ {
+ if (thereIsTail)
+ openCur = specFlags.CanReturnMid;
+ else
+ openCur = specFlags.CanReturnTail;
+ }
+ }
+ else
+ {
+ if (!thereIsTail)
+ openCur = true;
+ else
+ openCur = specFlags.CanReturnFrontal;
+
+ if (formatIndex >= -2)
+ openCur = true;
+ }
+
+ if (formatIndex < 0 && pi.IsSelfExe /* && mode.SkipSfxStub */)
+ openCur = false;
+
+ // We open file as SFX, if there is front archive or first archive is "Self Executable"
+ if (!openCur && !pi.IsSelfExe && !thereIsTail &&
+ (!pi.IsNotArcType || pi.Offset == 0))
+ {
+ if (handlerSpec->_items.IsEmpty())
+ {
+ if (specFlags.CanReturnTail)
+ openCur = true;
+ }
+ else if (handlerSpec->_items.Size() == 1)
+ {
+ if (handlerSpec->_items[0].IsSelfExe)
+ {
+ if (mode.SpecUnknownExt.CanReturnTail)
+ openCur = true;
+ }
+ }
+ }
+
+ if (openCur)
+ {
+ InStream = op.stream;
+ Archive = archive;
+ FormatIndex = (int)index;
+ ArcStreamOffset = arcStreamOffset;
+ return S_OK;
+ }
+ }
+
+ /*
+ if (openOnlyFullArc)
+ {
+ ErrorInfo.ClearErrors();
+ return S_FALSE;
+ }
+ */
+
+ pi.FormatIndex = (int)index;
+
+ // printf("\nAdd offset = %d", (int)pi.Offset);
+ handlerSpec->AddItem(pi);
+ wasOpen = true;
+ break;
+ }
+ // ---------- End of Open Loop for Current Pos ----------
+
+ if (!wasOpen)
+ pos++;
+ needCheckStartOpen = (nextNeedCheckStartOpen && wasOpen);
+ }
+ // ---------- End of Main Scan Loop ----------
+
+ /*
+ if (handlerSpec->_items.Size() == 1)
+ {
+ const NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
+ if (pi.Size == fileSize && pi.Offset == 0)
+ {
+ Archive = archive;
+ FormatIndex2 = pi.FormatIndex;
+ return S_OK;
+ }
+ }
+ */
+
+ if (mode.CanReturnParser)
+ {
+ bool returnParser = (handlerSpec->_items.Size() == 1); // it's possible if fileSize was not correct at start of parsing
+ handlerSpec->AddUnknownItem(fileSize);
+ if (handlerSpec->_items.Size() == 0)
+ return S_FALSE;
+ if (returnParser || handlerSpec->_items.Size() != 1)
+ {
+ // return S_FALSE;
+ handlerSpec->_stream = op.stream;
+ Archive = handler;
+ ErrorInfo.ClearErrors();
+ IsParseArc = true;
+ FormatIndex = -1; // It's parser
+ Offset = 0;
+ return S_OK;
+ }
+ }
+ }
+
+ #endif
+
+ if (!Archive)
+ return S_FALSE;
+ return S_OK;
+}
+
+
+
+
+HRESULT CArc::OpenStream(const COpenOptions &op)
+{
+ RINOK(OpenStream2(op))
+ // PrintNumber("op.formatIndex 3", op.formatIndex);
+
+ if (Archive)
+ {
+ GetRawProps.Release();
+ GetRootProps.Release();
+ Archive->QueryInterface(IID_IArchiveGetRawProps, (void **)&GetRawProps);
+ Archive->QueryInterface(IID_IArchiveGetRootProps, (void **)&GetRootProps);
+
+ RINOK(Archive_GetArcProp_Bool(Archive, kpidIsTree, IsTree))
+ RINOK(Archive_GetArcProp_Bool(Archive, kpidIsDeleted, Ask_Deleted))
+ RINOK(Archive_GetArcProp_Bool(Archive, kpidIsAltStream, Ask_AltStream))
+ RINOK(Archive_GetArcProp_Bool(Archive, kpidIsAux, Ask_Aux))
+ RINOK(Archive_GetArcProp_Bool(Archive, kpidINode, Ask_INode))
+ RINOK(Archive_GetArcProp_Bool(Archive, kpidReadOnly, IsReadOnly))
+
+ const UString fileName = ExtractFileNameFromPath(Path);
+ UString extension;
+ {
+ int dotPos = fileName.ReverseFind_Dot();
+ if (dotPos >= 0)
+ extension = fileName.Ptr((unsigned)(dotPos + 1));
+ }
+
+ DefaultName.Empty();
+ if (FormatIndex >= 0)
+ {
+ const CArcInfoEx &ai = op.codecs->Formats[(unsigned)FormatIndex];
+ if (ai.Exts.Size() == 0)
+ DefaultName = GetDefaultName2(fileName, UString(), UString());
+ else
+ {
+ int subExtIndex = ai.FindExtension(extension);
+ if (subExtIndex < 0)
+ subExtIndex = 0;
+ const CArcExtInfo &extInfo = ai.Exts[(unsigned)subExtIndex];
+ DefaultName = GetDefaultName2(fileName, extInfo.Ext, extInfo.AddExt);
+ }
+ }
+ }
+
+ return S_OK;
+}
+
+#ifdef Z7_SFX
+
+#ifdef _WIN32
+ #define k_ExeExt ".exe"
+ static const unsigned k_ExeExt_Len = 4;
+#else
+ #define k_ExeExt ""
+ static const unsigned k_ExeExt_Len = 0;
+#endif
+
+#endif
+
+HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
+{
+ CMyComPtr<IInStream> fileStream;
+ CMyComPtr<ISequentialInStream> seqStream;
+ CInFileStream *fileStreamSpec = NULL;
+
+ if (op.stdInMode)
+ {
+ seqStream = new CStdInFileStream;
+ op.seqStream = seqStream;
+ }
+ else if (!op.stream)
+ {
+ fileStreamSpec = new CInFileStream;
+ fileStream = fileStreamSpec;
+ Path = filePath;
+ if (!fileStreamSpec->Open(us2fs(Path)))
+ return GetLastError_noZero_HRESULT();
+ op.stream = fileStream;
+ #ifdef Z7_SFX
+ IgnoreSplit = true;
+ #endif
+ }
+
+ /*
+ if (callback)
+ {
+ UInt64 fileSize;
+ RINOK(InStream_GetSize_SeekToEnd(op.stream, fileSize));
+ RINOK(op.callback->SetTotal(NULL, &fileSize))
+ }
+ */
+
+ HRESULT res = OpenStream(op);
+ IgnoreSplit = false;
+
+ #ifdef Z7_SFX
+
+ if (res != S_FALSE
+ || !fileStreamSpec
+ || !op.callbackSpec
+ || NonOpen_ErrorInfo.IsArc_After_NonOpen())
+ return res;
+
+ {
+ if (filePath.Len() > k_ExeExt_Len
+ && StringsAreEqualNoCase_Ascii(filePath.RightPtr(k_ExeExt_Len), k_ExeExt))
+ {
+ const UString path2 = filePath.Left(filePath.Len() - k_ExeExt_Len);
+ FOR_VECTOR (i, op.codecs->Formats)
+ {
+ const CArcInfoEx &ai = op.codecs->Formats[i];
+ if (ai.Is_Split())
+ continue;
+ UString path3 = path2;
+ path3.Add_Dot();
+ path3 += ai.GetMainExt(); // "7z" for SFX.
+ Path = path3;
+ Path += ".001";
+ bool isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
+ if (!isOk)
+ {
+ Path = path3;
+ isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
+ }
+ if (isOk)
+ {
+ if (fileStreamSpec->Open(us2fs(Path)))
+ {
+ op.stream = fileStream;
+ NonOpen_ErrorInfo.ClearErrors_Full();
+ if (OpenStream(op) == S_OK)
+ return S_OK;
+ }
+ }
+ }
+ }
+ }
+
+ #endif
+
+ return res;
+}
+
+void CArchiveLink::KeepModeForNextOpen()
+{
+ for (unsigned i = Arcs.Size(); i != 0;)
+ {
+ i--;
+ CMyComPtr<IArchiveKeepModeForNextOpen> keep;
+ Arcs[i].Archive->QueryInterface(IID_IArchiveKeepModeForNextOpen, (void **)&keep);
+ if (keep)
+ keep->KeepModeForNextOpen();
+ }
+}
+
+HRESULT CArchiveLink::Close()
+{
+ for (unsigned i = Arcs.Size(); i != 0;)
+ {
+ i--;
+ RINOK(Arcs[i].Close())
+ }
+ IsOpen = false;
+ // ErrorsText.Empty();
+ return S_OK;
+}
+
+void CArchiveLink::Release()
+{
+ // NonOpenErrorFormatIndex = -1;
+ NonOpen_ErrorInfo.ClearErrors();
+ NonOpen_ArcPath.Empty();
+ while (!Arcs.IsEmpty())
+ Arcs.DeleteBack();
+}
+
+/*
+void CArchiveLink::Set_ErrorsText()
+{
+ FOR_VECTOR(i, Arcs)
+ {
+ const CArc &arc = Arcs[i];
+ if (!arc.ErrorFlagsText.IsEmpty())
+ {
+ if (!ErrorsText.IsEmpty())
+ ErrorsText.Add_LF();
+ ErrorsText += GetUnicodeString(arc.ErrorFlagsText);
+ }
+ if (!arc.ErrorMessage.IsEmpty())
+ {
+ if (!ErrorsText.IsEmpty())
+ ErrorsText.Add_LF();
+ ErrorsText += arc.ErrorMessage;
+ }
+
+ if (!arc.WarningMessage.IsEmpty())
+ {
+ if (!ErrorsText.IsEmpty())
+ ErrorsText.Add_LF();
+ ErrorsText += arc.WarningMessage;
+ }
+ }
+}
+*/
+
+HRESULT CArchiveLink::Open(COpenOptions &op)
+{
+ Release();
+ if (op.types->Size() >= 32)
+ return E_NOTIMPL;
+
+ HRESULT resSpec;
+
+ for (;;)
+ {
+ resSpec = S_OK;
+
+ op.openType = COpenType();
+ if (op.types->Size() >= 1)
+ {
+ COpenType latest;
+ if (Arcs.Size() < op.types->Size())
+ latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
+ else
+ {
+ latest = (*op.types)[0];
+ if (!latest.Recursive)
+ break;
+ }
+ op.openType = latest;
+ }
+ else if (Arcs.Size() >= 32)
+ break;
+
+ /*
+ op.formatIndex = -1;
+ if (op.types->Size() >= 1)
+ {
+ int latest;
+ if (Arcs.Size() < op.types->Size())
+ latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
+ else
+ {
+ latest = (*op.types)[0];
+ if (latest != -2 && latest != -3)
+ break;
+ }
+ if (latest >= 0)
+ op.formatIndex = latest;
+ else if (latest == -1 || latest == -2)
+ {
+ // default
+ }
+ else if (latest == -3)
+ op.formatIndex = -2;
+ else
+ op.formatIndex = latest + 2;
+ }
+ else if (Arcs.Size() >= 32)
+ break;
+ */
+
+ if (Arcs.IsEmpty())
+ {
+ CArc arc;
+ arc.filePath = op.filePath;
+ arc.Path = op.filePath;
+ arc.SubfileIndex = (UInt32)(Int32)-1;
+ HRESULT result = arc.OpenStreamOrFile(op);
+ if (result != S_OK)
+ {
+ if (result == S_FALSE)
+ {
+ NonOpen_ErrorInfo = arc.NonOpen_ErrorInfo;
+ // NonOpenErrorFormatIndex = arc.ErrorFormatIndex;
+ NonOpen_ArcPath = arc.Path;
+ }
+ return result;
+ }
+ Arcs.Add(arc);
+ continue;
+ }
+
+ // PrintNumber("op.formatIndex 11", op.formatIndex);
+
+ const CArc &arc = Arcs.Back();
+
+ if (op.types->Size() > Arcs.Size())
+ resSpec = E_NOTIMPL;
+
+ UInt32 mainSubfile;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(arc.Archive->GetArchiveProperty(kpidMainSubfile, &prop))
+ if (prop.vt == VT_UI4)
+ mainSubfile = prop.ulVal;
+ else
+ break;
+ UInt32 numItems;
+ RINOK(arc.Archive->GetNumberOfItems(&numItems))
+ if (mainSubfile >= numItems)
+ break;
+ }
+
+
+ CMyComPtr<IInArchiveGetStream> getStream;
+ if (arc.Archive->QueryInterface(IID_IInArchiveGetStream, (void **)&getStream) != S_OK || !getStream)
+ break;
+
+ CMyComPtr<ISequentialInStream> subSeqStream;
+ if (getStream->GetStream(mainSubfile, &subSeqStream) != S_OK || !subSeqStream)
+ break;
+
+ CMyComPtr<IInStream> subStream;
+ if (subSeqStream.QueryInterface(IID_IInStream, &subStream) != S_OK || !subStream)
+ break;
+
+ CArc arc2;
+ RINOK(arc.GetItem_Path(mainSubfile, arc2.Path))
+
+ bool zerosTailIsAllowed;
+ RINOK(Archive_GetItemBoolProp(arc.Archive, mainSubfile, kpidZerosTailIsAllowed, zerosTailIsAllowed))
+
+
+ if (op.callback)
+ {
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IArchiveOpenSetSubArchiveName,
+ setSubArchiveName, op.callback)
+ if (setSubArchiveName)
+ setSubArchiveName->SetSubArchiveName(arc2.Path);
+ }
+
+ arc2.SubfileIndex = mainSubfile;
+
+ // CIntVector incl;
+ CIntVector excl;
+
+ COpenOptions op2;
+ #ifndef Z7_SFX
+ op2.props = op.props;
+ #endif
+ op2.codecs = op.codecs;
+ // op2.types = &incl;
+ op2.openType = op.openType;
+ op2.openType.ZerosTailIsAllowed = zerosTailIsAllowed;
+ op2.excludedFormats = !
+ op2.stdInMode = false;
+ op2.stream = subStream;
+ op2.filePath = arc2.Path;
+ op2.callback = op.callback;
+ op2.callbackSpec = op.callbackSpec;
+
+
+ HRESULT result = arc2.OpenStream(op2);
+ resSpec = (op.types->Size() == 0 ? S_OK : S_FALSE);
+ if (result == S_FALSE)
+ {
+ NonOpen_ErrorInfo = arc2.ErrorInfo;
+ NonOpen_ArcPath = arc2.Path;
+ break;
+ }
+ RINOK(result)
+ RINOK(arc.GetItem_MTime(mainSubfile, arc2.MTime))
+ Arcs.Add(arc2);
+ }
+ IsOpen = !Arcs.IsEmpty();
+ return resSpec;
+}
+
+HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
+{
+ VolumesSize = 0;
+ COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
+ CMyComPtr<IArchiveOpenCallback> callback = openCallbackSpec;
+ openCallbackSpec->Callback = callbackUI;
+
+ FString prefix, name;
+
+ if (!op.stream && !op.stdInMode)
+ {
+ NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), prefix, name);
+ RINOK(openCallbackSpec->Init2(prefix, name))
+ }
+ else
+ {
+ openCallbackSpec->SetSubArchiveName(op.filePath);
+ }
+
+ op.callback = callback;
+ op.callbackSpec = openCallbackSpec;
+
+ HRESULT res = Open(op);
+
+ PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
+ // Password = openCallbackSpec->Password;
+
+ RINOK(res)
+ // VolumePaths.Add(fs2us(prefix + name));
+
+ FOR_VECTOR (i, openCallbackSpec->FileNames_WasUsed)
+ {
+ if (openCallbackSpec->FileNames_WasUsed[i])
+ {
+ VolumePaths.Add(fs2us(prefix) + openCallbackSpec->FileNames[i]);
+ VolumesSize += openCallbackSpec->FileSizes[i];
+ }
+ }
+ // VolumesSize = openCallbackSpec->TotalSize;
+ return S_OK;
+}
+
+HRESULT CArc::ReOpen(const COpenOptions &op, IArchiveOpenCallback *openCallback_Additional)
+{
+ ErrorInfo.ClearErrors();
+ ErrorInfo.ErrorFormatIndex = -1;
+
+ UInt64 fileSize = 0;
+ if (op.stream)
+ {
+ RINOK(InStream_SeekToBegin(op.stream))
+ RINOK(InStream_AtBegin_GetSize(op.stream, fileSize))
+ // RINOK(InStream_GetSize_SeekToBegin(op.stream, fileSize))
+ }
+ FileSize = fileSize;
+
+ CMyComPtr<IInStream> stream2;
+ Int64 globalOffset = GetGlobalOffset();
+ if (globalOffset <= 0)
+ stream2 = op.stream;
+ else
+ {
+ CTailInStream *tailStreamSpec = new CTailInStream;
+ stream2 = tailStreamSpec;
+ tailStreamSpec->Stream = op.stream;
+ tailStreamSpec->Offset = (UInt64)globalOffset;
+ tailStreamSpec->Init();
+ RINOK(tailStreamSpec->SeekToStart())
+ }
+
+ // There are archives with embedded STUBs (like ZIP), so we must support signature scanning
+ // But for another archives we can use 0 here. So the code can be fixed !!!
+ UInt64 maxStartPosition = kMaxCheckStartPosition;
+ IArchiveOpenCallback *openCallback = openCallback_Additional;
+ if (!openCallback)
+ openCallback = op.callback;
+ HRESULT res = Archive->Open(stream2, &maxStartPosition, openCallback);
+
+ if (res == S_OK)
+ {
+ RINOK(ReadBasicProps(Archive, (UInt64)globalOffset, res))
+ ArcStreamOffset = (UInt64)globalOffset;
+ if (ArcStreamOffset != 0)
+ InStream = op.stream;
+ }
+ return res;
+}
+
+HRESULT CArchiveLink::Open3(COpenOptions &op, IOpenCallbackUI *callbackUI)
+{
+ HRESULT res = Open2(op, callbackUI);
+ if (callbackUI)
+ {
+ RINOK(callbackUI->Open_Finished())
+ }
+ return res;
+}
+
+HRESULT CArchiveLink::ReOpen(COpenOptions &op)
+{
+ if (Arcs.Size() > 1)
+ return E_NOTIMPL;
+
+ CObjectVector<COpenType> inc;
+ CIntVector excl;
+
+ op.types = &inc;
+ op.excludedFormats = !
+ op.stdInMode = false;
+ op.stream = NULL;
+ if (Arcs.Size() == 0) // ???
+ return Open2(op, NULL);
+
+ /* if archive is multivolume (unsupported here still)
+ COpenCallbackImp object will exist after Open stage. */
+ COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
+ CMyComPtr<IArchiveOpenCallback> openCallbackNew = openCallbackSpec;
+
+ openCallbackSpec->Callback = NULL;
+ openCallbackSpec->ReOpenCallback = op.callback;
+ {
+ FString dirPrefix, fileName;
+ NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), dirPrefix, fileName);
+ RINOK(openCallbackSpec->Init2(dirPrefix, fileName))
+ }
+
+
+ CInFileStream *fileStreamSpec = new CInFileStream;
+ CMyComPtr<IInStream> stream(fileStreamSpec);
+ if (!fileStreamSpec->Open(us2fs(op.filePath)))
+ return GetLastError_noZero_HRESULT();
+ op.stream = stream;
+
+ CArc &arc = Arcs[0];
+ const HRESULT res = arc.ReOpen(op, openCallbackNew);
+
+ openCallbackSpec->ReOpenCallback = NULL;
+
+ PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
+ // Password = openCallbackSpec->Password;
+
+ IsOpen = (res == S_OK);
+ return res;
+}
+
+#ifndef Z7_SFX
+
+bool ParseComplexSize(const wchar_t *s, UInt64 &result);
+bool ParseComplexSize(const wchar_t *s, UInt64 &result)
+{
+ result = 0;
+ const wchar_t *end;
+ UInt64 number = ConvertStringToUInt64(s, &end);
+ if (end == s)
+ return false;
+ if (*end == 0)
+ {
+ result = number;
+ return true;
+ }
+ if (end[1] != 0)
+ return false;
+ unsigned numBits;
+ switch (MyCharLower_Ascii(*end))
+ {
+ case 'b': result = number; return true;
+ case 'k': numBits = 10; break;
+ case 'm': numBits = 20; break;
+ case 'g': numBits = 30; break;
+ case 't': numBits = 40; break;
+ default: return false;
+ }
+ if (number >= ((UInt64)1 << (64 - numBits)))
+ return false;
+ result = number << numBits;
+ return true;
+}
+
+static bool ParseTypeParams(const UString &s, COpenType &type)
+{
+ if (s[0] == 0)
+ return true;
+ if (s[1] == 0)
+ {
+ switch ((unsigned)(Byte)s[0])
+ {
+ case 'e': type.EachPos = true; return true;
+ case 'a': type.CanReturnArc = true; return true;
+ case 'r': type.Recursive = true; return true;
+ }
+ return false;
+ }
+ if (s[0] == 's')
+ {
+ UInt64 result;
+ if (!ParseComplexSize(s.Ptr(1), result))
+ return false;
+ type.MaxStartOffset = result;
+ type.MaxStartOffset_Defined = true;
+ return true;
+ }
+
+ return false;
+}
+
+static bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
+{
+ int pos2 = s.Find(L':');
+
+ {
+ UString name;
+ if (pos2 < 0)
+ {
+ name = s;
+ pos2 = (int)s.Len();
+ }
+ else
+ {
+ name = s.Left((unsigned)pos2);
+ pos2++;
+ }
+
+ int index = codecs.FindFormatForArchiveType(name);
+ type.Recursive = false;
+
+ if (index < 0)
+ {
+ if (name[0] == '*')
+ {
+ if (name[1] != 0)
+ return false;
+ }
+ else if (name[0] == '#')
+ {
+ if (name[1] != 0)
+ return false;
+ type.CanReturnArc = false;
+ type.CanReturnParser = true;
+ }
+ else if (name.IsEqualTo_Ascii_NoCase("hash"))
+ {
+ // type.CanReturnArc = false;
+ // type.CanReturnParser = false;
+ type.IsHashType = true;
+ }
+ else
+ return false;
+ }
+
+ type.FormatIndex = index;
+
+ }
+
+ for (unsigned i = (unsigned)pos2; i < s.Len();)
+ {
+ int next = s.Find(L':', i);
+ if (next < 0)
+ next = (int)s.Len();
+ const UString name = s.Mid(i, (unsigned)next - i);
+ if (name.IsEmpty())
+ return false;
+ if (!ParseTypeParams(name, type))
+ return false;
+ i = (unsigned)next + 1;
+ }
+
+ return true;
+}
+
+bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types)
+{
+ types.Clear();
+ bool isHashType = false;
+ for (unsigned pos = 0; pos < s.Len();)
+ {
+ int pos2 = s.Find(L'.', pos);
+ if (pos2 < 0)
+ pos2 = (int)s.Len();
+ UString name = s.Mid(pos, (unsigned)pos2 - pos);
+ if (name.IsEmpty())
+ return false;
+ COpenType type;
+ if (!ParseType(codecs, name, type))
+ return false;
+ if (isHashType)
+ return false;
+ if (type.IsHashType)
+ isHashType = true;
+ types.Add(type);
+ pos = (unsigned)pos2 + 1;
+ }
+ return true;
+}
+
+/*
+bool IsHashType(const CObjectVector<COpenType> &types)
+{
+ if (types.Size() != 1)
+ return false;
+ return types[0].IsHashType;
+}
+*/
+
+
+#endif
diff --git a/CPP/7zip/UI/Common/OpenArchive.h b/CPP/7zip/UI/Common/OpenArchive.h
index 033cb96..5c3bfe5 100644
--- a/CPP/7zip/UI/Common/OpenArchive.h
+++ b/CPP/7zip/UI/Common/OpenArchive.h
@@ -1,436 +1,469 @@
-// OpenArchive.h
-
-#ifndef __OPEN_ARCHIVE_H
-#define __OPEN_ARCHIVE_H
-
-#include "../../../Windows/PropVariant.h"
-
-#include "ArchiveOpenCallback.h"
-#include "LoadCodecs.h"
-#include "Property.h"
-
-#ifndef _SFX
-
-#define SUPPORT_ALT_STREAMS
-
-#endif
-
-HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bool &result) throw();
-HRESULT Archive_IsItem_Dir(IInArchive *arc, UInt32 index, bool &result) throw();
-HRESULT Archive_IsItem_Aux(IInArchive *arc, UInt32 index, bool &result) throw();
-HRESULT Archive_IsItem_AltStream(IInArchive *arc, UInt32 index, bool &result) throw();
-HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &deleted) throw();
-
-#ifdef SUPPORT_ALT_STREAMS
-int FindAltStreamColon_in_Path(const wchar_t *path);
-#endif
-
-/*
-struct COptionalOpenProperties
-{
- UString FormatName;
- CObjectVector<CProperty> Props;
-};
-*/
-
-#ifdef _SFX
-#define OPEN_PROPS_DECL
-#else
-#define OPEN_PROPS_DECL const CObjectVector<CProperty> *props;
-// #define OPEN_PROPS_DECL , const CObjectVector<COptionalOpenProperties> *props
-#endif
-
-struct COpenSpecFlags
-{
- // bool CanReturnFull;
- bool CanReturnFrontal;
- bool CanReturnTail;
- bool CanReturnMid;
-
- bool CanReturn_NonStart() const { return CanReturnTail || CanReturnMid; }
-
- COpenSpecFlags():
- // CanReturnFull(true),
- CanReturnFrontal(false),
- CanReturnTail(false),
- CanReturnMid(false)
- {}
-};
-
-struct COpenType
-{
- int FormatIndex;
-
- COpenSpecFlags SpecForcedType;
- COpenSpecFlags SpecMainType;
- COpenSpecFlags SpecWrongExt;
- COpenSpecFlags SpecUnknownExt;
-
- bool Recursive;
-
- bool CanReturnArc;
- bool CanReturnParser;
- bool EachPos;
-
- // bool SkipSfxStub;
- // bool ExeAsUnknown;
-
- bool ZerosTailIsAllowed;
-
- bool MaxStartOffset_Defined;
- UInt64 MaxStartOffset;
-
- const COpenSpecFlags &GetSpec(bool isForced, bool isMain, bool isUnknown) const
- {
- return isForced ? SpecForcedType : (isMain ? SpecMainType : (isUnknown ? SpecUnknownExt : SpecWrongExt));
- }
-
- COpenType():
- FormatIndex(-1),
- Recursive(true),
- EachPos(false),
- CanReturnArc(true),
- CanReturnParser(false),
- // SkipSfxStub(true),
- // ExeAsUnknown(true),
- ZerosTailIsAllowed(false),
- MaxStartOffset_Defined(false),
- MaxStartOffset(0)
- {
- SpecForcedType.CanReturnFrontal = true;
- SpecForcedType.CanReturnTail = true;
- SpecForcedType.CanReturnMid = true;
-
- SpecMainType.CanReturnFrontal = true;
-
- SpecUnknownExt.CanReturnTail = true; // for sfx
- SpecUnknownExt.CanReturnMid = true;
- SpecUnknownExt.CanReturnFrontal = true; // for alt streams of sfx with pad
-
- // ZerosTailIsAllowed = true;
- }
-};
-
-struct COpenOptions
-{
- CCodecs *codecs;
- COpenType openType;
- const CObjectVector<COpenType> *types;
- const CIntVector *excludedFormats;
-
- IInStream *stream;
- ISequentialInStream *seqStream;
- IArchiveOpenCallback *callback;
- COpenCallbackImp *callbackSpec;
- OPEN_PROPS_DECL
- // bool openOnlySpecifiedByExtension,
-
- bool stdInMode;
- UString filePath;
-
- COpenOptions():
- codecs(NULL),
- types(NULL),
- excludedFormats(NULL),
- stream(NULL),
- seqStream(NULL),
- callback(NULL),
- callbackSpec(NULL),
- stdInMode(false)
- {}
-
-};
-
-UInt32 GetOpenArcErrorFlags(const NWindows::NCOM::CPropVariant &prop, bool *isDefinedProp = NULL);
-
-struct CArcErrorInfo
-{
- bool ThereIsTail;
- bool UnexpecedEnd;
- bool IgnoreTail; // all are zeros
- // bool NonZerosTail;
- bool ErrorFlags_Defined;
- UInt32 ErrorFlags;
- UInt32 WarningFlags;
- int ErrorFormatIndex; // - 1 means no Error.
- // if FormatIndex == ErrorFormatIndex, the archive is open with offset
- UInt64 TailSize;
-
- /* if CArc is Open OK with some format:
- - ErrorFormatIndex shows error format index, if extension is incorrect
- - other variables show message and warnings of archive that is open */
-
- UString ErrorMessage;
- UString WarningMessage;
-
- // call IsArc_After_NonOpen only if Open returns S_FALSE
- bool IsArc_After_NonOpen() const
- {
- return (ErrorFlags_Defined && (ErrorFlags & kpv_ErrorFlags_IsNotArc) == 0);
- }
-
-
- CArcErrorInfo():
- ThereIsTail(false),
- UnexpecedEnd(false),
- IgnoreTail(false),
- // NonZerosTail(false),
- ErrorFlags_Defined(false),
- ErrorFlags(0),
- WarningFlags(0),
- ErrorFormatIndex(-1),
- TailSize(0)
- {}
-
- void ClearErrors();
-
- void ClearErrors_Full()
- {
- ErrorFormatIndex = -1;
- ClearErrors();
- }
-
- bool IsThereErrorOrWarning() const
- {
- return ErrorFlags != 0
- || WarningFlags != 0
- || NeedTailWarning()
- || UnexpecedEnd
- || !ErrorMessage.IsEmpty()
- || !WarningMessage.IsEmpty();
- }
-
- bool AreThereErrors() const { return ErrorFlags != 0 || UnexpecedEnd; }
- bool AreThereWarnings() const { return WarningFlags != 0 || NeedTailWarning(); }
-
- bool NeedTailWarning() const { return !IgnoreTail && ThereIsTail; }
-
- UInt32 GetWarningFlags() const
- {
- UInt32 a = WarningFlags;
- if (NeedTailWarning() && (ErrorFlags & kpv_ErrorFlags_DataAfterEnd) == 0)
- a |= kpv_ErrorFlags_DataAfterEnd;
- return a;
- }
-
- UInt32 GetErrorFlags() const
- {
- UInt32 a = ErrorFlags;
- if (UnexpecedEnd)
- a |= kpv_ErrorFlags_UnexpectedEnd;
- return a;
- }
-};
-
-struct CReadArcItem
-{
- UString Path; // Path from root (including alt stream name, if alt stream)
- UStringVector PathParts; // without altStream name, path from root or from _baseParentFolder, if _use_baseParentFolder_mode
-
- #ifdef SUPPORT_ALT_STREAMS
- UString MainPath;
- /* MainPath = Path for non-AltStream,
- MainPath = Path of parent, if there is parent for AltStream. */
- UString AltStreamName;
- bool IsAltStream;
- bool WriteToAltStreamIfColon;
- #endif
-
- bool IsDir;
- bool MainIsDir;
- UInt32 ParentIndex; // use it, if IsAltStream
-
- #ifndef _SFX
- bool _use_baseParentFolder_mode;
- int _baseParentFolder;
- #endif
-
- CReadArcItem()
- {
- #ifdef SUPPORT_ALT_STREAMS
- WriteToAltStreamIfColon = false;
- #endif
-
- #ifndef _SFX
- _use_baseParentFolder_mode = false;
- _baseParentFolder = -1;
- #endif
- }
-};
-
-class CArc
-{
- HRESULT PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyComPtr<IInArchive> &archive);
- HRESULT CheckZerosTail(const COpenOptions &op, UInt64 offset);
- HRESULT OpenStream2(const COpenOptions &options);
-
- #ifndef _SFX
- // parts.Back() can contain alt stream name "nams:AltName"
- HRESULT GetItemPathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const;
- #endif
-
-public:
- CMyComPtr<IInArchive> Archive;
- CMyComPtr<IInStream> InStream;
- // we use InStream in 2 cases (ArcStreamOffset != 0):
- // 1) if we use additional cache stream
- // 2) we reopen sfx archive with CTailInStream
-
- CMyComPtr<IArchiveGetRawProps> GetRawProps;
- CMyComPtr<IArchiveGetRootProps> GetRootProps;
-
- CArcErrorInfo ErrorInfo; // for OK archives
- CArcErrorInfo NonOpen_ErrorInfo; // ErrorInfo for mainArchive (false OPEN)
-
- UString Path;
- UString filePath;
- UString DefaultName;
- int FormatIndex; // - 1 means Parser.
- int SubfileIndex;
- FILETIME MTime;
- bool MTimeDefined;
-
- Int64 Offset; // it's offset of start of archive inside stream that is open by Archive Handler
- UInt64 PhySize;
- // UInt64 OkPhySize;
- bool PhySizeDefined;
- // bool OkPhySize_Defined;
- UInt64 FileSize;
- UInt64 AvailPhySize; // PhySize, but it's reduced if exceed end of file
- // bool offsetDefined;
-
- UInt64 GetEstmatedPhySize() const { return PhySizeDefined ? PhySize : FileSize; }
-
- UInt64 ArcStreamOffset; // offset of stream that is open by Archive Handler
- Int64 GetGlobalOffset() const { return ArcStreamOffset + Offset; } // it's global offset of archive
-
- // AString ErrorFlagsText;
-
- bool IsParseArc;
-
- bool IsTree;
- bool IsReadOnly;
-
- bool Ask_Deleted;
- bool Ask_AltStream;
- bool Ask_Aux;
- bool Ask_INode;
-
- bool IgnoreSplit; // don't try split handler
-
- // void Set_ErrorFlagsText();
-
- CArc():
- MTimeDefined(false),
- IsTree(false),
- IsReadOnly(false),
- Ask_Deleted(false),
- Ask_AltStream(false),
- Ask_Aux(false),
- Ask_INode(false),
- IgnoreSplit(false)
- {}
-
- HRESULT ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes);
-
- // ~CArc();
-
- HRESULT Close()
- {
- InStream.Release();
- return Archive->Close();
- }
-
- HRESULT GetItemPath(UInt32 index, UString &result) const;
- HRESULT GetDefaultItemPath(UInt32 index, UString &result) const;
-
- // GetItemPath2 adds [DELETED] dir prefix for deleted items.
- HRESULT GetItemPath2(UInt32 index, UString &result) const;
-
- HRESULT GetItem(UInt32 index, CReadArcItem &item) const;
-
- HRESULT GetItemSize(UInt32 index, UInt64 &size, bool &defined) const;
- HRESULT GetItemMTime(UInt32 index, FILETIME &ft, bool &defined) const;
- HRESULT IsItemAnti(UInt32 index, bool &result) const
- { return Archive_GetItemBoolProp(Archive, index, kpidIsAnti, result); }
-
-
- HRESULT OpenStream(const COpenOptions &options);
- HRESULT OpenStreamOrFile(COpenOptions &options);
-
- HRESULT ReOpen(const COpenOptions &options);
-
- HRESULT CreateNewTailStream(CMyComPtr<IInStream> &stream);
-};
-
-struct CArchiveLink
-{
- CObjectVector<CArc> Arcs;
- UStringVector VolumePaths;
- UInt64 VolumesSize;
- bool IsOpen;
-
- bool PasswordWasAsked;
- // UString Password;
-
- // int NonOpenErrorFormatIndex; // - 1 means no Error.
- UString NonOpen_ArcPath;
-
- CArcErrorInfo NonOpen_ErrorInfo;
-
- // UString ErrorsText;
- // void Set_ErrorsText();
-
- CArchiveLink():
- VolumesSize(0),
- IsOpen(false),
- PasswordWasAsked(false)
- {}
-
- void KeepModeForNextOpen();
- HRESULT Close();
- void Release();
- ~CArchiveLink() { Release(); }
-
- const CArc *GetArc() const { return &Arcs.Back(); }
- IInArchive *GetArchive() const { return Arcs.Back().Archive; }
- IArchiveGetRawProps *GetArchiveGetRawProps() const { return Arcs.Back().GetRawProps; }
- IArchiveGetRootProps *GetArchiveGetRootProps() const { return Arcs.Back().GetRootProps; }
-
- HRESULT Open(COpenOptions &options);
- HRESULT Open2(COpenOptions &options, IOpenCallbackUI *callbackUI);
- HRESULT Open3(COpenOptions &options, IOpenCallbackUI *callbackUI);
-
- HRESULT Open_Strict(COpenOptions &options, IOpenCallbackUI *callbackUI)
- {
- HRESULT result = Open3(options, callbackUI);
- if (result == S_OK && NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
- result = S_FALSE;
- return result;
- }
-
- HRESULT ReOpen(COpenOptions &options);
-};
-
-bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types);
-
-
-struct CDirPathSortPair
-{
- unsigned Len;
- unsigned Index;
-
- void SetNumSlashes(const FChar *s);
-
- int Compare(const CDirPathSortPair &a) const
- {
- // We need sorting order where parent items will be after child items
- if (Len < a.Len) return 1;
- if (Len > a.Len) return -1;
- if (Index < a.Index) return -1;
- if (Index > a.Index) return 1;
- return 0;
- }
-};
-
-#endif
+// OpenArchive.h
+
+#ifndef ZIP7_INC_OPEN_ARCHIVE_H
+#define ZIP7_INC_OPEN_ARCHIVE_H
+
+#include "../../../Windows/PropVariant.h"
+
+#include "ArchiveOpenCallback.h"
+#include "LoadCodecs.h"
+#include "Property.h"
+#include "DirItem.h"
+
+#ifndef Z7_SFX
+
+#define SUPPORT_ALT_STREAMS
+
+#endif
+
+HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bool &result) throw();
+HRESULT Archive_IsItem_Dir(IInArchive *arc, UInt32 index, bool &result) throw();
+HRESULT Archive_IsItem_Aux(IInArchive *arc, UInt32 index, bool &result) throw();
+HRESULT Archive_IsItem_AltStream(IInArchive *arc, UInt32 index, bool &result) throw();
+HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &deleted) throw();
+
+#ifdef SUPPORT_ALT_STREAMS
+int FindAltStreamColon_in_Path(const wchar_t *path);
+#endif
+
+/*
+struct COptionalOpenProperties
+{
+ UString FormatName;
+ CObjectVector<CProperty> Props;
+};
+*/
+
+#ifdef Z7_SFX
+#define OPEN_PROPS_DECL
+#else
+#define OPEN_PROPS_DECL const CObjectVector<CProperty> *props;
+// #define OPEN_PROPS_DECL , const CObjectVector<COptionalOpenProperties> *props
+#endif
+
+struct COpenSpecFlags
+{
+ // bool CanReturnFull;
+ bool CanReturnFrontal;
+ bool CanReturnTail;
+ bool CanReturnMid;
+
+ bool CanReturn_NonStart() const { return CanReturnTail || CanReturnMid; }
+
+ COpenSpecFlags():
+ // CanReturnFull(true),
+ CanReturnFrontal(false),
+ CanReturnTail(false),
+ CanReturnMid(false)
+ {}
+};
+
+struct COpenType
+{
+ int FormatIndex;
+
+ COpenSpecFlags SpecForcedType;
+ COpenSpecFlags SpecMainType;
+ COpenSpecFlags SpecWrongExt;
+ COpenSpecFlags SpecUnknownExt;
+
+ bool Recursive;
+
+ bool CanReturnArc;
+ bool CanReturnParser;
+ bool IsHashType;
+ bool EachPos;
+
+ // bool SkipSfxStub;
+ // bool ExeAsUnknown;
+
+ bool ZerosTailIsAllowed;
+
+ bool MaxStartOffset_Defined;
+ UInt64 MaxStartOffset;
+
+ const COpenSpecFlags &GetSpec(bool isForced, bool isMain, bool isUnknown) const
+ {
+ return isForced ? SpecForcedType : (isMain ? SpecMainType : (isUnknown ? SpecUnknownExt : SpecWrongExt));
+ }
+
+ COpenType():
+ FormatIndex(-1),
+ Recursive(true),
+ CanReturnArc(true),
+ CanReturnParser(false),
+ IsHashType(false),
+ EachPos(false),
+ // SkipSfxStub(true),
+ // ExeAsUnknown(true),
+ ZerosTailIsAllowed(false),
+ MaxStartOffset_Defined(false),
+ MaxStartOffset(0)
+ {
+ SpecForcedType.CanReturnFrontal = true;
+ SpecForcedType.CanReturnTail = true;
+ SpecForcedType.CanReturnMid = true;
+
+ SpecMainType.CanReturnFrontal = true;
+
+ SpecUnknownExt.CanReturnTail = true; // for sfx
+ SpecUnknownExt.CanReturnMid = true;
+ SpecUnknownExt.CanReturnFrontal = true; // for alt streams of sfx with pad
+
+ // ZerosTailIsAllowed = true;
+ }
+};
+
+struct COpenOptions
+{
+ CCodecs *codecs;
+ COpenType openType;
+ const CObjectVector<COpenType> *types;
+ const CIntVector *excludedFormats;
+
+ IInStream *stream;
+ ISequentialInStream *seqStream;
+ IArchiveOpenCallback *callback;
+ COpenCallbackImp *callbackSpec; // it's used for SFX only
+ OPEN_PROPS_DECL
+ // bool openOnlySpecifiedByExtension,
+
+ bool stdInMode;
+ UString filePath;
+
+ COpenOptions():
+ codecs(NULL),
+ types(NULL),
+ excludedFormats(NULL),
+ stream(NULL),
+ seqStream(NULL),
+ callback(NULL),
+ callbackSpec(NULL),
+ stdInMode(false)
+ {}
+
+};
+
+UInt32 GetOpenArcErrorFlags(const NWindows::NCOM::CPropVariant &prop, bool *isDefinedProp = NULL);
+
+struct CArcErrorInfo
+{
+ bool ThereIsTail;
+ bool UnexpecedEnd;
+ bool IgnoreTail; // all are zeros
+ // bool NonZerosTail;
+ bool ErrorFlags_Defined;
+ UInt32 ErrorFlags;
+ UInt32 WarningFlags;
+ int ErrorFormatIndex; // - 1 means no Error.
+ // if FormatIndex == ErrorFormatIndex, the archive is open with offset
+ UInt64 TailSize;
+
+ /* if CArc is Open OK with some format:
+ - ErrorFormatIndex shows error format index, if extension is incorrect
+ - other variables show message and warnings of archive that is open */
+
+ UString ErrorMessage;
+ UString WarningMessage;
+
+ // call IsArc_After_NonOpen only if Open returns S_FALSE
+ bool IsArc_After_NonOpen() const
+ {
+ return (ErrorFlags_Defined && (ErrorFlags & kpv_ErrorFlags_IsNotArc) == 0);
+ }
+
+
+ CArcErrorInfo():
+ ThereIsTail(false),
+ UnexpecedEnd(false),
+ IgnoreTail(false),
+ // NonZerosTail(false),
+ ErrorFlags_Defined(false),
+ ErrorFlags(0),
+ WarningFlags(0),
+ ErrorFormatIndex(-1),
+ TailSize(0)
+ {}
+
+ void ClearErrors();
+
+ void ClearErrors_Full()
+ {
+ ErrorFormatIndex = -1;
+ ClearErrors();
+ }
+
+ bool IsThereErrorOrWarning() const
+ {
+ return ErrorFlags != 0
+ || WarningFlags != 0
+ || NeedTailWarning()
+ || UnexpecedEnd
+ || !ErrorMessage.IsEmpty()
+ || !WarningMessage.IsEmpty();
+ }
+
+ bool AreThereErrors() const { return ErrorFlags != 0 || UnexpecedEnd; }
+ bool AreThereWarnings() const { return WarningFlags != 0 || NeedTailWarning(); }
+
+ bool NeedTailWarning() const { return !IgnoreTail && ThereIsTail; }
+
+ UInt32 GetWarningFlags() const
+ {
+ UInt32 a = WarningFlags;
+ if (NeedTailWarning() && (ErrorFlags & kpv_ErrorFlags_DataAfterEnd) == 0)
+ a |= kpv_ErrorFlags_DataAfterEnd;
+ return a;
+ }
+
+ UInt32 GetErrorFlags() const
+ {
+ UInt32 a = ErrorFlags;
+ if (UnexpecedEnd)
+ a |= kpv_ErrorFlags_UnexpectedEnd;
+ return a;
+ }
+};
+
+struct CReadArcItem
+{
+ UString Path; // Path from root (including alt stream name, if alt stream)
+ UStringVector PathParts; // without altStream name, path from root or from _baseParentFolder, if _use_baseParentFolder_mode
+
+ #ifdef SUPPORT_ALT_STREAMS
+ UString MainPath;
+ /* MainPath = Path for non-AltStream,
+ MainPath = Path of parent, if there is parent for AltStream. */
+ UString AltStreamName;
+ bool IsAltStream;
+ bool WriteToAltStreamIfColon;
+ #endif
+
+ bool IsDir;
+ bool MainIsDir;
+ UInt32 ParentIndex; // use it, if IsAltStream
+
+ #ifndef Z7_SFX
+ bool _use_baseParentFolder_mode;
+ int _baseParentFolder;
+ #endif
+
+ CReadArcItem()
+ {
+ #ifdef SUPPORT_ALT_STREAMS
+ WriteToAltStreamIfColon = false;
+ #endif
+
+ #ifndef Z7_SFX
+ _use_baseParentFolder_mode = false;
+ _baseParentFolder = -1;
+ #endif
+ }
+};
+
+
+
+
+class CArc
+{
+ HRESULT PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyComPtr<IInArchive> &archive);
+ HRESULT CheckZerosTail(const COpenOptions &op, UInt64 offset);
+ HRESULT OpenStream2(const COpenOptions &options);
+
+ #ifndef Z7_SFX
+ // parts.Back() can contain alt stream name "nams:AltName"
+ HRESULT GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const;
+ #endif
+
+public:
+ CMyComPtr<IInArchive> Archive;
+ CMyComPtr<IInStream> InStream;
+ // we use InStream in 2 cases (ArcStreamOffset != 0):
+ // 1) if we use additional cache stream
+ // 2) we reopen sfx archive with CTailInStream
+
+ CMyComPtr<IArchiveGetRawProps> GetRawProps;
+ CMyComPtr<IArchiveGetRootProps> GetRootProps;
+
+ bool IsParseArc;
+
+ bool IsTree;
+ bool IsReadOnly;
+
+ bool Ask_Deleted;
+ bool Ask_AltStream;
+ bool Ask_Aux;
+ bool Ask_INode;
+
+ bool IgnoreSplit; // don't try split handler
+
+ UString Path;
+ UString filePath;
+ UString DefaultName;
+ int FormatIndex; // -1 means Parser
+ UInt32 SubfileIndex; // (UInt32)(Int32)-1; means no subfile
+
+ // CFiTime MTime;
+ // bool MTime_Defined;
+ CArcTime MTime;
+
+ Int64 Offset; // it's offset of start of archive inside stream that is open by Archive Handler
+ UInt64 PhySize;
+ // UInt64 OkPhySize;
+ bool PhySize_Defined;
+ // bool OkPhySize_Defined;
+ UInt64 FileSize;
+ UInt64 AvailPhySize; // PhySize, but it's reduced if exceed end of file
+
+ CArcErrorInfo ErrorInfo; // for OK archives
+ CArcErrorInfo NonOpen_ErrorInfo; // ErrorInfo for mainArchive (false OPEN)
+
+ UInt64 GetEstmatedPhySize() const { return PhySize_Defined ? PhySize : FileSize; }
+
+ UInt64 ArcStreamOffset; // offset of stream that is open by Archive Handler
+ Int64 GetGlobalOffset() const { return (Int64)ArcStreamOffset + Offset; } // it's global offset of archive
+
+ // AString ErrorFlagsText;
+
+ // void Set_ErrorFlagsText();
+
+ CArc():
+ // MTime_Defined(false),
+ IsTree(false),
+ IsReadOnly(false),
+ Ask_Deleted(false),
+ Ask_AltStream(false),
+ Ask_Aux(false),
+ Ask_INode(false),
+ IgnoreSplit(false)
+ {}
+
+ HRESULT ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes);
+
+ HRESULT Close()
+ {
+ InStream.Release();
+ return Archive->Close();
+ }
+
+ HRESULT GetItem_Path(UInt32 index, UString &result) const;
+ HRESULT GetItem_DefaultPath(UInt32 index, UString &result) const;
+
+ // GetItemPath2 adds [DELETED] dir prefix for deleted items.
+ HRESULT GetItem_Path2(UInt32 index, UString &result) const;
+
+ HRESULT GetItem(UInt32 index, CReadArcItem &item) const;
+
+ HRESULT GetItem_Size(UInt32 index, UInt64 &size, bool &defined) const;
+
+ /* if (GetProperty() returns vt==VT_EMPTY), this function sets
+ timestamp from archive file timestamp (MTime).
+ So (at) will be set in most cases (at.Def == true)
+ if (at.Prec == 0)
+ {
+ it means that (Prec == 0) was returned for (kpidMTime),
+ and no value was returned for (kpidTimeType).
+ it can mean Windows precision or unknown precision.
+ }
+ */
+ HRESULT GetItem_MTime(UInt32 index, CArcTime &at) const;
+
+ HRESULT IsItem_Anti(UInt32 index, bool &result) const
+ { return Archive_GetItemBoolProp(Archive, index, kpidIsAnti, result); }
+
+
+ HRESULT OpenStream(const COpenOptions &options);
+ HRESULT OpenStreamOrFile(COpenOptions &options);
+
+ HRESULT ReOpen(const COpenOptions &options, IArchiveOpenCallback *openCallback_Additional);
+
+ HRESULT CreateNewTailStream(CMyComPtr<IInStream> &stream);
+
+ bool IsHashHandler(const COpenOptions &options) const
+ {
+ if (FormatIndex < 0)
+ return false;
+ return options.codecs->Formats[(unsigned)FormatIndex].Flags_HashHandler();
+ }
+};
+
+struct CArchiveLink
+{
+ CObjectVector<CArc> Arcs;
+ UStringVector VolumePaths;
+ UInt64 VolumesSize;
+ bool IsOpen;
+
+ bool PasswordWasAsked;
+ // UString Password;
+
+ // int NonOpenErrorFormatIndex; // - 1 means no Error.
+ UString NonOpen_ArcPath;
+
+ CArcErrorInfo NonOpen_ErrorInfo;
+
+ // UString ErrorsText;
+ // void Set_ErrorsText();
+
+ CArchiveLink():
+ VolumesSize(0),
+ IsOpen(false),
+ PasswordWasAsked(false)
+ {}
+
+ void KeepModeForNextOpen();
+ HRESULT Close();
+ void Release();
+ ~CArchiveLink() { Release(); }
+
+ const CArc *GetArc() const { return &Arcs.Back(); }
+ IInArchive *GetArchive() const { return Arcs.Back().Archive; }
+ IArchiveGetRawProps *GetArchiveGetRawProps() const { return Arcs.Back().GetRawProps; }
+ IArchiveGetRootProps *GetArchiveGetRootProps() const { return Arcs.Back().GetRootProps; }
+
+ /*
+ Open() opens archive and COpenOptions::callback
+ Open2() uses COpenCallbackImp that implements Volumes and password callback
+ Open3() calls Open2() and callbackUI->Open_Finished();
+ Open_Strict() returns S_FALSE also in case, if there is non-open expected nested archive.
+ */
+
+ HRESULT Open(COpenOptions &options);
+ HRESULT Open2(COpenOptions &options, IOpenCallbackUI *callbackUI);
+ HRESULT Open3(COpenOptions &options, IOpenCallbackUI *callbackUI);
+
+ HRESULT Open_Strict(COpenOptions &options, IOpenCallbackUI *callbackUI)
+ {
+ HRESULT result = Open3(options, callbackUI);
+ if (result == S_OK && NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
+ result = S_FALSE;
+ return result;
+ }
+
+ HRESULT ReOpen(COpenOptions &options);
+};
+
+bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types);
+
+// bool IsHashType(const CObjectVector<COpenType> &types);
+
+
+struct CDirPathSortPair
+{
+ unsigned Len;
+ unsigned Index;
+
+ void SetNumSlashes(const FChar *s);
+
+ int Compare(const CDirPathSortPair &a) const
+ {
+ // We need sorting order where parent items will be after child items
+ if (Len < a.Len) return 1;
+ if (Len > a.Len) return -1;
+ if (Index < a.Index) return -1;
+ if (Index > a.Index) return 1;
+ return 0;
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/PropIDUtils.cpp b/CPP/7zip/UI/Common/PropIDUtils.cpp
index bb9c89f..ee9ff32 100644
--- a/CPP/7zip/UI/Common/PropIDUtils.cpp
+++ b/CPP/7zip/UI/Common/PropIDUtils.cpp
@@ -1,668 +1,741 @@
-// PropIDUtils.cpp
-
-#include "StdAfx.h"
-
-#include "../../../../C/CpuArch.h"
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/FileIO.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#include "../../PropID.h"
-
-#include "PropIDUtils.h"
-
-#define Get16(x) GetUi16(x)
-#define Get32(x) GetUi32(x)
-
-using namespace NWindows;
-
-static const unsigned kNumWinAtrribFlags = 21;
-static const char g_WinAttribChars[kNumWinAtrribFlags + 1] = "RHS8DAdNTsLCOIEV.X.PU";
-
-/*
-FILE_ATTRIBUTE_
-
-0 READONLY
-1 HIDDEN
-2 SYSTEM
-3 (Volume label - obsolete)
-4 DIRECTORY
-5 ARCHIVE
-6 DEVICE
-7 NORMAL
-8 TEMPORARY
-9 SPARSE_FILE
-10 REPARSE_POINT
-11 COMPRESSED
-12 OFFLINE
-13 NOT_CONTENT_INDEXED (I - Win10 attrib/Explorer)
-14 ENCRYPTED
-15 INTEGRITY_STREAM (V - ReFS Win8/Win2012)
-16 VIRTUAL (reserved)
-17 NO_SCRUB_DATA (X - ReFS Win8/Win2012 attrib)
-18 RECALL_ON_OPEN or EA
-19 PINNED
-20 UNPINNED
-21 STRICTLY_SEQUENTIAL
-22 RECALL_ON_DATA_ACCESS
-*/
-
-
-static const char kPosixTypes[16] = { '0', 'p', 'c', '3', 'd', '5', 'b', '7', '-', '9', 'l', 'B', 's', 'D', 'E', 'F' };
-#define MY_ATTR_CHAR(a, n, c) ((a) & (1 << (n))) ? c : '-';
-
-static void ConvertPosixAttribToString(char *s, UInt32 a) throw()
-{
- s[0] = kPosixTypes[(a >> 12) & 0xF];
- for (int i = 6; i >= 0; i -= 3)
- {
- s[7 - i] = MY_ATTR_CHAR(a, i + 2, 'r');
- s[8 - i] = MY_ATTR_CHAR(a, i + 1, 'w');
- s[9 - i] = MY_ATTR_CHAR(a, i + 0, 'x');
- }
- if ((a & 0x800) != 0) s[3] = ((a & (1 << 6)) ? 's' : 'S');
- if ((a & 0x400) != 0) s[6] = ((a & (1 << 3)) ? 's' : 'S');
- if ((a & 0x200) != 0) s[9] = ((a & (1 << 0)) ? 't' : 'T');
- s[10] = 0;
-
- a &= ~(UInt32)0xFFFF;
- if (a != 0)
- {
- s[10] = ' ';
- ConvertUInt32ToHex8Digits(a, s + 11);
- }
-}
-
-
-void ConvertWinAttribToString(char *s, UInt32 wa) throw()
-{
- /*
- some programs store posix attributes in high 16 bits.
- p7zip - stores additional 0x8000 flag marker.
- macos - stores additional 0x4000 flag marker.
- info-zip - no additional marker.
- */
-
- bool isPosix = ((wa & 0xF0000000) != 0);
-
- UInt32 posix = 0;
- if (isPosix)
- {
- posix = wa >> 16;
- wa &= (UInt32)0x3FFF;
- }
-
- for (unsigned i = 0; i < kNumWinAtrribFlags; i++)
- {
- UInt32 flag = (1 << i);
- if ((wa & flag) != 0)
- {
- char c = g_WinAttribChars[i];
- if (c != '.')
- {
- wa &= ~flag;
- // if (i != 7) // we can disable N (NORMAL) printing
- *s++ = c;
- }
- }
- }
-
- if (wa != 0)
- {
- *s++ = ' ';
- ConvertUInt32ToHex8Digits(wa, s);
- s += strlen(s);
- }
-
- *s = 0;
-
- if (isPosix)
- {
- *s++ = ' ';
- ConvertPosixAttribToString(s, posix);
- }
-}
-
-
-void ConvertPropertyToShortString2(char *dest, const PROPVARIANT &prop, PROPID propID, int level) throw()
-{
- *dest = 0;
-
- if (prop.vt == VT_FILETIME)
- {
- const FILETIME &ft = prop.filetime;
- if ((ft.dwHighDateTime == 0 &&
- ft.dwLowDateTime == 0))
- return;
- ConvertUtcFileTimeToString(prop.filetime, dest, level);
- return;
- }
-
- switch (propID)
- {
- case kpidCRC:
- {
- if (prop.vt != VT_UI4)
- break;
- ConvertUInt32ToHex8Digits(prop.ulVal, dest);
- return;
- }
- case kpidAttrib:
- {
- if (prop.vt != VT_UI4)
- break;
- UInt32 a = prop.ulVal;
-
- /*
- if ((a & 0x8000) && (a & 0x7FFF) == 0)
- ConvertPosixAttribToString(dest, a >> 16);
- else
- */
- ConvertWinAttribToString(dest, a);
- return;
- }
- case kpidPosixAttrib:
- {
- if (prop.vt != VT_UI4)
- break;
- ConvertPosixAttribToString(dest, prop.ulVal);
- return;
- }
- case kpidINode:
- {
- if (prop.vt != VT_UI8)
- break;
- ConvertUInt32ToString((UInt32)(prop.uhVal.QuadPart >> 48), dest);
- dest += strlen(dest);
- *dest++ = '-';
- UInt64 low = prop.uhVal.QuadPart & (((UInt64)1 << 48) - 1);
- ConvertUInt64ToString(low, dest);
- return;
- }
- case kpidVa:
- {
- UInt64 v = 0;
- if (prop.vt == VT_UI4)
- v = prop.ulVal;
- else if (prop.vt == VT_UI8)
- v = (UInt64)prop.uhVal.QuadPart;
- else
- break;
- dest[0] = '0';
- dest[1] = 'x';
- ConvertUInt64ToHex(v, dest + 2);
- return;
- }
- }
-
- ConvertPropVariantToShortString(prop, dest);
-}
-
-void ConvertPropertyToString2(UString &dest, const PROPVARIANT &prop, PROPID propID, int level)
-{
- if (prop.vt == VT_BSTR)
- {
- dest.SetFromBstr(prop.bstrVal);
- return;
- }
- char temp[64];
- ConvertPropertyToShortString2(temp, prop, propID, level);
- dest = temp;
-}
-
-static inline unsigned GetHex(unsigned v)
-{
- return (v < 10) ? ('0' + v) : ('A' + (v - 10));
-}
-
-#ifndef _SFX
-
-static inline void AddHexToString(AString &res, unsigned v)
-{
- res += (char)GetHex(v >> 4);
- res += (char)GetHex(v & 0xF);
-}
-
-/*
-static AString Data_To_Hex(const Byte *data, size_t size)
-{
- AString s;
- for (size_t i = 0; i < size; i++)
- AddHexToString(s, data[i]);
- return s;
-}
-*/
-
-static const char * const sidNames[] =
-{
- "0"
- , "Dialup"
- , "Network"
- , "Batch"
- , "Interactive"
- , "Logon" // S-1-5-5-X-Y
- , "Service"
- , "Anonymous"
- , "Proxy"
- , "EnterpriseDC"
- , "Self"
- , "AuthenticatedUsers"
- , "RestrictedCode"
- , "TerminalServer"
- , "RemoteInteractiveLogon"
- , "ThisOrganization"
- , "16"
- , "IUserIIS"
- , "LocalSystem"
- , "LocalService"
- , "NetworkService"
- , "Domains"
-};
-
-struct CSecID2Name
-{
- UInt32 n;
- const char *sz;
-};
-
-static int FindPairIndex(const CSecID2Name * pairs, unsigned num, UInt32 id)
-{
- for (unsigned i = 0; i < num; i++)
- if (pairs[i].n == id)
- return i;
- return -1;
-}
-
-static const CSecID2Name sid_32_Names[] =
-{
- { 544, "Administrators" },
- { 545, "Users" },
- { 546, "Guests" },
- { 547, "PowerUsers" },
- { 548, "AccountOperators" },
- { 549, "ServerOperators" },
- { 550, "PrintOperators" },
- { 551, "BackupOperators" },
- { 552, "Replicators" },
- { 553, "Backup Operators" },
- { 554, "PreWindows2000CompatibleAccess" },
- { 555, "RemoteDesktopUsers" },
- { 556, "NetworkConfigurationOperators" },
- { 557, "IncomingForestTrustBuilders" },
- { 558, "PerformanceMonitorUsers" },
- { 559, "PerformanceLogUsers" },
- { 560, "WindowsAuthorizationAccessGroup" },
- { 561, "TerminalServerLicenseServers" },
- { 562, "DistributedCOMUsers" },
- { 569, "CryptographicOperators" },
- { 573, "EventLogReaders" },
- { 574, "CertificateServiceDCOMAccess" }
-};
-
-static const CSecID2Name sid_21_Names[] =
-{
- { 500, "Administrator" },
- { 501, "Guest" },
- { 502, "KRBTGT" },
- { 512, "DomainAdmins" },
- { 513, "DomainUsers" },
- { 515, "DomainComputers" },
- { 516, "DomainControllers" },
- { 517, "CertPublishers" },
- { 518, "SchemaAdmins" },
- { 519, "EnterpriseAdmins" },
- { 520, "GroupPolicyCreatorOwners" },
- { 553, "RASandIASServers" },
- { 553, "RASandIASServers" },
- { 571, "AllowedRODCPasswordReplicationGroup" },
- { 572, "DeniedRODCPasswordReplicationGroup" }
-};
-
-struct CServicesToName
-{
- UInt32 n[5];
- const char *sz;
-};
-
-static const CServicesToName services_to_name[] =
-{
- { { 0x38FB89B5, 0xCBC28419, 0x6D236C5C, 0x6E770057, 0x876402C0 } , "TrustedInstaller" }
-};
-
-static void ParseSid(AString &s, const Byte *p, UInt32 lim, UInt32 &sidSize)
-{
- sidSize = 0;
- if (lim < 8)
- {
- s += "ERROR";
- return;
- }
- UInt32 rev = p[0];
- if (rev != 1)
- {
- s += "UNSUPPORTED";
- return;
- }
- UInt32 num = p[1];
- if (8 + num * 4 > lim)
- {
- s += "ERROR";
- return;
- }
- sidSize = 8 + num * 4;
- UInt32 authority = GetBe32(p + 4);
-
- if (p[2] == 0 && p[3] == 0 && authority == 5 && num >= 1)
- {
- UInt32 v0 = Get32(p + 8);
- if (v0 < ARRAY_SIZE(sidNames))
- {
- s += sidNames[v0];
- return;
- }
- if (v0 == 32 && num == 2)
- {
- UInt32 v1 = Get32(p + 12);
- int index = FindPairIndex(sid_32_Names, ARRAY_SIZE(sid_32_Names), v1);
- if (index >= 0)
- {
- s += sid_32_Names[(unsigned)index].sz;
- return;
- }
- }
- if (v0 == 21 && num == 5)
- {
- UInt32 v4 = Get32(p + 8 + 4 * 4);
- int index = FindPairIndex(sid_21_Names, ARRAY_SIZE(sid_21_Names), v4);
- if (index >= 0)
- {
- s += sid_21_Names[(unsigned)index].sz;
- return;
- }
- }
- if (v0 == 80 && num == 6)
- {
- for (unsigned i = 0; i < ARRAY_SIZE(services_to_name); i++)
- {
- const CServicesToName &sn = services_to_name[i];
- int j;
- for (j = 0; j < 5 && sn.n[j] == Get32(p + 8 + 4 + j * 4); j++);
- if (j == 5)
- {
- s += sn.sz;
- return;
- }
- }
- }
- }
-
- s += "S-1-";
- if (p[2] == 0 && p[3] == 0)
- s.Add_UInt32(authority);
- else
- {
- s += "0x";
- for (int i = 2; i < 8; i++)
- AddHexToString(s, p[i]);
- }
- for (UInt32 i = 0; i < num; i++)
- {
- s += '-';
- s.Add_UInt32(Get32(p + 8 + i * 4));
- }
-}
-
-static void ParseOwner(AString &s, const Byte *p, UInt32 size, UInt32 pos)
-{
- if (pos > size)
- {
- s += "ERROR";
- return;
- }
- UInt32 sidSize = 0;
- ParseSid(s, p + pos, size - pos, sidSize);
-}
-
-static void ParseAcl(AString &s, const Byte *p, UInt32 size, const char *strName, UInt32 flags, UInt32 offset)
-{
- UInt32 control = Get16(p + 2);
- if ((flags & control) == 0)
- return;
- UInt32 pos = Get32(p + offset);
- s.Add_Space();
- s += strName;
- if (pos >= size)
- return;
- p += pos;
- size -= pos;
- if (size < 8)
- return;
- if (Get16(p) != 2) // revision
- return;
- UInt32 num = Get32(p + 4);
- s.Add_UInt32(num);
-
- /*
- UInt32 aclSize = Get16(p + 2);
- if (num >= (1 << 16))
- return;
- if (aclSize > size)
- return;
- size = aclSize;
- size -= 8;
- p += 8;
- for (UInt32 i = 0 ; i < num; i++)
- {
- if (size <= 8)
- return;
- // Byte type = p[0];
- // Byte flags = p[1];
- // UInt32 aceSize = Get16(p + 2);
- // UInt32 mask = Get32(p + 4);
- p += 8;
- size -= 8;
-
- UInt32 sidSize = 0;
- s.Add_Space();
- ParseSid(s, p, size, sidSize);
- if (sidSize == 0)
- return;
- p += sidSize;
- size -= sidSize;
- }
-
- // the tail can contain zeros. So (size != 0) is not ERROR
- // if (size != 0) s += " ERROR";
- */
-}
-
-#define MY_SE_OWNER_DEFAULTED (0x0001)
-#define MY_SE_GROUP_DEFAULTED (0x0002)
-#define MY_SE_DACL_PRESENT (0x0004)
-#define MY_SE_DACL_DEFAULTED (0x0008)
-#define MY_SE_SACL_PRESENT (0x0010)
-#define MY_SE_SACL_DEFAULTED (0x0020)
-#define MY_SE_DACL_AUTO_INHERIT_REQ (0x0100)
-#define MY_SE_SACL_AUTO_INHERIT_REQ (0x0200)
-#define MY_SE_DACL_AUTO_INHERITED (0x0400)
-#define MY_SE_SACL_AUTO_INHERITED (0x0800)
-#define MY_SE_DACL_PROTECTED (0x1000)
-#define MY_SE_SACL_PROTECTED (0x2000)
-#define MY_SE_RM_CONTROL_VALID (0x4000)
-#define MY_SE_SELF_RELATIVE (0x8000)
-
-void ConvertNtSecureToString(const Byte *data, UInt32 size, AString &s)
-{
- s.Empty();
- if (size < 20 || size > (1 << 18))
- {
- s += "ERROR";
- return;
- }
- if (Get16(data) != 1) // revision
- {
- s += "UNSUPPORTED";
- return;
- }
- ParseOwner(s, data, size, Get32(data + 4));
- s.Add_Space();
- ParseOwner(s, data, size, Get32(data + 8));
- ParseAcl(s, data, size, "s:", MY_SE_SACL_PRESENT, 12);
- ParseAcl(s, data, size, "d:", MY_SE_DACL_PRESENT, 16);
- s.Add_Space();
- s.Add_UInt32(size);
- // s += '\n';
- // s += Data_To_Hex(data, size);
-}
-
-#ifdef _WIN32
-
-static bool CheckSid(const Byte *data, UInt32 size, UInt32 pos) throw()
-{
- if (pos >= size)
- return false;
- size -= pos;
- if (size < 8)
- return false;
- UInt32 rev = data[pos];
- if (rev != 1)
- return false;
- UInt32 num = data[pos + 1];
- return (8 + num * 4 <= size);
-}
-
-static bool CheckAcl(const Byte *p, UInt32 size, UInt32 flags, UInt32 offset) throw()
-{
- UInt32 control = Get16(p + 2);
- if ((flags & control) == 0)
- return true;
- UInt32 pos = Get32(p + offset);
- if (pos >= size)
- return false;
- p += pos;
- size -= pos;
- if (size < 8)
- return false;
- UInt32 aclSize = Get16(p + 2);
- return (aclSize <= size);
-}
-
-bool CheckNtSecure(const Byte *data, UInt32 size) throw()
-{
- if (size < 20)
- return false;
- if (Get16(data) != 1) // revision
- return true; // windows function can handle such error, so we allow it
- if (size > (1 << 18))
- return false;
- if (!CheckSid(data, size, Get32(data + 4))) return false;
- if (!CheckSid(data, size, Get32(data + 8))) return false;
- if (!CheckAcl(data, size, MY_SE_SACL_PRESENT, 12)) return false;
- if (!CheckAcl(data, size, MY_SE_DACL_PRESENT, 16)) return false;
- return true;
-}
-
-#endif
-
-
-
-// IO_REPARSE_TAG_*
-
-static const CSecID2Name k_ReparseTags[] =
-{
- { 0xA0000003, "MOUNT_POINT" },
- { 0xC0000004, "HSM" },
- { 0x80000005, "DRIVE_EXTENDER" },
- { 0x80000006, "HSM2" },
- { 0x80000007, "SIS" },
- { 0x80000008, "WIM" },
- { 0x80000009, "CSV" },
- { 0x8000000A, "DFS" },
- { 0x8000000B, "FILTER_MANAGER" },
- { 0xA000000C, "SYMLINK" },
- { 0xA0000010, "IIS_CACHE" },
- { 0x80000012, "DFSR" },
- { 0x80000013, "DEDUP" },
- { 0xC0000014, "APPXSTRM" },
- { 0x80000014, "NFS" },
- { 0x80000015, "FILE_PLACEHOLDER" },
- { 0x80000016, "DFM" },
- { 0x80000017, "WOF" }
-};
-
-bool ConvertNtReparseToString(const Byte *data, UInt32 size, UString &s)
-{
- s.Empty();
- NFile::CReparseAttr attr;
- DWORD errorCode = 0;
- if (attr.Parse(data, size, errorCode))
- {
- if (!attr.IsSymLink())
- s += "Junction: ";
- s += attr.GetPath();
- if (!attr.IsOkNamePair())
- {
- s += " : ";
- s += attr.PrintName;
- }
- return true;
- }
-
- if (size < 8)
- return false;
- UInt32 tag = Get32(data);
- UInt32 len = Get16(data + 4);
- if (len + 8 > size)
- return false;
- if (Get16(data + 6) != 0) // padding
- return false;
-
- /*
- #define _my_IO_REPARSE_TAG_DEDUP (0x80000013L)
- if (tag == _my_IO_REPARSE_TAG_DEDUP)
- {
- }
- */
-
- {
- int index = FindPairIndex(k_ReparseTags, ARRAY_SIZE(k_ReparseTags), tag);
- if (index >= 0)
- s += k_ReparseTags[(unsigned)index].sz;
- else
- {
- s += "REPARSE:";
- char hex[16];
- ConvertUInt32ToHex8Digits(tag, hex);
- s += hex;
- }
- }
-
- s += ":";
- s.Add_UInt32(len);
-
- if (len != 0)
- {
- s.Add_Space();
-
- data += 8;
-
- for (UInt32 i = 0; i < len; i++)
- {
- if (i >= 8)
- {
- s += "...";
- break;
- }
- unsigned b = data[i];
- s += (char)GetHex((b >> 4) & 0xF);
- s += (char)GetHex(b & 0xF);
- }
- }
-
- return true;
-}
-
-#endif
+// PropIDUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../PropID.h"
+
+#include "PropIDUtils.h"
+
+#ifndef Z7_SFX
+#define Get16(x) GetUi16(x)
+#define Get32(x) GetUi32(x)
+#endif
+
+using namespace NWindows;
+
+static const unsigned kNumWinAtrribFlags = 21;
+static const char g_WinAttribChars[kNumWinAtrribFlags + 1] = "RHS8DAdNTsLCOIEV.X.PU";
+
+/*
+FILE_ATTRIBUTE_
+
+0 READONLY
+1 HIDDEN
+2 SYSTEM
+3 (Volume label - obsolete)
+4 DIRECTORY
+5 ARCHIVE
+6 DEVICE
+7 NORMAL
+8 TEMPORARY
+9 SPARSE_FILE
+10 REPARSE_POINT
+11 COMPRESSED
+12 OFFLINE
+13 NOT_CONTENT_INDEXED (I - Win10 attrib/Explorer)
+14 ENCRYPTED
+15 INTEGRITY_STREAM (V - ReFS Win8/Win2012)
+16 VIRTUAL (reserved)
+17 NO_SCRUB_DATA (X - ReFS Win8/Win2012 attrib)
+18 RECALL_ON_OPEN or EA
+19 PINNED
+20 UNPINNED
+21 STRICTLY_SEQUENTIAL
+22 RECALL_ON_DATA_ACCESS
+*/
+
+
+static const char kPosixTypes[16] = { '0', 'p', 'c', '3', 'd', '5', 'b', '7', '-', '9', 'l', 'B', 's', 'D', 'E', 'F' };
+#define MY_ATTR_CHAR(a, n, c) (((a) & (1 << (n))) ? c : '-')
+
+static void ConvertPosixAttribToString(char *s, UInt32 a) throw()
+{
+ s[0] = kPosixTypes[(a >> 12) & 0xF];
+ for (int i = 6; i >= 0; i -= 3)
+ {
+ s[7 - i] = MY_ATTR_CHAR(a, i + 2, 'r');
+ s[8 - i] = MY_ATTR_CHAR(a, i + 1, 'w');
+ s[9 - i] = MY_ATTR_CHAR(a, i + 0, 'x');
+ }
+ if ((a & 0x800) != 0) s[3] = ((a & (1 << 6)) ? 's' : 'S'); // S_ISUID
+ if ((a & 0x400) != 0) s[6] = ((a & (1 << 3)) ? 's' : 'S'); // S_ISGID
+ if ((a & 0x200) != 0) s[9] = ((a & (1 << 0)) ? 't' : 'T'); // S_ISVTX
+ s[10] = 0;
+
+ a &= ~(UInt32)0xFFFF;
+ if (a != 0)
+ {
+ s[10] = ' ';
+ ConvertUInt32ToHex8Digits(a, s + 11);
+ }
+}
+
+
+void ConvertWinAttribToString(char *s, UInt32 wa) throw()
+{
+ /*
+ some programs store posix attributes in high 16 bits.
+ p7zip - stores additional 0x8000 flag marker.
+ macos - stores additional 0x4000 flag marker.
+ info-zip - no additional marker.
+ */
+
+ const bool isPosix = ((wa & 0xF0000000) != 0);
+
+ UInt32 posix = 0;
+ if (isPosix)
+ {
+ posix = wa >> 16;
+ wa &= (UInt32)0x3FFF;
+ }
+
+ for (unsigned i = 0; i < kNumWinAtrribFlags; i++)
+ {
+ UInt32 flag = (1 << i);
+ if ((wa & flag) != 0)
+ {
+ char c = g_WinAttribChars[i];
+ if (c != '.')
+ {
+ wa &= ~flag;
+ // if (i != 7) // we can disable N (NORMAL) printing
+ *s++ = c;
+ }
+ }
+ }
+
+ if (wa != 0)
+ {
+ *s++ = ' ';
+ ConvertUInt32ToHex8Digits(wa, s);
+ s += strlen(s);
+ }
+
+ *s = 0;
+
+ if (isPosix)
+ {
+ *s++ = ' ';
+ ConvertPosixAttribToString(s, posix);
+ }
+}
+
+
+void ConvertPropertyToShortString2(char *dest, const PROPVARIANT &prop, PROPID propID, int level) throw()
+{
+ *dest = 0;
+
+ if (prop.vt == VT_FILETIME)
+ {
+ const FILETIME &ft = prop.filetime;
+ unsigned ns100 = 0;
+ int numDigits = kTimestampPrintLevel_NTFS;
+ const unsigned prec = prop.wReserved1;
+ const unsigned ns100_Temp = prop.wReserved2;
+ if (prec != 0
+ && prec <= k_PropVar_TimePrec_1ns
+ && ns100_Temp < 100
+ && prop.wReserved3 == 0)
+ {
+ ns100 = ns100_Temp;
+ if (prec == k_PropVar_TimePrec_Unix ||
+ prec == k_PropVar_TimePrec_DOS)
+ numDigits = 0;
+ else if (prec == k_PropVar_TimePrec_HighPrec)
+ numDigits = 9;
+ else
+ {
+ numDigits = (int)prec - (int)k_PropVar_TimePrec_Base;
+ if (
+ // numDigits < kTimestampPrintLevel_DAY // for debuf
+ numDigits < kTimestampPrintLevel_SEC
+ )
+
+ numDigits = kTimestampPrintLevel_NTFS;
+ }
+ }
+ if (ft.dwHighDateTime == 0 && ft.dwLowDateTime == 0 && ns100 == 0)
+ return;
+ if (level > numDigits)
+ level = numDigits;
+ ConvertUtcFileTimeToString2(ft, ns100, dest, level);
+ return;
+ }
+
+ switch (propID)
+ {
+ case kpidCRC:
+ {
+ if (prop.vt != VT_UI4)
+ break;
+ ConvertUInt32ToHex8Digits(prop.ulVal, dest);
+ return;
+ }
+ case kpidAttrib:
+ {
+ if (prop.vt != VT_UI4)
+ break;
+ const UInt32 a = prop.ulVal;
+
+ /*
+ if ((a & 0x8000) && (a & 0x7FFF) == 0)
+ ConvertPosixAttribToString(dest, a >> 16);
+ else
+ */
+ ConvertWinAttribToString(dest, a);
+ return;
+ }
+ case kpidPosixAttrib:
+ {
+ if (prop.vt != VT_UI4)
+ break;
+ ConvertPosixAttribToString(dest, prop.ulVal);
+ return;
+ }
+ case kpidINode:
+ {
+ if (prop.vt != VT_UI8)
+ break;
+ ConvertUInt32ToString((UInt32)(prop.uhVal.QuadPart >> 48), dest);
+ dest += strlen(dest);
+ *dest++ = '-';
+ const UInt64 low = prop.uhVal.QuadPart & (((UInt64)1 << 48) - 1);
+ ConvertUInt64ToString(low, dest);
+ return;
+ }
+ case kpidVa:
+ {
+ UInt64 v = 0;
+ if (prop.vt == VT_UI4)
+ v = prop.ulVal;
+ else if (prop.vt == VT_UI8)
+ v = (UInt64)prop.uhVal.QuadPart;
+ else
+ break;
+ dest[0] = '0';
+ dest[1] = 'x';
+ ConvertUInt64ToHex(v, dest + 2);
+ return;
+ }
+
+ /*
+ case kpidDevice:
+ {
+ UInt64 v = 0;
+ if (prop.vt == VT_UI4)
+ v = prop.ulVal;
+ else if (prop.vt == VT_UI8)
+ v = (UInt64)prop.uhVal.QuadPart;
+ else
+ break;
+ ConvertUInt32ToString(MY_dev_major(v), dest);
+ dest += strlen(dest);
+ *dest++ = ',';
+ ConvertUInt32ToString(MY_dev_minor(v), dest);
+ return;
+ }
+ */
+ }
+
+ ConvertPropVariantToShortString(prop, dest);
+}
+
+void ConvertPropertyToString2(UString &dest, const PROPVARIANT &prop, PROPID propID, int level)
+{
+ if (prop.vt == VT_BSTR)
+ {
+ dest.SetFromBstr(prop.bstrVal);
+ return;
+ }
+ char temp[64];
+ ConvertPropertyToShortString2(temp, prop, propID, level);
+ dest = temp;
+}
+
+#ifndef Z7_SFX
+
+static inline unsigned GetHex(unsigned v)
+{
+ return (v < 10) ? ('0' + v) : ('A' + (v - 10));
+}
+
+static inline void AddHexToString(AString &res, unsigned v)
+{
+ res += (char)GetHex(v >> 4);
+ res += (char)GetHex(v & 0xF);
+}
+
+/*
+static AString Data_To_Hex(const Byte *data, size_t size)
+{
+ AString s;
+ for (size_t i = 0; i < size; i++)
+ AddHexToString(s, data[i]);
+ return s;
+}
+*/
+
+static const char * const sidNames[] =
+{
+ "0"
+ , "Dialup"
+ , "Network"
+ , "Batch"
+ , "Interactive"
+ , "Logon" // S-1-5-5-X-Y
+ , "Service"
+ , "Anonymous"
+ , "Proxy"
+ , "EnterpriseDC"
+ , "Self"
+ , "AuthenticatedUsers"
+ , "RestrictedCode"
+ , "TerminalServer"
+ , "RemoteInteractiveLogon"
+ , "ThisOrganization"
+ , "16"
+ , "IUserIIS"
+ , "LocalSystem"
+ , "LocalService"
+ , "NetworkService"
+ , "Domains"
+};
+
+struct CSecID2Name
+{
+ UInt32 n;
+ const char *sz;
+};
+
+static int FindPairIndex(const CSecID2Name * pairs, unsigned num, UInt32 id)
+{
+ for (unsigned i = 0; i < num; i++)
+ if (pairs[i].n == id)
+ return (int)i;
+ return -1;
+}
+
+static const CSecID2Name sid_32_Names[] =
+{
+ { 544, "Administrators" },
+ { 545, "Users" },
+ { 546, "Guests" },
+ { 547, "PowerUsers" },
+ { 548, "AccountOperators" },
+ { 549, "ServerOperators" },
+ { 550, "PrintOperators" },
+ { 551, "BackupOperators" },
+ { 552, "Replicators" },
+ { 553, "Backup Operators" },
+ { 554, "PreWindows2000CompatibleAccess" },
+ { 555, "RemoteDesktopUsers" },
+ { 556, "NetworkConfigurationOperators" },
+ { 557, "IncomingForestTrustBuilders" },
+ { 558, "PerformanceMonitorUsers" },
+ { 559, "PerformanceLogUsers" },
+ { 560, "WindowsAuthorizationAccessGroup" },
+ { 561, "TerminalServerLicenseServers" },
+ { 562, "DistributedCOMUsers" },
+ { 569, "CryptographicOperators" },
+ { 573, "EventLogReaders" },
+ { 574, "CertificateServiceDCOMAccess" }
+};
+
+static const CSecID2Name sid_21_Names[] =
+{
+ { 500, "Administrator" },
+ { 501, "Guest" },
+ { 502, "KRBTGT" },
+ { 512, "DomainAdmins" },
+ { 513, "DomainUsers" },
+ { 515, "DomainComputers" },
+ { 516, "DomainControllers" },
+ { 517, "CertPublishers" },
+ { 518, "SchemaAdmins" },
+ { 519, "EnterpriseAdmins" },
+ { 520, "GroupPolicyCreatorOwners" },
+ { 553, "RASandIASServers" },
+ { 553, "RASandIASServers" },
+ { 571, "AllowedRODCPasswordReplicationGroup" },
+ { 572, "DeniedRODCPasswordReplicationGroup" }
+};
+
+struct CServicesToName
+{
+ UInt32 n[5];
+ const char *sz;
+};
+
+static const CServicesToName services_to_name[] =
+{
+ { { 0x38FB89B5, 0xCBC28419, 0x6D236C5C, 0x6E770057, 0x876402C0 } , "TrustedInstaller" }
+};
+
+static void ParseSid(AString &s, const Byte *p, UInt32 lim, UInt32 &sidSize)
+{
+ sidSize = 0;
+ if (lim < 8)
+ {
+ s += "ERROR";
+ return;
+ }
+ const UInt32 rev = p[0];
+ if (rev != 1)
+ {
+ s += "UNSUPPORTED";
+ return;
+ }
+ const UInt32 num = p[1];
+ if (8 + num * 4 > lim)
+ {
+ s += "ERROR";
+ return;
+ }
+ sidSize = 8 + num * 4;
+ const UInt32 authority = GetBe32(p + 4);
+
+ if (p[2] == 0 && p[3] == 0 && authority == 5 && num >= 1)
+ {
+ const UInt32 v0 = Get32(p + 8);
+ if (v0 < Z7_ARRAY_SIZE(sidNames))
+ {
+ s += sidNames[v0];
+ return;
+ }
+ if (v0 == 32 && num == 2)
+ {
+ const UInt32 v1 = Get32(p + 12);
+ const int index = FindPairIndex(sid_32_Names, Z7_ARRAY_SIZE(sid_32_Names), v1);
+ if (index >= 0)
+ {
+ s += sid_32_Names[(unsigned)index].sz;
+ return;
+ }
+ }
+ if (v0 == 21 && num == 5)
+ {
+ UInt32 v4 = Get32(p + 8 + 4 * 4);
+ const int index = FindPairIndex(sid_21_Names, Z7_ARRAY_SIZE(sid_21_Names), v4);
+ if (index >= 0)
+ {
+ s += sid_21_Names[(unsigned)index].sz;
+ return;
+ }
+ }
+ if (v0 == 80 && num == 6)
+ {
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(services_to_name); i++)
+ {
+ const CServicesToName &sn = services_to_name[i];
+ int j;
+ for (j = 0; j < 5 && sn.n[j] == Get32(p + 8 + 4 + j * 4); j++);
+ if (j == 5)
+ {
+ s += sn.sz;
+ return;
+ }
+ }
+ }
+ }
+
+ s += "S-1-";
+ if (p[2] == 0 && p[3] == 0)
+ s.Add_UInt32(authority);
+ else
+ {
+ s += "0x";
+ for (int i = 2; i < 8; i++)
+ AddHexToString(s, p[i]);
+ }
+ for (UInt32 i = 0; i < num; i++)
+ {
+ s.Add_Minus();
+ s.Add_UInt32(Get32(p + 8 + i * 4));
+ }
+}
+
+static void ParseOwner(AString &s, const Byte *p, UInt32 size, UInt32 pos)
+{
+ if (pos > size)
+ {
+ s += "ERROR";
+ return;
+ }
+ UInt32 sidSize = 0;
+ ParseSid(s, p + pos, size - pos, sidSize);
+}
+
+static void ParseAcl(AString &s, const Byte *p, UInt32 size, const char *strName, UInt32 flags, UInt32 offset)
+{
+ const UInt32 control = Get16(p + 2);
+ if ((flags & control) == 0)
+ return;
+ const UInt32 pos = Get32(p + offset);
+ s.Add_Space();
+ s += strName;
+ if (pos >= size)
+ return;
+ p += pos;
+ size -= pos;
+ if (size < 8)
+ return;
+ if (Get16(p) != 2) // revision
+ return;
+ const UInt32 num = Get32(p + 4);
+ s.Add_UInt32(num);
+
+ /*
+ UInt32 aclSize = Get16(p + 2);
+ if (num >= (1 << 16))
+ return;
+ if (aclSize > size)
+ return;
+ size = aclSize;
+ size -= 8;
+ p += 8;
+ for (UInt32 i = 0 ; i < num; i++)
+ {
+ if (size <= 8)
+ return;
+ // Byte type = p[0];
+ // Byte flags = p[1];
+ // UInt32 aceSize = Get16(p + 2);
+ // UInt32 mask = Get32(p + 4);
+ p += 8;
+ size -= 8;
+
+ UInt32 sidSize = 0;
+ s.Add_Space();
+ ParseSid(s, p, size, sidSize);
+ if (sidSize == 0)
+ return;
+ p += sidSize;
+ size -= sidSize;
+ }
+
+ // the tail can contain zeros. So (size != 0) is not ERROR
+ // if (size != 0) s += " ERROR";
+ */
+}
+
+/*
+#define MY_SE_OWNER_DEFAULTED (0x0001)
+#define MY_SE_GROUP_DEFAULTED (0x0002)
+*/
+#define MY_SE_DACL_PRESENT (0x0004)
+/*
+#define MY_SE_DACL_DEFAULTED (0x0008)
+*/
+#define MY_SE_SACL_PRESENT (0x0010)
+/*
+#define MY_SE_SACL_DEFAULTED (0x0020)
+#define MY_SE_DACL_AUTO_INHERIT_REQ (0x0100)
+#define MY_SE_SACL_AUTO_INHERIT_REQ (0x0200)
+#define MY_SE_DACL_AUTO_INHERITED (0x0400)
+#define MY_SE_SACL_AUTO_INHERITED (0x0800)
+#define MY_SE_DACL_PROTECTED (0x1000)
+#define MY_SE_SACL_PROTECTED (0x2000)
+#define MY_SE_RM_CONTROL_VALID (0x4000)
+#define MY_SE_SELF_RELATIVE (0x8000)
+*/
+
+void ConvertNtSecureToString(const Byte *data, UInt32 size, AString &s)
+{
+ s.Empty();
+ if (size < 20 || size > (1 << 18))
+ {
+ s += "ERROR";
+ return;
+ }
+ if (Get16(data) != 1) // revision
+ {
+ s += "UNSUPPORTED";
+ return;
+ }
+ ParseOwner(s, data, size, Get32(data + 4));
+ s.Add_Space();
+ ParseOwner(s, data, size, Get32(data + 8));
+ ParseAcl(s, data, size, "s:", MY_SE_SACL_PRESENT, 12);
+ ParseAcl(s, data, size, "d:", MY_SE_DACL_PRESENT, 16);
+ s.Add_Space();
+ s.Add_UInt32(size);
+ // s += '\n';
+ // s += Data_To_Hex(data, size);
+}
+
+#ifdef _WIN32
+
+static bool CheckSid(const Byte *data, UInt32 size, UInt32 pos) throw()
+{
+ if (pos >= size)
+ return false;
+ size -= pos;
+ if (size < 8)
+ return false;
+ const UInt32 rev = data[pos];
+ if (rev != 1)
+ return false;
+ const UInt32 num = data[pos + 1];
+ return (8 + num * 4 <= size);
+}
+
+static bool CheckAcl(const Byte *p, UInt32 size, UInt32 flags, UInt32 offset) throw()
+{
+ const UInt32 control = Get16(p + 2);
+ if ((flags & control) == 0)
+ return true;
+ const UInt32 pos = Get32(p + offset);
+ if (pos >= size)
+ return false;
+ p += pos;
+ size -= pos;
+ if (size < 8)
+ return false;
+ const UInt32 aclSize = Get16(p + 2);
+ return (aclSize <= size);
+}
+
+bool CheckNtSecure(const Byte *data, UInt32 size) throw()
+{
+ if (size < 20)
+ return false;
+ if (Get16(data) != 1) // revision
+ return true; // windows function can handle such error, so we allow it
+ if (size > (1 << 18))
+ return false;
+ if (!CheckSid(data, size, Get32(data + 4))) return false;
+ if (!CheckSid(data, size, Get32(data + 8))) return false;
+ if (!CheckAcl(data, size, MY_SE_SACL_PRESENT, 12)) return false;
+ if (!CheckAcl(data, size, MY_SE_DACL_PRESENT, 16)) return false;
+ return true;
+}
+
+#endif
+
+
+
+// IO_REPARSE_TAG_*
+
+static const CSecID2Name k_ReparseTags[] =
+{
+ { 0xA0000003, "MOUNT_POINT" },
+ { 0xC0000004, "HSM" },
+ { 0x80000005, "DRIVE_EXTENDER" },
+ { 0x80000006, "HSM2" },
+ { 0x80000007, "SIS" },
+ { 0x80000008, "WIM" },
+ { 0x80000009, "CSV" },
+ { 0x8000000A, "DFS" },
+ { 0x8000000B, "FILTER_MANAGER" },
+ { 0xA000000C, "SYMLINK" },
+ { 0xA0000010, "IIS_CACHE" },
+ { 0x80000012, "DFSR" },
+ { 0x80000013, "DEDUP" },
+ { 0xC0000014, "APPXSTRM" },
+ { 0x80000014, "NFS" },
+ { 0x80000015, "FILE_PLACEHOLDER" },
+ { 0x80000016, "DFM" },
+ { 0x80000017, "WOF" },
+ { 0x80000018, "WCI" },
+ { 0x8000001B, "APPEXECLINK" },
+ { 0xA000001D, "LX_SYMLINK" },
+ { 0x80000023, "AF_UNIX" },
+ { 0x80000024, "LX_FIFO" },
+ { 0x80000025, "LX_CHR" },
+ { 0x80000026, "LX_BLK" }
+};
+
+bool ConvertNtReparseToString(const Byte *data, UInt32 size, UString &s)
+{
+ s.Empty();
+ NFile::CReparseAttr attr;
+
+ if (attr.Parse(data, size))
+ {
+ if (attr.IsSymLink_WSL())
+ {
+ s += "WSL: ";
+ s += attr.GetPath();
+ }
+ else
+ {
+ if (!attr.IsSymLink_Win())
+ s += "Junction: ";
+ s += attr.GetPath();
+ if (s.IsEmpty())
+ s += "Link: ";
+ if (!attr.IsOkNamePair())
+ {
+ s += " : ";
+ s += attr.PrintName;
+ }
+ }
+ if (attr.MinorError)
+ s += " : MINOR_ERROR";
+ return true;
+ // s += " "; // for debug
+ }
+
+ if (size < 8)
+ return false;
+ const UInt32 tag = Get32(data);
+ const UInt32 len = Get16(data + 4);
+ if (len + 8 > size)
+ return false;
+ if (Get16(data + 6) != 0) // padding
+ return false;
+
+ /*
+ #define my_IO_REPARSE_TAG_DEDUP (0x80000013L)
+ if (tag == my_IO_REPARSE_TAG_DEDUP)
+ {
+ }
+ */
+
+ {
+ const int index = FindPairIndex(k_ReparseTags, Z7_ARRAY_SIZE(k_ReparseTags), tag);
+ if (index >= 0)
+ s += k_ReparseTags[(unsigned)index].sz;
+ else
+ {
+ s += "REPARSE:";
+ char hex[16];
+ ConvertUInt32ToHex8Digits(tag, hex);
+ s += hex;
+ }
+ }
+
+ s += ":";
+ s.Add_UInt32(len);
+
+ if (len != 0)
+ {
+ s.Add_Space();
+
+ data += 8;
+
+ for (UInt32 i = 0; i < len; i++)
+ {
+ if (i >= 16)
+ {
+ s += "...";
+ break;
+ }
+ const unsigned b = data[i];
+ s += (char)GetHex((b >> 4) & 0xF);
+ s += (char)GetHex(b & 0xF);
+ }
+ }
+
+ return true;
+}
+
+#endif
diff --git a/CPP/7zip/UI/Common/PropIDUtils.h b/CPP/7zip/UI/Common/PropIDUtils.h
index e94e6d7..6df1e94 100644
--- a/CPP/7zip/UI/Common/PropIDUtils.h
+++ b/CPP/7zip/UI/Common/PropIDUtils.h
@@ -1,18 +1,18 @@
-// PropIDUtils.h
-
-#ifndef __PROPID_UTILS_H
-#define __PROPID_UTILS_H
-
-#include "../../../Common/MyString.h"
-
-// provide at least 64 bytes for buffer including zero-end
-void ConvertPropertyToShortString2(char *dest, const PROPVARIANT &propVariant, PROPID propID, int level = 0) throw();
-void ConvertPropertyToString2(UString &dest, const PROPVARIANT &propVariant, PROPID propID, int level = 0);
-
-bool ConvertNtReparseToString(const Byte *data, UInt32 size, UString &s);
-void ConvertNtSecureToString(const Byte *data, UInt32 size, AString &s);
-bool CheckNtSecure(const Byte *data, UInt32 size) throw();;
-
-void ConvertWinAttribToString(char *s, UInt32 wa) throw();
-
-#endif
+// PropIDUtils.h
+
+#ifndef ZIP7_INC_PROPID_UTILS_H
+#define ZIP7_INC_PROPID_UTILS_H
+
+#include "../../../Common/MyString.h"
+
+// provide at least 64 bytes for buffer including zero-end
+void ConvertPropertyToShortString2(char *dest, const PROPVARIANT &propVariant, PROPID propID, int level = 0) throw();
+void ConvertPropertyToString2(UString &dest, const PROPVARIANT &propVariant, PROPID propID, int level = 0);
+
+bool ConvertNtReparseToString(const Byte *data, UInt32 size, UString &s);
+void ConvertNtSecureToString(const Byte *data, UInt32 size, AString &s);
+bool CheckNtSecure(const Byte *data, UInt32 size) throw();
+
+void ConvertWinAttribToString(char *s, UInt32 wa) throw();
+
+#endif
diff --git a/CPP/7zip/UI/Common/Property.h b/CPP/7zip/UI/Common/Property.h
index 31234ad..0462809 100644
--- a/CPP/7zip/UI/Common/Property.h
+++ b/CPP/7zip/UI/Common/Property.h
@@ -1,14 +1,14 @@
-// Property.h
-
-#ifndef __7Z_PROPERTY_H
-#define __7Z_PROPERTY_H
-
-#include "../../../Common/MyString.h"
-
-struct CProperty
-{
- UString Name;
- UString Value;
-};
-
-#endif
+// Property.h
+
+#ifndef ZIP7_INC_7Z_PROPERTY_H
+#define ZIP7_INC_7Z_PROPERTY_H
+
+#include "../../../Common/MyString.h"
+
+struct CProperty
+{
+ UString Name;
+ UString Value;
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/SetProperties.cpp b/CPP/7zip/UI/Common/SetProperties.cpp
index 3cd4d57..5e15d9c 100644
--- a/CPP/7zip/UI/Common/SetProperties.cpp
+++ b/CPP/7zip/UI/Common/SetProperties.cpp
@@ -1,80 +1,88 @@
-// SetProperties.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/MyString.h"
-#include "../../../Common/StringToInt.h"
-
-#include "../../../Windows/PropVariant.h"
-
-#include "../../Archive/IArchive.h"
-
-#include "SetProperties.h"
-
-using namespace NWindows;
-using namespace NCOM;
-
-static void ParseNumberString(const UString &s, NCOM::CPropVariant &prop)
-{
- const wchar_t *end;
- UInt64 result = ConvertStringToUInt64(s, &end);
- if (*end != 0 || s.IsEmpty())
- prop = s;
- else if (result <= (UInt32)0xFFFFFFFF)
- prop = (UInt32)result;
- else
- prop = result;
-}
-
-HRESULT SetProperties(IUnknown *unknown, const CObjectVector<CProperty> &properties)
-{
- if (properties.IsEmpty())
- return S_OK;
- CMyComPtr<ISetProperties> setProperties;
- unknown->QueryInterface(IID_ISetProperties, (void **)&setProperties);
- if (!setProperties)
- return S_OK;
-
- UStringVector realNames;
- CPropVariant *values = new CPropVariant[properties.Size()];
- try
- {
- unsigned i;
- for (i = 0; i < properties.Size(); i++)
- {
- const CProperty &property = properties[i];
- NCOM::CPropVariant propVariant;
- UString name = property.Name;
- if (property.Value.IsEmpty())
- {
- if (!name.IsEmpty())
- {
- wchar_t c = name.Back();
- if (c == L'-')
- propVariant = false;
- else if (c == L'+')
- propVariant = true;
- if (propVariant.vt != VT_EMPTY)
- name.DeleteBack();
- }
- }
- else
- ParseNumberString(property.Value, propVariant);
- realNames.Add(name);
- values[i] = propVariant;
- }
- CRecordVector<const wchar_t *> names;
- for (i = 0; i < realNames.Size(); i++)
- names.Add((const wchar_t *)realNames[i]);
-
- RINOK(setProperties->SetProperties(&names.Front(), values, names.Size()));
- }
- catch(...)
- {
- delete []values;
- throw;
- }
- delete []values;
- return S_OK;
-}
+// SetProperties.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyString.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "SetProperties.h"
+
+using namespace NWindows;
+using namespace NCOM;
+
+static void ParseNumberString(const UString &s, NCOM::CPropVariant &prop)
+{
+ const wchar_t *end;
+ const UInt64 result = ConvertStringToUInt64(s, &end);
+ if (*end != 0 || s.IsEmpty())
+ prop = s;
+ else if (result <= (UInt32)0xFFFFFFFF)
+ prop = (UInt32)result;
+ else
+ prop = result;
+}
+
+
+struct CPropPropetiesVector
+{
+ CPropVariant *values;
+ CPropPropetiesVector(unsigned num)
+ {
+ values = new CPropVariant[num];
+ }
+ ~CPropPropetiesVector()
+ {
+ delete []values;
+ }
+};
+
+
+HRESULT SetProperties(IUnknown *unknown, const CObjectVector<CProperty> &properties)
+{
+ if (properties.IsEmpty())
+ return S_OK;
+ Z7_DECL_CMyComPtr_QI_FROM(
+ ISetProperties,
+ setProperties, unknown)
+ if (!setProperties)
+ return S_OK;
+
+ UStringVector realNames;
+ CPropPropetiesVector values(properties.Size());
+ {
+ unsigned i;
+ for (i = 0; i < properties.Size(); i++)
+ {
+ const CProperty &property = properties[i];
+ NCOM::CPropVariant propVariant;
+ UString name = property.Name;
+ if (property.Value.IsEmpty())
+ {
+ if (!name.IsEmpty())
+ {
+ const wchar_t c = name.Back();
+ if (c == L'-')
+ propVariant = false;
+ else if (c == L'+')
+ propVariant = true;
+ if (propVariant.vt != VT_EMPTY)
+ name.DeleteBack();
+ }
+ }
+ else
+ ParseNumberString(property.Value, propVariant);
+ realNames.Add(name);
+ values.values[i] = propVariant;
+ }
+ CRecordVector<const wchar_t *> names;
+ for (i = 0; i < realNames.Size(); i++)
+ names.Add((const wchar_t *)realNames[i]);
+
+ return setProperties->SetProperties(&names.Front(), values.values, names.Size());
+ }
+}
diff --git a/CPP/7zip/UI/Common/SetProperties.h b/CPP/7zip/UI/Common/SetProperties.h
index 64c947c..0676c45 100644
--- a/CPP/7zip/UI/Common/SetProperties.h
+++ b/CPP/7zip/UI/Common/SetProperties.h
@@ -1,10 +1,10 @@
-// SetProperties.h
-
-#ifndef __SETPROPERTIES_H
-#define __SETPROPERTIES_H
-
-#include "Property.h"
-
-HRESULT SetProperties(IUnknown *unknown, const CObjectVector<CProperty> &properties);
-
-#endif
+// SetProperties.h
+
+#ifndef ZIP7_INC_SETPROPERTIES_H
+#define ZIP7_INC_SETPROPERTIES_H
+
+#include "Property.h"
+
+HRESULT SetProperties(IUnknown *unknown, const CObjectVector<CProperty> &properties);
+
+#endif
diff --git a/CPP/7zip/UI/Common/SortUtils.cpp b/CPP/7zip/UI/Common/SortUtils.cpp
index f73ece8..5f29249 100644
--- a/CPP/7zip/UI/Common/SortUtils.cpp
+++ b/CPP/7zip/UI/Common/SortUtils.cpp
@@ -1,25 +1,25 @@
-// SortUtils.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/Wildcard.h"
-
-#include "SortUtils.h"
-
-static int CompareStrings(const unsigned *p1, const unsigned *p2, void *param)
-{
- const UStringVector &strings = *(const UStringVector *)param;
- return CompareFileNames(strings[*p1], strings[*p2]);
-}
-
-void SortFileNames(const UStringVector &strings, CUIntVector &indices)
-{
- const unsigned numItems = strings.Size();
- indices.ClearAndSetSize(numItems);
- if (numItems == 0)
- return;
- unsigned *vals = &indices[0];
- for (unsigned i = 0; i < numItems; i++)
- vals[i] = i;
- indices.Sort(CompareStrings, (void *)&strings);
-}
+// SortUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Wildcard.h"
+
+#include "SortUtils.h"
+
+static int CompareStrings(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const UStringVector &strings = *(const UStringVector *)param;
+ return CompareFileNames(strings[*p1], strings[*p2]);
+}
+
+void SortFileNames(const UStringVector &strings, CUIntVector &indices)
+{
+ const unsigned numItems = strings.Size();
+ indices.ClearAndSetSize(numItems);
+ if (numItems == 0)
+ return;
+ unsigned *vals = &indices[0];
+ for (unsigned i = 0; i < numItems; i++)
+ vals[i] = i;
+ indices.Sort(CompareStrings, (void *)&strings);
+}
diff --git a/CPP/7zip/UI/Common/SortUtils.h b/CPP/7zip/UI/Common/SortUtils.h
index 82d5e4c..07aa24d 100644
--- a/CPP/7zip/UI/Common/SortUtils.h
+++ b/CPP/7zip/UI/Common/SortUtils.h
@@ -1,10 +1,10 @@
-// SortUtils.h
-
-#ifndef __SORT_UTLS_H
-#define __SORT_UTLS_H
-
-#include "../../../Common/MyString.h"
-
-void SortFileNames(const UStringVector &strings, CUIntVector &indices);
-
-#endif
+// SortUtils.h
+
+#ifndef ZIP7_INC_SORT_UTLS_H
+#define ZIP7_INC_SORT_UTLS_H
+
+#include "../../../Common/MyString.h"
+
+void SortFileNames(const UStringVector &strings, CUIntVector &indices);
+
+#endif
diff --git a/CPP/7zip/UI/Common/StdAfx.h b/CPP/7zip/UI/Common/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/UI/Common/StdAfx.h
+++ b/CPP/7zip/UI/Common/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/UI/Common/TempFiles.cpp b/CPP/7zip/UI/Common/TempFiles.cpp
index 56bba9a..2f86838 100644
--- a/CPP/7zip/UI/Common/TempFiles.cpp
+++ b/CPP/7zip/UI/Common/TempFiles.cpp
@@ -1,19 +1,19 @@
-// TempFiles.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Windows/FileDir.h"
-
-#include "TempFiles.h"
-
-using namespace NWindows;
-using namespace NFile;
-
-void CTempFiles::Clear()
-{
- while (!Paths.IsEmpty())
- {
- NDir::DeleteFileAlways(Paths.Back());
- Paths.DeleteBack();
- }
-}
+// TempFiles.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileDir.h"
+
+#include "TempFiles.h"
+
+using namespace NWindows;
+using namespace NFile;
+
+void CTempFiles::Clear()
+{
+ while (!Paths.IsEmpty())
+ {
+ NDir::DeleteFileAlways(Paths.Back());
+ Paths.DeleteBack();
+ }
+}
diff --git a/CPP/7zip/UI/Common/TempFiles.h b/CPP/7zip/UI/Common/TempFiles.h
index f62192d..dd4ac20 100644
--- a/CPP/7zip/UI/Common/TempFiles.h
+++ b/CPP/7zip/UI/Common/TempFiles.h
@@ -1,16 +1,16 @@
-// TempFiles.h
-
-#ifndef __TEMP_FILES_H
-#define __TEMP_FILES_H
-
-#include "../../../Common/MyString.h"
-
-class CTempFiles
-{
- void Clear();
-public:
- FStringVector Paths;
- ~CTempFiles() { Clear(); }
-};
-
-#endif
+// TempFiles.h
+
+#ifndef ZIP7_INC_TEMP_FILES_H
+#define ZIP7_INC_TEMP_FILES_H
+
+#include "../../../Common/MyString.h"
+
+class CTempFiles
+{
+ void Clear();
+public:
+ FStringVector Paths;
+ ~CTempFiles() { Clear(); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/Update.cpp b/CPP/7zip/UI/Common/Update.cpp
index 2f1b365..27625ae 100644
--- a/CPP/7zip/UI/Common/Update.cpp
+++ b/CPP/7zip/UI/Common/Update.cpp
@@ -1,1704 +1,1857 @@
-// Update.cpp
-
-#include "StdAfx.h"
-
-#include "Update.h"
-
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/DLL.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/PropVariant.h"
-#include "../../../Windows/PropVariantConv.h"
-#include "../../../Windows/TimeUtils.h"
-
-#include "../../Common/FileStreams.h"
-#include "../../Common/LimitedStreams.h"
-
-#include "../../Compress/CopyCoder.h"
-
-#include "../Common/DirItem.h"
-#include "../Common/EnumDirItems.h"
-#include "../Common/OpenArchive.h"
-#include "../Common/UpdateProduce.h"
-
-#include "EnumDirItems.h"
-#include "SetProperties.h"
-#include "TempFiles.h"
-#include "UpdateCallback.h"
-
-static const char * const kUpdateIsNotSupoorted =
- "update operations are not supported for this archive";
-
-static const char * const kUpdateIsNotSupoorted_MultiVol =
- "Updating for multivolume archives is not implemented";
-
-using namespace NWindows;
-using namespace NCOM;
-using namespace NFile;
-using namespace NDir;
-using namespace NName;
-
-static CFSTR const kTempFolderPrefix = FTEXT("7zE");
-
-
-void CUpdateErrorInfo::SetFromLastError(const char *message)
-{
- SystemError = ::GetLastError();
- Message = message;
-}
-
-HRESULT CUpdateErrorInfo::SetFromLastError(const char *message, const FString &fileName)
-{
- SetFromLastError(message);
- FileNames.Add(fileName);
- return Get_HRESULT_Error();
-}
-
-static bool DeleteEmptyFolderAndEmptySubFolders(const FString &path)
-{
- NFind::CFileInfo fileInfo;
- FString pathPrefix = path + FCHAR_PATH_SEPARATOR;
- {
- NFind::CEnumerator enumerator;
- enumerator.SetDirPrefix(pathPrefix);
- while (enumerator.Next(fileInfo))
- {
- if (fileInfo.IsDir())
- if (!DeleteEmptyFolderAndEmptySubFolders(pathPrefix + fileInfo.Name))
- return false;
- }
- }
- /*
- // we don't need clear read-only for folders
- if (!MySetFileAttributes(path, 0))
- return false;
- */
- return RemoveDir(path);
-}
-
-
-using namespace NUpdateArchive;
-
-class COutMultiVolStream:
- public IOutStream,
- public CMyUnknownImp
-{
- unsigned _streamIndex; // required stream
- UInt64 _offsetPos; // offset from start of _streamIndex index
- UInt64 _absPos;
- UInt64 _length;
-
- struct CAltStreamInfo
- {
- COutFileStream *StreamSpec;
- CMyComPtr<IOutStream> Stream;
- FString Name;
- UInt64 Pos;
- UInt64 RealSize;
- };
- CObjectVector<CAltStreamInfo> Streams;
-public:
- // CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
- CRecordVector<UInt64> Sizes;
- FString Prefix;
- CTempFiles *TempFiles;
-
- void Init()
- {
- _streamIndex = 0;
- _offsetPos = 0;
- _absPos = 0;
- _length = 0;
- }
-
- bool SetMTime(const FILETIME *mTime);
- HRESULT Close();
-
- UInt64 GetSize() const { return _length; }
-
- MY_UNKNOWN_IMP1(IOutStream)
-
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
- STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
- STDMETHOD(SetSize)(UInt64 newSize);
-};
-
-// static NSynchronization::CCriticalSection g_TempPathsCS;
-
-HRESULT COutMultiVolStream::Close()
-{
- HRESULT res = S_OK;
- FOR_VECTOR (i, Streams)
- {
- COutFileStream *s = Streams[i].StreamSpec;
- if (s)
- {
- HRESULT res2 = s->Close();
- if (res2 != S_OK)
- res = res2;
- }
- }
- return res;
-}
-
-bool COutMultiVolStream::SetMTime(const FILETIME *mTime)
-{
- bool res = true;
- FOR_VECTOR (i, Streams)
- {
- COutFileStream *s = Streams[i].StreamSpec;
- if (s)
- if (!s->SetMTime(mTime))
- res = false;
- }
- return res;
-}
-
-STDMETHODIMP COutMultiVolStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- while (size > 0)
- {
- if (_streamIndex >= Streams.Size())
- {
- CAltStreamInfo altStream;
-
- FString name;
- name.Add_UInt32(_streamIndex + 1);
- while (name.Len() < 3)
- name.InsertAtFront(FTEXT('0'));
- name.Insert(0, Prefix);
- altStream.StreamSpec = new COutFileStream;
- altStream.Stream = altStream.StreamSpec;
- if (!altStream.StreamSpec->Create(name, false))
- return ::GetLastError();
- {
- // NSynchronization::CCriticalSectionLock lock(g_TempPathsCS);
- TempFiles->Paths.Add(name);
- }
-
- altStream.Pos = 0;
- altStream.RealSize = 0;
- altStream.Name = name;
- Streams.Add(altStream);
- continue;
- }
- CAltStreamInfo &altStream = Streams[_streamIndex];
-
- unsigned index = _streamIndex;
- if (index >= Sizes.Size())
- index = Sizes.Size() - 1;
- UInt64 volSize = Sizes[index];
-
- if (_offsetPos >= volSize)
- {
- _offsetPos -= volSize;
- _streamIndex++;
- continue;
- }
- if (_offsetPos != altStream.Pos)
- {
- // CMyComPtr<IOutStream> outStream;
- // RINOK(altStream.Stream.QueryInterface(IID_IOutStream, &outStream));
- RINOK(altStream.Stream->Seek(_offsetPos, STREAM_SEEK_SET, NULL));
- altStream.Pos = _offsetPos;
- }
-
- UInt32 curSize = (UInt32)MyMin((UInt64)size, volSize - altStream.Pos);
- UInt32 realProcessed;
- RINOK(altStream.Stream->Write(data, curSize, &realProcessed));
- data = (void *)((Byte *)data + realProcessed);
- size -= realProcessed;
- altStream.Pos += realProcessed;
- _offsetPos += realProcessed;
- _absPos += realProcessed;
- if (_absPos > _length)
- _length = _absPos;
- if (_offsetPos > altStream.RealSize)
- altStream.RealSize = _offsetPos;
- if (processedSize)
- *processedSize += realProcessed;
- if (altStream.Pos == volSize)
- {
- _streamIndex++;
- _offsetPos = 0;
- }
- if (realProcessed == 0 && curSize != 0)
- return E_FAIL;
- break;
- }
- return S_OK;
-}
-
-STDMETHODIMP COutMultiVolStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
- if (seekOrigin >= 3)
- return STG_E_INVALIDFUNCTION;
- switch (seekOrigin)
- {
- case STREAM_SEEK_SET: _absPos = offset; break;
- case STREAM_SEEK_CUR: _absPos += offset; break;
- case STREAM_SEEK_END: _absPos = _length + offset; break;
- }
- _offsetPos = _absPos;
- if (newPosition)
- *newPosition = _absPos;
- _streamIndex = 0;
- return S_OK;
-}
-
-STDMETHODIMP COutMultiVolStream::SetSize(UInt64 newSize)
-{
- unsigned i = 0;
- while (i < Streams.Size())
- {
- CAltStreamInfo &altStream = Streams[i++];
- if ((UInt64)newSize < altStream.RealSize)
- {
- RINOK(altStream.Stream->SetSize(newSize));
- altStream.RealSize = newSize;
- break;
- }
- newSize -= altStream.RealSize;
- }
- while (i < Streams.Size())
- {
- {
- CAltStreamInfo &altStream = Streams.Back();
- altStream.Stream.Release();
- DeleteFileAlways(altStream.Name);
- }
- Streams.DeleteBack();
- }
- _offsetPos = _absPos;
- _streamIndex = 0;
- _length = newSize;
- return S_OK;
-}
-
-void CArchivePath::ParseFromPath(const UString &path, EArcNameMode mode)
-{
- OriginalPath = path;
-
- SplitPathToParts_2(path, Prefix, Name);
-
- if (mode == k_ArcNameMode_Add)
- return;
-
- if (mode != k_ArcNameMode_Exact)
- {
- int dotPos = Name.ReverseFind_Dot();
- if (dotPos < 0)
- return;
- if ((unsigned)dotPos == Name.Len() - 1)
- Name.DeleteBack();
- else
- {
- const UString ext = Name.Ptr(dotPos + 1);
- if (BaseExtension.IsEqualTo_NoCase(ext))
- {
- BaseExtension = ext;
- Name.DeleteFrom(dotPos);
- return;
- }
- }
- }
-
- BaseExtension.Empty();
-}
-
-UString CArchivePath::GetFinalPath() const
-{
- UString path = GetPathWithoutExt();
- if (!BaseExtension.IsEmpty())
- {
- path += '.';
- path += BaseExtension;
- }
- return path;
-}
-
-UString CArchivePath::GetFinalVolPath() const
-{
- UString path = GetPathWithoutExt();
- // if BaseExtension is empty, we must ignore VolExtension also.
- if (!BaseExtension.IsEmpty())
- {
- path += '.';
- path += VolExtension;
- }
- return path;
-}
-
-FString CArchivePath::GetTempPath() const
-{
- FString path = TempPrefix;
- path += us2fs(Name);
- if (!BaseExtension.IsEmpty())
- {
- path += '.';
- path += us2fs(BaseExtension);
- }
- path += ".tmp";
- path += TempPostfix;
- return path;
-}
-
-static const char * const kDefaultArcType = "7z";
-static const char * const kDefaultArcExt = "7z";
-static const char * const kSFXExtension =
- #ifdef _WIN32
- "exe";
- #else
- "";
- #endif
-
-bool CUpdateOptions::InitFormatIndex(const CCodecs *codecs,
- const CObjectVector<COpenType> &types, const UString &arcPath)
-{
- if (types.Size() > 1)
- return false;
- // int arcTypeIndex = -1;
- if (types.Size() != 0)
- {
- MethodMode.Type = types[0];
- MethodMode.Type_Defined = true;
- }
- if (MethodMode.Type.FormatIndex < 0)
- {
- // MethodMode.Type = -1;
- MethodMode.Type = COpenType();
- if (ArcNameMode != k_ArcNameMode_Add)
- {
- MethodMode.Type.FormatIndex = codecs->FindFormatForArchiveName(arcPath);
- if (MethodMode.Type.FormatIndex >= 0)
- MethodMode.Type_Defined = true;
- }
- }
- return true;
-}
-
-bool CUpdateOptions::SetArcPath(const CCodecs *codecs, const UString &arcPath)
-{
- UString typeExt;
- int formatIndex = MethodMode.Type.FormatIndex;
- if (formatIndex < 0)
- {
- typeExt = kDefaultArcExt;
- }
- else
- {
- const CArcInfoEx &arcInfo = codecs->Formats[formatIndex];
- if (!arcInfo.UpdateEnabled)
- return false;
- typeExt = arcInfo.GetMainExt();
- }
- UString ext = typeExt;
- if (SfxMode)
- ext = kSFXExtension;
- ArchivePath.BaseExtension = ext;
- ArchivePath.VolExtension = typeExt;
- ArchivePath.ParseFromPath(arcPath, ArcNameMode);
- FOR_VECTOR (i, Commands)
- {
- CUpdateArchiveCommand &uc = Commands[i];
- uc.ArchivePath.BaseExtension = ext;
- uc.ArchivePath.VolExtension = typeExt;
- uc.ArchivePath.ParseFromPath(uc.UserArchivePath, ArcNameMode);
- }
- return true;
-}
-
-
-struct CUpdateProduceCallbackImp: public IUpdateProduceCallback
-{
- const CObjectVector<CArcItem> *_arcItems;
- IUpdateCallbackUI *_callback;
- CDirItemsStat *_stat;
-
- CUpdateProduceCallbackImp(
- const CObjectVector<CArcItem> *a,
- CDirItemsStat *stat,
- IUpdateCallbackUI *callback):
- _arcItems(a),
- _stat(stat),
- _callback(callback) {}
-
- virtual HRESULT ShowDeleteFile(unsigned arcIndex);
-};
-
-
-HRESULT CUpdateProduceCallbackImp::ShowDeleteFile(unsigned arcIndex)
-{
- const CArcItem &ai = (*_arcItems)[arcIndex];
- {
- CDirItemsStat &stat = *_stat;
- if (ai.IsDir)
- stat.NumDirs++;
- else if (ai.IsAltStream)
- {
- stat.NumAltStreams++;
- stat.AltStreamsSize += ai.Size;
- }
- else
- {
- stat.NumFiles++;
- stat.FilesSize += ai.Size;
- }
- }
- return _callback->ShowDeleteFile(ai.Name, ai.IsDir);
-}
-
-bool CRenamePair::Prepare()
-{
- if (RecursedType != NRecursedType::kNonRecursed)
- return false;
- if (!WildcardParsing)
- return true;
- return !DoesNameContainWildcard(OldName);
-}
-
-extern bool g_CaseSensitive;
-
-static unsigned CompareTwoNames(const wchar_t *s1, const wchar_t *s2)
-{
- for (unsigned i = 0;; i++)
- {
- wchar_t c1 = s1[i];
- wchar_t c2 = s2[i];
- if (c1 == 0 || c2 == 0)
- return i;
- if (c1 == c2)
- continue;
- if (!g_CaseSensitive && (MyCharUpper(c1) == MyCharUpper(c2)))
- continue;
- if (IsPathSepar(c1) && IsPathSepar(c2))
- continue;
- return i;
- }
-}
-
-bool CRenamePair::GetNewPath(bool isFolder, const UString &src, UString &dest) const
-{
- unsigned num = CompareTwoNames(OldName, src);
- if (OldName[num] == 0)
- {
- if (src[num] != 0 && !IsPathSepar(src[num]) && num != 0 && !IsPathSepar(src[num - 1]))
- return false;
- }
- else
- {
- // OldName[num] != 0
- // OldName = "1\1a.txt"
- // src = "1"
-
- if (!isFolder
- || src[num] != 0
- || !IsPathSepar(OldName[num])
- || OldName[num + 1] != 0)
- return false;
- }
- dest = NewName + src.Ptr(num);
- return true;
-}
-
-#ifdef SUPPORT_ALT_STREAMS
-int FindAltStreamColon_in_Path(const wchar_t *path);
-#endif
-
-static HRESULT Compress(
- const CUpdateOptions &options,
- bool isUpdatingItself,
- CCodecs *codecs,
- const CActionSet &actionSet,
- const CArc *arc,
- CArchivePath &archivePath,
- const CObjectVector<CArcItem> &arcItems,
- Byte *processedItemsStatuses,
- const CDirItems &dirItems,
- const CDirItem *parentDirItem,
- CTempFiles &tempFiles,
- CUpdateErrorInfo &errorInfo,
- IUpdateCallbackUI *callback,
- CFinishArchiveStat &st)
-{
- CMyComPtr<IOutArchive> outArchive;
- int formatIndex = options.MethodMode.Type.FormatIndex;
-
- if (arc)
- {
- formatIndex = arc->FormatIndex;
- if (formatIndex < 0)
- return E_NOTIMPL;
- CMyComPtr<IInArchive> archive2 = arc->Archive;
- HRESULT result = archive2.QueryInterface(IID_IOutArchive, &outArchive);
- if (result != S_OK)
- throw kUpdateIsNotSupoorted;
- }
- else
- {
- RINOK(codecs->CreateOutArchive(formatIndex, outArchive));
-
- #ifdef EXTERNAL_CODECS
- {
- CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
- outArchive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
- if (setCompressCodecsInfo)
- {
- RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs));
- }
- }
- #endif
- }
-
- if (outArchive == 0)
- throw kUpdateIsNotSupoorted;
-
- NFileTimeType::EEnum fileTimeType;
- {
- UInt32 value;
- RINOK(outArchive->GetFileTimeType(&value));
-
- switch (value)
- {
- case NFileTimeType::kWindows:
- case NFileTimeType::kUnix:
- case NFileTimeType::kDOS:
- fileTimeType = (NFileTimeType::EEnum)value;
- break;
- default:
- return E_FAIL;
- }
- }
-
- {
- const CArcInfoEx &arcInfo = codecs->Formats[formatIndex];
- if (options.AltStreams.Val && !arcInfo.Flags_AltStreams())
- return E_NOTIMPL;
- if (options.NtSecurity.Val && !arcInfo.Flags_NtSecure())
- return E_NOTIMPL;
- }
-
- CRecordVector<CUpdatePair2> updatePairs2;
-
- UStringVector newNames;
-
- CArcToDoStat stat2;
-
- if (options.RenamePairs.Size() != 0)
- {
- FOR_VECTOR (i, arcItems)
- {
- const CArcItem &ai = arcItems[i];
- bool needRename = false;
- UString dest;
-
- if (ai.Censored)
- {
- FOR_VECTOR (j, options.RenamePairs)
- {
- const CRenamePair &rp = options.RenamePairs[j];
- if (rp.GetNewPath(ai.IsDir, ai.Name, dest))
- {
- needRename = true;
- break;
- }
-
- #ifdef SUPPORT_ALT_STREAMS
- if (ai.IsAltStream)
- {
- int colonPos = FindAltStreamColon_in_Path(ai.Name);
- if (colonPos >= 0)
- {
- UString mainName = ai.Name.Left(colonPos);
- /*
- actually we must improve that code to support cases
- with folder renaming like: rn arc dir1\ dir2\
- */
- if (rp.GetNewPath(false, mainName, dest))
- {
- needRename = true;
- dest += ':';
- dest += ai.Name.Ptr(colonPos + 1);
- break;
- }
- }
- }
- #endif
- }
- }
-
- CUpdatePair2 up2;
- up2.SetAs_NoChangeArcItem(ai.IndexInServer);
- if (needRename)
- {
- up2.NewProps = true;
- RINOK(arc->IsItemAnti(i, up2.IsAnti));
- up2.NewNameIndex = newNames.Add(dest);
- }
- updatePairs2.Add(up2);
- }
- }
- else
- {
- CRecordVector<CUpdatePair> updatePairs;
- GetUpdatePairInfoList(dirItems, arcItems, fileTimeType, updatePairs); // must be done only once!!!
- CUpdateProduceCallbackImp upCallback(&arcItems, &stat2.DeleteData, callback);
-
- UpdateProduce(updatePairs, actionSet, updatePairs2, isUpdatingItself ? &upCallback : NULL);
- }
-
- {
- FOR_VECTOR (i, updatePairs2)
- {
- const CUpdatePair2 &up = updatePairs2[i];
-
- // 17.01: anti-item is (up.NewData && (p.UseArcProps in most cases))
-
- if (up.NewData && !up.UseArcProps)
- {
- if (up.ExistOnDisk())
- {
- CDirItemsStat2 &stat = stat2.NewData;
- const CDirItem &di = dirItems.Items[up.DirIndex];
- if (di.IsDir())
- {
- if (up.IsAnti)
- stat.Anti_NumDirs++;
- else
- stat.NumDirs++;
- }
- else if (di.IsAltStream)
- {
- if (up.IsAnti)
- stat.Anti_NumAltStreams++;
- else
- {
- stat.NumAltStreams++;
- stat.AltStreamsSize += di.Size;
- }
- }
- else
- {
- if (up.IsAnti)
- stat.Anti_NumFiles++;
- else
- {
- stat.NumFiles++;
- stat.FilesSize += di.Size;
- }
- }
- }
- }
- else if (up.ArcIndex >= 0)
- {
- CDirItemsStat2 &stat = *(up.NewData ? &stat2.NewData : &stat2.OldData);
- const CArcItem &ai = arcItems[up.ArcIndex];
- if (ai.IsDir)
- {
- if (up.IsAnti)
- stat.Anti_NumDirs++;
- else
- stat.NumDirs++;
- }
- else if (ai.IsAltStream)
- {
- if (up.IsAnti)
- stat.Anti_NumAltStreams++;
- else
- {
- stat.NumAltStreams++;
- stat.AltStreamsSize += ai.Size;
- }
- }
- else
- {
- if (up.IsAnti)
- stat.Anti_NumFiles++;
- else
- {
- stat.NumFiles++;
- stat.FilesSize += ai.Size;
- }
- }
- }
- }
- RINOK(callback->SetNumItems(stat2));
- }
-
- CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
- CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
-
- updateCallbackSpec->ShareForWrite = options.OpenShareForWrite;
- updateCallbackSpec->StopAfterOpenError = options.StopAfterOpenError;
- updateCallbackSpec->StdInMode = options.StdInMode;
- updateCallbackSpec->Callback = callback;
-
- if (arc)
- {
- // we set Archive to allow to transfer GetProperty requests back to DLL.
- updateCallbackSpec->Archive = arc->Archive;
- }
-
- updateCallbackSpec->DirItems = &dirItems;
- updateCallbackSpec->ParentDirItem = parentDirItem;
-
- updateCallbackSpec->StoreNtSecurity = options.NtSecurity.Val;
- updateCallbackSpec->StoreHardLinks = options.HardLinks.Val;
- updateCallbackSpec->StoreSymLinks = options.SymLinks.Val;
-
- updateCallbackSpec->Arc = arc;
- updateCallbackSpec->ArcItems = &arcItems;
- updateCallbackSpec->UpdatePairs = &updatePairs2;
-
- updateCallbackSpec->ProcessedItemsStatuses = processedItemsStatuses;
-
- if (options.RenamePairs.Size() != 0)
- updateCallbackSpec->NewNames = &newNames;
-
- CMyComPtr<IOutStream> outSeekStream;
- CMyComPtr<ISequentialOutStream> outStream;
-
- if (!options.StdOutMode)
- {
- FString dirPrefix;
- if (!GetOnlyDirPrefix(us2fs(archivePath.GetFinalPath()), dirPrefix))
- throw 1417161;
- CreateComplexDir(dirPrefix);
- }
-
- COutFileStream *outStreamSpec = NULL;
- CStdOutFileStream *stdOutFileStreamSpec = NULL;
- COutMultiVolStream *volStreamSpec = NULL;
-
- if (options.VolumesSizes.Size() == 0)
- {
- if (options.StdOutMode)
- {
- stdOutFileStreamSpec = new CStdOutFileStream;
- outStream = stdOutFileStreamSpec;
- }
- else
- {
- outStreamSpec = new COutFileStream;
- outSeekStream = outStreamSpec;
- outStream = outSeekStream;
- bool isOK = false;
- FString realPath;
-
- for (unsigned i = 0; i < (1 << 16); i++)
- {
- if (archivePath.Temp)
- {
- if (i > 0)
- {
- archivePath.TempPostfix.Empty();
- archivePath.TempPostfix.Add_UInt32(i);
- }
- realPath = archivePath.GetTempPath();
- }
- else
- realPath = us2fs(archivePath.GetFinalPath());
- if (outStreamSpec->Create(realPath, false))
- {
- tempFiles.Paths.Add(realPath);
- isOK = true;
- break;
- }
- if (::GetLastError() != ERROR_FILE_EXISTS)
- break;
- if (!archivePath.Temp)
- break;
- }
-
- if (!isOK)
- return errorInfo.SetFromLastError("cannot open file", realPath);
- }
- }
- else
- {
- if (options.StdOutMode)
- return E_FAIL;
- if (arc && arc->GetGlobalOffset() > 0)
- return E_NOTIMPL;
-
- volStreamSpec = new COutMultiVolStream;
- outSeekStream = volStreamSpec;
- outStream = outSeekStream;
- volStreamSpec->Sizes = options.VolumesSizes;
- volStreamSpec->Prefix = us2fs(archivePath.GetFinalVolPath());
- volStreamSpec->Prefix += '.';
- volStreamSpec->TempFiles = &tempFiles;
- volStreamSpec->Init();
-
- /*
- updateCallbackSpec->VolumesSizes = volumesSizes;
- updateCallbackSpec->VolName = archivePath.Prefix + archivePath.Name;
- if (!archivePath.VolExtension.IsEmpty())
- updateCallbackSpec->VolExt = UString('.') + archivePath.VolExtension;
- */
- }
-
- RINOK(SetProperties(outArchive, options.MethodMode.Properties));
-
- if (options.SfxMode)
- {
- CInFileStream *sfxStreamSpec = new CInFileStream;
- CMyComPtr<IInStream> sfxStream(sfxStreamSpec);
- if (!sfxStreamSpec->Open(options.SfxModule))
- return errorInfo.SetFromLastError("cannot open SFX module", options.SfxModule);
-
- CMyComPtr<ISequentialOutStream> sfxOutStream;
- COutFileStream *outStreamSpec2 = NULL;
- if (options.VolumesSizes.Size() == 0)
- sfxOutStream = outStream;
- else
- {
- outStreamSpec2 = new COutFileStream;
- sfxOutStream = outStreamSpec2;
- FString realPath = us2fs(archivePath.GetFinalPath());
- if (!outStreamSpec2->Create(realPath, false))
- return errorInfo.SetFromLastError("cannot open file", realPath);
- }
-
- {
- UInt64 sfxSize;
- RINOK(sfxStreamSpec->GetSize(&sfxSize));
- RINOK(callback->WriteSfx(fs2us(options.SfxModule), sfxSize));
- }
-
- RINOK(NCompress::CopyStream(sfxStream, sfxOutStream, NULL));
-
- if (outStreamSpec2)
- {
- RINOK(outStreamSpec2->Close());
- }
- }
-
- CMyComPtr<ISequentialOutStream> tailStream;
-
- if (options.SfxMode || !arc || arc->ArcStreamOffset == 0)
- tailStream = outStream;
- else
- {
- // Int64 globalOffset = arc->GetGlobalOffset();
- RINOK(arc->InStream->Seek(0, STREAM_SEEK_SET, NULL));
- RINOK(NCompress::CopyStream_ExactSize(arc->InStream, outStream, arc->ArcStreamOffset, NULL));
- if (options.StdOutMode)
- tailStream = outStream;
- else
- {
- CTailOutStream *tailStreamSpec = new CTailOutStream;
- tailStream = tailStreamSpec;
- tailStreamSpec->Stream = outSeekStream;
- tailStreamSpec->Offset = arc->ArcStreamOffset;
- tailStreamSpec->Init();
- }
- }
-
-
- HRESULT result = outArchive->UpdateItems(tailStream, updatePairs2.Size(), updateCallback);
- // callback->Finalize();
- RINOK(result);
-
- if (!updateCallbackSpec->AreAllFilesClosed())
- {
- errorInfo.Message = "There are unclosed input file:";
- errorInfo.FileNames = updateCallbackSpec->_openFiles_Paths;
- return E_FAIL;
- }
-
- if (options.SetArcMTime)
- {
- FILETIME ft;
- ft.dwLowDateTime = 0;
- ft.dwHighDateTime = 0;
- FOR_VECTOR (i, updatePairs2)
- {
- CUpdatePair2 &pair2 = updatePairs2[i];
- const FILETIME *ft2 = NULL;
- if (pair2.NewProps && pair2.DirIndex >= 0)
- ft2 = &dirItems.Items[pair2.DirIndex].MTime;
- else if (pair2.UseArcProps && pair2.ArcIndex >= 0)
- ft2 = &arcItems[pair2.ArcIndex].MTime;
- if (ft2)
- {
- if (::CompareFileTime(&ft, ft2) < 0)
- ft = *ft2;
- }
- }
- if (ft.dwLowDateTime != 0 || ft.dwHighDateTime != 0)
- {
- if (outStreamSpec)
- outStreamSpec->SetMTime(&ft);
- else if (volStreamSpec)
- volStreamSpec->SetMTime(&ft);;
- }
- }
-
- if (callback)
- {
- UInt64 size = 0;
- if (outStreamSpec)
- outStreamSpec->GetSize(&size);
- else if (stdOutFileStreamSpec)
- size = stdOutFileStreamSpec->GetSize();
- else
- size = volStreamSpec->GetSize();
-
- st.OutArcFileSize = size;
- }
-
- if (outStreamSpec)
- result = outStreamSpec->Close();
- else if (volStreamSpec)
- result = volStreamSpec->Close();
- return result;
-}
-
-bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include);
-
-static bool Censor_CheckPath(const NWildcard::CCensor &censor, const CReadArcItem &item)
-{
- bool finded = false;
- FOR_VECTOR (i, censor.Pairs)
- {
- bool include;
- if (CensorNode_CheckPath2(censor.Pairs[i].Head, item, include))
- {
- if (!include)
- return false;
- finded = true;
- }
- }
- return finded;
-}
-
-static HRESULT EnumerateInArchiveItems(
- // bool storeStreamsMode,
- const NWildcard::CCensor &censor,
- const CArc &arc,
- CObjectVector<CArcItem> &arcItems)
-{
- arcItems.Clear();
- UInt32 numItems;
- IInArchive *archive = arc.Archive;
- RINOK(archive->GetNumberOfItems(&numItems));
- arcItems.ClearAndReserve(numItems);
-
- CReadArcItem item;
-
- for (UInt32 i = 0; i < numItems; i++)
- {
- CArcItem ai;
-
- RINOK(arc.GetItem(i, item));
- ai.Name = item.Path;
- ai.IsDir = item.IsDir;
- ai.IsAltStream =
- #ifdef SUPPORT_ALT_STREAMS
- item.IsAltStream;
- #else
- false;
- #endif
-
- /*
- if (!storeStreamsMode && ai.IsAltStream)
- continue;
- */
- ai.Censored = Censor_CheckPath(censor, item);
-
- RINOK(arc.GetItemMTime(i, ai.MTime, ai.MTimeDefined));
- RINOK(arc.GetItemSize(i, ai.Size, ai.SizeDefined));
-
- {
- CPropVariant prop;
- RINOK(archive->GetProperty(i, kpidTimeType, &prop));
- if (prop.vt == VT_UI4)
- {
- ai.TimeType = (int)(NFileTimeType::EEnum)prop.ulVal;
- switch (ai.TimeType)
- {
- case NFileTimeType::kWindows:
- case NFileTimeType::kUnix:
- case NFileTimeType::kDOS:
- break;
- default:
- return E_FAIL;
- }
- }
- }
-
- ai.IndexInServer = i;
- arcItems.AddInReserved(ai);
- }
- return S_OK;
-}
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-#include <mapi.h>
-
-#endif
-
-HRESULT UpdateArchive(
- CCodecs *codecs,
- const CObjectVector<COpenType> &types,
- const UString &cmdArcPath2,
- NWildcard::CCensor &censor,
- CUpdateOptions &options,
- CUpdateErrorInfo &errorInfo,
- IOpenCallbackUI *openCallback,
- IUpdateCallbackUI2 *callback,
- bool needSetPath)
-{
- if (options.StdOutMode && options.EMailMode)
- return E_FAIL;
-
- if (types.Size() > 1)
- return E_NOTIMPL;
-
- bool renameMode = !options.RenamePairs.IsEmpty();
- if (renameMode)
- {
- if (options.Commands.Size() != 1)
- return E_FAIL;
- }
-
- if (options.DeleteAfterCompressing)
- {
- if (options.Commands.Size() != 1)
- return E_NOTIMPL;
- const CActionSet &as = options.Commands[0].ActionSet;
- for (int i = 2; i < NPairState::kNumValues; i++)
- if (as.StateActions[i] != NPairAction::kCompress)
- return E_NOTIMPL;
- }
-
- censor.AddPathsToCensor(options.PathMode);
- #ifdef _WIN32
- ConvertToLongNames(censor);
- #endif
- censor.ExtendExclude();
-
-
- if (options.VolumesSizes.Size() > 0 && (options.EMailMode /* || options.SfxMode */))
- return E_NOTIMPL;
-
- if (options.SfxMode)
- {
- CProperty property;
- property.Name = "rsfx";
- options.MethodMode.Properties.Add(property);
- if (options.SfxModule.IsEmpty())
- {
- errorInfo.Message = "SFX file is not specified";
- return E_FAIL;
- }
- bool found = false;
- if (options.SfxModule.Find(FCHAR_PATH_SEPARATOR) < 0)
- {
- const FString fullName = NDLL::GetModuleDirPrefix() + options.SfxModule;
- if (NFind::DoesFileExist(fullName))
- {
- options.SfxModule = fullName;
- found = true;
- }
- }
- if (!found)
- {
- if (!NFind::DoesFileExist(options.SfxModule))
- return errorInfo.SetFromLastError("cannot find specified SFX module", options.SfxModule);
- }
- }
-
- CArchiveLink arcLink;
-
-
- if (needSetPath)
- {
- if (!options.InitFormatIndex(codecs, types, cmdArcPath2) ||
- !options.SetArcPath(codecs, cmdArcPath2))
- return E_NOTIMPL;
- }
-
- UString arcPath = options.ArchivePath.GetFinalPath();
-
- if (!options.VolumesSizes.IsEmpty())
- {
- arcPath = options.ArchivePath.GetFinalVolPath();
- arcPath += '.';
- arcPath += "001";
- }
-
- if (cmdArcPath2.IsEmpty())
- {
- if (options.MethodMode.Type.FormatIndex < 0)
- throw "type of archive is not specified";
- }
- else
- {
- NFind::CFileInfo fi;
- if (!fi.Find(us2fs(arcPath)))
- {
- if (renameMode)
- throw "can't find archive";;
- if (options.MethodMode.Type.FormatIndex < 0)
- {
- if (!options.SetArcPath(codecs, cmdArcPath2))
- return E_NOTIMPL;
- }
- }
- else
- {
- if (fi.IsDir())
- throw "there is no such archive";
- if (fi.IsDevice)
- return E_NOTIMPL;
-
- if (!options.StdOutMode && options.UpdateArchiveItself)
- if (fi.IsReadOnly())
- {
- errorInfo.SystemError = ERROR_ACCESS_DENIED;
- errorInfo.Message = "The file is read-only";
- errorInfo.FileNames.Add(us2fs(arcPath));
- return errorInfo.Get_HRESULT_Error();
- }
-
- if (options.VolumesSizes.Size() > 0)
- {
- errorInfo.FileNames.Add(us2fs(arcPath));
- errorInfo.SystemError = (DWORD)E_NOTIMPL;
- errorInfo.Message = kUpdateIsNotSupoorted_MultiVol;
- return E_NOTIMPL;
- }
- CObjectVector<COpenType> types2;
- // change it.
- if (options.MethodMode.Type_Defined)
- types2.Add(options.MethodMode.Type);
- // We need to set Properties to open archive only in some cases (WIM archives).
-
- CIntVector excl;
- COpenOptions op;
- #ifndef _SFX
- op.props = &options.MethodMode.Properties;
- #endif
- op.codecs = codecs;
- op.types = &types2;
- op.excludedFormats = !
- op.stdInMode = false;
- op.stream = NULL;
- op.filePath = arcPath;
-
- RINOK(callback->StartOpenArchive(arcPath));
-
- HRESULT result = arcLink.Open_Strict(op, openCallback);
-
- if (result == E_ABORT)
- return result;
-
- HRESULT res2 = callback->OpenResult(codecs, arcLink, arcPath, result);
- /*
- if (result == S_FALSE)
- return E_FAIL;
- */
- RINOK(res2);
- RINOK(result);
-
- if (arcLink.VolumePaths.Size() > 1)
- {
- errorInfo.SystemError = (DWORD)E_NOTIMPL;
- errorInfo.Message = kUpdateIsNotSupoorted_MultiVol;
- return E_NOTIMPL;
- }
-
- CArc &arc = arcLink.Arcs.Back();
- arc.MTimeDefined = !fi.IsDevice;
- arc.MTime = fi.MTime;
-
- if (arc.ErrorInfo.ThereIsTail)
- {
- errorInfo.SystemError = (DWORD)E_NOTIMPL;
- errorInfo.Message = "There is some data block after the end of the archive";
- return E_NOTIMPL;
- }
- if (options.MethodMode.Type.FormatIndex < 0)
- {
- options.MethodMode.Type.FormatIndex = arcLink.GetArc()->FormatIndex;
- if (!options.SetArcPath(codecs, cmdArcPath2))
- return E_NOTIMPL;
- }
- }
- }
-
- if (options.MethodMode.Type.FormatIndex < 0)
- {
- options.MethodMode.Type.FormatIndex = codecs->FindFormatForArchiveType((UString)kDefaultArcType);
- if (options.MethodMode.Type.FormatIndex < 0)
- return E_NOTIMPL;
- }
-
- bool thereIsInArchive = arcLink.IsOpen;
- if (!thereIsInArchive && renameMode)
- return E_FAIL;
-
- CDirItems dirItems;
- dirItems.Callback = callback;
-
- CDirItem parentDirItem;
- CDirItem *parentDirItem_Ptr = NULL;
-
- /*
- FStringVector requestedPaths;
- FStringVector *requestedPaths_Ptr = NULL;
- if (options.DeleteAfterCompressing)
- requestedPaths_Ptr = &requestedPaths;
- */
-
- if (options.StdInMode)
- {
- CDirItem di;
- di.Name = options.StdInFileName;
- di.Size = (UInt64)(Int64)-1;
- di.Attrib = 0;
- NTime::GetCurUtcFileTime(di.MTime);
- di.CTime = di.ATime = di.MTime;
- dirItems.Items.Add(di);
- }
- else
- {
- bool needScanning = false;
-
- if (!renameMode)
- FOR_VECTOR (i, options.Commands)
- if (options.Commands[i].ActionSet.NeedScanning())
- needScanning = true;
-
- if (needScanning)
- {
- RINOK(callback->StartScanning());
-
- dirItems.SymLinks = options.SymLinks.Val;
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- dirItems.ReadSecure = options.NtSecurity.Val;
- #endif
-
- dirItems.ScanAltStreams = options.AltStreams.Val;
-
- HRESULT res = EnumerateItems(censor,
- options.PathMode,
- options.AddPathPrefix,
- dirItems);
-
- if (res != S_OK)
- {
- if (res != E_ABORT)
- errorInfo.Message = "Scanning error";
- return res;
- }
-
- RINOK(callback->FinishScanning(dirItems.Stat));
-
- if (censor.Pairs.Size() == 1)
- {
- NFind::CFileInfo fi;
- FString prefix = us2fs(censor.Pairs[0].Prefix);
- prefix += '.';
- // UString prefix = censor.Pairs[0].Prefix;
- /*
- if (prefix.Back() == WCHAR_PATH_SEPARATOR)
- {
- prefix.DeleteBack();
- }
- */
- if (fi.Find(prefix))
- if (fi.IsDir())
- {
- parentDirItem.Size = fi.Size;
- parentDirItem.CTime = fi.CTime;
- parentDirItem.ATime = fi.ATime;
- parentDirItem.MTime = fi.MTime;
- parentDirItem.Attrib = fi.Attrib;
- parentDirItem_Ptr = &parentDirItem;
-
- int secureIndex = -1;
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (options.NtSecurity.Val)
- dirItems.AddSecurityItem(prefix, secureIndex);
- #endif
- parentDirItem.SecureIndex = secureIndex;
-
- parentDirItem_Ptr = &parentDirItem;
- }
- }
- }
- }
-
- FString tempDirPrefix;
- bool usesTempDir = false;
-
- #ifdef _WIN32
- CTempDir tempDirectory;
- if (options.EMailMode && options.EMailRemoveAfter)
- {
- tempDirectory.Create(kTempFolderPrefix);
- tempDirPrefix = tempDirectory.GetPath();
- NormalizeDirPathPrefix(tempDirPrefix);
- usesTempDir = true;
- }
- #endif
-
- CTempFiles tempFiles;
-
- bool createTempFile = false;
-
- if (!options.StdOutMode && options.UpdateArchiveItself)
- {
- CArchivePath &ap = options.Commands[0].ArchivePath;
- ap = options.ArchivePath;
- // if ((archive != 0 && !usesTempDir) || !options.WorkingDir.IsEmpty())
- if ((thereIsInArchive || !options.WorkingDir.IsEmpty()) && !usesTempDir && options.VolumesSizes.Size() == 0)
- {
- createTempFile = true;
- ap.Temp = true;
- if (!options.WorkingDir.IsEmpty())
- ap.TempPrefix = options.WorkingDir;
- else
- ap.TempPrefix = us2fs(ap.Prefix);
- NormalizeDirPathPrefix(ap.TempPrefix);
- }
- }
-
- unsigned ci;
-
-
- // self including protection
- if (options.DeleteAfterCompressing)
- {
- for (ci = 0; ci < options.Commands.Size(); ci++)
- {
- CArchivePath &ap = options.Commands[ci].ArchivePath;
- const FString path = us2fs(ap.GetFinalPath());
- // maybe we must compare absolute paths path here
- FOR_VECTOR (i, dirItems.Items)
- {
- const FString phyPath = dirItems.GetPhyPath(i);
- if (phyPath == path)
- {
- UString s;
- s = "It is not allowed to include archive to itself";
- s.Add_LF();
- s += path;
- throw s;
- }
- }
- }
- }
-
-
- for (ci = 0; ci < options.Commands.Size(); ci++)
- {
- CArchivePath &ap = options.Commands[ci].ArchivePath;
- if (usesTempDir)
- {
- // Check it
- ap.Prefix = fs2us(tempDirPrefix);
- // ap.Temp = true;
- // ap.TempPrefix = tempDirPrefix;
- }
- if (!options.StdOutMode &&
- (ci > 0 || !createTempFile))
- {
- const FString path = us2fs(ap.GetFinalPath());
- if (NFind::DoesFileOrDirExist(path))
- {
- errorInfo.SystemError = ERROR_FILE_EXISTS;
- errorInfo.Message = "The file already exists";
- errorInfo.FileNames.Add(path);
- return errorInfo.Get_HRESULT_Error();
- }
- }
- }
-
- CObjectVector<CArcItem> arcItems;
- if (thereIsInArchive)
- {
- RINOK(EnumerateInArchiveItems(
- // options.StoreAltStreams,
- censor, arcLink.Arcs.Back(), arcItems));
- }
-
- /*
- FStringVector processedFilePaths;
- FStringVector *processedFilePaths_Ptr = NULL;
- if (options.DeleteAfterCompressing)
- processedFilePaths_Ptr = &processedFilePaths;
- */
-
- CByteBuffer processedItems;
- if (options.DeleteAfterCompressing)
- {
- unsigned num = dirItems.Items.Size();
- processedItems.Alloc(num);
- for (unsigned i = 0; i < num; i++)
- processedItems[i] = 0;
- }
-
- /*
- #ifndef _NO_CRYPTO
- if (arcLink.PasswordWasAsked)
- {
- // We set password, if open have requested password
- RINOK(callback->SetPassword(arcLink.Password));
- }
- #endif
- */
-
- for (ci = 0; ci < options.Commands.Size(); ci++)
- {
- const CArc *arc = thereIsInArchive ? arcLink.GetArc() : NULL;
- CUpdateArchiveCommand &command = options.Commands[ci];
- UString name;
- bool isUpdating;
-
- if (options.StdOutMode)
- {
- name = "stdout";
- isUpdating = thereIsInArchive;
- }
- else
- {
- name = command.ArchivePath.GetFinalPath();
- isUpdating = (ci == 0 && options.UpdateArchiveItself && thereIsInArchive);
- }
-
- RINOK(callback->StartArchive(name, isUpdating))
-
- CFinishArchiveStat st;
-
- RINOK(Compress(options,
- isUpdating,
- codecs,
- command.ActionSet,
- arc,
- command.ArchivePath,
- arcItems,
- options.DeleteAfterCompressing ? (Byte *)processedItems : NULL,
-
- dirItems,
- parentDirItem_Ptr,
-
- tempFiles,
- errorInfo, callback, st));
-
- RINOK(callback->FinishArchive(st));
- }
-
-
- if (thereIsInArchive)
- {
- RINOK(arcLink.Close());
- arcLink.Release();
- }
-
- tempFiles.Paths.Clear();
- if (createTempFile)
- {
- try
- {
- CArchivePath &ap = options.Commands[0].ArchivePath;
- const FString &tempPath = ap.GetTempPath();
-
- // DWORD attrib = 0;
- if (thereIsInArchive)
- {
- // attrib = NFind::GetFileAttrib(us2fs(arcPath));
- if (!DeleteFileAlways(us2fs(arcPath)))
- return errorInfo.SetFromLastError("cannot delete the file", us2fs(arcPath));
- }
-
- if (!MyMoveFile(tempPath, us2fs(arcPath)))
- {
- errorInfo.SetFromLastError("cannot move the file", tempPath);
- errorInfo.FileNames.Add(us2fs(arcPath));
- return errorInfo.Get_HRESULT_Error();
- }
-
- /*
- if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
- {
- DWORD attrib2 = NFind::GetFileAttrib(us2fs(arcPath));
- if (attrib2 != INVALID_FILE_ATTRIBUTES)
- NDir::SetFileAttrib(us2fs(arcPath), attrib2 | FILE_ATTRIBUTE_READONLY);
- }
- */
- }
- catch(...)
- {
- throw;
- }
- }
-
-
- #if defined(_WIN32) && !defined(UNDER_CE)
-
- if (options.EMailMode)
- {
- NDLL::CLibrary mapiLib;
- if (!mapiLib.Load(FTEXT("Mapi32.dll")))
- {
- errorInfo.SetFromLastError("cannot load Mapi32.dll");
- return errorInfo.Get_HRESULT_Error();
- }
-
- /*
- LPMAPISENDDOCUMENTS fnSend = (LPMAPISENDDOCUMENTS)mapiLib.GetProc("MAPISendDocuments");
- if (fnSend == 0)
- {
- errorInfo.SetFromLastError)("7-Zip cannot find MAPISendDocuments function");
- return errorInfo.Get_HRESULT_Error();
- }
- */
-
- LPMAPISENDMAIL sendMail = (LPMAPISENDMAIL)mapiLib.GetProc("MAPISendMail");
- if (sendMail == 0)
- {
- errorInfo.SetFromLastError("7-Zip cannot find MAPISendMail function");
- return errorInfo.Get_HRESULT_Error();;
- }
-
- FStringVector fullPaths;
- unsigned i;
-
- for (i = 0; i < options.Commands.Size(); i++)
- {
- CArchivePath &ap = options.Commands[i].ArchivePath;
- FString finalPath = us2fs(ap.GetFinalPath());
- FString arcPath2;
- if (!MyGetFullPathName(finalPath, arcPath2))
- return errorInfo.SetFromLastError("GetFullPathName error", finalPath);
- fullPaths.Add(arcPath2);
- }
-
- CCurrentDirRestorer curDirRestorer;
-
- AStringVector paths;
- AStringVector names;
-
- for (i = 0; i < fullPaths.Size(); i++)
- {
- const UString arcPath2 = fs2us(fullPaths[i]);
- const UString fileName = ExtractFileNameFromPath(arcPath2);
- paths.Add(GetAnsiString(arcPath2));
- names.Add(GetAnsiString(fileName));
- // const AString path (GetAnsiString(arcPath2));
- // const AString name (GetAnsiString(fileName));
- // Warning!!! MAPISendDocuments function changes Current directory
- // fnSend(0, ";", (LPSTR)(LPCSTR)path, (LPSTR)(LPCSTR)name, 0);
- }
-
- CRecordVector<MapiFileDesc> files;
- files.ClearAndSetSize(paths.Size());
-
- for (i = 0; i < paths.Size(); i++)
- {
- MapiFileDesc &f = files[i];
- memset(&f, 0, sizeof(f));
- f.nPosition = 0xFFFFFFFF;
- f.lpszPathName = (char *)(const char *)paths[i];
- f.lpszFileName = (char *)(const char *)names[i];
- }
-
- {
- MapiMessage m;
- memset(&m, 0, sizeof(m));
- m.nFileCount = files.Size();
- m.lpFiles = &files.Front();
-
- const AString addr (GetAnsiString(options.EMailAddress));
- MapiRecipDesc rec;
- if (!addr.IsEmpty())
- {
- memset(&rec, 0, sizeof(rec));
- rec.ulRecipClass = MAPI_TO;
- rec.lpszAddress = (char *)(const char *)addr;
- m.nRecipCount = 1;
- m.lpRecips = &rec;
- }
-
- sendMail((LHANDLE)0, 0, &m, MAPI_DIALOG, 0);
- }
- }
-
- #endif
-
- if (options.DeleteAfterCompressing)
- {
- CRecordVector<CDirPathSortPair> pairs;
- FStringVector foldersNames;
-
- unsigned i;
-
- for (i = 0; i < dirItems.Items.Size(); i++)
- {
- const CDirItem &dirItem = dirItems.Items[i];
- const FString phyPath = dirItems.GetPhyPath(i);
- if (dirItem.IsDir())
- {
- CDirPathSortPair pair;
- pair.Index = i;
- pair.SetNumSlashes(phyPath);
- pairs.Add(pair);
- }
- else
- {
- if (processedItems[i] != 0 || dirItem.Size == 0)
- {
- NFind::CFileInfo fileInfo;
- if (fileInfo.Find(phyPath))
- {
- // maybe we must exclude also files with archive name: "a a.7z * -sdel"
- if (fileInfo.Size == dirItem.Size
- && CompareFileTime(&fileInfo.MTime, &dirItem.MTime) == 0
- && CompareFileTime(&fileInfo.CTime, &dirItem.CTime) == 0)
- {
- RINOK(callback->DeletingAfterArchiving(phyPath, false));
- DeleteFileAlways(phyPath);
- }
- }
- }
- else
- {
- // file was skipped
- /*
- errorInfo.SystemError = 0;
- errorInfo.Message = "file was not processed";
- errorInfo.FileName = phyPath;
- return E_FAIL;
- */
- }
- }
- }
-
- pairs.Sort2();
-
- for (i = 0; i < pairs.Size(); i++)
- {
- const FString phyPath = dirItems.GetPhyPath(pairs[i].Index);
- if (NFind::DoesDirExist(phyPath))
- {
- RINOK(callback->DeletingAfterArchiving(phyPath, true));
- RemoveDir(phyPath);
- }
- }
-
- RINOK(callback->FinishDeletingAfterArchiving());
- }
-
- return S_OK;
-}
+// Update.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "Update.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+#include "../../../Windows/TimeUtils.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/MultiOutStream.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "../Common/DirItem.h"
+#include "../Common/EnumDirItems.h"
+#include "../Common/OpenArchive.h"
+#include "../Common/UpdateProduce.h"
+
+#include "EnumDirItems.h"
+#include "SetProperties.h"
+#include "TempFiles.h"
+#include "UpdateCallback.h"
+
+static const char * const kUpdateIsNotSupoorted =
+ "update operations are not supported for this archive";
+
+static const char * const kUpdateIsNotSupported_MultiVol =
+ "Updating for multivolume archives is not implemented";
+
+using namespace NWindows;
+using namespace NCOM;
+using namespace NFile;
+using namespace NDir;
+using namespace NName;
+
+#ifdef _WIN32
+static CFSTR const kTempFolderPrefix = FTEXT("7zE");
+#endif
+
+void CUpdateErrorInfo::SetFromLastError(const char *message)
+{
+ SystemError = ::GetLastError();
+ Message = message;
+}
+
+HRESULT CUpdateErrorInfo::SetFromLastError(const char *message, const FString &fileName)
+{
+ SetFromLastError(message);
+ FileNames.Add(fileName);
+ return Get_HRESULT_Error();
+}
+
+HRESULT CUpdateErrorInfo::SetFromError_DWORD(const char *message, const FString &fileName, DWORD error)
+{
+ Message = message;
+ FileNames.Add(fileName);
+ SystemError = error;
+ return Get_HRESULT_Error();
+}
+
+
+using namespace NUpdateArchive;
+
+struct CMultiOutStream_Rec
+{
+ CMultiOutStream *Spec;
+ CMyComPtr<IOutStream> Ref;
+};
+
+struct CMultiOutStream_Bunch
+{
+ CObjectVector<CMultiOutStream_Rec> Items;
+
+ HRESULT Destruct()
+ {
+ HRESULT hres = S_OK;
+ FOR_VECTOR (i, Items)
+ {
+ CMultiOutStream_Rec &rec = Items[i];
+ if (rec.Ref)
+ {
+ const HRESULT hres2 = rec.Spec->Destruct();
+ if (hres == S_OK)
+ hres = hres2;
+ }
+ }
+ Items.Clear();
+ return hres;
+ }
+
+ void DisableDeletion()
+ {
+ FOR_VECTOR (i, Items)
+ {
+ CMultiOutStream_Rec &rec = Items[i];
+ if (rec.Ref)
+ rec.Spec->NeedDelete = false;
+ }
+ }
+};
+
+
+void CArchivePath::ParseFromPath(const UString &path, EArcNameMode mode)
+{
+ OriginalPath = path;
+
+ SplitPathToParts_2(path, Prefix, Name);
+
+ if (mode == k_ArcNameMode_Add)
+ return;
+
+ if (mode != k_ArcNameMode_Exact)
+ {
+ int dotPos = Name.ReverseFind_Dot();
+ if (dotPos < 0)
+ return;
+ if ((unsigned)dotPos == Name.Len() - 1)
+ Name.DeleteBack();
+ else
+ {
+ const UString ext = Name.Ptr((unsigned)(dotPos + 1));
+ if (BaseExtension.IsEqualTo_NoCase(ext))
+ {
+ BaseExtension = ext;
+ Name.DeleteFrom((unsigned)dotPos);
+ return;
+ }
+ }
+ }
+
+ BaseExtension.Empty();
+}
+
+UString CArchivePath::GetFinalPath() const
+{
+ UString path = GetPathWithoutExt();
+ if (!BaseExtension.IsEmpty())
+ {
+ path.Add_Dot();
+ path += BaseExtension;
+ }
+ return path;
+}
+
+UString CArchivePath::GetFinalVolPath() const
+{
+ UString path = GetPathWithoutExt();
+ // if BaseExtension is empty, we must ignore VolExtension also.
+ if (!BaseExtension.IsEmpty())
+ {
+ path.Add_Dot();
+ path += VolExtension;
+ }
+ return path;
+}
+
+FString CArchivePath::GetTempPath() const
+{
+ FString path = TempPrefix;
+ path += us2fs(Name);
+ if (!BaseExtension.IsEmpty())
+ {
+ path.Add_Dot();
+ path += us2fs(BaseExtension);
+ }
+ path += ".tmp";
+ path += TempPostfix;
+ return path;
+}
+
+static const char * const kDefaultArcType = "7z";
+static const char * const kDefaultArcExt = "7z";
+static const char * const kSFXExtension =
+ #ifdef _WIN32
+ "exe";
+ #else
+ "";
+ #endif
+
+bool CUpdateOptions::InitFormatIndex(const CCodecs *codecs,
+ const CObjectVector<COpenType> &types, const UString &arcPath)
+{
+ if (types.Size() > 1)
+ return false;
+ // int arcTypeIndex = -1;
+ if (types.Size() != 0)
+ {
+ MethodMode.Type = types[0];
+ MethodMode.Type_Defined = true;
+ }
+ if (MethodMode.Type.FormatIndex < 0)
+ {
+ // MethodMode.Type = -1;
+ MethodMode.Type = COpenType();
+ if (ArcNameMode != k_ArcNameMode_Add)
+ {
+ MethodMode.Type.FormatIndex = codecs->FindFormatForArchiveName(arcPath);
+ if (MethodMode.Type.FormatIndex >= 0)
+ MethodMode.Type_Defined = true;
+ }
+ }
+ return true;
+}
+
+bool CUpdateOptions::SetArcPath(const CCodecs *codecs, const UString &arcPath)
+{
+ UString typeExt;
+ int formatIndex = MethodMode.Type.FormatIndex;
+ if (formatIndex < 0)
+ {
+ typeExt = kDefaultArcExt;
+ }
+ else
+ {
+ const CArcInfoEx &arcInfo = codecs->Formats[(unsigned)formatIndex];
+ if (!arcInfo.UpdateEnabled)
+ return false;
+ typeExt = arcInfo.GetMainExt();
+ }
+ UString ext = typeExt;
+ if (SfxMode)
+ ext = kSFXExtension;
+ ArchivePath.BaseExtension = ext;
+ ArchivePath.VolExtension = typeExt;
+ ArchivePath.ParseFromPath(arcPath, ArcNameMode);
+ FOR_VECTOR (i, Commands)
+ {
+ CUpdateArchiveCommand &uc = Commands[i];
+ uc.ArchivePath.BaseExtension = ext;
+ uc.ArchivePath.VolExtension = typeExt;
+ uc.ArchivePath.ParseFromPath(uc.UserArchivePath, ArcNameMode);
+ }
+ return true;
+}
+
+
+struct CUpdateProduceCallbackImp Z7_final: public IUpdateProduceCallback
+{
+ const CObjectVector<CArcItem> *_arcItems;
+ CDirItemsStat *_stat;
+ IUpdateCallbackUI *_callback;
+
+ CUpdateProduceCallbackImp(
+ const CObjectVector<CArcItem> *a,
+ CDirItemsStat *stat,
+ IUpdateCallbackUI *callback):
+ _arcItems(a),
+ _stat(stat),
+ _callback(callback) {}
+
+ virtual HRESULT ShowDeleteFile(unsigned arcIndex) Z7_override;
+};
+
+
+HRESULT CUpdateProduceCallbackImp::ShowDeleteFile(unsigned arcIndex)
+{
+ const CArcItem &ai = (*_arcItems)[arcIndex];
+ {
+ CDirItemsStat &stat = *_stat;
+ if (ai.IsDir)
+ stat.NumDirs++;
+ else if (ai.IsAltStream)
+ {
+ stat.NumAltStreams++;
+ stat.AltStreamsSize += ai.Size;
+ }
+ else
+ {
+ stat.NumFiles++;
+ stat.FilesSize += ai.Size;
+ }
+ }
+ return _callback->ShowDeleteFile(ai.Name, ai.IsDir);
+}
+
+bool CRenamePair::Prepare()
+{
+ if (RecursedType != NRecursedType::kNonRecursed)
+ return false;
+ if (!WildcardParsing)
+ return true;
+ return !DoesNameContainWildcard(OldName);
+}
+
+extern bool g_CaseSensitive;
+
+static unsigned CompareTwoNames(const wchar_t *s1, const wchar_t *s2)
+{
+ for (unsigned i = 0;; i++)
+ {
+ wchar_t c1 = s1[i];
+ wchar_t c2 = s2[i];
+ if (c1 == 0 || c2 == 0)
+ return i;
+ if (c1 == c2)
+ continue;
+ if (!g_CaseSensitive && (MyCharUpper(c1) == MyCharUpper(c2)))
+ continue;
+ if (IsPathSepar(c1) && IsPathSepar(c2))
+ continue;
+ return i;
+ }
+}
+
+bool CRenamePair::GetNewPath(bool isFolder, const UString &src, UString &dest) const
+{
+ unsigned num = CompareTwoNames(OldName, src);
+ if (OldName[num] == 0)
+ {
+ if (src[num] != 0 && !IsPathSepar(src[num]) && num != 0 && !IsPathSepar(src[num - 1]))
+ return false;
+ }
+ else
+ {
+ // OldName[num] != 0
+ // OldName = "1\1a.txt"
+ // src = "1"
+
+ if (!isFolder
+ || src[num] != 0
+ || !IsPathSepar(OldName[num])
+ || OldName[num + 1] != 0)
+ return false;
+ }
+ dest = NewName + src.Ptr(num);
+ return true;
+}
+
+#ifdef SUPPORT_ALT_STREAMS
+int FindAltStreamColon_in_Path(const wchar_t *path);
+#endif
+
+
+
+static HRESULT Compress(
+ const CUpdateOptions &options,
+ bool isUpdatingItself,
+ CCodecs *codecs,
+ const CActionSet &actionSet,
+ const CArc *arc,
+ CArchivePath &archivePath,
+ const CObjectVector<CArcItem> &arcItems,
+ Byte *processedItemsStatuses,
+ const CDirItems &dirItems,
+ const CDirItem *parentDirItem,
+ CTempFiles &tempFiles,
+ CMultiOutStream_Bunch &multiStreams,
+ CUpdateErrorInfo &errorInfo,
+ IUpdateCallbackUI *callback,
+ CFinishArchiveStat &st)
+{
+ CMyComPtr<IOutArchive> outArchive;
+ int formatIndex = options.MethodMode.Type.FormatIndex;
+
+ if (arc)
+ {
+ formatIndex = arc->FormatIndex;
+ if (formatIndex < 0)
+ return E_NOTIMPL;
+ CMyComPtr<IInArchive> archive2 = arc->Archive;
+ HRESULT result = archive2.QueryInterface(IID_IOutArchive, &outArchive);
+ if (result != S_OK)
+ throw kUpdateIsNotSupoorted;
+ }
+ else
+ {
+ RINOK(codecs->CreateOutArchive((unsigned)formatIndex, outArchive))
+
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
+ outArchive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
+ if (setCompressCodecsInfo)
+ {
+ RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs))
+ }
+ }
+ #endif
+ }
+
+ if (!outArchive)
+ throw kUpdateIsNotSupoorted;
+
+ // we need to set properties to get fileTimeType.
+ RINOK(SetProperties(outArchive, options.MethodMode.Properties))
+
+ NFileTimeType::EEnum fileTimeType;
+ {
+ /*
+ how we compare file_in_archive::MTime with dirItem.MTime
+ for GetUpdatePairInfoList():
+
+ if (kpidMTime is not defined), external MTime of archive is used.
+
+ before 22.00:
+ if (kpidTimeType is defined)
+ {
+ kpidTimeType is used as precision.
+ (kpidTimeType > kDOS) is not allowed.
+ }
+ else GetFileTimeType() value is used as precision.
+
+ 22.00:
+ if (kpidMTime is defined)
+ {
+ if (kpidMTime::precision != 0), then kpidMTime::precision is used as precision.
+ else
+ {
+ if (kpidTimeType is defined), kpidTimeType is used as precision.
+ else GetFileTimeType() value is used as precision.
+ }
+ }
+ else external MTime of archive is used as precision.
+ */
+
+ UInt32 value;
+ RINOK(outArchive->GetFileTimeType(&value))
+
+ // we support any future fileType here.
+ fileTimeType = (NFileTimeType::EEnum)value;
+
+ /*
+ old 21.07 code:
+ switch (value)
+ {
+ case NFileTimeType::kWindows:
+ case NFileTimeType::kUnix:
+ case NFileTimeType::kDOS:
+ fileTimeType = (NFileTimeType::EEnum)value;
+ break;
+ default:
+ return E_FAIL;
+ }
+ */
+ }
+
+ // bool noTimestampExpected = false;
+ {
+ const CArcInfoEx &arcInfo = codecs->Formats[(unsigned)formatIndex];
+
+ // if (arcInfo.Flags_KeepName()) noTimestampExpected = true;
+ if (arcInfo.Is_Xz() ||
+ arcInfo.Is_BZip2())
+ {
+ /* 7-zip before 22.00 returns NFileTimeType::kUnix for xz and bzip2,
+ but we want to set timestamp without reduction to unix. */
+ // noTimestampExpected = true;
+ fileTimeType = NFileTimeType::kNotDefined; // it means not defined
+ }
+
+ if (options.AltStreams.Val && !arcInfo.Flags_AltStreams())
+ return E_NOTIMPL;
+ if (options.NtSecurity.Val && !arcInfo.Flags_NtSecurity())
+ return E_NOTIMPL;
+ if (options.DeleteAfterCompressing && arcInfo.Flags_HashHandler())
+ return E_NOTIMPL;
+ }
+
+ CRecordVector<CUpdatePair2> updatePairs2;
+
+ UStringVector newNames;
+
+ CArcToDoStat stat2;
+
+ if (options.RenamePairs.Size() != 0)
+ {
+ FOR_VECTOR (i, arcItems)
+ {
+ const CArcItem &ai = arcItems[i];
+ bool needRename = false;
+ UString dest;
+
+ if (ai.Censored)
+ {
+ FOR_VECTOR (j, options.RenamePairs)
+ {
+ const CRenamePair &rp = options.RenamePairs[j];
+ if (rp.GetNewPath(ai.IsDir, ai.Name, dest))
+ {
+ needRename = true;
+ break;
+ }
+
+ #ifdef SUPPORT_ALT_STREAMS
+ if (ai.IsAltStream)
+ {
+ int colonPos = FindAltStreamColon_in_Path(ai.Name);
+ if (colonPos >= 0)
+ {
+ UString mainName = ai.Name.Left((unsigned)colonPos);
+ /*
+ actually we must improve that code to support cases
+ with folder renaming like: rn arc dir1\ dir2\
+ */
+ if (rp.GetNewPath(false, mainName, dest))
+ {
+ needRename = true;
+ dest += ':';
+ dest += ai.Name.Ptr((unsigned)(colonPos + 1));
+ break;
+ }
+ }
+ }
+ #endif
+ }
+ }
+
+ CUpdatePair2 up2;
+ up2.SetAs_NoChangeArcItem(ai.IndexInServer);
+ if (needRename)
+ {
+ up2.NewProps = true;
+ RINOK(arc->IsItem_Anti(i, up2.IsAnti))
+ up2.NewNameIndex = (int)newNames.Add(dest);
+ }
+ updatePairs2.Add(up2);
+ }
+ }
+ else
+ {
+ CRecordVector<CUpdatePair> updatePairs;
+ GetUpdatePairInfoList(dirItems, arcItems, fileTimeType, updatePairs); // must be done only once!!!
+ CUpdateProduceCallbackImp upCallback(&arcItems, &stat2.DeleteData, callback);
+
+ UpdateProduce(updatePairs, actionSet, updatePairs2, isUpdatingItself ? &upCallback : NULL);
+ }
+
+ {
+ FOR_VECTOR (i, updatePairs2)
+ {
+ const CUpdatePair2 &up = updatePairs2[i];
+
+ // 17.01: anti-item is (up.NewData && (p.UseArcProps in most cases))
+
+ if (up.NewData && !up.UseArcProps)
+ {
+ if (up.ExistOnDisk())
+ {
+ CDirItemsStat2 &stat = stat2.NewData;
+ const CDirItem &di = dirItems.Items[(unsigned)up.DirIndex];
+ if (di.IsDir())
+ {
+ if (up.IsAnti)
+ stat.Anti_NumDirs++;
+ else
+ stat.NumDirs++;
+ }
+ #ifdef _WIN32
+ else if (di.IsAltStream)
+ {
+ if (up.IsAnti)
+ stat.Anti_NumAltStreams++;
+ else
+ {
+ stat.NumAltStreams++;
+ stat.AltStreamsSize += di.Size;
+ }
+ }
+ #endif
+ else
+ {
+ if (up.IsAnti)
+ stat.Anti_NumFiles++;
+ else
+ {
+ stat.NumFiles++;
+ stat.FilesSize += di.Size;
+ }
+ }
+ }
+ }
+ else if (up.ArcIndex >= 0)
+ {
+ CDirItemsStat2 &stat = *(up.NewData ? &stat2.NewData : &stat2.OldData);
+ const CArcItem &ai = arcItems[(unsigned)up.ArcIndex];
+ if (ai.IsDir)
+ {
+ if (up.IsAnti)
+ stat.Anti_NumDirs++;
+ else
+ stat.NumDirs++;
+ }
+ else if (ai.IsAltStream)
+ {
+ if (up.IsAnti)
+ stat.Anti_NumAltStreams++;
+ else
+ {
+ stat.NumAltStreams++;
+ stat.AltStreamsSize += ai.Size;
+ }
+ }
+ else
+ {
+ if (up.IsAnti)
+ stat.Anti_NumFiles++;
+ else
+ {
+ stat.NumFiles++;
+ stat.FilesSize += ai.Size;
+ }
+ }
+ }
+ }
+ RINOK(callback->SetNumItems(stat2))
+ }
+
+ CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
+ CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ updateCallbackSpec->PreserveATime = options.PreserveATime;
+ updateCallbackSpec->ShareForWrite = options.OpenShareForWrite;
+ updateCallbackSpec->StopAfterOpenError = options.StopAfterOpenError;
+ updateCallbackSpec->StdInMode = options.StdInMode;
+ updateCallbackSpec->Callback = callback;
+
+ if (arc)
+ {
+ // we set Archive to allow to transfer GetProperty requests back to DLL.
+ updateCallbackSpec->Archive = arc->Archive;
+ }
+
+ updateCallbackSpec->DirItems = &dirItems;
+ updateCallbackSpec->ParentDirItem = parentDirItem;
+
+ updateCallbackSpec->StoreNtSecurity = options.NtSecurity.Val;
+ updateCallbackSpec->StoreHardLinks = options.HardLinks.Val;
+ updateCallbackSpec->StoreSymLinks = options.SymLinks.Val;
+ updateCallbackSpec->StoreOwnerName = options.StoreOwnerName.Val;
+ updateCallbackSpec->StoreOwnerId = options.StoreOwnerId.Val;
+
+ updateCallbackSpec->Arc = arc;
+ updateCallbackSpec->ArcItems = &arcItems;
+ updateCallbackSpec->UpdatePairs = &updatePairs2;
+
+ updateCallbackSpec->ProcessedItemsStatuses = processedItemsStatuses;
+
+ {
+ const UString arcPath = archivePath.GetFinalPath();
+ updateCallbackSpec->ArcFileName = ExtractFileNameFromPath(arcPath);
+ }
+
+ if (options.RenamePairs.Size() != 0)
+ updateCallbackSpec->NewNames = &newNames;
+
+ if (options.SetArcMTime)
+ {
+ // updateCallbackSpec->Need_ArcMTime_Report = true;
+ updateCallbackSpec->Need_LatestMTime = true;
+ }
+
+ CMyComPtr<IOutStream> outSeekStream;
+ CMyComPtr<ISequentialOutStream> outStream;
+
+ if (!options.StdOutMode)
+ {
+ FString dirPrefix;
+ if (!GetOnlyDirPrefix(us2fs(archivePath.GetFinalPath()), dirPrefix))
+ throw 1417161;
+ CreateComplexDir(dirPrefix);
+ }
+
+ COutFileStream *outStreamSpec = NULL;
+ CStdOutFileStream *stdOutFileStreamSpec = NULL;
+ CMultiOutStream *volStreamSpec = NULL;
+
+ if (options.VolumesSizes.Size() == 0)
+ {
+ if (options.StdOutMode)
+ {
+ stdOutFileStreamSpec = new CStdOutFileStream;
+ outStream = stdOutFileStreamSpec;
+ }
+ else
+ {
+ outStreamSpec = new COutFileStream;
+ outSeekStream = outStreamSpec;
+ outStream = outSeekStream;
+ bool isOK = false;
+ FString realPath;
+
+ for (unsigned i = 0; i < (1 << 16); i++)
+ {
+ if (archivePath.Temp)
+ {
+ if (i > 0)
+ {
+ archivePath.TempPostfix.Empty();
+ archivePath.TempPostfix.Add_UInt32(i);
+ }
+ realPath = archivePath.GetTempPath();
+ }
+ else
+ realPath = us2fs(archivePath.GetFinalPath());
+ if (outStreamSpec->Create(realPath, false))
+ {
+ tempFiles.Paths.Add(realPath);
+ isOK = true;
+ break;
+ }
+ if (::GetLastError() != ERROR_FILE_EXISTS)
+ break;
+ if (!archivePath.Temp)
+ break;
+ }
+
+ if (!isOK)
+ return errorInfo.SetFromLastError("cannot open file", realPath);
+ }
+ }
+ else
+ {
+ if (options.StdOutMode)
+ return E_FAIL;
+ if (arc && arc->GetGlobalOffset() > 0)
+ return E_NOTIMPL;
+
+ volStreamSpec = new CMultiOutStream();
+ outSeekStream = volStreamSpec;
+ outStream = outSeekStream;
+ volStreamSpec->Prefix = us2fs(archivePath.GetFinalVolPath());
+ volStreamSpec->Prefix.Add_Dot();
+ volStreamSpec->Init(options.VolumesSizes);
+ {
+ CMultiOutStream_Rec &rec = multiStreams.Items.AddNew();
+ rec.Spec = volStreamSpec;
+ rec.Ref = rec.Spec;
+ }
+
+ /*
+ updateCallbackSpec->VolumesSizes = volumesSizes;
+ updateCallbackSpec->VolName = archivePath.Prefix + archivePath.Name;
+ if (!archivePath.VolExtension.IsEmpty())
+ updateCallbackSpec->VolExt = UString('.') + archivePath.VolExtension;
+ */
+ }
+
+ if (options.SfxMode)
+ {
+ CInFileStream *sfxStreamSpec = new CInFileStream;
+ CMyComPtr<IInStream> sfxStream(sfxStreamSpec);
+ if (!sfxStreamSpec->Open(options.SfxModule))
+ return errorInfo.SetFromLastError("cannot open SFX module", options.SfxModule);
+
+ CMyComPtr<ISequentialOutStream> sfxOutStream;
+ COutFileStream *outStreamSpec2 = NULL;
+ if (options.VolumesSizes.Size() == 0)
+ sfxOutStream = outStream;
+ else
+ {
+ outStreamSpec2 = new COutFileStream;
+ sfxOutStream = outStreamSpec2;
+ const FString realPath = us2fs(archivePath.GetFinalPath());
+ if (!outStreamSpec2->Create(realPath, false))
+ return errorInfo.SetFromLastError("cannot open file", realPath);
+ }
+
+ {
+ UInt64 sfxSize;
+ RINOK(sfxStreamSpec->GetSize(&sfxSize))
+ RINOK(callback->WriteSfx(fs2us(options.SfxModule), sfxSize))
+ }
+
+ RINOK(NCompress::CopyStream(sfxStream, sfxOutStream, NULL))
+
+ if (outStreamSpec2)
+ {
+ RINOK(outStreamSpec2->Close())
+ }
+ }
+
+ CMyComPtr<ISequentialOutStream> tailStream;
+
+ if (options.SfxMode || !arc || arc->ArcStreamOffset == 0)
+ tailStream = outStream;
+ else
+ {
+ // Int64 globalOffset = arc->GetGlobalOffset();
+ RINOK(InStream_SeekToBegin(arc->InStream))
+ RINOK(NCompress::CopyStream_ExactSize(arc->InStream, outStream, arc->ArcStreamOffset, NULL))
+ if (options.StdOutMode)
+ tailStream = outStream;
+ else
+ {
+ CTailOutStream *tailStreamSpec = new CTailOutStream;
+ tailStream = tailStreamSpec;
+ tailStreamSpec->Stream = outSeekStream;
+ tailStreamSpec->Offset = arc->ArcStreamOffset;
+ tailStreamSpec->Init();
+ }
+ }
+
+ CFiTime ft;
+ FiTime_Clear(ft);
+ bool ft_Defined = false;
+ {
+ FOR_VECTOR (i, updatePairs2)
+ {
+ const CUpdatePair2 &pair2 = updatePairs2[i];
+ CFiTime ft2;
+ FiTime_Clear(ft2);
+ bool ft2_Defined = false;
+ /* we use full precision of dirItem, if dirItem is defined
+ and (dirItem will be used or dirItem is sameTime in dir and arc */
+ if (pair2.DirIndex >= 0 &&
+ (pair2.NewProps || pair2.IsSameTime))
+ {
+ ft2 = dirItems.Items[(unsigned)pair2.DirIndex].MTime;
+ ft2_Defined = true;
+ }
+ else if (pair2.UseArcProps && pair2.ArcIndex >= 0)
+ {
+ const CArcItem &arcItem = arcItems[(unsigned)pair2.ArcIndex];
+ if (arcItem.MTime.Def)
+ {
+ arcItem.MTime.Write_To_FiTime(ft2);
+ ft2_Defined = true;
+ }
+ }
+ if (ft2_Defined)
+ {
+ if (!ft_Defined || Compare_FiTime(&ft, &ft2) < 0)
+ {
+ ft = ft2;
+ ft_Defined = true;
+ }
+ }
+ }
+ /*
+ if (fileTimeType != NFileTimeType::kNotDefined)
+ FiTime_Normalize_With_Prec(ft, fileTimeType);
+ */
+ }
+
+ if (volStreamSpec && options.SetArcMTime && ft_Defined)
+ {
+ volStreamSpec->MTime = ft;
+ volStreamSpec->MTime_Defined = true;
+ }
+
+ HRESULT result = outArchive->UpdateItems(tailStream, updatePairs2.Size(), updateCallback);
+ // callback->Finalize();
+ RINOK(result)
+
+ if (!updateCallbackSpec->AreAllFilesClosed())
+ {
+ errorInfo.Message = "There are unclosed input file:";
+ errorInfo.FileNames = updateCallbackSpec->_openFiles_Paths;
+ return E_FAIL;
+ }
+
+ if (options.SetArcMTime)
+ {
+ // bool needNormalizeAfterStream;
+ // needParse;
+ /*
+ if (updateCallbackSpec->ArcMTime_WasReported)
+ {
+ isDefined = updateCallbackSpec->Reported_ArcMTime.Def;
+ if (isDefined)
+ updateCallbackSpec->Reported_ArcMTime.Write_To_FiTime(ft);
+ else
+ fileTimeType = NFileTimeType::kNotDefined;
+ }
+ if (!isDefined)
+ */
+ {
+ if (updateCallbackSpec->LatestMTime_Defined)
+ {
+ // CArcTime at = StreamCallback_ArcMTime;
+ // updateCallbackSpec->StreamCallback_ArcMTime.Write_To_FiTime(ft);
+ // we must normalize with precision from archive;
+ if (!ft_Defined || Compare_FiTime(&ft, &updateCallbackSpec->LatestMTime) < 0)
+ ft = updateCallbackSpec->LatestMTime;
+ ft_Defined = true;
+ }
+ /*
+ if (fileTimeType != NFileTimeType::kNotDefined)
+ FiTime_Normalize_With_Prec(ft, fileTimeType);
+ */
+ }
+ // if (ft.dwLowDateTime != 0 || ft.dwHighDateTime != 0)
+ if (ft_Defined)
+ {
+ // we ignore set time errors here.
+ // note that user could move some finished volumes to another folder.
+ if (outStreamSpec)
+ outStreamSpec->SetMTime(&ft);
+ else if (volStreamSpec)
+ volStreamSpec->SetMTime_Final(ft);
+ }
+ }
+
+ if (callback)
+ {
+ UInt64 size = 0;
+ if (outStreamSpec)
+ outStreamSpec->GetSize(&size);
+ else if (stdOutFileStreamSpec)
+ size = stdOutFileStreamSpec->GetSize();
+ else
+ size = volStreamSpec->GetSize();
+
+ st.OutArcFileSize = size;
+ }
+
+ if (outStreamSpec)
+ result = outStreamSpec->Close();
+ else if (volStreamSpec)
+ {
+ result = volStreamSpec->FinalFlush_and_CloseFiles(st.NumVolumes);
+ st.IsMultiVolMode = true;
+ }
+
+ RINOK(result)
+
+ if (processedItemsStatuses)
+ {
+ FOR_VECTOR (i, updatePairs2)
+ {
+ const CUpdatePair2 &up = updatePairs2[i];
+ if (up.NewData && up.DirIndex >= 0)
+ {
+ const CDirItem &di = dirItems.Items[(unsigned)up.DirIndex];
+ if (di.AreReparseData() || (!di.IsDir() && di.Size == 0))
+ processedItemsStatuses[(unsigned)up.DirIndex] = 1;
+ }
+ }
+ }
+
+ return result;
+}
+
+
+
+static bool Censor_AreAllAllowed(const NWildcard::CCensor &censor)
+{
+ if (censor.Pairs.Size() != 1)
+ return false;
+ const NWildcard::CPair &pair = censor.Pairs[0];
+ /* Censor_CheckPath() ignores (CPair::Prefix).
+ So we also ignore (CPair::Prefix) here */
+ // if (!pair.Prefix.IsEmpty()) return false;
+ return pair.Head.AreAllAllowed();
+}
+
+bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include);
+
+static bool Censor_CheckPath(const NWildcard::CCensor &censor, const CReadArcItem &item)
+{
+ bool finded = false;
+ FOR_VECTOR (i, censor.Pairs)
+ {
+ /* (CPair::Prefix) in not used for matching items in archive.
+ So we ignore (CPair::Prefix) here */
+ bool include;
+ if (CensorNode_CheckPath2(censor.Pairs[i].Head, item, include))
+ {
+ // Check it and FIXME !!!!
+ // here we can exclude item via some Pair, that is still allowed by another Pair
+ if (!include)
+ return false;
+ finded = true;
+ }
+ }
+ return finded;
+}
+
+static HRESULT EnumerateInArchiveItems(
+ // bool storeStreamsMode,
+ const NWildcard::CCensor &censor,
+ const CArc &arc,
+ CObjectVector<CArcItem> &arcItems)
+{
+ arcItems.Clear();
+ UInt32 numItems;
+ IInArchive *archive = arc.Archive;
+ RINOK(archive->GetNumberOfItems(&numItems))
+ arcItems.ClearAndReserve(numItems);
+
+ CReadArcItem item;
+
+ const bool allFilesAreAllowed = Censor_AreAllAllowed(censor);
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ CArcItem ai;
+
+ RINOK(arc.GetItem(i, item))
+ ai.Name = item.Path;
+ ai.IsDir = item.IsDir;
+ ai.IsAltStream =
+ #ifdef SUPPORT_ALT_STREAMS
+ item.IsAltStream;
+ #else
+ false;
+ #endif
+
+ /*
+ if (!storeStreamsMode && ai.IsAltStream)
+ continue;
+ */
+ if (allFilesAreAllowed)
+ ai.Censored = true;
+ else
+ ai.Censored = Censor_CheckPath(censor, item);
+
+ // ai.MTime will be set to archive MTime, if not present in archive item
+ RINOK(arc.GetItem_MTime(i, ai.MTime))
+ RINOK(arc.GetItem_Size(i, ai.Size, ai.Size_Defined))
+
+ ai.IndexInServer = i;
+ arcItems.AddInReserved(ai);
+ }
+ return S_OK;
+}
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <mapi.h>
+#else
+#include <MAPI.h>
+#endif
+
+extern "C" {
+
+#ifdef MAPI_FORCE_UNICODE
+
+#define Z7_WIN_LPMAPISENDMAILW LPMAPISENDMAILW
+#define Z7_WIN_MapiFileDescW MapiFileDescW
+#define Z7_WIN_MapiMessageW MapiMessageW
+#define Z7_WIN_MapiRecipDescW MapiRecipDescW
+
+#else
+
+typedef struct
+{
+ ULONG ulReserved;
+ ULONG ulRecipClass;
+ PWSTR lpszName;
+ PWSTR lpszAddress;
+ ULONG ulEIDSize;
+ PVOID lpEntryID;
+} Z7_WIN_MapiRecipDescW, *Z7_WIN_lpMapiRecipDescW;
+
+typedef struct
+{
+ ULONG ulReserved;
+ ULONG flFlags;
+ ULONG nPosition;
+ PWSTR lpszPathName;
+ PWSTR lpszFileName;
+ PVOID lpFileType;
+} Z7_WIN_MapiFileDescW, *Z7_WIN_lpMapiFileDescW;
+
+typedef struct
+{
+ ULONG ulReserved;
+ PWSTR lpszSubject;
+ PWSTR lpszNoteText;
+ PWSTR lpszMessageType;
+ PWSTR lpszDateReceived;
+ PWSTR lpszConversationID;
+ FLAGS flFlags;
+ Z7_WIN_lpMapiRecipDescW lpOriginator;
+ ULONG nRecipCount;
+ Z7_WIN_lpMapiRecipDescW lpRecips;
+ ULONG nFileCount;
+ Z7_WIN_lpMapiFileDescW lpFiles;
+} Z7_WIN_MapiMessageW, *Z7_WIN_lpMapiMessageW;
+
+typedef ULONG (FAR PASCAL Z7_WIN_MAPISENDMAILW)(
+ LHANDLE lhSession,
+ ULONG_PTR ulUIParam,
+ Z7_WIN_lpMapiMessageW lpMessage,
+ FLAGS flFlags,
+ ULONG ulReserved
+);
+typedef Z7_WIN_MAPISENDMAILW FAR *Z7_WIN_LPMAPISENDMAILW;
+
+#endif // MAPI_FORCE_UNICODE
+}
+#endif // _WIN32
+
+
+HRESULT UpdateArchive(
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &types,
+ const UString &cmdArcPath2,
+ NWildcard::CCensor &censor,
+ CUpdateOptions &options,
+ CUpdateErrorInfo &errorInfo,
+ IOpenCallbackUI *openCallback,
+ IUpdateCallbackUI2 *callback,
+ bool needSetPath)
+{
+ if (options.StdOutMode && options.EMailMode)
+ return E_FAIL;
+
+ if (types.Size() > 1)
+ return E_NOTIMPL;
+
+ bool renameMode = !options.RenamePairs.IsEmpty();
+ if (renameMode)
+ {
+ if (options.Commands.Size() != 1)
+ return E_FAIL;
+ }
+
+ if (options.DeleteAfterCompressing)
+ {
+ if (options.Commands.Size() != 1)
+ return E_NOTIMPL;
+ const CActionSet &as = options.Commands[0].ActionSet;
+ for (unsigned i = 2; i < NPairState::kNumValues; i++)
+ if (as.StateActions[i] != NPairAction::kCompress)
+ return E_NOTIMPL;
+ }
+
+ censor.AddPathsToCensor(options.PathMode);
+ #ifdef _WIN32
+ ConvertToLongNames(censor);
+ #endif
+ censor.ExtendExclude();
+
+
+ if (options.VolumesSizes.Size() > 0 && (options.EMailMode /* || options.SfxMode */))
+ return E_NOTIMPL;
+
+ if (options.SfxMode)
+ {
+ CProperty property;
+ property.Name = "rsfx";
+ options.MethodMode.Properties.Add(property);
+ if (options.SfxModule.IsEmpty())
+ {
+ errorInfo.Message = "SFX file is not specified";
+ return E_FAIL;
+ }
+ bool found = false;
+ if (options.SfxModule.Find(FCHAR_PATH_SEPARATOR) < 0)
+ {
+ const FString fullName = NDLL::GetModuleDirPrefix() + options.SfxModule;
+ if (NFind::DoesFileExist_FollowLink(fullName))
+ {
+ options.SfxModule = fullName;
+ found = true;
+ }
+ }
+ if (!found)
+ {
+ if (!NFind::DoesFileExist_FollowLink(options.SfxModule))
+ return errorInfo.SetFromLastError("cannot find specified SFX module", options.SfxModule);
+ }
+ }
+
+ CArchiveLink arcLink;
+
+
+ if (needSetPath)
+ {
+ if (!options.InitFormatIndex(codecs, types, cmdArcPath2) ||
+ !options.SetArcPath(codecs, cmdArcPath2))
+ return E_NOTIMPL;
+ }
+
+ UString arcPath = options.ArchivePath.GetFinalPath();
+
+ if (!options.VolumesSizes.IsEmpty())
+ {
+ arcPath = options.ArchivePath.GetFinalVolPath();
+ arcPath += ".001";
+ }
+
+ if (cmdArcPath2.IsEmpty())
+ {
+ if (options.MethodMode.Type.FormatIndex < 0)
+ throw "type of archive is not specified";
+ }
+ else
+ {
+ NFind::CFileInfo fi;
+ if (!fi.Find_FollowLink(us2fs(arcPath)))
+ {
+ if (renameMode)
+ throw "can't find archive";
+ if (options.MethodMode.Type.FormatIndex < 0)
+ {
+ if (!options.SetArcPath(codecs, cmdArcPath2))
+ return E_NOTIMPL;
+ }
+ }
+ else
+ {
+ if (fi.IsDir())
+ return errorInfo.SetFromError_DWORD("There is a folder with the name of archive",
+ us2fs(arcPath),
+ #ifdef _WIN32
+ ERROR_ACCESS_DENIED
+ #else
+ EISDIR
+ #endif
+ );
+ #ifdef _WIN32
+ if (fi.IsDevice)
+ return E_NOTIMPL;
+ #endif
+
+ if (!options.StdOutMode && options.UpdateArchiveItself)
+ if (fi.IsReadOnly())
+ {
+ return errorInfo.SetFromError_DWORD("The file is read-only",
+ us2fs(arcPath),
+ #ifdef _WIN32
+ ERROR_ACCESS_DENIED
+ #else
+ EACCES
+ #endif
+ );
+ }
+
+ if (options.VolumesSizes.Size() > 0)
+ {
+ errorInfo.FileNames.Add(us2fs(arcPath));
+ // errorInfo.SystemError = (DWORD)E_NOTIMPL;
+ errorInfo.Message = kUpdateIsNotSupported_MultiVol;
+ return E_NOTIMPL;
+ }
+ CObjectVector<COpenType> types2;
+ // change it.
+ if (options.MethodMode.Type_Defined)
+ types2.Add(options.MethodMode.Type);
+ // We need to set Properties to open archive only in some cases (WIM archives).
+
+ CIntVector excl;
+ COpenOptions op;
+ #ifndef Z7_SFX
+ op.props = &options.MethodMode.Properties;
+ #endif
+ op.codecs = codecs;
+ op.types = &types2;
+ op.excludedFormats = !
+ op.stdInMode = false;
+ op.stream = NULL;
+ op.filePath = arcPath;
+
+ RINOK(callback->StartOpenArchive(arcPath))
+
+ HRESULT result = arcLink.Open_Strict(op, openCallback);
+
+ if (result == E_ABORT)
+ return result;
+
+ HRESULT res2 = callback->OpenResult(codecs, arcLink, arcPath, result);
+ /*
+ if (result == S_FALSE)
+ return E_FAIL;
+ */
+ RINOK(res2)
+ RINOK(result)
+
+ if (arcLink.VolumePaths.Size() > 1)
+ {
+ // errorInfo.SystemError = (DWORD)E_NOTIMPL;
+ errorInfo.Message = kUpdateIsNotSupported_MultiVol;
+ return E_NOTIMPL;
+ }
+
+ CArc &arc = arcLink.Arcs.Back();
+ arc.MTime.Def =
+ #ifdef _WIN32
+ !fi.IsDevice;
+ #else
+ true;
+ #endif
+ if (arc.MTime.Def)
+ arc.MTime.Set_From_FiTime(fi.MTime);
+
+ if (arc.ErrorInfo.ThereIsTail)
+ {
+ // errorInfo.SystemError = (DWORD)E_NOTIMPL;
+ errorInfo.Message = "There is some data block after the end of the archive";
+ return E_NOTIMPL;
+ }
+ if (options.MethodMode.Type.FormatIndex < 0)
+ {
+ options.MethodMode.Type.FormatIndex = arcLink.GetArc()->FormatIndex;
+ if (!options.SetArcPath(codecs, cmdArcPath2))
+ return E_NOTIMPL;
+ }
+ }
+ }
+
+ if (options.MethodMode.Type.FormatIndex < 0)
+ {
+ options.MethodMode.Type.FormatIndex = codecs->FindFormatForArchiveType((UString)kDefaultArcType);
+ if (options.MethodMode.Type.FormatIndex < 0)
+ return E_NOTIMPL;
+ }
+
+ bool thereIsInArchive = arcLink.IsOpen;
+ if (!thereIsInArchive && renameMode)
+ return E_FAIL;
+
+ CDirItems dirItems;
+ dirItems.Callback = callback;
+
+ CDirItem parentDirItem;
+ CDirItem *parentDirItem_Ptr = NULL;
+
+ /*
+ FStringVector requestedPaths;
+ FStringVector *requestedPaths_Ptr = NULL;
+ if (options.DeleteAfterCompressing)
+ requestedPaths_Ptr = &requestedPaths;
+ */
+
+ if (options.StdInMode)
+ {
+ CDirItem di;
+ di.ClearBase();
+ di.Name = options.StdInFileName;
+ di.Size = (UInt64)(Int64)-1;
+ di.SetAsFile();
+ NTime::GetCurUtc_FiTime(di.MTime);
+ di.CTime = di.ATime = di.MTime;
+ dirItems.Items.Add(di);
+ }
+ else
+ {
+ bool needScanning = false;
+
+ if (!renameMode)
+ FOR_VECTOR (i, options.Commands)
+ if (options.Commands[i].ActionSet.NeedScanning())
+ needScanning = true;
+
+ if (needScanning)
+ {
+ RINOK(callback->StartScanning())
+
+ dirItems.SymLinks = options.SymLinks.Val;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ dirItems.ReadSecure = options.NtSecurity.Val;
+ #endif
+
+ dirItems.ScanAltStreams = options.AltStreams.Val;
+ dirItems.ExcludeDirItems = censor.ExcludeDirItems;
+ dirItems.ExcludeFileItems = censor.ExcludeFileItems;
+
+ dirItems.ShareForWrite = options.OpenShareForWrite;
+
+ #ifndef _WIN32
+ dirItems.StoreOwnerName = options.StoreOwnerName.Val;
+ #endif
+
+ const HRESULT res = EnumerateItems(censor,
+ options.PathMode,
+ UString(), // options.AddPathPrefix,
+ dirItems);
+
+ if (res != S_OK)
+ {
+ if (res != E_ABORT)
+ errorInfo.Message = "Scanning error";
+ return res;
+ }
+
+ RINOK(callback->FinishScanning(dirItems.Stat))
+
+ // 22.00: we don't need parent folder, if absolute path mode
+ if (options.PathMode != NWildcard::k_AbsPath)
+ if (censor.Pairs.Size() == 1)
+ {
+ NFind::CFileInfo fi;
+ FString prefix = us2fs(censor.Pairs[0].Prefix);
+ prefix.Add_Dot();
+ // UString prefix = censor.Pairs[0].Prefix;
+ /*
+ if (prefix.Back() == WCHAR_PATH_SEPARATOR)
+ {
+ prefix.DeleteBack();
+ }
+ */
+ if (fi.Find(prefix))
+ if (fi.IsDir())
+ {
+ parentDirItem.Copy_From_FileInfoBase(fi);
+ parentDirItem_Ptr = &parentDirItem;
+
+ int secureIndex = -1;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (options.NtSecurity.Val)
+ dirItems.AddSecurityItem(prefix, secureIndex);
+ #endif
+ parentDirItem.SecureIndex = secureIndex;
+ }
+ }
+ }
+ }
+
+ FString tempDirPrefix;
+ bool usesTempDir = false;
+
+ #ifdef _WIN32
+ CTempDir tempDirectory;
+ if (options.EMailMode && options.EMailRemoveAfter)
+ {
+ tempDirectory.Create(kTempFolderPrefix);
+ tempDirPrefix = tempDirectory.GetPath();
+ NormalizeDirPathPrefix(tempDirPrefix);
+ usesTempDir = true;
+ }
+ #endif
+
+ CTempFiles tempFiles;
+
+ bool createTempFile = false;
+
+ if (!options.StdOutMode && options.UpdateArchiveItself)
+ {
+ CArchivePath &ap = options.Commands[0].ArchivePath;
+ ap = options.ArchivePath;
+ // if ((archive != 0 && !usesTempDir) || !options.WorkingDir.IsEmpty())
+ if ((thereIsInArchive || !options.WorkingDir.IsEmpty()) && !usesTempDir && options.VolumesSizes.Size() == 0)
+ {
+ createTempFile = true;
+ ap.Temp = true;
+ if (!options.WorkingDir.IsEmpty())
+ ap.TempPrefix = options.WorkingDir;
+ else
+ ap.TempPrefix = us2fs(ap.Prefix);
+ NormalizeDirPathPrefix(ap.TempPrefix);
+ }
+ }
+
+ unsigned ci;
+
+
+ // self including protection
+ if (options.DeleteAfterCompressing)
+ {
+ for (ci = 0; ci < options.Commands.Size(); ci++)
+ {
+ CArchivePath &ap = options.Commands[ci].ArchivePath;
+ const FString path = us2fs(ap.GetFinalPath());
+ // maybe we must compare absolute paths path here
+ FOR_VECTOR (i, dirItems.Items)
+ {
+ const FString phyPath = dirItems.GetPhyPath(i);
+ if (phyPath == path)
+ {
+ UString s;
+ s = "It is not allowed to include archive to itself";
+ s.Add_LF();
+ s += fs2us(path);
+ throw s;
+ }
+ }
+ }
+ }
+
+
+ for (ci = 0; ci < options.Commands.Size(); ci++)
+ {
+ CArchivePath &ap = options.Commands[ci].ArchivePath;
+ if (usesTempDir)
+ {
+ // Check it
+ ap.Prefix = fs2us(tempDirPrefix);
+ // ap.Temp = true;
+ // ap.TempPrefix = tempDirPrefix;
+ }
+ if (!options.StdOutMode &&
+ (ci > 0 || !createTempFile))
+ {
+ const FString path = us2fs(ap.GetFinalPath());
+ if (NFind::DoesFileOrDirExist(path))
+ {
+ errorInfo.SystemError = ERROR_FILE_EXISTS;
+ errorInfo.Message = "The file already exists";
+ errorInfo.FileNames.Add(path);
+ return errorInfo.Get_HRESULT_Error();
+ }
+ }
+ }
+
+ CObjectVector<CArcItem> arcItems;
+ if (thereIsInArchive)
+ {
+ RINOK(EnumerateInArchiveItems(
+ // options.StoreAltStreams,
+ censor, arcLink.Arcs.Back(), arcItems))
+ }
+
+ /*
+ FStringVector processedFilePaths;
+ FStringVector *processedFilePaths_Ptr = NULL;
+ if (options.DeleteAfterCompressing)
+ processedFilePaths_Ptr = &processedFilePaths;
+ */
+
+ CByteBuffer processedItems;
+ if (options.DeleteAfterCompressing)
+ {
+ const unsigned num = dirItems.Items.Size();
+ processedItems.Alloc(num);
+ for (unsigned i = 0; i < num; i++)
+ processedItems[i] = 0;
+ }
+
+ CMultiOutStream_Bunch multiStreams;
+
+ /*
+ #ifndef Z7_NO_CRYPTO
+ if (arcLink.PasswordWasAsked)
+ {
+ // We set password, if open have requested password
+ RINOK(callback->SetPassword(arcLink.Password));
+ }
+ #endif
+ */
+
+ for (ci = 0; ci < options.Commands.Size(); ci++)
+ {
+ const CArc *arc = thereIsInArchive ? arcLink.GetArc() : NULL;
+ CUpdateArchiveCommand &command = options.Commands[ci];
+ UString name;
+ bool isUpdating;
+
+ if (options.StdOutMode)
+ {
+ name = "stdout";
+ isUpdating = thereIsInArchive;
+ }
+ else
+ {
+ name = command.ArchivePath.GetFinalPath();
+ isUpdating = (ci == 0 && options.UpdateArchiveItself && thereIsInArchive);
+ }
+
+ RINOK(callback->StartArchive(name, isUpdating))
+
+ CFinishArchiveStat st;
+
+ RINOK(Compress(options,
+ isUpdating,
+ codecs,
+ command.ActionSet,
+ arc,
+ command.ArchivePath,
+ arcItems,
+ options.DeleteAfterCompressing ? (Byte *)processedItems : NULL,
+
+ dirItems,
+ parentDirItem_Ptr,
+
+ tempFiles,
+ multiStreams,
+ errorInfo, callback, st))
+
+ RINOK(callback->FinishArchive(st))
+ }
+
+
+ if (thereIsInArchive)
+ {
+ RINOK(arcLink.Close())
+ arcLink.Release();
+ }
+
+ multiStreams.DisableDeletion();
+ RINOK(multiStreams.Destruct())
+
+ tempFiles.Paths.Clear();
+ if (createTempFile)
+ {
+ try
+ {
+ CArchivePath &ap = options.Commands[0].ArchivePath;
+ const FString &tempPath = ap.GetTempPath();
+
+ // DWORD attrib = 0;
+ if (thereIsInArchive)
+ {
+ // attrib = NFind::GetFileAttrib(us2fs(arcPath));
+ if (!DeleteFileAlways(us2fs(arcPath)))
+ return errorInfo.SetFromLastError("cannot delete the file", us2fs(arcPath));
+ }
+
+ if (!MyMoveFile(tempPath, us2fs(arcPath)))
+ {
+ errorInfo.SetFromLastError("cannot move the file", tempPath);
+ errorInfo.FileNames.Add(us2fs(arcPath));
+ return errorInfo.Get_HRESULT_Error();
+ }
+
+ /*
+ if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
+ {
+ DWORD attrib2 = NFind::GetFileAttrib(us2fs(arcPath));
+ if (attrib2 != INVALID_FILE_ATTRIBUTES)
+ NDir::SetFileAttrib(us2fs(arcPath), attrib2 | FILE_ATTRIBUTE_READONLY);
+ }
+ */
+ }
+ catch(...)
+ {
+ throw;
+ }
+ }
+
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+
+ if (options.EMailMode)
+ {
+ NDLL::CLibrary mapiLib;
+ if (!mapiLib.Load(FTEXT("Mapi32.dll")))
+ {
+ errorInfo.SetFromLastError("cannot load Mapi32.dll");
+ return errorInfo.Get_HRESULT_Error();
+ }
+
+ FStringVector fullPaths;
+ unsigned i;
+
+ for (i = 0; i < options.Commands.Size(); i++)
+ {
+ CArchivePath &ap = options.Commands[i].ArchivePath;
+ const FString finalPath = us2fs(ap.GetFinalPath());
+ FString arcPath2;
+ if (!MyGetFullPathName(finalPath, arcPath2))
+ return errorInfo.SetFromLastError("GetFullPathName error", finalPath);
+ fullPaths.Add(arcPath2);
+ }
+
+ /*
+ LPMAPISENDDOCUMENTS fnSend = (LPMAPISENDDOCUMENTS)mapiLib.GetProc("MAPISendDocuments");
+ if (fnSend == 0)
+ {
+ errorInfo.SetFromLastError)("7-Zip cannot find MAPISendDocuments function");
+ return errorInfo.Get_HRESULT_Error();
+ }
+ */
+ const
+ Z7_WIN_LPMAPISENDMAILW sendMailW = Z7_GET_PROC_ADDRESS(
+ Z7_WIN_LPMAPISENDMAILW, mapiLib.Get_HMODULE(),
+ "MAPISendMailW");
+ if (sendMailW)
+ {
+
+ CCurrentDirRestorer curDirRestorer;
+
+ UStringVector paths;
+ UStringVector names;
+
+ for (i = 0; i < fullPaths.Size(); i++)
+ {
+ const UString arcPath2 = fs2us(fullPaths[i]);
+ const UString fileName = ExtractFileNameFromPath(arcPath2);
+ paths.Add(arcPath2);
+ names.Add(fileName);
+ // Warning!!! MAPISendDocuments function changes Current directory
+ // fnSend(0, ";", (LPSTR)(LPCSTR)path, (LPSTR)(LPCSTR)name, 0);
+ }
+
+ CRecordVector<Z7_WIN_MapiFileDescW> files;
+ files.ClearAndSetSize(paths.Size());
+
+ for (i = 0; i < paths.Size(); i++)
+ {
+ Z7_WIN_MapiFileDescW &f = files[i];
+ memset(&f, 0, sizeof(f));
+ f.nPosition = 0xFFFFFFFF;
+ f.lpszPathName = paths[i].Ptr_non_const();
+ f.lpszFileName = names[i].Ptr_non_const();
+ }
+
+ {
+ Z7_WIN_MapiMessageW m;
+ memset(&m, 0, sizeof(m));
+ m.nFileCount = files.Size();
+ m.lpFiles = &files.Front();
+
+ const UString addr (options.EMailAddress);
+ Z7_WIN_MapiRecipDescW rec;
+ if (!addr.IsEmpty())
+ {
+ memset(&rec, 0, sizeof(rec));
+ rec.ulRecipClass = MAPI_TO;
+ rec.lpszAddress = addr.Ptr_non_const();
+ m.nRecipCount = 1;
+ m.lpRecips = &rec;
+ }
+
+ sendMailW((LHANDLE)0, 0, &m, MAPI_DIALOG, 0);
+ }
+ }
+ else
+ {
+ const
+ LPMAPISENDMAIL sendMail = Z7_GET_PROC_ADDRESS(
+ LPMAPISENDMAIL, mapiLib.Get_HMODULE(),
+ "MAPISendMail");
+ if (!sendMail)
+ {
+ errorInfo.SetFromLastError("7-Zip cannot find MAPISendMail function");
+ return errorInfo.Get_HRESULT_Error();
+ }
+
+ CCurrentDirRestorer curDirRestorer;
+
+ AStringVector paths;
+ AStringVector names;
+
+ for (i = 0; i < fullPaths.Size(); i++)
+ {
+ const UString arcPath2 = fs2us(fullPaths[i]);
+ const UString fileName = ExtractFileNameFromPath(arcPath2);
+ paths.Add(GetAnsiString(arcPath2));
+ names.Add(GetAnsiString(fileName));
+ // const AString path (GetAnsiString(arcPath2));
+ // const AString name (GetAnsiString(fileName));
+ // Warning!!! MAPISendDocuments function changes Current directory
+ // fnSend(0, ";", (LPSTR)(LPCSTR)path, (LPSTR)(LPCSTR)name, 0);
+ }
+
+ CRecordVector<MapiFileDesc> files;
+ files.ClearAndSetSize(paths.Size());
+
+ for (i = 0; i < paths.Size(); i++)
+ {
+ MapiFileDesc &f = files[i];
+ memset(&f, 0, sizeof(f));
+ f.nPosition = 0xFFFFFFFF;
+ f.lpszPathName = paths[i].Ptr_non_const();
+ f.lpszFileName = names[i].Ptr_non_const();
+ }
+
+ {
+ MapiMessage m;
+ memset(&m, 0, sizeof(m));
+ m.nFileCount = files.Size();
+ m.lpFiles = &files.Front();
+
+ const AString addr (GetAnsiString(options.EMailAddress));
+ MapiRecipDesc rec;
+ if (!addr.IsEmpty())
+ {
+ memset(&rec, 0, sizeof(rec));
+ rec.ulRecipClass = MAPI_TO;
+ rec.lpszAddress = addr.Ptr_non_const();
+ m.nRecipCount = 1;
+ m.lpRecips = &rec;
+ }
+
+ sendMail((LHANDLE)0, 0, &m, MAPI_DIALOG, 0);
+ }
+ }
+ }
+
+ #endif
+
+ if (options.DeleteAfterCompressing)
+ {
+ CRecordVector<CDirPathSortPair> pairs;
+ FStringVector foldersNames;
+
+ unsigned i;
+
+ for (i = 0; i < dirItems.Items.Size(); i++)
+ {
+ const CDirItem &dirItem = dirItems.Items[i];
+ const FString phyPath = dirItems.GetPhyPath(i);
+ if (dirItem.IsDir())
+ {
+ CDirPathSortPair pair;
+ pair.Index = i;
+ pair.SetNumSlashes(phyPath);
+ pairs.Add(pair);
+ }
+ else
+ {
+ // 21.04: we have set processedItems[*] before for all required items
+ if (processedItems[i] != 0
+ // || dirItem.Size == 0
+ // || dirItem.AreReparseData()
+ )
+ {
+ NFind::CFileInfo fileInfo;
+ /* if (!SymLinks), we follow link here, similar to (dirItem) filling */
+ if (fileInfo.Find(phyPath, !options.SymLinks.Val))
+ {
+ bool is_SameSize = false;
+ if (options.SymLinks.Val && dirItem.AreReparseData())
+ {
+ /* (dirItem.Size = dirItem.ReparseData.Size()) was set before.
+ So we don't compare sizes for that case here */
+ is_SameSize = fileInfo.IsOsSymLink();
+ }
+ else
+ is_SameSize = (fileInfo.Size == dirItem.Size);
+
+ if (is_SameSize
+ && Compare_FiTime(&fileInfo.MTime, &dirItem.MTime) == 0
+ && Compare_FiTime(&fileInfo.CTime, &dirItem.CTime) == 0)
+ {
+ RINOK(callback->DeletingAfterArchiving(phyPath, false))
+ DeleteFileAlways(phyPath);
+ }
+ }
+ }
+ else
+ {
+ // file was skipped by some reason. We can throw error for debug:
+ /*
+ errorInfo.SystemError = 0;
+ errorInfo.Message = "file was not processed";
+ errorInfo.FileNames.Add(phyPath);
+ return E_FAIL;
+ */
+ }
+ }
+ }
+
+ pairs.Sort2();
+
+ for (i = 0; i < pairs.Size(); i++)
+ {
+ const FString phyPath = dirItems.GetPhyPath(pairs[i].Index);
+ if (NFind::DoesDirExist(phyPath))
+ {
+ RINOK(callback->DeletingAfterArchiving(phyPath, true))
+ RemoveDir(phyPath);
+ }
+ }
+
+ RINOK(callback->FinishDeletingAfterArchiving())
+ }
+
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Common/Update.h b/CPP/7zip/UI/Common/Update.h
index 45b02d7..a9459ff 100644
--- a/CPP/7zip/UI/Common/Update.h
+++ b/CPP/7zip/UI/Common/Update.h
@@ -1,200 +1,218 @@
-// Update.h
-
-#ifndef __COMMON_UPDATE_H
-#define __COMMON_UPDATE_H
-
-#include "../../../Common/Wildcard.h"
-
-#include "ArchiveOpenCallback.h"
-#include "LoadCodecs.h"
-#include "OpenArchive.h"
-#include "Property.h"
-#include "UpdateAction.h"
-#include "UpdateCallback.h"
-
-#include "DirItem.h"
-
-enum EArcNameMode
-{
- k_ArcNameMode_Smart,
- k_ArcNameMode_Exact,
- k_ArcNameMode_Add,
-};
-
-struct CArchivePath
-{
- UString OriginalPath;
-
- UString Prefix; // path(folder) prefix including slash
- UString Name; // base name
- UString BaseExtension; // archive type extension or "exe" extension
- UString VolExtension; // archive type extension for volumes
-
- bool Temp;
- FString TempPrefix; // path(folder) for temp location
- FString TempPostfix;
-
- CArchivePath(): Temp(false) {};
-
- void ParseFromPath(const UString &path, EArcNameMode mode);
- UString GetPathWithoutExt() const { return Prefix + Name; }
- UString GetFinalPath() const;
- UString GetFinalVolPath() const;
- FString GetTempPath() const;
-};
-
-struct CUpdateArchiveCommand
-{
- UString UserArchivePath;
- CArchivePath ArchivePath;
- NUpdateArchive::CActionSet ActionSet;
-};
-
-struct CCompressionMethodMode
-{
- bool Type_Defined;
- COpenType Type;
- CObjectVector<CProperty> Properties;
-
- CCompressionMethodMode(): Type_Defined(false) {}
-};
-
-namespace NRecursedType { enum EEnum
-{
- kRecursed,
- kWildcardOnlyRecursed,
- kNonRecursed
-};}
-
-struct CRenamePair
-{
- UString OldName;
- UString NewName;
- bool WildcardParsing;
- NRecursedType::EEnum RecursedType;
-
- CRenamePair(): WildcardParsing(true), RecursedType(NRecursedType::kNonRecursed) {}
-
- bool Prepare();
- bool GetNewPath(bool isFolder, const UString &src, UString &dest) const;
-};
-
-struct CUpdateOptions
-{
- CCompressionMethodMode MethodMode;
-
- CObjectVector<CUpdateArchiveCommand> Commands;
- bool UpdateArchiveItself;
- CArchivePath ArchivePath;
- EArcNameMode ArcNameMode;
-
- bool SfxMode;
- FString SfxModule;
-
- bool OpenShareForWrite;
- bool StopAfterOpenError;
-
- bool StdInMode;
- UString StdInFileName;
- bool StdOutMode;
-
- bool EMailMode;
- bool EMailRemoveAfter;
- UString EMailAddress;
-
- FString WorkingDir;
- NWildcard::ECensorPathMode PathMode;
- UString AddPathPrefix;
-
- CBoolPair NtSecurity;
- CBoolPair AltStreams;
- CBoolPair HardLinks;
- CBoolPair SymLinks;
-
- bool DeleteAfterCompressing;
-
- bool SetArcMTime;
-
- CObjectVector<CRenamePair> RenamePairs;
-
- bool InitFormatIndex(const CCodecs *codecs, const CObjectVector<COpenType> &types, const UString &arcPath);
- bool SetArcPath(const CCodecs *codecs, const UString &arcPath);
-
- CUpdateOptions():
- UpdateArchiveItself(true),
- SfxMode(false),
- StdInMode(false),
- StdOutMode(false),
- EMailMode(false),
- EMailRemoveAfter(false),
- OpenShareForWrite(false),
- StopAfterOpenError(false),
- ArcNameMode(k_ArcNameMode_Smart),
- PathMode(NWildcard::k_RelatPath),
-
- DeleteAfterCompressing(false),
- SetArcMTime(false)
-
- {};
-
- void SetActionCommand_Add()
- {
- Commands.Clear();
- CUpdateArchiveCommand c;
- c.ActionSet = NUpdateArchive::k_ActionSet_Add;
- Commands.Add(c);
- }
-
- CRecordVector<UInt64> VolumesSizes;
-};
-
-struct CUpdateErrorInfo
-{
- DWORD SystemError;
- AString Message;
- FStringVector FileNames;
-
- bool ThereIsError() const { return SystemError != 0 || !Message.IsEmpty() || !FileNames.IsEmpty(); }
- HRESULT Get_HRESULT_Error() const { return SystemError == 0 ? E_FAIL : HRESULT_FROM_WIN32(SystemError); }
- void SetFromLastError(const char *message);
- HRESULT SetFromLastError(const char *message, const FString &fileName);
-
- CUpdateErrorInfo(): SystemError(0) {};
-};
-
-struct CFinishArchiveStat
-{
- UInt64 OutArcFileSize;
-
- CFinishArchiveStat(): OutArcFileSize(0) {}
-};
-
-#define INTERFACE_IUpdateCallbackUI2(x) \
- INTERFACE_IUpdateCallbackUI(x) \
- INTERFACE_IDirItemsCallback(x) \
- virtual HRESULT OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result) x; \
- virtual HRESULT StartScanning() x; \
- virtual HRESULT FinishScanning(const CDirItemsStat &st) x; \
- virtual HRESULT StartOpenArchive(const wchar_t *name) x; \
- virtual HRESULT StartArchive(const wchar_t *name, bool updating) x; \
- virtual HRESULT FinishArchive(const CFinishArchiveStat &st) x; \
- virtual HRESULT DeletingAfterArchiving(const FString &path, bool isDir) x; \
- virtual HRESULT FinishDeletingAfterArchiving() x; \
-
-struct IUpdateCallbackUI2: public IUpdateCallbackUI, public IDirItemsCallback
-{
- INTERFACE_IUpdateCallbackUI2(=0)
-};
-
-HRESULT UpdateArchive(
- CCodecs *codecs,
- const CObjectVector<COpenType> &types,
- const UString &cmdArcPath2,
- NWildcard::CCensor &censor,
- CUpdateOptions &options,
- CUpdateErrorInfo &errorInfo,
- IOpenCallbackUI *openCallback,
- IUpdateCallbackUI2 *callback,
- bool needSetPath);
-
-#endif
+// Update.h
+
+#ifndef ZIP7_INC_COMMON_UPDATE_H
+#define ZIP7_INC_COMMON_UPDATE_H
+
+#include "../../../Common/Wildcard.h"
+
+#include "ArchiveOpenCallback.h"
+#include "LoadCodecs.h"
+#include "OpenArchive.h"
+#include "Property.h"
+#include "UpdateAction.h"
+#include "UpdateCallback.h"
+
+#include "DirItem.h"
+
+enum EArcNameMode
+{
+ k_ArcNameMode_Smart,
+ k_ArcNameMode_Exact,
+ k_ArcNameMode_Add
+};
+
+struct CArchivePath
+{
+ UString OriginalPath;
+
+ UString Prefix; // path(folder) prefix including slash
+ UString Name; // base name
+ UString BaseExtension; // archive type extension or "exe" extension
+ UString VolExtension; // archive type extension for volumes
+
+ bool Temp;
+ FString TempPrefix; // path(folder) for temp location
+ FString TempPostfix;
+
+ CArchivePath(): Temp(false) {}
+
+ void ParseFromPath(const UString &path, EArcNameMode mode);
+ UString GetPathWithoutExt() const { return Prefix + Name; }
+ UString GetFinalPath() const;
+ UString GetFinalVolPath() const;
+ FString GetTempPath() const;
+};
+
+struct CUpdateArchiveCommand
+{
+ UString UserArchivePath;
+ CArchivePath ArchivePath;
+ NUpdateArchive::CActionSet ActionSet;
+};
+
+struct CCompressionMethodMode
+{
+ bool Type_Defined;
+ COpenType Type;
+ CObjectVector<CProperty> Properties;
+
+ CCompressionMethodMode(): Type_Defined(false) {}
+};
+
+namespace NRecursedType { enum EEnum
+{
+ kRecursed,
+ kWildcardOnlyRecursed,
+ kNonRecursed
+};}
+
+struct CRenamePair
+{
+ UString OldName;
+ UString NewName;
+ bool WildcardParsing;
+ NRecursedType::EEnum RecursedType;
+
+ CRenamePair(): WildcardParsing(true), RecursedType(NRecursedType::kNonRecursed) {}
+
+ bool Prepare();
+ bool GetNewPath(bool isFolder, const UString &src, UString &dest) const;
+};
+
+struct CUpdateOptions
+{
+ bool UpdateArchiveItself;
+ bool SfxMode;
+
+ bool PreserveATime;
+ bool OpenShareForWrite;
+ bool StopAfterOpenError;
+
+ bool StdInMode;
+ bool StdOutMode;
+
+ bool EMailMode;
+ bool EMailRemoveAfter;
+
+ bool DeleteAfterCompressing;
+ bool SetArcMTime;
+
+ CBoolPair NtSecurity;
+ CBoolPair AltStreams;
+ CBoolPair HardLinks;
+ CBoolPair SymLinks;
+
+ CBoolPair StoreOwnerId;
+ CBoolPair StoreOwnerName;
+
+ EArcNameMode ArcNameMode;
+ NWildcard::ECensorPathMode PathMode;
+
+ CCompressionMethodMode MethodMode;
+
+ CObjectVector<CUpdateArchiveCommand> Commands;
+ CArchivePath ArchivePath;
+
+ FString SfxModule;
+ UString StdInFileName;
+ UString EMailAddress;
+ FString WorkingDir;
+ // UString AddPathPrefix;
+
+ CObjectVector<CRenamePair> RenamePairs;
+ CRecordVector<UInt64> VolumesSizes;
+
+ bool InitFormatIndex(const CCodecs *codecs, const CObjectVector<COpenType> &types, const UString &arcPath);
+ bool SetArcPath(const CCodecs *codecs, const UString &arcPath);
+
+ CUpdateOptions():
+ UpdateArchiveItself(true),
+ SfxMode(false),
+
+ PreserveATime(false),
+ OpenShareForWrite(false),
+ StopAfterOpenError(false),
+
+ StdInMode(false),
+ StdOutMode(false),
+
+ EMailMode(false),
+ EMailRemoveAfter(false),
+
+ DeleteAfterCompressing(false),
+ SetArcMTime(false),
+
+ ArcNameMode(k_ArcNameMode_Smart),
+ PathMode(NWildcard::k_RelatPath)
+
+ {}
+
+ void SetActionCommand_Add()
+ {
+ Commands.Clear();
+ CUpdateArchiveCommand c;
+ c.ActionSet = NUpdateArchive::k_ActionSet_Add;
+ Commands.Add(c);
+ }
+};
+
+
+struct CUpdateErrorInfo
+{
+ DWORD SystemError; // it's DWORD (WRes) only;
+ AString Message;
+ FStringVector FileNames;
+
+ bool ThereIsError() const { return SystemError != 0 || !Message.IsEmpty() || !FileNames.IsEmpty(); }
+ HRESULT Get_HRESULT_Error() const { return SystemError == 0 ? E_FAIL : HRESULT_FROM_WIN32(SystemError); }
+ void SetFromLastError(const char *message);
+ HRESULT SetFromLastError(const char *message, const FString &fileName);
+ HRESULT SetFromError_DWORD(const char *message, const FString &fileName, DWORD error);
+
+ CUpdateErrorInfo(): SystemError(0) {}
+};
+
+struct CFinishArchiveStat
+{
+ UInt64 OutArcFileSize;
+ unsigned NumVolumes;
+ bool IsMultiVolMode;
+
+ CFinishArchiveStat(): OutArcFileSize(0), NumVolumes(0), IsMultiVolMode(false) {}
+};
+
+Z7_PURE_INTERFACES_BEGIN
+
+// INTERFACE_IUpdateCallbackUI(x)
+// INTERFACE_IDirItemsCallback(x)
+
+#define Z7_IFACEN_IUpdateCallbackUI2(x) \
+ virtual HRESULT OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result) x \
+ virtual HRESULT StartScanning() x \
+ virtual HRESULT FinishScanning(const CDirItemsStat &st) x \
+ virtual HRESULT StartOpenArchive(const wchar_t *name) x \
+ virtual HRESULT StartArchive(const wchar_t *name, bool updating) x \
+ virtual HRESULT FinishArchive(const CFinishArchiveStat &st) x \
+ virtual HRESULT DeletingAfterArchiving(const FString &path, bool isDir) x \
+ virtual HRESULT FinishDeletingAfterArchiving() x \
+
+DECLARE_INTERFACE(IUpdateCallbackUI2):
+ public IUpdateCallbackUI,
+ public IDirItemsCallback
+{
+ Z7_IFACE_PURE(IUpdateCallbackUI2)
+};
+Z7_PURE_INTERFACES_END
+
+HRESULT UpdateArchive(
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &types,
+ const UString &cmdArcPath2,
+ NWildcard::CCensor &censor,
+ CUpdateOptions &options,
+ CUpdateErrorInfo &errorInfo,
+ IOpenCallbackUI *openCallback,
+ IUpdateCallbackUI2 *callback,
+ bool needSetPath);
+
+#endif
diff --git a/CPP/7zip/UI/Common/UpdateAction.cpp b/CPP/7zip/UI/Common/UpdateAction.cpp
index ba138d2..a80db72 100644
--- a/CPP/7zip/UI/Common/UpdateAction.cpp
+++ b/CPP/7zip/UI/Common/UpdateAction.cpp
@@ -1,64 +1,64 @@
-// UpdateAction.cpp
-
-#include "StdAfx.h"
-
-#include "UpdateAction.h"
-
-namespace NUpdateArchive {
-
-const CActionSet k_ActionSet_Add =
-{{
- NPairAction::kCopy,
- NPairAction::kCopy,
- NPairAction::kCompress,
- NPairAction::kCompress,
- NPairAction::kCompress,
- NPairAction::kCompress,
- NPairAction::kCompress
-}};
-
-const CActionSet k_ActionSet_Update =
-{{
- NPairAction::kCopy,
- NPairAction::kCopy,
- NPairAction::kCompress,
- NPairAction::kCopy,
- NPairAction::kCompress,
- NPairAction::kCopy,
- NPairAction::kCompress
-}};
-
-const CActionSet k_ActionSet_Fresh =
-{{
- NPairAction::kCopy,
- NPairAction::kCopy,
- NPairAction::kIgnore,
- NPairAction::kCopy,
- NPairAction::kCompress,
- NPairAction::kCopy,
- NPairAction::kCompress
-}};
-
-const CActionSet k_ActionSet_Sync =
-{{
- NPairAction::kCopy,
- NPairAction::kIgnore,
- NPairAction::kCompress,
- NPairAction::kCopy,
- NPairAction::kCompress,
- NPairAction::kCopy,
- NPairAction::kCompress,
-}};
-
-const CActionSet k_ActionSet_Delete =
-{{
- NPairAction::kCopy,
- NPairAction::kIgnore,
- NPairAction::kIgnore,
- NPairAction::kIgnore,
- NPairAction::kIgnore,
- NPairAction::kIgnore,
- NPairAction::kIgnore
-}};
-
-}
+// UpdateAction.cpp
+
+#include "StdAfx.h"
+
+#include "UpdateAction.h"
+
+namespace NUpdateArchive {
+
+const CActionSet k_ActionSet_Add =
+{{
+ NPairAction::kCopy,
+ NPairAction::kCopy,
+ NPairAction::kCompress,
+ NPairAction::kCompress,
+ NPairAction::kCompress,
+ NPairAction::kCompress,
+ NPairAction::kCompress
+}};
+
+const CActionSet k_ActionSet_Update =
+{{
+ NPairAction::kCopy,
+ NPairAction::kCopy,
+ NPairAction::kCompress,
+ NPairAction::kCopy,
+ NPairAction::kCompress,
+ NPairAction::kCopy,
+ NPairAction::kCompress
+}};
+
+const CActionSet k_ActionSet_Fresh =
+{{
+ NPairAction::kCopy,
+ NPairAction::kCopy,
+ NPairAction::kIgnore,
+ NPairAction::kCopy,
+ NPairAction::kCompress,
+ NPairAction::kCopy,
+ NPairAction::kCompress
+}};
+
+const CActionSet k_ActionSet_Sync =
+{{
+ NPairAction::kCopy,
+ NPairAction::kIgnore,
+ NPairAction::kCompress,
+ NPairAction::kCopy,
+ NPairAction::kCompress,
+ NPairAction::kCopy,
+ NPairAction::kCompress,
+}};
+
+const CActionSet k_ActionSet_Delete =
+{{
+ NPairAction::kCopy,
+ NPairAction::kIgnore,
+ NPairAction::kIgnore,
+ NPairAction::kIgnore,
+ NPairAction::kIgnore,
+ NPairAction::kIgnore,
+ NPairAction::kIgnore
+}};
+
+}
diff --git a/CPP/7zip/UI/Common/UpdateAction.h b/CPP/7zip/UI/Common/UpdateAction.h
index 8d6002f..6a3565e 100644
--- a/CPP/7zip/UI/Common/UpdateAction.h
+++ b/CPP/7zip/UI/Common/UpdateAction.h
@@ -1,66 +1,66 @@
-// UpdateAction.h
-
-#ifndef __UPDATE_ACTION_H
-#define __UPDATE_ACTION_H
-
-namespace NUpdateArchive {
-
- namespace NPairState
- {
- const unsigned kNumValues = 7;
- enum EEnum
- {
- kNotMasked = 0,
- kOnlyInArchive,
- kOnlyOnDisk,
- kNewInArchive,
- kOldInArchive,
- kSameFiles,
- kUnknowNewerFiles
- };
- }
-
- namespace NPairAction
- {
- enum EEnum
- {
- kIgnore = 0,
- kCopy,
- kCompress,
- kCompressAsAnti
- };
- }
-
- struct CActionSet
- {
- NPairAction::EEnum StateActions[NPairState::kNumValues];
-
- bool IsEqualTo(const CActionSet &a) const
- {
- for (unsigned i = 0; i < NPairState::kNumValues; i++)
- if (StateActions[i] != a.StateActions[i])
- return false;
- return true;
- }
-
- bool NeedScanning() const
- {
- unsigned i;
- for (i = 0; i < NPairState::kNumValues; i++)
- if (StateActions[i] == NPairAction::kCompress)
- return true;
- for (i = 1; i < NPairState::kNumValues; i++)
- if (StateActions[i] != NPairAction::kIgnore)
- return true;
- return false;
- }
- };
-
- extern const CActionSet k_ActionSet_Add;
- extern const CActionSet k_ActionSet_Update;
- extern const CActionSet k_ActionSet_Fresh;
- extern const CActionSet k_ActionSet_Sync;
- extern const CActionSet k_ActionSet_Delete;
-}
-
-#endif
+// UpdateAction.h
+
+#ifndef ZIP7_INC_UPDATE_ACTION_H
+#define ZIP7_INC_UPDATE_ACTION_H
+
+namespace NUpdateArchive {
+
+ namespace NPairState
+ {
+ const unsigned kNumValues = 7;
+ enum EEnum
+ {
+ kNotMasked = 0,
+ kOnlyInArchive,
+ kOnlyOnDisk,
+ kNewInArchive,
+ kOldInArchive,
+ kSameFiles,
+ kUnknowNewerFiles
+ };
+ }
+
+ namespace NPairAction
+ {
+ enum EEnum
+ {
+ kIgnore = 0,
+ kCopy,
+ kCompress,
+ kCompressAsAnti
+ };
+ }
+
+ struct CActionSet
+ {
+ NPairAction::EEnum StateActions[NPairState::kNumValues];
+
+ bool IsEqualTo(const CActionSet &a) const
+ {
+ for (unsigned i = 0; i < NPairState::kNumValues; i++)
+ if (StateActions[i] != a.StateActions[i])
+ return false;
+ return true;
+ }
+
+ bool NeedScanning() const
+ {
+ unsigned i;
+ for (i = 0; i < NPairState::kNumValues; i++)
+ if (StateActions[i] == NPairAction::kCompress)
+ return true;
+ for (i = 1; i < NPairState::kNumValues; i++)
+ if (StateActions[i] != NPairAction::kIgnore)
+ return true;
+ return false;
+ }
+ };
+
+ extern const CActionSet k_ActionSet_Add;
+ extern const CActionSet k_ActionSet_Update;
+ extern const CActionSet k_ActionSet_Fresh;
+ extern const CActionSet k_ActionSet_Sync;
+ extern const CActionSet k_ActionSet_Delete;
+}
+
+#endif
diff --git a/CPP/7zip/UI/Common/UpdateCallback.cpp b/CPP/7zip/UI/Common/UpdateCallback.cpp
index 9c165fe..5e2860d 100644
--- a/CPP/7zip/UI/Common/UpdateCallback.cpp
+++ b/CPP/7zip/UI/Common/UpdateCallback.cpp
@@ -1,771 +1,1026 @@
-// UpdateCallback.cpp
-
-#include "StdAfx.h"
-
-#ifndef _7ZIP_ST
-#include "../../../Windows/Synchronization.h"
-#endif
-
-#include "../../../Common/ComTry.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/PropVariant.h"
-
-#include "../../Common/StreamObjects.h"
-
-#include "UpdateCallback.h"
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-#define _USE_SECURITY_CODE
-#include "../../../Windows/SecurityUtils.h"
-#endif
-
-using namespace NWindows;
-using namespace NFile;
-
-#ifndef _7ZIP_ST
-static NSynchronization::CCriticalSection g_CriticalSection;
-#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
-#else
-#define MT_LOCK
-#endif
-
-
-#ifdef _USE_SECURITY_CODE
-bool InitLocalPrivileges();
-#endif
-
-CArchiveUpdateCallback::CArchiveUpdateCallback():
- _hardIndex_From((UInt32)(Int32)-1),
-
- Callback(NULL),
-
- DirItems(NULL),
- ParentDirItem(NULL),
-
- Arc(NULL),
- ArcItems(NULL),
- UpdatePairs(NULL),
- NewNames(NULL),
- CommentIndex(-1),
- Comment(NULL),
-
- ShareForWrite(false),
- StopAfterOpenError(false),
- StdInMode(false),
-
- KeepOriginalItemNames(false),
- StoreNtSecurity(false),
- StoreHardLinks(false),
- StoreSymLinks(false),
-
- ProcessedItemsStatuses(NULL)
-{
- #ifdef _USE_SECURITY_CODE
- _saclEnabled = InitLocalPrivileges();
- #endif
-}
-
-
-STDMETHODIMP CArchiveUpdateCallback::SetTotal(UInt64 size)
-{
- COM_TRY_BEGIN
- return Callback->SetTotal(size);
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::SetCompleted(const UInt64 *completeValue)
-{
- COM_TRY_BEGIN
- return Callback->SetCompleted(completeValue);
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
- COM_TRY_BEGIN
- return Callback->SetRatioInfo(inSize, outSize);
- COM_TRY_END
-}
-
-
-/*
-static const CStatProp kProps[] =
-{
- { NULL, kpidPath, VT_BSTR},
- { NULL, kpidIsDir, VT_BOOL},
- { NULL, kpidSize, VT_UI8},
- { NULL, kpidCTime, VT_FILETIME},
- { NULL, kpidATime, VT_FILETIME},
- { NULL, kpidMTime, VT_FILETIME},
- { NULL, kpidAttrib, VT_UI4},
- { NULL, kpidIsAnti, VT_BOOL}
-};
-
-STDMETHODIMP CArchiveUpdateCallback::EnumProperties(IEnumSTATPROPSTG **)
-{
- return CStatPropEnumerator::CreateEnumerator(kProps, ARRAY_SIZE(kProps), enumerator);
-}
-*/
-
-STDMETHODIMP CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 index,
- Int32 *newData, Int32 *newProps, UInt32 *indexInArchive)
-{
- COM_TRY_BEGIN
- RINOK(Callback->CheckBreak());
- const CUpdatePair2 &up = (*UpdatePairs)[index];
- if (newData) *newData = BoolToInt(up.NewData);
- if (newProps) *newProps = BoolToInt(up.NewProps);
- if (indexInArchive)
- {
- *indexInArchive = (UInt32)(Int32)-1;
- if (up.ExistInArchive())
- *indexInArchive = (ArcItems == 0) ? up.ArcIndex : (*ArcItems)[up.ArcIndex].IndexInServer;
- }
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetRootProp(PROPID propID, PROPVARIANT *value)
-{
- NCOM::CPropVariant prop;
- switch (propID)
- {
- case kpidIsDir: prop = true; break;
- case kpidAttrib: if (ParentDirItem) prop = ParentDirItem->Attrib; break;
- case kpidCTime: if (ParentDirItem) prop = ParentDirItem->CTime; break;
- case kpidATime: if (ParentDirItem) prop = ParentDirItem->ATime; break;
- case kpidMTime: if (ParentDirItem) prop = ParentDirItem->MTime; break;
- }
- prop.Detach(value);
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetParent(UInt32 /* index */, UInt32 *parent, UInt32 *parentType)
-{
- *parentType = NParentType::kDir;
- *parent = (UInt32)(Int32)-1;
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetNumRawProps(UInt32 *numProps)
-{
- *numProps = 0;
- if (StoreNtSecurity)
- *numProps = 1;
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID)
-{
- *name = NULL;
- *propID = kpidNtSecure;
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetRootRawProp(PROPID
- #ifdef _USE_SECURITY_CODE
- propID
- #endif
- , const void **data, UInt32 *dataSize, UInt32 *propType)
-{
- *data = 0;
- *dataSize = 0;
- *propType = 0;
- if (!StoreNtSecurity)
- return S_OK;
- #ifdef _USE_SECURITY_CODE
- if (propID == kpidNtSecure)
- {
- if (StdInMode)
- return S_OK;
-
- if (ParentDirItem)
- {
- if (ParentDirItem->SecureIndex < 0)
- return S_OK;
- const CByteBuffer &buf = DirItems->SecureBlocks.Bufs[ParentDirItem->SecureIndex];
- *data = buf;
- *dataSize = (UInt32)buf.Size();
- *propType = NPropDataType::kRaw;
- return S_OK;
- }
-
- if (Arc && Arc->GetRootProps)
- return Arc->GetRootProps->GetRootRawProp(propID, data, dataSize, propType);
- }
- #endif
- return S_OK;
-}
-
-// #ifdef _USE_SECURITY_CODE
-// #endif
-
-STDMETHODIMP CArchiveUpdateCallback::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)
-{
- *data = 0;
- *dataSize = 0;
- *propType = 0;
-
- if (propID == kpidNtSecure ||
- propID == kpidNtReparse)
- {
- if (StdInMode)
- return S_OK;
-
- const CUpdatePair2 &up = (*UpdatePairs)[index];
- if (up.UseArcProps && up.ExistInArchive() && Arc->GetRawProps)
- return Arc->GetRawProps->GetRawProp(
- ArcItems ? (*ArcItems)[up.ArcIndex].IndexInServer : up.ArcIndex,
- propID, data, dataSize, propType);
- {
- /*
- if (!up.NewData)
- return E_FAIL;
- */
- if (up.IsAnti)
- return S_OK;
-
- #ifndef UNDER_CE
- const CDirItem &di = DirItems->Items[up.DirIndex];
- #endif
-
- #ifdef _USE_SECURITY_CODE
- if (propID == kpidNtSecure)
- {
- if (!StoreNtSecurity)
- return S_OK;
- if (di.SecureIndex < 0)
- return S_OK;
- const CByteBuffer &buf = DirItems->SecureBlocks.Bufs[di.SecureIndex];
- *data = buf;
- *dataSize = (UInt32)buf.Size();
- *propType = NPropDataType::kRaw;
- }
- else
- #endif
- {
- // propID == kpidNtReparse
- if (!StoreSymLinks)
- return S_OK;
- #ifndef UNDER_CE
- const CByteBuffer *buf = &di.ReparseData2;
- if (buf->Size() == 0)
- buf = &di.ReparseData;
- if (buf->Size() != 0)
- {
- *data = *buf;
- *dataSize = (UInt32)buf->Size();
- *propType = NPropDataType::kRaw;
- }
- #endif
- }
-
- return S_OK;
- }
- }
-
- return S_OK;
-}
-
-#ifndef UNDER_CE
-
-static UString GetRelativePath(const UString &to, const UString &from)
-{
- UStringVector partsTo, partsFrom;
- SplitPathToParts(to, partsTo);
- SplitPathToParts(from, partsFrom);
-
- unsigned i;
- for (i = 0;; i++)
- {
- if (i + 1 >= partsFrom.Size() ||
- i + 1 >= partsTo.Size())
- break;
- if (CompareFileNames(partsFrom[i], partsTo[i]) != 0)
- break;
- }
-
- if (i == 0)
- {
- #ifdef _WIN32
- if (NName::IsDrivePath(to) ||
- NName::IsDrivePath(from))
- return to;
- #endif
- }
-
- UString s;
- unsigned k;
-
- for (k = i + 1; k < partsFrom.Size(); k++)
- s += ".." STRING_PATH_SEPARATOR;
-
- for (k = i; k < partsTo.Size(); k++)
- {
- if (k != i)
- s.Add_PathSepar();
- s += partsTo[k];
- }
-
- return s;
-}
-
-#endif
-
-STDMETHODIMP CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
-{
- COM_TRY_BEGIN
- const CUpdatePair2 &up = (*UpdatePairs)[index];
- NCOM::CPropVariant prop;
-
- if (up.NewData)
- {
- /*
- if (propID == kpidIsHardLink)
- {
- prop = _isHardLink;
- prop.Detach(value);
- return S_OK;
- }
- */
- if (propID == kpidSymLink)
- {
- if (index == _hardIndex_From)
- {
- prop.Detach(value);
- return S_OK;
- }
- if (up.DirIndex >= 0)
- {
- #ifndef UNDER_CE
- const CDirItem &di = DirItems->Items[up.DirIndex];
- // if (di.IsDir())
- {
- CReparseAttr attr;
- DWORD errorCode = 0;
- if (attr.Parse(di.ReparseData, di.ReparseData.Size(), errorCode))
- {
- UString simpleName = attr.GetPath();
- if (attr.IsRelative())
- prop = simpleName;
- else
- {
- const FString phyPath = DirItems->GetPhyPath(up.DirIndex);
- FString fullPath;
- if (NDir::MyGetFullPathName(phyPath, fullPath))
- {
- prop = GetRelativePath(simpleName, fs2us(fullPath));
- }
- }
- prop.Detach(value);
- return S_OK;
- }
- }
- #endif
- }
- }
- else if (propID == kpidHardLink)
- {
- if (index == _hardIndex_From)
- {
- const CKeyKeyValPair &pair = _map[_hardIndex_To];
- const CUpdatePair2 &up2 = (*UpdatePairs)[pair.Value];
- prop = DirItems->GetLogPath(up2.DirIndex);
- prop.Detach(value);
- return S_OK;
- }
- if (up.DirIndex >= 0)
- {
- prop.Detach(value);
- return S_OK;
- }
- }
- }
-
- if (up.IsAnti
- && propID != kpidIsDir
- && propID != kpidPath
- && propID != kpidIsAltStream)
- {
- switch (propID)
- {
- case kpidSize: prop = (UInt64)0; break;
- case kpidIsAnti: prop = true; break;
- }
- }
- else if (propID == kpidPath && up.NewNameIndex >= 0)
- prop = (*NewNames)[up.NewNameIndex];
- else if (propID == kpidComment
- && CommentIndex >= 0
- && (unsigned)CommentIndex == index
- && Comment)
- prop = *Comment;
- else if (propID == kpidShortName && up.NewNameIndex >= 0 && up.IsMainRenameItem)
- {
- // we can generate new ShortName here;
- }
- else if ((up.UseArcProps || (KeepOriginalItemNames && (propID == kpidPath || propID == kpidIsAltStream)))
- && up.ExistInArchive() && Archive)
- return Archive->GetProperty(ArcItems ? (*ArcItems)[up.ArcIndex].IndexInServer : up.ArcIndex, propID, value);
- else if (up.ExistOnDisk())
- {
- const CDirItem &di = DirItems->Items[up.DirIndex];
- switch (propID)
- {
- case kpidPath: prop = DirItems->GetLogPath(up.DirIndex); break;
- case kpidIsDir: prop = di.IsDir(); break;
- case kpidSize: prop = di.IsDir() ? (UInt64)0 : di.Size; break;
- case kpidAttrib: prop = di.Attrib; break;
- case kpidCTime: prop = di.CTime; break;
- case kpidATime: prop = di.ATime; break;
- case kpidMTime: prop = di.MTime; break;
- case kpidIsAltStream: prop = di.IsAltStream; break;
- #if defined(_WIN32) && !defined(UNDER_CE)
- // case kpidShortName: prop = di.ShortName; break;
- #endif
- }
- }
- prop.Detach(value);
- return S_OK;
- COM_TRY_END
-}
-
-#ifndef _7ZIP_ST
-static NSynchronization::CCriticalSection CS;
-#endif
-
-STDMETHODIMP CArchiveUpdateCallback::GetStream2(UInt32 index, ISequentialInStream **inStream, UInt32 mode)
-{
- COM_TRY_BEGIN
- *inStream = NULL;
- const CUpdatePair2 &up = (*UpdatePairs)[index];
- if (!up.NewData)
- return E_FAIL;
-
- RINOK(Callback->CheckBreak());
- // RINOK(Callback->Finalize());
-
- bool isDir = IsDir(up);
-
- if (up.IsAnti)
- {
- UString name;
- if (up.ArcIndex >= 0)
- name = (*ArcItems)[up.ArcIndex].Name;
- else if (up.DirIndex >= 0)
- name = DirItems->GetLogPath(up.DirIndex);
- RINOK(Callback->GetStream(name, isDir, true, mode));
-
- /* 9.33: fixed. Handlers expect real stream object for files, even for anti-file.
- so we return empty stream */
-
- if (!isDir)
- {
- CBufInStream *inStreamSpec = new CBufInStream();
- CMyComPtr<ISequentialInStream> inStreamLoc = inStreamSpec;
- inStreamSpec->Init(NULL, 0);
- *inStream = inStreamLoc.Detach();
- }
- return S_OK;
- }
-
- RINOK(Callback->GetStream(DirItems->GetLogPath(up.DirIndex), isDir, false, mode));
-
- if (isDir)
- return S_OK;
-
- if (StdInMode)
- {
- if (mode != NUpdateNotifyOp::kAdd &&
- mode != NUpdateNotifyOp::kUpdate)
- return S_OK;
-
- CStdInFileStream *inStreamSpec = new CStdInFileStream;
- CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
- *inStream = inStreamLoc.Detach();
- }
- else
- {
- CInFileStream *inStreamSpec = new CInFileStream;
- CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
-
- inStreamSpec->SupportHardLinks = StoreHardLinks;
- inStreamSpec->Callback = this;
- inStreamSpec->CallbackRef = index;
-
- const FString path = DirItems->GetPhyPath(up.DirIndex);
- _openFiles_Indexes.Add(index);
- _openFiles_Paths.Add(path);
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (DirItems->Items[up.DirIndex].AreReparseData())
- {
- if (!inStreamSpec->File.OpenReparse(path))
- {
- return Callback->OpenFileError(path, ::GetLastError());
- }
- }
- else
- #endif
- if (!inStreamSpec->OpenShared(path, ShareForWrite))
- {
- DWORD error = ::GetLastError();
- HRESULT hres = Callback->OpenFileError(path, error);
- if (StopAfterOpenError)
- if (hres == S_OK || hres == S_FALSE)
- return HRESULT_FROM_WIN32(error);
- return hres;
- }
-
- if (StoreHardLinks)
- {
- CStreamFileProps props;
- if (inStreamSpec->GetProps2(&props) == S_OK)
- {
- if (props.NumLinks > 1)
- {
- CKeyKeyValPair pair;
- pair.Key1 = props.VolID;
- pair.Key2 = props.FileID_Low;
- pair.Value = index;
- unsigned numItems = _map.Size();
- unsigned pairIndex = _map.AddToUniqueSorted2(pair);
- if (numItems == _map.Size())
- {
- // const CKeyKeyValPair &pair2 = _map.Pairs[pairIndex];
- _hardIndex_From = index;
- _hardIndex_To = pairIndex;
- // we could return NULL as stream, but it's better to return real stream
- // return S_OK;
- }
- }
- }
- }
-
- if (ProcessedItemsStatuses)
- {
- #ifndef _7ZIP_ST
- NSynchronization::CCriticalSectionLock lock(CS);
- #endif
- ProcessedItemsStatuses[(unsigned)up.DirIndex] = 1;
- }
- *inStream = inStreamLoc.Detach();
- }
-
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::SetOperationResult(Int32 opRes)
-{
- COM_TRY_BEGIN
- return Callback->SetOperationResult(opRes);
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream)
-{
- COM_TRY_BEGIN
- return GetStream2(index, inStream,
- (*UpdatePairs)[index].ArcIndex < 0 ?
- NUpdateNotifyOp::kAdd :
- NUpdateNotifyOp::kUpdate);
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::ReportOperation(UInt32 indexType, UInt32 index, UInt32 op)
-{
- COM_TRY_BEGIN
-
- bool isDir = false;
-
- if (indexType == NArchive::NEventIndexType::kOutArcIndex)
- {
- UString name;
- if (index != (UInt32)(Int32)-1)
- {
- const CUpdatePair2 &up = (*UpdatePairs)[index];
- if (up.ExistOnDisk())
- {
- name = DirItems->GetLogPath(up.DirIndex);
- isDir = DirItems->Items[up.DirIndex].IsDir();
- }
- }
- return Callback->ReportUpdateOpeartion(op, name.IsEmpty() ? NULL : name.Ptr(), isDir);
- }
-
- wchar_t temp[16];
- UString s2;
- const wchar_t *s = NULL;
-
- if (indexType == NArchive::NEventIndexType::kInArcIndex)
- {
- if (index != (UInt32)(Int32)-1)
- {
- if (ArcItems)
- {
- const CArcItem &ai = (*ArcItems)[index];
- s = ai.Name;
- isDir = ai.IsDir;
- }
- else if (Arc)
- {
- RINOK(Arc->GetItemPath(index, s2));
- s = s2;
- RINOK(Archive_IsItem_Dir(Arc->Archive, index, isDir));
- }
- }
- }
- else if (indexType == NArchive::NEventIndexType::kBlockIndex)
- {
- temp[0] = '#';
- ConvertUInt32ToString(index, temp + 1);
- s = temp;
- }
-
- if (!s)
- s = L"";
-
- return Callback->ReportUpdateOpeartion(op, s, isDir);
-
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes)
-{
- COM_TRY_BEGIN
-
- bool isEncrypted = false;
- wchar_t temp[16];
- UString s2;
- const wchar_t *s = NULL;
-
- if (indexType == NArchive::NEventIndexType::kOutArcIndex)
- {
- /*
- UString name;
- if (index != (UInt32)(Int32)-1)
- {
- const CUpdatePair2 &up = (*UpdatePairs)[index];
- if (up.ExistOnDisk())
- {
- s2 = DirItems->GetLogPath(up.DirIndex);
- s = s2;
- }
- }
- */
- return E_FAIL;
- }
-
- if (indexType == NArchive::NEventIndexType::kInArcIndex)
- {
- if (index != (UInt32)(Int32)-1)
- {
- if (ArcItems)
- s = (*ArcItems)[index].Name;
- else if (Arc)
- {
- RINOK(Arc->GetItemPath(index, s2));
- s = s2;
- }
- if (Archive)
- {
- RINOK(Archive_GetItemBoolProp(Archive, index, kpidEncrypted, isEncrypted));
- }
- }
- }
- else if (indexType == NArchive::NEventIndexType::kBlockIndex)
- {
- temp[0] = '#';
- ConvertUInt32ToString(index, temp + 1);
- s = temp;
- }
-
- return Callback->ReportExtractResult(opRes, BoolToInt(isEncrypted), s);
-
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size)
-{
- if (VolumesSizes.Size() == 0)
- return S_FALSE;
- if (index >= (UInt32)VolumesSizes.Size())
- index = VolumesSizes.Size() - 1;
- *size = VolumesSizes[index];
- return S_OK;
-}
-
-STDMETHODIMP CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream)
-{
- COM_TRY_BEGIN
- char temp[16];
- ConvertUInt32ToString(index + 1, temp);
- FString res (temp);
- while (res.Len() < 2)
- res.InsertAtFront(FTEXT('0'));
- FString fileName = VolName;
- fileName += '.';
- fileName += res;
- fileName += VolExt;
- COutFileStream *streamSpec = new COutFileStream;
- CMyComPtr<ISequentialOutStream> streamLoc(streamSpec);
- if (!streamSpec->Create(fileName, false))
- return ::GetLastError();
- *volumeStream = streamLoc.Detach();
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
-{
- COM_TRY_BEGIN
- return Callback->CryptoGetTextPassword2(passwordIsDefined, password);
- COM_TRY_END
-}
-
-STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword(BSTR *password)
-{
- COM_TRY_BEGIN
- return Callback->CryptoGetTextPassword(password);
- COM_TRY_END
-}
-
-HRESULT CArchiveUpdateCallback::InFileStream_On_Error(UINT_PTR val, DWORD error)
-{
- if (error == ERROR_LOCK_VIOLATION)
- {
- MT_LOCK
- UInt32 index = (UInt32)val;
- FOR_VECTOR(i, _openFiles_Indexes)
- {
- if (_openFiles_Indexes[i] == index)
- {
- RINOK(Callback->ReadingFileError(_openFiles_Paths[i], error));
- break;
- }
- }
- }
- return HRESULT_FROM_WIN32(error);
-}
-
-void CArchiveUpdateCallback::InFileStream_On_Destroy(UINT_PTR val)
-{
- MT_LOCK
- UInt32 index = (UInt32)val;
- FOR_VECTOR(i, _openFiles_Indexes)
- {
- if (_openFiles_Indexes[i] == index)
- {
- _openFiles_Indexes.Delete(i);
- _openFiles_Paths.Delete(i);
- return;
- }
- }
- throw 20141125;
-}
+// UpdateCallback.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#ifndef _WIN32
+// #include <grp.h>
+// #include <pwd.h>
+/*
+inclusion of <sys/sysmacros.h> by <sys/types.h> is deprecated since glibc 2.25.
+Since glibc 2.3.3, macros have been aliases for three GNU-specific
+functions: gnu_dev_makedev(), gnu_dev_major(), and gnu_dev_minor()
+*/
+// for major()/minor():
+#include <sys/types.h>
+#if defined(__FreeBSD__) || defined(BSD) || defined(__APPLE__)
+#else
+#ifndef major
+#include <sys/sysmacros.h>
+#endif
+#endif
+
+#endif // _WIN32
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Common/StreamObjects.h"
+
+#include "UpdateCallback.h"
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+#define Z7_USE_SECURITY_CODE
+#include "../../../Windows/SecurityUtils.h"
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+
+#ifdef Z7_USE_SECURITY_CODE
+bool InitLocalPrivileges();
+#endif
+
+CArchiveUpdateCallback::CArchiveUpdateCallback():
+ PreserveATime(false),
+ ShareForWrite(false),
+ StopAfterOpenError(false),
+ StdInMode(false),
+
+ KeepOriginalItemNames(false),
+ StoreNtSecurity(false),
+ StoreHardLinks(false),
+ StoreSymLinks(false),
+
+ #ifndef _WIN32
+ StoreOwnerId(false),
+ StoreOwnerName(false),
+ #endif
+
+ /*
+ , Need_ArcMTime_Report(false),
+ , ArcMTime_WasReported(false),
+ */
+ Need_LatestMTime(false),
+ LatestMTime_Defined(false),
+
+ Callback(NULL),
+
+ DirItems(NULL),
+ ParentDirItem(NULL),
+
+ Arc(NULL),
+ ArcItems(NULL),
+ UpdatePairs(NULL),
+ NewNames(NULL),
+ Comment(NULL),
+ CommentIndex(-1),
+
+ ProcessedItemsStatuses(NULL),
+ _hardIndex_From((UInt32)(Int32)-1)
+{
+ #ifdef Z7_USE_SECURITY_CODE
+ _saclEnabled = InitLocalPrivileges();
+ #endif
+}
+
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetTotal(UInt64 size))
+{
+ COM_TRY_BEGIN
+ return Callback->SetTotal(size);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetCompleted(const UInt64 *completeValue))
+{
+ COM_TRY_BEGIN
+ return Callback->SetCompleted(completeValue);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ COM_TRY_BEGIN
+ return Callback->SetRatioInfo(inSize, outSize);
+ COM_TRY_END
+}
+
+
+/*
+static const CStatProp kProps[] =
+{
+ { NULL, kpidPath, VT_BSTR},
+ { NULL, kpidIsDir, VT_BOOL},
+ { NULL, kpidSize, VT_UI8},
+ { NULL, kpidCTime, VT_FILETIME},
+ { NULL, kpidATime, VT_FILETIME},
+ { NULL, kpidMTime, VT_FILETIME},
+ { NULL, kpidAttrib, VT_UI4},
+ { NULL, kpidIsAnti, VT_BOOL}
+};
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::EnumProperties(IEnumSTATPROPSTG **)
+{
+ return CStatPropEnumerator::CreateEnumerator(kProps, Z7_ARRAY_SIZE(kProps), enumerator);
+}
+*/
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 index,
+ Int32 *newData, Int32 *newProps, UInt32 *indexInArchive))
+{
+ COM_TRY_BEGIN
+ RINOK(Callback->CheckBreak())
+ const CUpdatePair2 &up = (*UpdatePairs)[index];
+ if (newData) *newData = BoolToInt(up.NewData);
+ if (newProps) *newProps = BoolToInt(up.NewProps);
+ if (indexInArchive)
+ {
+ *indexInArchive = (UInt32)(Int32)-1;
+ if (up.ExistInArchive())
+ *indexInArchive = ArcItems ? (*ArcItems)[(unsigned)up.ArcIndex].IndexInServer : (UInt32)(Int32)up.ArcIndex;
+ }
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetRootProp(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidIsDir: prop = true; break;
+ case kpidAttrib: if (ParentDirItem) prop = ParentDirItem->GetWinAttrib(); break;
+ case kpidCTime: if (ParentDirItem) PropVariant_SetFrom_FiTime(prop, ParentDirItem->CTime); break;
+ case kpidATime: if (ParentDirItem) PropVariant_SetFrom_FiTime(prop, ParentDirItem->ATime); break;
+ case kpidMTime: if (ParentDirItem) PropVariant_SetFrom_FiTime(prop, ParentDirItem->MTime); break;
+ case kpidArcFileName: if (!ArcFileName.IsEmpty()) prop = ArcFileName; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetParent(UInt32 /* index */, UInt32 *parent, UInt32 *parentType))
+{
+ *parentType = NParentType::kDir;
+ *parent = (UInt32)(Int32)-1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = 0;
+ if (StoreNtSecurity)
+ *numProps = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID))
+{
+ *name = NULL;
+ *propID = kpidNtSecure;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetRootRawProp(PROPID
+ propID
+ , const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ #ifndef Z7_USE_SECURITY_CODE
+ UNUSED_VAR(propID)
+ #endif
+
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+ if (!StoreNtSecurity)
+ return S_OK;
+ #ifdef Z7_USE_SECURITY_CODE
+ if (propID == kpidNtSecure)
+ {
+ if (StdInMode)
+ return S_OK;
+
+ if (ParentDirItem)
+ {
+ if (ParentDirItem->SecureIndex < 0)
+ return S_OK;
+ const CByteBuffer &buf = DirItems->SecureBlocks.Bufs[(unsigned)ParentDirItem->SecureIndex];
+ *data = buf;
+ *dataSize = (UInt32)buf.Size();
+ *propType = NPropDataType::kRaw;
+ return S_OK;
+ }
+
+ if (Arc && Arc->GetRootProps)
+ return Arc->GetRootProps->GetRootRawProp(propID, data, dataSize, propType);
+ }
+ #endif
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ if (propID == kpidNtSecure ||
+ propID == kpidNtReparse)
+ {
+ if (StdInMode)
+ return S_OK;
+
+ const CUpdatePair2 &up = (*UpdatePairs)[index];
+ if (up.UseArcProps && up.ExistInArchive() && Arc->GetRawProps)
+ return Arc->GetRawProps->GetRawProp(
+ ArcItems ? (*ArcItems)[(unsigned)up.ArcIndex].IndexInServer : (UInt32)(Int32)up.ArcIndex,
+ propID, data, dataSize, propType);
+ {
+ /*
+ if (!up.NewData)
+ return E_FAIL;
+ */
+ if (up.IsAnti)
+ return S_OK;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ const CDirItem &di = DirItems->Items[(unsigned)up.DirIndex];
+ #endif
+
+ #ifdef Z7_USE_SECURITY_CODE
+ if (propID == kpidNtSecure)
+ {
+ if (!StoreNtSecurity)
+ return S_OK;
+ if (di.SecureIndex < 0)
+ return S_OK;
+ const CByteBuffer &buf = DirItems->SecureBlocks.Bufs[(unsigned)di.SecureIndex];
+ *data = buf;
+ *dataSize = (UInt32)buf.Size();
+ *propType = NPropDataType::kRaw;
+ }
+ else
+ #endif
+ if (propID == kpidNtReparse)
+ {
+ if (!StoreSymLinks)
+ return S_OK;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // we use ReparseData2 instead of ReparseData for WIM format
+ const CByteBuffer *buf = &di.ReparseData2;
+ if (buf->Size() == 0)
+ buf = &di.ReparseData;
+ if (buf->Size() != 0)
+ {
+ *data = *buf;
+ *dataSize = (UInt32)buf->Size();
+ *propType = NPropDataType::kRaw;
+ }
+ #endif
+ }
+
+ return S_OK;
+ }
+ }
+
+ return S_OK;
+}
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+static UString GetRelativePath(const UString &to, const UString &from)
+{
+ UStringVector partsTo, partsFrom;
+ SplitPathToParts(to, partsTo);
+ SplitPathToParts(from, partsFrom);
+
+ unsigned i;
+ for (i = 0;; i++)
+ {
+ if (i + 1 >= partsFrom.Size() ||
+ i + 1 >= partsTo.Size())
+ break;
+ if (CompareFileNames(partsFrom[i], partsTo[i]) != 0)
+ break;
+ }
+
+ if (i == 0)
+ {
+ #ifdef _WIN32
+ if (NName::IsDrivePath(to) ||
+ NName::IsDrivePath(from))
+ return to;
+ #endif
+ }
+
+ UString s;
+ unsigned k;
+
+ for (k = i + 1; k < partsFrom.Size(); k++)
+ s += ".." STRING_PATH_SEPARATOR;
+
+ for (k = i; k < partsTo.Size(); k++)
+ {
+ if (k != i)
+ s.Add_PathSepar();
+ s += partsTo[k];
+ }
+
+ return s;
+}
+
+#endif
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ const CUpdatePair2 &up = (*UpdatePairs)[index];
+ NCOM::CPropVariant prop;
+
+ if (up.NewData)
+ {
+ /*
+ if (propID == kpidIsHardLink)
+ {
+ prop = _isHardLink;
+ prop.Detach(value);
+ return S_OK;
+ }
+ */
+ if (propID == kpidSymLink)
+ {
+ if (index == _hardIndex_From)
+ {
+ prop.Detach(value);
+ return S_OK;
+ }
+
+ #if !defined(UNDER_CE)
+
+ if (up.DirIndex >= 0)
+ {
+ const CDirItem &di = DirItems->Items[(unsigned)up.DirIndex];
+
+ #ifdef _WIN32
+ // if (di.IsDir())
+ {
+ CReparseAttr attr;
+ if (attr.Parse(di.ReparseData, di.ReparseData.Size()))
+ {
+ const UString simpleName = attr.GetPath();
+ if (!attr.IsSymLink_WSL() && attr.IsRelative_Win())
+ prop = simpleName;
+ else
+ {
+ const FString phyPath = DirItems->GetPhyPath((unsigned)up.DirIndex);
+ FString fullPath;
+ if (NDir::MyGetFullPathName(phyPath, fullPath))
+ {
+ prop = GetRelativePath(simpleName, fs2us(fullPath));
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ }
+ }
+
+ #else // _WIN32
+
+ if (di.ReparseData.Size() != 0)
+ {
+ AString utf;
+ utf.SetFrom_CalcLen((const char *)(const Byte *)di.ReparseData, (unsigned)di.ReparseData.Size());
+
+ UString us;
+ if (ConvertUTF8ToUnicode(utf, us))
+ {
+ prop = us;
+ prop.Detach(value);
+ return S_OK;
+ }
+ }
+
+ #endif // _WIN32
+ }
+ #endif // !defined(UNDER_CE)
+ }
+ else if (propID == kpidHardLink)
+ {
+ if (index == _hardIndex_From)
+ {
+ const CKeyKeyValPair &pair = _map[_hardIndex_To];
+ const CUpdatePair2 &up2 = (*UpdatePairs)[pair.Value];
+ prop = DirItems->GetLogPath((unsigned)up2.DirIndex);
+ prop.Detach(value);
+ return S_OK;
+ }
+ if (up.DirIndex >= 0)
+ {
+ prop.Detach(value);
+ return S_OK;
+ }
+ }
+ }
+
+ if (up.IsAnti
+ && propID != kpidIsDir
+ && propID != kpidPath
+ && propID != kpidIsAltStream)
+ {
+ switch (propID)
+ {
+ case kpidSize: prop = (UInt64)0; break;
+ case kpidIsAnti: prop = true; break;
+ }
+ }
+ else if (propID == kpidPath && up.NewNameIndex >= 0)
+ prop = (*NewNames)[(unsigned)up.NewNameIndex];
+ else if (propID == kpidComment
+ && CommentIndex >= 0
+ && (unsigned)CommentIndex == index
+ && Comment)
+ prop = *Comment;
+ else if (propID == kpidShortName && up.NewNameIndex >= 0 && up.IsMainRenameItem)
+ {
+ // we can generate new ShortName here;
+ }
+ else if ((up.UseArcProps || (KeepOriginalItemNames && (propID == kpidPath || propID == kpidIsAltStream)))
+ && up.ExistInArchive() && Archive)
+ return Archive->GetProperty(ArcItems ? (*ArcItems)[(unsigned)up.ArcIndex].IndexInServer : (UInt32)(Int32)up.ArcIndex, propID, value);
+ else if (up.ExistOnDisk())
+ {
+ const CDirItem &di = DirItems->Items[(unsigned)up.DirIndex];
+ switch (propID)
+ {
+ case kpidPath: prop = DirItems->GetLogPath((unsigned)up.DirIndex); break;
+ case kpidIsDir: prop = di.IsDir(); break;
+ case kpidSize: prop = (UInt64)(di.IsDir() ? (UInt64)0 : di.Size); break;
+ case kpidCTime: PropVariant_SetFrom_FiTime(prop, di.CTime); break;
+ case kpidATime: PropVariant_SetFrom_FiTime(prop, di.ATime); break;
+ case kpidMTime: PropVariant_SetFrom_FiTime(prop, di.MTime); break;
+ case kpidAttrib: prop = (UInt32)di.GetWinAttrib(); break;
+ case kpidPosixAttrib: prop = (UInt32)di.GetPosixAttrib(); break;
+
+ #if defined(_WIN32)
+ case kpidIsAltStream: prop = di.IsAltStream; break;
+ // case kpidShortName: prop = di.ShortName; break;
+ #else
+
+ #if defined(__APPLE__)
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wsign-conversion"
+ #endif
+
+ case kpidDeviceMajor:
+ /*
+ printf("\ndi.mode = %o\n", di.mode);
+ printf("\nst.st_rdev major = %d\n", (unsigned)major(di.rdev));
+ printf("\nst.st_rdev minor = %d\n", (unsigned)minor(di.rdev));
+ */
+ if (S_ISCHR(di.mode) || S_ISBLK(di.mode))
+ prop = (UInt32)major(di.rdev);
+ break;
+
+ case kpidDeviceMinor:
+ if (S_ISCHR(di.mode) || S_ISBLK(di.mode))
+ prop = (UInt32)minor(di.rdev);
+ break;
+
+ #if defined(__APPLE__)
+ #pragma GCC diagnostic pop
+ #endif
+
+ // case kpidDevice: if (S_ISCHR(di.mode) || S_ISBLK(di.mode)) prop = (UInt64)(di.rdev); break;
+
+ case kpidUserId: if (StoreOwnerId) prop = (UInt32)di.uid; break;
+ case kpidGroupId: if (StoreOwnerId) prop = (UInt32)di.gid; break;
+ case kpidUser:
+ if (di.OwnerNameIndex >= 0)
+ prop = DirItems->OwnerNameMap.Strings[(unsigned)di.OwnerNameIndex];
+ break;
+ case kpidGroup:
+ if (di.OwnerGroupIndex >= 0)
+ prop = DirItems->OwnerGroupMap.Strings[(unsigned)di.OwnerGroupIndex];
+ break;
+ #endif
+ }
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CS;
+#endif
+
+void CArchiveUpdateCallback::UpdateProcessedItemStatus(unsigned dirIndex)
+{
+ if (ProcessedItemsStatuses)
+ {
+ #ifndef Z7_ST
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ #endif
+ ProcessedItemsStatuses[dirIndex] = 1;
+ }
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetStream2(UInt32 index, ISequentialInStream **inStream, UInt32 mode))
+{
+ COM_TRY_BEGIN
+ *inStream = NULL;
+ const CUpdatePair2 &up = (*UpdatePairs)[index];
+ if (!up.NewData)
+ return E_FAIL;
+
+ RINOK(Callback->CheckBreak())
+ // RINOK(Callback->Finalize());
+
+ bool isDir = IsDir(up);
+
+ if (up.IsAnti)
+ {
+ UString name;
+ if (up.ArcIndex >= 0)
+ name = (*ArcItems)[(unsigned)up.ArcIndex].Name;
+ else if (up.DirIndex >= 0)
+ name = DirItems->GetLogPath((unsigned)up.DirIndex);
+ RINOK(Callback->GetStream(name, isDir, true, mode))
+
+ /* 9.33: fixed. Handlers expect real stream object for files, even for anti-file.
+ so we return empty stream */
+
+ if (!isDir)
+ {
+ CBufInStream *inStreamSpec = new CBufInStream();
+ CMyComPtr<ISequentialInStream> inStreamLoc = inStreamSpec;
+ inStreamSpec->Init(NULL, 0);
+ *inStream = inStreamLoc.Detach();
+ }
+ return S_OK;
+ }
+
+ RINOK(Callback->GetStream(DirItems->GetLogPath((unsigned)up.DirIndex), isDir, false, mode))
+
+ if (isDir)
+ return S_OK;
+
+ if (StdInMode)
+ {
+ if (mode != NUpdateNotifyOp::kAdd &&
+ mode != NUpdateNotifyOp::kUpdate)
+ return S_OK;
+
+ CStdInFileStream *inStreamSpec = new CStdInFileStream;
+ CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
+ *inStream = inStreamLoc.Detach();
+ }
+ else
+ {
+ #if !defined(UNDER_CE)
+ const CDirItem &di = DirItems->Items[(unsigned)up.DirIndex];
+ if (di.AreReparseData())
+ {
+ /*
+ // we still need DeviceIoControlOut() instead of Read
+ if (!inStreamSpec->File.OpenReparse(path))
+ {
+ return Callback->OpenFileError(path, ::GetLastError());
+ }
+ */
+ // 20.03: we use Reparse Data instead of real data
+
+ CBufInStream *inStreamSpec = new CBufInStream();
+ CMyComPtr<ISequentialInStream> inStreamLoc = inStreamSpec;
+ inStreamSpec->Init(di.ReparseData, di.ReparseData.Size());
+ *inStream = inStreamLoc.Detach();
+
+ UpdateProcessedItemStatus((unsigned)up.DirIndex);
+ return S_OK;
+ }
+ #endif // !defined(UNDER_CE)
+
+ CInFileStream *inStreamSpec = new CInFileStream;
+ CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
+
+ /*
+ // for debug:
+ #ifdef _WIN32
+ inStreamSpec->StoreOwnerName = true;
+ inStreamSpec->OwnerName = "user_name";
+ inStreamSpec->OwnerName += di.Name;
+ inStreamSpec->OwnerName += "11111111112222222222222333333333333";
+ inStreamSpec->OwnerGroup = "gname_";
+ inStreamSpec->OwnerGroup += inStreamSpec->OwnerName;
+ #endif
+ */
+
+ #ifndef _WIN32
+ inStreamSpec->StoreOwnerId = StoreOwnerId;
+ inStreamSpec->StoreOwnerName = StoreOwnerName;
+
+ // if (StoreOwner)
+ {
+ inStreamSpec->_uid = di.uid;
+ inStreamSpec->_gid = di.gid;
+ if (di.OwnerNameIndex >= 0)
+ inStreamSpec->OwnerName = DirItems->OwnerNameMap.Strings[(unsigned)di.OwnerNameIndex];
+ if (di.OwnerGroupIndex >= 0)
+ inStreamSpec->OwnerGroup = DirItems->OwnerGroupMap.Strings[(unsigned)di.OwnerGroupIndex];
+ }
+ #endif
+
+ inStreamSpec->SupportHardLinks = StoreHardLinks;
+ const bool preserveATime = (PreserveATime
+ || mode == NUpdateNotifyOp::kAnalyze); // 22.00 : we don't change access time in Analyze pass.
+ inStreamSpec->Set_PreserveATime(preserveATime);
+
+ const FString path = DirItems->GetPhyPath((unsigned)up.DirIndex);
+ _openFiles_Indexes.Add(index);
+ _openFiles_Paths.Add(path);
+ // _openFiles_Streams.Add(inStreamSpec);
+
+ /* 21.02 : we set Callback/CallbackRef after _openFiles_Indexes adding
+ for correct working if exception was raised in GetPhyPath */
+ inStreamSpec->Callback = this;
+ inStreamSpec->CallbackRef = index;
+
+ if (!inStreamSpec->OpenShared(path, ShareForWrite))
+ {
+ bool isOpen = false;
+ if (preserveATime)
+ {
+ inStreamSpec->Set_PreserveATime(false);
+ isOpen = inStreamSpec->OpenShared(path, ShareForWrite);
+ }
+ if (!isOpen)
+ {
+ const DWORD error = ::GetLastError();
+ const HRESULT hres = Callback->OpenFileError(path, error);
+ if (hres == S_OK || hres == S_FALSE)
+ if (StopAfterOpenError ||
+ // v23: we check also for some critical errors:
+ #ifdef _WIN32
+ error == ERROR_NO_SYSTEM_RESOURCES
+ #else
+ error == EMFILE
+ #endif
+ )
+ {
+ if (error == 0)
+ return E_FAIL;
+ return HRESULT_FROM_WIN32(error);
+ }
+ return hres;
+ }
+ }
+
+ /*
+ {
+ // for debug:
+ Byte b = 0;
+ UInt32 processedSize = 0;
+ if (inStreamSpec->Read(&b, 1, &processedSize) != S_OK ||
+ processedSize != 1)
+ return E_FAIL;
+ }
+ */
+
+ if (Need_LatestMTime)
+ {
+ inStreamSpec->ReloadProps();
+ }
+
+ // #if defined(Z7_FILE_STREAMS_USE_WIN_FILE) || !defined(_WIN32)
+ if (StoreHardLinks)
+ {
+ CStreamFileProps props;
+ if (inStreamSpec->GetProps2(&props) == S_OK)
+ {
+ if (props.NumLinks > 1)
+ {
+ CKeyKeyValPair pair;
+ pair.Key1 = props.VolID;
+ pair.Key2 = props.FileID_Low;
+ pair.Value = index;
+ const unsigned numItems = _map.Size();
+ const unsigned pairIndex = _map.AddToUniqueSorted2(pair);
+ if (numItems == _map.Size())
+ {
+ // const CKeyKeyValPair &pair2 = _map.Pairs[pairIndex];
+ _hardIndex_From = index;
+ _hardIndex_To = pairIndex;
+ // we could return NULL as stream, but it's better to return real stream
+ // return S_OK;
+ }
+ }
+ }
+ }
+ // #endif
+
+ UpdateProcessedItemStatus((unsigned)up.DirIndex);
+ *inStream = inStreamLoc.Detach();
+ }
+
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::SetOperationResult(Int32 opRes))
+{
+ COM_TRY_BEGIN
+ return Callback->SetOperationResult(opRes);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream))
+{
+ COM_TRY_BEGIN
+ return GetStream2(index, inStream,
+ (*UpdatePairs)[index].ArcIndex < 0 ?
+ NUpdateNotifyOp::kAdd :
+ NUpdateNotifyOp::kUpdate);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::ReportOperation(UInt32 indexType, UInt32 index, UInt32 op))
+{
+ COM_TRY_BEGIN
+
+ // if (op == NUpdateNotifyOp::kOpFinished) return Callback->ReportFinished(indexType, index);
+
+ bool isDir = false;
+
+ if (indexType == NArchive::NEventIndexType::kOutArcIndex)
+ {
+ UString name;
+ if (index != (UInt32)(Int32)-1)
+ {
+ const CUpdatePair2 &up = (*UpdatePairs)[index];
+ if (up.ExistOnDisk())
+ {
+ name = DirItems->GetLogPath((unsigned)up.DirIndex);
+ isDir = DirItems->Items[(unsigned)up.DirIndex].IsDir();
+ }
+ }
+ return Callback->ReportUpdateOperation(op, name.IsEmpty() ? NULL : name.Ptr(), isDir);
+ }
+
+ wchar_t temp[16];
+ UString s2;
+ const wchar_t *s = NULL;
+
+ if (indexType == NArchive::NEventIndexType::kInArcIndex)
+ {
+ if (index != (UInt32)(Int32)-1)
+ {
+ if (ArcItems)
+ {
+ const CArcItem &ai = (*ArcItems)[index];
+ s = ai.Name;
+ isDir = ai.IsDir;
+ }
+ else if (Arc)
+ {
+ RINOK(Arc->GetItem_Path(index, s2))
+ s = s2;
+ RINOK(Archive_IsItem_Dir(Arc->Archive, index, isDir))
+ }
+ }
+ }
+ else if (indexType == NArchive::NEventIndexType::kBlockIndex)
+ {
+ temp[0] = '#';
+ ConvertUInt32ToString(index, temp + 1);
+ s = temp;
+ }
+
+ if (!s)
+ s = L"";
+
+ return Callback->ReportUpdateOperation(op, s, isDir);
+
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes))
+{
+ COM_TRY_BEGIN
+
+ bool isEncrypted = false;
+ wchar_t temp[16];
+ UString s2;
+ const wchar_t *s = NULL;
+
+ if (indexType == NArchive::NEventIndexType::kOutArcIndex)
+ {
+ /*
+ UString name;
+ if (index != (UInt32)(Int32)-1)
+ {
+ const CUpdatePair2 &up = (*UpdatePairs)[index];
+ if (up.ExistOnDisk())
+ {
+ s2 = DirItems->GetLogPath(up.DirIndex);
+ s = s2;
+ }
+ }
+ */
+ return E_FAIL;
+ }
+
+ if (indexType == NArchive::NEventIndexType::kInArcIndex)
+ {
+ if (index != (UInt32)(Int32)-1)
+ {
+ if (ArcItems)
+ s = (*ArcItems)[index].Name;
+ else if (Arc)
+ {
+ RINOK(Arc->GetItem_Path(index, s2))
+ s = s2;
+ }
+ if (Archive)
+ {
+ RINOK(Archive_GetItemBoolProp(Archive, index, kpidEncrypted, isEncrypted))
+ }
+ }
+ }
+ else if (indexType == NArchive::NEventIndexType::kBlockIndex)
+ {
+ temp[0] = '#';
+ ConvertUInt32ToString(index, temp + 1);
+ s = temp;
+ }
+
+ return Callback->ReportExtractResult(opRes, BoolToInt(isEncrypted), s);
+
+ COM_TRY_END
+}
+
+
+/*
+Z7_COM7F_IMF(CArchiveUpdateCallback::DoNeedArcProp(PROPID propID, Int32 *answer))
+{
+ *answer = 0;
+ if (Need_ArcMTime_Report && propID == kpidComboMTime)
+ *answer = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::ReportProp(UInt32 indexType, UInt32 index, PROPID propID, const PROPVARIANT *value))
+{
+ if (indexType == NArchive::NEventIndexType::kArcProp)
+ {
+ if (propID == kpidComboMTime)
+ {
+ ArcMTime_WasReported = true;
+ if (value->vt == VT_FILETIME)
+ {
+ Reported_ArcMTime.Set_From_Prop(*value);
+ Reported_ArcMTime.Def = true;
+ }
+ else
+ {
+ Reported_ArcMTime.Clear();
+ if (value->vt != VT_EMPTY)
+ return E_FAIL; // for debug
+ }
+ }
+ }
+ return Callback->ReportProp(indexType, index, propID, value);
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::ReportRawProp(UInt32 indexType, UInt32 index,
+ PROPID propID, const void *data, UInt32 dataSize, UInt32 propType))
+{
+ return Callback->ReportRawProp(indexType, index, propID, data, dataSize, propType);
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::ReportFinished(UInt32 indexType, UInt32 index, Int32 opRes))
+{
+ return Callback->ReportFinished(indexType, index, opRes);
+}
+*/
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size))
+{
+ if (VolumesSizes.Size() == 0)
+ return S_FALSE;
+ if (index >= (UInt32)VolumesSizes.Size())
+ index = VolumesSizes.Size() - 1;
+ *size = VolumesSizes[index];
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream))
+{
+ COM_TRY_BEGIN
+ char temp[16];
+ ConvertUInt32ToString(index + 1, temp);
+ FString res (temp);
+ while (res.Len() < 2)
+ res.InsertAtFront(FTEXT('0'));
+ FString fileName = VolName;
+ fileName.Add_Dot();
+ fileName += res;
+ fileName += VolExt;
+ COutFileStream *streamSpec = new COutFileStream;
+ CMyComPtr<ISequentialOutStream> streamLoc(streamSpec);
+ if (!streamSpec->Create(fileName, false))
+ return GetLastError_noZero_HRESULT();
+ *volumeStream = streamLoc.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+{
+ COM_TRY_BEGIN
+ return Callback->CryptoGetTextPassword2(passwordIsDefined, password);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CArchiveUpdateCallback::CryptoGetTextPassword(BSTR *password))
+{
+ COM_TRY_BEGIN
+ return Callback->CryptoGetTextPassword(password);
+ COM_TRY_END
+}
+
+HRESULT CArchiveUpdateCallback::InFileStream_On_Error(UINT_PTR val, DWORD error)
+{
+ #ifdef _WIN32 // FIX IT !!!
+ // why did we check only for ERROR_LOCK_VIOLATION ?
+ // if (error == ERROR_LOCK_VIOLATION)
+ #endif
+ {
+ MT_LOCK
+ const UInt32 index = (UInt32)val;
+ FOR_VECTOR(i, _openFiles_Indexes)
+ {
+ if (_openFiles_Indexes[i] == index)
+ {
+ RINOK(Callback->ReadingFileError(_openFiles_Paths[i], error))
+ break;
+ }
+ }
+ }
+ return HRESULT_FROM_WIN32(error);
+}
+
+void CArchiveUpdateCallback::InFileStream_On_Destroy(CInFileStream *stream, UINT_PTR val)
+{
+ MT_LOCK
+ if (Need_LatestMTime)
+ {
+ if (stream->_info_WasLoaded)
+ {
+ const CFiTime &ft = ST_MTIME(stream->_info);
+ if (!LatestMTime_Defined
+ || Compare_FiTime(&LatestMTime, &ft) < 0)
+ LatestMTime = ft;
+ LatestMTime_Defined = true;
+ }
+ }
+ const UInt32 index = (UInt32)val;
+ FOR_VECTOR(i, _openFiles_Indexes)
+ {
+ if (_openFiles_Indexes[i] == index)
+ {
+ _openFiles_Indexes.Delete(i);
+ _openFiles_Paths.Delete(i);
+ // _openFiles_Streams.Delete(i);
+ return;
+ }
+ }
+ /* 21.02 : this function can be called in destructor.
+ And destructor can be called after some exception.
+ If we don't want to throw exception in desctructors or after another exceptions,
+ we must disable the code below that raises new exception.
+ */
+ // throw 20141125;
+}
diff --git a/CPP/7zip/UI/Common/UpdateCallback.h b/CPP/7zip/UI/Common/UpdateCallback.h
index 1b5d1ee..379b814 100644
--- a/CPP/7zip/UI/Common/UpdateCallback.h
+++ b/CPP/7zip/UI/Common/UpdateCallback.h
@@ -1,162 +1,197 @@
-// UpdateCallback.h
-
-#ifndef __UPDATE_CALLBACK_H
-#define __UPDATE_CALLBACK_H
-
-#include "../../../Common/MyCom.h"
-
-#include "../../Common/FileStreams.h"
-
-#include "../../IPassword.h"
-#include "../../ICoder.h"
-
-#include "../Common/UpdatePair.h"
-#include "../Common/UpdateProduce.h"
-
-#include "OpenArchive.h"
-
-struct CArcToDoStat
-{
- CDirItemsStat2 NewData;
- CDirItemsStat2 OldData;
- CDirItemsStat2 DeleteData;
-
- UInt64 Get_NumDataItems_Total() const
- {
- return NewData.Get_NumDataItems2() + OldData.Get_NumDataItems2();
- }
-};
-
-#define INTERFACE_IUpdateCallbackUI(x) \
- virtual HRESULT WriteSfx(const wchar_t *name, UInt64 size) x; \
- virtual HRESULT SetTotal(UInt64 size) x; \
- virtual HRESULT SetCompleted(const UInt64 *completeValue) x; \
- virtual HRESULT SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize) x; \
- virtual HRESULT CheckBreak() x; \
- /* virtual HRESULT Finalize() x; */ \
- virtual HRESULT SetNumItems(const CArcToDoStat &stat) x; \
- virtual HRESULT GetStream(const wchar_t *name, bool isDir, bool isAnti, UInt32 mode) x; \
- virtual HRESULT OpenFileError(const FString &path, DWORD systemError) x; \
- virtual HRESULT ReadingFileError(const FString &path, DWORD systemError) x; \
- virtual HRESULT SetOperationResult(Int32 opRes) x; \
- virtual HRESULT ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name) x; \
- virtual HRESULT ReportUpdateOpeartion(UInt32 op, const wchar_t *name, bool isDir) x; \
- /* virtual HRESULT SetPassword(const UString &password) x; */ \
- virtual HRESULT CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password) x; \
- virtual HRESULT CryptoGetTextPassword(BSTR *password) x; \
- virtual HRESULT ShowDeleteFile(const wchar_t *name, bool isDir) x; \
- /* virtual HRESULT CloseProgress() { return S_OK; } */
-
-struct IUpdateCallbackUI
-{
- INTERFACE_IUpdateCallbackUI(=0)
-};
-
-struct CKeyKeyValPair
-{
- UInt64 Key1;
- UInt64 Key2;
- unsigned Value;
-
- int Compare(const CKeyKeyValPair &a) const
- {
- if (Key1 < a.Key1) return -1;
- if (Key1 > a.Key1) return 1;
- return MyCompare(Key2, a.Key2);
- }
-};
-
-
-class CArchiveUpdateCallback:
- public IArchiveUpdateCallback2,
- public IArchiveUpdateCallbackFile,
- public IArchiveExtractCallbackMessage,
- public IArchiveGetRawProps,
- public IArchiveGetRootProps,
- public ICryptoGetTextPassword2,
- public ICryptoGetTextPassword,
- public ICompressProgressInfo,
- public IInFileStream_Callback,
- public CMyUnknownImp
-{
- #if defined(_WIN32) && !defined(UNDER_CE)
- bool _saclEnabled;
- #endif
- CRecordVector<CKeyKeyValPair> _map;
-
- UInt32 _hardIndex_From;
- UInt32 _hardIndex_To;
-
-public:
- MY_QUERYINTERFACE_BEGIN2(IArchiveUpdateCallback2)
- MY_QUERYINTERFACE_ENTRY(IArchiveUpdateCallbackFile)
- MY_QUERYINTERFACE_ENTRY(IArchiveExtractCallbackMessage)
- MY_QUERYINTERFACE_ENTRY(IArchiveGetRawProps)
- MY_QUERYINTERFACE_ENTRY(IArchiveGetRootProps)
- MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword2)
- MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
- MY_QUERYINTERFACE_ENTRY(ICompressProgressInfo)
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
-
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-
- INTERFACE_IArchiveUpdateCallback2(;)
- INTERFACE_IArchiveUpdateCallbackFile(;)
- INTERFACE_IArchiveExtractCallbackMessage(;)
- INTERFACE_IArchiveGetRawProps(;)
- INTERFACE_IArchiveGetRootProps(;)
-
- STDMETHOD(CryptoGetTextPassword2)(Int32 *passwordIsDefined, BSTR *password);
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
-
- CRecordVector<UInt32> _openFiles_Indexes;
- FStringVector _openFiles_Paths;
-
- bool AreAllFilesClosed() const { return _openFiles_Indexes.IsEmpty(); }
- virtual HRESULT InFileStream_On_Error(UINT_PTR val, DWORD error);
- virtual void InFileStream_On_Destroy(UINT_PTR val);
-
- CRecordVector<UInt64> VolumesSizes;
- FString VolName;
- FString VolExt;
-
- IUpdateCallbackUI *Callback;
-
- const CDirItems *DirItems;
- const CDirItem *ParentDirItem;
-
- const CArc *Arc;
- CMyComPtr<IInArchive> Archive;
- const CObjectVector<CArcItem> *ArcItems;
- const CRecordVector<CUpdatePair2> *UpdatePairs;
- const UStringVector *NewNames;
- int CommentIndex;
- const UString *Comment;
-
- bool ShareForWrite;
- bool StopAfterOpenError;
- bool StdInMode;
-
- bool KeepOriginalItemNames;
- bool StoreNtSecurity;
- bool StoreHardLinks;
- bool StoreSymLinks;
-
- Byte *ProcessedItemsStatuses;
-
-
- CArchiveUpdateCallback();
-
- bool IsDir(const CUpdatePair2 &up) const
- {
- if (up.DirIndex >= 0)
- return DirItems->Items[up.DirIndex].IsDir();
- else if (up.ArcIndex >= 0)
- return (*ArcItems)[up.ArcIndex].IsDir;
- return false;
- }
-};
-
-#endif
+// UpdateCallback.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK_H
+#define ZIP7_INC_UPDATE_CALLBACK_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "../../IPassword.h"
+#include "../../ICoder.h"
+
+#include "../Common/UpdatePair.h"
+#include "../Common/UpdateProduce.h"
+
+#include "OpenArchive.h"
+
+struct CArcToDoStat
+{
+ CDirItemsStat2 NewData;
+ CDirItemsStat2 OldData;
+ CDirItemsStat2 DeleteData;
+
+ UInt64 Get_NumDataItems_Total() const
+ {
+ return NewData.Get_NumDataItems2() + OldData.Get_NumDataItems2();
+ }
+};
+
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACEN_IUpdateCallbackUI(x) \
+ virtual HRESULT WriteSfx(const wchar_t *name, UInt64 size) x \
+ virtual HRESULT SetTotal(UInt64 size) x \
+ virtual HRESULT SetCompleted(const UInt64 *completeValue) x \
+ virtual HRESULT SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize) x \
+ virtual HRESULT CheckBreak() x \
+ /* virtual HRESULT Finalize() x */ \
+ virtual HRESULT SetNumItems(const CArcToDoStat &stat) x \
+ virtual HRESULT GetStream(const wchar_t *name, bool isDir, bool isAnti, UInt32 mode) x \
+ virtual HRESULT OpenFileError(const FString &path, DWORD systemError) x \
+ virtual HRESULT ReadingFileError(const FString &path, DWORD systemError) x \
+ virtual HRESULT SetOperationResult(Int32 opRes) x \
+ virtual HRESULT ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name) x \
+ virtual HRESULT ReportUpdateOperation(UInt32 op, const wchar_t *name, bool isDir) x \
+ /* virtual HRESULT SetPassword(const UString &password) x */ \
+ virtual HRESULT CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password) x \
+ virtual HRESULT CryptoGetTextPassword(BSTR *password) x \
+ virtual HRESULT ShowDeleteFile(const wchar_t *name, bool isDir) x \
+
+ /*
+ virtual HRESULT ReportProp(UInt32 indexType, UInt32 index, PROPID propID, const PROPVARIANT *value) x \
+ virtual HRESULT ReportRawProp(UInt32 indexType, UInt32 index, PROPID propID, const void *data, UInt32 dataSize, UInt32 propType) x \
+ virtual HRESULT ReportFinished(UInt32 indexType, UInt32 index, Int32 opRes) x \
+ */
+
+ /* virtual HRESULT CloseProgress() { return S_OK; } */
+
+Z7_IFACE_DECL_PURE(IUpdateCallbackUI)
+Z7_PURE_INTERFACES_END
+
+struct CKeyKeyValPair
+{
+ UInt64 Key1;
+ UInt64 Key2;
+ unsigned Value;
+
+ int Compare(const CKeyKeyValPair &a) const
+ {
+ if (Key1 < a.Key1) return -1;
+ if (Key1 > a.Key1) return 1;
+ return MyCompare(Key2, a.Key2);
+ }
+};
+
+
+class CArchiveUpdateCallback Z7_final:
+ public IArchiveUpdateCallback2,
+ public IArchiveUpdateCallbackFile,
+ // public IArchiveUpdateCallbackArcProp,
+ public IArchiveExtractCallbackMessage2,
+ public IArchiveGetRawProps,
+ public IArchiveGetRootProps,
+ public ICryptoGetTextPassword2,
+ public ICryptoGetTextPassword,
+ public ICompressProgressInfo,
+ public IInFileStream_Callback,
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IArchiveUpdateCallback2)
+ Z7_COM_QI_ENTRY(IArchiveUpdateCallbackFile)
+ // Z7_COM_QI_ENTRY(IArchiveUpdateCallbackArcProp)
+ Z7_COM_QI_ENTRY(IArchiveExtractCallbackMessage2)
+ Z7_COM_QI_ENTRY(IArchiveGetRawProps)
+ Z7_COM_QI_ENTRY(IArchiveGetRootProps)
+ Z7_COM_QI_ENTRY(ICryptoGetTextPassword2)
+ Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+ Z7_COM_QI_ENTRY(ICompressProgressInfo)
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(ICompressProgressInfo)
+
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IArchiveUpdateCallback)
+ Z7_IFACE_COM7_IMP(IArchiveUpdateCallback2)
+ Z7_IFACE_COM7_IMP(IArchiveUpdateCallbackFile)
+ // Z7_IFACE_COM7_IMP(IArchiveUpdateCallbackArcProp)
+ Z7_IFACE_COM7_IMP(IArchiveExtractCallbackMessage2)
+ Z7_IFACE_COM7_IMP(IArchiveGetRawProps)
+ Z7_IFACE_COM7_IMP(IArchiveGetRootProps)
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword2)
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+
+
+ void UpdateProcessedItemStatus(unsigned dirIndex);
+
+public:
+ bool PreserveATime;
+ bool ShareForWrite;
+ bool StopAfterOpenError;
+ bool StdInMode;
+
+ bool KeepOriginalItemNames;
+ bool StoreNtSecurity;
+ bool StoreHardLinks;
+ bool StoreSymLinks;
+
+ bool StoreOwnerId;
+ bool StoreOwnerName;
+
+ bool Need_LatestMTime;
+ bool LatestMTime_Defined;
+
+ /*
+ bool Need_ArcMTime_Report;
+ bool ArcMTime_WasReported;
+ */
+
+ CRecordVector<UInt32> _openFiles_Indexes;
+ FStringVector _openFiles_Paths;
+ // CRecordVector< CInFileStream* > _openFiles_Streams;
+
+ bool AreAllFilesClosed() const { return _openFiles_Indexes.IsEmpty(); }
+ virtual HRESULT InFileStream_On_Error(UINT_PTR val, DWORD error) Z7_override;
+ virtual void InFileStream_On_Destroy(CInFileStream *stream, UINT_PTR val) Z7_override;
+
+ IUpdateCallbackUI *Callback;
+
+ const CDirItems *DirItems;
+ const CDirItem *ParentDirItem;
+
+ const CArc *Arc;
+ CMyComPtr<IInArchive> Archive;
+ const CObjectVector<CArcItem> *ArcItems;
+ const CRecordVector<CUpdatePair2> *UpdatePairs;
+
+ CRecordVector<UInt64> VolumesSizes;
+ FString VolName;
+ FString VolExt;
+ UString ArcFileName; // without path prefix
+
+ const UStringVector *NewNames;
+ const UString *Comment;
+ int CommentIndex;
+
+ /*
+ CArcTime Reported_ArcMTime;
+ */
+ CFiTime LatestMTime;
+
+ Byte *ProcessedItemsStatuses;
+
+
+ CArchiveUpdateCallback();
+
+ bool IsDir(const CUpdatePair2 &up) const
+ {
+ if (up.DirIndex >= 0)
+ return DirItems->Items[(unsigned)up.DirIndex].IsDir();
+ else if (up.ArcIndex >= 0)
+ return (*ArcItems)[(unsigned)up.ArcIndex].IsDir;
+ return false;
+ }
+
+private:
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ bool _saclEnabled;
+ #endif
+ CRecordVector<CKeyKeyValPair> _map;
+
+ UInt32 _hardIndex_From;
+ UInt32 _hardIndex_To;
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/UpdatePair.cpp b/CPP/7zip/UI/Common/UpdatePair.cpp
index 5153671..99b0aaf 100644
--- a/CPP/7zip/UI/Common/UpdatePair.cpp
+++ b/CPP/7zip/UI/Common/UpdatePair.cpp
@@ -1,233 +1,302 @@
-// UpdatePair.cpp
-
-#include "StdAfx.h"
-
-#include <time.h>
-
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/TimeUtils.h"
-
-#include "SortUtils.h"
-#include "UpdatePair.h"
-
-using namespace NWindows;
-using namespace NTime;
-
-static int MyCompareTime(NFileTimeType::EEnum fileTimeType, const FILETIME &time1, const FILETIME &time2)
-{
- switch (fileTimeType)
- {
- case NFileTimeType::kWindows:
- return ::CompareFileTime(&time1, &time2);
- case NFileTimeType::kUnix:
- {
- UInt32 unixTime1, unixTime2;
- FileTimeToUnixTime(time1, unixTime1);
- FileTimeToUnixTime(time2, unixTime2);
- return MyCompare(unixTime1, unixTime2);
- }
- case NFileTimeType::kDOS:
- {
- UInt32 dosTime1, dosTime2;
- FileTimeToDosTime(time1, dosTime1);
- FileTimeToDosTime(time2, dosTime2);
- return MyCompare(dosTime1, dosTime2);
- }
- }
- throw 4191618;
-}
-
-static const char * const k_Duplicate_inArc_Message = "Duplicate filename in archive:";
-static const char * const k_Duplicate_inDir_Message = "Duplicate filename on disk:";
-static const char * const k_NotCensoredCollision_Message = "Internal file name collision (file on disk, file in archive):";
-
-static void ThrowError(const char *message, const UString &s1, const UString &s2)
-{
- UString m (message);
- m.Add_LF(); m += s1;
- m.Add_LF(); m += s2;
- throw m;
-}
-
-static int CompareArcItemsBase(const CArcItem &ai1, const CArcItem &ai2)
-{
- int res = CompareFileNames(ai1.Name, ai2.Name);
- if (res != 0)
- return res;
- if (ai1.IsDir != ai2.IsDir)
- return ai1.IsDir ? -1 : 1;
- return 0;
-}
-
-static int CompareArcItems(const unsigned *p1, const unsigned *p2, void *param)
-{
- unsigned i1 = *p1;
- unsigned i2 = *p2;
- const CObjectVector<CArcItem> &arcItems = *(const CObjectVector<CArcItem> *)param;
- int res = CompareArcItemsBase(arcItems[i1], arcItems[i2]);
- if (res != 0)
- return res;
- return MyCompare(i1, i2);
-}
-
-void GetUpdatePairInfoList(
- const CDirItems &dirItems,
- const CObjectVector<CArcItem> &arcItems,
- NFileTimeType::EEnum fileTimeType,
- CRecordVector<CUpdatePair> &updatePairs)
-{
- CUIntVector dirIndices, arcIndices;
-
- unsigned numDirItems = dirItems.Items.Size();
- unsigned numArcItems = arcItems.Size();
-
- CIntArr duplicatedArcItem(numArcItems);
- {
- int *vals = &duplicatedArcItem[0];
- for (unsigned i = 0; i < numArcItems; i++)
- vals[i] = 0;
- }
-
- {
- arcIndices.ClearAndSetSize(numArcItems);
- if (numArcItems != 0)
- {
- unsigned *vals = &arcIndices[0];
- for (unsigned i = 0; i < numArcItems; i++)
- vals[i] = i;
- }
- arcIndices.Sort(CompareArcItems, (void *)&arcItems);
- for (unsigned i = 0; i + 1 < numArcItems; i++)
- if (CompareArcItemsBase(
- arcItems[arcIndices[i]],
- arcItems[arcIndices[i + 1]]) == 0)
- {
- duplicatedArcItem[i] = 1;
- duplicatedArcItem[i + 1] = -1;
- }
- }
-
- UStringVector dirNames;
- {
- dirNames.ClearAndReserve(numDirItems);
- unsigned i;
- for (i = 0; i < numDirItems; i++)
- dirNames.AddInReserved(dirItems.GetLogPath(i));
- SortFileNames(dirNames, dirIndices);
- for (i = 0; i + 1 < numDirItems; i++)
- {
- const UString &s1 = dirNames[dirIndices[i]];
- const UString &s2 = dirNames[dirIndices[i + 1]];
- if (CompareFileNames(s1, s2) == 0)
- ThrowError(k_Duplicate_inDir_Message, s1, s2);
- }
- }
-
- unsigned dirIndex = 0;
- unsigned arcIndex = 0;
-
- int prevHostFile = -1;
- const UString *prevHostName = NULL;
-
- while (dirIndex < numDirItems || arcIndex < numArcItems)
- {
- CUpdatePair pair;
-
- int dirIndex2 = -1;
- int arcIndex2 = -1;
- const CDirItem *di = NULL;
- const CArcItem *ai = NULL;
-
- int compareResult = -1;
- const UString *name = NULL;
-
- if (dirIndex < numDirItems)
- {
- dirIndex2 = dirIndices[dirIndex];
- di = &dirItems.Items[dirIndex2];
- }
-
- if (arcIndex < numArcItems)
- {
- arcIndex2 = arcIndices[arcIndex];
- ai = &arcItems[arcIndex2];
- compareResult = 1;
- if (dirIndex < numDirItems)
- {
- compareResult = CompareFileNames(dirNames[dirIndex2], ai->Name);
- if (compareResult == 0)
- {
- if (di->IsDir() != ai->IsDir)
- compareResult = (ai->IsDir ? 1 : -1);
- }
- }
- }
-
- if (compareResult < 0)
- {
- name = &dirNames[dirIndex2];
- pair.State = NUpdateArchive::NPairState::kOnlyOnDisk;
- pair.DirIndex = dirIndex2;
- dirIndex++;
- }
- else if (compareResult > 0)
- {
- name = &ai->Name;
- pair.State = ai->Censored ?
- NUpdateArchive::NPairState::kOnlyInArchive:
- NUpdateArchive::NPairState::kNotMasked;
- pair.ArcIndex = arcIndex2;
- arcIndex++;
- }
- else
- {
- int dupl = duplicatedArcItem[arcIndex];
- if (dupl != 0)
- ThrowError(k_Duplicate_inArc_Message, ai->Name, arcItems[arcIndices[arcIndex + dupl]].Name);
-
- name = &dirNames[dirIndex2];
- if (!ai->Censored)
- ThrowError(k_NotCensoredCollision_Message, *name, ai->Name);
-
- pair.DirIndex = dirIndex2;
- pair.ArcIndex = arcIndex2;
-
- switch (ai->MTimeDefined ? MyCompareTime(
- ai->TimeType != - 1 ? (NFileTimeType::EEnum)ai->TimeType : fileTimeType,
- di->MTime, ai->MTime): 0)
- {
- case -1: pair.State = NUpdateArchive::NPairState::kNewInArchive; break;
- case 1: pair.State = NUpdateArchive::NPairState::kOldInArchive; break;
- default:
- pair.State = (ai->SizeDefined && di->Size == ai->Size) ?
- NUpdateArchive::NPairState::kSameFiles :
- NUpdateArchive::NPairState::kUnknowNewerFiles;
- }
-
- dirIndex++;
- arcIndex++;
- }
-
- if ((di && di->IsAltStream) ||
- (ai && ai->IsAltStream))
- {
- if (prevHostName)
- {
- unsigned hostLen = prevHostName->Len();
- if (name->Len() > hostLen)
- if ((*name)[hostLen] == ':' && CompareFileNames(*prevHostName, name->Left(hostLen)) == 0)
- pair.HostIndex = prevHostFile;
- }
- }
- else
- {
- prevHostFile = updatePairs.Size();
- prevHostName = name;
- }
-
- updatePairs.Add(pair);
- }
-
- updatePairs.ReserveDown();
-}
+// UpdatePair.cpp
+
+#include "StdAfx.h"
+
+#include <time.h>
+// #include <stdio.h>
+
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/TimeUtils.h"
+
+#include "SortUtils.h"
+#include "UpdatePair.h"
+
+using namespace NWindows;
+using namespace NTime;
+
+
+/*
+ a2.Prec =
+ {
+ 0 (k_PropVar_TimePrec_0):
+ if GetProperty(kpidMTime) returned 0 and
+ GetProperty(kpidTimeType) did not returned VT_UI4.
+ 7z, wim, tar in 7-Zip before v21)
+ in that case we use
+ (prec) that is set by IOutArchive::GetFileTimeType()
+ }
+*/
+
+static int MyCompareTime(unsigned prec, const CFiTime &f1, const CArcTime &a2)
+{
+ // except of precision, we also have limitation, when timestamp is out of range
+
+ /* if (Prec) in archive item is defined, then use global (prec) */
+ if (a2.Prec != k_PropVar_TimePrec_0)
+ prec = a2.Prec;
+
+ CArcTime a1;
+ a1.Set_From_FiTime(f1);
+ /* Set_From_FiTime() must set full form precision:
+ k_PropVar_TimePrec_Base + numDigits
+ windows: 7 digits, non-windows: 9 digits */
+
+ if (prec == k_PropVar_TimePrec_DOS)
+ {
+ const UInt32 dosTime1 = a1.Get_DosTime();
+ const UInt32 dosTime2 = a2.Get_DosTime();
+ return MyCompare(dosTime1, dosTime2);
+ }
+
+ if (prec == k_PropVar_TimePrec_Unix)
+ {
+ const Int64 u2 = FileTime_To_UnixTime64(a2.FT);
+ if (u2 == 0 || u2 == (UInt32)0xFFFFFFFF)
+ {
+ // timestamp probably was saturated in archive to 32-bit
+ // so we use saturated 32-bit value for disk file too.
+ UInt32 u1;
+ FileTime_To_UnixTime(a1.FT, u1);
+ const UInt32 u2_32 = (UInt32)u2;
+ return MyCompare(u1, u2_32);
+ }
+
+ const Int64 u1 = FileTime_To_UnixTime64(a1.FT);
+ return MyCompare(u1, u2);
+ // prec = k_PropVar_TimePrec_Base; // for debug
+ }
+
+ if (prec == k_PropVar_TimePrec_0)
+ prec = k_PropVar_TimePrec_Base + 7;
+ else if (prec == k_PropVar_TimePrec_HighPrec)
+ prec = k_PropVar_TimePrec_Base + 9;
+ else if (prec < k_PropVar_TimePrec_Base)
+ prec = k_PropVar_TimePrec_Base;
+ else if (prec > k_PropVar_TimePrec_Base + 9)
+ prec = k_PropVar_TimePrec_Base + 7;
+
+ // prec now is full form: k_PropVar_TimePrec_Base + numDigits;
+ if (prec > a1.Prec && a1.Prec >= k_PropVar_TimePrec_Base)
+ prec = a1.Prec;
+
+ const unsigned numDigits = prec - k_PropVar_TimePrec_Base;
+ if (numDigits >= 7)
+ {
+ const int comp = CompareFileTime(&a1.FT, &a2.FT);
+ if (comp != 0 || numDigits == 7)
+ return comp;
+ return MyCompare(a1.Ns100, a2.Ns100);
+ }
+ UInt32 d = 1;
+ for (unsigned k = numDigits; k < 7; k++)
+ d *= 10;
+ const UInt64 v1 = a1.Get_FILETIME_as_UInt64() / d * d;
+ const UInt64 v2 = a2.Get_FILETIME_as_UInt64() / d * d;
+ // printf("\ndelta=%d numDigits=%d\n", (unsigned)(v1- v2), numDigits);
+ return MyCompare(v1, v2);
+}
+
+
+
+static const char * const k_Duplicate_inArc_Message = "Duplicate filename in archive:";
+static const char * const k_Duplicate_inDir_Message = "Duplicate filename on disk:";
+static const char * const k_NotCensoredCollision_Message = "Internal file name collision (file on disk, file in archive):";
+
+Z7_ATTR_NORETURN
+static
+void ThrowError(const char *message, const UString &s1, const UString &s2)
+{
+ UString m (message);
+ m.Add_LF(); m += s1;
+ m.Add_LF(); m += s2;
+ throw m;
+}
+
+static int CompareArcItemsBase(const CArcItem &ai1, const CArcItem &ai2)
+{
+ const int res = CompareFileNames(ai1.Name, ai2.Name);
+ if (res != 0)
+ return res;
+ if (ai1.IsDir != ai2.IsDir)
+ return ai1.IsDir ? -1 : 1;
+ return 0;
+}
+
+static int CompareArcItems(const unsigned *p1, const unsigned *p2, void *param)
+{
+ const unsigned i1 = *p1;
+ const unsigned i2 = *p2;
+ const CObjectVector<CArcItem> &arcItems = *(const CObjectVector<CArcItem> *)param;
+ const int res = CompareArcItemsBase(arcItems[i1], arcItems[i2]);
+ if (res != 0)
+ return res;
+ return MyCompare(i1, i2);
+}
+
+void GetUpdatePairInfoList(
+ const CDirItems &dirItems,
+ const CObjectVector<CArcItem> &arcItems,
+ NFileTimeType::EEnum fileTimeType,
+ CRecordVector<CUpdatePair> &updatePairs)
+{
+ CUIntVector dirIndices, arcIndices;
+
+ const unsigned numDirItems = dirItems.Items.Size();
+ const unsigned numArcItems = arcItems.Size();
+
+ CIntArr duplicatedArcItem(numArcItems);
+ {
+ int *vals = &duplicatedArcItem[0];
+ for (unsigned i = 0; i < numArcItems; i++)
+ vals[i] = 0;
+ }
+
+ {
+ arcIndices.ClearAndSetSize(numArcItems);
+ if (numArcItems != 0)
+ {
+ unsigned *vals = &arcIndices[0];
+ for (unsigned i = 0; i < numArcItems; i++)
+ vals[i] = i;
+ }
+ arcIndices.Sort(CompareArcItems, (void *)&arcItems);
+ for (unsigned i = 0; i + 1 < numArcItems; i++)
+ if (CompareArcItemsBase(
+ arcItems[arcIndices[i]],
+ arcItems[arcIndices[i + 1]]) == 0)
+ {
+ duplicatedArcItem[i] = 1;
+ duplicatedArcItem[i + 1] = -1;
+ }
+ }
+
+ UStringVector dirNames;
+ {
+ dirNames.ClearAndReserve(numDirItems);
+ unsigned i;
+ for (i = 0; i < numDirItems; i++)
+ dirNames.AddInReserved(dirItems.GetLogPath(i));
+ SortFileNames(dirNames, dirIndices);
+ for (i = 0; i + 1 < numDirItems; i++)
+ {
+ const UString &s1 = dirNames[dirIndices[i]];
+ const UString &s2 = dirNames[dirIndices[i + 1]];
+ if (CompareFileNames(s1, s2) == 0)
+ ThrowError(k_Duplicate_inDir_Message, s1, s2);
+ }
+ }
+
+ unsigned dirIndex = 0;
+ unsigned arcIndex = 0;
+
+ int prevHostFile = -1;
+ const UString *prevHostName = NULL;
+
+ while (dirIndex < numDirItems || arcIndex < numArcItems)
+ {
+ CUpdatePair pair;
+
+ int dirIndex2 = -1;
+ int arcIndex2 = -1;
+ const CDirItem *di = NULL;
+ const CArcItem *ai = NULL;
+
+ int compareResult = -1;
+ const UString *name = NULL;
+
+ if (dirIndex < numDirItems)
+ {
+ dirIndex2 = (int)dirIndices[dirIndex];
+ di = &dirItems.Items[(unsigned)dirIndex2];
+ }
+
+ if (arcIndex < numArcItems)
+ {
+ arcIndex2 = (int)arcIndices[arcIndex];
+ ai = &arcItems[(unsigned)arcIndex2];
+ compareResult = 1;
+ if (dirIndex < numDirItems)
+ {
+ compareResult = CompareFileNames(dirNames[(unsigned)dirIndex2], ai->Name);
+ if (compareResult == 0)
+ {
+ if (di->IsDir() != ai->IsDir)
+ compareResult = (ai->IsDir ? 1 : -1);
+ }
+ }
+ }
+
+ if (compareResult < 0)
+ {
+ name = &dirNames[(unsigned)dirIndex2];
+ pair.State = NUpdateArchive::NPairState::kOnlyOnDisk;
+ pair.DirIndex = dirIndex2;
+ dirIndex++;
+ }
+ else if (compareResult > 0)
+ {
+ name = &ai->Name;
+ pair.State = ai->Censored ?
+ NUpdateArchive::NPairState::kOnlyInArchive:
+ NUpdateArchive::NPairState::kNotMasked;
+ pair.ArcIndex = arcIndex2;
+ arcIndex++;
+ }
+ else
+ {
+ const int dupl = duplicatedArcItem[arcIndex];
+ if (dupl != 0)
+ ThrowError(k_Duplicate_inArc_Message, ai->Name, arcItems[arcIndices[(unsigned)((int)arcIndex + dupl)]].Name);
+
+ name = &dirNames[(unsigned)dirIndex2];
+ if (!ai->Censored)
+ ThrowError(k_NotCensoredCollision_Message, *name, ai->Name);
+
+ pair.DirIndex = dirIndex2;
+ pair.ArcIndex = arcIndex2;
+
+ int compResult = 0;
+ if (ai->MTime.Def)
+ {
+ compResult = MyCompareTime((unsigned)fileTimeType, di->MTime, ai->MTime);
+ }
+ switch (compResult)
+ {
+ case -1: pair.State = NUpdateArchive::NPairState::kNewInArchive; break;
+ case 1: pair.State = NUpdateArchive::NPairState::kOldInArchive; break;
+ default:
+ pair.State = (ai->Size_Defined && di->Size == ai->Size) ?
+ NUpdateArchive::NPairState::kSameFiles :
+ NUpdateArchive::NPairState::kUnknowNewerFiles;
+ }
+
+ dirIndex++;
+ arcIndex++;
+ }
+
+ if (
+ #ifdef _WIN32
+ (di && di->IsAltStream) ||
+ #endif
+ (ai && ai->IsAltStream))
+ {
+ if (prevHostName)
+ {
+ const unsigned hostLen = prevHostName->Len();
+ if (name->Len() > hostLen)
+ if ((*name)[hostLen] == ':' && CompareFileNames(*prevHostName, name->Left(hostLen)) == 0)
+ pair.HostIndex = prevHostFile;
+ }
+ }
+ else
+ {
+ prevHostFile = (int)updatePairs.Size();
+ prevHostName = name;
+ }
+
+ updatePairs.Add(pair);
+ }
+
+ updatePairs.ReserveDown();
+}
diff --git a/CPP/7zip/UI/Common/UpdatePair.h b/CPP/7zip/UI/Common/UpdatePair.h
index 36da243..13228b0 100644
--- a/CPP/7zip/UI/Common/UpdatePair.h
+++ b/CPP/7zip/UI/Common/UpdatePair.h
@@ -1,27 +1,27 @@
-// UpdatePair.h
-
-#ifndef __UPDATE_PAIR_H
-#define __UPDATE_PAIR_H
-
-#include "DirItem.h"
-#include "UpdateAction.h"
-
-#include "../../Archive/IArchive.h"
-
-struct CUpdatePair
-{
- NUpdateArchive::NPairState::EEnum State;
- int ArcIndex;
- int DirIndex;
- int HostIndex; // >= 0 for alt streams only, contains index of host pair
-
- CUpdatePair(): ArcIndex(-1), DirIndex(-1), HostIndex(-1) {}
-};
-
-void GetUpdatePairInfoList(
- const CDirItems &dirItems,
- const CObjectVector<CArcItem> &arcItems,
- NFileTimeType::EEnum fileTimeType,
- CRecordVector<CUpdatePair> &updatePairs);
-
-#endif
+// UpdatePair.h
+
+#ifndef ZIP7_INC_UPDATE_PAIR_H
+#define ZIP7_INC_UPDATE_PAIR_H
+
+#include "DirItem.h"
+#include "UpdateAction.h"
+
+#include "../../Archive/IArchive.h"
+
+struct CUpdatePair
+{
+ NUpdateArchive::NPairState::EEnum State;
+ int ArcIndex;
+ int DirIndex;
+ int HostIndex; // >= 0 for alt streams only, contains index of host pair
+
+ CUpdatePair(): ArcIndex(-1), DirIndex(-1), HostIndex(-1) {}
+};
+
+void GetUpdatePairInfoList(
+ const CDirItems &dirItems,
+ const CObjectVector<CArcItem> &arcItems,
+ NFileTimeType::EEnum fileTimeType,
+ CRecordVector<CUpdatePair> &updatePairs);
+
+#endif
diff --git a/CPP/7zip/UI/Common/UpdateProduce.cpp b/CPP/7zip/UI/Common/UpdateProduce.cpp
index c025ac4..e921dc3 100644
--- a/CPP/7zip/UI/Common/UpdateProduce.cpp
+++ b/CPP/7zip/UI/Common/UpdateProduce.cpp
@@ -1,70 +1,72 @@
-// UpdateProduce.cpp
-
-#include "StdAfx.h"
-
-#include "UpdateProduce.h"
-
-using namespace NUpdateArchive;
-
-static const char * const kUpdateActionSetCollision = "Internal collision in update action set";
-
-void UpdateProduce(
- const CRecordVector<CUpdatePair> &updatePairs,
- const CActionSet &actionSet,
- CRecordVector<CUpdatePair2> &operationChain,
- IUpdateProduceCallback *callback)
-{
- FOR_VECTOR (i, updatePairs)
- {
- const CUpdatePair &pair = updatePairs[i];
-
- CUpdatePair2 up2;
- up2.DirIndex = pair.DirIndex;
- up2.ArcIndex = pair.ArcIndex;
- up2.NewData = up2.NewProps = true;
- up2.UseArcProps = false;
-
- switch (actionSet.StateActions[(unsigned)pair.State])
- {
- case NPairAction::kIgnore:
- if (pair.ArcIndex >= 0 && callback)
- callback->ShowDeleteFile(pair.ArcIndex);
- continue;
-
- case NPairAction::kCopy:
- if (pair.State == NPairState::kOnlyOnDisk)
- throw kUpdateActionSetCollision;
- if (pair.State == NPairState::kOnlyInArchive)
- {
- if (pair.HostIndex >= 0)
- {
- /*
- ignore alt stream if
- 1) no such alt stream in Disk
- 2) there is Host file in disk
- */
- if (updatePairs[pair.HostIndex].DirIndex >= 0)
- continue;
- }
- }
- up2.NewData = up2.NewProps = false;
- up2.UseArcProps = true;
- break;
-
- case NPairAction::kCompress:
- if (pair.State == NPairState::kOnlyInArchive ||
- pair.State == NPairState::kNotMasked)
- throw kUpdateActionSetCollision;
- break;
-
- case NPairAction::kCompressAsAnti:
- up2.IsAnti = true;
- up2.UseArcProps = (pair.ArcIndex >= 0);
- break;
- }
-
- operationChain.Add(up2);
- }
-
- operationChain.ReserveDown();
-}
+// UpdateProduce.cpp
+
+#include "StdAfx.h"
+
+#include "UpdateProduce.h"
+
+using namespace NUpdateArchive;
+
+static const char * const kUpdateActionSetCollision = "Internal collision in update action set";
+
+void UpdateProduce(
+ const CRecordVector<CUpdatePair> &updatePairs,
+ const CActionSet &actionSet,
+ CRecordVector<CUpdatePair2> &operationChain,
+ IUpdateProduceCallback *callback)
+{
+ FOR_VECTOR (i, updatePairs)
+ {
+ const CUpdatePair &pair = updatePairs[i];
+
+ CUpdatePair2 up2;
+ up2.DirIndex = pair.DirIndex;
+ up2.ArcIndex = pair.ArcIndex;
+ up2.NewData = up2.NewProps = true;
+ up2.UseArcProps = false;
+
+ switch (actionSet.StateActions[(unsigned)pair.State])
+ {
+ case NPairAction::kIgnore:
+ if (pair.ArcIndex >= 0 && callback)
+ callback->ShowDeleteFile((unsigned)pair.ArcIndex);
+ continue;
+
+ case NPairAction::kCopy:
+ if (pair.State == NPairState::kOnlyOnDisk)
+ throw kUpdateActionSetCollision;
+ if (pair.State == NPairState::kOnlyInArchive)
+ {
+ if (pair.HostIndex >= 0)
+ {
+ /*
+ ignore alt stream if
+ 1) no such alt stream in Disk
+ 2) there is Host file in disk
+ */
+ if (updatePairs[(unsigned)pair.HostIndex].DirIndex >= 0)
+ continue;
+ }
+ }
+ up2.NewData = up2.NewProps = false;
+ up2.UseArcProps = true;
+ break;
+
+ case NPairAction::kCompress:
+ if (pair.State == NPairState::kOnlyInArchive ||
+ pair.State == NPairState::kNotMasked)
+ throw kUpdateActionSetCollision;
+ break;
+
+ case NPairAction::kCompressAsAnti:
+ up2.IsAnti = true;
+ up2.UseArcProps = (pair.ArcIndex >= 0);
+ break;
+ }
+
+ up2.IsSameTime = ((unsigned)pair.State == NUpdateArchive::NPairState::kSameFiles);
+
+ operationChain.Add(up2);
+ }
+
+ operationChain.ReserveDown();
+}
diff --git a/CPP/7zip/UI/Common/UpdateProduce.h b/CPP/7zip/UI/Common/UpdateProduce.h
index 8467543..9db6c1e 100644
--- a/CPP/7zip/UI/Common/UpdateProduce.h
+++ b/CPP/7zip/UI/Common/UpdateProduce.h
@@ -1,55 +1,60 @@
-// UpdateProduce.h
-
-#ifndef __UPDATE_PRODUCE_H
-#define __UPDATE_PRODUCE_H
-
-#include "UpdatePair.h"
-
-struct CUpdatePair2
-{
- bool NewData;
- bool NewProps;
- bool UseArcProps; // if (UseArcProps && NewProps), we want to change only some properties.
- bool IsAnti; // if (!IsAnti) we use other ways to detect Anti status
-
- int DirIndex;
- int ArcIndex;
- int NewNameIndex;
-
- bool IsMainRenameItem;
-
- void SetAs_NoChangeArcItem(int arcIndex)
- {
- NewData = NewProps = false;
- UseArcProps = true;
- IsAnti = false;
- ArcIndex = arcIndex;
- }
-
- bool ExistOnDisk() const { return DirIndex != -1; }
- bool ExistInArchive() const { return ArcIndex != -1; }
-
- CUpdatePair2():
- NewData(false),
- NewProps(false),
- UseArcProps(false),
- IsAnti(false),
- DirIndex(-1),
- ArcIndex(-1),
- NewNameIndex(-1),
- IsMainRenameItem(false)
- {}
-};
-
-struct IUpdateProduceCallback
-{
- virtual HRESULT ShowDeleteFile(unsigned arcIndex) = 0;
-};
-
-void UpdateProduce(
- const CRecordVector<CUpdatePair> &updatePairs,
- const NUpdateArchive::CActionSet &actionSet,
- CRecordVector<CUpdatePair2> &operationChain,
- IUpdateProduceCallback *callback);
-
-#endif
+// UpdateProduce.h
+
+#ifndef ZIP7_INC_UPDATE_PRODUCE_H
+#define ZIP7_INC_UPDATE_PRODUCE_H
+
+#include "UpdatePair.h"
+
+struct CUpdatePair2
+{
+ bool NewData;
+ bool NewProps;
+ bool UseArcProps; // if (UseArcProps && NewProps), we want to change only some properties.
+ bool IsAnti; // if (!IsAnti) we use other ways to detect Anti status
+
+ int DirIndex;
+ int ArcIndex;
+ int NewNameIndex;
+
+ bool IsMainRenameItem;
+ bool IsSameTime;
+
+ void SetAs_NoChangeArcItem(unsigned arcIndex) // int
+ {
+ NewData = NewProps = false;
+ UseArcProps = true;
+ IsAnti = false;
+ ArcIndex = (int)arcIndex;
+ }
+
+ bool ExistOnDisk() const { return DirIndex != -1; }
+ bool ExistInArchive() const { return ArcIndex != -1; }
+
+ CUpdatePair2():
+ NewData(false),
+ NewProps(false),
+ UseArcProps(false),
+ IsAnti(false),
+ DirIndex(-1),
+ ArcIndex(-1),
+ NewNameIndex(-1),
+ IsMainRenameItem(false),
+ IsSameTime(false)
+ {}
+};
+
+Z7_PURE_INTERFACES_BEGIN
+
+DECLARE_INTERFACE(IUpdateProduceCallback)
+{
+ virtual HRESULT ShowDeleteFile(unsigned arcIndex) = 0;
+};
+Z7_PURE_INTERFACES_END
+
+void UpdateProduce(
+ const CRecordVector<CUpdatePair> &updatePairs,
+ const NUpdateArchive::CActionSet &actionSet,
+ CRecordVector<CUpdatePair2> &operationChain,
+ IUpdateProduceCallback *callback);
+
+#endif
diff --git a/CPP/7zip/UI/Common/WorkDir.cpp b/CPP/7zip/UI/Common/WorkDir.cpp
index 03d6eed..cfec635 100644
--- a/CPP/7zip/UI/Common/WorkDir.cpp
+++ b/CPP/7zip/UI/Common/WorkDir.cpp
@@ -1,94 +1,86 @@
-// WorkDir.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileName.h"
-
-#include "WorkDir.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName)
-{
- NWorkDir::NMode::EEnum mode = workDirInfo.Mode;
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (workDirInfo.ForRemovableOnly)
- {
- mode = NWorkDir::NMode::kCurrent;
- FString prefix = path.Left(3);
- if (prefix[1] == FTEXT(':') && prefix[2] == FTEXT('\\'))
- {
- UINT driveType = GetDriveType(GetSystemString(prefix, ::AreFileApisANSI() ? CP_ACP : CP_OEMCP));
- if (driveType == DRIVE_CDROM || driveType == DRIVE_REMOVABLE)
- mode = workDirInfo.Mode;
- }
- /*
- CParsedPath parsedPath;
- parsedPath.ParsePath(archiveName);
- UINT driveType = GetDriveType(parsedPath.Prefix);
- if ((driveType != DRIVE_CDROM) && (driveType != DRIVE_REMOVABLE))
- mode = NZipSettings::NWorkDir::NMode::kCurrent;
- */
- }
- #endif
-
- int pos = path.ReverseFind_PathSepar() + 1;
- fileName = path.Ptr(pos);
-
- switch (mode)
- {
- case NWorkDir::NMode::kCurrent:
- {
- return path.Left(pos);
- }
- case NWorkDir::NMode::kSpecified:
- {
- FString tempDir = workDirInfo.Path;
- NName::NormalizeDirPathPrefix(tempDir);
- return tempDir;
- }
- default:
- {
- FString tempDir;
- if (!MyGetTempPath(tempDir))
- throw 141717;
- return tempDir;
- }
- }
-}
-
-HRESULT CWorkDirTempFile::CreateTempFile(const FString &originalPath)
-{
- NWorkDir::CInfo workDirInfo;
- workDirInfo.Load();
- FString namePart;
- FString workDir = GetWorkDir(workDirInfo, originalPath, namePart);
- CreateComplexDir(workDir);
- CTempFile tempFile;
- _outStreamSpec = new COutFileStream;
- OutStream = _outStreamSpec;
- if (!_tempFile.Create(workDir + namePart, &_outStreamSpec->File))
- {
- DWORD error = GetLastError();
- return error ? error : E_FAIL;
- }
- _originalPath = originalPath;
- return S_OK;
-}
-
-HRESULT CWorkDirTempFile::MoveToOriginal(bool deleteOriginal)
-{
- OutStream.Release();
- if (!_tempFile.MoveTo(_originalPath, deleteOriginal))
- {
- DWORD error = GetLastError();
- return error ? error : E_FAIL;
- }
- return S_OK;
-}
+// WorkDir.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileSystem.h"
+
+#include "WorkDir.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName)
+{
+ NWorkDir::NMode::EEnum mode = workDirInfo.Mode;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (workDirInfo.ForRemovableOnly)
+ {
+ mode = NWorkDir::NMode::kCurrent;
+ const FString prefix = path.Left(3);
+ if (NName::IsDrivePath(prefix))
+ {
+ const UINT driveType = NSystem::MyGetDriveType(prefix);
+ if (driveType == DRIVE_CDROM || driveType == DRIVE_REMOVABLE)
+ mode = workDirInfo.Mode;
+ }
+ /*
+ CParsedPath parsedPath;
+ parsedPath.ParsePath(archiveName);
+ UINT driveType = GetDriveType(parsedPath.Prefix);
+ if ((driveType != DRIVE_CDROM) && (driveType != DRIVE_REMOVABLE))
+ mode = NZipSettings::NWorkDir::NMode::kCurrent;
+ */
+ }
+ #endif
+
+ const int pos = path.ReverseFind_PathSepar() + 1;
+ fileName = path.Ptr((unsigned)pos);
+
+ FString tempDir;
+ switch ((int)mode)
+ {
+ case NWorkDir::NMode::kCurrent:
+ tempDir = path.Left((unsigned)pos);
+ break;
+ case NWorkDir::NMode::kSpecified:
+ tempDir = workDirInfo.Path;
+ break;
+ // case NWorkDir::NMode::kSystem:
+ default:
+ if (!MyGetTempPath(tempDir))
+ throw 141717;
+ break;
+ }
+ NName::NormalizeDirPathPrefix(tempDir);
+ return tempDir;
+}
+
+HRESULT CWorkDirTempFile::CreateTempFile(const FString &originalPath)
+{
+ NWorkDir::CInfo workDirInfo;
+ workDirInfo.Load();
+ FString namePart;
+ const FString workDir = GetWorkDir(workDirInfo, originalPath, namePart);
+ CreateComplexDir(workDir);
+ _outStreamSpec = new COutFileStream;
+ OutStream = _outStreamSpec;
+ if (!_tempFile.Create(workDir + namePart, &_outStreamSpec->File))
+ {
+ return GetLastError_noZero_HRESULT();
+ }
+ _originalPath = originalPath;
+ return S_OK;
+}
+
+HRESULT CWorkDirTempFile::MoveToOriginal(bool deleteOriginal)
+{
+ OutStream.Release();
+ if (!_tempFile.MoveTo(_originalPath, deleteOriginal))
+ {
+ return GetLastError_noZero_HRESULT();
+ }
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Common/WorkDir.h b/CPP/7zip/UI/Common/WorkDir.h
index 13d4ed9..d32ab9d 100644
--- a/CPP/7zip/UI/Common/WorkDir.h
+++ b/CPP/7zip/UI/Common/WorkDir.h
@@ -1,26 +1,26 @@
-// WorkDir.h
-
-#ifndef __WORK_DIR_H
-#define __WORK_DIR_H
-
-#include "../../../Windows/FileDir.h"
-
-#include "../../Common/FileStreams.h"
-
-#include "ZipRegistry.h"
-
-FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName);
-
-class CWorkDirTempFile
-{
- FString _originalPath;
- NWindows::NFile::NDir::CTempFile _tempFile;
- COutFileStream *_outStreamSpec;
-public:
- CMyComPtr<IOutStream> OutStream;
-
- HRESULT CreateTempFile(const FString &originalPath);
- HRESULT MoveToOriginal(bool deleteOriginal);
-};
-
-#endif
+// WorkDir.h
+
+#ifndef ZIP7_INC_WORK_DIR_H
+#define ZIP7_INC_WORK_DIR_H
+
+#include "../../../Windows/FileDir.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "ZipRegistry.h"
+
+FString GetWorkDir(const NWorkDir::CInfo &workDirInfo, const FString &path, FString &fileName);
+
+class CWorkDirTempFile
+{
+ FString _originalPath;
+ NWindows::NFile::NDir::CTempFile _tempFile;
+ COutFileStream *_outStreamSpec;
+public:
+ CMyComPtr<IOutStream> OutStream;
+
+ HRESULT CreateTempFile(const FString &originalPath);
+ HRESULT MoveToOriginal(bool deleteOriginal);
+};
+
+#endif
diff --git a/CPP/7zip/UI/Common/ZipRegistry.cpp b/CPP/7zip/UI/Common/ZipRegistry.cpp
new file mode 100644
index 0000000..6c1b9c8
--- /dev/null
+++ b/CPP/7zip/UI/Common/ZipRegistry.cpp
@@ -0,0 +1,580 @@
+// ZipRegistry.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/Registry.h"
+#include "../../../Windows/Synchronization.h"
+
+// #include "../Explorer/ContextMenuFlags.h"
+#include "ZipRegistry.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+static NSynchronization::CCriticalSection g_CS;
+#define CS_LOCK NSynchronization::CCriticalSectionLock lock(g_CS);
+
+static LPCTSTR const kCuPrefix = TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-Zip") TEXT(STRING_PATH_SEPARATOR);
+
+static CSysString GetKeyPath(LPCTSTR path) { return kCuPrefix + (CSysString)path; }
+
+static LONG OpenMainKey(CKey &key, LPCTSTR keyName)
+{
+ return key.Open(HKEY_CURRENT_USER, GetKeyPath(keyName), KEY_READ);
+}
+
+static LONG CreateMainKey(CKey &key, LPCTSTR keyName)
+{
+ return key.Create(HKEY_CURRENT_USER, GetKeyPath(keyName));
+}
+
+static void Key_Set_UInt32(CKey &key, LPCTSTR name, UInt32 value)
+{
+ if (value == (UInt32)(Int32)-1)
+ key.DeleteValue(name);
+ else
+ key.SetValue(name, value);
+}
+
+
+static void Key_Get_UInt32(CKey &key, LPCTSTR name, UInt32 &value)
+{
+ if (key.QueryValue(name, value) != ERROR_SUCCESS)
+ value = (UInt32)(Int32)-1;
+}
+
+
+static void Key_Set_BoolPair(CKey &key, LPCTSTR name, const CBoolPair &b)
+{
+ if (b.Def)
+ key.SetValue(name, b.Val);
+}
+
+static void Key_Set_bool_if_Changed(CKey &key, LPCTSTR name, bool val)
+{
+ bool oldVal = false;
+ if (key.GetValue_IfOk(name, oldVal) == ERROR_SUCCESS)
+ if (val == oldVal)
+ return;
+ key.SetValue(name, val);
+}
+
+static void Key_Set_BoolPair_Delete_IfNotDef(CKey &key, LPCTSTR name, const CBoolPair &b)
+{
+ if (b.Def)
+ Key_Set_bool_if_Changed(key, name, b.Val);
+ else
+ key.DeleteValue(name);
+}
+
+static void Key_Get_BoolPair(CKey &key, LPCTSTR name, CBoolPair &b)
+{
+ b.Val = false;
+ b.Def = (key.GetValue_IfOk(name, b.Val) == ERROR_SUCCESS);
+}
+
+static void Key_Get_BoolPair_true(CKey &key, LPCTSTR name, CBoolPair &b)
+{
+ b.Val = true;
+ b.Def = (key.GetValue_IfOk(name, b.Val) == ERROR_SUCCESS);
+}
+
+namespace NExtract
+{
+
+static LPCTSTR const kKeyName = TEXT("Extraction");
+
+static LPCTSTR const kExtractMode = TEXT("ExtractMode");
+static LPCTSTR const kOverwriteMode = TEXT("OverwriteMode");
+static LPCTSTR const kShowPassword = TEXT("ShowPassword");
+static LPCTSTR const kPathHistory = TEXT("PathHistory");
+static LPCTSTR const kSplitDest = TEXT("SplitDest");
+static LPCTSTR const kElimDup = TEXT("ElimDup");
+// static LPCTSTR const kAltStreams = TEXT("AltStreams");
+static LPCTSTR const kNtSecur = TEXT("Security");
+
+void CInfo::Save() const
+{
+ CS_LOCK
+ CKey key;
+ CreateMainKey(key, kKeyName);
+
+ if (PathMode_Force)
+ key.SetValue(kExtractMode, (UInt32)PathMode);
+ if (OverwriteMode_Force)
+ key.SetValue(kOverwriteMode, (UInt32)OverwriteMode);
+
+ Key_Set_BoolPair(key, kSplitDest, SplitDest);
+ Key_Set_BoolPair(key, kElimDup, ElimDup);
+ // Key_Set_BoolPair(key, kAltStreams, AltStreams);
+ Key_Set_BoolPair(key, kNtSecur, NtSecurity);
+ Key_Set_BoolPair(key, kShowPassword, ShowPassword);
+
+ key.RecurseDeleteKey(kPathHistory);
+ key.SetValue_Strings(kPathHistory, Paths);
+}
+
+void Save_ShowPassword(bool showPassword)
+{
+ CS_LOCK
+ CKey key;
+ CreateMainKey(key, kKeyName);
+ key.SetValue(kShowPassword, showPassword);
+}
+
+void CInfo::Load()
+{
+ PathMode = NPathMode::kCurPaths;
+ PathMode_Force = false;
+ OverwriteMode = NOverwriteMode::kAsk;
+ OverwriteMode_Force = false;
+
+ SplitDest.Val = true;
+
+ Paths.Clear();
+
+ CS_LOCK
+ CKey key;
+ if (OpenMainKey(key, kKeyName) != ERROR_SUCCESS)
+ return;
+
+ key.GetValue_Strings(kPathHistory, Paths);
+ UInt32 v;
+ if (key.QueryValue(kExtractMode, v) == ERROR_SUCCESS && v <= NPathMode::kAbsPaths)
+ {
+ PathMode = (NPathMode::EEnum)v;
+ PathMode_Force = true;
+ }
+ if (key.QueryValue(kOverwriteMode, v) == ERROR_SUCCESS && v <= NOverwriteMode::kRenameExisting)
+ {
+ OverwriteMode = (NOverwriteMode::EEnum)v;
+ OverwriteMode_Force = true;
+ }
+
+ Key_Get_BoolPair_true(key, kSplitDest, SplitDest);
+
+ Key_Get_BoolPair(key, kElimDup, ElimDup);
+ // Key_Get_BoolPair(key, kAltStreams, AltStreams);
+ Key_Get_BoolPair(key, kNtSecur, NtSecurity);
+ Key_Get_BoolPair(key, kShowPassword, ShowPassword);
+}
+
+bool Read_ShowPassword()
+{
+ CS_LOCK
+ CKey key;
+ bool showPassword = false;
+ if (OpenMainKey(key, kKeyName) != ERROR_SUCCESS)
+ return showPassword;
+ key.GetValue_IfOk(kShowPassword, showPassword);
+ return showPassword;
+}
+
+}
+
+namespace NCompression
+{
+
+static LPCTSTR const kKeyName = TEXT("Compression");
+
+static LPCTSTR const kArcHistory = TEXT("ArcHistory");
+static LPCWSTR const kArchiver = L"Archiver";
+static LPCTSTR const kShowPassword = TEXT("ShowPassword");
+static LPCTSTR const kEncryptHeaders = TEXT("EncryptHeaders");
+
+static LPCTSTR const kOptionsKeyName = TEXT("Options");
+
+static LPCTSTR const kLevel = TEXT("Level");
+static LPCTSTR const kDictionary = TEXT("Dictionary");
+// static LPCTSTR const kDictionaryChain = TEXT("DictionaryChain");
+static LPCTSTR const kOrder = TEXT("Order");
+static LPCTSTR const kBlockSize = TEXT("BlockSize");
+static LPCTSTR const kNumThreads = TEXT("NumThreads");
+static LPCWSTR const kMethod = L"Method";
+static LPCWSTR const kOptions = L"Options";
+static LPCWSTR const kEncryptionMethod = L"EncryptionMethod";
+
+static LPCTSTR const kNtSecur = TEXT("Security");
+static LPCTSTR const kAltStreams = TEXT("AltStreams");
+static LPCTSTR const kHardLinks = TEXT("HardLinks");
+static LPCTSTR const kSymLinks = TEXT("SymLinks");
+static LPCTSTR const kPreserveATime = TEXT("PreserveATime");
+
+static LPCTSTR const kTimePrec = TEXT("TimePrec");
+static LPCTSTR const kMTime = TEXT("MTime");
+static LPCTSTR const kATime = TEXT("ATime");
+static LPCTSTR const kCTime = TEXT("CTime");
+static LPCTSTR const kSetArcMTime = TEXT("SetArcMTime");
+
+static void SetRegString(CKey &key, LPCWSTR name, const UString &value)
+{
+ if (value.IsEmpty())
+ key.DeleteValue(name);
+ else
+ key.SetValue(name, value);
+}
+
+static void GetRegString(CKey &key, LPCWSTR name, UString &value)
+{
+ if (key.QueryValue(name, value) != ERROR_SUCCESS)
+ value.Empty();
+}
+
+static LPCWSTR const kMemUse = L"MemUse"
+ #if defined(MY_CPU_SIZEOF_POINTER) && (MY_CPU_SIZEOF_POINTER == 4)
+ L"32";
+ #else
+ L"64";
+ #endif
+
+void CInfo::Save() const
+{
+ CS_LOCK
+
+ CKey key;
+ CreateMainKey(key, kKeyName);
+
+ Key_Set_BoolPair_Delete_IfNotDef (key, kNtSecur, NtSecurity);
+ Key_Set_BoolPair_Delete_IfNotDef (key, kAltStreams, AltStreams);
+ Key_Set_BoolPair_Delete_IfNotDef (key, kHardLinks, HardLinks);
+ Key_Set_BoolPair_Delete_IfNotDef (key, kSymLinks, SymLinks);
+ Key_Set_BoolPair_Delete_IfNotDef (key, kPreserveATime, PreserveATime);
+
+ key.SetValue(kShowPassword, ShowPassword);
+ key.SetValue(kLevel, (UInt32)Level);
+ key.SetValue(kArchiver, ArcType);
+ key.SetValue(kShowPassword, ShowPassword);
+ key.SetValue(kEncryptHeaders, EncryptHeaders);
+ key.RecurseDeleteKey(kArcHistory);
+ key.SetValue_Strings(kArcHistory, ArcPaths);
+
+ key.RecurseDeleteKey(kOptionsKeyName);
+ {
+ CKey optionsKey;
+ optionsKey.Create(key, kOptionsKeyName);
+ FOR_VECTOR (i, Formats)
+ {
+ const CFormatOptions &fo = Formats[i];
+ CKey fk;
+ fk.Create(optionsKey, fo.FormatID);
+
+ SetRegString(fk, kMethod, fo.Method);
+ SetRegString(fk, kOptions, fo.Options);
+ SetRegString(fk, kEncryptionMethod, fo.EncryptionMethod);
+ SetRegString(fk, kMemUse, fo.MemUse);
+
+ Key_Set_UInt32(fk, kLevel, fo.Level);
+ Key_Set_UInt32(fk, kDictionary, fo.Dictionary);
+ // Key_Set_UInt32(fk, kDictionaryChain, fo.DictionaryChain);
+ Key_Set_UInt32(fk, kOrder, fo.Order);
+ Key_Set_UInt32(fk, kBlockSize, fo.BlockLogSize);
+ Key_Set_UInt32(fk, kNumThreads, fo.NumThreads);
+
+ Key_Set_UInt32(fk, kTimePrec, fo.TimePrec);
+ Key_Set_BoolPair_Delete_IfNotDef (fk, kMTime, fo.MTime);
+ Key_Set_BoolPair_Delete_IfNotDef (fk, kATime, fo.ATime);
+ Key_Set_BoolPair_Delete_IfNotDef (fk, kCTime, fo.CTime);
+ Key_Set_BoolPair_Delete_IfNotDef (fk, kSetArcMTime, fo.SetArcMTime);
+ }
+ }
+}
+
+void CInfo::Load()
+{
+ ArcPaths.Clear();
+ Formats.Clear();
+
+ Level = 5;
+ ArcType = L"7z";
+ ShowPassword = false;
+ EncryptHeaders = false;
+
+ CS_LOCK
+ CKey key;
+
+ if (OpenMainKey(key, kKeyName) != ERROR_SUCCESS)
+ return;
+
+ Key_Get_BoolPair(key, kNtSecur, NtSecurity);
+ Key_Get_BoolPair(key, kAltStreams, AltStreams);
+ Key_Get_BoolPair(key, kHardLinks, HardLinks);
+ Key_Get_BoolPair(key, kSymLinks, SymLinks);
+ Key_Get_BoolPair(key, kPreserveATime, PreserveATime);
+
+ key.GetValue_Strings(kArcHistory, ArcPaths);
+
+ {
+ CKey optionsKey;
+ if (optionsKey.Open(key, kOptionsKeyName, KEY_READ) == ERROR_SUCCESS)
+ {
+ CSysStringVector formatIDs;
+ optionsKey.EnumKeys(formatIDs);
+ FOR_VECTOR (i, formatIDs)
+ {
+ CKey fk;
+ CFormatOptions fo;
+ fo.FormatID = formatIDs[i];
+ if (fk.Open(optionsKey, fo.FormatID, KEY_READ) == ERROR_SUCCESS)
+ {
+ GetRegString(fk, kMethod, fo.Method);
+ GetRegString(fk, kOptions, fo.Options);
+ GetRegString(fk, kEncryptionMethod, fo.EncryptionMethod);
+ GetRegString(fk, kMemUse, fo.MemUse);
+
+ Key_Get_UInt32(fk, kLevel, fo.Level);
+ Key_Get_UInt32(fk, kDictionary, fo.Dictionary);
+ // Key_Get_UInt32(fk, kDictionaryChain, fo.DictionaryChain);
+ Key_Get_UInt32(fk, kOrder, fo.Order);
+ Key_Get_UInt32(fk, kBlockSize, fo.BlockLogSize);
+ Key_Get_UInt32(fk, kNumThreads, fo.NumThreads);
+
+ Key_Get_UInt32(fk, kTimePrec, fo.TimePrec);
+ Key_Get_BoolPair(fk, kMTime, fo.MTime);
+ Key_Get_BoolPair(fk, kATime, fo.ATime);
+ Key_Get_BoolPair(fk, kCTime, fo.CTime);
+ Key_Get_BoolPair(fk, kSetArcMTime, fo.SetArcMTime);
+
+ Formats.Add(fo);
+ }
+ }
+ }
+ }
+
+ UString a;
+ if (key.QueryValue(kArchiver, a) == ERROR_SUCCESS)
+ ArcType = a;
+ key.GetValue_IfOk(kLevel, Level);
+ key.GetValue_IfOk(kShowPassword, ShowPassword);
+ key.GetValue_IfOk(kEncryptHeaders, EncryptHeaders);
+}
+
+
+static bool ParseMemUse(const wchar_t *s, CMemUse &mu)
+{
+ mu.Clear();
+
+ bool percentMode = false;
+ {
+ const wchar_t c = *s;
+ if (MyCharLower_Ascii(c) == 'p')
+ {
+ percentMode = true;
+ s++;
+ }
+ }
+ const wchar_t *end;
+ UInt64 number = ConvertStringToUInt64(s, &end);
+ if (end == s)
+ return false;
+
+ wchar_t c = *end;
+
+ if (percentMode)
+ {
+ if (c != 0)
+ return false;
+ mu.IsPercent = true;
+ mu.Val = number;
+ return true;
+ }
+
+ if (c == 0)
+ {
+ mu.Val = number;
+ return true;
+ }
+
+ c = MyCharLower_Ascii(c);
+
+ const wchar_t c1 = end[1];
+
+ if (c == '%')
+ {
+ if (c1 != 0)
+ return false;
+ mu.IsPercent = true;
+ mu.Val = number;
+ return true;
+ }
+
+ if (c == 'b')
+ {
+ if (c1 != 0)
+ return false;
+ mu.Val = number;
+ return true;
+ }
+
+ if (c1 != 0)
+ if (MyCharLower_Ascii(c1) != 'b' || end[2] != 0)
+ return false;
+
+ unsigned numBits;
+ switch (c)
+ {
+ case 'k': numBits = 10; break;
+ case 'm': numBits = 20; break;
+ case 'g': numBits = 30; break;
+ case 't': numBits = 40; break;
+ default: return false;
+ }
+ if (number >= ((UInt64)1 << (64 - numBits)))
+ return false;
+ mu.Val = number << numBits;
+ return true;
+}
+
+
+void CMemUse::Parse(const UString &s)
+{
+ IsDefined = ParseMemUse(s, *this);
+}
+
+/*
+void MemLimit_Save(const UString &s)
+{
+ CS_LOCK
+ CKey key;
+ CreateMainKey(key, kKeyName);
+ SetRegString(key, kMemUse, s);
+}
+
+bool MemLimit_Load(NCompression::CMemUse &mu)
+{
+ mu.Clear();
+ UString a;
+ {
+ CS_LOCK
+ CKey key;
+ if (OpenMainKey(key, kKeyName) != ERROR_SUCCESS)
+ return false;
+ if (key.QueryValue(kMemUse, a) != ERROR_SUCCESS)
+ return false;
+ }
+ if (a.IsEmpty())
+ return false;
+ mu.Parse(a);
+ return mu.IsDefined;
+}
+*/
+
+}
+
+static LPCTSTR const kOptionsInfoKeyName = TEXT("Options");
+
+namespace NWorkDir
+{
+static LPCTSTR const kWorkDirType = TEXT("WorkDirType");
+static LPCWSTR const kWorkDirPath = L"WorkDirPath";
+static LPCTSTR const kTempRemovableOnly = TEXT("TempRemovableOnly");
+
+
+void CInfo::Save()const
+{
+ CS_LOCK
+ CKey key;
+ CreateMainKey(key, kOptionsInfoKeyName);
+ key.SetValue(kWorkDirType, (UInt32)Mode);
+ key.SetValue(kWorkDirPath, fs2us(Path));
+ key.SetValue(kTempRemovableOnly, ForRemovableOnly);
+}
+
+void CInfo::Load()
+{
+ SetDefault();
+
+ CS_LOCK
+ CKey key;
+ if (OpenMainKey(key, kOptionsInfoKeyName) != ERROR_SUCCESS)
+ return;
+
+ UInt32 dirType;
+ if (key.QueryValue(kWorkDirType, dirType) != ERROR_SUCCESS)
+ return;
+ switch (dirType)
+ {
+ case NMode::kSystem:
+ case NMode::kCurrent:
+ case NMode::kSpecified:
+ Mode = (NMode::EEnum)dirType;
+ }
+ UString pathU;
+ if (key.QueryValue(kWorkDirPath, pathU) == ERROR_SUCCESS)
+ Path = us2fs(pathU);
+ else
+ {
+ Path.Empty();
+ if (Mode == NMode::kSpecified)
+ Mode = NMode::kSystem;
+ }
+ key.GetValue_IfOk(kTempRemovableOnly, ForRemovableOnly);
+}
+
+}
+
+static LPCTSTR const kCascadedMenu = TEXT("CascadedMenu");
+static LPCTSTR const kContextMenu = TEXT("ContextMenu");
+static LPCTSTR const kMenuIcons = TEXT("MenuIcons");
+static LPCTSTR const kElimDup = TEXT("ElimDupExtract");
+static LPCTSTR const kWriteZoneId = TEXT("WriteZoneIdExtract");
+
+void CContextMenuInfo::Save() const
+{
+ CS_LOCK
+ CKey key;
+ CreateMainKey(key, kOptionsInfoKeyName);
+
+ Key_Set_BoolPair(key, kCascadedMenu, Cascaded);
+ Key_Set_BoolPair(key, kMenuIcons, MenuIcons);
+ Key_Set_BoolPair(key, kElimDup, ElimDup);
+
+ Key_Set_UInt32(key, kWriteZoneId, WriteZone);
+
+ if (Flags_Def)
+ key.SetValue(kContextMenu, Flags);
+}
+
+void CContextMenuInfo::Load()
+{
+ Cascaded.Val = true;
+ Cascaded.Def = false;
+
+ MenuIcons.Val = false;
+ MenuIcons.Def = false;
+
+ ElimDup.Val = true;
+ ElimDup.Def = false;
+
+ WriteZone = (UInt32)(Int32)-1;
+
+ /* we can disable email items by default,
+ because email code doesn't work in some systems */
+ Flags = (UInt32)(Int32)-1
+ /*
+ & ~NContextMenuFlags::kCompressEmail
+ & ~NContextMenuFlags::kCompressTo7zEmail
+ & ~NContextMenuFlags::kCompressToZipEmail
+ */
+ ;
+ Flags_Def = false;
+
+ CS_LOCK
+
+ CKey key;
+ if (OpenMainKey(key, kOptionsInfoKeyName) != ERROR_SUCCESS)
+ return;
+
+ Key_Get_BoolPair_true(key, kCascadedMenu, Cascaded);
+ Key_Get_BoolPair_true(key, kElimDup, ElimDup);
+ Key_Get_BoolPair(key, kMenuIcons, MenuIcons);
+
+ Key_Get_UInt32(key, kWriteZoneId, WriteZone);
+
+ Flags_Def = (key.GetValue_IfOk(kContextMenu, Flags) == ERROR_SUCCESS);
+}
diff --git a/CPP/7zip/UI/Common/ZipRegistry.h b/CPP/7zip/UI/Common/ZipRegistry.h
index 4c16b61..6bc6977 100644
--- a/CPP/7zip/UI/Common/ZipRegistry.h
+++ b/CPP/7zip/UI/Common/ZipRegistry.h
@@ -1,130 +1,209 @@
-// ZipRegistry.h
-
-#ifndef __ZIP_REGISTRY_H
-#define __ZIP_REGISTRY_H
-
-#include "../../../Common/MyTypes.h"
-#include "../../../Common/MyString.h"
-
-#include "ExtractMode.h"
-
-namespace NExtract
-{
- struct CInfo
- {
- NPathMode::EEnum PathMode;
- NOverwriteMode::EEnum OverwriteMode;
- bool PathMode_Force;
- bool OverwriteMode_Force;
-
- CBoolPair SplitDest;
- CBoolPair ElimDup;
- // CBoolPair AltStreams;
- CBoolPair NtSecurity;
- CBoolPair ShowPassword;
-
- UStringVector Paths;
-
- void Save() const;
- void Load();
- };
-
- void Save_ShowPassword(bool showPassword);
- bool Read_ShowPassword();
-}
-
-namespace NCompression
-{
- struct CFormatOptions
- {
- UInt32 Level;
- UInt32 Dictionary;
- UInt32 Order;
- UInt32 BlockLogSize;
- UInt32 NumThreads;
-
- CSysString FormatID;
- UString Method;
- UString Options;
- UString EncryptionMethod;
-
- void Reset_BlockLogSize()
- {
- BlockLogSize = (UInt32)(Int32)-1;
- }
-
- void ResetForLevelChange()
- {
- BlockLogSize = NumThreads = Level = Dictionary = Order = (UInt32)(Int32)-1;
- Method.Empty();
- // Options.Empty();
- // EncryptionMethod.Empty();
- }
- CFormatOptions() { ResetForLevelChange(); }
- };
-
- struct CInfo
- {
- UInt32 Level;
- bool ShowPassword;
- bool EncryptHeaders;
- UString ArcType;
- UStringVector ArcPaths;
-
- CObjectVector<CFormatOptions> Formats;
-
- CBoolPair NtSecurity;
- CBoolPair AltStreams;
- CBoolPair HardLinks;
- CBoolPair SymLinks;
-
- void Save() const;
- void Load();
- };
-}
-
-namespace NWorkDir
-{
- namespace NMode
- {
- enum EEnum
- {
- kSystem,
- kCurrent,
- kSpecified
- };
- }
- struct CInfo
- {
- NMode::EEnum Mode;
- FString Path;
- bool ForRemovableOnly;
-
- void SetForRemovableOnlyDefault() { ForRemovableOnly = true; }
- void SetDefault()
- {
- Mode = NMode::kSystem;
- Path.Empty();
- SetForRemovableOnlyDefault();
- }
-
- void Save() const;
- void Load();
- };
-}
-
-
-struct CContextMenuInfo
-{
- CBoolPair Cascaded;
- CBoolPair MenuIcons;
- CBoolPair ElimDup;
-
- bool Flags_Def;
- UInt32 Flags;
-
- void Save() const;
- void Load();
-};
-
-#endif
+// ZipRegistry.h
+
+#ifndef ZIP7_INC_ZIP_REGISTRY_H
+#define ZIP7_INC_ZIP_REGISTRY_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+#include "../../Common/MethodProps.h"
+
+#include "ExtractMode.h"
+
+/*
+CBoolPair::Def in writing functions means:
+ if ( CBoolPair::Def ), we write CBoolPair::Val
+ if ( !CBoolPair::Def )
+ {
+ in NCompression functions we delete registry value
+ in another functions we do nothing
+ }
+*/
+
+namespace NExtract
+{
+ struct CInfo
+ {
+ NPathMode::EEnum PathMode;
+ NOverwriteMode::EEnum OverwriteMode;
+ bool PathMode_Force;
+ bool OverwriteMode_Force;
+
+ CBoolPair SplitDest;
+ CBoolPair ElimDup;
+ // CBoolPair AltStreams;
+ CBoolPair NtSecurity;
+ CBoolPair ShowPassword;
+
+ UStringVector Paths;
+
+ void Save() const;
+ void Load();
+ };
+
+ void Save_ShowPassword(bool showPassword);
+ bool Read_ShowPassword();
+}
+
+namespace NCompression
+{
+ struct CMemUse
+ {
+ // UString Str;
+ bool IsDefined;
+ bool IsPercent;
+ UInt64 Val;
+
+ CMemUse():
+ IsDefined(false),
+ IsPercent(false),
+ Val(0)
+ {}
+
+ void Clear()
+ {
+ // Str.Empty();
+ IsDefined = false;
+ IsPercent = false;
+ Val = 0;
+ }
+
+ UInt64 GetBytes(UInt64 ramSize) const
+ {
+ if (!IsPercent)
+ return Val;
+ return Calc_From_Val_Percents(ramSize, Val);
+ }
+ void Parse(const UString &s);
+ };
+
+ struct CFormatOptions
+ {
+ UInt32 Level;
+ UInt32 Dictionary;
+ // UInt32 DictionaryChain;
+ UInt32 Order;
+ UInt32 BlockLogSize;
+ UInt32 NumThreads;
+
+ UInt32 TimePrec;
+ CBoolPair MTime;
+ CBoolPair ATime;
+ CBoolPair CTime;
+ CBoolPair SetArcMTime;
+
+ CSysString FormatID;
+ UString Method;
+ UString Options;
+ UString EncryptionMethod;
+ UString MemUse;
+
+ void Reset_TimePrec()
+ {
+ TimePrec = (UInt32)(Int32)-1;
+ }
+
+ bool IsSet_TimePrec() const
+ {
+ return TimePrec != (UInt32)(Int32)-1;
+ }
+
+
+ void Reset_BlockLogSize()
+ {
+ BlockLogSize = (UInt32)(Int32)-1;
+ }
+
+ void ResetForLevelChange()
+ {
+ BlockLogSize = NumThreads = Level = Dictionary = Order = (UInt32)(Int32)-1;
+ // DictionaryChain = (UInt32)(Int32)-1;
+ Method.Empty();
+ // Options.Empty();
+ // EncryptionMethod.Empty();
+ }
+ CFormatOptions()
+ {
+ // TimePrec = 0;
+ Reset_TimePrec();
+ ResetForLevelChange();
+ }
+ };
+
+ struct CInfo
+ {
+ UInt32 Level;
+ bool ShowPassword;
+ bool EncryptHeaders;
+
+ CBoolPair NtSecurity;
+ CBoolPair AltStreams;
+ CBoolPair HardLinks;
+ CBoolPair SymLinks;
+
+ CBoolPair PreserveATime;
+
+ UString ArcType;
+ UStringVector ArcPaths;
+
+ CObjectVector<CFormatOptions> Formats;
+
+ void Save() const;
+ void Load();
+ };
+}
+
+namespace NWorkDir
+{
+ namespace NMode
+ {
+ enum EEnum
+ {
+ kSystem,
+ kCurrent,
+ kSpecified
+ };
+ }
+ struct CInfo
+ {
+ NMode::EEnum Mode;
+ bool ForRemovableOnly;
+ FString Path;
+
+ void SetForRemovableOnlyDefault() { ForRemovableOnly = true; }
+ void SetDefault()
+ {
+ Mode = NMode::kSystem;
+ Path.Empty();
+ SetForRemovableOnlyDefault();
+ }
+
+ void Save() const;
+ void Load();
+ };
+}
+
+
+struct CContextMenuInfo
+{
+ CBoolPair Cascaded;
+ CBoolPair MenuIcons;
+ CBoolPair ElimDup;
+
+ bool Flags_Def;
+ UInt32 Flags;
+ UInt32 WriteZone;
+
+ /*
+ CContextMenuInfo():
+ Flags_Def(0),
+ WriteZone((UInt32)(Int32)-1),
+ Flags((UInt32)(Int32)-1)
+ {}
+ */
+
+ void Save() const;
+ void Load();
+};
+
+#endif
diff --git a/CPP/7zip/UI/Console/BenchCon.cpp b/CPP/7zip/UI/Console/BenchCon.cpp
index 9cf8dd6..113f584 100644
--- a/CPP/7zip/UI/Console/BenchCon.cpp
+++ b/CPP/7zip/UI/Console/BenchCon.cpp
@@ -1,41 +1,41 @@
-// BenchCon.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/Bench.h"
-
-#include "BenchCon.h"
-#include "ConsoleClose.h"
-
-struct CPrintBenchCallback: public IBenchPrintCallback
-{
- FILE *_file;
-
- void Print(const char *s);
- void NewLine();
- HRESULT CheckBreak();
-};
-
-void CPrintBenchCallback::Print(const char *s)
-{
- fputs(s, _file);
-}
-
-void CPrintBenchCallback::NewLine()
-{
- fputc('\n', _file);
-}
-
-HRESULT CPrintBenchCallback::CheckBreak()
-{
- return NConsoleClose::TestBreakSignal() ? E_ABORT: S_OK;
-}
-
-HRESULT BenchCon(DECL_EXTERNAL_CODECS_LOC_VARS
- const CObjectVector<CProperty> &props, UInt32 numIterations, FILE *f)
-{
- CPrintBenchCallback callback;
- callback._file = f;
- return Bench(EXTERNAL_CODECS_LOC_VARS
- &callback, NULL, props, numIterations, true);
-}
+// BenchCon.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/Bench.h"
+
+#include "BenchCon.h"
+#include "ConsoleClose.h"
+
+struct CPrintBenchCallback Z7_final: public IBenchPrintCallback
+{
+ FILE *_file;
+
+ void Print(const char *s) Z7_override;
+ void NewLine() Z7_override;
+ HRESULT CheckBreak() Z7_override;
+};
+
+void CPrintBenchCallback::Print(const char *s)
+{
+ fputs(s, _file);
+}
+
+void CPrintBenchCallback::NewLine()
+{
+ fputc('\n', _file);
+}
+
+HRESULT CPrintBenchCallback::CheckBreak()
+{
+ return NConsoleClose::TestBreakSignal() ? E_ABORT: S_OK;
+}
+
+HRESULT BenchCon(DECL_EXTERNAL_CODECS_LOC_VARS
+ const CObjectVector<CProperty> &props, UInt32 numIterations, FILE *f)
+{
+ CPrintBenchCallback callback;
+ callback._file = f;
+ return Bench(EXTERNAL_CODECS_LOC_VARS
+ &callback, NULL, props, numIterations, true);
+}
diff --git a/CPP/7zip/UI/Console/BenchCon.h b/CPP/7zip/UI/Console/BenchCon.h
index ef235ee..844cc2a 100644
--- a/CPP/7zip/UI/Console/BenchCon.h
+++ b/CPP/7zip/UI/Console/BenchCon.h
@@ -1,14 +1,14 @@
-// BenchCon.h
-
-#ifndef __BENCH_CON_H
-#define __BENCH_CON_H
-
-#include <stdio.h>
-
-#include "../../Common/CreateCoder.h"
-#include "../../UI/Common/Property.h"
-
-HRESULT BenchCon(DECL_EXTERNAL_CODECS_LOC_VARS
- const CObjectVector<CProperty> &props, UInt32 numIterations, FILE *f);
-
-#endif
+// BenchCon.h
+
+#ifndef ZIP7_INC_BENCH_CON_H
+#define ZIP7_INC_BENCH_CON_H
+
+#include <stdio.h>
+
+#include "../../Common/CreateCoder.h"
+#include "../../UI/Common/Property.h"
+
+HRESULT BenchCon(DECL_EXTERNAL_CODECS_LOC_VARS
+ const CObjectVector<CProperty> &props, UInt32 numIterations, FILE *f);
+
+#endif
diff --git a/CPP/7zip/UI/Console/Console.dsp b/CPP/7zip/UI/Console/Console.dsp
new file mode 100644
index 0000000..26e8c7f
--- /dev/null
+++ b/CPP/7zip/UI/Console/Console.dsp
@@ -0,0 +1,1040 @@
+# Microsoft Developer Studio Project File - Name="Console" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Console - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Console.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Console.mak" CFG="Console - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Console - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Console - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "Console - Win32 ReleaseU" (based on "Win32 (x86) Console Application")
+!MESSAGE "Console - Win32 DebugU" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Console - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /FAcs /Yu"StdAfx.h" /FD /GF /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\UTIL\7z.exe" /OPT:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Console - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gr /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /FAcs /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\UTIL\7z.exe" /pdbtype:sept /ignore:4033
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Console - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Console___Win32_ReleaseU"
+# PROP BASE Intermediate_Dir "Console___Win32_ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /Gz /MD /W3 /GX /O1 /I "../../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\UTIL\7z.exe"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"C:\UTIL\7zn.exe" /OPT:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Console - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Console___Win32_DebugU"
+# PROP BASE Intermediate_Dir "Console___Win32_DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /Gz /W3 /Gm /GX /ZI /Od /I "../../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gr /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_CONSOLE" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_LARGE_PAGES" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\UTIL\7z.exe" /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"C:\UTIL\7z.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Console - Win32 Release"
+# Name "Console - Win32 Debug"
+# Name "Console - Win32 ReleaseU"
+# Name "Console - Win32 DebugU"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Console"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\BenchCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BenchCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ConsoleClose.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ConsoleClose.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\HashCon.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\HashCon.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\List.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\List.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MainAr.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\OpenCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\OpenCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PercentPrinter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PercentPrinter.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackConsole.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackConsole.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UserInputUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UserInputUtils.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyGuidDef.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdInStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StdOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\ArchiveCommandLine.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveCommandLine.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Bench.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Bench.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\TempFiles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\TempFiles.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Update.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Update.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "7-zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\RegisterArc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+
+!IF "$(CFG)" == "Console - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Console - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Console - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "Console - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "ArchiveCommon"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# End Group
+# Begin Group "Asm"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\7zAsm.asm
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\Asm\x86\7zCrcOpt.asm
+
+!IF "$(CFG)" == "Console - Win32 Release"
+
+# Begin Custom Build
+OutDir=.\Release
+InputPath=..\..\..\..\Asm\x86\7zCrcOpt.asm
+InputName=7zCrcOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Console - Win32 Debug"
+
+# Begin Custom Build
+OutDir=.\Debug
+InputPath=..\..\..\..\Asm\x86\7zCrcOpt.asm
+InputName=7zCrcOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -omf -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Console - Win32 ReleaseU"
+
+# Begin Custom Build
+OutDir=.\ReleaseU
+InputPath=..\..\..\..\Asm\x86\7zCrcOpt.asm
+InputName=7zCrcOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Console - Win32 DebugU"
+
+# Begin Custom Build
+OutDir=.\DebugU
+InputPath=..\..\..\..\Asm\x86\7zCrcOpt.asm
+InputName=7zCrcOpt
+
+"$(OutDir)\$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ ml.exe -c -omf -Fo$(OutDir)\$(InputName).obj $(InputPath)
+
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/Console/Console.dsw b/CPP/7zip/UI/Console/Console.dsw
new file mode 100644
index 0000000..0d93da2
--- /dev/null
+++ b/CPP/7zip/UI/Console/Console.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Console"=".\Console.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/Console/Console.mak b/CPP/7zip/UI/Console/Console.mak
index d4268c5..1a47bfa 100644
--- a/CPP/7zip/UI/Console/Console.mak
+++ b/CPP/7zip/UI/Console/Console.mak
@@ -1,43 +1,45 @@
-MY_CONSOLE = 1
-
-!IFNDEF UNDER_CE
-CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -D_7ZIP_LARGE_PAGES -DSUPPORT_DEVICE_FILE
-!ENDIF
-
-CONSOLE_OBJS = \
- $O\BenchCon.obj \
- $O\ConsoleClose.obj \
- $O\ExtractCallbackConsole.obj \
- $O\HashCon.obj \
- $O\List.obj \
- $O\Main.obj \
- $O\MainAr.obj \
- $O\OpenCallbackConsole.obj \
- $O\PercentPrinter.obj \
- $O\UpdateCallbackConsole.obj \
- $O\UserInputUtils.obj \
-
-UI_COMMON_OBJS = \
- $O\ArchiveCommandLine.obj \
- $O\ArchiveExtractCallback.obj \
- $O\ArchiveOpenCallback.obj \
- $O\Bench.obj \
- $O\DefaultName.obj \
- $O\EnumDirItems.obj \
- $O\Extract.obj \
- $O\ExtractingFilePath.obj \
- $O\HashCalc.obj \
- $O\LoadCodecs.obj \
- $O\OpenArchive.obj \
- $O\PropIDUtils.obj \
- $O\SetProperties.obj \
- $O\SortUtils.obj \
- $O\TempFiles.obj \
- $O\Update.obj \
- $O\UpdateAction.obj \
- $O\UpdateCallback.obj \
- $O\UpdatePair.obj \
- $O\UpdateProduce.obj \
-
-C_OBJS = $(C_OBJS) \
- $O\DllSecur.obj \
+MY_CONSOLE = 1
+
+!IFNDEF UNDER_CE
+CFLAGS = $(CFLAGS) -DZ7_LONG_PATH -DZ7_LARGE_PAGES -DZ7_DEVICE_FILE
+!ENDIF
+
+CONSOLE_OBJS = \
+ $O\BenchCon.obj \
+ $O\ConsoleClose.obj \
+ $O\ExtractCallbackConsole.obj \
+ $O\HashCon.obj \
+ $O\List.obj \
+ $O\Main.obj \
+ $O\MainAr.obj \
+ $O\OpenCallbackConsole.obj \
+ $O\PercentPrinter.obj \
+ $O\UpdateCallbackConsole.obj \
+ $O\UserInputUtils.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveCommandLine.obj \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\Bench.obj \
+ $O\DefaultName.obj \
+ $O\EnumDirItems.obj \
+ $O\Extract.obj \
+ $O\ExtractingFilePath.obj \
+ $O\HashCalc.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+ $O\PropIDUtils.obj \
+ $O\SetProperties.obj \
+ $O\SortUtils.obj \
+ $O\TempFiles.obj \
+ $O\Update.obj \
+ $O\UpdateAction.obj \
+ $O\UpdateCallback.obj \
+ $O\UpdatePair.obj \
+ $O\UpdateProduce.obj \
+
+C_OBJS = $(C_OBJS) \
+ $O\DllSecur.obj \
+
+# we need empty line after last line above
diff --git a/CPP/7zip/UI/Console/Console.manifest b/CPP/7zip/UI/Console/Console.manifest
index 77ecaad..c932b28 100644
--- a/CPP/7zip/UI/Console/Console.manifest
+++ b/CPP/7zip/UI/Console/Console.manifest
@@ -1,13 +1,16 @@
-<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
-<assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7z" type="win32"></assemblyIdentity>
-<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-<security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false">
-</requestedExecutionLevel></requestedPrivileges></security></trustInfo>
-<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
-<!-- Vista --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
-<!-- Win 7 --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
-<!-- Win 8 --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
-<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
-<!-- Win 10 --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
-</application></compatibility>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+<assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7z" type="win32"></assemblyIdentity>
+<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+<security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false">
+</requestedExecutionLevel></requestedPrivileges></security></trustInfo>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7 --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8 --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10 --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+<application xmlns="urn:schemas-microsoft-com:asm.v3">
+<windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
+<ws2:longPathAware>true</ws2:longPathAware></windowsSettings></application>
</assembly>
\ No newline at end of file
diff --git a/CPP/7zip/UI/Console/ConsoleClose.cpp b/CPP/7zip/UI/Console/ConsoleClose.cpp
index a6f17af..9e4c040 100644
--- a/CPP/7zip/UI/Console/ConsoleClose.cpp
+++ b/CPP/7zip/UI/Console/ConsoleClose.cpp
@@ -1,69 +1,100 @@
-// ConsoleClose.cpp
-
-#include "StdAfx.h"
-
-#include "ConsoleClose.h"
-
-#if !defined(UNDER_CE) && defined(_WIN32)
-#include "../../../Common/MyWindows.h"
-#endif
-
-namespace NConsoleClose {
-
-unsigned g_BreakCounter = 0;
-static const unsigned kBreakAbortThreshold = 2;
-
-#if !defined(UNDER_CE) && defined(_WIN32)
-static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
-{
- if (ctrlType == CTRL_LOGOFF_EVENT)
- {
- // printf("\nCTRL_LOGOFF_EVENT\n");
- return TRUE;
- }
-
- g_BreakCounter++;
- if (g_BreakCounter < kBreakAbortThreshold)
- return TRUE;
- return FALSE;
- /*
- switch (ctrlType)
- {
- case CTRL_C_EVENT:
- case CTRL_BREAK_EVENT:
- if (g_BreakCounter < kBreakAbortThreshold)
- return TRUE;
- }
- return FALSE;
- */
-}
-#endif
-
-/*
-void CheckCtrlBreak()
-{
- if (TestBreakSignal())
- throw CCtrlBreakException();
-}
-*/
-
-CCtrlHandlerSetter::CCtrlHandlerSetter()
-{
- #if !defined(UNDER_CE) && defined(_WIN32)
- if (!SetConsoleCtrlHandler(HandlerRoutine, TRUE))
- throw "SetConsoleCtrlHandler fails";
- #endif
-}
-
-CCtrlHandlerSetter::~CCtrlHandlerSetter()
-{
- #if !defined(UNDER_CE) && defined(_WIN32)
- if (!SetConsoleCtrlHandler(HandlerRoutine, FALSE))
- {
- // warning for throw in destructor.
- // throw "SetConsoleCtrlHandler fails";
- }
- #endif
-}
-
-}
+// ConsoleClose.cpp
+
+#include "StdAfx.h"
+
+#include "ConsoleClose.h"
+
+#ifndef UNDER_CE
+
+#ifdef _WIN32
+#include "../../../Common/MyWindows.h"
+#else
+#include <stdlib.h>
+#include <signal.h>
+#endif
+
+namespace NConsoleClose {
+
+unsigned g_BreakCounter = 0;
+static const unsigned kBreakAbortThreshold = 2;
+
+#ifdef _WIN32
+
+static BOOL WINAPI HandlerRoutine(DWORD ctrlType)
+{
+ if (ctrlType == CTRL_LOGOFF_EVENT)
+ {
+ // printf("\nCTRL_LOGOFF_EVENT\n");
+ return TRUE;
+ }
+
+ g_BreakCounter++;
+ if (g_BreakCounter < kBreakAbortThreshold)
+ return TRUE;
+ return FALSE;
+ /*
+ switch (ctrlType)
+ {
+ case CTRL_C_EVENT:
+ case CTRL_BREAK_EVENT:
+ if (g_BreakCounter < kBreakAbortThreshold)
+ return TRUE;
+ }
+ return FALSE;
+ */
+}
+
+CCtrlHandlerSetter::CCtrlHandlerSetter()
+{
+ if (!SetConsoleCtrlHandler(HandlerRoutine, TRUE))
+ throw "SetConsoleCtrlHandler fails";
+}
+
+CCtrlHandlerSetter::~CCtrlHandlerSetter()
+{
+ if (!SetConsoleCtrlHandler(HandlerRoutine, FALSE))
+ {
+ // warning for throw in destructor.
+ // throw "SetConsoleCtrlHandler fails";
+ }
+}
+
+#else // _WIN32
+
+static void HandlerRoutine(int)
+{
+ g_BreakCounter++;
+ if (g_BreakCounter < kBreakAbortThreshold)
+ return;
+ exit(EXIT_FAILURE);
+}
+
+CCtrlHandlerSetter::CCtrlHandlerSetter()
+{
+ memo_sig_int = signal(SIGINT, HandlerRoutine); // CTRL-C
+ if (memo_sig_int == SIG_ERR)
+ throw "SetConsoleCtrlHandler fails (SIGINT)";
+ memo_sig_term = signal(SIGTERM, HandlerRoutine); // for kill -15 (before "kill -9")
+ if (memo_sig_term == SIG_ERR)
+ throw "SetConsoleCtrlHandler fails (SIGTERM)";
+}
+
+CCtrlHandlerSetter::~CCtrlHandlerSetter()
+{
+ signal(SIGINT, memo_sig_int); // CTRL-C
+ signal(SIGTERM, memo_sig_term); // kill {pid}
+}
+
+#endif // _WIN32
+
+/*
+void CheckCtrlBreak()
+{
+ if (TestBreakSignal())
+ throw CCtrlBreakException();
+}
+*/
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Console/ConsoleClose.h b/CPP/7zip/UI/Console/ConsoleClose.h
index 0a0bbf0..25c5d0c 100644
--- a/CPP/7zip/UI/Console/ConsoleClose.h
+++ b/CPP/7zip/UI/Console/ConsoleClose.h
@@ -1,33 +1,39 @@
-// ConsoleClose.h
-
-#ifndef __CONSOLE_CLOSE_H
-#define __CONSOLE_CLOSE_H
-
-namespace NConsoleClose {
-
-extern unsigned g_BreakCounter;
-
-inline bool TestBreakSignal()
-{
- #ifdef UNDER_CE
- return false;
- #else
- return (g_BreakCounter != 0);
- #endif
-}
-
-class CCtrlHandlerSetter
-{
-public:
- CCtrlHandlerSetter();
- virtual ~CCtrlHandlerSetter();
-};
-
-class CCtrlBreakException
-{};
-
-// void CheckCtrlBreak();
-
-}
-
-#endif
+// ConsoleClose.h
+
+#ifndef ZIP7_INC_CONSOLE_CLOSE_H
+#define ZIP7_INC_CONSOLE_CLOSE_H
+
+namespace NConsoleClose {
+
+class CCtrlBreakException {};
+
+#ifdef UNDER_CE
+
+inline bool TestBreakSignal() { return false; }
+struct CCtrlHandlerSetter {};
+
+#else
+
+extern unsigned g_BreakCounter;
+
+inline bool TestBreakSignal()
+{
+ return (g_BreakCounter != 0);
+}
+
+class CCtrlHandlerSetter Z7_final
+{
+ #ifndef _WIN32
+ void (*memo_sig_int)(int);
+ void (*memo_sig_term)(int);
+ #endif
+public:
+ CCtrlHandlerSetter();
+ ~CCtrlHandlerSetter();
+};
+
+#endif
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp b/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp
index bdf9549..dd7a214 100644
--- a/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp
+++ b/CPP/7zip/UI/Console/ExtractCallbackConsole.cpp
@@ -1,825 +1,849 @@
-// ExtractCallbackConsole.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/TimeUtils.h"
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#ifndef _7ZIP_ST
-#include "../../../Windows/Synchronization.h"
-#endif
-
-#include "../../Common/FilePathAutoRename.h"
-
-#include "../Common/ExtractingFilePath.h"
-
-#include "ConsoleClose.h"
-#include "ExtractCallbackConsole.h"
-#include "UserInputUtils.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static HRESULT CheckBreak2()
-{
- return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
-}
-
-static const char * const kError = "ERROR: ";
-
-
-void CExtractScanConsole::StartScanning()
-{
- if (NeedPercents())
- _percent.Command = "Scan";
-}
-
-HRESULT CExtractScanConsole::ScanProgress(const CDirItemsStat &st, const FString &path, bool /* isDir */)
-{
- if (NeedPercents())
- {
- _percent.Files = st.NumDirs + st.NumFiles;
- _percent.Completed = st.GetTotalBytes();
- _percent.FileName = fs2us(path);
- _percent.Print();
- }
-
- return CheckBreak2();
-}
-
-HRESULT CExtractScanConsole::ScanError(const FString &path, DWORD systemError)
-{
- ClosePercentsAndFlush();
-
- if (_se)
- {
- *_se << endl << kError << NError::MyFormatMessage(systemError) << endl;
- _se->NormalizePrint_UString(fs2us(path));
- *_se << endl << endl;
- _se->Flush();
- }
- return HRESULT_FROM_WIN32(systemError);
-}
-
-
-void Print_UInt64_and_String(AString &s, UInt64 val, const char *name)
-{
- char temp[32];
- ConvertUInt64ToString(val, temp);
- s += temp;
- s.Add_Space();
- s += name;
-}
-
-void PrintSize_bytes_Smart(AString &s, UInt64 val)
-{
- Print_UInt64_and_String(s, val, "bytes");
-
- if (val == 0)
- return;
-
- unsigned numBits = 10;
- char c = 'K';
- char temp[4] = { 'K', 'i', 'B', 0 };
- if (val >= ((UInt64)10 << 30)) { numBits = 30; c = 'G'; }
- else if (val >= ((UInt64)10 << 20)) { numBits = 20; c = 'M'; }
- temp[0] = c;
- s += " (";
- Print_UInt64_and_String(s, ((val + ((UInt64)1 << numBits) - 1) >> numBits), temp);
- s += ')';
-}
-
-void PrintSize_bytes_Smart_comma(AString &s, UInt64 val)
-{
- if (val == (UInt64)(Int64)-1)
- return;
- s += ", ";
- PrintSize_bytes_Smart(s, val);
-}
-
-
-
-void Print_DirItemsStat(AString &s, const CDirItemsStat &st)
-{
- if (st.NumDirs != 0)
- {
- Print_UInt64_and_String(s, st.NumDirs, st.NumDirs == 1 ? "folder" : "folders");
- s += ", ";
- }
- Print_UInt64_and_String(s, st.NumFiles, st.NumFiles == 1 ? "file" : "files");
- PrintSize_bytes_Smart_comma(s, st.FilesSize);
- if (st.NumAltStreams != 0)
- {
- s.Add_LF();
- Print_UInt64_and_String(s, st.NumAltStreams, "alternate streams");
- PrintSize_bytes_Smart_comma(s, st.AltStreamsSize);
- }
-}
-
-
-void Print_DirItemsStat2(AString &s, const CDirItemsStat2 &st)
-{
- Print_DirItemsStat(s, (CDirItemsStat &)st);
- bool needLF = true;
- if (st.Anti_NumDirs != 0)
- {
- if (needLF)
- s.Add_LF();
- needLF = false;
- Print_UInt64_and_String(s, st.Anti_NumDirs, st.Anti_NumDirs == 1 ? "anti-folder" : "anti-folders");
- }
- if (st.Anti_NumFiles != 0)
- {
- if (needLF)
- s.Add_LF();
- else
- s += ", ";
- needLF = false;
- Print_UInt64_and_String(s, st.Anti_NumFiles, st.Anti_NumFiles == 1 ? "anti-file" : "anti-files");
- }
- if (st.Anti_NumAltStreams != 0)
- {
- if (needLF)
- s.Add_LF();
- else
- s += ", ";
- needLF = false;
- Print_UInt64_and_String(s, st.Anti_NumAltStreams, "anti-alternate-streams");
- }
-}
-
-
-void CExtractScanConsole::PrintStat(const CDirItemsStat &st)
-{
- if (_so)
- {
- AString s;
- Print_DirItemsStat(s, st);
- *_so << s << endl;
- }
-}
-
-
-
-
-
-
-
-#ifndef _7ZIP_ST
-static NSynchronization::CCriticalSection g_CriticalSection;
-#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
-#else
-#define MT_LOCK
-#endif
-
-
-static const char * const kTestString = "T";
-static const char * const kExtractString = "-";
-static const char * const kSkipString = ".";
-
-// static const char * const kCantAutoRename = "can not create file with auto name\n";
-// static const char * const kCantRenameFile = "can not rename existing file\n";
-// static const char * const kCantDeleteOutputFile = "can not delete output file ";
-
-static const char * const kMemoryExceptionMessage = "Can't allocate required memory!";
-
-static const char * const kExtracting = "Extracting archive: ";
-static const char * const kTesting = "Testing archive: ";
-
-static const char * const kEverythingIsOk = "Everything is Ok";
-static const char * const kNoFiles = "No files to process";
-
-static const char * const kUnsupportedMethod = "Unsupported Method";
-static const char * const kCrcFailed = "CRC Failed";
-static const char * const kCrcFailedEncrypted = "CRC Failed in encrypted file. Wrong password?";
-static const char * const kDataError = "Data Error";
-static const char * const kDataErrorEncrypted = "Data Error in encrypted file. Wrong password?";
-static const char * const kUnavailableData = "Unavailable data";
-static const char * const kUnexpectedEnd = "Unexpected end of data";
-static const char * const kDataAfterEnd = "There are some data after the end of the payload data";
-static const char * const kIsNotArc = "Is not archive";
-static const char * const kHeadersError = "Headers Error";
-static const char * const kWrongPassword = "Wrong password";
-
-static const char * const k_ErrorFlagsMessages[] =
-{
- "Is not archive"
- , "Headers Error"
- , "Headers Error in encrypted archive. Wrong password?"
- , "Unavailable start of archive"
- , "Unconfirmed start of archive"
- , "Unexpected end of archive"
- , "There are data after the end of archive"
- , "Unsupported method"
- , "Unsupported feature"
- , "Data Error"
- , "CRC Error"
-};
-
-STDMETHODIMP CExtractCallbackConsole::SetTotal(UInt64 size)
-{
- MT_LOCK
-
- if (NeedPercents())
- {
- _percent.Total = size;
- _percent.Print();
- }
- return CheckBreak2();
-}
-
-STDMETHODIMP CExtractCallbackConsole::SetCompleted(const UInt64 *completeValue)
-{
- MT_LOCK
-
- if (NeedPercents())
- {
- if (completeValue)
- _percent.Completed = *completeValue;
- _percent.Print();
- }
- return CheckBreak2();
-}
-
-static const char * const kTab = " ";
-
-static void PrintFileInfo(CStdOutStream *_so, const wchar_t *path, const FILETIME *ft, const UInt64 *size)
-{
- *_so << kTab << "Path: ";
- _so->NormalizePrint_wstr(path);
- *_so << endl;
- if (size && *size != (UInt64)(Int64)-1)
- {
- AString s;
- PrintSize_bytes_Smart(s, *size);
- *_so << kTab << "Size: " << s << endl;
- }
- if (ft)
- {
- char temp[64];
- if (ConvertUtcFileTimeToString(*ft, temp, kTimestampPrintLevel_SEC))
- *_so << kTab << "Modified: " << temp << endl;
- }
-}
-
-STDMETHODIMP CExtractCallbackConsole::AskOverwrite(
- const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize,
- const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize,
- Int32 *answer)
-{
- MT_LOCK
-
- RINOK(CheckBreak2());
-
- ClosePercentsAndFlush();
-
- if (_so)
- {
- *_so << endl << "Would you like to replace the existing file:\n";
- PrintFileInfo(_so, existName, existTime, existSize);
- *_so << "with the file from archive:\n";
- PrintFileInfo(_so, newName, newTime, newSize);
- }
-
- NUserAnswerMode::EEnum overwriteAnswer = ScanUserYesNoAllQuit(_so);
-
- switch (overwriteAnswer)
- {
- case NUserAnswerMode::kQuit: return E_ABORT;
- case NUserAnswerMode::kNo: *answer = NOverwriteAnswer::kNo; break;
- case NUserAnswerMode::kNoAll: *answer = NOverwriteAnswer::kNoToAll; break;
- case NUserAnswerMode::kYesAll: *answer = NOverwriteAnswer::kYesToAll; break;
- case NUserAnswerMode::kYes: *answer = NOverwriteAnswer::kYes; break;
- case NUserAnswerMode::kAutoRenameAll: *answer = NOverwriteAnswer::kAutoRename; break;
- case NUserAnswerMode::kEof: return E_ABORT;
- case NUserAnswerMode::kError: return E_FAIL;
- default: return E_FAIL;
- }
-
- if (_so)
- {
- *_so << endl;
- if (NeedFlush)
- _so->Flush();
- }
-
- return CheckBreak2();
-}
-
-STDMETHODIMP CExtractCallbackConsole::PrepareOperation(const wchar_t *name, Int32 /* isFolder */, Int32 askExtractMode, const UInt64 *position)
-{
- MT_LOCK
-
- _currentName = name;
-
- const char *s;
- unsigned requiredLevel = 1;
-
- switch (askExtractMode)
- {
- case NArchive::NExtract::NAskMode::kExtract: s = kExtractString; break;
- case NArchive::NExtract::NAskMode::kTest: s = kTestString; break;
- case NArchive::NExtract::NAskMode::kSkip: s = kSkipString; requiredLevel = 2; break;
- default: s = "???"; requiredLevel = 2;
- };
-
- bool show2 = (LogLevel >= requiredLevel && _so);
-
- if (show2)
- {
- ClosePercents_for_so();
-
- _tempA = s;
- if (name)
- _tempA.Add_Space();
- *_so << _tempA;
-
- _tempU.Empty();
- if (name)
- {
- _tempU = name;
- _so->Normalize_UString(_tempU);
- }
- _so->PrintUString(_tempU, _tempA);
- if (position)
- *_so << " <" << *position << ">";
- *_so << endl;
-
- if (NeedFlush)
- _so->Flush();
- }
-
- if (NeedPercents())
- {
- if (PercentsNameLevel >= 1)
- {
- _percent.FileName.Empty();
- _percent.Command.Empty();
- if (PercentsNameLevel > 1 || !show2)
- {
- _percent.Command = s;
- if (name)
- _percent.FileName = name;
- }
- }
- _percent.Print();
- }
-
- return CheckBreak2();
-}
-
-STDMETHODIMP CExtractCallbackConsole::MessageError(const wchar_t *message)
-{
- MT_LOCK
-
- RINOK(CheckBreak2());
-
- NumFileErrors_in_Current++;
- NumFileErrors++;
-
- ClosePercentsAndFlush();
- if (_se)
- {
- *_se << kError << message << endl;
- _se->Flush();
- }
-
- return CheckBreak2();
-}
-
-void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &dest)
-{
- dest.Empty();
- const char *s = NULL;
-
- switch (opRes)
- {
- case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
- s = kUnsupportedMethod;
- break;
- case NArchive::NExtract::NOperationResult::kCRCError:
- s = (encrypted ? kCrcFailedEncrypted : kCrcFailed);
- break;
- case NArchive::NExtract::NOperationResult::kDataError:
- s = (encrypted ? kDataErrorEncrypted : kDataError);
- break;
- case NArchive::NExtract::NOperationResult::kUnavailable:
- s = kUnavailableData;
- break;
- case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
- s = kUnexpectedEnd;
- break;
- case NArchive::NExtract::NOperationResult::kDataAfterEnd:
- s = kDataAfterEnd;
- break;
- case NArchive::NExtract::NOperationResult::kIsNotArc:
- s = kIsNotArc;
- break;
- case NArchive::NExtract::NOperationResult::kHeadersError:
- s = kHeadersError;
- break;
- case NArchive::NExtract::NOperationResult::kWrongPassword:
- s = kWrongPassword;
- break;
- }
-
- dest += kError;
- if (s)
- dest += s;
- else
- {
- dest += "Error #";
- dest.Add_UInt32(opRes);
- }
-}
-
-STDMETHODIMP CExtractCallbackConsole::SetOperationResult(Int32 opRes, Int32 encrypted)
-{
- MT_LOCK
-
- if (opRes == NArchive::NExtract::NOperationResult::kOK)
- {
- if (NeedPercents())
- {
- _percent.Command.Empty();
- _percent.FileName.Empty();
- _percent.Files++;
- }
- }
- else
- {
- NumFileErrors_in_Current++;
- NumFileErrors++;
-
- if (_se)
- {
- ClosePercentsAndFlush();
-
- AString s;
- SetExtractErrorMessage(opRes, encrypted, s);
-
- *_se << s;
- if (!_currentName.IsEmpty())
- {
- *_se << " : ";
- _se->NormalizePrint_UString(_currentName);
- }
- *_se << endl;
- _se->Flush();
- }
- }
-
- return CheckBreak2();
-}
-
-STDMETHODIMP CExtractCallbackConsole::ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name)
-{
- if (opRes != NArchive::NExtract::NOperationResult::kOK)
- {
- _currentName = name;
- return SetOperationResult(opRes, encrypted);
- }
-
- return CheckBreak2();
-}
-
-
-
-#ifndef _NO_CRYPTO
-
-HRESULT CExtractCallbackConsole::SetPassword(const UString &password)
-{
- PasswordIsDefined = true;
- Password = password;
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackConsole::CryptoGetTextPassword(BSTR *password)
-{
- COM_TRY_BEGIN
- MT_LOCK
- return Open_CryptoGetTextPassword(password);
- COM_TRY_END
-}
-
-#endif
-
-HRESULT CExtractCallbackConsole::BeforeOpen(const wchar_t *name, bool testMode)
-{
- RINOK(CheckBreak2());
-
- NumTryArcs++;
- ThereIsError_in_Current = false;
- ThereIsWarning_in_Current = false;
- NumFileErrors_in_Current = 0;
-
- ClosePercents_for_so();
- if (_so)
- {
- *_so << endl << (testMode ? kTesting : kExtracting);
- _so->NormalizePrint_wstr(name);
- *_so << endl;
- }
-
- if (NeedPercents())
- _percent.Command = "Open";
- return S_OK;
-}
-
-HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
-HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
-
-static AString GetOpenArcErrorMessage(UInt32 errorFlags)
-{
- AString s;
-
- for (unsigned i = 0; i < ARRAY_SIZE(k_ErrorFlagsMessages); i++)
- {
- UInt32 f = (1 << i);
- if ((errorFlags & f) == 0)
- continue;
- const char *m = k_ErrorFlagsMessages[i];
- if (!s.IsEmpty())
- s.Add_LF();
- s += m;
- errorFlags &= ~f;
- }
-
- if (errorFlags != 0)
- {
- char sz[16];
- sz[0] = '0';
- sz[1] = 'x';
- ConvertUInt32ToHex(errorFlags, sz + 2);
- if (!s.IsEmpty())
- s.Add_LF();
- s += sz;
- }
-
- return s;
-}
-
-void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags)
-{
- if (errorFlags == 0)
- return;
- so << s << endl << GetOpenArcErrorMessage(errorFlags) << endl;
-}
-
-void Add_Messsage_Pre_ArcType(UString &s, const char *pre, const wchar_t *arcType)
-{
- s.Add_LF();
- s += pre;
- s += " as [";
- s += arcType;
- s += "] archive";
-}
-
-void Print_ErrorFormatIndex_Warning(CStdOutStream *_so, const CCodecs *codecs, const CArc &arc)
-{
- const CArcErrorInfo &er = arc.ErrorInfo;
-
- *_so << "WARNING:\n";
- _so->NormalizePrint_UString(arc.Path);
- UString s;
- if (arc.FormatIndex == er.ErrorFormatIndex)
- {
- s.Add_LF();
- s += "The archive is open with offset";
- }
- else
- {
- Add_Messsage_Pre_ArcType(s, "Can not open the file", codecs->GetFormatNamePtr(er.ErrorFormatIndex));
- Add_Messsage_Pre_ArcType(s, "The file is open", codecs->GetFormatNamePtr(arc.FormatIndex));
- }
-
- *_so << s << endl << endl;
-}
-
-
-HRESULT CExtractCallbackConsole::OpenResult(
- const CCodecs *codecs, const CArchiveLink &arcLink,
- const wchar_t *name, HRESULT result)
-{
- ClosePercents();
-
- if (NeedPercents())
- {
- _percent.Files = 0;
- _percent.Command.Empty();
- _percent.FileName.Empty();
- }
-
-
- ClosePercentsAndFlush();
-
- FOR_VECTOR (level, arcLink.Arcs)
- {
- const CArc &arc = arcLink.Arcs[level];
- const CArcErrorInfo &er = arc.ErrorInfo;
-
- UInt32 errorFlags = er.GetErrorFlags();
-
- if (errorFlags != 0 || !er.ErrorMessage.IsEmpty())
- {
- if (_se)
- {
- *_se << endl;
- if (level != 0)
- {
- _se->NormalizePrint_UString(arc.Path);
- *_se << endl;
- }
- }
-
- if (errorFlags != 0)
- {
- if (_se)
- PrintErrorFlags(*_se, "ERRORS:", errorFlags);
- NumOpenArcErrors++;
- ThereIsError_in_Current = true;
- }
-
- if (!er.ErrorMessage.IsEmpty())
- {
- if (_se)
- *_se << "ERRORS:" << endl << er.ErrorMessage << endl;
- NumOpenArcErrors++;
- ThereIsError_in_Current = true;
- }
-
- if (_se)
- {
- *_se << endl;
- _se->Flush();
- }
- }
-
- UInt32 warningFlags = er.GetWarningFlags();
-
- if (warningFlags != 0 || !er.WarningMessage.IsEmpty())
- {
- if (_so)
- {
- *_so << endl;
- if (level != 0)
- {
- _so->NormalizePrint_UString(arc.Path);
- *_so << endl;
- }
- }
-
- if (warningFlags != 0)
- {
- if (_so)
- PrintErrorFlags(*_so, "WARNINGS:", warningFlags);
- NumOpenArcWarnings++;
- ThereIsWarning_in_Current = true;
- }
-
- if (!er.WarningMessage.IsEmpty())
- {
- if (_so)
- *_so << "WARNINGS:" << endl << er.WarningMessage << endl;
- NumOpenArcWarnings++;
- ThereIsWarning_in_Current = true;
- }
-
- if (_so)
- {
- *_so << endl;
- if (NeedFlush)
- _so->Flush();
- }
- }
-
-
- if (er.ErrorFormatIndex >= 0)
- {
- if (_so)
- {
- Print_ErrorFormatIndex_Warning(_so, codecs, arc);
- if (NeedFlush)
- _so->Flush();
- }
- ThereIsWarning_in_Current = true;
- }
- }
-
- if (result == S_OK)
- {
- if (_so)
- {
- RINOK(Print_OpenArchive_Props(*_so, codecs, arcLink));
- *_so << endl;
- }
- }
- else
- {
- NumCantOpenArcs++;
- if (_so)
- _so->Flush();
- if (_se)
- {
- *_se << kError;
- _se->NormalizePrint_wstr(name);
- *_se << endl;
- HRESULT res = Print_OpenArchive_Error(*_se, codecs, arcLink);
- RINOK(res);
- if (result == S_FALSE)
- {
- }
- else
- {
- if (result == E_OUTOFMEMORY)
- *_se << "Can't allocate required memory";
- else
- *_se << NError::MyFormatMessage(result);
- *_se << endl;
- }
- _se->Flush();
- }
- }
-
-
- return CheckBreak2();
-}
-
-HRESULT CExtractCallbackConsole::ThereAreNoFiles()
-{
- ClosePercents_for_so();
-
- if (_so)
- {
- *_so << endl << kNoFiles << endl;
- if (NeedFlush)
- _so->Flush();
- }
- return CheckBreak2();
-}
-
-HRESULT CExtractCallbackConsole::ExtractResult(HRESULT result)
-{
- MT_LOCK
-
- if (NeedPercents())
- {
- _percent.ClosePrint(true);
- _percent.Command.Empty();
- _percent.FileName.Empty();
- }
-
- if (_so)
- _so->Flush();
-
- if (result == S_OK)
- {
- if (NumFileErrors_in_Current == 0 && !ThereIsError_in_Current)
- {
- if (ThereIsWarning_in_Current)
- NumArcsWithWarnings++;
- else
- NumOkArcs++;
- if (_so)
- *_so << kEverythingIsOk << endl;
- }
- else
- {
- NumArcsWithError++;
- if (_so)
- {
- *_so << endl;
- if (NumFileErrors_in_Current != 0)
- *_so << "Sub items Errors: " << NumFileErrors_in_Current << endl;
- }
- }
- if (_so && NeedFlush)
- _so->Flush();
- }
- else
- {
- NumArcsWithError++;
- if (result == E_ABORT || result == ERROR_DISK_FULL)
- return result;
-
- if (_se)
- {
- *_se << endl << kError;
- if (result == E_OUTOFMEMORY)
- *_se << kMemoryExceptionMessage;
- else
- *_se << NError::MyFormatMessage(result);
- *_se << endl;
- _se->Flush();
- }
- }
-
- return CheckBreak2();
-}
+// ExtractCallbackConsole.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/TimeUtils.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "../../Common/FilePathAutoRename.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "ConsoleClose.h"
+#include "ExtractCallbackConsole.h"
+#include "UserInputUtils.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static HRESULT CheckBreak2()
+{
+ return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
+}
+
+static const char * const kError = "ERROR: ";
+
+
+void CExtractScanConsole::StartScanning()
+{
+ if (NeedPercents())
+ _percent.Command = "Scan";
+}
+
+HRESULT CExtractScanConsole::ScanProgress(const CDirItemsStat &st, const FString &path, bool /* isDir */)
+{
+ if (NeedPercents())
+ {
+ _percent.Files = st.NumDirs + st.NumFiles;
+ _percent.Completed = st.GetTotalBytes();
+ _percent.FileName = fs2us(path);
+ _percent.Print();
+ }
+
+ return CheckBreak2();
+}
+
+HRESULT CExtractScanConsole::ScanError(const FString &path, DWORD systemError)
+{
+ // 22.00:
+ // ScanErrors.AddError(path, systemError);
+
+ ClosePercentsAndFlush();
+
+ if (_se)
+ {
+ *_se << endl << kError << NError::MyFormatMessage(systemError) << endl;
+ _se->NormalizePrint_UString(fs2us(path));
+ *_se << endl << endl;
+ _se->Flush();
+ }
+ return HRESULT_FROM_WIN32(systemError);
+
+ // 22.00: commented
+ // CommonError(path, systemError, true);
+ // return S_OK;
+}
+
+
+void Print_UInt64_and_String(AString &s, UInt64 val, const char *name);
+void Print_UInt64_and_String(AString &s, UInt64 val, const char *name)
+{
+ char temp[32];
+ ConvertUInt64ToString(val, temp);
+ s += temp;
+ s.Add_Space();
+ s += name;
+}
+
+void PrintSize_bytes_Smart(AString &s, UInt64 val);
+void PrintSize_bytes_Smart(AString &s, UInt64 val)
+{
+ Print_UInt64_and_String(s, val, "bytes");
+
+ if (val == 0)
+ return;
+
+ unsigned numBits = 10;
+ char c = 'K';
+ char temp[4] = { 'K', 'i', 'B', 0 };
+ if (val >= ((UInt64)10 << 30)) { numBits = 30; c = 'G'; }
+ else if (val >= ((UInt64)10 << 20)) { numBits = 20; c = 'M'; }
+ temp[0] = c;
+ s += " (";
+ Print_UInt64_and_String(s, ((val + ((UInt64)1 << numBits) - 1) >> numBits), temp);
+ s += ')';
+}
+
+static void PrintSize_bytes_Smart_comma(AString &s, UInt64 val)
+{
+ if (val == (UInt64)(Int64)-1)
+ return;
+ s += ", ";
+ PrintSize_bytes_Smart(s, val);
+}
+
+
+
+void Print_DirItemsStat(AString &s, const CDirItemsStat &st);
+void Print_DirItemsStat(AString &s, const CDirItemsStat &st)
+{
+ if (st.NumDirs != 0)
+ {
+ Print_UInt64_and_String(s, st.NumDirs, st.NumDirs == 1 ? "folder" : "folders");
+ s += ", ";
+ }
+ Print_UInt64_and_String(s, st.NumFiles, st.NumFiles == 1 ? "file" : "files");
+ PrintSize_bytes_Smart_comma(s, st.FilesSize);
+ if (st.NumAltStreams != 0)
+ {
+ s.Add_LF();
+ Print_UInt64_and_String(s, st.NumAltStreams, "alternate streams");
+ PrintSize_bytes_Smart_comma(s, st.AltStreamsSize);
+ }
+}
+
+
+void Print_DirItemsStat2(AString &s, const CDirItemsStat2 &st);
+void Print_DirItemsStat2(AString &s, const CDirItemsStat2 &st)
+{
+ Print_DirItemsStat(s, (CDirItemsStat &)st);
+ bool needLF = true;
+ if (st.Anti_NumDirs != 0)
+ {
+ if (needLF)
+ s.Add_LF();
+ needLF = false;
+ Print_UInt64_and_String(s, st.Anti_NumDirs, st.Anti_NumDirs == 1 ? "anti-folder" : "anti-folders");
+ }
+ if (st.Anti_NumFiles != 0)
+ {
+ if (needLF)
+ s.Add_LF();
+ else
+ s += ", ";
+ needLF = false;
+ Print_UInt64_and_String(s, st.Anti_NumFiles, st.Anti_NumFiles == 1 ? "anti-file" : "anti-files");
+ }
+ if (st.Anti_NumAltStreams != 0)
+ {
+ if (needLF)
+ s.Add_LF();
+ else
+ s += ", ";
+ needLF = false;
+ Print_UInt64_and_String(s, st.Anti_NumAltStreams, "anti-alternate-streams");
+ }
+}
+
+
+void CExtractScanConsole::PrintStat(const CDirItemsStat &st)
+{
+ if (_so)
+ {
+ AString s;
+ Print_DirItemsStat(s, st);
+ *_so << s << endl;
+ }
+}
+
+
+
+
+
+
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+
+static const char * const kTestString = "T";
+static const char * const kExtractString = "-";
+static const char * const kSkipString = ".";
+static const char * const kReadString = "H";
+
+// static const char * const kCantAutoRename = "cannot create file with auto name\n";
+// static const char * const kCantRenameFile = "cannot rename existing file\n";
+// static const char * const kCantDeleteOutputFile = "cannot delete output file ";
+
+static const char * const kMemoryExceptionMessage = "Can't allocate required memory!";
+
+static const char * const kExtracting = "Extracting archive: ";
+static const char * const kTesting = "Testing archive: ";
+
+static const char * const kEverythingIsOk = "Everything is Ok";
+static const char * const kNoFiles = "No files to process";
+
+static const char * const kUnsupportedMethod = "Unsupported Method";
+static const char * const kCrcFailed = "CRC Failed";
+static const char * const kCrcFailedEncrypted = "CRC Failed in encrypted file. Wrong password?";
+static const char * const kDataError = "Data Error";
+static const char * const kDataErrorEncrypted = "Data Error in encrypted file. Wrong password?";
+static const char * const kUnavailableData = "Unavailable data";
+static const char * const kUnexpectedEnd = "Unexpected end of data";
+static const char * const kDataAfterEnd = "There are some data after the end of the payload data";
+static const char * const kIsNotArc = "Is not archive";
+static const char * const kHeadersError = "Headers Error";
+static const char * const kWrongPassword = "Wrong password";
+
+static const char * const k_ErrorFlagsMessages[] =
+{
+ "Is not archive"
+ , "Headers Error"
+ , "Headers Error in encrypted archive. Wrong password?"
+ , "Unavailable start of archive"
+ , "Unconfirmed start of archive"
+ , "Unexpected end of archive"
+ , "There are data after the end of archive"
+ , "Unsupported method"
+ , "Unsupported feature"
+ , "Data Error"
+ , "CRC Error"
+};
+
+Z7_COM7F_IMF(CExtractCallbackConsole::SetTotal(UInt64 size))
+{
+ MT_LOCK
+
+ if (NeedPercents())
+ {
+ _percent.Total = size;
+ _percent.Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::SetCompleted(const UInt64 *completeValue))
+{
+ MT_LOCK
+
+ if (NeedPercents())
+ {
+ if (completeValue)
+ _percent.Completed = *completeValue;
+ _percent.Print();
+ }
+ return CheckBreak2();
+}
+
+static const char * const kTab = " ";
+
+static void PrintFileInfo(CStdOutStream *_so, const wchar_t *path, const FILETIME *ft, const UInt64 *size)
+{
+ *_so << kTab << "Path: ";
+ _so->NormalizePrint_wstr(path);
+ *_so << endl;
+ if (size && *size != (UInt64)(Int64)-1)
+ {
+ AString s;
+ PrintSize_bytes_Smart(s, *size);
+ *_so << kTab << "Size: " << s << endl;
+ }
+ if (ft)
+ {
+ char temp[64];
+ if (ConvertUtcFileTimeToString(*ft, temp, kTimestampPrintLevel_SEC))
+ *_so << kTab << "Modified: " << temp << endl;
+ }
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::AskOverwrite(
+ const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize,
+ const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize,
+ Int32 *answer))
+{
+ MT_LOCK
+
+ RINOK(CheckBreak2())
+
+ ClosePercentsAndFlush();
+
+ if (_so)
+ {
+ *_so << endl << "Would you like to replace the existing file:\n";
+ PrintFileInfo(_so, existName, existTime, existSize);
+ *_so << "with the file from archive:\n";
+ PrintFileInfo(_so, newName, newTime, newSize);
+ }
+
+ NUserAnswerMode::EEnum overwriteAnswer = ScanUserYesNoAllQuit(_so);
+
+ switch ((int)overwriteAnswer)
+ {
+ case NUserAnswerMode::kQuit: return E_ABORT;
+ case NUserAnswerMode::kNo: *answer = NOverwriteAnswer::kNo; break;
+ case NUserAnswerMode::kNoAll: *answer = NOverwriteAnswer::kNoToAll; break;
+ case NUserAnswerMode::kYesAll: *answer = NOverwriteAnswer::kYesToAll; break;
+ case NUserAnswerMode::kYes: *answer = NOverwriteAnswer::kYes; break;
+ case NUserAnswerMode::kAutoRenameAll: *answer = NOverwriteAnswer::kAutoRename; break;
+ case NUserAnswerMode::kEof: return E_ABORT;
+ case NUserAnswerMode::kError: return E_FAIL;
+ default: return E_FAIL;
+ }
+
+ if (_so)
+ {
+ *_so << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::PrepareOperation(const wchar_t *name, Int32 isFolder, Int32 askExtractMode, const UInt64 *position))
+{
+ MT_LOCK
+
+ _currentName = name;
+
+ const char *s;
+ unsigned requiredLevel = 1;
+
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract: s = kExtractString; break;
+ case NArchive::NExtract::NAskMode::kTest: s = kTestString; break;
+ case NArchive::NExtract::NAskMode::kSkip: s = kSkipString; requiredLevel = 2; break;
+ case NArchive::NExtract::NAskMode::kReadExternal: s = kReadString; requiredLevel = 0; break;
+ default: s = "???"; requiredLevel = 2;
+ }
+
+ bool show2 = (LogLevel >= requiredLevel && _so);
+
+ if (show2)
+ {
+ ClosePercents_for_so();
+
+ _tempA = s;
+ if (name)
+ _tempA.Add_Space();
+ *_so << _tempA;
+
+ _tempU.Empty();
+ if (name)
+ {
+ _tempU = name;
+ _so->Normalize_UString(_tempU);
+ // 21.04
+ if (isFolder)
+ {
+ if (!_tempU.IsEmpty() && _tempU.Back() != WCHAR_PATH_SEPARATOR)
+ _tempU.Add_PathSepar();
+ }
+ }
+ _so->PrintUString(_tempU, _tempA);
+ if (position)
+ *_so << " <" << *position << ">";
+ *_so << endl;
+
+ if (NeedFlush)
+ _so->Flush();
+ }
+
+ if (NeedPercents())
+ {
+ if (PercentsNameLevel >= 1)
+ {
+ _percent.FileName.Empty();
+ _percent.Command.Empty();
+ if (PercentsNameLevel > 1 || !show2)
+ {
+ _percent.Command = s;
+ if (name)
+ _percent.FileName = name;
+ }
+ }
+ _percent.Print();
+ }
+
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::MessageError(const wchar_t *message))
+{
+ MT_LOCK
+
+ RINOK(CheckBreak2())
+
+ NumFileErrors_in_Current++;
+ NumFileErrors++;
+
+ ClosePercentsAndFlush();
+ if (_se)
+ {
+ *_se << kError << message << endl;
+ _se->Flush();
+ }
+
+ return CheckBreak2();
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &dest);
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &dest)
+{
+ dest.Empty();
+ const char *s = NULL;
+
+ switch (opRes)
+ {
+ case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
+ s = kUnsupportedMethod;
+ break;
+ case NArchive::NExtract::NOperationResult::kCRCError:
+ s = (encrypted ? kCrcFailedEncrypted : kCrcFailed);
+ break;
+ case NArchive::NExtract::NOperationResult::kDataError:
+ s = (encrypted ? kDataErrorEncrypted : kDataError);
+ break;
+ case NArchive::NExtract::NOperationResult::kUnavailable:
+ s = kUnavailableData;
+ break;
+ case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
+ s = kUnexpectedEnd;
+ break;
+ case NArchive::NExtract::NOperationResult::kDataAfterEnd:
+ s = kDataAfterEnd;
+ break;
+ case NArchive::NExtract::NOperationResult::kIsNotArc:
+ s = kIsNotArc;
+ break;
+ case NArchive::NExtract::NOperationResult::kHeadersError:
+ s = kHeadersError;
+ break;
+ case NArchive::NExtract::NOperationResult::kWrongPassword:
+ s = kWrongPassword;
+ break;
+ }
+
+ dest += kError;
+ if (s)
+ dest += s;
+ else
+ {
+ dest += "Error #";
+ dest.Add_UInt32((UInt32)opRes);
+ }
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::SetOperationResult(Int32 opRes, Int32 encrypted))
+{
+ MT_LOCK
+
+ if (opRes == NArchive::NExtract::NOperationResult::kOK)
+ {
+ if (NeedPercents())
+ {
+ _percent.Command.Empty();
+ _percent.FileName.Empty();
+ _percent.Files++;
+ }
+ }
+ else
+ {
+ NumFileErrors_in_Current++;
+ NumFileErrors++;
+
+ if (_se)
+ {
+ ClosePercentsAndFlush();
+
+ AString s;
+ SetExtractErrorMessage(opRes, encrypted, s);
+
+ *_se << s;
+ if (!_currentName.IsEmpty())
+ {
+ *_se << " : ";
+ _se->NormalizePrint_UString(_currentName);
+ }
+ *_se << endl;
+ _se->Flush();
+ }
+ }
+
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name))
+{
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ _currentName = name;
+ return SetOperationResult(opRes, encrypted);
+ }
+
+ return CheckBreak2();
+}
+
+
+
+#ifndef Z7_NO_CRYPTO
+
+HRESULT CExtractCallbackConsole::SetPassword(const UString &password)
+{
+ PasswordIsDefined = true;
+ Password = password;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackConsole::CryptoGetTextPassword(BSTR *password))
+{
+ COM_TRY_BEGIN
+ MT_LOCK
+ return Open_CryptoGetTextPassword(password);
+ COM_TRY_END
+}
+
+#endif
+
+HRESULT CExtractCallbackConsole::BeforeOpen(const wchar_t *name, bool testMode)
+{
+ RINOK(CheckBreak2())
+
+ NumTryArcs++;
+ ThereIsError_in_Current = false;
+ ThereIsWarning_in_Current = false;
+ NumFileErrors_in_Current = 0;
+
+ ClosePercents_for_so();
+ if (_so)
+ {
+ *_so << endl << (testMode ? kTesting : kExtracting);
+ _so->NormalizePrint_wstr(name);
+ *_so << endl;
+ }
+
+ if (NeedPercents())
+ _percent.Command = "Open";
+ return S_OK;
+}
+
+HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
+HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
+
+static AString GetOpenArcErrorMessage(UInt32 errorFlags)
+{
+ AString s;
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_ErrorFlagsMessages); i++)
+ {
+ UInt32 f = (1 << i);
+ if ((errorFlags & f) == 0)
+ continue;
+ const char *m = k_ErrorFlagsMessages[i];
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += m;
+ errorFlags &= ~f;
+ }
+
+ if (errorFlags != 0)
+ {
+ char sz[16];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt32ToHex(errorFlags, sz + 2);
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += sz;
+ }
+
+ return s;
+}
+
+void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags);
+void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags)
+{
+ if (errorFlags == 0)
+ return;
+ so << s << endl << GetOpenArcErrorMessage(errorFlags) << endl;
+}
+
+static void Add_Messsage_Pre_ArcType(UString &s, const char *pre, const wchar_t *arcType)
+{
+ s.Add_LF();
+ s += pre;
+ s += " as [";
+ s += arcType;
+ s += "] archive";
+}
+
+void Print_ErrorFormatIndex_Warning(CStdOutStream *_so, const CCodecs *codecs, const CArc &arc);
+void Print_ErrorFormatIndex_Warning(CStdOutStream *_so, const CCodecs *codecs, const CArc &arc)
+{
+ const CArcErrorInfo &er = arc.ErrorInfo;
+
+ *_so << "WARNING:\n";
+ _so->NormalizePrint_UString(arc.Path);
+ UString s;
+ if (arc.FormatIndex == er.ErrorFormatIndex)
+ {
+ s.Add_LF();
+ s += "The archive is open with offset";
+ }
+ else
+ {
+ Add_Messsage_Pre_ArcType(s, "Cannot open the file", codecs->GetFormatNamePtr(er.ErrorFormatIndex));
+ Add_Messsage_Pre_ArcType(s, "The file is open", codecs->GetFormatNamePtr(arc.FormatIndex));
+ }
+
+ *_so << s << endl << endl;
+}
+
+
+HRESULT CExtractCallbackConsole::OpenResult(
+ const CCodecs *codecs, const CArchiveLink &arcLink,
+ const wchar_t *name, HRESULT result)
+{
+ ClosePercents();
+
+ if (NeedPercents())
+ {
+ _percent.Files = 0;
+ _percent.Command.Empty();
+ _percent.FileName.Empty();
+ }
+
+
+ ClosePercentsAndFlush();
+
+ FOR_VECTOR (level, arcLink.Arcs)
+ {
+ const CArc &arc = arcLink.Arcs[level];
+ const CArcErrorInfo &er = arc.ErrorInfo;
+
+ UInt32 errorFlags = er.GetErrorFlags();
+
+ if (errorFlags != 0 || !er.ErrorMessage.IsEmpty())
+ {
+ if (_se)
+ {
+ *_se << endl;
+ if (level != 0)
+ {
+ _se->NormalizePrint_UString(arc.Path);
+ *_se << endl;
+ }
+ }
+
+ if (errorFlags != 0)
+ {
+ if (_se)
+ PrintErrorFlags(*_se, "ERRORS:", errorFlags);
+ NumOpenArcErrors++;
+ ThereIsError_in_Current = true;
+ }
+
+ if (!er.ErrorMessage.IsEmpty())
+ {
+ if (_se)
+ *_se << "ERRORS:" << endl << er.ErrorMessage << endl;
+ NumOpenArcErrors++;
+ ThereIsError_in_Current = true;
+ }
+
+ if (_se)
+ {
+ *_se << endl;
+ _se->Flush();
+ }
+ }
+
+ UInt32 warningFlags = er.GetWarningFlags();
+
+ if (warningFlags != 0 || !er.WarningMessage.IsEmpty())
+ {
+ if (_so)
+ {
+ *_so << endl;
+ if (level != 0)
+ {
+ _so->NormalizePrint_UString(arc.Path);
+ *_so << endl;
+ }
+ }
+
+ if (warningFlags != 0)
+ {
+ if (_so)
+ PrintErrorFlags(*_so, "WARNINGS:", warningFlags);
+ NumOpenArcWarnings++;
+ ThereIsWarning_in_Current = true;
+ }
+
+ if (!er.WarningMessage.IsEmpty())
+ {
+ if (_so)
+ *_so << "WARNINGS:" << endl << er.WarningMessage << endl;
+ NumOpenArcWarnings++;
+ ThereIsWarning_in_Current = true;
+ }
+
+ if (_so)
+ {
+ *_so << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+ }
+
+
+ if (er.ErrorFormatIndex >= 0)
+ {
+ if (_so)
+ {
+ Print_ErrorFormatIndex_Warning(_so, codecs, arc);
+ if (NeedFlush)
+ _so->Flush();
+ }
+ ThereIsWarning_in_Current = true;
+ }
+ }
+
+ if (result == S_OK)
+ {
+ if (_so)
+ {
+ RINOK(Print_OpenArchive_Props(*_so, codecs, arcLink))
+ *_so << endl;
+ }
+ }
+ else
+ {
+ NumCantOpenArcs++;
+ if (_so)
+ _so->Flush();
+ if (_se)
+ {
+ *_se << kError;
+ _se->NormalizePrint_wstr(name);
+ *_se << endl;
+ const HRESULT res = Print_OpenArchive_Error(*_se, codecs, arcLink);
+ RINOK(res)
+ if (result == S_FALSE)
+ {
+ }
+ else
+ {
+ if (result == E_OUTOFMEMORY)
+ *_se << "Can't allocate required memory";
+ else
+ *_se << NError::MyFormatMessage(result);
+ *_se << endl;
+ }
+ _se->Flush();
+ }
+ }
+
+
+ return CheckBreak2();
+}
+
+HRESULT CExtractCallbackConsole::ThereAreNoFiles()
+{
+ ClosePercents_for_so();
+
+ if (_so)
+ {
+ *_so << endl << kNoFiles << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+ return CheckBreak2();
+}
+
+HRESULT CExtractCallbackConsole::ExtractResult(HRESULT result)
+{
+ MT_LOCK
+
+ if (NeedPercents())
+ {
+ _percent.ClosePrint(true);
+ _percent.Command.Empty();
+ _percent.FileName.Empty();
+ }
+
+ if (_so)
+ _so->Flush();
+
+ if (result == S_OK)
+ {
+ if (NumFileErrors_in_Current == 0 && !ThereIsError_in_Current)
+ {
+ if (ThereIsWarning_in_Current)
+ NumArcsWithWarnings++;
+ else
+ NumOkArcs++;
+ if (_so)
+ *_so << kEverythingIsOk << endl;
+ }
+ else
+ {
+ NumArcsWithError++;
+ if (_so)
+ {
+ *_so << endl;
+ if (NumFileErrors_in_Current != 0)
+ *_so << "Sub items Errors: " << NumFileErrors_in_Current << endl;
+ }
+ }
+ if (_so && NeedFlush)
+ _so->Flush();
+ }
+ else
+ {
+ NumArcsWithError++;
+ if (result == E_ABORT
+ || result == HRESULT_FROM_WIN32(ERROR_DISK_FULL)
+ )
+ return result;
+
+ if (_se)
+ {
+ *_se << endl << kError;
+ if (result == E_OUTOFMEMORY)
+ *_se << kMemoryExceptionMessage;
+ else
+ *_se << NError::MyFormatMessage(result);
+ *_se << endl;
+ _se->Flush();
+ }
+ }
+
+ return CheckBreak2();
+}
diff --git a/CPP/7zip/UI/Console/ExtractCallbackConsole.h b/CPP/7zip/UI/Console/ExtractCallbackConsole.h
index 5de6c5b..478b293 100644
--- a/CPP/7zip/UI/Console/ExtractCallbackConsole.h
+++ b/CPP/7zip/UI/Console/ExtractCallbackConsole.h
@@ -1,164 +1,181 @@
-// ExtractCallbackConsole.h
-
-#ifndef __EXTRACT_CALLBACK_CONSOLE_H
-#define __EXTRACT_CALLBACK_CONSOLE_H
-
-#include "../../../Common/StdOutStream.h"
-
-#include "../../IPassword.h"
-
-#include "../../Archive/IArchive.h"
-
-#include "../Common/ArchiveExtractCallback.h"
-
-#include "PercentPrinter.h"
-
-#include "OpenCallbackConsole.h"
-
-class CExtractScanConsole: public IDirItemsCallback
-{
- CStdOutStream *_so;
- CStdOutStream *_se;
- CPercentPrinter _percent;
-
- bool NeedPercents() const { return _percent._so != NULL; }
-
- void ClosePercentsAndFlush()
- {
- if (NeedPercents())
- _percent.ClosePrint(true);
- if (_so)
- _so->Flush();
- }
-
-public:
- void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
- {
- _so = outStream;
- _se = errorStream;
- _percent._so = percentStream;
- }
-
- void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
-
- void StartScanning();
-
- INTERFACE_IDirItemsCallback(;)
-
- void CloseScanning()
- {
- if (NeedPercents())
- _percent.ClosePrint(true);
- }
-
- void PrintStat(const CDirItemsStat &st);
-};
-
-
-
-
-class CExtractCallbackConsole:
- public IExtractCallbackUI,
- // public IArchiveExtractCallbackMessage,
- public IFolderArchiveExtractCallback2,
- #ifndef _NO_CRYPTO
- public ICryptoGetTextPassword,
- #endif
- public COpenCallbackConsole,
- public CMyUnknownImp
-{
- AString _tempA;
- UString _tempU;
-
- UString _currentName;
-
- void ClosePercents_for_so()
- {
- if (NeedPercents() && _so == _percent._so)
- _percent.ClosePrint(false);
- }
-
- void ClosePercentsAndFlush()
- {
- if (NeedPercents())
- _percent.ClosePrint(true);
- if (_so)
- _so->Flush();
- }
-
-public:
- MY_QUERYINTERFACE_BEGIN2(IFolderArchiveExtractCallback)
- // MY_QUERYINTERFACE_ENTRY(IArchiveExtractCallbackMessage)
- MY_QUERYINTERFACE_ENTRY(IFolderArchiveExtractCallback2)
- #ifndef _NO_CRYPTO
- MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- STDMETHOD(SetTotal)(UInt64 total);
- STDMETHOD(SetCompleted)(const UInt64 *completeValue);
-
- INTERFACE_IFolderArchiveExtractCallback(;)
-
- INTERFACE_IExtractCallbackUI(;)
- // INTERFACE_IArchiveExtractCallbackMessage(;)
- INTERFACE_IFolderArchiveExtractCallback2(;)
-
- #ifndef _NO_CRYPTO
-
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
-
- #endif
-
- UInt64 NumTryArcs;
-
- bool ThereIsError_in_Current;
- bool ThereIsWarning_in_Current;
-
- UInt64 NumOkArcs;
- UInt64 NumCantOpenArcs;
- UInt64 NumArcsWithError;
- UInt64 NumArcsWithWarnings;
-
- UInt64 NumOpenArcErrors;
- UInt64 NumOpenArcWarnings;
-
- UInt64 NumFileErrors;
- UInt64 NumFileErrors_in_Current;
-
- bool NeedFlush;
- unsigned PercentsNameLevel;
- unsigned LogLevel;
-
- CExtractCallbackConsole():
- NeedFlush(false),
- PercentsNameLevel(1),
- LogLevel(0)
- {}
-
- void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
-
- void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
- {
- COpenCallbackConsole::Init(outStream, errorStream, percentStream);
-
- NumTryArcs = 0;
-
- ThereIsError_in_Current = false;
- ThereIsWarning_in_Current = false;
-
- NumOkArcs = 0;
- NumCantOpenArcs = 0;
- NumArcsWithError = 0;
- NumArcsWithWarnings = 0;
-
- NumOpenArcErrors = 0;
- NumOpenArcWarnings = 0;
-
- NumFileErrors = 0;
- NumFileErrors_in_Current = 0;
- }
-};
-
-#endif
+// ExtractCallbackConsole.h
+
+#ifndef ZIP7_INC_EXTRACT_CALLBACK_CONSOLE_H
+#define ZIP7_INC_EXTRACT_CALLBACK_CONSOLE_H
+
+#include "../../../Common/StdOutStream.h"
+
+#include "../../IPassword.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "../Common/ArchiveExtractCallback.h"
+
+#include "PercentPrinter.h"
+
+#include "OpenCallbackConsole.h"
+
+/*
+struct CErrorPathCodes2
+{
+ FStringVector Paths;
+ CRecordVector<DWORD> Codes;
+
+ void AddError(const FString &path, DWORD systemError)
+ {
+ Paths.Add(path);
+ Codes.Add(systemError);
+ }
+ void Clear()
+ {
+ Paths.Clear();
+ Codes.Clear();
+ }
+};
+*/
+
+class CExtractScanConsole Z7_final: public IDirItemsCallback
+{
+ Z7_IFACE_IMP(IDirItemsCallback)
+
+ CStdOutStream *_so;
+ CStdOutStream *_se;
+ CPercentPrinter _percent;
+
+ // CErrorPathCodes2 ScanErrors;
+
+ bool NeedPercents() const { return _percent._so != NULL; }
+
+ void ClosePercentsAndFlush()
+ {
+ if (NeedPercents())
+ _percent.ClosePrint(true);
+ if (_so)
+ _so->Flush();
+ }
+
+public:
+
+ void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
+ {
+ _so = outStream;
+ _se = errorStream;
+ _percent._so = percentStream;
+ }
+
+ void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
+
+ void StartScanning();
+
+ void CloseScanning()
+ {
+ if (NeedPercents())
+ _percent.ClosePrint(true);
+ }
+
+ void PrintStat(const CDirItemsStat &st);
+};
+
+
+
+
+class CExtractCallbackConsole Z7_final:
+ public IFolderArchiveExtractCallback,
+ public IExtractCallbackUI,
+ // public IArchiveExtractCallbackMessage,
+ public IFolderArchiveExtractCallback2,
+ #ifndef Z7_NO_CRYPTO
+ public ICryptoGetTextPassword,
+ #endif
+ public COpenCallbackConsole,
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IFolderArchiveExtractCallback)
+ // Z7_COM_QI_ENTRY(IArchiveExtractCallbackMessage)
+ Z7_COM_QI_ENTRY(IFolderArchiveExtractCallback2)
+ #ifndef Z7_NO_CRYPTO
+ Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IFolderArchiveExtractCallback)
+ Z7_IFACE_IMP(IExtractCallbackUI)
+ // Z7_IFACE_COM7_IMP(IArchiveExtractCallbackMessage)
+ Z7_IFACE_COM7_IMP(IFolderArchiveExtractCallback2)
+ #ifndef Z7_NO_CRYPTO
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ #endif
+
+
+ AString _tempA;
+ UString _tempU;
+
+ UString _currentName;
+
+ void ClosePercents_for_so()
+ {
+ if (NeedPercents() && _so == _percent._so)
+ _percent.ClosePrint(false);
+ }
+
+ void ClosePercentsAndFlush()
+ {
+ if (NeedPercents())
+ _percent.ClosePrint(true);
+ if (_so)
+ _so->Flush();
+ }
+public:
+ UInt64 NumTryArcs;
+
+ bool ThereIsError_in_Current;
+ bool ThereIsWarning_in_Current;
+
+ UInt64 NumOkArcs;
+ UInt64 NumCantOpenArcs;
+ UInt64 NumArcsWithError;
+ UInt64 NumArcsWithWarnings;
+
+ UInt64 NumOpenArcErrors;
+ UInt64 NumOpenArcWarnings;
+
+ UInt64 NumFileErrors;
+ UInt64 NumFileErrors_in_Current;
+
+ bool NeedFlush;
+ unsigned PercentsNameLevel;
+ unsigned LogLevel;
+
+ CExtractCallbackConsole():
+ NeedFlush(false),
+ PercentsNameLevel(1),
+ LogLevel(0)
+ {}
+
+ void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
+
+ void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
+ {
+ COpenCallbackConsole::Init(outStream, errorStream, percentStream);
+
+ NumTryArcs = 0;
+
+ ThereIsError_in_Current = false;
+ ThereIsWarning_in_Current = false;
+
+ NumOkArcs = 0;
+ NumCantOpenArcs = 0;
+ NumArcsWithError = 0;
+ NumArcsWithWarnings = 0;
+
+ NumOpenArcErrors = 0;
+ NumOpenArcWarnings = 0;
+
+ NumFileErrors = 0;
+ NumFileErrors_in_Current = 0;
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/Console/HashCon.cpp b/CPP/7zip/UI/Console/HashCon.cpp
index 3ade0fd..c0e69e2 100644
--- a/CPP/7zip/UI/Console/HashCon.cpp
+++ b/CPP/7zip/UI/Console/HashCon.cpp
@@ -1,367 +1,426 @@
-// HashCon.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "ConsoleClose.h"
-#include "HashCon.h"
-
-static const char * const kEmptyFileAlias = "[Content]";
-
-static const char * const kScanningMessage = "Scanning";
-
-static HRESULT CheckBreak2()
-{
- return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
-}
-
-HRESULT CHashCallbackConsole::CheckBreak()
-{
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::StartScanning()
-{
- if (PrintHeaders && _so)
- *_so << kScanningMessage << endl;
- if (NeedPercents())
- {
- _percent.ClearCurState();
- _percent.Command = "Scan";
- }
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::ScanProgress(const CDirItemsStat &st, const FString &path, bool /* isDir */)
-{
- if (NeedPercents())
- {
- _percent.Files = st.NumDirs + st.NumFiles + st.NumAltStreams;
- _percent.Completed = st.GetTotalBytes();
- _percent.FileName = fs2us(path);
- _percent.Print();
- }
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::ScanError(const FString &path, DWORD systemError)
-{
- return ScanError_Base(path, systemError);
-}
-
-void Print_DirItemsStat(AString &s, const CDirItemsStat &st);
-
-HRESULT CHashCallbackConsole::FinishScanning(const CDirItemsStat &st)
-{
- if (NeedPercents())
- {
- _percent.ClosePrint(true);
- _percent.ClearCurState();
- }
- if (PrintHeaders && _so)
- {
- Print_DirItemsStat(_s, st);
- *_so << _s << endl << endl;
- }
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::SetNumFiles(UInt64 /* numFiles */)
-{
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::SetTotal(UInt64 size)
-{
- if (NeedPercents())
- {
- _percent.Total = size;
- _percent.Print();
- }
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::SetCompleted(const UInt64 *completeValue)
-{
- if (completeValue && NeedPercents())
- {
- _percent.Completed = *completeValue;
- _percent.Print();
- }
- return CheckBreak2();
-}
-
-static void AddMinuses(AString &s, unsigned num)
-{
- for (unsigned i = 0; i < num; i++)
- s += '-';
-}
-
-static void AddSpaces_if_Positive(AString &s, int num)
-{
- for (int i = 0; i < num; i++)
- s.Add_Space();
-}
-
-static void SetSpacesAndNul(char *s, unsigned num)
-{
- for (unsigned i = 0; i < num; i++)
- s[i] = ' ';
- s[num] = 0;
-}
-
-static const unsigned kSizeField_Len = 13;
-static const unsigned kNameField_Len = 12;
-
-static const unsigned kHashColumnWidth_Min = 4 * 2;
-
-static unsigned GetColumnWidth(unsigned digestSize)
-{
- unsigned width = digestSize * 2;
- return width < kHashColumnWidth_Min ? kHashColumnWidth_Min: width;
-}
-
-void CHashCallbackConsole::PrintSeparatorLine(const CObjectVector<CHasherState> &hashers)
-{
- _s.Empty();
-
- for (unsigned i = 0; i < hashers.Size(); i++)
- {
- if (i != 0)
- _s.Add_Space();
- const CHasherState &h = hashers[i];
- AddMinuses(_s, GetColumnWidth(h.DigestSize));
- }
-
- if (PrintSize)
- {
- _s.Add_Space();
- AddMinuses(_s, kSizeField_Len);
- }
-
- if (PrintName)
- {
- AddSpacesBeforeName();
- AddMinuses(_s, kNameField_Len);
- }
-
- *_so << _s << endl;
-}
-
-HRESULT CHashCallbackConsole::BeforeFirstFile(const CHashBundle &hb)
-{
- if (PrintHeaders && _so)
- {
- _s.Empty();
- ClosePercents_for_so();
-
- FOR_VECTOR (i, hb.Hashers)
- {
- if (i != 0)
- _s.Add_Space();
- const CHasherState &h = hb.Hashers[i];
- _s += h.Name;
- AddSpaces_if_Positive(_s, (int)GetColumnWidth(h.DigestSize) - (int)h.Name.Len());
- }
-
- if (PrintSize)
- {
- _s.Add_Space();
- const AString s2 ("Size");
- AddSpaces_if_Positive(_s, (int)kSizeField_Len - (int)s2.Len());
- _s += s2;
- }
-
- if (PrintName)
- {
- AddSpacesBeforeName();
- _s += "Name";
- }
-
- *_so << _s << endl;
- PrintSeparatorLine(hb.Hashers);
- }
-
- return CheckBreak2();
-}
-
-HRESULT CHashCallbackConsole::OpenFileError(const FString &path, DWORD systemError)
-{
- return OpenFileError_Base(path, systemError);
-}
-
-HRESULT CHashCallbackConsole::GetStream(const wchar_t *name, bool /* isFolder */)
-{
- _fileName = name;
-
- if (NeedPercents())
- {
- if (PrintNameInPercents)
- {
- _percent.FileName.Empty();
- if (name)
- _percent.FileName = name;
- }
- _percent.Print();
- }
- return CheckBreak2();
-}
-
-void CHashCallbackConsole::PrintResultLine(UInt64 fileSize,
- const CObjectVector<CHasherState> &hashers, unsigned digestIndex, bool showHash)
-{
- ClosePercents_for_so();
-
- _s.Empty();
-
- FOR_VECTOR (i, hashers)
- {
- const CHasherState &h = hashers[i];
- char s[k_HashCalc_DigestSize_Max * 2 + 64];
- s[0] = 0;
- if (showHash)
- AddHashHexToString(s, h.Digests[digestIndex], h.DigestSize);
- SetSpacesAndNul(s + strlen(s), (int)GetColumnWidth(h.DigestSize) - (int)strlen(s));
- if (i != 0)
- _s.Add_Space();
- _s += s;
- }
-
- if (PrintSize)
- {
- _s.Add_Space();
-
- char s[kSizeField_Len + 32];
- char *p = s;
-
- if (showHash)
- {
- p = s + kSizeField_Len;
- ConvertUInt64ToString(fileSize, p);
- int numSpaces = kSizeField_Len - (int)strlen(p);
- if (numSpaces > 0)
- {
- p -= (unsigned)numSpaces;
- for (unsigned i = 0; i < (unsigned)numSpaces; i++)
- p[i] = ' ';
- }
- }
- else
- SetSpacesAndNul(s, kSizeField_Len);
-
- _s += p;
- }
-
- if (PrintName)
- AddSpacesBeforeName();
-
- *_so << _s;
-}
-
-HRESULT CHashCallbackConsole::SetOperationResult(UInt64 fileSize, const CHashBundle &hb, bool showHash)
-{
- if (_so)
- {
- PrintResultLine(fileSize, hb.Hashers, k_HashCalc_Index_Current, showHash);
- if (PrintName)
- {
- if (_fileName.IsEmpty())
- *_so << kEmptyFileAlias;
- else
- _so->NormalizePrint_UString(_fileName);
- }
- *_so << endl;
- }
-
- if (NeedPercents())
- {
- _percent.Files++;
- _percent.Print();
- }
-
- return CheckBreak2();
-}
-
-static const char * const k_DigestTitles[] =
-{
- " : "
- , " for data: "
- , " for data and names: "
- , " for streams and names: "
-};
-
-static void PrintSum(CStdOutStream &so, const CHasherState &h, unsigned digestIndex)
-{
- so << h.Name;
-
- {
- AString temp;
- AddSpaces_if_Positive(temp, 6 - (int)h.Name.Len());
- so << temp;
- }
-
- so << k_DigestTitles[digestIndex];
-
- char s[k_HashCalc_DigestSize_Max * 2 + 64];
- s[0] = 0;
- AddHashHexToString(s, h.Digests[digestIndex], h.DigestSize);
- so << s << endl;
-}
-
-void PrintHashStat(CStdOutStream &so, const CHashBundle &hb)
-{
- FOR_VECTOR (i, hb.Hashers)
- {
- const CHasherState &h = hb.Hashers[i];
- PrintSum(so, h, k_HashCalc_Index_DataSum);
- if (hb.NumFiles != 1 || hb.NumDirs != 0)
- PrintSum(so, h, k_HashCalc_Index_NamesSum);
- if (hb.NumAltStreams != 0)
- PrintSum(so, h, k_HashCalc_Index_StreamsSum);
- so << endl;
- }
-}
-
-void CHashCallbackConsole::PrintProperty(const char *name, UInt64 value)
-{
- char s[32];
- s[0] = ':';
- s[1] = ' ';
- ConvertUInt64ToString(value, s + 2);
- *_so << name << s << endl;
-}
-
-HRESULT CHashCallbackConsole::AfterLastFile(CHashBundle &hb)
-{
- ClosePercents2();
-
- if (PrintHeaders && _so)
- {
- PrintSeparatorLine(hb.Hashers);
-
- PrintResultLine(hb.FilesSize, hb.Hashers, k_HashCalc_Index_DataSum, true);
-
- *_so << endl << endl;
-
- if (hb.NumFiles != 1 || hb.NumDirs != 0)
- {
- if (hb.NumDirs != 0)
- PrintProperty("Folders", hb.NumDirs);
- PrintProperty("Files", hb.NumFiles);
- }
-
- PrintProperty("Size", hb.FilesSize);
-
- if (hb.NumAltStreams != 0)
- {
- PrintProperty("Alternate streams", hb.NumAltStreams);
- PrintProperty("Alternate streams size", hb.AltStreamsSize);
- }
-
- *_so << endl;
- PrintHashStat(*_so, hb);
- }
-
- return S_OK;
-}
+// HashCon.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/FileName.h"
+
+#include "ConsoleClose.h"
+#include "HashCon.h"
+
+static const char * const kEmptyFileAlias = "[Content]";
+
+static const char * const kScanningMessage = "Scanning";
+
+static HRESULT CheckBreak2()
+{
+ return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
+}
+
+HRESULT CHashCallbackConsole::CheckBreak()
+{
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::StartScanning()
+{
+ if (PrintHeaders && _so)
+ *_so << kScanningMessage << endl;
+ if (NeedPercents())
+ {
+ _percent.ClearCurState();
+ _percent.Command = "Scan";
+ }
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::ScanProgress(const CDirItemsStat &st, const FString &path, bool isDir)
+{
+ if (NeedPercents())
+ {
+ _percent.Files = st.NumDirs + st.NumFiles + st.NumAltStreams;
+ _percent.Completed = st.GetTotalBytes();
+ _percent.FileName = fs2us(path);
+ if (isDir)
+ NWindows::NFile::NName::NormalizeDirPathPrefix(_percent.FileName);
+ _percent.Print();
+ }
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::ScanError(const FString &path, DWORD systemError)
+{
+ return ScanError_Base(path, systemError);
+}
+
+void Print_DirItemsStat(AString &s, const CDirItemsStat &st);
+
+HRESULT CHashCallbackConsole::FinishScanning(const CDirItemsStat &st)
+{
+ if (NeedPercents())
+ {
+ _percent.ClosePrint(true);
+ _percent.ClearCurState();
+ }
+ if (PrintHeaders && _so)
+ {
+ Print_DirItemsStat(_s, st);
+ *_so << _s << endl << endl;
+ }
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::SetNumFiles(UInt64 /* numFiles */)
+{
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::SetTotal(UInt64 size)
+{
+ if (NeedPercents())
+ {
+ _percent.Total = size;
+ _percent.Print();
+ }
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::SetCompleted(const UInt64 *completeValue)
+{
+ if (completeValue && NeedPercents())
+ {
+ _percent.Completed = *completeValue;
+ _percent.Print();
+ }
+ return CheckBreak2();
+}
+
+static void AddMinuses(AString &s, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ s.Add_Minus();
+}
+
+static void AddSpaces_if_Positive(AString &s, int num)
+{
+ for (int i = 0; i < num; i++)
+ s.Add_Space();
+}
+
+static void SetSpacesAndNul(char *s, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ s[i] = ' ';
+ s[num] = 0;
+}
+
+static void SetSpacesAndNul_if_Positive(char *s, int num)
+{
+ if (num < 0)
+ return;
+ for (int i = 0; i < num; i++)
+ s[i] = ' ';
+ s[num] = 0;
+}
+
+static const unsigned kSizeField_Len = 13;
+static const unsigned kNameField_Len = 12;
+
+static const unsigned kHashColumnWidth_Min = 4 * 2;
+
+static unsigned GetColumnWidth(unsigned digestSize)
+{
+ unsigned width = digestSize * 2;
+ return width < kHashColumnWidth_Min ? kHashColumnWidth_Min: width;
+}
+
+
+AString CHashCallbackConsole::GetFields() const
+{
+ AString s (PrintFields);
+ if (s.IsEmpty())
+ s = "hsn";
+ s.MakeLower_Ascii();
+ return s;
+}
+
+
+void CHashCallbackConsole::PrintSeparatorLine(const CObjectVector<CHasherState> &hashers)
+{
+ _s.Empty();
+ const AString fields = GetFields();
+ for (unsigned pos = 0; pos < fields.Len(); pos++)
+ {
+ const char c = fields[pos];
+ if (c == 'h')
+ {
+ for (unsigned i = 0; i < hashers.Size(); i++)
+ {
+ AddSpace();
+ const CHasherState &h = hashers[i];
+ AddMinuses(_s, GetColumnWidth(h.DigestSize));
+ }
+ }
+ else if (c == 's')
+ {
+ AddSpace();
+ AddMinuses(_s, kSizeField_Len);
+ }
+ else if (c == 'n')
+ {
+ AddSpacesBeforeName();
+ AddMinuses(_s, kNameField_Len);
+ }
+ }
+
+ *_so << _s << endl;
+}
+
+
+HRESULT CHashCallbackConsole::BeforeFirstFile(const CHashBundle &hb)
+{
+ if (PrintHeaders && _so)
+ {
+ _s.Empty();
+ ClosePercents_for_so();
+
+ const AString fields = GetFields();
+ for (unsigned pos = 0; pos < fields.Len(); pos++)
+ {
+ const char c = fields[pos];
+ if (c == 'h')
+ {
+ FOR_VECTOR (i, hb.Hashers)
+ {
+ AddSpace();
+ const CHasherState &h = hb.Hashers[i];
+ _s += h.Name;
+ AddSpaces_if_Positive(_s, (int)GetColumnWidth(h.DigestSize) - (int)h.Name.Len());
+ }
+ }
+
+ else if (c == 's')
+ {
+ AddSpace();
+ const AString s2 ("Size");
+ AddSpaces_if_Positive(_s, (int)kSizeField_Len - (int)s2.Len());
+ _s += s2;
+ }
+ else if (c == 'n')
+ {
+ AddSpacesBeforeName();
+ _s += "Name";
+ }
+ }
+
+ *_so << _s << endl;
+ PrintSeparatorLine(hb.Hashers);
+ }
+
+ return CheckBreak2();
+}
+
+HRESULT CHashCallbackConsole::OpenFileError(const FString &path, DWORD systemError)
+{
+ return OpenFileError_Base(path, systemError);
+}
+
+HRESULT CHashCallbackConsole::GetStream(const wchar_t *name, bool isDir)
+{
+ _fileName = name;
+ if (isDir)
+ NWindows::NFile::NName::NormalizeDirPathPrefix(_fileName);
+
+ if (NeedPercents())
+ {
+ if (PrintNameInPercents)
+ {
+ _percent.FileName.Empty();
+ if (name)
+ _percent.FileName = name;
+ }
+ _percent.Print();
+ }
+ return CheckBreak2();
+}
+
+
+static const unsigned k_DigestStringSize = k_HashCalc_DigestSize_Max * 2 + k_HashCalc_ExtraSize * 2 + 16;
+
+
+
+void CHashCallbackConsole::PrintResultLine(UInt64 fileSize,
+ const CObjectVector<CHasherState> &hashers, unsigned digestIndex, bool showHash,
+ const AString &path)
+{
+ ClosePercents_for_so();
+
+ _s.Empty();
+ const AString fields = GetFields();
+
+ for (unsigned pos = 0; pos < fields.Len(); pos++)
+ {
+ const char c = fields[pos];
+ if (c == 'h')
+ {
+ FOR_VECTOR (i, hashers)
+ {
+ AddSpace();
+ const CHasherState &h = hashers[i];
+ char s[k_DigestStringSize];
+ s[0] = 0;
+ if (showHash)
+ h.WriteToString(digestIndex, s);
+ const unsigned len = (unsigned)strlen(s);
+ SetSpacesAndNul_if_Positive(s + len, (int)GetColumnWidth(h.DigestSize) - (int)len);
+ _s += s;
+ }
+ }
+ else if (c == 's')
+ {
+ AddSpace();
+ char s[kSizeField_Len + 32];
+ char *p = s;
+ SetSpacesAndNul(s, kSizeField_Len);
+ if (showHash)
+ {
+ p = s + kSizeField_Len;
+ ConvertUInt64ToString(fileSize, p);
+ const int numSpaces = (int)kSizeField_Len - (int)strlen(p);
+ if (numSpaces > 0)
+ p -= (unsigned)numSpaces;
+ }
+ _s += p;
+ }
+ else if (c == 'n')
+ {
+ AddSpacesBeforeName();
+ _s += path;
+ }
+ }
+
+ *_so << _s;
+}
+
+
+HRESULT CHashCallbackConsole::SetOperationResult(UInt64 fileSize, const CHashBundle &hb, bool showHash)
+{
+ if (_so)
+ {
+ AString s;
+ if (_fileName.IsEmpty())
+ s = kEmptyFileAlias;
+ else
+ {
+ UString temp (_fileName);
+ _so->Normalize_UString(temp);
+ _so->Convert_UString_to_AString(temp, s);
+ }
+ PrintResultLine(fileSize, hb.Hashers, k_HashCalc_Index_Current, showHash, s);
+
+ /*
+ PrintResultLine(fileSize, hb.Hashers, k_HashCalc_Index_Current, showHash);
+ if (PrintName)
+ {
+ if (_fileName.IsEmpty())
+ *_so << kEmptyFileAlias;
+ else
+ _so->NormalizePrint_UString(_fileName);
+ }
+ */
+ // if (PrintNewLine)
+ *_so << endl;
+ }
+
+ if (NeedPercents())
+ {
+ _percent.Files++;
+ _percent.Print();
+ }
+
+ return CheckBreak2();
+}
+
+static const char * const k_DigestTitles[] =
+{
+ " : "
+ , " for data: "
+ , " for data and names: "
+ , " for streams and names: "
+};
+
+static void PrintSum(CStdOutStream &so, const CHasherState &h, unsigned digestIndex)
+{
+ so << h.Name;
+
+ {
+ AString temp;
+ AddSpaces_if_Positive(temp, 6 - (int)h.Name.Len());
+ so << temp;
+ }
+
+ so << k_DigestTitles[digestIndex];
+
+ char s[k_DigestStringSize];
+ // s[0] = 0;
+ h.WriteToString(digestIndex, s);
+ so << s << endl;
+}
+
+void PrintHashStat(CStdOutStream &so, const CHashBundle &hb)
+{
+ FOR_VECTOR (i, hb.Hashers)
+ {
+ const CHasherState &h = hb.Hashers[i];
+ PrintSum(so, h, k_HashCalc_Index_DataSum);
+ if (hb.NumFiles != 1 || hb.NumDirs != 0)
+ PrintSum(so, h, k_HashCalc_Index_NamesSum);
+ if (hb.NumAltStreams != 0)
+ PrintSum(so, h, k_HashCalc_Index_StreamsSum);
+ so << endl;
+ }
+}
+
+void CHashCallbackConsole::PrintProperty(const char *name, UInt64 value)
+{
+ char s[32];
+ s[0] = ':';
+ s[1] = ' ';
+ ConvertUInt64ToString(value, s + 2);
+ *_so << name << s << endl;
+}
+
+HRESULT CHashCallbackConsole::AfterLastFile(CHashBundle &hb)
+{
+ ClosePercents2();
+
+ if (PrintHeaders && _so)
+ {
+ PrintSeparatorLine(hb.Hashers);
+
+ PrintResultLine(hb.FilesSize, hb.Hashers, k_HashCalc_Index_DataSum, true, AString());
+
+ *_so << endl << endl;
+
+ if (hb.NumFiles != 1 || hb.NumDirs != 0)
+ {
+ if (hb.NumDirs != 0)
+ PrintProperty("Folders", hb.NumDirs);
+ PrintProperty("Files", hb.NumFiles);
+ }
+
+ PrintProperty("Size", hb.FilesSize);
+
+ if (hb.NumAltStreams != 0)
+ {
+ PrintProperty("Alternate streams", hb.NumAltStreams);
+ PrintProperty("Alternate streams size", hb.AltStreamsSize);
+ }
+
+ *_so << endl;
+ PrintHashStat(*_so, hb);
+ }
+
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Console/HashCon.h b/CPP/7zip/UI/Console/HashCon.h
index 9c12869..ebccb6f 100644
--- a/CPP/7zip/UI/Console/HashCon.h
+++ b/CPP/7zip/UI/Console/HashCon.h
@@ -1,48 +1,58 @@
-// HashCon.h
-
-#ifndef __HASH_CON_H
-#define __HASH_CON_H
-
-#include "../Common/HashCalc.h"
-
-#include "UpdateCallbackConsole.h"
-
-class CHashCallbackConsole: public IHashCallbackUI, public CCallbackConsoleBase
-{
- UString _fileName;
- AString _s;
-
- void AddSpacesBeforeName()
- {
- _s.Add_Space();
- _s.Add_Space();
- }
-
- void PrintSeparatorLine(const CObjectVector<CHasherState> &hashers);
- void PrintResultLine(UInt64 fileSize,
- const CObjectVector<CHasherState> &hashers, unsigned digestIndex, bool showHash);
- void PrintProperty(const char *name, UInt64 value);
-
-public:
- bool PrintNameInPercents;
-
- bool PrintHeaders;
-
- bool PrintSize;
- bool PrintName;
-
- CHashCallbackConsole():
- PrintNameInPercents(true),
- PrintHeaders(false),
- PrintSize(true),
- PrintName(true)
- {}
-
- ~CHashCallbackConsole() { }
-
- INTERFACE_IHashCallbackUI(;)
-};
-
-void PrintHashStat(CStdOutStream &so, const CHashBundle &hb);
-
-#endif
+// HashCon.h
+
+#ifndef ZIP7_INC_HASH_CON_H
+#define ZIP7_INC_HASH_CON_H
+
+#include "../Common/HashCalc.h"
+
+#include "UpdateCallbackConsole.h"
+
+class CHashCallbackConsole Z7_final:
+ public IHashCallbackUI,
+ public CCallbackConsoleBase
+{
+ Z7_IFACE_IMP(IDirItemsCallback)
+ Z7_IFACE_IMP(IHashCallbackUI)
+
+ UString _fileName;
+ AString _s;
+
+ void AddSpace()
+ {
+ _s.Add_Space_if_NotEmpty();
+ }
+
+ void AddSpacesBeforeName()
+ {
+ if (!_s.IsEmpty())
+ {
+ _s.Add_Space();
+ _s.Add_Space();
+ }
+ }
+
+ void PrintSeparatorLine(const CObjectVector<CHasherState> &hashers);
+ void PrintResultLine(UInt64 fileSize,
+ const CObjectVector<CHasherState> &hashers, unsigned digestIndex, bool showHash, const AString &path);
+ void PrintProperty(const char *name, UInt64 value);
+
+public:
+ bool PrintNameInPercents;
+ bool PrintHeaders;
+ // bool PrintSize;
+ // bool PrintNewLine; // set it too (false), if you need only hash for single file without LF char.
+ AString PrintFields;
+
+ AString GetFields() const;
+
+ CHashCallbackConsole():
+ PrintNameInPercents(true),
+ PrintHeaders(false)
+ // , PrintSize(true),
+ // , PrintNewLine(true)
+ {}
+};
+
+void PrintHashStat(CStdOutStream &so, const CHashBundle &hb);
+
+#endif
diff --git a/CPP/7zip/UI/Console/List.cpp b/CPP/7zip/UI/Console/List.cpp
index c56e2e2..46819f1 100644
--- a/CPP/7zip/UI/Console/List.cpp
+++ b/CPP/7zip/UI/Console/List.cpp
@@ -1,1359 +1,1390 @@
-// List.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/MyCom.h"
-#include "../../../Common/StdOutStream.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/UTFConvert.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/PropVariant.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#include "../Common/OpenArchive.h"
-#include "../Common/PropIDUtils.h"
-
-#include "ConsoleClose.h"
-#include "List.h"
-#include "OpenCallbackConsole.h"
-
-using namespace NWindows;
-using namespace NCOM;
-
-extern CStdOutStream *g_StdStream;
-extern CStdOutStream *g_ErrStream;
-
-static const char * const kPropIdToName[] =
-{
- "0"
- , "1"
- , "2"
- , "Path"
- , "Name"
- , "Extension"
- , "Folder"
- , "Size"
- , "Packed Size"
- , "Attributes"
- , "Created"
- , "Accessed"
- , "Modified"
- , "Solid"
- , "Commented"
- , "Encrypted"
- , "Split Before"
- , "Split After"
- , "Dictionary Size"
- , "CRC"
- , "Type"
- , "Anti"
- , "Method"
- , "Host OS"
- , "File System"
- , "User"
- , "Group"
- , "Block"
- , "Comment"
- , "Position"
- , "Path Prefix"
- , "Folders"
- , "Files"
- , "Version"
- , "Volume"
- , "Multivolume"
- , "Offset"
- , "Links"
- , "Blocks"
- , "Volumes"
- , "Time Type"
- , "64-bit"
- , "Big-endian"
- , "CPU"
- , "Physical Size"
- , "Headers Size"
- , "Checksum"
- , "Characteristics"
- , "Virtual Address"
- , "ID"
- , "Short Name"
- , "Creator Application"
- , "Sector Size"
- , "Mode"
- , "Symbolic Link"
- , "Error"
- , "Total Size"
- , "Free Space"
- , "Cluster Size"
- , "Label"
- , "Local Name"
- , "Provider"
- , "NT Security"
- , "Alternate Stream"
- , "Aux"
- , "Deleted"
- , "Tree"
- , "SHA-1"
- , "SHA-256"
- , "Error Type"
- , "Errors"
- , "Errors"
- , "Warnings"
- , "Warning"
- , "Streams"
- , "Alternate Streams"
- , "Alternate Streams Size"
- , "Virtual Size"
- , "Unpack Size"
- , "Total Physical Size"
- , "Volume Index"
- , "SubType"
- , "Short Comment"
- , "Code Page"
- , "Is not archive type"
- , "Physical Size can't be detected"
- , "Zeros Tail Is Allowed"
- , "Tail Size"
- , "Embedded Stub Size"
- , "Link"
- , "Hard Link"
- , "iNode"
- , "Stream ID"
- , "Read-only"
- , "Out Name"
- , "Copy Link"
-};
-
-static const char kEmptyAttribChar = '.';
-
-static const char * const kListing = "Listing archive: ";
-
-static const char * const kString_Files = "files";
-static const char * const kString_Dirs = "folders";
-static const char * const kString_AltStreams = "alternate streams";
-static const char * const kString_Streams = "streams";
-
-static const char * const kError = "ERROR: ";
-
-static void GetAttribString(UInt32 wa, bool isDir, bool allAttribs, char *s)
-{
- if (isDir)
- wa |= FILE_ATTRIBUTE_DIRECTORY;
- if (allAttribs)
- {
- ConvertWinAttribToString(s, wa);
- return;
- }
- s[0] = ((wa & FILE_ATTRIBUTE_DIRECTORY) != 0) ? 'D': kEmptyAttribChar;
- s[1] = ((wa & FILE_ATTRIBUTE_READONLY) != 0) ? 'R': kEmptyAttribChar;
- s[2] = ((wa & FILE_ATTRIBUTE_HIDDEN) != 0) ? 'H': kEmptyAttribChar;
- s[3] = ((wa & FILE_ATTRIBUTE_SYSTEM) != 0) ? 'S': kEmptyAttribChar;
- s[4] = ((wa & FILE_ATTRIBUTE_ARCHIVE) != 0) ? 'A': kEmptyAttribChar;
- s[5] = 0;
-}
-
-enum EAdjustment
-{
- kLeft,
- kCenter,
- kRight
-};
-
-struct CFieldInfo
-{
- PROPID PropID;
- bool IsRawProp;
- UString NameU;
- AString NameA;
- EAdjustment TitleAdjustment;
- EAdjustment TextAdjustment;
- unsigned PrefixSpacesWidth;
- unsigned Width;
-};
-
-struct CFieldInfoInit
-{
- PROPID PropID;
- const char *Name;
- EAdjustment TitleAdjustment;
- EAdjustment TextAdjustment;
- unsigned PrefixSpacesWidth;
- unsigned Width;
-};
-
-static const CFieldInfoInit kStandardFieldTable[] =
-{
- { kpidMTime, " Date Time", kLeft, kLeft, 0, 19 },
- { kpidAttrib, "Attr", kRight, kCenter, 1, 5 },
- { kpidSize, "Size", kRight, kRight, 1, 12 },
- { kpidPackSize, "Compressed", kRight, kRight, 1, 12 },
- { kpidPath, "Name", kLeft, kLeft, 2, 24 }
-};
-
-const unsigned kNumSpacesMax = 32; // it must be larger than max CFieldInfoInit.Width
-static const char *g_Spaces =
-" " ;
-
-static void PrintSpaces(unsigned numSpaces)
-{
- if (numSpaces > 0 && numSpaces <= kNumSpacesMax)
- g_StdOut << g_Spaces + (kNumSpacesMax - numSpaces);
-}
-
-static void PrintSpacesToString(char *dest, unsigned numSpaces)
-{
- unsigned i;
- for (i = 0; i < numSpaces; i++)
- dest[i] = ' ';
- dest[i] = 0;
-}
-
-// extern int g_CodePage;
-
-static void PrintUString(EAdjustment adj, unsigned width, const UString &s, AString &temp)
-{
- /*
- // we don't need multibyte align.
- int codePage = g_CodePage;
- if (codePage == -1)
- codePage = CP_OEMCP;
- if (codePage == CP_UTF8)
- ConvertUnicodeToUTF8(s, temp);
- else
- UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
- */
-
- unsigned numSpaces = 0;
-
- if (width > s.Len())
- {
- numSpaces = width - s.Len();
- unsigned numLeftSpaces = 0;
- switch (adj)
- {
- case kLeft: numLeftSpaces = 0; break;
- case kCenter: numLeftSpaces = numSpaces / 2; break;
- case kRight: numLeftSpaces = numSpaces; break;
- }
- PrintSpaces(numLeftSpaces);
- numSpaces -= numLeftSpaces;
- }
-
- g_StdOut.PrintUString(s, temp);
- PrintSpaces(numSpaces);
-}
-
-static void PrintString(EAdjustment adj, unsigned width, const char *s)
-{
- unsigned numSpaces = 0;
- unsigned len = (unsigned)strlen(s);
-
- if (width > len)
- {
- numSpaces = width - len;
- unsigned numLeftSpaces = 0;
- switch (adj)
- {
- case kLeft: numLeftSpaces = 0; break;
- case kCenter: numLeftSpaces = numSpaces / 2; break;
- case kRight: numLeftSpaces = numSpaces; break;
- }
- PrintSpaces(numLeftSpaces);
- numSpaces -= numLeftSpaces;
- }
-
- g_StdOut << s;
- PrintSpaces(numSpaces);
-}
-
-static void PrintStringToString(char *dest, EAdjustment adj, unsigned width, const char *textString)
-{
- unsigned numSpaces = 0;
- unsigned len = (unsigned)strlen(textString);
-
- if (width > len)
- {
- numSpaces = width - len;
- unsigned numLeftSpaces = 0;
- switch (adj)
- {
- case kLeft: numLeftSpaces = 0; break;
- case kCenter: numLeftSpaces = numSpaces / 2; break;
- case kRight: numLeftSpaces = numSpaces; break;
- }
- PrintSpacesToString(dest, numLeftSpaces);
- dest += numLeftSpaces;
- numSpaces -= numLeftSpaces;
- }
-
- memcpy(dest, textString, len);
- dest += len;
- PrintSpacesToString(dest, numSpaces);
-}
-
-struct CListUInt64Def
-{
- UInt64 Val;
- bool Def;
-
- CListUInt64Def(): Val(0), Def(false) {}
- void Add(UInt64 v) { Val += v; Def = true; }
- void Add(const CListUInt64Def &v) { if (v.Def) Add(v.Val); }
-};
-
-struct CListFileTimeDef
-{
- FILETIME Val;
- bool Def;
-
- CListFileTimeDef(): Def(false) { Val.dwLowDateTime = 0; Val.dwHighDateTime = 0; }
- void Update(const CListFileTimeDef &t)
- {
- if (t.Def && (!Def || CompareFileTime(&Val, &t.Val) < 0))
- {
- Val = t.Val;
- Def = true;
- }
- }
-};
-
-struct CListStat
-{
- CListUInt64Def Size;
- CListUInt64Def PackSize;
- CListFileTimeDef MTime;
- UInt64 NumFiles;
-
- CListStat(): NumFiles(0) {}
- void Update(const CListStat &st)
- {
- Size.Add(st.Size);
- PackSize.Add(st.PackSize);
- MTime.Update(st.MTime);
- NumFiles += st.NumFiles;
- }
- void SetSizeDefIfNoFiles() { if (NumFiles == 0) Size.Def = true; }
-};
-
-struct CListStat2
-{
- CListStat MainFiles;
- CListStat AltStreams;
- UInt64 NumDirs;
-
- CListStat2(): NumDirs(0) {}
-
- void Update(const CListStat2 &st)
- {
- MainFiles.Update(st.MainFiles);
- AltStreams.Update(st.AltStreams);
- NumDirs += st.NumDirs;
- }
- const UInt64 GetNumStreams() const { return MainFiles.NumFiles + AltStreams.NumFiles; }
- CListStat &GetStat(bool altStreamsMode) { return altStreamsMode ? AltStreams : MainFiles; }
-};
-
-class CFieldPrinter
-{
- CObjectVector<CFieldInfo> _fields;
-
- void AddProp(const wchar_t *name, PROPID propID, bool isRawProp);
-public:
- const CArc *Arc;
- bool TechMode;
- UString FilePath;
- AString TempAString;
- UString TempWString;
- bool IsDir;
-
- AString LinesString;
-
- void Clear() { _fields.Clear(); LinesString.Empty(); }
- void Init(const CFieldInfoInit *standardFieldTable, unsigned numItems);
-
- HRESULT AddMainProps(IInArchive *archive);
- HRESULT AddRawProps(IArchiveGetRawProps *getRawProps);
-
- void PrintTitle();
- void PrintTitleLines();
- HRESULT PrintItemInfo(UInt32 index, const CListStat &st);
- void PrintSum(const CListStat &st, UInt64 numDirs, const char *str);
- void PrintSum(const CListStat2 &stat2);
-};
-
-void CFieldPrinter::Init(const CFieldInfoInit *standardFieldTable, unsigned numItems)
-{
- Clear();
- for (unsigned i = 0; i < numItems; i++)
- {
- CFieldInfo &f = _fields.AddNew();
- const CFieldInfoInit &fii = standardFieldTable[i];
- f.PropID = fii.PropID;
- f.IsRawProp = false;
- f.NameA = fii.Name;
- f.TitleAdjustment = fii.TitleAdjustment;
- f.TextAdjustment = fii.TextAdjustment;
- f.PrefixSpacesWidth = fii.PrefixSpacesWidth;
- f.Width = fii.Width;
-
- unsigned k;
- for (k = 0; k < fii.PrefixSpacesWidth; k++)
- LinesString.Add_Space();
- for (k = 0; k < fii.Width; k++)
- LinesString += '-';
- }
-}
-
-static void GetPropName(PROPID propID, const wchar_t *name, AString &nameA, UString &nameU)
-{
- if (propID < ARRAY_SIZE(kPropIdToName))
- {
- nameA = kPropIdToName[propID];
- return;
- }
- if (name)
- nameU = name;
- else
- {
- nameA.Empty();
- nameA.Add_UInt32(propID);
- }
-}
-
-void CFieldPrinter::AddProp(const wchar_t *name, PROPID propID, bool isRawProp)
-{
- CFieldInfo f;
- f.PropID = propID;
- f.IsRawProp = isRawProp;
- GetPropName(propID, name, f.NameA, f.NameU);
- f.NameU += " = ";
- if (!f.NameA.IsEmpty())
- f.NameA += " = ";
- else
- {
- const UString &s = f.NameU;
- AString sA;
- unsigned i;
- for (i = 0; i < s.Len(); i++)
- {
- wchar_t c = s[i];
- if (c >= 0x80)
- break;
- sA += (char)c;
- }
- if (i == s.Len())
- f.NameA = sA;
- }
- _fields.Add(f);
-}
-
-HRESULT CFieldPrinter::AddMainProps(IInArchive *archive)
-{
- UInt32 numProps;
- RINOK(archive->GetNumberOfProperties(&numProps));
- for (UInt32 i = 0; i < numProps; i++)
- {
- CMyComBSTR name;
- PROPID propID;
- VARTYPE vt;
- RINOK(archive->GetPropertyInfo(i, &name, &propID, &vt));
- AddProp(name, propID, false);
- }
- return S_OK;
-}
-
-HRESULT CFieldPrinter::AddRawProps(IArchiveGetRawProps *getRawProps)
-{
- UInt32 numProps;
- RINOK(getRawProps->GetNumRawProps(&numProps));
- for (UInt32 i = 0; i < numProps; i++)
- {
- CMyComBSTR name;
- PROPID propID;
- RINOK(getRawProps->GetRawPropInfo(i, &name, &propID));
- AddProp(name, propID, true);
- }
- return S_OK;
-}
-
-void CFieldPrinter::PrintTitle()
-{
- FOR_VECTOR (i, _fields)
- {
- const CFieldInfo &f = _fields[i];
- PrintSpaces(f.PrefixSpacesWidth);
- PrintString(f.TitleAdjustment, ((f.PropID == kpidPath) ? 0: f.Width), f.NameA);
- }
-}
-
-void CFieldPrinter::PrintTitleLines()
-{
- g_StdOut << LinesString;
-}
-
-static void PrintTime(char *dest, const FILETIME *ft)
-{
- *dest = 0;
- if (ft->dwLowDateTime == 0 && ft->dwHighDateTime == 0)
- return;
- ConvertUtcFileTimeToString(*ft, dest, kTimestampPrintLevel_SEC);
-}
-
-#ifndef _SFX
-
-static inline char GetHex(Byte value)
-{
- return (char)((value < 10) ? ('0' + value) : ('A' + (value - 10)));
-}
-
-static void HexToString(char *dest, const Byte *data, UInt32 size)
-{
- for (UInt32 i = 0; i < size; i++)
- {
- Byte b = data[i];
- dest[0] = GetHex((Byte)((b >> 4) & 0xF));
- dest[1] = GetHex((Byte)(b & 0xF));
- dest += 2;
- }
- *dest = 0;
-}
-
-#endif
-
-#define MY_ENDL endl
-
-HRESULT CFieldPrinter::PrintItemInfo(UInt32 index, const CListStat &st)
-{
- char temp[128];
- size_t tempPos = 0;
-
- bool techMode = this->TechMode;
- /*
- if (techMode)
- {
- g_StdOut << "Index = ";
- g_StdOut << (UInt64)index;
- g_StdOut << endl;
- }
- */
- FOR_VECTOR (i, _fields)
- {
- const CFieldInfo &f = _fields[i];
-
- if (!techMode)
- {
- PrintSpacesToString(temp + tempPos, f.PrefixSpacesWidth);
- tempPos += f.PrefixSpacesWidth;
- }
-
- if (techMode)
- {
- if (!f.NameA.IsEmpty())
- g_StdOut << f.NameA;
- else
- g_StdOut << f.NameU;
- }
-
- if (f.PropID == kpidPath)
- {
- if (!techMode)
- g_StdOut << temp;
- g_StdOut.NormalizePrint_UString(FilePath, TempWString, TempAString);
- if (techMode)
- g_StdOut << MY_ENDL;
- continue;
- }
-
- const unsigned width = f.Width;
-
- if (f.IsRawProp)
- {
- #ifndef _SFX
-
- const void *data;
- UInt32 dataSize;
- UInt32 propType;
- RINOK(Arc->GetRawProps->GetRawProp(index, f.PropID, &data, &dataSize, &propType));
-
- if (dataSize != 0)
- {
- bool needPrint = true;
-
- if (f.PropID == kpidNtSecure)
- {
- if (propType != NPropDataType::kRaw)
- return E_FAIL;
- #ifndef _SFX
- ConvertNtSecureToString((const Byte *)data, dataSize, TempAString);
- g_StdOut << TempAString;
- needPrint = false;
- #endif
- }
- else if (f.PropID == kpidNtReparse)
- {
- UString s;
- if (ConvertNtReparseToString((const Byte *)data, dataSize, s))
- {
- needPrint = false;
- g_StdOut.PrintUString(s, TempAString);
- }
- }
-
- if (needPrint)
- {
- if (propType != NPropDataType::kRaw)
- return E_FAIL;
-
- const UInt32 kMaxDataSize = 64;
-
- if (dataSize > kMaxDataSize)
- {
- g_StdOut << "data:";
- g_StdOut << dataSize;
- }
- else
- {
- char hexStr[kMaxDataSize * 2 + 4];
- HexToString(hexStr, (const Byte *)data, dataSize);
- g_StdOut << hexStr;
- }
- }
- }
-
- #endif
- }
- else
- {
- CPropVariant prop;
- switch (f.PropID)
- {
- case kpidSize: if (st.Size.Def) prop = st.Size.Val; break;
- case kpidPackSize: if (st.PackSize.Def) prop = st.PackSize.Val; break;
- case kpidMTime: if (st.MTime.Def) prop = st.MTime.Val; break;
- default:
- RINOK(Arc->Archive->GetProperty(index, f.PropID, &prop));
- }
- if (f.PropID == kpidAttrib && (prop.vt == VT_EMPTY || prop.vt == VT_UI4))
- {
- GetAttribString((prop.vt == VT_EMPTY) ? 0 : prop.ulVal, IsDir, techMode, temp + tempPos);
- if (techMode)
- g_StdOut << temp + tempPos;
- else
- tempPos += strlen(temp + tempPos);
- }
- else if (prop.vt == VT_EMPTY)
- {
- if (!techMode)
- {
- PrintSpacesToString(temp + tempPos, width);
- tempPos += width;
- }
- }
- else if (prop.vt == VT_FILETIME)
- {
- PrintTime(temp + tempPos, &prop.filetime);
- if (techMode)
- g_StdOut << temp + tempPos;
- else
- {
- size_t len = strlen(temp + tempPos);
- tempPos += len;
- if (len < (unsigned)f.Width)
- {
- len = f.Width - len;
- PrintSpacesToString(temp + tempPos, (unsigned)len);
- tempPos += len;
- }
- }
- }
- else if (prop.vt == VT_BSTR)
- {
- TempWString.SetFromBstr(prop.bstrVal);
- // do we need multi-line support here ?
- g_StdOut.Normalize_UString(TempWString);
- if (techMode)
- {
- g_StdOut.PrintUString(TempWString, TempAString);
- }
- else
- PrintUString(f.TextAdjustment, width, TempWString, TempAString);
- }
- else
- {
- char s[64];
- ConvertPropertyToShortString2(s, prop, f.PropID);
- if (techMode)
- g_StdOut << s;
- else
- {
- PrintStringToString(temp + tempPos, f.TextAdjustment, width, s);
- tempPos += strlen(temp + tempPos);
- }
- }
- }
- if (techMode)
- g_StdOut << MY_ENDL;
- }
- g_StdOut << MY_ENDL;
- return S_OK;
-}
-
-static void PrintNumber(EAdjustment adj, unsigned width, const CListUInt64Def &value)
-{
- char s[32];
- s[0] = 0;
- if (value.Def)
- ConvertUInt64ToString(value.Val, s);
- PrintString(adj, width, s);
-}
-
-void Print_UInt64_and_String(AString &s, UInt64 val, const char *name);
-
-void CFieldPrinter::PrintSum(const CListStat &st, UInt64 numDirs, const char *str)
-{
- FOR_VECTOR (i, _fields)
- {
- const CFieldInfo &f = _fields[i];
- PrintSpaces(f.PrefixSpacesWidth);
- if (f.PropID == kpidSize)
- PrintNumber(f.TextAdjustment, f.Width, st.Size);
- else if (f.PropID == kpidPackSize)
- PrintNumber(f.TextAdjustment, f.Width, st.PackSize);
- else if (f.PropID == kpidMTime)
- {
- char s[64];
- s[0] = 0;
- if (st.MTime.Def)
- PrintTime(s, &st.MTime.Val);
- PrintString(f.TextAdjustment, f.Width, s);
- }
- else if (f.PropID == kpidPath)
- {
- AString s;
- Print_UInt64_and_String(s, st.NumFiles, str);
- if (numDirs != 0)
- {
- s += ", ";
- Print_UInt64_and_String(s, numDirs, kString_Dirs);
- }
- PrintString(f.TextAdjustment, 0, s);
- }
- else
- PrintString(f.TextAdjustment, f.Width, "");
- }
- g_StdOut << endl;
-}
-
-void CFieldPrinter::PrintSum(const CListStat2 &stat2)
-{
- PrintSum(stat2.MainFiles, stat2.NumDirs, kString_Files);
- if (stat2.AltStreams.NumFiles != 0)
- {
- PrintSum(stat2.AltStreams, 0, kString_AltStreams);;
- CListStat st = stat2.MainFiles;
- st.Update(stat2.AltStreams);
- PrintSum(st, 0, kString_Streams);
- }
-}
-
-static HRESULT GetUInt64Value(IInArchive *archive, UInt32 index, PROPID propID, CListUInt64Def &value)
-{
- value.Val = 0;
- value.Def = false;
- CPropVariant prop;
- RINOK(archive->GetProperty(index, propID, &prop));
- value.Def = ConvertPropVariantToUInt64(prop, value.Val);
- return S_OK;
-}
-
-static HRESULT GetItemMTime(IInArchive *archive, UInt32 index, CListFileTimeDef &t)
-{
- t.Val.dwLowDateTime = 0;
- t.Val.dwHighDateTime = 0;
- t.Def = false;
- CPropVariant prop;
- RINOK(archive->GetProperty(index, kpidMTime, &prop));
- if (prop.vt == VT_FILETIME)
- {
- t.Val = prop.filetime;
- t.Def = true;
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-static void PrintPropNameAndNumber(CStdOutStream &so, const char *name, UInt64 val)
-{
- so << name << ": " << val << endl;
-}
-
-static void PrintPropName_and_Eq(CStdOutStream &so, PROPID propID)
-{
- const char *s;
- char temp[16];
- if (propID < ARRAY_SIZE(kPropIdToName))
- s = kPropIdToName[propID];
- else
- {
- ConvertUInt32ToString(propID, temp);
- s = temp;
- }
- so << s << " = ";
-}
-
-static void PrintPropNameAndNumber(CStdOutStream &so, PROPID propID, UInt64 val)
-{
- PrintPropName_and_Eq(so, propID);
- so << val << endl;
-}
-
-static void PrintPropNameAndNumber_Signed(CStdOutStream &so, PROPID propID, Int64 val)
-{
- PrintPropName_and_Eq(so, propID);
- so << val << endl;
-}
-
-
-static void UString_Replace_CRLF_to_LF(UString &s)
-{
- // s.Replace(L"\r\n", L"\n");
- wchar_t *src = s.GetBuf();
- wchar_t *dest = src;
- for (;;)
- {
- wchar_t c = *src++;
- if (c == 0)
- break;
- if (c == '\r' && *src == '\n')
- {
- src++;
- c = '\n';
- }
- *dest++ = c;
- }
- s.ReleaseBuf_SetEnd((unsigned)(dest - s.GetBuf()));
-}
-
-
-static void PrintPropVal_MultiLine(CStdOutStream &so, const wchar_t *val)
-{
- UString s = val;
- if (s.Find(L'\n') >= 0)
- {
- so << endl;
- so << "{";
- so << endl;
- UString_Replace_CRLF_to_LF(s);
- so.Normalize_UString__LF_Allowed(s);
- so << s;
- so << endl;
- so << "}";
- }
- else
- {
- so.Normalize_UString(s);
- so << s;
- }
- so << endl;
-}
-
-
-static void PrintPropPair(CStdOutStream &so, const char *name, const wchar_t *val, bool multiLine)
-{
- so << name << " = ";
- if (multiLine)
- {
- PrintPropVal_MultiLine(so, val);
- return;
- }
- UString s = val;
- so.Normalize_UString(s);
- so << s;
- so << endl;
-}
-
-
-static void PrintPropertyPair2(CStdOutStream &so, PROPID propID, const wchar_t *name, const CPropVariant &prop)
-{
- UString s;
- ConvertPropertyToString2(s, prop, propID);
- if (!s.IsEmpty())
- {
- AString nameA;
- UString nameU;
- GetPropName(propID, name, nameA, nameU);
- if (!nameA.IsEmpty())
- so << nameA;
- else
- so << nameU;
- so << " = ";
- PrintPropVal_MultiLine(so, s);
- }
-}
-
-static HRESULT PrintArcProp(CStdOutStream &so, IInArchive *archive, PROPID propID, const wchar_t *name)
-{
- CPropVariant prop;
- RINOK(archive->GetArchiveProperty(propID, &prop));
- PrintPropertyPair2(so, propID, name, prop);
- return S_OK;
-}
-
-static void PrintArcTypeError(CStdOutStream &so, const UString &type, bool isWarning)
-{
- so << "Open " << (isWarning ? "WARNING" : "ERROR")
- << ": Can not open the file as ["
- << type
- << "] archive"
- << endl;
-}
-
-int Find_FileName_InSortedVector(const UStringVector &fileName, const UString& name);
-
-void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags);
-
-static void ErrorInfo_Print(CStdOutStream &so, const CArcErrorInfo &er)
-{
- PrintErrorFlags(so, "ERRORS:", er.GetErrorFlags());
- if (!er.ErrorMessage.IsEmpty())
- PrintPropPair(so, "ERROR", er.ErrorMessage, true);
-
- PrintErrorFlags(so, "WARNINGS:", er.GetWarningFlags());
- if (!er.WarningMessage.IsEmpty())
- PrintPropPair(so, "WARNING", er.WarningMessage, true);
-}
-
-HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink)
-{
- FOR_VECTOR (r, arcLink.Arcs)
- {
- const CArc &arc = arcLink.Arcs[r];
- const CArcErrorInfo &er = arc.ErrorInfo;
-
- so << "--\n";
- PrintPropPair(so, "Path", arc.Path, false);
- if (er.ErrorFormatIndex >= 0)
- {
- if (er.ErrorFormatIndex == arc.FormatIndex)
- so << "Warning: The archive is open with offset" << endl;
- else
- PrintArcTypeError(so, codecs->GetFormatNamePtr(er.ErrorFormatIndex), true);
- }
- PrintPropPair(so, "Type", codecs->GetFormatNamePtr(arc.FormatIndex), false);
-
- ErrorInfo_Print(so, er);
-
- Int64 offset = arc.GetGlobalOffset();
- if (offset != 0)
- PrintPropNameAndNumber_Signed(so, kpidOffset, offset);
- IInArchive *archive = arc.Archive;
- RINOK(PrintArcProp(so, archive, kpidPhySize, NULL));
- if (er.TailSize != 0)
- PrintPropNameAndNumber(so, kpidTailSize, er.TailSize);
- {
- UInt32 numProps;
- RINOK(archive->GetNumberOfArchiveProperties(&numProps));
-
- for (UInt32 j = 0; j < numProps; j++)
- {
- CMyComBSTR name;
- PROPID propID;
- VARTYPE vt;
- RINOK(archive->GetArchivePropertyInfo(j, &name, &propID, &vt));
- RINOK(PrintArcProp(so, archive, propID, name));
- }
- }
-
- if (r != arcLink.Arcs.Size() - 1)
- {
- UInt32 numProps;
- so << "----\n";
- if (archive->GetNumberOfProperties(&numProps) == S_OK)
- {
- UInt32 mainIndex = arcLink.Arcs[r + 1].SubfileIndex;
- for (UInt32 j = 0; j < numProps; j++)
- {
- CMyComBSTR name;
- PROPID propID;
- VARTYPE vt;
- RINOK(archive->GetPropertyInfo(j, &name, &propID, &vt));
- CPropVariant prop;
- RINOK(archive->GetProperty(mainIndex, propID, &prop));
- PrintPropertyPair2(so, propID, name, prop);
- }
- }
- }
- }
- return S_OK;
-}
-
-HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink)
-{
- #ifndef _NO_CRYPTO
- if (arcLink.PasswordWasAsked)
- so << "Can not open encrypted archive. Wrong password?";
- else
- #endif
- {
- if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
- {
- so.NormalizePrint_UString(arcLink.NonOpen_ArcPath);
- so << endl;
- PrintArcTypeError(so, codecs->Formats[arcLink.NonOpen_ErrorInfo.ErrorFormatIndex].Name, false);
- }
- else
- so << "Can not open the file as archive";
- }
-
- so << endl;
- so << endl;
- ErrorInfo_Print(so, arcLink.NonOpen_ErrorInfo);
-
- return S_OK;
-}
-
-bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item);
-
-HRESULT ListArchives(CCodecs *codecs,
- const CObjectVector<COpenType> &types,
- const CIntVector &excludedFormats,
- bool stdInMode,
- UStringVector &arcPaths, UStringVector &arcPathsFull,
- bool processAltStreams, bool showAltStreams,
- const NWildcard::CCensorNode &wildcardCensor,
- bool enableHeaders, bool techMode,
- #ifndef _NO_CRYPTO
- bool &passwordEnabled, UString &password,
- #endif
- #ifndef _SFX
- const CObjectVector<CProperty> *props,
- #endif
- UInt64 &numErrors,
- UInt64 &numWarnings)
-{
- bool allFilesAreAllowed = wildcardCensor.AreAllAllowed();
-
- numErrors = 0;
- numWarnings = 0;
-
- CFieldPrinter fp;
- if (!techMode)
- fp.Init(kStandardFieldTable, ARRAY_SIZE(kStandardFieldTable));
-
- CListStat2 stat2total;
-
- CBoolArr skipArcs(arcPaths.Size());
- unsigned arcIndex;
- for (arcIndex = 0; arcIndex < arcPaths.Size(); arcIndex++)
- skipArcs[arcIndex] = false;
- UInt64 numVolumes = 0;
- UInt64 numArcs = 0;
- UInt64 totalArcSizes = 0;
-
- HRESULT lastError = 0;
-
- for (arcIndex = 0; arcIndex < arcPaths.Size(); arcIndex++)
- {
- if (skipArcs[arcIndex])
- continue;
- const UString &arcPath = arcPaths[arcIndex];
- UInt64 arcPackSize = 0;
-
- if (!stdInMode)
- {
- NFile::NFind::CFileInfo fi;
- if (!fi.Find(us2fs(arcPath)))
- {
- DWORD errorCode = GetLastError();
- if (errorCode == 0)
- errorCode = ERROR_FILE_NOT_FOUND;
- lastError = HRESULT_FROM_WIN32(lastError);;
- g_StdOut.Flush();
- if (g_ErrStream)
- {
- *g_ErrStream << endl << kError << NError::MyFormatMessage(errorCode) << endl;
- g_ErrStream->NormalizePrint_UString(arcPath);
- *g_ErrStream << endl << endl;
- }
- numErrors++;
- continue;
- }
- if (fi.IsDir())
- {
- g_StdOut.Flush();
- if (g_ErrStream)
- {
- *g_ErrStream << endl << kError;
- g_ErrStream->NormalizePrint_UString(arcPath);
- *g_ErrStream << " is not a file" << endl << endl;
- }
- numErrors++;
- continue;
- }
- arcPackSize = fi.Size;
- totalArcSizes += arcPackSize;
- }
-
- CArchiveLink arcLink;
-
- COpenCallbackConsole openCallback;
- openCallback.Init(&g_StdOut, g_ErrStream, NULL);
-
- #ifndef _NO_CRYPTO
-
- openCallback.PasswordIsDefined = passwordEnabled;
- openCallback.Password = password;
-
- #endif
-
- /*
- CObjectVector<COptionalOpenProperties> optPropsVector;
- COptionalOpenProperties &optProps = optPropsVector.AddNew();
- optProps.Props = *props;
- */
-
- COpenOptions options;
- #ifndef _SFX
- options.props = props;
- #endif
- options.codecs = codecs;
- options.types = &types;
- options.excludedFormats = &excludedFormats;
- options.stdInMode = stdInMode;
- options.stream = NULL;
- options.filePath = arcPath;
-
- if (enableHeaders)
- {
- g_StdOut << endl << kListing;
- g_StdOut.NormalizePrint_UString(arcPath);
- g_StdOut << endl << endl;
- }
-
- HRESULT result = arcLink.Open_Strict(options, &openCallback);
-
- if (result != S_OK)
- {
- if (result == E_ABORT)
- return result;
- if (result != S_FALSE)
- lastError = result;
- g_StdOut.Flush();
- if (g_ErrStream)
- {
- *g_ErrStream << endl << kError;
- g_ErrStream->NormalizePrint_UString(arcPath);
- *g_ErrStream << " : ";
- if (result == S_FALSE)
- {
- Print_OpenArchive_Error(*g_ErrStream, codecs, arcLink);
- }
- else
- {
- *g_ErrStream << "opening : ";
- if (result == E_OUTOFMEMORY)
- *g_ErrStream << "Can't allocate required memory";
- else
- *g_ErrStream << NError::MyFormatMessage(result);
- }
- *g_ErrStream << endl;
- }
- numErrors++;
- continue;
- }
-
- {
- FOR_VECTOR (r, arcLink.Arcs)
- {
- const CArcErrorInfo &arc = arcLink.Arcs[r].ErrorInfo;
- if (!arc.WarningMessage.IsEmpty())
- numWarnings++;
- if (arc.AreThereWarnings())
- numWarnings++;
- if (arc.ErrorFormatIndex >= 0)
- numWarnings++;
- if (arc.AreThereErrors())
- {
- numErrors++;
- // break;
- }
- if (!arc.ErrorMessage.IsEmpty())
- numErrors++;
- }
- }
-
- numArcs++;
- numVolumes++;
-
- if (!stdInMode)
- {
- numVolumes += arcLink.VolumePaths.Size();
- totalArcSizes += arcLink.VolumesSize;
- FOR_VECTOR (v, arcLink.VolumePaths)
- {
- int index = Find_FileName_InSortedVector(arcPathsFull, arcLink.VolumePaths[v]);
- if (index >= 0 && (unsigned)index > arcIndex)
- skipArcs[(unsigned)index] = true;
- }
- }
-
-
- if (enableHeaders)
- {
- RINOK(Print_OpenArchive_Props(g_StdOut, codecs, arcLink));
-
- g_StdOut << endl;
- if (techMode)
- g_StdOut << "----------\n";
- }
-
- if (enableHeaders && !techMode)
- {
- fp.PrintTitle();
- g_StdOut << endl;
- fp.PrintTitleLines();
- g_StdOut << endl;
- }
-
- const CArc &arc = arcLink.Arcs.Back();
- fp.Arc = &arc;
- fp.TechMode = techMode;
- IInArchive *archive = arc.Archive;
- if (techMode)
- {
- fp.Clear();
- RINOK(fp.AddMainProps(archive));
- if (arc.GetRawProps)
- {
- RINOK(fp.AddRawProps(arc.GetRawProps));
- }
- }
-
- CListStat2 stat2;
-
- UInt32 numItems;
- RINOK(archive->GetNumberOfItems(&numItems));
-
- CReadArcItem item;
- UStringVector pathParts;
-
- for (UInt32 i = 0; i < numItems; i++)
- {
- if (NConsoleClose::TestBreakSignal())
- return E_ABORT;
-
- HRESULT res = arc.GetItemPath2(i, fp.FilePath);
-
- if (stdInMode && res == E_INVALIDARG)
- break;
- RINOK(res);
-
- if (arc.Ask_Aux)
- {
- bool isAux;
- RINOK(Archive_IsItem_Aux(archive, i, isAux));
- if (isAux)
- continue;
- }
-
- bool isAltStream = false;
- if (arc.Ask_AltStream)
- {
- RINOK(Archive_IsItem_AltStream(archive, i, isAltStream));
- if (isAltStream && !processAltStreams)
- continue;
- }
-
- RINOK(Archive_IsItem_Dir(archive, i, fp.IsDir));
-
- if (!allFilesAreAllowed)
- {
- if (isAltStream)
- {
- RINOK(arc.GetItem(i, item));
- if (!CensorNode_CheckPath(wildcardCensor, item))
- continue;
- }
- else
- {
- SplitPathToParts(fp.FilePath, pathParts);;
- bool include;
- if (!wildcardCensor.CheckPathVect(pathParts, !fp.IsDir, include))
- continue;
- if (!include)
- continue;
- }
- }
-
- CListStat st;
-
- RINOK(GetUInt64Value(archive, i, kpidSize, st.Size));
- RINOK(GetUInt64Value(archive, i, kpidPackSize, st.PackSize));
- RINOK(GetItemMTime(archive, i, st.MTime));
-
- if (fp.IsDir)
- stat2.NumDirs++;
- else
- st.NumFiles = 1;
- stat2.GetStat(isAltStream).Update(st);
-
- if (isAltStream && !showAltStreams)
- continue;
- RINOK(fp.PrintItemInfo(i, st));
- }
-
- UInt64 numStreams = stat2.GetNumStreams();
- if (!stdInMode
- && !stat2.MainFiles.PackSize.Def
- && !stat2.AltStreams.PackSize.Def)
- {
- if (arcLink.VolumePaths.Size() != 0)
- arcPackSize += arcLink.VolumesSize;
- stat2.MainFiles.PackSize.Add((numStreams == 0) ? 0 : arcPackSize);
- }
-
- stat2.MainFiles.SetSizeDefIfNoFiles();
- stat2.AltStreams.SetSizeDefIfNoFiles();
-
- if (enableHeaders && !techMode)
- {
- fp.PrintTitleLines();
- g_StdOut << endl;
- fp.PrintSum(stat2);
- }
-
- if (enableHeaders)
- {
- if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
- {
- g_StdOut << "----------\n";
- PrintPropPair(g_StdOut, "Path", arcLink.NonOpen_ArcPath, false);
- PrintArcTypeError(g_StdOut, codecs->Formats[arcLink.NonOpen_ErrorInfo.ErrorFormatIndex].Name, false);
- }
- }
-
- stat2total.Update(stat2);
-
- g_StdOut.Flush();
- }
-
- if (enableHeaders && !techMode && (arcPaths.Size() > 1 || numVolumes > 1))
- {
- g_StdOut << endl;
- fp.PrintTitleLines();
- g_StdOut << endl;
- fp.PrintSum(stat2total);
- g_StdOut << endl;
- PrintPropNameAndNumber(g_StdOut, "Archives", numArcs);
- PrintPropNameAndNumber(g_StdOut, "Volumes", numVolumes);
- PrintPropNameAndNumber(g_StdOut, "Total archives size", totalArcSizes);
- }
-
- if (numErrors == 1 && lastError != 0)
- return lastError;
-
- return S_OK;
-}
+// List.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyCom.h"
+#include "../../../Common/StdOutStream.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../Common/OpenArchive.h"
+#include "../Common/PropIDUtils.h"
+
+#include "ConsoleClose.h"
+#include "List.h"
+#include "OpenCallbackConsole.h"
+
+using namespace NWindows;
+using namespace NCOM;
+
+extern CStdOutStream *g_StdStream;
+extern CStdOutStream *g_ErrStream;
+
+static const char * const kPropIdToName[] =
+{
+ "0"
+ , "1"
+ , "2"
+ , "Path"
+ , "Name"
+ , "Extension"
+ , "Folder"
+ , "Size"
+ , "Packed Size"
+ , "Attributes"
+ , "Created"
+ , "Accessed"
+ , "Modified"
+ , "Solid"
+ , "Commented"
+ , "Encrypted"
+ , "Split Before"
+ , "Split After"
+ , "Dictionary Size"
+ , "CRC"
+ , "Type"
+ , "Anti"
+ , "Method"
+ , "Host OS"
+ , "File System"
+ , "User"
+ , "Group"
+ , "Block"
+ , "Comment"
+ , "Position"
+ , "Path Prefix"
+ , "Folders"
+ , "Files"
+ , "Version"
+ , "Volume"
+ , "Multivolume"
+ , "Offset"
+ , "Links"
+ , "Blocks"
+ , "Volumes"
+ , "Time Type"
+ , "64-bit"
+ , "Big-endian"
+ , "CPU"
+ , "Physical Size"
+ , "Headers Size"
+ , "Checksum"
+ , "Characteristics"
+ , "Virtual Address"
+ , "ID"
+ , "Short Name"
+ , "Creator Application"
+ , "Sector Size"
+ , "Mode"
+ , "Symbolic Link"
+ , "Error"
+ , "Total Size"
+ , "Free Space"
+ , "Cluster Size"
+ , "Label"
+ , "Local Name"
+ , "Provider"
+ , "NT Security"
+ , "Alternate Stream"
+ , "Aux"
+ , "Deleted"
+ , "Tree"
+ , "SHA-1"
+ , "SHA-256"
+ , "Error Type"
+ , "Errors"
+ , "Errors"
+ , "Warnings"
+ , "Warning"
+ , "Streams"
+ , "Alternate Streams"
+ , "Alternate Streams Size"
+ , "Virtual Size"
+ , "Unpack Size"
+ , "Total Physical Size"
+ , "Volume Index"
+ , "SubType"
+ , "Short Comment"
+ , "Code Page"
+ , "Is not archive type"
+ , "Physical Size can't be detected"
+ , "Zeros Tail Is Allowed"
+ , "Tail Size"
+ , "Embedded Stub Size"
+ , "Link"
+ , "Hard Link"
+ , "iNode"
+ , "Stream ID"
+ , "Read-only"
+ , "Out Name"
+ , "Copy Link"
+ , "ArcFileName"
+ , "IsHash"
+ , "Metadata Changed"
+ , "User ID"
+ , "Group ID"
+ , "Device Major"
+ , "Device Minor"
+ , "Dev Major"
+ , "Dev Minor"
+};
+
+static const char kEmptyAttribChar = '.';
+
+static const char * const kListing = "Listing archive: ";
+
+static const char * const kString_Files = "files";
+static const char * const kString_Dirs = "folders";
+static const char * const kString_AltStreams = "alternate streams";
+static const char * const kString_Streams = "streams";
+
+static const char * const kError = "ERROR: ";
+
+static void GetAttribString(UInt32 wa, bool isDir, bool allAttribs, char *s)
+{
+ if (isDir)
+ wa |= FILE_ATTRIBUTE_DIRECTORY;
+ if (allAttribs)
+ {
+ ConvertWinAttribToString(s, wa);
+ return;
+ }
+ s[0] = ((wa & FILE_ATTRIBUTE_DIRECTORY) != 0) ? 'D': kEmptyAttribChar;
+ s[1] = ((wa & FILE_ATTRIBUTE_READONLY) != 0) ? 'R': kEmptyAttribChar;
+ s[2] = ((wa & FILE_ATTRIBUTE_HIDDEN) != 0) ? 'H': kEmptyAttribChar;
+ s[3] = ((wa & FILE_ATTRIBUTE_SYSTEM) != 0) ? 'S': kEmptyAttribChar;
+ s[4] = ((wa & FILE_ATTRIBUTE_ARCHIVE) != 0) ? 'A': kEmptyAttribChar;
+ s[5] = 0;
+}
+
+enum EAdjustment
+{
+ kLeft,
+ kCenter,
+ kRight
+};
+
+struct CFieldInfo
+{
+ PROPID PropID;
+ bool IsRawProp;
+ UString NameU;
+ AString NameA;
+ EAdjustment TitleAdjustment;
+ EAdjustment TextAdjustment;
+ unsigned PrefixSpacesWidth;
+ unsigned Width;
+};
+
+struct CFieldInfoInit
+{
+ PROPID PropID;
+ const char *Name;
+ EAdjustment TitleAdjustment;
+ EAdjustment TextAdjustment;
+ unsigned PrefixSpacesWidth;
+ unsigned Width;
+};
+
+static const CFieldInfoInit kStandardFieldTable[] =
+{
+ { kpidMTime, " Date Time", kLeft, kLeft, 0, 19 },
+ { kpidAttrib, "Attr", kRight, kCenter, 1, 5 },
+ { kpidSize, "Size", kRight, kRight, 1, 12 },
+ { kpidPackSize, "Compressed", kRight, kRight, 1, 12 },
+ { kpidPath, "Name", kLeft, kLeft, 2, 24 }
+};
+
+const unsigned kNumSpacesMax = 32; // it must be larger than max CFieldInfoInit.Width
+static const char *g_Spaces =
+" " ;
+
+static void PrintSpaces(unsigned numSpaces)
+{
+ if (numSpaces > 0 && numSpaces <= kNumSpacesMax)
+ g_StdOut << g_Spaces + (kNumSpacesMax - numSpaces);
+}
+
+static void PrintSpacesToString(char *dest, unsigned numSpaces)
+{
+ unsigned i;
+ for (i = 0; i < numSpaces; i++)
+ dest[i] = ' ';
+ dest[i] = 0;
+}
+
+// extern int g_CodePage;
+
+static void PrintUString(EAdjustment adj, unsigned width, const UString &s, AString &temp)
+{
+ /*
+ // we don't need multibyte align.
+ int codePage = g_CodePage;
+ if (codePage == -1)
+ codePage = CP_OEMCP;
+ if (codePage == CP_UTF8)
+ ConvertUnicodeToUTF8(s, temp);
+ else
+ UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
+ */
+
+ unsigned numSpaces = 0;
+
+ if (width > s.Len())
+ {
+ numSpaces = width - s.Len();
+ unsigned numLeftSpaces = 0;
+ switch (adj)
+ {
+ case kLeft: numLeftSpaces = 0; break;
+ case kCenter: numLeftSpaces = numSpaces / 2; break;
+ case kRight: numLeftSpaces = numSpaces; break;
+ }
+ PrintSpaces(numLeftSpaces);
+ numSpaces -= numLeftSpaces;
+ }
+
+ g_StdOut.PrintUString(s, temp);
+ PrintSpaces(numSpaces);
+}
+
+static void PrintString(EAdjustment adj, unsigned width, const char *s)
+{
+ unsigned numSpaces = 0;
+ unsigned len = (unsigned)strlen(s);
+
+ if (width > len)
+ {
+ numSpaces = width - len;
+ unsigned numLeftSpaces = 0;
+ switch (adj)
+ {
+ case kLeft: numLeftSpaces = 0; break;
+ case kCenter: numLeftSpaces = numSpaces / 2; break;
+ case kRight: numLeftSpaces = numSpaces; break;
+ }
+ PrintSpaces(numLeftSpaces);
+ numSpaces -= numLeftSpaces;
+ }
+
+ g_StdOut << s;
+ PrintSpaces(numSpaces);
+}
+
+static void PrintStringToString(char *dest, EAdjustment adj, unsigned width, const char *textString)
+{
+ unsigned numSpaces = 0;
+ unsigned len = (unsigned)strlen(textString);
+
+ if (width > len)
+ {
+ numSpaces = width - len;
+ unsigned numLeftSpaces = 0;
+ switch (adj)
+ {
+ case kLeft: numLeftSpaces = 0; break;
+ case kCenter: numLeftSpaces = numSpaces / 2; break;
+ case kRight: numLeftSpaces = numSpaces; break;
+ }
+ PrintSpacesToString(dest, numLeftSpaces);
+ dest += numLeftSpaces;
+ numSpaces -= numLeftSpaces;
+ }
+
+ memcpy(dest, textString, len);
+ dest += len;
+ PrintSpacesToString(dest, numSpaces);
+}
+
+struct CListUInt64Def
+{
+ UInt64 Val;
+ bool Def;
+
+ CListUInt64Def(): Val(0), Def(false) {}
+ void Add(UInt64 v) { Val += v; Def = true; }
+ void Add(const CListUInt64Def &v) { if (v.Def) Add(v.Val); }
+};
+
+
+struct CListFileTimeDef: public CArcTime
+{
+ void Update(const CListFileTimeDef &t)
+ {
+ if (t.Def && (!Def || CompareWith(t) < 0))
+ (*this) = t;
+ }
+};
+
+
+
+struct CListStat
+{
+ CListUInt64Def Size;
+ CListUInt64Def PackSize;
+ CListFileTimeDef MTime;
+ UInt64 NumFiles;
+
+ CListStat(): NumFiles(0) {}
+ void Update(const CListStat &st)
+ {
+ Size.Add(st.Size);
+ PackSize.Add(st.PackSize);
+ MTime.Update(st.MTime);
+ NumFiles += st.NumFiles;
+ }
+ void SetSizeDefIfNoFiles() { if (NumFiles == 0) Size.Def = true; }
+};
+
+struct CListStat2
+{
+ CListStat MainFiles;
+ CListStat AltStreams;
+ UInt64 NumDirs;
+
+ CListStat2(): NumDirs(0) {}
+
+ void Update(const CListStat2 &st)
+ {
+ MainFiles.Update(st.MainFiles);
+ AltStreams.Update(st.AltStreams);
+ NumDirs += st.NumDirs;
+ }
+ UInt64 GetNumStreams() const { return MainFiles.NumFiles + AltStreams.NumFiles; }
+ CListStat &GetStat(bool altStreamsMode) { return altStreamsMode ? AltStreams : MainFiles; }
+};
+
+class CFieldPrinter
+{
+ CObjectVector<CFieldInfo> _fields;
+
+ void AddProp(const wchar_t *name, PROPID propID, bool isRawProp);
+public:
+ const CArc *Arc;
+ bool TechMode;
+ UString FilePath;
+ AString TempAString;
+ UString TempWString;
+ bool IsDir;
+
+ AString LinesString;
+
+ void Clear() { _fields.Clear(); LinesString.Empty(); }
+ void Init(const CFieldInfoInit *standardFieldTable, unsigned numItems);
+
+ HRESULT AddMainProps(IInArchive *archive);
+ HRESULT AddRawProps(IArchiveGetRawProps *getRawProps);
+
+ void PrintTitle();
+ void PrintTitleLines();
+ HRESULT PrintItemInfo(UInt32 index, const CListStat &st);
+ void PrintSum(const CListStat &st, UInt64 numDirs, const char *str);
+ void PrintSum(const CListStat2 &stat2);
+};
+
+void CFieldPrinter::Init(const CFieldInfoInit *standardFieldTable, unsigned numItems)
+{
+ Clear();
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ CFieldInfo &f = _fields.AddNew();
+ const CFieldInfoInit &fii = standardFieldTable[i];
+ f.PropID = fii.PropID;
+ f.IsRawProp = false;
+ f.NameA = fii.Name;
+ f.TitleAdjustment = fii.TitleAdjustment;
+ f.TextAdjustment = fii.TextAdjustment;
+ f.PrefixSpacesWidth = fii.PrefixSpacesWidth;
+ f.Width = fii.Width;
+
+ unsigned k;
+ for (k = 0; k < fii.PrefixSpacesWidth; k++)
+ LinesString.Add_Space();
+ for (k = 0; k < fii.Width; k++)
+ LinesString.Add_Minus();
+ }
+}
+
+static void GetPropName(PROPID propID, const wchar_t *name, AString &nameA, UString &nameU)
+{
+ if (propID < Z7_ARRAY_SIZE(kPropIdToName))
+ {
+ nameA = kPropIdToName[propID];
+ return;
+ }
+ if (name)
+ nameU = name;
+ else
+ {
+ nameA.Empty();
+ nameA.Add_UInt32(propID);
+ }
+}
+
+void CFieldPrinter::AddProp(const wchar_t *name, PROPID propID, bool isRawProp)
+{
+ CFieldInfo f;
+ f.PropID = propID;
+ f.IsRawProp = isRawProp;
+ GetPropName(propID, name, f.NameA, f.NameU);
+ f.NameU += " = ";
+ if (!f.NameA.IsEmpty())
+ f.NameA += " = ";
+ else
+ {
+ const UString &s = f.NameU;
+ AString sA;
+ unsigned i;
+ for (i = 0; i < s.Len(); i++)
+ {
+ wchar_t c = s[i];
+ if (c >= 0x80)
+ break;
+ sA += (char)c;
+ }
+ if (i == s.Len())
+ f.NameA = sA;
+ }
+ _fields.Add(f);
+}
+
+HRESULT CFieldPrinter::AddMainProps(IInArchive *archive)
+{
+ UInt32 numProps;
+ RINOK(archive->GetNumberOfProperties(&numProps))
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ RINOK(archive->GetPropertyInfo(i, &name, &propID, &vt))
+ AddProp(name, propID, false);
+ }
+ return S_OK;
+}
+
+HRESULT CFieldPrinter::AddRawProps(IArchiveGetRawProps *getRawProps)
+{
+ UInt32 numProps;
+ RINOK(getRawProps->GetNumRawProps(&numProps))
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ RINOK(getRawProps->GetRawPropInfo(i, &name, &propID))
+ AddProp(name, propID, true);
+ }
+ return S_OK;
+}
+
+void CFieldPrinter::PrintTitle()
+{
+ FOR_VECTOR (i, _fields)
+ {
+ const CFieldInfo &f = _fields[i];
+ PrintSpaces(f.PrefixSpacesWidth);
+ PrintString(f.TitleAdjustment, ((f.PropID == kpidPath) ? 0: f.Width), f.NameA);
+ }
+}
+
+void CFieldPrinter::PrintTitleLines()
+{
+ g_StdOut << LinesString;
+}
+
+static void PrintTime(char *dest, const CListFileTimeDef &t, bool showNS)
+{
+ *dest = 0;
+ if (t.IsZero())
+ return;
+ int prec = kTimestampPrintLevel_SEC;
+ if (showNS)
+ {
+ prec = kTimestampPrintLevel_NTFS;
+ if (t.Prec != 0)
+ {
+ prec = t.GetNumDigits();
+ if (prec < kTimestampPrintLevel_DAY)
+ prec = kTimestampPrintLevel_NTFS;
+ }
+ }
+
+ ConvertUtcFileTimeToString2(t.FT, t.Ns100, dest, prec);
+}
+
+#ifndef Z7_SFX
+
+static inline char GetHex(Byte value)
+{
+ return (char)((value < 10) ? ('0' + value) : ('a' + (value - 10)));
+}
+
+static void HexToString(char *dest, const Byte *data, UInt32 size)
+{
+ for (UInt32 i = 0; i < size; i++)
+ {
+ Byte b = data[i];
+ dest[0] = GetHex((Byte)((b >> 4) & 0xF));
+ dest[1] = GetHex((Byte)(b & 0xF));
+ dest += 2;
+ }
+ *dest = 0;
+}
+
+#endif
+
+#define MY_ENDL endl
+
+HRESULT CFieldPrinter::PrintItemInfo(UInt32 index, const CListStat &st)
+{
+ char temp[128];
+ size_t tempPos = 0;
+
+ bool techMode = this->TechMode;
+ /*
+ if (techMode)
+ {
+ g_StdOut << "Index = ";
+ g_StdOut << (UInt64)index;
+ g_StdOut << endl;
+ }
+ */
+ FOR_VECTOR (i, _fields)
+ {
+ const CFieldInfo &f = _fields[i];
+
+ if (!techMode)
+ {
+ PrintSpacesToString(temp + tempPos, f.PrefixSpacesWidth);
+ tempPos += f.PrefixSpacesWidth;
+ }
+
+ if (techMode)
+ {
+ if (!f.NameA.IsEmpty())
+ g_StdOut << f.NameA;
+ else
+ g_StdOut << f.NameU;
+ }
+
+ if (f.PropID == kpidPath)
+ {
+ if (!techMode)
+ g_StdOut << temp;
+ g_StdOut.NormalizePrint_UString(FilePath, TempWString, TempAString);
+ if (techMode)
+ g_StdOut << MY_ENDL;
+ continue;
+ }
+
+ const unsigned width = f.Width;
+
+ if (f.IsRawProp)
+ {
+ #ifndef Z7_SFX
+
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+ RINOK(Arc->GetRawProps->GetRawProp(index, f.PropID, &data, &dataSize, &propType))
+
+ if (dataSize != 0)
+ {
+ bool needPrint = true;
+
+ if (f.PropID == kpidNtSecure)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+ #ifndef Z7_SFX
+ ConvertNtSecureToString((const Byte *)data, dataSize, TempAString);
+ g_StdOut << TempAString;
+ needPrint = false;
+ #endif
+ }
+ else if (f.PropID == kpidNtReparse)
+ {
+ UString s;
+ if (ConvertNtReparseToString((const Byte *)data, dataSize, s))
+ {
+ needPrint = false;
+ g_StdOut.PrintUString(s, TempAString);
+ }
+ }
+
+ if (needPrint)
+ {
+ if (propType != NPropDataType::kRaw)
+ return E_FAIL;
+
+ const UInt32 kMaxDataSize = 64;
+
+ if (dataSize > kMaxDataSize)
+ {
+ g_StdOut << "data:";
+ g_StdOut << dataSize;
+ }
+ else
+ {
+ char hexStr[kMaxDataSize * 2 + 4];
+ HexToString(hexStr, (const Byte *)data, dataSize);
+ g_StdOut << hexStr;
+ }
+ }
+ }
+
+ #endif
+ }
+ else
+ {
+ CPropVariant prop;
+ switch (f.PropID)
+ {
+ case kpidSize: if (st.Size.Def) prop = st.Size.Val; break;
+ case kpidPackSize: if (st.PackSize.Def) prop = st.PackSize.Val; break;
+ case kpidMTime:
+ {
+ const CListFileTimeDef &mtime = st.MTime;
+ if (mtime.Def)
+ prop.SetAsTimeFrom_FT_Prec_Ns100(mtime.FT, mtime.Prec, mtime.Ns100);
+ break;
+ }
+ default:
+ RINOK(Arc->Archive->GetProperty(index, f.PropID, &prop))
+ }
+ if (f.PropID == kpidAttrib && (prop.vt == VT_EMPTY || prop.vt == VT_UI4))
+ {
+ GetAttribString((prop.vt == VT_EMPTY) ? 0 : prop.ulVal, IsDir, techMode, temp + tempPos);
+ if (techMode)
+ g_StdOut << temp + tempPos;
+ else
+ tempPos += strlen(temp + tempPos);
+ }
+ else if (prop.vt == VT_EMPTY)
+ {
+ if (!techMode)
+ {
+ PrintSpacesToString(temp + tempPos, width);
+ tempPos += width;
+ }
+ }
+ else if (prop.vt == VT_FILETIME)
+ {
+ CListFileTimeDef t;
+ t.Set_From_Prop(prop);
+ PrintTime(temp + tempPos, t, techMode);
+ if (techMode)
+ g_StdOut << temp + tempPos;
+ else
+ {
+ size_t len = strlen(temp + tempPos);
+ tempPos += len;
+ if (len < (unsigned)f.Width)
+ {
+ len = f.Width - len;
+ PrintSpacesToString(temp + tempPos, (unsigned)len);
+ tempPos += len;
+ }
+ }
+ }
+ else if (prop.vt == VT_BSTR)
+ {
+ TempWString.SetFromBstr(prop.bstrVal);
+ // do we need multi-line support here ?
+ g_StdOut.Normalize_UString(TempWString);
+ if (techMode)
+ {
+ g_StdOut.PrintUString(TempWString, TempAString);
+ }
+ else
+ PrintUString(f.TextAdjustment, width, TempWString, TempAString);
+ }
+ else
+ {
+ char s[64];
+ ConvertPropertyToShortString2(s, prop, f.PropID);
+ if (techMode)
+ g_StdOut << s;
+ else
+ {
+ PrintStringToString(temp + tempPos, f.TextAdjustment, width, s);
+ tempPos += strlen(temp + tempPos);
+ }
+ }
+ }
+ if (techMode)
+ g_StdOut << MY_ENDL;
+ }
+ g_StdOut << MY_ENDL;
+ return S_OK;
+}
+
+static void PrintNumber(EAdjustment adj, unsigned width, const CListUInt64Def &value)
+{
+ char s[32];
+ s[0] = 0;
+ if (value.Def)
+ ConvertUInt64ToString(value.Val, s);
+ PrintString(adj, width, s);
+}
+
+void Print_UInt64_and_String(AString &s, UInt64 val, const char *name);
+
+void CFieldPrinter::PrintSum(const CListStat &st, UInt64 numDirs, const char *str)
+{
+ FOR_VECTOR (i, _fields)
+ {
+ const CFieldInfo &f = _fields[i];
+ PrintSpaces(f.PrefixSpacesWidth);
+ if (f.PropID == kpidSize)
+ PrintNumber(f.TextAdjustment, f.Width, st.Size);
+ else if (f.PropID == kpidPackSize)
+ PrintNumber(f.TextAdjustment, f.Width, st.PackSize);
+ else if (f.PropID == kpidMTime)
+ {
+ char s[64];
+ s[0] = 0;
+ if (st.MTime.Def)
+ PrintTime(s, st.MTime, false); // showNS
+ PrintString(f.TextAdjustment, f.Width, s);
+ }
+ else if (f.PropID == kpidPath)
+ {
+ AString s;
+ Print_UInt64_and_String(s, st.NumFiles, str);
+ if (numDirs != 0)
+ {
+ s += ", ";
+ Print_UInt64_and_String(s, numDirs, kString_Dirs);
+ }
+ PrintString(f.TextAdjustment, 0, s);
+ }
+ else
+ PrintString(f.TextAdjustment, f.Width, "");
+ }
+ g_StdOut << endl;
+}
+
+void CFieldPrinter::PrintSum(const CListStat2 &stat2)
+{
+ PrintSum(stat2.MainFiles, stat2.NumDirs, kString_Files);
+ if (stat2.AltStreams.NumFiles != 0)
+ {
+ PrintSum(stat2.AltStreams, 0, kString_AltStreams);
+ CListStat st = stat2.MainFiles;
+ st.Update(stat2.AltStreams);
+ PrintSum(st, 0, kString_Streams);
+ }
+}
+
+static HRESULT GetUInt64Value(IInArchive *archive, UInt32 index, PROPID propID, CListUInt64Def &value)
+{
+ value.Val = 0;
+ value.Def = false;
+ CPropVariant prop;
+ RINOK(archive->GetProperty(index, propID, &prop))
+ value.Def = ConvertPropVariantToUInt64(prop, value.Val);
+ return S_OK;
+}
+
+static HRESULT GetItemMTime(IInArchive *archive, UInt32 index, CListFileTimeDef &t)
+{
+ /* maybe we could call CArc::GetItemMTime(UInt32 index, CArcTime &ft, bool &defined) here
+ that can set default timestamp, if not defined */
+ t.Clear();
+ // t.Def = false;
+ CPropVariant prop;
+ RINOK(archive->GetProperty(index, kpidMTime, &prop))
+ if (prop.vt == VT_FILETIME)
+ t.Set_From_Prop(prop);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+static void PrintPropNameAndNumber(CStdOutStream &so, const char *name, UInt64 val)
+{
+ so << name << ": " << val << endl;
+}
+
+static void PrintPropName_and_Eq(CStdOutStream &so, PROPID propID)
+{
+ const char *s;
+ char temp[16];
+ if (propID < Z7_ARRAY_SIZE(kPropIdToName))
+ s = kPropIdToName[propID];
+ else
+ {
+ ConvertUInt32ToString(propID, temp);
+ s = temp;
+ }
+ so << s << " = ";
+}
+
+static void PrintPropNameAndNumber(CStdOutStream &so, PROPID propID, UInt64 val)
+{
+ PrintPropName_and_Eq(so, propID);
+ so << val << endl;
+}
+
+static void PrintPropNameAndNumber_Signed(CStdOutStream &so, PROPID propID, Int64 val)
+{
+ PrintPropName_and_Eq(so, propID);
+ so << val << endl;
+}
+
+
+static void UString_Replace_CRLF_to_LF(UString &s)
+{
+ // s.Replace(L"\r\n", L"\n");
+ wchar_t *src = s.GetBuf();
+ wchar_t *dest = src;
+ for (;;)
+ {
+ wchar_t c = *src++;
+ if (c == 0)
+ break;
+ if (c == '\r' && *src == '\n')
+ {
+ src++;
+ c = '\n';
+ }
+ *dest++ = c;
+ }
+ s.ReleaseBuf_SetEnd((unsigned)(dest - s.GetBuf()));
+}
+
+
+static void PrintPropVal_MultiLine(CStdOutStream &so, const wchar_t *val)
+{
+ UString s (val);
+ if (s.Find(L'\n') >= 0)
+ {
+ so << endl;
+ so << "{";
+ so << endl;
+ UString_Replace_CRLF_to_LF(s);
+ so.Normalize_UString_LF_Allowed(s);
+ so << s;
+ so << endl;
+ so << "}";
+ }
+ else
+ {
+ so.Normalize_UString(s);
+ so << s;
+ }
+ so << endl;
+}
+
+
+static void PrintPropPair(CStdOutStream &so, const char *name, const wchar_t *val, bool multiLine)
+{
+ so << name << " = ";
+ if (multiLine)
+ {
+ PrintPropVal_MultiLine(so, val);
+ return;
+ }
+ UString s (val);
+ so.Normalize_UString(s);
+ so << s;
+ so << endl;
+}
+
+
+static void PrintPropertyPair2(CStdOutStream &so, PROPID propID, const wchar_t *name, const CPropVariant &prop)
+{
+ UString s;
+ const int levelTopLimit = 9; // 1ns level
+ ConvertPropertyToString2(s, prop, propID, levelTopLimit);
+ if (!s.IsEmpty())
+ {
+ AString nameA;
+ UString nameU;
+ GetPropName(propID, name, nameA, nameU);
+ if (!nameA.IsEmpty())
+ so << nameA;
+ else
+ so << nameU;
+ so << " = ";
+ PrintPropVal_MultiLine(so, s);
+ }
+}
+
+static HRESULT PrintArcProp(CStdOutStream &so, IInArchive *archive, PROPID propID, const wchar_t *name)
+{
+ CPropVariant prop;
+ RINOK(archive->GetArchiveProperty(propID, &prop))
+ PrintPropertyPair2(so, propID, name, prop);
+ return S_OK;
+}
+
+static void PrintArcTypeError(CStdOutStream &so, const UString &type, bool isWarning)
+{
+ so << "Open " << (isWarning ? "WARNING" : "ERROR")
+ << ": Cannot open the file as ["
+ << type
+ << "] archive"
+ << endl;
+}
+
+int Find_FileName_InSortedVector(const UStringVector &fileName, const UString& name);
+
+void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags);
+
+static void ErrorInfo_Print(CStdOutStream &so, const CArcErrorInfo &er)
+{
+ PrintErrorFlags(so, "ERRORS:", er.GetErrorFlags());
+ if (!er.ErrorMessage.IsEmpty())
+ PrintPropPair(so, "ERROR", er.ErrorMessage, true);
+
+ PrintErrorFlags(so, "WARNINGS:", er.GetWarningFlags());
+ if (!er.WarningMessage.IsEmpty())
+ PrintPropPair(so, "WARNING", er.WarningMessage, true);
+}
+
+HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
+HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink)
+{
+ FOR_VECTOR (r, arcLink.Arcs)
+ {
+ const CArc &arc = arcLink.Arcs[r];
+ const CArcErrorInfo &er = arc.ErrorInfo;
+
+ so << "--\n";
+ PrintPropPair(so, "Path", arc.Path, false);
+ if (er.ErrorFormatIndex >= 0)
+ {
+ if (er.ErrorFormatIndex == arc.FormatIndex)
+ so << "Warning: The archive is open with offset" << endl;
+ else
+ PrintArcTypeError(so, codecs->GetFormatNamePtr(er.ErrorFormatIndex), true);
+ }
+ PrintPropPair(so, "Type", codecs->GetFormatNamePtr(arc.FormatIndex), false);
+
+ ErrorInfo_Print(so, er);
+
+ Int64 offset = arc.GetGlobalOffset();
+ if (offset != 0)
+ PrintPropNameAndNumber_Signed(so, kpidOffset, offset);
+ IInArchive *archive = arc.Archive;
+ RINOK(PrintArcProp(so, archive, kpidPhySize, NULL))
+ if (er.TailSize != 0)
+ PrintPropNameAndNumber(so, kpidTailSize, er.TailSize);
+ {
+ UInt32 numProps;
+ RINOK(archive->GetNumberOfArchiveProperties(&numProps))
+
+ for (UInt32 j = 0; j < numProps; j++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ RINOK(archive->GetArchivePropertyInfo(j, &name, &propID, &vt))
+ RINOK(PrintArcProp(so, archive, propID, name))
+ }
+ }
+
+ if (r != arcLink.Arcs.Size() - 1)
+ {
+ UInt32 numProps;
+ so << "----\n";
+ if (archive->GetNumberOfProperties(&numProps) == S_OK)
+ {
+ UInt32 mainIndex = arcLink.Arcs[r + 1].SubfileIndex;
+ for (UInt32 j = 0; j < numProps; j++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ RINOK(archive->GetPropertyInfo(j, &name, &propID, &vt))
+ CPropVariant prop;
+ RINOK(archive->GetProperty(mainIndex, propID, &prop))
+ PrintPropertyPair2(so, propID, name, prop);
+ }
+ }
+ }
+ }
+ return S_OK;
+}
+
+HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
+HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink)
+{
+ #ifndef Z7_NO_CRYPTO
+ if (arcLink.PasswordWasAsked)
+ so << "Cannot open encrypted archive. Wrong password?";
+ else
+ #endif
+ {
+ if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
+ {
+ so.NormalizePrint_UString(arcLink.NonOpen_ArcPath);
+ so << endl;
+ PrintArcTypeError(so, codecs->Formats[(unsigned)arcLink.NonOpen_ErrorInfo.ErrorFormatIndex].Name, false);
+ }
+ else
+ so << "Cannot open the file as archive";
+ }
+
+ so << endl;
+ so << endl;
+ ErrorInfo_Print(so, arcLink.NonOpen_ErrorInfo);
+
+ return S_OK;
+}
+
+bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item);
+
+HRESULT ListArchives(
+ const CListOptions &listOptions,
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &types,
+ const CIntVector &excludedFormats,
+ bool stdInMode,
+ UStringVector &arcPaths, UStringVector &arcPathsFull,
+ bool processAltStreams, bool showAltStreams,
+ const NWildcard::CCensorNode &wildcardCensor,
+ bool enableHeaders, bool techMode,
+ #ifndef Z7_NO_CRYPTO
+ bool &passwordEnabled, UString &password,
+ #endif
+ #ifndef Z7_SFX
+ const CObjectVector<CProperty> *props,
+ #endif
+ UInt64 &numErrors,
+ UInt64 &numWarnings)
+{
+ bool allFilesAreAllowed = wildcardCensor.AreAllAllowed();
+
+ numErrors = 0;
+ numWarnings = 0;
+
+ CFieldPrinter fp;
+ if (!techMode)
+ fp.Init(kStandardFieldTable, Z7_ARRAY_SIZE(kStandardFieldTable));
+
+ CListStat2 stat2total;
+
+ CBoolArr skipArcs(arcPaths.Size());
+ unsigned arcIndex;
+ for (arcIndex = 0; arcIndex < arcPaths.Size(); arcIndex++)
+ skipArcs[arcIndex] = false;
+ UInt64 numVolumes = 0;
+ UInt64 numArcs = 0;
+ UInt64 totalArcSizes = 0;
+
+ HRESULT lastError = 0;
+
+ for (arcIndex = 0; arcIndex < arcPaths.Size(); arcIndex++)
+ {
+ if (skipArcs[arcIndex])
+ continue;
+ const UString &arcPath = arcPaths[arcIndex];
+ UInt64 arcPackSize = 0;
+
+ if (!stdInMode)
+ {
+ NFile::NFind::CFileInfo fi;
+ if (!fi.Find_FollowLink(us2fs(arcPath)))
+ {
+ DWORD errorCode = GetLastError();
+ if (errorCode == 0)
+ errorCode = ERROR_FILE_NOT_FOUND;
+ lastError = HRESULT_FROM_WIN32(errorCode);
+ g_StdOut.Flush();
+ if (g_ErrStream)
+ {
+ *g_ErrStream << endl << kError << NError::MyFormatMessage(errorCode) << endl;
+ g_ErrStream->NormalizePrint_UString(arcPath);
+ *g_ErrStream << endl << endl;
+ }
+ numErrors++;
+ continue;
+ }
+ if (fi.IsDir())
+ {
+ g_StdOut.Flush();
+ if (g_ErrStream)
+ {
+ *g_ErrStream << endl << kError;
+ g_ErrStream->NormalizePrint_UString(arcPath);
+ *g_ErrStream << " is not a file" << endl << endl;
+ }
+ numErrors++;
+ continue;
+ }
+ arcPackSize = fi.Size;
+ totalArcSizes += arcPackSize;
+ }
+
+ CArchiveLink arcLink;
+
+ COpenCallbackConsole openCallback;
+ openCallback.Init(&g_StdOut, g_ErrStream, NULL);
+
+ #ifndef Z7_NO_CRYPTO
+
+ openCallback.PasswordIsDefined = passwordEnabled;
+ openCallback.Password = password;
+
+ #endif
+
+ /*
+ CObjectVector<COptionalOpenProperties> optPropsVector;
+ COptionalOpenProperties &optProps = optPropsVector.AddNew();
+ optProps.Props = *props;
+ */
+
+ COpenOptions options;
+ #ifndef Z7_SFX
+ options.props = props;
+ #endif
+ options.codecs = codecs;
+ options.types = &types;
+ options.excludedFormats = &excludedFormats;
+ options.stdInMode = stdInMode;
+ options.stream = NULL;
+ options.filePath = arcPath;
+
+ if (enableHeaders)
+ {
+ g_StdOut << endl << kListing;
+ g_StdOut.NormalizePrint_UString(arcPath);
+ g_StdOut << endl << endl;
+ }
+
+ HRESULT result = arcLink.Open_Strict(options, &openCallback);
+
+ if (result != S_OK)
+ {
+ if (result == E_ABORT)
+ return result;
+ if (result != S_FALSE)
+ lastError = result;
+ g_StdOut.Flush();
+ if (g_ErrStream)
+ {
+ *g_ErrStream << endl << kError;
+ g_ErrStream->NormalizePrint_UString(arcPath);
+ *g_ErrStream << " : ";
+ if (result == S_FALSE)
+ {
+ Print_OpenArchive_Error(*g_ErrStream, codecs, arcLink);
+ }
+ else
+ {
+ *g_ErrStream << "opening : ";
+ if (result == E_OUTOFMEMORY)
+ *g_ErrStream << "Can't allocate required memory";
+ else
+ *g_ErrStream << NError::MyFormatMessage(result);
+ }
+ *g_ErrStream << endl;
+ }
+ numErrors++;
+ continue;
+ }
+
+ {
+ FOR_VECTOR (r, arcLink.Arcs)
+ {
+ const CArcErrorInfo &arc = arcLink.Arcs[r].ErrorInfo;
+ if (!arc.WarningMessage.IsEmpty())
+ numWarnings++;
+ if (arc.AreThereWarnings())
+ numWarnings++;
+ if (arc.ErrorFormatIndex >= 0)
+ numWarnings++;
+ if (arc.AreThereErrors())
+ {
+ numErrors++;
+ // break;
+ }
+ if (!arc.ErrorMessage.IsEmpty())
+ numErrors++;
+ }
+ }
+
+ numArcs++;
+ numVolumes++;
+
+ if (!stdInMode)
+ {
+ numVolumes += arcLink.VolumePaths.Size();
+ totalArcSizes += arcLink.VolumesSize;
+ FOR_VECTOR (v, arcLink.VolumePaths)
+ {
+ int index = Find_FileName_InSortedVector(arcPathsFull, arcLink.VolumePaths[v]);
+ if (index >= 0 && (unsigned)index > arcIndex)
+ skipArcs[(unsigned)index] = true;
+ }
+ }
+
+
+ if (enableHeaders)
+ {
+ RINOK(Print_OpenArchive_Props(g_StdOut, codecs, arcLink))
+
+ g_StdOut << endl;
+ if (techMode)
+ g_StdOut << "----------\n";
+ }
+
+ if (enableHeaders && !techMode)
+ {
+ fp.PrintTitle();
+ g_StdOut << endl;
+ fp.PrintTitleLines();
+ g_StdOut << endl;
+ }
+
+ const CArc &arc = arcLink.Arcs.Back();
+ fp.Arc = &arc;
+ fp.TechMode = techMode;
+ IInArchive *archive = arc.Archive;
+ if (techMode)
+ {
+ fp.Clear();
+ RINOK(fp.AddMainProps(archive))
+ if (arc.GetRawProps)
+ {
+ RINOK(fp.AddRawProps(arc.GetRawProps))
+ }
+ }
+
+ CListStat2 stat2;
+
+ UInt32 numItems;
+ RINOK(archive->GetNumberOfItems(&numItems))
+
+ CReadArcItem item;
+ UStringVector pathParts;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ if (NConsoleClose::TestBreakSignal())
+ return E_ABORT;
+
+ HRESULT res = arc.GetItem_Path2(i, fp.FilePath);
+
+ if (stdInMode && res == E_INVALIDARG)
+ break;
+ RINOK(res)
+
+ if (arc.Ask_Aux)
+ {
+ bool isAux;
+ RINOK(Archive_IsItem_Aux(archive, i, isAux))
+ if (isAux)
+ continue;
+ }
+
+ bool isAltStream = false;
+ if (arc.Ask_AltStream)
+ {
+ RINOK(Archive_IsItem_AltStream(archive, i, isAltStream))
+ if (isAltStream && !processAltStreams)
+ continue;
+ }
+
+ RINOK(Archive_IsItem_Dir(archive, i, fp.IsDir))
+
+ if (fp.IsDir ? listOptions.ExcludeDirItems : listOptions.ExcludeFileItems)
+ continue;
+
+ if (!allFilesAreAllowed)
+ {
+ if (isAltStream)
+ {
+ RINOK(arc.GetItem(i, item))
+ if (!CensorNode_CheckPath(wildcardCensor, item))
+ continue;
+ }
+ else
+ {
+ SplitPathToParts(fp.FilePath, pathParts);
+ bool include;
+ if (!wildcardCensor.CheckPathVect(pathParts, !fp.IsDir, include))
+ continue;
+ if (!include)
+ continue;
+ }
+ }
+
+ CListStat st;
+
+ RINOK(GetUInt64Value(archive, i, kpidSize, st.Size))
+ RINOK(GetUInt64Value(archive, i, kpidPackSize, st.PackSize))
+ RINOK(GetItemMTime(archive, i, st.MTime))
+
+ if (fp.IsDir)
+ stat2.NumDirs++;
+ else
+ st.NumFiles = 1;
+ stat2.GetStat(isAltStream).Update(st);
+
+ if (isAltStream && !showAltStreams)
+ continue;
+ RINOK(fp.PrintItemInfo(i, st))
+ }
+
+ UInt64 numStreams = stat2.GetNumStreams();
+ if (!stdInMode
+ && !stat2.MainFiles.PackSize.Def
+ && !stat2.AltStreams.PackSize.Def)
+ {
+ if (arcLink.VolumePaths.Size() != 0)
+ arcPackSize += arcLink.VolumesSize;
+ stat2.MainFiles.PackSize.Add((numStreams == 0) ? 0 : arcPackSize);
+ }
+
+ stat2.MainFiles.SetSizeDefIfNoFiles();
+ stat2.AltStreams.SetSizeDefIfNoFiles();
+
+ if (enableHeaders && !techMode)
+ {
+ fp.PrintTitleLines();
+ g_StdOut << endl;
+ fp.PrintSum(stat2);
+ }
+
+ if (enableHeaders)
+ {
+ if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
+ {
+ g_StdOut << "----------\n";
+ PrintPropPair(g_StdOut, "Path", arcLink.NonOpen_ArcPath, false);
+ PrintArcTypeError(g_StdOut, codecs->Formats[(unsigned)arcLink.NonOpen_ErrorInfo.ErrorFormatIndex].Name, false);
+ }
+ }
+
+ stat2total.Update(stat2);
+
+ g_StdOut.Flush();
+ }
+
+ if (enableHeaders && !techMode && (arcPaths.Size() > 1 || numVolumes > 1))
+ {
+ g_StdOut << endl;
+ fp.PrintTitleLines();
+ g_StdOut << endl;
+ fp.PrintSum(stat2total);
+ g_StdOut << endl;
+ PrintPropNameAndNumber(g_StdOut, "Archives", numArcs);
+ PrintPropNameAndNumber(g_StdOut, "Volumes", numVolumes);
+ PrintPropNameAndNumber(g_StdOut, "Total archives size", totalArcSizes);
+ }
+
+ if (numErrors == 1 && lastError != 0)
+ return lastError;
+
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Console/List.h b/CPP/7zip/UI/Console/List.h
index dabbc2a..4969c3e 100644
--- a/CPP/7zip/UI/Console/List.h
+++ b/CPP/7zip/UI/Console/List.h
@@ -1,27 +1,40 @@
-// List.h
-
-#ifndef __LIST_H
-#define __LIST_H
-
-#include "../../../Common/Wildcard.h"
-
-#include "../Common/LoadCodecs.h"
-
-HRESULT ListArchives(CCodecs *codecs,
- const CObjectVector<COpenType> &types,
- const CIntVector &excludedFormats,
- bool stdInMode,
- UStringVector &archivePaths, UStringVector &archivePathsFull,
- bool processAltStreams, bool showAltStreams,
- const NWildcard::CCensorNode &wildcardCensor,
- bool enableHeaders, bool techMode,
- #ifndef _NO_CRYPTO
- bool &passwordEnabled, UString &password,
- #endif
- #ifndef _SFX
- const CObjectVector<CProperty> *props,
- #endif
- UInt64 &errors,
- UInt64 &numWarnings);
-
-#endif
+// List.h
+
+#ifndef ZIP7_INC_LIST_H
+#define ZIP7_INC_LIST_H
+
+#include "../../../Common/Wildcard.h"
+
+#include "../Common/LoadCodecs.h"
+
+struct CListOptions
+{
+ bool ExcludeDirItems;
+ bool ExcludeFileItems;
+
+ CListOptions():
+ ExcludeDirItems(false),
+ ExcludeFileItems(false)
+ {}
+};
+
+HRESULT ListArchives(
+ const CListOptions &listOptions,
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &types,
+ const CIntVector &excludedFormats,
+ bool stdInMode,
+ UStringVector &archivePaths, UStringVector &archivePathsFull,
+ bool processAltStreams, bool showAltStreams,
+ const NWildcard::CCensorNode &wildcardCensor,
+ bool enableHeaders, bool techMode,
+ #ifndef Z7_NO_CRYPTO
+ bool &passwordEnabled, UString &password,
+ #endif
+ #ifndef Z7_SFX
+ const CObjectVector<CProperty> *props,
+ #endif
+ UInt64 &errors,
+ UInt64 &numWarnings);
+
+#endif
diff --git a/CPP/7zip/UI/Console/Main.cpp b/CPP/7zip/UI/Console/Main.cpp
index 4d7aac9..eb9e2a8 100644
--- a/CPP/7zip/UI/Console/Main.cpp
+++ b/CPP/7zip/UI/Console/Main.cpp
@@ -1,1154 +1,1576 @@
-// Main.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/MyWindows.h"
-
-#ifdef _WIN32
-#include <Psapi.h>
-#endif
-
-#include "../../../../C/CpuArch.h"
-
-#include "../../../Common/MyInitGuid.h"
-
-#include "../../../Common/CommandLineParser.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/MyException.h"
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/StringToInt.h"
-#include "../../../Common/UTFConvert.h"
-
-#include "../../../Windows/ErrorMsg.h"
-
-#include "../../../Windows/TimeUtils.h"
-
-#include "../Common/ArchiveCommandLine.h"
-#include "../Common/Bench.h"
-#include "../Common/ExitCode.h"
-#include "../Common/Extract.h"
-
-#ifdef EXTERNAL_CODECS
-#include "../Common/LoadCodecs.h"
-#endif
-
-#include "../../Common/RegisterCodec.h"
-
-#include "BenchCon.h"
-#include "ConsoleClose.h"
-#include "ExtractCallbackConsole.h"
-#include "List.h"
-#include "OpenCallbackConsole.h"
-#include "UpdateCallbackConsole.h"
-
-#include "HashCon.h"
-
-#ifdef PROG_VARIANT_R
-#include "../../../../C/7zVersion.h"
-#else
-#include "../../MyVersion.h"
-#endif
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NCommandLineParser;
-
-#ifdef _WIN32
-HINSTANCE g_hInstance = 0;
-#endif
-
-extern CStdOutStream *g_StdStream;
-extern CStdOutStream *g_ErrStream;
-
-extern unsigned g_NumCodecs;
-extern const CCodecInfo *g_Codecs[];
-
-extern unsigned g_NumHashers;
-extern const CHasherInfo *g_Hashers[];
-
-static const char * const kCopyrightString = "\n7-Zip"
- #ifndef EXTERNAL_CODECS
- #ifdef PROG_VARIANT_R
- " (r)"
- #else
- " (a)"
- #endif
- #endif
-
- " " MY_VERSION_CPU
- " : " MY_COPYRIGHT_DATE "\n\n";
-
-static const char * const kHelpString =
- "Usage: 7z"
-#ifndef EXTERNAL_CODECS
-#ifdef PROG_VARIANT_R
- "r"
-#else
- "a"
-#endif
-#endif
- " <command> [<switches>...] <archive_name> [<file_names>...] [@listfile]\n"
- "\n"
- "<Commands>\n"
- " a : Add files to archive\n"
- " b : Benchmark\n"
- " d : Delete files from archive\n"
- " e : Extract files from archive (without using directory names)\n"
- " h : Calculate hash values for files\n"
- " i : Show information about supported formats\n"
- " l : List contents of archive\n"
- " rn : Rename files in archive\n"
- " t : Test integrity of archive\n"
- " u : Update files to archive\n"
- " x : eXtract files with full paths\n"
- "\n"
- "<Switches>\n"
- " -- : Stop switches and @listfile parsing\n"
- " -ai[r[-|0]]{@listfile|!wildcard} : Include archives\n"
- " -ax[r[-|0]]{@listfile|!wildcard} : eXclude archives\n"
- " -ao{a|s|t|u} : set Overwrite mode\n"
- " -an : disable archive_name field\n"
- " -bb[0-3] : set output log level\n"
- " -bd : disable progress indicator\n"
- " -bs{o|e|p}{0|1|2} : set output stream for output/error/progress line\n"
- " -bt : show execution time statistics\n"
- " -i[r[-|0]]{@listfile|!wildcard} : Include filenames\n"
- " -m{Parameters} : set compression Method\n"
- " -mmt[N] : set number of CPU threads\n"
- " -mx[N] : set compression level: -mx1 (fastest) ... -mx9 (ultra)\n"
- " -o{Directory} : set Output directory\n"
- #ifndef _NO_CRYPTO
- " -p{Password} : set Password\n"
- #endif
- " -r[-|0] : Recurse subdirectories\n"
- " -sa{a|e|s} : set Archive name mode\n"
- " -scc{UTF-8|WIN|DOS} : set charset for for console input/output\n"
- " -scs{UTF-8|UTF-16LE|UTF-16BE|WIN|DOS|{id}} : set charset for list files\n"
- " -scrc[CRC32|CRC64|SHA1|SHA256|*] : set hash function for x, e, h commands\n"
- " -sdel : delete files after compression\n"
- " -seml[.] : send archive by email\n"
- " -sfx[{name}] : Create SFX archive\n"
- " -si[{name}] : read data from stdin\n"
- " -slp : set Large Pages mode\n"
- " -slt : show technical information for l (List) command\n"
- " -snh : store hard links as links\n"
- " -snl : store symbolic links as links\n"
- " -sni : store NT security information\n"
- " -sns[-] : store NTFS alternate streams\n"
- " -so : write data to stdout\n"
- " -spd : disable wildcard matching for file names\n"
- " -spe : eliminate duplication of root folder for extract command\n"
- " -spf : use fully qualified file paths\n"
- " -ssc[-] : set sensitive case mode\n"
- " -sse : stop archive creating, if it can't open some input file\n"
- " -ssw : compress shared files\n"
- " -stl : set archive timestamp from the most recently modified file\n"
- " -stm{HexMask} : set CPU thread affinity mask (hexadecimal number)\n"
- " -stx{Type} : exclude archive type\n"
- " -t{Type} : Set type of archive\n"
- " -u[-][p#][q#][r#][x#][y#][z#][!newArchiveName] : Update options\n"
- " -v{Size}[b|k|m|g] : Create volumes\n"
- " -w[{path}] : assign Work directory. Empty path means a temporary directory\n"
- " -x[r[-|0]]{@listfile|!wildcard} : eXclude filenames\n"
- " -y : assume Yes on all queries\n";
-
-// ---------------------------
-// exception messages
-
-static const char * const kEverythingIsOk = "Everything is Ok";
-static const char * const kUserErrorMessage = "Incorrect command line";
-static const char * const kNoFormats = "7-Zip cannot find the code that works with archives.";
-static const char * const kUnsupportedArcTypeMessage = "Unsupported archive type";
-// static const char * const kUnsupportedUpdateArcType = "Can't create archive for that type";
-
-#define kDefaultSfxModule "7zCon.sfx"
-
-static void ShowMessageAndThrowException(LPCSTR message, NExitCode::EEnum code)
-{
- if (g_ErrStream)
- *g_ErrStream << endl << "ERROR: " << message << endl;
- throw code;
-}
-
-#ifndef _WIN32
-static void GetArguments(int numArgs, const char *args[], UStringVector &parts)
-{
- parts.Clear();
- for (int i = 0; i < numArgs; i++)
- {
- UString s = MultiByteToUnicodeString(args[i]);
- parts.Add(s);
- }
-}
-#endif
-
-static void ShowCopyrightAndHelp(CStdOutStream *so, bool needHelp)
-{
- if (!so)
- return;
- *so << kCopyrightString;
- // *so << "# CPUs: " << (UInt64)NWindows::NSystem::GetNumberOfProcessors() << endl;
- if (needHelp)
- *so << kHelpString;
-}
-
-
-static void PrintStringRight(CStdOutStream &so, const char *s, unsigned size)
-{
- unsigned len = MyStringLen(s);
- for (unsigned i = len; i < size; i++)
- so << ' ';
- so << s;
-}
-
-static void PrintUInt32(CStdOutStream &so, UInt32 val, unsigned size)
-{
- char s[16];
- ConvertUInt32ToString(val, s);
- PrintStringRight(so, s, size);
-}
-
-static void PrintLibIndex(CStdOutStream &so, int libIndex)
-{
- if (libIndex >= 0)
- PrintUInt32(so, libIndex, 2);
- else
- so << " ";
- so << ' ';
-}
-
-static void PrintString(CStdOutStream &so, const UString &s, unsigned size)
-{
- unsigned len = s.Len();
- so << s;
- for (unsigned i = len; i < size; i++)
- so << ' ';
-}
-
-static inline char GetHex(unsigned val)
-{
- return (char)((val < 10) ? ('0' + val) : ('A' + (val - 10)));
-}
-
-static void PrintWarningsPaths(const CErrorPathCodes &pc, CStdOutStream &so)
-{
- FOR_VECTOR(i, pc.Paths)
- {
- so.NormalizePrint_UString(fs2us(pc.Paths[i]));
- so << " : ";
- so << NError::MyFormatMessage(pc.Codes[i]) << endl;
- }
- so << "----------------" << endl;
-}
-
-static int WarningsCheck(HRESULT result, const CCallbackConsoleBase &callback,
- const CUpdateErrorInfo &errorInfo,
- CStdOutStream *so,
- CStdOutStream *se,
- bool showHeaders)
-{
- int exitCode = NExitCode::kSuccess;
-
- if (callback.ScanErrors.Paths.Size() != 0)
- {
- if (se)
- {
- *se << endl;
- *se << "Scan WARNINGS for files and folders:" << endl << endl;
- PrintWarningsPaths(callback.ScanErrors, *se);
- *se << "Scan WARNINGS: " << callback.ScanErrors.Paths.Size();
- *se << endl;
- }
- exitCode = NExitCode::kWarning;
- }
-
- if (result != S_OK || errorInfo.ThereIsError())
- {
- if (se)
- {
- UString message;
- if (!errorInfo.Message.IsEmpty())
- {
- message += errorInfo.Message.Ptr();
- message.Add_LF();
- }
- {
- FOR_VECTOR(i, errorInfo.FileNames)
- {
- message += fs2us(errorInfo.FileNames[i]);
- message.Add_LF();
- }
- }
- if (errorInfo.SystemError != 0)
- {
- message += NError::MyFormatMessage(errorInfo.SystemError);
- message.Add_LF();
- }
- if (!message.IsEmpty())
- *se << L"\nError:\n" << message;
- }
-
- // we will work with (result) later
- // throw CSystemException(result);
- return NExitCode::kFatalError;
- }
-
- unsigned numErrors = callback.FailedFiles.Paths.Size();
- if (numErrors == 0)
- {
- if (showHeaders)
- if (callback.ScanErrors.Paths.Size() == 0)
- if (so)
- {
- if (se)
- se->Flush();
- *so << kEverythingIsOk << endl;
- }
- }
- else
- {
- if (se)
- {
- *se << endl;
- *se << "WARNINGS for files:" << endl << endl;
- PrintWarningsPaths(callback.FailedFiles, *se);
- *se << "WARNING: Cannot open " << numErrors << " file";
- if (numErrors > 1)
- *se << 's';
- *se << endl;
- }
- exitCode = NExitCode::kWarning;
- }
-
- return exitCode;
-}
-
-static void ThrowException_if_Error(HRESULT res)
-{
- if (res != S_OK)
- throw CSystemException(res);
-}
-
-
-static void PrintNum(UInt64 val, unsigned numDigits, char c = ' ')
-{
- char temp[64];
- char *p = temp + 32;
- ConvertUInt64ToString(val, p);
- unsigned len = MyStringLen(p);
- for (; len < numDigits; len++)
- *--p = c;
- *g_StdStream << p;
-}
-
-static void PrintTime(const char *s, UInt64 val, UInt64 total)
-{
- *g_StdStream << endl << s << " Time =";
- const UInt32 kFreq = 10000000;
- UInt64 sec = val / kFreq;
- PrintNum(sec, 6);
- *g_StdStream << '.';
- UInt32 ms = (UInt32)(val - (sec * kFreq)) / (kFreq / 1000);
- PrintNum(ms, 3, '0');
-
- while (val > ((UInt64)1 << 56))
- {
- val >>= 1;
- total >>= 1;
- }
-
- UInt64 percent = 0;
- if (total != 0)
- percent = val * 100 / total;
- *g_StdStream << " =";
- PrintNum(percent, 5);
- *g_StdStream << '%';
-}
-
-#ifndef UNDER_CE
-
-#define SHIFT_SIZE_VALUE(x, num) (((x) + (1 << (num)) - 1) >> (num))
-
-static void PrintMemUsage(const char *s, UInt64 val)
-{
- *g_StdStream << " " << s << " Memory =";
- PrintNum(SHIFT_SIZE_VALUE(val, 20), 7);
- *g_StdStream << " MB";
-
- #ifdef _7ZIP_LARGE_PAGES
- AString lp;
- Add_LargePages_String(lp);
- if (!lp.IsEmpty())
- *g_StdStream << lp;
- #endif
-}
-
-EXTERN_C_BEGIN
-typedef BOOL (WINAPI *Func_GetProcessMemoryInfo)(HANDLE Process,
- PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb);
-typedef BOOL (WINAPI *Func_QueryProcessCycleTime)(HANDLE Process, PULONG64 CycleTime);
-EXTERN_C_END
-
-#endif
-
-static inline UInt64 GetTime64(const FILETIME &t) { return ((UInt64)t.dwHighDateTime << 32) | t.dwLowDateTime; }
-
-static void PrintStat()
-{
- FILETIME creationTimeFT, exitTimeFT, kernelTimeFT, userTimeFT;
- if (!
- #ifdef UNDER_CE
- ::GetThreadTimes(::GetCurrentThread()
- #else
- // NT 3.5
- ::GetProcessTimes(::GetCurrentProcess()
- #endif
- , &creationTimeFT, &exitTimeFT, &kernelTimeFT, &userTimeFT))
- return;
- FILETIME curTimeFT;
- NTime::GetCurUtcFileTime(curTimeFT);
-
- #ifndef UNDER_CE
-
- PROCESS_MEMORY_COUNTERS m;
- memset(&m, 0, sizeof(m));
- BOOL memDefined = FALSE;
- BOOL cycleDefined = FALSE;
- ULONG64 cycleTime = 0;
- {
- /* NT 4.0: GetProcessMemoryInfo() in Psapi.dll
- Win7: new function K32GetProcessMemoryInfo() in kernel32.dll
- It's faster to call kernel32.dll code than Psapi.dll code
- GetProcessMemoryInfo() requires Psapi.lib
- Psapi.lib in SDK7+ can link to K32GetProcessMemoryInfo in kernel32.dll
- The program with K32GetProcessMemoryInfo will not work on systems before Win7
- // memDefined = GetProcessMemoryInfo(GetCurrentProcess(), &m, sizeof(m));
- */
-
- HMODULE kern = ::GetModuleHandleW(L"kernel32.dll");
- Func_GetProcessMemoryInfo my_GetProcessMemoryInfo = (Func_GetProcessMemoryInfo)
- ::GetProcAddress(kern, "K32GetProcessMemoryInfo");
- if (!my_GetProcessMemoryInfo)
- {
- HMODULE lib = LoadLibraryW(L"Psapi.dll");
- if (lib)
- my_GetProcessMemoryInfo = (Func_GetProcessMemoryInfo)::GetProcAddress(lib, "GetProcessMemoryInfo");
- }
- if (my_GetProcessMemoryInfo)
- memDefined = my_GetProcessMemoryInfo(GetCurrentProcess(), &m, sizeof(m));
- // FreeLibrary(lib);
-
- Func_QueryProcessCycleTime my_QueryProcessCycleTime = (Func_QueryProcessCycleTime)
- ::GetProcAddress(kern, "QueryProcessCycleTime");
- if (my_QueryProcessCycleTime)
- cycleDefined = my_QueryProcessCycleTime(GetCurrentProcess(), &cycleTime);
- }
-
- #endif
-
- UInt64 curTime = GetTime64(curTimeFT);
- UInt64 creationTime = GetTime64(creationTimeFT);
- UInt64 kernelTime = GetTime64(kernelTimeFT);
- UInt64 userTime = GetTime64(userTimeFT);
-
- UInt64 totalTime = curTime - creationTime;
-
- PrintTime("Kernel ", kernelTime, totalTime);
-
- #ifndef UNDER_CE
- if (cycleDefined)
- {
- *g_StdStream << " ";
- PrintNum(cycleTime / 1000000, 22);
- *g_StdStream << " MCycles";
- }
- #endif
-
- PrintTime("User ", userTime, totalTime);
-
- PrintTime("Process", kernelTime + userTime, totalTime);
- #ifndef UNDER_CE
- if (memDefined) PrintMemUsage("Virtual ", m.PeakPagefileUsage);
- #endif
-
- PrintTime("Global ", totalTime, totalTime);
- #ifndef UNDER_CE
- if (memDefined) PrintMemUsage("Physical", m.PeakWorkingSetSize);
- #endif
-
- *g_StdStream << endl;
-}
-
-static void PrintHexId(CStdOutStream &so, UInt64 id)
-{
- char s[32];
- ConvertUInt64ToHex(id, s);
- PrintStringRight(so, s, 8);
-}
-
-
-int Main2(
- #ifndef _WIN32
- int numArgs, char *args[]
- #endif
-)
-{
- #if defined(_WIN32) && !defined(UNDER_CE)
- SetFileApisToOEM();
- #endif
-
- UStringVector commandStrings;
-
- #ifdef _WIN32
- NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
- #else
- GetArguments(numArgs, args, commandStrings);
- #endif
-
- #ifndef UNDER_CE
- if (commandStrings.Size() > 0)
- commandStrings.Delete(0);
- #endif
-
- if (commandStrings.Size() == 0)
- {
- ShowCopyrightAndHelp(g_StdStream, true);
- return 0;
- }
-
- CArcCmdLineOptions options;
-
- CArcCmdLineParser parser;
-
- parser.Parse1(commandStrings, options);
-
- g_StdOut.IsTerminalMode = options.IsStdOutTerminal;
- g_StdErr.IsTerminalMode = options.IsStdErrTerminal;
-
- if (options.Number_for_Out != k_OutStream_stdout)
- g_StdStream = (options.Number_for_Out == k_OutStream_stderr ? &g_StdErr : NULL);
-
- if (options.Number_for_Errors != k_OutStream_stderr)
- g_ErrStream = (options.Number_for_Errors == k_OutStream_stdout ? &g_StdOut : NULL);
-
- CStdOutStream *percentsStream = NULL;
- if (options.Number_for_Percents != k_OutStream_disabled)
- percentsStream = (options.Number_for_Percents == k_OutStream_stderr) ? &g_StdErr : &g_StdOut;;
-
- if (options.HelpMode)
- {
- ShowCopyrightAndHelp(g_StdStream, true);
- return 0;
- }
-
- if (options.EnableHeaders)
- ShowCopyrightAndHelp(g_StdStream, false);
-
- parser.Parse2(options);
-
- unsigned percentsNameLevel = 1;
- if (options.LogLevel == 0 || options.Number_for_Percents != options.Number_for_Out)
- percentsNameLevel = 2;
-
- unsigned consoleWidth = 80;
-
- if (percentsStream)
- {
- #ifdef _WIN32
-
- #if !defined(UNDER_CE)
- CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
- if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo))
- consoleWidth = consoleInfo.dwSize.X;
- #endif
-
- #else
-
- struct winsize w;
- if (ioctl(0, TIOCGWINSZ, &w) == )
- consoleWidth = w.ws_col;
-
- #endif
- }
-
- CREATE_CODECS_OBJECT
-
- codecs->CaseSensitiveChange = options.CaseSensitiveChange;
- codecs->CaseSensitive = options.CaseSensitive;
- ThrowException_if_Error(codecs->Load());
-
- bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
-
- if (codecs->Formats.Size() == 0 &&
- (isExtractGroupCommand
- || options.Command.CommandType == NCommandType::kList
- || options.Command.IsFromUpdateGroup()))
- {
- #ifdef EXTERNAL_CODECS
- if (!codecs->MainDll_ErrorPath.IsEmpty())
- {
- UString s ("Can't load module: ");
- s += fs2us(codecs->MainDll_ErrorPath);
- throw s;
- }
- #endif
-
- throw kNoFormats;
- }
-
- CObjectVector<COpenType> types;
- if (!ParseOpenTypes(*codecs, options.ArcType, types))
- throw kUnsupportedArcTypeMessage;
-
- CIntVector excludedFormats;
- FOR_VECTOR (k, options.ExcludedArcTypes)
- {
- CIntVector tempIndices;
- if (!codecs->FindFormatForArchiveType(options.ExcludedArcTypes[k], tempIndices)
- || tempIndices.Size() != 1)
- throw kUnsupportedArcTypeMessage;
- excludedFormats.AddToUniqueSorted(tempIndices[0]);
- // excludedFormats.Sort();
- }
-
-
- #ifdef EXTERNAL_CODECS
- if (isExtractGroupCommand
- || options.Command.CommandType == NCommandType::kHash
- || options.Command.CommandType == NCommandType::kBenchmark)
- ThrowException_if_Error(__externalCodecs.Load());
- #endif
-
- int retCode = NExitCode::kSuccess;
- HRESULT hresultMain = S_OK;
-
- // bool showStat = options.ShowTime;
-
- /*
- if (!options.EnableHeaders ||
- options.TechMode)
- showStat = false;
- */
-
-
- if (options.Command.CommandType == NCommandType::kInfo)
- {
- CStdOutStream &so = (g_StdStream ? *g_StdStream : g_StdOut);
- unsigned i;
-
- #ifdef EXTERNAL_CODECS
- so << endl << "Libs:" << endl;
- for (i = 0; i < codecs->Libs.Size(); i++)
- {
- PrintLibIndex(so, i);
- so << ' ' << codecs->Libs[i].Path << endl;
- }
- #endif
-
- so << endl << "Formats:" << endl;
-
- const char * const kArcFlags = "KSNFMGOPBELH";
- const unsigned kNumArcFlags = (unsigned)strlen(kArcFlags);
-
- for (i = 0; i < codecs->Formats.Size(); i++)
- {
- const CArcInfoEx &arc = codecs->Formats[i];
-
- #ifdef EXTERNAL_CODECS
- PrintLibIndex(so, arc.LibIndex);
- #else
- so << " ";
- #endif
-
- so << (char)(arc.UpdateEnabled ? 'C' : ' ');
-
- for (unsigned b = 0; b < kNumArcFlags; b++)
- {
- so << (char)
- ((arc.Flags & ((UInt32)1 << b)) != 0 ? kArcFlags[b] : ' ');
- }
-
- so << ' ';
- PrintString(so, arc.Name, 8);
- so << ' ';
- UString s;
-
- FOR_VECTOR (t, arc.Exts)
- {
- if (t != 0)
- s.Add_Space();
- const CArcExtInfo &ext = arc.Exts[t];
- s += ext.Ext;
- if (!ext.AddExt.IsEmpty())
- {
- s += " (";
- s += ext.AddExt;
- s += ')';
- }
- }
-
- PrintString(so, s, 13);
- so << ' ';
-
- if (arc.SignatureOffset != 0)
- so << "offset=" << arc.SignatureOffset << ' ';
-
- FOR_VECTOR(si, arc.Signatures)
- {
- if (si != 0)
- so << " || ";
-
- const CByteBuffer &sig = arc.Signatures[si];
-
- for (size_t j = 0; j < sig.Size(); j++)
- {
- if (j != 0)
- so << ' ';
- Byte b = sig[j];
- if (b > 0x20 && b < 0x80)
- {
- so << (char)b;
- }
- else
- {
- so << GetHex((b >> 4) & 0xF);
- so << GetHex(b & 0xF);
- }
- }
- }
- so << endl;
- }
-
- so << endl << "Codecs:" << endl; // << "Lib ID Name" << endl;
-
- for (i = 0; i < g_NumCodecs; i++)
- {
- const CCodecInfo &cod = *g_Codecs[i];
-
- PrintLibIndex(so, -1);
-
- if (cod.NumStreams == 1)
- so << ' ';
- else
- so << cod.NumStreams;
-
- so << (char)(cod.CreateEncoder ? 'E' : ' ');
- so << (char)(cod.CreateDecoder ? 'D' : ' ');
-
- so << ' ';
- PrintHexId(so, cod.Id);
- so << ' ' << cod.Name << endl;
- }
-
-
- #ifdef EXTERNAL_CODECS
-
- UInt32 numMethods;
- if (codecs->GetNumMethods(&numMethods) == S_OK)
- for (UInt32 j = 0; j < numMethods; j++)
- {
- PrintLibIndex(so, codecs->GetCodec_LibIndex(j));
-
- UInt32 numStreams = codecs->GetCodec_NumStreams(j);
- if (numStreams == 1)
- so << ' ';
- else
- so << numStreams;
-
- so << (char)(codecs->GetCodec_EncoderIsAssigned(j) ? 'E' : ' ');
- so << (char)(codecs->GetCodec_DecoderIsAssigned(j) ? 'D' : ' ');
-
- so << ' ';
- UInt64 id;
- HRESULT res = codecs->GetCodec_Id(j, id);
- if (res != S_OK)
- id = (UInt64)(Int64)-1;
- PrintHexId(so, id);
- so << ' ' << codecs->GetCodec_Name(j) << endl;
- }
-
- #endif
-
-
- so << endl << "Hashers:" << endl; // << " L Size ID Name" << endl;
-
- for (i = 0; i < g_NumHashers; i++)
- {
- const CHasherInfo &codec = *g_Hashers[i];
- PrintLibIndex(so, -1);
- PrintUInt32(so, codec.DigestSize, 4);
- so << ' ';
- PrintHexId(so, codec.Id);
- so << ' ' << codec.Name << endl;
- }
-
- #ifdef EXTERNAL_CODECS
-
- numMethods = codecs->GetNumHashers();
- for (UInt32 j = 0; j < numMethods; j++)
- {
- PrintLibIndex(so, codecs->GetHasherLibIndex(j));
- PrintUInt32(so, codecs->GetHasherDigestSize(j), 4);
- so << ' ';
- PrintHexId(so, codecs->GetHasherId(j));
- so << ' ' << codecs->GetHasherName(j) << endl;
- }
-
- #endif
-
- }
- else if (options.Command.CommandType == NCommandType::kBenchmark)
- {
- CStdOutStream &so = (g_StdStream ? *g_StdStream : g_StdOut);
- hresultMain = BenchCon(EXTERNAL_CODECS_VARS_L
- options.Properties, options.NumIterations, (FILE *)so);
- if (hresultMain == S_FALSE)
- {
- if (g_ErrStream)
- *g_ErrStream << "\nDecoding ERROR\n";
- retCode = NExitCode::kFatalError;
- hresultMain = S_OK;
- }
- }
- else if (isExtractGroupCommand || options.Command.CommandType == NCommandType::kList)
- {
- UStringVector ArchivePathsSorted;
- UStringVector ArchivePathsFullSorted;
-
- if (options.StdInMode)
- {
- ArchivePathsSorted.Add(options.ArcName_for_StdInMode);
- ArchivePathsFullSorted.Add(options.ArcName_for_StdInMode);
- }
- else
- {
- CExtractScanConsole scan;
-
- scan.Init(options.EnableHeaders ? g_StdStream : NULL, g_ErrStream, percentsStream);
- scan.SetWindowWidth(consoleWidth);
-
- if (g_StdStream && options.EnableHeaders)
- *g_StdStream << "Scanning the drive for archives:" << endl;
-
- CDirItemsStat st;
-
- scan.StartScanning();
-
- hresultMain = EnumerateDirItemsAndSort(
- options.arcCensor,
- NWildcard::k_RelatPath,
- UString(), // addPathPrefix
- ArchivePathsSorted,
- ArchivePathsFullSorted,
- st,
- &scan);
-
- scan.CloseScanning();
-
- if (hresultMain == S_OK)
- {
- if (options.EnableHeaders)
- scan.PrintStat(st);
- }
- else
- {
- /*
- if (res != E_ABORT)
- {
- throw CSystemException(res);
- // errorInfo.Message = "Scanning error";
- }
- return res;
- */
- }
- }
-
- if (hresultMain == S_OK)
- if (isExtractGroupCommand)
- {
- CExtractCallbackConsole *ecs = new CExtractCallbackConsole;
- CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
-
- #ifndef _NO_CRYPTO
- ecs->PasswordIsDefined = options.PasswordEnabled;
- ecs->Password = options.Password;
- #endif
-
- ecs->Init(g_StdStream, g_ErrStream, percentsStream);
- ecs->MultiArcMode = (ArchivePathsSorted.Size() > 1);
-
- ecs->LogLevel = options.LogLevel;
- ecs->PercentsNameLevel = percentsNameLevel;
-
- if (percentsStream)
- ecs->SetWindowWidth(consoleWidth);
-
- /*
- COpenCallbackConsole openCallback;
- openCallback.Init(g_StdStream, g_ErrStream);
-
- #ifndef _NO_CRYPTO
- openCallback.PasswordIsDefined = options.PasswordEnabled;
- openCallback.Password = options.Password;
- #endif
- */
-
- CExtractOptions eo;
- (CExtractOptionsBase &)eo = options.ExtractOptions;
-
- eo.StdInMode = options.StdInMode;
- eo.StdOutMode = options.StdOutMode;
- eo.YesToAll = options.YesToAll;
- eo.TestMode = options.Command.IsTestCommand();
-
- #ifndef _SFX
- eo.Properties = options.Properties;
- #endif
-
- UString errorMessage;
- CDecompressStat stat;
- CHashBundle hb;
- IHashCalc *hashCalc = NULL;
-
- if (!options.HashMethods.IsEmpty())
- {
- hashCalc = &hb;
- ThrowException_if_Error(hb.SetMethods(EXTERNAL_CODECS_VARS_L options.HashMethods));
- // hb.Init();
- }
-
- hresultMain = Extract(
- codecs,
- types,
- excludedFormats,
- ArchivePathsSorted,
- ArchivePathsFullSorted,
- options.Censor.Pairs.Front().Head,
- eo, ecs, ecs, hashCalc, errorMessage, stat);
-
- ecs->ClosePercents();
-
- if (!errorMessage.IsEmpty())
- {
- if (g_ErrStream)
- *g_ErrStream << endl << "ERROR:" << endl << errorMessage << endl;
- if (hresultMain == S_OK)
- hresultMain = E_FAIL;
- }
-
- CStdOutStream *so = g_StdStream;
-
- bool isError = false;
-
- if (so)
- {
- *so << endl;
-
- if (ecs->NumTryArcs > 1)
- {
- *so << "Archives: " << ecs->NumTryArcs << endl;
- *so << "OK archives: " << ecs->NumOkArcs << endl;
- }
- }
-
- if (ecs->NumCantOpenArcs != 0)
- {
- isError = true;
- if (so)
- *so << "Can't open as archive: " << ecs->NumCantOpenArcs << endl;
- }
-
- if (ecs->NumArcsWithError != 0)
- {
- isError = true;
- if (so)
- *so << "Archives with Errors: " << ecs->NumArcsWithError << endl;
- }
-
- if (so)
- {
- if (ecs->NumArcsWithWarnings != 0)
- *so << "Archives with Warnings: " << ecs->NumArcsWithWarnings << endl;
-
- if (ecs->NumOpenArcWarnings != 0)
- {
- *so << endl;
- if (ecs->NumOpenArcWarnings != 0)
- *so << "Warnings: " << ecs->NumOpenArcWarnings << endl;
- }
- }
-
- if (ecs->NumOpenArcErrors != 0)
- {
- isError = true;
- if (so)
- {
- *so << endl;
- if (ecs->NumOpenArcErrors != 0)
- *so << "Open Errors: " << ecs->NumOpenArcErrors << endl;
- }
- }
-
- if (isError)
- retCode = NExitCode::kFatalError;
-
- if (so)
- if (ecs->NumArcsWithError != 0 || ecs->NumFileErrors != 0)
- {
- // if (ecs->NumArchives > 1)
- {
- *so << endl;
- if (ecs->NumFileErrors != 0)
- *so << "Sub items Errors: " << ecs->NumFileErrors << endl;
- }
- }
- else if (hresultMain == S_OK)
- {
- if (stat.NumFolders != 0)
- *so << "Folders: " << stat.NumFolders << endl;
- if (stat.NumFiles != 1 || stat.NumFolders != 0 || stat.NumAltStreams != 0)
- *so << "Files: " << stat.NumFiles << endl;
- if (stat.NumAltStreams != 0)
- {
- *so << "Alternate Streams: " << stat.NumAltStreams << endl;
- *so << "Alternate Streams Size: " << stat.AltStreams_UnpackSize << endl;
- }
-
- *so
- << "Size: " << stat.UnpackSize << endl
- << "Compressed: " << stat.PackSize << endl;
- if (hashCalc)
- {
- *so << endl;
- PrintHashStat(*so, hb);
- }
- }
- }
- else
- {
- UInt64 numErrors = 0;
- UInt64 numWarnings = 0;
-
- // options.ExtractNtOptions.StoreAltStreams = true, if -sns[-] is not definmed
-
- hresultMain = ListArchives(
- codecs,
- types,
- excludedFormats,
- options.StdInMode,
- ArchivePathsSorted,
- ArchivePathsFullSorted,
- options.ExtractOptions.NtOptions.AltStreams.Val,
- options.AltStreams.Val, // we don't want to show AltStreams by default
- options.Censor.Pairs.Front().Head,
- options.EnableHeaders,
- options.TechMode,
- #ifndef _NO_CRYPTO
- options.PasswordEnabled,
- options.Password,
- #endif
- &options.Properties,
- numErrors, numWarnings);
-
- if (options.EnableHeaders)
- if (numWarnings > 0)
- g_StdOut << endl << "Warnings: " << numWarnings << endl;
-
- if (numErrors > 0)
- {
- if (options.EnableHeaders)
- g_StdOut << endl << "Errors: " << numErrors << endl;
- retCode = NExitCode::kFatalError;
- }
- }
- }
- else if (options.Command.IsFromUpdateGroup())
- {
- CUpdateOptions &uo = options.UpdateOptions;
- if (uo.SfxMode && uo.SfxModule.IsEmpty())
- uo.SfxModule = kDefaultSfxModule;
-
- COpenCallbackConsole openCallback;
- openCallback.Init(g_StdStream, g_ErrStream, percentsStream);
-
- #ifndef _NO_CRYPTO
- bool passwordIsDefined =
- (options.PasswordEnabled && !options.Password.IsEmpty());
- openCallback.PasswordIsDefined = passwordIsDefined;
- openCallback.Password = options.Password;
- #endif
-
- CUpdateCallbackConsole callback;
- callback.LogLevel = options.LogLevel;
- callback.PercentsNameLevel = percentsNameLevel;
-
- if (percentsStream)
- callback.SetWindowWidth(consoleWidth);
-
- #ifndef _NO_CRYPTO
- callback.PasswordIsDefined = passwordIsDefined;
- callback.AskPassword = (options.PasswordEnabled && options.Password.IsEmpty());
- callback.Password = options.Password;
- #endif
-
- callback.StdOutMode = uo.StdOutMode;
- callback.Init(
- // NULL,
- g_StdStream, g_ErrStream, percentsStream);
-
- CUpdateErrorInfo errorInfo;
-
- /*
- if (!uo.Init(codecs, types, options.ArchiveName))
- throw kUnsupportedUpdateArcType;
- */
- hresultMain = UpdateArchive(codecs,
- types,
- options.ArchiveName,
- options.Censor,
- uo,
- errorInfo, &openCallback, &callback, true);
-
- callback.ClosePercents2();
-
- CStdOutStream *se = g_StdStream;
- if (!se)
- se = g_ErrStream;
-
- retCode = WarningsCheck(hresultMain, callback, errorInfo,
- g_StdStream, se,
- true // options.EnableHeaders
- );
- }
- else if (options.Command.CommandType == NCommandType::kHash)
- {
- const CHashOptions &uo = options.HashOptions;
-
- CHashCallbackConsole callback;
- if (percentsStream)
- callback.SetWindowWidth(consoleWidth);
-
- callback.Init(g_StdStream, g_ErrStream, percentsStream);
- callback.PrintHeaders = options.EnableHeaders;
-
- AString errorInfoString;
- hresultMain = HashCalc(EXTERNAL_CODECS_VARS_L
- options.Censor, uo,
- errorInfoString, &callback);
- CUpdateErrorInfo errorInfo;
- errorInfo.Message = errorInfoString;
- CStdOutStream *se = g_StdStream;
- if (!se)
- se = g_ErrStream;
- retCode = WarningsCheck(hresultMain, callback, errorInfo, g_StdStream, se, options.EnableHeaders);
- }
- else
- ShowMessageAndThrowException(kUserErrorMessage, NExitCode::kUserError);
-
- if (options.ShowTime && g_StdStream)
- PrintStat();
-
- ThrowException_if_Error(hresultMain);
-
- return retCode;
-}
+// Main.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#ifdef _WIN32
+
+#ifndef Z7_OLD_WIN_SDK
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <psapi.h>
+#else
+#include <Psapi.h>
+#endif
+
+#else // Z7_OLD_WIN_SDK
+
+typedef struct _PROCESS_MEMORY_COUNTERS {
+ DWORD cb;
+ DWORD PageFaultCount;
+ SIZE_T PeakWorkingSetSize;
+ SIZE_T WorkingSetSize;
+ SIZE_T QuotaPeakPagedPoolUsage;
+ SIZE_T QuotaPagedPoolUsage;
+ SIZE_T QuotaPeakNonPagedPoolUsage;
+ SIZE_T QuotaNonPagedPoolUsage;
+ SIZE_T PagefileUsage;
+ SIZE_T PeakPagefileUsage;
+} PROCESS_MEMORY_COUNTERS;
+typedef PROCESS_MEMORY_COUNTERS *PPROCESS_MEMORY_COUNTERS;
+
+#endif // Z7_OLD_WIN_SDK
+
+#else // _WIN32
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#endif // _WIN32
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyException.h"
+#include "../../../Common/StdInStream.h"
+#include "../../../Common/StdOutStream.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/TimeUtils.h"
+#include "../../../Windows/FileDir.h"
+
+#include "../Common/ArchiveCommandLine.h"
+#include "../Common/Bench.h"
+#include "../Common/ExitCode.h"
+#include "../Common/Extract.h"
+
+#ifdef Z7_EXTERNAL_CODECS
+#include "../Common/LoadCodecs.h"
+#endif
+
+#include "../../Common/RegisterCodec.h"
+
+#include "BenchCon.h"
+#include "ConsoleClose.h"
+#include "ExtractCallbackConsole.h"
+#include "HashCon.h"
+#include "List.h"
+#include "OpenCallbackConsole.h"
+#include "UpdateCallbackConsole.h"
+
+#ifdef Z7_PROG_VARIANT_R
+#include "../../../../C/7zVersion.h"
+#else
+#include "../../MyVersion.h"
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NCommandLineParser;
+
+#ifdef _WIN32
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance = NULL;
+#endif
+
+extern CStdOutStream *g_StdStream;
+extern CStdOutStream *g_ErrStream;
+
+extern unsigned g_NumCodecs;
+extern const CCodecInfo *g_Codecs[];
+
+extern unsigned g_NumHashers;
+extern const CHasherInfo *g_Hashers[];
+
+#ifdef Z7_EXTERNAL_CODECS
+extern
+const CExternalCodecs *g_ExternalCodecs_Ptr;
+const CExternalCodecs *g_ExternalCodecs_Ptr;
+#endif
+
+DECLARE_AND_SET_CLIENT_VERSION_VAR
+
+#if defined(Z7_PROG_VARIANT_Z)
+ #define PROG_POSTFIX "z"
+ #define PROG_POSTFIX_2 " (z)"
+#elif defined(Z7_PROG_VARIANT_R)
+ #define PROG_POSTFIX "r"
+ #define PROG_POSTFIX_2 " (r)"
+#elif !defined(Z7_EXTERNAL_CODECS)
+ #define PROG_POSTFIX "a"
+ #define PROG_POSTFIX_2 " (a)"
+#else
+ #define PROG_POSTFIX ""
+ #define PROG_POSTFIX_2 ""
+#endif
+
+
+static const char * const kCopyrightString = "\n7-Zip"
+ PROG_POSTFIX_2
+ " " MY_VERSION_CPU
+ " : " MY_COPYRIGHT_DATE "\n";
+
+static const char * const kHelpString =
+ "Usage: 7z"
+ PROG_POSTFIX
+ " <command> [<switches>...] <archive_name> [<file_names>...] [@listfile]\n"
+ "\n"
+ "<Commands>\n"
+ " a : Add files to archive\n"
+ " b : Benchmark\n"
+ " d : Delete files from archive\n"
+ " e : Extract files from archive (without using directory names)\n"
+ " h : Calculate hash values for files\n"
+ " i : Show information about supported formats\n"
+ " l : List contents of archive\n"
+ " rn : Rename files in archive\n"
+ " t : Test integrity of archive\n"
+ " u : Update files to archive\n"
+ " x : eXtract files with full paths\n"
+ "\n"
+ "<Switches>\n"
+ " -- : Stop switches and @listfile parsing\n"
+ " -ai[r[-|0]]{@listfile|!wildcard} : Include archives\n"
+ " -ax[r[-|0]]{@listfile|!wildcard} : eXclude archives\n"
+ " -ao{a|s|t|u} : set Overwrite mode\n"
+ " -an : disable archive_name field\n"
+ " -bb[0-3] : set output log level\n"
+ " -bd : disable progress indicator\n"
+ " -bs{o|e|p}{0|1|2} : set output stream for output/error/progress line\n"
+ " -bt : show execution time statistics\n"
+ " -i[r[-|0]]{@listfile|!wildcard} : Include filenames\n"
+ " -m{Parameters} : set compression Method\n"
+ " -mmt[N] : set number of CPU threads\n"
+ " -mx[N] : set compression level: -mx1 (fastest) ... -mx9 (ultra)\n"
+ " -o{Directory} : set Output directory\n"
+ #ifndef Z7_NO_CRYPTO
+ " -p{Password} : set Password\n"
+ #endif
+ " -r[-|0] : Recurse subdirectories for name search\n"
+ " -sa{a|e|s} : set Archive name mode\n"
+ " -scc{UTF-8|WIN|DOS} : set charset for console input/output\n"
+ " -scs{UTF-8|UTF-16LE|UTF-16BE|WIN|DOS|{id}} : set charset for list files\n"
+ " -scrc[CRC32|CRC64|SHA1|SHA256|*] : set hash function for x, e, h commands\n"
+ " -sdel : delete files after compression\n"
+ " -seml[.] : send archive by email\n"
+ " -sfx[{name}] : Create SFX archive\n"
+ " -si[{name}] : read data from stdin\n"
+ " -slp : set Large Pages mode\n"
+ " -slt : show technical information for l (List) command\n"
+ " -snh : store hard links as links\n"
+ " -snl : store symbolic links as links\n"
+ " -sni : store NT security information\n"
+ " -sns[-] : store NTFS alternate streams\n"
+ " -so : write data to stdout\n"
+ " -spd : disable wildcard matching for file names\n"
+ " -spe : eliminate duplication of root folder for extract command\n"
+ " -spf[2] : use fully qualified file paths\n"
+ " -ssc[-] : set sensitive case mode\n"
+ " -sse : stop archive creating, if it can't open some input file\n"
+ " -ssp : do not change Last Access Time of source files while archiving\n"
+ " -ssw : compress shared files\n"
+ " -stl : set archive timestamp from the most recently modified file\n"
+ " -stm{HexMask} : set CPU thread affinity mask (hexadecimal number)\n"
+ " -stx{Type} : exclude archive type\n"
+ " -t{Type} : Set type of archive\n"
+ " -u[-][p#][q#][r#][x#][y#][z#][!newArchiveName] : Update options\n"
+ " -v{Size}[b|k|m|g] : Create volumes\n"
+ " -w[{path}] : assign Work directory. Empty path means a temporary directory\n"
+ " -x[r[-|0]]{@listfile|!wildcard} : eXclude filenames\n"
+ " -y : assume Yes on all queries\n";
+
+// ---------------------------
+// exception messages
+
+static const char * const kEverythingIsOk = "Everything is Ok";
+static const char * const kUserErrorMessage = "Incorrect command line";
+static const char * const kNoFormats = "7-Zip cannot find the code that works with archives.";
+static const char * const kUnsupportedArcTypeMessage = "Unsupported archive type";
+// static const char * const kUnsupportedUpdateArcType = "Can't create archive for that type";
+
+#define kDefaultSfxModule "7zCon.sfx"
+
+Z7_ATTR_NORETURN
+static void ShowMessageAndThrowException(LPCSTR message, NExitCode::EEnum code)
+{
+ if (g_ErrStream)
+ *g_ErrStream << endl << "ERROR: " << message << endl;
+ throw code;
+}
+
+
+#ifdef _WIN32
+#define ShowProgInfo(so)
+#else
+static void ShowProgInfo(CStdOutStream *so)
+{
+ if (!so)
+ return;
+
+ *so
+
+ /*
+ #ifdef __DATE__
+ << " " << __DATE__
+ #endif
+ #ifdef __TIME__
+ << " " << __TIME__
+ #endif
+ */
+
+ << " " << (unsigned)(sizeof(void *)) * 8 << "-bit"
+
+ #ifdef __ILP32__
+ << " ILP32"
+ #endif
+
+ #ifdef __ARM_ARCH
+ << " arm_v:" << __ARM_ARCH
+ #ifdef __ARM_ARCH_ISA_THUMB
+ << " thumb:" << __ARM_ARCH_ISA_THUMB
+ #endif
+ #endif
+ ;
+
+
+
+ #ifdef ENV_HAVE_LOCALE
+ *so << " locale=" << GetLocale();
+ #endif
+ #ifndef _WIN32
+ {
+ const bool is_IsNativeUTF8 = IsNativeUTF8();
+ if (!is_IsNativeUTF8)
+ *so << " UTF8=" << (is_IsNativeUTF8 ? "+" : "-");
+ }
+ if (!g_ForceToUTF8)
+ *so << " use-UTF8=" << (g_ForceToUTF8 ? "+" : "-");
+ {
+ const unsigned wchar_t_size = (unsigned)sizeof(wchar_t);
+ if (wchar_t_size != 4)
+ *so << " wchar_t=" << wchar_t_size * 8 << "-bit";
+ }
+ {
+ const unsigned off_t_size = (unsigned)sizeof(off_t);
+ if (off_t_size != 8)
+ *so << " Files=" << off_t_size * 8 << "-bit";
+ }
+ #endif
+
+ {
+ const UInt32 numCpus = NWindows::NSystem::GetNumberOfProcessors();
+ *so << " Threads:" << numCpus;
+ const UInt64 openMAX= NWindows::NSystem::Get_File_OPEN_MAX();
+ *so << " OPEN_MAX:" << openMAX;
+ {
+ FString temp;
+ NDir::MyGetTempPath(temp);
+ if (!temp.IsEqualTo(STRING_PATH_SEPARATOR "tmp" STRING_PATH_SEPARATOR))
+ *so << " temp_path:" << temp;
+ }
+ }
+
+ #ifdef Z7_7ZIP_ASM
+ *so << ", ASM";
+ #endif
+
+ /*
+ {
+ AString s;
+ GetCpuName(s);
+ s.Trim();
+ *so << ", " << s;
+ }
+
+ #ifdef __ARM_FEATURE_CRC32
+ << " CRC32"
+ #endif
+
+
+ #if (defined MY_CPU_X86_OR_AMD64 || defined(MY_CPU_ARM_OR_ARM64))
+ if (CPU_IsSupported_AES()) *so << ",AES";
+ #endif
+
+ #ifdef MY_CPU_ARM_OR_ARM64
+ if (CPU_IsSupported_CRC32()) *so << ",CRC32";
+ #if defined(_WIN32)
+ if (CPU_IsSupported_CRYPTO()) *so << ",CRYPTO";
+ #else
+ if (CPU_IsSupported_SHA1()) *so << ",SHA1";
+ if (CPU_IsSupported_SHA2()) *so << ",SHA2";
+ #endif
+ #endif
+ */
+
+ *so << endl;
+}
+#endif
+
+static void ShowCopyrightAndHelp(CStdOutStream *so, bool needHelp)
+{
+ if (!so)
+ return;
+ *so << kCopyrightString;
+ // *so << "# CPUs: " << (UInt64)NWindows::NSystem::GetNumberOfProcessors() << endl;
+ ShowProgInfo(so);
+ *so << endl;
+ if (needHelp)
+ *so << kHelpString;
+}
+
+
+static void PrintStringRight(CStdOutStream &so, const char *s, unsigned size)
+{
+ unsigned len = MyStringLen(s);
+ for (unsigned i = len; i < size; i++)
+ so << ' ';
+ so << s;
+}
+
+static void PrintUInt32(CStdOutStream &so, UInt32 val, unsigned size)
+{
+ char s[16];
+ ConvertUInt32ToString(val, s);
+ PrintStringRight(so, s, size);
+}
+
+#ifdef Z7_EXTERNAL_CODECS
+static void PrintNumber(CStdOutStream &so, UInt32 val, unsigned numDigits)
+{
+ AString s;
+ s.Add_UInt32(val);
+ while (s.Len() < numDigits)
+ s.InsertAtFront('0');
+ so << s;
+}
+#endif
+
+static void PrintLibIndex(CStdOutStream &so, int libIndex)
+{
+ if (libIndex >= 0)
+ PrintUInt32(so, (UInt32)libIndex, 2);
+ else
+ so << " ";
+ so << ' ';
+}
+
+static void PrintString(CStdOutStream &so, const UString &s, unsigned size)
+{
+ unsigned len = s.Len();
+ so << s;
+ for (unsigned i = len; i < size; i++)
+ so << ' ';
+}
+
+static inline char GetHex(unsigned val)
+{
+ return (char)((val < 10) ? ('0' + val) : ('A' + (val - 10)));
+}
+
+static void PrintWarningsPaths(const CErrorPathCodes &pc, CStdOutStream &so)
+{
+ FOR_VECTOR(i, pc.Paths)
+ {
+ so.NormalizePrint_UString(fs2us(pc.Paths[i]));
+ so << " : ";
+ so << NError::MyFormatMessage(pc.Codes[i]) << endl;
+ }
+ so << "----------------" << endl;
+}
+
+static int WarningsCheck(HRESULT result, const CCallbackConsoleBase &callback,
+ const CUpdateErrorInfo &errorInfo,
+ CStdOutStream *so,
+ CStdOutStream *se,
+ bool showHeaders)
+{
+ int exitCode = NExitCode::kSuccess;
+
+ if (callback.ScanErrors.Paths.Size() != 0)
+ {
+ if (se)
+ {
+ *se << endl;
+ *se << "Scan WARNINGS for files and folders:" << endl << endl;
+ PrintWarningsPaths(callback.ScanErrors, *se);
+ *se << "Scan WARNINGS: " << callback.ScanErrors.Paths.Size();
+ *se << endl;
+ }
+ exitCode = NExitCode::kWarning;
+ }
+
+ if (result != S_OK || errorInfo.ThereIsError())
+ {
+ if (se)
+ {
+ UString message;
+ if (!errorInfo.Message.IsEmpty())
+ {
+ message += errorInfo.Message.Ptr();
+ message.Add_LF();
+ }
+ {
+ FOR_VECTOR(i, errorInfo.FileNames)
+ {
+ message += fs2us(errorInfo.FileNames[i]);
+ message.Add_LF();
+ }
+ }
+ if (errorInfo.SystemError != 0)
+ {
+ message += NError::MyFormatMessage(errorInfo.SystemError);
+ message.Add_LF();
+ }
+ if (!message.IsEmpty())
+ *se << L"\nError:\n" << message;
+ }
+
+ // we will work with (result) later
+ // throw CSystemException(result);
+ return NExitCode::kFatalError;
+ }
+
+ unsigned numErrors = callback.FailedFiles.Paths.Size();
+ if (numErrors == 0)
+ {
+ if (showHeaders)
+ if (callback.ScanErrors.Paths.Size() == 0)
+ if (so)
+ {
+ if (se)
+ se->Flush();
+ *so << kEverythingIsOk << endl;
+ }
+ }
+ else
+ {
+ if (se)
+ {
+ *se << endl;
+ *se << "WARNINGS for files:" << endl << endl;
+ PrintWarningsPaths(callback.FailedFiles, *se);
+ *se << "WARNING: Cannot open " << numErrors << " file";
+ if (numErrors > 1)
+ *se << 's';
+ *se << endl;
+ }
+ exitCode = NExitCode::kWarning;
+ }
+
+ return exitCode;
+}
+
+static void ThrowException_if_Error(HRESULT res)
+{
+ if (res != S_OK)
+ throw CSystemException(res);
+}
+
+static void PrintNum(UInt64 val, unsigned numDigits, char c = ' ')
+{
+ char temp[64];
+ char *p = temp + 32;
+ ConvertUInt64ToString(val, p);
+ unsigned len = MyStringLen(p);
+ for (; len < numDigits; len++)
+ *--p = c;
+ *g_StdStream << p;
+}
+
+#ifdef _WIN32
+
+static void PrintTime(const char *s, UInt64 val, UInt64 total)
+{
+ *g_StdStream << endl << s << " Time =";
+ const UInt32 kFreq = 10000000;
+ UInt64 sec = val / kFreq;
+ PrintNum(sec, 6);
+ *g_StdStream << '.';
+ UInt32 ms = (UInt32)(val - (sec * kFreq)) / (kFreq / 1000);
+ PrintNum(ms, 3, '0');
+
+ while (val > ((UInt64)1 << 56))
+ {
+ val >>= 1;
+ total >>= 1;
+ }
+
+ UInt64 percent = 0;
+ if (total != 0)
+ percent = val * 100 / total;
+ *g_StdStream << " =";
+ PrintNum(percent, 5);
+ *g_StdStream << '%';
+}
+
+#ifndef UNDER_CE
+
+#define SHIFT_SIZE_VALUE(x, num) (((x) + (1 << (num)) - 1) >> (num))
+
+static void PrintMemUsage(const char *s, UInt64 val)
+{
+ *g_StdStream << " " << s << " Memory =";
+ PrintNum(SHIFT_SIZE_VALUE(val, 20), 7);
+ *g_StdStream << " MB";
+ /*
+ *g_StdStream << " =";
+ PrintNum(SHIFT_SIZE_VALUE(val, 10), 9);
+ *g_StdStream << " KB";
+ */
+ #ifdef Z7_LARGE_PAGES
+ AString lp;
+ Add_LargePages_String(lp);
+ if (!lp.IsEmpty())
+ *g_StdStream << lp;
+ #endif
+}
+
+EXTERN_C_BEGIN
+typedef BOOL (WINAPI *Func_GetProcessMemoryInfo)(HANDLE Process,
+ PPROCESS_MEMORY_COUNTERS ppsmemCounters, DWORD cb);
+typedef BOOL (WINAPI *Func_QueryProcessCycleTime)(HANDLE Process, PULONG64 CycleTime);
+EXTERN_C_END
+
+#endif
+
+static inline UInt64 GetTime64(const FILETIME &t) { return ((UInt64)t.dwHighDateTime << 32) | t.dwLowDateTime; }
+
+static void PrintStat()
+{
+ FILETIME creationTimeFT, exitTimeFT, kernelTimeFT, userTimeFT;
+ if (!
+ #ifdef UNDER_CE
+ ::GetThreadTimes(::GetCurrentThread()
+ #else
+ // NT 3.5
+ ::GetProcessTimes(::GetCurrentProcess()
+ #endif
+ , &creationTimeFT, &exitTimeFT, &kernelTimeFT, &userTimeFT))
+ return;
+ FILETIME curTimeFT;
+ NTime::GetCurUtc_FiTime(curTimeFT);
+
+ #ifndef UNDER_CE
+
+ PROCESS_MEMORY_COUNTERS m;
+ memset(&m, 0, sizeof(m));
+ BOOL memDefined = FALSE;
+ BOOL cycleDefined = FALSE;
+ ULONG64 cycleTime = 0;
+ {
+ /* NT 4.0: GetProcessMemoryInfo() in Psapi.dll
+ Win7: new function K32GetProcessMemoryInfo() in kernel32.dll
+ It's faster to call kernel32.dll code than Psapi.dll code
+ GetProcessMemoryInfo() requires Psapi.lib
+ Psapi.lib in SDK7+ can link to K32GetProcessMemoryInfo in kernel32.dll
+ The program with K32GetProcessMemoryInfo will not work on systems before Win7
+ // memDefined = GetProcessMemoryInfo(GetCurrentProcess(), &m, sizeof(m));
+ */
+ const HMODULE kern = ::GetModuleHandleW(L"kernel32.dll");
+ Func_GetProcessMemoryInfo
+ my_GetProcessMemoryInfo = Z7_GET_PROC_ADDRESS(
+ Func_GetProcessMemoryInfo, kern,
+ "K32GetProcessMemoryInfo");
+ if (!my_GetProcessMemoryInfo)
+ {
+ const HMODULE lib = LoadLibraryW(L"Psapi.dll");
+ if (lib)
+ my_GetProcessMemoryInfo = Z7_GET_PROC_ADDRESS(
+ Func_GetProcessMemoryInfo, lib,
+ "GetProcessMemoryInfo");
+ }
+ if (my_GetProcessMemoryInfo)
+ memDefined = my_GetProcessMemoryInfo(GetCurrentProcess(), &m, sizeof(m));
+ // FreeLibrary(lib);
+ const
+ Func_QueryProcessCycleTime
+ my_QueryProcessCycleTime = Z7_GET_PROC_ADDRESS(
+ Func_QueryProcessCycleTime, kern,
+ "QueryProcessCycleTime");
+ if (my_QueryProcessCycleTime)
+ cycleDefined = my_QueryProcessCycleTime(GetCurrentProcess(), &cycleTime);
+ }
+
+ #endif
+
+ UInt64 curTime = GetTime64(curTimeFT);
+ UInt64 creationTime = GetTime64(creationTimeFT);
+ UInt64 kernelTime = GetTime64(kernelTimeFT);
+ UInt64 userTime = GetTime64(userTimeFT);
+
+ UInt64 totalTime = curTime - creationTime;
+
+ PrintTime("Kernel ", kernelTime, totalTime);
+
+ const UInt64 processTime = kernelTime + userTime;
+
+ #ifndef UNDER_CE
+ if (cycleDefined)
+ {
+ *g_StdStream << " Cnt:";
+ PrintNum(cycleTime / 1000000, 15);
+ *g_StdStream << " MCycles";
+ }
+ #endif
+
+ PrintTime("User ", userTime, totalTime);
+
+ #ifndef UNDER_CE
+ if (cycleDefined)
+ {
+ *g_StdStream << " Freq (cnt/ptime):";
+ UInt64 us = processTime / 10;
+ if (us == 0)
+ us = 1;
+ PrintNum(cycleTime / us, 6);
+ *g_StdStream << " MHz";
+ }
+ #endif
+
+ PrintTime("Process", processTime, totalTime);
+ #ifndef UNDER_CE
+ if (memDefined) PrintMemUsage("Virtual ", m.PeakPagefileUsage);
+ #endif
+
+ PrintTime("Global ", totalTime, totalTime);
+ #ifndef UNDER_CE
+ if (memDefined) PrintMemUsage("Physical", m.PeakWorkingSetSize);
+ #endif
+ *g_StdStream << endl;
+}
+
+
+#else // ! _WIN32
+
+static UInt64 Get_timeofday_us()
+{
+ struct timeval now;
+ if (gettimeofday(&now, NULL) == 0)
+ return (UInt64)now.tv_sec * 1000000 + (UInt64)now.tv_usec;
+ return 0;
+}
+
+static void PrintTime(const char *s, UInt64 val, UInt64 total_us, UInt64 kFreq)
+{
+ *g_StdStream << endl << s << " Time =";
+
+ {
+ UInt64 sec, ms;
+
+ if (kFreq == 0)
+ {
+ sec = val / 1000000;
+ ms = val % 1000000 / 1000;
+ }
+ else
+ {
+ sec = val / kFreq;
+ ms = (UInt32)((val - (sec * kFreq)) * 1000 / kFreq);
+ }
+
+ PrintNum(sec, 6);
+ *g_StdStream << '.';
+ PrintNum(ms, 3, '0');
+ }
+
+ if (total_us == 0)
+ return;
+
+ UInt64 percent = 0;
+ if (kFreq == 0)
+ percent = val * 100 / total_us;
+ else
+ {
+ const UInt64 kMaxVal = (UInt64)(Int64)-1;
+ UInt32 m = 100000000;
+ for (;;)
+ {
+ if (m == 0 || kFreq == 0)
+ break;
+ if (kMaxVal / m > val &&
+ kMaxVal / kFreq > total_us)
+ break;
+ if (val > m)
+ val >>= 1;
+ else
+ m >>= 1;
+ if (kFreq > total_us)
+ kFreq >>= 1;
+ else
+ total_us >>= 1;
+ }
+ const UInt64 total = kFreq * total_us;
+ if (total != 0)
+ percent = val * m / total;
+ }
+ *g_StdStream << " =";
+ PrintNum(percent, 5);
+ *g_StdStream << '%';
+}
+
+static void PrintStat(const UInt64 startTime)
+{
+ tms t;
+ /* clock_t res = */ times(&t);
+ const UInt64 totalTime = Get_timeofday_us() - startTime;
+ const UInt64 kFreq = (UInt64)sysconf(_SC_CLK_TCK);
+ PrintTime("Kernel ", (UInt64)t.tms_stime, totalTime, kFreq);
+ PrintTime("User ", (UInt64)t.tms_utime, totalTime, kFreq);
+ PrintTime("Process", (UInt64)t.tms_utime + (UInt64)t.tms_stime, totalTime, kFreq);
+ PrintTime("Global ", totalTime, totalTime, 0);
+ *g_StdStream << endl;
+}
+
+#endif // ! _WIN32
+
+
+
+
+
+static void PrintHexId(CStdOutStream &so, UInt64 id)
+{
+ char s[32];
+ ConvertUInt64ToHex(id, s);
+ PrintStringRight(so, s, 8);
+}
+
+#ifndef _WIN32
+void Set_ModuleDirPrefix_From_ProgArg0(const char *s);
+#endif
+
+int Main2(
+ #ifndef _WIN32
+ int numArgs, char *args[]
+ #endif
+);
+int Main2(
+ #ifndef _WIN32
+ int numArgs, char *args[]
+ #endif
+)
+{
+ #if defined(MY_CPU_SIZEOF_POINTER)
+ { unsigned k = sizeof(void *); if (k != MY_CPU_SIZEOF_POINTER) throw "incorrect MY_CPU_PTR_SIZE"; }
+ #endif
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ SetFileApisToOEM();
+ #endif
+
+ #ifdef ENV_HAVE_LOCALE
+ // printf("\nBefore SetLocale() : %s\n", IsNativeUtf8() ? "NATIVE UTF-8" : "IS NOT NATIVE UTF-8");
+ MY_SetLocale();
+ // printf("\nAfter SetLocale() : %s\n", IsNativeUtf8() ? "NATIVE UTF-8" : "IS NOT NATIVE UTF-8");
+ #endif
+
+ #ifndef _WIN32
+ const UInt64 startTime = Get_timeofday_us();
+ #endif
+
+ /*
+ {
+ g_StdOut << "DWORD:" << (unsigned)sizeof(DWORD);
+ g_StdOut << " LONG:" << (unsigned)sizeof(LONG);
+ g_StdOut << " long:" << (unsigned)sizeof(long);
+ #ifdef _WIN64
+ // g_StdOut << " long long:" << (unsigned)sizeof(long long);
+ #endif
+ g_StdOut << " int:" << (unsigned)sizeof(int);
+ g_StdOut << " void*:" << (unsigned)sizeof(void *);
+ g_StdOut << endl;
+ }
+ */
+
+ UStringVector commandStrings;
+
+ #ifdef _WIN32
+ NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
+ #else
+ {
+ if (numArgs > 0)
+ Set_ModuleDirPrefix_From_ProgArg0(args[0]);
+
+ for (int i = 0; i < numArgs; i++)
+ {
+ AString a (args[i]);
+ /*
+ printf("\n%d %s :", i, a.Ptr());
+ for (unsigned k = 0; k < a.Len(); k++)
+ printf(" %2x", (unsigned)(Byte)a[k]);
+ */
+ const UString s = MultiByteToUnicodeString(a);
+ commandStrings.Add(s);
+ }
+ // printf("\n");
+ }
+
+ #endif
+
+ #ifndef UNDER_CE
+ if (commandStrings.Size() > 0)
+ commandStrings.Delete(0);
+ #endif
+
+ if (commandStrings.Size() == 0)
+ {
+ ShowCopyrightAndHelp(g_StdStream, true);
+ return 0;
+ }
+
+ CArcCmdLineOptions options;
+
+ CArcCmdLineParser parser;
+
+ parser.Parse1(commandStrings, options);
+
+ g_StdOut.IsTerminalMode = options.IsStdOutTerminal;
+ g_StdErr.IsTerminalMode = options.IsStdErrTerminal;
+
+ if (options.Number_for_Out != k_OutStream_stdout)
+ g_StdStream = (options.Number_for_Out == k_OutStream_stderr ? &g_StdErr : NULL);
+
+ if (options.Number_for_Errors != k_OutStream_stderr)
+ g_ErrStream = (options.Number_for_Errors == k_OutStream_stdout ? &g_StdOut : NULL);
+
+ CStdOutStream *percentsStream = NULL;
+ if (options.Number_for_Percents != k_OutStream_disabled)
+ percentsStream = (options.Number_for_Percents == k_OutStream_stderr) ? &g_StdErr : &g_StdOut;
+
+ if (options.HelpMode)
+ {
+ ShowCopyrightAndHelp(g_StdStream, true);
+ return 0;
+ }
+
+ if (options.EnableHeaders)
+ {
+ ShowCopyrightAndHelp(g_StdStream, false);
+ if (!parser.Parse1Log.IsEmpty())
+ *g_StdStream << parser.Parse1Log;
+ }
+
+ parser.Parse2(options);
+
+ {
+ int cp = options.ConsoleCodePage;
+
+ int stdout_cp = cp;
+ int stderr_cp = cp;
+ int stdin_cp = cp;
+
+ /*
+ // these cases are complicated.
+ // maybe we must use CRT functions instead of console WIN32.
+ // different Windows/CRT versions also can work different ways.
+ // so the following code was not enabled:
+ if (cp == -1)
+ {
+ // we set CodePage only if stream is attached to terminal
+ // maybe we should set CodePage even if is not terminal?
+ #ifdef _WIN32
+ {
+ UINT ccp = GetConsoleOutputCP();
+ if (ccp != 0)
+ {
+ if (options.IsStdOutTerminal) stdout_cp = ccp;
+ if (options.IsStdErrTerminal) stderr_cp = ccp;
+ }
+ }
+ if (options.IsInTerminal)
+ {
+ UINT ccp = GetConsoleCP();
+ if (ccp != 0) stdin_cp = ccp;
+ }
+ #endif
+ }
+ */
+
+ if (stdout_cp != -1) g_StdOut.CodePage = stdout_cp;
+ if (stderr_cp != -1) g_StdErr.CodePage = stderr_cp;
+ if (stdin_cp != -1) g_StdIn.CodePage = stdin_cp;
+ }
+
+ unsigned percentsNameLevel = 1;
+ if (options.LogLevel == 0 || options.Number_for_Percents != options.Number_for_Out)
+ percentsNameLevel = 2;
+
+ unsigned consoleWidth = 80;
+
+ if (percentsStream)
+ {
+ #ifdef _WIN32
+
+ #if !defined(UNDER_CE)
+ CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
+ if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo))
+ consoleWidth = (unsigned)(unsigned short)consoleInfo.dwSize.X;
+ #endif
+
+ #else
+
+ struct winsize w;
+ if (ioctl(0, TIOCGWINSZ, &w) == 0)
+ consoleWidth = w.ws_col;
+
+ #endif
+ }
+
+ CREATE_CODECS_OBJECT
+
+ codecs->CaseSensitive_Change = options.CaseSensitive_Change;
+ codecs->CaseSensitive = options.CaseSensitive;
+ ThrowException_if_Error(codecs->Load());
+ Codecs_AddHashArcHandler(codecs);
+
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ g_ExternalCodecs_Ptr = &_externalCodecs;
+ UString s;
+ codecs->GetCodecsErrorMessage(s);
+ if (!s.IsEmpty())
+ {
+ CStdOutStream &so = (g_StdStream ? *g_StdStream : g_StdOut);
+ so << endl << s << endl;
+ }
+ }
+ #endif
+
+ const bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
+
+ if (codecs->Formats.Size() == 0 &&
+ (isExtractGroupCommand
+ || options.Command.CommandType == NCommandType::kList
+ || options.Command.IsFromUpdateGroup()))
+ {
+ #ifdef Z7_EXTERNAL_CODECS
+ if (!codecs->MainDll_ErrorPath.IsEmpty())
+ {
+ UString s ("Can't load module: ");
+ s += fs2us(codecs->MainDll_ErrorPath);
+ throw s;
+ }
+ #endif
+ throw kNoFormats;
+ }
+
+ CObjectVector<COpenType> types;
+ if (!ParseOpenTypes(*codecs, options.ArcType, types))
+ {
+ throw kUnsupportedArcTypeMessage;
+ }
+
+
+ CIntVector excludedFormats;
+ FOR_VECTOR (k, options.ExcludedArcTypes)
+ {
+ CIntVector tempIndices;
+ if (!codecs->FindFormatForArchiveType(options.ExcludedArcTypes[k], tempIndices)
+ || tempIndices.Size() != 1)
+ throw kUnsupportedArcTypeMessage;
+
+
+
+ excludedFormats.AddToUniqueSorted(tempIndices[0]);
+ // excludedFormats.Sort();
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+ if (isExtractGroupCommand
+ || options.Command.IsFromUpdateGroup()
+ || options.Command.CommandType == NCommandType::kHash
+ || options.Command.CommandType == NCommandType::kBenchmark)
+ ThrowException_if_Error(_externalCodecs.Load());
+ #endif
+
+ int retCode = NExitCode::kSuccess;
+ HRESULT hresultMain = S_OK;
+
+ // bool showStat = options.ShowTime;
+
+ /*
+ if (!options.EnableHeaders ||
+ options.TechMode)
+ showStat = false;
+ */
+
+
+ if (options.Command.CommandType == NCommandType::kInfo)
+ {
+ CStdOutStream &so = (g_StdStream ? *g_StdStream : g_StdOut);
+ unsigned i;
+
+ #ifdef Z7_EXTERNAL_CODECS
+ so << endl << "Libs:" << endl;
+ for (i = 0; i < codecs->Libs.Size(); i++)
+ {
+ PrintLibIndex(so, (int)i);
+ const CCodecLib &lib = codecs->Libs[i];
+ // if (lib.Version != 0)
+ so << ": " << (lib.Version >> 16) << ".";
+ PrintNumber(so, lib.Version & 0xffff, 2);
+ so << " : " << lib.Path << endl;
+ }
+ #endif
+
+ so << endl << "Formats:" << endl;
+
+ const char * const kArcFlags = "KSNFMGOPBELHXCc+a+m+r+";
+ const char * const kArcTimeFlags = "wudn";
+ const unsigned kNumArcFlags = (unsigned)strlen(kArcFlags);
+ const unsigned kNumArcTimeFlags = (unsigned)strlen(kArcTimeFlags);
+
+ for (i = 0; i < codecs->Formats.Size(); i++)
+ {
+ const CArcInfoEx &arc = codecs->Formats[i];
+
+ #ifdef Z7_EXTERNAL_CODECS
+ PrintLibIndex(so, arc.LibIndex);
+ #else
+ so << " ";
+ #endif
+
+ so << (char)(arc.UpdateEnabled ? 'C' : ' ');
+
+ {
+ unsigned b;
+ for (b = 0; b < kNumArcFlags; b++)
+ so << (char)((arc.Flags & ((UInt32)1 << b)) != 0 ? kArcFlags[b] : '.');
+ so << ' ';
+ }
+
+ if (arc.TimeFlags != 0)
+ {
+ unsigned b;
+ for (b = 0; b < kNumArcTimeFlags; b++)
+ so << (char)((arc.TimeFlags & ((UInt32)1 << b)) != 0 ? kArcTimeFlags[b] : '.');
+ so << arc.Get_DefaultTimePrec();
+ so << ' ';
+ }
+
+ so << ' ';
+ PrintString(so, arc.Name, 8);
+ so << ' ';
+ UString s;
+
+ FOR_VECTOR (t, arc.Exts)
+ {
+ if (t != 0)
+ s.Add_Space();
+ const CArcExtInfo &ext = arc.Exts[t];
+ s += ext.Ext;
+ if (!ext.AddExt.IsEmpty())
+ {
+ s += " (";
+ s += ext.AddExt;
+ s += ')';
+ }
+ }
+
+ PrintString(so, s, 13);
+ so << ' ';
+
+ if (arc.SignatureOffset != 0)
+ so << "offset=" << arc.SignatureOffset << ' ';
+
+ // so << "numSignatures = " << arc.Signatures.Size() << " ";
+
+ FOR_VECTOR(si, arc.Signatures)
+ {
+ if (si != 0)
+ so << " || ";
+
+ const CByteBuffer &sig = arc.Signatures[si];
+
+ for (size_t j = 0; j < sig.Size(); j++)
+ {
+ if (j != 0)
+ so << ' ';
+ Byte b = sig[j];
+ if (b > 0x20 && b < 0x80)
+ {
+ so << (char)b;
+ }
+ else
+ {
+ so << GetHex((b >> 4) & 0xF);
+ so << GetHex(b & 0xF);
+ }
+ }
+ }
+ so << endl;
+ }
+
+ so << endl << "Codecs:" << endl; // << "Lib ID Name" << endl;
+
+ for (i = 0; i < g_NumCodecs; i++)
+ {
+ const CCodecInfo &cod = *g_Codecs[i];
+
+ PrintLibIndex(so, -1);
+
+ if (cod.NumStreams == 1)
+ so << ' ';
+ else
+ so << cod.NumStreams;
+
+ so << (char)(cod.CreateEncoder ? 'E' : ' ');
+ so << (char)(cod.CreateDecoder ? 'D' : ' ');
+ so << (char)(cod.IsFilter ? 'F' : ' ');
+
+ so << ' ';
+ PrintHexId(so, cod.Id);
+ so << ' ' << cod.Name << endl;
+ }
+
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ UInt32 numMethods;
+ if (_externalCodecs.GetCodecs->GetNumMethods(&numMethods) == S_OK)
+ for (UInt32 j = 0; j < numMethods; j++)
+ {
+ PrintLibIndex(so, codecs->GetCodec_LibIndex(j));
+
+ UInt32 numStreams = codecs->GetCodec_NumStreams(j);
+ if (numStreams == 1)
+ so << ' ';
+ else
+ so << numStreams;
+
+ so << (char)(codecs->GetCodec_EncoderIsAssigned(j) ? 'E' : ' ');
+ so << (char)(codecs->GetCodec_DecoderIsAssigned(j) ? 'D' : ' ');
+ {
+ bool isFilter_Assigned;
+ const bool isFilter = codecs->GetCodec_IsFilter(j, isFilter_Assigned);
+ so << (char)(isFilter ? 'F' : isFilter_Assigned ? ' ' : '*');
+ }
+
+
+ so << ' ';
+ UInt64 id;
+ HRESULT res = codecs->GetCodec_Id(j, id);
+ if (res != S_OK)
+ id = (UInt64)(Int64)-1;
+ PrintHexId(so, id);
+ so << ' ' << codecs->GetCodec_Name(j) << endl;
+ }
+
+ #endif
+
+
+ so << endl << "Hashers:" << endl; // << " L Size ID Name" << endl;
+
+ for (i = 0; i < g_NumHashers; i++)
+ {
+ const CHasherInfo &codec = *g_Hashers[i];
+ PrintLibIndex(so, -1);
+ PrintUInt32(so, codec.DigestSize, 4);
+ so << ' ';
+ PrintHexId(so, codec.Id);
+ so << ' ' << codec.Name << endl;
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ numMethods = _externalCodecs.GetHashers->GetNumHashers();
+ for (UInt32 j = 0; j < numMethods; j++)
+ {
+ PrintLibIndex(so, codecs->GetHasherLibIndex(j));
+ PrintUInt32(so, codecs->GetHasherDigestSize(j), 4);
+ so << ' ';
+ PrintHexId(so, codecs->GetHasherId(j));
+ so << ' ' << codecs->GetHasherName(j) << endl;
+ }
+
+ #endif
+
+ }
+ else if (options.Command.CommandType == NCommandType::kBenchmark)
+ {
+ CStdOutStream &so = (g_StdStream ? *g_StdStream : g_StdOut);
+ hresultMain = BenchCon(EXTERNAL_CODECS_VARS_L
+ options.Properties, options.NumIterations, (FILE *)so);
+ if (hresultMain == S_FALSE)
+ {
+ so << endl;
+ if (g_ErrStream)
+ *g_ErrStream << "\nDecoding ERROR\n";
+ retCode = NExitCode::kFatalError;
+ hresultMain = S_OK;
+ }
+ }
+ else if (isExtractGroupCommand || options.Command.CommandType == NCommandType::kList)
+ {
+ UStringVector ArchivePathsSorted;
+ UStringVector ArchivePathsFullSorted;
+
+ if (options.StdInMode)
+ {
+ ArchivePathsSorted.Add(options.ArcName_for_StdInMode);
+ ArchivePathsFullSorted.Add(options.ArcName_for_StdInMode);
+ }
+ else
+ {
+ CExtractScanConsole scan;
+
+ scan.Init(options.EnableHeaders ? g_StdStream : NULL, g_ErrStream, percentsStream);
+ scan.SetWindowWidth(consoleWidth);
+
+ if (g_StdStream && options.EnableHeaders)
+ *g_StdStream << "Scanning the drive for archives:" << endl;
+
+ CDirItemsStat st;
+
+ scan.StartScanning();
+
+ hresultMain = EnumerateDirItemsAndSort(
+ options.arcCensor,
+ NWildcard::k_RelatPath,
+ UString(), // addPathPrefix
+ ArchivePathsSorted,
+ ArchivePathsFullSorted,
+ st,
+ &scan);
+
+ scan.CloseScanning();
+
+ if (hresultMain == S_OK)
+ {
+ if (options.EnableHeaders)
+ scan.PrintStat(st);
+ }
+ else
+ {
+ /*
+ if (res != E_ABORT)
+ {
+ throw CSystemException(res);
+ // errorInfo.Message = "Scanning error";
+ }
+ return res;
+ */
+ }
+ }
+
+ if (hresultMain == S_OK) {
+ if (isExtractGroupCommand)
+ {
+ CExtractCallbackConsole *ecs = new CExtractCallbackConsole;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
+
+ #ifndef Z7_NO_CRYPTO
+ ecs->PasswordIsDefined = options.PasswordEnabled;
+ ecs->Password = options.Password;
+ #endif
+
+ ecs->Init(g_StdStream, g_ErrStream, percentsStream);
+ ecs->MultiArcMode = (ArchivePathsSorted.Size() > 1);
+
+ ecs->LogLevel = options.LogLevel;
+ ecs->PercentsNameLevel = percentsNameLevel;
+
+ if (percentsStream)
+ ecs->SetWindowWidth(consoleWidth);
+
+ /*
+ COpenCallbackConsole openCallback;
+ openCallback.Init(g_StdStream, g_ErrStream);
+
+ #ifndef Z7_NO_CRYPTO
+ openCallback.PasswordIsDefined = options.PasswordEnabled;
+ openCallback.Password = options.Password;
+ #endif
+ */
+
+ CExtractOptions eo;
+ (CExtractOptionsBase &)eo = options.ExtractOptions;
+
+ eo.StdInMode = options.StdInMode;
+ eo.StdOutMode = options.StdOutMode;
+ eo.YesToAll = options.YesToAll;
+ eo.TestMode = options.Command.IsTestCommand();
+
+ #ifndef Z7_SFX
+ eo.Properties = options.Properties;
+ #endif
+
+ UString errorMessage;
+ CDecompressStat stat;
+ CHashBundle hb;
+ IHashCalc *hashCalc = NULL;
+
+ if (!options.HashMethods.IsEmpty())
+ {
+ hashCalc = &hb;
+ ThrowException_if_Error(hb.SetMethods(EXTERNAL_CODECS_VARS_L options.HashMethods));
+ // hb.Init();
+ }
+
+ hresultMain = Extract(
+ // EXTERNAL_CODECS_VARS_L
+ codecs,
+ types,
+ excludedFormats,
+ ArchivePathsSorted,
+ ArchivePathsFullSorted,
+ options.Censor.Pairs.Front().Head,
+ eo,
+ ecs, ecs, ecs,
+ hashCalc, errorMessage, stat);
+
+ ecs->ClosePercents();
+
+ if (!errorMessage.IsEmpty())
+ {
+ if (g_ErrStream)
+ *g_ErrStream << endl << "ERROR:" << endl << errorMessage << endl;
+ if (hresultMain == S_OK)
+ hresultMain = E_FAIL;
+ }
+
+ CStdOutStream *so = g_StdStream;
+
+ bool isError = false;
+
+ if (so)
+ {
+ *so << endl;
+
+ if (ecs->NumTryArcs > 1)
+ {
+ *so << "Archives: " << ecs->NumTryArcs << endl;
+ *so << "OK archives: " << ecs->NumOkArcs << endl;
+ }
+ }
+
+ if (ecs->NumCantOpenArcs != 0)
+ {
+ isError = true;
+ if (so)
+ *so << "Can't open as archive: " << ecs->NumCantOpenArcs << endl;
+ }
+
+ if (ecs->NumArcsWithError != 0)
+ {
+ isError = true;
+ if (so)
+ *so << "Archives with Errors: " << ecs->NumArcsWithError << endl;
+ }
+
+ if (so)
+ {
+ if (ecs->NumArcsWithWarnings != 0)
+ *so << "Archives with Warnings: " << ecs->NumArcsWithWarnings << endl;
+
+ if (ecs->NumOpenArcWarnings != 0)
+ {
+ *so << endl;
+ if (ecs->NumOpenArcWarnings != 0)
+ *so << "Warnings: " << ecs->NumOpenArcWarnings << endl;
+ }
+ }
+
+ if (ecs->NumOpenArcErrors != 0)
+ {
+ isError = true;
+ if (so)
+ {
+ *so << endl;
+ if (ecs->NumOpenArcErrors != 0)
+ *so << "Open Errors: " << ecs->NumOpenArcErrors << endl;
+ }
+ }
+
+ if (isError)
+ retCode = NExitCode::kFatalError;
+
+ if (so) {
+ if (ecs->NumArcsWithError != 0 || ecs->NumFileErrors != 0)
+ {
+ // if (ecs->NumArchives > 1)
+ {
+ *so << endl;
+ if (ecs->NumFileErrors != 0)
+ *so << "Sub items Errors: " << ecs->NumFileErrors << endl;
+ }
+ }
+ else if (hresultMain == S_OK)
+ {
+ if (stat.NumFolders != 0)
+ *so << "Folders: " << stat.NumFolders << endl;
+ if (stat.NumFiles != 1 || stat.NumFolders != 0 || stat.NumAltStreams != 0)
+ *so << "Files: " << stat.NumFiles << endl;
+ if (stat.NumAltStreams != 0)
+ {
+ *so << "Alternate Streams: " << stat.NumAltStreams << endl;
+ *so << "Alternate Streams Size: " << stat.AltStreams_UnpackSize << endl;
+ }
+
+ *so
+ << "Size: " << stat.UnpackSize << endl
+ << "Compressed: " << stat.PackSize << endl;
+ if (hashCalc)
+ {
+ *so << endl;
+ PrintHashStat(*so, hb);
+ }
+ }
+ } // if (so)
+ }
+ else // if_(!isExtractGroupCommand)
+ {
+ UInt64 numErrors = 0;
+ UInt64 numWarnings = 0;
+
+ // options.ExtractNtOptions.StoreAltStreams = true, if -sns[-] is not definmed
+
+ CListOptions lo;
+ lo.ExcludeDirItems = options.Censor.ExcludeDirItems;
+ lo.ExcludeFileItems = options.Censor.ExcludeFileItems;
+
+ hresultMain = ListArchives(
+ lo,
+ codecs,
+ types,
+ excludedFormats,
+ options.StdInMode,
+ ArchivePathsSorted,
+ ArchivePathsFullSorted,
+ options.ExtractOptions.NtOptions.AltStreams.Val,
+ options.AltStreams.Val, // we don't want to show AltStreams by default
+ options.Censor.Pairs.Front().Head,
+ options.EnableHeaders,
+ options.TechMode,
+ #ifndef Z7_NO_CRYPTO
+ options.PasswordEnabled,
+ options.Password,
+ #endif
+ &options.Properties,
+ numErrors, numWarnings);
+
+ if (options.EnableHeaders)
+ if (numWarnings > 0)
+ g_StdOut << endl << "Warnings: " << numWarnings << endl;
+
+ if (numErrors > 0)
+ {
+ if (options.EnableHeaders)
+ g_StdOut << endl << "Errors: " << numErrors << endl;
+ retCode = NExitCode::kFatalError;
+ }
+ } // if_(isExtractGroupCommand)
+ } // if_(hresultMain == S_OK)
+ }
+ else if (options.Command.IsFromUpdateGroup())
+ {
+ CUpdateOptions &uo = options.UpdateOptions;
+ if (uo.SfxMode && uo.SfxModule.IsEmpty())
+ uo.SfxModule = kDefaultSfxModule;
+
+ COpenCallbackConsole openCallback;
+ openCallback.Init(g_StdStream, g_ErrStream, percentsStream);
+
+ #ifndef Z7_NO_CRYPTO
+ bool passwordIsDefined =
+ (options.PasswordEnabled && !options.Password.IsEmpty());
+ openCallback.PasswordIsDefined = passwordIsDefined;
+ openCallback.Password = options.Password;
+ #endif
+
+ CUpdateCallbackConsole callback;
+ callback.LogLevel = options.LogLevel;
+ callback.PercentsNameLevel = percentsNameLevel;
+
+ if (percentsStream)
+ callback.SetWindowWidth(consoleWidth);
+
+ #ifndef Z7_NO_CRYPTO
+ callback.PasswordIsDefined = passwordIsDefined;
+ callback.AskPassword = (options.PasswordEnabled && options.Password.IsEmpty());
+ callback.Password = options.Password;
+ #endif
+
+ callback.StdOutMode = uo.StdOutMode;
+ callback.Init(
+ // NULL,
+ g_StdStream, g_ErrStream, percentsStream);
+
+ CUpdateErrorInfo errorInfo;
+
+ /*
+ if (!uo.Init(codecs, types, options.ArchiveName))
+ throw kUnsupportedUpdateArcType;
+ */
+ hresultMain = UpdateArchive(codecs,
+ types,
+ options.ArchiveName,
+ options.Censor,
+ uo,
+ errorInfo, &openCallback, &callback, true);
+
+ callback.ClosePercents2();
+
+ CStdOutStream *se = g_StdStream;
+ if (!se)
+ se = g_ErrStream;
+
+ retCode = WarningsCheck(hresultMain, callback, errorInfo,
+ g_StdStream, se,
+ true // options.EnableHeaders
+ );
+ }
+ else if (options.Command.CommandType == NCommandType::kHash)
+ {
+ const CHashOptions &uo = options.HashOptions;
+
+ CHashCallbackConsole callback;
+ if (percentsStream)
+ callback.SetWindowWidth(consoleWidth);
+
+ callback.Init(g_StdStream, g_ErrStream, percentsStream);
+ callback.PrintHeaders = options.EnableHeaders;
+ callback.PrintFields = options.ListFields;
+
+ AString errorInfoString;
+ hresultMain = HashCalc(EXTERNAL_CODECS_VARS_L
+ options.Censor, uo,
+ errorInfoString, &callback);
+ CUpdateErrorInfo errorInfo;
+ errorInfo.Message = errorInfoString;
+ CStdOutStream *se = g_StdStream;
+ if (!se)
+ se = g_ErrStream;
+ retCode = WarningsCheck(hresultMain, callback, errorInfo, g_StdStream, se, options.EnableHeaders);
+ }
+ else
+ ShowMessageAndThrowException(kUserErrorMessage, NExitCode::kUserError);
+
+ if (options.ShowTime && g_StdStream)
+ PrintStat(
+ #ifndef _WIN32
+ startTime
+ #endif
+ );
+
+ ThrowException_if_Error(hresultMain);
+
+ return retCode;
+}
diff --git a/CPP/7zip/UI/Console/MainAr.cpp b/CPP/7zip/UI/Console/MainAr.cpp
index 1d6c5a4..80f84f5 100644
--- a/CPP/7zip/UI/Console/MainAr.cpp
+++ b/CPP/7zip/UI/Console/MainAr.cpp
@@ -1,175 +1,227 @@
-// MainAr.cpp
-
-#include "StdAfx.h"
-
-#ifdef _WIN32
-#include "../../../../C/DllSecur.h"
-#endif
-
-#include "../../../Common/MyException.h"
-#include "../../../Common/StdOutStream.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/NtCheck.h"
-
-#include "../Common/ArchiveCommandLine.h"
-#include "../Common/ExitCode.h"
-
-#include "ConsoleClose.h"
-
-using namespace NWindows;
-
-CStdOutStream *g_StdStream = NULL;
-CStdOutStream *g_ErrStream = NULL;
-
-extern int Main2(
- #ifndef _WIN32
- int numArgs, char *args[]
- #endif
-);
-
-static const char * const kException_CmdLine_Error_Message = "Command Line Error:";
-static const char * const kExceptionErrorMessage = "ERROR:";
-static const char * const kUserBreakMessage = "Break signaled";
-static const char * const kMemoryExceptionMessage = "ERROR: Can't allocate required memory!";
-static const char * const kUnknownExceptionMessage = "Unknown Error";
-static const char * const kInternalExceptionMessage = "\n\nInternal Error #";
-
-static void FlushStreams()
-{
- if (g_StdStream)
- g_StdStream->Flush();
-}
-
-static void PrintError(const char *message)
-{
- FlushStreams();
- if (g_ErrStream)
- *g_ErrStream << "\n\n" << message << endl;
-}
-
-#define NT_CHECK_FAIL_ACTION *g_StdStream << "Unsupported Windows version"; return NExitCode::kFatalError;
-
-int MY_CDECL main
-(
- #ifndef _WIN32
- int numArgs, char *args[]
- #endif
-)
-{
- g_ErrStream = &g_StdErr;
- g_StdStream = &g_StdOut;
-
- NT_CHECK
-
- NConsoleClose::CCtrlHandlerSetter ctrlHandlerSetter;
- int res = 0;
-
- try
- {
- #ifdef _WIN32
- My_SetDefaultDllDirectories();
- #endif
-
- res = Main2(
- #ifndef _WIN32
- numArgs, args
- #endif
- );
- }
- catch(const CNewException &)
- {
- PrintError(kMemoryExceptionMessage);
- return (NExitCode::kMemoryError);
- }
- catch(const NConsoleClose::CCtrlBreakException &)
- {
- PrintError(kUserBreakMessage);
- return (NExitCode::kUserBreak);
- }
- catch(const CMessagePathException &e)
- {
- PrintError(kException_CmdLine_Error_Message);
- if (g_ErrStream)
- *g_ErrStream << e << endl;
- return (NExitCode::kUserError);
- }
- catch(const CSystemException &systemError)
- {
- if (systemError.ErrorCode == E_OUTOFMEMORY)
- {
- PrintError(kMemoryExceptionMessage);
- return (NExitCode::kMemoryError);
- }
- if (systemError.ErrorCode == E_ABORT)
- {
- PrintError(kUserBreakMessage);
- return (NExitCode::kUserBreak);
- }
- if (g_ErrStream)
- {
- PrintError("System ERROR:");
- *g_ErrStream << NError::MyFormatMessage(systemError.ErrorCode) << endl;
- }
- return (NExitCode::kFatalError);
- }
- catch(NExitCode::EEnum &exitCode)
- {
- FlushStreams();
- if (g_ErrStream)
- *g_ErrStream << kInternalExceptionMessage << exitCode << endl;
- return (exitCode);
- }
- catch(const UString &s)
- {
- if (g_ErrStream)
- {
- PrintError(kExceptionErrorMessage);
- *g_ErrStream << s << endl;
- }
- return (NExitCode::kFatalError);
- }
- catch(const AString &s)
- {
- if (g_ErrStream)
- {
- PrintError(kExceptionErrorMessage);
- *g_ErrStream << s << endl;
- }
- return (NExitCode::kFatalError);
- }
- catch(const char *s)
- {
- if (g_ErrStream)
- {
- PrintError(kExceptionErrorMessage);
- *g_ErrStream << s << endl;
- }
- return (NExitCode::kFatalError);
- }
- catch(const wchar_t *s)
- {
- if (g_ErrStream)
- {
- PrintError(kExceptionErrorMessage);
- *g_ErrStream << s << endl;
- }
- return (NExitCode::kFatalError);
- }
- catch(int t)
- {
- if (g_ErrStream)
- {
- FlushStreams();
- *g_ErrStream << kInternalExceptionMessage << t << endl;
- return (NExitCode::kFatalError);
- }
- }
- catch(...)
- {
- PrintError(kUnknownExceptionMessage);
- return (NExitCode::kFatalError);
- }
-
- return res;
-}
+// MainAr.cpp
+
+#include "StdAfx.h"
+
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyException.h"
+#include "../../../Common/StdOutStream.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/NtCheck.h"
+
+#include "../Common/ArchiveCommandLine.h"
+#include "../Common/ExitCode.h"
+
+#include "ConsoleClose.h"
+
+using namespace NWindows;
+
+extern
+CStdOutStream *g_StdStream;
+CStdOutStream *g_StdStream = NULL;
+extern
+CStdOutStream *g_ErrStream;
+CStdOutStream *g_ErrStream = NULL;
+
+extern int Main2(
+ #ifndef _WIN32
+ int numArgs, char *args[]
+ #endif
+);
+
+static const char * const kException_CmdLine_Error_Message = "Command Line Error:";
+static const char * const kExceptionErrorMessage = "ERROR:";
+static const char * const kUserBreakMessage = "Break signaled";
+static const char * const kMemoryExceptionMessage = "ERROR: Can't allocate required memory!";
+static const char * const kUnknownExceptionMessage = "Unknown Error";
+static const char * const kInternalExceptionMessage = "\n\nInternal Error #";
+
+static void FlushStreams()
+{
+ if (g_StdStream)
+ g_StdStream->Flush();
+}
+
+static void PrintError(const char *message)
+{
+ FlushStreams();
+ if (g_ErrStream)
+ *g_ErrStream << "\n\n" << message << endl;
+}
+
+#if defined(_WIN32) && defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION *g_StdStream << "Unsupported Windows version"; return NExitCode::kFatalError;
+#endif
+
+static inline bool CheckIsa()
+{
+ // __try
+ {
+ #if defined(__AVX2__)
+ if (!CPU_IsSupported_AVX2())
+ return false;
+ #elif defined(__AVX__)
+ if (!CPU_IsSupported_AVX())
+ return false;
+ #elif defined(__SSE2__) && !defined(MY_CPU_AMD64) || defined(_M_IX86_FP) && (_M_IX86_FP >= 2)
+ if (!CPU_IsSupported_SSE2())
+ return false;
+ #elif defined(__SSE__) && !defined(MY_CPU_AMD64) || defined(_M_IX86_FP) && (_M_IX86_FP >= 1)
+ if (!CPU_IsSupported_SSE() ||
+ !CPU_IsSupported_CMOV())
+ return false;
+ #endif
+ /*
+ __asm
+ {
+ _emit 0fH
+ _emit 038H
+ _emit 0cbH
+ _emit (0c0H + 0 * 8 + 0)
+ }
+ */
+ return true;
+ }
+ /*
+ __except (EXCEPTION_EXECUTE_HANDLER)
+ {
+ return false;
+ }
+ */
+}
+
+int Z7_CDECL main
+(
+ #ifndef _WIN32
+ int numArgs, char *args[]
+ #endif
+)
+{
+ g_ErrStream = &g_StdErr;
+ g_StdStream = &g_StdOut;
+
+ // #if (defined(_MSC_VER) && defined(_M_IX86))
+ if (!CheckIsa())
+ {
+ PrintError("ERROR: processor doesn't support required ISA extension");
+ return NExitCode::kFatalError;
+ }
+ // #endif
+
+ NT_CHECK
+
+ NConsoleClose::CCtrlHandlerSetter ctrlHandlerSetter;
+ int res = 0;
+
+ try
+ {
+ #ifdef _WIN32
+ My_SetDefaultDllDirectories();
+ #endif
+
+ res = Main2(
+ #ifndef _WIN32
+ numArgs, args
+ #endif
+ );
+ }
+ catch(const CNewException &)
+ {
+ PrintError(kMemoryExceptionMessage);
+ return (NExitCode::kMemoryError);
+ }
+ catch(const NConsoleClose::CCtrlBreakException &)
+ {
+ PrintError(kUserBreakMessage);
+ return (NExitCode::kUserBreak);
+ }
+ catch(const CMessagePathException &e)
+ {
+ PrintError(kException_CmdLine_Error_Message);
+ if (g_ErrStream)
+ *g_ErrStream << e << endl;
+ return (NExitCode::kUserError);
+ }
+ catch(const CSystemException &systemError)
+ {
+ if (systemError.ErrorCode == E_OUTOFMEMORY)
+ {
+ PrintError(kMemoryExceptionMessage);
+ return (NExitCode::kMemoryError);
+ }
+ if (systemError.ErrorCode == E_ABORT)
+ {
+ PrintError(kUserBreakMessage);
+ return (NExitCode::kUserBreak);
+ }
+ if (g_ErrStream)
+ {
+ PrintError("System ERROR:");
+ *g_ErrStream << NError::MyFormatMessage(systemError.ErrorCode) << endl;
+ }
+ return (NExitCode::kFatalError);
+ }
+ catch(NExitCode::EEnum exitCode)
+ {
+ FlushStreams();
+ if (g_ErrStream)
+ *g_ErrStream << kInternalExceptionMessage << exitCode << endl;
+ return (exitCode);
+ }
+ catch(const UString &s)
+ {
+ if (g_ErrStream)
+ {
+ PrintError(kExceptionErrorMessage);
+ *g_ErrStream << s << endl;
+ }
+ return (NExitCode::kFatalError);
+ }
+ catch(const AString &s)
+ {
+ if (g_ErrStream)
+ {
+ PrintError(kExceptionErrorMessage);
+ *g_ErrStream << s << endl;
+ }
+ return (NExitCode::kFatalError);
+ }
+ catch(const char *s)
+ {
+ if (g_ErrStream)
+ {
+ PrintError(kExceptionErrorMessage);
+ *g_ErrStream << s << endl;
+ }
+ return (NExitCode::kFatalError);
+ }
+ catch(const wchar_t *s)
+ {
+ if (g_ErrStream)
+ {
+ PrintError(kExceptionErrorMessage);
+ *g_ErrStream << s << endl;
+ }
+ return (NExitCode::kFatalError);
+ }
+ catch(int t)
+ {
+ if (g_ErrStream)
+ {
+ FlushStreams();
+ *g_ErrStream << kInternalExceptionMessage << t << endl;
+ return (NExitCode::kFatalError);
+ }
+ }
+ catch(...)
+ {
+ PrintError(kUnknownExceptionMessage);
+ return (NExitCode::kFatalError);
+ }
+
+ return res;
+}
diff --git a/CPP/7zip/UI/Console/OpenCallbackConsole.cpp b/CPP/7zip/UI/Console/OpenCallbackConsole.cpp
index 6e58c1f..1e7adf5 100644
--- a/CPP/7zip/UI/Console/OpenCallbackConsole.cpp
+++ b/CPP/7zip/UI/Console/OpenCallbackConsole.cpp
@@ -1,115 +1,115 @@
-// OpenCallbackConsole.cpp
-
-#include "StdAfx.h"
-
-#include "OpenCallbackConsole.h"
-
-#include "ConsoleClose.h"
-#include "UserInputUtils.h"
-
-static HRESULT CheckBreak2()
-{
- return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
-}
-
-HRESULT COpenCallbackConsole::Open_CheckBreak()
-{
- return CheckBreak2();
-}
-
-HRESULT COpenCallbackConsole::Open_SetTotal(const UInt64 *files, const UInt64 *bytes)
-{
- if (!MultiArcMode && NeedPercents())
- {
- if (files)
- {
- _totalFilesDefined = true;
- // _totalFiles = *files;
- _percent.Total = *files;
- }
- else
- _totalFilesDefined = false;
-
- if (bytes)
- {
- // _totalBytesDefined = true;
- _totalBytes = *bytes;
- if (!files)
- _percent.Total = *bytes;
- }
- else
- {
- // _totalBytesDefined = false;
- if (!files)
- _percent.Total = _totalBytes;
- }
- }
-
- return CheckBreak2();
-}
-
-HRESULT COpenCallbackConsole::Open_SetCompleted(const UInt64 *files, const UInt64 *bytes)
-{
- if (!MultiArcMode && NeedPercents())
- {
- if (files)
- {
- _percent.Files = *files;
- if (_totalFilesDefined)
- _percent.Completed = *files;
- }
-
- if (bytes)
- {
- if (!_totalFilesDefined)
- _percent.Completed = *bytes;
- }
- _percent.Print();
- }
-
- return CheckBreak2();
-}
-
-HRESULT COpenCallbackConsole::Open_Finished()
-{
- ClosePercents();
- return S_OK;
-}
-
-
-#ifndef _NO_CRYPTO
-
-HRESULT COpenCallbackConsole::Open_CryptoGetTextPassword(BSTR *password)
-{
- *password = NULL;
- RINOK(CheckBreak2());
-
- if (!PasswordIsDefined)
- {
- ClosePercents();
- RINOK(GetPassword_HRESULT(_so, Password));
- PasswordIsDefined = true;
- }
- return StringToBstr(Password, password);
-}
-
-/*
-HRESULT COpenCallbackConsole::Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password)
-{
- passwordIsDefined = PasswordIsDefined;
- password = Password;
- return S_OK;
-}
-
-bool COpenCallbackConsole::Open_WasPasswordAsked()
-{
- return PasswordWasAsked;
-}
-
-void COpenCallbackConsole::Open_Clear_PasswordWasAsked_Flag ()
-{
- PasswordWasAsked = false;
-}
-*/
-
-#endif
+// OpenCallbackConsole.cpp
+
+#include "StdAfx.h"
+
+#include "OpenCallbackConsole.h"
+
+#include "ConsoleClose.h"
+#include "UserInputUtils.h"
+
+static HRESULT CheckBreak2()
+{
+ return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
+}
+
+HRESULT COpenCallbackConsole::Open_CheckBreak()
+{
+ return CheckBreak2();
+}
+
+HRESULT COpenCallbackConsole::Open_SetTotal(const UInt64 *files, const UInt64 *bytes)
+{
+ if (!MultiArcMode && NeedPercents())
+ {
+ if (files)
+ {
+ _totalFilesDefined = true;
+ // _totalFiles = *files;
+ _percent.Total = *files;
+ }
+ else
+ _totalFilesDefined = false;
+
+ if (bytes)
+ {
+ // _totalBytesDefined = true;
+ _totalBytes = *bytes;
+ if (!files)
+ _percent.Total = *bytes;
+ }
+ else
+ {
+ // _totalBytesDefined = false;
+ if (!files)
+ _percent.Total = _totalBytes;
+ }
+ }
+
+ return CheckBreak2();
+}
+
+HRESULT COpenCallbackConsole::Open_SetCompleted(const UInt64 *files, const UInt64 *bytes)
+{
+ if (!MultiArcMode && NeedPercents())
+ {
+ if (files)
+ {
+ _percent.Files = *files;
+ if (_totalFilesDefined)
+ _percent.Completed = *files;
+ }
+
+ if (bytes)
+ {
+ if (!_totalFilesDefined)
+ _percent.Completed = *bytes;
+ }
+ _percent.Print();
+ }
+
+ return CheckBreak2();
+}
+
+HRESULT COpenCallbackConsole::Open_Finished()
+{
+ ClosePercents();
+ return S_OK;
+}
+
+
+#ifndef Z7_NO_CRYPTO
+
+HRESULT COpenCallbackConsole::Open_CryptoGetTextPassword(BSTR *password)
+{
+ *password = NULL;
+ RINOK(CheckBreak2())
+
+ if (!PasswordIsDefined)
+ {
+ ClosePercents();
+ RINOK(GetPassword_HRESULT(_so, Password))
+ PasswordIsDefined = true;
+ }
+ return StringToBstr(Password, password);
+}
+
+/*
+HRESULT COpenCallbackConsole::Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password)
+{
+ passwordIsDefined = PasswordIsDefined;
+ password = Password;
+ return S_OK;
+}
+
+bool COpenCallbackConsole::Open_WasPasswordAsked()
+{
+ return PasswordWasAsked;
+}
+
+void COpenCallbackConsole::Open_Clear_PasswordWasAsked_Flag ()
+{
+ PasswordWasAsked = false;
+}
+*/
+
+#endif
diff --git a/CPP/7zip/UI/Console/OpenCallbackConsole.h b/CPP/7zip/UI/Console/OpenCallbackConsole.h
index b9270f8..c5b4b45 100644
--- a/CPP/7zip/UI/Console/OpenCallbackConsole.h
+++ b/CPP/7zip/UI/Console/OpenCallbackConsole.h
@@ -1,66 +1,68 @@
-// OpenCallbackConsole.h
-
-#ifndef __OPEN_CALLBACK_CONSOLE_H
-#define __OPEN_CALLBACK_CONSOLE_H
-
-#include "../../../Common/StdOutStream.h"
-
-#include "../Common/ArchiveOpenCallback.h"
-
-#include "PercentPrinter.h"
-
-class COpenCallbackConsole: public IOpenCallbackUI
-{
-protected:
- CPercentPrinter _percent;
-
- CStdOutStream *_so;
- CStdOutStream *_se;
-
- bool _totalFilesDefined;
- // bool _totalBytesDefined;
- // UInt64 _totalFiles;
- UInt64 _totalBytes;
-
- bool NeedPercents() const { return _percent._so != NULL; }
-
-public:
-
- bool MultiArcMode;
-
- void ClosePercents()
- {
- if (NeedPercents())
- _percent.ClosePrint(true);
- }
-
- COpenCallbackConsole():
- _totalFilesDefined(false),
- // _totalBytesDefined(false),
- _totalBytes(0),
- MultiArcMode(false)
-
- #ifndef _NO_CRYPTO
- , PasswordIsDefined(false)
- // , PasswordWasAsked(false)
- #endif
-
- {}
-
- void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
- {
- _so = outStream;
- _se = errorStream;
- _percent._so = percentStream;
- }
-
- INTERFACE_IOpenCallbackUI(;)
-
- #ifndef _NO_CRYPTO
- bool PasswordIsDefined;
- // bool PasswordWasAsked;
- UString Password;
- #endif
-};
-
-#endif
+// OpenCallbackConsole.h
+
+#ifndef ZIP7_INC_OPEN_CALLBACK_CONSOLE_H
+#define ZIP7_INC_OPEN_CALLBACK_CONSOLE_H
+
+#include "../../../Common/StdOutStream.h"
+
+#include "../Common/ArchiveOpenCallback.h"
+
+#include "PercentPrinter.h"
+
+class COpenCallbackConsole: public IOpenCallbackUI
+{
+protected:
+ CPercentPrinter _percent;
+
+ CStdOutStream *_so;
+ CStdOutStream *_se;
+
+ // UInt64 _totalFiles;
+ UInt64 _totalBytes;
+ bool _totalFilesDefined;
+ // bool _totalBytesDefined;
+
+ bool NeedPercents() const { return _percent._so != NULL; }
+
+public:
+
+ bool MultiArcMode;
+
+ void ClosePercents()
+ {
+ if (NeedPercents())
+ _percent.ClosePrint(true);
+ }
+
+ COpenCallbackConsole():
+ _totalBytes(0),
+ _totalFilesDefined(false),
+ // _totalBytesDefined(false),
+ MultiArcMode(false)
+
+ #ifndef Z7_NO_CRYPTO
+ , PasswordIsDefined(false)
+ // , PasswordWasAsked(false)
+ #endif
+
+ {}
+
+ virtual ~COpenCallbackConsole() {}
+
+ void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
+ {
+ _so = outStream;
+ _se = errorStream;
+ _percent._so = percentStream;
+ }
+
+ Z7_IFACE_IMP(IOpenCallbackUI)
+
+ #ifndef Z7_NO_CRYPTO
+ bool PasswordIsDefined;
+ // bool PasswordWasAsked;
+ UString Password;
+ #endif
+};
+
+#endif
diff --git a/CPP/7zip/UI/Console/PercentPrinter.cpp b/CPP/7zip/UI/Console/PercentPrinter.cpp
index 20249ed..9d392ab 100644
--- a/CPP/7zip/UI/Console/PercentPrinter.cpp
+++ b/CPP/7zip/UI/Console/PercentPrinter.cpp
@@ -1,183 +1,184 @@
-// PercentPrinter.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "PercentPrinter.h"
-
-static const unsigned kPercentsSize = 4;
-
-CPercentPrinter::~CPercentPrinter()
-{
- ClosePrint(false);
-}
-
-void CPercentPrinterState::ClearCurState()
-{
- Completed = 0;
- Total = ((UInt64)(Int64)-1);
- Files = 0;
- Command.Empty();
- FileName.Empty();
-}
-
-void CPercentPrinter::ClosePrint(bool needFlush)
-{
- unsigned num = _printedString.Len();
- if (num != 0)
- {
-
- unsigned i;
-
- /* '\r' in old MAC OS means "new line".
- So we can't use '\r' in some systems */
-
- #ifdef _WIN32
- char *start = _temp.GetBuf(num + 2);
- char *p = start;
- *p++ = '\r';
- for (i = 0; i < num; i++) *p++ = ' ';
- *p++ = '\r';
- #else
- char *start = _temp.GetBuf(num * 3);
- char *p = start;
- for (i = 0; i < num; i++) *p++ = '\b';
- for (i = 0; i < num; i++) *p++ = ' ';
- for (i = 0; i < num; i++) *p++ = '\b';
- #endif
-
- *p = 0;
- _temp.ReleaseBuf_SetLen((unsigned)(p - start));
- *_so << _temp;
- }
- if (needFlush)
- _so->Flush();
- _printedString.Empty();
-}
-
-void CPercentPrinter::GetPercents()
-{
- char s[32];
- unsigned size;
- {
- char c = '%';
- UInt64 val = 0;
- if (Total == (UInt64)(Int64)-1)
- {
- val = Completed >> 20;
- c = 'M';
- }
- else if (Total != 0)
- val = Completed * 100 / Total;
- ConvertUInt64ToString(val, s);
- size = (unsigned)strlen(s);
- s[size++] = c;
- s[size] = 0;
- }
-
- while (size < kPercentsSize)
- {
- _s += ' ';
- size++;
- }
-
- _s += s;
-}
-
-void CPercentPrinter::Print()
-{
- DWORD tick = 0;
- if (_tickStep != 0)
- tick = GetTickCount();
-
- bool onlyPercentsChanged = false;
-
- if (!_printedString.IsEmpty())
- {
- if (_tickStep != 0 && (UInt32)(tick - _prevTick) < _tickStep)
- return;
-
- CPercentPrinterState &st = *this;
- if (_printedState.Command == st.Command
- && _printedState.FileName == st.FileName
- && _printedState.Files == st.Files)
- {
- if (_printedState.Total == st.Total
- && _printedState.Completed == st.Completed)
- return;
- onlyPercentsChanged = true;
- }
- }
-
- _s.Empty();
-
- GetPercents();
-
- if (onlyPercentsChanged && _s == _printedPercents)
- return;
-
- _printedPercents = _s;
-
- if (Files != 0)
- {
- char s[32];
- ConvertUInt64ToString(Files, s);
- // unsigned size = (unsigned)strlen(s);
- // for (; size < 3; size++) _s += ' ';
- _s += ' ';
- _s += s;
- // _s += "f";
- }
-
-
- if (!Command.IsEmpty())
- {
- _s += ' ';
- _s += Command;
- }
-
- if (!FileName.IsEmpty() && _s.Len() < MaxLen)
- {
- _s += ' ';
-
- _tempU = FileName;
- _so->Normalize_UString(_tempU);
- StdOut_Convert_UString_to_AString(_tempU, _temp);
- if (_s.Len() + _temp.Len() > MaxLen)
- {
- unsigned len = FileName.Len();
- for (; len != 0;)
- {
- unsigned delta = len / 8;
- if (delta == 0)
- delta = 1;
- len -= delta;
- _tempU = FileName;
- _tempU.Delete(len / 2, _tempU.Len() - len);
- _tempU.Insert(len / 2, L" . ");
- _so->Normalize_UString(_tempU);
- StdOut_Convert_UString_to_AString(_tempU, _temp);
- if (_s.Len() + _temp.Len() <= MaxLen)
- break;
- }
- if (len == 0)
- _temp.Empty();
- }
- _s += _temp;
- }
-
- if (_printedString != _s)
- {
- ClosePrint(false);
- *_so << _s;
- if (NeedFlush)
- _so->Flush();
- _printedString = _s;
- }
-
- _printedState = *this;
-
- if (_tickStep != 0)
- _prevTick = tick;
-}
+// PercentPrinter.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "PercentPrinter.h"
+
+static const unsigned kPercentsSize = 4;
+
+CPercentPrinter::~CPercentPrinter()
+{
+ ClosePrint(false);
+}
+
+void CPercentPrinterState::ClearCurState()
+{
+ Completed = 0;
+ Total = ((UInt64)(Int64)-1);
+ Files = 0;
+ Command.Empty();
+ FileName.Empty();
+}
+
+void CPercentPrinter::ClosePrint(bool needFlush)
+{
+ unsigned num = _printedString.Len();
+ if (num != 0)
+ {
+
+ unsigned i;
+
+ /* '\r' in old MAC OS means "new line".
+ So we can't use '\r' in some systems */
+
+ #ifdef _WIN32
+ char *start = _temp.GetBuf(num + 2);
+ char *p = start;
+ *p++ = '\r';
+ for (i = 0; i < num; i++) *p++ = ' ';
+ *p++ = '\r';
+ #else
+ char *start = _temp.GetBuf(num * 3);
+ char *p = start;
+ for (i = 0; i < num; i++) *p++ = '\b';
+ for (i = 0; i < num; i++) *p++ = ' ';
+ for (i = 0; i < num; i++) *p++ = '\b';
+ #endif
+
+ *p = 0;
+ _temp.ReleaseBuf_SetLen((unsigned)(p - start));
+ *_so << _temp;
+ }
+ if (needFlush)
+ _so->Flush();
+ _printedString.Empty();
+}
+
+void CPercentPrinter::GetPercents()
+{
+ char s[32];
+ unsigned size;
+ {
+ char c = '%';
+ UInt64 val = 0;
+ if (Total == (UInt64)(Int64)-1 ||
+ (Total == 0 && Completed != 0))
+ {
+ val = Completed >> 20;
+ c = 'M';
+ }
+ else if (Total != 0)
+ val = Completed * 100 / Total;
+ ConvertUInt64ToString(val, s);
+ size = (unsigned)strlen(s);
+ s[size++] = c;
+ s[size] = 0;
+ }
+
+ while (size < kPercentsSize)
+ {
+ _s.Add_Space();
+ size++;
+ }
+
+ _s += s;
+}
+
+void CPercentPrinter::Print()
+{
+ DWORD tick = 0;
+ if (_tickStep != 0)
+ tick = GetTickCount();
+
+ bool onlyPercentsChanged = false;
+
+ if (!_printedString.IsEmpty())
+ {
+ if (_tickStep != 0 && (UInt32)(tick - _prevTick) < _tickStep)
+ return;
+
+ CPercentPrinterState &st = *this;
+ if (_printedState.Command == st.Command
+ && _printedState.FileName == st.FileName
+ && _printedState.Files == st.Files)
+ {
+ if (_printedState.Total == st.Total
+ && _printedState.Completed == st.Completed)
+ return;
+ onlyPercentsChanged = true;
+ }
+ }
+
+ _s.Empty();
+
+ GetPercents();
+
+ if (onlyPercentsChanged && _s == _printedPercents)
+ return;
+
+ _printedPercents = _s;
+
+ if (Files != 0)
+ {
+ char s[32];
+ ConvertUInt64ToString(Files, s);
+ // unsigned size = (unsigned)strlen(s);
+ // for (; size < 3; size++) _s.Add_Space();
+ _s.Add_Space();
+ _s += s;
+ // _s += "f";
+ }
+
+
+ if (!Command.IsEmpty())
+ {
+ _s.Add_Space();
+ _s += Command;
+ }
+
+ if (!FileName.IsEmpty() && _s.Len() < MaxLen)
+ {
+ _s.Add_Space();
+
+ _tempU = FileName;
+ _so->Normalize_UString(_tempU);
+ _so->Convert_UString_to_AString(_tempU, _temp);
+ if (_s.Len() + _temp.Len() > MaxLen)
+ {
+ unsigned len = FileName.Len();
+ for (; len != 0;)
+ {
+ unsigned delta = len / 8;
+ if (delta == 0)
+ delta = 1;
+ len -= delta;
+ _tempU = FileName;
+ _tempU.Delete(len / 2, _tempU.Len() - len);
+ _tempU.Insert(len / 2, L" . ");
+ _so->Normalize_UString(_tempU);
+ _so->Convert_UString_to_AString(_tempU, _temp);
+ if (_s.Len() + _temp.Len() <= MaxLen)
+ break;
+ }
+ if (len == 0)
+ _temp.Empty();
+ }
+ _s += _temp;
+ }
+
+ if (_printedString != _s)
+ {
+ ClosePrint(false);
+ *_so << _s;
+ if (NeedFlush)
+ _so->Flush();
+ _printedString = _s;
+ }
+
+ _printedState = *this;
+
+ if (_tickStep != 0)
+ _prevTick = tick;
+}
diff --git a/CPP/7zip/UI/Console/PercentPrinter.h b/CPP/7zip/UI/Console/PercentPrinter.h
index 90b4083..4debb3b 100644
--- a/CPP/7zip/UI/Console/PercentPrinter.h
+++ b/CPP/7zip/UI/Console/PercentPrinter.h
@@ -1,62 +1,62 @@
-// PercentPrinter.h
-
-#ifndef __PERCENT_PRINTER_H
-#define __PERCENT_PRINTER_H
-
-#include "../../../Common/StdOutStream.h"
-
-struct CPercentPrinterState
-{
- UInt64 Completed;
- UInt64 Total;
-
- UInt64 Files;
-
- AString Command;
- UString FileName;
-
- void ClearCurState();
-
- CPercentPrinterState():
- Completed(0),
- Total((UInt64)(Int64)-1),
- Files(0)
- {}
-};
-
-class CPercentPrinter: public CPercentPrinterState
-{
- UInt32 _tickStep;
- DWORD _prevTick;
-
- AString _s;
-
- AString _printedString;
- AString _temp;
- UString _tempU;
-
- CPercentPrinterState _printedState;
- AString _printedPercents;
-
- void GetPercents();
-
-public:
- CStdOutStream *_so;
-
- bool NeedFlush;
- unsigned MaxLen;
-
- CPercentPrinter(UInt32 tickStep = 200):
- _tickStep(tickStep),
- _prevTick(0),
- NeedFlush(true),
- MaxLen(80 - 1)
- {}
-
- ~CPercentPrinter();
-
- void ClosePrint(bool needFlush);
- void Print();
-};
-
-#endif
+// PercentPrinter.h
+
+#ifndef ZIP7_INC_PERCENT_PRINTER_H
+#define ZIP7_INC_PERCENT_PRINTER_H
+
+#include "../../../Common/StdOutStream.h"
+
+struct CPercentPrinterState
+{
+ UInt64 Completed;
+ UInt64 Total;
+
+ UInt64 Files;
+
+ AString Command;
+ UString FileName;
+
+ void ClearCurState();
+
+ CPercentPrinterState():
+ Completed(0),
+ Total((UInt64)(Int64)-1),
+ Files(0)
+ {}
+};
+
+class CPercentPrinter: public CPercentPrinterState
+{
+ UInt32 _tickStep;
+ DWORD _prevTick;
+
+ AString _s;
+
+ AString _printedString;
+ AString _temp;
+ UString _tempU;
+
+ CPercentPrinterState _printedState;
+ AString _printedPercents;
+
+ void GetPercents();
+
+public:
+ CStdOutStream *_so;
+
+ bool NeedFlush;
+ unsigned MaxLen;
+
+ CPercentPrinter(UInt32 tickStep = 200):
+ _tickStep(tickStep),
+ _prevTick(0),
+ NeedFlush(true),
+ MaxLen(80 - 1)
+ {}
+
+ ~CPercentPrinter();
+
+ void ClosePrint(bool needFlush);
+ void Print();
+};
+
+#endif
diff --git a/CPP/7zip/UI/Console/StdAfx.cpp b/CPP/7zip/UI/Console/StdAfx.cpp
index c6d3b1f..d0feea8 100644
--- a/CPP/7zip/UI/Console/StdAfx.cpp
+++ b/CPP/7zip/UI/Console/StdAfx.cpp
@@ -1,3 +1,3 @@
-// StdAfx.cpp
-
-#include "StdAfx.h"
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/Console/StdAfx.h b/CPP/7zip/UI/Console/StdAfx.h
index 59d9ac1..035267c 100644
--- a/CPP/7zip/UI/Console/StdAfx.h
+++ b/CPP/7zip/UI/Console/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp b/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp
index 46ffaba..85496f5 100644
--- a/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp
+++ b/CPP/7zip/UI/Console/UpdateCallbackConsole.cpp
@@ -1,702 +1,885 @@
-// UpdateCallbackConsole.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "../../../Windows/ErrorMsg.h"
-
-#ifndef _7ZIP_ST
-#include "../../../Windows/Synchronization.h"
-#endif
-
-#include "ConsoleClose.h"
-#include "UserInputUtils.h"
-#include "UpdateCallbackConsole.h"
-
-using namespace NWindows;
-
-#ifndef _7ZIP_ST
-static NSynchronization::CCriticalSection g_CriticalSection;
-#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
-#else
-#define MT_LOCK
-#endif
-
-static const wchar_t * const kEmptyFileAlias = L"[Content]";
-
-static const char * const kOpenArchiveMessage = "Open archive: ";
-static const char * const kCreatingArchiveMessage = "Creating archive: ";
-static const char * const kUpdatingArchiveMessage = "Updating archive: ";
-static const char * const kScanningMessage = "Scanning the drive:";
-
-static const char * const kError = "ERROR: ";
-static const char * const kWarning = "WARNING: ";
-
-static HRESULT CheckBreak2()
-{
- return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
-}
-
-HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
-HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
-
-void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags);
-
-void Print_ErrorFormatIndex_Warning(CStdOutStream *_so, const CCodecs *codecs, const CArc &arc);
-
-HRESULT CUpdateCallbackConsole::OpenResult(
- const CCodecs *codecs, const CArchiveLink &arcLink,
- const wchar_t *name, HRESULT result)
-{
- ClosePercents2();
-
- FOR_VECTOR (level, arcLink.Arcs)
- {
- const CArc &arc = arcLink.Arcs[level];
- const CArcErrorInfo &er = arc.ErrorInfo;
-
- UInt32 errorFlags = er.GetErrorFlags();
-
- if (errorFlags != 0 || !er.ErrorMessage.IsEmpty())
- {
- if (_se)
- {
- *_se << endl;
- if (level != 0)
- *_se << arc.Path << endl;
- }
-
- if (errorFlags != 0)
- {
- if (_se)
- PrintErrorFlags(*_se, "ERRORS:", errorFlags);
- }
-
- if (!er.ErrorMessage.IsEmpty())
- {
- if (_se)
- *_se << "ERRORS:" << endl << er.ErrorMessage << endl;
- }
-
- if (_se)
- {
- *_se << endl;
- _se->Flush();
- }
- }
-
- UInt32 warningFlags = er.GetWarningFlags();
-
- if (warningFlags != 0 || !er.WarningMessage.IsEmpty())
- {
- if (_so)
- {
- *_so << endl;
- if (level != 0)
- *_so << arc.Path << endl;
- }
-
- if (warningFlags != 0)
- {
- if (_so)
- PrintErrorFlags(*_so, "WARNINGS:", warningFlags);
- }
-
- if (!er.WarningMessage.IsEmpty())
- {
- if (_so)
- *_so << "WARNINGS:" << endl << er.WarningMessage << endl;
- }
-
- if (_so)
- {
- *_so << endl;
- if (NeedFlush)
- _so->Flush();
- }
- }
-
-
- if (er.ErrorFormatIndex >= 0)
- {
- if (_so)
- {
- Print_ErrorFormatIndex_Warning(_so, codecs, arc);
- if (NeedFlush)
- _so->Flush();
- }
- }
- }
-
- if (result == S_OK)
- {
- if (_so)
- {
- RINOK(Print_OpenArchive_Props(*_so, codecs, arcLink));
- *_so << endl;
- }
- }
- else
- {
- if (_so)
- _so->Flush();
- if (_se)
- {
- *_se << kError;
- _se->NormalizePrint_wstr(name);
- *_se << endl;
- HRESULT res = Print_OpenArchive_Error(*_se, codecs, arcLink);
- RINOK(res);
- _se->Flush();
- }
- }
-
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::StartScanning()
-{
- if (_so)
- *_so << kScanningMessage << endl;
- _percent.Command = "Scan ";
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::ScanProgress(const CDirItemsStat &st, const FString &path, bool /* isDir */)
-{
- if (NeedPercents())
- {
- _percent.Files = st.NumDirs + st.NumFiles + st.NumAltStreams;
- _percent.Completed = st.GetTotalBytes();
- _percent.FileName = fs2us(path);
- _percent.Print();
- }
-
- return CheckBreak();
-}
-
-void CCallbackConsoleBase::CommonError(const FString &path, DWORD systemError, bool isWarning)
-{
- ClosePercents2();
-
- if (_se)
- {
- if (_so)
- _so->Flush();
-
- *_se << endl << (isWarning ? kWarning : kError)
- << NError::MyFormatMessage(systemError)
- << endl;
- _se->NormalizePrint_UString(fs2us(path));
- *_se << endl << endl;
- _se->Flush();
- }
-}
-
-
-HRESULT CCallbackConsoleBase::ScanError_Base(const FString &path, DWORD systemError)
-{
- MT_LOCK
-
- ScanErrors.AddError(path, systemError);
- CommonError(path, systemError, true);
-
- return S_OK;
-}
-
-HRESULT CCallbackConsoleBase::OpenFileError_Base(const FString &path, DWORD systemError)
-{
- MT_LOCK
- FailedFiles.AddError(path, systemError);
- /*
- if (systemError == ERROR_SHARING_VIOLATION)
- {
- */
- CommonError(path, systemError, true);
- return S_FALSE;
- /*
- }
- return systemError;
- */
-}
-
-HRESULT CCallbackConsoleBase::ReadingFileError_Base(const FString &path, DWORD systemError)
-{
- MT_LOCK
- CommonError(path, systemError, false);
- return HRESULT_FROM_WIN32(systemError);
-}
-
-HRESULT CUpdateCallbackConsole::ScanError(const FString &path, DWORD systemError)
-{
- return ScanError_Base(path, systemError);
-}
-
-
-static void PrintPropPair(AString &s, const char *name, UInt64 val)
-{
- char temp[32];
- ConvertUInt64ToString(val, temp);
- s += name;
- s += ": ";
- s += temp;
-}
-
-void PrintSize_bytes_Smart(AString &s, UInt64 val);
-void Print_DirItemsStat(AString &s, const CDirItemsStat &st);
-void Print_DirItemsStat2(AString &s, const CDirItemsStat2 &st);
-
-HRESULT CUpdateCallbackConsole::FinishScanning(const CDirItemsStat &st)
-{
- if (NeedPercents())
- {
- _percent.ClosePrint(true);
- _percent.ClearCurState();
- }
-
- if (_so)
- {
- AString s;
- Print_DirItemsStat(s, st);
- *_so << s << endl << endl;
- }
- return S_OK;
-}
-
-static const char * const k_StdOut_ArcName = "StdOut";
-
-HRESULT CUpdateCallbackConsole::StartOpenArchive(const wchar_t *name)
-{
- if (_so)
- {
- *_so << kOpenArchiveMessage;
- if (name)
- *_so << name;
- else
- *_so << k_StdOut_ArcName;
- *_so << endl;
- }
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::StartArchive(const wchar_t *name, bool updating)
-{
- if (_so)
- {
- *_so << (updating ? kUpdatingArchiveMessage : kCreatingArchiveMessage);
- if (name)
- _so->NormalizePrint_wstr(name);
- else
- *_so << k_StdOut_ArcName;
- *_so << endl << endl;
- }
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::FinishArchive(const CFinishArchiveStat &st)
-{
- ClosePercents2();
-
- if (_so)
- {
- AString s;
- // Print_UInt64_and_String(s, _percent.Files == 1 ? "file" : "files", _percent.Files);
- PrintPropPair(s, "Files read from disk", _percent.Files);
- s.Add_LF();
- s += "Archive size: ";
- PrintSize_bytes_Smart(s, st.OutArcFileSize);
- s.Add_LF();
- *_so << endl;
- *_so << s;
- // *_so << endl;
- }
-
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::WriteSfx(const wchar_t *name, UInt64 size)
-{
- if (_so)
- {
- *_so << "Write SFX: ";
- *_so << name;
- AString s (" : ");
- PrintSize_bytes_Smart(s, size);
- *_so << s << endl;
- }
- return S_OK;
-}
-
-
-HRESULT CUpdateCallbackConsole::DeletingAfterArchiving(const FString &path, bool /* isDir */)
-{
- if (LogLevel > 0 && _so)
- {
- ClosePercents_for_so();
-
- if (!DeleteMessageWasShown)
- {
- if (_so)
- *_so << endl << ": Removing files after including to archive" << endl;
- }
-
- {
- {
- _tempA = "Removing";
- _tempA.Add_Space();
- *_so << _tempA;
- _tempU = fs2us(path);
- _so->Normalize_UString(_tempU);
- _so->PrintUString(_tempU, _tempA);
- *_so << endl;
- if (NeedFlush)
- _so->Flush();
- }
- }
- }
-
- if (!DeleteMessageWasShown)
- {
- if (NeedPercents())
- {
- _percent.ClearCurState();
- }
- DeleteMessageWasShown = true;
- }
- else
- {
- _percent.Files++;
- }
-
- if (NeedPercents())
- {
- // if (!FullLog)
- {
- _percent.Command = "Removing";
- _percent.FileName = fs2us(path);
- }
- _percent.Print();
- }
-
- return S_OK;
-}
-
-
-HRESULT CUpdateCallbackConsole::FinishDeletingAfterArchiving()
-{
- ClosePercents2();
- if (_so && DeleteMessageWasShown)
- *_so << endl;
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::CheckBreak()
-{
- return CheckBreak2();
-}
-
-/*
-HRESULT CUpdateCallbackConsole::Finalize()
-{
- // MT_LOCK
- return S_OK;
-}
-*/
-
-
-void static PrintToDoStat(CStdOutStream *_so, const CDirItemsStat2 &stat, const char *name)
-{
- AString s;
- Print_DirItemsStat2(s, stat);
- *_so << name << ": " << s << endl;
-}
-
-HRESULT CUpdateCallbackConsole::SetNumItems(const CArcToDoStat &stat)
-{
- if (_so)
- {
- ClosePercents_for_so();
- if (!stat.DeleteData.IsEmpty())
- {
- *_so << endl;
- PrintToDoStat(_so, stat.DeleteData, "Delete data from archive");
- }
- if (!stat.OldData.IsEmpty())
- PrintToDoStat(_so, stat.OldData, "Keep old data in archive");
- // if (!stat.NewData.IsEmpty())
- {
- PrintToDoStat(_so, stat.NewData, "Add new data to archive");
- }
- *_so << endl;
- }
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::SetTotal(UInt64 size)
-{
- MT_LOCK
- if (NeedPercents())
- {
- _percent.Total = size;
- _percent.Print();
- }
- return S_OK;
-}
-
-HRESULT CUpdateCallbackConsole::SetCompleted(const UInt64 *completeValue)
-{
- MT_LOCK
- if (completeValue)
- {
- if (NeedPercents())
- {
- _percent.Completed = *completeValue;
- _percent.Print();
- }
- }
- return CheckBreak2();
-}
-
-HRESULT CUpdateCallbackConsole::SetRatioInfo(const UInt64 * /* inSize */, const UInt64 * /* outSize */)
-{
- return CheckBreak2();
-}
-
-HRESULT CCallbackConsoleBase::PrintProgress(const wchar_t *name, const char *command, bool showInLog)
-{
- MT_LOCK
-
- bool show2 = (showInLog && _so);
-
- if (show2)
- {
- ClosePercents_for_so();
-
- _tempA = command;
- if (name)
- _tempA.Add_Space();
- *_so << _tempA;
-
- _tempU.Empty();
- if (name)
- {
- _tempU = name;
- _so->Normalize_UString(_tempU);
- }
- _so->PrintUString(_tempU, _tempA);
- *_so << endl;
- if (NeedFlush)
- _so->Flush();
- }
-
- if (NeedPercents())
- {
- if (PercentsNameLevel >= 1)
- {
- _percent.FileName.Empty();
- _percent.Command.Empty();
- if (PercentsNameLevel > 1 || !show2)
- {
- _percent.Command = command;
- if (name)
- _percent.FileName = name;
- }
- }
- _percent.Print();
- }
-
- return CheckBreak2();
-}
-
-HRESULT CUpdateCallbackConsole::GetStream(const wchar_t *name, bool /* isDir */, bool isAnti, UInt32 mode)
-{
- if (StdOutMode)
- return S_OK;
-
- if (!name || name[0] == 0)
- name = kEmptyFileAlias;
-
- unsigned requiredLevel = 1;
-
- const char *s;
- if (mode == NUpdateNotifyOp::kAdd ||
- mode == NUpdateNotifyOp::kUpdate)
- {
- if (isAnti)
- s = "Anti";
- else if (mode == NUpdateNotifyOp::kAdd)
- s = "+";
- else
- s = "U";
- }
- else
- {
- requiredLevel = 3;
- if (mode == NUpdateNotifyOp::kAnalyze)
- s = "A";
- else
- s = "Reading";
- }
-
- return PrintProgress(name, s, LogLevel >= requiredLevel);
-}
-
-HRESULT CUpdateCallbackConsole::OpenFileError(const FString &path, DWORD systemError)
-{
- return OpenFileError_Base(path, systemError);
-}
-
-HRESULT CUpdateCallbackConsole::ReadingFileError(const FString &path, DWORD systemError)
-{
- return ReadingFileError_Base(path, systemError);
-}
-
-HRESULT CUpdateCallbackConsole::SetOperationResult(Int32)
-{
- MT_LOCK
- _percent.Files++;
- return S_OK;
-}
-
-void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &dest);
-
-HRESULT CUpdateCallbackConsole::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name)
-{
- // if (StdOutMode) return S_OK;
-
- if (opRes != NArchive::NExtract::NOperationResult::kOK)
- {
- ClosePercents2();
-
- if (_se)
- {
- if (_so)
- _so->Flush();
-
- AString s;
- SetExtractErrorMessage(opRes, isEncrypted, s);
- *_se << s << " : " << endl;
- _se->NormalizePrint_wstr(name);
- *_se << endl << endl;
- _se->Flush();
- }
- return S_OK;
- }
- return S_OK;
-}
-
-
-HRESULT CUpdateCallbackConsole::ReportUpdateOpeartion(UInt32 op, const wchar_t *name, bool /* isDir */)
-{
- // if (StdOutMode) return S_OK;
-
- char temp[16];
- const char *s;
-
- unsigned requiredLevel = 1;
-
- switch (op)
- {
- case NUpdateNotifyOp::kAdd: s = "+"; break;
- case NUpdateNotifyOp::kUpdate: s = "U"; break;
- case NUpdateNotifyOp::kAnalyze: s = "A"; requiredLevel = 3; break;
- case NUpdateNotifyOp::kReplicate: s = "="; requiredLevel = 3; break;
- case NUpdateNotifyOp::kRepack: s = "R"; requiredLevel = 2; break;
- case NUpdateNotifyOp::kSkip: s = "."; requiredLevel = 2; break;
- case NUpdateNotifyOp::kDelete: s = "D"; requiredLevel = 3; break;
- case NUpdateNotifyOp::kHeader: s = "Header creation"; requiredLevel = 100; break;
- default:
- {
- temp[0] = 'o';
- temp[1] = 'p';
- ConvertUInt64ToString(op, temp + 2);
- s = temp;
- }
- }
-
- return PrintProgress(name, s, LogLevel >= requiredLevel);
-}
-
-/*
-HRESULT CUpdateCallbackConsole::SetPassword(const UString &
- #ifndef _NO_CRYPTO
- password
- #endif
- )
-{
- #ifndef _NO_CRYPTO
- PasswordIsDefined = true;
- Password = password;
- #endif
- return S_OK;
-}
-*/
-
-HRESULT CUpdateCallbackConsole::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
-{
- COM_TRY_BEGIN
-
- *password = NULL;
-
- #ifdef _NO_CRYPTO
-
- *passwordIsDefined = false;
- return S_OK;
-
- #else
-
- if (!PasswordIsDefined)
- {
- if (AskPassword)
- {
- RINOK(GetPassword_HRESULT(_so, Password));
- PasswordIsDefined = true;
- }
- }
- *passwordIsDefined = BoolToInt(PasswordIsDefined);
- return StringToBstr(Password, password);
-
- #endif
-
- COM_TRY_END
-}
-
-HRESULT CUpdateCallbackConsole::CryptoGetTextPassword(BSTR *password)
-{
- COM_TRY_BEGIN
-
- *password = NULL;
-
- #ifdef _NO_CRYPTO
-
- return E_NOTIMPL;
-
- #else
-
- if (!PasswordIsDefined)
- {
- {
- RINOK(GetPassword_HRESULT(_so, Password))
- PasswordIsDefined = true;
- }
- }
- return StringToBstr(Password, password);
-
- #endif
- COM_TRY_END
-}
-
-HRESULT CUpdateCallbackConsole::ShowDeleteFile(const wchar_t *name, bool /* isDir */)
-{
- if (StdOutMode)
- return S_OK;
-
- if (LogLevel > 7)
- {
- if (!name || name[0] == 0)
- name = kEmptyFileAlias;
- return PrintProgress(name, "D", true);
- }
- return S_OK;
-}
+// UpdateCallbackConsole.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileName.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+// #include "../Common/PropIDUtils.h"
+
+#include "ConsoleClose.h"
+#include "UserInputUtils.h"
+#include "UpdateCallbackConsole.h"
+
+using namespace NWindows;
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+static const wchar_t * const kEmptyFileAlias = L"[Content]";
+
+static const char * const kOpenArchiveMessage = "Open archive: ";
+static const char * const kCreatingArchiveMessage = "Creating archive: ";
+static const char * const kUpdatingArchiveMessage = "Updating archive: ";
+static const char * const kScanningMessage = "Scanning the drive:";
+
+static const char * const kError = "ERROR: ";
+static const char * const kWarning = "WARNING: ";
+
+static HRESULT CheckBreak2()
+{
+ return NConsoleClose::TestBreakSignal() ? E_ABORT : S_OK;
+}
+
+HRESULT Print_OpenArchive_Props(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
+HRESULT Print_OpenArchive_Error(CStdOutStream &so, const CCodecs *codecs, const CArchiveLink &arcLink);
+
+void PrintErrorFlags(CStdOutStream &so, const char *s, UInt32 errorFlags);
+
+void Print_ErrorFormatIndex_Warning(CStdOutStream *_so, const CCodecs *codecs, const CArc &arc);
+
+HRESULT CUpdateCallbackConsole::OpenResult(
+ const CCodecs *codecs, const CArchiveLink &arcLink,
+ const wchar_t *name, HRESULT result)
+{
+ ClosePercents2();
+
+ FOR_VECTOR (level, arcLink.Arcs)
+ {
+ const CArc &arc = arcLink.Arcs[level];
+ const CArcErrorInfo &er = arc.ErrorInfo;
+
+ UInt32 errorFlags = er.GetErrorFlags();
+
+ if (errorFlags != 0 || !er.ErrorMessage.IsEmpty())
+ {
+ if (_se)
+ {
+ *_se << endl;
+ if (level != 0)
+ *_se << arc.Path << endl;
+ }
+
+ if (errorFlags != 0)
+ {
+ if (_se)
+ PrintErrorFlags(*_se, "ERRORS:", errorFlags);
+ }
+
+ if (!er.ErrorMessage.IsEmpty())
+ {
+ if (_se)
+ *_se << "ERRORS:" << endl << er.ErrorMessage << endl;
+ }
+
+ if (_se)
+ {
+ *_se << endl;
+ _se->Flush();
+ }
+ }
+
+ UInt32 warningFlags = er.GetWarningFlags();
+
+ if (warningFlags != 0 || !er.WarningMessage.IsEmpty())
+ {
+ if (_so)
+ {
+ *_so << endl;
+ if (level != 0)
+ *_so << arc.Path << endl;
+ }
+
+ if (warningFlags != 0)
+ {
+ if (_so)
+ PrintErrorFlags(*_so, "WARNINGS:", warningFlags);
+ }
+
+ if (!er.WarningMessage.IsEmpty())
+ {
+ if (_so)
+ *_so << "WARNINGS:" << endl << er.WarningMessage << endl;
+ }
+
+ if (_so)
+ {
+ *_so << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+ }
+
+
+ if (er.ErrorFormatIndex >= 0)
+ {
+ if (_so)
+ {
+ Print_ErrorFormatIndex_Warning(_so, codecs, arc);
+ if (NeedFlush)
+ _so->Flush();
+ }
+ }
+ }
+
+ if (result == S_OK)
+ {
+ if (_so)
+ {
+ RINOK(Print_OpenArchive_Props(*_so, codecs, arcLink))
+ *_so << endl;
+ }
+ }
+ else
+ {
+ if (_so)
+ _so->Flush();
+ if (_se)
+ {
+ *_se << kError;
+ _se->NormalizePrint_wstr(name);
+ *_se << endl;
+ HRESULT res = Print_OpenArchive_Error(*_se, codecs, arcLink);
+ RINOK(res)
+ _se->Flush();
+ }
+ }
+
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::StartScanning()
+{
+ if (_so)
+ *_so << kScanningMessage << endl;
+ _percent.Command = "Scan ";
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::ScanProgress(const CDirItemsStat &st, const FString &path, bool /* isDir */)
+{
+ if (NeedPercents())
+ {
+ _percent.Files = st.NumDirs + st.NumFiles + st.NumAltStreams;
+ _percent.Completed = st.GetTotalBytes();
+ _percent.FileName = fs2us(path);
+ _percent.Print();
+ }
+
+ return CheckBreak();
+}
+
+void CCallbackConsoleBase::CommonError(const FString &path, DWORD systemError, bool isWarning)
+{
+ ClosePercents2();
+
+ if (_se)
+ {
+ if (_so)
+ _so->Flush();
+
+ *_se << endl << (isWarning ? kWarning : kError)
+ << NError::MyFormatMessage(systemError)
+ << endl;
+ _se->NormalizePrint_UString(fs2us(path));
+ *_se << endl << endl;
+ _se->Flush();
+ }
+}
+
+/*
+void CCallbackConsoleBase::CommonError(const char *message)
+{
+ ClosePercents2();
+
+ if (_se)
+ {
+ if (_so)
+ _so->Flush();
+
+ *_se << endl << kError << message << endl;
+ _se->Flush();
+ }
+}
+*/
+
+
+HRESULT CCallbackConsoleBase::ScanError_Base(const FString &path, DWORD systemError)
+{
+ MT_LOCK
+
+ ScanErrors.AddError(path, systemError);
+ CommonError(path, systemError, true);
+
+ return S_OK;
+}
+
+HRESULT CCallbackConsoleBase::OpenFileError_Base(const FString &path, DWORD systemError)
+{
+ MT_LOCK
+ FailedFiles.AddError(path, systemError);
+ NumNonOpenFiles++;
+ /*
+ if (systemError == ERROR_SHARING_VIOLATION)
+ {
+ */
+ CommonError(path, systemError, true);
+ return S_FALSE;
+ /*
+ }
+ return systemError;
+ */
+}
+
+HRESULT CCallbackConsoleBase::ReadingFileError_Base(const FString &path, DWORD systemError)
+{
+ MT_LOCK
+ CommonError(path, systemError, false);
+ return HRESULT_FROM_WIN32(systemError);
+}
+
+HRESULT CUpdateCallbackConsole::ScanError(const FString &path, DWORD systemError)
+{
+ return ScanError_Base(path, systemError);
+}
+
+
+static void PrintPropPair(AString &s, const char *name, UInt64 val)
+{
+ char temp[32];
+ ConvertUInt64ToString(val, temp);
+ s += name;
+ s += ": ";
+ s += temp;
+}
+
+void PrintSize_bytes_Smart(AString &s, UInt64 val);
+void Print_DirItemsStat(AString &s, const CDirItemsStat &st);
+void Print_DirItemsStat2(AString &s, const CDirItemsStat2 &st);
+
+HRESULT CUpdateCallbackConsole::FinishScanning(const CDirItemsStat &st)
+{
+ if (NeedPercents())
+ {
+ _percent.ClosePrint(true);
+ _percent.ClearCurState();
+ }
+
+ if (_so)
+ {
+ AString s;
+ Print_DirItemsStat(s, st);
+ *_so << s << endl << endl;
+ }
+ return S_OK;
+}
+
+static const char * const k_StdOut_ArcName = "StdOut";
+
+HRESULT CUpdateCallbackConsole::StartOpenArchive(const wchar_t *name)
+{
+ if (_so)
+ {
+ *_so << kOpenArchiveMessage;
+ if (name)
+ *_so << name;
+ else
+ *_so << k_StdOut_ArcName;
+ *_so << endl;
+ }
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::StartArchive(const wchar_t *name, bool updating)
+{
+ if (NeedPercents())
+ _percent.ClosePrint(true);
+
+ _percent.ClearCurState();
+ NumNonOpenFiles = 0;
+
+ if (_so)
+ {
+ *_so << (updating ? kUpdatingArchiveMessage : kCreatingArchiveMessage);
+ if (name)
+ _so->NormalizePrint_wstr(name);
+ else
+ *_so << k_StdOut_ArcName;
+ *_so << endl << endl;
+ }
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::FinishArchive(const CFinishArchiveStat &st)
+{
+ ClosePercents2();
+
+ if (_so)
+ {
+ AString s;
+ // Print_UInt64_and_String(s, _percent.Files == 1 ? "file" : "files", _percent.Files);
+ PrintPropPair(s, "Files read from disk", _percent.Files - NumNonOpenFiles);
+ s.Add_LF();
+ s += "Archive size: ";
+ PrintSize_bytes_Smart(s, st.OutArcFileSize);
+ s.Add_LF();
+ if (st.IsMultiVolMode)
+ {
+ s += "Volumes: ";
+ s.Add_UInt32(st.NumVolumes);
+ s.Add_LF();
+ }
+ *_so << endl;
+ *_so << s;
+ // *_so << endl;
+ }
+
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::WriteSfx(const wchar_t *name, UInt64 size)
+{
+ if (_so)
+ {
+ *_so << "Write SFX: ";
+ *_so << name;
+ AString s (" : ");
+ PrintSize_bytes_Smart(s, size);
+ *_so << s << endl;
+ }
+ return S_OK;
+}
+
+
+HRESULT CUpdateCallbackConsole::DeletingAfterArchiving(const FString &path, bool /* isDir */)
+{
+ if (LogLevel > 0 && _so)
+ {
+ ClosePercents_for_so();
+
+ if (!DeleteMessageWasShown)
+ {
+ if (_so)
+ *_so << endl << ": Removing files after including to archive" << endl;
+ }
+
+ {
+ {
+ _tempA = "Removing";
+ _tempA.Add_Space();
+ *_so << _tempA;
+ _tempU = fs2us(path);
+ _so->Normalize_UString(_tempU);
+ _so->PrintUString(_tempU, _tempA);
+ *_so << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+ }
+ }
+
+ if (!DeleteMessageWasShown)
+ {
+ if (NeedPercents())
+ {
+ _percent.ClearCurState();
+ }
+ DeleteMessageWasShown = true;
+ }
+ else
+ {
+ _percent.Files++;
+ }
+
+ if (NeedPercents())
+ {
+ // if (!FullLog)
+ {
+ _percent.Command = "Removing";
+ _percent.FileName = fs2us(path);
+ }
+ _percent.Print();
+ }
+
+ return S_OK;
+}
+
+
+HRESULT CUpdateCallbackConsole::FinishDeletingAfterArchiving()
+{
+ ClosePercents2();
+ if (_so && DeleteMessageWasShown)
+ *_so << endl;
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::CheckBreak()
+{
+ return CheckBreak2();
+}
+
+/*
+HRESULT CUpdateCallbackConsole::Finalize()
+{
+ // MT_LOCK
+ return S_OK;
+}
+*/
+
+
+void static PrintToDoStat(CStdOutStream *_so, const CDirItemsStat2 &stat, const char *name)
+{
+ AString s;
+ Print_DirItemsStat2(s, stat);
+ *_so << name << ": " << s << endl;
+}
+
+HRESULT CUpdateCallbackConsole::SetNumItems(const CArcToDoStat &stat)
+{
+ if (_so)
+ {
+ ClosePercents_for_so();
+ if (!stat.DeleteData.IsEmpty())
+ {
+ *_so << endl;
+ PrintToDoStat(_so, stat.DeleteData, "Delete data from archive");
+ }
+ if (!stat.OldData.IsEmpty())
+ PrintToDoStat(_so, stat.OldData, "Keep old data in archive");
+ // if (!stat.NewData.IsEmpty())
+ {
+ PrintToDoStat(_so, stat.NewData, "Add new data to archive");
+ }
+ *_so << endl;
+ }
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::SetTotal(UInt64 size)
+{
+ MT_LOCK
+ if (NeedPercents())
+ {
+ _percent.Total = size;
+ _percent.Print();
+ }
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::SetCompleted(const UInt64 *completeValue)
+{
+ MT_LOCK
+ if (completeValue)
+ {
+ if (NeedPercents())
+ {
+ _percent.Completed = *completeValue;
+ _percent.Print();
+ }
+ }
+ return CheckBreak2();
+}
+
+HRESULT CUpdateCallbackConsole::SetRatioInfo(const UInt64 * /* inSize */, const UInt64 * /* outSize */)
+{
+ return CheckBreak2();
+}
+
+HRESULT CCallbackConsoleBase::PrintProgress(const wchar_t *name, bool isDir, const char *command, bool showInLog)
+{
+ MT_LOCK
+
+ bool show2 = (showInLog && _so);
+
+ if (show2)
+ {
+ ClosePercents_for_so();
+
+ _tempA = command;
+ if (name)
+ _tempA.Add_Space();
+ *_so << _tempA;
+
+ _tempU.Empty();
+ if (name)
+ {
+ _tempU = name;
+ if (isDir)
+ NWindows::NFile::NName::NormalizeDirPathPrefix(_tempU);
+ _so->Normalize_UString(_tempU);
+ }
+ _so->PrintUString(_tempU, _tempA);
+ *_so << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+
+ if (NeedPercents())
+ {
+ if (PercentsNameLevel >= 1)
+ {
+ _percent.FileName.Empty();
+ _percent.Command.Empty();
+ if (PercentsNameLevel > 1 || !show2)
+ {
+ _percent.Command = command;
+ if (name)
+ _percent.FileName = name;
+ }
+ }
+ _percent.Print();
+ }
+
+ return CheckBreak2();
+}
+
+
+/*
+void CCallbackConsoleBase::PrintInfoLine(const UString &s)
+{
+ if (LogLevel < 1000)
+ return;
+
+ MT_LOCK
+
+ const bool show2 = (_so != NULL);
+
+ if (show2)
+ {
+ ClosePercents_for_so();
+ _so->PrintUString(s, _tempA);
+ *_so << endl;
+ if (NeedFlush)
+ _so->Flush();
+ }
+}
+*/
+
+HRESULT CUpdateCallbackConsole::GetStream(const wchar_t *name, bool isDir, bool isAnti, UInt32 mode)
+{
+ if (StdOutMode)
+ return S_OK;
+
+ if (!name || name[0] == 0)
+ name = kEmptyFileAlias;
+
+ unsigned requiredLevel = 1;
+
+ const char *s;
+ if (mode == NUpdateNotifyOp::kAdd ||
+ mode == NUpdateNotifyOp::kUpdate)
+ {
+ if (isAnti)
+ s = "Anti";
+ else if (mode == NUpdateNotifyOp::kAdd)
+ s = "+";
+ else
+ s = "U";
+ }
+ else
+ {
+ requiredLevel = 3;
+ if (mode == NUpdateNotifyOp::kAnalyze)
+ s = "A";
+ else
+ s = "Reading";
+ }
+
+ return PrintProgress(name, isDir, s, LogLevel >= requiredLevel);
+}
+
+HRESULT CUpdateCallbackConsole::OpenFileError(const FString &path, DWORD systemError)
+{
+ return OpenFileError_Base(path, systemError);
+}
+
+HRESULT CUpdateCallbackConsole::ReadingFileError(const FString &path, DWORD systemError)
+{
+ return ReadingFileError_Base(path, systemError);
+}
+
+HRESULT CUpdateCallbackConsole::SetOperationResult(Int32 /* opRes */)
+{
+ MT_LOCK
+ _percent.Files++;
+ /*
+ if (opRes != NArchive::NUpdate::NOperationResult::kOK)
+ {
+ if (opRes == NArchive::NUpdate::NOperationResult::kError_FileChanged)
+ {
+ CommonError("Input file changed");
+ }
+ }
+ */
+ return S_OK;
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &dest);
+
+HRESULT CUpdateCallbackConsole::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name)
+{
+ // if (StdOutMode) return S_OK;
+
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ ClosePercents2();
+
+ if (_se)
+ {
+ if (_so)
+ _so->Flush();
+
+ AString s;
+ SetExtractErrorMessage(opRes, isEncrypted, s);
+ *_se << s << " : " << endl;
+ _se->NormalizePrint_wstr(name);
+ *_se << endl << endl;
+ _se->Flush();
+ }
+ return S_OK;
+ }
+ return S_OK;
+}
+
+
+HRESULT CUpdateCallbackConsole::ReportUpdateOperation(UInt32 op, const wchar_t *name, bool isDir)
+{
+ // if (StdOutMode) return S_OK;
+
+ char temp[16];
+ const char *s;
+
+ unsigned requiredLevel = 1;
+
+ switch (op)
+ {
+ case NUpdateNotifyOp::kAdd: s = "+"; break;
+ case NUpdateNotifyOp::kUpdate: s = "U"; break;
+ case NUpdateNotifyOp::kAnalyze: s = "A"; requiredLevel = 3; break;
+ case NUpdateNotifyOp::kReplicate: s = "="; requiredLevel = 3; break;
+ case NUpdateNotifyOp::kRepack: s = "R"; requiredLevel = 2; break;
+ case NUpdateNotifyOp::kSkip: s = "."; requiredLevel = 2; break;
+ case NUpdateNotifyOp::kDelete: s = "D"; requiredLevel = 3; break;
+ case NUpdateNotifyOp::kHeader: s = "Header creation"; requiredLevel = 100; break;
+ case NUpdateNotifyOp::kInFileChanged: s = "Size of input file was changed:"; requiredLevel = 10; break;
+ // case NUpdateNotifyOp::kOpFinished: s = "Finished"; requiredLevel = 100; break;
+ default:
+ {
+ temp[0] = 'o';
+ temp[1] = 'p';
+ ConvertUInt64ToString(op, temp + 2);
+ s = temp;
+ }
+ }
+
+ return PrintProgress(name, isDir, s, LogLevel >= requiredLevel);
+}
+
+/*
+HRESULT CUpdateCallbackConsole::SetPassword(const UString &
+ #ifndef Z7_NO_CRYPTO
+ password
+ #endif
+ )
+{
+ #ifndef Z7_NO_CRYPTO
+ PasswordIsDefined = true;
+ Password = password;
+ #endif
+ return S_OK;
+}
+*/
+
+HRESULT CUpdateCallbackConsole::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
+{
+ COM_TRY_BEGIN
+
+ *password = NULL;
+
+ #ifdef Z7_NO_CRYPTO
+
+ *passwordIsDefined = false;
+ return S_OK;
+
+ #else
+
+ if (!PasswordIsDefined)
+ {
+ if (AskPassword)
+ {
+ RINOK(GetPassword_HRESULT(_so, Password))
+ PasswordIsDefined = true;
+ }
+ }
+ *passwordIsDefined = BoolToInt(PasswordIsDefined);
+ return StringToBstr(Password, password);
+
+ #endif
+
+ COM_TRY_END
+}
+
+HRESULT CUpdateCallbackConsole::CryptoGetTextPassword(BSTR *password)
+{
+ COM_TRY_BEGIN
+
+ *password = NULL;
+
+ #ifdef Z7_NO_CRYPTO
+
+ return E_NOTIMPL;
+
+ #else
+
+ if (!PasswordIsDefined)
+ {
+ {
+ RINOK(GetPassword_HRESULT(_so, Password))
+ PasswordIsDefined = true;
+ }
+ }
+ return StringToBstr(Password, password);
+
+ #endif
+ COM_TRY_END
+}
+
+HRESULT CUpdateCallbackConsole::ShowDeleteFile(const wchar_t *name, bool isDir)
+{
+ if (StdOutMode)
+ return S_OK;
+
+ if (LogLevel > 7)
+ {
+ if (!name || name[0] == 0)
+ name = kEmptyFileAlias;
+ return PrintProgress(name, isDir, "D", true);
+ }
+ return S_OK;
+}
+
+/*
+void GetPropName(PROPID propID, const wchar_t *name, AString &nameA, UString &nameU);
+
+static void GetPropName(PROPID propID, UString &nameU)
+{
+ AString nameA;
+ GetPropName(propID, NULL, nameA, nameU);
+ // if (!nameA.IsEmpty())
+ nameU = nameA;
+}
+
+
+static void AddPropNamePrefix(UString &s, PROPID propID)
+{
+ UString name;
+ GetPropName(propID, name);
+ s += name;
+ s += " = ";
+}
+
+void CCallbackConsoleBase::PrintPropInfo(UString &s, PROPID propID, const PROPVARIANT *value)
+{
+ AddPropNamePrefix(s, propID);
+ {
+ UString dest;
+ const int level = 9; // we show up to ns precision level
+ ConvertPropertyToString2(dest, *value, propID, level);
+ s += dest;
+ }
+ PrintInfoLine(s);
+}
+
+static void Add_IndexType_Index(UString &s, UInt32 indexType, UInt32 index)
+{
+ if (indexType == NArchive::NEventIndexType::kArcProp)
+ {
+ }
+ else
+ {
+ if (indexType == NArchive::NEventIndexType::kBlockIndex)
+ {
+ s += "#";
+ }
+ else if (indexType == NArchive::NEventIndexType::kOutArcIndex)
+ {
+ }
+ else
+ {
+ s += "indexType_";
+ s.Add_UInt32(indexType);
+ s.Add_Space();
+ }
+ s.Add_UInt32(index);
+ }
+ s += ": ";
+}
+
+HRESULT CUpdateCallbackConsole::ReportProp(UInt32 indexType, UInt32 index, PROPID propID, const PROPVARIANT *value)
+{
+ UString s;
+ Add_IndexType_Index(s, indexType, index);
+ PrintPropInfo(s, propID, value);
+ return S_OK;
+}
+
+static inline char GetHex(Byte value)
+{
+ return (char)((value < 10) ? ('0' + value) : ('a' + (value - 10)));
+}
+
+static void AddHexToString(UString &dest, const Byte *data, UInt32 size)
+{
+ for (UInt32 i = 0; i < size; i++)
+ {
+ Byte b = data[i];
+ dest += GetHex((Byte)((b >> 4) & 0xF));
+ dest += GetHex((Byte)(b & 0xF));
+ }
+}
+
+void HashHexToString(char *dest, const Byte *data, UInt32 size);
+
+HRESULT CUpdateCallbackConsole::ReportRawProp(UInt32 indexType, UInt32 index,
+ PROPID propID, const void *data, UInt32 dataSize, UInt32 propType)
+{
+ UString s;
+ propType = propType;
+ Add_IndexType_Index(s, indexType, index);
+ AddPropNamePrefix(s, propID);
+ if (propID == kpidChecksum)
+ {
+ char temp[k_HashCalc_DigestSize_Max + 8];
+ HashHexToString(temp, (const Byte *)data, dataSize);
+ s += temp;
+ }
+ else
+ AddHexToString(s, (const Byte *)data, dataSize);
+ PrintInfoLine(s);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackConsole::ReportFinished(UInt32 indexType, UInt32 index, Int32 opRes)
+{
+ UString s;
+ Add_IndexType_Index(s, indexType, index);
+ s += "finished";
+ if (opRes != NArchive::NUpdate::NOperationResult::kOK)
+ {
+ s += ": ";
+ s.Add_UInt32(opRes);
+ }
+ PrintInfoLine(s);
+ return S_OK;
+}
+*/
diff --git a/CPP/7zip/UI/Console/UpdateCallbackConsole.h b/CPP/7zip/UI/Console/UpdateCallbackConsole.h
index 6765db6..b6c1be4 100644
--- a/CPP/7zip/UI/Console/UpdateCallbackConsole.h
+++ b/CPP/7zip/UI/Console/UpdateCallbackConsole.h
@@ -1,124 +1,133 @@
-// UpdateCallbackConsole.h
-
-#ifndef __UPDATE_CALLBACK_CONSOLE_H
-#define __UPDATE_CALLBACK_CONSOLE_H
-
-#include "../../../Common/StdOutStream.h"
-
-#include "../Common/Update.h"
-
-#include "PercentPrinter.h"
-
-struct CErrorPathCodes
-{
- FStringVector Paths;
- CRecordVector<DWORD> Codes;
-
- void AddError(const FString &path, DWORD systemError)
- {
- Paths.Add(path);
- Codes.Add(systemError);
- }
- void Clear()
- {
- Paths.Clear();
- Codes.Clear();
- }
-};
-
-class CCallbackConsoleBase
-{
-protected:
- CPercentPrinter _percent;
-
- CStdOutStream *_so;
- CStdOutStream *_se;
-
- void CommonError(const FString &path, DWORD systemError, bool isWarning);
-
- HRESULT ScanError_Base(const FString &path, DWORD systemError);
- HRESULT OpenFileError_Base(const FString &name, DWORD systemError);
- HRESULT ReadingFileError_Base(const FString &name, DWORD systemError);
-
-public:
- bool NeedPercents() const { return _percent._so != NULL; };
-
- bool StdOutMode;
-
- bool NeedFlush;
- unsigned PercentsNameLevel;
- unsigned LogLevel;
-
- AString _tempA;
- UString _tempU;
-
- CCallbackConsoleBase():
- StdOutMode(false),
- NeedFlush(false),
- PercentsNameLevel(1),
- LogLevel(0)
- {}
-
- void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
-
- void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
- {
- FailedFiles.Clear();
-
- _so = outStream;
- _se = errorStream;
- _percent._so = percentStream;
- }
-
- void ClosePercents2()
- {
- if (NeedPercents())
- _percent.ClosePrint(true);
- }
-
- void ClosePercents_for_so()
- {
- if (NeedPercents() && _so == _percent._so)
- _percent.ClosePrint(false);
- }
-
-
- CErrorPathCodes FailedFiles;
- CErrorPathCodes ScanErrors;
-
- HRESULT PrintProgress(const wchar_t *name, const char *command, bool showInLog);
-
-};
-
-class CUpdateCallbackConsole: public IUpdateCallbackUI2, public CCallbackConsoleBase
-{
- // void PrintPropPair(const char *name, const wchar_t *val);
-
-public:
- #ifndef _NO_CRYPTO
- bool PasswordIsDefined;
- UString Password;
- bool AskPassword;
- #endif
-
- bool DeleteMessageWasShown;
-
- CUpdateCallbackConsole()
- : DeleteMessageWasShown(false)
- #ifndef _NO_CRYPTO
- , PasswordIsDefined(false)
- , AskPassword(false)
- #endif
- {}
-
- /*
- void Init(CStdOutStream *outStream)
- {
- CCallbackConsoleBase::Init(outStream);
- }
- */
- // ~CUpdateCallbackConsole() { if (NeedPercents()) _percent.ClosePrint(); }
- INTERFACE_IUpdateCallbackUI2(;)
-};
-
-#endif
+// UpdateCallbackConsole.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK_CONSOLE_H
+#define ZIP7_INC_UPDATE_CALLBACK_CONSOLE_H
+
+#include "../../../Common/StdOutStream.h"
+
+#include "../Common/Update.h"
+
+#include "PercentPrinter.h"
+
+struct CErrorPathCodes
+{
+ FStringVector Paths;
+ CRecordVector<DWORD> Codes;
+
+ void AddError(const FString &path, DWORD systemError)
+ {
+ Paths.Add(path);
+ Codes.Add(systemError);
+ }
+ void Clear()
+ {
+ Paths.Clear();
+ Codes.Clear();
+ }
+};
+
+
+class CCallbackConsoleBase
+{
+protected:
+ CPercentPrinter _percent;
+
+ CStdOutStream *_so;
+ CStdOutStream *_se;
+
+ void CommonError(const FString &path, DWORD systemError, bool isWarning);
+ // void CommonError(const char *message);
+
+ HRESULT ScanError_Base(const FString &path, DWORD systemError);
+ HRESULT OpenFileError_Base(const FString &name, DWORD systemError);
+ HRESULT ReadingFileError_Base(const FString &name, DWORD systemError);
+
+public:
+ bool NeedPercents() const { return _percent._so != NULL; }
+
+ bool StdOutMode;
+
+ bool NeedFlush;
+ unsigned PercentsNameLevel;
+ unsigned LogLevel;
+
+ AString _tempA;
+ UString _tempU;
+
+ CCallbackConsoleBase():
+ StdOutMode(false),
+ NeedFlush(false),
+ PercentsNameLevel(1),
+ LogLevel(0),
+ NumNonOpenFiles(0)
+ {}
+
+ void SetWindowWidth(unsigned width) { _percent.MaxLen = width - 1; }
+
+ void Init(CStdOutStream *outStream, CStdOutStream *errorStream, CStdOutStream *percentStream)
+ {
+ FailedFiles.Clear();
+
+ _so = outStream;
+ _se = errorStream;
+ _percent._so = percentStream;
+ }
+
+ void ClosePercents2()
+ {
+ if (NeedPercents())
+ _percent.ClosePrint(true);
+ }
+
+ void ClosePercents_for_so()
+ {
+ if (NeedPercents() && _so == _percent._so)
+ _percent.ClosePrint(false);
+ }
+
+ CErrorPathCodes FailedFiles;
+ CErrorPathCodes ScanErrors;
+ UInt64 NumNonOpenFiles;
+
+ HRESULT PrintProgress(const wchar_t *name, bool isDir, const char *command, bool showInLog);
+
+ // void PrintInfoLine(const UString &s);
+ // void PrintPropInfo(UString &s, PROPID propID, const PROPVARIANT *value);
+};
+
+
+class CUpdateCallbackConsole Z7_final:
+ public IUpdateCallbackUI2,
+ public CCallbackConsoleBase
+{
+ // void PrintPropPair(const char *name, const wchar_t *val);
+ Z7_IFACE_IMP(IUpdateCallbackUI)
+ Z7_IFACE_IMP(IDirItemsCallback)
+ Z7_IFACE_IMP(IUpdateCallbackUI2)
+public:
+ bool DeleteMessageWasShown;
+
+ #ifndef Z7_NO_CRYPTO
+ bool PasswordIsDefined;
+ bool AskPassword;
+ UString Password;
+ #endif
+
+ CUpdateCallbackConsole():
+ DeleteMessageWasShown(false)
+ #ifndef Z7_NO_CRYPTO
+ , PasswordIsDefined(false)
+ , AskPassword(false)
+ #endif
+ {}
+
+ /*
+ void Init(CStdOutStream *outStream)
+ {
+ CCallbackConsoleBase::Init(outStream);
+ }
+ */
+ // ~CUpdateCallbackConsole() { if (NeedPercents()) _percent.ClosePrint(); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/Console/UserInputUtils.cpp b/CPP/7zip/UI/Console/UserInputUtils.cpp
index 7bdafda..04d675e 100644
--- a/CPP/7zip/UI/Console/UserInputUtils.cpp
+++ b/CPP/7zip/UI/Console/UserInputUtils.cpp
@@ -1,110 +1,117 @@
-// UserInputUtils.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/StdInStream.h"
-#include "../../../Common/StringConvert.h"
-
-#include "UserInputUtils.h"
-
-static const char kYes = 'y';
-static const char kNo = 'n';
-static const char kYesAll = 'a';
-static const char kNoAll = 's';
-static const char kAutoRenameAll = 'u';
-static const char kQuit = 'q';
-
-static const char * const kFirstQuestionMessage = "? ";
-static const char * const kHelpQuestionMessage =
- "(Y)es / (N)o / (A)lways / (S)kip all / A(u)to rename all / (Q)uit? ";
-
-// return true if pressed Quite;
-
-NUserAnswerMode::EEnum ScanUserYesNoAllQuit(CStdOutStream *outStream)
-{
- if (outStream)
- *outStream << kFirstQuestionMessage;
- for (;;)
- {
- if (outStream)
- {
- *outStream << kHelpQuestionMessage;
- outStream->Flush();
- }
- AString scannedString;
- if (!g_StdIn.ScanAStringUntilNewLine(scannedString))
- return NUserAnswerMode::kError;
- if (g_StdIn.Error())
- return NUserAnswerMode::kError;
- scannedString.Trim();
- if (scannedString.IsEmpty() && g_StdIn.Eof())
- return NUserAnswerMode::kEof;
-
- if (scannedString.Len() == 1)
- switch (::MyCharLower_Ascii(scannedString[0]))
- {
- case kYes: return NUserAnswerMode::kYes;
- case kNo: return NUserAnswerMode::kNo;
- case kYesAll: return NUserAnswerMode::kYesAll;
- case kNoAll: return NUserAnswerMode::kNoAll;
- case kAutoRenameAll: return NUserAnswerMode::kAutoRenameAll;
- case kQuit: return NUserAnswerMode::kQuit;
- }
- }
-}
-
-#ifdef _WIN32
-#ifndef UNDER_CE
-#define MY_DISABLE_ECHO
-#endif
-#endif
-
-static bool GetPassword(CStdOutStream *outStream, UString &psw)
-{
- if (outStream)
- {
- *outStream << "\nEnter password"
- #ifdef MY_DISABLE_ECHO
- " (will not be echoed)"
- #endif
- ":";
- outStream->Flush();
- }
-
- #ifdef MY_DISABLE_ECHO
-
- HANDLE console = GetStdHandle(STD_INPUT_HANDLE);
- bool wasChanged = false;
- DWORD mode = 0;
- if (console != INVALID_HANDLE_VALUE && console != 0)
- if (GetConsoleMode(console, &mode))
- wasChanged = (SetConsoleMode(console, mode & ~ENABLE_ECHO_INPUT) != 0);
- bool res = g_StdIn.ScanUStringUntilNewLine(psw);
- if (wasChanged)
- SetConsoleMode(console, mode);
-
- #else
-
- bool res = g_StdIn.ScanUStringUntilNewLine(psw);
-
- #endif
-
- if (outStream)
- {
- *outStream << endl;
- outStream->Flush();
- }
-
- return res;
-}
-
-HRESULT GetPassword_HRESULT(CStdOutStream *outStream, UString &psw)
-{
- if (!GetPassword(outStream, psw))
- return E_INVALIDARG;
- if (g_StdIn.Error())
- return E_FAIL;
- if (g_StdIn.Eof() && psw.IsEmpty())
- return E_ABORT;
- return S_OK;
-}
+// UserInputUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StdInStream.h"
+#include "../../../Common/StringConvert.h"
+
+#include "UserInputUtils.h"
+
+static const char kYes = 'y';
+static const char kNo = 'n';
+static const char kYesAll = 'a';
+static const char kNoAll = 's';
+static const char kAutoRenameAll = 'u';
+static const char kQuit = 'q';
+
+static const char * const kFirstQuestionMessage = "? ";
+static const char * const kHelpQuestionMessage =
+ "(Y)es / (N)o / (A)lways / (S)kip all / A(u)to rename all / (Q)uit? ";
+
+// return true if pressed Quite;
+
+NUserAnswerMode::EEnum ScanUserYesNoAllQuit(CStdOutStream *outStream)
+{
+ if (outStream)
+ *outStream << kFirstQuestionMessage;
+ for (;;)
+ {
+ if (outStream)
+ {
+ *outStream << kHelpQuestionMessage;
+ outStream->Flush();
+ }
+ AString scannedString;
+ if (!g_StdIn.ScanAStringUntilNewLine(scannedString))
+ return NUserAnswerMode::kError;
+ if (g_StdIn.Error())
+ return NUserAnswerMode::kError;
+ scannedString.Trim();
+ if (scannedString.IsEmpty() && g_StdIn.Eof())
+ return NUserAnswerMode::kEof;
+
+ if (scannedString.Len() == 1)
+ switch (::MyCharLower_Ascii(scannedString[0]))
+ {
+ case kYes: return NUserAnswerMode::kYes;
+ case kNo: return NUserAnswerMode::kNo;
+ case kYesAll: return NUserAnswerMode::kYesAll;
+ case kNoAll: return NUserAnswerMode::kNoAll;
+ case kAutoRenameAll: return NUserAnswerMode::kAutoRenameAll;
+ case kQuit: return NUserAnswerMode::kQuit;
+ }
+ }
+}
+
+#ifdef _WIN32
+#ifndef UNDER_CE
+#define MY_DISABLE_ECHO
+#endif
+#endif
+
+static bool GetPassword(CStdOutStream *outStream, UString &psw)
+{
+ if (outStream)
+ {
+ *outStream << "\nEnter password"
+ #ifdef MY_DISABLE_ECHO
+ " (will not be echoed)"
+ #endif
+ ":";
+ outStream->Flush();
+ }
+
+ #ifdef MY_DISABLE_ECHO
+
+ const HANDLE console = GetStdHandle(STD_INPUT_HANDLE);
+
+ /*
+ GetStdHandle() returns
+ INVALID_HANDLE_VALUE: If the function fails.
+ NULL : If an application does not have associated standard handles,
+ such as a service running on an interactive desktop,
+ and has not redirected them. */
+ bool wasChanged = false;
+ DWORD mode = 0;
+ if (console != INVALID_HANDLE_VALUE && console != NULL)
+ if (GetConsoleMode(console, &mode))
+ wasChanged = (SetConsoleMode(console, mode & ~(DWORD)ENABLE_ECHO_INPUT) != 0);
+ const bool res = g_StdIn.ScanUStringUntilNewLine(psw);
+ if (wasChanged)
+ SetConsoleMode(console, mode);
+
+ #else
+
+ const bool res = g_StdIn.ScanUStringUntilNewLine(psw);
+
+ #endif
+
+ if (outStream)
+ {
+ *outStream << endl;
+ outStream->Flush();
+ }
+
+ return res;
+}
+
+HRESULT GetPassword_HRESULT(CStdOutStream *outStream, UString &psw)
+{
+ if (!GetPassword(outStream, psw))
+ return E_INVALIDARG;
+ if (g_StdIn.Error())
+ return E_FAIL;
+ if (g_StdIn.Eof() && psw.IsEmpty())
+ return E_ABORT;
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Console/UserInputUtils.h b/CPP/7zip/UI/Console/UserInputUtils.h
index ebe09c1..695a3e6 100644
--- a/CPP/7zip/UI/Console/UserInputUtils.h
+++ b/CPP/7zip/UI/Console/UserInputUtils.h
@@ -1,27 +1,27 @@
-// UserInputUtils.h
-
-#ifndef __USER_INPUT_UTILS_H
-#define __USER_INPUT_UTILS_H
-
-#include "../../../Common/StdOutStream.h"
-
-namespace NUserAnswerMode {
-
-enum EEnum
-{
- kYes,
- kNo,
- kYesAll,
- kNoAll,
- kAutoRenameAll,
- kQuit,
- kEof,
- kError
-};
-}
-
-NUserAnswerMode::EEnum ScanUserYesNoAllQuit(CStdOutStream *outStream);
-// bool GetPassword(CStdOutStream *outStream, UString &psw);
-HRESULT GetPassword_HRESULT(CStdOutStream *outStream, UString &psw);
-
-#endif
+// UserInputUtils.h
+
+#ifndef ZIP7_INC_USER_INPUT_UTILS_H
+#define ZIP7_INC_USER_INPUT_UTILS_H
+
+#include "../../../Common/StdOutStream.h"
+
+namespace NUserAnswerMode {
+
+enum EEnum
+{
+ kYes,
+ kNo,
+ kYesAll,
+ kNoAll,
+ kAutoRenameAll,
+ kQuit,
+ kEof,
+ kError
+};
+}
+
+NUserAnswerMode::EEnum ScanUserYesNoAllQuit(CStdOutStream *outStream);
+// bool GetPassword(CStdOutStream *outStream, UString &psw);
+HRESULT GetPassword_HRESULT(CStdOutStream *outStream, UString &psw);
+
+#endif
diff --git a/CPP/7zip/UI/Console/makefile b/CPP/7zip/UI/Console/makefile
index 2210e0b..a20b0cc 100644
--- a/CPP/7zip/UI/Console/makefile
+++ b/CPP/7zip/UI/Console/makefile
@@ -1,64 +1,68 @@
-PROG = 7z.exe
-CFLAGS = $(CFLAGS) \
- -DEXTERNAL_CODECS \
-
-COMMON_OBJS = \
- $O\CommandLineParser.obj \
- $O\CRC.obj \
- $O\IntToString.obj \
- $O\ListFileUtils.obj \
- $O\NewHandler.obj \
- $O\StdInStream.obj \
- $O\StdOutStream.obj \
- $O\MyString.obj \
- $O\StringConvert.obj \
- $O\StringToInt.obj \
- $O\UTFConvert.obj \
- $O\MyVector.obj \
- $O\Wildcard.obj \
-
-WIN_OBJS = \
- $O\DLL.obj \
- $O\ErrorMsg.obj \
- $O\FileDir.obj \
- $O\FileFind.obj \
- $O\FileIO.obj \
- $O\FileLink.obj \
- $O\FileName.obj \
- $O\FileSystem.obj \
- $O\MemoryLock.obj \
- $O\PropVariant.obj \
- $O\PropVariantConv.obj \
- $O\Registry.obj \
- $O\System.obj \
- $O\TimeUtils.obj \
-
-7ZIP_COMMON_OBJS = \
- $O\CreateCoder.obj \
- $O\FilePathAutoRename.obj \
- $O\FileStreams.obj \
- $O\FilterCoder.obj \
- $O\LimitedStreams.obj \
- $O\MethodProps.obj \
- $O\ProgressUtils.obj \
- $O\PropId.obj \
- $O\StreamObjects.obj \
- $O\StreamUtils.obj \
- $O\UniqBlocks.obj \
-
-AR_COMMON_OBJS = \
- $O\OutStreamWithCRC.obj \
-
-COMPRESS_OBJS = \
- $O\CopyCoder.obj \
-
-C_OBJS = $(C_OBJS) \
- $O\Alloc.obj \
- $O\CpuArch.obj \
- $O\Sort.obj \
- $O\Threads.obj \
-
-!include "../../Crc.mak"
-!include "Console.mak"
-
-!include "../../7zip.mak"
+PROG = 7z.exe
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTERNAL_CODECS \
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\ListFileUtils.obj \
+ $O\NewHandler.obj \
+ $O\StdInStream.obj \
+ $O\StdOutStream.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\MyVector.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileLink.obj \
+ $O\FileName.obj \
+ $O\FileSystem.obj \
+ $O\MemoryLock.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\Registry.obj \
+ $O\System.obj \
+ $O\SystemInfo.obj \
+ $O\TimeUtils.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodProps.obj \
+ $O\MultiOutStream.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+
+AR_COMMON_OBJS = \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+
+COMPRESS_OBJS = \
+ $O\CopyCoder.obj \
+
+C_OBJS = $(C_OBJS) \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\Sort.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+!include "Console.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Console/makefile.gcc b/CPP/7zip/UI/Console/makefile.gcc
new file mode 100644
index 0000000..8a293d8
--- /dev/null
+++ b/CPP/7zip/UI/Console/makefile.gcc
@@ -0,0 +1,186 @@
+PROG = 7z
+IS_NOT_STANDALONE = 1
+
+# IS_X64 = 1
+# USE_ASM = 1
+# ST_MODE = 1
+
+
+LOCAL_FLAGS_ST =
+MT_OBJS =
+
+ifdef SystemDrive
+IS_MINGW = 1
+else
+ifdef SYSTEMDRIVE
+# ifdef OS
+IS_MINGW = 1
+endif
+endif
+
+ifdef ST_MODE
+
+LOCAL_FLAGS_ST = -DZ7_ST
+
+ifdef IS_MINGW
+MT_OBJS = \
+ $O/Threads.o \
+
+endif
+
+else
+
+MT_OBJS = \
+ $O/Synchronization.o \
+ $O/Threads.o \
+
+endif
+
+
+
+LOCAL_FLAGS_WIN=
+
+ifdef IS_MINGW
+
+LOCAL_FLAGS_WIN = \
+ -DZ7_LARGE_PAGES \
+ -DZ7_LONG_PATH \
+ -DZ7_DEVICE_FILE \
+
+SYS_OBJS = \
+ $O/FileSystem.o \
+ $O/Registry.o \
+ $O/MemoryLock.o \
+ $O/DllSecur.o \
+ $O/resource.o \
+
+else
+
+SYS_OBJS = \
+ $O/MyWindows.o \
+
+endif
+
+
+
+LOCAL_FLAGS = \
+ $(LOCAL_FLAGS_WIN) \
+ $(LOCAL_FLAGS_ST) \
+ -DZ7_EXTERNAL_CODECS \
+
+
+
+CONSOLE_OBJS = \
+ $O/BenchCon.o \
+ $O/ConsoleClose.o \
+ $O/ExtractCallbackConsole.o \
+ $O/HashCon.o \
+ $O/List.o \
+ $O/Main.o \
+ $O/MainAr.o \
+ $O/OpenCallbackConsole.o \
+ $O/PercentPrinter.o \
+ $O/UpdateCallbackConsole.o \
+ $O/UserInputUtils.o \
+
+UI_COMMON_OBJS = \
+ $O/ArchiveCommandLine.o \
+ $O/ArchiveExtractCallback.o \
+ $O/ArchiveOpenCallback.o \
+ $O/Bench.o \
+ $O/DefaultName.o \
+ $O/EnumDirItems.o \
+ $O/Extract.o \
+ $O/ExtractingFilePath.o \
+ $O/HashCalc.o \
+ $O/LoadCodecs.o \
+ $O/OpenArchive.o \
+ $O/PropIDUtils.o \
+ $O/SetProperties.o \
+ $O/SortUtils.o \
+ $O/TempFiles.o \
+ $O/Update.o \
+ $O/UpdateAction.o \
+ $O/UpdateCallback.o \
+ $O/UpdatePair.o \
+ $O/UpdateProduce.o \
+
+COMMON_OBJS = \
+ $O/CommandLineParser.o \
+ $O/CRC.o \
+ $O/CrcReg.o \
+ $O/DynLimBuf.o \
+ $O/IntToString.o \
+ $O/ListFileUtils.o \
+ $O/NewHandler.o \
+ $O/StdInStream.o \
+ $O/StdOutStream.o \
+ $O/MyString.o \
+ $O/StringConvert.o \
+ $O/StringToInt.o \
+ $O/UTFConvert.o \
+ $O/MyVector.o \
+ $O/Wildcard.o \
+
+WIN_OBJS = \
+ $O/DLL.o \
+ $O/ErrorMsg.o \
+ $O/FileDir.o \
+ $O/FileFind.o \
+ $O/FileIO.o \
+ $O/FileLink.o \
+ $O/FileName.o \
+ $O/PropVariant.o \
+ $O/PropVariantConv.o \
+ $O/System.o \
+ $O/SystemInfo.o \
+ $O/TimeUtils.o \
+
+7ZIP_COMMON_OBJS = \
+ $O/CreateCoder.o \
+ $O/CWrappers.o \
+ $O/FilePathAutoRename.o \
+ $O/FileStreams.o \
+ $O/InBuffer.o \
+ $O/InOutTempBuffer.o \
+ $O/FilterCoder.o \
+ $O/LimitedStreams.o \
+ $O/MethodId.o \
+ $O/MethodProps.o \
+ $O/MultiOutStream.o \
+ $O/OffsetStream.o \
+ $O/OutBuffer.o \
+ $O/ProgressUtils.o \
+ $O/PropId.o \
+ $O/StreamObjects.o \
+ $O/StreamUtils.o \
+ $O/UniqBlocks.o \
+
+COMPRESS_OBJS = \
+ $O/CopyCoder.o \
+
+AR_COMMON_OBJS = \
+ $O/ItemNameUtils.o \
+
+C_OBJS = \
+ $O/Alloc.o \
+ $O/CpuArch.o \
+ $O/Sort.o \
+ $O/7zCrc.o \
+ $O/7zCrcOpt.o \
+
+
+OBJS = \
+ $(C_OBJS) \
+ $(MT_OBJS) \
+ $(COMMON_OBJS) \
+ $(WIN_OBJS) \
+ $(SYS_OBJS) \
+ $(COMPRESS_OBJS) \
+ $(AR_COMMON_OBJS) \
+ $(7ZIP_COMMON_OBJS) \
+ $(UI_COMMON_OBJS) \
+ $(CONSOLE_OBJS) \
+
+
+include ../../7zip_gcc.mak
diff --git a/CPP/7zip/UI/Console/resource.rc b/CPP/7zip/UI/Console/resource.rc
index 8d721f5..414427f 100644
--- a/CPP/7zip/UI/Console/resource.rc
+++ b/CPP/7zip/UI/Console/resource.rc
@@ -1,7 +1,7 @@
-#include "../../MyVersionInfo.rc"
-
-MY_VERSION_INFO_APP("7-Zip Console" , "7z")
-
-#ifndef UNDER_CE
-1 24 MOVEABLE PURE "Console.manifest"
-#endif
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_APP("7-Zip Console" , "7z")
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "Console.manifest"
+#endif
diff --git a/CPP/7zip/UI/Explorer/7-zip.dll.manifest b/CPP/7zip/UI/Explorer/7-zip.dll.manifest
new file mode 100644
index 0000000..cba1c5d
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/7-zip.dll.manifest
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?><assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"><assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7-Zip.7-Zip.7-zip" type="win32"/><description>7-Zip Extension.</description><dependency> <dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/></dependentAssembly></dependency></assembly>
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.cpp b/CPP/7zip/UI/Explorer/ContextMenu.cpp
new file mode 100644
index 0000000..7815e13
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/ContextMenu.cpp
@@ -0,0 +1,1822 @@
+// ContextMenu.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/COM.h"
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/ProcessUtils.h"
+
+// for IS_INTRESOURCE():
+#include "../../../Windows/Window.h"
+
+#include "../../PropID.h"
+
+#include "../Common/ArchiveName.h"
+#include "../Common/CompressCall.h"
+#include "../Common/ExtractingFilePath.h"
+#include "../Common/ZipRegistry.h"
+
+#include "../FileManager/FormatUtils.h"
+#include "../FileManager/LangUtils.h"
+#include "../FileManager/PropertyName.h"
+
+#include "ContextMenu.h"
+#include "ContextMenuFlags.h"
+#include "MyMessages.h"
+
+#include "resource.h"
+
+
+// #define SHOW_DEBUG_CTX_MENU
+
+#ifdef SHOW_DEBUG_CTX_MENU
+#include <stdio.h>
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+#ifndef UNDER_CE
+#define EMAIL_SUPPORT 1
+#endif
+
+extern LONG g_DllRefCount;
+
+#ifdef _WIN32
+extern HINSTANCE g_hInstance;
+#endif
+
+#ifdef UNDER_CE
+ #define MY_IS_INTRESOURCE(_r) ((((ULONG_PTR)(_r)) >> 16) == 0)
+#else
+ #define MY_IS_INTRESOURCE(_r) IS_INTRESOURCE(_r)
+#endif
+
+
+#ifdef SHOW_DEBUG_CTX_MENU
+
+static void PrintStringA(const char *name, LPCSTR ptr)
+{
+ AString m;
+ m += name;
+ m += ": ";
+ char s[32];
+ sprintf(s, "%p", (const void *)ptr);
+ m += s;
+ if (!MY_IS_INTRESOURCE(ptr))
+ {
+ m += ": \"";
+ m += ptr;
+ m += "\"";
+ }
+ OutputDebugStringA(m);
+}
+
+#if !defined(UNDER_CE)
+static void PrintStringW(const char *name, LPCWSTR ptr)
+{
+ UString m;
+ m += name;
+ m += ": ";
+ char s[32];
+ sprintf(s, "%p", (const void *)ptr);
+ m += s;
+ if (!MY_IS_INTRESOURCE(ptr))
+ {
+ m += ": \"";
+ m += ptr;
+ m += "\"";
+ }
+ OutputDebugStringW(m);
+}
+#endif
+
+static void Print_Ptr(const void *p, const char *s)
+{
+ char temp[32];
+ sprintf(temp, "%p", (const void *)p);
+ AString m;
+ m += temp;
+ m.Add_Space();
+ m += s;
+ OutputDebugStringA(m);
+}
+
+static void Print_Number(UInt32 number, const char *s)
+{
+ AString m;
+ m.Add_UInt32(number);
+ m.Add_Space();
+ m += s;
+ OutputDebugStringA(m);
+}
+
+#define ODS(sz) { Print_Ptr(this, sz); }
+#define ODS_U(s) { OutputDebugStringW(s); }
+#define ODS_(op) { op; }
+#define ODS_SPRF_s(x) { char s[256]; x; OutputDebugStringA(s); }
+
+#else
+
+#define ODS(sz)
+#define ODS_U(s)
+#define ODS_(op)
+#define ODS_SPRF_s(x)
+
+#endif
+
+
+/*
+DOCs: In Windows 7 and later, the number of items passed to
+ a verb is limited to 16 when a shortcut menu is queried.
+ The verb is then re-created and re-initialized with the full
+ selection when that verb is invoked.
+win10 tests:
+ if (the number of selected file/dir objects > 16)
+ {
+ Explorer does the following actions:
+ - it creates ctx_menu_1 IContextMenu object
+ - it calls ctx_menu_1->Initialize() with list of only up to 16 items
+ - it calls ctx_menu_1->QueryContextMenu(menu_1)
+ - if (some menu command is pressed)
+ {
+ - it gets shown string from selected menu item : shown_menu_1_string
+ - it creates another ctx_menu_2 IContextMenu object
+ - it calls ctx_menu_2->Initialize() with list of all items
+ - it calls ctx_menu_2->QueryContextMenu(menu_2)
+ - if there is menu item with shown_menu_1_string string in menu_2,
+ Explorer calls ctx_menu_2->InvokeCommand() for that item.
+ Explorer probably doesn't use VERB from first object ctx_menu_1.
+ So we must provide same shown menu strings for both objects:
+ ctx_menu_1 and ctx_menu_2.
+ }
+ }
+*/
+
+
+CZipContextMenu::CZipContextMenu():
+ _isMenuForFM(true),
+ _fileNames_WereReduced(true),
+ _dropMode(false),
+ _bitmap(NULL),
+ _writeZone((UInt32)(Int32)-1),
+ IsSeparator(false),
+ IsRoot(true),
+ CurrentSubCommand(0)
+{
+ ODS("== CZipContextMenu()");
+ InterlockedIncrement(&g_DllRefCount);
+}
+
+CZipContextMenu::~CZipContextMenu()
+{
+ ODS("== ~CZipContextMenu");
+ if (_bitmap)
+ DeleteObject(_bitmap);
+ InterlockedDecrement(&g_DllRefCount);
+}
+
+// IShellExtInit
+
+/*
+IShellExtInit::Initialize()
+ pidlFolder:
+ - for property sheet extension:
+ NULL
+ - for shortcut menu extensions:
+ pidl of folder that contains the item whose shortcut menu is being displayed:
+ - for nondefault drag-and-drop menu extensions:
+ pidl of target folder: for nondefault drag-and-drop menu extensions
+ pidlFolder == NULL in (win10): for context menu
+*/
+
+Z7_COMWF_B CZipContextMenu::Initialize(LPCITEMIDLIST pidlFolder, LPDATAOBJECT dataObject, HKEY /* hkeyProgID */)
+{
+ COM_TRY_BEGIN
+ ODS("==== CZipContextMenu::Initialize START")
+ _isMenuForFM = false;
+ _fileNames_WereReduced = true;
+ _dropMode = false;
+ _attribs.Clear();
+ _fileNames.Clear();
+ _dropPath.Empty();
+
+ if (pidlFolder)
+ {
+ ODS("==== CZipContextMenu::Initialize (pidlFolder != 0)")
+ #ifndef UNDER_CE
+ if (NShell::GetPathFromIDList(pidlFolder, _dropPath))
+ {
+ ODS("==== CZipContextMenu::Initialize path from (pidl):")
+ ODS_U(_dropPath);
+ /* win10 : path with "\\\\?\\\" prefix is returned by GetPathFromIDList, if path is long
+ we can remove super prefix here. But probably prefix
+ is not problem for following 7-zip code.
+ so we don't remove super prefix */
+ NFile::NName::If_IsSuperPath_RemoveSuperPrefix(_dropPath);
+ NName::NormalizeDirPathPrefix(_dropPath);
+ _dropMode = !_dropPath.IsEmpty();
+ }
+ else
+ #endif
+ _dropPath.Empty();
+ }
+
+ if (!dataObject)
+ return E_INVALIDARG;
+
+ #ifndef UNDER_CE
+
+ RINOK(NShell::DataObject_GetData_HDROP_or_IDLIST_Names(dataObject, _fileNames))
+ // for (unsigned y = 0; y < 10000; y++)
+ if (NShell::DataObject_GetData_FILE_ATTRS(dataObject, _attribs) != S_OK)
+ _attribs.Clear();
+
+ #endif
+
+ ODS_SPRF_s(sprintf(s, "==== CZipContextMenu::Initialize END _files=%d",
+ _fileNames.Size()))
+
+ return S_OK;
+ COM_TRY_END
+}
+
+
+/////////////////////////////
+// IContextMenu
+
+static LPCSTR const kMainVerb = "SevenZip";
+static LPCSTR const kOpenCascadedVerb = "SevenZip.OpenWithType.";
+static LPCSTR const kCheckSumCascadedVerb = "SevenZip.Checksum";
+
+
+struct CContextMenuCommand
+{
+ UInt32 flag;
+ CZipContextMenu::enum_CommandInternalID CommandInternalID;
+ LPCSTR Verb;
+ UINT ResourceID;
+};
+
+#define CMD_REC(cns, verb, ids) { NContextMenuFlags::cns, CZipContextMenu::cns, verb, ids }
+
+static const CContextMenuCommand g_Commands[] =
+{
+ CMD_REC( kOpen, "Open", IDS_CONTEXT_OPEN),
+ CMD_REC( kExtract, "Extract", IDS_CONTEXT_EXTRACT),
+ CMD_REC( kExtractHere, "ExtractHere", IDS_CONTEXT_EXTRACT_HERE),
+ CMD_REC( kExtractTo, "ExtractTo", IDS_CONTEXT_EXTRACT_TO),
+ CMD_REC( kTest, "Test", IDS_CONTEXT_TEST),
+ CMD_REC( kCompress, "Compress", IDS_CONTEXT_COMPRESS),
+ CMD_REC( kCompressEmail, "CompressEmail", IDS_CONTEXT_COMPRESS_EMAIL),
+ CMD_REC( kCompressTo7z, "CompressTo7z", IDS_CONTEXT_COMPRESS_TO),
+ CMD_REC( kCompressTo7zEmail, "CompressTo7zEmail", IDS_CONTEXT_COMPRESS_TO_EMAIL),
+ CMD_REC( kCompressToZip, "CompressToZip", IDS_CONTEXT_COMPRESS_TO),
+ CMD_REC( kCompressToZipEmail, "CompressToZipEmail", IDS_CONTEXT_COMPRESS_TO_EMAIL)
+};
+
+
+struct CHashCommand
+{
+ CZipContextMenu::enum_CommandInternalID CommandInternalID;
+ LPCSTR UserName;
+ LPCSTR MethodName;
+};
+
+static const CHashCommand g_HashCommands[] =
+{
+ { CZipContextMenu::kHash_CRC32, "CRC-32", "CRC32" },
+ { CZipContextMenu::kHash_CRC64, "CRC-64", "CRC64" },
+ { CZipContextMenu::kHash_SHA1, "SHA-1", "SHA1" },
+ { CZipContextMenu::kHash_SHA256, "SHA-256", "SHA256" },
+ { CZipContextMenu::kHash_All, "*", "*" },
+ { CZipContextMenu::kHash_Generate_SHA256, "SHA-256 -> file.sha256", "SHA256" },
+ { CZipContextMenu::kHash_TestArc, "Checksum : Test", "Hash" }
+};
+
+
+static int FindCommand(CZipContextMenu::enum_CommandInternalID &id)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Commands); i++)
+ if (g_Commands[i].CommandInternalID == id)
+ return (int)i;
+ return -1;
+}
+
+
+void CZipContextMenu::FillCommand(enum_CommandInternalID id, UString &mainString, CCommandMapItem &cmi) const
+{
+ mainString.Empty();
+ const int i = FindCommand(id);
+ if (i < 0)
+ throw 201908;
+ const CContextMenuCommand &command = g_Commands[(unsigned)i];
+ cmi.CommandInternalID = command.CommandInternalID;
+ cmi.Verb = kMainVerb;
+ cmi.Verb += command.Verb;
+ // cmi.HelpString = cmi.Verb;
+ LangString(command.ResourceID, mainString);
+ cmi.UserString = mainString;
+}
+
+
+static UString LangStringAlt(UInt32 id, const char *altString)
+{
+ UString s = LangString(id);
+ if (s.IsEmpty())
+ s = altString;
+ return s;
+}
+
+
+void CZipContextMenu::AddCommand(enum_CommandInternalID id, UString &mainString, CCommandMapItem &cmi)
+{
+ FillCommand(id, mainString, cmi);
+ _commandMap.Add(cmi);
+}
+
+
+
+/*
+note: old msdn article:
+Duplicate Menu Items In the File Menu For a Shell Context Menu Extension (214477)
+----------
+ On systems with Shell32.dll version 4.71 or higher, a context menu extension
+ for a file folder that inserts one or more pop-up menus results in duplicates
+ of these menu items.
+ This occurs when the file menu is activated more than once for the selected object.
+
+CAUSE
+ In a context menu extension, if pop-up menus are inserted using InsertMenu
+ or AppendMenu, then the ID for the pop-up menu item cannot be specified.
+ Instead, this field should take in the HMENU of the pop-up menu.
+ Because the ID is not specified for the pop-up menu item, the Shell does
+ not keep track of the menu item if the file menu is pulled down multiple times.
+ As a result, the pop-up menu items are added multiple times in the context menu.
+
+ This problem occurs only when the file menu is pulled down, and does not happen
+ when the context menu is invoked by using the right button or the context menu key.
+RESOLUTION
+ To work around this problem, use InsertMenuItem and specify the ID of the
+ pop-up menu item in the wID member of the MENUITEMINFO structure.
+*/
+
+static void MyInsertMenu(CMenu &menu, unsigned pos, UINT id, const UString &s, HBITMAP bitmap)
+{
+ if (!menu)
+ return;
+ CMenuItem mi;
+ mi.fType = MFT_STRING;
+ mi.fMask = MIIM_TYPE | MIIM_ID;
+ if (bitmap)
+ mi.fMask |= MIIM_CHECKMARKS;
+ mi.wID = id;
+ mi.StringValue = s;
+ mi.hbmpUnchecked = bitmap;
+ // mi.hbmpChecked = bitmap; // do we need hbmpChecked ???
+ if (!menu.InsertItem(pos, true, mi))
+ throw 20190816;
+
+ // SetMenuItemBitmaps also works
+ // ::SetMenuItemBitmaps(menu, pos, MF_BYPOSITION, bitmap, NULL);
+}
+
+
+static void MyAddSubMenu(
+ CObjectVector<CZipContextMenu::CCommandMapItem> &_commandMap,
+ const char *verb,
+ CMenu &menu, unsigned pos, UINT id, const UString &s, HMENU hSubMenu, HBITMAP bitmap)
+{
+ CZipContextMenu::CCommandMapItem cmi;
+ cmi.CommandInternalID = CZipContextMenu::kCommandNULL;
+ cmi.Verb = verb;
+ cmi.IsPopup = true;
+ // cmi.HelpString = verb;
+ cmi.UserString = s;
+ _commandMap.Add(cmi);
+
+ if (!menu)
+ return;
+
+ CMenuItem mi;
+ mi.fType = MFT_STRING;
+ mi.fMask = MIIM_SUBMENU | MIIM_TYPE | MIIM_ID;
+ if (bitmap)
+ mi.fMask |= MIIM_CHECKMARKS;
+ mi.wID = id;
+ mi.hSubMenu = hSubMenu;
+ mi.hbmpUnchecked = bitmap;
+
+ mi.StringValue = s;
+ if (!menu.InsertItem(pos, true, mi))
+ throw 20190817;
+}
+
+
+static const char * const kArcExts[] =
+{
+ "7z"
+ , "bz2"
+ , "gz"
+ , "rar"
+ , "zip"
+};
+
+static bool IsItArcExt(const UString &ext)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kArcExts); i++)
+ if (ext.IsEqualTo_Ascii_NoCase(kArcExts[i]))
+ return true;
+ return false;
+}
+
+UString GetSubFolderNameForExtract(const UString &arcName);
+UString GetSubFolderNameForExtract(const UString &arcName)
+{
+ int dotPos = arcName.ReverseFind_Dot();
+ if (dotPos < 0)
+ return Get_Correct_FsFile_Name(arcName) + L'~';
+
+ const UString ext = arcName.Ptr(dotPos + 1);
+ UString res = arcName.Left(dotPos);
+ res.TrimRight();
+ dotPos = res.ReverseFind_Dot();
+ if (dotPos > 0)
+ {
+ const UString ext2 = res.Ptr(dotPos + 1);
+ if ((ext.IsEqualTo_Ascii_NoCase("001") && IsItArcExt(ext2))
+ || (ext.IsEqualTo_Ascii_NoCase("rar") &&
+ ( ext2.IsEqualTo_Ascii_NoCase("part001")
+ || ext2.IsEqualTo_Ascii_NoCase("part01")
+ || ext2.IsEqualTo_Ascii_NoCase("part1"))))
+ res.DeleteFrom(dotPos);
+ res.TrimRight();
+ }
+ return Get_Correct_FsFile_Name(res);
+}
+
+static void ReduceString(UString &s)
+{
+ const unsigned kMaxSize = 64;
+ if (s.Len() <= kMaxSize)
+ return;
+ s.Delete(kMaxSize / 2, s.Len() - kMaxSize);
+ s.Insert(kMaxSize / 2, L" ... ");
+}
+
+static UString GetQuotedReducedString(const UString &s)
+{
+ UString s2 = s;
+ ReduceString(s2);
+ s2.Replace(L"&", L"&&");
+ return GetQuotedString(s2);
+}
+
+static void MyFormatNew_ReducedName(UString &s, const UString &name)
+{
+ s = MyFormatNew(s, GetQuotedReducedString(name));
+}
+
+static const char * const kExtractExcludeExtensions =
+ " 3gp"
+ " aac ans ape asc asm asp aspx avi awk"
+ " bas bat bmp"
+ " c cs cls clw cmd cpp csproj css ctl cxx"
+ " def dep dlg dsp dsw"
+ " eps"
+ " f f77 f90 f95 fla flac frm"
+ " gif"
+ " h hpp hta htm html hxx"
+ " ico idl inc ini inl"
+ " java jpeg jpg js"
+ " la lnk log"
+ " mak manifest wmv mov mp3 mp4 mpe mpeg mpg m4a"
+ " ofr ogg"
+ " pac pas pdf php php3 php4 php5 phptml pl pm png ps py pyo"
+ " ra rb rc reg rka rm rtf"
+ " sed sh shn shtml sln sql srt swa"
+ " tcl tex tiff tta txt"
+ " vb vcproj vbs"
+ " wav wma wv"
+ " xml xsd xsl xslt"
+ " ";
+
+/*
+static const char * const kNoOpenAsExtensions =
+ " 7z arj bz2 cab chm cpio flv gz lha lzh lzma rar swm tar tbz2 tgz wim xar xz z zip ";
+*/
+
+static const char * const kOpenTypes[] =
+{
+ ""
+ , "*"
+ , "#"
+ , "#:e"
+ // , "#:a"
+ , "7z"
+ , "zip"
+ , "cab"
+ , "rar"
+};
+
+
+bool FindExt(const char *p, const UString &name, CStringFinder &finder);
+bool FindExt(const char *p, const UString &name, CStringFinder &finder)
+{
+ const int dotPos = name.ReverseFind_Dot();
+ if (dotPos < 0 || dotPos == (int)name.Len() - 1)
+ return false;
+ return finder.FindWord_In_LowCaseAsciiList_NoCase(p, name.Ptr(dotPos + 1));
+}
+
+/* returns false, if extraction of that file extension is not expected */
+static bool DoNeedExtract(const UString &name, CStringFinder &finder)
+{
+ // for (int y = 0; y < 1000; y++) FindExt(kExtractExcludeExtensions, name);
+ return !FindExt(kExtractExcludeExtensions, name, finder);
+}
+
+// we must use diferent Verbs for Popup subMenu.
+void CZipContextMenu::AddMapItem_ForSubMenu(const char *verb)
+{
+ CCommandMapItem cmi;
+ cmi.CommandInternalID = kCommandNULL;
+ cmi.Verb = verb;
+ // cmi.HelpString = verb;
+ _commandMap.Add(cmi);
+}
+
+
+static HRESULT RETURN_WIN32_LastError_AS_HRESULT()
+{
+ DWORD lastError = ::GetLastError();
+ if (lastError == 0)
+ return E_FAIL;
+ return HRESULT_FROM_WIN32(lastError);
+}
+
+
+/*
+ we add CCommandMapItem to _commandMap for each new Menu ID.
+ so then we use _commandMap[offset].
+ That way we can execute commands that have menu item.
+ Another non-implemented way:
+ We can return the number off all possible commands in QueryContextMenu().
+ so the caller could call InvokeCommand() via string verb even
+ without using menu items.
+*/
+
+
+Z7_COMWF_B CZipContextMenu::QueryContextMenu(HMENU hMenu, UINT indexMenu,
+ UINT commandIDFirst, UINT commandIDLast, UINT flags)
+{
+ ODS("+ QueryContextMenu()")
+ COM_TRY_BEGIN
+ try {
+
+ _commandMap.Clear();
+
+ ODS_SPRF_s(sprintf(s, "QueryContextMenu: index=%u first=%u last=%u flags=%x _files=%u",
+ indexMenu, commandIDFirst, commandIDLast, flags, _fileNames.Size()))
+ /*
+ for (UInt32 i = 0; i < _fileNames.Size(); i++)
+ {
+ ODS_U(_fileNames[i])
+ }
+ */
+
+ if (_fileNames.Size() == 0)
+ {
+ return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
+ // return E_INVALIDARG;
+ }
+
+ if (commandIDFirst > commandIDLast)
+ return E_INVALIDARG;
+
+ UINT currentCommandID = commandIDFirst;
+
+ if ((flags & 0x000F) != CMF_NORMAL
+ && (flags & CMF_VERBSONLY) == 0
+ && (flags & CMF_EXPLORE) == 0)
+ return MAKE_HRESULT(SEVERITY_SUCCESS, 0, currentCommandID - commandIDFirst);
+ // return MAKE_HRESULT(SEVERITY_SUCCESS, 0, currentCommandID);
+ // 19.01 : we changed from (currentCommandID) to (currentCommandID - commandIDFirst)
+ // why it was so before?
+
+#ifdef Z7_LANG
+ LoadLangOneTime();
+#endif
+
+ CMenu popupMenu;
+ CMenuDestroyer menuDestroyer;
+
+ ODS("### 40")
+ CContextMenuInfo ci;
+ ci.Load();
+ ODS("### 44")
+
+ _elimDup = ci.ElimDup;
+ _writeZone = ci.WriteZone;
+
+ HBITMAP bitmap = NULL;
+ if (ci.MenuIcons.Val)
+ {
+ ODS("### 45")
+ if (!_bitmap)
+ _bitmap = ::LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_MENU_LOGO));
+ bitmap = _bitmap;
+ }
+
+ UINT subIndex = indexMenu;
+
+ ODS("### 50")
+
+ if (ci.Cascaded.Val)
+ {
+ if (hMenu)
+ if (!popupMenu.CreatePopup())
+ return RETURN_WIN32_LastError_AS_HRESULT();
+ menuDestroyer.Attach(popupMenu);
+
+ /* 9.31: we commented the following code. Probably we don't need.
+ Check more systems. Maybe it was for old Windows? */
+ /*
+ AddMapItem_ForSubMenu();
+ currentCommandID++;
+ */
+ subIndex = 0;
+ }
+ else
+ {
+ popupMenu.Attach(hMenu);
+ CMenuItem mi;
+ mi.fType = MFT_SEPARATOR;
+ mi.fMask = MIIM_TYPE;
+ if (hMenu)
+ popupMenu.InsertItem(subIndex++, true, mi);
+ }
+
+ const UInt32 contextMenuFlags = ci.Flags;
+
+ NFind::CFileInfo fi0;
+ FString folderPrefix;
+
+ if (_fileNames.Size() > 0)
+ {
+ const UString &fileName = _fileNames.Front();
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (NName::IsDevicePath(us2fs(fileName)))
+ {
+ // CFileInfo::Find can be slow for device files. So we don't call it.
+ // we need only name here.
+ fi0.Name = us2fs(fileName.Ptr(NName::kDevicePathPrefixSize));
+ folderPrefix =
+ #ifdef UNDER_CE
+ "\\";
+ #else
+ "C:\\";
+ #endif
+ }
+ else
+ #endif
+ {
+ if (!fi0.Find(us2fs(fileName)))
+ {
+ throw 20190820;
+ // return RETURN_WIN32_LastError_AS_HRESULT();
+ }
+ GetOnlyDirPrefix(us2fs(fileName), folderPrefix);
+ }
+ }
+
+ ODS("### 100")
+
+ UString mainString;
+ CStringFinder finder;
+ UStringVector fileNames_Reduced;
+ const unsigned k_Explorer_NumReducedItems = 16;
+ const bool needReduce = !_isMenuForFM && (_fileNames.Size() >= k_Explorer_NumReducedItems);
+ _fileNames_WereReduced = needReduce;
+ // _fileNames_WereReduced = true; // for debug;
+ const UStringVector *fileNames = &_fileNames;
+ if (needReduce)
+ {
+ for (unsigned i = 0; i < k_Explorer_NumReducedItems
+ && i < _fileNames.Size(); i++)
+ fileNames_Reduced.Add(_fileNames[i]);
+ fileNames = &fileNames_Reduced;
+ }
+
+ /*
+ if (_fileNames.Size() == k_Explorer_NumReducedItems) // for debug
+ {
+ for (int i = 0; i < 10; i++)
+ {
+ CCommandMapItem cmi;
+ AddCommand(kCompressToZipEmail, mainString, cmi);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+ }
+ */
+
+ if (_fileNames.Size() == 1 && currentCommandID + 14 <= commandIDLast)
+ {
+ if (!fi0.IsDir() && DoNeedExtract(fs2us(fi0.Name), finder))
+ {
+ // Open
+ const bool thereIsMainOpenItem = ((contextMenuFlags & NContextMenuFlags::kOpen) != 0);
+ if (thereIsMainOpenItem)
+ {
+ CCommandMapItem cmi;
+ AddCommand(kOpen, mainString, cmi);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+ if ((contextMenuFlags & NContextMenuFlags::kOpenAs) != 0
+ // && (!thereIsMainOpenItem || !FindExt(kNoOpenAsExtensions, fi0.Name))
+ && hMenu // we want to reduce number of menu items below 16
+ )
+ {
+ CMenu subMenu;
+ if (!hMenu || subMenu.CreatePopup())
+ {
+ MyAddSubMenu(_commandMap, kOpenCascadedVerb, popupMenu, subIndex++, currentCommandID++, LangString(IDS_CONTEXT_OPEN), subMenu, bitmap);
+ _commandMap.Back().CtxCommandType = CtxCommandType_OpenRoot;
+
+ UINT subIndex2 = 0;
+ for (unsigned i = (thereIsMainOpenItem ? 1 : 0); i < Z7_ARRAY_SIZE(kOpenTypes); i++)
+ {
+ CCommandMapItem cmi;
+ if (i == 0)
+ FillCommand(kOpen, mainString, cmi);
+ else
+ {
+ mainString = kOpenTypes[i];
+ cmi.CommandInternalID = kOpen;
+ cmi.Verb = kMainVerb;
+ cmi.Verb += ".Open.";
+ cmi.Verb += mainString;
+ // cmi.HelpString = cmi.Verb;
+ cmi.ArcType = mainString;
+ cmi.CtxCommandType = CtxCommandType_OpenChild;
+ }
+ _commandMap.Add(cmi);
+ Set_UserString_in_LastCommand(mainString);
+ MyInsertMenu(subMenu, subIndex2++, currentCommandID++, mainString, bitmap);
+ }
+
+ subMenu.Detach();
+ }
+ }
+ }
+ }
+
+ ODS("### 150")
+
+ if (_fileNames.Size() > 0 && currentCommandID + 10 <= commandIDLast)
+ {
+ ODS("### needExtract list START")
+ const bool needExtendedVerbs = ((flags & Z7_WIN_CMF_EXTENDEDVERBS) != 0);
+ // || _isMenuForFM;
+ bool needExtract = true;
+ bool areDirs = fi0.IsDir() || (unsigned)_attribs.FirstDirIndex < k_Explorer_NumReducedItems;
+ if (!needReduce)
+ areDirs = areDirs || (_attribs.FirstDirIndex != -1);
+ if (areDirs)
+ needExtract = false;
+
+ if (!needExtendedVerbs)
+ if (needExtract)
+ {
+ UString name;
+ const unsigned numItemsCheck = fileNames->Size();
+ for (unsigned i = 0; i < numItemsCheck; i++)
+ {
+ const UString &a = (*fileNames)[i];
+ const int slash = a.ReverseFind_PathSepar();
+ name = a.Ptr(slash + 1);
+ // for (int y = 0; y < 600; y++) // for debug
+ const bool needExtr2 = DoNeedExtract(name, finder);
+ if (!needExtr2)
+ {
+ needExtract = needExtr2;
+ break;
+ }
+ }
+ }
+ ODS("### needExtract list END")
+
+ if (needExtract)
+ {
+ {
+ UString baseFolder = fs2us(folderPrefix);
+ if (_dropMode)
+ baseFolder = _dropPath;
+
+ UString specFolder ('*');
+ if (_fileNames.Size() == 1)
+ specFolder = GetSubFolderNameForExtract(fs2us(fi0.Name));
+ specFolder.Add_PathSepar();
+
+ if ((contextMenuFlags & NContextMenuFlags::kExtract) != 0)
+ {
+ // Extract
+ CCommandMapItem cmi;
+ cmi.Folder = baseFolder + specFolder;
+ AddCommand(kExtract, mainString, cmi);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+
+ if ((contextMenuFlags & NContextMenuFlags::kExtractHere) != 0)
+ {
+ // Extract Here
+ CCommandMapItem cmi;
+ cmi.Folder = baseFolder;
+ AddCommand(kExtractHere, mainString, cmi);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+
+ if ((contextMenuFlags & NContextMenuFlags::kExtractTo) != 0)
+ {
+ // Extract To
+ CCommandMapItem cmi;
+ UString s;
+ cmi.Folder = baseFolder + specFolder;
+ AddCommand(kExtractTo, s, cmi);
+ MyFormatNew_ReducedName(s, specFolder);
+ Set_UserString_in_LastCommand(s);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, s, bitmap);
+ }
+ }
+
+ if ((contextMenuFlags & NContextMenuFlags::kTest) != 0)
+ {
+ // Test
+ CCommandMapItem cmi;
+ AddCommand(kTest, mainString, cmi);
+ // if (_fileNames.Size() == 16) mainString += "_[16]"; // for debug
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+ }
+
+ ODS("### CreateArchiveName START")
+ UString arcName_base;
+ const UString arcName = CreateArchiveName(
+ *fileNames,
+ false, // isHash
+ fileNames->Size() == 1 ? &fi0 : NULL,
+ arcName_base);
+ ODS("### CreateArchiveName END")
+ UString arcName_Show = arcName;
+ if (needReduce)
+ {
+ /* we need same arcName_Show for two calls from Explorer:
+ 1) reduced call (only first 16 items)
+ 2) full call with all items (can be >= 16 items)
+ (fileNames) array was reduced to 16 items.
+ So we will have same (arcName) in both reduced and full calls.
+ If caller (Explorer) uses (reduce_to_first_16_items) scheme,
+ we can use (arcName) here instead of (arcName_base).
+ (arcName_base) has no number in name.
+ */
+ arcName_Show = arcName_base; // we can comment that line
+ /* we use "_" in archive name as sign to user
+ that shows that final archive name can be changed. */
+ arcName_Show += "_";
+ }
+
+ UString arcName_7z = arcName;
+ arcName_7z += ".7z";
+ UString arcName_7z_Show = arcName_Show;
+ arcName_7z_Show += ".7z";
+ UString arcName_zip = arcName;
+ arcName_zip += ".zip";
+ UString arcName_zip_Show = arcName_Show;
+ arcName_zip_Show += ".zip";
+
+
+ // Compress
+ if ((contextMenuFlags & NContextMenuFlags::kCompress) != 0)
+ {
+ CCommandMapItem cmi;
+ if (_dropMode)
+ cmi.Folder = _dropPath;
+ else
+ cmi.Folder = fs2us(folderPrefix);
+ cmi.ArcName = arcName;
+ AddCommand(kCompress, mainString, cmi);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+
+ #ifdef EMAIL_SUPPORT
+ // CompressEmail
+ if ((contextMenuFlags & NContextMenuFlags::kCompressEmail) != 0 && !_dropMode)
+ {
+ CCommandMapItem cmi;
+ cmi.ArcName = arcName;
+ AddCommand(kCompressEmail, mainString, cmi);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, mainString, bitmap);
+ }
+ #endif
+
+ // CompressTo7z
+ if (contextMenuFlags & NContextMenuFlags::kCompressTo7z &&
+ !arcName_7z.IsEqualTo_NoCase(fs2us(fi0.Name)))
+ {
+ CCommandMapItem cmi;
+ UString s;
+ if (_dropMode)
+ cmi.Folder = _dropPath;
+ else
+ cmi.Folder = fs2us(folderPrefix);
+ cmi.ArcName = arcName_7z;
+ cmi.ArcType = "7z";
+ AddCommand(kCompressTo7z, s, cmi);
+ MyFormatNew_ReducedName(s, arcName_7z_Show);
+ Set_UserString_in_LastCommand(s);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, s, bitmap);
+ }
+
+ #ifdef EMAIL_SUPPORT
+ // CompressTo7zEmail
+ if ((contextMenuFlags & NContextMenuFlags::kCompressTo7zEmail) != 0 && !_dropMode)
+ {
+ CCommandMapItem cmi;
+ UString s;
+ cmi.ArcName = arcName_7z;
+ cmi.ArcType = "7z";
+ AddCommand(kCompressTo7zEmail, s, cmi);
+ MyFormatNew_ReducedName(s, arcName_7z_Show);
+ Set_UserString_in_LastCommand(s);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, s, bitmap);
+ }
+ #endif
+
+ // CompressToZip
+ if (contextMenuFlags & NContextMenuFlags::kCompressToZip &&
+ !arcName_zip.IsEqualTo_NoCase(fs2us(fi0.Name)))
+ {
+ CCommandMapItem cmi;
+ UString s;
+ if (_dropMode)
+ cmi.Folder = _dropPath;
+ else
+ cmi.Folder = fs2us(folderPrefix);
+ cmi.ArcName = arcName_zip;
+ cmi.ArcType = "zip";
+ AddCommand(kCompressToZip, s, cmi);
+ MyFormatNew_ReducedName(s, arcName_zip_Show);
+ Set_UserString_in_LastCommand(s);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, s, bitmap);
+ }
+
+ #ifdef EMAIL_SUPPORT
+ // CompressToZipEmail
+ if ((contextMenuFlags & NContextMenuFlags::kCompressToZipEmail) != 0 && !_dropMode)
+ {
+ CCommandMapItem cmi;
+ UString s;
+ cmi.ArcName = arcName_zip;
+ cmi.ArcType = "zip";
+ AddCommand(kCompressToZipEmail, s, cmi);
+ MyFormatNew_ReducedName(s, arcName_zip_Show);
+ Set_UserString_in_LastCommand(s);
+ MyInsertMenu(popupMenu, subIndex++, currentCommandID++, s, bitmap);
+ }
+ #endif
+ }
+
+ ODS("### 300")
+
+ // don't use InsertMenu: See MSDN:
+ // PRB: Duplicate Menu Items In the File Menu For a Shell Context Menu Extension
+ // ID: Q214477
+
+ if (ci.Cascaded.Val)
+ {
+ CMenu menu;
+ menu.Attach(hMenu);
+ menuDestroyer.Disable();
+ MyAddSubMenu(_commandMap, kMainVerb, menu, indexMenu++, currentCommandID++, (UString)"7-Zip",
+ popupMenu, // popupMenu.Detach(),
+ bitmap);
+ }
+ else
+ {
+ // popupMenu.Detach();
+ indexMenu = subIndex;
+ }
+
+ ODS("### 350")
+
+ const bool needCrc = ((contextMenuFlags &
+ (NContextMenuFlags::kCRC |
+ NContextMenuFlags::kCRC_Cascaded)) != 0);
+
+ if (
+ // !_isMenuForFM && // 21.04: we don't hide CRC SHA menu in 7-Zip FM
+ needCrc
+ && currentCommandID + 1 < commandIDLast)
+ {
+ CMenu subMenu;
+ // CMenuDestroyer menuDestroyer_CRC;
+
+ UINT subIndex_CRC = 0;
+
+ if (!hMenu || subMenu.CreatePopup())
+ {
+ // menuDestroyer_CRC.Attach(subMenu);
+ const bool insertHashMenuTo7zipMenu = (ci.Cascaded.Val
+ && (contextMenuFlags & NContextMenuFlags::kCRC_Cascaded) != 0);
+
+ CMenu menu;
+ {
+ unsigned indexInParent;
+ if (insertHashMenuTo7zipMenu)
+ {
+ indexInParent = subIndex;
+ menu.Attach(popupMenu);
+ }
+ else
+ {
+ indexInParent = indexMenu;
+ menu.Attach(hMenu);
+ // menuDestroyer_CRC.Disable();
+ }
+ MyAddSubMenu(_commandMap, kCheckSumCascadedVerb, menu, indexInParent++, currentCommandID++, (UString)"CRC SHA", subMenu,
+ /* insertHashMenuTo7zipMenu ? NULL : */ bitmap);
+ _commandMap.Back().CtxCommandType = CtxCommandType_CrcRoot;
+ if (!insertHashMenuTo7zipMenu)
+ indexMenu = indexInParent;
+ }
+
+ ODS("### HashCommands")
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_HashCommands); i++)
+ {
+ if (currentCommandID >= commandIDLast)
+ break;
+ const CHashCommand &hc = g_HashCommands[i];
+ CCommandMapItem cmi;
+ cmi.CommandInternalID = hc.CommandInternalID;
+ cmi.Verb = kCheckSumCascadedVerb;
+ cmi.Verb.Add_Dot();
+ UString s;
+ s += hc.UserName;
+
+ if (hc.CommandInternalID == kHash_Generate_SHA256)
+ {
+ cmi.Verb += "Generate";
+ {
+ popupMenu.Attach(hMenu);
+ CMenuItem mi;
+ mi.fType = MFT_SEPARATOR;
+ mi.fMask = MIIM_TYPE;
+ subMenu.InsertItem(subIndex_CRC++, true, mi);
+ }
+
+ UString name;
+ UString showName;
+ ODS("### Hash CreateArchiveName Start")
+ // for (int y = 0; y < 10000; y++) // for debug
+ // if (fileNames->Size() == 1) name = fs2us(fi0.Name); else
+ name = CreateArchiveName(
+ *fileNames,
+ true, // isHash
+ fileNames->Size() == 1 ? &fi0 : NULL,
+ showName);
+ if (needReduce)
+ showName += "_";
+ else
+ showName = name;
+
+ ODS("### Hash CreateArchiveName END")
+ name += ".sha256";
+ showName += ".sha256";
+ cmi.Folder = fs2us(folderPrefix);
+ cmi.ArcName = name;
+ s = "SHA-256 -> ";
+ s += showName;
+ }
+ else if (hc.CommandInternalID == kHash_TestArc)
+ {
+ cmi.Verb += "Test";
+ s = LangStringAlt(IDS_CONTEXT_TEST, "Test archive");
+ s += " : ";
+ s += GetNameOfProperty(kpidChecksum, UString("Checksum"));
+ }
+ else
+ cmi.Verb += "Calc";
+
+ cmi.Verb.Add_Dot();
+ cmi.Verb += hc.MethodName;
+
+ // cmi.HelpString = cmi.Verb;
+ cmi.UserString = s;
+ cmi.CtxCommandType = CtxCommandType_CrcChild;
+ _commandMap.Add(cmi);
+ MyInsertMenu(subMenu, subIndex_CRC++, currentCommandID++, s, bitmap);
+ ODS("### 380")
+ }
+
+ subMenu.Detach();
+ }
+ }
+
+ popupMenu.Detach();
+ /*
+ if (!ci.Cascaded.Val)
+ indexMenu = subIndex;
+ */
+ const unsigned numCommands = currentCommandID - commandIDFirst;
+ ODS("+ QueryContextMenu() END")
+ ODS_SPRF_s(sprintf(s, "Commands=%u currentCommandID - commandIDFirst = %u",
+ _commandMap.Size(), numCommands))
+ if (_commandMap.Size() != numCommands)
+ throw 20190818;
+ /*
+ FOR_VECTOR (k, _commandMap)
+ {
+ ODS_U(_commandMap[k].Verb);
+ }
+ */
+ }
+ catch(...)
+ {
+ ODS_SPRF_s(sprintf(s, "catch() exception: Commands=%u", _commandMap.Size()))
+ if (_commandMap.Size() == 0)
+ throw;
+ }
+ /* we added some menu items already : num_added_menu_items,
+ So we MUST return (number_of_defined_ids), where (number_of_defined_ids >= num_added_menu_items)
+ This will prevent incorrect menu working, when same IDs can be
+ assigned in multiple menu items from different subhandlers.
+ And we must add items to _commandMap before adding to menu.
+ */
+ return MAKE_HRESULT(SEVERITY_SUCCESS, 0, _commandMap.Size());
+ COM_TRY_END
+}
+
+
+int CZipContextMenu::FindVerb(const UString &verb) const
+{
+ FOR_VECTOR (i, _commandMap)
+ if (_commandMap[i].Verb == verb)
+ return (int)i;
+ return -1;
+}
+
+static UString Get7zFmPath()
+{
+ return fs2us(NWindows::NDLL::GetModuleDirPrefix()) + L"7zFM.exe";
+}
+
+
+Z7_COMWF_B CZipContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO commandInfo)
+{
+ COM_TRY_BEGIN
+
+ ODS("==== CZipContextMenu::InvokeCommand()")
+
+ #ifdef SHOW_DEBUG_CTX_MENU
+
+ ODS_SPRF_s(sprintf(s, ": InvokeCommand: cbSize=%u flags=%x ",
+ (unsigned)commandInfo->cbSize, (unsigned)commandInfo->fMask))
+
+ PrintStringA("Verb", commandInfo->lpVerb);
+ PrintStringA("Parameters", commandInfo->lpParameters);
+ PrintStringA("Directory", commandInfo->lpDirectory);
+ #endif
+
+ int commandOffset = -1;
+
+ // xp64 / Win10 : explorer.exe sends 0 in lpVerbW
+ // MSDN: if (IS_INTRESOURCE(lpVerbW)), we must use LOWORD(lpVerb) as command offset
+
+ // FIXME: old MINGW doesn't define CMINVOKECOMMANDINFOEX / CMIC_MASK_UNICODE
+ #if !defined(UNDER_CE) && defined(CMIC_MASK_UNICODE)
+ bool unicodeVerb = false;
+ if (commandInfo->cbSize == sizeof(CMINVOKECOMMANDINFOEX) &&
+ (commandInfo->fMask & CMIC_MASK_UNICODE) != 0)
+ {
+ LPCMINVOKECOMMANDINFOEX commandInfoEx = (LPCMINVOKECOMMANDINFOEX)commandInfo;
+ if (!MY_IS_INTRESOURCE(commandInfoEx->lpVerbW))
+ {
+ unicodeVerb = true;
+ commandOffset = FindVerb(commandInfoEx->lpVerbW);
+ }
+
+ #ifdef SHOW_DEBUG_CTX_MENU
+ PrintStringW("VerbW", commandInfoEx->lpVerbW);
+ PrintStringW("ParametersW", commandInfoEx->lpParametersW);
+ PrintStringW("DirectoryW", commandInfoEx->lpDirectoryW);
+ PrintStringW("TitleW", commandInfoEx->lpTitleW);
+ PrintStringA("Title", commandInfoEx->lpTitle);
+ #endif
+ }
+ if (!unicodeVerb)
+ #endif
+ {
+ ODS("use non-UNICODE verb")
+ // if (HIWORD(commandInfo->lpVerb) == 0)
+ if (MY_IS_INTRESOURCE(commandInfo->lpVerb))
+ commandOffset = LOWORD(commandInfo->lpVerb);
+ else
+ commandOffset = FindVerb(GetUnicodeString(commandInfo->lpVerb));
+ }
+
+ ODS_SPRF_s(sprintf(s, "commandOffset=%d", commandOffset))
+
+ if (/* commandOffset < 0 || */ (unsigned)commandOffset >= _commandMap.Size())
+ return E_INVALIDARG;
+ const CCommandMapItem &cmi = _commandMap[(unsigned)commandOffset];
+ return InvokeCommandCommon(cmi);
+ COM_TRY_END
+}
+
+
+HRESULT CZipContextMenu::InvokeCommandCommon(const CCommandMapItem &cmi)
+{
+ const enum_CommandInternalID cmdID = cmi.CommandInternalID;
+
+ try
+ {
+ switch (cmdID)
+ {
+ case kOpen:
+ {
+ UString params;
+ params = GetQuotedString(_fileNames[0]);
+ if (!cmi.ArcType.IsEmpty())
+ {
+ params += " -t";
+ params += cmi.ArcType;
+ }
+ MyCreateProcess(Get7zFmPath(), params);
+ break;
+ }
+ case kExtract:
+ case kExtractHere:
+ case kExtractTo:
+ {
+ if (_attribs.FirstDirIndex != -1)
+ {
+ ShowErrorMessageRes(IDS_SELECT_FILES);
+ break;
+ }
+ ExtractArchives(_fileNames, cmi.Folder,
+ (cmdID == kExtract), // showDialog
+ (cmdID == kExtractTo) && _elimDup.Val, // elimDup
+ _writeZone
+ );
+ break;
+ }
+ case kTest:
+ {
+ TestArchives(_fileNames);
+ break;
+ }
+ case kCompress:
+ case kCompressEmail:
+ case kCompressTo7z:
+ case kCompressTo7zEmail:
+ case kCompressToZip:
+ case kCompressToZipEmail:
+ {
+ UString arcName = cmi.ArcName;
+ if (_fileNames_WereReduced)
+ {
+ UString arcName_base;
+ arcName = CreateArchiveName(
+ _fileNames,
+ false, // isHash
+ NULL, // fi0
+ arcName_base);
+ const char *postfix = NULL;
+ if (cmdID == kCompressTo7z ||
+ cmdID == kCompressTo7zEmail)
+ postfix = ".7z";
+ else if (
+ cmdID == kCompressToZip ||
+ cmdID == kCompressToZipEmail)
+ postfix = ".zip";
+ if (postfix)
+ arcName += postfix;
+ }
+
+ const bool email =
+ cmdID == kCompressEmail ||
+ cmdID == kCompressTo7zEmail ||
+ cmdID == kCompressToZipEmail;
+ const bool showDialog =
+ cmdID == kCompress ||
+ cmdID == kCompressEmail;
+ const bool addExtension = showDialog;
+ CompressFiles(cmi.Folder,
+ arcName, cmi.ArcType,
+ addExtension,
+ _fileNames, email, showDialog,
+ false // waitFinish
+ );
+ break;
+ }
+
+ case kHash_CRC32:
+ case kHash_CRC64:
+ case kHash_SHA1:
+ case kHash_SHA256:
+ case kHash_All:
+ case kHash_Generate_SHA256:
+ case kHash_TestArc:
+ {
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_HashCommands); i++)
+ {
+ const CHashCommand &hc = g_HashCommands[i];
+ if (hc.CommandInternalID == cmdID)
+ {
+ if (cmdID == kHash_TestArc)
+ {
+ TestArchives(_fileNames, true); // hashMode
+ break;
+ }
+ UString generateName;
+ if (cmdID == kHash_Generate_SHA256)
+ {
+ generateName = cmi.ArcName;
+ if (_fileNames_WereReduced)
+ {
+ UString arcName_base;
+ generateName = CreateArchiveName(_fileNames,
+ true, // isHash
+ NULL, // fi0
+ arcName_base);
+ generateName += ".sha256";
+ }
+ }
+ CalcChecksum(_fileNames, (UString)hc.MethodName,
+ cmi.Folder, generateName);
+ break;
+ }
+ }
+ break;
+ }
+ case kCommandNULL:
+ break;
+ }
+ }
+ catch(...)
+ {
+ ShowErrorMessage(NULL, L"Error");
+ }
+ return S_OK;
+}
+
+
+
+static void MyCopyString_isUnicode(void *dest, UINT size, const UString &src, bool writeInUnicode)
+{
+ if (size != 0)
+ size--;
+ if (writeInUnicode)
+ {
+ UString s = src;
+ s.DeleteFrom(size);
+ MyStringCopy((wchar_t *)dest, s);
+ ODS_U(s)
+ }
+ else
+ {
+ AString s = GetAnsiString(src);
+ s.DeleteFrom(size);
+ MyStringCopy((char *)dest, s);
+ }
+}
+
+
+Z7_COMWF_B CZipContextMenu::GetCommandString(
+ #ifdef Z7_OLD_WIN_SDK
+ UINT
+ #else
+ UINT_PTR
+ #endif
+ commandOffset,
+ UINT uType,
+ UINT * /* pwReserved */ , LPSTR pszName, UINT cchMax)
+{
+ COM_TRY_BEGIN
+
+ ODS("GetCommandString")
+
+ const int cmdOffset = (int)commandOffset;
+
+ ODS_SPRF_s(sprintf(s, "GetCommandString: cmdOffset=%d uType=%d cchMax = %d",
+ cmdOffset, uType, cchMax))
+
+ if ((uType | GCS_UNICODE) == GCS_VALIDATEW)
+ {
+ if (/* cmdOffset < 0 || */ (unsigned)cmdOffset >= _commandMap.Size())
+ return S_FALSE;
+ return S_OK;
+ }
+
+ if (/* cmdOffset < 0 || */ (unsigned)cmdOffset >= _commandMap.Size())
+ {
+ ODS("------ cmdOffset: E_INVALIDARG")
+ return E_INVALIDARG;
+ }
+
+ // we use Verb as HelpString
+ if (cchMax != 0)
+ if ((uType | GCS_UNICODE) == GCS_VERBW ||
+ (uType | GCS_UNICODE) == GCS_HELPTEXTW)
+ {
+ const CCommandMapItem &cmi = _commandMap[(unsigned)cmdOffset];
+ MyCopyString_isUnicode(pszName, cchMax, cmi.Verb, (uType & GCS_UNICODE) != 0);
+ return S_OK;
+ }
+
+ return E_INVALIDARG;
+
+ COM_TRY_END
+}
+
+
+
+// ---------- IExplorerCommand ----------
+
+static HRESULT WINAPI My_SHStrDupW(LPCWSTR src, LPWSTR *dest)
+{
+ if (src)
+ {
+ const SIZE_T size = (wcslen(src) + 1) * sizeof(WCHAR);
+ WCHAR *p = (WCHAR *)CoTaskMemAlloc(size);
+ if (p)
+ {
+ memcpy(p, src, size);
+ *dest = p;
+ return S_OK;
+ }
+ }
+ *dest = NULL;
+ return E_OUTOFMEMORY;
+}
+
+
+#define CZipExplorerCommand CZipContextMenu
+
+class CCoTaskWSTR
+{
+ LPWSTR m_str;
+ Z7_CLASS_NO_COPY(CCoTaskWSTR)
+public:
+ CCoTaskWSTR(): m_str(NULL) {}
+ ~CCoTaskWSTR() { ::CoTaskMemFree(m_str); }
+ LPWSTR* operator&() { return &m_str; }
+ operator LPCWSTR () const { return m_str; }
+ // operator LPCOLESTR() const { return m_str; }
+ operator bool() const { return m_str != NULL; }
+ // bool operator!() const { return m_str == NULL; }
+
+ /*
+ void Wipe_and_Free()
+ {
+ if (m_str)
+ {
+ memset(m_str, 0, ::SysStringLen(m_str) * sizeof(*m_str));
+ Empty();
+ }
+ }
+ */
+
+private:
+ /*
+ CCoTaskWSTR(LPCOLESTR src) { m_str = ::CoTaskMemAlloc(src); }
+
+ CCoTaskWSTR& operator=(LPCOLESTR src)
+ {
+ ::CoTaskMemFree(m_str);
+ m_str = ::SysAllocString(src);
+ return *this;
+ }
+
+
+ void Empty()
+ {
+ ::CoTaskMemFree(m_str);
+ m_str = NULL;
+ }
+ */
+};
+
+static HRESULT LoadPaths(IShellItemArray *psiItemArray, UStringVector &paths)
+{
+ if (psiItemArray)
+ {
+ DWORD numItems = 0;
+ RINOK(psiItemArray->GetCount(&numItems))
+ {
+ ODS_(Print_Number(numItems, " ==== LoadPaths START === "))
+ for (DWORD i = 0; i < numItems; i++)
+ {
+ CMyComPtr<IShellItem> item;
+ RINOK(psiItemArray->GetItemAt(i, &item))
+ if (item)
+ {
+ CCoTaskWSTR displayName;
+ if (item->GetDisplayName(SIGDN_FILESYSPATH, &displayName) == S_OK
+ && (bool)displayName)
+ {
+ ODS_U(displayName)
+ paths.Add((LPCWSTR)displayName);
+ }
+ }
+ }
+ ODS_(Print_Number(numItems, " ==== LoadPaths END === "))
+ }
+ }
+ return S_OK;
+}
+
+
+void CZipExplorerCommand::LoadItems(IShellItemArray *psiItemArray)
+{
+ SubCommands.Clear();
+ _fileNames.Clear();
+ {
+ UStringVector paths;
+ if (LoadPaths(psiItemArray, paths) != S_OK)
+ return;
+ _fileNames = paths;
+ }
+ const HRESULT res = QueryContextMenu(
+ NULL, // hMenu,
+ 0, // indexMenu,
+ 0, // commandIDFirst,
+ 0 + 999, // commandIDLast,
+ CMF_NORMAL);
+
+ if (FAILED(res))
+ return /* res */;
+
+ CZipExplorerCommand *crcHandler = NULL;
+ CZipExplorerCommand *openHandler = NULL;
+
+ bool useCascadedCrc = true; // false;
+ bool useCascadedOpen = true; // false;
+
+ for (unsigned i = 0; i < _commandMap.Size(); i++)
+ {
+ const CCommandMapItem &cmi = _commandMap[i];
+
+ if (cmi.IsPopup)
+ if (!cmi.IsSubMenu())
+ continue;
+
+ // if (cmi.IsSubMenu()) continue // for debug
+
+ CZipContextMenu *shellExt = new CZipContextMenu();
+ shellExt->IsRoot = false;
+
+ if (cmi.CtxCommandType == CtxCommandType_CrcRoot && !useCascadedCrc)
+ shellExt->IsSeparator = true;
+
+ {
+ CZipExplorerCommand *handler = this;
+ if (cmi.CtxCommandType == CtxCommandType_CrcChild && crcHandler)
+ handler = crcHandler;
+ else if (cmi.CtxCommandType == CtxCommandType_OpenChild && openHandler)
+ handler = openHandler;
+ handler->SubCommands.AddNew() = shellExt;
+ }
+
+ shellExt->_commandMap_Cur.Add(cmi);
+
+ ODS_U(cmi.UserString)
+
+ if (cmi.CtxCommandType == CtxCommandType_CrcRoot && useCascadedCrc)
+ crcHandler = shellExt;
+ if (cmi.CtxCommandType == CtxCommandType_OpenRoot && useCascadedOpen)
+ {
+ // ODS("cmi.CtxCommandType == CtxCommandType_OpenRoot");
+ openHandler = shellExt;
+ }
+ }
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::GetTitle(IShellItemArray *psiItemArray, LPWSTR *ppszName)
+{
+ ODS("- GetTitle()")
+ // COM_TRY_BEGIN
+ if (IsSeparator)
+ {
+ *ppszName = NULL;
+ return S_FALSE;
+ }
+
+ UString name;
+ if (IsRoot)
+ {
+ LoadItems(psiItemArray);
+ name = "7-Zip"; // "New"
+ }
+ else
+ name = "7-Zip item";
+
+ if (!_commandMap_Cur.IsEmpty())
+ {
+ const CCommandMapItem &mi = _commandMap_Cur[0];
+ // s += mi.Verb;
+ // s += " : ";
+ name = mi.UserString;
+ }
+
+ return My_SHStrDupW(name, ppszName);
+ // return S_OK;
+ // COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::GetIcon(IShellItemArray * /* psiItemArray */, LPWSTR *ppszIcon)
+{
+ ODS("- GetIcon()")
+ // COM_TRY_BEGIN
+ *ppszIcon = NULL;
+ // return E_NOTIMPL;
+ UString imageName = fs2us(NWindows::NDLL::GetModuleDirPrefix());
+ // imageName += "7zG.exe";
+ imageName += "7-zip.dll";
+ // imageName += ",190";
+ return My_SHStrDupW(imageName, ppszIcon);
+ // COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::GetToolTip (IShellItemArray * /* psiItemArray */, LPWSTR *ppszInfotip)
+{
+ // COM_TRY_BEGIN
+ ODS("- GetToolTip()")
+ *ppszInfotip = NULL;
+ return E_NOTIMPL;
+ // COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::GetCanonicalName(GUID *pguidCommandName)
+{
+ // COM_TRY_BEGIN
+ ODS("- GetCanonicalName()")
+ *pguidCommandName = GUID_NULL;
+ return E_NOTIMPL;
+ // COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::GetState(IShellItemArray * /* psiItemArray */, BOOL /* fOkToBeSlow */, EXPCMDSTATE *pCmdState)
+{
+ // COM_TRY_BEGIN
+ ODS("- GetState()")
+ *pCmdState = ECS_ENABLED;
+ return S_OK;
+ // COM_TRY_END
+}
+
+
+
+
+Z7_COMWF_B CZipExplorerCommand::Invoke(IShellItemArray *psiItemArray, IBindCtx * /* pbc */)
+{
+ COM_TRY_BEGIN
+
+ if (_commandMap_Cur.IsEmpty())
+ return E_INVALIDARG;
+
+ ODS("- Invoke()")
+ _fileNames.Clear();
+ UStringVector paths;
+ RINOK(LoadPaths(psiItemArray, paths))
+ _fileNames = paths;
+ return InvokeCommandCommon(_commandMap_Cur[0]);
+
+ COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::GetFlags(EXPCMDFLAGS *pFlags)
+{
+ ODS("- GetFlags()")
+ // COM_TRY_BEGIN
+ EXPCMDFLAGS f = ECF_DEFAULT;
+ if (IsSeparator)
+ f = ECF_ISSEPARATOR;
+ else if (IsRoot)
+ f = ECF_HASSUBCOMMANDS;
+ else
+ {
+ if (!_commandMap_Cur.IsEmpty())
+ {
+ // const CCommandMapItem &cmi = ;
+ if (_commandMap_Cur[0].IsSubMenu())
+ {
+ // ODS("ECF_HASSUBCOMMANDS")
+ f = ECF_HASSUBCOMMANDS;
+ }
+ }
+ }
+ *pFlags = f;
+ return S_OK;
+ // COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipExplorerCommand::EnumSubCommands(IEnumExplorerCommand **ppEnum)
+{
+ ODS("- EnumSubCommands()")
+ // COM_TRY_BEGIN
+ *ppEnum = NULL;
+
+ if (!_commandMap_Cur.IsEmpty() && _commandMap_Cur[0].IsSubMenu())
+ {
+ }
+ else
+ {
+ if (!IsRoot)
+ return E_NOTIMPL;
+ if (SubCommands.IsEmpty())
+ {
+ return E_NOTIMPL;
+ }
+ }
+
+ // shellExt->
+ return QueryInterface(IID_IEnumExplorerCommand, (void **)ppEnum);
+
+ // return S_OK;
+ // COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipContextMenu::Next(ULONG celt, IExplorerCommand **pUICommand, ULONG *pceltFetched)
+{
+ ODS("CZipContextMenu::Next()")
+ ODS_(Print_Number(celt, "celt"))
+ ODS_(Print_Number(CurrentSubCommand, "CurrentSubCommand"))
+ ODS_(Print_Number(SubCommands.Size(), "SubCommands.Size()"))
+
+ COM_TRY_BEGIN
+ ULONG fetched = 0;
+
+ ULONG i;
+ for (i = 0; i < celt; i++)
+ {
+ pUICommand[i] = NULL;
+ }
+
+ for (i = 0; i < celt && CurrentSubCommand < SubCommands.Size(); i++)
+ {
+ pUICommand[i] = SubCommands[CurrentSubCommand++];
+ pUICommand[i]->AddRef();
+ fetched++;
+ }
+
+ if (pceltFetched)
+ *pceltFetched = fetched;
+
+ ODS(fetched == celt ? " === OK === " : "=== ERROR ===")
+
+ // we return S_FALSE for (fetched == 0)
+ return (fetched == celt) ? S_OK : S_FALSE;
+ COM_TRY_END
+}
+
+
+Z7_COMWF_B CZipContextMenu::Skip(ULONG /* celt */)
+{
+ ODS("CZipContextMenu::Skip()")
+ return E_NOTIMPL;
+}
+
+
+Z7_COMWF_B CZipContextMenu::Reset(void)
+{
+ ODS("CZipContextMenu::Reset()")
+ CurrentSubCommand = 0;
+ return S_OK;
+}
+
+
+Z7_COMWF_B CZipContextMenu::Clone(IEnumExplorerCommand **ppenum)
+{
+ ODS("CZipContextMenu::Clone()")
+ *ppenum = NULL;
+ return E_NOTIMPL;
+}
diff --git a/CPP/7zip/UI/Explorer/ContextMenu.h b/CPP/7zip/UI/Explorer/ContextMenu.h
new file mode 100644
index 0000000..3f25f6a
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/ContextMenu.h
@@ -0,0 +1,167 @@
+// ContextMenu.h
+
+#ifndef ZIP7_INC_CONTEXT_MENU_H
+#define ZIP7_INC_CONTEXT_MENU_H
+
+#include "../../../Windows/Shell.h"
+
+#include "MyExplorerCommand.h"
+
+#include "../FileManager/MyCom2.h"
+
+#ifdef CMF_EXTENDEDVERBS
+#define Z7_WIN_CMF_EXTENDEDVERBS CMF_EXTENDEDVERBS
+#else
+#define Z7_WIN_CMF_EXTENDEDVERBS 0x00000100
+#endif
+
+enum enum_CtxCommandType
+{
+ CtxCommandType_Normal,
+ CtxCommandType_OpenRoot,
+ CtxCommandType_OpenChild,
+ CtxCommandType_CrcRoot,
+ CtxCommandType_CrcChild
+};
+
+
+class CZipContextMenu Z7_final:
+ public IContextMenu,
+ public IShellExtInit,
+ public IExplorerCommand,
+ public IEnumExplorerCommand,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_4_MT(
+ IContextMenu,
+ IShellExtInit,
+ IExplorerCommand,
+ IEnumExplorerCommand
+ )
+
+ // IShellExtInit
+ STDMETHOD(Initialize)(LPCITEMIDLIST pidlFolder, LPDATAOBJECT dataObject, HKEY hkeyProgID) Z7_override;
+
+ // IContextMenu
+ STDMETHOD(QueryContextMenu)(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags) Z7_override;
+ STDMETHOD(InvokeCommand)(LPCMINVOKECOMMANDINFO lpici) Z7_override;
+ STDMETHOD(GetCommandString)(
+ #ifdef Z7_OLD_WIN_SDK
+ UINT
+ #else
+ UINT_PTR
+ #endif
+ idCmd, UINT uType, UINT *pwReserved, LPSTR pszName, UINT cchMax) Z7_override;
+
+ // IExplorerCommand
+ STDMETHOD (GetTitle) (IShellItemArray *psiItemArray, LPWSTR *ppszName) Z7_override;
+ STDMETHOD (GetIcon) (IShellItemArray *psiItemArray, LPWSTR *ppszIcon) Z7_override;
+ STDMETHOD (GetToolTip) (IShellItemArray *psiItemArray, LPWSTR *ppszInfotip) Z7_override;
+ STDMETHOD (GetCanonicalName) (GUID *pguidCommandName) Z7_override;
+ STDMETHOD (GetState) (IShellItemArray *psiItemArray, BOOL fOkToBeSlow, EXPCMDSTATE *pCmdState) Z7_override;
+ STDMETHOD (Invoke) (IShellItemArray *psiItemArray, IBindCtx *pbc) Z7_override;
+ STDMETHOD (GetFlags) (EXPCMDFLAGS *pFlags) Z7_override;
+ STDMETHOD (EnumSubCommands) (IEnumExplorerCommand **ppEnum) Z7_override;
+
+ // IEnumExplorerCommand
+ STDMETHOD (Next) (ULONG celt, IExplorerCommand **pUICommand, ULONG *pceltFetched) Z7_override;
+ STDMETHOD (Skip) (ULONG celt) Z7_override;
+ STDMETHOD (Reset) (void) Z7_override;
+ STDMETHOD (Clone) (IEnumExplorerCommand **ppenum) Z7_override;
+
+public:
+
+ enum enum_CommandInternalID
+ {
+ kCommandNULL,
+ kOpen,
+ kExtract,
+ kExtractHere,
+ kExtractTo,
+ kTest,
+ kCompress,
+ kCompressEmail,
+ kCompressTo7z,
+ kCompressTo7zEmail,
+ kCompressToZip,
+ kCompressToZipEmail,
+ kHash_CRC32,
+ kHash_CRC64,
+ kHash_SHA1,
+ kHash_SHA256,
+ kHash_All,
+ kHash_Generate_SHA256,
+ kHash_TestArc
+ };
+
+public:
+ void Init_For_7zFM()
+ {
+ // _isMenuForFM = true;
+ // _fileNames_WereReduced = false;
+ }
+
+ void LoadItems(IShellItemArray *psiItemArray);
+
+ CZipContextMenu();
+ ~CZipContextMenu();
+
+ struct CCommandMapItem
+ {
+ enum_CommandInternalID CommandInternalID;
+ UString Verb;
+ UString UserString;
+ // UString HelpString;
+ UString Folder;
+ UString ArcName;
+ UString ArcType;
+ bool IsPopup;
+ enum_CtxCommandType CtxCommandType;
+
+ CCommandMapItem():
+ IsPopup(false),
+ CtxCommandType(CtxCommandType_Normal)
+ {}
+
+ bool IsSubMenu() const
+ {
+ return
+ CtxCommandType == CtxCommandType_CrcRoot ||
+ CtxCommandType == CtxCommandType_OpenRoot;
+ }
+ };
+
+ UStringVector _fileNames;
+ NWindows::NShell::CFileAttribs _attribs;
+
+private:
+ bool _isMenuForFM;
+ bool _fileNames_WereReduced; // = true, if only first 16 items were used in QueryContextMenu()
+ bool _dropMode;
+ UString _dropPath;
+ CObjectVector<CCommandMapItem> _commandMap;
+ CObjectVector<CCommandMapItem> _commandMap_Cur;
+
+ HBITMAP _bitmap;
+ UInt32 _writeZone;
+ CBoolPair _elimDup;
+
+ bool IsSeparator;
+ bool IsRoot;
+ CObjectVector< CMyComPtr<IExplorerCommand> > SubCommands;
+ unsigned CurrentSubCommand;
+
+ void Set_UserString_in_LastCommand(const UString &s)
+ {
+ _commandMap.Back().UserString = s;
+ }
+
+ int FindVerb(const UString &verb) const;
+ void FillCommand(enum_CommandInternalID id, UString &mainString, CCommandMapItem &cmi) const;
+ void AddCommand(enum_CommandInternalID id, UString &mainString, CCommandMapItem &cmi);
+ void AddMapItem_ForSubMenu(const char *ver);
+
+ HRESULT InvokeCommandCommon(const CCommandMapItem &cmi);
+};
+
+#endif
diff --git a/CPP/7zip/UI/Explorer/ContextMenuFlags.h b/CPP/7zip/UI/Explorer/ContextMenuFlags.h
new file mode 100644
index 0000000..50c177e
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/ContextMenuFlags.h
@@ -0,0 +1,27 @@
+// ContextMenuFlags.h
+
+#ifndef ZIP7_INC_CONTEXT_MENU_FLAGS_H
+#define ZIP7_INC_CONTEXT_MENU_FLAGS_H
+
+namespace NContextMenuFlags
+{
+ const UInt32 kExtract = 1 << 0;
+ const UInt32 kExtractHere = 1 << 1;
+ const UInt32 kExtractTo = 1 << 2;
+
+ const UInt32 kTest = 1 << 4;
+ const UInt32 kOpen = 1 << 5;
+ const UInt32 kOpenAs = 1 << 6;
+
+ const UInt32 kCompress = 1 << 8;
+ const UInt32 kCompressTo7z = 1 << 9;
+ const UInt32 kCompressEmail = 1 << 10;
+ const UInt32 kCompressTo7zEmail = 1 << 11;
+ const UInt32 kCompressToZip = 1 << 12;
+ const UInt32 kCompressToZipEmail = 1 << 13;
+
+ const UInt32 kCRC_Cascaded = (UInt32)1 << 30;
+ const UInt32 kCRC = (UInt32)1 << 31;
+}
+
+#endif
diff --git a/CPP/7zip/UI/Explorer/DllExportsExplorer.cpp b/CPP/7zip/UI/Explorer/DllExportsExplorer.cpp
new file mode 100644
index 0000000..7307b07
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/DllExportsExplorer.cpp
@@ -0,0 +1,264 @@
+// DLLExportsExplorer.cpp
+//
+// Notes:
+// Win2000:
+// If I register at HKCR\Folder\ShellEx then DLL is locked.
+// otherwise it unloads after explorer closing.
+// but if I call menu for desktop items it's locked all the time
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#if defined(__clang__) && __clang_major__ >= 4
+#pragma GCC diagnostic ignored "-Wnonportable-system-include-path"
+#endif
+// <olectl.h> : in new Windows Kit 10.0.2**** (NTDDI_WIN10_MN is defined)
+// <OleCtl.h> : in another Windows Kit versions
+#if defined(NTDDI_WIN10_MN) || defined(__MINGW32__) || defined(__MINGW64__)
+#include <olectl.h>
+#else
+#include <OleCtl.h>
+#endif
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlguid.h>
+#else
+#include <ShlGuid.h>
+#endif
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/ComTry.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/Registry.h"
+
+#include "../FileManager/IFolder.h"
+
+#include "ContextMenu.h"
+
+static LPCTSTR const k_ShellExtName = TEXT("7-Zip Shell Extension");
+static LPCTSTR const k_Approved = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved");
+
+// {23170F69-40C1-278A-1000-000100020000}
+static LPCTSTR const k_Clsid = TEXT("{23170F69-40C1-278A-1000-000100020000}");
+
+Z7_DEFINE_GUID(CLSID_CZipContextMenu,
+ k_7zip_GUID_Data1,
+ k_7zip_GUID_Data2,
+ k_7zip_GUID_Data3_Common,
+ 0x10, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00);
+
+using namespace NWindows;
+
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance = NULL;
+
+extern
+HWND g_HWND;
+HWND g_HWND = NULL;
+
+extern
+LONG g_DllRefCount;
+LONG g_DllRefCount = 0; // Reference count of this DLL.
+
+
+// #define ODS(sz) OutputDebugStringW(L#sz)
+#define ODS(sz)
+
+class CShellExtClassFactory Z7_final:
+ public IClassFactory,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1_MT(IClassFactory)
+
+ STDMETHOD(CreateInstance)(LPUNKNOWN, REFIID, void**) Z7_override Z7_final;
+ STDMETHOD(LockServer)(BOOL) Z7_override Z7_final;
+public:
+ CShellExtClassFactory() { InterlockedIncrement(&g_DllRefCount); }
+ ~CShellExtClassFactory() { InterlockedDecrement(&g_DllRefCount); }
+};
+
+Z7_COMWF_B CShellExtClassFactory::CreateInstance(LPUNKNOWN pUnkOuter,
+ REFIID riid, void **ppvObj)
+{
+ ODS("CShellExtClassFactory::CreateInstance()\r\n");
+ /*
+ char s[64];
+ ConvertUInt32ToHex(riid.Data1, s);
+ OutputDebugStringA(s);
+ */
+ *ppvObj = NULL;
+ if (pUnkOuter)
+ return CLASS_E_NOAGGREGATION;
+
+ CZipContextMenu *shellExt;
+ try
+ {
+ shellExt = new CZipContextMenu();
+ }
+ catch(...) { return E_OUTOFMEMORY; }
+ if (!shellExt)
+ return E_OUTOFMEMORY;
+
+ IContextMenu *ctxm = shellExt;
+ const HRESULT res = ctxm->QueryInterface(riid, ppvObj);
+ if (res != S_OK)
+ delete shellExt;
+ return res;
+}
+
+
+Z7_COMWF_B CShellExtClassFactory::LockServer(BOOL /* fLock */)
+{
+ return S_OK; // Check it
+}
+
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION return FALSE;
+#endif
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE hInstance
+ #else
+ HINSTANCE hInstance
+ #endif
+ , DWORD dwReason, LPVOID);
+
+extern "C"
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE hInstance
+ #else
+ HINSTANCE hInstance
+ #endif
+ , DWORD dwReason, LPVOID)
+{
+ if (dwReason == DLL_PROCESS_ATTACH)
+ {
+ g_hInstance = (HINSTANCE)hInstance;
+ ODS("In DLLMain, DLL_PROCESS_ATTACH\r\n");
+ NT_CHECK
+ }
+ else if (dwReason == DLL_PROCESS_DETACH)
+ {
+ ODS("In DLLMain, DLL_PROCESS_DETACH\r\n");
+ }
+ return TRUE;
+}
+
+
+// Used to determine whether the DLL can be unloaded by OLE
+
+STDAPI DllCanUnloadNow(void)
+{
+ ODS("In DLLCanUnloadNow\r\n");
+ /*
+ if (g_DllRefCount == 0)
+ ODS( "g_DllRefCount == 0");
+ else
+ ODS( "g_DllRefCount != 0");
+ */
+ return (g_DllRefCount == 0 ? S_OK : S_FALSE);
+}
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
+{
+ ODS("In DllGetClassObject\r\n");
+ *ppv = NULL;
+ if (IsEqualIID(rclsid, CLSID_CZipContextMenu))
+ {
+ CShellExtClassFactory *cf;
+ try
+ {
+ cf = new CShellExtClassFactory;
+ }
+ catch(...) { return E_OUTOFMEMORY; }
+ if (!cf)
+ return E_OUTOFMEMORY;
+ IClassFactory *cf2 = cf;
+ const HRESULT res = cf2->QueryInterface(riid, ppv);
+ if (res != S_OK)
+ delete cf;
+ return res;
+ }
+ return CLASS_E_CLASSNOTAVAILABLE;
+ // return _Module.GetClassObject(rclsid, riid, ppv);
+}
+
+
+static BOOL RegisterServer()
+{
+ ODS("RegisterServer\r\n");
+ FString modulePath;
+ if (!NDLL::MyGetModuleFileName(modulePath))
+ return FALSE;
+ const UString modulePathU = fs2us(modulePath);
+
+ CSysString s ("CLSID\\");
+ s += k_Clsid;
+
+ {
+ NRegistry::CKey key;
+ if (key.Create(HKEY_CLASSES_ROOT, s, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE) != NOERROR)
+ return FALSE;
+ key.SetValue(NULL, k_ShellExtName);
+ NRegistry::CKey keyInproc;
+ if (keyInproc.Create(key, TEXT("InprocServer32"), NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE) != NOERROR)
+ return FALSE;
+ keyInproc.SetValue(NULL, modulePathU);
+ keyInproc.SetValue(TEXT("ThreadingModel"), TEXT("Apartment"));
+ }
+
+ #if !defined(_WIN64) && !defined(UNDER_CE)
+ if (IsItWindowsNT())
+ #endif
+ {
+ NRegistry::CKey key;
+ if (key.Create(HKEY_LOCAL_MACHINE, k_Approved, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE) == NOERROR)
+ key.SetValue(k_Clsid, k_ShellExtName);
+ }
+
+ ODS("RegisterServer :: return TRUE");
+ return TRUE;
+}
+
+STDAPI DllRegisterServer(void)
+{
+ return RegisterServer() ? S_OK: SELFREG_E_CLASS;
+}
+
+static BOOL UnregisterServer()
+{
+ CSysString s ("CLSID\\");
+ s += k_Clsid;
+
+ RegDeleteKey(HKEY_CLASSES_ROOT, s + TEXT("\\InprocServer32"));
+ RegDeleteKey(HKEY_CLASSES_ROOT, s);
+
+ #if !defined(_WIN64) && !defined(UNDER_CE)
+ if (IsItWindowsNT())
+ #endif
+ {
+ HKEY hKey;
+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, k_Approved, 0, KEY_SET_VALUE, &hKey) == NOERROR)
+ {
+ RegDeleteValue(hKey, k_Clsid);
+ RegCloseKey(hKey);
+ }
+ }
+
+ return TRUE;
+}
+
+STDAPI DllUnregisterServer(void)
+{
+ return UnregisterServer() ? S_OK: SELFREG_E_CLASS;
+}
diff --git a/CPP/7zip/UI/Explorer/Explorer.def b/CPP/7zip/UI/Explorer/Explorer.def
new file mode 100644
index 0000000..034a269
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/Explorer.def
@@ -0,0 +1,9 @@
+; 7-zip.def
+
+LIBRARY "7-zip"
+
+EXPORTS
+ DllCanUnloadNow PRIVATE
+ DllGetClassObject PRIVATE
+ DllRegisterServer PRIVATE
+ DllUnregisterServer PRIVATE
diff --git a/CPP/7zip/UI/Explorer/Explorer.dsp b/CPP/7zip/UI/Explorer/Explorer.dsp
new file mode 100644
index 0000000..ff8503b
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/Explorer.dsp
@@ -0,0 +1,612 @@
+# Microsoft Developer Studio Project File - Name="Explorer" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=Explorer - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Explorer.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Explorer.mak" CFG="Explorer - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Explorer - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "Explorer - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "Explorer - Win32 ReleaseU" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "Explorer - Win32 DebugU" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Explorer - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /D "Z7_LANG" /D "Z7_LONG_PATH" /FAcs /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /dll /machine:I386 /out:"C:\Util\7-Zip.dll" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Explorer - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /D "Z7_LANG" /D "Z7_LONG_PATH" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /dll /debug /machine:I386 /out:"C:\Util\7-Zip.dll" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "Explorer - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 1
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /D "Z7_LANG" /D "_MBCS" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /D "Z7_LANG" /D "Z7_LONG_PATH" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /dll /machine:I386 /out:"C:\Program Files\7-ZIP\7-Zip.dll" /opt:NOWIN98
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /dll /machine:I386 /out:"C:\Util\7-Zip.dll" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Explorer - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 1
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /D "Z7_LANG" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_WINDOWS" /D "_USRDLL" /D "EXPLORER_EXPORTS" /D "Z7_LANG" /D "Z7_LONG_PATH" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /dll /debug /machine:I386 /out:"C:\Program Files\7-ZIP\7-Zip.dll" /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /dll /debug /machine:I386 /out:"C:\Util\7-Zip.dll" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Explorer - Win32 Release"
+# Name "Explorer - Win32 Debug"
+# Name "Explorer - Win32 ReleaseU"
+# Name "Explorer - Win32 DebugU"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\DllExportsExplorer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Explorer.def
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\ArchiveName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CompressCall.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CompressCall.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "Engine"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ContextMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyExplorerCommand.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyMessages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyMessages.h
+# End Source File
+# End Group
+# Begin Group "FileManager"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\FileManager\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\HelpUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\HelpUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\IFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\LangUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\LangUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\MyCom2.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ProgramLocation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ProgramLocation.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\PropertyName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\PropertyName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\RegistryUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\RegistryUtils.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Types.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\COM.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=".\7-zip.dll.manifest"
+# End Source File
+# Begin Source File
+
+SOURCE=.\ContextMenuFlags.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\FM.ico
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/Explorer/Explorer.dsw b/CPP/7zip/UI/Explorer/Explorer.dsw
new file mode 100644
index 0000000..beb8df7
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/Explorer.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Explorer"=".\Explorer.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/Explorer/MenuLogo.bmp b/CPP/7zip/UI/Explorer/MenuLogo.bmp
new file mode 100644
index 0000000..906a6c5
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/MenuLogo.bmp
Binary files differ
diff --git a/CPP/7zip/UI/Explorer/MyExplorerCommand.h b/CPP/7zip/UI/Explorer/MyExplorerCommand.h
new file mode 100644
index 0000000..11ac247
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/MyExplorerCommand.h
@@ -0,0 +1,217 @@
+// MyExplorerCommand.h
+
+#ifndef ZIP7_INC_MY_EXPLORER_COMMAND_H
+#define ZIP7_INC_MY_EXPLORER_COMMAND_H
+
+#if _MSC_VER >= 1910
+#define USE_SYS_shobjidl_core
+#endif
+
+#ifdef USE_SYS_shobjidl_core
+
+// #include <shobjidl_core.h>
+
+#else
+
+/* IShellItem is defined:
+ ShObjIdl.h : old Windows SDK
+ ShObjIdl_core.h : new Windows 10 SDK */
+
+#ifndef Z7_OLD_WIN_SDK
+#include <ShObjIdl.h>
+#endif
+
+#ifndef __IShellItem_INTERFACE_DEFINED__
+#define __IShellItem_INTERFACE_DEFINED__
+
+// For MINGW we define IShellItem
+
+// #error Stop_Compiling__NOT_DEFINED__IShellItem_INTERFACE_DEFINED__
+
+typedef
+enum
+{ SIGDN_NORMALDISPLAY = 0,
+ SIGDN_PARENTRELATIVEPARSING = 0x80018001,
+ SIGDN_PARENTRELATIVEFORADDRESSBAR = 0x8001c001,
+ SIGDN_DESKTOPABSOLUTEPARSING = 0x80028000,
+ SIGDN_PARENTRELATIVEEDITING = 0x80031001,
+ SIGDN_DESKTOPABSOLUTEEDITING = 0x8004c000,
+ SIGDN_FILESYSPATH = 0x80058000,
+ SIGDN_URL = 0x80068000
+} SIGDN;
+
+
+typedef DWORD SICHINTF;
+typedef ULONG SFGAOF;
+
+struct IShellItem : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE BindToHandler(IBindCtx *pbc, REFGUID rbhid, REFIID riid, void **ppvOut) = 0;
+ virtual HRESULT STDMETHODCALLTYPE GetParent(IShellItem **ppsi) = 0;
+ virtual HRESULT STDMETHODCALLTYPE GetDisplayName(SIGDN sigdnName, LPOLESTR *ppszName) = 0;
+ virtual HRESULT STDMETHODCALLTYPE GetAttributes(SFGAOF sfgaoMask, SFGAOF *psfgaoAttribs) = 0;
+ virtual HRESULT STDMETHODCALLTYPE Compare(IShellItem *psi, SICHINTF hint, int *piOrder) = 0;
+};
+
+#endif // __IShellItem_INTERFACE_DEFINED__
+
+
+
+#ifndef __IShellItemArray_INTERFACE_DEFINED__
+#define __IShellItemArray_INTERFACE_DEFINED__
+
+// propsys.h
+
+typedef /* [v1_enum] */
+enum GETPROPERTYSTOREFLAGS
+{
+ GPS_DEFAULT = 0,
+ GPS_HANDLERPROPERTIESONLY = 0x1,
+ GPS_READWRITE = 0x2,
+ GPS_TEMPORARY = 0x4,
+ GPS_FASTPROPERTIESONLY = 0x8,
+ GPS_OPENSLOWITEM = 0x10,
+ GPS_DELAYCREATION = 0x20,
+ GPS_BESTEFFORT = 0x40,
+ GPS_NO_OPLOCK = 0x80,
+ GPS_PREFERQUERYPROPERTIES = 0x100,
+ GPS_EXTRINSICPROPERTIES = 0x200,
+ GPS_EXTRINSICPROPERTIESONLY = 0x400,
+ GPS_VOLATILEPROPERTIES = 0x800,
+ GPS_VOLATILEPROPERTIESONLY = 0x1000,
+ GPS_MASK_VALID = 0x1fff
+} GETPROPERTYSTOREFLAGS;
+
+// DEFINE_ENUM_FLAG_OPERATORS(GETPROPERTYSTOREFLAGS)
+
+
+#ifndef PROPERTYKEY_DEFINED
+#define PROPERTYKEY_DEFINED
+
+typedef
+struct _tagpropertykey
+{
+ GUID fmtid;
+ DWORD pid;
+} PROPERTYKEY;
+
+#endif // PROPERTYKEY_DEFINED
+
+// propkeydef.h
+#define REFPROPERTYKEY const PROPERTYKEY &
+
+#ifdef INITGUID
+#define DEFINE_PROPERTYKEY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8, pid) EXTERN_C const PROPERTYKEY DECLSPEC_SELECTANY name = { { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }, pid }
+#else
+#define DEFINE_PROPERTYKEY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8, pid) EXTERN_C const PROPERTYKEY name
+#endif // INITGUID
+
+
+// <shobjidl_core.h>
+typedef /* [v1_enum] */
+enum SIATTRIBFLAGS
+{
+ SIATTRIBFLAGS_AND = 0x1,
+ SIATTRIBFLAGS_OR = 0x2,
+ SIATTRIBFLAGS_APPCOMPAT = 0x3,
+ SIATTRIBFLAGS_MASK = 0x3,
+ SIATTRIBFLAGS_ALLITEMS = 0x4000
+} SIATTRIBFLAGS;
+
+// DEFINE_ENUM_FLAG_OPERATORS(SIATTRIBFLAGS)
+
+
+// MIDL_INTERFACE("70629033-e363-4a28-a567-0db78006e6d7")
+DEFINE_GUID(IID_IEnumShellItems, 0x70629033, 0xe363, 0xe363, 0xa5, 0x67, 0x0d, 0xb7, 0x80, 0x06, 0xe6, 0xd7);
+
+struct IEnumShellItems : public IUnknown
+{
+ STDMETHOD (Next) (ULONG celt, IShellItem **rgelt, ULONG *pceltFetched) = 0;
+ STDMETHOD (Skip) (ULONG celt) = 0;
+ STDMETHOD (Reset) (void) = 0;
+ STDMETHOD (Clone) (IEnumShellItems **ppenum) = 0;
+};
+
+
+// MIDL_INTERFACE("b63ea76d-1f85-456f-a19c-48159efa858b")
+DEFINE_GUID(IID_IShellItemArray, 0xb63ea76d, 0x1f85, 0x456f, 0xa1, 0x9c, 0x48, 0x15, 0x9e, 0xfa, 0x85, 0x8b);
+
+struct IShellItemArray : public IUnknown
+{
+ STDMETHOD (BindToHandler) (IBindCtx *pbc, REFGUID bhid, REFIID riid, void **ppvOut) = 0;
+ STDMETHOD (GetPropertyStore) (GETPROPERTYSTOREFLAGS flags, REFIID riid, void **ppv) = 0;
+ STDMETHOD (GetPropertyDescriptionList) (REFPROPERTYKEY keyType, REFIID riid, void **ppv) = 0;
+ STDMETHOD (GetAttributes) ( SIATTRIBFLAGS AttribFlags, SFGAOF sfgaoMask, SFGAOF *psfgaoAttribs) = 0;
+ STDMETHOD (GetCount) (DWORD *pdwNumItems) = 0;
+ STDMETHOD (GetItemAt) (DWORD dwIndex, IShellItem **ppsi) = 0;
+ STDMETHOD (EnumItems) (IEnumShellItems **ppenumShellItems) = 0;
+};
+
+
+#ifndef __IEnumExplorerCommand_INTERFACE_DEFINED__
+#define __IEnumExplorerCommand_INTERFACE_DEFINED__
+
+struct IExplorerCommand;
+
+// MIDL_INTERFACE("a88826f8-186f-4987-aade-ea0cef8fbfe8")
+DEFINE_GUID(IID_IEnumExplorerCommand , 0xa88826f8, 0x186f, 0x4987, 0xaa, 0xde, 0xea, 0x0c, 0xef, 0x8f, 0xbf, 0xe8);
+
+struct IEnumExplorerCommand : public IUnknown
+{
+ STDMETHOD (Next) (ULONG celt, IExplorerCommand **pUICommand, ULONG *pceltFetched) = 0;
+ STDMETHOD (Skip) (ULONG celt) = 0;
+ STDMETHOD (Reset) (void) = 0;
+ STDMETHOD (Clone) (IEnumExplorerCommand **ppenum) = 0;
+};
+
+
+enum _EXPCMDSTATE
+{
+ ECS_ENABLED = 0,
+ ECS_DISABLED = 0x1,
+ ECS_HIDDEN = 0x2,
+ ECS_CHECKBOX = 0x4,
+ ECS_CHECKED = 0x8,
+ ECS_RADIOCHECK = 0x10
+};
+
+typedef DWORD EXPCMDSTATE;
+
+/* [v1_enum] */
+enum _EXPCMDFLAGS
+{
+ ECF_DEFAULT = 0,
+ ECF_HASSUBCOMMANDS = 0x1,
+ ECF_HASSPLITBUTTON = 0x2,
+ ECF_HIDELABEL = 0x4,
+ ECF_ISSEPARATOR = 0x8,
+ ECF_HASLUASHIELD = 0x10,
+ ECF_SEPARATORBEFORE = 0x20,
+ ECF_SEPARATORAFTER = 0x40,
+ ECF_ISDROPDOWN = 0x80,
+ ECF_TOGGLEABLE = 0x100,
+ ECF_AUTOMENUICONS = 0x200
+};
+typedef DWORD EXPCMDFLAGS;
+
+
+// MIDL_INTERFACE("a08ce4d0-fa25-44ab-b57c-c7b1c323e0b9")
+DEFINE_GUID(IID_IExplorerCommand, 0xa08ce4d0, 0xfa25, 0x44ab, 0xb5, 0x7c, 0xc7, 0xb1, 0xc3, 0x23, 0xe0, 0xb9);
+
+struct IExplorerCommand : public IUnknown
+{
+ STDMETHOD (GetTitle) (IShellItemArray *psiItemArray, LPWSTR *ppszName) = 0;
+ STDMETHOD (GetIcon) (IShellItemArray *psiItemArray, LPWSTR *ppszIcon) = 0;
+ STDMETHOD (GetToolTip) (IShellItemArray *psiItemArray, LPWSTR *ppszInfotip) = 0;
+ STDMETHOD (GetCanonicalName) (GUID *pguidCommandName) = 0;
+ STDMETHOD (GetState) (IShellItemArray *psiItemArray, BOOL fOkToBeSlow, EXPCMDSTATE *pCmdState) = 0;
+ STDMETHOD (Invoke) (IShellItemArray *psiItemArray, IBindCtx *pbc) = 0;
+ STDMETHOD (GetFlags) (EXPCMDFLAGS *pFlags) = 0;
+ STDMETHOD (EnumSubCommands) (IEnumExplorerCommand **ppEnum) = 0;
+};
+
+#endif // IShellItemArray
+#endif // __IEnumExplorerCommand_INTERFACE_DEFINED__
+#endif // USE_SYS_shobjidl_core
+
+#endif // __MY_EXPLORER_COMMAND_H
diff --git a/CPP/7zip/UI/Explorer/MyMessages.cpp b/CPP/7zip/UI/Explorer/MyMessages.cpp
index 1ef0d9c..daff7de 100644
--- a/CPP/7zip/UI/Explorer/MyMessages.cpp
+++ b/CPP/7zip/UI/Explorer/MyMessages.cpp
@@ -1,37 +1,40 @@
-// MyMessages.cpp
-
-#include "StdAfx.h"
-
-#include "MyMessages.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/ResourceString.h"
-
-#include "../FileManager/LangUtils.h"
-
-using namespace NWindows;
-
-void ShowErrorMessage(HWND window, LPCWSTR message)
-{
- ::MessageBoxW(window, message, L"7-Zip", MB_OK | MB_ICONSTOP);
-}
-
-void ShowErrorMessageHwndRes(HWND window, UINT resID)
-{
- ShowErrorMessage(window, LangString(resID));
-}
-
-void ShowErrorMessageRes(UINT resID)
-{
- ShowErrorMessageHwndRes(0, resID);
-}
-
-void ShowErrorMessageDWORD(HWND window, DWORD errorCode)
-{
- ShowErrorMessage(window, NError::MyFormatMessage(errorCode));
-}
-
-void ShowLastErrorMessage(HWND window)
-{
- ShowErrorMessageDWORD(window, ::GetLastError());
-}
+// MyMessages.cpp
+
+#include "StdAfx.h"
+
+#include "MyMessages.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "../FileManager/LangUtils.h"
+
+using namespace NWindows;
+
+void ShowErrorMessage(HWND window, LPCWSTR message)
+{
+ ::MessageBoxW(window, message, L"7-Zip", MB_OK | MB_ICONSTOP);
+}
+
+void ShowErrorMessageHwndRes(HWND window, UINT resID)
+{
+ UString s = LangString(resID);
+ if (s.IsEmpty())
+ s.Add_UInt32(resID);
+ ShowErrorMessage(window, s);
+}
+
+void ShowErrorMessageRes(UINT resID)
+{
+ ShowErrorMessageHwndRes(NULL, resID);
+}
+
+static void ShowErrorMessageDWORD(HWND window, DWORD errorCode)
+{
+ ShowErrorMessage(window, NError::MyFormatMessage(errorCode));
+}
+
+void ShowLastErrorMessage(HWND window)
+{
+ ShowErrorMessageDWORD(window, ::GetLastError());
+}
diff --git a/CPP/7zip/UI/Explorer/MyMessages.h b/CPP/7zip/UI/Explorer/MyMessages.h
index c175e8a..47d10db 100644
--- a/CPP/7zip/UI/Explorer/MyMessages.h
+++ b/CPP/7zip/UI/Explorer/MyMessages.h
@@ -1,16 +1,16 @@
-// MyMessages.h
-
-#ifndef __MY_MESSAGES_H
-#define __MY_MESSAGES_H
-
-#include "../../../Common/MyString.h"
-
-void ShowErrorMessage(HWND window, LPCWSTR message);
-inline void ShowErrorMessage(LPCWSTR message) { ShowErrorMessage(0, message); }
-
-void ShowErrorMessageHwndRes(HWND window, UInt32 langID);
-void ShowErrorMessageRes(UInt32 langID);
-
-void ShowLastErrorMessage(HWND window = 0);
-
-#endif
+// MyMessages.h
+
+#ifndef ZIP7_INC_MY_MESSAGES_H
+#define ZIP7_INC_MY_MESSAGES_H
+
+#include "../../../Common/MyString.h"
+
+void ShowErrorMessage(HWND window, LPCWSTR message);
+inline void ShowErrorMessage(LPCWSTR message) { ShowErrorMessage(NULL, message); }
+
+void ShowErrorMessageHwndRes(HWND window, UInt32 langID);
+void ShowErrorMessageRes(UInt32 langID);
+
+void ShowLastErrorMessage(HWND window = NULL);
+
+#endif
diff --git a/CPP/7zip/UI/Explorer/RegistryContextMenu.cpp b/CPP/7zip/UI/Explorer/RegistryContextMenu.cpp
new file mode 100644
index 0000000..bc03d6a
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/RegistryContextMenu.cpp
@@ -0,0 +1,227 @@
+// RegistryContextMenu.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/Registry.h"
+
+#include "RegistryContextMenu.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+#ifndef UNDER_CE
+
+// does extension can work, if Approved is removed ?
+// CLISID (and Approved ?) items are separated for 32-bit and 64-bit code.
+// shellex items shared by 32-bit and 64-bit code?
+
+#define k_Clsid_A "{23170F69-40C1-278A-1000-000100020000}"
+
+static LPCTSTR const k_Clsid = TEXT(k_Clsid_A);
+static LPCTSTR const k_ShellExtName = TEXT("7-Zip Shell Extension");
+
+static LPCTSTR const k_Approved = TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Shell Extensions\\Approved");
+static LPCTSTR const k_Inproc = TEXT("InprocServer32");
+
+static LPCSTR const k_KeyPostfix_ContextMenu = "\\shellex\\ContextMenuHandlers\\7-Zip";
+static LPCSTR const k_KeyPostfix_DragDrop = "\\shellex\\DragDropHandlers\\7-Zip";
+
+static LPCSTR const k_KeyName_File = "*";
+static LPCSTR const k_KeyName_Folder = "Folder";
+static LPCSTR const k_KeyName_Directory = "Directory";
+static LPCSTR const k_KeyName_Drive = "Drive";
+
+static LPCSTR const k_shellex_Prefixes[] =
+{
+ k_KeyName_File,
+ k_KeyName_Folder,
+ k_KeyName_Directory,
+ k_KeyName_Drive
+};
+
+static const bool k_shellex_Statuses[2][4] =
+{
+ { true, true, true, false },
+ { false, false, true, true }
+};
+
+
+// can we use static RegDeleteKeyExW in _WIN64 mode?
+// is it supported by Windows 2003 x64?
+
+/*
+#ifdef _WIN64
+
+#define INIT_REG_WOW
+
+#else
+*/
+
+typedef
+// WINADVAPI
+LONG (APIENTRY *Func_RegDeleteKeyExW)(HKEY hKey, LPCWSTR lpSubKey, REGSAM samDesired, DWORD Reserved);
+static Func_RegDeleteKeyExW func_RegDeleteKeyExW;
+
+static void Init_RegDeleteKeyExW()
+{
+ if (!func_RegDeleteKeyExW)
+ func_RegDeleteKeyExW = Z7_GET_PROC_ADDRESS(
+ Func_RegDeleteKeyExW, GetModuleHandleW(L"advapi32.dll"),
+ "RegDeleteKeyExW");
+}
+
+#define INIT_REG_WOW if (wow != 0) Init_RegDeleteKeyExW();
+
+// #endif
+
+static LONG MyRegistry_DeleteKey(HKEY parentKey, LPCTSTR name, UInt32 wow)
+{
+ if (wow == 0)
+ return RegDeleteKey(parentKey, name);
+
+ /*
+ #ifdef _WIN64
+ return RegDeleteKeyExW
+ #else
+ */
+ if (!func_RegDeleteKeyExW)
+ return E_NOTIMPL;
+ return func_RegDeleteKeyExW
+ // #endif
+ (parentKey, GetUnicodeString(name), wow, 0);
+}
+
+static LONG MyRegistry_DeleteKey_HKCR(LPCTSTR name, UInt32 wow)
+{
+ return MyRegistry_DeleteKey(HKEY_CLASSES_ROOT, name, wow);
+}
+
+// static NSynchronization::CCriticalSection g_CS;
+
+static AString Get_ContextMenuHandler_KeyName(LPCSTR keyName)
+ { return (AString)keyName + k_KeyPostfix_ContextMenu; }
+
+/*
+static CSysString Get_DragDropHandler_KeyName(LPCTSTR keyName)
+ { return (AString)keyName + k_KeyPostfix_DragDrop); }
+*/
+
+static bool CheckHandlerCommon(const AString &keyName, UInt32 wow)
+{
+ CKey key;
+ if (key.Open(HKEY_CLASSES_ROOT, (CSysString)keyName, KEY_READ | wow) != ERROR_SUCCESS)
+ return false;
+ CSysString value;
+ if (key.QueryValue(NULL, value) != ERROR_SUCCESS)
+ return false;
+ return StringsAreEqualNoCase_Ascii(value, k_Clsid_A);
+}
+
+bool CheckContextMenuHandler(const UString &path, UInt32 wow)
+{
+ // NSynchronization::CCriticalSectionLock lock(g_CS);
+
+ CSysString s ("CLSID\\");
+ s += k_Clsid_A;
+ s += "\\InprocServer32";
+
+ {
+ NRegistry::CKey key;
+ if (key.Open(HKEY_CLASSES_ROOT, s, KEY_READ | wow) != ERROR_SUCCESS)
+ return false;
+ UString regPath;
+ if (key.QueryValue(NULL, regPath) != ERROR_SUCCESS)
+ return false;
+ if (!path.IsEqualTo_NoCase(regPath))
+ return false;
+ }
+
+ return
+ CheckHandlerCommon(Get_ContextMenuHandler_KeyName(k_KeyName_File), wow);
+ /*
+ && CheckHandlerCommon(Get_ContextMenuHandler_KeyName(k_KeyName_Directory), wow)
+ // && CheckHandlerCommon(Get_ContextMenuHandler_KeyName(k_KeyName_Folder))
+
+ && CheckHandlerCommon(Get_DragDropHandler_KeyName(k_KeyName_Directory), wow)
+ && CheckHandlerCommon(Get_DragDropHandler_KeyName(k_KeyName_Drive), wow);
+ */
+}
+
+
+static LONG MyCreateKey(CKey &key, HKEY parentKey, LPCTSTR keyName, UInt32 wow)
+{
+ return key.Create(parentKey, keyName, REG_NONE,
+ REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS | wow);
+}
+
+LONG SetContextMenuHandler(bool setMode, const UString &path, UInt32 wow)
+{
+ // NSynchronization::CCriticalSectionLock lock(g_CS);
+
+ INIT_REG_WOW
+
+ LONG res;
+
+ {
+ CSysString s ("CLSID\\");
+ s += k_Clsid_A;
+
+ if (setMode)
+ {
+ {
+ CKey key;
+ res = MyCreateKey(key, HKEY_CLASSES_ROOT, s, wow);
+ if (res == ERROR_SUCCESS)
+ {
+ key.SetValue(NULL, k_ShellExtName);
+ CKey keyInproc;
+ res = MyCreateKey(keyInproc, key, k_Inproc, wow);
+ if (res == ERROR_SUCCESS)
+ {
+ res = keyInproc.SetValue(NULL, path);
+ keyInproc.SetValue(TEXT("ThreadingModel"), TEXT("Apartment"));
+ }
+ }
+ }
+
+ {
+ CKey key;
+ if (MyCreateKey(key, HKEY_LOCAL_MACHINE, k_Approved, wow) == ERROR_SUCCESS)
+ key.SetValue(k_Clsid, k_ShellExtName);
+ }
+ }
+ else
+ {
+ CSysString s2 (s);
+ s2 += "\\InprocServer32";
+
+ MyRegistry_DeleteKey_HKCR(s2, wow);
+ res = MyRegistry_DeleteKey_HKCR(s, wow);
+ }
+ }
+
+ // shellex items probably are shared beween 32-bit and 64-bit apps. So we don't delete items for delete operation.
+ if (setMode)
+ for (unsigned i = 0; i < 2; i++)
+ {
+ for (unsigned k = 0; k < Z7_ARRAY_SIZE(k_shellex_Prefixes); k++)
+ {
+ CSysString s (k_shellex_Prefixes[k]);
+ s += (i == 0 ? k_KeyPostfix_ContextMenu : k_KeyPostfix_DragDrop);
+ if (k_shellex_Statuses[i][k])
+ {
+ CKey key;
+ MyCreateKey(key, HKEY_CLASSES_ROOT, s, wow);
+ key.SetValue(NULL, k_Clsid);
+ }
+ else
+ MyRegistry_DeleteKey_HKCR(s, wow);
+ }
+ }
+
+ return res;
+}
+
+#endif
diff --git a/CPP/7zip/UI/Explorer/RegistryContextMenu.h b/CPP/7zip/UI/Explorer/RegistryContextMenu.h
new file mode 100644
index 0000000..bf3bb5b
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/RegistryContextMenu.h
@@ -0,0 +1,13 @@
+// RegistryContextMenu.h
+
+#ifndef ZIP7_INC_REGISTRY_CONTEXT_MENU_H
+#define ZIP7_INC_REGISTRY_CONTEXT_MENU_H
+
+#ifndef UNDER_CE
+
+bool CheckContextMenuHandler(const UString &path, UInt32 wow = 0);
+LONG SetContextMenuHandler(bool setMode, const UString &path, UInt32 wow = 0);
+
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/Explorer/StdAfx.cpp b/CPP/7zip/UI/Explorer/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/Explorer/StdAfx.h b/CPP/7zip/UI/Explorer/StdAfx.h
new file mode 100644
index 0000000..130db8a
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/StdAfx.h
@@ -0,0 +1,6 @@
+// StdAfx.h
+
+#if _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../FileManager/StdAfx.h"
diff --git a/CPP/7zip/UI/Explorer/makefile b/CPP/7zip/UI/Explorer/makefile
new file mode 100644
index 0000000..da63a5c
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/makefile
@@ -0,0 +1,76 @@
+PROG = 7-zip.dll
+DEF_FILE = Explorer.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_LANG \
+
+!IFDEF UNDER_CE
+LIBS = $(LIBS) Commctrl.lib
+!ELSE
+LIBS = $(LIBS) htmlhelp.lib comdlg32.lib Mpr.lib Gdi32.lib
+CFLAGS = $(CFLAGS) -DZ7_LONG_PATH
+!ENDIF
+
+EXPLORER_OBJS = \
+ $O\DllExportsExplorer.obj \
+ $O\ContextMenu.obj \
+ $O\MyMessages.obj \
+
+COMMON_OBJS = \
+ $O\IntToString.obj \
+ $O\Lang.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\NewHandler.obj \
+ $O\Random.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileName.obj \
+ $O\MemoryLock.obj \
+ $O\Menu.obj \
+ $O\ProcessUtils.obj \
+ $O\Registry.obj \
+ $O\ResourceString.obj \
+ $O\Shell.obj \
+ $O\Synchronization.obj \
+ $O\Window.obj \
+
+!IFDEF UNDER_CE
+
+WIN_OBJS = $(WIN_OBJS) \
+ $O\CommonDialog.obj \
+
+!ENDIF
+
+WIN_CTRL_OBJS = \
+ $O\Dialog.obj \
+ $O\ListView.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveName.obj \
+ $O\CompressCall.obj \
+ $O\ExtractingFilePath.obj \
+ $O\ZipRegistry.obj \
+
+FM_OBJS = \
+ $O\FormatUtils.obj \
+ $O\HelpUtils.obj \
+ $O\LangUtils.obj \
+ $O\ProgramLocation.obj \
+ $O\PropertyName.obj \
+ $O\RegistryUtils.obj \
+
+C_OBJS = \
+ $O\CpuArch.obj \
+ $O\Sort.obj \
+ $O\Threads.obj \
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Explorer/resource.h b/CPP/7zip/UI/Explorer/resource.h
new file mode 100644
index 0000000..bbb28b1
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/resource.h
@@ -0,0 +1,15 @@
+#define IDS_CONTEXT_FOLDER 2320
+#define IDS_CONTEXT_ARCHIVE 2321
+#define IDS_CONTEXT_OPEN 2322
+#define IDS_CONTEXT_EXTRACT 2323
+#define IDS_CONTEXT_COMPRESS 2324
+#define IDS_CONTEXT_TEST 2325
+#define IDS_CONTEXT_EXTRACT_HERE 2326
+#define IDS_CONTEXT_EXTRACT_TO 2327
+#define IDS_CONTEXT_COMPRESS_TO 2328
+#define IDS_CONTEXT_COMPRESS_EMAIL 2329
+#define IDS_CONTEXT_COMPRESS_TO_EMAIL 2330
+
+#define IDS_SELECT_FILES 3015
+
+#define IDB_MENU_LOGO 190
diff --git a/CPP/7zip/UI/Explorer/resource.rc b/CPP/7zip/UI/Explorer/resource.rc
new file mode 100644
index 0000000..acfa6e5
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/resource.rc
@@ -0,0 +1,10 @@
+#include "../../MyVersionInfo.rc"
+#include "resource2.rc"
+
+MY_VERSION_INFO_DLL("7-Zip Shell Extension", "7-zip")
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "7-zip.dll.manifest"
+#endif
+
+IDI_ICON ICON "../FileManager/FM.ico"
diff --git a/CPP/7zip/UI/Explorer/resource2.rc b/CPP/7zip/UI/Explorer/resource2.rc
new file mode 100644
index 0000000..de34824
--- /dev/null
+++ b/CPP/7zip/UI/Explorer/resource2.rc
@@ -0,0 +1,19 @@
+#include "resource.h"
+
+STRINGTABLE
+BEGIN
+ IDS_CONTEXT_FOLDER "<Folder>"
+ IDS_CONTEXT_ARCHIVE "<Archive>"
+ IDS_CONTEXT_OPEN "Open archive"
+ IDS_CONTEXT_EXTRACT "Extract files..."
+ IDS_CONTEXT_COMPRESS "Add to archive..."
+ IDS_CONTEXT_TEST "Test archive"
+ IDS_CONTEXT_EXTRACT_HERE "Extract Here"
+ IDS_CONTEXT_EXTRACT_TO "Extract to {0}"
+ IDS_CONTEXT_COMPRESS_TO "Add to {0}"
+ IDS_CONTEXT_COMPRESS_EMAIL "Compress and email..."
+ IDS_CONTEXT_COMPRESS_TO_EMAIL "Compress to {0} and email"
+ IDS_SELECT_FILES "You must select one or more files"
+END
+
+IDB_MENU_LOGO BITMAP "../../UI/Explorer/MenuLogo.bmp"
diff --git a/CPP/7zip/UI/Far/ExtractEngine.cpp b/CPP/7zip/UI/Far/ExtractEngine.cpp
new file mode 100644
index 0000000..05e9208
--- /dev/null
+++ b/CPP/7zip/UI/Far/ExtractEngine.cpp
@@ -0,0 +1,274 @@
+// ExtractEngine.h
+
+#include "StdAfx.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "../../../Common/StringConvert.h"
+
+#include "ExtractEngine.h"
+#include "FarUtils.h"
+#include "Messages.h"
+#include "OverwriteDialogFar.h"
+
+using namespace NWindows;
+using namespace NFar;
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+
+static HRESULT CheckBreak2()
+{
+ return WasEscPressed() ? E_ABORT : S_OK;
+}
+
+extern void PrintMessage(const char *message);
+
+void CExtractCallbackImp::Init(
+ UINT codePage,
+ CProgressBox *progressBox,
+ bool passwordIsDefined,
+ const UString &password)
+{
+ m_PasswordIsDefined = passwordIsDefined;
+ m_Password = password;
+ m_CodePage = codePage;
+ _percent = progressBox;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetTotal(UInt64 size))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->Total = size;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetCompleted(const UInt64 *completeValue))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ if (completeValue)
+ _percent->Completed = *completeValue;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::AskOverwrite(
+ const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize,
+ const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize,
+ Int32 *answer))
+{
+ MT_LOCK
+
+ NOverwriteDialog::CFileInfo oldFileInfo, newFileInfo;
+ oldFileInfo.TimeIsDefined = (existTime != NULL);
+ if (oldFileInfo.TimeIsDefined)
+ oldFileInfo.Time = *existTime;
+ oldFileInfo.SizeIsDefined = (existSize != NULL);
+ if (oldFileInfo.SizeIsDefined)
+ oldFileInfo.Size = *existSize;
+ oldFileInfo.Name = existName;
+
+ newFileInfo.TimeIsDefined = (newTime != NULL);
+ if (newFileInfo.TimeIsDefined)
+ newFileInfo.Time = *newTime;
+ newFileInfo.SizeIsDefined = (newSize != NULL);
+ if (newFileInfo.SizeIsDefined)
+ newFileInfo.Size = *newSize;
+ newFileInfo.Name = newName;
+
+ NOverwriteDialog::NResult::EEnum result =
+ NOverwriteDialog::Execute(oldFileInfo, newFileInfo);
+
+ switch ((int)result)
+ {
+ case NOverwriteDialog::NResult::kCancel:
+ // *answer = NOverwriteAnswer::kCancel;
+ // break;
+ return E_ABORT;
+ case NOverwriteDialog::NResult::kNo:
+ *answer = NOverwriteAnswer::kNo;
+ break;
+ case NOverwriteDialog::NResult::kNoToAll:
+ *answer = NOverwriteAnswer::kNoToAll;
+ break;
+ case NOverwriteDialog::NResult::kYesToAll:
+ *answer = NOverwriteAnswer::kYesToAll;
+ break;
+ case NOverwriteDialog::NResult::kYes:
+ *answer = NOverwriteAnswer::kYes;
+ break;
+ case NOverwriteDialog::NResult::kAutoRename:
+ *answer = NOverwriteAnswer::kAutoRename;
+ break;
+ default:
+ return E_FAIL;
+ }
+
+ return CheckBreak2();
+}
+
+static const char * const kTestString = "Testing";
+static const char * const kExtractString = "Extracting";
+static const char * const kSkipString = "Skipping";
+static const char * const kReadString = "Reading";
+
+Z7_COM7F_IMF(CExtractCallbackImp::PrepareOperation(const wchar_t *name, Int32 /* isFolder */, Int32 askExtractMode, const UInt64 * /* position */))
+{
+ MT_LOCK
+
+ m_CurrentFilePath = name;
+ const char *s;
+
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract: s = kExtractString; break;
+ case NArchive::NExtract::NAskMode::kTest: s = kTestString; break;
+ case NArchive::NExtract::NAskMode::kSkip: s = kSkipString; break;
+ case NArchive::NExtract::NAskMode::kReadExternal: s = kReadString; break;
+ default: s = "???"; // return E_FAIL;
+ }
+
+ if (_percent)
+ {
+ _percent->Command = s;
+ _percent->FileName = name;
+ _percent->Print();
+ }
+
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::MessageError(const wchar_t *message))
+{
+ MT_LOCK
+
+ AString s (UnicodeStringToMultiByte(message, CP_OEMCP));
+ if (g_StartupInfo.ShowErrorMessage((const char *)s) == -1)
+ return E_ABORT;
+
+ return CheckBreak2();
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &s);
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &s)
+{
+ s.Empty();
+
+ switch (opRes)
+ {
+ case NArchive::NExtract::NOperationResult::kOK:
+ return;
+ default:
+ {
+ UINT messageID = 0;
+ switch (opRes)
+ {
+ case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
+ messageID = NMessageID::kExtractUnsupportedMethod;
+ break;
+ case NArchive::NExtract::NOperationResult::kCRCError:
+ messageID = encrypted ?
+ NMessageID::kExtractCRCFailedEncrypted :
+ NMessageID::kExtractCRCFailed;
+ break;
+ case NArchive::NExtract::NOperationResult::kDataError:
+ messageID = encrypted ?
+ NMessageID::kExtractDataErrorEncrypted :
+ NMessageID::kExtractDataError;
+ break;
+ }
+ if (messageID != 0)
+ {
+ s = g_StartupInfo.GetMsgString((int)messageID);
+ s.Replace((AString)" '%s'", AString());
+ }
+ else if (opRes == NArchive::NExtract::NOperationResult::kUnavailable)
+ s = "Unavailable data";
+ else if (opRes == NArchive::NExtract::NOperationResult::kUnexpectedEnd)
+ s = "Unexpected end of data";
+ else if (opRes == NArchive::NExtract::NOperationResult::kDataAfterEnd)
+ s = "There are some data after the end of the payload data";
+ else if (opRes == NArchive::NExtract::NOperationResult::kIsNotArc)
+ s = "Is not archive";
+ else if (opRes == NArchive::NExtract::NOperationResult::kHeadersError)
+ s = "kHeaders Error";
+ else if (opRes == NArchive::NExtract::NOperationResult::kWrongPassword)
+ s = "Wrong Password";
+ else
+ {
+ s = "Error #";
+ s.Add_UInt32((UInt32)opRes);
+ }
+ }
+ }
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetOperationResult(Int32 opRes, Int32 encrypted))
+{
+ MT_LOCK
+
+ if (opRes == NArchive::NExtract::NOperationResult::kOK)
+ {
+ if (_percent)
+ {
+ _percent->Command.Empty();
+ _percent->FileName.Empty();
+ _percent->Files++;
+ }
+ }
+ else
+ {
+ AString s;
+ SetExtractErrorMessage(opRes, encrypted, s);
+ if (PrintErrorMessage(s, m_CurrentFilePath) == -1)
+ return E_ABORT;
+ }
+
+ return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CExtractCallbackImp::ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name))
+{
+ MT_LOCK
+
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ AString s;
+ SetExtractErrorMessage(opRes, encrypted, s);
+ if (PrintErrorMessage(s, name) == -1)
+ return E_ABORT;
+ }
+
+ return CheckBreak2();
+}
+
+extern HRESULT GetPassword(UString &password);
+
+Z7_COM7F_IMF(CExtractCallbackImp::CryptoGetTextPassword(BSTR *password))
+{
+ MT_LOCK
+
+ if (!m_PasswordIsDefined)
+ {
+ RINOK(GetPassword(m_Password))
+ m_PasswordIsDefined = true;
+ }
+ return StringToBstr(m_Password, password);
+}
diff --git a/CPP/7zip/UI/Far/ExtractEngine.h b/CPP/7zip/UI/Far/ExtractEngine.h
new file mode 100644
index 0000000..2bee2ee
--- /dev/null
+++ b/CPP/7zip/UI/Far/ExtractEngine.h
@@ -0,0 +1,43 @@
+// ExtractEngine.h
+
+#ifndef ZIP7_INC_EXTRACT_ENGINE_H
+#define ZIP7_INC_EXTRACT_ENGINE_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyString.h"
+
+#include "../../IPassword.h"
+#include "../Agent/IFolderArchive.h"
+
+#include "ProgressBox.h"
+
+Z7_CLASS_IMP_COM_3(
+ CExtractCallbackImp
+ , IFolderArchiveExtractCallback
+ , IFolderArchiveExtractCallback2
+ , ICryptoGetTextPassword
+)
+ Z7_IFACE_COM7_IMP(IProgress)
+
+ UString m_CurrentFilePath;
+
+ CProgressBox *_percent;
+ UINT m_CodePage;
+
+ bool m_PasswordIsDefined;
+ UString m_Password;
+
+ void CreateComplexDirectory(const UStringVector &dirPathParts);
+ /*
+ void GetPropertyValue(LPITEMIDLIST anItemIDList, PROPID aPropId,
+ PROPVARIANT *aValue);
+ bool IsEncrypted(LPITEMIDLIST anItemIDList);
+ */
+ void AddErrorMessage(LPCTSTR message);
+public:
+ void Init(UINT codePage,
+ CProgressBox *progressBox,
+ bool passwordIsDefined, const UString &password);
+};
+
+#endif
diff --git a/CPP/7zip/UI/Far/Far.cpp b/CPP/7zip/UI/Far/Far.cpp
new file mode 100644
index 0000000..74d5e60
--- /dev/null
+++ b/CPP/7zip/UI/Far/Far.cpp
@@ -0,0 +1,587 @@
+// Far.cpp
+// Test Align for updating !!!!!!!!!!!!!!!!!!
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/NtCheck.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "Messages.h"
+#include "Plugin.h"
+#include "ProgressBox.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NFar;
+
+static const DWORD kShowProgressTime_ms = 100;
+
+static const char * const kCommandPrefix = "7-zip";
+static const char * const kRegisrtryMainKeyName = NULL; // ""
+static LPCTSTR const kRegisrtryValueNameEnabled = TEXT("UsedByDefault3");
+static const char * const kHelpTopicConfig = "Config";
+static bool kPluginEnabledDefault = true;
+
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance;
+
+namespace NFar {
+
+extern
+const char *g_PluginName_for_Error;
+const char *g_PluginName_for_Error = "7-Zip";
+
+}
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION return FALSE;
+#endif
+
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ hInstance, DWORD dwReason, LPVOID);
+BOOL WINAPI DllMain(
+ #ifdef UNDER_CE
+ HANDLE
+ #else
+ HINSTANCE
+ #endif
+ hInstance, DWORD dwReason, LPVOID)
+{
+ if (dwReason == DLL_PROCESS_ATTACH)
+ {
+ // OutputDebugStringA("7-Zip FAR DLL_PROCESS_ATTACH");
+ g_hInstance = (HINSTANCE)hInstance;
+ NT_CHECK
+ }
+ if (dwReason == DLL_PROCESS_DETACH)
+ {
+ // OutputDebugStringA("7-Zip FAR DLL_PROCESS_DETACH");
+ }
+ return TRUE;
+}
+
+static struct COptions
+{
+ bool Enabled;
+} g_Options;
+
+static const char * const kPliginNameForRegistry = "7-ZIP";
+
+EXTERN_C void WINAPI ExitFAR()
+{
+ /* WIN32:
+ it's not allowed to call FreeLibrary() from FreeLibrary().
+ So we try to free all DLLs before destructors */
+ // OutputDebugStringA("-- ExitFAR --- START");
+
+ FreeGlobalCodecs();
+
+ // OutputDebugStringA("-- ExitFAR --- END");
+}
+
+EXTERN_C void WINAPI SetStartupInfo(const PluginStartupInfo *info)
+{
+ MY_TRY_BEGIN
+ g_StartupInfo.Init(*info, kPliginNameForRegistry);
+ g_Options.Enabled = g_StartupInfo.QueryRegKeyValue(
+ HKEY_CURRENT_USER, kRegisrtryMainKeyName,
+ kRegisrtryValueNameEnabled, kPluginEnabledDefault);
+
+ // OutputDebugStringA("SetStartupInfo");
+ // LoadGlobalCodecs();
+
+ MY_TRY_END1("SetStartupInfo")
+}
+
+Z7_CLASS_IMP_COM_3(
+ COpenArchiveCallback
+ , IArchiveOpenCallback
+ , IProgress
+ , ICryptoGetTextPassword
+)
+ // DWORD m_StartTickValue;
+ bool m_MessageBoxIsShown;
+
+ CProgressBox _progressBox;
+
+ bool _numFilesTotalDefined;
+ bool _numBytesTotalDefined;
+
+public:
+ bool PasswordIsDefined;
+ UString Password;
+
+ COpenArchiveCallback()
+ {}
+
+ void Init()
+ {
+ PasswordIsDefined = false;
+
+ _numFilesTotalDefined = false;
+ _numBytesTotalDefined = false;
+
+ m_MessageBoxIsShown = false;
+
+ _progressBox.Init(
+ // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kReading));
+ }
+ void ShowMessage();
+};
+
+static HRESULT CheckBreak2()
+{
+ return WasEscPressed() ? E_ABORT : S_OK;
+}
+
+void COpenArchiveCallback::ShowMessage()
+{
+ if (!m_MessageBoxIsShown)
+ {
+ DWORD currentTime = GetTickCount();
+ if (currentTime - _progressBox.StartTick < kShowProgressTime_ms)
+ return;
+ m_MessageBoxIsShown = true;
+ }
+
+ _progressBox.UseBytesForPercents = !_numFilesTotalDefined;
+ _progressBox.Print();
+}
+
+Z7_COM7F_IMF(COpenArchiveCallback::SetTotal(const UInt64 *numFiles, const UInt64 *numBytes))
+{
+ _numFilesTotalDefined = (numFiles != NULL);
+ if (_numFilesTotalDefined)
+ _progressBox.FilesTotal = *numFiles;
+
+ _numBytesTotalDefined = (numBytes != NULL);
+ if (_numBytesTotalDefined)
+ _progressBox.Total = *numBytes;
+
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(COpenArchiveCallback::SetCompleted(const UInt64 *numFiles, const UInt64 *numBytes))
+{
+ if (numFiles)
+ _progressBox.Files = *numFiles;
+
+ if (numBytes)
+ _progressBox.Completed = *numBytes;
+
+ ShowMessage();
+ return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(COpenArchiveCallback::SetTotal(const UInt64 /* total */))
+{
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(COpenArchiveCallback::SetCompleted(const UInt64 * /* completed */))
+{
+ ShowMessage();
+ return CheckBreak2();
+}
+
+HRESULT GetPassword(UString &password);
+HRESULT GetPassword(UString &password)
+{
+ if (WasEscPressed())
+ return E_ABORT;
+ password.Empty();
+ CInitDialogItem initItems[]=
+ {
+ { DI_DOUBLEBOX, 3, 1, 72, 4, false, false, 0, false, NMessageID::kGetPasswordTitle, NULL, NULL },
+ { DI_TEXT, 5, 2, 0, 0, false, false, DIF_SHOWAMPERSAND, false, NMessageID::kEnterPasswordForFile, NULL, NULL },
+ { DI_PSWEDIT, 5, 3, 70, 3, true, false, 0, true, -1, "", NULL }
+ };
+
+ const int kNumItems = Z7_ARRAY_SIZE(initItems);
+ FarDialogItem dialogItems[kNumItems];
+ g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumItems);
+
+ // sprintf(DialogItems[1].Data,GetMsg(MGetPasswordForFile),FileName);
+ if (g_StartupInfo.ShowDialog(76, 6, NULL, dialogItems, kNumItems) < 0)
+ return E_ABORT;
+
+ password = MultiByteToUnicodeString(dialogItems[2].Data, CP_OEMCP);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(COpenArchiveCallback::CryptoGetTextPassword(BSTR *password))
+{
+ if (!PasswordIsDefined)
+ {
+ RINOK(GetPassword(Password))
+ PasswordIsDefined = true;
+ }
+ return StringToBstr(Password, password);
+}
+
+/*
+HRESULT OpenArchive(const CSysString &fileName,
+ IInFolderArchive **archiveHandlerResult,
+ CArchiverInfo &archiverInfoResult,
+ UString &defaultName,
+ IArchiveOpenCallback *openArchiveCallback)
+{
+ HRESULT OpenArchive(const CSysString &fileName,
+ IInArchive **archive,
+ CArchiverInfo &archiverInfoResult,
+ IArchiveOpenCallback *openArchiveCallback);
+}
+*/
+
+static HANDLE MyOpenFilePluginW(const wchar_t *name, bool isAbortCodeSupported)
+{
+ FString normalizedName = us2fs(name);
+ normalizedName.Trim();
+ FString fullName;
+ MyGetFullPathName(normalizedName, fullName);
+ NFind::CFileInfo fileInfo;
+ if (!fileInfo.Find(fullName))
+ return INVALID_HANDLE_VALUE;
+ if (fileInfo.IsDir())
+ return INVALID_HANDLE_VALUE;
+
+
+ CMyComPtr<IInFolderArchive> archiveHandler;
+
+ // CArchiverInfo archiverInfoResult;
+ // ::OutputDebugStringA("before OpenArchive\n");
+
+ CScreenRestorer screenRestorer;
+ {
+ screenRestorer.Save();
+ }
+
+ COpenArchiveCallback *openArchiveCallbackSpec = new COpenArchiveCallback;
+ CMyComPtr<IArchiveOpenCallback> uiCallback = openArchiveCallbackSpec;
+
+ /* COpenCallbackImp object will exist after Open stage for multivolume archioves */
+ COpenCallbackImp *impSpec = new COpenCallbackImp;
+ CMyComPtr<IArchiveOpenCallback> impCallback = impSpec;
+ impSpec->ReOpenCallback = openArchiveCallbackSpec; // we set pointer without reference counter
+
+ // if ((opMode & OPM_SILENT) == 0 && (opMode & OPM_FIND ) == 0)
+ openArchiveCallbackSpec->Init();
+ {
+ FString dirPrefix, fileName;
+ GetFullPathAndSplit(fullName, dirPrefix, fileName);
+ impSpec->Init2(dirPrefix, fileName);
+ }
+
+ // ::OutputDebugStringA("before OpenArchive\n");
+
+ CAgent *agent = new CAgent;
+ archiveHandler = agent;
+ CMyComBSTR archiveType;
+ HRESULT result = archiveHandler->Open(NULL,
+ GetUnicodeString(fullName, CP_OEMCP), UString(), &archiveType, impCallback);
+ /*
+ HRESULT result = ::OpenArchive(fullName, &archiveHandler,
+ archiverInfoResult, defaultName, openArchiveCallback);
+ */
+ if (result == E_ABORT)
+ {
+ // fixed 18.06:
+ // OpenFilePlugin() is allowed to return (HANDLE)-2 as abort code
+ // OpenPlugin() is not allowed to return (HANDLE)-2.
+ return isAbortCodeSupported ? (HANDLE)-2 : INVALID_HANDLE_VALUE;
+ }
+
+ UString errorMessage = agent->GetErrorMessage();
+ if (!errorMessage.IsEmpty())
+ g_StartupInfo.ShowErrorMessage(UnicodeStringToMultiByte(errorMessage, CP_OEMCP));
+
+ if (result != S_OK)
+ {
+ if (result == S_FALSE)
+ return INVALID_HANDLE_VALUE;
+ ShowSysErrorMessage(result);
+ return INVALID_HANDLE_VALUE;
+ }
+
+ // ::OutputDebugStringA("after OpenArchive\n");
+
+ CPlugin *plugin = new CPlugin(
+ fullName,
+ // defaultName,
+ agent,
+ (const wchar_t *)archiveType
+ );
+
+ plugin->PasswordIsDefined = openArchiveCallbackSpec->PasswordIsDefined;
+ plugin->Password = openArchiveCallbackSpec->Password;
+
+ // OutputDebugStringA("--- OpenFilePlugin ---- END");
+ return (HANDLE)(plugin);
+}
+
+static HANDLE MyOpenFilePlugin(const char *name, bool isAbortCodeSupported)
+{
+ UINT codePage =
+ #ifdef UNDER_CE
+ CP_OEMCP;
+ #else
+ ::AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+ #endif
+ return MyOpenFilePluginW(GetUnicodeString(name, codePage), isAbortCodeSupported);
+}
+
+EXTERN_C HANDLE WINAPI OpenFilePlugin(char *name, const unsigned char * /* data */, int /* dataSize */)
+{
+ MY_TRY_BEGIN
+ // OutputDebugStringA("--- OpenFilePlugin");
+ if (name == NULL || (!g_Options.Enabled))
+ {
+ // if (!Opt.ProcessShiftF1)
+ return(INVALID_HANDLE_VALUE);
+ }
+ return MyOpenFilePlugin(name, true); // isAbortCodeSupported
+ MY_TRY_END2("OpenFilePlugin", INVALID_HANDLE_VALUE)
+}
+
+/*
+EXTERN_C HANDLE WINAPI OpenFilePluginW(const wchar_t *name,const unsigned char *Data,int DataSize,int OpMode)
+{
+ MY_TRY_BEGIN
+ if (name == NULL || (!g_Options.Enabled))
+ {
+ // if (!Opt.ProcessShiftF1)
+ return(INVALID_HANDLE_VALUE);
+ }
+ return MyOpenFilePluginW(name);
+ ::OutputDebugStringA("OpenFilePluginW\n");
+ MY_TRY_END2("OpenFilePluginW", INVALID_HANDLE_VALUE);
+}
+*/
+
+EXTERN_C HANDLE WINAPI OpenPlugin(int openFrom, INT_PTR item)
+{
+ MY_TRY_BEGIN
+
+ if (openFrom == OPEN_COMMANDLINE)
+ {
+ AString fileName ((const char *)item);
+ if (fileName.IsEmpty())
+ return INVALID_HANDLE_VALUE;
+ if (fileName.Len() >= 2
+ && fileName[0] == '\"'
+ && fileName.Back() == '\"')
+ {
+ fileName.DeleteBack();
+ fileName.DeleteFrontal(1);
+ }
+ return MyOpenFilePlugin(fileName, false); // isAbortCodeSupported
+ }
+
+ if (openFrom == OPEN_PLUGINSMENU)
+ {
+ switch (item)
+ {
+ case 0:
+ {
+ PluginPanelItem pluginPanelItem;
+ if (!g_StartupInfo.ControlGetActivePanelCurrentItemInfo(pluginPanelItem))
+ throw 142134;
+ return MyOpenFilePlugin(pluginPanelItem.FindData.cFileName, false); // isAbortCodeSupported
+ }
+
+ case 1:
+ {
+ CObjectVector<PluginPanelItem> pluginPanelItem;
+ if (!g_StartupInfo.ControlGetActivePanelSelectedOrCurrentItems(pluginPanelItem))
+ throw 142134;
+ HRESULT res = CompressFiles(pluginPanelItem);
+ if (res != S_OK && res != E_ABORT)
+ {
+ ShowSysErrorMessage(res);
+ }
+ // if (res == S_OK)
+ {
+ /* int t = */ g_StartupInfo.ControlClearPanelSelection();
+ g_StartupInfo.ControlRequestActivePanel(FCTL_UPDATEPANEL, NULL);
+ g_StartupInfo.ControlRequestActivePanel(FCTL_REDRAWPANEL, NULL);
+ g_StartupInfo.ControlRequestActivePanel(FCTL_UPDATEANOTHERPANEL, NULL);
+ g_StartupInfo.ControlRequestActivePanel(FCTL_REDRAWANOTHERPANEL, NULL);
+ }
+ return INVALID_HANDLE_VALUE;
+ }
+
+ default:
+ throw 4282215;
+ }
+ }
+
+ return INVALID_HANDLE_VALUE;
+ MY_TRY_END2("OpenPlugin", INVALID_HANDLE_VALUE)
+}
+
+EXTERN_C void WINAPI ClosePlugin(HANDLE plugin)
+{
+ // OutputDebugStringA("-- ClosePlugin --- START");
+ // MY_TRY_BEGIN
+ delete (CPlugin *)plugin;
+ // OutputDebugStringA("-- ClosePlugin --- END");
+ // MY_TRY_END1("ClosePlugin");
+}
+
+EXTERN_C int WINAPI GetFindData(HANDLE plugin, struct PluginPanelItem **panelItems, int *itemsNumber, int opMode)
+{
+ MY_TRY_BEGIN
+ return(((CPlugin *)plugin)->GetFindData(panelItems, itemsNumber, opMode));
+ MY_TRY_END2("GetFindData", FALSE)
+}
+
+EXTERN_C void WINAPI FreeFindData(HANDLE plugin, struct PluginPanelItem *panelItems, int itemsNumber)
+{
+ // MY_TRY_BEGIN
+ ((CPlugin *)plugin)->FreeFindData(panelItems, itemsNumber);
+ // MY_TRY_END1("FreeFindData");
+}
+
+EXTERN_C int WINAPI GetFiles(HANDLE plugin, struct PluginPanelItem *panelItems,
+ int itemsNumber, int move, char *destPath, int opMode)
+{
+ MY_TRY_BEGIN
+ return(((CPlugin *)plugin)->GetFiles(panelItems, (unsigned)itemsNumber, move, destPath, opMode));
+ MY_TRY_END2("GetFiles", NFileOperationReturnCode::kError)
+}
+
+EXTERN_C int WINAPI SetDirectory(HANDLE plugin, const char *dir, int opMode)
+{
+ MY_TRY_BEGIN
+ return(((CPlugin *)plugin)->SetDirectory(dir, opMode));
+ MY_TRY_END2("SetDirectory", FALSE)
+}
+
+EXTERN_C void WINAPI GetPluginInfo(struct PluginInfo *info)
+{
+ MY_TRY_BEGIN
+
+ info->StructSize = sizeof(*info);
+ info->Flags = 0;
+ info->DiskMenuStrings = NULL;
+ info->DiskMenuNumbers = NULL;
+ info->DiskMenuStringsNumber = 0;
+ static char *pluginMenuStrings[2];
+ pluginMenuStrings[0] = const_cast<char *>(g_StartupInfo.GetMsgString(NMessageID::kOpenArchiveMenuString));
+ pluginMenuStrings[1] = const_cast<char *>(g_StartupInfo.GetMsgString(NMessageID::kCreateArchiveMenuString));
+ info->PluginMenuStrings = (char **)pluginMenuStrings;
+ info->PluginMenuStringsNumber = 2;
+ static char *pluginCfgStrings[1];
+ pluginCfgStrings[0] = const_cast<char *>(g_StartupInfo.GetMsgString(NMessageID::kOpenArchiveMenuString));
+ info->PluginConfigStrings = (char **)pluginCfgStrings;
+ info->PluginConfigStringsNumber = Z7_ARRAY_SIZE(pluginCfgStrings);
+ info->CommandPrefix = const_cast<char *>(kCommandPrefix);
+ MY_TRY_END1("GetPluginInfo")
+}
+
+EXTERN_C int WINAPI Configure(int /* itemNumber */)
+{
+ MY_TRY_BEGIN
+
+ const int kEnabledCheckBoxIndex = 1;
+
+ const int kYSize = 7;
+
+ struct CInitDialogItem initItems[]=
+ {
+ { DI_DOUBLEBOX, 3, 1, 72, kYSize - 2, false, false, 0, false, NMessageID::kConfigTitle, NULL, NULL },
+ { DI_CHECKBOX, 5, 2, 0, 0, true, g_Options.Enabled, 0, false, NMessageID::kConfigPluginEnabled, NULL, NULL },
+ { DI_TEXT, 5, 3, 0, 0, false, false, DIF_BOXCOLOR | DIF_SEPARATOR, false, -1, "", NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, true, NMessageID::kOk, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kCancel, NULL, NULL },
+ };
+
+ const int kNumDialogItems = Z7_ARRAY_SIZE(initItems);
+ const int kOkButtonIndex = kNumDialogItems - 2;
+
+ FarDialogItem dialogItems[kNumDialogItems];
+ g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumDialogItems);
+
+ int askCode = g_StartupInfo.ShowDialog(76, kYSize,
+ kHelpTopicConfig, dialogItems, kNumDialogItems);
+
+ if (askCode != kOkButtonIndex)
+ return (FALSE);
+
+ g_Options.Enabled = BOOLToBool(dialogItems[kEnabledCheckBoxIndex].Selected);
+
+ g_StartupInfo.SetRegKeyValue(HKEY_CURRENT_USER, kRegisrtryMainKeyName,
+ kRegisrtryValueNameEnabled, g_Options.Enabled);
+ return(TRUE);
+ MY_TRY_END2("Configure", FALSE)
+}
+
+EXTERN_C void WINAPI GetOpenPluginInfo(HANDLE plugin,struct OpenPluginInfo *info)
+{
+ MY_TRY_BEGIN
+ ((CPlugin *)plugin)->GetOpenPluginInfo(info);
+ MY_TRY_END1("GetOpenPluginInfo")
+}
+
+EXTERN_C int WINAPI PutFiles(HANDLE plugin, struct PluginPanelItem *panelItems, int itemsNumber, int move, int opMode)
+{
+ MY_TRY_BEGIN
+ return (((CPlugin *)plugin)->PutFiles(panelItems, (unsigned)itemsNumber, move, opMode));
+ MY_TRY_END2("PutFiles", NFileOperationReturnCode::kError)
+}
+
+EXTERN_C int WINAPI DeleteFiles(HANDLE plugin, PluginPanelItem *panelItems, int itemsNumber, int opMode)
+{
+ MY_TRY_BEGIN
+ return (((CPlugin *)plugin)->DeleteFiles(panelItems, (unsigned)itemsNumber, opMode));
+ MY_TRY_END2("DeleteFiles", FALSE)
+}
+
+EXTERN_C int WINAPI ProcessKey(HANDLE plugin, int key, unsigned int controlState)
+{
+ MY_TRY_BEGIN
+ /* FIXME: after folder creation with F7, it doesn't reload new file list
+ We need some to reload it */
+ return (((CPlugin *)plugin)->ProcessKey(key, controlState));
+ MY_TRY_END2("ProcessKey", FALSE)
+}
+
+/*
+struct MakeDirectoryInfo
+{
+ size_t StructSize;
+ HANDLE hPanel;
+ const wchar_t *Name;
+ OPERATION_MODES OpMode;
+ void* Instance;
+};
+
+typedef INT_PTR MY_intptr_t;
+
+MY_intptr_t WINAPI MakeDirectoryW(struct MakeDirectoryInfo *Info)
+{
+ MY_TRY_BEGIN
+ if (Info->StructSize < sizeof(MakeDirectoryInfo))
+ {
+ return 0;
+ }
+ return 0;
+ MY_TRY_END2("MakeDirectoryW", FALSE);
+}
+*/
diff --git a/CPP/7zip/UI/Far/Far.def b/CPP/7zip/UI/Far/Far.def
new file mode 100644
index 0000000..1de9acd
--- /dev/null
+++ b/CPP/7zip/UI/Far/Far.def
@@ -0,0 +1,35 @@
+; 7-ZipFar.def : Declares the module parameters for the DLL.
+
+LIBRARY "7-ZipFar"
+
+EXPORTS
+ ExitFAR
+ SetStartupInfo
+ OpenPlugin
+ OpenFilePlugin
+ ClosePlugin
+ GetFindData
+ FreeFindData
+ SetDirectory
+ GetPluginInfo
+ Configure
+ GetOpenPluginInfo
+ GetFiles
+ PutFiles
+ DeleteFiles
+ ProcessKey
+
+ ;SetStartupInfoW
+ ;OpenPluginW
+ ;OpenFilePluginW
+ ;ClosePluginW
+ ;GetFindDataW
+ ;FreeFindDataW
+ ;SetDirectoryW
+ ;GetPluginInfoW
+ ;ConfigureW
+ ;GetOpenPluginInfoW
+ ;GetFilesW
+ ;PutFilesW
+ ;DeleteFilesW
+ ;ProcessKeyW
diff --git a/CPP/7zip/UI/Far/Far.dsp b/CPP/7zip/UI/Far/Far.dsp
new file mode 100644
index 0000000..823c728
--- /dev/null
+++ b/CPP/7zip/UI/Far/Far.dsp
@@ -0,0 +1,831 @@
+# Microsoft Developer Studio Project File - Name="Far" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=Far - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Far.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Far.mak" CFG="Far - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Far - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "Far - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Far - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FAR_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FAR_EXPORTS" /D "Z7_EXTERNAL_CODECS" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"C:\Progs\Far\Plugins\7-Zip\7-ZipFar.dll" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "Far - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FAR_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MTd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "FAR_EXPORTS" /D "Z7_EXTERNAL_CODECS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"C:\Progs\Far\Plugins\7-Zip\7-ZipFar.dll" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "Far - Win32 Release"
+# Name "Far - Win32 Debug"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Far.def
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "Plugin"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ExtractEngine.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractEngine.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Far.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Messages.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\OverwriteDialogFar.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\OverwriteDialogFar.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Plugin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Plugin.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginDelete.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginRead.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginWrite.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackFar.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackFar.h
+# End Source File
+# End Group
+# Begin Group "Far"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\FarPlugin.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FarUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FarUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgressBox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgressBox.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HandlerLoader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "Agent"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Agent\Agent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\Agent.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentProxy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentProxy.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolderOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\IFolderArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\UpdateCallbackAgent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\UpdateCallbackAgent.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# End Group
+# Begin Group "7-zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Arc Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\IFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/Far/Far.dsw b/CPP/7zip/UI/Far/Far.dsw
new file mode 100644
index 0000000..f4ef080
--- /dev/null
+++ b/CPP/7zip/UI/Far/Far.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Far"=.\Far.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/Far/FarPlugin.h b/CPP/7zip/UI/Far/FarPlugin.h
new file mode 100644
index 0000000..ad3ed38
--- /dev/null
+++ b/CPP/7zip/UI/Far/FarPlugin.h
@@ -0,0 +1,560 @@
+// FarPlugin.h
+
+// #include "plugin.hpp"
+
+const int kInfoPanelLineSize = 80;
+
+// #define __FAR_PLUGIN_H
+
+#ifdef UNDER_CE
+typedef struct _CHAR_INFO {
+ union {
+ WCHAR UnicodeChar;
+ CHAR AsciiChar;
+ } Char;
+ WORD Attributes;
+} CHAR_INFO, *PCHAR_INFO;
+#endif
+
+#ifndef ZIP7_INC_FAR_PLUGIN_H
+#define ZIP7_INC_FAR_PLUGIN_H
+
+#ifndef _WIN64
+#if defined(__BORLANDC__) && (__BORLANDC <= 0x520)
+ #pragma option -a1
+#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100))
+ #pragma pack(1)
+#else
+ #pragma pack(push,1)
+#endif
+#endif
+
+ #if _MSC_VER
+ #define _export
+ #endif
+
+#define NM 260
+
+struct FarFindData
+{
+ DWORD dwFileAttributes;
+ FILETIME ftCreationTime;
+ FILETIME ftLastAccessTime;
+ FILETIME ftLastWriteTime;
+ DWORD nFileSizeHigh;
+ DWORD nFileSizeLow;
+ DWORD dwReserved0;
+ DWORD dwReserved1;
+ char cFileName[ MAX_PATH ];
+ char cAlternateFileName[ 14 ];
+};
+
+struct PluginPanelItem
+{
+ FarFindData FindData;
+ DWORD PackSizeHigh;
+ DWORD PackSize;
+ DWORD Flags;
+ DWORD NumberOfLinks;
+ char *Description;
+ char *Owner;
+ char **CustomColumnData;
+ int CustomColumnNumber;
+ DWORD_PTR UserData;
+ DWORD CRC32;
+ DWORD_PTR Reserved[2];
+};
+
+#define PPIF_PROCESSDESCR 0x80000000
+#define PPIF_SELECTED 0x40000000
+#define PPIF_USERDATA 0x20000000
+
+enum {
+ FMENU_SHOWAMPERSAND=1,
+ FMENU_WRAPMODE=2,
+ FMENU_AUTOHIGHLIGHT=4,
+ FMENU_REVERSEAUTOHIGHLIGHT=8
+};
+
+
+typedef int (WINAPI *FARAPIMENU)(
+ INT_PTR PluginNumber,
+ int X,
+ int Y,
+ int MaxHeight,
+ unsigned int Flags,
+ char *Title,
+ char *Bottom,
+ char *HelpTopic,
+ int *BreakKeys,
+ int *BreakCode,
+ struct FarMenuItem *Item,
+ int ItemsNumber
+);
+
+typedef int (WINAPI *FARAPIDIALOG)(
+ INT_PTR PluginNumber,
+ int X1,
+ int Y1,
+ int X2,
+ int Y2,
+ char *HelpTopic,
+ struct FarDialogItem *Item,
+ int ItemsNumber
+);
+
+enum {
+ FMSG_WARNING = 0x00000001,
+ FMSG_ERRORTYPE = 0x00000002,
+ FMSG_KEEPBACKGROUND = 0x00000004,
+ FMSG_DOWN = 0x00000008,
+ FMSG_LEFTALIGN = 0x00000010,
+
+ FMSG_ALLINONE = 0x00000020,
+
+ FMSG_MB_OK = 0x00010000,
+ FMSG_MB_OKCANCEL = 0x00020000,
+ FMSG_MB_ABORTRETRYIGNORE = 0x00030000,
+ FMSG_MB_YESNO = 0x00040000,
+ FMSG_MB_YESNOCANCEL = 0x00050000,
+ FMSG_MB_RETRYCANCEL = 0x00060000
+};
+
+typedef int (WINAPI *FARAPIMESSAGE)(
+ INT_PTR PluginNumber,
+ unsigned int Flags,
+ const char *HelpTopic,
+ const char * const *Items,
+ int ItemsNumber,
+ int ButtonsNumber
+);
+
+typedef char* (WINAPI *FARAPIGETMSG)(
+ INT_PTR PluginNumber,
+ int MsgId
+);
+
+
+enum DialogItemTypes {
+ DI_TEXT,
+ DI_VTEXT,
+ DI_SINGLEBOX,
+ DI_DOUBLEBOX,
+ DI_EDIT,
+ DI_PSWEDIT,
+ DI_FIXEDIT,
+ DI_BUTTON,
+ DI_CHECKBOX,
+ DI_RADIOBUTTON
+};
+
+enum FarDialogItemFlags {
+ DIF_COLORMASK = 0xff,
+ DIF_SETCOLOR = 0x100,
+ DIF_BOXCOLOR = 0x200,
+ DIF_GROUP = 0x400,
+ DIF_LEFTTEXT = 0x800,
+ DIF_MOVESELECT = 0x1000,
+ DIF_SHOWAMPERSAND = 0x2000,
+ DIF_CENTERGROUP = 0x4000,
+ DIF_NOBRACKETS = 0x8000,
+ DIF_SEPARATOR = 0x10000,
+ DIF_EDITOR = 0x20000,
+ DIF_HISTORY = 0x40000
+};
+
+struct FarDialogItem
+{
+ int Type;
+ int X1,Y1,X2,Y2;
+ int Focus;
+ union
+ {
+ int Selected;
+ const char *History;
+ const char *Mask;
+ struct FarList *ListItems;
+ int ListPos;
+ CHAR_INFO *VBuf;
+ };
+ unsigned int Flags;
+ int DefaultButton;
+ char Data[512];
+};
+
+
+struct FarMenuItem
+{
+ char Text[128];
+ int Selected;
+ int Checked;
+ int Separator;
+};
+
+
+enum {FCTL_CLOSEPLUGIN,FCTL_GETPANELINFO,FCTL_GETANOTHERPANELINFO,
+ FCTL_UPDATEPANEL,FCTL_UPDATEANOTHERPANEL,
+ FCTL_REDRAWPANEL,FCTL_REDRAWANOTHERPANEL,
+ FCTL_SETANOTHERPANELDIR,FCTL_GETCMDLINE,FCTL_SETCMDLINE,
+ FCTL_SETSELECTION,FCTL_SETANOTHERSELECTION,
+ FCTL_SETVIEWMODE,FCTL_SETANOTHERVIEWMODE,FCTL_INSERTCMDLINE,
+ FCTL_SETUSERSCREEN,FCTL_SETPANELDIR,FCTL_SETCMDLINEPOS,
+ FCTL_GETCMDLINEPOS
+};
+
+enum {PTYPE_FILEPANEL,PTYPE_TREEPANEL,PTYPE_QVIEWPANEL,PTYPE_INFOPANEL};
+
+struct PanelInfo
+{
+ int PanelType;
+ int Plugin;
+ RECT PanelRect;
+ struct PluginPanelItem *PanelItems;
+ int ItemsNumber;
+ struct PluginPanelItem *SelectedItems;
+ int SelectedItemsNumber;
+ int CurrentItem;
+ int TopPanelItem;
+ int Visible;
+ int Focus;
+ int ViewMode;
+ char ColumnTypes[80];
+ char ColumnWidths[80];
+ char CurDir[NM];
+ int ShortNames;
+ int SortMode;
+ DWORD Flags;
+ DWORD Reserved;
+};
+
+
+struct PanelRedrawInfo
+{
+ int CurrentItem;
+ int TopPanelItem;
+};
+
+
+typedef int (WINAPI *FARAPICONTROL)(
+ HANDLE hPlugin,
+ int Command,
+ void *Param
+);
+
+typedef HANDLE (WINAPI *FARAPISAVESCREEN)(int X1,int Y1,int X2,int Y2);
+
+typedef void (WINAPI *FARAPIRESTORESCREEN)(HANDLE hScreen);
+
+typedef int (WINAPI *FARAPIGETDIRLIST)(
+ char *Dir,
+ struct PluginPanelItem **pPanelItem,
+ int *pItemsNumber
+);
+
+typedef int (WINAPI *FARAPIGETPLUGINDIRLIST)(
+ INT_PTR PluginNumber,
+ HANDLE hPlugin,
+ char *Dir,
+ struct PluginPanelItem **pPanelItem,
+ int *pItemsNumber
+);
+
+typedef void (WINAPI *FARAPIFREEDIRLIST)(struct PluginPanelItem *PanelItem);
+
+enum VIEWER_FLAGS {
+ VF_NONMODAL=1,VF_DELETEONCLOSE=2
+};
+
+typedef int (WINAPI *FARAPIVIEWER)(
+ char *FileName,
+ char *Title,
+ int X1,
+ int Y1,
+ int X2,
+ int Y2,
+ DWORD Flags
+);
+
+typedef int (WINAPI *FARAPIEDITOR)(
+ char *FileName,
+ char *Title,
+ int X1,
+ int Y1,
+ int X2,
+ int Y2,
+ DWORD Flags,
+ int StartLine,
+ int StartChar
+);
+
+typedef int (WINAPI *FARAPICMPNAME)(
+ char *Pattern,
+ char *String,
+ int SkipPath
+);
+
+
+#define FCT_DETECT 0x40000000
+
+struct CharTableSet
+{
+ char DecodeTable[256];
+ char EncodeTable[256];
+ char UpperTable[256];
+ char LowerTable[256];
+ char TableName[128];
+};
+
+typedef int (WINAPI *FARAPICHARTABLE)(
+ int Command,
+ char *Buffer,
+ int BufferSize
+);
+
+typedef void (WINAPI *FARAPITEXT)(
+ int X,
+ int Y,
+ int Color,
+ char *Str
+);
+
+
+typedef int (WINAPI *FARAPIEDITORCONTROL)(
+ int Command,
+ void *Param
+);
+
+struct PluginStartupInfo
+{
+ int StructSize;
+ char ModuleName[NM];
+ INT_PTR ModuleNumber;
+ char *RootKey;
+ FARAPIMENU Menu;
+ FARAPIDIALOG Dialog;
+ FARAPIMESSAGE Message;
+ FARAPIGETMSG GetMsg;
+ FARAPICONTROL Control;
+ FARAPISAVESCREEN SaveScreen;
+ FARAPIRESTORESCREEN RestoreScreen;
+ FARAPIGETDIRLIST GetDirList;
+ FARAPIGETPLUGINDIRLIST GetPluginDirList;
+ FARAPIFREEDIRLIST FreeDirList;
+ FARAPIVIEWER Viewer;
+ FARAPIEDITOR Editor;
+ FARAPICMPNAME CmpName;
+ FARAPICHARTABLE CharTable;
+ FARAPITEXT Text;
+ FARAPIEDITORCONTROL EditorControl;
+};
+
+
+enum PLUGIN_FLAGS {
+ PF_PRELOAD = 0x0001,
+ PF_DISABLEPANELS = 0x0002,
+ PF_EDITOR = 0x0004,
+ PF_VIEWER = 0x0008
+};
+
+
+struct PluginInfo
+{
+ int StructSize;
+ DWORD Flags;
+ char **DiskMenuStrings;
+ int *DiskMenuNumbers;
+ int DiskMenuStringsNumber;
+ char **PluginMenuStrings;
+ int PluginMenuStringsNumber;
+ char **PluginConfigStrings;
+ int PluginConfigStringsNumber;
+ char *CommandPrefix;
+};
+
+struct InfoPanelLine
+{
+ char Text[kInfoPanelLineSize];
+ char Data[kInfoPanelLineSize];
+ int Separator;
+};
+
+
+struct PanelMode
+{
+ char *ColumnTypes;
+ char *ColumnWidths;
+ char **ColumnTitles;
+ int FullScreen;
+ int DetailedStatus;
+ int AlignExtensions;
+ int CaseConversion;
+ char *StatusColumnTypes;
+ char *StatusColumnWidths;
+ DWORD Reserved[2];
+};
+
+
+enum OPENPLUGININFO_FLAGS {
+ OPIF_USEFILTER = 0x0001,
+ OPIF_USESORTGROUPS = 0x0002,
+ OPIF_USEHIGHLIGHTING = 0x0004,
+ OPIF_ADDDOTS = 0x0008,
+ OPIF_RAWSELECTION = 0x0010,
+ OPIF_REALNAMES = 0x0020,
+ OPIF_SHOWNAMESONLY = 0x0040,
+ OPIF_SHOWRIGHTALIGNNAMES = 0x0080,
+ OPIF_SHOWPRESERVECASE = 0x0100,
+ OPIF_FINDFOLDERS = 0x0200,
+ OPIF_COMPAREFATTIME = 0x0400,
+ OPIF_EXTERNALGET = 0x0800,
+ OPIF_EXTERNALPUT = 0x1000,
+ OPIF_EXTERNALDELETE = 0x2000,
+ OPIF_EXTERNALMKDIR = 0x4000,
+ OPIF_USEATTRHIGHLIGHTING = 0x8000
+};
+
+
+enum OPENPLUGININFO_SORTMODES {
+ SM_DEFAULT,SM_UNSORTED,SM_NAME,SM_EXT,SM_MTIME,SM_CTIME,
+ SM_ATIME,SM_SIZE,SM_DESCR,SM_OWNER,SM_COMPRESSEDSIZE,SM_NUMLINKS
+};
+
+
+struct KeyBarTitles
+{
+ char *Titles[12];
+ char *CtrlTitles[12];
+ char *AltTitles[12];
+ char *ShiftTitles[12];
+};
+
+
+struct OpenPluginInfo
+{
+ int StructSize;
+ DWORD Flags;
+ const char *HostFile;
+ const char *CurDir;
+ const char *Format;
+ const char *PanelTitle;
+ const struct InfoPanelLine *InfoLines;
+ int InfoLinesNumber;
+ const char * const *DescrFiles;
+ int DescrFilesNumber;
+ const struct PanelMode *PanelModesArray;
+ int PanelModesNumber;
+ int StartPanelMode;
+ int StartSortMode;
+ int StartSortOrder;
+ const struct KeyBarTitles *KeyBar;
+ const char *ShortcutData;
+ // long Reserverd;
+};
+
+enum {
+ OPEN_DISKMENU,
+ OPEN_PLUGINSMENU,
+ OPEN_FINDLIST,
+ OPEN_SHORTCUT,
+ OPEN_COMMANDLINE,
+ OPEN_EDITOR,
+ OPEN_VIEWER
+};
+
+enum {PKF_CONTROL=1,PKF_ALT=2,PKF_SHIFT=4};
+
+enum FAR_EVENTS {
+ FE_CHANGEVIEWMODE,
+ FE_REDRAW,
+ FE_IDLE,
+ FE_CLOSE,
+ FE_BREAK,
+ FE_COMMAND
+};
+
+enum OPERATION_MODES {
+ OPM_SILENT=1,
+ OPM_FIND=2,
+ OPM_VIEW=4,
+ OPM_EDIT=8,
+ OPM_TOPLEVEL=16,
+ OPM_DESCR=32
+};
+
+#ifndef _WIN64
+#if defined(__BORLANDC__) && (__BORLANDC <= 0x520)
+ #pragma option -a.
+#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100))
+ #pragma pack()
+#else
+ #pragma pack(pop)
+#endif
+#endif
+
+/*
+EXTERN_C_BEGIN
+
+ void WINAPI _export ClosePluginW(HANDLE hPlugin);
+ int WINAPI _export CompareW(HANDLE hPlugin,const struct PluginPanelItem *Item1,const struct PluginPanelItem *Item2,unsigned int Mode);
+ int WINAPI _export ConfigureW(int ItemNumber);
+ int WINAPI _export DeleteFilesW(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int OpMode);
+ void WINAPI _export ExitFARW(void);
+ void WINAPI _export FreeFindDataW(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber);
+ void WINAPI _export FreeVirtualFindDataW(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber);
+ int WINAPI _export GetFilesW(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int Move,const wchar_t **DestPath,int OpMode);
+ int WINAPI _export GetFindDataW(HANDLE hPlugin,struct PluginPanelItem **pPanelItem,int *pItemsNumber,int OpMode);
+ int WINAPI _export GetMinFarVersionW(void);
+ void WINAPI _export GetOpenPluginInfoW(HANDLE hPlugin,struct OpenPluginInfo *Info);
+ void WINAPI _export GetPluginInfoW(struct PluginInfo *Info);
+ int WINAPI _export GetVirtualFindDataW(HANDLE hPlugin,struct PluginPanelItem **pPanelItem,int *pItemsNumber,const wchar_t *Path);
+ int WINAPI _export MakeDirectoryW(HANDLE hPlugin,const wchar_t **Name,int OpMode);
+ HANDLE WINAPI _export OpenFilePluginW(const wchar_t *Name,const unsigned char *Data,int DataSize,int OpMode);
+ HANDLE WINAPI _export OpenPluginW(int OpenFrom,INT_PTR Item);
+ int WINAPI _export ProcessDialogEventW(int Event,void *Param);
+ int WINAPI _export ProcessEditorEventW(int Event,void *Param);
+ int WINAPI _export ProcessEditorInputW(const INPUT_RECORD *Rec);
+ int WINAPI _export ProcessEventW(HANDLE hPlugin,int Event,void *Param);
+ int WINAPI _export ProcessHostFileW(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int OpMode);
+ int WINAPI _export ProcessKeyW(HANDLE hPlugin,int Key,unsigned int ControlState);
+ int WINAPI _export ProcessSynchroEventW(int Event,void *Param);
+ int WINAPI _export ProcessViewerEventW(int Event,void *Param);
+ int WINAPI _export PutFilesW(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int Move,const wchar_t *SrcPath,int OpMode);
+ int WINAPI _export SetDirectoryW(HANDLE hPlugin,const wchar_t *Dir,int OpMode);
+ int WINAPI _export SetFindListW(HANDLE hPlugin,const struct PluginPanelItem *PanelItem,int ItemsNumber);
+ void WINAPI _export SetStartupInfoW(const struct PluginStartupInfo *Info);
+
+EXTERN_C_END
+*/
+EXTERN_C_BEGIN
+
+ void WINAPI _export ClosePlugin(HANDLE hPlugin);
+ int WINAPI _export Compare(HANDLE hPlugin,const struct PluginPanelItem *Item1,const struct PluginPanelItem *Item2,unsigned int Mode);
+ int WINAPI _export Configure(int ItemNumber);
+ int WINAPI _export DeleteFiles(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int OpMode);
+ void WINAPI _export ExitFAR(void);
+ void WINAPI _export FreeFindData(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber);
+ void WINAPI _export FreeVirtualFindData(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber);
+ int WINAPI _export GetFiles(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int Move,char *DestPath,int OpMode);
+ int WINAPI _export GetFindData(HANDLE hPlugin,struct PluginPanelItem **pPanelItem,int *pItemsNumber,int OpMode);
+ int WINAPI _export GetMinFarVersion(void);
+ void WINAPI _export GetOpenPluginInfo(HANDLE hPlugin,struct OpenPluginInfo *Info);
+ void WINAPI _export GetPluginInfo(struct PluginInfo *Info);
+ int WINAPI _export GetVirtualFindData(HANDLE hPlugin,struct PluginPanelItem **pPanelItem,int *pItemsNumber,const char *Path);
+ int WINAPI _export MakeDirectory(HANDLE hPlugin,char *Name,int OpMode);
+ HANDLE WINAPI _export OpenFilePlugin(char *Name,const unsigned char *Data,int DataSize);
+ HANDLE WINAPI _export OpenPlugin(int OpenFrom,INT_PTR Item);
+ int WINAPI _export ProcessDialogEvent(int Event,void *Param);
+ int WINAPI _export ProcessEditorEvent(int Event,void *Param);
+ int WINAPI _export ProcessEditorInput(const INPUT_RECORD *Rec);
+ int WINAPI _export ProcessEvent(HANDLE hPlugin,int Event,void *Param);
+ int WINAPI _export ProcessHostFile(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int OpMode);
+ int WINAPI _export ProcessKey(HANDLE hPlugin,int Key,unsigned int ControlState);
+ int WINAPI _export ProcessViewerEvent(int Event,void *Param);
+ int WINAPI _export PutFiles(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int Move,int OpMode);
+ int WINAPI _export SetDirectory(HANDLE hPlugin,const char *Dir,int OpMode);
+ int WINAPI _export SetFindList(HANDLE hPlugin,const struct PluginPanelItem *PanelItem,int ItemsNumber);
+ void WINAPI _export SetStartupInfo(const struct PluginStartupInfo *Info);
+
+EXTERN_C_END
+
+#endif
diff --git a/CPP/7zip/UI/Far/FarUtils.cpp b/CPP/7zip/UI/Far/FarUtils.cpp
new file mode 100644
index 0000000..9fddbc1
--- /dev/null
+++ b/CPP/7zip/UI/Far/FarUtils.cpp
@@ -0,0 +1,524 @@
+// FarUtils.cpp
+
+#include "StdAfx.h"
+
+// #include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#ifndef UNDER_CE
+#include "../../../Windows/Console.h"
+#endif
+#include "../../../Windows/Defs.h"
+#include "../../../Windows/ErrorMsg.h"
+
+#include "FarUtils.h"
+
+using namespace NWindows;
+
+namespace NFar {
+
+CStartupInfo g_StartupInfo;
+
+const char kRegistryKeyDelimiter = '\\';
+
+void CStartupInfo::Init(const PluginStartupInfo &pluginStartupInfo,
+ const char *pluginNameForRegistry)
+{
+ m_Data = pluginStartupInfo;
+ m_RegistryPath = pluginStartupInfo.RootKey;
+ m_RegistryPath += kRegistryKeyDelimiter;
+ m_RegistryPath += pluginNameForRegistry;
+}
+
+const char *CStartupInfo::GetMsgString(int messageId)
+{
+ return (const char*)m_Data.GetMsg(m_Data.ModuleNumber, messageId);
+}
+
+int CStartupInfo::ShowMessage(unsigned int flags,
+ const char *helpTopic, const char **items, unsigned numItems, int numButtons)
+{
+ return m_Data.Message(m_Data.ModuleNumber, flags, helpTopic,
+ items, (int)numItems, numButtons);
+}
+
+namespace NMessageID
+{
+ enum
+ {
+ kOk,
+ kCancel,
+ kWarning,
+ kError
+ };
+}
+
+int CStartupInfo::ShowWarningWithOk(const char **items, unsigned numItems)
+{
+ return ShowMessage(FMSG_WARNING | FMSG_MB_OK, NULL, items, numItems, 0);
+}
+
+extern const char *g_PluginName_for_Error;
+
+void CStartupInfo::SetErrorTitle(AString &s)
+{
+ if (g_PluginName_for_Error)
+ {
+ s += g_PluginName_for_Error;
+ s += ": ";
+ }
+ s += GetMsgString(NMessageID::kError);
+}
+
+/*
+int CStartupInfo::ShowErrorMessage(const char *message)
+{
+ AString s;
+ SetErrorTitle(s);
+ const char *items[]= { s, message };
+ return ShowWarningWithOk(items, Z7_ARRAY_SIZE(items));
+}
+*/
+
+int CStartupInfo::ShowErrorMessage2(const char *m1, const char *m2)
+{
+ AString s;
+ SetErrorTitle(s);
+ const char *items[]= { s, m1, m2 };
+ return ShowWarningWithOk(items, Z7_ARRAY_SIZE(items));
+}
+
+static void SplitString(const AString &src, AStringVector &destStrings)
+{
+ destStrings.Clear();
+ AString s;
+ unsigned len = src.Len();
+ if (len == 0)
+ return;
+ for (unsigned i = 0; i < len; i++)
+ {
+ char c = src[i];
+ if (c == '\n')
+ {
+ if (!s.IsEmpty())
+ {
+ destStrings.Add(s);
+ s.Empty();
+ }
+ }
+ else
+ s += c;
+ }
+ if (!s.IsEmpty())
+ destStrings.Add(s);
+}
+
+int CStartupInfo::ShowErrorMessage(const char *message)
+{
+ AStringVector strings;
+ SplitString((AString)message, strings);
+ const unsigned kNumStringsMax = 20;
+ const char *items[kNumStringsMax + 1];
+ unsigned pos = 0;
+ items[pos++] = GetMsgString(NMessageID::kError);
+ for (unsigned i = 0; i < strings.Size() && pos < kNumStringsMax; i++)
+ items[pos++] = strings[i];
+ items[pos++] = GetMsgString(NMessageID::kOk);
+
+ return ShowMessage(FMSG_WARNING, NULL, items, pos, 1);
+}
+
+/*
+int CStartupInfo::ShowMessageLines(const char *message)
+{
+ AString s = GetMsgString(NMessageID::kError);
+ s.Add_LF();
+ s += message;
+ return ShowMessage(FMSG_WARNING | FMSG_MB_OK | FMSG_ALLINONE, NULL,
+ (const char **)(const char *)s, 1, 0);
+}
+*/
+
+int CStartupInfo::ShowMessage(int messageId)
+{
+ return ShowErrorMessage(GetMsgString(messageId));
+}
+
+int CStartupInfo::ShowDialog(int X1, int Y1, int X2, int Y2,
+ const char *helpTopic, struct FarDialogItem *items, unsigned numItems)
+{
+ return m_Data.Dialog(m_Data.ModuleNumber, X1, Y1, X2, Y2, const_cast<char *>(helpTopic),
+ items, (int)numItems);
+}
+
+int CStartupInfo::ShowDialog(int sizeX, int sizeY,
+ const char *helpTopic, struct FarDialogItem *items, unsigned numItems)
+{
+ return ShowDialog(-1, -1, sizeX, sizeY, helpTopic, items, numItems);
+}
+
+inline static BOOL GetBOOLValue(bool v) { return (v? TRUE: FALSE); }
+
+void CStartupInfo::InitDialogItems(const CInitDialogItem *srcItems,
+ FarDialogItem *destItems, unsigned numItems)
+{
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ const CInitDialogItem &srcItem = srcItems[i];
+ FarDialogItem &destItem = destItems[i];
+
+ destItem.Type = srcItem.Type;
+ destItem.X1 = srcItem.X1;
+ destItem.Y1 = srcItem.Y1;
+ destItem.X2 = srcItem.X2;
+ destItem.Y2 = srcItem.Y2;
+ destItem.Focus = GetBOOLValue(srcItem.Focus);
+ if (srcItem.HistoryName != NULL)
+ destItem.History = srcItem.HistoryName;
+ else
+ destItem.Selected = GetBOOLValue(srcItem.Selected);
+ destItem.Flags = srcItem.Flags;
+ destItem.DefaultButton = GetBOOLValue(srcItem.DefaultButton);
+
+ if (srcItem.DataMessageId < 0)
+ MyStringCopy(destItem.Data, srcItem.DataString);
+ else
+ MyStringCopy(destItem.Data, GetMsgString(srcItem.DataMessageId));
+
+ /*
+ if ((unsigned int)Init[i].Data < 0xFFF)
+ MyStringCopy(destItem.Data, GetMsg((unsigned int)srcItem.Data));
+ else
+ MyStringCopy(destItem.Data,srcItem.Data);
+ */
+ }
+}
+
+// --------------------------------------------
+
+HANDLE CStartupInfo::SaveScreen(int X1, int Y1, int X2, int Y2)
+{
+ return m_Data.SaveScreen(X1, Y1, X2, Y2);
+}
+
+HANDLE CStartupInfo::SaveScreen()
+{
+ return SaveScreen(0, 0, -1, -1);
+}
+
+void CStartupInfo::RestoreScreen(HANDLE handle)
+{
+ m_Data.RestoreScreen(handle);
+}
+
+CSysString CStartupInfo::GetFullKeyName(const char *keyName) const
+{
+ AString s (m_RegistryPath);
+ if (keyName && *keyName)
+ {
+ s += kRegistryKeyDelimiter;
+ s += keyName;
+ }
+ return (CSysString)s;
+}
+
+
+LONG CStartupInfo::CreateRegKey(HKEY parentKey,
+ const char *keyName, NRegistry::CKey &destKey) const
+{
+ return destKey.Create(parentKey, GetFullKeyName(keyName));
+}
+
+LONG CStartupInfo::OpenRegKey(HKEY parentKey,
+ const char *keyName, NRegistry::CKey &destKey) const
+{
+ return destKey.Open(parentKey, GetFullKeyName(keyName));
+}
+
+void CStartupInfo::SetRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, LPCTSTR value) const
+{
+ NRegistry::CKey regKey;
+ CreateRegKey(parentKey, keyName, regKey);
+ regKey.SetValue(valueName, value);
+}
+
+void CStartupInfo::SetRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, UInt32 value) const
+{
+ NRegistry::CKey regKey;
+ CreateRegKey(parentKey, keyName, regKey);
+ regKey.SetValue(valueName, value);
+}
+
+void CStartupInfo::SetRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, bool value) const
+{
+ NRegistry::CKey regKey;
+ CreateRegKey(parentKey, keyName, regKey);
+ regKey.SetValue(valueName, value);
+}
+
+CSysString CStartupInfo::QueryRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, const CSysString &valueDefault) const
+{
+ NRegistry::CKey regKey;
+ if (OpenRegKey(parentKey, keyName, regKey) != ERROR_SUCCESS)
+ return valueDefault;
+
+ CSysString value;
+ if (regKey.QueryValue(valueName, value) != ERROR_SUCCESS)
+ return valueDefault;
+
+ return value;
+}
+
+UInt32 CStartupInfo::QueryRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, UInt32 valueDefault) const
+{
+ NRegistry::CKey regKey;
+ if (OpenRegKey(parentKey, keyName, regKey) != ERROR_SUCCESS)
+ return valueDefault;
+
+ UInt32 value;
+ if (regKey.QueryValue(valueName, value) != ERROR_SUCCESS)
+ return valueDefault;
+
+ return value;
+}
+
+bool CStartupInfo::QueryRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, bool valueDefault) const
+{
+ NRegistry::CKey regKey;
+ if (OpenRegKey(parentKey, keyName, regKey) != ERROR_SUCCESS)
+ return valueDefault;
+
+ bool value;
+ if (regKey.QueryValue(valueName, value) != ERROR_SUCCESS)
+ return valueDefault;
+
+ return value;
+}
+
+bool CStartupInfo::Control(HANDLE pluginHandle, int command, void *param)
+{
+ return BOOLToBool(m_Data.Control(pluginHandle, command, param));
+}
+
+bool CStartupInfo::ControlRequestActivePanel(int command, void *param)
+{
+ return Control(INVALID_HANDLE_VALUE, command, param);
+}
+
+bool CStartupInfo::ControlGetActivePanelInfo(PanelInfo &panelInfo)
+{
+ return ControlRequestActivePanel(FCTL_GETPANELINFO, &panelInfo);
+}
+
+bool CStartupInfo::ControlSetSelection(const PanelInfo &panelInfo)
+{
+ return ControlRequestActivePanel(FCTL_SETSELECTION, (void *)&panelInfo);
+}
+
+bool CStartupInfo::ControlGetActivePanelCurrentItemInfo(
+ PluginPanelItem &pluginPanelItem)
+{
+ PanelInfo panelInfo;
+ if (!ControlGetActivePanelInfo(panelInfo))
+ return false;
+ if (panelInfo.ItemsNumber <= 0)
+ throw "There are no items";
+ pluginPanelItem = panelInfo.PanelItems[panelInfo.CurrentItem];
+ return true;
+}
+
+bool CStartupInfo::ControlGetActivePanelSelectedOrCurrentItems(
+ CObjectVector<PluginPanelItem> &pluginPanelItems)
+{
+ pluginPanelItems.Clear();
+ PanelInfo panelInfo;
+ if (!ControlGetActivePanelInfo(panelInfo))
+ return false;
+ if (panelInfo.ItemsNumber <= 0)
+ throw "There are no items";
+ if (panelInfo.SelectedItemsNumber == 0)
+ pluginPanelItems.Add(panelInfo.PanelItems[panelInfo.CurrentItem]);
+ else
+ for (int i = 0; i < panelInfo.SelectedItemsNumber; i++)
+ pluginPanelItems.Add(panelInfo.SelectedItems[i]);
+ return true;
+}
+
+bool CStartupInfo::ControlClearPanelSelection()
+{
+ PanelInfo panelInfo;
+ if (!ControlGetActivePanelInfo(panelInfo))
+ return false;
+ for (int i = 0; i < panelInfo.ItemsNumber; i++)
+ panelInfo.PanelItems[i].Flags &= ~(DWORD)PPIF_SELECTED;
+ return ControlSetSelection(panelInfo);
+}
+
+////////////////////////////////////////////////
+// menu function
+
+int CStartupInfo::Menu(
+ int x,
+ int y,
+ int maxHeight,
+ unsigned int flags,
+ const char *title,
+ const char *aBottom,
+ const char *helpTopic,
+ int *breakKeys,
+ int *breakCode,
+ struct FarMenuItem *items,
+ unsigned numItems)
+{
+ return m_Data.Menu(m_Data.ModuleNumber, x, y, maxHeight, flags,
+ const_cast<char *>(title),
+ const_cast<char *>(aBottom),
+ const_cast<char *>(helpTopic),
+ breakKeys, breakCode, items, (int)numItems);
+}
+
+int CStartupInfo::Menu(
+ unsigned int flags,
+ const char *title,
+ const char *helpTopic,
+ struct FarMenuItem *items,
+ unsigned numItems)
+{
+ return Menu(-1, -1, 0, flags, title, NULL, helpTopic, NULL,
+ NULL, items, numItems);
+}
+
+int CStartupInfo::Menu(
+ unsigned int flags,
+ const char *title,
+ const char *helpTopic,
+ const AStringVector &items,
+ int selectedItem)
+{
+ CRecordVector<FarMenuItem> farMenuItems;
+ FOR_VECTOR (i, items)
+ {
+ FarMenuItem item;
+ item.Checked = 0;
+ item.Separator = 0;
+ item.Selected = ((int)i == selectedItem);
+ const AString reducedString (items[i].Left(Z7_ARRAY_SIZE(item.Text) - 1));
+ MyStringCopy(item.Text, reducedString);
+ farMenuItems.Add(item);
+ }
+ return Menu(flags, title, helpTopic, &farMenuItems.Front(), farMenuItems.Size());
+}
+
+
+//////////////////////////////////
+// CScreenRestorer
+
+CScreenRestorer::~CScreenRestorer()
+{
+ Restore();
+}
+void CScreenRestorer::Save()
+{
+ if (m_Saved)
+ return;
+ m_HANDLE = g_StartupInfo.SaveScreen();
+ m_Saved = true;
+}
+
+void CScreenRestorer::Restore()
+{
+ if (m_Saved)
+ {
+ g_StartupInfo.RestoreScreen(m_HANDLE);
+ m_Saved = false;
+ }
+}
+
+int PrintErrorMessage(const char *message, unsigned code)
+{
+ AString s (message);
+ s += " #";
+ s.Add_UInt32((UInt32)code);
+ return g_StartupInfo.ShowErrorMessage(s);
+}
+
+int PrintErrorMessage(const char *message, const char *text)
+{
+ return g_StartupInfo.ShowErrorMessage2(message, text);
+}
+
+
+void ReduceString(UString &s, unsigned size)
+{
+ if (s.Len() > size)
+ {
+ if (size > 5)
+ size -= 5;
+ s.Delete(size / 2, s.Len() - size);
+ s.Insert(size / 2, L" ... ");
+ }
+}
+
+int PrintErrorMessage(const char *message, const wchar_t *name, unsigned maxLen)
+{
+ UString s = name;
+ ReduceString(s, maxLen);
+ return PrintErrorMessage(message, UnicodeStringToMultiByte(s, CP_OEMCP));
+}
+
+int ShowSysErrorMessage(DWORD errorCode)
+{
+ const UString message = NError::MyFormatMessage(errorCode);
+ return g_StartupInfo.ShowErrorMessage(UnicodeStringToMultiByte(message, CP_OEMCP));
+}
+
+int ShowLastErrorMessage()
+{
+ return ShowSysErrorMessage(::GetLastError());
+}
+
+int ShowSysErrorMessage(DWORD errorCode, const wchar_t *name)
+{
+ const UString s = NError::MyFormatMessage(errorCode);
+ return g_StartupInfo.ShowErrorMessage2(
+ UnicodeStringToMultiByte(s, CP_OEMCP),
+ UnicodeStringToMultiByte(name, CP_OEMCP));
+}
+
+
+bool WasEscPressed()
+{
+ #ifdef UNDER_CE
+ return false;
+ #else
+ NConsole::CIn inConsole;
+ HANDLE handle = ::GetStdHandle(STD_INPUT_HANDLE);
+ if (handle == INVALID_HANDLE_VALUE)
+ return true;
+ inConsole.Attach(handle);
+ for (;;)
+ {
+ DWORD numEvents;
+ if (!inConsole.GetNumberOfEvents(numEvents))
+ return true;
+ if (numEvents == 0)
+ return false;
+
+ INPUT_RECORD event;
+ if (!inConsole.ReadEvent(event, numEvents))
+ return true;
+ if (event.EventType == KEY_EVENT &&
+ event.Event.KeyEvent.bKeyDown &&
+ event.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)
+ return true;
+ }
+ #endif
+}
+
+}
diff --git a/CPP/7zip/UI/Far/FarUtils.h b/CPP/7zip/UI/Far/FarUtils.h
new file mode 100644
index 0000000..6e6ff3c
--- /dev/null
+++ b/CPP/7zip/UI/Far/FarUtils.h
@@ -0,0 +1,203 @@
+// FarUtils.h
+
+#ifndef ZIP7_INC_FAR_UTILS_H
+#define ZIP7_INC_FAR_UTILS_H
+
+#include "FarPlugin.h"
+
+#include "../../../Windows/Registry.h"
+
+namespace NFar {
+
+namespace NFileOperationReturnCode
+{
+ enum EEnum
+ {
+ kInterruptedByUser = -1,
+ kError = 0,
+ kSuccess = 1
+ };
+}
+
+namespace NEditorReturnCode
+{
+ enum EEnum
+ {
+ kOpenError = 0,
+ kFileWasChanged = 1,
+ kFileWasNotChanged = 2,
+ kInterruptedByUser = 3
+ };
+}
+
+struct CInitDialogItem
+{
+ DialogItemTypes Type;
+ int X1,Y1,X2,Y2;
+ bool Focus;
+ bool Selected;
+ unsigned int Flags; //FarDialogItemFlags Flags;
+ bool DefaultButton;
+ int DataMessageId;
+ const char *DataString;
+ const char *HistoryName;
+ // void InitToFarDialogItem(struct FarDialogItem &anItemDest);
+};
+
+class CStartupInfo
+{
+ PluginStartupInfo m_Data;
+ AString m_RegistryPath;
+
+ CSysString GetFullKeyName(const char *keyName) const;
+ LONG CreateRegKey(HKEY parentKey,
+ const char *keyName, NWindows::NRegistry::CKey &destKey) const;
+ LONG OpenRegKey(HKEY parentKey,
+ const char *keyName, NWindows::NRegistry::CKey &destKey) const;
+
+public:
+ void Init(const PluginStartupInfo &pluginStartupInfo,
+ const char *pluginNameForRegistry);
+ const char *GetMsgString(int messageId);
+
+ int ShowMessage(unsigned int flags, const char *helpTopic,
+ const char **items, unsigned numItems, int numButtons);
+ int ShowWarningWithOk(const char **items, unsigned numItems);
+
+ void SetErrorTitle(AString &s);
+ int ShowErrorMessage(const char *message);
+ int ShowErrorMessage2(const char *m1, const char *m2);
+ // int ShowMessageLines(const char *messageLines);
+ int ShowMessage(int messageId);
+
+ int ShowDialog(int X1, int Y1, int X2, int Y2,
+ const char *helpTopic, struct FarDialogItem *items, unsigned numItems);
+ int ShowDialog(int sizeX, int sizeY,
+ const char *helpTopic, struct FarDialogItem *items, unsigned numItems);
+
+ void InitDialogItems(const CInitDialogItem *srcItems,
+ FarDialogItem *destItems, unsigned numItems);
+
+ HANDLE SaveScreen(int X1, int Y1, int X2, int Y2);
+ HANDLE SaveScreen();
+ void RestoreScreen(HANDLE handle);
+
+ void SetRegKeyValue(HKEY parentKey, const char *keyName,
+ const LPCTSTR valueName, LPCTSTR value) const;
+ void SetRegKeyValue(HKEY hRoot, const char *keyName,
+ const LPCTSTR valueName, UInt32 value) const;
+ void SetRegKeyValue(HKEY hRoot, const char *keyName,
+ const LPCTSTR valueName, bool value) const;
+
+ CSysString QueryRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, const CSysString &valueDefault) const;
+
+ UInt32 QueryRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, UInt32 valueDefault) const;
+
+ bool QueryRegKeyValue(HKEY parentKey, const char *keyName,
+ LPCTSTR valueName, bool valueDefault) const;
+
+ bool Control(HANDLE plugin, int command, void *param);
+ bool ControlRequestActivePanel(int command, void *param);
+ bool ControlGetActivePanelInfo(PanelInfo &panelInfo);
+ bool ControlSetSelection(const PanelInfo &panelInfo);
+ bool ControlGetActivePanelCurrentItemInfo(PluginPanelItem &pluginPanelItem);
+ bool ControlGetActivePanelSelectedOrCurrentItems(
+ CObjectVector<PluginPanelItem> &pluginPanelItems);
+
+ bool ControlClearPanelSelection();
+
+ int Menu(
+ int x,
+ int y,
+ int maxHeight,
+ unsigned int flags,
+ const char *title,
+ const char *aBottom,
+ const char *helpTopic,
+ int *breakKeys,
+ int *breakCode,
+ FarMenuItem *items,
+ unsigned numItems);
+ int Menu(
+ unsigned int flags,
+ const char *title,
+ const char *helpTopic,
+ FarMenuItem *items,
+ unsigned numItems);
+
+ int Menu(
+ unsigned int flags,
+ const char *title,
+ const char *helpTopic,
+ const AStringVector &items,
+ int selectedItem);
+
+ int Editor(const char *fileName, const char *title,
+ int X1, int Y1, int X2, int Y2, DWORD flags, int startLine, int startChar)
+ { return m_Data.Editor(const_cast<char *>(fileName), const_cast<char *>(title), X1, Y1, X2, Y2,
+ flags, startLine, startChar); }
+ int Editor(const char *fileName)
+ { return Editor(fileName, NULL, 0, 0, -1, -1, 0, -1, -1); }
+
+ int Viewer(const char *fileName, const char *title,
+ int X1, int Y1, int X2, int Y2, DWORD flags)
+ { return m_Data.Viewer(const_cast<char *>(fileName), const_cast<char *>(title), X1, Y1, X2, Y2, flags); }
+ int Viewer(const char *fileName)
+ { return Viewer(fileName, NULL, 0, 0, -1, -1, VF_NONMODAL); }
+
+};
+
+class CScreenRestorer
+{
+ bool m_Saved;
+ HANDLE m_HANDLE;
+public:
+ CScreenRestorer(): m_Saved(false) {}
+ ~CScreenRestorer();
+ void Save();
+ void Restore();
+};
+
+
+extern CStartupInfo g_StartupInfo;
+
+
+int PrintErrorMessage(const char *message, unsigned code);
+int PrintErrorMessage(const char *message, const char *text);
+int PrintErrorMessage(const char *message, const wchar_t *name, unsigned maxLen = 70);
+
+#define MY_TRY_BEGIN try {
+
+#define MY_TRY_END1(x) }\
+ catch(unsigned n) { PrintErrorMessage(x, n); return; }\
+ catch(const CSysString &s) { PrintErrorMessage(x, s); return; }\
+ catch(const char *s) { PrintErrorMessage(x, s); return; }\
+ catch(...) { g_StartupInfo.ShowErrorMessage(x); return; }
+
+#define MY_TRY_END2(x, y) }\
+ catch(unsigned n) { PrintErrorMessage(x, n); return y; }\
+ catch(const AString &s) { PrintErrorMessage(x, s); return y; }\
+ catch(const char *s) { PrintErrorMessage(x, s); return y; }\
+ catch(const UString &s) { PrintErrorMessage(x, s); return y; }\
+ catch(const wchar_t *s) { PrintErrorMessage(x, s); return y; }\
+ catch(...) { g_StartupInfo.ShowErrorMessage(x); return y; }
+
+
+int ShowSysErrorMessage(DWORD errorCode);
+int ShowSysErrorMessage(DWORD errorCode, const wchar_t *name);
+int ShowLastErrorMessage();
+
+inline int ShowSysErrorMessage(HRESULT errorCode)
+ { return ShowSysErrorMessage((DWORD)errorCode); }
+inline int ShowSysErrorMessage(HRESULT errorCode, const wchar_t *name)
+ { return ShowSysErrorMessage((DWORD)errorCode, name); }
+
+bool WasEscPressed();
+
+void ReduceString(UString &s, unsigned size);
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Far/Messages.h b/CPP/7zip/UI/Far/Messages.h
new file mode 100644
index 0000000..f6b20a3
--- /dev/null
+++ b/CPP/7zip/UI/Far/Messages.h
@@ -0,0 +1,136 @@
+// Far/Messages.h
+
+#ifndef ZIP7_INC_FAR_MESSAGES_H
+#define ZIP7_INC_FAR_MESSAGES_H
+
+#include "../../PropID.h"
+
+namespace NMessageID {
+
+const unsigned k_Last_PropId_supported_by_plugin = kpidDevMinor;
+
+enum EEnum
+{
+ kOk,
+ kCancel,
+
+ kWarning,
+ kError,
+
+ kArchiveType,
+
+ kProperties,
+
+ kYes,
+ kNo,
+
+ kGetPasswordTitle,
+ kEnterPasswordForFile,
+
+ kExtractTitle,
+ kExtractTo,
+
+ kExtractPathMode,
+ kExtractPathFull,
+ kExtractPathCurrent,
+ kExtractPathNo,
+
+ kExtractOwerwriteMode,
+ kExtractOwerwriteAsk,
+ kExtractOwerwritePrompt,
+ kExtractOwerwriteSkip,
+ kExtractOwerwriteAutoRename,
+ kExtractOwerwriteAutoRenameExisting,
+
+ kExtractFilesMode,
+ kExtractFilesSelected,
+ kExtractFilesAll,
+
+ kExtractPassword,
+
+ kExtractExtract,
+ kExtractCancel,
+
+ kExtractCanNotOpenOutputFile,
+
+ kExtractUnsupportedMethod,
+ kExtractCRCFailed,
+ kExtractDataError,
+ kExtractCRCFailedEncrypted,
+ kExtractDataErrorEncrypted,
+
+ kOverwriteTitle,
+ kOverwriteMessage1,
+ kOverwriteMessageWouldYouLike,
+ kOverwriteMessageWithtTisOne,
+
+ kOverwriteBytes,
+ kOverwriteModifiedOn,
+
+ kOverwriteYes,
+ kOverwriteYesToAll,
+ kOverwriteNo,
+ kOverwriteNoToAll,
+ kOverwriteAutoRename,
+ kOverwriteCancel,
+
+ kUpdateNotSupportedForThisArchive,
+
+ kDeleteTitle,
+ kDeleteFile,
+ kDeleteFiles,
+ kDeleteNumberOfFiles,
+ kDeleteDelete,
+ kDeleteCancel,
+
+ kUpdateTitle,
+ kUpdateAddToArchive,
+
+ kUpdateMethod,
+ kUpdateMethod_Store,
+ kUpdateMethod_Fastest,
+ kUpdateMethod_Fast,
+ kUpdateMethod_Normal,
+ kUpdateMethod_Maximum,
+ kUpdateMethod_Ultra,
+
+ kUpdateMode,
+ kUpdateMode_Add,
+ kUpdateMode_Update,
+ kUpdateMode_Fresh,
+ kUpdateMode_Sync,
+
+ kUpdateAdd,
+ kUpdateSelectArchiver,
+
+ kUpdateSelectArchiverMenuTitle,
+
+ // kArcReadFiles,
+
+ kWaitTitle,
+
+ kReading,
+ kExtracting,
+ kDeleting,
+ kUpdating,
+
+ // kReadingList,
+
+ kMoveIsNotSupported,
+
+ kOpenArchiveMenuString,
+ kCreateArchiveMenuString,
+
+ kConfigTitle,
+
+ kConfigPluginEnabled,
+
+ // ---------- IDs for Properies (kpid*) ----------
+ kNoProperty,
+ k_Last_MessageID_for_Property = kNoProperty + k_Last_PropId_supported_by_plugin
+ // ----------
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Far/OverwriteDialogFar.cpp b/CPP/7zip/UI/Far/OverwriteDialogFar.cpp
new file mode 100644
index 0000000..a45d2b2
--- /dev/null
+++ b/CPP/7zip/UI/Far/OverwriteDialogFar.cpp
@@ -0,0 +1,145 @@
+// OverwriteDialogFar.cpp
+
+#include "StdAfx.h"
+
+#include <stdio.h>
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "FarUtils.h"
+#include "Messages.h"
+
+#include "OverwriteDialogFar.h"
+
+using namespace NWindows;
+using namespace NFar;
+
+namespace NOverwriteDialog {
+
+struct CFileInfoStrings
+{
+ AString Size;
+ AString Time;
+};
+
+static void SetFileInfoStrings(const CFileInfo &fileInfo,
+ CFileInfoStrings &fileInfoStrings)
+{
+ char buffer[256];
+
+ if (fileInfo.SizeIsDefined)
+ {
+ ConvertUInt64ToString(fileInfo.Size, buffer);
+ fileInfoStrings.Size = buffer;
+ fileInfoStrings.Size.Add_Space();
+ fileInfoStrings.Size += g_StartupInfo.GetMsgString(NMessageID::kOverwriteBytes);
+ }
+ else
+ {
+ fileInfoStrings.Size = "";
+ }
+
+ fileInfoStrings.Time.Empty();
+ if (fileInfo.TimeIsDefined)
+ {
+ char timeString[32];
+ ConvertUtcFileTimeToString(fileInfo.Time, timeString);
+ fileInfoStrings.Time = g_StartupInfo.GetMsgString(NMessageID::kOverwriteModifiedOn);
+ fileInfoStrings.Time.Add_Space();
+ fileInfoStrings.Time += timeString;
+ }
+}
+
+static void ReduceString2(UString &s, unsigned size)
+{
+ if (!s.IsEmpty() && s.Back() == ' ')
+ {
+ // s += (wchar_t)(0x2423);
+ s.InsertAtFront(L'\"');
+ s += L'\"';
+ }
+ ReduceString(s, size);
+}
+
+NResult::EEnum Execute(const CFileInfo &oldFileInfo, const CFileInfo &newFileInfo)
+{
+ const int kYSize = 22;
+ const int kXSize = 76;
+
+ CFileInfoStrings oldFileInfoStrings;
+ CFileInfoStrings newFileInfoStrings;
+
+ SetFileInfoStrings(oldFileInfo, oldFileInfoStrings);
+ SetFileInfoStrings(newFileInfo, newFileInfoStrings);
+
+ const UString &oldName2 = oldFileInfo.Name;
+ const UString &newName2 = newFileInfo.Name;
+
+ int slashPos = oldName2.ReverseFind_PathSepar();
+ UString pref1 = oldName2.Left(slashPos + 1);
+ UString name1 = oldName2.Ptr(slashPos + 1);
+
+ slashPos = newName2.ReverseFind_PathSepar();
+ UString pref2 = newName2.Left(slashPos + 1);
+ UString name2 = newName2.Ptr(slashPos + 1);
+
+ const unsigned kNameOffset = 2;
+ {
+ const unsigned maxNameLen = kXSize - 9 - 2;
+ ReduceString(pref1, maxNameLen);
+ ReduceString(pref2, maxNameLen);
+ ReduceString2(name1, maxNameLen - kNameOffset);
+ ReduceString2(name2, maxNameLen - kNameOffset);
+ }
+
+ const AString pref1A (UnicodeStringToMultiByte(pref1, CP_OEMCP));
+ const AString pref2A (UnicodeStringToMultiByte(pref2, CP_OEMCP));
+ const AString name1A (UnicodeStringToMultiByte(name1, CP_OEMCP));
+ const AString name2A (UnicodeStringToMultiByte(name2, CP_OEMCP));
+
+ const struct CInitDialogItem initItems[]={
+ { DI_DOUBLEBOX, 3, 1, kXSize - 4, kYSize - 2, false, false, 0, false, NMessageID::kOverwriteTitle, NULL, NULL },
+ { DI_TEXT, 5, 2, 0, 0, false, false, 0, false, NMessageID::kOverwriteMessage1, NULL, NULL },
+
+ { DI_TEXT, 3, 3, 0, 0, false, false, DIF_BOXCOLOR|DIF_SEPARATOR, false, -1, "", NULL },
+
+ { DI_TEXT, 5, 4, 0, 0, false, false, 0, false, NMessageID::kOverwriteMessageWouldYouLike, NULL, NULL },
+
+ { DI_TEXT, 7, 6, 0, 0, false, false, 0, false, -1, pref1A, NULL },
+ { DI_TEXT, 7 + kNameOffset, 7, 0, 0, false, false, 0, false, -1, name1A, NULL },
+ { DI_TEXT, 7, 8, 0, 0, false, false, 0, false, -1, oldFileInfoStrings.Size, NULL },
+ { DI_TEXT, 7, 9, 0, 0, false, false, 0, false, -1, oldFileInfoStrings.Time, NULL },
+
+ { DI_TEXT, 5, 11, 0, 0, false, false, 0, false, NMessageID::kOverwriteMessageWithtTisOne, NULL, NULL },
+
+ { DI_TEXT, 7, 13, 0, 0, false, false, 0, false, -1, pref2A, NULL },
+ { DI_TEXT, 7 + kNameOffset, 14, 0, 0, false, false, 0, false, -1, name2A, NULL },
+ { DI_TEXT, 7, 15, 0, 0, false, false, 0, false, -1, newFileInfoStrings.Size, NULL },
+ { DI_TEXT, 7, 16, 0, 0, false, false, 0, false, -1, newFileInfoStrings.Time, NULL },
+
+ { DI_TEXT, 3, kYSize - 5, 0, 0, false, false, DIF_BOXCOLOR|DIF_SEPARATOR, false, -1, "", NULL },
+
+ { DI_BUTTON, 0, kYSize - 4, 0, 0, true, false, DIF_CENTERGROUP, true, NMessageID::kOverwriteYes, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 4, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kOverwriteYesToAll, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 4, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kOverwriteNo, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 4, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kOverwriteNoToAll, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kOverwriteAutoRename, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kOverwriteCancel, NULL, NULL }
+ };
+
+ const int kNumDialogItems = Z7_ARRAY_SIZE(initItems);
+ FarDialogItem aDialogItems[kNumDialogItems];
+ g_StartupInfo.InitDialogItems(initItems, aDialogItems, kNumDialogItems);
+ const int anAskCode = g_StartupInfo.ShowDialog(kXSize, kYSize,
+ NULL, aDialogItems, kNumDialogItems);
+ const int kButtonStartPos = kNumDialogItems - 6;
+ if (anAskCode >= kButtonStartPos && anAskCode < kNumDialogItems)
+ return NResult::EEnum(anAskCode - kButtonStartPos);
+ return NResult::kCancel;
+}
+
+}
diff --git a/CPP/7zip/UI/Far/OverwriteDialogFar.h b/CPP/7zip/UI/Far/OverwriteDialogFar.h
new file mode 100644
index 0000000..bc6e92b
--- /dev/null
+++ b/CPP/7zip/UI/Far/OverwriteDialogFar.h
@@ -0,0 +1,37 @@
+// OverwriteDialogFar.h
+
+#ifndef ZIP7_INC_OVERWRITE_DIALOG_FAR_H
+#define ZIP7_INC_OVERWRITE_DIALOG_FAR_H
+
+#include "../../../Common/MyString.h"
+#include "../../../Common/MyTypes.h"
+
+namespace NOverwriteDialog {
+
+struct CFileInfo
+{
+ bool SizeIsDefined;
+ bool TimeIsDefined;
+ UInt64 Size;
+ FILETIME Time;
+ UString Name;
+};
+
+namespace NResult
+{
+ enum EEnum
+ {
+ kYes,
+ kYesToAll,
+ kNo,
+ kNoToAll,
+ kAutoRename,
+ kCancel
+ };
+}
+
+NResult::EEnum Execute(const CFileInfo &oldFileInfo, const CFileInfo &newFileInfo);
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/Far/Plugin.cpp b/CPP/7zip/UI/Far/Plugin.cpp
new file mode 100644
index 0000000..fe6fcce
--- /dev/null
+++ b/CPP/7zip/UI/Far/Plugin.cpp
@@ -0,0 +1,939 @@
+// Plugin.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../Common/PropIDUtils.h"
+
+#include "FarUtils.h"
+#include "Messages.h"
+#include "Plugin.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NFar;
+
+// This function is used by CAgentFolder
+int CompareFileNames_ForFolderList(const wchar_t *s1, const wchar_t *s2);
+int CompareFileNames_ForFolderList(const wchar_t *s1, const wchar_t *s2)
+{
+ return MyStringCompareNoCase(s1, s2);
+}
+
+CPlugin::CPlugin(const FString &fileName, CAgent *agent, UString archiveTypeName):
+ _agent(agent),
+ m_FileName(fileName),
+ _archiveTypeName(archiveTypeName),
+ PasswordIsDefined(false)
+{
+ m_ArchiveHandler = agent;
+ if (!m_FileInfo.Find(m_FileName))
+ throw "error";
+ m_ArchiveHandler->BindToRootFolder(&_folder);
+}
+
+CPlugin::~CPlugin() {}
+
+static void MyGetFileTime(IFolderFolder *folder, UInt32 itemIndex,
+ PROPID propID, FILETIME &fileTime)
+{
+ NCOM::CPropVariant prop;
+ if (folder->GetProperty(itemIndex, propID, &prop) != S_OK)
+ throw 271932;
+ if (prop.vt == VT_EMPTY)
+ {
+ fileTime.dwHighDateTime = 0;
+ fileTime.dwLowDateTime = 0;
+ }
+ else
+ {
+ if (prop.vt != VT_FILETIME)
+ throw 4191730;
+ fileTime = prop.filetime;
+ }
+}
+
+#define kDotsReplaceString "[[..]]"
+#define kDotsReplaceStringU L"[[..]]"
+
+static void CopyStrLimited(char *dest, const AString &src, unsigned len)
+{
+ len--;
+ if (src.Len() < len)
+ len = src.Len();
+ memcpy(dest, src, sizeof(dest[0]) * len);
+ dest[len] = 0;
+}
+
+#define COPY_STR_LIMITED(dest, src) CopyStrLimited(dest, src, Z7_ARRAY_SIZE(dest))
+
+void CPlugin::ReadPluginPanelItem(PluginPanelItem &panelItem, UInt32 itemIndex)
+{
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, kpidName, &prop) != S_OK)
+ throw 271932;
+
+ if (prop.vt != VT_BSTR)
+ throw 272340;
+
+ AString oemString (UnicodeStringToMultiByte(prop.bstrVal, CP_OEMCP));
+ if (oemString == "..")
+ oemString = kDotsReplaceString;
+
+ COPY_STR_LIMITED(panelItem.FindData.cFileName, oemString);
+ panelItem.FindData.cAlternateFileName[0] = 0;
+
+ if (_folder->GetProperty(itemIndex, kpidAttrib, &prop) != S_OK)
+ throw 271932;
+ if (prop.vt == VT_UI4)
+ panelItem.FindData.dwFileAttributes = prop.ulVal;
+ else if (prop.vt == VT_EMPTY)
+ panelItem.FindData.dwFileAttributes = m_FileInfo.Attrib;
+ else
+ throw 21631;
+
+ if (_folder->GetProperty(itemIndex, kpidIsDir, &prop) != S_OK)
+ throw 271932;
+ if (prop.vt == VT_BOOL)
+ {
+ if (VARIANT_BOOLToBool(prop.boolVal))
+ panelItem.FindData.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
+ }
+ else if (prop.vt != VT_EMPTY)
+ throw 21632;
+
+ if (_folder->GetProperty(itemIndex, kpidSize, &prop) != S_OK)
+ throw 271932;
+ UInt64 length = 0;
+ ConvertPropVariantToUInt64(prop, length);
+ panelItem.FindData.nFileSizeLow = (UInt32)length;
+ panelItem.FindData.nFileSizeHigh = (UInt32)(length >> 32);
+
+ MyGetFileTime(_folder, itemIndex, kpidCTime, panelItem.FindData.ftCreationTime);
+ MyGetFileTime(_folder, itemIndex, kpidATime, panelItem.FindData.ftLastAccessTime);
+ MyGetFileTime(_folder, itemIndex, kpidMTime, panelItem.FindData.ftLastWriteTime);
+
+ if (panelItem.FindData.ftLastWriteTime.dwHighDateTime == 0 &&
+ panelItem.FindData.ftLastWriteTime.dwLowDateTime == 0)
+ panelItem.FindData.ftLastWriteTime = m_FileInfo.MTime;
+
+ if (_folder->GetProperty(itemIndex, kpidPackSize, &prop) != S_OK)
+ throw 271932;
+ length = 0;
+ ConvertPropVariantToUInt64(prop, length);
+ panelItem.PackSize = UInt32(length);
+ panelItem.PackSizeHigh = UInt32(length >> 32);
+
+ panelItem.Flags = 0;
+ panelItem.NumberOfLinks = 0;
+
+ panelItem.Description = NULL;
+ panelItem.Owner = NULL;
+ panelItem.CustomColumnData = NULL;
+ panelItem.CustomColumnNumber = 0;
+
+ panelItem.CRC32 = 0;
+ panelItem.Reserved[0] = 0;
+ panelItem.Reserved[1] = 0;
+}
+
+int CPlugin::GetFindData(PluginPanelItem **panelItems, int *itemsNumber, int opMode)
+{
+ // CScreenRestorer screenRestorer;
+ if ((opMode & OPM_SILENT) == 0 && (opMode & OPM_FIND ) == 0)
+ {
+ /*
+ screenRestorer.Save();
+ const char *msgItems[]=
+ {
+ g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kReadingList)
+ };
+ g_StartupInfo.ShowMessage(0, NULL, msgItems, Z7_ARRAY_SIZE(msgItems), 0);
+ */
+ }
+
+ UInt32 numItems;
+ _folder->GetNumberOfItems(&numItems);
+ *panelItems = new PluginPanelItem[numItems];
+ try
+ {
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ PluginPanelItem &panelItem = (*panelItems)[i];
+ ReadPluginPanelItem(panelItem, i);
+ panelItem.UserData = i;
+ }
+ }
+ catch(...)
+ {
+ delete [](*panelItems);
+ throw;
+ }
+ *itemsNumber = (int)numItems;
+ return(TRUE);
+}
+
+void CPlugin::FreeFindData(struct PluginPanelItem *panelItems, int itemsNumber)
+{
+ for (int i = 0; i < itemsNumber; i++)
+ if (panelItems[i].Description != NULL)
+ delete []panelItems[i].Description;
+ delete []panelItems;
+}
+
+void CPlugin::EnterToDirectory(const UString &dirName)
+{
+ CMyComPtr<IFolderFolder> newFolder;
+ UString s = dirName;
+ if (dirName == kDotsReplaceStringU)
+ s = "..";
+ _folder->BindToFolder(s, &newFolder);
+ if (!newFolder)
+ {
+ if (dirName.IsEmpty())
+ return;
+ else
+ throw 40325;
+ }
+ _folder = newFolder;
+}
+
+int CPlugin::SetDirectory(const char *aszDir, int /* opMode */)
+{
+ UString path = MultiByteToUnicodeString(aszDir, CP_OEMCP);
+ if (path == WSTRING_PATH_SEPARATOR)
+ {
+ _folder.Release();
+ m_ArchiveHandler->BindToRootFolder(&_folder);
+ }
+ else if (path == L"..")
+ {
+ CMyComPtr<IFolderFolder> newFolder;
+ _folder->BindToParentFolder(&newFolder);
+ if (!newFolder)
+ throw 40312;
+ _folder = newFolder;
+ }
+ else if (path.IsEmpty())
+ EnterToDirectory(path);
+ else
+ {
+ if (path[0] == WCHAR_PATH_SEPARATOR)
+ {
+ _folder.Release();
+ m_ArchiveHandler->BindToRootFolder(&_folder);
+ path.DeleteFrontal(1);
+ }
+ UStringVector pathParts;
+ SplitPathToParts(path, pathParts);
+ FOR_VECTOR (i, pathParts)
+ EnterToDirectory(pathParts[i]);
+ }
+ SetCurrentDirVar();
+ return TRUE;
+}
+
+void CPlugin::GetPathParts(UStringVector &pathParts)
+{
+ pathParts.Clear();
+ CMyComPtr<IFolderFolder> folderItem = _folder;
+ for (;;)
+ {
+ CMyComPtr<IFolderFolder> newFolder;
+ folderItem->BindToParentFolder(&newFolder);
+ if (!newFolder)
+ break;
+ NCOM::CPropVariant prop;
+ if (folderItem->GetFolderProperty(kpidName, &prop) == S_OK)
+ if (prop.vt == VT_BSTR)
+ pathParts.Insert(0, (const wchar_t *)prop.bstrVal);
+ folderItem = newFolder;
+ }
+}
+
+void CPlugin::SetCurrentDirVar()
+{
+ m_CurrentDir.Empty();
+
+ /*
+ // kpidPath path has tail slash, but we don't need it for compatibility with default FAR style
+ NCOM::CPropVariant prop;
+ if (_folder->GetFolderProperty(kpidPath, &prop) == S_OK)
+ if (prop.vt == VT_BSTR)
+ {
+ m_CurrentDir = (wchar_t *)prop.bstrVal;
+ // if (!m_CurrentDir.IsEmpty())
+ }
+ m_CurrentDir.InsertAtFront(WCHAR_PATH_SEPARATOR);
+ */
+
+ UStringVector pathParts;
+ GetPathParts(pathParts);
+ FOR_VECTOR (i, pathParts)
+ {
+ m_CurrentDir.Add_PathSepar();
+ m_CurrentDir += pathParts[i];
+ }
+}
+
+static const char * const kPluginFormatName = "7-ZIP";
+
+
+static int FindPropNameID(PROPID propID)
+{
+ if (propID > NMessageID::k_Last_PropId_supported_by_plugin)
+ return -1;
+ return NMessageID::kNoProperty + (int)propID;
+}
+
+/*
+struct CPropertyIDInfo
+{
+ PROPID PropID;
+ const char *FarID;
+ int Width;
+ // char CharID;
+};
+
+static CPropertyIDInfo kPropertyIDInfos[] =
+{
+ { kpidName, "N", 0},
+ { kpidSize, "S", 8},
+ { kpidPackSize, "P", 8},
+ { kpidAttrib, "A", 0},
+ { kpidCTime, "DC", 14},
+ { kpidATime, "DA", 14},
+ { kpidMTime, "DM", 14},
+
+ { kpidSolid, NULL, 0, 'S'},
+ { kpidEncrypted, NULL, 0, 'P'},
+
+ { kpidDictionarySize, IDS_PROPERTY_DICTIONARY_SIZE },
+ { kpidSplitBefore, NULL, 'B'},
+ { kpidSplitAfter, NULL, 'A'},
+ { kpidComment, NULL, 'C'},
+ { kpidCRC, IDS_PROPERTY_CRC }
+ // { kpidType, L"Type" }
+};
+
+static const int kNumPropertyIDInfos = Z7_ARRAY_SIZE(kPropertyIDInfos);
+
+static int FindPropertyInfo(PROPID propID)
+{
+ for (int i = 0; i < kNumPropertyIDInfos; i++)
+ if (kPropertyIDInfos[i].PropID == propID)
+ return i;
+ return -1;
+}
+*/
+
+// char *g_Titles[] = { "a", "f", "v" };
+/*
+static void SmartAddToString(AString &destString, const char *srcString)
+{
+ if (!destString.IsEmpty())
+ destString += ',';
+ destString += srcString;
+}
+*/
+
+/*
+void CPlugin::AddColumn(PROPID propID)
+{
+ int index = FindPropertyInfo(propID);
+ if (index >= 0)
+ {
+ for (int i = 0; i < m_ProxyHandler->m_InternalProperties.Size(); i++)
+ {
+ const CArchiveItemProperty &aHandlerProperty = m_ProxyHandler->m_InternalProperties[i];
+ if (aHandlerProperty.ID == propID)
+ break;
+ }
+ if (i == m_ProxyHandler->m_InternalProperties.Size())
+ return;
+
+ const CPropertyIDInfo &propertyIDInfo = kPropertyIDInfos[index];
+ SmartAddToString(PanelModeColumnTypes, propertyIDInfo.FarID);
+ char tmp[32];
+ itoa(propertyIDInfo.Width, tmp, 10);
+ SmartAddToString(PanelModeColumnWidths, tmp);
+ return;
+ }
+}
+*/
+
+static AString GetNameOfProp(PROPID propID, const wchar_t *name)
+{
+ int farID = FindPropNameID(propID);
+ if (farID >= 0)
+ return (AString)g_StartupInfo.GetMsgString(farID);
+ if (name)
+ return UnicodeStringToMultiByte(name, CP_OEMCP);
+ char s[16];
+ ConvertUInt32ToString(propID, s);
+ return (AString)s;
+}
+
+static AString GetNameOfProp2(PROPID propID, const wchar_t *name)
+{
+ AString s (GetNameOfProp(propID, name));
+ if (s.Len() > (kInfoPanelLineSize - 1))
+ s.DeleteFrom(kInfoPanelLineSize - 1);
+ return s;
+}
+
+static AString ConvertSizeToString(UInt64 value)
+{
+ char s[32];
+ ConvertUInt64ToString(value, s);
+ unsigned i = MyStringLen(s);
+ unsigned pos = Z7_ARRAY_SIZE(s);
+ s[--pos] = 0;
+ while (i > 3)
+ {
+ s[--pos] = s[--i];
+ s[--pos] = s[--i];
+ s[--pos] = s[--i];
+ s[--pos] = ' ';
+ }
+ while (i > 0)
+ s[--pos] = s[--i];
+ return (AString)(s + pos);
+}
+
+static AString PropToString(const NCOM::CPropVariant &prop, PROPID propID)
+{
+ if (prop.vt == VT_BSTR)
+ {
+ AString s (UnicodeStringToMultiByte(prop.bstrVal, CP_OEMCP));
+ s.Replace((char)0xA, ' ');
+ s.Replace((char)0xD, ' ');
+ return s;
+ }
+ if (prop.vt == VT_BOOL)
+ {
+ int messageID = VARIANT_BOOLToBool(prop.boolVal) ?
+ NMessageID::kYes : NMessageID::kNo;
+ return (AString)g_StartupInfo.GetMsgString(messageID);
+ }
+ if (prop.vt != VT_EMPTY)
+ {
+ if ((prop.vt == VT_UI8 || prop.vt == VT_UI4) && (
+ propID == kpidSize ||
+ propID == kpidPackSize ||
+ propID == kpidNumSubDirs ||
+ propID == kpidNumSubFiles ||
+ propID == kpidNumBlocks ||
+ propID == kpidPhySize ||
+ propID == kpidHeadersSize ||
+ propID == kpidClusterSize ||
+ propID == kpidUnpackSize
+ ))
+ {
+ UInt64 v = 0;
+ ConvertPropVariantToUInt64(prop, v);
+ return ConvertSizeToString(v);
+ }
+ {
+ char sz[64];
+ ConvertPropertyToShortString2(sz, prop, propID);
+ return (AString)sz;
+ }
+ }
+ return AString();
+}
+
+static AString PropToString2(const NCOM::CPropVariant &prop, PROPID propID)
+{
+ AString s (PropToString(prop, propID));
+ if (s.Len() > (kInfoPanelLineSize - 1))
+ s.DeleteFrom(kInfoPanelLineSize - 1);
+ return s;
+}
+
+static void AddPropertyString(InfoPanelLine *lines, unsigned &numItems, PROPID propID, const wchar_t *name,
+ const NCOM::CPropVariant &prop)
+{
+ if (prop.vt != VT_EMPTY)
+ {
+ AString val (PropToString2(prop, propID));
+ if (!val.IsEmpty())
+ {
+ InfoPanelLine &item = lines[numItems++];
+ COPY_STR_LIMITED(item.Text, GetNameOfProp2(propID, name));
+ COPY_STR_LIMITED(item.Data, val);
+ }
+ }
+}
+
+static void InsertSeparator(InfoPanelLine *lines, unsigned &numItems)
+{
+ if (numItems < kNumInfoLinesMax)
+ {
+ InfoPanelLine &item = lines[numItems++];
+ *item.Text = 0;
+ *item.Data = 0;
+ item.Separator = TRUE;
+ }
+}
+
+void CPlugin::GetOpenPluginInfo(struct OpenPluginInfo *info)
+{
+ info->StructSize = sizeof(*info);
+ info->Flags = OPIF_USEFILTER | OPIF_USESORTGROUPS | OPIF_USEHIGHLIGHTING |
+ OPIF_ADDDOTS | OPIF_COMPAREFATTIME;
+
+ COPY_STR_LIMITED(m_FileNameBuffer, UnicodeStringToMultiByte(fs2us(m_FileName), CP_OEMCP));
+ info->HostFile = m_FileNameBuffer; // test it it is not static
+
+ COPY_STR_LIMITED(m_CurrentDirBuffer, UnicodeStringToMultiByte(m_CurrentDir, CP_OEMCP));
+ info->CurDir = m_CurrentDirBuffer;
+
+ info->Format = kPluginFormatName;
+
+ {
+ UString name;
+ {
+ FString dirPrefix, fileName;
+ GetFullPathAndSplit(m_FileName, dirPrefix, fileName);
+ name = fs2us(fileName);
+ }
+
+ m_PannelTitle = ' ';
+ m_PannelTitle += _archiveTypeName;
+ m_PannelTitle += ':';
+ m_PannelTitle += name;
+ m_PannelTitle.Add_Space();
+ if (!m_CurrentDir.IsEmpty())
+ {
+ // m_PannelTitle += '\\';
+ m_PannelTitle += m_CurrentDir;
+ }
+
+ COPY_STR_LIMITED(m_PannelTitleBuffer, UnicodeStringToMultiByte(m_PannelTitle, CP_OEMCP));
+ info->PanelTitle = m_PannelTitleBuffer;
+
+ }
+
+ memset(m_InfoLines, 0, sizeof(m_InfoLines));
+ m_InfoLines[0].Text[0] = 0;
+ m_InfoLines[0].Separator = TRUE;
+
+ MyStringCopy(m_InfoLines[1].Text, g_StartupInfo.GetMsgString(NMessageID::kArchiveType));
+ MyStringCopy(m_InfoLines[1].Data, (const char *)UnicodeStringToMultiByte(_archiveTypeName, CP_OEMCP));
+
+ unsigned numItems = 2;
+
+ {
+ CMyComPtr<IFolderProperties> folderProperties;
+ _folder.QueryInterface(IID_IFolderProperties, &folderProperties);
+ if (folderProperties)
+ {
+ UInt32 numProps;
+ if (folderProperties->GetNumberOfFolderProperties(&numProps) == S_OK)
+ {
+ for (UInt32 i = 0; i < numProps && numItems < kNumInfoLinesMax; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ if (folderProperties->GetFolderPropertyInfo(i, &name, &propID, &vt) != S_OK)
+ continue;
+ NCOM::CPropVariant prop;
+ if (_folder->GetFolderProperty(propID, &prop) != S_OK || prop.vt == VT_EMPTY)
+ continue;
+
+ InfoPanelLine &item = m_InfoLines[numItems++];
+ COPY_STR_LIMITED(item.Text, GetNameOfProp2(propID, name));
+ COPY_STR_LIMITED(item.Data, PropToString2(prop, propID));
+ }
+ }
+ }
+ }
+
+ /*
+ if (numItems < kNumInfoLinesMax)
+ {
+ InsertSeparator(m_InfoLines, numItems);
+ }
+ */
+
+ {
+ CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+ _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+ if (getFolderArcProps)
+ {
+ CMyComPtr<IFolderArcProps> getProps;
+ getFolderArcProps->GetFolderArcProps(&getProps);
+ if (getProps)
+ {
+ UInt32 numLevels;
+ if (getProps->GetArcNumLevels(&numLevels) != S_OK)
+ numLevels = 0;
+ for (UInt32 level2 = 0; level2 < numLevels; level2++)
+ {
+ {
+ UInt32 level = numLevels - 1 - level2;
+ UInt32 numProps;
+ if (getProps->GetArcNumProps(level, &numProps) == S_OK)
+ {
+ InsertSeparator(m_InfoLines, numItems);
+ for (Int32 i = -3; i < (Int32)numProps && numItems < kNumInfoLinesMax; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ switch (i)
+ {
+ case -3: propID = kpidPath; break;
+ case -2: propID = kpidType; break;
+ case -1: propID = kpidError; break;
+ default:
+ if (getProps->GetArcPropInfo(level, (UInt32)i, &name, &propID, &vt) != S_OK)
+ continue;
+ }
+ NCOM::CPropVariant prop;
+ if (getProps->GetArcProp(level, propID, &prop) != S_OK)
+ continue;
+ AddPropertyString(m_InfoLines, numItems, propID, name, prop);
+ }
+ }
+ }
+ if (level2 != numLevels - 1)
+ {
+ UInt32 level = numLevels - 1 - level2;
+ UInt32 numProps;
+ if (getProps->GetArcNumProps2(level, &numProps) == S_OK)
+ {
+ InsertSeparator(m_InfoLines, numItems);
+ for (Int32 i = 0; i < (Int32)numProps && numItems < kNumInfoLinesMax; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ if (getProps->GetArcPropInfo2(level, (UInt32)i, &name, &propID, &vt) != S_OK)
+ continue;
+ NCOM::CPropVariant prop;
+ if (getProps->GetArcProp2(level, propID, &prop) != S_OK)
+ continue;
+ AddPropertyString(m_InfoLines, numItems, propID, name, prop);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ //m_InfoLines[1].Separator = 0;
+
+ info->InfoLines = m_InfoLines;
+ info->InfoLinesNumber = (int)numItems;
+
+
+ info->DescrFiles = NULL;
+ info->DescrFilesNumber = 0;
+
+ PanelModeColumnTypes.Empty();
+ PanelModeColumnWidths.Empty();
+
+ /*
+ AddColumn(kpidName);
+ AddColumn(kpidSize);
+ AddColumn(kpidPackSize);
+ AddColumn(kpidMTime);
+ AddColumn(kpidCTime);
+ AddColumn(kpidATime);
+ AddColumn(kpidAttrib);
+
+ _panelMode.ColumnTypes = (char *)(const char *)PanelModeColumnTypes;
+ _panelMode.ColumnWidths = (char *)(const char *)PanelModeColumnWidths;
+ _panelMode.ColumnTitles = NULL;
+ _panelMode.FullScreen = TRUE;
+ _panelMode.DetailedStatus = FALSE;
+ _panelMode.AlignExtensions = FALSE;
+ _panelMode.CaseConversion = FALSE;
+ _panelMode.StatusColumnTypes = "N";
+ _panelMode.StatusColumnWidths = "0";
+ _panelMode.Reserved[0] = 0;
+ _panelMode.Reserved[1] = 0;
+
+ info->PanelModesArray = &_panelMode;
+ info->PanelModesNumber = 1;
+ */
+
+ info->PanelModesArray = NULL;
+ info->PanelModesNumber = 0;
+
+ info->StartPanelMode = 0;
+ info->StartSortMode = 0;
+ info->KeyBar = NULL;
+ info->ShortcutData = NULL;
+}
+
+struct CArchiveItemProperty
+{
+ AString Name;
+ PROPID ID;
+ VARTYPE Type;
+};
+
+static inline char GetHex_Upper(unsigned v)
+{
+ return (char)((v < 10) ? ('0' + v) : ('A' + (v - 10)));
+}
+
+static inline char GetHex_Lower(unsigned v)
+{
+ return (char)((v < 10) ? ('0' + v) : ('a' + (v - 10)));
+}
+
+HRESULT CPlugin::ShowAttributesWindow()
+{
+ PluginPanelItem pluginPanelItem;
+ if (!g_StartupInfo.ControlGetActivePanelCurrentItemInfo(pluginPanelItem))
+ return S_FALSE;
+ if (strcmp(pluginPanelItem.FindData.cFileName, "..") == 0 &&
+ NFind::NAttributes::IsDir(pluginPanelItem.FindData.dwFileAttributes))
+ return S_FALSE;
+ const UInt32 itemIndex = (UInt32)pluginPanelItem.UserData;
+
+ CObjectVector<CArchiveItemProperty> properties;
+ UInt32 numProps;
+ RINOK(_folder->GetNumberOfProperties(&numProps))
+ unsigned i;
+ for (i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ RINOK(_folder->GetPropertyInfo(i, &name, &propID, &vt))
+ CArchiveItemProperty prop;
+ prop.Type = vt;
+ prop.ID = propID;
+ if (prop.ID == kpidPath)
+ prop.ID = kpidName;
+ prop.Name = GetNameOfProp(propID, name);
+ properties.Add(prop);
+ }
+
+ int size = 2;
+ CRecordVector<CInitDialogItem> initDialogItems;
+
+ int xSize = 70;
+ {
+ const CInitDialogItem idi =
+ { DI_DOUBLEBOX, 3, 1, xSize - 4, size - 2, false, false, 0, false, NMessageID::kProperties, NULL, NULL };
+ initDialogItems.Add(idi);
+ }
+
+ AStringVector values;
+
+ const int kStartY = 3;
+
+ for (i = 0; i < properties.Size(); i++)
+ {
+ const CArchiveItemProperty &property = properties[i];
+
+ const int startY = kStartY + (int)values.Size();
+
+ {
+ CInitDialogItem idi =
+ { DI_TEXT, 5, startY, 0, 0, false, false, 0, false, 0, NULL, NULL };
+ idi.DataMessageId = FindPropNameID(property.ID);
+ if (idi.DataMessageId < 0)
+ idi.DataString = property.Name;
+ initDialogItems.Add(idi);
+ }
+
+ NCOM::CPropVariant prop;
+ RINOK(_folder->GetProperty(itemIndex, property.ID, &prop))
+ values.Add(PropToString(prop, property.ID));
+
+ {
+ const CInitDialogItem idi =
+ { DI_TEXT, 30, startY, 0, 0, false, false, 0, false, -1, NULL, NULL };
+ initDialogItems.Add(idi);
+ }
+ }
+
+ CMyComPtr<IArchiveGetRawProps> _folderRawProps;
+ _folder.QueryInterface(IID_IArchiveGetRawProps, &_folderRawProps);
+
+ CObjectVector<CArchiveItemProperty> properties2;
+
+ if (_folderRawProps)
+ {
+ _folderRawProps->GetNumRawProps(&numProps);
+
+ for (i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ if (_folderRawProps->GetRawPropInfo(i, &name, &propID) != S_OK)
+ continue;
+ CArchiveItemProperty prop;
+ prop.Type = VT_EMPTY;
+ prop.ID = propID;
+ if (prop.ID == kpidPath)
+ prop.ID = kpidName;
+ prop.Name = GetNameOfProp(propID, name);
+ properties2.Add(prop);
+ }
+
+ for (i = 0; i < properties2.Size(); i++)
+ {
+ const CArchiveItemProperty &property = properties2[i];
+ CMyComBSTR name;
+
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+ if (_folderRawProps->GetRawProp(itemIndex, property.ID, &data, &dataSize, &propType) != S_OK)
+ continue;
+
+ if (dataSize != 0)
+ {
+ AString s;
+ if (property.ID == kpidNtSecure)
+ ConvertNtSecureToString((const Byte *)data, dataSize, s);
+ else
+ {
+ const UInt32 kMaxDataSize = 64;
+ if (dataSize > kMaxDataSize)
+ {
+ s += "data:";
+ s.Add_UInt32(dataSize);
+ }
+ else
+ {
+ const bool needUpper = (dataSize <= 8)
+ && (property.ID == kpidCRC || property.ID == kpidChecksum);
+ for (UInt32 k = 0; k < dataSize; k++)
+ {
+ unsigned b = ((const Byte *)data)[k];
+ if (needUpper)
+ {
+ s += GetHex_Upper((b >> 4) & 0xF);
+ s += GetHex_Upper(b & 0xF);
+ }
+ else
+ {
+ s += GetHex_Lower((b >> 4) & 0xF);
+ s += GetHex_Lower(b & 0xF);
+ }
+ }
+ }
+ }
+
+ const int startY = kStartY + (int)values.Size();
+
+ {
+ CInitDialogItem idi =
+ { DI_TEXT, 5, startY, 0, 0, false, false, 0, false, 0, NULL, NULL };
+ idi.DataMessageId = FindPropNameID(property.ID);
+ if (idi.DataMessageId < 0)
+ idi.DataString = property.Name;
+ initDialogItems.Add(idi);
+ }
+
+ values.Add(s);
+
+ {
+ const CInitDialogItem idi =
+ { DI_TEXT, 30, startY, 0, 0, false, false, 0, false, -1, NULL, NULL };
+ initDialogItems.Add(idi);
+ }
+ }
+ }
+ }
+
+ const unsigned numLines = values.Size();
+ for (i = 0; i < numLines; i++)
+ {
+ CInitDialogItem &idi = initDialogItems[1 + i * 2 + 1];
+ idi.DataString = values[i];
+ }
+
+ const unsigned numDialogItems = initDialogItems.Size();
+
+ CObjArray<FarDialogItem> dialogItems(numDialogItems);
+ g_StartupInfo.InitDialogItems(&initDialogItems.Front(), dialogItems, numDialogItems);
+
+ unsigned maxLen = 0;
+
+ for (i = 0; i < numLines; i++)
+ {
+ FarDialogItem &dialogItem = dialogItems[1 + i * 2];
+ unsigned len = (unsigned)strlen(dialogItem.Data);
+ if (len > maxLen)
+ maxLen = len;
+ }
+
+ unsigned maxLen2 = 0;
+ const unsigned kSpace = 10;
+
+ for (i = 0; i < numLines; i++)
+ {
+ FarDialogItem &dialogItem = dialogItems[1 + i * 2 + 1];
+ const unsigned len = (unsigned)strlen(dialogItem.Data);
+ if (len > maxLen2)
+ maxLen2 = len;
+ dialogItem.X1 = (int)(maxLen + kSpace);
+ }
+
+ size = (int)numLines + 6;
+ xSize = (int)(maxLen + kSpace + maxLen2 + 5);
+ FarDialogItem &firstDialogItem = dialogItems[0];
+ firstDialogItem.Y2 = size - 2;
+ firstDialogItem.X2 = xSize - 4;
+
+ /* int askCode = */ g_StartupInfo.ShowDialog(xSize, size, NULL, dialogItems, numDialogItems);
+ return S_OK;
+}
+
+int CPlugin::ProcessKey(int key, unsigned int controlState)
+{
+ if (key == VK_F7 && controlState == 0)
+ {
+ CreateFolder();
+ return TRUE;
+ }
+
+ if (controlState == PKF_CONTROL && key == 'A')
+ {
+ HRESULT result = ShowAttributesWindow();
+ if (result == S_OK)
+ return TRUE;
+ if (result == S_FALSE)
+ return FALSE;
+ throw "Error";
+ }
+
+ if ((controlState & PKF_ALT) != 0 && key == VK_F6)
+ {
+ FString folderPath;
+ if (!GetOnlyDirPrefix(m_FileName, folderPath))
+ return FALSE;
+ PanelInfo panelInfo;
+ g_StartupInfo.ControlGetActivePanelInfo(panelInfo);
+ GetFilesReal(panelInfo.SelectedItems,
+ (unsigned)panelInfo.SelectedItemsNumber, FALSE,
+ UnicodeStringToMultiByte(fs2us(folderPath), CP_OEMCP), OPM_SILENT, true);
+ g_StartupInfo.Control(this, FCTL_UPDATEPANEL, NULL);
+ g_StartupInfo.Control(this, FCTL_REDRAWPANEL, NULL);
+ g_StartupInfo.Control(this, FCTL_UPDATEANOTHERPANEL, NULL);
+ g_StartupInfo.Control(this, FCTL_REDRAWANOTHERPANEL, NULL);
+ return TRUE;
+ }
+
+ return FALSE;
+}
diff --git a/CPP/7zip/UI/Far/Plugin.h b/CPP/7zip/UI/Far/Plugin.h
new file mode 100644
index 0000000..00ccc81
--- /dev/null
+++ b/CPP/7zip/UI/Far/Plugin.h
@@ -0,0 +1,94 @@
+// 7zip/Far/Plugin.h
+
+#ifndef ZIP7_INC_7ZIP_FAR_PLUGIN_H
+#define ZIP7_INC_7ZIP_FAR_PLUGIN_H
+
+#include "../../../Common/MyCom.h"
+
+// #include "../../../Windows/COM.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../Common/WorkDir.h"
+
+#include "../Agent/Agent.h"
+
+#include "FarUtils.h"
+
+const UInt32 kNumInfoLinesMax = 64;
+
+class CPlugin
+{
+ CAgent *_agent;
+ CMyComPtr<IInFolderArchive> m_ArchiveHandler;
+ CMyComPtr<IFolderFolder> _folder;
+
+ // NWindows::NCOM::CComInitializer m_ComInitializer;
+ UString m_CurrentDir;
+
+ UString m_PannelTitle;
+ FString m_FileName;
+ NWindows::NFile::NFind::CFileInfo m_FileInfo;
+
+ UString _archiveTypeName;
+
+ InfoPanelLine m_InfoLines[kNumInfoLinesMax];
+
+ char m_FileNameBuffer[1024];
+ char m_CurrentDirBuffer[1024];
+ char m_PannelTitleBuffer[1024];
+
+ AString PanelModeColumnTypes;
+ AString PanelModeColumnWidths;
+ // PanelMode _panelMode;
+ void AddColumn(PROPID aPropID);
+
+ void EnterToDirectory(const UString &dirName);
+ void GetPathParts(UStringVector &pathParts);
+ void SetCurrentDirVar();
+ // HRESULT AfterUpdate(CWorkDirTempFile &tempFile, const UStringVector &pathVector);
+
+public:
+
+ bool PasswordIsDefined;
+ UString Password;
+
+ CPlugin(const FString &fileName, CAgent *agent, UString archiveTypeName);
+ ~CPlugin();
+
+ void ReadPluginPanelItem(PluginPanelItem &panelItem, UInt32 itemIndex);
+
+ int GetFindData(PluginPanelItem **panelItems,int *itemsNumber,int opMode);
+ void FreeFindData(PluginPanelItem *panelItem,int ItemsNumber);
+ int SetDirectory(const char *aszDir, int opMode);
+ void GetOpenPluginInfo(struct OpenPluginInfo *info);
+ int DeleteFiles(PluginPanelItem *panelItems, unsigned itemsNumber, int opMode);
+
+ HRESULT ExtractFiles(
+ bool decompressAllItems,
+ const UInt32 *indices,
+ UInt32 numIndices,
+ bool silent,
+ NExtract::NPathMode::EEnum pathMode,
+ NExtract::NOverwriteMode::EEnum overwriteMode,
+ const UString &destPath,
+ bool passwordIsDefined, const UString &password);
+
+ NFar::NFileOperationReturnCode::EEnum GetFiles(struct PluginPanelItem *panelItem, unsigned itemsNumber,
+ int move, char *destPath, int opMode);
+
+ NFar::NFileOperationReturnCode::EEnum GetFilesReal(struct PluginPanelItem *panelItems,
+ unsigned itemsNumber, int move, const char *_aDestPath, int opMode, bool showBox);
+
+ NFar::NFileOperationReturnCode::EEnum PutFiles(struct PluginPanelItem *panelItems, unsigned itemsNumber,
+ int move, int opMode);
+ HRESULT CreateFolder();
+
+ HRESULT ShowAttributesWindow();
+
+ int ProcessKey(int key, unsigned int controlState);
+};
+
+HRESULT CompressFiles(const CObjectVector<PluginPanelItem> &pluginPanelItems);
+
+#endif
diff --git a/CPP/7zip/UI/Far/PluginCommon.cpp b/CPP/7zip/UI/Far/PluginCommon.cpp
new file mode 100644
index 0000000..e1d4458
--- /dev/null
+++ b/CPP/7zip/UI/Far/PluginCommon.cpp
@@ -0,0 +1,50 @@
+// SevenZip/Plugin.cpp
+
+#include "StdAfx.h"
+
+#include "Plugin.h"
+
+/*
+void CPlugin::AddRealIndexOfFile(const CArchiveFolderItem &aFolder,
+ int anIndexInVector, vector<int> &aRealIndexes)
+{
+ const CArchiveFolderFileItem &anItem = aFolder.m_FileSubItems[anIndexInVector];
+ int aHandlerItemIndex = m_ProxyHandler->GetHandlerItemIndex(anItem.m_Properties);
+ if (aHandlerItemIndex < 0)
+ throw "error";
+ aRealIndexes.push_back(aHandlerItemIndex);
+}
+
+void CPlugin::AddRealIndexes(const CArchiveFolderItem &anItem,
+ vector<int> &aRealIndexes)
+{
+ int aHandlerItemIndex = m_ProxyHandler->GetHandlerItemIndex(anItem.m_Properties);
+ if (aHandlerItemIndex >= 0) // test -1 value
+ aRealIndexes.push_back(aHandlerItemIndex);
+ for (int i = 0; i < anItem.m_DirSubItems.Size(); i++)
+ AddRealIndexes(anItem.m_DirSubItems[i], aRealIndexes);
+ for (i = 0; i < anItem.m_FileSubItems.Size(); i++)
+ AddRealIndexOfFile(anItem, i , aRealIndexes);
+}
+
+
+void CPlugin::GetRealIndexes(PluginPanelItem *aPanelItems, int anItemsNumber,
+ vector<int> &aRealIndexes)
+{
+ aRealIndexes.clear();
+ for (int i = 0; i < anItemsNumber; i++)
+ {
+ int anIndex = aPanelItems[i].UserData;
+ if (anIndex < m_FolderItem->m_DirSubItems.Size())
+ {
+ const CArchiveFolderItem &anItem = m_FolderItem->m_DirSubItems[anIndex];
+ AddRealIndexes(anItem, aRealIndexes);
+ }
+ else
+ AddRealIndexOfFile(*m_FolderItem, anIndex - m_FolderItem->m_DirSubItems.Size(),
+ aRealIndexes);
+ }
+ sort(aRealIndexes.begin(), aRealIndexes.end());
+}
+
+*/
diff --git a/CPP/7zip/UI/Far/PluginDelete.cpp b/CPP/7zip/UI/Far/PluginDelete.cpp
new file mode 100644
index 0000000..fdade1a
--- /dev/null
+++ b/CPP/7zip/UI/Far/PluginDelete.cpp
@@ -0,0 +1,144 @@
+// PluginDelete.cpp
+
+#include "StdAfx.h"
+
+#include <stdio.h>
+
+#include "../../../Common/StringConvert.h"
+#include "FarUtils.h"
+
+#include "Messages.h"
+#include "Plugin.h"
+#include "UpdateCallbackFar.h"
+
+using namespace NFar;
+
+int CPlugin::DeleteFiles(PluginPanelItem *panelItems, unsigned numItems, int opMode)
+{
+ if (numItems == 0)
+ return FALSE;
+ if (_agent->IsThere_ReadOnlyArc())
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return FALSE;
+ }
+ if ((opMode & OPM_SILENT) == 0)
+ {
+ const char *msgItems[]=
+ {
+ g_StartupInfo.GetMsgString(NMessageID::kDeleteTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kDeleteFiles),
+ g_StartupInfo.GetMsgString(NMessageID::kDeleteDelete),
+ g_StartupInfo.GetMsgString(NMessageID::kDeleteCancel)
+ };
+
+ // char msg[1024];
+ AString str1;
+
+ if (numItems == 1)
+ {
+ str1 = g_StartupInfo.GetMsgString(NMessageID::kDeleteFile);
+ AString name (panelItems[0].FindData.cFileName);
+ const unsigned kSizeLimit = 48;
+ if (name.Len() > kSizeLimit)
+ {
+ UString s = MultiByteToUnicodeString(name, CP_OEMCP);
+ ReduceString(s, kSizeLimit);
+ name = UnicodeStringToMultiByte(s, CP_OEMCP);
+ }
+ str1.Replace(AString ("%.40s"), name);
+ msgItems[1] = str1;
+ // sprintf(msg, g_StartupInfo.GetMsgString(NMessageID::kDeleteFile), panelItems[0].FindData.cFileName);
+ // msgItems[2] = msg;
+ }
+ else if (numItems > 1)
+ {
+ str1 = g_StartupInfo.GetMsgString(NMessageID::kDeleteNumberOfFiles);
+ {
+ AString n;
+ n.Add_UInt32(numItems);
+ str1.Replace(AString ("%d"), n);
+ }
+ msgItems[1] = str1;
+ // sprintf(msg, g_StartupInfo.GetMsgString(NMessageID::kDeleteNumberOfFiles), numItems);
+ // msgItems[1] = msg;
+ }
+ if (g_StartupInfo.ShowMessage(FMSG_WARNING, NULL, msgItems, Z7_ARRAY_SIZE(msgItems), 2) != 0)
+ return (FALSE);
+ }
+
+ CScreenRestorer screenRestorer;
+ CProgressBox progressBox;
+ CProgressBox *progressBoxPointer = NULL;
+ if ((opMode & OPM_SILENT) == 0 && (opMode & OPM_FIND ) == 0)
+ {
+ screenRestorer.Save();
+
+ progressBoxPointer = &progressBox;
+ progressBox.Init(
+ // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kDeleting));
+ }
+
+ /*
+ CWorkDirTempFile tempFile;
+ if (tempFile.CreateTempFile(m_FileName) != S_OK)
+ return FALSE;
+ */
+
+ CObjArray<UInt32> indices(numItems);
+ unsigned i;
+ for (i = 0; i < numItems; i++)
+ indices[i] = (UInt32)panelItems[i].UserData;
+
+ /*
+ UStringVector pathVector;
+ GetPathParts(pathVector);
+
+ CMyComPtr<IOutFolderArchive> outArchive;
+ HRESULT result = m_ArchiveHandler.QueryInterface(IID_IOutFolderArchive, &outArchive);
+ if (result != S_OK)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return FALSE;
+ }
+ */
+
+ CUpdateCallback100Imp *updateCallbackSpec = new CUpdateCallback100Imp;
+ CMyComPtr<IFolderArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ updateCallbackSpec->Init(/* m_ArchiveHandler, */ progressBoxPointer);
+ updateCallbackSpec->PasswordIsDefined = PasswordIsDefined;
+ updateCallbackSpec->Password = Password;
+
+ /*
+ outArchive->SetFolder(_folder);
+ result = outArchive->DeleteItems(tempFile.OutStream, indices, numItems, updateCallback);
+ updateCallback.Release();
+ outArchive.Release();
+
+ if (result == S_OK)
+ {
+ result = AfterUpdate(tempFile, pathVector);
+ }
+ */
+
+ HRESULT result;
+ {
+ CMyComPtr<IFolderOperations> folderOperations;
+ result = _folder.QueryInterface(IID_IFolderOperations, &folderOperations);
+ if (folderOperations)
+ result = folderOperations->Delete(indices, numItems, updateCallback);
+ else if (result != S_OK)
+ result = E_FAIL;
+ }
+
+ if (result != S_OK)
+ {
+ ShowSysErrorMessage(result);
+ return FALSE;
+ }
+
+ SetCurrentDirVar();
+ return TRUE;
+}
diff --git a/CPP/7zip/UI/Far/PluginRead.cpp b/CPP/7zip/UI/Far/PluginRead.cpp
new file mode 100644
index 0000000..7e81ddd
--- /dev/null
+++ b/CPP/7zip/UI/Far/PluginRead.cpp
@@ -0,0 +1,301 @@
+// PluginRead.cpp
+
+#include "StdAfx.h"
+
+#include "Plugin.h"
+
+#include "Messages.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileDir.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "ExtractEngine.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NFar;
+
+static const char * const kHelpTopicExtrFromSevenZip = "Extract";
+
+static const char kDirDelimiter = CHAR_PATH_SEPARATOR;
+
+static const char * const kExractPathHistoryName = "7-ZipExtractPath";
+
+HRESULT CPlugin::ExtractFiles(
+ bool decompressAllItems,
+ const UInt32 *indices,
+ UInt32 numIndices,
+ bool silent,
+ NExtract::NPathMode::EEnum pathMode,
+ NExtract::NOverwriteMode::EEnum overwriteMode,
+ const UString &destPath,
+ bool passwordIsDefined, const UString &password)
+{
+ if (_agent->_isHashHandler)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kMoveIsNotSupported);
+ return NFileOperationReturnCode::kError;
+ }
+
+ CScreenRestorer screenRestorer;
+ CProgressBox progressBox;
+ CProgressBox *progressBoxPointer = NULL;
+ if (!silent)
+ {
+ screenRestorer.Save();
+
+ progressBoxPointer = &progressBox;
+ progressBox.Init(
+ // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kExtracting));
+ }
+
+
+ CExtractCallbackImp *extractCallbackSpec = new CExtractCallbackImp;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback(extractCallbackSpec);
+
+ extractCallbackSpec->Init(
+ CP_OEMCP,
+ progressBoxPointer,
+ /*
+ GetDefaultName(m_FileName, m_ArchiverInfo.Extension),
+ m_FileInfo.MTime, m_FileInfo.Attributes,
+ */
+ passwordIsDefined, password);
+
+ if (decompressAllItems)
+ return m_ArchiveHandler->Extract(pathMode, overwriteMode,
+ destPath, BoolToInt(false), extractCallback);
+ else
+ {
+ CMyComPtr<IArchiveFolder> archiveFolder;
+ _folder.QueryInterface(IID_IArchiveFolder, &archiveFolder);
+
+ return archiveFolder->Extract(indices, numIndices,
+ BoolToInt(true), // includeAltStreams
+ BoolToInt(false), // replaceAltStreamChars
+ pathMode, overwriteMode,
+ destPath, BoolToInt(false), extractCallback);
+ }
+}
+
+NFileOperationReturnCode::EEnum CPlugin::GetFiles(struct PluginPanelItem *panelItems,
+ unsigned itemsNumber, int move, char *destPath, int opMode)
+{
+ return GetFilesReal(panelItems, itemsNumber, move,
+ destPath, opMode, (opMode & OPM_SILENT) == 0);
+}
+
+NFileOperationReturnCode::EEnum CPlugin::GetFilesReal(struct PluginPanelItem *panelItems,
+ unsigned itemsNumber, int move, const char *destPathLoc, int opMode, bool showBox)
+{
+ if (move != 0)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kMoveIsNotSupported);
+ return NFileOperationReturnCode::kError;
+ }
+
+ AString destPath (destPathLoc);
+ UString destPathU = GetUnicodeString(destPath, CP_OEMCP);
+ NName::NormalizeDirPathPrefix(destPathU);
+ destPath = UnicodeStringToMultiByte(destPathU, CP_OEMCP);
+
+ // bool extractSelectedFiles = true;
+
+ NExtract::CInfo extractionInfo;
+ extractionInfo.PathMode = NExtract::NPathMode::kCurPaths;
+ extractionInfo.OverwriteMode = NExtract::NOverwriteMode::kOverwrite;
+
+ const bool silent = (opMode & OPM_SILENT) != 0;
+ bool decompressAllItems = false;
+ UString password = Password;
+ bool passwordIsDefined = PasswordIsDefined;
+
+ if (!silent)
+ {
+ const int kPathIndex = 2;
+
+ extractionInfo.Load();
+
+ const int kPathModeRadioIndex = 4;
+ const int kOverwriteModeRadioIndex = kPathModeRadioIndex + 4;
+ const int kNumOverwriteOptions = 6;
+ const int kFilesModeIndex = kOverwriteModeRadioIndex + kNumOverwriteOptions;
+ const int kXSize = 76;
+ const int kYSize = 19;
+ const int kPasswordYPos = 12;
+
+ const int kXMid = kXSize / 2;
+
+ AString oemPassword (UnicodeStringToMultiByte(password, CP_OEMCP));
+
+ struct CInitDialogItem initItems[]={
+ { DI_DOUBLEBOX, 3, 1, kXSize - 4, kYSize - 2, false, false, 0, false, NMessageID::kExtractTitle, NULL, NULL },
+ { DI_TEXT, 5, 2, 0, 0, false, false, 0, false, NMessageID::kExtractTo, NULL, NULL },
+
+ { DI_EDIT, 5, 3, kXSize - 6, 3, true, false, DIF_HISTORY, false, -1, destPath, kExractPathHistoryName},
+ // { DI_EDIT, 5, 3, kXSize - 6, 3, true, false, 0, false, -1, destPath, NULL},
+
+ { DI_SINGLEBOX, 4, 5, kXMid - 2, 5 + 4, false, false, 0, false, NMessageID::kExtractPathMode, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 6, 0, 0, false,
+ extractionInfo.PathMode == NExtract::NPathMode::kFullPaths,
+ DIF_GROUP, false, NMessageID::kExtractPathFull, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 7, 0, 0, false,
+ extractionInfo.PathMode == NExtract::NPathMode::kCurPaths,
+ 0, false, NMessageID::kExtractPathCurrent, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 8, 0, 0, false,
+ extractionInfo.PathMode == NExtract::NPathMode::kNoPaths,
+ false, 0, NMessageID::kExtractPathNo, NULL, NULL },
+
+ { DI_SINGLEBOX, kXMid, 5, kXSize - 6, 5 + kNumOverwriteOptions, false, false, 0, false, NMessageID::kExtractOwerwriteMode, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 6, 0, 0, false,
+ extractionInfo.OverwriteMode == NExtract::NOverwriteMode::kAsk,
+ DIF_GROUP, false, NMessageID::kExtractOwerwriteAsk, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 7, 0, 0, false,
+ extractionInfo.OverwriteMode == NExtract::NOverwriteMode::kOverwrite,
+ 0, false, NMessageID::kExtractOwerwritePrompt, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 8, 0, 0, false,
+ extractionInfo.OverwriteMode == NExtract::NOverwriteMode::kSkip,
+ 0, false, NMessageID::kExtractOwerwriteSkip, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 9, 0, 0, false,
+ extractionInfo.OverwriteMode == NExtract::NOverwriteMode::kRename,
+ 0, false, NMessageID::kExtractOwerwriteAutoRename, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 10, 0, 0, false,
+ extractionInfo.OverwriteMode == NExtract::NOverwriteMode::kRenameExisting,
+ 0, false, NMessageID::kExtractOwerwriteAutoRenameExisting, NULL, NULL },
+
+ { DI_SINGLEBOX, 4, 10, kXMid- 2, 10 + 3, false, false, 0, false, NMessageID::kExtractFilesMode, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 11, 0, 0, false, true, DIF_GROUP, false, NMessageID::kExtractFilesSelected, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 12, 0, 0, false, false, 0, false, NMessageID::kExtractFilesAll, NULL, NULL },
+
+ { DI_SINGLEBOX, kXMid, kPasswordYPos, kXSize - 6, kPasswordYPos + 2, false, false, 0, false, NMessageID::kExtractPassword, NULL, NULL },
+ { DI_PSWEDIT, kXMid + 2, kPasswordYPos + 1, kXSize - 8, 12, false, false, 0, false, -1, oemPassword, NULL},
+
+ { DI_TEXT, 3, kYSize - 4, 0, 0, false, false, DIF_BOXCOLOR|DIF_SEPARATOR, false, -1, "", NULL },
+
+
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, true, NMessageID::kExtractExtract, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kExtractCancel, NULL, NULL }
+ };
+
+ const unsigned kNumDialogItems = Z7_ARRAY_SIZE(initItems);
+ const unsigned kOkButtonIndex = kNumDialogItems - 2;
+ const unsigned kPasswordIndex = kNumDialogItems - 4;
+
+ FarDialogItem dialogItems[kNumDialogItems];
+ g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumDialogItems);
+ for (;;)
+ {
+ int askCode = g_StartupInfo.ShowDialog(kXSize, kYSize,
+ kHelpTopicExtrFromSevenZip, dialogItems, kNumDialogItems);
+ if (askCode != kOkButtonIndex)
+ return NFileOperationReturnCode::kInterruptedByUser;
+ destPath = dialogItems[kPathIndex].Data;
+ destPathU = GetUnicodeString(destPath, CP_OEMCP);
+ destPathU.Trim();
+ if (destPathU.IsEmpty())
+ {
+ #ifdef UNDER_CE
+ destPathU = "\\";
+ #else
+ FString destPathF = us2fs(destPathU);
+ if (!GetCurrentDir(destPathF))
+ throw 318016;
+ NName::NormalizeDirPathPrefix(destPathF);
+ destPathU = fs2us(destPathF);
+ #endif
+ break;
+ }
+ else
+ {
+ if (destPathU.Back() == kDirDelimiter)
+ break;
+ }
+ g_StartupInfo.ShowErrorMessage("You must specify directory path");
+ }
+
+ if (dialogItems[kPathModeRadioIndex].Selected)
+ extractionInfo.PathMode = NExtract::NPathMode::kFullPaths;
+ else if (dialogItems[kPathModeRadioIndex + 1].Selected)
+ extractionInfo.PathMode = NExtract::NPathMode::kCurPaths;
+ else if (dialogItems[kPathModeRadioIndex + 2].Selected)
+ extractionInfo.PathMode = NExtract::NPathMode::kNoPaths;
+ else
+ throw 31806;
+
+ if (dialogItems[kOverwriteModeRadioIndex].Selected)
+ extractionInfo.OverwriteMode = NExtract::NOverwriteMode::kAsk;
+ else if (dialogItems[kOverwriteModeRadioIndex + 1].Selected)
+ extractionInfo.OverwriteMode = NExtract::NOverwriteMode::kOverwrite;
+ else if (dialogItems[kOverwriteModeRadioIndex + 2].Selected)
+ extractionInfo.OverwriteMode = NExtract::NOverwriteMode::kSkip;
+ else if (dialogItems[kOverwriteModeRadioIndex + 3].Selected)
+ extractionInfo.OverwriteMode = NExtract::NOverwriteMode::kRename;
+ else if (dialogItems[kOverwriteModeRadioIndex + 4].Selected)
+ extractionInfo.OverwriteMode = NExtract::NOverwriteMode::kRenameExisting;
+ else
+ throw 31806;
+
+ if (dialogItems[kFilesModeIndex].Selected)
+ decompressAllItems = false;
+ else if (dialogItems[kFilesModeIndex + 1].Selected)
+ decompressAllItems = true;
+ else
+ throw 31806;
+
+ extractionInfo.Save();
+
+ if (dialogItems[kFilesModeIndex].Selected)
+ {
+ // extractSelectedFiles = true;
+ }
+ else if (dialogItems[kFilesModeIndex + 1].Selected)
+ {
+ // extractSelectedFiles = false;
+ }
+ else
+ throw 31806;
+
+ oemPassword = dialogItems[kPasswordIndex].Data;
+ password = MultiByteToUnicodeString(oemPassword, CP_OEMCP);
+ passwordIsDefined = !password.IsEmpty();
+ }
+
+ CreateComplexDir(us2fs(destPathU));
+
+ /*
+ vector<int> realIndices;
+ if (!decompressAllItems)
+ GetRealIndexes(panelItems, itemsNumber, realIndices);
+ */
+ CObjArray<UInt32> indices(itemsNumber);
+ for (unsigned i = 0; i < itemsNumber; i++)
+ indices[i] = (UInt32)panelItems[i].UserData;
+
+ const HRESULT result = ExtractFiles(decompressAllItems, indices, itemsNumber,
+ !showBox, extractionInfo.PathMode, extractionInfo.OverwriteMode,
+ destPathU,
+ passwordIsDefined, password);
+ // HRESULT result = ExtractFiles(decompressAllItems, realIndices, !showBox,
+ // extractionInfo, destPath, passwordIsDefined, password);
+ if (result != S_OK)
+ {
+ if (result == E_ABORT)
+ return NFileOperationReturnCode::kInterruptedByUser;
+ ShowSysErrorMessage(result);
+ return NFileOperationReturnCode::kError;
+ }
+
+ // if (move != 0)
+ // {
+ // if (DeleteFiles(panelItems, itemsNumber, opMode) == FALSE)
+ // return NFileOperationReturnCode::kError;
+ // }
+ return NFileOperationReturnCode::kSuccess;
+}
diff --git a/CPP/7zip/UI/Far/PluginWrite.cpp b/CPP/7zip/UI/Far/PluginWrite.cpp
new file mode 100644
index 0000000..3f1fba8
--- /dev/null
+++ b/CPP/7zip/UI/Far/PluginWrite.cpp
@@ -0,0 +1,839 @@
+// PluginWrite.cpp
+
+#include "StdAfx.h"
+
+#include <stdio.h>
+
+#include "Plugin.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileFind.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "../Agent/Agent.h"
+
+#include "ProgressBox.h"
+#include "Messages.h"
+#include "UpdateCallbackFar.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NFar;
+
+using namespace NUpdateArchive;
+
+static const char * const kHelpTopic = "Update";
+
+static const char * const kArchiveHistoryKeyName = "7-ZipArcName";
+
+static const UInt32 g_MethodMap[] = { 0, 1, 3, 5, 7, 9 };
+
+static HRESULT SetOutProperties(IOutFolderArchive *outArchive, UInt32 method)
+{
+ CMyComPtr<ISetProperties> setProperties;
+ if (outArchive->QueryInterface(IID_ISetProperties, (void **)&setProperties) == S_OK)
+ {
+ /*
+ UStringVector realNames;
+ realNames.Add(UString("x"));
+ NCOM::CPropVariant value = (UInt32)method;
+ CRecordVector<const wchar_t *> names;
+ FOR_VECTOR (i, realNames)
+ names.Add(realNames[i]);
+ RINOK(setProperties->SetProperties(&names.Front(), &value, names.Size()));
+ */
+ NCOM::CPropVariant value = (UInt32)method;
+ const wchar_t *name = L"x";
+ RINOK(setProperties->SetProperties(&name, &value, 1))
+ }
+ return S_OK;
+}
+
+/*
+HRESULT CPlugin::AfterUpdate(CWorkDirTempFile &tempFile, const UStringVector &pathVector)
+{
+ _folder.Release();
+ m_ArchiveHandler->Close();
+
+ RINOK(tempFile.MoveToOriginal(true));
+
+ RINOK(m_ArchiveHandler->ReOpen(NULL)); // check it
+
+ m_ArchiveHandler->BindToRootFolder(&_folder);
+ FOR_VECTOR (i, pathVector)
+ {
+ CMyComPtr<IFolderFolder> newFolder;
+ _folder->BindToFolder(pathVector[i], &newFolder);
+ if (!newFolder)
+ break;
+ _folder = newFolder;
+ }
+ return S_OK;
+}
+*/
+
+NFileOperationReturnCode::EEnum CPlugin::PutFiles(
+ struct PluginPanelItem *panelItems, unsigned numItems,
+ int moveMode, int opMode)
+{
+ if (moveMode != 0
+ && _agent->_isHashHandler)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kMoveIsNotSupported);
+ return NFileOperationReturnCode::kError;
+ }
+
+ if (numItems <= 0)
+ return NFileOperationReturnCode::kError;
+
+ if (_agent->IsThere_ReadOnlyArc())
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return NFileOperationReturnCode::kError;
+ }
+
+ const int kYSize = 14;
+ const int kXMid = 38;
+
+ NCompression::CInfo compressionInfo;
+ compressionInfo.Load();
+
+ unsigned methodIndex = 0;
+
+ unsigned i;
+ for (i = Z7_ARRAY_SIZE(g_MethodMap); i != 0;)
+ {
+ i--;
+ if (compressionInfo.Level >= g_MethodMap[i])
+ {
+ methodIndex = i;
+ break;
+ }
+ }
+
+ const int kMethodRadioIndex = 2;
+ const int kModeRadioIndex = kMethodRadioIndex + 7;
+
+ struct CInitDialogItem initItems[]={
+ { DI_DOUBLEBOX, 3, 1, 72, kYSize - 2, false, false, 0, false, NMessageID::kUpdateTitle, NULL, NULL },
+
+ { DI_SINGLEBOX, 4, 2, kXMid - 2, 2 + 7, false, false, 0, false, NMessageID::kUpdateMethod, NULL, NULL },
+
+ { DI_RADIOBUTTON, 6, 3, 0, 0, methodIndex == 0, methodIndex == 0, DIF_GROUP, false, NMessageID::kUpdateMethod_Store, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 4, 0, 0, methodIndex == 1, methodIndex == 1, 0, false, NMessageID::kUpdateMethod_Fastest, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 5, 0, 0, methodIndex == 2, methodIndex == 2, 0, false, NMessageID::kUpdateMethod_Fast, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 6, 0, 0, methodIndex == 3, methodIndex == 3, 0, false, NMessageID::kUpdateMethod_Normal, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 7, 0, 0, methodIndex == 4, methodIndex == 4, 0, false, NMessageID::kUpdateMethod_Maximum, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 8, 0, 0, methodIndex == 5, methodIndex == 5, 0, false, NMessageID::kUpdateMethod_Ultra, NULL, NULL },
+
+ { DI_SINGLEBOX, kXMid, 2, 70, 2 + 5, false, false, 0, false, NMessageID::kUpdateMode, NULL, NULL },
+
+ { DI_RADIOBUTTON, kXMid + 2, 3, 0, 0, false, true, DIF_GROUP, false, NMessageID::kUpdateMode_Add, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 4, 0, 0, false, false, 0, false, NMessageID::kUpdateMode_Update, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 5, 0, 0, false, false, 0, false, NMessageID::kUpdateMode_Fresh, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 6, 0, 0, false, false, 0, false, NMessageID::kUpdateMode_Sync, NULL, NULL },
+
+ { DI_TEXT, 3, kYSize - 4, 0, 0, false, false, DIF_BOXCOLOR|DIF_SEPARATOR, false, -1, "", NULL },
+
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, true, NMessageID::kUpdateAdd, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kCancel, NULL, NULL }
+ };
+
+ const int kNumDialogItems = Z7_ARRAY_SIZE(initItems);
+ const int kOkButtonIndex = kNumDialogItems - 2;
+ FarDialogItem dialogItems[kNumDialogItems];
+ g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumDialogItems);
+ const int askCode = g_StartupInfo.ShowDialog(76, kYSize,
+ kHelpTopic, dialogItems, kNumDialogItems);
+ if (askCode != kOkButtonIndex)
+ return NFileOperationReturnCode::kInterruptedByUser;
+
+ compressionInfo.Level = g_MethodMap[0];
+ for (i = 0; i < Z7_ARRAY_SIZE(g_MethodMap); i++)
+ if (dialogItems[kMethodRadioIndex + i].Selected)
+ compressionInfo.Level = g_MethodMap[i];
+
+ const CActionSet *actionSet;
+
+ if (dialogItems[kModeRadioIndex ].Selected) actionSet = &k_ActionSet_Add;
+ else if (dialogItems[kModeRadioIndex + 1].Selected) actionSet = &k_ActionSet_Update;
+ else if (dialogItems[kModeRadioIndex + 2].Selected) actionSet = &k_ActionSet_Fresh;
+ else if (dialogItems[kModeRadioIndex + 3].Selected) actionSet = &k_ActionSet_Sync;
+ else throw 51751;
+
+ compressionInfo.Save();
+
+ CWorkDirTempFile tempFile;
+ if (tempFile.CreateTempFile(m_FileName) != S_OK)
+ return NFileOperationReturnCode::kError;
+
+
+ /*
+ CSysStringVector fileNames;
+ for (int i = 0; i < numItems; i++)
+ {
+ const PluginPanelItem &panelItem = panelItems[i];
+ CSysString fullName;
+ if (!MyGetFullPathName(panelItem.FindData.cFileName, fullName))
+ return NFileOperationReturnCode::kError;
+ fileNames.Add(fullName);
+ }
+ */
+
+ CScreenRestorer screenRestorer;
+ CProgressBox progressBox;
+ CProgressBox *progressBoxPointer = NULL;
+ if ((opMode & OPM_SILENT) == 0 && (opMode & OPM_FIND ) == 0)
+ {
+ screenRestorer.Save();
+
+ progressBoxPointer = &progressBox;
+ progressBox.Init(
+ // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kUpdating));
+ }
+
+ UStringVector pathVector;
+ GetPathParts(pathVector);
+
+ UStringVector fileNames;
+ fileNames.ClearAndReserve(numItems);
+ for (i = 0; i < (unsigned)numItems; i++)
+ fileNames.AddInReserved(MultiByteToUnicodeString(panelItems[i].FindData.cFileName, CP_OEMCP));
+ CObjArray<const wchar_t *> fileNamePointers(numItems);
+ for (i = 0; i < (unsigned)numItems; i++)
+ fileNamePointers[i] = fileNames[i];
+
+ CMyComPtr<IOutFolderArchive> outArchive;
+ HRESULT result = m_ArchiveHandler.QueryInterface(IID_IOutFolderArchive, &outArchive);
+ if (result != S_OK)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return NFileOperationReturnCode::kError;
+ }
+
+ /*
+ BYTE actionSetByte[NUpdateArchive::NPairState::kNumValues];
+ for (i = 0; i < NUpdateArchive::NPairState::kNumValues; i++)
+ actionSetByte[i] = (BYTE)actionSet->StateActions[i];
+ */
+
+ CUpdateCallback100Imp *updateCallbackSpec = new CUpdateCallback100Imp;
+ CMyComPtr<IFolderArchiveUpdateCallback> updateCallback(updateCallbackSpec );
+
+ updateCallbackSpec->Init(/* m_ArchiveHandler, */ progressBoxPointer);
+ updateCallbackSpec->PasswordIsDefined = PasswordIsDefined;
+ updateCallbackSpec->Password = Password;
+
+ if (!_agent->_isHashHandler)
+ {
+ if (SetOutProperties(outArchive, compressionInfo.Level) != S_OK)
+ return NFileOperationReturnCode::kError;
+ }
+
+ /*
+ outArchive->SetFolder(_folder);
+ outArchive->SetFiles(L"", fileNamePointers, numItems);
+ // FStringVector requestedPaths;
+ // FStringVector processedPaths;
+ result = outArchive->DoOperation2(
+ // &requestedPaths, &processedPaths,
+ NULL, NULL,
+ tempFile.OutStream, actionSetByte, NULL, updateCallback);
+ updateCallback.Release();
+ outArchive.Release();
+
+ if (result == S_OK)
+ {
+ result = AfterUpdate(tempFile, pathVector);
+ }
+ */
+
+ {
+ result = _agent->SetFiles(L"", fileNamePointers, numItems);
+ if (result == S_OK)
+ {
+ CAgentFolder *agentFolder = NULL;
+ {
+ CMyComPtr<IArchiveFolderInternal> afi;
+ _folder.QueryInterface(IID_IArchiveFolderInternal, &afi);
+ if (afi)
+ afi->GetAgentFolder(&agentFolder);
+ }
+ if (agentFolder)
+ result = agentFolder->CommonUpdateOperation(AGENT_OP_Uni,
+ (moveMode != 0), NULL, actionSet, NULL, 0, updateCallback);
+ else
+ result = E_FAIL;
+ }
+ }
+
+ if (result != S_OK)
+ {
+ ShowSysErrorMessage(result);
+ return NFileOperationReturnCode::kError;
+ }
+
+ return NFileOperationReturnCode::kSuccess;
+}
+
+namespace NPathType
+{
+ enum EEnum
+ {
+ kLocal,
+ kUNC
+ };
+ EEnum GetPathType(const UString &path);
+}
+
+struct CParsedPath
+{
+ UString Prefix; // Disk or UNC with slash
+ UStringVector PathParts;
+ void ParsePath(const UString &path);
+ UString MergePath() const;
+};
+
+static const char kDirDelimiter = CHAR_PATH_SEPARATOR;
+static const wchar_t kDiskDelimiter = L':';
+
+namespace NPathType
+{
+ EEnum GetPathType(const UString &path)
+ {
+ if (path.Len() <= 2)
+ return kLocal;
+ if (path[0] == kDirDelimiter && path[1] == kDirDelimiter)
+ return kUNC;
+ return kLocal;
+ }
+}
+
+void CParsedPath::ParsePath(const UString &path)
+{
+ int curPos = 0;
+ switch (NPathType::GetPathType(path))
+ {
+ case NPathType::kLocal:
+ {
+ int posDiskDelimiter = path.Find(kDiskDelimiter);
+ if (posDiskDelimiter >= 0)
+ {
+ curPos = posDiskDelimiter + 1;
+ if ((int)path.Len() > curPos)
+ if (path[curPos] == kDirDelimiter)
+ curPos++;
+ }
+ break;
+ }
+ case NPathType::kUNC:
+ {
+ // the bug was fixed:
+ curPos = path.Find((wchar_t)kDirDelimiter, 2);
+ if (curPos < 0)
+ curPos = (int)path.Len();
+ else
+ curPos++;
+ }
+ }
+ Prefix = path.Left(curPos);
+ SplitPathToParts(path.Ptr(curPos), PathParts);
+}
+
+UString CParsedPath::MergePath() const
+{
+ UString result = Prefix;
+ FOR_VECTOR (i, PathParts)
+ {
+ if (i != 0)
+ result += kDirDelimiter;
+ result += PathParts[i];
+ }
+ return result;
+}
+
+
+static void SetArcName(UString &arcName, const CArcInfoEx &arcInfo)
+{
+ if (!arcInfo.Flags_KeepName())
+ {
+ int dotPos = arcName.ReverseFind_Dot();
+ int slashPos = arcName.ReverseFind_PathSepar();
+ if (dotPos > slashPos + 1)
+ arcName.DeleteFrom(dotPos);
+ }
+ arcName.Add_Dot();
+ arcName += arcInfo.GetMainExt();
+}
+
+HRESULT CompressFiles(const CObjectVector<PluginPanelItem> &pluginPanelItems)
+{
+ if (pluginPanelItems.Size() == 0)
+ return E_FAIL;
+
+ UStringVector fileNames;
+ {
+ FOR_VECTOR (i, pluginPanelItems)
+ {
+ const PluginPanelItem &panelItem = pluginPanelItems[i];
+ if (strcmp(panelItem.FindData.cFileName, "..") == 0 &&
+ NFind::NAttributes::IsDir(panelItem.FindData.dwFileAttributes))
+ return E_FAIL;
+ if (strcmp(panelItem.FindData.cFileName, ".") == 0 &&
+ NFind::NAttributes::IsDir(panelItem.FindData.dwFileAttributes))
+ return E_FAIL;
+ FString fullPath;
+ FString fileNameUnicode = us2fs(MultiByteToUnicodeString(panelItem.FindData.cFileName, CP_OEMCP));
+ if (!MyGetFullPathName(fileNameUnicode, fullPath))
+ return E_FAIL;
+ fileNames.Add(fs2us(fullPath));
+ }
+ }
+
+ NCompression::CInfo compressionInfo;
+ compressionInfo.Load();
+
+ int archiverIndex = -1;
+
+ /*
+ CCodecs *codecs = new CCodecs;
+ CMyComPtr<ICompressCodecsInfo> compressCodecsInfo = codecs;
+ if (codecs->Load() != S_OK)
+ throw "Can't load 7-Zip codecs";
+ */
+
+ if (LoadGlobalCodecs() != S_OK)
+ throw "Can't load 7-Zip codecs";
+
+ CCodecs *codecs = g_CodecsObj;
+
+ {
+ FOR_VECTOR (i, codecs->Formats)
+ {
+ const CArcInfoEx &arcInfo = codecs->Formats[i];
+ if (arcInfo.UpdateEnabled)
+ {
+ if (archiverIndex == -1)
+ archiverIndex = (int)i;
+ if (MyStringCompareNoCase(arcInfo.Name, compressionInfo.ArcType) == 0)
+ archiverIndex = (int)i;
+ }
+ }
+ }
+
+ if (archiverIndex < 0)
+ throw "there is no output handler";
+
+ UString resultPath;
+ {
+ CParsedPath parsedPath;
+ parsedPath.ParsePath(fileNames.Front());
+ if (parsedPath.PathParts.Size() == 0)
+ return E_FAIL;
+ if (fileNames.Size() == 1 || parsedPath.PathParts.Size() == 1)
+ {
+ // CSysString pureName, dot, extension;
+ resultPath = parsedPath.PathParts.Back();
+ }
+ else
+ {
+ parsedPath.PathParts.DeleteBack();
+ resultPath = parsedPath.PathParts.Back();
+ }
+ }
+ UString archiveNameSrc = resultPath;
+ UString arcName = archiveNameSrc;
+
+ int prevFormat = archiverIndex;
+ SetArcName(arcName, codecs->Formats[archiverIndex]);
+
+ const CActionSet *actionSet = &k_ActionSet_Add;
+
+ for (;;)
+ {
+ AString archiveNameA (UnicodeStringToMultiByte(arcName, CP_OEMCP));
+ const int kYSize = 16;
+ const int kXMid = 38;
+
+ const int kArchiveNameIndex = 2;
+ const int kMethodRadioIndex = kArchiveNameIndex + 2;
+ const int kModeRadioIndex = kMethodRadioIndex + 7;
+
+ // char updateAddToArchiveString[512];
+ AString str1;
+ {
+ const CArcInfoEx &arcInfo = codecs->Formats[archiverIndex];
+ const AString s (UnicodeStringToMultiByte(arcInfo.Name, CP_OEMCP));
+ str1 = g_StartupInfo.GetMsgString(NMessageID::kUpdateAddToArchive);
+ str1.Replace(AString ("%s"), s);
+ /*
+ sprintf(updateAddToArchiveString,
+ g_StartupInfo.GetMsgString(NMessageID::kUpdateAddToArchive), (const char *)s);
+ */
+ }
+
+ unsigned methodIndex = 0;
+ unsigned i;
+ for (i = Z7_ARRAY_SIZE(g_MethodMap); i != 0;)
+ {
+ i--;
+ if (compressionInfo.Level >= g_MethodMap[i])
+ {
+ methodIndex = i;
+ break;
+ }
+ }
+
+ const struct CInitDialogItem initItems[]=
+ {
+ { DI_DOUBLEBOX, 3, 1, 72, kYSize - 2, false, false, 0, false, NMessageID::kUpdateTitle, NULL, NULL },
+
+ { DI_TEXT, 5, 2, 0, 0, false, false, 0, false, -1, str1, NULL },
+
+ { DI_EDIT, 5, 3, 70, 3, true, false, DIF_HISTORY, false, -1, archiveNameA, kArchiveHistoryKeyName},
+ // { DI_EDIT, 5, 3, 70, 3, true, false, 0, false, -1, arcName, NULL},
+
+ { DI_SINGLEBOX, 4, 4, kXMid - 2, 4 + 7, false, false, 0, false, NMessageID::kUpdateMethod, NULL, NULL },
+
+ { DI_RADIOBUTTON, 6, 5, 0, 0, false, methodIndex == 0, DIF_GROUP, false, NMessageID::kUpdateMethod_Store, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 6, 0, 0, false, methodIndex == 1, 0, false, NMessageID::kUpdateMethod_Fastest, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 7, 0, 0, false, methodIndex == 2, 0, false, NMessageID::kUpdateMethod_Fast, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 8, 0, 0, false, methodIndex == 3, 0, false, NMessageID::kUpdateMethod_Normal, NULL, NULL },
+ { DI_RADIOBUTTON, 6, 9, 0, 0, false, methodIndex == 4, 0, false, NMessageID::kUpdateMethod_Maximum, NULL, NULL },
+ { DI_RADIOBUTTON, 6,10, 0, 0, false, methodIndex == 5, 0, false, NMessageID::kUpdateMethod_Ultra, NULL, NULL },
+
+ { DI_SINGLEBOX, kXMid, 4, 70, 4 + 5, false, false, 0, false, NMessageID::kUpdateMode, NULL, NULL },
+
+ { DI_RADIOBUTTON, kXMid + 2, 5, 0, 0, false, actionSet == &k_ActionSet_Add, DIF_GROUP, false, NMessageID::kUpdateMode_Add, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 6, 0, 0, false, actionSet == &k_ActionSet_Update, 0, false, NMessageID::kUpdateMode_Update, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 7, 0, 0, false, actionSet == &k_ActionSet_Fresh, 0, false, NMessageID::kUpdateMode_Fresh, NULL, NULL },
+ { DI_RADIOBUTTON, kXMid + 2, 8, 0, 0, false, actionSet == &k_ActionSet_Sync, 0, false, NMessageID::kUpdateMode_Sync, NULL, NULL },
+
+ { DI_TEXT, 3, kYSize - 4, 0, 0, false, false, DIF_BOXCOLOR|DIF_SEPARATOR, false, -1, "", NULL },
+
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, true, NMessageID::kUpdateAdd, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kUpdateSelectArchiver, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kCancel, NULL, NULL }
+ };
+
+ const int kNumDialogItems = Z7_ARRAY_SIZE(initItems);
+
+ const int kOkButtonIndex = kNumDialogItems - 3;
+ const int kSelectarchiverButtonIndex = kNumDialogItems - 2;
+
+ FarDialogItem dialogItems[kNumDialogItems];
+ g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumDialogItems);
+ int askCode = g_StartupInfo.ShowDialog(76, kYSize,
+ kHelpTopic, dialogItems, kNumDialogItems);
+
+ archiveNameA = dialogItems[kArchiveNameIndex].Data;
+ archiveNameA.Trim();
+ MultiByteToUnicodeString2(arcName, archiveNameA, CP_OEMCP);
+
+ compressionInfo.Level = g_MethodMap[0];
+ for (i = 0; i < Z7_ARRAY_SIZE(g_MethodMap); i++)
+ if (dialogItems[kMethodRadioIndex + i].Selected)
+ compressionInfo.Level = g_MethodMap[i];
+
+ if (dialogItems[kModeRadioIndex ].Selected) actionSet = &k_ActionSet_Add;
+ else if (dialogItems[kModeRadioIndex + 1].Selected) actionSet = &k_ActionSet_Update;
+ else if (dialogItems[kModeRadioIndex + 2].Selected) actionSet = &k_ActionSet_Fresh;
+ else if (dialogItems[kModeRadioIndex + 3].Selected) actionSet = &k_ActionSet_Sync;
+ else throw 51751;
+
+ if (askCode == kSelectarchiverButtonIndex)
+ {
+ CUIntVector indices;
+ AStringVector archiverNames;
+ FOR_VECTOR (k, codecs->Formats)
+ {
+ const CArcInfoEx &arc = codecs->Formats[k];
+ if (arc.UpdateEnabled)
+ {
+ indices.Add(k);
+ archiverNames.Add(GetOemString(arc.Name));
+ }
+ }
+
+ const int index = g_StartupInfo.Menu(FMENU_AUTOHIGHLIGHT,
+ g_StartupInfo.GetMsgString(NMessageID::kUpdateSelectArchiverMenuTitle),
+ NULL, archiverNames, archiverIndex);
+ if (index >= 0)
+ {
+ const CArcInfoEx &prevArchiverInfo = codecs->Formats[prevFormat];
+ if (prevArchiverInfo.Flags_KeepName())
+ {
+ const UString &prevExtension = prevArchiverInfo.GetMainExt();
+ const unsigned prevExtensionLen = prevExtension.Len();
+ if (arcName.Len() >= prevExtensionLen &&
+ MyStringCompareNoCase(arcName.RightPtr(prevExtensionLen), prevExtension) == 0)
+ {
+ const unsigned pos = arcName.Len() - prevExtensionLen;
+ if (pos > 2)
+ {
+ if (arcName[pos - 1] == '.')
+ arcName.DeleteFrom(pos - 1);
+ }
+ }
+ }
+
+ archiverIndex = (int)indices[index];
+ const CArcInfoEx &arcInfo = codecs->Formats[archiverIndex];
+ prevFormat = archiverIndex;
+
+ if (arcInfo.Flags_KeepName())
+ arcName = archiveNameSrc;
+ SetArcName(arcName, arcInfo);
+ }
+ continue;
+ }
+
+ if (askCode != kOkButtonIndex)
+ return E_ABORT;
+
+ break;
+ }
+
+ const CArcInfoEx &archiverInfoFinal = codecs->Formats[archiverIndex];
+ compressionInfo.ArcType = archiverInfoFinal.Name;
+ compressionInfo.Save();
+
+ NWorkDir::CInfo workDirInfo;
+ workDirInfo.Load();
+
+ FString fullArcName;
+ if (!MyGetFullPathName(us2fs(arcName), fullArcName))
+ return E_FAIL;
+
+ CWorkDirTempFile tempFile;
+ RINOK(tempFile.CreateTempFile(fullArcName))
+ CScreenRestorer screenRestorer;
+ CProgressBox progressBox;
+ CProgressBox *progressBoxPointer = NULL;
+
+ screenRestorer.Save();
+
+ progressBoxPointer = &progressBox;
+ progressBox.Init(
+ // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kUpdating));
+
+
+ NFind::CFileInfo fileInfo;
+
+ CMyComPtr<IOutFolderArchive> outArchive;
+
+ CMyComPtr<IInFolderArchive> archiveHandler;
+ if (fileInfo.Find(fullArcName))
+ {
+ if (fileInfo.IsDir())
+ throw "There is Directory with such name";
+
+ CAgent *agentSpec = new CAgent;
+ archiveHandler = agentSpec;
+ // CLSID realClassID;
+ CMyComBSTR archiveType;
+ RINOK(archiveHandler->Open(NULL,
+ GetUnicodeString(fullArcName, CP_OEMCP), UString(),
+ // &realClassID,
+ &archiveType,
+ NULL))
+
+ if (MyStringCompareNoCase(archiverInfoFinal.Name, (const wchar_t *)archiveType) != 0)
+ throw "Type of existing archive differs from specified type";
+ const HRESULT result = archiveHandler.QueryInterface(
+ IID_IOutFolderArchive, &outArchive);
+ if (result != S_OK)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return E_FAIL;
+ }
+ }
+ else
+ {
+ // HRESULT result = outArchive.CoCreateInstance(classID);
+ CAgent *agentSpec = new CAgent;
+ outArchive = agentSpec;
+
+ /*
+ HRESULT result = outArchive.CoCreateInstance(CLSID_CAgentArchiveHandler);
+ if (result != S_OK)
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return E_FAIL;
+ }
+ */
+ }
+
+ CObjArray<const wchar_t *> fileNamePointers(fileNames.Size());
+
+ unsigned i;
+ for (i = 0; i < fileNames.Size(); i++)
+ fileNamePointers[i] = fileNames[i];
+
+ outArchive->SetFolder(NULL);
+ outArchive->SetFiles(L"", fileNamePointers, fileNames.Size());
+ BYTE actionSetByte[NUpdateArchive::NPairState::kNumValues];
+ for (i = 0; i < NUpdateArchive::NPairState::kNumValues; i++)
+ actionSetByte[i] = (BYTE)actionSet->StateActions[i];
+
+ CUpdateCallback100Imp *updateCallbackSpec = new CUpdateCallback100Imp;
+ CMyComPtr<IFolderArchiveUpdateCallback> updateCallback(updateCallbackSpec );
+
+ updateCallbackSpec->Init(/* archiveHandler, */ progressBoxPointer);
+
+
+ RINOK(SetOutProperties(outArchive, compressionInfo.Level))
+
+ // FStringVector requestedPaths;
+ // FStringVector processedPaths;
+ HRESULT result = outArchive->DoOperation(
+ // &requestedPaths, &processedPaths,
+ NULL, NULL,
+ codecs, archiverIndex,
+ tempFile.OutStream, actionSetByte,
+ NULL, updateCallback);
+ updateCallback.Release();
+ outArchive.Release();
+
+ if (result != S_OK)
+ {
+ ShowSysErrorMessage(result);
+ return result;
+ }
+
+ if (archiveHandler)
+ {
+ archiveHandler->Close();
+ }
+
+ result = tempFile.MoveToOriginal(archiveHandler != NULL);
+ if (result != S_OK)
+ {
+ ShowSysErrorMessage(result);
+ return result;
+ }
+ return S_OK;
+}
+
+
+static const char * const k_CreateFolder_History = "NewFolder"; // we use default FAR folder name
+
+HRESULT CPlugin::CreateFolder()
+{
+ if (_agent->IsThere_ReadOnlyArc())
+ {
+ g_StartupInfo.ShowMessage(NMessageID::kUpdateNotSupportedForThisArchive);
+ return TRUE;
+ }
+
+ UString destPathU;
+ {
+ const int kXSize = 60;
+ const int kYSize = 8;
+ const int kPathIndex = 2;
+
+ AString destPath ("New Folder");
+
+ const struct CInitDialogItem initItems[]={
+ { DI_DOUBLEBOX, 3, 1, kXSize - 4, kYSize - 2, false, false, 0, false,
+ -1, "Create Folder", NULL },
+
+ { DI_TEXT, 5, 2, 0, 0, false, false, 0, false, -1, "Folder name:", NULL },
+
+ { DI_EDIT, 5, 3, kXSize - 6, 3, true, false, DIF_HISTORY, false, -1, destPath, k_CreateFolder_History },
+
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, true, NMessageID::kOk, NULL, NULL },
+ { DI_BUTTON, 0, kYSize - 3, 0, 0, false, false, DIF_CENTERGROUP, false, NMessageID::kCancel, NULL, NULL }
+ };
+
+ const int kNumDialogItems = Z7_ARRAY_SIZE(initItems);
+ const int kOkButtonIndex = kNumDialogItems - 2;
+
+ FarDialogItem dialogItems[kNumDialogItems];
+ g_StartupInfo.InitDialogItems(initItems, dialogItems, kNumDialogItems);
+ for (;;)
+ {
+ int askCode = g_StartupInfo.ShowDialog(kXSize, kYSize,
+ NULL, // kHelpTopic
+ dialogItems, kNumDialogItems);
+ if (askCode != kOkButtonIndex)
+ return E_ABORT;
+ destPath = dialogItems[kPathIndex].Data;
+ destPathU = GetUnicodeString(destPath, CP_OEMCP);
+ destPathU.Trim();
+ if (!destPathU.IsEmpty())
+ break;
+ g_StartupInfo.ShowErrorMessage("You must specify folder name");
+ }
+
+ }
+
+ CScreenRestorer screenRestorer;
+ CProgressBox progressBox;
+ CProgressBox *progressBoxPointer = NULL;
+ // if ((opMode & OPM_SILENT) == 0 && (opMode & OPM_FIND ) == 0)
+ {
+ screenRestorer.Save();
+
+ progressBoxPointer = &progressBox;
+ progressBox.Init(
+ // g_StartupInfo.GetMsgString(NMessageID::kWaitTitle),
+ g_StartupInfo.GetMsgString(NMessageID::kDeleting));
+ }
+
+ CUpdateCallback100Imp *updateCallbackSpec = new CUpdateCallback100Imp;
+ CMyComPtr<IFolderArchiveUpdateCallback> updateCallback(updateCallbackSpec);
+
+ updateCallbackSpec->Init(/* m_ArchiveHandler, */ progressBoxPointer);
+ updateCallbackSpec->PasswordIsDefined = PasswordIsDefined;
+ updateCallbackSpec->Password = Password;
+
+ HRESULT result;
+ {
+ CMyComPtr<IFolderOperations> folderOperations;
+ result = _folder.QueryInterface(IID_IFolderOperations, &folderOperations);
+ if (folderOperations)
+ result = folderOperations->CreateFolder(destPathU, updateCallback);
+ else if (result != S_OK)
+ result = E_FAIL;
+ }
+
+ if (result != S_OK)
+ {
+ ShowSysErrorMessage(result);
+ return result;
+ }
+
+ g_StartupInfo.Control(this, FCTL_UPDATEPANEL, (void *)1);
+ g_StartupInfo.Control(this, FCTL_REDRAWPANEL, NULL);
+
+ PanelInfo panelInfo;
+
+ if (g_StartupInfo.ControlGetActivePanelInfo(panelInfo))
+ {
+ const AString destPath (GetOemString(destPathU));
+
+ for (int i = 0; i < panelInfo.ItemsNumber; i++)
+ {
+ const PluginPanelItem &pi = panelInfo.PanelItems[i];
+ if (strcmp(destPath, pi.FindData.cFileName) == 0)
+ {
+ PanelRedrawInfo panelRedrawInfo;
+ panelRedrawInfo.CurrentItem = i;
+ panelRedrawInfo.TopPanelItem = 0;
+ g_StartupInfo.Control(this, FCTL_REDRAWPANEL, &panelRedrawInfo);
+ break;
+ }
+ }
+ }
+
+ SetCurrentDirVar();
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/Far/ProgressBox.cpp b/CPP/7zip/UI/Far/ProgressBox.cpp
new file mode 100644
index 0000000..ab25a10
--- /dev/null
+++ b/CPP/7zip/UI/Far/ProgressBox.cpp
@@ -0,0 +1,305 @@
+// ProgressBox.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "FarUtils.h"
+#include "ProgressBox.h"
+
+void CPercentPrinterState::ClearCurState()
+{
+ Completed = 0;
+ Total = ((UInt64)(Int64)-1);
+ Files = 0;
+ FilesTotal = 0;
+ Command.Empty();
+ FileName.Empty();
+}
+
+void CProgressBox::Init(const char *title)
+{
+ _title = title;
+ _wasPrinted = false;
+ StartTick = GetTickCount();
+ _prevTick = StartTick;
+ _prevElapsedSec = 0;
+}
+
+static unsigned GetPower32(UInt32 val)
+{
+ const unsigned kStart = 32;
+ UInt32 mask = ((UInt32)1 << (kStart - 1));
+ for (unsigned i = kStart;; i--)
+ {
+ if (i == 0 || (val & mask) != 0)
+ return i;
+ mask >>= 1;
+ }
+}
+
+static unsigned GetPower64(UInt64 val)
+{
+ UInt32 high = (UInt32)(val >> 32);
+ if (high == 0)
+ return GetPower32((UInt32)val);
+ return GetPower32(high) + 32;
+}
+
+static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider)
+{
+ unsigned pow1 = GetPower64(mult1);
+ unsigned pow2 = GetPower64(mult2);
+ while (pow1 + pow2 > 64)
+ {
+ if (pow1 > pow2) { pow1--; mult1 >>= 1; }
+ else { pow2--; mult2 >>= 1; }
+ divider >>= 1;
+ }
+ UInt64 res = mult1 * mult2;
+ if (divider != 0)
+ res /= divider;
+ return res;
+}
+
+#define UINT_TO_STR_2(val) { s[0] = (char)('0' + (val) / 10); s[1] = (char)('0' + (val) % 10); s += 2; }
+
+static void GetTimeString(UInt64 timeValue, char *s)
+{
+ const UInt64 hours = timeValue / 3600;
+ UInt32 seconds = (UInt32)(timeValue - hours * 3600);
+ const UInt32 minutes = seconds / 60;
+ seconds %= 60;
+ if (hours > 99)
+ {
+ ConvertUInt64ToString(hours, s);
+ for (; *s != 0; s++);
+ }
+ else
+ {
+ const UInt32 hours32 = (UInt32)hours;
+ UINT_TO_STR_2(hours32)
+ }
+ *s++ = ':'; UINT_TO_STR_2(minutes)
+ *s++ = ':'; UINT_TO_STR_2(seconds)
+ *s = 0;
+}
+
+void CProgressBox::ReduceString(const UString &src, AString &dest)
+{
+ UnicodeStringToMultiByte2(dest, src, CP_OEMCP);
+
+ if (dest.Len() <= MaxLen)
+ return;
+ unsigned len = FileName.Len();
+ for (; len != 0;)
+ {
+ unsigned delta = len / 8;
+ if (delta == 0)
+ delta = 1;
+ len -= delta;
+ _tempU = FileName;
+ _tempU.Delete(len / 2, FileName.Len() - len);
+ _tempU.Insert(len / 2, L" . ");
+ UnicodeStringToMultiByte2(dest, _tempU, CP_OEMCP);
+ if (dest.Len() <= MaxLen)
+ return;
+ }
+ dest.Empty();
+}
+
+static void Print_UInt64_and_String(AString &s, UInt64 val, const char *name)
+{
+ char temp[32];
+ ConvertUInt64ToString(val, temp);
+ s += temp;
+ s.Add_Space();
+ s += name;
+}
+
+
+static void PrintSize_bytes_Smart(AString &s, UInt64 val)
+{
+ // Print_UInt64_and_String(s, val, "bytes");
+ {
+ char temp[32];
+ ConvertUInt64ToString(val, temp);
+ s += temp;
+ }
+
+ if (val == 0)
+ return;
+
+ unsigned numBits = 10;
+ char c = 'K';
+ char temp[4] = { 'K', 'i', 'B', 0 };
+ if (val >= ((UInt64)10 << 30)) { numBits = 30; c = 'G'; }
+ else if (val >= ((UInt64)10 << 20)) { numBits = 20; c = 'M'; }
+ temp[0] = c;
+ s += " (";
+ Print_UInt64_and_String(s, ((val + ((UInt64)1 << numBits) - 1) >> numBits), temp);
+ s += ')';
+}
+
+
+static const unsigned kPercentsSize = 4;
+
+void CProgressBox::Print()
+{
+ DWORD tick = GetTickCount();
+ DWORD elapsedTicks = tick - StartTick;
+ DWORD elapsedSec = elapsedTicks / 1000;
+
+ if (_wasPrinted)
+ {
+ if (elapsedSec == _prevElapsedSec)
+ {
+ if ((UInt32)(tick - _prevTick) < _tickStep)
+ return;
+ if (_printedState.IsEqualTo((const CPercentPrinterState &)*this))
+ return;
+ }
+ }
+
+ UInt64 cur = Completed;
+ UInt64 total = Total;
+
+ if (!UseBytesForPercents)
+ {
+ cur = Files;
+ total = FilesTotal;
+ }
+
+ {
+ _timeStr.Empty();
+ _timeStr = "Elapsed time: ";
+ char s[40];
+ GetTimeString(elapsedSec, s);
+ _timeStr += s;
+
+ if (cur != 0)
+ {
+ UInt64 remainingTime = 0;
+ if (cur < total)
+ remainingTime = MyMultAndDiv(elapsedTicks, total - cur, cur);
+ UInt64 remainingSec = remainingTime / 1000;
+ _timeStr += " Remaining time: ";
+
+ GetTimeString(remainingSec, s);
+ _timeStr += s;
+ }
+ }
+
+
+ {
+ _perc.Empty();
+ char s[32];
+ unsigned size;
+ {
+ UInt64 val = 0;
+ if (total != (UInt64)(Int64)-1 && total != 0)
+ val = cur * 100 / Total;
+
+ ConvertUInt64ToString(val, s);
+ size = (unsigned)strlen(s);
+ s[size++] = '%';
+ s[size] = 0;
+ }
+
+ unsigned len = size;
+ while (len < kPercentsSize)
+ len = kPercentsSize;
+ len++;
+
+ if (len < MaxLen)
+ {
+ unsigned numChars = MaxLen - len;
+ unsigned filled = 0;
+ if (total != (UInt64)(Int64)-1 && total != 0)
+ filled = (unsigned)(cur * numChars / total);
+ if (filled > numChars)
+ filled = numChars;
+ unsigned i = 0;
+ for (i = 0; i < filled; i++)
+ _perc += (char)(Byte)0xDB; // '=';
+ for (; i < numChars; i++)
+ _perc += (char)(Byte)0xB0; // '.';
+ }
+
+ _perc.Add_Space();
+ while (size < kPercentsSize)
+ {
+ _perc.Add_Space();
+ size++;
+ }
+ _perc += s;
+ }
+
+ _files.Empty();
+ if (Files != 0 || FilesTotal != 0)
+ {
+ _files += "Files: ";
+ char s[32];
+ // if (Files != 0)
+ {
+ ConvertUInt64ToString(Files, s);
+ _files += s;
+ }
+ if (FilesTotal != 0)
+ {
+ _files += " / ";
+ ConvertUInt64ToString(FilesTotal, s);
+ _files += s;
+ }
+ }
+
+ _sizesStr.Empty();
+ if (Total != 0)
+ {
+ _sizesStr += "Size: ";
+ PrintSize_bytes_Smart(_sizesStr, Completed);
+ if (Total != 0 && Total != (UInt64)(Int64)-1)
+ {
+ _sizesStr += " / ";
+ PrintSize_bytes_Smart(_sizesStr, Total);
+ }
+ }
+
+ _name1.Empty();
+ _name2.Empty();
+
+ if (!FileName.IsEmpty())
+ {
+ _name1U.Empty();
+ _name2U.Empty();
+
+ /*
+ if (_isDir)
+ s1 = _filePath;
+ else
+ */
+ {
+ const int slashPos = FileName.ReverseFind_PathSepar();
+ if (slashPos >= 0)
+ {
+ _name1U.SetFrom(FileName, (unsigned)(slashPos + 1));
+ _name2U = FileName.Ptr(slashPos + 1);
+ }
+ else
+ _name2U = FileName;
+ }
+ ReduceString(_name1U, _name1);
+ ReduceString(_name2U, _name2);
+ }
+
+ {
+ const char *strings[] = { _title, _timeStr, _files, _sizesStr, Command, _name1, _name2, _perc };
+ NFar::g_StartupInfo.ShowMessage(FMSG_LEFTALIGN, NULL, strings, Z7_ARRAY_SIZE(strings), 0);
+ }
+
+ _wasPrinted = true;
+ _printedState = *this;
+ _prevTick = tick;
+ _prevElapsedSec = elapsedSec;
+}
diff --git a/CPP/7zip/UI/Far/ProgressBox.h b/CPP/7zip/UI/Far/ProgressBox.h
new file mode 100644
index 0000000..6e8b487
--- /dev/null
+++ b/CPP/7zip/UI/Far/ProgressBox.h
@@ -0,0 +1,83 @@
+// ProgressBox.h
+
+#ifndef ZIP7_INC_PROGRESS_BOX_H
+#define ZIP7_INC_PROGRESS_BOX_H
+
+#include "../../../Common/MyString.h"
+#include "../../../Common/MyTypes.h"
+
+struct CPercentPrinterState
+{
+ UInt64 Completed;
+ UInt64 Total;
+
+ UInt64 Files;
+ UInt64 FilesTotal;
+
+ AString Command;
+ UString FileName;
+
+ void ClearCurState();
+
+ bool IsEqualTo(const CPercentPrinterState &s) const
+ {
+ return
+ Completed == s.Completed
+ && Total == s.Total
+ && Files == s.Files
+ && FilesTotal == s.FilesTotal
+ && Command == s.Command
+ && FileName == s.FileName;
+ }
+
+ CPercentPrinterState():
+ Completed(0),
+ Total((UInt64)(Int64)-1),
+ Files(0),
+ FilesTotal(0)
+ {}
+};
+
+class CProgressBox: public CPercentPrinterState
+{
+ UInt32 _tickStep;
+ DWORD _prevTick;
+ DWORD _prevElapsedSec;
+
+ bool _wasPrinted;
+
+ UString _tempU;
+ UString _name1U;
+ UString _name2U;
+
+ CPercentPrinterState _printedState;
+
+ AString _title;
+
+ AString _timeStr;
+ AString _files;
+ AString _sizesStr;
+ AString _name1;
+ AString _name2;
+ AString _perc;
+
+ void ReduceString(const UString &src, AString &dest);
+
+public:
+ DWORD StartTick;
+ bool UseBytesForPercents;
+ unsigned MaxLen;
+
+ CProgressBox(UInt32 tickStep = 200):
+ _tickStep(tickStep),
+ _prevTick(0),
+ StartTick(0),
+ UseBytesForPercents(true),
+ MaxLen(60)
+ {}
+
+ void Init(const char *title);
+ void Print();
+};
+
+#endif
diff --git a/CPP/7zip/UI/Far/StdAfx.cpp b/CPP/7zip/UI/Far/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/UI/Far/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/Far/StdAfx.h b/CPP/7zip/UI/Far/StdAfx.h
new file mode 100644
index 0000000..035267c
--- /dev/null
+++ b/CPP/7zip/UI/Far/StdAfx.h
@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif
diff --git a/CPP/7zip/UI/Far/UpdateCallbackFar.cpp b/CPP/7zip/UI/Far/UpdateCallbackFar.cpp
new file mode 100644
index 0000000..94f0a47
--- /dev/null
+++ b/CPP/7zip/UI/Far/UpdateCallbackFar.cpp
@@ -0,0 +1,237 @@
+// UpdateCallbackFar.cpp
+
+#include "StdAfx.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "../../../Common/StringConvert.h"
+
+#include "FarUtils.h"
+#include "UpdateCallbackFar.h"
+
+using namespace NWindows;
+using namespace NFar;
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+static HRESULT CheckBreak2()
+{
+ return WasEscPressed() ? E_ABORT : S_OK;
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ScanProgress(UInt64 numFolders, UInt64 numFiles, UInt64 totalSize, const wchar_t *path, Int32 /* isDir */))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->FilesTotal = numFolders + numFiles;
+ _percent->Total = totalSize;
+ _percent->Command = "Scanning";
+ _percent->FileName = path;
+ _percent->Print();
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ScanError(const wchar_t *path, HRESULT errorCode))
+{
+ if (ShowSysErrorMessage(errorCode, path) == -1)
+ return E_ABORT;
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetNumFiles(UInt64 numFiles))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->FilesTotal = numFiles;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+ MT_LOCK
+ return CheckBreak2();
+}
+
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetTotal(UInt64 size))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->Total = size;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 *completeValue))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ if (completeValue)
+ _percent->Completed = *completeValue;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CompressOperation(const wchar_t *name))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->Command = "Adding";
+ _percent->FileName = name;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::DeleteOperation(const wchar_t *name))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->Command = "Deleting";
+ _percent->FileName = name;
+ _percent->Print();
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::OperationResult(Int32 /* opRes */))
+{
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->Files++;
+ }
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::UpdateErrorMessage(const wchar_t *message))
+{
+ MT_LOCK
+
+ if (g_StartupInfo.ShowErrorMessage(UnicodeStringToMultiByte(message, CP_OEMCP)) == -1)
+ return E_ABORT;
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::OpenFileError(const wchar_t *path, HRESULT errorCode))
+{
+ if (ShowSysErrorMessage(errorCode, path) == -1)
+ return E_ABORT;
+ return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReadingFileError(const wchar_t *path, HRESULT errorCode))
+{
+ if (ShowSysErrorMessage(errorCode, path) == -1)
+ return E_ABORT;
+ return CheckBreak2();
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &s);
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name))
+{
+ MT_LOCK
+
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ AString s;
+ SetExtractErrorMessage(opRes, isEncrypted, s);
+ if (PrintErrorMessage(s, name) == -1)
+ return E_ABORT;
+ }
+
+ return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReportUpdateOperation(UInt32 op, const wchar_t *name, Int32 /* isDir */))
+{
+ const char *s;
+ switch (op)
+ {
+ case NUpdateNotifyOp::kAdd: s = "Adding"; break;
+ case NUpdateNotifyOp::kUpdate: s = "Updating"; break;
+ case NUpdateNotifyOp::kAnalyze: s = "Analyzing"; break;
+ case NUpdateNotifyOp::kReplicate: s = "Replicating"; break;
+ case NUpdateNotifyOp::kRepack: s = "Repacking"; break;
+ case NUpdateNotifyOp::kSkip: s = "Skipping"; break;
+ case NUpdateNotifyOp::kHeader: s = "Header creating"; break;
+ case NUpdateNotifyOp::kDelete: s = "Deleting"; break;
+ default: s = "Unknown operation";
+ }
+
+ MT_LOCK
+
+ if (_percent)
+ {
+ _percent->Command = s;
+ _percent->FileName.Empty();
+ if (name)
+ _percent->FileName = name;
+ _percent->Print();
+ }
+
+ return CheckBreak2();
+}
+
+
+extern HRESULT GetPassword(UString &password);
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword(BSTR *password))
+{
+ MT_LOCK
+
+ *password = NULL;
+ if (!PasswordIsDefined)
+ {
+ RINOK(GetPassword(Password))
+ PasswordIsDefined = true;
+ }
+ return StringToBstr(Password, password);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+{
+ MT_LOCK
+
+ *password = NULL;
+ *passwordIsDefined = BoolToInt(PasswordIsDefined);
+ if (!PasswordIsDefined)
+ return S_OK;
+ return StringToBstr(Password, password);
+}
diff --git a/CPP/7zip/UI/Far/UpdateCallbackFar.h b/CPP/7zip/UI/Far/UpdateCallbackFar.h
new file mode 100644
index 0000000..4ec5eed
--- /dev/null
+++ b/CPP/7zip/UI/Far/UpdateCallbackFar.h
@@ -0,0 +1,44 @@
+// UpdateCallbackFar.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK_FAR_H
+#define ZIP7_INC_UPDATE_CALLBACK_FAR_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IPassword.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "ProgressBox.h"
+
+Z7_CLASS_IMP_COM_6(
+ CUpdateCallback100Imp
+ , IFolderArchiveUpdateCallback
+ , IFolderArchiveUpdateCallback2
+ , IFolderScanProgress
+ , ICryptoGetTextPassword2
+ , ICryptoGetTextPassword
+ , IArchiveOpenCallback
+)
+ Z7_IFACE_COM7_IMP(IProgress)
+
+ // CMyComPtr<IInFolderArchive> _archiveHandler;
+ CProgressBox *_percent;
+ // UInt64 _total;
+public:
+ bool PasswordIsDefined;
+ UString Password;
+
+ CUpdateCallback100Imp()
+ // : _total(0)
+ {}
+ void Init(/* IInFolderArchive *archiveHandler, */ CProgressBox *progressBox)
+ {
+ // _archiveHandler = archiveHandler;
+ _percent = progressBox;
+ PasswordIsDefined = false;
+ Password.Empty();
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/Far/makefile b/CPP/7zip/UI/Far/makefile
new file mode 100644
index 0000000..f3809a8
--- /dev/null
+++ b/CPP/7zip/UI/Far/makefile
@@ -0,0 +1,106 @@
+PROG = 7-ZipFar.dll
+DEF_FILE = Far.def
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTERNAL_CODECS \
+
+!IFNDEF UNDER_CE
+CFLAGS = $(CFLAGS) -DZ7_LONG_PATH
+!ENDIF
+
+CURRENT_OBJS = \
+ $O\ExtractEngine.obj \
+ $O\FarUtils.obj \
+ $O\Far.obj \
+ $O\OverwriteDialogFar.obj \
+ $O\Plugin.obj \
+ $O\PluginCommon.obj \
+ $O\PluginDelete.obj \
+ $O\PluginRead.obj \
+ $O\PluginWrite.obj \
+ $O\ProgressBox.obj \
+ $O\UpdateCallbackFar.obj \
+
+COMMON_OBJS = \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\NewHandler.obj \
+ $O\MyString.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\MyVector.obj \
+ $O\UTFConvert.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileLink.obj \
+ $O\FileName.obj \
+ $O\FileSystem.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\Registry.obj \
+ $O\ResourceString.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\TimeUtils.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodProps.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\DefaultName.obj \
+ $O\EnumDirItems.obj \
+ $O\ExtractingFilePath.obj \
+ $O\HashCalc.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+ $O\PropIDUtils.obj \
+ $O\SetProperties.obj \
+ $O\SortUtils.obj \
+ $O\UpdateAction.obj \
+ $O\UpdateCallback.obj \
+ $O\UpdatePair.obj \
+ $O\UpdateProduce.obj \
+ $O\WorkDir.obj \
+ $O\ZipRegistry.obj \
+
+AR_COMMON_OBJS = \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+
+AGENT_OBJS = \
+ $O\Agent.obj \
+ $O\AgentOut.obj \
+ $O\AgentProxy.obj \
+ $O\ArchiveFolder.obj \
+ $O\ArchiveFolderOut.obj \
+ $O\UpdateCallbackAgent.obj \
+
+COMPRESS_OBJS = \
+ $O\CopyCoder.obj \
+
+C_OBJS = \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\Sort.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/Far/resource.rc b/CPP/7zip/UI/Far/resource.rc
new file mode 100644
index 0000000..a5c2e2f
--- /dev/null
+++ b/CPP/7zip/UI/Far/resource.rc
@@ -0,0 +1,3 @@
+#include "../../MyVersionInfo.rc"
+
+MY_VERSION_INFO_DLL("7-Zip Plugin for FAR Manager", "7-ZipFar")
diff --git a/CPP/7zip/UI/FileManager/7zFM.exe.manifest b/CPP/7zip/UI/FileManager/7zFM.exe.manifest
new file mode 100644
index 0000000..69c7f0b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/7zFM.exe.manifest
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+ <assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7-Zip.7-Zip.7zFM" type="win32"/>
+ <description>7-Zip File Manager.</description>
+ <dependency>
+ <dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/></dependentAssembly>
+ </dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7 --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8 --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10 --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+ <asmv3:application>
+ <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
+ <dpiAware>true</dpiAware>
+ </asmv3:windowsSettings>
+ </asmv3:application>
+<application xmlns="urn:schemas-microsoft-com:asm.v3">
+<windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
+<ws2:longPathAware>true</ws2:longPathAware></windowsSettings></application>
+</assembly>
diff --git a/CPP/7zip/UI/FileManager/7zipLogo.ico b/CPP/7zip/UI/FileManager/7zipLogo.ico
new file mode 100644
index 0000000..973241c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/7zipLogo.ico
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/AboutDialog.cpp b/CPP/7zip/UI/FileManager/AboutDialog.cpp
new file mode 100644
index 0000000..efc74cc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialog.cpp
@@ -0,0 +1,81 @@
+// AboutDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../MyVersion.h"
+
+#include "../Common/LoadCodecs.h"
+
+#include "AboutDialog.h"
+#include "PropertyNameRes.h"
+
+#include "HelpUtils.h"
+#include "LangUtils.h"
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_ABOUT_INFO
+};
+#endif
+
+#define kHomePageURL TEXT("https://www.7-zip.org/")
+#define kHelpTopic "start.htm"
+
+#define LLL_(quote) L##quote
+#define LLL(quote) LLL_(quote)
+
+extern CCodecs *g_CodecsObj;
+
+bool CAboutDialog::OnInit()
+{
+ #ifdef Z7_EXTERNAL_CODECS
+ if (g_CodecsObj)
+ {
+ UString s;
+ g_CodecsObj->GetCodecsErrorMessage(s);
+ if (!s.IsEmpty())
+ MessageBoxW(GetParent(), s, L"7-Zip", MB_ICONERROR);
+ }
+ #endif
+
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_ABOUT);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ #endif
+ SetItemText(IDT_ABOUT_VERSION, UString("7-Zip " MY_VERSION_CPU));
+ SetItemText(IDT_ABOUT_DATE, LLL(MY_DATE));
+
+ NormalizePosition();
+ return CModalDialog::OnInit();
+}
+
+void CAboutDialog::OnHelp()
+{
+ ShowHelpWindow(kHelpTopic);
+}
+
+bool CAboutDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ LPCTSTR url;
+ switch (buttonID)
+ {
+ case IDB_ABOUT_HOMEPAGE: url = kHomePageURL; break;
+ default:
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+ }
+
+ #ifdef UNDER_CE
+ SHELLEXECUTEINFO s;
+ memset(&s, 0, sizeof(s));
+ s.cbSize = sizeof(s);
+ s.lpFile = url;
+ ::ShellExecuteEx(&s);
+ #else
+ ::ShellExecute(NULL, NULL, url, NULL, NULL, SW_SHOWNORMAL);
+ #endif
+
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/AboutDialog.h b/CPP/7zip/UI/FileManager/AboutDialog.h
new file mode 100644
index 0000000..1d11d74
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialog.h
@@ -0,0 +1,19 @@
+// AboutDialog.h
+
+#ifndef ZIP7_INC_ABOUT_DIALOG_H
+#define ZIP7_INC_ABOUT_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+
+#include "AboutDialogRes.h"
+
+class CAboutDialog: public NWindows::NControl::CModalDialog
+{
+public:
+ virtual bool OnInit() Z7_override;
+ virtual void OnHelp() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ INT_PTR Create(HWND wndParent = NULL) { return CModalDialog::Create(IDD_ABOUT, wndParent); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/AboutDialog.rc b/CPP/7zip/UI/FileManager/AboutDialog.rc
new file mode 100644
index 0000000..b235df0
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialog.rc
@@ -0,0 +1,26 @@
+#include "AboutDialogRes.h"
+#include "../../GuiCommon.rc"
+#include "../../MyVersion.h"
+
+#define xc 144
+#define yc 144
+
+#define y 93
+
+IDI_LOGO ICON "../../UI/FileManager/7zipLogo.ico"
+
+#ifndef SS_REALSIZEIMAGE
+#define SS_REALSIZEIMAGE 0x800
+#endif
+
+IDD_ABOUT DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "About 7-Zip"
+{
+ DEFPUSHBUTTON "OK", IDOK, bx1, by, bxs, bys
+ PUSHBUTTON "www.7-zip.org", IDB_ABOUT_HOMEPAGE, bx2, by, bxs, bys
+ ICON IDI_LOGO, -1, m, m, 32, 32, SS_REALSIZEIMAGE
+ LTEXT "", IDT_ABOUT_VERSION, m, 54, xc, 8
+ LTEXT "", IDT_ABOUT_DATE, m, 67, xc, 8
+ LTEXT MY_COPYRIGHT, -1, m, 80, xc, 8
+ LTEXT "7-Zip is free software", IDT_ABOUT_INFO, m, y, xc, (by - y - 1)
+}
diff --git a/CPP/7zip/UI/FileManager/AboutDialogRes.h b/CPP/7zip/UI/FileManager/AboutDialogRes.h
new file mode 100644
index 0000000..b416558
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AboutDialogRes.h
@@ -0,0 +1,8 @@
+#define IDD_ABOUT 2900
+
+#define IDT_ABOUT_INFO 2901
+
+#define IDI_LOGO 100
+#define IDT_ABOUT_VERSION 101
+#define IDT_ABOUT_DATE 102
+#define IDB_ABOUT_HOMEPAGE 110
diff --git a/CPP/7zip/UI/FileManager/Add.bmp b/CPP/7zip/UI/FileManager/Add.bmp
new file mode 100644
index 0000000..a8577fc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Add.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Add2.bmp b/CPP/7zip/UI/FileManager/Add2.bmp
new file mode 100644
index 0000000..252fc25
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Add2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/AltStreamsFolder.cpp b/CPP/7zip/UI/FileManager/AltStreamsFolder.cpp
new file mode 100644
index 0000000..b3d354d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AltStreamsFolder.cpp
@@ -0,0 +1,952 @@
+// AltStreamsFolder.cpp
+
+#include "StdAfx.h"
+
+#ifdef __MINGW32_VERSION
+// #if !defined(_MSC_VER) && (__GNUC__) && (__GNUC__ < 10)
+// for old mingw
+#include <ddk/ntddk.h>
+#else
+#ifndef Z7_OLD_WIN_SDK
+ #if !defined(_M_IA64)
+ #include <winternl.h>
+ #endif
+#else
+typedef LONG NTSTATUS;
+typedef struct _IO_STATUS_BLOCK {
+ union {
+ NTSTATUS Status;
+ PVOID Pointer;
+ };
+ ULONG_PTR Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+#endif
+#endif
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "AltStreamsFolder.h"
+#include "FSDrives.h"
+#include "FSFolder.h"
+
+#include "SysIconUtils.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+using namespace NDir;
+using namespace NName;
+
+#ifndef USE_UNICODE_FSTRING
+int CompareFileNames_ForFolderList(const FChar *s1, const FChar *s2);
+#endif
+
+#ifndef UNDER_CE
+
+namespace NFsFolder
+{
+bool MyGetCompressedFileSizeW(CFSTR path, UInt64 &size);
+}
+
+#endif
+
+namespace NAltStreamsFolder {
+
+static const Byte kProps[] =
+{
+ kpidName,
+ kpidSize,
+ kpidPackSize
+};
+
+static unsigned GetFsParentPrefixSize(const FString &path)
+{
+ if (IsNetworkShareRootPath(path))
+ return 0;
+ const unsigned prefixSize = GetRootPrefixSize(path);
+ if (prefixSize == 0 || prefixSize >= path.Len())
+ return 0;
+ FString parentPath = path;
+ int pos = parentPath.ReverseFind_PathSepar();
+ if (pos < 0)
+ return 0;
+ if (pos == (int)parentPath.Len() - 1)
+ {
+ parentPath.DeleteBack();
+ pos = parentPath.ReverseFind_PathSepar();
+ if (pos < 0)
+ return 0;
+ }
+ if ((unsigned)pos + 1 < prefixSize)
+ return 0;
+ return (unsigned)pos + 1;
+}
+
+HRESULT CAltStreamsFolder::Init(const FString &path /* , IFolderFolder *parentFolder */)
+{
+ // _parentFolder = parentFolder;
+ if (path.Back() != ':')
+ return E_FAIL;
+
+ _pathPrefix = path;
+ _pathBaseFile = path;
+ _pathBaseFile.DeleteBack();
+
+ {
+ CFileInfo fi;
+ if (!fi.Find(_pathBaseFile))
+ return GetLastError_noZero_HRESULT();
+ }
+
+ unsigned prefixSize = GetFsParentPrefixSize(_pathBaseFile);
+ if (prefixSize == 0)
+ return S_OK;
+ FString parentPath = _pathBaseFile;
+ parentPath.DeleteFrom(prefixSize);
+
+ _findChangeNotification.FindFirst(parentPath, false,
+ FILE_NOTIFY_CHANGE_FILE_NAME
+ | FILE_NOTIFY_CHANGE_DIR_NAME
+ | FILE_NOTIFY_CHANGE_ATTRIBUTES
+ | FILE_NOTIFY_CHANGE_SIZE
+ | FILE_NOTIFY_CHANGE_LAST_WRITE
+ /*
+ | FILE_NOTIFY_CHANGE_LAST_ACCESS
+ | FILE_NOTIFY_CHANGE_CREATION
+ | FILE_NOTIFY_CHANGE_SECURITY
+ */
+ );
+ /*
+ if (_findChangeNotification.IsHandleAllocated())
+ return S_OK;
+ return GetLastError();
+ */
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::LoadItems())
+{
+ Int32 dummy;
+ WasChanged(&dummy);
+ Clear();
+
+ CStreamEnumerator enumerator(_pathBaseFile);
+
+ CStreamInfo si;
+ for (;;)
+ {
+ bool found;
+ if (!enumerator.Next(si, found))
+ {
+ // if (GetLastError() == ERROR_ACCESS_DENIED)
+ // break;
+ // return E_FAIL;
+ break;
+ }
+ if (!found)
+ break;
+ if (si.IsMainStream())
+ continue;
+ CAltStream ss;
+ ss.Name = si.GetReducedName();
+ if (!ss.Name.IsEmpty() && ss.Name[0] == ':')
+ ss.Name.Delete(0);
+
+ ss.Size = si.Size;
+ ss.PackSize_Defined = false;
+ ss.PackSize = si.Size;
+ Streams.Add(ss);
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = Streams.Size();
+ return S_OK;
+}
+
+#ifdef USE_UNICODE_FSTRING
+
+Z7_COM7F_IMF(CAltStreamsFolder::GetItemPrefix(UInt32 /* index */, const wchar_t **name, unsigned *len))
+{
+ *name = NULL;
+ *len = 0;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::GetItemName(UInt32 index, const wchar_t **name, unsigned *len))
+{
+ *name = NULL;
+ *len = 0;
+ {
+ const CAltStream &ss = Streams[index];
+ *name = ss.Name;
+ *len = ss.Name.Len();
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt64, CAltStreamsFolder::GetItemSize(UInt32 index))
+{
+ return Streams[index].Size;
+}
+
+#endif
+
+
+Z7_COM7F_IMF(CAltStreamsFolder::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ {
+ CAltStream &ss = Streams[index];
+ switch (propID)
+ {
+ case kpidIsDir: prop = false; break;
+ case kpidIsAltStream: prop = true; break;
+ case kpidName: prop = ss.Name; break;
+ case kpidSize: prop = ss.Size; break;
+ case kpidPackSize:
+ #ifdef UNDER_CE
+ prop = ss.Size;
+ #else
+ if (!ss.PackSize_Defined)
+ {
+ ss.PackSize_Defined = true;
+ if (!NFsFolder::MyGetCompressedFileSizeW(_pathPrefix + us2fs(ss.Name), ss.PackSize))
+ ss.PackSize = ss.Size;
+ }
+ prop = ss.PackSize;
+ #endif
+ break;
+ }
+ }
+
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+// returns Position of extension including '.'
+
+static inline const wchar_t *GetExtensionPtr(const UString &name)
+{
+ const int dotPos = name.ReverseFind_Dot();
+ return name.Ptr(dotPos < 0 ? name.Len() : (unsigned)dotPos);
+}
+
+Z7_COM7F_IMF2(Int32, CAltStreamsFolder::CompareItems(UInt32 index1, UInt32 index2, PROPID propID, Int32 /* propIsRaw */))
+{
+ const CAltStream &ss1 = Streams[index1];
+ const CAltStream &ss2 = Streams[index2];
+
+ switch (propID)
+ {
+ case kpidName:
+ {
+ return CompareFileNames_ForFolderList(ss1.Name, ss2.Name);
+ // return MyStringCompareNoCase(ss1.Name, ss2.Name);
+ }
+ case kpidSize:
+ return MyCompare(ss1.Size, ss2.Size);
+ case kpidPackSize:
+ {
+ #ifdef UNDER_CE
+ return MyCompare(ss1.Size, ss2.Size);
+ #else
+ // PackSize can be undefined here
+ return MyCompare(
+ ss1.PackSize,
+ ss2.PackSize);
+ #endif
+ }
+
+ case kpidExtension:
+ return CompareFileNames_ForFolderList(
+ GetExtensionPtr(ss1.Name),
+ GetExtensionPtr(ss2.Name));
+ }
+
+ return 0;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::BindToFolder(UInt32 /* index */, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ return E_INVALIDARG;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::BindToFolder(const wchar_t * /* name */, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ return E_INVALIDARG;
+}
+
+// static CFSTR const kSuperPrefix = FTEXT("\\\\?\\");
+
+Z7_COM7F_IMF(CAltStreamsFolder::BindToParentFolder(IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ /*
+ if (_parentFolder)
+ {
+ CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+ *resultFolder = parentFolder.Detach();
+ return S_OK;
+ }
+ */
+
+ if (IsDriveRootPath_SuperAllowed(_pathBaseFile))
+ {
+ CFSDrives *drivesFolderSpec = new CFSDrives;
+ CMyComPtr<IFolderFolder> drivesFolder = drivesFolderSpec;
+ drivesFolderSpec->Init();
+ *resultFolder = drivesFolder.Detach();
+ return S_OK;
+ }
+
+ /*
+ parentPath.DeleteFrom(pos + 1);
+
+ if (parentPath == kSuperPrefix)
+ {
+ #ifdef UNDER_CE
+ *resultFolder = 0;
+ #else
+ CFSDrives *drivesFolderSpec = new CFSDrives;
+ CMyComPtr<IFolderFolder> drivesFolder = drivesFolderSpec;
+ drivesFolderSpec->Init(false, true);
+ *resultFolder = drivesFolder.Detach();
+ #endif
+ return S_OK;
+ }
+
+ FString parentPathReduced = parentPath.Left(pos);
+
+ #ifndef UNDER_CE
+ pos = parentPathReduced.ReverseFind_PathSepar();
+ if (pos == 1)
+ {
+ if (!IS_PATH_SEPAR_CHAR(parentPath[0]))
+ return E_FAIL;
+ CNetFolder *netFolderSpec = new CNetFolder;
+ CMyComPtr<IFolderFolder> netFolder = netFolderSpec;
+ netFolderSpec->Init(fs2us(parentPath));
+ *resultFolder = netFolder.Detach();
+ return S_OK;
+ }
+ #endif
+
+ CFSFolder *parentFolderSpec = new CFSFolder;
+ CMyComPtr<IFolderFolder> parentFolder = parentFolderSpec;
+ RINOK(parentFolderSpec->Init(parentPath, 0));
+ *resultFolder = parentFolder.Detach();
+ */
+
+ return S_OK;
+}
+
+IMP_IFolderFolder_Props(CAltStreamsFolder)
+
+Z7_COM7F_IMF(CAltStreamsFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidType: prop = "AltStreamsFolder"; break;
+ case kpidPath: prop = fs2us(_pathPrefix); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::WasChanged(Int32 *wasChanged))
+{
+ bool wasChangedMain = false;
+ for (;;)
+ {
+ if (!_findChangeNotification.IsHandleAllocated())
+ {
+ *wasChanged = BoolToInt(false);
+ return S_OK;
+ }
+
+ DWORD waitResult = ::WaitForSingleObject(_findChangeNotification, 0);
+ bool wasChangedLoc = (waitResult == WAIT_OBJECT_0);
+ if (wasChangedLoc)
+ {
+ _findChangeNotification.FindNext();
+ wasChangedMain = true;
+ }
+ else
+ break;
+ }
+ *wasChanged = BoolToInt(wasChangedMain);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::Clone(IFolderFolder **resultFolder))
+{
+ CAltStreamsFolder *folderSpec = new CAltStreamsFolder;
+ CMyComPtr<IFolderFolder> folderNew = folderSpec;
+ folderSpec->Init(_pathPrefix);
+ *resultFolder = folderNew.Detach();
+ return S_OK;
+}
+
+void CAltStreamsFolder::GetAbsPath(const wchar_t *name, FString &absPath)
+{
+ absPath.Empty();
+ if (!IsAbsolutePath(name))
+ absPath += _pathPrefix;
+ absPath += us2fs(name);
+}
+
+
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+ const wchar_t *message, const FString &fileName)
+{
+ UString s = message;
+ s += " : ";
+ s += fs2us(fileName);
+ return callback->ShowMessage(s);
+}
+
+static HRESULT SendMessageError(IFolderArchiveUpdateCallback *callback,
+ const wchar_t *message, const FString &fileName)
+{
+ UString s = message;
+ s += " : ";
+ s += fs2us(fileName);
+ return callback->UpdateErrorMessage(s);
+}
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+ const char *message, const FString &fileName)
+{
+ return SendMessageError(callback, MultiByteToUnicodeString(message), fileName);
+}
+
+/*
+static HRESULT SendMessageError(IFolderArchiveUpdateCallback *callback,
+ const char *message, const FString &fileName)
+{
+ return SendMessageError(callback, MultiByteToUnicodeString(message), fileName);
+}
+*/
+
+Z7_COM7F_IMF(CAltStreamsFolder::CreateFolder(const wchar_t * /* name */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::CreateFile(const wchar_t *name, IProgress * /* progress */))
+{
+ FString absPath;
+ GetAbsPath(name, absPath);
+ NIO::COutFile outFile;
+ if (!outFile.Create(absPath, false))
+ return GetLastError_noZero_HRESULT();
+ return S_OK;
+}
+
+static UString GetLastErrorMessage()
+{
+ return NError::MyFormatMessage(GetLastError_noZero_HRESULT());
+}
+
+static HRESULT UpdateFile(NFsFolder::CCopyStateIO &state, CFSTR inPath, CFSTR outPath, IFolderArchiveUpdateCallback *callback)
+{
+ if (NFind::DoesFileOrDirExist(outPath))
+ {
+ RINOK(SendMessageError(callback, NError::MyFormatMessage(ERROR_ALREADY_EXISTS), FString(outPath)))
+ CFileInfo fi;
+ if (fi.Find(inPath))
+ {
+ if (state.TotalSize >= fi.Size)
+ state.TotalSize -= fi.Size;
+ }
+ return S_OK;
+ }
+
+ {
+ if (callback)
+ RINOK(callback->CompressOperation(fs2us(inPath)))
+ RINOK(state.MyCopyFile(inPath, outPath))
+ if (state.ErrorFileIndex >= 0)
+ {
+ if (state.ErrorMessage.IsEmpty())
+ state.ErrorMessage = GetLastErrorMessage();
+ FString errorName;
+ if (state.ErrorFileIndex == 0)
+ errorName = inPath;
+ else
+ errorName = outPath;
+ if (callback)
+ RINOK(SendMessageError(callback, state.ErrorMessage, errorName))
+ }
+ if (callback)
+ RINOK(callback->OperationResult(0))
+ }
+
+ return S_OK;
+}
+
+EXTERN_C_BEGIN
+
+typedef enum
+{
+ Z7_WIN_FileRenameInformation = 10
+}
+Z7_WIN_FILE_INFORMATION_CLASS;
+
+
+typedef struct
+{
+ // #if (_WIN32_WINNT >= _WIN32_WINNT_WIN10_RS1)
+ union
+ {
+ BOOLEAN ReplaceIfExists; // FileRenameInformation
+ ULONG Flags; // FileRenameInformationEx
+ } DUMMYUNIONNAME;
+ // #else
+ // BOOLEAN ReplaceIfExists;
+ // #endif
+ HANDLE RootDirectory;
+ ULONG FileNameLength;
+ WCHAR FileName[1];
+} Z7_WIN_FILE_RENAME_INFORMATION;
+
+#if (_WIN32_WINNT >= 0x0500) && !defined(_M_IA64)
+#define Z7_WIN_NTSTATUS NTSTATUS
+#define Z7_WIN_IO_STATUS_BLOCK IO_STATUS_BLOCK
+#else
+typedef LONG Z7_WIN_NTSTATUS;
+typedef struct
+{
+ union
+ {
+ Z7_WIN_NTSTATUS Status;
+ PVOID Pointer;
+ } DUMMYUNIONNAME;
+ ULONG_PTR Information;
+} Z7_WIN_IO_STATUS_BLOCK;
+#endif
+
+typedef Z7_WIN_NTSTATUS (WINAPI *Func_NtSetInformationFile)(
+ HANDLE FileHandle,
+ Z7_WIN_IO_STATUS_BLOCK *IoStatusBlock,
+ PVOID FileInformation,
+ ULONG Length,
+ Z7_WIN_FILE_INFORMATION_CLASS FileInformationClass);
+
+// NTAPI
+typedef ULONG (WINAPI *Func_RtlNtStatusToDosError)(Z7_WIN_NTSTATUS Status);
+
+#define MY_STATUS_SUCCESS 0
+
+EXTERN_C_END
+
+// static Func_NtSetInformationFile f_NtSetInformationFile;
+// static bool g_NtSetInformationFile_WasRequested = false;
+
+
+Z7_COM7F_IMF(CAltStreamsFolder::Rename(UInt32 index, const wchar_t *newName, IProgress *progress))
+{
+ const CAltStream &ss = Streams[index];
+ const FString srcPath = _pathPrefix + us2fs(ss.Name);
+
+ const HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
+ // if (!g_NtSetInformationFile_WasRequested) {
+ // g_NtSetInformationFile_WasRequested = true;
+ const
+ Func_NtSetInformationFile
+ f_NtSetInformationFile = Z7_GET_PROC_ADDRESS(
+ Func_NtSetInformationFile, ntdll,
+ "NtSetInformationFile");
+ if (f_NtSetInformationFile)
+ {
+ NIO::CInFile inFile;
+ if (inFile.Open_for_FileRenameInformation(srcPath))
+ {
+ UString destPath (':');
+ destPath += newName;
+ const ULONG len = (ULONG)sizeof(wchar_t) * destPath.Len();
+ CByteBuffer buffer(sizeof(Z7_WIN_FILE_RENAME_INFORMATION) + len);
+ // buffer is 4 bytes larger than required.
+ Z7_WIN_FILE_RENAME_INFORMATION *fri = (Z7_WIN_FILE_RENAME_INFORMATION *)(void *)(Byte *)buffer;
+ memset(fri, 0, sizeof(Z7_WIN_FILE_RENAME_INFORMATION));
+ /* DOCS: If ReplaceIfExists is set to TRUE, the rename operation will succeed only
+ if a stream with the same name does not exist or is a zero-length data stream. */
+ fri->ReplaceIfExists = FALSE;
+ fri->RootDirectory = NULL;
+ fri->FileNameLength = len;
+ memcpy(fri->FileName, destPath.Ptr(), len);
+ Z7_WIN_IO_STATUS_BLOCK iosb;
+ const Z7_WIN_NTSTATUS status = f_NtSetInformationFile (inFile.GetHandle(),
+ &iosb, fri, (ULONG)buffer.Size(), Z7_WIN_FileRenameInformation);
+ if (status != MY_STATUS_SUCCESS)
+ {
+ const
+ Func_RtlNtStatusToDosError
+ f_RtlNtStatusToDosError = Z7_GET_PROC_ADDRESS(
+ Func_RtlNtStatusToDosError, ntdll,
+ "RtlNtStatusToDosError");
+ if (f_RtlNtStatusToDosError)
+ {
+ const ULONG res = f_RtlNtStatusToDosError(status);
+ if (res != ERROR_MR_MID_NOT_FOUND)
+ return HRESULT_FROM_WIN32(res);
+ }
+ }
+ return status;
+ }
+ }
+
+ CMyComPtr<IFolderArchiveUpdateCallback> callback;
+ if (progress)
+ {
+ RINOK(progress->QueryInterface(IID_IFolderArchiveUpdateCallback, (void **)&callback))
+ }
+
+ if (callback)
+ {
+ RINOK(callback->SetNumFiles(1))
+ RINOK(callback->SetTotal(ss.Size))
+ }
+
+ NFsFolder::CCopyStateIO state;
+ state.Progress = progress;
+ state.TotalSize = 0;
+ state.DeleteSrcFile = true;
+
+ const FString destPath = _pathPrefix + us2fs(newName);
+ return UpdateFile(state, srcPath, destPath, callback);
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::Delete(const UInt32 *indices, UInt32 numItems,IProgress *progress))
+{
+ RINOK(progress->SetTotal(numItems))
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ const CAltStream &ss = Streams[indices[i]];
+ const FString fullPath = _pathPrefix + us2fs(ss.Name);
+ const bool result = DeleteFileAlways(fullPath);
+ if (!result)
+ return GetLastError_noZero_HRESULT();
+ const UInt64 completed = i;
+ RINOK(progress->SetCompleted(&completed))
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::SetProperty(UInt32 /* index */, PROPID /* propID */,
+ const PROPVARIANT * /* value */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex))
+{
+ const CAltStream &ss = Streams[index];
+ *iconIndex = 0;
+ int iconIndexTemp;
+ if (GetRealIconIndex(_pathPrefix + us2fs(ss.Name),
+ 0 // fi.Attrib
+ , iconIndexTemp) != 0)
+ {
+ *iconIndex = iconIndexTemp;
+ return S_OK;
+ }
+ return GetLastError_noZero_HRESULT();
+}
+
+/*
+Z7_CLASS_IMP_COM_1(
+ CGetProp
+ , IGetProp
+)
+public:
+ // const CArc *Arc;
+ // UInt32 IndexInArc;
+ UString Name; // relative path
+ UInt64 Size;
+};
+
+Z7_COM7F_IMF(CGetProp::GetProp(PROPID propID, PROPVARIANT *value))
+{
+ if (propID == kpidName)
+ {
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ prop = Name;
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+ }
+ if (propID == kpidSize)
+ {
+ NCOM::CPropVariant prop = Size;
+ prop.Detach(value);
+ return S_OK;
+ }
+ NCOM::CPropVariant prop;
+ prop.Detach(value);
+ return S_OK;
+}
+*/
+
+static HRESULT CopyStream(
+ NFsFolder::CCopyStateIO &state,
+ const FString &srcPath,
+ const CFileInfo &srcFileInfo,
+ const CAltStream &srcAltStream,
+ const FString &destPathSpec,
+ IFolderOperationsExtractCallback *callback)
+{
+ FString destPath = destPathSpec;
+ if (CompareFileNames(destPath, srcPath) == 0)
+ {
+ RINOK(SendMessageError(callback, "Cannot copy file onto itself", destPath))
+ return E_ABORT;
+ }
+
+ Int32 writeAskResult;
+ CMyComBSTR destPathResult;
+ RINOK(callback->AskWrite(
+ fs2us(srcPath),
+ BoolToInt(false),
+ &srcFileInfo.MTime, &srcAltStream.Size,
+ fs2us(destPath),
+ &destPathResult,
+ &writeAskResult))
+
+ if (IntToBool(writeAskResult))
+ {
+ RINOK(callback->SetCurrentFilePath(fs2us(srcPath)))
+ FString destPathNew (us2fs((LPCOLESTR)destPathResult));
+ RINOK(state.MyCopyFile(srcPath, destPathNew))
+ if (state.ErrorFileIndex >= 0)
+ {
+ if (state.ErrorMessage.IsEmpty())
+ state.ErrorMessage = GetLastErrorMessage();
+ FString errorName;
+ if (state.ErrorFileIndex == 0)
+ errorName = srcPath;
+ else
+ errorName = destPathNew;
+ RINOK(SendMessageError(callback, state.ErrorMessage, errorName))
+ return E_ABORT;
+ }
+ state.StartPos += state.CurrentSize;
+ }
+ else
+ {
+ if (state.TotalSize >= srcAltStream.Size)
+ {
+ state.TotalSize -= srcAltStream.Size;
+ RINOK(state.Progress->SetTotal(state.TotalSize))
+ }
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+ Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */,
+ const wchar_t *path, IFolderOperationsExtractCallback *callback))
+{
+ if (numItems == 0)
+ return S_OK;
+
+ /*
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IFolderExtractToStreamCallback,
+ ExtractToStreamCallback, callback)
+ if (ExtractToStreamCallback)
+ {
+ Int32 useStreams = 0;
+ if (ExtractToStreamCallback->UseExtractToStream(&useStreams) != S_OK)
+ useStreams = 0;
+ if (useStreams == 0)
+ ExtractToStreamCallback.Release();
+ }
+ */
+
+ UInt64 totalSize = 0;
+ {
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ totalSize += Streams[indices[i]].Size;
+ }
+ RINOK(callback->SetTotal(totalSize))
+ RINOK(callback->SetNumFiles(numItems))
+ }
+
+ /*
+ if (ExtractToStreamCallback)
+ {
+ CGetProp *GetProp_Spec = new CGetProp;
+ CMyComPtr<IGetProp> GetProp= GetProp_Spec;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ UInt32 index = indices[i];
+ const CAltStream &ss = Streams[index];
+ GetProp_Spec->Name = ss.Name;
+ GetProp_Spec->Size = ss.Size;
+ CMyComPtr<ISequentialOutStream> outStream;
+ RINOK(ExtractToStreamCallback->GetStream7(GetProp_Spec->Name, BoolToInt(false), &outStream,
+ NArchive::NExtract::NAskMode::kExtract, GetProp)); // isDir
+ FString srcPath;
+ GetFullPath(ss, srcPath);
+ RINOK(ExtractToStreamCallback->PrepareOperation7(NArchive::NExtract::NAskMode::kExtract));
+ RINOK(ExtractToStreamCallback->SetOperationResult7(NArchive::NExtract::NOperationResult::kOK, BoolToInt(false))); // _encrypted
+ // RINOK(CopyStream(state, srcPath, fi, ss, destPath2, callback, completedSize));
+ }
+ return S_OK;
+ }
+ */
+
+ FString destPath (us2fs(path));
+ if (destPath.IsEmpty() /* && !ExtractToStreamCallback */)
+ return E_INVALIDARG;
+
+ const bool isAltDest = NName::IsAltPathPrefix(destPath);
+ const bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back()));
+
+ if (isDirectPath)
+ {
+ if (numItems > 1)
+ return E_INVALIDARG;
+ }
+
+ CFileInfo fi;
+ if (!fi.Find(_pathBaseFile))
+ return GetLastError_noZero_HRESULT();
+
+ NFsFolder::CCopyStateIO state;
+ state.Progress = callback;
+ state.DeleteSrcFile = IntToBool(moveMode);
+ state.TotalSize = totalSize;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ const UInt32 index = indices[i];
+ const CAltStream &ss = Streams[index];
+ FString destPath2 = destPath;
+ if (!isDirectPath)
+ destPath2 += us2fs(Get_Correct_FsFile_Name(ss.Name));
+ FString srcPath;
+ GetFullPath(ss, srcPath);
+ RINOK(CopyStream(state, srcPath, fi, ss, destPath2, callback))
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::CopyFrom(Int32 /* moveMode */, const wchar_t * /* fromFolderPath */,
+ const wchar_t * const * /* itemsPaths */, UInt32 /* numItems */, IProgress * /* progress */))
+{
+ /*
+ if (numItems == 0)
+ return S_OK;
+
+ CMyComPtr<IFolderArchiveUpdateCallback> callback;
+ if (progress)
+ {
+ RINOK(progress->QueryInterface(IID_IFolderArchiveUpdateCallback, (void **)&callback));
+ }
+
+ if (CompareFileNames(fromFolderPath, fs2us(_pathPrefix)) == 0)
+ {
+ RINOK(SendMessageError(callback, "Cannot copy file onto itself", _pathPrefix));
+ return E_ABORT;
+ }
+
+ if (callback)
+ RINOK(callback->SetNumFiles(numItems));
+
+ UInt64 totalSize = 0;
+
+ UInt32 i;
+
+ FString path;
+ for (i = 0; i < numItems; i++)
+ {
+ path = us2fs(fromFolderPath);
+ path += us2fs(itemsPaths[i]);
+
+ CFileInfo fi;
+ if (!fi.Find(path))
+ return ::GetLastError();
+ if (fi.IsDir())
+ return E_NOTIMPL;
+ totalSize += fi.Size;
+ }
+
+ RINOK(progress->SetTotal(totalSize));
+
+ // UInt64 completedSize = 0;
+
+ NFsFolder::CCopyStateIO state;
+ state.Progress = progress;
+ state.DeleteSrcFile = IntToBool(moveMode);
+ state.TotalSize = totalSize;
+
+ // we need to clear READ-ONLY of parent before creating alt stream
+ {
+ DWORD attrib = GetFileAttrib(_pathBaseFile);
+ if (attrib != INVALID_FILE_ATTRIBUTES
+ && (attrib & FILE_ATTRIBUTE_READONLY) != 0)
+ {
+ if (!SetFileAttrib(_pathBaseFile, attrib & ~FILE_ATTRIBUTE_READONLY))
+ {
+ if (callback)
+ {
+ RINOK(SendMessageError(callback, GetLastErrorMessage(), _pathBaseFile));
+ return S_OK;
+ }
+ return Return_LastError_or_FAIL();
+ }
+ }
+ }
+
+ for (i = 0; i < numItems; i++)
+ {
+ path = us2fs(fromFolderPath);
+ path += us2fs(itemsPaths[i]);
+
+ FString destPath = _pathPrefix + us2fs(itemsPaths[i]);
+
+ RINOK(UpdateFile(state, path, destPath, callback));
+ }
+
+ return S_OK;
+ */
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CAltStreamsFolder::CopyFromFile(UInt32 /* index */, const wchar_t * /* fullFilePath */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+}
diff --git a/CPP/7zip/UI/FileManager/AltStreamsFolder.h b/CPP/7zip/UI/FileManager/AltStreamsFolder.h
new file mode 100644
index 0000000..ccb6d6f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AltStreamsFolder.h
@@ -0,0 +1,92 @@
+// AltStreamsFolder.h
+
+#ifndef ZIP7_INC_ALT_STREAMS_FOLDER_H
+#define ZIP7_INC_ALT_STREAMS_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "IFolder.h"
+
+namespace NAltStreamsFolder {
+
+class CAltStreamsFolder;
+
+struct CAltStream
+{
+ UInt64 Size;
+ UInt64 PackSize;
+ bool PackSize_Defined;
+ UString Name;
+};
+
+
+class CAltStreamsFolder Z7_final:
+ public IFolderFolder,
+ public IFolderCompare,
+ #ifdef USE_UNICODE_FSTRING
+ public IFolderGetItemName,
+ #endif
+ public IFolderWasChanged,
+ public IFolderOperations,
+ // public IFolderOperationsDeleteToRecycleBin,
+ public IFolderClone,
+ public IFolderGetSystemIconIndex,
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IFolderFolder)
+ Z7_COM_QI_ENTRY(IFolderCompare)
+ #ifdef USE_UNICODE_FSTRING
+ Z7_COM_QI_ENTRY(IFolderGetItemName)
+ #endif
+ Z7_COM_QI_ENTRY(IFolderWasChanged)
+ // Z7_COM_QI_ENTRY(IFolderOperationsDeleteToRecycleBin)
+ Z7_COM_QI_ENTRY(IFolderOperations)
+ Z7_COM_QI_ENTRY(IFolderClone)
+ Z7_COM_QI_ENTRY(IFolderGetSystemIconIndex)
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IFolderFolder)
+ Z7_IFACE_COM7_IMP(IFolderCompare)
+ #ifdef USE_UNICODE_FSTRING
+ Z7_IFACE_COM7_IMP(IFolderGetItemName)
+ #endif
+ Z7_IFACE_COM7_IMP(IFolderWasChanged)
+ Z7_IFACE_COM7_IMP(IFolderOperations)
+ Z7_IFACE_COM7_IMP(IFolderClone)
+ Z7_IFACE_COM7_IMP(IFolderGetSystemIconIndex)
+
+ FString _pathBaseFile; // folder
+ FString _pathPrefix; // folder:
+
+ CObjectVector<CAltStream> Streams;
+ // CMyComPtr<IFolderFolder> _parentFolder;
+
+ NWindows::NFile::NFind::CFindChangeNotification _findChangeNotification;
+
+ HRESULT GetItemFullSize(unsigned index, UInt64 &size, IProgress *progress);
+ void GetAbsPath(const wchar_t *name, FString &absPath);
+
+public:
+ // path must be with ':' at tail
+ HRESULT Init(const FString &path /* , IFolderFolder *parentFolder */);
+
+ void GetFullPath(const CAltStream &item, FString &path) const
+ {
+ path = _pathPrefix;
+ path += us2fs(item.Name);
+ }
+
+ void Clear()
+ {
+ Streams.Clear();
+ }
+};
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/App.cpp b/CPP/7zip/UI/FileManager/App.cpp
new file mode 100644
index 0000000..3461c92
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/App.cpp
@@ -0,0 +1,998 @@
+// App.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+#include "OverwriteDialogRes.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariantConv.h"
+
+/*
+#include "Windows/COM.h"
+#include "Windows/Error.h"
+#include "Windows/FileDir.h"
+
+#include "Windows/PropVariant.h"
+#include "Windows/Thread.h"
+*/
+
+#include "App.h"
+#include "CopyDialog.h"
+#include "ExtractCallback.h"
+#include "FormatUtils.h"
+#include "IFolder.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+#include "RegistryUtils.h"
+#include "ViewSettings.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NFind;
+using namespace NName;
+
+extern DWORD g_ComCtl32Version;
+extern HINSTANCE g_hInstance;
+
+#define kTempDirPrefix FTEXT("7zE")
+
+void CPanelCallbackImp::OnTab()
+{
+ if (g_App.NumPanels != 1)
+ _app->Panels[1 - _index].SetFocusToList();
+ _app->RefreshTitle();
+}
+
+void CPanelCallbackImp::SetFocusToPath(unsigned index)
+{
+ unsigned newPanelIndex = index;
+ if (g_App.NumPanels == 1)
+ newPanelIndex = g_App.LastFocusedPanel;
+ _app->RefreshTitle();
+ _app->Panels[newPanelIndex]._headerComboBox.SetFocus();
+ _app->Panels[newPanelIndex]._headerComboBox.ShowDropDown();
+}
+
+
+void CPanelCallbackImp::OnCopy(bool move, bool copyToSame) { _app->OnCopy(move, copyToSame, _index); }
+void CPanelCallbackImp::OnSetSameFolder() { _app->OnSetSameFolder(_index); }
+void CPanelCallbackImp::OnSetSubFolder() { _app->OnSetSubFolder(_index); }
+void CPanelCallbackImp::PanelWasFocused() { _app->SetFocusedPanel(_index); _app->RefreshTitlePanel(_index); }
+void CPanelCallbackImp::DragBegin() { _app->DragBegin(_index); }
+void CPanelCallbackImp::DragEnd() { _app->DragEnd(); }
+void CPanelCallbackImp::RefreshTitle(bool always) { _app->RefreshTitlePanel(_index, always); }
+
+void CApp::ReloadLangItems()
+{
+ LangString(IDS_N_SELECTED_ITEMS, LangString_N_SELECTED_ITEMS);
+}
+
+void CApp::SetListSettings()
+{
+ CFmSettings st;
+ st.Load();
+
+ ShowSystemMenu = st.ShowSystemMenu;
+
+ DWORD extendedStyle = LVS_EX_HEADERDRAGDROP;
+ if (st.FullRow)
+ extendedStyle |= LVS_EX_FULLROWSELECT;
+ if (st.ShowGrid)
+ extendedStyle |= LVS_EX_GRIDLINES;
+
+ if (st.SingleClick)
+ {
+ extendedStyle |= LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT;
+ /*
+ if (ReadUnderline())
+ extendedStyle |= LVS_EX_UNDERLINEHOT;
+ */
+ }
+
+ for (unsigned i = 0; i < kNumPanelsMax; i++)
+ {
+ CPanel &panel = Panels[i];
+ panel._mySelectMode = st.AlternativeSelection;
+ panel._showDots = st.ShowDots;
+ panel._showRealFileIcons = st.ShowRealFileIcons;
+ panel._exStyle = extendedStyle;
+
+ LONG_PTR style = panel._listView.GetStyle();
+ if (st.AlternativeSelection)
+ style |= LVS_SINGLESEL;
+ else
+ style &= ~(LONG_PTR)(DWORD)LVS_SINGLESEL;
+ panel._listView.SetStyle(style);
+ panel.SetExtendedStyle();
+ }
+}
+
+#ifndef ILC_COLOR32
+#define ILC_COLOR32 0x0020
+#endif
+
+HRESULT CApp::CreateOnePanel(unsigned panelIndex, const UString &mainPath, const UString &arcFormat,
+ bool needOpenArc,
+ COpenResult &openRes)
+{
+ if (Panels[panelIndex].PanelCreated)
+ return S_OK;
+
+ m_PanelCallbackImp[panelIndex].Init(this, panelIndex);
+
+ UString path;
+ if (mainPath.IsEmpty())
+ {
+ if (!::ReadPanelPath(panelIndex, path))
+ path.Empty();
+ }
+ else
+ path = mainPath;
+
+ const unsigned id = 1000 + 100 * panelIndex; // check it
+
+ return Panels[panelIndex].Create(_window, _window,
+ id, path, arcFormat, &m_PanelCallbackImp[panelIndex], &AppState,
+ needOpenArc,
+ openRes);
+}
+
+
+static void CreateToolbar(HWND parent,
+ NControl::CImageList &imageList,
+ NControl::CToolBar &toolBar,
+ bool largeButtons)
+{
+ toolBar.Attach(::CreateWindowEx(0, TOOLBARCLASSNAME, NULL, 0
+ | WS_CHILD
+ | WS_VISIBLE
+ | TBSTYLE_FLAT
+ | TBSTYLE_TOOLTIPS
+ | TBSTYLE_WRAPABLE
+ // | TBSTYLE_AUTOSIZE
+ // | CCS_NORESIZE
+ #ifdef UNDER_CE
+ | CCS_NODIVIDER
+ | CCS_NOPARENTALIGN
+ #endif
+ ,0,0,0,0, parent, NULL, g_hInstance, NULL));
+
+ // TB_BUTTONSTRUCTSIZE message, which is required for
+ // backward compatibility.
+ toolBar.ButtonStructSize();
+
+ imageList.Create(
+ largeButtons ? 48: 24,
+ largeButtons ? 36: 24,
+ ILC_MASK | ILC_COLOR32, 0, 0);
+ toolBar.SetImageList(0, imageList);
+}
+
+
+struct CButtonInfo
+{
+ int CommandID;
+ UINT BitmapResID;
+ UINT Bitmap2ResID;
+ UINT StringResID;
+
+ UString GetText() const { return LangString(StringResID); }
+};
+
+static const CButtonInfo g_StandardButtons[] =
+{
+ { IDM_COPY_TO, IDB_COPY, IDB_COPY2, IDS_BUTTON_COPY },
+ { IDM_MOVE_TO, IDB_MOVE, IDB_MOVE2, IDS_BUTTON_MOVE },
+ { IDM_DELETE, IDB_DELETE, IDB_DELETE2, IDS_BUTTON_DELETE } ,
+ { IDM_PROPERTIES, IDB_INFO, IDB_INFO2, IDS_BUTTON_INFO }
+};
+
+static const CButtonInfo g_ArchiveButtons[] =
+{
+ { kMenuCmdID_Toolbar_Add, IDB_ADD, IDB_ADD2, IDS_ADD },
+ { kMenuCmdID_Toolbar_Extract, IDB_EXTRACT, IDB_EXTRACT2, IDS_EXTRACT },
+ { kMenuCmdID_Toolbar_Test, IDB_TEST, IDB_TEST2, IDS_TEST }
+};
+
+static bool SetButtonText(int commandID, const CButtonInfo *buttons, unsigned numButtons, UString &s)
+{
+ for (unsigned i = 0; i < numButtons; i++)
+ {
+ const CButtonInfo &b = buttons[i];
+ if (b.CommandID == commandID)
+ {
+ s = b.GetText();
+ return true;
+ }
+ }
+ return false;
+}
+
+static void SetButtonText(int commandID, UString &s)
+{
+ if (SetButtonText(commandID, g_StandardButtons, Z7_ARRAY_SIZE(g_StandardButtons), s))
+ return;
+ SetButtonText(commandID, g_ArchiveButtons, Z7_ARRAY_SIZE(g_ArchiveButtons), s);
+}
+
+static void AddButton(
+ NControl::CImageList &imageList,
+ NControl::CToolBar &toolBar,
+ const CButtonInfo &butInfo, bool showText, bool large)
+{
+ TBBUTTON but;
+ but.iBitmap = 0;
+ but.idCommand = butInfo.CommandID;
+ but.fsState = TBSTATE_ENABLED;
+ but.fsStyle = TBSTYLE_BUTTON;
+ but.dwData = 0;
+
+ UString s = butInfo.GetText();
+ but.iString = 0;
+ if (showText)
+ but.iString = (INT_PTR)(LPCWSTR)s;
+
+ but.iBitmap = imageList.GetImageCount();
+ HBITMAP b = ::LoadBitmap(g_hInstance,
+ large ?
+ MAKEINTRESOURCE(butInfo.BitmapResID):
+ MAKEINTRESOURCE(butInfo.Bitmap2ResID));
+ if (b)
+ {
+ imageList.AddMasked(b, RGB(255, 0, 255));
+ ::DeleteObject(b);
+ }
+ #ifdef _UNICODE
+ toolBar.AddButton(1, &but);
+ #else
+ toolBar.AddButtonW(1, &but);
+ #endif
+}
+
+void CApp::ReloadToolbars()
+{
+ _buttonsImageList.Destroy();
+ _toolBar.Destroy();
+
+
+ if (ShowArchiveToolbar || ShowStandardToolbar)
+ {
+ CreateToolbar(_window, _buttonsImageList, _toolBar, LargeButtons);
+ unsigned i;
+ if (ShowArchiveToolbar)
+ for (i = 0; i < Z7_ARRAY_SIZE(g_ArchiveButtons); i++)
+ AddButton(_buttonsImageList, _toolBar, g_ArchiveButtons[i], ShowButtonsLables, LargeButtons);
+ if (ShowStandardToolbar)
+ for (i = 0; i < Z7_ARRAY_SIZE(g_StandardButtons); i++)
+ AddButton(_buttonsImageList, _toolBar, g_StandardButtons[i], ShowButtonsLables, LargeButtons);
+
+ _toolBar.AutoSize();
+ }
+}
+
+void CApp::SaveToolbarChanges()
+{
+ SaveToolbar();
+ ReloadToolbars();
+ MoveSubWindows();
+}
+
+
+HRESULT CApp::Create(HWND hwnd, const UString &mainPath, const UString &arcFormat, int xSizes[2], bool needOpenArc, COpenResult &openRes)
+{
+ _window.Attach(hwnd);
+
+ #ifdef UNDER_CE
+ _commandBar.Create(g_hInstance, hwnd, 1);
+ #endif
+
+ MyLoadMenu(false); // needResetMenu
+
+ #ifdef UNDER_CE
+ _commandBar.AutoSize();
+ #endif
+
+ ReadToolbar();
+ ReloadToolbars();
+
+ unsigned i;
+ for (i = 0; i < kNumPanelsMax; i++)
+ Panels[i].PanelCreated = false;
+
+ AppState.Read();
+
+ SetListSettings();
+
+ if (LastFocusedPanel >= kNumPanelsMax)
+ LastFocusedPanel = 0;
+ // ShowDeletedFiles = Read_ShowDeleted();
+
+ CListMode listMode;
+ listMode.Read();
+
+ for (i = 0; i < kNumPanelsMax; i++)
+ {
+ CPanel &panel = Panels[i];
+ panel._listViewMode = listMode.Panels[i];
+ panel._xSize = xSizes[i];
+ panel._flatModeForArc = ReadFlatView(i);
+ }
+
+ for (i = 0; i < kNumPanelsMax; i++)
+ {
+ unsigned panelIndex = i;
+ if (needOpenArc && LastFocusedPanel == 1)
+ panelIndex = 1 - i;
+
+ bool isMainPanel = (panelIndex == LastFocusedPanel);
+
+ if (NumPanels > 1 || isMainPanel)
+ {
+ if (NumPanels == 1)
+ Panels[panelIndex]._xSize = xSizes[0] + xSizes[1];
+
+ COpenResult openRes2;
+ UString path;
+ if (isMainPanel)
+ path = mainPath;
+
+ RINOK(CreateOnePanel(panelIndex, path, arcFormat,
+ isMainPanel && needOpenArc,
+ *(isMainPanel ? &openRes : &openRes2)))
+
+ if (isMainPanel)
+ {
+ if (needOpenArc && !openRes.ArchiveIsOpened)
+ return S_OK;
+ }
+ }
+ }
+
+ SetFocusedPanel(LastFocusedPanel);
+ Panels[LastFocusedPanel].SetFocusToList();
+ return S_OK;
+}
+
+
+HRESULT CApp::SwitchOnOffOnePanel()
+{
+ if (NumPanels == 1)
+ {
+ NumPanels++;
+ COpenResult openRes;
+ RINOK(CreateOnePanel(1 - LastFocusedPanel, UString(), UString(),
+ false, // needOpenArc
+ openRes))
+ Panels[1 - LastFocusedPanel].Enable(true);
+ Panels[1 - LastFocusedPanel].Show(SW_SHOWNORMAL);
+ }
+ else
+ {
+ NumPanels--;
+ Panels[1 - LastFocusedPanel].Enable(false);
+ Panels[1 - LastFocusedPanel].Show(SW_HIDE);
+ }
+ MoveSubWindows();
+ return S_OK;
+}
+
+void CApp::Save()
+{
+ AppState.Save();
+ CListMode listMode;
+
+ for (unsigned i = 0; i < kNumPanelsMax; i++)
+ {
+ const CPanel &panel = Panels[i];
+ UString path;
+ if (panel._parentFolders.IsEmpty())
+ path = panel._currentFolderPrefix;
+ else
+ path = panel._parentFolders[0].ParentFolderPath;
+ // GetFolderPath(panel._parentFolders[0].ParentFolder);
+ SavePanelPath(i, path);
+ listMode.Panels[i] = panel.GetListViewMode();
+ SaveFlatView(i, panel._flatModeForArc);
+ }
+
+ listMode.Save();
+ // Save_ShowDeleted(ShowDeletedFiles);
+}
+
+void CApp::Release()
+{
+ // It's for unloading COM dll's: don't change it.
+ for (unsigned i = 0; i < kNumPanelsMax; i++)
+ Panels[i].Release();
+}
+
+// reduces path to part that exists on disk (or root prefix of path)
+// output path is normalized (with WCHAR_PATH_SEPARATOR)
+static void Reduce_Path_To_RealFileSystemPath(UString &path)
+{
+ unsigned prefixSize = GetRootPrefixSize(path);
+
+ while (!path.IsEmpty())
+ {
+ if (NFind::DoesDirExist_FollowLink(us2fs(path)))
+ {
+ NName::NormalizeDirPathPrefix(path);
+ break;
+ }
+ int pos = path.ReverseFind_PathSepar();
+ if (pos < 0)
+ {
+ path.Empty();
+ break;
+ }
+ path.DeleteFrom((unsigned)(pos + 1));
+ if ((unsigned)pos + 1 == prefixSize)
+ break;
+ path.DeleteFrom((unsigned)pos);
+ }
+}
+
+// returns: true, if such dir exists or is root
+/*
+static bool CheckFolderPath(const UString &path)
+{
+ UString pathReduced = path;
+ Reduce_Path_To_RealFileSystemPath(pathReduced);
+ return (pathReduced == path);
+}
+*/
+
+extern UString ConvertSizeToString(UInt64 value);
+
+static void AddSizeValue(UString &s, UInt64 size)
+{
+ s += MyFormatNew(IDS_FILE_SIZE, ConvertSizeToString(size));
+}
+
+static void AddValuePair1(UString &s, UINT resourceID, UInt64 size)
+{
+ AddLangString(s, resourceID);
+ s += ": ";
+ AddSizeValue(s, size);
+ s.Add_LF();
+}
+
+void AddValuePair2(UString &s, UINT resourceID, UInt64 num, UInt64 size);
+void AddValuePair2(UString &s, UINT resourceID, UInt64 num, UInt64 size)
+{
+ if (num == 0)
+ return;
+ AddLangString(s, resourceID);
+ s += ": ";
+ s += ConvertSizeToString(num);
+
+ if (size != (UInt64)(Int64)-1)
+ {
+ s += " ( ";
+ AddSizeValue(s, size);
+ s += " )";
+ }
+ s.Add_LF();
+}
+
+static void AddPropValueToSum(IFolderFolder *folder, UInt32 index, PROPID propID, UInt64 &sum)
+{
+ if (sum == (UInt64)(Int64)-1)
+ return;
+ NCOM::CPropVariant prop;
+ folder->GetProperty(index, propID, &prop);
+ UInt64 val = 0;
+ if (ConvertPropVariantToUInt64(prop, val))
+ sum += val;
+ else
+ sum = (UInt64)(Int64)-1;
+}
+
+UString CPanel::GetItemsInfoString(const CRecordVector<UInt32> &indices)
+{
+ UString info;
+ UInt64 numDirs, numFiles, filesSize, foldersSize;
+ numDirs = numFiles = filesSize = foldersSize = 0;
+
+ unsigned i;
+ for (i = 0; i < indices.Size(); i++)
+ {
+ const UInt32 index = indices[i];
+ if (IsItem_Folder(index))
+ {
+ AddPropValueToSum(_folder, index, kpidSize, foldersSize);
+ numDirs++;
+ }
+ else
+ {
+ AddPropValueToSum(_folder, index, kpidSize, filesSize);
+ numFiles++;
+ }
+ }
+
+ AddValuePair2(info, IDS_PROP_FOLDERS, numDirs, foldersSize);
+ AddValuePair2(info, IDS_PROP_FILES, numFiles, filesSize);
+ int numDefined = ((foldersSize != (UInt64)(Int64)-1) && foldersSize != 0) ? 1: 0;
+ numDefined += ((filesSize != (UInt64)(Int64)-1) && filesSize != 0) ? 1: 0;
+ if (numDefined == 2)
+ AddValuePair1(info, IDS_PROP_SIZE, filesSize + foldersSize);
+
+ info.Add_LF();
+ info += _currentFolderPrefix;
+
+ for (i = 0; i < indices.Size() && (int)i < (int)kCopyDialog_NumInfoLines - 6; i++)
+ {
+ info.Add_LF();
+ info += " ";
+ const UInt32 index = indices[i];
+ info += GetItemRelPath(index);
+ if (IsItem_Folder(index))
+ info.Add_PathSepar();
+ }
+ if (i != indices.Size())
+ {
+ info.Add_LF();
+ info += " ...";
+ }
+ return info;
+}
+
+bool IsCorrectFsName(const UString &name);
+
+
+
+/* Returns true, if path is path that can be used as path for File System functions
+*/
+
+/*
+static bool IsFsPath(const FString &path)
+{
+ if (!IsAbsolutePath(path))
+ return false;
+ unsigned prefixSize = GetRootPrefixSize(path);
+}
+*/
+
+void CApp::OnCopy(bool move, bool copyToSame, unsigned srcPanelIndex)
+{
+ const unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+ CPanel &srcPanel = Panels[srcPanelIndex];
+ CPanel &destPanel = Panels[destPanelIndex];
+
+ CPanel::CDisableTimerProcessing disableTimerProcessing1(destPanel);
+ CPanel::CDisableTimerProcessing disableTimerProcessing2(srcPanel);
+
+ if (move)
+ {
+ if (!srcPanel.CheckBeforeUpdate(IDS_MOVE))
+ return;
+ }
+ else if (!srcPanel.DoesItSupportOperations())
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ CRecordVector<UInt32> indices;
+ UString destPath;
+ bool useDestPanel = false;
+
+ {
+ if (copyToSame)
+ {
+ const int focusedItem = srcPanel._listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const unsigned realIndex = srcPanel.GetRealItemIndex(focusedItem);
+ if (realIndex == kParentIndex)
+ return;
+ indices.Add(realIndex);
+ destPath = srcPanel.GetItemName(realIndex);
+ }
+ else
+ {
+ srcPanel.Get_ItemIndices_OperSmart(indices);
+ if (indices.Size() == 0)
+ return;
+ destPath = destPanel.GetFsPath();
+ if (NumPanels == 1)
+ Reduce_Path_To_RealFileSystemPath(destPath);
+ }
+ }
+
+ UStringVector copyFolders;
+ ReadCopyHistory(copyFolders);
+
+ const bool useFullItemPaths = srcPanel.Is_IO_FS_Folder(); // maybe we need flat also here ??
+
+ {
+ CCopyDialog copyDialog;
+
+ copyDialog.Strings = copyFolders;
+ copyDialog.Value = destPath;
+ LangString(move ? IDS_MOVE : IDS_COPY, copyDialog.Title);
+ LangString(move ? IDS_MOVE_TO : IDS_COPY_TO, copyDialog.Static);
+ copyDialog.Info = srcPanel.GetItemsInfoString(indices);
+
+ if (copyDialog.Create(srcPanel.GetParent()) != IDOK)
+ return;
+
+ destPath = copyDialog.Value;
+ }
+
+ {
+ if (destPath.IsEmpty())
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ UString correctName;
+ if (!srcPanel.CorrectFsPath(destPath, correctName))
+ {
+ srcPanel.MessageBox_Error_HRESULT(E_INVALIDARG);
+ return;
+ }
+
+ if (IsAbsolutePath(destPath))
+ destPath.Empty();
+ else
+ destPath = srcPanel.GetFsPath();
+ destPath += correctName;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (destPath.Len() > 0 && destPath[0] == '\\')
+ if (destPath.Len() == 1 || destPath[1] != '\\')
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ #endif
+
+ bool possibleToUseDestPanel = false;
+
+ if (CompareFileNames(destPath, destPanel.GetFsPath()) == 0)
+ {
+ if (NumPanels == 1 || CompareFileNames(destPath, srcPanel.GetFsPath()) == 0)
+ {
+ srcPanel.MessageBox_Error(L"Cannot copy files onto itself");
+ return;
+ }
+
+ if (destPanel.DoesItSupportOperations())
+ possibleToUseDestPanel = true;
+ }
+
+ bool destIsFsPath = false;
+
+ if (possibleToUseDestPanel)
+ {
+ if (destPanel.IsFSFolder() || destPanel.IsAltStreamsFolder())
+ destIsFsPath = true;
+ else if (destPanel.IsFSDrivesFolder() || destPanel.IsRootFolder())
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ }
+ else
+ {
+ if (IsAltPathPrefix(us2fs(destPath)))
+ {
+ // we allow alt streams dest only to alt stream folder in second panel
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ /*
+ FString basePath = us2fs(destPath);
+ basePath.DeleteBack();
+ if (!DoesFileOrDirExist(basePath))
+ {
+ srcPanel.MessageBoxError2Lines(basePath, ERROR_FILE_NOT_FOUND); // GetLastError()
+ return;
+ }
+ destIsFsPath = true;
+ */
+ }
+ else
+ {
+ if (indices.Size() == 1 &&
+ !destPath.IsEmpty() && !IS_PATH_SEPAR(destPath.Back()))
+ {
+ int pos = destPath.ReverseFind_PathSepar();
+ if (pos < 0)
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ {
+ /*
+ #ifdef _WIN32
+ UString name = destPath.Ptr(pos + 1);
+ if (name.Find(L':') >= 0)
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ #endif
+ */
+ UString prefix = destPath.Left(pos + 1);
+ if (!CreateComplexDir(us2fs(prefix)))
+ {
+ const HRESULT lastError = GetLastError_noZero_HRESULT();
+ srcPanel.MessageBox_Error_2Lines_Message_HRESULT(prefix, lastError);
+ return;
+ }
+ }
+ // bool isFolder = srcPanael.IsItem_Folder(indices[0]);
+ }
+ else
+ {
+ NName::NormalizeDirPathPrefix(destPath);
+ if (!CreateComplexDir(us2fs(destPath)))
+ {
+ const HRESULT lastError = GetLastError_noZero_HRESULT();
+ srcPanel.MessageBox_Error_2Lines_Message_HRESULT(destPath, lastError);
+ return;
+ }
+ }
+ destIsFsPath = true;
+ }
+ }
+
+ if (!destIsFsPath)
+ useDestPanel = true;
+
+ AddUniqueStringToHeadOfList(copyFolders, destPath);
+ while (copyFolders.Size() > 20)
+ copyFolders.DeleteBack();
+ SaveCopyHistory(copyFolders);
+ }
+
+ bool useSrcPanel = !useDestPanel || !srcPanel.Is_IO_FS_Folder();
+
+ bool useTemp = useSrcPanel && useDestPanel;
+ if (useTemp && NumPanels == 1)
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ CTempDir tempDirectory;
+ FString tempDirPrefix;
+ if (useTemp)
+ {
+ tempDirectory.Create(kTempDirPrefix);
+ tempDirPrefix = tempDirectory.GetPath();
+ NFile::NName::NormalizeDirPathPrefix(tempDirPrefix);
+ }
+
+ CSelectedState srcSelState;
+ CSelectedState destSelState;
+ srcPanel.SaveSelectedState(srcSelState);
+ destPanel.SaveSelectedState(destSelState);
+
+ CPanel::CDisableNotify disableNotify1(destPanel);
+ CPanel::CDisableNotify disableNotify2(srcPanel);
+
+ HRESULT result = S_OK;
+
+ if (useSrcPanel)
+ {
+ CCopyToOptions options;
+ options.folder = useTemp ? fs2us(tempDirPrefix) : destPath;
+ options.moveMode = move;
+ options.includeAltStreams = true;
+ options.replaceAltStreamChars = false;
+ options.showErrorMessages = true;
+
+ result = srcPanel.CopyTo(options, indices, NULL);
+ }
+
+ if (result == S_OK && useDestPanel)
+ {
+ UStringVector filePaths;
+ UString folderPrefix;
+
+ if (useTemp)
+ folderPrefix = fs2us(tempDirPrefix);
+ else
+ folderPrefix = srcPanel.GetFsPath();
+
+ filePaths.ClearAndReserve(indices.Size());
+
+ FOR_VECTOR (i, indices)
+ {
+ UInt32 index = indices[i];
+ UString s;
+ if (useFullItemPaths)
+ s = srcPanel.GetItemRelPath2(index);
+ else
+ s = srcPanel.GetItemName_for_Copy(index);
+ filePaths.AddInReserved(s);
+ }
+
+ result = destPanel.CopyFrom(move, folderPrefix, filePaths, true, NULL);
+ }
+
+ if (result != S_OK)
+ {
+ // disableNotify1.Restore();
+ // disableNotify2.Restore();
+ // For Password:
+ // srcPanel.SetFocusToList();
+ // srcPanel.InvalidateList(NULL, true);
+
+ if (result != E_ABORT)
+ srcPanel.MessageBox_Error_HRESULT(result);
+ // return;
+ }
+
+ RefreshTitleAlways();
+
+ if (copyToSame || move)
+ {
+ srcPanel.RefreshListCtrl(srcSelState);
+ }
+
+ if (!copyToSame)
+ {
+ destPanel.RefreshListCtrl(destSelState);
+ srcPanel.KillSelection();
+ }
+
+ disableNotify1.Restore();
+ disableNotify2.Restore();
+ srcPanel.SetFocusToList();
+}
+
+void CApp::OnSetSameFolder(unsigned srcPanelIndex)
+{
+ if (NumPanels <= 1)
+ return;
+ const CPanel &srcPanel = Panels[srcPanelIndex];
+ CPanel &destPanel = Panels[1 - srcPanelIndex];
+ destPanel.BindToPathAndRefresh(srcPanel._currentFolderPrefix);
+}
+
+void CApp::OnSetSubFolder(unsigned srcPanelIndex)
+{
+ if (NumPanels <= 1)
+ return;
+ const CPanel &srcPanel = Panels[srcPanelIndex];
+ CPanel &destPanel = Panels[1 - srcPanelIndex];
+
+ const int focusedItem = srcPanel._listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const unsigned realIndex = srcPanel.GetRealItemIndex(focusedItem);
+ if (!srcPanel.IsItem_Folder(realIndex))
+ return;
+
+ // destPanel.BindToFolder(srcPanel._currentFolderPrefix + srcPanel.GetItemName(realIndex) + WCHAR_PATH_SEPARATOR);
+
+ CMyComPtr<IFolderFolder> newFolder;
+ if (realIndex == kParentIndex)
+ {
+ if (srcPanel._folder->BindToParentFolder(&newFolder) != S_OK)
+ return;
+ if (!newFolder)
+ {
+ {
+ const UString parentPrefix = srcPanel.GetParentDirPrefix();
+ COpenResult openRes;
+ destPanel.BindToPath(parentPrefix, UString(), openRes);
+ }
+ destPanel.RefreshListCtrl();
+ return;
+ }
+ }
+ else
+ {
+ if (srcPanel._folder->BindToFolder(realIndex, &newFolder) != S_OK)
+ return;
+ }
+
+ if (!newFolder)
+ return;
+
+ destPanel.CloseOpenFolders();
+ destPanel.SetNewFolder(newFolder);
+ destPanel.RefreshListCtrl();
+}
+
+/*
+int CApp::GetFocusedPanelIndex() const
+{
+ return LastFocusedPanel;
+ HWND hwnd = ::GetFocus();
+ for (;;)
+ {
+ if (hwnd == 0)
+ return 0;
+ for (unsigned i = 0; i < kNumPanelsMax; i++)
+ {
+ if (PanelsCreated[i] &&
+ ((HWND)Panels[i] == hwnd || Panels[i]._listView == hwnd))
+ return i;
+ }
+ hwnd = GetParent(hwnd);
+ }
+}
+*/
+
+static UString g_ToolTipBuffer;
+static CSysString g_ToolTipBufferSys;
+
+void CApp::OnNotify(int /* ctrlID */, LPNMHDR pnmh)
+{
+ {
+ if (pnmh->code == TTN_GETDISPINFO)
+ {
+ LPNMTTDISPINFO info = (LPNMTTDISPINFO)pnmh;
+ info->hinst = NULL;
+ g_ToolTipBuffer.Empty();
+ SetButtonText((int)info->hdr.idFrom, g_ToolTipBuffer);
+ g_ToolTipBufferSys = GetSystemString(g_ToolTipBuffer);
+ info->lpszText = g_ToolTipBufferSys.Ptr_non_const();
+ return;
+ }
+ #ifndef _UNICODE
+ if (pnmh->code == TTN_GETDISPINFOW)
+ {
+ LPNMTTDISPINFOW info = (LPNMTTDISPINFOW)pnmh;
+ info->hinst = NULL;
+ g_ToolTipBuffer.Empty();
+ SetButtonText((int)info->hdr.idFrom, g_ToolTipBuffer);
+ info->lpszText = g_ToolTipBuffer.Ptr_non_const();
+ return;
+ }
+ #endif
+ }
+}
+
+void CApp::RefreshTitle(bool always)
+{
+ UString path = GetFocusedPanel()._currentFolderPrefix;
+ if (path.IsEmpty())
+ path = "7-Zip"; // LangString(IDS_APP_TITLE);
+ if (!always && path == PrevTitle)
+ return;
+ PrevTitle = path;
+ NWindows::MySetWindowText(_window, path);
+}
+
+void CApp::RefreshTitlePanel(unsigned panelIndex, bool always)
+{
+ if (panelIndex != GetFocusedPanelIndex())
+ return;
+ RefreshTitle(always);
+}
+
+static void AddUniqueStringToHead(UStringVector &list, const UString &s)
+{
+ for (unsigned i = 0; i < list.Size();)
+ if (s.IsEqualTo_NoCase(list[i]))
+ list.Delete(i);
+ else
+ i++;
+ list.Insert(0, s);
+}
+
+
+void CFolderHistory::Normalize()
+{
+ const unsigned kMaxSize = 100;
+ if (Strings.Size() > kMaxSize)
+ Strings.DeleteFrom(kMaxSize);
+}
+
+void CFolderHistory::AddString(const UString &s)
+{
+ NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ AddUniqueStringToHead(Strings, s);
+ Normalize();
+}
diff --git a/CPP/7zip/UI/FileManager/App.h b/CPP/7zip/UI/FileManager/App.h
new file mode 100644
index 0000000..fc54501
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/App.h
@@ -0,0 +1,306 @@
+// App.h
+
+#ifndef ZIP7_INC_APP_H
+#define ZIP7_INC_APP_H
+
+#include "../../../Windows/Control/CommandBar.h"
+#include "../../../Windows/Control/ImageList.h"
+
+#include "AppState.h"
+#include "Panel.h"
+
+class CApp;
+
+extern CApp g_App;
+extern HWND g_HWND;
+
+const unsigned kNumPanelsMax = 2;
+
+extern bool g_IsSmallScreen;
+
+// must be larger than context menu IDs
+const int kMenuCmdID_Toolbar_Start = 1070;
+const int kMenuCmdID_Plugin_Start = 1100;
+
+enum
+{
+ kMenuCmdID_Toolbar_Add = kMenuCmdID_Toolbar_Start,
+ kMenuCmdID_Toolbar_Extract,
+ kMenuCmdID_Toolbar_Test,
+ kMenuCmdID_Toolbar_End
+};
+
+class CPanelCallbackImp Z7_final: public CPanelCallback
+{
+ CApp *_app;
+ unsigned _index;
+public:
+ void Init(CApp *app, unsigned index)
+ {
+ _app = app;
+ _index = index;
+ }
+ virtual void OnTab() Z7_override;
+ virtual void SetFocusToPath(unsigned index) Z7_override;
+ virtual void OnCopy(bool move, bool copyToSame) Z7_override;
+ virtual void OnSetSameFolder() Z7_override;
+ virtual void OnSetSubFolder() Z7_override;
+ virtual void PanelWasFocused() Z7_override;
+ virtual void DragBegin() Z7_override;
+ virtual void DragEnd() Z7_override;
+ virtual void RefreshTitle(bool always) Z7_override;
+};
+
+
+class CDropTarget;
+
+class CApp
+{
+public:
+ NWindows::CWindow _window;
+ bool ShowSystemMenu;
+ bool AutoRefresh_Mode;
+ // bool ShowDeletedFiles;
+ unsigned NumPanels;
+ unsigned LastFocusedPanel;
+
+ bool ShowStandardToolbar;
+ bool ShowArchiveToolbar;
+ bool ShowButtonsLables;
+ bool LargeButtons;
+
+ CAppState AppState;
+ CPanelCallbackImp m_PanelCallbackImp[kNumPanelsMax];
+ CPanel Panels[kNumPanelsMax];
+
+ NWindows::NControl::CImageList _buttonsImageList;
+
+ #ifdef UNDER_CE
+ NWindows::NControl::CCommandBar _commandBar;
+ #endif
+ NWindows::NControl::CToolBar _toolBar;
+
+ CDropTarget *_dropTargetSpec;
+ CMyComPtr<IDropTarget> _dropTarget;
+
+ UString LangString_N_SELECTED_ITEMS;
+
+ void ReloadLangItems();
+
+ CApp():
+ _window(NULL),
+ AutoRefresh_Mode(true),
+ NumPanels(2),
+ LastFocusedPanel(0)
+ {
+ SetPanels_AutoRefresh_Mode();
+ }
+
+ void CreateDragTarget();
+ void SetFocusedPanel(unsigned index);
+ void DragBegin(unsigned panelIndex);
+ void DragEnd();
+
+ void OnCopy(bool move, bool copyToSame, unsigned srcPanelIndex);
+ void OnSetSameFolder(unsigned srcPanelIndex);
+ void OnSetSubFolder(unsigned srcPanelIndex);
+
+ HRESULT CreateOnePanel(unsigned panelIndex, const UString &mainPath, const UString &arcFormat, bool needOpenArc, COpenResult &openRes);
+ HRESULT Create(HWND hwnd, const UString &mainPath, const UString &arcFormat, int xSizes[2], bool needOpenArc, COpenResult &openRes);
+ void Read();
+ void Save();
+ void Release();
+
+ // void SetFocus(int panelIndex) { Panels[panelIndex].SetFocusToList(); }
+ void SetFocusToLastItem() { Panels[LastFocusedPanel].SetFocusToLastRememberedItem(); }
+ unsigned GetFocusedPanelIndex() const { return LastFocusedPanel; }
+ bool IsPanelVisible(unsigned index) const { return (NumPanels > 1 || index == LastFocusedPanel); }
+ CPanel &GetFocusedPanel() { return Panels[GetFocusedPanelIndex()]; }
+
+ // File Menu
+ void OpenItem() { GetFocusedPanel().OpenSelectedItems(true); }
+ void OpenItemInside(const wchar_t *type) { GetFocusedPanel().OpenFocusedItemAsInternal(type); }
+ void OpenItemOutside() { GetFocusedPanel().OpenSelectedItems(false); }
+ void EditItem(bool useEditor) { GetFocusedPanel().EditItem(useEditor); }
+ void Rename() { GetFocusedPanel().RenameFile(); }
+ void CopyTo() { OnCopy(false, false, GetFocusedPanelIndex()); }
+ void MoveTo() { OnCopy(true, false, GetFocusedPanelIndex()); }
+ void Delete(bool toRecycleBin) { GetFocusedPanel().DeleteItems(toRecycleBin); }
+ HRESULT CalculateCrc2(const UString &methodName);
+ void CalculateCrc(const char *methodName);
+
+ void DiffFiles(const UString &path1, const UString &path2);
+ void DiffFiles();
+
+ void VerCtrl(unsigned id);
+
+ void Split();
+ void Combine();
+ void Properties() { GetFocusedPanel().Properties(); }
+ void Comment() { GetFocusedPanel().ChangeComment(); }
+
+ #ifndef UNDER_CE
+ void Link();
+ void OpenAltStreams() { GetFocusedPanel().OpenAltStreams(); }
+ #endif
+
+ void CreateFolder() { GetFocusedPanel().CreateFolder(); }
+ void CreateFile() { GetFocusedPanel().CreateFile(); }
+
+ // Edit
+ void EditCut() { GetFocusedPanel().EditCut(); }
+ void EditCopy() { GetFocusedPanel().EditCopy(); }
+ void EditPaste() { GetFocusedPanel().EditPaste(); }
+
+ void SelectAll(bool selectMode) { GetFocusedPanel().SelectAll(selectMode); }
+ void InvertSelection() { GetFocusedPanel().InvertSelection(); }
+ void SelectSpec(bool selectMode) { GetFocusedPanel().SelectSpec(selectMode); }
+ void SelectByType(bool selectMode) { GetFocusedPanel().SelectByType(selectMode); }
+
+ void Refresh_StatusBar() { GetFocusedPanel().Refresh_StatusBar(); }
+
+ void SetListViewMode(UInt32 index) { GetFocusedPanel().SetListViewMode(index); }
+ UInt32 GetListViewMode() { return GetFocusedPanel().GetListViewMode(); }
+ PROPID GetSortID() { return GetFocusedPanel().GetSortID(); }
+
+ void SortItemsWithPropID(PROPID propID) { GetFocusedPanel().SortItemsWithPropID(propID); }
+
+ void OpenRootFolder() { GetFocusedPanel().OpenDrivesFolder(); }
+ void OpenParentFolder() { GetFocusedPanel().OpenParentFolder(); }
+ void FoldersHistory() { GetFocusedPanel().FoldersHistory(); }
+ void RefreshView() { GetFocusedPanel().OnReload(); }
+ void RefreshAllPanels()
+ {
+ for (unsigned i = 0; i < NumPanels; i++)
+ {
+ unsigned index = i;
+ if (NumPanels == 1)
+ index = LastFocusedPanel;
+ Panels[index].OnReload();
+ }
+ }
+
+ /*
+ void SysIconsWereChanged()
+ {
+ for (unsigned i = 0; i < NumPanels; i++)
+ {
+ unsigned index = i;
+ if (NumPanels == 1)
+ index = LastFocusedPanel;
+ Panels[index].SysIconsWereChanged();
+ }
+ }
+ */
+
+ void SetListSettings();
+ HRESULT SwitchOnOffOnePanel();
+
+ CIntVector _timestampLevels;
+
+ bool GetFlatMode() { return Panels[LastFocusedPanel].GetFlatMode(); }
+
+ int GetTimestampLevel() const { return Panels[LastFocusedPanel]._timestampLevel; }
+ void SetTimestampLevel(int level)
+ {
+ unsigned i;
+ for (i = 0; i < kNumPanelsMax; i++)
+ {
+ CPanel &panel = Panels[i];
+ panel._timestampLevel = level;
+ if (panel.PanelCreated)
+ panel.RedrawListItems();
+ }
+ }
+
+ // bool Get_ShowNtfsStrems_Mode() { return Panels[LastFocusedPanel].Get_ShowNtfsStrems_Mode(); }
+
+ void ChangeFlatMode() { Panels[LastFocusedPanel].ChangeFlatMode(); }
+ // void Change_ShowNtfsStrems_Mode() { Panels[LastFocusedPanel].Change_ShowNtfsStrems_Mode(); }
+ // void Change_ShowDeleted() { ShowDeletedFiles = !ShowDeletedFiles; }
+
+ bool Get_AutoRefresh_Mode()
+ {
+ // return Panels[LastFocusedPanel].Get_ShowNtfsStrems_Mode();
+ return AutoRefresh_Mode;
+ }
+ void Change_AutoRefresh_Mode()
+ {
+ AutoRefresh_Mode = !AutoRefresh_Mode;
+ SetPanels_AutoRefresh_Mode();
+ }
+ void SetPanels_AutoRefresh_Mode()
+ {
+ for (unsigned i = 0; i < kNumPanelsMax; i++)
+ Panels[i].Set_AutoRefresh_Mode(AutoRefresh_Mode);
+ }
+
+ void OpenBookmark(unsigned index) { GetFocusedPanel().OpenBookmark(index); }
+ void SetBookmark(unsigned index) { GetFocusedPanel().SetBookmark(index); }
+
+ void ReloadToolbars();
+ void ReadToolbar()
+ {
+ const UInt32 mask = ReadToolbarsMask();
+ if (mask & ((UInt32)1 << 31))
+ {
+ ShowButtonsLables = !g_IsSmallScreen;
+ LargeButtons = false;
+ ShowStandardToolbar = ShowArchiveToolbar = true;
+ }
+ else
+ {
+ ShowButtonsLables = ((mask & 1) != 0);
+ LargeButtons = ((mask & 2) != 0);
+ ShowStandardToolbar = ((mask & 4) != 0);
+ ShowArchiveToolbar = ((mask & 8) != 0);
+ }
+ }
+ void SaveToolbar()
+ {
+ UInt32 mask = 0;
+ if (ShowButtonsLables) mask |= 1;
+ if (LargeButtons) mask |= 2;
+ if (ShowStandardToolbar) mask |= 4;
+ if (ShowArchiveToolbar) mask |= 8;
+ SaveToolbarsMask(mask);
+ }
+
+ void SaveToolbarChanges();
+
+ void SwitchStandardToolbar()
+ {
+ ShowStandardToolbar = !ShowStandardToolbar;
+ SaveToolbarChanges();
+ }
+ void SwitchArchiveToolbar()
+ {
+ ShowArchiveToolbar = !ShowArchiveToolbar;
+ SaveToolbarChanges();
+ }
+ void SwitchButtonsLables()
+ {
+ ShowButtonsLables = !ShowButtonsLables;
+ SaveToolbarChanges();
+ }
+ void SwitchLargeButtons()
+ {
+ LargeButtons = !LargeButtons;
+ SaveToolbarChanges();
+ }
+
+ void AddToArchive() { GetFocusedPanel().AddToArchive(); }
+ void ExtractArchives() { GetFocusedPanel().ExtractArchives(); }
+ void TestArchives() { GetFocusedPanel().TestArchives(); }
+
+ void OnNotify(int ctrlID, LPNMHDR pnmh);
+
+ UString PrevTitle;
+ void RefreshTitle(bool always = false);
+ void RefreshTitleAlways() { RefreshTitle(true); }
+ void RefreshTitlePanel(unsigned panelIndex, bool always = false);
+
+ void MoveSubWindows();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/AppState.h b/CPP/7zip/UI/FileManager/AppState.h
new file mode 100644
index 0000000..6630b96
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/AppState.h
@@ -0,0 +1,95 @@
+// AppState.h
+
+#ifndef ZIP7_INC_APP_STATE_H
+#define ZIP7_INC_APP_STATE_H
+
+#include "../../../Windows/Synchronization.h"
+
+#include "ViewSettings.h"
+
+class CFastFolders
+{
+ NWindows::NSynchronization::CCriticalSection _criticalSection;
+public:
+ UStringVector Strings;
+ void SetString(unsigned index, const UString &s)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ while (Strings.Size() <= index)
+ Strings.AddNew();
+ Strings[index] = s;
+ }
+ UString GetString(unsigned index)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ if (index >= Strings.Size())
+ return UString();
+ return Strings[index];
+ }
+ void Save()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ SaveFastFolders(Strings);
+ }
+ void Read()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ ReadFastFolders(Strings);
+ }
+};
+
+class CFolderHistory
+{
+ NWindows::NSynchronization::CCriticalSection _criticalSection;
+ UStringVector Strings;
+
+ void Normalize();
+
+public:
+
+ void GetList(UStringVector &foldersHistory)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ foldersHistory = Strings;
+ }
+
+ void AddString(const UString &s);
+
+ void RemoveAll()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ Strings.Clear();
+ }
+
+ void Save()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ SaveFolderHistory(Strings);
+ }
+
+ void Read()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ ReadFolderHistory(Strings);
+ Normalize();
+ }
+};
+
+struct CAppState
+{
+ CFastFolders FastFolders;
+ CFolderHistory FolderHistory;
+
+ void Save()
+ {
+ FastFolders.Save();
+ FolderHistory.Save();
+ }
+ void Read()
+ {
+ FastFolders.Read();
+ FolderHistory.Read();
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/BrowseDialog.cpp b/CPP/7zip/UI/FileManager/BrowseDialog.cpp
index d5c981c..5170302 100644
--- a/CPP/7zip/UI/FileManager/BrowseDialog.cpp
+++ b/CPP/7zip/UI/FileManager/BrowseDialog.cpp
@@ -1,1025 +1,1088 @@
-// BrowseDialog.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/MyWindows.h"
-
-#include <commctrl.h>
-
-#ifndef UNDER_CE
-#include "../../../Windows/CommonDialog.h"
-#include "../../../Windows/Shell.h"
-#endif
-
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/FileFind.h"
-
-#ifdef UNDER_CE
-#include <commdlg.h>
-#endif
-
-#include "BrowseDialog.h"
-
-#define USE_MY_BROWSE_DIALOG
-
-#ifdef USE_MY_BROWSE_DIALOG
-
-#include "../../../Common/Defs.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#include "../../../Windows/Control/ComboBox.h"
-#include "../../../Windows/Control/Dialog.h"
-#include "../../../Windows/Control/Edit.h"
-#include "../../../Windows/Control/ListView.h"
-
-#include "BrowseDialogRes.h"
-#include "PropertyNameRes.h"
-#include "SysIconUtils.h"
-
-#ifndef _SFX
-#include "RegistryUtils.h"
-#endif
-
-#endif
-
-#include "ComboDialog.h"
-#include "LangUtils.h"
-
-#include "resource.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NName;
-using namespace NFind;
-
-#ifdef USE_MY_BROWSE_DIALOG
-
-extern bool g_LVN_ITEMACTIVATE_Support;
-
-static const int kParentIndex = -1;
-static const UINT k_Message_RefreshPathEdit = WM_APP + 1;
-
-static HRESULT GetNormalizedError()
-{
- DWORD errorCode = GetLastError();
- return errorCode == 0 ? E_FAIL : errorCode;
-}
-
-extern UString HResultToMessage(HRESULT errorCode);
-
-static void MessageBox_Error_Global(HWND wnd, const wchar_t *message)
-{
- ::MessageBoxW(wnd, message, L"7-Zip", MB_ICONERROR);
-}
-
-static void MessageBox_HResError(HWND wnd, HRESULT errorCode, const wchar_t *name)
-{
- UString s = HResultToMessage(errorCode);
- if (name)
- {
- s.Add_LF();
- s += name;
- }
- MessageBox_Error_Global(wnd, s);
-}
-
-class CBrowseDialog: public NControl::CModalDialog
-{
- NControl::CListView _list;
- NControl::CEdit _pathEdit;
- NControl::CComboBox _filterCombo;
-
- CObjectVector<CFileInfo> _files;
-
- CExtToIconMap _extToIconMap;
- int _sortIndex;
- bool _ascending;
- bool _showDots;
- UString _topDirPrefix; // we don't open parent of that folder
- UString DirPrefix;
-
- virtual bool OnInit();
- virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
- virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
- virtual bool OnNotify(UINT controlID, LPNMHDR header);
- virtual bool OnKeyDown(LPNMLVKEYDOWN keyDownInfo);
- virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
- virtual void OnOK();
-
- void Post_RefreshPathEdit() { PostMsg(k_Message_RefreshPathEdit); }
-
- bool GetParentPath(const UString &path, UString &parentPrefix, UString &name);
- // Reload changes DirPrefix. Don't send DirPrefix in pathPrefix parameter
- HRESULT Reload(const UString &pathPrefix, const UString &selectedName);
- HRESULT Reload();
-
- void OpenParentFolder();
- void SetPathEditText();
- void OnCreateDir();
- void OnItemEnter();
- void FinishOnOK();
-
- int GetRealItemIndex(int indexInListView) const
- {
- LPARAM param;
- if (!_list.GetItemParam(indexInListView, param))
- return (int)-1;
- return (int)param;
- }
-
-public:
- bool FolderMode;
- UString Title;
- UString FilePath; // input/ result path
- bool ShowAllFiles;
- UStringVector Filters;
- UString FilterDescription;
-
- CBrowseDialog(): FolderMode(false), _showDots(false), ShowAllFiles(true) {}
- void SetFilter(const UString &s);
- INT_PTR Create(HWND parent = 0) { return CModalDialog::Create(IDD_BROWSE, parent); }
- int CompareItems(LPARAM lParam1, LPARAM lParam2);
-};
-
-void CBrowseDialog::SetFilter(const UString &s)
-{
- Filters.Clear();
- UString mask;
- unsigned i;
- for (i = 0; i < s.Len(); i++)
- {
- wchar_t c = s[i];
- if (c == ';')
- {
- if (!mask.IsEmpty())
- Filters.Add(mask);
- mask.Empty();
- }
- else
- mask += c;
- }
- if (!mask.IsEmpty())
- Filters.Add(mask);
- ShowAllFiles = Filters.IsEmpty();
- for (i = 0; i < Filters.Size(); i++)
- {
- const UString &f = Filters[i];
- if (f == L"*.*" || f == L"*")
- {
- ShowAllFiles = true;
- break;
- }
- }
-}
-
-bool CBrowseDialog::OnInit()
-{
- #ifdef LANG
- LangSetDlgItems(*this, NULL, 0);
- #endif
- if (!Title.IsEmpty())
- SetText(Title);
- _list.Attach(GetItem(IDL_BROWSE));
- _filterCombo.Attach(GetItem(IDC_BROWSE_FILTER));
- _pathEdit.Attach(GetItem(IDE_BROWSE_PATH));
-
- if (FolderMode)
- HideItem(IDC_BROWSE_FILTER);
- else
- EnableItem(IDC_BROWSE_FILTER, false);
-
- #ifndef UNDER_CE
- _list.SetUnicodeFormat();
- #endif
-
- #ifndef _SFX
- CFmSettings st;
- st.Load();
- if (st.SingleClick)
- _list.SetExtendedListViewStyle(LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT);
- _showDots = st.ShowDots;
- #endif
-
- {
- UString s;
- if (!FilterDescription.IsEmpty())
- s = FilterDescription;
- else if (ShowAllFiles)
- s = "*.*";
- else
- {
- FOR_VECTOR (i, Filters)
- {
- if (i != 0)
- s.Add_Space();
- s += Filters[i];
- }
- }
- _filterCombo.AddString(s);
- _filterCombo.SetCurSel(0);
- }
-
- _list.SetImageList(GetSysImageList(true), LVSIL_SMALL);
- _list.SetImageList(GetSysImageList(false), LVSIL_NORMAL);
-
- _list.InsertColumn(0, LangString(IDS_PROP_NAME), 100);
- _list.InsertColumn(1, LangString(IDS_PROP_MTIME), 100);
- {
- LV_COLUMNW column;
- column.iSubItem = 2;
- column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
- column.fmt = LVCFMT_RIGHT;
- column.cx = 100;
- const UString s = LangString(IDS_PROP_SIZE);
- column.pszText = (wchar_t *)(const wchar_t *)s;
- _list.InsertColumn(2, &column);
- }
-
- _list.InsertItem(0, L"12345678901234567"
- #ifndef UNDER_CE
- L"1234567890"
- #endif
- );
- _list.SetSubItem(0, 1, L"2009-09-09"
- #ifndef UNDER_CE
- L" 09:09"
- #endif
- );
- _list.SetSubItem(0, 2, L"9999 MB");
- for (int i = 0; i < 3; i++)
- _list.SetColumnWidthAuto(i);
- _list.DeleteAllItems();
-
- _ascending = true;
- _sortIndex = 0;
-
- NormalizeSize();
-
- _topDirPrefix.Empty();
- {
- int rootSize = GetRootPrefixSize(FilePath);
- #if defined(_WIN32) && !defined(UNDER_CE)
- // We can go up from root folder to drives list
- if (IsDrivePath(FilePath))
- rootSize = 0;
- else if (IsSuperPath(FilePath))
- {
- if (IsDrivePath(FilePath.Ptr(kSuperPathPrefixSize)))
- rootSize = kSuperPathPrefixSize;
- }
- #endif
- _topDirPrefix.SetFrom(FilePath, rootSize);
- }
-
- UString name;
- if (!GetParentPath(FilePath, DirPrefix, name))
- DirPrefix = _topDirPrefix;
-
- for (;;)
- {
- UString baseFolder = DirPrefix;
- if (Reload(baseFolder, name) == S_OK)
- break;
- name.Empty();
- if (DirPrefix.IsEmpty())
- break;
- UString parent, name2;
- GetParentPath(DirPrefix, parent, name2);
- DirPrefix = parent;
- }
-
- if (name.IsEmpty())
- name = FilePath;
- if (FolderMode)
- NormalizeDirPathPrefix(name);
- _pathEdit.SetText(name);
-
- #ifndef UNDER_CE
- /* If we clear UISF_HIDEFOCUS, the focus rectangle in ListView will be visible,
- even if we use mouse for pressing the button to open this dialog. */
- PostMsg(MY__WM_UPDATEUISTATE, MAKEWPARAM(MY__UIS_CLEAR, MY__UISF_HIDEFOCUS));
- #endif
-
- return CModalDialog::OnInit();
-}
-
-bool CBrowseDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
-{
- int mx, my;
- {
- RECT r;
- GetClientRectOfItem(IDB_BROWSE_PARENT, r);
- mx = r.left;
- my = r.top;
- }
- InvalidateRect(NULL);
-
- int xLim = xSize - mx;
- {
- RECT r;
- GetClientRectOfItem(IDT_BROWSE_FOLDER, r);
- MoveItem(IDT_BROWSE_FOLDER, r.left, r.top, xLim - r.left, RECT_SIZE_Y(r));
- }
-
- int bx1, bx2, by;
- GetItemSizes(IDCANCEL, bx1, by);
- GetItemSizes(IDOK, bx2, by);
- int y = ySize - my - by;
- int x = xLim - bx1;
- MoveItem(IDCANCEL, x, y, bx1, by);
- MoveItem(IDOK, x - mx - bx2, y, bx2, by);
-
- // Y_Size of ComboBox is tricky. So we use Y_Size of _pathEdit instead
-
- int yPathSize;
- {
- RECT r;
- GetClientRectOfItem(IDE_BROWSE_PATH, r);
- yPathSize = RECT_SIZE_Y(r);
- _pathEdit.Move(r.left, y - my - yPathSize - my - yPathSize, xLim - r.left, yPathSize);
- }
-
- {
- RECT r;
- GetClientRectOfItem(IDC_BROWSE_FILTER, r);
- _filterCombo.Move(r.left, y - my - yPathSize, xLim - r.left, RECT_SIZE_Y(r));
- }
-
- {
- RECT r;
- GetClientRectOfItem(IDL_BROWSE, r);
- _list.Move(r.left, r.top, xLim - r.left, y - my - yPathSize - my - yPathSize - my - r.top);
- }
-
- return false;
-}
-
-bool CBrowseDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- if (message == k_Message_RefreshPathEdit)
- {
- SetPathEditText();
- return true;
- }
- return CModalDialog::OnMessage(message, wParam, lParam);
-}
-
-bool CBrowseDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
-{
- if (header->hwndFrom != _list)
- return false;
- switch (header->code)
- {
- case LVN_ITEMACTIVATE:
- if (g_LVN_ITEMACTIVATE_Support)
- OnItemEnter();
- break;
- case NM_DBLCLK:
- case NM_RETURN: // probabably it's unused
- if (!g_LVN_ITEMACTIVATE_Support)
- OnItemEnter();
- break;
- case LVN_COLUMNCLICK:
- {
- int index = LPNMLISTVIEW(header)->iSubItem;
- if (index == _sortIndex)
- _ascending = !_ascending;
- else
- {
- _ascending = (index == 0);
- _sortIndex = index;
- }
- Reload();
- return false;
- }
- case LVN_KEYDOWN:
- {
- bool boolResult = OnKeyDown(LPNMLVKEYDOWN(header));
- Post_RefreshPathEdit();
- return boolResult;
- }
- case NM_RCLICK:
- case NM_CLICK:
- case LVN_BEGINDRAG:
- Post_RefreshPathEdit();
- break;
- }
- return false;
-}
-
-bool CBrowseDialog::OnKeyDown(LPNMLVKEYDOWN keyDownInfo)
-{
- bool ctrl = IsKeyDown(VK_CONTROL);
-
- switch (keyDownInfo->wVKey)
- {
- case VK_BACK:
- OpenParentFolder();
- return true;
- case 'R':
- if (ctrl)
- {
- Reload();
- return true;
- }
- return false;
- case VK_F7:
- OnCreateDir();
- return true;
- }
- return false;
-}
-
-bool CBrowseDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- switch (buttonID)
- {
- case IDB_BROWSE_PARENT: OpenParentFolder(); break;
- case IDB_BROWSE_CREATE_DIR: OnCreateDir(); break;
- default: return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
- }
- _list.SetFocus();
- return true;
-}
-
-void CBrowseDialog::OnOK()
-{
- /* When we press "Enter" in listview, Windows sends message to first Button.
- We check that message was from ListView; */
- if (GetFocus() == _list)
- {
- OnItemEnter();
- return;
- }
- FinishOnOK();
-}
-
-
-bool CBrowseDialog::GetParentPath(const UString &path, UString &parentPrefix, UString &name)
-{
- parentPrefix.Empty();
- name.Empty();
- if (path.IsEmpty())
- return false;
- if (_topDirPrefix == path)
- return false;
- UString s = path;
- if (IS_PATH_SEPAR(s.Back()))
- s.DeleteBack();
- if (s.IsEmpty())
- return false;
- if (IS_PATH_SEPAR(s.Back()))
- return false;
- int pos = s.ReverseFind_PathSepar();
- parentPrefix.SetFrom(s, pos + 1);
- name = s.Ptr(pos + 1);
- return true;
-}
-
-int CBrowseDialog::CompareItems(LPARAM lParam1, LPARAM lParam2)
-{
- if (lParam1 == kParentIndex) return -1;
- if (lParam2 == kParentIndex) return 1;
- const CFileInfo &f1 = _files[(int)lParam1];
- const CFileInfo &f2 = _files[(int)lParam2];
-
- bool isDir1 = f1.IsDir();
- bool isDir2 = f2.IsDir();
- if (isDir1 && !isDir2) return -1;
- if (isDir2 && !isDir1) return 1;
-
- int res = 0;
- switch (_sortIndex)
- {
- case 0: res = CompareFileNames(fs2us(f1.Name), fs2us(f2.Name)); break;
- case 1: res = CompareFileTime(&f1.MTime, &f2.MTime); break;
- case 2: res = MyCompare(f1.Size, f2.Size); break;
- }
- return _ascending ? res: -res;
-}
-
-static int CALLBACK CompareItems2(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
-{
- return ((CBrowseDialog *)lpData)->CompareItems(lParam1, lParam2);
-}
-
-static void ConvertSizeToString(UInt64 v, wchar_t *s)
-{
- Byte c = 0;
- if (v >= ((UInt64)10000 << 20)) { v >>= 30; c = 'G'; }
- else if (v >= ((UInt64)10000 << 10)) { v >>= 20; c = 'M'; }
- else if (v >= ((UInt64)10000 << 0)) { v >>= 10; c = 'K'; }
- ConvertUInt64ToString(v, s);
- if (c != 0)
- {
- s += MyStringLen(s);
- *s++ = ' ';
- *s++ = c;
- *s++ = 0;
- }
-}
-
-// Reload changes DirPrefix. Don't send DirPrefix in pathPrefix parameter
-
-HRESULT CBrowseDialog::Reload(const UString &pathPrefix, const UString &selectedName)
-{
- CObjectVector<CFileInfo> files;
-
- #ifndef UNDER_CE
- bool isDrive = false;
- if (pathPrefix.IsEmpty() || pathPrefix.IsEqualTo(kSuperPathPrefix))
- {
- isDrive = true;
- FStringVector drives;
- if (!MyGetLogicalDriveStrings(drives))
- return GetNormalizedError();
- FOR_VECTOR (i, drives)
- {
- FString d = drives[i];
- if (d.Len() < 3 || d.Back() != '\\')
- return E_FAIL;
- d.DeleteBack();
- CFileInfo &fi = files.AddNew();
- fi.SetAsDir();
- fi.Name = d;
- }
- }
- else
- #endif
- {
- CEnumerator enumerator;
- enumerator.SetDirPrefix(us2fs(pathPrefix));
- for (;;)
- {
- bool found;
- CFileInfo fi;
- if (!enumerator.Next(fi, found))
- return GetNormalizedError();
- if (!found)
- break;
- if (!fi.IsDir())
- {
- if (FolderMode)
- continue;
- if (!ShowAllFiles)
- {
- unsigned i;
- for (i = 0; i < Filters.Size(); i++)
- if (DoesWildcardMatchName(Filters[i], fs2us(fi.Name)))
- break;
- if (i == Filters.Size())
- continue;
- }
- }
- files.Add(fi);
- }
- }
-
- DirPrefix = pathPrefix;
-
- _files = files;
-
- SetItemText(IDT_BROWSE_FOLDER, DirPrefix);
-
- _list.SetRedraw(false);
- _list.DeleteAllItems();
-
- LVITEMW item;
-
- int index = 0;
- int cursorIndex = -1;
-
- #ifndef _SFX
- if (_showDots && _topDirPrefix != DirPrefix)
- {
- item.iItem = index;
- const UString itemName ("..");
- if (selectedName.IsEmpty())
- cursorIndex = index;
- item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
- int subItem = 0;
- item.iSubItem = subItem++;
- item.lParam = kParentIndex;
- item.pszText = (wchar_t *)(const wchar_t *)itemName;
- item.iImage = _extToIconMap.GetIconIndex(FILE_ATTRIBUTE_DIRECTORY, DirPrefix);
- if (item.iImage < 0)
- item.iImage = 0;
- _list.InsertItem(&item);
- _list.SetSubItem(index, subItem++, L"");
- _list.SetSubItem(index, subItem++, L"");
- index++;
- }
- #endif
-
- for (unsigned i = 0; i < _files.Size(); i++, index++)
- {
- item.iItem = index;
- const CFileInfo &fi = _files[i];
- const UString name = fs2us(fi.Name);
- if (!selectedName.IsEmpty() && CompareFileNames(name, selectedName) == 0)
- cursorIndex = index;
- item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
- int subItem = 0;
- item.iSubItem = subItem++;
- item.lParam = i;
- item.pszText = (wchar_t *)(const wchar_t *)name;
-
- const UString fullPath = DirPrefix + name;
- #ifndef UNDER_CE
- if (isDrive)
- {
- if (GetRealIconIndex(fi.Name + FCHAR_PATH_SEPARATOR, FILE_ATTRIBUTE_DIRECTORY, item.iImage) == 0)
- item.iImage = 0;
- }
- else
- #endif
- item.iImage = _extToIconMap.GetIconIndex(fi.Attrib, fullPath);
- if (item.iImage < 0)
- item.iImage = 0;
- _list.InsertItem(&item);
- wchar_t s[32];
- {
- s[0] = 0;
- ConvertUtcFileTimeToString(fi.MTime, s,
- #ifndef UNDER_CE
- kTimestampPrintLevel_MIN
- #else
- kTimestampPrintLevel_DAY
- #endif
- );
- _list.SetSubItem(index, subItem++, s);
- }
- {
- s[0] = 0;
- if (!fi.IsDir())
- ConvertSizeToString(fi.Size, s);
- _list.SetSubItem(index, subItem++, s);
- }
- }
-
- if (_list.GetItemCount() > 0 && cursorIndex >= 0)
- _list.SetItemState_FocusedSelected(cursorIndex);
- _list.SortItems(CompareItems2, (LPARAM)this);
- if (_list.GetItemCount() > 0 && cursorIndex < 0)
- _list.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);
- _list.EnsureVisible(_list.GetFocusedItem(), false);
- _list.SetRedraw(true);
- _list.InvalidateRect(NULL, true);
- return S_OK;
-}
-
-HRESULT CBrowseDialog::Reload()
-{
- UString selected;
- int index = _list.GetNextSelectedItem(-1);
- if (index >= 0)
- {
- int fileIndex = GetRealItemIndex(index);
- if (fileIndex != kParentIndex)
- selected = fs2us(_files[fileIndex].Name);
- }
- UString dirPathTemp = DirPrefix;
- return Reload(dirPathTemp, selected);
-}
-
-void CBrowseDialog::OpenParentFolder()
-{
- UString parent, selected;
- if (GetParentPath(DirPrefix, parent, selected))
- {
- Reload(parent, selected);
- SetPathEditText();
- }
-}
-
-void CBrowseDialog::SetPathEditText()
-{
- int index = _list.GetNextSelectedItem(-1);
- if (index < 0)
- {
- if (FolderMode)
- _pathEdit.SetText(DirPrefix);
- return;
- }
- int fileIndex = GetRealItemIndex(index);
- if (fileIndex == kParentIndex)
- {
- if (FolderMode)
- _pathEdit.SetText(L".." WSTRING_PATH_SEPARATOR);
- return;
- }
- const CFileInfo &file = _files[fileIndex];
- if (file.IsDir())
- {
- if (!FolderMode)
- return;
- _pathEdit.SetText(fs2us(file.Name) + WCHAR_PATH_SEPARATOR);
- }
- else
- _pathEdit.SetText(fs2us(file.Name));
-}
-
-void CBrowseDialog::OnCreateDir()
-{
- UString name;
- {
- UString enteredName;
- Dlg_CreateFolder((HWND)*this, enteredName);
- if (enteredName.IsEmpty())
- return;
- if (!CorrectFsPath(DirPrefix, enteredName, name))
- {
- MessageBox_HResError((HWND)*this, ERROR_INVALID_NAME, name);
- return;
- }
- }
- if (name.IsEmpty())
- return;
-
- FString destPath;
- if (GetFullPath(us2fs(DirPrefix), us2fs(name), destPath))
- {
- if (!NDir::CreateComplexDir(destPath))
- {
- MessageBox_HResError((HWND)*this, GetNormalizedError(), fs2us(destPath));
- }
- else
- {
- UString tempPath = DirPrefix;
- Reload(tempPath, name);
- SetPathEditText();
- }
- _list.SetFocus();
- }
-}
-
-void CBrowseDialog::OnItemEnter()
-{
- int index = _list.GetNextSelectedItem(-1);
- if (index < 0)
- return;
- int fileIndex = GetRealItemIndex(index);
- if (fileIndex == kParentIndex)
- OpenParentFolder();
- else
- {
- const CFileInfo &file = _files[fileIndex];
- if (!file.IsDir())
- {
- if (!FolderMode)
- FinishOnOK();
- /*
- MessageBox_Error_Global(*this, FolderMode ?
- L"You must select some folder":
- L"You must select some file");
- */
- return;
- }
- UString s = DirPrefix;
- s += fs2us(file.Name);
- s.Add_PathSepar();
- HRESULT res = Reload(s, UString());
- if (res != S_OK)
- MessageBox_HResError(*this, res, s);
- SetPathEditText();
- }
-}
-
-void CBrowseDialog::FinishOnOK()
-{
- UString s;
- _pathEdit.GetText(s);
- FString destPath;
- if (!GetFullPath(us2fs(DirPrefix), us2fs(s), destPath))
- {
- MessageBox_HResError((HWND)*this, ERROR_INVALID_NAME, s);
- return;
- }
- FilePath = fs2us(destPath);
- if (FolderMode)
- NormalizeDirPathPrefix(FilePath);
- End(IDOK);
-}
-
-#endif
-
-bool MyBrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR path, UString &resultPath)
-{
- resultPath.Empty();
-
- #ifndef UNDER_CE
-
- #ifdef USE_MY_BROWSE_DIALOG
- if (!IsSuperOrDevicePath(path))
- #endif
- return NShell::BrowseForFolder(owner, title, path, resultPath);
-
- #endif
-
- #ifdef USE_MY_BROWSE_DIALOG
-
- CBrowseDialog dialog;
- dialog.FolderMode = true;
- if (title)
- dialog.Title = title;
- if (path)
- dialog.FilePath = path;
- if (dialog.Create(owner) != IDOK)
- return false;
- resultPath = dialog.FilePath;
- #endif
-
- return true;
-}
-
-bool MyBrowseForFile(HWND owner, LPCWSTR title, LPCWSTR path,
- LPCWSTR filterDescription, LPCWSTR filter, UString &resultPath)
-{
- resultPath.Empty();
-
- #ifndef UNDER_CE
-
- #ifdef USE_MY_BROWSE_DIALOG
- if (!IsSuperOrDevicePath(path))
- #endif
- {
- if (MyGetOpenFileName(owner, title, NULL, path, filterDescription, filter, resultPath))
- return true;
- #ifdef UNDER_CE
- return false;
- #else
- // maybe we must use GetLastError in WinCE.
- DWORD errorCode = CommDlgExtendedError();
- const char *errorMessage = NULL;
- switch (errorCode)
- {
- case 0: return false; // cancel or close obn dialog
- case FNERR_INVALIDFILENAME: errorMessage = "Invalid File Name"; break;
- default: errorMessage = "Open Dialog Error";
- }
- if (!errorMessage)
- return false;
- {
- UString s (errorMessage);
- s.Add_LF();
- s += path;
- MessageBox_Error_Global(owner, s);
- }
- #endif
- }
-
- #endif
-
- #ifdef USE_MY_BROWSE_DIALOG
- CBrowseDialog dialog;
- if (title)
- dialog.Title = title;
- if (path)
- dialog.FilePath = path;
- dialog.FolderMode = false;
- if (filter)
- dialog.SetFilter(filter);
- if (filterDescription)
- dialog.FilterDescription = filterDescription;
- if (dialog.Create(owner) != IDOK)
- return false;
- resultPath = dialog.FilePath;
- #endif
-
- return true;
-}
-
-
-#ifdef _WIN32
-
-static void RemoveDotsAndSpaces(UString &path)
-{
- while (!path.IsEmpty())
- {
- wchar_t c = path.Back();
- if (c != ' ' && c != '.')
- return;
- path.DeleteBack();
- }
-}
-
-
-bool CorrectFsPath(const UString &relBase, const UString &path2, UString &result)
-{
- result.Empty();
-
- UString path = path2;
- path.Replace(L'/', WCHAR_PATH_SEPARATOR);
- unsigned start = 0;
- UString base;
-
- if (IsAbsolutePath(path))
- {
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (IsSuperOrDevicePath(path))
- {
- result = path;
- return true;
- }
- #endif
- int pos = GetRootPrefixSize(path);
- if (pos > 0)
- start = pos;
- }
- else
- {
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (IsSuperOrDevicePath(relBase))
- {
- result = path;
- return true;
- }
- #endif
- base = relBase;
- }
-
- /* We can't use backward, since we must change only disk paths */
- /*
- for (;;)
- {
- if (path.Len() <= start)
- break;
- if (DoesFileOrDirExist(us2fs(path)))
- break;
- if (path.Back() == WCHAR_PATH_SEPARATOR)
- {
- path.DeleteBack();
- result.Insert(0, WCHAR_PATH_SEPARATOR);;
- }
- int pos = path.ReverseFind(WCHAR_PATH_SEPARATOR) + 1;
- UString cur = path.Ptr(pos);
- RemoveDotsAndSpaces(cur);
- result.Insert(0, cur);
- path.DeleteFrom(pos);
- }
- result.Insert(0, path);
- return true;
- */
-
- result += path.Left(start);
- bool checkExist = true;
- UString cur;
-
- for (;;)
- {
- if (start == path.Len())
- break;
- int slashPos = path.Find(WCHAR_PATH_SEPARATOR, start);
- cur.SetFrom(path.Ptr(start), (slashPos < 0 ? path.Len() : slashPos) - start);
- if (checkExist)
- {
- CFileInfo fi;
- if (fi.Find(us2fs(base + result + cur)))
- {
- if (!fi.IsDir())
- {
- result = path;
- break;
- }
- }
- else
- checkExist = false;
- }
- if (!checkExist)
- RemoveDotsAndSpaces(cur);
- result += cur;
- if (slashPos < 0)
- break;
- result.Add_PathSepar();
- start = slashPos + 1;
- }
-
- return true;
-}
-
-#else
-
-bool CorrectFsPath(const UString & /* relBase */, const UString &path, UString &result)
-{
- result = path;
- return true;
-}
-
-#endif
-
-bool Dlg_CreateFolder(HWND wnd, UString &destName)
-{
- destName.Empty();
- CComboDialog dlg;
- LangString(IDS_CREATE_FOLDER, dlg.Title);
- LangString(IDS_CREATE_FOLDER_NAME, dlg.Static);
- LangString(IDS_CREATE_FOLDER_DEFAULT_NAME, dlg.Value);
- if (dlg.Create(wnd) != IDOK)
- return false;
- destName = dlg.Value;
- return true;
-}
+// BrowseDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include "../../../Common/IntToString.h"
+
+#ifndef UNDER_CE
+#include "../../../Windows/CommonDialog.h"
+#include "../../../Windows/Shell.h"
+#endif
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileFind.h"
+
+#ifdef UNDER_CE
+#include <commdlg.h>
+#endif
+
+#include "BrowseDialog.h"
+
+#define USE_MY_BROWSE_DIALOG
+
+#ifdef USE_MY_BROWSE_DIALOG
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/Edit.h"
+#include "../../../Windows/Control/ListView.h"
+
+#include "BrowseDialogRes.h"
+#include "PropertyNameRes.h"
+#include "SysIconUtils.h"
+
+#ifndef Z7_SFX
+#include "RegistryUtils.h"
+#endif
+
+#endif // USE_MY_BROWSE_DIALOG
+
+#include "ComboDialog.h"
+#include "LangUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+using namespace NFind;
+
+static void MessageBox_Error_Global(HWND wnd, const wchar_t *message)
+{
+ ::MessageBoxW(wnd, message, L"7-Zip", MB_ICONERROR);
+}
+
+#ifdef USE_MY_BROWSE_DIALOG
+
+extern bool g_LVN_ITEMACTIVATE_Support;
+
+static const int kParentIndex = -1;
+static const UINT k_Message_RefreshPathEdit = WM_APP + 1;
+
+extern UString HResultToMessage(HRESULT errorCode);
+
+static void MessageBox_HResError(HWND wnd, HRESULT errorCode, const wchar_t *name)
+{
+ UString s = HResultToMessage(errorCode);
+ if (name)
+ {
+ s.Add_LF();
+ s += name;
+ }
+ MessageBox_Error_Global(wnd, s);
+}
+
+class CBrowseDialog: public NControl::CModalDialog
+{
+ NControl::CListView _list;
+ NControl::CEdit _pathEdit;
+ NControl::CComboBox _filterCombo;
+
+ CObjectVector<CFileInfo> _files;
+
+ CExtToIconMap _extToIconMap;
+ int _sortIndex;
+ bool _ascending;
+ #ifndef Z7_SFX
+ bool _showDots;
+ #endif
+ UString _topDirPrefix; // we don't open parent of that folder
+ UString DirPrefix;
+
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+ virtual bool OnNotify(UINT controlID, LPNMHDR header) Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual void OnOK() Z7_override;
+
+ bool OnKeyDown(LPNMLVKEYDOWN keyDownInfo);
+
+ void Post_RefreshPathEdit() { PostMsg(k_Message_RefreshPathEdit); }
+
+ bool GetParentPath(const UString &path, UString &parentPrefix, UString &name);
+ // Reload changes DirPrefix. Don't send DirPrefix in pathPrefix parameter
+ HRESULT Reload(const UString &pathPrefix, const UString &selectedName);
+ HRESULT Reload();
+
+ void OpenParentFolder();
+ void SetPathEditText();
+ void OnCreateDir();
+ void OnItemEnter();
+ void FinishOnOK();
+
+ int GetRealItemIndex(int indexInListView) const
+ {
+ LPARAM param;
+ if (!_list.GetItemParam((unsigned)indexInListView, param))
+ return (int)-1;
+ return (int)param;
+ }
+
+public:
+
+ bool SaveMode;
+ bool FolderMode;
+ int FilterIndex; // [in / out]
+ CObjectVector<CBrowseFilterInfo> Filters;
+
+ UString FilePath; // [in / out]
+ UString Title;
+
+ CBrowseDialog():
+ #ifndef Z7_SFX
+ _showDots(false),
+ #endif
+ SaveMode(false)
+ , FolderMode(false)
+ , FilterIndex(-1)
+ {}
+ INT_PTR Create(HWND parent = NULL) { return CModalDialog::Create(IDD_BROWSE, parent); }
+ int CompareItems(LPARAM lParam1, LPARAM lParam2) const;
+};
+
+
+bool CBrowseDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, NULL, 0);
+ #endif
+ if (!Title.IsEmpty())
+ SetText(Title);
+ _list.Attach(GetItem(IDL_BROWSE));
+ _filterCombo.Attach(GetItem(IDC_BROWSE_FILTER));
+ _pathEdit.Attach(GetItem(IDE_BROWSE_PATH));
+
+ #ifndef UNDER_CE
+ _list.SetUnicodeFormat();
+ #endif
+
+ #ifndef Z7_SFX
+ CFmSettings st;
+ st.Load();
+ if (st.SingleClick)
+ _list.SetExtendedListViewStyle(LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT);
+ _showDots = st.ShowDots;
+ #endif
+
+ {
+ /*
+ Filters.Clear(); // for debug
+ if (Filters.IsEmpty() && !FolderMode)
+ {
+ CBrowseFilterInfo &f = Filters.AddNew();
+ const UString mask("*.*");
+ f.Masks.Add(mask);
+ // f.Description = "(";
+ f.Description += mask;
+ // f.Description += ")";
+ }
+ */
+
+ FOR_VECTOR (i, Filters)
+ {
+ _filterCombo.AddString(Filters[i].Description);
+ }
+
+ if (Filters.Size() <= 1)
+ {
+ if (FolderMode)
+ HideItem(IDC_BROWSE_FILTER);
+ else
+ EnableItem(IDC_BROWSE_FILTER, false);
+ }
+
+ if (/* FilterIndex >= 0 && */ (unsigned)FilterIndex < Filters.Size())
+ _filterCombo.SetCurSel(FilterIndex);
+ }
+
+ _list.SetImageList(GetSysImageList(true), LVSIL_SMALL);
+ _list.SetImageList(GetSysImageList(false), LVSIL_NORMAL);
+
+ _list.InsertColumn(0, LangString(IDS_PROP_NAME), 100);
+ _list.InsertColumn(1, LangString(IDS_PROP_MTIME), 100);
+ {
+ LV_COLUMNW column;
+ column.iSubItem = 2;
+ column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
+ column.fmt = LVCFMT_RIGHT;
+ column.cx = 100;
+ const UString s = LangString(IDS_PROP_SIZE);
+ column.pszText = s.Ptr_non_const();
+ _list.InsertColumn(2, &column);
+ }
+
+ _list.InsertItem(0, L"12345678901234567"
+ #ifndef UNDER_CE
+ L"1234567890"
+ #endif
+ );
+ _list.SetSubItem(0, 1, L"2009-09-09"
+ #ifndef UNDER_CE
+ L" 09:09"
+ #endif
+ );
+ _list.SetSubItem(0, 2, L"9999 MB");
+ for (int i = 0; i < 3; i++)
+ _list.SetColumnWidthAuto(i);
+ _list.DeleteAllItems();
+
+ _ascending = true;
+ _sortIndex = 0;
+
+ NormalizeSize();
+
+ _topDirPrefix.Empty();
+ {
+ unsigned rootSize = GetRootPrefixSize(FilePath);
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // We can go up from root folder to drives list
+ if (IsDrivePath(FilePath))
+ rootSize = 0;
+ else if (IsSuperPath(FilePath))
+ {
+ if (IsDrivePath(FilePath.Ptr(kSuperPathPrefixSize)))
+ rootSize = kSuperPathPrefixSize;
+ }
+ #endif
+ _topDirPrefix.SetFrom(FilePath, rootSize);
+ }
+
+ UString name;
+ if (!GetParentPath(FilePath, DirPrefix, name))
+ DirPrefix = _topDirPrefix;
+
+ for (;;)
+ {
+ UString baseFolder = DirPrefix;
+ if (Reload(baseFolder, name) == S_OK)
+ break;
+ name.Empty();
+ if (DirPrefix.IsEmpty())
+ break;
+ UString parent, name2;
+ GetParentPath(DirPrefix, parent, name2);
+ DirPrefix = parent;
+ }
+
+ if (name.IsEmpty())
+ name = FilePath;
+ if (FolderMode)
+ NormalizeDirPathPrefix(name);
+ _pathEdit.SetText(name);
+
+ #ifndef UNDER_CE
+ /* If we clear UISF_HIDEFOCUS, the focus rectangle in ListView will be visible,
+ even if we use mouse for pressing the button to open this dialog. */
+ PostMsg(Z7_WIN_WM_UPDATEUISTATE, MAKEWPARAM(Z7_WIN_UIS_CLEAR, Z7_WIN_UISF_HIDEFOCUS));
+ #endif
+
+ return CModalDialog::OnInit();
+}
+
+bool CBrowseDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ {
+ RECT r;
+ GetClientRectOfItem(IDB_BROWSE_PARENT, r);
+ mx = r.left;
+ my = r.top;
+ }
+ InvalidateRect(NULL);
+
+ int xLim = xSize - mx;
+ {
+ RECT r;
+ GetClientRectOfItem(IDT_BROWSE_FOLDER, r);
+ MoveItem(IDT_BROWSE_FOLDER, r.left, r.top, xLim - r.left, RECT_SIZE_Y(r));
+ }
+
+ int bx1, bx2, by;
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDOK, bx2, by);
+ int y = ySize - my - by;
+ int x = xLim - bx1;
+ MoveItem(IDCANCEL, x, y, bx1, by);
+ MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+
+ // Y_Size of ComboBox is tricky. So we use Y_Size of _pathEdit instead
+
+ int yPathSize;
+ {
+ RECT r;
+ GetClientRectOfItem(IDE_BROWSE_PATH, r);
+ yPathSize = RECT_SIZE_Y(r);
+ _pathEdit.Move(r.left, y - my - yPathSize - my - yPathSize, xLim - r.left, yPathSize);
+ }
+
+ {
+ RECT r;
+ GetClientRectOfItem(IDC_BROWSE_FILTER, r);
+ _filterCombo.Move(r.left, y - my - yPathSize, xLim - r.left, RECT_SIZE_Y(r));
+ }
+
+ {
+ RECT r;
+ GetClientRectOfItem(IDL_BROWSE, r);
+ _list.Move(r.left, r.top, xLim - r.left, y - my - yPathSize - my - yPathSize - my - r.top);
+ }
+
+ return false;
+}
+
+bool CBrowseDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ if (message == k_Message_RefreshPathEdit)
+ {
+ SetPathEditText();
+ return true;
+ }
+ return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+
+bool CBrowseDialog::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+ if (code == CBN_SELCHANGE)
+ {
+ switch (itemID)
+ {
+ case IDC_BROWSE_FILTER:
+ {
+ Reload();
+ return true;
+ }
+ }
+ }
+ return CModalDialog::OnCommand(code, itemID, lParam);
+}
+
+
+bool CBrowseDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
+{
+ if (header->hwndFrom != _list)
+ return false;
+ switch (header->code)
+ {
+ case LVN_ITEMACTIVATE:
+ if (g_LVN_ITEMACTIVATE_Support)
+ OnItemEnter();
+ break;
+ case NM_DBLCLK:
+ case NM_RETURN: // probabably it's unused
+ if (!g_LVN_ITEMACTIVATE_Support)
+ OnItemEnter();
+ break;
+ case LVN_COLUMNCLICK:
+ {
+ const int index = LPNMLISTVIEW(header)->iSubItem;
+ if (index == _sortIndex)
+ _ascending = !_ascending;
+ else
+ {
+ _ascending = (index == 0);
+ _sortIndex = index;
+ }
+ Reload();
+ return false;
+ }
+ case LVN_KEYDOWN:
+ {
+ bool boolResult = OnKeyDown(LPNMLVKEYDOWN(header));
+ Post_RefreshPathEdit();
+ return boolResult;
+ }
+ case NM_RCLICK:
+ case NM_CLICK:
+ case LVN_BEGINDRAG:
+ Post_RefreshPathEdit();
+ break;
+ }
+ return false;
+}
+
+bool CBrowseDialog::OnKeyDown(LPNMLVKEYDOWN keyDownInfo)
+{
+ const bool ctrl = IsKeyDown(VK_CONTROL);
+
+ switch (keyDownInfo->wVKey)
+ {
+ case VK_BACK:
+ OpenParentFolder();
+ return true;
+ case 'R':
+ if (ctrl)
+ {
+ Reload();
+ return true;
+ }
+ return false;
+ case VK_F7:
+ OnCreateDir();
+ return true;
+ }
+ return false;
+}
+
+
+bool CBrowseDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_BROWSE_PARENT: OpenParentFolder(); break;
+ case IDB_BROWSE_CREATE_DIR: OnCreateDir(); break;
+ default: return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+ }
+ _list.SetFocus();
+ return true;
+}
+
+void CBrowseDialog::OnOK()
+{
+ /* When we press "Enter" in listview, Windows sends message to first Button.
+ We check that message was from ListView; */
+ if (GetFocus() == _list)
+ {
+ OnItemEnter();
+ return;
+ }
+ FinishOnOK();
+}
+
+
+bool CBrowseDialog::GetParentPath(const UString &path, UString &parentPrefix, UString &name)
+{
+ parentPrefix.Empty();
+ name.Empty();
+ if (path.IsEmpty())
+ return false;
+ if (_topDirPrefix == path)
+ return false;
+ UString s = path;
+ if (IS_PATH_SEPAR(s.Back()))
+ s.DeleteBack();
+ if (s.IsEmpty())
+ return false;
+ if (IS_PATH_SEPAR(s.Back()))
+ return false;
+ const unsigned pos1 = (unsigned)(s.ReverseFind_PathSepar() + 1);
+ parentPrefix.SetFrom(s, pos1);
+ name = s.Ptr(pos1);
+ return true;
+}
+
+int CBrowseDialog::CompareItems(LPARAM lParam1, LPARAM lParam2) const
+{
+ if (lParam1 == kParentIndex) return -1;
+ if (lParam2 == kParentIndex) return 1;
+ const CFileInfo &f1 = _files[(int)lParam1];
+ const CFileInfo &f2 = _files[(int)lParam2];
+
+ const bool isDir1 = f1.IsDir();
+ const bool isDir2 = f2.IsDir();
+ if (isDir1 && !isDir2) return -1;
+ if (isDir2 && !isDir1) return 1;
+
+ int res = 0;
+ switch (_sortIndex)
+ {
+ case 0: res = CompareFileNames(fs2us(f1.Name), fs2us(f2.Name)); break;
+ case 1: res = CompareFileTime(&f1.MTime, &f2.MTime); break;
+ case 2: res = MyCompare(f1.Size, f2.Size); break;
+ }
+ return _ascending ? res: -res;
+}
+
+static int CALLBACK CompareItems2(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
+{
+ return ((CBrowseDialog *)lpData)->CompareItems(lParam1, lParam2);
+}
+
+static void ConvertSizeToString(UInt64 v, wchar_t *s)
+{
+ char c = 0;
+ if (v >= ((UInt64)10000 << 20)) { v >>= 30; c = 'G'; }
+ else if (v >= ((UInt64)10000 << 10)) { v >>= 20; c = 'M'; }
+ else if (v >= ((UInt64)10000 << 0)) { v >>= 10; c = 'K'; }
+ s = ConvertUInt64ToString(v, s);
+ if (c != 0)
+ {
+ *s++ = ' ';
+ *s++ = (wchar_t)c;
+ *s++ = 'B';
+ *s++ = 0;
+ }
+}
+
+// Reload changes DirPrefix. Don't send DirPrefix in pathPrefix parameter
+
+HRESULT CBrowseDialog::Reload(const UString &pathPrefix, const UString &selectedName)
+{
+ CObjectVector<CFileInfo> files;
+
+ #ifndef UNDER_CE
+ bool isDrive = false;
+ if (pathPrefix.IsEmpty() || pathPrefix.IsEqualTo(kSuperPathPrefix))
+ {
+ isDrive = true;
+ FStringVector drives;
+ if (!MyGetLogicalDriveStrings(drives))
+ return GetLastError_noZero_HRESULT();
+ FOR_VECTOR (i, drives)
+ {
+ const FString &d = drives[i];
+ if (d.Len() < 2 || d.Back() != '\\')
+ return E_FAIL;
+ CFileInfo &fi = files.AddNew();
+ fi.SetAsDir();
+ fi.Name = d;
+ fi.Name.DeleteBack();
+ }
+ }
+ else
+ #endif
+ {
+ const UStringVector *masks = NULL;
+ if (!Filters.IsEmpty() && _filterCombo.GetCount() > 0)
+ {
+ const int selected = _filterCombo.GetCurSel();
+ // GetItemData_of_CurSel(); // we don't use data field
+ if (/* selected >= 0 && */ (unsigned)selected < Filters.Size())
+ {
+ const UStringVector &m = Filters[selected].Masks;
+ if (m.Size() > 1 || (m.Size() == 1
+ && !m[0].IsEqualTo("*.*")
+ && !m[0].IsEqualTo("*")))
+ masks = &m;
+ }
+ }
+ CEnumerator enumerator;
+ enumerator.SetDirPrefix(us2fs(pathPrefix));
+ CFileInfo fi;
+ for (;;)
+ {
+ bool found;
+ if (!enumerator.Next(fi, found))
+ return GetLastError_noZero_HRESULT();
+ if (!found)
+ break;
+ if (!fi.IsDir())
+ {
+ if (FolderMode)
+ continue;
+ if (masks)
+ {
+ unsigned i;
+ const unsigned numMasks = masks->Size();
+ for (i = 0; i < numMasks; i++)
+ if (DoesWildcardMatchName((*masks)[i], fs2us(fi.Name)))
+ break;
+ if (i == numMasks)
+ continue;
+ }
+ }
+ files.Add(fi);
+ }
+ }
+
+ DirPrefix = pathPrefix;
+
+ _files = files;
+
+ SetItemText(IDT_BROWSE_FOLDER, DirPrefix);
+
+ _list.SetRedraw(false);
+ _list.DeleteAllItems();
+
+ LVITEMW item;
+
+ unsigned index = 0;
+ int cursorIndex = -1;
+
+ #ifndef Z7_SFX
+ if (_showDots && _topDirPrefix != DirPrefix)
+ {
+ item.iItem = (int)index;
+ const UString itemName ("..");
+ if (selectedName.IsEmpty())
+ cursorIndex = (int)index;
+ item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+ unsigned subItem = 0;
+ item.iSubItem = (int)(subItem++);
+ item.lParam = kParentIndex;
+ item.pszText = itemName.Ptr_non_const();
+ item.iImage = _extToIconMap.GetIconIndex(FILE_ATTRIBUTE_DIRECTORY, DirPrefix);
+ if (item.iImage < 0)
+ item.iImage = 0;
+ _list.InsertItem(&item);
+ _list.SetSubItem(index, subItem++, L"");
+ _list.SetSubItem(index, subItem++, L"");
+ index++;
+ }
+ #endif
+
+ for (unsigned i = 0; i < _files.Size(); i++, index++)
+ {
+ item.iItem = (int)index;
+ const CFileInfo &fi = _files[i];
+ const UString name = fs2us(fi.Name);
+ if (!selectedName.IsEmpty() && CompareFileNames(name, selectedName) == 0)
+ cursorIndex = (int)index;
+ item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+ unsigned subItem = 0;
+ item.iSubItem = (int)(subItem++);
+ item.lParam = (LPARAM)i;
+ item.pszText = name.Ptr_non_const();
+
+ const UString fullPath = DirPrefix + name;
+ #ifndef UNDER_CE
+ if (isDrive)
+ {
+ if (GetRealIconIndex(fi.Name + FCHAR_PATH_SEPARATOR, FILE_ATTRIBUTE_DIRECTORY, item.iImage) == 0)
+ item.iImage = 0;
+ }
+ else
+ #endif
+ item.iImage = _extToIconMap.GetIconIndex(fi.Attrib, fullPath);
+ if (item.iImage < 0)
+ item.iImage = 0;
+ _list.InsertItem(&item);
+ wchar_t s[32];
+ {
+ s[0] = 0;
+ ConvertUtcFileTimeToString(fi.MTime, s,
+ #ifndef UNDER_CE
+ kTimestampPrintLevel_MIN
+ #else
+ kTimestampPrintLevel_DAY
+ #endif
+ );
+ _list.SetSubItem(index, subItem++, s);
+ }
+ {
+ s[0] = 0;
+ if (!fi.IsDir())
+ ConvertSizeToString(fi.Size, s);
+ _list.SetSubItem(index, subItem++, s);
+ }
+ }
+
+ if (_list.GetItemCount() > 0 && cursorIndex >= 0)
+ _list.SetItemState_FocusedSelected(cursorIndex);
+ _list.SortItems(CompareItems2, (LPARAM)this);
+ if (_list.GetItemCount() > 0 && cursorIndex < 0)
+ _list.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);
+ _list.EnsureVisible(_list.GetFocusedItem(), false);
+ _list.SetRedraw(true);
+ _list.InvalidateRect(NULL, true);
+ return S_OK;
+}
+
+HRESULT CBrowseDialog::Reload()
+{
+ UString selected;
+ const int index = _list.GetNextSelectedItem(-1);
+ if (index >= 0)
+ {
+ const int fileIndex = GetRealItemIndex(index);
+ if (fileIndex != kParentIndex)
+ selected = fs2us(_files[fileIndex].Name);
+ }
+ const UString dirPathTemp = DirPrefix;
+ return Reload(dirPathTemp, selected);
+}
+
+void CBrowseDialog::OpenParentFolder()
+{
+ UString parent, selected;
+ if (GetParentPath(DirPrefix, parent, selected))
+ {
+ Reload(parent, selected);
+ SetPathEditText();
+ }
+}
+
+void CBrowseDialog::SetPathEditText()
+{
+ const int index = _list.GetNextSelectedItem(-1);
+ if (index < 0)
+ {
+ if (FolderMode)
+ _pathEdit.SetText(DirPrefix);
+ return;
+ }
+ const int fileIndex = GetRealItemIndex(index);
+ if (fileIndex == kParentIndex)
+ {
+ if (FolderMode)
+ _pathEdit.SetText(L".." WSTRING_PATH_SEPARATOR);
+ return;
+ }
+ const CFileInfo &file = _files[fileIndex];
+ if (file.IsDir())
+ {
+ if (!FolderMode)
+ return;
+ _pathEdit.SetText(fs2us(file.Name) + WCHAR_PATH_SEPARATOR);
+ }
+ else
+ _pathEdit.SetText(fs2us(file.Name));
+}
+
+void CBrowseDialog::OnCreateDir()
+{
+ UString name;
+ {
+ UString enteredName;
+ Dlg_CreateFolder((HWND)*this, enteredName);
+ if (enteredName.IsEmpty())
+ return;
+ if (!CorrectFsPath(DirPrefix, enteredName, name))
+ {
+ MessageBox_HResError((HWND)*this, ERROR_INVALID_NAME, name);
+ return;
+ }
+ }
+ if (name.IsEmpty())
+ return;
+
+ FString destPath;
+ if (GetFullPath(us2fs(DirPrefix), us2fs(name), destPath))
+ {
+ if (!NDir::CreateComplexDir(destPath))
+ {
+ MessageBox_HResError((HWND)*this, GetLastError_noZero_HRESULT(), fs2us(destPath));
+ }
+ else
+ {
+ UString tempPath = DirPrefix;
+ Reload(tempPath, name);
+ SetPathEditText();
+ }
+ _list.SetFocus();
+ }
+}
+
+void CBrowseDialog::OnItemEnter()
+{
+ const int index = _list.GetNextSelectedItem(-1);
+ if (index < 0)
+ return;
+ const int fileIndex = GetRealItemIndex(index);
+ if (fileIndex == kParentIndex)
+ OpenParentFolder();
+ else
+ {
+ const CFileInfo &file = _files[fileIndex];
+ if (!file.IsDir())
+ {
+ if (!FolderMode)
+ FinishOnOK();
+ /*
+ MessageBox_Error_Global(*this, FolderMode ?
+ L"You must select some folder":
+ L"You must select some file");
+ */
+ return;
+ }
+ UString s = DirPrefix;
+ s += fs2us(file.Name);
+ s.Add_PathSepar();
+ const HRESULT res = Reload(s, UString());
+ if (res != S_OK)
+ MessageBox_HResError(*this, res, s);
+ SetPathEditText();
+ }
+}
+
+void CBrowseDialog::FinishOnOK()
+{
+ UString s;
+ _pathEdit.GetText(s);
+ FString destPath;
+ if (!GetFullPath(us2fs(DirPrefix), us2fs(s), destPath))
+ {
+ MessageBox_HResError((HWND)*this, ERROR_INVALID_NAME, s);
+ return;
+ }
+ FilePath = fs2us(destPath);
+ if (FolderMode)
+ NormalizeDirPathPrefix(FilePath);
+ FilterIndex = _filterCombo.GetCurSel();
+ End(IDOK);
+}
+
+#endif // USE_MY_BROWSE_DIALOG
+
+
+
+bool MyBrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR path, UString &resultPath)
+{
+ resultPath.Empty();
+
+ #ifndef UNDER_CE
+
+#ifdef USE_MY_BROWSE_DIALOG
+ if (!IsSuperOrDevicePath(path))
+ if (MyStringLen(path) < MAX_PATH)
+#endif
+ return NShell::BrowseForFolder(owner, title, path, resultPath);
+
+ #endif // UNDER_CE
+
+ #ifdef USE_MY_BROWSE_DIALOG
+
+ CBrowseDialog dialog;
+ dialog.FolderMode = true;
+ if (title)
+ dialog.Title = title;
+ if (path)
+ dialog.FilePath = path;
+ if (dialog.Create(owner) != IDOK)
+ return false;
+ resultPath = dialog.FilePath;
+ return true;
+
+ #endif
+}
+
+
+// LPCWSTR filterDescription, LPCWSTR filter,
+
+bool CBrowseInfo::BrowseForFile(const CObjectVector<CBrowseFilterInfo> &filters)
+{
+#ifndef UNDER_CE
+#ifdef USE_MY_BROWSE_DIALOG
+ /* win10:
+ GetOpenFileName() for FilePath doesn't support super prefix "\\\\?\\"
+ GetOpenFileName() for FilePath doesn't support long path
+ */
+ if (!IsSuperOrDevicePath(FilePath))
+ // if (filters.Size() > 100) // for debug
+#endif
+ {
+ const UString filePath_Store = FilePath;
+ UString dirPrefix;
+ {
+ FString prefix, name;
+ if (NDir::GetFullPathAndSplit(us2fs(FilePath), prefix, name))
+ {
+ dirPrefix = fs2us(prefix);
+ FilePath = fs2us(name);
+ }
+ }
+ UStringVector filters2;
+ FOR_VECTOR (i, filters)
+ {
+ const CBrowseFilterInfo &fi = filters[i];
+ filters2.Add(fi.Description);
+ UString s;
+ FOR_VECTOR (k, fi.Masks)
+ {
+ if (k != 0)
+ s += ";";
+ s += fi.Masks[k];
+ }
+ filters2.Add(s);
+ }
+ if (CommonDlg_BrowseForFile(!dirPrefix.IsEmpty() ? dirPrefix.Ptr(): NULL, filters2))
+ return true;
+ FilePath = filePath_Store;
+
+ #ifdef UNDER_CE
+ return false;
+ #else
+ // maybe we must use GetLastError in WinCE.
+ const DWORD errorCode = CommDlgExtendedError();
+ #ifdef USE_MY_BROWSE_DIALOG
+ // FNERR_INVALIDFILENAME is expected error, if long path was used
+ if (errorCode != FNERR_INVALIDFILENAME
+ || FilePath.Len() < MAX_PATH)
+ #endif
+ {
+ if (errorCode == 0) // cancel or close on dialog
+ return false;
+ const char *message = NULL;
+ if (errorCode == FNERR_INVALIDFILENAME)
+ message = "Invalid file name";
+ UString s ("Open Dialog Error:");
+ s.Add_LF();
+ if (message)
+ s += message;
+ else
+ {
+ char temp[16];
+ ConvertUInt32ToHex8Digits(errorCode, temp);
+ s += "Error #";
+ s += temp;
+ }
+ s.Add_LF();
+ s += FilePath;
+ MessageBox_Error_Global(hwndOwner, s);
+ }
+ #endif // UNDER_CE
+ }
+
+#endif // UNDER_CE
+
+#ifdef USE_MY_BROWSE_DIALOG
+
+ CBrowseDialog dialog;
+
+ dialog.FolderMode = false;
+ dialog.SaveMode = SaveMode;
+ dialog.FilterIndex = FilterIndex;
+ dialog.Filters = filters;
+
+ if (lpstrTitle)
+ dialog.Title = lpstrTitle;
+ dialog.FilePath = FilePath;
+ if (dialog.Create(hwndOwner) != IDOK)
+ return false;
+ FilePath = dialog.FilePath;
+ FilterIndex = dialog.FilterIndex;
+#endif
+
+ return true;
+}
+
+
+#ifdef _WIN32
+
+static void RemoveDotsAndSpaces(UString &path)
+{
+ while (!path.IsEmpty())
+ {
+ wchar_t c = path.Back();
+ if (c != ' ' && c != '.')
+ return;
+ path.DeleteBack();
+ }
+}
+
+
+bool CorrectFsPath(const UString &relBase, const UString &path2, UString &result)
+{
+ result.Empty();
+
+ UString path = path2;
+ #ifdef _WIN32
+ path.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+ unsigned start = 0;
+ UString base;
+
+ if (IsAbsolutePath(path))
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (IsSuperOrDevicePath(path))
+ {
+ result = path;
+ return true;
+ }
+ #endif
+ start = GetRootPrefixSize(path);
+ }
+ else
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (IsSuperOrDevicePath(relBase))
+ {
+ result = path;
+ return true;
+ }
+ #endif
+ base = relBase;
+ }
+
+ /* We can't use backward, since we must change only disk paths */
+ /*
+ for (;;)
+ {
+ if (path.Len() <= start)
+ break;
+ if (DoesFileOrDirExist(us2fs(path)))
+ break;
+ if (path.Back() == WCHAR_PATH_SEPARATOR)
+ {
+ path.DeleteBack();
+ result.Insert(0, WCHAR_PATH_SEPARATOR);
+ }
+ int pos = path.ReverseFind(WCHAR_PATH_SEPARATOR) + 1;
+ UString cur = path.Ptr(pos);
+ RemoveDotsAndSpaces(cur);
+ result.Insert(0, cur);
+ path.DeleteFrom(pos);
+ }
+ result.Insert(0, path);
+ return true;
+ */
+
+ result += path.Left(start);
+ bool checkExist = true;
+ UString cur;
+
+ for (;;)
+ {
+ if (start == path.Len())
+ break;
+ const int slashPos = path.Find(WCHAR_PATH_SEPARATOR, start);
+ cur.SetFrom(path.Ptr(start), (slashPos < 0 ? path.Len() : (unsigned)slashPos) - start);
+ if (checkExist)
+ {
+ CFileInfo fi;
+ if (fi.Find(us2fs(base + result + cur)))
+ {
+ if (!fi.IsDir())
+ {
+ result = path;
+ break;
+ }
+ }
+ else
+ checkExist = false;
+ }
+ if (!checkExist)
+ RemoveDotsAndSpaces(cur);
+ result += cur;
+ if (slashPos < 0)
+ break;
+ start = (unsigned)(slashPos + 1);
+ result.Add_PathSepar();
+ }
+
+ return true;
+}
+
+#else
+
+bool CorrectFsPath(const UString & /* relBase */, const UString &path, UString &result)
+{
+ result = path;
+ return true;
+}
+
+#endif
+
+bool Dlg_CreateFolder(HWND wnd, UString &destName)
+{
+ destName.Empty();
+ CComboDialog dlg;
+ LangString(IDS_CREATE_FOLDER, dlg.Title);
+ LangString(IDS_CREATE_FOLDER_NAME, dlg.Static);
+ LangString(IDS_CREATE_FOLDER_DEFAULT_NAME, dlg.Value);
+ if (dlg.Create(wnd) != IDOK)
+ return false;
+ destName = dlg.Value;
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/BrowseDialog.h b/CPP/7zip/UI/FileManager/BrowseDialog.h
index be51085..2ad8d54 100644
--- a/CPP/7zip/UI/FileManager/BrowseDialog.h
+++ b/CPP/7zip/UI/FileManager/BrowseDialog.h
@@ -1,21 +1,32 @@
-// BrowseDialog.h
-
-#ifndef __BROWSE_DIALOG_H
-#define __BROWSE_DIALOG_H
-
-#include "../../../Common/MyString.h"
-
-bool MyBrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR path, UString &resultPath);
-bool MyBrowseForFile(HWND owner, LPCWSTR title, LPCWSTR path, LPCWSTR filterDescription, LPCWSTR filter, UString &resultPath);
-
-/* CorrectFsPath removes undesirable characters in names (dots and spaces at the end of file)
- But it doesn't change "bad" name in any of the following cases:
- - path is Super Path (with \\?\ prefix)
- - path is relative and relBase is Super Path
- - there is file or dir in filesystem with specified "bad" name */
-
-bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
-
-bool Dlg_CreateFolder(HWND wnd, UString &destName);
-
-#endif
+// BrowseDialog.h
+
+#ifndef ZIP7_INC_BROWSE_DIALOG_H
+#define ZIP7_INC_BROWSE_DIALOG_H
+
+#include "../../../Windows/CommonDialog.h"
+
+bool MyBrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR path, UString &resultPath);
+
+struct CBrowseFilterInfo
+{
+ UStringVector Masks;
+ UString Description;
+};
+
+struct CBrowseInfo: public NWindows::CCommonDialogInfo
+{
+ bool BrowseForFile(const CObjectVector<CBrowseFilterInfo> &filters);
+};
+
+
+/* CorrectFsPath removes undesirable characters in names (dots and spaces at the end of file)
+ But it doesn't change "bad" name in any of the following cases:
+ - path is Super Path (with \\?\ prefix)
+ - path is relative and relBase is Super Path
+ - there is file or dir in filesystem with specified "bad" name */
+
+bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
+
+bool Dlg_CreateFolder(HWND wnd, UString &destName);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/BrowseDialog.rc b/CPP/7zip/UI/FileManager/BrowseDialog.rc
new file mode 100644
index 0000000..04a6ad6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/BrowseDialog.rc
@@ -0,0 +1,25 @@
+#include "BrowseDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 256
+#define yc 320
+
+#define k_BROWSE_y_CtrlSize 14
+
+#define k_BROWSE_y_List 24
+
+IDD_BROWSE DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "7-Zip: Browse"
+{
+ EDITTEXT IDE_BROWSE_PATH, m, by - m - k_BROWSE_y_CtrlSize - k_BROWSE_y_CtrlSize - m, xc, k_BROWSE_y_CtrlSize, ES_AUTOHSCROLL
+ COMBOBOX IDC_BROWSE_FILTER, m, by - m - k_BROWSE_y_CtrlSize, xc, 30, MY_COMBO
+
+ PUSHBUTTON "OK", IDOK, bx2, by, bxs, bys
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+ PUSHBUTTON "<--", IDB_BROWSE_PARENT, m, m, 24, bys
+ PUSHBUTTON "+", IDB_BROWSE_CREATE_DIR, m + 32, m, 24, bys
+ LTEXT "", IDT_BROWSE_FOLDER, m + 64, m + 3, xc - 20, 8
+ CONTROL "List1", IDL_BROWSE, "SysListView32",
+ LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS | LVS_SINGLESEL | WS_BORDER | WS_TABSTOP,
+ m, m + k_BROWSE_y_List, xc, yc - bys - m - k_BROWSE_y_List - k_BROWSE_y_CtrlSize - m - k_BROWSE_y_CtrlSize - m
+}
diff --git a/CPP/7zip/UI/FileManager/BrowseDialogRes.h b/CPP/7zip/UI/FileManager/BrowseDialogRes.h
index f211b73..aff84ec 100644
--- a/CPP/7zip/UI/FileManager/BrowseDialogRes.h
+++ b/CPP/7zip/UI/FileManager/BrowseDialogRes.h
@@ -1,9 +1,9 @@
-#define IDD_BROWSE 95
-
-#define IDL_BROWSE 100
-#define IDT_BROWSE_FOLDER 101
-#define IDE_BROWSE_PATH 102
-#define IDC_BROWSE_FILTER 103
-
-#define IDB_BROWSE_PARENT 110
-#define IDB_BROWSE_CREATE_DIR 112
+#define IDD_BROWSE 95
+
+#define IDL_BROWSE 100
+#define IDT_BROWSE_FOLDER 101
+#define IDE_BROWSE_PATH 102
+#define IDC_BROWSE_FILTER 103
+
+#define IDB_BROWSE_PARENT 110
+#define IDB_BROWSE_CREATE_DIR 112
diff --git a/CPP/7zip/UI/FileManager/ClassDefs.cpp b/CPP/7zip/UI/FileManager/ClassDefs.cpp
new file mode 100644
index 0000000..5c26904
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ClassDefs.cpp
@@ -0,0 +1,12 @@
+// ClassDefs.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../Agent/Agent.h"
+
+#include "MyWindowsNew.h"
+#include "../Explorer/MyExplorerCommand.h"
diff --git a/CPP/7zip/UI/FileManager/ComboDialog.cpp b/CPP/7zip/UI/FileManager/ComboDialog.cpp
index e846c56..921972e 100644
--- a/CPP/7zip/UI/FileManager/ComboDialog.cpp
+++ b/CPP/7zip/UI/FileManager/ComboDialog.cpp
@@ -1,64 +1,64 @@
-// ComboDialog.cpp
-
-#include "StdAfx.h"
-#include "ComboDialog.h"
-
-#include "../../../Windows/Control/Static.h"
-
-#ifdef LANG
-#include "LangUtils.h"
-#endif
-
-using namespace NWindows;
-
-bool CComboDialog::OnInit()
-{
- #ifdef LANG
- LangSetDlgItems(*this, NULL, 0);
- #endif
- _comboBox.Attach(GetItem(IDC_COMBO));
-
- /*
- // why it doesn't work ?
- DWORD style = _comboBox.GetStyle();
- if (Sorted)
- style |= CBS_SORT;
- else
- style &= ~CBS_SORT;
- _comboBox.SetStyle(style);
- */
- SetText(Title);
-
- NControl::CStatic staticContol;
- staticContol.Attach(GetItem(IDT_COMBO));
- staticContol.SetText(Static);
- _comboBox.SetText(Value);
- FOR_VECTOR (i, Strings)
- _comboBox.AddString(Strings[i]);
- NormalizeSize();
- return CModalDialog::OnInit();
-}
-
-bool CComboDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
-{
- int mx, my;
- GetMargins(8, mx, my);
- int bx1, bx2, by;
- GetItemSizes(IDCANCEL, bx1, by);
- GetItemSizes(IDOK, bx2, by);
- int y = ySize - my - by;
- int x = xSize - mx - bx1;
-
- InvalidateRect(NULL);
-
- MoveItem(IDCANCEL, x, y, bx1, by);
- MoveItem(IDOK, x - mx - bx2, y, bx2, by);
- ChangeSubWindowSizeX(_comboBox, xSize - mx * 2);
- return false;
-}
-
-void CComboDialog::OnOK()
-{
- _comboBox.GetText(Value);
- CModalDialog::OnOK();
-}
+// ComboDialog.cpp
+
+#include "StdAfx.h"
+#include "ComboDialog.h"
+
+#include "../../../Windows/Control/Static.h"
+
+#ifdef Z7_LANG
+#include "LangUtils.h"
+#endif
+
+using namespace NWindows;
+
+bool CComboDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, NULL, 0);
+ #endif
+ _comboBox.Attach(GetItem(IDC_COMBO));
+
+ /*
+ // why it doesn't work ?
+ DWORD style = _comboBox.GetStyle();
+ if (Sorted)
+ style |= CBS_SORT;
+ else
+ style &= ~CBS_SORT;
+ _comboBox.SetStyle(style);
+ */
+ SetText(Title);
+
+ NControl::CStatic staticContol;
+ staticContol.Attach(GetItem(IDT_COMBO));
+ staticContol.SetText(Static);
+ _comboBox.SetText(Value);
+ FOR_VECTOR (i, Strings)
+ _comboBox.AddString(Strings[i]);
+ NormalizeSize();
+ return CModalDialog::OnInit();
+}
+
+bool CComboDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx1, bx2, by;
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDOK, bx2, by);
+ int y = ySize - my - by;
+ int x = xSize - mx - bx1;
+
+ InvalidateRect(NULL);
+
+ MoveItem(IDCANCEL, x, y, bx1, by);
+ MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+ ChangeSubWindowSizeX(_comboBox, xSize - mx * 2);
+ return false;
+}
+
+void CComboDialog::OnOK()
+{
+ _comboBox.GetText(Value);
+ CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/ComboDialog.h b/CPP/7zip/UI/FileManager/ComboDialog.h
index 6869cff..bb0fda8 100644
--- a/CPP/7zip/UI/FileManager/ComboDialog.h
+++ b/CPP/7zip/UI/FileManager/ComboDialog.h
@@ -1,28 +1,28 @@
-// ComboDialog.h
-
-#ifndef __COMBO_DIALOG_H
-#define __COMBO_DIALOG_H
-
-#include "../../../Windows/Control/ComboBox.h"
-#include "../../../Windows/Control/Dialog.h"
-
-#include "ComboDialogRes.h"
-
-class CComboDialog: public NWindows::NControl::CModalDialog
-{
- NWindows::NControl::CComboBox _comboBox;
- virtual void OnOK();
- virtual bool OnInit();
- virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
-public:
- // bool Sorted;
- UString Title;
- UString Static;
- UString Value;
- UStringVector Strings;
-
- // CComboDialog(): Sorted(false) {};
- INT_PTR Create(HWND parentWindow = 0) { return CModalDialog::Create(IDD_COMBO, parentWindow); }
-};
-
-#endif
+// ComboDialog.h
+
+#ifndef ZIP7_INC_COMBO_DIALOG_H
+#define ZIP7_INC_COMBO_DIALOG_H
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Dialog.h"
+
+#include "ComboDialogRes.h"
+
+class CComboDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CComboBox _comboBox;
+ virtual void OnOK() Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+public:
+ // bool Sorted;
+ UString Title;
+ UString Static;
+ UString Value;
+ UStringVector Strings;
+
+ // CComboDialog(): Sorted(false) {};
+ INT_PTR Create(HWND parentWindow = NULL) { return CModalDialog::Create(IDD_COMBO, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ComboDialog.rc b/CPP/7zip/UI/FileManager/ComboDialog.rc
new file mode 100644
index 0000000..fddb748
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ComboDialog.rc
@@ -0,0 +1,16 @@
+#include "ComboDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 64
+
+IDD_COMBO DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Combo"
+{
+ LTEXT "", IDT_COMBO, m, m, xc, 8
+ COMBOBOX IDC_COMBO, m, 20, xc, 65, MY_COMBO_WITH_EDIT
+ OK_CANCEL
+}
+
+#undef xc
+#undef yc
diff --git a/CPP/7zip/UI/FileManager/ComboDialogRes.h b/CPP/7zip/UI/FileManager/ComboDialogRes.h
index 98938b6..a044797 100644
--- a/CPP/7zip/UI/FileManager/ComboDialogRes.h
+++ b/CPP/7zip/UI/FileManager/ComboDialogRes.h
@@ -1,4 +1,4 @@
-#define IDD_COMBO 98
-
-#define IDT_COMBO 100
-#define IDC_COMBO 101
+#define IDD_COMBO 98
+
+#define IDT_COMBO 100
+#define IDC_COMBO 101
diff --git a/CPP/7zip/UI/FileManager/Copy.bmp b/CPP/7zip/UI/FileManager/Copy.bmp
new file mode 100644
index 0000000..0f28a32
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Copy.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Copy2.bmp b/CPP/7zip/UI/FileManager/Copy2.bmp
new file mode 100644
index 0000000..ba88ded
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Copy2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/CopyDialog.cpp b/CPP/7zip/UI/FileManager/CopyDialog.cpp
new file mode 100644
index 0000000..9bc01d0
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialog.cpp
@@ -0,0 +1,103 @@
+// CopyDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileName.h"
+
+#include "../../../Windows/Control/Static.h"
+
+#include "BrowseDialog.h"
+#include "CopyDialog.h"
+#include "LangUtils.h"
+
+using namespace NWindows;
+
+bool CCopyDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, NULL, 0);
+ #endif
+ _path.Attach(GetItem(IDC_COPY));
+ SetText(Title);
+
+ NControl::CStatic staticContol;
+ staticContol.Attach(GetItem(IDT_COPY));
+ staticContol.SetText(Static);
+ #ifdef UNDER_CE
+ // we do it, since WinCE selects Value\something instead of Value !!!!
+ _path.AddString(Value);
+ #endif
+ FOR_VECTOR (i, Strings)
+ _path.AddString(Strings[i]);
+ _path.SetText(Value);
+ SetItemText(IDT_COPY_INFO, Info);
+ NormalizeSize(true);
+ return CModalDialog::OnInit();
+}
+
+bool CCopyDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx1, bx2, by;
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDOK, bx2, by);
+ const int y = ySize - my - by;
+ const int x = xSize - mx - bx1;
+
+ InvalidateRect(NULL);
+
+ {
+ RECT r;
+ GetClientRectOfItem(IDB_COPY_SET_PATH, r);
+ const int bx = RECT_SIZE_X(r);
+ MoveItem(IDB_COPY_SET_PATH, xSize - mx - bx, r.top, bx, RECT_SIZE_Y(r));
+ ChangeSubWindowSizeX(_path, xSize - mx - mx - bx - mx);
+ }
+
+ {
+ RECT r;
+ GetClientRectOfItem(IDT_COPY_INFO, r);
+ NControl::CStatic staticContol;
+ staticContol.Attach(GetItem(IDT_COPY_INFO));
+ const int yPos = r.top;
+ staticContol.Move(mx, yPos, xSize - mx * 2, y - 2 - yPos);
+ }
+
+ MoveItem(IDCANCEL, x, y, bx1, by);
+ MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+
+ return false;
+}
+
+bool CCopyDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_COPY_SET_PATH:
+ OnButtonSetPath();
+ return true;
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CCopyDialog::OnButtonSetPath()
+{
+ UString currentPath;
+ _path.GetText(currentPath);
+
+ const UString title = LangString(IDS_SET_FOLDER);
+
+ UString resultPath;
+ if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+ return;
+ NFile::NName::NormalizeDirPathPrefix(resultPath);
+ _path.SetCurSel(-1);
+ _path.SetText(resultPath);
+}
+
+void CCopyDialog::OnOK()
+{
+ _path.GetText(Value);
+ CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/CopyDialog.h b/CPP/7zip/UI/FileManager/CopyDialog.h
new file mode 100644
index 0000000..3782420
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialog.h
@@ -0,0 +1,31 @@
+// CopyDialog.h
+
+#ifndef ZIP7_INC_COPY_DIALOG_H
+#define ZIP7_INC_COPY_DIALOG_H
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Dialog.h"
+
+#include "CopyDialogRes.h"
+
+const int kCopyDialog_NumInfoLines = 11;
+
+class CCopyDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CComboBox _path;
+ virtual void OnOK() Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ void OnButtonSetPath();
+public:
+ UString Title;
+ UString Static;
+ UString Value;
+ UString Info;
+ UStringVector Strings;
+
+ INT_PTR Create(HWND parentWindow = NULL) { return CModalDialog::Create(IDD_COPY, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/CopyDialog.rc b/CPP/7zip/UI/FileManager/CopyDialog.rc
new file mode 100644
index 0000000..73d3ea8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialog.rc
@@ -0,0 +1,20 @@
+#include "CopyDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 320
+#define yc 144
+
+#define y 40
+
+IDD_COPY DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Copy"
+{
+ LTEXT "", IDT_COPY, m, m, xc, 8
+ COMBOBOX IDC_COPY, m, 20, xc - bxsDots - m, 65, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_COPY_SET_PATH, xs - m - bxsDots, 18, bxsDots, bys, WS_GROUP
+ LTEXT "", IDT_COPY_INFO, m, y, xc, by - y - 1, SS_NOPREFIX | SS_LEFTNOWORDWRAP
+ OK_CANCEL
+}
+
+#undef xc
+#undef yc
diff --git a/CPP/7zip/UI/FileManager/CopyDialogRes.h b/CPP/7zip/UI/FileManager/CopyDialogRes.h
new file mode 100644
index 0000000..85f5a39
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/CopyDialogRes.h
@@ -0,0 +1,8 @@
+#define IDD_COPY 96
+
+#define IDT_COPY 100
+#define IDC_COPY 101
+#define IDB_COPY_SET_PATH 102
+#define IDT_COPY_INFO 103
+
+#define IDS_SET_FOLDER 6007
diff --git a/CPP/7zip/UI/FileManager/Delete.bmp b/CPP/7zip/UI/FileManager/Delete.bmp
new file mode 100644
index 0000000..d1004d8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Delete.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Delete2.bmp b/CPP/7zip/UI/FileManager/Delete2.bmp
new file mode 100644
index 0000000..60e08c6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Delete2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/DialogSize.h b/CPP/7zip/UI/FileManager/DialogSize.h
index bbce159..9f2270b 100644
--- a/CPP/7zip/UI/FileManager/DialogSize.h
+++ b/CPP/7zip/UI/FileManager/DialogSize.h
@@ -1,16 +1,16 @@
-// DialogSize.h
-
-#ifndef __DIALOG_SIZE_H
-#define __DIALOG_SIZE_H
-
-#include "../../../Windows/Control/Dialog.h"
-
-#ifdef UNDER_CE
-#define BIG_DIALOG_SIZE(x, y) bool isBig = NWindows::NControl::IsDialogSizeOK(x, y);
-#define SIZED_DIALOG(big) (isBig ? big : big ## _2)
-#else
-#define BIG_DIALOG_SIZE(x, y)
-#define SIZED_DIALOG(big) big
-#endif
-
-#endif
+// DialogSize.h
+
+#ifndef ZIP7_INC_DIALOG_SIZE_H
+#define ZIP7_INC_DIALOG_SIZE_H
+
+#include "../../../Windows/Control/Dialog.h"
+
+#ifdef UNDER_CE
+#define BIG_DIALOG_SIZE(x, y) bool isBig = NWindows::NControl::IsDialogSizeOK(x, y);
+#define SIZED_DIALOG(big) (isBig ? big : big ## _2)
+#else
+#define BIG_DIALOG_SIZE(x, y)
+#define SIZED_DIALOG(big) big
+#endif
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditDialog.cpp b/CPP/7zip/UI/FileManager/EditDialog.cpp
new file mode 100644
index 0000000..e97d9ea
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialog.cpp
@@ -0,0 +1,57 @@
+// EditDialog.cpp
+
+#include "StdAfx.h"
+
+#include "EditDialog.h"
+
+#ifdef Z7_LANG
+#include "LangUtils.h"
+#endif
+
+bool CEditDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, NULL, 0);
+ #endif
+ _edit.Attach(GetItem(IDE_EDIT));
+
+ SetText(Title);
+ _edit.SetText(Text);
+
+ NormalizeSize();
+ return CModalDialog::OnInit();
+}
+
+// #define MY_CLOSE_BUTTON_ID IDCANCEL
+#define MY_CLOSE_BUTTON_ID IDCLOSE
+
+bool CEditDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx1, by;
+ GetItemSizes(MY_CLOSE_BUTTON_ID, bx1, by);
+
+ // int bx2;
+ // GetItemSizes(IDOK, bx2, by);
+
+ const int y = ySize - my - by;
+ const int x = xSize - mx - bx1;
+
+ /*
+ RECT rect;
+ GetClientRect(&rect);
+ rect.top = y - my;
+ InvalidateRect(&rect);
+ */
+ InvalidateRect(NULL);
+
+ MoveItem(MY_CLOSE_BUTTON_ID, x, y, bx1, by);
+ // MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+ /*
+ if (wParam == SIZE_MAXSHOW || wParam == SIZE_MAXIMIZED || wParam == SIZE_MAXHIDE)
+ mx = 0;
+ */
+ _edit.Move(mx, my, xSize - mx * 2, y - my * 2);
+ return false;
+}
diff --git a/CPP/7zip/UI/FileManager/EditDialog.h b/CPP/7zip/UI/FileManager/EditDialog.h
new file mode 100644
index 0000000..6970b14
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialog.h
@@ -0,0 +1,25 @@
+// EditDialog.h
+
+#ifndef ZIP7_INC_EDIT_DIALOG_H
+#define ZIP7_INC_EDIT_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "EditDialogRes.h"
+
+class CEditDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CEdit _edit;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+public:
+ UString Title;
+ UString Text;
+
+ INT_PTR Create(HWND wndParent = NULL) { return CModalDialog::Create(IDD_EDIT_DLG, wndParent); }
+
+ CEditDialog() {}
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditDialog.rc b/CPP/7zip/UI/FileManager/EditDialog.rc
new file mode 100644
index 0000000..cdb0b44
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialog.rc
@@ -0,0 +1,15 @@
+#include "EditDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 320
+#define yc 240
+
+IDD_EDIT_DLG DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Edit"
+{
+ // OK_CANCEL
+ MY_BUTTON__CLOSE
+
+ EDITTEXT IDE_EDIT, m, m, xc, yc - bys - m,
+ ES_MULTILINE | ES_READONLY | WS_VSCROLL | WS_HSCROLL | ES_WANTRETURN
+}
diff --git a/CPP/7zip/UI/FileManager/EditDialogRes.h b/CPP/7zip/UI/FileManager/EditDialogRes.h
new file mode 100644
index 0000000..58c5ca9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditDialogRes.h
@@ -0,0 +1,2 @@
+#define IDD_EDIT_DLG 94
+#define IDE_EDIT 100
diff --git a/CPP/7zip/UI/FileManager/EditPage.cpp b/CPP/7zip/UI/FileManager/EditPage.cpp
new file mode 100644
index 0000000..a2a0321
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage.cpp
@@ -0,0 +1,159 @@
+// EditPage.cpp
+
+#include "StdAfx.h"
+
+#include "EditPage.h"
+#include "EditPageRes.h"
+
+#include "BrowseDialog.h"
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_EDIT_EDITOR,
+ IDT_EDIT_DIFF
+};
+
+static const UInt32 kLangIDs_Colon[] =
+{
+ IDT_EDIT_VIEWER
+};
+#endif
+
+#define kEditTopic "FM/options.htm#editor"
+
+bool CEditPage::OnInit()
+{
+ _initMode = true;
+
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ LangSetDlgItems_Colon(*this, kLangIDs_Colon, Z7_ARRAY_SIZE(kLangIDs_Colon));
+ #endif
+
+ _ctrls[0].Ctrl = IDE_EDIT_VIEWER; _ctrls[0].Button = IDB_EDIT_VIEWER;
+ _ctrls[1].Ctrl = IDE_EDIT_EDITOR; _ctrls[1].Button = IDB_EDIT_EDITOR;
+ _ctrls[2].Ctrl = IDE_EDIT_DIFF; _ctrls[2].Button = IDB_EDIT_DIFF;
+
+ for (unsigned i = 0; i < 3; i++)
+ {
+ CEditPageCtrl &c = _ctrls[i];
+ c.WasChanged = false;
+ c.Edit.Attach(GetItem(c.Ctrl));
+ UString path;
+ if (i < 2)
+ ReadRegEditor(i > 0, path);
+ else
+ ReadRegDiff(path);
+ c.Edit.SetText(path);
+ }
+
+ _initMode = false;
+
+ return CPropertyPage::OnInit();
+}
+
+LONG CEditPage::OnApply()
+{
+ for (unsigned i = 0; i < 3; i++)
+ {
+ CEditPageCtrl &c = _ctrls[i];
+ if (c.WasChanged)
+ {
+ UString path;
+ c.Edit.GetText(path);
+ if (i < 2)
+ SaveRegEditor(i > 0, path);
+ else
+ SaveRegDiff(path);
+ c.WasChanged = false;
+ }
+ }
+
+ return PSNRET_NOERROR;
+}
+
+void CEditPage::OnNotifyHelp()
+{
+ ShowHelpWindow(kEditTopic);
+}
+
+void SplitCmdLineSmart(const UString &cmd, UString &prg, UString ¶ms);
+
+static void Edit_BrowseForFile(NWindows::NControl::CEdit &edit, HWND hwnd)
+{
+ UString cmd;
+ edit.GetText(cmd);
+
+ UString param;
+ UString prg;
+
+ SplitCmdLineSmart(cmd, prg, param);
+
+ CObjectVector<CBrowseFilterInfo> filters;
+ CBrowseFilterInfo &bfi = filters.AddNew();
+ bfi.Description = "*.exe";
+ bfi.Masks.Add(UString("*.exe"));
+
+ CBrowseInfo bi;
+ bi.FilterIndex = 0;
+ bi.FilePath = prg;
+ bi.hwndOwner = hwnd;
+
+ if (bi.BrowseForFile(filters))
+ {
+ cmd = bi.FilePath;
+ cmd.Trim();
+ /*
+ if (!param.IsEmpty() && !resPath.IsEmpty())
+ {
+ cmd.InsertAtFront(L'\"');
+ cmd += L'\"';
+ cmd.Add_Space();
+ cmd += param;
+ }
+ */
+
+ edit.SetText(cmd);
+ // Changed();
+ }
+}
+
+bool CEditPage::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ for (unsigned i = 0; i < 3; i++)
+ {
+ CEditPageCtrl &c = _ctrls[i];
+ if (buttonID == c.Button)
+ {
+ Edit_BrowseForFile(c.Edit, *this);
+ return true;
+ }
+ }
+
+ return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+}
+
+bool CEditPage::OnCommand(unsigned code, unsigned itemID, LPARAM param)
+{
+ if (!_initMode && code == EN_CHANGE)
+ {
+ for (unsigned i = 0; i < 3; i++)
+ {
+ CEditPageCtrl &c = _ctrls[i];
+ if (itemID == c.Ctrl)
+ {
+ c.WasChanged = true;
+ Changed();
+ return true;
+ }
+ }
+ }
+
+ return CPropertyPage::OnCommand(code, itemID, param);
+}
diff --git a/CPP/7zip/UI/FileManager/EditPage.h b/CPP/7zip/UI/FileManager/EditPage.h
new file mode 100644
index 0000000..a70fad7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage.h
@@ -0,0 +1,30 @@
+// EditPage.h
+
+#ifndef ZIP7_INC_EDIT_PAGE_H
+#define ZIP7_INC_EDIT_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/Edit.h"
+
+struct CEditPageCtrl
+{
+ NWindows::NControl::CEdit Edit;
+ bool WasChanged;
+ unsigned Ctrl;
+ unsigned Button;
+};
+
+class CEditPage: public NWindows::NControl::CPropertyPage
+{
+ CEditPageCtrl _ctrls[3];
+
+ bool _initMode;
+public:
+ virtual bool OnInit() Z7_override;
+ virtual void OnNotifyHelp() Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM param) Z7_override;
+ virtual LONG OnApply() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditPage.rc b/CPP/7zip/UI/FileManager/EditPage.rc
new file mode 100644
index 0000000..38f74ea
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage.rc
@@ -0,0 +1,19 @@
+#include "EditPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 80
+
+IDD_EDIT MY_PAGE
+#include "EditPage2.rc"
+
+#ifdef UNDER_CE
+
+#undef xc
+
+#define xc SMALL_PAGE_SIZE_X
+
+IDD_EDIT_2 MY_PAGE
+#include "EditPage2.rc"
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/EditPage2.rc b/CPP/7zip/UI/FileManager/EditPage2.rc
new file mode 100644
index 0000000..2d6554f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPage2.rc
@@ -0,0 +1,14 @@
+CAPTION "Editor"
+{
+ LTEXT "&View:", IDT_EDIT_VIEWER, m, m, xc, 8
+ EDITTEXT IDE_EDIT_VIEWER, m, m + 12, xc - m - bxsDots, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_EDIT_VIEWER, xs - m - bxsDots, m + 11, bxsDots, bys
+
+ LTEXT "&Editor:", IDT_EDIT_EDITOR, m, m + 32, xc, 8
+ EDITTEXT IDE_EDIT_EDITOR, m, m + 44, xc - m - bxsDots, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_EDIT_EDITOR, xs - m - bxsDots, m + 43, bxsDots, bys
+
+ LTEXT "&Diff:", IDT_EDIT_DIFF, m, m + 64, xc, 8
+ EDITTEXT IDE_EDIT_DIFF, m, m + 76, xc - m - bxsDots, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_EDIT_DIFF, xs - m - bxsDots, m + 75, bxsDots, bys
+}
diff --git a/CPP/7zip/UI/FileManager/EditPageRes.h b/CPP/7zip/UI/FileManager/EditPageRes.h
new file mode 100644
index 0000000..017d702
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EditPageRes.h
@@ -0,0 +1,15 @@
+#define IDD_EDIT 2103
+#define IDD_EDIT_2 12103
+
+#define IDT_EDIT_VIEWER 543
+#define IDT_EDIT_EDITOR 2104
+#define IDT_EDIT_DIFF 2105
+
+#define IDE_EDIT_VIEWER 100
+#define IDB_EDIT_VIEWER 101
+
+#define IDE_EDIT_EDITOR 102
+#define IDB_EDIT_EDITOR 103
+
+#define IDE_EDIT_DIFF 104
+#define IDB_EDIT_DIFF 105
diff --git a/CPP/7zip/UI/FileManager/EnumFormatEtc.cpp b/CPP/7zip/UI/FileManager/EnumFormatEtc.cpp
new file mode 100644
index 0000000..fc2fd6c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EnumFormatEtc.cpp
@@ -0,0 +1,107 @@
+// EnumFormatEtc.cpp
+
+#include "StdAfx.h"
+
+#include "EnumFormatEtc.h"
+#include "../../IDecl.h"
+#include "MyCom2.h"
+
+class CEnumFormatEtc Z7_final:
+ public IEnumFORMATETC,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1_MT(IEnumFORMATETC)
+
+ STDMETHOD(Next)(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched) Z7_override;
+ STDMETHOD(Skip)(ULONG celt) Z7_override;
+ STDMETHOD(Reset)(void) Z7_override;
+ STDMETHOD(Clone)(IEnumFORMATETC **ppEnumFormatEtc) Z7_override;
+
+ LONG m_RefCount;
+ ULONG m_NumFormats;
+ FORMATETC *m_Formats;
+ ULONG m_Index;
+public:
+ CEnumFormatEtc(const FORMATETC *pFormatEtc, ULONG numFormats);
+ ~CEnumFormatEtc();
+};
+
+static void DeepCopyFormatEtc(FORMATETC *dest, const FORMATETC *src)
+{
+ *dest = *src;
+ if (src->ptd)
+ {
+ dest->ptd = (DVTARGETDEVICE*)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
+ *(dest->ptd) = *(src->ptd);
+ }
+}
+
+CEnumFormatEtc::CEnumFormatEtc(const FORMATETC *pFormatEtc, ULONG numFormats)
+{
+ m_RefCount = 1;
+ m_Index = 0;
+ m_NumFormats = 0;
+ m_Formats = new FORMATETC[numFormats];
+ // if (m_Formats)
+ {
+ m_NumFormats = numFormats;
+ for (ULONG i = 0; i < numFormats; i++)
+ DeepCopyFormatEtc(&m_Formats[i], &pFormatEtc[i]);
+ }
+}
+
+CEnumFormatEtc::~CEnumFormatEtc()
+{
+ if (m_Formats)
+ {
+ for (ULONG i = 0; i < m_NumFormats; i++)
+ if (m_Formats[i].ptd)
+ CoTaskMemFree(m_Formats[i].ptd);
+ delete []m_Formats;
+ }
+}
+
+Z7_COMWF_B CEnumFormatEtc::Next(ULONG celt, FORMATETC *pFormatEtc, ULONG *pceltFetched)
+{
+ ULONG copied = 0;
+ if (celt == 0 || !pFormatEtc)
+ return E_INVALIDARG;
+ while (m_Index < m_NumFormats && copied < celt)
+ {
+ DeepCopyFormatEtc(&pFormatEtc[copied], &m_Formats[m_Index]);
+ copied++;
+ m_Index++;
+ }
+ if (pceltFetched)
+ *pceltFetched = copied;
+ return (copied == celt) ? S_OK : S_FALSE;
+}
+
+Z7_COMWF_B CEnumFormatEtc::Skip(ULONG celt)
+{
+ m_Index += celt;
+ return (m_Index <= m_NumFormats) ? S_OK : S_FALSE;
+}
+
+Z7_COMWF_B CEnumFormatEtc::Reset(void)
+{
+ m_Index = 0;
+ return S_OK;
+}
+
+Z7_COMWF_B CEnumFormatEtc::Clone(IEnumFORMATETC ** ppEnumFormatEtc)
+{
+ HRESULT hResult = CreateEnumFormatEtc(m_NumFormats, m_Formats, ppEnumFormatEtc);
+ if (hResult == S_OK)
+ ((CEnumFormatEtc *)*ppEnumFormatEtc)->m_Index = m_Index;
+ return hResult;
+}
+
+// replacement for SHCreateStdEnumFmtEtc
+HRESULT CreateEnumFormatEtc(UINT numFormats, const FORMATETC *formats, IEnumFORMATETC **enumFormat)
+{
+ if (numFormats == 0 || !formats || !enumFormat)
+ return E_INVALIDARG;
+ *enumFormat = new CEnumFormatEtc(formats, numFormats);
+ return (*enumFormat) ? S_OK : E_OUTOFMEMORY;
+}
diff --git a/CPP/7zip/UI/FileManager/EnumFormatEtc.h b/CPP/7zip/UI/FileManager/EnumFormatEtc.h
new file mode 100644
index 0000000..12df225
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/EnumFormatEtc.h
@@ -0,0 +1,10 @@
+// EnumFormatEtc.h
+
+#ifndef ZIP7_INC_ENUMFORMATETC_H
+#define ZIP7_INC_ENUMFORMATETC_H
+
+#include "../../../Common/MyWindows.h"
+
+HRESULT CreateEnumFormatEtc(UINT numFormats, const FORMATETC *formats, IEnumFORMATETC **enumFormat);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/Extract.bmp b/CPP/7zip/UI/FileManager/Extract.bmp
new file mode 100644
index 0000000..0aeba92
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Extract.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Extract2.bmp b/CPP/7zip/UI/FileManager/Extract2.bmp
new file mode 100644
index 0000000..a7e5775
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Extract2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/ExtractCallback.cpp b/CPP/7zip/UI/FileManager/ExtractCallback.cpp
index f230594..f674044 100644
--- a/CPP/7zip/UI/FileManager/ExtractCallback.cpp
+++ b/CPP/7zip/UI/FileManager/ExtractCallback.cpp
@@ -1,1037 +1,1056 @@
-// ExtractCallback.cpp
-
-#include "StdAfx.h"
-
-
-#include "../../../Common/ComTry.h"
-#include "../../../Common/IntToString.h"
-#include "../../../Common/Lang.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/PropVariantConv.h"
-
-#include "../../Common/FilePathAutoRename.h"
-#include "../../Common/StreamUtils.h"
-#include "../Common/ExtractingFilePath.h"
-
-#ifndef _SFX
-#include "../Common/ZipRegistry.h"
-#endif
-
-#include "../GUI/ExtractRes.h"
-#include "resourceGui.h"
-
-#include "ExtractCallback.h"
-#include "FormatUtils.h"
-#include "LangUtils.h"
-#include "OverwriteDialog.h"
-#ifndef _NO_CRYPTO
-#include "PasswordDialog.h"
-#endif
-#include "PropertyName.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NFind;
-
-CExtractCallbackImp::~CExtractCallbackImp() {}
-
-void CExtractCallbackImp::Init()
-{
- _lang_Extracting = LangString(IDS_PROGRESS_EXTRACTING);
- _lang_Testing = LangString(IDS_PROGRESS_TESTING);
- _lang_Skipping = LangString(IDS_PROGRESS_SKIPPING);
-
- NumArchiveErrors = 0;
- ThereAreMessageErrors = false;
- #ifndef _SFX
- NumFolders = NumFiles = 0;
- NeedAddFile = false;
- #endif
-}
-
-void CExtractCallbackImp::AddError_Message(LPCWSTR s)
-{
- ThereAreMessageErrors = true;
- ProgressDialog->Sync.AddError_Message(s);
-}
-
-#ifndef _SFX
-
-STDMETHODIMP CExtractCallbackImp::SetNumFiles(UInt64
- #ifndef _SFX
- numFiles
- #endif
- )
-{
- #ifndef _SFX
- ProgressDialog->Sync.Set_NumFilesTotal(numFiles);
- #endif
- return S_OK;
-}
-
-#endif
-
-STDMETHODIMP CExtractCallbackImp::SetTotal(UInt64 total)
-{
- ProgressDialog->Sync.Set_NumBytesTotal(total);
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::SetCompleted(const UInt64 *value)
-{
- return ProgressDialog->Sync.Set_NumBytesCur(value);
-}
-
-HRESULT CExtractCallbackImp::Open_CheckBreak()
-{
- return ProgressDialog->Sync.CheckStop();
-}
-
-HRESULT CExtractCallbackImp::Open_SetTotal(const UInt64 *files, const UInt64 *bytes)
-{
- HRESULT res = S_OK;
- if (!MultiArcMode)
- {
- if (files)
- {
- _totalFilesDefined = true;
- // res = ProgressDialog->Sync.Set_NumFilesTotal(*files);
- }
- else
- _totalFilesDefined = false;
-
- if (bytes)
- {
- _totalBytesDefined = true;
- ProgressDialog->Sync.Set_NumBytesTotal(*bytes);
- }
- else
- _totalBytesDefined = false;
- }
-
- return res;
-}
-
-HRESULT CExtractCallbackImp::Open_SetCompleted(const UInt64 *files, const UInt64 *bytes)
-{
- if (!MultiArcMode)
- {
- if (files)
- {
- ProgressDialog->Sync.Set_NumFilesCur(*files);
- }
-
- if (bytes)
- {
- }
- }
-
- return ProgressDialog->Sync.CheckStop();
-}
-
-HRESULT CExtractCallbackImp::Open_Finished()
-{
- return ProgressDialog->Sync.CheckStop();
-}
-
-#ifndef _NO_CRYPTO
-
-HRESULT CExtractCallbackImp::Open_CryptoGetTextPassword(BSTR *password)
-{
- return CryptoGetTextPassword(password);
-}
-
-/*
-HRESULT CExtractCallbackImp::Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password)
-{
- passwordIsDefined = PasswordIsDefined;
- password = Password;
- return S_OK;
-}
-
-bool CExtractCallbackImp::Open_WasPasswordAsked()
-{
- return PasswordWasAsked;
-}
-
-void CExtractCallbackImp::Open_Clear_PasswordWasAsked_Flag()
-{
- PasswordWasAsked = false;
-}
-*/
-
-#endif
-
-
-#ifndef _SFX
-STDMETHODIMP CExtractCallbackImp::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
- ProgressDialog->Sync.Set_Ratio(inSize, outSize);
- return S_OK;
-}
-#endif
-
-/*
-STDMETHODIMP CExtractCallbackImp::SetTotalFiles(UInt64 total)
-{
- ProgressDialog->Sync.SetNumFilesTotal(total);
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::SetCompletedFiles(const UInt64 *value)
-{
- if (value != NULL)
- ProgressDialog->Sync.SetNumFilesCur(*value);
- return S_OK;
-}
-*/
-
-STDMETHODIMP CExtractCallbackImp::AskOverwrite(
- const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize,
- const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize,
- Int32 *answer)
-{
- COverwriteDialog dialog;
-
- dialog.OldFileInfo.SetTime(existTime);
- dialog.OldFileInfo.SetSize(existSize);
- dialog.OldFileInfo.Name = existName;
-
- dialog.NewFileInfo.SetTime(newTime);
- dialog.NewFileInfo.SetSize(newSize);
- dialog.NewFileInfo.Name = newName;
-
- ProgressDialog->WaitCreating();
- INT_PTR writeAnswer = dialog.Create(*ProgressDialog);
-
- switch (writeAnswer)
- {
- case IDCANCEL: *answer = NOverwriteAnswer::kCancel; return E_ABORT;
- case IDYES: *answer = NOverwriteAnswer::kYes; break;
- case IDNO: *answer = NOverwriteAnswer::kNo; break;
- case IDB_YES_TO_ALL: *answer = NOverwriteAnswer::kYesToAll; break;
- case IDB_NO_TO_ALL: *answer = NOverwriteAnswer::kNoToAll; break;
- case IDB_AUTO_RENAME: *answer = NOverwriteAnswer::kAutoRename; break;
- default: return E_FAIL;
- }
- return S_OK;
-}
-
-
-STDMETHODIMP CExtractCallbackImp::PrepareOperation(const wchar_t *name, Int32 isFolder, Int32 askExtractMode, const UInt64 * /* position */)
-{
- _isFolder = IntToBool(isFolder);
- _currentFilePath = name;
-
- const UString *msg = &_lang_Empty;
- switch (askExtractMode)
- {
- case NArchive::NExtract::NAskMode::kExtract: msg = &_lang_Extracting; break;
- case NArchive::NExtract::NAskMode::kTest: msg = &_lang_Testing; break;
- case NArchive::NExtract::NAskMode::kSkip: msg = &_lang_Skipping; break;
- // default: s = "Unknown operation";
- }
-
- return ProgressDialog->Sync.Set_Status2(*msg, name, IntToBool(isFolder));
-}
-
-STDMETHODIMP CExtractCallbackImp::MessageError(const wchar_t *s)
-{
- AddError_Message(s);
- return S_OK;
-}
-
-HRESULT CExtractCallbackImp::MessageError(const char *message, const FString &path)
-{
- ThereAreMessageErrors = true;
- ProgressDialog->Sync.AddError_Message_Name(GetUnicodeString(message), fs2us(path));
- return S_OK;
-}
-
-#ifndef _SFX
-
-STDMETHODIMP CExtractCallbackImp::ShowMessage(const wchar_t *s)
-{
- AddError_Message(s);
- return S_OK;
-}
-
-#endif
-
-void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s)
-{
- s.Empty();
-
- if (opRes == NArchive::NExtract::NOperationResult::kOK)
- return;
-
- UINT messageID = 0;
- UINT id = 0;
-
- switch (opRes)
- {
- case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
- messageID = IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD;
- id = IDS_EXTRACT_MSG_UNSUPPORTED_METHOD;
- break;
- case NArchive::NExtract::NOperationResult::kDataError:
- messageID = encrypted ?
- IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED:
- IDS_EXTRACT_MESSAGE_DATA_ERROR;
- id = IDS_EXTRACT_MSG_DATA_ERROR;
- break;
- case NArchive::NExtract::NOperationResult::kCRCError:
- messageID = encrypted ?
- IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED:
- IDS_EXTRACT_MESSAGE_CRC_ERROR;
- id = IDS_EXTRACT_MSG_CRC_ERROR;
- break;
- case NArchive::NExtract::NOperationResult::kUnavailable:
- id = IDS_EXTRACT_MSG_UNAVAILABLE_DATA;
- break;
- case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
- id = IDS_EXTRACT_MSG_UEXPECTED_END;
- break;
- case NArchive::NExtract::NOperationResult::kDataAfterEnd:
- id = IDS_EXTRACT_MSG_DATA_AFTER_END;
- break;
- case NArchive::NExtract::NOperationResult::kIsNotArc:
- id = IDS_EXTRACT_MSG_IS_NOT_ARC;
- break;
- case NArchive::NExtract::NOperationResult::kHeadersError:
- id = IDS_EXTRACT_MSG_HEADERS_ERROR;
- break;
- case NArchive::NExtract::NOperationResult::kWrongPassword:
- id = IDS_EXTRACT_MSG_WRONG_PSW_CLAIM;
- break;
- /*
- default:
- messageID = IDS_EXTRACT_MESSAGE_UNKNOWN_ERROR;
- break;
- */
- }
-
- UString msg;
- UString msgOld;
-
- #ifndef _SFX
- if (id != 0)
- LangString_OnlyFromLangFile(id, msg);
- if (messageID != 0 && msg.IsEmpty())
- LangString_OnlyFromLangFile(messageID, msgOld);
- #endif
-
- if (msg.IsEmpty() && !msgOld.IsEmpty())
- s = MyFormatNew(msgOld, fileName);
- else
- {
- if (msg.IsEmpty() && id != 0)
- LangString(id, msg);
- if (!msg.IsEmpty())
- s += msg;
- else
- {
- s += "Error #";
- s.Add_UInt32(opRes);
- }
-
- if (encrypted && opRes != NArchive::NExtract::NOperationResult::kWrongPassword)
- {
- // s += " : ";
- // AddLangString(s, IDS_EXTRACT_MSG_ENCRYPTED);
- s += " : ";
- AddLangString(s, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
- }
- s += " : ";
- s += fileName;
- }
-}
-
-STDMETHODIMP CExtractCallbackImp::SetOperationResult(Int32 opRes, Int32 encrypted)
-{
- switch (opRes)
- {
- case NArchive::NExtract::NOperationResult::kOK:
- break;
- default:
- {
- UString s;
- SetExtractErrorMessage(opRes, encrypted, _currentFilePath, s);
- Add_ArchiveName_Error();
- AddError_Message(s);
- }
- }
-
- #ifndef _SFX
- if (_isFolder)
- NumFolders++;
- else
- NumFiles++;
- ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
- #endif
-
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name)
-{
- if (opRes != NArchive::NExtract::NOperationResult::kOK)
- {
- UString s;
- SetExtractErrorMessage(opRes, encrypted, name, s);
- Add_ArchiveName_Error();
- AddError_Message(s);
- }
- return S_OK;
-}
-
-////////////////////////////////////////
-// IExtractCallbackUI
-
-HRESULT CExtractCallbackImp::BeforeOpen(const wchar_t *name, bool /* testMode */)
-{
- #ifndef _SFX
- RINOK(ProgressDialog->Sync.CheckStop());
- ProgressDialog->Sync.Set_TitleFileName(name);
- #endif
- _currentArchivePath = name;
- return S_OK;
-}
-
-HRESULT CExtractCallbackImp::SetCurrentFilePath2(const wchar_t *path)
-{
- _currentFilePath = path;
- #ifndef _SFX
- ProgressDialog->Sync.Set_FilePath(path);
- #endif
- return S_OK;
-}
-
-#ifndef _SFX
-
-HRESULT CExtractCallbackImp::SetCurrentFilePath(const wchar_t *path)
-{
- #ifndef _SFX
- if (NeedAddFile)
- NumFiles++;
- NeedAddFile = true;
- ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
- #endif
- return SetCurrentFilePath2(path);
-}
-
-#endif
-
-UString HResultToMessage(HRESULT errorCode);
-
-static const UInt32 k_ErrorFlagsIds[] =
-{
- IDS_EXTRACT_MSG_IS_NOT_ARC,
- IDS_EXTRACT_MSG_HEADERS_ERROR,
- IDS_EXTRACT_MSG_HEADERS_ERROR,
- IDS_OPEN_MSG_UNAVAILABLE_START,
- IDS_OPEN_MSG_UNCONFIRMED_START,
- IDS_EXTRACT_MSG_UEXPECTED_END,
- IDS_EXTRACT_MSG_DATA_AFTER_END,
- IDS_EXTRACT_MSG_UNSUPPORTED_METHOD,
- IDS_OPEN_MSG_UNSUPPORTED_FEATURE,
- IDS_EXTRACT_MSG_DATA_ERROR,
- IDS_EXTRACT_MSG_CRC_ERROR
-};
-
-static void AddNewLineString(UString &s, const UString &m)
-{
- s += m;
- s.Add_LF();
-}
-
-UString GetOpenArcErrorMessage(UInt32 errorFlags)
-{
- UString s;
-
- for (unsigned i = 0; i < ARRAY_SIZE(k_ErrorFlagsIds); i++)
- {
- UInt32 f = ((UInt32)1 << i);
- if ((errorFlags & f) == 0)
- continue;
- UInt32 id = k_ErrorFlagsIds[i];
- UString m = LangString(id);
- if (m.IsEmpty())
- continue;
- if (f == kpv_ErrorFlags_EncryptedHeadersError)
- {
- m += " : ";
- AddLangString(m, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
- }
- if (!s.IsEmpty())
- s.Add_LF();
- s += m;
- errorFlags &= ~f;
- }
-
- if (errorFlags != 0)
- {
- char sz[16];
- sz[0] = '0';
- sz[1] = 'x';
- ConvertUInt32ToHex(errorFlags, sz + 2);
- if (!s.IsEmpty())
- s.Add_LF();
- s += sz;
- }
-
- return s;
-}
-
-static void ErrorInfo_Print(UString &s, const CArcErrorInfo &er)
-{
- UInt32 errorFlags = er.GetErrorFlags();
- UInt32 warningFlags = er.GetWarningFlags();
-
- if (errorFlags != 0)
- AddNewLineString(s, GetOpenArcErrorMessage(errorFlags));
-
- if (!er.ErrorMessage.IsEmpty())
- AddNewLineString(s, er.ErrorMessage);
-
- if (warningFlags != 0)
- {
- s += GetNameOfProperty(kpidWarningFlags, L"Warnings");
- s += ":";
- s.Add_LF();
- AddNewLineString(s, GetOpenArcErrorMessage(warningFlags));
- }
-
- if (!er.WarningMessage.IsEmpty())
- {
- s += GetNameOfProperty(kpidWarning, L"Warning");
- s += ": ";
- s += er.WarningMessage;
- s.Add_LF();
- }
-}
-
-static UString GetBracedType(const wchar_t *type)
-{
- UString s ('[');
- s += type;
- s += ']';
- return s;
-}
-
-void OpenResult_GUI(UString &s, const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
-{
- FOR_VECTOR (level, arcLink.Arcs)
- {
- const CArc &arc = arcLink.Arcs[level];
- const CArcErrorInfo &er = arc.ErrorInfo;
-
- if (!er.IsThereErrorOrWarning() && er.ErrorFormatIndex < 0)
- continue;
-
- if (s.IsEmpty())
- {
- s += name;
- s.Add_LF();
- }
-
- if (level != 0)
- {
- AddNewLineString(s, arc.Path);
- }
-
- ErrorInfo_Print(s, er);
-
- if (er.ErrorFormatIndex >= 0)
- {
- AddNewLineString(s, GetNameOfProperty(kpidWarning, L"Warning"));
- if (arc.FormatIndex == er.ErrorFormatIndex)
- {
- AddNewLineString(s, LangString(IDS_IS_OPEN_WITH_OFFSET));
- }
- else
- {
- AddNewLineString(s, MyFormatNew(IDS_CANT_OPEN_AS_TYPE, GetBracedType(codecs->GetFormatNamePtr(er.ErrorFormatIndex))));
- AddNewLineString(s, MyFormatNew(IDS_IS_OPEN_AS_TYPE, GetBracedType(codecs->GetFormatNamePtr(arc.FormatIndex))));
- }
- }
- }
-
- if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0 || result != S_OK)
- {
- s += name;
- s.Add_LF();
- if (!arcLink.Arcs.IsEmpty())
- AddNewLineString(s, arcLink.NonOpen_ArcPath);
-
- if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0 || result == S_FALSE)
- {
- UINT id = IDS_CANT_OPEN_ARCHIVE;
- UString param;
- if (arcLink.PasswordWasAsked)
- id = IDS_CANT_OPEN_ENCRYPTED_ARCHIVE;
- else if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
- {
- id = IDS_CANT_OPEN_AS_TYPE;
- param = GetBracedType(codecs->GetFormatNamePtr(arcLink.NonOpen_ErrorInfo.ErrorFormatIndex));
- }
- UString s2 = MyFormatNew(id, param);
- s2.Replace(L" ''", L"");
- s2.Replace(L"''", L"");
- s += s2;
- }
- else
- s += HResultToMessage(result);
-
- s.Add_LF();
- ErrorInfo_Print(s, arcLink.NonOpen_ErrorInfo);
- }
-
- if (!s.IsEmpty() && s.Back() == '\n')
- s.DeleteBack();
-}
-
-HRESULT CExtractCallbackImp::OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
-{
- _currentArchivePath = name;
- _needWriteArchivePath = true;
-
- UString s;
- OpenResult_GUI(s, codecs, arcLink, name, result);
- if (!s.IsEmpty())
- {
- NumArchiveErrors++;
- AddError_Message(s);
- _needWriteArchivePath = false;
- }
-
- return S_OK;
-}
-
-HRESULT CExtractCallbackImp::ThereAreNoFiles()
-{
- return S_OK;
-}
-
-void CExtractCallbackImp::Add_ArchiveName_Error()
-{
- if (_needWriteArchivePath)
- {
- if (!_currentArchivePath.IsEmpty())
- AddError_Message(_currentArchivePath);
- _needWriteArchivePath = false;
- }
-}
-
-HRESULT CExtractCallbackImp::ExtractResult(HRESULT result)
-{
- if (result == S_OK)
- return result;
- NumArchiveErrors++;
- if (result == E_ABORT || result == ERROR_DISK_FULL)
- return result;
-
- Add_ArchiveName_Error();
- if (!_currentFilePath.IsEmpty())
- MessageError(_currentFilePath);
- MessageError(NError::MyFormatMessage(result));
- return S_OK;
-}
-
-#ifndef _NO_CRYPTO
-
-HRESULT CExtractCallbackImp::SetPassword(const UString &password)
-{
- PasswordIsDefined = true;
- Password = password;
- return S_OK;
-}
-
-STDMETHODIMP CExtractCallbackImp::CryptoGetTextPassword(BSTR *password)
-{
- PasswordWasAsked = true;
- if (!PasswordIsDefined)
- {
- CPasswordDialog dialog;
- #ifndef _SFX
- bool showPassword = NExtract::Read_ShowPassword();
- dialog.ShowPassword = showPassword;
- #endif
- ProgressDialog->WaitCreating();
- if (dialog.Create(*ProgressDialog) != IDOK)
- return E_ABORT;
- Password = dialog.Password;
- PasswordIsDefined = true;
- #ifndef _SFX
- if (dialog.ShowPassword != showPassword)
- NExtract::Save_ShowPassword(dialog.ShowPassword);
- #endif
- }
- return StringToBstr(Password, password);
-}
-
-#endif
-
-#ifndef _SFX
-
-STDMETHODIMP CExtractCallbackImp::AskWrite(
- const wchar_t *srcPath, Int32 srcIsFolder,
- const FILETIME *srcTime, const UInt64 *srcSize,
- const wchar_t *destPath,
- BSTR *destPathResult,
- Int32 *writeAnswer)
-{
- UString destPathResultTemp = destPath;
-
- // RINOK(StringToBstr(destPath, destPathResult));
-
- *destPathResult = 0;
- *writeAnswer = BoolToInt(false);
-
- FString destPathSys = us2fs(destPath);
- bool srcIsFolderSpec = IntToBool(srcIsFolder);
- CFileInfo destFileInfo;
-
- if (destFileInfo.Find(destPathSys))
- {
- if (srcIsFolderSpec)
- {
- if (!destFileInfo.IsDir())
- {
- RINOK(MessageError("can not replace file with folder with same name", destPathSys));
- return E_ABORT;
- }
- *writeAnswer = BoolToInt(false);
- return S_OK;
- }
-
- if (destFileInfo.IsDir())
- {
- RINOK(MessageError("can not replace folder with file with same name", destPathSys));
- *writeAnswer = BoolToInt(false);
- return S_OK;
- }
-
- switch (OverwriteMode)
- {
- case NExtract::NOverwriteMode::kSkip:
- return S_OK;
- case NExtract::NOverwriteMode::kAsk:
- {
- Int32 overwriteResult;
- UString destPathSpec = destPath;
- int slashPos = destPathSpec.ReverseFind_PathSepar();
- destPathSpec.DeleteFrom(slashPos + 1);
- destPathSpec += fs2us(destFileInfo.Name);
-
- RINOK(AskOverwrite(
- destPathSpec,
- &destFileInfo.MTime, &destFileInfo.Size,
- srcPath,
- srcTime, srcSize,
- &overwriteResult));
-
- switch (overwriteResult)
- {
- case NOverwriteAnswer::kCancel: return E_ABORT;
- case NOverwriteAnswer::kNo: return S_OK;
- case NOverwriteAnswer::kNoToAll: OverwriteMode = NExtract::NOverwriteMode::kSkip; return S_OK;
- case NOverwriteAnswer::kYes: break;
- case NOverwriteAnswer::kYesToAll: OverwriteMode = NExtract::NOverwriteMode::kOverwrite; break;
- case NOverwriteAnswer::kAutoRename: OverwriteMode = NExtract::NOverwriteMode::kRename; break;
- default:
- return E_FAIL;
- }
- }
- }
-
- if (OverwriteMode == NExtract::NOverwriteMode::kRename)
- {
- if (!AutoRenamePath(destPathSys))
- {
- RINOK(MessageError("can not create name for file", destPathSys));
- return E_ABORT;
- }
- destPathResultTemp = fs2us(destPathSys);
- }
- else
- {
- if (NFind::DoesFileExist(destPathSys))
- if (!NDir::DeleteFileAlways(destPathSys))
- if (GetLastError() != ERROR_FILE_NOT_FOUND)
- {
- RINOK(MessageError("can not delete output file", destPathSys));
- return E_ABORT;
- }
- }
- }
- *writeAnswer = BoolToInt(true);
- return StringToBstr(destPathResultTemp, destPathResult);
-}
-
-
-STDMETHODIMP CExtractCallbackImp::UseExtractToStream(Int32 *res)
-{
- *res = BoolToInt(StreamMode);
- return S_OK;
-}
-
-static HRESULT GetTime(IGetProp *getProp, PROPID propID, FILETIME &ft, bool &ftDefined)
-{
- ftDefined = false;
- NCOM::CPropVariant prop;
- RINOK(getProp->GetProp(propID, &prop));
- if (prop.vt == VT_FILETIME)
- {
- ft = prop.filetime;
- ftDefined = (ft.dwHighDateTime != 0 || ft.dwLowDateTime != 0);
- }
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-
-static HRESULT GetItemBoolProp(IGetProp *getProp, PROPID propID, bool &result)
-{
- NCOM::CPropVariant prop;
- result = false;
- RINOK(getProp->GetProp(propID, &prop));
- if (prop.vt == VT_BOOL)
- result = VARIANT_BOOLToBool(prop.boolVal);
- else if (prop.vt != VT_EMPTY)
- return E_FAIL;
- return S_OK;
-}
-
-
-STDMETHODIMP CExtractCallbackImp::GetStream7(const wchar_t *name,
- Int32 isDir,
- ISequentialOutStream **outStream, Int32 askExtractMode,
- IGetProp *getProp)
-{
- COM_TRY_BEGIN
- *outStream = 0;
- _newVirtFileWasAdded = false;
- _hashStreamWasUsed = false;
- _needUpdateStat = false;
-
- if (_hashStream)
- _hashStreamSpec->ReleaseStream();
-
- GetItemBoolProp(getProp, kpidIsAltStream, _isAltStream);
-
- if (!ProcessAltStreams && _isAltStream)
- return S_OK;
-
- _filePath = name;
- _isFolder = IntToBool(isDir);
- _curSize = 0;
- _curSizeDefined = false;
-
- UInt64 size = 0;
- bool sizeDefined;
- {
- NCOM::CPropVariant prop;
- RINOK(getProp->GetProp(kpidSize, &prop));
- sizeDefined = ConvertPropVariantToUInt64(prop, size);
- }
-
- if (sizeDefined)
- {
- _curSize = size;
- _curSizeDefined = true;
- }
-
- if (askExtractMode != NArchive::NExtract::NAskMode::kExtract &&
- askExtractMode != NArchive::NExtract::NAskMode::kTest)
- return S_OK;
-
- _needUpdateStat = true;
-
- CMyComPtr<ISequentialOutStream> outStreamLoc;
-
- if (VirtFileSystem && askExtractMode == NArchive::NExtract::NAskMode::kExtract)
- {
- CVirtFile &file = VirtFileSystemSpec->AddNewFile();
- _newVirtFileWasAdded = true;
- file.Name = name;
- file.IsDir = IntToBool(isDir);
- file.IsAltStream = _isAltStream;
- file.Size = 0;
-
- RINOK(GetTime(getProp, kpidCTime, file.CTime, file.CTimeDefined));
- RINOK(GetTime(getProp, kpidATime, file.ATime, file.ATimeDefined));
- RINOK(GetTime(getProp, kpidMTime, file.MTime, file.MTimeDefined));
-
- NCOM::CPropVariant prop;
- RINOK(getProp->GetProp(kpidAttrib, &prop));
- if (prop.vt == VT_UI4)
- {
- file.Attrib = prop.ulVal;
- file.AttribDefined = true;
- }
- // else if (isDir) file.Attrib = FILE_ATTRIBUTE_DIRECTORY;
-
- file.ExpectedSize = 0;
- if (sizeDefined)
- file.ExpectedSize = size;
- outStreamLoc = VirtFileSystem;
- }
-
- if (_hashStream)
- {
- {
- _hashStreamSpec->SetStream(outStreamLoc);
- outStreamLoc = _hashStream;
- _hashStreamSpec->Init(true);
- _hashStreamWasUsed = true;
- }
- }
-
- if (outStreamLoc)
- *outStream = outStreamLoc.Detach();
- return S_OK;
- COM_TRY_END
-}
-
-STDMETHODIMP CExtractCallbackImp::PrepareOperation7(Int32 askExtractMode)
-{
- COM_TRY_BEGIN
- _needUpdateStat = (
- askExtractMode == NArchive::NExtract::NAskMode::kExtract ||
- askExtractMode == NArchive::NExtract::NAskMode::kTest);
-
- /*
- _extractMode = false;
- switch (askExtractMode)
- {
- case NArchive::NExtract::NAskMode::kExtract:
- if (_testMode)
- askExtractMode = NArchive::NExtract::NAskMode::kTest;
- else
- _extractMode = true;
- break;
- };
- */
- return SetCurrentFilePath2(_filePath);
- COM_TRY_END
-}
-
-STDMETHODIMP CExtractCallbackImp::SetOperationResult7(Int32 opRes, Int32 encrypted)
-{
- COM_TRY_BEGIN
- if (VirtFileSystem && _newVirtFileWasAdded)
- {
- // FIXME: probably we must request file size from VirtFileSystem
- // _curSize = VirtFileSystem->GetLastFileSize()
- // _curSizeDefined = true;
- RINOK(VirtFileSystemSpec->CloseMemFile());
- }
- if (_hashStream && _hashStreamWasUsed)
- {
- _hashStreamSpec->_hash->Final(_isFolder, _isAltStream, _filePath);
- _curSize = _hashStreamSpec->GetSize();
- _curSizeDefined = true;
- _hashStreamSpec->ReleaseStream();
- _hashStreamWasUsed = false;
- }
- else if (_hashCalc && _needUpdateStat)
- {
- _hashCalc->SetSize(_curSize);
- _hashCalc->Final(_isFolder, _isAltStream, _filePath);
- }
- return SetOperationResult(opRes, encrypted);
- COM_TRY_END
-}
-
-
-static const size_t k_SizeT_MAX = (size_t)((size_t)0 - 1);
-
-static const UInt32 kBlockSize = ((UInt32)1 << 31);
-
-STDMETHODIMP CVirtFileSystem::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
- if (processedSize)
- *processedSize = 0;
- if (size == 0)
- return S_OK;
- if (!_fileMode)
- {
- CVirtFile &file = Files.Back();
- size_t rem = file.Data.Size() - (size_t)file.Size;
- bool useMem = true;
- if (rem < size)
- {
- UInt64 b = 0;
- if (file.Data.Size() == 0)
- b = file.ExpectedSize;
- UInt64 a = file.Size + size;
- if (b < a)
- b = a;
- a = (UInt64)file.Data.Size() * 2;
- if (b < a)
- b = a;
- useMem = false;
- if (b <= k_SizeT_MAX && b <= MaxTotalAllocSize)
- useMem = file.Data.ReAlloc_KeepData((size_t)b, (size_t)file.Size);
- }
- if (useMem)
- {
- memcpy(file.Data + file.Size, data, size);
- file.Size += size;
- if (processedSize)
- *processedSize = (UInt32)size;
- return S_OK;
- }
- _fileMode = true;
- }
- RINOK(FlushToDisk(false));
- return _outFileStream->Write(data, size, processedSize);
-}
-
-HRESULT CVirtFileSystem::FlushToDisk(bool closeLast)
-{
- if (!_outFileStream)
- {
- _outFileStreamSpec = new COutFileStream;
- _outFileStream = _outFileStreamSpec;
- }
- while (_numFlushed < Files.Size())
- {
- const CVirtFile &file = Files[_numFlushed];
- const FString path = DirPrefix + us2fs(Get_Correct_FsFile_Name(file.Name));
- if (!_fileIsOpen)
- {
- if (!_outFileStreamSpec->Create(path, false))
- {
- _outFileStream.Release();
- return E_FAIL;
- // MessageBoxMyError(UString("Can't create file ") + fs2us(tempFilePath));
- }
- _fileIsOpen = true;
- RINOK(WriteStream(_outFileStream, file.Data, (size_t)file.Size));
- }
- if (_numFlushed == Files.Size() - 1 && !closeLast)
- break;
- if (file.CTimeDefined ||
- file.ATimeDefined ||
- file.MTimeDefined)
- _outFileStreamSpec->SetTime(
- file.CTimeDefined ? &file.CTime : NULL,
- file.ATimeDefined ? &file.ATime : NULL,
- file.MTimeDefined ? &file.MTime : NULL);
- _outFileStreamSpec->Close();
- _numFlushed++;
- _fileIsOpen = false;
- if (file.AttribDefined)
- NDir::SetFileAttrib_PosixHighDetect(path, file.Attrib);
- }
- return S_OK;
-}
-
-#endif
+// ExtractCallback.cpp
+
+#include "StdAfx.h"
+
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/Lang.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../Common/FilePathAutoRename.h"
+#include "../../Common/StreamUtils.h"
+#include "../Common/ExtractingFilePath.h"
+
+#ifndef Z7_SFX
+#include "../Common/ZipRegistry.h"
+#endif
+
+#include "../GUI/ExtractRes.h"
+#include "resourceGui.h"
+
+#include "ExtractCallback.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OverwriteDialog.h"
+#ifndef Z7_NO_CRYPTO
+#include "PasswordDialog.h"
+#endif
+#include "PropertyName.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+CExtractCallbackImp::~CExtractCallbackImp() {}
+
+void CExtractCallbackImp::Init()
+{
+ _lang_Extracting = LangString(IDS_PROGRESS_EXTRACTING);
+ _lang_Testing = LangString(IDS_PROGRESS_TESTING);
+ _lang_Skipping = LangString(IDS_PROGRESS_SKIPPING);
+ _lang_Reading = "Reading";
+
+ NumArchiveErrors = 0;
+ ThereAreMessageErrors = false;
+ #ifndef Z7_SFX
+ NumFolders = NumFiles = 0;
+ NeedAddFile = false;
+ #endif
+}
+
+void CExtractCallbackImp::AddError_Message(LPCWSTR s)
+{
+ ThereAreMessageErrors = true;
+ ProgressDialog->Sync.AddError_Message(s);
+}
+
+#ifndef Z7_SFX
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetNumFiles(UInt64 numFiles))
+{
+ #ifdef Z7_SFX
+ UNUSED_VAR(numFiles)
+ #else
+ ProgressDialog->Sync.Set_NumFilesTotal(numFiles);
+ #endif
+ return S_OK;
+}
+
+#endif
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetTotal(UInt64 total))
+{
+ ProgressDialog->Sync.Set_NumBytesTotal(total);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetCompleted(const UInt64 *value))
+{
+ return ProgressDialog->Sync.Set_NumBytesCur(value);
+}
+
+HRESULT CExtractCallbackImp::Open_CheckBreak()
+{
+ return ProgressDialog->Sync.CheckStop();
+}
+
+HRESULT CExtractCallbackImp::Open_SetTotal(const UInt64 *files, const UInt64 *bytes)
+{
+ HRESULT res = S_OK;
+ if (!MultiArcMode)
+ {
+ if (files)
+ {
+ _totalFilesDefined = true;
+ // res = ProgressDialog->Sync.Set_NumFilesTotal(*files);
+ }
+ else
+ _totalFilesDefined = false;
+
+ if (bytes)
+ {
+ _totalBytesDefined = true;
+ ProgressDialog->Sync.Set_NumBytesTotal(*bytes);
+ }
+ else
+ _totalBytesDefined = false;
+ }
+
+ return res;
+}
+
+HRESULT CExtractCallbackImp::Open_SetCompleted(const UInt64 *files, const UInt64 *bytes)
+{
+ if (!MultiArcMode)
+ {
+ if (files)
+ {
+ ProgressDialog->Sync.Set_NumFilesCur(*files);
+ }
+
+ if (bytes)
+ {
+ }
+ }
+
+ return ProgressDialog->Sync.CheckStop();
+}
+
+HRESULT CExtractCallbackImp::Open_Finished()
+{
+ return ProgressDialog->Sync.CheckStop();
+}
+
+#ifndef Z7_NO_CRYPTO
+
+HRESULT CExtractCallbackImp::Open_CryptoGetTextPassword(BSTR *password)
+{
+ return CryptoGetTextPassword(password);
+}
+
+/*
+HRESULT CExtractCallbackImp::Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password)
+{
+ passwordIsDefined = PasswordIsDefined;
+ password = Password;
+ return S_OK;
+}
+
+bool CExtractCallbackImp::Open_WasPasswordAsked()
+{
+ return PasswordWasAsked;
+}
+
+void CExtractCallbackImp::Open_Clear_PasswordWasAsked_Flag()
+{
+ PasswordWasAsked = false;
+}
+*/
+
+#endif
+
+
+#ifndef Z7_SFX
+Z7_COM7F_IMF(CExtractCallbackImp::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ ProgressDialog->Sync.Set_Ratio(inSize, outSize);
+ return S_OK;
+}
+#endif
+
+/*
+Z7_COM7F_IMF(CExtractCallbackImp::SetTotalFiles(UInt64 total)
+{
+ ProgressDialog->Sync.SetNumFilesTotal(total);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetCompletedFiles(const UInt64 *value)
+{
+ if (value != NULL)
+ ProgressDialog->Sync.SetNumFilesCur(*value);
+ return S_OK;
+}
+*/
+
+Z7_COM7F_IMF(CExtractCallbackImp::AskOverwrite(
+ const wchar_t *existName, const FILETIME *existTime, const UInt64 *existSize,
+ const wchar_t *newName, const FILETIME *newTime, const UInt64 *newSize,
+ Int32 *answer))
+{
+ COverwriteDialog dialog;
+
+ dialog.OldFileInfo.SetTime(existTime);
+ dialog.OldFileInfo.SetSize(existSize);
+ dialog.OldFileInfo.Name = existName;
+
+ dialog.NewFileInfo.SetTime(newTime);
+ dialog.NewFileInfo.SetSize(newSize);
+ dialog.NewFileInfo.Name = newName;
+
+ ProgressDialog->WaitCreating();
+ INT_PTR writeAnswer = dialog.Create(*ProgressDialog);
+
+ switch (writeAnswer)
+ {
+ case IDCANCEL: *answer = NOverwriteAnswer::kCancel; return E_ABORT;
+ case IDYES: *answer = NOverwriteAnswer::kYes; break;
+ case IDNO: *answer = NOverwriteAnswer::kNo; break;
+ case IDB_YES_TO_ALL: *answer = NOverwriteAnswer::kYesToAll; break;
+ case IDB_NO_TO_ALL: *answer = NOverwriteAnswer::kNoToAll; break;
+ case IDB_AUTO_RENAME: *answer = NOverwriteAnswer::kAutoRename; break;
+ default: return E_FAIL;
+ }
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CExtractCallbackImp::PrepareOperation(const wchar_t *name, Int32 isFolder, Int32 askExtractMode, const UInt64 * /* position */))
+{
+ _isFolder = IntToBool(isFolder);
+ _currentFilePath = name;
+
+ const UString *msg = &_lang_Empty;
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract: msg = &_lang_Extracting; break;
+ case NArchive::NExtract::NAskMode::kTest: msg = &_lang_Testing; break;
+ case NArchive::NExtract::NAskMode::kSkip: msg = &_lang_Skipping; break;
+ case NArchive::NExtract::NAskMode::kReadExternal: msg = &_lang_Reading; break;
+ // default: s = "Unknown operation";
+ }
+
+ return ProgressDialog->Sync.Set_Status2(*msg, name, IntToBool(isFolder));
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::MessageError(const wchar_t *s))
+{
+ AddError_Message(s);
+ return S_OK;
+}
+
+HRESULT CExtractCallbackImp::MessageError(const char *message, const FString &path)
+{
+ ThereAreMessageErrors = true;
+ ProgressDialog->Sync.AddError_Message_Name(GetUnicodeString(message), fs2us(path));
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+Z7_COM7F_IMF(CExtractCallbackImp::ShowMessage(const wchar_t *s))
+{
+ AddError_Message(s);
+ return S_OK;
+}
+
+#endif
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s);
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s)
+{
+ s.Empty();
+
+ if (opRes == NArchive::NExtract::NOperationResult::kOK)
+ return;
+
+ #ifndef Z7_SFX
+ UINT messageID = 0;
+ #endif
+ UINT id = 0;
+
+ switch (opRes)
+ {
+ case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
+ #ifndef Z7_SFX
+ messageID = IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD;
+ #endif
+ id = IDS_EXTRACT_MSG_UNSUPPORTED_METHOD;
+ break;
+ case NArchive::NExtract::NOperationResult::kDataError:
+ #ifndef Z7_SFX
+ messageID = encrypted ?
+ IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED:
+ IDS_EXTRACT_MESSAGE_DATA_ERROR;
+ #endif
+ id = IDS_EXTRACT_MSG_DATA_ERROR;
+ break;
+ case NArchive::NExtract::NOperationResult::kCRCError:
+ #ifndef Z7_SFX
+ messageID = encrypted ?
+ IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED:
+ IDS_EXTRACT_MESSAGE_CRC_ERROR;
+ #endif
+ id = IDS_EXTRACT_MSG_CRC_ERROR;
+ break;
+ case NArchive::NExtract::NOperationResult::kUnavailable:
+ id = IDS_EXTRACT_MSG_UNAVAILABLE_DATA;
+ break;
+ case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
+ id = IDS_EXTRACT_MSG_UEXPECTED_END;
+ break;
+ case NArchive::NExtract::NOperationResult::kDataAfterEnd:
+ id = IDS_EXTRACT_MSG_DATA_AFTER_END;
+ break;
+ case NArchive::NExtract::NOperationResult::kIsNotArc:
+ id = IDS_EXTRACT_MSG_IS_NOT_ARC;
+ break;
+ case NArchive::NExtract::NOperationResult::kHeadersError:
+ id = IDS_EXTRACT_MSG_HEADERS_ERROR;
+ break;
+ case NArchive::NExtract::NOperationResult::kWrongPassword:
+ id = IDS_EXTRACT_MSG_WRONG_PSW_CLAIM;
+ break;
+ /*
+ default:
+ messageID = IDS_EXTRACT_MESSAGE_UNKNOWN_ERROR;
+ break;
+ */
+ }
+
+ UString msg;
+
+ #ifndef Z7_SFX
+ UString msgOld;
+ #ifdef Z7_LANG
+ if (id != 0)
+ LangString_OnlyFromLangFile(id, msg);
+ if (messageID != 0 && msg.IsEmpty())
+ LangString_OnlyFromLangFile(messageID, msgOld);
+ #endif
+ if (msg.IsEmpty() && !msgOld.IsEmpty())
+ s = MyFormatNew(msgOld, fileName);
+ else
+ #endif
+ {
+ if (msg.IsEmpty() && id != 0)
+ LangString(id, msg);
+ if (!msg.IsEmpty())
+ s += msg;
+ else
+ {
+ s += "Error #";
+ s.Add_UInt32((UInt32)opRes);
+ }
+
+ if (encrypted && opRes != NArchive::NExtract::NOperationResult::kWrongPassword)
+ {
+ // s += " : ";
+ // AddLangString(s, IDS_EXTRACT_MSG_ENCRYPTED);
+ s += " : ";
+ AddLangString(s, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
+ }
+ s += " : ";
+ s += fileName;
+ }
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetOperationResult(Int32 opRes, Int32 encrypted))
+{
+ switch (opRes)
+ {
+ case NArchive::NExtract::NOperationResult::kOK:
+ break;
+ default:
+ {
+ UString s;
+ SetExtractErrorMessage(opRes, encrypted, _currentFilePath, s);
+ Add_ArchiveName_Error();
+ AddError_Message(s);
+ }
+ }
+
+ #ifndef Z7_SFX
+ if (_isFolder)
+ NumFolders++;
+ else
+ NumFiles++;
+ ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
+ #endif
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::ReportExtractResult(Int32 opRes, Int32 encrypted, const wchar_t *name))
+{
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ UString s;
+ SetExtractErrorMessage(opRes, encrypted, name, s);
+ Add_ArchiveName_Error();
+ AddError_Message(s);
+ }
+ return S_OK;
+}
+
+////////////////////////////////////////
+// IExtractCallbackUI
+
+HRESULT CExtractCallbackImp::BeforeOpen(const wchar_t *name, bool /* testMode */)
+{
+ #ifndef Z7_SFX
+ RINOK(ProgressDialog->Sync.CheckStop())
+ ProgressDialog->Sync.Set_TitleFileName(name);
+ #endif
+ _currentArchivePath = name;
+ return S_OK;
+}
+
+HRESULT CExtractCallbackImp::SetCurrentFilePath2(const wchar_t *path)
+{
+ _currentFilePath = path;
+ #ifndef Z7_SFX
+ ProgressDialog->Sync.Set_FilePath(path);
+ #endif
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetCurrentFilePath(const wchar_t *path))
+{
+ #ifndef Z7_SFX
+ if (NeedAddFile)
+ NumFiles++;
+ NeedAddFile = true;
+ ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
+ #endif
+ return SetCurrentFilePath2(path);
+}
+
+#endif
+
+UString HResultToMessage(HRESULT errorCode);
+
+static const UInt32 k_ErrorFlagsIds[] =
+{
+ IDS_EXTRACT_MSG_IS_NOT_ARC,
+ IDS_EXTRACT_MSG_HEADERS_ERROR,
+ IDS_EXTRACT_MSG_HEADERS_ERROR,
+ IDS_OPEN_MSG_UNAVAILABLE_START,
+ IDS_OPEN_MSG_UNCONFIRMED_START,
+ IDS_EXTRACT_MSG_UEXPECTED_END,
+ IDS_EXTRACT_MSG_DATA_AFTER_END,
+ IDS_EXTRACT_MSG_UNSUPPORTED_METHOD,
+ IDS_OPEN_MSG_UNSUPPORTED_FEATURE,
+ IDS_EXTRACT_MSG_DATA_ERROR,
+ IDS_EXTRACT_MSG_CRC_ERROR
+};
+
+static void AddNewLineString(UString &s, const UString &m)
+{
+ s += m;
+ s.Add_LF();
+}
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+UString GetOpenArcErrorMessage(UInt32 errorFlags)
+{
+ UString s;
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_ErrorFlagsIds); i++)
+ {
+ UInt32 f = ((UInt32)1 << i);
+ if ((errorFlags & f) == 0)
+ continue;
+ UInt32 id = k_ErrorFlagsIds[i];
+ UString m = LangString(id);
+ if (m.IsEmpty())
+ continue;
+ if (f == kpv_ErrorFlags_EncryptedHeadersError)
+ {
+ m += " : ";
+ AddLangString(m, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
+ }
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += m;
+ errorFlags &= ~f;
+ }
+
+ if (errorFlags != 0)
+ {
+ char sz[16];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt32ToHex(errorFlags, sz + 2);
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += sz;
+ }
+
+ return s;
+}
+
+static void ErrorInfo_Print(UString &s, const CArcErrorInfo &er)
+{
+ UInt32 errorFlags = er.GetErrorFlags();
+ UInt32 warningFlags = er.GetWarningFlags();
+
+ if (errorFlags != 0)
+ AddNewLineString(s, GetOpenArcErrorMessage(errorFlags));
+
+ if (!er.ErrorMessage.IsEmpty())
+ AddNewLineString(s, er.ErrorMessage);
+
+ if (warningFlags != 0)
+ {
+ s += GetNameOfProperty(kpidWarningFlags, L"Warnings");
+ s += ":";
+ s.Add_LF();
+ AddNewLineString(s, GetOpenArcErrorMessage(warningFlags));
+ }
+
+ if (!er.WarningMessage.IsEmpty())
+ {
+ s += GetNameOfProperty(kpidWarning, L"Warning");
+ s += ": ";
+ s += er.WarningMessage;
+ s.Add_LF();
+ }
+}
+
+static UString GetBracedType(const wchar_t *type)
+{
+ UString s ('[');
+ s += type;
+ s += ']';
+ return s;
+}
+
+void OpenResult_GUI(UString &s, const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result);
+void OpenResult_GUI(UString &s, const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
+{
+ FOR_VECTOR (level, arcLink.Arcs)
+ {
+ const CArc &arc = arcLink.Arcs[level];
+ const CArcErrorInfo &er = arc.ErrorInfo;
+
+ if (!er.IsThereErrorOrWarning() && er.ErrorFormatIndex < 0)
+ continue;
+
+ if (s.IsEmpty())
+ {
+ s += name;
+ s.Add_LF();
+ }
+
+ if (level != 0)
+ {
+ AddNewLineString(s, arc.Path);
+ }
+
+ ErrorInfo_Print(s, er);
+
+ if (er.ErrorFormatIndex >= 0)
+ {
+ AddNewLineString(s, GetNameOfProperty(kpidWarning, L"Warning"));
+ if (arc.FormatIndex == er.ErrorFormatIndex)
+ {
+ AddNewLineString(s, LangString(IDS_IS_OPEN_WITH_OFFSET));
+ }
+ else
+ {
+ AddNewLineString(s, MyFormatNew(IDS_CANT_OPEN_AS_TYPE, GetBracedType(codecs->GetFormatNamePtr(er.ErrorFormatIndex))));
+ AddNewLineString(s, MyFormatNew(IDS_IS_OPEN_AS_TYPE, GetBracedType(codecs->GetFormatNamePtr(arc.FormatIndex))));
+ }
+ }
+ }
+
+ if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0 || result != S_OK)
+ {
+ s += name;
+ s.Add_LF();
+ if (!arcLink.Arcs.IsEmpty())
+ AddNewLineString(s, arcLink.NonOpen_ArcPath);
+
+ if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0 || result == S_FALSE)
+ {
+ UINT id = IDS_CANT_OPEN_ARCHIVE;
+ UString param;
+ if (arcLink.PasswordWasAsked)
+ id = IDS_CANT_OPEN_ENCRYPTED_ARCHIVE;
+ else if (arcLink.NonOpen_ErrorInfo.ErrorFormatIndex >= 0)
+ {
+ id = IDS_CANT_OPEN_AS_TYPE;
+ param = GetBracedType(codecs->GetFormatNamePtr(arcLink.NonOpen_ErrorInfo.ErrorFormatIndex));
+ }
+ UString s2 = MyFormatNew(id, param);
+ s2.Replace(L" ''", L"");
+ s2.Replace(L"''", L"");
+ s += s2;
+ }
+ else
+ s += HResultToMessage(result);
+
+ s.Add_LF();
+ ErrorInfo_Print(s, arcLink.NonOpen_ErrorInfo);
+ }
+
+ if (!s.IsEmpty() && s.Back() == '\n')
+ s.DeleteBack();
+}
+
+HRESULT CExtractCallbackImp::OpenResult(const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
+{
+ _currentArchivePath = name;
+ _needWriteArchivePath = true;
+
+ UString s;
+ OpenResult_GUI(s, codecs, arcLink, name, result);
+ if (!s.IsEmpty())
+ {
+ NumArchiveErrors++;
+ AddError_Message(s);
+ _needWriteArchivePath = false;
+ }
+
+ return S_OK;
+}
+
+HRESULT CExtractCallbackImp::ThereAreNoFiles()
+{
+ return S_OK;
+}
+
+void CExtractCallbackImp::Add_ArchiveName_Error()
+{
+ if (_needWriteArchivePath)
+ {
+ if (!_currentArchivePath.IsEmpty())
+ AddError_Message(_currentArchivePath);
+ _needWriteArchivePath = false;
+ }
+}
+
+HRESULT CExtractCallbackImp::ExtractResult(HRESULT result)
+{
+ if (result == S_OK)
+ return result;
+ NumArchiveErrors++;
+ if (result == E_ABORT
+ || result == HRESULT_FROM_WIN32(ERROR_DISK_FULL)
+ )
+ return result;
+
+ Add_ArchiveName_Error();
+ if (!_currentFilePath.IsEmpty())
+ MessageError(_currentFilePath);
+ MessageError(NError::MyFormatMessage(result));
+ return S_OK;
+}
+
+#ifndef Z7_NO_CRYPTO
+
+HRESULT CExtractCallbackImp::SetPassword(const UString &password)
+{
+ PasswordIsDefined = true;
+ Password = password;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::CryptoGetTextPassword(BSTR *password))
+{
+ PasswordWasAsked = true;
+ if (!PasswordIsDefined)
+ {
+ CPasswordDialog dialog;
+ #ifndef Z7_SFX
+ const bool showPassword = NExtract::Read_ShowPassword();
+ dialog.ShowPassword = showPassword;
+ #endif
+ ProgressDialog->WaitCreating();
+ if (dialog.Create(*ProgressDialog) != IDOK)
+ return E_ABORT;
+ Password = dialog.Password;
+ PasswordIsDefined = true;
+ #ifndef Z7_SFX
+ if (dialog.ShowPassword != showPassword)
+ NExtract::Save_ShowPassword(dialog.ShowPassword);
+ #endif
+ }
+ return StringToBstr(Password, password);
+}
+
+#endif
+
+#ifndef Z7_SFX
+
+Z7_COM7F_IMF(CExtractCallbackImp::AskWrite(
+ const wchar_t *srcPath, Int32 srcIsFolder,
+ const FILETIME *srcTime, const UInt64 *srcSize,
+ const wchar_t *destPath,
+ BSTR *destPathResult,
+ Int32 *writeAnswer))
+{
+ UString destPathResultTemp = destPath;
+
+ // RINOK(StringToBstr(destPath, destPathResult));
+
+ *destPathResult = NULL;
+ *writeAnswer = BoolToInt(false);
+
+ FString destPathSys = us2fs(destPath);
+ const bool srcIsFolderSpec = IntToBool(srcIsFolder);
+ CFileInfo destFileInfo;
+
+ if (destFileInfo.Find(destPathSys))
+ {
+ if (srcIsFolderSpec)
+ {
+ if (!destFileInfo.IsDir())
+ {
+ RINOK(MessageError("Cannot replace file with folder with same name", destPathSys))
+ return E_ABORT;
+ }
+ *writeAnswer = BoolToInt(false);
+ return S_OK;
+ }
+
+ if (destFileInfo.IsDir())
+ {
+ RINOK(MessageError("Cannot replace folder with file with same name", destPathSys))
+ *writeAnswer = BoolToInt(false);
+ return S_OK;
+ }
+
+ switch ((int)OverwriteMode)
+ {
+ case NExtract::NOverwriteMode::kSkip:
+ return S_OK;
+ case NExtract::NOverwriteMode::kAsk:
+ {
+ Int32 overwriteResult;
+ UString destPathSpec = destPath;
+ const int slashPos = destPathSpec.ReverseFind_PathSepar();
+ destPathSpec.DeleteFrom((unsigned)(slashPos + 1));
+ destPathSpec += fs2us(destFileInfo.Name);
+
+ RINOK(AskOverwrite(
+ destPathSpec,
+ &destFileInfo.MTime, &destFileInfo.Size,
+ srcPath,
+ srcTime, srcSize,
+ &overwriteResult))
+
+ switch (overwriteResult)
+ {
+ case NOverwriteAnswer::kCancel: return E_ABORT;
+ case NOverwriteAnswer::kNo: return S_OK;
+ case NOverwriteAnswer::kNoToAll: OverwriteMode = NExtract::NOverwriteMode::kSkip; return S_OK;
+ case NOverwriteAnswer::kYes: break;
+ case NOverwriteAnswer::kYesToAll: OverwriteMode = NExtract::NOverwriteMode::kOverwrite; break;
+ case NOverwriteAnswer::kAutoRename: OverwriteMode = NExtract::NOverwriteMode::kRename; break;
+ default:
+ return E_FAIL;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ if (OverwriteMode == NExtract::NOverwriteMode::kRename)
+ {
+ if (!AutoRenamePath(destPathSys))
+ {
+ RINOK(MessageError("Cannot create name for file", destPathSys))
+ return E_ABORT;
+ }
+ destPathResultTemp = fs2us(destPathSys);
+ }
+ else
+ {
+ if (NFind::DoesFileExist_Raw(destPathSys))
+ if (!NDir::DeleteFileAlways(destPathSys))
+ if (GetLastError() != ERROR_FILE_NOT_FOUND)
+ {
+ RINOK(MessageError("Cannot delete output file", destPathSys))
+ return E_ABORT;
+ }
+ }
+ }
+ *writeAnswer = BoolToInt(true);
+ return StringToBstr(destPathResultTemp, destPathResult);
+}
+
+
+Z7_COM7F_IMF(CExtractCallbackImp::UseExtractToStream(Int32 *res))
+{
+ *res = BoolToInt(StreamMode);
+ return S_OK;
+}
+
+static HRESULT GetTime(IGetProp *getProp, PROPID propID, FILETIME &ft, bool &ftDefined)
+{
+ ftDefined = false;
+ NCOM::CPropVariant prop;
+ RINOK(getProp->GetProp(propID, &prop))
+ if (prop.vt == VT_FILETIME)
+ {
+ ft = prop.filetime;
+ ftDefined = (ft.dwHighDateTime != 0 || ft.dwLowDateTime != 0);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+
+static HRESULT GetItemBoolProp(IGetProp *getProp, PROPID propID, bool &result)
+{
+ NCOM::CPropVariant prop;
+ result = false;
+ RINOK(getProp->GetProp(propID, &prop))
+ if (prop.vt == VT_BOOL)
+ result = VARIANT_BOOLToBool(prop.boolVal);
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CExtractCallbackImp::GetStream7(const wchar_t *name,
+ Int32 isDir,
+ ISequentialOutStream **outStream, Int32 askExtractMode,
+ IGetProp *getProp))
+{
+ COM_TRY_BEGIN
+ *outStream = NULL;
+ _newVirtFileWasAdded = false;
+ _hashStreamWasUsed = false;
+ _needUpdateStat = false;
+
+ if (_hashStream)
+ _hashStreamSpec->ReleaseStream();
+
+ GetItemBoolProp(getProp, kpidIsAltStream, _isAltStream);
+
+ if (!ProcessAltStreams && _isAltStream)
+ return S_OK;
+
+ _filePath = name;
+ _isFolder = IntToBool(isDir);
+ _curSize = 0;
+ _curSize_Defined = false;
+
+ UInt64 size = 0;
+ bool sizeDefined;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(getProp->GetProp(kpidSize, &prop))
+ sizeDefined = ConvertPropVariantToUInt64(prop, size);
+ }
+
+ if (sizeDefined)
+ {
+ _curSize = size;
+ _curSize_Defined = true;
+ }
+
+ if (askExtractMode != NArchive::NExtract::NAskMode::kExtract &&
+ askExtractMode != NArchive::NExtract::NAskMode::kTest)
+ return S_OK;
+
+ _needUpdateStat = true;
+
+ CMyComPtr<ISequentialOutStream> outStreamLoc;
+
+ if (VirtFileSystem && askExtractMode == NArchive::NExtract::NAskMode::kExtract)
+ {
+ CVirtFile &file = VirtFileSystemSpec->AddNewFile();
+ _newVirtFileWasAdded = true;
+ file.Name = name;
+ file.IsDir = IntToBool(isDir);
+ file.IsAltStream = _isAltStream;
+ file.Size = 0;
+
+ RINOK(GetTime(getProp, kpidCTime, file.CTime, file.CTimeDefined))
+ RINOK(GetTime(getProp, kpidATime, file.ATime, file.ATimeDefined))
+ RINOK(GetTime(getProp, kpidMTime, file.MTime, file.MTimeDefined))
+
+ NCOM::CPropVariant prop;
+ RINOK(getProp->GetProp(kpidAttrib, &prop))
+ if (prop.vt == VT_UI4)
+ {
+ file.Attrib = prop.ulVal;
+ file.AttribDefined = true;
+ }
+ // else if (isDir) file.Attrib = FILE_ATTRIBUTE_DIRECTORY;
+
+ file.ExpectedSize = 0;
+ if (sizeDefined)
+ file.ExpectedSize = size;
+ outStreamLoc = VirtFileSystem;
+ }
+
+ if (_hashStream)
+ {
+ {
+ _hashStreamSpec->SetStream(outStreamLoc);
+ outStreamLoc = _hashStream;
+ _hashStreamSpec->Init(true);
+ _hashStreamWasUsed = true;
+ }
+ }
+
+ if (outStreamLoc)
+ *outStream = outStreamLoc.Detach();
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::PrepareOperation7(Int32 askExtractMode))
+{
+ COM_TRY_BEGIN
+ _needUpdateStat = (
+ askExtractMode == NArchive::NExtract::NAskMode::kExtract
+ || askExtractMode == NArchive::NExtract::NAskMode::kTest
+ || askExtractMode == NArchive::NExtract::NAskMode::kReadExternal
+ );
+
+ /*
+ _extractMode = false;
+ switch (askExtractMode)
+ {
+ case NArchive::NExtract::NAskMode::kExtract:
+ if (_testMode)
+ askExtractMode = NArchive::NExtract::NAskMode::kTest;
+ else
+ _extractMode = true;
+ break;
+ };
+ */
+ return SetCurrentFilePath2(_filePath);
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CExtractCallbackImp::SetOperationResult8(Int32 opRes, Int32 encrypted, UInt64 size))
+{
+ COM_TRY_BEGIN
+ if (VirtFileSystem && _newVirtFileWasAdded)
+ {
+ // FIXME: probably we must request file size from VirtFileSystem
+ // _curSize = VirtFileSystem->GetLastFileSize()
+ // _curSize_Defined = true;
+ RINOK(VirtFileSystemSpec->CloseMemFile())
+ }
+ if (_hashStream && _hashStreamWasUsed)
+ {
+ _hashStreamSpec->_hash->Final(_isFolder, _isAltStream, _filePath);
+ _curSize = _hashStreamSpec->GetSize();
+ _curSize_Defined = true;
+ _hashStreamSpec->ReleaseStream();
+ _hashStreamWasUsed = false;
+ }
+ else if (_hashCalc && _needUpdateStat)
+ {
+ _hashCalc->SetSize(size); // (_curSize) before 21.04
+ _hashCalc->Final(_isFolder, _isAltStream, _filePath);
+ }
+ return SetOperationResult(opRes, encrypted);
+ COM_TRY_END
+}
+
+
+
+// static const UInt32 kBlockSize = ((UInt32)1 << 31);
+
+Z7_COM7F_IMF(CVirtFileSystem::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (size == 0)
+ return S_OK;
+ if (!_fileMode)
+ {
+ CVirtFile &file = Files.Back();
+ size_t rem = file.Data.Size() - (size_t)file.Size;
+ bool useMem = true;
+ if (rem < size)
+ {
+ UInt64 b = 0;
+ if (file.Data.Size() == 0)
+ b = file.ExpectedSize;
+ UInt64 a = file.Size + size;
+ if (b < a)
+ b = a;
+ a = (UInt64)file.Data.Size() * 2;
+ if (b < a)
+ b = a;
+ useMem = false;
+ const size_t b_sizet = (size_t)b;
+ if (b == b_sizet && b <= MaxTotalAllocSize)
+ useMem = file.Data.ReAlloc_KeepData(b_sizet, (size_t)file.Size);
+ }
+ if (useMem)
+ {
+ memcpy(file.Data + file.Size, data, size);
+ file.Size += size;
+ if (processedSize)
+ *processedSize = (UInt32)size;
+ return S_OK;
+ }
+ _fileMode = true;
+ }
+ RINOK(FlushToDisk(false))
+ return _outFileStream->Write(data, size, processedSize);
+}
+
+HRESULT CVirtFileSystem::FlushToDisk(bool closeLast)
+{
+ if (!_outFileStream)
+ {
+ _outFileStreamSpec = new COutFileStream;
+ _outFileStream = _outFileStreamSpec;
+ }
+ while (_numFlushed < Files.Size())
+ {
+ const CVirtFile &file = Files[_numFlushed];
+ const FString path = DirPrefix + us2fs(Get_Correct_FsFile_Name(file.Name));
+ if (!_fileIsOpen)
+ {
+ if (!_outFileStreamSpec->Create(path, false))
+ {
+ _outFileStream.Release();
+ return E_FAIL;
+ // MessageBoxMyError(UString("Can't create file ") + fs2us(tempFilePath));
+ }
+ _fileIsOpen = true;
+ RINOK(WriteStream(_outFileStream, file.Data, (size_t)file.Size))
+ }
+ if (_numFlushed == Files.Size() - 1 && !closeLast)
+ break;
+ if (file.CTimeDefined ||
+ file.ATimeDefined ||
+ file.MTimeDefined)
+ _outFileStreamSpec->SetTime(
+ file.CTimeDefined ? &file.CTime : NULL,
+ file.ATimeDefined ? &file.ATime : NULL,
+ file.MTimeDefined ? &file.MTime : NULL);
+ _outFileStreamSpec->Close();
+ _numFlushed++;
+ _fileIsOpen = false;
+ if (file.AttribDefined)
+ NDir::SetFileAttrib_PosixHighDetect(path, file.Attrib);
+ }
+ return S_OK;
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ExtractCallback.h b/CPP/7zip/UI/FileManager/ExtractCallback.h
index a6d5ae3..c2aa470 100644
--- a/CPP/7zip/UI/FileManager/ExtractCallback.h
+++ b/CPP/7zip/UI/FileManager/ExtractCallback.h
@@ -1,328 +1,310 @@
-// ExtractCallback.h
-
-#ifndef __EXTRACT_CALLBACK_H
-#define __EXTRACT_CALLBACK_H
-
-#include "../../../../C/Alloc.h"
-
-#include "../../../Common/MyCom.h"
-#include "../../../Common/StringConvert.h"
-
-#ifndef _SFX
-#include "../Agent/IFolderArchive.h"
-#endif
-
-#include "../Common/ArchiveExtractCallback.h"
-#include "../Common/ArchiveOpenCallback.h"
-
-#ifndef _NO_CRYPTO
-#include "../../IPassword.h"
-#endif
-
-#ifndef _SFX
-#include "IFolder.h"
-#endif
-
-#include "ProgressDialog2.h"
-
-#ifdef LANG
-#include "LangUtils.h"
-#endif
-
-#ifndef _SFX
-
-class CGrowBuf
-{
- Byte *_items;
- size_t _size;
-
- CLASS_NO_COPY(CGrowBuf);
-
-public:
- bool ReAlloc_KeepData(size_t newSize, size_t keepSize)
- {
- void *buf = MyAlloc(newSize);
- if (!buf)
- return false;
- if (keepSize != 0)
- memcpy(buf, _items, keepSize);
- MyFree(_items);
- _items = (Byte *)buf;
- _size = newSize;
- return true;
- }
-
- CGrowBuf(): _items(0), _size(0) {}
- ~CGrowBuf() { MyFree(_items); }
-
- operator Byte *() { return _items; }
- operator const Byte *() const { return _items; }
- size_t Size() const { return _size; }
-};
-
-struct CVirtFile
-{
- CGrowBuf Data;
-
- UInt64 Size; // real size
- UInt64 ExpectedSize; // the size from props request. 0 if unknown
-
- UString Name;
-
- bool CTimeDefined;
- bool ATimeDefined;
- bool MTimeDefined;
- bool AttribDefined;
-
- bool IsDir;
- bool IsAltStream;
-
- DWORD Attrib;
-
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
-
- CVirtFile():
- CTimeDefined(false),
- ATimeDefined(false),
- MTimeDefined(false),
- AttribDefined(false),
- IsDir(false),
- IsAltStream(false) {}
-};
-
-class CVirtFileSystem:
- public ISequentialOutStream,
- public CMyUnknownImp
-{
- UInt64 _totalAllocSize;
-
- size_t _pos;
- unsigned _numFlushed;
- bool _fileIsOpen;
- bool _fileMode;
- COutFileStream *_outFileStreamSpec;
- CMyComPtr<ISequentialOutStream> _outFileStream;
-public:
- CObjectVector<CVirtFile> Files;
- UInt64 MaxTotalAllocSize;
- FString DirPrefix;
-
- CVirtFile &AddNewFile()
- {
- if (!Files.IsEmpty())
- {
- MaxTotalAllocSize -= Files.Back().Data.Size();
- }
- return Files.AddNew();
- }
- HRESULT CloseMemFile()
- {
- if (_fileMode)
- {
- return FlushToDisk(true);
- }
- CVirtFile &file = Files.Back();
- if (file.Data.Size() != file.Size)
- {
- file.Data.ReAlloc_KeepData((size_t)file.Size, (size_t)file.Size);
- }
- return S_OK;
- }
-
- bool IsStreamInMem() const
- {
- if (_fileMode)
- return false;
- if (Files.Size() < 1 || /* Files[0].IsAltStream || */ Files[0].IsDir)
- return false;
- return true;
- }
-
- size_t GetMemStreamWrittenSize() const { return _pos; }
-
- CVirtFileSystem(): _outFileStreamSpec(NULL), MaxTotalAllocSize((UInt64)0 - 1) {}
-
- void Init()
- {
- _totalAllocSize = 0;
- _fileMode = false;
- _pos = 0;
- _numFlushed = 0;
- _fileIsOpen = false;
- }
-
- HRESULT CloseFile(const FString &path);
- HRESULT FlushToDisk(bool closeLast);
- size_t GetPos() const { return _pos; }
-
- MY_UNKNOWN_IMP
- STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-#endif
-
-class CExtractCallbackImp:
- public IExtractCallbackUI, // it includes IFolderArchiveExtractCallback
- public IOpenCallbackUI,
- public IFolderArchiveExtractCallback2,
- #ifndef _SFX
- public IFolderOperationsExtractCallback,
- public IFolderExtractToStreamCallback,
- public ICompressProgressInfo,
- #endif
- #ifndef _NO_CRYPTO
- public ICryptoGetTextPassword,
- #endif
- public CMyUnknownImp
-{
- HRESULT MessageError(const char *message, const FString &path);
- void Add_ArchiveName_Error();
-public:
- MY_QUERYINTERFACE_BEGIN2(IFolderArchiveExtractCallback)
- MY_QUERYINTERFACE_ENTRY(IFolderArchiveExtractCallback2)
- #ifndef _SFX
- MY_QUERYINTERFACE_ENTRY(IFolderOperationsExtractCallback)
- MY_QUERYINTERFACE_ENTRY(IFolderExtractToStreamCallback)
- MY_QUERYINTERFACE_ENTRY(ICompressProgressInfo)
- #endif
- #ifndef _NO_CRYPTO
- MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
- #endif
- MY_QUERYINTERFACE_END
- MY_ADDREF_RELEASE
-
- INTERFACE_IProgress(;)
- INTERFACE_IOpenCallbackUI(;)
- INTERFACE_IFolderArchiveExtractCallback(;)
- INTERFACE_IFolderArchiveExtractCallback2(;)
- // STDMETHOD(SetTotalFiles)(UInt64 total);
- // STDMETHOD(SetCompletedFiles)(const UInt64 *value);
-
- INTERFACE_IExtractCallbackUI(;)
-
- #ifndef _SFX
- // IFolderOperationsExtractCallback
- STDMETHOD(AskWrite)(
- const wchar_t *srcPath,
- Int32 srcIsFolder,
- const FILETIME *srcTime,
- const UInt64 *srcSize,
- const wchar_t *destPathRequest,
- BSTR *destPathResult,
- Int32 *writeAnswer);
- STDMETHOD(ShowMessage)(const wchar_t *message);
- STDMETHOD(SetCurrentFilePath)(const wchar_t *filePath);
- STDMETHOD(SetNumFiles)(UInt64 numFiles);
- INTERFACE_IFolderExtractToStreamCallback(;)
- STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
- #endif
-
- // ICryptoGetTextPassword
- #ifndef _NO_CRYPTO
- STDMETHOD(CryptoGetTextPassword)(BSTR *password);
- #endif
-
-private:
- UString _currentArchivePath;
- bool _needWriteArchivePath;
-
- UString _currentFilePath;
- bool _isFolder;
-
- bool _isAltStream;
- UInt64 _curSize;
- bool _curSizeDefined;
- UString _filePath;
- // bool _extractMode;
- // bool _testMode;
- bool _newVirtFileWasAdded;
- bool _needUpdateStat;
-
-
- HRESULT SetCurrentFilePath2(const wchar_t *filePath);
- void AddError_Message(LPCWSTR message);
-
- #ifndef _SFX
- bool _hashStreamWasUsed;
- COutStreamWithHash *_hashStreamSpec;
- CMyComPtr<ISequentialOutStream> _hashStream;
- IHashCalc *_hashCalc; // it's for stat in Test operation
- #endif
-
-public:
-
- #ifndef _SFX
- CVirtFileSystem *VirtFileSystemSpec;
- CMyComPtr<ISequentialOutStream> VirtFileSystem;
- #endif
-
- bool ProcessAltStreams;
-
- bool StreamMode;
-
- CProgressDialog *ProgressDialog;
- #ifndef _SFX
- UInt64 NumFolders;
- UInt64 NumFiles;
- bool NeedAddFile;
- #endif
- UInt32 NumArchiveErrors;
- bool ThereAreMessageErrors;
- NExtract::NOverwriteMode::EEnum OverwriteMode;
-
- #ifndef _NO_CRYPTO
- bool PasswordIsDefined;
- bool PasswordWasAsked;
- UString Password;
- #endif
-
-
- UString _lang_Extracting;
- UString _lang_Testing;
- UString _lang_Skipping;
- UString _lang_Empty;
-
- bool _totalFilesDefined;
- bool _totalBytesDefined;
- bool MultiArcMode;
-
- CExtractCallbackImp():
- #ifndef _NO_CRYPTO
- PasswordIsDefined(false),
- PasswordWasAsked(false),
- #endif
- OverwriteMode(NExtract::NOverwriteMode::kAsk),
- StreamMode(false),
- ProcessAltStreams(true),
-
- _totalFilesDefined(false),
- _totalBytesDefined(false),
- MultiArcMode(false)
-
- #ifndef _SFX
- , _hashCalc(NULL)
- #endif
- {}
-
- ~CExtractCallbackImp();
- void Init();
-
- #ifndef _SFX
- void SetHashCalc(IHashCalc *hashCalc) { _hashCalc = hashCalc; }
-
- void SetHashMethods(IHashCalc *hash)
- {
- if (!hash)
- return;
- _hashStreamSpec = new COutStreamWithHash;
- _hashStream = _hashStreamSpec;
- _hashStreamSpec->_hash = hash;
- }
- #endif
-
- bool IsOK() const { return NumArchiveErrors == 0 && !ThereAreMessageErrors; }
-};
-
-#endif
+// ExtractCallback.h
+
+#ifndef ZIP7_INC_EXTRACT_CALLBACK_H
+#define ZIP7_INC_EXTRACT_CALLBACK_H
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/StringConvert.h"
+
+#ifndef Z7_SFX
+#include "../Agent/IFolderArchive.h"
+#endif
+
+#include "../Common/ArchiveExtractCallback.h"
+#include "../Common/ArchiveOpenCallback.h"
+
+#ifndef Z7_NO_CRYPTO
+#include "../../IPassword.h"
+#endif
+
+#ifndef Z7_SFX
+#include "IFolder.h"
+#endif
+
+#include "ProgressDialog2.h"
+
+#ifdef Z7_LANG
+// #include "LangUtils.h"
+#endif
+
+#ifndef Z7_SFX
+
+class CGrowBuf
+{
+ Byte *_items;
+ size_t _size;
+
+ Z7_CLASS_NO_COPY(CGrowBuf)
+
+public:
+ bool ReAlloc_KeepData(size_t newSize, size_t keepSize)
+ {
+ void *buf = MyAlloc(newSize);
+ if (!buf)
+ return false;
+ if (keepSize != 0)
+ memcpy(buf, _items, keepSize);
+ MyFree(_items);
+ _items = (Byte *)buf;
+ _size = newSize;
+ return true;
+ }
+
+ CGrowBuf(): _items(NULL), _size(0) {}
+ ~CGrowBuf() { MyFree(_items); }
+
+ operator Byte *() { return _items; }
+ operator const Byte *() const { return _items; }
+ size_t Size() const { return _size; }
+};
+
+struct CVirtFile
+{
+ CGrowBuf Data;
+
+ UInt64 Size; // real size
+ UInt64 ExpectedSize; // the size from props request. 0 if unknown
+
+ UString Name;
+
+ bool CTimeDefined;
+ bool ATimeDefined;
+ bool MTimeDefined;
+ bool AttribDefined;
+
+ bool IsDir;
+ bool IsAltStream;
+
+ DWORD Attrib;
+
+ FILETIME CTime;
+ FILETIME ATime;
+ FILETIME MTime;
+
+ CVirtFile():
+ CTimeDefined(false),
+ ATimeDefined(false),
+ MTimeDefined(false),
+ AttribDefined(false),
+ IsDir(false),
+ IsAltStream(false) {}
+};
+
+
+Z7_CLASS_IMP_NOQIB_1(
+ CVirtFileSystem,
+ ISequentialOutStream
+)
+ UInt64 _totalAllocSize;
+
+ size_t _pos;
+ unsigned _numFlushed;
+ bool _fileIsOpen;
+ bool _fileMode;
+ COutFileStream *_outFileStreamSpec;
+ CMyComPtr<ISequentialOutStream> _outFileStream;
+public:
+ CObjectVector<CVirtFile> Files;
+ UInt64 MaxTotalAllocSize;
+ FString DirPrefix;
+
+ CVirtFile &AddNewFile()
+ {
+ if (!Files.IsEmpty())
+ {
+ MaxTotalAllocSize -= Files.Back().Data.Size();
+ }
+ return Files.AddNew();
+ }
+ HRESULT CloseMemFile()
+ {
+ if (_fileMode)
+ {
+ return FlushToDisk(true);
+ }
+ CVirtFile &file = Files.Back();
+ if (file.Data.Size() != file.Size)
+ {
+ file.Data.ReAlloc_KeepData((size_t)file.Size, (size_t)file.Size);
+ }
+ return S_OK;
+ }
+
+ bool IsStreamInMem() const
+ {
+ if (_fileMode)
+ return false;
+ if (Files.Size() < 1 || /* Files[0].IsAltStream || */ Files[0].IsDir)
+ return false;
+ return true;
+ }
+
+ size_t GetMemStreamWrittenSize() const { return _pos; }
+
+ CVirtFileSystem(): _outFileStreamSpec(NULL), MaxTotalAllocSize((UInt64)0 - 1) {}
+
+ void Init()
+ {
+ _totalAllocSize = 0;
+ _fileMode = false;
+ _pos = 0;
+ _numFlushed = 0;
+ _fileIsOpen = false;
+ }
+
+ HRESULT CloseFile(const FString &path);
+ HRESULT FlushToDisk(bool closeLast);
+ size_t GetPos() const { return _pos; }
+};
+
+#endif
+
+class CExtractCallbackImp Z7_final:
+ public IFolderArchiveExtractCallback,
+ /* IExtractCallbackUI:
+ before v23.00 : it included IFolderArchiveExtractCallback
+ since v23.00 : it doesn't include IFolderArchiveExtractCallback
+ */
+ public IExtractCallbackUI, // NON-COM interface since 23.00
+ public IOpenCallbackUI, // NON-COM interface
+ public IFolderArchiveExtractCallback2,
+ #ifndef Z7_SFX
+ public IFolderOperationsExtractCallback,
+ public IFolderExtractToStreamCallback,
+ public ICompressProgressInfo,
+ #endif
+ #ifndef Z7_NO_CRYPTO
+ public ICryptoGetTextPassword,
+ #endif
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IFolderArchiveExtractCallback)
+ Z7_COM_QI_ENTRY(IFolderArchiveExtractCallback2)
+ #ifndef Z7_SFX
+ Z7_COM_QI_ENTRY(IFolderOperationsExtractCallback)
+ Z7_COM_QI_ENTRY(IFolderExtractToStreamCallback)
+ Z7_COM_QI_ENTRY(ICompressProgressInfo)
+ #endif
+ #ifndef Z7_NO_CRYPTO
+ Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+ #endif
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_IMP(IExtractCallbackUI)
+ Z7_IFACE_IMP(IOpenCallbackUI)
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IFolderArchiveExtractCallback)
+ Z7_IFACE_COM7_IMP(IFolderArchiveExtractCallback2)
+ #ifndef Z7_SFX
+ Z7_IFACE_COM7_IMP(IFolderOperationsExtractCallback)
+ Z7_IFACE_COM7_IMP(IFolderExtractToStreamCallback)
+ Z7_IFACE_COM7_IMP(ICompressProgressInfo)
+ #endif
+ #ifndef Z7_NO_CRYPTO
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ #endif
+
+
+ UString _currentArchivePath;
+ bool _needWriteArchivePath;
+
+ bool _isFolder;
+ UString _currentFilePath;
+ UString _filePath;
+
+ #ifndef Z7_SFX
+ bool _needUpdateStat;
+ bool _newVirtFileWasAdded;
+ bool _isAltStream;
+ bool _curSize_Defined;
+ UInt64 _curSize;
+ // bool _extractMode;
+ // bool _testMode;
+ bool _hashStreamWasUsed;
+ COutStreamWithHash *_hashStreamSpec;
+ CMyComPtr<ISequentialOutStream> _hashStream;
+ IHashCalc *_hashCalc; // it's for stat in Test operation
+ #endif
+
+ HRESULT SetCurrentFilePath2(const wchar_t *filePath);
+ void AddError_Message(LPCWSTR message);
+ HRESULT MessageError(const char *message, const FString &path);
+ void Add_ArchiveName_Error();
+
+public:
+
+ #ifndef Z7_SFX
+ CVirtFileSystem *VirtFileSystemSpec;
+ CMyComPtr<ISequentialOutStream> VirtFileSystem;
+ #endif
+
+ bool ProcessAltStreams;
+
+ bool StreamMode;
+
+ CProgressDialog *ProgressDialog;
+ #ifndef Z7_SFX
+ UInt64 NumFolders;
+ UInt64 NumFiles;
+ bool NeedAddFile;
+ #endif
+ UInt32 NumArchiveErrors;
+ bool ThereAreMessageErrors;
+ NExtract::NOverwriteMode::EEnum OverwriteMode;
+
+ #ifndef Z7_NO_CRYPTO
+ bool PasswordIsDefined;
+ bool PasswordWasAsked;
+ UString Password;
+ #endif
+
+
+ UString _lang_Extracting;
+ UString _lang_Testing;
+ UString _lang_Skipping;
+ UString _lang_Reading;
+ UString _lang_Empty;
+
+ bool _totalFilesDefined;
+ bool _totalBytesDefined;
+ bool MultiArcMode;
+
+ CExtractCallbackImp():
+ #ifndef Z7_SFX
+ _hashCalc(NULL),
+ #endif
+ ProcessAltStreams(true),
+ StreamMode(false),
+ OverwriteMode(NExtract::NOverwriteMode::kAsk),
+ #ifndef Z7_NO_CRYPTO
+ PasswordIsDefined(false),
+ PasswordWasAsked(false),
+ #endif
+ _totalFilesDefined(false),
+ _totalBytesDefined(false),
+ MultiArcMode(false)
+ {}
+
+ ~CExtractCallbackImp();
+ void Init();
+
+ #ifndef Z7_SFX
+ void SetHashCalc(IHashCalc *hashCalc) { _hashCalc = hashCalc; }
+
+ void SetHashMethods(IHashCalc *hash)
+ {
+ if (!hash)
+ return;
+ _hashStreamSpec = new COutStreamWithHash;
+ _hashStream = _hashStreamSpec;
+ _hashStreamSpec->_hash = hash;
+ }
+ #endif
+
+ bool IsOK() const { return NumArchiveErrors == 0 && !ThereAreMessageErrors; }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FM.cpp b/CPP/7zip/UI/FileManager/FM.cpp
new file mode 100644
index 0000000..13189a7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.cpp
@@ -0,0 +1,1116 @@
+// FM.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlwapi.h>
+#else
+#include <Shlwapi.h>
+#endif
+
+#include "../../../../C/Compiler.h"
+#include "../../../../C/Alloc.h"
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/MemoryLock.h"
+#include "../../../Windows/NtCheck.h"
+#include "../../../Windows/System.h"
+
+#ifndef UNDER_CE
+#include "../../../Windows/SecurityUtils.h"
+#endif
+
+#include "../GUI/ExtractRes.h"
+
+#include "resource.h"
+
+#include "App.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+#include "Panel.h"
+#include "RegistryUtils.h"
+#include "StringUtils.h"
+#include "ViewSettings.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+// #define MAX_LOADSTRING 100
+
+extern
+bool g_RAM_Size_Defined;
+bool g_RAM_Size_Defined;
+
+extern
+bool g_LargePagesMode;
+bool g_LargePagesMode = false;
+// static bool g_OpenArchive = false;
+
+static bool g_Maximized = false;
+
+extern
+UInt64 g_RAM_Size;
+UInt64 g_RAM_Size;
+
+#ifdef _WIN32
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance;
+#endif
+
+HWND g_HWND;
+
+static UString g_MainPath;
+static UString g_ArcFormat;
+
+// HRESULT LoadGlobalCodecs();
+void FreeGlobalCodecs();
+
+#ifndef UNDER_CE
+
+extern
+DWORD g_ComCtl32Version;
+DWORD g_ComCtl32Version;
+
+static DWORD GetDllVersion(LPCTSTR dllName)
+{
+ DWORD dwVersion = 0;
+ const HMODULE hmodule = LoadLibrary(dllName);
+ if (hmodule)
+ {
+ const
+ DLLGETVERSIONPROC f_DllGetVersion = Z7_GET_PROC_ADDRESS(
+ DLLGETVERSIONPROC, hmodule,
+ "DllGetVersion");
+ if (f_DllGetVersion)
+ {
+ DLLVERSIONINFO dvi;
+ ZeroMemory(&dvi, sizeof(dvi));
+ dvi.cbSize = sizeof(dvi);
+ const HRESULT hr = f_DllGetVersion(&dvi);
+ if (SUCCEEDED(hr))
+ dwVersion = (DWORD)MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
+ }
+ FreeLibrary(hmodule);
+ }
+ return dwVersion;
+}
+
+#endif
+
+bool g_IsSmallScreen = false;
+
+extern
+bool g_LVN_ITEMACTIVATE_Support;
+bool g_LVN_ITEMACTIVATE_Support = true;
+// LVN_ITEMACTIVATE replaces both NM_DBLCLK & NM_RETURN
+// Windows 2000
+// NT/98 + IE 3 (g_ComCtl32Version >= 4.70)
+
+
+static const int kNumDefaultPanels = 1;
+static const int kSplitterWidth = 4;
+static const int kSplitterRateMax = 1 << 16;
+static const int kPanelSizeMin = 120;
+
+
+class CSplitterPos
+{
+ int _ratio; // 10000 is max
+ int _pos;
+ int _fullWidth;
+ void SetRatioFromPos(HWND hWnd)
+ { _ratio = (_pos + kSplitterWidth / 2) * kSplitterRateMax /
+ MyMax(GetWidth(hWnd), 1); }
+public:
+ int GetPos() const
+ { return _pos; }
+ int GetWidth(HWND hWnd) const
+ {
+ RECT rect;
+ ::GetClientRect(hWnd, &rect);
+ return rect.right;
+ }
+ void SetRatio(HWND hWnd, int aRatio)
+ {
+ _ratio = aRatio;
+ SetPosFromRatio(hWnd);
+ }
+ void SetPosPure(HWND hWnd, int pos)
+ {
+ int posMax = GetWidth(hWnd) - kSplitterWidth;
+ if (posMax < kPanelSizeMin * 2)
+ pos = posMax / 2;
+ else
+ {
+ if (pos > posMax - kPanelSizeMin)
+ pos = posMax - kPanelSizeMin;
+ else if (pos < kPanelSizeMin)
+ pos = kPanelSizeMin;
+ }
+ _pos = pos;
+ }
+ void SetPos(HWND hWnd, int pos)
+ {
+ _fullWidth = GetWidth(hWnd);
+ SetPosPure(hWnd, pos);
+ SetRatioFromPos(hWnd);
+ }
+ void SetPosFromRatio(HWND hWnd)
+ {
+ int fullWidth = GetWidth(hWnd);
+ if (_fullWidth != fullWidth && fullWidth != 0)
+ {
+ _fullWidth = fullWidth;
+ SetPosPure(hWnd, GetWidth(hWnd) * _ratio / kSplitterRateMax - kSplitterWidth / 2);
+ }
+ }
+};
+
+static bool g_CanChangeSplitter = false;
+static UInt32 g_SplitterPos = 0;
+static CSplitterPos g_Splitter;
+static bool g_PanelsInfoDefined = false;
+static bool g_WindowWasCreated = false;
+
+static int g_StartCaptureMousePos;
+static int g_StartCaptureSplitterPos;
+
+CApp g_App;
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+static const wchar_t * const kWindowClass = L"7-Zip::FM";
+
+#ifdef UNDER_CE
+#define WS_OVERLAPPEDWINDOW ( \
+ WS_OVERLAPPED | \
+ WS_CAPTION | \
+ WS_SYSMENU | \
+ WS_THICKFRAME | \
+ WS_MINIMIZEBOX | \
+ WS_MAXIMIZEBOX)
+#endif
+
+// FUNCTION: InitInstance(HANDLE, int)
+static BOOL InitInstance(int nCmdShow)
+{
+ CWindow wnd;
+
+ // LoadString(hInstance, IDS_CLASS, windowClass, MAX_LOADSTRING);
+
+ UString title ("7-Zip"); // LangString(IDS_APP_TITLE, 0x03000000);
+
+ /*
+ //If it is already running, then focus on the window
+ hWnd = FindWindow(windowClass, title);
+ if (hWnd)
+ {
+ SetForegroundWindow ((HWND) (((DWORD)hWnd) | 0x01));
+ return 0;
+ }
+ */
+
+ WNDCLASSW wc;
+
+ // wc.style = CS_HREDRAW | CS_VREDRAW;
+ wc.style = 0;
+ wc.lpfnWndProc = (WNDPROC) WndProc;
+ wc.cbClsExtra = 0;
+ wc.cbWndExtra = 0;
+ wc.hInstance = g_hInstance;
+ wc.hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ICON));
+
+ // wc.hCursor = LoadCursor (NULL, IDC_ARROW);
+ wc.hCursor = ::LoadCursor(NULL, IDC_SIZEWE);
+ // wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
+ wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
+
+ wc.lpszMenuName =
+ #ifdef UNDER_CE
+ 0
+ #else
+ MAKEINTRESOURCEW(IDM_MENU)
+ #endif
+ ;
+
+ wc.lpszClassName = kWindowClass;
+
+ if (MyRegisterClass(&wc) == 0)
+ return FALSE;
+
+ // RECT rect;
+ // GetClientRect(hWnd, &rect);
+
+ DWORD style = WS_OVERLAPPEDWINDOW;
+ // DWORD style = 0;
+
+ CWindowInfo info;
+ info.maximized = false;
+ int x, y, xSize, ySize;
+ x = y = xSize = ySize = CW_USEDEFAULT;
+ bool windowPosIsRead;
+ info.Read(windowPosIsRead, g_PanelsInfoDefined);
+
+ if (windowPosIsRead)
+ {
+ x = info.rect.left;
+ y = info.rect.top;
+
+ xSize = RECT_SIZE_X(info.rect);
+ ySize = RECT_SIZE_Y(info.rect);
+ }
+
+
+ if (g_PanelsInfoDefined)
+ {
+ g_SplitterPos = info.splitterPos;
+ if (info.numPanels < 1 || info.numPanels > 2)
+ info.numPanels = kNumDefaultPanels;
+ if (info.currentPanel >= 2)
+ info.currentPanel = 0;
+ }
+ else
+ {
+ info.numPanels = kNumDefaultPanels;
+ info.currentPanel = 0;
+ }
+
+ g_App.NumPanels = info.numPanels;
+ g_App.LastFocusedPanel = info.currentPanel;
+
+ if (!wnd.Create(kWindowClass, title, style,
+ x, y, xSize, ySize, NULL, NULL, g_hInstance, NULL))
+ return FALSE;
+
+ if (nCmdShow == SW_SHOWNORMAL ||
+ nCmdShow == SW_SHOW
+ #ifndef UNDER_CE
+ || nCmdShow == SW_SHOWDEFAULT
+ #endif
+ )
+ {
+ if (info.maximized)
+ nCmdShow = SW_SHOWMAXIMIZED;
+ else
+ nCmdShow = SW_SHOWNORMAL;
+ }
+
+ if (nCmdShow == SW_SHOWMAXIMIZED)
+ g_Maximized = true;
+
+ #ifndef UNDER_CE
+ WINDOWPLACEMENT placement;
+ placement.length = sizeof(placement);
+ if (wnd.GetPlacement(&placement))
+ {
+ if (windowPosIsRead)
+ placement.rcNormalPosition = info.rect;
+ placement.showCmd = (UINT)nCmdShow;
+ wnd.SetPlacement(&placement);
+ }
+ else
+ #endif
+ wnd.Show(nCmdShow);
+
+ return TRUE;
+}
+
+/*
+static void GetCommands(const UString &aCommandLine, UString &aCommands)
+{
+ UString aProgramName;
+ aCommands.Empty();
+ bool aQuoteMode = false;
+ for (int i = 0; i < aCommandLine.Length(); i++)
+ {
+ wchar_t aChar = aCommandLine[i];
+ if (aChar == L'\"')
+ aQuoteMode = !aQuoteMode;
+ else if (aChar == L' ' && !aQuoteMode)
+ {
+ if (!aQuoteMode)
+ {
+ i++;
+ break;
+ }
+ }
+ else
+ aProgramName += aChar;
+ }
+ aCommands = aCommandLine.Ptr(i);
+}
+*/
+
+#if defined(_WIN32) && !defined(_WIN64) && !defined(UNDER_CE)
+
+extern
+bool g_Is_Wow64;
+bool g_Is_Wow64;
+
+typedef BOOL (WINAPI *Func_IsWow64Process)(HANDLE, PBOOL);
+
+static void Set_Wow64()
+{
+ g_Is_Wow64 = false;
+ const
+ Func_IsWow64Process fn = Z7_GET_PROC_ADDRESS(
+ Func_IsWow64Process, GetModuleHandleA("kernel32.dll"),
+ "IsWow64Process");
+ if (fn)
+ {
+ BOOL isWow;
+ if (fn(GetCurrentProcess(), &isWow))
+ g_Is_Wow64 = (isWow != FALSE);
+ }
+}
+
+#endif
+
+#if _MSC_VER > 1400 /* && _MSC_VER <= 1900 */
+ // GetVersion was declared deprecated
+ #pragma warning(disable : 4996)
+#endif
+#ifdef __clang__
+ #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+bool IsLargePageSupported();
+bool IsLargePageSupported()
+{
+ #ifdef _WIN64
+ return true;
+ #else
+
+ DWORD v = GetVersion();
+ // low byte is major version:
+ // next byte is minor version:
+ v = ((v & 0xff) << 8) | ((v >> 8) & 0xFF);
+ return (v > 0x501);
+ // if ((Byte)v < 5) return false;
+ // if ((Byte)v > 5) return true;
+ // return ((Byte)(v >> 8) > 1);
+ /* large pages work in 5.1 (XP-32bit) if it's (g_Is_Wow64) mode;
+ but here we don't enable them in (XP-32bit). */
+ #endif
+}
+
+#ifndef UNDER_CE
+
+static void SetMemoryLock()
+{
+ if (!IsLargePageSupported())
+ return;
+ // if (ReadLockMemoryAdd())
+ NSecurity::AddLockMemoryPrivilege();
+
+ if (ReadLockMemoryEnable())
+ if (NSecurity::Get_LargePages_RiskLevel() == 0)
+ {
+ // note: child processes can inherit that Privilege
+ g_LargePagesMode = NSecurity::EnablePrivilege_LockMemory();
+ }
+}
+
+extern
+bool g_SymLink_Supported;
+bool g_SymLink_Supported = false;
+
+static void Set_SymLink_Supported()
+{
+ // g_SymLink_Supported = false;
+ const DWORD v = GetVersion();
+ // low byte is major version:
+ if ((Byte)v < 6)
+ return;
+ g_SymLink_Supported = true;
+ // if (g_SymLink_Supported)
+ {
+ NSecurity::EnablePrivilege_SymLink();
+ }
+}
+
+#endif
+
+/*
+static const int kNumSwitches = 1;
+
+namespace NKey {
+enum Enum
+{
+ kOpenArachive = 0
+};
+
+}
+
+static const CSwitchForm kSwitchForms[kNumSwitches] =
+ {
+ { L"SOA", NSwitchType::kSimple, false },
+ };
+*/
+
+// int APIENTRY WinMain2(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */, LPSTR /* lpCmdLine */, int /* nCmdShow */);
+
+static void ErrorMessage(const wchar_t *s)
+{
+ MessageBoxW(NULL, s, L"7-Zip", MB_ICONERROR);
+}
+
+static void ErrorMessage(const char *s)
+{
+ ErrorMessage(GetUnicodeString(s));
+}
+
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION ErrorMessage("Unsupported Windows version"); return 1;
+#endif
+
+static int WINAPI WinMain2(int nCmdShow)
+{
+ g_RAM_Size_Defined = NSystem::GetRamSize(g_RAM_Size);
+
+ #ifdef _WIN32
+
+ /*
+ #ifndef _WIN64
+ #ifndef UNDER_CE
+ {
+ HMODULE hMod = GetModuleHandle("Kernel32.dll");
+ if (hMod)
+ {
+ typedef BOOL (WINAPI *PSETDEP)(DWORD);
+ #define MY_PROCESS_DEP_ENABLE 1
+ PSETDEP procSet = (PSETDEP)GetProcAddress(hMod,"SetProcessDEPPolicy");
+ if (procSet)
+ procSet(MY_PROCESS_DEP_ENABLE);
+
+ typedef BOOL (WINAPI *HSI)(HANDLE, HEAP_INFORMATION_CLASS ,PVOID, SIZE_T);
+ HSI hsi = (HSI)GetProcAddress(hMod, "HeapSetInformation");
+ #define MY_HeapEnableTerminationOnCorruption ((HEAP_INFORMATION_CLASS)1)
+ if (hsi)
+ hsi(NULL, MY_HeapEnableTerminationOnCorruption, NULL, 0);
+ }
+ }
+ #endif
+ #endif
+ */
+
+ NT_CHECK
+ #ifdef Z7_LARGE_PAGES
+ SetLargePageSize();
+ #endif
+
+ #endif
+
+ #ifdef Z7_LANG
+ LoadLangOneTime();
+ #endif
+
+ InitCommonControls();
+
+ #ifndef UNDER_CE
+ g_ComCtl32Version = ::GetDllVersion(TEXT("comctl32.dll"));
+ g_LVN_ITEMACTIVATE_Support = (g_ComCtl32Version >= MAKELONG(71, 4));
+ #endif
+
+ #if defined(_WIN32) && !defined(_WIN64) && !defined(UNDER_CE)
+ Set_Wow64();
+ #endif
+
+
+ g_IsSmallScreen = !NWindows::NControl::IsDialogSizeOK(200, 200);
+
+ // OleInitialize is required for drag and drop.
+ #ifndef UNDER_CE
+ OleInitialize(NULL);
+ #endif
+ // Maybe needs CoInitializeEx also ?
+ // NCOM::CComInitializer comInitializer;
+
+ UString commandsString;
+ // MessageBoxW(NULL, GetCommandLineW(), L"", 0);
+
+ #ifdef UNDER_CE
+ commandsString = GetCommandLineW();
+ #else
+ UString programString;
+ SplitStringToTwoStrings(GetCommandLineW(), programString, commandsString);
+ #endif
+
+ commandsString.Trim();
+ UString paramString, tailString;
+ SplitStringToTwoStrings(commandsString, paramString, tailString);
+ paramString.Trim();
+ tailString.Trim();
+ if (tailString.IsPrefixedBy(L"-t"))
+ g_ArcFormat = tailString.Ptr(2);
+
+ /*
+ UStringVector switches;
+ for (;;)
+ {
+ if (tailString.IsEmpty())
+ break;
+ UString s1, s2;
+ SplitStringToTwoStrings(tailString, s1, s2);
+ if (s2.IsEmpty())
+ {
+ tailString.Trim();
+ switches.Add(tailString);
+ break;
+ }
+ s1.Trim();
+ switches.Add(s1);
+ tailString = s2;
+ }
+
+ FOR_VECTOR(i, switches)
+ {
+ const UString &sw = switches[i];
+ if (sw.IsPrefixedBy(L"-t"))
+ g_ArcFormat = sw.Ptr(2);
+ //
+ else if (sw.IsPrefixedBy(L"-stp"))
+ {
+ const wchar_t *end;
+ UInt32 val = ConvertStringToUInt32(sw.Ptr(4), &end);
+ if (*end != 0)
+ throw 111;
+ g_TypeParseLevel = val;
+ }
+ else
+ //
+ throw 112;
+ }
+ */
+
+ if (!paramString.IsEmpty())
+ {
+ g_MainPath = paramString;
+ // return WinMain2(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
+
+ // MessageBoxW(NULL, paramString, L"", 0);
+ }
+ /*
+ UStringVector commandStrings;
+ NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
+ NCommandLineParser::CParser parser(kNumSwitches);
+ try
+ {
+ parser.ParseStrings(kSwitchForms, commandStrings);
+ const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
+ if (nonSwitchStrings.Size() > 1)
+ {
+ g_MainPath = nonSwitchStrings[1];
+ // g_OpenArchive = parser[NKey::kOpenArachive].ThereIs;
+ CFileInfoW fileInfo;
+ if (FindFile(g_MainPath, fileInfo))
+ {
+ if (!fileInfo.IsDir())
+ g_OpenArchive = true;
+ }
+ }
+ }
+ catch(...) { }
+ */
+
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ SetMemoryLock();
+ Set_SymLink_Supported();
+ #endif
+
+ g_App.ReloadLangItems();
+
+ MSG msg;
+ if (!InitInstance (nCmdShow))
+ return FALSE;
+
+ // we will load Global_Codecs at first use instead.
+ /*
+ OutputDebugStringW(L"Before LoadGlobalCodecs");
+ LoadGlobalCodecs();
+ OutputDebugStringW(L"After LoadGlobalCodecs");
+ */
+
+ #ifndef _UNICODE
+ if (g_IsNT)
+ {
+ HACCEL hAccels = LoadAcceleratorsW(g_hInstance, MAKEINTRESOURCEW(IDR_ACCELERATOR1));
+ while (GetMessageW(&msg, NULL, 0, 0))
+ {
+ if (TranslateAcceleratorW(g_HWND, hAccels, &msg) == 0)
+ {
+ TranslateMessage(&msg);
+ DispatchMessageW(&msg);
+ }
+ }
+ }
+ else
+ #endif
+ {
+ HACCEL hAccels = LoadAccelerators(g_hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR1));
+ while (GetMessage(&msg, NULL, 0, 0))
+ {
+ if (TranslateAccelerator(g_HWND, hAccels, &msg) == 0)
+ {
+ // if (g_Hwnd != NULL || !IsDialogMessage(g_Hwnd, &msg))
+ // if (!IsDialogMessage(g_Hwnd, &msg))
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ }
+ }
+
+ // Destructor of g_CodecsReleaser can release DLLs.
+ // But we suppose that it's better to release DLLs here (before destructor).
+ FreeGlobalCodecs();
+
+ g_HWND = NULL;
+ #ifndef UNDER_CE
+ OleUninitialize();
+ #endif
+ return (int)msg.wParam;
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ /* lpCmdLine */, int nCmdShow)
+{
+ g_hInstance = hInstance;
+
+ try
+ {
+ try
+ {
+ #ifdef _WIN32
+ My_SetDefaultDllDirectories();
+ #endif
+ return WinMain2(nCmdShow);
+ }
+ catch (...)
+ {
+ g_ExitEventLauncher.Exit(true);
+ throw;
+ }
+ }
+ catch(const CNewException &)
+ {
+ ErrorMessage(LangString(IDS_MEM_ERROR));
+ return 1;
+ }
+ catch(const UString &s)
+ {
+ ErrorMessage(s);
+ return 1;
+ }
+ catch(const AString &s)
+ {
+ ErrorMessage(s.Ptr());
+ return 1;
+ }
+ catch(const wchar_t *s)
+ {
+ ErrorMessage(s);
+ return 1;
+ }
+ catch(const char *s)
+ {
+ ErrorMessage(s);
+ return 1;
+ }
+ catch(int v)
+ {
+ AString e ("Error: ");
+ e.Add_UInt32((unsigned)v);
+ ErrorMessage(e);
+ return 1;
+ }
+ catch(...)
+ {
+ ErrorMessage("Unknown error");
+ return 1;
+ }
+}
+
+static void SaveWindowInfo(HWND aWnd)
+{
+ CWindowInfo info;
+
+ #ifdef UNDER_CE
+
+ if (!::GetWindowRect(aWnd, &info.rect))
+ return;
+ info.maximized = g_Maximized;
+
+ #else
+
+ WINDOWPLACEMENT placement;
+ placement.length = sizeof(placement);
+ if (!::GetWindowPlacement(aWnd, &placement))
+ return;
+ info.rect = placement.rcNormalPosition;
+ info.maximized = BOOLToBool(::IsZoomed(aWnd));
+
+ #endif
+
+ info.numPanels = g_App.NumPanels;
+ info.currentPanel = g_App.LastFocusedPanel;
+ info.splitterPos = (unsigned)g_Splitter.GetPos();
+
+ info.Save();
+}
+
+static void ExecuteCommand(UINT commandID)
+{
+ CPanel::CDisableTimerProcessing disableTimerProcessing1(g_App.Panels[0]);
+ CPanel::CDisableTimerProcessing disableTimerProcessing2(g_App.Panels[1]);
+
+ switch (commandID)
+ {
+ case kMenuCmdID_Toolbar_Add: g_App.AddToArchive(); break;
+ case kMenuCmdID_Toolbar_Extract: g_App.ExtractArchives(); break;
+ case kMenuCmdID_Toolbar_Test: g_App.TestArchives(); break;
+ }
+}
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case WM_COMMAND:
+ {
+ unsigned wmId = LOWORD(wParam);
+ unsigned wmEvent = HIWORD(wParam);
+ if ((HWND) lParam != NULL && wmEvent != 0)
+ break;
+ if (wmId >= kMenuCmdID_Toolbar_Start && wmId < kMenuCmdID_Toolbar_End)
+ {
+ ExecuteCommand(wmId);
+ return 0;
+ }
+ if (OnMenuCommand(hWnd, wmId))
+ return 0;
+ break;
+ }
+ case WM_INITMENUPOPUP:
+ OnMenuActivating(hWnd, HMENU(wParam), LOWORD(lParam));
+ break;
+
+ /*
+ It doesn't help
+ case WM_EXITMENULOOP:
+ {
+ OnMenuUnActivating(hWnd);
+ break;
+ }
+ case WM_UNINITMENUPOPUP:
+ OnMenuUnActivating(hWnd, HMENU(wParam), lParam);
+ break;
+ */
+
+ case WM_CREATE:
+ {
+ g_HWND = hWnd;
+ /*
+ INITCOMMONCONTROLSEX icex;
+ icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+ icex.dwICC = ICC_BAR_CLASSES;
+ InitCommonControlsEx(&icex);
+
+ // Toolbar buttons used to create the first 4 buttons.
+ TBBUTTON tbb [ ] =
+ {
+ // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+ // {VIEW_PARENTFOLDER, kParentFolderID, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
+ // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+ {VIEW_NEWFOLDER, ID_FILE_CREATEFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
+ };
+
+ int baseID = 100;
+ NWindows::NControl::CToolBar aToolBar;
+ aToolBar.Attach(::CreateToolbarEx (hWnd,
+ WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS, // | TBSTYLE_FLAT
+ baseID + 2, 11,
+ (HINSTANCE)HINST_COMMCTRL, IDB_VIEW_SMALL_COLOR,
+ (LPCTBBUTTON)&tbb, Z7_ARRAY_SIZE(tbb),
+ 0, 0, 100, 30, sizeof (TBBUTTON)));
+ */
+ // HCURSOR cursor = ::LoadCursor(0, IDC_SIZEWE);
+ // ::SetCursor(cursor);
+
+ if (g_PanelsInfoDefined)
+ g_Splitter.SetPos(hWnd, (int)g_SplitterPos);
+ else
+ {
+ g_Splitter.SetRatio(hWnd, kSplitterRateMax / 2);
+ g_SplitterPos = (unsigned)g_Splitter.GetPos();
+ }
+
+ RECT rect;
+ ::GetClientRect(hWnd, &rect);
+ const int xSize = rect.right;
+ int xSizes[2];
+ xSizes[0] = g_Splitter.GetPos();
+ xSizes[1] = xSize - kSplitterWidth - xSizes[0];
+ if (xSizes[1] < 0)
+ xSizes[1] = 0;
+
+ g_App.CreateDragTarget();
+
+ COpenResult openRes;
+ bool needOpenArc = false;
+
+ UString fullPath = g_MainPath;
+ if (!fullPath.IsEmpty() /* && g_OpenArchive */)
+ {
+ if (!NFile::NName::IsAbsolutePath(fullPath))
+ {
+ FString fullPathF;
+ if (NFile::NName::GetFullPath(us2fs(fullPath), fullPathF))
+ fullPath = fs2us(fullPathF);
+ }
+ if (NFile::NFind::DoesFileExist_FollowLink(us2fs(fullPath)))
+ needOpenArc = true;
+ }
+
+ HRESULT res = g_App.Create(hWnd, fullPath, g_ArcFormat, xSizes,
+ needOpenArc,
+ openRes);
+
+ if (res == E_ABORT)
+ return -1;
+
+ if ((needOpenArc && !openRes.ArchiveIsOpened) || res != S_OK)
+ {
+ UString m ("Error");
+ if (res == S_FALSE || res == S_OK)
+ {
+ m = MyFormatNew(openRes.Encrypted ?
+ IDS_CANT_OPEN_ENCRYPTED_ARCHIVE :
+ IDS_CANT_OPEN_ARCHIVE,
+ fullPath);
+ }
+ else if (res != S_OK)
+ m = HResultToMessage(res);
+ if (!openRes.ErrorMessage.IsEmpty())
+ {
+ m.Add_LF();
+ m += openRes.ErrorMessage;
+ }
+ ErrorMessage(m);
+ return -1;
+ }
+
+ g_WindowWasCreated = true;
+
+ // g_SplitterPos = 0;
+
+ // ::DragAcceptFiles(hWnd, TRUE);
+ RegisterDragDrop(hWnd, g_App._dropTarget);
+
+ break;
+ }
+
+ case WM_DESTROY:
+ {
+ // ::DragAcceptFiles(hWnd, FALSE);
+ RevokeDragDrop(hWnd);
+ g_App._dropTarget.Release();
+
+ if (g_WindowWasCreated)
+ g_App.Save();
+
+ g_App.Release();
+
+ if (g_WindowWasCreated)
+ SaveWindowInfo(hWnd);
+
+ g_ExitEventLauncher.Exit(true);
+ PostQuitMessage(0);
+ break;
+ }
+
+ // case WM_MOVE: break;
+
+ case WM_LBUTTONDOWN:
+ g_StartCaptureMousePos = LOWORD(lParam);
+ g_StartCaptureSplitterPos = g_Splitter.GetPos();
+ ::SetCapture(hWnd);
+ break;
+
+ case WM_LBUTTONUP:
+ {
+ ::ReleaseCapture();
+ break;
+ }
+
+ case WM_MOUSEMOVE:
+ {
+ if ((wParam & MK_LBUTTON) != 0 && ::GetCapture() == hWnd)
+ {
+ g_Splitter.SetPos(hWnd, g_StartCaptureSplitterPos +
+ (short)LOWORD(lParam) - g_StartCaptureMousePos);
+ g_App.MoveSubWindows();
+ }
+ break;
+ }
+
+ case WM_SIZE:
+ {
+ if (g_CanChangeSplitter)
+ g_Splitter.SetPosFromRatio(hWnd);
+ else
+ {
+ g_Splitter.SetPos(hWnd, (int)g_SplitterPos );
+ g_CanChangeSplitter = true;
+ }
+
+ g_Maximized = (wParam == SIZE_MAXIMIZED) || (wParam == SIZE_MAXSHOW);
+
+ g_App.MoveSubWindows();
+ /*
+ int xSize = LOWORD(lParam);
+ int ySize = HIWORD(lParam);
+ // int xSplitter = 2;
+ int xWidth = g_SplitPos;
+ // int xSplitPos = xWidth;
+ g_Panel[0]._listView.MoveWindow(0, 0, xWidth, ySize);
+ g_Panel[1]._listView.MoveWindow(xSize - xWidth, 0, xWidth, ySize);
+ */
+ return 0;
+ // break;
+ }
+
+ case WM_SETFOCUS:
+ // g_App.SetFocus(g_App.LastFocusedPanel);
+ g_App.SetFocusToLastItem();
+ break;
+
+ /*
+ case WM_ACTIVATE:
+ {
+ int fActive = LOWORD(wParam);
+ switch (fActive)
+ {
+ case WA_INACTIVE:
+ {
+ // g_FocusIndex = g_App.LastFocusedPanel;
+ // g_App.LastFocusedPanel = g_App.GetFocusedPanelIndex();
+ // return 0;
+ }
+ }
+ break;
+ }
+ */
+
+ /*
+ case kLangWasChangedMessage:
+ MyLoadMenu();
+ return 0;
+ */
+
+ /*
+ case WM_SETTINGCHANGE:
+ break;
+ */
+
+ case WM_NOTIFY:
+ {
+ g_App.OnNotify((int)wParam, (LPNMHDR)lParam);
+ break;
+ }
+
+ /*
+ case WM_DROPFILES:
+ {
+ g_App.GetFocusedPanel().CompressDropFiles((HDROP)wParam);
+ return 0 ;
+ }
+ */
+ }
+ #ifndef _UNICODE
+ if (g_IsNT)
+ return DefWindowProcW(hWnd, message, wParam, lParam);
+ else
+ #endif
+ return DefWindowProc(hWnd, message, wParam, lParam);
+
+}
+
+static int Window_GetRealHeight(NWindows::CWindow &w)
+{
+ RECT rect;
+ w.GetWindowRect(&rect);
+ int res = RECT_SIZE_Y(rect);
+ #ifndef UNDER_CE
+ WINDOWPLACEMENT placement;
+ if (w.GetPlacement(&placement))
+ res += placement.rcNormalPosition.top;
+ #endif
+ return res;
+}
+
+void CApp::MoveSubWindows()
+{
+ HWND hWnd = _window;
+ RECT rect;
+ if (!hWnd)
+ return;
+ ::GetClientRect(hWnd, &rect);
+ int xSize = rect.right;
+ if (xSize == 0)
+ return;
+ int headerSize = 0;
+
+ #ifdef UNDER_CE
+ _commandBar.AutoSize();
+ {
+ _commandBar.Show(true); // maybe we need it for
+ headerSize += _commandBar.Height();
+ }
+ #endif
+
+ if (_toolBar)
+ {
+ _toolBar.AutoSize();
+ #ifdef UNDER_CE
+ int h2 = Window_GetRealHeight(_toolBar);
+ _toolBar.Move(0, headerSize, xSize, h2);
+ #endif
+ headerSize += Window_GetRealHeight(_toolBar);
+ }
+
+ int ySize = MyMax((int)(rect.bottom - headerSize), 0);
+
+ if (NumPanels > 1)
+ {
+ Panels[0].Move(0, headerSize, g_Splitter.GetPos(), ySize);
+ int xWidth1 = g_Splitter.GetPos() + kSplitterWidth;
+ Panels[1].Move(xWidth1, headerSize, xSize - xWidth1, ySize);
+ }
+ else
+ {
+ /*
+ int otherPanel = 1 - LastFocusedPanel;
+ if (PanelsCreated[otherPanel])
+ Panels[otherPanel].Move(0, headerSize, 0, ySize);
+ */
+ Panels[LastFocusedPanel].Move(0, headerSize, xSize, ySize);
+ }
+}
diff --git a/CPP/7zip/UI/FileManager/FM.dsp b/CPP/7zip/UI/FileManager/FM.dsp
new file mode 100644
index 0000000..1ae054d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.dsp
@@ -0,0 +1,1667 @@
+# Microsoft Developer Studio Project File - Name="FM" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=FM - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "FM.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "FM.mak" CFG="FM - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "FM - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 ReleaseU" (based on "Win32 (x86) Application")
+!MESSAGE "FM - Win32 DebugU" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "FM - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /FAcs /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zFM.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "FM - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zFM.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "FM - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"StdAfx.h" /FD /c
+# ADD CPP /nologo /Gz /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zFM.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "FM - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"StdAfx.h" /FD /GZ /c
+# ADD CPP /nologo /Gz /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /Yu"StdAfx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib Mpr.lib htmlhelp.lib Urlmon.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zFM.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "FM - Win32 Release"
+# Name "FM - Win32 Debug"
+# Name "FM - Win32 ReleaseU"
+# Name "FM - Win32 DebugU"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\7zipLogo.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\add.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ClassDefs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Copy.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Delete.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Extract.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FM.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\Move.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyWindowsNew.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Parent.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Properties.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# ADD BASE RSC /l 0x419
+# ADD RSC /l 0x409
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"StdAfx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Test.bmp
+# End Source File
+# End Group
+# Begin Group "Folders"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\AltStreamsFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\AltStreamsFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSDrives.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSDrives.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FSFolderCopy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\IFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\NetFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\NetFolder.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RootFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RootFolder.h
+# End Source File
+# End Group
+# Begin Group "Registry"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\RegistryAssociations.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryAssociations.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryPlugins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryPlugins.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RegistryUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ViewSettings.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ViewSettings.h
+# End Source File
+# End Group
+# Begin Group "Panel"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\App.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\App.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\AppState.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\EnumFormatEtc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\EnumFormatEtc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FileFolderPluginOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FileFolderPluginOpen.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Panel.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Panel.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelCopy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelCrc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelDrag.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelFolderChange.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelItemOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelKey.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelListNotify.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelOperations.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelSelect.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelSort.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PanelSplitFile.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\VerCtrl.cpp
+# End Source File
+# End Group
+# Begin Group "Dialog"
+
+# PROP Default_Filter ""
+# Begin Group "Options"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\EditPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\EditPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FoldersPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FoldersPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MenuPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MenuPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\OptionsDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SettingsPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SettingsPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SystemPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SystemPage.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\AboutDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\AboutDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\BrowseDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BrowseDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ComboDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ComboDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=CopyDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=CopyDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\DialogSize.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\EditDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\EditDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LinkDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LinkDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ListViewDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ListViewDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=MessagesDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=MessagesDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=OverwriteDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=OverwriteDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PasswordDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PasswordDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgressDialog2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgressDialog2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitDialog.h
+# End Source File
+# End Group
+# Begin Group "FM Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\HelpUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\HelpUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\LangUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgramLocation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ProgramLocation.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallback100.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallback100.h
+# End Source File
+# End Group
+# Begin Group "7-Zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\CommandBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Edit.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ImageList.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ProgressBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\PropertyPage.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ReBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Static.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\StatusBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ToolBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Window2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Window2.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\COM.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Device.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Handle.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Menu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Net.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Net.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\NtCheck.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ProcessUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SecurityUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ComTry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Defs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynamicBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Exception.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyCom.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyInitGuid.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Random.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "UI"
+
+# PROP Default_Filter ""
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CompressCall.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\CompressCall.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\StdAfx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "Agent"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Agent\Agent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\Agent.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentProxy.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\AgentProxy.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolderOpen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\ArchiveFolderOut.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\IFolderArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\UpdateCallbackAgent.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Agent\UpdateCallbackAgent.h
+# End Source File
+# End Group
+# Begin Group "Explorer"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Explorer\ContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\ContextMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\ContextMenuFlags.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\MyExplorerCommand.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\MyMessages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\MyMessages.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\RegistryContextMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\RegistryContextMenu.h
+# End Source File
+# End Group
+# Begin Group "GUI"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\GUI\HashGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\GUI\HashGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\GUI\UpdateCallbackGUI2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\GUI\UpdateCallbackGUI2.h
+# End Source File
+# End Group
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# End Group
+# Begin Group "Interface"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IPassword.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IProgress.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\PropID.h
+# End Source File
+# End Group
+# Begin Group "ArchiveCommon"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\7zFM.exe.manifest
+# End Source File
+# Begin Source File
+
+SOURCE=.\7zipLogo.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\Add2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Copy2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Delete2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Extract2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FilePlugins.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\FilePlugins.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FM.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Info.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Info2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Move2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyCom2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyLoadMenu.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\MyLoadMenu.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\OpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\OpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginInterface.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PluginLoader.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\PropertyName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\PropertyName.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SplitUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\StringUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\StringUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\SysIconUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\SysIconUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Test2.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TextPairs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TextPairs.h
+# End Source File
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/FileManager/FM.dsw b/CPP/7zip/UI/FileManager/FM.dsw
new file mode 100644
index 0000000..1c955d9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "FM"=.\FM.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/FileManager/FM.ico b/CPP/7zip/UI/FileManager/FM.ico
new file mode 100644
index 0000000..3a0a34d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.ico
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/FM.mak b/CPP/7zip/UI/FileManager/FM.mak
new file mode 100644
index 0000000..8331285
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FM.mak
@@ -0,0 +1,100 @@
+CFLAGS = $(CFLAGS) \
+ -DZ7_LANG \
+
+!IFDEF UNDER_CE
+LIBS = $(LIBS) ceshell.lib Commctrl.lib
+!ELSE
+LIBS = $(LIBS) comctl32.lib htmlhelp.lib comdlg32.lib Mpr.lib Gdi32.lib
+CFLAGS = $(CFLAGS) -DZ7_LONG_PATH -DZ7_DEVICE_FILE
+LFLAGS = $(LFLAGS) /DELAYLOAD:mpr.dll
+LIBS = $(LIBS) delayimp.lib
+!ENDIF
+
+FM_OBJS = \
+ $O\App.obj \
+ $O\BrowseDialog.obj \
+ $O\ClassDefs.obj \
+ $O\EnumFormatEtc.obj \
+ $O\ExtractCallback.obj \
+ $O\FileFolderPluginOpen.obj \
+ $O\FilePlugins.obj \
+ $O\FM.obj \
+ $O\FoldersPage.obj \
+ $O\FormatUtils.obj \
+ $O\FSFolder.obj \
+ $O\FSFolderCopy.obj \
+ $O\HelpUtils.obj \
+ $O\LangUtils.obj \
+ $O\MenuPage.obj \
+ $O\MyLoadMenu.obj \
+ $O\OpenCallback.obj \
+ $O\OptionsDialog.obj \
+ $O\Panel.obj \
+ $O\PanelCopy.obj \
+ $O\PanelCrc.obj \
+ $O\PanelDrag.obj \
+ $O\PanelFolderChange.obj \
+ $O\PanelItemOpen.obj \
+ $O\PanelItems.obj \
+ $O\PanelKey.obj \
+ $O\PanelListNotify.obj \
+ $O\PanelMenu.obj \
+ $O\PanelOperations.obj \
+ $O\PanelSelect.obj \
+ $O\PanelSort.obj \
+ $O\PanelSplitFile.obj \
+ $O\ProgramLocation.obj \
+ $O\PropertyName.obj \
+ $O\RegistryAssociations.obj \
+ $O\RegistryUtils.obj \
+ $O\RootFolder.obj \
+ $O\SplitUtils.obj \
+ $O\StringUtils.obj \
+ $O\SysIconUtils.obj \
+ $O\TextPairs.obj \
+ $O\UpdateCallback100.obj \
+ $O\ViewSettings.obj \
+ $O\AboutDialog.obj \
+ $O\ComboDialog.obj \
+ $O\CopyDialog.obj \
+ $O\EditDialog.obj \
+ $O\EditPage.obj \
+ $O\LangPage.obj \
+ $O\ListViewDialog.obj \
+ $O\MessagesDialog.obj \
+ $O\OverwriteDialog.obj \
+ $O\PasswordDialog.obj \
+ $O\ProgressDialog2.obj \
+ $O\SettingsPage.obj \
+ $O\SplitDialog.obj \
+ $O\SystemPage.obj \
+ $O\VerCtrl.obj \
+
+!IFNDEF UNDER_CE
+
+FM_OBJS = $(FM_OBJS) \
+ $O\AltStreamsFolder.obj \
+ $O\FSDrives.obj \
+ $O\LinkDialog.obj \
+ $O\NetFolder.obj \
+
+WIN_OBJS = $(WIN_OBJS) \
+ $O\FileSystem.obj \
+ $O\Net.obj \
+ $O\SecurityUtils.obj \
+
+!ENDIF
+
+C_OBJS = $(C_OBJS) \
+ $O\DllSecur.obj \
+
+AGENT_OBJS = \
+ $O\Agent.obj \
+ $O\AgentOut.obj \
+ $O\AgentProxy.obj \
+ $O\ArchiveFolder.obj \
+ $O\ArchiveFolderOpen.obj \
+ $O\ArchiveFolderOut.obj \
+ $O\UpdateCallbackAgent.obj \
+
+# we need empty line after last line above
diff --git a/CPP/7zip/UI/FileManager/FSDrives.cpp b/CPP/7zip/UI/FileManager/FSDrives.cpp
new file mode 100644
index 0000000..985d7c4
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSDrives.cpp
@@ -0,0 +1,518 @@
+// FSDrives.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/Defs.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileSystem.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "FSDrives.h"
+#include "FSFolder.h"
+#include "LangUtils.h"
+#include "SysIconUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+static const char * const kVolPrefix = "\\\\.\\";
+static const char * const kSuperPrefix = "\\\\?\\";
+
+FString CDriveInfo::GetDeviceFileIoName() const
+{
+ FString f (kVolPrefix);
+ f += Name;
+ return f;
+}
+
+struct CPhysTempBuffer
+{
+ void *buffer;
+ CPhysTempBuffer(): buffer(NULL) {}
+ ~CPhysTempBuffer() { MidFree(buffer); }
+};
+
+static HRESULT CopyFileSpec(CFSTR fromPath, CFSTR toPath, bool writeToDisk, UInt64 fileSize,
+ UInt32 bufferSize, UInt64 progressStart, IProgress *progress)
+{
+ NIO::CInFile inFile;
+ if (!inFile.Open(fromPath))
+ return GetLastError_noZero_HRESULT();
+ if (fileSize == (UInt64)(Int64)-1)
+ {
+ if (!inFile.GetLength(fileSize))
+ return GetLastError_noZero_HRESULT();
+ }
+
+ NIO::COutFile outFile;
+ if (writeToDisk)
+ {
+ if (!outFile.Open(toPath, FILE_SHARE_WRITE, OPEN_EXISTING, 0))
+ return GetLastError_noZero_HRESULT();
+ }
+ else
+ if (!outFile.Create(toPath, true))
+ return GetLastError_noZero_HRESULT();
+
+ CPhysTempBuffer tempBuffer;
+ tempBuffer.buffer = MidAlloc(bufferSize);
+ if (!tempBuffer.buffer)
+ return E_OUTOFMEMORY;
+
+ for (UInt64 pos = 0; pos < fileSize;)
+ {
+ UInt64 progressCur = progressStart + pos;
+ RINOK(progress->SetCompleted(&progressCur))
+ UInt64 rem = fileSize - pos;
+ UInt32 curSize = (UInt32)MyMin(rem, (UInt64)bufferSize);
+ UInt32 processedSize;
+ if (!inFile.Read(tempBuffer.buffer, curSize, processedSize))
+ return GetLastError_noZero_HRESULT();
+ if (processedSize == 0)
+ break;
+ curSize = processedSize;
+ if (writeToDisk)
+ {
+ const UInt32 kMask = 0x1FF;
+ curSize = (curSize + kMask) & ~kMask;
+ if (curSize > bufferSize)
+ return E_FAIL;
+ }
+
+ if (!outFile.Write(tempBuffer.buffer, curSize, processedSize))
+ return GetLastError_noZero_HRESULT();
+ if (curSize != processedSize)
+ return E_FAIL;
+ pos += curSize;
+ }
+
+ return S_OK;
+}
+
+static const Byte kProps[] =
+{
+ kpidName,
+ // kpidOutName,
+ kpidTotalSize,
+ kpidFreeSpace,
+ kpidType,
+ kpidVolumeName,
+ kpidFileSystem,
+ kpidClusterSize
+};
+
+static const char * const kDriveTypes[] =
+{
+ "Unknown"
+ , "No Root Dir"
+ , "Removable"
+ , "Fixed"
+ , "Remote"
+ , "CD-ROM"
+ , "RAM disk"
+};
+
+Z7_COM7F_IMF(CFSDrives::LoadItems())
+{
+ _drives.Clear();
+
+ FStringVector driveStrings;
+ MyGetLogicalDriveStrings(driveStrings);
+
+ FOR_VECTOR (i, driveStrings)
+ {
+ CDriveInfo di;
+
+ const FString &driveName = driveStrings[i];
+
+ di.FullSystemName = driveName;
+ if (!driveName.IsEmpty())
+ di.Name.SetFrom(driveName, driveName.Len() - 1);
+ di.ClusterSize = 0;
+ di.DriveSize = 0;
+ di.FreeSpace = 0;
+ di.DriveType = NSystem::MyGetDriveType(driveName);
+ bool needRead = true;
+
+ if (di.DriveType == DRIVE_CDROM || di.DriveType == DRIVE_REMOVABLE)
+ {
+ /*
+ DWORD dwSerialNumber;`
+ if (!::GetVolumeInformation(di.FullSystemName,
+ NULL, 0, &dwSerialNumber, NULL, NULL, NULL, 0))
+ */
+ {
+ needRead = false;
+ }
+ }
+
+ if (needRead)
+ {
+ DWORD volumeSerialNumber, maximumComponentLength, fileSystemFlags;
+ NSystem::MyGetVolumeInformation(driveName,
+ di.VolumeName,
+ &volumeSerialNumber, &maximumComponentLength, &fileSystemFlags,
+ di.FileSystemName);
+
+ NSystem::MyGetDiskFreeSpace(driveName,
+ di.ClusterSize, di.DriveSize, di.FreeSpace);
+ di.KnownSizes = true;
+ di.KnownSize = true;
+ }
+
+ _drives.Add(di);
+ }
+
+ if (_volumeMode)
+ {
+ // we must use IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS
+ for (unsigned n = 0; n < 16; n++) // why 16 ?
+ {
+ FString name ("PhysicalDrive");
+ name.Add_UInt32(n);
+
+ FString fullPath (kVolPrefix);
+ fullPath += name;
+
+ CFileInfo fi;
+ if (!fi.Find(fullPath))
+ continue;
+
+ CDriveInfo di;
+ di.Name = name;
+ di.FullSystemName = fullPath;
+ di.ClusterSize = 0;
+ di.DriveSize = fi.Size;
+ di.FreeSpace = 0;
+ di.DriveType = 0;
+
+ di.IsPhysicalDrive = true;
+ di.KnownSize = true;
+
+ _drives.Add(di);
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSDrives::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _drives.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSDrives::GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value))
+{
+ if (itemIndex >= (UInt32)_drives.Size())
+ return E_INVALIDARG;
+ NCOM::CPropVariant prop;
+ const CDriveInfo &di = _drives[itemIndex];
+ switch (propID)
+ {
+ case kpidIsDir: prop = !_volumeMode; break;
+ case kpidName: prop = fs2us(di.Name); break;
+ case kpidOutName:
+ if (!di.Name.IsEmpty() && di.Name.Back() == ':')
+ {
+ FString s = di.Name;
+ s.DeleteBack();
+ AddExt(s, itemIndex);
+ prop = fs2us(s);
+ }
+ break;
+
+ case kpidTotalSize: if (di.KnownSize) prop = di.DriveSize; break;
+ case kpidFreeSpace: if (di.KnownSizes) prop = di.FreeSpace; break;
+ case kpidClusterSize: if (di.KnownSizes) prop = di.ClusterSize; break;
+ case kpidType:
+ if (di.DriveType < Z7_ARRAY_SIZE(kDriveTypes))
+ prop = kDriveTypes[di.DriveType];
+ break;
+ case kpidVolumeName: prop = di.VolumeName; break;
+ case kpidFileSystem: prop = di.FileSystemName; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+HRESULT CFSDrives::BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder)
+{
+ *resultFolder = NULL;
+ if (_volumeMode)
+ return S_OK;
+ NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+ CMyComPtr<IFolderFolder> subFolder = fsFolderSpec;
+ FString path;
+ if (_superMode)
+ path = kSuperPrefix;
+ path += name;
+ RINOK(fsFolderSpec->Init(path))
+ *resultFolder = subFolder.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSDrives::BindToFolder(UInt32 index, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ if (index >= (UInt32)_drives.Size())
+ return E_INVALIDARG;
+ const CDriveInfo &di = _drives[index];
+ /*
+ if (_volumeMode)
+ {
+ *resultFolder = 0;
+ CPhysDriveFolder *folderSpec = new CPhysDriveFolder;
+ CMyComPtr<IFolderFolder> subFolder = folderSpec;
+ RINOK(folderSpec->Init(di.Name));
+ *resultFolder = subFolder.Detach();
+ return S_OK;
+ }
+ */
+ return BindToFolderSpec(di.FullSystemName, resultFolder);
+}
+
+Z7_COM7F_IMF(CFSDrives::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder))
+{
+ return BindToFolderSpec(us2fs(name), resultFolder);
+}
+
+Z7_COM7F_IMF(CFSDrives::BindToParentFolder(IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ return S_OK;
+}
+
+IMP_IFolderFolder_Props(CFSDrives)
+
+Z7_COM7F_IMF(CFSDrives::GetFolderProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidType: prop = "FSDrives"; break;
+ case kpidPath:
+ if (_volumeMode)
+ prop = kVolPrefix;
+ else if (_superMode)
+ prop = kSuperPrefix;
+ else
+ prop = (UString)LangString(IDS_COMPUTER) + WCHAR_PATH_SEPARATOR;
+ break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CFSDrives::GetSystemIconIndex(UInt32 index, Int32 *iconIndex))
+{
+ *iconIndex = 0;
+ const CDriveInfo &di = _drives[index];
+ if (di.IsPhysicalDrive)
+ return S_OK;
+ int iconIndexTemp;
+ if (GetRealIconIndex(di.FullSystemName, 0, iconIndexTemp) != 0)
+ {
+ *iconIndex = iconIndexTemp;
+ return S_OK;
+ }
+ return GetLastError_noZero_HRESULT();
+}
+
+void CFSDrives::AddExt(FString &s, unsigned index) const
+{
+ s.Add_Dot();
+ const CDriveInfo &di = _drives[index];
+ UString n = di.FileSystemName;
+ n.MakeLower_Ascii();
+ const char *ext;
+ if (di.DriveType == DRIVE_CDROM)
+ ext = "iso";
+ else
+ {
+ unsigned i;
+ for (i = 0; i < n.Len(); i++)
+ {
+ const wchar_t c = n[i];
+ if (c < 'a' || c > 'z')
+ break;
+ }
+ if (i != 0)
+ {
+ n.DeleteFrom(i);
+ s += us2fs(n);
+ return;
+ }
+ ext = "img";
+ }
+ /*
+ if (n.IsPrefixedBy_Ascii_NoCase("NTFS")) ext = "ntfs";
+ else if (n.IsPrefixedBy_Ascii_NoCase("UDF")) ext = "udf";
+ else if (n.IsPrefixedBy_Ascii_NoCase("exFAT")) ext = "exfat";
+ */
+ s += ext;
+}
+
+HRESULT CFSDrives::GetFileSize(unsigned index, UInt64& fileSize) const
+{
+#ifdef Z7_DEVICE_FILE
+ NIO::CInFile inFile;
+ if (!inFile.Open(_drives[index].GetDeviceFileIoName()))
+ return GetLastError_noZero_HRESULT();
+ if (inFile.SizeDefined)
+ {
+ fileSize = inFile.Size;
+ return S_OK;
+ }
+#else
+ UNUSED_VAR(index)
+#endif
+ fileSize = 0;
+ return E_FAIL;
+}
+
+Z7_COM7F_IMF(CFSDrives::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+ Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */,
+ const wchar_t *path, IFolderOperationsExtractCallback *callback))
+{
+ if (numItems == 0)
+ return S_OK;
+
+ if (moveMode)
+ return E_NOTIMPL;
+
+ if (!_volumeMode)
+ return E_NOTIMPL;
+
+ UInt64 totalSize = 0;
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const CDriveInfo &di = _drives[indices[i]];
+ if (di.KnownSize)
+ totalSize += di.DriveSize;
+ }
+ RINOK(callback->SetTotal(totalSize))
+ RINOK(callback->SetNumFiles(numItems))
+
+ FString destPath = us2fs(path);
+ if (destPath.IsEmpty())
+ return E_INVALIDARG;
+
+ bool isAltDest = NName::IsAltPathPrefix(destPath);
+ bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back()));
+
+ if (isDirectPath)
+ {
+ if (numItems > 1)
+ return E_INVALIDARG;
+ }
+
+ UInt64 completedSize = 0;
+ RINOK(callback->SetCompleted(&completedSize))
+ for (i = 0; i < numItems; i++)
+ {
+ unsigned index = indices[i];
+ const CDriveInfo &di = _drives[index];
+ FString destPath2 = destPath;
+
+ if (!isDirectPath)
+ {
+ FString destName = di.Name;
+ if (!destName.IsEmpty() && destName.Back() == ':')
+ {
+ destName.DeleteBack();
+ AddExt(destName, index);
+ }
+ destPath2 += destName;
+ }
+
+ FString srcPath = di.GetDeviceFileIoName();
+
+ UInt64 fileSize = 0;
+ if (GetFileSize(index, fileSize) != S_OK)
+ {
+ return E_FAIL;
+ }
+ if (!di.KnownSize)
+ {
+ totalSize += fileSize;
+ RINOK(callback->SetTotal(totalSize))
+ }
+
+ Int32 writeAskResult;
+ CMyComBSTR destPathResult;
+ RINOK(callback->AskWrite(fs2us(srcPath), BoolToInt(false), NULL, &fileSize,
+ fs2us(destPath2), &destPathResult, &writeAskResult))
+
+ if (!IntToBool(writeAskResult))
+ {
+ if (totalSize >= fileSize)
+ totalSize -= fileSize;
+ RINOK(callback->SetTotal(totalSize))
+ continue;
+ }
+
+ RINOK(callback->SetCurrentFilePath(fs2us(srcPath)))
+
+ const UInt32 kBufferSize = (4 << 20);
+ const UInt32 bufferSize = (di.DriveType == DRIVE_REMOVABLE) ? (18 << 10) * 4 : kBufferSize;
+ RINOK(CopyFileSpec(srcPath, us2fs(destPathResult), false, fileSize, bufferSize, completedSize, callback))
+ completedSize += fileSize;
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSDrives::CopyFrom(Int32 /* moveMode */, const wchar_t * /* fromFolderPath */,
+ const wchar_t * const * /* itemsPaths */, UInt32 /* numItems */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSDrives::CopyFromFile(UInt32 /* index */, const wchar_t * /* fullFilePath */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSDrives::CreateFolder(const wchar_t * /* name */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSDrives::CreateFile(const wchar_t * /* name */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSDrives::Rename(UInt32 /* index */, const wchar_t * /* newName */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSDrives::Delete(const UInt32 * /* indices */, UInt32 /* numItems */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSDrives::SetProperty(UInt32 /* index */, PROPID /* propID */,
+ const PROPVARIANT * /* value */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
diff --git a/CPP/7zip/UI/FileManager/FSDrives.h b/CPP/7zip/UI/FileManager/FSDrives.h
new file mode 100644
index 0000000..8ae831c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSDrives.h
@@ -0,0 +1,52 @@
+// FSDrives.h
+
+#ifndef ZIP7_INC_FS_DRIVES_H
+#define ZIP7_INC_FS_DRIVES_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyString.h"
+
+#include "IFolder.h"
+
+struct CDriveInfo
+{
+ FString Name;
+ FString FullSystemName;
+ UInt64 DriveSize;
+ UInt64 FreeSpace;
+ UInt64 ClusterSize;
+ // UString Type;
+ UString VolumeName;
+ UString FileSystemName;
+ UINT DriveType;
+
+ bool KnownSize;
+ bool KnownSizes;
+ bool IsPhysicalDrive;
+
+ FString GetDeviceFileIoName() const;
+ CDriveInfo(): KnownSize(false), KnownSizes(false), IsPhysicalDrive(false) {}
+};
+
+Z7_CLASS_IMP_NOQIB_3(
+ CFSDrives
+ , IFolderFolder
+ , IFolderOperations
+ , IFolderGetSystemIconIndex
+)
+ CObjectVector<CDriveInfo> _drives;
+ bool _volumeMode;
+ bool _superMode;
+
+ HRESULT BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder);
+ void AddExt(FString &s, unsigned index) const;
+ HRESULT GetFileSize(unsigned index, UInt64 &fileSize) const;
+public:
+ void Init(bool volMode = false, bool superMode = false)
+ {
+ _volumeMode = volMode;
+ _superMode = superMode;
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FSFolder.cpp b/CPP/7zip/UI/FileManager/FSFolder.cpp
new file mode 100644
index 0000000..06c572d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSFolder.cpp
@@ -0,0 +1,1200 @@
+// FSFolder.cpp
+
+#include "StdAfx.h"
+
+#ifdef __MINGW32_VERSION
+// #if !defined(_MSC_VER) && (__GNUC__) && (__GNUC__ < 10)
+// for old mingw
+#include <ddk/ntddk.h>
+#else
+#ifndef Z7_OLD_WIN_SDK
+ #if !defined(_M_IA64)
+ #include <winternl.h>
+ #endif
+#else
+typedef LONG NTSTATUS;
+typedef struct _IO_STATUS_BLOCK {
+ union {
+ NTSTATUS Status;
+ PVOID Pointer;
+ };
+ ULONG_PTR Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+#endif
+#endif
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/UTFConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "FSDrives.h"
+#include "FSFolder.h"
+
+#ifndef UNDER_CE
+#include "NetFolder.h"
+#endif
+
+#include "SysIconUtils.h"
+
+#if _WIN32_WINNT < 0x0501
+#ifdef _APISETFILE_
+// Windows SDK 8.1 defines in fileapi.h the function GetCompressedFileSizeW only if _WIN32_WINNT >= 0x0501
+// But real support version for that function is NT 3.1 (probably)
+// So we must define GetCompressedFileSizeW
+EXTERN_C_BEGIN
+WINBASEAPI DWORD WINAPI GetCompressedFileSizeW(LPCWSTR lpFileName, LPDWORD lpFileSizeHigh);
+EXTERN_C_END
+#endif
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+using namespace NDir;
+using namespace NName;
+
+#ifndef USE_UNICODE_FSTRING
+int CompareFileNames_ForFolderList(const FChar *s1, const FChar *s2)
+{
+ return CompareFileNames_ForFolderList(fs2us(s1), fs2us(s2));
+}
+#endif
+
+namespace NFsFolder {
+
+static const Byte kProps[] =
+{
+ kpidName,
+ kpidSize,
+ kpidMTime,
+ kpidCTime,
+ kpidATime,
+ #ifdef FS_SHOW_LINKS_INFO
+ kpidChangeTime,
+ #endif
+ kpidAttrib,
+ kpidPackSize,
+ #ifdef FS_SHOW_LINKS_INFO
+ kpidINode,
+ kpidLinks,
+ #endif
+ kpidComment,
+ kpidNumSubDirs,
+ kpidNumSubFiles,
+ kpidPrefix
+};
+
+HRESULT CFSFolder::Init(const FString &path /* , IFolderFolder *parentFolder */)
+{
+ // _parentFolder = parentFolder;
+ _path = path;
+
+ #ifdef _WIN32
+
+ _findChangeNotification.FindFirst(_path, false,
+ FILE_NOTIFY_CHANGE_FILE_NAME
+ | FILE_NOTIFY_CHANGE_DIR_NAME
+ | FILE_NOTIFY_CHANGE_ATTRIBUTES
+ | FILE_NOTIFY_CHANGE_SIZE
+ | FILE_NOTIFY_CHANGE_LAST_WRITE
+ /*
+ | FILE_NOTIFY_CHANGE_LAST_ACCESS
+ | FILE_NOTIFY_CHANGE_CREATION
+ | FILE_NOTIFY_CHANGE_SECURITY
+ */
+ );
+
+ if (!_findChangeNotification.IsHandleAllocated())
+ {
+ const HRESULT lastError = GetLastError_noZero_HRESULT();
+ CFindFile findFile;
+ CFileInfo fi;
+ FString path2 = _path;
+ path2 += '*'; // CHAR_ANY_MASK;
+ if (!findFile.FindFirst(path2, fi))
+ return lastError;
+ }
+
+ #endif
+
+ return S_OK;
+}
+
+
+HRESULT CFsFolderStat::Enumerate()
+{
+ if (Progress)
+ {
+ RINOK(Progress->SetCompleted(NULL))
+ }
+ Path.Add_PathSepar();
+ const unsigned len = Path.Len();
+ CEnumerator enumerator;
+ enumerator.SetDirPrefix(Path);
+ CDirEntry fi;
+ while (enumerator.Next(fi))
+ {
+ if (fi.IsDir())
+ {
+ NumFolders++;
+ Path.DeleteFrom(len);
+ Path += fi.Name;
+ RINOK(Enumerate())
+ }
+ else
+ {
+ NumFiles++;
+ Size += fi.Size;
+ }
+ }
+ return S_OK;
+}
+
+#ifndef UNDER_CE
+
+bool MyGetCompressedFileSizeW(CFSTR path, UInt64 &size);
+bool MyGetCompressedFileSizeW(CFSTR path, UInt64 &size)
+{
+ DWORD highPart;
+ DWORD lowPart = INVALID_FILE_SIZE;
+ IF_USE_MAIN_PATH
+ {
+ lowPart = ::GetCompressedFileSizeW(fs2us(path), &highPart);
+ if (lowPart != INVALID_FILE_SIZE || ::GetLastError() == NO_ERROR)
+ {
+ size = ((UInt64)highPart << 32) | lowPart;
+ return true;
+ }
+ }
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ {
+ lowPart = ::GetCompressedFileSizeW(superPath, &highPart);
+ if (lowPart != INVALID_FILE_SIZE || ::GetLastError() == NO_ERROR)
+ {
+ size = ((UInt64)highPart << 32) | lowPart;
+ return true;
+ }
+ }
+ }
+ #endif
+ return false;
+}
+
+#endif
+
+HRESULT CFSFolder::LoadSubItems(int dirItem, const FString &relPrefix)
+{
+ const unsigned startIndex = Folders.Size();
+ {
+ CEnumerator enumerator;
+ enumerator.SetDirPrefix(_path + relPrefix);
+ CDirItem fi;
+ fi.FolderStat_Defined = false;
+ fi.NumFolders = 0;
+ fi.NumFiles = 0;
+ fi.Parent = dirItem;
+
+ while (enumerator.Next(fi))
+ {
+ if (fi.IsDir())
+ {
+ fi.Size = 0;
+ if (_flatMode)
+ Folders.Add(relPrefix + fi.Name + FCHAR_PATH_SEPARATOR);
+ }
+ else
+ {
+ /*
+ fi.PackSize_Defined = true;
+ if (!MyGetCompressedFileSizeW(_path + relPrefix + fi.Name, fi.PackSize))
+ fi.PackSize = fi.Size;
+ */
+ }
+
+ #ifndef UNDER_CE
+
+ fi.Reparse.Free();
+ fi.PackSize_Defined = false;
+
+ #ifdef FS_SHOW_LINKS_INFO
+ fi.FileInfo_Defined = false;
+ fi.FileInfo_WasRequested = false;
+ fi.FileIndex = 0;
+ fi.NumLinks = 0;
+ fi.ChangeTime_Defined = false;
+ fi.ChangeTime_WasRequested = false;
+ #endif
+
+ fi.PackSize = fi.Size;
+
+ #ifdef FS_SHOW_LINKS_INFO
+ if (fi.HasReparsePoint())
+ {
+ fi.FileInfo_WasRequested = true;
+ BY_HANDLE_FILE_INFORMATION info;
+ NIO::GetReparseData(_path + relPrefix + fi.Name, fi.Reparse, &info);
+ fi.NumLinks = info.nNumberOfLinks;
+ fi.FileIndex = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
+ fi.FileInfo_Defined = true;
+ }
+ #endif
+
+ #endif // UNDER_CE
+
+ /* unsigned fileIndex = */ Files.Add(fi);
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ /*
+ if (_scanAltStreams)
+ {
+ CStreamEnumerator enumerator(_path + relPrefix + fi.Name);
+ CStreamInfo si;
+ for (;;)
+ {
+ bool found;
+ if (!enumerator.Next(si, found))
+ {
+ // if (GetLastError() == ERROR_ACCESS_DENIED)
+ // break;
+ // return E_FAIL;
+ break;
+ }
+ if (!found)
+ break;
+ if (si.IsMainStream())
+ continue;
+ CAltStream ss;
+ ss.Parent = fileIndex;
+ ss.Name = si.GetReducedName();
+ ss.Size = si.Size;
+ ss.PackSize_Defined = false;
+ ss.PackSize = si.Size;
+ Streams.Add(ss);
+ }
+ }
+ */
+ #endif
+ }
+ }
+ if (!_flatMode)
+ return S_OK;
+
+ const unsigned endIndex = Folders.Size();
+ for (unsigned i = startIndex; i < endIndex; i++)
+ LoadSubItems((int)i, Folders[i]);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::LoadItems())
+{
+ Int32 dummy;
+ WasChanged(&dummy);
+ Clear();
+ RINOK(LoadSubItems(-1, FString()))
+ _commentsAreLoaded = false;
+ return S_OK;
+}
+
+static CFSTR const kDescriptionFileName = FTEXT("descript.ion");
+
+bool CFSFolder::LoadComments()
+{
+ _comments.Clear();
+ _commentsAreLoaded = true;
+ NIO::CInFile file;
+ if (!file.Open(_path + kDescriptionFileName))
+ return false;
+ UInt64 len;
+ if (!file.GetLength(len))
+ return false;
+ if (len >= (1 << 28))
+ return false;
+ AString s;
+ char *p = s.GetBuf((unsigned)(size_t)len);
+ size_t processedSize;
+ if (!file.ReadFull(p, (unsigned)(size_t)len, processedSize))
+ return false;
+ s.ReleaseBuf_CalcLen((unsigned)(size_t)len);
+ if (processedSize != len)
+ return false;
+ file.Close();
+ UString unicodeString;
+ if (!ConvertUTF8ToUnicode(s, unicodeString))
+ return false;
+ return _comments.ReadFromString(unicodeString);
+}
+
+bool CFSFolder::SaveComments()
+{
+ AString utf;
+ {
+ UString unicode;
+ _comments.SaveToString(unicode);
+ ConvertUnicodeToUTF8(unicode, utf);
+ }
+ if (!utf.IsAscii())
+ utf.Insert(0, "\xEF\xBB\xBF" "\r\n");
+
+ FString path = _path + kDescriptionFileName;
+ // We must set same attrib. COutFile::CreateAlways can fail, if file has another attrib.
+ DWORD attrib = FILE_ATTRIBUTE_NORMAL;
+ {
+ CFileInfo fi;
+ if (fi.Find(path))
+ attrib = fi.Attrib;
+ }
+ NIO::COutFile file;
+ if (!file.CreateAlways(path, attrib))
+ return false;
+ UInt32 processed;
+ file.Write(utf, utf.Len(), processed);
+ _commentsAreLoaded = false;
+ return true;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = Files.Size() /* + Streams.Size() */;
+ return S_OK;
+}
+
+#ifdef USE_UNICODE_FSTRING
+
+Z7_COM7F_IMF(CFSFolder::GetItemPrefix(UInt32 index, const wchar_t **name, unsigned *len))
+{
+ *name = NULL;
+ *len = 0;
+ /*
+ if (index >= Files.Size())
+ index = Streams[index - Files.Size()].Parent;
+ */
+ CDirItem &fi = Files[index];
+ if (fi.Parent >= 0)
+ {
+ const FString &fo = Folders[fi.Parent];
+ USE_UNICODE_FSTRING
+ *name = fo;
+ *len = fo.Len();
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetItemName(UInt32 index, const wchar_t **name, unsigned *len))
+{
+ *name = NULL;
+ *len = 0;
+ if (index < Files.Size())
+ {
+ CDirItem &fi = Files[index];
+ *name = fi.Name;
+ *len = fi.Name.Len();
+ return S_OK;
+ }
+ else
+ {
+ // const CAltStream &ss = Streams[index - Files.Size()];
+ // *name = ss.Name;
+ // *len = ss.Name.Len();
+ //
+ // change it;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(UInt64, CFSFolder::GetItemSize(UInt32 index))
+{
+ /*
+ if (index >= Files.Size())
+ return Streams[index - Files.Size()].Size;
+ */
+ CDirItem &fi = Files[index];
+ return fi.IsDir() ? 0 : fi.Size;
+}
+
+#endif
+
+
+#ifdef FS_SHOW_LINKS_INFO
+
+bool CFSFolder::ReadFileInfo(CDirItem &di)
+{
+ di.FileInfo_WasRequested = true;
+ BY_HANDLE_FILE_INFORMATION info;
+ memset(&info, 0, sizeof(info)); // for vc6-O2
+ if (!NIO::CFileBase::GetFileInformation(_path + GetRelPath(di), &info))
+ return false;
+ di.NumLinks = info.nNumberOfLinks;
+ di.FileIndex = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
+ di.FileInfo_Defined = true;
+ return true;
+}
+
+
+EXTERN_C_BEGIN
+
+typedef struct
+{
+ LARGE_INTEGER CreationTime;
+ LARGE_INTEGER LastAccessTime;
+ LARGE_INTEGER LastWriteTime;
+ LARGE_INTEGER ChangeTime;
+ ULONG FileAttributes;
+ UInt32 Reserved; // it's expected for alignment
+}
+Z7_WIN_FILE_BASIC_INFORMATION;
+
+
+typedef enum
+{
+ Z7_WIN_FileDirectoryInformation = 1,
+ Z7_WIN_FileFullDirectoryInformation,
+ Z7_WIN_FileBothDirectoryInformation,
+ Z7_WIN_FileBasicInformation
+}
+Z7_WIN_FILE_INFORMATION_CLASS;
+
+
+#if (_WIN32_WINNT >= 0x0500) && !defined(_M_IA64)
+#define Z7_WIN_NTSTATUS NTSTATUS
+#define Z7_WIN_IO_STATUS_BLOCK IO_STATUS_BLOCK
+#else
+typedef LONG Z7_WIN_NTSTATUS;
+typedef struct
+{
+ union
+ {
+ Z7_WIN_NTSTATUS Status;
+ PVOID Pointer;
+ } DUMMYUNIONNAME;
+ ULONG_PTR Information;
+} Z7_WIN_IO_STATUS_BLOCK;
+#endif
+
+
+typedef Z7_WIN_NTSTATUS (WINAPI * Func_NtQueryInformationFile)(
+ HANDLE handle, Z7_WIN_IO_STATUS_BLOCK *io,
+ void *ptr, LONG len, Z7_WIN_FILE_INFORMATION_CLASS cls);
+
+#define MY_STATUS_SUCCESS 0
+
+EXTERN_C_END
+
+static Func_NtQueryInformationFile f_NtQueryInformationFile;
+static bool g_NtQueryInformationFile_WasRequested = false;
+
+
+void CFSFolder::ReadChangeTime(CDirItem &di)
+{
+ di.ChangeTime_WasRequested = true;
+
+ if (!g_NtQueryInformationFile_WasRequested)
+ {
+ g_NtQueryInformationFile_WasRequested = true;
+ f_NtQueryInformationFile = Z7_GET_PROC_ADDRESS(
+ Func_NtQueryInformationFile, ::GetModuleHandleW(L"ntdll.dll"),
+ "NtQueryInformationFile");
+ }
+ if (!f_NtQueryInformationFile)
+ return;
+
+ NIO::CInFile file;
+ if (!file.Open_for_ReadAttributes(_path + GetRelPath(di)))
+ return;
+ Z7_WIN_FILE_BASIC_INFORMATION fbi;
+ Z7_WIN_IO_STATUS_BLOCK IoStatusBlock;
+ const Z7_WIN_NTSTATUS status = f_NtQueryInformationFile(file.GetHandle(), &IoStatusBlock,
+ &fbi, sizeof(fbi), Z7_WIN_FileBasicInformation);
+ if (status != MY_STATUS_SUCCESS)
+ return;
+ if (IoStatusBlock.Information != sizeof(fbi))
+ return;
+ di.ChangeTime.dwLowDateTime = fbi.ChangeTime.u.LowPart;
+ di.ChangeTime.dwHighDateTime = (DWORD)fbi.ChangeTime.u.HighPart;
+ di.ChangeTime_Defined = true;
+}
+
+#endif // FS_SHOW_LINKS_INFO
+
+
+Z7_COM7F_IMF(CFSFolder::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ /*
+ if (index >= (UInt32)Files.Size())
+ {
+ CAltStream &ss = Streams[index - Files.Size()];
+ CDirItem &fi = Files[ss.Parent];
+ switch (propID)
+ {
+ case kpidIsDir: prop = false; break;
+ case kpidIsAltStream: prop = true; break;
+ case kpidName: prop = fs2us(fi.Name) + ss.Name; break;
+ case kpidSize: prop = ss.Size; break;
+ case kpidPackSize:
+ #ifdef UNDER_CE
+ prop = ss.Size;
+ #else
+ if (!ss.PackSize_Defined)
+ {
+ ss.PackSize_Defined = true;
+ if (!MyGetCompressedFileSizeW(_path + GetRelPath(fi) + us2fs(ss.Name), ss.PackSize))
+ ss.PackSize = ss.Size;
+ }
+ prop = ss.PackSize;
+ #endif
+ break;
+ case kpidComment: break;
+ default: index = ss.Parent;
+ }
+ if (index >= (UInt32)Files.Size())
+ {
+ prop.Detach(value);
+ return S_OK;
+ }
+ }
+ */
+ CDirItem &fi = Files[index];
+ switch (propID)
+ {
+ case kpidIsDir: prop = fi.IsDir(); break;
+ case kpidIsAltStream: prop = false; break;
+ case kpidName: prop = fs2us(fi.Name); break;
+ case kpidSize: if (!fi.IsDir() || fi.FolderStat_Defined) prop = fi.Size; break;
+ case kpidPackSize:
+ #ifdef UNDER_CE
+ prop = fi.Size;
+ #else
+ if (!fi.PackSize_Defined)
+ {
+ fi.PackSize_Defined = true;
+ if (fi.IsDir () || !MyGetCompressedFileSizeW(_path + GetRelPath(fi), fi.PackSize))
+ fi.PackSize = fi.Size;
+ }
+ prop = fi.PackSize;
+ #endif
+ break;
+
+ #ifdef FS_SHOW_LINKS_INFO
+
+ case kpidLinks:
+ #ifdef UNDER_CE
+ // prop = fi.NumLinks;
+ #else
+ if (!fi.FileInfo_WasRequested)
+ ReadFileInfo(fi);
+ if (fi.FileInfo_Defined)
+ prop = fi.NumLinks;
+ #endif
+ break;
+
+ case kpidINode:
+ #ifdef UNDER_CE
+ // prop = fi.FileIndex;
+ #else
+ if (!fi.FileInfo_WasRequested)
+ ReadFileInfo(fi);
+ if (fi.FileInfo_Defined)
+ prop = fi.FileIndex;
+ #endif
+ break;
+
+ case kpidChangeTime:
+ if (!fi.ChangeTime_WasRequested)
+ ReadChangeTime(fi);
+ if (fi.ChangeTime_Defined)
+ prop = fi.ChangeTime;
+ break;
+
+ #endif
+
+ case kpidAttrib: prop = (UInt32)fi.Attrib; break;
+ case kpidCTime: prop = fi.CTime; break;
+ case kpidATime: prop = fi.ATime; break;
+ case kpidMTime: prop = fi.MTime; break;
+ case kpidComment:
+ {
+ if (!_commentsAreLoaded)
+ LoadComments();
+ UString comment;
+ if (_comments.GetValue(fs2us(GetRelPath(fi)), comment))
+ {
+ int pos = comment.Find((wchar_t)4);
+ if (pos >= 0)
+ comment.DeleteFrom((unsigned)pos);
+ prop = comment;
+ }
+ break;
+ }
+ case kpidPrefix:
+ if (fi.Parent >= 0)
+ prop = fs2us(Folders[fi.Parent]);
+ break;
+ case kpidNumSubDirs: if (fi.IsDir() && fi.FolderStat_Defined) prop = fi.NumFolders; break;
+ case kpidNumSubFiles: if (fi.IsDir() && fi.FolderStat_Defined) prop = fi.NumFiles; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+
+// ---------- IArchiveGetRawProps ----------
+
+
+Z7_COM7F_IMF(CFSFolder::GetNumRawProps(UInt32 *numProps))
+{
+ *numProps = 1;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID))
+{
+ *name = NULL;
+ *propID = kpidNtReparse;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetParent(UInt32 /* index */, UInt32 * /* parent */, UInt32 * /* parentType */))
+{
+ return E_FAIL;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetRawProp(UInt32 index, PROPID propID,
+ const void **data, UInt32 *dataSize, UInt32 *propType))
+{
+ #ifdef UNDER_CE
+ UNUSED(index)
+ UNUSED(propID)
+ #endif
+
+ *data = NULL;
+ *dataSize = 0;
+ *propType = 0;
+
+ #ifndef UNDER_CE
+ if (propID == kpidNtReparse)
+ {
+ const CDirItem &fi = Files[index];
+ const CByteBuffer &buf = fi.Reparse;
+ if (buf.Size() == 0)
+ return S_OK;
+ *data = buf;
+ *dataSize = (UInt32)buf.Size();
+ *propType = NPropDataType::kRaw;
+ return S_OK;
+ }
+ #endif
+
+ return S_OK;
+}
+
+
+// returns Position of extension including '.'
+
+static inline CFSTR GetExtensionPtr(const FString &name)
+{
+ const int dotPos = name.ReverseFind_Dot();
+ return name.Ptr((dotPos < 0) ? name.Len() : (unsigned)dotPos);
+}
+
+Z7_COM7F_IMF2(Int32, CFSFolder::CompareItems(UInt32 index1, UInt32 index2, PROPID propID, Int32 /* propIsRaw */))
+{
+ /*
+ const CAltStream *ss1 = NULL;
+ const CAltStream *ss2 = NULL;
+ if (index1 >= (UInt32)Files.Size()) { ss1 = &Streams[index1 - Files.Size()]; index1 = ss1->Parent; }
+ if (index2 >= (UInt32)Files.Size()) { ss2 = &Streams[index2 - Files.Size()]; index2 = ss2->Parent; }
+ */
+ CDirItem &fi1 = Files[index1];
+ CDirItem &fi2 = Files[index2];
+
+ switch (propID)
+ {
+ case kpidName:
+ {
+ const int comp = CompareFileNames_ForFolderList(fi1.Name, fi2.Name);
+ /*
+ if (comp != 0)
+ return comp;
+ if (!ss1)
+ return ss2 ? -1 : 0;
+ if (!ss2)
+ return 1;
+ return MyStringCompareNoCase(ss1->Name, ss2->Name);
+ */
+ return comp;
+ }
+ case kpidSize:
+ return MyCompare(
+ /* ss1 ? ss1->Size : */ fi1.Size,
+ /* ss2 ? ss2->Size : */ fi2.Size);
+ case kpidAttrib: return MyCompare(fi1.Attrib, fi2.Attrib);
+ case kpidCTime: return CompareFileTime(&fi1.CTime, &fi2.CTime);
+ case kpidATime: return CompareFileTime(&fi1.ATime, &fi2.ATime);
+ case kpidMTime: return CompareFileTime(&fi1.MTime, &fi2.MTime);
+ case kpidIsDir:
+ {
+ bool isDir1 = /* ss1 ? false : */ fi1.IsDir();
+ bool isDir2 = /* ss2 ? false : */ fi2.IsDir();
+ if (isDir1 == isDir2)
+ return 0;
+ return isDir1 ? -1 : 1;
+ }
+ case kpidPackSize:
+ {
+ #ifdef UNDER_CE
+ return MyCompare(fi1.Size, fi2.Size);
+ #else
+ // PackSize can be undefined here
+ return MyCompare(
+ /* ss1 ? ss1->PackSize : */ fi1.PackSize,
+ /* ss2 ? ss2->PackSize : */ fi2.PackSize);
+ #endif
+ }
+
+ #ifdef FS_SHOW_LINKS_INFO
+ case kpidINode:
+ {
+ #ifndef UNDER_CE
+ if (!fi1.FileInfo_WasRequested) ReadFileInfo(fi1);
+ if (!fi2.FileInfo_WasRequested) ReadFileInfo(fi2);
+ return MyCompare(
+ fi1.FileIndex,
+ fi2.FileIndex);
+ #endif
+ }
+ case kpidLinks:
+ {
+ #ifndef UNDER_CE
+ if (!fi1.FileInfo_WasRequested) ReadFileInfo(fi1);
+ if (!fi2.FileInfo_WasRequested) ReadFileInfo(fi2);
+ return MyCompare(
+ fi1.NumLinks,
+ fi2.NumLinks);
+ #endif
+ }
+ #endif
+
+ case kpidComment:
+ {
+ // change it !
+ UString comment1, comment2;
+ _comments.GetValue(fs2us(GetRelPath(fi1)), comment1);
+ _comments.GetValue(fs2us(GetRelPath(fi2)), comment2);
+ return MyStringCompareNoCase(comment1, comment2);
+ }
+ case kpidPrefix:
+ if (fi1.Parent < 0) return (fi2.Parent < 0) ? 0 : -1;
+ if (fi2.Parent < 0) return 1;
+ return CompareFileNames_ForFolderList(
+ Folders[fi1.Parent],
+ Folders[fi2.Parent]);
+ case kpidExtension:
+ return CompareFileNames_ForFolderList(
+ GetExtensionPtr(fi1.Name),
+ GetExtensionPtr(fi2.Name));
+ }
+
+ return 0;
+}
+
+HRESULT CFSFolder::BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder)
+{
+ *resultFolder = NULL;
+ CFSFolder *folderSpec = new CFSFolder;
+ CMyComPtr<IFolderFolder> subFolder = folderSpec;
+ RINOK(folderSpec->Init(_path + name + FCHAR_PATH_SEPARATOR))
+ *resultFolder = subFolder.Detach();
+ return S_OK;
+}
+
+/*
+void CFSFolder::GetPrefix(const CDirItem &item, FString &prefix) const
+{
+ if (item.Parent >= 0)
+ prefix = Folders[item.Parent];
+ else
+ prefix.Empty();
+}
+*/
+
+/*
+void CFSFolder::GetPrefix(const CDirItem &item, FString &prefix) const
+{
+ int parent = item.Parent;
+
+ unsigned len = 0;
+
+ while (parent >= 0)
+ {
+ const CDirItem &cur = Files[parent];
+ len += cur.Name.Len() + 1;
+ parent = cur.Parent;
+ }
+
+ wchar_t *p = prefix.GetBuf_SetEnd(len) + len;
+ parent = item.Parent;
+
+ while (parent >= 0)
+ {
+ const CDirItem &cur = Files[parent];
+ *(--p) = FCHAR_PATH_SEPARATOR;
+ p -= cur.Name.Len();
+ wmemcpy(p, cur.Name, cur.Name.Len());
+ parent = cur.Parent;
+ }
+}
+*/
+
+FString CFSFolder::GetRelPath(const CDirItem &item) const
+{
+ if (item.Parent < 0)
+ return item.Name;
+ return Folders[item.Parent] + item.Name;
+}
+
+Z7_COM7F_IMF(CFSFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ const CDirItem &fi = Files[index];
+ if (!fi.IsDir())
+ return E_INVALIDARG;
+ return BindToFolderSpec(GetRelPath(fi), resultFolder);
+}
+
+Z7_COM7F_IMF(CFSFolder::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder))
+{
+ return BindToFolderSpec(us2fs(name), resultFolder);
+}
+
+Z7_COM7F_IMF(CFSFolder::BindToParentFolder(IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ /*
+ if (_parentFolder)
+ {
+ CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+ *resultFolder = parentFolder.Detach();
+ return S_OK;
+ }
+ */
+ if (_path.IsEmpty())
+ return E_INVALIDARG;
+
+ #ifndef UNDER_CE
+
+ if (IsDriveRootPath_SuperAllowed(_path))
+ {
+ CFSDrives *drivesFolderSpec = new CFSDrives;
+ CMyComPtr<IFolderFolder> drivesFolder = drivesFolderSpec;
+ drivesFolderSpec->Init(false, IsSuperPath(_path));
+ *resultFolder = drivesFolder.Detach();
+ return S_OK;
+ }
+
+ int pos = _path.ReverseFind_PathSepar();
+ if (pos < 0 || pos != (int)_path.Len() - 1)
+ return E_FAIL;
+ FString parentPath = _path.Left(pos);
+ pos = parentPath.ReverseFind_PathSepar();
+ parentPath.DeleteFrom((unsigned)(pos + 1));
+
+ if (NName::IsDrivePath_SuperAllowed(parentPath))
+ {
+ CFSFolder *parentFolderSpec = new CFSFolder;
+ CMyComPtr<IFolderFolder> parentFolder = parentFolderSpec;
+ if (parentFolderSpec->Init(parentPath) == S_OK)
+ {
+ *resultFolder = parentFolder.Detach();
+ return S_OK;
+ }
+ }
+
+ /*
+ FString parentPathReduced = parentPath.Left(pos);
+
+ pos = parentPathReduced.ReverseFind_PathSepar();
+ if (pos == 1)
+ {
+ if (!IS_PATH_SEPAR_CHAR(parentPath[0]))
+ return E_FAIL;
+ CNetFolder *netFolderSpec = new CNetFolder;
+ CMyComPtr<IFolderFolder> netFolder = netFolderSpec;
+ netFolderSpec->Init(fs2us(parentPath));
+ *resultFolder = netFolder.Detach();
+ return S_OK;
+ }
+ */
+
+ #endif
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetNumberOfProperties(UInt32 *numProperties))
+{
+ *numProperties = Z7_ARRAY_SIZE(kProps);
+ if (!_flatMode)
+ (*numProperties)--;
+ return S_OK;
+}
+
+IMP_IFolderFolder_GetProp(CFSFolder::GetPropertyInfo, kProps)
+
+Z7_COM7F_IMF(CFSFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value))
+{
+ COM_TRY_BEGIN
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidType: prop = "FSFolder"; break;
+ case kpidPath: prop = fs2us(_path); break;
+ }
+ prop.Detach(value);
+ return S_OK;
+ COM_TRY_END
+}
+
+Z7_COM7F_IMF(CFSFolder::WasChanged(Int32 *wasChanged))
+{
+ bool wasChangedMain = false;
+
+ #ifdef _WIN32
+
+ for (;;)
+ {
+ if (!_findChangeNotification.IsHandleAllocated())
+ break;
+ DWORD waitResult = ::WaitForSingleObject(_findChangeNotification, 0);
+ if (waitResult != WAIT_OBJECT_0)
+ break;
+ _findChangeNotification.FindNext();
+ wasChangedMain = true;
+ }
+
+ #endif
+
+ *wasChanged = BoolToInt(wasChangedMain);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::Clone(IFolderFolder **resultFolder))
+{
+ CFSFolder *fsFolderSpec = new CFSFolder;
+ CMyComPtr<IFolderFolder> folderNew = fsFolderSpec;
+ fsFolderSpec->Init(_path);
+ *resultFolder = folderNew.Detach();
+ return S_OK;
+}
+
+
+/*
+HRESULT CFSFolder::GetItemFullSize(unsigned index, UInt64 &size, IProgress *progress)
+{
+ if (index >= Files.Size())
+ {
+ size = Streams[index - Files.Size()].Size;
+ return S_OK;
+ }
+ const CDirItem &fi = Files[index];
+ if (fi.IsDir())
+ {
+ UInt64 numFolders = 0, numFiles = 0;
+ size = 0;
+ return GetFolderSize(_path + GetRelPath(fi), numFolders, numFiles, size, progress);
+ }
+ size = fi.Size;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetItemFullSize(UInt32 index, PROPVARIANT *value, IProgress *progress)
+{
+ NCOM::CPropVariant prop;
+ UInt64 size = 0;
+ HRESULT result = GetItemFullSize(index, size, progress);
+ prop = size;
+ prop.Detach(value);
+ return result;
+}
+*/
+
+Z7_COM7F_IMF(CFSFolder::CalcItemFullSize(UInt32 index, IProgress *progress))
+{
+ if (index >= (UInt32)Files.Size())
+ return S_OK;
+ CDirItem &fi = Files[index];
+ if (!fi.IsDir())
+ return S_OK;
+ CFsFolderStat stat(_path + GetRelPath(fi), progress);
+ RINOK(stat.Enumerate())
+ fi.Size = stat.Size;
+ fi.NumFolders = stat.NumFolders;
+ fi.NumFiles = stat.NumFiles;
+ fi.FolderStat_Defined = true;
+ return S_OK;
+}
+
+void CFSFolder::GetAbsPath(const wchar_t *name, FString &absPath)
+{
+ absPath.Empty();
+ if (!IsAbsolutePath(name))
+ absPath += _path;
+ absPath += us2fs(name);
+}
+
+Z7_COM7F_IMF(CFSFolder::CreateFolder(const wchar_t *name, IProgress * /* progress */))
+{
+ FString absPath;
+ GetAbsPath(name, absPath);
+ if (CreateDir(absPath))
+ return S_OK;
+ if (::GetLastError() != ERROR_ALREADY_EXISTS)
+ if (CreateComplexDir(absPath))
+ return S_OK;
+ return GetLastError_noZero_HRESULT();
+}
+
+Z7_COM7F_IMF(CFSFolder::CreateFile(const wchar_t *name, IProgress * /* progress */))
+{
+ FString absPath;
+ GetAbsPath(name, absPath);
+ NIO::COutFile outFile;
+ if (!outFile.Create(absPath, false))
+ return GetLastError_noZero_HRESULT();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::Rename(UInt32 index, const wchar_t *newName, IProgress * /* progress */))
+{
+ if (index >= (UInt32)Files.Size())
+ return E_NOTIMPL;
+ const CDirItem &fi = Files[index];
+ // FString prefix;
+ // GetPrefix(fi, prefix);
+ FString fullPrefix = _path;
+ if (fi.Parent >= 0)
+ fullPrefix += Folders[fi.Parent];
+ if (!MyMoveFile(fullPrefix + fi.Name, fullPrefix + us2fs(newName)))
+ return GetLastError_noZero_HRESULT();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::Delete(const UInt32 *indices, UInt32 numItems,IProgress *progress))
+{
+ RINOK(progress->SetTotal(numItems))
+ // int prevDeletedFileIndex = -1;
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ // Sleep(200);
+ UInt32 index = indices[i];
+ bool result = true;
+ /*
+ if (index >= (UInt32)Files.Size())
+ {
+ const CAltStream &ss = Streams[index - (UInt32)Files.Size()];
+ if (prevDeletedFileIndex != ss.Parent)
+ {
+ const CDirItem &fi = Files[ss.Parent];
+ result = DeleteFileAlways(_path + GetRelPath(fi) + us2fs(ss.Name));
+ }
+ }
+ else
+ */
+ {
+ const CDirItem &fi = Files[index];
+ const FString fullPath = _path + GetRelPath(fi);
+ // prevDeletedFileIndex = index;
+ if (fi.IsDir())
+ result = RemoveDirWithSubItems(fullPath);
+ else
+ result = DeleteFileAlways(fullPath);
+ }
+ if (!result)
+ return GetLastError_noZero_HRESULT();
+ const UInt64 completed = i;
+ RINOK(progress->SetCompleted(&completed))
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::SetProperty(UInt32 index, PROPID propID,
+ const PROPVARIANT *value, IProgress * /* progress */))
+{
+ if (index >= (UInt32)Files.Size())
+ return E_INVALIDARG;
+ CDirItem &fi = Files[index];
+ if (fi.Parent >= 0)
+ return E_NOTIMPL;
+ switch (propID)
+ {
+ case kpidComment:
+ {
+ UString filename = fs2us(fi.Name);
+ filename.Trim();
+ if (value->vt == VT_EMPTY)
+ _comments.DeletePair(filename);
+ else if (value->vt == VT_BSTR)
+ {
+ CTextPair pair;
+ pair.ID = filename;
+ pair.ID.Trim();
+ pair.Value.SetFromBstr(value->bstrVal);
+ pair.Value.Trim();
+ if (pair.Value.IsEmpty())
+ _comments.DeletePair(filename);
+ else
+ _comments.AddPair(pair);
+ }
+ else
+ return E_INVALIDARG;
+ SaveComments();
+ break;
+ }
+ default:
+ return E_NOTIMPL;
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex))
+{
+ if (index >= (UInt32)Files.Size())
+ return E_INVALIDARG;
+ const CDirItem &fi = Files[index];
+ *iconIndex = 0;
+ int iconIndexTemp;
+ if (GetRealIconIndex(_path + GetRelPath(fi), fi.Attrib, iconIndexTemp) != 0)
+ {
+ *iconIndex = iconIndexTemp;
+ return S_OK;
+ }
+ return GetLastError_noZero_HRESULT();
+}
+
+Z7_COM7F_IMF(CFSFolder::SetFlatMode(Int32 flatMode))
+{
+ _flatMode = IntToBool(flatMode);
+ return S_OK;
+}
+
+/*
+Z7_COM7F_IMF(CFSFolder::SetShowNtfsStreamsMode(Int32 showStreamsMode)
+{
+ _scanAltStreams = IntToBool(showStreamsMode);
+ return S_OK;
+}
+*/
+
+}
diff --git a/CPP/7zip/UI/FileManager/FSFolder.h b/CPP/7zip/UI/FileManager/FSFolder.h
new file mode 100644
index 0000000..fe8538a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSFolder.h
@@ -0,0 +1,221 @@
+// FSFolder.h
+
+#ifndef ZIP7_INC_FS_FOLDER_H
+#define ZIP7_INC_FS_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyBuffer.h"
+
+#include "../../../Windows/FileFind.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "IFolder.h"
+#include "TextPairs.h"
+
+namespace NFsFolder {
+
+class CFSFolder;
+
+#define FS_SHOW_LINKS_INFO
+// #define FS_SHOW_CHANGE_TIME
+
+struct CDirItem: public NWindows::NFile::NFind::CFileInfo
+{
+ #ifndef UNDER_CE
+ UInt64 PackSize;
+ #endif
+
+ #ifdef FS_SHOW_LINKS_INFO
+ FILETIME ChangeTime;
+ UInt64 FileIndex;
+ UInt32 NumLinks;
+ bool FileInfo_Defined;
+ bool FileInfo_WasRequested;
+ bool ChangeTime_Defined;
+ bool ChangeTime_WasRequested;
+ #endif
+
+ #ifndef UNDER_CE
+ bool PackSize_Defined;
+ #endif
+
+ bool FolderStat_Defined;
+
+ #ifndef UNDER_CE
+ CByteBuffer Reparse;
+ #endif
+
+ UInt64 NumFolders;
+ UInt64 NumFiles;
+
+ int Parent;
+};
+
+/*
+struct CAltStream
+{
+ UInt64 Size;
+ UInt64 PackSize;
+ bool PackSize_Defined;
+ int Parent;
+ UString Name;
+};
+*/
+
+struct CFsFolderStat
+{
+ UInt64 NumFolders;
+ UInt64 NumFiles;
+ UInt64 Size;
+ IProgress *Progress;
+ FString Path;
+
+ CFsFolderStat(): NumFolders(0), NumFiles(0), Size(0), Progress(NULL) {}
+ CFsFolderStat(const FString &path, IProgress *progress = NULL):
+ NumFolders(0), NumFiles(0), Size(0), Progress(progress), Path(path) {}
+
+ HRESULT Enumerate();
+};
+
+class CFSFolder Z7_final:
+ public IFolderFolder,
+ public IArchiveGetRawProps,
+ public IFolderCompare,
+ #ifdef USE_UNICODE_FSTRING
+ public IFolderGetItemName,
+ #endif
+ public IFolderWasChanged,
+ public IFolderOperations,
+ // public IFolderOperationsDeleteToRecycleBin,
+ public IFolderCalcItemFullSize,
+ public IFolderClone,
+ public IFolderGetSystemIconIndex,
+ public IFolderSetFlatMode,
+ // public IFolderSetShowNtfsStreamsMode,
+ public CMyUnknownImp
+{
+ Z7_COM_QI_BEGIN2(IFolderFolder)
+ Z7_COM_QI_ENTRY(IArchiveGetRawProps)
+ Z7_COM_QI_ENTRY(IFolderCompare)
+ #ifdef USE_UNICODE_FSTRING
+ Z7_COM_QI_ENTRY(IFolderGetItemName)
+ #endif
+ Z7_COM_QI_ENTRY(IFolderWasChanged)
+ // Z7_COM_QI_ENTRY(IFolderOperationsDeleteToRecycleBin)
+ Z7_COM_QI_ENTRY(IFolderOperations)
+ Z7_COM_QI_ENTRY(IFolderCalcItemFullSize)
+ Z7_COM_QI_ENTRY(IFolderClone)
+ Z7_COM_QI_ENTRY(IFolderGetSystemIconIndex)
+ Z7_COM_QI_ENTRY(IFolderSetFlatMode)
+ // Z7_COM_QI_ENTRY(IFolderSetShowNtfsStreamsMode)
+ Z7_COM_QI_END
+ Z7_COM_ADDREF_RELEASE
+
+ Z7_IFACE_COM7_IMP(IFolderFolder)
+ Z7_IFACE_COM7_IMP(IArchiveGetRawProps)
+ Z7_IFACE_COM7_IMP(IFolderCompare)
+ #ifdef USE_UNICODE_FSTRING
+ Z7_IFACE_COM7_IMP(IFolderGetItemName)
+ #endif
+ Z7_IFACE_COM7_IMP(IFolderWasChanged)
+ Z7_IFACE_COM7_IMP(IFolderOperations)
+ Z7_IFACE_COM7_IMP(IFolderCalcItemFullSize)
+ Z7_IFACE_COM7_IMP(IFolderClone)
+ Z7_IFACE_COM7_IMP(IFolderGetSystemIconIndex)
+ Z7_IFACE_COM7_IMP(IFolderSetFlatMode)
+ // Z7_IFACE_COM7_IMP(IFolderSetShowNtfsStreamsMode)
+
+private:
+ FString _path;
+
+ CObjectVector<CDirItem> Files;
+ FStringVector Folders;
+ // CObjectVector<CAltStream> Streams;
+ // CMyComPtr<IFolderFolder> _parentFolder;
+
+ bool _commentsAreLoaded;
+ CPairsStorage _comments;
+
+ // bool _scanAltStreams;
+ bool _flatMode;
+
+ #ifdef _WIN32
+ NWindows::NFile::NFind::CFindChangeNotification _findChangeNotification;
+ #endif
+
+ // HRESULT GetItemFullSize(unsigned index, UInt64 &size, IProgress *progress);
+ void GetAbsPath(const wchar_t *name, FString &absPath);
+ HRESULT BindToFolderSpec(CFSTR name, IFolderFolder **resultFolder);
+
+ bool LoadComments();
+ bool SaveComments();
+ HRESULT LoadSubItems(int dirItem, const FString &path);
+
+ #ifdef FS_SHOW_LINKS_INFO
+ bool ReadFileInfo(CDirItem &di);
+ void ReadChangeTime(CDirItem &di);
+ #endif
+
+public:
+ HRESULT Init(const FString &path /* , IFolderFolder *parentFolder */);
+ #if !defined(_WIN32) || defined(UNDER_CE)
+ HRESULT InitToRoot() { return Init((FString) FSTRING_PATH_SEPARATOR /* , NULL */); }
+ #endif
+
+ CFSFolder() : _flatMode(false)
+ // , _scanAltStreams(false)
+ {}
+
+ void GetFullPath(const CDirItem &item, FString &path) const
+ {
+ // FString prefix;
+ // GetPrefix(item, prefix);
+ path = _path;
+ if (item.Parent >= 0)
+ path += Folders[item.Parent];
+ path += item.Name;
+ }
+
+ // void GetPrefix(const CDirItem &item, FString &prefix) const;
+
+ FString GetRelPath(const CDirItem &item) const;
+
+ void Clear()
+ {
+ Files.Clear();
+ Folders.Clear();
+ // Streams.Clear();
+ }
+};
+
+struct CCopyStateIO
+{
+ IProgress *Progress;
+ UInt64 TotalSize;
+ UInt64 StartPos;
+ UInt64 CurrentSize;
+ bool DeleteSrcFile;
+
+ int ErrorFileIndex;
+ UString ErrorMessage;
+
+ CCopyStateIO(): TotalSize(0), StartPos(0), DeleteSrcFile(false) {}
+
+ HRESULT MyCopyFile(CFSTR inPath, CFSTR outPath, DWORD attrib = INVALID_FILE_ATTRIBUTES);
+};
+
+HRESULT SendLastErrorMessage(IFolderOperationsExtractCallback *callback, const FString &fileName);
+
+/* destDirPrefix is allowed to be:
+ "full_path\" or "full_path:" for alt streams */
+
+HRESULT CopyFileSystemItems(
+ const UStringVector &itemsPaths,
+ const FString &destDirPrefix,
+ bool moveMode,
+ IFolderOperationsExtractCallback *callback);
+
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FSFolderCopy.cpp b/CPP/7zip/UI/FileManager/FSFolderCopy.cpp
new file mode 100644
index 0000000..db4ae0a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FSFolderCopy.cpp
@@ -0,0 +1,810 @@
+// FSFolderCopy.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+
+#include "../../Common/FilePathAutoRename.h"
+
+#include "FSFolder.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+using namespace NName;
+using namespace NFind;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NFsFolder {
+
+static const char * const k_CannotCopyDirToAltStream = "Cannot copy folder as alternate stream";
+
+
+HRESULT CCopyStateIO::MyCopyFile(CFSTR inPath, CFSTR outPath, DWORD attrib)
+{
+ ErrorFileIndex = -1;
+ ErrorMessage.Empty();
+ CurrentSize = 0;
+
+ {
+ const size_t kBufSize = 1 << 16;
+ CByteArr buf(kBufSize);
+
+ NIO::CInFile inFile;
+ NIO::COutFile outFile;
+
+ if (!inFile.Open(inPath))
+ {
+ ErrorFileIndex = 0;
+ return S_OK;
+ }
+
+ if (!outFile.Create(outPath, true))
+ {
+ ErrorFileIndex = 1;
+ return S_OK;
+ }
+
+ for (;;)
+ {
+ UInt32 num;
+ if (!inFile.Read(buf, kBufSize, num))
+ {
+ ErrorFileIndex = 0;
+ return S_OK;
+ }
+ if (num == 0)
+ break;
+
+ UInt32 written = 0;
+ if (!outFile.Write(buf, num, written))
+ {
+ ErrorFileIndex = 1;
+ return S_OK;
+ }
+ if (written != num)
+ {
+ ErrorMessage = "Write error";
+ return S_OK;
+ }
+ CurrentSize += num;
+ if (Progress)
+ {
+ UInt64 completed = StartPos + CurrentSize;
+ RINOK(Progress->SetCompleted(&completed))
+ }
+ }
+ }
+
+ /* SetFileAttrib("path:alt_stream_name") sets attributes for main file "path".
+ But we don't want to change attributes of main file, when we write alt stream.
+ So we need INVALID_FILE_ATTRIBUTES for alt stream here */
+
+ if (attrib != INVALID_FILE_ATTRIBUTES)
+ SetFileAttrib(outPath, attrib);
+
+ if (DeleteSrcFile)
+ {
+ if (!DeleteFileAlways(inPath))
+ {
+ ErrorFileIndex = 0;
+ return S_OK;
+ }
+ }
+
+ return S_OK;
+}
+
+
+/*
+static bool IsItWindows2000orHigher()
+{
+ OSVERSIONINFO versionInfo;
+ versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
+ if (!::GetVersionEx(&versionInfo))
+ return false;
+ return (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
+ (versionInfo.dwMajorVersion >= 5);
+}
+*/
+
+struct CProgressInfo
+{
+ UInt64 TotalSize;
+ UInt64 StartPos;
+ UInt64 FileSize;
+ IProgress *Progress;
+ HRESULT ProgressResult;
+
+ void Init() { ProgressResult = S_OK; }
+};
+
+#ifndef PROGRESS_CONTINUE
+
+#define PROGRESS_CONTINUE 0
+#define PROGRESS_CANCEL 1
+
+#define COPY_FILE_FAIL_IF_EXISTS 0x00000001
+
+typedef
+DWORD
+(WINAPI* LPPROGRESS_ROUTINE)(
+ LARGE_INTEGER TotalFileSize,
+ LARGE_INTEGER TotalBytesTransferred,
+ LARGE_INTEGER StreamSize,
+ LARGE_INTEGER StreamBytesTransferred,
+ DWORD dwStreamNumber,
+ DWORD dwCallbackReason,
+ HANDLE hSourceFile,
+ HANDLE hDestinationFile,
+ LPVOID lpData
+ );
+
+#endif
+
+static DWORD CALLBACK CopyProgressRoutine(
+ LARGE_INTEGER TotalFileSize, // file size
+ LARGE_INTEGER TotalBytesTransferred, // bytes transferred
+ LARGE_INTEGER /* StreamSize */, // bytes in stream
+ LARGE_INTEGER /* StreamBytesTransferred */, // bytes transferred for stream
+ DWORD /* dwStreamNumber */, // current stream
+ DWORD /* dwCallbackReason */, // callback reason
+ HANDLE /* hSourceFile */, // handle to source file
+ HANDLE /* hDestinationFile */, // handle to destination file
+ LPVOID lpData // from CopyFileEx
+)
+{
+ // StreamSize = StreamSize;
+ // StreamBytesTransferred = StreamBytesTransferred;
+ // dwStreamNumber = dwStreamNumber;
+ // dwCallbackReason = dwCallbackReason;
+
+ CProgressInfo &pi = *(CProgressInfo *)lpData;
+
+ if ((UInt64)TotalFileSize.QuadPart > pi.FileSize)
+ {
+ pi.TotalSize += (UInt64)TotalFileSize.QuadPart - pi.FileSize;
+ pi.FileSize = (UInt64)TotalFileSize.QuadPart;
+ pi.ProgressResult = pi.Progress->SetTotal(pi.TotalSize);
+ }
+ const UInt64 completed = pi.StartPos + (UInt64)TotalBytesTransferred.QuadPart;
+ pi.ProgressResult = pi.Progress->SetCompleted(&completed);
+ return (pi.ProgressResult == S_OK ? PROGRESS_CONTINUE : PROGRESS_CANCEL);
+}
+
+typedef BOOL (WINAPI * Func_CopyFileExA)(
+ IN LPCSTR lpExistingFileName,
+ IN LPCSTR lpNewFileName,
+ IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
+ IN LPVOID lpData OPTIONAL,
+ IN LPBOOL pbCancel OPTIONAL,
+ IN DWORD dwCopyFlags
+ );
+
+typedef BOOL (WINAPI * Func_CopyFileExW)(
+ IN LPCWSTR lpExistingFileName,
+ IN LPCWSTR lpNewFileName,
+ IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
+ IN LPVOID lpData OPTIONAL,
+ IN LPBOOL pbCancel OPTIONAL,
+ IN DWORD dwCopyFlags
+ );
+
+typedef BOOL (WINAPI * Func_MoveFileWithProgressW)(
+ IN LPCWSTR lpExistingFileName,
+ IN LPCWSTR lpNewFileName,
+ IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL,
+ IN LPVOID lpData OPTIONAL,
+ IN DWORD dwFlags
+ );
+
+struct CCopyState
+{
+ CProgressInfo ProgressInfo;
+ IFolderOperationsExtractCallback *Callback;
+ bool MoveMode;
+ bool UseReadWriteMode;
+ bool IsAltStreamsDest;
+
+ Func_CopyFileExW my_CopyFileExW;
+ #ifndef UNDER_CE
+ Func_MoveFileWithProgressW my_MoveFileWithProgressW;
+ #endif
+ #ifndef _UNICODE
+ Func_CopyFileExA my_CopyFileExA;
+ #endif
+
+ void Prepare();
+ bool CopyFile_NT(const wchar_t *oldFile, const wchar_t *newFile);
+ bool CopyFile_Sys(CFSTR oldFile, CFSTR newFile);
+ bool MoveFile_Sys(CFSTR oldFile, CFSTR newFile);
+
+ HRESULT CallProgress();
+
+ bool IsCallbackProgressError() { return ProgressInfo.ProgressResult != S_OK; }
+};
+
+HRESULT CCopyState::CallProgress()
+{
+ return ProgressInfo.Progress->SetCompleted(&ProgressInfo.StartPos);
+}
+
+void CCopyState::Prepare()
+{
+ my_CopyFileExW = NULL;
+ #ifndef UNDER_CE
+ my_MoveFileWithProgressW = NULL;
+ #endif
+ #ifndef _UNICODE
+ my_CopyFileExA = NULL;
+ if (!g_IsNT)
+ {
+ my_CopyFileExA = Z7_GET_PROC_ADDRESS(
+ Func_CopyFileExA, ::GetModuleHandleA("kernel32.dll"),
+ "CopyFileExA");
+ }
+ else
+ #endif
+ {
+ const HMODULE module = ::GetModuleHandleW(
+ #ifdef UNDER_CE
+ L"coredll.dll"
+ #else
+ L"kernel32.dll"
+ #endif
+ );
+ my_CopyFileExW = Z7_GET_PROC_ADDRESS(
+ Func_CopyFileExW, module,
+ "CopyFileExW");
+ #ifndef UNDER_CE
+ my_MoveFileWithProgressW = Z7_GET_PROC_ADDRESS(
+ Func_MoveFileWithProgressW, module,
+ "MoveFileWithProgressW");
+ #endif
+ }
+}
+
+/* WinXP-64:
+ CopyFileW(fromFile, toFile:altStream)
+ OK - there are NO alt streams in fromFile
+ ERROR_INVALID_PARAMETER - there are alt streams in fromFile
+*/
+
+bool CCopyState::CopyFile_NT(const wchar_t *oldFile, const wchar_t *newFile)
+{
+ BOOL cancelFlag = FALSE;
+ if (my_CopyFileExW)
+ return BOOLToBool(my_CopyFileExW(oldFile, newFile, CopyProgressRoutine,
+ &ProgressInfo, &cancelFlag, COPY_FILE_FAIL_IF_EXISTS));
+ return BOOLToBool(::CopyFileW(oldFile, newFile, TRUE));
+}
+
+bool CCopyState::CopyFile_Sys(CFSTR oldFile, CFSTR newFile)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (my_CopyFileExA)
+ {
+ BOOL cancelFlag = FALSE;
+ if (my_CopyFileExA(fs2fas(oldFile), fs2fas(newFile),
+ CopyProgressRoutine, &ProgressInfo, &cancelFlag, COPY_FILE_FAIL_IF_EXISTS))
+ return true;
+ if (::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+ return false;
+ }
+ return BOOLToBool(::CopyFile(fs2fas(oldFile), fs2fas(newFile), TRUE));
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH_2(oldFile, newFile)
+ {
+ if (CopyFile_NT(fs2us(oldFile), fs2us(newFile)))
+ return true;
+ }
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH_2)
+ {
+ if (IsCallbackProgressError())
+ return false;
+ UString superPathOld, superPathNew;
+ if (!GetSuperPaths(oldFile, newFile, superPathOld, superPathNew, USE_MAIN_PATH_2))
+ return false;
+ if (CopyFile_NT(superPathOld, superPathNew))
+ return true;
+ }
+ #endif
+ return false;
+ }
+}
+
+bool CCopyState::MoveFile_Sys(CFSTR oldFile, CFSTR newFile)
+{
+ #ifndef UNDER_CE
+ // if (IsItWindows2000orHigher())
+ // {
+ if (my_MoveFileWithProgressW)
+ {
+ IF_USE_MAIN_PATH_2(oldFile, newFile)
+ {
+ if (my_MoveFileWithProgressW(fs2us(oldFile), fs2us(newFile), CopyProgressRoutine,
+ &ProgressInfo, MOVEFILE_COPY_ALLOWED))
+ return true;
+ }
+ #ifdef Z7_LONG_PATH
+ if ((!(USE_MAIN_PATH_2) || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED) && USE_SUPER_PATH_2)
+ {
+ if (IsCallbackProgressError())
+ return false;
+ UString superPathOld, superPathNew;
+ if (!GetSuperPaths(oldFile, newFile, superPathOld, superPathNew, USE_MAIN_PATH_2))
+ return false;
+ if (my_MoveFileWithProgressW(superPathOld, superPathNew, CopyProgressRoutine,
+ &ProgressInfo, MOVEFILE_COPY_ALLOWED))
+ return true;
+ }
+ #endif
+ if (::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+ return false;
+ }
+ // }
+ // else
+ #endif
+ return MyMoveFile(oldFile, newFile);
+}
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+ const wchar_t *message, const FString &fileName)
+{
+ UString s = message;
+ s += " : ";
+ s += fs2us(fileName);
+ return callback->ShowMessage(s);
+}
+
+static HRESULT SendMessageError(IFolderOperationsExtractCallback *callback,
+ const char *message, const FString &fileName)
+{
+ return SendMessageError(callback, MultiByteToUnicodeString(message), fileName);
+}
+
+static DWORD Return_LastError_or_FAIL()
+{
+ DWORD errorCode = GetLastError();
+ if (errorCode == 0)
+ errorCode = (DWORD)E_FAIL;
+ return errorCode;
+}
+
+static UString GetLastErrorMessage()
+{
+ return NError::MyFormatMessage(Return_LastError_or_FAIL());
+}
+
+HRESULT SendLastErrorMessage(IFolderOperationsExtractCallback *callback, const FString &fileName)
+{
+ return SendMessageError(callback, GetLastErrorMessage(), fileName);
+}
+
+static HRESULT CopyFile_Ask(
+ CCopyState &state,
+ const FString &srcPath,
+ const CFileInfo &srcFileInfo,
+ const FString &destPath)
+{
+ if (CompareFileNames(destPath, srcPath) == 0)
+ {
+ RINOK(SendMessageError(state.Callback,
+ state.MoveMode ?
+ "Cannot move file onto itself" :
+ "Cannot copy file onto itself"
+ , destPath))
+ return E_ABORT;
+ }
+
+ Int32 writeAskResult;
+ CMyComBSTR destPathResult;
+ RINOK(state.Callback->AskWrite(
+ fs2us(srcPath),
+ BoolToInt(false),
+ &srcFileInfo.MTime, &srcFileInfo.Size,
+ fs2us(destPath),
+ &destPathResult,
+ &writeAskResult))
+
+ if (IntToBool(writeAskResult))
+ {
+ FString destPathNew = us2fs((LPCOLESTR)destPathResult);
+ RINOK(state.Callback->SetCurrentFilePath(fs2us(srcPath)))
+
+ if (state.UseReadWriteMode)
+ {
+ NFsFolder::CCopyStateIO state2;
+ state2.Progress = state.Callback;
+ state2.DeleteSrcFile = state.MoveMode;
+ state2.TotalSize = state.ProgressInfo.TotalSize;
+ state2.StartPos = state.ProgressInfo.StartPos;
+
+ RINOK(state2.MyCopyFile(srcPath, destPathNew,
+ state.IsAltStreamsDest ? INVALID_FILE_ATTRIBUTES: srcFileInfo.Attrib))
+
+ if (state2.ErrorFileIndex >= 0)
+ {
+ if (state2.ErrorMessage.IsEmpty())
+ state2.ErrorMessage = GetLastErrorMessage();
+ FString errorName;
+ if (state2.ErrorFileIndex == 0)
+ errorName = srcPath;
+ else
+ errorName = destPathNew;
+ RINOK(SendMessageError(state.Callback, state2.ErrorMessage, errorName))
+ return E_ABORT;
+ }
+ state.ProgressInfo.StartPos += state2.CurrentSize;
+ }
+ else
+ {
+ state.ProgressInfo.FileSize = srcFileInfo.Size;
+ bool res;
+ if (state.MoveMode)
+ res = state.MoveFile_Sys(srcPath, destPathNew);
+ else
+ res = state.CopyFile_Sys(srcPath, destPathNew);
+ RINOK(state.ProgressInfo.ProgressResult)
+ if (!res)
+ {
+ // GetLastError() is ERROR_REQUEST_ABORTED in case of PROGRESS_CANCEL.
+ RINOK(SendMessageError(state.Callback, GetLastErrorMessage(), destPathNew))
+ return E_ABORT;
+ }
+ state.ProgressInfo.StartPos += state.ProgressInfo.FileSize;
+ }
+ }
+ else
+ {
+ if (state.ProgressInfo.TotalSize >= srcFileInfo.Size)
+ {
+ state.ProgressInfo.TotalSize -= srcFileInfo.Size;
+ RINOK(state.ProgressInfo.Progress->SetTotal(state.ProgressInfo.TotalSize))
+ }
+ }
+ return state.CallProgress();
+}
+
+static FString CombinePath(const FString &folderPath, const FString &fileName)
+{
+ FString s (folderPath);
+ s.Add_PathSepar(); // FCHAR_PATH_SEPARATOR
+ s += fileName;
+ return s;
+}
+
+static bool IsDestChild(const FString &src, const FString &dest)
+{
+ unsigned len = src.Len();
+ if (dest.Len() < len)
+ return false;
+ if (dest.Len() != len && dest[len] != FCHAR_PATH_SEPARATOR)
+ return false;
+ return CompareFileNames(dest.Left(len), src) == 0;
+}
+
+static HRESULT CopyFolder(
+ CCopyState &state,
+ const FString &srcPath, // without TAIL separator
+ const FString &destPath) // without TAIL separator
+{
+ RINOK(state.CallProgress())
+
+ if (IsDestChild(srcPath, destPath))
+ {
+ RINOK(SendMessageError(state.Callback,
+ state.MoveMode ?
+ "Cannot copy folder onto itself" :
+ "Cannot move folder onto itself"
+ , destPath))
+ return E_ABORT;
+ }
+
+ if (state.MoveMode)
+ {
+ if (state.MoveFile_Sys(srcPath, destPath))
+ return S_OK;
+
+ // MSDN: MoveFile() fails for dirs on different volumes.
+ }
+
+ if (!CreateComplexDir(destPath))
+ {
+ RINOK(SendMessageError(state.Callback, "Cannot create folder", destPath))
+ return E_ABORT;
+ }
+
+ CEnumerator enumerator;
+ enumerator.SetDirPrefix(CombinePath(srcPath, FString()));
+
+ for (;;)
+ {
+ NFind::CFileInfo fi;
+ bool found;
+ if (!enumerator.Next(fi, found))
+ {
+ SendLastErrorMessage(state.Callback, srcPath);
+ return S_OK;
+ }
+ if (!found)
+ break;
+ const FString srcPath2 = CombinePath(srcPath, fi.Name);
+ const FString destPath2 = CombinePath(destPath, fi.Name);
+ if (fi.IsDir())
+ {
+ RINOK(CopyFolder(state, srcPath2, destPath2))
+ }
+ else
+ {
+ RINOK(CopyFile_Ask(state, srcPath2, fi, destPath2))
+ }
+ }
+
+ if (state.MoveMode)
+ {
+ if (!RemoveDir(srcPath))
+ {
+ RINOK(SendMessageError(state.Callback, "Cannot remove folder", srcPath))
+ return E_ABORT;
+ }
+ }
+
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CFSFolder::CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems,
+ Int32 /* includeAltStreams */, Int32 /* replaceAltStreamColon */,
+ const wchar_t *path, IFolderOperationsExtractCallback *callback))
+{
+ if (numItems == 0)
+ return S_OK;
+
+ const FString destPath = us2fs(path);
+ if (destPath.IsEmpty())
+ return E_INVALIDARG;
+
+ const bool isAltDest = NName::IsAltPathPrefix(destPath);
+ const bool isDirectPath = (!isAltDest && !IsPathSepar(destPath.Back()));
+
+ if (isDirectPath)
+ if (numItems > 1)
+ return E_INVALIDARG;
+
+ CFsFolderStat stat;
+ stat.Progress = callback;
+
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = indices[i];
+ /*
+ if (index >= Files.Size())
+ {
+ size += Streams[index - Files.Size()].Size;
+ // numFiles++;
+ continue;
+ }
+ */
+ const CDirItem &fi = Files[index];
+ if (fi.IsDir())
+ {
+ if (!isAltDest)
+ {
+ stat.Path = _path;
+ stat.Path += GetRelPath(fi);
+ RINOK(stat.Enumerate())
+ }
+ stat.NumFolders++;
+ }
+ else
+ {
+ stat.NumFiles++;
+ stat.Size += fi.Size;
+ }
+ }
+
+ /*
+ if (stat.NumFolders != 0 && isAltDest)
+ return E_NOTIMPL;
+ */
+
+ RINOK(callback->SetTotal(stat.Size))
+ RINOK(callback->SetNumFiles(stat.NumFiles))
+
+ UInt64 completedSize = 0;
+ RINOK(callback->SetCompleted(&completedSize))
+
+ CCopyState state;
+ state.ProgressInfo.TotalSize = stat.Size;
+ state.ProgressInfo.StartPos = 0;
+ state.ProgressInfo.Progress = callback;
+ state.ProgressInfo.Init();
+ state.Callback = callback;
+ state.MoveMode = IntToBool(moveMode);
+ state.IsAltStreamsDest = isAltDest;
+ /* CopyFileW(fromFile, toFile:altStream) returns ERROR_INVALID_PARAMETER,
+ if there are alt streams in fromFile.
+ So we don't use CopyFileW() for alt Streams. */
+ state.UseReadWriteMode = isAltDest;
+ state.Prepare();
+
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 index = indices[i];
+ if (index >= (UInt32)Files.Size())
+ continue;
+ const CDirItem &fi = Files[index];
+ FString destPath2 = destPath;
+ if (!isDirectPath)
+ destPath2 += fi.Name;
+ FString srcPath;
+ GetFullPath(fi, srcPath);
+
+ if (fi.IsDir())
+ {
+ if (isAltDest)
+ {
+ RINOK(SendMessageError(callback, k_CannotCopyDirToAltStream, srcPath))
+ }
+ else
+ {
+ RINOK(CopyFolder(state, srcPath, destPath2))
+ }
+ }
+ else
+ {
+ RINOK(CopyFile_Ask(state, srcPath, fi, destPath2))
+ }
+ }
+ return S_OK;
+}
+
+
+
+/* we can call CopyFileSystemItems() from CDropTarget::Drop() */
+
+HRESULT CopyFileSystemItems(
+ const UStringVector &itemsPaths,
+ const FString &destDirPrefix,
+ bool moveMode,
+ IFolderOperationsExtractCallback *callback)
+{
+ if (itemsPaths.IsEmpty())
+ return S_OK;
+
+ if (destDirPrefix.IsEmpty())
+ return E_INVALIDARG;
+
+ const bool isAltDest = NName::IsAltPathPrefix(destDirPrefix);
+
+ CFsFolderStat stat;
+ stat.Progress = callback;
+
+ {
+ FOR_VECTOR (i, itemsPaths)
+ {
+ const UString &path = itemsPaths[i];
+ CFileInfo fi;
+ if (!fi.Find(us2fs(path)))
+ continue;
+ if (fi.IsDir())
+ {
+ if (!isAltDest)
+ {
+ stat.Path = us2fs(path);
+ RINOK(stat.Enumerate())
+ }
+ stat.NumFolders++;
+ }
+ else
+ {
+ stat.NumFiles++;
+ stat.Size += fi.Size;
+ }
+ }
+ }
+
+ /*
+ if (stat.NumFolders != 0 && isAltDest)
+ return E_NOTIMPL;
+ */
+
+ RINOK(callback->SetTotal(stat.Size))
+ // RINOK(progress->SetNumFiles(stat.NumFiles));
+
+ UInt64 completedSize = 0;
+ RINOK(callback->SetCompleted(&completedSize))
+
+ CCopyState state;
+ state.ProgressInfo.TotalSize = stat.Size;
+ state.ProgressInfo.StartPos = 0;
+ state.ProgressInfo.Progress = callback;
+ state.ProgressInfo.Init();
+ state.Callback = callback;
+ state.MoveMode = moveMode;
+ state.IsAltStreamsDest = isAltDest;
+ /* CopyFileW(fromFile, toFile:altStream) returns ERROR_INVALID_PARAMETER,
+ if there are alt streams in fromFile.
+ So we don't use CopyFileW() for alt Streams. */
+ state.UseReadWriteMode = isAltDest;
+ state.Prepare();
+
+ FOR_VECTOR (i, itemsPaths)
+ {
+ const UString path = itemsPaths[i];
+ CFileInfo fi;
+
+ if (!fi.Find(us2fs(path)))
+ {
+ RINOK(SendMessageError(callback, "Cannot find the file", us2fs(path)))
+ continue;
+ }
+
+ FString destPath = destDirPrefix;
+ destPath += fi.Name;
+
+ if (fi.IsDir())
+ {
+ if (isAltDest)
+ {
+ RINOK(SendMessageError(callback, k_CannotCopyDirToAltStream, us2fs(path)))
+ }
+ else
+ {
+ RINOK(CopyFolder(state, us2fs(path), destPath))
+ }
+ }
+ else
+ {
+ RINOK(CopyFile_Ask(state, us2fs(path), fi, destPath))
+ }
+ }
+ return S_OK;
+}
+
+
+/* we don't use CFSFolder::CopyFrom() because the caller of CopyFrom()
+ is optimized for IFolderArchiveUpdateCallback interface,
+ but we want to use IFolderOperationsExtractCallback interface instead */
+
+Z7_COM7F_IMF(CFSFolder::CopyFrom(Int32 /* moveMode */, const wchar_t * /* fromFolderPath */,
+ const wchar_t * const * /* itemsPaths */, UInt32 /* numItems */, IProgress * /* progress */))
+{
+ /*
+ Z7_DECL_CMyComPtr_QI_FROM(
+ IFolderOperationsExtractCallback,
+ callback, progress)
+ if (!callback)
+ return E_NOTIMPL;
+ return CopyFileSystemItems(_path,
+ moveMode, fromDirPrefix,
+ itemsPaths, numItems, callback);
+ */
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CFSFolder::CopyFromFile(UInt32 /* index */, const wchar_t * /* fullFilePath */, IProgress * /* progress */))
+{
+ return E_NOTIMPL;
+}
+
+}
diff --git a/CPP/7zip/UI/FileManager/FileFolderPluginOpen.cpp b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.cpp
new file mode 100644
index 0000000..e4e9997
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.cpp
@@ -0,0 +1,394 @@
+// FileFolderPluginOpen.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Thread.h"
+
+#include "../Agent/Agent.h"
+#include "../GUI/ExtractRes.h"
+
+#include "FileFolderPluginOpen.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OpenCallback.h"
+#include "PluginLoader.h"
+#include "PropertyName.h"
+#include "RegistryPlugins.h"
+
+using namespace NWindows;
+
+struct CThreadArchiveOpen
+{
+ UString Path;
+ UString ArcFormat;
+ CMyComPtr<IInStream> InStream;
+ CMyComPtr<IFolderManager> FolderManager;
+ CMyComPtr<IProgress> OpenCallbackProgress;
+
+ COpenArchiveCallback *OpenCallbackSpec;
+ /*
+ CMyComPtr<IUnknown>
+ // CMyComPtr<IProgress>
+ // CMyComPtr<IArchiveOpenCallback>
+ OpenCallbackSpec_Ref;
+ */
+
+ CMyComPtr<IFolderFolder> Folder;
+ HRESULT Result;
+
+ void Process()
+ {
+ try
+ {
+ CProgressCloser closer(OpenCallbackSpec->ProgressDialog);
+ Result = FolderManager->OpenFolderFile(InStream, Path, ArcFormat, &Folder, OpenCallbackProgress);
+ }
+ catch(...) { Result = E_FAIL; }
+ }
+
+ static THREAD_FUNC_DECL MyThreadFunction(void *param)
+ {
+ ((CThreadArchiveOpen *)param)->Process();
+ return 0;
+ }
+};
+
+/*
+static int FindPlugin(const CObjectVector<CPluginInfo> &plugins, const UString &pluginName)
+{
+ for (int i = 0; i < plugins.Size(); i++)
+ if (plugins[i].Name.CompareNoCase(pluginName) == 0)
+ return i;
+ return -1;
+}
+*/
+
+static void SplitNameToPureNameAndExtension(const FString &fullName,
+ FString &pureName, FString &extensionDelimiter, FString &extension)
+{
+ const int index = fullName.ReverseFind_Dot();
+ if (index < 0)
+ {
+ pureName = fullName;
+ extensionDelimiter.Empty();
+ extension.Empty();
+ }
+ else
+ {
+ pureName.SetFrom(fullName, (unsigned)index);
+ extensionDelimiter = '.';
+ extension = fullName.Ptr((unsigned)index + 1);
+ }
+}
+
+
+struct CArcLevelInfo
+{
+ UString Error;
+ UString Path;
+ UString Type;
+ UString ErrorType;
+ UString ErrorFlags;
+};
+
+
+struct CArcLevelsInfo
+{
+ CObjectVector<CArcLevelInfo> Levels; // LastLevel Is NON-OPEN
+};
+
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+
+
+static void GetFolderLevels(CMyComPtr<IFolderFolder> &folder, CArcLevelsInfo &levels)
+{
+ levels.Levels.Clear();
+
+ CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+ folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+
+ if (!getFolderArcProps)
+ return;
+ CMyComPtr<IFolderArcProps> arcProps;
+ getFolderArcProps->GetFolderArcProps(&arcProps);
+ if (!arcProps)
+ return;
+
+ UInt32 numLevels;
+ if (arcProps->GetArcNumLevels(&numLevels) != S_OK)
+ numLevels = 0;
+
+ for (UInt32 level = 0; level <= numLevels; level++)
+ {
+ const PROPID propIDs[] = { kpidError, kpidPath, kpidType, kpidErrorType };
+
+ CArcLevelInfo lev;
+
+ for (Int32 i = 0; i < 4; i++)
+ {
+ CMyComBSTR name;
+ NCOM::CPropVariant prop;
+ if (arcProps->GetArcProp(level, propIDs[i], &prop) != S_OK)
+ continue;
+ if (prop.vt != VT_EMPTY)
+ {
+ UString *s = NULL;
+ switch (propIDs[i])
+ {
+ case kpidError: s = &lev.Error; break;
+ case kpidPath: s = &lev.Path; break;
+ case kpidType: s = &lev.Type; break;
+ case kpidErrorType: s = &lev.ErrorType; break;
+ }
+ *s = (prop.vt == VT_BSTR) ? prop.bstrVal : L"?";
+ }
+ }
+
+ {
+ NCOM::CPropVariant prop;
+ if (arcProps->GetArcProp(level, kpidErrorFlags, &prop) == S_OK)
+ {
+ UInt32 flags = GetOpenArcErrorFlags(prop);
+ if (flags != 0)
+ lev.ErrorFlags = GetOpenArcErrorMessage(flags);
+ }
+ }
+
+ levels.Levels.Add(lev);
+ }
+}
+
+static UString GetBracedType(const wchar_t *type)
+{
+ UString s ('[');
+ s += type;
+ s += ']';
+ return s;
+}
+
+static void GetFolderError(CMyComPtr<IFolderFolder> &folder, UString &open_Errors, UString &nonOpen_Errors)
+{
+ CArcLevelsInfo levs;
+ GetFolderLevels(folder, levs);
+ open_Errors.Empty();
+ nonOpen_Errors.Empty();
+
+ FOR_VECTOR (i, levs.Levels)
+ {
+ bool isNonOpenLevel = (i == 0);
+ const CArcLevelInfo &lev = levs.Levels[levs.Levels.Size() - 1 - i];
+
+ UString m;
+
+ if (!lev.ErrorType.IsEmpty())
+ {
+ m = MyFormatNew(IDS_CANT_OPEN_AS_TYPE, GetBracedType(lev.ErrorType));
+ if (!isNonOpenLevel)
+ {
+ m.Add_LF();
+ m += MyFormatNew(IDS_IS_OPEN_AS_TYPE, GetBracedType(lev.Type));
+ }
+ }
+
+ if (!lev.Error.IsEmpty())
+ {
+ if (!m.IsEmpty())
+ m.Add_LF();
+ m += GetBracedType(lev.Type);
+ m += " : ";
+ m += GetNameOfProperty(kpidError, L"Error");
+ m += " : ";
+ m += lev.Error;
+ }
+
+ if (!lev.ErrorFlags.IsEmpty())
+ {
+ if (!m.IsEmpty())
+ m.Add_LF();
+ m += GetNameOfProperty(kpidErrorFlags, L"Errors");
+ m += ": ";
+ m += lev.ErrorFlags;
+ }
+
+ if (!m.IsEmpty())
+ {
+ if (isNonOpenLevel)
+ {
+ UString &s = nonOpen_Errors;
+ s += lev.Path;
+ s.Add_LF();
+ s += m;
+ }
+ else
+ {
+ UString &s = open_Errors;
+ if (!s.IsEmpty())
+ s += "--------------------\n";
+ s += lev.Path;
+ s.Add_LF();
+ s += m;
+ }
+ }
+ }
+}
+
+#ifdef _MSC_VER
+#pragma warning(error : 4702) // unreachable code
+#endif
+
+HRESULT CFfpOpen::OpenFileFolderPlugin(IInStream *inStream,
+ const FString &path, const UString &arcFormat, HWND parentWindow)
+{
+ /*
+ CObjectVector<CPluginInfo> plugins;
+ ReadFileFolderPluginInfoList(plugins);
+ */
+
+ FString extension, name, pureName, dot;
+
+ const int slashPos = path.ReverseFind_PathSepar();
+ FString dirPrefix;
+ FString fileName;
+ if (slashPos >= 0)
+ {
+ dirPrefix.SetFrom(path, (unsigned)(slashPos + 1));
+ fileName = path.Ptr((unsigned)(slashPos + 1));
+ }
+ else
+ fileName = path;
+
+ SplitNameToPureNameAndExtension(fileName, pureName, dot, extension);
+
+ /*
+ if (!extension.IsEmpty())
+ {
+ CExtInfo extInfo;
+ if (ReadInternalAssociation(extension, extInfo))
+ {
+ for (int i = extInfo.Plugins.Size() - 1; i >= 0; i--)
+ {
+ int pluginIndex = FindPlugin(plugins, extInfo.Plugins[i]);
+ if (pluginIndex >= 0)
+ {
+ const CPluginInfo plugin = plugins[pluginIndex];
+ plugins.Delete(pluginIndex);
+ plugins.Insert(0, plugin);
+ }
+ }
+ }
+ }
+ */
+
+ ErrorMessage.Empty();
+
+ // FOR_VECTOR (i, plugins)
+ // {
+ /*
+ const CPluginInfo &plugin = plugins[i];
+ if (!plugin.ClassID_Defined && !plugin.FilePath.IsEmpty())
+ continue;
+ */
+ CPluginLibrary library;
+
+ CThreadArchiveOpen t;
+
+ // if (plugin.FilePath.IsEmpty())
+ t.FolderManager = new CArchiveFolderManager;
+ /*
+ else if (library.LoadAndCreateManager(plugin.FilePath, plugin.ClassID, &t.FolderManager) != S_OK)
+ continue;
+ */
+
+ COpenArchiveCallback OpenCallbackSpec_loc;
+ t.OpenCallbackSpec = &OpenCallbackSpec_loc;
+ /*
+ t.OpenCallbackSpec = new COpenArchiveCallback;
+ t.OpenCallbackSpec_Ref = t.OpenCallbackSpec;
+ */
+ t.OpenCallbackSpec->PasswordIsDefined = Encrypted;
+ t.OpenCallbackSpec->Password = Password;
+ t.OpenCallbackSpec->ParentWindow = parentWindow;
+
+ /* COpenCallbackImp object will exist after Open stage for multivolume archives */
+ COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
+ t.OpenCallbackProgress = openCallbackSpec;
+ // openCallbackSpec->Callback_Ref = t.OpenCallbackSpec;
+ // we set pointer without reference counter:
+ openCallbackSpec->Callback =
+ // openCallbackSpec->ReOpenCallback =
+ t.OpenCallbackSpec;
+
+ if (inStream)
+ openCallbackSpec->SetSubArchiveName(fs2us(fileName));
+ else
+ {
+ RINOK(openCallbackSpec->Init2(dirPrefix, fileName))
+ }
+
+ t.InStream = inStream;
+ t.Path = fs2us(path);
+ t.ArcFormat = arcFormat;
+
+ const UString progressTitle = LangString(IDS_OPENNING);
+ {
+ CProgressDialog &pd = t.OpenCallbackSpec->ProgressDialog;
+ pd.MainWindow = parentWindow;
+ pd.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+ pd.MainAddTitle = progressTitle + L' ';
+ pd.WaitMode = true;
+ }
+
+ {
+ NWindows::CThread thread;
+ const WRes wres = thread.Create(CThreadArchiveOpen::MyThreadFunction, &t);
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ t.OpenCallbackSpec->StartProgressDialog(progressTitle, thread);
+ }
+
+ /*
+ if archive is multivolume:
+ COpenCallbackImp object will exist after Open stage.
+ COpenCallbackImp object will be deleted when last reference
+ from each volume object (CInFileStreamVol) will be closed (when archive will be closed).
+ */
+ t.OpenCallbackProgress.Release();
+
+ if (t.Result != S_FALSE && t.Result != S_OK)
+ return t.Result;
+
+ if (t.Folder)
+ {
+ UString open_Errors, nonOpen_Errors;
+ GetFolderError(t.Folder, open_Errors, nonOpen_Errors);
+ if (!nonOpen_Errors.IsEmpty())
+ {
+ ErrorMessage = nonOpen_Errors;
+ // if (t.Result != S_OK) return t.Result;
+ /* if there are good open leves, and non0open level,
+ we could force error as critical error and return error here
+ but it's better to allow to open such rachives */
+ // return S_FALSE;
+ }
+ }
+
+ // if (openCallbackSpec->PasswordWasAsked)
+ {
+ Encrypted = t.OpenCallbackSpec->PasswordIsDefined;
+ Password = t.OpenCallbackSpec->Password;
+ }
+
+ if (t.Result == S_OK)
+ {
+ Library.Attach(library.Detach());
+ // Folder.Attach(t.Folder.Detach());
+ Folder = t.Folder;
+ }
+
+ return t.Result;
+ // }
+}
diff --git a/CPP/7zip/UI/FileManager/FileFolderPluginOpen.h b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.h
new file mode 100644
index 0000000..8802765
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FileFolderPluginOpen.h
@@ -0,0 +1,27 @@
+// FileFolderPluginOpen.h
+
+#ifndef ZIP7_INC_FILE_FOLDER_PLUGIN_OPEN_H
+#define ZIP7_INC_FILE_FOLDER_PLUGIN_OPEN_H
+
+#include "../../../Windows/DLL.h"
+
+struct CFfpOpen
+{
+ Z7_CLASS_NO_COPY(CFfpOpen)
+public:
+ // out:
+ bool Encrypted;
+ UString Password;
+
+ NWindows::NDLL::CLibrary Library;
+ CMyComPtr<IFolderFolder> Folder;
+ UString ErrorMessage;
+
+ CFfpOpen(): Encrypted (false) {}
+
+ HRESULT OpenFileFolderPlugin(IInStream *inStream,
+ const FString &path, const UString &arcFormat, HWND parentWindow);
+};
+
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FilePlugins.cpp b/CPP/7zip/UI/FileManager/FilePlugins.cpp
new file mode 100644
index 0000000..cf20970
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FilePlugins.cpp
@@ -0,0 +1,78 @@
+// FilePlugins.cpp
+
+#include "StdAfx.h"
+
+#include "../Agent/Agent.h"
+
+#include "FilePlugins.h"
+#include "PluginLoader.h"
+#include "StringUtils.h"
+
+int CExtDatabase::FindExt(const UString &ext) const
+{
+ FOR_VECTOR (i, Exts)
+ if (Exts[i].Ext.IsEqualTo_NoCase(ext))
+ return (int)i;
+ return -1;
+}
+
+void CExtDatabase::Read()
+{
+ /*
+ ReadFileFolderPluginInfoList(Plugins);
+ FOR_VECTOR (pluginIndex, Plugins)
+ */
+ {
+ // const CPluginInfo &plugin = Plugins[pluginIndex];
+
+ CPluginLibrary pluginLib;
+ CMyComPtr<IFolderManager> folderManager;
+
+ // if (plugin.FilePath.IsEmpty())
+ folderManager = new CArchiveFolderManager;
+ /*
+ else
+ {
+ if (!plugin.ClassID_Defined)
+ continue;
+ if (pluginLib.LoadAndCreateManager(plugin.FilePath, plugin.ClassID, &folderManager) != S_OK)
+ continue;
+ }
+ */
+ CMyComBSTR extBSTR;
+ if (folderManager->GetExtensions(&extBSTR) != S_OK)
+ return;
+ UStringVector exts;
+ SplitString((const wchar_t *)extBSTR, exts);
+ FOR_VECTOR (i, exts)
+ {
+ const UString &ext = exts[i];
+ #ifdef UNDER_CE
+ if (ext == L"cab")
+ continue;
+ #endif
+
+ Int32 iconIndex;
+ CMyComBSTR iconPath;
+ CPluginToIcon plugPair;
+ // plugPair.PluginIndex = pluginIndex;
+ if (folderManager->GetIconPath(ext, &iconPath, &iconIndex) == S_OK)
+ if (iconPath)
+ {
+ plugPair.IconPath = (const wchar_t *)iconPath;
+ plugPair.IconIndex = iconIndex;
+ }
+
+ const int index = FindExt(ext);
+ if (index >= 0)
+ Exts[index].Plugins.Add(plugPair);
+ else
+ {
+ CExtPlugins extInfo;
+ extInfo.Plugins.Add(plugPair);
+ extInfo.Ext = ext;
+ Exts.Add(extInfo);
+ }
+ }
+ }
+}
diff --git a/CPP/7zip/UI/FileManager/FilePlugins.h b/CPP/7zip/UI/FileManager/FilePlugins.h
new file mode 100644
index 0000000..db8ec39
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FilePlugins.h
@@ -0,0 +1,33 @@
+// FilePlugins.h
+
+#ifndef ZIP7_INC_FILE_PLUGINS_H
+#define ZIP7_INC_FILE_PLUGINS_H
+
+#include "RegistryPlugins.h"
+
+struct CPluginToIcon
+{
+ // unsigned PluginIndex;
+ int IconIndex;
+ UString IconPath;
+
+ CPluginToIcon(): IconIndex(-1) {}
+};
+
+struct CExtPlugins
+{
+ UString Ext;
+ CObjectVector<CPluginToIcon> Plugins;
+};
+
+class CExtDatabase
+{
+ int FindExt(const UString &ext) const;
+public:
+ CObjectVector<CExtPlugins> Exts;
+ // CObjectVector<CPluginInfo> Plugins;
+
+ void Read();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FoldersPage.cpp b/CPP/7zip/UI/FileManager/FoldersPage.cpp
new file mode 100644
index 0000000..7e74635
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage.cpp
@@ -0,0 +1,172 @@
+// FoldersPage.cpp
+
+#include "StdAfx.h"
+
+#include "FoldersPageRes.h"
+#include "FoldersPage.h"
+
+#include "../FileManager/BrowseDialog.h"
+#include "../FileManager/HelpUtils.h"
+#include "../FileManager/LangUtils.h"
+
+using namespace NWindows;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_FOLDERS_WORKING_FOLDER,
+ IDR_FOLDERS_WORK_SYSTEM,
+ IDR_FOLDERS_WORK_CURRENT,
+ IDR_FOLDERS_WORK_SPECIFIED,
+ IDX_FOLDERS_WORK_FOR_REMOVABLE
+};
+#endif
+
+static const unsigned kWorkModeButtons[] =
+{
+ IDR_FOLDERS_WORK_SYSTEM,
+ IDR_FOLDERS_WORK_CURRENT,
+ IDR_FOLDERS_WORK_SPECIFIED
+};
+
+#define kFoldersTopic "fm/options.htm#folders"
+
+static const unsigned kNumWorkModeButtons = Z7_ARRAY_SIZE(kWorkModeButtons);
+
+bool CFoldersPage::OnInit()
+{
+ _initMode = true;
+ _needSave = false;
+
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ #endif
+ m_WorkDirInfo.Load();
+
+ CheckButton(IDX_FOLDERS_WORK_FOR_REMOVABLE, m_WorkDirInfo.ForRemovableOnly);
+
+ CheckRadioButton(
+ kWorkModeButtons[0],
+ kWorkModeButtons[kNumWorkModeButtons - 1],
+ kWorkModeButtons[m_WorkDirInfo.Mode]);
+
+ m_WorkPath.Init(*this, IDE_FOLDERS_WORK_PATH);
+
+ m_WorkPath.SetText(fs2us(m_WorkDirInfo.Path));
+
+ MyEnableControls();
+
+ _initMode = false;
+ return CPropertyPage::OnInit();
+}
+
+int CFoldersPage::GetWorkMode() const
+{
+ for (unsigned i = 0; i < kNumWorkModeButtons; i++)
+ if (IsButtonCheckedBool(kWorkModeButtons[i]))
+ return (int)i;
+ throw 0;
+}
+
+void CFoldersPage::MyEnableControls()
+{
+ bool enablePath = (GetWorkMode() == NWorkDir::NMode::kSpecified);
+ m_WorkPath.Enable(enablePath);
+ EnableItem(IDB_FOLDERS_WORK_PATH, enablePath);
+}
+
+void CFoldersPage::GetWorkDir(NWorkDir::CInfo &workDirInfo)
+{
+ UString s;
+ m_WorkPath.GetText(s);
+ workDirInfo.Path = us2fs(s);
+ workDirInfo.ForRemovableOnly = IsButtonCheckedBool(IDX_FOLDERS_WORK_FOR_REMOVABLE);
+ workDirInfo.Mode = NWorkDir::NMode::EEnum(GetWorkMode());
+}
+
+/*
+bool CFoldersPage::WasChanged()
+{
+ NWorkDir::CInfo workDirInfo;
+ GetWorkDir(workDirInfo);
+ return (workDirInfo.Mode != m_WorkDirInfo.Mode ||
+ workDirInfo.ForRemovableOnly != m_WorkDirInfo.ForRemovableOnly ||
+ workDirInfo.Path.Compare(m_WorkDirInfo.Path) != 0);
+}
+*/
+
+void CFoldersPage::ModifiedEvent()
+{
+ if (!_initMode)
+ {
+ _needSave = true;
+ Changed();
+ }
+ /*
+ if (WasChanged())
+ Changed();
+ else
+ UnChanged();
+ */
+}
+
+bool CFoldersPage::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ for (unsigned i = 0; i < kNumWorkModeButtons; i++)
+ if (buttonID == kWorkModeButtons[i])
+ {
+ MyEnableControls();
+ ModifiedEvent();
+ return true;
+ }
+
+ switch (buttonID)
+ {
+ case IDB_FOLDERS_WORK_PATH:
+ OnFoldersWorkButtonPath();
+ return true;
+ case IDX_FOLDERS_WORK_FOR_REMOVABLE:
+ break;
+ default:
+ return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+ }
+
+ ModifiedEvent();
+ return true;
+}
+
+bool CFoldersPage::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+ if (code == EN_CHANGE && itemID == IDE_FOLDERS_WORK_PATH)
+ {
+ ModifiedEvent();
+ return true;
+ }
+ return CPropertyPage::OnCommand(code, itemID, lParam);
+}
+
+void CFoldersPage::OnFoldersWorkButtonPath()
+{
+ UString currentPath;
+ m_WorkPath.GetText(currentPath);
+ UString title = LangString(IDS_FOLDERS_SET_WORK_PATH_TITLE);
+ UString resultPath;
+ if (MyBrowseForFolder(*this, title, currentPath, resultPath))
+ m_WorkPath.SetText(resultPath);
+}
+
+LONG CFoldersPage::OnApply()
+{
+ if (_needSave)
+ {
+ GetWorkDir(m_WorkDirInfo);
+ m_WorkDirInfo.Save();
+ _needSave = false;
+ }
+ return PSNRET_NOERROR;
+}
+
+void CFoldersPage::OnNotifyHelp()
+{
+ ShowHelpWindow(kFoldersTopic);
+}
diff --git a/CPP/7zip/UI/FileManager/FoldersPage.h b/CPP/7zip/UI/FileManager/FoldersPage.h
new file mode 100644
index 0000000..09b6cdd
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage.h
@@ -0,0 +1,32 @@
+// FoldersPage.h
+
+#ifndef ZIP7_INC_FOLDERS_PAGE_H
+#define ZIP7_INC_FOLDERS_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+
+#include "../Common/ZipRegistry.h"
+
+class CFoldersPage : public NWindows::NControl::CPropertyPage
+{
+ NWorkDir::CInfo m_WorkDirInfo;
+ NWindows::NControl::CDialogChildControl m_WorkPath;
+
+ bool _needSave;
+ bool _initMode;
+
+ void MyEnableControls();
+ void ModifiedEvent();
+
+ void OnFoldersWorkButtonPath();
+ int GetWorkMode() const;
+ void GetWorkDir(NWorkDir::CInfo &workDirInfo);
+ // bool WasChanged();
+ virtual bool OnInit() Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam) Z7_override;
+ virtual void OnNotifyHelp() Z7_override;
+ virtual LONG OnApply() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/FoldersPage.rc b/CPP/7zip/UI/FileManager/FoldersPage.rc
new file mode 100644
index 0000000..cb345ea
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage.rc
@@ -0,0 +1,23 @@
+#include "FoldersPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 100
+
+IDD_FOLDERS MY_PAGE
+#include "FoldersPage2.rc"
+
+#ifdef UNDER_CE
+
+#undef xc
+#define xc SMALL_PAGE_SIZE_X
+
+IDD_FOLDERS_2 MY_PAGE
+#include "FoldersPage2.rc"
+
+#endif
+
+STRINGTABLE
+BEGIN
+ IDS_FOLDERS_SET_WORK_PATH_TITLE "Specify a location for temporary archive files."
+END
diff --git a/CPP/7zip/UI/FileManager/FoldersPage2.rc b/CPP/7zip/UI/FileManager/FoldersPage2.rc
new file mode 100644
index 0000000..9b9276e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPage2.rc
@@ -0,0 +1,16 @@
+CAPTION "Folders"
+BEGIN
+ // GROUPBOX "&Working folder", IDT_FOLDERS_WORKING_FOLDER, m, m, xc, 98
+
+ LTEXT "&Working folder", IDT_FOLDERS_WORKING_FOLDER, m, m, xc, 8
+ CONTROL "&System temp folder", IDR_FOLDERS_WORK_SYSTEM, "Button", BS_AUTORADIOBUTTON | WS_GROUP,
+ m, 20, xc, 10
+ CONTROL "&Current", IDR_FOLDERS_WORK_CURRENT, "Button", BS_AUTORADIOBUTTON,
+ m, 34, xc, 10
+ CONTROL "Specified:", IDR_FOLDERS_WORK_SPECIFIED, "Button", BS_AUTORADIOBUTTON,
+ m, 48, xc, 10
+ EDITTEXT IDE_FOLDERS_WORK_PATH, m + m, 62, xc - m - m - bxsDots, 14, ES_AUTOHSCROLL
+ PUSHBUTTON "...", IDB_FOLDERS_WORK_PATH, xs - m - bxsDots, 61, bxsDots, bys
+ CONTROL "Use for removable drives only", IDX_FOLDERS_WORK_FOR_REMOVABLE, MY_CHECKBOX,
+ m, 86, xc, 10
+END
diff --git a/CPP/7zip/UI/FileManager/FoldersPageRes.h b/CPP/7zip/UI/FileManager/FoldersPageRes.h
new file mode 100644
index 0000000..ba9ab73
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/FoldersPageRes.h
@@ -0,0 +1,12 @@
+#define IDD_FOLDERS 2400
+#define IDD_FOLDERS_2 12400
+
+#define IDT_FOLDERS_WORKING_FOLDER 2401
+#define IDR_FOLDERS_WORK_SYSTEM 2402
+#define IDR_FOLDERS_WORK_CURRENT 2403
+#define IDR_FOLDERS_WORK_SPECIFIED 2404
+#define IDX_FOLDERS_WORK_FOR_REMOVABLE 2405
+#define IDS_FOLDERS_SET_WORK_PATH_TITLE 2406
+
+#define IDE_FOLDERS_WORK_PATH 100
+#define IDB_FOLDERS_WORK_PATH 101
diff --git a/CPP/7zip/UI/FileManager/FormatUtils.cpp b/CPP/7zip/UI/FileManager/FormatUtils.cpp
index 4f7ef74..2143c3f 100644
--- a/CPP/7zip/UI/FileManager/FormatUtils.cpp
+++ b/CPP/7zip/UI/FileManager/FormatUtils.cpp
@@ -1,28 +1,28 @@
-// FormatUtils.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "FormatUtils.h"
-
-#include "LangUtils.h"
-
-UString NumberToString(UInt64 number)
-{
- wchar_t numberString[32];
- ConvertUInt64ToString(number, numberString);
- return numberString;
-}
-
-UString MyFormatNew(const UString &format, const UString &argument)
-{
- UString result = format;
- result.Replace(L"{0}", argument);
- return result;
-}
-
-UString MyFormatNew(UINT resourceID, const UString &argument)
-{
- return MyFormatNew(LangString(resourceID), argument);
-}
+// FormatUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "FormatUtils.h"
+
+#include "LangUtils.h"
+
+UString NumberToString(UInt64 number)
+{
+ wchar_t numberString[32];
+ ConvertUInt64ToString(number, numberString);
+ return numberString;
+}
+
+UString MyFormatNew(const UString &format, const UString &argument)
+{
+ UString result = format;
+ result.Replace(L"{0}", argument);
+ return result;
+}
+
+UString MyFormatNew(UINT resourceID, const UString &argument)
+{
+ return MyFormatNew(LangString(resourceID), argument);
+}
diff --git a/CPP/7zip/UI/FileManager/FormatUtils.h b/CPP/7zip/UI/FileManager/FormatUtils.h
index f221cd2..1db08ef 100644
--- a/CPP/7zip/UI/FileManager/FormatUtils.h
+++ b/CPP/7zip/UI/FileManager/FormatUtils.h
@@ -1,14 +1,14 @@
-// FormatUtils.h
-
-#ifndef __FORMAT_UTILS_H
-#define __FORMAT_UTILS_H
-
-#include "../../../Common/MyTypes.h"
-#include "../../../Common/MyString.h"
-
-UString NumberToString(UInt64 number);
-
-UString MyFormatNew(const UString &format, const UString &argument);
-UString MyFormatNew(UINT resourceID, const UString &argument);
-
-#endif
+// FormatUtils.h
+
+#ifndef ZIP7_INC_FORMAT_UTILS_H
+#define ZIP7_INC_FORMAT_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+UString NumberToString(UInt64 number);
+
+UString MyFormatNew(const UString &format, const UString &argument);
+UString MyFormatNew(UINT resourceID, const UString &argument);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/HelpUtils.cpp b/CPP/7zip/UI/FileManager/HelpUtils.cpp
new file mode 100644
index 0000000..d5b6a58
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/HelpUtils.cpp
@@ -0,0 +1,78 @@
+// HelpUtils.cpp
+
+#include "StdAfx.h"
+
+#include "HelpUtils.h"
+
+#if defined(UNDER_CE) || defined(__MINGW32_VERSION)
+
+void ShowHelpWindow(LPCSTR)
+{
+}
+
+#else
+
+/* USE_EXTERNAL_HELP creates new help process window for each HtmlHelp() call.
+ HtmlHelp() call uses one window. */
+
+#if defined(__MINGW32_VERSION) /* || defined(Z7_OLD_WIN_SDK) */
+#define USE_EXTERNAL_HELP
+#endif
+
+// #define USE_EXTERNAL_HELP
+
+#ifdef USE_EXTERNAL_HELP
+
+#include "../../../Windows/ProcessUtils.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+
+#else
+#include <HtmlHelp.h>
+#endif
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+
+#define kHelpFileName "7-zip.chm::/"
+
+void ShowHelpWindow(LPCSTR topicFile)
+{
+ FString path = NWindows::NDLL::GetModuleDirPrefix();
+ path += kHelpFileName;
+ path += topicFile;
+ #ifdef USE_EXTERNAL_HELP
+ FString prog;
+
+ #ifdef UNDER_CE
+ prog = "\\Windows\\";
+ #else
+ if (!NWindows::NFile::NDir::GetWindowsDir(prog))
+ return;
+ NWindows::NFile::NName::NormalizeDirPathPrefix(prog);
+ #endif
+ prog += "hh.exe";
+
+ UString params;
+ params += '"';
+ params += fs2us(path);
+ params += '"';
+
+ NWindows::CProcess process;
+ const WRes wres = process.Create(fs2us(prog), params, NULL); // curDir);
+ if (wres != 0)
+ {
+ /*
+ HRESULT hres = HRESULT_FROM_WIN32(wres);
+ ErrorMessageHRESULT(hres, imageName);
+ return hres;
+ */
+ }
+ #else
+ // HWND hwnd = NULL;
+ HtmlHelp(NULL, GetSystemString(fs2us(path)), HH_DISPLAY_TOPIC, 0);
+ #endif
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/HelpUtils.h b/CPP/7zip/UI/FileManager/HelpUtils.h
new file mode 100644
index 0000000..d7bdf45
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/HelpUtils.h
@@ -0,0 +1,10 @@
+// HelpUtils.h
+
+#ifndef ZIP7_INC_HELP_UTILS_H
+#define ZIP7_INC_HELP_UTILS_H
+
+#include "../../../Common/MyString.h"
+
+void ShowHelpWindow(LPCSTR topicFile);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/IFolder.h b/CPP/7zip/UI/FileManager/IFolder.h
new file mode 100644
index 0000000..1ebdf7e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/IFolder.h
@@ -0,0 +1,187 @@
+// IFolder.h
+
+#ifndef ZIP7_INC_IFOLDER_H
+#define ZIP7_INC_IFOLDER_H
+
+#include "../../IProgress.h"
+#include "../../IStream.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+#define Z7_IFACE_CONSTR_FOLDER_SUB(i, base, n) \
+ Z7_DECL_IFACE_7ZIP_SUB(i, base, 8, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACE_CONSTR_FOLDER(i, n) \
+ Z7_IFACE_CONSTR_FOLDER_SUB(i, IUnknown, n)
+
+namespace NPlugin
+{
+ enum
+ {
+ kName = 0,
+ kType,
+ kClassID,
+ kOptionsClassID
+ };
+}
+
+#define Z7_IFACEM_IFolderFolder(x) \
+ x(LoadItems()) \
+ x(GetNumberOfItems(UInt32 *numItems)) \
+ x(GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value)) \
+ x(BindToFolder(UInt32 index, IFolderFolder **resultFolder)) \
+ x(BindToFolder(const wchar_t *name, IFolderFolder **resultFolder)) \
+ x(BindToParentFolder(IFolderFolder **resultFolder)) \
+ x(GetNumberOfProperties(UInt32 *numProperties)) \
+ x(GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ x(GetFolderProperty(PROPID propID, PROPVARIANT *value)) \
+
+Z7_IFACE_CONSTR_FOLDER(IFolderFolder, 0x00)
+
+/*
+ IFolderAltStreams::
+ BindToAltStreams((UInt32)(Int32)-1, ... ) means alt streams of that folder
+*/
+
+#define Z7_IFACEM_IFolderAltStreams(x) \
+ x(BindToAltStreams(UInt32 index, IFolderFolder **resultFolder)) \
+ x(BindToAltStreams(const wchar_t *name, IFolderFolder **resultFolder)) \
+ x(AreAltStreamsSupported(UInt32 index, Int32 *isSupported)) \
+
+Z7_IFACE_CONSTR_FOLDER(IFolderAltStreams, 0x17)
+
+#define Z7_IFACEM_IFolderWasChanged(x) \
+ x(WasChanged(Int32 *wasChanged))
+Z7_IFACE_CONSTR_FOLDER(IFolderWasChanged, 0x04)
+
+ /* x(SetTotalFiles(UInt64 total)) */ \
+ /* x(SetCompletedFiles(const UInt64 *completedValue)) */ \
+#define Z7_IFACEM_IFolderOperationsExtractCallback(x) \
+ x(AskWrite( \
+ const wchar_t *srcPath, \
+ Int32 srcIsFolder, \
+ const FILETIME *srcTime, \
+ const UInt64 *srcSize, \
+ const wchar_t *destPathRequest, \
+ BSTR *destPathResult, \
+ Int32 *writeAnswer)) \
+ x(ShowMessage(const wchar_t *message)) \
+ x(SetCurrentFilePath(const wchar_t *filePath)) \
+ x(SetNumFiles(UInt64 numFiles)) \
+
+Z7_IFACE_CONSTR_FOLDER_SUB(IFolderOperationsExtractCallback, IProgress, 0x0B)
+
+
+#define Z7_IFACEM_IFolderOperations(x) \
+ x(CreateFolder(const wchar_t *name, IProgress *progress)) \
+ x(CreateFile(const wchar_t *name, IProgress *progress)) \
+ x(Rename(UInt32 index, const wchar_t *newName, IProgress *progress)) \
+ x(Delete(const UInt32 *indices, UInt32 numItems, IProgress *progress)) \
+ x(CopyTo(Int32 moveMode, const UInt32 *indices, UInt32 numItems, \
+ Int32 includeAltStreams, Int32 replaceAltStreamCharsMode, \
+ const wchar_t *path, IFolderOperationsExtractCallback *callback)) \
+ x(CopyFrom(Int32 moveMode, const wchar_t *fromFolderPath, \
+ const wchar_t * const *itemsPaths, UInt32 numItems, IProgress *progress)) \
+ x(SetProperty(UInt32 index, PROPID propID, const PROPVARIANT *value, IProgress *progress)) \
+ x(CopyFromFile(UInt32 index, const wchar_t *fullFilePath, IProgress *progress)) \
+
+Z7_IFACE_CONSTR_FOLDER(IFolderOperations, 0x13)
+
+/*
+FOLDER_INTERFACE2(IFolderOperationsDeleteToRecycleBin, 0x06, 0x03)
+{
+ x(DeleteToRecycleBin(const UInt32 *indices, UInt32 numItems, IProgress *progress)) \
+};
+*/
+
+#define Z7_IFACEM_IFolderGetSystemIconIndex(x) \
+ x(GetSystemIconIndex(UInt32 index, Int32 *iconIndex))
+Z7_IFACE_CONSTR_FOLDER(IFolderGetSystemIconIndex, 0x07)
+
+#define Z7_IFACEM_IFolderGetItemFullSize(x) \
+ x(GetItemFullSize(UInt32 index, PROPVARIANT *value, IProgress *progress))
+Z7_IFACE_CONSTR_FOLDER(IFolderGetItemFullSize, 0x08)
+
+#define Z7_IFACEM_IFolderCalcItemFullSize(x) \
+ x(CalcItemFullSize(UInt32 index, IProgress *progress))
+Z7_IFACE_CONSTR_FOLDER(IFolderCalcItemFullSize, 0x14)
+
+#define Z7_IFACEM_IFolderClone(x) \
+ x(Clone(IFolderFolder **resultFolder))
+Z7_IFACE_CONSTR_FOLDER(IFolderClone, 0x09)
+
+#define Z7_IFACEM_IFolderSetFlatMode(x) \
+ x(SetFlatMode(Int32 flatMode))
+Z7_IFACE_CONSTR_FOLDER(IFolderSetFlatMode, 0x0A)
+
+/*
+#define Z7_IFACEM_IFolderSetShowNtfsStreamsMode(x) \
+ x(SetShowNtfsStreamsMode(Int32 showStreamsMode))
+Z7_IFACE_CONSTR_FOLDER(IFolderSetShowNtfsStreamsMode, 0xFA)
+*/
+
+#define Z7_IFACEM_IFolderProperties(x) \
+ x(GetNumberOfFolderProperties(UInt32 *numProperties)) \
+ x(GetFolderPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+
+Z7_IFACE_CONSTR_FOLDER(IFolderProperties, 0x0E)
+
+#define Z7_IFACEM_IFolderArcProps(x) \
+ x(GetArcNumLevels(UInt32 *numLevels)) \
+ x(GetArcProp(UInt32 level, PROPID propID, PROPVARIANT *value)) \
+ x(GetArcNumProps(UInt32 level, UInt32 *numProps)) \
+ x(GetArcPropInfo(UInt32 level, UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ x(GetArcProp2(UInt32 level, PROPID propID, PROPVARIANT *value)) \
+ x(GetArcNumProps2(UInt32 level, UInt32 *numProps)) \
+ x(GetArcPropInfo2(UInt32 level, UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+
+Z7_IFACE_CONSTR_FOLDER(IFolderArcProps, 0x10)
+
+#define Z7_IFACEM_IGetFolderArcProps(x) \
+ x(GetFolderArcProps(IFolderArcProps **object))
+Z7_IFACE_CONSTR_FOLDER(IGetFolderArcProps, 0x11)
+
+#define Z7_IFACEM_IFolderCompare(x) \
+ x##2(Int32, CompareItems(UInt32 index1, UInt32 index2, PROPID propID, Int32 propIsRaw))
+Z7_IFACE_CONSTR_FOLDER(IFolderCompare, 0x15)
+
+#define Z7_IFACEM_IFolderGetItemName(x) \
+ x(GetItemName(UInt32 index, const wchar_t **name, unsigned *len)) \
+ x(GetItemPrefix(UInt32 index, const wchar_t **name, unsigned *len)) \
+ x##2(UInt64, GetItemSize(UInt32 index)) \
+
+Z7_IFACE_CONSTR_FOLDER(IFolderGetItemName, 0x16)
+
+
+#define Z7_IFACEM_IFolderManager(x) \
+ x(OpenFolderFile(IInStream *inStream, const wchar_t *filePath, const wchar_t *arcFormat, IFolderFolder **resultFolder, IProgress *progress)) \
+ x(GetExtensions(BSTR *extensions)) \
+ x(GetIconPath(const wchar_t *ext, BSTR *iconPath, Int32 *iconIndex)) \
+
+ // x(GetTypes(BSTR *types))
+ // x(CreateFolderFile(const wchar_t *type, const wchar_t *filePath, IProgress *progress))
+
+Z7_DECL_IFACE_7ZIP(IFolderManager, 9, 5)
+ { Z7_IFACE_COM7_PURE(IFolderManager) };
+
+/*
+ const CMy_STATPROPSTG_2 &srcItem = k[index]; \
+ *propID = srcItem.propid; *varType = srcItem.vt; *name = 0; return S_OK; } \
+*/
+#define IMP_IFolderFolder_GetProp(fn, k) \
+ Z7_COM7F_IMF(fn(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+ { if (index >= Z7_ARRAY_SIZE(k)) return E_INVALIDARG; \
+ *propID = k[index]; *varType = k7z_PROPID_To_VARTYPE[(unsigned)*propID]; *name = NULL; return S_OK; } \
+
+#define IMP_IFolderFolder_Props(c) \
+ Z7_COM7F_IMF(c::GetNumberOfProperties(UInt32 *numProperties)) \
+ { *numProperties = Z7_ARRAY_SIZE(kProps); return S_OK; } \
+ IMP_IFolderFolder_GetProp(c::GetPropertyInfo, kProps)
+
+
+int CompareFileNames_ForFolderList(const wchar_t *s1, const wchar_t *s2);
+// int CompareFileNames_ForFolderList(const FChar *s1, const FChar *s2);
+
+Z7_PURE_INTERFACES_END
+#endif
diff --git a/CPP/7zip/UI/FileManager/Info.bmp b/CPP/7zip/UI/FileManager/Info.bmp
new file mode 100644
index 0000000..d769a66
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Info.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Info2.bmp b/CPP/7zip/UI/FileManager/Info2.bmp
new file mode 100644
index 0000000..af724d2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Info2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/LangPage.cpp b/CPP/7zip/UI/FileManager/LangPage.cpp
new file mode 100644
index 0000000..ec1dd2e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPage.cpp
@@ -0,0 +1,361 @@
+// LangPage.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Lang.h"
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "HelpUtils.h"
+#include "LangPage.h"
+#include "LangPageRes.h"
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+
+
+static const unsigned k_NumLangLines_EN = 429;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_LANG_LANG
+};
+#endif
+
+#define kLangTopic "fm/options.htm#language"
+
+
+struct CLangListRecord
+{
+ int Order;
+ unsigned LangInfoIndex;
+ bool IsSelected;
+ UString Mark;
+ UString Name;
+
+ CLangListRecord(): Order (10), IsSelected(false) {}
+ int Compare(const CLangListRecord &a) const
+ {
+ if (Order < a.Order) return -1;
+ if (Order > a.Order) return 1;
+ return MyStringCompareNoCase(Name, a.Name);
+ }
+};
+
+
+static void NativeLangString(UString &dest, const wchar_t *s)
+{
+ dest += " (";
+ dest += s;
+ dest += ')';
+}
+
+bool LangOpen(CLang &lang, CFSTR fileName);
+
+bool CLangPage::OnInit()
+{
+#ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+#endif
+ _langCombo.Attach(GetItem(IDC_LANG_LANG));
+
+
+ unsigned listRecords_SelectedIndex = 0;
+
+ CObjectVector<CLangListRecord> listRecords;
+ {
+ CLangListRecord listRecord;
+ listRecord.Order = 0;
+ listRecord.Mark = "---";
+ listRecord.Name = MyLoadString(IDS_LANG_ENGLISH);
+ NativeLangString(listRecord.Name, MyLoadString(IDS_LANG_NATIVE));
+ listRecord.LangInfoIndex = _langs.Size();
+ listRecords.Add(listRecord);
+ }
+
+ AStringVector names;
+ unsigned subLangIndex = 0;
+ Lang_GetShortNames_for_DefaultLang(names, subLangIndex);
+
+ const FString dirPrefix = GetLangDirPrefix();
+ NFile::NFind::CEnumerator enumerator;
+ enumerator.SetDirPrefix(dirPrefix);
+ NFile::NFind::CFileInfo fi;
+
+ CLang lang_en;
+ {
+ CLangInfo &langInfo = _langs.AddNew();
+ langInfo.Name = "-";
+ if (LangOpen(lang_en, dirPrefix + FTEXT("en.ttt")))
+ {
+ langInfo.NumLines = lang_en._ids.Size();
+ // langInfo.Comments = lang_en.Comments;
+ }
+ else
+ langInfo.NumLines = k_NumLangLines_EN;
+ NumLangLines_EN = langInfo.NumLines;
+ }
+
+ CLang lang;
+ UString error;
+ UString n;
+
+ while (enumerator.Next(fi))
+ {
+ if (fi.IsDir())
+ continue;
+ const unsigned kExtSize = 4;
+ if (fi.Name.Len() < kExtSize)
+ continue;
+ const unsigned pos = fi.Name.Len() - kExtSize;
+ if (!StringsAreEqualNoCase_Ascii(fi.Name.Ptr(pos), ".txt"))
+ {
+ // if (!StringsAreEqualNoCase_Ascii(fi.Name.Ptr(pos), ".ttt"))
+ continue;
+ }
+
+ if (!LangOpen(lang, dirPrefix + fi.Name))
+ {
+ error.Add_Space_if_NotEmpty();
+ error += fs2us(fi.Name);
+ continue;
+ }
+
+ const UString shortName = fs2us(fi.Name.Left(pos));
+
+ CLangListRecord listRecord;
+ if (!names.IsEmpty())
+ {
+ for (unsigned i = 0; i < names.Size(); i++)
+ if (shortName.IsEqualTo_Ascii_NoCase(names[i]))
+ {
+ if (subLangIndex == i || names.Size() == 1)
+ {
+ listRecord.Mark = "***";
+ // listRecord.Order = 1;
+ }
+ else
+ {
+ listRecord.Mark = "+++";
+ // listRecord.Order = 2;
+ }
+ break;
+ }
+ if (listRecord.Mark.IsEmpty())
+ {
+ const int minusPos = shortName.Find(L'-');
+ if (minusPos >= 0)
+ {
+ const UString shortName2 = shortName.Left(minusPos);
+ if (shortName2.IsEqualTo_Ascii_NoCase(names[0]))
+ {
+ listRecord.Mark = "+++";
+ // listRecord.Order = 3;
+ }
+ }
+ }
+ }
+ UString s = shortName;
+ const wchar_t *eng = lang.Get(IDS_LANG_ENGLISH);
+ if (eng)
+ s = eng;
+ const wchar_t *native = lang.Get(IDS_LANG_NATIVE);
+ if (native)
+ NativeLangString(s, native);
+
+ listRecord.Name = s;
+ listRecord.LangInfoIndex = _langs.Size();
+ listRecords.Add(listRecord);
+ if (g_LangID.IsEqualTo_NoCase(shortName))
+ listRecords_SelectedIndex = listRecords.Size() - 1;
+
+ CLangInfo &langInfo = _langs.AddNew();
+ langInfo.Comments = lang.Comments;
+ langInfo.Name = shortName;
+ unsigned numLines = lang._ids.Size();
+ if (!lang_en.IsEmpty())
+ {
+ numLines = 0;
+ unsigned i1 = 0;
+ unsigned i2 = 0;
+ for (;;)
+ {
+ UInt32 id1 = (UInt32)0 - 1;
+ UInt32 id2 = (UInt32)0 - 1;
+ bool id1_defined = false;
+ bool id2_defined = false;
+ if (i1 < lang_en._ids.Size())
+ {
+ id1 = lang_en._ids[i1];
+ id1_defined = true;
+ }
+ if (i2 < lang._ids.Size())
+ {
+ id2 = lang._ids[i2];
+ id2_defined = true;
+ }
+
+ bool id1_is_smaller = true;
+ if (id1_defined)
+ {
+ if (id2_defined)
+ {
+ if (id1 == id2)
+ {
+ i1++;
+ i2++;
+ numLines++;
+ continue;
+ }
+ if (id1 > id2)
+ id1_is_smaller = false;
+ }
+ }
+ else if (!id2_defined)
+ break;
+ else
+ id1_is_smaller = false;
+
+ n.Empty();
+ if (id1_is_smaller)
+ {
+ n.Add_UInt32(id1);
+ n += " : ";
+ n += lang_en.Get_by_index(i1);
+ langInfo.MissingLines.Add(n);
+ i1++;
+ }
+ else
+ {
+ n.Add_UInt32(id2);
+ n += " : ";
+ n += lang.Get_by_index(i2);
+ langInfo.ExtraLines.Add(n);
+ i2++;
+ }
+ }
+ }
+ langInfo.NumLines = numLines + langInfo.ExtraLines.Size();
+ }
+
+ listRecords[listRecords_SelectedIndex].IsSelected = true;
+
+ listRecords.Sort();
+ FOR_VECTOR (i, listRecords)
+ {
+ const CLangListRecord &rec= listRecords[i];
+ UString temp = rec.Name;
+ if (!rec.Mark.IsEmpty())
+ {
+ temp += " ";
+ temp += rec.Mark;
+ }
+ const int index = (int)_langCombo.AddString(temp);
+ _langCombo.SetItemData(index, (LPARAM)rec.LangInfoIndex);
+ if (rec.IsSelected)
+ _langCombo.SetCurSel(index);
+ }
+
+ ShowLangInfo();
+
+ if (!error.IsEmpty())
+ MessageBoxW(NULL, error, L"Error in Lang file", MB_ICONERROR);
+ return CPropertyPage::OnInit();
+}
+
+LONG CLangPage::OnApply()
+{
+ if (_needSave)
+ {
+ const int pathIndex = (int)_langCombo.GetItemData_of_CurSel();
+ if ((unsigned)pathIndex < _langs.Size())
+ SaveRegLang(_langs[pathIndex].Name);
+ }
+ _needSave = false;
+ #ifdef Z7_LANG
+ ReloadLang();
+ #endif
+ LangWasChanged = true;
+ return PSNRET_NOERROR;
+}
+
+void CLangPage::OnNotifyHelp()
+{
+ ShowHelpWindow(kLangTopic);
+}
+
+bool CLangPage::OnCommand(unsigned code, unsigned itemID, LPARAM param)
+{
+ if (code == CBN_SELCHANGE && itemID == IDC_LANG_LANG)
+ {
+ _needSave = true;
+ Changed();
+ ShowLangInfo();
+ return true;
+ }
+ return CPropertyPage::OnCommand(code, itemID, param);
+}
+
+static void AddVectorToString(UString &s, const UStringVector &v)
+{
+ UString a;
+ FOR_VECTOR (i, v)
+ {
+ if (i >= 50)
+ break;
+ a = v[i];
+ if (a.Len() > 1500)
+ continue;
+ if (a[0] == ';')
+ {
+ a.DeleteFrontal(1);
+ a.Trim();
+ }
+ s += a;
+ s.Add_LF();
+ }
+}
+
+static void AddVectorToString2(UString &s, const char *name, const UStringVector &v)
+{
+ if (v.IsEmpty())
+ return;
+ s.Add_LF();
+ s += "------ ";
+ s += name;
+ s += ": ";
+ s.Add_UInt32(v.Size());
+ s += " :";
+ s.Add_LF();
+ AddVectorToString(s, v);
+}
+
+void CLangPage::ShowLangInfo()
+{
+ UString s;
+ const int pathIndex = (int)_langCombo.GetItemData_of_CurSel();
+ if ((unsigned)pathIndex < _langs.Size())
+ {
+ const CLangInfo &langInfo = _langs[pathIndex];
+ const unsigned numLines = langInfo.NumLines;
+ s += langInfo.Name;
+ s += " : ";
+ s.Add_UInt32(numLines);
+ if (NumLangLines_EN != 0)
+ {
+ s += " / ";
+ s.Add_UInt32(NumLangLines_EN);
+ s += " = ";
+ s.Add_UInt32(numLines * 100 / NumLangLines_EN);
+ s += "%";
+ }
+ s.Add_LF();
+ AddVectorToString(s, langInfo.Comments);
+ AddVectorToString2(s, "Missing lines", langInfo.MissingLines);
+ AddVectorToString2(s, "Extra lines", langInfo.ExtraLines);
+ }
+ SetItemText(IDT_LANG_INFO, s);
+}
diff --git a/CPP/7zip/UI/FileManager/LangPage.h b/CPP/7zip/UI/FileManager/LangPage.h
new file mode 100644
index 0000000..e37ba05
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPage.h
@@ -0,0 +1,36 @@
+// LangPage.h
+
+#ifndef ZIP7_INC_LANG_PAGE_H
+#define ZIP7_INC_LANG_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/ComboBox.h"
+
+struct CLangInfo
+{
+ unsigned NumLines;
+ UString Name;
+ UStringVector Comments;
+ UStringVector MissingLines;
+ UStringVector ExtraLines;
+};
+
+class CLangPage: public NWindows::NControl::CPropertyPage
+{
+ NWindows::NControl::CComboBox _langCombo;
+ CObjectVector<CLangInfo> _langs;
+ unsigned NumLangLines_EN;
+ bool _needSave;
+
+ void ShowLangInfo();
+public:
+ bool LangWasChanged;
+
+ CLangPage(): _needSave(false), LangWasChanged(false) {}
+ virtual bool OnInit() Z7_override;
+ virtual void OnNotifyHelp() Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM param) Z7_override;
+ virtual LONG OnApply() Z7_override;
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LangPage.rc b/CPP/7zip/UI/FileManager/LangPage.rc
new file mode 100644
index 0000000..506f102
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPage.rc
@@ -0,0 +1,40 @@
+#include "LangPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 252
+
+#define y 32
+
+IDD_LANG DIALOG 0, 0, xs, ys MY_PAGE_STYLE MY_FONT
+CAPTION "Language"
+{
+ LTEXT "Language:", IDT_LANG_LANG, m, m, xc, 8
+ COMBOBOX IDC_LANG_LANG, m, 20, 160, yc - 20, MY_COMBO // MY_COMBO_SORTED
+ LTEXT "", IDT_LANG_INFO, m, m + y, xc, yc - y, SS_NOPREFIX
+}
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+
+IDD_LANG_2 MY_PAGE
+CAPTION "Language"
+{
+ LTEXT "Language:", IDT_LANG_LANG, m, m, xc, 8
+ COMBOBOX IDC_LANG_LANG, m, 20, xc, yc - 20, MY_COMBO // MY_COMBO_SORTED
+}
+
+#endif
+
+
+STRINGTABLE
+BEGIN
+ IDS_LANG_ENGLISH "English"
+ IDS_LANG_NATIVE "English"
+END
diff --git a/CPP/7zip/UI/FileManager/LangPageRes.h b/CPP/7zip/UI/FileManager/LangPageRes.h
new file mode 100644
index 0000000..a1ad30f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangPageRes.h
@@ -0,0 +1,9 @@
+#define IDD_LANG 2101
+#define IDD_LANG_2 12101
+
+#define IDS_LANG_ENGLISH 1
+#define IDS_LANG_NATIVE 2
+
+#define IDT_LANG_LANG 2102
+#define IDC_LANG_LANG 100
+#define IDT_LANG_INFO 101
diff --git a/CPP/7zip/UI/FileManager/LangUtils.cpp b/CPP/7zip/UI/FileManager/LangUtils.cpp
new file mode 100644
index 0000000..4c9d16f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LangUtils.cpp
@@ -0,0 +1,326 @@
+// LangUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/Lang.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Window.h"
+
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+UString g_LangID;
+
+// static
+CLang g_Lang;
+static bool g_Loaded = false;
+static NSynchronization::CCriticalSection g_CriticalSection;
+
+bool LangOpen(CLang &lang, CFSTR fileName);
+bool LangOpen(CLang &lang, CFSTR fileName)
+{
+ return lang.Open(fileName, "7-Zip");
+}
+
+FString GetLangDirPrefix()
+{
+ return NDLL::GetModuleDirPrefix() + FTEXT("Lang") FSTRING_PATH_SEPARATOR;
+}
+
+#ifdef Z7_LANG
+
+void LoadLangOneTime()
+{
+ NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+ if (g_Loaded)
+ return;
+ g_Loaded = true;
+ ReloadLang();
+}
+
+void LangSetDlgItemText(HWND dialog, UInt32 controlID, UInt32 langID)
+{
+ const wchar_t *s = g_Lang.Get(langID);
+ if (s)
+ {
+ CWindow window(GetDlgItem(dialog, (int)controlID));
+ window.SetText(s);
+ }
+}
+
+static const CIDLangPair kLangPairs[] =
+{
+ { IDOK, 401 },
+ { IDCANCEL, 402 },
+ { IDYES, 406 },
+ { IDNO, 407 },
+ { IDCLOSE, 408 },
+ { IDHELP, 409 }
+};
+
+
+void LangSetDlgItems(HWND dialog, const UInt32 *ids, unsigned numItems)
+{
+ unsigned i;
+ for (i = 0; i < Z7_ARRAY_SIZE(kLangPairs); i++)
+ {
+ const CIDLangPair &pair = kLangPairs[i];
+ CWindow window(GetDlgItem(dialog, (int)pair.ControlID));
+ if (window)
+ {
+ const wchar_t *s = g_Lang.Get(pair.LangID);
+ if (s)
+ window.SetText(s);
+ }
+ }
+
+ for (i = 0; i < numItems; i++)
+ {
+ const UInt32 id = ids[i];
+ LangSetDlgItemText(dialog, id, id);
+ }
+}
+
+void LangSetDlgItems_Colon(HWND dialog, const UInt32 *ids, unsigned numItems)
+{
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ const UInt32 id = ids[i];
+ const wchar_t *s = g_Lang.Get(id);
+ if (s)
+ {
+ CWindow window(GetDlgItem(dialog, (int)id));
+ UString s2 = s;
+ s2 += ':';
+ window.SetText(s2);
+ }
+ }
+}
+
+void LangSetDlgItems_RemoveColon(HWND dialog, const UInt32 *ids, unsigned numItems)
+{
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ const UInt32 id = ids[i];
+ const wchar_t *s = g_Lang.Get(id);
+ if (s)
+ {
+ CWindow window(GetDlgItem(dialog, (int)id));
+ UString s2 = s;
+ if (!s2.IsEmpty() && s2.Back() == ':')
+ s2.DeleteBack();
+ window.SetText(s2);
+ }
+ }
+}
+
+void LangSetWindowText(HWND window, UInt32 langID)
+{
+ const wchar_t *s = g_Lang.Get(langID);
+ if (s)
+ MySetWindowText(window, s);
+}
+
+UString LangString(UInt32 langID)
+{
+ const wchar_t *s = g_Lang.Get(langID);
+ if (s)
+ return s;
+ return MyLoadString(langID);
+}
+
+void AddLangString(UString &s, UInt32 langID)
+{
+ s += LangString(langID);
+}
+
+void LangString(UInt32 langID, UString &dest)
+{
+ const wchar_t *s = g_Lang.Get(langID);
+ if (s)
+ {
+ dest = s;
+ return;
+ }
+ MyLoadString(langID, dest);
+}
+
+void LangString_OnlyFromLangFile(UInt32 langID, UString &dest)
+{
+ dest.Empty();
+ const wchar_t *s = g_Lang.Get(langID);
+ if (s)
+ dest = s;
+}
+
+static const char * const kLangs =
+ "ar.bg.ca.zh.-tw.-cn.cs.da.de.el.en.es.fi.fr.he.hu.is."
+ "it.ja.ko.nl.no.=nb.=nn.pl.pt.-br.rm.ro.ru.sr.=hr.-spl.-spc.sk.sq.sv.th.tr."
+ "ur.id.uk.be.sl.et.lv.lt.tg.fa.vi.hy.az.eu.hsb.mk."
+ "st.ts.tn.ve.xh.zu.af.ka.fo.hi.mt.se.ga.yi.ms.kk."
+ "ky.sw.tk.uz.-latn.-cyrl.tt.bn.pa.-in.gu.or.ta.te.kn.ml.as.mr.sa."
+ "mn.=mn.=mng.bo.cy.kh.lo.my.gl.kok..sd.syr.si..iu.am.tzm."
+ "ks.ne.fy.ps.tl.dv..ff.ha..yo.qu.st.ba.lb.kl."
+ "ig.kr.om.ti.gn..la.so.ii..arn..moh..br.."
+ "ug.mi.oc.co."
+ // "gsw.sah.qut.rw.wo....prs...."
+ // ".gd."
+ ;
+
+static void FindShortNames(UInt32 primeLang, AStringVector &names)
+{
+ UInt32 index = 0;
+ for (const char *p = kLangs; *p != 0;)
+ {
+ const char *p2 = p;
+ for (; *p2 != '.'; p2++);
+ bool isSub = (p[0] == '-' || p[0] == '=');
+ if (!isSub)
+ index++;
+ if (index >= primeLang)
+ {
+ if (index > primeLang)
+ break;
+ AString s;
+ if (isSub)
+ {
+ if (p[0] == '-')
+ s = names[0];
+ else
+ p++;
+ }
+ while (p != p2)
+ s += (char)(Byte)*p++;
+ names.Add(s);
+ }
+ p = p2 + 1;
+ }
+}
+
+/*
+#include "../../../Common/IntToString.h"
+
+static struct CC1Lang
+{
+ CC1Lang()
+ {
+ for (int i = 1; i < 150; i++)
+ {
+ UString s;
+ char ttt[32];
+ ConvertUInt32ToHex(i, ttt);
+ s += ttt;
+ UStringVector names;
+ FindShortNames(i, names);
+
+ FOR_VECTOR (k, names)
+ {
+ s.Add_Space();
+ s += names[k];
+ }
+ OutputDebugStringW(s);
+ }
+ }
+} g_cc1;
+*/
+
+// typedef LANGID (WINAPI *GetUserDefaultUILanguageP)();
+
+void Lang_GetShortNames_for_DefaultLang(AStringVector &names, unsigned &subLang)
+{
+ names.Clear();
+ subLang = 0;
+ const LANGID sysLang = GetSystemDefaultLangID(); // "Language for non-Unicode programs" in XP64
+ const LANGID userLang = GetUserDefaultLangID(); // "Standards and formats" language in XP64
+
+ if (sysLang != userLang)
+ return;
+ const LANGID langID = userLang;
+
+ // const LANGID langID = MAKELANGID(0x1a, 1); // for debug
+
+ /*
+ LANGID sysUILang; // english in XP64
+ LANGID userUILang; // english in XP64
+
+ GetUserDefaultUILanguageP fn = (GetUserDefaultUILanguageP)GetProcAddress(
+ GetModuleHandle("kernel32"), "GetUserDefaultUILanguage");
+ if (fn)
+ userUILang = fn();
+ fn = (GetUserDefaultUILanguageP)GetProcAddress(
+ GetModuleHandle("kernel32"), "GetSystemDefaultUILanguage");
+ if (fn)
+ sysUILang = fn();
+ */
+
+ const WORD primLang = (WORD)(PRIMARYLANGID(langID));
+ subLang = SUBLANGID(langID);
+ FindShortNames(primLang, names);
+}
+
+
+static void OpenDefaultLang()
+{
+ AStringVector names;
+ unsigned subLang;
+ Lang_GetShortNames_for_DefaultLang(names, subLang);
+ {
+ const FString dirPrefix (GetLangDirPrefix());
+ for (unsigned i = 0; i < 2; i++)
+ {
+ const unsigned index = (i == 0 ? subLang : 0);
+ if (index < names.Size())
+ {
+ const AString &name = names[index];
+ if (!name.IsEmpty())
+ {
+ FString path (dirPrefix);
+ path += name;
+ path += ".txt";
+ if (LangOpen(g_Lang, path))
+ {
+ g_LangID = name;
+ return;
+ }
+ }
+ }
+ }
+ }
+}
+
+void ReloadLang()
+{
+ g_Lang.Clear();
+ ReadRegLang(g_LangID);
+ #ifndef _UNICODE
+ if (g_IsNT)
+ #endif
+ {
+ if (g_LangID.IsEmpty())
+ {
+ OpenDefaultLang();
+ return;
+ }
+ }
+ if (g_LangID.Len() > 1 || g_LangID[0] != L'-')
+ {
+ FString s = us2fs(g_LangID);
+ if (s.ReverseFind_PathSepar() < 0)
+ {
+ if (s.ReverseFind_Dot() < 0)
+ s += ".txt";
+ s.Insert(0, GetLangDirPrefix());
+ LangOpen(g_Lang, s);
+ }
+ }
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LangUtils.h b/CPP/7zip/UI/FileManager/LangUtils.h
index c694423..d53d270 100644
--- a/CPP/7zip/UI/FileManager/LangUtils.h
+++ b/CPP/7zip/UI/FileManager/LangUtils.h
@@ -1,40 +1,48 @@
-// LangUtils.h
-
-#ifndef __LANG_UTILS_H
-#define __LANG_UTILS_H
-
-#include "../../../Windows/ResourceString.h"
-
-#ifdef LANG
-
-extern UString g_LangID;
-
-struct CIDLangPair
-{
- UInt32 ControlID;
- UInt32 LangID;
-};
-
-void ReloadLang();
-void LoadLangOneTime();
-FString GetLangDirPrefix();
-
-void LangSetDlgItemText(HWND dialog, UInt32 controlID, UInt32 langID);
-void LangSetDlgItems(HWND dialog, const UInt32 *ids, unsigned numItems);
-void LangSetDlgItems_Colon(HWND dialog, const UInt32 *ids, unsigned numItems);
-void LangSetWindowText(HWND window, UInt32 langID);
-
-UString LangString(UInt32 langID);
-void AddLangString(UString &s, UInt32 langID);
-void LangString(UInt32 langID, UString &dest);
-void LangString_OnlyFromLangFile(UInt32 langID, UString &dest);
-
-#else
-
-inline UString LangString(UInt32 langID) { return NWindows::MyLoadString(langID); }
-inline void LangString(UInt32 langID, UString &dest) { NWindows::MyLoadString(langID, dest); }
-inline void AddLangString(UString &s, UInt32 langID) { s += NWindows::MyLoadString(langID); }
-
-#endif
-
-#endif
+// LangUtils.h
+
+#ifndef ZIP7_INC_LANG_UTILS_H
+#define ZIP7_INC_LANG_UTILS_H
+
+#include "../../../Common/Lang.h"
+
+#include "../../../Windows/ResourceString.h"
+
+extern UString g_LangID;
+extern CLang g_Lang;
+
+#ifdef Z7_LANG
+
+struct CIDLangPair
+{
+ UInt32 ControlID;
+ UInt32 LangID;
+};
+
+void ReloadLang();
+void LoadLangOneTime();
+
+void LangSetDlgItemText(HWND dialog, UInt32 controlID, UInt32 langID);
+void LangSetDlgItems(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetDlgItems_Colon(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetDlgItems_RemoveColon(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetWindowText(HWND window, UInt32 langID);
+
+UString LangString(UInt32 langID);
+void AddLangString(UString &s, UInt32 langID);
+void LangString(UInt32 langID, UString &dest);
+void LangString_OnlyFromLangFile(UInt32 langID, UString &dest);
+
+#else
+
+inline UString LangString(UInt32 langID) { return NWindows::MyLoadString(langID); }
+inline void LangString(UInt32 langID, UString &dest) { NWindows::MyLoadString(langID, dest); }
+inline void AddLangString(UString &s, UInt32 langID) { s += NWindows::MyLoadString(langID); }
+
+#endif
+
+FString GetLangDirPrefix();
+// bool LangOpen(CLang &lang, CFSTR fileName);
+
+void Lang_GetShortNames_for_DefaultLang(AStringVector &names, unsigned &subLang);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.cpp b/CPP/7zip/UI/FileManager/LinkDialog.cpp
new file mode 100644
index 0000000..0f24761
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialog.cpp
@@ -0,0 +1,400 @@
+// LinkDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+
+#include "LangUtils.h"
+
+#include "BrowseDialog.h"
+#include "CopyDialogRes.h"
+#include "LinkDialog.h"
+#include "resourceGui.h"
+
+#include "App.h"
+
+#include "resource.h"
+
+extern bool g_SymLink_Supported;
+
+using namespace NWindows;
+using namespace NFile;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDB_LINK_LINK,
+ IDT_LINK_PATH_FROM,
+ IDT_LINK_PATH_TO,
+ IDG_LINK_TYPE,
+ IDR_LINK_TYPE_HARD,
+ IDR_LINK_TYPE_SYM_FILE,
+ IDR_LINK_TYPE_SYM_DIR,
+ IDR_LINK_TYPE_JUNCTION,
+ IDR_LINK_TYPE_WSL
+};
+#endif
+
+
+static bool GetSymLink(CFSTR path, CReparseAttr &attr, UString &errorMessage)
+{
+ CByteBuffer buf;
+ if (!NIO::GetReparseData(path, buf, NULL))
+ return false;
+
+ if (!attr.Parse(buf, buf.Size()))
+ {
+ SetLastError(attr.ErrorCode);
+ return false;
+ }
+
+ CByteBuffer data2;
+ if (!FillLinkData(data2, attr.GetPath(),
+ !attr.IsMountPoint(), attr.IsSymLink_WSL()))
+ {
+ errorMessage = "Cannot reproduce reparse point";
+ return false;
+ }
+
+ if (data2.Size() != buf.Size() ||
+ memcmp(data2, buf, buf.Size()) != 0)
+ {
+ errorMessage = "mismatch for reproduced reparse point";
+ return false;
+ }
+
+ return true;
+}
+
+
+static const unsigned k_LinkType_Buttons[] =
+{
+ IDR_LINK_TYPE_HARD,
+ IDR_LINK_TYPE_SYM_FILE,
+ IDR_LINK_TYPE_SYM_DIR,
+ IDR_LINK_TYPE_JUNCTION,
+ IDR_LINK_TYPE_WSL
+};
+
+void CLinkDialog::Set_LinkType_Radio(unsigned idb)
+{
+ CheckRadioButton(
+ k_LinkType_Buttons[0],
+ k_LinkType_Buttons[Z7_ARRAY_SIZE(k_LinkType_Buttons) - 1],
+ idb);
+}
+
+bool CLinkDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_LINK);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ #endif
+
+ _pathFromCombo.Attach(GetItem(IDC_LINK_PATH_FROM));
+ _pathToCombo.Attach(GetItem(IDC_LINK_PATH_TO));
+
+ if (!FilePath.IsEmpty())
+ {
+ NFind::CFileInfo fi;
+ unsigned linkType = 0;
+ if (!fi.Find(us2fs(FilePath)))
+ linkType = IDR_LINK_TYPE_SYM_FILE;
+ else
+ {
+ if (fi.HasReparsePoint())
+ {
+ CReparseAttr attr;
+ UString error;
+ const bool res = GetSymLink(us2fs(FilePath), attr, error);
+ if (!res && error.IsEmpty())
+ {
+ DWORD lastError = GetLastError();
+ if (lastError != 0)
+ error = NError::MyFormatMessage(lastError);
+ }
+
+ UString s = attr.GetPath();
+ if (!attr.IsSymLink_WSL())
+ if (!attr.IsOkNamePair())
+ {
+ s += " : ";
+ s += attr.PrintName;
+ }
+
+ if (!res)
+ {
+ s.Insert(0, L"ERROR: ");
+ if (!error.IsEmpty())
+ {
+ s += " : ";
+ s += error;
+ }
+ }
+
+
+ SetItemText(IDT_LINK_PATH_TO_CUR, s);
+
+ const UString destPath = attr.GetPath();
+ _pathFromCombo.SetText(FilePath);
+ _pathToCombo.SetText(destPath);
+
+ // if (res)
+ {
+ if (attr.IsMountPoint())
+ linkType = IDR_LINK_TYPE_JUNCTION;
+ else if (attr.IsSymLink_WSL())
+ linkType = IDR_LINK_TYPE_WSL;
+ else if (attr.IsSymLink_Win())
+ {
+ linkType =
+ fi.IsDir() ?
+ IDR_LINK_TYPE_SYM_DIR :
+ IDR_LINK_TYPE_SYM_FILE;
+ // if (attr.IsRelative()) linkType = IDR_LINK_TYPE_SYM_RELATIVE;
+ }
+
+ if (linkType != 0)
+ Set_LinkType_Radio(linkType);
+ }
+ }
+ else
+ {
+ // no ReparsePoint
+ _pathFromCombo.SetText(AnotherPath);
+ _pathToCombo.SetText(FilePath);
+ if (fi.IsDir())
+ linkType = g_SymLink_Supported ?
+ IDR_LINK_TYPE_SYM_DIR :
+ IDR_LINK_TYPE_JUNCTION;
+ else
+ linkType = IDR_LINK_TYPE_HARD;
+ }
+ }
+ if (linkType != 0)
+ Set_LinkType_Radio(linkType);
+ }
+
+ NormalizeSize();
+ return CModalDialog::OnInit();
+}
+
+bool CLinkDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx1, bx2, by;
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDB_LINK_LINK, bx2, by);
+ int yPos = ySize - my - by;
+ int xPos = xSize - mx - bx1;
+
+ InvalidateRect(NULL);
+
+ {
+ RECT r, r2;
+ GetClientRectOfItem(IDB_LINK_PATH_FROM, r);
+ GetClientRectOfItem(IDB_LINK_PATH_TO, r2);
+ int bx = RECT_SIZE_X(r);
+ int newButtonXpos = xSize - mx - bx;
+
+ MoveItem(IDB_LINK_PATH_FROM, newButtonXpos, r.top, bx, RECT_SIZE_Y(r));
+ MoveItem(IDB_LINK_PATH_TO, newButtonXpos, r2.top, bx, RECT_SIZE_Y(r2));
+
+ int newComboXsize = newButtonXpos - mx - mx;
+ ChangeSubWindowSizeX(_pathFromCombo, newComboXsize);
+ ChangeSubWindowSizeX(_pathToCombo, newComboXsize);
+ }
+
+ MoveItem(IDCANCEL, xPos, yPos, bx1, by);
+ MoveItem(IDB_LINK_LINK, xPos - mx - bx2, yPos, bx2, by);
+
+ return false;
+}
+
+bool CLinkDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_LINK_PATH_FROM:
+ OnButton_SetPath(false);
+ return true;
+ case IDB_LINK_PATH_TO:
+ OnButton_SetPath(true);
+ return true;
+ case IDB_LINK_LINK:
+ OnButton_Link();
+ return true;
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CLinkDialog::OnButton_SetPath(bool to)
+{
+ UString currentPath;
+ NWindows::NControl::CComboBox &combo = to ?
+ _pathToCombo :
+ _pathFromCombo;
+ combo.GetText(currentPath);
+ // UString title = "Specify a location for output folder";
+ const UString title = LangString(IDS_SET_FOLDER);
+
+ UString resultPath;
+ if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+ return;
+ NName::NormalizeDirPathPrefix(resultPath);
+ combo.SetCurSel(-1);
+ combo.SetText(resultPath);
+}
+
+void CLinkDialog::ShowError(const wchar_t *s)
+{
+ ::MessageBoxW(*this, s, L"7-Zip", MB_ICONERROR);
+}
+
+void CLinkDialog::ShowLastErrorMessage()
+{
+ ShowError(NError::MyFormatMessage(GetLastError()));
+}
+
+void CLinkDialog::OnButton_Link()
+{
+ UString from, to;
+ _pathFromCombo.GetText(from);
+ _pathToCombo.GetText(to);
+
+ if (from.IsEmpty())
+ return;
+ if (!NName::IsAbsolutePath(from))
+ from.Insert(0, CurDirPrefix);
+
+ unsigned idb = 0;
+ for (unsigned i = 0;; i++)
+ {
+ if (i >= Z7_ARRAY_SIZE(k_LinkType_Buttons))
+ return;
+ idb = k_LinkType_Buttons[i];
+ if (IsButtonCheckedBool(idb))
+ break;
+ }
+
+ NFind::CFileInfo info1, info2;
+ const bool finded1 = info1.Find(us2fs(from));
+ const bool finded2 = info2.Find(us2fs(to));
+
+ const bool isDirLink = (
+ idb == IDR_LINK_TYPE_SYM_DIR ||
+ idb == IDR_LINK_TYPE_JUNCTION);
+
+ const bool isWSL = (idb == IDR_LINK_TYPE_WSL);
+
+ if (!isWSL)
+ if ((finded1 && info1.IsDir() != isDirLink) ||
+ (finded2 && info2.IsDir() != isDirLink))
+ {
+ ShowError(L"Incorrect link type");
+ return;
+ }
+
+ if (idb == IDR_LINK_TYPE_HARD)
+ {
+ if (!NDir::MyCreateHardLink(us2fs(from), us2fs(to)))
+ {
+ ShowLastErrorMessage();
+ return;
+ }
+ }
+ else
+ {
+ if (finded1 && !info1.IsDir() && !info1.HasReparsePoint() && info1.Size != 0)
+ {
+ UString s ("WARNING: reparse point will hide the data of existing file");
+ s.Add_LF();
+ s += from;
+ ShowError(s);
+ return;
+ }
+
+ const bool isSymLink = (idb != IDR_LINK_TYPE_JUNCTION);
+
+ CByteBuffer data;
+ if (!FillLinkData(data, to, isSymLink, isWSL))
+ {
+ ShowError(L"Incorrect link");
+ return;
+ }
+
+ CReparseAttr attr;
+ if (!attr.Parse(data, data.Size()))
+ {
+ ShowError(L"Internal conversion error");
+ return;
+ }
+
+ bool res;
+ if (to.IsEmpty())
+ {
+ // res = NIO::SetReparseData(us2fs(from), isDirLink, NULL, 0);
+ res = NIO::DeleteReparseData(us2fs(from));
+ }
+ else
+ res = NIO::SetReparseData(us2fs(from), isDirLink, data, (DWORD)data.Size());
+
+ if (!res)
+ {
+ ShowLastErrorMessage();
+ return;
+ }
+ }
+
+ End(IDOK);
+}
+
+void CApp::Link()
+{
+ const unsigned srcPanelIndex = GetFocusedPanelIndex();
+ CPanel &srcPanel = Panels[srcPanelIndex];
+ if (!srcPanel.IsFSFolder())
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ CRecordVector<UInt32> indices;
+ srcPanel.Get_ItemIndices_Operated(indices);
+ if (indices.IsEmpty())
+ return;
+ if (indices.Size() != 1)
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_SELECT_ONE_FILE);
+ return;
+ }
+ const UInt32 index = indices[0];
+ const UString itemName = srcPanel.GetItemName(index);
+
+ const UString fsPrefix = srcPanel.GetFsPath();
+ const UString srcPath = fsPrefix + srcPanel.GetItemPrefix(index);
+ UString path = srcPath;
+ {
+ const unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+ CPanel &destPanel = Panels[destPanelIndex];
+ if (NumPanels > 1)
+ if (destPanel.IsFSFolder())
+ path = destPanel.GetFsPath();
+ }
+
+ CLinkDialog dlg;
+ dlg.CurDirPrefix = fsPrefix;
+ dlg.FilePath = srcPath + itemName;
+ dlg.AnotherPath = path;
+
+ if (dlg.Create(srcPanel.GetParent()) != IDOK)
+ return;
+
+ // fix it: we should refresh panel with changed link
+
+ RefreshTitleAlways();
+}
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.h b/CPP/7zip/UI/FileManager/LinkDialog.h
new file mode 100644
index 0000000..dd768f7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialog.h
@@ -0,0 +1,34 @@
+// LinkDialog.h
+
+#ifndef ZIP7_INC_LINK_DIALOG_H
+#define ZIP7_INC_LINK_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ComboBox.h"
+
+#include "LinkDialogRes.h"
+
+class CLinkDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CComboBox _pathFromCombo;
+ NWindows::NControl::CComboBox _pathToCombo;
+
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ void OnButton_SetPath(bool to);
+ void OnButton_Link();
+
+ void ShowLastErrorMessage();
+ void ShowError(const wchar_t *s);
+ void Set_LinkType_Radio(unsigned idb);
+public:
+ UString CurDirPrefix;
+ UString FilePath;
+ UString AnotherPath;
+
+ INT_PTR Create(HWND parentWindow = NULL)
+ { return CModalDialog::Create(IDD_LINK, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/LinkDialog.rc b/CPP/7zip/UI/FileManager/LinkDialog.rc
new file mode 100644
index 0000000..a9e220b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialog.rc
@@ -0,0 +1,38 @@
+#include "LinkDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 288
+#define yc 214
+
+#undef xRadioSize
+#define xRadioSize xc - m - 2
+
+IDD_LINK DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Link"
+BEGIN
+ LTEXT "Link from:", IDT_LINK_PATH_FROM, m, m, xc, 8
+ COMBOBOX IDC_LINK_PATH_FROM, m, 20, xc - bxsDots - m, 64, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_LINK_PATH_FROM, xs - m - bxsDots, 18, bxsDots, bys, WS_GROUP
+
+ LTEXT "Link to:", IDT_LINK_PATH_TO, m, 48, xc, 8
+ COMBOBOX IDC_LINK_PATH_TO, m, 60, xc - bxsDots - m, 64, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_LINK_PATH_TO, xs - m - bxsDots, 58, bxsDots, bys, WS_GROUP
+
+ LTEXT "", IDT_LINK_PATH_TO_CUR, m, 78, xc, 8
+
+ GROUPBOX "Link Type", IDG_LINK_TYPE, m, 104, xc, 90
+
+ CONTROL "Hard Link", IDR_LINK_TYPE_HARD, "Button", BS_AUTORADIOBUTTON | WS_GROUP,
+ m + m, 120, xRadioSize, 10
+ CONTROL "File Symbolic Link", IDR_LINK_TYPE_SYM_FILE, "Button", BS_AUTORADIOBUTTON,
+ m + m, 134, xRadioSize, 10
+ CONTROL "Directory Symbolic Link", IDR_LINK_TYPE_SYM_DIR, "Button", BS_AUTORADIOBUTTON,
+ m + m, 148, xRadioSize, 10
+ CONTROL "Directory Junction", IDR_LINK_TYPE_JUNCTION, "Button", BS_AUTORADIOBUTTON,
+ m + m, 162, xRadioSize, 10
+ CONTROL "WSL", IDR_LINK_TYPE_WSL, "Button", BS_AUTORADIOBUTTON,
+ m + m, 176, xRadioSize, 10
+
+ DEFPUSHBUTTON "Link", IDB_LINK_LINK, bx2, by, bxs, bys
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+END
diff --git a/CPP/7zip/UI/FileManager/LinkDialogRes.h b/CPP/7zip/UI/FileManager/LinkDialogRes.h
new file mode 100644
index 0000000..3f7b3f2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/LinkDialogRes.h
@@ -0,0 +1,22 @@
+#define IDD_LINK 7700
+
+#define IDB_LINK_LINK 7701
+
+#define IDT_LINK_PATH_FROM 7702
+#define IDT_LINK_PATH_TO 7703
+
+#define IDG_LINK_TYPE 7710
+#define IDR_LINK_TYPE_HARD 7711
+#define IDR_LINK_TYPE_SYM_FILE 7712
+#define IDR_LINK_TYPE_SYM_DIR 7713
+#define IDR_LINK_TYPE_JUNCTION 7714
+#define IDR_LINK_TYPE_WSL 7715
+
+
+#define IDC_LINK_PATH_FROM 100
+#define IDC_LINK_PATH_TO 101
+
+#define IDT_LINK_PATH_TO_CUR 102
+
+#define IDB_LINK_PATH_FROM 103
+#define IDB_LINK_PATH_TO 104
diff --git a/CPP/7zip/UI/FileManager/ListViewDialog.cpp b/CPP/7zip/UI/FileManager/ListViewDialog.cpp
new file mode 100644
index 0000000..6767e4c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialog.cpp
@@ -0,0 +1,321 @@
+// ListViewDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/Clipboard.h"
+
+#include "EditDialog.h"
+#include "ListViewDialog.h"
+#include "RegistryUtils.h"
+
+#ifdef Z7_LANG
+#include "LangUtils.h"
+#endif
+
+using namespace NWindows;
+
+static const unsigned kOneStringMaxSize = 1024;
+
+
+static void ListView_GetSelected(NControl::CListView &listView, CUIntVector &vector)
+{
+ vector.Clear();
+ int index = -1;
+ for (;;)
+ {
+ index = listView.GetNextSelectedItem(index);
+ if (index < 0)
+ break;
+ vector.Add((unsigned)index);
+ }
+}
+
+
+bool CListViewDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, NULL, 0);
+ #endif
+ _listView.Attach(GetItem(IDL_LISTVIEW));
+
+ if (NumColumns > 1)
+ {
+ LONG_PTR style = _listView.GetStyle();
+ style &= ~(LONG_PTR)LVS_NOCOLUMNHEADER;
+ _listView.SetStyle(style);
+ }
+
+ CFmSettings st;
+ st.Load();
+
+ DWORD exStyle = 0;
+
+ if (st.SingleClick)
+ exStyle |= LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT;
+
+ exStyle |= LVS_EX_FULLROWSELECT;
+ if (exStyle != 0)
+ _listView.SetExtendedListViewStyle(exStyle);
+
+
+ SetText(Title);
+
+ const int kWidth = 400;
+
+ LVCOLUMN columnInfo;
+ columnInfo.mask = LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
+ columnInfo.fmt = LVCFMT_LEFT;
+ columnInfo.iSubItem = 0;
+ columnInfo.cx = kWidth;
+ columnInfo.pszText = NULL; // (TCHAR *)(const TCHAR *)""; // "Property"
+
+ if (NumColumns > 1)
+ {
+ columnInfo.cx = 100;
+ /*
+ // Windows always uses LVCFMT_LEFT for first column.
+ // if we need LVCFMT_RIGHT, we can create dummy column and then remove it
+
+ // columnInfo.mask |= LVCF_TEXT;
+ _listView.InsertColumn(0, &columnInfo);
+
+ columnInfo.iSubItem = 1;
+ columnInfo.fmt = LVCFMT_RIGHT;
+ _listView.InsertColumn(1, &columnInfo);
+ _listView.DeleteColumn(0);
+ */
+ }
+ // else
+ _listView.InsertColumn(0, &columnInfo);
+
+ if (NumColumns > 1)
+ {
+ // columnInfo.fmt = LVCFMT_LEFT;
+ columnInfo.cx = kWidth - columnInfo.cx;
+ columnInfo.iSubItem = 1;
+ // columnInfo.pszText = NULL; // (TCHAR *)(const TCHAR *)""; // "Value"
+ _listView.InsertColumn(1, &columnInfo);
+ }
+
+
+ UString s;
+
+ FOR_VECTOR (i, Strings)
+ {
+ _listView.InsertItem(i, Strings[i]);
+
+ if (NumColumns > 1 && i < Values.Size())
+ {
+ s = Values[i];
+ if (s.Len() > kOneStringMaxSize)
+ {
+ s.DeleteFrom(kOneStringMaxSize);
+ s += " ...";
+ }
+ s.Replace(L"\r\n", L" ");
+ s.Replace(L"\n", L" ");
+ _listView.SetSubItem(i, 1, s);
+ }
+ }
+
+ if (SelectFirst && Strings.Size() > 0)
+ _listView.SetItemState_FocusedSelected(0);
+
+ _listView.SetColumnWidthAuto(0);
+ if (NumColumns > 1)
+ _listView.SetColumnWidthAuto(1);
+ StringsWereChanged = false;
+
+ NormalizeSize();
+ return CModalDialog::OnInit();
+}
+
+bool CListViewDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx1, bx2, by;
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDOK, bx2, by);
+ int y = ySize - my - by;
+ int x = xSize - mx - bx1;
+
+ /*
+ RECT rect;
+ GetClientRect(&rect);
+ rect.top = y - my;
+ InvalidateRect(&rect);
+ */
+ InvalidateRect(NULL);
+
+ MoveItem(IDCANCEL, x, y, bx1, by);
+ MoveItem(IDOK, x - mx - bx2, y, bx2, by);
+ /*
+ if (wParam == SIZE_MAXSHOW || wParam == SIZE_MAXIMIZED || wParam == SIZE_MAXHIDE)
+ mx = 0;
+ */
+ _listView.Move(mx, my, xSize - mx * 2, y - my * 2);
+ return false;
+}
+
+
+extern bool g_LVN_ITEMACTIVATE_Support;
+
+void CListViewDialog::CopyToClipboard()
+{
+ CUIntVector indexes;
+ ListView_GetSelected(_listView, indexes);
+ UString s;
+
+ FOR_VECTOR (i, indexes)
+ {
+ unsigned index = indexes[i];
+ s += Strings[index];
+ if (NumColumns > 1 && index < Values.Size())
+ {
+ const UString &v = Values[index];
+ // if (!v.IsEmpty())
+ {
+ s += ": ";
+ s += v;
+ }
+ }
+ // if (indexes.Size() > 1)
+ {
+ s +=
+ #ifdef _WIN32
+ "\r\n"
+ #else
+ "\n"
+ #endif
+ ;
+ }
+ }
+
+ ClipboardSetText(*this, s);
+}
+
+
+void CListViewDialog::ShowItemInfo()
+{
+ CUIntVector indexes;
+ ListView_GetSelected(_listView, indexes);
+ if (indexes.Size() != 1)
+ return;
+ unsigned index = indexes[0];
+
+ CEditDialog dlg;
+ if (NumColumns == 1)
+ dlg.Text = Strings[index];
+ else
+ {
+ dlg.Title = Strings[index];
+ if (index < Values.Size())
+ dlg.Text = Values[index];
+ }
+
+ #ifdef _WIN32
+ if (dlg.Text.Find(L'\r') < 0)
+ dlg.Text.Replace(L"\n", L"\r\n");
+ #endif
+
+ dlg.Create(*this);
+}
+
+
+void CListViewDialog::DeleteItems()
+{
+ for (;;)
+ {
+ const int index = _listView.GetNextSelectedItem(-1);
+ if (index < 0)
+ break;
+ StringsWereChanged = true;
+ _listView.DeleteItem((unsigned)index);
+ if ((unsigned)index < Strings.Size())
+ Strings.Delete((unsigned)index);
+ if ((unsigned)index < Values.Size())
+ Values.Delete((unsigned)index);
+ }
+ const int focusedIndex = _listView.GetFocusedItem();
+ if (focusedIndex >= 0)
+ _listView.SetItemState_FocusedSelected(focusedIndex);
+ _listView.SetColumnWidthAuto(0);
+}
+
+
+void CListViewDialog::OnEnter()
+{
+ if (IsKeyDown(VK_MENU)
+ || NumColumns > 1)
+ {
+ ShowItemInfo();
+ return;
+ }
+ OnOK();
+}
+
+bool CListViewDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
+{
+ if (header->hwndFrom != _listView)
+ return false;
+ switch (header->code)
+ {
+ case LVN_ITEMACTIVATE:
+ if (g_LVN_ITEMACTIVATE_Support)
+ {
+ OnEnter();
+ return true;
+ }
+ break;
+ case NM_DBLCLK:
+ case NM_RETURN: // probabably it's unused
+ if (!g_LVN_ITEMACTIVATE_Support)
+ {
+ OnEnter();
+ return true;
+ }
+ break;
+
+ case LVN_KEYDOWN:
+ {
+ LPNMLVKEYDOWN keyDownInfo = LPNMLVKEYDOWN(header);
+ switch (keyDownInfo->wVKey)
+ {
+ case VK_DELETE:
+ {
+ if (!DeleteIsAllowed)
+ return false;
+ DeleteItems();
+ return true;
+ }
+ case 'A':
+ {
+ if (IsKeyDown(VK_CONTROL))
+ {
+ _listView.SelectAll();
+ return true;
+ }
+ break;
+ }
+ case VK_INSERT:
+ case 'C':
+ {
+ if (IsKeyDown(VK_CONTROL))
+ {
+ CopyToClipboard();
+ return true;
+ }
+ break;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+void CListViewDialog::OnOK()
+{
+ FocusedItemIndex = _listView.GetFocusedItem();
+ CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/ListViewDialog.h b/CPP/7zip/UI/FileManager/ListViewDialog.h
new file mode 100644
index 0000000..5f0b66d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialog.h
@@ -0,0 +1,46 @@
+// ListViewDialog.h
+
+#ifndef ZIP7_INC_LISTVIEW_DIALOG_H
+#define ZIP7_INC_LISTVIEW_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ListView.h"
+
+#include "ListViewDialogRes.h"
+
+class CListViewDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CListView _listView;
+ virtual void OnOK() Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual bool OnNotify(UINT controlID, LPNMHDR header) Z7_override;
+ void CopyToClipboard();
+ void DeleteItems();
+ void ShowItemInfo();
+ void OnEnter();
+public:
+ UString Title;
+
+ bool SelectFirst;
+ bool DeleteIsAllowed;
+ bool StringsWereChanged;
+
+ UStringVector Strings;
+ UStringVector Values;
+
+ int FocusedItemIndex;
+ unsigned NumColumns;
+
+ INT_PTR Create(HWND wndParent = NULL) { return CModalDialog::Create(IDD_LISTVIEW, wndParent); }
+
+ CListViewDialog():
+ SelectFirst(false),
+ DeleteIsAllowed(false),
+ StringsWereChanged(false),
+ FocusedItemIndex(-1),
+ NumColumns(1)
+ {}
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ListViewDialog.rc b/CPP/7zip/UI/FileManager/ListViewDialog.rc
new file mode 100644
index 0000000..4343b75
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialog.rc
@@ -0,0 +1,14 @@
+#include "ListViewDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 480
+#define yc 320
+
+IDD_LISTVIEW DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "ListView"
+{
+ CONTROL "List1", IDL_LISTVIEW, "SysListView32", LVS_REPORT | LVS_SHOWSELALWAYS |
+ LVS_AUTOARRANGE | LVS_NOCOLUMNHEADER | WS_BORDER | WS_TABSTOP,
+ m, m, xc, yc - bys - m
+ OK_CANCEL
+}
diff --git a/CPP/7zip/UI/FileManager/ListViewDialogRes.h b/CPP/7zip/UI/FileManager/ListViewDialogRes.h
new file mode 100644
index 0000000..9abdb9d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ListViewDialogRes.h
@@ -0,0 +1,2 @@
+#define IDD_LISTVIEW 99
+#define IDL_LISTVIEW 100
diff --git a/CPP/7zip/UI/FileManager/MenuPage.cpp b/CPP/7zip/UI/FileManager/MenuPage.cpp
new file mode 100644
index 0000000..2da7f3a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage.cpp
@@ -0,0 +1,440 @@
+// MenuPage.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileFind.h"
+
+#include "../Explorer/ContextMenuFlags.h"
+#include "../Explorer/RegistryContextMenu.h"
+#include "../Explorer/resource.h"
+
+#include "../FileManager/PropertyNameRes.h"
+
+#include "../GUI/ExtractDialogRes.h"
+
+#include "FormatUtils.h"
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "MenuPage.h"
+#include "MenuPageRes.h"
+
+
+using namespace NWindows;
+using namespace NContextMenuFlags;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDX_SYSTEM_INTEGRATE_TO_MENU,
+ IDX_SYSTEM_CASCADED_MENU,
+ IDX_SYSTEM_ICON_IN_MENU,
+ IDX_EXTRACT_ELIM_DUP,
+ IDT_SYSTEM_ZONE,
+ IDT_SYSTEM_CONTEXT_MENU_ITEMS
+};
+#endif
+
+#define kMenuTopic "fm/options.htm#sevenZip"
+
+struct CContextMenuItem
+{
+ unsigned ControlID;
+ UInt32 Flag;
+};
+
+static const CContextMenuItem kMenuItems[] =
+{
+ { IDS_CONTEXT_OPEN, kOpen },
+ { IDS_CONTEXT_OPEN, kOpenAs },
+ { IDS_CONTEXT_EXTRACT, kExtract },
+ { IDS_CONTEXT_EXTRACT_HERE, kExtractHere },
+ { IDS_CONTEXT_EXTRACT_TO, kExtractTo },
+
+ { IDS_CONTEXT_TEST, kTest },
+
+ { IDS_CONTEXT_COMPRESS, kCompress },
+ { IDS_CONTEXT_COMPRESS_TO, kCompressTo7z },
+ { IDS_CONTEXT_COMPRESS_TO, kCompressToZip },
+
+ #ifndef UNDER_CE
+ { IDS_CONTEXT_COMPRESS_EMAIL, kCompressEmail },
+ { IDS_CONTEXT_COMPRESS_TO_EMAIL, kCompressTo7zEmail },
+ { IDS_CONTEXT_COMPRESS_TO_EMAIL, kCompressToZipEmail },
+ #endif
+
+ { IDS_PROP_CHECKSUM, kCRC },
+ { IDS_PROP_CHECKSUM, kCRC_Cascaded },
+};
+
+
+#if !defined(_WIN64)
+extern bool g_Is_Wow64;
+#endif
+
+#ifndef KEY_WOW64_64KEY
+ #define KEY_WOW64_64KEY (0x0100)
+#endif
+
+#ifndef KEY_WOW64_32KEY
+ #define KEY_WOW64_32KEY (0x0200)
+#endif
+
+
+static void LoadLang_Spec(UString &s, UInt32 id, const char *eng)
+{
+ LangString(id, s);
+ if (s.IsEmpty())
+ s = eng;
+ s.RemoveChar(L'&');
+}
+
+
+bool CMenuPage::OnInit()
+{
+ _initMode = true;
+
+ Clear_MenuChanged();
+
+#ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+#endif
+
+ #ifdef UNDER_CE
+
+ HideItem(IDX_SYSTEM_INTEGRATE_TO_MENU);
+ HideItem(IDX_SYSTEM_INTEGRATE_TO_MENU_2);
+
+ #else
+
+ {
+ UString s;
+ {
+ CWindow window(GetItem(IDX_SYSTEM_INTEGRATE_TO_MENU));
+ window.GetText(s);
+ }
+ UString bit64 = LangString(IDS_PROP_BIT64);
+ if (bit64.IsEmpty())
+ bit64 = "64-bit";
+ #ifdef _WIN64
+ bit64.Replace(L"64", L"32");
+ #endif
+ s.Add_Space();
+ s += '(';
+ s += bit64;
+ s += ')';
+ SetItemText(IDX_SYSTEM_INTEGRATE_TO_MENU_2, s);
+ }
+
+ const FString prefix = NDLL::GetModuleDirPrefix();
+
+ _dlls[0].ctrl = IDX_SYSTEM_INTEGRATE_TO_MENU;
+ _dlls[1].ctrl = IDX_SYSTEM_INTEGRATE_TO_MENU_2;
+
+ _dlls[0].wow = 0;
+ _dlls[1].wow =
+ #ifdef _WIN64
+ KEY_WOW64_32KEY
+ #else
+ KEY_WOW64_64KEY
+ #endif
+ ;
+
+ for (unsigned d = 0; d < 2; d++)
+ {
+ CShellDll &dll = _dlls[d];
+
+ dll.wasChanged = false;
+
+ #ifndef _WIN64
+ if (d != 0 && !g_Is_Wow64)
+ {
+ HideItem(dll.ctrl);
+ continue;
+ }
+ #endif
+
+ FString &path = dll.Path;
+ path = prefix;
+ path += (d == 0 ? "7-zip.dll" :
+ #ifdef _WIN64
+ "7-zip32.dll"
+ #else
+ "7-zip64.dll"
+ #endif
+ );
+
+
+ if (!NFile::NFind::DoesFileExist_Raw(path))
+ {
+ path.Empty();
+ EnableItem(dll.ctrl, false);
+ }
+ else
+ {
+ dll.prevValue = CheckContextMenuHandler(fs2us(path), dll.wow);
+ CheckButton(dll.ctrl, dll.prevValue);
+ }
+ }
+
+ #endif
+
+
+ CContextMenuInfo ci;
+ ci.Load();
+
+ CheckButton(IDX_SYSTEM_CASCADED_MENU, ci.Cascaded.Val);
+ CheckButton(IDX_SYSTEM_ICON_IN_MENU, ci.MenuIcons.Val);
+ CheckButton(IDX_EXTRACT_ELIM_DUP, ci.ElimDup.Val);
+
+ _listView.Attach(GetItem(IDL_SYSTEM_OPTIONS));
+ _zoneCombo.Attach(GetItem(IDC_SYSTEM_ZONE));
+
+ {
+ unsigned wz = ci.WriteZone;
+ if (wz == (UInt32)(Int32)-1)
+ wz = 0;
+ for (unsigned i = 0; i <= 3; i++)
+ {
+ unsigned val = i;
+ UString s;
+ if (i == 3)
+ {
+ if (wz < 3)
+ break;
+ val = wz;
+ }
+ else
+ {
+ #define MY_IDYES 406
+ #define MY_IDNO 407
+ if (i == 0)
+ LoadLang_Spec(s, MY_IDNO, "No");
+ else if (i == 1)
+ LoadLang_Spec(s, MY_IDYES, "Yes");
+ else
+ LangString(IDT_ZONE_FOR_OFFICE, s);
+ }
+ if (s.IsEmpty())
+ s.Add_UInt32(val);
+ if (i == 0)
+ s.Insert(0, L"* ");
+ const int index = (int)_zoneCombo.AddString(s);
+ _zoneCombo.SetItemData(index, (LPARAM)val);
+ if (val == wz)
+ _zoneCombo.SetCurSel(index);
+ }
+ }
+
+
+ const UInt32 newFlags = LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT;
+ _listView.SetExtendedListViewStyle(newFlags, newFlags);
+
+ _listView.InsertColumn(0, L"", 200);
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kMenuItems); i++)
+ {
+ const CContextMenuItem &menuItem = kMenuItems[i];
+
+ UString s = LangString(menuItem.ControlID);
+ if (menuItem.Flag == kCRC)
+ s = "CRC SHA";
+ else if (menuItem.Flag == kCRC_Cascaded)
+ s = "7-Zip > CRC SHA";
+ if (menuItem.Flag == kOpenAs
+ || menuItem.Flag == kCRC
+ || menuItem.Flag == kCRC_Cascaded)
+ s += " >";
+
+ switch (menuItem.ControlID)
+ {
+ case IDS_CONTEXT_EXTRACT_TO:
+ {
+ s = MyFormatNew(s, LangString(IDS_CONTEXT_FOLDER));
+ break;
+ }
+ case IDS_CONTEXT_COMPRESS_TO:
+ case IDS_CONTEXT_COMPRESS_TO_EMAIL:
+ {
+ UString s2 = LangString(IDS_CONTEXT_ARCHIVE);
+ switch (menuItem.Flag)
+ {
+ case kCompressTo7z:
+ case kCompressTo7zEmail:
+ s2 += (".7z");
+ break;
+ case kCompressToZip:
+ case kCompressToZipEmail:
+ s2 += (".zip");
+ break;
+ }
+ s = MyFormatNew(s, s2);
+ break;
+ }
+ }
+
+ const int itemIndex = _listView.InsertItem(i, s);
+ _listView.SetCheckState((unsigned)itemIndex, ((ci.Flags & menuItem.Flag) != 0));
+ }
+
+ _listView.SetColumnWidthAuto(0);
+ _initMode = false;
+
+ return CPropertyPage::OnInit();
+}
+
+
+#ifndef UNDER_CE
+
+static void ShowMenuErrorMessage(const wchar_t *m, HWND hwnd)
+{
+ MessageBoxW(hwnd, m, L"7-Zip", MB_ICONERROR);
+}
+
+#endif
+
+
+LONG CMenuPage::OnApply()
+{
+ #ifndef UNDER_CE
+
+ for (unsigned d = 2; d != 0;)
+ {
+ d--;
+ CShellDll &dll = _dlls[d];
+ if (dll.wasChanged && !dll.Path.IsEmpty())
+ {
+ const bool newVal = IsButtonCheckedBool(dll.ctrl);
+ const LONG res = SetContextMenuHandler(newVal, fs2us(dll.Path), dll.wow);
+ if (res != ERROR_SUCCESS && (dll.prevValue != newVal || newVal))
+ ShowMenuErrorMessage(NError::MyFormatMessage(res), *this);
+ dll.prevValue = CheckContextMenuHandler(fs2us(dll.Path), dll.wow);
+ CheckButton(dll.ctrl, dll.prevValue);
+ dll.wasChanged = false;
+ }
+ }
+
+ #endif
+
+ if (_cascaded_Changed
+ || _menuIcons_Changed
+ || _elimDup_Changed
+ || _writeZone_Changed
+ || _flags_Changed)
+ {
+ CContextMenuInfo ci;
+ ci.Cascaded.Val = IsButtonCheckedBool(IDX_SYSTEM_CASCADED_MENU);
+ ci.Cascaded.Def = _cascaded_Changed;
+
+ ci.MenuIcons.Val = IsButtonCheckedBool(IDX_SYSTEM_ICON_IN_MENU);
+ ci.MenuIcons.Def = _menuIcons_Changed;
+
+ ci.ElimDup.Val = IsButtonCheckedBool(IDX_EXTRACT_ELIM_DUP);
+ ci.ElimDup.Def = _elimDup_Changed;
+
+ {
+ int zoneIndex = (int)_zoneCombo.GetItemData_of_CurSel();
+ if (zoneIndex <= 0)
+ zoneIndex = -1;
+ ci.WriteZone = (UInt32)(Int32)zoneIndex;
+ }
+
+ ci.Flags = 0;
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kMenuItems); i++)
+ if (_listView.GetCheckState(i))
+ ci.Flags |= kMenuItems[i].Flag;
+
+ ci.Flags_Def = _flags_Changed;
+ ci.Save();
+
+ Clear_MenuChanged();
+ }
+
+ // UnChanged();
+
+ return PSNRET_NOERROR;
+}
+
+void CMenuPage::OnNotifyHelp()
+{
+ ShowHelpWindow(kMenuTopic);
+}
+
+bool CMenuPage::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ #ifndef UNDER_CE
+ case IDX_SYSTEM_INTEGRATE_TO_MENU:
+ case IDX_SYSTEM_INTEGRATE_TO_MENU_2:
+ {
+ for (unsigned d = 0; d < 2; d++)
+ {
+ CShellDll &dll = _dlls[d];
+ if (buttonID == dll.ctrl && !dll.Path.IsEmpty())
+ dll.wasChanged = true;
+ }
+ break;
+ }
+ #endif
+
+ case IDX_SYSTEM_CASCADED_MENU: _cascaded_Changed = true; break;
+ case IDX_SYSTEM_ICON_IN_MENU: _menuIcons_Changed = true; break;
+ case IDX_EXTRACT_ELIM_DUP: _elimDup_Changed = true; break;
+ // case IDX_EXTRACT_WRITE_ZONE: _writeZone_Changed = true; break;
+
+ default:
+ return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+ }
+
+ Changed();
+ return true;
+}
+
+
+bool CMenuPage::OnCommand(unsigned code, unsigned itemID, LPARAM param)
+{
+ if (code == CBN_SELCHANGE && itemID == IDC_SYSTEM_ZONE)
+ {
+ _writeZone_Changed = true;
+ Changed();
+ return true;
+ }
+ return CPropertyPage::OnCommand(code, itemID, param);
+}
+
+
+bool CMenuPage::OnNotify(UINT controlID, LPNMHDR lParam)
+{
+ if (lParam->hwndFrom == HWND(_listView))
+ {
+ switch (lParam->code)
+ {
+ case (LVN_ITEMCHANGED):
+ return OnItemChanged((const NMLISTVIEW *)lParam);
+ }
+ }
+ return CPropertyPage::OnNotify(controlID, lParam);
+}
+
+
+bool CMenuPage::OnItemChanged(const NMLISTVIEW *info)
+{
+ if (_initMode)
+ return true;
+ if ((info->uChanged & LVIF_STATE) != 0)
+ {
+ UINT oldState = info->uOldState & LVIS_STATEIMAGEMASK;
+ UINT newState = info->uNewState & LVIS_STATEIMAGEMASK;
+ if (oldState != newState)
+ {
+ _flags_Changed = true;
+ Changed();
+ }
+ }
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/MenuPage.h b/CPP/7zip/UI/FileManager/MenuPage.h
new file mode 100644
index 0000000..3b62a8b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage.h
@@ -0,0 +1,57 @@
+// MenuPage.h
+
+#ifndef ZIP7_INC_MENU_PAGE_H
+#define ZIP7_INC_MENU_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/ListView.h"
+
+struct CShellDll
+{
+ FString Path;
+ bool wasChanged;
+ bool prevValue;
+ unsigned ctrl;
+ UInt32 wow;
+
+ CShellDll(): wasChanged (false), prevValue(false), ctrl(0), wow(0) {}
+};
+
+class CMenuPage: public NWindows::NControl::CPropertyPage
+{
+ bool _initMode;
+
+ bool _cascaded_Changed;
+ bool _menuIcons_Changed;
+ bool _elimDup_Changed;
+ bool _writeZone_Changed;
+ bool _flags_Changed;
+
+ void Clear_MenuChanged()
+ {
+ _cascaded_Changed = false;
+ _menuIcons_Changed = false;
+ _elimDup_Changed = false;
+ _writeZone_Changed = false;
+ _flags_Changed = false;
+ }
+
+ #ifndef UNDER_CE
+ CShellDll _dlls[2];
+ #endif
+
+ NWindows::NControl::CListView _listView;
+ NWindows::NControl::CComboBox _zoneCombo;
+
+ virtual bool OnInit() Z7_override;
+ virtual void OnNotifyHelp() Z7_override;
+ virtual bool OnNotify(UINT controlID, LPNMHDR lParam) Z7_override;
+ virtual LONG OnApply() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM param) Z7_override;
+
+ bool OnItemChanged(const NMLISTVIEW* info);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MenuPage.rc b/CPP/7zip/UI/FileManager/MenuPage.rc
new file mode 100644
index 0000000..fc21107
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage.rc
@@ -0,0 +1,24 @@
+#include "MenuPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 252
+
+IDD_MENU MY_PAGE
+#include "MenuPage2.rc"
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+
+#define yc 112
+
+IDD_MENU_2 MY_PAGE
+#include "MenuPage2.rc"
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MenuPage2.rc b/CPP/7zip/UI/FileManager/MenuPage2.rc
new file mode 100644
index 0000000..4d1ba21
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPage2.rc
@@ -0,0 +1,28 @@
+#include "../GUI/ExtractDialogRes.h"
+
+#define y 96
+
+#define zoneX 90
+
+CAPTION "7-Zip"
+BEGIN
+ CONTROL "Integrate 7-Zip to shell context menu", IDX_SYSTEM_INTEGRATE_TO_MENU, MY_CHECKBOX, m, m, xc, 10
+ CONTROL "(32-bit)", IDX_SYSTEM_INTEGRATE_TO_MENU_2, MY_CHECKBOX, m, m + 14, xc, 10
+ CONTROL "Cascaded context menu", IDX_SYSTEM_CASCADED_MENU, MY_CHECKBOX, m, m + 28, xc, 10
+ CONTROL "Icons in context menu", IDX_SYSTEM_ICON_IN_MENU, MY_CHECKBOX, m, m + 42, xc, 10
+ CONTROL "Eliminate duplication of root folder", IDX_EXTRACT_ELIM_DUP, MY_CHECKBOX, m, m + 56, xc, 10
+
+ LTEXT "Propagate Zone.Id stream:", IDT_SYSTEM_ZONE, m, m + 70, xc - zoneX, 8
+ COMBOBOX IDC_SYSTEM_ZONE, m + xc - zoneX, m + 70 - 2, zoneX, 50, MY_COMBO
+
+ LTEXT "Context menu items:", IDT_SYSTEM_CONTEXT_MENU_ITEMS, m, m + 84, xc, 8
+ CONTROL "List", IDL_SYSTEM_OPTIONS, "SysListView32",
+ LVS_REPORT | LVS_SINGLESEL | LVS_NOCOLUMNHEADER | WS_BORDER | WS_TABSTOP,
+ m, m + y, xc, yc - y
+END
+
+
+STRINGTABLE
+BEGIN
+ IDT_ZONE_FOR_OFFICE "For Office files"
+END
diff --git a/CPP/7zip/UI/FileManager/MenuPageRes.h b/CPP/7zip/UI/FileManager/MenuPageRes.h
new file mode 100644
index 0000000..e2cf798
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MenuPageRes.h
@@ -0,0 +1,15 @@
+#define IDD_MENU 2300
+#define IDD_MENU_2 12300
+
+#define IDX_SYSTEM_INTEGRATE_TO_MENU 2301
+#define IDX_SYSTEM_CASCADED_MENU 2302
+#define IDT_SYSTEM_CONTEXT_MENU_ITEMS 2303
+#define IDX_SYSTEM_ICON_IN_MENU 2304
+
+#define IDX_SYSTEM_INTEGRATE_TO_MENU_2 2310
+
+#define IDT_SYSTEM_ZONE 3440
+#define IDT_ZONE_FOR_OFFICE 3441
+
+#define IDL_SYSTEM_OPTIONS 100
+#define IDC_SYSTEM_ZONE 101
diff --git a/CPP/7zip/UI/FileManager/MessagesDialog.cpp b/CPP/7zip/UI/FileManager/MessagesDialog.cpp
new file mode 100644
index 0000000..57e56bc
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialog.cpp
@@ -0,0 +1,76 @@
+// MessagesDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/ResourceString.h"
+
+#include "MessagesDialog.h"
+
+#include "LangUtils.h"
+
+#include "ProgressDialog2Res.h"
+
+using namespace NWindows;
+
+void CMessagesDialog::AddMessageDirect(LPCWSTR message)
+{
+ const unsigned i = (unsigned)_messageList.GetItemCount();
+ wchar_t sz[16];
+ ConvertUInt32ToString(i, sz);
+ _messageList.InsertItem(i, sz);
+ _messageList.SetSubItem(i, 1, message);
+}
+
+void CMessagesDialog::AddMessage(LPCWSTR message)
+{
+ UString s = message;
+ while (!s.IsEmpty())
+ {
+ const int pos = s.Find(L'\n');
+ if (pos < 0)
+ break;
+ AddMessageDirect(s.Left(pos));
+ s.DeleteFrontal((unsigned)pos + 1);
+ }
+ AddMessageDirect(s);
+}
+
+bool CMessagesDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_MESSAGES);
+ LangSetDlgItems(*this, NULL, 0);
+ SetItemText(IDOK, LangString(IDS_CLOSE));
+ #endif
+ _messageList.Attach(GetItem(IDL_MESSAGE));
+ _messageList.SetUnicodeFormat();
+
+ _messageList.InsertColumn(0, L"", 30);
+ _messageList.InsertColumn(1, LangString(IDS_MESSAGE), 600);
+
+ FOR_VECTOR (i, *Messages)
+ AddMessage((*Messages)[i]);
+
+ _messageList.SetColumnWidthAuto(0);
+ _messageList.SetColumnWidthAuto(1);
+ NormalizeSize();
+ return CModalDialog::OnInit();
+}
+
+bool CMessagesDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx, by;
+ GetItemSizes(IDOK, bx, by);
+ int y = ySize - my - by;
+ int x = xSize - mx - bx;
+
+ InvalidateRect(NULL);
+
+ MoveItem(IDOK, x, y, bx, by);
+ _messageList.Move(mx, my, xSize - mx * 2, y - my * 2);
+ return false;
+}
diff --git a/CPP/7zip/UI/FileManager/MessagesDialog.h b/CPP/7zip/UI/FileManager/MessagesDialog.h
new file mode 100644
index 0000000..40b0379
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialog.h
@@ -0,0 +1,25 @@
+// MessagesDialog.h
+
+#ifndef ZIP7_INC_MESSAGES_DIALOG_H
+#define ZIP7_INC_MESSAGES_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ListView.h"
+
+#include "MessagesDialogRes.h"
+
+class CMessagesDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CListView _messageList;
+
+ void AddMessageDirect(LPCWSTR message);
+ void AddMessage(LPCWSTR message);
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+public:
+ const UStringVector *Messages;
+
+ INT_PTR Create(HWND parent = NULL) { return CModalDialog::Create(IDD_MESSAGES, parent); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MessagesDialog.rc b/CPP/7zip/UI/FileManager/MessagesDialog.rc
new file mode 100644
index 0000000..49b73e8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialog.rc
@@ -0,0 +1,14 @@
+#include "MessagesDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 440
+#define yc 160
+
+IDD_MESSAGES DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "7-Zip: Diagnostic messages"
+{
+ DEFPUSHBUTTON "&Close", IDOK, bx, by, bxs, bys
+ CONTROL "List1", IDL_MESSAGE, "SysListView32",
+ LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+ m, m, xc, yc - bys - m
+}
diff --git a/CPP/7zip/UI/FileManager/MessagesDialogRes.h b/CPP/7zip/UI/FileManager/MessagesDialogRes.h
new file mode 100644
index 0000000..c8fffff
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MessagesDialogRes.h
@@ -0,0 +1,3 @@
+#define IDD_MESSAGES 6602
+#define IDS_MESSAGE 6603
+#define IDL_MESSAGE 100
diff --git a/CPP/7zip/UI/FileManager/Move.bmp b/CPP/7zip/UI/FileManager/Move.bmp
new file mode 100644
index 0000000..eb5f20f
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Move.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Move2.bmp b/CPP/7zip/UI/FileManager/Move2.bmp
new file mode 100644
index 0000000..58679ef
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Move2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/MyCom2.h b/CPP/7zip/UI/FileManager/MyCom2.h
new file mode 100644
index 0000000..d3b49fe
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyCom2.h
@@ -0,0 +1,55 @@
+// MyCom2.h
+
+#ifndef ZIP7_INC_MYCOM2_H
+#define ZIP7_INC_MYCOM2_H
+
+#include "../../../Common/MyCom.h"
+
+#define Z7_COM_ADDREF_RELEASE_MT \
+ private: \
+ STDMETHOD_(ULONG, AddRef)() Z7_override Z7_final \
+ { return (ULONG)InterlockedIncrement((LONG *)&_m_RefCount); } \
+ STDMETHOD_(ULONG, Release)() Z7_override Z7_final \
+ { const LONG v = InterlockedDecrement((LONG *)&_m_RefCount); \
+ if (v != 0) return (ULONG)v; \
+ delete this; return 0; }
+
+#define Z7_COM_UNKNOWN_IMP_SPEC_MT2(i1, i) \
+ Z7_COM_QI_BEGIN \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ i \
+ Z7_COM_QI_END \
+ Z7_COM_ADDREF_RELEASE_MT
+
+
+#define Z7_COM_UNKNOWN_IMP_1_MT(i) \
+ Z7_COM_UNKNOWN_IMP_SPEC_MT2( \
+ i, \
+ Z7_COM_QI_ENTRY(i) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_2_MT(i1, i2) \
+ Z7_COM_UNKNOWN_IMP_SPEC_MT2( \
+ i1, \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_3_MT(i1, i2, i3) \
+ Z7_COM_UNKNOWN_IMP_SPEC_MT2( \
+ i1, \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_4_MT(i1, i2, i3, i4) \
+ Z7_COM_UNKNOWN_IMP_SPEC_MT2( \
+ i1, \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ Z7_COM_QI_ENTRY(i4) \
+ )
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MyLoadMenu.cpp b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
new file mode 100644
index 0000000..9453536
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyLoadMenu.cpp
@@ -0,0 +1,918 @@
+// MyLoadMenu.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/TimeUtils.h"
+#include "../../../Windows/Control/Dialog.h"
+
+#include "../../PropID.h"
+
+#include "../Common/CompressCall.h"
+
+#include "AboutDialog.h"
+#include "App.h"
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+#include "RegistryUtils.h"
+
+#include "PropertyNameRes.h"
+#include "resource.h"
+
+using namespace NWindows;
+
+static const UINT k_MenuID_OpenBookmark = 830;
+static const UINT k_MenuID_SetBookmark = 810;
+static const UINT k_MenuID_TimePopup = IDM_VIEW_TIME_POPUP;
+static const UINT k_MenuID_Time = IDM_VIEW_TIME;
+
+extern HINSTANCE g_hInstance;
+
+#define kFMHelpTopic "FM/index.htm"
+
+extern void OptionsDialog(HWND hwndOwner, HINSTANCE hInstance);
+
+enum
+{
+ k_MenuIndex_File = 0,
+ k_MenuIndex_Edit,
+ k_MenuIndex_View,
+ k_MenuIndex_Bookmarks
+};
+
+#ifdef Z7_LANG
+static const UInt32 k_LangID_TopMenuItems[] =
+{
+ IDM_FILE,
+ IDM_EDIT,
+ IDM_VIEW,
+ IDM_FAVORITES,
+ IDM_TOOLS,
+ IDM_HELP
+};
+
+static const UInt32 k_LangID_Toolbars = IDM_VIEW_TOOLBARS;
+static const UInt32 k_LangID_AddToFavorites = IDM_ADD_TO_FAVORITES;
+
+static const CIDLangPair kIDLangPairs[] =
+{
+ { IDCLOSE, 557 }, // IDM_EXIT
+ { IDM_VIEW_ARANGE_BY_NAME, IDS_PROP_NAME },
+ { IDM_VIEW_ARANGE_BY_TYPE, IDS_PROP_FILE_TYPE },
+ { IDM_VIEW_ARANGE_BY_DATE, IDS_PROP_MTIME },
+ { IDM_VIEW_ARANGE_BY_SIZE, IDS_PROP_SIZE }
+};
+
+static int FindLangItem(unsigned controlID)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kIDLangPairs); i++)
+ if (kIDLangPairs[i].ControlID == controlID)
+ return (int)i;
+ return -1;
+}
+#endif
+
+static unsigned GetSortControlID(PROPID propID)
+{
+ switch (propID)
+ {
+ case kpidName: return IDM_VIEW_ARANGE_BY_NAME;
+ case kpidExtension: return IDM_VIEW_ARANGE_BY_TYPE;
+ case kpidMTime: return IDM_VIEW_ARANGE_BY_DATE;
+ case kpidSize: return IDM_VIEW_ARANGE_BY_SIZE;
+ case kpidNoProperty: return IDM_VIEW_ARANGE_NO_SORT;
+ }
+ return IDM_VIEW_ARANGE_BY_NAME;
+ // IDM_VIEW_ARANGE_NO_SORT;
+ // return -1;
+}
+
+/*
+#if _MSC_VER > 1400
+// GetVersion was declared deprecated
+#pragma warning(disable : 4996)
+#endif
+
+static bool g_IsNew_fMask = false;
+static class CInit_fMask
+{
+public:
+ CInit_fMask()
+ {
+ DWORD v = GetVersion();
+ v = ((v & 0xff) << 8) | ((v >> 8) & 0xFF);
+ g_IsNew_fMask = (v > 0x400); // (win98/win2000) or newer
+ }
+} g_Init_fMask;
+static UINT Get_fMask_for_String()
+ { return g_IsNew_fMask ? MIIM_STRING : MIIM_TYPE; }
+static UINT Get_fMask_for_FType_and_String()
+ { return g_IsNew_fMask ? (MIIM_STRING | MIIM_FTYPE) : MIIM_TYPE; }
+*/
+
+/*
+We can use new MIIM_STRING / MIIM_FTYPE flags in the following conditions:
+ 1) we run at new Windows (win98/win2000) or newer
+ 2) also we probably must set MENUITEMINFO::cbSize as sizeof of full
+ (MENUITEMINFO) that was compiled with (WINVER >= 0x0500)
+But it's simpler to use old MIIM_TYPE without these complex checks.
+*/
+
+// /*
+static inline UINT Get_fMask_for_String() { return MIIM_TYPE; }
+static inline UINT Get_fMask_for_FType_and_String() { return MIIM_TYPE; }
+// */
+
+static bool Is_MenuItem_TimePopup(const CMenuItem &item)
+{
+ return item.wID == k_MenuID_TimePopup ||
+ item.StringValue.IsPrefixedBy_Ascii_NoCase("20");
+}
+
+#ifdef Z7_LANG
+static void MyChangeMenu(HMENU menuLoc, unsigned menuID, unsigned level, unsigned menuIndex)
+{
+ CMenu menu;
+ menu.Attach(menuLoc);
+
+ for (unsigned i = 0;; i++)
+ {
+ CMenuItem item;
+ /* here we can use
+ Get_fMask_for_String() or
+ Get_fMask_for_FType_and_String()
+ We want to change only String of menu item.
+ It's not required to change (fType) of menu item.
+ We can look (fType) to check for SEPARATOR item.
+ But String of separator is empty and (wID == 0).
+ So we can check for SEPARATOR without (fType) requesting.
+ So it's enough to use Get_fMask_for_String() here */
+ item.fMask =
+ Get_fMask_for_String()
+ // Get_fMask_for_FType_and_String()
+ | MIIM_SUBMENU | MIIM_ID;
+ if (!menu.GetItem(i, true, item))
+ break;
+ {
+ UString newString;
+ if (item.hSubMenu)
+ {
+ /* in win10:
+ MENU+POPUP:
+ (wID == item.hSubMenu)
+ MENUEX+POPUP where ID is not set:
+ (wID == 0)
+ MENU+SEPARATOR
+ (wID == 0)
+ */
+ UInt32 langID = item.wID;
+ if (langID >= (1 << 16))
+ {
+ // here we try to exclude the case (wID == item.hSubMenu) if (MENU+POPUP)
+ continue;
+ }
+ if (langID == 0)
+ {
+ if (level == 0)
+ {
+ if (i < Z7_ARRAY_SIZE(k_LangID_TopMenuItems))
+ langID = k_LangID_TopMenuItems[i];
+ }
+ else if (level == 1)
+ {
+ if (menuID == IDM_FAVORITES || (menuID == 0 && menuIndex == k_MenuIndex_Bookmarks))
+ langID = k_LangID_AddToFavorites;
+ else if (menuID == IDM_VIEW || (menuID == 0 && menuIndex == k_MenuIndex_View))
+ {
+ if (Is_MenuItem_TimePopup(item))
+ langID = k_MenuID_TimePopup;
+ else
+ langID = k_LangID_Toolbars;
+ }
+ }
+ }
+ if (langID == k_MenuID_TimePopup)
+ continue;
+ if (langID != k_LangID_AddToFavorites)
+ MyChangeMenu(item.hSubMenu, langID, level + 1, i);
+ if (langID == 0)
+ continue;
+ LangString_OnlyFromLangFile(langID, newString);
+ if (newString.IsEmpty())
+ continue;
+ }
+ else
+ {
+ if (item.fMask & (MIIM_TYPE | MIIM_FTYPE))
+ if (item.IsSeparator())
+ continue;
+ if (item.StringValue.IsEmpty())
+ continue;
+ const int langPos = FindLangItem(item.wID);
+ // we don't need lang change for CRC items!!!
+ const UInt32 langID = langPos >= 0 ? kIDLangPairs[langPos].LangID : item.wID;
+ if (langID == 0)
+ continue;
+
+ if (langID == IDM_OPEN_INSIDE_ONE ||
+ langID == IDM_OPEN_INSIDE_PARSER)
+ {
+ LangString_OnlyFromLangFile(IDM_OPEN_INSIDE, newString);
+ if (newString.IsEmpty())
+ continue;
+ newString.Replace(L"&", L"");
+ const int tabPos = newString.Find(L"\t");
+ if (tabPos >= 0)
+ newString.DeleteFrom(tabPos);
+ newString += (langID == IDM_OPEN_INSIDE_ONE ? " *" : " #");
+ }
+ else if (langID == IDM_BENCHMARK2)
+ {
+ LangString_OnlyFromLangFile(IDM_BENCHMARK, newString);
+ if (newString.IsEmpty())
+ continue;
+ newString.Replace(L"&", L"");
+ const int tabPos = newString.Find(L"\t");
+ if (tabPos >= 0)
+ newString.DeleteFrom(tabPos);
+ newString += " 2";
+ }
+ else
+ {
+ LangString_OnlyFromLangFile(langID, newString);
+ }
+
+ if (newString.IsEmpty())
+ continue;
+
+ const int tabPos = item.StringValue.ReverseFind(L'\t');
+ if (tabPos >= 0)
+ newString += item.StringValue.Ptr(tabPos);
+ }
+
+ {
+ item.StringValue = newString;
+ // we want to change only String
+ item.fMask = Get_fMask_for_String();
+ menu.SetItem(i, true, item);
+ }
+ }
+ }
+}
+#endif
+
+static CMenu g_FileMenu;
+
+static struct CFileMenuDestroyer
+{
+ ~CFileMenuDestroyer() { if ((HMENU)g_FileMenu) g_FileMenu.Destroy(); }
+} g_FileMenuDestroyer;
+
+
+static void CopyMenu(HMENU srcMenuSpec, HMENU destMenuSpec);
+
+static void CopyPopMenu_IfRequired(CMenuItem &item)
+{
+ /* if (item.hSubMenu) is defined
+ {
+ - it creates new (popup) menu
+ - it copies menu items from old item.hSubMenu menu to new (popup) menu
+ - it sets item.hSubMenu to handle of created (popup) menu
+ } */
+ if (item.hSubMenu)
+ {
+ CMenu popup;
+ popup.CreatePopup();
+ CopyMenu(item.hSubMenu, popup);
+ item.hSubMenu = popup;
+ }
+}
+
+/* destMenuSpec must be non-NULL handle to created empty popup menu */
+static void CopyMenu(HMENU srcMenuSpec, HMENU destMenuSpec)
+{
+ CMenu srcMenu;
+ srcMenu.Attach(srcMenuSpec);
+ CMenu destMenu;
+ destMenu.Attach(destMenuSpec);
+ unsigned startPos = 0;
+ for (unsigned i = 0;; i++)
+ {
+ CMenuItem item;
+ item.fMask = MIIM_SUBMENU | MIIM_STATE | MIIM_ID | Get_fMask_for_FType_and_String();
+ if (!srcMenu.GetItem(i, true, item))
+ break;
+ CopyPopMenu_IfRequired(item);
+ if (destMenu.InsertItem(startPos, true, item))
+ startPos++;
+ }
+}
+
+
+/* use for (needResetMenu):
+ false : for call from program window creation code
+ true : for another calls : (from Options language change)
+*/
+void MyLoadMenu(bool needResetMenu)
+{
+ #ifdef UNDER_CE
+
+ const HMENU oldMenu = g_App._commandBar.GetMenu(0);
+ if (oldMenu)
+ ::DestroyMenu(oldMenu);
+ /* BOOL b = */ g_App._commandBar.InsertMenubar(g_hInstance, IDM_MENU, 0);
+ const HMENU baseMenu = g_App._commandBar.GetMenu(0);
+ // if (startInit)
+ // SetIdsForSubMenus(baseMenu, 0, 0);
+ if (!g_LangID.IsEmpty())
+ MyChangeMenu(baseMenu, 0, 0);
+ g_App._commandBar.DrawMenuBar(0);
+
+ #else // UNDER_CE
+
+ const HWND hWnd = g_HWND;
+ bool menuWasChanged = false;
+ /*
+ We must reload to english default menu for at least two cases:
+ - if some submenu was changed (File or another submenu can be changed after menu activating).
+ - for change from non-english lang to another partial non-english lang,
+ where we still need some english strings.
+ But we reload menu to default menu everytime except of program starting stage.
+ That scheme is simpler than complex checks for exact conditions for menu reload.
+ */
+ if (needResetMenu)
+ {
+ const HMENU oldMenu = ::GetMenu(hWnd);
+ const HMENU newMenu = ::LoadMenu(g_hInstance, MAKEINTRESOURCE(IDM_MENU));
+ // docs for SetMenu(): the window is redrawn to reflect the menu change.
+ if (newMenu && ::SetMenu(hWnd, newMenu))
+ ::DestroyMenu(oldMenu);
+ menuWasChanged = true;
+ }
+ const HMENU baseMenu = ::GetMenu(hWnd);
+ // if (startInit)
+ // SetIdsForSubMenus(baseMenu, 0, 0);
+ #ifdef Z7_LANG
+ if (!g_Lang.IsEmpty()) // !g_LangID.IsEmpty() &&
+ {
+ MyChangeMenu(baseMenu, 0, 0, 0);
+ menuWasChanged = true;
+ }
+ #endif
+
+ if (menuWasChanged)
+ ::DrawMenuBar(hWnd);
+
+ #endif // UNDER_CE
+
+ // menuWasChanged = false; // for debug
+ if (menuWasChanged || !(HMENU)g_FileMenu)
+ {
+ if ((HMENU)g_FileMenu)
+ g_FileMenu.Destroy();
+ g_FileMenu.CreatePopup();
+ CopyMenu(::GetSubMenu(baseMenu, k_MenuIndex_File), g_FileMenu);
+ }
+}
+
+void OnMenuActivating(HWND /* hWnd */, HMENU hMenu, int position)
+{
+ HMENU mainMenu =
+ #ifdef UNDER_CE
+ g_App._commandBar.GetMenu(0);
+ #else
+ ::GetMenu(g_HWND)
+ #endif
+ ;
+
+ if (::GetSubMenu(mainMenu, position) != hMenu)
+ return;
+
+ if (position == k_MenuIndex_File)
+ {
+ CMenu menu;
+ menu.Attach(hMenu);
+ menu.RemoveAllItems();
+ g_App.GetFocusedPanel().CreateFileMenu(hMenu);
+ }
+ else if (position == k_MenuIndex_Edit)
+ {
+ /*
+ CMenu menu;
+ menu.Attach(hMenu);
+ menu.EnableItem(IDM_EDIT_CUT, MF_ENABLED);
+ menu.EnableItem(IDM_EDIT_COPY, MF_ENABLED);
+ menu.EnableItem(IDM_EDIT_PASTE, IsClipboardFormatAvailableHDROP() ? MF_ENABLED : MF_GRAYED);
+ */
+ }
+ else if (position == k_MenuIndex_View)
+ {
+ // View;
+ CMenu menu;
+ menu.Attach(hMenu);
+ menu.CheckRadioItem(
+ IDM_VIEW_LARGE_ICONS, IDM_VIEW_DETAILS,
+ IDM_VIEW_LARGE_ICONS + g_App.GetListViewMode(), MF_BYCOMMAND);
+
+ menu.CheckRadioItem(
+ IDM_VIEW_ARANGE_BY_NAME,
+ IDM_VIEW_ARANGE_NO_SORT,
+ GetSortControlID(g_App.GetSortID()),
+ MF_BYCOMMAND);
+
+ menu.CheckItemByID(IDM_VIEW_TWO_PANELS, g_App.NumPanels == 2);
+ menu.CheckItemByID(IDM_VIEW_FLAT_VIEW, g_App.GetFlatMode());
+ menu.CheckItemByID(IDM_VIEW_ARCHIVE_TOOLBAR, g_App.ShowArchiveToolbar);
+ menu.CheckItemByID(IDM_VIEW_STANDARD_TOOLBAR, g_App.ShowStandardToolbar);
+ menu.CheckItemByID(IDM_VIEW_TOOLBARS_LARGE_BUTTONS, g_App.LargeButtons);
+ menu.CheckItemByID(IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT, g_App.ShowButtonsLables);
+ menu.CheckItemByID(IDM_VIEW_AUTO_REFRESH, g_App.Get_AutoRefresh_Mode());
+ // menu.CheckItemByID(IDM_VIEW_SHOW_STREAMS, g_App.Get_ShowNtfsStrems_Mode());
+ // menu.CheckItemByID(IDM_VIEW_SHOW_DELETED, g_App.ShowDeletedFiles);
+
+ for (unsigned i = 0;; i++)
+ {
+ CMenuItem item;
+ item.fMask = Get_fMask_for_String() | MIIM_SUBMENU | MIIM_ID;
+ item.fType = MFT_STRING;
+ if (!menu.GetItem(i, true, item))
+ break;
+ if (item.hSubMenu && Is_MenuItem_TimePopup(item))
+ {
+ FILETIME ft;
+ NTime::GetCurUtcFileTime(ft);
+
+ {
+ wchar_t s[64];
+ s[0] = 0;
+ if (ConvertUtcFileTimeToString(ft, s, kTimestampPrintLevel_DAY))
+ item.StringValue = s;
+ }
+
+ item.fMask = Get_fMask_for_String() | MIIM_ID;
+ item.fType = MFT_STRING;
+ item.wID = k_MenuID_TimePopup;
+ menu.SetItem(i, true, item);
+
+ CMenu subMenu;
+ subMenu.Attach(menu.GetSubMenu((int)i));
+ subMenu.RemoveAllItems();
+
+ const int k_TimeLevels[] =
+ {
+ kTimestampPrintLevel_DAY,
+ kTimestampPrintLevel_MIN,
+ kTimestampPrintLevel_SEC,
+ // 1,2,3,4,5,6,
+ kTimestampPrintLevel_NTFS,
+ kTimestampPrintLevel_NS
+ };
+
+ unsigned last = k_MenuID_Time;
+ unsigned selectedCommand = 0;
+ g_App._timestampLevels.Clear();
+ unsigned id = k_MenuID_Time;
+
+ for (unsigned k = 0; k < Z7_ARRAY_SIZE(k_TimeLevels); k++)
+ {
+ wchar_t s[64];
+ s[0] = 0;
+ const int timestampLevel = k_TimeLevels[k];
+ if (ConvertUtcFileTimeToString(ft, s, timestampLevel))
+ {
+ if (subMenu.AppendItem(MF_STRING, id, s))
+ {
+ last = id;
+ g_App._timestampLevels.Add(timestampLevel);
+ if (g_App.GetTimestampLevel() == timestampLevel)
+ selectedCommand = id;
+ id++;
+ }
+ }
+ }
+ if (selectedCommand != 0)
+ menu.CheckRadioItem(k_MenuID_Time, last, selectedCommand, MF_BYCOMMAND);
+ }
+ }
+ }
+ else if (position == k_MenuIndex_Bookmarks)
+ {
+ CMenu menu;
+ menu.Attach(hMenu);
+
+ CMenu subMenu;
+ subMenu.Attach(menu.GetSubMenu(0));
+ subMenu.RemoveAllItems();
+ unsigned i;
+
+ for (i = 0; i < 10; i++)
+ {
+ UString s = LangString(IDS_BOOKMARK);
+ s.Add_Space();
+ const char c = (char)(L'0' + i);
+ s += c;
+ s += "\tAlt+Shift+";
+ s += c;
+ subMenu.AppendItem(MF_STRING, k_MenuID_SetBookmark + i, s);
+ }
+
+ menu.RemoveAllItemsFrom(2);
+
+ for (i = 0; i < 10; i++)
+ {
+ UString s = g_App.AppState.FastFolders.GetString(i);
+ const int kMaxSize = 100;
+ const int kFirstPartSize = kMaxSize / 2;
+ if (s.Len() > kMaxSize)
+ {
+ s.Delete(kFirstPartSize, s.Len() - kMaxSize);
+ s.Insert(kFirstPartSize, L" ... ");
+ }
+ if (s.IsEmpty())
+ s = '-';
+ s += "\tAlt+";
+ s += (char)('0' + i);
+ menu.AppendItem(MF_STRING, k_MenuID_OpenBookmark + i, s);
+ }
+ }
+}
+
+/*
+It doesn't help
+void OnMenuUnActivating(HWND hWnd, HMENU hMenu, int id)
+{
+ if (::GetSubMenu(::GetMenu(g_HWND), 0) != hMenu)
+ return;
+}
+*/
+
+static const unsigned g_Zvc_IDs[] =
+{
+ IDM_VER_EDIT,
+ IDM_VER_COMMIT,
+ IDM_VER_REVERT,
+ IDM_VER_DIFF
+};
+
+static const char * const g_Zvc_Strings[] =
+{
+ "Ver Edit (&1)"
+ , "Ver Commit"
+ , "Ver Revert"
+ , "Ver Diff (&0)"
+};
+
+void CFileMenu::Load(HMENU hMenu, unsigned startPos)
+{
+ CMenu destMenu;
+ destMenu.Attach(hMenu);
+
+ UString diffPath;
+ ReadRegDiff(diffPath);
+
+ unsigned numRealItems = startPos;
+
+ const bool isBigScreen = NControl::IsDialogSizeOK(40, 200, g_HWND);
+
+ for (unsigned i = 0;; i++)
+ {
+ CMenuItem item;
+
+ item.fMask = MIIM_SUBMENU | MIIM_STATE | MIIM_ID | Get_fMask_for_FType_and_String();
+ item.fType = MFT_STRING;
+
+ if (!g_FileMenu.GetItem(i, true, item))
+ break;
+
+ {
+ if (!programMenu && item.wID == IDCLOSE)
+ continue;
+
+ if (item.wID == IDM_DIFF && diffPath.IsEmpty())
+ continue;
+
+ if (item.wID == IDM_OPEN_INSIDE_ONE || item.wID == IDM_OPEN_INSIDE_PARSER)
+ {
+ // We use diff as "super mode" marker for additional commands.
+ /*
+ if (diffPath.IsEmpty())
+ continue;
+ */
+ }
+
+ if (item.wID == IDM_BENCHMARK2)
+ {
+ // We use diff as "super mode" marker for additional commands.
+ if (diffPath.IsEmpty())
+ continue;
+ }
+
+ bool isOneFsFile = (isFsFolder && numItems == 1 && allAreFiles);
+ bool disable = (!isOneFsFile && (item.wID == IDM_SPLIT || item.wID == IDM_COMBINE));
+
+ if (readOnly)
+ {
+ switch (item.wID)
+ {
+ case IDM_RENAME:
+ case IDM_MOVE_TO:
+ case IDM_DELETE:
+ case IDM_COMMENT:
+ case IDM_CREATE_FOLDER:
+ case IDM_CREATE_FILE:
+ disable = true;
+ }
+ }
+
+ if (isHashFolder)
+ {
+ switch (item.wID)
+ {
+ case IDM_OPEN:
+ case IDM_OPEN_INSIDE:
+ case IDM_OPEN_INSIDE_ONE:
+ case IDM_OPEN_INSIDE_PARSER:
+ case IDM_OPEN_OUTSIDE:
+ case IDM_FILE_VIEW:
+ case IDM_FILE_EDIT:
+ // case IDM_RENAME:
+ case IDM_COPY_TO:
+ case IDM_MOVE_TO:
+ // case IDM_DELETE:
+ case IDM_COMMENT:
+ case IDM_CREATE_FOLDER:
+ case IDM_CREATE_FILE:
+ case IDM_LINK:
+ case IDM_DIFF:
+ disable = true;
+ }
+ }
+
+
+ if (item.wID == IDM_LINK && numItems != 1)
+ disable = true;
+
+ if (item.wID == IDM_ALT_STREAMS)
+ disable = !isAltStreamsSupported;
+
+ if (!isBigScreen && (disable || item.IsSeparator()))
+ continue;
+
+ CopyPopMenu_IfRequired(item);
+ if (destMenu.InsertItem(startPos, true, item))
+ {
+ if (disable)
+ destMenu.EnableItem(startPos, MF_BYPOSITION | MF_GRAYED);
+ startPos++;
+ }
+
+ if (!item.IsSeparator())
+ numRealItems = startPos;
+ }
+ }
+
+ UString vercPath;
+ if (!diffPath.IsEmpty() && isFsFolder && allAreFiles && numItems == 1)
+ ReadReg_VerCtrlPath(vercPath);
+
+ if (!vercPath.IsEmpty())
+ {
+ NFile::NFind::CFileInfo fi;
+ if (fi.Find(FilePath) && fi.Size < ((UInt32)1 << 31) && !fi.IsDir())
+ {
+ for (unsigned k = 0; k < Z7_ARRAY_SIZE(g_Zvc_IDs); k++)
+ {
+ const unsigned id = g_Zvc_IDs[k];
+ if (fi.IsReadOnly())
+ {
+ if (id == IDM_VER_COMMIT ||
+ id == IDM_VER_REVERT ||
+ id == IDM_VER_DIFF)
+ continue;
+ }
+ else
+ {
+ if (id == IDM_VER_EDIT)
+ continue;
+ }
+
+ CMenuItem item;
+ UString s (g_Zvc_Strings[k]);
+ if (destMenu.AppendItem(MF_STRING, id, s))
+ {
+ startPos++;
+ numRealItems = startPos;
+ }
+ }
+ }
+ }
+
+ destMenu.RemoveAllItemsFrom(numRealItems);
+}
+
+bool ExecuteFileCommand(unsigned id)
+{
+ if (id >= kMenuCmdID_Plugin_Start)
+ {
+ g_App.GetFocusedPanel().InvokePluginCommand(id);
+ g_App.GetFocusedPanel()._sevenZipContextMenu.Release();
+ g_App.GetFocusedPanel()._systemContextMenu.Release();
+ return true;
+ }
+
+ switch (id)
+ {
+ // File
+ case IDM_OPEN: g_App.OpenItem(); break;
+
+ case IDM_OPEN_INSIDE: g_App.OpenItemInside(NULL); break;
+ case IDM_OPEN_INSIDE_ONE: g_App.OpenItemInside(L"*"); break;
+ case IDM_OPEN_INSIDE_PARSER: g_App.OpenItemInside(L"#"); break;
+
+ case IDM_OPEN_OUTSIDE: g_App.OpenItemOutside(); break;
+ case IDM_FILE_VIEW: g_App.EditItem(false); break;
+ case IDM_FILE_EDIT: g_App.EditItem(true); break;
+ case IDM_RENAME: g_App.Rename(); break;
+ case IDM_COPY_TO: g_App.CopyTo(); break;
+ case IDM_MOVE_TO: g_App.MoveTo(); break;
+ case IDM_DELETE: g_App.Delete(!IsKeyDown(VK_SHIFT)); break;
+
+ case IDM_HASH_ALL: g_App.CalculateCrc("*"); break;
+ case IDM_CRC32: g_App.CalculateCrc("CRC32"); break;
+ case IDM_CRC64: g_App.CalculateCrc("CRC64"); break;
+ case IDM_SHA1: g_App.CalculateCrc("SHA1"); break;
+ case IDM_SHA256: g_App.CalculateCrc("SHA256"); break;
+
+ case IDM_DIFF: g_App.DiffFiles(); break;
+
+ case IDM_VER_EDIT:
+ case IDM_VER_COMMIT:
+ case IDM_VER_REVERT:
+ case IDM_VER_DIFF:
+ g_App.VerCtrl(id); break;
+
+ case IDM_SPLIT: g_App.Split(); break;
+ case IDM_COMBINE: g_App.Combine(); break;
+ case IDM_PROPERTIES: g_App.Properties(); break;
+ case IDM_COMMENT: g_App.Comment(); break;
+ case IDM_CREATE_FOLDER: g_App.CreateFolder(); break;
+ case IDM_CREATE_FILE: g_App.CreateFile(); break;
+ #ifndef UNDER_CE
+ case IDM_LINK: g_App.Link(); break;
+ case IDM_ALT_STREAMS: g_App.OpenAltStreams(); break;
+ #endif
+ default: return false;
+ }
+ return true;
+}
+
+static void MyBenchmark(bool totalMode)
+{
+ CPanel::CDisableTimerProcessing disableTimerProcessing1(g_App.Panels[0]);
+ CPanel::CDisableTimerProcessing disableTimerProcessing2(g_App.Panels[1]);
+ Benchmark(totalMode);
+}
+
+bool OnMenuCommand(HWND hWnd, unsigned id)
+{
+ if (ExecuteFileCommand(id))
+ return true;
+
+ switch (id)
+ {
+ // File
+ case IDCLOSE:
+ SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
+ g_ExitEventLauncher.Exit(false);
+ SendMessage(hWnd, WM_CLOSE, 0, 0);
+ break;
+
+ // Edit
+ /*
+ case IDM_EDIT_CUT:
+ g_App.EditCut();
+ break;
+ case IDM_EDIT_COPY:
+ g_App.EditCopy();
+ break;
+ case IDM_EDIT_PASTE:
+ g_App.EditPaste();
+ break;
+ */
+ case IDM_SELECT_ALL:
+ g_App.SelectAll(true);
+ g_App.Refresh_StatusBar();
+ break;
+ case IDM_DESELECT_ALL:
+ g_App.SelectAll(false);
+ g_App.Refresh_StatusBar();
+ break;
+ case IDM_INVERT_SELECTION:
+ g_App.InvertSelection();
+ g_App.Refresh_StatusBar();
+ break;
+ case IDM_SELECT:
+ g_App.SelectSpec(true);
+ g_App.Refresh_StatusBar();
+ break;
+ case IDM_DESELECT:
+ g_App.SelectSpec(false);
+ g_App.Refresh_StatusBar();
+ break;
+ case IDM_SELECT_BY_TYPE:
+ g_App.SelectByType(true);
+ g_App.Refresh_StatusBar();
+ break;
+ case IDM_DESELECT_BY_TYPE:
+ g_App.SelectByType(false);
+ g_App.Refresh_StatusBar();
+ break;
+
+ //View
+ case IDM_VIEW_LARGE_ICONS:
+ case IDM_VIEW_SMALL_ICONS:
+ case IDM_VIEW_LIST:
+ case IDM_VIEW_DETAILS:
+ {
+ UINT index = id - IDM_VIEW_LARGE_ICONS;
+ if (index < 4)
+ {
+ g_App.SetListViewMode(index);
+ /*
+ CMenu menu;
+ menu.Attach(::GetSubMenu(::GetMenu(hWnd), k_MenuIndex_View));
+ menu.CheckRadioItem(IDM_VIEW_LARGE_ICONS, IDM_VIEW_DETAILS,
+ id, MF_BYCOMMAND);
+ */
+ }
+ break;
+ }
+ case IDM_VIEW_ARANGE_BY_NAME: g_App.SortItemsWithPropID(kpidName); break;
+ case IDM_VIEW_ARANGE_BY_TYPE: g_App.SortItemsWithPropID(kpidExtension); break;
+ case IDM_VIEW_ARANGE_BY_DATE: g_App.SortItemsWithPropID(kpidMTime); break;
+ case IDM_VIEW_ARANGE_BY_SIZE: g_App.SortItemsWithPropID(kpidSize); break;
+ case IDM_VIEW_ARANGE_NO_SORT: g_App.SortItemsWithPropID(kpidNoProperty); break;
+
+ case IDM_OPEN_ROOT_FOLDER: g_App.OpenRootFolder(); break;
+ case IDM_OPEN_PARENT_FOLDER: g_App.OpenParentFolder(); break;
+ case IDM_FOLDERS_HISTORY: g_App.FoldersHistory(); break;
+ case IDM_VIEW_FLAT_VIEW: g_App.ChangeFlatMode(); break;
+ case IDM_VIEW_REFRESH: g_App.RefreshView(); break;
+ case IDM_VIEW_AUTO_REFRESH: g_App.Change_AutoRefresh_Mode(); break;
+
+ // case IDM_VIEW_SHOW_STREAMS: g_App.Change_ShowNtfsStrems_Mode(); break;
+ /*
+ case IDM_VIEW_SHOW_DELETED:
+ {
+ g_App.Change_ShowDeleted();
+ bool isChecked = g_App.ShowDeletedFiles;
+ Save_ShowDeleted(isChecked);
+ }
+ */
+
+ case IDM_VIEW_TWO_PANELS: g_App.SwitchOnOffOnePanel(); break;
+ case IDM_VIEW_STANDARD_TOOLBAR: g_App.SwitchStandardToolbar(); break;
+ case IDM_VIEW_ARCHIVE_TOOLBAR: g_App.SwitchArchiveToolbar(); break;
+
+ case IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT: g_App.SwitchButtonsLables(); break;
+ case IDM_VIEW_TOOLBARS_LARGE_BUTTONS: g_App.SwitchLargeButtons(); break;
+
+ // Tools
+ case IDM_OPTIONS: OptionsDialog(hWnd, g_hInstance); break;
+
+ case IDM_BENCHMARK: MyBenchmark(false); break;
+ case IDM_BENCHMARK2: MyBenchmark(true); break;
+
+ // Help
+ case IDM_HELP_CONTENTS:
+ ShowHelpWindow(kFMHelpTopic);
+ break;
+ case IDM_ABOUT:
+ {
+ CAboutDialog dialog;
+ dialog.Create(hWnd);
+ break;
+ }
+ default:
+ {
+ if (id >= k_MenuID_OpenBookmark && id <= k_MenuID_OpenBookmark + 9)
+ {
+ g_App.OpenBookmark(id - k_MenuID_OpenBookmark);
+ return true;
+ }
+ else if (id >= k_MenuID_SetBookmark && id <= k_MenuID_SetBookmark + 9)
+ {
+ g_App.SetBookmark(id - k_MenuID_SetBookmark);
+ return true;
+ }
+ else if (id >= k_MenuID_Time && (unsigned)id < k_MenuID_Time + g_App._timestampLevels.Size())
+ {
+ g_App.SetTimestampLevel(g_App._timestampLevels[id - k_MenuID_Time]);
+ return true;
+ }
+ return false;
+ }
+ }
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/MyLoadMenu.h b/CPP/7zip/UI/FileManager/MyLoadMenu.h
new file mode 100644
index 0000000..e71dbbf
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/MyLoadMenu.h
@@ -0,0 +1,40 @@
+// MyLoadMenu.h
+
+#ifndef ZIP7_INC_MY_LOAD_MENU_H
+#define ZIP7_INC_MY_LOAD_MENU_H
+
+void OnMenuActivating(HWND hWnd, HMENU hMenu, int position);
+// void OnMenuUnActivating(HWND hWnd, HMENU hMenu, int id);
+// void OnMenuUnActivating(HWND hWnd);
+
+bool OnMenuCommand(HWND hWnd, unsigned id);
+void MyLoadMenu(bool needResetMenu);
+
+struct CFileMenu
+{
+ bool programMenu;
+ bool readOnly;
+ bool isHashFolder;
+ bool isFsFolder;
+ bool allAreFiles;
+ bool isAltStreamsSupported;
+ unsigned numItems;
+
+ FString FilePath;
+
+ CFileMenu():
+ programMenu(false),
+ readOnly(false),
+ isHashFolder(false),
+ isFsFolder(false),
+ allAreFiles(false),
+ isAltStreamsSupported(true),
+ numItems(0)
+ {}
+
+ void Load(HMENU hMenu, unsigned startPos);
+};
+
+bool ExecuteFileCommand(unsigned id);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/MyWindowsNew.h b/CPP/7zip/UI/FileManager/MyWindowsNew.h
index c0fe843..325babc 100644
--- a/CPP/7zip/UI/FileManager/MyWindowsNew.h
+++ b/CPP/7zip/UI/FileManager/MyWindowsNew.h
@@ -1,76 +1,119 @@
-// MyWindowsNew.h
-
-#ifndef __MY_WINDOWS_NEW_H
-#define __MY_WINDOWS_NEW_H
-
-#ifdef _MSC_VER
-
-#include <ShObjIdl.h>
-
-#ifndef __ITaskbarList3_INTERFACE_DEFINED__
-#define __ITaskbarList3_INTERFACE_DEFINED__
-
-typedef enum THUMBBUTTONFLAGS
-{
- THBF_ENABLED = 0,
- THBF_DISABLED = 0x1,
- THBF_DISMISSONCLICK = 0x2,
- THBF_NOBACKGROUND = 0x4,
- THBF_HIDDEN = 0x8,
- THBF_NONINTERACTIVE = 0x10
-} THUMBBUTTONFLAGS;
-
-typedef enum THUMBBUTTONMASK
-{
- THB_BITMAP = 0x1,
- THB_ICON = 0x2,
- THB_TOOLTIP = 0x4,
- THB_FLAGS = 0x8
-} THUMBBUTTONMASK;
-
-// #include <pshpack8.h>
-
-typedef struct THUMBBUTTON
-{
- THUMBBUTTONMASK dwMask;
- UINT iId;
- UINT iBitmap;
- HICON hIcon;
- WCHAR szTip[260];
- THUMBBUTTONFLAGS dwFlags;
-} THUMBBUTTON;
-
-typedef struct THUMBBUTTON *LPTHUMBBUTTON;
-
-typedef enum TBPFLAG
-{
- TBPF_NOPROGRESS = 0,
- TBPF_INDETERMINATE = 0x1,
- TBPF_NORMAL = 0x2,
- TBPF_ERROR = 0x4,
- TBPF_PAUSED = 0x8
-} TBPFLAG;
-
-DEFINE_GUID(IID_ITaskbarList3, 0xEA1AFB91, 0x9E28, 0x4B86, 0x90, 0xE9, 0x9E, 0x9F, 0x8A, 0x5E, 0xEF, 0xAF);
-
-struct ITaskbarList3: public ITaskbarList2
-{
- STDMETHOD(SetProgressValue)(HWND hwnd, ULONGLONG ullCompleted, ULONGLONG ullTotal) = 0;
- STDMETHOD(SetProgressState)(HWND hwnd, TBPFLAG tbpFlags) = 0;
- STDMETHOD(RegisterTab)(HWND hwndTab, HWND hwndMDI) = 0;
- STDMETHOD(UnregisterTab)(HWND hwndTab) = 0;
- STDMETHOD(SetTabOrder)(HWND hwndTab, HWND hwndInsertBefore) = 0;
- STDMETHOD(SetTabActive)(HWND hwndTab, HWND hwndMDI, DWORD dwReserved) = 0;
- STDMETHOD(ThumbBarAddButtons)(HWND hwnd, UINT cButtons, LPTHUMBBUTTON pButton) = 0;
- STDMETHOD(ThumbBarUpdateButtons)(HWND hwnd, UINT cButtons, LPTHUMBBUTTON pButton) = 0;
- STDMETHOD(ThumbBarSetImageList)(HWND hwnd, HIMAGELIST himl) = 0;
- STDMETHOD(SetOverlayIcon)(HWND hwnd, HICON hIcon, LPCWSTR pszDescription) = 0;
- STDMETHOD(SetThumbnailTooltip)(HWND hwnd, LPCWSTR pszTip) = 0;
- STDMETHOD(SetThumbnailClip)(HWND hwnd, RECT *prcClip) = 0;
-};
-
-#endif
-
-#endif
-
-#endif
+// MyWindowsNew.h
+
+#ifndef ZIP7_INC_MY_WINDOWS_NEW_H
+#define ZIP7_INC_MY_WINDOWS_NEW_H
+
+#if defined(__MINGW32__) || defined(__MINGW64__) || defined(__MINGW32_VERSION)
+#include <shobjidl.h>
+
+#if defined(__MINGW32_VERSION) && !defined(__ITaskbarList3_INTERFACE_DEFINED__)
+// for old mingw
+extern "C" {
+DEFINE_GUID(IID_ITaskbarList3, 0xEA1AFB91, 0x9E28, 0x4B86, 0x90, 0xE9, 0x9E, 0x9F, 0x8A, 0x5E, 0xEF, 0xAF);
+DEFINE_GUID(CLSID_TaskbarList, 0x56fdf344, 0xfd6d, 0x11d0, 0x95,0x8a, 0x00,0x60,0x97,0xc9,0xa0,0x90);
+}
+#endif
+
+#else // is not __MINGW*
+
+#ifndef Z7_OLD_WIN_SDK
+#include <ShObjIdl.h>
+#else
+
+#ifndef HIMAGELIST
+struct _IMAGELIST;
+typedef struct _IMAGELIST* HIMAGELIST;
+#endif
+
+#ifndef __ITaskbarList_INTERFACE_DEFINED__
+#define __ITaskbarList_INTERFACE_DEFINED__
+DEFINE_GUID(IID_ITaskbarList, 0x56FDF342, 0xFD6D, 0x11d0, 0x95, 0x8A, 0x00, 0x60, 0x97, 0xC9, 0xA0, 0x90);
+struct ITaskbarList: public IUnknown
+{
+ STDMETHOD(HrInit)(void) = 0;
+ STDMETHOD(AddTab)(HWND hwnd) = 0;
+ STDMETHOD(DeleteTab)(HWND hwnd) = 0;
+ STDMETHOD(ActivateTab)(HWND hwnd) = 0;
+ STDMETHOD(SetActiveAlt)(HWND hwnd) = 0;
+};
+#endif // __ITaskbarList_INTERFACE_DEFINED__
+
+#ifndef __ITaskbarList2_INTERFACE_DEFINED__
+#define __ITaskbarList2_INTERFACE_DEFINED__
+DEFINE_GUID(IID_ITaskbarList2, 0x602D4995, 0xB13A, 0x429b, 0xA6, 0x6E, 0x19, 0x35, 0xE4, 0x4F, 0x43, 0x17);
+struct ITaskbarList2: public ITaskbarList
+{
+ STDMETHOD(MarkFullscreenWindow)(HWND hwnd, BOOL fFullscreen) = 0;
+};
+#endif // __ITaskbarList2_INTERFACE_DEFINED__
+
+#endif // Z7_OLD_WIN_SDK
+
+
+#ifndef __ITaskbarList3_INTERFACE_DEFINED__
+#define __ITaskbarList3_INTERFACE_DEFINED__
+
+typedef enum THUMBBUTTONFLAGS
+{
+ THBF_ENABLED = 0,
+ THBF_DISABLED = 0x1,
+ THBF_DISMISSONCLICK = 0x2,
+ THBF_NOBACKGROUND = 0x4,
+ THBF_HIDDEN = 0x8,
+ THBF_NONINTERACTIVE = 0x10
+} THUMBBUTTONFLAGS;
+
+typedef enum THUMBBUTTONMASK
+{
+ THB_BITMAP = 0x1,
+ THB_ICON = 0x2,
+ THB_TOOLTIP = 0x4,
+ THB_FLAGS = 0x8
+} THUMBBUTTONMASK;
+
+// #include <pshpack8.h>
+
+typedef struct THUMBBUTTON
+{
+ THUMBBUTTONMASK dwMask;
+ UINT iId;
+ UINT iBitmap;
+ HICON hIcon;
+ WCHAR szTip[260];
+ THUMBBUTTONFLAGS dwFlags;
+} THUMBBUTTON;
+
+typedef struct THUMBBUTTON *LPTHUMBBUTTON;
+
+typedef enum TBPFLAG
+{
+ TBPF_NOPROGRESS = 0,
+ TBPF_INDETERMINATE = 0x1,
+ TBPF_NORMAL = 0x2,
+ TBPF_ERROR = 0x4,
+ TBPF_PAUSED = 0x8
+} TBPFLAG;
+
+DEFINE_GUID(IID_ITaskbarList3, 0xEA1AFB91, 0x9E28, 0x4B86, 0x90, 0xE9, 0x9E, 0x9F, 0x8A, 0x5E, 0xEF, 0xAF);
+
+struct ITaskbarList3: public ITaskbarList2
+{
+ STDMETHOD(SetProgressValue)(HWND hwnd, ULONGLONG ullCompleted, ULONGLONG ullTotal) = 0;
+ STDMETHOD(SetProgressState)(HWND hwnd, TBPFLAG tbpFlags) = 0;
+ STDMETHOD(RegisterTab)(HWND hwndTab, HWND hwndMDI) = 0;
+ STDMETHOD(UnregisterTab)(HWND hwndTab) = 0;
+ STDMETHOD(SetTabOrder)(HWND hwndTab, HWND hwndInsertBefore) = 0;
+ STDMETHOD(SetTabActive)(HWND hwndTab, HWND hwndMDI, DWORD dwReserved) = 0;
+ STDMETHOD(ThumbBarAddButtons)(HWND hwnd, UINT cButtons, LPTHUMBBUTTON pButton) = 0;
+ STDMETHOD(ThumbBarUpdateButtons)(HWND hwnd, UINT cButtons, LPTHUMBBUTTON pButton) = 0;
+ STDMETHOD(ThumbBarSetImageList)(HWND hwnd, HIMAGELIST himl) = 0;
+ STDMETHOD(SetOverlayIcon)(HWND hwnd, HICON hIcon, LPCWSTR pszDescription) = 0;
+ STDMETHOD(SetThumbnailTooltip)(HWND hwnd, LPCWSTR pszTip) = 0;
+ STDMETHOD(SetThumbnailClip)(HWND hwnd, RECT *prcClip) = 0;
+};
+
+#endif // __ITaskbarList3_INTERFACE_DEFINED__
+
+#endif // __MINGW*
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/NetFolder.cpp b/CPP/7zip/UI/FileManager/NetFolder.cpp
new file mode 100644
index 0000000..879f1db
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/NetFolder.cpp
@@ -0,0 +1,281 @@
+// NetFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "FSFolder.h"
+#include "NetFolder.h"
+#include "SysIconUtils.h"
+
+using namespace NWindows;
+using namespace NNet;
+
+static const Byte kProps[] =
+{
+ kpidName,
+ kpidLocalName,
+ kpidComment,
+ kpidProvider
+};
+
+void CNetFolder::Init(const UString &path)
+{
+ /*
+ if (path.Len() > 2)
+ {
+ if (path[0] == L'\\' && path[1] == L'\\')
+ {
+ CResource netResource;
+ netResource.RemoteName = GetSystemString(path.Left(path.Len() - 1));
+ netResource.Scope = RESOURCE_GLOBALNET;
+ netResource.Type = RESOURCETYPE_DISK;
+ netResource.DisplayType = RESOURCEDISPLAYTYPE_SERVER;
+ netResource.Usage = RESOURCEUSAGE_CONTAINER;
+ Init(&netResource, 0, path);
+ return;
+ }
+ }
+ Init(0, 0 , L"");
+ */
+ CResourceW resource;
+ resource.RemoteNameIsDefined = true;
+ if (!path.IsEmpty())
+ resource.RemoteName.SetFrom(path, path.Len() - 1);
+ resource.ProviderIsDefined = false;
+ resource.LocalNameIsDefined = false;
+ resource.CommentIsDefined = false;
+ resource.Type = RESOURCETYPE_DISK;
+ resource.Scope = RESOURCE_GLOBALNET;
+ resource.Usage = 0;
+ resource.DisplayType = 0;
+ CResourceW destResource;
+ UString systemPathPart;
+ DWORD result = GetResourceInformation(resource, destResource, systemPathPart);
+ if (result == NO_ERROR)
+ Init(&destResource, NULL, path);
+ else
+ Init(NULL, NULL , L"");
+ return;
+}
+
+void CNetFolder::Init(const NWindows::NNet::CResourceW *netResource,
+ IFolderFolder *parentFolder, const UString &path)
+{
+ _path = path;
+ if (!netResource)
+ _netResourcePointer = NULL;
+ else
+ {
+ _netResource = *netResource;
+ _netResourcePointer = &_netResource;
+
+ // if (_netResource.DisplayType == RESOURCEDISPLAYTYPE_SERVER)
+ _path = _netResource.RemoteName;
+
+ /* WinXP-64: When we move UP from Network share without _parentFolder chain,
+ we can get empty _netResource.RemoteName. Do we need to use Provider there ? */
+ if (_path.IsEmpty())
+ _path = _netResource.Provider;
+
+ if (!_path.IsEmpty())
+ _path.Add_PathSepar();
+ }
+ _parentFolder = parentFolder;
+}
+
+Z7_COM7F_IMF(CNetFolder::LoadItems())
+{
+ _items.Clear();
+ CEnum enumerator;
+
+ for (;;)
+ {
+ DWORD result = enumerator.Open(
+ RESOURCE_GLOBALNET,
+ RESOURCETYPE_DISK,
+ 0, // enumerate all resources
+ _netResourcePointer
+ );
+ if (result == NO_ERROR)
+ break;
+ if (result != ERROR_ACCESS_DENIED)
+ return HRESULT_FROM_WIN32(result);
+ if (_netResourcePointer)
+ result = AddConnection2(_netResource,
+ NULL, NULL, CONNECT_INTERACTIVE);
+ if (result != NO_ERROR)
+ return HRESULT_FROM_WIN32(result);
+ }
+
+ for (;;)
+ {
+ CResourceEx resource;
+ const DWORD result = enumerator.Next(resource);
+ if (result == NO_ERROR)
+ {
+ if (!resource.RemoteNameIsDefined) // For Win 98, I don't know what's wrong
+ resource.RemoteName = resource.Comment;
+ resource.Name = resource.RemoteName;
+ const int pos = resource.Name.ReverseFind_PathSepar();
+ if (pos >= 0)
+ {
+ // _path = resource.Name.Left(pos + 1);
+ resource.Name.DeleteFrontal((unsigned)pos + 1);
+ }
+ _items.Add(resource);
+ }
+ else if (result == ERROR_NO_MORE_ITEMS)
+ break;
+ else
+ return HRESULT_FROM_WIN32(result);
+ }
+
+ /*
+ It's too slow for some systems.
+ if (_netResourcePointer && _netResource.DisplayType == RESOURCEDISPLAYTYPE_SERVER)
+ {
+ for (char c = 'a'; c <= 'z'; c++)
+ {
+ CResourceEx resource;
+ resource.Name = UString(wchar_t(c)) + L'$';
+ resource.RemoteNameIsDefined = true;
+ resource.RemoteName = _path + resource.Name;
+
+ NFile::NFind::CFindFile findFile;
+ NFile::NFind::CFileInfo fileInfo;
+ if (!findFile.FindFirst(us2fs(resource.RemoteName) + FString(FCHAR_PATH_SEPARATOR) + FCHAR_ANY_MASK, fileInfo))
+ continue;
+ resource.Usage = RESOURCEUSAGE_CONNECTABLE;
+ resource.LocalNameIsDefined = false;
+ resource.CommentIsDefined = false;
+ resource.ProviderIsDefined = false;
+ _items.Add(resource);
+ }
+ }
+ */
+ return S_OK;
+}
+
+
+Z7_COM7F_IMF(CNetFolder::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = _items.Size();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CNetFolder::GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ const CResourceEx &item = _items[itemIndex];
+ switch (propID)
+ {
+ case kpidIsDir: prop = true; break;
+ case kpidName:
+ // if (item.RemoteNameIsDefined)
+ prop = item.Name;
+ break;
+ case kpidLocalName: if (item.LocalNameIsDefined) prop = item.LocalName; break;
+ case kpidComment: if (item.CommentIsDefined) prop = item.Comment; break;
+ case kpidProvider: if (item.ProviderIsDefined) prop = item.Provider; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CNetFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ const CResourceEx &resource = _items[index];
+ if (resource.Usage == RESOURCEUSAGE_CONNECTABLE ||
+ resource.DisplayType == RESOURCEDISPLAYTYPE_SHARE)
+ {
+ NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+ CMyComPtr<IFolderFolder> subFolder = fsFolderSpec;
+ RINOK(fsFolderSpec->Init(us2fs(resource.RemoteName + WCHAR_PATH_SEPARATOR))) // , this
+ *resultFolder = subFolder.Detach();
+ }
+ else
+ {
+ CNetFolder *netFolder = new CNetFolder;
+ CMyComPtr<IFolderFolder> subFolder = netFolder;
+ netFolder->Init(&resource, this, resource.Name + WCHAR_PATH_SEPARATOR);
+ *resultFolder = subFolder.Detach();
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CNetFolder::BindToFolder(const wchar_t * /* name */, IFolderFolder ** /* resultFolder */))
+{
+ return E_NOTIMPL;
+}
+
+Z7_COM7F_IMF(CNetFolder::BindToParentFolder(IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ if (_parentFolder)
+ {
+ CMyComPtr<IFolderFolder> parentFolder = _parentFolder;
+ *resultFolder = parentFolder.Detach();
+ return S_OK;
+ }
+ if (_netResourcePointer)
+ {
+ CResourceW resourceParent;
+ const DWORD result = GetResourceParent(_netResource, resourceParent);
+ if (result != NO_ERROR)
+ return HRESULT_FROM_WIN32(result);
+ if (!_netResource.RemoteNameIsDefined)
+ return S_OK;
+
+ CNetFolder *netFolder = new CNetFolder;
+ CMyComPtr<IFolderFolder> subFolder = netFolder;
+ netFolder->Init(&resourceParent, NULL, WSTRING_PATH_SEPARATOR);
+ *resultFolder = subFolder.Detach();
+ }
+ return S_OK;
+}
+
+IMP_IFolderFolder_Props(CNetFolder)
+
+Z7_COM7F_IMF(CNetFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value))
+{
+ NWindows::NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidType: prop = "NetFolder"; break;
+ case kpidPath: prop = _path; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CNetFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex))
+{
+ if (index >= (UInt32)_items.Size())
+ return E_INVALIDARG;
+ *iconIndex = 0;
+ const CResourceW &resource = _items[index];
+ int iconIndexTemp;
+ if (resource.DisplayType == RESOURCEDISPLAYTYPE_SERVER ||
+ resource.Usage == RESOURCEUSAGE_CONNECTABLE)
+ {
+ if (GetRealIconIndex(us2fs(resource.RemoteName), 0, iconIndexTemp))
+ {
+ *iconIndex = iconIndexTemp;
+ return S_OK;
+ }
+ }
+ else
+ {
+ if (GetRealIconIndex(FTEXT(""), FILE_ATTRIBUTE_DIRECTORY, iconIndexTemp))
+ {
+ *iconIndex = iconIndexTemp;
+ return S_OK;
+ }
+ // *anIconIndex = GetRealIconIndex(0, L"\\\\HOME");
+ }
+ return GetLastError_noZero_HRESULT();
+}
diff --git a/CPP/7zip/UI/FileManager/NetFolder.h b/CPP/7zip/UI/FileManager/NetFolder.h
new file mode 100644
index 0000000..352f5bd
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/NetFolder.h
@@ -0,0 +1,36 @@
+// NetFolder.h
+
+#ifndef ZIP7_INC_NET_FOLDER_H
+#define ZIP7_INC_NET_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/Net.h"
+
+#include "IFolder.h"
+
+struct CResourceEx: public NWindows::NNet::CResourceW
+{
+ UString Name;
+};
+
+Z7_CLASS_IMP_NOQIB_2(
+ CNetFolder
+ , IFolderFolder
+ , IFolderGetSystemIconIndex
+)
+ NWindows::NNet::CResourceW _netResource;
+ NWindows::NNet::CResourceW *_netResourcePointer;
+
+ CObjectVector<CResourceEx> _items;
+
+ CMyComPtr<IFolderFolder> _parentFolder;
+ UString _path;
+public:
+ CNetFolder(): _netResourcePointer(NULL) {}
+ void Init(const UString &path);
+ void Init(const NWindows::NNet::CResourceW *netResource,
+ IFolderFolder *parentFolder, const UString &path);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/OpenCallback.cpp b/CPP/7zip/UI/FileManager/OpenCallback.cpp
new file mode 100644
index 0000000..5b6df50
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OpenCallback.cpp
@@ -0,0 +1,86 @@
+// OpenCallback.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../Common/FileStreams.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "OpenCallback.h"
+#include "PasswordDialog.h"
+
+using namespace NWindows;
+
+HRESULT COpenArchiveCallback::Open_SetTotal(const UInt64 *numFiles, const UInt64 *numBytes)
+// Z7_COM7F_IMF(COpenArchiveCallback::SetTotal(const UInt64 *numFiles, const UInt64 *numBytes))
+{
+ // COM_TRY_BEGIN
+ RINOK(ProgressDialog.Sync.CheckStop())
+ {
+ // NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ ProgressDialog.Sync.Set_NumFilesTotal(numFiles ? *numFiles : (UInt64)(Int64)-1);
+ // if (numFiles)
+ {
+ ProgressDialog.Sync.Set_BytesProgressMode(numFiles == NULL);
+ }
+ if (numBytes)
+ ProgressDialog.Sync.Set_NumBytesTotal(*numBytes);
+ }
+ return S_OK;
+ // COM_TRY_END
+}
+
+HRESULT COpenArchiveCallback::Open_SetCompleted(const UInt64 *numFiles, const UInt64 *numBytes)
+// Z7_COM7F_IMF(COpenArchiveCallback::SetCompleted(const UInt64 *numFiles, const UInt64 *numBytes))
+{
+ // COM_TRY_BEGIN
+ // NSynchronization::CCriticalSectionLock lock(_criticalSection);
+ if (numFiles)
+ ProgressDialog.Sync.Set_NumFilesCur(*numFiles);
+ if (numBytes)
+ ProgressDialog.Sync.Set_NumBytesCur(*numBytes);
+ return ProgressDialog.Sync.CheckStop();
+ // COM_TRY_END
+}
+
+HRESULT COpenArchiveCallback::Open_CheckBreak()
+{
+ return ProgressDialog.Sync.CheckStop();
+}
+
+HRESULT COpenArchiveCallback::Open_Finished()
+{
+ return ProgressDialog.Sync.CheckStop();
+}
+
+#ifndef Z7_NO_CRYPTO
+HRESULT COpenArchiveCallback::Open_CryptoGetTextPassword(BSTR *password)
+// Z7_COM7F_IMF(COpenArchiveCallback::CryptoGetTextPassword(BSTR *password))
+{
+ // COM_TRY_BEGIN
+ PasswordWasAsked = true;
+ if (!PasswordIsDefined)
+ {
+ CPasswordDialog dialog;
+ bool showPassword = NExtract::Read_ShowPassword();
+ dialog.ShowPassword = showPassword;
+
+ ProgressDialog.WaitCreating();
+ if (dialog.Create(ProgressDialog) != IDOK)
+ return E_ABORT;
+
+ Password = dialog.Password;
+ PasswordIsDefined = true;
+ if (dialog.ShowPassword != showPassword)
+ NExtract::Save_ShowPassword(dialog.ShowPassword);
+ }
+ return StringToBstr(Password, password);
+ // COM_TRY_END
+}
+#endif
diff --git a/CPP/7zip/UI/FileManager/OpenCallback.h b/CPP/7zip/UI/FileManager/OpenCallback.h
new file mode 100644
index 0000000..8f4638c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OpenCallback.h
@@ -0,0 +1,69 @@
+// OpenCallback.h
+
+#ifndef ZIP7_INC_OPEN_CALLBACK_H
+#define ZIP7_INC_OPEN_CALLBACK_H
+
+#include "../Common/ArchiveOpenCallback.h"
+
+#ifdef Z7_SFX
+#include "ProgressDialog.h"
+#else
+#include "ProgressDialog2.h"
+#endif
+
+/* we can use IArchiveOpenCallback or IOpenCallbackUI here */
+
+class COpenArchiveCallback Z7_final:
+ /*
+ public IArchiveOpenCallback,
+ public IProgress,
+ public ICryptoGetTextPassword,
+ public CMyUnknownImp
+ */
+ public IOpenCallbackUI
+{
+ // NWindows::NSynchronization::CCriticalSection _criticalSection;
+public:
+ bool PasswordIsDefined;
+ bool PasswordWasAsked;
+ UString Password;
+ HWND ParentWindow;
+ CProgressDialog ProgressDialog;
+
+ /*
+ Z7_COM_UNKNOWN_IMP_3(
+ IArchiveOpenVolumeCallback,
+ IProgress
+ ICryptoGetTextPassword
+ )
+
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IArchiveOpenCallback)
+ // ICryptoGetTextPassword
+ Z7_COM7F_IMP(CryptoGetTextPassword(BSTR *password))
+ */
+
+ Z7_IFACE_IMP(IOpenCallbackUI)
+
+ COpenArchiveCallback():
+ ParentWindow(NULL)
+ {
+ // _subArchiveMode = false;
+ PasswordIsDefined = false;
+ PasswordWasAsked = false;
+ }
+ /*
+ void Init()
+ {
+ PasswordIsDefined = false;
+ _subArchiveMode = false;
+ }
+ */
+
+ INT_PTR StartProgressDialog(const UString &title, NWindows::CThread &thread)
+ {
+ return ProgressDialog.Create(title, thread, ParentWindow);
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/OptionsDialog.cpp b/CPP/7zip/UI/FileManager/OptionsDialog.cpp
new file mode 100644
index 0000000..b71c323
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/OptionsDialog.cpp
@@ -0,0 +1,89 @@
+// OptionsDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/PropertyPage.h"
+
+#include "DialogSize.h"
+
+#include "EditPage.h"
+#include "EditPageRes.h"
+#include "FoldersPage.h"
+#include "FoldersPageRes.h"
+#include "LangPage.h"
+#include "LangPageRes.h"
+#include "MenuPage.h"
+#include "MenuPageRes.h"
+#include "SettingsPage.h"
+#include "SettingsPageRes.h"
+#include "SystemPage.h"
+#include "SystemPageRes.h"
+
+#include "App.h"
+#include "LangUtils.h"
+#include "MyLoadMenu.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+
+void OptionsDialog(HWND hwndOwner, HINSTANCE hInstance);
+void OptionsDialog(HWND hwndOwner, HINSTANCE /* hInstance */)
+{
+ CSystemPage systemPage;
+ CMenuPage menuPage;
+ CFoldersPage foldersPage;
+ CEditPage editPage;
+ CSettingsPage settingsPage;
+ CLangPage langPage;
+
+ CObjectVector<NControl::CPageInfo> pages;
+ BIG_DIALOG_SIZE(200, 200);
+
+ const UINT pageIDs[] = {
+ SIZED_DIALOG(IDD_SYSTEM),
+ SIZED_DIALOG(IDD_MENU),
+ SIZED_DIALOG(IDD_FOLDERS),
+ SIZED_DIALOG(IDD_EDIT),
+ SIZED_DIALOG(IDD_SETTINGS),
+ SIZED_DIALOG(IDD_LANG) };
+
+ NControl::CPropertyPage *pagePointers[] = { &systemPage, &menuPage, &foldersPage, &editPage, &settingsPage, &langPage };
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(pageIDs); i++)
+ {
+ NControl::CPageInfo &page = pages.AddNew();
+ page.ID = pageIDs[i];
+ #ifdef Z7_LANG
+ LangString_OnlyFromLangFile(page.ID, page.Title);
+ #endif
+ page.Page = pagePointers[i];
+ }
+
+ const INT_PTR res = NControl::MyPropertySheet(pages, hwndOwner, LangString(IDS_OPTIONS));
+
+ if (res != -1 && res != 0)
+ {
+ if (langPage.LangWasChanged)
+ {
+ // g_App._window.SetText(LangString(IDS_APP_TITLE, 0x03000000));
+ MyLoadMenu(true); // needResetMenu
+ g_App.ReloadToolbars();
+ g_App.MoveSubWindows(); // we need it to change list window aafter _toolBar.AutoSize();
+ g_App.ReloadLangItems();
+ }
+
+ /*
+ if (systemPage.WasChanged)
+ {
+ // probably it doesn't work, since image list is locked?
+ g_App.SysIconsWereChanged();
+ }
+ */
+
+ g_App.SetListSettings();
+ g_App.RefreshAllPanels();
+ // ::PostMessage(hwndOwner, kLangWasChangedMessage, 0 , 0);
+ }
+}
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialog.cpp b/CPP/7zip/UI/FileManager/OverwriteDialog.cpp
index 3f0180d..096527c 100644
--- a/CPP/7zip/UI/FileManager/OverwriteDialog.cpp
+++ b/CPP/7zip/UI/FileManager/OverwriteDialog.cpp
@@ -1,122 +1,138 @@
-// OverwriteDialog.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/PropVariantConv.h"
-#include "../../../Windows/ResourceString.h"
-
-#include "../../../Windows/Control/Static.h"
-
-#include "FormatUtils.h"
-#include "LangUtils.h"
-#include "OverwriteDialog.h"
-
-#include "PropertyNameRes.h"
-
-using namespace NWindows;
-
-#ifdef LANG
-static const UInt32 kLangIDs[] =
-{
- IDT_OVERWRITE_HEADER,
- IDT_OVERWRITE_QUESTION_BEGIN,
- IDT_OVERWRITE_QUESTION_END,
- IDB_YES_TO_ALL,
- IDB_NO_TO_ALL,
- IDB_AUTO_RENAME
-};
-#endif
-
-static const unsigned kCurrentFileNameSizeLimit = 82;
-static const unsigned kCurrentFileNameSizeLimit2 = 30;
-
-void COverwriteDialog::ReduceString(UString &s)
-{
- unsigned size = _isBig ? kCurrentFileNameSizeLimit : kCurrentFileNameSizeLimit2;
- if (s.Len() > size)
- {
- s.Delete(size / 2, s.Len() - size);
- s.Insert(size / 2, L" ... ");
- }
- if (!s.IsEmpty() && s.Back() == ' ')
- {
- // s += (wchar_t)(0x2423);
- s.InsertAtFront(L'\"');
- s += L'\"';
- }
-}
-
-void COverwriteDialog::SetFileInfoControl(int textID, int iconID,
- const NOverwriteDialog::CFileInfo &fileInfo)
-{
- UString sizeString;
- if (fileInfo.SizeIsDefined)
- sizeString = MyFormatNew(IDS_FILE_SIZE, NumberToString(fileInfo.Size));
-
- const UString &fileName = fileInfo.Name;
- int slashPos = fileName.ReverseFind_PathSepar();
- UString s1 = fileName.Left(slashPos + 1);
- UString s2 = fileName.Ptr(slashPos + 1);
-
- ReduceString(s1);
- ReduceString(s2);
-
- UString s = s1;
- s.Add_LF();
- s += s2;
- s.Add_LF();
- s += sizeString;
- s.Add_LF();
-
- if (fileInfo.TimeIsDefined)
- {
- AddLangString(s, IDS_PROP_MTIME);
- s += ": ";
- char t[32];
- ConvertUtcFileTimeToString(fileInfo.Time, t);
- s += t;
- }
-
- NControl::CDialogChildControl control;
- control.Init(*this, textID);
- control.SetText(s);
-
- SHFILEINFO shellFileInfo;
- if (::SHGetFileInfo(
- GetSystemString(fileInfo.Name), FILE_ATTRIBUTE_NORMAL, &shellFileInfo,
- sizeof(shellFileInfo), SHGFI_ICON | SHGFI_USEFILEATTRIBUTES | SHGFI_LARGEICON))
- {
- NControl::CStatic staticContol;
- staticContol.Attach(GetItem(iconID));
- staticContol.SetIcon(shellFileInfo.hIcon);
- }
-}
-
-bool COverwriteDialog::OnInit()
-{
- #ifdef LANG
- LangSetWindowText(*this, IDD_OVERWRITE);
- LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
- #endif
- SetFileInfoControl(IDT_OVERWRITE_OLD_FILE_SIZE_TIME, IDI_OVERWRITE_OLD_FILE, OldFileInfo);
- SetFileInfoControl(IDT_OVERWRITE_NEW_FILE_SIZE_TIME, IDI_OVERWRITE_NEW_FILE, NewFileInfo);
- NormalizePosition();
- return CModalDialog::OnInit();
-}
-
-bool COverwriteDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- switch (buttonID)
- {
- case IDYES:
- case IDNO:
- case IDB_YES_TO_ALL:
- case IDB_NO_TO_ALL:
- case IDB_AUTO_RENAME:
- End(buttonID);
- return true;
- }
- return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
-}
+// OverwriteDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariantConv.h"
+#include "../../../Windows/ResourceString.h"
+
+#include "../../../Windows/Control/Static.h"
+
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "OverwriteDialog.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_OVERWRITE_HEADER,
+ IDT_OVERWRITE_QUESTION_BEGIN,
+ IDT_OVERWRITE_QUESTION_END,
+ IDB_YES_TO_ALL,
+ IDB_NO_TO_ALL,
+ IDB_AUTO_RENAME
+};
+#endif
+
+static const unsigned kCurrentFileNameSizeLimit = 82;
+static const unsigned kCurrentFileNameSizeLimit2 = 30;
+
+void COverwriteDialog::ReduceString(UString &s)
+{
+ unsigned size = _isBig ? kCurrentFileNameSizeLimit : kCurrentFileNameSizeLimit2;
+ if (s.Len() > size)
+ {
+ s.Delete(size / 2, s.Len() - size);
+ s.Insert(size / 2, L" ... ");
+ }
+ if (!s.IsEmpty() && s.Back() == ' ')
+ {
+ // s += (wchar_t)(0x2423);
+ s.InsertAtFront(L'\"');
+ s += L'\"';
+ }
+}
+
+void COverwriteDialog::SetFileInfoControl(unsigned textID, unsigned iconID,
+ const NOverwriteDialog::CFileInfo &fileInfo)
+{
+ UString sizeString;
+ if (fileInfo.SizeIsDefined)
+ sizeString = MyFormatNew(IDS_FILE_SIZE, NumberToString(fileInfo.Size));
+
+ const UString &fileName = fileInfo.Name;
+ int slashPos = fileName.ReverseFind_PathSepar();
+ UString s1 = fileName.Left((unsigned)(slashPos + 1));
+ UString s2 = fileName.Ptr((unsigned)(slashPos + 1));
+
+ ReduceString(s1);
+ ReduceString(s2);
+
+ UString s = s1;
+ s.Add_LF();
+ s += s2;
+ s.Add_LF();
+ s += sizeString;
+ s.Add_LF();
+
+ if (fileInfo.TimeIsDefined)
+ {
+ AddLangString(s, IDS_PROP_MTIME);
+ s += ": ";
+ char t[32];
+ ConvertUtcFileTimeToString(fileInfo.Time, t);
+ s += t;
+ }
+
+ NControl::CDialogChildControl control;
+ control.Init(*this, textID);
+ control.SetText(s);
+
+ SHFILEINFO shellFileInfo;
+ if (::SHGetFileInfo(
+ GetSystemString(fileInfo.Name), FILE_ATTRIBUTE_NORMAL, &shellFileInfo,
+ sizeof(shellFileInfo), SHGFI_ICON | SHGFI_USEFILEATTRIBUTES | SHGFI_LARGEICON))
+ {
+ NControl::CStatic staticContol;
+ staticContol.Attach(GetItem(iconID));
+ staticContol.SetIcon(shellFileInfo.hIcon);
+ }
+}
+
+bool COverwriteDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_OVERWRITE);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ #endif
+ SetFileInfoControl(IDT_OVERWRITE_OLD_FILE_SIZE_TIME, IDI_OVERWRITE_OLD_FILE, OldFileInfo);
+ SetFileInfoControl(IDT_OVERWRITE_NEW_FILE_SIZE_TIME, IDI_OVERWRITE_NEW_FILE, NewFileInfo);
+ NormalizePosition();
+
+ if (!ShowExtraButtons)
+ {
+ HideItem(IDB_YES_TO_ALL);
+ HideItem(IDB_NO_TO_ALL);
+ HideItem(IDB_AUTO_RENAME);
+ }
+
+ if (DefaultButton_is_NO)
+ {
+ PostMsg(DM_SETDEFID, IDNO);
+ HWND h = GetItem(IDNO);
+ PostMsg(WM_NEXTDLGCTL, (WPARAM)h, TRUE);
+ // ::SetFocus(h);
+ }
+
+ return CModalDialog::OnInit();
+}
+
+bool COverwriteDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDYES:
+ case IDNO:
+ case IDB_YES_TO_ALL:
+ case IDB_NO_TO_ALL:
+ case IDB_AUTO_RENAME:
+ End((INT_PTR)buttonID);
+ return true;
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialog.h b/CPP/7zip/UI/FileManager/OverwriteDialog.h
index 4564a47..a9ca991 100644
--- a/CPP/7zip/UI/FileManager/OverwriteDialog.h
+++ b/CPP/7zip/UI/FileManager/OverwriteDialog.h
@@ -1,69 +1,79 @@
-// OverwriteDialog.h
-
-#ifndef __OVERWRITE_DIALOG_H
-#define __OVERWRITE_DIALOG_H
-
-#include "../../../Windows/Control/Dialog.h"
-
-#include "DialogSize.h"
-#include "OverwriteDialogRes.h"
-
-namespace NOverwriteDialog
-{
- struct CFileInfo
- {
- bool SizeIsDefined;
- bool TimeIsDefined;
- UInt64 Size;
- FILETIME Time;
- UString Name;
-
- void SetTime(const FILETIME *t)
- {
- if (t == 0)
- TimeIsDefined = false;
- else
- {
- TimeIsDefined = true;
- Time = *t;
- }
- }
- void SetSize(const UInt64 *size)
- {
- if (size == 0)
- SizeIsDefined = false;
- else
- {
- SizeIsDefined = true;
- Size = *size;
- }
- }
- };
-}
-
-class COverwriteDialog: public NWindows::NControl::CModalDialog
-{
- bool _isBig;
-
- void SetFileInfoControl(int textID, int iconID, const NOverwriteDialog::CFileInfo &fileInfo);
- virtual bool OnInit();
- bool OnButtonClicked(int buttonID, HWND buttonHWND);
- void ReduceString(UString &s);
-
-public:
- INT_PTR Create(HWND parent = 0)
- {
- BIG_DIALOG_SIZE(280, 200);
- #ifdef UNDER_CE
- _isBig = isBig;
- #else
- _isBig = true;
- #endif
- return CModalDialog::Create(SIZED_DIALOG(IDD_OVERWRITE), parent);
- }
-
- NOverwriteDialog::CFileInfo OldFileInfo;
- NOverwriteDialog::CFileInfo NewFileInfo;
-};
-
-#endif
+// OverwriteDialog.h
+
+#ifndef ZIP7_INC_OVERWRITE_DIALOG_H
+#define ZIP7_INC_OVERWRITE_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+
+#include "DialogSize.h"
+#include "OverwriteDialogRes.h"
+
+namespace NOverwriteDialog
+{
+ struct CFileInfo
+ {
+ bool SizeIsDefined;
+ bool TimeIsDefined;
+ UInt64 Size;
+ FILETIME Time;
+ UString Name;
+
+ void SetTime(const FILETIME *t)
+ {
+ if (!t)
+ TimeIsDefined = false;
+ else
+ {
+ TimeIsDefined = true;
+ Time = *t;
+ }
+ }
+
+ void SetSize(UInt64 size)
+ {
+ SizeIsDefined = true;
+ Size = size;
+ }
+
+ void SetSize(const UInt64 *size)
+ {
+ if (!size)
+ SizeIsDefined = false;
+ else
+ SetSize(*size);
+ }
+ };
+}
+
+class COverwriteDialog: public NWindows::NControl::CModalDialog
+{
+ bool _isBig;
+
+ void SetFileInfoControl(unsigned textID, unsigned iconID, const NOverwriteDialog::CFileInfo &fileInfo);
+ virtual bool OnInit() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ void ReduceString(UString &s);
+
+public:
+ bool ShowExtraButtons;
+ bool DefaultButton_is_NO;
+
+
+ COverwriteDialog(): ShowExtraButtons(true), DefaultButton_is_NO(false) {}
+
+ INT_PTR Create(HWND parent = NULL)
+ {
+ BIG_DIALOG_SIZE(280, 200);
+ #ifdef UNDER_CE
+ _isBig = isBig;
+ #else
+ _isBig = true;
+ #endif
+ return CModalDialog::Create(SIZED_DIALOG(IDD_OVERWRITE), parent);
+ }
+
+ NOverwriteDialog::CFileInfo OldFileInfo;
+ NOverwriteDialog::CFileInfo NewFileInfo;
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialog.rc b/CPP/7zip/UI/FileManager/OverwriteDialog.rc
index 80f48b0..29f9912 100644
--- a/CPP/7zip/UI/FileManager/OverwriteDialog.rc
+++ b/CPP/7zip/UI/FileManager/OverwriteDialog.rc
@@ -1,91 +1,91 @@
-#include "OverwriteDialogRes.h"
-#include "../../GuiCommon.rc"
-
-#define xc 280
-#define yc 200
-
-#undef iconSize
-#define iconSize 24
-
-#undef x
-#undef fx
-#undef fy
-#define x (m + iconSize + m)
-#define fx (xc - iconSize - m)
-#define fy 50
-
-#define bSizeBig 104
-#undef bx1
-#define bx1 (xs - m - bSizeBig)
-
-IDD_OVERWRITE DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "Confirm File Replace"
-BEGIN
- LTEXT "Destination folder already contains processed file.", IDT_OVERWRITE_HEADER, m, 7, xc, 8
- LTEXT "Would you like to replace the existing file", IDT_OVERWRITE_QUESTION_BEGIN, m, 28, xc, 8
-
- ICON "", IDI_OVERWRITE_OLD_FILE, m, 44, iconSize, iconSize
- LTEXT "", IDT_OVERWRITE_OLD_FILE_SIZE_TIME, x, 44, fx, fy, SS_NOPREFIX
-
- LTEXT "with this one?", IDT_OVERWRITE_QUESTION_END, m, 98, xc, 8
-
- ICON "", IDI_OVERWRITE_NEW_FILE, m, 114, iconSize, iconSize
- LTEXT "", IDT_OVERWRITE_NEW_FILE_SIZE_TIME, x, 114, fx, fy, SS_NOPREFIX
-
- PUSHBUTTON "&Yes", IDYES, bx3, by2, bxs, bys
- PUSHBUTTON "Yes to &All", IDB_YES_TO_ALL, bx2, by2, bxs, bys
- PUSHBUTTON "A&uto Rename", IDB_AUTO_RENAME, bx1, by2, bSizeBig, bys
- PUSHBUTTON "&No", IDNO, bx3, by1, bxs, bys
- PUSHBUTTON "No to A&ll", IDB_NO_TO_ALL, bx2, by1, bxs, bys
- PUSHBUTTON "&Cancel", IDCANCEL, xs - m - bxs, by1, bxs, bys
-END
-
-
-#ifdef UNDER_CE
-
-#undef m
-#undef xc
-#undef yc
-
-#define m 4
-#define xc 152
-#define yc 144
-
-#undef fy
-#define fy 40
-
-#undef bxs
-#define bxs 48
-
-#undef bx1
-
-#define bx1 (xs - m - bxs)
-
-IDD_OVERWRITE_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "Confirm File Replace"
-BEGIN
- LTEXT "Would you like to replace the existing file", IDT_OVERWRITE_QUESTION_BEGIN, m, m, xc, 8
-
- ICON "", IDI_OVERWRITE_OLD_FILE, m, 20, iconSize, iconSize
- LTEXT "", IDT_OVERWRITE_OLD_FILE_SIZE_TIME, x, 20, fx, fy, SS_NOPREFIX
-
- LTEXT "with this one?", IDT_OVERWRITE_QUESTION_END, m, 60, xc, 8
-
- ICON "", IDI_OVERWRITE_NEW_FILE, m, 72, iconSize, iconSize
- LTEXT "", IDT_OVERWRITE_NEW_FILE_SIZE_TIME, x, 72, fx, fy, SS_NOPREFIX
-
- PUSHBUTTON "&Yes", IDYES, bx3, by2, bxs, bys
- PUSHBUTTON "Yes to &All", IDB_YES_TO_ALL, bx2, by2, bxs, bys
- PUSHBUTTON "A&uto Rename", IDB_AUTO_RENAME, bx1, by2, bxs, bys
- PUSHBUTTON "&No", IDNO, bx3, by1, bxs, bys
- PUSHBUTTON "No to A&ll", IDB_NO_TO_ALL, bx2, by1, bxs, bys
- PUSHBUTTON "&Cancel", IDCANCEL, bx1, by1, bxs, bys
-END
-
-#endif
-
-
-STRINGTABLE
-BEGIN
- IDS_FILE_SIZE "{0} bytes"
-END
+#include "OverwriteDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 280
+#define yc 200
+
+#undef iconSize
+#define iconSize 24
+
+#undef x
+#undef fx
+#undef fy
+#define x (m + iconSize + m)
+#define fx (xc - iconSize - m)
+#define fy 50
+
+#define bSizeBig 104
+#undef bx1
+#define bx1 (xs - m - bSizeBig)
+
+IDD_OVERWRITE DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Confirm File Replace"
+BEGIN
+ LTEXT "Destination folder already contains processed file.", IDT_OVERWRITE_HEADER, m, 7, xc, 8
+ LTEXT "Would you like to replace the existing file", IDT_OVERWRITE_QUESTION_BEGIN, m, 28, xc, 8
+
+ ICON "", IDI_OVERWRITE_OLD_FILE, m, 44, iconSize, iconSize
+ LTEXT "", IDT_OVERWRITE_OLD_FILE_SIZE_TIME, x, 44, fx, fy, SS_NOPREFIX
+
+ LTEXT "with this one?", IDT_OVERWRITE_QUESTION_END, m, 98, xc, 8
+
+ ICON "", IDI_OVERWRITE_NEW_FILE, m, 114, iconSize, iconSize
+ LTEXT "", IDT_OVERWRITE_NEW_FILE_SIZE_TIME, x, 114, fx, fy, SS_NOPREFIX
+
+ PUSHBUTTON "&Yes", IDYES, bx3, by2, bxs, bys
+ PUSHBUTTON "Yes to &All", IDB_YES_TO_ALL, bx2, by2, bxs, bys
+ PUSHBUTTON "A&uto Rename", IDB_AUTO_RENAME, bx1, by2, bSizeBig, bys
+ PUSHBUTTON "&No", IDNO, bx3, by1, bxs, bys
+ PUSHBUTTON "No to A&ll", IDB_NO_TO_ALL, bx2, by1, bxs, bys
+ PUSHBUTTON "&Cancel", IDCANCEL, xs - m - bxs, by1, bxs, bys
+END
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc 152
+#define yc 144
+
+#undef fy
+#define fy 40
+
+#undef bxs
+#define bxs 48
+
+#undef bx1
+
+#define bx1 (xs - m - bxs)
+
+IDD_OVERWRITE_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Confirm File Replace"
+BEGIN
+ LTEXT "Would you like to replace the existing file", IDT_OVERWRITE_QUESTION_BEGIN, m, m, xc, 8
+
+ ICON "", IDI_OVERWRITE_OLD_FILE, m, 20, iconSize, iconSize
+ LTEXT "", IDT_OVERWRITE_OLD_FILE_SIZE_TIME, x, 20, fx, fy, SS_NOPREFIX
+
+ LTEXT "with this one?", IDT_OVERWRITE_QUESTION_END, m, 60, xc, 8
+
+ ICON "", IDI_OVERWRITE_NEW_FILE, m, 72, iconSize, iconSize
+ LTEXT "", IDT_OVERWRITE_NEW_FILE_SIZE_TIME, x, 72, fx, fy, SS_NOPREFIX
+
+ PUSHBUTTON "&Yes", IDYES, bx3, by2, bxs, bys
+ PUSHBUTTON "Yes to &All", IDB_YES_TO_ALL, bx2, by2, bxs, bys
+ PUSHBUTTON "A&uto Rename", IDB_AUTO_RENAME, bx1, by2, bxs, bys
+ PUSHBUTTON "&No", IDNO, bx3, by1, bxs, bys
+ PUSHBUTTON "No to A&ll", IDB_NO_TO_ALL, bx2, by1, bxs, bys
+ PUSHBUTTON "&Cancel", IDCANCEL, bx1, by1, bxs, bys
+END
+
+#endif
+
+
+STRINGTABLE
+BEGIN
+ IDS_FILE_SIZE "{0} bytes"
+END
diff --git a/CPP/7zip/UI/FileManager/OverwriteDialogRes.h b/CPP/7zip/UI/FileManager/OverwriteDialogRes.h
index 28bc0d0..b480ba1 100644
--- a/CPP/7zip/UI/FileManager/OverwriteDialogRes.h
+++ b/CPP/7zip/UI/FileManager/OverwriteDialogRes.h
@@ -1,17 +1,17 @@
-#define IDD_OVERWRITE 3500
-#define IDD_OVERWRITE_2 13500
-
-#define IDT_OVERWRITE_HEADER 3501
-#define IDT_OVERWRITE_QUESTION_BEGIN 3502
-#define IDT_OVERWRITE_QUESTION_END 3503
-#define IDS_FILE_SIZE 3504
-
-#define IDB_AUTO_RENAME 3505
-#define IDB_YES_TO_ALL 440
-#define IDB_NO_TO_ALL 441
-
-#define IDI_OVERWRITE_OLD_FILE 100
-#define IDI_OVERWRITE_NEW_FILE 101
-
-#define IDT_OVERWRITE_OLD_FILE_SIZE_TIME 102
-#define IDT_OVERWRITE_NEW_FILE_SIZE_TIME 103
+#define IDD_OVERWRITE 3500
+#define IDD_OVERWRITE_2 13500
+
+#define IDT_OVERWRITE_HEADER 3501
+#define IDT_OVERWRITE_QUESTION_BEGIN 3502
+#define IDT_OVERWRITE_QUESTION_END 3503
+#define IDS_FILE_SIZE 3504
+
+#define IDB_AUTO_RENAME 3505
+#define IDB_YES_TO_ALL 440
+#define IDB_NO_TO_ALL 441
+
+#define IDI_OVERWRITE_OLD_FILE 100
+#define IDI_OVERWRITE_NEW_FILE 101
+
+#define IDT_OVERWRITE_OLD_FILE_SIZE_TIME 102
+#define IDT_OVERWRITE_NEW_FILE_SIZE_TIME 103
diff --git a/CPP/7zip/UI/FileManager/Panel.cpp b/CPP/7zip/UI/FileManager/Panel.cpp
new file mode 100644
index 0000000..72b72c6
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Panel.cpp
@@ -0,0 +1,1182 @@
+// Panel.cpp
+
+#include "StdAfx.h"
+
+#include <windowsx.h>
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../PropID.h"
+
+#include "resource.h"
+#include "../GUI/ExtractRes.h"
+
+#include "../Common/ArchiveName.h"
+#include "../Common/CompressCall.h"
+#include "../Common/ZipRegistry.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "App.h"
+#include "ExtractCallback.h"
+#include "FSFolder.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "Panel.h"
+#include "RootFolder.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NControl;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+static const UINT_PTR kTimerID = 1;
+static const UINT kTimerElapse = 1000;
+
+static DWORD kStyles[4] = { LVS_ICON, LVS_SMALLICON, LVS_LIST, LVS_REPORT };
+
+// static const int kCreateFolderID = 101;
+
+extern HINSTANCE g_hInstance;
+extern DWORD g_ComCtl32Version;
+
+void CPanel::Release()
+{
+ // It's for unloading COM dll's: don't change it.
+ CloseOpenFolders();
+ _sevenZipContextMenu.Release();
+ _systemContextMenu.Release();
+}
+
+CPanel::~CPanel()
+{
+ CloseOpenFolders();
+}
+
+HWND CPanel::GetParent() const
+{
+ const HWND h = CWindow2::GetParent();
+ return h ? h : _mainWindow;
+}
+
+#define kClassName L"7-Zip::Panel"
+
+
+HRESULT CPanel::Create(HWND mainWindow, HWND parentWindow, UINT id,
+ const UString ¤tFolderPrefix,
+ const UString &arcFormat,
+ CPanelCallback *panelCallback, CAppState *appState,
+ bool needOpenArc,
+ COpenResult &openRes)
+{
+ _mainWindow = mainWindow;
+ _processTimer = true;
+ _processNotify = true;
+ _processStatusBar = true;
+
+ _panelCallback = panelCallback;
+ _appState = appState;
+ // _index = index;
+ _baseID = id;
+ _comboBoxID = _baseID + 3;
+ _statusBarID = _comboBoxID + 1;
+
+ UString cfp = currentFolderPrefix;
+
+ if (!currentFolderPrefix.IsEmpty())
+ if (currentFolderPrefix[0] == L'.')
+ {
+ FString cfpF;
+ if (NFile::NDir::MyGetFullPathName(us2fs(currentFolderPrefix), cfpF))
+ cfp = fs2us(cfpF);
+ }
+
+ RINOK(BindToPath(cfp, arcFormat, openRes))
+
+ if (needOpenArc && !openRes.ArchiveIsOpened)
+ return S_OK;
+
+ if (!CreateEx(0, kClassName, NULL, WS_CHILD | WS_VISIBLE,
+ 0, 0, _xSize, 260,
+ parentWindow, (HMENU)(UINT_PTR)id, g_hInstance))
+ return E_FAIL;
+ PanelCreated = true;
+
+ return S_OK;
+}
+
+// extern UInt32 g_NumMessages;
+
+LRESULT CPanel::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ // g_NumMessages++;
+ switch (message)
+ {
+ case kShiftSelectMessage:
+ OnShiftSelectMessage();
+ return 0;
+ case kReLoadMessage:
+ RefreshListCtrl(_selectedState);
+ return 0;
+ case kSetFocusToListView:
+ _listView.SetFocus();
+ return 0;
+ case kOpenItemChanged:
+ return OnOpenItemChanged(lParam);
+ case kRefresh_StatusBar:
+ if (_processStatusBar)
+ Refresh_StatusBar();
+ return 0;
+ #ifdef UNDER_CE
+ case kRefresh_HeaderComboBox:
+ LoadFullPathAndShow();
+ return 0;
+ #endif
+ case WM_TIMER:
+ OnTimer();
+ return 0;
+ case WM_CONTEXTMENU:
+ if (OnContextMenu(HANDLE(wParam), GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)))
+ return 0;
+ break;
+ /*
+ case WM_DROPFILES:
+ CompressDropFiles(HDROP(wParam));
+ return 0;
+ */
+ }
+ return CWindow2::OnMessage(message, wParam, lParam);
+}
+
+LRESULT CMyListView::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ if (message == WM_CHAR)
+ {
+ UINT scanCode = (UINT)((lParam >> 16) & 0xFF);
+ bool extended = ((lParam & 0x1000000) != 0);
+ UINT virtualKey = MapVirtualKey(scanCode, 1);
+ if (virtualKey == VK_MULTIPLY || virtualKey == VK_ADD ||
+ virtualKey == VK_SUBTRACT)
+ return 0;
+ if ((wParam == '/' && extended)
+ || wParam == '\\' || wParam == '/')
+ {
+ _panel->OpenDrivesFolder();
+ return 0;
+ }
+ }
+ else if (message == WM_SYSCHAR)
+ {
+ // For Alt+Enter Beep disabling
+ UINT scanCode = (UINT)(lParam >> 16) & 0xFF;
+ UINT virtualKey = MapVirtualKey(scanCode, 1);
+ if (virtualKey == VK_RETURN || virtualKey == VK_MULTIPLY ||
+ virtualKey == VK_ADD || virtualKey == VK_SUBTRACT)
+ return 0;
+ }
+ /*
+ else if (message == WM_SYSKEYDOWN)
+ {
+ // return 0;
+ }
+ */
+ else if (message == WM_KEYDOWN)
+ {
+ bool alt = IsKeyDown(VK_MENU);
+ bool ctrl = IsKeyDown(VK_CONTROL);
+ bool shift = IsKeyDown(VK_SHIFT);
+ switch (wParam)
+ {
+ /*
+ case VK_RETURN:
+ {
+ if (shift && !alt && !ctrl)
+ {
+ _panel->OpenSelectedItems(false);
+ return 0;
+ }
+ break;
+ }
+ */
+ case VK_NEXT:
+ {
+ if (ctrl && !alt && !shift)
+ {
+ _panel->OpenFocusedItemAsInternal();
+ return 0;
+ }
+ break;
+ }
+ case VK_PRIOR:
+ if (ctrl && !alt && !shift)
+ {
+ _panel->OpenParentFolder();
+ return 0;
+ }
+ }
+ }
+ #ifdef UNDER_CE
+ else if (message == WM_KEYUP)
+ {
+ if (wParam == VK_F2) // it's VK_TSOFT2
+ {
+ // Activate Menu
+ ::PostMessage(g_HWND, WM_SYSCOMMAND, SC_KEYMENU, 0);
+ return 0;
+ }
+ }
+ #endif
+ else if (message == WM_SETFOCUS)
+ {
+ _panel->_lastFocusedIsList = true;
+ _panel->_panelCallback->PanelWasFocused();
+ }
+ return CListView2::OnMessage(message, wParam, lParam);
+}
+
+/*
+static LRESULT APIENTRY ComboBoxSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ CWindow tempDialog(hwnd);
+ CMyComboBox *w = (CMyComboBox *)(tempDialog.GetUserDataLongPtr());
+ if (w == NULL)
+ return 0;
+ return w->OnMessage(message, wParam, lParam);
+}
+
+LRESULT CMyComboBox::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
+}
+*/
+
+#ifndef UNDER_CE
+
+static LRESULT APIENTRY ComboBoxEditSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ CWindow tempDialog(hwnd);
+ CMyComboBoxEdit *w = (CMyComboBoxEdit *)(tempDialog.GetUserDataLongPtr());
+ if (w == NULL)
+ return 0;
+ return w->OnMessage(message, wParam, lParam);
+}
+
+#endif
+
+LRESULT CMyComboBoxEdit::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ // See MSDN / Subclassing a Combo Box / Creating a Combo-box Toolbar
+ switch (message)
+ {
+ case WM_SYSKEYDOWN:
+ switch (wParam)
+ {
+ case VK_F1:
+ case VK_F2:
+ {
+ // check ALT
+ if ((lParam & (1<<29)) == 0)
+ break;
+ bool alt = IsKeyDown(VK_MENU);
+ bool ctrl = IsKeyDown(VK_CONTROL);
+ bool shift = IsKeyDown(VK_SHIFT);
+ if (alt && !ctrl && !shift)
+ {
+ _panel->_panelCallback->SetFocusToPath(wParam == VK_F1 ? 0 : 1);
+ return 0;
+ }
+ break;
+ }
+ }
+ break;
+ case WM_KEYDOWN:
+ switch (wParam)
+ {
+ case VK_TAB:
+ // SendMessage(hwndMain, WM_ENTER, 0, 0);
+ _panel->SetFocusToList();
+ return 0;
+ case VK_F9:
+ {
+ bool alt = IsKeyDown(VK_MENU);
+ bool ctrl = IsKeyDown(VK_CONTROL);
+ bool shift = IsKeyDown(VK_SHIFT);
+ if (!alt && !ctrl && !shift)
+ {
+ g_App.SwitchOnOffOnePanel();
+ return 0;
+ }
+ break;
+ }
+ case 'W':
+ {
+ bool ctrl = IsKeyDown(VK_CONTROL);
+ if (ctrl)
+ {
+ PostMessage(g_HWND, WM_COMMAND, IDCLOSE, 0);
+ return 0;
+ }
+ break;
+ }
+ }
+ break;
+ case WM_CHAR:
+ switch (wParam)
+ {
+ case VK_TAB:
+ case VK_ESCAPE:
+ return 0;
+ }
+ }
+ #ifndef _UNICODE
+ if (g_IsNT)
+ return CallWindowProcW(_origWindowProc, *this, message, wParam, lParam);
+ else
+ #endif
+ return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
+}
+
+
+/*
+ REBARBANDINFO in vista (_WIN32_WINNT >= 0x0600) has additional fields
+ we want 2000/xp compatibility.
+ so we must use reduced structure, if we compile with (_WIN32_WINNT >= 0x0600)
+ Also there are additional fields, if (_WIN32_IE >= 0x0400).
+ but (_WIN32_IE >= 0x0400) is expected.
+ note:
+ in x64 (64-bit):
+ {
+ (108 == REBARBANDINFO_V6_SIZE)
+ (112 == sizeof(REBARBANDINFO) // for (_WIN32_WINNT < 0x0600)
+ (128 == sizeof(REBARBANDINFO) // for (_WIN32_WINNT >= 0x0600)
+ there is difference in sizes, because REBARBANDINFO size was
+ not aligned for 8-bytes in (_WIN32_WINNT < 0x0600).
+ We hope that WinVista+ support support both (108 and 112) sizes.
+ But does WinXP-x64 support (108 == REBARBANDINFO_V6_SIZE)?
+ {
+ 96 LPARAM lParam;
+ 104 UINT cxHeader;
+ #if (_WIN32_WINNT >= 0x0600)
+ 108 RECT rcChevronLocation;
+ 124 UINT uChevronState;
+ #endif
+ }
+*/
+
+#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600) && defined(REBARBANDINFOA_V6_SIZE)
+ #define my_compatib_REBARBANDINFO_size REBARBANDINFO_V6_SIZE
+#else
+ #define my_compatib_REBARBANDINFO_size sizeof(REBARBANDINFO)
+#endif
+
+
+bool CPanel::OnCreate(CREATESTRUCT * /* createStruct */)
+{
+ // _virtualMode = false;
+ // _sortIndex = 0;
+ _sortID = kpidName;
+ _ascending = true;
+ _lastFocusedIsList = true;
+
+ DWORD style = WS_CHILD | WS_VISIBLE; // | WS_BORDER ; // | LVS_SHAREIMAGELISTS; // | LVS_SHOWSELALWAYS;
+
+ style |= LVS_SHAREIMAGELISTS;
+ // style |= LVS_AUTOARRANGE;
+ style |= WS_CLIPCHILDREN;
+ style |= WS_CLIPSIBLINGS;
+
+ const UInt32 kNumListModes = Z7_ARRAY_SIZE(kStyles);
+ if (_listViewMode >= kNumListModes)
+ _listViewMode = kNumListModes - 1;
+
+ style |= kStyles[_listViewMode]
+ | WS_TABSTOP
+ | LVS_EDITLABELS;
+ if (_mySelectMode)
+ style |= LVS_SINGLESEL;
+
+ /*
+ if (_virtualMode)
+ style |= LVS_OWNERDATA;
+ */
+
+ DWORD exStyle;
+ exStyle = WS_EX_CLIENTEDGE;
+
+ if (!_listView.CreateEx(exStyle, style, 0, 0, 116, 260,
+ *this, (HMENU)(UINT_PTR)(_baseID + 1), g_hInstance, NULL))
+ return false;
+
+ _listView.SetUnicodeFormat();
+ _listView._panel = this;
+ _listView.SetWindowProc();
+
+ _listView.SetImageList(GetSysImageList(true), LVSIL_SMALL);
+ _listView.SetImageList(GetSysImageList(false), LVSIL_NORMAL);
+
+ // _exStyle |= LVS_EX_HEADERDRAGDROP;
+ // DWORD extendedStyle = _listView.GetExtendedListViewStyle();
+ // extendedStyle |= _exStyle;
+ // _listView.SetExtendedListViewStyle(extendedStyle);
+ SetExtendedStyle();
+
+ _listView.Show(SW_SHOW);
+ _listView.InvalidateRect(NULL, true);
+ _listView.Update();
+
+ // Ensure that the common control DLL is loaded.
+ INITCOMMONCONTROLSEX icex;
+
+ icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+ icex.dwICC = ICC_BAR_CLASSES;
+ InitCommonControlsEx(&icex);
+
+ const TBBUTTON tbb[] =
+ {
+ // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+ {VIEW_PARENTFOLDER, kParentFolderID, TBSTATE_ENABLED, BTNS_BUTTON, { 0, 0 }, 0, 0 },
+ // {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
+ // {VIEW_NEWFOLDER, kCreateFolderID, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
+ };
+
+ #ifndef UNDER_CE
+ if (g_ComCtl32Version >= MAKELONG(71, 4))
+ #endif
+ {
+ icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+ icex.dwICC = ICC_COOL_CLASSES | ICC_BAR_CLASSES;
+ InitCommonControlsEx(&icex);
+
+ // if there is no CCS_NOPARENTALIGN, there is space of some pixels after rebar (Incorrect GetWindowRect ?)
+
+ _headerReBar.Attach(::CreateWindowEx(WS_EX_TOOLWINDOW,
+ REBARCLASSNAME,
+ NULL, WS_VISIBLE | WS_BORDER | WS_CHILD |
+ WS_CLIPCHILDREN | WS_CLIPSIBLINGS
+ | CCS_NODIVIDER
+ | CCS_NOPARENTALIGN
+ | CCS_TOP
+ | RBS_VARHEIGHT
+ | RBS_BANDBORDERS
+ ,0,0,0,0, *this, NULL, g_hInstance, NULL));
+ }
+
+ DWORD toolbarStyle = WS_CHILD | WS_VISIBLE ;
+ if (_headerReBar)
+ {
+ toolbarStyle |= 0
+ // | WS_CLIPCHILDREN
+ // | WS_CLIPSIBLINGS
+
+ | TBSTYLE_TOOLTIPS
+ | CCS_NODIVIDER
+ | CCS_NORESIZE
+ | TBSTYLE_FLAT
+ ;
+ }
+
+ _headerToolBar.Attach(::CreateToolbarEx ((*this), toolbarStyle,
+ _baseID + 2, 11,
+ (HINSTANCE)HINST_COMMCTRL,
+ IDB_VIEW_SMALL_COLOR,
+ (LPCTBBUTTON)&tbb, Z7_ARRAY_SIZE(tbb),
+ 0, 0, 0, 0, sizeof (TBBUTTON)));
+
+ #ifndef UNDER_CE
+ // Load ComboBoxEx class
+ icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
+ icex.dwICC = ICC_USEREX_CLASSES;
+ InitCommonControlsEx(&icex);
+ #endif
+
+ _headerComboBox.CreateEx(0,
+ #ifdef UNDER_CE
+ WC_COMBOBOXW
+ #else
+ WC_COMBOBOXEXW
+ #endif
+ , NULL,
+ WS_BORDER | WS_VISIBLE |WS_CHILD | CBS_DROPDOWN | CBS_AUTOHSCROLL,
+ 0, 0, 100, 520,
+ (_headerReBar ? _headerToolBar : (HWND)*this),
+ (HMENU)(UINT_PTR)(_comboBoxID),
+ g_hInstance, NULL);
+ #ifndef UNDER_CE
+ _headerComboBox.SetUnicodeFormat(true);
+
+ _headerComboBox.SetImageList(GetSysImageList(true));
+
+ _headerComboBox.SetExtendedStyle(CBES_EX_PATHWORDBREAKPROC, CBES_EX_PATHWORDBREAKPROC);
+
+ /*
+ _headerComboBox.SetUserDataLongPtr(LONG_PTR(&_headerComboBox));
+ _headerComboBox._panel = this;
+ _headerComboBox._origWindowProc =
+ (WNDPROC)_headerComboBox.SetLongPtr(GWLP_WNDPROC,
+ LONG_PTR(ComboBoxSubclassProc));
+ */
+ _comboBoxEdit.Attach(_headerComboBox.GetEditControl());
+
+ // _comboBoxEdit.SendMessage(CCM_SETUNICODEFORMAT, (WPARAM)(BOOL)TRUE, 0);
+
+ _comboBoxEdit.SetUserDataLongPtr(LONG_PTR(&_comboBoxEdit));
+ _comboBoxEdit._panel = this;
+ #ifndef _UNICODE
+ if (g_IsNT)
+ _comboBoxEdit._origWindowProc =
+ (WNDPROC)_comboBoxEdit.SetLongPtrW(GWLP_WNDPROC, LONG_PTR(ComboBoxEditSubclassProc));
+ else
+ #endif
+ _comboBoxEdit._origWindowProc =
+ (WNDPROC)_comboBoxEdit.SetLongPtr(GWLP_WNDPROC, LONG_PTR(ComboBoxEditSubclassProc));
+
+ #endif
+
+ if (_headerReBar)
+ {
+ REBARINFO rbi;
+ rbi.cbSize = sizeof(REBARINFO); // Required when using this struct.
+ rbi.fMask = 0;
+ rbi.himl = (HIMAGELIST)NULL;
+ _headerReBar.SetBarInfo(&rbi);
+
+ // Send the TB_BUTTONSTRUCTSIZE message, which is required for
+ // backward compatibility.
+ // _headerToolBar.SendMessage(TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
+ SIZE size;
+ _headerToolBar.GetMaxSize(&size);
+
+ REBARBANDINFO rbBand;
+ memset(&rbBand, 0, sizeof(rbBand));
+ // rbBand.cbSize = sizeof(rbBand); // for debug
+ // rbBand.cbSize = REBARBANDINFO_V3_SIZE; // for debug
+ rbBand.cbSize = my_compatib_REBARBANDINFO_size;
+ rbBand.fMask = RBBIM_STYLE | RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_SIZE;
+ rbBand.fStyle = RBBS_NOGRIPPER;
+ rbBand.cxMinChild = (UINT)size.cx;
+ rbBand.cyMinChild = (UINT)size.cy;
+ rbBand.cyChild = (UINT)size.cy;
+ rbBand.cx = (UINT)size.cx;
+ rbBand.hwndChild = _headerToolBar;
+ _headerReBar.InsertBand(-1, &rbBand);
+
+ RECT rc;
+ ::GetWindowRect(_headerComboBox, &rc);
+ rbBand.cxMinChild = 30;
+ rbBand.cyMinChild = (UINT)(rc.bottom - rc.top);
+ rbBand.cx = 1000;
+ rbBand.hwndChild = _headerComboBox;
+ _headerReBar.InsertBand(-1, &rbBand);
+ // _headerReBar.MaximizeBand(1, false);
+ }
+
+ _statusBar.Create(WS_CHILD | WS_VISIBLE, L"Status", (*this), _statusBarID);
+ // _statusBar2.Create(WS_CHILD | WS_VISIBLE, L"Status", (*this), _statusBarID + 1);
+
+ const int sizes[] = {220, 320, 420, -1};
+ _statusBar.SetParts(4, sizes);
+ // _statusBar2.SetParts(5, sizes);
+
+ /*
+ RECT rect;
+ GetClientRect(&rect);
+ OnSize(0, RECT_SIZE_X(rect), RECT_SIZE_Y(rect));
+ */
+
+ SetTimer(kTimerID, kTimerElapse);
+
+ // InitListCtrl();
+ RefreshListCtrl();
+
+ return true;
+}
+
+void CPanel::OnDestroy()
+{
+ SaveListViewInfo();
+ CWindow2::OnDestroy();
+}
+
+void CPanel::ChangeWindowSize(int xSize, int ySize)
+{
+ if (!(HWND)*this)
+ return;
+ int kHeaderSize;
+ int kStatusBarSize;
+ // int kStatusBar2Size;
+ RECT rect;
+ if (_headerReBar)
+ _headerReBar.GetWindowRect(&rect);
+ else
+ _headerToolBar.GetWindowRect(&rect);
+
+ kHeaderSize = RECT_SIZE_Y(rect);
+
+ _statusBar.GetWindowRect(&rect);
+ kStatusBarSize = RECT_SIZE_Y(rect);
+
+ // _statusBar2.GetWindowRect(&rect);
+ // kStatusBar2Size = RECT_SIZE_Y(rect);
+
+ int yListViewSize = MyMax(ySize - kHeaderSize - kStatusBarSize, 0);
+ const int kStartXPos = 32;
+ if (_headerReBar)
+ {
+ }
+ else
+ {
+ _headerToolBar.Move(0, 0, xSize, 0);
+ _headerComboBox.Move(kStartXPos, 2,
+ MyMax(xSize - kStartXPos - 10, kStartXPos), 0);
+ }
+ _listView.Move(0, kHeaderSize, xSize, yListViewSize);
+ _statusBar.Move(0, kHeaderSize + yListViewSize, xSize, kStatusBarSize);
+ // _statusBar2.MoveWindow(0, kHeaderSize + yListViewSize + kStatusBarSize, xSize, kStatusBar2Size);
+ // _statusBar.MoveWindow(0, 100, xSize, kStatusBarSize);
+ // _statusBar2.MoveWindow(0, 200, xSize, kStatusBar2Size);
+}
+
+bool CPanel::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ if (!(HWND)*this)
+ return true;
+ if (_headerReBar)
+ _headerReBar.Move(0, 0, xSize, 0);
+ ChangeWindowSize(xSize, ySize);
+ return true;
+}
+
+bool CPanel::OnNotifyReBar(LPNMHDR header, LRESULT & /* result */)
+{
+ switch (header->code)
+ {
+ case RBN_HEIGHTCHANGE:
+ {
+ RECT rect;
+ GetWindowRect(&rect);
+ ChangeWindowSize(RECT_SIZE_X(rect), RECT_SIZE_Y(rect));
+ return false;
+ }
+ }
+ return false;
+}
+
+/*
+UInt32 g_OnNotify = 0;
+UInt32 g_LVIF_TEXT = 0;
+UInt32 g_Time = 0;
+
+void Print_OnNotify(const char *name)
+{
+ char s[256];
+ DWORD tim = GetTickCount();
+ sprintf(s,
+ "Time = %7u ms, Notify = %9u, TEXT = %9u, %s",
+ tim - g_Time,
+ g_OnNotify,
+ g_LVIF_TEXT,
+ name);
+ g_Time = tim;
+ OutputDebugStringA(s);
+ g_OnNotify = 0;
+ g_LVIF_TEXT = 0;
+}
+*/
+
+bool CPanel::OnNotify(UINT /* controlID */, LPNMHDR header, LRESULT &result)
+{
+ /*
+ g_OnNotify++;
+
+ if (header->hwndFrom == _listView)
+ {
+ if (header->code == LVN_GETDISPINFOW)
+ {
+ LV_DISPINFOW *dispInfo = (LV_DISPINFOW *)header;
+ if ((dispInfo->item.mask & LVIF_TEXT))
+ g_LVIF_TEXT++;
+ }
+ }
+ */
+
+ if (!_processNotify)
+ return false;
+
+ if (header->hwndFrom == _headerComboBox)
+ return OnNotifyComboBox(header, result);
+ else if (header->hwndFrom == _headerReBar)
+ return OnNotifyReBar(header, result);
+ else if (header->hwndFrom == _listView)
+ return OnNotifyList(header, result);
+ else if (::GetParent(header->hwndFrom) == _listView)
+ {
+ // NMHDR:code is UINT
+ // NM_RCLICK is unsigned in windows sdk
+ // NM_RCLICK is int in MinGW
+ if (header->code == (UINT)NM_RCLICK)
+ return OnRightClick((MY_NMLISTVIEW_NMITEMACTIVATE *)header, result);
+ }
+ return false;
+}
+
+bool CPanel::OnCommand(unsigned code, unsigned itemID, LPARAM lParam, LRESULT &result)
+{
+ if (itemID == kParentFolderID)
+ {
+ OpenParentFolder();
+ result = 0;
+ return true;
+ }
+ /*
+ if (itemID == kCreateFolderID)
+ {
+ CreateFolder();
+ result = 0;
+ return true;
+ }
+ */
+ if (itemID == _comboBoxID)
+ {
+ if (OnComboBoxCommand(code, lParam, result))
+ return true;
+ }
+ return CWindow2::OnCommand(code, itemID, lParam, result);
+}
+
+
+
+/*
+void CPanel::MessageBox_Info(LPCWSTR message, LPCWSTR caption) const
+ { ::MessageBoxW((HWND)*this, message, caption, MB_OK); }
+void CPanel::MessageBox_Warning(LPCWSTR message) const
+ { ::MessageBoxW((HWND)*this, message, L"7-Zip", MB_OK | MB_ICONWARNING); }
+*/
+
+void CPanel::MessageBox_Error_Caption(LPCWSTR message, LPCWSTR caption) const
+ { ::MessageBoxW((HWND)*this, message, caption, MB_OK | MB_ICONSTOP); }
+
+void CPanel::MessageBox_Error(LPCWSTR message) const
+ { MessageBox_Error_Caption(message, L"7-Zip"); }
+
+static UString ErrorHResult_To_Message(HRESULT errorCode)
+{
+ if (errorCode == 0)
+ errorCode = E_FAIL;
+ return HResultToMessage(errorCode);
+}
+
+void CPanel::MessageBox_Error_HRESULT_Caption(HRESULT errorCode, LPCWSTR caption) const
+{
+ MessageBox_Error_Caption(ErrorHResult_To_Message(errorCode), caption);
+}
+
+void CPanel::MessageBox_Error_HRESULT(HRESULT errorCode) const
+ { MessageBox_Error_HRESULT_Caption(errorCode, L"7-Zip"); }
+
+void CPanel::MessageBox_Error_2Lines_Message_HRESULT(LPCWSTR message, HRESULT errorCode) const
+{
+ UString m = message;
+ m.Add_LF();
+ m += ErrorHResult_To_Message(errorCode);
+ MessageBox_Error(m);
+}
+
+void CPanel::MessageBox_LastError(LPCWSTR caption) const
+ { MessageBox_Error_HRESULT_Caption(GetLastError_noZero_HRESULT(), caption); }
+
+void CPanel::MessageBox_LastError() const
+ { MessageBox_LastError(L"7-Zip"); }
+
+void CPanel::MessageBox_Error_LangID(UINT resourceID) const
+ { MessageBox_Error(LangString(resourceID)); }
+
+void CPanel::MessageBox_Error_UnsupportOperation() const
+ { MessageBox_Error_LangID(IDS_OPERATION_IS_NOT_SUPPORTED); }
+
+
+
+
+void CPanel::SetFocusToList()
+{
+ _listView.SetFocus();
+ // SetCurrentPathText();
+}
+
+void CPanel::SetFocusToLastRememberedItem()
+{
+ if (_lastFocusedIsList)
+ SetFocusToList();
+ else
+ _headerComboBox.SetFocus();
+}
+
+UString CPanel::GetFolderTypeID() const
+{
+ {
+ NCOM::CPropVariant prop;
+ if (_folder->GetFolderProperty(kpidType, &prop) == S_OK)
+ if (prop.vt == VT_BSTR)
+ return (const wchar_t *)prop.bstrVal;
+ }
+ return UString();
+}
+
+bool CPanel::IsFolderTypeEqTo(const char *s) const
+{
+ return StringsAreEqual_Ascii(GetFolderTypeID(), s);
+}
+
+bool CPanel::IsRootFolder() const { return IsFolderTypeEqTo("RootFolder"); }
+bool CPanel::IsFSFolder() const { return IsFolderTypeEqTo("FSFolder"); }
+bool CPanel::IsFSDrivesFolder() const { return IsFolderTypeEqTo("FSDrives"); }
+bool CPanel::IsAltStreamsFolder() const { return IsFolderTypeEqTo("AltStreamsFolder"); }
+bool CPanel::IsArcFolder() const
+{
+ return GetFolderTypeID().IsPrefixedBy_Ascii_NoCase("7-Zip");
+}
+
+bool CPanel::IsHashFolder() const
+{
+ if (_folder)
+ {
+ NCOM::CPropVariant prop;
+ if (_folder->GetFolderProperty(kpidIsHash, &prop) == S_OK)
+ if (prop.vt == VT_BOOL)
+ return VARIANT_BOOLToBool(prop.boolVal);
+ }
+ return false;
+}
+
+UString CPanel::GetFsPath() const
+{
+ if (IsFSDrivesFolder() && !IsDeviceDrivesPrefix() && !IsSuperDrivesPrefix())
+ return UString();
+ return _currentFolderPrefix;
+}
+
+UString CPanel::GetDriveOrNetworkPrefix() const
+{
+ if (!IsFSFolder())
+ return UString();
+ UString drive = GetFsPath();
+ drive.DeleteFrom(NFile::NName::GetRootPrefixSize(drive));
+ return drive;
+}
+
+void CPanel::SetListViewMode(UInt32 index)
+{
+ if (index >= 4)
+ return;
+ _listViewMode = index;
+ const LONG_PTR oldStyle = _listView.GetStyle();
+ const DWORD newStyle = kStyles[index];
+
+ // DWORD tickCount1 = GetTickCount();
+ if ((oldStyle & LVS_TYPEMASK) != (LONG_PTR)newStyle)
+ _listView.SetStyle((oldStyle & ~(LONG_PTR)(DWORD)LVS_TYPEMASK) | (LONG_PTR)newStyle);
+ // RefreshListCtrlSaveFocused();
+ /*
+ DWORD tickCount2 = GetTickCount();
+ char s[256];
+ sprintf(s, "SetStyle = %5d",
+ tickCount2 - tickCount1
+ );
+ OutputDebugStringA(s);
+ */
+
+}
+
+void CPanel::ChangeFlatMode()
+{
+ _flatMode = !_flatMode;
+ if (_parentFolders.Size() > 0)
+ _flatModeForArc = _flatMode;
+ else
+ _flatModeForDisk = _flatMode;
+ RefreshListCtrl_SaveFocused();
+}
+
+/*
+void CPanel::Change_ShowNtfsStrems_Mode()
+{
+ _showNtfsStrems_Mode = !_showNtfsStrems_Mode;
+ if (_parentFolders.Size() > 0)
+ _showNtfsStrems_ModeForArc = _showNtfsStrems_Mode;
+ else
+ _showNtfsStrems_ModeForDisk = _showNtfsStrems_Mode;
+ RefreshListCtrlSaveFocused();
+}
+*/
+
+void CPanel::Post_Refresh_StatusBar()
+{
+ if (_processStatusBar)
+ PostMsg(kRefresh_StatusBar);
+}
+
+void CPanel::AddToArchive()
+{
+ if (!Is_IO_FS_Folder())
+ {
+ MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ if (indices.Size() == 0)
+ {
+ MessageBox_Error_LangID(IDS_SELECT_FILES);
+ return;
+ }
+ UString destCurDirPrefix = GetFsPath();
+ if (IsFSDrivesFolder())
+ destCurDirPrefix = ROOT_FS_FOLDER;
+ UStringVector names;
+ GetFilePaths(indices, names);
+ UString baseName;
+ const UString arcName = CreateArchiveName(names,
+ false, // isHash
+ NULL, // CFileInfo *fi
+ baseName);
+ const HRESULT res = CompressFiles(destCurDirPrefix, arcName, L"",
+ true, // addExtension
+ names,
+ false, // email
+ true, // showDialog
+ false); // waitFinish
+ if (res != S_OK)
+ {
+ if (destCurDirPrefix.Len() >= MAX_PATH)
+ MessageBox_Error_LangID(IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER);
+ }
+ // KillSelection();
+}
+
+// function from ContextMenu.cpp
+UString GetSubFolderNameForExtract(const UString &arcPath);
+
+static UString GetSubFolderNameForExtract2(const UString &arcPath)
+{
+ int slashPos = arcPath.ReverseFind_PathSepar();
+ UString s;
+ UString name = arcPath;
+ if (slashPos >= 0)
+ {
+ s = arcPath.Left((unsigned)(slashPos + 1));
+ name = arcPath.Ptr((unsigned)(slashPos + 1));
+ }
+ s += GetSubFolderNameForExtract(name);
+ return s;
+}
+
+
+int CPanel::FindDir_InOperatedList(const CRecordVector<UInt32> &operatedIndices) const
+{
+ const bool *isDirVector = &_isDirVector.Front();
+ const UInt32 *indices = &operatedIndices.Front();
+ const unsigned numItems = operatedIndices.Size();
+ for (unsigned i = 0; i < numItems; i++)
+ if (isDirVector[indices[i]])
+ return (int)i;
+ return -1;
+}
+
+
+void CPanel::GetFilePaths(const CRecordVector<UInt32> &operatedIndices, UStringVector &paths) const
+{
+ paths.ClearAndReserve(operatedIndices.Size());
+ UString path = GetFsPath();
+ const unsigned prefixLen = path.Len();
+ const UInt32 *indices = &operatedIndices.Front();
+ const unsigned numItems = operatedIndices.Size();
+ // for (unsigned y = 0; y < 10000; y++, paths.Clear())
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ path.DeleteFrom(prefixLen);
+ Add_ItemRelPath2_To_String(indices[i], path);
+ // ODS_U(path)
+ paths.AddInReserved(path);
+ }
+}
+
+
+void CPanel::ExtractArchives()
+{
+ if (_parentFolders.Size() > 0)
+ {
+ _panelCallback->OnCopy(false, false);
+ return;
+ }
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ if (indices.IsEmpty() || FindDir_InOperatedList(indices) != -1)
+ {
+ MessageBox_Error_LangID(IDS_SELECT_FILES);
+ return;
+ }
+ UStringVector paths;
+ GetFilePaths(indices, paths);
+ UString outFolder = GetFsPath();
+ if (indices.Size() == 1)
+ outFolder += GetSubFolderNameForExtract2(GetItemRelPath(indices[0]));
+ else
+ outFolder += '*';
+ outFolder.Add_PathSepar();
+
+ CContextMenuInfo ci;
+ ci.Load();
+
+ ::ExtractArchives(paths, outFolder
+ , true // showDialog
+ , false // elimDup
+ , ci.WriteZone
+ );
+}
+
+/*
+static void AddValuePair(UINT resourceID, UInt64 value, UString &s)
+{
+ AddLangString(s, resourceID);
+ char sz[32];
+ s += ": ";
+ ConvertUInt64ToString(value, sz);
+ s += sz;
+ s.Add_LF();
+}
+
+// now we don't need CThreadTest, since now we call CopyTo for "test command
+
+class CThreadTest: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt();
+public:
+ CRecordVector<UInt32> Indices;
+ CExtractCallbackImp *ExtractCallbackSpec;
+ CMyComPtr<IFolderArchiveExtractCallback> ExtractCallback;
+ CMyComPtr<IArchiveFolder> ArchiveFolder;
+};
+
+HRESULT CThreadTest::ProcessVirt()
+{
+ RINOK(ArchiveFolder->Extract(&Indices[0], Indices.Size(),
+ true, // includeAltStreams
+ false, // replaceAltStreamColon
+ NExtract::NPathMode::kFullPathnames,
+ NExtract::NOverwriteMode::kAskBefore,
+ NULL, // path
+ BoolToInt(true), // testMode
+ ExtractCallback));
+ if (ExtractCallbackSpec->IsOK())
+ {
+ UString s;
+ AddValuePair(IDS_PROP_FOLDERS, ExtractCallbackSpec->NumFolders, s);
+ AddValuePair(IDS_PROP_FILES, ExtractCallbackSpec->NumFiles, s);
+ // AddValuePair(IDS_PROP_SIZE, ExtractCallbackSpec->UnpackSize, s);
+ // AddSizePair(IDS_COMPRESSED_COLON, Stat.PackSize, s);
+ s.Add_LF();
+ AddLangString(s, IDS_MESSAGE_NO_ERRORS);
+ FinalMessage.OkMessage.Message = s;
+ }
+ return S_OK;
+}
+
+static void AddSizePair(UInt32 langID, UInt64 value, UString &s)
+{
+ char sz[32];
+ AddLangString(s, langID);
+ s += L' ';
+ ConvertUInt64ToString(value, sz);
+ s += sz;
+ ConvertUInt64ToString(value >> 20, sz);
+ s += " (";
+ s += sz;
+ s += " MB)";
+ s.Add_LF();
+}
+*/
+
+void CPanel::TestArchives()
+{
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_OperSmart(indices);
+ CMyComPtr<IArchiveFolder> archiveFolder;
+ _folder.QueryInterface(IID_IArchiveFolder, &archiveFolder);
+ if (archiveFolder)
+ {
+ CCopyToOptions options;
+ options.streamMode = true;
+ options.showErrorMessages = true;
+ options.testMode = true;
+
+ UStringVector messages;
+ HRESULT res = CopyTo(options, indices, &messages);
+ if (res != S_OK)
+ {
+ if (res != E_ABORT)
+ MessageBox_Error_HRESULT(res);
+ }
+ return;
+
+ /*
+ {
+ CThreadTest extracter;
+
+ extracter.ArchiveFolder = archiveFolder;
+ extracter.ExtractCallbackSpec = new CExtractCallbackImp;
+ extracter.ExtractCallback = extracter.ExtractCallbackSpec;
+ extracter.ExtractCallbackSpec->ProgressDialog = &extracter.ProgressDialog;
+ if (!_parentFolders.IsEmpty())
+ {
+ const CFolderLink &fl = _parentFolders.Back();
+ extracter.ExtractCallbackSpec->PasswordIsDefined = fl.UsePassword;
+ extracter.ExtractCallbackSpec->Password = fl.Password;
+ }
+
+ if (indices.IsEmpty())
+ return;
+
+ extracter.Indices = indices;
+
+ const UString title = LangString(IDS_PROGRESS_TESTING);
+
+ extracter.ProgressDialog.CompressingMode = false;
+ extracter.ProgressDialog.MainWindow = GetParent();
+ extracter.ProgressDialog.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+ extracter.ProgressDialog.MainAddTitle = title + L' ';
+
+ extracter.ExtractCallbackSpec->OverwriteMode = NExtract::NOverwriteMode::kAskBefore;
+ extracter.ExtractCallbackSpec->Init();
+
+ if (extracter.Create(title, GetParent()) != S_OK)
+ return;
+
+ }
+ RefreshTitleAlways();
+ return;
+ */
+ }
+
+ if (!IsFSFolder())
+ {
+ MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ UStringVector paths;
+ GetFilePaths(indices, paths);
+ if (paths.IsEmpty())
+ {
+ MessageBox_Error_LangID(IDS_SELECT_FILES);
+ return;
+ }
+ ::TestArchives(paths);
+}
diff --git a/CPP/7zip/UI/FileManager/Panel.h b/CPP/7zip/UI/FileManager/Panel.h
new file mode 100644
index 0000000..e512cad
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Panel.h
@@ -0,0 +1,1016 @@
+// Panel.h
+
+#ifndef ZIP7_INC_PANEL_H
+#define ZIP7_INC_PANEL_H
+
+#include "../../../Common/MyWindows.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Handle.h"
+#include "../../../Windows/PropVariantConv.h"
+#include "../../../Windows/Synchronization.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+#include "../../../Windows/Control/ListView.h"
+#include "../../../Windows/Control/ReBar.h"
+#include "../../../Windows/Control/Static.h"
+#include "../../../Windows/Control/StatusBar.h"
+#include "../../../Windows/Control/ToolBar.h"
+#include "../../../Windows/Control/Window2.h"
+
+#include "../../Archive/IArchive.h"
+
+#include "ExtractCallback.h"
+
+#include "AppState.h"
+#include "IFolder.h"
+#include "MyCom2.h"
+#include "ProgressDialog2.h"
+#include "SysIconUtils.h"
+
+#ifdef UNDER_CE
+#define NON_CE_VAR(_v_)
+#else
+#define NON_CE_VAR(_v_) _v_
+#endif
+
+const int kParentFolderID = 100;
+
+const unsigned kParentIndex = (unsigned)(int)-1;
+const UInt32 kParentIndex_UInt32 = (UInt32)(Int32)kParentIndex;
+
+#if !defined(_WIN32) || defined(UNDER_CE)
+#define ROOT_FS_FOLDER L"\\"
+#else
+#define ROOT_FS_FOLDER L"C:\\"
+#endif
+
+Z7_PURE_INTERFACES_BEGIN
+
+DECLARE_INTERFACE(CPanelCallback)
+{
+ virtual void OnTab() = 0;
+ virtual void SetFocusToPath(unsigned index) = 0;
+ virtual void OnCopy(bool move, bool copyToSame) = 0;
+ virtual void OnSetSameFolder() = 0;
+ virtual void OnSetSubFolder() = 0;
+ virtual void PanelWasFocused() = 0;
+ virtual void DragBegin() = 0;
+ virtual void DragEnd() = 0;
+ virtual void RefreshTitle(bool always) = 0;
+};
+Z7_PURE_INTERFACES_END
+
+void PanelCopyItems();
+
+
+struct CPropColumn
+{
+ int Order;
+ PROPID ID;
+ VARTYPE Type;
+ bool IsVisible;
+ bool IsRawProp;
+ UInt32 Width;
+ UString Name;
+
+ bool IsEqualTo(const CPropColumn &a) const
+ {
+ return Order == a.Order
+ && ID == a.ID
+ && Type == a.Type
+ && IsVisible == a.IsVisible
+ && IsRawProp == a.IsRawProp
+ && Width == a.Width
+ && Name == a.Name;
+ }
+
+ int Compare(const CPropColumn &a) const { return MyCompare(Order, a.Order); }
+
+ int Compare_NameFirst(const CPropColumn &a) const
+ {
+ if (ID == kpidName)
+ {
+ if (a.ID != kpidName)
+ return -1;
+ }
+ else if (a.ID == kpidName)
+ return 1;
+ return MyCompare(Order, a.Order);
+ }
+};
+
+
+class CPropColumns: public CObjectVector<CPropColumn>
+{
+public:
+ int FindItem_for_PropID(PROPID id) const
+ {
+ FOR_VECTOR (i, (*this))
+ if ((*this)[i].ID == id)
+ return (int)i;
+ return -1;
+ }
+
+ bool IsEqualTo(const CPropColumns &props) const
+ {
+ if (Size() != props.Size())
+ return false;
+ FOR_VECTOR (i, (*this))
+ if (!(*this)[i].IsEqualTo(props[i]))
+ return false;
+ return true;
+ }
+};
+
+
+struct CTempFileInfo
+{
+ UInt32 FileIndex; // index of file in folder
+ UString RelPath; // Relative path of file from Folder
+ FString FolderPath;
+ FString FilePath;
+ NWindows::NFile::NFind::CFileInfo FileInfo;
+ bool NeedDelete;
+
+ CTempFileInfo(): FileIndex((UInt32)(Int32)-1), NeedDelete(false) {}
+ void DeleteDirAndFile() const
+ {
+ if (NeedDelete)
+ {
+ NWindows::NFile::NDir::DeleteFileAlways(FilePath);
+ NWindows::NFile::NDir::RemoveDir(FolderPath);
+ }
+ }
+ bool WasChanged(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
+ {
+ return newFileInfo.Size != FileInfo.Size ||
+ CompareFileTime(&newFileInfo.MTime, &FileInfo.MTime) != 0;
+ }
+};
+
+struct CFolderLink: public CTempFileInfo
+{
+ NWindows::NDLL::CLibrary Library;
+ CMyComPtr<IFolderFolder> ParentFolder; // can be NULL, if parent is FS folder (in _parentFolders[0])
+ UString ParentFolderPath; // including tail slash (doesn't include paths parts of parent in next level)
+ bool UsePassword;
+ UString Password;
+ bool IsVirtual;
+
+ UString VirtualPath; // without tail slash
+ CFolderLink(): UsePassword(false), IsVirtual(false) {}
+
+ bool WasChanged(const NWindows::NFile::NFind::CFileInfo &newFileInfo) const
+ {
+ return IsVirtual || CTempFileInfo::WasChanged(newFileInfo);
+ }
+
+};
+
+enum MyMessages
+{
+ // we can use WM_USER, since we have defined new window class.
+ // so we don't need WM_APP.
+ kShiftSelectMessage = WM_USER + 1,
+ kReLoadMessage,
+ kSetFocusToListView,
+ kOpenItemChanged,
+ kRefresh_StatusBar
+ #ifdef UNDER_CE
+ , kRefresh_HeaderComboBox
+ #endif
+};
+
+UString GetFolderPath(IFolderFolder *folder);
+
+class CPanel;
+
+class CMyListView Z7_final: public NWindows::NControl::CListView2
+{
+ // ~CMyListView() ZIP7_eq_delete;
+ // CMyListView() ZIP7_eq_delete;
+public:
+ // CMyListView() {}
+ // ~CMyListView() Z7_DESTRUCTOR_override {} // change it
+ CPanel *_panel;
+ LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+};
+
+/*
+class CMyComboBox: public NWindows::NControl::CComboBoxEx
+{
+public:
+ WNDPROC _origWindowProc;
+ CPanel *_panel;
+ LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+*/
+class CMyComboBoxEdit: public NWindows::NControl::CEdit
+{
+public:
+ WNDPROC _origWindowProc;
+ CPanel *_panel;
+ LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+
+struct CSelectedState
+{
+ int FocusedItem;
+ bool SelectFocused;
+ bool FocusedName_Defined;
+ bool CalledFromTimer;
+ UString FocusedName;
+ UStringVector SelectedNames;
+
+ CSelectedState():
+ FocusedItem(-1),
+ SelectFocused(true),
+ FocusedName_Defined(false),
+ CalledFromTimer(false)
+ {}
+};
+
+#ifdef UNDER_CE
+#define MY_NMLISTVIEW_NMITEMACTIVATE NMLISTVIEW
+#else
+#define MY_NMLISTVIEW_NMITEMACTIVATE NMITEMACTIVATE
+#endif
+
+struct CCopyToOptions
+{
+ bool streamMode;
+ bool moveMode;
+ bool testMode;
+ bool includeAltStreams;
+ bool replaceAltStreamChars;
+ bool showErrorMessages;
+
+ bool NeedRegistryZone;
+ NExtract::NZoneIdMode::EEnum ZoneIdMode;
+
+ UString folder;
+
+ UStringVector hashMethods;
+
+ CVirtFileSystem *VirtFileSystemSpec;
+ ISequentialOutStream *VirtFileSystem;
+
+ CCopyToOptions():
+ streamMode(false),
+ moveMode(false),
+ testMode(false),
+ includeAltStreams(true),
+ replaceAltStreamChars(false),
+ showErrorMessages(false),
+ NeedRegistryZone(true),
+ ZoneIdMode(NExtract::NZoneIdMode::kNone),
+ VirtFileSystemSpec(NULL),
+ VirtFileSystem(NULL)
+ {}
+};
+
+
+
+struct COpenResult
+{
+ // bool needOpenArc;
+ // out:
+ bool ArchiveIsOpened;
+ bool Encrypted;
+ UString ErrorMessage;
+
+ COpenResult():
+ // needOpenArc(false),
+ ArchiveIsOpened(false), Encrypted(false) {}
+};
+
+
+
+
+class CPanel Z7_final: public NWindows::NControl::CWindow2
+{
+ CExtToIconMap _extToIconMap;
+ UINT _baseID;
+ unsigned _comboBoxID;
+ UINT _statusBarID;
+
+ CAppState *_appState;
+
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam, LRESULT &result) Z7_override;
+ virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+ virtual bool OnCreate(CREATESTRUCT *createStruct) Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual void OnDestroy() Z7_override;
+ virtual bool OnNotify(UINT controlID, LPNMHDR lParam, LRESULT &result) Z7_override;
+
+ void AddComboBoxItem(const UString &name, int iconIndex, int indent, bool addToList);
+
+ bool OnComboBoxCommand(UINT code, LPARAM param, LRESULT &result);
+
+ #ifndef UNDER_CE
+
+ LRESULT OnNotifyComboBoxEnter(const UString &s);
+ bool OnNotifyComboBoxEndEdit(PNMCBEENDEDITW info, LRESULT &result);
+ #ifndef _UNICODE
+ bool OnNotifyComboBoxEndEdit(PNMCBEENDEDIT info, LRESULT &result);
+ #endif
+
+ #endif
+
+ bool OnNotifyReBar(LPNMHDR lParam, LRESULT &result);
+ bool OnNotifyComboBox(LPNMHDR lParam, LRESULT &result);
+ void OnItemChanged(NMLISTVIEW *item);
+ void OnNotifyActivateItems();
+ bool OnNotifyList(LPNMHDR lParam, LRESULT &result);
+ void OnDrag(LPNMLISTVIEW nmListView, bool isRightButton = false);
+ bool OnKeyDown(LPNMLVKEYDOWN keyDownInfo, LRESULT &result);
+ BOOL OnBeginLabelEdit(LV_DISPINFOW * lpnmh);
+ BOOL OnEndLabelEdit(LV_DISPINFOW * lpnmh);
+ void OnColumnClick(LPNMLISTVIEW info);
+ bool OnCustomDraw(LPNMLVCUSTOMDRAW lplvcd, LRESULT &result);
+
+
+public:
+ HWND _mainWindow;
+ CPanelCallback *_panelCallback;
+
+ void SysIconsWereChanged() { _extToIconMap.Clear(); }
+
+ void DeleteItems(bool toRecycleBin);
+ void CreateFolder();
+ void CreateFile();
+ bool CorrectFsPath(const UString &path, UString &result);
+ // bool IsPathForPlugin(const UString &path);
+
+private:
+
+ void ChangeWindowSize(int xSize, int ySize);
+
+ HRESULT InitColumns();
+ void DeleteColumn(unsigned index);
+ void AddColumn(const CPropColumn &prop);
+
+ void SetFocusedSelectedItem(int index, bool select);
+
+ void OnShiftSelectMessage();
+ void OnArrowWithShift();
+
+ void OnInsert();
+ // void OnUpWithShift();
+ // void OnDownWithShift();
+public:
+ void UpdateSelection();
+ void SelectSpec(bool selectMode);
+ void SelectByType(bool selectMode);
+ void SelectAll(bool selectMode);
+ void InvertSelection();
+private:
+
+ // UString GetFileType(UInt32 index);
+ LRESULT SetItemText(LVITEMW &item);
+
+ // CRecordVector<PROPID> m_ColumnsPropIDs;
+
+public:
+ NWindows::NControl::CReBar _headerReBar;
+ NWindows::NControl::CToolBar _headerToolBar;
+ NWindows::NControl::
+ #ifdef UNDER_CE
+ CComboBox
+ #else
+ CComboBoxEx
+ #endif
+ _headerComboBox;
+ UStringVector ComboBoxPaths;
+ // CMyComboBox _headerComboBox;
+ CMyComboBoxEdit _comboBoxEdit;
+ CMyListView _listView;
+ bool _thereAre_ListView_Items;
+ NWindows::NControl::CStatusBar _statusBar;
+ bool _lastFocusedIsList;
+ // NWindows::NControl::CStatusBar _statusBar2;
+
+ DWORD _exStyle;
+ bool _showDots;
+ bool _showRealFileIcons;
+ // bool _virtualMode;
+ // CUIntVector _realIndices;
+ bool _enableItemChangeNotify;
+ bool _mySelectMode;
+
+ int _timestampLevel;
+
+
+ void RedrawListItems()
+ {
+ _listView.RedrawAllItems();
+ }
+
+
+ CBoolVector _selectedStatusVector;
+
+ CSelectedState _selectedState;
+ bool _thereAreDeletedItems;
+ bool _markDeletedItems;
+
+ bool PanelCreated;
+
+ void DeleteListItems()
+ {
+ if (_thereAre_ListView_Items)
+ {
+ bool b = _enableItemChangeNotify;
+ _enableItemChangeNotify = false;
+ _listView.DeleteAllItems();
+ _thereAre_ListView_Items = false;
+ _enableItemChangeNotify = b;
+ }
+ }
+
+ HWND GetParent() const;
+
+ UInt32 GetRealIndex(const LVITEMW &item) const
+ {
+ /*
+ if (_virtualMode)
+ return _realIndices[item.iItem];
+ */
+ return (UInt32)item.lParam;
+ }
+
+ unsigned GetRealItemIndex(int indexInListView) const
+ {
+ /*
+ if (_virtualMode)
+ return indexInListView;
+ */
+ LPARAM param;
+ if (!_listView.GetItemParam((unsigned)indexInListView, param))
+ throw 1;
+ return (unsigned)param;
+ }
+
+ UInt32 _listViewMode;
+ int _xSize;
+
+ bool _flatMode;
+ bool _flatModeForDisk;
+ bool _flatModeForArc;
+
+ // bool _showNtfsStrems_Mode;
+ // bool _showNtfsStrems_ModeForDisk;
+ // bool _showNtfsStrems_ModeForArc;
+
+ bool _dontShowMode;
+
+
+ UString _currentFolderPrefix;
+
+ CObjectVector<CFolderLink> _parentFolders;
+ NWindows::NDLL::CLibrary _library;
+
+ CMyComPtr<IFolderFolder> _folder;
+ CBoolVector _isDirVector;
+ CMyComPtr<IFolderCompare> _folderCompare;
+ CMyComPtr<IFolderGetItemName> _folderGetItemName;
+ CMyComPtr<IArchiveGetRawProps> _folderRawProps;
+ CMyComPtr<IFolderAltStreams> _folderAltStreams;
+ CMyComPtr<IFolderOperations> _folderOperations;
+
+
+ // for drag and drop highliting
+ int m_DropHighlighted_SelectionIndex;
+ // int m_SubFolderIndex; // realIndex of item in m_Panel list (if drop cursor to that item)
+ UString m_DropHighlighted_SubFolderName; // name of folder in m_Panel list (if drop cursor to that folder)
+
+ void ReleaseFolder();
+ void SetNewFolder(IFolderFolder *newFolder);
+
+ // CMyComPtr<IFolderGetSystemIconIndex> _folderGetSystemIconIndex;
+
+ UStringVector _fastFolders;
+
+ void GetSelectedNames(UStringVector &selectedNames);
+ void SaveSelectedState(CSelectedState &s);
+ HRESULT RefreshListCtrl(const CSelectedState &s);
+ HRESULT RefreshListCtrl_SaveFocused(bool onTimer = false);
+
+ // UInt32 GetItem_Attrib(UInt32 itemIndex) const;
+
+ bool GetItem_BoolProp(UInt32 itemIndex, PROPID propID) const;
+
+ bool IsItem_Deleted(unsigned itemIndex) const;
+ bool IsItem_Folder(unsigned itemIndex) const;
+ bool IsItem_AltStream(unsigned itemIndex) const;
+
+ UString GetItemName(unsigned itemIndex) const;
+ UString GetItemName_for_Copy(unsigned itemIndex) const;
+ void GetItemName(unsigned itemIndex, UString &s) const;
+ UString GetItemPrefix(unsigned itemIndex) const;
+ UString GetItemRelPath(unsigned itemIndex) const;
+ UString GetItemRelPath2(unsigned itemIndex) const;
+
+ void Add_ItemRelPath2_To_String(unsigned itemIndex, UString &s) const;
+
+ UString GetItemFullPath(unsigned itemIndex) const;
+ UInt64 GetItem_UInt64Prop(unsigned itemIndex, PROPID propID) const;
+ UInt64 GetItemSize(unsigned itemIndex) const;
+
+ ////////////////////////
+ // PanelFolderChange.cpp
+
+ void SetToRootFolder();
+ HRESULT BindToPath(const UString &fullPath, const UString &arcFormat, COpenResult &openRes); // can be prefix
+ HRESULT BindToPathAndRefresh(const UString &path);
+ void OpenDrivesFolder();
+
+ void SetBookmark(unsigned index);
+ void OpenBookmark(unsigned index);
+
+ void LoadFullPath();
+ void LoadFullPathAndShow();
+ void FoldersHistory();
+ void OpenParentFolder();
+ void CloseOneLevel();
+ void CloseOpenFolders();
+ void OpenRootFolder();
+
+ UString GetParentDirPrefix() const;
+
+ HRESULT Create(HWND mainWindow, HWND parentWindow,
+ UINT id,
+ const UString ¤tFolderPrefix,
+ const UString &arcFormat,
+ CPanelCallback *panelCallback,
+ CAppState *appState,
+ bool needOpenArc,
+ COpenResult &openRes);
+
+ void SetFocusToList();
+ void SetFocusToLastRememberedItem();
+
+
+ void SaveListViewInfo();
+
+ CPanel() :
+ _thereAre_ListView_Items(false),
+ _exStyle(0),
+ _showDots(false),
+ _showRealFileIcons(false),
+ // _virtualMode(flase),
+ _enableItemChangeNotify(true),
+ _mySelectMode(false),
+ _timestampLevel(kTimestampPrintLevel_MIN),
+
+ _thereAreDeletedItems(false),
+ _markDeletedItems(true),
+ PanelCreated(false),
+
+ _listViewMode(3),
+ _xSize(300),
+
+ _flatMode(false),
+ _flatModeForDisk(false),
+ _flatModeForArc(false),
+
+ // _showNtfsStrems_Mode(false),
+ // _showNtfsStrems_ModeForDisk(false),
+ // _showNtfsStrems_ModeForArc(false),
+
+ _dontShowMode(false),
+
+ m_DropHighlighted_SelectionIndex(-1),
+
+ _needSaveInfo(false),
+ _startGroupSelect(0),
+ _selectionIsDefined(false)
+ {}
+
+ void SetExtendedStyle()
+ {
+ if (_listView)
+ _listView.SetExtendedListViewStyle(_exStyle);
+ }
+
+
+ bool _needSaveInfo;
+ UString _typeIDString;
+ CListViewInfo _listViewInfo;
+
+ CPropColumns _columns;
+ CPropColumns _visibleColumns;
+
+ PROPID _sortID;
+ // int _sortIndex;
+ bool _ascending;
+ Int32 _isRawSortProp;
+
+ void SetSortRawStatus();
+
+ void Release();
+ ~CPanel() Z7_DESTRUCTOR_override;
+ void OnLeftClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate);
+ bool OnRightClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate, LRESULT &result);
+ void ShowColumnsContextMenu(int x, int y);
+
+ void OnTimer();
+ void OnReload(bool onTimer = false);
+ bool OnContextMenu(HANDLE windowHandle, int xPos, int yPos);
+
+ CMyComPtr<IContextMenu> _sevenZipContextMenu;
+ CMyComPtr<IContextMenu> _systemContextMenu;
+
+ HRESULT CreateShellContextMenu(
+ const CRecordVector<UInt32> &operatedIndices,
+ CMyComPtr<IContextMenu> &systemContextMenu);
+
+ void CreateSystemMenu(HMENU menu,
+ bool showExtendedVerbs,
+ const CRecordVector<UInt32> &operatedIndices,
+ CMyComPtr<IContextMenu> &systemContextMenu);
+
+ void CreateSevenZipMenu(HMENU menu,
+ bool showExtendedVerbs,
+ const CRecordVector<UInt32> &operatedIndices,
+ int firstDirIndex,
+ CMyComPtr<IContextMenu> &sevenZipContextMenu);
+
+ void CreateFileMenu(HMENU menu,
+ CMyComPtr<IContextMenu> &sevenZipContextMenu,
+ CMyComPtr<IContextMenu> &systemContextMenu,
+ bool programMenu);
+
+ void CreateFileMenu(HMENU menu);
+ bool InvokePluginCommand(unsigned id);
+ bool InvokePluginCommand(unsigned id, IContextMenu *sevenZipContextMenu,
+ IContextMenu *systemContextMenu);
+
+ void InvokeSystemCommand(const char *command);
+ void Properties();
+ void EditCut();
+ void EditCopy();
+ void EditPaste();
+
+ int _startGroupSelect;
+
+ bool _selectionIsDefined;
+ bool _selectMark;
+ int _prevFocusedItem;
+
+
+ // void SortItems(int index);
+ void SortItemsWithPropID(PROPID propID);
+
+ void Get_ItemIndices_Selected(CRecordVector<UInt32> &indices) const;
+ void Get_ItemIndices_Operated(CRecordVector<UInt32> &indices) const;
+ void Get_ItemIndices_All(CRecordVector<UInt32> &indices) const;
+ void Get_ItemIndices_OperSmart(CRecordVector<UInt32> &indices) const;
+ // void GetOperatedListViewIndices(CRecordVector<UInt32> &indices) const;
+ void KillSelection();
+
+ UString GetFolderTypeID() const;
+
+ bool IsFolderTypeEqTo(const char *s) const;
+ bool IsRootFolder() const;
+ bool IsFSFolder() const;
+ bool IsFSDrivesFolder() const;
+ bool IsAltStreamsFolder() const;
+ bool IsArcFolder() const;
+ bool IsHashFolder() const;
+
+ /*
+ c:\Dir
+ Computer\
+ \\?\
+ \\.\
+ */
+ bool Is_IO_FS_Folder() const
+ {
+ return IsFSFolder() || IsFSDrivesFolder() || IsAltStreamsFolder();
+ }
+
+ bool Is_Slow_Icon_Folder() const
+ {
+ return IsFSFolder() || IsAltStreamsFolder();
+ }
+
+ // bool IsFsOrDrivesFolder() const { return IsFSFolder() || IsFSDrivesFolder(); }
+ bool IsDeviceDrivesPrefix() const { return _currentFolderPrefix == L"\\\\.\\"; }
+ bool IsSuperDrivesPrefix() const { return _currentFolderPrefix == L"\\\\?\\"; }
+
+ /*
+ c:\Dir
+ Computer\
+ \\?\
+ */
+ bool IsFsOrPureDrivesFolder() const { return IsFSFolder() || (IsFSDrivesFolder() && !IsDeviceDrivesPrefix()); }
+
+ /*
+ c:\Dir
+ Computer\
+ \\?\
+ \\SERVER\
+ */
+ bool IsFolder_with_FsItems() const
+ {
+ if (IsFsOrPureDrivesFolder())
+ return true;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ FString prefix = us2fs(GetFsPath());
+ return (prefix.Len() == NWindows::NFile::NName::GetNetworkServerPrefixSize(prefix));
+ #else
+ return false;
+ #endif
+ }
+
+ UString GetFsPath() const;
+ UString GetDriveOrNetworkPrefix() const;
+
+ bool DoesItSupportOperations() const { return _folderOperations != NULL; }
+ bool IsThereReadOnlyFolder() const;
+ bool CheckBeforeUpdate(UINT resourceID);
+
+ bool _processTimer;
+ bool _processNotify;
+ bool _processStatusBar;
+
+ class CDisableTimerProcessing
+ {
+ Z7_CLASS_NO_COPY(CDisableTimerProcessing)
+
+ bool _processTimer;
+ CPanel &_panel;
+
+ public:
+
+ CDisableTimerProcessing(CPanel &panel): _panel(panel) { Disable(); }
+ ~CDisableTimerProcessing() { Restore(); }
+ void Disable()
+ {
+ _processTimer = _panel._processTimer;
+ _panel._processTimer = false;
+ }
+ void Restore()
+ {
+ _panel._processTimer = _processTimer;
+ }
+ };
+
+ class CDisableTimerProcessing2
+ {
+ Z7_CLASS_NO_COPY(CDisableTimerProcessing2)
+
+ bool _processTimer;
+ CPanel *_panel;
+
+ public:
+
+ CDisableTimerProcessing2(CPanel *panel): _processTimer(true), _panel(panel) { Disable(); }
+ ~CDisableTimerProcessing2() { Restore(); }
+ void Disable()
+ {
+ if (_panel)
+ {
+ _processTimer = _panel->_processTimer;
+ _panel->_processTimer = false;
+ }
+ }
+ void Restore()
+ {
+ if (_panel)
+ {
+ _panel->_processTimer = _processTimer;
+ _panel = NULL;
+ }
+ }
+ };
+
+ class CDisableNotify
+ {
+ Z7_CLASS_NO_COPY(CDisableNotify)
+
+ bool _processNotify;
+ bool _processStatusBar;
+
+ CPanel &_panel;
+
+ public:
+
+ CDisableNotify(CPanel &panel): _panel(panel) { Disable(); }
+ ~CDisableNotify() { Restore(); }
+ void Disable()
+ {
+ _processNotify = _panel._processNotify;
+ _processStatusBar = _panel._processStatusBar;
+ _panel._processNotify = false;
+ _panel._processStatusBar = false;
+ }
+ void SetMemMode_Enable()
+ {
+ _processNotify = true;
+ _processStatusBar = true;
+ }
+ void Restore()
+ {
+ _panel._processNotify = _processNotify;
+ _panel._processStatusBar = _processStatusBar;
+ }
+ };
+
+ void InvalidateList() { _listView.InvalidateRect(NULL, true); }
+
+ HRESULT RefreshListCtrl();
+
+
+ // void MessageBox_Info(LPCWSTR message, LPCWSTR caption) const;
+ // void MessageBox_Warning(LPCWSTR message) const;
+ void MessageBox_Error_Caption(LPCWSTR message, LPCWSTR caption) const;
+ void MessageBox_Error(LPCWSTR message) const;
+ void MessageBox_Error_HRESULT_Caption(HRESULT errorCode, LPCWSTR caption) const;
+ void MessageBox_Error_HRESULT(HRESULT errorCode) const;
+ void MessageBox_Error_2Lines_Message_HRESULT(LPCWSTR message, HRESULT errorCode) const;
+ void MessageBox_LastError(LPCWSTR caption) const;
+ void MessageBox_LastError() const;
+ void MessageBox_Error_LangID(UINT resourceID) const;
+ void MessageBox_Error_UnsupportOperation() const;
+ // void MessageBoxErrorForUpdate(HRESULT errorCode, UINT resourceID);
+
+
+ void OpenAltStreams();
+
+ void OpenFocusedItemAsInternal(const wchar_t *type = NULL);
+ void OpenSelectedItems(bool internal);
+
+ void OpenFolderExternal(unsigned index);
+
+ void OpenFolder(unsigned index);
+ HRESULT OpenParentArchiveFolder();
+
+ HRESULT OpenAsArc(IInStream *inStream,
+ const CTempFileInfo &tempFileInfo,
+ const UString &virtualFilePath,
+ const UString &arcFormat,
+ COpenResult &openRes);
+
+ HRESULT OpenAsArc_Msg(IInStream *inStream,
+ const CTempFileInfo &tempFileInfo,
+ const UString &virtualFilePath,
+ const UString &arcFormat
+ // , bool showErrorMessage
+ );
+
+ HRESULT OpenAsArc_Name(const UString &relPath, const UString &arcFormat
+ // , bool showErrorMessage
+ );
+ HRESULT OpenAsArc_Index(unsigned index, const wchar_t *type /* = NULL */
+ // , bool showErrorMessage
+ );
+
+ void OpenItemInArchive(unsigned index, bool tryInternal, bool tryExternal,
+ bool editMode, bool useEditor, const wchar_t *type = NULL);
+
+ HRESULT OnOpenItemChanged(UInt32 index, const wchar_t *fullFilePath, bool usePassword, const UString &password);
+ LRESULT OnOpenItemChanged(LPARAM lParam);
+
+ bool IsVirus_Message(const UString &name);
+ void OpenItem(unsigned index, bool tryInternal, bool tryExternal, const wchar_t *type = NULL);
+ void EditItem(bool useEditor);
+ void EditItem(unsigned index, bool useEditor);
+
+ void RenameFile();
+ void ChangeComment();
+
+ void SetListViewMode(UInt32 index);
+ UInt32 GetListViewMode() const { return _listViewMode; }
+ PROPID GetSortID() const { return _sortID; }
+
+ void ChangeFlatMode();
+ void Change_ShowNtfsStrems_Mode();
+ bool GetFlatMode() const { return _flatMode; }
+ // bool Get_ShowNtfsStrems_Mode() const { return _showNtfsStrems_Mode; }
+
+ bool AutoRefresh_Mode;
+ void Set_AutoRefresh_Mode(bool mode)
+ {
+ AutoRefresh_Mode = mode;
+ }
+
+ void Post_Refresh_StatusBar();
+ void Refresh_StatusBar();
+
+ void AddToArchive();
+
+ int FindDir_InOperatedList(const CRecordVector<UInt32> &indices) const;
+ void GetFilePaths(const CRecordVector<UInt32> &indices, UStringVector &paths) const;
+ void ExtractArchives();
+ void TestArchives();
+
+
+ HRESULT CopyTo(CCopyToOptions &options,
+ const CRecordVector<UInt32> &indices,
+ UStringVector *messages,
+ bool &usePassword, UString &password,
+ const UStringVector *filePaths = NULL);
+
+ HRESULT CopyTo(CCopyToOptions &options,
+ const CRecordVector<UInt32> &indices,
+ UStringVector *messages)
+ {
+ bool usePassword = false;
+ UString password;
+ if (_parentFolders.Size() > 0)
+ {
+ const CFolderLink &fl = _parentFolders.Back();
+ usePassword = fl.UsePassword;
+ password = fl.Password;
+ }
+ return CopyTo(options, indices, messages, usePassword, password);
+ }
+
+ HRESULT CopyFsItems(CCopyToOptions &options,
+ const UStringVector &filePaths,
+ UStringVector *messages)
+ {
+ bool usePassword = false;
+ UString password;
+ CRecordVector<UInt32> indices;
+ return CopyTo(options, indices, messages, usePassword, password, &filePaths);
+ }
+
+
+ HRESULT CopyFrom(bool moveMode, const UString &folderPrefix, const UStringVector &filePaths,
+ bool showErrorMessages, UStringVector *messages);
+
+ void CopyFromNoAsk(bool moveMode, const UStringVector &filePaths);
+
+ void CompressDropFiles(
+ const UStringVector &filePaths,
+ const UString &folderPath,
+ bool createNewArchive,
+ bool moveMode,
+ UInt32 sourceFlags,
+ UInt32 &targetFlags);
+
+ void RefreshTitle(bool always = false) { _panelCallback->RefreshTitle(always); }
+ void RefreshTitleAlways() { RefreshTitle(true); }
+
+ UString GetItemsInfoString(const CRecordVector<UInt32> &indices);
+};
+
+class CMyBuffer
+{
+ void *_data;
+public:
+ CMyBuffer(): _data(NULL) {}
+ operator void *() { return _data; }
+ bool Allocate(size_t size)
+ {
+ if (_data)
+ return false;
+ _data = ::MidAlloc(size);
+ return _data != NULL;
+ }
+ ~CMyBuffer() { ::MidFree(_data); }
+};
+
+class CExitEventLauncher
+{
+public:
+ NWindows::NSynchronization::CManualResetEvent _exitEvent;
+ bool _needExit;
+ CRecordVector< ::CThread > _threads;
+ unsigned _numActiveThreads;
+
+ CExitEventLauncher()
+ {
+ _needExit = false;
+ if (_exitEvent.Create(false) != S_OK)
+ throw 9387173;
+ _needExit = true;
+ _numActiveThreads = 0;
+ }
+
+ ~CExitEventLauncher() { Exit(true); }
+
+ void Exit(bool hardExit);
+};
+
+extern CExitEventLauncher g_ExitEventLauncher;
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PanelCopy.cpp b/CPP/7zip/UI/FileManager/PanelCopy.cpp
new file mode 100644
index 0000000..de3d764
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelCopy.cpp
@@ -0,0 +1,435 @@
+/// PanelCopy.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "../GUI/HashGUI.h"
+
+#include "FSFolder.h"
+#include "ExtractCallback.h"
+#include "LangUtils.h"
+#include "Panel.h"
+#include "UpdateCallback100.h"
+
+#include "resource.h"
+
+
+class CPanelCopyThread: public CProgressThreadVirt
+{
+ bool ResultsWereShown;
+ bool NeedShowRes;
+
+ HRESULT ProcessVirt() Z7_override;
+ virtual void ProcessWasFinished_GuiVirt() Z7_override;
+public:
+ const CCopyToOptions *options;
+ const UStringVector *CopyFrom_Paths;
+ CMyComPtr<IFolderOperations> FolderOperations;
+ CRecordVector<UInt32> Indices;
+ CExtractCallbackImp *ExtractCallbackSpec;
+ CMyComPtr<IFolderOperationsExtractCallback> ExtractCallback;
+
+ CHashBundle Hash;
+ // UString FirstFilePath;
+
+ // HRESULT Result2;
+
+ void ShowFinalResults(HWND hwnd);
+
+ CPanelCopyThread():
+ ResultsWereShown(false),
+ NeedShowRes(false),
+ CopyFrom_Paths(NULL)
+ // , Result2(E_FAIL)
+ {}
+};
+
+void CPanelCopyThread::ShowFinalResults(HWND hwnd)
+{
+ if (NeedShowRes)
+ if (!ResultsWereShown)
+ {
+ ResultsWereShown = true;
+ ShowHashResults(Hash, hwnd);
+ }
+}
+
+void CPanelCopyThread::ProcessWasFinished_GuiVirt()
+{
+ ShowFinalResults(*this);
+}
+
+HRESULT CPanelCopyThread::ProcessVirt()
+{
+ /*
+ CMyComPtr<IFolderSetReplaceAltStreamCharsMode> iReplace;
+ FolderOperations.QueryInterface(IID_IFolderSetReplaceAltStreamCharsMode, &iReplace);
+ if (iReplace)
+ {
+ RINOK(iReplace->SetReplaceAltStreamCharsMode(ReplaceAltStreamChars ? 1 : 0));
+ }
+ */
+
+ HRESULT result2;
+
+ if (FolderOperations)
+ {
+ CMyComPtr<IFolderSetZoneIdMode> setZoneMode;
+ FolderOperations.QueryInterface(IID_IFolderSetZoneIdMode, &setZoneMode);
+ if (setZoneMode)
+ {
+ RINOK(setZoneMode->SetZoneIdMode(options->ZoneIdMode))
+ }
+ }
+
+ if (CopyFrom_Paths)
+ {
+ result2 = NFsFolder::CopyFileSystemItems(
+ *CopyFrom_Paths,
+ us2fs(options->folder),
+ options->moveMode,
+ (IFolderOperationsExtractCallback *)ExtractCallbackSpec);
+ }
+ else if (options->testMode)
+ {
+ CMyComPtr<IArchiveFolder> archiveFolder;
+ FolderOperations.QueryInterface(IID_IArchiveFolder, &archiveFolder);
+ if (!archiveFolder)
+ return E_NOTIMPL;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback2;
+ RINOK(ExtractCallback.QueryInterface(IID_IFolderArchiveExtractCallback, &extractCallback2))
+ NExtract::NPathMode::EEnum pathMode =
+ NExtract::NPathMode::kCurPaths;
+ // NExtract::NPathMode::kFullPathnames;
+ result2 = archiveFolder->Extract(&Indices.Front(), Indices.Size(),
+ BoolToInt(options->includeAltStreams),
+ BoolToInt(options->replaceAltStreamChars),
+ pathMode, NExtract::NOverwriteMode::kAsk,
+ options->folder, BoolToInt(true), extractCallback2);
+ }
+ else
+ result2 = FolderOperations->CopyTo(
+ BoolToInt(options->moveMode),
+ &Indices.Front(), Indices.Size(),
+ BoolToInt(options->includeAltStreams),
+ BoolToInt(options->replaceAltStreamChars),
+ options->folder, ExtractCallback);
+
+ if (result2 == S_OK && !ExtractCallbackSpec->ThereAreMessageErrors)
+ {
+ if (!options->hashMethods.IsEmpty())
+ NeedShowRes = true;
+ else if (options->testMode)
+ {
+ CProgressMessageBoxPair &pair = GetMessagePair(false); // GetMessagePair(ExtractCallbackSpec->Hash.NumErrors != 0);
+ AddHashBundleRes(pair.Message, Hash);
+ }
+ }
+
+ return result2;
+}
+
+
+/*
+#ifdef Z7_EXTERNAL_CODECS
+
+static void ThrowException_if_Error(HRESULT res)
+{
+ if (res != S_OK)
+ throw CSystemException(res);
+}
+
+#endif
+*/
+
+HRESULT CPanel::CopyTo(CCopyToOptions &options,
+ const CRecordVector<UInt32> &indices,
+ UStringVector *messages,
+ bool &usePassword, UString &password,
+ const UStringVector *filePaths)
+{
+ if (options.NeedRegistryZone && !options.testMode)
+ {
+ CContextMenuInfo ci;
+ ci.Load();
+ if (ci.WriteZone != (UInt32)(Int32)-1)
+ options.ZoneIdMode = (NExtract::NZoneIdMode::EEnum)(int)(Int32)ci.WriteZone;
+ }
+
+ if (IsHashFolder())
+ {
+ if (!options.testMode)
+ return E_NOTIMPL;
+ }
+
+ if (!filePaths)
+ if (!_folderOperations)
+ {
+ const UString errorMessage = LangString(IDS_OPERATION_IS_NOT_SUPPORTED);
+ if (options.showErrorMessages)
+ MessageBox_Error(errorMessage);
+ else if (messages)
+ messages->Add(errorMessage);
+ return E_FAIL;
+ }
+
+ HRESULT res = S_OK;
+
+ {
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ CExternalCodecs g_ExternalCodecs;
+ #endif
+ */
+ /* extracter.Hash uses g_ExternalCodecs
+ extracter must be declared after g_ExternalCodecs for correct destructor order !!! */
+
+ CPanelCopyThread extracter;
+
+ extracter.ExtractCallbackSpec = new CExtractCallbackImp;
+ extracter.ExtractCallback = extracter.ExtractCallbackSpec;
+
+ extracter.options = &options;
+ extracter.ExtractCallbackSpec->ProgressDialog = &extracter;
+ extracter.CompressingMode = false;
+
+ extracter.ExtractCallbackSpec->StreamMode = options.streamMode;
+
+
+ if (indices.Size() == 1)
+ {
+ extracter.Hash.FirstFileName = GetItemRelPath(indices[0]);
+ extracter.Hash.MainName = extracter.Hash.FirstFileName;
+ }
+
+ if (options.VirtFileSystem)
+ {
+ extracter.ExtractCallbackSpec->VirtFileSystem = options.VirtFileSystem;
+ extracter.ExtractCallbackSpec->VirtFileSystemSpec = options.VirtFileSystemSpec;
+ }
+ extracter.ExtractCallbackSpec->ProcessAltStreams = options.includeAltStreams;
+
+ if (!options.hashMethods.IsEmpty())
+ {
+ /* this code is used when we call CRC calculation for files in side archive
+ But new code uses global codecs so we don't need to call LoadGlobalCodecs again */
+
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ ThrowException_if_Error(LoadGlobalCodecs());
+ #endif
+ */
+
+ extracter.Hash.SetMethods(EXTERNAL_CODECS_VARS_G options.hashMethods);
+ extracter.ExtractCallbackSpec->SetHashMethods(&extracter.Hash);
+ }
+ else if (options.testMode)
+ {
+ extracter.ExtractCallbackSpec->SetHashCalc(&extracter.Hash);
+ }
+
+ // extracter.Hash.Init();
+
+ UString title;
+ {
+ UInt32 titleID = IDS_COPYING;
+ if (options.moveMode)
+ titleID = IDS_MOVING;
+ else if (!options.hashMethods.IsEmpty() && options.streamMode)
+ {
+ titleID = IDS_CHECKSUM_CALCULATING;
+ if (options.hashMethods.Size() == 1)
+ {
+ const UString &s = options.hashMethods[0];
+ if (s != L"*")
+ title = s;
+ }
+ }
+ else if (options.testMode)
+ titleID = IDS_PROGRESS_TESTING;
+
+ if (title.IsEmpty())
+ title = LangString(titleID);
+ }
+
+ const UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE);
+
+ extracter.MainWindow = GetParent();
+ extracter.MainTitle = progressWindowTitle;
+ extracter.MainAddTitle = title + L' ';
+
+ extracter.ExtractCallbackSpec->OverwriteMode = NExtract::NOverwriteMode::kAsk;
+ extracter.ExtractCallbackSpec->Init();
+
+ extracter.CopyFrom_Paths = filePaths;
+ if (!filePaths)
+ {
+ extracter.Indices = indices;
+ extracter.FolderOperations = _folderOperations;
+ }
+
+ extracter.ExtractCallbackSpec->PasswordIsDefined = usePassword;
+ extracter.ExtractCallbackSpec->Password = password;
+
+ RINOK(extracter.Create(title, GetParent()))
+
+
+ if (messages)
+ *messages = extracter.Sync.Messages;
+
+ // res = extracter.Result2;
+ res = extracter.Result;
+
+ if (res == S_OK && extracter.ExtractCallbackSpec->IsOK())
+ {
+ usePassword = extracter.ExtractCallbackSpec->PasswordIsDefined;
+ password = extracter.ExtractCallbackSpec->Password;
+ }
+
+ extracter.ShowFinalResults(_window);
+
+ }
+
+ RefreshTitleAlways();
+ return res;
+}
+
+
+struct CThreadUpdate
+{
+ CMyComPtr<IFolderOperations> FolderOperations;
+ UString FolderPrefix;
+ UStringVector FileNames;
+ CRecordVector<const wchar_t *> FileNamePointers;
+ CProgressDialog ProgressDialog;
+ CMyComPtr<IFolderArchiveUpdateCallback> UpdateCallback;
+ CUpdateCallback100Imp *UpdateCallbackSpec;
+ HRESULT Result;
+ bool MoveMode;
+
+ void Process()
+ {
+ try
+ {
+ CProgressCloser closer(ProgressDialog);
+ Result = FolderOperations->CopyFrom(
+ MoveMode,
+ FolderPrefix,
+ &FileNamePointers.Front(),
+ FileNamePointers.Size(),
+ UpdateCallback);
+ }
+ catch(...) { Result = E_FAIL; }
+ }
+ static THREAD_FUNC_DECL MyThreadFunction(void *param)
+ {
+ ((CThreadUpdate *)param)->Process();
+ return 0;
+ }
+};
+
+
+HRESULT CPanel::CopyFrom(bool moveMode, const UString &folderPrefix, const UStringVector &filePaths,
+ bool showErrorMessages, UStringVector *messages)
+{
+ if (IsHashFolder())
+ {
+ if (moveMode)
+ return E_NOTIMPL;
+ }
+ // CDisableNotify disableNotify(*this);
+
+ HRESULT res;
+ if (!_folderOperations)
+ res = E_NOINTERFACE;
+ else
+ {
+ CThreadUpdate updater;
+ updater.MoveMode = moveMode;
+ updater.UpdateCallbackSpec = new CUpdateCallback100Imp;
+ updater.UpdateCallback = updater.UpdateCallbackSpec;
+ updater.UpdateCallbackSpec->Init();
+
+ updater.UpdateCallbackSpec->ProgressDialog = &updater.ProgressDialog;
+
+ const UString title = LangString(IDS_COPYING);
+ const UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE);
+
+ updater.ProgressDialog.MainWindow = GetParent();
+ updater.ProgressDialog.MainTitle = progressWindowTitle;
+ updater.ProgressDialog.MainAddTitle = title + L' ';
+
+ {
+ if (!_parentFolders.IsEmpty())
+ {
+ const CFolderLink &fl = _parentFolders.Back();
+ updater.UpdateCallbackSpec->PasswordIsDefined = fl.UsePassword;
+ updater.UpdateCallbackSpec->Password = fl.Password;
+ }
+ }
+
+ updater.FolderOperations = _folderOperations;
+ updater.FolderPrefix = folderPrefix;
+ updater.FileNames.ClearAndReserve(filePaths.Size());
+ unsigned i;
+ for (i = 0; i < filePaths.Size(); i++)
+ updater.FileNames.AddInReserved(filePaths[i]);
+ updater.FileNamePointers.ClearAndReserve(updater.FileNames.Size());
+ for (i = 0; i < updater.FileNames.Size(); i++)
+ updater.FileNamePointers.AddInReserved(updater.FileNames[i]);
+
+ {
+ NWindows::CThread thread;
+ const WRes wres = thread.Create(CThreadUpdate::MyThreadFunction, &updater);
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ updater.ProgressDialog.Create(title, thread, GetParent());
+ }
+
+ if (messages)
+ *messages = updater.ProgressDialog.Sync.Messages;
+
+ res = updater.Result;
+ }
+
+ if (res == E_NOINTERFACE)
+ {
+ const UString errorMessage = LangString(IDS_OPERATION_IS_NOT_SUPPORTED);
+ if (showErrorMessages)
+ MessageBox_Error(errorMessage);
+ else if (messages)
+ messages->Add(errorMessage);
+ return E_ABORT;
+ }
+
+ RefreshTitleAlways();
+ return res;
+}
+
+void CPanel::CopyFromNoAsk(bool moveMode, const UStringVector &filePaths)
+{
+ CDisableTimerProcessing disableTimerProcessing(*this);
+
+ CSelectedState srcSelState;
+ SaveSelectedState(srcSelState);
+
+ CDisableNotify disableNotify(*this);
+
+ const HRESULT result = CopyFrom(moveMode, L"", filePaths, true, NULL);
+
+ if (result != S_OK)
+ {
+ disableNotify.Restore();
+ // For Password:
+ SetFocusToList();
+ if (result != E_ABORT)
+ MessageBox_Error_HRESULT(result);
+ return;
+ }
+
+ RefreshListCtrl(srcSelState);
+
+ disableNotify.Restore();
+ SetFocusToList();
+}
diff --git a/CPP/7zip/UI/FileManager/PanelCrc.cpp b/CPP/7zip/UI/FileManager/PanelCrc.cpp
new file mode 100644
index 0000000..df0b733
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelCrc.cpp
@@ -0,0 +1,422 @@
+// PanelCrc.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyException.h"
+
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileIO.h"
+#include "../../../Windows/FileName.h"
+
+#include "../Common/LoadCodecs.h"
+
+#include "../GUI/HashGUI.h"
+
+#include "App.h"
+#include "LangUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+
+#ifdef Z7_EXTERNAL_CODECS
+extern CExternalCodecs g_ExternalCodecs;
+HRESULT LoadGlobalCodecs();
+#endif
+
+static const UInt32 kBufSize = (1 << 15);
+
+struct CDirEnumerator
+{
+ bool EnterToDirs;
+ FString BasePrefix;
+ FString BasePrefix_for_Open;
+ FStringVector FilePaths;
+
+ CObjectVector<NFind::CEnumerator> Enumerators;
+ FStringVector Prefixes;
+ unsigned Index;
+
+ CDirEnumerator(): EnterToDirs(false), Index(0) {}
+
+ void Init();
+ DWORD GetNextFile(NFind::CFileInfo &fi, bool &filled, FString &resPath);
+};
+
+void CDirEnumerator::Init()
+{
+ Enumerators.Clear();
+ Prefixes.Clear();
+ Index = 0;
+}
+
+static DWORD GetNormalizedError()
+{
+ const DWORD error = GetLastError();
+ return (error == 0) ? (DWORD)E_FAIL : error;
+}
+
+DWORD CDirEnumerator::GetNextFile(NFind::CFileInfo &fi, bool &filled, FString &resPath)
+{
+ filled = false;
+ resPath.Empty();
+
+ for (;;)
+ {
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ bool isRootPrefix = (BasePrefix.IsEmpty() || (NName::IsSuperPath(BasePrefix) && BasePrefix[NName::kSuperPathPrefixSize] == 0));
+ #endif
+
+ if (Enumerators.IsEmpty())
+ {
+ if (Index >= FilePaths.Size())
+ return S_OK;
+ const FString &path = FilePaths[Index++];
+ const int pos = path.ReverseFind_PathSepar();
+ if (pos >= 0)
+ resPath.SetFrom(path, (unsigned)pos + 1);
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (isRootPrefix && path.Len() == 2 && NName::IsDrivePath2(path))
+ {
+ // we use "c:" item as directory item
+ fi.ClearBase();
+ fi.Name = path;
+ fi.SetAsDir();
+ fi.Size = 0;
+ }
+ else
+ #endif
+ if (!fi.Find(BasePrefix + path))
+ {
+ const DWORD error = GetNormalizedError();
+ resPath = path;
+ return error;
+ }
+
+ break;
+ }
+
+ bool found;
+
+ if (Enumerators.Back().Next(fi, found))
+ {
+ if (found)
+ {
+ resPath = Prefixes.Back();
+ break;
+ }
+ }
+ else
+ {
+ const DWORD error = GetNormalizedError();
+ resPath = Prefixes.Back();
+ Enumerators.DeleteBack();
+ Prefixes.DeleteBack();
+ return error;
+ }
+
+ Enumerators.DeleteBack();
+ Prefixes.DeleteBack();
+ }
+
+ resPath += fi.Name;
+
+ if (EnterToDirs && fi.IsDir())
+ {
+ FString s = resPath;
+ s.Add_PathSepar();
+ Prefixes.Add(s);
+ Enumerators.AddNew().SetDirPrefix(BasePrefix + s);
+ }
+
+ filled = true;
+ return S_OK;
+}
+
+
+
+class CThreadCrc: public CProgressThreadVirt
+{
+ bool ResultsWereShown;
+ bool WasFinished;
+
+ HRESULT ProcessVirt() Z7_override;
+ virtual void ProcessWasFinished_GuiVirt() Z7_override;
+public:
+ CDirEnumerator Enumerator;
+ CHashBundle Hash;
+ // FString FirstFilePath;
+
+ void SetStatus(const UString &s);
+ void AddErrorMessage(DWORD systemError, const FChar *name);
+ void ShowFinalResults(HWND hwnd);
+
+ CThreadCrc():
+ ResultsWereShown(false),
+ WasFinished(false)
+ {}
+};
+
+void CThreadCrc::ShowFinalResults(HWND hwnd)
+{
+ if (WasFinished)
+ if (!ResultsWereShown)
+ {
+ ResultsWereShown = true;
+ ShowHashResults(Hash, hwnd);
+ }
+}
+
+void CThreadCrc::ProcessWasFinished_GuiVirt()
+{
+ ShowFinalResults(*this);
+}
+
+void CThreadCrc::AddErrorMessage(DWORD systemError, const FChar *name)
+{
+ Sync.AddError_Code_Name(HRESULT_FROM_WIN32(systemError), fs2us(Enumerator.BasePrefix + name));
+ Hash.NumErrors++;
+}
+
+void CThreadCrc::SetStatus(const UString &s2)
+{
+ UString s = s2;
+ if (!Enumerator.BasePrefix.IsEmpty())
+ {
+ s.Add_Space_if_NotEmpty();
+ s += fs2us(Enumerator.BasePrefix);
+ }
+ Sync.Set_Status(s);
+}
+
+HRESULT CThreadCrc::ProcessVirt()
+{
+ // Hash.Init();
+
+ CMyBuffer buf;
+ if (!buf.Allocate(kBufSize))
+ return E_OUTOFMEMORY;
+
+ CProgressSync &sync = Sync;
+
+ SetStatus(LangString(IDS_SCANNING));
+
+ Enumerator.Init();
+
+ FString path;
+ NFind::CFileInfo fi;
+ UInt64 numFiles = 0;
+ UInt64 numItems = 0, numItems_Prev = 0;
+ UInt64 totalSize = 0;
+
+ for (;;)
+ {
+ bool filled;
+ const DWORD error = Enumerator.GetNextFile(fi, filled, path);
+ if (error != 0)
+ {
+ AddErrorMessage(error, path);
+ continue;
+ }
+ if (!filled)
+ break;
+ if (!fi.IsDir())
+ {
+ totalSize += fi.Size;
+ numFiles++;
+ }
+ numItems++;
+ bool needPrint = false;
+ // if (fi.IsDir())
+ {
+ if (numItems - numItems_Prev >= 100)
+ {
+ needPrint = true;
+ numItems_Prev = numItems;
+ }
+ }
+ /*
+ else if (numFiles - numFiles_Prev >= 200)
+ {
+ needPrint = true;
+ numFiles_Prev = numFiles;
+ }
+ */
+ if (needPrint)
+ {
+ RINOK(sync.ScanProgress(numFiles, totalSize, path, fi.IsDir()))
+ }
+ }
+ RINOK(sync.ScanProgress(numFiles, totalSize, FString(), false))
+ // sync.SetNumFilesTotal(numFiles);
+ // sync.SetProgress(totalSize, 0);
+ // SetStatus(LangString(IDS_CHECKSUM_CALCULATING));
+ // sync.SetCurFilePath(L"");
+ SetStatus(L"");
+
+ Enumerator.Init();
+
+ FString tempPath;
+ bool isFirstFile = true;
+ UInt64 errorsFilesSize = 0;
+
+ for (;;)
+ {
+ bool filled;
+ DWORD error = Enumerator.GetNextFile(fi, filled, path);
+ if (error != 0)
+ {
+ AddErrorMessage(error, path);
+ continue;
+ }
+ if (!filled)
+ break;
+
+ error = 0;
+ Hash.InitForNewFile();
+ if (!fi.IsDir())
+ {
+ NIO::CInFile inFile;
+ tempPath = Enumerator.BasePrefix_for_Open;
+ tempPath += path;
+ if (!inFile.Open(tempPath))
+ {
+ error = GetNormalizedError();
+ AddErrorMessage(error, path);
+ continue;
+ }
+ if (isFirstFile)
+ {
+ Hash.FirstFileName = fs2us(path);
+ isFirstFile = false;
+ }
+ sync.Set_FilePath(fs2us(path));
+ sync.Set_NumFilesCur(Hash.NumFiles);
+ UInt64 progress_Prev = 0;
+ for (;;)
+ {
+ UInt32 size;
+ if (!inFile.Read(buf, kBufSize, size))
+ {
+ error = GetNormalizedError();
+ AddErrorMessage(error, path);
+ UInt64 errorSize = 0;
+ if (inFile.GetLength(errorSize))
+ errorsFilesSize += errorSize;
+ break;
+ }
+ if (size == 0)
+ break;
+ Hash.Update(buf, size);
+ if (Hash.CurSize - progress_Prev >= ((UInt32)1 << 21))
+ {
+ RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize + Hash.CurSize))
+ progress_Prev = Hash.CurSize;
+ }
+ }
+ }
+ if (error == 0)
+ Hash.Final(fi.IsDir(), false, fs2us(path));
+ RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize))
+ }
+ RINOK(sync.Set_NumBytesCur(errorsFilesSize + Hash.FilesSize))
+ sync.Set_NumFilesCur(Hash.NumFiles);
+ if (Hash.NumFiles != 1)
+ sync.Set_FilePath(L"");
+ SetStatus(L"");
+
+ CProgressMessageBoxPair &pair = GetMessagePair(Hash.NumErrors != 0);
+ WasFinished = true;
+ LangString(IDS_CHECKSUM_INFORMATION, pair.Title);
+ return S_OK;
+}
+
+
+
+HRESULT CApp::CalculateCrc2(const UString &methodName)
+{
+ unsigned srcPanelIndex = GetFocusedPanelIndex();
+ CPanel &srcPanel = Panels[srcPanelIndex];
+
+ CRecordVector<UInt32> indices;
+ srcPanel.Get_ItemIndices_OperSmart(indices);
+ if (indices.IsEmpty())
+ return S_OK;
+
+ if (!srcPanel.Is_IO_FS_Folder())
+ {
+ CCopyToOptions options;
+ options.streamMode = true;
+ options.showErrorMessages = true;
+ options.hashMethods.Add(methodName);
+ options.NeedRegistryZone = false;
+
+ UStringVector messages;
+ return srcPanel.CopyTo(options, indices, &messages);
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+
+ LoadGlobalCodecs();
+
+ #endif
+
+ {
+ CThreadCrc t;
+
+ {
+ UStringVector methods;
+ methods.Add(methodName);
+ RINOK(t.Hash.SetMethods(EXTERNAL_CODECS_VARS_G methods))
+ }
+
+ FOR_VECTOR (i, indices)
+ t.Enumerator.FilePaths.Add(us2fs(srcPanel.GetItemRelPath(indices[i])));
+
+ if (t.Enumerator.FilePaths.Size() == 1)
+ t.Hash.MainName = fs2us(t.Enumerator.FilePaths[0]);
+
+ UString basePrefix = srcPanel.GetFsPath();
+ UString basePrefix2 = basePrefix;
+ if (basePrefix2.Back() == ':')
+ {
+ const int pos = basePrefix2.ReverseFind_PathSepar();
+ if (pos >= 0)
+ basePrefix2.DeleteFrom((unsigned)(pos + 1));
+ }
+
+ t.Enumerator.BasePrefix = us2fs(basePrefix);
+ t.Enumerator.BasePrefix_for_Open = us2fs(basePrefix2);
+
+ t.Enumerator.EnterToDirs = !GetFlatMode();
+
+ t.ShowCompressionInfo = false;
+
+ const UString title = LangString(IDS_CHECKSUM_CALCULATING);
+
+ t.MainWindow = _window;
+ t.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+ t.MainAddTitle = title;
+ t.MainAddTitle.Add_Space();
+
+ RINOK(t.Create(title, _window))
+
+ t.ShowFinalResults(_window);
+ }
+
+ RefreshTitleAlways();
+ return S_OK;
+}
+
+void CApp::CalculateCrc(const char *methodName)
+{
+ HRESULT res = CalculateCrc2(UString(methodName));
+ if (res != S_OK && res != E_ABORT)
+ {
+ unsigned srcPanelIndex = GetFocusedPanelIndex();
+ CPanel &srcPanel = Panels[srcPanelIndex];
+ srcPanel.MessageBox_Error_HRESULT(res);
+ }
+}
diff --git a/CPP/7zip/UI/FileManager/PanelDrag.cpp b/CPP/7zip/UI/FileManager/PanelDrag.cpp
new file mode 100644
index 0000000..040444c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelDrag.cpp
@@ -0,0 +1,3006 @@
+// PanelDrag.cpp
+
+#include "StdAfx.h"
+
+#ifdef UNDER_CE
+#include <winuserm.h>
+#endif
+
+#include "../../../../C/7zVersion.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/COM.h"
+#include "../../../Windows/MemoryGlobal.h"
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Shell.h"
+
+#include "../Common/ArchiveName.h"
+#include "../Common/CompressCall.h"
+#include "../Common/ExtractingFilePath.h"
+
+#include "MessagesDialog.h"
+
+#include "App.h"
+#include "EnumFormatEtc.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+
+#include "resource.h"
+#include "../Explorer/resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+#define PRF(x)
+#define PRF_W(x)
+// #define PRF2(x)
+#define PRF3(x)
+#define PRF3_W(x)
+#define PRF4(x)
+// #define PRF4(x) OutputDebugStringA(x)
+// #define PRF4_W(x) OutputDebugStringW(x)
+
+// #define SHOW_DEBUG_DRAG
+
+#ifdef SHOW_DEBUG_DRAG
+
+#define PRF_(x) { x; }
+
+static void Print_Point(const char *name, DWORD keyState, const POINTL &pt, DWORD effect)
+{
+ AString s (name);
+ s += " x="; s.Add_UInt32((unsigned)pt.x);
+ s += " y="; s.Add_UInt32((unsigned)pt.y);
+ s += " k="; s.Add_UInt32(keyState);
+ s += " e="; s.Add_UInt32(effect);
+ PRF4(s);
+}
+
+#else
+
+#define PRF_(x)
+
+#endif
+
+
+#define kTempDirPrefix FTEXT("7zE")
+
+// all versions: k_Format_7zip_SetTargetFolder format to transfer folder path from target to source
+static LPCTSTR const k_Format_7zip_SetTargetFolder = TEXT("7-Zip::SetTargetFolder");
+// new v23 formats:
+static LPCTSTR const k_Format_7zip_SetTransfer = TEXT("7-Zip::SetTransfer");
+static LPCTSTR const k_Format_7zip_GetTransfer = TEXT("7-Zip::GetTransfer");
+
+/*
+ Win10: clipboard formats.
+ There are about 16K free ids (formats) per system that can be
+ registered with RegisterClipboardFormat() with different names.
+ Probably that 16K ids space is common for ids registering for both
+ formats: RegisterClipboardFormat(), and registered window classes:
+ RegisterClass(). But ids for window classes will be deleted from
+ the list after process finishing. And registered clipboard
+ formats probably will be deleted from the list only after reboot.
+*/
+
+// static bool const g_CreateArchive_for_Drag_from_7zip = false;
+// static bool const g_CreateArchive_for_Drag_from_Explorer = true;
+ // = false; // for debug
+
+/*
+How DoDragDrop() works:
+{
+ IDropSource::QueryContinueDrag() (keyState & MK_LBUTTON) != 0
+ IDropTarget::Enter()
+ IDropSource::GiveFeedback()
+ IDropTarget::DragOver()
+ IDropSource::GiveFeedback()
+
+ for()
+ {
+ IDropSource::QueryContinueDrag() (keyState & MK_LBUTTON) != 0
+ IDropTarget::DragOver() (keyState & MK_LBUTTON) != 0
+ IDropSource::GiveFeedback()
+ }
+
+ {
+ // DoDragDrop() in Win10 before calling // QueryContinueDrag()
+ // with (*(keyState & MK_LBUTTON) == 0) probably calls:
+ // 1) IDropTarget::DragOver() with same point values (x,y), but (keyState & MK_LBUTTON) != 0)
+ // 2) IDropSource::GiveFeedback().
+ // so DropSource can know exact GiveFeedback(effect) mode just before LBUTTON releasing.
+
+ if (IDropSource::QueryContinueDrag() for (keyState & MK_LBUTTON) == 0
+ returns DRAGDROP_S_DROP), it will call
+ IDropTarget::Drop()
+ }
+ or
+ {
+ IDropSource::QueryContinueDrag()
+ IDropTarget::DragLeave()
+ IDropSource::GiveFeedback(0)
+ }
+ or
+ {
+ if (IDropSource::QueryContinueDrag()
+ returns DRAGDROP_S_CANCEL)
+ IDropTarget::DragLeave()
+ }
+}
+*/
+
+
+// ---------- CDropTarget ----------
+
+static const UInt32 k_Struct_Id_SetTranfer = 2; // it's our selected id
+static const UInt32 k_Struct_Id_GetTranfer = 3; // it's our selected id
+
+static const UInt64 k_Program_Id = 1; // "7-Zip"
+
+enum E_Program_ISA
+{
+ k_Program_ISA_x86 = 2,
+ k_Program_ISA_x64 = 3,
+ k_Program_ISA_armt = 4,
+ k_Program_ISA_arm64 = 5,
+ k_Program_ISA_arm32 = 6,
+ k_Program_ISA_ia64 = 9
+};
+
+#define k_Program_Ver ((MY_VER_MAJOR << 16) | MY_VER_MINOR)
+
+
+// k_SourceFlags_* are flags that are sent from Source to Target
+
+static const UInt32 k_SourceFlags_DoNotProcessInTarget = 1 << 1;
+/* Do not process in Target. Source will process operation instead of Target.
+ By default Target processes Drop opearation. */
+// static const UInt32 k_SourceFlags_ProcessInTarget = 1 << 2;
+
+static const UInt32 k_SourceFlags_DoNotWaitFinish = 1 << 3;
+static const UInt32 k_SourceFlags_WaitFinish = 1 << 4;
+/* usually Source needs WaitFinish, if temp files were created. */
+
+static const UInt32 k_SourceFlags_TempFiles = 1 << 6;
+static const UInt32 k_SourceFlags_NamesAreParent = 1 << 7;
+/* if returned path list for GetData(CF_HDROP) contains
+ path of parent temp folder instead of final paths of items
+ that will be extracted later from archive */
+
+static const UInt32 k_SourceFlags_SetTargetFolder = 1 << 8;
+/* SetData::("SetTargetFolder") was called (with empty or non-empty string) */
+
+static const UInt32 k_SourceFlags_SetTargetFolder_NonEmpty = 1 << 9;
+/* SetData::("SetTargetFolder") was called with non-empty string */
+
+static const UInt32 k_SourceFlags_NeedExtractOpToFs = 1 << 10;
+
+static const UInt32 k_SourceFlags_Copy_WasCalled = 1 << 11;
+
+static const UInt32 k_SourceFlags_LeftButton = 1 << 14;
+static const UInt32 k_SourceFlags_RightButton = 1 << 15;
+
+
+static const UInt32 k_TargetFlags_WasCanceled = 1 << 0;
+static const UInt32 k_TargetFlags_MustBeProcessedBySource = 1 << 1;
+static const UInt32 k_TargetFlags_WasProcessed = 1 << 2;
+static const UInt32 k_TargetFlags_DoNotWaitFinish = 1 << 3;
+static const UInt32 k_TargetFlags_WaitFinish = 1 << 4;
+static const UInt32 k_TargetFlags_MenuWasShown = 1 << 16;
+
+struct CDataObject_TransferBase
+{
+ UInt32 Struct_Id;
+ UInt32 Struct_Size;
+
+ UInt64 Program_Id;
+ UInt32 Program_Ver_Main;
+ UInt32 Program_Ver_Build;
+ UInt32 Program_ISA;
+ UInt32 Program_Flags;
+
+ UInt32 ProcessId;
+ UInt32 _reserved1[7];
+
+protected:
+ void Init_Program();
+};
+
+
+void CDataObject_TransferBase::Init_Program()
+{
+ Program_Id = k_Program_Id;
+ Program_ISA =
+ #if defined(MY_CPU_AMD64)
+ k_Program_ISA_x64
+ #elif defined(MY_CPU_X86)
+ k_Program_ISA_x86
+ #elif defined(MY_CPU_ARM64)
+ k_Program_ISA_arm64
+ #elif defined(MY_CPU_ARM32)
+ k_Program_ISA_arm32
+ #elif defined(MY_CPU_ARMT) || defined(MY_CPU_ARM)
+ k_Program_ISA_armt
+ #elif defined(MY_CPU_IA64)
+ k_Program_ISA_ia64
+ #else
+ 0
+ #endif
+ ;
+ Program_Flags = sizeof(size_t);
+ Program_Ver_Main = k_Program_Ver;
+ // Program_Ver_Build = 0;
+ ProcessId = GetCurrentProcessId();
+}
+
+
+#if defined(__GNUC__) && !defined(__clang__)
+/* 'void* memset(void*, int, size_t)' clearing an object
+ of non-trivial type 'struct CDataObject_SetTransfer' */
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
+
+
+struct CDataObject_GetTransfer:
+public CDataObject_TransferBase
+{
+ UInt32 Flags;
+
+ UInt32 _reserved2[11];
+
+ CDataObject_GetTransfer()
+ {
+ memset(this, 0, sizeof(*this));
+ Init_Program();
+ Struct_Id = k_Struct_Id_GetTranfer;
+ Struct_Size = sizeof(*this);
+ }
+
+ bool Check() const
+ {
+ return Struct_Size >= sizeof(*this) && Struct_Id == k_Struct_Id_GetTranfer;
+ }
+};
+
+
+enum Enum_FolderType
+{
+ k_FolderType_None,
+ k_FolderType_Unknown = 1,
+ k_FolderType_Fs = 2,
+ k_FolderType_AltStreams = 3,
+ k_FolderType_Archive = 4
+};
+
+struct CTargetTransferInfo
+{
+ UInt32 Flags;
+ UInt32 FuncType;
+
+ UInt32 KeyState;
+ UInt32 OkEffects;
+ POINTL Point;
+
+ UInt32 Cmd_Effect;
+ UInt32 Cmd_Type;
+ UInt32 FolderType;
+ UInt32 _reserved3[3];
+
+ CTargetTransferInfo()
+ {
+ memset(this, 0, sizeof(*this));
+ }
+};
+
+struct CDataObject_SetTransfer:
+public CDataObject_TransferBase
+{
+ CTargetTransferInfo Target;
+
+ void Init()
+ {
+ memset(this, 0, sizeof(*this));
+ Init_Program();
+ Struct_Id = k_Struct_Id_SetTranfer;
+ Struct_Size = sizeof(*this);
+ }
+
+ bool Check() const
+ {
+ return Struct_Size >= sizeof(*this) && Struct_Id == k_Struct_Id_SetTranfer;
+ }
+};
+
+
+
+
+
+enum Enum_DragTargetMode
+{
+ k_DragTargetMode_None = 0,
+ k_DragTargetMode_Leave = 1,
+ k_DragTargetMode_Enter = 2,
+ k_DragTargetMode_Over = 3,
+ k_DragTargetMode_Drop_Begin = 4,
+ k_DragTargetMode_Drop_End = 5
+};
+
+
+// ---- menu ----
+
+namespace NDragMenu {
+
+enum Enum_CmdId
+{
+ k_None = 0,
+ k_Cancel = 1,
+ k_Copy_Base = 2, // to fs
+ k_Copy_ToArc = 3,
+ k_AddToArc = 4
+ /*
+ k_OpenArc = 8,
+ k_TestArc = 9,
+ k_ExtractFiles = 10,
+ k_ExtractHere = 11
+ */
+};
+
+struct CCmdLangPair
+{
+ unsigned CmdId_and_Flags;
+ unsigned LangId;
+};
+
+static const UInt32 k_MenuFlags_CmdMask = (1 << 7) - 1;
+static const UInt32 k_MenuFlag_Copy = 1 << 14;
+static const UInt32 k_MenuFlag_Move = 1 << 15;
+// #define IDS_CANCEL (IDCANCEL + 400)
+#define IDS_CANCEL 402
+
+static const CCmdLangPair g_Pairs[] =
+{
+ { k_Copy_Base | k_MenuFlag_Copy, IDS_COPY },
+ { k_Copy_Base | k_MenuFlag_Move, IDS_MOVE },
+ { k_Copy_ToArc | k_MenuFlag_Copy, IDS_COPY_TO },
+ // { k_Copy_ToArc | k_MenuFlag_Move, IDS_MOVE_TO }, // IDS_CONTEXT_COMPRESS_TO
+ // { k_OpenArc, IDS_CONTEXT_OPEN },
+ // { k_ExtractFiles, IDS_CONTEXT_EXTRACT },
+ // { k_ExtractHere, IDS_CONTEXT_EXTRACT_HERE },
+ // { k_TestArc, IDS_CONTEXT_TEST },
+ { k_AddToArc | k_MenuFlag_Copy, IDS_CONTEXT_COMPRESS },
+ { k_Cancel, IDS_CANCEL }
+};
+
+}
+
+
+class CDropTarget Z7_final:
+ public IDropTarget,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1_MT(IDropTarget)
+ STDMETHOD(DragEnter)(IDataObject *dataObject, DWORD keyState, POINTL pt, DWORD *effect) Z7_override;
+ STDMETHOD(DragOver)(DWORD keyState, POINTL pt, DWORD *effect) Z7_override;
+ STDMETHOD(DragLeave)() Z7_override;
+ STDMETHOD(Drop)(IDataObject *dataObject, DWORD keyState, POINTL pt, DWORD *effect) Z7_override;
+
+ bool m_IsRightButton;
+ bool m_GetTransfer_WasSuccess;
+ bool m_DropIsAllowed; // = true, if data IDataObject can return CF_HDROP (so we can get list of paths)
+ bool m_PanelDropIsAllowed; // = false, if current target_panel is source_panel.
+ // check it only if m_DropIsAllowed == true
+ // we use it to show icon effect that drop is not allowed here.
+
+ CMyComPtr<IDataObject> m_DataObject; // we set it in DragEnter()
+ UStringVector m_SourcePaths;
+
+ // int m_DropHighlighted_SelectionIndex;
+ // int m_SubFolderIndex; // realIndex of item in m_Panel list (if drop cursor to that item)
+ // UString m_DropHighlighted_SubFolderName; // name of folder in m_Panel list (if drop cursor to that folder)
+
+ CPanel *m_Panel;
+ bool m_IsAppTarget; // true, if we want to drop to app window (not to panel)
+
+ bool m_TargetPath_WasSent_ToDataObject; // true, if TargetPath was sent
+ bool m_TargetPath_NonEmpty_WasSent_ToDataObject; // true, if non-empty TargetPath was sent
+ bool m_Transfer_WasSent_ToDataObject; // true, if Transfer was sent
+ UINT m_Format_7zip_SetTargetFolder;
+ UINT m_Format_7zip_SetTransfer;
+ UINT m_Format_7zip_GetTransfer;
+
+ UInt32 m_ProcessId; // for sending
+
+ bool IsItSameDrive() const;
+
+ // void Try_QueryGetData(IDataObject *dataObject);
+ void LoadNames_From_DataObject(IDataObject *dataObject);
+
+ UInt32 GetFolderType() const;
+ bool IsFsFolderPath() const;
+ DWORD GetEffect(DWORD keyState, POINTL pt, DWORD allowedEffect) const;
+ void RemoveSelection();
+ void PositionCursor(const POINTL &ptl);
+ UString GetTargetPath() const;
+ bool SendToSource_TargetPath_enable(IDataObject *dataObject, bool enablePath);
+ bool SendToSource_UInt32(IDataObject *dataObject, UINT format, UInt32 value);
+ bool SendToSource_TransferInfo(IDataObject *dataObject,
+ const CTargetTransferInfo &info);
+ void SendToSource_auto(IDataObject *dataObject,
+ const CTargetTransferInfo &info);
+ void SendToSource_Drag(CTargetTransferInfo &info)
+ {
+ SendToSource_auto(m_DataObject, info);
+ }
+
+ void ClearState();
+
+public:
+ CDropTarget();
+
+ CApp *App;
+ int SrcPanelIndex; // index of D&D source_panel
+ int TargetPanelIndex; // what panel to use as target_panel of Application
+};
+
+
+
+
+// ---------- CDataObject ----------
+
+/*
+ Some programs (like Sticky Notes in Win10) do not like
+ virtual non-existing items (files/dirs) in CF_HDROP format.
+ So we use two versions of CF_HDROP data:
+ m_hGlobal_HDROP_Pre : the list contains only destination path of temp directory.
+ That directory later will be filled with extracted items.
+ m_hGlobal_HDROP_Final : the list contains paths of all root items that
+ will be created in temp directory by archive extraction operation,
+ or the list of existing fs items, if source is filesystem directory.
+
+ The DRAWBACK: some programs (like Edge in Win10) can use names from IDataObject::GetData()
+ call that was called before IDropSource::QueryContinueDrag() where we set (UseFinalGlobal = true)
+ So such programs will use non-relevant m_hGlobal_HDROP_Pre item,
+ instead of m_hGlobal_HDROP_Final items.
+*/
+
+class CDataObject Z7_final:
+ public IDataObject,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1_MT(IDataObject)
+
+ Z7_COMWF_B GetData(LPFORMATETC pformatetcIn, LPSTGMEDIUM medium) Z7_override;
+ Z7_COMWF_B GetDataHere(LPFORMATETC pformatetc, LPSTGMEDIUM medium) Z7_override;
+ Z7_COMWF_B QueryGetData(LPFORMATETC pformatetc) Z7_override;
+
+ Z7_COMWF_B GetCanonicalFormatEtc(LPFORMATETC /* pformatetc */, LPFORMATETC pformatetcOut) Z7_override
+ {
+ if (!pformatetcOut)
+ return E_INVALIDARG;
+ pformatetcOut->ptd = NULL;
+ return E_NOTIMPL;
+ }
+
+ Z7_COMWF_B SetData(LPFORMATETC etc, STGMEDIUM *medium, BOOL release) Z7_override;
+ Z7_COMWF_B EnumFormatEtc(DWORD drection, LPENUMFORMATETC *enumFormatEtc) Z7_override;
+
+ Z7_COMWF_B DAdvise(FORMATETC * /* etc */, DWORD /* advf */, LPADVISESINK /* pAdvSink */, DWORD * /* pdwConnection */) Z7_override
+ { return OLE_E_ADVISENOTSUPPORTED; }
+ Z7_COMWF_B DUnadvise(DWORD /* dwConnection */) Z7_override
+ { return OLE_E_ADVISENOTSUPPORTED; }
+ Z7_COMWF_B EnumDAdvise(LPENUMSTATDATA *ppenumAdvise) Z7_override
+ {
+ if (ppenumAdvise)
+ *ppenumAdvise = NULL;
+ return OLE_E_ADVISENOTSUPPORTED;
+ }
+
+ bool m_PerformedDropEffect_WasSet;
+ bool m_LogicalPerformedDropEffect_WasSet;
+ bool m_DestDirPrefix_FromTarget_WasSet;
+public:
+ bool m_Transfer_WasSet;
+private:
+ // GetData formats (source to target):
+ FORMATETC m_Etc;
+ // UINT m_Format_FileOpFlags;
+ // UINT m_Format_PreferredDropEffect;
+
+ // SetData() formats (target to source):
+ // 7-Zip's format:
+ UINT m_Format_7zip_SetTargetFolder;
+ UINT m_Format_7zip_SetTransfer;
+ UINT m_Format_7zip_GetTransfer; // for GetData()
+
+ UINT m_Format_PerformedDropEffect;
+ UINT m_Format_LogicalPerformedDropEffect;
+ UINT m_Format_DisableDragText;
+ UINT m_Format_IsShowingLayered;
+ UINT m_Format_IsShowingText;
+ UINT m_Format_DropDescription;
+ UINT m_Format_TargetCLSID;
+
+ DWORD m_PerformedDropEffect;
+ DWORD m_LogicalPerformedDropEffect;
+
+ void CopyFromPanelTo_Folder();
+ HRESULT SetData2(const FORMATETC *formatetc, const STGMEDIUM *medium);
+
+public:
+ bool IsRightButton;
+ bool IsTempFiles;
+
+ bool UsePreGlobal;
+ bool DoNotProcessInTarget;
+
+ bool NeedCall_Copy;
+ bool Copy_WasCalled;
+
+ NMemory::CGlobal m_hGlobal_HDROP_Pre;
+ NMemory::CGlobal m_hGlobal_HDROP_Final;
+ // NMemory::CGlobal m_hGlobal_FileOpFlags;
+ // NMemory::CGlobal m_hGlobal_PreferredDropEffect;
+
+ CPanel *Panel;
+ CRecordVector<UInt32> Indices;
+
+ UString SrcDirPrefix_Temp; // FS directory with source files or Temp
+ UString DestDirPrefix_FromTarget;
+ /* destination Path that was sent by Target via SetData().
+ it can be altstreams prefix.
+ if (!DestDirPrefix_FromTarget.IsEmpty()) m_Panel->CompressDropFiles() was not called by Target.
+ So we must do drop actions in Source */
+ HRESULT Copy_HRESULT;
+ UStringVector Messages;
+
+ CDataObject();
+public:
+ CDataObject_SetTransfer m_Transfer;
+};
+
+
+// for old mingw:
+#ifndef CFSTR_LOGICALPERFORMEDDROPEFFECT
+#define CFSTR_LOGICALPERFORMEDDROPEFFECT TEXT("Logical Performed DropEffect")
+#endif
+#ifndef CFSTR_TARGETCLSID
+#define CFSTR_TARGETCLSID TEXT("TargetCLSID") // HGLOBAL with a CLSID of the drop target
+#endif
+
+
+
+CDataObject::CDataObject()
+{
+ // GetData formats (source to target):
+ // and we use CF_HDROP format to transfer file paths from source to target:
+ m_Etc.cfFormat = CF_HDROP;
+ m_Etc.ptd = NULL;
+ m_Etc.dwAspect = DVASPECT_CONTENT;
+ m_Etc.lindex = -1;
+ m_Etc.tymed = TYMED_HGLOBAL;
+
+ // m_Format_FileOpFlags = RegisterClipboardFormat(TEXT("FileOpFlags"));
+ // m_Format_PreferredDropEffect = RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT); // "Preferred DropEffect"
+
+ // SetData() formats (target to source):
+ m_Format_7zip_SetTargetFolder = RegisterClipboardFormat(k_Format_7zip_SetTargetFolder);
+ m_Format_7zip_SetTransfer = RegisterClipboardFormat(k_Format_7zip_SetTransfer);
+ m_Format_7zip_GetTransfer = RegisterClipboardFormat(k_Format_7zip_GetTransfer);
+
+ m_Format_PerformedDropEffect = RegisterClipboardFormat(CFSTR_PERFORMEDDROPEFFECT); // "Performed DropEffect"
+ m_Format_LogicalPerformedDropEffect = RegisterClipboardFormat(CFSTR_LOGICALPERFORMEDDROPEFFECT); // "Logical Performed DropEffect"
+ m_Format_DisableDragText = RegisterClipboardFormat(TEXT("DisableDragText"));
+ m_Format_IsShowingLayered = RegisterClipboardFormat(TEXT("IsShowingLayered"));
+ m_Format_IsShowingText = RegisterClipboardFormat(TEXT("IsShowingText"));
+ m_Format_DropDescription = RegisterClipboardFormat(TEXT("DropDescription"));
+ m_Format_TargetCLSID = RegisterClipboardFormat(CFSTR_TARGETCLSID);
+
+ m_PerformedDropEffect = 0;
+ m_LogicalPerformedDropEffect = 0;
+
+ m_PerformedDropEffect_WasSet = false;
+ m_LogicalPerformedDropEffect_WasSet = false;
+
+ m_DestDirPrefix_FromTarget_WasSet = false;
+ m_Transfer_WasSet = false;
+
+ IsRightButton = false;
+ IsTempFiles = false;
+
+ UsePreGlobal = false;
+ DoNotProcessInTarget = false;
+
+ NeedCall_Copy = false;
+ Copy_WasCalled = false;
+
+ Copy_HRESULT = S_OK;
+}
+
+
+
+void CDataObject::CopyFromPanelTo_Folder()
+{
+ try
+ {
+ CCopyToOptions options;
+ options.folder = SrcDirPrefix_Temp;
+ /* 15.13: fixed problem with mouse cursor for password window.
+ DoDragDrop() probably calls SetCapture() to some hidden window.
+ But it's problem, if we show some modal window, like MessageBox.
+ So we return capture to our window.
+ If you know better way to solve the problem, please notify 7-Zip developer.
+ */
+ // MessageBoxW(*Panel, L"test", L"test", 0);
+ /* HWND oldHwnd = */ SetCapture(*Panel);
+ Copy_WasCalled = true;
+ Copy_HRESULT = E_FAIL;
+ Copy_HRESULT = Panel->CopyTo(options, Indices, &Messages);
+ // do we need to restore capture?
+ // ReleaseCapture();
+ // oldHwnd = SetCapture(oldHwnd);
+ }
+ catch(...)
+ {
+ Copy_HRESULT = E_FAIL;
+ }
+}
+
+
+#ifdef SHOW_DEBUG_DRAG
+
+static void PrintFormat2(AString &s, unsigned format)
+{
+ s += " ";
+ s += "= format=";
+ s.Add_UInt32(format);
+ s += " ";
+ const int k_len = 512;
+ CHAR temp[k_len];
+ if (GetClipboardFormatNameA(format, temp, k_len) && strlen(temp) != 0)
+ s += temp;
+}
+
+static void PrintFormat(const char *title, unsigned format)
+{
+ AString s (title);
+ PrintFormat2(s, format);
+ PRF4(s);
+}
+
+static void PrintFormat_AndData(const char *title, unsigned format, const void *data, size_t size)
+{
+ AString s (title);
+ PrintFormat2(s, format);
+ s += " size=";
+ s.Add_UInt32((UInt32)size);
+ for (size_t i = 0; i < size && i < 16; i++)
+ {
+ s += " ";
+ s.Add_UInt32(((const Byte *)data)[i]);
+ }
+ PRF4(s);
+}
+
+static void PrintFormat_GUIDToStringW(const void *p)
+{
+ const GUID *guid = (const GUID *)p;
+ UString s;
+ const unsigned kSize = 48;
+ StringFromGUID2(*guid, s.GetBuf(kSize), kSize);
+ s.ReleaseBuf_CalcLen(kSize);
+ PRF3_W(s);
+}
+
+// Vista
+typedef enum
+{
+ MY_DROPIMAGE_INVALID = -1, // no image preference (use default)
+ MY_DROPIMAGE_NONE = 0, // red "no" circle
+ MY_DROPIMAGE_COPY = DROPEFFECT_COPY, // plus for copy
+ MY_DROPIMAGE_MOVE = DROPEFFECT_MOVE, // movement arrow for move
+ MY_DROPIMAGE_LINK = DROPEFFECT_LINK, // link arrow for link
+ MY_DROPIMAGE_LABEL = 6, // tag icon to indicate metadata will be changed
+ MY_DROPIMAGE_WARNING = 7, // yellow exclamation, something is amiss with the operation
+ MY_DROPIMAGE_NOIMAGE = 8 // no image at all
+} MY_DROPIMAGETYPE;
+
+typedef struct {
+ MY_DROPIMAGETYPE type;
+ WCHAR szMessage[MAX_PATH];
+ WCHAR szInsert[MAX_PATH];
+} MY_DROPDESCRIPTION;
+
+#endif
+
+
+/*
+IDataObject::SetData(LPFORMATETC etc, STGMEDIUM *medium, BOOL release)
+======================================================================
+
+ Main purpose of CDataObject is to transfer data from source to target
+ of drag and drop operation.
+ But also CDataObject can be used to transfer data in backward direction
+ from target to source (even if target and source are different processes).
+ There are some predefined Explorer's formats to transfer some data from target to source.
+ And 7-Zip uses 7-Zip's format k_Format_7zip_SetTargetFolder to transfer
+ destination directory path from target to source.
+
+ Our CDataObject::SetData() function here is used only to transfer data from target to source.
+ Usual source_to_target data is filled to m_hGlobal_* objects directly without SetData() calling.
+
+The main problem of SetData() is ownership of medium for (release == TRUE) case.
+
+SetData(,, release = TRUE) from different processes (DropSource and DropTarget)
+===============================================================================
+{
+ MS DOCs about (STGMEDIUM *medium) ownership:
+ The data object called does not take ownership of the data
+ until it has successfully received it and no error code is returned.
+
+ Each of processes (Source and Target) has own copy of medium allocated.
+ Windows code creates proxy IDataObject object in Target process to transferr
+ SetData() call between Target and Source processes via special proxies:
+ DropTarget ->
+ proxy_DataObject_in_Target ->
+ proxy_in_Source ->
+ DataObject_in_Source
+ when Target calls SetData() with proxy_DataObject_in_Target,
+ the system and proxy_in_Source
+ - allocates proxy-medium-in-Source process
+ - copies medium data from Target to that proxy-medium-in-Source
+ - sends proxy-medium-in-Source to DataObject_in_Source->SetData().
+
+ after returning from SetData() to Target process:
+ Win10 proxy_DataObject_in_Target releases original medium in Target process,
+ only if SetData() in Source returns S_OK. It's consistent with DOCs above.
+
+ for unsupported cfFormat:
+ [DropSource is 7-Zip 22.01 (old) : (etc->cfFormat != m_Format_7zip_SetTargetFolder && release == TRUE)]
+ (DropSource is WinRAR case):
+ Source doesn't release medium and returns error (for example, E_NOTIMPL)
+ {
+ Then Win10 proxy_in_Source also doesn't release proxy-medium-in-Source.
+ So there is memory leak in Source process.
+ Probably Win10 proxy_in_Source tries to avoid possible double releasing
+ that can be more fatal than memory leak.
+
+ Then Win10 proxy_DataObject_in_Target also doesn't release
+ original medium, that was allocated by DropTarget.
+ So if DropTarget also doesn't release medium, there is memory leak in
+ DropTarget process too.
+ DropTarget is Win10-Explorer probably doesn't release medium in that case.
+ }
+
+ [DropSource is 7-Zip 22.01 (old) : (etc->cfFormat == m_Format_7zip_SetTargetFolder && release == TRUE)]
+ DropSource returns S_OK and doesn't release medium:
+ {
+ then there is memory leak in DropSource process only.
+ }
+
+ (DropSource is 7-Zip v23 (new)):
+ (DropSource is Win10-Explorer case)
+ {
+ Win10-Explorer-DropSource probably always releases medium,
+ and then it always returns S_OK.
+ So Win10 proxy_DataObject_in_Target also releases
+ original medium, that was allocated by DropTarget.
+ So there is no memory leak in Source and Target processes.
+ }
+
+ if (DropTarget is Win10-Explorer)
+ {
+ Explorer Target uses SetData(,, (release = TRUE)) and
+ Explorer Target probably doesn't free memory after SetData(),
+ even if SetData(,, (release = TRUE)) returns E_NOTIMPL;
+ }
+
+ if (DropSource is Win10-Explorer)
+ {
+ (release == FALSE) doesn't work, and SetData() returns E_NOTIMPL;
+ (release == TRUE) works, and SetData() returns S_OK, and
+ it returns S_OK even for formats unsupported by Explorer.
+ }
+
+ To be more compatible with DOCs and Win10-Explorer and to avoid memory leaks,
+ we use the following scheme for our IDataObject::SetData(,, release == TRUE)
+ in DropSource code:
+ if (release == TRUE) { our SetData() always releases medium
+ with ReleaseStgMedium() and returns S_OK; }
+ The DRAWBACK of that scheme:
+ The caller always receives S_OK,
+ so the caller doesn't know about any error in SetData() in that case.
+
+for 7zip-Target to 7zip-Source calls:
+ we use (release == FALSE)
+ So we avoid (release == TRUE) memory leak problems,
+ and we can get real return code from SetData().
+
+for 7zip-Target to Explorer-Source calls:
+ we use (release == TRUE).
+ beacuse Explorer-Source doesn't accept (release == FALSE).
+}
+*/
+
+/*
+https://github.com/MicrosoftDocs/win32/blob/docs/desktop-src/shell/datascenarios.md
+CFSTR_PERFORMEDDROPEFFECT:
+ is used by the target to inform the data object through its
+ IDataObject::SetData method of the outcome of a data transfer.
+CFSTR_PREFERREDDROPEFFECT:
+ is used by the source to specify whether its preferred method of data transfer is move or copy.
+*/
+
+Z7_COMWF_B CDataObject::SetData(LPFORMATETC etc, STGMEDIUM *medium, BOOL release)
+{
+ try {
+ const HRESULT hres = SetData2(etc, medium);
+ // PrintFormat(release ? "SetData RELEASE=TRUE" : "SetData RELEASE=FALSE" , etc->cfFormat);
+ if (release)
+ {
+ /*
+ const DWORD tymed = medium->tymed;
+ IUnknown *pUnkForRelease = medium->pUnkForRelease;
+ */
+ // medium->tymed = NULL; // for debug
+ // return E_NOTIMPL; // for debug
+ ReleaseStgMedium(medium);
+ /* ReleaseStgMedium() will change STGMEDIUM::tymed to (TYMED_NULL = 0).
+ but we also can clear (medium.hGlobal = NULL),
+ to prevent some incorrect releasing, if the caller will try to release the data */
+ /*
+ if (medium->tymed == TYMED_NULL && tymed == TYMED_HGLOBAL && !pUnkForRelease)
+ medium->hGlobal = NULL;
+ */
+ // do we need return S_OK; for (tymed != TYMED_HGLOBAL) cases ?
+ /* we return S_OK here to shows that we take ownership of the data in (medium),
+ so the caller will not try to release (medium) */
+ return S_OK; // to be more compatible with Win10-Explorer and DOCs.
+ }
+ return hres;
+ } catch(...) { return E_FAIL; }
+}
+
+
+
+HRESULT CDataObject::SetData2(const FORMATETC *etc, const STGMEDIUM *medium)
+{
+ // PRF3("== CDataObject::SetData()");
+
+ HRESULT hres = S_OK;
+
+ if (etc->cfFormat == 0)
+ return DV_E_FORMATETC;
+ if (etc->tymed != TYMED_HGLOBAL)
+ return E_NOTIMPL; // DV_E_TYMED;
+ if (etc->dwAspect != DVASPECT_CONTENT)
+ return E_NOTIMPL; // DV_E_DVASPECT;
+ if (medium->tymed != TYMED_HGLOBAL)
+ return E_NOTIMPL; // DV_E_TYMED;
+
+ if (!medium->hGlobal)
+ return S_OK;
+
+ if (etc->cfFormat == m_Format_7zip_SetTargetFolder)
+ {
+ DestDirPrefix_FromTarget.Empty();
+ m_DestDirPrefix_FromTarget_WasSet = true;
+ }
+ else if (etc->cfFormat == m_Format_7zip_SetTransfer)
+ m_Transfer_WasSet = false;
+
+ const size_t size = GlobalSize(medium->hGlobal);
+ // GlobalLock() can return NULL, if memory block has a zero size
+ if (size == 0)
+ return S_OK;
+ const void *src = (const Byte *)GlobalLock(medium->hGlobal);
+ if (!src)
+ return E_FAIL;
+
+ PRF_(PrintFormat_AndData("SetData", etc->cfFormat, src, size))
+
+ if (etc->cfFormat == m_Format_7zip_SetTargetFolder)
+ {
+ /* this is our registered k_Format_7zip_SetTargetFolder format.
+ so it's call from 7-zip's CDropTarget */
+ /* 7-zip's CDropTarget calls SetData() for m_Format_7zip_SetTargetFolder
+ with (release == FALSE) */
+ const size_t num = size / sizeof(wchar_t);
+ if (size != num * sizeof(wchar_t))
+ return E_FAIL;
+ // if (num == 0) return S_OK;
+ // GlobalLock() can return NULL, if memory block has a zero-byte size
+ const wchar_t *s = (const wchar_t *)src;
+ UString &dest = DestDirPrefix_FromTarget;
+ for (size_t i = 0; i < num; i++)
+ {
+ const wchar_t c = s[i];
+ if (c == 0)
+ break;
+ dest += c;
+ }
+ // PRF_(PrintFormat_AndData("SetData", etc->cfFormat, src, size))
+ PRF3_W(DestDirPrefix_FromTarget);
+ }
+ else if (etc->cfFormat == m_Format_7zip_SetTransfer)
+ {
+ /* 7-zip's CDropTarget calls SetData() for m_Format_7zip_SetTransfer
+ with (release == FALSE) */
+ if (size < sizeof(CDataObject_SetTransfer))
+ return E_FAIL;
+ const CDataObject_SetTransfer *t = (const CDataObject_SetTransfer *)src;
+ if (!t->Check())
+ return E_FAIL;
+ m_Transfer = *t;
+ if (t->Target.FuncType != k_DragTargetMode_Leave)
+ m_Transfer_WasSet = true;
+ bool needProcessBySource = !DestDirPrefix_FromTarget.IsEmpty();
+ if (t->Target.FuncType == k_DragTargetMode_Drop_Begin)
+ {
+ if (t->Target.Cmd_Type != NDragMenu::k_Copy_Base
+ // || t->Target.Cmd_Effect != DROPEFFECT_COPY
+ )
+ needProcessBySource = false;
+ }
+ if (t->Target.FuncType == k_DragTargetMode_Drop_End)
+ {
+ if (t->Target.Flags & k_TargetFlags_MustBeProcessedBySource)
+ needProcessBySource = true;
+ else if (t->Target.Flags & k_TargetFlags_WasProcessed)
+ needProcessBySource = false;
+ }
+ DoNotProcessInTarget = needProcessBySource;
+ }
+ else
+ {
+ // SetData() from Explorer Target:
+ if (etc->cfFormat == m_Format_PerformedDropEffect)
+ {
+ m_PerformedDropEffect_WasSet = false;
+ if (size == sizeof(DWORD))
+ {
+ m_PerformedDropEffect = *(const DWORD *)src;
+ m_PerformedDropEffect_WasSet = true;
+ }
+ }
+ else if (etc->cfFormat == m_Format_LogicalPerformedDropEffect)
+ {
+ m_LogicalPerformedDropEffect_WasSet = false;
+ if (size == sizeof(DWORD))
+ {
+ m_LogicalPerformedDropEffect = *(const DWORD *)src;
+ m_LogicalPerformedDropEffect_WasSet = true;
+ }
+ }
+ else if (etc->cfFormat == m_Format_DropDescription)
+ {
+ // drop description contains only name of dest folder without full path
+ #ifdef SHOW_DEBUG_DRAG
+ if (size == sizeof(MY_DROPDESCRIPTION))
+ {
+ // const MY_DROPDESCRIPTION *s = (const MY_DROPDESCRIPTION *)src;
+ // PRF3_W(s->szMessage);
+ // PRF3_W(s->szInsert);
+ }
+ #endif
+ }
+ else if (etc->cfFormat == m_Format_TargetCLSID)
+ {
+ // it's called after call QueryContinueDrag() (keyState & MK_LBUTTON) == 0
+ // Shell File System Folder (explorer) guid: F3364BA0-65B9-11CE-A9BA-00AA004AE837
+ #ifdef SHOW_DEBUG_DRAG
+ if (size == 16)
+ {
+ PrintFormat_GUIDToStringW((const Byte *)src);
+ }
+ #endif
+ }
+ else if (etc->cfFormat == m_Format_DisableDragText)
+ {
+ // (size == 4) (UInt32 value)
+ // value==0 : if drag to folder item or folder
+ // value==1 : if drag to file or non list_view */
+ }
+ else if (
+ etc->cfFormat == m_Format_IsShowingLayered ||
+ etc->cfFormat == m_Format_IsShowingText)
+ {
+ // (size == 4) (UInt32 value) value==0 :
+ }
+ else
+ hres = DV_E_FORMATETC;
+ // hres = E_NOTIMPL; // for debug
+ // hres = DV_E_FORMATETC; // for debug
+ }
+
+ GlobalUnlock(medium->hGlobal);
+ return hres;
+}
+
+
+
+static HGLOBAL DuplicateGlobalMem(HGLOBAL srcGlobal)
+{
+ /* GlobalSize() returns 0: If the specified handle
+ is not valid or if the object has been discarded */
+ const SIZE_T size = GlobalSize(srcGlobal);
+ if (size == 0)
+ return NULL;
+ // GlobalLock() can return NULL, if memory block has a zero-byte size
+ const void *src = GlobalLock(srcGlobal);
+ if (!src)
+ return NULL;
+ HGLOBAL destGlobal = GlobalAlloc(GHND | GMEM_SHARE, size);
+ if (destGlobal)
+ {
+ void *dest = GlobalLock(destGlobal);
+ if (!dest)
+ {
+ GlobalFree(destGlobal);
+ destGlobal = NULL;
+ }
+ else
+ {
+ memcpy(dest, src, size);
+ GlobalUnlock(destGlobal);
+ }
+ }
+ GlobalUnlock(srcGlobal);
+ return destGlobal;
+}
+
+
+static bool Medium_CopyFrom(LPSTGMEDIUM medium, const void *data, size_t size)
+{
+ medium->tymed = TYMED_NULL;
+ medium->pUnkForRelease = NULL;
+ medium->hGlobal = NULL;
+ const HGLOBAL global = GlobalAlloc(GHND | GMEM_SHARE, size);
+ if (!global)
+ return false;
+ void *dest = GlobalLock(global);
+ if (!dest)
+ {
+ GlobalFree(global);
+ return false;
+ }
+ memcpy(dest, data, size);
+ GlobalUnlock(global);
+ medium->hGlobal = global;
+ medium->tymed = TYMED_HGLOBAL;
+ return true;
+}
+
+
+Z7_COMWF_B CDataObject::GetData(LPFORMATETC etc, LPSTGMEDIUM medium)
+{
+ try {
+ PRF_(PrintFormat("-- GetData", etc->cfFormat))
+
+ medium->tymed = TYMED_NULL;
+ medium->pUnkForRelease = NULL;
+ medium->hGlobal = NULL;
+
+ if (NeedCall_Copy && !Copy_WasCalled)
+ CopyFromPanelTo_Folder();
+
+ // PRF3("+ CDataObject::GetData");
+ // PrintFormat(etc->cfFormat);
+ HGLOBAL global;
+ RINOK(QueryGetData(etc))
+
+ /*
+ if (etc->cfFormat == m_Format_FileOpFlags)
+ global = m_hGlobal_FileOpFlags;
+ else if (etc->cfFormat == m_Format_PreferredDropEffect)
+ {
+ // Explorer requests PreferredDropEffect only if Move/Copy selection is possible:
+ // Shift is not pressed and Ctrl is not pressed
+ PRF3("------ CDataObject::GetData() PreferredDropEffect");
+ global = m_hGlobal_PreferredDropEffect;
+ }
+ else
+ */
+ if (etc->cfFormat == m_Etc.cfFormat) // CF_HDROP
+ global = UsePreGlobal ? m_hGlobal_HDROP_Pre : m_hGlobal_HDROP_Final;
+ else if (etc->cfFormat == m_Format_7zip_GetTransfer)
+ {
+ CDataObject_GetTransfer transfer;
+ if (m_DestDirPrefix_FromTarget_WasSet)
+ {
+ transfer.Flags |= k_SourceFlags_SetTargetFolder;
+ }
+ if (!DestDirPrefix_FromTarget.IsEmpty())
+ {
+ transfer.Flags |= k_SourceFlags_SetTargetFolder_NonEmpty;
+ }
+ if (IsTempFiles)
+ {
+ transfer.Flags |= k_SourceFlags_TempFiles;
+ transfer.Flags |= k_SourceFlags_WaitFinish;
+ transfer.Flags |= k_SourceFlags_NeedExtractOpToFs;
+ if (UsePreGlobal)
+ transfer.Flags |= k_SourceFlags_NamesAreParent;
+ }
+ else
+ transfer.Flags |= k_SourceFlags_DoNotWaitFinish;
+
+ if (IsRightButton)
+ transfer.Flags |= k_SourceFlags_RightButton;
+ else
+ transfer.Flags |= k_SourceFlags_LeftButton;
+
+ if (DoNotProcessInTarget)
+ transfer.Flags |= k_SourceFlags_DoNotProcessInTarget;
+ if (Copy_WasCalled)
+ transfer.Flags |= k_SourceFlags_Copy_WasCalled;
+
+ if (Medium_CopyFrom(medium, &transfer, sizeof(transfer)))
+ return S_OK;
+ return E_OUTOFMEMORY;
+ }
+ else
+ return DV_E_FORMATETC;
+
+ if (!global)
+ return DV_E_FORMATETC;
+ medium->tymed = m_Etc.tymed;
+ medium->hGlobal = DuplicateGlobalMem(global);
+ if (!medium->hGlobal)
+ return E_OUTOFMEMORY;
+ return S_OK;
+ } catch(...) { return E_FAIL; }
+}
+
+Z7_COMWF_B CDataObject::GetDataHere(LPFORMATETC /* etc */, LPSTGMEDIUM /* medium */)
+{
+ PRF3("CDataObject::GetDataHere()");
+ // Seems Windows doesn't call it, so we will not implement it.
+ return E_UNEXPECTED;
+}
+
+
+/*
+ IDataObject::QueryGetData() Determines whether the data object is capable of
+ rendering the data as specified. Objects attempting a paste or drop
+ operation can call this method before calling IDataObject::GetData
+ to get an indication of whether the operation may be successful.
+
+ The client of a data object calls QueryGetData to determine whether
+ passing the specified FORMATETC structure to a subsequent call to
+ IDataObject::GetData is likely to be successful.
+
+ we check Try_QueryGetData with CF_HDROP
+*/
+
+Z7_COMWF_B CDataObject::QueryGetData(LPFORMATETC etc)
+{
+ PRF3("-- CDataObject::QueryGetData()");
+ if ( etc->cfFormat == m_Etc.cfFormat // CF_HDROP
+ || etc->cfFormat == m_Format_7zip_GetTransfer
+ // || (etc->cfFormat == m_Format_FileOpFlags && (HGLOBAL)m_hGlobal_FileOpFlags)
+ // || (etc->cfFormat == m_Format_PreferredDropEffect && (HGLOBAL)m_hGlobal_PreferredDropEffect)
+ )
+ {
+ }
+ else
+ return DV_E_FORMATETC;
+ if (etc->dwAspect != m_Etc.dwAspect)
+ return DV_E_DVASPECT;
+ /* GetData(): It is possible to specify more than one medium by using the Boolean OR
+ operator, allowing the method to choose the best medium among those specified. */
+ if ((etc->tymed & m_Etc.tymed) == 0)
+ return DV_E_TYMED;
+ return S_OK;
+}
+
+Z7_COMWF_B CDataObject::EnumFormatEtc(DWORD direction, LPENUMFORMATETC FAR* enumFormatEtc)
+{
+ // we don't enumerate for DATADIR_SET. Seems it can work without it.
+ if (direction != DATADIR_GET)
+ return E_NOTIMPL;
+ // we don't enumerate for m_Format_FileOpFlags also. Seems it can work without it.
+ return CreateEnumFormatEtc(1, &m_Etc, enumFormatEtc);
+}
+
+
+
+////////////////////////////////////////////////////////
+
+class CDropSource Z7_final:
+ public IDropSource,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_1_MT(IDropSource)
+ STDMETHOD(QueryContinueDrag)(BOOL escapePressed, DWORD keyState) Z7_override;
+ STDMETHOD(GiveFeedback)(DWORD effect) Z7_override;
+
+ DWORD m_Effect;
+public:
+ CDataObject *DataObjectSpec;
+ CMyComPtr<IDataObject> DataObject;
+
+ HRESULT DragProcessing_HRESULT;
+ bool DragProcessing_WasFinished;
+
+ CDropSource():
+ m_Effect(DROPEFFECT_NONE),
+ // Panel(NULL),
+ DragProcessing_HRESULT(S_OK),
+ DragProcessing_WasFinished(false)
+ {}
+};
+
+// static bool g_Debug = 0;
+
+
+Z7_COMWF_B CDropSource::QueryContinueDrag(BOOL escapePressed, DWORD keyState)
+{
+ // try {
+
+ /* Determines whether a drag-and-drop operation should be continued, canceled, or completed.
+ escapePressed : Indicates whether the Esc key has been pressed
+ since the previous call to QueryContinueDrag
+ or to DoDragDrop if this is the first call to QueryContinueDrag:
+ TRUE : the end user has pressed the escape key;
+ FALSE : it has not been pressed.
+ keyState : The current state of the keyboard modifier keys on the keyboard.
+ Possible values can be a combination of any of the flags:
+ MK_CONTROL, MK_SHIFT, MK_ALT, MK_BUTTON, MK_LBUTTON, MK_MBUTTON, and MK_RBUTTON.
+ */
+ #ifdef SHOW_DEBUG_DRAG
+ {
+ AString s ("CDropSource::QueryContinueDrag()");
+ s.Add_Space();
+ s += "keystate=";
+ s.Add_UInt32(keyState);
+ PRF4(s);
+ }
+ #endif
+
+ /*
+ if ((keyState & MK_LBUTTON) == 0)
+ {
+ // PRF4("CDropSource::QueryContinueDrag() (keyState & MK_LBUTTON) == 0");
+ g_Debug = true;
+ }
+ else
+ {
+ // PRF4("CDropSource::QueryContinueDrag() (keyState & MK_LBUTTON) != 0");
+ }
+ */
+
+ if (escapePressed)
+ {
+ // The drag operation should be canceled with no drop operation occurring.
+ DragProcessing_WasFinished = true;
+ DragProcessing_HRESULT = DRAGDROP_S_CANCEL;
+ return DRAGDROP_S_CANCEL;
+ }
+
+ if (DragProcessing_WasFinished)
+ return DragProcessing_HRESULT;
+
+ if ((keyState & MK_RBUTTON) != 0)
+ {
+ if (!DataObjectSpec->IsRightButton)
+ {
+ DragProcessing_WasFinished = true;
+ DragProcessing_HRESULT = DRAGDROP_S_CANCEL;
+ return DRAGDROP_S_CANCEL;
+ }
+ return S_OK;
+ }
+
+ if ((keyState & MK_LBUTTON) != 0)
+ {
+ if (DataObjectSpec->IsRightButton)
+ {
+ DragProcessing_WasFinished = true;
+ DragProcessing_HRESULT = DRAGDROP_S_CANCEL;
+ return DRAGDROP_S_CANCEL;
+ }
+ /* The drag operation should continue. This result occurs if no errors are detected,
+ the mouse button starting the drag-and-drop operation has not been released,
+ and the Esc key has not been detected. */
+ return S_OK;
+ }
+ {
+ // the mouse button starting the drag-and-drop operation has been released.
+
+ /* Win10 probably calls DragOver()/GiveFeedback() just before LBUTTON releasing.
+ so m_Effect is effect returned by DropTarget::DragOver()
+ just before LBUTTON releasing.
+ So here we can use Effect sent to last GiveFeedback() */
+
+ if (m_Effect == DROPEFFECT_NONE)
+ {
+ DragProcessing_WasFinished = true;
+ DragProcessing_HRESULT = DRAGDROP_S_CANCEL;
+ // Drop target cannot accept the data. So we cancel drag and drop
+ // maybe return DRAGDROP_S_DROP also OK here ?
+ // return DRAGDROP_S_DROP; // for debug
+ return DRAGDROP_S_CANCEL;
+ }
+
+ // we switch to real names for items that will be created in temp folder
+ DataObjectSpec->UsePreGlobal = false;
+ DataObjectSpec->Copy_HRESULT = S_OK;
+ // MoveMode = (((keyState & MK_SHIFT) != 0) && MoveIsAllowed);
+ /*
+ if (DataObjectSpec->IsRightButton)
+ return DRAGDROP_S_DROP;
+ */
+
+ if (DataObjectSpec->IsTempFiles)
+ {
+ if (!DataObjectSpec->DestDirPrefix_FromTarget.IsEmpty())
+ {
+ /* we know the destination Path.
+ So we can copy or extract items later in Source with simpler code. */
+ DataObjectSpec->DoNotProcessInTarget = true;
+ // return DRAGDROP_S_CANCEL;
+ }
+ else
+ {
+ DataObjectSpec->NeedCall_Copy = true;
+ /*
+ if (Copy_HRESULT != S_OK || !Messages.IsEmpty())
+ {
+ DragProcessing_WasFinished = true;
+ DragProcessing_HRESULT = DRAGDROP_S_CANCEL;
+ return DRAGDROP_S_CANCEL;
+ }
+ */
+ }
+ }
+ DragProcessing_HRESULT = DRAGDROP_S_DROP;
+ DragProcessing_WasFinished = true;
+ return DRAGDROP_S_DROP;
+ }
+ // } catch(...) { return E_FAIL; }
+}
+
+
+Z7_COMWF_B CDropSource::GiveFeedback(DWORD effect)
+{
+ // PRF3("CDropSource::GiveFeedback");
+ /* Enables a source application to give visual feedback to the end user
+ during a drag-and-drop operation by providing the DoDragDrop function
+ with an enumeration value specifying the visual effect.
+ in (effect):
+ The DROPEFFECT value returned by the most recent call to
+ IDropTarget::DragEnter,
+ IDropTarget::DragOver,
+ or DROPEFFECT_NONE after IDropTarget::DragLeave.
+ 0: DROPEFFECT_NONE
+ 1: DROPEFFECT_COPY
+ 2: DROPEFFECT_MOVE
+ 4: DROPEFFECT_LINK
+ 0x80000000: DROPEFFECT_SCROLL
+ The dwEffect parameter can include DROPEFFECT_SCROLL, indicating that the
+ source should put up the drag-scrolling variation of the appropriate pointer.
+ */
+ m_Effect = effect;
+
+ #ifdef SHOW_DEBUG_DRAG
+ AString w ("GiveFeedback effect=");
+ if (effect & DROPEFFECT_SCROLL)
+ w += " SCROLL ";
+ w.Add_UInt32(effect & ~DROPEFFECT_SCROLL);
+ // if (g_Debug)
+ PRF4(w);
+ #endif
+
+ /* S_OK : no special drag and drop cursors.
+ Maybe it's for case where we created custom custom cursors.
+ DRAGDROP_S_USEDEFAULTCURSORS: Indicates successful completion of the method,
+ and requests OLE to update the cursor using the OLE-provided default cursors. */
+ // return S_OK; // for debug
+ return DRAGDROP_S_USEDEFAULTCURSORS;
+}
+
+
+
+/*
+static bool Global_SetUInt32(NMemory::CGlobal &hg, const UInt32 v)
+{
+ if (!hg.Alloc(GHND | GMEM_SHARE, sizeof(v)))
+ return false;
+ NMemory::CGlobalLock dropLock(hg);
+ *(UInt32 *)dropLock.GetPointer() = v;
+ return true;
+}
+*/
+
+static bool CopyNamesToHGlobal(NMemory::CGlobal &hgDrop, const UStringVector &names)
+{
+ size_t totalLen = 1;
+
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ AStringVector namesA;
+ unsigned i;
+ for (i = 0; i < names.Size(); i++)
+ namesA.Add(GetSystemString(names[i]));
+ for (i = 0; i < namesA.Size(); i++)
+ totalLen += namesA[i].Len() + 1;
+
+ if (!hgDrop.Alloc(GHND | GMEM_SHARE, totalLen * sizeof(CHAR) + sizeof(DROPFILES)))
+ return false;
+
+ NMemory::CGlobalLock dropLock(hgDrop);
+ DROPFILES *dropFiles = (DROPFILES *)dropLock.GetPointer();
+ if (!dropFiles)
+ return false;
+ dropFiles->fNC = FALSE;
+ dropFiles->pt.x = 0;
+ dropFiles->pt.y = 0;
+ dropFiles->pFiles = sizeof(DROPFILES);
+ dropFiles->fWide = FALSE;
+ CHAR *p = (CHAR *) (void *) ((BYTE *)dropFiles + sizeof(DROPFILES));
+ for (i = 0; i < namesA.Size(); i++)
+ {
+ const AString &s = namesA[i];
+ const unsigned fullLen = s.Len() + 1;
+ MyStringCopy(p, (const char *)s);
+ p += fullLen;
+ totalLen -= fullLen;
+ }
+ *p = 0;
+ }
+ else
+ #endif
+ {
+ unsigned i;
+ for (i = 0; i < names.Size(); i++)
+ totalLen += names[i].Len() + 1;
+
+ if (!hgDrop.Alloc(GHND | GMEM_SHARE, totalLen * sizeof(WCHAR) + sizeof(DROPFILES)))
+ return false;
+
+ NMemory::CGlobalLock dropLock(hgDrop);
+ DROPFILES *dropFiles = (DROPFILES *)dropLock.GetPointer();
+ if (!dropFiles)
+ return false;
+ /* fNC:
+ TRUE : pt specifies the screen coordinates of a point in a window's nonclient area.
+ FALSE : pt specifies the client coordinates of a point in the client area.
+ */
+ dropFiles->fNC = FALSE;
+ dropFiles->pt.x = 0;
+ dropFiles->pt.y = 0;
+ dropFiles->pFiles = sizeof(DROPFILES);
+ dropFiles->fWide = TRUE;
+ WCHAR *p = (WCHAR *) (void *) ((BYTE *)dropFiles + sizeof(DROPFILES));
+ for (i = 0; i < names.Size(); i++)
+ {
+ const UString &s = names[i];
+ const unsigned fullLen = s.Len() + 1;
+ MyStringCopy(p, (const WCHAR *)s);
+ p += fullLen;
+ totalLen -= fullLen;
+ }
+ *p = 0;
+ }
+ // if (totalLen != 1) return false;
+ return true;
+}
+
+
+void CPanel::OnDrag(LPNMLISTVIEW /* nmListView */, bool isRightButton)
+{
+ PRF("CPanel::OnDrag");
+ if (!DoesItSupportOperations())
+ return;
+
+ CDisableTimerProcessing disableTimerProcessing2(*this);
+
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ if (indices.Size() == 0)
+ return;
+
+ // CSelectedState selState;
+ // SaveSelectedState(selState);
+
+ const bool isFSFolder = IsFSFolder();
+ // why we don't allow drag with rightButton from archive?
+ if (!isFSFolder && isRightButton)
+ return;
+
+ UString dirPrefix;
+ CTempDir tempDirectory;
+
+ CDataObject *dataObjectSpec = new CDataObject;
+ CMyComPtr<IDataObject> dataObject = dataObjectSpec;
+ dataObjectSpec->IsRightButton = isRightButton;
+
+ {
+ /* we can change confirmation mode and another options.
+ Explorer target requests that FILEOP_FLAGS value. */
+ /*
+ const FILEOP_FLAGS fopFlags =
+ FOF_NOCONFIRMATION
+ | FOF_NOCONFIRMMKDIR
+ | FOF_NOERRORUI
+ | FOF_SILENT;
+ // | FOF_SIMPLEPROGRESS; // it doesn't work as expected in Win10
+ Global_SetUInt32(dataObjectSpec->m_hGlobal_FileOpFlags, fopFlags);
+ // dataObjectSpec->m_hGlobal_FileOpFlags.Free(); // for debug : disable these options
+ */
+ }
+ {
+ /* we can change Preferred DropEffect.
+ Explorer target requests that FILEOP_FLAGS value. */
+ /*
+ const DWORD effect = DROPEFFECT_MOVE; // DROPEFFECT_COPY;
+ Global_SetUInt32(dataObjectSpec->m_hGlobal_PreferredDropEffect, effect);
+ */
+ }
+ if (isFSFolder)
+ {
+ dirPrefix = GetFsPath(); // why this in 22.01 ?
+ dataObjectSpec->UsePreGlobal = false;
+ // dataObjectSpec->IsTempFiles = false;
+ }
+ else
+ {
+ if (!tempDirectory.Create(kTempDirPrefix))
+ {
+ MessageBox_Error(L"Can't create temp folder");
+ return;
+ }
+ dirPrefix = fs2us(tempDirectory.GetPath());
+ {
+ UStringVector names;
+ names.Add(dirPrefix);
+ dataObjectSpec->IsTempFiles = true;
+ dataObjectSpec->UsePreGlobal = true;
+ if (!CopyNamesToHGlobal(dataObjectSpec->m_hGlobal_HDROP_Pre, names))
+ return;
+ }
+ NFile::NName::NormalizeDirPathPrefix(dirPrefix);
+ /*
+ {
+ FString path2 = dirPrefix;
+ path2 += "1.txt";
+ CopyFileW(L"C:\\1\\1.txt", path2, FALSE);
+ }
+ */
+ }
+
+ {
+ UStringVector names;
+ // names variable is USED for drag and drop from 7-zip to Explorer or to 7-zip archive folder.
+ // names variable is NOT USED for drag and drop from 7-zip to 7-zip File System folder.
+ FOR_VECTOR (i, indices)
+ {
+ const UInt32 index = indices[i];
+ UString s;
+ if (isFSFolder)
+ s = GetItemRelPath(index);
+ else
+ {
+ s = GetItemName(index);
+ /*
+ // We use (keepAndReplaceEmptyPrefixes = true) in CAgentFolder::Extract
+ // So the following code is not required.
+ // Maybe we also can change IFolder interface and send some flag also.
+ if (s.IsEmpty())
+ {
+ // Correct_FsFile_Name("") returns "_".
+ // If extracting code removes empty folder prefixes from path (as it was in old version),
+ // Explorer can't find "_" folder in temp folder.
+ // We can ask Explorer to copy parent temp folder "7zE" instead.
+ names.Clear();
+ names.Add(dirPrefix2);
+ break;
+ }
+ */
+ s = Get_Correct_FsFile_Name(s);
+ }
+ names.Add(dirPrefix + s);
+ }
+ if (!CopyNamesToHGlobal(dataObjectSpec->m_hGlobal_HDROP_Final, names))
+ return;
+ }
+
+ CDropSource *dropSourceSpec = new CDropSource;
+ CMyComPtr<IDropSource> dropSource = dropSourceSpec;
+ dataObjectSpec->Panel = this;
+ dataObjectSpec->Indices = indices;
+ dataObjectSpec->SrcDirPrefix_Temp = dirPrefix;
+
+ dropSourceSpec->DataObjectSpec = dataObjectSpec;
+ dropSourceSpec->DataObject = dataObjectSpec;
+
+
+ /*
+ CTime - file creation timestamp.
+ There are two operations in Windows with Drag and Drop:
+ COPY_OPERATION : icon with Plus sign : CTime will be set as current_time.
+ MOVE_OPERATION : icon without Plus sign : CTime will be preserved.
+
+ Note: if we call DoDragDrop() with (effectsOK = DROPEFFECT_MOVE), then
+ it will use MOVE_OPERATION and CTime will be preserved.
+ But MoveFile() function doesn't preserve CTime, if different volumes are used.
+ Why it's so?
+ Does DoDragDrop() use some another function (not MoveFile())?
+
+ if (effectsOK == DROPEFFECT_COPY) it works as COPY_OPERATION
+
+ if (effectsOK == DROPEFFECT_MOVE) drag works as MOVE_OPERATION
+
+ if (effectsOK == (DROPEFFECT_COPY | DROPEFFECT_MOVE))
+ {
+ if we drag file to same volume, then Windows suggests:
+ CTRL - COPY_OPERATION
+ [default] - MOVE_OPERATION
+
+ if we drag file to another volume, then Windows suggests
+ [default] - COPY_OPERATION
+ SHIFT - MOVE_OPERATION
+ }
+
+ We want to use MOVE_OPERATION for extracting from archive (open in 7-Zip) to Explorer:
+ It has the following advantages:
+ 1) it uses fast MOVE_OPERATION instead of slow COPY_OPERATION and DELETE, if same volume.
+ 2) it preserves CTime
+
+ Some another programs support only COPY_OPERATION.
+ So we can use (DROPEFFECT_COPY | DROPEFFECT_MOVE)
+
+ Also another program can return from DoDragDrop() before
+ files using. But we delete temp folder after DoDragDrop(),
+ and another program can't open input files in that case.
+
+ We create objects:
+ IDropSource *dropSource
+ IDataObject *dataObject
+ if DropTarget is 7-Zip window, then 7-Zip's
+ IDropTarget::DragOver() sets DestDirPrefix_FromTarget in IDataObject.
+ and
+ IDropSource::QueryContinueDrag() sets DoNotProcessInTarget, if DestDirPrefix_FromTarget is not empty.
+ So we can detect destination path after DoDragDrop().
+ Now we don't know any good way to detect destination path for D&D to Explorer.
+ */
+
+ /*
+ DWORD effectsOK = DROPEFFECT_COPY;
+ if (moveIsAllowed)
+ effectsOK |= DROPEFFECT_MOVE;
+ */
+ const bool moveIsAllowed = isFSFolder;
+ _panelCallback->DragBegin();
+ PRF("=== DoDragDrop()");
+ DWORD effect = 0;
+ // 18.04: was changed
+ const DWORD effectsOK = DROPEFFECT_MOVE | DROPEFFECT_COPY;
+ // effectsOK |= (1 << 8); // for debug
+ HRESULT res = ::DoDragDrop(dataObject, dropSource, effectsOK, &effect);
+ PRF("=== After DoDragDrop()");
+ _panelCallback->DragEnd();
+
+ /*
+ Win10 drag and drop to Explorer:
+ DoDragDrop() output variables:
+ for MOVE operation:
+ {
+ effect == DROPEFFECT_NONE;
+ dropSourceSpec->m_PerformedDropEffect == DROPEFFECT_MOVE;
+ }
+ for COPY operation:
+ {
+ effect == DROPEFFECT_COPY;
+ dropSourceSpec->m_PerformedDropEffect == DROPEFFECT_COPY;
+ }
+ DOCs: The source inspects the two values that can be returned by the target.
+ If both are set to DROPEFFECT_MOVE, it completes the unoptimized move
+ by deleting the original data. Otherwise, the target did an optimized
+ move and the original data has been deleted.
+
+ We didn't see "unoptimized move" case (two values of DROPEFFECT_MOVE),
+ where we still need to delete source files.
+ So we don't delete files after DoDragDrop().
+
+ Also DOCs say for "optimized move":
+ The target also calls the data object's IDataObject::SetData method and passes
+ it a CFSTR_PERFORMEDDROPEFFECT format identifier set to DROPEFFECT_NONE.
+ but actually in Win10 we always have
+ (dropSourceSpec->m_PerformedDropEffect == DROPEFFECT_MOVE)
+ for any MOVE operation.
+ */
+
+ const bool canceled = (res == DRAGDROP_S_CANCEL);
+
+ CDisableNotify disableNotify(*this);
+
+ if (res == DRAGDROP_S_DROP)
+ {
+ /* DRAGDROP_S_DROP is returned. It means that
+ - IDropTarget::Drop() was called,
+ - IDropTarget::Drop() returned (ret_code >= 0)
+ */
+ res = dataObjectSpec->Copy_HRESULT;
+ bool need_Process = dataObjectSpec->DoNotProcessInTarget;
+ if (dataObjectSpec->m_Transfer_WasSet)
+ {
+ if (dataObjectSpec->m_Transfer.Target.FuncType == k_DragTargetMode_Drop_End)
+ {
+ if (dataObjectSpec->m_Transfer.Target.Flags & k_TargetFlags_MustBeProcessedBySource)
+ need_Process = true;
+ }
+ }
+
+ if (need_Process)
+ if (!dataObjectSpec->DestDirPrefix_FromTarget.IsEmpty())
+ {
+ if (!NFile::NName::IsAltStreamPrefixWithColon(dataObjectSpec->DestDirPrefix_FromTarget))
+ NFile::NName::NormalizeDirPathPrefix(dataObjectSpec->DestDirPrefix_FromTarget);
+ CCopyToOptions options;
+ options.folder = dataObjectSpec->DestDirPrefix_FromTarget;
+ // if MOVE is not allowed, we just use COPY operation
+ /* it was 7-zip's Target that set non-empty dataObjectSpec->DestDirPrefix_FromTarget.
+ it means that target didn't completed operation,
+ and we can use (effect) value returned by target via DoDragDrop().
+ as indicator of type of operation
+ */
+ // options.moveMode = (moveIsAllowed && effect == DROPEFFECT_MOVE) // before v23.00:
+ options.moveMode = moveIsAllowed;
+ if (moveIsAllowed)
+ {
+ if (dataObjectSpec->m_Transfer_WasSet)
+ options.moveMode = (
+ dataObjectSpec->m_Transfer.Target.Cmd_Effect == DROPEFFECT_MOVE);
+ else
+ options.moveMode = (effect == DROPEFFECT_MOVE);
+ // we expect (DROPEFFECT_MOVE) as indicator of move operation for Drag&Drop MOVE ver 22.01.
+ }
+ res = CopyTo(options, indices, &dataObjectSpec->Messages);
+ }
+ /*
+ if (effect & DROPEFFECT_MOVE)
+ RefreshListCtrl(selState);
+ */
+ }
+ else
+ {
+ // we ignore E_UNEXPECTED that is returned if we drag file to printer
+ if (res != DRAGDROP_S_CANCEL
+ && res != S_OK
+ && res != E_UNEXPECTED)
+ MessageBox_Error_HRESULT(res);
+ res = dataObjectSpec->Copy_HRESULT;
+ }
+
+ if (!dataObjectSpec->Messages.IsEmpty())
+ {
+ CMessagesDialog messagesDialog;
+ messagesDialog.Messages = &dataObjectSpec->Messages;
+ messagesDialog.Create((*this));
+ }
+
+ if (res != S_OK && res != E_ABORT)
+ {
+ // we restore Notify before MessageBox_Error_HRESULT. So we will see files selection
+ disableNotify.Restore();
+ // SetFocusToList();
+ MessageBox_Error_HRESULT(res);
+ }
+ if (res == S_OK && dataObjectSpec->Messages.IsEmpty() && !canceled)
+ KillSelection();
+}
+
+
+
+
+
+CDropTarget::CDropTarget():
+ m_IsRightButton(false),
+ m_GetTransfer_WasSuccess(false),
+ m_DropIsAllowed(false),
+ m_PanelDropIsAllowed(false),
+ // m_DropHighlighted_SelectionIndex(-1),
+ // m_SubFolderIndex(-1),
+ m_Panel(NULL),
+ m_IsAppTarget(false),
+ m_TargetPath_WasSent_ToDataObject(false),
+ m_TargetPath_NonEmpty_WasSent_ToDataObject(false),
+ m_Transfer_WasSent_ToDataObject(false),
+ App(NULL),
+ SrcPanelIndex(-1),
+ TargetPanelIndex(-1)
+{
+ m_Format_7zip_SetTargetFolder = RegisterClipboardFormat(k_Format_7zip_SetTargetFolder);
+ m_Format_7zip_SetTransfer = RegisterClipboardFormat(k_Format_7zip_SetTransfer);
+ m_Format_7zip_GetTransfer = RegisterClipboardFormat(k_Format_7zip_GetTransfer);
+
+ m_ProcessId = GetCurrentProcessId();
+ // m_TransactionId = ((UInt64)m_ProcessId << 32) + 1;
+ // ClearState();
+}
+
+// clear internal state
+void CDropTarget::ClearState()
+{
+ m_DataObject.Release();
+ m_SourcePaths.Clear();
+
+ m_IsRightButton = false;
+
+ m_GetTransfer_WasSuccess = false;
+ m_DropIsAllowed = false;
+
+ m_PanelDropIsAllowed = false;
+ // m_SubFolderIndex = -1;
+ // m_DropHighlighted_SubFolderName.Empty();
+ m_Panel = NULL;
+ m_IsAppTarget = false;
+ m_TargetPath_WasSent_ToDataObject = false;
+ m_TargetPath_NonEmpty_WasSent_ToDataObject = false;
+ m_Transfer_WasSent_ToDataObject = false;
+}
+
+/*
+ IDataObject::QueryGetData() Determines whether the data object is capable of
+ rendering the data as specified. Objects attempting a paste or drop
+ operation can call this method before calling IDataObject::GetData
+ to get an indication of whether the operation may be successful.
+
+ The client of a data object calls QueryGetData to determine whether
+ passing the specified FORMATETC structure to a subsequent call to
+ IDataObject::GetData is likely to be successful.
+
+ We check Try_QueryGetData with CF_HDROP
+*/
+/*
+void CDropTarget::Try_QueryGetData(IDataObject *dataObject)
+{
+ FORMATETC etc = { CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+ m_DropIsAllowed = (dataObject->QueryGetData(&etc) == S_OK);
+}
+*/
+
+static void ListView_SetItemState_DropHighlighted(
+ NControl::CListView &listView, int index, bool highlighted)
+{
+ // LVIS_DROPHILITED : The item is highlighted as a drag-and-drop target
+ /*
+ LVITEM item;
+ item.mask = LVIF_STATE;
+ item.iItem = index;
+ item.iSubItem = 0;
+ item.state = enable ? LVIS_DROPHILITED : 0;
+ item.stateMask = LVIS_DROPHILITED;
+ item.pszText = NULL;
+ listView.SetItem(&item);
+ */
+ listView.SetItemState(index, highlighted ? LVIS_DROPHILITED : 0, LVIS_DROPHILITED);
+}
+
+// Removes DropHighlighted state in ListView item, if it was set before
+void CDropTarget::RemoveSelection()
+{
+ if (m_Panel)
+ {
+ m_Panel->m_DropHighlighted_SubFolderName.Empty();
+ if (m_Panel->m_DropHighlighted_SelectionIndex >= 0)
+ {
+ ListView_SetItemState_DropHighlighted(m_Panel->_listView,
+ m_Panel->m_DropHighlighted_SelectionIndex, false);
+ m_Panel->m_DropHighlighted_SelectionIndex = -1;
+ }
+ }
+}
+
+#ifdef UNDER_CE
+#define ChildWindowFromPointEx(hwndParent, pt, uFlags) ChildWindowFromPoint(hwndParent, pt)
+#endif
+
+
+/*
+ PositionCursor() function sets m_Panel under cursor drop, and
+ m_SubFolderIndex/m_DropHighlighted_SubFolderName, if drop to some folder in Panel list.
+*/
+/*
+PositionCursor() uses as input variables:
+ m_DropIsAllowed must be set before PositionCursor()
+ if (m_DropHighlighted_SelectionIndex >= 0 && m_Panel) it uses m_Panel and removes previous selection
+PositionCursor() sets
+ m_PanelDropIsAllowed
+ m_Panel
+ m_IsAppTarget
+ m_SubFolderIndex
+ m_DropHighlighted_SubFolderName
+ m_DropHighlighted_SelectionIndex
+*/
+void CDropTarget::PositionCursor(const POINTL &ptl)
+{
+ RemoveSelection();
+
+ // m_SubFolderIndex = -1;
+ // m_DropHighlighted_SubFolderName.Empty();
+ m_IsAppTarget = true;
+ m_Panel = NULL;
+ m_PanelDropIsAllowed = false;
+
+ if (!m_DropIsAllowed)
+ return;
+
+ POINT pt;
+ pt.x = ptl.x;
+ pt.y = ptl.y;
+ {
+ POINT pt2 = pt;
+ if (App->_window.ScreenToClient(&pt2))
+ for (unsigned i = 0; i < kNumPanelsMax; i++)
+ if (App->IsPanelVisible(i))
+ {
+ CPanel *panel = &App->Panels[i];
+ if (panel->IsEnabled())
+ if (::ChildWindowFromPointEx(App->_window, pt2,
+ CWP_SKIPINVISIBLE | CWP_SKIPDISABLED) == (HWND)*panel)
+ {
+ m_Panel = panel;
+ m_IsAppTarget = false;
+ if ((int)i == SrcPanelIndex)
+ return; // we don't allow to drop to source panel
+ break;
+ }
+ }
+ }
+
+ m_PanelDropIsAllowed = true;
+
+ if (!m_Panel)
+ {
+ if (TargetPanelIndex >= 0)
+ m_Panel = &App->Panels[TargetPanelIndex];
+ // we don't need to find item in panel
+ return;
+ }
+
+ // we will try to find and highlight drop folder item in listView under cursor
+ /*
+ m_PanelDropIsAllowed = m_Panel->DoesItSupportOperations();
+ if (!m_PanelDropIsAllowed)
+ return;
+ */
+ /* now we don't allow drop to subfolder under cursor, if dest panel is archive.
+ Another code must be fixed for that case, where we must use m_SubFolderIndex/m_DropHighlighted_SubFolderName */
+ if (!m_Panel->IsFsOrPureDrivesFolder())
+ return;
+
+ if (::WindowFromPoint(pt) != (HWND)m_Panel->_listView)
+ return;
+
+ LVHITTESTINFO info;
+ m_Panel->_listView.ScreenToClient(&pt);
+ info.pt = pt;
+ const int index = ListView_HitTest(m_Panel->_listView, &info);
+ if (index < 0)
+ return;
+ const unsigned realIndex = m_Panel->GetRealItemIndex(index);
+ if (realIndex == kParentIndex)
+ return;
+ if (!m_Panel->IsItem_Folder(realIndex))
+ return;
+ // m_SubFolderIndex = (int)realIndex;
+ m_Panel->m_DropHighlighted_SubFolderName = m_Panel->GetItemName(realIndex);
+ ListView_SetItemState_DropHighlighted(m_Panel->_listView, index, true);
+ m_Panel->m_DropHighlighted_SelectionIndex = index;
+}
+
+
+/* returns true, if !m_IsAppTarget
+ and target is FS folder or altStream folder
+*/
+
+UInt32 CDropTarget::GetFolderType() const
+{
+ if (m_IsAppTarget || !m_Panel)
+ return k_FolderType_None;
+ if (m_Panel->IsFSFolder() ||
+ (m_Panel->IsFSDrivesFolder()
+ && m_Panel->m_DropHighlighted_SelectionIndex >= 0))
+ return k_FolderType_Fs;
+ if (m_Panel->IsAltStreamsFolder())
+ return k_FolderType_AltStreams;
+ if (m_Panel->IsArcFolder())
+ return k_FolderType_Archive;
+ return k_FolderType_Unknown;
+}
+
+bool CDropTarget::IsFsFolderPath() const
+{
+ if (m_IsAppTarget || !m_Panel)
+ return false;
+ if (m_Panel->IsFSFolder())
+ return true;
+ if (m_Panel->IsAltStreamsFolder())
+ return true;
+ return m_Panel->IsFSDrivesFolder() &&
+ m_Panel->m_DropHighlighted_SelectionIndex >= 0;
+}
+
+
+#define INIT_FORMATETC_HGLOBAL(type) { (type), NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }
+
+static bool DataObject_GetData_GetTransfer(IDataObject *dataObject,
+ UINT a_Format_7zip_GetTransfer, CDataObject_GetTransfer &transfer)
+{
+ FORMATETC etc = INIT_FORMATETC_HGLOBAL((CLIPFORMAT)a_Format_7zip_GetTransfer);
+ NCOM::CStgMedium medium;
+ const HRESULT res = dataObject->GetData(&etc, &medium);
+ if (res != S_OK)
+ return false;
+ if (medium.tymed != TYMED_HGLOBAL)
+ return false;
+ const size_t size = GlobalSize(medium.hGlobal);
+ if (size < sizeof(transfer))
+ return false;
+ NMemory::CGlobalLock dropLock(medium.hGlobal);
+ const CDataObject_GetTransfer *t = (const CDataObject_GetTransfer *)dropLock.GetPointer();
+ if (!t)
+ return false;
+ if (!t->Check()) // isSetData
+ return false;
+ transfer = *t;
+ return true;
+}
+
+/*
+ returns true, if all m_SourcePaths[] items are same drive
+ as destination drop path in m_Panel
+*/
+bool CDropTarget::IsItSameDrive() const
+{
+ if (!m_Panel)
+ return false;
+ if (!IsFsFolderPath())
+ return false;
+
+ UString drive;
+
+ if (m_Panel->IsFSFolder())
+ {
+ drive = m_Panel->GetDriveOrNetworkPrefix();
+ if (drive.IsEmpty())
+ return false;
+ }
+ else if (m_Panel->IsFSDrivesFolder()
+ && m_Panel->m_DropHighlighted_SelectionIndex >= 0)
+ {
+ drive = m_Panel->m_DropHighlighted_SubFolderName;
+ drive.Add_PathSepar();
+ }
+ else
+ return false;
+
+ if (m_SourcePaths.Size() == 0)
+ return false;
+
+ FOR_VECTOR (i, m_SourcePaths)
+ {
+ if (!m_SourcePaths[i].IsPrefixedBy_NoCase(drive))
+ return false;
+ }
+ return true;
+}
+
+
+/*
+ There are 2 different actions, when we drag to 7-Zip:
+ 1) if target panel is "7-Zip" FS and any of the 2 cases:
+ - Drag from any non "7-Zip" program;
+ or
+ - Drag from "7-Zip" to non-panel area of "7-Zip".
+ We want to create new archive for that operation with "Add to Archive" window.
+ 2) all another operations work as usual file COPY/MOVE
+ - Drag from "7-Zip" FS to "7-Zip" FS.
+ COPY/MOVE are supported.
+ - Drag to open archive in 7-Zip.
+ We want to update archive.
+ We replace COPY to MOVE.
+ - Drag from "7-Zip" archive to "7-Zip" FS.
+ We replace COPY to MOVE.
+*/
+
+// we try to repeat Explorer's effects.
+// out: 0 - means that use default effect
+static DWORD GetEffect_ForKeys(DWORD keyState)
+{
+ if (keyState & MK_CONTROL)
+ {
+ if (keyState & MK_ALT)
+ return 0;
+ if (keyState & MK_SHIFT)
+ return DROPEFFECT_LINK; // CONTROL + SHIFT
+ return DROPEFFECT_COPY; // CONTROL
+ }
+ // no CONTROL
+ if (keyState & MK_SHIFT)
+ {
+ if (keyState & MK_ALT)
+ return 0;
+ return DROPEFFECT_MOVE; // SHIFT
+ }
+ // no CONTROL, no SHIFT
+ if (keyState & MK_ALT)
+ return DROPEFFECT_LINK; // ALT
+ return 0;
+}
+
+
+/* GetEffect() uses m_TargetPath_WasSentToDataObject
+ to disale MOVE operation, if Source is not 7-Zip
+*/
+DWORD CDropTarget::GetEffect(DWORD keyState, POINTL /* pt */, DWORD allowedEffect) const
+{
+ // (DROPEFFECT_NONE == 0)
+ if (!m_DropIsAllowed || !m_PanelDropIsAllowed)
+ return 0;
+ if (!IsFsFolderPath() || !m_TargetPath_WasSent_ToDataObject)
+ {
+ // we don't allow MOVE, if Target is archive or Source is not 7-Zip
+ // disabled for debug:
+ // allowedEffect &= ~DROPEFFECT_MOVE;
+ }
+ DWORD effect;
+ {
+ effect = GetEffect_ForKeys(keyState);
+ if (effect == DROPEFFECT_LINK)
+ return 0;
+ effect &= allowedEffect;
+ }
+ if (effect == 0)
+ {
+ if (allowedEffect & DROPEFFECT_COPY)
+ effect = DROPEFFECT_COPY;
+ if (allowedEffect & DROPEFFECT_MOVE)
+ {
+ /* MOVE operation can be optimized. So MOVE is preferred way
+ for default action, if Source and Target are at same drive */
+ if (IsItSameDrive())
+ effect = DROPEFFECT_MOVE;
+ }
+ }
+ return effect;
+}
+
+
+/* returns:
+ - target folder path prefix, if target is FS folder
+ - empty string, if target is not FS folder
+*/
+UString CDropTarget::GetTargetPath() const
+{
+ if (!IsFsFolderPath())
+ return UString();
+ UString path = m_Panel->GetFsPath();
+ if (/* m_SubFolderIndex >= 0 && */
+ !m_Panel->m_DropHighlighted_SubFolderName.IsEmpty())
+ {
+ path += m_Panel->m_DropHighlighted_SubFolderName;
+ path.Add_PathSepar();
+ }
+ return path;
+}
+
+
+/*
+if IDropSource is Win10-Explorer
+--------------------------------
+ As in MS DOCs:
+ The source inspects the two (effect) values that can be returned by the target:
+ 1) SetData(CFSTR_PERFORMEDDROPEFFECT)
+ 2) returned value (*effect) by
+ CDropTarget::Drop(IDataObject *dataObject, DWORD keyState,
+ POINTL pt, DWORD *effect)
+ If both are set to DROPEFFECT_MOVE, Explorer completes the unoptimized move by deleting
+ the original data.
+ // Otherwise, the target did an optimized move and the original data has been deleted.
+*/
+
+
+/*
+ Send targetPath from target to dataObject (to Source)
+ input: set (enablePath = false) to send empty path
+ returns true, if SetData() returns S_OK : (source is 7-zip)
+ returns false, if SetData() doesn't return S_OK : (source is Explorer)
+*/
+bool CDropTarget::SendToSource_TargetPath_enable(IDataObject *dataObject, bool enablePath)
+{
+ m_TargetPath_NonEmpty_WasSent_ToDataObject = false;
+ UString path;
+ if (enablePath)
+ path = GetTargetPath();
+ PRF("CDropTarget::SetPath");
+ PRF_W(path);
+ if (!dataObject || m_Format_7zip_SetTargetFolder == 0)
+ return false;
+ FORMATETC etc = INIT_FORMATETC_HGLOBAL((CLIPFORMAT)m_Format_7zip_SetTargetFolder);
+ STGMEDIUM medium;
+ medium.tymed = etc.tymed;
+ medium.pUnkForRelease = NULL;
+ const size_t num = path.Len() + 1; // + (1 << 19) // for debug
+ medium.hGlobal = GlobalAlloc(GHND | GMEM_SHARE, num * sizeof(wchar_t));
+ if (!medium.hGlobal)
+ return false;
+ // Sleep(1000);
+ wchar_t *dest = (wchar_t *)GlobalLock(medium.hGlobal);
+ // Sleep(1000);
+ bool res = false;
+ if (dest)
+ {
+ MyStringCopy(dest, (const wchar_t *)path);
+ GlobalUnlock(medium.hGlobal);
+ // OutputDebugString("m_DataObject->SetData");
+ const BOOL release = FALSE; // that way is more simple for correct releasing.
+ // TRUE; // for debug : is not good for some cases.
+ /* If DropSource is Win10-Explorer, dataObject->SetData() returns E_NOTIMPL; */
+ const HRESULT hres = dataObject->SetData(&etc, &medium, release);
+ // Sleep(1000);
+ res = (hres == S_OK);
+ }
+
+ ReleaseStgMedium(&medium);
+ if (res && !path.IsEmpty())
+ m_TargetPath_NonEmpty_WasSent_ToDataObject = true;
+ // Sleep(1000);
+ return res;
+}
+
+
+void CDropTarget::SendToSource_auto(IDataObject *dataObject,
+ const CTargetTransferInfo &info)
+{
+ /* we try to send target path to Source.
+ If Source is 7-Zip, then it will accept k_Format_7zip_SetTargetFolder.
+ That sent path will be non-Empty, if this target is FS folder and drop is allowed */
+ bool need_Send = false;
+ if ( info.FuncType == k_DragTargetMode_Enter
+ || info.FuncType == k_DragTargetMode_Over
+ || (info.FuncType == k_DragTargetMode_Drop_Begin
+ // && targetOp_Cmd != NDragMenu::k_None
+ && info.Cmd_Type != NDragMenu::k_Cancel))
+ // if (!g_CreateArchive_for_Drag_from_7zip)
+ need_Send = m_DropIsAllowed && m_PanelDropIsAllowed && IsFsFolderPath();
+ m_TargetPath_WasSent_ToDataObject = SendToSource_TargetPath_enable(dataObject, need_Send);
+ SendToSource_TransferInfo(dataObject, info);
+}
+
+
+bool CDropTarget::SendToSource_TransferInfo(IDataObject *dataObject,
+ const CTargetTransferInfo &info)
+{
+ m_Transfer_WasSent_ToDataObject = false;
+ PRF("CDropTarget::SendToSource_TransferInfo");
+
+ if (!dataObject || m_Format_7zip_SetTransfer == 0)
+ return false;
+ FORMATETC etc = INIT_FORMATETC_HGLOBAL((CLIPFORMAT)m_Format_7zip_SetTransfer);
+ STGMEDIUM medium;
+ medium.tymed = etc.tymed;
+ medium.pUnkForRelease = NULL;
+ CDataObject_SetTransfer transfer;
+ const size_t size = sizeof(transfer); // + (1 << 19) // for debug
+ // OutputDebugString("GlobalAlloc");
+ medium.hGlobal = GlobalAlloc(GHND | GMEM_SHARE, size);
+ // Sleep(1000);
+ if (!medium.hGlobal)
+ return false;
+ // OutputDebugString("GlobalLock");
+ void *dest = (wchar_t *)GlobalLock(medium.hGlobal);
+ // Sleep(1000);
+ bool res = false;
+ if (dest)
+ {
+ transfer.Init();
+ transfer.Target = info;
+
+ memcpy(dest, &transfer, sizeof(transfer));
+ GlobalUnlock(medium.hGlobal);
+ // OutputDebugString("m_DataObject->SetData");
+ const BOOL release = FALSE; // that way is more simple for correct releasing.
+ // TRUE; // for debug : is not good for some cases
+ const HRESULT hres = dataObject->SetData(&etc, &medium, release);
+ res = (hres == S_OK);
+ }
+
+ ReleaseStgMedium(&medium);
+ if (res)
+ m_Transfer_WasSent_ToDataObject = true;
+ return res;
+}
+
+
+bool CDropTarget::SendToSource_UInt32(IDataObject *dataObject, UINT format, UInt32 value)
+{
+ PRF("CDropTarget::Send_UInt32 (Performed)");
+
+ if (!dataObject || format == 0)
+ return false;
+ FORMATETC etc = INIT_FORMATETC_HGLOBAL((CLIPFORMAT)format);
+ STGMEDIUM medium;
+ medium.tymed = etc.tymed;
+ medium.pUnkForRelease = NULL;
+ const size_t size = 4;
+ medium.hGlobal = GlobalAlloc(GHND | GMEM_SHARE, size);
+ if (!medium.hGlobal)
+ return false;
+ void *dest = GlobalLock(medium.hGlobal);
+ bool res = false;
+ if (dest)
+ {
+ *(UInt32 *)dest = value;
+ GlobalUnlock(medium.hGlobal);
+ // OutputDebugString("m_DataObject->SetData");
+ const BOOL release = TRUE;
+ // FALSE; // for debug
+ /* If DropSource is Win10-Explorer, then (release == FALSE) doesn't work
+ and dataObject->SetData() returns E_NOTIMPL;
+ So we use release = TRUE; here */
+ const HRESULT hres = dataObject->SetData(&etc, &medium, release);
+ // we return here without calling ReleaseStgMedium().
+ return (hres == S_OK);
+ // Sleep(1000);
+ /*
+ if (we use release = TRUE), we expect that
+ - SetData() will release medium, and
+ - SetData() will set STGMEDIUM::tymed to (TYMED_NULL = 0).
+ but some "incorrect" SetData() implementations can keep STGMEDIUM::tymed unchanged.
+ And it's not safe to call ReleaseStgMedium() here for that case,
+ because DropSource also could release medium.
+ We can reset (medium.tymed = TYMED_NULL) manually here to disable
+ unsafe medium releasing in ReleaseStgMedium().
+ */
+ /*
+ if (release)
+ {
+ medium.tymed = TYMED_NULL;
+ medium.pUnkForRelease = NULL;
+ medium.hGlobal = NULL;
+ }
+ res = (hres == S_OK);
+ */
+ }
+ ReleaseStgMedium(&medium);
+ return res;
+}
+
+
+void CDropTarget::LoadNames_From_DataObject(IDataObject *dataObject)
+{
+ // "\\\\.\\" prefix is possible for long names
+ m_DropIsAllowed = NShell::DataObject_GetData_HDROP_or_IDLIST_Names(dataObject, m_SourcePaths) == S_OK;
+}
+
+
+Z7_COMWF_B CDropTarget::DragEnter(IDataObject *dataObject, DWORD keyState, POINTL pt, DWORD *effect)
+{
+ /* *(effect):
+ - on input : value of the dwOKEffects parameter of the DoDragDrop() function.
+ - on return : must contain one of the DROPEFFECT flags, which indicates
+ what the result of the drop operation would be.
+ (pt): the current cursor coordinates in screen coordinates.
+ */
+ PRF_(Print_Point("CDropTarget::DragEnter", keyState, pt, *effect))
+ try {
+
+ if ((keyState & (MK_RBUTTON | MK_MBUTTON)) != 0)
+ m_IsRightButton = true;
+
+ LoadNames_From_DataObject(dataObject);
+ // Try_QueryGetData(dataObject);
+ // we will use (m_DataObject) later in DragOver() and DragLeave().
+ m_DataObject = dataObject;
+ // return DragOver(keyState, pt, effect);
+ PositionCursor(pt);
+ CTargetTransferInfo target;
+ target.FuncType = k_DragTargetMode_Enter;
+ target.KeyState = keyState;
+ target.Point = pt;
+ target.OkEffects = *effect;
+ SendToSource_Drag(target);
+
+ CDataObject_GetTransfer transfer;
+ m_GetTransfer_WasSuccess = DataObject_GetData_GetTransfer(
+ dataObject, m_Format_7zip_GetTransfer, transfer);
+ if (m_GetTransfer_WasSuccess)
+ {
+ if (transfer.Flags & k_SourceFlags_LeftButton)
+ m_IsRightButton = false;
+ else if (transfer.Flags & k_SourceFlags_RightButton)
+ m_IsRightButton = true;
+ }
+
+ *effect = GetEffect(keyState, pt, *effect);
+ return S_OK;
+ } catch(...) { return E_FAIL; }
+}
+
+
+Z7_COMWF_B CDropTarget::DragOver(DWORD keyState, POINTL pt, DWORD *effect)
+{
+ PRF_(Print_Point("CDropTarget::DragOver", keyState, pt, *effect))
+ /*
+ For efficiency reasons, a data object is not passed in IDropTarget::DragOver.
+ The data object passed in the most recent call to IDropTarget::DragEnter
+ is available and can be used.
+
+ When IDropTarget::DragOver has completed its operation, the DoDragDrop
+ function calls IDropSource::GiveFeedback so the source application can display
+ the appropriate visual feedback to the user.
+ */
+ /*
+ we suppose that it's unexpected that (keyState) shows that mouse
+ button is not pressed, because such cases will be processed by
+ IDropSource::QueryContinueDrag() that returns DRAGDROP_S_DROP or DRAGDROP_S_CANCEL.
+ So DragOver() will not be called.
+ */
+
+ if ((keyState & MK_LBUTTON) == 0)
+ {
+ PRF4("CDropTarget::DragOver() (keyState & MK_LBUTTON) == 0");
+ // g_Debug = true;
+ }
+
+ try {
+ /* we suppose that source names were not changed after DragEnter()
+ so we don't request GetNames_From_DataObject() for each call of DragOver() */
+ PositionCursor(pt);
+ CTargetTransferInfo target;
+ target.FuncType = k_DragTargetMode_Over;
+ target.KeyState = keyState;
+ target.Point = pt;
+ target.OkEffects = *effect;
+ SendToSource_Drag(target);
+ *effect = GetEffect(keyState, pt, *effect);
+ // *effect = 1 << 8; // for debug
+ return S_OK;
+ } catch(...) { return E_FAIL; }
+}
+
+
+Z7_COMWF_B CDropTarget::DragLeave()
+{
+ PRF4("CDropTarget::DragLeave");
+ try {
+ RemoveSelection();
+ // we send empty TargetPath to 7-Zip Source to clear value of TargetPath that was sent before
+
+ CTargetTransferInfo target;
+ target.FuncType = k_DragTargetMode_Leave;
+ /*
+ target.KeyState = 0;
+ target.Point = pt;
+ pt.x = 0; // -1
+ pt.y = 0; // -1
+ target.Effect = 0;
+ */
+ SendToSource_Drag(target);
+ ClearState();
+ return S_OK;
+ } catch(...) { return E_FAIL; }
+}
+
+
+static unsigned Drag_OnContextMenu(int xPos, int yPos, UInt32 cmdFlags);
+
+/*
+ We suppose that there was DragEnter/DragOver for same (POINTL pt) before Drop().
+ But we can work without DragEnter/DragOver too.
+*/
+Z7_COMWF_B CDropTarget::Drop(IDataObject *dataObject, DWORD keyState,
+ POINTL pt, DWORD *effect)
+{
+ PRF_(Print_Point("CDropTarget::Drop", keyState, pt, *effect))
+ /* Drop() is called after SourceDrop::QueryContinueDrag() returned DRAGDROP_S_DROP.
+ So it's possible that Source have done some operations already.
+ */
+ HRESULT hres = S_OK;
+ bool needDrop_by_Source = false;
+ DWORD opEffect = DROPEFFECT_NONE;
+
+ try {
+ // we don't need m_DataObject reference anymore, because we use local (dataObject)
+ m_DataObject.Release();
+
+ /* in normal case : we called LoadNames_From_DataObject() in DragEnter() already.
+ But if by some reason DragEnter() was not called,
+ we need to call LoadNames_From_DataObject() before PositionCursor().
+ */
+ if (!m_DropIsAllowed) LoadNames_From_DataObject(dataObject);
+ PositionCursor(pt);
+
+ CPanel::CDisableTimerProcessing2 disableTimerProcessing(m_Panel);
+ // CDisableNotify disableNotify2(m_Panel);
+
+ UInt32 cmd = NDragMenu::k_None;
+ UInt32 cmdEffect = DROPEFFECT_NONE;
+ bool menu_WasShown = false;
+ if (m_IsRightButton && m_Panel)
+ {
+ UInt32 flagsMask;
+ if (m_Panel->IsArcFolder())
+ flagsMask = (UInt32)1 << NDragMenu::k_Copy_ToArc;
+ else
+ {
+ flagsMask = (UInt32)1 << NDragMenu::k_AddToArc;
+ if (IsFsFolderPath())
+ flagsMask |= (UInt32)1 << NDragMenu::k_Copy_Base;
+ }
+ // flagsMask |= (UInt32)1 << NDragMenu::k_Cancel;
+ const UInt32 cmd32 = Drag_OnContextMenu(pt.x, pt.y, flagsMask);
+ cmd = cmd32 & NDragMenu::k_MenuFlags_CmdMask;
+ if (cmd32 & NDragMenu::k_MenuFlag_Copy)
+ cmdEffect = DROPEFFECT_COPY;
+ else if (cmd32 & NDragMenu::k_MenuFlag_Move)
+ cmdEffect = DROPEFFECT_MOVE;
+ opEffect = cmdEffect;
+ menu_WasShown = true;
+ }
+ else
+ {
+ opEffect = GetEffect(keyState, pt, *effect);
+ if (m_IsAppTarget)
+ cmd = NDragMenu::k_AddToArc;
+ else if (m_Panel)
+ {
+ if (IsFsFolderPath())
+ {
+ const bool is7zip = m_TargetPath_WasSent_ToDataObject;
+ bool createNewArchive = false;
+ if (is7zip)
+ createNewArchive = false; // g_CreateArchive_for_Drag_from_7zip;
+ else
+ createNewArchive = true; // g_CreateArchive_for_Drag_from_Explorer;
+
+ if (createNewArchive)
+ cmd = NDragMenu::k_AddToArc;
+ else
+ {
+ if (opEffect != 0)
+ cmd = NDragMenu::k_Copy_Base;
+ cmdEffect = opEffect;
+ }
+ }
+ else
+ {
+ /* if we are inside open archive:
+ if archive support operations -> we will call operations
+ if archive doesn't support operations -> we will create new archove
+ */
+ if (m_Panel->IsArcFolder()
+ || m_Panel->DoesItSupportOperations())
+ {
+ cmd = NDragMenu::k_Copy_ToArc;
+ // we don't want move to archive operation here.
+ // so we force to DROPEFFECT_COPY.
+ if (opEffect != DROPEFFECT_NONE)
+ opEffect = DROPEFFECT_COPY;
+ cmdEffect = opEffect;
+ }
+ else
+ cmd = NDragMenu::k_AddToArc;
+ }
+ }
+ }
+
+ if (cmd == 0)
+ cmd = NDragMenu::k_AddToArc;
+
+ if (cmd == NDragMenu::k_AddToArc)
+ {
+ opEffect = DROPEFFECT_COPY;
+ cmdEffect = DROPEFFECT_COPY;
+ }
+
+ if (m_Panel)
+ if (cmd == NDragMenu::k_Copy_ToArc)
+ {
+ const UString title = LangString(IDS_CONFIRM_FILE_COPY);
+ UString s = LangString(cmdEffect == DROPEFFECT_MOVE ?
+ IDS_MOVE_TO : IDS_COPY_TO);
+ s.Add_LF();
+ s += "\'";
+ s += m_Panel->_currentFolderPrefix;
+ s += "\'";
+ s.Add_LF();
+ s += LangString(IDS_WANT_TO_COPY_FILES);
+ s += " ?";
+ const int res = ::MessageBoxW(*m_Panel, s, title, MB_YESNOCANCEL | MB_ICONQUESTION);
+ if (res != IDYES)
+ cmd = NDragMenu::k_Cancel;
+ }
+
+ CTargetTransferInfo target;
+ target.FuncType = k_DragTargetMode_Drop_Begin;
+ target.KeyState = keyState;
+ target.Point = pt;
+ target.OkEffects = *effect;
+ target.Flags = 0;
+
+ target.Cmd_Effect = cmdEffect;
+ target.Cmd_Type = cmd;
+ target.FolderType = GetFolderType();
+
+ if (cmd == NDragMenu::k_Cancel)
+ target.Flags |= k_TargetFlags_WasCanceled;
+ if (menu_WasShown)
+ target.Flags |= k_TargetFlags_MenuWasShown;
+
+ SendToSource_auto(dataObject, target);
+
+ CDataObject_GetTransfer transfer;
+ m_GetTransfer_WasSuccess = DataObject_GetData_GetTransfer(
+ dataObject, m_Format_7zip_GetTransfer, transfer);
+
+ /* The Source (for example, 7-zip) could change file names when drop was confirmed.
+ So we must reload source file paths here */
+ if (cmd != NDragMenu::k_Cancel)
+ LoadNames_From_DataObject(dataObject);
+
+ if (cmd == NDragMenu::k_Cancel)
+ {
+ opEffect = DROPEFFECT_NONE;
+ cmdEffect = DROPEFFECT_NONE;
+ }
+ else
+ {
+ if (m_GetTransfer_WasSuccess)
+ needDrop_by_Source = ((transfer.Flags & k_SourceFlags_DoNotProcessInTarget) != 0);
+ if (!needDrop_by_Source)
+ {
+ bool moveMode = (cmdEffect == DROPEFFECT_MOVE);
+ bool needDrop = false;
+ if (m_IsRightButton && m_Panel)
+ needDrop = true;
+ if (m_DropIsAllowed && m_PanelDropIsAllowed)
+ {
+ /* if non-empty TargetPath was sent successfully to DataObject,
+ then the Source is 7-Zip, and that 7zip-Source can copy to FS operation.
+ So we can disable Drop operation here for such case.
+ */
+ needDrop_by_Source = (cmd != NDragMenu::k_AddToArc
+ && m_TargetPath_WasSent_ToDataObject
+ && m_TargetPath_NonEmpty_WasSent_ToDataObject);
+ needDrop = !(needDrop_by_Source);
+ }
+ if (needDrop)
+ {
+ UString path = GetTargetPath();
+ if (m_IsAppTarget && m_Panel)
+ if (m_Panel->IsFSFolder())
+ path = m_Panel->GetFsPath();
+
+ UInt32 sourceFlags = 0;
+ if (m_GetTransfer_WasSuccess)
+ sourceFlags = transfer.Flags;
+
+ if (menu_WasShown)
+ target.Flags |= k_TargetFlags_MenuWasShown;
+
+ target.Flags |= k_TargetFlags_WasProcessed;
+
+ RemoveSelection();
+ // disableTimerProcessing.Restore();
+ m_Panel->CompressDropFiles(m_SourcePaths, path,
+ (cmd == NDragMenu::k_AddToArc), // createNewArchive,
+ moveMode, sourceFlags,
+ target.Flags
+ );
+ }
+ }
+ } // end of if (cmd != NDragMenu::k_Cancel)
+ {
+ /* note that, if (we send CFSTR_PERFORMEDDROPEFFECT as DROPEFFECT_MOVE
+ and Drop() returns (*effect == DROPEFFECT_MOVE), then
+ Win10-Explorer-Source will try to remove files just after Drop() exit.
+ But our CompressFiles() could be run without waiting finishing.
+ DOCs say, that we must send CFSTR_PERFORMEDDROPEFFECT
+ - DROPEFFECT_NONE : for optimized move
+ - DROPEFFECT_MOVE : for unoptimized move.
+ But actually Win10-Explorer-Target sends (DROPEFFECT_MOVE) for move operation.
+ And it still works as in optimized mode, because "unoptimized" deleting by Source will be performed
+ if both conditions are met:
+ 1) DROPEFFECT_MOVE is sent to (CFSTR_PERFORMEDDROPEFFECT) and
+ 2) (*effect == DROPEFFECT_MOVE) is returend by Drop().
+ We don't want to send DROPEFFECT_MOVE here to protect from
+ deleting file by Win10-Explorer.
+ We are not sure that allfile fieree processed by move.
+ */
+
+ // for debug: we test the case when source tries to delete original files
+ // bool res;
+ // only CFSTR_PERFORMEDDROPEFFECT affects file removing in Win10-Explorer.
+ // res = SendToSource_UInt32(dataObject, RegisterClipboardFormat(CFSTR_LOGICALPERFORMEDDROPEFFECT), DROPEFFECT_MOVE); // for debug
+ /* res = */ SendToSource_UInt32(dataObject,
+ RegisterClipboardFormat(CFSTR_PERFORMEDDROPEFFECT),
+ cmd == NDragMenu::k_Cancel ? DROPEFFECT_NONE : DROPEFFECT_COPY);
+ // res = res;
+ }
+ RemoveSelection();
+
+ target.FuncType = k_DragTargetMode_Drop_End;
+ target.Cmd_Type = cmd;
+ if (needDrop_by_Source)
+ target.Flags |= k_TargetFlags_MustBeProcessedBySource;
+
+ SendToSource_TransferInfo(dataObject, target);
+ } catch(...) { hres = E_FAIL; }
+
+ ClearState();
+ // *effect |= (1 << 10); // for debug
+ // *effect = DROPEFFECT_COPY; // for debug
+
+ /*
+ if we return (*effect == DROPEFFECT_MOVE) here,
+ Explorer-Source at some conditions can treat it as (unoptimized move) mode,
+ and Explorer-Source will remove source files after DoDragDrop()
+ in that (unoptimized move) mode.
+ We want to avoid such (unoptimized move) cases.
+ So we don't return (*effect == DROPEFFECT_MOVE), here if Source is not 7-Zip.
+ If source is 7-Zip that will do acual opeartion, then we can return DROPEFFECT_MOVE.
+ */
+ if (hres != S_OK || (opEffect == DROPEFFECT_MOVE && !needDrop_by_Source))
+ {
+ // opEffect = opEffect;
+ // opEffect = DROPEFFECT_NONE; // for debug disabled
+ }
+
+ *effect = opEffect;
+ /* if (hres < 0), DoDragDrop() also will return (hres).
+ if (hres >= 0), DoDragDrop() will return DRAGDROP_S_DROP;
+ */
+ return hres;
+}
+
+
+
+// ---------- CPanel ----------
+
+
+static bool Is_Path1_Prefixed_by_Path2(const UString &path, const UString &prefix)
+{
+ const unsigned len = prefix.Len();
+ if (path.Len() < len)
+ return false;
+ return CompareFileNames(path.Left(len), prefix) == 0;
+}
+
+static bool IsFolderInTemp(const UString &path)
+{
+ FString tempPathF;
+ if (!MyGetTempPath(tempPathF))
+ return false;
+ const UString tempPath = fs2us(tempPathF);
+ if (tempPath.IsEmpty())
+ return false;
+ return Is_Path1_Prefixed_by_Path2(path, tempPath);
+}
+
+static bool AreThereNamesFromTemp(const UStringVector &filePaths)
+{
+ FString tempPathF;
+ if (!MyGetTempPath(tempPathF))
+ return false;
+ const UString tempPath = fs2us(tempPathF);
+ if (tempPath.IsEmpty())
+ return false;
+ FOR_VECTOR (i, filePaths)
+ if (Is_Path1_Prefixed_by_Path2(filePaths[i], tempPath))
+ return true;
+ return false;
+}
+
+
+/*
+ empty folderPath means create new Archive to path of first fileName.
+ createNewArchive == true : show "Add to archive ..." dialog with external program
+ folderPath.IsEmpty() : create archive in folder of filePaths[0].
+ createNewArchive == false :
+ folderPath.IsEmpty() : copy to archive folder that is open in panel
+ !folderPath.IsEmpty() : CopyFsItems() to folderPath.
+*/
+void CPanel::CompressDropFiles(
+ const UStringVector &filePaths,
+ const UString &folderPath,
+ bool createNewArchive,
+ bool moveMode,
+ UInt32 sourceFlags,
+ UInt32 &targetFlags
+ )
+{
+ if (filePaths.Size() == 0)
+ return;
+ // createNewArchive = false; // for debug
+
+ if (createNewArchive)
+ {
+ UString folderPath2 = folderPath;
+ // folderPath2.Empty(); // for debug
+ if (folderPath2.IsEmpty())
+ {
+ {
+ FString folderPath2F;
+ GetOnlyDirPrefix(us2fs(filePaths.Front()), folderPath2F);
+ folderPath2 = fs2us(folderPath2F);
+ }
+ if (IsFolderInTemp(folderPath2))
+ {
+ /* we don't want archive to be created in temp directory.
+ so we change the path to root folder (non-temp) */
+ folderPath2 = ROOT_FS_FOLDER;
+ }
+ }
+
+ UString arcName_base;
+ const UString arcName = CreateArchiveName(filePaths,
+ false, // isHash
+ NULL, // CFileInfo *fi
+ arcName_base);
+
+ bool needWait;
+ if (sourceFlags & k_SourceFlags_WaitFinish)
+ needWait = true;
+ else if (sourceFlags & k_SourceFlags_DoNotWaitFinish)
+ needWait = false;
+ else if (sourceFlags & k_SourceFlags_TempFiles)
+ needWait = true;
+ else
+ needWait = AreThereNamesFromTemp(filePaths);
+
+ targetFlags |= (needWait ?
+ k_TargetFlags_WaitFinish :
+ k_TargetFlags_DoNotWaitFinish);
+
+ CompressFiles(folderPath2, arcName,
+ L"", // arcType
+ true, // addExtension
+ filePaths,
+ false, // email
+ true, // showDialog
+ needWait);
+ }
+ else
+ {
+ targetFlags |= k_TargetFlags_WaitFinish;
+ if (!folderPath.IsEmpty())
+ {
+ CCopyToOptions options;
+ options.moveMode = moveMode;
+ options.folder = folderPath;
+ options.showErrorMessages = true; // showErrorMessages is not used for this operation
+ options.NeedRegistryZone = false;
+ options.ZoneIdMode = NExtract::NZoneIdMode::kNone;
+ // maybe we need more options here: FIXME
+ /* HRESULT hres = */ CopyFsItems(options,
+ filePaths,
+ NULL // UStringVector *messages
+ );
+ // hres = hres;
+ }
+ else
+ {
+ CopyFromNoAsk(moveMode, filePaths);
+ }
+ }
+}
+
+
+
+static unsigned Drag_OnContextMenu(int xPos, int yPos, UInt32 cmdFlags)
+{
+ CMenu menu;
+ CMenuDestroyer menuDestroyer(menu);
+ /*
+ Esc key in shown menu doesn't work if we call Drag_OnContextMenu from ::Drop().
+ We call SetFocus() tp solve that problem.
+ But the focus will be changed to Target Window after Drag and Drop.
+ Is it OK to use SetFocus() here ?
+ Is there another way to enable Esc key ?
+ */
+ // _listView.SetFocus(); // for debug
+ ::SetFocus(g_HWND);
+ menu.CreatePopup();
+ /*
+ int defaultCmd; // = NDragMenu::k_Move;
+ defaultCmd = NDragMenu::k_None;
+ */
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(NDragMenu::g_Pairs); i++)
+ {
+ const NDragMenu::CCmdLangPair &pair = NDragMenu::g_Pairs[i];
+ const UInt32 cmdAndFlags = pair.CmdId_and_Flags;
+ const UInt32 cmdId = cmdAndFlags & NDragMenu::k_MenuFlags_CmdMask;
+ if (cmdId != NDragMenu::k_Cancel)
+ if ((cmdFlags & ((UInt32)1 << cmdId)) == 0)
+ continue;
+ const UINT flags = MF_STRING;
+ /*
+ if (prop.IsVisible)
+ flags |= MF_CHECKED;
+ if (i == 0)
+ flags |= MF_GRAYED;
+ */
+ // MF_DEFAULT doesn't work
+ // if (i == 2) flags |= MF_DEFAULT;
+ // if (i == 4) flags |= MF_HILITE;
+ // if (cmd == defaultCmd) flags |= MF_HILITE;
+ UString name = LangString(pair.LangId);
+ if (name.IsEmpty())
+ {
+ if (cmdId == NDragMenu::k_Cancel)
+ name = "Cancel";
+ else
+ name.Add_UInt32(pair.LangId);
+ }
+ if (cmdId == NDragMenu::k_Copy_ToArc)
+ {
+ // UString destPath = _currentFolderPrefix;
+ /*
+ UString destPath = LangString(IDS_CONTEXT_ARCHIVE);
+ name = MyFormatNew(name, destPath);
+ */
+ name.Add_Space();
+ name += LangString(IDS_CONTEXT_ARCHIVE);
+ }
+ if (cmdId == NDragMenu::k_Cancel)
+ menu.AppendItem(MF_SEPARATOR, 0, (LPCTSTR)NULL);
+ menu.AppendItem(flags, cmdAndFlags, name);
+ }
+ /*
+ if (defaultCmd != 0)
+ SetMenuDefaultItem(menu, (unsigned)defaultCmd,
+ FALSE); // byPos
+ */
+ int menuResult = menu.Track(
+ TPM_LEFTALIGN | TPM_RETURNCMD | TPM_NONOTIFY,
+ xPos, yPos,
+ g_HWND
+ // _listView // for debug
+ );
+ /* menu.Track() return value is zero, if the user cancels
+ the menu without making a selection, or if an error occurs */
+ if (menuResult <= 0)
+ menuResult = NDragMenu::k_Cancel;
+ return (unsigned)menuResult;
+}
+
+
+
+void CApp::CreateDragTarget()
+{
+ _dropTargetSpec = new CDropTarget();
+ _dropTarget = _dropTargetSpec;
+ _dropTargetSpec->App = (this);
+}
+
+void CApp::SetFocusedPanel(unsigned index)
+{
+ LastFocusedPanel = index;
+ _dropTargetSpec->TargetPanelIndex = (int)LastFocusedPanel;
+}
+
+void CApp::DragBegin(unsigned panelIndex)
+{
+ _dropTargetSpec->TargetPanelIndex = (int)(NumPanels > 1 ? 1 - panelIndex : panelIndex);
+ _dropTargetSpec->SrcPanelIndex = (int)panelIndex;
+}
+
+void CApp::DragEnd()
+{
+ _dropTargetSpec->TargetPanelIndex = (int)LastFocusedPanel;
+ _dropTargetSpec->SrcPanelIndex = -1;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelFolderChange.cpp b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
new file mode 100644
index 0000000..a13b88d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelFolderChange.cpp
@@ -0,0 +1,913 @@
+// PanelFolderChange.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#ifdef UNDER_CE
+#include "FSFolder.h"
+#else
+#include "FSDrives.h"
+#endif
+#include "LangUtils.h"
+#include "ListViewDialog.h"
+#include "Panel.h"
+#include "RootFolder.h"
+#include "ViewSettings.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+
+void CPanel::ReleaseFolder()
+{
+ DeleteListItems();
+
+ _folder.Release();
+
+ _folderCompare.Release();
+ _folderGetItemName.Release();
+ _folderRawProps.Release();
+ _folderAltStreams.Release();
+ _folderOperations.Release();
+
+ _thereAreDeletedItems = false;
+}
+
+void CPanel::SetNewFolder(IFolderFolder *newFolder)
+{
+ ReleaseFolder();
+ _folder = newFolder;
+ if (_folder)
+ {
+ _folder.QueryInterface(IID_IFolderCompare, &_folderCompare);
+ _folder.QueryInterface(IID_IFolderGetItemName, &_folderGetItemName);
+ _folder.QueryInterface(IID_IArchiveGetRawProps, &_folderRawProps);
+ _folder.QueryInterface(IID_IFolderAltStreams, &_folderAltStreams);
+ _folder.QueryInterface(IID_IFolderOperations, &_folderOperations);
+ }
+}
+
+void CPanel::SetToRootFolder()
+{
+ ReleaseFolder();
+ _library.Free();
+
+ CRootFolder *rootFolderSpec = new CRootFolder;
+ SetNewFolder(rootFolderSpec);
+ rootFolderSpec->Init();
+}
+
+
+static bool DoesNameContainWildcard_SkipRoot(const UString &path)
+{
+ return DoesNameContainWildcard(path.Ptr(NName::GetRootPrefixSize(path)));
+}
+
+HRESULT CPanel::BindToPath(const UString &fullPath, const UString &arcFormat, COpenResult &openRes)
+{
+ UString path = fullPath;
+ #ifdef _WIN32
+ path.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+
+ openRes.ArchiveIsOpened = false;
+ openRes.Encrypted = false;
+
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+
+ for (; !_parentFolders.IsEmpty(); CloseOneLevel())
+ {
+ // ---------- we try to use open archive ----------
+
+ const CFolderLink &link = _parentFolders.Back();
+ const UString &virtPath = link.VirtualPath;
+ if (!path.IsPrefixedBy(virtPath))
+ continue;
+ UString relatPath = path.Ptr(virtPath.Len());
+ if (!relatPath.IsEmpty())
+ {
+ if (!IS_PATH_SEPAR(relatPath[0]))
+ continue;
+ else
+ relatPath.Delete(0);
+ }
+
+ UString relatPath2 = relatPath;
+ if (!relatPath2.IsEmpty() && !IS_PATH_SEPAR(relatPath2.Back()))
+ relatPath2.Add_PathSepar();
+
+ for (;;)
+ {
+ const UString foldPath = GetFolderPath(_folder);
+ if (relatPath2 == foldPath)
+ break;
+ if (relatPath.IsPrefixedBy(foldPath))
+ {
+ path = relatPath.Ptr(foldPath.Len());
+ break;
+ }
+ CMyComPtr<IFolderFolder> newFolder;
+ if (_folder->BindToParentFolder(&newFolder) != S_OK)
+ throw 20140918;
+ if (!newFolder) // we exit from loop above if (relatPath.IsPrefixedBy(empty path for root folder)
+ throw 20140918;
+ SetNewFolder(newFolder);
+ }
+ break;
+ }
+
+ if (_parentFolders.IsEmpty())
+ {
+ // ---------- we open file or folder from file system ----------
+
+ CloseOpenFolders();
+ UString sysPath = path;
+ /* we will Empty() sysPath variable, if we need to BindToFolder()
+ directly with (path) variable */
+ const unsigned prefixSize = NName::GetRootPrefixSize(sysPath);
+ if (prefixSize == 0 || sysPath[prefixSize] == 0)
+ sysPath.Empty();
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (!sysPath.IsEmpty() && sysPath.Back() == ':' &&
+ (sysPath.Len() != 2 || !NName::IsDrivePath2(sysPath)))
+ {
+ // if base item for alt streams prefix "base:" exists, we will use it
+ UString baseFile = sysPath;
+ baseFile.DeleteBack();
+ if (NFind::DoesFileOrDirExist(us2fs(baseFile)))
+ sysPath.Empty();
+ }
+ #endif
+
+ CFileInfo fileInfo;
+
+ while (!sysPath.IsEmpty())
+ {
+ if (sysPath.Len() <= prefixSize)
+ {
+ path.DeleteFrom(prefixSize);
+ sysPath.Empty();
+ break;
+ }
+
+ fileInfo.ClearBase();
+ if (IsPathSepar(sysPath.Back()))
+ {
+ /* Windows 10 by default doesn't allow look "Local Settings" that is junction to "AppData\Local",
+ but it does allow look "Local Settings\Temp\*"
+ 22.02: at first we try to use paths with slashes "path\" */
+ CFileInfo fi;
+ // CFindFile findFile;
+ // FString path2 = us2fs(sysPath);
+ // path2 += '*'; // CHAR_ANY_MASK;
+ // if (findFile.FindFirst(path2, fi))
+ CEnumerator enumerator;
+ enumerator.SetDirPrefix(us2fs(sysPath));
+ bool found = false;
+ if (enumerator.Next(fi, found))
+ {
+ // sysPath.DeleteBack();
+ fileInfo.SetAsDir();
+ fileInfo.Size = 0;
+ fileInfo.Name.Empty();
+ break;
+ }
+ sysPath.DeleteBack();
+ continue;
+ }
+
+ if (fileInfo.Find(us2fs(sysPath)))
+ break;
+ int pos = sysPath.ReverseFind_PathSepar();
+ if (pos < 0)
+ {
+ sysPath.Empty();
+ break;
+ }
+ {
+ if ((unsigned)pos != sysPath.Len() - 1)
+ pos++;
+ sysPath.DeleteFrom((unsigned)pos);
+ }
+ }
+
+ SetToRootFolder();
+
+ CMyComPtr<IFolderFolder> newFolder;
+
+ if (sysPath.IsEmpty())
+ {
+ _folder->BindToFolder(path, &newFolder);
+ }
+ else if (fileInfo.IsDir())
+ {
+ #ifdef _WIN32
+ if (DoesNameContainWildcard_SkipRoot(sysPath))
+ {
+ FString dirPrefix, fileName;
+ NDir::GetFullPathAndSplit(us2fs(sysPath), dirPrefix, fileName);
+ if (DoesNameContainWildcard_SkipRoot(fs2us(dirPrefix)))
+ return E_INVALIDARG;
+ sysPath = fs2us(dirPrefix + fileInfo.Name);
+ }
+ #endif
+
+ NName::NormalizeDirPathPrefix(sysPath);
+ _folder->BindToFolder(sysPath, &newFolder);
+ }
+ else
+ {
+ FString dirPrefix, fileName;
+
+ NDir::GetFullPathAndSplit(us2fs(sysPath), dirPrefix, fileName);
+
+ HRESULT res = S_OK;
+
+ #ifdef _WIN32
+ if (DoesNameContainWildcard_SkipRoot(fs2us(dirPrefix)))
+ return E_INVALIDARG;
+
+ if (DoesNameContainWildcard(fs2us(fileName)))
+ res = S_FALSE;
+ else
+ #endif
+ {
+ CTempFileInfo tfi;
+ tfi.RelPath = fs2us(fileName);
+ tfi.FolderPath = dirPrefix;
+ tfi.FilePath = us2fs(sysPath);
+ res = OpenAsArc(NULL, tfi, sysPath, arcFormat, openRes);
+ }
+
+ if (res == S_FALSE)
+ _folder->BindToFolder(fs2us(dirPrefix), &newFolder);
+ else
+ {
+ RINOK(res)
+ openRes.ArchiveIsOpened = true;
+ _parentFolders.Back().ParentFolderPath = fs2us(dirPrefix);
+ path.DeleteFrontal(sysPath.Len());
+ if (!path.IsEmpty() && IS_PATH_SEPAR(path[0]))
+ path.Delete(0);
+ }
+ }
+
+ if (newFolder)
+ {
+ SetNewFolder(newFolder);
+ // LoadFullPath();
+ return S_OK;
+ }
+ }
+
+ {
+ // ---------- we open folder remPath in archive and sub archives ----------
+
+ for (unsigned curPos = 0; curPos != path.Len();)
+ {
+ UString s = path.Ptr(curPos);
+ const int slashPos = NName::FindSepar(s);
+ unsigned skipLen = s.Len();
+ if (slashPos >= 0)
+ {
+ s.DeleteFrom((unsigned)slashPos);
+ skipLen = (unsigned)slashPos + 1;
+ }
+
+ CMyComPtr<IFolderFolder> newFolder;
+ _folder->BindToFolder(s, &newFolder);
+ if (newFolder)
+ curPos += skipLen;
+ else if (_folderAltStreams)
+ {
+ const int pos = s.Find(L':');
+ if (pos >= 0)
+ {
+ UString baseName = s;
+ baseName.DeleteFrom((unsigned)pos);
+ if (_folderAltStreams->BindToAltStreams(baseName, &newFolder) == S_OK && newFolder)
+ curPos += (unsigned)pos + 1;
+ }
+ }
+
+ if (!newFolder)
+ break;
+
+ SetNewFolder(newFolder);
+ }
+ }
+
+ return S_OK;
+}
+
+HRESULT CPanel::BindToPathAndRefresh(const UString &path)
+{
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+ COpenResult openRes;
+ UString s = path;
+
+ #ifdef _WIN32
+ if (!s.IsEmpty() && s[0] == '\"' && s.Back() == '\"')
+ {
+ s.DeleteBack();
+ s.Delete(0);
+ }
+ #endif
+
+ HRESULT res = BindToPath(s, UString(), openRes);
+ RefreshListCtrl();
+ return res;
+}
+
+void CPanel::SetBookmark(unsigned index)
+{
+ _appState->FastFolders.SetString(index, _currentFolderPrefix);
+}
+
+void CPanel::OpenBookmark(unsigned index)
+{
+ BindToPathAndRefresh(_appState->FastFolders.GetString(index));
+}
+
+UString GetFolderPath(IFolderFolder *folder)
+{
+ {
+ NCOM::CPropVariant prop;
+ if (folder->GetFolderProperty(kpidPath, &prop) == S_OK)
+ if (prop.vt == VT_BSTR)
+ return (wchar_t *)prop.bstrVal;
+ }
+ return UString();
+}
+
+void CPanel::LoadFullPath()
+{
+ _currentFolderPrefix.Empty();
+ FOR_VECTOR (i, _parentFolders)
+ {
+ const CFolderLink &folderLink = _parentFolders[i];
+ _currentFolderPrefix += folderLink.ParentFolderPath;
+ // GetFolderPath(folderLink.ParentFolder);
+ _currentFolderPrefix += folderLink.RelPath;
+ _currentFolderPrefix.Add_PathSepar();
+ }
+ if (_folder)
+ _currentFolderPrefix += GetFolderPath(_folder);
+}
+
+static int GetRealIconIndex(CFSTR path, DWORD attributes)
+{
+ int index = -1;
+ if (GetRealIconIndex(path, attributes, index) != 0)
+ return index;
+ return -1;
+}
+
+void CPanel::LoadFullPathAndShow()
+{
+ LoadFullPath();
+ _appState->FolderHistory.AddString(_currentFolderPrefix);
+
+ _headerComboBox.SetText(_currentFolderPrefix);
+
+ #ifndef UNDER_CE
+
+ COMBOBOXEXITEM item;
+ item.mask = 0;
+
+ UString path = _currentFolderPrefix;
+ if (path.Len() >
+ #ifdef _WIN32
+ 3
+ #else
+ 1
+ #endif
+ && IS_PATH_SEPAR(path.Back()))
+ path.DeleteBack();
+
+ DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+
+ // GetRealIconIndex is slow for direct DVD/UDF path. So we use dummy path
+ if (path.IsPrefixedBy(L"\\\\.\\"))
+ path = "_TestFolder_";
+ else
+ {
+ CFileInfo fi;
+ if (fi.Find(us2fs(path)))
+ attrib = fi.Attrib;
+ }
+ item.iImage = GetRealIconIndex(us2fs(path), attrib);
+
+ if (item.iImage >= 0)
+ {
+ item.iSelectedImage = item.iImage;
+ item.mask |= (CBEIF_IMAGE | CBEIF_SELECTEDIMAGE);
+ }
+ item.iItem = -1;
+ _headerComboBox.SetItem(&item);
+
+ #endif
+
+ RefreshTitle();
+}
+
+#ifndef UNDER_CE
+LRESULT CPanel::OnNotifyComboBoxEnter(const UString &s)
+{
+ if (BindToPathAndRefresh(GetUnicodeString(s)) == S_OK)
+ {
+ PostMsg(kSetFocusToListView);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+bool CPanel::OnNotifyComboBoxEndEdit(PNMCBEENDEDITW info, LRESULT &result)
+{
+ if (info->iWhy == CBENF_ESCAPE)
+ {
+ _headerComboBox.SetText(_currentFolderPrefix);
+ PostMsg(kSetFocusToListView);
+ result = FALSE;
+ return true;
+ }
+
+ /*
+ if (info->iWhy == CBENF_DROPDOWN)
+ {
+ result = FALSE;
+ return true;
+ }
+ */
+
+ if (info->iWhy == CBENF_RETURN)
+ {
+ // When we use Edit control and press Enter.
+ UString s;
+ _headerComboBox.GetText(s);
+ result = OnNotifyComboBoxEnter(s);
+ return true;
+ }
+ return false;
+}
+#endif
+
+#ifndef _UNICODE
+bool CPanel::OnNotifyComboBoxEndEdit(PNMCBEENDEDIT info, LRESULT &result)
+{
+ if (info->iWhy == CBENF_ESCAPE)
+ {
+ _headerComboBox.SetText(_currentFolderPrefix);
+ PostMsg(kSetFocusToListView);
+ result = FALSE;
+ return true;
+ }
+ /*
+ if (info->iWhy == CBENF_DROPDOWN)
+ {
+ result = FALSE;
+ return true;
+ }
+ */
+
+ if (info->iWhy == CBENF_RETURN)
+ {
+ UString s;
+ _headerComboBox.GetText(s);
+ // GetUnicodeString(info->szText)
+ result = OnNotifyComboBoxEnter(s);
+ return true;
+ }
+ return false;
+}
+#endif
+
+void CPanel::AddComboBoxItem(const UString &name, int iconIndex, int indent, bool addToList)
+{
+ #ifdef UNDER_CE
+
+ UString s;
+ iconIndex = iconIndex;
+ for (int i = 0; i < indent; i++)
+ s += " ";
+ _headerComboBox.AddString(s + name);
+
+ #else
+
+ COMBOBOXEXITEMW item;
+ item.mask = CBEIF_TEXT | CBEIF_INDENT;
+ item.iSelectedImage = item.iImage = iconIndex;
+ if (iconIndex >= 0)
+ item.mask |= (CBEIF_IMAGE | CBEIF_SELECTEDIMAGE);
+ item.iItem = -1;
+ item.iIndent = indent;
+ item.pszText = name.Ptr_non_const();
+ _headerComboBox.InsertItem(&item);
+
+ #endif
+
+ if (addToList)
+ ComboBoxPaths.Add(name);
+}
+
+extern UString RootFolder_GetName_Computer(int &iconIndex);
+extern UString RootFolder_GetName_Network(int &iconIndex);
+extern UString RootFolder_GetName_Documents(int &iconIndex);
+
+bool CPanel::OnComboBoxCommand(UINT code, LPARAM /* param */, LRESULT &result)
+{
+ result = FALSE;
+ switch (code)
+ {
+ case CBN_DROPDOWN:
+ {
+ ComboBoxPaths.Clear();
+ _headerComboBox.ResetContent();
+
+ unsigned i;
+ UStringVector pathParts;
+
+ SplitPathToParts(_currentFolderPrefix, pathParts);
+ UString sumPass;
+ if (!pathParts.IsEmpty())
+ pathParts.DeleteBack();
+ for (i = 0; i < pathParts.Size(); i++)
+ {
+ const UString name = pathParts[i];
+ sumPass += name;
+ sumPass.Add_PathSepar();
+ CFileInfo info;
+ DWORD attrib = FILE_ATTRIBUTE_DIRECTORY;
+ if (info.Find(us2fs(sumPass)))
+ attrib = info.Attrib;
+ AddComboBoxItem(
+ name.IsEmpty() ? L"\\" : name,
+ GetRealIconIndex(us2fs(sumPass), attrib),
+ (int)i, // iIndent
+ false); // addToList
+ ComboBoxPaths.Add(sumPass);
+ }
+
+ #ifndef UNDER_CE
+
+ int iconIndex;
+ UString name;
+ name = RootFolder_GetName_Documents(iconIndex);
+ AddComboBoxItem(name, iconIndex, 0, true);
+
+ name = RootFolder_GetName_Computer(iconIndex);
+ AddComboBoxItem(name, iconIndex, 0, true);
+
+ FStringVector driveStrings;
+ MyGetLogicalDriveStrings(driveStrings);
+ for (i = 0; i < driveStrings.Size(); i++)
+ {
+ FString s = driveStrings[i];
+ ComboBoxPaths.Add(fs2us(s));
+ int iconIndex2 = GetRealIconIndex(s, 0);
+ if (s.Len() > 0 && s.Back() == FCHAR_PATH_SEPARATOR)
+ s.DeleteBack();
+ AddComboBoxItem(fs2us(s), iconIndex2, 1, false);
+ }
+
+ name = RootFolder_GetName_Network(iconIndex);
+ AddComboBoxItem(name, iconIndex, 0, true);
+
+ #endif
+
+ return false;
+ }
+
+ case CBN_SELENDOK:
+ {
+ int index = _headerComboBox.GetCurSel();
+ if (index >= 0)
+ {
+ UString pass = ComboBoxPaths[index];
+ _headerComboBox.SetCurSel(-1);
+ // _headerComboBox.SetText(pass); // it's fix for seclecting by mouse.
+ if (BindToPathAndRefresh(pass) == S_OK)
+ {
+ PostMsg(kSetFocusToListView);
+ #ifdef UNDER_CE
+ PostMsg(kRefresh_HeaderComboBox);
+ #endif
+ return true;
+ }
+ }
+ return false;
+ }
+ /*
+ case CBN_CLOSEUP:
+ {
+ LoadFullPathAndShow();
+ true;
+
+ }
+ case CBN_SELCHANGE:
+ {
+ // LoadFullPathAndShow();
+ return true;
+ }
+ */
+ }
+ return false;
+}
+
+bool CPanel::OnNotifyComboBox(LPNMHDR NON_CE_VAR(header), LRESULT & NON_CE_VAR(result))
+{
+ #ifndef UNDER_CE
+ switch (header->code)
+ {
+ case CBEN_BEGINEDIT:
+ {
+ _lastFocusedIsList = false;
+ _panelCallback->PanelWasFocused();
+ break;
+ }
+ #ifndef _UNICODE
+ case CBEN_ENDEDIT:
+ {
+ return OnNotifyComboBoxEndEdit((PNMCBEENDEDIT)header, result);
+ }
+ #endif
+ case CBEN_ENDEDITW:
+ {
+ return OnNotifyComboBoxEndEdit((PNMCBEENDEDITW)header, result);
+ }
+ }
+ #endif
+ return false;
+}
+
+
+void CPanel::FoldersHistory()
+{
+ CListViewDialog listViewDialog;
+ listViewDialog.DeleteIsAllowed = true;
+ listViewDialog.SelectFirst = true;
+ LangString(IDS_FOLDERS_HISTORY, listViewDialog.Title);
+ _appState->FolderHistory.GetList(listViewDialog.Strings);
+ if (listViewDialog.Create(GetParent()) != IDOK)
+ return;
+ UString selectString;
+ if (listViewDialog.StringsWereChanged)
+ {
+ _appState->FolderHistory.RemoveAll();
+ for (int i = (int)listViewDialog.Strings.Size() - 1; i >= 0; i--)
+ _appState->FolderHistory.AddString(listViewDialog.Strings[i]);
+ if (listViewDialog.FocusedItemIndex >= 0)
+ selectString = listViewDialog.Strings[listViewDialog.FocusedItemIndex];
+ }
+ else
+ {
+ if (listViewDialog.FocusedItemIndex >= 0)
+ selectString = listViewDialog.Strings[listViewDialog.FocusedItemIndex];
+ }
+ if (listViewDialog.FocusedItemIndex >= 0)
+ BindToPathAndRefresh(selectString);
+}
+
+
+UString CPanel::GetParentDirPrefix() const
+{
+ UString s;
+ if (!_currentFolderPrefix.IsEmpty())
+ {
+ wchar_t c = _currentFolderPrefix.Back();
+ if (IS_PATH_SEPAR(c) || c == ':')
+ {
+ s = _currentFolderPrefix;
+ s.DeleteBack();
+ if (s != L"\\\\." &&
+ s != L"\\\\?")
+ {
+ int pos = s.ReverseFind_PathSepar();
+ if (pos >= 0)
+ s.DeleteFrom((unsigned)(pos + 1));
+ }
+ }
+ }
+ return s;
+}
+
+
+void CPanel::OpenParentFolder()
+{
+ LoadFullPath(); // Maybe we don't need it ??
+
+ UString parentFolderPrefix;
+ UString focusedName;
+
+ if (!_currentFolderPrefix.IsEmpty())
+ {
+ wchar_t c = _currentFolderPrefix.Back();
+ if (IS_PATH_SEPAR(c) || c == ':')
+ {
+ focusedName = _currentFolderPrefix;
+ focusedName.DeleteBack();
+ /*
+ if (c == ':' && !focusedName.IsEmpty() && IS_PATH_SEPAR(focusedName.Back()))
+ {
+ focusedName.DeleteBack();
+ }
+ else
+ */
+ if (focusedName != L"\\\\." &&
+ focusedName != L"\\\\?")
+ {
+ const int pos = focusedName.ReverseFind_PathSepar();
+ if (pos >= 0)
+ {
+ parentFolderPrefix = focusedName;
+ parentFolderPrefix.DeleteFrom((unsigned)(pos + 1));
+ focusedName.DeleteFrontal((unsigned)(pos + 1));
+ }
+ }
+ }
+ }
+
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+
+ CMyComPtr<IFolderFolder> newFolder;
+ _folder->BindToParentFolder(&newFolder);
+
+ // newFolder.Release(); // for test
+
+ if (newFolder)
+ SetNewFolder(newFolder);
+ else
+ {
+ bool needSetFolder = true;
+ if (!_parentFolders.IsEmpty())
+ {
+ {
+ const CFolderLink &link = _parentFolders.Back();
+ parentFolderPrefix = link.ParentFolderPath;
+ focusedName = link.RelPath;
+ }
+ CloseOneLevel();
+ needSetFolder = (!_folder);
+ }
+
+ if (needSetFolder)
+ {
+ {
+ COpenResult openRes;
+ BindToPath(parentFolderPrefix, UString(), openRes);
+ }
+ }
+ }
+
+ CSelectedState state;
+ state.FocusedName = focusedName;
+ state.FocusedName_Defined = true;
+ /*
+ if (!focusedName.IsEmpty())
+ state.SelectedNames.Add(focusedName);
+ */
+ LoadFullPath();
+ // ::SetCurrentDirectory(::_currentFolderPrefix);
+ RefreshListCtrl(state);
+ // _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+
+void CPanel::CloseOneLevel()
+{
+ ReleaseFolder();
+ _library.Free();
+ {
+ CFolderLink &link = _parentFolders.Back();
+ if (link.ParentFolder)
+ SetNewFolder(link.ParentFolder);
+ _library.Attach(link.Library.Detach());
+ }
+ if (_parentFolders.Size() > 1)
+ OpenParentArchiveFolder();
+ _parentFolders.DeleteBack();
+ if (_parentFolders.IsEmpty())
+ _flatMode = _flatModeForDisk;
+}
+
+void CPanel::CloseOpenFolders()
+{
+ while (!_parentFolders.IsEmpty())
+ CloseOneLevel();
+ _flatMode = _flatModeForDisk;
+ ReleaseFolder();
+ _library.Free();
+}
+
+void CPanel::OpenRootFolder()
+{
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+ _parentFolders.Clear();
+ SetToRootFolder();
+ RefreshListCtrl();
+ // ::SetCurrentDirectory(::_currentFolderPrefix);
+ /*
+ BeforeChangeFolder();
+ _currentFolderPrefix.Empty();
+ AfterChangeFolder();
+ SetCurrentPathText();
+ RefreshListCtrl(UString(), 0, UStringVector());
+ _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+ */
+}
+
+void CPanel::OpenDrivesFolder()
+{
+ CloseOpenFolders();
+ #ifdef UNDER_CE
+ NFsFolder::CFSFolder *folderSpec = new NFsFolder::CFSFolder;
+ SetNewFolder(folderSpec);
+ folderSpec->InitToRoot();
+ #else
+ CFSDrives *folderSpec = new CFSDrives;
+ SetNewFolder(folderSpec);
+ folderSpec->Init();
+ #endif
+ RefreshListCtrl();
+}
+
+void CPanel::OpenFolder(unsigned index)
+{
+ if (index == kParentIndex)
+ {
+ OpenParentFolder();
+ return;
+ }
+ CMyComPtr<IFolderFolder> newFolder;
+ const HRESULT res = _folder->BindToFolder((unsigned)index, &newFolder);
+ if (res != 0)
+ {
+ MessageBox_Error_HRESULT(res);
+ return;
+ }
+ if (!newFolder)
+ return;
+ SetNewFolder(newFolder);
+ LoadFullPath();
+ RefreshListCtrl();
+ // 17.02: fixed : now we don't select first item
+ // _listView.SetItemState_Selected(_listView.GetFocusedItem());
+ _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+void CPanel::OpenAltStreams()
+{
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ Int32 realIndex = -1;
+ if (indices.Size() > 1)
+ return;
+ if (indices.Size() == 1)
+ realIndex = (Int32)indices[0];
+
+ if (_folderAltStreams)
+ {
+ CMyComPtr<IFolderFolder> newFolder;
+ _folderAltStreams->BindToAltStreams((UInt32)realIndex, &newFolder);
+ if (newFolder)
+ {
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+ SetNewFolder(newFolder);
+ RefreshListCtrl();
+ return;
+ }
+ return;
+ }
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ UString path;
+ if (realIndex >= 0)
+ path = GetItemFullPath((UInt32)realIndex);
+ else
+ {
+ path = GetFsPath();
+ if (!NName::IsDriveRootPath_SuperAllowed(us2fs(path)))
+ if (!path.IsEmpty() && IS_PATH_SEPAR(path.Back()))
+ path.DeleteBack();
+ }
+
+ path += ':';
+ BindToPathAndRefresh(path);
+ #endif
+}
diff --git a/CPP/7zip/UI/FileManager/PanelItemOpen.cpp b/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
new file mode 100644
index 0000000..bd65aef
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelItemOpen.cpp
@@ -0,0 +1,1869 @@
+// PanelItemOpen.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#include <TlHelp32.h>
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Common/AutoPtr.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/ProcessUtils.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../Common/FileStreams.h"
+#include "../../Common/StreamObjects.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "App.h"
+
+#include "FileFolderPluginOpen.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "PropertyNameRes.h"
+#include "RegistryUtils.h"
+#include "UpdateCallback100.h"
+
+#include "../GUI/ExtractRes.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NSynchronization;
+using namespace NFile;
+using namespace NDir;
+
+extern bool g_RAM_Size_Defined;
+extern UInt64 g_RAM_Size;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+#define kTempDirPrefix FTEXT("7zO")
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+ #define DEBUG_PRINT(s) OutputDebugStringA(s);
+ #define DEBUG_PRINT_W(s) OutputDebugStringW(s);
+ #define DEBUG_PRINT_NUM(s, num) { char ttt[32]; ConvertUInt32ToString(num, ttt); OutputDebugStringA(s); OutputDebugStringA(ttt); }
+#else
+ #define DEBUG_PRINT(s)
+ #define DEBUG_PRINT_W(s)
+ #define DEBUG_PRINT_NUM(s, num)
+#endif
+
+
+
+#ifndef UNDER_CE
+
+class CProcessSnapshot
+{
+ HANDLE _handle;
+public:
+ CProcessSnapshot(): _handle(INVALID_HANDLE_VALUE) {}
+ ~CProcessSnapshot() { Close(); }
+
+ bool Close()
+ {
+ if (_handle == INVALID_HANDLE_VALUE)
+ return true;
+ if (!::CloseHandle(_handle))
+ return false;
+ _handle = INVALID_HANDLE_VALUE;
+ return true;
+ }
+
+ bool Create()
+ {
+ _handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+ return (_handle != INVALID_HANDLE_VALUE);
+ }
+
+ bool GetFirstProcess(PROCESSENTRY32 *pe) { return BOOLToBool(Process32First(_handle, pe)); }
+ bool GetNextProcess(PROCESSENTRY32 *pe) { return BOOLToBool(Process32Next(_handle, pe)); }
+};
+
+#endif
+
+
+/*
+struct COpenExtProg
+{
+ const char *Ext;
+ const char *Prog;
+};
+
+static const COpenExtProg g_Progs[] =
+{
+ { "jpeg jpg png bmp gif", "Microsoft.Photos.exe" },
+ { "html htm pdf", "MicrosoftEdge.exe" },
+ // , { "rrr", "notepad.exe" }
+};
+
+static bool FindExtProg(const char *exts, const char *ext)
+{
+ unsigned len = (unsigned)strlen(ext);
+ for (;;)
+ {
+ const char *p = exts;
+ for (;; p++)
+ {
+ const char c = *p;
+ if (c == 0 || c == ' ')
+ break;
+ }
+ if (len == (unsigned)(p - exts) && IsString1PrefixedByString2(exts, ext))
+ return true;
+ if (*p == 0)
+ return false;
+ exts = p + 1;
+ }
+}
+
+class CPossibleProgs
+{
+public:
+ AStringVector ProgNames;
+
+ void SetFromExtension(const char *ext) // ext must be low case
+ {
+ ProgNames.Clear();
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Progs); i++)
+ if (FindExtProg(g_Progs[i].Ext, ext))
+ {
+ ProgNames.Add(g_Progs[i].Prog);
+ }
+ }
+
+ bool IsFromList(const UString &progName) const
+ {
+ FOR_VECTOR (i, ProgNames)
+ if (progName.IsEqualTo_Ascii_NoCase(ProgNames[i]))
+ return true;
+ return false;
+ }
+};
+*/
+
+
+#ifndef UNDER_CE
+
+EXTERN_C_BEGIN
+
+/*
+GetProcessImageFileName
+ returns the path in device form, rather than drive letters:
+ \Device\HarddiskVolume1\WINDOWS\SysWOW64\notepad.exe
+
+GetModuleFileNameEx works only after Sleep(something). Why?
+ returns the path
+ C:\WINDOWS\system32\NOTEPAD.EXE
+*/
+
+/* Kernel32.dll: Win7, Win2008R2;
+ Psapi.dll: (if PSAPI_VERSION=1) on Win7 and Win2008R2;
+ Psapi.dll: XP, Win2003, Vista, 2008;
+*/
+
+typedef DWORD (WINAPI *Func_GetProcessImageFileNameW)(
+ HANDLE hProcess, LPWSTR lpFilename, DWORD nSize);
+
+typedef DWORD (WINAPI *Func_GetModuleFileNameExW)(
+ HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
+
+typedef DWORD (WINAPI *Func_GetProcessId)(HANDLE process);
+
+EXTERN_C_END
+
+
+static HMODULE g_Psapi_dll_module;
+
+/*
+static void My_GetProcessFileName_2(HANDLE hProcess, UString &path)
+{
+ path.Empty();
+ const unsigned maxPath = 1024;
+ WCHAR temp[maxPath + 1];
+
+ const char *func_name = "GetModuleFileNameExW";
+ Func_GetModuleFileNameExW my_func = (Func_GetModuleFileNameExW)
+ ::GetProcAddress(::GetModuleHandleA("kernel32.dll"), func_name);
+ if (!my_func)
+ {
+ if (!g_Psapi_dll_module)
+ g_Psapi_dll_module = LoadLibraryW(L"Psapi.dll");
+ if (g_Psapi_dll_module)
+ my_func = (Func_GetModuleFileNameExW)::GetProcAddress(g_Psapi_dll_module, func_name);
+ }
+ if (my_func)
+ {
+ // DWORD num = GetModuleFileNameEx(hProcess, NULL, temp, maxPath);
+ DWORD num = my_func(hProcess, NULL, temp, maxPath);
+ if (num != 0)
+ path = temp;
+ }
+ // FreeLibrary(lib);
+}
+*/
+
+static void My_GetProcessFileName(HANDLE hProcess, UString &path)
+{
+ path.Empty();
+ const unsigned maxPath = 1024;
+ WCHAR temp[maxPath + 1];
+
+ const char *func_name =
+ "GetProcessImageFileNameW";
+ Func_GetProcessImageFileNameW my_func = Z7_GET_PROC_ADDRESS(
+ Func_GetProcessImageFileNameW, ::GetModuleHandleA("kernel32.dll"), func_name);
+
+ if (!my_func)
+ {
+ if (!g_Psapi_dll_module)
+ g_Psapi_dll_module = LoadLibraryW(L"Psapi.dll");
+ if (g_Psapi_dll_module)
+ my_func = Z7_GET_PROC_ADDRESS(
+ Func_GetProcessImageFileNameW, g_Psapi_dll_module, func_name);
+ }
+
+ if (my_func)
+ {
+ const DWORD num =
+ // GetProcessImageFileNameW(hProcess, temp, maxPath);
+ my_func(hProcess, temp, maxPath);
+ if (num != 0)
+ path = temp;
+ }
+ // FreeLibrary(lib);
+}
+
+struct CSnapshotProcess
+{
+ DWORD Id;
+ DWORD ParentId;
+ UString Name;
+};
+
+static void GetSnapshot(CObjectVector<CSnapshotProcess> &items)
+{
+ items.Clear();
+
+ CProcessSnapshot snapshot;
+ if (!snapshot.Create())
+ return;
+
+ DEBUG_PRINT("snapshot.Create() OK");
+ PROCESSENTRY32 pe;
+ CSnapshotProcess item;
+ memset(&pe, 0, sizeof(pe));
+ pe.dwSize = sizeof(pe);
+ BOOL res = snapshot.GetFirstProcess(&pe);
+ while (res)
+ {
+ item.Id = pe.th32ProcessID;
+ item.ParentId = pe.th32ParentProcessID;
+ item.Name = GetUnicodeString(pe.szExeFile);
+ items.Add(item);
+ res = snapshot.GetNextProcess(&pe);
+ }
+}
+
+#endif
+
+
+class CChildProcesses
+{
+ #ifndef UNDER_CE
+ CRecordVector<DWORD> _ids;
+ #endif
+
+public:
+ // bool ProgsWereUsed;
+ CRecordVector<HANDLE> Handles;
+ CRecordVector<bool> NeedWait;
+ // UStringVector Names;
+
+ #ifndef UNDER_CE
+ UString Path;
+ #endif
+
+ // CChildProcesses(): ProgsWereUsed(false) {}
+ ~CChildProcesses() { CloseAll(); }
+ void DisableWait(unsigned index) { NeedWait[index] = false; }
+
+ void CloseAll()
+ {
+ FOR_VECTOR (i, Handles)
+ {
+ HANDLE h = Handles[i];
+ if (h != NULL)
+ CloseHandle(h);
+ }
+
+ Handles.Clear();
+ NeedWait.Clear();
+ // Names.Clear();
+
+ #ifndef UNDER_CE
+ // Path.Empty();
+ _ids.Clear();
+ #endif
+ }
+
+ void SetMainProcess(HANDLE h)
+ {
+ #ifndef UNDER_CE
+ const
+ Func_GetProcessId func = Z7_GET_PROC_ADDRESS(
+ Func_GetProcessId, ::GetModuleHandleA("kernel32.dll"),
+ "GetProcessId");
+ if (func)
+ {
+ const DWORD id = func(h);
+ if (id != 0)
+ _ids.AddToUniqueSorted(id);
+ }
+
+ My_GetProcessFileName(h, Path);
+ DEBUG_PRINT_W(Path);
+
+ #endif
+
+ Handles.Add(h);
+ NeedWait.Add(true);
+ }
+
+ #ifndef UNDER_CE
+
+ void Update(bool needFindProcessByPath /* , const CPossibleProgs &progs */)
+ {
+ /*
+ if (_ids.IsEmpty())
+ return;
+ */
+
+ CObjectVector<CSnapshotProcess> sps;
+ GetSnapshot(sps);
+
+ const int separ = Path.ReverseFind_PathSepar();
+ const UString mainName = Path.Ptr((unsigned)(separ + 1));
+ if (mainName.IsEmpty())
+ needFindProcessByPath = false;
+
+ const DWORD currentProcessId = GetCurrentProcessId();
+
+ for (;;)
+ {
+ bool wasAdded = false;
+
+ FOR_VECTOR (i, sps)
+ {
+ const CSnapshotProcess &sp = sps[i];
+ const DWORD id = sp.Id;
+
+ if (id == currentProcessId)
+ continue;
+ if (_ids.FindInSorted(id) >= 0)
+ continue;
+
+ bool isSameName = false;
+ const UString &name = sp.Name;
+
+ if (needFindProcessByPath)
+ isSameName = mainName.IsEqualTo_NoCase(name);
+
+ bool needAdd = false;
+ // bool isFromProgs = false;
+
+ if (isSameName || _ids.FindInSorted(sp.ParentId) >= 0)
+ needAdd = true;
+ /*
+ else if (progs.IsFromList(name))
+ {
+ needAdd = true;
+ isFromProgs = true;
+ }
+ */
+
+ if (needAdd)
+ {
+ DEBUG_PRINT("----- OpenProcess -----");
+ DEBUG_PRINT_W(name);
+ HANDLE hProcess = OpenProcess(SYNCHRONIZE, FALSE, id);
+ if (hProcess)
+ {
+ DEBUG_PRINT("----- OpenProcess OK -----");
+ // if (!isFromProgs)
+ _ids.AddToUniqueSorted(id);
+ Handles.Add(hProcess);
+ NeedWait.Add(true);
+ // Names.Add(name);
+ wasAdded = true;
+ // ProgsWereUsed = isFromProgs;
+ }
+ }
+ }
+
+ if (!wasAdded)
+ break;
+ }
+ }
+
+ #endif
+};
+
+
+struct CTmpProcessInfo: public CTempFileInfo
+{
+ CChildProcesses Processes;
+ HWND Window;
+ UString FullPathFolderPrefix;
+ bool UsePassword;
+ UString Password;
+
+ bool ReadOnly;
+
+ CTmpProcessInfo(): UsePassword(false), ReadOnly(false) {}
+};
+
+
+class CTmpProcessInfoRelease
+{
+ CTmpProcessInfo *_tmpProcessInfo;
+public:
+ bool _needDelete;
+ CTmpProcessInfoRelease(CTmpProcessInfo &tpi):
+ _tmpProcessInfo(&tpi), _needDelete(true) {}
+ ~CTmpProcessInfoRelease()
+ {
+ if (_needDelete)
+ _tmpProcessInfo->DeleteDirAndFile();
+ }
+};
+
+void GetFolderError(CMyComPtr<IFolderFolder> &folder, UString &s);
+
+
+HRESULT CPanel::OpenAsArc(IInStream *inStream,
+ const CTempFileInfo &tempFileInfo,
+ const UString &virtualFilePath,
+ const UString &arcFormat,
+ COpenResult &openRes)
+{
+ openRes.Encrypted = false;
+ CFolderLink folderLink;
+ (CTempFileInfo &)folderLink = tempFileInfo;
+
+ if (inStream)
+ folderLink.IsVirtual = true;
+ else
+ {
+ if (!folderLink.FileInfo.Find(folderLink.FilePath))
+ return GetLastError_noZero_HRESULT();
+ if (folderLink.FileInfo.IsDir())
+ return S_FALSE;
+ folderLink.IsVirtual = false;
+ }
+
+ folderLink.VirtualPath = virtualFilePath;
+
+ CFfpOpen ffp;
+ const HRESULT res = ffp.OpenFileFolderPlugin(inStream,
+ folderLink.FilePath.IsEmpty() ? us2fs(virtualFilePath) : folderLink.FilePath,
+ arcFormat, GetParent());
+
+ openRes.Encrypted = ffp.Encrypted;
+ openRes.ErrorMessage = ffp.ErrorMessage;
+
+ RINOK(res)
+
+ folderLink.Password = ffp.Password;
+ folderLink.UsePassword = ffp.Encrypted;
+
+ if (_folder)
+ folderLink.ParentFolderPath = GetFolderPath(_folder);
+ else
+ folderLink.ParentFolderPath = _currentFolderPrefix;
+
+ if (!_parentFolders.IsEmpty())
+ folderLink.ParentFolder = _folder;
+
+ _parentFolders.Add(folderLink);
+ _parentFolders.Back().Library.Attach(_library.Detach());
+
+ ReleaseFolder();
+ _library.Free();
+ SetNewFolder(ffp.Folder);
+ _library.Attach(ffp.Library.Detach());
+
+ _flatMode = _flatModeForArc;
+
+ _thereAreDeletedItems = false;
+
+ if (!openRes.ErrorMessage.IsEmpty())
+ MessageBox_Error(openRes.ErrorMessage);
+ /*
+ UString s;
+ GetFolderError(_folder, s);
+ if (!s.IsEmpty())
+ MessageBox_Error(s);
+ */
+ // we don't show error here by some reasons:
+ // after MessageBox_Warning it throws exception in nested archives in Debug Mode. why ?.
+ // MessageBox_Warning(L"test error");
+
+ return S_OK;
+}
+
+
+HRESULT CPanel::OpenAsArc_Msg(IInStream *inStream,
+ const CTempFileInfo &tempFileInfo,
+ const UString &virtualFilePath,
+ const UString &arcFormat
+ // , bool &encrypted
+ // , bool showErrorMessage
+ )
+{
+ COpenResult opRes;
+
+ HRESULT res = OpenAsArc(inStream, tempFileInfo, virtualFilePath, arcFormat, opRes);
+
+ if (res == S_OK)
+ return res;
+ if (res == E_ABORT)
+ return res;
+
+ // if (showErrorMessage)
+ if (opRes.Encrypted || res != S_FALSE) // 17.01 : we show message also for (res != S_FALSE)
+ {
+ UString message;
+ if (res == S_FALSE)
+ {
+ message = MyFormatNew(
+ opRes.Encrypted ?
+ IDS_CANT_OPEN_ENCRYPTED_ARCHIVE :
+ IDS_CANT_OPEN_ARCHIVE,
+ virtualFilePath);
+ }
+ else
+ message = HResultToMessage(res);
+ MessageBox_Error(message);
+ }
+
+ return res;
+}
+
+
+HRESULT CPanel::OpenAsArc_Name(const UString &relPath, const UString &arcFormat
+ // , bool &encrypted,
+ // , bool showErrorMessage
+ )
+{
+ CTempFileInfo tfi;
+ tfi.RelPath = relPath;
+ tfi.FolderPath = us2fs(GetFsPath());
+ const UString fullPath = GetFsPath() + relPath;
+ tfi.FilePath = us2fs(fullPath);
+ return OpenAsArc_Msg(NULL, tfi, fullPath, arcFormat /* , encrypted, showErrorMessage */);
+}
+
+
+HRESULT CPanel::OpenAsArc_Index(unsigned index, const wchar_t *type
+ // , bool showErrorMessage
+ )
+{
+ CDisableTimerProcessing disableTimerProcessing1(*this);
+ CDisableNotify disableNotify(*this);
+
+ HRESULT res = OpenAsArc_Name(GetItemRelPath2(index), type ? type : L"" /* , encrypted, showErrorMessage */);
+ if (res != S_OK)
+ {
+ RefreshTitle(true); // in case of error we must refresh changed title of 7zFM
+ return res;
+ }
+ RefreshListCtrl();
+ return S_OK;
+}
+
+
+HRESULT CPanel::OpenParentArchiveFolder()
+{
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+ if (_parentFolders.Size() < 2)
+ return S_OK;
+ const CFolderLink &folderLinkPrev = _parentFolders[_parentFolders.Size() - 2];
+ const CFolderLink &folderLink = _parentFolders.Back();
+ NFind::CFileInfo newFileInfo;
+ if (newFileInfo.Find(folderLink.FilePath))
+ {
+ if (folderLink.WasChanged(newFileInfo))
+ {
+ UString message = MyFormatNew(IDS_WANT_UPDATE_MODIFIED_FILE, folderLink.RelPath);
+ if (::MessageBoxW((HWND)*this, message, L"7-Zip", MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
+ {
+ if (OnOpenItemChanged(folderLink.FileIndex, fs2us(folderLink.FilePath),
+ folderLinkPrev.UsePassword, folderLinkPrev.Password) != S_OK)
+ {
+ ::MessageBoxW((HWND)*this, MyFormatNew(IDS_CANNOT_UPDATE_FILE,
+ fs2us(folderLink.FilePath)), L"7-Zip", MB_OK | MB_ICONSTOP);
+ return S_OK;
+ }
+ }
+ }
+ }
+ folderLink.DeleteDirAndFile();
+ return S_OK;
+}
+
+
+static const char * const kExeExtensions =
+ " exe bat ps1 com"
+ " ";
+
+static const char * const kStartExtensions =
+ #ifdef UNDER_CE
+ " cab"
+ #endif
+ " exe bat ps1 com"
+ " chm"
+ " msi doc dot xls ppt pps wps wpt wks xlr wdb vsd pub"
+
+ " docx docm dotx dotm xlsx xlsm xltx xltm xlsb xps"
+ " xlam pptx pptm potx potm ppam ppsx ppsm vsdx xsn"
+ " mpp"
+ " msg"
+ " dwf"
+
+ " flv swf"
+
+ " epub"
+ " odt ods"
+ " wb3"
+ " pdf"
+ " ps"
+ " txt"
+ " xml xsd xsl xslt hxk hxc htm html xhtml xht mht mhtml htw asp aspx css cgi jsp shtml"
+ " h hpp hxx c cpp cxx m mm go swift"
+ " awk sed hta js json php php3 php4 php5 phptml pl pm py pyo rb tcl ts vbs"
+ " asm"
+ " mak clw csproj vcproj sln dsp dsw"
+ " ";
+
+// bool FindExt(const char *p, const UString &name, AString &s);
+bool FindExt(const char *p, const UString &name, CStringFinder &finder);
+
+static bool DoItemAlwaysStart(const UString &name)
+{
+ CStringFinder finder;
+ return FindExt(kStartExtensions, name, finder);
+}
+
+UString GetQuotedString(const UString &s);
+
+
+void SplitCmdLineSmart(const UString &cmd, UString &prg, UString ¶ms);
+void SplitCmdLineSmart(const UString &cmd, UString &prg, UString ¶ms)
+{
+ params.Empty();
+ prg = cmd;
+ prg.Trim();
+ if (prg.Len() >= 2 && prg[0] == L'"')
+ {
+ int pos = prg.Find(L'"', 1);
+ if (pos >= 0)
+ {
+ if ((unsigned)(pos + 1) == prg.Len() || prg[pos + 1] == ' ')
+ {
+ params = prg.Ptr((unsigned)(pos + 1));
+ params.Trim();
+ prg.DeleteFrom((unsigned)pos);
+ prg.DeleteFrontal(1);
+ }
+ }
+ }
+}
+
+
+static WRes StartAppWithParams(const UString &cmd, const UStringVector ¶mVector, CProcess &process)
+{
+ UString param;
+ UString prg;
+
+ SplitCmdLineSmart(cmd, prg, param);
+
+ param.Trim();
+
+ // int pos = params.Find(L"%1");
+
+ FOR_VECTOR (i, paramVector)
+ {
+ if (!param.IsEmpty() && param.Back() != ' ')
+ param.Add_Space();
+ param += GetQuotedString(paramVector[i]);
+ }
+
+ return process.Create(prg, param, NULL);
+}
+
+
+static HRESULT StartEditApplication(const UString &path, bool useEditor, HWND window, CProcess &process)
+{
+ UString command;
+ ReadRegEditor(useEditor, command);
+ if (command.IsEmpty())
+ {
+ #ifdef UNDER_CE
+ command = "\\Windows\\";
+ #else
+ FString winDir;
+ if (!GetWindowsDir(winDir))
+ return 0;
+ NName::NormalizeDirPathPrefix(winDir);
+ command = fs2us(winDir);
+ #endif
+ command += "notepad.exe";
+ }
+
+ UStringVector params;
+ params.Add(path);
+
+ const WRes res = StartAppWithParams(command, params, process);
+ if (res != 0)
+ ::MessageBoxW(window, LangString(IDS_CANNOT_START_EDITOR), L"7-Zip", MB_OK | MB_ICONSTOP);
+ return HRESULT_FROM_WIN32(res);
+}
+
+
+void CApp::DiffFiles()
+{
+ const CPanel &panel = GetFocusedPanel();
+
+ if (!panel.Is_IO_FS_Folder())
+ {
+ panel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ CRecordVector<UInt32> indices;
+ panel.Get_ItemIndices_Selected(indices);
+
+ UString path1, path2;
+ if (indices.Size() == 2)
+ {
+ path1 = panel.GetItemFullPath(indices[0]);
+ path2 = panel.GetItemFullPath(indices[1]);
+ }
+ else if (indices.Size() == 1 && NumPanels >= 2)
+ {
+ const CPanel &destPanel = Panels[1 - LastFocusedPanel];
+
+ if (!destPanel.Is_IO_FS_Folder())
+ {
+ panel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ path1 = panel.GetItemFullPath(indices[0]);
+ CRecordVector<UInt32> indices2;
+ destPanel.Get_ItemIndices_Selected(indices2);
+ if (indices2.Size() == 1)
+ path2 = destPanel.GetItemFullPath(indices2[0]);
+ else
+ {
+ UString relPath = panel.GetItemRelPath2(indices[0]);
+ if (panel._flatMode && !destPanel._flatMode)
+ relPath = panel.GetItemName(indices[0]);
+ path2 = destPanel._currentFolderPrefix + relPath;
+ }
+ }
+ else
+ return;
+
+ DiffFiles(path1, path2);
+}
+
+void CApp::DiffFiles(const UString &path1, const UString &path2)
+{
+ UString command;
+ ReadRegDiff(command);
+ if (command.IsEmpty())
+ return;
+
+ UStringVector params;
+ params.Add(path1);
+ params.Add(path2);
+
+ WRes res;
+ {
+ CProcess process;
+ res = StartAppWithParams(command, params, process);
+ }
+ if (res == 0)
+ return;
+ ::MessageBoxW(_window, LangString(IDS_CANNOT_START_EDITOR), L"7-Zip", MB_OK | MB_ICONSTOP);
+}
+
+
+#ifndef _UNICODE
+typedef BOOL (WINAPI * Func_ShellExecuteExW)(LPSHELLEXECUTEINFOW lpExecInfo);
+#endif
+
+static HRESULT StartApplication(const UString &dir, const UString &path, HWND window, CProcess &process)
+{
+ UString path2 = path;
+
+ #ifdef _WIN32
+ {
+ int dot = path2.ReverseFind_Dot();
+ int separ = path2.ReverseFind_PathSepar();
+ if (dot < 0 || dot < separ)
+ path2.Add_Dot();
+ }
+ #endif
+
+ UINT32 result;
+
+ #ifndef _UNICODE
+ if (g_IsNT)
+ {
+ SHELLEXECUTEINFOW execInfo;
+ execInfo.cbSize = sizeof(execInfo);
+ execInfo.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_DDEWAIT;
+ execInfo.hwnd = NULL;
+ execInfo.lpVerb = NULL;
+ execInfo.lpFile = path2;
+ execInfo.lpParameters = NULL;
+ execInfo.lpDirectory = dir.IsEmpty() ? NULL : (LPCWSTR)dir;
+ execInfo.nShow = SW_SHOWNORMAL;
+ execInfo.hProcess = NULL;
+ const
+ Func_ShellExecuteExW
+ f_ShellExecuteExW = Z7_GET_PROC_ADDRESS(
+ Func_ShellExecuteExW, ::GetModuleHandleW(L"shell32.dll"),
+ "ShellExecuteExW");
+ if (!f_ShellExecuteExW)
+ return 0;
+ f_ShellExecuteExW(&execInfo);
+ result = (UINT32)(UINT_PTR)execInfo.hInstApp;
+ process.Attach(execInfo.hProcess);
+ }
+ else
+ #endif
+ {
+ SHELLEXECUTEINFO execInfo;
+ execInfo.cbSize = sizeof(execInfo);
+ execInfo.fMask = SEE_MASK_NOCLOSEPROCESS
+ #ifndef UNDER_CE
+ | SEE_MASK_FLAG_DDEWAIT
+ #endif
+ ;
+ execInfo.hwnd = NULL;
+ execInfo.lpVerb = NULL;
+ const CSysString sysPath (GetSystemString(path2));
+ const CSysString sysDir (GetSystemString(dir));
+ execInfo.lpFile = sysPath;
+ execInfo.lpParameters = NULL;
+ execInfo.lpDirectory =
+ #ifdef UNDER_CE
+ NULL
+ #else
+ sysDir.IsEmpty() ? NULL : (LPCTSTR)sysDir
+ #endif
+ ;
+ execInfo.nShow = SW_SHOWNORMAL;
+ execInfo.hProcess = NULL;
+ ::ShellExecuteEx(&execInfo);
+ result = (UINT32)(UINT_PTR)execInfo.hInstApp;
+ process.Attach(execInfo.hProcess);
+ }
+
+
+ DEBUG_PRINT_NUM("-- ShellExecuteEx -- execInfo.hInstApp = ", result)
+
+ if (result <= 32)
+ {
+ switch (result)
+ {
+ case SE_ERR_NOASSOC:
+ ::MessageBoxW(window,
+ NError::MyFormatMessage(::GetLastError()),
+ // L"There is no application associated with the given file name extension",
+ L"7-Zip", MB_OK | MB_ICONSTOP);
+ }
+
+ return E_FAIL; // fixed in 15.13. Can we use it for any Windows version?
+ }
+
+ return S_OK;
+}
+
+static void StartApplicationDontWait(const UString &dir, const UString &path, HWND window)
+{
+ CProcess process;
+ StartApplication(dir, path, window, process);
+}
+
+void CPanel::EditItem(unsigned index, bool useEditor)
+{
+ if (!_parentFolders.IsEmpty())
+ {
+ OpenItemInArchive(index, false, true, true, useEditor);
+ return;
+ }
+ CProcess process;
+ StartEditApplication(GetItemFullPath(index), useEditor, (HWND)*this, process);
+}
+
+
+void CPanel::OpenFolderExternal(unsigned index)
+{
+ UString prefix = GetFsPath();
+ UString path = prefix;
+
+ if (index == kParentIndex)
+ {
+ if (prefix.IsEmpty())
+ return;
+ const wchar_t c = prefix.Back();
+ if (!IS_PATH_SEPAR(c) && c != ':')
+ return;
+ prefix.DeleteBack();
+ int pos = prefix.ReverseFind_PathSepar();
+ if (pos < 0)
+ return;
+ prefix.DeleteFrom((unsigned)(pos + 1));
+ path = prefix;
+ }
+ else
+ {
+ path += GetItemRelPath(index);
+ path.Add_PathSepar();
+ }
+
+ StartApplicationDontWait(prefix, path, (HWND)*this);
+}
+
+
+bool CPanel::IsVirus_Message(const UString &name)
+{
+ UString name2;
+
+ const wchar_t cRLO = (wchar_t)0x202E;
+ bool isVirus = false;
+ bool isSpaceError = false;
+ name2 = name;
+
+ if (name2.Find(cRLO) >= 0)
+ {
+ const UString badString(cRLO);
+ name2.Replace(badString, L"[RLO]");
+ isVirus = true;
+ }
+ {
+ const wchar_t * const kVirusSpaces = L" ";
+ // const unsigned kNumSpaces = strlen(kVirusSpaces);
+ for (;;)
+ {
+ int pos = name2.Find(kVirusSpaces);
+ if (pos < 0)
+ break;
+ isVirus = true;
+ isSpaceError = true;
+ name2.Replace(kVirusSpaces, L" ");
+ }
+ }
+
+ #ifdef _WIN32
+ {
+ unsigned i;
+ for (i = name2.Len(); i != 0;)
+ {
+ wchar_t c = name2[i - 1];
+ if (c != '.' && c != ' ')
+ break;
+ i--;
+ name2.ReplaceOneCharAtPos(i, '_');
+ }
+ if (i != name2.Len())
+ {
+ CStringFinder finder;
+ UString name3 = name2;
+ name3.DeleteFrom(i);
+ if (FindExt(kExeExtensions, name3, finder))
+ isVirus = true;
+ }
+ }
+ #endif
+
+ if (!isVirus)
+ return false;
+
+ UString s = LangString(IDS_VIRUS);
+
+ if (!isSpaceError)
+ {
+ const int pos1 = s.Find(L'(');
+ if (pos1 >= 0)
+ {
+ const int pos2 = s.Find(L')', (unsigned)pos1 + 1);
+ if (pos2 >= 0)
+ {
+ s.Delete((unsigned)pos1, (unsigned)pos2 + 1 - (unsigned)pos1);
+ if (pos1 > 0 && s[pos1 - 1] == ' ' && s[pos1] == '.')
+ s.Delete(pos1 - 1);
+ }
+ }
+ }
+
+ UString name3 = name;
+ name3.Replace(L'\n', L'_');
+ name2.Replace(L'\n', L'_');
+
+ s.Add_LF(); s += name2;
+ s.Add_LF(); s += name3;
+
+ MessageBox_Error(s);
+ return true;
+}
+
+
+void CPanel::OpenItem(unsigned index, bool tryInternal, bool tryExternal, const wchar_t *type)
+{
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ const UString name = GetItemRelPath2(index);
+
+ if (tryExternal)
+ if (IsVirus_Message(name))
+ return;
+
+ if (!_parentFolders.IsEmpty())
+ {
+ OpenItemInArchive(index, tryInternal, tryExternal, false, false, type);
+ return;
+ }
+
+ CDisableNotify disableNotify(*this);
+ UString prefix = GetFsPath();
+ UString fullPath = prefix + name;
+
+ if (tryInternal)
+ if (!tryExternal || !DoItemAlwaysStart(name))
+ {
+ HRESULT res = OpenAsArc_Index(index, type
+ // , true
+ );
+ disableNotify.Restore(); // we must restore to allow text notification update
+ InvalidateList();
+ if (res == S_OK || res == E_ABORT)
+ return;
+ if (res != S_FALSE)
+ {
+ MessageBox_Error_HRESULT(res);
+ return;
+ }
+ }
+
+ if (tryExternal)
+ {
+ // SetCurrentDirectory opens HANDLE to folder!!!
+ // NDirectory::MySetCurrentDirectory(prefix);
+ StartApplicationDontWait(prefix, fullPath, (HWND)*this);
+ }
+}
+
+class CThreadCopyFrom: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt() Z7_override;
+public:
+ UString FullPath;
+ UInt32 ItemIndex;
+
+ CMyComPtr<IFolderOperations> FolderOperations;
+ CMyComPtr<IProgress> UpdateCallback;
+ CUpdateCallback100Imp *UpdateCallbackSpec;
+};
+
+HRESULT CThreadCopyFrom::ProcessVirt()
+{
+ return FolderOperations->CopyFromFile(ItemIndex, FullPath, UpdateCallback);
+}
+
+HRESULT CPanel::OnOpenItemChanged(UInt32 index, const wchar_t *fullFilePath,
+ bool usePassword, const UString &password)
+{
+ if (!_folderOperations)
+ {
+ MessageBox_Error_UnsupportOperation();
+ return E_FAIL;
+ }
+
+ CThreadCopyFrom t;
+ t.UpdateCallbackSpec = new CUpdateCallback100Imp;
+ t.UpdateCallback = t.UpdateCallbackSpec;
+ t.UpdateCallbackSpec->ProgressDialog = &t;
+ t.ItemIndex = index;
+ t.FullPath = fullFilePath;
+ t.FolderOperations = _folderOperations;
+
+ t.UpdateCallbackSpec->Init();
+ t.UpdateCallbackSpec->PasswordIsDefined = usePassword;
+ t.UpdateCallbackSpec->Password = password;
+
+
+ RINOK(t.Create(GetItemName(index), (HWND)*this))
+ return t.Result;
+}
+
+LRESULT CPanel::OnOpenItemChanged(LPARAM lParam)
+{
+ // DEBUG_PRINT_NUM("OnOpenItemChanged", GetCurrentThreadId());
+
+ CTmpProcessInfo &tpi = *(CTmpProcessInfo *)lParam;
+ if (tpi.FullPathFolderPrefix != _currentFolderPrefix)
+ return 0;
+ UInt32 fileIndex = tpi.FileIndex;
+ UInt32 numItems;
+ _folder->GetNumberOfItems(&numItems);
+
+ // This code is not 100% OK for cases when there are several files with
+ // tpi.RelPath name and there are changes in archive before update.
+ // So tpi.FileIndex can point to another file.
+
+ if (fileIndex >= numItems || GetItemRelPath(fileIndex) != tpi.RelPath)
+ {
+ UInt32 i;
+ for (i = 0; i < numItems; i++)
+ if (GetItemRelPath(i) == tpi.RelPath)
+ break;
+ if (i == numItems)
+ return 0;
+ fileIndex = i;
+ }
+
+ CSelectedState state;
+ SaveSelectedState(state);
+
+ CDisableNotify disableNotify(*this); // do we need it??
+
+ HRESULT result = OnOpenItemChanged(fileIndex, fs2us(tpi.FilePath), tpi.UsePassword, tpi.Password);
+ RefreshListCtrl(state);
+ if (result != S_OK)
+ return 0;
+ return 1;
+}
+
+
+CExitEventLauncher g_ExitEventLauncher;
+
+void CExitEventLauncher::Exit(bool hardExit)
+{
+ if (_needExit)
+ {
+ _exitEvent.Set();
+ _needExit = false;
+ }
+
+ if (_numActiveThreads == 0)
+ return;
+
+ FOR_VECTOR (i, _threads)
+ {
+ ::CThread &th = _threads[i];
+ DWORD wait = (hardExit ? 100 : INFINITE);
+ if (Thread_WasCreated(&th))
+ {
+ DWORD waitResult = WaitForSingleObject(th, wait);
+ // Thread_Wait(&th);
+ if (waitResult == WAIT_TIMEOUT)
+ wait = 1;
+ if (!hardExit && waitResult != WAIT_OBJECT_0)
+ continue;
+ Thread_Close(&th);
+ _numActiveThreads--;
+ }
+ }
+}
+
+
+
+static THREAD_FUNC_DECL MyThreadFunction(void *param)
+{
+ DEBUG_PRINT("==== MyThreadFunction ====");
+
+ CMyAutoPtr<CTmpProcessInfo> tmpProcessInfoPtr((CTmpProcessInfo *)param);
+ CTmpProcessInfo *tpi = tmpProcessInfoPtr.get();
+ CChildProcesses &processes = tpi->Processes;
+
+ bool mainProcessWasSet = !processes.Handles.IsEmpty();
+
+ bool isComplexMode = true;
+
+ if (!processes.Handles.IsEmpty())
+ {
+
+ const DWORD startTime = GetTickCount();
+
+ /*
+ CPossibleProgs progs;
+ {
+ const UString &name = tpi->RelPath;
+ int slashPos = name.ReverseFind_PathSepar();
+ int dotPos = name.ReverseFind_Dot();
+ if (dotPos > slashPos)
+ {
+ const UString ext = name.Ptr(dotPos + 1);
+ AString extA = UnicodeStringToMultiByte(ext);
+ extA.MakeLower_Ascii();
+ progs.SetFromExtension(extA);
+ }
+ }
+ */
+
+ bool firstPass = true;
+
+ for (;;)
+ {
+ CRecordVector<HANDLE> handles;
+ CUIntVector indices;
+
+ FOR_VECTOR (i, processes.Handles)
+ {
+ if (handles.Size() > 60)
+ break;
+ if (processes.NeedWait[i])
+ {
+ handles.Add(processes.Handles[i]);
+ indices.Add(i);
+ }
+ }
+
+ bool needFindProcessByPath = false;
+
+ if (handles.IsEmpty())
+ {
+ if (!firstPass)
+ break;
+ }
+ else
+ {
+ handles.Add(g_ExitEventLauncher._exitEvent);
+
+ DWORD waitResult = WaitForMultiObj_Any_Infinite(handles.Size(), &handles.Front());
+
+ waitResult -= WAIT_OBJECT_0;
+
+ if (waitResult >= handles.Size() - 1)
+ {
+ processes.CloseAll();
+ /*
+ if (waitResult == handles.Size() - 1)
+ {
+ // exit event
+ // we want to delete temp files, if progs were used
+ if (processes.ProgsWereUsed)
+ break;
+ }
+ */
+ return waitResult >= (DWORD)handles.Size() ? 1 : 0;
+ }
+
+ if (firstPass && indices.Size() == 1)
+ {
+ const DWORD curTime = GetTickCount() - startTime;
+
+ /*
+ if (curTime > 5 * 1000)
+ progs.ProgNames.Clear();
+ */
+
+ needFindProcessByPath = (curTime < 2 * 1000);
+
+ if (needFindProcessByPath)
+ {
+ NFind::CFileInfo newFileInfo;
+ if (newFileInfo.Find(tpi->FilePath))
+ if (tpi->WasChanged(newFileInfo))
+ needFindProcessByPath = false;
+ }
+
+ DEBUG_PRINT_NUM(" -- firstPass -- time = ", curTime)
+ }
+
+ processes.DisableWait(indices[(unsigned)waitResult]);
+ }
+
+ firstPass = false;
+
+ // Sleep(300);
+ #ifndef UNDER_CE
+ processes.Update(needFindProcessByPath /* , progs */);
+ #endif
+ }
+
+
+ const DWORD curTime = GetTickCount() - startTime;
+
+ DEBUG_PRINT_NUM("after time = ", curTime)
+
+ processes.CloseAll();
+
+ isComplexMode = (curTime < 2 * 1000);
+
+ }
+
+ bool needCheckTimestamp = true;
+
+ for (;;)
+ {
+ NFind::CFileInfo newFileInfo;
+
+ if (!newFileInfo.Find(tpi->FilePath))
+ break;
+
+ if (mainProcessWasSet)
+ {
+ if (tpi->WasChanged(newFileInfo))
+ {
+ UString m = MyFormatNew(IDS_CANNOT_UPDATE_FILE, fs2us(tpi->FilePath));
+ if (tpi->ReadOnly)
+ {
+ m.Add_LF();
+ AddLangString(m, IDS_PROP_READ_ONLY);
+ m.Add_LF();
+ m += tpi->FullPathFolderPrefix;
+ ::MessageBoxW(g_HWND, m, L"7-Zip", MB_OK | MB_ICONSTOP);
+ return 0;
+ }
+ {
+ const UString message = MyFormatNew(IDS_WANT_UPDATE_MODIFIED_FILE, tpi->RelPath);
+ if (::MessageBoxW(g_HWND, message, L"7-Zip", MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
+ {
+ // DEBUG_PRINT_NUM("SendMessage", GetCurrentThreadId());
+ if (SendMessage(tpi->Window, kOpenItemChanged, 0, (LONG_PTR)tpi) != 1)
+ {
+ ::MessageBoxW(g_HWND, m, L"7-Zip", MB_OK | MB_ICONSTOP);
+ return 0;
+ }
+ }
+ needCheckTimestamp = false;
+ break;
+ }
+ }
+
+ if (!isComplexMode)
+ break;
+ }
+
+ // DEBUG_PRINT("WaitForSingleObject");
+ DWORD waitResult = ::WaitForSingleObject(g_ExitEventLauncher._exitEvent, INFINITE);
+ // DEBUG_PRINT("---");
+
+ if (waitResult == WAIT_OBJECT_0)
+ break;
+
+ return 1;
+ }
+
+ {
+ NFind::CFileInfo newFileInfo;
+
+ bool finded = newFileInfo.Find(tpi->FilePath);
+
+ if (!needCheckTimestamp || !finded || !tpi->WasChanged(newFileInfo))
+ {
+ DEBUG_PRINT("Delete Temp file");
+ tpi->DeleteDirAndFile();
+ }
+ }
+
+ return 0;
+}
+
+
+/*
+#if defined(_WIN32) && !defined(UNDER_CE)
+static const FChar * const k_ZoneId_StreamName = FTEXT(":Zone.Identifier");
+#endif
+
+
+#ifndef UNDER_CE
+
+static void ReadZoneFile(CFSTR fileName, CByteBuffer &buf)
+{
+ buf.Free();
+ NIO::CInFile file;
+ if (!file.Open(fileName))
+ return;
+ UInt64 fileSize;
+ if (!file.GetLength(fileSize))
+ return;
+ if (fileSize == 0 || fileSize >= ((UInt32)1 << 20))
+ return;
+ buf.Alloc((size_t)fileSize);
+ size_t processed;
+ if (file.ReadFull(buf, (size_t)fileSize, processed) && processed == fileSize)
+ return;
+ buf.Free();
+}
+
+static bool WriteZoneFile(CFSTR fileName, const CByteBuffer &buf)
+{
+ NIO::COutFile file;
+ if (!file.Create(fileName, true))
+ return false;
+ UInt32 processed;
+ if (!file.Write(buf, (UInt32)buf.Size(), processed))
+ return false;
+ return processed == buf.Size();
+}
+
+#endif
+*/
+
+/*
+Z7_CLASS_IMP_COM_1(
+ CBufSeqOutStream_WithFile
+ , ISequentialOutStream
+)
+ Byte *_buffer;
+ size_t _size;
+ size_t _pos;
+
+ size_t _fileWritePos;
+ bool fileMode;
+public:
+
+ bool IsStreamInMem() const { return !fileMode; }
+ size_t GetMemStreamWrittenSize() const { return _pos; }
+
+ // ISequentialOutStream *FileStream;
+ FString FilePath;
+ COutFileStream *outFileStreamSpec;
+ CMyComPtr<ISequentialOutStream> outFileStream;
+
+ CBufSeqOutStream_WithFile(): outFileStreamSpec(NULL) {}
+
+ void Init(Byte *buffer, size_t size)
+ {
+ fileMode = false;
+ _buffer = buffer;
+ _pos = 0;
+ _size = size;
+ _fileWritePos = 0;
+ }
+
+ HRESULT FlushToFile();
+ size_t GetPos() const { return _pos; }
+};
+
+static const UInt32 kBlockSize = ((UInt32)1 << 31);
+
+STDMETHODIMP CBufSeqOutStream_WithFile::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+ if (processedSize)
+ *processedSize = 0;
+ if (!fileMode)
+ {
+ if (_size - _pos >= size)
+ {
+ if (size != 0)
+ {
+ memcpy(_buffer + _pos, data, size);
+ _pos += size;
+ }
+ if (processedSize)
+ *processedSize = (UInt32)size;
+ return S_OK;
+ }
+
+ fileMode = true;
+ }
+ RINOK(FlushToFile());
+ return outFileStream->Write(data, size, processedSize);
+}
+
+HRESULT CBufSeqOutStream_WithFile::FlushToFile()
+{
+ if (!outFileStream)
+ {
+ outFileStreamSpec = new COutFileStream;
+ outFileStream = outFileStreamSpec;
+ if (!outFileStreamSpec->Create(FilePath, false))
+ {
+ outFileStream.Release();
+ return E_FAIL;
+ // MessageBoxMyError(UString("Can't create file ") + fs2us(tempFilePath));
+ }
+ }
+ while (_fileWritePos != _pos)
+ {
+ size_t cur = _pos - _fileWritePos;
+ UInt32 curSize = (cur < kBlockSize) ? (UInt32)cur : kBlockSize;
+ UInt32 processedSizeLoc = 0;
+ HRESULT res = outFileStream->Write(_buffer + _fileWritePos, curSize, &processedSizeLoc);
+ _fileWritePos += processedSizeLoc;
+ RINOK(res);
+ if (processedSizeLoc == 0)
+ return E_FAIL;
+ }
+ return S_OK;
+}
+*/
+
+/*
+static HRESULT GetTime(IFolderFolder *folder, UInt32 index, PROPID propID, FILETIME &filetime, bool &filetimeIsDefined)
+{
+ filetimeIsDefined = false;
+ NCOM::CPropVariant prop;
+ RINOK(folder->GetProperty(index, propID, &prop));
+ if (prop.vt == VT_FILETIME)
+ {
+ filetime = prop.filetime;
+ filetimeIsDefined = (filetime.dwHighDateTime != 0 || filetime.dwLowDateTime != 0);
+ }
+ else if (prop.vt != VT_EMPTY)
+ return E_FAIL;
+ return S_OK;
+}
+*/
+
+
+/*
+tryInternal tryExternal
+ false false : unused
+ false true : external
+ true false : internal
+ true true : smart based on file extension:
+ !alwaysStart(name) : both
+ alwaysStart(name) : external
+*/
+
+void CPanel::OpenItemInArchive(unsigned index, bool tryInternal, bool tryExternal, bool editMode, bool useEditor, const wchar_t *type)
+{
+ // we don't want to change hash data here
+ if (IsHashFolder())
+ return;
+
+ const UString name = GetItemName(index);
+ const UString relPath = GetItemRelPath(index);
+
+ if (tryExternal)
+ if (IsVirus_Message(name))
+ return;
+
+ if (!_folderOperations)
+ {
+ MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ bool tryAsArchive = tryInternal && (!tryExternal || !DoItemAlwaysStart(name));
+
+ const UString fullVirtPath = _currentFolderPrefix + relPath;
+
+ CTempDir tempDirectory;
+ if (!tempDirectory.Create(kTempDirPrefix))
+ {
+ MessageBox_LastError();
+ return;
+ }
+
+ FString tempDir = tempDirectory.GetPath();
+ FString tempDirNorm = tempDir;
+ NName::NormalizeDirPathPrefix(tempDirNorm);
+ const FString tempFilePath = tempDirNorm + us2fs(Get_Correct_FsFile_Name(name));
+
+ CTempFileInfo tempFileInfo;
+ tempFileInfo.FileIndex = index;
+ tempFileInfo.RelPath = relPath;
+ tempFileInfo.FolderPath = tempDir;
+ tempFileInfo.FilePath = tempFilePath;
+ tempFileInfo.NeedDelete = true;
+
+ if (tryAsArchive)
+ {
+ CMyComPtr<IInArchiveGetStream> getStream;
+ _folder.QueryInterface(IID_IInArchiveGetStream, &getStream);
+ if (getStream)
+ {
+ CMyComPtr<ISequentialInStream> subSeqStream;
+ getStream->GetStream(index, &subSeqStream);
+ if (subSeqStream)
+ {
+ CMyComPtr<IInStream> subStream;
+ subSeqStream.QueryInterface(IID_IInStream, &subStream);
+ if (subStream)
+ {
+ HRESULT res = OpenAsArc_Msg(subStream, tempFileInfo, fullVirtPath, type ? type : L""
+ // , true // showErrorMessage
+ );
+ if (res == S_OK)
+ {
+ tempDirectory.DisableDeleting();
+ RefreshListCtrl();
+ return;
+ }
+ if (res == E_ABORT || res != S_FALSE)
+ return;
+ if (!tryExternal)
+ return;
+ tryAsArchive = false;
+ }
+ }
+ }
+ }
+
+
+ CRecordVector<UInt32> indices;
+ indices.Add(index);
+
+ UStringVector messages;
+
+ bool usePassword = false;
+ UString password;
+ if (_parentFolders.Size() > 0)
+ {
+ const CFolderLink &fl = _parentFolders.Back();
+ usePassword = fl.UsePassword;
+ password = fl.Password;
+ }
+
+ /*
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ CByteBuffer zoneBuf;
+ #ifndef _UNICODE
+ if (g_IsNT)
+ #endif
+ if (_parentFolders.Size() > 0)
+ {
+ const CFolderLink &fl = _parentFolders.Front();
+ if (!fl.IsVirtual && !fl.FilePath.IsEmpty())
+ ReadZoneFile(fl.FilePath + k_ZoneId_StreamName, zoneBuf);
+ }
+ #endif
+ */
+
+
+ CVirtFileSystem *virtFileSystemSpec = NULL;
+ CMyComPtr<ISequentialOutStream> virtFileSystem;
+
+ const bool isAltStream = IsItem_AltStream(index);
+
+ CCopyToOptions options;
+ options.includeAltStreams = true;
+ options.replaceAltStreamChars = isAltStream;
+ {
+ // CContextMenuInfo ci;
+ // ci.Load();
+ // if (ci.WriteZone != (UInt32)(Int32)-1)
+ // we use kAll when we unpack just one file.
+ options.ZoneIdMode = NExtract::NZoneIdMode::kAll;
+ options.NeedRegistryZone = false;
+ }
+
+ if (tryAsArchive)
+ {
+ NCOM::CPropVariant prop;
+ _folder->GetProperty(index, kpidSize, &prop);
+ UInt64 fileLimit = 1 << 22;
+ if (g_RAM_Size_Defined)
+ fileLimit = g_RAM_Size / 4;
+
+ UInt64 fileSize = 0;
+ if (!ConvertPropVariantToUInt64(prop, fileSize))
+ fileSize = fileLimit;
+ if (fileSize <= fileLimit && fileSize > 0)
+ {
+ options.streamMode = true;
+ virtFileSystemSpec = new CVirtFileSystem;
+ virtFileSystem = virtFileSystemSpec;
+ // we allow additional total size for small alt streams;
+ virtFileSystemSpec->MaxTotalAllocSize = fileSize + (1 << 10);
+
+ virtFileSystemSpec->DirPrefix = tempDirNorm;
+ virtFileSystemSpec->Init();
+ options.VirtFileSystem = virtFileSystem;
+ options.VirtFileSystemSpec = virtFileSystemSpec;
+ }
+ }
+
+ options.folder = fs2us(tempDirNorm);
+ options.showErrorMessages = true;
+
+ const HRESULT result = CopyTo(options, indices, &messages, usePassword, password);
+
+ if (_parentFolders.Size() > 0)
+ {
+ CFolderLink &fl = _parentFolders.Back();
+ fl.UsePassword = usePassword;
+ fl.Password = password;
+ }
+
+ if (!messages.IsEmpty())
+ return;
+ if (result != S_OK)
+ {
+ if (result != E_ABORT)
+ MessageBox_Error_HRESULT(result);
+ return;
+ }
+
+ if (options.VirtFileSystem)
+ {
+ if (virtFileSystemSpec->IsStreamInMem())
+ {
+ const CVirtFile &file = virtFileSystemSpec->Files[0];
+
+ size_t streamSize = (size_t)file.Size;
+ CBufInStream *bufInStreamSpec = new CBufInStream;
+ CMyComPtr<IInStream> bufInStream = bufInStreamSpec;
+ bufInStreamSpec->Init(file.Data, streamSize, virtFileSystem);
+
+ HRESULT res = OpenAsArc_Msg(bufInStream, tempFileInfo, fullVirtPath, type ? type : L""
+ // , encrypted
+ // , true // showErrorMessage
+ );
+
+ if (res == S_OK)
+ {
+ tempDirectory.DisableDeleting();
+ RefreshListCtrl();
+ return;
+ }
+
+ if (res == E_ABORT || res != S_FALSE)
+ return;
+ if (!tryExternal)
+ return;
+
+ tryAsArchive = false;
+ if (virtFileSystemSpec->FlushToDisk(true) != S_OK)
+ return;
+ }
+ }
+
+
+ /*
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (zoneBuf.Size() != 0)
+ {
+ if (NFind::DoesFileExist_Raw(tempFilePath))
+ {
+ WriteZoneFile(tempFilePath + k_ZoneId_StreamName, zoneBuf);
+ }
+ }
+ #endif
+ */
+
+
+ if (tryAsArchive)
+ {
+ HRESULT res = OpenAsArc_Msg(NULL, tempFileInfo, fullVirtPath, type ? type : L""
+ // , encrypted
+ // , true // showErrorMessage
+ );
+ if (res == S_OK)
+ {
+ tempDirectory.DisableDeleting();
+ RefreshListCtrl();
+ return;
+ }
+ if (res == E_ABORT || res != S_FALSE)
+ return;
+ }
+
+ if (!tryExternal)
+ return;
+
+ CMyAutoPtr<CTmpProcessInfo> tmpProcessInfoPtr(new CTmpProcessInfo());
+ CTmpProcessInfo *tpi = tmpProcessInfoPtr.get();
+ tpi->FolderPath = tempDir;
+ tpi->FilePath = tempFilePath;
+ tpi->NeedDelete = true;
+ tpi->UsePassword = usePassword;
+ tpi->Password = password;
+ tpi->ReadOnly = IsThereReadOnlyFolder();
+ if (IsHashFolder())
+ tpi->ReadOnly = true;
+
+ if (!tpi->FileInfo.Find(tempFilePath))
+ return;
+
+ CTmpProcessInfoRelease tmpProcessInfoRelease(*tpi);
+
+ CProcess process;
+ HRESULT res;
+ if (editMode)
+ res = StartEditApplication(fs2us(tempFilePath), useEditor, (HWND)*this, process);
+ else
+ res = StartApplication(fs2us(tempDirNorm), fs2us(tempFilePath), (HWND)*this, process);
+
+ if ((HANDLE)process == NULL)
+ {
+ // win7 / win10 work so for some extensions (pdf, html ..);
+ DEBUG_PRINT("#### (HANDLE)process == 0");
+ // return;
+ if (res != S_OK)
+ return;
+ }
+
+ tpi->Window = (HWND)(*this);
+ tpi->FullPathFolderPrefix = _currentFolderPrefix;
+ tpi->FileIndex = index;
+ tpi->RelPath = relPath;
+
+ if ((HANDLE)process)
+ tpi->Processes.SetMainProcess(process.Detach());
+
+ ::CThread th;
+ if (Thread_Create(&th, MyThreadFunction, tpi) != 0)
+ throw 271824;
+ g_ExitEventLauncher._threads.Add(th);
+ g_ExitEventLauncher._numActiveThreads++;
+
+ tempDirectory.DisableDeleting();
+ tmpProcessInfoPtr.release();
+ tmpProcessInfoRelease._needDelete = false;
+}
+
+
+/*
+static const UINT64 kTimeLimit = UINT64(10000000) * 3600 * 24;
+
+static bool CheckDeleteItem(UINT64 currentFileTime, UINT64 folderFileTime)
+{
+ return (currentFileTime - folderFileTime > kTimeLimit &&
+ folderFileTime - currentFileTime > kTimeLimit);
+}
+
+void DeleteOldTempFiles()
+{
+ UString tempPath;
+ if (!MyGetTempPath(tempPath))
+ throw 1;
+
+ UINT64 currentFileTime;
+ NTime::GetCurUtcFileTime(currentFileTime);
+ UString searchWildCard = tempPath + kTempDirPrefix + L"*.tmp";
+ searchWildCard += WCHAR(NName::kAnyStringWildcard);
+ NFind::CEnumeratorW enumerator(searchWildCard);
+ NFind::CFileInfo fileInfo;
+ while (enumerator.Next(fileInfo))
+ {
+ if (!fileInfo.IsDir())
+ continue;
+ const UINT64 &cTime = *(const UINT64 *)(&fileInfo.CTime);
+ if (CheckDeleteItem(cTime, currentFileTime))
+ RemoveDirectoryWithSubItems(tempPath + fileInfo.Name);
+ }
+}
+*/
diff --git a/CPP/7zip/UI/FileManager/PanelItems.cpp b/CPP/7zip/UI/FileManager/PanelItems.cpp
new file mode 100644
index 0000000..0cb33d8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelItems.cpp
@@ -0,0 +1,1391 @@
+// PanelItems.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/Sort.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../PropID.h"
+
+#include "../Common/ExtractingFilePath.h"
+
+#include "resource.h"
+
+#include "LangUtils.h"
+#include "Panel.h"
+#include "PropertyName.h"
+#include "RootFolder.h"
+
+using namespace NWindows;
+
+static bool GetColumnVisible(PROPID propID, bool isFsFolder)
+{
+ if (isFsFolder)
+ {
+ switch (propID)
+ {
+ case kpidATime:
+ case kpidChangeTime:
+ case kpidAttrib:
+ case kpidPackSize:
+ case kpidINode:
+ case kpidLinks:
+ case kpidNtReparse:
+ return false;
+ }
+ }
+ return true;
+}
+
+static unsigned GetColumnWidth(PROPID propID, VARTYPE /* varType */)
+{
+ switch (propID)
+ {
+ case kpidName: return 160;
+ }
+ return 100;
+}
+
+static int GetColumnAlign(PROPID propID, VARTYPE varType)
+{
+ switch (propID)
+ {
+ case kpidCTime:
+ case kpidATime:
+ case kpidMTime:
+ case kpidChangeTime:
+ return LVCFMT_LEFT;
+ }
+
+ switch (varType)
+ {
+ case VT_UI1:
+ case VT_I2:
+ case VT_UI2:
+ case VT_I4:
+ case VT_INT:
+ case VT_UI4:
+ case VT_UINT:
+ case VT_I8:
+ case VT_UI8:
+ case VT_BOOL:
+ return LVCFMT_RIGHT;
+
+ case VT_EMPTY:
+ case VT_I1:
+ case VT_FILETIME:
+ case VT_BSTR:
+ return LVCFMT_LEFT;
+
+ default:
+ return LVCFMT_CENTER;
+ }
+}
+
+
+static int ItemProperty_Compare_NameFirst(void *const *a1, void *const *a2, void * /* param */)
+{
+ return (*(*((const CPropColumn *const *)a1))).Compare_NameFirst(*(*((const CPropColumn *const *)a2)));
+}
+
+HRESULT CPanel::InitColumns()
+{
+ SaveListViewInfo();
+
+ // DeleteListItems();
+ _selectedStatusVector.Clear();
+
+ {
+ // ReadListViewInfo();
+ const UString oldType = _typeIDString;
+ _typeIDString = GetFolderTypeID();
+ // an empty _typeIDString is allowed.
+
+ // we read registry only for new FolderTypeID
+ if (!_needSaveInfo || _typeIDString != oldType)
+ _listViewInfo.Read(_typeIDString);
+
+ // folders with same FolderTypeID can have different columns
+ // so we still read columns for that case.
+ // if (_needSaveInfo && _typeIDString == oldType) return S_OK;
+ }
+
+ // PROPID sortID;
+ /*
+ if (_listViewInfo.SortIndex >= 0)
+ sortID = _listViewInfo.Columns[_listViewInfo.SortIndex].PropID;
+ */
+ // sortID = _listViewInfo.SortID;
+
+ _ascending = _listViewInfo.Ascending;
+
+ _columns.Clear();
+
+ bool isFsFolder = IsFSFolder() || IsAltStreamsFolder();
+
+ {
+ UInt32 numProps;
+ _folder->GetNumberOfProperties(&numProps);
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE varType;
+ HRESULT res = _folder->GetPropertyInfo(i, &name, &propID, &varType);
+
+ if (res != S_OK)
+ {
+ /* We can return ERROR, but in that case, other code will not be called,
+ and user can see empty window without error message. So we just ignore that field */
+ continue;
+ }
+ if (propID == kpidIsDir)
+ continue;
+ CPropColumn prop;
+ prop.Type = varType;
+ prop.ID = propID;
+ prop.Name = GetNameOfProperty(propID, name);
+ prop.Order = -1;
+ prop.IsVisible = GetColumnVisible(propID, isFsFolder);
+ prop.Width = GetColumnWidth(propID, varType);
+ prop.IsRawProp = false;
+ _columns.Add(prop);
+ }
+
+ /*
+ {
+ // debug column
+ CPropColumn prop;
+ prop.Type = VT_BSTR;
+ prop.ID = 2000;
+ prop.Name = "Debug";
+ prop.Order = -1;
+ prop.IsVisible = true;
+ prop.Width = 300;
+ prop.IsRawProp = false;
+ _columns.Add(prop);
+ }
+ */
+ }
+
+ if (_folderRawProps)
+ {
+ UInt32 numProps;
+ _folderRawProps->GetNumRawProps(&numProps);
+
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ HRESULT res = _folderRawProps->GetRawPropInfo(i, &name, &propID);
+ if (res != S_OK)
+ continue;
+ CPropColumn prop;
+ prop.Type = VT_EMPTY;
+ prop.ID = propID;
+ prop.Name = GetNameOfProperty(propID, name);
+ prop.Order = -1;
+ prop.IsVisible = GetColumnVisible(propID, isFsFolder);
+ prop.Width = GetColumnWidth(propID, VT_BSTR);
+ prop.IsRawProp = true;
+ _columns.Add(prop);
+ }
+ }
+
+ unsigned order = 0;
+ unsigned i;
+
+ for (i = 0; i < _listViewInfo.Columns.Size(); i++)
+ {
+ const CColumnInfo &columnInfo = _listViewInfo.Columns[i];
+ const int index = _columns.FindItem_for_PropID(columnInfo.PropID);
+ if (index >= 0)
+ {
+ CPropColumn &item = _columns[index];
+ if (item.Order >= 0)
+ continue; // we ignore duplicated items
+ bool isVisible = columnInfo.IsVisible;
+ // we enable kpidName, if it was disabled by some incorrect code
+ if (columnInfo.PropID == kpidName)
+ isVisible = true;
+ item.IsVisible = isVisible;
+ item.Width = columnInfo.Width;
+ if (isVisible)
+ item.Order = (int)(order++);
+ continue;
+ }
+ }
+
+ for (i = 0; i < _columns.Size(); i++)
+ {
+ CPropColumn &item = _columns[i];
+ if (item.IsVisible && item.Order < 0)
+ item.Order = (int)(order++);
+ }
+
+ for (i = 0; i < _columns.Size(); i++)
+ {
+ CPropColumn &item = _columns[i];
+ if (item.Order < 0)
+ item.Order = (int)(order++);
+ }
+
+ CPropColumns newColumns;
+
+ for (i = 0; i < _columns.Size(); i++)
+ {
+ const CPropColumn &prop = _columns[i];
+ if (prop.IsVisible)
+ newColumns.Add(prop);
+ }
+
+
+ /*
+ _sortIndex = 0;
+ if (_listViewInfo.SortIndex >= 0)
+ {
+ int sortIndex = _columns.FindItem_for_PropID(sortID);
+ if (sortIndex >= 0)
+ _sortIndex = sortIndex;
+ }
+ */
+
+ if (_listViewInfo.IsLoaded)
+ _sortID = _listViewInfo.SortID;
+ else
+ {
+ _sortID = 0;
+ if (IsFSFolder() || IsAltStreamsFolder() || IsArcFolder())
+ _sortID = kpidName;
+ }
+
+ /* There are restrictions in ListView control:
+ 1) main column (kpidName) must have (LV_COLUMNW::iSubItem = 0)
+ So we need special sorting for columns.
+ 2) when we add new column, LV_COLUMNW::iOrder cannot be larger than already inserted columns)
+ So we set column order after all columns are added.
+ */
+ newColumns.Sort(ItemProperty_Compare_NameFirst, NULL);
+
+ if (newColumns.IsEqualTo(_visibleColumns))
+ return S_OK;
+
+ CIntArr columns(newColumns.Size());
+ for (i = 0; i < newColumns.Size(); i++)
+ columns[i] = -1;
+
+ bool orderError = false;
+
+ for (i = 0; i < newColumns.Size(); i++)
+ {
+ const CPropColumn &prop = newColumns[i];
+ if (prop.Order < (int)newColumns.Size() && columns[prop.Order] == -1)
+ columns[prop.Order] = (int)i;
+ else
+ orderError = true;
+ }
+
+ for (;;)
+ {
+ const unsigned numColumns = _visibleColumns.Size();
+ if (numColumns == 0)
+ break;
+ DeleteColumn(numColumns - 1);
+ }
+
+ for (i = 0; i < newColumns.Size(); i++)
+ AddColumn(newColumns[i]);
+
+ // columns[0], columns[1], .... should be displayed from left to right:
+ if (!orderError)
+ _listView.SetColumnOrderArray(_visibleColumns.Size(), columns);
+
+ _needSaveInfo = true;
+
+ return S_OK;
+}
+
+
+void CPanel::DeleteColumn(unsigned index)
+{
+ _visibleColumns.Delete(index);
+ _listView.DeleteColumn(index);
+}
+
+void CPanel::AddColumn(const CPropColumn &prop)
+{
+ const unsigned index = _visibleColumns.Size();
+
+ LV_COLUMNW column;
+ column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM | LVCF_ORDER;
+ column.cx = (int)prop.Width;
+ column.fmt = GetColumnAlign(prop.ID, prop.Type);
+ column.iOrder = (int)index; // must be <= _listView.ItemCount
+ column.iSubItem = (int)index; // must be <= _listView.ItemCount
+ column.pszText = const_cast<wchar_t *>((const wchar_t *)prop.Name);
+
+ _visibleColumns.Add(prop);
+ _listView.InsertColumn(index, &column);
+}
+
+
+HRESULT CPanel::RefreshListCtrl()
+{
+ CSelectedState state;
+ return RefreshListCtrl(state);
+}
+
+int CALLBACK CompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData);
+
+
+void CPanel::GetSelectedNames(UStringVector &selectedNames)
+{
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Selected(indices);
+ selectedNames.ClearAndReserve(indices.Size());
+ FOR_VECTOR (i, indices)
+ selectedNames.AddInReserved(GetItemRelPath(indices[i]));
+
+ /*
+ for (int i = 0; i < _listView.GetItemCount(); i++)
+ {
+ const int kSize = 1024;
+ WCHAR name[kSize + 1];
+ LVITEMW item;
+ item.iItem = i;
+ item.pszText = name;
+ item.cchTextMax = kSize;
+ item.iSubItem = 0;
+ item.mask = LVIF_TEXT | LVIF_PARAM;
+ if (!_listView.GetItem(&item))
+ continue;
+ const unsigned realIndex = GetRealIndex(item);
+ if (realIndex == kParentIndex)
+ continue;
+ if (_selectedStatusVector[realIndex])
+ selectedNames.Add(item.pszText);
+ }
+ */
+ selectedNames.Sort();
+}
+
+void CPanel::SaveSelectedState(CSelectedState &s)
+{
+ s.FocusedName_Defined = false;
+ s.FocusedName.Empty();
+ s.SelectFocused = true; // false;
+ s.SelectedNames.Clear();
+ s.FocusedItem = _listView.GetFocusedItem();
+ {
+ if (s.FocusedItem >= 0)
+ {
+ const unsigned realIndex = GetRealItemIndex(s.FocusedItem);
+ if (realIndex != kParentIndex)
+ {
+ s.FocusedName = GetItemRelPath(realIndex);
+ s.FocusedName_Defined = true;
+
+ s.SelectFocused = _listView.IsItemSelected(s.FocusedItem);
+
+ /*
+ const int kSize = 1024;
+ WCHAR name[kSize + 1];
+ LVITEMW item;
+ item.iItem = focusedItem;
+ item.pszText = name;
+ item.cchTextMax = kSize;
+ item.iSubItem = 0;
+ item.mask = LVIF_TEXT;
+ if (_listView.GetItem(&item))
+ focusedName = item.pszText;
+ */
+ }
+ }
+ }
+ GetSelectedNames(s.SelectedNames);
+}
+
+/*
+HRESULT CPanel::RefreshListCtrl(const CSelectedState &s)
+{
+ bool selectFocused = s.SelectFocused;
+ if (_mySelectMode)
+ selectFocused = true;
+ return RefreshListCtrl2(
+ s.FocusedItem >= 0, // allowEmptyFocusedName
+ s.FocusedName, s.FocusedItem, selectFocused, s.SelectedNames);
+}
+*/
+
+HRESULT CPanel::RefreshListCtrl_SaveFocused(bool onTimer)
+{
+ CSelectedState state;
+ SaveSelectedState(state);
+ state.CalledFromTimer = onTimer;
+ return RefreshListCtrl(state);
+}
+
+void CPanel::SetFocusedSelectedItem(int index, bool select)
+{
+ UINT state = LVIS_FOCUSED;
+ if (select)
+ state |= LVIS_SELECTED;
+ _listView.SetItemState(index, state, state);
+ if (!_mySelectMode && select)
+ {
+ const unsigned realIndex = GetRealItemIndex(index);
+ if (realIndex != kParentIndex)
+ _selectedStatusVector[realIndex] = true;
+ }
+}
+
+// #define PRINT_STAT
+
+#ifdef PRINT_STAT
+ void Print_OnNotify(const char *name);
+#else
+ #define Print_OnNotify(x)
+#endif
+
+
+
+/*
+
+extern UInt32 g_NumGroups;
+extern DWORD g_start_tick;
+extern DWORD g_prev_tick;
+extern DWORD g_Num_SetItemText;
+extern UInt32 g_NumMessages;
+*/
+
+HRESULT CPanel::RefreshListCtrl(const CSelectedState &state)
+{
+ m_DropHighlighted_SelectionIndex = -1;
+ m_DropHighlighted_SubFolderName.Empty();
+
+ if (!_folder)
+ return S_OK;
+
+ /*
+ g_start_tick = GetTickCount();
+ g_Num_SetItemText = 0;
+ g_NumMessages = 0;
+ */
+
+ _dontShowMode = false;
+ if (!state.CalledFromTimer)
+ LoadFullPathAndShow();
+ // OutputDebugStringA("=======\n");
+ // OutputDebugStringA("s1 \n");
+ CDisableTimerProcessing timerProcessing(*this);
+ CDisableNotify disableNotify(*this);
+
+ int focusedPos = state.FocusedItem;
+ if (focusedPos < 0)
+ focusedPos = 0;
+
+ _listView.SetRedraw(false);
+ // m_RedrawEnabled = false;
+
+ LVITEMW item;
+ ZeroMemory(&item, sizeof(item));
+
+ // DWORD tickCount0 = GetTickCount();
+
+ // _enableItemChangeNotify = false;
+ DeleteListItems();
+ _enableItemChangeNotify = true;
+
+ int listViewItemCount = 0;
+
+ _selectedStatusVector.Clear();
+ // _realIndices.Clear();
+ _startGroupSelect = 0;
+
+ _selectionIsDefined = false;
+
+ // m_Files.Clear();
+
+ /*
+ if (!_folder)
+ {
+ // throw 1;
+ SetToRootFolder();
+ }
+ */
+
+ _headerToolBar.EnableButton(kParentFolderID, !IsRootFolder());
+
+ {
+ CMyComPtr<IFolderSetFlatMode> folderSetFlatMode;
+ _folder.QueryInterface(IID_IFolderSetFlatMode, &folderSetFlatMode);
+ if (folderSetFlatMode)
+ folderSetFlatMode->SetFlatMode(BoolToInt(_flatMode));
+ }
+
+ /*
+ {
+ CMyComPtr<IFolderSetShowNtfsStreamsMode> setShow;
+ _folder.QueryInterface(IID_IFolderSetShowNtfsStreamsMode, &setShow);
+ if (setShow)
+ setShow->SetShowNtfsStreamsMode(BoolToInt(_showNtfsStrems_Mode));
+ }
+ */
+
+ _isDirVector.Clear();
+ // DWORD tickCount1 = GetTickCount();
+ IFolderFolder *folder = _folder;
+ RINOK(_folder->LoadItems())
+ // DWORD tickCount2 = GetTickCount();
+ // OutputDebugString(TEXT("Start Dir\n"));
+ RINOK(InitColumns())
+
+ UInt32 numItems;
+ _folder->GetNumberOfItems(&numItems);
+ {
+ NCOM::CPropVariant prop;
+ _isDirVector.ClearAndSetSize(numItems);
+ bool *vec = (bool *)&_isDirVector.Front();
+ HRESULT hres = S_OK;
+ unsigned i;
+ for (i = 0; i < numItems; i++)
+ {
+ hres = folder->GetProperty(i, kpidIsDir, &prop);
+ if (hres != S_OK)
+ break;
+ bool v = false;
+ if (prop.vt == VT_BOOL)
+ v = VARIANT_BOOLToBool(prop.boolVal);
+ else if (prop.vt != VT_EMPTY)
+ break;
+ vec[i] = v;
+ }
+ if (i != numItems)
+ {
+ _isDirVector.Clear();
+ if (hres == S_OK)
+ hres = E_FAIL;
+ }
+ RINOK(hres)
+ }
+
+ const bool showDots = _showDots && !IsRootFolder();
+
+ _listView.SetItemCount(numItems + (showDots ? 1 : 0));
+
+ _selectedStatusVector.ClearAndReserve(numItems);
+ int cursorIndex = -1;
+
+ CMyComPtr<IFolderGetSystemIconIndex> folderGetSystemIconIndex;
+ if (!Is_Slow_Icon_Folder() || _showRealFileIcons)
+ _folder.QueryInterface(IID_IFolderGetSystemIconIndex, &folderGetSystemIconIndex);
+
+ if (!IsFSFolder())
+ {
+ CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+ _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+ _thereAreDeletedItems = false;
+ if (getFolderArcProps)
+ {
+ CMyComPtr<IFolderArcProps> arcProps;
+ getFolderArcProps->GetFolderArcProps(&arcProps);
+ if (arcProps)
+ {
+ UInt32 numLevels;
+ if (arcProps->GetArcNumLevels(&numLevels) != S_OK)
+ numLevels = 0;
+ NCOM::CPropVariant prop;
+ if (arcProps->GetArcProp(numLevels - 1, kpidIsDeleted, &prop) == S_OK)
+ if (prop.vt == VT_BOOL && VARIANT_BOOLToBool(prop.boolVal))
+ _thereAreDeletedItems = true;
+ }
+ }
+ }
+
+ _thereAre_ListView_Items = true;
+
+ // OutputDebugStringA("\n\n");
+
+ Print_OnNotify("===== Before Load");
+
+ // #define USE_EMBED_ITEM
+
+ if (showDots)
+ {
+ const UString itemName ("..");
+ item.iItem = listViewItemCount;
+ if (itemName == state.FocusedName)
+ cursorIndex = listViewItemCount;
+ item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+ int subItem = 0;
+ item.iSubItem = subItem++;
+ item.lParam = (LPARAM)(int)kParentIndex;
+ #ifdef USE_EMBED_ITEM
+ item.pszText = const_cast<wchar_t *>((const wchar_t *)itemName);
+ #else
+ item.pszText = LPSTR_TEXTCALLBACKW;
+ #endif
+ const UInt32 attrib = FILE_ATTRIBUTE_DIRECTORY;
+ item.iImage = _extToIconMap.GetIconIndex(attrib, itemName);
+ if (item.iImage < 0)
+ item.iImage = 0;
+ if (_listView.InsertItem(&item) == -1)
+ return E_FAIL;
+ listViewItemCount++;
+ }
+
+ // OutputDebugStringA("S1\n");
+
+ UString correctedName;
+ UString itemName;
+ UString relPath;
+
+ for (UInt32 i = 0; i < numItems; i++)
+ {
+ const wchar_t *name = NULL;
+ unsigned nameLen = 0;
+
+ if (_folderGetItemName)
+ _folderGetItemName->GetItemName(i, &name, &nameLen);
+ if (!name)
+ {
+ GetItemName(i, itemName);
+ name = itemName;
+ nameLen = itemName.Len();
+ }
+
+ bool selected = false;
+
+ if (state.FocusedName_Defined || !state.SelectedNames.IsEmpty())
+ {
+ relPath.Empty();
+ // relPath += GetItemPrefix(i);
+ if (_flatMode)
+ {
+ const wchar_t *prefix = NULL;
+ if (_folderGetItemName)
+ {
+ unsigned prefixLen = 0;
+ _folderGetItemName->GetItemPrefix(i, &prefix, &prefixLen);
+ if (prefix)
+ relPath = prefix;
+ }
+ if (!prefix)
+ {
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(i, kpidPrefix, &prop) != S_OK)
+ throw 2723400;
+ if (prop.vt == VT_BSTR)
+ relPath.SetFromBstr(prop.bstrVal);
+ }
+ }
+ relPath += name;
+ if (relPath == state.FocusedName)
+ cursorIndex = listViewItemCount;
+ if (state.SelectedNames.FindInSorted(relPath) != -1)
+ selected = true;
+ }
+
+ _selectedStatusVector.AddInReserved(selected);
+
+ item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+
+ if (!_mySelectMode)
+ if (selected)
+ {
+ item.mask |= LVIF_STATE;
+ item.state = LVIS_SELECTED;
+ }
+
+ int subItem = 0;
+ item.iItem = listViewItemCount;
+
+ item.iSubItem = subItem++;
+ item.lParam = (LPARAM)i;
+
+ /*
+ int finish = nameLen - 4;
+ int j;
+ for (j = 0; j < finish; j++)
+ {
+ if (name[j ] == ' ' &&
+ name[j + 1] == ' ' &&
+ name[j + 2] == ' ' &&
+ name[j + 3] == ' ' &&
+ name[j + 4] == ' ')
+ break;
+ }
+ if (j < finish)
+ {
+ correctedName.Empty();
+ correctedName = "virus";
+ int pos = 0;
+ for (;;)
+ {
+ int posNew = itemName.Find(L" ", pos);
+ if (posNew < 0)
+ {
+ correctedName += itemName.Ptr(pos);
+ break;
+ }
+ correctedName += itemName.Mid(pos, posNew - pos);
+ correctedName += " ... ";
+ pos = posNew;
+ while (itemName[++pos] == ' ');
+ }
+ item.pszText = const_cast<wchar_t *>((const wchar_t *)correctedName);
+ }
+ else
+ */
+ {
+ #ifdef USE_EMBED_ITEM
+ item.pszText = const_cast<wchar_t *>((const wchar_t *)name);
+ #else
+ item.pszText = LPSTR_TEXTCALLBACKW;
+ #endif
+ /* LPSTR_TEXTCALLBACKW works, but in some cases there are problems,
+ since we block notify handler.
+ LPSTR_TEXTCALLBACKW can be 2-3 times faster for loading in this loop. */
+ }
+
+ bool defined = false;
+
+ if (folderGetSystemIconIndex)
+ {
+ folderGetSystemIconIndex->GetSystemIconIndex(i, &item.iImage);
+ defined = (item.iImage > 0);
+ }
+
+ if (!defined)
+ {
+ UInt32 attrib = 0;
+ {
+ NCOM::CPropVariant prop;
+ RINOK(_folder->GetProperty(i, kpidAttrib, &prop))
+ if (prop.vt == VT_UI4)
+ attrib = prop.ulVal;
+ }
+ if (IsItem_Folder(i))
+ attrib |= FILE_ATTRIBUTE_DIRECTORY;
+
+ if (_currentFolderPrefix.IsEmpty())
+ {
+ int iconIndexTemp;
+ GetRealIconIndex(us2fs((UString)name) + FCHAR_PATH_SEPARATOR, attrib, iconIndexTemp);
+ item.iImage = iconIndexTemp;
+ }
+ else
+ {
+ item.iImage = _extToIconMap.GetIconIndex(attrib, name);
+ }
+ }
+
+ if (item.iImage < 0)
+ item.iImage = 0;
+
+ if (_listView.InsertItem(&item) == -1)
+ return E_FAIL;
+ listViewItemCount++;
+ }
+
+ /*
+ xp-64: there is different order when Windows calls CPanel::OnNotify for _listView modes:
+ Details : after whole code
+ List : 2 times:
+ 1) - ListView.SotRedraw()
+ 2) - after whole code
+ Small Icons :
+ Large icons : 2 times:
+ 1) - ListView.Sort()
+ 2) - after whole code (calls with reverse order of items)
+
+ So we need to allow Notify(), when windows requests names during the following code.
+ */
+
+ Print_OnNotify("after Load");
+
+ disableNotify.SetMemMode_Enable();
+ disableNotify.Restore();
+
+ if (_listView.GetItemCount() > 0 && cursorIndex >= 0)
+ SetFocusedSelectedItem(cursorIndex, state.SelectFocused);
+
+ Print_OnNotify("after SetFocusedSelectedItem");
+
+ SetSortRawStatus();
+ _listView.SortItems(CompareItems, (LPARAM)this);
+
+ Print_OnNotify("after Sort");
+
+ if (cursorIndex < 0 && _listView.GetItemCount() > 0)
+ {
+ if (focusedPos >= _listView.GetItemCount())
+ focusedPos = _listView.GetItemCount() - 1;
+ // we select item only in showDots mode.
+ SetFocusedSelectedItem(focusedPos, showDots && (focusedPos == 0));
+ }
+
+ // m_RedrawEnabled = true;
+
+ Print_OnNotify("after SetFocusedSelectedItem2");
+
+ _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+
+ // disableNotify.SetMemMode_Enable();
+ // disableNotify.Restore();
+
+ Print_OnNotify("after EnsureVisible");
+
+ _listView.SetRedraw(true);
+
+ Print_OnNotify("after SetRedraw");
+
+ _listView.InvalidateRect(NULL, true);
+
+ Print_OnNotify("after InvalidateRect");
+ /*
+ _listView.UpdateWindow();
+ */
+ Refresh_StatusBar();
+ /*
+ char s[256];
+ sprintf(s,
+ // "attribMap = %5d, extMap = %5d, "
+ "delete = %5d, load = %5d, list = %5d, sort = %5d, end = %5d",
+ // _extToIconMap._attribMap.Size(),
+ // _extToIconMap._extMap.Size(),
+ tickCount1 - tickCount0,
+ tickCount2 - tickCount1,
+ tickCount3 - tickCount2,
+ tickCount4 - tickCount3,
+ tickCount5 - tickCount4
+ );
+ sprintf(s,
+ "5 = %5d, 6 = %5d, 7 = %5d, 8 = %5d, 9 = %5d",
+ tickCount5 - tickCount4,
+ tickCount6 - tickCount5,
+ tickCount7 - tickCount6,
+ tickCount8 - tickCount7,
+ tickCount9 - tickCount8
+ );
+ OutputDebugStringA(s);
+ */
+ return S_OK;
+}
+
+
+void CPanel::Get_ItemIndices_Selected(CRecordVector<UInt32> &indices) const
+{
+ indices.Clear();
+ /*
+ int itemIndex = -1;
+ while ((itemIndex = _listView.GetNextSelectedItem(itemIndex)) != -1)
+ {
+ LPARAM param;
+ if (_listView.GetItemParam(itemIndex, param))
+ indices.Add(param);
+ }
+ HeapSort(&indices.Front(), indices.Size());
+ */
+ const bool *v = &_selectedStatusVector.Front();
+ const unsigned size = _selectedStatusVector.Size();
+ for (unsigned i = 0; i < size; i++)
+ if (v[i])
+ indices.Add(i);
+}
+
+
+void CPanel::Get_ItemIndices_Operated(CRecordVector<UInt32> &indices) const
+{
+ Get_ItemIndices_Selected(indices);
+ if (!indices.IsEmpty())
+ return;
+ if (_listView.GetSelectedCount() == 0)
+ return;
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem >= 0)
+ {
+ if (_listView.IsItemSelected(focusedItem))
+ {
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ if (realIndex != kParentIndex)
+ indices.Add(realIndex);
+ }
+ }
+}
+
+void CPanel::Get_ItemIndices_All(CRecordVector<UInt32> &indices) const
+{
+ indices.Clear();
+ UInt32 numItems;
+ if (_folder->GetNumberOfItems(&numItems) != S_OK)
+ return;
+ indices.ClearAndSetSize(numItems);
+ UInt32 *vec = (UInt32 *)&indices.Front();
+ for (UInt32 i = 0; i < numItems; i++)
+ vec[i] = i;
+}
+
+void CPanel::Get_ItemIndices_OperSmart(CRecordVector<UInt32> &indices) const
+{
+ Get_ItemIndices_Operated(indices);
+ if (indices.IsEmpty() || (indices.Size() == 1 && indices[0] == (UInt32)(Int32)-1))
+ Get_ItemIndices_All(indices);
+}
+
+/*
+void CPanel::GetOperatedListViewIndices(CRecordVector<UInt32> &indices) const
+{
+ indices.Clear();
+ int numItems = _listView.GetItemCount();
+ for (int i = 0; i < numItems; i++)
+ {
+ const unsigned realIndex = GetRealItemIndex(i);
+ if (realIndex >= 0)
+ if (_selectedStatusVector[realIndex])
+ indices.Add(i);
+ }
+ if (indices.IsEmpty())
+ {
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem >= 0)
+ indices.Add(focusedItem);
+ }
+}
+*/
+
+void CPanel::EditItem(bool useEditor)
+{
+ if (!useEditor)
+ {
+ CMyComPtr<IFolderCalcItemFullSize> calcItemFullSize;
+ _folder.QueryInterface(IID_IFolderCalcItemFullSize, &calcItemFullSize);
+ if (calcItemFullSize)
+ {
+ bool needRefresh = false;
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ FOR_VECTOR (i, indices)
+ {
+ UInt32 index = indices[i];
+ if (IsItem_Folder(index))
+ {
+ calcItemFullSize->CalcItemFullSize(index, NULL);
+ needRefresh = true;
+ }
+ }
+ if (needRefresh)
+ {
+ // _listView.RedrawItem(0);
+ // _listView.RedrawAllItems();
+ InvalidateList();
+ return;
+ }
+ }
+ }
+
+
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ if (realIndex == kParentIndex)
+ return;
+ if (!IsItem_Folder(realIndex))
+ EditItem(realIndex, useEditor);
+}
+
+void CPanel::OpenFocusedItemAsInternal(const wchar_t *type)
+{
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ if (IsItem_Folder(realIndex))
+ OpenFolder(realIndex);
+ else
+ OpenItem(realIndex, true, false, type);
+}
+
+void CPanel::OpenSelectedItems(bool tryInternal)
+{
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ if (indices.Size() > 20)
+ {
+ MessageBox_Error_LangID(IDS_TOO_MANY_ITEMS);
+ return;
+ }
+
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem >= 0)
+ {
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ if (realIndex == kParentIndex && (tryInternal || indices.Size() == 0) && _listView.IsItemSelected(focusedItem))
+ indices.Insert(0, realIndex);
+ }
+
+ bool dirIsStarted = false;
+ FOR_VECTOR (i, indices)
+ {
+ UInt32 index = indices[i];
+ // CFileInfo &aFile = m_Files[index];
+ if (IsItem_Folder(index))
+ {
+ if (!dirIsStarted)
+ {
+ if (tryInternal)
+ {
+ OpenFolder(index);
+ dirIsStarted = true;
+ break;
+ }
+ else
+ OpenFolderExternal(index);
+ }
+ }
+ else
+ OpenItem(index, (tryInternal && indices.Size() == 1), true);
+ }
+}
+
+UString CPanel::GetItemName(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return L"..";
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, kpidName, &prop) != S_OK)
+ throw 2723400;
+ if (prop.vt != VT_BSTR)
+ throw 2723401;
+ return prop.bstrVal;
+}
+
+UString CPanel::GetItemName_for_Copy(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return L"..";
+ UString s;
+ {
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, kpidOutName, &prop) == S_OK)
+ {
+ if (prop.vt == VT_BSTR)
+ s = prop.bstrVal;
+ else if (prop.vt != VT_EMPTY)
+ throw 2723401;
+ }
+ if (s.IsEmpty())
+ s = GetItemName(itemIndex);
+ }
+ return Get_Correct_FsFile_Name(s);
+}
+
+void CPanel::GetItemName(unsigned itemIndex, UString &s) const
+{
+ if (itemIndex == kParentIndex)
+ {
+ s = "..";
+ return;
+ }
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, kpidName, &prop) != S_OK)
+ throw 2723400;
+ if (prop.vt != VT_BSTR)
+ throw 2723401;
+ s.SetFromBstr(prop.bstrVal);
+}
+
+UString CPanel::GetItemPrefix(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return UString();
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, kpidPrefix, &prop) != S_OK)
+ throw 2723400;
+ UString prefix;
+ if (prop.vt == VT_BSTR)
+ prefix.SetFromBstr(prop.bstrVal);
+ return prefix;
+}
+
+UString CPanel::GetItemRelPath(unsigned itemIndex) const
+{
+ return GetItemPrefix(itemIndex) + GetItemName(itemIndex);
+}
+
+UString CPanel::GetItemRelPath2(unsigned itemIndex) const
+{
+ UString s = GetItemRelPath(itemIndex);
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (s.Len() == 2 && NFile::NName::IsDrivePath2(s))
+ {
+ if (IsFSDrivesFolder() && !IsDeviceDrivesPrefix())
+ s.Add_PathSepar();
+ }
+ #endif
+ return s;
+}
+
+
+void CPanel::Add_ItemRelPath2_To_String(unsigned itemIndex, UString &s) const
+{
+ if (itemIndex == kParentIndex)
+ {
+ s += "..";
+ return;
+ }
+
+ const unsigned start = s.Len();
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, kpidPrefix, &prop) != S_OK)
+ throw 2723400;
+ if (prop.vt == VT_BSTR)
+ s += prop.bstrVal;
+
+ const wchar_t *name = NULL;
+ unsigned nameLen = 0;
+
+ if (_folderGetItemName)
+ _folderGetItemName->GetItemName(itemIndex, &name, &nameLen);
+ if (name)
+ s += name;
+ else
+ {
+ prop.Clear();
+ if (_folder->GetProperty(itemIndex, kpidName, &prop) != S_OK)
+ throw 2723400;
+ if (prop.vt != VT_BSTR)
+ throw 2723401;
+ s += prop.bstrVal;
+ }
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (s.Len() - start == 2 && NFile::NName::IsDrivePath2(s.Ptr(start)))
+ {
+ if (IsFSDrivesFolder() && !IsDeviceDrivesPrefix())
+ s.Add_PathSepar();
+ }
+ #endif
+}
+
+
+UString CPanel::GetItemFullPath(unsigned itemIndex) const
+{
+ return GetFsPath() + GetItemRelPath2(itemIndex);
+}
+
+bool CPanel::GetItem_BoolProp(UInt32 itemIndex, PROPID propID) const
+{
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, propID, &prop) != S_OK)
+ throw 2723400;
+ if (prop.vt == VT_BOOL)
+ return VARIANT_BOOLToBool(prop.boolVal);
+ if (prop.vt == VT_EMPTY)
+ return false;
+ throw 2723401;
+}
+
+bool CPanel::IsItem_Deleted(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return false;
+ return GetItem_BoolProp(itemIndex, kpidIsDeleted);
+}
+
+bool CPanel::IsItem_Folder(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return true;
+ if (itemIndex < _isDirVector.Size())
+ return _isDirVector[itemIndex];
+ return GetItem_BoolProp(itemIndex, kpidIsDir);
+}
+
+bool CPanel::IsItem_AltStream(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return false;
+ return GetItem_BoolProp(itemIndex, kpidIsAltStream);
+}
+
+UInt64 CPanel::GetItem_UInt64Prop(unsigned itemIndex, PROPID propID) const
+{
+ if (itemIndex == kParentIndex)
+ return 0;
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(itemIndex, propID, &prop) != S_OK)
+ throw 2723400;
+ UInt64 val = 0;
+ if (ConvertPropVariantToUInt64(prop, val))
+ return val;
+ return 0;
+}
+
+UInt64 CPanel::GetItemSize(unsigned itemIndex) const
+{
+ if (itemIndex == kParentIndex)
+ return 0;
+ if (_folderGetItemName)
+ return _folderGetItemName->GetItemSize(itemIndex);
+ return GetItem_UInt64Prop(itemIndex, kpidSize);
+}
+
+void CPanel::SaveListViewInfo()
+{
+ if (!_needSaveInfo)
+ return;
+
+ unsigned i;
+
+ for (i = 0; i < _visibleColumns.Size(); i++)
+ {
+ CPropColumn &prop = _visibleColumns[i];
+ LVCOLUMN winColumnInfo;
+ winColumnInfo.mask = LVCF_ORDER | LVCF_WIDTH;
+ if (!_listView.GetColumn(i, &winColumnInfo))
+ throw 1;
+ prop.Order = winColumnInfo.iOrder;
+ prop.Width = (UInt32)(Int32)winColumnInfo.cx;
+ }
+
+ CListViewInfo viewInfo;
+
+ // PROPID sortPropID = _columns[_sortIndex].ID;
+ PROPID sortPropID = _sortID;
+
+ // we save columns as "sorted by order" to registry
+
+ CPropColumns sortedProperties = _visibleColumns;
+
+ sortedProperties.Sort();
+
+ for (i = 0; i < sortedProperties.Size(); i++)
+ {
+ const CPropColumn &prop = sortedProperties[i];
+ CColumnInfo columnInfo;
+ columnInfo.IsVisible = prop.IsVisible;
+ columnInfo.PropID = prop.ID;
+ columnInfo.Width = prop.Width;
+ viewInfo.Columns.Add(columnInfo);
+ }
+
+ for (i = 0; i < _columns.Size(); i++)
+ {
+ const CPropColumn &prop = _columns[i];
+ if (sortedProperties.FindItem_for_PropID(prop.ID) < 0)
+ {
+ CColumnInfo columnInfo;
+ columnInfo.IsVisible = false;
+ columnInfo.PropID = prop.ID;
+ columnInfo.Width = prop.Width;
+ viewInfo.Columns.Add(columnInfo);
+ }
+ }
+
+ viewInfo.SortID = sortPropID;
+ viewInfo.Ascending = _ascending;
+ viewInfo.IsLoaded = true;
+ if (!_listViewInfo.IsEqual(viewInfo))
+ {
+ viewInfo.Save(_typeIDString);
+ _listViewInfo = viewInfo;
+ }
+}
+
+
+bool CPanel::OnRightClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActiveate, LRESULT &result)
+{
+ if (itemActiveate->hdr.hwndFrom == HWND(_listView))
+ return false;
+ POINT point;
+ ::GetCursorPos(&point);
+ ShowColumnsContextMenu(point.x, point.y);
+ result = TRUE;
+ return true;
+}
+
+void CPanel::ShowColumnsContextMenu(int x, int y)
+{
+ CMenu menu;
+ CMenuDestroyer menuDestroyer(menu);
+
+ menu.CreatePopup();
+
+ const int kCommandStart = 100;
+ FOR_VECTOR (i, _columns)
+ {
+ const CPropColumn &prop = _columns[i];
+ UINT flags = MF_STRING;
+ if (prop.IsVisible)
+ flags |= MF_CHECKED;
+ if (i == 0)
+ flags |= MF_GRAYED;
+ menu.AppendItem(flags, kCommandStart + i, prop.Name);
+ }
+
+ const int menuResult = menu.Track(TPM_LEFTALIGN | TPM_RETURNCMD | TPM_NONOTIFY, x, y, _listView);
+
+ if (menuResult >= kCommandStart && menuResult <= kCommandStart + (int)_columns.Size())
+ {
+ const unsigned index = (unsigned)(menuResult - kCommandStart);
+ CPropColumn &prop = _columns[index];
+ prop.IsVisible = !prop.IsVisible;
+
+ if (prop.IsVisible)
+ {
+ prop.Order = (int)_visibleColumns.Size();
+ AddColumn(prop);
+ }
+ else
+ {
+ const int visibleIndex = _visibleColumns.FindItem_for_PropID(prop.ID);
+ if (visibleIndex >= 0)
+ {
+ /*
+ if (_sortIndex == index)
+ {
+ _sortIndex = 0;
+ _ascending = true;
+ }
+ */
+ if (_sortID == prop.ID)
+ {
+ _sortID = kpidName;
+ _ascending = true;
+ }
+ DeleteColumn((unsigned)visibleIndex);
+ }
+ }
+ }
+}
+
+void CPanel::OnReload(bool onTimer)
+{
+ const HRESULT res = RefreshListCtrl_SaveFocused(onTimer);
+ if (res != S_OK)
+ MessageBox_Error_HRESULT(res);
+}
+
+void CPanel::OnTimer()
+{
+ if (!_processTimer)
+ return;
+ if (!AutoRefresh_Mode)
+ return;
+ CMyComPtr<IFolderWasChanged> folderWasChanged;
+ if (_folder.QueryInterface(IID_IFolderWasChanged, &folderWasChanged) != S_OK)
+ return;
+ Int32 wasChanged;
+ if (folderWasChanged->WasChanged(&wasChanged) != S_OK)
+ return;
+ if (wasChanged == 0)
+ return;
+ OnReload(true); // onTimer
+}
diff --git a/CPP/7zip/UI/FileManager/PanelKey.cpp b/CPP/7zip/UI/FileManager/PanelKey.cpp
new file mode 100644
index 0000000..a4ea489
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelKey.cpp
@@ -0,0 +1,357 @@
+// PanelKey.cpp
+
+#include "StdAfx.h"
+
+#include "Panel.h"
+#include "HelpUtils.h"
+
+#include "../../PropID.h"
+#include "App.h"
+
+using namespace NWindows;
+
+// #define kHelpTopic "FM/index.htm"
+
+struct CVKeyPropIDPair
+{
+ WORD VKey;
+ PROPID PropID;
+};
+
+static const CVKeyPropIDPair g_VKeyPropIDPairs[] =
+{
+ { VK_F3, kpidName },
+ { VK_F4, kpidExtension },
+ { VK_F5, kpidMTime },
+ { VK_F6, kpidSize },
+ { VK_F7, kpidNoProperty }
+};
+
+static int FindVKeyPropIDPair(WORD vKey)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_VKeyPropIDPairs); i++)
+ if (g_VKeyPropIDPairs[i].VKey == vKey)
+ return (int)i;
+ return -1;
+}
+
+
+bool CPanel::OnKeyDown(LPNMLVKEYDOWN keyDownInfo, LRESULT &result)
+{
+ if (keyDownInfo->wVKey == VK_TAB && keyDownInfo->hdr.hwndFrom == _listView)
+ {
+ _panelCallback->OnTab();
+ return false;
+ }
+ const bool alt = IsKeyDown(VK_MENU);
+ const bool ctrl = IsKeyDown(VK_CONTROL);
+ // const bool leftCtrl = IsKeyDown(VK_LCONTROL);
+ const bool rightCtrl = IsKeyDown(VK_RCONTROL);
+ const bool shift = IsKeyDown(VK_SHIFT);
+ result = 0;
+
+ if (keyDownInfo->wVKey >= '0' &&
+ keyDownInfo->wVKey <= '9' &&
+ (rightCtrl || alt))
+ {
+ const unsigned index = (unsigned)(keyDownInfo->wVKey - '0');
+ if (shift)
+ {
+ SetBookmark(index);
+ return true;
+ }
+ else
+ {
+ OpenBookmark(index);
+ return true;
+ }
+ }
+
+ if ((keyDownInfo->wVKey == VK_F2 ||
+ keyDownInfo->wVKey == VK_F1)
+ && alt && !ctrl && !shift)
+ {
+ _panelCallback->SetFocusToPath(keyDownInfo->wVKey == VK_F1 ? 0 : 1);
+ return true;
+ }
+
+ if ((keyDownInfo->wVKey == VK_F9) && !alt && !ctrl && !shift)
+ {
+ g_App.SwitchOnOffOnePanel();
+ }
+
+ if (keyDownInfo->wVKey >= VK_F3 && keyDownInfo->wVKey <= VK_F12 && ctrl)
+ {
+ const int index = FindVKeyPropIDPair(keyDownInfo->wVKey);
+ if (index >= 0)
+ SortItemsWithPropID(g_VKeyPropIDPairs[index].PropID);
+ }
+
+ switch (keyDownInfo->wVKey)
+ {
+ case VK_SHIFT:
+ {
+ _selectionIsDefined = false;
+ _prevFocusedItem = _listView.GetFocusedItem();
+ break;
+ }
+ /*
+ case VK_F1:
+ {
+ // ShowHelpWindow(NULL, kHelpTopic);
+ break;
+ }
+ */
+ case VK_F2:
+ {
+ if (!alt && !ctrl &&!shift)
+ {
+ RenameFile();
+ return true;
+ }
+ break;
+ }
+ case VK_F3:
+ {
+ if (!alt && !ctrl && !shift)
+ {
+ EditItem(false);
+ return true;
+ }
+ break;
+ }
+ case VK_F4:
+ {
+ if (!alt && !ctrl && !shift)
+ {
+ EditItem(true);
+ return true;
+ }
+ if (!alt && !ctrl && shift)
+ {
+ CreateFile();
+ return true;
+ }
+ break;
+ }
+ case VK_F5:
+ {
+ if (!alt && !ctrl)
+ {
+ _panelCallback->OnCopy(false, shift);
+ return true;
+ }
+ break;
+ }
+ case VK_F6:
+ {
+ if (!alt && !ctrl)
+ {
+ _panelCallback->OnCopy(true, shift);
+ return true;
+ }
+ break;
+ }
+ case VK_F7:
+ {
+ if (!alt && !ctrl && !shift)
+ {
+ /* we can process F7 via menu ACCELERATOR.
+ But menu loading can be slow in case of UNC paths and system menu.
+ So we use don't use ACCELERATOR */
+ CreateFolder();
+ return true;
+ }
+ break;
+ }
+ case VK_DELETE:
+ {
+ DeleteItems(!shift);
+ return true;
+ }
+ case VK_INSERT:
+ {
+ if (!alt)
+ {
+ if (ctrl && !shift)
+ {
+ EditCopy();
+ return true;
+ }
+ if (shift && !ctrl)
+ {
+ EditPaste();
+ return true;
+ }
+ if (!shift && !ctrl && _mySelectMode)
+ {
+ OnInsert();
+ return true;
+ }
+ }
+ return false;
+ }
+ case VK_DOWN:
+ {
+ if (shift)
+ OnArrowWithShift();
+ return false;
+ }
+ case VK_UP:
+ {
+ if (alt)
+ _panelCallback->OnSetSameFolder();
+ else if (shift)
+ OnArrowWithShift();
+ return false;
+ }
+ case VK_RIGHT:
+ {
+ if (alt)
+ _panelCallback->OnSetSubFolder();
+ else if (shift)
+ OnArrowWithShift();
+ return false;
+ }
+ case VK_LEFT:
+ {
+ if (alt)
+ _panelCallback->OnSetSubFolder();
+ else if (shift)
+ OnArrowWithShift();
+ return false;
+ }
+ case VK_NEXT:
+ {
+ if (ctrl && !alt && !shift)
+ {
+ // EnterToFocused();
+ return true;
+ }
+ break;
+ }
+ case VK_ADD:
+ {
+ if (alt)
+ SelectByType(true);
+ else if (shift)
+ SelectAll(true);
+ else if (!ctrl)
+ SelectSpec(true);
+ return true;
+ }
+ case VK_SUBTRACT:
+ {
+ if (alt)
+ SelectByType(false);
+ else if (shift)
+ SelectAll(false);
+ else
+ SelectSpec(false);
+ return true;
+ }
+ /*
+ case VK_DELETE:
+ CommandDelete();
+ return 0;
+ case VK_F1:
+ CommandHelp();
+ return 0;
+ */
+ case VK_BACK:
+ OpenParentFolder();
+ return true;
+ /*
+ case VK_DIVIDE:
+ case '\\':
+ case '/':
+ case VK_OEM_5:
+ {
+ // OpenRootFolder();
+ OpenDrivesFolder();
+
+ return true;
+ }
+ */
+ case 'A':
+ if (ctrl)
+ {
+ SelectAll(true);
+ return true;
+ }
+ return false;
+ case 'X':
+ if (ctrl)
+ {
+ EditCut();
+ return true;
+ }
+ return false;
+ case 'C':
+ if (ctrl)
+ {
+ EditCopy();
+ return true;
+ }
+ return false;
+ case 'V':
+ if (ctrl)
+ {
+ EditPaste();
+ return true;
+ }
+ return false;
+ case 'N':
+ if (ctrl)
+ {
+ CreateFile();
+ return true;
+ }
+ return false;
+ case 'R':
+ if (ctrl)
+ {
+ OnReload();
+ return true;
+ }
+ return false;
+ case 'W':
+ if (ctrl)
+ {
+ // SendMessage();
+ PostMessage(g_HWND, WM_COMMAND, IDCLOSE, 0);
+ return true;
+ }
+ return false;
+ case 'Z':
+ if (ctrl)
+ {
+ ChangeComment();
+ return true;
+ }
+ return false;
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ if (ctrl)
+ {
+ const unsigned styleIndex = (unsigned)(keyDownInfo->wVKey - '1');
+ SetListViewMode(styleIndex);
+ return true;
+ }
+ return false;
+ case VK_MULTIPLY:
+ {
+ InvertSelection();
+ return true;
+ }
+ case VK_F12:
+ if (alt && !ctrl && !shift)
+ {
+ FoldersHistory();
+ return true;
+ }
+ }
+ return false;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelListNotify.cpp b/CPP/7zip/UI/FileManager/PanelListNotify.cpp
new file mode 100644
index 0000000..2fb0e87
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelListNotify.cpp
@@ -0,0 +1,870 @@
+// PanelListNotify.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../Common/PropIDUtils.h"
+#include "../../PropID.h"
+
+#include "App.h"
+#include "Panel.h"
+#include "FormatUtils.h"
+
+using namespace NWindows;
+
+/* Unicode characters for space:
+0x009C STRING TERMINATOR
+0x00B7 Middle dot
+0x237D Shouldered open box
+0x2420 Symbol for space
+0x2422 Blank symbol
+0x2423 Open box
+*/
+
+#define SPACE_REPLACE_CHAR (wchar_t)(0x2423)
+#define SPACE_TERMINATOR_CHAR (wchar_t)(0x9C)
+
+#define INT_TO_STR_SPEC(v) \
+ while (v >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(v % 10)); v /= 10; } \
+ *s++ = (unsigned char)('0' + (unsigned)v);
+
+static void ConvertSizeToString(UInt64 val, wchar_t *s) throw()
+{
+ unsigned char temp[32];
+ unsigned i = 0;
+
+ if (val <= (UInt32)0xFFFFFFFF)
+ {
+ UInt32 val32 = (UInt32)val;
+ INT_TO_STR_SPEC(val32)
+ }
+ else
+ {
+ INT_TO_STR_SPEC(val)
+ }
+
+ if (i < 3)
+ {
+ if (i != 0)
+ {
+ *s++ = temp[(size_t)i - 1];
+ if (i == 2)
+ *s++ = temp[0];
+ }
+ *s = 0;
+ return;
+ }
+
+ unsigned r = i % 3;
+ if (r != 0)
+ {
+ s[0] = temp[--i];
+ if (r == 2)
+ s[1] = temp[--i];
+ s += r;
+ }
+
+ do
+ {
+ s[0] = ' ';
+ s[1] = temp[(size_t)i - 1];
+ s[2] = temp[(size_t)i - 2];
+ s[3] = temp[(size_t)i - 3];
+ s += 4;
+ }
+ while (i -= 3);
+
+ *s = 0;
+}
+
+UString ConvertSizeToString(UInt64 value);
+UString ConvertSizeToString(UInt64 value)
+{
+ wchar_t s[32];
+ ConvertSizeToString(value, s);
+ return s;
+}
+
+static inline unsigned GetHex_Upper(unsigned v)
+{
+ return (v < 10) ? ('0' + v) : ('A' + (v - 10));
+}
+
+static inline unsigned GetHex_Lower(unsigned v)
+{
+ return (v < 10) ? ('0' + v) : ('a' + (v - 10));
+}
+
+/*
+static void HexToString(char *dest, const Byte *data, UInt32 size)
+{
+ for (UInt32 i = 0; i < size; i++)
+ {
+ unsigned b = data[i];
+ dest[0] = GetHex((b >> 4) & 0xF);
+ dest[1] = GetHex(b & 0xF);
+ dest += 2;
+ }
+ *dest = 0;
+}
+*/
+
+bool IsSizeProp(UINT propID) throw();
+bool IsSizeProp(UINT propID) throw()
+{
+ switch (propID)
+ {
+ case kpidSize:
+ case kpidPackSize:
+ case kpidNumSubDirs:
+ case kpidNumSubFiles:
+ case kpidOffset:
+ case kpidLinks:
+ case kpidNumBlocks:
+ case kpidNumVolumes:
+ case kpidPhySize:
+ case kpidHeadersSize:
+ case kpidTotalSize:
+ case kpidFreeSpace:
+ case kpidClusterSize:
+ case kpidNumErrors:
+ case kpidNumStreams:
+ case kpidNumAltStreams:
+ case kpidAltStreamsSize:
+ case kpidVirtualSize:
+ case kpidUnpackSize:
+ case kpidTotalPhySize:
+ case kpidTailSize:
+ case kpidEmbeddedStubSize:
+ return true;
+ }
+ return false;
+}
+
+
+
+/*
+#include <stdio.h>
+
+UInt64 GetCpuTicks()
+{
+ #ifdef _WIN64
+ return __rdtsc();
+ #else
+ UInt32 lowVal, highVal;
+ __asm RDTSC;
+ __asm mov lowVal, EAX;
+ __asm mov highVal, EDX;
+ return ((UInt64)highVal << 32) | lowVal;
+ #endif
+}
+
+UInt32 g_NumGroups;
+UInt64 g_start_tick;
+UInt64 g_prev_tick;
+DWORD g_Num_SetItemText;
+UInt32 g_NumMessages;
+*/
+
+LRESULT CPanel::SetItemText(LVITEMW &item)
+{
+ if (_dontShowMode)
+ return 0;
+ UInt32 realIndex = GetRealIndex(item);
+
+ // g_Num_SetItemText++;
+
+ /*
+ if ((item.mask & LVIF_IMAGE) != 0)
+ {
+ bool defined = false;
+ CComPtr<IFolderGetSystemIconIndex> folderGetSystemIconIndex;
+ _folder.QueryInterface(&folderGetSystemIconIndex);
+ if (folderGetSystemIconIndex)
+ {
+ folderGetSystemIconIndex->GetSystemIconIndex(index, &item.iImage);
+ defined = (item.iImage > 0);
+ }
+ if (!defined)
+ {
+ NCOM::CPropVariant prop;
+ _folder->GetProperty(index, kpidAttrib, &prop);
+ UINT32 attrib = 0;
+ if (prop.vt == VT_UI4)
+ attrib = prop.ulVal;
+ else if (IsItemFolder(index))
+ attrib |= FILE_ATTRIBUTE_DIRECTORY;
+ if (_currentFolderPrefix.IsEmpty())
+ throw 1;
+ else
+ item.iImage = _extToIconMap.GetIconIndex(attrib, GetSystemString(GetItemName(index)));
+ }
+ // item.iImage = 1;
+ }
+ */
+
+ if ((item.mask & LVIF_TEXT) == 0)
+ return 0;
+
+ LPWSTR text = item.pszText;
+
+ if (item.cchTextMax > 0)
+ text[0] = 0;
+
+ if (item.cchTextMax <= 1)
+ return 0;
+
+ const CPropColumn &property = _visibleColumns[item.iSubItem];
+ PROPID propID = property.ID;
+
+ if (realIndex == kParentIndex_UInt32)
+ {
+ if (propID == kpidName)
+ {
+ if (item.cchTextMax > 2)
+ {
+ text[0] = '.';
+ text[1] = '.';
+ text[2] = 0;
+ }
+ }
+ return 0;
+ }
+
+ /*
+ // List-view in report-view in Windows 10 is slow (50+ ms) for page change.
+ // that code shows the time of page reload for items
+ // if you know how to improve the speed of list view refresh, notify 7-Zip developer
+
+ // if (propID == 2000)
+ // if (propID == kpidName)
+ {
+ // debug column;
+ // DWORD dw = GetCpuTicks();
+ UInt64 dw = GetCpuTicks();
+ UInt64 deltaLast = dw - g_prev_tick;
+ #define conv_ticks(t) ((unsigned)((t) / 100000))
+ if (deltaLast > 1000u * 1000 * 1000)
+ {
+ UInt64 deltaFull = g_prev_tick - g_start_tick;
+ char s[128];
+ sprintf(s, "%d", conv_ticks(deltaFull));
+ OutputDebugStringA(s);
+ g_start_tick = dw;
+ g_NumGroups++;
+ }
+ g_prev_tick = dw;
+ UString u;
+ char s[128];
+ UInt64 deltaFull = dw - g_start_tick;
+ // for (int i = 0; i < 100000; i++)
+ sprintf(s, "%d %d %d-%d ", g_NumMessages, g_Num_SetItemText, g_NumGroups, conv_ticks(deltaFull));
+ // sprintf(s, "%d-%d ", g_NumGroups, conv_ticks(deltaFull));
+ u = s;
+ lstrcpyW(text, u.Ptr());
+ text += u.Len();
+
+ // dw = GetCpuTicks();
+ // deltaFull = dw - g_prev_tick;
+ // sprintf(s, "-%d ", conv_ticks(deltaFull));
+ // u = s;
+ // lstrcpyW(text, u.Ptr());
+ // text += u.Len();
+
+ if (propID != kpidName)
+ return 0;
+ }
+ */
+
+
+ if (property.IsRawProp)
+ {
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+ RINOK(_folderRawProps->GetRawProp(realIndex, propID, &data, &dataSize, &propType))
+ const unsigned limit = (unsigned)item.cchTextMax - 1;
+ if (dataSize == 0)
+ {
+ text[0] = 0;
+ return 0;
+ }
+
+ if (propID == kpidNtReparse)
+ {
+ UString s;
+ ConvertNtReparseToString((const Byte *)data, dataSize, s);
+ if (!s.IsEmpty())
+ {
+ unsigned i;
+ for (i = 0; i < limit; i++)
+ {
+ wchar_t c = s[i];
+ if (c == 0)
+ break;
+ text[i] = c;
+ }
+ text[i] = 0;
+ return 0;
+ }
+ }
+ else if (propID == kpidNtSecure)
+ {
+ AString s;
+ ConvertNtSecureToString((const Byte *)data, dataSize, s);
+ if (!s.IsEmpty())
+ {
+ unsigned i;
+ for (i = 0; i < limit; i++)
+ {
+ wchar_t c = (Byte)s[i];
+ if (c == 0)
+ break;
+ text[i] = c;
+ }
+ text[i] = 0;
+ return 0;
+ }
+ }
+ {
+ const unsigned kMaxDataSize = 64;
+ if (dataSize > kMaxDataSize)
+ {
+ char temp[32];
+ MyStringCopy(temp, "data:");
+ ConvertUInt32ToString(dataSize, temp + 5);
+ unsigned i;
+ for (i = 0; i < limit; i++)
+ {
+ wchar_t c = (Byte)temp[i];
+ if (c == 0)
+ break;
+ text[i] = c;
+ }
+ text[i] = 0;
+ }
+ else
+ {
+ if (dataSize > limit)
+ dataSize = limit;
+ WCHAR *dest = text;
+ const bool needUpper = (dataSize <= 8)
+ && (propID == kpidCRC || propID == kpidChecksum);
+ for (UInt32 i = 0; i < dataSize; i++)
+ {
+ unsigned b = ((const Byte *)data)[i];
+ if (needUpper)
+ {
+ dest[0] = (WCHAR)GetHex_Upper((b >> 4) & 0xF);
+ dest[1] = (WCHAR)GetHex_Upper(b & 0xF);
+ }
+ else
+ {
+ dest[0] = (WCHAR)GetHex_Lower((b >> 4) & 0xF);
+ dest[1] = (WCHAR)GetHex_Lower(b & 0xF);
+ }
+ dest += 2;
+ }
+ *dest = 0;
+ }
+ }
+ return 0;
+ }
+ /*
+ {
+ NCOM::CPropVariant prop;
+ if (propID == kpidType)
+ string = GetFileType(index);
+ else
+ {
+ HRESULT result = m_ArchiveFolder->GetProperty(index, propID, &prop);
+ if (result != S_OK)
+ {
+ // PrintMessage("GetPropertyValue error");
+ return 0;
+ }
+ string = ConvertPropertyToString(prop, propID, false);
+ }
+ }
+ */
+ // const NFind::CFileInfo &aFileInfo = m_Files[index];
+
+ NCOM::CPropVariant prop;
+ /*
+ bool needRead = true;
+ if (propID == kpidSize)
+ {
+ CComPtr<IFolderGetItemFullSize> getItemFullSize;
+ if (_folder.QueryInterface(&getItemFullSize) == S_OK)
+ {
+ if (getItemFullSize->GetItemFullSize(index, &prop) == S_OK)
+ needRead = false;
+ }
+ }
+ if (needRead)
+ */
+
+ if (item.cchTextMax < 32)
+ return 0;
+
+ if (propID == kpidName)
+ {
+ if (_folderGetItemName)
+ {
+ const wchar_t *name = NULL;
+ unsigned nameLen = 0;
+ _folderGetItemName->GetItemName(realIndex, &name, &nameLen);
+
+ if (name)
+ {
+ unsigned dest = 0;
+ const unsigned limit = (unsigned)item.cchTextMax - 1;
+
+ for (unsigned i = 0; dest < limit;)
+ {
+ const wchar_t c = name[i++];
+ if (c == 0)
+ break;
+ text[dest++] = c;
+
+ if (c != ' ')
+ {
+ if (c != 0x202E) // RLO
+ continue;
+ text[(size_t)dest - 1] = '_';
+ continue;
+ }
+
+ if (name[i] != ' ')
+ continue;
+
+ unsigned t = 1;
+ for (; name[i + t] == ' '; t++);
+
+ if (t >= 4 && dest + 4 < limit)
+ {
+ text[dest++] = '.';
+ text[dest++] = '.';
+ text[dest++] = '.';
+ text[dest++] = ' ';
+ i += t;
+ }
+ }
+
+ if (dest == 0)
+ text[dest++]= '_';
+
+ #ifdef _WIN32
+ else if (text[(size_t)dest - 1] == ' ')
+ {
+ if (dest < limit)
+ text[dest++] = SPACE_TERMINATOR_CHAR;
+ else
+ text[dest - 1] = SPACE_REPLACE_CHAR;
+ }
+ #endif
+
+ text[dest] = 0;
+ // OutputDebugStringW(text);
+ return 0;
+ }
+ }
+ }
+
+ if (propID == kpidPrefix)
+ {
+ if (_folderGetItemName)
+ {
+ const wchar_t *name = NULL;
+ unsigned nameLen = 0;
+ _folderGetItemName->GetItemPrefix(realIndex, &name, &nameLen);
+ if (name)
+ {
+ unsigned dest = 0;
+ const unsigned limit = (unsigned)item.cchTextMax - 1;
+ for (unsigned i = 0; dest < limit;)
+ {
+ const wchar_t c = name[i++];
+ if (c == 0)
+ break;
+ text[dest++] = c;
+ }
+ text[dest] = 0;
+ return 0;
+ }
+ }
+ }
+
+ const HRESULT res = _folder->GetProperty(realIndex, propID, &prop);
+
+ if (res != S_OK)
+ {
+ MyStringCopy(text, L"Error: ");
+ // s = UString("Error: ") + HResultToMessage(res);
+ }
+ else if ((prop.vt == VT_UI8 || prop.vt == VT_UI4 || prop.vt == VT_UI2) && IsSizeProp(propID))
+ {
+ UInt64 v = 0;
+ ConvertPropVariantToUInt64(prop, v);
+ ConvertSizeToString(v, text);
+ }
+ else if (prop.vt == VT_BSTR)
+ {
+ const unsigned limit = (unsigned)item.cchTextMax - 1;
+ const wchar_t *src = prop.bstrVal;
+ unsigned i;
+ for (i = 0; i < limit; i++)
+ {
+ wchar_t c = src[i];
+ if (c == 0) break;
+ if (c == 0xA) c = ' ';
+ if (c == 0xD) c = ' ';
+ text[i] = c;
+ }
+ text[i] = 0;
+ }
+ else
+ {
+ char temp[64];
+ ConvertPropertyToShortString2(temp, prop, propID, _timestampLevel);
+ unsigned i;
+ const unsigned limit = (unsigned)item.cchTextMax - 1;
+ for (i = 0; i < limit; i++)
+ {
+ const wchar_t c = (Byte)temp[i];
+ if (c == 0)
+ break;
+ text[i] = c;
+ }
+ text[i] = 0;
+ }
+
+ return 0;
+}
+
+#ifndef UNDER_CE
+extern DWORD g_ComCtl32Version;
+#endif
+
+void CPanel::OnItemChanged(NMLISTVIEW *item)
+{
+ const unsigned index = (unsigned)item->lParam;
+ if (index == kParentIndex)
+ return;
+ const bool oldSelected = (item->uOldState & LVIS_SELECTED) != 0;
+ const bool newSelected = (item->uNewState & LVIS_SELECTED) != 0;
+ // Don't change this code. It works only with such check
+ if (oldSelected != newSelected)
+ _selectedStatusVector[index] = newSelected;
+}
+
+extern bool g_LVN_ITEMACTIVATE_Support;
+
+void CPanel::OnNotifyActivateItems()
+{
+ bool alt = IsKeyDown(VK_MENU);
+ bool ctrl = IsKeyDown(VK_CONTROL);
+ bool shift = IsKeyDown(VK_SHIFT);
+ if (!shift && alt && !ctrl)
+ Properties();
+ else
+ OpenSelectedItems(!shift || alt || ctrl);
+}
+
+bool CPanel::OnNotifyList(LPNMHDR header, LRESULT &result)
+{
+ switch (header->code)
+ {
+ case LVN_ITEMCHANGED:
+ {
+ if (_enableItemChangeNotify)
+ {
+ if (!_mySelectMode)
+ OnItemChanged((LPNMLISTVIEW)header);
+
+ // Post_Refresh_StatusBar();
+ /* 9.26: we don't call Post_Refresh_StatusBar.
+ it was very slow if we select big number of files
+ and then clead slection by selecting just new file.
+ probably it called slow Refresh_StatusBar for each item deselection.
+ I hope Refresh_StatusBar still will be called for each key / mouse action.
+ */
+ }
+ return false;
+ }
+ /*
+
+ case LVN_ODSTATECHANGED:
+ {
+ break;
+ }
+ */
+
+ case LVN_GETDISPINFOW:
+ {
+ LV_DISPINFOW *dispInfo = (LV_DISPINFOW *)header;
+
+ //is the sub-item information being requested?
+
+ if ((dispInfo->item.mask & LVIF_TEXT) != 0 ||
+ (dispInfo->item.mask & LVIF_IMAGE) != 0)
+ SetItemText(dispInfo->item);
+ {
+ // 20.03:
+ result = 0;
+ return true;
+ // old 7-Zip:
+ // return false;
+ }
+ }
+ case LVN_KEYDOWN:
+ {
+ LPNMLVKEYDOWN keyDownInfo = LPNMLVKEYDOWN(header);
+ bool boolResult = OnKeyDown(keyDownInfo, result);
+ switch (keyDownInfo->wVKey)
+ {
+ case VK_CONTROL:
+ case VK_SHIFT:
+ case VK_MENU:
+ break;
+ default:
+ Post_Refresh_StatusBar();
+ }
+ return boolResult;
+ }
+
+ case LVN_COLUMNCLICK:
+ OnColumnClick(LPNMLISTVIEW(header));
+ return false;
+
+ case LVN_ITEMACTIVATE:
+ if (g_LVN_ITEMACTIVATE_Support)
+ {
+ OnNotifyActivateItems();
+ return false;
+ }
+ break;
+ case NM_DBLCLK:
+ case NM_RETURN:
+ if (!g_LVN_ITEMACTIVATE_Support)
+ {
+ OnNotifyActivateItems();
+ return false;
+ }
+ break;
+
+ case NM_RCLICK:
+ Post_Refresh_StatusBar();
+ break;
+
+ /*
+ return OnRightClick((LPNMITEMACTIVATE)header, result);
+ */
+ /*
+ case NM_CLICK:
+ SendRefreshStatusBarMessage();
+ return 0;
+
+ // TODO : Handler default action...
+ return 0;
+ case LVN_ITEMCHANGED:
+ {
+ NMLISTVIEW *pNMLV = (NMLISTVIEW *) lpnmh;
+ SelChange(pNMLV);
+ return TRUE;
+ }
+ case NM_SETFOCUS:
+ return onSetFocus(NULL);
+ case NM_KILLFOCUS:
+ return onKillFocus(NULL);
+ */
+ case NM_CLICK:
+ {
+ // we need SetFocusToList, if we drag-select items from other panel.
+ SetFocusToList();
+ Post_Refresh_StatusBar();
+ if (_mySelectMode)
+ #ifndef UNDER_CE
+ if (g_ComCtl32Version >= MAKELONG(71, 4))
+ #endif
+ OnLeftClick((MY_NMLISTVIEW_NMITEMACTIVATE *)header);
+ return false;
+ }
+ case LVN_BEGINLABELEDITW:
+ result = OnBeginLabelEdit((LV_DISPINFOW *)header);
+ return true;
+ case LVN_ENDLABELEDITW:
+ result = OnEndLabelEdit((LV_DISPINFOW *)header);
+ return true;
+
+ case NM_CUSTOMDRAW:
+ {
+ if (_mySelectMode || (_markDeletedItems && _thereAreDeletedItems))
+ return OnCustomDraw((LPNMLVCUSTOMDRAW)header, result);
+ break;
+ }
+ case LVN_BEGINDRAG:
+ {
+ OnDrag((LPNMLISTVIEW)header, false);
+ Post_Refresh_StatusBar();
+ break;
+ }
+ case LVN_BEGINRDRAG:
+ {
+ OnDrag((LPNMLISTVIEW)header, true);
+ Post_Refresh_StatusBar();
+ break;
+ }
+ // case LVN_BEGINRDRAG:
+ }
+ return false;
+}
+
+bool CPanel::OnCustomDraw(LPNMLVCUSTOMDRAW lplvcd, LRESULT &result)
+{
+ switch (lplvcd->nmcd.dwDrawStage)
+ {
+ case CDDS_PREPAINT :
+ result = CDRF_NOTIFYITEMDRAW;
+ return true;
+
+ case CDDS_ITEMPREPAINT:
+ /*
+ SelectObject(lplvcd->nmcd.hdc,
+ GetFontForItem(lplvcd->nmcd.dwItemSpec,
+ lplvcd->nmcd.lItemlParam) );
+ lplvcd->clrText = GetColorForItem(lplvcd->nmcd.dwItemSpec,
+ lplvcd->nmcd.lItemlParam);
+ lplvcd->clrTextBk = GetBkColorForItem(lplvcd->nmcd.dwItemSpec,
+ lplvcd->nmcd.lItemlParam);
+ */
+ const unsigned realIndex = (unsigned)lplvcd->nmcd.lItemlParam;
+ lplvcd->clrTextBk = _listView.GetBkColor();
+ if (_mySelectMode)
+ {
+ if (realIndex != kParentIndex && _selectedStatusVector[realIndex])
+ lplvcd->clrTextBk = RGB(255, 192, 192);
+ }
+
+ if (_markDeletedItems && _thereAreDeletedItems)
+ {
+ if (IsItem_Deleted(realIndex))
+ lplvcd->clrText = RGB(255, 0, 0);
+ }
+ // lplvcd->clrText = RGB(0, 0, 0);
+ // result = CDRF_NEWFONT;
+ result = CDRF_NOTIFYITEMDRAW;
+ return true;
+
+ // return false;
+ // return true;
+ /*
+ case CDDS_SUBITEM | CDDS_ITEMPREPAINT:
+ if (lplvcd->iSubItem == 0)
+ {
+ // lplvcd->clrText = RGB(255, 0, 0);
+ lplvcd->clrTextBk = RGB(192, 192, 192);
+ }
+ else
+ {
+ lplvcd->clrText = RGB(0, 0, 0);
+ lplvcd->clrTextBk = RGB(255, 255, 255);
+ }
+ return true;
+ */
+
+ /* At this point, you can change the background colors for the item
+ and any subitems and return CDRF_NEWFONT. If the list-view control
+ is in report mode, you can simply return CDRF_NOTIFYSUBITEMREDRAW
+ to customize the item's subitems individually */
+ }
+ return false;
+}
+
+void CPanel::Refresh_StatusBar()
+{
+ /*
+ g_name_cnt++;
+ char s[256];
+ sprintf(s, "g_name_cnt = %8d", g_name_cnt);
+ OutputDebugStringA(s);
+ */
+ // DWORD dw = GetTickCount();
+
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+
+ {
+ UString s;
+ s.Add_UInt32(indices.Size());
+ s += " / ";
+ s.Add_UInt32(_selectedStatusVector.Size());
+
+ // UString s1 = MyFormatNew(g_App.LangString_N_SELECTED_ITEMS, NumberToString(indices.Size()));
+ // UString s1 = MyFormatNew(IDS_N_SELECTED_ITEMS, NumberToString(indices.Size()));
+ _statusBar.SetText(0, MyFormatNew(g_App.LangString_N_SELECTED_ITEMS, s));
+ // _statusBar.SetText(0, MyFormatNew(IDS_N_SELECTED_ITEMS, NumberToString(indices.Size())));
+ }
+
+ {
+ wchar_t selectSizeString[32];
+ selectSizeString[0] = 0;
+
+ if (indices.Size() > 0)
+ {
+ // for (unsigned ttt = 0; ttt < 1000; ttt++) {
+ UInt64 totalSize = 0;
+ FOR_VECTOR (i, indices)
+ totalSize += GetItemSize(indices[i]);
+ ConvertSizeToString(totalSize, selectSizeString);
+ // }
+ }
+ _statusBar.SetText(1, selectSizeString);
+ }
+
+ const int focusedItem = _listView.GetFocusedItem();
+ wchar_t sizeString[32];
+ sizeString[0] = 0;
+ wchar_t dateString[32];
+ dateString[0] = 0;
+ if (focusedItem >= 0 && _listView.GetSelectedCount() > 0)
+ {
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ if (realIndex != kParentIndex)
+ {
+ ConvertSizeToString(GetItemSize(realIndex), sizeString);
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(realIndex, kpidMTime, &prop) == S_OK)
+ {
+ char dateString2[32];
+ dateString2[0] = 0;
+ ConvertPropertyToShortString2(dateString2, prop, kpidMTime);
+ for (unsigned i = 0;; i++)
+ {
+ char c = dateString2[i];
+ dateString[i] = (Byte)c;
+ if (c == 0)
+ break;
+ }
+ }
+ }
+ }
+ _statusBar.SetText(2, sizeString);
+ _statusBar.SetText(3, dateString);
+
+ // _statusBar.SetText(4, nameString);
+ // _statusBar2.SetText(1, MyFormatNew(L"{0} bytes", NumberToStringW(totalSize)));
+ // }
+ /*
+ dw = GetTickCount() - dw;
+ sprintf(s, "status = %8d ms", dw);
+ OutputDebugStringA(s);
+ */
+}
diff --git a/CPP/7zip/UI/FileManager/PanelMenu.cpp b/CPP/7zip/UI/FileManager/PanelMenu.cpp
new file mode 100644
index 0000000..f0afe15
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelMenu.cpp
@@ -0,0 +1,1176 @@
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/COM.h"
+#include "../../../Windows/Clipboard.h"
+#include "../../../Windows/Menu.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/PropVariantConv.h"
+
+#include "../../PropID.h"
+#include "../Common/PropIDUtils.h"
+#include "../Explorer/ContextMenu.h"
+
+#include "App.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "ListViewDialog.h"
+#include "MyLoadMenu.h"
+#include "PropertyName.h"
+
+#include "PropertyNameRes.h"
+#include "resource.h"
+
+// #define SHOW_DEBUG_PANEL_MENU
+
+using namespace NWindows;
+
+extern
+LONG g_DllRefCount;
+LONG g_DllRefCount = 0;
+
+static const UINT kSevenZipStartMenuID = kMenuCmdID_Plugin_Start;
+static const UINT kSystemStartMenuID = kMenuCmdID_Plugin_Start + 400;
+
+
+#ifdef SHOW_DEBUG_PANEL_MENU
+static void Print_Ptr(void *p, const char *s)
+{
+ char temp[32];
+ ConvertUInt64ToHex((UInt64)(void *)p, temp);
+ AString m;
+ m += temp;
+ m.Add_Space();
+ m += s;
+ OutputDebugStringA(m);
+}
+#define ODS(sz) { Print_Ptr(this, sz); }
+#define ODS_U(s) { OutputDebugStringW(s); }
+#else
+#define ODS(sz)
+#define ODS_U(s)
+#endif
+
+
+void CPanel::InvokeSystemCommand(const char *command)
+{
+ NCOM::CComInitializer comInitializer;
+ if (!IsFsOrPureDrivesFolder())
+ return;
+ CRecordVector<UInt32> operatedIndices;
+ Get_ItemIndices_Operated(operatedIndices);
+ if (operatedIndices.IsEmpty())
+ return;
+ CMyComPtr<IContextMenu> contextMenu;
+ if (CreateShellContextMenu(operatedIndices, contextMenu) != S_OK)
+ return;
+
+ CMINVOKECOMMANDINFO ci;
+ ZeroMemory(&ci, sizeof(ci));
+ ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
+ ci.hwnd = GetParent();
+ ci.lpVerb = command;
+ contextMenu->InvokeCommand(&ci);
+}
+
+static const char * const kSeparator = "------------------------";
+static const char * const kSeparatorSmall = "----------------";
+
+extern UString ConvertSizeToString(UInt64 value) throw();
+bool IsSizeProp(UINT propID) throw();
+
+UString GetOpenArcErrorMessage(UInt32 errorFlags);
+
+
+static void AddListAscii(CListViewDialog &dialog, const char *s)
+{
+ dialog.Strings.Add((UString)s);
+ dialog.Values.AddNew();
+}
+
+static void AddSeparator(CListViewDialog &dialog)
+{
+ AddListAscii(dialog, kSeparator);
+}
+
+static void AddSeparatorSmall(CListViewDialog &dialog)
+{
+ AddListAscii(dialog, kSeparatorSmall);
+}
+
+static void AddPropertyPair(const UString &name, const UString &val, CListViewDialog &dialog)
+{
+ dialog.Strings.Add(name);
+ dialog.Values.Add(val);
+}
+
+
+static void AddPropertyString(PROPID propID, const wchar_t *nameBSTR,
+ const NCOM::CPropVariant &prop, CListViewDialog &dialog)
+{
+ if (prop.vt != VT_EMPTY)
+ {
+ UString val;
+
+ if (propID == kpidErrorFlags ||
+ propID == kpidWarningFlags)
+ {
+ UInt32 flags = GetOpenArcErrorFlags(prop);
+ if (flags == 0)
+ return;
+ if (flags != 0)
+ val = GetOpenArcErrorMessage(flags);
+ }
+
+ if (val.IsEmpty())
+ {
+ if ((prop.vt == VT_UI8 || prop.vt == VT_UI4 || prop.vt == VT_UI2) && IsSizeProp(propID))
+ {
+ UInt64 v = 0;
+ ConvertPropVariantToUInt64(prop, v);
+ val = ConvertSizeToString(v);
+ }
+ else
+ ConvertPropertyToString2(val, prop, propID, 9); // we send 9 - is ns precision
+ }
+
+ if (!val.IsEmpty())
+ {
+ if (propID == kpidErrorType)
+ {
+ AddPropertyPair(L"Open WARNING:", L"Cannot open the file as expected archive type", dialog);
+ }
+ AddPropertyPair(GetNameOfProperty(propID, nameBSTR), val, dialog);
+ }
+ }
+}
+
+
+static void AddPropertyString(PROPID propID, UInt64 val, CListViewDialog &dialog)
+{
+ NCOM::CPropVariant prop = val;
+ AddPropertyString(propID, NULL, prop, dialog);
+}
+
+
+static inline unsigned GetHex_Upper(unsigned v)
+{
+ return (v < 10) ? ('0' + v) : ('A' + (v - 10));
+}
+
+static inline unsigned GetHex_Lower(unsigned v)
+{
+ return (v < 10) ? ('0' + v) : ('a' + (v - 10));
+}
+
+static const Byte kSpecProps[] =
+{
+ kpidPath,
+ kpidType,
+ kpidErrorType,
+ kpidError,
+ kpidErrorFlags,
+ kpidWarning,
+ kpidWarningFlags,
+ kpidOffset,
+ kpidPhySize,
+ kpidTailSize
+};
+
+void CPanel::Properties()
+{
+ CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+ _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+ if (!getFolderArcProps)
+ {
+ InvokeSystemCommand("properties");
+ return;
+ }
+
+ {
+ CListViewDialog message;
+ // message.DeleteIsAllowed = false;
+ // message.SelectFirst = false;
+
+ CRecordVector<UInt32> operatedIndices;
+ Get_ItemIndices_Operated(operatedIndices);
+
+ if (operatedIndices.Size() == 1)
+ {
+ UInt32 index = operatedIndices[0];
+ // message += "Item:\n");
+ UInt32 numProps;
+ if (_folder->GetNumberOfProperties(&numProps) == S_OK)
+ {
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE varType;
+
+ if (_folder->GetPropertyInfo(i, &name, &propID, &varType) != S_OK)
+ continue;
+
+ NCOM::CPropVariant prop;
+ if (_folder->GetProperty(index, propID, &prop) != S_OK)
+ continue;
+ AddPropertyString(propID, name, prop, message);
+ }
+ }
+
+
+ if (_folderRawProps)
+ {
+ _folderRawProps->GetNumRawProps(&numProps);
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ if (_folderRawProps->GetRawPropInfo(i, &name, &propID) != S_OK)
+ continue;
+
+ const void *data;
+ UInt32 dataSize;
+ UInt32 propType;
+ if (_folderRawProps->GetRawProp(index, propID, &data, &dataSize, &propType) != S_OK)
+ continue;
+
+ if (dataSize != 0)
+ {
+ AString s;
+ if (propID == kpidNtSecure)
+ ConvertNtSecureToString((const Byte *)data, dataSize, s);
+ else
+ {
+ const UInt32 kMaxDataSize = 64;
+ if (dataSize > kMaxDataSize)
+ {
+ s += "data:";
+ s.Add_UInt32(dataSize);
+ }
+ else
+ {
+ const bool needUpper = (dataSize <= 8)
+ && (propID == kpidCRC || propID == kpidChecksum);
+ for (UInt32 k = 0; k < dataSize; k++)
+ {
+ const Byte b = ((const Byte *)data)[k];
+ if (needUpper)
+ {
+ s += (char)GetHex_Upper((b >> 4) & 0xF);
+ s += (char)GetHex_Upper(b & 0xF);
+ }
+ else
+ {
+ s += (char)GetHex_Lower((b >> 4) & 0xF);
+ s += (char)GetHex_Lower(b & 0xF);
+ }
+ }
+ }
+ }
+ AddPropertyPair(GetNameOfProperty(propID, name), (UString)s.Ptr(), message);
+ }
+ }
+ }
+
+ AddSeparator(message);
+ }
+ else if (operatedIndices.Size() >= 1)
+ {
+ UInt64 packSize = 0;
+ UInt64 unpackSize = 0;
+ UInt64 numFiles = 0;
+ UInt64 numDirs = 0;
+
+ FOR_VECTOR (i, operatedIndices)
+ {
+ const UInt32 index = operatedIndices[i];
+ unpackSize += GetItemSize(index);
+ packSize += GetItem_UInt64Prop(index, kpidPackSize);
+ if (IsItem_Folder(index))
+ {
+ numDirs++;
+ numDirs += GetItem_UInt64Prop(index, kpidNumSubDirs);
+ numFiles += GetItem_UInt64Prop(index, kpidNumSubFiles);
+ }
+ else
+ numFiles++;
+ }
+ {
+ wchar_t temp[32];
+ ConvertUInt32ToString(operatedIndices.Size(), temp);
+ AddPropertyPair(L"", MyFormatNew(g_App.LangString_N_SELECTED_ITEMS, temp), message);
+ }
+
+ if (numDirs != 0)
+ AddPropertyString(kpidNumSubDirs, numDirs, message);
+ if (numFiles != 0)
+ AddPropertyString(kpidNumSubFiles, numFiles, message);
+ AddPropertyString(kpidSize, unpackSize, message);
+ AddPropertyString(kpidPackSize, packSize, message);
+
+ AddSeparator(message);
+ }
+
+
+ /*
+ AddLangString(message, IDS_PROP_FILE_TYPE);
+ message += kPropValueSeparator;
+ message += GetFolderTypeID();
+ message.Add_LF();
+ */
+
+ {
+ NCOM::CPropVariant prop;
+ if (_folder->GetFolderProperty(kpidPath, &prop) == S_OK)
+ {
+ AddPropertyString(kpidName, L"Path", prop, message);
+ }
+ }
+
+ CMyComPtr<IFolderProperties> folderProperties;
+ _folder.QueryInterface(IID_IFolderProperties, &folderProperties);
+ if (folderProperties)
+ {
+ UInt32 numProps;
+ if (folderProperties->GetNumberOfFolderProperties(&numProps) == S_OK)
+ {
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ if (folderProperties->GetFolderPropertyInfo(i, &name, &propID, &vt) != S_OK)
+ continue;
+ NCOM::CPropVariant prop;
+ if (_folder->GetFolderProperty(propID, &prop) != S_OK)
+ continue;
+ AddPropertyString(propID, name, prop, message);
+ }
+ }
+ }
+
+ if (getFolderArcProps)
+ {
+ CMyComPtr<IFolderArcProps> getProps;
+ getFolderArcProps->GetFolderArcProps(&getProps);
+ if (getProps)
+ {
+ UInt32 numLevels;
+ if (getProps->GetArcNumLevels(&numLevels) != S_OK)
+ numLevels = 0;
+ for (UInt32 level2 = 0; level2 < numLevels; level2++)
+ {
+ {
+ UInt32 level = numLevels - 1 - level2;
+ UInt32 numProps;
+ if (getProps->GetArcNumProps(level, &numProps) == S_OK)
+ {
+ const int kNumSpecProps = Z7_ARRAY_SIZE(kSpecProps);
+
+ AddSeparator(message);
+
+ for (Int32 i = -(int)kNumSpecProps; i < (Int32)numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ if (i < 0)
+ propID = kSpecProps[i + kNumSpecProps];
+ else if (getProps->GetArcPropInfo(level, (UInt32)i, &name, &propID, &vt) != S_OK)
+ continue;
+ NCOM::CPropVariant prop;
+ if (getProps->GetArcProp(level, propID, &prop) != S_OK)
+ continue;
+ AddPropertyString(propID, name, prop, message);
+ }
+ }
+ }
+
+ if (level2 < numLevels - 1)
+ {
+ const UInt32 level = numLevels - 1 - level2;
+ UInt32 numProps;
+ if (getProps->GetArcNumProps2(level, &numProps) == S_OK)
+ {
+ AddSeparatorSmall(message);
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ CMyComBSTR name;
+ PROPID propID;
+ VARTYPE vt;
+ if (getProps->GetArcPropInfo2(level, i, &name, &propID, &vt) != S_OK)
+ continue;
+ NCOM::CPropVariant prop;
+ if (getProps->GetArcProp2(level, propID, &prop) != S_OK)
+ continue;
+ AddPropertyString(propID, name, prop, message);
+ }
+ }
+ }
+ }
+
+ {
+ // we ERROR message for NonOpen level
+ bool needSep = true;
+ const int kNumSpecProps = Z7_ARRAY_SIZE(kSpecProps);
+ for (Int32 i = -(int)kNumSpecProps; i < 0; i++)
+ {
+ CMyComBSTR name;
+ const PROPID propID = kSpecProps[i + kNumSpecProps];
+ NCOM::CPropVariant prop;
+ if (getProps->GetArcProp(numLevels, propID, &prop) != S_OK)
+ continue;
+ if (needSep)
+ {
+ AddSeparator(message);
+ AddSeparator(message);
+ needSep = false;
+ }
+ AddPropertyString(propID, name, prop, message);
+ }
+ }
+
+ }
+ }
+
+ message.Title = LangString(IDS_PROPERTIES);
+ message.NumColumns = 2;
+ message.Create(GetParent());
+ }
+}
+
+
+
+void CPanel::EditCut()
+{
+ // InvokeSystemCommand("cut");
+}
+
+void CPanel::EditCopy()
+{
+ /*
+ CMyComPtr<IGetFolderArcProps> getFolderArcProps;
+ _folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
+ if (!getFolderArcProps)
+ {
+ InvokeSystemCommand("copy");
+ return;
+ }
+ */
+ UString s;
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Selected(indices);
+ FOR_VECTOR (i, indices)
+ {
+ if (i != 0)
+ s += "\xD\n";
+ s += GetItemName(indices[i]);
+ }
+ ClipboardSetText(_mainWindow, s);
+}
+
+void CPanel::EditPaste()
+{
+ /*
+ UStringVector names;
+ ClipboardGetFileNames(names);
+ CopyFromNoAsk(names);
+ UString s;
+ for (int i = 0; i < names.Size(); i++)
+ {
+ s += L' ';
+ s += names[i];
+ }
+
+ MessageBoxW(0, s, L"", 0);
+ */
+
+ // InvokeSystemCommand("paste");
+}
+
+
+
+struct CFolderPidls
+{
+ LPITEMIDLIST parent;
+ CRecordVector<LPITEMIDLIST> items;
+
+ CFolderPidls(): parent(NULL) {}
+ ~CFolderPidls()
+ {
+ FOR_VECTOR (i, items)
+ CoTaskMemFree(items[i]);
+ CoTaskMemFree(parent);
+ }
+};
+
+
+static HRESULT ShellFolder_ParseDisplayName(IShellFolder *shellFolder,
+ HWND hwnd, const UString &path, LPITEMIDLIST *ppidl)
+{
+ ULONG eaten = 0;
+ return shellFolder->ParseDisplayName(hwnd, NULL,
+ path.Ptr_non_const(), &eaten, ppidl, NULL);
+}
+
+
+HRESULT CPanel::CreateShellContextMenu(
+ const CRecordVector<UInt32> &operatedIndices,
+ CMyComPtr<IContextMenu> &systemContextMenu)
+{
+ ODS("==== CPanel::CreateShellContextMenu");
+ systemContextMenu.Release();
+ UString folderPath = GetFsPath();
+
+ CMyComPtr<IShellFolder> desktopFolder;
+ RINOK(::SHGetDesktopFolder(&desktopFolder))
+ if (!desktopFolder)
+ {
+ // ShowMessage("Failed to get Desktop folder");
+ return E_FAIL;
+ }
+
+ CFolderPidls pidls;
+ // NULL is allowed for parentHWND in ParseDisplayName()
+ const HWND parentHWND_for_ParseDisplayName = GetParent();
+ // if (folderPath.IsEmpty()), then ParseDisplayName returns pidls of "My Computer"
+ /* win10: ParseDisplayName() supports folder path with tail slash
+ ParseDisplayName() returns {
+ E_INVALIDARG : path with super path prefix "\\\\?\\"
+ ERROR_FILE_NOT_FOUND : path for network share (\\server\path1\long path2") larger than MAX_PATH
+ } */
+ const HRESULT res = ShellFolder_ParseDisplayName(desktopFolder,
+ parentHWND_for_ParseDisplayName,
+ folderPath, &pidls.parent);
+ if (res != S_OK)
+ {
+ ODS_U(folderPath);
+ if (res != E_INVALIDARG)
+ return res;
+ if (!NFile::NName::If_IsSuperPath_RemoveSuperPrefix(folderPath))
+ return res;
+ RINOK(ShellFolder_ParseDisplayName(desktopFolder,
+ parentHWND_for_ParseDisplayName,
+ folderPath, &pidls.parent))
+ }
+ if (!pidls.parent)
+ return E_FAIL;
+
+ /*
+ UString path2;
+ NShell::GetPathFromIDList(pidls.parent, path2);
+ ODS_U(path2);
+ */
+
+ if (operatedIndices.IsEmpty())
+ {
+ // how to get IContextMenu, if there are no selected files?
+ return E_FAIL;
+
+ /*
+ xp64 :
+ 1) we can't use GetUIObjectOf() with (numItems == 0), it throws exception
+ 2) we can't use desktopFolder->GetUIObjectOf() with absolute pidls of folder
+ context menu items are different in that case:
+ "Open / Explorer" for folder
+ "Delete" for "My Computer" icon
+ "Preperties" for "System"
+ */
+ /*
+ parentFolder = desktopFolder;
+ pidls.items.AddInReserved(pidls.parent);
+ pidls.parent = NULL;
+ */
+
+ // CreateViewObject() doesn't show all context menu items
+ /*
+ HRESULT res = parentFolder->CreateViewObject(
+ GetParent(), IID_IContextMenu, (void**)&systemContextMenu);
+ */
+ }
+
+ CMyComPtr<IShellFolder> parentFolder;
+ RINOK(desktopFolder->BindToObject(pidls.parent,
+ NULL, IID_IShellFolder, (void**)&parentFolder))
+ if (!parentFolder)
+ return E_FAIL;
+
+ ODS("==== CPanel::CreateShellContextMenu pidls START");
+
+ pidls.items.ClearAndReserve(operatedIndices.Size());
+ UString fileName;
+ FOR_VECTOR (i, operatedIndices)
+ {
+ fileName.Empty();
+ Add_ItemRelPath2_To_String(operatedIndices[i], fileName);
+ /* ParseDisplayName() in win10 returns:
+ E_INVALIDARG : if empty name, or path with dots only: "." , ".."
+ HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) : if there is no such file
+ */
+ LPITEMIDLIST pidl = NULL;
+ RINOK(ShellFolder_ParseDisplayName(parentFolder,
+ parentHWND_for_ParseDisplayName,
+ fileName, &pidl))
+ if (!pidl)
+ return E_FAIL;
+ pidls.items.AddInReserved(pidl);
+ }
+
+ ODS("==== CPanel::CreateShellContextMenu pidls END");
+ // Get IContextMenu for items
+ RINOK(parentFolder->GetUIObjectOf(GetParent(),
+ pidls.items.Size(), (LPCITEMIDLIST *)(void *)&pidls.items.Front(),
+ IID_IContextMenu, NULL, (void**)&systemContextMenu))
+ ODS("==== CPanel::CreateShellContextMenu GetUIObjectOf finished");
+ if (!systemContextMenu)
+ {
+ // ShowMessage("Unable to get context menu interface");
+ return E_FAIL;
+ }
+ return S_OK;
+}
+
+
+// #define SHOW_DEBUG_FM_CTX_MENU
+
+#ifdef SHOW_DEBUG_FM_CTX_MENU
+
+static void PrintHex(UString &s, UInt32 v)
+{
+ char sz[32];
+ ConvertUInt32ToHex(v, sz);
+ s += sz;
+}
+
+static void PrintContextStr(UString &s, IContextMenu *ctxm, unsigned i, unsigned id, const char *name)
+{
+ s += " | ";
+ s += name;
+ s += ": ";
+ UString s1;
+ {
+ char buf[256];
+ buf[0] = 0;
+ const HRESULT res = ctxm->GetCommandString(i, id,
+ NULL, buf, Z7_ARRAY_SIZE(buf) - 1);
+ if (res != S_OK)
+ {
+ PrintHex(s1, res);
+ s1.Add_Space();
+ }
+ s1 += GetUnicodeString(buf);
+ }
+ UString s2;
+ {
+ wchar_t buf2[256];
+ buf2[0] = 0;
+ const HRESULT res = ctxm->GetCommandString(i, id | GCS_UNICODE,
+ NULL, (char *)buf2, Z7_ARRAY_SIZE(buf2) - sizeof(wchar_t));
+ if (res != S_OK)
+ {
+ PrintHex(s2, res);
+ s2.Add_Space();
+ }
+ s2 += buf2;
+ }
+ s += s1;
+ if (s2.Compare(s1) != 0)
+ {
+ s += " Unicode: ";
+ s += s2;
+ }
+}
+
+static void PrintAllContextItems(IContextMenu *ctxm, unsigned num)
+{
+ for (unsigned i = 0; i < num; i++)
+ {
+ UString s;
+ s.Add_UInt32(i);
+ s += ": ";
+ PrintContextStr(s, ctxm, i, GCS_VALIDATEA, "valid");
+ PrintContextStr(s, ctxm, i, GCS_VERBA, "verb");
+ PrintContextStr(s, ctxm, i, GCS_HELPTEXTA, "helptext");
+ OutputDebugStringW(s);
+ }
+}
+
+#endif
+
+
+void CPanel::CreateSystemMenu(HMENU menuSpec,
+ bool showExtendedVerbs,
+ const CRecordVector<UInt32> &operatedIndices,
+ CMyComPtr<IContextMenu> &systemContextMenu)
+{
+ systemContextMenu.Release();
+
+ CreateShellContextMenu(operatedIndices, systemContextMenu);
+
+ if (!systemContextMenu)
+ return;
+
+ /*
+ // Set up a CMINVOKECOMMANDINFO structure.
+ CMINVOKECOMMANDINFO ci;
+ ZeroMemory(&ci, sizeof(ci));
+ ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
+ ci.hwnd = GetParent();
+ */
+
+ /*
+ if (Sender == GoBtn)
+ {
+ // Verbs that can be used are cut, paste,
+ // properties, delete, and so on.
+ String action;
+ if (CutRb->Checked)
+ action = "cut";
+ else if (CopyRb->Checked)
+ action = "copy";
+ else if (DeleteRb->Checked)
+ action = "delete";
+ else if (PropertiesRb->Checked)
+ action = "properties";
+
+ ci.lpVerb = action.c_str();
+ result = cm->InvokeCommand(&ci);
+ if (result)
+ ShowMessage(
+ "Error copying file to clipboard.");
+
+ }
+ else
+ */
+ {
+ // HMENU hMenu = CreatePopupMenu();
+ CMenu popupMenu;
+ CMenuDestroyer menuDestroyer(popupMenu);
+ if (!popupMenu.CreatePopup())
+ throw 210503;
+ const HMENU hMenu = popupMenu;
+ DWORD flags = CMF_EXPLORE;
+ if (showExtendedVerbs)
+ flags |= Z7_WIN_CMF_EXTENDEDVERBS;
+ ODS("=== systemContextMenu->QueryContextMenu START");
+ const HRESULT res = systemContextMenu->QueryContextMenu(hMenu, 0, kSystemStartMenuID, 0x7FFF, flags);
+ ODS("=== systemContextMenu->QueryContextMenu END");
+ if (SUCCEEDED(res))
+ {
+ #ifdef SHOW_DEBUG_FM_CTX_MENU
+ PrintAllContextItems(systemContextMenu, (unsigned)res);
+ #endif
+
+ CMenu menu;
+ menu.Attach(menuSpec);
+ CMenuItem menuItem;
+ menuItem.fMask = MIIM_SUBMENU | MIIM_TYPE | MIIM_ID;
+ menuItem.fType = MFT_STRING;
+ menuItem.hSubMenu = popupMenu.Detach();
+ menuDestroyer.Disable();
+ LangString(IDS_SYSTEM, menuItem.StringValue);
+ menu.InsertItem(0, true, menuItem);
+ }
+ /*
+ if (Cmd < 100 && Cmd != 0)
+ {
+ ci.lpVerb = MAKEINTRESOURCE(Cmd - 1);
+ ci.lpParameters = "";
+ ci.lpDirectory = "";
+ ci.nShow = SW_SHOWNORMAL;
+ cm->InvokeCommand(&ci);
+ }
+ // If Cmd is > 100 then it's one of our
+ // inserted menu items.
+ else
+ // Find the menu item.
+ for (int i = 0; i < popupMenu1->Items->Count; i++)
+ {
+ TMenuItem* menu = popupMenu1->Items->Items[i];
+ // Call its OnClick handler.
+ if (menu->Command == Cmd - 100)
+ menu->OnClick(this);
+ }
+ // Release the memory allocated for the menu.
+ DestroyMenu(hMenu);
+ */
+ }
+}
+
+void CPanel::CreateFileMenu(HMENU menuSpec)
+{
+ CreateFileMenu(menuSpec, _sevenZipContextMenu, _systemContextMenu, true); // programMenu
+}
+
+void CPanel::CreateSevenZipMenu(HMENU menuSpec,
+ bool showExtendedVerbs,
+ const CRecordVector<UInt32> &operatedIndices,
+ int firstDirIndex,
+ CMyComPtr<IContextMenu> &sevenZipContextMenu)
+{
+ sevenZipContextMenu.Release();
+
+ CMenu menu;
+ menu.Attach(menuSpec);
+ // CMenuDestroyer menuDestroyer(menu);
+ // menu.CreatePopup();
+
+ CZipContextMenu *contextMenuSpec = new CZipContextMenu;
+ CMyComPtr<IContextMenu> contextMenu = contextMenuSpec;
+ // if (contextMenu.CoCreateInstance(CLSID_CZipContextMenu, IID_IContextMenu) == S_OK)
+ {
+ /*
+ CMyComPtr<IInitContextMenu> initContextMenu;
+ if (contextMenu.QueryInterface(IID_IInitContextMenu, &initContextMenu) != S_OK)
+ return;
+ */
+ ODS("=== FileName List Add START")
+ // for (unsigned y = 0; y < 10000; y++, contextMenuSpec->_fileNames.Clear())
+ GetFilePaths(operatedIndices, contextMenuSpec->_fileNames);
+ ODS("=== FileName List Add END")
+ contextMenuSpec->Init_For_7zFM();
+ contextMenuSpec->_attribs.FirstDirIndex = firstDirIndex;
+ {
+ DWORD flags = CMF_EXPLORE;
+ if (showExtendedVerbs)
+ flags |= Z7_WIN_CMF_EXTENDEDVERBS;
+ const HRESULT res = contextMenu->QueryContextMenu(menu,
+ 0, // indexMenu
+ kSevenZipStartMenuID, // first
+ kSystemStartMenuID - 1, // last
+ flags);
+ ODS("=== contextMenu->QueryContextMenu END")
+ const bool sevenZipMenuCreated = SUCCEEDED(res);
+ if (sevenZipMenuCreated)
+ {
+ // if (res != 0)
+ {
+ // some "non-good" implementation of QueryContextMenu() could add some items to menu, but it return 0.
+ // so we still allow these items
+ sevenZipContextMenu = contextMenu;
+ #ifdef SHOW_DEBUG_FM_CTX_MENU
+ PrintAllContextItems(contextMenu, (unsigned)res);
+ #endif
+ }
+ }
+ else
+ {
+ // MessageBox_Error_HRESULT_Caption(res, L"QueryContextMenu");
+ }
+ // int code = HRESULT_CODE(res);
+ // int nextItemID = code;
+ }
+ }
+}
+
+static bool IsReadOnlyFolder(IFolderFolder *folder)
+{
+ if (!folder)
+ return false;
+
+ bool res = false;
+ {
+ NCOM::CPropVariant prop;
+ if (folder->GetFolderProperty(kpidReadOnly, &prop) == S_OK)
+ if (prop.vt == VT_BOOL)
+ res = VARIANT_BOOLToBool(prop.boolVal);
+ }
+ return res;
+}
+
+bool CPanel::IsThereReadOnlyFolder() const
+{
+ if (!_folderOperations)
+ return true;
+ if (IsReadOnlyFolder(_folder))
+ return true;
+ FOR_VECTOR (i, _parentFolders)
+ {
+ if (IsReadOnlyFolder(_parentFolders[i].ParentFolder))
+ return true;
+ }
+ return false;
+}
+
+bool CPanel::CheckBeforeUpdate(UINT resourceID)
+{
+ if (!_folderOperations)
+ {
+ MessageBox_Error_UnsupportOperation();
+ // resourceID = resourceID;
+ // MessageBoxErrorForUpdate(E_NOINTERFACE, resourceID);
+ return false;
+ }
+
+ for (int i = (int)_parentFolders.Size(); i >= 0; i--)
+ {
+ IFolderFolder *folder;
+ if (i == (int)_parentFolders.Size())
+ folder = _folder;
+ else
+ folder = _parentFolders[i].ParentFolder;
+
+ if (!IsReadOnlyFolder(folder))
+ continue;
+
+ UString s;
+ AddLangString(s, resourceID);
+ s.Add_LF();
+ AddLangString(s, IDS_OPERATION_IS_NOT_SUPPORTED);
+ s.Add_LF();
+ if (i == 0)
+ s += GetFolderPath(folder);
+ else
+ s += _parentFolders[i - 1].VirtualPath;
+ s.Add_LF();
+ AddLangString(s, IDS_PROP_READ_ONLY);
+ MessageBox_Error(s);
+ return false;
+ }
+
+ return true;
+}
+
+void CPanel::CreateFileMenu(HMENU menuSpec,
+ CMyComPtr<IContextMenu> &sevenZipContextMenu,
+ CMyComPtr<IContextMenu> &systemContextMenu,
+ bool programMenu)
+{
+ sevenZipContextMenu.Release();
+ systemContextMenu.Release();
+
+ const bool showExtendedVerbs = IsKeyDown(VK_SHIFT);
+
+ CRecordVector<UInt32> operatedIndices;
+ Get_ItemIndices_Operated(operatedIndices);
+ const int firstDirIndex = FindDir_InOperatedList(operatedIndices);
+
+ CMenu menu;
+ menu.Attach(menuSpec);
+
+ if (!IsArcFolder())
+ {
+ CreateSevenZipMenu(menu, showExtendedVerbs, operatedIndices, firstDirIndex, sevenZipContextMenu);
+ // CreateSystemMenu is very slow if you call it inside ZIP archive with big number of files
+ // Windows probably can parse items inside ZIP archive.
+ if (g_App.ShowSystemMenu)
+ CreateSystemMenu(menu, showExtendedVerbs, operatedIndices, systemContextMenu);
+ }
+
+ /*
+ if (menu.GetItemCount() > 0)
+ menu.AppendItem(MF_SEPARATOR, 0, (LPCTSTR)0);
+ */
+
+ CFileMenu fm;
+
+ fm.readOnly = IsThereReadOnlyFolder();
+ fm.isHashFolder = IsHashFolder();
+ fm.isFsFolder = Is_IO_FS_Folder();
+ fm.programMenu = programMenu;
+ fm.allAreFiles = (firstDirIndex == -1);
+ fm.numItems = operatedIndices.Size();
+
+ fm.isAltStreamsSupported = false;
+
+ if (fm.numItems == 1)
+ fm.FilePath = us2fs(GetItemFullPath(operatedIndices[0]));
+
+ if (_folderAltStreams)
+ {
+ if (operatedIndices.Size() <= 1)
+ {
+ UInt32 realIndex = (UInt32)(Int32)-1;
+ if (operatedIndices.Size() == 1)
+ realIndex = operatedIndices[0];
+ Int32 val = 0;
+ if (_folderAltStreams->AreAltStreamsSupported(realIndex, &val) == S_OK)
+ fm.isAltStreamsSupported = IntToBool(val);
+ }
+ }
+ else
+ {
+ if (fm.numItems == 0)
+ fm.isAltStreamsSupported = IsFSFolder();
+ else
+ fm.isAltStreamsSupported = IsFolder_with_FsItems();
+ }
+
+ fm.Load(menu, (unsigned)menu.GetItemCount());
+}
+
+bool CPanel::InvokePluginCommand(unsigned id)
+{
+ return InvokePluginCommand(id, _sevenZipContextMenu, _systemContextMenu);
+}
+
+#if defined(_MSC_VER) && !defined(UNDER_CE)
+#define use_CMINVOKECOMMANDINFOEX
+/* CMINVOKECOMMANDINFOEX depends from (_WIN32_IE >= 0x0400) */
+#endif
+
+bool CPanel::InvokePluginCommand(unsigned id,
+ IContextMenu *sevenZipContextMenu, IContextMenu *systemContextMenu)
+{
+ UInt32 offset;
+ const bool isSystemMenu = (id >= kSystemStartMenuID);
+ if (isSystemMenu)
+ {
+ if (!systemContextMenu)
+ return false;
+ offset = id - kSystemStartMenuID;
+ }
+ else
+ {
+ if (!sevenZipContextMenu)
+ return false;
+ offset = id - kSevenZipStartMenuID;
+ }
+
+ #ifdef use_CMINVOKECOMMANDINFOEX
+ CMINVOKECOMMANDINFOEX
+ #else
+ CMINVOKECOMMANDINFO
+ #endif
+ commandInfo;
+
+ memset(&commandInfo, 0, sizeof(commandInfo));
+ commandInfo.cbSize = sizeof(commandInfo);
+
+ commandInfo.fMask = 0
+ #ifdef use_CMINVOKECOMMANDINFOEX
+ | CMIC_MASK_UNICODE
+ #endif
+ ;
+
+ commandInfo.hwnd = GetParent();
+ commandInfo.lpVerb = (LPCSTR)(MAKEINTRESOURCE(offset));
+ commandInfo.lpParameters = NULL;
+ // 19.01: fixed CSysString to AString
+ // MSDN suggest to send NULL: lpDirectory: This member is always NULL for menu items inserted by a Shell extension.
+ const AString currentFolderA (GetAnsiString(_currentFolderPrefix));
+ commandInfo.lpDirectory = (LPCSTR)(currentFolderA);
+ commandInfo.nShow = SW_SHOW;
+
+ #ifdef use_CMINVOKECOMMANDINFOEX
+
+ commandInfo.lpParametersW = NULL;
+ commandInfo.lpTitle = "";
+
+ /*
+ system ContextMenu handler supports ContextMenu subhandlers.
+ so InvokeCommand() converts (command_offset) from global number to subhandler number.
+ XP-64 / win10:
+ system ContextMenu converts (command_offset) in lpVerb only,
+ and it keeps lpVerbW unchanged.
+ also explorer.exe sends 0 in lpVerbW.
+ We try to keep compatibility with Windows Explorer here.
+ */
+ commandInfo.lpVerbW = NULL;
+
+ const UString currentFolderUnicode = _currentFolderPrefix;
+ commandInfo.lpDirectoryW = currentFolderUnicode;
+ commandInfo.lpTitleW = L"";
+ // commandInfo.ptInvoke.x = xPos;
+ // commandInfo.ptInvoke.y = yPos;
+ commandInfo.ptInvoke.x = 0;
+ commandInfo.ptInvoke.y = 0;
+
+ #endif
+
+ HRESULT result;
+ if (isSystemMenu)
+ result = systemContextMenu->InvokeCommand(LPCMINVOKECOMMANDINFO(&commandInfo));
+ else
+ result = sevenZipContextMenu->InvokeCommand(LPCMINVOKECOMMANDINFO(&commandInfo));
+ if (result == NOERROR)
+ {
+ KillSelection();
+ return true;
+ }
+ else
+ MessageBox_Error_HRESULT_Caption(result, L"InvokeCommand");
+ return false;
+}
+
+bool CPanel::OnContextMenu(HANDLE windowHandle, int xPos, int yPos)
+{
+ if (::GetParent((HWND)windowHandle) == _listView)
+ {
+ ShowColumnsContextMenu(xPos, yPos);
+ return true;
+ }
+
+ if (windowHandle != _listView)
+ return false;
+ /*
+ POINT point;
+ point.x = xPos;
+ point.y = yPos;
+ if (!_listView.ScreenToClient(&point))
+ return false;
+
+ LVHITTESTINFO info;
+ info.pt = point;
+ int index = _listView.HitTest(&info);
+ */
+
+ CRecordVector<UInt32> operatedIndices;
+ Get_ItemIndices_Operated(operatedIndices);
+
+ // negative x,y are possible for multi-screen modes.
+ // x=-1 && y=-1 for keyboard call (SHIFT+F10 and others).
+ if (xPos == -1 && yPos == -1)
+ {
+ if (operatedIndices.Size() == 0)
+ {
+ xPos = 0;
+ yPos = 0;
+ }
+ else
+ {
+ int itemIndex = _listView.GetNextItem(-1, LVNI_FOCUSED);
+ if (itemIndex == -1)
+ return false;
+ RECT rect;
+ if (!_listView.GetItemRect(itemIndex, &rect, LVIR_ICON))
+ return false;
+ xPos = (rect.left + rect.right) / 2;
+ yPos = (rect.top + rect.bottom) / 2;
+ }
+ POINT point = {xPos, yPos};
+ _listView.ClientToScreen(&point);
+ xPos = point.x;
+ yPos = point.y;
+ }
+
+ CMenu menu;
+ CMenuDestroyer menuDestroyer(menu);
+ menu.CreatePopup();
+
+ CMyComPtr<IContextMenu> sevenZipContextMenu;
+ CMyComPtr<IContextMenu> systemContextMenu;
+ CreateFileMenu(menu, sevenZipContextMenu, systemContextMenu, false); // programMenu
+
+ const unsigned id = (unsigned)menu.Track(TPM_LEFTALIGN
+ #ifndef UNDER_CE
+ | TPM_RIGHTBUTTON
+ #endif
+ | TPM_RETURNCMD | TPM_NONOTIFY,
+ xPos, yPos, _listView);
+
+ if (id == 0)
+ return true;
+
+ if (id >= kMenuCmdID_Plugin_Start)
+ {
+ InvokePluginCommand(id, sevenZipContextMenu, systemContextMenu);
+ return true;
+ }
+ if (ExecuteFileCommand(id))
+ return true;
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelOperations.cpp b/CPP/7zip/UI/FileManager/PanelOperations.cpp
new file mode 100644
index 0000000..b61f4e9
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelOperations.cpp
@@ -0,0 +1,528 @@
+// PanelOperations.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/DynamicBuffer.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/COM.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "ComboDialog.h"
+
+#include "FSFolder.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "Panel.h"
+#include "UpdateCallback100.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+enum EFolderOpType
+{
+ FOLDER_TYPE_CREATE_FOLDER = 0,
+ FOLDER_TYPE_DELETE = 1,
+ FOLDER_TYPE_RENAME = 2
+};
+
+class CThreadFolderOperations: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt() Z7_override;
+public:
+ EFolderOpType OpType;
+ UString Name;
+ UInt32 Index;
+ CRecordVector<UInt32> Indices;
+
+ CMyComPtr<IFolderOperations> FolderOperations;
+ CMyComPtr<IProgress> UpdateCallback;
+ CUpdateCallback100Imp *UpdateCallbackSpec;
+
+ CThreadFolderOperations(EFolderOpType opType): OpType(opType) {}
+ HRESULT DoOperation(CPanel &panel, const UString &progressTitle, const UString &titleError);
+};
+
+HRESULT CThreadFolderOperations::ProcessVirt()
+{
+ NCOM::CComInitializer comInitializer;
+ switch ((int)OpType)
+ {
+ case FOLDER_TYPE_CREATE_FOLDER:
+ return FolderOperations->CreateFolder(Name, UpdateCallback);
+ case FOLDER_TYPE_DELETE:
+ return FolderOperations->Delete(&Indices.Front(), Indices.Size(), UpdateCallback);
+ case FOLDER_TYPE_RENAME:
+ return FolderOperations->Rename(Index, Name, UpdateCallback);
+ default:
+ return E_FAIL;
+ }
+}
+
+
+HRESULT CThreadFolderOperations::DoOperation(CPanel &panel, const UString &progressTitle, const UString &titleError)
+{
+ UpdateCallbackSpec = new CUpdateCallback100Imp;
+ UpdateCallback = UpdateCallbackSpec;
+ UpdateCallbackSpec->ProgressDialog = this;
+
+ WaitMode = true;
+ Sync.FinalMessage.ErrorMessage.Title = titleError;
+
+ UpdateCallbackSpec->Init();
+
+ if (panel._parentFolders.Size() > 0)
+ {
+ const CFolderLink &fl = panel._parentFolders.Back();
+ UpdateCallbackSpec->PasswordIsDefined = fl.UsePassword;
+ UpdateCallbackSpec->Password = fl.Password;
+ }
+
+ MainWindow = panel._mainWindow; // panel.GetParent()
+ MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+ MainAddTitle = progressTitle + L' ';
+
+ RINOK(Create(progressTitle, MainWindow))
+ return Result;
+}
+
+#ifndef _UNICODE
+typedef int (WINAPI * Func_SHFileOperationW)(LPSHFILEOPSTRUCTW lpFileOp);
+#endif
+
+/*
+void CPanel::MessageBoxErrorForUpdate(HRESULT errorCode, UINT resourceID)
+{
+ if (errorCode == E_NOINTERFACE)
+ MessageBox_Error_UnsupportOperation();
+ else
+ MessageBox_Error_HRESULT_Caption(errorCode, LangString(resourceID));
+}
+*/
+
+void CPanel::DeleteItems(bool NON_CE_VAR(toRecycleBin))
+{
+ CDisableTimerProcessing disableTimerProcessing(*this);
+ CRecordVector<UInt32> indices;
+ Get_ItemIndices_Operated(indices);
+ if (indices.IsEmpty())
+ return;
+ CSelectedState state;
+ SaveSelectedState(state);
+
+ #ifndef UNDER_CE
+ // WM6 / SHFileOperationW doesn't ask user! So we use internal delete
+ if (IsFSFolder() && toRecycleBin)
+ {
+ bool useInternalDelete = false;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ CDynamicBuffer<CHAR> buffer;
+ FOR_VECTOR (i, indices)
+ {
+ const AString path (GetSystemString(GetItemFullPath(indices[i])));
+ buffer.AddData(path, path.Len() + 1);
+ }
+ *buffer.GetCurPtrAndGrow(1) = 0;
+ SHFILEOPSTRUCTA fo;
+ fo.hwnd = GetParent();
+ fo.wFunc = FO_DELETE;
+ fo.pFrom = (const CHAR *)buffer;
+ fo.pTo = NULL;
+ fo.fFlags = 0;
+ if (toRecycleBin)
+ fo.fFlags |= FOF_ALLOWUNDO;
+ // fo.fFlags |= FOF_NOCONFIRMATION;
+ // fo.fFlags |= FOF_NOERRORUI;
+ // fo.fFlags |= FOF_SILENT;
+ // fo.fFlags |= FOF_WANTNUKEWARNING;
+ fo.fAnyOperationsAborted = FALSE;
+ fo.hNameMappings = NULL;
+ fo.lpszProgressTitle = NULL;
+ /* int res = */ ::SHFileOperationA(&fo);
+ }
+ else
+ #endif
+ {
+ CDynamicBuffer<WCHAR> buffer;
+ unsigned maxLen = 0;
+ const UString prefix = GetFsPath();
+ FOR_VECTOR (i, indices)
+ {
+ // L"\\\\?\\") doesn't work here.
+ const UString path = prefix + GetItemRelPath2(indices[i]);
+ if (path.Len() > maxLen)
+ maxLen = path.Len();
+ buffer.AddData(path, path.Len() + 1);
+ }
+ *buffer.GetCurPtrAndGrow(1) = 0;
+ if (maxLen >= MAX_PATH)
+ {
+ if (toRecycleBin)
+ {
+ MessageBox_Error_LangID(IDS_ERROR_LONG_PATH_TO_RECYCLE);
+ return;
+ }
+ useInternalDelete = true;
+ }
+ else
+ {
+ SHFILEOPSTRUCTW fo;
+ fo.hwnd = GetParent();
+ fo.wFunc = FO_DELETE;
+ fo.pFrom = (const WCHAR *)buffer;
+ fo.pTo = NULL;
+ fo.fFlags = 0;
+ if (toRecycleBin)
+ fo.fFlags |= FOF_ALLOWUNDO;
+ fo.fAnyOperationsAborted = FALSE;
+ fo.hNameMappings = NULL;
+ fo.lpszProgressTitle = NULL;
+ // int res;
+ #ifdef _UNICODE
+ /* res = */ ::SHFileOperationW(&fo);
+ #else
+ Func_SHFileOperationW
+ f_SHFileOperationW = Z7_GET_PROC_ADDRESS(
+ Func_SHFileOperationW, ::GetModuleHandleW(L"shell32.dll"),
+ "SHFileOperationW");
+ if (!f_SHFileOperationW)
+ return;
+ /* res = */ f_SHFileOperationW(&fo);
+ #endif
+ }
+ }
+ /*
+ if (fo.fAnyOperationsAborted)
+ MessageBox_Error_HRESULT_Caption(result, LangString(IDS_ERROR_DELETING));
+ */
+ if (!useInternalDelete)
+ {
+ RefreshListCtrl(state);
+ return;
+ }
+ }
+ #endif
+
+ // DeleteItemsInternal
+
+ if (!CheckBeforeUpdate(IDS_ERROR_DELETING))
+ return;
+
+ UInt32 titleID, messageID;
+ UString messageParam;
+ if (indices.Size() == 1)
+ {
+ const unsigned index = indices[0];
+ messageParam = GetItemRelPath2(index);
+ if (IsItem_Folder(index))
+ {
+ titleID = IDS_CONFIRM_FOLDER_DELETE;
+ messageID = IDS_WANT_TO_DELETE_FOLDER;
+ }
+ else
+ {
+ titleID = IDS_CONFIRM_FILE_DELETE;
+ messageID = IDS_WANT_TO_DELETE_FILE;
+ }
+ }
+ else
+ {
+ titleID = IDS_CONFIRM_ITEMS_DELETE;
+ messageID = IDS_WANT_TO_DELETE_ITEMS;
+ messageParam = NumberToString(indices.Size());
+ }
+ if (::MessageBoxW(GetParent(), MyFormatNew(messageID, messageParam), LangString(titleID), MB_OKCANCEL | MB_ICONQUESTION) != IDOK)
+ return;
+
+ CDisableNotify disableNotify(*this);
+ {
+ CThreadFolderOperations op(FOLDER_TYPE_DELETE);
+ op.FolderOperations = _folderOperations;
+ op.Indices = indices;
+ op.DoOperation(*this,
+ LangString(IDS_DELETING),
+ LangString(IDS_ERROR_DELETING));
+ }
+ RefreshTitleAlways();
+ RefreshListCtrl(state);
+}
+
+BOOL CPanel::OnBeginLabelEdit(LV_DISPINFOW * lpnmh)
+{
+ const unsigned realIndex = GetRealIndex(lpnmh->item);
+ if (realIndex == kParentIndex)
+ return TRUE;
+ if (IsThereReadOnlyFolder())
+ return TRUE;
+ return FALSE;
+}
+
+static bool IsCorrectFsName(const UString &name)
+{
+ const UString lastPart = name.Ptr((unsigned)(name.ReverseFind_PathSepar() + 1));
+ return
+ lastPart != L"." &&
+ lastPart != L"..";
+}
+
+bool CorrectFsPath(const UString &relBase, const UString &path, UString &result);
+
+bool CPanel::CorrectFsPath(const UString &path2, UString &result)
+{
+ return ::CorrectFsPath(GetFsPath(), path2, result);
+}
+
+BOOL CPanel::OnEndLabelEdit(LV_DISPINFOW * lpnmh)
+{
+ if (lpnmh->item.pszText == NULL)
+ return FALSE;
+ CDisableTimerProcessing disableTimerProcessing2(*this);
+
+ if (!CheckBeforeUpdate(IDS_ERROR_RENAMING))
+ return FALSE;
+
+ UString newName = lpnmh->item.pszText;
+ if (!IsCorrectFsName(newName))
+ {
+ MessageBox_Error_HRESULT(E_INVALIDARG);
+ return FALSE;
+ }
+
+ if (IsFSFolder())
+ {
+ UString correctName;
+ if (!CorrectFsPath(newName, correctName))
+ {
+ MessageBox_Error_HRESULT(E_INVALIDARG);
+ return FALSE;
+ }
+ newName = correctName;
+ }
+
+ SaveSelectedState(_selectedState);
+
+ const unsigned realIndex = GetRealIndex(lpnmh->item);
+ if (realIndex == kParentIndex)
+ return FALSE;
+ const UString prefix = GetItemPrefix(realIndex);
+
+
+ CDisableNotify disableNotify(*this);
+ {
+ CThreadFolderOperations op(FOLDER_TYPE_RENAME);
+ op.FolderOperations = _folderOperations;
+ op.Index = realIndex;
+ op.Name = newName;
+ /* HRESULTres = */ op.DoOperation(*this,
+ LangString(IDS_RENAMING),
+ LangString(IDS_ERROR_RENAMING));
+ // fixed in 9.26: we refresh list even after errors
+ // (it's more safe, since error can be at different stages, so list can be incorrect).
+ /*
+ if (res != S_OK)
+ return FALSE;
+ */
+ }
+
+ // Can't use RefreshListCtrl here.
+ // RefreshListCtrlSaveFocused();
+ _selectedState.FocusedName = prefix + newName;
+ _selectedState.FocusedName_Defined = true;
+ _selectedState.SelectFocused = true;
+
+ // We need clear all items to disable GetText before Reload:
+ // number of items can change.
+ // DeleteListItems();
+ // But seems it can still call GetText (maybe for current item)
+ // so we can't delete items.
+
+ _dontShowMode = true;
+
+ PostMsg(kReLoadMessage);
+ return TRUE;
+}
+
+bool Dlg_CreateFolder(HWND wnd, UString &destName);
+
+void CPanel::CreateFolder()
+{
+ if (IsHashFolder())
+ return;
+
+ if (!CheckBeforeUpdate(IDS_CREATE_FOLDER_ERROR))
+ return;
+
+ CDisableTimerProcessing disableTimerProcessing2(*this);
+ CSelectedState state;
+ SaveSelectedState(state);
+
+ UString newName;
+ if (!Dlg_CreateFolder(GetParent(), newName))
+ return;
+
+ if (!IsCorrectFsName(newName))
+ {
+ MessageBox_Error_HRESULT(E_INVALIDARG);
+ return;
+ }
+
+ if (IsFSFolder())
+ {
+ UString correctName;
+ if (!CorrectFsPath(newName, correctName))
+ {
+ MessageBox_Error_HRESULT(E_INVALIDARG);
+ return;
+ }
+ newName = correctName;
+ }
+
+ HRESULT res;
+ CDisableNotify disableNotify(*this);
+ {
+ CThreadFolderOperations op(FOLDER_TYPE_CREATE_FOLDER);
+ op.FolderOperations = _folderOperations;
+ op.Name = newName;
+ res = op.DoOperation(*this,
+ LangString(IDS_CREATE_FOLDER),
+ LangString(IDS_CREATE_FOLDER_ERROR));
+ /*
+ // fixed for 9.26: we must refresh always
+ if (res != S_OK)
+ return;
+ */
+ }
+ if (res == S_OK)
+ {
+ int pos = newName.Find(WCHAR_PATH_SEPARATOR);
+ if (pos >= 0)
+ newName.DeleteFrom((unsigned)(pos));
+ if (!_mySelectMode)
+ state.SelectedNames.Clear();
+ state.FocusedName = newName;
+ state.FocusedName_Defined = true;
+ state.SelectFocused = true;
+ }
+ RefreshTitleAlways();
+ RefreshListCtrl(state);
+}
+
+void CPanel::CreateFile()
+{
+ if (IsHashFolder())
+ return;
+
+ if (!CheckBeforeUpdate(IDS_CREATE_FILE_ERROR))
+ return;
+
+ CDisableTimerProcessing disableTimerProcessing2(*this);
+ CSelectedState state;
+ SaveSelectedState(state);
+ CComboDialog dlg;
+ LangString(IDS_CREATE_FILE, dlg.Title);
+ LangString(IDS_CREATE_FILE_NAME, dlg.Static);
+ LangString(IDS_CREATE_FILE_DEFAULT_NAME, dlg.Value);
+
+ if (dlg.Create(GetParent()) != IDOK)
+ return;
+
+ CDisableNotify disableNotify(*this);
+
+ UString newName = dlg.Value;
+
+ if (IsFSFolder())
+ {
+ UString correctName;
+ if (!CorrectFsPath(newName, correctName))
+ {
+ MessageBox_Error_HRESULT(E_INVALIDARG);
+ return;
+ }
+ newName = correctName;
+ }
+
+ const HRESULT result = _folderOperations->CreateFile(newName, NULL);
+ if (result != S_OK)
+ {
+ MessageBox_Error_HRESULT_Caption(result, LangString(IDS_CREATE_FILE_ERROR));
+ // MessageBoxErrorForUpdate(result, IDS_CREATE_FILE_ERROR);
+ return;
+ }
+ const int pos = newName.Find(WCHAR_PATH_SEPARATOR);
+ if (pos >= 0)
+ newName.DeleteFrom((unsigned)pos);
+ if (!_mySelectMode)
+ state.SelectedNames.Clear();
+ state.FocusedName = newName;
+ state.FocusedName_Defined = true;
+ state.SelectFocused = true;
+ RefreshListCtrl(state);
+}
+
+void CPanel::RenameFile()
+{
+ if (!CheckBeforeUpdate(IDS_ERROR_RENAMING))
+ return;
+ int index = _listView.GetFocusedItem();
+ if (index >= 0)
+ _listView.EditLabel(index);
+}
+
+void CPanel::ChangeComment()
+{
+ if (IsHashFolder())
+ return;
+ if (!CheckBeforeUpdate(IDS_COMMENT))
+ return;
+ CDisableTimerProcessing disableTimerProcessing2(*this);
+ const int index = _listView.GetFocusedItem();
+ if (index < 0)
+ return;
+ const unsigned realIndex = GetRealItemIndex(index);
+ if (realIndex == kParentIndex)
+ return;
+ CSelectedState state;
+ SaveSelectedState(state);
+ UString comment;
+ {
+ NCOM::CPropVariant propVariant;
+ if (_folder->GetProperty(realIndex, kpidComment, &propVariant) != S_OK)
+ return;
+ if (propVariant.vt == VT_BSTR)
+ comment = propVariant.bstrVal;
+ else if (propVariant.vt != VT_EMPTY)
+ return;
+ }
+ const UString name = GetItemRelPath2(realIndex);
+ CComboDialog dlg;
+ dlg.Title = name;
+ dlg.Title += " : ";
+ AddLangString(dlg.Title, IDS_COMMENT);
+ dlg.Value = comment;
+ LangString(IDS_COMMENT2, dlg.Static);
+ if (dlg.Create(GetParent()) != IDOK)
+ return;
+ NCOM::CPropVariant propVariant (dlg.Value);
+
+ CDisableNotify disableNotify(*this);
+ const HRESULT result = _folderOperations->SetProperty(realIndex, kpidComment, &propVariant, NULL);
+ if (result != S_OK)
+ {
+ if (result == E_NOINTERFACE)
+ MessageBox_Error_UnsupportOperation();
+ else
+ MessageBox_Error_HRESULT_Caption(result, L"Set Comment Error");
+ }
+ RefreshListCtrl(state);
+}
diff --git a/CPP/7zip/UI/FileManager/PanelSelect.cpp b/CPP/7zip/UI/FileManager/PanelSelect.cpp
new file mode 100644
index 0000000..f7a16dd
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelSelect.cpp
@@ -0,0 +1,317 @@
+// PanelSelect.cpp
+
+#include "StdAfx.h"
+
+#include "resource.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "ComboDialog.h"
+#include "LangUtils.h"
+#include "Panel.h"
+
+void CPanel::OnShiftSelectMessage()
+{
+ if (!_mySelectMode)
+ return;
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ if (!_selectionIsDefined)
+ return;
+ int startItem = MyMin(focusedItem, _prevFocusedItem);
+ int finishItem = MyMax(focusedItem, _prevFocusedItem);
+
+ int numItems = _listView.GetItemCount();
+ for (int i = 0; i < numItems; i++)
+ {
+ const unsigned realIndex = GetRealItemIndex(i);
+ if (realIndex == kParentIndex)
+ continue;
+ if (i >= startItem && i <= finishItem)
+ if (_selectedStatusVector[realIndex] != _selectMark)
+ {
+ _selectedStatusVector[realIndex] = _selectMark;
+ _listView.RedrawItem(i);
+ }
+ }
+
+ _prevFocusedItem = focusedItem;
+}
+
+void CPanel::OnArrowWithShift()
+{
+ if (!_mySelectMode)
+ return;
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+
+ if (_selectionIsDefined)
+ {
+ if (realIndex != kParentIndex)
+ _selectedStatusVector[realIndex] = _selectMark;
+ }
+ else
+ {
+ if (realIndex == kParentIndex)
+ {
+ _selectionIsDefined = true;
+ _selectMark = true;
+ }
+ else
+ {
+ _selectionIsDefined = true;
+ _selectMark = !_selectedStatusVector[realIndex];
+ _selectedStatusVector[realIndex] = _selectMark;
+ }
+ }
+
+ _prevFocusedItem = focusedItem;
+ PostMsg(kShiftSelectMessage);
+ _listView.RedrawItem(focusedItem);
+}
+
+void CPanel::OnInsert()
+{
+ /*
+ const int kState = CDIS_MARKED; // LVIS_DROPHILITED;
+ UINT state = (_listView.GetItemState(focusedItem, LVIS_CUT) == 0) ?
+ LVIS_CUT : 0;
+ _listView.SetItemState(focusedItem, state, LVIS_CUT);
+ // _listView.SetItemState_Selected(focusedItem);
+ */
+
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ if (realIndex != kParentIndex)
+ {
+ bool isSelected = !_selectedStatusVector[realIndex];
+ _selectedStatusVector[realIndex] = isSelected;
+ if (!_mySelectMode)
+ _listView.SetItemState_Selected(focusedItem, isSelected);
+ _listView.RedrawItem(focusedItem);
+ }
+
+ int nextIndex = focusedItem + 1;
+ if (nextIndex < _listView.GetItemCount())
+ {
+ _listView.SetItemState_FocusedSelected(nextIndex);
+ _listView.EnsureVisible(nextIndex, false);
+ }
+}
+
+/*
+void CPanel::OnUpWithShift()
+{
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const int index = GetRealItemIndex(focusedItem);
+ if (index == kParentIndex)
+ return;
+ _selectedStatusVector[index] = !_selectedStatusVector[index];
+ _listView.RedrawItem(index);
+}
+
+void CPanel::OnDownWithShift()
+{
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const int index = GetRealItemIndex(focusedItem);
+ if (index == kParentIndex)
+ return;
+ _selectedStatusVector[index] = !_selectedStatusVector[index];
+ _listView.RedrawItem(index);
+}
+*/
+
+void CPanel::UpdateSelection()
+{
+ if (!_mySelectMode)
+ {
+ bool enableTemp = _enableItemChangeNotify;
+ _enableItemChangeNotify = false;
+ int numItems = _listView.GetItemCount();
+ for (int i = 0; i < numItems; i++)
+ {
+ const unsigned realIndex = GetRealItemIndex(i);
+ if (realIndex != kParentIndex)
+ _listView.SetItemState_Selected(i, _selectedStatusVector[realIndex]);
+ }
+ _enableItemChangeNotify = enableTemp;
+ }
+ _listView.RedrawAllItems();
+}
+
+
+void CPanel::SelectSpec(bool selectMode)
+{
+ CComboDialog dlg;
+ LangString(selectMode ? IDS_SELECT : IDS_DESELECT, dlg.Title );
+ LangString(IDS_SELECT_MASK, dlg.Static);
+ dlg.Value = '*';
+ if (dlg.Create(GetParent()) != IDOK)
+ return;
+ const UString &mask = dlg.Value;
+ FOR_VECTOR (i, _selectedStatusVector)
+ if (DoesWildcardMatchName(mask, GetItemName(i)))
+ _selectedStatusVector[i] = selectMode;
+ UpdateSelection();
+}
+
+void CPanel::SelectByType(bool selectMode)
+{
+ const int focusedItem = _listView.GetFocusedItem();
+ if (focusedItem < 0)
+ return;
+ const unsigned realIndex = GetRealItemIndex(focusedItem);
+ UString name = GetItemName(realIndex);
+ bool isItemFolder = IsItem_Folder(realIndex);
+
+ if (isItemFolder)
+ {
+ FOR_VECTOR (i, _selectedStatusVector)
+ if (IsItem_Folder(i) == isItemFolder)
+ _selectedStatusVector[i] = selectMode;
+ }
+ else
+ {
+ int pos = name.ReverseFind_Dot();
+ if (pos < 0)
+ {
+ FOR_VECTOR (i, _selectedStatusVector)
+ if (IsItem_Folder(i) == isItemFolder && GetItemName(i).ReverseFind_Dot() < 0)
+ _selectedStatusVector[i] = selectMode;
+ }
+ else
+ {
+ UString mask ('*');
+ mask += name.Ptr((unsigned)pos);
+ FOR_VECTOR (i, _selectedStatusVector)
+ if (IsItem_Folder(i) == isItemFolder && DoesWildcardMatchName(mask, GetItemName(i)))
+ _selectedStatusVector[i] = selectMode;
+ }
+ }
+
+ UpdateSelection();
+}
+
+void CPanel::SelectAll(bool selectMode)
+{
+ FOR_VECTOR (i, _selectedStatusVector)
+ _selectedStatusVector[i] = selectMode;
+ UpdateSelection();
+}
+
+void CPanel::InvertSelection()
+{
+ if (!_mySelectMode)
+ {
+ /*
+ unsigned numSelected = 0;
+ FOR_VECTOR (i, _selectedStatusVector)
+ if (_selectedStatusVector[i])
+ numSelected++;
+ */
+ // 17.02: fixed : now we invert item even, if single item is selected
+ /*
+ if (numSelected == 1)
+ {
+ int focused = _listView.GetFocusedItem();
+ if (focused >= 0)
+ {
+ const unsigned realIndex = GetRealItemIndex(focused);
+ if (realIndex >= 0)
+ if (_selectedStatusVector[realIndex])
+ _selectedStatusVector[realIndex] = false;
+ }
+ }
+ */
+ }
+ FOR_VECTOR (i, _selectedStatusVector)
+ _selectedStatusVector[i] = !_selectedStatusVector[i];
+ UpdateSelection();
+}
+
+void CPanel::KillSelection()
+{
+ SelectAll(false);
+ // ver 20.01: now we don't like that focused will be selected item.
+ // So the following code was disabled:
+ /*
+ if (!_mySelectMode)
+ {
+ int focused = _listView.GetFocusedItem();
+ if (focused >= 0)
+ {
+ // CPanel::OnItemChanged notify for LVIS_SELECTED change doesn't work here. Why?
+ // so we change _selectedStatusVector[realIndex] here.
+ const unsigned realIndex = GetRealItemIndex(focused);
+ if (realIndex != kParentIndex)
+ _selectedStatusVector[realIndex] = true;
+ _listView.SetItemState_Selected(focused);
+ }
+ }
+ */
+}
+
+void CPanel::OnLeftClick(MY_NMLISTVIEW_NMITEMACTIVATE *itemActivate)
+{
+ if (itemActivate->hdr.hwndFrom != HWND(_listView))
+ return;
+ // It will work only for Version 4.71 (IE 4);
+ int indexInList = itemActivate->iItem;
+ if (indexInList < 0)
+ return;
+
+ #ifndef UNDER_CE
+ if ((itemActivate->uKeyFlags & LVKF_SHIFT) != 0)
+ {
+ // int focusedIndex = _listView.GetFocusedItem();
+ const int focusedIndex = _startGroupSelect;
+ if (focusedIndex < 0)
+ return;
+ const int startItem = MyMin(focusedIndex, indexInList);
+ const int finishItem = MyMax(focusedIndex, indexInList);
+
+ const int numItems = _listView.GetItemCount();
+ for (int i = 0; i < numItems; i++)
+ {
+ const unsigned realIndex = GetRealItemIndex(i);
+ if (realIndex == kParentIndex)
+ continue;
+ const bool selected = (i >= startItem && i <= finishItem);
+ if (_selectedStatusVector[realIndex] != selected)
+ {
+ _selectedStatusVector[realIndex] = selected;
+ _listView.RedrawItem(i);
+ }
+ }
+ }
+ else
+ #endif
+ {
+ _startGroupSelect = indexInList;
+
+ #ifndef UNDER_CE
+ if ((itemActivate->uKeyFlags & LVKF_CONTROL) != 0)
+ {
+ const unsigned realIndex = GetRealItemIndex(indexInList);
+ if (realIndex != kParentIndex)
+ {
+ _selectedStatusVector[realIndex] = !_selectedStatusVector[realIndex];
+ _listView.RedrawItem(indexInList);
+ }
+ }
+ #endif
+ }
+
+ return;
+}
diff --git a/CPP/7zip/UI/FileManager/PanelSort.cpp b/CPP/7zip/UI/FileManager/PanelSort.cpp
new file mode 100644
index 0000000..f95f8ee
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelSort.cpp
@@ -0,0 +1,269 @@
+// PanelSort.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#include "Panel.h"
+
+using namespace NWindows;
+
+int CompareFileNames_ForFolderList(const wchar_t *s1, const wchar_t *s2)
+{
+ for (;;)
+ {
+ wchar_t c1 = *s1;
+ wchar_t c2 = *s2;
+ if ((c1 >= '0' && c1 <= '9') &&
+ (c2 >= '0' && c2 <= '9'))
+ {
+ for (; *s1 == '0'; s1++);
+ for (; *s2 == '0'; s2++);
+ size_t len1 = 0;
+ size_t len2 = 0;
+ for (; (s1[len1] >= '0' && s1[len1] <= '9'); len1++);
+ for (; (s2[len2] >= '0' && s2[len2] <= '9'); len2++);
+ if (len1 < len2) return -1;
+ if (len1 > len2) return 1;
+ for (; len1 > 0; s1++, s2++, len1--)
+ {
+ if (*s1 == *s2) continue;
+ return (*s1 < *s2) ? -1 : 1;
+ }
+ c1 = *s1;
+ c2 = *s2;
+ }
+ s1++;
+ s2++;
+ if (c1 != c2)
+ {
+ // Probably we need to change the order for special characters like in Explorer.
+ wchar_t u1 = MyCharUpper(c1);
+ wchar_t u2 = MyCharUpper(c2);
+ if (u1 < u2) return -1;
+ if (u1 > u2) return 1;
+ }
+ if (c1 == 0) return 0;
+ }
+}
+
+static int CompareFileNames_Le16(const Byte *s1, unsigned size1, const Byte *s2, unsigned size2)
+{
+ size1 &= ~1u;
+ size2 &= ~1u;
+ for (unsigned i = 0;; i += 2)
+ {
+ if (i >= size1)
+ return (i >= size2) ? 0 : -1;
+ if (i >= size2)
+ return 1;
+ UInt16 c1 = GetUi16(s1 + i);
+ UInt16 c2 = GetUi16(s2 + i);
+ if (c1 == c2)
+ {
+ if (c1 == 0)
+ return 0;
+ continue;
+ }
+ if (c1 < c2)
+ return -1;
+ return 1;
+ }
+}
+
+static inline const wchar_t *GetExtensionPtr(const UString &name)
+{
+ const int dotPos = name.ReverseFind_Dot();
+ return name.Ptr(dotPos < 0 ? name.Len() : (unsigned)dotPos);
+}
+
+void CPanel::SetSortRawStatus()
+{
+ _isRawSortProp = false;
+ FOR_VECTOR (i, _columns)
+ {
+ const CPropColumn &prop = _columns[i];
+ if (prop.ID == _sortID)
+ {
+ _isRawSortProp = prop.IsRawProp ? 1 : 0;
+ return;
+ }
+ }
+}
+
+
+static int CALLBACK CompareItems2(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
+{
+ if (lpData == 0)
+ return 0;
+ CPanel *panel = (CPanel*)lpData;
+
+
+ PROPID propID = panel->_sortID;
+
+ if (propID == kpidNoProperty)
+ return MyCompare(lParam1, lParam2);
+
+ if (panel->_isRawSortProp)
+ {
+ // Sha1, NtSecurity, NtReparse
+ const void *data1;
+ const void *data2;
+ UInt32 dataSize1;
+ UInt32 dataSize2;
+ UInt32 propType1;
+ UInt32 propType2;
+ if (panel->_folderRawProps->GetRawProp((UInt32)lParam1, propID, &data1, &dataSize1, &propType1) != 0) return 0;
+ if (panel->_folderRawProps->GetRawProp((UInt32)lParam2, propID, &data2, &dataSize2, &propType2) != 0) return 0;
+ if (dataSize1 == 0)
+ return (dataSize2 == 0) ? 0 : -1;
+ if (dataSize2 == 0)
+ return 1;
+ if (propType1 != NPropDataType::kRaw) return 0;
+ if (propType2 != NPropDataType::kRaw) return 0;
+ if (propID == kpidNtReparse)
+ {
+ NFile::CReparseShortInfo r1; r1.Parse((const Byte *)data1, dataSize1);
+ NFile::CReparseShortInfo r2; r2.Parse((const Byte *)data2, dataSize2);
+ return CompareFileNames_Le16(
+ (const Byte *)data1 + r1.Offset, r1.Size,
+ (const Byte *)data2 + r2.Offset, r2.Size);
+ }
+ }
+
+ if (panel->_folderCompare)
+ return panel->_folderCompare->CompareItems((UInt32)lParam1, (UInt32)lParam2, propID, panel->_isRawSortProp);
+
+ switch (propID)
+ {
+ // if (panel->_sortIndex == 0)
+ case kpidName:
+ {
+ const UString name1 = panel->GetItemName((unsigned)lParam1);
+ const UString name2 = panel->GetItemName((unsigned)lParam2);
+ const int res = CompareFileNames_ForFolderList(name1, name2);
+ /*
+ if (res != 0 || !panel->_flatMode)
+ return res;
+ const UString prefix1 = panel->GetItemPrefix(lParam1);
+ const UString prefix2 = panel->GetItemPrefix(lParam2);
+ return res = CompareFileNames_ForFolderList(prefix1, prefix2);
+ */
+ return res;
+ }
+ case kpidExtension:
+ {
+ const UString name1 = panel->GetItemName((unsigned)lParam1);
+ const UString name2 = panel->GetItemName((unsigned)lParam2);
+ return CompareFileNames_ForFolderList(
+ GetExtensionPtr(name1),
+ GetExtensionPtr(name2));
+ }
+ }
+ /*
+ if (panel->_sortIndex == 1)
+ return MyCompare(file1.Size, file2.Size);
+ return ::CompareFileTime(&file1.MTime, &file2.MTime);
+ */
+
+ // PROPID propID = panel->_columns[panel->_sortIndex].ID;
+
+ NCOM::CPropVariant prop1, prop2;
+ // Name must be first property
+ panel->_folder->GetProperty((UInt32)lParam1, propID, &prop1);
+ panel->_folder->GetProperty((UInt32)lParam2, propID, &prop2);
+ if (prop1.vt != prop2.vt)
+ return MyCompare(prop1.vt, prop2.vt);
+ if (prop1.vt == VT_BSTR)
+ return MyStringCompareNoCase(prop1.bstrVal, prop2.bstrVal);
+ return prop1.Compare(prop2);
+}
+
+int CALLBACK CompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData);
+int CALLBACK CompareItems(LPARAM lParam1, LPARAM lParam2, LPARAM lpData)
+{
+ if (lpData == 0) return 0;
+ if (lParam1 == (int)kParentIndex) return -1;
+ if (lParam2 == (int)kParentIndex) return 1;
+
+ CPanel *panel = (CPanel*)lpData;
+
+ const bool isDir1 = panel->IsItem_Folder((unsigned)lParam1);
+ const bool isDir2 = panel->IsItem_Folder((unsigned)lParam2);
+
+ if (isDir1 && !isDir2) return -1;
+ if (isDir2 && !isDir1) return 1;
+
+ const int result = CompareItems2(lParam1, lParam2, lpData);
+ return panel->_ascending ? result: (-result);
+}
+
+
+/*
+void CPanel::SortItems(int index)
+{
+ if (index == _sortIndex)
+ _ascending = !_ascending;
+ else
+ {
+ _sortIndex = index;
+ _ascending = true;
+ switch (_columns[_sortIndex].ID)
+ {
+ case kpidSize:
+ case kpidPackedSize:
+ case kpidCTime:
+ case kpidATime:
+ case kpidMTime:
+ _ascending = false;
+ break;
+ }
+ }
+ _listView.SortItems(CompareItems, (LPARAM)this);
+ _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+void CPanel::SortItemsWithPropID(PROPID propID)
+{
+ int index = _columns.FindItem_for_PropID(propID);
+ if (index >= 0)
+ SortItems(index);
+}
+*/
+
+void CPanel::SortItemsWithPropID(PROPID propID)
+{
+ if (propID == _sortID)
+ _ascending = !_ascending;
+ else
+ {
+ _sortID = propID;
+ _ascending = true;
+ switch (propID)
+ {
+ case kpidSize:
+ case kpidPackSize:
+ case kpidCTime:
+ case kpidATime:
+ case kpidMTime:
+ _ascending = false;
+ break;
+ }
+ }
+ SetSortRawStatus();
+ _listView.SortItems(CompareItems, (LPARAM)this);
+ _listView.EnsureVisible(_listView.GetFocusedItem(), false);
+}
+
+
+void CPanel::OnColumnClick(LPNMLISTVIEW info)
+{
+ /*
+ int index = _columns.FindItem_for_PropID(_visibleColumns[info->iSubItem].ID);
+ SortItems(index);
+ */
+ SortItemsWithPropID(_visibleColumns[info->iSubItem].ID);
+}
diff --git a/CPP/7zip/UI/FileManager/PanelSplitFile.cpp b/CPP/7zip/UI/FileManager/PanelSplitFile.cpp
new file mode 100644
index 0000000..64aa039
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PanelSplitFile.cpp
@@ -0,0 +1,562 @@
+// PanelSplitFile.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/FileName.h"
+
+#include "../GUI/ExtractRes.h"
+
+#include "resource.h"
+
+#include "App.h"
+#include "CopyDialog.h"
+#include "FormatUtils.h"
+#include "LangUtils.h"
+#include "SplitDialog.h"
+#include "SplitUtils.h"
+
+#include "PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static const char * const g_Message_FileWriteError = "File write error";
+
+struct CVolSeqName
+{
+ UString UnchangedPart;
+ UString ChangedPart;
+ CVolSeqName(): ChangedPart("000") {}
+
+ void SetNumDigits(UInt64 numVolumes)
+ {
+ ChangedPart = "000";
+ while (numVolumes > 999)
+ {
+ numVolumes /= 10;
+ ChangedPart += '0';
+ }
+ }
+
+ bool ParseName(const UString &name)
+ {
+ if (name.Len() < 2)
+ return false;
+ if (name.Back() != L'1' || name[name.Len() - 2] != L'0')
+ return false;
+
+ unsigned pos = name.Len() - 2;
+ for (; pos > 0 && name[pos - 1] == '0'; pos--);
+ UnchangedPart.SetFrom(name, pos);
+ ChangedPart = name.Ptr(pos);
+ return true;
+ }
+
+ UString GetNextName();
+};
+
+
+UString CVolSeqName::GetNextName()
+{
+ for (int i = (int)ChangedPart.Len() - 1; i >= 0; i--)
+ {
+ const wchar_t c = ChangedPart[i];
+ if (c != L'9')
+ {
+ ChangedPart.ReplaceOneCharAtPos((unsigned)i, (wchar_t)(c + 1));
+ break;
+ }
+ ChangedPart.ReplaceOneCharAtPos((unsigned)i, L'0');
+ if (i == 0)
+ ChangedPart.InsertAtFront(L'1');
+ }
+ return UnchangedPart + ChangedPart;
+}
+
+class CThreadSplit: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt() Z7_override;
+public:
+ FString FilePath;
+ FString VolBasePath;
+ UInt64 NumVolumes;
+ CRecordVector<UInt64> VolumeSizes;
+};
+
+
+class CPreAllocOutFile
+{
+ UInt64 _preAllocSize;
+public:
+ NIO::COutFile File;
+ UInt64 Written;
+
+ CPreAllocOutFile(): _preAllocSize(0), Written(0) {}
+
+ ~CPreAllocOutFile()
+ {
+ SetCorrectFileLength();
+ }
+
+ void PreAlloc(UInt64 preAllocSize)
+ {
+ _preAllocSize = 0;
+ if (File.SetLength(preAllocSize))
+ _preAllocSize = preAllocSize;
+ File.SeekToBegin();
+ }
+
+ bool Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
+ {
+ bool res = File.Write(data, size, processedSize);
+ Written += processedSize;
+ return res;
+ }
+
+ void Close()
+ {
+ SetCorrectFileLength();
+ Written = 0;
+ _preAllocSize = 0;
+ File.Close();
+ }
+
+ void SetCorrectFileLength()
+ {
+ if (Written < _preAllocSize)
+ {
+ File.SetLength(Written);
+ _preAllocSize = 0;
+ }
+ }
+};
+
+
+static const UInt32 kBufSize = (1 << 20);
+
+HRESULT CThreadSplit::ProcessVirt()
+{
+ NIO::CInFile inFile;
+ if (!inFile.Open(FilePath))
+ return GetLastError_noZero_HRESULT();
+
+ CPreAllocOutFile outFile;
+
+ CMyBuffer buffer;
+ if (!buffer.Allocate(kBufSize))
+ return E_OUTOFMEMORY;
+
+ CVolSeqName seqName;
+ seqName.SetNumDigits(NumVolumes);
+
+ UInt64 length;
+ if (!inFile.GetLength(length))
+ return GetLastError_noZero_HRESULT();
+
+ CProgressSync &sync = Sync;
+ sync.Set_NumBytesTotal(length);
+
+ UInt64 pos = 0;
+ UInt64 prev = 0;
+ UInt64 numFiles = 0;
+ unsigned volIndex = 0;
+
+ for (;;)
+ {
+ UInt64 volSize;
+ if (volIndex < VolumeSizes.Size())
+ volSize = VolumeSizes[volIndex];
+ else
+ volSize = VolumeSizes.Back();
+
+ UInt32 needSize = kBufSize;
+ {
+ const UInt64 rem = volSize - outFile.Written;
+ if (needSize > rem)
+ needSize = (UInt32)rem;
+ }
+ UInt32 processedSize;
+ if (!inFile.Read(buffer, needSize, processedSize))
+ return GetLastError_noZero_HRESULT();
+ if (processedSize == 0)
+ return S_OK;
+ needSize = processedSize;
+
+ if (outFile.Written == 0)
+ {
+ FString name = VolBasePath;
+ name.Add_Dot();
+ name += us2fs(seqName.GetNextName());
+ sync.Set_FilePath(fs2us(name));
+ if (!outFile.File.Create(name, false))
+ {
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ AddErrorPath(name);
+ return res;
+ }
+ UInt64 expectSize = volSize;
+ if (pos < length)
+ {
+ const UInt64 rem = length - pos;
+ if (expectSize > rem)
+ expectSize = rem;
+ }
+ outFile.PreAlloc(expectSize);
+ }
+
+ if (!outFile.Write(buffer, needSize, processedSize))
+ return GetLastError_noZero_HRESULT();
+ if (needSize != processedSize)
+ throw g_Message_FileWriteError;
+
+ pos += processedSize;
+
+ if (outFile.Written == volSize)
+ {
+ outFile.Close();
+ sync.Set_NumFilesCur(++numFiles);
+ if (volIndex < VolumeSizes.Size())
+ volIndex++;
+ }
+
+ if (pos - prev >= ((UInt32)1 << 22) || outFile.Written == 0)
+ {
+ RINOK(sync.Set_NumBytesCur(pos))
+ prev = pos;
+ }
+ }
+}
+
+
+void CApp::Split()
+{
+ const unsigned srcPanelIndex = GetFocusedPanelIndex();
+ CPanel &srcPanel = Panels[srcPanelIndex];
+ if (!srcPanel.Is_IO_FS_Folder())
+ {
+ srcPanel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+ CRecordVector<UInt32> indices;
+ srcPanel.Get_ItemIndices_Operated(indices);
+ if (indices.IsEmpty())
+ return;
+ if (indices.Size() != 1)
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_SELECT_ONE_FILE);
+ return;
+ }
+ const unsigned index = indices[0];
+ if (srcPanel.IsItem_Folder(index))
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_SELECT_ONE_FILE);
+ return;
+ }
+ const UString itemName = srcPanel.GetItemName(index);
+
+ const UString srcPath = srcPanel.GetFsPath() + srcPanel.GetItemPrefix(index);
+ UString path = srcPath;
+ unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+ CPanel &destPanel = Panels[destPanelIndex];
+ if (NumPanels > 1)
+ if (destPanel.IsFSFolder())
+ path = destPanel.GetFsPath();
+ CSplitDialog splitDialog;
+ splitDialog.FilePath = srcPanel.GetItemRelPath(index);
+ splitDialog.Path = path;
+ if (splitDialog.Create(srcPanel.GetParent()) != IDOK)
+ return;
+
+ NFind::CFileInfo fileInfo;
+ if (!fileInfo.Find(us2fs(srcPath + itemName)))
+ {
+ srcPanel.MessageBox_Error(L"Cannot find file");
+ return;
+ }
+ if (fileInfo.Size <= splitDialog.VolumeSizes.Front())
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_SPLIT_VOL_MUST_BE_SMALLER);
+ return;
+ }
+ const UInt64 numVolumes = GetNumberOfVolumes(fileInfo.Size, splitDialog.VolumeSizes);
+ if (numVolumes >= 100)
+ {
+ wchar_t s[32];
+ ConvertUInt64ToString(numVolumes, s);
+ if (::MessageBoxW(srcPanel, MyFormatNew(IDS_SPLIT_CONFIRM_MESSAGE, s),
+ LangString(IDS_SPLIT_CONFIRM_TITLE),
+ MB_YESNOCANCEL | MB_ICONQUESTION) != IDYES)
+ return;
+ }
+
+ path = splitDialog.Path;
+ NName::NormalizeDirPathPrefix(path);
+ if (!CreateComplexDir(us2fs(path)))
+ {
+ const HRESULT lastError = GetLastError_noZero_HRESULT();
+ srcPanel.MessageBox_Error_2Lines_Message_HRESULT(MyFormatNew(IDS_CANNOT_CREATE_FOLDER, path), lastError);
+ return;
+ }
+
+ {
+ CThreadSplit spliter;
+ spliter.NumVolumes = numVolumes;
+
+ CProgressDialog &progressDialog = spliter;
+
+ const UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE, 0x03000000);
+ const UString title = LangString(IDS_SPLITTING);
+
+ progressDialog.ShowCompressionInfo = false;
+
+ progressDialog.MainWindow = _window;
+ progressDialog.MainTitle = progressWindowTitle;
+ progressDialog.MainAddTitle = title;
+ progressDialog.MainAddTitle.Add_Space();
+ progressDialog.Sync.Set_TitleFileName(itemName);
+
+
+ spliter.FilePath = us2fs(srcPath + itemName);
+ spliter.VolBasePath = us2fs(path + srcPanel.GetItemName_for_Copy(index));
+ spliter.VolumeSizes = splitDialog.VolumeSizes;
+
+ // if (splitDialog.VolumeSizes.Size() == 0) return;
+
+ // CPanel::CDisableTimerProcessing disableTimerProcessing1(srcPanel);
+ // CPanel::CDisableTimerProcessing disableTimerProcessing2(destPanel);
+
+ if (spliter.Create(title, _window) != 0)
+ return;
+ }
+ RefreshTitleAlways();
+
+
+ // disableNotify.Restore();
+ // disableNotify.Restore();
+ // srcPanel.SetFocusToList();
+ // srcPanel.RefreshListCtrlSaveFocused();
+}
+
+
+class CThreadCombine: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt() Z7_override;
+public:
+ FString InputDirPrefix;
+ FStringVector Names;
+ FString OutputPath;
+ UInt64 TotalSize;
+};
+
+HRESULT CThreadCombine::ProcessVirt()
+{
+ NIO::COutFile outFile;
+ if (!outFile.Create(OutputPath, false))
+ {
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ AddErrorPath(OutputPath);
+ return res;
+ }
+
+ CProgressSync &sync = Sync;
+ sync.Set_NumBytesTotal(TotalSize);
+
+ CMyBuffer bufferObject;
+ if (!bufferObject.Allocate(kBufSize))
+ return E_OUTOFMEMORY;
+ Byte *buffer = (Byte *)(void *)bufferObject;
+ UInt64 pos = 0;
+ FOR_VECTOR (i, Names)
+ {
+ NIO::CInFile inFile;
+ const FString nextName = InputDirPrefix + Names[i];
+ if (!inFile.Open(nextName))
+ {
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ AddErrorPath(nextName);
+ return res;
+ }
+ sync.Set_FilePath(fs2us(nextName));
+ for (;;)
+ {
+ UInt32 processedSize;
+ if (!inFile.Read(buffer, kBufSize, processedSize))
+ {
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ AddErrorPath(nextName);
+ return res;
+ }
+ if (processedSize == 0)
+ break;
+ const UInt32 needSize = processedSize;
+ if (!outFile.Write(buffer, needSize, processedSize))
+ {
+ const HRESULT res = GetLastError_noZero_HRESULT();
+ AddErrorPath(OutputPath);
+ return res;
+ }
+ if (needSize != processedSize)
+ throw g_Message_FileWriteError;
+ pos += processedSize;
+ RINOK(sync.Set_NumBytesCur(pos))
+ }
+ }
+ return S_OK;
+}
+
+extern void AddValuePair2(UString &s, UINT resourceID, UInt64 num, UInt64 size);
+
+static void AddInfoFileName(UString &dest, const UString &name)
+{
+ dest += "\n ";
+ dest += name;
+}
+
+void CApp::Combine()
+{
+ const unsigned srcPanelIndex = GetFocusedPanelIndex();
+ CPanel &srcPanel = Panels[srcPanelIndex];
+ if (!srcPanel.IsFSFolder())
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_OPERATION_IS_NOT_SUPPORTED);
+ return;
+ }
+ CRecordVector<UInt32> indices;
+ srcPanel.Get_ItemIndices_Operated(indices);
+ if (indices.IsEmpty())
+ return;
+ const unsigned index = indices[0];
+ if (indices.Size() != 1 || srcPanel.IsItem_Folder(index))
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_COMBINE_SELECT_ONE_FILE);
+ return;
+ }
+ const UString itemName = srcPanel.GetItemName(index);
+
+ UString srcPath = srcPanel.GetFsPath() + srcPanel.GetItemPrefix(index);
+ UString path = srcPath;
+ unsigned destPanelIndex = (NumPanels <= 1) ? srcPanelIndex : (1 - srcPanelIndex);
+ CPanel &destPanel = Panels[destPanelIndex];
+ if (NumPanels > 1)
+ if (destPanel.IsFSFolder())
+ path = destPanel.GetFsPath();
+
+ CVolSeqName volSeqName;
+ if (!volSeqName.ParseName(itemName))
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_COMBINE_CANT_DETECT_SPLIT_FILE);
+ return;
+ }
+
+ {
+ CThreadCombine combiner;
+
+ UString nextName = itemName;
+ combiner.TotalSize = 0;
+ for (;;)
+ {
+ NFind::CFileInfo fileInfo;
+ if (!fileInfo.Find(us2fs(srcPath + nextName)) || fileInfo.IsDir())
+ break;
+ combiner.Names.Add(us2fs(nextName));
+ combiner.TotalSize += fileInfo.Size;
+ nextName = volSeqName.GetNextName();
+ }
+ if (combiner.Names.Size() == 1)
+ {
+ srcPanel.MessageBox_Error_LangID(IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART);
+ return;
+ }
+
+ if (combiner.TotalSize == 0)
+ {
+ srcPanel.MessageBox_Error(L"No data");
+ return;
+ }
+
+ UString info;
+ AddValuePair2(info, IDS_PROP_FILES, combiner.Names.Size(), combiner.TotalSize);
+
+ info.Add_LF();
+ info += srcPath;
+
+ unsigned i;
+ for (i = 0; i < combiner.Names.Size() && i < 2; i++)
+ AddInfoFileName(info, fs2us(combiner.Names[i]));
+ if (i != combiner.Names.Size())
+ {
+ if (i + 1 != combiner.Names.Size())
+ AddInfoFileName(info, L"...");
+ AddInfoFileName(info, fs2us(combiner.Names.Back()));
+ }
+
+ {
+ CCopyDialog copyDialog;
+ copyDialog.Value = path;
+ LangString(IDS_COMBINE, copyDialog.Title);
+ copyDialog.Title.Add_Space();
+ copyDialog.Title += srcPanel.GetItemRelPath(index);
+ LangString(IDS_COMBINE_TO, copyDialog.Static);
+ copyDialog.Info = info;
+ if (copyDialog.Create(srcPanel.GetParent()) != IDOK)
+ return;
+ path = copyDialog.Value;
+ }
+
+ NName::NormalizeDirPathPrefix(path);
+ if (!CreateComplexDir(us2fs(path)))
+ {
+ const HRESULT lastError = GetLastError_noZero_HRESULT();
+ srcPanel.MessageBox_Error_2Lines_Message_HRESULT(MyFormatNew(IDS_CANNOT_CREATE_FOLDER, path), lastError);
+ return;
+ }
+
+ UString outName = volSeqName.UnchangedPart;
+ while (!outName.IsEmpty())
+ {
+ if (outName.Back() != L'.')
+ break;
+ outName.DeleteBack();
+ }
+ if (outName.IsEmpty())
+ outName = "file";
+
+ NFind::CFileInfo fileInfo;
+ UString destFilePath = path + outName;
+ combiner.OutputPath = us2fs(destFilePath);
+ if (fileInfo.Find(combiner.OutputPath))
+ {
+ srcPanel.MessageBox_Error(MyFormatNew(IDS_FILE_EXIST, destFilePath));
+ return;
+ }
+
+ CProgressDialog &progressDialog = combiner;
+ progressDialog.ShowCompressionInfo = false;
+
+ const UString progressWindowTitle ("7-Zip"); // LangString(IDS_APP_TITLE, 0x03000000);
+ const UString title = LangString(IDS_COMBINING);
+
+ progressDialog.MainWindow = _window;
+ progressDialog.MainTitle = progressWindowTitle;
+ progressDialog.MainAddTitle = title;
+ progressDialog.MainAddTitle.Add_Space();
+
+ combiner.InputDirPrefix = us2fs(srcPath);
+
+ // CPanel::CDisableTimerProcessing disableTimerProcessing1(srcPanel);
+ // CPanel::CDisableTimerProcessing disableTimerProcessing2(destPanel);
+
+ if (combiner.Create(title, _window) != 0)
+ return;
+ }
+ RefreshTitleAlways();
+
+ // disableNotify.Restore();
+ // disableNotify.Restore();
+ // srcPanel.SetFocusToList();
+ // srcPanel.RefreshListCtrlSaveFocused();
+}
diff --git a/CPP/7zip/UI/FileManager/PasswordDialog.cpp b/CPP/7zip/UI/FileManager/PasswordDialog.cpp
index 95e83fe..bf99580 100644
--- a/CPP/7zip/UI/FileManager/PasswordDialog.cpp
+++ b/CPP/7zip/UI/FileManager/PasswordDialog.cpp
@@ -1,58 +1,58 @@
-// PasswordDialog.cpp
-
-#include "StdAfx.h"
-
-#include "PasswordDialog.h"
-
-#ifdef LANG
-#include "LangUtils.h"
-#endif
-
-#ifdef LANG
-static const UInt32 kLangIDs[] =
-{
- IDT_PASSWORD_ENTER,
- IDX_PASSWORD_SHOW
-};
-#endif
-
-void CPasswordDialog::ReadControls()
-{
- _passwordEdit.GetText(Password);
- ShowPassword = IsButtonCheckedBool(IDX_PASSWORD_SHOW);
-}
-
-void CPasswordDialog::SetTextSpec()
-{
- _passwordEdit.SetPasswordChar(ShowPassword ? 0: TEXT('*'));
- _passwordEdit.SetText(Password);
-}
-
-bool CPasswordDialog::OnInit()
-{
- #ifdef LANG
- LangSetWindowText(*this, IDD_PASSWORD);
- LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
- #endif
- _passwordEdit.Attach(GetItem(IDE_PASSWORD_PASSWORD));
- CheckButton(IDX_PASSWORD_SHOW, ShowPassword);
- SetTextSpec();
- return CModalDialog::OnInit();
-}
-
-bool CPasswordDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- if (buttonID == IDX_PASSWORD_SHOW)
- {
- ReadControls();
- SetTextSpec();
- return true;
- }
- return CDialog::OnButtonClicked(buttonID, buttonHWND);
-}
-
-void CPasswordDialog::OnOK()
-{
- ReadControls();
- CModalDialog::OnOK();
-}
+// PasswordDialog.cpp
+
+#include "StdAfx.h"
+
+#include "PasswordDialog.h"
+
+#ifdef Z7_LANG
+#include "LangUtils.h"
+#endif
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_PASSWORD_ENTER,
+ IDX_PASSWORD_SHOW
+};
+#endif
+
+void CPasswordDialog::ReadControls()
+{
+ _passwordEdit.GetText(Password);
+ ShowPassword = IsButtonCheckedBool(IDX_PASSWORD_SHOW);
+}
+
+void CPasswordDialog::SetTextSpec()
+{
+ _passwordEdit.SetPasswordChar(ShowPassword ? 0: TEXT('*'));
+ _passwordEdit.SetText(Password);
+}
+
+bool CPasswordDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_PASSWORD);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ #endif
+ _passwordEdit.Attach(GetItem(IDE_PASSWORD_PASSWORD));
+ CheckButton(IDX_PASSWORD_SHOW, ShowPassword);
+ SetTextSpec();
+ return CModalDialog::OnInit();
+}
+
+bool CPasswordDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ if (buttonID == IDX_PASSWORD_SHOW)
+ {
+ ReadControls();
+ SetTextSpec();
+ return true;
+ }
+ return CDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CPasswordDialog::OnOK()
+{
+ ReadControls();
+ CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/PasswordDialog.h b/CPP/7zip/UI/FileManager/PasswordDialog.h
index b756a1c..e05c4ad 100644
--- a/CPP/7zip/UI/FileManager/PasswordDialog.h
+++ b/CPP/7zip/UI/FileManager/PasswordDialog.h
@@ -1,28 +1,28 @@
-// PasswordDialog.h
-
-#ifndef __PASSWORD_DIALOG_H
-#define __PASSWORD_DIALOG_H
-
-#include "../../../Windows/Control/Dialog.h"
-#include "../../../Windows/Control/Edit.h"
-
-#include "PasswordDialogRes.h"
-
-class CPasswordDialog: public NWindows::NControl::CModalDialog
-{
- NWindows::NControl::CEdit _passwordEdit;
-
- virtual void OnOK();
- virtual bool OnInit();
- virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
- void SetTextSpec();
- void ReadControls();
-public:
- UString Password;
- bool ShowPassword;
-
- CPasswordDialog(): ShowPassword(false) {}
- INT_PTR Create(HWND parentWindow = 0) { return CModalDialog::Create(IDD_PASSWORD, parentWindow); }
-};
-
-#endif
+// PasswordDialog.h
+
+#ifndef ZIP7_INC_PASSWORD_DIALOG_H
+#define ZIP7_INC_PASSWORD_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "PasswordDialogRes.h"
+
+class CPasswordDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CEdit _passwordEdit;
+
+ virtual void OnOK() Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ void SetTextSpec();
+ void ReadControls();
+public:
+ UString Password;
+ bool ShowPassword;
+
+ CPasswordDialog(): ShowPassword(false) {}
+ INT_PTR Create(HWND parentWindow = NULL) { return CModalDialog::Create(IDD_PASSWORD, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PasswordDialog.rc b/CPP/7zip/UI/FileManager/PasswordDialog.rc
index 51dd5bc..90c57ef 100644
--- a/CPP/7zip/UI/FileManager/PasswordDialog.rc
+++ b/CPP/7zip/UI/FileManager/PasswordDialog.rc
@@ -1,14 +1,14 @@
-#include "PasswordDialogRes.h"
-#include "../../GuiCommon.rc"
-
-#define xc 140
-#define yc 72
-
-IDD_PASSWORD DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "Enter password"
-BEGIN
- LTEXT "&Enter password:", IDT_PASSWORD_ENTER, m, m, xc, 8
- EDITTEXT IDE_PASSWORD_PASSWORD, m, 20, xc, 14, ES_PASSWORD | ES_AUTOHSCROLL
- CONTROL "&Show password", IDX_PASSWORD_SHOW, MY_CHECKBOX, m, 42, xc, 10
- OK_CANCEL
-END
+#include "PasswordDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 140
+#define yc 72
+
+IDD_PASSWORD DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Enter password"
+BEGIN
+ LTEXT "&Enter password:", IDT_PASSWORD_ENTER, m, m, xc, 8
+ EDITTEXT IDE_PASSWORD_PASSWORD, m, 20, xc, 14, ES_PASSWORD | ES_AUTOHSCROLL
+ CONTROL "&Show password", IDX_PASSWORD_SHOW, MY_CHECKBOX, m, 42, xc, 10
+ OK_CANCEL
+END
diff --git a/CPP/7zip/UI/FileManager/PasswordDialogRes.h b/CPP/7zip/UI/FileManager/PasswordDialogRes.h
index f9300d6..1fe32e1 100644
--- a/CPP/7zip/UI/FileManager/PasswordDialogRes.h
+++ b/CPP/7zip/UI/FileManager/PasswordDialogRes.h
@@ -1,5 +1,5 @@
-#define IDD_PASSWORD 3800
-#define IDT_PASSWORD_ENTER 3801
-#define IDX_PASSWORD_SHOW 3803
-
-#define IDE_PASSWORD_PASSWORD 120
+#define IDD_PASSWORD 3800
+#define IDT_PASSWORD_ENTER 3801
+#define IDX_PASSWORD_SHOW 3803
+
+#define IDE_PASSWORD_PASSWORD 120
diff --git a/CPP/7zip/UI/FileManager/PluginInterface.h b/CPP/7zip/UI/FileManager/PluginInterface.h
new file mode 100644
index 0000000..dcb1b4b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PluginInterface.h
@@ -0,0 +1,32 @@
+// PluginInterface.h
+
+#ifndef ZIP7_INC_PLUGIN_INTERFACE_H
+#define ZIP7_INC_PLUGIN_INTERFACE_H
+
+/*
+#include "../../../../C/7zTypes.h"
+#include "../../IDecl.h"
+
+#define Z7_IFACE_CONSTR_PLUGIN(i, n) \
+ Z7_DECL_IFACE_7ZIP(i, 0x0A, n) \
+ { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACEM_IInitContextMenu(x) \
+ x(InitContextMenu(const wchar_t *folder, const wchar_t * const *names, UInt32 numFiles)) \
+
+Z7_IFACE_CONSTR_PLUGIN(IInitContextMenu, 0x00)
+
+#define Z7_IFACEM_IPluginOptionsCallback(x) \
+ x(GetProgramFolderPath(BSTR *value)) \
+ x(GetProgramPath(BSTR *value)) \
+ x(GetRegistryCUPath(BSTR *value)) \
+
+Z7_IFACE_CONSTR_PLUGIN(IPluginOptionsCallback, 0x01)
+
+#define Z7_IFACEM_IPluginOptions(x) \
+ x(PluginOptions(HWND hWnd, IPluginOptionsCallback *callback)) \
+ // x(GetFileExtensions(BSTR *extensions))
+
+Z7_IFACE_CONSTR_PLUGIN(IPluginOptions, 0x02)
+*/
+#endif
diff --git a/CPP/7zip/UI/FileManager/PluginLoader.h b/CPP/7zip/UI/FileManager/PluginLoader.h
new file mode 100644
index 0000000..d9309f2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PluginLoader.h
@@ -0,0 +1,31 @@
+// PluginLoader.h
+
+#ifndef ZIP7_INC_PLUGIN_LOADER_H
+#define ZIP7_INC_PLUGIN_LOADER_H
+
+#include "../../../Windows/DLL.h"
+
+#include "IFolder.h"
+
+class CPluginLibrary: public NWindows::NDLL::CLibrary
+{
+public:
+ HRESULT CreateManager(REFGUID clsID, IFolderManager **manager)
+ {
+ const
+ Func_CreateObject createObject = Z7_GET_PROC_ADDRESS(
+ Func_CreateObject, Get_HMODULE(),
+ "CreateObject");
+ if (!createObject)
+ return GetLastError_noZero_HRESULT();
+ return createObject(&clsID, &IID_IFolderManager, (void **)manager);
+ }
+ HRESULT LoadAndCreateManager(CFSTR filePath, REFGUID clsID, IFolderManager **manager)
+ {
+ if (!Load(filePath))
+ return GetLastError_noZero_HRESULT();
+ return CreateManager(clsID, manager);
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgramLocation.cpp b/CPP/7zip/UI/FileManager/ProgramLocation.cpp
new file mode 100644
index 0000000..50ca5ca
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgramLocation.cpp
@@ -0,0 +1,3 @@
+// ProgramLocation.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/FileManager/ProgramLocation.h b/CPP/7zip/UI/FileManager/ProgramLocation.h
new file mode 100644
index 0000000..0cd9c74
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ProgramLocation.h
@@ -0,0 +1,6 @@
+// ProgramLocation.h
+
+#ifndef ZIP7_INC_PROGRAM_LOCATION_H
+#define ZIP7_INC_PROGRAM_LOCATION_H
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog.cpp b/CPP/7zip/UI/FileManager/ProgressDialog.cpp
index 27d42b2..fc6f559 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog.cpp
+++ b/CPP/7zip/UI/FileManager/ProgressDialog.cpp
@@ -1,196 +1,201 @@
-// ProgressDialog.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "resource.h"
-
-#include "ProgressDialog.h"
-
-using namespace NWindows;
-
-extern HINSTANCE g_hInstance;
-
-static const UINT_PTR kTimerID = 3;
-static const UINT kTimerElapse = 100;
-
-#ifdef LANG
-#include "LangUtils.h"
-#endif
-
-HRESULT CProgressSync::ProcessStopAndPause()
-{
- for (;;)
- {
- if (GetStopped())
- return E_ABORT;
- if (!GetPaused())
- break;
- ::Sleep(100);
- }
- return S_OK;
-}
-
-#ifndef _SFX
-CProgressDialog::~CProgressDialog()
-{
- AddToTitle(L"");
-}
-void CProgressDialog::AddToTitle(LPCWSTR s)
-{
- if (MainWindow != 0)
- MySetWindowText(MainWindow, UString(s) + MainTitle);
-}
-#endif
-
-
-bool CProgressDialog::OnInit()
-{
- _range = (UInt64)(Int64)-1;
- _prevPercentValue = -1;
-
- _wasCreated = true;
- _dialogCreatedEvent.Set();
-
- #ifdef LANG
- LangSetDlgItems(*this, NULL, 0);
- #endif
-
- m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
-
- if (IconID >= 0)
- {
- HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
- SetIcon(ICON_BIG, icon);
- }
-
- _timer = SetTimer(kTimerID, kTimerElapse);
- SetText(_title);
- CheckNeedClose();
- return CModalDialog::OnInit();
-}
-
-void CProgressDialog::OnCancel() { Sync.SetStopped(true); }
-void CProgressDialog::OnOK() { }
-
-void CProgressDialog::SetRange(UInt64 range)
-{
- _range = range;
- _peviousPos = (UInt64)(Int64)-1;
- _converter.Init(range);
- m_ProgressBar.SetRange32(0 , _converter.Count(range)); // Test it for 100%
-}
-
-void CProgressDialog::SetPos(UInt64 pos)
-{
- bool redraw = true;
- if (pos < _range && pos > _peviousPos)
- {
- UInt64 posDelta = pos - _peviousPos;
- if (posDelta < (_range >> 10))
- redraw = false;
- }
- if (redraw)
- {
- m_ProgressBar.SetPos(_converter.Count(pos)); // Test it for 100%
- _peviousPos = pos;
- }
-}
-
-bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
-{
- if (Sync.GetPaused())
- return true;
-
- CheckNeedClose();
-
- UInt64 total, completed;
- Sync.GetProgress(total, completed);
- if (total != _range)
- SetRange(total);
- SetPos(completed);
-
- if (total == 0)
- total = 1;
-
- int percentValue = (int)(completed * 100 / total);
- if (percentValue != _prevPercentValue)
- {
- wchar_t s[64];
- ConvertUInt64ToString(percentValue, s);
- UString title = s;
- title += "% ";
- SetText(title + _title);
- #ifndef _SFX
- AddToTitle(title + MainAddTitle);
- #endif
- _prevPercentValue = percentValue;
- }
- return true;
-}
-
-bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- switch (message)
- {
- case kCloseMessage:
- {
- KillTimer(_timer);
- _timer = 0;
- if (_inCancelMessageBox)
- {
- _externalCloseMessageWasReceived = true;
- break;
- }
- return OnExternalCloseMessage();
- }
- /*
- case WM_SETTEXT:
- {
- if (_timer == 0)
- return true;
- }
- */
- }
- return CModalDialog::OnMessage(message, wParam, lParam);
-}
-
-bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- switch (buttonID)
- {
- case IDCANCEL:
- {
- bool paused = Sync.GetPaused();
- Sync.SetPaused(true);
- _inCancelMessageBox = true;
- int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNOCANCEL);
- _inCancelMessageBox = false;
- Sync.SetPaused(paused);
- if (res == IDCANCEL || res == IDNO)
- {
- if (_externalCloseMessageWasReceived)
- OnExternalCloseMessage();
- return true;
- }
- break;
- }
- }
- return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
-}
-
-void CProgressDialog::CheckNeedClose()
-{
- if (_needClose)
- {
- PostMsg(kCloseMessage);
- _needClose = false;
- }
-}
-
-bool CProgressDialog::OnExternalCloseMessage()
-{
- End(0);
- return true;
-}
+// ProgressDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "resource.h"
+
+#include "ProgressDialog.h"
+
+using namespace NWindows;
+
+extern HINSTANCE g_hInstance;
+
+static const UINT_PTR kTimerID = 3;
+static const UINT kTimerElapse = 100;
+
+#ifdef Z7_LANG
+#include "LangUtils.h"
+#endif
+
+HRESULT CProgressSync::ProcessStopAndPause()
+{
+ for (;;)
+ {
+ if (GetStopped())
+ return E_ABORT;
+ if (!GetPaused())
+ break;
+ ::Sleep(100);
+ }
+ return S_OK;
+}
+
+#ifndef Z7_SFX
+CProgressDialog::~CProgressDialog()
+{
+ AddToTitle(L"");
+}
+void CProgressDialog::AddToTitle(LPCWSTR s)
+{
+ if (MainWindow != 0)
+ MySetWindowText(MainWindow, UString(s) + MainTitle);
+}
+#endif
+
+
+#define UNDEFINED_VAL ((UInt64)(Int64)-1)
+
+bool CProgressDialog::OnInit()
+{
+ _range = UNDEFINED_VAL;
+ _prevPercentValue = UNDEFINED_VAL;
+
+ _wasCreated = true;
+ _dialogCreatedEvent.Set();
+
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, NULL, 0);
+ #endif
+
+ m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
+
+ if (IconID >= 0)
+ {
+ HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
+ SetIcon(ICON_BIG, icon);
+ }
+
+ _timer = SetTimer(kTimerID, kTimerElapse);
+ SetText(_title);
+ CheckNeedClose();
+ return CModalDialog::OnInit();
+}
+
+void CProgressDialog::OnCancel() { Sync.SetStopped(true); }
+void CProgressDialog::OnOK() { }
+
+void CProgressDialog::SetRange(UInt64 range)
+{
+ _range = range;
+ _peviousPos = (UInt64)(Int64)-1;
+ _converter.Init(range);
+ m_ProgressBar.SetRange32(0 , _converter.Count(range)); // Test it for 100%
+}
+
+void CProgressDialog::SetPos(UInt64 pos)
+{
+ bool redraw = true;
+ if (pos < _range && pos > _peviousPos)
+ {
+ UInt64 posDelta = pos - _peviousPos;
+ if (posDelta < (_range >> 10))
+ redraw = false;
+ }
+ if (redraw)
+ {
+ m_ProgressBar.SetPos(_converter.Count(pos)); // Test it for 100%
+ _peviousPos = pos;
+ }
+}
+
+bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
+{
+ if (Sync.GetPaused())
+ return true;
+
+ CheckNeedClose();
+
+ UInt64 total, completed;
+ Sync.GetProgress(total, completed);
+ if (total != _range)
+ SetRange(total);
+ SetPos(completed);
+
+ if (total == 0)
+ total = 1;
+
+ const UInt64 percentValue = completed * 100 / total;
+ if (percentValue != _prevPercentValue)
+ {
+ wchar_t s[64];
+ ConvertUInt64ToString(percentValue, s);
+ UString title = s;
+ title += "% ";
+ SetText(title + _title);
+ #ifndef Z7_SFX
+ AddToTitle(title + MainAddTitle);
+ #endif
+ _prevPercentValue = percentValue;
+ }
+ return true;
+}
+
+bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case kCloseMessage:
+ {
+ if (_timer)
+ {
+ KillTimer(kTimerID);
+ _timer = 0;
+ }
+ if (_inCancelMessageBox)
+ {
+ _externalCloseMessageWasReceived = true;
+ break;
+ }
+ return OnExternalCloseMessage();
+ }
+ /*
+ case WM_SETTEXT:
+ {
+ if (_timer == 0)
+ return true;
+ }
+ */
+ }
+ return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+bool CProgressDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDCANCEL:
+ {
+ bool paused = Sync.GetPaused();
+ Sync.SetPaused(true);
+ _inCancelMessageBox = true;
+ int res = ::MessageBoxW(*this, L"Are you sure you want to cancel?", _title, MB_YESNOCANCEL);
+ _inCancelMessageBox = false;
+ Sync.SetPaused(paused);
+ if (res == IDCANCEL || res == IDNO)
+ {
+ if (_externalCloseMessageWasReceived)
+ OnExternalCloseMessage();
+ return true;
+ }
+ break;
+ }
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CProgressDialog::CheckNeedClose()
+{
+ if (_needClose)
+ {
+ PostMsg(kCloseMessage);
+ _needClose = false;
+ }
+}
+
+bool CProgressDialog::OnExternalCloseMessage()
+{
+ End(0);
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog.h b/CPP/7zip/UI/FileManager/ProgressDialog.h
index 2a9d26d..1fe9587 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog.h
+++ b/CPP/7zip/UI/FileManager/ProgressDialog.h
@@ -1,170 +1,171 @@
-// ProgressDialog.h
-
-#ifndef __PROGRESS_DIALOG_H
-#define __PROGRESS_DIALOG_H
-
-#include "../../../Windows/Synchronization.h"
-#include "../../../Windows/Thread.h"
-
-#include "../../../Windows/Control/Dialog.h"
-#include "../../../Windows/Control/ProgressBar.h"
-
-#include "ProgressDialogRes.h"
-
-class CProgressSync
-{
- NWindows::NSynchronization::CCriticalSection _cs;
- bool _stopped;
- bool _paused;
- UInt64 _total;
- UInt64 _completed;
-public:
- CProgressSync(): _stopped(false), _paused(false), _total(1), _completed(0) {}
-
- HRESULT ProcessStopAndPause();
- bool GetStopped()
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- return _stopped;
- }
- void SetStopped(bool value)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _stopped = value;
- }
- bool GetPaused()
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- return _paused;
- }
- void SetPaused(bool value)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _paused = value;
- }
- void SetProgress(UInt64 total, UInt64 completed)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _total = total;
- _completed = completed;
- }
- void SetPos(UInt64 completed)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _completed = completed;
- }
- void GetProgress(UInt64 &total, UInt64 &completed)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- total = _total;
- completed = _completed;
- }
-};
-
-class CU64ToI32Converter
-{
- UInt64 _numShiftBits;
-public:
- void Init(UInt64 range)
- {
- // Windows CE doesn't like big number here.
- for (_numShiftBits = 0; range > (1 << 15); _numShiftBits++)
- range >>= 1;
- }
- int Count(UInt64 value) { return int(value >> _numShiftBits); }
-};
-
-class CProgressDialog: public NWindows::NControl::CModalDialog
-{
-private:
- UINT_PTR _timer;
-
- UString _title;
- CU64ToI32Converter _converter;
- UInt64 _peviousPos;
- UInt64 _range;
- NWindows::NControl::CProgressBar m_ProgressBar;
-
- int _prevPercentValue;
-
- bool _wasCreated;
- bool _needClose;
- bool _inCancelMessageBox;
- bool _externalCloseMessageWasReceived;
-
- bool OnTimer(WPARAM timerID, LPARAM callback);
- void SetRange(UInt64 range);
- void SetPos(UInt64 pos);
- virtual bool OnInit();
- virtual void OnCancel();
- virtual void OnOK();
- NWindows::NSynchronization::CManualResetEvent _dialogCreatedEvent;
- #ifndef _SFX
- void AddToTitle(LPCWSTR string);
- #endif
- bool OnButtonClicked(int buttonID, HWND buttonHWND);
-
- void WaitCreating() { _dialogCreatedEvent.Lock(); }
- void CheckNeedClose();
- bool OnExternalCloseMessage();
-public:
- CProgressSync Sync;
- int IconID;
-
- #ifndef _SFX
- HWND MainWindow;
- UString MainTitle;
- UString MainAddTitle;
- ~CProgressDialog();
- #endif
-
- CProgressDialog(): _timer(0)
- #ifndef _SFX
- ,MainWindow(0)
- #endif
- {
- IconID = -1;
- _wasCreated = false;
- _needClose = false;
- _inCancelMessageBox = false;
- _externalCloseMessageWasReceived = false;
-
- if (_dialogCreatedEvent.Create() != S_OK)
- throw 1334987;
- }
-
- INT_PTR Create(const UString &title, NWindows::CThread &thread, HWND wndParent = 0)
- {
- _title = title;
- INT_PTR res = CModalDialog::Create(IDD_PROGRESS, wndParent);
- thread.Wait();
- return res;
- }
-
- enum
- {
- kCloseMessage = WM_APP + 1
- };
-
- virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
-
- void ProcessWasFinished()
- {
- WaitCreating();
- if (_wasCreated)
- PostMsg(kCloseMessage);
- else
- _needClose = true;
- };
-};
-
-
-class CProgressCloser
-{
- CProgressDialog *_p;
-public:
- CProgressCloser(CProgressDialog &p) : _p(&p) {}
- ~CProgressCloser() { _p->ProcessWasFinished(); }
-};
-
-#endif
+// ProgressDialog.h
+
+#ifndef ZIP7_INC_PROGRESS_DIALOG_H
+#define ZIP7_INC_PROGRESS_DIALOG_H
+
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ProgressBar.h"
+
+#include "ProgressDialogRes.h"
+
+class CProgressSync
+{
+ NWindows::NSynchronization::CCriticalSection _cs;
+ bool _stopped;
+ bool _paused;
+ UInt64 _total;
+ UInt64 _completed;
+public:
+ CProgressSync(): _stopped(false), _paused(false), _total(1), _completed(0) {}
+
+ HRESULT ProcessStopAndPause();
+ bool GetStopped()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ return _stopped;
+ }
+ void SetStopped(bool value)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _stopped = value;
+ }
+ bool GetPaused()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ return _paused;
+ }
+ void SetPaused(bool value)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _paused = value;
+ }
+ void SetProgress(UInt64 total, UInt64 completed)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _total = total;
+ _completed = completed;
+ }
+ void SetPos(UInt64 completed)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _completed = completed;
+ }
+ void GetProgress(UInt64 &total, UInt64 &completed)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ total = _total;
+ completed = _completed;
+ }
+};
+
+class CU64ToI32Converter
+{
+ UInt64 _numShiftBits;
+public:
+ void Init(UInt64 range)
+ {
+ // Windows CE doesn't like big number here.
+ for (_numShiftBits = 0; range > (1 << 15); _numShiftBits++)
+ range >>= 1;
+ }
+ int Count(UInt64 value) { return int(value >> _numShiftBits); }
+};
+
+class CProgressDialog: public NWindows::NControl::CModalDialog
+{
+private:
+ UINT_PTR _timer;
+
+ UString _title;
+ CU64ToI32Converter _converter;
+ UInt64 _peviousPos;
+ UInt64 _range;
+ NWindows::NControl::CProgressBar m_ProgressBar;
+
+ UInt64 _prevPercentValue;
+
+ bool _wasCreated;
+ bool _needClose;
+ bool _inCancelMessageBox;
+ bool _externalCloseMessageWasReceived;
+
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual bool OnTimer(WPARAM timerID, LPARAM callback) Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual void OnCancel() Z7_override;
+ virtual void OnOK() Z7_override;
+ virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+
+ void SetRange(UInt64 range);
+ void SetPos(UInt64 pos);
+
+ NWindows::NSynchronization::CManualResetEvent _dialogCreatedEvent;
+ #ifndef Z7_SFX
+ void AddToTitle(LPCWSTR string);
+ #endif
+
+ void WaitCreating() { _dialogCreatedEvent.Lock(); }
+ void CheckNeedClose();
+ bool OnExternalCloseMessage();
+public:
+ CProgressSync Sync;
+ int IconID;
+
+ #ifndef Z7_SFX
+ HWND MainWindow;
+ UString MainTitle;
+ UString MainAddTitle;
+ ~CProgressDialog();
+ #endif
+
+ CProgressDialog(): _timer(0)
+ #ifndef Z7_SFX
+ ,MainWindow(NULL)
+ #endif
+ {
+ IconID = -1;
+ _wasCreated = false;
+ _needClose = false;
+ _inCancelMessageBox = false;
+ _externalCloseMessageWasReceived = false;
+
+ if (_dialogCreatedEvent.Create() != S_OK)
+ throw 1334987;
+ }
+
+ INT_PTR Create(const UString &title, NWindows::CThread &thread, HWND wndParent = NULL)
+ {
+ _title = title;
+ INT_PTR res = CModalDialog::Create(IDD_PROGRESS, wndParent);
+ thread.Wait_Close();
+ return res;
+ }
+
+ enum
+ {
+ kCloseMessage = WM_APP + 1
+ };
+
+ void ProcessWasFinished()
+ {
+ WaitCreating();
+ if (_wasCreated)
+ PostMsg(kCloseMessage);
+ else
+ _needClose = true;
+ }
+};
+
+
+class CProgressCloser
+{
+ CProgressDialog *_p;
+public:
+ CProgressCloser(CProgressDialog &p) : _p(&p) {}
+ ~CProgressCloser() { _p->ProcessWasFinished(); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog.rc b/CPP/7zip/UI/FileManager/ProgressDialog.rc
index 5af370f..55d9923 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog.rc
+++ b/CPP/7zip/UI/FileManager/ProgressDialog.rc
@@ -1,12 +1,12 @@
-#include "ProgressDialogRes.h"
-#include "../../GuiCommon.rc"
-
-#define xc 172
-#define yc 44
-
-IDD_PROGRESS DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "Progress"
-BEGIN
- PUSHBUTTON "Cancel", IDCANCEL, bx, by, bxs, bys
- CONTROL "Progress1", IDC_PROGRESS1, "msctls_progress32", PBS_SMOOTH | WS_BORDER, m, m, xc, 14
-END
+#include "ProgressDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 172
+#define yc 44
+
+IDD_PROGRESS DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Progress"
+BEGIN
+ PUSHBUTTON "Cancel", IDCANCEL, bx, by, bxs, bys
+ CONTROL "Progress1", IDC_PROGRESS1, "msctls_progress32", PBS_SMOOTH | WS_BORDER, m, m, xc, 14
+END
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.cpp b/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
index bdb2be3..1521d83 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.cpp
@@ -1,1337 +1,1467 @@
-// ProgressDialog2.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/Control/Static.h"
-#include "../../../Windows/ErrorMsg.h"
-
-#include "../GUI/ExtractRes.h"
-
-#include "LangUtils.h"
-
-#include "DialogSize.h"
-#include "ProgressDialog2.h"
-#include "ProgressDialog2Res.h"
-
-using namespace NWindows;
-
-extern HINSTANCE g_hInstance;
-
-static const UINT_PTR kTimerID = 3;
-
-static const UINT kCloseMessage = WM_APP + 1;
-// we can't use WM_USER, since WM_USER can be used by standard Windows procedure for Dialog
-
-static const UINT kTimerElapse =
- #ifdef UNDER_CE
- 500
- #else
- 200
- #endif
- ;
-
-static const UINT kCreateDelay =
- #ifdef UNDER_CE
- 2500
- #else
- 500
- #endif
- ;
-
-static const DWORD kPauseSleepTime = 100;
-
-#ifdef LANG
-
-static const UInt32 kLangIDs[] =
-{
- IDT_PROGRESS_ELAPSED,
- IDT_PROGRESS_REMAINING,
- IDT_PROGRESS_TOTAL,
- IDT_PROGRESS_SPEED,
- IDT_PROGRESS_PROCESSED,
- IDT_PROGRESS_RATIO,
- IDT_PROGRESS_ERRORS,
- IDB_PROGRESS_BACKGROUND,
- IDB_PAUSE
-};
-
-static const UInt32 kLangIDs_Colon[] =
-{
- IDT_PROGRESS_PACKED,
- IDT_PROGRESS_FILES
-};
-
-#endif
-
-
-#define UNDEFINED_VAL ((UInt64)(Int64)-1)
-#define INIT_AS_UNDEFINED(v) v = UNDEFINED_VAL;
-#define IS_UNDEFINED_VAL(v) ((v) == UNDEFINED_VAL)
-#define IS_DEFINED_VAL(v) ((v) != UNDEFINED_VAL)
-
-CProgressSync::CProgressSync():
- _stopped(false), _paused(false),
- _bytesProgressMode(true),
- _totalBytes(UNDEFINED_VAL), _completedBytes(0),
- _totalFiles(UNDEFINED_VAL), _curFiles(0),
- _inSize(UNDEFINED_VAL),
- _outSize(UNDEFINED_VAL),
- _isDir(false)
- {}
-
-#define CHECK_STOP if (_stopped) return E_ABORT; if (!_paused) return S_OK;
-#define CRITICAL_LOCK NSynchronization::CCriticalSectionLock lock(_cs);
-
-bool CProgressSync::Get_Paused()
-{
- CRITICAL_LOCK
- return _paused;
-}
-
-HRESULT CProgressSync::CheckStop()
-{
- for (;;)
- {
- {
- CRITICAL_LOCK
- CHECK_STOP
- }
- ::Sleep(kPauseSleepTime);
- }
-}
-
-HRESULT CProgressSync::ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir)
-{
- {
- CRITICAL_LOCK
- _totalFiles = numFiles;
- _totalBytes = totalSize;
- _filePath = fs2us(fileName);
- _isDir = isDir;
- // _completedBytes = 0;
- CHECK_STOP
- }
- return CheckStop();
-}
-
-HRESULT CProgressSync::Set_NumFilesTotal(UInt64 val)
-{
- {
- CRITICAL_LOCK
- _totalFiles = val;
- CHECK_STOP
- }
- return CheckStop();
-}
-
-void CProgressSync::Set_NumBytesTotal(UInt64 val)
-{
- CRITICAL_LOCK
- _totalBytes = val;
-}
-
-void CProgressSync::Set_NumFilesCur(UInt64 val)
-{
- CRITICAL_LOCK
- _curFiles = val;
-}
-
-HRESULT CProgressSync::Set_NumBytesCur(const UInt64 *val)
-{
- {
- CRITICAL_LOCK
- if (val)
- _completedBytes = *val;
- CHECK_STOP
- }
- return CheckStop();
-}
-
-HRESULT CProgressSync::Set_NumBytesCur(UInt64 val)
-{
- {
- CRITICAL_LOCK
- _completedBytes = val;
- CHECK_STOP
- }
- return CheckStop();
-}
-
-void CProgressSync::Set_Ratio(const UInt64 *inSize, const UInt64 *outSize)
-{
- CRITICAL_LOCK
- if (inSize)
- _inSize = *inSize;
- if (outSize)
- _outSize = *outSize;
-}
-
-void CProgressSync::Set_TitleFileName(const UString &fileName)
-{
- CRITICAL_LOCK
- _titleFileName = fileName;
-}
-
-void CProgressSync::Set_Status(const UString &s)
-{
- CRITICAL_LOCK
- _status = s;
-}
-
-HRESULT CProgressSync::Set_Status2(const UString &s, const wchar_t *path, bool isDir)
-{
- {
- CRITICAL_LOCK
- _status = s;
- if (path)
- _filePath = path;
- else
- _filePath.Empty();
- _isDir = isDir;
- }
- return CheckStop();
-}
-
-void CProgressSync::Set_FilePath(const wchar_t *path, bool isDir)
-{
- CRITICAL_LOCK
- if (path)
- _filePath = path;
- else
- _filePath.Empty();
- _isDir = isDir;
-}
-
-
-void CProgressSync::AddError_Message(const wchar_t *message)
-{
- CRITICAL_LOCK
- Messages.Add(message);
-}
-
-void CProgressSync::AddError_Message_Name(const wchar_t *message, const wchar_t *name)
-{
- UString s;
- if (name && *name != 0)
- s += name;
- if (message && *message != 0)
- {
- if (!s.IsEmpty())
- s.Add_LF();
- s += message;
- if (!s.IsEmpty() && s.Back() == L'\n')
- s.DeleteBack();
- }
- AddError_Message(s);
-}
-
-void CProgressSync::AddError_Code_Name(DWORD systemError, const wchar_t *name)
-{
- UString s = NError::MyFormatMessage(systemError);
- if (systemError == 0)
- s = "Error";
- AddError_Message_Name(s, name);
-}
-
-CProgressDialog::CProgressDialog():
- _timer(0),
- CompressingMode(true),
- MainWindow(0)
-{
- _isDir = false;
-
- _numMessages = 0;
- IconID = -1;
- MessagesDisplayed = false;
- _wasCreated = false;
- _needClose = false;
- _inCancelMessageBox = false;
- _externalCloseMessageWasReceived = false;
-
- _numPostedMessages = 0;
- _numAutoSizeMessages = 0;
- _errorsWereDisplayed = false;
- _waitCloseByCancelButton = false;
- _cancelWasPressed = false;
- ShowCompressionInfo = true;
- WaitMode = false;
- if (_dialogCreatedEvent.Create() != S_OK)
- throw 1334987;
- if (_createDialogEvent.Create() != S_OK)
- throw 1334987;
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (void**)&_taskbarList);
- if (_taskbarList)
- _taskbarList->HrInit();
- #endif
-}
-
-#ifndef _SFX
-
-CProgressDialog::~CProgressDialog()
-{
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- SetTaskbarProgressState(TBPF_NOPROGRESS);
- #endif
- AddToTitle(L"");
-}
-void CProgressDialog::AddToTitle(LPCWSTR s)
-{
- if (MainWindow != 0)
- {
- CWindow window(MainWindow);
- window.SetText((UString)s + MainTitle);
- }
-}
-
-#endif
-
-
-void CProgressDialog::SetTaskbarProgressState()
-{
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- if (_taskbarList && _hwndForTaskbar)
- {
- TBPFLAG tbpFlags;
- if (Sync.Get_Paused())
- tbpFlags = TBPF_PAUSED;
- else
- tbpFlags = _errorsWereDisplayed ? TBPF_ERROR: TBPF_NORMAL;
- SetTaskbarProgressState(tbpFlags);
- }
- #endif
-}
-
-static const unsigned kTitleFileNameSizeLimit = 36;
-static const unsigned kCurrentFileNameSizeLimit = 82;
-
-static void ReduceString(UString &s, unsigned size)
-{
- if (s.Len() <= size)
- return;
- s.Delete(size / 2, s.Len() - size);
- s.Insert(size / 2, L" ... ");
-}
-
-void CProgressDialog::EnableErrorsControls(bool enable)
-{
- ShowItem_Bool(IDT_PROGRESS_ERRORS, enable);
- ShowItem_Bool(IDT_PROGRESS_ERRORS_VAL, enable);
- ShowItem_Bool(IDL_PROGRESS_MESSAGES, enable);
-}
-
-bool CProgressDialog::OnInit()
-{
- _hwndForTaskbar = MainWindow;
- if (!_hwndForTaskbar)
- _hwndForTaskbar = GetParent();
- if (!_hwndForTaskbar)
- _hwndForTaskbar = *this;
-
- INIT_AS_UNDEFINED(_progressBar_Range);
- INIT_AS_UNDEFINED(_progressBar_Pos);
-
- INIT_AS_UNDEFINED(_prevPercentValue);
- INIT_AS_UNDEFINED(_prevElapsedSec);
- INIT_AS_UNDEFINED(_prevRemainingSec);
-
- INIT_AS_UNDEFINED(_prevSpeed);
- _prevSpeed_MoveBits = 0;
-
- _prevTime = ::GetTickCount();
- _elapsedTime = 0;
-
- INIT_AS_UNDEFINED(_totalBytes_Prev);
- INIT_AS_UNDEFINED(_processed_Prev);
- INIT_AS_UNDEFINED(_packed_Prev);
- INIT_AS_UNDEFINED(_ratio_Prev);
- _filesStr_Prev.Empty();
-
- _foreground = true;
-
- m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
- _messageList.Attach(GetItem(IDL_PROGRESS_MESSAGES));
- _messageList.SetUnicodeFormat();
-
- _wasCreated = true;
- _dialogCreatedEvent.Set();
-
- #ifdef LANG
- LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
- LangSetDlgItems_Colon(*this, kLangIDs_Colon, ARRAY_SIZE(kLangIDs_Colon));
- #endif
-
- CWindow window(GetItem(IDB_PROGRESS_BACKGROUND));
- window.GetText(_background_String);
- _backgrounded_String = _background_String;
- _backgrounded_String.RemoveChar(L'&');
-
- window = GetItem(IDB_PAUSE);
- window.GetText(_pause_String);
-
- LangString(IDS_PROGRESS_FOREGROUND, _foreground_String);
- LangString(IDS_CONTINUE, _continue_String);
- LangString(IDS_PROGRESS_PAUSED, _paused_String);
-
- SetText(_title);
- SetPauseText();
- SetPriorityText();
-
- _messageList.InsertColumn(0, L"", 30);
- _messageList.InsertColumn(1, L"", 600);
-
- _messageList.SetColumnWidthAuto(0);
- _messageList.SetColumnWidthAuto(1);
-
- EnableErrorsControls(false);
-
- GetItemSizes(IDCANCEL, _buttonSizeX, _buttonSizeY);
- _numReduceSymbols = kCurrentFileNameSizeLimit;
- NormalizeSize(true);
-
- if (!ShowCompressionInfo)
- {
- HideItem(IDT_PROGRESS_PACKED);
- HideItem(IDT_PROGRESS_PACKED_VAL);
- HideItem(IDT_PROGRESS_RATIO);
- HideItem(IDT_PROGRESS_RATIO_VAL);
- }
-
- if (IconID >= 0)
- {
- HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
- // SetIcon(ICON_SMALL, icon);
- SetIcon(ICON_BIG, icon);
- }
- _timer = SetTimer(kTimerID, kTimerElapse);
- #ifdef UNDER_CE
- Foreground();
- #endif
-
- CheckNeedClose();
-
- SetTaskbarProgressState();
-
- return CModalDialog::OnInit();
-}
-
-static const UINT kIDs[] =
-{
- IDT_PROGRESS_ELAPSED, IDT_PROGRESS_ELAPSED_VAL,
- IDT_PROGRESS_REMAINING, IDT_PROGRESS_REMAINING_VAL,
- IDT_PROGRESS_FILES, IDT_PROGRESS_FILES_VAL,
- IDT_PROGRESS_RATIO, IDT_PROGRESS_RATIO_VAL,
- IDT_PROGRESS_ERRORS, IDT_PROGRESS_ERRORS_VAL,
-
- IDT_PROGRESS_TOTAL, IDT_PROGRESS_TOTAL_VAL,
- IDT_PROGRESS_SPEED, IDT_PROGRESS_SPEED_VAL,
- IDT_PROGRESS_PROCESSED, IDT_PROGRESS_PROCESSED_VAL,
- IDT_PROGRESS_PACKED, IDT_PROGRESS_PACKED_VAL
-};
-
-bool CProgressDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
-{
- int sY;
- int sStep;
- int mx, my;
- {
- RECT r;
- GetClientRectOfItem(IDT_PROGRESS_ELAPSED, r);
- mx = r.left;
- my = r.top;
- sY = RECT_SIZE_Y(r);
- GetClientRectOfItem(IDT_PROGRESS_REMAINING, r);
- sStep = r.top - my;
- }
-
- InvalidateRect(NULL);
-
- int xSizeClient = xSize - mx * 2;
-
- {
- int i;
- for (i = 800; i > 40; i = i * 9 / 10)
- if (Units_To_Pixels_X(i) <= xSizeClient)
- break;
- _numReduceSymbols = i / 4;
- }
-
- int yPos = ySize - my - _buttonSizeY;
-
- ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_STATUS), xSize - mx * 2);
- ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_FILE_NAME), xSize - mx * 2);
- ChangeSubWindowSizeX(GetItem(IDC_PROGRESS1), xSize - mx * 2);
-
- int bSizeX = _buttonSizeX;
- int mx2 = mx;
- for (;; mx2--)
- {
- int bSize2 = bSizeX * 3 + mx2 * 2;
- if (bSize2 <= xSizeClient)
- break;
- if (mx2 < 5)
- {
- bSizeX = (xSizeClient - mx2 * 2) / 3;
- break;
- }
- }
- if (bSizeX < 2)
- bSizeX = 2;
-
- {
- RECT r;
- GetClientRectOfItem(IDL_PROGRESS_MESSAGES, r);
- int y = r.top;
- int ySize2 = yPos - my - y;
- const int kMinYSize = _buttonSizeY + _buttonSizeY * 3 / 4;
- int xx = xSize - mx * 2;
- if (ySize2 < kMinYSize)
- {
- ySize2 = kMinYSize;
- if (xx > bSizeX * 2)
- xx -= bSizeX;
- }
-
- _messageList.Move(mx, y, xx, ySize2);
- }
-
- {
- int xPos = xSize - mx;
- xPos -= bSizeX;
- MoveItem(IDCANCEL, xPos, yPos, bSizeX, _buttonSizeY);
- xPos -= (mx2 + bSizeX);
- MoveItem(IDB_PAUSE, xPos, yPos, bSizeX, _buttonSizeY);
- xPos -= (mx2 + bSizeX);
- MoveItem(IDB_PROGRESS_BACKGROUND, xPos, yPos, bSizeX, _buttonSizeY);
- }
-
- int valueSize;
- int labelSize;
- int padSize;
-
- labelSize = Units_To_Pixels_X(MY_PROGRESS_LABEL_UNITS_MIN);
- valueSize = Units_To_Pixels_X(MY_PROGRESS_VAL_UNITS);
- padSize = Units_To_Pixels_X(MY_PROGRESS_PAD_UNITS);
- int requiredSize = (labelSize + valueSize) * 2 + padSize;
-
- int gSize;
- {
- if (requiredSize < xSizeClient)
- {
- int incr = (xSizeClient - requiredSize) / 3;
- labelSize += incr;
- }
- else
- labelSize = (xSizeClient - valueSize * 2 - padSize) / 2;
- if (labelSize < 0)
- labelSize = 0;
-
- gSize = labelSize + valueSize;
- padSize = xSizeClient - gSize * 2;
- }
-
- labelSize = gSize - valueSize;
-
- yPos = my;
- for (int i = 0; i < ARRAY_SIZE(kIDs); i += 2)
- {
- int x = mx;
- const int kNumColumn1Items = 5 * 2;
- if (i >= kNumColumn1Items)
- {
- if (i == kNumColumn1Items)
- yPos = my;
- x = mx + gSize + padSize;
- }
- MoveItem(kIDs[i], x, yPos, labelSize, sY);
- MoveItem(kIDs[i + 1], x + labelSize, yPos, valueSize, sY);
- yPos += sStep;
- }
- return false;
-}
-
-void CProgressDialog::OnCancel() { Sync.Set_Stopped(true); }
-void CProgressDialog::OnOK() { }
-
-void CProgressDialog::SetProgressRange(UInt64 range)
-{
- if (range == _progressBar_Range)
- return;
- _progressBar_Range = range;
- INIT_AS_UNDEFINED(_progressBar_Pos);
- _progressConv.Init(range);
- m_ProgressBar.SetRange32(0, _progressConv.Count(range));
-}
-
-void CProgressDialog::SetProgressPos(UInt64 pos)
-{
- if (pos >= _progressBar_Range ||
- pos <= _progressBar_Pos ||
- pos - _progressBar_Pos >= (_progressBar_Range >> 10))
- {
- m_ProgressBar.SetPos(_progressConv.Count(pos));
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- if (_taskbarList && _hwndForTaskbar)
- _taskbarList->SetProgressValue(_hwndForTaskbar, pos, _progressBar_Range);
- #endif
- _progressBar_Pos = pos;
- }
-}
-
-#define UINT_TO_STR_2(val) { s[0] = (wchar_t)('0' + (val) / 10); s[1] = (wchar_t)('0' + (val) % 10); s += 2; }
-
-void GetTimeString(UInt64 timeValue, wchar_t *s)
-{
- UInt64 hours = timeValue / 3600;
- UInt32 seconds = (UInt32)(timeValue - hours * 3600);
- UInt32 minutes = seconds / 60;
- seconds %= 60;
- if (hours > 99)
- {
- ConvertUInt64ToString(hours, s);
- for (; *s != 0; s++);
- }
- else
- {
- UInt32 hours32 = (UInt32)hours;
- UINT_TO_STR_2(hours32);
- }
- *s++ = ':'; UINT_TO_STR_2(minutes);
- *s++ = ':'; UINT_TO_STR_2(seconds);
- *s = 0;
-}
-
-static void ConvertSizeToString(UInt64 v, wchar_t *s)
-{
- Byte c = 0;
- if (v >= ((UInt64)100000 << 20)) { v >>= 30; c = 'G'; }
- else if (v >= ((UInt64)100000 << 10)) { v >>= 20; c = 'M'; }
- else if (v >= ((UInt64)100000 << 0)) { v >>= 10; c = 'K'; }
- ConvertUInt64ToString(v, s);
- if (c != 0)
- {
- s += MyStringLen(s);
- *s++ = ' ';
- *s++ = c;
- *s++ = 0;
- }
-}
-
-void CProgressDialog::ShowSize(int id, UInt64 val, UInt64 &prev)
-{
- if (val == prev)
- return;
- prev = val;
- wchar_t s[40];
- s[0] = 0;
- if (IS_DEFINED_VAL(val))
- ConvertSizeToString(val, s);
- SetItemText(id, s);
-}
-
-static void GetChangedString(const UString &newStr, UString &prevStr, bool &hasChanged)
-{
- hasChanged = !(prevStr == newStr);
- if (hasChanged)
- prevStr = newStr;
-}
-
-static unsigned GetPower32(UInt32 val)
-{
- const unsigned kStart = 32;
- UInt32 mask = ((UInt32)1 << (kStart - 1));
- for (unsigned i = kStart;; i--)
- {
- if (i == 0 || (val & mask) != 0)
- return i;
- mask >>= 1;
- }
-}
-
-static unsigned GetPower64(UInt64 val)
-{
- UInt32 high = (UInt32)(val >> 32);
- if (high == 0)
- return GetPower32((UInt32)val);
- return GetPower32(high) + 32;
-}
-
-static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider)
-{
- unsigned pow1 = GetPower64(mult1);
- unsigned pow2 = GetPower64(mult2);
- while (pow1 + pow2 > 64)
- {
- if (pow1 > pow2) { pow1--; mult1 >>= 1; }
- else { pow2--; mult2 >>= 1; }
- divider >>= 1;
- }
- UInt64 res = mult1 * mult2;
- if (divider != 0)
- res /= divider;
- return res;
-}
-
-void CProgressDialog::UpdateStatInfo(bool showAll)
-{
- UInt64 total, completed, totalFiles, completedFiles, inSize, outSize;
- bool bytesProgressMode;
-
- bool titleFileName_Changed;
- bool curFilePath_Changed;
- bool status_Changed;
- unsigned numErrors;
- {
- NSynchronization::CCriticalSectionLock lock(Sync._cs);
- total = Sync._totalBytes;
- completed = Sync._completedBytes;
- totalFiles = Sync._totalFiles;
- completedFiles = Sync._curFiles;
- inSize = Sync._inSize;
- outSize = Sync._outSize;
- bytesProgressMode = Sync._bytesProgressMode;
-
- GetChangedString(Sync._titleFileName, _titleFileName, titleFileName_Changed);
- GetChangedString(Sync._filePath, _filePath, curFilePath_Changed);
- GetChangedString(Sync._status, _status, status_Changed);
- if (_isDir != Sync._isDir)
- {
- curFilePath_Changed = true;
- _isDir = Sync._isDir;
- }
- numErrors = Sync.Messages.Size();
- }
-
- UInt32 curTime = ::GetTickCount();
-
- const UInt64 progressTotal = bytesProgressMode ? total : totalFiles;
- const UInt64 progressCompleted = bytesProgressMode ? completed : completedFiles;
- {
- if (IS_UNDEFINED_VAL(progressTotal))
- {
- // SetPos(0);
- // SetRange(progressCompleted);
- }
- else
- {
- if (_progressBar_Pos != 0 || progressCompleted != 0 ||
- (_progressBar_Range == 0 && progressTotal != 0))
- {
- SetProgressRange(progressTotal);
- SetProgressPos(progressCompleted);
- }
- }
- }
-
- ShowSize(IDT_PROGRESS_TOTAL_VAL, total, _totalBytes_Prev);
-
- _elapsedTime += (curTime - _prevTime);
- _prevTime = curTime;
- UInt64 elapsedSec = _elapsedTime / 1000;
- bool elapsedChanged = false;
- if (elapsedSec != _prevElapsedSec)
- {
- _prevElapsedSec = elapsedSec;
- elapsedChanged = true;
- wchar_t s[40];
- GetTimeString(elapsedSec, s);
- SetItemText(IDT_PROGRESS_ELAPSED_VAL, s);
- }
-
- bool needSetTitle = false;
- if (elapsedChanged || showAll)
- {
- if (numErrors > _numPostedMessages)
- {
- UpdateMessagesDialog();
- wchar_t s[32];
- ConvertUInt64ToString(numErrors, s);
- SetItemText(IDT_PROGRESS_ERRORS_VAL, s);
- if (!_errorsWereDisplayed)
- {
- _errorsWereDisplayed = true;
- EnableErrorsControls(true);
- SetTaskbarProgressState();
- }
- }
-
- if (progressCompleted != 0)
- {
- if (IS_UNDEFINED_VAL(progressTotal))
- {
- if (IS_DEFINED_VAL(_prevRemainingSec))
- {
- INIT_AS_UNDEFINED(_prevRemainingSec);
- SetItemText(IDT_PROGRESS_REMAINING_VAL, L"");
- }
- }
- else
- {
- UInt64 remainingTime = 0;
- if (progressCompleted < progressTotal)
- remainingTime = MyMultAndDiv(_elapsedTime, progressTotal - progressCompleted, progressCompleted);
- UInt64 remainingSec = remainingTime / 1000;
- if (remainingSec != _prevRemainingSec)
- {
- _prevRemainingSec = remainingSec;
- wchar_t s[40];
- GetTimeString(remainingSec, s);
- SetItemText(IDT_PROGRESS_REMAINING_VAL, s);
- }
- }
- {
- UInt64 elapsedTime = (_elapsedTime == 0) ? 1 : _elapsedTime;
- UInt64 v = (progressCompleted * 1000) / elapsedTime;
- Byte c = 0;
- unsigned moveBits = 0;
- if (v >= ((UInt64)10000 << 10)) { moveBits = 20; c = 'M'; }
- else if (v >= ((UInt64)10000 << 0)) { moveBits = 10; c = 'K'; }
- v >>= moveBits;
- if (moveBits != _prevSpeed_MoveBits || v != _prevSpeed)
- {
- _prevSpeed_MoveBits = moveBits;
- _prevSpeed = v;
- wchar_t s[40];
- ConvertUInt64ToString(v, s);
- unsigned pos = MyStringLen(s);
- s[pos++] = ' ';
- if (moveBits != 0)
- s[pos++] = c;
- s[pos++] = 'B';
- s[pos++] = '/';
- s[pos++] = 's';
- s[pos++] = 0;
- SetItemText(IDT_PROGRESS_SPEED_VAL, s);
- }
- }
- }
-
- {
- UInt64 percent = 0;
- {
- if (IS_DEFINED_VAL(progressTotal))
- {
- percent = progressCompleted * 100;
- if (progressTotal != 0)
- percent /= progressTotal;
- }
- }
- if (percent != _prevPercentValue)
- {
- _prevPercentValue = percent;
- needSetTitle = true;
- }
- }
-
- {
- wchar_t s[64];
- ConvertUInt64ToString(completedFiles, s);
- if (IS_DEFINED_VAL(totalFiles))
- {
- MyStringCat(s, L" / ");
- ConvertUInt64ToString(totalFiles, s + MyStringLen(s));
- }
- if (_filesStr_Prev != s)
- {
- _filesStr_Prev = s;
- SetItemText(IDT_PROGRESS_FILES_VAL, s);
- }
- }
-
- const UInt64 packSize = CompressingMode ? outSize : inSize;
- const UInt64 unpackSize = CompressingMode ? inSize : outSize;
-
- if (IS_UNDEFINED_VAL(unpackSize) &&
- IS_UNDEFINED_VAL(packSize))
- {
- ShowSize(IDT_PROGRESS_PROCESSED_VAL, completed, _processed_Prev);
- ShowSize(IDT_PROGRESS_PACKED_VAL, UNDEFINED_VAL, _packed_Prev);
- }
- else
- {
- ShowSize(IDT_PROGRESS_PROCESSED_VAL, unpackSize, _processed_Prev);
- ShowSize(IDT_PROGRESS_PACKED_VAL, packSize, _packed_Prev);
-
- if (IS_DEFINED_VAL(packSize) &&
- IS_DEFINED_VAL(unpackSize) &&
- unpackSize != 0)
- {
- wchar_t s[32];
- UInt64 ratio = packSize * 100 / unpackSize;
- if (_ratio_Prev != ratio)
- {
- _ratio_Prev = ratio;
- ConvertUInt64ToString(ratio, s);
- MyStringCat(s, L"%");
- SetItemText(IDT_PROGRESS_RATIO_VAL, s);
- }
- }
- }
- }
-
- if (needSetTitle || titleFileName_Changed)
- SetTitleText();
-
- if (status_Changed)
- {
- UString s = _status;
- ReduceString(s, _numReduceSymbols);
- SetItemText(IDT_PROGRESS_STATUS, _status);
- }
-
- if (curFilePath_Changed)
- {
- UString s1, s2;
- if (_isDir)
- s1 = _filePath;
- else
- {
- int slashPos = _filePath.ReverseFind_PathSepar();
- if (slashPos >= 0)
- {
- s1.SetFrom(_filePath, slashPos + 1);
- s2 = _filePath.Ptr(slashPos + 1);
- }
- else
- s2 = _filePath;
- }
- ReduceString(s1, _numReduceSymbols);
- ReduceString(s2, _numReduceSymbols);
- s1.Add_LF();
- s1 += s2;
- SetItemText(IDT_PROGRESS_FILE_NAME, s1);
- }
-}
-
-bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
-{
- if (Sync.Get_Paused())
- return true;
- CheckNeedClose();
- UpdateStatInfo(false);
- return true;
-}
-
-struct CWaitCursor
-{
- HCURSOR _waitCursor;
- HCURSOR _oldCursor;
- CWaitCursor()
- {
- _waitCursor = LoadCursor(NULL, IDC_WAIT);
- if (_waitCursor != NULL)
- _oldCursor = SetCursor(_waitCursor);
- }
- ~CWaitCursor()
- {
- if (_waitCursor != NULL)
- SetCursor(_oldCursor);
- }
-};
-
-INT_PTR CProgressDialog::Create(const UString &title, NWindows::CThread &thread, HWND wndParent)
-{
- INT_PTR res = 0;
- try
- {
- if (WaitMode)
- {
- CWaitCursor waitCursor;
- HANDLE h[] = { thread, _createDialogEvent };
-
- WRes res2 = WaitForMultipleObjects(ARRAY_SIZE(h), h, FALSE, kCreateDelay);
- if (res2 == WAIT_OBJECT_0 && !Sync.ThereIsMessage())
- return 0;
- }
- _title = title;
- BIG_DIALOG_SIZE(360, 192);
- res = CModalDialog::Create(SIZED_DIALOG(IDD_PROGRESS), wndParent);
- }
- catch(...)
- {
- _wasCreated = true;
- _dialogCreatedEvent.Set();
- res = res;
- }
- thread.Wait();
- if (!MessagesDisplayed)
- MessageBoxW(wndParent, L"Progress Error", L"7-Zip", MB_ICONERROR);
- return res;
-}
-
-bool CProgressDialog::OnExternalCloseMessage()
-{
- // it doesn't work if there is MessageBox.
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- SetTaskbarProgressState(TBPF_NOPROGRESS);
- #endif
- // AddToTitle(L"Finished ");
- // SetText(L"Finished2 ");
-
- UpdateStatInfo(true);
-
- SetItemText(IDCANCEL, LangString(IDS_CLOSE));
- ::SendMessage(GetItem(IDCANCEL), BM_SETSTYLE, BS_DEFPUSHBUTTON, MAKELPARAM(TRUE, 0));
- HideItem(IDB_PROGRESS_BACKGROUND);
- HideItem(IDB_PAUSE);
-
- ProcessWasFinished_GuiVirt();
-
- bool thereAreMessages;
- CProgressFinalMessage fm;
- {
- NSynchronization::CCriticalSectionLock lock(Sync._cs);
- thereAreMessages = !Sync.Messages.IsEmpty();
- fm = Sync.FinalMessage;
- }
-
- if (!fm.ErrorMessage.Message.IsEmpty())
- {
- MessagesDisplayed = true;
- if (fm.ErrorMessage.Title.IsEmpty())
- fm.ErrorMessage.Title = "7-Zip";
- MessageBoxW(*this, fm.ErrorMessage.Message, fm.ErrorMessage.Title, MB_ICONERROR);
- }
- else if (!thereAreMessages)
- {
- MessagesDisplayed = true;
-
- if (!fm.OkMessage.Message.IsEmpty())
- {
- if (fm.OkMessage.Title.IsEmpty())
- fm.OkMessage.Title = "7-Zip";
- MessageBoxW(*this, fm.OkMessage.Message, fm.OkMessage.Title, MB_OK);
- }
- }
-
- if (thereAreMessages && !_cancelWasPressed)
- {
- _waitCloseByCancelButton = true;
- UpdateMessagesDialog();
- return true;
- }
-
- End(0);
- return true;
-}
-
-bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- switch (message)
- {
- case kCloseMessage:
- {
- KillTimer(_timer);
- _timer = 0;
- if (_inCancelMessageBox)
- {
- _externalCloseMessageWasReceived = true;
- break;
- }
- return OnExternalCloseMessage();
- }
- /*
- case WM_SETTEXT:
- {
- if (_timer == 0)
- return true;
- break;
- }
- */
- }
- return CModalDialog::OnMessage(message, wParam, lParam);
-}
-
-void CProgressDialog::SetTitleText()
-{
- UString s;
- if (Sync.Get_Paused())
- {
- s += _paused_String;
- s.Add_Space();
- }
- if (IS_DEFINED_VAL(_prevPercentValue))
- {
- char temp[32];
- ConvertUInt64ToString(_prevPercentValue, temp);
- s += temp;
- s += '%';
- }
- if (!_foreground)
- {
- s.Add_Space();
- s += _backgrounded_String;
- }
-
- s.Add_Space();
- #ifndef _SFX
- {
- unsigned len = s.Len();
- s += MainAddTitle;
- AddToTitle(s);
- s.DeleteFrom(len);
- }
- #endif
-
- s += _title;
- if (!_titleFileName.IsEmpty())
- {
- UString fileName = _titleFileName;
- ReduceString(fileName, kTitleFileNameSizeLimit);
- s.Add_Space();
- s += fileName;
- }
- SetText(s);
-}
-
-void CProgressDialog::SetPauseText()
-{
- SetItemText(IDB_PAUSE, Sync.Get_Paused() ? _continue_String : _pause_String);
- SetTitleText();
-}
-
-void CProgressDialog::OnPauseButton()
-{
- bool paused = !Sync.Get_Paused();
- Sync.Set_Paused(paused);
- UInt32 curTime = ::GetTickCount();
- if (paused)
- _elapsedTime += (curTime - _prevTime);
- SetTaskbarProgressState();
- _prevTime = curTime;
- SetPauseText();
-}
-
-void CProgressDialog::SetPriorityText()
-{
- SetItemText(IDB_PROGRESS_BACKGROUND, _foreground ?
- _background_String :
- _foreground_String);
- SetTitleText();
-}
-
-void CProgressDialog::OnPriorityButton()
-{
- _foreground = !_foreground;
- #ifndef UNDER_CE
- SetPriorityClass(GetCurrentProcess(), _foreground ? NORMAL_PRIORITY_CLASS: IDLE_PRIORITY_CLASS);
- #endif
- SetPriorityText();
-}
-
-void CProgressDialog::AddMessageDirect(LPCWSTR message, bool needNumber)
-{
- int itemIndex = _messageList.GetItemCount();
- wchar_t sz[16];
- sz[0] = 0;
- if (needNumber)
- ConvertUInt32ToString(_numMessages + 1, sz);
- _messageList.InsertItem(itemIndex, sz);
- _messageList.SetSubItem(itemIndex, 1, message);
-}
-
-void CProgressDialog::AddMessage(LPCWSTR message)
-{
- UString s = message;
- bool needNumber = true;
- while (!s.IsEmpty())
- {
- int pos = s.Find(L'\n');
- if (pos < 0)
- break;
- AddMessageDirect(s.Left(pos), needNumber);
- needNumber = false;
- s.DeleteFrontal(pos + 1);
- }
- AddMessageDirect(s, needNumber);
- _numMessages++;
-}
-
-static unsigned GetNumDigits(UInt32 val)
-{
- unsigned i;
- for (i = 0; val >= 10; i++)
- val /= 10;
- return i;
-}
-
-void CProgressDialog::UpdateMessagesDialog()
-{
- UStringVector messages;
- {
- NSynchronization::CCriticalSectionLock lock(Sync._cs);
- unsigned num = Sync.Messages.Size();
- if (num > _numPostedMessages)
- {
- messages.ClearAndReserve(num - _numPostedMessages);
- for (unsigned i = _numPostedMessages; i < num; i++)
- messages.AddInReserved(Sync.Messages[i]);
- _numPostedMessages = num;
- }
- }
- if (!messages.IsEmpty())
- {
- FOR_VECTOR (i, messages)
- AddMessage(messages[i]);
- if (_numAutoSizeMessages < 256 || GetNumDigits(_numPostedMessages) > GetNumDigits(_numAutoSizeMessages))
- {
- _messageList.SetColumnWidthAuto(0);
- _messageList.SetColumnWidthAuto(1);
- _numAutoSizeMessages = _numPostedMessages;
- }
- }
-}
-
-
-bool CProgressDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- switch (buttonID)
- {
- // case IDOK: // if IDCANCEL is not DEFPUSHBUTTON
- case IDCANCEL:
- {
- if (_waitCloseByCancelButton)
- {
- MessagesDisplayed = true;
- End(IDCLOSE);
- break;
- }
-
- bool paused = Sync.Get_Paused();
- if (!paused)
- OnPauseButton();
- _inCancelMessageBox = true;
- int res = ::MessageBoxW(*this, LangString(IDS_PROGRESS_ASK_CANCEL), _title, MB_YESNOCANCEL);
- _inCancelMessageBox = false;
- if (!paused)
- OnPauseButton();
- if (res == IDCANCEL || res == IDNO)
- {
- if (_externalCloseMessageWasReceived)
- OnExternalCloseMessage();
- return true;
- }
-
- _cancelWasPressed = true;
- MessagesDisplayed = true;
- break;
- }
-
- case IDB_PAUSE:
- OnPauseButton();
- return true;
- case IDB_PROGRESS_BACKGROUND:
- OnPriorityButton();
- return true;
- }
- return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
-}
-
-void CProgressDialog::CheckNeedClose()
-{
- if (_needClose)
- {
- PostMsg(kCloseMessage);
- _needClose = false;
- }
-}
-
-void CProgressDialog::ProcessWasFinished()
-{
- // Set Window title here.
- if (!WaitMode)
- WaitCreating();
-
- if (_wasCreated)
- PostMsg(kCloseMessage);
- else
- _needClose = true;
-}
-
-
-static THREAD_FUNC_DECL MyThreadFunction(void *param)
-{
- CProgressThreadVirt *p = (CProgressThreadVirt *)param;
- try
- {
- p->Process();
- p->ThreadFinishedOK = true;
- }
- catch (...) { p->Result = E_FAIL; }
- return 0;
-}
-
-
-HRESULT CProgressThreadVirt::Create(const UString &title, HWND parentWindow)
-{
- NWindows::CThread thread;
- RINOK(thread.Create(MyThreadFunction, this));
- CProgressDialog::Create(title, thread, parentWindow);
- return S_OK;
-}
-
-static void AddMessageToString(UString &dest, const UString &src)
-{
- if (!src.IsEmpty())
- {
- if (!dest.IsEmpty())
- dest.Add_LF();
- dest += src;
- }
-}
-
-void CProgressThreadVirt::Process()
-{
- CProgressCloser closer(*this);
- UString m;
- try { Result = ProcessVirt(); }
- catch(const wchar_t *s) { m = s; }
- catch(const UString &s) { m = s; }
- catch(const char *s) { m = GetUnicodeString(s); }
- catch(int v)
- {
- m = "Error #";
- m.Add_UInt32(v);
- }
- catch(...) { m = "Error"; }
- if (Result != E_ABORT)
- {
- if (m.IsEmpty() && Result != S_OK)
- m = HResultToMessage(Result);
- }
- AddMessageToString(m, FinalMessage.ErrorMessage.Message);
-
- {
- FOR_VECTOR(i, ErrorPaths)
- {
- if (i >= 32)
- break;
- AddMessageToString(m, fs2us(ErrorPaths[i]));
- }
- }
-
- CProgressSync &sync = Sync;
- NSynchronization::CCriticalSectionLock lock(sync._cs);
- if (m.IsEmpty())
- {
- if (!FinalMessage.OkMessage.Message.IsEmpty())
- sync.FinalMessage.OkMessage = FinalMessage.OkMessage;
- }
- else
- {
- sync.FinalMessage.ErrorMessage.Message = m;
- if (Result == S_OK)
- Result = E_FAIL;
- }
-}
-
-UString HResultToMessage(HRESULT errorCode)
-{
- if (errorCode == E_OUTOFMEMORY)
- return LangString(IDS_MEM_ERROR);
- else
- return NError::MyFormatMessage(errorCode);
-}
+// ProgressDialog2.cpp
+
+#include "StdAfx.h"
+
+#ifdef Z7_OLD_WIN_SDK
+#include <ShlGuid.h>
+#endif
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/Clipboard.h"
+#include "../../../Windows/ErrorMsg.h"
+
+#include "../GUI/ExtractRes.h"
+
+#include "LangUtils.h"
+
+#include "DialogSize.h"
+#include "ProgressDialog2.h"
+#include "ProgressDialog2Res.h"
+
+using namespace NWindows;
+
+extern HINSTANCE g_hInstance;
+
+static const UINT_PTR kTimerID = 3;
+
+static const UINT kCloseMessage = WM_APP + 1;
+// we can't use WM_USER, since WM_USER can be used by standard Windows procedure for Dialog
+
+static const UINT kTimerElapse =
+ #ifdef UNDER_CE
+ 500
+ #else
+ 200
+ #endif
+ ;
+
+static const UINT kCreateDelay =
+ #ifdef UNDER_CE
+ 2500
+ #else
+ 500
+ #endif
+ ;
+
+static const DWORD kPauseSleepTime = 100;
+
+#ifdef Z7_LANG
+
+static const UInt32 kLangIDs[] =
+{
+ IDT_PROGRESS_ELAPSED,
+ IDT_PROGRESS_REMAINING,
+ IDT_PROGRESS_TOTAL,
+ IDT_PROGRESS_SPEED,
+ IDT_PROGRESS_PROCESSED,
+ IDT_PROGRESS_RATIO,
+ IDT_PROGRESS_ERRORS,
+ IDB_PROGRESS_BACKGROUND,
+ IDB_PAUSE
+};
+
+static const UInt32 kLangIDs_Colon[] =
+{
+ IDT_PROGRESS_PACKED,
+ IDT_PROGRESS_FILES
+};
+
+#endif
+
+
+#define UNDEFINED_VAL ((UInt64)(Int64)-1)
+#define INIT_AS_UNDEFINED(v) v = UNDEFINED_VAL;
+#define IS_UNDEFINED_VAL(v) ((v) == UNDEFINED_VAL)
+#define IS_DEFINED_VAL(v) ((v) != UNDEFINED_VAL)
+
+CProgressSync::CProgressSync():
+ _stopped(false), _paused(false),
+ _bytesProgressMode(true),
+ _isDir(false),
+ _totalBytes(UNDEFINED_VAL), _completedBytes(0),
+ _totalFiles(UNDEFINED_VAL), _curFiles(0),
+ _inSize(UNDEFINED_VAL),
+ _outSize(UNDEFINED_VAL)
+ {}
+
+#define CHECK_STOP if (_stopped) return E_ABORT; if (!_paused) return S_OK;
+#define CRITICAL_LOCK NSynchronization::CCriticalSectionLock lock(_cs);
+
+bool CProgressSync::Get_Paused()
+{
+ CRITICAL_LOCK
+ return _paused;
+}
+
+HRESULT CProgressSync::CheckStop()
+{
+ for (;;)
+ {
+ {
+ CRITICAL_LOCK
+ CHECK_STOP
+ }
+ ::Sleep(kPauseSleepTime);
+ }
+}
+
+HRESULT CProgressSync::ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir)
+{
+ {
+ CRITICAL_LOCK
+ _totalFiles = numFiles;
+ _totalBytes = totalSize;
+ _filePath = fs2us(fileName);
+ _isDir = isDir;
+ // _completedBytes = 0;
+ CHECK_STOP
+ }
+ return CheckStop();
+}
+
+HRESULT CProgressSync::Set_NumFilesTotal(UInt64 val)
+{
+ {
+ CRITICAL_LOCK
+ _totalFiles = val;
+ CHECK_STOP
+ }
+ return CheckStop();
+}
+
+void CProgressSync::Set_NumBytesTotal(UInt64 val)
+{
+ CRITICAL_LOCK
+ _totalBytes = val;
+}
+
+void CProgressSync::Set_NumFilesCur(UInt64 val)
+{
+ CRITICAL_LOCK
+ _curFiles = val;
+}
+
+HRESULT CProgressSync::Set_NumBytesCur(const UInt64 *val)
+{
+ {
+ CRITICAL_LOCK
+ if (val)
+ _completedBytes = *val;
+ CHECK_STOP
+ }
+ return CheckStop();
+}
+
+HRESULT CProgressSync::Set_NumBytesCur(UInt64 val)
+{
+ {
+ CRITICAL_LOCK
+ _completedBytes = val;
+ CHECK_STOP
+ }
+ return CheckStop();
+}
+
+void CProgressSync::Set_Ratio(const UInt64 *inSize, const UInt64 *outSize)
+{
+ CRITICAL_LOCK
+ if (inSize)
+ _inSize = *inSize;
+ if (outSize)
+ _outSize = *outSize;
+}
+
+void CProgressSync::Set_TitleFileName(const UString &fileName)
+{
+ CRITICAL_LOCK
+ _titleFileName = fileName;
+}
+
+void CProgressSync::Set_Status(const UString &s)
+{
+ CRITICAL_LOCK
+ _status = s;
+}
+
+HRESULT CProgressSync::Set_Status2(const UString &s, const wchar_t *path, bool isDir)
+{
+ {
+ CRITICAL_LOCK
+ _status = s;
+ if (path)
+ _filePath = path;
+ else
+ _filePath.Empty();
+ _isDir = isDir;
+ }
+ return CheckStop();
+}
+
+void CProgressSync::Set_FilePath(const wchar_t *path, bool isDir)
+{
+ CRITICAL_LOCK
+ if (path)
+ _filePath = path;
+ else
+ _filePath.Empty();
+ _isDir = isDir;
+}
+
+
+void CProgressSync::AddError_Message(const wchar_t *message)
+{
+ CRITICAL_LOCK
+ Messages.Add(message);
+}
+
+void CProgressSync::AddError_Message_Name(const wchar_t *message, const wchar_t *name)
+{
+ UString s;
+ if (name && *name != 0)
+ s += name;
+ if (message && *message != 0)
+ {
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += message;
+ if (!s.IsEmpty() && s.Back() == L'\n')
+ s.DeleteBack();
+ }
+ AddError_Message(s);
+}
+
+void CProgressSync::AddError_Code_Name(HRESULT systemError, const wchar_t *name)
+{
+ UString s = NError::MyFormatMessage(systemError);
+ if (systemError == 0)
+ s = "Error";
+ AddError_Message_Name(s, name);
+}
+
+CProgressDialog::CProgressDialog():
+ _timer(0),
+ CompressingMode(true),
+ MainWindow(NULL)
+{
+ _isDir = false;
+
+ _numMessages = 0;
+ IconID = -1;
+ MessagesDisplayed = false;
+ _wasCreated = false;
+ _needClose = false;
+ _inCancelMessageBox = false;
+ _externalCloseMessageWasReceived = false;
+
+ _numPostedMessages = 0;
+ _numAutoSizeMessages = 0;
+ _errorsWereDisplayed = false;
+ _waitCloseByCancelButton = false;
+ _cancelWasPressed = false;
+ ShowCompressionInfo = true;
+ WaitMode = false;
+ if (_dialogCreatedEvent.Create() != S_OK)
+ throw 1334987;
+ if (_createDialogEvent.Create() != S_OK)
+ throw 1334987;
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_ITaskbarList3, (void**)&_taskbarList);
+ if (_taskbarList)
+ _taskbarList->HrInit();
+ // #endif
+}
+
+#ifndef Z7_SFX
+
+CProgressDialog::~CProgressDialog()
+{
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ SetTaskbarProgressState(TBPF_NOPROGRESS);
+ // #endif
+ AddToTitle(L"");
+}
+void CProgressDialog::AddToTitle(LPCWSTR s)
+{
+ if (MainWindow)
+ {
+ CWindow window(MainWindow);
+ window.SetText((UString)s + MainTitle);
+ }
+}
+
+#endif
+
+
+void CProgressDialog::SetTaskbarProgressState()
+{
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ if (_taskbarList && _hwndForTaskbar)
+ {
+ TBPFLAG tbpFlags;
+ if (Sync.Get_Paused())
+ tbpFlags = TBPF_PAUSED;
+ else
+ tbpFlags = _errorsWereDisplayed ? TBPF_ERROR: TBPF_NORMAL;
+ SetTaskbarProgressState(tbpFlags);
+ }
+ // #endif
+}
+
+static const unsigned kTitleFileNameSizeLimit = 36;
+static const unsigned kCurrentFileNameSizeLimit = 82;
+
+static void ReduceString(UString &s, unsigned size)
+{
+ if (s.Len() <= size)
+ return;
+ s.Delete(size / 2, s.Len() - size);
+ s.Insert(size / 2, L" ... ");
+}
+
+void CProgressDialog::EnableErrorsControls(bool enable)
+{
+ ShowItem_Bool(IDT_PROGRESS_ERRORS, enable);
+ ShowItem_Bool(IDT_PROGRESS_ERRORS_VAL, enable);
+ ShowItem_Bool(IDL_PROGRESS_MESSAGES, enable);
+}
+
+bool CProgressDialog::OnInit()
+{
+ _hwndForTaskbar = MainWindow;
+ if (!_hwndForTaskbar)
+ _hwndForTaskbar = GetParent();
+ if (!_hwndForTaskbar)
+ _hwndForTaskbar = *this;
+
+ INIT_AS_UNDEFINED(_progressBar_Range)
+ INIT_AS_UNDEFINED(_progressBar_Pos)
+
+ INIT_AS_UNDEFINED(_prevPercentValue)
+ INIT_AS_UNDEFINED(_prevElapsedSec)
+ INIT_AS_UNDEFINED(_prevRemainingSec)
+
+ INIT_AS_UNDEFINED(_prevSpeed)
+ _prevSpeed_MoveBits = 0;
+
+ _prevTime = ::GetTickCount();
+ _elapsedTime = 0;
+
+ INIT_AS_UNDEFINED(_totalBytes_Prev)
+ INIT_AS_UNDEFINED(_processed_Prev)
+ INIT_AS_UNDEFINED(_packed_Prev)
+ INIT_AS_UNDEFINED(_ratio_Prev)
+
+ _filesStr_Prev.Empty();
+ _filesTotStr_Prev.Empty();
+
+ _foreground = true;
+
+ m_ProgressBar.Attach(GetItem(IDC_PROGRESS1));
+ _messageList.Attach(GetItem(IDL_PROGRESS_MESSAGES));
+ _messageList.SetUnicodeFormat();
+ _messageList.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT);
+
+ _wasCreated = true;
+ _dialogCreatedEvent.Set();
+
+ #ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ LangSetDlgItems_Colon(*this, kLangIDs_Colon, Z7_ARRAY_SIZE(kLangIDs_Colon));
+ #endif
+
+ CWindow window(GetItem(IDB_PROGRESS_BACKGROUND));
+ window.GetText(_background_String);
+ _backgrounded_String = _background_String;
+ _backgrounded_String.RemoveChar(L'&');
+
+ window = GetItem(IDB_PAUSE);
+ window.GetText(_pause_String);
+
+ LangString(IDS_PROGRESS_FOREGROUND, _foreground_String);
+ LangString(IDS_CONTINUE, _continue_String);
+ LangString(IDS_PROGRESS_PAUSED, _paused_String);
+
+ SetText(_title);
+ SetPauseText();
+ SetPriorityText();
+
+ _messageList.InsertColumn(0, L"", 30);
+ _messageList.InsertColumn(1, L"", 600);
+
+ _messageList.SetColumnWidthAuto(0);
+ _messageList.SetColumnWidthAuto(1);
+
+ EnableErrorsControls(false);
+
+ GetItemSizes(IDCANCEL, _buttonSizeX, _buttonSizeY);
+ _numReduceSymbols = kCurrentFileNameSizeLimit;
+ NormalizeSize(true);
+
+ if (!ShowCompressionInfo)
+ {
+ HideItem(IDT_PROGRESS_PACKED);
+ HideItem(IDT_PROGRESS_PACKED_VAL);
+ HideItem(IDT_PROGRESS_RATIO);
+ HideItem(IDT_PROGRESS_RATIO_VAL);
+ }
+
+ if (IconID >= 0)
+ {
+ HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IconID));
+ // SetIcon(ICON_SMALL, icon);
+ SetIcon(ICON_BIG, icon);
+ }
+ _timer = SetTimer(kTimerID, kTimerElapse);
+ #ifdef UNDER_CE
+ Foreground();
+ #endif
+
+ CheckNeedClose();
+
+ SetTaskbarProgressState();
+
+ return CModalDialog::OnInit();
+}
+
+static const UINT kIDs[] =
+{
+ IDT_PROGRESS_ELAPSED, IDT_PROGRESS_ELAPSED_VAL,
+ IDT_PROGRESS_REMAINING, IDT_PROGRESS_REMAINING_VAL,
+ IDT_PROGRESS_FILES, IDT_PROGRESS_FILES_VAL,
+ 0, IDT_PROGRESS_FILES_TOTAL,
+ IDT_PROGRESS_ERRORS, IDT_PROGRESS_ERRORS_VAL,
+
+ IDT_PROGRESS_TOTAL, IDT_PROGRESS_TOTAL_VAL,
+ IDT_PROGRESS_SPEED, IDT_PROGRESS_SPEED_VAL,
+ IDT_PROGRESS_PROCESSED, IDT_PROGRESS_PROCESSED_VAL,
+ IDT_PROGRESS_PACKED, IDT_PROGRESS_PACKED_VAL,
+ IDT_PROGRESS_RATIO, IDT_PROGRESS_RATIO_VAL
+};
+
+bool CProgressDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int sY;
+ int sStep;
+ int mx, my;
+ {
+ RECT r;
+ GetClientRectOfItem(IDT_PROGRESS_ELAPSED, r);
+ mx = r.left;
+ my = r.top;
+ sY = RECT_SIZE_Y(r);
+ GetClientRectOfItem(IDT_PROGRESS_REMAINING, r);
+ sStep = r.top - my;
+ }
+
+ InvalidateRect(NULL);
+
+ const int xSizeClient = xSize - mx * 2;
+
+ {
+ unsigned i;
+ for (i = 800; i > 40; i = i * 9 / 10)
+ if (Units_To_Pixels_X((int)i) <= xSizeClient)
+ break;
+ _numReduceSymbols = i / 4;
+ }
+
+ int yPos = ySize - my - _buttonSizeY;
+
+ ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_STATUS), xSize - mx * 2);
+ ChangeSubWindowSizeX(GetItem(IDT_PROGRESS_FILE_NAME), xSize - mx * 2);
+ ChangeSubWindowSizeX(GetItem(IDC_PROGRESS1), xSize - mx * 2);
+
+ int bSizeX = _buttonSizeX;
+ int mx2 = mx;
+ for (;; mx2--)
+ {
+ const int bSize2 = bSizeX * 3 + mx2 * 2;
+ if (bSize2 <= xSizeClient)
+ break;
+ if (mx2 < 5)
+ {
+ bSizeX = (xSizeClient - mx2 * 2) / 3;
+ break;
+ }
+ }
+ if (bSizeX < 2)
+ bSizeX = 2;
+
+ {
+ RECT r;
+ GetClientRectOfItem(IDL_PROGRESS_MESSAGES, r);
+ const int y = r.top;
+ int ySize2 = yPos - my - y;
+ const int kMinYSize = _buttonSizeY + _buttonSizeY * 3 / 4;
+ int xx = xSize - mx * 2;
+ if (ySize2 < kMinYSize)
+ {
+ ySize2 = kMinYSize;
+ if (xx > bSizeX * 2)
+ xx -= bSizeX;
+ }
+
+ _messageList.Move(mx, y, xx, ySize2);
+ }
+
+ {
+ int xPos = xSize - mx;
+ xPos -= bSizeX;
+ MoveItem(IDCANCEL, xPos, yPos, bSizeX, _buttonSizeY);
+ xPos -= (mx2 + bSizeX);
+ MoveItem(IDB_PAUSE, xPos, yPos, bSizeX, _buttonSizeY);
+ xPos -= (mx2 + bSizeX);
+ MoveItem(IDB_PROGRESS_BACKGROUND, xPos, yPos, bSizeX, _buttonSizeY);
+ }
+
+ int valueSize;
+ int labelSize;
+ int padSize;
+
+ labelSize = Units_To_Pixels_X(MY_PROGRESS_LABEL_UNITS_MIN);
+ valueSize = Units_To_Pixels_X(MY_PROGRESS_VAL_UNITS);
+ padSize = Units_To_Pixels_X(MY_PROGRESS_PAD_UNITS);
+ const int requiredSize = (labelSize + valueSize) * 2 + padSize;
+
+ int gSize;
+ {
+ if (requiredSize < xSizeClient)
+ {
+ const int incr = (xSizeClient - requiredSize) / 3;
+ labelSize += incr;
+ }
+ else
+ labelSize = (xSizeClient - valueSize * 2 - padSize) / 2;
+ if (labelSize < 0)
+ labelSize = 0;
+
+ gSize = labelSize + valueSize;
+ padSize = xSizeClient - gSize * 2;
+ }
+
+ labelSize = gSize - valueSize;
+
+ yPos = my;
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(kIDs); i += 2)
+ {
+ int x = mx;
+ const unsigned kNumColumn1Items = 5 * 2;
+ if (i >= kNumColumn1Items)
+ {
+ if (i == kNumColumn1Items)
+ yPos = my;
+ x = mx + gSize + padSize;
+ }
+ if (kIDs[i] != 0)
+ MoveItem(kIDs[i], x, yPos, labelSize, sY);
+ MoveItem(kIDs[i + 1], x + labelSize, yPos, valueSize, sY);
+ yPos += sStep;
+ }
+ return false;
+}
+
+void CProgressDialog::OnCancel() { Sync.Set_Stopped(true); }
+void CProgressDialog::OnOK() { }
+
+void CProgressDialog::SetProgressRange(UInt64 range)
+{
+ if (range == _progressBar_Range)
+ return;
+ _progressBar_Range = range;
+ INIT_AS_UNDEFINED(_progressBar_Pos)
+ _progressConv.Init(range);
+ m_ProgressBar.SetRange32(0, _progressConv.Count(range));
+}
+
+void CProgressDialog::SetProgressPos(UInt64 pos)
+{
+ if (pos >= _progressBar_Range ||
+ pos <= _progressBar_Pos ||
+ pos - _progressBar_Pos >= (_progressBar_Range >> 10))
+ {
+ m_ProgressBar.SetPos(_progressConv.Count(pos));
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ if (_taskbarList && _hwndForTaskbar)
+ _taskbarList->SetProgressValue(_hwndForTaskbar, pos, _progressBar_Range);
+ // #endif
+ _progressBar_Pos = pos;
+ }
+}
+
+#define UINT_TO_STR_2(val) { s[0] = (wchar_t)('0' + (val) / 10); s[1] = (wchar_t)('0' + (val) % 10); s += 2; }
+
+void GetTimeString(UInt64 timeValue, wchar_t *s);
+void GetTimeString(UInt64 timeValue, wchar_t *s)
+{
+ UInt64 hours = timeValue / 3600;
+ UInt32 seconds = (UInt32)(timeValue - hours * 3600);
+ UInt32 minutes = seconds / 60;
+ seconds %= 60;
+ if (hours > 99)
+ {
+ ConvertUInt64ToString(hours, s);
+ for (; *s != 0; s++);
+ }
+ else
+ {
+ UInt32 hours32 = (UInt32)hours;
+ UINT_TO_STR_2(hours32)
+ }
+ *s++ = ':'; UINT_TO_STR_2(minutes)
+ *s++ = ':'; UINT_TO_STR_2(seconds)
+ *s = 0;
+}
+
+static void ConvertSizeToString(UInt64 v, wchar_t *s)
+{
+ Byte c = 0;
+ if (v >= ((UInt64)100000 << 20)) { v >>= 30; c = 'G'; }
+ else if (v >= ((UInt64)100000 << 10)) { v >>= 20; c = 'M'; }
+ else if (v >= ((UInt64)100000 << 0)) { v >>= 10; c = 'K'; }
+ ConvertUInt64ToString(v, s);
+ if (c != 0)
+ {
+ s += MyStringLen(s);
+ *s++ = ' ';
+ *s++ = c;
+ *s++ = 'B';
+ *s++ = 0;
+ }
+}
+
+void CProgressDialog::ShowSize(unsigned id, UInt64 val, UInt64 &prev)
+{
+ if (val == prev)
+ return;
+ prev = val;
+ wchar_t s[40];
+ s[0] = 0;
+ if (IS_DEFINED_VAL(val))
+ ConvertSizeToString(val, s);
+ SetItemText(id, s);
+}
+
+static void GetChangedString(const UString &newStr, UString &prevStr, bool &hasChanged)
+{
+ hasChanged = !(prevStr == newStr);
+ if (hasChanged)
+ prevStr = newStr;
+}
+
+static unsigned GetPower32(UInt32 val)
+{
+ const unsigned kStart = 32;
+ UInt32 mask = ((UInt32)1 << (kStart - 1));
+ for (unsigned i = kStart;; i--)
+ {
+ if (i == 0 || (val & mask) != 0)
+ return i;
+ mask >>= 1;
+ }
+}
+
+static unsigned GetPower64(UInt64 val)
+{
+ UInt32 high = (UInt32)(val >> 32);
+ if (high == 0)
+ return GetPower32((UInt32)val);
+ return GetPower32(high) + 32;
+}
+
+static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider)
+{
+ unsigned pow1 = GetPower64(mult1);
+ unsigned pow2 = GetPower64(mult2);
+ while (pow1 + pow2 > 64)
+ {
+ if (pow1 > pow2) { pow1--; mult1 >>= 1; }
+ else { pow2--; mult2 >>= 1; }
+ divider >>= 1;
+ }
+ UInt64 res = mult1 * mult2;
+ if (divider != 0)
+ res /= divider;
+ return res;
+}
+
+void CProgressDialog::UpdateStatInfo(bool showAll)
+{
+ UInt64 total, completed, totalFiles, completedFiles, inSize, outSize;
+ bool bytesProgressMode;
+
+ bool titleFileName_Changed;
+ bool curFilePath_Changed;
+ bool status_Changed;
+ unsigned numErrors;
+ {
+ NSynchronization::CCriticalSectionLock lock(Sync._cs);
+ total = Sync._totalBytes;
+ completed = Sync._completedBytes;
+ totalFiles = Sync._totalFiles;
+ completedFiles = Sync._curFiles;
+ inSize = Sync._inSize;
+ outSize = Sync._outSize;
+ bytesProgressMode = Sync._bytesProgressMode;
+
+ GetChangedString(Sync._titleFileName, _titleFileName, titleFileName_Changed);
+ GetChangedString(Sync._filePath, _filePath, curFilePath_Changed);
+ GetChangedString(Sync._status, _status, status_Changed);
+ if (_isDir != Sync._isDir)
+ {
+ curFilePath_Changed = true;
+ _isDir = Sync._isDir;
+ }
+ numErrors = Sync.Messages.Size();
+ }
+
+ UInt32 curTime = ::GetTickCount();
+
+ const UInt64 progressTotal = bytesProgressMode ? total : totalFiles;
+ const UInt64 progressCompleted = bytesProgressMode ? completed : completedFiles;
+ {
+ if (IS_UNDEFINED_VAL(progressTotal))
+ {
+ // SetPos(0);
+ // SetRange(progressCompleted);
+ }
+ else
+ {
+ if (_progressBar_Pos != 0 || progressCompleted != 0 ||
+ (_progressBar_Range == 0 && progressTotal != 0))
+ {
+ SetProgressRange(progressTotal);
+ SetProgressPos(progressCompleted);
+ }
+ }
+ }
+
+ ShowSize(IDT_PROGRESS_TOTAL_VAL, total, _totalBytes_Prev);
+
+ _elapsedTime += (curTime - _prevTime);
+ _prevTime = curTime;
+ UInt64 elapsedSec = _elapsedTime / 1000;
+ bool elapsedChanged = false;
+ if (elapsedSec != _prevElapsedSec)
+ {
+ _prevElapsedSec = elapsedSec;
+ elapsedChanged = true;
+ wchar_t s[40];
+ GetTimeString(elapsedSec, s);
+ SetItemText(IDT_PROGRESS_ELAPSED_VAL, s);
+ }
+
+ bool needSetTitle = false;
+ if (elapsedChanged || showAll)
+ {
+ if (numErrors > _numPostedMessages)
+ {
+ UpdateMessagesDialog();
+ wchar_t s[32];
+ ConvertUInt64ToString(numErrors, s);
+ SetItemText(IDT_PROGRESS_ERRORS_VAL, s);
+ if (!_errorsWereDisplayed)
+ {
+ _errorsWereDisplayed = true;
+ EnableErrorsControls(true);
+ SetTaskbarProgressState();
+ }
+ }
+
+ if (progressCompleted != 0)
+ {
+ if (IS_UNDEFINED_VAL(progressTotal))
+ {
+ if (IS_DEFINED_VAL(_prevRemainingSec))
+ {
+ INIT_AS_UNDEFINED(_prevRemainingSec)
+ SetItemText(IDT_PROGRESS_REMAINING_VAL, L"");
+ }
+ }
+ else
+ {
+ UInt64 remainingTime = 0;
+ if (progressCompleted < progressTotal)
+ remainingTime = MyMultAndDiv(_elapsedTime, progressTotal - progressCompleted, progressCompleted);
+ UInt64 remainingSec = remainingTime / 1000;
+ if (remainingSec != _prevRemainingSec)
+ {
+ _prevRemainingSec = remainingSec;
+ wchar_t s[40];
+ GetTimeString(remainingSec, s);
+ SetItemText(IDT_PROGRESS_REMAINING_VAL, s);
+ }
+ }
+ {
+ const UInt64 elapsedTime = (_elapsedTime == 0) ? 1 : _elapsedTime;
+ // 22.02: progressCompleted can be for number of files
+ UInt64 v = (completed * 1000) / elapsedTime;
+ Byte c = 0;
+ unsigned moveBits = 0;
+ if (v >= ((UInt64)10000 << 10)) { moveBits = 20; c = 'M'; }
+ else if (v >= ((UInt64)10000 << 0)) { moveBits = 10; c = 'K'; }
+ v >>= moveBits;
+ if (moveBits != _prevSpeed_MoveBits || v != _prevSpeed)
+ {
+ _prevSpeed_MoveBits = moveBits;
+ _prevSpeed = v;
+ wchar_t s[40];
+ ConvertUInt64ToString(v, s);
+ unsigned pos = MyStringLen(s);
+ s[pos++] = ' ';
+ if (moveBits != 0)
+ s[pos++] = c;
+ s[pos++] = 'B';
+ s[pos++] = '/';
+ s[pos++] = 's';
+ s[pos++] = 0;
+ SetItemText(IDT_PROGRESS_SPEED_VAL, s);
+ }
+ }
+ }
+
+ {
+ UInt64 percent = 0;
+ {
+ if (IS_DEFINED_VAL(progressTotal))
+ {
+ percent = progressCompleted * 100;
+ if (progressTotal != 0)
+ percent /= progressTotal;
+ }
+ }
+ if (percent != _prevPercentValue)
+ {
+ _prevPercentValue = percent;
+ needSetTitle = true;
+ }
+ }
+
+ {
+ wchar_t s[64];
+
+ ConvertUInt64ToString(completedFiles, s);
+ if (_filesStr_Prev != s)
+ {
+ _filesStr_Prev = s;
+ SetItemText(IDT_PROGRESS_FILES_VAL, s);
+ }
+
+ s[0] = 0;
+ if (IS_DEFINED_VAL(totalFiles))
+ {
+ MyStringCopy(s, L" / ");
+ ConvertUInt64ToString(totalFiles, s + MyStringLen(s));
+ }
+ if (_filesTotStr_Prev != s)
+ {
+ _filesTotStr_Prev = s;
+ SetItemText(IDT_PROGRESS_FILES_TOTAL, s);
+ }
+ }
+
+ const UInt64 packSize = CompressingMode ? outSize : inSize;
+ const UInt64 unpackSize = CompressingMode ? inSize : outSize;
+
+ if (IS_UNDEFINED_VAL(unpackSize) &&
+ IS_UNDEFINED_VAL(packSize))
+ {
+ ShowSize(IDT_PROGRESS_PROCESSED_VAL, completed, _processed_Prev);
+ ShowSize(IDT_PROGRESS_PACKED_VAL, UNDEFINED_VAL, _packed_Prev);
+ }
+ else
+ {
+ ShowSize(IDT_PROGRESS_PROCESSED_VAL, unpackSize, _processed_Prev);
+ ShowSize(IDT_PROGRESS_PACKED_VAL, packSize, _packed_Prev);
+
+ if (IS_DEFINED_VAL(packSize) &&
+ IS_DEFINED_VAL(unpackSize) &&
+ unpackSize != 0)
+ {
+ wchar_t s[32];
+ UInt64 ratio = packSize * 100 / unpackSize;
+ if (_ratio_Prev != ratio)
+ {
+ _ratio_Prev = ratio;
+ ConvertUInt64ToString(ratio, s);
+ MyStringCat(s, L"%");
+ SetItemText(IDT_PROGRESS_RATIO_VAL, s);
+ }
+ }
+ }
+ }
+
+ if (needSetTitle || titleFileName_Changed)
+ SetTitleText();
+
+ if (status_Changed)
+ {
+ UString s = _status;
+ ReduceString(s, _numReduceSymbols);
+ SetItemText(IDT_PROGRESS_STATUS, _status);
+ }
+
+ if (curFilePath_Changed)
+ {
+ UString s1, s2;
+ if (_isDir)
+ s1 = _filePath;
+ else
+ {
+ int slashPos = _filePath.ReverseFind_PathSepar();
+ if (slashPos >= 0)
+ {
+ s1.SetFrom(_filePath, (unsigned)(slashPos + 1));
+ s2 = _filePath.Ptr((unsigned)(slashPos + 1));
+ }
+ else
+ s2 = _filePath;
+ }
+ ReduceString(s1, _numReduceSymbols);
+ ReduceString(s2, _numReduceSymbols);
+ s1.Add_LF();
+ s1 += s2;
+ SetItemText(IDT_PROGRESS_FILE_NAME, s1);
+ }
+}
+
+bool CProgressDialog::OnTimer(WPARAM /* timerID */, LPARAM /* callback */)
+{
+ if (Sync.Get_Paused())
+ return true;
+ CheckNeedClose();
+ UpdateStatInfo(false);
+ return true;
+}
+
+struct CWaitCursor
+{
+ HCURSOR _waitCursor;
+ HCURSOR _oldCursor;
+ CWaitCursor()
+ {
+ _waitCursor = LoadCursor(NULL, IDC_WAIT);
+ if (_waitCursor != NULL)
+ _oldCursor = SetCursor(_waitCursor);
+ }
+ ~CWaitCursor()
+ {
+ if (_waitCursor != NULL)
+ SetCursor(_oldCursor);
+ }
+};
+
+INT_PTR CProgressDialog::Create(const UString &title, NWindows::CThread &thread, HWND wndParent)
+{
+ INT_PTR res = 0;
+ try
+ {
+ if (WaitMode)
+ {
+ CWaitCursor waitCursor;
+ HANDLE h[] = { thread, _createDialogEvent };
+
+ const DWORD res2 = WaitForMultipleObjects(Z7_ARRAY_SIZE(h), h, FALSE, kCreateDelay);
+ if (res2 == WAIT_OBJECT_0 && !Sync.ThereIsMessage())
+ return 0;
+ }
+ _title = title;
+ BIG_DIALOG_SIZE(360, 192);
+ res = CModalDialog::Create(SIZED_DIALOG(IDD_PROGRESS), wndParent);
+ }
+ catch(...)
+ {
+ _wasCreated = true;
+ _dialogCreatedEvent.Set();
+ }
+ thread.Wait_Close();
+ if (!MessagesDisplayed)
+ MessageBoxW(wndParent, L"Progress Error", L"7-Zip", MB_ICONERROR);
+ return res;
+}
+
+bool CProgressDialog::OnExternalCloseMessage()
+{
+ // it doesn't work if there is MessageBox.
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ SetTaskbarProgressState(TBPF_NOPROGRESS);
+ // #endif
+ // AddToTitle(L"Finished ");
+ // SetText(L"Finished2 ");
+
+ UpdateStatInfo(true);
+
+ SetItemText(IDCANCEL, LangString(IDS_CLOSE));
+ ::SendMessage(GetItem(IDCANCEL), BM_SETSTYLE, BS_DEFPUSHBUTTON, MAKELPARAM(TRUE, 0));
+ HideItem(IDB_PROGRESS_BACKGROUND);
+ HideItem(IDB_PAUSE);
+
+ ProcessWasFinished_GuiVirt();
+
+ bool thereAreMessages;
+ CProgressFinalMessage fm;
+ {
+ NSynchronization::CCriticalSectionLock lock(Sync._cs);
+ thereAreMessages = !Sync.Messages.IsEmpty();
+ fm = Sync.FinalMessage;
+ }
+
+ if (!fm.ErrorMessage.Message.IsEmpty())
+ {
+ MessagesDisplayed = true;
+ if (fm.ErrorMessage.Title.IsEmpty())
+ fm.ErrorMessage.Title = "7-Zip";
+ MessageBoxW(*this, fm.ErrorMessage.Message, fm.ErrorMessage.Title, MB_ICONERROR);
+ }
+ else if (!thereAreMessages)
+ {
+ MessagesDisplayed = true;
+
+ if (!fm.OkMessage.Message.IsEmpty())
+ {
+ if (fm.OkMessage.Title.IsEmpty())
+ fm.OkMessage.Title = "7-Zip";
+ MessageBoxW(*this, fm.OkMessage.Message, fm.OkMessage.Title, MB_OK);
+ }
+ }
+
+ if (thereAreMessages && !_cancelWasPressed)
+ {
+ _waitCloseByCancelButton = true;
+ UpdateMessagesDialog();
+ return true;
+ }
+
+ End(0);
+ return true;
+}
+
+bool CProgressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case kCloseMessage:
+ {
+ if (_timer)
+ {
+ /* 21.03 : KillTimer(kTimerID) instead of KillTimer(_timer).
+ But (_timer == kTimerID) in Win10. So it worked too */
+ KillTimer(kTimerID);
+ _timer = 0;
+ }
+ if (_inCancelMessageBox)
+ {
+ /* if user is in MessageBox(), we will call OnExternalCloseMessage()
+ later, when MessageBox() will be closed */
+ _externalCloseMessageWasReceived = true;
+ break;
+ }
+ return OnExternalCloseMessage();
+ }
+ /*
+ case WM_SETTEXT:
+ {
+ if (_timer == 0)
+ return true;
+ break;
+ }
+ */
+ }
+ return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+void CProgressDialog::SetTitleText()
+{
+ UString s;
+ if (Sync.Get_Paused())
+ {
+ s += _paused_String;
+ s.Add_Space();
+ }
+ if (IS_DEFINED_VAL(_prevPercentValue))
+ {
+ char temp[32];
+ ConvertUInt64ToString(_prevPercentValue, temp);
+ s += temp;
+ s += '%';
+ }
+ if (!_foreground)
+ {
+ s.Add_Space();
+ s += _backgrounded_String;
+ }
+
+ s.Add_Space();
+ #ifndef Z7_SFX
+ {
+ unsigned len = s.Len();
+ s += MainAddTitle;
+ AddToTitle(s);
+ s.DeleteFrom(len);
+ }
+ #endif
+
+ s += _title;
+ if (!_titleFileName.IsEmpty())
+ {
+ UString fileName = _titleFileName;
+ ReduceString(fileName, kTitleFileNameSizeLimit);
+ s.Add_Space();
+ s += fileName;
+ }
+ SetText(s);
+}
+
+void CProgressDialog::SetPauseText()
+{
+ SetItemText(IDB_PAUSE, Sync.Get_Paused() ? _continue_String : _pause_String);
+ SetTitleText();
+}
+
+void CProgressDialog::OnPauseButton()
+{
+ bool paused = !Sync.Get_Paused();
+ Sync.Set_Paused(paused);
+ UInt32 curTime = ::GetTickCount();
+ if (paused)
+ _elapsedTime += (curTime - _prevTime);
+ SetTaskbarProgressState();
+ _prevTime = curTime;
+ SetPauseText();
+}
+
+void CProgressDialog::SetPriorityText()
+{
+ SetItemText(IDB_PROGRESS_BACKGROUND, _foreground ?
+ _background_String :
+ _foreground_String);
+ SetTitleText();
+}
+
+void CProgressDialog::OnPriorityButton()
+{
+ _foreground = !_foreground;
+ #ifndef UNDER_CE
+ SetPriorityClass(GetCurrentProcess(), _foreground ? NORMAL_PRIORITY_CLASS: IDLE_PRIORITY_CLASS);
+ #endif
+ SetPriorityText();
+}
+
+void CProgressDialog::AddMessageDirect(LPCWSTR message, bool needNumber)
+{
+ wchar_t sz[16];
+ sz[0] = 0;
+ if (needNumber)
+ ConvertUInt32ToString(_numMessages + 1, sz);
+ const unsigned itemIndex = _messageStrings.Size(); // _messageList.GetItemCount();
+ if (_messageList.InsertItem(itemIndex, sz) == (int)itemIndex)
+ {
+ _messageList.SetSubItem(itemIndex, 1, message);
+ _messageStrings.Add(message);
+ }
+}
+
+void CProgressDialog::AddMessage(LPCWSTR message)
+{
+ UString s = message;
+ bool needNumber = true;
+ while (!s.IsEmpty())
+ {
+ const int pos = s.Find(L'\n');
+ if (pos < 0)
+ break;
+ AddMessageDirect(s.Left((unsigned)pos), needNumber);
+ needNumber = false;
+ s.DeleteFrontal((unsigned)pos + 1);
+ }
+ AddMessageDirect(s, needNumber);
+ _numMessages++;
+}
+
+static unsigned GetNumDigits(UInt32 val)
+{
+ unsigned i;
+ for (i = 0; val >= 10; i++)
+ val /= 10;
+ return i;
+}
+
+void CProgressDialog::UpdateMessagesDialog()
+{
+ UStringVector messages;
+ {
+ NSynchronization::CCriticalSectionLock lock(Sync._cs);
+ unsigned num = Sync.Messages.Size();
+ if (num > _numPostedMessages)
+ {
+ messages.ClearAndReserve(num - _numPostedMessages);
+ for (unsigned i = _numPostedMessages; i < num; i++)
+ messages.AddInReserved(Sync.Messages[i]);
+ _numPostedMessages = num;
+ }
+ }
+ if (!messages.IsEmpty())
+ {
+ FOR_VECTOR (i, messages)
+ AddMessage(messages[i]);
+ if (_numAutoSizeMessages < 256 || GetNumDigits(_numPostedMessages) > GetNumDigits(_numAutoSizeMessages))
+ {
+ _messageList.SetColumnWidthAuto(0);
+ _messageList.SetColumnWidthAuto(1);
+ _numAutoSizeMessages = _numPostedMessages;
+ }
+ }
+}
+
+
+bool CProgressDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ // case IDOK: // if IDCANCEL is not DEFPUSHBUTTON
+ case IDCANCEL:
+ {
+ if (_waitCloseByCancelButton)
+ {
+ MessagesDisplayed = true;
+ End(IDCLOSE);
+ break;
+ }
+
+ if (_cancelWasPressed)
+ return true;
+
+ const bool paused = Sync.Get_Paused();
+
+ if (!paused)
+ {
+ OnPauseButton();
+ }
+
+ _inCancelMessageBox = true;
+ const int res = ::MessageBoxW(*this, LangString(IDS_PROGRESS_ASK_CANCEL), _title, MB_YESNOCANCEL);
+ _inCancelMessageBox = false;
+ if (res == IDYES)
+ _cancelWasPressed = true;
+
+ if (!paused)
+ {
+ OnPauseButton();
+ }
+
+ if (_externalCloseMessageWasReceived)
+ {
+ /* we have received kCloseMessage while we were in MessageBoxW().
+ so we call OnExternalCloseMessage() here.
+ it can show MessageBox and it can close dialog */
+ OnExternalCloseMessage();
+ return true;
+ }
+
+ if (!_cancelWasPressed)
+ return true;
+
+ MessagesDisplayed = true;
+ // we will call Sync.Set_Stopped(true) in OnButtonClicked() : OnCancel()
+ break;
+ }
+
+ case IDB_PAUSE:
+ OnPauseButton();
+ return true;
+ case IDB_PROGRESS_BACKGROUND:
+ OnPriorityButton();
+ return true;
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CProgressDialog::CheckNeedClose()
+{
+ if (_needClose)
+ {
+ PostMsg(kCloseMessage);
+ _needClose = false;
+ }
+}
+
+void CProgressDialog::ProcessWasFinished()
+{
+ // Set Window title here.
+ if (!WaitMode)
+ WaitCreating();
+
+ if (_wasCreated)
+ PostMsg(kCloseMessage);
+ else
+ _needClose = true;
+}
+
+
+bool CProgressDialog::OnNotify(UINT /* controlID */, LPNMHDR header)
+{
+ if (header->hwndFrom != _messageList)
+ return false;
+ switch (header->code)
+ {
+ case LVN_KEYDOWN:
+ {
+ LPNMLVKEYDOWN keyDownInfo = LPNMLVKEYDOWN(header);
+ switch (keyDownInfo->wVKey)
+ {
+ case 'A':
+ {
+ if (IsKeyDown(VK_CONTROL))
+ {
+ _messageList.SelectAll();
+ return true;
+ }
+ break;
+ }
+ case VK_INSERT:
+ case 'C':
+ {
+ if (IsKeyDown(VK_CONTROL))
+ {
+ CopyToClipboard();
+ return true;
+ }
+ break;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+
+static void ListView_GetSelected(NControl::CListView &listView, CUIntVector &vector)
+{
+ vector.Clear();
+ int index = -1;
+ for (;;)
+ {
+ index = listView.GetNextSelectedItem(index);
+ if (index < 0)
+ break;
+ vector.Add((unsigned)index);
+ }
+}
+
+
+void CProgressDialog::CopyToClipboard()
+{
+ CUIntVector indexes;
+ ListView_GetSelected(_messageList, indexes);
+ UString s;
+ unsigned numIndexes = indexes.Size();
+ if (numIndexes == 0)
+ numIndexes = (unsigned)_messageList.GetItemCount();
+
+ for (unsigned i = 0; i < numIndexes; i++)
+ {
+ const unsigned index = (i < indexes.Size() ? indexes[i] : i);
+ // s.Add_UInt32(index);
+ // s += ": ";
+ s += _messageStrings[index];
+ {
+ s +=
+ #ifdef _WIN32
+ "\r\n"
+ #else
+ "\n"
+ #endif
+ ;
+ }
+ }
+
+ ClipboardSetText(*this, s);
+}
+
+
+static THREAD_FUNC_DECL MyThreadFunction(void *param)
+{
+ CProgressThreadVirt *p = (CProgressThreadVirt *)param;
+ try
+ {
+ p->Process();
+ p->ThreadFinishedOK = true;
+ }
+ catch (...) { p->Result = E_FAIL; }
+ return 0;
+}
+
+
+HRESULT CProgressThreadVirt::Create(const UString &title, HWND parentWindow)
+{
+ NWindows::CThread thread;
+ const WRes wres = thread.Create(MyThreadFunction, this);
+ if (wres != 0)
+ return HRESULT_FROM_WIN32(wres);
+ CProgressDialog::Create(title, thread, parentWindow);
+ return S_OK;
+}
+
+static void AddMessageToString(UString &dest, const UString &src)
+{
+ if (!src.IsEmpty())
+ {
+ if (!dest.IsEmpty())
+ dest.Add_LF();
+ dest += src;
+ }
+}
+
+void CProgressThreadVirt::Process()
+{
+ CProgressCloser closer(*this);
+ UString m;
+ try { Result = ProcessVirt(); }
+ catch(const wchar_t *s) { m = s; }
+ catch(const UString &s) { m = s; }
+ catch(const char *s) { m = GetUnicodeString(s); }
+ catch(int v)
+ {
+ m = "Error #";
+ m.Add_UInt32((unsigned)v);
+ }
+ catch(...) { m = "Error"; }
+ if (Result != E_ABORT)
+ {
+ if (m.IsEmpty() && Result != S_OK)
+ m = HResultToMessage(Result);
+ }
+ AddMessageToString(m, FinalMessage.ErrorMessage.Message);
+
+ {
+ FOR_VECTOR(i, ErrorPaths)
+ {
+ if (i >= 32)
+ break;
+ AddMessageToString(m, fs2us(ErrorPaths[i]));
+ }
+ }
+
+ CProgressSync &sync = Sync;
+ NSynchronization::CCriticalSectionLock lock(sync._cs);
+ if (m.IsEmpty())
+ {
+ if (!FinalMessage.OkMessage.Message.IsEmpty())
+ sync.FinalMessage.OkMessage = FinalMessage.OkMessage;
+ }
+ else
+ {
+ sync.FinalMessage.ErrorMessage.Message = m;
+ if (Result == S_OK)
+ Result = E_FAIL;
+ }
+}
+
+UString HResultToMessage(HRESULT errorCode)
+{
+ if (errorCode == E_OUTOFMEMORY)
+ return LangString(IDS_MEM_ERROR);
+ else
+ return NError::MyFormatMessage(errorCode);
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.h b/CPP/7zip/UI/FileManager/ProgressDialog2.h
index 5e916e6..4ca9be7 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2.h
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.h
@@ -1,351 +1,358 @@
-// ProgressDialog2.h
-
-#ifndef __PROGRESS_DIALOG_2_H
-#define __PROGRESS_DIALOG_2_H
-
-#include "../../../Common/MyCom.h"
-
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/Synchronization.h"
-#include "../../../Windows/Thread.h"
-
-#include "../../../Windows/Control/Dialog.h"
-#include "../../../Windows/Control/ListView.h"
-#include "../../../Windows/Control/ProgressBar.h"
-
-#include "MyWindowsNew.h"
-
-struct CProgressMessageBoxPair
-{
- UString Title;
- UString Message;
-};
-
-struct CProgressFinalMessage
-{
- CProgressMessageBoxPair ErrorMessage;
- CProgressMessageBoxPair OkMessage;
-
- bool ThereIsMessage() const { return !ErrorMessage.Message.IsEmpty() || !OkMessage.Message.IsEmpty(); }
-};
-
-class CProgressSync
-{
- bool _stopped;
- bool _paused;
-
-public:
- bool _bytesProgressMode;
- UInt64 _totalBytes;
- UInt64 _completedBytes;
- UInt64 _totalFiles;
- UInt64 _curFiles;
- UInt64 _inSize;
- UInt64 _outSize;
-
- UString _titleFileName;
- UString _status;
- UString _filePath;
- bool _isDir;
-
- UStringVector Messages;
- CProgressFinalMessage FinalMessage;
-
- NWindows::NSynchronization::CCriticalSection _cs;
-
- CProgressSync();
-
- bool Get_Stopped()
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- return _stopped;
- }
- void Set_Stopped(bool val)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _stopped = val;
- }
-
- bool Get_Paused();
- void Set_Paused(bool val)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _paused = val;
- }
-
- void Set_BytesProgressMode(bool bytesProgressMode)
- {
- NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
- _bytesProgressMode = bytesProgressMode;
- }
-
- HRESULT CheckStop();
- HRESULT ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir = false);
-
- HRESULT Set_NumFilesTotal(UInt64 val);
- void Set_NumBytesTotal(UInt64 val);
- void Set_NumFilesCur(UInt64 val);
- HRESULT Set_NumBytesCur(const UInt64 *val);
- HRESULT Set_NumBytesCur(UInt64 val);
- void Set_Ratio(const UInt64 *inSize, const UInt64 *outSize);
-
- void Set_TitleFileName(const UString &fileName);
- void Set_Status(const UString &s);
- HRESULT Set_Status2(const UString &s, const wchar_t *path, bool isDir = false);
- void Set_FilePath(const wchar_t *path, bool isDir = false);
-
- void AddError_Message(const wchar_t *message);
- void AddError_Message_Name(const wchar_t *message, const wchar_t *name);
- void AddError_Code_Name(DWORD systemError, const wchar_t *name);
-
- bool ThereIsMessage() const { return !Messages.IsEmpty() || FinalMessage.ThereIsMessage(); }
-};
-
-class CProgressDialog: public NWindows::NControl::CModalDialog
-{
- UString _titleFileName;
- UString _filePath;
- UString _status;
- bool _isDir;
-
- UString _background_String;
- UString _backgrounded_String;
- UString _foreground_String;
- UString _pause_String;
- UString _continue_String;
- UString _paused_String;
-
- int _buttonSizeX;
- int _buttonSizeY;
-
- UINT_PTR _timer;
-
- UString _title;
-
- class CU64ToI32Converter
- {
- unsigned _numShiftBits;
- UInt64 _range;
- public:
- CU64ToI32Converter(): _numShiftBits(0), _range(1) {}
- void Init(UInt64 range)
- {
- _range = range;
- // Windows CE doesn't like big number for ProgressBar.
- for (_numShiftBits = 0; range >= ((UInt32)1 << 15); _numShiftBits++)
- range >>= 1;
- }
- int Count(UInt64 val)
- {
- int res = (int)(val >> _numShiftBits);
- if (val == _range)
- res++;
- return res;
- }
- };
-
- CU64ToI32Converter _progressConv;
- UInt64 _progressBar_Pos;
- UInt64 _progressBar_Range;
-
- NWindows::NControl::CProgressBar m_ProgressBar;
- NWindows::NControl::CListView _messageList;
-
- int _numMessages;
-
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- CMyComPtr<ITaskbarList3> _taskbarList;
- #endif
- HWND _hwndForTaskbar;
-
- UInt32 _prevTime;
- UInt64 _elapsedTime;
-
- UInt64 _prevPercentValue;
- UInt64 _prevElapsedSec;
- UInt64 _prevRemainingSec;
-
- UInt64 _totalBytes_Prev;
- UInt64 _processed_Prev;
- UInt64 _packed_Prev;
- UInt64 _ratio_Prev;
- UString _filesStr_Prev;
-
- unsigned _prevSpeed_MoveBits;
- UInt64 _prevSpeed;
-
- bool _foreground;
-
- unsigned _numReduceSymbols;
-
- bool _wasCreated;
- bool _needClose;
-
- unsigned _numPostedMessages;
- UInt32 _numAutoSizeMessages;
-
- bool _errorsWereDisplayed;
-
- bool _waitCloseByCancelButton;
- bool _cancelWasPressed;
-
- bool _inCancelMessageBox;
- bool _externalCloseMessageWasReceived;
-
-
- #ifdef __ITaskbarList3_INTERFACE_DEFINED__
- void SetTaskbarProgressState(TBPFLAG tbpFlags)
- {
- if (_taskbarList && _hwndForTaskbar)
- _taskbarList->SetProgressState(_hwndForTaskbar, tbpFlags);
- }
- #endif
- void SetTaskbarProgressState();
-
- void UpdateStatInfo(bool showAll);
- bool OnTimer(WPARAM timerID, LPARAM callback);
- void SetProgressRange(UInt64 range);
- void SetProgressPos(UInt64 pos);
- virtual bool OnInit();
- virtual bool OnSize(WPARAM wParam, int xSize, int ySize);
- virtual void OnCancel();
- virtual void OnOK();
- NWindows::NSynchronization::CManualResetEvent _createDialogEvent;
- NWindows::NSynchronization::CManualResetEvent _dialogCreatedEvent;
- #ifndef _SFX
- void AddToTitle(LPCWSTR string);
- #endif
-
- void SetPauseText();
- void SetPriorityText();
- void OnPauseButton();
- void OnPriorityButton();
- bool OnButtonClicked(int buttonID, HWND buttonHWND);
- bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
-
- void SetTitleText();
- void ShowSize(int id, UInt64 val, UInt64 &prev);
-
- void UpdateMessagesDialog();
-
- void AddMessageDirect(LPCWSTR message, bool needNumber);
- void AddMessage(LPCWSTR message);
-
- bool OnExternalCloseMessage();
- void EnableErrorsControls(bool enable);
-
- void ShowAfterMessages(HWND wndParent);
-
- void CheckNeedClose();
-public:
- CProgressSync Sync;
- bool CompressingMode;
- bool WaitMode;
- bool ShowCompressionInfo;
- bool MessagesDisplayed; // = true if user pressed OK on all messages or there are no messages.
- int IconID;
-
- HWND MainWindow;
- #ifndef _SFX
- UString MainTitle;
- UString MainAddTitle;
- ~CProgressDialog();
- #endif
-
- CProgressDialog();
- void WaitCreating()
- {
- _createDialogEvent.Set();
- _dialogCreatedEvent.Lock();
- }
-
- INT_PTR Create(const UString &title, NWindows::CThread &thread, HWND wndParent = 0);
-
-
- /* how it works:
- 1) the working thread calls ProcessWasFinished()
- that sends kCloseMessage message to CProgressDialog (GUI) thread
- 2) CProgressDialog (GUI) thread receives kCloseMessage message and
- calls ProcessWasFinished_GuiVirt();
- So we can implement ProcessWasFinished_GuiVirt() and show special
- results window in GUI thread with CProgressDialog as parent window
- */
-
- void ProcessWasFinished();
- virtual void ProcessWasFinished_GuiVirt() {}
-};
-
-
-class CProgressCloser
-{
- CProgressDialog *_p;
-public:
- CProgressCloser(CProgressDialog &p) : _p(&p) {}
- ~CProgressCloser() { _p->ProcessWasFinished(); }
-};
-
-
-class CProgressThreadVirt: public CProgressDialog
-{
-protected:
- FStringVector ErrorPaths;
- CProgressFinalMessage FinalMessage;
-
- // error if any of HRESULT, ErrorMessage, ErrorPath
- virtual HRESULT ProcessVirt() = 0;
-public:
- HRESULT Result;
- bool ThreadFinishedOK; // if there is no fatal exception
-
- void Process();
- void AddErrorPath(const FString &path) { ErrorPaths.Add(path); }
-
- HRESULT Create(const UString &title, HWND parentWindow = 0);
- CProgressThreadVirt(): Result(E_FAIL), ThreadFinishedOK(false) {}
-
- CProgressMessageBoxPair &GetMessagePair(bool isError) { return isError ? FinalMessage.ErrorMessage : FinalMessage.OkMessage; }
-};
-
-UString HResultToMessage(HRESULT errorCode);
-
-/*
-how it works:
-
-client code inherits CProgressThreadVirt and calls
-CProgressThreadVirt::Create()
-{
- it creates new thread that calls CProgressThreadVirt::Process();
- it creates modal progress dialog window with ProgressDialog.Create()
-}
-
-CProgressThreadVirt::Process()
-{
- {
- ProcessVirt(); // virtual function that must implement real work
- }
- if (exceptions) or FinalMessage.ErrorMessage.Message
- {
- set message to ProgressDialog.Sync.FinalMessage.ErrorMessage.Message
- }
- else if (FinalMessage.OkMessage.Message)
- {
- set message to ProgressDialog.Sync.FinalMessage.OkMessage
- }
-
- PostMsg(kCloseMessage);
-}
-
-
-CProgressDialog::OnExternalCloseMessage()
-{
- if (ProgressDialog.Sync.FinalMessage)
- {
- WorkWasFinishedVirt();
- Show (ProgressDialog.Sync.FinalMessage)
- MessagesDisplayed = true;
- }
-}
-
-*/
-
-#endif
+// ProgressDialog2.h
+
+#ifndef ZIP7_INC_PROGRESS_DIALOG_2_H
+#define ZIP7_INC_PROGRESS_DIALOG_2_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../../Windows/ErrorMsg.h"
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/Thread.h"
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ListView.h"
+#include "../../../Windows/Control/ProgressBar.h"
+
+#include "MyWindowsNew.h"
+
+struct CProgressMessageBoxPair
+{
+ UString Title;
+ UString Message;
+};
+
+struct CProgressFinalMessage
+{
+ CProgressMessageBoxPair ErrorMessage;
+ CProgressMessageBoxPair OkMessage;
+
+ bool ThereIsMessage() const { return !ErrorMessage.Message.IsEmpty() || !OkMessage.Message.IsEmpty(); }
+};
+
+class CProgressSync
+{
+ bool _stopped;
+ bool _paused;
+
+public:
+ bool _bytesProgressMode;
+ bool _isDir;
+ UInt64 _totalBytes;
+ UInt64 _completedBytes;
+ UInt64 _totalFiles;
+ UInt64 _curFiles;
+ UInt64 _inSize;
+ UInt64 _outSize;
+
+ UString _titleFileName;
+ UString _status;
+ UString _filePath;
+
+ UStringVector Messages;
+ CProgressFinalMessage FinalMessage;
+
+ NWindows::NSynchronization::CCriticalSection _cs;
+
+ CProgressSync();
+
+ bool Get_Stopped()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ return _stopped;
+ }
+ void Set_Stopped(bool val)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _stopped = val;
+ }
+
+ bool Get_Paused();
+ void Set_Paused(bool val)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _paused = val;
+ }
+
+ void Set_BytesProgressMode(bool bytesProgressMode)
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(_cs);
+ _bytesProgressMode = bytesProgressMode;
+ }
+
+ HRESULT CheckStop();
+ HRESULT ScanProgress(UInt64 numFiles, UInt64 totalSize, const FString &fileName, bool isDir = false);
+
+ HRESULT Set_NumFilesTotal(UInt64 val);
+ void Set_NumBytesTotal(UInt64 val);
+ void Set_NumFilesCur(UInt64 val);
+ HRESULT Set_NumBytesCur(const UInt64 *val);
+ HRESULT Set_NumBytesCur(UInt64 val);
+ void Set_Ratio(const UInt64 *inSize, const UInt64 *outSize);
+
+ void Set_TitleFileName(const UString &fileName);
+ void Set_Status(const UString &s);
+ HRESULT Set_Status2(const UString &s, const wchar_t *path, bool isDir = false);
+ void Set_FilePath(const wchar_t *path, bool isDir = false);
+
+ void AddError_Message(const wchar_t *message);
+ void AddError_Message_Name(const wchar_t *message, const wchar_t *name);
+ // void AddError_Code_Name(DWORD systemError, const wchar_t *name);
+ void AddError_Code_Name(HRESULT systemError, const wchar_t *name);
+
+ bool ThereIsMessage() const { return !Messages.IsEmpty() || FinalMessage.ThereIsMessage(); }
+};
+
+class CProgressDialog: public NWindows::NControl::CModalDialog
+{
+ UString _titleFileName;
+ UString _filePath;
+ UString _status;
+ bool _isDir;
+
+ UString _background_String;
+ UString _backgrounded_String;
+ UString _foreground_String;
+ UString _pause_String;
+ UString _continue_String;
+ UString _paused_String;
+
+ int _buttonSizeX;
+ int _buttonSizeY;
+
+ UINT_PTR _timer;
+
+ UString _title;
+
+ class CU64ToI32Converter
+ {
+ unsigned _numShiftBits;
+ UInt64 _range;
+ public:
+ CU64ToI32Converter(): _numShiftBits(0), _range(1) {}
+ void Init(UInt64 range)
+ {
+ _range = range;
+ // Windows CE doesn't like big number for ProgressBar.
+ for (_numShiftBits = 0; range >= ((UInt32)1 << 15); _numShiftBits++)
+ range >>= 1;
+ }
+ int Count(UInt64 val)
+ {
+ int res = (int)(val >> _numShiftBits);
+ if (val == _range)
+ res++;
+ return res;
+ }
+ };
+
+ CU64ToI32Converter _progressConv;
+ UInt64 _progressBar_Pos;
+ UInt64 _progressBar_Range;
+
+ NWindows::NControl::CProgressBar m_ProgressBar;
+ NWindows::NControl::CListView _messageList;
+
+ unsigned _numMessages;
+ UStringVector _messageStrings;
+
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ CMyComPtr<ITaskbarList3> _taskbarList;
+ // #endif
+ HWND _hwndForTaskbar;
+
+ UInt32 _prevTime;
+ UInt64 _elapsedTime;
+
+ UInt64 _prevPercentValue;
+ UInt64 _prevElapsedSec;
+ UInt64 _prevRemainingSec;
+
+ UInt64 _totalBytes_Prev;
+ UInt64 _processed_Prev;
+ UInt64 _packed_Prev;
+ UInt64 _ratio_Prev;
+
+ UString _filesStr_Prev;
+ UString _filesTotStr_Prev;
+
+ unsigned _prevSpeed_MoveBits;
+ UInt64 _prevSpeed;
+
+ bool _foreground;
+
+ unsigned _numReduceSymbols;
+
+ bool _wasCreated;
+ bool _needClose;
+
+ unsigned _numPostedMessages;
+ UInt32 _numAutoSizeMessages;
+
+ bool _errorsWereDisplayed;
+
+ bool _waitCloseByCancelButton;
+ bool _cancelWasPressed;
+
+ bool _inCancelMessageBox;
+ bool _externalCloseMessageWasReceived;
+
+
+ // #ifdef __ITaskbarList3_INTERFACE_DEFINED__
+ void SetTaskbarProgressState(TBPFLAG tbpFlags)
+ {
+ if (_taskbarList && _hwndForTaskbar)
+ _taskbarList->SetProgressState(_hwndForTaskbar, tbpFlags);
+ }
+ // #endif
+ void SetTaskbarProgressState();
+
+ void UpdateStatInfo(bool showAll);
+ void SetProgressRange(UInt64 range);
+ void SetProgressPos(UInt64 pos);
+ virtual bool OnTimer(WPARAM timerID, LPARAM callback) Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual void OnCancel() Z7_override;
+ virtual void OnOK() Z7_override;
+ virtual bool OnNotify(UINT /* controlID */, LPNMHDR header) Z7_override;
+ void CopyToClipboard();
+
+ NWindows::NSynchronization::CManualResetEvent _createDialogEvent;
+ NWindows::NSynchronization::CManualResetEvent _dialogCreatedEvent;
+ #ifndef Z7_SFX
+ void AddToTitle(LPCWSTR string);
+ #endif
+
+ void SetPauseText();
+ void SetPriorityText();
+ void OnPauseButton();
+ void OnPriorityButton();
+ bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+
+ void SetTitleText();
+ void ShowSize(unsigned id, UInt64 val, UInt64 &prev);
+
+ void UpdateMessagesDialog();
+
+ void AddMessageDirect(LPCWSTR message, bool needNumber);
+ void AddMessage(LPCWSTR message);
+
+ bool OnExternalCloseMessage();
+ void EnableErrorsControls(bool enable);
+
+ void ShowAfterMessages(HWND wndParent);
+
+ void CheckNeedClose();
+public:
+ CProgressSync Sync;
+ bool CompressingMode;
+ bool WaitMode;
+ bool ShowCompressionInfo;
+ bool MessagesDisplayed; // = true if user pressed OK on all messages or there are no messages.
+ int IconID;
+
+ HWND MainWindow;
+ #ifndef Z7_SFX
+ UString MainTitle;
+ UString MainAddTitle;
+ ~CProgressDialog() Z7_DESTRUCTOR_override;
+ #endif
+
+ CProgressDialog();
+ void WaitCreating()
+ {
+ _createDialogEvent.Set();
+ _dialogCreatedEvent.Lock();
+ }
+
+ INT_PTR Create(const UString &title, NWindows::CThread &thread, HWND wndParent = NULL);
+
+
+ /* how it works:
+ 1) the working thread calls ProcessWasFinished()
+ that sends kCloseMessage message to CProgressDialog (GUI) thread
+ 2) CProgressDialog (GUI) thread receives kCloseMessage message and
+ calls ProcessWasFinished_GuiVirt();
+ So we can implement ProcessWasFinished_GuiVirt() and show special
+ results window in GUI thread with CProgressDialog as parent window
+ */
+
+ void ProcessWasFinished();
+ virtual void ProcessWasFinished_GuiVirt() {}
+};
+
+
+class CProgressCloser
+{
+ CProgressDialog *_p;
+public:
+ CProgressCloser(CProgressDialog &p) : _p(&p) {}
+ ~CProgressCloser() { _p->ProcessWasFinished(); }
+};
+
+
+class CProgressThreadVirt: public CProgressDialog
+{
+protected:
+ FStringVector ErrorPaths;
+ CProgressFinalMessage FinalMessage;
+
+ // error if any of HRESULT, ErrorMessage, ErrorPath
+ virtual HRESULT ProcessVirt() = 0;
+public:
+ HRESULT Result;
+ bool ThreadFinishedOK; // if there is no fatal exception
+
+ void Process();
+ void AddErrorPath(const FString &path) { ErrorPaths.Add(path); }
+
+ HRESULT Create(const UString &title, HWND parentWindow = NULL);
+ CProgressThreadVirt(): Result(E_FAIL), ThreadFinishedOK(false) {}
+
+ CProgressMessageBoxPair &GetMessagePair(bool isError) { return isError ? FinalMessage.ErrorMessage : FinalMessage.OkMessage; }
+};
+
+UString HResultToMessage(HRESULT errorCode);
+
+/*
+how it works:
+
+client code inherits CProgressThreadVirt and calls
+CProgressThreadVirt::Create()
+{
+ it creates new thread that calls CProgressThreadVirt::Process();
+ it creates modal progress dialog window with ProgressDialog.Create()
+}
+
+CProgressThreadVirt::Process()
+{
+ {
+ Result = ProcessVirt(); // virtual function that must implement real work
+ }
+ if (exceptions) or FinalMessage.ErrorMessage.Message
+ {
+ set message to ProgressDialog.Sync.FinalMessage.ErrorMessage.Message
+ }
+ else if (FinalMessage.OkMessage.Message)
+ {
+ set message to ProgressDialog.Sync.FinalMessage.OkMessage
+ }
+
+ PostMsg(kCloseMessage);
+}
+
+
+CProgressDialog::OnExternalCloseMessage()
+{
+ if (ProgressDialog.Sync.FinalMessage)
+ {
+ WorkWasFinishedVirt();
+ Show (ProgressDialog.Sync.FinalMessage)
+ MessagesDisplayed = true;
+ }
+}
+
+*/
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2.rc b/CPP/7zip/UI/FileManager/ProgressDialog2.rc
index 535a008..4d0e0c7 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2.rc
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2.rc
@@ -1,40 +1,40 @@
-#include "ProgressDialog2Res.h"
-#include "../../GuiCommon.rc"
-
-#undef DIALOG_ID
-#define DIALOG_ID IDD_PROGRESS
-#define xc 360
-#define k 11
-#define z1s 16
-
-#include "ProgressDialog2a.rc"
-
-#ifdef UNDER_CE
-
-#include "../../GuiCommon.rc"
-
-
-#undef DIALOG_ID
-#undef m
-#undef k
-#undef z1s
-
-#define DIALOG_ID IDD_PROGRESS_2
-#define m 4
-#define k 8
-#define z1s 12
-
-#define xc 280
-
-#include "ProgressDialog2a.rc"
-
-#endif
-
-STRINGTABLE DISCARDABLE
-{
- IDS_PROGRESS_PAUSED "Paused"
- IDS_PROGRESS_FOREGROUND "&Foreground"
- IDS_CONTINUE "&Continue"
- IDS_PROGRESS_ASK_CANCEL "Are you sure you want to cancel?"
- IDS_CLOSE "&Close"
-}
+#include "ProgressDialog2Res.h"
+#include "../../GuiCommon.rc"
+
+#undef DIALOG_ID
+#define DIALOG_ID IDD_PROGRESS
+#define xc 360
+#define k 11
+#define z1s 16
+
+#include "ProgressDialog2a.rc"
+
+#ifdef UNDER_CE
+
+#include "../../GuiCommon.rc"
+
+
+#undef DIALOG_ID
+#undef m
+#undef k
+#undef z1s
+
+#define DIALOG_ID IDD_PROGRESS_2
+#define m 4
+#define k 8
+#define z1s 12
+
+#define xc 280
+
+#include "ProgressDialog2a.rc"
+
+#endif
+
+STRINGTABLE DISCARDABLE
+{
+ IDS_PROGRESS_PAUSED "Paused"
+ IDS_PROGRESS_FOREGROUND "&Foreground"
+ IDS_CONTINUE "&Continue"
+ IDS_PROGRESS_ASK_CANCEL "Are you sure you want to cancel?"
+ IDS_CLOSE "&Close"
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2Res.h b/CPP/7zip/UI/FileManager/ProgressDialog2Res.h
index 54f02f0..736c717 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2Res.h
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2Res.h
@@ -1,48 +1,49 @@
-#define IDD_PROGRESS 97
-#define IDD_PROGRESS_2 10097
-
-#define IDS_CLOSE 408
-#define IDS_CONTINUE 411
-
-#define IDB_PROGRESS_BACKGROUND 444
-#define IDS_PROGRESS_FOREGROUND 445
-#define IDB_PAUSE 446
-#define IDS_PROGRESS_PAUSED 447
-#define IDS_PROGRESS_ASK_CANCEL 448
-
-#define IDT_PROGRESS_PACKED 1008
-#define IDT_PROGRESS_FILES 1032
-
-#define IDT_PROGRESS_ELAPSED 3900
-#define IDT_PROGRESS_REMAINING 3901
-#define IDT_PROGRESS_TOTAL 3902
-#define IDT_PROGRESS_SPEED 3903
-#define IDT_PROGRESS_PROCESSED 3904
-#define IDT_PROGRESS_RATIO 3905
-#define IDT_PROGRESS_ERRORS 3906
-
-#define IDC_PROGRESS1 100
-#define IDL_PROGRESS_MESSAGES 101
-#define IDT_PROGRESS_FILE_NAME 102
-#define IDT_PROGRESS_STATUS 103
-
-#define IDT_PROGRESS_PACKED_VAL 110
-#define IDT_PROGRESS_FILES_VAL 111
-
-#define IDT_PROGRESS_ELAPSED_VAL 120
-#define IDT_PROGRESS_REMAINING_VAL 121
-#define IDT_PROGRESS_TOTAL_VAL 122
-#define IDT_PROGRESS_SPEED_VAL 123
-#define IDT_PROGRESS_PROCESSED_VAL 124
-#define IDT_PROGRESS_RATIO_VAL 125
-#define IDT_PROGRESS_ERRORS_VAL 126
-
-
-#ifdef UNDER_CE
-#define MY_PROGRESS_VAL_UNITS 44
-#else
-#define MY_PROGRESS_VAL_UNITS 76
-#endif
-#define MY_PROGRESS_LABEL_UNITS_MIN 60
-#define MY_PROGRESS_LABEL_UNITS_START 90
-#define MY_PROGRESS_PAD_UNITS 4
+#define IDD_PROGRESS 97
+#define IDD_PROGRESS_2 10097
+
+#define IDS_CLOSE 408
+#define IDS_CONTINUE 411
+
+#define IDB_PROGRESS_BACKGROUND 444
+#define IDS_PROGRESS_FOREGROUND 445
+#define IDB_PAUSE 446
+#define IDS_PROGRESS_PAUSED 447
+#define IDS_PROGRESS_ASK_CANCEL 448
+
+#define IDT_PROGRESS_PACKED 1008
+#define IDT_PROGRESS_FILES 1032
+
+#define IDT_PROGRESS_ELAPSED 3900
+#define IDT_PROGRESS_REMAINING 3901
+#define IDT_PROGRESS_TOTAL 3902
+#define IDT_PROGRESS_SPEED 3903
+#define IDT_PROGRESS_PROCESSED 3904
+#define IDT_PROGRESS_RATIO 3905
+#define IDT_PROGRESS_ERRORS 3906
+
+#define IDC_PROGRESS1 100
+#define IDL_PROGRESS_MESSAGES 101
+#define IDT_PROGRESS_FILE_NAME 102
+#define IDT_PROGRESS_STATUS 103
+
+#define IDT_PROGRESS_PACKED_VAL 110
+#define IDT_PROGRESS_FILES_VAL 111
+#define IDT_PROGRESS_FILES_TOTAL 112
+
+#define IDT_PROGRESS_ELAPSED_VAL 120
+#define IDT_PROGRESS_REMAINING_VAL 121
+#define IDT_PROGRESS_TOTAL_VAL 122
+#define IDT_PROGRESS_SPEED_VAL 123
+#define IDT_PROGRESS_PROCESSED_VAL 124
+#define IDT_PROGRESS_RATIO_VAL 125
+#define IDT_PROGRESS_ERRORS_VAL 126
+
+
+#ifdef UNDER_CE
+#define MY_PROGRESS_VAL_UNITS 44
+#else
+#define MY_PROGRESS_VAL_UNITS 72
+#endif
+#define MY_PROGRESS_LABEL_UNITS_MIN 60
+#define MY_PROGRESS_LABEL_UNITS_START 90
+#define MY_PROGRESS_PAD_UNITS 4
diff --git a/CPP/7zip/UI/FileManager/ProgressDialog2a.rc b/CPP/7zip/UI/FileManager/ProgressDialog2a.rc
index f1daec7..dc7d797 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialog2a.rc
+++ b/CPP/7zip/UI/FileManager/ProgressDialog2a.rc
@@ -1,80 +1,85 @@
-#undef bxs
-#define bxs 80
-
-#define x0s MY_PROGRESS_LABEL_UNITS_START
-#define x1s MY_PROGRESS_VAL_UNITS
-#define x2s MY_PROGRESS_LABEL_UNITS_START
-#define x3s MY_PROGRESS_VAL_UNITS
-
-#define x1 (m + x0s)
-#define x3 (xs - m - x3s)
-#define x2 (x3 - x2s)
-
-#undef y0
-#undef y1
-#undef y2
-#undef y3
-#undef y4
-
-#undef z0
-#undef z1
-#undef z2
-#undef z3
-
-#define y0 m
-#define y1 (y0 + k)
-#define y2 (y1 + k)
-#define y3 (y2 + k)
-#define y4 (y3 + k)
-
-#define z3 (y4 + k + 1)
-
-#define z2 (z3 + k + 1)
-#define z2s 24
-
-#define z1 (z2 + z2s)
-
-#define z0 (z1 + z1s + m)
-#define z0s 48
-
-#define yc (z0 + z0s + bys)
-
-
-DIALOG_ID DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
-CAPTION "Progress"
-{
- DEFPUSHBUTTON "&Background", IDB_PROGRESS_BACKGROUND, bx3, by, bxs, bys
- PUSHBUTTON "&Pause", IDB_PAUSE bx2, by, bxs, bys
- PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
-
- LTEXT "Elapsed time:", IDT_PROGRESS_ELAPSED, m, y0, x0s, 8
- LTEXT "Remaining time:", IDT_PROGRESS_REMAINING, m, y1, x0s, 8
- LTEXT "Files:", IDT_PROGRESS_FILES, m, y2, x0s, 8
- LTEXT "Compression ratio:", IDT_PROGRESS_RATIO, m, y3, x0s, 8
- LTEXT "Errors:", IDT_PROGRESS_ERRORS, m, y4, x0s, 8
-
- LTEXT "Total size:", IDT_PROGRESS_TOTAL, x2, y0, x2s, 8
- LTEXT "Speed:", IDT_PROGRESS_SPEED, x2, y1, x2s, 8
- LTEXT "Processed:", IDT_PROGRESS_PROCESSED,x2, y2, x2s, 8
- LTEXT "Compressed size:" , IDT_PROGRESS_PACKED, x2, y3, x2s, 8
-
- RTEXT "", IDT_PROGRESS_ELAPSED_VAL, x1, y0, x1s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_REMAINING_VAL, x1, y1, x1s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_FILES_VAL, x1, y2, x1s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_RATIO_VAL, x1, y3, x1s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_ERRORS_VAL, x1, y4, x1s, MY_TEXT_NOPREFIX
-
- RTEXT "", IDT_PROGRESS_TOTAL_VAL, x3, y0, x3s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_SPEED_VAL, x3, y1, x3s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_PROCESSED_VAL, x3, y2, x3s, MY_TEXT_NOPREFIX
- RTEXT "", IDT_PROGRESS_PACKED_VAL, x3, y3, x3s, MY_TEXT_NOPREFIX
-
- LTEXT "", IDT_PROGRESS_STATUS, m, z3, xc, MY_TEXT_NOPREFIX
- CONTROL "", IDT_PROGRESS_FILE_NAME, "Static", SS_NOPREFIX | SS_LEFTNOWORDWRAP, m, z2, xc, z2s
-
- CONTROL "Progress1", IDC_PROGRESS1, "msctls_progress32", PBS_SMOOTH | WS_BORDER, m, z1, xc, z1s
-
- CONTROL "List1", IDL_PROGRESS_MESSAGES, "SysListView32",
- LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOCOLUMNHEADER | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
- m, z0, xc, z0s
-}
+#undef bxs
+#define bxs 80
+
+#define x0s MY_PROGRESS_LABEL_UNITS_START
+#define x1s MY_PROGRESS_VAL_UNITS
+#define x2s MY_PROGRESS_LABEL_UNITS_START
+#define x3s MY_PROGRESS_VAL_UNITS
+
+#define x1 (m + x0s)
+#define x3 (xs - m - x3s)
+#define x2 (x3 - x2s)
+
+#undef y0
+#undef y1
+#undef y2
+#undef y3
+#undef y4
+
+#undef z0
+#undef z1
+#undef z2
+#undef z3
+
+#define y0 m
+#define y1 (y0 + k)
+#define y2 (y1 + k)
+#define y3 (y2 + k)
+#define y4 (y3 + k)
+
+#define z3 (y4 + k + 1)
+
+#define z2 (z3 + k + 1)
+#define z2s 24
+
+#define z1 (z2 + z2s)
+
+#define z0 (z1 + z1s + m)
+#define z0s 48
+
+#define yc (z0 + z0s + bys)
+
+
+DIALOG_ID DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Progress"
+{
+ DEFPUSHBUTTON "&Background", IDB_PROGRESS_BACKGROUND, bx3, by, bxs, bys
+ PUSHBUTTON "&Pause", IDB_PAUSE, bx2, by, bxs, bys
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+
+
+ LTEXT "Elapsed time:", IDT_PROGRESS_ELAPSED, m, y0, x0s, 8
+ LTEXT "Remaining time:", IDT_PROGRESS_REMAINING, m, y1, x0s, 8
+ LTEXT "Files:", IDT_PROGRESS_FILES, m, y2, x0s, 8
+
+ LTEXT "Errors:", IDT_PROGRESS_ERRORS, m, y4, x0s, 8
+
+
+ LTEXT "Total size:", IDT_PROGRESS_TOTAL, x2, y0, x2s, 8
+ LTEXT "Speed:", IDT_PROGRESS_SPEED, x2, y1, x2s, 8
+ LTEXT "Processed:", IDT_PROGRESS_PROCESSED,x2, y2, x2s, 8
+ LTEXT "Compressed size:" , IDT_PROGRESS_PACKED, x2, y3, x2s, 8
+ LTEXT "Compression ratio:", IDT_PROGRESS_RATIO, x2, y4, x2s, 8
+
+
+ RTEXT "", IDT_PROGRESS_ELAPSED_VAL, x1, y0, x1s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_REMAINING_VAL, x1, y1, x1s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_FILES_VAL, x1, y2, x1s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_FILES_TOTAL, x1, y3, x1s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_ERRORS_VAL, x1, y4, x1s, MY_TEXT_NOPREFIX
+
+ RTEXT "", IDT_PROGRESS_TOTAL_VAL, x3, y0, x3s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_SPEED_VAL, x3, y1, x3s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_PROCESSED_VAL, x3, y2, x3s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_PACKED_VAL, x3, y3, x3s, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_PROGRESS_RATIO_VAL, x3, y4, x3s, MY_TEXT_NOPREFIX
+
+ LTEXT "", IDT_PROGRESS_STATUS, m, z3, xc, MY_TEXT_NOPREFIX
+ CONTROL "", IDT_PROGRESS_FILE_NAME, "Static", SS_NOPREFIX | SS_LEFTNOWORDWRAP, m, z2, xc, z2s
+
+ CONTROL "Progress1", IDC_PROGRESS1, "msctls_progress32", PBS_SMOOTH | WS_BORDER, m, z1, xc, z1s
+
+ CONTROL "List1", IDL_PROGRESS_MESSAGES, "SysListView32",
+ LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOCOLUMNHEADER | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+ m, z0, xc, z0s
+}
diff --git a/CPP/7zip/UI/FileManager/ProgressDialogRes.h b/CPP/7zip/UI/FileManager/ProgressDialogRes.h
index a281418..cbf3beb 100644
--- a/CPP/7zip/UI/FileManager/ProgressDialogRes.h
+++ b/CPP/7zip/UI/FileManager/ProgressDialogRes.h
@@ -1,3 +1,3 @@
-#define IDD_PROGRESS 97
-
-#define IDC_PROGRESS1 100
+#define IDD_PROGRESS 97
+
+#define IDC_PROGRESS1 100
diff --git a/CPP/7zip/UI/FileManager/PropertyName.cpp b/CPP/7zip/UI/FileManager/PropertyName.cpp
index a955241..838b6e3 100644
--- a/CPP/7zip/UI/FileManager/PropertyName.cpp
+++ b/CPP/7zip/UI/FileManager/PropertyName.cpp
@@ -1,23 +1,23 @@
-// PropertyName.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-
-#include "LangUtils.h"
-#include "PropertyName.h"
-
-UString GetNameOfProperty(PROPID propID, const wchar_t *name)
-{
- if (propID < 1000)
- {
- UString s = LangString(1000 + propID);
- if (!s.IsEmpty())
- return s;
- }
- if (name)
- return name;
- wchar_t temp[16];
- ConvertUInt32ToString(propID, temp);
- return temp;
-}
+// PropertyName.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "LangUtils.h"
+#include "PropertyName.h"
+
+UString GetNameOfProperty(PROPID propID, const wchar_t *name)
+{
+ if (propID < 1000)
+ {
+ UString s = LangString(1000 + propID);
+ if (!s.IsEmpty())
+ return s;
+ }
+ if (name)
+ return name;
+ wchar_t temp[16];
+ ConvertUInt32ToString(propID, temp);
+ return temp;
+}
diff --git a/CPP/7zip/UI/FileManager/PropertyName.h b/CPP/7zip/UI/FileManager/PropertyName.h
index a1061b7..fa6e5c5 100644
--- a/CPP/7zip/UI/FileManager/PropertyName.h
+++ b/CPP/7zip/UI/FileManager/PropertyName.h
@@ -1,10 +1,10 @@
-// PropertyName.h
-
-#ifndef __PROPERTY_NAME_H
-#define __PROPERTY_NAME_H
-
-#include "../../../Common/MyString.h"
-
-UString GetNameOfProperty(PROPID propID, const wchar_t *name);
-
-#endif
+// PropertyName.h
+
+#ifndef ZIP7_INC_PROPERTY_NAME_H
+#define ZIP7_INC_PROPERTY_NAME_H
+
+#include "../../../Common/MyString.h"
+
+UString GetNameOfProperty(PROPID propID, const wchar_t *name);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/PropertyName.rc b/CPP/7zip/UI/FileManager/PropertyName.rc
new file mode 100644
index 0000000..618875b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/PropertyName.rc
@@ -0,0 +1,109 @@
+#include "PropertyNameRes.h"
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+STRINGTABLE
+BEGIN
+ IDS_PROP_PATH "Path"
+ IDS_PROP_NAME "Name"
+ IDS_PROP_EXTENSION "Extension"
+ IDS_PROP_IS_FOLDER "Folder"
+ IDS_PROP_SIZE "Size"
+ IDS_PROP_PACKED_SIZE "Packed Size"
+ IDS_PROP_ATTRIBUTES "Attributes"
+ IDS_PROP_CTIME "Created"
+ IDS_PROP_ATIME "Accessed"
+ IDS_PROP_MTIME "Modified"
+ IDS_PROP_SOLID "Solid"
+ IDS_PROP_C0MMENTED "Commented"
+ IDS_PROP_ENCRYPTED "Encrypted"
+ IDS_PROP_SPLIT_BEFORE "Split Before"
+ IDS_PROP_SPLIT_AFTER "Split After"
+ IDS_PROP_DICTIONARY_SIZE "Dictionary"
+ IDS_PROP_CRC "CRC"
+ IDS_PROP_FILE_TYPE "Type"
+ IDS_PROP_ANTI "Anti"
+ IDS_PROP_METHOD "Method"
+ IDS_PROP_HOST_OS "Host OS"
+ IDS_PROP_FILE_SYSTEM "File System"
+ IDS_PROP_USER "User"
+ IDS_PROP_GROUP "Group"
+ IDS_PROP_BLOCK "Block"
+ IDS_PROP_COMMENT "Comment"
+ IDS_PROP_POSITION "Position"
+ IDS_PROP_PREFIX "Path Prefix"
+ IDS_PROP_FOLDERS "Folders"
+ IDS_PROP_FILES "Files"
+ IDS_PROP_VERSION "Version"
+ IDS_PROP_VOLUME "Volume"
+ IDS_PROP_IS_VOLUME "Multivolume"
+ IDS_PROP_OFFSET "Offset"
+ IDS_PROP_LINKS "Links"
+ IDS_PROP_NUM_BLOCKS "Blocks"
+ IDS_PROP_NUM_VOLUMES "Volumes"
+
+ IDS_PROP_BIT64 "64-bit"
+ IDS_PROP_BIG_ENDIAN "Big-endian"
+ IDS_PROP_CPU "CPU"
+ IDS_PROP_PHY_SIZE "Physical Size"
+ IDS_PROP_HEADERS_SIZE "Headers Size"
+ IDS_PROP_CHECKSUM "Checksum"
+ IDS_PROP_CHARACTS "Characteristics"
+ IDS_PROP_VA "Virtual Address"
+ IDS_PROP_ID "ID"
+ IDS_PROP_SHORT_NAME "Short Name"
+ IDS_PROP_CREATOR_APP "Creator Application"
+ IDS_PROP_SECTOR_SIZE "Sector Size"
+ IDS_PROP_POSIX_ATTRIB "Mode"
+ IDS_PROP_SYM_LINK "Symbolic Link"
+ IDS_PROP_ERROR "Error"
+ IDS_PROP_TOTAL_SIZE "Total Size"
+ IDS_PROP_FREE_SPACE "Free Space"
+ IDS_PROP_CLUSTER_SIZE "Cluster Size"
+ IDS_PROP_VOLUME_NAME "Label"
+ IDS_PROP_LOCAL_NAME "Local Name"
+ IDS_PROP_PROVIDER "Provider"
+ IDS_PROP_NT_SECURITY "NT Security"
+ IDS_PROP_ALT_STREAM "Alternate Stream"
+ IDS_PROP_AUX "Aux"
+ IDS_PROP_DELETED "Deleted"
+ IDS_PROP_IS_TREE "Is Tree"
+ IDS_PROP_SHA1 "SHA-1"
+ IDS_PROP_SHA256 "SHA-256"
+ IDS_PROP_ERROR_TYPE "Error Type"
+ IDS_PROP_NUM_ERRORS "Errors"
+ IDS_PROP_ERROR_FLAGS "Errors"
+ IDS_PROP_WARNING_FLAGS "Warnings"
+ IDS_PROP_WARNING "Warning"
+ IDS_PROP_NUM_STREAMS "Streams"
+ IDS_PROP_NUM_ALT_STREAMS "Alternate Streams"
+ IDS_PROP_ALT_STREAMS_SIZE "Alternate Streams Size"
+ IDS_PROP_VIRTUAL_SIZE "Virtual Size"
+ IDS_PROP_UNPACK_SIZE "Unpack Size"
+ IDS_PROP_TOTAL_PHY_SIZE "Total Physical Size"
+ IDS_PROP_VOLUME_INDEX "Volume Index"
+ IDS_PROP_SUBTYPE "SubType"
+ IDS_PROP_SHORT_COMMENT "Short Comment"
+ IDS_PROP_CODE_PAGE "Code Page"
+ IDS_PROP_IS_NOT_ARC_TYPE "Is not archive type"
+ IDS_PROP_PHY_SIZE_CANT_BE_DETECTED "Physical Size can't be detected"
+ IDS_PROP_ZEROS_TAIL_IS_ALLOWED "Zeros Tail Is Allowed"
+ IDS_PROP_TAIL_SIZE "Tail Size"
+ IDS_PROP_EMB_STUB_SIZE "Embedded Stub Size"
+ IDS_PROP_NT_REPARSE "Link"
+ IDS_PROP_HARD_LINK "Hard Link"
+ IDS_PROP_INODE "iNode"
+ IDS_PROP_STREAM_ID "Stream ID"
+ IDS_PROP_READ_ONLY "Read-only"
+ IDS_PROP_OUT_NAME "Out Name"
+ IDS_PROP_COPY_LINK "Copy Link"
+ IDS_PROP_ARC_FILE_NAME "ArcFileName"
+ IDS_PROP_IS_HASH "IsHash"
+ IDS_PROP_CHANGE_TIME "Metadata Changed"
+ IDS_PROP_USER_ID "User ID"
+ IDS_PROP_GROUP_ID "Group ID"
+ IDS_PROP_DEVICE_MAJOR "Device Major"
+ IDS_PROP_DEVICE_MINOR "Device Minor"
+ IDS_PROP_DEV_MAJOR "Dev Major"
+ IDS_PROP_DEV_MINOR "Dev Minor"
+END
diff --git a/CPP/7zip/UI/FileManager/PropertyNameRes.h b/CPP/7zip/UI/FileManager/PropertyNameRes.h
index 1315b89..913887e 100644
--- a/CPP/7zip/UI/FileManager/PropertyNameRes.h
+++ b/CPP/7zip/UI/FileManager/PropertyNameRes.h
@@ -1,95 +1,104 @@
-
-
-#define IDS_PROP_PATH 1003
-#define IDS_PROP_NAME 1004
-#define IDS_PROP_EXTENSION 1005
-#define IDS_PROP_IS_FOLDER 1006
-#define IDS_PROP_SIZE 1007
-#define IDS_PROP_PACKED_SIZE 1008
-#define IDS_PROP_ATTRIBUTES 1009
-#define IDS_PROP_CTIME 1010
-#define IDS_PROP_ATIME 1011
-#define IDS_PROP_MTIME 1012
-#define IDS_PROP_SOLID 1013
-#define IDS_PROP_C0MMENTED 1014
-#define IDS_PROP_ENCRYPTED 1015
-#define IDS_PROP_SPLIT_BEFORE 1016
-#define IDS_PROP_SPLIT_AFTER 1017
-#define IDS_PROP_DICTIONARY_SIZE 1018
-#define IDS_PROP_CRC 1019
-#define IDS_PROP_FILE_TYPE 1020
-#define IDS_PROP_ANTI 1021
-#define IDS_PROP_METHOD 1022
-#define IDS_PROP_HOST_OS 1023
-#define IDS_PROP_FILE_SYSTEM 1024
-#define IDS_PROP_USER 1025
-#define IDS_PROP_GROUP 1026
-#define IDS_PROP_BLOCK 1027
-#define IDS_PROP_COMMENT 1028
-#define IDS_PROP_POSITION 1029
-#define IDS_PROP_PREFIX 1030
-#define IDS_PROP_FOLDERS 1031
-#define IDS_PROP_FILES 1032
-#define IDS_PROP_VERSION 1033
-#define IDS_PROP_VOLUME 1034
-#define IDS_PROP_IS_VOLUME 1035
-#define IDS_PROP_OFFSET 1036
-#define IDS_PROP_LINKS 1037
-#define IDS_PROP_NUM_BLOCKS 1038
-#define IDS_PROP_NUM_VOLUMES 1039
-
-#define IDS_PROP_BIT64 1041
-#define IDS_PROP_BIG_ENDIAN 1042
-#define IDS_PROP_CPU 1043
-#define IDS_PROP_PHY_SIZE 1044
-#define IDS_PROP_HEADERS_SIZE 1045
-#define IDS_PROP_CHECKSUM 1046
-#define IDS_PROP_CHARACTS 1047
-#define IDS_PROP_VA 1048
-#define IDS_PROP_ID 1049
-#define IDS_PROP_SHORT_NAME 1050
-#define IDS_PROP_CREATOR_APP 1051
-#define IDS_PROP_SECTOR_SIZE 1052
-#define IDS_PROP_POSIX_ATTRIB 1053
-#define IDS_PROP_SYM_LINK 1054
-#define IDS_PROP_ERROR 1055
-#define IDS_PROP_TOTAL_SIZE 1056
-#define IDS_PROP_FREE_SPACE 1057
-#define IDS_PROP_CLUSTER_SIZE 1058
-#define IDS_PROP_VOLUME_NAME 1059
-#define IDS_PROP_LOCAL_NAME 1060
-#define IDS_PROP_PROVIDER 1061
-#define IDS_PROP_NT_SECURITY 1062
-#define IDS_PROP_ALT_STREAM 1063
-#define IDS_PROP_AUX 1064
-#define IDS_PROP_DELETED 1065
-#define IDS_PROP_IS_TREE 1066
-#define IDS_PROP_SHA1 1067
-#define IDS_PROP_SHA256 1068
-#define IDS_PROP_ERROR_TYPE 1069
-#define IDS_PROP_NUM_ERRORS 1070
-#define IDS_PROP_ERROR_FLAGS 1071
-#define IDS_PROP_WARNING_FLAGS 1072
-#define IDS_PROP_WARNING 1073
-#define IDS_PROP_NUM_STREAMS 1074
-#define IDS_PROP_NUM_ALT_STREAMS 1075
-#define IDS_PROP_ALT_STREAMS_SIZE 1076
-#define IDS_PROP_VIRTUAL_SIZE 1077
-#define IDS_PROP_UNPACK_SIZE 1078
-#define IDS_PROP_TOTAL_PHY_SIZE 1079
-#define IDS_PROP_VOLUME_INDEX 1080
-#define IDS_PROP_SUBTYPE 1081
-#define IDS_PROP_SHORT_COMMENT 1082
-#define IDS_PROP_CODE_PAGE 1083
-#define IDS_PROP_IS_NOT_ARC_TYPE 1084
-#define IDS_PROP_PHY_SIZE_CANT_BE_DETECTED 1085
-#define IDS_PROP_ZEROS_TAIL_IS_ALLOWED 1086
-#define IDS_PROP_TAIL_SIZE 1087
-#define IDS_PROP_EMB_STUB_SIZE 1088
-#define IDS_PROP_NT_REPARSE 1089
-#define IDS_PROP_HARD_LINK 1090
-#define IDS_PROP_INODE 1091
-#define IDS_PROP_STREAM_ID 1092
-#define IDS_PROP_READ_ONLY 1093
-#define IDS_PROP_OUT_NAME 1094
-#define IDS_PROP_COPY_LINK 1095
+
+
+#define IDS_PROP_PATH 1003
+#define IDS_PROP_NAME 1004
+#define IDS_PROP_EXTENSION 1005
+#define IDS_PROP_IS_FOLDER 1006
+#define IDS_PROP_SIZE 1007
+#define IDS_PROP_PACKED_SIZE 1008
+#define IDS_PROP_ATTRIBUTES 1009
+#define IDS_PROP_CTIME 1010
+#define IDS_PROP_ATIME 1011
+#define IDS_PROP_MTIME 1012
+#define IDS_PROP_SOLID 1013
+#define IDS_PROP_C0MMENTED 1014
+#define IDS_PROP_ENCRYPTED 1015
+#define IDS_PROP_SPLIT_BEFORE 1016
+#define IDS_PROP_SPLIT_AFTER 1017
+#define IDS_PROP_DICTIONARY_SIZE 1018
+#define IDS_PROP_CRC 1019
+#define IDS_PROP_FILE_TYPE 1020
+#define IDS_PROP_ANTI 1021
+#define IDS_PROP_METHOD 1022
+#define IDS_PROP_HOST_OS 1023
+#define IDS_PROP_FILE_SYSTEM 1024
+#define IDS_PROP_USER 1025
+#define IDS_PROP_GROUP 1026
+#define IDS_PROP_BLOCK 1027
+#define IDS_PROP_COMMENT 1028
+#define IDS_PROP_POSITION 1029
+#define IDS_PROP_PREFIX 1030
+#define IDS_PROP_FOLDERS 1031
+#define IDS_PROP_FILES 1032
+#define IDS_PROP_VERSION 1033
+#define IDS_PROP_VOLUME 1034
+#define IDS_PROP_IS_VOLUME 1035
+#define IDS_PROP_OFFSET 1036
+#define IDS_PROP_LINKS 1037
+#define IDS_PROP_NUM_BLOCKS 1038
+#define IDS_PROP_NUM_VOLUMES 1039
+
+#define IDS_PROP_BIT64 1041
+#define IDS_PROP_BIG_ENDIAN 1042
+#define IDS_PROP_CPU 1043
+#define IDS_PROP_PHY_SIZE 1044
+#define IDS_PROP_HEADERS_SIZE 1045
+#define IDS_PROP_CHECKSUM 1046
+#define IDS_PROP_CHARACTS 1047
+#define IDS_PROP_VA 1048
+#define IDS_PROP_ID 1049
+#define IDS_PROP_SHORT_NAME 1050
+#define IDS_PROP_CREATOR_APP 1051
+#define IDS_PROP_SECTOR_SIZE 1052
+#define IDS_PROP_POSIX_ATTRIB 1053
+#define IDS_PROP_SYM_LINK 1054
+#define IDS_PROP_ERROR 1055
+#define IDS_PROP_TOTAL_SIZE 1056
+#define IDS_PROP_FREE_SPACE 1057
+#define IDS_PROP_CLUSTER_SIZE 1058
+#define IDS_PROP_VOLUME_NAME 1059
+#define IDS_PROP_LOCAL_NAME 1060
+#define IDS_PROP_PROVIDER 1061
+#define IDS_PROP_NT_SECURITY 1062
+#define IDS_PROP_ALT_STREAM 1063
+#define IDS_PROP_AUX 1064
+#define IDS_PROP_DELETED 1065
+#define IDS_PROP_IS_TREE 1066
+#define IDS_PROP_SHA1 1067
+#define IDS_PROP_SHA256 1068
+#define IDS_PROP_ERROR_TYPE 1069
+#define IDS_PROP_NUM_ERRORS 1070
+#define IDS_PROP_ERROR_FLAGS 1071
+#define IDS_PROP_WARNING_FLAGS 1072
+#define IDS_PROP_WARNING 1073
+#define IDS_PROP_NUM_STREAMS 1074
+#define IDS_PROP_NUM_ALT_STREAMS 1075
+#define IDS_PROP_ALT_STREAMS_SIZE 1076
+#define IDS_PROP_VIRTUAL_SIZE 1077
+#define IDS_PROP_UNPACK_SIZE 1078
+#define IDS_PROP_TOTAL_PHY_SIZE 1079
+#define IDS_PROP_VOLUME_INDEX 1080
+#define IDS_PROP_SUBTYPE 1081
+#define IDS_PROP_SHORT_COMMENT 1082
+#define IDS_PROP_CODE_PAGE 1083
+#define IDS_PROP_IS_NOT_ARC_TYPE 1084
+#define IDS_PROP_PHY_SIZE_CANT_BE_DETECTED 1085
+#define IDS_PROP_ZEROS_TAIL_IS_ALLOWED 1086
+#define IDS_PROP_TAIL_SIZE 1087
+#define IDS_PROP_EMB_STUB_SIZE 1088
+#define IDS_PROP_NT_REPARSE 1089
+#define IDS_PROP_HARD_LINK 1090
+#define IDS_PROP_INODE 1091
+#define IDS_PROP_STREAM_ID 1092
+#define IDS_PROP_READ_ONLY 1093
+#define IDS_PROP_OUT_NAME 1094
+#define IDS_PROP_COPY_LINK 1095
+#define IDS_PROP_ARC_FILE_NAME 1096
+#define IDS_PROP_IS_HASH 1097
+#define IDS_PROP_CHANGE_TIME 1098
+#define IDS_PROP_USER_ID 1099
+#define IDS_PROP_GROUP_ID 1100
+#define IDS_PROP_DEVICE_MAJOR 1101
+#define IDS_PROP_DEVICE_MINOR 1102
+#define IDS_PROP_DEV_MAJOR 1103
+#define IDS_PROP_DEV_MINOR 1104
diff --git a/CPP/7zip/UI/FileManager/RegistryAssociations.cpp b/CPP/7zip/UI/FileManager/RegistryAssociations.cpp
new file mode 100644
index 0000000..16e4675
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryAssociations.cpp
@@ -0,0 +1,167 @@
+// RegistryAssociations.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/Registry.h"
+
+#include "RegistryAssociations.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+namespace NRegistryAssoc {
+
+// static NSynchronization::CCriticalSection g_CriticalSection;
+
+static const TCHAR * const kClasses = TEXT("Software\\Classes\\");
+// static const TCHAR * const kShellNewKeyName = TEXT("ShellNew");
+// static const TCHAR * const kShellNewDataValueName = TEXT("Data");
+static const TCHAR * const kDefaultIconKeyName = TEXT("DefaultIcon");
+static const TCHAR * const kShellKeyName = TEXT("shell");
+static const TCHAR * const kOpenKeyName = TEXT("open");
+static const TCHAR * const kCommandKeyName = TEXT("command");
+static const char * const k7zipPrefix = "7-Zip.";
+
+static CSysString GetExtProgramKeyName(const CSysString &ext)
+{
+ return CSysString(k7zipPrefix) + ext;
+}
+
+static CSysString GetFullKeyPath(HKEY hkey, const CSysString &name)
+{
+ CSysString s;
+ if (hkey != HKEY_CLASSES_ROOT)
+ s = kClasses;
+ return s + name;
+}
+
+static CSysString GetExtKeyPath(HKEY hkey, const CSysString &ext)
+{
+ return GetFullKeyPath(hkey, (TEXT(".")) + ext);
+}
+
+bool CShellExtInfo::ReadFromRegistry(HKEY hkey, const CSysString &ext)
+{
+ ProgramKey.Empty();
+ IconPath.Empty();
+ IconIndex = -1;
+ // NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+ {
+ CKey extKey;
+ if (extKey.Open(hkey, GetExtKeyPath(hkey, ext), KEY_READ) != ERROR_SUCCESS)
+ return false;
+ if (extKey.QueryValue(NULL, ProgramKey) != ERROR_SUCCESS)
+ return false;
+ }
+ {
+ CKey iconKey;
+
+ if (iconKey.Open(hkey, GetFullKeyPath(hkey, ProgramKey + CSysString(CHAR_PATH_SEPARATOR) + kDefaultIconKeyName), KEY_READ) == ERROR_SUCCESS)
+ {
+ UString value;
+ if (iconKey.QueryValue(NULL, value) == ERROR_SUCCESS)
+ {
+ const int pos = value.ReverseFind(L',');
+ IconPath = value;
+ if (pos >= 0)
+ {
+ const wchar_t *end;
+ const Int32 index = ConvertStringToInt32((const wchar_t *)value + pos + 1, &end);
+ if (*end == 0)
+ {
+ // 9.31: if there is no icon index, we use -1. Is it OK?
+ if (pos != (int)value.Len() - 1)
+ IconIndex = (int)index;
+ IconPath.SetFrom(value, (unsigned)pos);
+ }
+ }
+ }
+ }
+ }
+ return true;
+}
+
+bool CShellExtInfo::IsIt7Zip() const
+{
+ return ProgramKey.IsPrefixedBy_Ascii_NoCase(k7zipPrefix);
+}
+
+LONG DeleteShellExtensionInfo(HKEY hkey, const CSysString &ext)
+{
+ // NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+ CKey rootKey;
+ rootKey.Attach(hkey);
+ LONG res = rootKey.RecurseDeleteKey(GetExtKeyPath(hkey, ext));
+ // then we delete only 7-Zip.* key.
+ rootKey.RecurseDeleteKey(GetFullKeyPath(hkey, GetExtProgramKeyName(ext)));
+ rootKey.Detach();
+ return res;
+}
+
+LONG AddShellExtensionInfo(HKEY hkey,
+ const CSysString &ext,
+ const UString &programTitle,
+ const UString &programOpenCommand,
+ const UString &iconPath, int iconIndex
+ // , const void *shellNewData, int shellNewDataSize
+ )
+{
+ LONG res = 0;
+ DeleteShellExtensionInfo(hkey, ext);
+ // NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+ CSysString programKeyName;
+ {
+ CSysString ext2 (ext);
+ if (iconIndex < 0)
+ ext2 = "*";
+ programKeyName = GetExtProgramKeyName(ext2);
+ }
+ {
+ CKey extKey;
+ res = extKey.Create(hkey, GetExtKeyPath(hkey, ext));
+ extKey.SetValue(NULL, programKeyName);
+ /*
+ if (shellNewData != NULL)
+ {
+ CKey shellNewKey;
+ shellNewKey.Create(extKey, kShellNewKeyName);
+ shellNewKey.SetValue(kShellNewDataValueName, shellNewData, shellNewDataSize);
+ }
+ */
+ }
+ CKey programKey;
+ programKey.Create(hkey, GetFullKeyPath(hkey, programKeyName));
+ programKey.SetValue(NULL, programTitle);
+ {
+ CKey iconKey;
+ UString iconPathFull = iconPath;
+ if (iconIndex < 0)
+ iconIndex = 0;
+ // if (iconIndex >= 0)
+ {
+ iconPathFull += ',';
+ iconPathFull.Add_UInt32((UInt32)iconIndex);
+ }
+ iconKey.Create(programKey, kDefaultIconKeyName);
+ iconKey.SetValue(NULL, iconPathFull);
+ }
+
+ CKey shellKey;
+ shellKey.Create(programKey, kShellKeyName);
+ shellKey.SetValue(NULL, TEXT(""));
+
+ CKey openKey;
+ openKey.Create(shellKey, kOpenKeyName);
+ openKey.SetValue(NULL, TEXT(""));
+
+ CKey commandKey;
+ commandKey.Create(openKey, kCommandKeyName);
+ commandKey.SetValue(NULL, programOpenCommand);
+ return res;
+}
+
+}
diff --git a/CPP/7zip/UI/FileManager/RegistryAssociations.h b/CPP/7zip/UI/FileManager/RegistryAssociations.h
new file mode 100644
index 0000000..3d7b63d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryAssociations.h
@@ -0,0 +1,31 @@
+// RegistryAssociations.h
+
+#ifndef ZIP7_INC_REGISTRY_ASSOCIATIONS_H
+#define ZIP7_INC_REGISTRY_ASSOCIATIONS_H
+
+#include "../../../Common/MyString.h"
+
+namespace NRegistryAssoc {
+
+ struct CShellExtInfo
+ {
+ CSysString ProgramKey;
+ UString IconPath;
+ int IconIndex;
+
+ bool ReadFromRegistry(HKEY hkey, const CSysString &ext);
+ bool IsIt7Zip() const;
+ };
+
+ LONG DeleteShellExtensionInfo(HKEY hkey, const CSysString &ext);
+
+ LONG AddShellExtensionInfo(HKEY hkey,
+ const CSysString &ext,
+ const UString &programTitle,
+ const UString &programOpenCommand,
+ const UString &iconPath, int iconIndex
+ // , const void *shellNewData, int shellNewDataSize
+ );
+}
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/RegistryPlugins.cpp b/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
new file mode 100644
index 0000000..87e5fa1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
@@ -0,0 +1,145 @@
+// RegistryPlugins.cpp
+
+#include "StdAfx.h"
+
+/*
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "IFolder.h"
+*/
+#include "RegistryPlugins.h"
+
+// using namespace NWindows;
+// using namespace NFile;
+
+/*
+typedef UINT32 (WINAPI * Func_GetPluginProperty)(PROPID propID, PROPVARIANT *value);
+
+static bool ReadPluginInfo(CPluginInfo &plugin, bool needCheckDll)
+{
+ if (needCheckDll)
+ {
+ NDLL::CLibrary lib;
+ if (!lib.LoadEx(plugin.FilePath, LOAD_LIBRARY_AS_DATAFILE))
+ return false;
+ }
+ NDLL::CLibrary lib;
+ if (!lib.Load(plugin.FilePath))
+ return false;
+ const
+ Func_GetPluginProperty
+ f_GetPluginProperty = ZIP7_GET_PROC_ADDRESS(
+ Func_GetPluginProperty, lib.Get_HMODULE(),
+ "GetPluginProperty");
+ if (!f_GetPluginProperty)
+ return false;
+
+ NCOM::CPropVariant prop;
+ if (f_GetPluginProperty(NPlugin::kType, &prop) != S_OK)
+ return false;
+ if (prop.vt == VT_EMPTY)
+ plugin.Type = kPluginTypeFF;
+ else if (prop.vt == VT_UI4)
+ plugin.Type = (EPluginType)prop.ulVal;
+ else
+ return false;
+ prop.Clear();
+
+ if (f_GetPluginProperty(NPlugin::kName, &prop) != S_OK)
+ return false;
+ if (prop.vt != VT_BSTR)
+ return false;
+ plugin.Name = prop.bstrVal;
+ prop.Clear();
+
+ if (f_GetPluginProperty(NPlugin::kClassID, &prop) != S_OK)
+ return false;
+ if (prop.vt == VT_EMPTY)
+ plugin.ClassID_Defined = false;
+ else if (prop.vt != VT_BSTR)
+ return false;
+ else
+ {
+ plugin.ClassID_Defined = true;
+ plugin.ClassID = *(const GUID *)(const void *)prop.bstrVal;
+ }
+ prop.Clear();
+ return true;
+*/
+
+/*
+{
+ if (f_GetPluginProperty(NPlugin::kOptionsClassID, &prop) != S_OK)
+ return false;
+ if (prop.vt == VT_EMPTY)
+ plugin.OptionsClassID_Defined = false;
+ else if (prop.vt != VT_BSTR)
+ return false;
+ else
+ {
+ plugin.OptionsClassID_Defined = true;
+ plugin.OptionsClassID = *(const GUID *)(const void *)prop.bstrVal;
+ }
+}
+*/
+
+ /*
+ {
+ // very old 7-zip used agent plugin in "7-zip.dll"
+ // but then agent code was moved to 7zfm.
+ // so now we don't need to load "7-zip.dll" here
+ CPluginInfo plugin;
+ plugin.FilePath = baseFolderPrefix + FTEXT("7-zip.dll");
+ if (::ReadPluginInfo(plugin, false))
+ if (plugin.Type == kPluginTypeFF)
+ plugins.Add(plugin);
+ }
+ */
+ /*
+ FString folderPath = NDLL::GetModuleDirPrefix();
+ folderPath += "Plugins" STRING_PATH_SEPARATOR;
+ NFind::CEnumerator enumerator;
+ enumerator.SetDirPrefix(folderPath);
+ NFind::CFileInfo fi;
+ while (enumerator.Next(fi))
+ {
+ if (fi.IsDir())
+ continue;
+ CPluginInfo plugin;
+ plugin.FilePath = folderPath + fi.Name;
+ if (::ReadPluginInfo(plugin, true))
+ if (plugin.Type == kPluginTypeFF)
+ plugins.Add(plugin);
+ }
+ */
+
+ /*
+ ReadPluginInfoList(plugins);
+ for (unsigned i = 0; i < plugins.Size();)
+ if (plugins[i].Type != kPluginTypeFF)
+ plugins.Delete(i);
+ else
+ i++;
+ */
+
+/*
+void ReadFileFolderPluginInfoList(CObjectVector<CPluginInfo> &plugins)
+{
+ plugins.Clear();
+ {
+ }
+
+ {
+ CPluginInfo &plugin = plugins.AddNew();
+ // p.FilePath.Empty();
+ plugin.Type = kPluginTypeFF;
+ plugin.Name = "7-Zip";
+ // plugin.ClassID = CLSID_CAgentArchiveHandler;
+ // plugin.ClassID_Defined = true;
+ // plugin.ClassID_Defined = false;
+ // plugin.OptionsClassID_Defined = false;
+ }
+}
+*/
diff --git a/CPP/7zip/UI/FileManager/RegistryPlugins.h b/CPP/7zip/UI/FileManager/RegistryPlugins.h
new file mode 100644
index 0000000..1cb765a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryPlugins.h
@@ -0,0 +1,29 @@
+// RegistryPlugins.h
+
+#ifndef ZIP7_INC_REGISTRY_PLUGINS_H
+#define ZIP7_INC_REGISTRY_PLUGINS_H
+
+#include "../../../Common/MyString.h"
+
+/*
+enum EPluginType
+{
+ kPluginTypeFF = 0
+};
+
+struct CPluginInfo
+{
+ EPluginType Type;
+ // bool ClassID_Defined;
+ // bool OptionsClassID_Defined;
+ // FString FilePath;
+ // UString Name;
+ // CLSID ClassID;
+ // CLSID OptionsClassID;
+};
+
+// void ReadPluginInfoList(CObjectVector<CPluginInfo> &plugins);
+// void ReadFileFolderPluginInfoList(CObjectVector<CPluginInfo> &plugins);
+*/
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/RegistryUtils.cpp b/CPP/7zip/UI/FileManager/RegistryUtils.cpp
new file mode 100644
index 0000000..7e61998
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryUtils.cpp
@@ -0,0 +1,196 @@
+// RegistryUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "../../../Windows/Registry.h"
+
+#include "RegistryUtils.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+#define REG_PATH_7Z TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-Zip")
+
+static LPCTSTR const kCUBasePath = REG_PATH_7Z;
+static LPCTSTR const kCU_FMPath = REG_PATH_7Z TEXT(STRING_PATH_SEPARATOR) TEXT("FM");
+// static LPCTSTR const kLM_Path = REG_PATH_7Z TEXT(STRING_PATH_SEPARATOR) TEXT("FM");
+
+static LPCWSTR const kLangValueName = L"Lang";
+
+static LPCWSTR const kViewer = L"Viewer";
+static LPCWSTR const kEditor = L"Editor";
+static LPCWSTR const kDiff = L"Diff";
+static LPCWSTR const kVerCtrlPath = L"7vc";
+
+static LPCTSTR const kShowDots = TEXT("ShowDots");
+static LPCTSTR const kShowRealFileIcons = TEXT("ShowRealFileIcons");
+static LPCTSTR const kFullRow = TEXT("FullRow");
+static LPCTSTR const kShowGrid = TEXT("ShowGrid");
+static LPCTSTR const kSingleClick = TEXT("SingleClick");
+static LPCTSTR const kAlternativeSelection = TEXT("AlternativeSelection");
+// static LPCTSTR const kUnderline = TEXT("Underline");
+
+static LPCTSTR const kShowSystemMenu = TEXT("ShowSystemMenu");
+
+// static LPCTSTR const kLockMemoryAdd = TEXT("LockMemoryAdd");
+static LPCTSTR const kLargePages = TEXT("LargePages");
+
+static LPCTSTR const kFlatViewName = TEXT("FlatViewArc");
+// static LPCTSTR const kShowDeletedFiles = TEXT("ShowDeleted");
+
+static void SaveCuString(LPCTSTR keyPath, LPCWSTR valuePath, LPCWSTR value)
+{
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, keyPath);
+ key.SetValue(valuePath, value);
+}
+
+static void ReadCuString(LPCTSTR keyPath, LPCWSTR valuePath, UString &res)
+{
+ res.Empty();
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, keyPath, KEY_READ) == ERROR_SUCCESS)
+ key.QueryValue(valuePath, res);
+}
+
+void SaveRegLang(const UString &path) { SaveCuString(kCUBasePath, kLangValueName, path); }
+void ReadRegLang(UString &path) { ReadCuString(kCUBasePath, kLangValueName, path); }
+
+void SaveRegEditor(bool useEditor, const UString &path) { SaveCuString(kCU_FMPath, useEditor ? kEditor : kViewer, path); }
+void ReadRegEditor(bool useEditor, UString &path) { ReadCuString(kCU_FMPath, useEditor ? kEditor : kViewer, path); }
+
+void SaveRegDiff(const UString &path) { SaveCuString(kCU_FMPath, kDiff, path); }
+void ReadRegDiff(UString &path) { ReadCuString(kCU_FMPath, kDiff, path); }
+
+void ReadReg_VerCtrlPath(UString &path) { ReadCuString(kCU_FMPath, kVerCtrlPath, path); }
+
+static void Save7ZipOption(LPCTSTR value, bool enabled)
+{
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCUBasePath);
+ key.SetValue(value, enabled);
+}
+
+static void SaveOption(LPCTSTR value, bool enabled)
+{
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCU_FMPath);
+ key.SetValue(value, enabled);
+}
+
+static bool Read7ZipOption(LPCTSTR value, bool defaultValue)
+{
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) == ERROR_SUCCESS)
+ {
+ bool enabled;
+ if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+ return enabled;
+ }
+ return defaultValue;
+}
+
+static void ReadOption(CKey &key, LPCTSTR value, bool &dest)
+{
+ bool enabled = false;
+ if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+ dest = enabled;
+}
+
+/*
+static void SaveLmOption(LPCTSTR value, bool enabled)
+{
+ CKey key;
+ key.Create(HKEY_LOCAL_MACHINE, kLM_Path);
+ key.SetValue(value, enabled);
+}
+
+static bool ReadLmOption(LPCTSTR value, bool defaultValue)
+{
+ CKey key;
+ if (key.Open(HKEY_LOCAL_MACHINE, kLM_Path, KEY_READ) == ERROR_SUCCESS)
+ {
+ bool enabled;
+ if (key.QueryValue(value, enabled) == ERROR_SUCCESS)
+ return enabled;
+ }
+ return defaultValue;
+}
+*/
+
+void CFmSettings::Save() const
+{
+ SaveOption(kShowDots, ShowDots);
+ SaveOption(kShowRealFileIcons, ShowRealFileIcons);
+ SaveOption(kFullRow, FullRow);
+ SaveOption(kShowGrid, ShowGrid);
+ SaveOption(kSingleClick, SingleClick);
+ SaveOption(kAlternativeSelection, AlternativeSelection);
+ // SaveOption(kUnderline, Underline);
+
+ SaveOption(kShowSystemMenu, ShowSystemMenu);
+}
+
+void CFmSettings::Load()
+{
+ ShowDots = false;
+ ShowRealFileIcons = false;
+ /* if (FullRow == false), we can use mouse click on another columns
+ to select group of files. We need to implement additional
+ way to select files in any column as in Explorer.
+ Then we can enable (FullRow == true) default mode. */
+ // FullRow = true;
+ FullRow = false;
+ ShowGrid = false;
+ SingleClick = false;
+ AlternativeSelection = false;
+ // Underline = false;
+
+ ShowSystemMenu = false;
+
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCU_FMPath, KEY_READ) == ERROR_SUCCESS)
+ {
+ ReadOption(key, kShowDots, ShowDots);
+ ReadOption(key, kShowRealFileIcons, ShowRealFileIcons);
+ ReadOption(key, kFullRow, FullRow);
+ ReadOption(key, kShowGrid, ShowGrid);
+ ReadOption(key, kSingleClick, SingleClick);
+ ReadOption(key, kAlternativeSelection, AlternativeSelection);
+ // ReadOption(key, kUnderline, Underline);
+
+ ReadOption(key, kShowSystemMenu, ShowSystemMenu );
+ }
+}
+
+
+// void SaveLockMemoryAdd(bool enable) { SaveLmOption(kLockMemoryAdd, enable); }
+// bool ReadLockMemoryAdd() { return ReadLmOption(kLockMemoryAdd, true); }
+
+void SaveLockMemoryEnable(bool enable) { Save7ZipOption(kLargePages, enable); }
+bool ReadLockMemoryEnable() { return Read7ZipOption(kLargePages, false); }
+
+static CSysString GetFlatViewName(UInt32 panelIndex)
+{
+ TCHAR panelString[16];
+ ConvertUInt32ToString(panelIndex, panelString);
+ return (CSysString)kFlatViewName + panelString;
+}
+
+void SaveFlatView(UInt32 panelIndex, bool enable) { SaveOption(GetFlatViewName(panelIndex), enable); }
+
+bool ReadFlatView(UInt32 panelIndex)
+{
+ bool enabled = false;
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCU_FMPath, KEY_READ) == ERROR_SUCCESS)
+ ReadOption(key, GetFlatViewName(panelIndex), enabled);
+ return enabled;
+}
+
+/*
+void Save_ShowDeleted(bool enable) { SaveOption(kShowDeletedFiles, enable); }
+bool Read_ShowDeleted() { return ReadOption(kShowDeletedFiles, false); }
+*/
diff --git a/CPP/7zip/UI/FileManager/RegistryUtils.h b/CPP/7zip/UI/FileManager/RegistryUtils.h
new file mode 100644
index 0000000..8b4cdf0
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RegistryUtils.h
@@ -0,0 +1,50 @@
+// RegistryUtils.h
+
+#ifndef ZIP7_INC_REGISTRY_UTILS_H
+#define ZIP7_INC_REGISTRY_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+void SaveRegLang(const UString &path);
+void ReadRegLang(UString &path);
+
+void SaveRegEditor(bool useEditor, const UString &path);
+void ReadRegEditor(bool useEditor, UString &path);
+
+void SaveRegDiff(const UString &path);
+void ReadRegDiff(UString &path);
+
+void ReadReg_VerCtrlPath(UString &path);
+
+struct CFmSettings
+{
+ bool ShowDots;
+ bool ShowRealFileIcons;
+ bool FullRow;
+ bool ShowGrid;
+ bool SingleClick;
+ bool AlternativeSelection;
+ // bool Underline;
+
+ bool ShowSystemMenu;
+
+ void Save() const;
+ void Load();
+};
+
+// void SaveLockMemoryAdd(bool enable);
+// bool ReadLockMemoryAdd();
+
+bool ReadLockMemoryEnable();
+void SaveLockMemoryEnable(bool enable);
+
+void SaveFlatView(UInt32 panelIndex, bool enable);
+bool ReadFlatView(UInt32 panelIndex);
+
+/*
+void Save_ShowDeleted(bool enable);
+bool Read_ShowDeleted();
+*/
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/RootFolder.cpp b/CPP/7zip/UI/FileManager/RootFolder.cpp
new file mode 100644
index 0000000..34dd638
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RootFolder.cpp
@@ -0,0 +1,326 @@
+// RootFolder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/PropVariant.h"
+
+#include "../../PropID.h"
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+#define USE_WIN_PATHS
+#endif
+
+static const unsigned kNumRootFolderItems =
+ #ifdef USE_WIN_PATHS
+ 4
+ #else
+ 1
+ #endif
+ ;
+
+
+#include "FSFolder.h"
+#include "LangUtils.h"
+#ifdef USE_WIN_PATHS
+#include "NetFolder.h"
+#include "FSDrives.h"
+#include "AltStreamsFolder.h"
+#endif
+#include "RootFolder.h"
+#include "SysIconUtils.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+
+static const Byte kProps[] =
+{
+ kpidName
+};
+
+UString RootFolder_GetName_Computer(int &iconIndex);
+UString RootFolder_GetName_Computer(int &iconIndex)
+{
+ #ifdef USE_WIN_PATHS
+ iconIndex = GetIconIndexForCSIDL(CSIDL_DRIVES);
+ #else
+ GetRealIconIndex(FSTRING_PATH_SEPARATOR, FILE_ATTRIBUTE_DIRECTORY, iconIndex);
+ #endif
+ return LangString(IDS_COMPUTER);
+}
+
+UString RootFolder_GetName_Network(int &iconIndex);
+UString RootFolder_GetName_Network(int &iconIndex)
+{
+ iconIndex = GetIconIndexForCSIDL(CSIDL_NETWORK);
+ return LangString(IDS_NETWORK);
+}
+
+UString RootFolder_GetName_Documents(int &iconIndex);
+UString RootFolder_GetName_Documents(int &iconIndex)
+{
+ iconIndex = GetIconIndexForCSIDL(CSIDL_PERSONAL);
+ return LangString(IDS_DOCUMENTS);
+}
+
+enum
+{
+ ROOT_INDEX_COMPUTER = 0
+ #ifdef USE_WIN_PATHS
+ , ROOT_INDEX_DOCUMENTS
+ , ROOT_INDEX_NETWORK
+ , ROOT_INDEX_VOLUMES
+ #endif
+};
+
+#ifdef USE_WIN_PATHS
+static const char * const kVolPrefix = "\\\\.";
+#endif
+
+void CRootFolder::Init()
+{
+ _names[ROOT_INDEX_COMPUTER] = RootFolder_GetName_Computer(_iconIndices[ROOT_INDEX_COMPUTER]);
+ #ifdef USE_WIN_PATHS
+ _names[ROOT_INDEX_DOCUMENTS] = RootFolder_GetName_Documents(_iconIndices[ROOT_INDEX_DOCUMENTS]);
+ _names[ROOT_INDEX_NETWORK] = RootFolder_GetName_Network(_iconIndices[ROOT_INDEX_NETWORK]);
+ _names[ROOT_INDEX_VOLUMES] = kVolPrefix;
+ _iconIndices[ROOT_INDEX_VOLUMES] = GetIconIndexForCSIDL(CSIDL_DRIVES);
+ #endif
+}
+
+Z7_COM7F_IMF(CRootFolder::LoadItems())
+{
+ Init();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CRootFolder::GetNumberOfItems(UInt32 *numItems))
+{
+ *numItems = kNumRootFolderItems;
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CRootFolder::GetProperty(UInt32 itemIndex, PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidIsDir: prop = true; break;
+ case kpidName: prop = _names[itemIndex]; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+typedef BOOL (WINAPI *Func_SHGetSpecialFolderPathW)(HWND hwnd, LPWSTR pszPath, int csidl, BOOL fCreate);
+typedef BOOL (WINAPI *Func_SHGetSpecialFolderPathA)(HWND hwnd, LPSTR pszPath, int csidl, BOOL fCreate);
+
+static UString GetMyDocsPath()
+{
+ UString us;
+ WCHAR s[MAX_PATH + 1];
+#ifdef UNDER_CE
+ #define shell_name TEXT("coredll.dll")
+#else
+ #define shell_name TEXT("shell32.dll")
+#endif
+ Func_SHGetSpecialFolderPathW getW = Z7_GET_PROC_ADDRESS(
+ Func_SHGetSpecialFolderPathW, GetModuleHandle(shell_name),
+ "SHGetSpecialFolderPathW");
+ if (getW && getW(NULL, s, CSIDL_PERSONAL, FALSE))
+ us = s;
+ #ifndef _UNICODE
+ else
+ {
+ Func_SHGetSpecialFolderPathA getA = Z7_GET_PROC_ADDRESS(
+ Func_SHGetSpecialFolderPathA, ::GetModuleHandleA("shell32.dll"),
+ "SHGetSpecialFolderPathA");
+ CHAR s2[MAX_PATH + 1];
+ if (getA && getA(NULL, s2, CSIDL_PERSONAL, FALSE))
+ us = GetUnicodeString(s2);
+ }
+ #endif
+ NFile::NName::NormalizeDirPathPrefix(us);
+ return us;
+}
+
+Z7_COM7F_IMF(CRootFolder::BindToFolder(UInt32 index, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ CMyComPtr<IFolderFolder> subFolder;
+
+ #ifdef USE_WIN_PATHS
+ if (index == ROOT_INDEX_COMPUTER || index == ROOT_INDEX_VOLUMES)
+ {
+ CFSDrives *fsDrivesSpec = new CFSDrives;
+ subFolder = fsDrivesSpec;
+ fsDrivesSpec->Init(index == ROOT_INDEX_VOLUMES);
+ }
+ else if (index == ROOT_INDEX_NETWORK)
+ {
+ CNetFolder *netFolderSpec = new CNetFolder;
+ subFolder = netFolderSpec;
+ netFolderSpec->Init(NULL, NULL, _names[ROOT_INDEX_NETWORK] + WCHAR_PATH_SEPARATOR);
+ }
+ else if (index == ROOT_INDEX_DOCUMENTS)
+ {
+ UString s = GetMyDocsPath();
+ if (!s.IsEmpty())
+ {
+ NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+ subFolder = fsFolderSpec;
+ RINOK(fsFolderSpec->Init(us2fs(s)))
+ }
+ }
+ #else
+ if (index == ROOT_INDEX_COMPUTER)
+ {
+ NFsFolder::CFSFolder *fsFolder = new NFsFolder::CFSFolder;
+ subFolder = fsFolder;
+ fsFolder->InitToRoot();
+ }
+ #endif
+ else
+ return E_INVALIDARG;
+
+ *resultFolder = subFolder.Detach();
+ return S_OK;
+}
+
+static bool AreEqualNames(const UString &path, const wchar_t *name)
+{
+ unsigned len = MyStringLen(name);
+ if (len > path.Len() || len + 1 < path.Len())
+ return false;
+ if (len + 1 == path.Len() && !IS_PATH_SEPAR(path[len]))
+ return false;
+ return path.IsPrefixedBy(name);
+}
+
+Z7_COM7F_IMF(CRootFolder::BindToFolder(const wchar_t *name, IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ UString name2 = name;
+ name2.Trim();
+
+ if (name2.IsEmpty())
+ {
+ CRootFolder *rootFolderSpec = new CRootFolder;
+ CMyComPtr<IFolderFolder> rootFolder = rootFolderSpec;
+ rootFolderSpec->Init();
+ *resultFolder = rootFolder.Detach();
+ return S_OK;
+ }
+
+ for (unsigned i = 0; i < kNumRootFolderItems; i++)
+ if (AreEqualNames(name2, _names[i]))
+ return BindToFolder((UInt32)i, resultFolder);
+
+ #ifdef USE_WIN_PATHS
+ if (AreEqualNames(name2, L"My Documents") ||
+ AreEqualNames(name2, L"Documents"))
+ return BindToFolder((UInt32)ROOT_INDEX_DOCUMENTS, resultFolder);
+ #else
+ if (name2 == WSTRING_PATH_SEPARATOR)
+ return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
+ #endif
+
+ if (AreEqualNames(name2, L"My Computer") ||
+ AreEqualNames(name2, L"Computer"))
+ return BindToFolder((UInt32)ROOT_INDEX_COMPUTER, resultFolder);
+
+ if (name2 == WSTRING_PATH_SEPARATOR)
+ {
+ CMyComPtr<IFolderFolder> subFolder = this;
+ *resultFolder = subFolder.Detach();
+ return S_OK;
+ }
+
+ if (name2.Len() < 2)
+ return E_INVALIDARG;
+
+ CMyComPtr<IFolderFolder> subFolder;
+
+ #ifdef USE_WIN_PATHS
+ if (name2.IsPrefixedBy_Ascii_NoCase(kVolPrefix))
+ {
+ CFSDrives *folderSpec = new CFSDrives;
+ subFolder = folderSpec;
+ folderSpec->Init(true);
+ }
+ else if (name2.IsEqualTo(NFile::NName::kSuperPathPrefix))
+ {
+ CFSDrives *folderSpec = new CFSDrives;
+ subFolder = folderSpec;
+ folderSpec->Init(false, true);
+ }
+ else if (name2.Back() == ':'
+ && (name2.Len() != 2 || !NFile::NName::IsDrivePath2(name2)))
+ {
+ NAltStreamsFolder::CAltStreamsFolder *folderSpec = new NAltStreamsFolder::CAltStreamsFolder;
+ subFolder = folderSpec;
+ if (folderSpec->Init(us2fs(name2)) != S_OK)
+ return E_INVALIDARG;
+ }
+ else
+ #endif
+ {
+ NFile::NName::NormalizeDirPathPrefix(name2);
+ NFsFolder::CFSFolder *fsFolderSpec = new NFsFolder::CFSFolder;
+ subFolder = fsFolderSpec;
+ if (fsFolderSpec->Init(us2fs(name2)) != S_OK)
+ {
+ #ifdef USE_WIN_PATHS
+ if (IS_PATH_SEPAR(name2[0]))
+ {
+ CNetFolder *netFolderSpec = new CNetFolder;
+ subFolder = netFolderSpec;
+ netFolderSpec->Init(name2);
+ }
+ else
+ #endif
+ return E_INVALIDARG;
+ }
+ }
+
+ *resultFolder = subFolder.Detach();
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CRootFolder::BindToParentFolder(IFolderFolder **resultFolder))
+{
+ *resultFolder = NULL;
+ return S_OK;
+}
+
+IMP_IFolderFolder_Props(CRootFolder)
+
+Z7_COM7F_IMF(CRootFolder::GetFolderProperty(PROPID propID, PROPVARIANT *value))
+{
+ NCOM::CPropVariant prop;
+ switch (propID)
+ {
+ case kpidType: prop = "RootFolder"; break;
+ case kpidPath: prop = ""; break;
+ }
+ prop.Detach(value);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CRootFolder::GetSystemIconIndex(UInt32 index, Int32 *iconIndex))
+{
+ *iconIndex = _iconIndices[index];
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/FileManager/RootFolder.h b/CPP/7zip/UI/FileManager/RootFolder.h
new file mode 100644
index 0000000..3f0a31b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/RootFolder.h
@@ -0,0 +1,24 @@
+// RootFolder.h
+
+#ifndef ZIP7_INC_ROOT_FOLDER_H
+#define ZIP7_INC_ROOT_FOLDER_H
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/MyString.h"
+
+#include "IFolder.h"
+
+const unsigned kNumRootFolderItems_Max = 4;
+
+Z7_CLASS_IMP_NOQIB_2(
+ CRootFolder
+ , IFolderFolder
+ , IFolderGetSystemIconIndex
+)
+ UString _names[kNumRootFolderItems_Max];
+ int _iconIndices[kNumRootFolderItems_Max];
+public:
+ void Init();
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.cpp b/CPP/7zip/UI/FileManager/SettingsPage.cpp
new file mode 100644
index 0000000..784b8c7
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage.cpp
@@ -0,0 +1,354 @@
+// SettingsPage.cpp
+
+#include "StdAfx.h"
+
+// #include "../../../Common/IntToString.h"
+// #include "../../../Common/StringConvert.h"
+
+#ifndef UNDER_CE
+#include "../../../Windows/MemoryLock.h"
+// #include "../../../Windows/System.h"
+#endif
+
+// #include "../Common/ZipRegistry.h"
+
+#include "HelpUtils.h"
+#include "LangUtils.h"
+#include "RegistryUtils.h"
+#include "SettingsPage.h"
+#include "SettingsPageRes.h"
+
+using namespace NWindows;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDX_SETTINGS_SHOW_DOTS,
+ IDX_SETTINGS_SHOW_REAL_FILE_ICONS,
+ IDX_SETTINGS_SHOW_SYSTEM_MENU,
+ IDX_SETTINGS_FULL_ROW,
+ IDX_SETTINGS_SHOW_GRID,
+ IDX_SETTINGS_SINGLE_CLICK,
+ IDX_SETTINGS_ALTERNATIVE_SELECTION,
+ IDX_SETTINGS_LARGE_PAGES
+ // , IDT_COMPRESS_MEMORY
+};
+#endif
+
+#define kSettingsTopic "FM/options.htm#settings"
+
+extern bool IsLargePageSupported();
+
+/*
+static void AddMemSize(UString &res, UInt64 size, bool needRound = false)
+{
+ char c;
+ unsigned moveBits = 0;
+ if (needRound)
+ {
+ UInt64 rn = 0;
+ if (size >= (1 << 31))
+ rn = (1 << 28) - 1;
+ UInt32 kRound = (1 << 20) - 1;
+ if (rn < kRound)
+ rn = kRound;
+ size += rn;
+ size &= ~rn;
+ }
+ if (size >= ((UInt64)1 << 31) && (size & 0x3FFFFFFF) == 0)
+ { moveBits = 30; c = 'G'; }
+ else
+ { moveBits = 20; c = 'M'; }
+ res.Add_UInt64(size >> moveBits);
+ res.Add_Space();
+ if (moveBits != 0)
+ res += c;
+ res += 'B';
+}
+
+
+int CSettingsPage::AddMemComboItem(UInt64 size, UInt64 percents, bool isDefault)
+{
+ UString sUser;
+ UString sRegistry;
+ if (size == 0)
+ {
+ UString s;
+ s.Add_UInt64(percents);
+ s += '%';
+ if (isDefault)
+ sUser = "* ";
+ else
+ sRegistry = s;
+ sUser += s;
+ }
+ else
+ {
+ AddMemSize(sUser, size);
+ sRegistry = sUser;
+ for (;;)
+ {
+ int pos = sRegistry.Find(L' ');
+ if (pos < 0)
+ break;
+ sRegistry.Delete(pos);
+ }
+ if (!sRegistry.IsEmpty())
+ if (sRegistry.Back() == 'B')
+ sRegistry.DeleteBack();
+ }
+ const int index = (int)_memCombo.AddString(sUser);
+ _memCombo.SetItemData(index, _memLimitStrings.Size());
+ _memLimitStrings.Add(sRegistry);
+ return index;
+}
+*/
+
+bool CSettingsPage::OnInit()
+{
+ _wasChanged = false;
+ _largePages_wasChanged = false;
+ /*
+ _wasChanged_MemLimit = false;
+ _memLimitStrings.Clear();
+ _memCombo.Attach(GetItem(IDC_SETTINGS_MEM));
+ */
+
+#ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+#endif
+
+ CFmSettings st;
+ st.Load();
+
+ CheckButton(IDX_SETTINGS_SHOW_DOTS, st.ShowDots);
+ CheckButton(IDX_SETTINGS_SHOW_REAL_FILE_ICONS, st.ShowRealFileIcons);
+ CheckButton(IDX_SETTINGS_FULL_ROW, st.FullRow);
+ CheckButton(IDX_SETTINGS_SHOW_GRID, st.ShowGrid);
+ CheckButton(IDX_SETTINGS_SINGLE_CLICK, st.SingleClick);
+ CheckButton(IDX_SETTINGS_ALTERNATIVE_SELECTION, st.AlternativeSelection);
+ // CheckButton(IDX_SETTINGS_UNDERLINE, st.Underline);
+
+ CheckButton(IDX_SETTINGS_SHOW_SYSTEM_MENU, st.ShowSystemMenu);
+
+ if (IsLargePageSupported())
+ CheckButton(IDX_SETTINGS_LARGE_PAGES, ReadLockMemoryEnable());
+ else
+ EnableItem(IDX_SETTINGS_LARGE_PAGES, false);
+
+
+ /*
+ NCompression::CMemUse mu;
+ bool needSetCur = NCompression::MemLimit_Load(mu);
+ UInt64 curMemLimit;
+ {
+ AddMemComboItem(0, 90, true);
+ _memCombo.SetCurSel(0);
+ }
+ if (mu.IsPercent)
+ {
+ const int index = AddMemComboItem(0, mu.Val);
+ _memCombo.SetCurSel(index);
+ needSetCur = false;
+ }
+ {
+ _ramSize = (UInt64)(sizeof(size_t)) << 29;
+ _ramSize_Defined = NSystem::GetRamSize(_ramSize);
+ UString s;
+ if (_ramSize_Defined)
+ {
+ s += "/ ";
+ AddMemSize(s, _ramSize, true);
+ }
+ SetItemText(IDT_SETTINGS_MEM_RAM, s);
+
+ curMemLimit = mu.GetBytes(_ramSize);
+
+ // size = 100 << 20; // for debug only;
+ for (unsigned i = (27) * 2;; i++)
+ {
+ UInt64 size = (UInt64)(2 + (i & 1)) << (i / 2);
+ if (i > (20 + sizeof(size_t) * 3 * 1 - 1) * 2)
+ size = (UInt64)(Int64)-1;
+ if (needSetCur && (size >= curMemLimit))
+ {
+ const int index = AddMemComboItem(curMemLimit);
+ _memCombo.SetCurSel(index);
+ needSetCur = false;
+ if (size == curMemLimit)
+ continue;
+ }
+ if (size == (UInt64)(Int64)-1)
+ break;
+ AddMemComboItem(size);
+ }
+ }
+ */
+
+ // EnableSubItems();
+
+ return CPropertyPage::OnInit();
+}
+
+/*
+void CSettingsPage::EnableSubItems()
+{
+ EnableItem(IDX_SETTINGS_UNDERLINE, IsButtonCheckedBool(IDX_SETTINGS_SINGLE_CLICK));
+}
+*/
+
+/*
+static void AddSize_MB(UString &s, UInt64 size)
+{
+ s.Add_UInt64((size + (1 << 20) - 1) >> 20);
+ s += " MB";
+}
+*/
+
+LONG CSettingsPage::OnApply()
+{
+ if (_wasChanged)
+ {
+ CFmSettings st;
+ st.ShowDots = IsButtonCheckedBool(IDX_SETTINGS_SHOW_DOTS);
+ st.ShowRealFileIcons = IsButtonCheckedBool(IDX_SETTINGS_SHOW_REAL_FILE_ICONS);
+ st.FullRow = IsButtonCheckedBool(IDX_SETTINGS_FULL_ROW);
+ st.ShowGrid = IsButtonCheckedBool(IDX_SETTINGS_SHOW_GRID);
+ st.SingleClick = IsButtonCheckedBool(IDX_SETTINGS_SINGLE_CLICK);
+ st.AlternativeSelection = IsButtonCheckedBool(IDX_SETTINGS_ALTERNATIVE_SELECTION);
+ // st.Underline = IsButtonCheckedBool(IDX_SETTINGS_UNDERLINE);
+
+ st.ShowSystemMenu = IsButtonCheckedBool(IDX_SETTINGS_SHOW_SYSTEM_MENU);
+
+ st.Save();
+ _wasChanged = false;
+ }
+
+ #ifndef UNDER_CE
+ if (_largePages_wasChanged)
+ {
+ if (IsLargePageSupported())
+ {
+ const bool enable = IsButtonCheckedBool(IDX_SETTINGS_LARGE_PAGES);
+ NSecurity::EnablePrivilege_LockMemory(enable);
+ SaveLockMemoryEnable(enable);
+ }
+ _largePages_wasChanged = false;
+ }
+ #endif
+
+ /*
+ if (_wasChanged_MemLimit)
+ {
+ const unsigned index = (int)_memCombo.GetItemData_of_CurSel();
+ const UString str = _memLimitStrings[index];
+
+ bool needSave = true;
+
+ NCompression::CMemUse mu;
+
+ if (_ramSize_Defined)
+ mu.Parse(str);
+ if (mu.IsDefined)
+ {
+ const UInt64 usage64 = mu.GetBytes(_ramSize);
+ if (_ramSize <= usage64)
+ {
+ UString s2 = LangString(IDT_COMPRESS_MEMORY);
+ if (s2.IsEmpty())
+ GetItemText(IDT_COMPRESS_MEMORY, s2);
+ UString s;
+
+ s += "The selected value is not safe for system performance.";
+ s.Add_LF();
+ s += "The memory consumption for compression operation will exceed RAM size.";
+ s.Add_LF();
+ s.Add_LF();
+ AddSize_MB(s, usage64);
+
+ if (!s2.IsEmpty())
+ {
+ s += " : ";
+ s += s2;
+ }
+
+ s.Add_LF();
+ AddSize_MB(s, _ramSize);
+ s += " : RAM";
+
+ s.Add_LF();
+ s.Add_LF();
+ s += "Are you sure you want set that unsafe value for memory usage?";
+
+ int res = MessageBoxW(*this, s, L"7-Zip", MB_YESNOCANCEL | MB_ICONQUESTION);
+ if (res != IDYES)
+ needSave = false;
+ }
+ }
+
+ if (needSave)
+ {
+ NCompression::MemLimit_Save(str);
+ _wasChanged_MemLimit = false;
+ }
+ else
+ return PSNRET_INVALID_NOCHANGEPAGE;
+ }
+ */
+
+ return PSNRET_NOERROR;
+}
+
+void CSettingsPage::OnNotifyHelp()
+{
+ ShowHelpWindow(kSettingsTopic);
+}
+
+/*
+bool CSettingsPage::OnCommand(unsigned code, unsigned itemID, LPARAM param)
+{
+ if (code == CBN_SELCHANGE)
+ {
+ switch (itemID)
+ {
+ case IDC_SETTINGS_MEM:
+ {
+ _wasChanged_MemLimit = true;
+ Changed();
+ break;
+ }
+ }
+ }
+ return CPropertyPage::OnCommand(code, itemID, param);
+}
+*/
+
+bool CSettingsPage::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDX_SETTINGS_SINGLE_CLICK:
+ /*
+ EnableSubItems();
+ break;
+ */
+ case IDX_SETTINGS_SHOW_DOTS:
+ case IDX_SETTINGS_SHOW_SYSTEM_MENU:
+ case IDX_SETTINGS_SHOW_REAL_FILE_ICONS:
+ case IDX_SETTINGS_FULL_ROW:
+ case IDX_SETTINGS_SHOW_GRID:
+ case IDX_SETTINGS_ALTERNATIVE_SELECTION:
+ _wasChanged = true;
+ break;
+
+ case IDX_SETTINGS_LARGE_PAGES:
+ _largePages_wasChanged = true;
+ break;
+
+ default:
+ return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+ }
+
+ Changed();
+ return true;
+}
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.h b/CPP/7zip/UI/FileManager/SettingsPage.h
new file mode 100644
index 0000000..91b9828
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage.h
@@ -0,0 +1,33 @@
+// SettingsPage.h
+
+#ifndef ZIP7_INC_SETTINGS_PAGE_H
+#define ZIP7_INC_SETTINGS_PAGE_H
+
+#include "../../../Windows/Control/PropertyPage.h"
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+
+class CSettingsPage: public NWindows::NControl::CPropertyPage
+{
+ bool _wasChanged;
+ bool _largePages_wasChanged;
+ /*
+ bool _wasChanged_MemLimit;
+ NWindows::NControl::CComboBox _memCombo;
+ UStringVector _memLimitStrings;
+ UInt64 _ramSize;
+ UInt64 _ramSize_Defined;
+
+ int AddMemComboItem(UInt64 size, UInt64 percents = 0, bool isDefault = false);
+ */
+
+ // void EnableSubItems();
+ // bool OnCommand(unsigned code, unsigned itemID, LPARAM param) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual void OnNotifyHelp() Z7_override;
+ virtual LONG OnApply() Z7_override;
+public:
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SettingsPage.rc b/CPP/7zip/UI/FileManager/SettingsPage.rc
new file mode 100644
index 0000000..baab484
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage.rc
@@ -0,0 +1,22 @@
+#include "SettingsPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 250
+
+IDD_SETTINGS MY_PAGE
+#include "SettingsPage2.rc"
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+
+IDD_SETTINGS_2 MY_PAGE
+#include "SettingsPage2.rc"
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SettingsPage2.rc b/CPP/7zip/UI/FileManager/SettingsPage2.rc
new file mode 100644
index 0000000..cf90742
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPage2.rc
@@ -0,0 +1,19 @@
+// #define g1xs 60
+
+CAPTION "Settings"
+BEGIN
+ CONTROL "Show "".."" item", IDX_SETTINGS_SHOW_DOTS, MY_CHECKBOX, m, 8, xc, 10
+ CONTROL "Show real file &icons", IDX_SETTINGS_SHOW_REAL_FILE_ICONS, MY_CHECKBOX, m, 22, xc, 10
+ CONTROL "&Full row select", IDX_SETTINGS_FULL_ROW, MY_CHECKBOX, m, 36, xc, 10
+ CONTROL "Show &grid lines", IDX_SETTINGS_SHOW_GRID, MY_CHECKBOX, m, 50, xc, 10
+ CONTROL "&Single-click to open an item", IDX_SETTINGS_SINGLE_CLICK, MY_CHECKBOX, m, 64, xc, 10
+ CONTROL "&Alternative selection mode", IDX_SETTINGS_ALTERNATIVE_SELECTION, MY_CHECKBOX, m, 78, xc, 10
+
+ CONTROL "Show system &menu", IDX_SETTINGS_SHOW_SYSTEM_MENU, MY_CHECKBOX, m, 100, xc, 10
+
+ CONTROL "Use &large memory pages", IDX_SETTINGS_LARGE_PAGES, MY_CHECKBOX, m, 122, xc, 10
+
+ // LTEXT "Memory usage for Compressing:", IDT_COMPRESS_MEMORY, m, 140, xc, 8
+ // COMBOBOX IDC_SETTINGS_MEM, m , 152, g1xs, yc - 152, MY_COMBO
+ // LTEXT "/ RAM", IDT_SETTINGS_MEM_RAM, m + g1xs + m, 154, xc - g1xs - m, MY_TEXT_NOPREFIX
+END
diff --git a/CPP/7zip/UI/FileManager/SettingsPageRes.h b/CPP/7zip/UI/FileManager/SettingsPageRes.h
new file mode 100644
index 0000000..e990bab
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SettingsPageRes.h
@@ -0,0 +1,17 @@
+#define IDD_SETTINGS 2500
+#define IDD_SETTINGS_2 12500
+
+#define IDX_SETTINGS_SHOW_DOTS 2501
+#define IDX_SETTINGS_SHOW_REAL_FILE_ICONS 2502
+#define IDX_SETTINGS_SHOW_SYSTEM_MENU 2503
+#define IDX_SETTINGS_FULL_ROW 2504
+#define IDX_SETTINGS_SHOW_GRID 2505
+#define IDX_SETTINGS_SINGLE_CLICK 2506
+#define IDX_SETTINGS_ALTERNATIVE_SELECTION 2507
+#define IDX_SETTINGS_LARGE_PAGES 2508
+
+
+// #define IDT_SETTINGS_MEM 100
+// #define IDC_SETTINGS_MEM 101
+// #define IDT_SETTINGS_MEM_RAM 102
+// #define IDT_COMPRESS_MEMORY 4017
diff --git a/CPP/7zip/UI/FileManager/SplitDialog.cpp b/CPP/7zip/UI/FileManager/SplitDialog.cpp
new file mode 100644
index 0000000..21d812c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialog.cpp
@@ -0,0 +1,114 @@
+// SplitDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/FileName.h"
+
+#include "LangUtils.h"
+
+#include "BrowseDialog.h"
+#include "CopyDialogRes.h"
+#include "SplitDialog.h"
+#include "SplitUtils.h"
+#include "resourceGui.h"
+
+using namespace NWindows;
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_SPLIT_PATH,
+ IDT_SPLIT_VOLUME
+};
+#endif
+
+
+bool CSplitDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_SPLIT);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ #endif
+ _pathCombo.Attach(GetItem(IDC_SPLIT_PATH));
+ _volumeCombo.Attach(GetItem(IDC_SPLIT_VOLUME));
+
+ if (!FilePath.IsEmpty())
+ {
+ UString title;
+ GetText(title);
+ title.Add_Space();
+ title += FilePath;
+ SetText(title);
+ }
+ _pathCombo.SetText(Path);
+ AddVolumeItems(_volumeCombo);
+ _volumeCombo.SetCurSel(0);
+ NormalizeSize();
+ return CModalDialog::OnInit();
+}
+
+bool CSplitDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+ int bx1, bx2, by;
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDOK, bx2, by);
+ int yPos = ySize - my - by;
+ int xPos = xSize - mx - bx1;
+
+ InvalidateRect(NULL);
+
+ {
+ RECT r;
+ GetClientRectOfItem(IDB_SPLIT_PATH, r);
+ int bx = RECT_SIZE_X(r);
+ MoveItem(IDB_SPLIT_PATH, xSize - mx - bx, r.top, bx, RECT_SIZE_Y(r));
+ ChangeSubWindowSizeX(_pathCombo, xSize - mx - mx - bx - mx);
+ }
+
+ MoveItem(IDCANCEL, xPos, yPos, bx1, by);
+ MoveItem(IDOK, xPos - mx - bx2, yPos, bx2, by);
+
+ return false;
+}
+
+bool CSplitDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_SPLIT_PATH:
+ OnButtonSetPath();
+ return true;
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CSplitDialog::OnButtonSetPath()
+{
+ UString currentPath;
+ _pathCombo.GetText(currentPath);
+ // UString title = "Specify a location for output folder";
+ const UString title = LangString(IDS_SET_FOLDER);
+
+ UString resultPath;
+ if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+ return;
+ NFile::NName::NormalizeDirPathPrefix(resultPath);
+ _pathCombo.SetCurSel(-1);
+ _pathCombo.SetText(resultPath);
+}
+
+void CSplitDialog::OnOK()
+{
+ _pathCombo.GetText(Path);
+ UString volumeString;
+ _volumeCombo.GetText(volumeString);
+ volumeString.Trim();
+ if (!ParseVolumeSizes(volumeString, VolumeSizes) || VolumeSizes.Size() == 0)
+ {
+ ::MessageBoxW(*this, LangString(IDS_INCORRECT_VOLUME_SIZE), L"7-Zip", MB_ICONERROR);
+ return;
+ }
+ CModalDialog::OnOK();
+}
diff --git a/CPP/7zip/UI/FileManager/SplitDialog.h b/CPP/7zip/UI/FileManager/SplitDialog.h
new file mode 100644
index 0000000..f897136
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialog.h
@@ -0,0 +1,28 @@
+// SplitDialog.h
+
+#ifndef ZIP7_INC_SPLIT_DIALOG_H
+#define ZIP7_INC_SPLIT_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+#include "../../../Windows/Control/ComboBox.h"
+
+#include "SplitDialogRes.h"
+
+class CSplitDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CComboBox _pathCombo;
+ NWindows::NControl::CComboBox _volumeCombo;
+ virtual void OnOK() Z7_override;
+ virtual bool OnInit() Z7_override;
+ virtual bool OnSize(WPARAM wParam, int xSize, int ySize) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ void OnButtonSetPath();
+public:
+ UString FilePath;
+ UString Path;
+ CRecordVector<UInt64> VolumeSizes;
+ INT_PTR Create(HWND parentWindow = NULL)
+ { return CModalDialog::Create(IDD_SPLIT, parentWindow); }
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SplitDialog.rc b/CPP/7zip/UI/FileManager/SplitDialog.rc
new file mode 100644
index 0000000..5a026e8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialog.rc
@@ -0,0 +1,16 @@
+#include "SplitDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 288
+#define yc 96
+
+IDD_SPLIT DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Split File"
+BEGIN
+ LTEXT "&Split to:", IDT_SPLIT_PATH, m, m, xc, 8
+ COMBOBOX IDC_SPLIT_PATH, m, 20, xc - bxsDots - m, 64, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_SPLIT_PATH, xs - m - bxsDots, 18, bxsDots, bys, WS_GROUP
+ LTEXT "Split to &volumes, bytes:", IDT_SPLIT_VOLUME, m, 44, xc, 8
+ COMBOBOX IDC_SPLIT_VOLUME, m, 56, 96, 52, MY_COMBO_WITH_EDIT
+ OK_CANCEL
+END
diff --git a/CPP/7zip/UI/FileManager/SplitDialogRes.h b/CPP/7zip/UI/FileManager/SplitDialogRes.h
new file mode 100644
index 0000000..50584a1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitDialogRes.h
@@ -0,0 +1,8 @@
+#define IDD_SPLIT 7300
+
+#define IDT_SPLIT_PATH 7301
+#define IDT_SPLIT_VOLUME 7302
+
+#define IDC_SPLIT_PATH 100
+#define IDB_SPLIT_PATH 101
+#define IDC_SPLIT_VOLUME 102
diff --git a/CPP/7zip/UI/FileManager/SplitUtils.cpp b/CPP/7zip/UI/FileManager/SplitUtils.cpp
new file mode 100644
index 0000000..1982afb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitUtils.cpp
@@ -0,0 +1,96 @@
+// SplitUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringToInt.h"
+
+#include "SplitUtils.h"
+
+bool ParseVolumeSizes(const UString &s, CRecordVector<UInt64> &values)
+{
+ values.Clear();
+ bool prevIsNumber = false;
+ for (unsigned i = 0; i < s.Len();)
+ {
+ wchar_t c = s[i++];
+ if (c == L' ')
+ continue;
+ if (c == L'-')
+ return true;
+ if (prevIsNumber)
+ {
+ prevIsNumber = false;
+ unsigned numBits = 0;
+ switch (MyCharLower_Ascii(c))
+ {
+ case 'b': continue;
+ case 'k': numBits = 10; break;
+ case 'm': numBits = 20; break;
+ case 'g': numBits = 30; break;
+ case 't': numBits = 40; break;
+ }
+ if (numBits != 0)
+ {
+ UInt64 &val = values.Back();
+ if (val >= ((UInt64)1 << (64 - numBits)))
+ return false;
+ val <<= numBits;
+
+ for (; i < s.Len(); i++)
+ if (s[i] == L' ')
+ break;
+ continue;
+ }
+ }
+ i--;
+ const wchar_t *start = s.Ptr(i);
+ const wchar_t *end;
+ UInt64 val = ConvertStringToUInt64(start, &end);
+ if (start == end)
+ return false;
+ if (val == 0)
+ return false;
+ values.Add(val);
+ prevIsNumber = true;
+ i += (unsigned)(end - start);
+ }
+ return true;
+}
+
+
+static const char * const k_Sizes[] =
+{
+ "10M"
+ , "100M"
+ , "1000M"
+ , "650M - CD"
+ , "700M - CD"
+ , "4092M - FAT"
+ , "4480M - DVD" // 4489 MiB limit
+ , "8128M - DVD DL" // 8147 MiB limit
+ , "23040M - BD" // 23866 MiB limit
+ // , "1457664 - 3.5\" floppy"
+};
+
+void AddVolumeItems(NWindows::NControl::CComboBox &combo)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_Sizes); i++)
+ combo.AddString(CSysString(k_Sizes[i]));
+}
+
+UInt64 GetNumberOfVolumes(UInt64 size, const CRecordVector<UInt64> &volSizes)
+{
+ if (size == 0 || volSizes.Size() == 0)
+ return 1;
+ FOR_VECTOR (i, volSizes)
+ {
+ UInt64 volSize = volSizes[i];
+ if (volSize >= size)
+ return i + 1;
+ size -= volSize;
+ }
+ UInt64 volSize = volSizes.Back();
+ if (volSize == 0)
+ return (UInt64)(Int64)-1;
+ return volSizes.Size() + (size - 1) / volSize + 1;
+}
diff --git a/CPP/7zip/UI/FileManager/SplitUtils.h b/CPP/7zip/UI/FileManager/SplitUtils.h
new file mode 100644
index 0000000..d1d44e4
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SplitUtils.h
@@ -0,0 +1,15 @@
+// SplitUtils.h
+
+#ifndef ZIP7_INC_SPLIT_UTILS_H
+#define ZIP7_INC_SPLIT_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+
+bool ParseVolumeSizes(const UString &s, CRecordVector<UInt64> &values);
+void AddVolumeItems(NWindows::NControl::CComboBox &volumeCombo);
+UInt64 GetNumberOfVolumes(UInt64 size, const CRecordVector<UInt64> &volSizes);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/StdAfx.cpp b/CPP/7zip/UI/FileManager/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/FileManager/StdAfx.h b/CPP/7zip/UI/FileManager/StdAfx.h
new file mode 100644
index 0000000..789cc6e
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StdAfx.h
@@ -0,0 +1,83 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../../../../C/Compiler.h"
+
+Z7_DIAGNOSCTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER
+#ifndef _WIN32_WINNT
+// #define _WIN32_WINNT 0x0400
+#define _WIN32_WINNT 0x0500
+// #define _WIN32_WINNT 0x0600
+// #define _WIN32_WINNT 0x0A00
+#endif
+#ifndef WINVER
+#define WINVER _WIN32_WINNT
+#endif
+// #define _WIN32_IE 0x400 // for debug
+Z7_DIAGNOSCTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER
+
+#include "../../../Common/Common.h"
+#include "../../../Common/MyWindows.h"
+
+#endif
+
+/*
+WINVER and _WIN32_WINNT
+
+MSVC6 / 2003sdk:
+{
+ <windows.h> doesn't set _WIN32_WINNT
+ if WINVER is not set <windows.h> sets WINVER to value:
+ 0x0400 : MSVC6
+ 0x0501 : Windows Server 2003 PSDK / 2003 R2 PSDK
+}
+
+SDK for Win7 (and later)
+{
+ <windows.h> sets _WIN32_WINNT if it's not set.
+ <windows.h> sets WINVER if it's not set.
+<windows.h> includes <sdkddkver.h> that does:
+#if !defined(_WIN32_WINNT) && !defined(_CHICAGO_)
+ #define _WIN32_WINNT 0x0601 // in win7 sdk
+ #define _WIN32_WINNT 0x0A00 // in win10 sdk
+#endif
+#ifndef WINVER
+ #ifdef _WIN32_WINNT
+ #define WINVER _WIN32_WINNT
+ else
+ #define WINVER 0x0601 // in win7 sdk
+ #define WINVER 0x0A00 // in win10 sdk
+ endif
+#endif
+}
+
+Some GUI structures defined by windows will be larger,
+If (_WIN32_WINNT) value is larger.
+
+Also if we send sizeof(win_gui_struct) to some windows function,
+and we compile that code with big (_WIN32_WINNT) value,
+the window function in old Windows can fail, if that old Windows
+doesn't understand new big version of (win_gui_struct) compiled
+with big (_WIN32_WINNT) value.
+
+So it's better to define smallest (_WIN32_WINNT) value here.
+In 7-Zip FM we use some functions that require (_WIN32_WINNT == 0x0500).
+So it's simpler to define (_WIN32_WINNT == 0x0500) here.
+If we define (_WIN32_WINNT == 0x0400) here, we need some manual
+declarations for functions and macros that require (0x0500) functions.
+Also libs must contain these (0x0500+) functions.
+
+Some code in 7-zip FM uses also CommCtrl.h structures
+that depend from (_WIN32_IE) value. But default
+(_WIN32_IE) value from <windows.h> probably is OK for us.
+So we don't set _WIN32_IE here.
+default _WIN32_IE value set by <windows.h>:
+ 0x501 2003sdk
+ 0xa00 win10 sdk
+*/
diff --git a/CPP/7zip/UI/FileManager/StringUtils.cpp b/CPP/7zip/UI/FileManager/StringUtils.cpp
new file mode 100644
index 0000000..4641d15
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StringUtils.cpp
@@ -0,0 +1,39 @@
+// StringUtils.cpp
+
+#include "StdAfx.h"
+
+#include "StringUtils.h"
+
+void SplitStringToTwoStrings(const UString &src, UString &dest1, UString &dest2)
+{
+ dest1.Empty();
+ dest2.Empty();
+ bool quoteMode = false;
+ for (unsigned i = 0; i < src.Len(); i++)
+ {
+ const wchar_t c = src[i];
+ if (c == '\"')
+ quoteMode = !quoteMode;
+ else if (c == ' ' && !quoteMode)
+ {
+ dest2 = src.Ptr(i + 1);
+ return;
+ }
+ else
+ dest1 += c;
+ }
+}
+
+/*
+UString JoinStrings(const UStringVector &srcStrings)
+{
+ UString s;
+ FOR_VECTOR (i, srcStrings)
+ {
+ if (i != 0)
+ s.Add_Space();
+ s += srcStrings[i];
+ }
+ return s;
+}
+*/
diff --git a/CPP/7zip/UI/FileManager/StringUtils.h b/CPP/7zip/UI/FileManager/StringUtils.h
new file mode 100644
index 0000000..37aad3a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/StringUtils.h
@@ -0,0 +1,11 @@
+// StringUtils.h
+
+#ifndef ZIP7_INC_STRING_UTILS_H
+#define ZIP7_INC_STRING_UTILS_H
+
+#include "../../../Common/MyString.h"
+
+void SplitStringToTwoStrings(const UString &src, UString &dest1, UString &dest2);
+// UString JoinStrings(const UStringVector &srcStrings);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SysIconUtils.cpp b/CPP/7zip/UI/FileManager/SysIconUtils.cpp
index 2100e82..1c7cab0 100644
--- a/CPP/7zip/UI/FileManager/SysIconUtils.cpp
+++ b/CPP/7zip/UI/FileManager/SysIconUtils.cpp
@@ -1,255 +1,278 @@
-// SysIconUtils.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../../../Common/StringConvert.h"
-#endif
-
-#include "../../../Windows/FileDir.h"
-
-#include "SysIconUtils.h"
-
-#include <ShlObj.h>
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-int GetIconIndexForCSIDL(int csidl)
-{
- LPITEMIDLIST pidl = 0;
- SHGetSpecialFolderLocation(NULL, csidl, &pidl);
- if (pidl)
- {
- SHFILEINFO shellInfo;
- SHGetFileInfo(LPCTSTR(pidl), FILE_ATTRIBUTE_NORMAL,
- &shellInfo, sizeof(shellInfo),
- SHGFI_PIDL | SHGFI_SYSICONINDEX);
- IMalloc *pMalloc;
- SHGetMalloc(&pMalloc);
- if (pMalloc)
- {
- pMalloc->Free(pidl);
- pMalloc->Release();
- }
- return shellInfo.iIcon;
- }
- return 0;
-}
-
-#ifndef _UNICODE
-typedef int (WINAPI * SHGetFileInfoWP)(LPCWSTR pszPath, DWORD attrib, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags);
-
-struct CSHGetFileInfoInit
-{
- SHGetFileInfoWP shGetFileInfoW;
- CSHGetFileInfoInit()
- {
- shGetFileInfoW = (SHGetFileInfoWP)
- ::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHGetFileInfoW");
- }
-} g_SHGetFileInfoInit;
-#endif
-
-static DWORD_PTR MySHGetFileInfoW(LPCWSTR pszPath, DWORD attrib, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags)
-{
- #ifdef _UNICODE
- return SHGetFileInfo
- #else
- if (g_SHGetFileInfoInit.shGetFileInfoW == 0)
- return 0;
- return g_SHGetFileInfoInit.shGetFileInfoW
- #endif
- (pszPath, attrib, psfi, cbFileInfo, uFlags);
-}
-
-DWORD_PTR GetRealIconIndex(CFSTR path, DWORD attrib, int &iconIndex)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- SHFILEINFO shellInfo;
- DWORD_PTR res = ::SHGetFileInfo(fs2fas(path), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
- sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX);
- iconIndex = shellInfo.iIcon;
- return res;
- }
- else
- #endif
- {
- SHFILEINFOW shellInfo;
- DWORD_PTR res = ::MySHGetFileInfoW(fs2us(path), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
- sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX);
- iconIndex = shellInfo.iIcon;
- return res;
- }
-}
-
-/*
-DWORD_PTR GetRealIconIndex(const UString &fileName, DWORD attrib, int &iconIndex, UString *typeName)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- SHFILEINFO shellInfo;
- shellInfo.szTypeName[0] = 0;
- DWORD_PTR res = ::SHGetFileInfoA(GetSystemString(fileName), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
- sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
- if (typeName)
- *typeName = GetUnicodeString(shellInfo.szTypeName);
- iconIndex = shellInfo.iIcon;
- return res;
- }
- else
- #endif
- {
- SHFILEINFOW shellInfo;
- shellInfo.szTypeName[0] = 0;
- DWORD_PTR res = ::MySHGetFileInfoW(fileName, FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
- sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
- if (typeName)
- *typeName = shellInfo.szTypeName;
- iconIndex = shellInfo.iIcon;
- return res;
- }
-}
-*/
-
-static int FindInSorted_Attrib(const CRecordVector<CAttribIconPair> &vect, DWORD attrib, int &insertPos)
-{
- unsigned left = 0, right = vect.Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- DWORD midAttrib = vect[mid].Attrib;
- if (attrib == midAttrib)
- return mid;
- if (attrib < midAttrib)
- right = mid;
- else
- left = mid + 1;
- }
- insertPos = left;
- return -1;
-}
-
-static int FindInSorted_Ext(const CObjectVector<CExtIconPair> &vect, const wchar_t *ext, int &insertPos)
-{
- unsigned left = 0, right = vect.Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- int compare = MyStringCompareNoCase(ext, vect[mid].Ext);
- if (compare == 0)
- return mid;
- if (compare < 0)
- right = mid;
- else
- left = mid + 1;
- }
- insertPos = left;
- return -1;
-}
-
-int CExtToIconMap::GetIconIndex(DWORD attrib, const wchar_t *fileName /*, UString *typeName */)
-{
- int dotPos = -1;
- unsigned i;
- for (i = 0;; i++)
- {
- wchar_t c = fileName[i];
- if (c == 0)
- break;
- if (c == '.')
- dotPos = i;
- }
-
- /*
- if (MyStringCompareNoCase(fileName, L"$Recycle.Bin") == 0)
- {
- char s[256];
- sprintf(s, "SPEC i = %3d, attr = %7x", _attribMap.Size(), attrib);
- OutputDebugStringA(s);
- OutputDebugStringW(fileName);
- }
- */
-
- if ((attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 || dotPos < 0)
- {
- int insertPos = 0;
- int index = FindInSorted_Attrib(_attribMap, attrib, insertPos);
- if (index >= 0)
- {
- // if (typeName) *typeName = _attribMap[index].TypeName;
- return _attribMap[index].IconIndex;
- }
- CAttribIconPair pair;
- GetRealIconIndex(
- #ifdef UNDER_CE
- FTEXT("\\")
- #endif
- FTEXT("__DIR__")
- , attrib, pair.IconIndex
- // , pair.TypeName
- );
-
- /*
- char s[256];
- sprintf(s, "i = %3d, attr = %7x", _attribMap.Size(), attrib);
- OutputDebugStringA(s);
- */
-
- pair.Attrib = attrib;
- _attribMap.Insert(insertPos, pair);
- // if (typeName) *typeName = pair.TypeName;
- return pair.IconIndex;
- }
-
- const wchar_t *ext = fileName + dotPos + 1;
- int insertPos = 0;
- int index = FindInSorted_Ext(_extMap, ext, insertPos);
- if (index >= 0)
- {
- const CExtIconPair &pa = _extMap[index];
- // if (typeName) *typeName = pa.TypeName;
- return pa.IconIndex;
- }
-
- for (i = 0;; i++)
- {
- wchar_t c = ext[i];
- if (c == 0)
- break;
- if (c < L'0' || c > L'9')
- break;
- }
- if (i != 0 && ext[i] == 0)
- {
- // GetRealIconIndex is too slow for big number of split extensions: .001, .002, .003
- if (!SplitIconIndex_Defined)
- {
- GetRealIconIndex(
- #ifdef UNDER_CE
- FTEXT("\\")
- #endif
- FTEXT("__FILE__.001"), 0, SplitIconIndex);
- SplitIconIndex_Defined = true;
- }
- return SplitIconIndex;
- }
-
- CExtIconPair pair;
- pair.Ext = ext;
- GetRealIconIndex(us2fs(fileName + dotPos), attrib, pair.IconIndex);
- _extMap.Insert(insertPos, pair);
- // if (typeName) *typeName = pair.TypeName;
- return pair.IconIndex;
-}
-
-/*
-int CExtToIconMap::GetIconIndex(DWORD attrib, const UString &fileName)
-{
- return GetIconIndex(attrib, fileName, NULL);
-}
-*/
+// SysIconUtils.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../../../Common/StringConvert.h"
+#endif
+
+#include "../../../Windows/FileDir.h"
+
+#include "SysIconUtils.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+int GetIconIndexForCSIDL(int csidl)
+{
+ LPITEMIDLIST pidl = NULL;
+ SHGetSpecialFolderLocation(NULL, csidl, &pidl);
+ if (pidl)
+ {
+ SHFILEINFO shellInfo;
+ shellInfo.iIcon = 0;
+ const DWORD_PTR res = SHGetFileInfo((LPCTSTR)(const void *)(pidl), FILE_ATTRIBUTE_NORMAL,
+ &shellInfo, sizeof(shellInfo),
+ SHGFI_PIDL | SHGFI_SYSICONINDEX);
+ /*
+ IMalloc *pMalloc;
+ SHGetMalloc(&pMalloc);
+ if (pMalloc)
+ {
+ pMalloc->Free(pidl);
+ pMalloc->Release();
+ }
+ */
+ // we use OLE2.dll function here
+ CoTaskMemFree(pidl);
+ if (res)
+ return shellInfo.iIcon;
+ }
+ return 0;
+}
+
+#ifndef _UNICODE
+typedef DWORD_PTR (WINAPI * Func_SHGetFileInfoW)(LPCWSTR pszPath, DWORD attrib, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags);
+
+static struct C_SHGetFileInfo_Init
+{
+ Func_SHGetFileInfoW f_SHGetFileInfoW;
+ C_SHGetFileInfo_Init()
+ {
+ f_SHGetFileInfoW = Z7_GET_PROC_ADDRESS(
+ Func_SHGetFileInfoW, ::GetModuleHandleW(L"shell32.dll"),
+ "SHGetFileInfoW");
+ }
+} g_SHGetFileInfo_Init;
+#endif
+
+static DWORD_PTR My_SHGetFileInfoW(LPCWSTR pszPath, DWORD attrib, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags)
+{
+ #ifdef _UNICODE
+ return SHGetFileInfo
+ #else
+ if (!g_SHGetFileInfo_Init.f_SHGetFileInfoW)
+ return 0;
+ return g_SHGetFileInfo_Init.f_SHGetFileInfoW
+ #endif
+ (pszPath, attrib, psfi, cbFileInfo, uFlags);
+}
+
+DWORD_PTR GetRealIconIndex(CFSTR path, DWORD attrib, int &iconIndex)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ SHFILEINFO shellInfo;
+ const DWORD_PTR res = ::SHGetFileInfo(fs2fas(path), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+ sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX);
+ iconIndex = shellInfo.iIcon;
+ return res;
+ }
+ else
+ #endif
+ {
+ SHFILEINFOW shellInfo;
+ const DWORD_PTR res = ::My_SHGetFileInfoW(fs2us(path), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+ sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX);
+ iconIndex = shellInfo.iIcon;
+ return res;
+ }
+}
+
+/*
+DWORD_PTR GetRealIconIndex(const UString &fileName, DWORD attrib, int &iconIndex, UString *typeName)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ SHFILEINFO shellInfo;
+ shellInfo.szTypeName[0] = 0;
+ DWORD_PTR res = ::SHGetFileInfoA(GetSystemString(fileName), FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+ sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
+ if (typeName)
+ *typeName = GetUnicodeString(shellInfo.szTypeName);
+ iconIndex = shellInfo.iIcon;
+ return res;
+ }
+ else
+ #endif
+ {
+ SHFILEINFOW shellInfo;
+ shellInfo.szTypeName[0] = 0;
+ DWORD_PTR res = ::My_SHGetFileInfoW(fileName, FILE_ATTRIBUTE_NORMAL | attrib, &shellInfo,
+ sizeof(shellInfo), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_TYPENAME);
+ if (typeName)
+ *typeName = shellInfo.szTypeName;
+ iconIndex = shellInfo.iIcon;
+ return res;
+ }
+}
+*/
+
+static int FindInSorted_Attrib(const CRecordVector<CAttribIconPair> &vect, DWORD attrib, unsigned &insertPos)
+{
+ unsigned left = 0, right = vect.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const DWORD midAttrib = vect[mid].Attrib;
+ if (attrib == midAttrib)
+ return (int)mid;
+ if (attrib < midAttrib)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ insertPos = left;
+ return -1;
+}
+
+static int FindInSorted_Ext(const CObjectVector<CExtIconPair> &vect, const wchar_t *ext, unsigned &insertPos)
+{
+ unsigned left = 0, right = vect.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const int compare = MyStringCompareNoCase(ext, vect[mid].Ext);
+ if (compare == 0)
+ return (int)mid;
+ if (compare < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ insertPos = left;
+ return -1;
+}
+
+int CExtToIconMap::GetIconIndex(DWORD attrib, const wchar_t *fileName /*, UString *typeName */)
+{
+ int dotPos = -1;
+ unsigned i;
+ for (i = 0;; i++)
+ {
+ const wchar_t c = fileName[i];
+ if (c == 0)
+ break;
+ if (c == '.')
+ dotPos = (int)i;
+ }
+
+ /*
+ if (MyStringCompareNoCase(fileName, L"$Recycle.Bin") == 0)
+ {
+ char s[256];
+ sprintf(s, "SPEC i = %3d, attr = %7x", _attribMap.Size(), attrib);
+ OutputDebugStringA(s);
+ OutputDebugStringW(fileName);
+ }
+ */
+
+ if ((attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 || dotPos < 0)
+ {
+ unsigned insertPos = 0;
+ const int index = FindInSorted_Attrib(_attribMap, attrib, insertPos);
+ if (index >= 0)
+ {
+ // if (typeName) *typeName = _attribMap[index].TypeName;
+ return _attribMap[(unsigned)index].IconIndex;
+ }
+ CAttribIconPair pair;
+ GetRealIconIndex(
+ #ifdef UNDER_CE
+ FTEXT("\\")
+ #endif
+ FTEXT("__DIR__")
+ , attrib, pair.IconIndex
+ // , pair.TypeName
+ );
+
+ /*
+ char s[256];
+ sprintf(s, "i = %3d, attr = %7x", _attribMap.Size(), attrib);
+ OutputDebugStringA(s);
+ */
+
+ pair.Attrib = attrib;
+ _attribMap.Insert(insertPos, pair);
+ // if (typeName) *typeName = pair.TypeName;
+ return pair.IconIndex;
+ }
+
+ const wchar_t *ext = fileName + dotPos + 1;
+ unsigned insertPos = 0;
+ const int index = FindInSorted_Ext(_extMap, ext, insertPos);
+ if (index >= 0)
+ {
+ const CExtIconPair &pa = _extMap[index];
+ // if (typeName) *typeName = pa.TypeName;
+ return pa.IconIndex;
+ }
+
+ for (i = 0;; i++)
+ {
+ const wchar_t c = ext[i];
+ if (c == 0)
+ break;
+ if (c < L'0' || c > L'9')
+ break;
+ }
+ if (i != 0 && ext[i] == 0)
+ {
+ // GetRealIconIndex is too slow for big number of split extensions: .001, .002, .003
+ if (!SplitIconIndex_Defined)
+ {
+ GetRealIconIndex(
+ #ifdef UNDER_CE
+ FTEXT("\\")
+ #endif
+ FTEXT("__FILE__.001"), 0, SplitIconIndex);
+ SplitIconIndex_Defined = true;
+ }
+ return SplitIconIndex;
+ }
+
+ CExtIconPair pair;
+ pair.Ext = ext;
+ GetRealIconIndex(us2fs(fileName + dotPos), attrib, pair.IconIndex);
+ _extMap.Insert(insertPos, pair);
+ // if (typeName) *typeName = pair.TypeName;
+ return pair.IconIndex;
+}
+
+/*
+int CExtToIconMap::GetIconIndex(DWORD attrib, const UString &fileName)
+{
+ return GetIconIndex(attrib, fileName, NULL);
+}
+*/
+
+HIMAGELIST GetSysImageList(bool smallIcons)
+{
+ SHFILEINFO shellInfo;
+ return (HIMAGELIST)SHGetFileInfo(TEXT(""),
+ FILE_ATTRIBUTE_NORMAL |
+ FILE_ATTRIBUTE_DIRECTORY,
+ &shellInfo, sizeof(shellInfo),
+ SHGFI_USEFILEATTRIBUTES |
+ SHGFI_SYSICONINDEX |
+ (smallIcons ? SHGFI_SMALLICON : SHGFI_ICON));
+}
diff --git a/CPP/7zip/UI/FileManager/SysIconUtils.h b/CPP/7zip/UI/FileManager/SysIconUtils.h
index 2eedc4b..1d34ef6 100644
--- a/CPP/7zip/UI/FileManager/SysIconUtils.h
+++ b/CPP/7zip/UI/FileManager/SysIconUtils.h
@@ -1,62 +1,55 @@
-// SysIconUtils.h
-
-#ifndef __SYS_ICON_UTILS_H
-#define __SYS_ICON_UTILS_H
-
-#include "../../../Common/MyWindows.h"
-
-#include <commctrl.h>
-
-#include "../../../Common/MyString.h"
-
-struct CExtIconPair
-{
- UString Ext;
- int IconIndex;
- // UString TypeName;
-
- // int Compare(const CExtIconPair &a) const { return MyStringCompareNoCase(Ext, a.Ext); }
-};
-
-struct CAttribIconPair
-{
- DWORD Attrib;
- int IconIndex;
- // UString TypeName;
-
- // int Compare(const CAttribIconPair &a) const { return Ext.Compare(a.Ext); }
-};
-
-class CExtToIconMap
-{
-public:
- CRecordVector<CAttribIconPair> _attribMap;
- CObjectVector<CExtIconPair> _extMap;
- int SplitIconIndex;
- int SplitIconIndex_Defined;
-
- CExtToIconMap(): SplitIconIndex_Defined(false) {}
-
- void Clear()
- {
- SplitIconIndex_Defined = false;
- _extMap.Clear();
- _attribMap.Clear();
- }
- int GetIconIndex(DWORD attrib, const wchar_t *fileName /* , UString *typeName */);
- // int GetIconIndex(DWORD attrib, const UString &fileName);
-};
-
-DWORD_PTR GetRealIconIndex(CFSTR path, DWORD attrib, int &iconIndex);
-int GetIconIndexForCSIDL(int csidl);
-
-inline HIMAGELIST GetSysImageList(bool smallIcons)
-{
- SHFILEINFO shellInfo;
- return (HIMAGELIST)SHGetFileInfo(TEXT(""),
- FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_DIRECTORY,
- &shellInfo, sizeof(shellInfo),
- SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | (smallIcons ? SHGFI_SMALLICON : SHGFI_ICON));
-}
-
-#endif
+// SysIconUtils.h
+
+#ifndef ZIP7_INC_SYS_ICON_UTILS_H
+#define ZIP7_INC_SYS_ICON_UTILS_H
+
+#include "../../../Common/MyWindows.h"
+
+#include <CommCtrl.h>
+
+#include "../../../Common/MyString.h"
+
+struct CExtIconPair
+{
+ UString Ext;
+ int IconIndex;
+ // UString TypeName;
+
+ // int Compare(const CExtIconPair &a) const { return MyStringCompareNoCase(Ext, a.Ext); }
+};
+
+struct CAttribIconPair
+{
+ DWORD Attrib;
+ int IconIndex;
+ // UString TypeName;
+
+ // int Compare(const CAttribIconPair &a) const { return Ext.Compare(a.Ext); }
+};
+
+class CExtToIconMap
+{
+public:
+ CRecordVector<CAttribIconPair> _attribMap;
+ CObjectVector<CExtIconPair> _extMap;
+ int SplitIconIndex;
+ int SplitIconIndex_Defined;
+
+ CExtToIconMap(): SplitIconIndex_Defined(false) {}
+
+ void Clear()
+ {
+ SplitIconIndex_Defined = false;
+ _extMap.Clear();
+ _attribMap.Clear();
+ }
+ int GetIconIndex(DWORD attrib, const wchar_t *fileName /* , UString *typeName */);
+ // int GetIconIndex(DWORD attrib, const UString &fileName);
+};
+
+DWORD_PTR GetRealIconIndex(CFSTR path, DWORD attrib, int &iconIndex);
+int GetIconIndexForCSIDL(int csidl);
+
+HIMAGELIST GetSysImageList(bool smallIcons);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SystemPage.cpp b/CPP/7zip/UI/FileManager/SystemPage.cpp
new file mode 100644
index 0000000..09d8a72
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPage.cpp
@@ -0,0 +1,472 @@
+// SystemPage.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/MyWindows.h"
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/ErrorMsg.h"
+
+#include "HelpUtils.h"
+#include "IFolder.h"
+#include "LangUtils.h"
+#include "PropertyNameRes.h"
+#include "SystemPage.h"
+#include "SystemPageRes.h"
+
+using namespace NWindows;
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_SYSTEM_ASSOCIATE
+};
+#endif
+
+#define kSystemTopic "FM/options.htm#system"
+
+CSysString CModifiedExtInfo::GetString() const
+{
+ const char *s;
+ if (State == kExtState_7Zip)
+ s = "7-Zip";
+ else if (State == kExtState_Clear)
+ s = "";
+ else if (Other7Zip)
+ s = "[7-Zip]";
+ else
+ return ProgramKey;
+ return CSysString (s);
+}
+
+
+int CSystemPage::AddIcon(const UString &iconPath, int iconIndex)
+{
+ if (iconPath.IsEmpty())
+ return -1;
+ if (iconIndex == -1)
+ iconIndex = 0;
+
+ HICON hicon;
+
+ #ifdef UNDER_CE
+ ExtractIconExW(iconPath, iconIndex, NULL, &hicon, 1);
+ if (!hicon)
+ #else
+ // we expand path from REG_EXPAND_SZ registry item.
+ UString path;
+ const DWORD size = MAX_PATH + 10;
+ const DWORD needLen = ::ExpandEnvironmentStringsW(iconPath, path.GetBuf(size + 2), size);
+ path.ReleaseBuf_CalcLen(size);
+ if (needLen == 0 || needLen >= size)
+ path = iconPath;
+ const UINT num = ExtractIconExW(path, iconIndex, NULL, &hicon, 1);
+ if (num != 1 || !hicon)
+ #endif
+ return -1;
+
+ _imageList.AddIcon(hicon);
+ DestroyIcon(hicon);
+ return (int)(_numIcons++);
+}
+
+
+void CSystemPage::RefreshListItem(unsigned group, unsigned listIndex)
+{
+ const CAssoc &assoc = _items[GetRealIndex(listIndex)];
+ _listView.SetSubItem(listIndex, group + 1, assoc.Pair[group].GetString());
+ LVITEMW newItem;
+ memset(&newItem, 0, sizeof(newItem));
+ newItem.iItem = (int)listIndex;
+ newItem.mask = LVIF_IMAGE;
+ newItem.iImage = assoc.GetIconIndex();
+ _listView.SetItem(&newItem);
+}
+
+
+void CSystemPage::ChangeState(unsigned group, const CUIntVector &indices)
+{
+ if (indices.IsEmpty())
+ return;
+
+ bool thereAreClearItems = false;
+ unsigned counters[3] = { 0, 0, 0 };
+
+ unsigned i;
+ for (i = 0; i < indices.Size(); i++)
+ {
+ const CModifiedExtInfo &mi = _items[GetRealIndex(indices[i])].Pair[group];
+ int state = kExtState_7Zip;
+ if (mi.State == kExtState_7Zip)
+ state = kExtState_Clear;
+ else if (mi.State == kExtState_Clear)
+ {
+ thereAreClearItems = true;
+ if (mi.Other)
+ state = kExtState_Other;
+ }
+ counters[state]++;
+ }
+
+ int state = kExtState_Clear;
+ if (counters[kExtState_Other] != 0)
+ state = kExtState_Other;
+ else if (counters[kExtState_7Zip] != 0)
+ state = kExtState_7Zip;
+
+ for (i = 0; i < indices.Size(); i++)
+ {
+ unsigned listIndex = indices[i];
+ CAssoc &assoc = _items[GetRealIndex(listIndex)];
+ CModifiedExtInfo &mi = assoc.Pair[group];
+ bool change = false;
+
+ switch (state)
+ {
+ case kExtState_Clear: change = true; break;
+ case kExtState_Other: change = mi.Other; break;
+ default: change = !(mi.Other && thereAreClearItems); break;
+ }
+
+ if (change)
+ {
+ mi.State = state;
+ RefreshListItem(group, listIndex);
+ }
+ }
+
+ _needSave = true;
+ Changed();
+}
+
+
+bool CSystemPage::OnInit()
+{
+ _needSave = false;
+
+#ifdef Z7_LANG
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+#endif
+
+ _listView.Attach(GetItem(IDL_SYSTEM_ASSOCIATE));
+ _listView.SetUnicodeFormat();
+ DWORD newFlags = LVS_EX_FULLROWSELECT;
+ _listView.SetExtendedListViewStyle(newFlags, newFlags);
+
+ _numIcons = 0;
+ _imageList.Create(16, 16, ILC_MASK | ILC_COLOR32, 0, 0);
+
+ _listView.SetImageList(_imageList, LVSIL_SMALL);
+
+ _listView.InsertColumn(0, LangString(IDS_PROP_FILE_TYPE), 72);
+
+ UString s;
+
+ #if NUM_EXT_GROUPS == 1
+ s = "Program";
+ #else
+ #ifndef UNDER_CE
+ const unsigned kSize = 256;
+ BOOL res;
+
+ DWORD size = kSize;
+
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ AString s2;
+ res = GetUserNameA(s2.GetBuf(size), &size);
+ s2.ReleaseBuf_CalcLen(MyMin((unsigned)size, kSize));
+ s = GetUnicodeString(s2);
+ }
+ else
+ #endif
+ {
+ res = GetUserNameW(s.GetBuf(size), &size);
+ s.ReleaseBuf_CalcLen(MyMin((unsigned)size, kSize));
+ }
+
+ if (!res)
+ #endif
+ s = "Current User";
+ #endif
+
+ LV_COLUMNW ci;
+ ci.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH | LVCF_SUBITEM;
+ ci.cx = 128;
+ ci.fmt = LVCFMT_CENTER;
+ ci.pszText = s.Ptr_non_const();
+ ci.iSubItem = 1;
+ _listView.InsertColumn(1, &ci);
+
+ #if NUM_EXT_GROUPS > 1
+ {
+ LangString(IDS_SYSTEM_ALL_USERS, s);
+ ci.pszText = s.Ptr_non_const();
+ ci.iSubItem = 2;
+ _listView.InsertColumn(2, &ci);
+ }
+ #endif
+
+ _extDB.Read();
+ _items.Clear();
+
+ FOR_VECTOR (i, _extDB.Exts)
+ {
+ const CExtPlugins &extInfo = _extDB.Exts[i];
+
+ LVITEMW item;
+ item.iItem = (int)i;
+ item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
+ item.lParam = (LPARAM)i;
+ item.iSubItem = 0;
+ // ListView always uses internal iImage that is 0 by default?
+ // so we always use LVIF_IMAGE.
+ item.iImage = -1;
+ item.pszText = extInfo.Ext.Ptr_non_const();
+
+ CAssoc assoc;
+ const CPluginToIcon &plug = extInfo.Plugins[0];
+ assoc.SevenZipImageIndex = AddIcon(plug.IconPath, plug.IconIndex);
+
+ CSysString texts[NUM_EXT_GROUPS];
+ unsigned g;
+ for (g = 0; g < NUM_EXT_GROUPS; g++)
+ {
+ CModifiedExtInfo &mi = assoc.Pair[g];
+ mi.ReadFromRegistry(GetHKey(g), GetSystemString(extInfo.Ext));
+ mi.SetState(plug.IconPath);
+ mi.ImageIndex = AddIcon(mi.IconPath, mi.IconIndex);
+ texts[g] = mi.GetString();
+ }
+ item.iImage = assoc.GetIconIndex();
+ const int itemIndex = _listView.InsertItem(&item);
+ for (g = 0; g < NUM_EXT_GROUPS; g++)
+ _listView.SetSubItem((unsigned)itemIndex, 1 + g, texts[g]);
+ _items.Add(assoc);
+ }
+
+ if (_listView.GetItemCount() > 0)
+ _listView.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);
+
+ return CPropertyPage::OnInit();
+}
+
+
+static UString GetProgramCommand()
+{
+ UString s ('\"');
+ s += fs2us(NDLL::GetModuleDirPrefix());
+ s += "7zFM.exe\" \"%1\"";
+ return s;
+}
+
+
+LONG CSystemPage::OnApply()
+{
+ if (!_needSave)
+ return PSNRET_NOERROR;
+
+ const UString command = GetProgramCommand();
+
+ LONG res = 0;
+
+ FOR_VECTOR (listIndex, _extDB.Exts)
+ {
+ unsigned realIndex = GetRealIndex(listIndex);
+ const CExtPlugins &extInfo = _extDB.Exts[realIndex];
+ CAssoc &assoc = _items[realIndex];
+
+ for (unsigned g = 0; g < NUM_EXT_GROUPS; g++)
+ {
+ CModifiedExtInfo &mi = assoc.Pair[g];
+ HKEY key = GetHKey(g);
+
+ if (mi.OldState != mi.State)
+ {
+ LONG res2 = 0;
+
+ if (mi.State == kExtState_7Zip)
+ {
+ UString title = extInfo.Ext;
+ title += " Archive";
+ const CPluginToIcon &plug = extInfo.Plugins[0];
+ res2 = NRegistryAssoc::AddShellExtensionInfo(key, GetSystemString(extInfo.Ext),
+ title, command, plug.IconPath, plug.IconIndex);
+ }
+ else if (mi.State == kExtState_Clear)
+ res2 = NRegistryAssoc::DeleteShellExtensionInfo(key, GetSystemString(extInfo.Ext));
+
+ if (res == 0)
+ res = res2;
+ if (res2 == 0)
+ mi.OldState = mi.State;
+
+ mi.State = mi.OldState;
+ RefreshListItem(g, listIndex);
+ }
+ }
+ }
+
+ #ifndef UNDER_CE
+ SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
+ #endif
+
+ WasChanged = true;
+
+ _needSave = false;
+
+ if (res != 0)
+ MessageBoxW(*this, NError::MyFormatMessage(res), L"7-Zip", MB_ICONERROR);
+
+ return PSNRET_NOERROR;
+}
+
+
+void CSystemPage::OnNotifyHelp()
+{
+ ShowHelpWindow(kSystemTopic);
+}
+
+
+bool CSystemPage::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ /*
+ case IDC_SYSTEM_SELECT_ALL:
+ _listView.SelectAll();
+ return true;
+ */
+ case IDB_SYSTEM_CURRENT:
+ case IDB_SYSTEM_ALL:
+ ChangeState(buttonID == IDB_SYSTEM_CURRENT ? 0 : 1);
+ return true;
+ }
+ return CPropertyPage::OnButtonClicked(buttonID, buttonHWND);
+}
+
+
+bool CSystemPage::OnNotify(UINT controlID, LPNMHDR lParam)
+{
+ if (lParam->hwndFrom == HWND(_listView))
+ {
+ switch (lParam->code)
+ {
+ case NM_RETURN:
+ {
+ ChangeState(0);
+ return true;
+ }
+
+ case NM_CLICK:
+ {
+ #ifdef UNDER_CE
+ NMLISTVIEW *item = (NMLISTVIEW *)lParam;
+ #else
+ NMITEMACTIVATE *item = (NMITEMACTIVATE *)lParam;
+ if (item->uKeyFlags == 0)
+ #endif
+ {
+ if (item->iItem >= 0)
+ {
+ // unsigned realIndex = GetRealIndex(item->iItem);
+ if (item->iSubItem >= 1 && item->iSubItem <= 2)
+ {
+ CUIntVector indices;
+ indices.Add((unsigned)item->iItem);
+ ChangeState(item->iSubItem < 2 ? 0 : 1, indices);
+ }
+ }
+ }
+ break;
+ }
+
+ case LVN_KEYDOWN:
+ {
+ if (OnListKeyDown(LPNMLVKEYDOWN(lParam)))
+ return true;
+ break;
+ }
+
+ /*
+ case NM_RCLICK:
+ case NM_DBLCLK:
+ case LVN_BEGINRDRAG:
+ // PostMessage(kRefreshpluginsListMessage, 0);
+ PostMessage(kUpdateDatabase, 0);
+ break;
+ */
+ }
+ }
+ return CPropertyPage::OnNotify(controlID, lParam);
+}
+
+
+void CSystemPage::ChangeState(unsigned group)
+{
+ CUIntVector indices;
+
+ int itemIndex = -1;
+ while ((itemIndex = _listView.GetNextSelectedItem(itemIndex)) != -1)
+ indices.Add((unsigned)itemIndex);
+
+ if (indices.IsEmpty())
+ FOR_VECTOR (i, _items)
+ indices.Add(i);
+
+ ChangeState(group, indices);
+}
+
+
+bool CSystemPage::OnListKeyDown(LPNMLVKEYDOWN keyDownInfo)
+{
+ bool ctrl = IsKeyDown(VK_CONTROL);
+ bool alt = IsKeyDown(VK_MENU);
+
+ if (alt)
+ return false;
+
+ if ((ctrl && keyDownInfo->wVKey == 'A')
+ || (!ctrl && keyDownInfo->wVKey == VK_MULTIPLY))
+ {
+ _listView.SelectAll();
+ return true;
+ }
+
+ switch (keyDownInfo->wVKey)
+ {
+ case VK_SPACE:
+ case VK_ADD:
+ case VK_SUBTRACT:
+ case VK_SEPARATOR:
+ case VK_DIVIDE:
+
+ #ifndef UNDER_CE
+ case VK_OEM_PLUS:
+ case VK_OEM_MINUS:
+ #endif
+
+ if (!ctrl)
+ {
+ ChangeState(keyDownInfo->wVKey == VK_SPACE ? 0 : 1);
+ return true;
+ }
+ break;
+ }
+
+ return false;
+}
diff --git a/CPP/7zip/UI/FileManager/SystemPage.h b/CPP/7zip/UI/FileManager/SystemPage.h
new file mode 100644
index 0000000..6f2ed0c
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPage.h
@@ -0,0 +1,126 @@
+// SystemPage.h
+
+#ifndef ZIP7_INC_SYSTEM_PAGE_H
+#define ZIP7_INC_SYSTEM_PAGE_H
+
+#include "../../../Windows/Control/ImageList.h"
+#include "../../../Windows/Control/ListView.h"
+#include "../../../Windows/Control/PropertyPage.h"
+
+#include "FilePlugins.h"
+#include "RegistryAssociations.h"
+
+enum EExtState
+{
+ kExtState_Clear = 0,
+ kExtState_Other,
+ kExtState_7Zip
+};
+
+struct CModifiedExtInfo: public NRegistryAssoc::CShellExtInfo
+{
+ int OldState;
+ int State;
+ int ImageIndex;
+ bool Other;
+ bool Other7Zip;
+
+ CModifiedExtInfo(): ImageIndex(-1) {}
+
+ CSysString GetString() const;
+
+ void SetState(const UString &iconPath)
+ {
+ State = kExtState_Clear;
+ Other = false;
+ Other7Zip = false;
+ if (!ProgramKey.IsEmpty())
+ {
+ State = kExtState_Other;
+ Other = true;
+ if (IsIt7Zip())
+ {
+ Other7Zip = !iconPath.IsEqualTo_NoCase(IconPath);
+ if (!Other7Zip)
+ {
+ State = kExtState_7Zip;
+ Other = false;
+ }
+ }
+ }
+ OldState = State;
+ }
+};
+
+struct CAssoc
+{
+ CModifiedExtInfo Pair[2];
+ int SevenZipImageIndex;
+
+ int GetIconIndex() const
+ {
+ for (unsigned i = 0; i < 2; i++)
+ {
+ const CModifiedExtInfo &pair = Pair[i];
+ if (pair.State == kExtState_Clear)
+ continue;
+ if (pair.State == kExtState_7Zip)
+ return SevenZipImageIndex;
+ if (pair.ImageIndex != -1)
+ return pair.ImageIndex;
+ }
+ return -1;
+ }
+};
+
+#ifdef UNDER_CE
+ #define NUM_EXT_GROUPS 1
+#else
+ #define NUM_EXT_GROUPS 2
+#endif
+
+class CSystemPage: public NWindows::NControl::CPropertyPage
+{
+ CExtDatabase _extDB;
+ CObjectVector<CAssoc> _items;
+
+ unsigned _numIcons;
+ NWindows::NControl::CImageList _imageList;
+ NWindows::NControl::CListView _listView;
+
+ bool _needSave;
+
+ HKEY GetHKey(unsigned
+ #if NUM_EXT_GROUPS != 1
+ group
+ #endif
+ ) const
+ {
+ #if NUM_EXT_GROUPS == 1
+ return HKEY_CLASSES_ROOT;
+ #else
+ return group == 0 ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
+ #endif
+ }
+
+ int AddIcon(const UString &path, int iconIndex);
+ unsigned GetRealIndex(unsigned listIndex) const { return listIndex; }
+ void RefreshListItem(unsigned group, unsigned listIndex);
+ void ChangeState(unsigned group, const CUIntVector &indices);
+ void ChangeState(unsigned group);
+
+ bool OnListKeyDown(LPNMLVKEYDOWN keyDownInfo);
+
+public:
+ bool WasChanged;
+
+ CSystemPage(): WasChanged(false) {}
+
+ virtual bool OnInit() Z7_override;
+ virtual void OnNotifyHelp() Z7_override;
+ virtual bool OnNotify(UINT controlID, LPNMHDR lParam) Z7_override;
+ virtual LONG OnApply() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/SystemPage.rc b/CPP/7zip/UI/FileManager/SystemPage.rc
new file mode 100644
index 0000000..3bb143a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPage.rc
@@ -0,0 +1,43 @@
+#include "SystemPageRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 252
+
+IDD_SYSTEM DIALOG 0, 0, xs, ys MY_PAGE_STYLE MY_FONT
+CAPTION "System"
+BEGIN
+ LTEXT "Associate 7-Zip with:", IDT_SYSTEM_ASSOCIATE, m, m, xc, 8
+ PUSHBUTTON "+", IDB_SYSTEM_CURRENT, 80, m + 12, 40, bys
+ PUSHBUTTON "+", IDB_SYSTEM_ALL, 166, m + 12, 40, bys
+ CONTROL "List1", IDL_SYSTEM_ASSOCIATE, "SysListView32",
+ LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+ m, m + 32, xc, (yc - 32)
+END
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc (SMALL_PAGE_SIZE_X + 8)
+#define yc (128 + 8)
+
+IDD_SYSTEM_2 DIALOG 0, 0, xs, ys MY_PAGE_STYLE MY_FONT
+CAPTION "System"
+BEGIN
+ LTEXT "Associate 7-Zip with:", IDT_SYSTEM_ASSOCIATE, m, m, xc, 8
+ PUSHBUTTON "+", IDB_SYSTEM_CURRENT, 60, m + 12, 40, bys
+ CONTROL "List1", IDL_SYSTEM_ASSOCIATE, "SysListView32",
+ LVS_REPORT | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,
+ m, m + 32, xc, (yc - 32)
+END
+
+#endif
+
+STRINGTABLE
+BEGIN
+ IDS_SYSTEM_ALL_USERS "All users"
+END
diff --git a/CPP/7zip/UI/FileManager/SystemPageRes.h b/CPP/7zip/UI/FileManager/SystemPageRes.h
new file mode 100644
index 0000000..c894448
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/SystemPageRes.h
@@ -0,0 +1,9 @@
+#define IDD_SYSTEM 2200
+#define IDD_SYSTEM_2 12200
+
+#define IDT_SYSTEM_ASSOCIATE 2201
+#define IDS_SYSTEM_ALL_USERS 2202
+
+#define IDL_SYSTEM_ASSOCIATE 100
+#define IDB_SYSTEM_CURRENT 101
+#define IDB_SYSTEM_ALL 102
diff --git a/CPP/7zip/UI/FileManager/Test.bmp b/CPP/7zip/UI/FileManager/Test.bmp
new file mode 100644
index 0000000..ef85ba2
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Test.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/Test2.bmp b/CPP/7zip/UI/FileManager/Test2.bmp
new file mode 100644
index 0000000..99b7dbf
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/Test2.bmp
Binary files differ
diff --git a/CPP/7zip/UI/FileManager/TextPairs.cpp b/CPP/7zip/UI/FileManager/TextPairs.cpp
new file mode 100644
index 0000000..1ac7098
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/TextPairs.cpp
@@ -0,0 +1,193 @@
+// TextPairs.cpp
+
+#include "StdAfx.h"
+
+#include "TextPairs.h"
+
+static const wchar_t kNewLineChar = '\n';
+static const wchar_t kQuoteChar = '\"';
+
+static const wchar_t kBOM = (wchar_t)0xFEFF;
+
+static bool IsSeparatorChar(wchar_t c)
+{
+ return (c == ' ' || c == '\t');
+}
+
+static void RemoveCr(UString &s)
+{
+ s.RemoveChar(L'\x0D');
+}
+
+static UString GetIDString(const wchar_t *srcString, unsigned &finishPos)
+{
+ UString result;
+ bool quotes = false;
+ for (finishPos = 0;;)
+ {
+ wchar_t c = srcString[finishPos];
+ if (c == 0)
+ break;
+ finishPos++;
+ bool isSeparatorChar = IsSeparatorChar(c);
+ if (c == kNewLineChar || (isSeparatorChar && !quotes)
+ || (c == kQuoteChar && quotes))
+ break;
+ else if (c == kQuoteChar)
+ quotes = true;
+ else
+ result += c;
+ }
+ result.Trim();
+ RemoveCr(result);
+ return result;
+}
+
+static UString GetValueString(const wchar_t *srcString, unsigned &finishPos)
+{
+ UString result;
+ for (finishPos = 0;;)
+ {
+ wchar_t c = srcString[finishPos];
+ if (c == 0)
+ break;
+ finishPos++;
+ if (c == kNewLineChar)
+ break;
+ result += c;
+ }
+ result.Trim();
+ RemoveCr(result);
+ return result;
+}
+
+static bool GetTextPairs(const UString &srcString, CObjectVector<CTextPair> &pairs)
+{
+ pairs.Clear();
+ unsigned pos = 0;
+
+ if (srcString.Len() > 0)
+ {
+ if (srcString[0] == kBOM)
+ pos++;
+ }
+ while (pos < srcString.Len())
+ {
+ unsigned finishPos;
+ UString id = GetIDString((const wchar_t *)srcString + pos, finishPos);
+ pos += finishPos;
+ if (id.IsEmpty())
+ continue;
+ UString value = GetValueString((const wchar_t *)srcString + pos, finishPos);
+ pos += finishPos;
+ if (!id.IsEmpty())
+ {
+ CTextPair pair;
+ pair.ID = id;
+ pair.Value = value;
+ pairs.Add(pair);
+ }
+ }
+ return true;
+}
+
+static int ComparePairIDs(const UString &s1, const UString &s2)
+ { return MyStringCompareNoCase(s1, s2); }
+
+static int ComparePairItems(const CTextPair &p1, const CTextPair &p2)
+ { return ComparePairIDs(p1.ID, p2.ID); }
+
+static int ComparePairItems(void *const *a1, void *const *a2, void * /* param */)
+ { return ComparePairItems(**(const CTextPair *const *)a1, **(const CTextPair *const *)a2); }
+
+void CPairsStorage::Sort() { Pairs.Sort(ComparePairItems, NULL); }
+
+int CPairsStorage::FindID(const UString &id, unsigned &insertPos) const
+{
+ unsigned left = 0, right = Pairs.Size();
+ while (left != right)
+ {
+ const unsigned mid = (left + right) / 2;
+ const int compResult = ComparePairIDs(id, Pairs[mid].ID);
+ if (compResult == 0)
+ {
+ insertPos = mid; // to disable GCC warning
+ return (int)mid;
+ }
+ if (compResult < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ insertPos = left;
+ return -1;
+}
+
+int CPairsStorage::FindID(const UString &id) const
+{
+ unsigned pos;
+ return FindID(id, pos);
+}
+
+void CPairsStorage::AddPair(const CTextPair &pair)
+{
+ unsigned insertPos;
+ const int pos = FindID(pair.ID, insertPos);
+ if (pos >= 0)
+ Pairs[pos] = pair;
+ else
+ Pairs.Insert(insertPos, pair);
+}
+
+void CPairsStorage::DeletePair(const UString &id)
+{
+ const int pos = FindID(id);
+ if (pos >= 0)
+ Pairs.Delete((unsigned)pos);
+}
+
+bool CPairsStorage::GetValue(const UString &id, UString &value) const
+{
+ value.Empty();
+ const int pos = FindID(id);
+ if (pos < 0)
+ return false;
+ value = Pairs[pos].Value;
+ return true;
+}
+
+UString CPairsStorage::GetValue(const UString &id) const
+{
+ const int pos = FindID(id);
+ if (pos < 0)
+ return UString();
+ return Pairs[pos].Value;
+}
+
+bool CPairsStorage::ReadFromString(const UString &text)
+{
+ bool result = ::GetTextPairs(text, Pairs);
+ if (result)
+ Sort();
+ else
+ Pairs.Clear();
+ return result;
+}
+
+void CPairsStorage::SaveToString(UString &text) const
+{
+ FOR_VECTOR (i, Pairs)
+ {
+ const CTextPair &pair = Pairs[i];
+ bool multiWord = (pair.ID.Find(L' ') >= 0);
+ if (multiWord)
+ text += '\"';
+ text += pair.ID;
+ if (multiWord)
+ text += '\"';
+ text.Add_Space();
+ text += pair.Value;
+ text += '\x0D';
+ text.Add_LF();
+ }
+}
diff --git a/CPP/7zip/UI/FileManager/TextPairs.h b/CPP/7zip/UI/FileManager/TextPairs.h
new file mode 100644
index 0000000..d18233d
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/TextPairs.h
@@ -0,0 +1,32 @@
+// TextPairs.h
+
+#ifndef ZIP7_INC_FM_TEXT_PAIRS_H
+#define ZIP7_INC_FM_TEXT_PAIRS_H
+
+#include "../../../Common/MyString.h"
+
+struct CTextPair
+{
+ UString ID;
+ UString Value;
+};
+
+class CPairsStorage
+{
+ CObjectVector<CTextPair> Pairs;
+
+ int FindID(const UString &id, unsigned &insertPos) const;
+ int FindID(const UString &id) const;
+ void Sort();
+public:
+ void Clear() { Pairs.Clear(); }
+ bool ReadFromString(const UString &text);
+ void SaveToString(UString &text) const;
+
+ bool GetValue(const UString &id, UString &value) const;
+ UString GetValue(const UString &id) const;
+ void AddPair(const CTextPair &pair);
+ void DeletePair(const UString &id);
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/UpdateCallback100.cpp b/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
new file mode 100644
index 0000000..71ad710
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/UpdateCallback100.cpp
@@ -0,0 +1,124 @@
+// UpdateCallback100.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Windows/ErrorMsg.h"
+
+#include "../GUI/resource3.h"
+
+#include "LangUtils.h"
+#include "UpdateCallback100.h"
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ScanProgress(UInt64 /* numFolders */, UInt64 numFiles, UInt64 totalSize, const wchar_t *path, Int32 /* isDir */))
+{
+ return ProgressDialog->Sync.ScanProgress(numFiles, totalSize, us2fs(path));
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ScanError(const wchar_t *path, HRESULT errorCode))
+{
+ ProgressDialog->Sync.AddError_Code_Name(errorCode, path);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetNumFiles(UInt64 numFiles))
+{
+ return ProgressDialog->Sync.Set_NumFilesTotal(numFiles);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetTotal(UInt64 size))
+{
+ ProgressDialog->Sync.Set_NumBytesTotal(size);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 *completed))
+{
+ return ProgressDialog->Sync.Set_NumBytesCur(completed);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+{
+ ProgressDialog->Sync.Set_Ratio(inSize, outSize);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CompressOperation(const wchar_t *name))
+{
+ return SetOperation_Base(NUpdateNotifyOp::kAdd, name, false);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::DeleteOperation(const wchar_t *name))
+{
+ return SetOperation_Base(NUpdateNotifyOp::kDelete, name, false);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::OperationResult(Int32 /* operationResult */))
+{
+ ProgressDialog->Sync.Set_NumFilesCur(++NumFiles);
+ return S_OK;
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s);
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name))
+{
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ UString s;
+ SetExtractErrorMessage(opRes, isEncrypted, name, s);
+ ProgressDialog->Sync.AddError_Message(s);
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReportUpdateOperation(UInt32 notifyOp, const wchar_t *name, Int32 isDir))
+{
+ return SetOperation_Base(notifyOp, name, IntToBool(isDir));
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::UpdateErrorMessage(const wchar_t *message))
+{
+ ProgressDialog->Sync.AddError_Message(message);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::OpenFileError(const wchar_t *path, HRESULT errorCode))
+{
+ ProgressDialog->Sync.AddError_Code_Name(errorCode, path);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReadingFileError(const wchar_t *path, HRESULT errorCode))
+{
+ ProgressDialog->Sync.AddError_Code_Name(errorCode, path);
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+{
+ *password = NULL;
+ *passwordIsDefined = BoolToInt(PasswordIsDefined);
+ if (!PasswordIsDefined)
+ return S_OK;
+ return StringToBstr(Password, password);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+ return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+ return ProgressDialog->Sync.CheckStop();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword(BSTR *password))
+{
+ *password = NULL;
+ if (!PasswordIsDefined)
+ {
+ RINOK(ShowAskPasswordDialog())
+ }
+ return StringToBstr(Password, password);
+}
diff --git a/CPP/7zip/UI/FileManager/UpdateCallback100.h b/CPP/7zip/UI/FileManager/UpdateCallback100.h
new file mode 100644
index 0000000..5d56dfb
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/UpdateCallback100.h
@@ -0,0 +1,46 @@
+// UpdateCallback100.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK100_H
+#define ZIP7_INC_UPDATE_CALLBACK100_H
+
+#include "../../../Common/MyCom.h"
+
+#include "../../IPassword.h"
+
+#include "../Agent/IFolderArchive.h"
+
+#include "../GUI/UpdateCallbackGUI2.h"
+
+#include "ProgressDialog2.h"
+
+class CUpdateCallback100Imp Z7_final:
+ public IFolderArchiveUpdateCallback,
+ public IFolderArchiveUpdateCallback2,
+ public IFolderScanProgress,
+ public ICryptoGetTextPassword2,
+ public ICryptoGetTextPassword,
+ public IArchiveOpenCallback,
+ public ICompressProgressInfo,
+ public CUpdateCallbackGUI2,
+ public CMyUnknownImp
+{
+ Z7_COM_UNKNOWN_IMP_7(
+ IFolderArchiveUpdateCallback,
+ IFolderArchiveUpdateCallback2,
+ IFolderScanProgress,
+ ICryptoGetTextPassword2,
+ ICryptoGetTextPassword,
+ IArchiveOpenCallback,
+ ICompressProgressInfo)
+
+ Z7_IFACE_COM7_IMP(IProgress)
+ Z7_IFACE_COM7_IMP(IFolderArchiveUpdateCallback)
+ Z7_IFACE_COM7_IMP(IFolderArchiveUpdateCallback2)
+ Z7_IFACE_COM7_IMP(IFolderScanProgress)
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword2)
+ Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ Z7_IFACE_COM7_IMP(IArchiveOpenCallback)
+ Z7_IFACE_COM7_IMP(ICompressProgressInfo)
+};
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/VerCtrl.cpp b/CPP/7zip/UI/FileManager/VerCtrl.cpp
new file mode 100644
index 0000000..0c894b8
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/VerCtrl.cpp
@@ -0,0 +1,428 @@
+// VerCtrl.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileFind.h"
+
+#include "App.h"
+#include "RegistryUtils.h"
+#include "OverwriteDialog.h"
+
+#include "resource.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NFind;
+using namespace NDir;
+
+static FString ConvertPath_to_Ctrl(const FString &path)
+{
+ FString s = path;
+ s.Replace(FChar(':'), FChar('_'));
+ return s;
+}
+
+struct CFileDataInfo
+{
+ CByteBuffer Data;
+ BY_HANDLE_FILE_INFORMATION Info;
+ bool IsOpen;
+
+ CFileDataInfo(): IsOpen (false) {}
+ UInt64 GetSize() const { return (((UInt64)Info.nFileSizeHigh) << 32) + Info.nFileSizeLow; }
+ bool Read(const FString &path);
+};
+
+
+bool CFileDataInfo::Read(const FString &path)
+{
+ IsOpen = false;
+ NIO::CInFile file;
+ if (!file.Open(path))
+ return false;
+ if (!file.GetFileInformation(&Info))
+ return false;
+
+ const UInt64 size = GetSize();
+ const size_t size2 = (size_t)size;
+ if (size2 != size || size2 > (1 << 28))
+ {
+ SetLastError(1);
+ return false;
+ }
+
+ Data.Alloc(size2);
+
+ size_t processedSize;
+ if (!file.ReadFull(Data, size2, processedSize))
+ return false;
+ if (processedSize != size2)
+ {
+ SetLastError(1);
+ return false;
+ }
+ IsOpen = true;
+ return true;
+}
+
+
+static bool CreateComplexDir_for_File(const FString &path)
+{
+ FString resDirPrefix;
+ FString resFileName;
+ if (!GetFullPathAndSplit(path, resDirPrefix, resFileName))
+ return false;
+ return CreateComplexDir(resDirPrefix);
+}
+
+
+static bool ParseNumberString(const FString &s, UInt32 &number)
+{
+ const FChar *end;
+ UInt64 result = ConvertStringToUInt64(s, &end);
+ if (*end != 0 || s.IsEmpty() || result > (UInt32)0x7FFFFFFF)
+ return false;
+ number = (UInt32)result;
+ return true;
+}
+
+
+static void WriteFile(const FString &path, bool createAlways, const CFileDataInfo &fdi, const CPanel &panel)
+{
+ NIO::COutFile outFile;
+ if (!outFile.Create(path, createAlways)) // (createAlways = false) means CREATE_NEW
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ UInt32 processedSize;
+ if (!outFile.Write(fdi.Data, (UInt32)fdi.Data.Size(), processedSize))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ if (processedSize != fdi.Data.Size())
+ {
+ panel.MessageBox_Error(L"Write error");
+ return;
+ }
+ if (!outFile.SetTime(
+ &fdi.Info.ftCreationTime,
+ &fdi.Info.ftLastAccessTime,
+ &fdi.Info.ftLastWriteTime))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+
+ if (!SetFileAttrib(path, fdi.Info.dwFileAttributes))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+}
+
+
+static UInt64 FILETIME_to_UInt64(const FILETIME &ft)
+{
+ return ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
+}
+
+static void UInt64_TO_FILETIME(UInt64 v, FILETIME &ft)
+{
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+
+void CApp::VerCtrl(unsigned id)
+{
+ const CPanel &panel = GetFocusedPanel();
+
+ if (!panel.Is_IO_FS_Folder())
+ {
+ panel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ CRecordVector<UInt32> indices;
+ panel.Get_ItemIndices_Selected(indices);
+
+ if (indices.Size() != 1)
+ {
+ // panel.MessageBox_Error_UnsupportOperation();
+ return;
+ }
+
+ const FString path = us2fs(panel.GetItemFullPath(indices[0]));
+
+ UString vercPath;
+ ReadReg_VerCtrlPath(vercPath);
+ if (vercPath.IsEmpty())
+ return;
+ NName::NormalizeDirPathPrefix(vercPath);
+
+ FString dirPrefix;
+ FString fileName;
+ if (!GetFullPathAndSplit(path, dirPrefix, fileName))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+
+ const FString dirPrefix2 = us2fs(vercPath) + ConvertPath_to_Ctrl(dirPrefix);
+ const FString path2 = dirPrefix2 + fileName;
+
+ bool sameTime = false;
+ bool sameData = false;
+ bool areIdentical = false;
+
+ CFileDataInfo fdi, fdi2;
+ if (!fdi.Read(path))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+
+ if (fdi2.Read(path2))
+ {
+ sameData = (fdi.Data == fdi2.Data);
+ sameTime = (CompareFileTime(&fdi.Info.ftLastWriteTime, &fdi2.Info.ftLastWriteTime) == 0);
+ areIdentical = (sameData && sameTime);
+ }
+
+ const bool isReadOnly = NAttributes::IsReadOnly(fdi.Info.dwFileAttributes);
+
+ if (id == IDM_VER_EDIT)
+ {
+ if (!isReadOnly)
+ {
+ panel.MessageBox_Error(L"File is not read-only");
+ return;
+ }
+
+ if (!areIdentical)
+ {
+ if (fdi2.IsOpen)
+ {
+ NFind::CEnumerator enumerator;
+ FString d2 = dirPrefix2;
+ d2 += "_7vc";
+ d2.Add_PathSepar();
+ d2 += fileName;
+ d2.Add_PathSepar();
+ enumerator.SetDirPrefix(d2);
+ NFind::CDirEntry fi;
+ Int32 maxVal = -1;
+ while (enumerator.Next(fi))
+ {
+ UInt32 val;
+ if (!ParseNumberString(fi.Name, val))
+ continue;
+ if ((Int32)val > maxVal)
+ maxVal = (Int32)val;
+ }
+
+ UInt32 next = (UInt32)maxVal + 1;
+ if (maxVal < 0)
+ {
+ next = 1;
+ if (!::CreateComplexDir_for_File(path2))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ }
+
+ // we rename old file2 to some name;
+ FString path_num = d2;
+ {
+ AString t;
+ t.Add_UInt32((UInt32)next);
+ while (t.Len() < 3)
+ t.InsertAtFront('0');
+ path_num += t;
+ }
+
+ if (maxVal < 0)
+ {
+ if (!::CreateComplexDir_for_File(path_num))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ }
+
+ if (!NDir::MyMoveFile(path2, path_num))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ }
+ else
+ {
+ if (!::CreateComplexDir_for_File(path2))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ }
+ /*
+ if (!::CopyFile(fs2fas(path), fs2fas(path2), TRUE))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ */
+ WriteFile(path2,
+ false, // (createAlways = false) means CREATE_NEW
+ fdi, panel);
+ }
+
+ if (!SetFileAttrib(path, fdi.Info.dwFileAttributes & ~(DWORD)FILE_ATTRIBUTE_READONLY))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+
+ return;
+ }
+
+ if (isReadOnly)
+ {
+ panel.MessageBox_Error(L"File is read-only");
+ return;
+ }
+
+ if (id == IDM_VER_COMMIT)
+ {
+ if (sameData)
+ {
+ if (!sameTime)
+ {
+ panel.MessageBox_Error(
+ L"Same data, but different timestamps.\n"
+ L"Use `Revert` to recover timestamp.");
+ return;
+ }
+ }
+
+ const UInt64 timeStampOriginal = FILETIME_to_UInt64(fdi.Info.ftLastWriteTime);
+ UInt64 timeStamp2 = 0;
+ if (fdi2.IsOpen)
+ timeStamp2 = FILETIME_to_UInt64(fdi2.Info.ftLastWriteTime);
+
+ if (timeStampOriginal > timeStamp2)
+ {
+ const UInt64 k_Ntfs_prec = 10000000;
+ UInt64 timeStamp = timeStampOriginal;
+ const UInt32 k_precs[] = { 60 * 60, 60, 2, 1 };
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_precs); i++)
+ {
+ timeStamp = timeStampOriginal;
+ const UInt64 prec = k_Ntfs_prec * k_precs[i];
+ // timeStamp += prec - 1; // for rounding up
+ timeStamp /= prec;
+ timeStamp *= prec;
+ if (timeStamp > timeStamp2)
+ break;
+ }
+
+ if (timeStamp != timeStampOriginal
+ && timeStamp > timeStamp2)
+ {
+ FILETIME mTime;
+ UInt64_TO_FILETIME(timeStamp, mTime);
+ // NDir::SetFileAttrib(path, 0);
+ {
+ NIO::COutFile outFile;
+ if (!outFile.Open(path, OPEN_EXISTING))
+ {
+ panel.MessageBox_LastError();
+ return;
+ // if (::GetLastError() != ERROR_SUCCESS)
+ // throw "open error";
+ }
+ else
+ {
+ const UInt64 cTime = FILETIME_to_UInt64(fdi.Info.ftCreationTime);
+ if (cTime > timeStamp)
+ outFile.SetTime(&mTime, NULL, &mTime);
+ else
+ outFile.SetMTime(&mTime);
+ }
+ }
+ }
+ }
+
+ if (!SetFileAttrib(path, fdi.Info.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ return;
+ }
+
+ if (id == IDM_VER_REVERT)
+ {
+ if (!fdi2.IsOpen)
+ {
+ panel.MessageBox_Error(L"No file to revert");
+ return;
+ }
+ if (!sameData || !sameTime)
+ {
+ if (!sameData)
+ {
+ /*
+ UString m;
+ m = "Are you sure you want to revert file ?";
+ m.Add_LF();
+ m += path;
+ if (::MessageBoxW(panel.GetParent(), m, L"Version Control: File Revert", MB_OKCANCEL | MB_ICONQUESTION) != IDOK)
+ return;
+ */
+ COverwriteDialog dialog;
+
+ dialog.OldFileInfo.SetTime(&fdi.Info.ftLastWriteTime);
+ dialog.OldFileInfo.SetSize(fdi.GetSize());
+ dialog.OldFileInfo.Name = fs2us(path);
+
+ dialog.NewFileInfo.SetTime(&fdi2.Info.ftLastWriteTime);
+ dialog.NewFileInfo.SetSize(fdi2.GetSize());
+ dialog.NewFileInfo.Name = fs2us(path2);
+
+ dialog.ShowExtraButtons = false;
+ dialog.DefaultButton_is_NO = true;
+
+ INT_PTR writeAnswer = dialog.Create(panel.GetParent());
+
+ if (writeAnswer != IDYES)
+ return;
+ }
+
+ WriteFile(path,
+ true, // (createAlways = true) means CREATE_ALWAYS
+ fdi2, panel);
+ }
+ else
+ {
+ if (!SetFileAttrib(path, fdi2.Info.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
+ {
+ panel.MessageBox_LastError();
+ return;
+ }
+ }
+ return;
+ }
+
+ // if (id == IDM_VER_DIFF)
+ {
+ if (!fdi2.IsOpen)
+ return;
+ DiffFiles(fs2us(path2), fs2us(path));
+ }
+}
diff --git a/CPP/7zip/UI/FileManager/ViewSettings.cpp b/CPP/7zip/UI/FileManager/ViewSettings.cpp
new file mode 100644
index 0000000..3d64602
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ViewSettings.cpp
@@ -0,0 +1,314 @@
+// ViewSettings.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/Registry.h"
+#include "../../../Windows/Synchronization.h"
+
+#include "ViewSettings.h"
+
+using namespace NWindows;
+using namespace NRegistry;
+
+#define REG_PATH_FM TEXT("Software") TEXT(STRING_PATH_SEPARATOR) TEXT("7-Zip") TEXT(STRING_PATH_SEPARATOR) TEXT("FM")
+
+static LPCTSTR const kCUBasePath = REG_PATH_FM;
+static LPCTSTR const kCulumnsKeyName = REG_PATH_FM TEXT(STRING_PATH_SEPARATOR) TEXT("Columns");
+
+static LPCTSTR const kPositionValueName = TEXT("Position");
+static LPCTSTR const kPanelsInfoValueName = TEXT("Panels");
+static LPCTSTR const kToolbars = TEXT("Toolbars");
+
+static LPCWSTR const kPanelPathValueName = L"PanelPath";
+
+static LPCTSTR const kListMode = TEXT("ListMode");
+static LPCTSTR const kFolderHistoryValueName = TEXT("FolderHistory");
+static LPCTSTR const kFastFoldersValueName = TEXT("FolderShortcuts");
+static LPCTSTR const kCopyHistoryValueName = TEXT("CopyHistory");
+
+static NSynchronization::CCriticalSection g_CS;
+
+#define Set32(p, v) SetUi32(((Byte *)p), v)
+#define SetBool(p, v) Set32(p, ((v) ? 1 : 0))
+
+#define Get32(p, dest) dest = GetUi32((const Byte *)p);
+#define Get32_LONG(p, dest) dest = (LONG)GetUi32((const Byte *)p);
+#define GetBool(p, dest) dest = (GetUi32(p) != 0);
+
+/*
+struct CColumnHeader
+{
+ UInt32 Version;
+ UInt32 SortID;
+ UInt32 Ascending; // bool
+};
+*/
+
+static const UInt32 kListViewHeaderSize = 3 * 4;
+static const UInt32 kColumnInfoSize = 3 * 4;
+static const UInt32 kListViewVersion = 1;
+
+void CListViewInfo::Save(const UString &id) const
+{
+ const UInt32 dataSize = kListViewHeaderSize + kColumnInfoSize * Columns.Size();
+ CByteArr buf(dataSize);
+
+ Set32(buf, kListViewVersion)
+ Set32(buf + 4, SortID)
+ SetBool(buf + 8, Ascending)
+ FOR_VECTOR (i, Columns)
+ {
+ const CColumnInfo &column = Columns[i];
+ Byte *p = buf + kListViewHeaderSize + i * kColumnInfoSize;
+ Set32(p, column.PropID)
+ SetBool(p + 4, column.IsVisible)
+ Set32(p + 8, column.Width)
+ }
+ {
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCulumnsKeyName);
+ key.SetValue(GetSystemString(id), (const Byte *)buf, dataSize);
+ }
+}
+
+void CListViewInfo::Read(const UString &id)
+{
+ Clear();
+ CByteBuffer buf;
+ UInt32 size;
+ {
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCulumnsKeyName, KEY_READ) != ERROR_SUCCESS)
+ return;
+ if (key.QueryValue(GetSystemString(id), buf, size) != ERROR_SUCCESS)
+ return;
+ }
+ if (size < kListViewHeaderSize)
+ return;
+ UInt32 version;
+ Get32(buf, version)
+ if (version != kListViewVersion)
+ return;
+ Get32(buf + 4, SortID)
+ GetBool(buf + 8, Ascending)
+
+ IsLoaded = true;
+
+ size -= kListViewHeaderSize;
+ if (size % kColumnInfoSize != 0)
+ return;
+ unsigned numItems = size / kColumnInfoSize;
+ Columns.ClearAndReserve(numItems);
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ CColumnInfo column;
+ const Byte *p = buf + kListViewHeaderSize + i * kColumnInfoSize;
+ Get32(p, column.PropID)
+ GetBool(p + 4, column.IsVisible)
+ Get32(p + 8, column.Width)
+ Columns.AddInReserved(column);
+ }
+}
+
+
+/*
+struct CWindowPosition
+{
+ RECT Rect;
+ UInt32 Maximized; // bool
+};
+
+struct CPanelsInfo
+{
+ UInt32 NumPanels;
+ UInt32 CurrentPanel;
+ UInt32 SplitterPos;
+};
+*/
+
+static const UInt32 kWindowPositionHeaderSize = 5 * 4;
+static const UInt32 kPanelsInfoHeaderSize = 3 * 4;
+
+void CWindowInfo::Save() const
+{
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCUBasePath);
+ {
+ Byte buf[kWindowPositionHeaderSize];
+ Set32(buf, (UInt32)rect.left)
+ Set32(buf + 4, (UInt32)rect.top)
+ Set32(buf + 8, (UInt32)rect.right)
+ Set32(buf + 12, (UInt32)rect.bottom)
+ SetBool(buf + 16, maximized)
+ key.SetValue(kPositionValueName, buf, kWindowPositionHeaderSize);
+ }
+ {
+ Byte buf[kPanelsInfoHeaderSize];
+ Set32(buf, numPanels)
+ Set32(buf + 4, currentPanel)
+ Set32(buf + 8, splitterPos)
+ key.SetValue(kPanelsInfoValueName, buf, kPanelsInfoHeaderSize);
+ }
+}
+
+static bool QueryBuf(CKey &key, LPCTSTR name, CByteBuffer &buf, UInt32 dataSize)
+{
+ UInt32 size;
+ return key.QueryValue(name, buf, size) == ERROR_SUCCESS && size == dataSize;
+}
+
+void CWindowInfo::Read(bool &windowPosDefined, bool &panelInfoDefined)
+{
+ windowPosDefined = false;
+ panelInfoDefined = false;
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
+ return;
+ CByteBuffer buf;
+ if (QueryBuf(key, kPositionValueName, buf, kWindowPositionHeaderSize))
+ {
+ Get32_LONG(buf, rect.left)
+ Get32_LONG(buf + 4, rect.top)
+ Get32_LONG(buf + 8, rect.right)
+ Get32_LONG(buf + 12, rect.bottom)
+ GetBool(buf + 16, maximized)
+ windowPosDefined = true;
+ }
+ if (QueryBuf(key, kPanelsInfoValueName, buf, kPanelsInfoHeaderSize))
+ {
+ Get32(buf, numPanels)
+ Get32(buf + 4, currentPanel)
+ Get32(buf + 8, splitterPos)
+ panelInfoDefined = true;
+ }
+ return;
+}
+
+
+static void SaveUi32Val(const TCHAR *name, UInt32 value)
+{
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCUBasePath);
+ key.SetValue(name, value);
+}
+
+static bool ReadUi32Val(const TCHAR *name, UInt32 &value)
+{
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
+ return false;
+ return key.QueryValue(name, value) == ERROR_SUCCESS;
+}
+
+void SaveToolbarsMask(UInt32 toolbarMask)
+{
+ SaveUi32Val(kToolbars, toolbarMask);
+}
+
+static const UInt32 kDefaultToolbarMask = ((UInt32)1 << 31) | 8 | 4 | 1;
+
+UInt32 ReadToolbarsMask()
+{
+ UInt32 mask;
+ if (!ReadUi32Val(kToolbars, mask))
+ return kDefaultToolbarMask;
+ return mask;
+}
+
+
+void CListMode::Save() const
+{
+ UInt32 t = 0;
+ for (int i = 0; i < 2; i++)
+ t |= ((Panels[i]) & 0xFF) << (i * 8);
+ SaveUi32Val(kListMode, t);
+}
+
+void CListMode::Read()
+{
+ Init();
+ UInt32 t;
+ if (!ReadUi32Val(kListMode, t))
+ return;
+ for (int i = 0; i < 2; i++)
+ {
+ Panels[i] = (t & 0xFF);
+ t >>= 8;
+ }
+}
+
+static UString GetPanelPathName(UInt32 panelIndex)
+{
+ UString s (kPanelPathValueName);
+ s.Add_UInt32(panelIndex);
+ return s;
+}
+
+void SavePanelPath(UInt32 panel, const UString &path)
+{
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCUBasePath);
+ key.SetValue(GetPanelPathName(panel), path);
+}
+
+bool ReadPanelPath(UInt32 panel, UString &path)
+{
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) != ERROR_SUCCESS)
+ return false;
+ return (key.QueryValue(GetPanelPathName(panel), path) == ERROR_SUCCESS);
+}
+
+
+static void SaveStringList(LPCTSTR valueName, const UStringVector &folders)
+{
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ key.Create(HKEY_CURRENT_USER, kCUBasePath);
+ key.SetValue_Strings(valueName, folders);
+}
+
+static void ReadStringList(LPCTSTR valueName, UStringVector &folders)
+{
+ folders.Clear();
+ NSynchronization::CCriticalSectionLock lock(g_CS);
+ CKey key;
+ if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) == ERROR_SUCCESS)
+ key.GetValue_Strings(valueName, folders);
+}
+
+void SaveFolderHistory(const UStringVector &folders)
+ { SaveStringList(kFolderHistoryValueName, folders); }
+void ReadFolderHistory(UStringVector &folders)
+ { ReadStringList(kFolderHistoryValueName, folders); }
+
+void SaveFastFolders(const UStringVector &folders)
+ { SaveStringList(kFastFoldersValueName, folders); }
+void ReadFastFolders(UStringVector &folders)
+ { ReadStringList(kFastFoldersValueName, folders); }
+
+void SaveCopyHistory(const UStringVector &folders)
+ { SaveStringList(kCopyHistoryValueName, folders); }
+void ReadCopyHistory(UStringVector &folders)
+ { ReadStringList(kCopyHistoryValueName, folders); }
+
+void AddUniqueStringToHeadOfList(UStringVector &list, const UString &s)
+{
+ for (unsigned i = 0; i < list.Size();)
+ if (s.IsEqualTo_NoCase(list[i]))
+ list.Delete(i);
+ else
+ i++;
+ list.Insert(0, s);
+}
diff --git a/CPP/7zip/UI/FileManager/ViewSettings.h b/CPP/7zip/UI/FileManager/ViewSettings.h
new file mode 100644
index 0000000..02af0a1
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/ViewSettings.h
@@ -0,0 +1,115 @@
+// ViewSettings.h
+
+#ifndef ZIP7_INC_VIEW_SETTINGS_H
+#define ZIP7_INC_VIEW_SETTINGS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+struct CColumnInfo
+{
+ PROPID PropID;
+ bool IsVisible;
+ UInt32 Width;
+
+ bool IsEqual(const CColumnInfo &a) const
+ {
+ return PropID == a.PropID && IsVisible == a.IsVisible && Width == a.Width;
+ }
+};
+
+struct CListViewInfo
+{
+ CRecordVector<CColumnInfo> Columns;
+ PROPID SortID;
+ bool Ascending;
+ bool IsLoaded;
+
+ void Clear()
+ {
+ SortID = 0;
+ Ascending = true;
+ IsLoaded = false;
+ Columns.Clear();
+ }
+
+ CListViewInfo():
+ SortID(0),
+ Ascending(true),
+ IsLoaded(false)
+ {}
+
+ /*
+ int FindColumnWithID(PROPID propID) const
+ {
+ FOR_VECTOR (i, Columns)
+ if (Columns[i].PropID == propID)
+ return i;
+ return -1;
+ }
+ */
+
+ bool IsEqual(const CListViewInfo &info) const
+ {
+ if (Columns.Size() != info.Columns.Size() ||
+ SortID != info.SortID ||
+ Ascending != info.Ascending)
+ return false;
+ FOR_VECTOR (i, Columns)
+ if (!Columns[i].IsEqual(info.Columns[i]))
+ return false;
+ return true;
+ }
+
+ void Save(const UString &id) const;
+ void Read(const UString &id);
+};
+
+
+struct CWindowInfo
+{
+ RECT rect;
+ bool maximized;
+
+ UInt32 numPanels;
+ UInt32 currentPanel;
+ UInt32 splitterPos;
+
+ void Save() const;
+ void Read(bool &windowPosDefined, bool &panelInfoDefined);
+};
+
+void SaveToolbarsMask(UInt32 toolbarMask);
+UInt32 ReadToolbarsMask();
+
+const UInt32 kListMode_Report = 3;
+
+struct CListMode
+{
+ UInt32 Panels[2];
+
+ void Init() { Panels[0] = Panels[1] = kListMode_Report; }
+ CListMode() { Init(); }
+
+ void Save() const ;
+ void Read();
+};
+
+
+
+void SavePanelPath(UInt32 panel, const UString &path);
+bool ReadPanelPath(UInt32 panel, UString &path);
+
+
+void SaveFolderHistory(const UStringVector &folders);
+void ReadFolderHistory(UStringVector &folders);
+
+void SaveFastFolders(const UStringVector &folders);
+void ReadFastFolders(UStringVector &folders);
+
+void SaveCopyHistory(const UStringVector &folders);
+void ReadCopyHistory(UStringVector &folders);
+
+void AddUniqueStringToHeadOfList(UStringVector &list, const UString &s);
+
+#endif
diff --git a/CPP/7zip/UI/FileManager/makefile b/CPP/7zip/UI/FileManager/makefile
new file mode 100644
index 0000000..df08c98
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/makefile
@@ -0,0 +1,108 @@
+PROG = 7zFM.exe
+CFLAGS = $(CFLAGS) \
+ -DZ7_EXTERNAL_CODECS \
+
+!include "FM.mak"
+
+COMMON_OBJS = \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\Lang.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\NewHandler.obj \
+ $O\Random.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = $(WIN_OBJS) \
+ $O\Clipboard.obj \
+ $O\CommonDialog.obj \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileLink.obj \
+ $O\FileName.obj \
+ $O\MemoryGlobal.obj \
+ $O\MemoryLock.obj \
+ $O\Menu.obj \
+ $O\ProcessUtils.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\Registry.obj \
+ $O\ResourceString.obj \
+ $O\Shell.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\TimeUtils.obj \
+ $O\Window.obj \
+
+
+WIN_CTRL_OBJS = \
+ $O\ComboBox.obj \
+ $O\Dialog.obj \
+ $O\ListView.obj \
+ $O\PropertyPage.obj \
+ $O\Window2.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodProps.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveName.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\CompressCall.obj \
+ $O\DefaultName.obj \
+ $O\EnumDirItems.obj \
+ $O\ExtractingFilePath.obj \
+ $O\HashCalc.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+ $O\PropIDUtils.obj \
+ $O\SetProperties.obj \
+ $O\SortUtils.obj \
+ $O\UpdateAction.obj \
+ $O\UpdateCallback.obj \
+ $O\UpdatePair.obj \
+ $O\UpdateProduce.obj \
+ $O\WorkDir.obj \
+ $O\ZipRegistry.obj \
+
+EXPLORER_OBJS = \
+ $O\ContextMenu.obj \
+ $O\MyMessages.obj \
+ $O\RegistryContextMenu.obj \
+
+GUI_OBJS = \
+ $O\HashGUI.obj \
+ $O\UpdateCallbackGUI2.obj \
+
+COMPRESS_OBJS = \
+ $O\CopyCoder.obj \
+
+AR_COMMON_OBJS = \
+ $O\ItemNameUtils.obj \
+
+
+C_OBJS = $(C_OBJS) \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\Sort.obj \
+ $O\Threads.obj \
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/FileManager/resource.h b/CPP/7zip/UI/FileManager/resource.h
index 4666269..9d605c6 100644
--- a/CPP/7zip/UI/FileManager/resource.h
+++ b/CPP/7zip/UI/FileManager/resource.h
@@ -1,177 +1,192 @@
-#include "resourceGui.h"
-
-#define IDR_MENUBAR1 70
-#define IDM_MENU 71
-#define IDR_ACCELERATOR1 72
-
-#define IDB_ADD 100
-#define IDB_EXTRACT 101
-#define IDB_TEST 102
-#define IDB_COPY 103
-#define IDB_MOVE 104
-#define IDB_DELETE 105
-#define IDB_INFO 106
-
-#define IDB_ADD2 150
-#define IDB_EXTRACT2 151
-#define IDB_TEST2 152
-#define IDB_COPY2 153
-#define IDB_MOVE2 154
-#define IDB_DELETE2 155
-#define IDB_INFO2 156
-
-#define IDM_HASH_ALL 101
-#define IDM_CRC32 102
-#define IDM_CRC64 103
-#define IDM_SHA1 104
-#define IDM_SHA256 105
-
-#define IDM_OPEN 540
-#define IDM_OPEN_INSIDE 541
-#define IDM_OPEN_OUTSIDE 542
-#define IDM_FILE_VIEW 543
-#define IDM_FILE_EDIT 544
-#define IDM_RENAME 545
-#define IDM_COPY_TO 546
-#define IDM_MOVE_TO 547
-#define IDM_DELETE 548
-#define IDM_SPLIT 549
-#define IDM_COMBINE 550
-#define IDM_PROPERTIES 551
-#define IDM_COMMENT 552
-#define IDM_CRC 553
-#define IDM_DIFF 554
-#define IDM_CREATE_FOLDER 555
-#define IDM_CREATE_FILE 556
-// #define IDM_EXIT 557
-#define IDM_LINK 558
-#define IDM_ALT_STREAMS 559
-
-#define IDM_OPEN_INSIDE_ONE 590
-#define IDM_OPEN_INSIDE_PARSER 591
-
-#define IDM_SELECT_ALL 600
-#define IDM_DESELECT_ALL 601
-#define IDM_INVERT_SELECTION 602
-#define IDM_SELECT 603
-#define IDM_DESELECT 604
-#define IDM_SELECT_BY_TYPE 605
-#define IDM_DESELECT_BY_TYPE 606
-
-#define IDM_VIEW_LARGE_ICONS 700
-#define IDM_VIEW_SMALL_ICONS 701
-#define IDM_VIEW_LIST 702
-#define IDM_VIEW_DETAILS 703
-
-#define IDM_VIEW_ARANGE_BY_NAME 710
-#define IDM_VIEW_ARANGE_BY_TYPE 711
-#define IDM_VIEW_ARANGE_BY_DATE 712
-#define IDM_VIEW_ARANGE_BY_SIZE 713
-
-#define IDM_VIEW_ARANGE_NO_SORT 730
-#define IDM_VIEW_FLAT_VIEW 731
-#define IDM_VIEW_TWO_PANELS 732
-#define IDM_VIEW_TOOLBARS 733
-#define IDM_OPEN_ROOT_FOLDER 734
-#define IDM_OPEN_PARENT_FOLDER 735
-#define IDM_FOLDERS_HISTORY 736
-#define IDM_VIEW_REFRESH 737
-#define IDM_VIEW_AUTO_REFRESH 738
-// #define IDM_VIEW_SHOW_DELETED 739
-// #define IDM_VIEW_SHOW_STREAMS 740
-
-#define IDM_VIEW_ARCHIVE_TOOLBAR 750
-#define IDM_VIEW_STANDARD_TOOLBAR 751
-#define IDM_VIEW_TOOLBARS_LARGE_BUTTONS 752
-#define IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT 753
-
-#define IDM_VIEW_TIME 761
-
-#define IDS_BOOKMARK 801
-
-#define IDM_OPTIONS 900
-#define IDM_BENCHMARK 901
-#define IDM_BENCHMARK2 902
-
-#define IDM_HELP_CONTENTS 960
-#define IDM_ABOUT 961
-
-#define IDS_OPTIONS 2100
-
-#define IDS_N_SELECTED_ITEMS 3002
-
-#define IDS_FILE_EXIST 3008
-#define IDS_WANT_UPDATE_MODIFIED_FILE 3009
-#define IDS_CANNOT_UPDATE_FILE 3010
-#define IDS_CANNOT_START_EDITOR 3011
-#define IDS_VIRUS 3012
-#define IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER 3013
-#define IDS_SELECT_ONE_FILE 3014
-#define IDS_SELECT_FILES 3015
-#define IDS_TOO_MANY_ITEMS 3016
-
-#define IDS_COPY 6000
-#define IDS_MOVE 6001
-#define IDS_COPY_TO 6002
-#define IDS_MOVE_TO 6003
-#define IDS_COPYING 6004
-#define IDS_MOVING 6005
-#define IDS_RENAMING 6006
-
-#define IDS_OPERATION_IS_NOT_SUPPORTED 6008
-#define IDS_ERROR_RENAMING 6009
-#define IDS_CONFIRM_FILE_COPY 6010
-#define IDS_WANT_TO_COPY_FILES 6011
-
-#define IDS_CONFIRM_FILE_DELETE 6100
-#define IDS_CONFIRM_FOLDER_DELETE 6101
-#define IDS_CONFIRM_ITEMS_DELETE 6102
-#define IDS_WANT_TO_DELETE_FILE 6103
-#define IDS_WANT_TO_DELETE_FOLDER 6104
-#define IDS_WANT_TO_DELETE_ITEMS 6105
-#define IDS_DELETING 6106
-#define IDS_ERROR_DELETING 6107
-#define IDS_ERROR_LONG_PATH_TO_RECYCLE 6108
-
-#define IDS_CREATE_FOLDER 6300
-#define IDS_CREATE_FILE 6301
-#define IDS_CREATE_FOLDER_NAME 6302
-#define IDS_CREATE_FILE_NAME 6303
-#define IDS_CREATE_FOLDER_DEFAULT_NAME 6304
-#define IDS_CREATE_FILE_DEFAULT_NAME 6305
-#define IDS_CREATE_FOLDER_ERROR 6306
-#define IDS_CREATE_FILE_ERROR 6307
-
-#define IDS_COMMENT 6400
-#define IDS_COMMENT2 6401
-#define IDS_SELECT 6402
-#define IDS_DESELECT 6403
-#define IDS_SELECT_MASK 6404
-
-#define IDS_PROPERTIES 6600
-#define IDS_FOLDERS_HISTORY 6601
-
-#define IDS_COMPUTER 7100
-#define IDS_NETWORK 7101
-#define IDS_DOCUMENTS 7102
-#define IDS_SYSTEM 7103
-
-#define IDS_ADD 7200
-#define IDS_EXTRACT 7201
-#define IDS_TEST 7202
-#define IDS_BUTTON_COPY 7203
-#define IDS_BUTTON_MOVE 7204
-#define IDS_BUTTON_DELETE 7205
-#define IDS_BUTTON_INFO 7206
-
-#define IDS_SPLITTING 7303
-#define IDS_SPLIT_CONFIRM_TITLE 7304
-#define IDS_SPLIT_CONFIRM_MESSAGE 7305
-#define IDS_SPLIT_VOL_MUST_BE_SMALLER 7306
-
-#define IDS_COMBINE 7400
-#define IDS_COMBINE_TO 7401
-#define IDS_COMBINING 7402
-#define IDS_COMBINE_SELECT_ONE_FILE 7403
-#define IDS_COMBINE_CANT_DETECT_SPLIT_FILE 7404
-#define IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART 7405
+#include "resourceGui.h"
+
+#define IDR_MENUBAR1 70
+#define IDM_MENU 71
+#define IDR_ACCELERATOR1 72
+
+#define IDB_ADD 100
+#define IDB_EXTRACT 101
+#define IDB_TEST 102
+#define IDB_COPY 103
+#define IDB_MOVE 104
+#define IDB_DELETE 105
+#define IDB_INFO 106
+
+#define IDB_ADD2 150
+#define IDB_EXTRACT2 151
+#define IDB_TEST2 152
+#define IDB_COPY2 153
+#define IDB_MOVE2 154
+#define IDB_DELETE2 155
+#define IDB_INFO2 156
+
+#define IDM_HASH_ALL 101
+#define IDM_CRC32 102
+#define IDM_CRC64 103
+#define IDM_SHA1 104
+#define IDM_SHA256 105
+
+
+#define IDM_FILE 500
+#define IDM_EDIT 501
+#define IDM_VIEW 502
+#define IDM_FAVORITES 503
+#define IDM_TOOLS 504
+#define IDM_HELP 505
+
+#define IDM_OPEN 540
+#define IDM_OPEN_INSIDE 541
+#define IDM_OPEN_OUTSIDE 542
+#define IDM_FILE_VIEW 543
+#define IDM_FILE_EDIT 544
+#define IDM_RENAME 545
+#define IDM_COPY_TO 546
+#define IDM_MOVE_TO 547
+#define IDM_DELETE 548
+#define IDM_SPLIT 549
+#define IDM_COMBINE 550
+#define IDM_PROPERTIES 551
+#define IDM_COMMENT 552
+#define IDM_CRC 553
+#define IDM_DIFF 554
+#define IDM_CREATE_FOLDER 555
+#define IDM_CREATE_FILE 556
+// #define IDM_EXIT 557
+#define IDM_LINK 558
+#define IDM_ALT_STREAMS 559
+
+#define IDM_VER_EDIT 580
+#define IDM_VER_COMMIT 581
+#define IDM_VER_REVERT 582
+#define IDM_VER_DIFF 583
+
+#define IDM_OPEN_INSIDE_ONE 590
+#define IDM_OPEN_INSIDE_PARSER 591
+
+#define IDM_SELECT_ALL 600
+#define IDM_DESELECT_ALL 601
+#define IDM_INVERT_SELECTION 602
+#define IDM_SELECT 603
+#define IDM_DESELECT 604
+#define IDM_SELECT_BY_TYPE 605
+#define IDM_DESELECT_BY_TYPE 606
+
+#define IDM_VIEW_LARGE_ICONS 700
+#define IDM_VIEW_SMALL_ICONS 701
+#define IDM_VIEW_LIST 702
+#define IDM_VIEW_DETAILS 703
+
+#define IDM_VIEW_ARANGE_BY_NAME 710
+#define IDM_VIEW_ARANGE_BY_TYPE 711
+#define IDM_VIEW_ARANGE_BY_DATE 712
+#define IDM_VIEW_ARANGE_BY_SIZE 713
+
+#define IDM_VIEW_ARANGE_NO_SORT 730
+#define IDM_VIEW_FLAT_VIEW 731
+#define IDM_VIEW_TWO_PANELS 732
+#define IDM_VIEW_TOOLBARS 733
+#define IDM_OPEN_ROOT_FOLDER 734
+#define IDM_OPEN_PARENT_FOLDER 735
+#define IDM_FOLDERS_HISTORY 736
+#define IDM_VIEW_REFRESH 737
+#define IDM_VIEW_AUTO_REFRESH 738
+// #define IDM_VIEW_SHOW_DELETED 739
+// #define IDM_VIEW_SHOW_STREAMS 740
+
+#define IDM_VIEW_ARCHIVE_TOOLBAR 750
+#define IDM_VIEW_STANDARD_TOOLBAR 751
+#define IDM_VIEW_TOOLBARS_LARGE_BUTTONS 752
+#define IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT 753
+
+#define IDM_VIEW_TIME_POPUP 760
+#define IDM_VIEW_TIME 761
+
+#define IDM_ADD_TO_FAVORITES 800
+#define IDS_BOOKMARK 801
+
+#define IDM_OPTIONS 900
+#define IDM_BENCHMARK 901
+#define IDM_BENCHMARK2 902
+
+#define IDM_HELP_CONTENTS 960
+#define IDM_ABOUT 961
+
+#define IDS_OPTIONS 2100
+
+#define IDS_N_SELECTED_ITEMS 3002
+
+#define IDS_FILE_EXIST 3008
+#define IDS_WANT_UPDATE_MODIFIED_FILE 3009
+#define IDS_CANNOT_UPDATE_FILE 3010
+#define IDS_CANNOT_START_EDITOR 3011
+#define IDS_VIRUS 3012
+#define IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER 3013
+#define IDS_SELECT_ONE_FILE 3014
+#define IDS_SELECT_FILES 3015
+#define IDS_TOO_MANY_ITEMS 3016
+
+#define IDS_COPY 6000
+#define IDS_MOVE 6001
+#define IDS_COPY_TO 6002
+#define IDS_MOVE_TO 6003
+#define IDS_COPYING 6004
+#define IDS_MOVING 6005
+#define IDS_RENAMING 6006
+
+#define IDS_OPERATION_IS_NOT_SUPPORTED 6008
+#define IDS_ERROR_RENAMING 6009
+#define IDS_CONFIRM_FILE_COPY 6010
+#define IDS_WANT_TO_COPY_FILES 6011
+
+#define IDS_CONFIRM_FILE_DELETE 6100
+#define IDS_CONFIRM_FOLDER_DELETE 6101
+#define IDS_CONFIRM_ITEMS_DELETE 6102
+#define IDS_WANT_TO_DELETE_FILE 6103
+#define IDS_WANT_TO_DELETE_FOLDER 6104
+#define IDS_WANT_TO_DELETE_ITEMS 6105
+#define IDS_DELETING 6106
+#define IDS_ERROR_DELETING 6107
+#define IDS_ERROR_LONG_PATH_TO_RECYCLE 6108
+
+#define IDS_CREATE_FOLDER 6300
+#define IDS_CREATE_FILE 6301
+#define IDS_CREATE_FOLDER_NAME 6302
+#define IDS_CREATE_FILE_NAME 6303
+#define IDS_CREATE_FOLDER_DEFAULT_NAME 6304
+#define IDS_CREATE_FILE_DEFAULT_NAME 6305
+#define IDS_CREATE_FOLDER_ERROR 6306
+#define IDS_CREATE_FILE_ERROR 6307
+
+#define IDS_COMMENT 6400
+#define IDS_COMMENT2 6401
+#define IDS_SELECT 6402
+#define IDS_DESELECT 6403
+#define IDS_SELECT_MASK 6404
+
+#define IDS_PROPERTIES 6600
+#define IDS_FOLDERS_HISTORY 6601
+
+#define IDS_COMPUTER 7100
+#define IDS_NETWORK 7101
+#define IDS_DOCUMENTS 7102
+#define IDS_SYSTEM 7103
+
+#define IDS_ADD 7200
+#define IDS_EXTRACT 7201
+#define IDS_TEST 7202
+#define IDS_BUTTON_COPY 7203
+#define IDS_BUTTON_MOVE 7204
+#define IDS_BUTTON_DELETE 7205
+#define IDS_BUTTON_INFO 7206
+
+#define IDS_SPLITTING 7303
+#define IDS_SPLIT_CONFIRM_TITLE 7304
+#define IDS_SPLIT_CONFIRM_MESSAGE 7305
+#define IDS_SPLIT_VOL_MUST_BE_SMALLER 7306
+
+#define IDS_COMBINE 7400
+#define IDS_COMBINE_TO 7401
+#define IDS_COMBINING 7402
+#define IDS_COMBINE_SELECT_ONE_FILE 7403
+#define IDS_COMBINE_CANT_DETECT_SPLIT_FILE 7404
+#define IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART 7405
diff --git a/CPP/7zip/UI/FileManager/resource.rc b/CPP/7zip/UI/FileManager/resource.rc
new file mode 100644
index 0000000..002265a
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/resource.rc
@@ -0,0 +1,286 @@
+#include "../../MyVersionInfo.rc"
+#include "../../GuiCommon.rc"
+#include "resource.h"
+
+MY_VERSION_INFO_APP("7-Zip File Manager", "7zFM")
+
+IDR_ACCELERATOR1 ACCELERATORS
+BEGIN
+// "N", IDM_CREATE_FILE, VIRTKEY, CONTROL, NOINVERT
+ VK_F1, IDM_HELP_CONTENTS, VIRTKEY, NOINVERT
+ VK_F12, IDM_FOLDERS_HISTORY, VIRTKEY, ALT, NOINVERT
+// VK_F7, IDM_CREATE_FOLDER, VIRTKEY, NOINVERT
+END
+
+// for MENUEX:
+// /*
+#define MY_MENUITEM_SEPARATOR MENUITEM "", 0, MFT_SEPARATOR
+#define MY_MFT_MENUBREAK MFT_MENUBREAK
+#define MY_MFT_MENUBARBREAK MFT_MENUBARBREAK
+#define MY_MFS_CHECKED MFT_STRING, MFS_CHECKED
+#define MY_MENUITEM_ID(x) , x
+// */
+
+// for MENU:
+/*
+#define MY_MENUITEM_SEPARATOR MENUITEM SEPARATOR
+#define MY_MFT_MENUBREAK MENUBREAK
+#define MY_MFT_MENUBARBREAK MENUBARBREAK
+#define MY_MFS_CHECKED CHECKED
+#define MY_MENUITEM_ID(x)
+*/
+
+IDM_MENU MENUEX
+BEGIN
+ POPUP "&File" MY_MENUITEM_ID(IDM_FILE)
+ BEGIN
+ MENUITEM "&Open\tEnter", IDM_OPEN
+ MENUITEM "Open &Inside\tCtrl+PgDn", IDM_OPEN_INSIDE
+ MENUITEM "Open Inside *", IDM_OPEN_INSIDE_ONE
+ MENUITEM "Open Inside #", IDM_OPEN_INSIDE_PARSER
+ MENUITEM "Open O&utside\tShift+Enter", IDM_OPEN_OUTSIDE
+ MENUITEM "&View\tF3", IDM_FILE_VIEW
+ MENUITEM "&Edit\tF4", IDM_FILE_EDIT
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "Rena&me\tF2", IDM_RENAME
+ MENUITEM "&Copy To...\tF5", IDM_COPY_TO
+ MENUITEM "&Move To...\tF6", IDM_MOVE_TO
+ MENUITEM "&Delete\tDel", IDM_DELETE
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "&Split file...", IDM_SPLIT
+ MENUITEM "Com&bine files...", IDM_COMBINE
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "P&roperties\tAlt+Enter", IDM_PROPERTIES
+ MENUITEM "Comme&nt...\tCtrl+Z", IDM_COMMENT
+ // MENUITEM "Calculate checksum", IDM_CRC
+ POPUP "CRC" MY_MENUITEM_ID(0)
+ BEGIN
+ MENUITEM "CRC-32", IDM_CRC32
+ MENUITEM "CRC-64", IDM_CRC64
+ MENUITEM "SHA-1", IDM_SHA1
+ MENUITEM "SHA-256", IDM_SHA256
+ MENUITEM "*", IDM_HASH_ALL
+ END
+ MENUITEM "Di&ff", IDM_DIFF
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "Create Folder\tF7", IDM_CREATE_FOLDER
+ MENUITEM "Create File\tCtrl+N", IDM_CREATE_FILE
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "&Link...", IDM_LINK
+ MENUITEM "&Alternate streams", IDM_ALT_STREAMS
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "E&xit\tAlt+F4", IDCLOSE
+ END
+ POPUP "&Edit" MY_MENUITEM_ID(IDM_EDIT)
+ BEGIN
+ // MENUITEM "Cu&t\tCtrl+X", IDM_EDIT_CUT, GRAYED
+ // MENUITEM "&Copy\tCtrl+C", IDM_EDIT_COPY, GRAYED
+ // MENUITEM "&Paste\tCtrl+V", IDM_EDIT_PASTE, GRAYED
+ // MY_MENUITEM_SEPARATOR
+ MENUITEM "Select &All\tShift+[Grey +]", IDM_SELECT_ALL
+ MENUITEM "Deselect All\tShift+[Grey -]", IDM_DESELECT_ALL
+ MENUITEM "&Invert Selection\tGrey *", IDM_INVERT_SELECTION
+ MENUITEM "Select...\tGrey +", IDM_SELECT
+ MENUITEM "Deselect...\tGrey -", IDM_DESELECT
+ MENUITEM "", 0, MY_MFT_MENUBARBREAK
+ MENUITEM "Select by Type\tAlt+[Grey+]", IDM_SELECT_BY_TYPE
+ MENUITEM "Deselect by Type\tAlt+[Grey -]", IDM_DESELECT_BY_TYPE
+ END
+ POPUP "&View" MY_MENUITEM_ID(IDM_VIEW)
+ BEGIN
+ MENUITEM "Lar&ge Icons\tCtrl+1", IDM_VIEW_LARGE_ICONS
+ MENUITEM "S&mall Icons\tCtrl+2", IDM_VIEW_SMALL_ICONS
+ MENUITEM "&List\tCtrl+3", IDM_VIEW_LIST
+ MENUITEM "&Details\tCtrl+4", IDM_VIEW_DETAILS, MY_MFS_CHECKED
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "Name\tCtrl+F3", IDM_VIEW_ARANGE_BY_NAME
+ MENUITEM "Type\tCtrl+F4", IDM_VIEW_ARANGE_BY_TYPE
+ MENUITEM "Date\tCtrl+F5", IDM_VIEW_ARANGE_BY_DATE
+ MENUITEM "Size\tCtrl+F6", IDM_VIEW_ARANGE_BY_SIZE
+ MENUITEM "Unsorted\tCtrl+F7", IDM_VIEW_ARANGE_NO_SORT
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "Flat View", IDM_VIEW_FLAT_VIEW
+ MENUITEM "&2 Panels\tF9", IDM_VIEW_TWO_PANELS
+
+ POPUP "2017" MY_MENUITEM_ID(IDM_VIEW_TIME_POPUP)
+ BEGIN
+ MENUITEM "Time", IDM_VIEW_TIME
+ END
+
+ POPUP "Toolbars" MY_MENUITEM_ID(IDM_VIEW_TOOLBARS)
+ BEGIN
+ MENUITEM "Archive Toolbar", IDM_VIEW_ARCHIVE_TOOLBAR
+ MENUITEM "Standard Toolbar", IDM_VIEW_STANDARD_TOOLBAR
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "Large Buttons", IDM_VIEW_TOOLBARS_LARGE_BUTTONS
+ MENUITEM "Show Buttons Text", IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT
+ END
+ MENUITEM "Open Root Folder\t\\", IDM_OPEN_ROOT_FOLDER
+ MENUITEM "Up One Level\tBackspace", IDM_OPEN_PARENT_FOLDER
+ MENUITEM "Folders History...\tAlt+F12", IDM_FOLDERS_HISTORY
+ MENUITEM "&Refresh\tCtrl+R", IDM_VIEW_REFRESH
+ MENUITEM "Auto Refresh", IDM_VIEW_AUTO_REFRESH
+
+ // MENUITEM "Show NTFS streams", IDM_VIEW_SHOW_STREAMS
+ // MENUITEM "Show deleted files", IDM_VIEW_SHOW_DELETED
+
+ END
+ POPUP "F&avorites" MY_MENUITEM_ID(IDM_FAVORITES)
+ BEGIN
+ POPUP "&Add folder to Favorites as" MY_MENUITEM_ID(IDM_ADD_TO_FAVORITES)
+ BEGIN
+ MY_MENUITEM_SEPARATOR
+ END
+ MY_MENUITEM_SEPARATOR
+ END
+ POPUP "&Tools" MY_MENUITEM_ID(IDM_TOOLS)
+ BEGIN
+ MENUITEM "&Options...", IDM_OPTIONS
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "&Benchmark", IDM_BENCHMARK
+ #ifdef UNDER_CE
+ MENUITEM "Benchmark 2", IDM_BENCHMARK2
+ #endif
+ #ifndef UNDER_CE
+ END
+ POPUP "&Help" MY_MENUITEM_ID(IDM_HELP)
+ BEGIN
+ MENUITEM "&Contents...\tF1", IDM_HELP_CONTENTS
+ #endif
+ MY_MENUITEM_SEPARATOR
+ MENUITEM "&About 7-Zip...", IDM_ABOUT
+ END
+END
+
+
+IDI_ICON ICON "../../UI/FileManager/FM.ico"
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "../../UI/FileManager/7zFM.exe.manifest"
+#endif
+
+IDB_ADD BITMAP "../../UI/FileManager/Add.bmp"
+IDB_EXTRACT BITMAP "../../UI/FileManager/Extract.bmp"
+IDB_TEST BITMAP "../../UI/FileManager/Test.bmp"
+IDB_COPY BITMAP "../../UI/FileManager/Copy.bmp"
+IDB_MOVE BITMAP "../../UI/FileManager/Move.bmp"
+IDB_DELETE BITMAP "../../UI/FileManager/Delete.bmp"
+IDB_INFO BITMAP "../../UI/FileManager/Info.bmp"
+IDB_ADD2 BITMAP "../../UI/FileManager/Add2.bmp"
+IDB_EXTRACT2 BITMAP "../../UI/FileManager/Extract2.bmp"
+IDB_TEST2 BITMAP "../../UI/FileManager/Test2.bmp"
+IDB_COPY2 BITMAP "../../UI/FileManager/Copy2.bmp"
+IDB_MOVE2 BITMAP "../../UI/FileManager/Move2.bmp"
+IDB_DELETE2 BITMAP "../../UI/FileManager/Delete2.bmp"
+IDB_INFO2 BITMAP "../../UI/FileManager/Info2.bmp"
+
+
+STRINGTABLE
+BEGIN
+ IDS_BOOKMARK "Bookmark"
+
+ IDS_OPTIONS "Options"
+
+ IDS_N_SELECTED_ITEMS "{0} object(s) selected"
+
+ IDS_FILE_EXIST "File {0} is already exist"
+ IDS_WANT_UPDATE_MODIFIED_FILE "File '{0}' was modified.\nDo you want to update it in the archive?"
+ IDS_CANNOT_UPDATE_FILE "Cannot update file\n'{0}'"
+ IDS_CANNOT_START_EDITOR "Cannot start editor."
+ IDS_VIRUS "The file looks like a virus (the file name contains long spaces in name)."
+ IDS_MESSAGE_UNSUPPORTED_OPERATION_FOR_LONG_PATH_FOLDER "The operation cannot be called from a folder that has a long path."
+ IDS_SELECT_ONE_FILE "You must select one file"
+ // IDS_SELECT_FILES "You must select one or more files"
+ IDS_TOO_MANY_ITEMS "Too many items"
+
+ IDS_COPY "Copy"
+ IDS_MOVE "Move"
+ IDS_COPY_TO "Copy to:"
+ IDS_MOVE_TO "Move to:"
+ IDS_COPYING "Copying..."
+ IDS_MOVING "Moving..."
+ IDS_RENAMING "Renaming..."
+
+ IDS_OPERATION_IS_NOT_SUPPORTED "Operation is not supported."
+ IDS_ERROR_RENAMING "Error Renaming File or Folder"
+ IDS_CONFIRM_FILE_COPY "Confirm File Copy"
+ IDS_WANT_TO_COPY_FILES "Are you sure you want to copy files to archive"
+
+ IDS_CONFIRM_FILE_DELETE "Confirm File Delete"
+ IDS_CONFIRM_FOLDER_DELETE "Confirm Folder Delete"
+ IDS_CONFIRM_ITEMS_DELETE "Confirm Multiple File Delete"
+ IDS_WANT_TO_DELETE_FILE "Are you sure you want to delete '{0}'?"
+ IDS_WANT_TO_DELETE_FOLDER "Are you sure you want to delete the folder '{0}' and all its contents?"
+ IDS_WANT_TO_DELETE_ITEMS "Are you sure you want to delete these {0} items?"
+ IDS_DELETING "Deleting..."
+ IDS_ERROR_DELETING "Error Deleting File or Folder"
+ IDS_ERROR_LONG_PATH_TO_RECYCLE "The system cannot move a file with long path to the Recycle Bin"
+
+ IDS_CREATE_FOLDER "Create Folder"
+ IDS_CREATE_FILE "Create File"
+ IDS_CREATE_FOLDER_NAME "Folder name:"
+ IDS_CREATE_FILE_NAME "File Name:"
+ IDS_CREATE_FOLDER_DEFAULT_NAME "New Folder"
+ IDS_CREATE_FILE_DEFAULT_NAME "New File"
+ IDS_CREATE_FOLDER_ERROR "Error Creating Folder"
+ IDS_CREATE_FILE_ERROR "Error Creating File"
+
+ IDS_COMMENT "Comment"
+ IDS_COMMENT2 "&Comment:"
+ IDS_SELECT "Select"
+ IDS_DESELECT "Deselect"
+ IDS_SELECT_MASK "Mask:"
+
+ IDS_PROPERTIES "Properties"
+ IDS_FOLDERS_HISTORY "Folders History"
+
+ IDS_COMPUTER "Computer"
+ IDS_NETWORK "Network"
+ IDS_DOCUMENTS "Documents"
+ IDS_SYSTEM "System"
+
+ IDS_ADD "Add"
+ IDS_EXTRACT "Extract"
+ IDS_TEST "Test"
+ IDS_BUTTON_COPY "Copy"
+ IDS_BUTTON_MOVE "Move"
+ IDS_BUTTON_DELETE "Delete"
+ IDS_BUTTON_INFO "Info"
+
+ IDS_SPLITTING "Splitting..."
+ IDS_SPLIT_CONFIRM_TITLE "Confirm Splitting"
+ IDS_SPLIT_CONFIRM_MESSAGE "Are you sure you want to split file into {0} volumes?"
+ IDS_SPLIT_VOL_MUST_BE_SMALLER "Volume size must be smaller than size of original file"
+
+ IDS_COMBINE "Combine Files"
+ IDS_COMBINE_TO "&Combine to:"
+ IDS_COMBINING "Combining..."
+ IDS_COMBINE_SELECT_ONE_FILE "Select only first part of split file"
+ IDS_COMBINE_CANT_DETECT_SPLIT_FILE "Cannot detect file as split file"
+ IDS_COMBINE_CANT_FIND_MORE_THAN_ONE_PART "Cannot find more than one part of split file"
+
+END
+
+#include "AboutDialog.rc"
+#include "BrowseDialog.rc"
+#include "ComboDialog.rc"
+#include "CopyDialog.rc"
+#include "EditDialog.rc"
+#include "EditPage.rc"
+#include "FoldersPage.rc"
+#include "LangPage.rc"
+#include "LinkDialog.rc"
+#include "ListViewDialog.rc"
+#include "MenuPage.rc"
+#include "MessagesDialog.rc"
+#include "OverwriteDialog.rc"
+#include "PasswordDialog.rc"
+#include "ProgressDialog2.rc"
+#include "PropertyName.rc"
+#include "SettingsPage.rc"
+#include "SplitDialog.rc"
+#include "SystemPage.rc"
+#include "../GUI/Extract.rc"
+#include "../GUI/resource3.rc"
+#include "../Explorer/resource2.rc"
+#include "resourceGui.rc"
diff --git a/CPP/7zip/UI/FileManager/resourceGui.h b/CPP/7zip/UI/FileManager/resourceGui.h
index 025f316..7c1b40e 100644
--- a/CPP/7zip/UI/FileManager/resourceGui.h
+++ b/CPP/7zip/UI/FileManager/resourceGui.h
@@ -1,15 +1,15 @@
-#define IDI_ICON 1
-
-#define IDS_MESSAGE_NO_ERRORS 3001
-
-#define IDS_PROGRESS_TESTING 3302
-#define IDS_OPENNING 3303
-#define IDS_SCANNING 3304
-
-#define IDS_CHECKSUM_CALCULATING 7500
-#define IDS_CHECKSUM_INFORMATION 7501
-#define IDS_CHECKSUM_CRC_DATA 7502
-#define IDS_CHECKSUM_CRC_DATA_NAMES 7503
-#define IDS_CHECKSUM_CRC_STREAMS_NAMES 7504
-
-#define IDS_INCORRECT_VOLUME_SIZE 7307
+#define IDI_ICON 1
+
+#define IDS_MESSAGE_NO_ERRORS 3001
+
+#define IDS_PROGRESS_TESTING 3302
+#define IDS_OPENNING 3303
+#define IDS_SCANNING 3304
+
+#define IDS_CHECKSUM_CALCULATING 7500
+#define IDS_CHECKSUM_INFORMATION 7501
+#define IDS_CHECKSUM_CRC_DATA 7502
+#define IDS_CHECKSUM_CRC_DATA_NAMES 7503
+#define IDS_CHECKSUM_CRC_STREAMS_NAMES 7504
+
+#define IDS_INCORRECT_VOLUME_SIZE 7307
diff --git a/CPP/7zip/UI/FileManager/resourceGui.rc b/CPP/7zip/UI/FileManager/resourceGui.rc
new file mode 100644
index 0000000..f748e0b
--- /dev/null
+++ b/CPP/7zip/UI/FileManager/resourceGui.rc
@@ -0,0 +1,19 @@
+#include "resourceGui.h"
+
+STRINGTABLE
+BEGIN
+ IDS_MESSAGE_NO_ERRORS "There are no errors"
+
+ IDS_PROGRESS_TESTING "Testing"
+
+ IDS_CHECKSUM_CALCULATING "Checksum calculating..."
+ IDS_CHECKSUM_INFORMATION "Checksum information"
+ IDS_CHECKSUM_CRC_DATA "CRC checksum for data:"
+ IDS_CHECKSUM_CRC_DATA_NAMES "CRC checksum for data and names:"
+ IDS_CHECKSUM_CRC_STREAMS_NAMES "CRC checksum for streams and names:"
+
+ IDS_INCORRECT_VOLUME_SIZE "Incorrect volume size"
+
+ IDS_OPENNING "Opening..."
+ IDS_SCANNING "Scanning..."
+END
diff --git a/CPP/7zip/UI/GUI/7zG.exe.manifest b/CPP/7zip/UI/GUI/7zG.exe.manifest
new file mode 100644
index 0000000..ae964d8
--- /dev/null
+++ b/CPP/7zip/UI/GUI/7zG.exe.manifest
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+ <assemblyIdentity version="1.0.0.0" processorArchitecture="*" name="7-Zip.7-Zip.7zG" type="win32"/>
+ <description>7-Zip GUI.</description>
+ <dependency>
+ <dependentAssembly><assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="*" publicKeyToken="6595b64144ccf1df" language="*"/></dependentAssembly>
+ </dependency>
+<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"><application>
+<!-- Vista --> <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
+<!-- Win 7 --> <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+<!-- Win 8 --> <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+<!-- Win 8.1 --> <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+<!-- Win 10 --> <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+</application></compatibility>
+ <asmv3:application>
+ <asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
+ <dpiAware>true</dpiAware>
+ </asmv3:windowsSettings>
+ </asmv3:application>
+<application xmlns="urn:schemas-microsoft-com:asm.v3">
+<windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
+<ws2:longPathAware>true</ws2:longPathAware></windowsSettings></application>
+</assembly>
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.cpp b/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
new file mode 100644
index 0000000..539d689
--- /dev/null
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.cpp
@@ -0,0 +1,1920 @@
+// BenchmarkDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/Defs.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/MyException.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/Synchronization.h"
+#include "../../../Windows/System.h"
+#include "../../../Windows/Thread.h"
+#include "../../../Windows/SystemInfo.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "../../Common/MethodProps.h"
+
+#include "../FileManager/DialogSize.h"
+#include "../FileManager/HelpUtils.h"
+#include "../FileManager/LangUtils.h"
+
+#include "../../MyVersion.h"
+
+#include "../Common/Bench.h"
+
+#include "BenchmarkDialogRes.h"
+#include "BenchmarkDialog.h"
+
+using namespace NWindows;
+
+#define kHelpTopic "fm/benchmark.htm"
+
+static const UINT_PTR kTimerID = 4;
+static const UINT kTimerElapse = 1000; // 1000
+
+// use PRINT_ITER_TIME to show time of each iteration in log box
+// #define PRINT_ITER_TIME
+
+static const unsigned kRatingVector_NumBundlesMax = 20;
+
+enum MyBenchMessages
+{
+ k_Message_Finished = WM_APP + 1
+};
+
+enum My_Message_WPARAM
+{
+ k_Msg_WPARM_Thread_Finished = 0,
+ k_Msg_WPARM_Iter_Finished,
+ k_Msg_WPARM_Enc1_Finished
+};
+
+
+struct CBenchPassResult
+{
+ CTotalBenchRes Enc;
+ CTotalBenchRes Dec;
+ #ifdef PRINT_ITER_TIME
+ DWORD Ticks;
+ #endif
+ // CBenchInfo EncInfo; // for debug
+ // CBenchPassResult() {};
+};
+
+
+struct CTotalBenchRes2: public CTotalBenchRes
+{
+ UInt64 UnpackSize;
+
+ void Init()
+ {
+ CTotalBenchRes::Init();
+ UnpackSize = 0;
+ }
+
+ void SetFrom_BenchInfo(const CBenchInfo &info)
+ {
+ NumIterations2 = 1;
+ Generate_From_BenchInfo(info);
+ UnpackSize = info.Get_UnpackSize_Full();
+ }
+
+ void Update_With_Res2(const CTotalBenchRes2 &r)
+ {
+ Update_With_Res(r);
+ UnpackSize += r.UnpackSize;
+ }
+};
+
+
+struct CSyncData
+{
+ UInt32 NumPasses_Finished;
+
+ // UInt64 NumEncProgress; // for debug
+ // UInt64 NumDecProgress; // for debug
+ // CBenchInfo EncInfo; // for debug
+
+ CTotalBenchRes2 Enc_BenchRes_1;
+ CTotalBenchRes2 Enc_BenchRes;
+
+ CTotalBenchRes2 Dec_BenchRes_1;
+ CTotalBenchRes2 Dec_BenchRes;
+
+ #ifdef PRINT_ITER_TIME
+ DWORD TotalTicks;
+ #endif
+
+ int RatingVector_DeletedIndex;
+ // UInt64 RatingVector_NumDeleted;
+
+ bool BenchWasFinished; // all passes were finished
+ bool NeedPrint_Freq;
+ bool NeedPrint_RatingVector;
+ bool NeedPrint_Enc_1;
+ bool NeedPrint_Enc;
+ bool NeedPrint_Dec_1;
+ bool NeedPrint_Dec;
+ bool NeedPrint_Tot; // intermediate Total was updated after current pass
+
+ void Init();
+};
+
+
+void CSyncData::Init()
+{
+ NumPasses_Finished = 0;
+
+ // NumEncProgress = 0;
+ // NumDecProgress = 0;
+
+ Enc_BenchRes.Init();
+ Enc_BenchRes_1.Init();
+ Dec_BenchRes.Init();
+ Dec_BenchRes_1.Init();
+
+ #ifdef PRINT_ITER_TIME
+ TotalTicks = 0;
+ #endif
+
+ RatingVector_DeletedIndex = -1;
+ // RatingVector_NumDeleted = 0;
+
+ BenchWasFinished =
+ NeedPrint_Freq =
+ NeedPrint_RatingVector =
+ NeedPrint_Enc_1 =
+ NeedPrint_Enc =
+ NeedPrint_Dec_1 =
+ NeedPrint_Dec =
+ NeedPrint_Tot = false;
+}
+
+
+struct CBenchProgressSync
+{
+ bool Exit; // GUI asks BenchThread to Exit, and BenchThread reads that variable
+ UInt32 NumThreads;
+ UInt64 DictSize;
+ UInt32 NumPasses_Limit;
+ int Level;
+
+ // must be written by benchmark thread, read by GUI thread */
+ CSyncData sd;
+ CRecordVector<CBenchPassResult> RatingVector;
+
+ NWindows::NSynchronization::CCriticalSection CS;
+
+ AString Text;
+ bool TextWasChanged;
+
+ /* BenchFinish_Task_HRESULT - for result from benchmark code
+ BenchFinish_Thread_HRESULT - for Exceptions and service errors
+ these arreos must be shown even if user escapes benchmark */
+
+ HRESULT BenchFinish_Task_HRESULT;
+ HRESULT BenchFinish_Thread_HRESULT;
+
+ UInt32 NumFreqThreadsPrev;
+ UString FreqString_Sync;
+ UString FreqString_GUI;
+
+ CBenchProgressSync()
+ {
+ NumPasses_Limit = 1;
+ }
+
+ void Init();
+
+ void SendExit()
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(CS);
+ Exit = true;
+ }
+};
+
+
+void CBenchProgressSync::Init()
+{
+ Exit = false;
+
+ BenchFinish_Task_HRESULT = S_OK;
+ BenchFinish_Thread_HRESULT = S_OK;
+
+ sd.Init();
+ RatingVector.Clear();
+
+ NumFreqThreadsPrev = 0;
+ FreqString_Sync.Empty();
+ FreqString_GUI.Empty();
+
+ Text.Empty();
+ TextWasChanged = true;
+}
+
+
+
+struct CMyFont
+{
+ HFONT _font;
+ CMyFont(): _font(NULL) {}
+ ~CMyFont()
+ {
+ if (_font)
+ DeleteObject(_font);
+ }
+ void Create(const LOGFONT *lplf)
+ {
+ _font = CreateFontIndirect(lplf);
+ }
+};
+
+
+class CBenchmarkDialog;
+
+struct CThreadBenchmark
+{
+ CBenchmarkDialog *BenchmarkDialog;
+ DECL_EXTERNAL_CODECS_LOC_VARS_DECL
+ // HRESULT Result;
+
+ HRESULT Process();
+ static THREAD_FUNC_DECL MyThreadFunction(void *param)
+ {
+ /* ((CThreadBenchmark *)param)->Result = */
+ ((CThreadBenchmark *)param)->Process();
+ return 0;
+ }
+};
+
+
+class CBenchmarkDialog:
+ public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CComboBox m_Dictionary;
+ NWindows::NControl::CComboBox m_NumThreads;
+ NWindows::NControl::CComboBox m_NumPasses;
+ NWindows::NControl::CEdit _consoleEdit;
+ UINT_PTR _timer;
+
+ UInt32 _startTime;
+ UInt32 _finishTime;
+ bool _finishTime_WasSet;
+
+ bool WasStopped_in_GUI;
+ bool ExitWasAsked_in_GUI;
+ bool NeedRestart;
+
+ CMyFont _font;
+
+ UInt64 RamSize;
+ UInt64 RamSize_Limit;
+ bool RamSize_Defined;
+
+ UInt32 NumPasses_Finished_Prev;
+
+ UString ElapsedSec_Prev;
+
+ void InitSyncNew()
+ {
+ NumPasses_Finished_Prev = (UInt32)(Int32)-1;
+ ElapsedSec_Prev.Empty();
+ Sync.Init();
+ }
+
+ virtual bool OnInit() Z7_override;
+ virtual bool OnDestroy() Z7_override;
+ virtual bool OnSize(WPARAM /* wParam */, int xSize, int ySize) Z7_override;
+ virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam) Z7_override;
+ virtual void OnHelp() Z7_override;
+ virtual void OnCancel() Z7_override;
+ virtual bool OnTimer(WPARAM timerID, LPARAM callback) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+
+ void Disable_Stop_Button();
+ void OnStopButton();
+ void RestartBenchmark();
+ void StartBenchmark();
+
+ void UpdateGui();
+
+ void PrintTime();
+ void PrintRating(UInt64 rating, UINT controlID);
+ void PrintUsage(UInt64 usage, UINT controlID);
+ void PrintBenchRes(const CTotalBenchRes2 &info, const UINT ids[]);
+
+ UInt32 GetNumberOfThreads();
+ size_t OnChangeDictionary();
+
+ void SetItemText_Number(unsigned itemID, UInt64 val, LPCTSTR post = NULL);
+ void Print_MemUsage(UString &s, UInt64 memUsage) const;
+ bool IsMemoryUsageOK(UInt64 memUsage) const
+ { return memUsage + (1 << 20) <= RamSize_Limit; }
+
+ void MyKillTimer();
+
+ void SendExit_Status(const wchar_t *message)
+ {
+ SetItemText(IDT_BENCH_ERROR_MESSAGE, message);
+ Sync.SendExit();
+ }
+
+public:
+ CBenchProgressSync Sync;
+
+ bool TotalMode;
+ CObjectVector<CProperty> Props;
+
+ CSysString Bench2Text;
+
+ NWindows::CThread _thread;
+ CThreadBenchmark _threadBenchmark;
+
+ CBenchmarkDialog():
+ _timer(0),
+ WasStopped_in_GUI(false),
+ ExitWasAsked_in_GUI(false),
+ NeedRestart(false),
+ TotalMode(false)
+ {}
+
+ ~CBenchmarkDialog() Z7_DESTRUCTOR_override;
+
+ bool PostMsg_Finish(WPARAM wparam)
+ {
+ if ((HWND)*this)
+ return PostMsg(k_Message_Finished, wparam);
+ // the (HWND)*this is NULL only for some internal code failure
+ return true;
+ }
+
+ INT_PTR Create(HWND wndParent = NULL)
+ {
+ BIG_DIALOG_SIZE(332, 228);
+ return CModalDialog::Create(TotalMode ? IDD_BENCH_TOTAL : SIZED_DIALOG(IDD_BENCH), wndParent);
+ }
+ void MessageBoxError(LPCWSTR message)
+ {
+ MessageBoxW(*this, message, L"7-Zip", MB_ICONERROR);
+ }
+ void MessageBoxError_Status(LPCWSTR message)
+ {
+ UString s ("ERROR: ");
+ s += message;
+ MessageBoxError(s);
+ SetItemText(IDT_BENCH_ERROR_MESSAGE, s);
+ }
+};
+
+
+
+
+
+
+
+
+
+UString HResultToMessage(HRESULT errorCode);
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+ IDT_BENCH_DICTIONARY,
+ IDT_BENCH_MEMORY,
+ IDT_BENCH_NUM_THREADS,
+ IDT_BENCH_SIZE,
+ IDT_BENCH_RATING_LABEL,
+ IDT_BENCH_USAGE_LABEL,
+ IDT_BENCH_RPU_LABEL,
+ IDG_BENCH_COMPRESSING,
+ IDG_BENCH_DECOMPRESSING,
+ IDG_BENCH_TOTAL_RATING,
+ IDT_BENCH_CURRENT,
+ IDT_BENCH_RESULTING,
+ IDT_BENCH_ELAPSED,
+ IDT_BENCH_PASSES,
+ IDB_STOP,
+ IDB_RESTART
+};
+
+static const UInt32 kLangIDs_RemoveColon[] =
+{
+ IDT_BENCH_SPEED
+};
+
+#endif
+
+static LPCTSTR const kProcessingString = TEXT("...");
+static LPCTSTR const kGB = TEXT(" GB");
+static LPCTSTR const kMB = TEXT(" MB");
+static LPCTSTR const kKB = TEXT(" KB");
+// static LPCTSTR const kMIPS = TEXT(" MIPS");
+static LPCTSTR const kKBs = TEXT(" KB/s");
+
+static const unsigned kMinDicLogSize = 18;
+
+static const UInt32 kMinDicSize = (UInt32)1 << kMinDicLogSize;
+static const size_t kMaxDicSize = (size_t)1 << (22 + sizeof(size_t) / 4 * 5);
+// static const size_t kMaxDicSize = (size_t)1 << 16;
+ /*
+ #ifdef MY_CPU_64BIT
+ (UInt32)(Int32)-1; // we can use it, if we want 4 GB buffer
+ // (UInt32)15 << 28;
+ #else
+ (UInt32)1 << 27;
+ #endif
+ */
+
+
+static int ComboBox_Add_UInt32(NWindows::NControl::CComboBox &cb, UInt32 v)
+{
+ TCHAR s[16];
+ ConvertUInt32ToString(v, s);
+ const int index = (int)cb.AddString(s);
+ cb.SetItemData(index, (LPARAM)v);
+ return index;
+}
+
+
+bool CBenchmarkDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_BENCH);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ LangSetDlgItems_RemoveColon(*this, kLangIDs_RemoveColon, Z7_ARRAY_SIZE(kLangIDs_RemoveColon));
+ LangSetDlgItemText(*this, IDT_BENCH_CURRENT2, IDT_BENCH_CURRENT);
+ LangSetDlgItemText(*this, IDT_BENCH_RESULTING2, IDT_BENCH_RESULTING);
+ #endif
+
+ InitSyncNew();
+
+ if (TotalMode)
+ {
+ _consoleEdit.Attach(GetItem(IDE_BENCH2_EDIT));
+ LOGFONT f;
+ memset(&f, 0, sizeof(f));
+ f.lfHeight = 14;
+ f.lfWidth = 0;
+ f.lfWeight = FW_DONTCARE;
+ f.lfCharSet = DEFAULT_CHARSET;
+ f.lfOutPrecision = OUT_DEFAULT_PRECIS;
+ f.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+ f.lfQuality = DEFAULT_QUALITY;
+
+ f.lfPitchAndFamily = FIXED_PITCH;
+ // MyStringCopy(f.lfFaceName, TEXT(""));
+ // f.lfFaceName[0] = 0;
+ _font.Create(&f);
+ if (_font._font)
+ _consoleEdit.SendMsg(WM_SETFONT, (WPARAM)_font._font, TRUE);
+ }
+
+ UInt32 numCPUs = 1;
+
+ {
+ AString s ("/ ");
+
+ NSystem::CProcessAffinity threadsInfo;
+ threadsInfo.InitST();
+
+ #ifndef Z7_ST
+ if (threadsInfo.Get() && threadsInfo.processAffinityMask != 0)
+ numCPUs = threadsInfo.GetNumProcessThreads();
+ else
+ numCPUs = NSystem::GetNumberOfProcessors();
+ #endif
+
+ s.Add_UInt32(numCPUs);
+ s += GetProcessThreadsInfo(threadsInfo);
+ SetItemTextA(IDT_BENCH_HARDWARE_THREADS, s);
+
+ {
+ AString s2;
+ GetSysInfo(s, s2);
+ SetItemTextA(IDT_BENCH_SYS1, s);
+ if (s != s2 && !s2.IsEmpty())
+ SetItemTextA(IDT_BENCH_SYS2, s2);
+ }
+ {
+ GetCpuName_MultiLine(s);
+ SetItemTextA(IDT_BENCH_CPU, s);
+ }
+ {
+ GetOsInfoText(s);
+ s += " : ";
+ AddCpuFeatures(s);
+ SetItemTextA(IDT_BENCH_CPU_FEATURE, s);
+ }
+
+ s = "7-Zip " MY_VERSION_CPU;
+ SetItemTextA(IDT_BENCH_VER, s);
+ }
+
+
+ // ----- Num Threads ----------
+
+ if (numCPUs < 1)
+ numCPUs = 1;
+ numCPUs = MyMin(numCPUs, (UInt32)(1 << 6)); // it's WIN32 limit
+
+ UInt32 numThreads = Sync.NumThreads;
+
+ if (numThreads == (UInt32)(Int32)-1)
+ numThreads = numCPUs;
+ if (numThreads > 1)
+ numThreads &= ~(UInt32)1;
+ const UInt32 kNumThreadsMax = (1 << 12);
+ if (numThreads > kNumThreadsMax)
+ numThreads = kNumThreadsMax;
+
+ m_NumThreads.Attach(GetItem(IDC_BENCH_NUM_THREADS));
+ const UInt32 numTheads_Combo = numCPUs * 2;
+ UInt32 v = 1;
+ int cur = 0;
+ for (; v <= numTheads_Combo;)
+ {
+ int index = ComboBox_Add_UInt32(m_NumThreads, v);
+ const UInt32 vNext = v + (v < 2 ? 1 : 2);
+ if (v <= numThreads)
+ if (numThreads < vNext || vNext > numTheads_Combo)
+ {
+ if (v != numThreads)
+ index = ComboBox_Add_UInt32(m_NumThreads, numThreads);
+ cur = index;
+ }
+ v = vNext;
+ }
+ m_NumThreads.SetCurSel(cur);
+ Sync.NumThreads = GetNumberOfThreads();
+
+
+ // ----- Dictionary ----------
+
+ m_Dictionary.Attach(GetItem(IDC_BENCH_DICTIONARY));
+
+ RamSize = (UInt64)(sizeof(size_t)) << 29;
+ RamSize_Defined = NSystem::GetRamSize(RamSize);
+
+
+ #ifdef UNDER_CE
+ const UInt32 kNormalizedCeSize = (16 << 20);
+ if (RamSize > kNormalizedCeSize && RamSize < (33 << 20))
+ RamSize = kNormalizedCeSize;
+ #endif
+ RamSize_Limit = RamSize / 16 * 15;
+
+ if (Sync.DictSize == (UInt64)(Int64)-1)
+ {
+ unsigned dicSizeLog = 25;
+ #ifdef UNDER_CE
+ dicSizeLog = 20;
+ #endif
+ if (RamSize_Defined)
+ for (; dicSizeLog > kBenchMinDicLogSize; dicSizeLog--)
+ if (IsMemoryUsageOK(GetBenchMemoryUsage(
+ Sync.NumThreads, Sync.Level, (UInt64)1 << dicSizeLog, TotalMode)))
+ break;
+ Sync.DictSize = (UInt64)1 << dicSizeLog;
+ }
+
+ if (Sync.DictSize < kMinDicSize) Sync.DictSize = kMinDicSize;
+ if (Sync.DictSize > kMaxDicSize) Sync.DictSize = kMaxDicSize;
+
+ cur = 0;
+ for (unsigned i = (kMinDicLogSize - 1) * 2; i <= (32 - 1) * 2; i++)
+ {
+ const size_t dict = (size_t)(2 + (i & 1)) << (i / 2);
+ // if (i == (32 - 1) * 2) dict = kMaxDicSize;
+ TCHAR s[32];
+ const TCHAR *post;
+ UInt32 d;
+ if (dict >= ((UInt32)1 << 31)) { d = (UInt32)(dict >> 30); post = kGB; }
+ else if (dict >= ((UInt32)1 << 21)) { d = (UInt32)(dict >> 20); post = kMB; }
+ else { d = (UInt32)(dict >> 10); post = kKB; }
+ ConvertUInt32ToString(d, s);
+ lstrcat(s, post);
+ const int index = (int)m_Dictionary.AddString(s);
+ m_Dictionary.SetItemData(index, (LPARAM)dict);
+ if (dict <= Sync.DictSize)
+ cur = index;
+ if (dict >= kMaxDicSize)
+ break;
+ }
+ m_Dictionary.SetCurSel(cur);
+
+
+ // ----- Num Passes ----------
+
+ m_NumPasses.Attach(GetItem(IDC_BENCH_NUM_PASSES));
+ cur = 0;
+ v = 1;
+ for (;;)
+ {
+ int index = ComboBox_Add_UInt32(m_NumPasses, v);
+ const bool isLast = (v >= 10000000);
+ UInt32 vNext = v * 10;
+ if (v < 2) vNext = 2;
+ else if (v < 5) vNext = 5;
+ else if (v < 10) vNext = 10;
+
+ if (v <= Sync.NumPasses_Limit)
+ if (isLast || Sync.NumPasses_Limit < vNext)
+ {
+ if (v != Sync.NumPasses_Limit)
+ index = ComboBox_Add_UInt32(m_NumPasses, Sync.NumPasses_Limit);
+ cur = index;
+ }
+ v = vNext;
+ if (isLast)
+ break;
+ }
+ m_NumPasses.SetCurSel(cur);
+
+ if (TotalMode)
+ NormalizeSize(true);
+ else
+ NormalizePosition();
+
+ RestartBenchmark();
+
+ return CModalDialog::OnInit();
+}
+
+
+bool CBenchmarkDialog::OnSize(WPARAM /* wParam */, int xSize, int ySize)
+{
+ int mx, my;
+ GetMargins(8, mx, my);
+
+ if (!TotalMode)
+ {
+ RECT rect;
+ GetClientRectOfItem(IDT_BENCH_LOG, rect);
+ int x = xSize - rect.left - mx;
+ int y = ySize - rect.top - my;
+ if (x < 0) x = 0;
+ if (y < 0) y = 0;
+ MoveItem(IDT_BENCH_LOG, rect.left, rect.top, x, y, true);
+ return false;
+ }
+
+ int bx1, bx2, by;
+
+ GetItemSizes(IDCANCEL, bx1, by);
+ GetItemSizes(IDHELP, bx2, by);
+
+ {
+ int y = ySize - my - by;
+ int x = xSize - mx - bx1;
+
+ InvalidateRect(NULL);
+
+ MoveItem(IDCANCEL, x, y, bx1, by);
+ MoveItem(IDHELP, x - mx - bx2, y, bx2, by);
+ }
+
+ if (_consoleEdit)
+ {
+ int yPos = ySize - my - by;
+ RECT rect;
+ GetClientRectOfItem(IDE_BENCH2_EDIT, rect);
+ int y = rect.top;
+ int ySize2 = yPos - my - y;
+ const int kMinYSize = 20;
+ int xx = xSize - mx * 2;
+ if (ySize2 < kMinYSize)
+ {
+ ySize2 = kMinYSize;
+ }
+ _consoleEdit.Move(mx, y, xx, ySize2);
+ }
+ return false;
+}
+
+
+UInt32 CBenchmarkDialog::GetNumberOfThreads()
+{
+ return (UInt32)m_NumThreads.GetItemData_of_CurSel();
+}
+
+
+#define UINT_TO_STR_3(s, val) { \
+ s[0] = (wchar_t)('0' + (val) / 100); \
+ s[1] = (wchar_t)('0' + (val) % 100 / 10); \
+ s[2] = (wchar_t)('0' + (val) % 10); \
+ s += 3; s[0] = 0; }
+
+static WCHAR *NumberToDot3(UInt64 val, WCHAR *s)
+{
+ s = ConvertUInt64ToString(val / 1000, s);
+ const UInt32 rem = (UInt32)(val % 1000);
+ *s++ = '.';
+ UINT_TO_STR_3(s, rem)
+ return s;
+}
+
+void CBenchmarkDialog::SetItemText_Number(unsigned itemID, UInt64 val, LPCTSTR post)
+{
+ TCHAR s[64];
+ ConvertUInt64ToString(val, s);
+ if (post)
+ lstrcat(s, post);
+ SetItemText(itemID, s);
+}
+
+static void AddSize_MB(UString &s, UInt64 size)
+{
+ s.Add_UInt64((size + (1 << 20) - 1) >> 20);
+ s += kMB;
+}
+
+void CBenchmarkDialog::Print_MemUsage(UString &s, UInt64 memUsage) const
+{
+ AddSize_MB(s, memUsage);
+ if (RamSize_Defined)
+ {
+ s += " / ";
+ AddSize_MB(s, RamSize);
+ }
+}
+
+size_t CBenchmarkDialog::OnChangeDictionary()
+{
+ const size_t dict = (size_t)m_Dictionary.GetItemData_of_CurSel();
+ const UInt64 memUsage = GetBenchMemoryUsage(GetNumberOfThreads(),
+ Sync.Level,
+ dict,
+ false); // totalBench mode
+
+ UString s;
+ Print_MemUsage(s, memUsage);
+
+ #ifdef Z7_LARGE_PAGES
+ {
+ AString s2;
+ Add_LargePages_String(s2);
+ if (!s2.IsEmpty())
+ {
+ s.Add_Space();
+ s += s2;
+ }
+ }
+ #endif
+
+ SetItemText(IDT_BENCH_MEMORY_VAL, s);
+
+ return dict;
+}
+
+
+static const UInt32 g_IDs[] =
+{
+ IDT_BENCH_COMPRESS_SIZE1,
+ IDT_BENCH_COMPRESS_SIZE2,
+ IDT_BENCH_COMPRESS_USAGE1,
+ IDT_BENCH_COMPRESS_USAGE2,
+ IDT_BENCH_COMPRESS_SPEED1,
+ IDT_BENCH_COMPRESS_SPEED2,
+ IDT_BENCH_COMPRESS_RATING1,
+ IDT_BENCH_COMPRESS_RATING2,
+ IDT_BENCH_COMPRESS_RPU1,
+ IDT_BENCH_COMPRESS_RPU2,
+
+ IDT_BENCH_DECOMPR_SIZE1,
+ IDT_BENCH_DECOMPR_SIZE2,
+ IDT_BENCH_DECOMPR_SPEED1,
+ IDT_BENCH_DECOMPR_SPEED2,
+ IDT_BENCH_DECOMPR_RATING1,
+ IDT_BENCH_DECOMPR_RATING2,
+ IDT_BENCH_DECOMPR_USAGE1,
+ IDT_BENCH_DECOMPR_USAGE2,
+ IDT_BENCH_DECOMPR_RPU1,
+ IDT_BENCH_DECOMPR_RPU2,
+
+ IDT_BENCH_TOTAL_USAGE_VAL,
+ IDT_BENCH_TOTAL_RATING_VAL,
+ IDT_BENCH_TOTAL_RPU_VAL
+};
+
+
+static const unsigned k_Ids_Enc_1[] = {
+ IDT_BENCH_COMPRESS_USAGE1,
+ IDT_BENCH_COMPRESS_SPEED1,
+ IDT_BENCH_COMPRESS_RPU1,
+ IDT_BENCH_COMPRESS_RATING1,
+ IDT_BENCH_COMPRESS_SIZE1 };
+
+static const unsigned k_Ids_Enc[] = {
+ IDT_BENCH_COMPRESS_USAGE2,
+ IDT_BENCH_COMPRESS_SPEED2,
+ IDT_BENCH_COMPRESS_RPU2,
+ IDT_BENCH_COMPRESS_RATING2,
+ IDT_BENCH_COMPRESS_SIZE2 };
+
+static const unsigned k_Ids_Dec_1[] = {
+ IDT_BENCH_DECOMPR_USAGE1,
+ IDT_BENCH_DECOMPR_SPEED1,
+ IDT_BENCH_DECOMPR_RPU1,
+ IDT_BENCH_DECOMPR_RATING1,
+ IDT_BENCH_DECOMPR_SIZE1 };
+
+static const unsigned k_Ids_Dec[] = {
+ IDT_BENCH_DECOMPR_USAGE2,
+ IDT_BENCH_DECOMPR_SPEED2,
+ IDT_BENCH_DECOMPR_RPU2,
+ IDT_BENCH_DECOMPR_RATING2,
+ IDT_BENCH_DECOMPR_SIZE2 };
+
+static const unsigned k_Ids_Tot[] = {
+ IDT_BENCH_TOTAL_USAGE_VAL,
+ 0,
+ IDT_BENCH_TOTAL_RPU_VAL,
+ IDT_BENCH_TOTAL_RATING_VAL,
+ 0 };
+
+
+void CBenchmarkDialog::MyKillTimer()
+{
+ if (_timer != 0)
+ {
+ KillTimer(kTimerID);
+ _timer = 0;
+ }
+}
+
+
+bool CBenchmarkDialog::OnDestroy()
+{
+ /* actually timer was removed before.
+ also the timer must be removed by Windows, when window will be removed. */
+ MyKillTimer(); // it's optional code
+ return false; // we return (false) to perform default dialog operation
+}
+
+void SetErrorMessage_MemUsage(UString &s, UInt64 reqSize, UInt64 ramSize, UInt64 ramLimit, const UString &usageString);
+
+void CBenchmarkDialog::StartBenchmark()
+{
+ NeedRestart = false;
+ WasStopped_in_GUI = false;
+
+ SetItemText_Empty(IDT_BENCH_ERROR_MESSAGE);
+
+ MyKillTimer(); // optional code. timer was killed before
+
+ const size_t dict = OnChangeDictionary();
+ const UInt32 numThreads = GetNumberOfThreads();
+ const UInt32 numPasses = (UInt32)m_NumPasses.GetItemData_of_CurSel();
+
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_IDs); i++)
+ SetItemText(g_IDs[i], kProcessingString);
+
+ SetItemText_Empty(IDT_BENCH_LOG);
+ SetItemText_Empty(IDT_BENCH_ELAPSED_VAL);
+ SetItemText_Empty(IDT_BENCH_ERROR_MESSAGE);
+
+ const UInt64 memUsage = GetBenchMemoryUsage(numThreads, Sync.Level, dict,
+ false); // totalBench
+ if (!IsMemoryUsageOK(memUsage))
+ {
+ UString s2 = LangString(IDT_BENCH_MEMORY);
+ if (s2.IsEmpty())
+ GetItemText(IDT_BENCH_MEMORY, s2);
+ UString s;
+ SetErrorMessage_MemUsage(s, memUsage, RamSize, RamSize_Limit, s2);
+ MessageBoxError_Status(s);
+ return;
+ }
+
+ EnableItem(IDB_STOP, true);
+
+ _startTime = GetTickCount();
+ _finishTime = _startTime;
+ _finishTime_WasSet = false;
+
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(Sync.CS);
+ InitSyncNew();
+ Sync.DictSize = dict;
+ Sync.NumThreads = numThreads;
+ Sync.NumPasses_Limit = numPasses;
+ }
+
+ PrintTime();
+
+ _timer = SetTimer(kTimerID, kTimerElapse);
+ if (_thread.Create(CThreadBenchmark::MyThreadFunction, &_threadBenchmark) != 0)
+ {
+ MyKillTimer();
+ MessageBoxError_Status(L"Can't create thread");
+ }
+ return;
+}
+
+
+void CBenchmarkDialog::RestartBenchmark()
+{
+ if (ExitWasAsked_in_GUI)
+ return;
+
+ if (_thread.IsCreated())
+ {
+ NeedRestart = true;
+ SendExit_Status(L"Stop for restart ...");
+ }
+ else
+ StartBenchmark();
+}
+
+
+void CBenchmarkDialog::Disable_Stop_Button()
+{
+ // if we disable focused button, then focus will be lost
+ if (GetFocus() == GetItem(IDB_STOP))
+ {
+ // SendMsg_NextDlgCtl_Prev();
+ SendMsg_NextDlgCtl_CtlId(IDB_RESTART);
+ }
+ EnableItem(IDB_STOP, false);
+}
+
+
+void CBenchmarkDialog::OnStopButton()
+{
+ if (ExitWasAsked_in_GUI)
+ return;
+
+ Disable_Stop_Button();
+
+ WasStopped_in_GUI = true;
+ if (_thread.IsCreated())
+ {
+ SendExit_Status(L"Stop ...");
+ }
+}
+
+
+
+void CBenchmarkDialog::OnCancel()
+{
+ ExitWasAsked_in_GUI = true;
+
+ /*
+ SendMsg_NextDlgCtl_Prev();
+ EnableItem(IDCANCEL, false);
+ */
+
+ if (_thread.IsCreated())
+ SendExit_Status(L"Cancel ...");
+ else
+ CModalDialog::OnCancel();
+}
+
+
+void CBenchmarkDialog::OnHelp()
+{
+ ShowHelpWindow(kHelpTopic);
+}
+
+
+
+// void GetTimeString(UInt64 timeValue, wchar_t *s);
+
+void CBenchmarkDialog::PrintTime()
+{
+ const UInt32 curTime =
+ _finishTime_WasSet ?
+ _finishTime :
+ ::GetTickCount();
+
+ const UInt32 elapsedTime = (curTime - _startTime);
+
+ WCHAR s[64];
+
+ WCHAR *p = ConvertUInt32ToString(elapsedTime / 1000, s);
+
+ if (_finishTime_WasSet)
+ {
+ *p++ = '.';
+ UINT_TO_STR_3(p, elapsedTime % 1000)
+ }
+
+ // p = NumberToDot3((UInt64)elapsedTime, s);
+
+ MyStringCopy(p, L" s");
+
+ // if (WasStopped_in_GUI) wcscat(s, L" X"); // for debug
+
+ if (s == ElapsedSec_Prev)
+ return;
+
+ ElapsedSec_Prev = s;
+
+ // static cnt = 0; cnt++; wcscat(s, L" ");
+ // UString s2; s2.Add_UInt32(cnt); wcscat(s, s2.Ptr());
+
+ SetItemText(IDT_BENCH_ELAPSED_VAL, s);
+}
+
+
+static UInt64 GetMips(UInt64 ips)
+{
+ return (ips + 500000) / 1000000;
+}
+
+
+static UInt64 GetUsagePercents(UInt64 usage)
+{
+ return Benchmark_GetUsage_Percents(usage);
+}
+
+
+static UInt32 GetRating(const CTotalBenchRes &info)
+{
+ UInt64 numIter = info.NumIterations2;
+ if (numIter == 0)
+ numIter = 1000000;
+ const UInt64 rating64 = GetMips(info.Rating / numIter);
+ // return rating64;
+ UInt32 rating32 = (UInt32)rating64;
+ if (rating32 != rating64)
+ rating32 = (UInt32)(Int32)-1;
+ return rating32;
+}
+
+
+static void AddUsageString(UString &s, const CTotalBenchRes &info)
+{
+ UInt64 numIter = info.NumIterations2;
+ if (numIter == 0)
+ numIter = 1000000;
+ UInt64 usage = GetUsagePercents(info.Usage / numIter);
+
+ wchar_t w[64];
+ ConvertUInt64ToString(usage, w);
+ unsigned len = MyStringLen(w);
+ while (len < 5)
+ {
+ s.Add_Space();
+ len++;
+ }
+ s += w;
+ s += "%";
+}
+
+
+static void Add_Dot3String(UString &s, UInt64 val)
+{
+ WCHAR temp[32];
+ NumberToDot3(val, temp);
+ s += temp;
+}
+
+
+static void AddRatingString(UString &s, const CTotalBenchRes &info)
+{
+ // AddUsageString(s, info);
+ // s += " ";
+ // s.Add_UInt32(GetRating(info));
+ Add_Dot3String(s, GetRating(info));
+}
+
+
+static void AddRatingsLine(UString &s, const CTotalBenchRes &enc, const CTotalBenchRes &dec
+ #ifdef PRINT_ITER_TIME
+ , DWORD ticks
+ #endif
+ )
+{
+ // AddUsageString(s, enc); s += " ";
+
+ AddRatingString(s, enc);
+ s += " ";
+ AddRatingString(s, dec);
+
+ CTotalBenchRes tot_BenchRes;
+ tot_BenchRes.SetSum(enc, dec);
+
+ s += " ";
+ AddRatingString(s, tot_BenchRes);
+
+ s += " "; AddUsageString(s, tot_BenchRes);
+
+
+ #ifdef PRINT_ITER_TIME
+ s += " ";
+ {
+ Add_Dot3String(s, ticks;
+ s += " s";
+ // s.Add_UInt32(ticks); s += " ms";
+ }
+ #endif
+}
+
+
+void CBenchmarkDialog::PrintRating(UInt64 rating, UINT controlID)
+{
+ // SetItemText_Number(controlID, GetMips(rating), kMIPS);
+ WCHAR s[64];
+ MyStringCopy(NumberToDot3(GetMips(rating), s), L" GIPS");
+ SetItemText(controlID, s);
+}
+
+void CBenchmarkDialog::PrintUsage(UInt64 usage, UINT controlID)
+{
+ SetItemText_Number(controlID, GetUsagePercents(usage), TEXT("%"));
+}
+
+
+// void SetItemText_Number
+
+void CBenchmarkDialog::PrintBenchRes(
+ const CTotalBenchRes2 &info,
+ const UINT ids[])
+{
+ if (info.NumIterations2 == 0)
+ return;
+ if (ids[1] != 0)
+ SetItemText_Number(ids[1], (info.Speed >> 10) / info.NumIterations2, kKBs);
+ PrintRating(info.Rating / info.NumIterations2, ids[3]);
+ PrintRating(info.RPU / info.NumIterations2, ids[2]);
+ PrintUsage(info.Usage / info.NumIterations2, ids[0]);
+ if (ids[4] != 0)
+ {
+ UInt64 val = info.UnpackSize;
+ LPCTSTR kPostfix;
+ if (val >= ((UInt64)1 << 40))
+ {
+ kPostfix = kGB;
+ val >>= 30;
+ }
+ else
+ {
+ kPostfix = kMB;
+ val >>= 20;
+ }
+ SetItemText_Number(ids[4], val, kPostfix);
+ }
+}
+
+
+// static UInt32 k_Message_Finished_cnt = 0;
+// static UInt32 k_OnTimer_cnt = 0;
+
+bool CBenchmarkDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ if (message != k_Message_Finished)
+ return CModalDialog::OnMessage(message, wParam, lParam);
+
+ {
+ if (wParam == k_Msg_WPARM_Thread_Finished)
+ {
+ _finishTime = GetTickCount();
+ _finishTime_WasSet = true;
+ MyKillTimer();
+
+ if (_thread.Wait_Close() != 0)
+ {
+ MessageBoxError_Status(L"Thread Wait Error");
+ }
+
+ if (!WasStopped_in_GUI)
+ {
+ WasStopped_in_GUI = true;
+ Disable_Stop_Button();
+ }
+
+ HRESULT res = Sync.BenchFinish_Thread_HRESULT;
+ if (res != S_OK)
+ // if (!ExitWasAsked_in_GUI || res != E_ABORT)
+ MessageBoxError_Status(HResultToMessage(res));
+
+ if (ExitWasAsked_in_GUI)
+ {
+ // SetItemText(IDT_BENCH_ERROR_MESSAGE, "before CModalDialog::OnCancel()");
+ // Sleep (2000);
+ // MessageBoxError(L"test");
+ CModalDialog::OnCancel();
+ return true;
+ }
+
+ SetItemText_Empty(IDT_BENCH_ERROR_MESSAGE);
+
+ res = Sync.BenchFinish_Task_HRESULT;
+ if (res != S_OK)
+ {
+ if (!WasStopped_in_GUI || res != E_ABORT)
+ {
+ UString m;
+ if (res == S_FALSE)
+ m = "Decoding error";
+ else if (res == CLASS_E_CLASSNOTAVAILABLE)
+ m = "Can't find 7z.dll";
+ else
+ m = HResultToMessage(res);
+ MessageBoxError_Status(m);
+ }
+ }
+
+ if (NeedRestart)
+ {
+ StartBenchmark();
+ return true;
+ }
+ }
+ // k_Message_Finished_cnt++;
+ UpdateGui();
+ return true;
+ }
+}
+
+
+bool CBenchmarkDialog::OnTimer(WPARAM timerID, LPARAM /* callback */)
+{
+ // k_OnTimer_cnt++;
+ if (timerID == kTimerID)
+ UpdateGui();
+ return true;
+}
+
+
+void CBenchmarkDialog::UpdateGui()
+{
+ PrintTime();
+
+ if (TotalMode)
+ {
+ bool wasChanged = false;
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(Sync.CS);
+
+ if (Sync.TextWasChanged)
+ {
+ wasChanged = true;
+ Bench2Text += Sync.Text;
+ Sync.Text.Empty();
+ Sync.TextWasChanged = false;
+ }
+ }
+ if (wasChanged)
+ _consoleEdit.SetText(Bench2Text);
+ return;
+ }
+
+ CSyncData sd;
+ CRecordVector<CBenchPassResult> RatingVector;
+
+ {
+ NWindows::NSynchronization::CCriticalSectionLock lock(Sync.CS);
+ sd = Sync.sd;
+
+ if (sd.NeedPrint_RatingVector)
+ RatingVector = Sync.RatingVector;
+
+ if (sd.NeedPrint_Freq)
+ {
+ Sync.FreqString_GUI = Sync.FreqString_Sync;
+ sd.NeedPrint_RatingVector = true;
+ }
+
+ Sync.sd.NeedPrint_RatingVector = false;
+ Sync.sd.NeedPrint_Enc_1 = false;
+ Sync.sd.NeedPrint_Enc = false;
+ Sync.sd.NeedPrint_Dec_1 = false;
+ Sync.sd.NeedPrint_Dec = false;
+ Sync.sd.NeedPrint_Tot = false;
+ Sync.sd.NeedPrint_Freq = false;
+ }
+
+ if (sd.NumPasses_Finished != NumPasses_Finished_Prev)
+ {
+ SetItemText_Number(IDT_BENCH_PASSES_VAL, sd.NumPasses_Finished, TEXT(" /"));
+ NumPasses_Finished_Prev = sd.NumPasses_Finished;
+ }
+
+ if (sd.NeedPrint_Enc_1) PrintBenchRes(sd.Enc_BenchRes_1, k_Ids_Enc_1);
+ if (sd.NeedPrint_Enc) PrintBenchRes(sd.Enc_BenchRes, k_Ids_Enc);
+ if (sd.NeedPrint_Dec_1) PrintBenchRes(sd.Dec_BenchRes_1, k_Ids_Dec_1);
+ if (sd.NeedPrint_Dec) PrintBenchRes(sd.Dec_BenchRes, k_Ids_Dec);
+
+ if (sd.BenchWasFinished && sd.NeedPrint_Tot)
+ {
+ CTotalBenchRes2 tot_BenchRes = sd.Enc_BenchRes;
+ tot_BenchRes.Update_With_Res2(sd.Dec_BenchRes);
+ PrintBenchRes(tot_BenchRes, k_Ids_Tot);
+ }
+
+
+ if (sd.NeedPrint_RatingVector)
+ // for (unsigned k = 0; k < 1; k++)
+ {
+ UString s;
+ s += Sync.FreqString_GUI;
+ if (!RatingVector.IsEmpty())
+ {
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s += "Compr Decompr Total CPU"
+ #ifdef PRINT_ITER_TIME
+ " Time"
+ #endif
+ ;
+ s.Add_LF();
+ }
+ // s += "GIPS GIPS GIPS % s"; s.Add_LF();
+ for (unsigned i = 0; i < RatingVector.Size(); i++)
+ {
+ if (i != 0)
+ s.Add_LF();
+ if ((int)i == sd.RatingVector_DeletedIndex)
+ {
+ s += "...";
+ s.Add_LF();
+ }
+ const CBenchPassResult &pair = RatingVector[i];
+ /*
+ s += "g:"; s.Add_UInt32((UInt32)pair.EncInfo.GlobalTime);
+ s += " u:"; s.Add_UInt32((UInt32)pair.EncInfo.UserTime);
+ s += " ";
+ */
+ AddRatingsLine(s, pair.Enc, pair.Dec
+ #ifdef PRINT_ITER_TIME
+ , pair.Ticks
+ #endif
+ );
+ /*
+ {
+ UInt64 v = i + 1;
+ if (sd.RatingVector_DeletedIndex >= 0 && i >= (unsigned)sd.RatingVector_DeletedIndex)
+ v += sd.RatingVector_NumDeleted;
+ char temp[64];
+ ConvertUInt64ToString(v, temp);
+ s += " : ";
+ s += temp;
+ }
+ */
+ }
+
+ if (sd.BenchWasFinished)
+ {
+ s.Add_LF();
+ s += "-------------";
+ s.Add_LF();
+ {
+ // average time is not correct because of freq detection in first iteration
+ AddRatingsLine(s, sd.Enc_BenchRes, sd.Dec_BenchRes
+ #ifdef PRINT_ITER_TIME
+ , (DWORD)(sd.TotalTicks / (sd.NumPasses_Finished ? sd.NumPasses_Finished : 1))
+ #endif
+ );
+ }
+ }
+ // s.Add_LF(); s += "OnTimer: "; s.Add_UInt32(k_OnTimer_cnt);
+ // s.Add_LF(); s += "finished Message: "; s.Add_UInt32(k_Message_Finished_cnt);
+ // static cnt = 0; cnt++; s.Add_LF(); s += "Print: "; s.Add_UInt32(cnt);
+ // s.Add_LF(); s += "NumEncProgress: "; s.Add_UInt32((UInt32)sd.NumEncProgress);
+ // s.Add_LF(); s += "NumDecProgress: "; s.Add_UInt32((UInt32)sd.NumDecProgress);
+ SetItemText(IDT_BENCH_LOG, s);
+ }
+}
+
+
+bool CBenchmarkDialog::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+ if (code == CBN_SELCHANGE &&
+ (itemID == IDC_BENCH_DICTIONARY ||
+ itemID == IDC_BENCH_NUM_PASSES ||
+ itemID == IDC_BENCH_NUM_THREADS))
+ {
+ RestartBenchmark();
+ return true;
+ }
+ return CModalDialog::OnCommand(code, itemID, lParam);
+}
+
+
+bool CBenchmarkDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_RESTART:
+ RestartBenchmark();
+ return true;
+ case IDB_STOP:
+ OnStopButton();
+ return true;
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+
+
+
+
+// ---------- Benchmark Thread ----------
+
+struct CBenchCallback Z7_final: public IBenchCallback
+{
+ UInt64 dictionarySize;
+ CBenchProgressSync *Sync;
+ CBenchmarkDialog *BenchmarkDialog;
+
+ HRESULT SetEncodeResult(const CBenchInfo &info, bool final) Z7_override;
+ HRESULT SetDecodeResult(const CBenchInfo &info, bool final) Z7_override;
+};
+
+HRESULT CBenchCallback::SetEncodeResult(const CBenchInfo &info, bool final)
+{
+ bool needPost = false;
+ {
+ NSynchronization::CCriticalSectionLock lock(Sync->CS);
+ if (Sync->Exit)
+ return E_ABORT;
+ CSyncData &sd = Sync->sd;
+ // sd.NumEncProgress++;
+ CTotalBenchRes2 &br = sd.Enc_BenchRes_1;
+ {
+ UInt64 dictSize = Sync->DictSize;
+ if (final)
+ {
+ // sd.EncInfo = info;
+ }
+ else
+ {
+ /* if (!final), then CBenchInfo::NumIterations means totalNumber of threads.
+ so we can reduce the dictionary */
+ if (dictSize > info.UnpackSize)
+ dictSize = info.UnpackSize;
+ }
+ br.Rating = info.GetRating_LzmaEnc(dictSize);
+ }
+ br.SetFrom_BenchInfo(info);
+ sd.NeedPrint_Enc_1 = true;
+ if (final)
+ {
+ sd.Enc_BenchRes.Update_With_Res2(br);
+ sd.NeedPrint_Enc = true;
+ needPost = true;
+ }
+ }
+
+ if (needPost)
+ BenchmarkDialog->PostMsg(k_Message_Finished, k_Msg_WPARM_Enc1_Finished);
+
+ return S_OK;
+}
+
+
+HRESULT CBenchCallback::SetDecodeResult(const CBenchInfo &info, bool final)
+{
+ NSynchronization::CCriticalSectionLock lock(Sync->CS);
+ if (Sync->Exit)
+ return E_ABORT;
+ CSyncData &sd = Sync->sd;
+ // sd.NumDecProgress++;
+ CTotalBenchRes2 &br = sd.Dec_BenchRes_1;
+ br.Rating = info.GetRating_LzmaDec();
+ br.SetFrom_BenchInfo(info);
+ sd.NeedPrint_Dec_1 = true;
+ if (final)
+ sd.Dec_BenchRes.Update_With_Res2(br);
+ return S_OK;
+}
+
+
+struct CBenchCallback2 Z7_final: public IBenchPrintCallback
+{
+ CBenchProgressSync *Sync;
+ bool TotalMode;
+
+ void Print(const char *s) Z7_override;
+ void NewLine() Z7_override;
+ HRESULT CheckBreak() Z7_override;
+};
+
+void CBenchCallback2::Print(const char *s)
+{
+ if (TotalMode)
+ {
+ NSynchronization::CCriticalSectionLock lock(Sync->CS);
+ Sync->Text += s;
+ Sync->TextWasChanged = true;
+ }
+}
+
+void CBenchCallback2::NewLine()
+{
+ Print("\xD\n");
+}
+
+HRESULT CBenchCallback2::CheckBreak()
+{
+ if (Sync->Exit)
+ return E_ABORT;
+ return S_OK;
+}
+
+
+
+struct CFreqCallback Z7_final: public IBenchFreqCallback
+{
+ CBenchmarkDialog *BenchmarkDialog;
+
+ virtual HRESULT AddCpuFreq(unsigned numThreads, UInt64 freq, UInt64 usage) Z7_override;
+ virtual HRESULT FreqsFinished(unsigned numThreads) Z7_override;
+};
+
+HRESULT CFreqCallback::AddCpuFreq(unsigned numThreads, UInt64 freq, UInt64 usage)
+{
+ HRESULT res;
+ {
+ CBenchProgressSync &sync = BenchmarkDialog->Sync;
+ NSynchronization::CCriticalSectionLock lock(sync.CS);
+ UString &s = sync.FreqString_Sync;
+ if (sync.NumFreqThreadsPrev != numThreads)
+ {
+ sync.NumFreqThreadsPrev = numThreads;
+ if (!s.IsEmpty())
+ s.Add_LF();
+ s.Add_UInt32(numThreads);
+ s += "T Frequency (MHz):";
+ s.Add_LF();
+ }
+ s += " ";
+ if (numThreads != 1)
+ {
+ s.Add_UInt64(GetUsagePercents(usage));
+ s += '%';
+ s.Add_Space();
+ }
+ s.Add_UInt64(GetMips(freq));
+ // BenchmarkDialog->Sync.sd.NeedPrint_Freq = true;
+ res = sync.Exit ? E_ABORT : S_OK;
+ }
+ // BenchmarkDialog->PostMsg(k_Message_Finished, k_Msg_WPARM_Enc1_Finished);
+ return res;
+}
+
+HRESULT CFreqCallback::FreqsFinished(unsigned /* numThreads */)
+{
+ HRESULT res;
+ {
+ CBenchProgressSync &sync = BenchmarkDialog->Sync;
+ NSynchronization::CCriticalSectionLock lock(sync.CS);
+ sync.sd.NeedPrint_Freq = true;
+ BenchmarkDialog->PostMsg(k_Message_Finished, k_Msg_WPARM_Enc1_Finished);
+ res = sync.Exit ? E_ABORT : S_OK;
+ }
+ BenchmarkDialog->PostMsg(k_Message_Finished, k_Msg_WPARM_Enc1_Finished);
+ return res;
+}
+
+
+
+// define USE_DUMMY only for debug
+// #define USE_DUMMY
+#ifdef USE_DUMMY
+static unsigned dummy = 1;
+static unsigned Dummy(unsigned limit)
+{
+ unsigned sum = 0;
+ for (unsigned k = 0; k < limit; k++)
+ {
+ sum += dummy;
+ if (sum == 0)
+ break;
+ }
+ return sum;
+}
+#endif
+
+
+HRESULT CThreadBenchmark::Process()
+{
+ /* the first benchmark pass can be slow,
+ if we run benchmark while the window is being created,
+ and (no freq detecion loop) && (dictionary is small) (-mtic is small) */
+
+ // Sleep(300); // for debug
+ #ifdef USE_DUMMY
+ Dummy(1000 * 1000 * 1000); // for debug
+ #endif
+
+ CBenchProgressSync &sync = BenchmarkDialog->Sync;
+ HRESULT finishHRESULT = S_OK;
+
+ try
+ {
+ for (UInt32 passIndex = 0;; passIndex++)
+ {
+ // throw 1; // to debug
+ // throw CSystemException(E_INVALIDARG); // to debug
+
+ UInt64 dictionarySize;
+ UInt32 numThreads;
+ {
+ NSynchronization::CCriticalSectionLock lock(sync.CS);
+ if (sync.Exit)
+ break;
+ dictionarySize = sync.DictSize;
+ numThreads = sync.NumThreads;
+ }
+
+ #ifdef PRINT_ITER_TIME
+ const DWORD startTick = GetTickCount();
+ #endif
+
+ CBenchCallback callback;
+
+ callback.dictionarySize = dictionarySize;
+ callback.Sync = &sync;
+ callback.BenchmarkDialog = BenchmarkDialog;
+
+ CBenchCallback2 callback2;
+ callback2.TotalMode = BenchmarkDialog->TotalMode;
+ callback2.Sync = &sync;
+
+ CFreqCallback freqCallback;
+ freqCallback.BenchmarkDialog = BenchmarkDialog;
+
+ HRESULT result;
+
+ try
+ {
+ CObjectVector<CProperty> props;
+
+ props = BenchmarkDialog->Props;
+
+ if (BenchmarkDialog->TotalMode)
+ {
+ props = BenchmarkDialog->Props;
+ }
+ else
+ {
+ {
+ CProperty prop;
+ prop.Name = "mt";
+ prop.Value.Add_UInt32(numThreads);
+ props.Add(prop);
+ }
+ {
+ CProperty prop;
+ prop.Name = 'd';
+ prop.Name.Add_UInt32((UInt32)(dictionarySize >> 10));
+ prop.Name += 'k';
+ props.Add(prop);
+ }
+ }
+
+ result = Bench(EXTERNAL_CODECS_LOC_VARS
+ BenchmarkDialog->TotalMode ? &callback2 : NULL,
+ BenchmarkDialog->TotalMode ? NULL : &callback,
+ props, 1, false,
+ (!BenchmarkDialog->TotalMode) && passIndex == 0 ? &freqCallback: NULL);
+
+ // result = S_FALSE; // for debug;
+ // throw 1;
+ }
+ catch(...)
+ {
+ result = E_FAIL;
+ }
+
+ #ifdef PRINT_ITER_TIME
+ const DWORD numTicks = GetTickCount() - startTick;
+ #endif
+
+ bool finished = true;
+
+ NSynchronization::CCriticalSectionLock lock(sync.CS);
+
+ if (result != S_OK)
+ {
+ sync.BenchFinish_Task_HRESULT = result;
+ break;
+ }
+
+ {
+ CSyncData &sd = sync.sd;
+
+ sd.NumPasses_Finished++;
+ #ifdef PRINT_ITER_TIME
+ sd.TotalTicks += numTicks;
+ #endif
+
+ if (BenchmarkDialog->TotalMode)
+ break;
+
+ {
+ CTotalBenchRes tot_BenchRes = sd.Enc_BenchRes_1;
+ tot_BenchRes.Update_With_Res(sd.Dec_BenchRes_1);
+
+ sd.NeedPrint_RatingVector = true;
+ {
+ CBenchPassResult pair;
+ // pair.EncInfo = sd.EncInfo; // for debug
+ pair.Enc = sd.Enc_BenchRes_1;
+ pair.Dec = sd.Dec_BenchRes_1;
+ #ifdef PRINT_ITER_TIME
+ pair.Ticks = numTicks;
+ #endif
+ sync.RatingVector.Add(pair);
+ // pair.Dec_Defined = true;
+ }
+ }
+
+ sd.NeedPrint_Dec = true;
+ sd.NeedPrint_Tot = true;
+
+ if (sync.RatingVector.Size() > kRatingVector_NumBundlesMax)
+ {
+ // sd.RatingVector_NumDeleted++;
+ sd.RatingVector_DeletedIndex = (int)(kRatingVector_NumBundlesMax / 4);
+ sync.RatingVector.Delete((unsigned)(sd.RatingVector_DeletedIndex));
+ }
+
+ if (sync.sd.NumPasses_Finished < sync.NumPasses_Limit)
+ finished = false;
+ else
+ {
+ sync.sd.BenchWasFinished = true;
+ // BenchmarkDialog->_finishTime = GetTickCount();
+ // return 0;
+ }
+ }
+
+ if (BenchmarkDialog->TotalMode)
+ break;
+
+ /*
+ if (newTick - prevTick < 1000)
+ numSameTick++;
+ if (numSameTick > 5 || finished)
+ {
+ prevTick = newTick;
+ numSameTick = 0;
+ */
+ // for (unsigned i = 0; i < 1; i++)
+ {
+ // we suppose that PostMsg messages will be processed in order.
+ if (!BenchmarkDialog->PostMsg_Finish(k_Msg_WPARM_Iter_Finished))
+ {
+ finished = true;
+ finishHRESULT = E_FAIL;
+ // throw 1234567;
+ }
+ }
+ if (finished)
+ break;
+ }
+ // return S_OK;
+ }
+ catch(CSystemException &e)
+ {
+ finishHRESULT = e.ErrorCode;
+ // BenchmarkDialog->MessageBoxError(HResultToMessage(e.ErrorCode));
+ // return E_FAIL;
+ }
+ catch(...)
+ {
+ finishHRESULT = E_FAIL;
+ // BenchmarkDialog->MessageBoxError(HResultToMessage(E_FAIL));
+ // return E_FAIL;
+ }
+
+ if (finishHRESULT != S_OK)
+ {
+ NSynchronization::CCriticalSectionLock lock(sync.CS);
+ sync.BenchFinish_Thread_HRESULT = finishHRESULT;
+ }
+ if (!BenchmarkDialog->PostMsg_Finish(k_Msg_WPARM_Thread_Finished))
+ {
+ // sync.BenchFinish_Thread_HRESULT = E_FAIL;
+ }
+ return 0;
+}
+
+
+
+static void ParseNumberString(const UString &s, NCOM::CPropVariant &prop)
+{
+ const wchar_t *end;
+ UInt64 result = ConvertStringToUInt64(s, &end);
+ if (*end != 0 || s.IsEmpty())
+ prop = s;
+ else if (result <= (UInt32)0xFFFFFFFF)
+ prop = (UInt32)result;
+ else
+ prop = result;
+}
+
+
+HRESULT Benchmark(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const CObjectVector<CProperty> &props, UInt32 numIterations, HWND hwndParent)
+{
+ CBenchmarkDialog bd;
+
+ bd.TotalMode = false;
+ bd.Props = props;
+ if (numIterations == 0)
+ numIterations = 1;
+ bd.Sync.NumPasses_Limit = numIterations;
+ bd.Sync.DictSize = (UInt64)(Int64)-1;
+ bd.Sync.NumThreads = (UInt32)(Int32)-1;
+ bd.Sync.Level = -1;
+
+ COneMethodInfo method;
+
+ UInt32 numCPUs = 1;
+ #ifndef Z7_ST
+ numCPUs = NSystem::GetNumberOfProcessors();
+ #endif
+ UInt32 numThreads = numCPUs;
+
+ FOR_VECTOR (i, props)
+ {
+ const CProperty &prop = props[i];
+ UString name = prop.Name;
+ name.MakeLower_Ascii();
+ if (name.IsEqualTo_Ascii_NoCase("m") && prop.Value == L"*")
+ {
+ bd.TotalMode = true;
+ continue;
+ }
+
+ NCOM::CPropVariant propVariant;
+ if (!prop.Value.IsEmpty())
+ ParseNumberString(prop.Value, propVariant);
+ if (name.IsPrefixedBy(L"mt"))
+ {
+ #ifndef Z7_ST
+ RINOK(ParseMtProp(name.Ptr(2), propVariant, numCPUs, numThreads))
+ if (numThreads != numCPUs)
+ bd.Sync.NumThreads = numThreads;
+ #endif
+ continue;
+ }
+ /*
+ if (name.IsEqualTo("time"))
+ {
+ // UInt32 testTime = 4;
+ // RINOK(ParsePropToUInt32(L"", propVariant, testTime));
+ continue;
+ }
+ RINOK(method.ParseMethodFromPROPVARIANT(name, propVariant));
+ */
+ // here we need to parse DictSize property, and ignore unknown properties
+ method.ParseMethodFromPROPVARIANT(name, propVariant);
+ }
+
+ if (bd.TotalMode)
+ {
+ // bd.Bench2Text.Empty();
+ bd.Bench2Text = "7-Zip " MY_VERSION_CPU;
+ bd.Bench2Text += (char)0xD;
+ bd.Bench2Text.Add_LF();
+ }
+
+ {
+ UInt64 dict;
+ if (method.Get_DicSize(dict))
+ bd.Sync.DictSize = dict;
+ }
+ bd.Sync.Level = (int)method.GetLevel();
+
+ // Dummy(1000 * 1000 * 1);
+
+ {
+ CThreadBenchmark &benchmarker = bd._threadBenchmark;
+ #ifdef Z7_EXTERNAL_CODECS
+ benchmarker._externalCodecs = _externalCodecs;
+ #endif
+ benchmarker.BenchmarkDialog = &bd;
+ }
+
+ bd.Create(hwndParent);
+
+ return S_OK;
+}
+
+
+CBenchmarkDialog::~CBenchmarkDialog()
+{
+ if (_thread.IsCreated())
+ {
+ /* the following code will be not executed in normal code flow.
+ it can be called, if there is some internal failure in dialog code. */
+ Attach(NULL);
+ MessageBoxError(L"The flaw in benchmark thread code");
+ Sync.SendExit();
+ _thread.Wait_Close();
+ }
+}
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.h b/CPP/7zip/UI/GUI/BenchmarkDialog.h
new file mode 100644
index 0000000..63c6ded
--- /dev/null
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.h
@@ -0,0 +1,15 @@
+// BenchmarkDialog.h
+
+#ifndef ZIP7_INC_BENCHMARK_DIALOG_H
+#define ZIP7_INC_BENCHMARK_DIALOG_H
+
+#include "../../Common/CreateCoder.h"
+#include "../../UI/Common/Property.h"
+
+const UInt32 k_NumBenchIterations_Default = 10;
+
+HRESULT Benchmark(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const CObjectVector<CProperty> &props, UInt32 numIterations, HWND hwndParent = NULL);
+
+#endif
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialog.rc b/CPP/7zip/UI/GUI/BenchmarkDialog.rc
new file mode 100644
index 0000000..3e73e46
--- /dev/null
+++ b/CPP/7zip/UI/GUI/BenchmarkDialog.rc
@@ -0,0 +1,288 @@
+#include "BenchmarkDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 332
+#define yc 248
+
+#undef g0xs
+#undef g1x
+#undef g1xs
+#undef g2xs
+#undef g3x
+#undef g3xs
+#undef g4x
+
+#define gs 160
+#define gSpace 24
+
+#define g0xs 90
+#define g1xs 48
+#define g1x (m + g0xs)
+#define gc2x (g1x + g1xs + m)
+#define gc2xs 80
+
+#define g4x (m + m)
+
+#define sRating 58
+#define sSpeed 60
+#define sUsage 46
+#define sRpu 58
+#define sSize 52
+// #define sFreq 34
+
+#define xRating (xs - m - m - sRating)
+#define xRpu (xRating - sRpu)
+#define xUsage (xRpu - sUsage)
+#define xSpeed (xUsage - sSpeed)
+#define xSize (xSpeed - sSize)
+
+// #define xFreq (xUsage - sFreq)
+
+#define sLabel (xSize - g4x)
+#define sTotalRating (sUsage + sRpu + sRating + m + m)
+#define xTotalRating (xs - m - sTotalRating)
+
+#define sPasses 60
+
+#define g2xs 60
+#define g3xs 64
+#define g3x (m + g2xs)
+
+#undef GROUP_Y_SIZE
+#undef GROUP_Y2_SIZE
+#ifdef UNDER_CE
+#define GROUP_Y_SIZE 8
+#define GROUP_Y2_SIZE 8
+#else
+#define GROUP_Y_SIZE 40
+#define GROUP_Y2_SIZE 32
+#endif
+
+#define g7xs bx1 - m - g0xs - g1xs - m
+
+#define sLog 140 + 0
+
+// MY_MODAL_DIALOG_STYLE
+IDD_BENCH DIALOG 0, 0, xs + sLog, ys MY_MODAL_RESIZE_DIALOG_STYLE | WS_MINIMIZEBOX
+CAPTION "Benchmark"
+MY_FONT
+BEGIN
+ PUSHBUTTON "&Restart", IDB_RESTART, bx1, m, bxs, bys
+ PUSHBUTTON "&Stop", IDB_STOP, bx1, m + bys + 6, bxs, bys
+
+ PUSHBUTTON "&Help", IDHELP, bx2, by, bxs, bys
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+
+ LTEXT "&Dictionary size:", IDT_BENCH_DICTIONARY, m, m + 1, g0xs, 8
+ COMBOBOX IDC_BENCH_DICTIONARY, g1x, m, g1xs, 140, MY_COMBO
+
+ LTEXT "Memory usage:", IDT_BENCH_MEMORY, gc2x, m - 2, g7xs, 8
+ LTEXT "", IDT_BENCH_MEMORY_VAL, gc2x, m + 8, g7xs, MY_TEXT_NOPREFIX
+
+ LTEXT "&Number of CPU threads:", IDT_BENCH_NUM_THREADS, m, 30, g0xs, 8
+ COMBOBOX IDC_BENCH_NUM_THREADS, g1x, 29, g1xs, 140, MY_COMBO
+ LTEXT "", IDT_BENCH_HARDWARE_THREADS, gc2x, 30, g7xs, MY_TEXT_NOPREFIX
+
+ RTEXT "Size", IDT_BENCH_SIZE, xSize, 54, sSize, MY_TEXT_NOPREFIX
+ RTEXT "CPU Usage", IDT_BENCH_USAGE_LABEL, xUsage, 54, sUsage, MY_TEXT_NOPREFIX
+ RTEXT "Speed", IDT_BENCH_SPEED, xSpeed, 54, sSpeed, MY_TEXT_NOPREFIX
+ RTEXT "Rating / Usage", IDT_BENCH_RPU_LABEL, xRpu, 54, sRpu, MY_TEXT_NOPREFIX
+ RTEXT "Rating", IDT_BENCH_RATING_LABEL, xRating, 54, sRating, MY_TEXT_NOPREFIX
+
+ GROUPBOX "Compressing", IDG_BENCH_COMPRESSING, m, 64, xc, GROUP_Y_SIZE
+
+ LTEXT "Current", IDT_BENCH_CURRENT, g4x, 76, sLabel, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_SIZE1, xSize, 76, sSize, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_USAGE1, xUsage, 76, sUsage, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_SPEED1, xSpeed, 76, sSpeed, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_RPU1, xRpu, 76, sRpu, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_RATING1, xRating, 76, sRating, MY_TEXT_NOPREFIX
+
+ LTEXT "Resulting", IDT_BENCH_RESULTING, g4x, 89, sLabel, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_SIZE2, xSize, 89, sSize, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_USAGE2, xUsage, 89, sUsage, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_SPEED2, xSpeed, 89, sSpeed, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_RPU2, xRpu, 89, sRpu, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_COMPRESS_RATING2, xRating, 89, sRating, MY_TEXT_NOPREFIX
+
+ GROUPBOX "Decompressing", IDG_BENCH_DECOMPRESSING, m, 111, xc, GROUP_Y_SIZE
+
+ LTEXT "Current", IDT_BENCH_CURRENT2, g4x, 123, sLabel, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_SIZE1, xSize, 123, sSize, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_USAGE1, xUsage, 123, sUsage, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_SPEED1, xSpeed, 123, sSpeed, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_RPU1, xRpu, 123, sRpu, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_RATING1, xRating, 123, sRating, MY_TEXT_NOPREFIX
+
+ LTEXT "Resulting", IDT_BENCH_RESULTING2, g4x, 136, sLabel, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_SIZE2, xSize, 136, sSize, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_USAGE2, xUsage, 136, sUsage, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_SPEED2, xSpeed, 136, sSpeed, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_RPU2, xRpu, 136, sRpu, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_DECOMPR_RATING2, xRating, 136, sRating, MY_TEXT_NOPREFIX
+
+ RTEXT "", IDT_BENCH_ERROR_MESSAGE, m, 155, xc, MY_TEXT_NOPREFIX
+
+ GROUPBOX "Total Rating", IDG_BENCH_TOTAL_RATING, xTotalRating, 163, sTotalRating, GROUP_Y2_SIZE
+
+ RTEXT "", IDT_BENCH_TOTAL_USAGE_VAL, xUsage, 176, sUsage, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_TOTAL_RPU_VAL, xRpu, 176, sRpu, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_TOTAL_RATING_VAL, xRating, 176, sRating, MY_TEXT_NOPREFIX
+
+
+ // RTEXT "", IDT_BENCH_CPU, m + sPasses, 202, xc - sPasses, 16, SS_NOPREFIX
+ RTEXT "", IDT_BENCH_CPU, m + 0, 202, xc - 0, 16, SS_NOPREFIX
+ RTEXT "", IDT_BENCH_VER, m + xc - 100, 222, 100, MY_TEXT_NOPREFIX
+
+ LTEXT "", IDT_BENCH_CPU_FEATURE, m, 222, xc - 100, 16, SS_NOPREFIX // - 100
+ LTEXT "", IDT_BENCH_SYS1, m, 238, xc - 140, MY_TEXT_NOPREFIX
+ LTEXT "", IDT_BENCH_SYS2, m, 248, xc - 140, MY_TEXT_NOPREFIX
+
+ LTEXT "", IDT_BENCH_LOG, m + xc + m, m, sLog - m, yc, SS_LEFTNOWORDWRAP | SS_NOPREFIX
+
+
+ LTEXT "Elapsed time:", IDT_BENCH_ELAPSED, m, 163, g2xs, 8
+// LTEXT "Size:", IDT_BENCH_SIZE, m, 176, g2xs, 8
+ LTEXT "Passes:", IDT_BENCH_PASSES, m, 176, g2xs, 8
+ COMBOBOX IDC_BENCH_NUM_PASSES, m, 187, sPasses, 140, MY_COMBO
+
+ RTEXT "", IDT_BENCH_ELAPSED_VAL, g3x, 163, g3xs, MY_TEXT_NOPREFIX
+ // RTEXT "", IDT_BENCH_SIZE_VAL, g3x, 176, g3xs, MY_TEXT_NOPREFIX
+ RTEXT "", IDT_BENCH_PASSES_VAL, g3x, 176, g3xs, MY_TEXT_NOPREFIX
+
+END
+
+#ifdef UNDER_CE
+
+#undef m
+#define m 4
+
+#undef xc
+#undef yc
+
+#define xc 154
+#define yc 160
+
+#undef g0xs
+#undef g1x
+#undef g1xs
+#undef g2xs
+#undef g3x
+#undef g3xs
+
+#undef bxs
+#undef bys
+
+#define bxs 60
+#define bys 14
+
+#undef gs
+#undef gSpace
+
+#define gs 160
+#define gSpace 24
+
+#define g0xs (xc - bxs)
+#define g1xs 44
+
+#undef g4x
+#define g4x (m)
+
+#undef xRpu
+#undef xUsage
+#undef xRating
+#undef xTotalRating
+
+#undef sRpu
+#undef sRating
+#undef sUsage
+#undef sLabel
+#undef sTotalRating
+
+#define sRating 40
+#define sUsage 24
+#define sRpu 40
+
+#define xRating (xs - m - sRating)
+#define xRpu (xRating - sRpu)
+#define xUsage (xRpu - sUsage)
+
+#define sLabel (xUsage - g4x)
+#define sTotalRating (sRpu + sRating)
+#define xTotalRating (xs - m - sTotalRating)
+
+#define g3xs 32
+#define g3x (xRpu - g3xs)
+#define g2xs (g3x - m)
+
+
+IDD_BENCH_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE | WS_MINIMIZEBOX
+CAPTION "Benchmark"
+MY_FONT
+BEGIN
+ PUSHBUTTON "&Restart", IDB_RESTART, bx1, m, bxs, bys
+ PUSHBUTTON "&Stop", IDB_STOP, bx1, m + bys + m, bxs, bys
+
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+
+ LTEXT "&Dictionary size:", IDT_BENCH_DICTIONARY, m, m, g0xs, 8
+ COMBOBOX IDC_BENCH_DICTIONARY, m, m + 11, g1xs, 140, MY_COMBO
+
+ LTEXT "&Number of CPU threads:", IDT_BENCH_NUM_THREADS, m, 31, g0xs, 8
+ COMBOBOX IDC_BENCH_NUM_THREADS, m, 42, g1xs, 140, MY_COMBO
+
+ LTEXT "", IDT_BENCH_MEMORY_VAL, m + g1xs + 8, m + 13, xc - bxs - g1xs - 8, 8
+ LTEXT "", IDT_BENCH_HARDWARE_THREADS, m + g1xs + 8, 44, xc - bxs - g1xs - 8, 8
+
+ LTEXT "Current", IDT_BENCH_CURRENT, g4x, 70, sLabel, 8
+ RTEXT "", IDT_BENCH_COMPRESS_USAGE1, xUsage, 70, sUsage, 8
+ RTEXT "", IDT_BENCH_COMPRESS_RPU1, xRpu, 70, sRpu, 8
+ RTEXT "", IDT_BENCH_COMPRESS_RATING1, xRating, 70, sRating, 8
+
+ LTEXT "Resulting", IDT_BENCH_RESULTING, g4x, 80, sLabel, 8
+ RTEXT "", IDT_BENCH_COMPRESS_USAGE2, xUsage, 80, sUsage, 8
+ RTEXT "", IDT_BENCH_COMPRESS_RPU2, xRpu, 80, sRpu, 8
+ RTEXT "", IDT_BENCH_COMPRESS_RATING2, xRating, 80, sRating, 8
+
+ LTEXT "Compressing", IDG_BENCH_COMPRESSING, m, 60, xc - bxs, 8
+
+ LTEXT "Current", IDT_BENCH_CURRENT2, g4x, 104, sLabel, 8
+ RTEXT "", IDT_BENCH_DECOMPR_USAGE1, xUsage, 104, sUsage, 8
+ RTEXT "", IDT_BENCH_DECOMPR_RPU1, xRpu, 104, sRpu, 8
+ RTEXT "", IDT_BENCH_DECOMPR_RATING1, xRating, 104, sRating, 8
+
+ LTEXT "Resulting", IDT_BENCH_RESULTING2, g4x, 114, sLabel, 8
+ RTEXT "", IDT_BENCH_DECOMPR_USAGE2, xUsage, 114, sUsage, 8
+ RTEXT "", IDT_BENCH_DECOMPR_RPU2, xRpu, 114, sRpu, 8
+ RTEXT "", IDT_BENCH_DECOMPR_RATING2, xRating, 114, sRating, 8
+
+ LTEXT "Decompressing", IDG_BENCH_DECOMPRESSING, m, 94, xc, 8
+
+ RTEXT "", IDT_BENCH_TOTAL_RPU_VAL, xRpu, 140, sRpu, 8
+ RTEXT "", IDT_BENCH_TOTAL_RATING_VAL, xRating, 140, sRating, 8
+
+ LTEXT "Elapsed time:", IDT_BENCH_ELAPSED, m, 130, g2xs, 8
+ LTEXT "Size:", IDT_BENCH_SIZE, m, 140, g2xs, 8
+ LTEXT "Passes:", IDT_BENCH_PASSES, m, 150, g2xs, 8
+
+ RTEXT "", IDT_BENCH_ELAPSED_VAL, g3x, 130, g3xs, 8
+ RTEXT "", IDT_BENCH_SIZE_VAL, g3x, 140, g3xs, 8
+ RTEXT "", IDT_BENCH_PASSES_VAL, g3x, 150, g3xs, 8
+END
+
+#endif
+
+#include "../../GuiCommon.rc"
+
+#define xc 360
+#define yc 260
+
+IDD_BENCH_TOTAL DIALOG 0, 0, xs, ys MY_MODAL_RESIZE_DIALOG_STYLE MY_FONT
+CAPTION "Benchmark"
+{
+ LTEXT "Elapsed time:", IDT_BENCH_ELAPSED, m, m, 58, 8
+ RTEXT "", IDT_BENCH_ELAPSED_VAL, m + 58, m, 38, 8
+ EDITTEXT IDE_BENCH2_EDIT, m, m + 14, xc, yc - bys - m - 14, ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL | WS_VSCROLL | WS_HSCROLL
+ PUSHBUTTON "&Help", IDHELP, bx2, by, bxs, bys
+ PUSHBUTTON "Cancel", IDCANCEL, bx1, by, bxs, bys
+}
diff --git a/CPP/7zip/UI/GUI/BenchmarkDialogRes.h b/CPP/7zip/UI/GUI/BenchmarkDialogRes.h
new file mode 100644
index 0000000..b7d54b7
--- /dev/null
+++ b/CPP/7zip/UI/GUI/BenchmarkDialogRes.h
@@ -0,0 +1,79 @@
+#define IDD_BENCH 7600
+#define IDD_BENCH_2 17600
+#define IDD_BENCH_TOTAL 7699
+
+#define IDE_BENCH2_EDIT 100
+
+#define IDC_BENCH_DICTIONARY 101
+#define IDT_BENCH_MEMORY_VAL 102
+#define IDC_BENCH_NUM_THREADS 103
+#define IDT_BENCH_HARDWARE_THREADS 104
+
+#define IDT_BENCH_VER 105
+#define IDT_BENCH_CPU 106
+#define IDT_BENCH_SYS1 107
+#define IDT_BENCH_SYS2 108
+#define IDT_BENCH_CPU_FEATURE 109
+
+#define IDT_BENCH_COMPRESS_SPEED1 110
+#define IDT_BENCH_COMPRESS_SPEED2 111
+#define IDT_BENCH_COMPRESS_RATING1 112
+#define IDT_BENCH_COMPRESS_RATING2 113
+#define IDT_BENCH_COMPRESS_USAGE1 114
+#define IDT_BENCH_COMPRESS_USAGE2 115
+#define IDT_BENCH_COMPRESS_RPU1 116
+#define IDT_BENCH_COMPRESS_RPU2 117
+
+#define IDT_BENCH_DECOMPR_SPEED1 118
+#define IDT_BENCH_DECOMPR_SPEED2 119
+#define IDT_BENCH_DECOMPR_RATING1 120
+#define IDT_BENCH_DECOMPR_RATING2 121
+#define IDT_BENCH_DECOMPR_USAGE1 122
+#define IDT_BENCH_DECOMPR_USAGE2 123
+#define IDT_BENCH_DECOMPR_RPU1 124
+#define IDT_BENCH_DECOMPR_RPU2 125
+
+#define IDT_BENCH_TOTAL_RATING_VAL 130
+#define IDT_BENCH_TOTAL_RPU_VAL 131
+#define IDT_BENCH_TOTAL_USAGE_VAL 133
+
+#define IDT_BENCH_ELAPSED_VAL 140
+// #define IDT_BENCH_SIZE_VAL 141
+#define IDT_BENCH_PASSES_VAL 142
+#define IDC_BENCH_NUM_PASSES 143
+
+#define IDT_BENCH_LOG 160
+#define IDT_BENCH_ERROR_MESSAGE 161
+
+#define IDT_BENCH_COMPRESS_SIZE1 170
+#define IDT_BENCH_COMPRESS_SIZE2 171
+#define IDT_BENCH_DECOMPR_SIZE1 172
+#define IDT_BENCH_DECOMPR_SIZE2 173
+
+// #define IDT_BENCH_FREQ_CUR 150
+// #define IDT_BENCH_FREQ_RES 151
+
+#define IDB_STOP 442
+#define IDB_RESTART 443
+
+#define IDT_BENCH_DICTIONARY 4006
+#define IDT_BENCH_NUM_THREADS 4009
+
+#define IDT_BENCH_SIZE 1007
+#define IDT_BENCH_ELAPSED 3900
+#define IDT_BENCH_SPEED 3903
+
+#define IDT_BENCH_MEMORY 7601
+
+#define IDG_BENCH_COMPRESSING 7602
+#define IDG_BENCH_DECOMPRESSING 7603
+#define IDG_BENCH_TOTAL_RATING 7605
+
+#define IDT_BENCH_RATING_LABEL 7604
+#define IDT_BENCH_CURRENT 7606
+#define IDT_BENCH_RESULTING 7607
+#define IDT_BENCH_USAGE_LABEL 7608
+#define IDT_BENCH_RPU_LABEL 7609
+#define IDT_BENCH_PASSES 7610
+#define IDT_BENCH_CURRENT2 (7606+50)
+#define IDT_BENCH_RESULTING2 (7607+50)
diff --git a/CPP/7zip/UI/GUI/CompressDialog.cpp b/CPP/7zip/UI/GUI/CompressDialog.cpp
new file mode 100644
index 0000000..c2aee6c
--- /dev/null
+++ b/CPP/7zip/UI/GUI/CompressDialog.cpp
@@ -0,0 +1,3820 @@
+// CompressDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/System.h"
+
+#include "../../Common/MethodProps.h"
+
+#include "../FileManager/BrowseDialog.h"
+#include "../FileManager/FormatUtils.h"
+#include "../FileManager/HelpUtils.h"
+#include "../FileManager/PropertyName.h"
+#include "../FileManager/SplitUtils.h"
+
+#include "../Explorer/MyMessages.h"
+
+#include "../Common/ZipRegistry.h"
+
+#include "CompressDialog.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+#include "../FileManager/LangUtils.h"
+
+#include "CompressDialogRes.h"
+#include "ExtractRes.h"
+#include "resource2.h"
+
+// #define PRINT_PARAMS
+
+#ifdef Z7_LANG
+
+// #define IDS_OPTIONS 2100
+
+static const UInt32 kLangIDs[] =
+{
+ IDT_COMPRESS_ARCHIVE,
+ IDT_COMPRESS_UPDATE_MODE,
+ IDT_COMPRESS_FORMAT,
+ IDT_COMPRESS_LEVEL,
+ IDT_COMPRESS_METHOD,
+ IDT_COMPRESS_DICTIONARY,
+ IDT_COMPRESS_ORDER,
+ IDT_COMPRESS_SOLID,
+ IDT_COMPRESS_THREADS,
+ IDT_COMPRESS_PARAMETERS,
+
+ IDB_COMPRESS_OPTIONS, // IDS_OPTIONS
+
+ IDG_COMPRESS_OPTIONS,
+ IDX_COMPRESS_SFX,
+ IDX_COMPRESS_SHARED,
+ IDX_COMPRESS_DEL,
+
+ IDT_COMPRESS_MEMORY,
+ IDT_COMPRESS_MEMORY_DE,
+
+ IDG_COMPRESS_ENCRYPTION,
+ IDT_COMPRESS_ENCRYPTION_METHOD,
+ IDX_COMPRESS_ENCRYPT_FILE_NAMES,
+
+ IDT_PASSWORD_ENTER,
+ IDT_PASSWORD_REENTER,
+ IDX_PASSWORD_SHOW,
+
+ IDT_SPLIT_TO_VOLUMES,
+ IDT_COMPRESS_PATH_MODE,
+};
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+using namespace NDir;
+
+static const unsigned kHistorySize = 20;
+
+static const UInt32 kSolidLog_NoSolid = 0;
+static const UInt32 kSolidLog_FullSolid = 64;
+
+static const UInt32 kLzmaMaxDictSize = (UInt32)15 << 28;
+
+static const UINT k_Message_ArcChanged = WM_APP + 1;
+
+/*
+static const UInt32 kZstd_MAX_DictSize = (UInt32)1 << MY_ZSTD_WINDOWLOG_MAX;
+*/
+
+/* The top value for windowLog_Chain:
+ (MY_ZSTD_CHAINLOG_MAX - 1): in BT mode
+ (MY_ZSTD_CHAINLOG_MAX) : in non-BT mode. But such big value is useless in most cases.
+ So we always reduce top value to (MY_ZSTD_CHAINLOG_MAX - 1) */
+/*
+static const unsigned kMaxDictChain = MY_ZSTD_CHAINLOG_MAX - 1;
+static const UInt32 kZstd_MAX_DictSize_Chain = (UInt32)1 << kMaxDictChain;
+*/
+
+static LPCSTR const kExeExt = ".exe";
+
+static const UInt32 g_Levels[] =
+{
+ IDS_METHOD_STORE,
+ IDS_METHOD_FASTEST,
+ 0,
+ IDS_METHOD_FAST,
+ 0,
+ IDS_METHOD_NORMAL,
+ 0,
+ IDS_METHOD_MAXIMUM,
+ 0,
+ IDS_METHOD_ULTRA
+};
+
+enum EMethodID
+{
+ kCopy,
+ kLZMA,
+ kLZMA2,
+ kPPMd,
+ kBZip2,
+ kDeflate,
+ kDeflate64,
+ kPPMdZip,
+ // kZSTD,
+ kSha256,
+ kSha1,
+ kCrc32,
+ kCrc64,
+ kGnu,
+ kPosix
+};
+
+static LPCSTR const kMethodsNames[] =
+{
+ "Copy"
+ , "LZMA"
+ , "LZMA2"
+ , "PPMd"
+ , "BZip2"
+ , "Deflate"
+ , "Deflate64"
+ , "PPMd"
+ // , "ZSTD"
+ , "SHA256"
+ , "SHA1"
+ , "CRC32"
+ , "CRC64"
+ , "GNU"
+ , "POSIX"
+};
+
+static const EMethodID g_7zMethods[] =
+{
+ kLZMA2,
+ kLZMA,
+ kPPMd,
+ kBZip2
+ , kDeflate
+ , kDeflate64
+ // , kZSTD
+ , kCopy
+};
+
+static const EMethodID g_7zSfxMethods[] =
+{
+ kCopy,
+ kLZMA,
+ kLZMA2,
+ kPPMd
+};
+
+static const EMethodID g_ZipMethods[] =
+{
+ kDeflate,
+ kDeflate64,
+ kBZip2,
+ kLZMA,
+ kPPMdZip
+ // , kZSTD
+};
+
+static const EMethodID g_GZipMethods[] =
+{
+ kDeflate
+};
+
+static const EMethodID g_BZip2Methods[] =
+{
+ kBZip2
+};
+
+static const EMethodID g_XzMethods[] =
+{
+ kLZMA2
+};
+
+/*
+static const EMethodID g_ZstdMethods[] =
+{
+ kZSTD
+};
+*/
+
+static const EMethodID g_SwfcMethods[] =
+{
+ kDeflate
+ // kLZMA
+};
+
+static const EMethodID g_TarMethods[] =
+{
+ kGnu,
+ kPosix
+};
+
+static const EMethodID g_HashMethods[] =
+{
+ kSha256
+ , kSha1
+ // , kCrc32
+ // , kCrc64
+};
+
+static const UInt32 kFF_Filter = 1 << 0;
+static const UInt32 kFF_Solid = 1 << 1;
+static const UInt32 kFF_MultiThread = 1 << 2;
+static const UInt32 kFF_Encrypt = 1 << 3;
+static const UInt32 kFF_EncryptFileNames = 1 << 4;
+static const UInt32 kFF_MemUse = 1 << 5;
+static const UInt32 kFF_SFX = 1 << 6;
+
+/*
+static const UInt32 kFF_Time_Win = 1 << 10;
+static const UInt32 kFF_Time_Unix = 1 << 11;
+static const UInt32 kFF_Time_DOS = 1 << 12;
+static const UInt32 kFF_Time_1ns = 1 << 13;
+*/
+
+struct CFormatInfo
+{
+ LPCSTR Name;
+ UInt32 LevelsMask;
+ unsigned NumMethods;
+ const EMethodID *MethodIDs;
+
+ UInt32 Flags;
+
+ bool Filter_() const { return (Flags & kFF_Filter) != 0; }
+ bool Solid_() const { return (Flags & kFF_Solid) != 0; }
+ bool MultiThread_() const { return (Flags & kFF_MultiThread) != 0; }
+ bool Encrypt_() const { return (Flags & kFF_Encrypt) != 0; }
+ bool EncryptFileNames_() const { return (Flags & kFF_EncryptFileNames) != 0; }
+ bool MemUse_() const { return (Flags & kFF_MemUse) != 0; }
+ bool SFX_() const { return (Flags & kFF_SFX) != 0; }
+};
+
+#define METHODS_PAIR(x) Z7_ARRAY_SIZE(x), x
+
+static const CFormatInfo g_Formats[] =
+{
+ {
+ "",
+ // (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+ ((UInt32)1 << 10) - 1,
+ // (UInt32)(Int32)-1,
+ 0, NULL,
+ kFF_MultiThread | kFF_MemUse
+ },
+ {
+ "7z",
+ (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+ METHODS_PAIR(g_7zMethods),
+ kFF_Filter | kFF_Solid | kFF_MultiThread | kFF_Encrypt |
+ kFF_EncryptFileNames | kFF_MemUse | kFF_SFX
+ // | kFF_Time_Win
+ },
+ {
+ "Zip",
+ (1 << 0) | (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+ METHODS_PAIR(g_ZipMethods),
+ kFF_MultiThread | kFF_Encrypt | kFF_MemUse
+ // | kFF_Time_Win | kFF_Time_Unix | kFF_Time_DOS
+ },
+ {
+ "GZip",
+ (1 << 1) | (1 << 5) | (1 << 7) | (1 << 9),
+ METHODS_PAIR(g_GZipMethods),
+ kFF_MemUse
+ // | kFF_Time_Unix
+ },
+ {
+ "BZip2",
+ (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+ METHODS_PAIR(g_BZip2Methods),
+ kFF_MultiThread | kFF_MemUse
+ },
+ {
+ "xz",
+ (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+ METHODS_PAIR(g_XzMethods),
+ kFF_Solid | kFF_MultiThread | kFF_MemUse
+ },
+ /*
+ {
+ "zstd",
+ // (1 << (MY_ZSTD_LEVEL_MAX + 1)) - 1,
+ (1 << (9 + 1)) - 1,
+ METHODS_PAIR(g_ZstdMethods),
+ // kFF_Solid |
+ kFF_MultiThread
+ | kFF_MemUse
+ },
+ */
+ {
+ "Swfc",
+ (1 << 1) | (1 << 3) | (1 << 5) | (1 << 7) | (1 << 9),
+ METHODS_PAIR(g_SwfcMethods),
+ 0
+ },
+ {
+ "Tar",
+ (1 << 0),
+ METHODS_PAIR(g_TarMethods),
+ 0
+ // kFF_Time_Unix | kFF_Time_Win // | kFF_Time_1ns
+ },
+ {
+ "wim",
+ (1 << 0),
+ 0, NULL,
+ 0
+ // | kFF_Time_Win
+ },
+ {
+ "Hash",
+ (0 << 0),
+ METHODS_PAIR(g_HashMethods),
+ 0
+ }
+};
+
+static bool IsMethodSupportedBySfx(int methodID)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_7zSfxMethods); i++)
+ if (methodID == g_7zSfxMethods[i])
+ return true;
+ return false;
+}
+
+
+static const
+ // NCompressDialog::NUpdateMode::EEnum
+ int
+ k_UpdateMode_Vals[] =
+{
+ NCompressDialog::NUpdateMode::kAdd,
+ NCompressDialog::NUpdateMode::kUpdate,
+ NCompressDialog::NUpdateMode::kFresh,
+ NCompressDialog::NUpdateMode::kSync
+};
+
+static const UInt32 k_UpdateMode_IDs[] =
+{
+ IDS_COMPRESS_UPDATE_MODE_ADD,
+ IDS_COMPRESS_UPDATE_MODE_UPDATE,
+ IDS_COMPRESS_UPDATE_MODE_FRESH,
+ IDS_COMPRESS_UPDATE_MODE_SYNC
+};
+
+static const
+ // NWildcard::ECensorPathMode
+ int
+ k_PathMode_Vals[] =
+{
+ NWildcard::k_RelatPath,
+ NWildcard::k_FullPath,
+ NWildcard::k_AbsPath,
+};
+
+static const UInt32 k_PathMode_IDs[] =
+{
+ IDS_PATH_MODE_RELAT,
+ IDS_EXTRACT_PATHS_FULL,
+ IDS_EXTRACT_PATHS_ABS
+};
+
+void AddComboItems(NControl::CComboBox &combo, const UInt32 *langIDs, unsigned numItems, const int *values, int curVal);
+
+void CCompressDialog::SetMethods(const CObjectVector<CCodecInfoUser> &userCodecs)
+{
+ ExternalMethods.Clear();
+ {
+ FOR_VECTOR (i, userCodecs)
+ {
+ const CCodecInfoUser &c = userCodecs[i];
+ if (!c.EncoderIsAssigned
+ || !c.IsFilter_Assigned
+ || c.IsFilter
+ || c.NumStreams != 1)
+ continue;
+ unsigned k;
+ for (k = 0; k < Z7_ARRAY_SIZE(g_7zMethods); k++)
+ if (c.Name.IsEqualTo_Ascii_NoCase(kMethodsNames[g_7zMethods[k]]))
+ break;
+ if (k != Z7_ARRAY_SIZE(g_7zMethods))
+ continue;
+ ExternalMethods.Add(c.Name);
+ }
+ }
+}
+
+
+bool CCompressDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDD_COMPRESS);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ // LangSetDlgItemText(*this, IDB_COMPRESS_OPTIONS, IDS_OPTIONS); // IDG_COMPRESS_OPTIONS
+ #endif
+
+ {
+ UInt64 size = (UInt64)(sizeof(size_t)) << 29;
+ _ramSize_Defined = NSystem::GetRamSize(size);
+ // size = (UInt64)3 << 62; // for debug only;
+ _ramSize = size;
+ const UInt64 kMinUseSize = (1 << 26);
+ if (size < kMinUseSize)
+ size = kMinUseSize;
+
+ unsigned bits = sizeof(size_t) * 8;
+ if (bits == 32)
+ {
+ const UInt32 limit2 = (UInt32)7 << 28;
+ if (size > limit2)
+ size = limit2;
+ }
+
+ _ramSize_Reduced = size;
+
+ // 80% - is auto usage limit in handlers
+ _ramUsage_Auto = Calc_From_Val_Percents(size, 80);
+ }
+
+ _password1Control.Attach(GetItem(IDE_COMPRESS_PASSWORD1));
+ _password2Control.Attach(GetItem(IDE_COMPRESS_PASSWORD2));
+ _password1Control.SetText(Info.Password);
+ _password2Control.SetText(Info.Password);
+ _encryptionMethod.Attach(GetItem(IDC_COMPRESS_ENCRYPTION_METHOD));
+ _default_encryptionMethod_Index = -1;
+
+ m_ArchivePath.Attach(GetItem(IDC_COMPRESS_ARCHIVE));
+ m_Format.Attach(GetItem(IDC_COMPRESS_FORMAT)); // that combo has CBS_SORT style in resources
+ m_Level.Attach(GetItem(IDC_COMPRESS_LEVEL));
+ m_Method.Attach(GetItem(IDC_COMPRESS_METHOD));
+ m_Dictionary.Attach(GetItem(IDC_COMPRESS_DICTIONARY));
+
+ /*
+ {
+ RECT r;
+ GetClientRectOfItem(IDC_COMPRESS_DICTIONARY, r);
+ _dictionaryCombo_left = r.left;
+ }
+ */
+ _dictionaryCombo_left = 0; // 230;
+
+ // m_Dictionary_Chain.Attach(GetItem(IDC_COMPRESS_DICTIONARY2));
+ m_Order.Attach(GetItem(IDC_COMPRESS_ORDER));
+ m_Solid.Attach(GetItem(IDC_COMPRESS_SOLID));
+ m_NumThreads.Attach(GetItem(IDC_COMPRESS_THREADS));
+ m_MemUse.Attach(GetItem(IDC_COMPRESS_MEM_USE));
+
+ m_UpdateMode.Attach(GetItem(IDC_COMPRESS_UPDATE_MODE));
+ m_PathMode.Attach(GetItem(IDC_COMPRESS_PATH_MODE));
+
+ m_Volume.Attach(GetItem(IDC_COMPRESS_VOLUME));
+ m_Params.Attach(GetItem(IDE_COMPRESS_PARAMETERS));
+
+ AddVolumeItems(m_Volume);
+
+ m_RegistryInfo.Load();
+ CheckButton(IDX_PASSWORD_SHOW, m_RegistryInfo.ShowPassword);
+ CheckButton(IDX_COMPRESS_ENCRYPT_FILE_NAMES, m_RegistryInfo.EncryptHeaders);
+
+ UpdatePasswordControl();
+
+ {
+ const bool needSetMain = (Info.FormatIndex < 0);
+ FOR_VECTOR(i, ArcIndices)
+ {
+ const unsigned arcIndex = ArcIndices[i];
+ const CArcInfoEx &ai = (*ArcFormats)[arcIndex];
+ const int index = (int)m_Format.AddString(ai.Name);
+ m_Format.SetItemData(index, (LPARAM)arcIndex);
+ if (!needSetMain)
+ {
+ if (Info.FormatIndex == (int)arcIndex)
+ m_Format.SetCurSel(index);
+ continue;
+ }
+ if (i == 0 || ai.Name.IsEqualTo_NoCase(m_RegistryInfo.ArcType))
+ {
+ m_Format.SetCurSel(index);
+ Info.FormatIndex = (int)arcIndex;
+ }
+ }
+ }
+
+ CheckButton(IDX_COMPRESS_SFX, Info.SFXMode);
+
+ {
+ UString fileName;
+ SetArcPathFields(Info.ArcPath, fileName, true);
+ StartDirPrefix = DirPrefix;
+ SetArchiveName(fileName);
+ }
+
+ for (unsigned i = 0; i < m_RegistryInfo.ArcPaths.Size() && i < kHistorySize; i++)
+ m_ArchivePath.AddString(m_RegistryInfo.ArcPaths[i]);
+
+ AddComboItems(m_UpdateMode, k_UpdateMode_IDs, Z7_ARRAY_SIZE(k_UpdateMode_IDs),
+ k_UpdateMode_Vals, Info.UpdateMode);
+
+ AddComboItems(m_PathMode, k_PathMode_IDs, Z7_ARRAY_SIZE(k_PathMode_IDs),
+ k_PathMode_Vals, Info.PathMode);
+
+
+ TCHAR s[32] = { TEXT('/'), TEXT(' '), 0 };
+ ConvertUInt32ToString(NSystem::GetNumberOfProcessors(), s + 2);
+ SetItemText(IDT_COMPRESS_HARDWARE_THREADS, s);
+
+ CheckButton(IDX_COMPRESS_SHARED, Info.OpenShareForWrite);
+ CheckButton(IDX_COMPRESS_DEL, Info.DeleteAfterCompressing);
+
+ FormatChanged(false); // isChanged
+
+ // OnButtonSFX();
+
+ NormalizePosition();
+
+ return CModalDialog::OnInit();
+}
+
+/*
+namespace NCompressDialog
+{
+ bool CInfo::GetFullPathName(UString &result) const
+ {
+ #ifndef UNDER_CE
+ // NDirectory::MySetCurrentDirectory(CurrentDirPrefix);
+ #endif
+ FString resultF;
+ bool res = MyGetFullPathName(us2fs(ArchiveName), resultF);
+ result = fs2us(resultF);
+ return res;
+ }
+}
+*/
+
+void CCompressDialog::UpdatePasswordControl()
+{
+ const bool showPassword = IsShowPasswordChecked();
+ const TCHAR c = showPassword ? (TCHAR)0: TEXT('*');
+ _password1Control.SetPasswordChar((WPARAM)c);
+ _password2Control.SetPasswordChar((WPARAM)c);
+ UString password;
+ _password1Control.GetText(password);
+ _password1Control.SetText(password);
+ _password2Control.GetText(password);
+ _password2Control.SetText(password);
+
+ ShowItem_Bool(IDT_PASSWORD_REENTER, !showPassword);
+ _password2Control.Show_Bool(!showPassword);
+}
+
+bool CCompressDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_COMPRESS_SET_ARCHIVE:
+ {
+ OnButtonSetArchive();
+ return true;
+ }
+ case IDX_COMPRESS_SFX:
+ {
+ SetMethod(GetMethodID());
+ OnButtonSFX();
+ SetMemoryUsage();
+ return true;
+ }
+ case IDX_PASSWORD_SHOW:
+ {
+ UpdatePasswordControl();
+ return true;
+ }
+ case IDB_COMPRESS_OPTIONS:
+ {
+ COptionsDialog dialog(this);
+ if (dialog.Create(*this) == IDOK)
+ ShowOptionsString();
+ return true;
+ }
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CCompressDialog::CheckSFXControlsEnable()
+{
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ bool enable = fi.SFX_();
+ if (enable)
+ {
+ const int methodID = GetMethodID();
+ enable = (methodID == -1 || IsMethodSupportedBySfx(methodID));
+ }
+ if (!enable)
+ CheckButton(IDX_COMPRESS_SFX, false);
+ EnableItem(IDX_COMPRESS_SFX, enable);
+}
+
+/*
+void CCompressDialog::CheckVolumeEnable()
+{
+ bool isSFX = IsSFX();
+ m_Volume.Enable(!isSFX);
+ if (isSFX)
+ m_Volume.SetText(TEXT(""));
+}
+*/
+
+void CCompressDialog::EnableMultiCombo(unsigned id)
+{
+ NWindows::NControl::CComboBox combo;
+ combo.Attach(GetItem(id));
+ const bool enable = (combo.GetCount() > 1);
+ EnableItem(id, enable);
+}
+
+static LRESULT ComboBox_AddStringAscii(NControl::CComboBox &cb, const char *s);
+
+static void Combine_Two_BoolPairs(const CBoolPair &b1, const CBoolPair &b2, CBool1 &res)
+{
+ if (!b1.Def && b2.Def)
+ res.Val = b2.Val;
+ else
+ res.Val = b1.Val;
+}
+
+#define SET_GUI_BOOL(name) \
+ Combine_Two_BoolPairs(Info. name, m_RegistryInfo. name, name)
+
+
+static void Set_Final_BoolPairs(
+ const CBool1 &gui,
+ CBoolPair &cmd,
+ CBoolPair ®)
+{
+ if (!cmd.Def)
+ {
+ reg.Val = gui.Val;
+ reg.Def = gui.Val;
+ }
+ if (gui.Supported)
+ {
+ cmd.Val = gui.Val;
+ cmd.Def = gui.Val;
+ }
+ else
+ cmd.Init();
+}
+
+#define SET_FINAL_BOOL_PAIRS(name) \
+ Set_Final_BoolPairs(name, Info. name, m_RegistryInfo. name)
+
+void CCompressDialog::FormatChanged(bool isChanged)
+{
+ SetLevel();
+ SetSolidBlockSize();
+ SetParams();
+ SetMemUseCombo();
+ SetNumThreads();
+
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ Info.SolidIsSpecified = fi.Solid_();
+ Info.EncryptHeadersIsAllowed = fi.EncryptFileNames_();
+
+ /*
+ const bool multiThreadEnable = fi.MultiThread;
+ Info.MultiThreadIsAllowed = multiThreadEnable;
+ EnableItem(IDC_COMPRESS_SOLID, fi.Solid);
+ EnableItem(IDC_COMPRESS_THREADS, multiThreadEnable);
+ const bool methodEnable = (fi.MethodIDs != NULL);
+ EnableItem(IDC_COMPRESS_METHOD, methodEnable);
+ EnableMultiCombo(IDC_COMPRESS_DICTIONARY, methodEnable);
+ EnableItem(IDC_COMPRESS_ORDER, methodEnable);
+ */
+
+ CheckSFXControlsEnable();
+
+ {
+ if (!isChanged)
+ {
+ SET_GUI_BOOL (SymLinks);
+ SET_GUI_BOOL (HardLinks);
+ SET_GUI_BOOL (AltStreams);
+ SET_GUI_BOOL (NtSecurity);
+ SET_GUI_BOOL (PreserveATime);
+ }
+
+ PreserveATime.Supported = true;
+
+ {
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ SymLinks.Supported = ai.Flags_SymLinks();
+ HardLinks.Supported = ai.Flags_HardLinks();
+ AltStreams.Supported = ai.Flags_AltStreams();
+ NtSecurity.Supported = ai.Flags_NtSecurity();
+ }
+
+ ShowOptionsString();
+ }
+ // CheckVolumeEnable();
+
+ const bool encrypt = fi.Encrypt_();
+ EnableItem(IDG_COMPRESS_ENCRYPTION, encrypt);
+
+ EnableItem(IDT_PASSWORD_ENTER, encrypt);
+ EnableItem(IDT_PASSWORD_REENTER, encrypt);
+ EnableItem(IDE_COMPRESS_PASSWORD1, encrypt);
+ EnableItem(IDE_COMPRESS_PASSWORD2, encrypt);
+ EnableItem(IDX_PASSWORD_SHOW, encrypt);
+
+ EnableItem(IDT_COMPRESS_ENCRYPTION_METHOD, encrypt);
+ EnableItem(IDC_COMPRESS_ENCRYPTION_METHOD, encrypt);
+ EnableItem(IDX_COMPRESS_ENCRYPT_FILE_NAMES, fi.EncryptFileNames_());
+
+ ShowItem_Bool(IDX_COMPRESS_ENCRYPT_FILE_NAMES, fi.EncryptFileNames_());
+
+ SetEncryptionMethod();
+ SetMemoryUsage();
+}
+
+
+bool CCompressDialog::IsSFX()
+{
+ return IsWindowEnabled(GetItem(IDX_COMPRESS_SFX))
+ && IsButtonCheckedBool(IDX_COMPRESS_SFX);
+}
+
+static int GetExtDotPos(const UString &s)
+{
+ const int dotPos = s.ReverseFind_Dot();
+ if (dotPos > s.ReverseFind_PathSepar() + 1)
+ return dotPos;
+ return -1;
+}
+
+void CCompressDialog::OnButtonSFX()
+{
+ UString fileName;
+ m_ArchivePath.GetText(fileName);
+ const int dotPos = GetExtDotPos(fileName);
+ if (IsSFX())
+ {
+ if (dotPos >= 0)
+ fileName.DeleteFrom(dotPos);
+ fileName += kExeExt;
+ m_ArchivePath.SetText(fileName);
+ }
+ else
+ {
+ if (dotPos >= 0)
+ {
+ const UString ext = fileName.Ptr(dotPos);
+ if (ext.IsEqualTo_Ascii_NoCase(kExeExt))
+ {
+ fileName.DeleteFrom(dotPos);
+ m_ArchivePath.SetText(fileName);
+ }
+ }
+ SetArchiveName2(false); // it's for OnInit
+ }
+
+ // CheckVolumeEnable();
+}
+
+
+bool CCompressDialog::GetFinalPath_Smart(UString &resPath) const
+{
+ resPath.Empty();
+ UString name;
+ m_ArchivePath.GetText(name);
+ name.Trim();
+ FString fullPath;
+ UString dirPrefx = DirPrefix;
+ if (dirPrefx.IsEmpty())
+ dirPrefx = StartDirPrefix;
+ const bool res = !dirPrefx.IsEmpty() ?
+ NName::GetFullPath(us2fs(dirPrefx), us2fs(name), fullPath):
+ NName::GetFullPath( us2fs(name), fullPath);
+ if (res)
+ resPath = fs2us(fullPath);
+ return res;
+}
+
+
+bool CCompressDialog::SetArcPathFields(const UString &path)
+{
+ UString name;
+ return SetArcPathFields(path, name, true); // always
+}
+
+
+bool CCompressDialog::SetArcPathFields(const UString &path, UString &name, bool always)
+{
+ FString resDirPrefix;
+ FString resFileName;
+ const bool res = GetFullPathAndSplit(us2fs(path), resDirPrefix, resFileName);
+ if (res)
+ {
+ DirPrefix = fs2us(resDirPrefix);
+ name = fs2us(resFileName);
+ }
+ else
+ {
+ if (!always)
+ return false;
+ DirPrefix.Empty();
+ name = path;
+ }
+ SetItemText(IDT_COMPRESS_ARCHIVE_FOLDER, DirPrefix);
+ m_ArchivePath.SetText(name);
+ return res;
+}
+
+
+static const wchar_t * const k_IncorrectPathMessage = L"Incorrect archive path";
+
+static void AddFilter(CObjectVector<CBrowseFilterInfo> &filters,
+ const UString &description, const UString &ext)
+{
+ CBrowseFilterInfo &f = filters.AddNew();
+ UString mask ("*.");
+ mask += ext;
+ f.Masks.Add(mask);
+ f.Description = description;
+ f.Description += " (";
+ f.Description += mask;
+ f.Description += ")";
+}
+
+
+static const char * const k_DontSave_Exts =
+ "xpi odt ods docx xlsx ";
+
+void CCompressDialog::OnButtonSetArchive()
+{
+ UString path;
+ if (!GetFinalPath_Smart(path))
+ {
+ ShowErrorMessage(*this, k_IncorrectPathMessage);
+ return;
+ }
+
+ int filterIndex;
+ CObjectVector<CBrowseFilterInfo> filters;
+ unsigned numFormats = 0;
+
+ const bool isSFX = IsSFX();
+ if (isSFX)
+ {
+ filterIndex = 0;
+ const UString ext ("exe");
+ AddFilter(filters, ext, ext);
+ }
+ else
+ {
+ filterIndex = m_Format.GetCurSel();
+ numFormats = (unsigned)m_Format.GetCount();
+
+ // filters [0, ... numFormats - 1] corresponds to items in m_Format combo
+ UString desc;
+ UStringVector masks;
+ CStringFinder finder;
+
+ for (unsigned i = 0; i < numFormats; i++)
+ {
+ const CArcInfoEx &ai = (*ArcFormats)[(unsigned)m_Format.GetItemData(i)];
+ CBrowseFilterInfo &f = filters.AddNew();
+ f.Description = ai.Name;
+ f.Description += " (";
+ bool needSpace_desc = false;
+
+ FOR_VECTOR (k, ai.Exts)
+ {
+ const UString &ext = ai.Exts[k].Ext;
+ UString mask ("*.");
+ mask += ext;
+
+ if (finder.FindWord_In_LowCaseAsciiList_NoCase(k_DontSave_Exts, ext))
+ continue;
+
+ f.Masks.Add(mask);
+ masks.Add(mask);
+ if (needSpace_desc)
+ f.Description.Add_Space();
+ needSpace_desc = true;
+ f.Description += ext;
+ }
+ f.Description += ")";
+ // we use only main ext in desc to reduce the size of list
+ if (i != 0)
+ desc.Add_Space();
+ desc += ai.GetMainExt();
+ }
+
+ CBrowseFilterInfo &f = filters.AddNew();
+ f.Description = LangString(IDT_COMPRESS_ARCHIVE); // IDS_ARCHIVES_COLON;
+ if (f.Description.IsEmpty())
+ GetItemText(IDT_COMPRESS_ARCHIVE, f.Description);
+ f.Description.RemoveChar(L'&');
+ // f.Description = "archive";
+ f.Description += " (";
+ f.Description += desc;
+ f.Description += ")";
+ f.Masks = masks;
+ }
+
+ AddFilter(filters, LangString(IDS_OPEN_TYPE_ALL_FILES), UString("*"));
+ if (filterIndex < 0)
+ filterIndex = (int)filters.Size() - 1;
+
+ const UString title = LangString(IDS_COMPRESS_SET_ARCHIVE_BROWSE);
+ CBrowseInfo bi;
+ bi.lpstrTitle = title;
+ bi.SaveMode = true;
+ bi.FilterIndex = filterIndex;
+ bi.hwndOwner = *this;
+ bi.FilePath = path;
+
+ if (!bi.BrowseForFile(filters))
+ return;
+
+ path = bi.FilePath;
+
+ if (isSFX)
+ {
+ const int dotPos = GetExtDotPos(path);
+ if (dotPos >= 0)
+ path.DeleteFrom(dotPos);
+ path += kExeExt;
+ }
+ else
+ // if (bi.FilterIndex >= 0)
+ // if (bi.FilterIndex != filterIndex)
+ if ((unsigned)bi.FilterIndex < numFormats)
+ {
+ // archive format was confirmed. So we try to set format extension
+ bool needAddExt = true;
+ const CArcInfoEx &ai = (*ArcFormats)[(unsigned)m_Format.GetItemData((unsigned)bi.FilterIndex)];
+ const int dotPos = GetExtDotPos(path);
+ if (dotPos >= 0)
+ {
+ const UString ext = path.Ptr(dotPos + 1);
+ if (ai.FindExtension(ext) >= 0)
+ needAddExt = false;
+ }
+ if (needAddExt)
+ {
+ if (path.IsEmpty() || path.Back() != '.')
+ path.Add_Dot();
+ path += ai.GetMainExt();
+ }
+ }
+
+ SetArcPathFields(path);
+
+ if (!isSFX)
+ if ((unsigned)bi.FilterIndex < numFormats)
+ if (bi.FilterIndex != m_Format.GetCurSel())
+ {
+ m_Format.SetCurSel(bi.FilterIndex);
+ SaveOptionsInMem();
+ FormatChanged(true); // isChanged
+ return;
+ }
+
+ ArcPath_WasChanged(path);
+}
+
+
+// in ExtractDialog.cpp
+extern void AddUniqueString(UStringVector &strings, const UString &srcString);
+
+static bool IsAsciiString(const UString &s)
+{
+ for (unsigned i = 0; i < s.Len(); i++)
+ {
+ const wchar_t c = s[i];
+ if (c < 0x20 || c > 0x7F)
+ return false;
+ }
+ return true;
+}
+
+
+static void AddSize_MB(UString &s, UInt64 size)
+{
+ const UInt64 v2 = size + ((UInt32)1 << 20) - 1;
+ if (size <= v2)
+ size = v2;
+ s.Add_UInt64(size >> 20);
+ s += " MB";
+}
+
+
+void SetErrorMessage_MemUsage(UString &s, UInt64 reqSize, UInt64 ramSize, UInt64 ramLimit, const UString &usageString);
+void SetErrorMessage_MemUsage(UString &s, UInt64 reqSize, UInt64 ramSize, UInt64 ramLimit, const UString &usageString)
+{
+ s += "The operation was blocked by 7-Zip";
+ s.Add_LF();
+ s += "The operation can require big amount of RAM (memory):";
+ s.Add_LF();
+ s.Add_LF();
+ AddSize_MB(s, reqSize);
+
+ if (!usageString.IsEmpty())
+ {
+ s += " : ";
+ s += usageString;
+ }
+
+ s.Add_LF();
+ AddSize_MB(s, ramSize);
+ s += " : RAM";
+
+ // if (ramLimit != 0)
+ {
+ s.Add_LF();
+ AddSize_MB(s, ramLimit);
+ s += " : 7-Zip limit";
+ }
+
+ s.Add_LF();
+ s.Add_LF();
+ AddLangString(s, IDS_MEM_ERROR);
+}
+
+
+void CCompressDialog::OnOK()
+{
+ _password1Control.GetText(Info.Password);
+ if (IsZipFormat())
+ {
+ if (!IsAsciiString(Info.Password))
+ {
+ ShowErrorMessageHwndRes(*this, IDS_PASSWORD_USE_ASCII);
+ return;
+ }
+ UString method = GetEncryptionMethodSpec();
+ if (method.IsPrefixedBy_Ascii_NoCase("aes"))
+ {
+ if (Info.Password.Len() > 99)
+ {
+ ShowErrorMessageHwndRes(*this, IDS_PASSWORD_TOO_LONG);
+ return;
+ }
+ }
+ }
+ if (!IsShowPasswordChecked())
+ {
+ UString password2;
+ _password2Control.GetText(password2);
+ if (password2 != Info.Password)
+ {
+ ShowErrorMessageHwndRes(*this, IDS_PASSWORD_NOT_MATCH);
+ return;
+ }
+ }
+
+ {
+ UInt64 decompressMem;
+ const UInt64 memUsage = GetMemoryUsage_DecompMem(decompressMem);
+ if (memUsage != (UInt64)(Int64)-1)
+ {
+ const UInt64 limit = Get_MemUse_Bytes();
+ if (memUsage > limit)
+ {
+ UString s;
+ UString s2 = LangString(IDT_COMPRESS_MEMORY);
+ if (s2.IsEmpty())
+ GetItemText(IDT_COMPRESS_MEMORY, s2);
+ SetErrorMessage_MemUsage(s, memUsage, _ramSize, limit, s2);
+ MessageBoxError(s);
+ return;
+ }
+ }
+ }
+
+ SaveOptionsInMem();
+
+ UStringVector arcPaths;
+ {
+ UString s;
+ if (!GetFinalPath_Smart(s))
+ {
+ ShowErrorMessage(*this, k_IncorrectPathMessage);
+ return;
+ }
+ Info.ArcPath = s;
+ AddUniqueString(arcPaths, s);
+ }
+
+ Info.UpdateMode = (NCompressDialog::NUpdateMode::EEnum)k_UpdateMode_Vals[m_UpdateMode.GetCurSel()];
+ Info.PathMode = (NWildcard::ECensorPathMode)k_PathMode_Vals[m_PathMode.GetCurSel()];
+
+ Info.Level = GetLevelSpec();
+ Info.Dict64 = GetDictSpec();
+ // Info.Dict64_Chain = GetDictChainSpec();
+ Info.Order = GetOrderSpec();
+ Info.OrderMode = GetOrderMode();
+ Info.NumThreads = GetNumThreadsSpec();
+
+ Info.MemUsage.Clear();
+ {
+ const UString mus = Get_MemUse_Spec();
+ if (!mus.IsEmpty())
+ {
+ NCompression::CMemUse mu;
+ mu.Parse(mus);
+ if (mu.IsDefined)
+ Info.MemUsage = mu;
+ }
+ }
+
+ {
+ // Info.SolidIsSpecified = g_Formats[GetStaticFormatIndex()].Solid;
+ const UInt32 solidLogSize = GetBlockSizeSpec();
+ Info.SolidBlockSize = 0;
+ if (solidLogSize == (UInt32)(Int32)-1)
+ Info.SolidIsSpecified = false;
+ else if (solidLogSize > 0)
+ Info.SolidBlockSize = (solidLogSize >= 64) ?
+ (UInt64)(Int64)-1 :
+ ((UInt64)1 << solidLogSize);
+ }
+
+ Info.Method = GetMethodSpec();
+ Info.EncryptionMethod = GetEncryptionMethodSpec();
+ Info.FormatIndex = (int)GetFormatIndex();
+ Info.SFXMode = IsSFX();
+ Info.OpenShareForWrite = IsButtonCheckedBool(IDX_COMPRESS_SHARED);
+ Info.DeleteAfterCompressing = IsButtonCheckedBool(IDX_COMPRESS_DEL);
+
+ m_RegistryInfo.EncryptHeaders =
+ Info.EncryptHeaders = IsButtonCheckedBool(IDX_COMPRESS_ENCRYPT_FILE_NAMES);
+
+
+ /* (Info) is for saving to registry:
+ (CBoolPair::Val) will be set as (false), if it was (false)
+ in registry at dialog creation, and user didn't click checkbox.
+ in another case (CBoolPair::Val) will be set as (true) */
+
+ {
+ /* Info properties could be for another archive types.
+ so we disable unsupported properties in Info */
+ // const CArcInfoEx &ai = Get_ArcInfoEx();
+
+ SET_FINAL_BOOL_PAIRS (SymLinks);
+ SET_FINAL_BOOL_PAIRS (HardLinks);
+ SET_FINAL_BOOL_PAIRS (AltStreams);
+ SET_FINAL_BOOL_PAIRS (NtSecurity);
+
+ SET_FINAL_BOOL_PAIRS (PreserveATime);
+ }
+
+ {
+ const NCompression::CFormatOptions &fo = Get_FormatOptions();
+
+ Info.TimePrec = fo.TimePrec;
+ Info.MTime = fo.MTime;
+ Info.CTime = fo.CTime;
+ Info.ATime = fo.ATime;
+ Info.SetArcMTime = fo.SetArcMTime;
+ }
+
+ m_Params.GetText(Info.Options);
+
+ UString volumeString;
+ m_Volume.GetText(volumeString);
+ volumeString.Trim();
+ Info.VolumeSizes.Clear();
+
+ if (!volumeString.IsEmpty())
+ {
+ if (!ParseVolumeSizes(volumeString, Info.VolumeSizes))
+ {
+ ShowErrorMessageHwndRes(*this, IDS_INCORRECT_VOLUME_SIZE);
+ return;
+ }
+ if (!Info.VolumeSizes.IsEmpty())
+ {
+ const UInt64 volumeSize = Info.VolumeSizes.Back();
+ if (volumeSize < (100 << 10))
+ {
+ wchar_t s[32];
+ ConvertUInt64ToString(volumeSize, s);
+ if (::MessageBoxW(*this, MyFormatNew(IDS_SPLIT_CONFIRM, s),
+ L"7-Zip", MB_YESNOCANCEL | MB_ICONQUESTION) != IDYES)
+ return;
+ }
+ }
+ }
+
+ if (Info.FormatIndex >= 0)
+ m_RegistryInfo.ArcType = (*ArcFormats)[Info.FormatIndex].Name;
+ m_RegistryInfo.ShowPassword = IsShowPasswordChecked();
+
+ FOR_VECTOR (i, m_RegistryInfo.ArcPaths)
+ {
+ if (arcPaths.Size() >= kHistorySize)
+ break;
+ AddUniqueString(arcPaths, m_RegistryInfo.ArcPaths[i]);
+ }
+ m_RegistryInfo.ArcPaths = arcPaths;
+
+ m_RegistryInfo.Save();
+
+ CModalDialog::OnOK();
+}
+
+#define kHelpTopic "fm/plugins/7-zip/add.htm"
+#define kHelpTopic_Options "fm/plugins/7-zip/add.htm#options"
+
+void CCompressDialog::OnHelp()
+{
+ ShowHelpWindow(kHelpTopic);
+}
+
+
+void CCompressDialog::ArcPath_WasChanged(const UString &path)
+{
+ const int dotPos = GetExtDotPos(path);
+ if (dotPos < 0)
+ return;
+ const UString ext = path.Ptr(dotPos + 1);
+ {
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ if (ai.FindExtension(ext) >= 0)
+ return;
+ }
+
+ const unsigned count = (unsigned)m_Format.GetCount();
+ for (unsigned i = 0; i < count; i++)
+ {
+ const CArcInfoEx &ai = (*ArcFormats)[(unsigned)m_Format.GetItemData(i)];
+ if (ai.FindExtension(ext) >= 0)
+ {
+ m_Format.SetCurSel(i);
+ SaveOptionsInMem();
+ FormatChanged(true); // isChanged
+ return;
+ }
+ }
+}
+
+
+bool CCompressDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case k_Message_ArcChanged:
+ {
+ // UString path;
+ // m_ArchivePath.GetText(path);
+ const int select = m_ArchivePath.GetCurSel();
+ if ((unsigned)select < m_RegistryInfo.ArcPaths.Size())
+ // if (path == m_RegistryInfo.ArcPaths[select])
+ {
+ const UString &path = m_RegistryInfo.ArcPaths[select];
+ SetArcPathFields(path);
+ // ArcPath_WasChanged(path);
+ }
+ return 0;
+ }
+ }
+ return CModalDialog::OnMessage(message, wParam, lParam);
+}
+
+
+bool CCompressDialog::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+ if (code == CBN_SELCHANGE)
+ {
+ switch (itemID)
+ {
+ case IDC_COMPRESS_ARCHIVE:
+ {
+ /* CBN_SELCHANGE is called before actual value of combo text will be changed.
+ So GetText() here returns old value (before change) of combo text.
+ So here we can change all controls except of m_ArchivePath.
+ */
+ const int select = m_ArchivePath.GetCurSel();
+ if ((unsigned)select < m_RegistryInfo.ArcPaths.Size())
+ {
+ // DirPrefix.Empty();
+ // SetItemText(IDT_COMPRESS_ARCHIVE_FOLDER, DirPrefix);
+ const UString &path = m_RegistryInfo.ArcPaths[select];
+ // SetArcPathFields(path);
+ ArcPath_WasChanged(path);
+ // we use PostMessage(k_Message_ArcChanged) here that later will change m_ArchivePath control
+ PostMsg(k_Message_ArcChanged);
+ }
+ return true;
+ }
+
+ case IDC_COMPRESS_FORMAT:
+ {
+ const bool isSFX = IsSFX();
+ SaveOptionsInMem();
+ FormatChanged(true); // isChanged
+ SetArchiveName2(isSFX);
+ return true;
+ }
+
+ case IDC_COMPRESS_LEVEL:
+ {
+ Get_FormatOptions().ResetForLevelChange();
+
+ SetMethod(); // call it if level changes method
+
+ // call the following if level change keeps old method
+ /*
+ {
+ // try to keep old method
+ SetMethod(GetMethodID());
+ MethodChanged();
+ }
+ */
+
+ SetSolidBlockSize();
+ SetNumThreads();
+ CheckSFXNameChange();
+ SetMemoryUsage();
+ return true;
+ }
+
+ case IDC_COMPRESS_METHOD:
+ {
+ MethodChanged();
+ SetSolidBlockSize();
+ SetNumThreads();
+ CheckSFXNameChange();
+ SetMemoryUsage();
+ if (Get_ArcInfoEx().Flags_HashHandler())
+ SetArchiveName2(false);
+
+ return true;
+ }
+
+ case IDC_COMPRESS_DICTIONARY:
+ // case IDC_COMPRESS_DICTIONARY2:
+ {
+ /* we want to change the reported threads for Auto line
+ and keep selected NumThreads option
+ So we save selected NumThreads option in memory */
+ SaveOptionsInMem();
+ const UInt32 blockSizeLog = GetBlockSizeSpec();
+ if (// blockSizeLog != (UInt32)(Int32)-1 &&
+ blockSizeLog != kSolidLog_NoSolid
+ && blockSizeLog != kSolidLog_FullSolid)
+ {
+ Get_FormatOptions().Reset_BlockLogSize();
+ // SetSolidBlockSize(true);
+ }
+
+ SetDictionary2();
+ SetSolidBlockSize();
+ SetNumThreads(); // we want to change the reported threads for Auto line only
+ SetMemoryUsage();
+ return true;
+ }
+
+ case IDC_COMPRESS_ORDER:
+ {
+ #ifdef PRINT_PARAMS
+ Print_Params();
+ #endif
+ return true;
+ }
+
+ case IDC_COMPRESS_SOLID:
+ {
+ SetMemoryUsage();
+ return true;
+ }
+
+ case IDC_COMPRESS_THREADS:
+ {
+ SetMemoryUsage();
+ return true;
+ }
+
+ case IDC_COMPRESS_MEM_USE:
+ {
+ /* we want to change the reported threads for Auto line
+ and keep selected NumThreads option
+ So we save selected NumThreads option in memory */
+ SaveOptionsInMem();
+
+ SetNumThreads(); // we want to change the reported threads for Auto line only
+ SetMemoryUsage();
+ return true;
+ }
+ }
+ }
+ return CModalDialog::OnCommand(code, itemID, lParam);
+}
+
+void CCompressDialog::CheckSFXNameChange()
+{
+ const bool isSFX = IsSFX();
+ CheckSFXControlsEnable();
+ if (isSFX != IsSFX())
+ SetArchiveName2(isSFX);
+}
+
+void CCompressDialog::SetArchiveName2(bool prevWasSFX)
+{
+ UString fileName;
+ m_ArchivePath.GetText(fileName);
+ const CArcInfoEx &prevArchiverInfo = (*ArcFormats)[m_PrevFormat];
+ if (prevArchiverInfo.Flags_KeepName() || Info.KeepName)
+ {
+ UString prevExtension;
+ if (prevWasSFX)
+ prevExtension = kExeExt;
+ else
+ {
+ prevExtension.Add_Dot();
+ prevExtension += prevArchiverInfo.GetMainExt();
+ }
+ const unsigned prevExtensionLen = prevExtension.Len();
+ if (fileName.Len() >= prevExtensionLen)
+ if (StringsAreEqualNoCase(fileName.RightPtr(prevExtensionLen), prevExtension))
+ fileName.DeleteFrom(fileName.Len() - prevExtensionLen);
+ }
+ SetArchiveName(fileName);
+}
+
+// if type.KeepName then use OriginalFileName
+// else if !KeepName remove extension
+// add new extension
+
+void CCompressDialog::SetArchiveName(const UString &name)
+{
+ UString fileName = name;
+ Info.FormatIndex = (int)GetFormatIndex();
+ const CArcInfoEx &ai = (*ArcFormats)[Info.FormatIndex];
+ m_PrevFormat = Info.FormatIndex;
+ if (ai.Flags_KeepName())
+ {
+ fileName = OriginalFileName;
+ }
+ else
+ {
+ if (!Info.KeepName)
+ {
+ int dotPos = GetExtDotPos(fileName);
+ if (dotPos >= 0)
+ fileName.DeleteFrom(dotPos);
+ }
+ }
+
+ if (IsSFX())
+ fileName += kExeExt;
+ else
+ {
+ fileName.Add_Dot();
+ UString ext = ai.GetMainExt();
+ if (ai.Flags_HashHandler())
+ {
+ UString estimatedName;
+ GetMethodSpec(estimatedName);
+ if (!estimatedName.IsEmpty())
+ {
+ ext = estimatedName;
+ ext.MakeLower_Ascii();
+ }
+ }
+ fileName += ext;
+ }
+ m_ArchivePath.SetText(fileName);
+}
+
+
+int CCompressDialog::FindRegistryFormat(const UString &name)
+{
+ FOR_VECTOR (i, m_RegistryInfo.Formats)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[i];
+ if (name.IsEqualTo_NoCase(GetUnicodeString(fo.FormatID)))
+ return (int)i;
+ }
+ return -1;
+}
+
+
+unsigned CCompressDialog::FindRegistryFormat_Always(const UString &name)
+{
+ const int index = FindRegistryFormat(name);
+ if (index >= 0)
+ return (unsigned)index;
+ {
+ NCompression::CFormatOptions fo;
+ fo.FormatID = GetSystemString(name);
+ return m_RegistryInfo.Formats.Add(fo);
+ }
+}
+
+
+NCompression::CFormatOptions &CCompressDialog::Get_FormatOptions()
+{
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ return m_RegistryInfo.Formats[FindRegistryFormat_Always(ai.Name)];
+}
+
+
+unsigned CCompressDialog::GetStaticFormatIndex()
+{
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_Formats); i++)
+ if (ai.Name.IsEqualTo_Ascii_NoCase(g_Formats[i].Name))
+ return i;
+ return 0; // -1;
+}
+
+void CCompressDialog::SetNearestSelectComboBox(NControl::CComboBox &comboBox, UInt32 value)
+{
+ for (int i = comboBox.GetCount() - 1; i >= 0; i--)
+ if ((UInt32)comboBox.GetItemData(i) <= value)
+ {
+ comboBox.SetCurSel(i);
+ return;
+ }
+ if (comboBox.GetCount() > 0)
+ comboBox.SetCurSel(0);
+}
+
+void CCompressDialog::SetLevel2()
+{
+ m_Level.ResetContent();
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ UInt32 level = 5;
+ {
+ int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ if (fo.Level <= 9)
+ level = fo.Level;
+ else if (fo.Level == (UInt32)(Int32)-1)
+ level = 5;
+ else
+ level = 9;
+ }
+ }
+
+ const bool isZstd = ai.Is_Zstd();
+
+ for (unsigned i = 0; i < sizeof(UInt32) * 8; i++)
+ {
+ const UInt32 mask = (UInt32)1 << i;
+ if ((fi.LevelsMask & mask) != 0)
+ {
+ const UInt32 langID = g_Levels[i];
+ UString s;
+ s.Add_UInt32(i);
+ // if (fi.LevelsMask < (1 << (MY_ZSTD_LEVEL_MAX + 1)) - 1)
+ if (langID)
+ if (i != 0 || !isZstd)
+ {
+ s += " - ";
+ s += LangString(langID);
+ }
+ const int index = (int)m_Level.AddString(s);
+ m_Level.SetItemData(index, (LPARAM)i);
+ }
+ if (fi.LevelsMask <= mask)
+ break;
+ }
+ SetNearestSelectComboBox(m_Level, level);
+}
+
+
+static LRESULT ComboBox_AddStringAscii(NControl::CComboBox &cb, const char *s)
+{
+ return cb.AddString((CSysString)s);
+}
+
+static const char *k_Auto_Prefix = "* ";
+
+static void Modify_Auto(AString &s)
+{
+ s.Insert(0, k_Auto_Prefix);
+}
+
+void CCompressDialog::SetMethod2(int keepMethodId)
+{
+ m_Method.ResetContent();
+ _auto_MethodId = -1;
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ if (GetLevel() == 0 && !ai.Flags_HashHandler())
+ {
+ if (!ai.Is_Tar() &&
+ !ai.Is_Zstd())
+ {
+ MethodChanged();
+ return;
+ }
+ }
+ UString defaultMethod;
+ {
+ const int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ defaultMethod = fo.Method;
+ }
+ }
+ const bool isSfx = IsSFX();
+ bool weUseSameMethod = false;
+
+ const bool is7z = ai.Is_7z();
+
+ for (unsigned m = 0;; m++)
+ {
+ int methodID;
+ const char *method;
+ if (m < fi.NumMethods)
+ {
+ methodID = fi.MethodIDs[m];
+ method = kMethodsNames[methodID];
+ if (is7z)
+ if (methodID == kCopy
+ || methodID == kDeflate
+ || methodID == kDeflate64
+ )
+ continue;
+ }
+ else
+ {
+ if (!is7z)
+ break;
+ const unsigned extIndex = m - fi.NumMethods;
+ if (extIndex >= ExternalMethods.Size())
+ break;
+ methodID = (int)(Z7_ARRAY_SIZE(kMethodsNames) + extIndex);
+ method = ExternalMethods[extIndex].Ptr();
+ }
+ if (isSfx)
+ if (!IsMethodSupportedBySfx(methodID))
+ continue;
+
+ AString s (method);
+ int writtenMethodId = methodID;
+ if (m == 0)
+ {
+ _auto_MethodId = methodID;
+ writtenMethodId = -1;
+ Modify_Auto(s);
+ }
+ const int itemIndex = (int)ComboBox_AddStringAscii(m_Method, s);
+ m_Method.SetItemData(itemIndex, writtenMethodId);
+ if (keepMethodId == methodID)
+ {
+ m_Method.SetCurSel(itemIndex);
+ weUseSameMethod = true;
+ continue;
+ }
+ if ((defaultMethod.IsEqualTo_Ascii_NoCase(method) || m == 0) && !weUseSameMethod)
+ m_Method.SetCurSel(itemIndex);
+ }
+
+ if (!weUseSameMethod)
+ MethodChanged();
+}
+
+
+
+bool CCompressDialog::IsZipFormat()
+{
+ return Get_ArcInfoEx().Is_Zip();
+}
+
+bool CCompressDialog::IsXzFormat()
+{
+ return Get_ArcInfoEx().Is_Xz();
+}
+
+void CCompressDialog::SetEncryptionMethod()
+{
+ _encryptionMethod.ResetContent();
+ _default_encryptionMethod_Index = -1;
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ if (ai.Is_7z())
+ {
+ ComboBox_AddStringAscii(_encryptionMethod, "AES-256");
+ _encryptionMethod.SetCurSel(0);
+ _default_encryptionMethod_Index = 0;
+ }
+ else if (ai.Is_Zip())
+ {
+ int index = FindRegistryFormat(ai.Name);
+ UString encryptionMethod;
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ encryptionMethod = fo.EncryptionMethod;
+ }
+ int sel = 0;
+ // if (ZipCryptoIsAllowed)
+ {
+ ComboBox_AddStringAscii(_encryptionMethod, "ZipCrypto");
+ sel = (encryptionMethod.IsPrefixedBy_Ascii_NoCase("aes") ? 1 : 0);
+ _default_encryptionMethod_Index = 0;
+ }
+ ComboBox_AddStringAscii(_encryptionMethod, "AES-256");
+ _encryptionMethod.SetCurSel(sel);
+ }
+}
+
+
+int CCompressDialog::GetMethodID_RAW()
+{
+ if (m_Method.GetCount() <= 0)
+ return -1;
+ return (int)(Int32)(UInt32)m_Method.GetItemData_of_CurSel();
+}
+
+int CCompressDialog::GetMethodID()
+{
+ int raw = GetMethodID_RAW();
+ if (raw < 0)
+ return _auto_MethodId;
+ return raw;
+}
+
+
+UString CCompressDialog::GetMethodSpec(UString &estimatedName)
+{
+ estimatedName.Empty();
+ if (m_Method.GetCount() < 1)
+ return estimatedName;
+ const int methodIdRaw = GetMethodID_RAW();
+ int methodId = methodIdRaw;
+ if (methodIdRaw < 0)
+ methodId = _auto_MethodId;
+ UString s;
+ if (methodId >= 0)
+ {
+ if ((unsigned)methodId < Z7_ARRAY_SIZE(kMethodsNames))
+ estimatedName = kMethodsNames[methodId];
+ else
+ estimatedName = ExternalMethods[(unsigned)methodId - (unsigned)Z7_ARRAY_SIZE(kMethodsNames)];
+ if (methodIdRaw >= 0)
+ s = estimatedName;
+ }
+ return s;
+}
+
+
+UString CCompressDialog::GetMethodSpec()
+{
+ UString estimatedName;
+ UString s = GetMethodSpec(estimatedName);
+ return s;
+}
+
+bool CCompressDialog::IsMethodEqualTo(const UString &s)
+{
+ UString estimatedName;
+ const UString shortName = GetMethodSpec(estimatedName);
+ if (s.IsEmpty())
+ return shortName.IsEmpty();
+ return s.IsEqualTo_NoCase(estimatedName);
+}
+
+
+UString CCompressDialog::GetEncryptionMethodSpec()
+{
+ UString s;
+ if (_encryptionMethod.GetCount() > 0
+ && _encryptionMethod.GetCurSel() != _default_encryptionMethod_Index)
+ {
+ _encryptionMethod.GetText(s);
+ s.RemoveChar(L'-');
+ }
+ return s;
+}
+
+
+static const size_t k_Auto_Dict = (size_t)0 - 1;
+
+static int Combo_AddDict2(NWindows::NControl::CComboBox &cb, size_t sizeReal, size_t sizeShow)
+{
+ char c = 0;
+ unsigned moveBits = 0;
+ if ((sizeShow & 0xFFFFF) == 0) { moveBits = 20; c = 'M'; }
+ else if ((sizeShow & 0x3FF) == 0) { moveBits = 10; c = 'K'; }
+ AString s;
+ s.Add_UInt64(sizeShow >> moveBits);
+ s.Add_Space();
+ if (c != 0)
+ s += c;
+ s += 'B';
+ if (sizeReal == k_Auto_Dict)
+ Modify_Auto(s);
+ const int index = (int)ComboBox_AddStringAscii(cb, s);
+ cb.SetItemData(index, (LPARAM)sizeReal);
+ return index;
+}
+
+int CCompressDialog::AddDict2(size_t sizeReal, size_t sizeShow)
+{
+ return Combo_AddDict2(m_Dictionary, sizeReal, sizeShow);
+}
+
+int CCompressDialog::AddDict(size_t size)
+{
+ return AddDict2(size, size);
+}
+
+/*
+int CCompressDialog::AddDict_Chain(size_t size)
+{
+ return Combo_AddDict2(m_Dictionary_Chain, size, size);
+}
+*/
+
+void CCompressDialog::SetDictionary2()
+{
+ m_Dictionary.ResetContent();
+ // m_Dictionary_Chain.ResetContent();
+
+ // _auto_Dict = (UInt32)1 << 24; // we can use this dictSize to calculate _auto_Solid for unknown method for 7z
+ _auto_Dict = (UInt32)(Int32)-1; // for debug
+ // _auto_Dict_Chain = (UInt32)(Int32)-1; // for debug
+
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ UInt32 defaultDict = (UInt32)(Int32)-1;
+ // UInt32 defaultDict_Chain = (UInt32)(Int32)-1;
+ {
+ const int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ if (IsMethodEqualTo(fo.Method))
+ {
+ defaultDict = fo.Dictionary;
+ // defaultDict_Chain = fo.DictionaryChain;
+ }
+ }
+ }
+
+ const int methodID = GetMethodID();
+ const UInt32 level = GetLevel2();
+
+ {
+ RECT r, rLabel;
+ GetClientRectOfItem(IDT_COMPRESS_DICTIONARY, rLabel);
+ GetClientRectOfItem(IDC_COMPRESS_DICTIONARY, r);
+ if (_dictionaryCombo_left == 0)
+ _dictionaryCombo_left = r.left;
+
+ // bool showDict2;
+ int newLableRight;
+ int newDictLeft;
+
+ /*
+ if (methodID == kZSTD)
+ {
+ showDict2 = true;
+ newDictLeft = _dictionaryCombo_left;
+ RECT r2;
+ GetClientRectOfItem(IDC_COMPRESS_DICTIONARY2, r2);
+ newLableRight = r2.left;
+ }
+ else
+ */
+ {
+ // showDict2 = false;
+ RECT rBig;
+ GetClientRectOfItem(IDC_COMPRESS_METHOD, rBig);
+ newDictLeft= rBig.left;
+ newLableRight = newDictLeft;
+ }
+
+ if (newLableRight != rLabel.right)
+ {
+ rLabel.right = newLableRight;
+ MoveItem_RECT(IDT_COMPRESS_DICTIONARY, rLabel);
+ InvalidateRect(&rLabel);
+ }
+ if (newDictLeft != r.left)
+ {
+ r.left = newDictLeft;
+ MoveItem_RECT(IDC_COMPRESS_DICTIONARY, r);
+ // InvalidateRect(&r);
+ }
+ // ShowItem_Bool(IDC_COMPRESS_DICTIONARY2, showDict2);
+ }
+
+ if (methodID < 0)
+ return;
+
+ switch (methodID)
+ {
+ case kLZMA:
+ case kLZMA2:
+ {
+ {
+ _auto_Dict =
+ ( level <= 3 ? ((UInt32)1 << (level * 2 + 16)) :
+ ( level <= 6 ? ((UInt32)1 << (level + 19)) :
+ ( level <= 7 ? ((UInt32)1 << 25) : ((UInt32)1 << 26)
+ )));
+ }
+
+ // we use threshold 3.75 GiB to switch to kLzmaMaxDictSize.
+ if (defaultDict != (UInt32)(Int32)-1
+ && defaultDict >= ((UInt32)15 << 28))
+ defaultDict = kLzmaMaxDictSize;
+
+ const size_t kLzmaMaxDictSize_Up = (size_t)1 << (20 + sizeof(size_t) / 4 * 6);
+
+ int curSel = AddDict2(k_Auto_Dict, _auto_Dict);
+
+ for (unsigned i = (16 - 1) * 2; i <= (32 - 1) * 2; i++)
+ {
+ if (i < (20 - 1) * 2
+ && i != (16 - 1) * 2
+ && i != (18 - 1) * 2)
+ continue;
+ if (i == (20 - 1) * 2 + 1)
+ continue;
+ const size_t dict_up = (size_t)(2 + (i & 1)) << (i / 2);
+ size_t dict = dict_up;
+ if (dict_up >= kLzmaMaxDictSize)
+ dict = kLzmaMaxDictSize; // we reduce dictionary
+
+ const int index = AddDict(dict);
+ // AddDict2(dict, dict_up); // for debug : we show 4 GB
+
+ // const UInt32 numThreads = 2;
+ // const UInt64 memUsage = GetMemoryUsageComp_Threads_Dict(numThreads, dict);
+ if (defaultDict != (UInt32)(Int32)-1)
+ if (dict <= defaultDict || curSel <= 0)
+ // if (!maxRamSize_Defined || memUsage <= maxRamSize)
+ curSel = index;
+ if (dict_up >= kLzmaMaxDictSize_Up)
+ break;
+ }
+
+ m_Dictionary.SetCurSel(curSel);
+ break;
+ }
+
+ /*
+ case kZSTD:
+ {
+ if (defaultDict != (UInt32)(Int32)-1 &&
+ defaultDict > kZstd_MAX_DictSize)
+ defaultDict = kZstd_MAX_DictSize;
+
+ if (defaultDict_Chain != (UInt32)(Int32)-1 &&
+ defaultDict_Chain > kZstd_MAX_DictSize_Chain)
+ defaultDict_Chain = kZstd_MAX_DictSize_Chain;
+
+ {
+ CZstdEncProps props;
+ ZstdEncProps_Init(&props);
+ // props.level_zstd = level;
+ props.level_7z = level;
+ ZstdEncProps_Set_WindowSize(&props, defaultDict != (UInt32)(Int32)-1 ? defaultDict: 0);
+ ZstdEncProps_NormalizeFull(&props);
+ _auto_Dict_Chain = (UInt32)1 << props.windowLog_Chain;
+ }
+ {
+ CZstdEncProps props;
+ ZstdEncProps_Init(&props);
+ // props.level_zstd = level;
+ props.level_7z = level;
+ ZstdEncProps_Set_WindowChainSize(&props, defaultDict_Chain != (UInt32)(Int32)-1 ? defaultDict_Chain: 0);
+ ZstdEncProps_NormalizeFull(&props);
+ _auto_Dict = (UInt32)1 << props.windowLog;
+ }
+
+ // if there is collision of two window sizes, we reduce dict_Chain
+ if (defaultDict != (UInt32)(Int32)-1 &&
+ defaultDict_Chain != (UInt32)(Int32)-1 &&
+ defaultDict < defaultDict_Chain)
+ defaultDict_Chain = defaultDict;
+
+ {
+ int curSel = AddDict2(k_Auto_Dict, _auto_Dict);
+
+ // defaultDict = 12 << 10; // for debug
+ const UInt32 kWinStart = 18;
+ if (defaultDict != 0 && defaultDict < ((UInt32)1 << kWinStart))
+ curSel = AddDict(defaultDict);
+
+ for (unsigned i = kWinStart; i <= MY_ZSTD_WINDOWLOG_MAX; i++)
+ {
+ const size_t dict = (size_t)1 << i;
+ const int index = AddDict(dict);
+ if (defaultDict != (UInt32)(Int32)-1)
+ if (dict <= defaultDict || curSel <= 0)
+ curSel = index;
+ }
+ m_Dictionary.SetCurSel(curSel);
+ }
+
+ {
+ int curSel = Combo_AddDict2(m_Dictionary_Chain, k_Auto_Dict, _auto_Dict_Chain);
+
+ // defaultDict_Chain = 10 << 10; // for debug
+ const UInt32 kWinChainStart = 15;
+ if (defaultDict_Chain != 0 && defaultDict_Chain < ((UInt32)1 << kWinChainStart))
+ curSel = AddDict_Chain(defaultDict_Chain);
+
+ for (unsigned i = kWinChainStart; i <= kMaxDictChain; i++)
+ {
+ const size_t dict = (size_t)1 << i;
+ if (defaultDict != (UInt32)(Int32)-1 && dict > defaultDict)
+ break;
+ const int index = AddDict_Chain(dict);
+ if (defaultDict_Chain != (UInt32)(Int32)-1)
+ if (dict <= defaultDict_Chain || curSel <= 0)
+ curSel = index;
+ }
+ m_Dictionary_Chain.SetCurSel(curSel);
+ }
+
+ break;
+ }
+ */
+
+ case kPPMd:
+ {
+ _auto_Dict = (UInt32)1 << (level + 19);
+
+ const UInt32 kPpmd_Default_4g = (UInt32)0 - ((UInt32)1 << 10);
+ const size_t kPpmd_MaxDictSize_Up = (size_t)1 << (29 + sizeof(size_t) / 8);
+
+ if (defaultDict != (UInt32)(Int32)-1
+ && defaultDict >= ((UInt32)15 << 28)) // threshold
+ defaultDict = kPpmd_Default_4g;
+
+ int curSel = AddDict2(k_Auto_Dict, _auto_Dict);
+
+ for (unsigned i = (20 - 1) * 2; i <= (32 - 1) * 2; i++)
+ {
+ if (i == (20 - 1) * 2 + 1)
+ continue;
+
+ const size_t dict_up = (size_t)(2 + (i & 1)) << (i / 2);
+ size_t dict = dict_up;
+ if (dict_up >= kPpmd_Default_4g)
+ dict = kPpmd_Default_4g;
+
+ const int index = AddDict2(dict, dict_up);
+ // AddDict2((UInt32)((UInt32)0 - 2), dict_up); // for debug
+ // AddDict(dict_up); // for debug
+ // const UInt64 memUsage = GetMemoryUsageComp_Threads_Dict(1, dict);
+ if (defaultDict != (UInt32)(Int32)-1)
+ if (dict <= defaultDict || curSel <= 0)
+ // if (!maxRamSize_Defined || memUsage <= maxRamSize)
+ curSel = index;
+ if (dict_up >= kPpmd_MaxDictSize_Up)
+ break;
+ }
+ m_Dictionary.SetCurSel(curSel);
+ break;
+ }
+
+ case kPPMdZip:
+ {
+ _auto_Dict = (UInt32)1 << (level + 19);
+
+ int curSel = AddDict2(k_Auto_Dict, _auto_Dict);
+
+ for (unsigned i = 20; i <= 28; i++)
+ {
+ const UInt32 dict = (UInt32)1 << i;
+ const int index = AddDict(dict);
+ // const UInt64 memUsage = GetMemoryUsageComp_Threads_Dict(1, dict);
+ if (defaultDict != (UInt32)(Int32)-1)
+ if (dict <= defaultDict || curSel <= 0)
+ // if (!maxRamSize_Defined || memUsage <= maxRamSize)
+ curSel = index;
+ }
+ m_Dictionary.SetCurSel(curSel);
+ break;
+ }
+
+ case kDeflate:
+ case kDeflate64:
+ {
+ const UInt32 dict = (methodID == kDeflate ? (UInt32)(1 << 15) : (UInt32)(1 << 16));
+ _auto_Dict = dict;
+ AddDict2(k_Auto_Dict, _auto_Dict);
+ m_Dictionary.SetCurSel(0);
+ // EnableItem(IDC_COMPRESS_DICTIONARY, false);
+ break;
+ }
+
+ case kBZip2:
+ {
+ {
+ if (level >= 5) _auto_Dict = (900 << 10);
+ else if (level >= 3) _auto_Dict = (500 << 10);
+ else _auto_Dict = (100 << 10);
+ }
+
+ int curSel = AddDict2(k_Auto_Dict, _auto_Dict);
+
+ for (unsigned i = 1; i <= 9; i++)
+ {
+ const UInt32 dict = ((UInt32)i * 100) << 10;
+ AddDict(dict);
+ // AddDict2(i * 100000, dict);
+ if (defaultDict != (UInt32)(Int32)-1)
+ if (i <= defaultDict / 100000 || curSel <= 0)
+ curSel = m_Dictionary.GetCount() - 1;
+ }
+ m_Dictionary.SetCurSel(curSel);
+ break;
+ }
+
+ case kCopy:
+ {
+ _auto_Dict = 0;
+ AddDict(0);
+ m_Dictionary.SetCurSel(0);
+ break;
+ }
+ }
+}
+
+
+UInt32 CCompressDialog::GetComboValue(NWindows::NControl::CComboBox &c, int defMax)
+{
+ if (c.GetCount() <= defMax)
+ return (UInt32)(Int32)-1;
+ return (UInt32)c.GetItemData_of_CurSel();
+}
+
+
+UInt64 CCompressDialog::GetComboValue_64(NWindows::NControl::CComboBox &c, int defMax)
+{
+ if (c.GetCount() <= defMax)
+ return (UInt64)(Int64)-1;
+ // LRESULT is signed. so we cast it to unsigned size_t at first:
+ LRESULT val = c.GetItemData_of_CurSel();
+ if (val == (LPARAM)(INT_PTR)(-1))
+ return (UInt64)(Int64)-1;
+ return (UInt64)(size_t)c.GetItemData_of_CurSel();
+}
+
+UInt32 CCompressDialog::GetLevel2()
+{
+ UInt32 level = GetLevel();
+ if (level == (UInt32)(Int32)-1)
+ level = 5;
+ return level;
+}
+
+
+int CCompressDialog::AddOrder(UInt32 size)
+{
+ char s[32];
+ ConvertUInt32ToString(size, s);
+ const int index = (int)ComboBox_AddStringAscii(m_Order, s);
+ m_Order.SetItemData(index, (LPARAM)size);
+ return index;
+}
+
+int CCompressDialog::AddOrder_Auto()
+{
+ AString s;
+ s.Add_UInt32(_auto_Order);
+ Modify_Auto(s);
+ int index = (int)ComboBox_AddStringAscii(m_Order, s);
+ m_Order.SetItemData(index, (LPARAM)(INT_PTR)(-1));
+ return index;
+}
+
+void CCompressDialog::SetOrder2()
+{
+ m_Order.ResetContent();
+
+ _auto_Order = 1;
+
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ UInt32 defaultOrder = (UInt32)(Int32)-1;
+
+ {
+ const int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ if (IsMethodEqualTo(fo.Method))
+ defaultOrder = fo.Order;
+ }
+ }
+
+ const int methodID = GetMethodID();
+ const UInt32 level = GetLevel2();
+ if (methodID < 0)
+ return;
+
+ switch (methodID)
+ {
+ case kLZMA:
+ case kLZMA2:
+ {
+ _auto_Order = (level < 7 ? 32 : 64);
+ int curSel = AddOrder_Auto();
+ for (unsigned i = 2 * 2; i < 8 * 2; i++)
+ {
+ UInt32 order = ((UInt32)(2 + (i & 1)) << (i / 2));
+ if (order > 256)
+ order = 273;
+ const int index = AddOrder(order);
+ if (defaultOrder != (UInt32)(Int32)-1)
+ if (order <= defaultOrder || curSel <= 0)
+ curSel = index;
+ }
+ m_Order.SetCurSel(curSel);
+ break;
+ }
+
+ /*
+ case kZSTD:
+ {
+ {
+ CZstdEncProps props;
+ ZstdEncProps_Init(&props);
+ // props.level_zstd = level;
+ props.level_7z = level;
+ ZstdEncProps_NormalizeFull(&props);
+ _auto_Order = props.targetLength;
+ if (props.strategy < ZSTD_strategy_btopt)
+ {
+ // ZSTD_strategy_fast uses targetLength to change fast level.
+ // targetLength probably is used only in ZSTD_strategy_btopt and higher
+ break;
+ }
+ }
+ int curSel = AddOrder_Auto();
+
+ for (unsigned i = 6; i <= 9 * 2; i++)
+ {
+ UInt32 order = ((UInt32)(2 + (i & 1)) << (i / 2));
+ // if (order > 999) order = 999;
+ const int index = AddOrder(order);
+ if (defaultOrder != (UInt32)(Int32)-1)
+ if (order <= defaultOrder || curSel <= 0)
+ curSel = index;
+ }
+ m_Order.SetCurSel(curSel);
+ break;
+ }
+ */
+
+ case kDeflate:
+ case kDeflate64:
+ {
+ {
+ if (level >= 9) _auto_Order = 128;
+ else if (level >= 7) _auto_Order = 64;
+ else _auto_Order = 32;
+ }
+ int curSel = AddOrder_Auto();
+ for (unsigned i = 2 * 2; i < 8 * 2; i++)
+ {
+ UInt32 order = ((UInt32)(2 + (i & 1)) << (i / 2));
+ if (order > 256)
+ order = (methodID == kDeflate64 ? 257 : 258);
+ const int index = AddOrder(order);
+ if (defaultOrder != (UInt32)(Int32)-1)
+ if (order <= defaultOrder || curSel <= 0)
+ curSel = index;
+ }
+
+ m_Order.SetCurSel(curSel);
+ break;
+ }
+
+ case kPPMd:
+ {
+ {
+ if (level >= 9) _auto_Order = 32;
+ else if (level >= 7) _auto_Order = 16;
+ else if (level >= 5) _auto_Order = 6;
+ else _auto_Order = 4;
+ }
+
+ int curSel = AddOrder_Auto();
+
+ for (unsigned i = 0;; i++)
+ {
+ UInt32 order = i + 2;
+ if (i >= 2)
+ order = (4 + ((i - 2) & 3)) << ((i - 2) / 4);
+ const int index = AddOrder(order);
+ if (defaultOrder != (UInt32)(Int32)-1)
+ if (order <= defaultOrder || curSel <= 0)
+ curSel = index;
+ if (order >= 32)
+ break;
+ }
+ m_Order.SetCurSel(curSel);
+ break;
+ }
+
+ case kPPMdZip:
+ {
+ _auto_Order = level + 3;
+ int curSel = AddOrder_Auto();
+ for (unsigned i = 2; i <= 16; i++)
+ {
+ const int index = AddOrder(i);
+ if (defaultOrder != (UInt32)(Int32)-1)
+ if (i <= defaultOrder || curSel <= 0)
+ curSel = index;
+ }
+ m_Order.SetCurSel(curSel);
+ break;
+ }
+
+ // case kBZip2:
+ default:
+ break;
+ }
+}
+
+bool CCompressDialog::GetOrderMode()
+{
+ switch (GetMethodID())
+ {
+ case kPPMd:
+ case kPPMdZip:
+ return true;
+ }
+ return false;
+}
+
+
+static UInt64 Get_Lzma2_ChunkSize(UInt64 dict)
+{
+ // we use same default chunk sizes as defined in 7z encoder and lzma2 encoder
+ UInt64 cs = (UInt64)dict << 2;
+ const UInt32 kMinSize = (UInt32)1 << 20;
+ const UInt32 kMaxSize = (UInt32)1 << 28;
+ if (cs < kMinSize) cs = kMinSize;
+ if (cs > kMaxSize) cs = kMaxSize;
+ if (cs < dict) cs = dict;
+ cs += (kMinSize - 1);
+ cs &= ~(UInt64)(kMinSize - 1);
+ return cs;
+}
+
+
+static void Add_Size(AString &s, UInt64 val)
+{
+ unsigned moveBits = 0;
+ char c = 0;
+ if ((val & 0x3FFFFFFF) == 0) { moveBits = 30; c = 'G'; }
+ else if ((val & 0xFFFFF) == 0) { moveBits = 20; c = 'M'; }
+ else if ((val & 0x3FF) == 0) { moveBits = 10; c = 'K'; }
+ s.Add_UInt64(val >> moveBits);
+ s.Add_Space();
+ if (moveBits != 0)
+ s += c;
+ s += 'B';
+}
+
+
+void CCompressDialog::SetSolidBlockSize2()
+{
+ m_Solid.ResetContent();
+ _auto_Solid = 1 << 20;
+
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ if (!fi.Solid_())
+ return;
+
+ const UInt32 level = GetLevel2();
+ if (level == 0)
+ return;
+
+ UInt64 dict = GetDict2();
+ if (dict == (UInt64)(Int64)-1)
+ {
+ dict = 1 << 25; // default dict for unknown methods
+ // return;
+ }
+
+
+ UInt32 defaultBlockSize = (UInt32)(Int32)-1;
+
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+
+ /*
+ if (usePrevDictionary)
+ defaultBlockSize = GetBlockSizeSpec();
+ else
+ */
+ {
+ const int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ if (IsMethodEqualTo(fo.Method))
+ defaultBlockSize = fo.BlockLogSize;
+ }
+ }
+
+ const bool is7z = ai.Is_7z();
+
+ const UInt64 cs = Get_Lzma2_ChunkSize(dict);
+
+ // Solid Block Size
+ UInt64 blockSize = cs; // for xz
+
+ if (is7z)
+ {
+ // we use same default block sizes as defined in 7z encoder
+ UInt64 kMaxSize = (UInt64)1 << 32;
+ const int methodId = GetMethodID();
+ if (methodId == kLZMA2)
+ {
+ blockSize = cs << 6;
+ kMaxSize = (UInt64)1 << 34;
+ }
+ else
+ {
+ UInt64 dict2 = dict;
+ if (methodId == kBZip2)
+ {
+ dict2 /= 100000;
+ if (dict2 < 1)
+ dict2 = 1;
+ dict2 *= 100000;
+ }
+ blockSize = dict2 << 7;
+ }
+
+ const UInt32 kMinSize = (UInt32)1 << 24;
+ if (blockSize < kMinSize) blockSize = kMinSize;
+ if (blockSize > kMaxSize) blockSize = kMaxSize;
+ }
+
+ _auto_Solid = blockSize;
+
+ int curSel;
+ {
+ AString s;
+ Add_Size(s, _auto_Solid);
+ Modify_Auto(s);
+ const int index = (int)ComboBox_AddStringAscii(m_Solid, s);
+ m_Solid.SetItemData(index, (LPARAM)(UInt32)(Int32)-1);
+ curSel = index;
+ }
+
+ if (is7z)
+ {
+ UString s ('-');
+ // kSolidLog_NoSolid = 0 for xz means default blockSize
+ if (is7z)
+ LangString(IDS_COMPRESS_NON_SOLID, s);
+ const int index = (int)m_Solid.AddString(s);
+ m_Solid.SetItemData(index, (LPARAM)(UInt32)kSolidLog_NoSolid);
+ if (defaultBlockSize == kSolidLog_NoSolid)
+ curSel = index;
+ }
+
+ for (unsigned i = 20; i <= 36; i++)
+ {
+ AString s;
+ Add_Size(s, (UInt64)1 << i);
+ const int index = (int)ComboBox_AddStringAscii(m_Solid, s);
+ m_Solid.SetItemData(index, (LPARAM)(UInt32)i);
+ if (defaultBlockSize != (UInt32)(Int32)-1)
+ if (i <= defaultBlockSize || index <= 1)
+ curSel = index;
+ }
+
+ {
+ const int index = (int)m_Solid.AddString(LangString(IDS_COMPRESS_SOLID));
+ m_Solid.SetItemData(index, (LPARAM)kSolidLog_FullSolid);
+ if (defaultBlockSize == kSolidLog_FullSolid)
+ curSel = index;
+ }
+
+ m_Solid.SetCurSel(curSel);
+}
+
+
+/*
+static void ZstdEncProps_SetDictProps_From_CompressDialog(CZstdEncProps *props, CCompressDialog &cd)
+{
+ {
+ const UInt64 d64 = cd.GetDictSpec();
+ UInt32 d32 = 0; // 0 is default for ZstdEncProps::windowLog
+ if (d64 != (UInt64)(Int64)-1)
+ {
+ d32 = (UInt32)d64;
+ if (d32 != d64)
+ d32 = (UInt32)(Int32)-2;
+ }
+ ZstdEncProps_Set_WindowSize(props, d32);
+ }
+ {
+ const UInt64 d64 = cd.GetDictChainSpec();
+ UInt32 d32 = 0; // 0 is default for ZstdEncProps::windowLog_Chain
+ if (d64 != (UInt64)(Int64)-1)
+ {
+ d32 = (UInt32)d64;
+ if (d32 != d64)
+ d32 = (UInt32)(Int32)-2;
+ }
+ ZstdEncProps_Set_WindowChainSize(props, d32);
+ }
+}
+
+static bool Is_Zstd_Mt_Supported()
+{
+ if (!GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "InitializeConditionVariable"))
+ return false;
+ return true;
+}
+*/
+
+static const char *k_ST_Threads = " (ST)";
+
+void CCompressDialog::SetNumThreads2()
+{
+ _auto_NumThreads = 1;
+
+ m_NumThreads.ResetContent();
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ if (!fi.MultiThread_())
+ return;
+
+ const UInt32 numHardwareThreads = NSystem::GetNumberOfProcessors();
+ // 64; // for debug:
+
+ UInt32 defaultValue = numHardwareThreads;
+ bool useAutoThreads = true;
+
+ {
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ if (IsMethodEqualTo(fo.Method) && fo.NumThreads != (UInt32)(Int32)-1)
+ {
+ defaultValue = fo.NumThreads;
+ useAutoThreads = false;
+ }
+ }
+ }
+
+ // const UInt32 num_ZSTD_threads_MAX = Is_Zstd_Mt_Supported() ? MY_ZSTDMT_NBWORKERS_MAX : 0;
+
+ UInt32 numAlgoThreadsMax = numHardwareThreads * 2;
+ const int methodID = GetMethodID();
+
+ switch (methodID)
+ {
+ case kLZMA: numAlgoThreadsMax = 2; break;
+ case kLZMA2: numAlgoThreadsMax = 256; break;
+ case kBZip2: numAlgoThreadsMax = 32; break;
+ // case kZSTD: numAlgoThreadsMax = num_ZSTD_threads_MAX; break;
+ case kCopy:
+ case kPPMd:
+ case kDeflate:
+ case kDeflate64:
+ case kPPMdZip:
+ numAlgoThreadsMax = 1;
+ }
+ const bool isZip = IsZipFormat();
+ if (isZip)
+ {
+ numAlgoThreadsMax =
+ #ifdef _WIN32
+ 64; // _WIN32 supports only 64 threads in one group. So no need for more threads here
+ #else
+ 128;
+ #endif
+ }
+
+ UInt32 autoThreads = numHardwareThreads;
+ if (autoThreads > numAlgoThreadsMax)
+ autoThreads = numAlgoThreadsMax;
+
+ const UInt64 memUse_Limit = Get_MemUse_Bytes();
+
+ if (_ramSize_Defined)
+ if (autoThreads > 1
+ // || (autoThreads == 0 && methodID == kZSTD)
+ )
+ {
+ if (isZip)
+ {
+ for (; autoThreads > 1; autoThreads--)
+ {
+ const UInt64 dict64 = GetDict2();
+ UInt64 decompressMemory;
+ const UInt64 usage = GetMemoryUsage_Threads_Dict_DecompMem(autoThreads, dict64, decompressMemory);
+ if (usage <= memUse_Limit)
+ break;
+ }
+ }
+ else if (methodID == kLZMA2)
+ {
+ const UInt64 dict64 = GetDict2();
+ const UInt32 numThreads1 = (GetLevel2() >= 5 ? 2 : 1);
+ UInt32 numBlockThreads = autoThreads / numThreads1;
+ for (; numBlockThreads > 1; numBlockThreads--)
+ {
+ autoThreads = numBlockThreads * numThreads1;
+ UInt64 decompressMemory;
+ const UInt64 usage = GetMemoryUsage_Threads_Dict_DecompMem(autoThreads, dict64, decompressMemory);
+ if (usage <= memUse_Limit)
+ break;
+ }
+ autoThreads = numBlockThreads * numThreads1;
+ }
+ /*
+ else if (methodID == kZSTD)
+ {
+ if (num_ZSTD_threads_MAX != 0)
+ {
+ CZstdEncProps props;
+ ZstdEncProps_Init(&props);
+ // props.level_zstd = level;
+ props.level_7z = GetLevel2();
+ ZstdEncProps_SetDictProps_From_CompressDialog(&props, *this);
+ autoThreads = ZstdEncProps_GetNumThreads_for_MemUsageLimit(&props, memUse_Limit, autoThreads);
+ }
+ }
+ */
+ }
+
+ _auto_NumThreads = autoThreads;
+
+ int curSel = -1;
+ {
+ AString s;
+ s.Add_UInt32(autoThreads);
+ if (autoThreads == 0) s += k_ST_Threads;
+ Modify_Auto(s);
+ const int index = (int)ComboBox_AddStringAscii(m_NumThreads, s);
+ m_NumThreads.SetItemData(index, (LPARAM)(INT_PTR)(-1));
+ // m_NumThreads.SetItemData(index, autoThreads);
+ if (useAutoThreads)
+ curSel = index;
+ }
+
+ if (numAlgoThreadsMax != autoThreads || autoThreads != 1)
+ for (UInt32 i =
+ // (methodID == kZSTD) ? 0 :
+ 1;
+ i <= numHardwareThreads * 2 && i <= numAlgoThreadsMax; i++)
+ {
+ AString s;
+ s.Add_UInt32(i);
+ if (i == 0) s += k_ST_Threads;
+ const int index = (int)ComboBox_AddStringAscii(m_NumThreads, s);
+ m_NumThreads.SetItemData(index, (LPARAM)(UInt32)i);
+ if (!useAutoThreads && i == defaultValue)
+ curSel = index;
+ }
+
+ m_NumThreads.SetCurSel(curSel);
+}
+
+
+static void AddMemSize(UString &res, UInt64 size)
+{
+ char c;
+ unsigned moveBits = 0;
+ if (size >= ((UInt64)1 << 31) && (size & 0x3FFFFFFF) == 0)
+ { moveBits = 30; c = 'G'; }
+ else // if (size >= ((UInt32)1 << 21) && (size & 0xFFFFF) == 0)
+ { moveBits = 20; c = 'M'; }
+ // else { moveBits = 10; c = 'K'; }
+ res.Add_UInt64(size >> moveBits);
+ res.Add_Space();
+ if (moveBits != 0)
+ res += c;
+ res += 'B';
+}
+
+
+int CCompressDialog::AddMemComboItem(UInt64 val, bool isPercent, bool isDefault)
+{
+ UString sUser;
+ UString sRegistry;
+ if (isPercent)
+ {
+ UString s;
+ s.Add_UInt64(val);
+ s += '%';
+ if (isDefault)
+ sUser = k_Auto_Prefix;
+ else
+ sRegistry = s;
+ sUser += s;
+ }
+ else
+ {
+ AddMemSize(sUser, val);
+ sRegistry = sUser;
+ for (;;)
+ {
+ const int pos = sRegistry.Find(L' ');
+ if (pos < 0)
+ break;
+ sRegistry.Delete(pos);
+ }
+ if (!sRegistry.IsEmpty())
+ if (sRegistry.Back() == 'B')
+ sRegistry.DeleteBack();
+ }
+ const unsigned dataIndex = _memUse_Strings.Add(sRegistry);
+ const int index = (int)m_MemUse.AddString(sUser);
+ m_MemUse.SetItemData(index, (LPARAM)dataIndex);
+ return index;
+}
+
+
+
+void CCompressDialog::SetMemUseCombo()
+{
+ _memUse_Strings.Clear();
+ m_MemUse.ResetContent();
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+
+ {
+ const bool enable = fi.MemUse_();
+ ShowItem_Bool(IDT_COMPRESS_MEMORY, enable);
+ ShowItem_Bool(IDT_COMPRESS_MEMORY_VALUE, enable);
+ ShowItem_Bool(IDT_COMPRESS_MEMORY_DE, enable);
+ ShowItem_Bool(IDT_COMPRESS_MEMORY_DE_VALUE, enable);
+ ShowItem_Bool(IDC_COMPRESS_MEM_USE, enable);
+ EnableItem(IDC_COMPRESS_MEM_USE, enable);
+ if (!enable)
+ return;
+ }
+
+ UInt64 curMem_Bytes = 0;
+ UInt64 curMem_Percents = 0;
+ bool needSetCur_Bytes = false;
+ bool needSetCur_Percents = false;
+ {
+ const NCompression::CFormatOptions &fo = Get_FormatOptions();
+ if (!fo.MemUse.IsEmpty())
+ {
+ NCompression::CMemUse mu;
+ mu.Parse(fo.MemUse);
+ if (mu.IsDefined)
+ {
+ if (mu.IsPercent)
+ {
+ curMem_Percents = mu.Val;
+ needSetCur_Percents = true;
+ }
+ else
+ {
+ curMem_Bytes = mu.GetBytes(_ramSize_Reduced);
+ needSetCur_Bytes = true;
+ }
+ }
+ }
+ }
+
+
+ // 80% - is auto usage limit in handlers
+ AddMemComboItem(80, true, true);
+ m_MemUse.SetCurSel(0);
+
+ {
+ for (unsigned i = 10;; i += 10)
+ {
+ UInt64 size = i;
+ if (i > 100)
+ size = (UInt64)(Int64)-1;
+ if (needSetCur_Percents && size >= curMem_Percents)
+ {
+ const int index = AddMemComboItem(curMem_Percents, true);
+ m_MemUse.SetCurSel(index);
+ needSetCur_Percents = false;
+ if (size == curMem_Percents)
+ continue;
+ }
+ if (size == (UInt64)(Int64)-1)
+ break;
+ AddMemComboItem(size, true);
+ }
+ }
+ {
+ for (unsigned i = (27) * 2;; i++)
+ {
+ UInt64 size = (UInt64)(2 + (i & 1)) << (i / 2);
+ if (i > (20 + sizeof(size_t) * 3 - 1) * 2)
+ size = (UInt64)(Int64)-1;
+ if (needSetCur_Bytes && size >= curMem_Bytes)
+ {
+ const int index = AddMemComboItem(curMem_Bytes);
+ m_MemUse.SetCurSel(index);
+ needSetCur_Bytes = false;
+ if (size == curMem_Bytes)
+ continue;
+ }
+ if (size == (UInt64)(Int64)-1)
+ break;
+ AddMemComboItem(size);
+ }
+ }
+}
+
+
+UString CCompressDialog::Get_MemUse_Spec()
+{
+ if (m_MemUse.GetCount() < 1)
+ return UString();
+ return _memUse_Strings[(unsigned)m_MemUse.GetItemData_of_CurSel()];
+}
+
+
+UInt64 CCompressDialog::Get_MemUse_Bytes()
+{
+ const UString mus = Get_MemUse_Spec();
+ NCompression::CMemUse mu;
+ if (!mus.IsEmpty())
+ {
+ mu.Parse(mus);
+ if (mu.IsDefined)
+ return mu.GetBytes(_ramSize_Reduced);
+ }
+ return _ramUsage_Auto; // _ramSize_Reduced; // _ramSize;;
+}
+
+
+
+UInt64 CCompressDialog::GetMemoryUsage_DecompMem(UInt64 &decompressMemory)
+{
+ return GetMemoryUsage_Dict_DecompMem(GetDict2(), decompressMemory);
+}
+
+
+/*
+we could use that function to reduce the dictionary if small RAM
+UInt64 CCompressDialog::GetMemoryUsageComp_Threads_Dict(UInt32 numThreads, UInt64 dict64)
+{
+ UInt64 decompressMemory;
+ return GetMemoryUsage_Threads_Dict_DecompMem(numThreads, dict64, decompressMemory);
+}
+*/
+
+
+UInt64 CCompressDialog::GetMemoryUsage_Dict_DecompMem(UInt64 dict64, UInt64 &decompressMemory)
+{
+ return GetMemoryUsage_Threads_Dict_DecompMem(GetNumThreads2(), dict64, decompressMemory);
+}
+
+UInt64 CCompressDialog::GetMemoryUsage_Threads_Dict_DecompMem(UInt32 numThreads, UInt64 dict64, UInt64 &decompressMemory)
+{
+ decompressMemory = (UInt64)(Int64)-1;
+
+ const UInt32 level = GetLevel2();
+ if (level == 0 && !Get_ArcInfoEx().Is_Zstd())
+ {
+ decompressMemory = (1 << 20);
+ return decompressMemory;
+ }
+ UInt64 size = 0;
+
+ const CFormatInfo &fi = g_Formats[GetStaticFormatIndex()];
+ if (fi.Filter_() && level >= 9)
+ size += (12 << 20) * 2 + (5 << 20);
+ // UInt32 numThreads = GetNumThreads2();
+
+ UInt32 numMainZipThreads = 1;
+
+ if (IsZipFormat())
+ {
+ UInt32 numSubThreads = 1;
+ if (GetMethodID() == kLZMA && numThreads > 1 && level >= 5)
+ numSubThreads = 2;
+ numMainZipThreads = numThreads / numSubThreads;
+ if (numMainZipThreads > 1)
+ size += (UInt64)numMainZipThreads * ((size_t)sizeof(size_t) << 23);
+ else
+ numMainZipThreads = 1;
+ }
+
+ const int methodId = GetMethodID();
+
+ if (dict64 == (UInt64)(Int64)-1
+ // && methodId != kZSTD
+ )
+ return (UInt64)(Int64)-1;
+
+
+ switch (methodId)
+ {
+ case kLZMA:
+ case kLZMA2:
+ {
+ const UInt32 dict = (dict64 >= kLzmaMaxDictSize ? kLzmaMaxDictSize : (UInt32)dict64);
+ UInt32 hs = dict - 1;
+ hs |= (hs >> 1);
+ hs |= (hs >> 2);
+ hs |= (hs >> 4);
+ hs |= (hs >> 8);
+ hs >>= 1;
+ if (hs >= (1 << 24))
+ hs >>= 1;
+ hs |= (1 << 16) - 1;
+ // if (numHashBytes >= 5)
+ if (level < 5)
+ hs |= (256 << 10) - 1;
+ hs++;
+ UInt64 size1 = (UInt64)hs * 4;
+ size1 += (UInt64)dict * 4;
+ if (level >= 5)
+ size1 += (UInt64)dict * 4;
+ size1 += (2 << 20);
+
+ UInt32 numThreads1 = 1;
+ if (numThreads > 1 && level >= 5)
+ {
+ size1 += (2 << 20) + (4 << 20);
+ numThreads1 = 2;
+ }
+
+ UInt32 numBlockThreads = numThreads / numThreads1;
+
+ UInt64 chunkSize = 0; // it's solid chunk
+
+ if (methodId != kLZMA && numBlockThreads != 1)
+ {
+ chunkSize = Get_Lzma2_ChunkSize(dict);
+
+ if (IsXzFormat())
+ {
+ UInt32 blockSizeLog = GetBlockSizeSpec();
+ if (blockSizeLog != (UInt32)(Int32)-1)
+ {
+ if (blockSizeLog == kSolidLog_FullSolid)
+ {
+ numBlockThreads = 1;
+ chunkSize = 0;
+ }
+ else if (blockSizeLog != kSolidLog_NoSolid)
+ chunkSize = (UInt64)1 << blockSizeLog;
+ }
+ }
+ }
+
+ if (chunkSize == 0)
+ {
+ const UInt32 kBlockSizeMax = (UInt32)0 - (UInt32)(1 << 16);
+ UInt64 blockSize = (UInt64)dict + (1 << 16)
+ + (numThreads1 > 1 ? (1 << 20) : 0);
+ blockSize += (blockSize >> (blockSize < ((UInt32)1 << 30) ? 1 : 2));
+ if (blockSize >= kBlockSizeMax)
+ blockSize = kBlockSizeMax;
+ size += numBlockThreads * (size1 + blockSize);
+ }
+ else
+ {
+ size += numBlockThreads * (size1 + chunkSize);
+ UInt32 numPackChunks = numBlockThreads + (numBlockThreads / 8) + 1;
+ if (chunkSize < ((UInt32)1 << 26)) numBlockThreads++;
+ if (chunkSize < ((UInt32)1 << 24)) numBlockThreads++;
+ if (chunkSize < ((UInt32)1 << 22)) numBlockThreads++;
+ size += numPackChunks * chunkSize;
+ }
+
+ decompressMemory = dict + (2 << 20);
+ return size;
+ }
+
+ /*
+ case kZSTD:
+ {
+ CZstdEncProps props;
+ ZstdEncProps_Init(&props);
+ // props.level_zstd = level;
+ props.level_7z = level;
+ props.nbWorkers = numThreads;
+ ZstdEncProps_SetDictProps_From_CompressDialog(&props, *this);
+ ZstdEncProps_NormalizeFull(&props);
+ size = ZstdEncProps_GetMemUsage(&props);
+ decompressMemory = (UInt64)1 << props.windowLog;
+ return size;
+ }
+ */
+
+ case kPPMd:
+ {
+ decompressMemory = dict64 + (2 << 20);
+ return size + decompressMemory;
+ }
+
+ case kDeflate:
+ case kDeflate64:
+ {
+ UInt64 size1 = 3 << 20;
+ // if (level >= 7)
+ size1 += (1 << 20);
+ size += size1 * numMainZipThreads;
+ decompressMemory = (2 << 20);
+ return size;
+ }
+
+ case kBZip2:
+ {
+ decompressMemory = (7 << 20);
+ UInt64 memForOneThread = (10 << 20);
+ return size + memForOneThread * numThreads;
+ }
+
+ case kPPMdZip:
+ {
+ decompressMemory = dict64 + (2 << 20);
+ return size + (UInt64)decompressMemory * numThreads;
+ }
+ }
+
+ return (UInt64)(Int64)-1;
+}
+
+
+
+static void AddMemUsage(UString &s, UInt64 v)
+{
+ const char *post;
+ if (v <= ((UInt64)16 << 30))
+ {
+ v = (v + (1 << 20) - 1) >> 20;
+ post = "MB";
+ }
+ else if (v <= ((UInt64)64 << 40))
+ {
+ v = (v + (1 << 30) - 1) >> 30;
+ post = "GB";
+ }
+ else
+ {
+ const UInt64 v2 = v + ((UInt64)1 << 40) - 1;
+ if (v <= v2)
+ v = v2;
+ v >>= 40;
+ post = "TB";
+ }
+ s.Add_UInt64(v);
+ s.Add_Space();
+ s += post;
+}
+
+
+void CCompressDialog::PrintMemUsage(UINT res, UInt64 value)
+{
+ if (value == (UInt64)(Int64)-1)
+ {
+ SetItemText(res, TEXT("?"));
+ return;
+ }
+ UString s;
+ AddMemUsage(s, value);
+ if (res == IDT_COMPRESS_MEMORY_VALUE)
+ {
+ const UString mus = Get_MemUse_Spec();
+ NCompression::CMemUse mu;
+ if (!mus.IsEmpty())
+ mu.Parse(mus);
+ if (mu.IsDefined)
+ {
+ s += " / ";
+ AddMemUsage(s, mu.GetBytes(_ramSize_Reduced));
+ }
+ else if (_ramSize_Defined)
+ {
+ s += " / ";
+ AddMemUsage(s, _ramUsage_Auto);
+ }
+
+ if (_ramSize_Defined)
+ {
+ s += " / ";
+ AddMemUsage(s, _ramSize);
+ }
+ }
+ SetItemText(res, s);
+}
+
+
+void CCompressDialog::SetMemoryUsage()
+{
+ UInt64 decompressMem;
+ const UInt64 memUsage = GetMemoryUsage_DecompMem(decompressMem);
+ PrintMemUsage(IDT_COMPRESS_MEMORY_VALUE, memUsage);
+ PrintMemUsage(IDT_COMPRESS_MEMORY_DE_VALUE, decompressMem);
+ #ifdef PRINT_PARAMS
+ Print_Params();
+ #endif
+}
+
+
+
+#ifdef PRINT_PARAMS
+
+static const char kPropDelimeter = ' '; // ':'
+
+static void AddPropName(AString &s, const char *name)
+{
+ if (!s.IsEmpty())
+ s += kPropDelimeter;
+ s += name;
+}
+
+static void AddProp(AString &s, const char *name, unsigned v)
+{
+ AddPropName(s, name);
+ s.Add_UInt32(v);
+}
+
+static void AddProp_switch(AString &s, const char *name, E_ZSTD_paramSwitch_e e)
+{
+ AddPropName(s, name);
+ s += e == k_ZSTD_ps_enable ? "" : "-";
+}
+
+static void PrintPropAsLog(AString &s, const char *name, size_t v)
+{
+ AddPropName(s, name);
+ for (unsigned i = 0; i < sizeof(size_t) * 8; i++)
+ {
+ if (((size_t)1 << i) == v)
+ {
+ s.Add_UInt32(i);
+ return;
+ }
+ }
+ char c = 'b';
+ if ((v & 0x3FFFFFFF) == 0) { v >>= 30; c = 'G'; }
+ else if ((v & 0xFFFFF) == 0) { v >>= 20; c = 'M'; }
+ else if ((v & 0x3FF) == 0) { v >>= 10; c = 'K'; }
+ s.Add_UInt64(v);
+ s += c;
+}
+
+static void ZstdEncProps_Print(CZstdEncProps *props, AString &s)
+{
+ if (props->level_zstd >= 0)
+ AddProp(s, "zx", props->level_zstd);
+ else
+ AddProp(s, "zf", -(props->level_zstd));
+ AddProp(s, "a", props->strategy);
+ AddProp(s, "d", props->windowLog);
+ AddProp(s, "zclog", props->chainLog);
+ AddProp(s, "zhb", props->hashLog);
+ AddProp(s, "mml", props->minMatch);
+ AddProp(s, "mcb", props->searchLog);
+ AddProp(s, "fb", props->targetLength);
+ AddProp(s, "mt", props->nbWorkers);
+ PrintPropAsLog(s, "c", props->jobSize);
+ AddProp(s, "zov", props->overlapLog);
+ PrintPropAsLog(s, "ztps", props->targetPrefixSize);
+ AddProp_switch(s, "zmfr", props->useRowMatchFinder);
+ if (props->ldmParams.enableLdm == k_ZSTD_ps_enable)
+ {
+ AddProp_switch(s, "zle", props->ldmParams.enableLdm);
+ AddProp(s, "zlhb", props->ldmParams.hashLog);
+ AddProp(s, "zlbb", props->ldmParams.bucketSizeLog);
+ AddProp(s, "zlmml", props->ldmParams.minMatchLength);
+ AddProp(s, "zlhrb", props->ldmParams.hashRateLog);
+ }
+}
+
+void CCompressDialog::Print_Params()
+{
+ {
+ CZstdEncProps props;
+ ZstdEncProps_Init(&props);
+ // props.level_zstd = level;
+ props.level_7z = GetLevel2();
+ ZstdEncProps_SetDictProps_From_CompressDialog(&props, *this);
+ {
+ UInt32 order = GetOrderSpec();
+ if (order != (UInt32)(Int32)-1)
+ props.targetLength = GetOrderSpec();
+ }
+ props.nbWorkers = GetNumThreads2();
+ // props.windowLog = 18; // for debug
+ ZstdEncProps_NormalizeFull(&props);
+ AString s;
+ ZstdEncProps_Print(&props, s);
+ SetItemTextA(IDT_COMPRESS_PARAMS_INFO, s);
+ }
+}
+
+#endif // PRINT_PARAMS
+
+
+
+void CCompressDialog::SetParams()
+{
+ const CArcInfoEx &ai = Get_ArcInfoEx();
+ m_Params.SetText(TEXT(""));
+ const int index = FindRegistryFormat(ai.Name);
+ if (index >= 0)
+ {
+ const NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ m_Params.SetText(fo.Options);
+ }
+}
+
+void CCompressDialog::SaveOptionsInMem()
+{
+ /* these options are for (Info.FormatIndex).
+ If it's called just after format changing,
+ then it's format that was selected before format changing
+ So we store previous format properties */
+
+ m_Params.GetText(Info.Options);
+ Info.Options.Trim();
+
+ const CArcInfoEx &ai = (*ArcFormats)[Info.FormatIndex];
+ const unsigned index = FindRegistryFormat_Always(ai.Name);
+ NCompression::CFormatOptions &fo = m_RegistryInfo.Formats[index];
+ fo.Options = Info.Options;
+ fo.Level = GetLevelSpec();
+ {
+ const UInt64 dict64 = GetDictSpec();
+ UInt32 dict32;
+ if (dict64 == (UInt64)(Int64)-1)
+ dict32 = (UInt32)(Int32)-1;
+ else
+ {
+ dict32 = (UInt32)dict64;
+ if (dict64 != dict32)
+ {
+ /* here we must write 32-bit value for registry that indicates big_value
+ (UInt32)(Int32)-1 : is used as marker for default size
+ (UInt32)(Int32)-2 : it can be used to indicate big value (4 GiB)
+ the value must be larger than threshold
+ */
+ dict32 = (UInt32)(Int32)-2;
+ // dict32 = kLzmaMaxDictSize; // it must be larger than threshold
+ }
+ }
+ fo.Dictionary = dict32;
+ }
+ /*
+ {
+ const UInt64 dict64 = GetDictChainSpec();
+ UInt32 dict32;
+ if (dict64 == (UInt64)(Int64)-1)
+ dict32 = (UInt32)(Int32)-1;
+ else
+ {
+ dict32 = (UInt32)dict64;
+ if (dict64 != dict32)
+ {
+ dict32 = (UInt32)(Int32)-2;
+ // dict32 = k_Zstd_MAX_DictSize; // it must be larger than threshold
+ }
+ }
+ fo.DictionaryChain = dict32;
+ }
+ */
+
+ fo.Order = GetOrderSpec();
+ fo.Method = GetMethodSpec();
+ fo.EncryptionMethod = GetEncryptionMethodSpec();
+ fo.NumThreads = GetNumThreadsSpec();
+ fo.BlockLogSize = GetBlockSizeSpec();
+ fo.MemUse = Get_MemUse_Spec();
+}
+
+
+unsigned CCompressDialog::GetFormatIndex()
+{
+ return (unsigned)m_Format.GetItemData_of_CurSel();
+}
+
+
+
+static void AddText_from_BoolPair(AString &s, const char *name, const CBoolPair &bp)
+{
+ if (bp.Def)
+ {
+ s.Add_OptSpaced(name);
+ if (!bp.Val)
+ s += "-";
+ }
+ /*
+ else if (bp.Val)
+ {
+ s.Add_OptSpaced("[");
+ s += name;
+ s += "]";
+ }
+ */
+}
+
+
+static void AddText_from_Bool1(AString &s, const char *name, const CBool1 &b)
+{
+ if (b.Supported && b.Val)
+ s.Add_OptSpaced(name);
+}
+
+
+void CCompressDialog::ShowOptionsString()
+{
+ NCompression::CFormatOptions &fo = Get_FormatOptions();
+
+ AString s;
+ if (fo.IsSet_TimePrec())
+ {
+ s.Add_OptSpaced("tp");
+ s.Add_UInt32(fo.TimePrec);
+ }
+ AddText_from_BoolPair(s, "tm", fo.MTime);
+ AddText_from_BoolPair(s, "tc", fo.CTime);
+ AddText_from_BoolPair(s, "ta", fo.ATime);
+ AddText_from_BoolPair(s, "-stl", fo.SetArcMTime);
+
+ // const CArcInfoEx &ai = Get_ArcInfoEx();
+ AddText_from_Bool1(s, "SL", SymLinks);
+ AddText_from_Bool1(s, "HL", HardLinks);
+ AddText_from_Bool1(s, "AS", AltStreams);
+ AddText_from_Bool1(s, "Sec", NtSecurity);
+
+ // AddText_from_Bool1(s, "Preserve", PreserveATime);
+
+ SetItemText(IDT_COMPRESS_OPTIONS, GetUnicodeString(s));
+}
+
+
+
+
+
+// ---------- OPTIONS ----------
+
+
+void COptionsDialog::CheckButton_Bool1(UINT id, const CBool1 &b1)
+{
+ CheckButton(id, b1.Val);
+}
+
+void COptionsDialog::GetButton_Bool1(UINT id, CBool1 &b1)
+{
+ b1.Val = IsButtonCheckedBool(id);
+}
+
+
+void COptionsDialog::CheckButton_BoolBox(
+ bool supported, const CBoolPair &b2, CBoolBox &bb)
+{
+ const bool isSet = b2.Def;
+ const bool val = isSet ? b2.Val : bb.DefaultVal;
+
+ bb.IsSupported = supported;
+
+ CheckButton (bb.Set_Id, isSet);
+ ShowItem_Bool (bb.Set_Id, supported);
+ CheckButton (bb.Id, val);
+ EnableItem (bb.Id, isSet);
+ ShowItem_Bool (bb.Id, supported);
+}
+
+void COptionsDialog::GetButton_BoolBox(CBoolBox &bb)
+{
+ // we save value for invisible buttons too
+ bb.BoolPair.Val = IsButtonCheckedBool (bb.Id);
+ bb.BoolPair.Def = IsButtonCheckedBool (bb.Set_Id);
+}
+
+
+void COptionsDialog::Store_TimeBoxes()
+{
+ TimePrec = GetPrecSpec();
+ GetButton_BoolBox (MTime);
+ GetButton_BoolBox (CTime);
+ GetButton_BoolBox (ATime);
+ GetButton_BoolBox (ZTime);
+}
+
+
+UInt32 COptionsDialog::GetComboValue(NWindows::NControl::CComboBox &c, int defMax)
+{
+ if (c.GetCount() <= defMax)
+ return (UInt32)(Int32)-1;
+ return (UInt32)c.GetItemData_of_CurSel();
+}
+
+static const unsigned kTimePrec_Win = 0;
+static const unsigned kTimePrec_Unix = 1;
+static const unsigned kTimePrec_DOS = 2;
+static const unsigned kTimePrec_1ns = 3;
+
+static void AddTimeOption(UString &s, UInt32 val, const UString &unit, const char *sys = NULL)
+{
+ // s += " : ";
+ {
+ AString s2;
+ s2.Add_UInt32(val);
+ s += s2;
+ }
+ s.Add_Space();
+ s += unit;
+ if (sys)
+ {
+ s += " : ";
+ s += sys;
+ }
+}
+
+int COptionsDialog::AddPrec(unsigned prec, bool isDefault)
+{
+ UString s;
+ UInt32 writePrec = prec;
+ if (isDefault)
+ {
+ // s += "* ";
+ // writePrec = (UInt32)(Int32)-1;
+ }
+ if (prec == kTimePrec_Win) AddTimeOption(s, 100, NsString, "Windows");
+ else if (prec == kTimePrec_Unix) AddTimeOption(s, 1, SecString, "Unix");
+ else if (prec == kTimePrec_DOS) AddTimeOption(s, 2, SecString, "DOS");
+ else if (prec == kTimePrec_1ns) AddTimeOption(s, 1, NsString, "Linux");
+ else if (prec == k_PropVar_TimePrec_Base) AddTimeOption(s, 1, SecString);
+ else if (prec >= k_PropVar_TimePrec_Base)
+ {
+ UInt32 d = 1;
+ for (unsigned i = prec; i < k_PropVar_TimePrec_Base + 9; i++)
+ d *= 10;
+ AddTimeOption(s, d, NsString);
+ }
+ else
+ s.Add_UInt32(prec);
+ const int index = (int)m_Prec.AddString(s);
+ m_Prec.SetItemData(index, (LPARAM)writePrec);
+ return index;
+}
+
+
+void COptionsDialog::SetPrec()
+{
+ // const CFormatInfo &fi = g_Formats[cd->GetStaticFormatIndex()];
+ const CArcInfoEx &ai = cd->Get_ArcInfoEx();
+
+ // UInt32 flags = fi.Flags;
+
+ UInt32 flags = ai.Get_TimePrecFlags();
+ UInt32 defaultPrec = ai.Get_DefaultTimePrec();
+ if (defaultPrec != 0)
+ flags |= ((UInt32)1 << defaultPrec);
+
+ // const NCompression::CFormatOptions &fo = cd->Get_FormatOptions();
+
+ // unsigned defaultPrec = kTimePrec_Win;
+
+ if (ai.Is_GZip())
+ defaultPrec = kTimePrec_Unix;
+
+ {
+ UString s;
+ s += GetNameOfProperty(kpidType, L"type");
+ s += ": ";
+ s += ai.Name;
+ if (ai.Is_Tar())
+ {
+ const int methodID = cd->GetMethodID();
+
+ // for debug
+ // defaultPrec = kTimePrec_Unix;
+ // flags = (UInt32)1 << kTimePrec_Unix;
+
+ s += ":";
+ if (methodID >= 0 && (unsigned)methodID < Z7_ARRAY_SIZE(kMethodsNames))
+ s += kMethodsNames[methodID];
+ if (methodID == kPosix)
+ {
+ // for debug
+ // flags |= (UInt32)1 << kTimePrec_Win;
+ // flags |= (UInt32)1 << kTimePrec_1ns;
+ }
+ }
+ else
+ {
+ // if (is_for_MethodChanging) return;
+ }
+
+ SetItemText(IDT_COMPRESS_TIME_INFO, s);
+ }
+
+ m_Prec.ResetContent();
+ _auto_Prec = defaultPrec;
+
+ unsigned selectedPrec = defaultPrec;
+ {
+ // if (TimePrec >= kTimePrec_Win && TimePrec <= kTimePrec_DOS)
+ if ((Int32)TimePrec >= 0)
+ selectedPrec = TimePrec;
+ }
+
+ int curSel = -1;
+ int defaultPrecIndex = -1;
+ for (unsigned prec = 0;
+ // prec <= k_PropVar_TimePrec_HighPrec;
+ prec <= k_PropVar_TimePrec_1ns;
+ prec++)
+ {
+ if (((flags >> prec) & 1) == 0)
+ continue;
+ const bool isDefault = (defaultPrec == prec);
+ const int index = AddPrec(prec, isDefault);
+ if (isDefault)
+ defaultPrecIndex = index;
+ if (selectedPrec == prec)
+ curSel = index;
+ }
+
+ if (curSel < 0 && selectedPrec > kTimePrec_DOS)
+ curSel = AddPrec(selectedPrec, false); // isDefault
+ if (curSel < 0)
+ curSel = defaultPrecIndex;
+ if (curSel >= 0)
+ m_Prec.SetCurSel(curSel);
+
+ {
+ const bool isSet = IsSet_TimePrec();
+ const int count = m_Prec.GetCount();
+ const bool showPrec = (count != 0);
+ ShowItem_Bool(IDC_COMPRESS_TIME_PREC, showPrec);
+ ShowItem_Bool(IDT_COMPRESS_TIME_PREC, showPrec);
+ EnableItem(IDC_COMPRESS_TIME_PREC, isSet && (count > 1));
+
+ CheckButton(IDX_COMPRESS_PREC_SET, isSet);
+ const bool setIsSupported = isSet || (count > 1);
+ EnableItem(IDX_COMPRESS_PREC_SET, setIsSupported);
+ ShowItem_Bool(IDX_COMPRESS_PREC_SET, setIsSupported);
+ }
+
+ SetTimeMAC();
+}
+
+
+void COptionsDialog::SetTimeMAC()
+{
+ const CArcInfoEx &ai = cd->Get_ArcInfoEx();
+
+ const
+ bool m_allow = ai.Flags_MTime();
+ bool c_allow = ai.Flags_CTime();
+ bool a_allow = ai.Flags_ATime();
+
+ if (ai.Is_Tar())
+ {
+ const int methodID = cd->GetMethodID();
+ c_allow = false;
+ a_allow = false;
+ if (methodID == kPosix)
+ {
+ // c_allow = true; // do we need it as change time ?
+ a_allow = true;
+ }
+ }
+
+ if (ai.Is_Zip())
+ {
+ // const int methodID = GetMethodID();
+ UInt32 prec = GetPrec();
+ if (prec == (UInt32)(Int32)-1)
+ prec = _auto_Prec;
+ if (prec != kTimePrec_Win)
+ {
+ c_allow = false;
+ a_allow = false;
+ }
+ }
+
+
+ /*
+ MTime.DefaultVal = true;
+ CTime.DefaultVal = false;
+ ATime.DefaultVal = false;
+ */
+
+ MTime.DefaultVal = ai.Flags_MTime_Default();
+ CTime.DefaultVal = ai.Flags_CTime_Default();
+ ATime.DefaultVal = ai.Flags_ATime_Default();
+
+ ZTime.DefaultVal = false;
+
+ const NCompression::CFormatOptions &fo = cd->Get_FormatOptions();
+
+ CheckButton_BoolBox (m_allow, fo.MTime, MTime );
+ CheckButton_BoolBox (c_allow, fo.CTime, CTime );
+ CheckButton_BoolBox (a_allow, fo.ATime, ATime );
+ CheckButton_BoolBox (true, fo.SetArcMTime, ZTime);
+
+ if (m_allow && !fo.MTime.Def)
+ {
+ const bool isSingleFile = ai.Flags_KeepName();
+ if (!isSingleFile)
+ {
+ // we can hide changing checkboxes for MTime here:
+ ShowItem_Bool (MTime.Set_Id, false);
+ EnableItem (MTime.Id, false);
+ }
+ }
+ // On_CheckBoxSet_Prec_Clicked();
+ // const bool isSingleFile = ai.Flags_KeepName();
+ // mtime for Gz can be
+}
+
+
+
+void COptionsDialog::On_CheckBoxSet_Prec_Clicked()
+{
+ const bool isSet = IsButtonCheckedBool(IDX_COMPRESS_PREC_SET);
+ if (!isSet)
+ {
+ // We save current MAC boxes to memory before SetPrec()
+ Store_TimeBoxes();
+ Reset_TimePrec();
+ SetPrec();
+ }
+ EnableItem(IDC_COMPRESS_TIME_PREC, isSet);
+}
+
+void COptionsDialog::On_CheckBoxSet_Clicked(const CBoolBox &bb)
+{
+ const bool isSet = IsButtonCheckedBool(bb.Set_Id);
+ if (!isSet)
+ CheckButton(bb.Id, bb.DefaultVal);
+ EnableItem(bb.Id, isSet);
+}
+
+
+
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs_Options[] =
+{
+ IDX_COMPRESS_NT_SYM_LINKS,
+ IDX_COMPRESS_NT_HARD_LINKS,
+ IDX_COMPRESS_NT_ALT_STREAMS,
+ IDX_COMPRESS_NT_SECUR,
+
+ IDG_COMPRESS_TIME,
+ IDT_COMPRESS_TIME_PREC,
+ IDX_COMPRESS_MTIME,
+ IDX_COMPRESS_CTIME,
+ IDX_COMPRESS_ATIME,
+ IDX_COMPRESS_ZTIME,
+ IDX_COMPRESS_PRESERVE_ATIME
+};
+#endif
+
+
+bool COptionsDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ LangSetWindowText(*this, IDB_COMPRESS_OPTIONS); // IDS_OPTIONS
+ LangSetDlgItems(*this, kLangIDs_Options, Z7_ARRAY_SIZE(kLangIDs_Options));
+ // LangSetDlgItemText(*this, IDB_COMPRESS_TIME_DEFAULT, IDB_COMPRESS_TIME_DEFAULT);
+ // LangSetDlgItemText(*this, IDX_COMPRESS_TIME_DEFAULT, IDX_COMPRESS_TIME_DEFAULT);
+ #endif
+
+ LangString(IDS_COMPRESS_SEC, SecString);
+ if (SecString.IsEmpty())
+ SecString = "sec";
+ LangString(IDS_COMPRESS_NS, NsString);
+ if (NsString.IsEmpty())
+ NsString = "ns";
+
+ {
+ // const CArcInfoEx &ai = cd->Get_ArcInfoEx();
+
+ ShowItem_Bool ( IDX_COMPRESS_NT_SYM_LINKS, cd->SymLinks.Supported);
+ ShowItem_Bool ( IDX_COMPRESS_NT_HARD_LINKS, cd->HardLinks.Supported);
+ ShowItem_Bool ( IDX_COMPRESS_NT_ALT_STREAMS, cd->AltStreams.Supported);
+ ShowItem_Bool ( IDX_COMPRESS_NT_SECUR, cd->NtSecurity.Supported);
+
+ ShowItem_Bool ( IDG_COMPRESS_NTFS,
+ cd->SymLinks.Supported
+ || cd->HardLinks.Supported
+ || cd->AltStreams.Supported
+ || cd->NtSecurity.Supported);
+ }
+
+ /* we read property from two sources:
+ 1) command line : (Info)
+ 2) registry : (m_RegistryInfo)
+ (Info) has priority, if both are no defined */
+
+ CheckButton_Bool1 ( IDX_COMPRESS_NT_SYM_LINKS, cd->SymLinks);
+ CheckButton_Bool1 ( IDX_COMPRESS_NT_HARD_LINKS, cd->HardLinks);
+ CheckButton_Bool1 ( IDX_COMPRESS_NT_ALT_STREAMS, cd->AltStreams);
+ CheckButton_Bool1 ( IDX_COMPRESS_NT_SECUR, cd->NtSecurity);
+
+ CheckButton_Bool1 (IDX_COMPRESS_PRESERVE_ATIME, cd->PreserveATime);
+
+ m_Prec.Attach (GetItem(IDC_COMPRESS_TIME_PREC));
+
+ MTime.SetIDs ( IDX_COMPRESS_MTIME, IDX_COMPRESS_MTIME_SET);
+ CTime.SetIDs ( IDX_COMPRESS_CTIME, IDX_COMPRESS_CTIME_SET);
+ ATime.SetIDs ( IDX_COMPRESS_ATIME, IDX_COMPRESS_ATIME_SET);
+ ZTime.SetIDs ( IDX_COMPRESS_ZTIME, IDX_COMPRESS_ZTIME_SET);
+
+ {
+ const NCompression::CFormatOptions &fo = cd->Get_FormatOptions();
+ TimePrec = fo.TimePrec;
+ MTime.BoolPair = fo.MTime;
+ CTime.BoolPair = fo.CTime;
+ ATime.BoolPair = fo.ATime;
+ ZTime.BoolPair = fo.SetArcMTime;
+ }
+
+ SetPrec();
+
+ NormalizePosition();
+
+ return CModalDialog::OnInit();
+}
+
+
+bool COptionsDialog::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+ if (code == CBN_SELCHANGE)
+ {
+ switch (itemID)
+ {
+ case IDC_COMPRESS_TIME_PREC:
+ {
+ Store_TimeBoxes();
+ SetTimeMAC(); // for zip/tar
+ return true;
+ }
+ }
+ }
+ return CModalDialog::OnCommand(code, itemID, lParam);
+}
+
+
+bool COptionsDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDX_COMPRESS_PREC_SET: { On_CheckBoxSet_Prec_Clicked(); return true; }
+ case IDX_COMPRESS_MTIME_SET: { On_CheckBoxSet_Clicked (MTime); return true; }
+ case IDX_COMPRESS_CTIME_SET: { On_CheckBoxSet_Clicked (CTime); return true; }
+ case IDX_COMPRESS_ATIME_SET: { On_CheckBoxSet_Clicked (ATime); return true; }
+ case IDX_COMPRESS_ZTIME_SET: { On_CheckBoxSet_Clicked (ZTime); return true; }
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+
+void COptionsDialog::OnOK()
+{
+ GetButton_Bool1 (IDX_COMPRESS_NT_SYM_LINKS, cd->SymLinks);
+ GetButton_Bool1 (IDX_COMPRESS_NT_HARD_LINKS, cd->HardLinks);
+ GetButton_Bool1 (IDX_COMPRESS_NT_ALT_STREAMS, cd->AltStreams);
+ GetButton_Bool1 (IDX_COMPRESS_NT_SECUR, cd->NtSecurity);
+ GetButton_Bool1 (IDX_COMPRESS_PRESERVE_ATIME, cd->PreserveATime);
+
+ Store_TimeBoxes();
+ {
+ NCompression::CFormatOptions &fo = cd->Get_FormatOptions();
+ fo.TimePrec = TimePrec;
+ fo.MTime = MTime.BoolPair;
+ fo.CTime = CTime.BoolPair;
+ fo.ATime = ATime.BoolPair;
+ fo.SetArcMTime = ZTime.BoolPair;
+ }
+
+ CModalDialog::OnOK();
+}
+
+void COptionsDialog::OnHelp()
+{
+ ShowHelpWindow(kHelpTopic_Options);
+}
diff --git a/CPP/7zip/UI/GUI/CompressDialog.h b/CPP/7zip/UI/GUI/CompressDialog.h
new file mode 100644
index 0000000..c2d2699
--- /dev/null
+++ b/CPP/7zip/UI/GUI/CompressDialog.h
@@ -0,0 +1,481 @@
+// CompressDialog.h
+
+#ifndef ZIP7_INC_COMPRESS_DIALOG_H
+#define ZIP7_INC_COMPRESS_DIALOG_H
+
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "../Common/LoadCodecs.h"
+#include "../Common/ZipRegistry.h"
+
+#include "../FileManager/DialogSize.h"
+
+#include "CompressDialogRes.h"
+
+namespace NCompressDialog
+{
+ namespace NUpdateMode
+ {
+ enum EEnum
+ {
+ kAdd,
+ kUpdate,
+ kFresh,
+ kSync
+ };
+ }
+
+ struct CInfo
+ {
+ NUpdateMode::EEnum UpdateMode;
+ NWildcard::ECensorPathMode PathMode;
+
+ bool SolidIsSpecified;
+ // bool MultiThreadIsAllowed;
+ UInt64 SolidBlockSize;
+ UInt32 NumThreads;
+
+ NCompression::CMemUse MemUsage;
+
+ CRecordVector<UInt64> VolumeSizes;
+
+ UInt32 Level;
+ UString Method;
+ UInt64 Dict64;
+ // UInt64 Dict64_Chain;
+ bool OrderMode;
+ UInt32 Order;
+ UString Options;
+
+ UString EncryptionMethod;
+
+ bool SFXMode;
+ bool OpenShareForWrite;
+ bool DeleteAfterCompressing;
+
+ CBoolPair SymLinks;
+ CBoolPair HardLinks;
+ CBoolPair AltStreams;
+ CBoolPair NtSecurity;
+
+ CBoolPair PreserveATime;
+
+ UInt32 TimePrec;
+ CBoolPair MTime;
+ CBoolPair CTime;
+ CBoolPair ATime;
+ CBoolPair SetArcMTime;
+
+ UString ArcPath; // in: Relative or abs ; out: Relative or abs
+
+ // FString CurrentDirPrefix;
+ bool KeepName;
+
+ bool GetFullPathName(UString &result) const;
+
+ int FormatIndex;
+
+ UString Password;
+ bool EncryptHeadersIsAllowed;
+ bool EncryptHeaders;
+
+ CInfo():
+ UpdateMode(NCompressDialog::NUpdateMode::kAdd),
+ PathMode(NWildcard::k_RelatPath),
+ SFXMode(false),
+ OpenShareForWrite(false),
+ DeleteAfterCompressing(false),
+ FormatIndex(-1)
+ {
+ Level = Order = (UInt32)(Int32)-1;
+ NumThreads = (UInt32)(Int32)-1;
+ SolidIsSpecified = false;
+ Dict64 = (UInt64)(Int64)(-1);
+ // Dict64_Chain = (UInt64)(Int64)(-1);
+ OrderMode = false;
+ Method.Empty();
+ Options.Empty();
+ EncryptionMethod.Empty();
+ TimePrec = (UInt32)(Int32)(-1);
+ }
+ };
+}
+
+
+struct CBool1
+{
+ bool Val;
+ bool Supported;
+
+ CBool1(): Val(false), Supported(false) {}
+
+ void Init()
+ {
+ Val = false;
+ Supported = false;
+ }
+
+ void SetTrueTrue()
+ {
+ Val = true;
+ Supported = true;
+ }
+
+ void SetVal_as_Supported(bool val)
+ {
+ Val = val;
+ Supported = true;
+ }
+
+ /*
+ bool IsVal_True_and_Defined() const
+ {
+ return Def && Val;
+ }
+ */
+};
+
+
+class CCompressDialog: public NWindows::NControl::CModalDialog
+{
+ NWindows::NControl::CComboBox m_ArchivePath;
+ NWindows::NControl::CComboBox m_Format;
+ NWindows::NControl::CComboBox m_Level;
+ NWindows::NControl::CComboBox m_Method;
+ NWindows::NControl::CComboBox m_Dictionary;
+ // NWindows::NControl::CComboBox m_Dictionary_Chain;
+ NWindows::NControl::CComboBox m_Order;
+ NWindows::NControl::CComboBox m_Solid;
+ NWindows::NControl::CComboBox m_NumThreads;
+ NWindows::NControl::CComboBox m_MemUse;
+ NWindows::NControl::CComboBox m_Volume;
+
+ int _dictionaryCombo_left;
+
+ UStringVector _memUse_Strings;
+
+ NWindows::NControl::CDialogChildControl m_Params;
+
+ NWindows::NControl::CComboBox m_UpdateMode;
+ NWindows::NControl::CComboBox m_PathMode;
+
+ NWindows::NControl::CEdit _password1Control;
+ NWindows::NControl::CEdit _password2Control;
+ NWindows::NControl::CComboBox _encryptionMethod;
+
+ int _auto_MethodId;
+ UInt32 _auto_Dict; // (UInt32)(Int32)-1 means unknown
+ UInt32 _auto_Dict_Chain; // (UInt32)(Int32)-1 means unknown
+ UInt32 _auto_Order;
+ UInt64 _auto_Solid;
+ UInt32 _auto_NumThreads;
+
+ int _default_encryptionMethod_Index;
+
+ int m_PrevFormat;
+ UString DirPrefix;
+ UString StartDirPrefix;
+
+ bool _ramSize_Defined;
+ UInt64 _ramSize; // full RAM size avail
+ UInt64 _ramSize_Reduced; // full for 64-bit and reduced for 32-bit
+ UInt64 _ramUsage_Auto;
+
+public:
+ NCompression::CInfo m_RegistryInfo;
+
+ CBool1 SymLinks;
+ CBool1 HardLinks;
+ CBool1 AltStreams;
+ CBool1 NtSecurity;
+ CBool1 PreserveATime;
+
+ void SetArchiveName(const UString &name);
+ int FindRegistryFormat(const UString &name);
+ unsigned FindRegistryFormat_Always(const UString &name);
+
+ const CArcInfoEx &Get_ArcInfoEx()
+ {
+ return (*ArcFormats)[GetFormatIndex()];
+ }
+
+ NCompression::CFormatOptions &Get_FormatOptions();
+
+ void CheckSFXNameChange();
+ void SetArchiveName2(bool prevWasSFX);
+
+ unsigned GetStaticFormatIndex();
+
+ void SetNearestSelectComboBox(NWindows::NControl::CComboBox &comboBox, UInt32 value);
+
+ void SetLevel2();
+ void SetLevel()
+ {
+ SetLevel2();
+ EnableMultiCombo(IDC_COMPRESS_LEVEL);
+ SetMethod();
+ }
+
+ void SetMethod2(int keepMethodId);
+ void SetMethod(int keepMethodId = -1)
+ {
+ SetMethod2(keepMethodId);
+ EnableMultiCombo(IDC_COMPRESS_METHOD);
+ }
+
+ void MethodChanged()
+ {
+ SetDictionary2();
+ EnableMultiCombo(IDC_COMPRESS_DICTIONARY);
+ // EnableMultiCombo(IDC_COMPRESS_DICTIONARY2);
+ SetOrder2();
+ EnableMultiCombo(IDC_COMPRESS_ORDER);
+ }
+
+ int GetMethodID_RAW();
+ int GetMethodID();
+
+ UString GetMethodSpec(UString &estimatedName);
+ UString GetMethodSpec();
+ bool IsMethodEqualTo(const UString &s);
+ UString GetEncryptionMethodSpec();
+
+ bool IsZipFormat();
+ bool IsXzFormat();
+
+ void SetEncryptionMethod();
+
+ int AddDict2(size_t sizeReal, size_t sizeShow);
+ int AddDict(size_t size);
+ // int AddDict_Chain(size_t size);
+
+ void SetDictionary2();
+
+ UInt32 GetComboValue(NWindows::NControl::CComboBox &c, int defMax = 0);
+ UInt64 GetComboValue_64(NWindows::NControl::CComboBox &c, int defMax = 0);
+
+ UInt32 GetLevel() { return GetComboValue(m_Level); }
+ UInt32 GetLevelSpec() { return GetComboValue(m_Level, 1); }
+ UInt32 GetLevel2();
+
+ UInt64 GetDictSpec() { return GetComboValue_64(m_Dictionary, 1); }
+ // UInt64 GetDictChainSpec() { return GetComboValue_64(m_Dictionary_Chain, 1); }
+
+ UInt64 GetDict2()
+ {
+ UInt64 num = GetDictSpec();
+ if (num == (UInt64)(Int64)-1)
+ {
+ if (_auto_Dict == (UInt32)(Int32)-1)
+ return (UInt64)(Int64)-1; // unknown
+ num = _auto_Dict;
+ }
+ return num;
+ }
+
+ // UInt32 GetOrder() { return GetComboValue(m_Order); }
+ UInt32 GetOrderSpec() { return GetComboValue(m_Order, 1); }
+ UInt32 GetNumThreadsSpec() { return GetComboValue(m_NumThreads, 1); }
+
+ UInt32 GetNumThreads2()
+ {
+ UInt32 num = GetNumThreadsSpec();
+ if (num == (UInt32)(Int32)-1)
+ num = _auto_NumThreads;
+ return num;
+ }
+
+ UInt32 GetBlockSizeSpec() { return GetComboValue(m_Solid, 1); }
+
+ /*
+ UInt32 GetPrecSpec() { return GetComboValue(m_Prec, 1); }
+ UInt32 GetPrec() { return GetComboValue(m_Prec, 0); }
+ */
+
+
+ int AddOrder(UInt32 size);
+ int AddOrder_Auto();
+
+ void SetOrder2();
+
+ bool GetOrderMode();
+
+ void SetSolidBlockSize2();
+ void SetSolidBlockSize(/* bool useDictionary = false */)
+ {
+ SetSolidBlockSize2();
+ EnableMultiCombo(IDC_COMPRESS_SOLID);
+ }
+
+ void SetNumThreads2();
+ void SetNumThreads()
+ {
+ SetNumThreads2();
+ EnableMultiCombo(IDC_COMPRESS_THREADS);
+ }
+
+ int AddMemComboItem(UInt64 val, bool isPercent = false, bool isDefault = false);
+ void SetMemUseCombo();
+ UString Get_MemUse_Spec();
+ UInt64 Get_MemUse_Bytes();
+
+ UInt64 GetMemoryUsage_Dict_DecompMem(UInt64 dict, UInt64 &decompressMemory);
+ UInt64 GetMemoryUsage_Threads_Dict_DecompMem(UInt32 numThreads, UInt64 dict, UInt64 &decompressMemory);
+ UInt64 GetMemoryUsage_DecompMem(UInt64 &decompressMemory);
+ UInt64 GetMemoryUsageComp_Threads_Dict(UInt32 numThreads, UInt64 dict64);
+
+ void PrintMemUsage(UINT res, UInt64 value);
+ void SetMemoryUsage();
+ void Print_Params();
+
+ void SetParams();
+
+ void SaveOptionsInMem();
+
+ void UpdatePasswordControl();
+ bool IsShowPasswordChecked() const { return IsButtonCheckedBool(IDX_PASSWORD_SHOW); }
+
+ unsigned GetFormatIndex();
+ bool SetArcPathFields(const UString &path, UString &name, bool always);
+ bool SetArcPathFields(const UString &path);
+ bool GetFinalPath_Smart(UString &resPath) const;
+ void ArcPath_WasChanged(const UString &newPath);
+
+ void CheckSFXControlsEnable();
+ // void CheckVolumeEnable();
+ void EnableMultiCombo(unsigned id);
+ void FormatChanged(bool isChanged);
+
+ void OnButtonSetArchive();
+ bool IsSFX();
+ void OnButtonSFX();
+
+ virtual bool OnInit() Z7_override;
+ virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam) Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual void OnOK() Z7_override;
+ virtual void OnHelp() Z7_override;
+
+ void MessageBoxError(LPCWSTR message)
+ {
+ MessageBoxW(*this, message, L"7-Zip", MB_ICONERROR);
+ }
+
+ void ShowOptionsString();
+
+public:
+ const CObjectVector<CArcInfoEx> *ArcFormats;
+ CUIntVector ArcIndices; // can not be empty, must contain Info.FormatIndex, if Info.FormatIndex >= 0
+ AStringVector ExternalMethods;
+
+ void SetMethods(const CObjectVector<CCodecInfoUser> &userCodecs);
+
+ NCompressDialog::CInfo Info;
+ UString OriginalFileName; // for bzip2, gzip2
+
+ INT_PTR Create(HWND wndParent = NULL)
+ {
+ BIG_DIALOG_SIZE(400, 320);
+ return CModalDialog::Create(SIZED_DIALOG(IDD_COMPRESS), wndParent);
+ }
+
+ CCompressDialog() {}
+};
+
+
+
+
+class COptionsDialog: public NWindows::NControl::CModalDialog
+{
+ struct CBoolBox
+ {
+ bool IsSupported;
+ bool DefaultVal;
+ CBoolPair BoolPair;
+
+ unsigned Id;
+ unsigned Set_Id;
+
+ void SetIDs(unsigned id, unsigned set_Id)
+ {
+ Id = id;
+ Set_Id = set_Id;
+ }
+
+ CBoolBox():
+ IsSupported(false),
+ DefaultVal(false)
+ {}
+ };
+
+ CCompressDialog *cd;
+
+ NWindows::NControl::CComboBox m_Prec;
+
+ UInt32 _auto_Prec;
+ UInt32 TimePrec;
+
+ void Reset_TimePrec() { TimePrec = (UInt32)(Int32)-1; }
+ bool IsSet_TimePrec() const { return TimePrec != (UInt32)(Int32)-1; }
+
+ CBoolBox MTime;
+ CBoolBox CTime;
+ CBoolBox ATime;
+ CBoolBox ZTime;
+
+ UString SecString;
+ UString NsString;
+
+
+ void CheckButton_Bool1(UINT id, const CBool1 &b1);
+ void GetButton_Bool1(UINT id, CBool1 &b1);
+ void CheckButton_BoolBox(bool supported, const CBoolPair &b2, CBoolBox &bb);
+ void GetButton_BoolBox(CBoolBox &bb);
+
+ void Store_TimeBoxes();
+
+ UInt32 GetComboValue(NWindows::NControl::CComboBox &c, int defMax = 0);
+ UInt32 GetPrecSpec()
+ {
+ UInt32 prec = GetComboValue(m_Prec, 1);
+ if (prec == _auto_Prec)
+ prec = (UInt32)(Int32)-1;
+ return prec;
+ }
+ UInt32 GetPrec() { return GetComboValue(m_Prec, 0); }
+
+ // void OnButton_TimeDefault();
+ int AddPrec(unsigned prec, bool isDefault);
+ void SetPrec();
+ void SetTimeMAC();
+
+ void On_CheckBoxSet_Prec_Clicked();
+ void On_CheckBoxSet_Clicked(const CBoolBox &bb);
+
+ virtual bool OnInit() Z7_override;
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam) Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual void OnOK() Z7_override;
+ virtual void OnHelp() Z7_override;
+
+public:
+
+ INT_PTR Create(HWND wndParent = NULL)
+ {
+ BIG_DIALOG_SIZE(240, 232);
+ return CModalDialog::Create(SIZED_DIALOG(IDD_COMPRESS_OPTIONS), wndParent);
+ }
+
+ COptionsDialog(CCompressDialog *cdLoc):
+ cd(cdLoc)
+ // , TimePrec(0)
+ {
+ Reset_TimePrec();
+ }
+};
+
+#endif
diff --git a/CPP/7zip/UI/GUI/CompressDialog.rc b/CPP/7zip/UI/GUI/CompressDialog.rc
new file mode 100644
index 0000000..f04329e
--- /dev/null
+++ b/CPP/7zip/UI/GUI/CompressDialog.rc
@@ -0,0 +1,231 @@
+#include "CompressDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 400
+#define yc 320
+
+#undef gSize
+#undef gSpace
+#undef g0xs
+#undef g1x
+#undef g1xs
+#undef g2xs
+#undef g3x
+#undef g3xs
+#undef g4x
+#undef g4x2
+#undef g4xs
+#undef g4xs2
+
+#define gSize 192
+#define gSpace 24
+
+
+#define g1xs 88
+#define g0xs (gSize - g1xs)
+#define g1x (m + g0xs)
+
+#define g3xs 52
+#define g2xs (gSize - g3xs)
+#define g3x (m + g2xs)
+
+#define g4x (m + gSize + gSpace)
+#define g4x2 (g4x + m)
+#define g4xs (xc - gSize - gSpace)
+#define g4xs2 (g4xs - m - m)
+
+#define yOpt 80
+
+#define xArcFolderOffs 40
+
+#undef GROUP_Y_SIZE
+#undef GROUP_Y_SIZE_ENCRYPT
+#ifdef UNDER_CE
+#define GROUP_Y_SIZE 8
+#define GROUP_Y_SIZE_ENCRYPT 8
+#else
+#define GROUP_Y_SIZE 64
+#define GROUP_Y_SIZE_ENCRYPT 128
+#endif
+
+// #define DICT_SIZE_SPACE 8
+// #define DICT_SIZE 54
+// #define DICT_x (g1x + g1xs - DICT_SIZE)
+// #define DICT2_x (DICT_x - DICT_SIZE_SPACE - DICT_SIZE)
+
+#define yPsw (yOpt + GROUP_Y_SIZE + 8)
+
+IDD_COMPRESS DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Add to Archive"
+BEGIN
+ LTEXT "", IDT_COMPRESS_ARCHIVE_FOLDER, m + xArcFolderOffs, m, xc - xArcFolderOffs, 8
+ LTEXT "&Archive:", IDT_COMPRESS_ARCHIVE, m, 12, xArcFolderOffs, 8
+ COMBOBOX IDC_COMPRESS_ARCHIVE, m + xArcFolderOffs, 18, xc - bxsDots - 12 - xArcFolderOffs, 126, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_COMPRESS_SET_ARCHIVE, xs - m - bxsDots, 16, bxsDots, bys, WS_GROUP
+
+ LTEXT "Archive &format:", IDT_COMPRESS_FORMAT, m, 41, g0xs, 8
+ COMBOBOX IDC_COMPRESS_FORMAT, g1x, 39, g1xs, 80, MY_COMBO | CBS_SORT
+
+ LTEXT "Compression &level:", IDT_COMPRESS_LEVEL, m, 62, g0xs, 8
+ COMBOBOX IDC_COMPRESS_LEVEL, g1x, 60, g1xs, 80, MY_COMBO
+
+ LTEXT "Compression &method:", IDT_COMPRESS_METHOD, m, 83, g0xs, 8
+ COMBOBOX IDC_COMPRESS_METHOD, g1x, 81, g1xs, 80, MY_COMBO
+
+ LTEXT "&Dictionary size:", IDT_COMPRESS_DICTIONARY, m, 104, g0xs, 8
+ COMBOBOX IDC_COMPRESS_DICTIONARY, g1x, 102, g1xs, 167, MY_COMBO
+ // LTEXT "&Dictionary size:", IDT_COMPRESS_DICTIONARY, m, 104, DICT_x - m, 16 // 8, SS_LEFTNOWORDWRAP
+ // LTEXT "", IDT_COMPRESS_PARAMS_INFO, m, 283, xs, MY_TEXT_NOPREFIX
+ // CTEXT "-", 0, DICT_x - DICT_SIZE_SPACE, 104, DICT_SIZE_SPACE, 8
+ // COMBOBOX IDC_COMPRESS_DICTIONARY2, DICT2_x, 102, DICT_SIZE, 140, MY_COMBO
+ // COMBOBOX IDC_COMPRESS_DICTIONARY, DICT_x, 102, DICT_SIZE, 140, MY_COMBO
+
+ LTEXT "&Word size:", IDT_COMPRESS_ORDER, m, 125, g0xs, 8
+ COMBOBOX IDC_COMPRESS_ORDER, g1x, 123, g1xs, 140, MY_COMBO
+
+ LTEXT "&Solid Block size:", IDT_COMPRESS_SOLID, m, 146, g0xs, 8
+ COMBOBOX IDC_COMPRESS_SOLID, g1x, 144, g1xs, 140, MY_COMBO
+
+ LTEXT "Number of CPU &threads:", IDT_COMPRESS_THREADS, m, 167, g0xs, 8
+ COMBOBOX IDC_COMPRESS_THREADS, g1x, 165, g1xs - 35, 140, MY_COMBO
+ RTEXT "", IDT_COMPRESS_HARDWARE_THREADS, g1x + g1xs - 35 + 10, 167, 25, MY_TEXT_NOPREFIX
+
+
+ LTEXT "Memory usage for Compressing:", IDT_COMPRESS_MEMORY, m, 184, g2xs, 8
+ COMBOBOX IDC_COMPRESS_MEM_USE, g3x, 188, g3xs, 140, MY_COMBO
+ LTEXT "", IDT_COMPRESS_MEMORY_VALUE, m, 194, g2xs, MY_TEXT_NOPREFIX
+
+ LTEXT "Memory usage for Decompressing:", IDT_COMPRESS_MEMORY_DE, m, 208, g2xs, 8
+ RTEXT "", IDT_COMPRESS_MEMORY_DE_VALUE, g3x, 208, g3xs, MY_TEXT_NOPREFIX
+
+
+ LTEXT "Split to &volumes, bytes:", IDT_SPLIT_TO_VOLUMES, m, 225, gSize, 8
+ COMBOBOX IDC_COMPRESS_VOLUME, m, 237, gSize, 73, MY_COMBO_WITH_EDIT
+
+ LTEXT "Parameters:", IDT_COMPRESS_PARAMETERS, m, 256, gSize, 8
+ EDITTEXT IDE_COMPRESS_PARAMETERS, m, 268, gSize, 14, ES_AUTOHSCROLL
+
+ PUSHBUTTON "Options", IDB_COMPRESS_OPTIONS, m, 292, bxs, bys
+ LTEXT "", IDT_COMPRESS_OPTIONS, m + bxs + m, 294, gSize - bxs - m, 16, SS_NOPREFIX
+
+
+ LTEXT "&Update mode:", IDT_COMPRESS_UPDATE_MODE, g4x, 41, 80, 8
+ COMBOBOX IDC_COMPRESS_UPDATE_MODE, g4x + 84, 39, g4xs - 84, 80, MY_COMBO
+
+ LTEXT "Path mode:", IDT_COMPRESS_PATH_MODE, g4x, 61, 80, 8
+ COMBOBOX IDC_COMPRESS_PATH_MODE, g4x + 84, 59, g4xs - 84, 80, MY_COMBO
+
+
+ GROUPBOX "Options", IDG_COMPRESS_OPTIONS, g4x, yOpt, g4xs, GROUP_Y_SIZE
+
+ CONTROL "Create SF&X archive", IDX_COMPRESS_SFX, MY_CHECKBOX,
+ g4x2, yOpt + 14, g4xs2, 10
+ CONTROL "Compress shared files", IDX_COMPRESS_SHARED, MY_CHECKBOX,
+ g4x2, yOpt + 30, g4xs2, 10
+ CONTROL "Delete files after compression", IDX_COMPRESS_DEL, MY_CHECKBOX,
+ g4x2, yOpt + 46, g4xs2, 10
+
+
+ GROUPBOX "Encryption", IDG_COMPRESS_ENCRYPTION, g4x, yPsw, g4xs, GROUP_Y_SIZE_ENCRYPT
+
+ LTEXT "Enter &password:", IDT_PASSWORD_ENTER, g4x2, yPsw + 14, g4xs2, 8
+ EDITTEXT IDE_COMPRESS_PASSWORD1, g4x2, yPsw + 26, g4xs2, 14, ES_PASSWORD | ES_AUTOHSCROLL
+ LTEXT "Reenter password:", IDT_PASSWORD_REENTER, g4x2, yPsw + 46, g4xs2, 8
+ EDITTEXT IDE_COMPRESS_PASSWORD2, g4x2, yPsw + 58, g4xs2, 14, ES_PASSWORD | ES_AUTOHSCROLL
+
+ CONTROL "Show Password", IDX_PASSWORD_SHOW, MY_CHECKBOX,
+ g4x2, yPsw + 79, g4xs2, 10
+
+ LTEXT "&Encryption method:", IDT_COMPRESS_ENCRYPTION_METHOD, g4x2, yPsw + 95, 100, 8
+ COMBOBOX IDC_COMPRESS_ENCRYPTION_METHOD, g4x2 + 100, yPsw + 93, g4xs2 - 100, 198, MY_COMBO
+
+ CONTROL "Encrypt file &names", IDX_COMPRESS_ENCRYPT_FILE_NAMES, MY_CHECKBOX,
+ g4x2, yPsw + 111, g4xs2, 10
+
+ DEFPUSHBUTTON "OK", IDOK, bx3, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx2, by, bxs, bys
+ PUSHBUTTON "Help", IDHELP, bx1, by, bxs, bys
+END
+
+
+#ifdef UNDER_CE
+
+#undef m
+#undef xc
+#undef yc
+
+#define m 4
+#define xc 152
+#define yc 160
+
+
+IDD_COMPRESS_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Add to Archive"
+MY_FONT
+BEGIN
+ COMBOBOX IDC_COMPRESS_ARCHIVE, m, m, xc - bxsDots - m, 126, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_COMPRESS_SET_ARCHIVE, xs - m - bxsDots, m, bxsDots, 12, WS_GROUP
+
+ COMBOBOX IDC_COMPRESS_FORMAT, m , 22, 32, 80, MY_COMBO | CBS_SORT
+ COMBOBOX IDC_COMPRESS_LEVEL, m + 36, 22, 68, 80, MY_COMBO
+ COMBOBOX IDC_COMPRESS_METHOD, m + 108, 22, 44, 80, MY_COMBO
+
+ COMBOBOX IDC_COMPRESS_DICTIONARY, m, 40, 40, 80, MY_COMBO
+ COMBOBOX IDC_COMPRESS_ORDER, m + 44, 40, 32, 80, MY_COMBO
+ COMBOBOX IDC_COMPRESS_SOLID, m + 80, 40, 40, 80, MY_COMBO
+ COMBOBOX IDC_COMPRESS_THREADS, m + 124, 40, 28, 80, MY_COMBO
+
+ LTEXT "Split to &volumes, bytes:", IDT_SPLIT_TO_VOLUMES, m, 60, 32, 8
+ COMBOBOX IDC_COMPRESS_VOLUME, m + 32, 58, 44, 73, MY_COMBO_WITH_EDIT
+ LTEXT "Parameters:", IDT_COMPRESS_PARAMETERS, m + 80, 60, 48, 8
+ EDITTEXT IDE_COMPRESS_PARAMETERS, m + 128, 58, 24, 13, ES_AUTOHSCROLL
+
+ COMBOBOX IDC_COMPRESS_UPDATE_MODE, m, 76, 88, 80, MY_COMBO
+ CONTROL "SF&X", IDX_COMPRESS_SFX, MY_CHECKBOX, m + 92, 77, 60, 10
+
+ CONTROL "Compress shared files", IDX_COMPRESS_SHARED, MY_CHECKBOX, m, 94, xc, 10
+
+ LTEXT "Enter &password:", IDT_PASSWORD_ENTER, m, 112, 60, 8
+ EDITTEXT IDE_COMPRESS_PASSWORD1, m + 60, 110, 44, 13, ES_PASSWORD | ES_AUTOHSCROLL
+ CONTROL "Show Password", IDX_PASSWORD_SHOW, MY_CHECKBOX, m + 108, 112, 44, 10
+
+ COMBOBOX IDC_COMPRESS_ENCRYPTION_METHOD, m, 128, 48, 198, MY_COMBO
+ CONTROL "Encrypt file &names", IDX_COMPRESS_ENCRYPT_FILE_NAMES, MY_CHECKBOX, m + 52, 130, 100, 10
+
+ OK_CANCEL
+END
+
+#endif
+
+STRINGTABLE
+BEGIN
+ IDS_PASSWORD_NOT_MATCH "Passwords do not match"
+ IDS_PASSWORD_USE_ASCII "Use only English letters, numbers and special characters (!, #, $, ...) for password."
+ IDS_PASSWORD_TOO_LONG "Password is too long"
+
+ IDS_METHOD_STORE "Store"
+ IDS_METHOD_FASTEST "Fastest"
+ IDS_METHOD_FAST "Fast"
+ IDS_METHOD_NORMAL "Normal"
+ IDS_METHOD_MAXIMUM "Maximum"
+ IDS_METHOD_ULTRA "Ultra"
+
+ IDS_COMPRESS_UPDATE_MODE_ADD "Add and replace files"
+ IDS_COMPRESS_UPDATE_MODE_UPDATE "Update and add files"
+ IDS_COMPRESS_UPDATE_MODE_FRESH "Freshen existing files"
+ IDS_COMPRESS_UPDATE_MODE_SYNC "Synchronize files"
+
+ IDS_OPEN_TYPE_ALL_FILES "All Files"
+ IDS_COMPRESS_SET_ARCHIVE_BROWSE "Browse"
+
+ IDS_COMPRESS_NON_SOLID "Non-solid"
+ IDS_COMPRESS_SOLID "Solid"
+
+ IDS_SPLIT_CONFIRM "Specified volume size: {0} bytes.\nAre you sure you want to split archive into such volumes?"
+
+ IDS_COMPRESS_SEC "sec"
+ IDS_COMPRESS_NS "ns"
+END
+
+
+#include "CompressOptionsDialog.rc"
diff --git a/CPP/7zip/UI/GUI/CompressDialogRes.h b/CPP/7zip/UI/GUI/CompressDialogRes.h
new file mode 100644
index 0000000..aa25b89
--- /dev/null
+++ b/CPP/7zip/UI/GUI/CompressDialogRes.h
@@ -0,0 +1,123 @@
+#define IDD_COMPRESS 4000
+#define IDD_COMPRESS_2 14000
+#define IDD_COMPRESS_OPTIONS 14001
+
+#define IDC_COMPRESS_ARCHIVE 100
+#define IDB_COMPRESS_SET_ARCHIVE 101
+#define IDC_COMPRESS_LEVEL 102
+#define IDC_COMPRESS_UPDATE_MODE 103
+#define IDC_COMPRESS_FORMAT 104
+#define IDC_COMPRESS_VOLUME 105
+#define IDC_COMPRESS_METHOD 106
+#define IDC_COMPRESS_DICTIONARY 107
+#define IDC_COMPRESS_ORDER 108
+#define IDC_COMPRESS_SOLID 109
+#define IDC_COMPRESS_THREADS 110
+#define IDE_COMPRESS_PARAMETERS 111
+
+#define IDT_COMPRESS_HARDWARE_THREADS 112
+#define IDT_COMPRESS_MEMORY_VALUE 113
+#define IDT_COMPRESS_MEMORY_DE_VALUE 114
+
+#define IDG_COMPRESS_NTFS 115
+#define IDC_COMPRESS_PATH_MODE 116
+#define IDC_COMPRESS_MEM_USE 117
+// #define IDC_COMPRESS_DICTIONARY2 118
+
+#define IDE_COMPRESS_PASSWORD1 120
+#define IDE_COMPRESS_PASSWORD2 121
+#define IDC_COMPRESS_ENCRYPTION_METHOD 122
+
+#define IDT_COMPRESS_ARCHIVE_FOLDER 130
+
+// #define IDB_COMPRESS_OPTIONS 140
+#define IDB_COMPRESS_OPTIONS 2100
+#define IDT_COMPRESS_OPTIONS 141
+// #define IDT_COMPRESS_PARAMS_INFO 142
+
+#define IDT_COMPRESS_PATH_MODE 3410
+
+#define IDT_PASSWORD_ENTER 3801
+#define IDT_PASSWORD_REENTER 3802
+#define IDX_PASSWORD_SHOW 3803
+#define IDS_PASSWORD_NOT_MATCH 3804
+#define IDS_PASSWORD_USE_ASCII 3805
+#define IDS_PASSWORD_TOO_LONG 3806
+
+#define IDT_COMPRESS_ARCHIVE 4001
+#define IDT_COMPRESS_UPDATE_MODE 4002
+#define IDT_COMPRESS_FORMAT 4003
+#define IDT_COMPRESS_LEVEL 4004
+#define IDT_COMPRESS_METHOD 4005
+#define IDT_COMPRESS_DICTIONARY 4006
+#define IDT_COMPRESS_ORDER 4007
+#define IDT_COMPRESS_SOLID 4008
+#define IDT_COMPRESS_THREADS 4009
+#define IDT_COMPRESS_PARAMETERS 4010
+#define IDG_COMPRESS_OPTIONS 4011
+
+#define IDX_COMPRESS_SFX 4012
+#define IDX_COMPRESS_SHARED 4013
+
+#define IDG_COMPRESS_ENCRYPTION 4014
+#define IDT_COMPRESS_ENCRYPTION_METHOD 4015
+#define IDX_COMPRESS_ENCRYPT_FILE_NAMES 4016
+
+#define IDT_COMPRESS_MEMORY 4017
+#define IDT_COMPRESS_MEMORY_DE 4018
+
+#define IDX_COMPRESS_DEL 4019
+
+#define IDX_COMPRESS_NT_SYM_LINKS 4040
+#define IDX_COMPRESS_NT_HARD_LINKS 4041
+#define IDX_COMPRESS_NT_ALT_STREAMS 4042
+#define IDX_COMPRESS_NT_SECUR 4043
+
+#define IDS_METHOD_STORE 4050
+#define IDS_METHOD_FASTEST 4051
+#define IDS_METHOD_FAST 4052
+#define IDS_METHOD_NORMAL 4053
+#define IDS_METHOD_MAXIMUM 4054
+#define IDS_METHOD_ULTRA 4055
+
+#define IDS_COMPRESS_UPDATE_MODE_ADD 4060
+#define IDS_COMPRESS_UPDATE_MODE_UPDATE 4061
+#define IDS_COMPRESS_UPDATE_MODE_FRESH 4062
+#define IDS_COMPRESS_UPDATE_MODE_SYNC 4063
+
+#define IDS_COMPRESS_SET_ARCHIVE_BROWSE 4070
+#define IDS_OPEN_TYPE_ALL_FILES 4071
+#define IDS_COMPRESS_NON_SOLID 4072
+#define IDS_COMPRESS_SOLID 4073
+
+#define IDT_SPLIT_TO_VOLUMES 7302
+#define IDS_INCORRECT_VOLUME_SIZE 7307
+#define IDS_SPLIT_CONFIRM 7308
+
+
+// Options Dialog
+
+#define IDG_COMPRESS_TIME 4080
+#define IDT_COMPRESS_TIME_PREC 4081
+#define IDX_COMPRESS_MTIME 4082
+#define IDX_COMPRESS_CTIME 4083
+#define IDX_COMPRESS_ATIME 4084
+#define IDX_COMPRESS_ZTIME 4085
+#define IDX_COMPRESS_PRESERVE_ATIME 4086
+
+#define IDS_COMPRESS_SEC 4090
+#define IDS_COMPRESS_NS 4091
+
+#define IDC_COMPRESS_TIME_PREC 190
+#define IDT_COMPRESS_TIME_INFO 191
+
+#define IDX_COMPRESS_PREC_SET 201
+#define IDX_COMPRESS_MTIME_SET 202
+#define IDX_COMPRESS_CTIME_SET 203
+#define IDX_COMPRESS_ATIME_SET 204
+#define IDX_COMPRESS_ZTIME_SET 205
+
+// #define IDX_COMPRESS_NT_SYM_LINKS_SET 210
+// #define IDX_COMPRESS_NT_HARD_LINKS_SET 211
+// #define IDX_COMPRESS_NT_ALT_STREAMS_SET 212
+// #define IDX_COMPRESS_NT_SECUR_SET 213
diff --git a/CPP/7zip/UI/GUI/CompressOptionsDialog.rc b/CPP/7zip/UI/GUI/CompressOptionsDialog.rc
new file mode 100644
index 0000000..0578227
--- /dev/null
+++ b/CPP/7zip/UI/GUI/CompressOptionsDialog.rc
@@ -0,0 +1,76 @@
+#include "CompressDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 240
+#define yc 232
+
+#define g5x m
+#define g5x2 (g5x + m)
+#define g5xs (xc)
+#define g5xs2 (g5xs - m - m)
+
+#define ntPosX g5x2
+#define ntPosY m
+#define ntSizeX g5xs2
+#define precSizeX 76
+
+#define ntSizeY 72
+#define timePosY (ntPosY + ntSizeY + 20)
+
+#define ceSize 18
+#define ceString ":"
+
+
+IDD_COMPRESS_OPTIONS DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Options"
+BEGIN
+ GROUPBOX "NTFS", IDG_COMPRESS_NTFS, g5x, ntPosY, g5xs, ntSizeY
+
+ CONTROL "Store symbolic links", IDX_COMPRESS_NT_SYM_LINKS, MY_CHECKBOX,
+ ntPosX, ntPosY + 12, ntSizeX, 10
+ CONTROL "Store hard links", IDX_COMPRESS_NT_HARD_LINKS, MY_CHECKBOX,
+ ntPosX, ntPosY + 26, ntSizeX, 10
+ CONTROL "Store alternate data streams", IDX_COMPRESS_NT_ALT_STREAMS, MY_CHECKBOX,
+ ntPosX, ntPosY + 40, ntSizeX, 10
+ CONTROL "Store file security", IDX_COMPRESS_NT_SECUR, MY_CHECKBOX,
+ ntPosX, ntPosY + 54, ntSizeX, 10
+
+ LTEXT "", IDT_COMPRESS_TIME_INFO, g5x, timePosY - 14, g5xs, 8
+
+
+ GROUPBOX "Time", IDG_COMPRESS_TIME, g5x, timePosY, g5xs, 112
+
+// CONTROL "Default", IDX_COMPRESS_TIME_DEFAULT, MY_CHECKBOX,
+// ntPosX, timePosY + 10, ntSizeX, 16
+
+ CONTROL ceString, IDX_COMPRESS_PREC_SET, MY_CHECKBOX, ntPosX, timePosY + 14, ceSize, 10
+ LTEXT "Timestamp precision:", IDT_COMPRESS_TIME_PREC,
+ ntPosX + ceSize, timePosY + 14, ntSizeX - precSizeX - ceSize, 8
+ COMBOBOX IDC_COMPRESS_TIME_PREC, ntPosX + ntSizeX - precSizeX, timePosY + 12, precSizeX, 70, MY_COMBO
+
+ // PUSHBUTTON "Default", IDB_COMPRESS_TIME_DEFAULT, ntPosX + ntSizeX - bxs, timePosY + 22, bxs, bys, WS_GROUP
+
+ CONTROL ceString, IDX_COMPRESS_MTIME_SET, MY_CHECKBOX, ntPosX, timePosY + 28, ceSize, 10
+ CONTROL "Store modification time", IDX_COMPRESS_MTIME, MY_CHECKBOX,
+ ntPosX + ceSize, timePosY + 28, ntSizeX - ceSize, 10
+
+ CONTROL ceString, IDX_COMPRESS_CTIME_SET, MY_CHECKBOX, ntPosX, timePosY + 42, ceSize, 10
+ CONTROL "Store creation time", IDX_COMPRESS_CTIME, MY_CHECKBOX,
+ ntPosX + ceSize, timePosY + 42, ntSizeX - ceSize, 10
+
+ CONTROL ceString, IDX_COMPRESS_ATIME_SET, MY_CHECKBOX, ntPosX, timePosY + 56, ceSize, 10
+ CONTROL "Store last access time", IDX_COMPRESS_ATIME, MY_CHECKBOX,
+ ntPosX + ceSize, timePosY + 56, ntSizeX - ceSize, 10
+
+ CONTROL ceString, IDX_COMPRESS_ZTIME_SET, MY_CHECKBOX | BS_MULTILINE, ntPosX, timePosY + 72, ceSize, 16
+ CONTROL "Set archive time to latest file time", IDX_COMPRESS_ZTIME, MY_CHECKBOX | BS_MULTILINE,
+ ntPosX + ceSize, timePosY + 72, ntSizeX - ceSize, 16
+
+ CONTROL "Do not change source files last access time", IDX_COMPRESS_PRESERVE_ATIME, MY_CHECKBOX | BS_MULTILINE,
+ ntPosX, timePosY + 92, ntSizeX, 16
+
+
+ DEFPUSHBUTTON "OK", IDOK, bx3, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx2, by, bxs, bys
+ PUSHBUTTON "Help", IDHELP, bx1, by, bxs, bys
+END
diff --git a/CPP/7zip/UI/GUI/Extract.rc b/CPP/7zip/UI/GUI/Extract.rc
index 6bda89e..36bfb00 100644
--- a/CPP/7zip/UI/GUI/Extract.rc
+++ b/CPP/7zip/UI/GUI/Extract.rc
@@ -1,59 +1,59 @@
-#include "ExtractRes.h"
-
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-
-STRINGTABLE DISCARDABLE
-BEGIN
- IDS_MEM_ERROR "The system cannot allocate the required amount of memory"
- IDS_CANNOT_CREATE_FOLDER "Cannot create folder '{0}'"
- IDS_UPDATE_NOT_SUPPORTED "Update operations are not supported for this archive."
- IDS_CANT_OPEN_ARCHIVE "Can not open file '{0}' as archive"
- IDS_CANT_OPEN_ENCRYPTED_ARCHIVE "Can not open encrypted archive '{0}'. Wrong password?"
- IDS_UNSUPPORTED_ARCHIVE_TYPE "Unsupported archive type"
-
- IDS_CANT_OPEN_AS_TYPE "Can not open the file as {0} archive"
- IDS_IS_OPEN_AS_TYPE "The file is open as {0} archive"
- IDS_IS_OPEN_WITH_OFFSET "The archive is open with offset"
-
- IDS_PROGRESS_EXTRACTING "Extracting"
-
- IDS_PROGRESS_SKIPPING "Skipping"
-
- IDS_EXTRACT_SET_FOLDER "Specify a location for extracted files."
-
- IDS_EXTRACT_PATHS_FULL "Full pathnames"
- IDS_EXTRACT_PATHS_NO "No pathnames"
- IDS_EXTRACT_PATHS_ABS "Absolute pathnames"
- IDS_PATH_MODE_RELAT "Relative pathnames"
-
- IDS_EXTRACT_OVERWRITE_ASK "Ask before overwrite"
- IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT "Overwrite without prompt"
- IDS_EXTRACT_OVERWRITE_SKIP_EXISTING "Skip existing files"
- IDS_EXTRACT_OVERWRITE_RENAME "Auto rename"
- IDS_EXTRACT_OVERWRITE_RENAME_EXISTING "Auto rename existing files"
-
- IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD "Unsupported compression method for '{0}'."
- IDS_EXTRACT_MESSAGE_DATA_ERROR "Data error in '{0}'. File is broken"
- IDS_EXTRACT_MESSAGE_CRC_ERROR "CRC failed in '{0}'. File is broken."
- IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED "Data error in encrypted file '{0}'. Wrong password?"
- IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED "CRC failed in encrypted file '{0}'. Wrong password?"
-
- IDS_EXTRACT_MSG_WRONG_PSW_GUESS "Wrong password?"
- // IDS_EXTRACT_MSG_ENCRYPTED "Encrypted file"
-
- IDS_EXTRACT_MSG_UNSUPPORTED_METHOD "Unsupported compression method"
- IDS_EXTRACT_MSG_DATA_ERROR "Data error"
- IDS_EXTRACT_MSG_CRC_ERROR "CRC failed"
- IDS_EXTRACT_MSG_UNAVAILABLE_DATA "Unavailable data"
- IDS_EXTRACT_MSG_UEXPECTED_END "Unexpected end of data";
- IDS_EXTRACT_MSG_DATA_AFTER_END "There are some data after the end of the payload data"
- IDS_EXTRACT_MSG_IS_NOT_ARC "Is not archive"
- IDS_EXTRACT_MSG_HEADERS_ERROR "Headers Error"
- IDS_EXTRACT_MSG_WRONG_PSW_CLAIM "Wrong password"
-
- IDS_OPEN_MSG_UNAVAILABLE_START "Unavailable start of archive"
- IDS_OPEN_MSG_UNCONFIRMED_START "Unconfirmed start of archive"
- // IDS_OPEN_MSG_ERROR_FLAGS + 5 "Unexpected end of archive"
- // IDS_OPEN_MSG_ERROR_FLAGS + 6 "There are data after the end of archive"
- IDS_OPEN_MSG_UNSUPPORTED_FEATURE "Unsupported feature"
-END
+#include "ExtractRes.h"
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+STRINGTABLE DISCARDABLE
+BEGIN
+ IDS_MEM_ERROR "The system cannot allocate the required amount of memory"
+ IDS_CANNOT_CREATE_FOLDER "Cannot create folder '{0}'"
+ IDS_UPDATE_NOT_SUPPORTED "Update operations are not supported for this archive."
+ IDS_CANT_OPEN_ARCHIVE "Cannot open file '{0}' as archive"
+ IDS_CANT_OPEN_ENCRYPTED_ARCHIVE "Cannot open encrypted archive '{0}'. Wrong password?"
+ IDS_UNSUPPORTED_ARCHIVE_TYPE "Unsupported archive type"
+
+ IDS_CANT_OPEN_AS_TYPE "Cannot open the file as {0} archive"
+ IDS_IS_OPEN_AS_TYPE "The file is open as {0} archive"
+ IDS_IS_OPEN_WITH_OFFSET "The archive is open with offset"
+
+ IDS_PROGRESS_EXTRACTING "Extracting"
+
+ IDS_PROGRESS_SKIPPING "Skipping"
+
+ IDS_EXTRACT_SET_FOLDER "Specify a location for extracted files."
+
+ IDS_EXTRACT_PATHS_FULL "Full pathnames"
+ IDS_EXTRACT_PATHS_NO "No pathnames"
+ IDS_EXTRACT_PATHS_ABS "Absolute pathnames"
+ IDS_PATH_MODE_RELAT "Relative pathnames"
+
+ IDS_EXTRACT_OVERWRITE_ASK "Ask before overwrite"
+ IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT "Overwrite without prompt"
+ IDS_EXTRACT_OVERWRITE_SKIP_EXISTING "Skip existing files"
+ IDS_EXTRACT_OVERWRITE_RENAME "Auto rename"
+ IDS_EXTRACT_OVERWRITE_RENAME_EXISTING "Auto rename existing files"
+
+ IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD "Unsupported compression method for '{0}'."
+ IDS_EXTRACT_MESSAGE_DATA_ERROR "Data error in '{0}'. File is broken"
+ IDS_EXTRACT_MESSAGE_CRC_ERROR "CRC failed in '{0}'. File is broken."
+ IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED "Data error in encrypted file '{0}'. Wrong password?"
+ IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED "CRC failed in encrypted file '{0}'. Wrong password?"
+
+ IDS_EXTRACT_MSG_WRONG_PSW_GUESS "Wrong password?"
+ // IDS_EXTRACT_MSG_ENCRYPTED "Encrypted file"
+
+ IDS_EXTRACT_MSG_UNSUPPORTED_METHOD "Unsupported compression method"
+ IDS_EXTRACT_MSG_DATA_ERROR "Data error"
+ IDS_EXTRACT_MSG_CRC_ERROR "CRC failed"
+ IDS_EXTRACT_MSG_UNAVAILABLE_DATA "Unavailable data"
+ IDS_EXTRACT_MSG_UEXPECTED_END "Unexpected end of data"
+ IDS_EXTRACT_MSG_DATA_AFTER_END "There are some data after the end of the payload data"
+ IDS_EXTRACT_MSG_IS_NOT_ARC "Is not archive"
+ IDS_EXTRACT_MSG_HEADERS_ERROR "Headers Error"
+ IDS_EXTRACT_MSG_WRONG_PSW_CLAIM "Wrong password"
+
+ IDS_OPEN_MSG_UNAVAILABLE_START "Unavailable start of archive"
+ IDS_OPEN_MSG_UNCONFIRMED_START "Unconfirmed start of archive"
+ // IDS_OPEN_MSG_ERROR_FLAGS + 5 "Unexpected end of archive"
+ // IDS_OPEN_MSG_ERROR_FLAGS + 6 "There are data after the end of archive"
+ IDS_OPEN_MSG_UNSUPPORTED_FEATURE "Unsupported feature"
+END
diff --git a/CPP/7zip/UI/GUI/ExtractDialog.cpp b/CPP/7zip/UI/GUI/ExtractDialog.cpp
index 71c2a3b..4628482 100644
--- a/CPP/7zip/UI/GUI/ExtractDialog.cpp
+++ b/CPP/7zip/UI/GUI/ExtractDialog.cpp
@@ -1,418 +1,421 @@
-// ExtractDialog.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/StringConvert.h"
-#include "../../../Common/Wildcard.h"
-
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/ResourceString.h"
-
-#ifndef NO_REGISTRY
-#include "../FileManager/HelpUtils.h"
-#endif
-
-
-#include "../FileManager/BrowseDialog.h"
-#include "../FileManager/LangUtils.h"
-#include "../FileManager/resourceGui.h"
-
-#include "ExtractDialog.h"
-#include "ExtractDialogRes.h"
-#include "ExtractRes.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NName;
-
-extern HINSTANCE g_hInstance;
-
-static const UInt32 kPathMode_IDs[] =
-{
- IDS_EXTRACT_PATHS_FULL,
- IDS_EXTRACT_PATHS_NO,
- IDS_EXTRACT_PATHS_ABS
-};
-
-static const UInt32 kOverwriteMode_IDs[] =
-{
- IDS_EXTRACT_OVERWRITE_ASK,
- IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT,
- IDS_EXTRACT_OVERWRITE_SKIP_EXISTING,
- IDS_EXTRACT_OVERWRITE_RENAME,
- IDS_EXTRACT_OVERWRITE_RENAME_EXISTING
-};
-
-#ifndef _SFX
-
-static const
- // NExtract::NPathMode::EEnum
- int
- kPathModeButtonsVals[] =
-{
- NExtract::NPathMode::kFullPaths,
- NExtract::NPathMode::kNoPaths,
- NExtract::NPathMode::kAbsPaths
-};
-
-static const
- int
- // NExtract::NOverwriteMode::EEnum
- kOverwriteButtonsVals[] =
-{
- NExtract::NOverwriteMode::kAsk,
- NExtract::NOverwriteMode::kOverwrite,
- NExtract::NOverwriteMode::kSkip,
- NExtract::NOverwriteMode::kRename,
- NExtract::NOverwriteMode::kRenameExisting
-};
-
-#endif
-
-#ifdef LANG
-
-static const UInt32 kLangIDs[] =
-{
- IDT_EXTRACT_EXTRACT_TO,
- IDT_EXTRACT_PATH_MODE,
- IDT_EXTRACT_OVERWRITE_MODE,
- // IDX_EXTRACT_ALT_STREAMS,
- IDX_EXTRACT_NT_SECUR,
- IDX_EXTRACT_ELIM_DUP,
- IDG_PASSWORD,
- IDX_PASSWORD_SHOW
-};
-#endif
-
-// static const int kWildcardsButtonIndex = 2;
-
-#ifndef NO_REGISTRY
-static const unsigned kHistorySize = 16;
-#endif
-
-#ifndef _SFX
-
-// it's used in CompressDialog also
-void AddComboItems(NControl::CComboBox &combo, const UInt32 *langIDs, unsigned numItems, const int *values, int curVal)
-{
- int curSel = 0;
- for (unsigned i = 0; i < numItems; i++)
- {
- UString s = LangString(langIDs[i]);
- s.RemoveChar(L'&');
- int index = (int)combo.AddString(s);
- combo.SetItemData(index, i);
- if (values[i] == curVal)
- curSel = i;
- }
- combo.SetCurSel(curSel);
-}
-
-// it's used in CompressDialog also
-bool GetBoolsVal(const CBoolPair &b1, const CBoolPair &b2)
-{
- if (b1.Def) return b1.Val;
- if (b2.Def) return b2.Val;
- return b1.Val;
-}
-
-void CExtractDialog::CheckButton_TwoBools(UINT id, const CBoolPair &b1, const CBoolPair &b2)
-{
- CheckButton(id, GetBoolsVal(b1, b2));
-}
-
-void CExtractDialog::GetButton_Bools(UINT id, CBoolPair &b1, CBoolPair &b2)
-{
- bool val = IsButtonCheckedBool(id);
- bool oldVal = GetBoolsVal(b1, b2);
- if (val != oldVal)
- b1.Def = b2.Def = true;
- b1.Val = b2.Val = val;
-}
-
-#endif
-
-bool CExtractDialog::OnInit()
-{
- #ifdef LANG
- {
- UString s;
- LangString_OnlyFromLangFile(IDD_EXTRACT, s);
- if (s.IsEmpty())
- GetText(s);
- if (!ArcPath.IsEmpty())
- {
- s += " : ";
- s += ArcPath;
- }
- SetText(s);
- // LangSetWindowText(*this, IDD_EXTRACT);
- LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
- }
- #endif
-
- #ifndef _SFX
- _passwordControl.Attach(GetItem(IDE_EXTRACT_PASSWORD));
- _passwordControl.SetText(Password);
- _passwordControl.SetPasswordChar(TEXT('*'));
- _pathName.Attach(GetItem(IDE_EXTRACT_NAME));
- #endif
-
- #ifdef NO_REGISTRY
-
- PathMode = NExtract::NPathMode::kFullPaths;
- OverwriteMode = NExtract::NOverwriteMode::kAsk;
-
- #else
-
- _info.Load();
-
- if (_info.PathMode == NExtract::NPathMode::kCurPaths)
- _info.PathMode = NExtract::NPathMode::kFullPaths;
-
- if (!PathMode_Force && _info.PathMode_Force)
- PathMode = _info.PathMode;
- if (!OverwriteMode_Force && _info.OverwriteMode_Force)
- OverwriteMode = _info.OverwriteMode;
-
- // CheckButton_TwoBools(IDX_EXTRACT_ALT_STREAMS, AltStreams, _info.AltStreams);
- CheckButton_TwoBools(IDX_EXTRACT_NT_SECUR, NtSecurity, _info.NtSecurity);
- CheckButton_TwoBools(IDX_EXTRACT_ELIM_DUP, ElimDup, _info.ElimDup);
-
- CheckButton(IDX_PASSWORD_SHOW, _info.ShowPassword.Val);
- UpdatePasswordControl();
-
- #endif
-
- _path.Attach(GetItem(IDC_EXTRACT_PATH));
-
- UString pathPrefix = DirPath;
-
- #ifndef _SFX
-
- if (_info.SplitDest.Val)
- {
- CheckButton(IDX_EXTRACT_NAME_ENABLE, true);
- UString pathName;
- SplitPathToParts_Smart(DirPath, pathPrefix, pathName);
- if (pathPrefix.IsEmpty())
- pathPrefix = pathName;
- else
- _pathName.SetText(pathName);
- }
- else
- ShowItem_Bool(IDE_EXTRACT_NAME, false);
-
- #endif
-
- _path.SetText(pathPrefix);
-
- #ifndef NO_REGISTRY
- for (unsigned i = 0; i < _info.Paths.Size() && i < kHistorySize; i++)
- _path.AddString(_info.Paths[i]);
- #endif
-
- /*
- if (_info.Paths.Size() > 0)
- _path.SetCurSel(0);
- else
- _path.SetCurSel(-1);
- */
-
- #ifndef _SFX
-
- _pathMode.Attach(GetItem(IDC_EXTRACT_PATH_MODE));
- _overwriteMode.Attach(GetItem(IDC_EXTRACT_OVERWRITE_MODE));
-
- AddComboItems(_pathMode, kPathMode_IDs, ARRAY_SIZE(kPathMode_IDs), kPathModeButtonsVals, PathMode);
- AddComboItems(_overwriteMode, kOverwriteMode_IDs, ARRAY_SIZE(kOverwriteMode_IDs), kOverwriteButtonsVals, OverwriteMode);
-
- #endif
-
- HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ICON));
- SetIcon(ICON_BIG, icon);
-
- // CWindow filesWindow = GetItem(IDC_EXTRACT_RADIO_FILES);
- // filesWindow.Enable(_enableFilesButton);
-
- NormalizePosition();
-
- return CModalDialog::OnInit();
-}
-
-#ifndef _SFX
-void CExtractDialog::UpdatePasswordControl()
-{
- _passwordControl.SetPasswordChar(IsShowPasswordChecked() ? 0 : TEXT('*'));
- UString password;
- _passwordControl.GetText(password);
- _passwordControl.SetText(password);
-}
-#endif
-
-bool CExtractDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- switch (buttonID)
- {
- case IDB_EXTRACT_SET_PATH:
- OnButtonSetPath();
- return true;
- #ifndef _SFX
- case IDX_EXTRACT_NAME_ENABLE:
- ShowItem_Bool(IDE_EXTRACT_NAME, IsButtonCheckedBool(IDX_EXTRACT_NAME_ENABLE));
- return true;
- case IDX_PASSWORD_SHOW:
- {
- UpdatePasswordControl();
- return true;
- }
- #endif
- }
- return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
-}
-
-void CExtractDialog::OnButtonSetPath()
-{
- UString currentPath;
- _path.GetText(currentPath);
- UString title = LangString(IDS_EXTRACT_SET_FOLDER);
- UString resultPath;
- if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
- return;
- #ifndef NO_REGISTRY
- _path.SetCurSel(-1);
- #endif
- _path.SetText(resultPath);
-}
-
-void AddUniqueString(UStringVector &list, const UString &s)
-{
- FOR_VECTOR (i, list)
- if (s.IsEqualTo_NoCase(list[i]))
- return;
- list.Add(s);
-}
-
-void CExtractDialog::OnOK()
-{
- #ifndef _SFX
- int pathMode2 = kPathModeButtonsVals[_pathMode.GetCurSel()];
- if (PathMode != NExtract::NPathMode::kCurPaths ||
- pathMode2 != NExtract::NPathMode::kFullPaths)
- PathMode = (NExtract::NPathMode::EEnum)pathMode2;
-
- OverwriteMode = (NExtract::NOverwriteMode::EEnum)kOverwriteButtonsVals[_overwriteMode.GetCurSel()];
-
- // _filesMode = (NExtractionDialog::NFilesMode::EEnum)GetFilesMode();
-
- _passwordControl.GetText(Password);
-
- #endif
-
- #ifndef NO_REGISTRY
-
- // GetButton_Bools(IDX_EXTRACT_ALT_STREAMS, AltStreams, _info.AltStreams);
- GetButton_Bools(IDX_EXTRACT_NT_SECUR, NtSecurity, _info.NtSecurity);
- GetButton_Bools(IDX_EXTRACT_ELIM_DUP, ElimDup, _info.ElimDup);
-
- bool showPassword = IsShowPasswordChecked();
- if (showPassword != _info.ShowPassword.Val)
- {
- _info.ShowPassword.Def = true;
- _info.ShowPassword.Val = showPassword;
- }
-
- if (_info.PathMode != pathMode2)
- {
- _info.PathMode_Force = true;
- _info.PathMode = (NExtract::NPathMode::EEnum)pathMode2;
- /*
- // we allow kAbsPaths in registry.
- if (_info.PathMode == NExtract::NPathMode::kAbsPaths)
- _info.PathMode = NExtract::NPathMode::kFullPaths;
- */
- }
-
- if (!OverwriteMode_Force && _info.OverwriteMode != OverwriteMode)
- _info.OverwriteMode_Force = true;
- _info.OverwriteMode = OverwriteMode;
-
-
- #else
-
- ElimDup.Val = IsButtonCheckedBool(IDX_EXTRACT_ELIM_DUP);
-
- #endif
-
- UString s;
-
- #ifdef NO_REGISTRY
-
- _path.GetText(s);
-
- #else
-
- int currentItem = _path.GetCurSel();
- if (currentItem == CB_ERR)
- {
- _path.GetText(s);
- if (_path.GetCount() >= kHistorySize)
- currentItem = _path.GetCount() - 1;
- }
- else
- _path.GetLBText(currentItem, s);
-
- #endif
-
- s.Trim();
- NName::NormalizeDirPathPrefix(s);
-
- #ifndef _SFX
-
- bool splitDest = IsButtonCheckedBool(IDX_EXTRACT_NAME_ENABLE);
- if (splitDest)
- {
- UString pathName;
- _pathName.GetText(pathName);
- pathName.Trim();
- s += pathName;
- NName::NormalizeDirPathPrefix(s);
- }
- if (splitDest != _info.SplitDest.Val)
- {
- _info.SplitDest.Def = true;
- _info.SplitDest.Val = splitDest;
- }
-
- #endif
-
- DirPath = s;
-
- #ifndef NO_REGISTRY
- _info.Paths.Clear();
- #ifndef _SFX
- AddUniqueString(_info.Paths, s);
- #endif
- for (int i = 0; i < _path.GetCount(); i++)
- if (i != currentItem)
- {
- UString sTemp;
- _path.GetLBText(i, sTemp);
- sTemp.Trim();
- AddUniqueString(_info.Paths, sTemp);
- }
- _info.Save();
- #endif
-
- CModalDialog::OnOK();
-}
-
-#ifndef NO_REGISTRY
-#define kHelpTopic "fm/plugins/7-zip/extract.htm"
-void CExtractDialog::OnHelp()
-{
- ShowHelpWindow(kHelpTopic);
- CModalDialog::OnHelp();
-}
-#endif
+// ExtractDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/Wildcard.h"
+
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/ResourceString.h"
+
+#ifndef Z7_NO_REGISTRY
+#include "../FileManager/HelpUtils.h"
+#endif
+
+
+#include "../FileManager/BrowseDialog.h"
+#include "../FileManager/LangUtils.h"
+#include "../FileManager/resourceGui.h"
+
+#include "ExtractDialog.h"
+#include "ExtractDialogRes.h"
+#include "ExtractRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+extern HINSTANCE g_hInstance;
+
+#ifndef Z7_SFX
+
+static const UInt32 kPathMode_IDs[] =
+{
+ IDS_EXTRACT_PATHS_FULL,
+ IDS_EXTRACT_PATHS_NO,
+ IDS_EXTRACT_PATHS_ABS
+};
+
+static const UInt32 kOverwriteMode_IDs[] =
+{
+ IDS_EXTRACT_OVERWRITE_ASK,
+ IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT,
+ IDS_EXTRACT_OVERWRITE_SKIP_EXISTING,
+ IDS_EXTRACT_OVERWRITE_RENAME,
+ IDS_EXTRACT_OVERWRITE_RENAME_EXISTING
+};
+
+static const
+ // NExtract::NPathMode::EEnum
+ int
+ kPathModeButtonsVals[] =
+{
+ NExtract::NPathMode::kFullPaths,
+ NExtract::NPathMode::kNoPaths,
+ NExtract::NPathMode::kAbsPaths
+};
+
+static const
+ int
+ // NExtract::NOverwriteMode::EEnum
+ kOverwriteButtonsVals[] =
+{
+ NExtract::NOverwriteMode::kAsk,
+ NExtract::NOverwriteMode::kOverwrite,
+ NExtract::NOverwriteMode::kSkip,
+ NExtract::NOverwriteMode::kRename,
+ NExtract::NOverwriteMode::kRenameExisting
+};
+
+#endif
+
+#ifdef Z7_LANG
+
+static const UInt32 kLangIDs[] =
+{
+ IDT_EXTRACT_EXTRACT_TO,
+ IDT_EXTRACT_PATH_MODE,
+ IDT_EXTRACT_OVERWRITE_MODE,
+ // IDX_EXTRACT_ALT_STREAMS,
+ IDX_EXTRACT_NT_SECUR,
+ IDX_EXTRACT_ELIM_DUP,
+ IDG_PASSWORD,
+ IDX_PASSWORD_SHOW
+};
+#endif
+
+// static const int kWildcardsButtonIndex = 2;
+
+#ifndef Z7_NO_REGISTRY
+static const unsigned kHistorySize = 16;
+#endif
+
+#ifndef Z7_SFX
+
+// it's used in CompressDialog also
+void AddComboItems(NControl::CComboBox &combo, const UInt32 *langIDs, unsigned numItems, const int *values, int curVal);
+void AddComboItems(NControl::CComboBox &combo, const UInt32 *langIDs, unsigned numItems, const int *values, int curVal)
+{
+ unsigned curSel = 0;
+ for (unsigned i = 0; i < numItems; i++)
+ {
+ UString s = LangString(langIDs[i]);
+ s.RemoveChar(L'&');
+ const int index = (int)combo.AddString(s);
+ combo.SetItemData(index, (LPARAM)i);
+ if (values[i] == curVal)
+ curSel = i;
+ }
+ combo.SetCurSel(curSel);
+}
+
+// it's used in CompressDialog also
+bool GetBoolsVal(const CBoolPair &b1, const CBoolPair &b2);
+bool GetBoolsVal(const CBoolPair &b1, const CBoolPair &b2)
+{
+ if (b1.Def) return b1.Val;
+ if (b2.Def) return b2.Val;
+ return b1.Val;
+}
+
+void CExtractDialog::CheckButton_TwoBools(UINT id, const CBoolPair &b1, const CBoolPair &b2)
+{
+ CheckButton(id, GetBoolsVal(b1, b2));
+}
+
+void CExtractDialog::GetButton_Bools(UINT id, CBoolPair &b1, CBoolPair &b2)
+{
+ const bool val = IsButtonCheckedBool(id);
+ const bool oldVal = GetBoolsVal(b1, b2);
+ if (val != oldVal)
+ b1.Def = b2.Def = true;
+ b1.Val = b2.Val = val;
+}
+
+#endif
+
+bool CExtractDialog::OnInit()
+{
+ #ifdef Z7_LANG
+ {
+ UString s;
+ LangString_OnlyFromLangFile(IDD_EXTRACT, s);
+ if (s.IsEmpty())
+ GetText(s);
+ if (!ArcPath.IsEmpty())
+ {
+ s += " : ";
+ s += ArcPath;
+ }
+ SetText(s);
+ // LangSetWindowText(*this, IDD_EXTRACT);
+ LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+ }
+ #endif
+
+ #ifndef Z7_SFX
+ _passwordControl.Attach(GetItem(IDE_EXTRACT_PASSWORD));
+ _passwordControl.SetText(Password);
+ _passwordControl.SetPasswordChar(TEXT('*'));
+ _pathName.Attach(GetItem(IDE_EXTRACT_NAME));
+ #endif
+
+ #ifdef Z7_NO_REGISTRY
+
+ PathMode = NExtract::NPathMode::kFullPaths;
+ OverwriteMode = NExtract::NOverwriteMode::kAsk;
+
+ #else
+
+ _info.Load();
+
+ if (_info.PathMode == NExtract::NPathMode::kCurPaths)
+ _info.PathMode = NExtract::NPathMode::kFullPaths;
+
+ if (!PathMode_Force && _info.PathMode_Force)
+ PathMode = _info.PathMode;
+ if (!OverwriteMode_Force && _info.OverwriteMode_Force)
+ OverwriteMode = _info.OverwriteMode;
+
+ // CheckButton_TwoBools(IDX_EXTRACT_ALT_STREAMS, AltStreams, _info.AltStreams);
+ CheckButton_TwoBools(IDX_EXTRACT_NT_SECUR, NtSecurity, _info.NtSecurity);
+ CheckButton_TwoBools(IDX_EXTRACT_ELIM_DUP, ElimDup, _info.ElimDup);
+
+ CheckButton(IDX_PASSWORD_SHOW, _info.ShowPassword.Val);
+ UpdatePasswordControl();
+
+ #endif
+
+ _path.Attach(GetItem(IDC_EXTRACT_PATH));
+
+ UString pathPrefix = DirPath;
+
+ #ifndef Z7_SFX
+
+ if (_info.SplitDest.Val)
+ {
+ CheckButton(IDX_EXTRACT_NAME_ENABLE, true);
+ UString pathName;
+ SplitPathToParts_Smart(DirPath, pathPrefix, pathName);
+ if (pathPrefix.IsEmpty())
+ pathPrefix = pathName;
+ else
+ _pathName.SetText(pathName);
+ }
+ else
+ ShowItem_Bool(IDE_EXTRACT_NAME, false);
+
+ #endif
+
+ _path.SetText(pathPrefix);
+
+ #ifndef Z7_NO_REGISTRY
+ for (unsigned i = 0; i < _info.Paths.Size() && i < kHistorySize; i++)
+ _path.AddString(_info.Paths[i]);
+ #endif
+
+ /*
+ if (_info.Paths.Size() > 0)
+ _path.SetCurSel(0);
+ else
+ _path.SetCurSel(-1);
+ */
+
+ #ifndef Z7_SFX
+
+ _pathMode.Attach(GetItem(IDC_EXTRACT_PATH_MODE));
+ _overwriteMode.Attach(GetItem(IDC_EXTRACT_OVERWRITE_MODE));
+
+ AddComboItems(_pathMode, kPathMode_IDs, Z7_ARRAY_SIZE(kPathMode_IDs), kPathModeButtonsVals, PathMode);
+ AddComboItems(_overwriteMode, kOverwriteMode_IDs, Z7_ARRAY_SIZE(kOverwriteMode_IDs), kOverwriteButtonsVals, OverwriteMode);
+
+ #endif
+
+ HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ICON));
+ SetIcon(ICON_BIG, icon);
+
+ // CWindow filesWindow = GetItem(IDC_EXTRACT_RADIO_FILES);
+ // filesWindow.Enable(_enableFilesButton);
+
+ NormalizePosition();
+
+ return CModalDialog::OnInit();
+}
+
+#ifndef Z7_SFX
+void CExtractDialog::UpdatePasswordControl()
+{
+ _passwordControl.SetPasswordChar(IsShowPasswordChecked() ? 0 : TEXT('*'));
+ UString password;
+ _passwordControl.GetText(password);
+ _passwordControl.SetText(password);
+}
+#endif
+
+bool CExtractDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDB_EXTRACT_SET_PATH:
+ OnButtonSetPath();
+ return true;
+ #ifndef Z7_SFX
+ case IDX_EXTRACT_NAME_ENABLE:
+ ShowItem_Bool(IDE_EXTRACT_NAME, IsButtonCheckedBool(IDX_EXTRACT_NAME_ENABLE));
+ return true;
+ case IDX_PASSWORD_SHOW:
+ {
+ UpdatePasswordControl();
+ return true;
+ }
+ #endif
+ }
+ return CModalDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+void CExtractDialog::OnButtonSetPath()
+{
+ UString currentPath;
+ _path.GetText(currentPath);
+ UString title = LangString(IDS_EXTRACT_SET_FOLDER);
+ UString resultPath;
+ if (!MyBrowseForFolder(*this, title, currentPath, resultPath))
+ return;
+ #ifndef Z7_NO_REGISTRY
+ _path.SetCurSel(-1);
+ #endif
+ _path.SetText(resultPath);
+}
+
+void AddUniqueString(UStringVector &list, const UString &s);
+void AddUniqueString(UStringVector &list, const UString &s)
+{
+ FOR_VECTOR (i, list)
+ if (s.IsEqualTo_NoCase(list[i]))
+ return;
+ list.Add(s);
+}
+
+void CExtractDialog::OnOK()
+{
+ #ifndef Z7_SFX
+ int pathMode2 = kPathModeButtonsVals[_pathMode.GetCurSel()];
+ if (PathMode != NExtract::NPathMode::kCurPaths ||
+ pathMode2 != NExtract::NPathMode::kFullPaths)
+ PathMode = (NExtract::NPathMode::EEnum)pathMode2;
+
+ OverwriteMode = (NExtract::NOverwriteMode::EEnum)kOverwriteButtonsVals[_overwriteMode.GetCurSel()];
+
+ // _filesMode = (NExtractionDialog::NFilesMode::EEnum)GetFilesMode();
+
+ _passwordControl.GetText(Password);
+
+ #endif
+
+ #ifndef Z7_NO_REGISTRY
+
+ // GetButton_Bools(IDX_EXTRACT_ALT_STREAMS, AltStreams, _info.AltStreams);
+ GetButton_Bools(IDX_EXTRACT_NT_SECUR, NtSecurity, _info.NtSecurity);
+ GetButton_Bools(IDX_EXTRACT_ELIM_DUP, ElimDup, _info.ElimDup);
+
+ bool showPassword = IsShowPasswordChecked();
+ if (showPassword != _info.ShowPassword.Val)
+ {
+ _info.ShowPassword.Def = true;
+ _info.ShowPassword.Val = showPassword;
+ }
+
+ if (_info.PathMode != pathMode2)
+ {
+ _info.PathMode_Force = true;
+ _info.PathMode = (NExtract::NPathMode::EEnum)pathMode2;
+ /*
+ // we allow kAbsPaths in registry.
+ if (_info.PathMode == NExtract::NPathMode::kAbsPaths)
+ _info.PathMode = NExtract::NPathMode::kFullPaths;
+ */
+ }
+
+ if (!OverwriteMode_Force && _info.OverwriteMode != OverwriteMode)
+ _info.OverwriteMode_Force = true;
+ _info.OverwriteMode = OverwriteMode;
+
+
+ #else
+
+ ElimDup.Val = IsButtonCheckedBool(IDX_EXTRACT_ELIM_DUP);
+
+ #endif
+
+ UString s;
+
+ #ifdef Z7_NO_REGISTRY
+
+ _path.GetText(s);
+
+ #else
+
+ int currentItem = _path.GetCurSel();
+ if (currentItem == CB_ERR)
+ {
+ _path.GetText(s);
+ if (_path.GetCount() >= (int)kHistorySize)
+ currentItem = _path.GetCount() - 1;
+ }
+ else
+ _path.GetLBText(currentItem, s);
+
+ #endif
+
+ s.Trim();
+ NName::NormalizeDirPathPrefix(s);
+
+ #ifndef Z7_SFX
+
+ const bool splitDest = IsButtonCheckedBool(IDX_EXTRACT_NAME_ENABLE);
+ if (splitDest)
+ {
+ UString pathName;
+ _pathName.GetText(pathName);
+ pathName.Trim();
+ s += pathName;
+ NName::NormalizeDirPathPrefix(s);
+ }
+ if (splitDest != _info.SplitDest.Val)
+ {
+ _info.SplitDest.Def = true;
+ _info.SplitDest.Val = splitDest;
+ }
+
+ #endif
+
+ DirPath = s;
+
+ #ifndef Z7_NO_REGISTRY
+ _info.Paths.Clear();
+ #ifndef Z7_SFX
+ AddUniqueString(_info.Paths, s);
+ #endif
+ for (int i = 0; i < _path.GetCount(); i++)
+ if (i != currentItem)
+ {
+ UString sTemp;
+ _path.GetLBText(i, sTemp);
+ sTemp.Trim();
+ AddUniqueString(_info.Paths, sTemp);
+ }
+ _info.Save();
+ #endif
+
+ CModalDialog::OnOK();
+}
+
+#ifndef Z7_NO_REGISTRY
+#define kHelpTopic "fm/plugins/7-zip/extract.htm"
+void CExtractDialog::OnHelp()
+{
+ ShowHelpWindow(kHelpTopic);
+ CModalDialog::OnHelp();
+}
+#endif
diff --git a/CPP/7zip/UI/GUI/ExtractDialog.h b/CPP/7zip/UI/GUI/ExtractDialog.h
index 308c786..1565fb8 100644
--- a/CPP/7zip/UI/GUI/ExtractDialog.h
+++ b/CPP/7zip/UI/GUI/ExtractDialog.h
@@ -1,113 +1,113 @@
-// ExtractDialog.h
-
-#ifndef __EXTRACT_DIALOG_H
-#define __EXTRACT_DIALOG_H
-
-#include "ExtractDialogRes.h"
-
-#include "../../../Windows/Control/ComboBox.h"
-#include "../../../Windows/Control/Edit.h"
-
-#include "../Common/ExtractMode.h"
-
-#include "../FileManager/DialogSize.h"
-
-#ifndef NO_REGISTRY
-#include "../Common/ZipRegistry.h"
-#endif
-
-namespace NExtractionDialog
-{
- /*
- namespace NFilesMode
- {
- enum EEnum
- {
- kSelected,
- kAll,
- kSpecified
- };
- }
- */
-}
-
-class CExtractDialog: public NWindows::NControl::CModalDialog
-{
- #ifdef NO_REGISTRY
- NWindows::NControl::CDialogChildControl _path;
- #else
- NWindows::NControl::CComboBox _path;
- #endif
-
- #ifndef _SFX
- NWindows::NControl::CEdit _pathName;
- NWindows::NControl::CEdit _passwordControl;
- NWindows::NControl::CComboBox _pathMode;
- NWindows::NControl::CComboBox _overwriteMode;
- #endif
-
- #ifndef _SFX
- // int GetFilesMode() const;
- void UpdatePasswordControl();
- #endif
-
- void OnButtonSetPath();
-
- void CheckButton_TwoBools(UINT id, const CBoolPair &b1, const CBoolPair &b2);
- void GetButton_Bools(UINT id, CBoolPair &b1, CBoolPair &b2);
- virtual bool OnInit();
- virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
- virtual void OnOK();
-
- #ifndef NO_REGISTRY
-
- virtual void OnHelp();
-
- NExtract::CInfo _info;
-
- #endif
-
- bool IsShowPasswordChecked() const { return IsButtonCheckedBool(IDX_PASSWORD_SHOW); }
-public:
- // bool _enableSelectedFilesButton;
- // bool _enableFilesButton;
- // NExtractionDialog::NFilesMode::EEnum FilesMode;
-
- UString DirPath;
- UString ArcPath;
-
- #ifndef _SFX
- UString Password;
- #endif
- bool PathMode_Force;
- bool OverwriteMode_Force;
- NExtract::NPathMode::EEnum PathMode;
- NExtract::NOverwriteMode::EEnum OverwriteMode;
-
- #ifndef _SFX
- // CBoolPair AltStreams;
- CBoolPair NtSecurity;
- #endif
-
- CBoolPair ElimDup;
-
- INT_PTR Create(HWND aWndParent = 0)
- {
- #ifdef _SFX
- BIG_DIALOG_SIZE(240, 64);
- #else
- BIG_DIALOG_SIZE(300, 160);
- #endif
- return CModalDialog::Create(SIZED_DIALOG(IDD_EXTRACT), aWndParent);
- }
-
- CExtractDialog():
- PathMode_Force(false),
- OverwriteMode_Force(false)
- {
- ElimDup.Val = true;
- }
-
-};
-
-#endif
+// ExtractDialog.h
+
+#ifndef ZIP7_INC_EXTRACT_DIALOG_H
+#define ZIP7_INC_EXTRACT_DIALOG_H
+
+#include "ExtractDialogRes.h"
+
+#include "../../../Windows/Control/ComboBox.h"
+#include "../../../Windows/Control/Edit.h"
+
+#include "../Common/ExtractMode.h"
+
+#include "../FileManager/DialogSize.h"
+
+#ifndef Z7_NO_REGISTRY
+#include "../Common/ZipRegistry.h"
+#endif
+
+namespace NExtractionDialog
+{
+ /*
+ namespace NFilesMode
+ {
+ enum EEnum
+ {
+ kSelected,
+ kAll,
+ kSpecified
+ };
+ }
+ */
+}
+
+class CExtractDialog: public NWindows::NControl::CModalDialog
+{
+ #ifdef Z7_NO_REGISTRY
+ NWindows::NControl::CDialogChildControl _path;
+ #else
+ NWindows::NControl::CComboBox _path;
+ #endif
+
+ #ifndef Z7_SFX
+ NWindows::NControl::CEdit _pathName;
+ NWindows::NControl::CEdit _passwordControl;
+ NWindows::NControl::CComboBox _pathMode;
+ NWindows::NControl::CComboBox _overwriteMode;
+ #endif
+
+ #ifndef Z7_SFX
+ // int GetFilesMode() const;
+ void UpdatePasswordControl();
+ #endif
+
+ void OnButtonSetPath();
+
+ void CheckButton_TwoBools(UINT id, const CBoolPair &b1, const CBoolPair &b2);
+ void GetButton_Bools(UINT id, CBoolPair &b1, CBoolPair &b2);
+ virtual bool OnInit() Z7_override;
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+ virtual void OnOK() Z7_override;
+
+ #ifndef Z7_NO_REGISTRY
+
+ virtual void OnHelp() Z7_override;
+
+ NExtract::CInfo _info;
+
+ #endif
+
+ bool IsShowPasswordChecked() const { return IsButtonCheckedBool(IDX_PASSWORD_SHOW); }
+public:
+ // bool _enableSelectedFilesButton;
+ // bool _enableFilesButton;
+ // NExtractionDialog::NFilesMode::EEnum FilesMode;
+
+ UString DirPath;
+ UString ArcPath;
+
+ #ifndef Z7_SFX
+ UString Password;
+ #endif
+ bool PathMode_Force;
+ bool OverwriteMode_Force;
+ NExtract::NPathMode::EEnum PathMode;
+ NExtract::NOverwriteMode::EEnum OverwriteMode;
+
+ #ifndef Z7_SFX
+ // CBoolPair AltStreams;
+ CBoolPair NtSecurity;
+ #endif
+
+ CBoolPair ElimDup;
+
+ INT_PTR Create(HWND aWndParent = NULL)
+ {
+ #ifdef Z7_SFX
+ BIG_DIALOG_SIZE(240, 64);
+ #else
+ BIG_DIALOG_SIZE(300, 160);
+ #endif
+ return CModalDialog::Create(SIZED_DIALOG(IDD_EXTRACT), aWndParent);
+ }
+
+ CExtractDialog():
+ PathMode_Force(false),
+ OverwriteMode_Force(false)
+ {
+ ElimDup.Val = true;
+ }
+
+};
+
+#endif
diff --git a/CPP/7zip/UI/GUI/ExtractDialog.rc b/CPP/7zip/UI/GUI/ExtractDialog.rc
index f5d6528..3728b96 100644
--- a/CPP/7zip/UI/GUI/ExtractDialog.rc
+++ b/CPP/7zip/UI/GUI/ExtractDialog.rc
@@ -1,98 +1,98 @@
-#include "ExtractDialogRes.h"
-#include "../../GuiCommon.rc"
-
-#define xc 336
-#define yc 168
-
-#undef g1xs
-#undef g2x
-#undef g2x2
-#undef g2xs
-#undef g2xs2
-
-#define g1xs 160
-
-#define gSpace 20
-#define g2x (m + g1xs + gSpace)
-#define g2x2 (g2x + m)
-#define g2xs (xc - g1xs - gSpace)
-#define g2xs2 (g2xs - m - m)
-
-#undef GROUP_Y_SIZE
-#ifdef UNDER_CE
-#define GROUP_Y_SIZE 8
-#else
-#define GROUP_Y_SIZE 56
-#endif
-
-IDD_EXTRACT DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "Extract"
-BEGIN
- LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc, 8
- COMBOBOX IDC_EXTRACT_PATH, m, m + 12, xc - bxsDots - 12, 100, MY_COMBO_WITH_EDIT
- PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, m + 12 - 2, bxsDots, bys, WS_GROUP
-
- CONTROL "", IDX_EXTRACT_NAME_ENABLE, MY_CHECKBOX, m, m + 34, 12, 10
- EDITTEXT IDE_EXTRACT_NAME, m + 12 + 2, m + 32, g1xs - 12 - 2, 14, ES_AUTOHSCROLL
-
- LTEXT "Path mode:", IDT_EXTRACT_PATH_MODE, m, m + 52, g1xs, 8
- COMBOBOX IDC_EXTRACT_PATH_MODE, m, m + 64, g1xs, 140, MY_COMBO
-
- CONTROL "Eliminate duplication of root folder", IDX_EXTRACT_ELIM_DUP, MY_CHECKBOX,
- m, m + 84, g1xs, 10
-
- LTEXT "Overwrite mode:", IDT_EXTRACT_OVERWRITE_MODE, m, m + 104, g1xs, 8
- COMBOBOX IDC_EXTRACT_OVERWRITE_MODE, m, m + 116, g1xs, 140, MY_COMBO
-
-
- GROUPBOX "Password", IDG_PASSWORD, g2x, m + 36, g2xs, GROUP_Y_SIZE
- EDITTEXT IDE_EXTRACT_PASSWORD, g2x2, m + 50, g2xs2, 14, ES_PASSWORD | ES_AUTOHSCROLL
- CONTROL "Show Password", IDX_PASSWORD_SHOW, MY_CHECKBOX, g2x2, m + 72, g2xs2, 10
-
-// CONTROL "Restore alternate data streams", IDX_EXTRACT_ALT_STREAMS, MY_CHECKBOX,
-// g2x, m + 104, g2xs, 10
- CONTROL "Restore file security", IDX_EXTRACT_NT_SECUR, MY_CHECKBOX,
- g2x, m + 104, g2xs, 10
-
- DEFPUSHBUTTON "OK", IDOK, bx3, by, bxs, bys, WS_GROUP
- PUSHBUTTON "Cancel", IDCANCEL, bx2, by, bxs, bys
- PUSHBUTTON "Help", IDHELP, bx1, by, bxs, bys
-END
-
-
-#ifdef UNDER_CE
-
-#undef m
-#define m 4
-
-#undef xc
-#undef yc
-
-#define xc 152
-#define yc 128
-
-#undef g1xs
-
-#define g1xs 64
-
-IDD_EXTRACT_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
-CAPTION "Extract"
-BEGIN
- LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc - bxsDots - 8, 8
- COMBOBOX IDC_EXTRACT_PATH, m, m + 12, xc - bxsDots - 8, 100, MY_COMBO_WITH_EDIT
- PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, m + 12 - 3, bxsDots, bys, WS_GROUP
-
- LTEXT "Path mode:", IDT_EXTRACT_PATH_MODE, m, m + 36, g1xs, 8
- COMBOBOX IDC_EXTRACT_PATH_MODE, m + g1xs, m + 36, xc - g1xs, 100, MY_COMBO
-
- LTEXT "Overwrite mode:", IDT_EXTRACT_OVERWRITE_MODE, m, m + 56, g1xs, 8
- COMBOBOX IDC_EXTRACT_OVERWRITE_MODE, m + g1xs, m + 56, xc - g1xs, 100, MY_COMBO
-
- LTEXT "Password", IDG_PASSWORD, m, m + 76, g1xs, 8
- EDITTEXT IDE_EXTRACT_PASSWORD, m + g1xs, m + 76, xc - g1xs, 14, ES_PASSWORD | ES_AUTOHSCROLL
- CONTROL "Show Password", IDX_PASSWORD_SHOW, MY_CHECKBOX, m, m + 92, xc, 10
-
- OK_CANCEL
-END
-
-#endif
+#include "ExtractDialogRes.h"
+#include "../../GuiCommon.rc"
+
+#define xc 336
+#define yc 168
+
+#undef g1xs
+#undef g2x
+#undef g2x2
+#undef g2xs
+#undef g2xs2
+
+#define g1xs 160
+
+#define gSpace 20
+#define g2x (m + g1xs + gSpace)
+#define g2x2 (g2x + m)
+#define g2xs (xc - g1xs - gSpace)
+#define g2xs2 (g2xs - m - m)
+
+#undef GROUP_Y_SIZE
+#ifdef UNDER_CE
+#define GROUP_Y_SIZE 8
+#else
+#define GROUP_Y_SIZE 56
+#endif
+
+IDD_EXTRACT DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Extract"
+BEGIN
+ LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc, 8
+ COMBOBOX IDC_EXTRACT_PATH, m, m + 12, xc - bxsDots - 12, 100, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, m + 12 - 2, bxsDots, bys, WS_GROUP
+
+ CONTROL "", IDX_EXTRACT_NAME_ENABLE, MY_CHECKBOX, m, m + 34, 12, 10
+ EDITTEXT IDE_EXTRACT_NAME, m + 12 + 2, m + 32, g1xs - 12 - 2, 14, ES_AUTOHSCROLL
+
+ LTEXT "Path mode:", IDT_EXTRACT_PATH_MODE, m, m + 52, g1xs, 8
+ COMBOBOX IDC_EXTRACT_PATH_MODE, m, m + 64, g1xs, 140, MY_COMBO
+
+ CONTROL "Eliminate duplication of root folder", IDX_EXTRACT_ELIM_DUP, MY_CHECKBOX,
+ m, m + 84, g1xs, 10
+
+ LTEXT "Overwrite mode:", IDT_EXTRACT_OVERWRITE_MODE, m, m + 104, g1xs, 8
+ COMBOBOX IDC_EXTRACT_OVERWRITE_MODE, m, m + 116, g1xs, 140, MY_COMBO
+
+
+ GROUPBOX "Password", IDG_PASSWORD, g2x, m + 36, g2xs, GROUP_Y_SIZE
+ EDITTEXT IDE_EXTRACT_PASSWORD, g2x2, m + 50, g2xs2, 14, ES_PASSWORD | ES_AUTOHSCROLL
+ CONTROL "Show Password", IDX_PASSWORD_SHOW, MY_CHECKBOX, g2x2, m + 72, g2xs2, 10
+
+// CONTROL "Restore alternate data streams", IDX_EXTRACT_ALT_STREAMS, MY_CHECKBOX,
+// g2x, m + 104, g2xs, 10
+ CONTROL "Restore file security", IDX_EXTRACT_NT_SECUR, MY_CHECKBOX,
+ g2x, m + 104, g2xs, 10
+
+ DEFPUSHBUTTON "OK", IDOK, bx3, by, bxs, bys, WS_GROUP
+ PUSHBUTTON "Cancel", IDCANCEL, bx2, by, bxs, bys
+ PUSHBUTTON "Help", IDHELP, bx1, by, bxs, bys
+END
+
+
+#ifdef UNDER_CE
+
+#undef m
+#define m 4
+
+#undef xc
+#undef yc
+
+#define xc 152
+#define yc 128
+
+#undef g1xs
+
+#define g1xs 64
+
+IDD_EXTRACT_2 DIALOG 0, 0, xs, ys MY_MODAL_DIALOG_STYLE MY_FONT
+CAPTION "Extract"
+BEGIN
+ LTEXT "E&xtract to:", IDT_EXTRACT_EXTRACT_TO, m, m, xc - bxsDots - 8, 8
+ COMBOBOX IDC_EXTRACT_PATH, m, m + 12, xc - bxsDots - 8, 100, MY_COMBO_WITH_EDIT
+ PUSHBUTTON "...", IDB_EXTRACT_SET_PATH, xs - m - bxsDots, m + 12 - 3, bxsDots, bys, WS_GROUP
+
+ LTEXT "Path mode:", IDT_EXTRACT_PATH_MODE, m, m + 36, g1xs, 8
+ COMBOBOX IDC_EXTRACT_PATH_MODE, m + g1xs, m + 36, xc - g1xs, 100, MY_COMBO
+
+ LTEXT "Overwrite mode:", IDT_EXTRACT_OVERWRITE_MODE, m, m + 56, g1xs, 8
+ COMBOBOX IDC_EXTRACT_OVERWRITE_MODE, m + g1xs, m + 56, xc - g1xs, 100, MY_COMBO
+
+ LTEXT "Password", IDG_PASSWORD, m, m + 76, g1xs, 8
+ EDITTEXT IDE_EXTRACT_PASSWORD, m + g1xs, m + 76, xc - g1xs, 14, ES_PASSWORD | ES_AUTOHSCROLL
+ CONTROL "Show Password", IDX_PASSWORD_SHOW, MY_CHECKBOX, m, m + 92, xc, 10
+
+ OK_CANCEL
+END
+
+#endif
diff --git a/CPP/7zip/UI/GUI/ExtractDialogRes.h b/CPP/7zip/UI/GUI/ExtractDialogRes.h
index e198796..ed12bfb 100644
--- a/CPP/7zip/UI/GUI/ExtractDialogRes.h
+++ b/CPP/7zip/UI/GUI/ExtractDialogRes.h
@@ -1,24 +1,24 @@
-#define IDD_EXTRACT 3400
-#define IDD_EXTRACT_2 13400
-
-#define IDC_EXTRACT_PATH 100
-#define IDB_EXTRACT_SET_PATH 101
-#define IDC_EXTRACT_PATH_MODE 102
-#define IDC_EXTRACT_OVERWRITE_MODE 103
-
-#define IDE_EXTRACT_PASSWORD 120
-
-#define IDE_EXTRACT_NAME 130
-#define IDX_EXTRACT_NAME_ENABLE 131
-
-
-#define IDT_EXTRACT_EXTRACT_TO 3401
-#define IDT_EXTRACT_PATH_MODE 3410
-#define IDT_EXTRACT_OVERWRITE_MODE 3420
-
-#define IDX_EXTRACT_ELIM_DUP 3430
-#define IDX_EXTRACT_NT_SECUR 3431
-// #define IDX_EXTRACT_ALT_STREAMS 3432
-
-#define IDX_PASSWORD_SHOW 3803
-#define IDG_PASSWORD 3807
+#define IDD_EXTRACT 3400
+#define IDD_EXTRACT_2 13400
+
+#define IDC_EXTRACT_PATH 100
+#define IDB_EXTRACT_SET_PATH 101
+#define IDC_EXTRACT_PATH_MODE 102
+#define IDC_EXTRACT_OVERWRITE_MODE 103
+
+#define IDE_EXTRACT_PASSWORD 120
+
+#define IDE_EXTRACT_NAME 130
+#define IDX_EXTRACT_NAME_ENABLE 131
+
+
+#define IDT_EXTRACT_EXTRACT_TO 3401
+#define IDT_EXTRACT_PATH_MODE 3410
+#define IDT_EXTRACT_OVERWRITE_MODE 3420
+
+#define IDX_EXTRACT_ELIM_DUP 3430
+#define IDX_EXTRACT_NT_SECUR 3431
+// #define IDX_EXTRACT_ALT_STREAMS 3432
+
+#define IDX_PASSWORD_SHOW 3803
+#define IDG_PASSWORD 3807
diff --git a/CPP/7zip/UI/GUI/ExtractGUI.cpp b/CPP/7zip/UI/GUI/ExtractGUI.cpp
index 99db743..fdf3cc7 100644
--- a/CPP/7zip/UI/GUI/ExtractGUI.cpp
+++ b/CPP/7zip/UI/GUI/ExtractGUI.cpp
@@ -1,280 +1,297 @@
-// ExtractGUI.cpp
-
-#include "StdAfx.h"
-
-#include "../../../Common/IntToString.h"
-#include "../../../Common/StringConvert.h"
-
-#include "../../../Windows/FileDir.h"
-#include "../../../Windows/FileFind.h"
-#include "../../../Windows/FileName.h"
-#include "../../../Windows/Thread.h"
-
-#include "../FileManager/ExtractCallback.h"
-#include "../FileManager/FormatUtils.h"
-#include "../FileManager/LangUtils.h"
-#include "../FileManager/resourceGui.h"
-#include "../FileManager/OverwriteDialogRes.h"
-
-#include "../Common/ArchiveExtractCallback.h"
-#include "../Common/PropIDUtils.h"
-
-#include "../Explorer/MyMessages.h"
-
-#include "resource2.h"
-#include "ExtractRes.h"
-
-#include "ExtractDialog.h"
-#include "ExtractGUI.h"
-#include "HashGUI.h"
-
-#include "../FileManager/PropertyNameRes.h"
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NDir;
-
-static const wchar_t * const kIncorrectOutDir = L"Incorrect output directory path";
-
-#ifndef _SFX
-
-static void AddValuePair(UString &s, UINT resourceID, UInt64 value, bool addColon = true)
-{
- AddLangString(s, resourceID);
- if (addColon)
- s += ':';
- s.Add_Space();
- char sz[32];
- ConvertUInt64ToString(value, sz);
- s += sz;
- s.Add_LF();
-}
-
-static void AddSizePair(UString &s, UINT resourceID, UInt64 value)
-{
- AddLangString(s, resourceID);
- s += ": ";
- AddSizeValue(s, value);
- s.Add_LF();
-}
-
-#endif
-
-class CThreadExtracting: public CProgressThreadVirt
-{
- HRESULT ProcessVirt();
-public:
- CCodecs *codecs;
- CExtractCallbackImp *ExtractCallbackSpec;
- const CObjectVector<COpenType> *FormatIndices;
- const CIntVector *ExcludedFormatIndices;
-
- UStringVector *ArchivePaths;
- UStringVector *ArchivePathsFull;
- const NWildcard::CCensorNode *WildcardCensor;
- const CExtractOptions *Options;
-
- #ifndef _SFX
- CHashBundle *HashBundle;
- virtual void ProcessWasFinished_GuiVirt();
- #endif
-
- CMyComPtr<IExtractCallbackUI> ExtractCallback;
- UString Title;
-
- CPropNameValPairs Pairs;
-};
-
-
-#ifndef _SFX
-void CThreadExtracting::ProcessWasFinished_GuiVirt()
-{
- if (HashBundle && !Pairs.IsEmpty())
- ShowHashResults(Pairs, *this);
-}
-#endif
-
-HRESULT CThreadExtracting::ProcessVirt()
-{
- CDecompressStat Stat;
-
- #ifndef _SFX
- /*
- if (HashBundle)
- HashBundle->Init();
- */
- #endif
-
- HRESULT res = Extract(codecs,
- *FormatIndices, *ExcludedFormatIndices,
- *ArchivePaths, *ArchivePathsFull,
- *WildcardCensor, *Options, ExtractCallbackSpec, ExtractCallback,
- #ifndef _SFX
- HashBundle,
- #endif
- FinalMessage.ErrorMessage.Message, Stat);
-
- #ifndef _SFX
- if (res == S_OK && ExtractCallbackSpec->IsOK())
- {
- if (HashBundle)
- {
- AddValuePair(Pairs, IDS_ARCHIVES_COLON, Stat.NumArchives);
- AddSizeValuePair(Pairs, IDS_PROP_PACKED_SIZE, Stat.PackSize);
- AddHashBundleRes(Pairs, *HashBundle);
- }
- else if (Options->TestMode)
- {
- UString s;
-
- AddValuePair(s, IDS_ARCHIVES_COLON, Stat.NumArchives, false);
- AddSizePair(s, IDS_PROP_PACKED_SIZE, Stat.PackSize);
-
- if (Stat.NumFolders != 0)
- AddValuePair(s, IDS_PROP_FOLDERS, Stat.NumFolders);
- AddValuePair(s, IDS_PROP_FILES, Stat.NumFiles);
- AddSizePair(s, IDS_PROP_SIZE, Stat.UnpackSize);
- if (Stat.NumAltStreams != 0)
- {
- s.Add_LF();
- AddValuePair(s, IDS_PROP_NUM_ALT_STREAMS, Stat.NumAltStreams);
- AddSizePair(s, IDS_PROP_ALT_STREAMS_SIZE, Stat.AltStreams_UnpackSize);
- }
- s.Add_LF();
- AddLangString(s, IDS_MESSAGE_NO_ERRORS);
- FinalMessage.OkMessage.Title = Title;
- FinalMessage.OkMessage.Message = s;
- }
- }
- #endif
-
- return res;
-}
-
-
-
-HRESULT ExtractGUI(
- CCodecs *codecs,
- const CObjectVector<COpenType> &formatIndices,
- const CIntVector &excludedFormatIndices,
- UStringVector &archivePaths,
- UStringVector &archivePathsFull,
- const NWildcard::CCensorNode &wildcardCensor,
- CExtractOptions &options,
- #ifndef _SFX
- CHashBundle *hb,
- #endif
- bool showDialog,
- bool &messageWasDisplayed,
- CExtractCallbackImp *extractCallback,
- HWND hwndParent)
-{
- messageWasDisplayed = false;
-
- CThreadExtracting extracter;
- extracter.codecs = codecs;
- extracter.FormatIndices = &formatIndices;
- extracter.ExcludedFormatIndices = &excludedFormatIndices;
-
- if (!options.TestMode)
- {
- FString outputDir = options.OutputDir;
- #ifndef UNDER_CE
- if (outputDir.IsEmpty())
- GetCurrentDir(outputDir);
- #endif
- if (showDialog)
- {
- CExtractDialog dialog;
- FString outputDirFull;
- if (!MyGetFullPathName(outputDir, outputDirFull))
- {
- ShowErrorMessage(kIncorrectOutDir);
- messageWasDisplayed = true;
- return E_FAIL;
- }
- NName::NormalizeDirPathPrefix(outputDirFull);
-
- dialog.DirPath = fs2us(outputDirFull);
-
- dialog.OverwriteMode = options.OverwriteMode;
- dialog.OverwriteMode_Force = options.OverwriteMode_Force;
- dialog.PathMode = options.PathMode;
- dialog.PathMode_Force = options.PathMode_Force;
- dialog.ElimDup = options.ElimDup;
-
- if (archivePathsFull.Size() == 1)
- dialog.ArcPath = archivePathsFull[0];
-
- #ifndef _SFX
- // dialog.AltStreams = options.NtOptions.AltStreams;
- dialog.NtSecurity = options.NtOptions.NtSecurity;
- if (extractCallback->PasswordIsDefined)
- dialog.Password = extractCallback->Password;
- #endif
-
- if (dialog.Create(hwndParent) != IDOK)
- return E_ABORT;
-
- outputDir = us2fs(dialog.DirPath);
-
- options.OverwriteMode = dialog.OverwriteMode;
- options.PathMode = dialog.PathMode;
- options.ElimDup = dialog.ElimDup;
-
- #ifndef _SFX
- // options.NtOptions.AltStreams = dialog.AltStreams;
- options.NtOptions.NtSecurity = dialog.NtSecurity;
- extractCallback->Password = dialog.Password;
- extractCallback->PasswordIsDefined = !dialog.Password.IsEmpty();
- #endif
- }
- if (!MyGetFullPathName(outputDir, options.OutputDir))
- {
- ShowErrorMessage(kIncorrectOutDir);
- messageWasDisplayed = true;
- return E_FAIL;
- }
- NName::NormalizeDirPathPrefix(options.OutputDir);
-
- /*
- if (!CreateComplexDirectory(options.OutputDir))
- {
- UString s = GetUnicodeString(NError::MyFormatMessage(GetLastError()));
- UString s2 = MyFormatNew(IDS_CANNOT_CREATE_FOLDER,
- #ifdef LANG
- 0x02000603,
- #endif
- options.OutputDir);
- s2.Add_LF();
- s2 += s;
- MyMessageBox(s2);
- return E_FAIL;
- }
- */
- }
-
- UString title = LangString(options.TestMode ? IDS_PROGRESS_TESTING : IDS_PROGRESS_EXTRACTING);
-
- extracter.Title = title;
- extracter.ExtractCallbackSpec = extractCallback;
- extracter.ExtractCallbackSpec->ProgressDialog = &extracter;
- extracter.ExtractCallback = extractCallback;
- extracter.ExtractCallbackSpec->Init();
-
- extracter.CompressingMode = false;
-
- extracter.ArchivePaths = &archivePaths;
- extracter.ArchivePathsFull = &archivePathsFull;
- extracter.WildcardCensor = &wildcardCensor;
- extracter.Options = &options;
- #ifndef _SFX
- extracter.HashBundle = hb;
- #endif
-
- extracter.IconID = IDI_ICON;
-
- RINOK(extracter.Create(title, hwndParent));
- messageWasDisplayed = extracter.ThreadFinishedOK && extracter.MessagesDisplayed;
- return extracter.Result;
-}
+// ExtractGUI.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileFind.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Thread.h"
+
+#include "../FileManager/ExtractCallback.h"
+#include "../FileManager/FormatUtils.h"
+#include "../FileManager/LangUtils.h"
+#include "../FileManager/resourceGui.h"
+#include "../FileManager/OverwriteDialogRes.h"
+
+#include "../Common/ArchiveExtractCallback.h"
+#include "../Common/PropIDUtils.h"
+
+#include "../Explorer/MyMessages.h"
+
+#include "resource2.h"
+#include "ExtractRes.h"
+
+#include "ExtractDialog.h"
+#include "ExtractGUI.h"
+#include "HashGUI.h"
+
+#include "../FileManager/PropertyNameRes.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static const wchar_t * const kIncorrectOutDir = L"Incorrect output directory path";
+
+#ifndef Z7_SFX
+
+static void AddValuePair(UString &s, UINT resourceID, UInt64 value, bool addColon = true)
+{
+ AddLangString(s, resourceID);
+ if (addColon)
+ s += ':';
+ s.Add_Space();
+ s.Add_UInt64(value);
+ s.Add_LF();
+}
+
+static void AddSizePair(UString &s, UINT resourceID, UInt64 value)
+{
+ AddLangString(s, resourceID);
+ s += ": ";
+ AddSizeValue(s, value);
+ s.Add_LF();
+}
+
+#endif
+
+class CThreadExtracting: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt() Z7_override;
+public:
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ const CExternalCodecs *externalCodecs;
+ #endif
+ */
+
+ CCodecs *codecs;
+ CExtractCallbackImp *ExtractCallbackSpec;
+ const CObjectVector<COpenType> *FormatIndices;
+ const CIntVector *ExcludedFormatIndices;
+
+ UStringVector *ArchivePaths;
+ UStringVector *ArchivePathsFull;
+ const NWildcard::CCensorNode *WildcardCensor;
+ const CExtractOptions *Options;
+
+ #ifndef Z7_SFX
+ CHashBundle *HashBundle;
+ virtual void ProcessWasFinished_GuiVirt() Z7_override;
+ #endif
+
+ CMyComPtr<IFolderArchiveExtractCallback> FolderArchiveExtractCallback;
+ UString Title;
+
+ CPropNameValPairs Pairs;
+};
+
+
+#ifndef Z7_SFX
+void CThreadExtracting::ProcessWasFinished_GuiVirt()
+{
+ if (HashBundle && !Pairs.IsEmpty())
+ ShowHashResults(Pairs, *this);
+}
+#endif
+
+HRESULT CThreadExtracting::ProcessVirt()
+{
+ CDecompressStat Stat;
+
+ #ifndef Z7_SFX
+ /*
+ if (HashBundle)
+ HashBundle->Init();
+ */
+ #endif
+
+ HRESULT res = Extract(
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ externalCodecs,
+ #endif
+ */
+ codecs,
+ *FormatIndices, *ExcludedFormatIndices,
+ *ArchivePaths, *ArchivePathsFull,
+ *WildcardCensor, *Options,
+ ExtractCallbackSpec, ExtractCallbackSpec, FolderArchiveExtractCallback,
+ #ifndef Z7_SFX
+ HashBundle,
+ #endif
+ FinalMessage.ErrorMessage.Message, Stat);
+
+ #ifndef Z7_SFX
+ if (res == S_OK && ExtractCallbackSpec->IsOK())
+ {
+ if (HashBundle)
+ {
+ AddValuePair(Pairs, IDS_ARCHIVES_COLON, Stat.NumArchives);
+ AddSizeValuePair(Pairs, IDS_PROP_PACKED_SIZE, Stat.PackSize);
+ AddHashBundleRes(Pairs, *HashBundle);
+ }
+ else if (Options->TestMode)
+ {
+ UString s;
+
+ AddValuePair(s, IDS_ARCHIVES_COLON, Stat.NumArchives, false);
+ AddSizePair(s, IDS_PROP_PACKED_SIZE, Stat.PackSize);
+
+ if (Stat.NumFolders != 0)
+ AddValuePair(s, IDS_PROP_FOLDERS, Stat.NumFolders);
+ AddValuePair(s, IDS_PROP_FILES, Stat.NumFiles);
+ AddSizePair(s, IDS_PROP_SIZE, Stat.UnpackSize);
+ if (Stat.NumAltStreams != 0)
+ {
+ s.Add_LF();
+ AddValuePair(s, IDS_PROP_NUM_ALT_STREAMS, Stat.NumAltStreams);
+ AddSizePair(s, IDS_PROP_ALT_STREAMS_SIZE, Stat.AltStreams_UnpackSize);
+ }
+ s.Add_LF();
+ AddLangString(s, IDS_MESSAGE_NO_ERRORS);
+ FinalMessage.OkMessage.Title = Title;
+ FinalMessage.OkMessage.Message = s;
+ }
+ }
+ #endif
+
+ return res;
+}
+
+
+
+HRESULT ExtractGUI(
+ // DECL_EXTERNAL_CODECS_LOC_VARS
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &formatIndices,
+ const CIntVector &excludedFormatIndices,
+ UStringVector &archivePaths,
+ UStringVector &archivePathsFull,
+ const NWildcard::CCensorNode &wildcardCensor,
+ CExtractOptions &options,
+ #ifndef Z7_SFX
+ CHashBundle *hb,
+ #endif
+ bool showDialog,
+ bool &messageWasDisplayed,
+ CExtractCallbackImp *extractCallback,
+ HWND hwndParent)
+{
+ messageWasDisplayed = false;
+
+ CThreadExtracting extracter;
+ /*
+ #ifdef Z7_EXTERNAL_CODECS
+ extracter.externalCodecs = _externalCodecs;
+ #endif
+ */
+ extracter.codecs = codecs;
+ extracter.FormatIndices = &formatIndices;
+ extracter.ExcludedFormatIndices = &excludedFormatIndices;
+
+ if (!options.TestMode)
+ {
+ FString outputDir = options.OutputDir;
+ #ifndef UNDER_CE
+ if (outputDir.IsEmpty())
+ GetCurrentDir(outputDir);
+ #endif
+ if (showDialog)
+ {
+ CExtractDialog dialog;
+ FString outputDirFull;
+ if (!MyGetFullPathName(outputDir, outputDirFull))
+ {
+ ShowErrorMessage(kIncorrectOutDir);
+ messageWasDisplayed = true;
+ return E_FAIL;
+ }
+ NName::NormalizeDirPathPrefix(outputDirFull);
+
+ dialog.DirPath = fs2us(outputDirFull);
+
+ dialog.OverwriteMode = options.OverwriteMode;
+ dialog.OverwriteMode_Force = options.OverwriteMode_Force;
+ dialog.PathMode = options.PathMode;
+ dialog.PathMode_Force = options.PathMode_Force;
+ dialog.ElimDup = options.ElimDup;
+
+ if (archivePathsFull.Size() == 1)
+ dialog.ArcPath = archivePathsFull[0];
+
+ #ifndef Z7_SFX
+ // dialog.AltStreams = options.NtOptions.AltStreams;
+ dialog.NtSecurity = options.NtOptions.NtSecurity;
+ if (extractCallback->PasswordIsDefined)
+ dialog.Password = extractCallback->Password;
+ #endif
+
+ if (dialog.Create(hwndParent) != IDOK)
+ return E_ABORT;
+
+ outputDir = us2fs(dialog.DirPath);
+
+ options.OverwriteMode = dialog.OverwriteMode;
+ options.PathMode = dialog.PathMode;
+ options.ElimDup = dialog.ElimDup;
+
+ #ifndef Z7_SFX
+ // options.NtOptions.AltStreams = dialog.AltStreams;
+ options.NtOptions.NtSecurity = dialog.NtSecurity;
+ extractCallback->Password = dialog.Password;
+ extractCallback->PasswordIsDefined = !dialog.Password.IsEmpty();
+ #endif
+ }
+ if (!MyGetFullPathName(outputDir, options.OutputDir))
+ {
+ ShowErrorMessage(kIncorrectOutDir);
+ messageWasDisplayed = true;
+ return E_FAIL;
+ }
+ NName::NormalizeDirPathPrefix(options.OutputDir);
+
+ /*
+ if (!CreateComplexDirectory(options.OutputDir))
+ {
+ UString s = GetUnicodeString(NError::MyFormatMessage(GetLastError()));
+ UString s2 = MyFormatNew(IDS_CANNOT_CREATE_FOLDER,
+ #ifdef Z7_LANG
+ 0x02000603,
+ #endif
+ options.OutputDir);
+ s2.Add_LF();
+ s2 += s;
+ MyMessageBox(s2);
+ return E_FAIL;
+ }
+ */
+ }
+
+ UString title = LangString(options.TestMode ? IDS_PROGRESS_TESTING : IDS_PROGRESS_EXTRACTING);
+
+ extracter.Title = title;
+ extracter.ExtractCallbackSpec = extractCallback;
+ extracter.ExtractCallbackSpec->ProgressDialog = &extracter;
+ extracter.FolderArchiveExtractCallback = extractCallback;
+ extracter.ExtractCallbackSpec->Init();
+
+ extracter.CompressingMode = false;
+
+ extracter.ArchivePaths = &archivePaths;
+ extracter.ArchivePathsFull = &archivePathsFull;
+ extracter.WildcardCensor = &wildcardCensor;
+ extracter.Options = &options;
+ #ifndef Z7_SFX
+ extracter.HashBundle = hb;
+ #endif
+
+ extracter.IconID = IDI_ICON;
+
+ RINOK(extracter.Create(title, hwndParent))
+ messageWasDisplayed = extracter.ThreadFinishedOK && extracter.MessagesDisplayed;
+ return extracter.Result;
+}
diff --git a/CPP/7zip/UI/GUI/ExtractGUI.h b/CPP/7zip/UI/GUI/ExtractGUI.h
index 466e524..13ca6ab 100644
--- a/CPP/7zip/UI/GUI/ExtractGUI.h
+++ b/CPP/7zip/UI/GUI/ExtractGUI.h
@@ -1,38 +1,39 @@
-// GUI/ExtractGUI.h
-
-#ifndef __EXTRACT_GUI_H
-#define __EXTRACT_GUI_H
-
-#include "../Common/Extract.h"
-
-#include "../FileManager/ExtractCallback.h"
-
-/*
- RESULT can be S_OK, even if there are errors!!!
- if RESULT == S_OK, check extractCallback->IsOK() after ExtractGUI().
-
- RESULT = E_ABORT - user break.
- RESULT != E_ABORT:
- {
- messageWasDisplayed = true - message was displayed already.
- messageWasDisplayed = false - there was some internal error, so you must show error message.
- }
-*/
-
-HRESULT ExtractGUI(
- CCodecs *codecs,
- const CObjectVector<COpenType> &formatIndices,
- const CIntVector &excludedFormatIndices,
- UStringVector &archivePaths,
- UStringVector &archivePathsFull,
- const NWildcard::CCensorNode &wildcardCensor,
- CExtractOptions &options,
- #ifndef _SFX
- CHashBundle *hb,
- #endif
- bool showDialog,
- bool &messageWasDisplayed,
- CExtractCallbackImp *extractCallback,
- HWND hwndParent = NULL);
-
-#endif
+// GUI/ExtractGUI.h
+
+#ifndef ZIP7_INC_EXTRACT_GUI_H
+#define ZIP7_INC_EXTRACT_GUI_H
+
+#include "../Common/Extract.h"
+
+#include "../FileManager/ExtractCallback.h"
+
+/*
+ RESULT can be S_OK, even if there are errors!!!
+ if RESULT == S_OK, check extractCallback->IsOK() after ExtractGUI().
+
+ RESULT = E_ABORT - user break.
+ RESULT != E_ABORT:
+ {
+ messageWasDisplayed = true - message was displayed already.
+ messageWasDisplayed = false - there was some internal error, so you must show error message.
+ }
+*/
+
+HRESULT ExtractGUI(
+ // DECL_EXTERNAL_CODECS_LOC_VARS
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &formatIndices,
+ const CIntVector &excludedFormatIndices,
+ UStringVector &archivePaths,
+ UStringVector &archivePathsFull,
+ const NWildcard::CCensorNode &wildcardCensor,
+ CExtractOptions &options,
+ #ifndef Z7_SFX
+ CHashBundle *hb,
+ #endif
+ bool showDialog,
+ bool &messageWasDisplayed,
+ CExtractCallbackImp *extractCallback,
+ HWND hwndParent = NULL);
+
+#endif
diff --git a/CPP/7zip/UI/GUI/ExtractRes.h b/CPP/7zip/UI/GUI/ExtractRes.h
index 6437d95..634ba6b 100644
--- a/CPP/7zip/UI/GUI/ExtractRes.h
+++ b/CPP/7zip/UI/GUI/ExtractRes.h
@@ -1,51 +1,51 @@
-#define IDS_MEM_ERROR 3000
-
-#define IDS_CANNOT_CREATE_FOLDER 3003
-#define IDS_UPDATE_NOT_SUPPORTED 3004
-#define IDS_CANT_OPEN_ARCHIVE 3005
-#define IDS_CANT_OPEN_ENCRYPTED_ARCHIVE 3006
-#define IDS_UNSUPPORTED_ARCHIVE_TYPE 3007
-
-#define IDS_CANT_OPEN_AS_TYPE 3017
-#define IDS_IS_OPEN_AS_TYPE 3018
-#define IDS_IS_OPEN_WITH_OFFSET 3019
-
-#define IDS_PROGRESS_EXTRACTING 3300
-
-#define IDS_PROGRESS_SKIPPING 3325
-
-#define IDS_EXTRACT_SET_FOLDER 3402
-
-#define IDS_EXTRACT_PATHS_FULL 3411
-#define IDS_EXTRACT_PATHS_NO 3412
-#define IDS_EXTRACT_PATHS_ABS 3413
-#define IDS_PATH_MODE_RELAT 3414
-
-#define IDS_EXTRACT_OVERWRITE_ASK 3421
-#define IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT 3422
-#define IDS_EXTRACT_OVERWRITE_SKIP_EXISTING 3423
-#define IDS_EXTRACT_OVERWRITE_RENAME 3424
-#define IDS_EXTRACT_OVERWRITE_RENAME_EXISTING 3425
-
-#define IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD 3700
-#define IDS_EXTRACT_MESSAGE_DATA_ERROR 3701
-#define IDS_EXTRACT_MESSAGE_CRC_ERROR 3702
-#define IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED 3703
-#define IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED 3704
-
-#define IDS_EXTRACT_MSG_WRONG_PSW_GUESS 3710
-// #define IDS_EXTRACT_MSG_ENCRYPTED 3711
-
-#define IDS_EXTRACT_MSG_UNSUPPORTED_METHOD 3721
-#define IDS_EXTRACT_MSG_DATA_ERROR 3722
-#define IDS_EXTRACT_MSG_CRC_ERROR 3723
-#define IDS_EXTRACT_MSG_UNAVAILABLE_DATA 3724
-#define IDS_EXTRACT_MSG_UEXPECTED_END 3725
-#define IDS_EXTRACT_MSG_DATA_AFTER_END 3726
-#define IDS_EXTRACT_MSG_IS_NOT_ARC 3727
-#define IDS_EXTRACT_MSG_HEADERS_ERROR 3728
-#define IDS_EXTRACT_MSG_WRONG_PSW_CLAIM 3729
-
-#define IDS_OPEN_MSG_UNAVAILABLE_START 3763
-#define IDS_OPEN_MSG_UNCONFIRMED_START 3764
-#define IDS_OPEN_MSG_UNSUPPORTED_FEATURE 3768
+#define IDS_MEM_ERROR 3000
+
+#define IDS_CANNOT_CREATE_FOLDER 3003
+#define IDS_UPDATE_NOT_SUPPORTED 3004
+#define IDS_CANT_OPEN_ARCHIVE 3005
+#define IDS_CANT_OPEN_ENCRYPTED_ARCHIVE 3006
+#define IDS_UNSUPPORTED_ARCHIVE_TYPE 3007
+
+#define IDS_CANT_OPEN_AS_TYPE 3017
+#define IDS_IS_OPEN_AS_TYPE 3018
+#define IDS_IS_OPEN_WITH_OFFSET 3019
+
+#define IDS_PROGRESS_EXTRACTING 3300
+
+#define IDS_PROGRESS_SKIPPING 3325
+
+#define IDS_EXTRACT_SET_FOLDER 3402
+
+#define IDS_EXTRACT_PATHS_FULL 3411
+#define IDS_EXTRACT_PATHS_NO 3412
+#define IDS_EXTRACT_PATHS_ABS 3413
+#define IDS_PATH_MODE_RELAT 3414
+
+#define IDS_EXTRACT_OVERWRITE_ASK 3421
+#define IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT 3422
+#define IDS_EXTRACT_OVERWRITE_SKIP_EXISTING 3423
+#define IDS_EXTRACT_OVERWRITE_RENAME 3424
+#define IDS_EXTRACT_OVERWRITE_RENAME_EXISTING 3425
+
+#define IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD 3700
+#define IDS_EXTRACT_MESSAGE_DATA_ERROR 3701
+#define IDS_EXTRACT_MESSAGE_CRC_ERROR 3702
+#define IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED 3703
+#define IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED 3704
+
+#define IDS_EXTRACT_MSG_WRONG_PSW_GUESS 3710
+// #define IDS_EXTRACT_MSG_ENCRYPTED 3711
+
+#define IDS_EXTRACT_MSG_UNSUPPORTED_METHOD 3721
+#define IDS_EXTRACT_MSG_DATA_ERROR 3722
+#define IDS_EXTRACT_MSG_CRC_ERROR 3723
+#define IDS_EXTRACT_MSG_UNAVAILABLE_DATA 3724
+#define IDS_EXTRACT_MSG_UEXPECTED_END 3725
+#define IDS_EXTRACT_MSG_DATA_AFTER_END 3726
+#define IDS_EXTRACT_MSG_IS_NOT_ARC 3727
+#define IDS_EXTRACT_MSG_HEADERS_ERROR 3728
+#define IDS_EXTRACT_MSG_WRONG_PSW_CLAIM 3729
+
+#define IDS_OPEN_MSG_UNAVAILABLE_START 3763
+#define IDS_OPEN_MSG_UNCONFIRMED_START 3764
+#define IDS_OPEN_MSG_UNSUPPORTED_FEATURE 3768
diff --git a/CPP/7zip/UI/GUI/FM.ico b/CPP/7zip/UI/GUI/FM.ico
new file mode 100644
index 0000000..3a0a34d
--- /dev/null
+++ b/CPP/7zip/UI/GUI/FM.ico
Binary files differ
diff --git a/CPP/7zip/UI/GUI/GUI.cpp b/CPP/7zip/UI/GUI/GUI.cpp
new file mode 100644
index 0000000..37e637b
--- /dev/null
+++ b/CPP/7zip/UI/GUI/GUI.cpp
@@ -0,0 +1,478 @@
+// GUI.cpp
+
+#include "StdAfx.h"
+
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
+
+#include "../../../Common/MyWindows.h"
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlwapi.h>
+#else
+#include <Shlwapi.h>
+#endif
+
+#include "../../../Common/MyInitGuid.h"
+
+#include "../../../Common/CommandLineParser.h"
+#include "../../../Common/MyException.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/NtCheck.h"
+
+#include "../Common/ArchiveCommandLine.h"
+#include "../Common/ExitCode.h"
+
+#include "../FileManager/StringUtils.h"
+#include "../FileManager/LangUtils.h"
+
+#include "BenchmarkDialog.h"
+#include "ExtractGUI.h"
+#include "HashGUI.h"
+#include "UpdateGUI.h"
+
+#include "ExtractRes.h"
+
+using namespace NWindows;
+
+#ifdef Z7_EXTERNAL_CODECS
+extern
+const CExternalCodecs *g_ExternalCodecs_Ptr;
+const CExternalCodecs *g_ExternalCodecs_Ptr;
+#endif
+
+extern
+HINSTANCE g_hInstance;
+HINSTANCE g_hInstance;
+
+#ifndef UNDER_CE
+
+extern
+DWORD g_ComCtl32Version;
+DWORD g_ComCtl32Version;
+
+static DWORD GetDllVersion(LPCTSTR dllName)
+{
+ DWORD dwVersion = 0;
+ const HMODULE hmodule = LoadLibrary(dllName);
+ if (hmodule)
+ {
+ const
+ DLLGETVERSIONPROC f_DllGetVersion = Z7_GET_PROC_ADDRESS(
+ DLLGETVERSIONPROC, hmodule,
+ "DllGetVersion");
+ if (f_DllGetVersion)
+ {
+ DLLVERSIONINFO dvi;
+ ZeroMemory(&dvi, sizeof(dvi));
+ dvi.cbSize = sizeof(dvi);
+ const HRESULT hr = (*f_DllGetVersion)(&dvi);
+ if (SUCCEEDED(hr))
+ dwVersion = (DWORD)MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
+ }
+ FreeLibrary(hmodule);
+ }
+ return dwVersion;
+}
+
+#endif
+
+extern
+bool g_LVN_ITEMACTIVATE_Support;
+bool g_LVN_ITEMACTIVATE_Support = true;
+
+DECLARE_AND_SET_CLIENT_VERSION_VAR
+
+static void ErrorMessage(LPCWSTR message)
+{
+ MessageBoxW(NULL, message, L"7-Zip", MB_ICONERROR | MB_OK);
+}
+
+static void ErrorMessage(const char *s)
+{
+ ErrorMessage(GetUnicodeString(s));
+}
+
+static void ErrorLangMessage(UINT resourceID)
+{
+ ErrorMessage(LangString(resourceID));
+}
+
+static const char * const kNoFormats = "7-Zip cannot find the code that works with archives.";
+
+static int ShowMemErrorMessage()
+{
+ ErrorLangMessage(IDS_MEM_ERROR);
+ return NExitCode::kMemoryError;
+}
+
+static int ShowSysErrorMessage(HRESULT errorCode)
+{
+ if (errorCode == E_OUTOFMEMORY)
+ return ShowMemErrorMessage();
+ ErrorMessage(HResultToMessage(errorCode));
+ return NExitCode::kFatalError;
+}
+
+static void ThrowException_if_Error(HRESULT res)
+{
+ if (res != S_OK)
+ throw CSystemException(res);
+}
+
+static int Main2()
+{
+ UStringVector commandStrings;
+ NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
+
+ #ifndef UNDER_CE
+ if (commandStrings.Size() > 0)
+ commandStrings.Delete(0);
+ #endif
+ if (commandStrings.Size() == 0)
+ {
+ MessageBoxW(NULL, L"Specify command", L"7-Zip", 0);
+ return 0;
+ }
+
+ CArcCmdLineOptions options;
+ CArcCmdLineParser parser;
+
+ parser.Parse1(commandStrings, options);
+ parser.Parse2(options);
+
+ CREATE_CODECS_OBJECT
+
+ codecs->CaseSensitive_Change = options.CaseSensitive_Change;
+ codecs->CaseSensitive = options.CaseSensitive;
+ ThrowException_if_Error(codecs->Load());
+ Codecs_AddHashArcHandler(codecs);
+
+ #ifdef Z7_EXTERNAL_CODECS
+ {
+ g_ExternalCodecs_Ptr = &_externalCodecs;
+ UString s;
+ codecs->GetCodecsErrorMessage(s);
+ if (!s.IsEmpty())
+ {
+ MessageBoxW(NULL, s, L"7-Zip", MB_ICONERROR);
+ }
+
+ }
+ #endif
+
+ const bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
+
+ if (codecs->Formats.Size() == 0 &&
+ (isExtractGroupCommand
+
+ || options.Command.IsFromUpdateGroup()))
+ {
+ #ifdef Z7_EXTERNAL_CODECS
+ if (!codecs->MainDll_ErrorPath.IsEmpty())
+ {
+ UString s ("7-Zip cannot load module: ");
+ s += fs2us(codecs->MainDll_ErrorPath);
+ throw s;
+ }
+ #endif
+ throw kNoFormats;
+ }
+
+ CObjectVector<COpenType> formatIndices;
+ if (!ParseOpenTypes(*codecs, options.ArcType, formatIndices))
+ {
+ ErrorLangMessage(IDS_UNSUPPORTED_ARCHIVE_TYPE);
+ return NExitCode::kFatalError;
+ }
+
+ CIntVector excludedFormats;
+ FOR_VECTOR (k, options.ExcludedArcTypes)
+ {
+ CIntVector tempIndices;
+ if (!codecs->FindFormatForArchiveType(options.ExcludedArcTypes[k], tempIndices)
+ || tempIndices.Size() != 1)
+ {
+ ErrorLangMessage(IDS_UNSUPPORTED_ARCHIVE_TYPE);
+ return NExitCode::kFatalError;
+ }
+ excludedFormats.AddToUniqueSorted(tempIndices[0]);
+ // excludedFormats.Sort();
+ }
+
+ #ifdef Z7_EXTERNAL_CODECS
+ if (isExtractGroupCommand
+ || options.Command.IsFromUpdateGroup()
+ || options.Command.CommandType == NCommandType::kHash
+ || options.Command.CommandType == NCommandType::kBenchmark)
+ ThrowException_if_Error(_externalCodecs.Load());
+ #endif
+
+ if (options.Command.CommandType == NCommandType::kBenchmark)
+ {
+ HRESULT res = Benchmark(
+ EXTERNAL_CODECS_VARS_L
+ options.Properties,
+ options.NumIterations_Defined ?
+ options.NumIterations :
+ k_NumBenchIterations_Default);
+ /*
+ if (res == S_FALSE)
+ {
+ stdStream << "\nDecoding Error\n";
+ return NExitCode::kFatalError;
+ }
+ */
+ ThrowException_if_Error(res);
+ }
+ else if (isExtractGroupCommand)
+ {
+ UStringVector ArchivePathsSorted;
+ UStringVector ArchivePathsFullSorted;
+
+ CExtractCallbackImp *ecs = new CExtractCallbackImp;
+ CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
+
+ #ifndef Z7_NO_CRYPTO
+ ecs->PasswordIsDefined = options.PasswordEnabled;
+ ecs->Password = options.Password;
+ #endif
+
+ ecs->Init();
+
+ CExtractOptions eo;
+ (CExtractOptionsBase &)eo = options.ExtractOptions;
+ eo.StdInMode = options.StdInMode;
+ eo.StdOutMode = options.StdOutMode;
+ eo.YesToAll = options.YesToAll;
+ eo.TestMode = options.Command.IsTestCommand();
+
+ #ifndef Z7_SFX
+ eo.Properties = options.Properties;
+ #endif
+
+ bool messageWasDisplayed = false;
+
+ #ifndef Z7_SFX
+ CHashBundle hb;
+ CHashBundle *hb_ptr = NULL;
+
+ if (!options.HashMethods.IsEmpty())
+ {
+ hb_ptr = &hb;
+ ThrowException_if_Error(hb.SetMethods(EXTERNAL_CODECS_VARS_L options.HashMethods));
+ }
+ #endif
+
+ {
+ CDirItemsStat st;
+ HRESULT hresultMain = EnumerateDirItemsAndSort(
+ options.arcCensor,
+ NWildcard::k_RelatPath,
+ UString(), // addPathPrefix
+ ArchivePathsSorted,
+ ArchivePathsFullSorted,
+ st,
+ NULL // &scan: change it!!!!
+ );
+ if (hresultMain != S_OK)
+ {
+ /*
+ if (hresultMain != E_ABORT && messageWasDisplayed)
+ return NExitCode::kFatalError;
+ */
+ throw CSystemException(hresultMain);
+ }
+ }
+
+ ecs->MultiArcMode = (ArchivePathsSorted.Size() > 1);
+
+ HRESULT result = ExtractGUI(
+ // EXTERNAL_CODECS_VARS_L
+ codecs,
+ formatIndices, excludedFormats,
+ ArchivePathsSorted,
+ ArchivePathsFullSorted,
+ options.Censor.Pairs.Front().Head,
+ eo,
+ #ifndef Z7_SFX
+ hb_ptr,
+ #endif
+ options.ShowDialog, messageWasDisplayed, ecs);
+ if (result != S_OK)
+ {
+ if (result != E_ABORT && messageWasDisplayed)
+ return NExitCode::kFatalError;
+ throw CSystemException(result);
+ }
+ if (!ecs->IsOK())
+ return NExitCode::kFatalError;
+ }
+ else if (options.Command.IsFromUpdateGroup())
+ {
+ #ifndef Z7_NO_CRYPTO
+ bool passwordIsDefined = options.PasswordEnabled && !options.Password.IsEmpty();
+ #endif
+
+ CUpdateCallbackGUI callback;
+ // callback.EnablePercents = options.EnablePercents;
+
+ #ifndef Z7_NO_CRYPTO
+ callback.PasswordIsDefined = passwordIsDefined;
+ callback.AskPassword = options.PasswordEnabled && options.Password.IsEmpty();
+ callback.Password = options.Password;
+ #endif
+
+ // callback.StdOutMode = options.UpdateOptions.StdOutMode;
+ callback.Init();
+
+ if (!options.UpdateOptions.InitFormatIndex(codecs, formatIndices, options.ArchiveName) ||
+ !options.UpdateOptions.SetArcPath(codecs, options.ArchiveName))
+ {
+ ErrorLangMessage(IDS_UPDATE_NOT_SUPPORTED);
+ return NExitCode::kFatalError;
+ }
+ bool messageWasDisplayed = false;
+ HRESULT result = UpdateGUI(
+ codecs, formatIndices,
+ options.ArchiveName,
+ options.Censor,
+ options.UpdateOptions,
+ options.ShowDialog,
+ messageWasDisplayed,
+ &callback);
+
+ if (result != S_OK)
+ {
+ if (result != E_ABORT && messageWasDisplayed)
+ return NExitCode::kFatalError;
+ throw CSystemException(result);
+ }
+ if (callback.FailedFiles.Size() > 0)
+ {
+ if (!messageWasDisplayed)
+ throw CSystemException(E_FAIL);
+ return NExitCode::kWarning;
+ }
+ }
+ else if (options.Command.CommandType == NCommandType::kHash)
+ {
+ bool messageWasDisplayed = false;
+ HRESULT result = HashCalcGUI(EXTERNAL_CODECS_VARS_L
+ options.Censor, options.HashOptions, messageWasDisplayed);
+
+ if (result != S_OK)
+ {
+ if (result != E_ABORT && messageWasDisplayed)
+ return NExitCode::kFatalError;
+ throw CSystemException(result);
+ }
+ /*
+ if (callback.FailedFiles.Size() > 0)
+ {
+ if (!messageWasDisplayed)
+ throw CSystemException(E_FAIL);
+ return NExitCode::kWarning;
+ }
+ */
+ }
+ else
+ {
+ throw "Unsupported command";
+ }
+ return 0;
+}
+
+#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
+#define NT_CHECK_FAIL_ACTION ErrorMessage("Unsupported Windows version"); return NExitCode::kFatalError;
+#endif
+
+int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
+ #ifdef UNDER_CE
+ LPWSTR
+ #else
+ LPSTR
+ #endif
+ /* lpCmdLine */, int /* nCmdShow */)
+{
+ g_hInstance = hInstance;
+
+ #ifdef _WIN32
+ NT_CHECK
+ #endif
+
+ InitCommonControls();
+
+ #ifndef UNDER_CE
+ g_ComCtl32Version = ::GetDllVersion(TEXT("comctl32.dll"));
+ g_LVN_ITEMACTIVATE_Support = (g_ComCtl32Version >= MAKELONG(71, 4));
+ #endif
+
+ // OleInitialize is required for ProgressBar in TaskBar.
+ #ifndef UNDER_CE
+ OleInitialize(NULL);
+ #endif
+
+ #ifdef Z7_LANG
+ LoadLangOneTime();
+ #endif
+
+ // setlocale(LC_COLLATE, ".ACP");
+ try
+ {
+ #ifdef _WIN32
+ My_SetDefaultDllDirectories();
+ #endif
+
+ return Main2();
+ }
+ catch(const CNewException &)
+ {
+ return ShowMemErrorMessage();
+ }
+ catch(const CMessagePathException &e)
+ {
+ ErrorMessage(e);
+ return NExitCode::kUserError;
+ }
+ catch(const CSystemException &systemError)
+ {
+ if (systemError.ErrorCode == E_ABORT)
+ return NExitCode::kUserBreak;
+ return ShowSysErrorMessage(systemError.ErrorCode);
+ }
+ catch(const UString &s)
+ {
+ ErrorMessage(s);
+ return NExitCode::kFatalError;
+ }
+ catch(const AString &s)
+ {
+ ErrorMessage(s);
+ return NExitCode::kFatalError;
+ }
+ catch(const wchar_t *s)
+ {
+ ErrorMessage(s);
+ return NExitCode::kFatalError;
+ }
+ catch(const char *s)
+ {
+ ErrorMessage(s);
+ return NExitCode::kFatalError;
+ }
+ catch(int v)
+ {
+ AString e ("Error: ");
+ e.Add_UInt32((unsigned)v);
+ ErrorMessage(e);
+ return NExitCode::kFatalError;
+ }
+ catch(...)
+ {
+ ErrorMessage("Unknown error");
+ return NExitCode::kFatalError;
+ }
+}
diff --git a/CPP/7zip/UI/GUI/GUI.dsp b/CPP/7zip/UI/GUI/GUI.dsp
new file mode 100644
index 0000000..3a6b60f
--- /dev/null
+++ b/CPP/7zip/UI/GUI/GUI.dsp
@@ -0,0 +1,1259 @@
+# Microsoft Developer Studio Project File - Name="GUI" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Application" 0x0101
+
+CFG=GUI - Win32 DebugU
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "GUI.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "GUI.mak" CFG="GUI - Win32 DebugU"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "GUI - Win32 Release" (based on "Win32 (x86) Application")
+!MESSAGE "GUI - Win32 Debug" (based on "Win32 (x86) Application")
+!MESSAGE "GUI - Win32 ReleaseU" (based on "Win32 (x86) Application")
+!MESSAGE "GUI - Win32 DebugU" (based on "Win32 (x86) Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "GUI - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /D "Z7_LARGE_PAGES" /FAcs /Yu"stdafx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zg.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "GUI - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /Gr /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_MBCS" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /D "Z7_LARGE_PAGES" /Yu"stdafx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zg.exe" /pdbtype:sept
+
+!ELSEIF "$(CFG)" == "GUI - Win32 ReleaseU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ReleaseU"
+# PROP BASE Intermediate_Dir "ReleaseU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ReleaseU"
+# PROP Intermediate_Dir "ReleaseU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /Gr /MD /W4 /WX /GX /O1 /D "NDEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /D "Z7_LARGE_PAGES" /Yu"stdafx.h" /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "NDEBUG"
+# ADD RSC /l 0x419 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 /out:"C:\UTIL\7zg.exe"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /subsystem:windows /machine:I386 /out:"C:\Util\7zg.exe" /opt:NOWIN98
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF "$(CFG)" == "GUI - Win32 DebugU"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugU"
+# PROP BASE Intermediate_Dir "DebugU"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugU"
+# PROP Intermediate_Dir "DebugU"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /Gr /MDd /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_WINDOWS" /D "Z7_LANG" /D "Z7_LONG_PATH" /D "Z7_EXTERNAL_CODECS" /D "Z7_DEVICE_FILE" /D "Z7_LARGE_PAGES" /Yu"stdafx.h" /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x419 /d "_DEBUG"
+# ADD RSC /l 0x419 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\UTIL\7zg.exe" /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib comctl32.lib htmlhelp.lib /nologo /subsystem:windows /debug /machine:I386 /out:"C:\Util\7zg.exe" /pdbtype:sept
+
+!ENDIF
+
+# Begin Target
+
+# Name "GUI - Win32 Release"
+# Name "GUI - Win32 Debug"
+# Name "GUI - Win32 ReleaseU"
+# Name "GUI - Win32 DebugU"
+# Begin Group "Spec"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\7zG.exe.manifest
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractRes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\FM.ico
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.rc
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.cpp
+# ADD CPP /Yc"stdafx.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\StdAfx.h
+# End Source File
+# End Group
+# Begin Group "UI Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Common\ArchiveCommandLine.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveCommandLine.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ArchiveOpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Bench.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Bench.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DefaultName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\DirItem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\EnumDirItems.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExitCode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Extract.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Extract.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractingFilePath.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ExtractMode.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\HashCalc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\IFileExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\LoadCodecs.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\OpenArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Property.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\PropIDUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SetProperties.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\SortUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\TempFiles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\TempFiles.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Update.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\Update.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateAction.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdatePair.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\UpdateProduce.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\WorkDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Common\ZipRegistry.h
+# End Source File
+# End Group
+# Begin Group "Explorer"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\Explorer\MyMessages.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\Explorer\MyMessages.h
+# End Source File
+# End Group
+# Begin Group "Dialogs"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\BenchmarkDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BenchmarkDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\BrowseDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\BrowseDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ComboDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ComboDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\CompressDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\CompressDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\EditDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\EditDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ListViewDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ListViewDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\OverwriteDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\OverwriteDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\PasswordDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\PasswordDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ProgressDialog2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ProgressDialog2.h
+# End Source File
+# End Group
+# Begin Group "FM Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\FileManager\ExtractCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ExtractCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\FormatUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\FormatUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\HelpUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\HelpUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\LangUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\LangUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\OpenCallback.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\OpenCallback.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ProgramLocation.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\ProgramLocation.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\PropertyName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\PropertyName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\RegistryUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\RegistryUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\SplitUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\SplitUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\StringUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\StringUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\SysIconUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\FileManager\SysIconUtils.h
+# End Source File
+# End Group
+# Begin Group "Engine"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ExtractGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ExtractGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\GUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\HashGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\HashGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackGUI.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackGUI2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateCallbackGUI2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateGUI.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\UpdateGUI.h
+# End Source File
+# End Group
+# Begin Group "7-zip Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\CreateCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilePathAutoRename.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FileStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\FilterCoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\LimitedStreams.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MethodProps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\MultiOutStream.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\ProgressUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\PropId.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamObjects.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\StreamUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Common\UniqBlocks.h
+# End Source File
+# End Group
+# Begin Group "Compress"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Compress\CopyCoder.h
+# End Source File
+# End Group
+# Begin Group "C"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.c
+
+!IF "$(CFG)" == "GUI - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zCrcOpt.c
+
+!IF "$(CFG)" == "GUI - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zTypes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\7zWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Alloc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.c
+
+!IF "$(CFG)" == "GUI - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.c
+
+!IF "$(CFG)" == "GUI - Win32 Release"
+
+# ADD CPP /O2
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 Debug"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 ReleaseU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ELSEIF "$(CFG)" == "GUI - Win32 DebugU"
+
+# SUBTRACT CPP /YX /Yc /Yu
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Sort.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Threads.h
+# End Source File
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CommandLineParser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Common.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\Compiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\CRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\DynLimBuf.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\IntToString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Lang.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\ListFileUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyBuffer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyVector.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\MyWindows.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\NewHandler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\StringToInt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\UTFConvert.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Common\Wildcard.h
+# End Source File
+# End Group
+# Begin Group "Windows"
+
+# PROP Default_Filter ""
+# Begin Group "Control"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ComboBox.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Edit.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ListView.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\ProgressBar.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Control\Static.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Clipboard.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\COM.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\CommonDialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\DLL.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ErrorMsg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileDir.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileFind.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileIO.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileLink.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileMapping.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileName.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\FileSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryGlobal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\MemoryLock.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariant.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\PropVariantConv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Registry.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\ResourceString.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Shell.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Synchronization.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\System.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\SystemInfo.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Thread.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\TimeUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\Windows\Window.h
+# End Source File
+# End Group
+# Begin Group "Archive Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\ItemNameUtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\Archive\Common\OutStreamWithCRC.h
+# End Source File
+# End Group
+# Begin Group "7-Zip"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\Archive\IArchive.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\ICoder.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IDecl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\IStream.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/CPP/7zip/UI/GUI/GUI.dsw b/CPP/7zip/UI/GUI/GUI.dsw
new file mode 100644
index 0000000..85d3348
--- /dev/null
+++ b/CPP/7zip/UI/GUI/GUI.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "GUI"=.\GUI.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/CPP/7zip/UI/GUI/HashGUI.cpp b/CPP/7zip/UI/GUI/HashGUI.cpp
new file mode 100644
index 0000000..b96e413
--- /dev/null
+++ b/CPP/7zip/UI/GUI/HashGUI.cpp
@@ -0,0 +1,363 @@
+// HashGUI.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/ErrorMsg.h"
+
+#include "../FileManager/FormatUtils.h"
+#include "../FileManager/LangUtils.h"
+#include "../FileManager/ListViewDialog.h"
+#include "../FileManager/OverwriteDialogRes.h"
+#include "../FileManager/ProgressDialog2.h"
+#include "../FileManager/ProgressDialog2Res.h"
+#include "../FileManager/PropertyNameRes.h"
+#include "../FileManager/resourceGui.h"
+
+#include "HashGUI.h"
+
+using namespace NWindows;
+
+
+
+class CHashCallbackGUI Z7_final: public CProgressThreadVirt, public IHashCallbackUI
+{
+ UInt64 NumFiles;
+ bool _curIsFolder;
+ UString FirstFileName;
+ // UString MainPath;
+
+ CPropNameValPairs PropNameValPairs;
+
+ HRESULT ProcessVirt() Z7_override;
+ virtual void ProcessWasFinished_GuiVirt() Z7_override;
+
+public:
+ const NWildcard::CCensor *censor;
+ const CHashOptions *options;
+
+ DECL_EXTERNAL_CODECS_LOC_VARS_DECL
+
+ Z7_IFACE_IMP(IDirItemsCallback)
+ Z7_IFACE_IMP(IHashCallbackUI)
+
+ /*
+ void AddErrorMessage(DWORD systemError, const wchar_t *name)
+ {
+ Sync.AddError_Code_Name(systemError, name);
+ }
+ */
+ void AddErrorMessage(HRESULT systemError, const wchar_t *name)
+ {
+ Sync.AddError_Code_Name(systemError, name);
+ }
+};
+
+
+void AddValuePair(CPropNameValPairs &pairs, UINT resourceID, UInt64 value)
+{
+ CProperty &pair = pairs.AddNew();
+ AddLangString(pair.Name, resourceID);
+ char sz[32];
+ ConvertUInt64ToString(value, sz);
+ pair.Value = sz;
+}
+
+
+void AddSizeValue(UString &s, UInt64 value)
+{
+ {
+ wchar_t sz[32];
+ ConvertUInt64ToString(value, sz);
+ s += MyFormatNew(IDS_FILE_SIZE, sz);
+ }
+ if (value >= (1 << 10))
+ {
+ char c;
+ if (value >= ((UInt64)10 << 30)) { value >>= 30; c = 'G'; }
+ else if (value >= (10 << 20)) { value >>= 20; c = 'M'; }
+ else { value >>= 10; c = 'K'; }
+
+ s += " (";
+ s.Add_UInt64(value);
+ s.Add_Space();
+ s += (wchar_t)c;
+ s += "iB)";
+ }
+}
+
+void AddSizeValuePair(CPropNameValPairs &pairs, UINT resourceID, UInt64 value)
+{
+ CProperty &pair = pairs.AddNew();
+ LangString(resourceID, pair.Name);
+ AddSizeValue(pair.Value, value);
+}
+
+
+HRESULT CHashCallbackGUI::StartScanning()
+{
+ CProgressSync &sync = Sync;
+ sync.Set_Status(LangString(IDS_SCANNING));
+ return CheckBreak();
+}
+
+HRESULT CHashCallbackGUI::ScanProgress(const CDirItemsStat &st, const FString &path, bool isDir)
+{
+ return Sync.ScanProgress(st.NumFiles, st.GetTotalBytes(), path, isDir);
+}
+
+HRESULT CHashCallbackGUI::ScanError(const FString &path, DWORD systemError)
+{
+ AddErrorMessage(HRESULT_FROM_WIN32(systemError), fs2us(path));
+ return CheckBreak();
+}
+
+HRESULT CHashCallbackGUI::FinishScanning(const CDirItemsStat &st)
+{
+ return ScanProgress(st, FString(), false); // isDir
+}
+
+HRESULT CHashCallbackGUI::CheckBreak()
+{
+ return Sync.CheckStop();
+}
+
+HRESULT CHashCallbackGUI::SetNumFiles(UInt64 numFiles)
+{
+ CProgressSync &sync = Sync;
+ sync.Set_NumFilesTotal(numFiles);
+ return CheckBreak();
+}
+
+HRESULT CHashCallbackGUI::SetTotal(UInt64 size)
+{
+ CProgressSync &sync = Sync;
+ sync.Set_NumBytesTotal(size);
+ return CheckBreak();
+}
+
+HRESULT CHashCallbackGUI::SetCompleted(const UInt64 *completed)
+{
+ return Sync.Set_NumBytesCur(completed);
+}
+
+HRESULT CHashCallbackGUI::BeforeFirstFile(const CHashBundle & /* hb */)
+{
+ return S_OK;
+}
+
+HRESULT CHashCallbackGUI::GetStream(const wchar_t *name, bool isFolder)
+{
+ if (NumFiles == 0)
+ FirstFileName = name;
+ _curIsFolder = isFolder;
+ CProgressSync &sync = Sync;
+ sync.Set_FilePath(name, isFolder);
+ return CheckBreak();
+}
+
+HRESULT CHashCallbackGUI::OpenFileError(const FString &path, DWORD systemError)
+{
+ // if (systemError == ERROR_SHARING_VIOLATION)
+ {
+ AddErrorMessage(HRESULT_FROM_WIN32(systemError), fs2us(path));
+ return S_FALSE;
+ }
+ // return systemError;
+}
+
+HRESULT CHashCallbackGUI::SetOperationResult(UInt64 /* fileSize */, const CHashBundle & /* hb */, bool /* showHash */)
+{
+ CProgressSync &sync = Sync;
+ if (!_curIsFolder)
+ NumFiles++;
+ sync.Set_NumFilesCur(NumFiles);
+ return CheckBreak();
+}
+
+static const unsigned k_DigestStringSize = k_HashCalc_DigestSize_Max * 2 + k_HashCalc_ExtraSize * 2 + 16;
+
+static void AddHashString(CProperty &s, const CHasherState &h, unsigned digestIndex)
+{
+ char temp[k_DigestStringSize];
+ h.WriteToString(digestIndex, temp);
+ s.Value = temp;
+}
+
+static void AddHashResString(CPropNameValPairs &s, const CHasherState &h, unsigned digestIndex, UInt32 resID)
+{
+ CProperty &pair = s.AddNew();
+ UString &s2 = pair.Name;
+ LangString(resID, s2);
+ UString name (h.Name);
+ s2.Replace(L"CRC", name);
+ s2.Replace(L":", L"");
+ AddHashString(pair, h, digestIndex);
+}
+
+
+void AddHashBundleRes(CPropNameValPairs &s, const CHashBundle &hb)
+{
+ if (hb.NumErrors != 0)
+ AddValuePair(s, IDS_PROP_NUM_ERRORS, hb.NumErrors);
+
+ if (hb.NumFiles == 1 && hb.NumDirs == 0 && !hb.FirstFileName.IsEmpty())
+ {
+ CProperty &pair = s.AddNew();
+ LangString(IDS_PROP_NAME, pair.Name);
+ pair.Value = hb.FirstFileName;
+ }
+ else
+ {
+ if (!hb.MainName.IsEmpty())
+ {
+ CProperty &pair = s.AddNew();
+ LangString(IDS_PROP_NAME, pair.Name);
+ pair.Value = hb.MainName;
+ }
+ if (hb.NumDirs != 0)
+ AddValuePair(s, IDS_PROP_FOLDERS, hb.NumDirs);
+ AddValuePair(s, IDS_PROP_FILES, hb.NumFiles);
+ }
+
+ AddSizeValuePair(s, IDS_PROP_SIZE, hb.FilesSize);
+
+ if (hb.NumAltStreams != 0)
+ {
+ AddValuePair(s, IDS_PROP_NUM_ALT_STREAMS, hb.NumAltStreams);
+ AddSizeValuePair(s, IDS_PROP_ALT_STREAMS_SIZE, hb.AltStreamsSize);
+ }
+
+ FOR_VECTOR (i, hb.Hashers)
+ {
+ const CHasherState &h = hb.Hashers[i];
+ if (hb.NumFiles == 1 && hb.NumDirs == 0)
+ {
+ CProperty &pair = s.AddNew();
+ pair.Name += h.Name;
+ AddHashString(pair, h, k_HashCalc_Index_DataSum);
+ }
+ else
+ {
+ AddHashResString(s, h, k_HashCalc_Index_DataSum, IDS_CHECKSUM_CRC_DATA);
+ AddHashResString(s, h, k_HashCalc_Index_NamesSum, IDS_CHECKSUM_CRC_DATA_NAMES);
+ }
+ if (hb.NumAltStreams != 0)
+ {
+ AddHashResString(s, h, k_HashCalc_Index_StreamsSum, IDS_CHECKSUM_CRC_STREAMS_NAMES);
+ }
+ }
+}
+
+
+void AddHashBundleRes(UString &s, const CHashBundle &hb)
+{
+ CPropNameValPairs pairs;
+ AddHashBundleRes(pairs, hb);
+
+ FOR_VECTOR (i, pairs)
+ {
+ const CProperty &pair = pairs[i];
+ s += pair.Name;
+ s += ": ";
+ s += pair.Value;
+ s.Add_LF();
+ }
+
+ if (hb.NumErrors == 0 && hb.Hashers.IsEmpty())
+ {
+ s.Add_LF();
+ AddLangString(s, IDS_MESSAGE_NO_ERRORS);
+ s.Add_LF();
+ }
+}
+
+
+HRESULT CHashCallbackGUI::AfterLastFile(CHashBundle &hb)
+{
+ hb.FirstFileName = FirstFileName;
+ // MainPath
+ AddHashBundleRes(PropNameValPairs, hb);
+
+ CProgressSync &sync = Sync;
+ sync.Set_NumFilesCur(hb.NumFiles);
+
+ // CProgressMessageBoxPair &pair = GetMessagePair(hb.NumErrors != 0);
+ // pair.Message = s;
+ // LangString(IDS_CHECKSUM_INFORMATION, pair.Title);
+
+ return S_OK;
+}
+
+
+HRESULT CHashCallbackGUI::ProcessVirt()
+{
+ NumFiles = 0;
+ AString errorInfo;
+ HRESULT res = HashCalc(EXTERNAL_CODECS_LOC_VARS
+ *censor, *options, errorInfo, this);
+ return res;
+}
+
+
+HRESULT HashCalcGUI(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const NWildcard::CCensor &censor,
+ const CHashOptions &options,
+ bool &messageWasDisplayed)
+{
+ CHashCallbackGUI t;
+ #ifdef Z7_EXTERNAL_CODECS
+ t._externalCodecs = _externalCodecs;
+ #endif
+ t.censor = &censor;
+ t.options = &options;
+
+ t.ShowCompressionInfo = false;
+
+ const UString title = LangString(IDS_CHECKSUM_CALCULATING);
+
+ t.MainTitle = "7-Zip"; // LangString(IDS_APP_TITLE);
+ t.MainAddTitle = title;
+ t.MainAddTitle.Add_Space();
+
+ RINOK(t.Create(title))
+ messageWasDisplayed = t.ThreadFinishedOK && t.MessagesDisplayed;
+ return S_OK;
+}
+
+
+void ShowHashResults(const CPropNameValPairs &propPairs, HWND hwnd)
+{
+ CListViewDialog lv;
+
+ FOR_VECTOR (i, propPairs)
+ {
+ const CProperty &pair = propPairs[i];
+ lv.Strings.Add(pair.Name);
+ lv.Values.Add(pair.Value);
+ }
+
+ lv.Title = LangString(IDS_CHECKSUM_INFORMATION);
+ lv.DeleteIsAllowed = true;
+ lv.SelectFirst = false;
+ lv.NumColumns = 2;
+
+ lv.Create(hwnd);
+}
+
+
+void ShowHashResults(const CHashBundle &hb, HWND hwnd)
+{
+ CPropNameValPairs propPairs;
+ AddHashBundleRes(propPairs, hb);
+ ShowHashResults(propPairs, hwnd);
+}
+
+void CHashCallbackGUI::ProcessWasFinished_GuiVirt()
+{
+ if (Result != E_ABORT)
+ ShowHashResults(PropNameValPairs, *this);
+}
diff --git a/CPP/7zip/UI/GUI/HashGUI.h b/CPP/7zip/UI/GUI/HashGUI.h
index b626823..1ec9c47 100644
--- a/CPP/7zip/UI/GUI/HashGUI.h
+++ b/CPP/7zip/UI/GUI/HashGUI.h
@@ -1,27 +1,27 @@
-// HashGUI.h
-
-#ifndef __HASH_GUI_H
-#define __HASH_GUI_H
-
-#include "../Common/HashCalc.h"
-#include "../Common/Property.h"
-
-HRESULT HashCalcGUI(
- DECL_EXTERNAL_CODECS_LOC_VARS
- const NWildcard::CCensor &censor,
- const CHashOptions &options,
- bool &messageWasDisplayed);
-
-typedef CObjectVector<CProperty> CPropNameValPairs;
-
-void AddValuePair(CPropNameValPairs &pairs, UINT resourceID, UInt64 value);
-void AddSizeValue(UString &s, UInt64 value);
-void AddSizeValuePair(CPropNameValPairs &pairs, UINT resourceID, UInt64 value);
-
-void AddHashBundleRes(CPropNameValPairs &s, const CHashBundle &hb);
-void AddHashBundleRes(UString &s, const CHashBundle &hb);
-
-void ShowHashResults(const CPropNameValPairs &propPairs, HWND hwnd);
-void ShowHashResults(const CHashBundle &hb, HWND hwnd);
-
-#endif
+// HashGUI.h
+
+#ifndef ZIP7_INC_HASH_GUI_H
+#define ZIP7_INC_HASH_GUI_H
+
+#include "../Common/HashCalc.h"
+#include "../Common/Property.h"
+
+HRESULT HashCalcGUI(
+ DECL_EXTERNAL_CODECS_LOC_VARS
+ const NWildcard::CCensor &censor,
+ const CHashOptions &options,
+ bool &messageWasDisplayed);
+
+typedef CObjectVector<CProperty> CPropNameValPairs;
+
+void AddValuePair(CPropNameValPairs &pairs, UINT resourceID, UInt64 value);
+void AddSizeValue(UString &s, UInt64 value);
+void AddSizeValuePair(CPropNameValPairs &pairs, UINT resourceID, UInt64 value);
+
+void AddHashBundleRes(CPropNameValPairs &s, const CHashBundle &hb);
+void AddHashBundleRes(UString &s, const CHashBundle &hb);
+
+void ShowHashResults(const CPropNameValPairs &propPairs, HWND hwnd);
+void ShowHashResults(const CHashBundle &hb, HWND hwnd);
+
+#endif
diff --git a/CPP/7zip/UI/GUI/StdAfx.cpp b/CPP/7zip/UI/GUI/StdAfx.cpp
new file mode 100644
index 0000000..d0feea8
--- /dev/null
+++ b/CPP/7zip/UI/GUI/StdAfx.cpp
@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/7zip/UI/GUI/StdAfx.h b/CPP/7zip/UI/GUI/StdAfx.h
new file mode 100644
index 0000000..130db8a
--- /dev/null
+++ b/CPP/7zip/UI/GUI/StdAfx.h
@@ -0,0 +1,6 @@
+// StdAfx.h
+
+#if _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../FileManager/StdAfx.h"
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp b/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp
new file mode 100644
index 0000000..26057a7
--- /dev/null
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI.cpp
@@ -0,0 +1,280 @@
+// UpdateCallbackGUI.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "../../../Windows/PropVariant.h"
+
+#include "../FileManager/FormatUtils.h"
+#include "../FileManager/LangUtils.h"
+
+#include "../FileManager/resourceGui.h"
+
+#include "resource2.h"
+
+#include "UpdateCallbackGUI.h"
+
+using namespace NWindows;
+
+// CUpdateCallbackGUI::~CUpdateCallbackGUI() {}
+
+void CUpdateCallbackGUI::Init()
+{
+ CUpdateCallbackGUI2::Init();
+ FailedFiles.Clear();
+}
+
+void OpenResult_GUI(UString &s, const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result);
+
+HRESULT CUpdateCallbackGUI::OpenResult(
+ const CCodecs *codecs, const CArchiveLink &arcLink, const wchar_t *name, HRESULT result)
+{
+ UString s;
+ OpenResult_GUI(s, codecs, arcLink, name, result);
+ if (!s.IsEmpty())
+ {
+ ProgressDialog->Sync.AddError_Message(s);
+ }
+
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::StartScanning()
+{
+ CProgressSync &sync = ProgressDialog->Sync;
+ sync.Set_Status(LangString(IDS_SCANNING));
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::ScanError(const FString &path, DWORD systemError)
+{
+ FailedFiles.Add(path);
+ ProgressDialog->Sync.AddError_Code_Name(HRESULT_FROM_WIN32(systemError), fs2us(path));
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::FinishScanning(const CDirItemsStat &st)
+{
+ CProgressSync &sync = ProgressDialog->Sync;
+ RINOK(ProgressDialog->Sync.ScanProgress(st.NumFiles + st.NumAltStreams,
+ st.GetTotalBytes(), FString(), true))
+ sync.Set_Status(L"");
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::StartArchive(const wchar_t *name, bool /* updating */)
+{
+ CProgressSync &sync = ProgressDialog->Sync;
+ sync.Set_Status(LangString(IDS_PROGRESS_COMPRESSING));
+ sync.Set_TitleFileName(name);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::FinishArchive(const CFinishArchiveStat & /* st */)
+{
+ CProgressSync &sync = ProgressDialog->Sync;
+ sync.Set_Status(L"");
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::CheckBreak()
+{
+ return ProgressDialog->Sync.CheckStop();
+}
+
+HRESULT CUpdateCallbackGUI::ScanProgress(const CDirItemsStat &st, const FString &path, bool isDir)
+{
+ return ProgressDialog->Sync.ScanProgress(st.NumFiles + st.NumAltStreams,
+ st.GetTotalBytes(), path, isDir);
+}
+
+/*
+HRESULT CUpdateCallbackGUI::Finalize()
+{
+ return S_OK;
+}
+*/
+
+HRESULT CUpdateCallbackGUI::SetNumItems(const CArcToDoStat &stat)
+{
+ ProgressDialog->Sync.Set_NumFilesTotal(stat.Get_NumDataItems_Total());
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::SetTotal(UInt64 total)
+{
+ ProgressDialog->Sync.Set_NumBytesTotal(total);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::SetCompleted(const UInt64 *completed)
+{
+ return ProgressDialog->Sync.Set_NumBytesCur(completed);
+}
+
+HRESULT CUpdateCallbackGUI::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+ ProgressDialog->Sync.Set_Ratio(inSize, outSize);
+ return CheckBreak();
+}
+
+HRESULT CUpdateCallbackGUI::GetStream(const wchar_t *name, bool isDir, bool /* isAnti */, UInt32 mode)
+{
+ return SetOperation_Base(mode, name, isDir);
+}
+
+HRESULT CUpdateCallbackGUI::OpenFileError(const FString &path, DWORD systemError)
+{
+ FailedFiles.Add(path);
+ // if (systemError == ERROR_SHARING_VIOLATION)
+ {
+ ProgressDialog->Sync.AddError_Code_Name(HRESULT_FROM_WIN32(systemError), fs2us(path));
+ return S_FALSE;
+ }
+ // return systemError;
+}
+
+HRESULT CUpdateCallbackGUI::SetOperationResult(Int32 /* operationResult */)
+{
+ NumFiles++;
+ ProgressDialog->Sync.Set_NumFilesCur(NumFiles);
+ return S_OK;
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s);
+
+HRESULT CUpdateCallbackGUI::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name)
+{
+ if (opRes != NArchive::NExtract::NOperationResult::kOK)
+ {
+ UString s;
+ SetExtractErrorMessage(opRes, isEncrypted, name, s);
+ ProgressDialog->Sync.AddError_Message(s);
+ }
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::ReportUpdateOperation(UInt32 op, const wchar_t *name, bool isDir)
+{
+ return SetOperation_Base(op, name, isDir);
+}
+
+HRESULT CUpdateCallbackGUI::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
+{
+ *password = NULL;
+ if (passwordIsDefined)
+ *passwordIsDefined = BoolToInt(PasswordIsDefined);
+ if (!PasswordIsDefined)
+ {
+ if (AskPassword)
+ {
+ RINOK(ShowAskPasswordDialog())
+ }
+ }
+ if (passwordIsDefined)
+ *passwordIsDefined = BoolToInt(PasswordIsDefined);
+ return StringToBstr(Password, password);
+}
+
+HRESULT CUpdateCallbackGUI::CryptoGetTextPassword(BSTR *password)
+{
+ return CryptoGetTextPassword2(NULL, password);
+}
+
+/*
+It doesn't work, since main stream waits Dialog
+HRESULT CUpdateCallbackGUI::CloseProgress()
+{
+ ProgressDialog->MyClose();
+ return S_OK;
+}
+*/
+
+
+HRESULT CUpdateCallbackGUI::Open_CheckBreak()
+{
+ return ProgressDialog->Sync.CheckStop();
+}
+
+HRESULT CUpdateCallbackGUI::Open_SetTotal(const UInt64 * /* numFiles */, const UInt64 * /* numBytes */)
+{
+ // if (numFiles != NULL) ProgressDialog->Sync.SetNumFilesTotal(*numFiles);
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::Open_SetCompleted(const UInt64 * /* numFiles */, const UInt64 * /* numBytes */)
+{
+ return ProgressDialog->Sync.CheckStop();
+}
+
+#ifndef Z7_NO_CRYPTO
+
+HRESULT CUpdateCallbackGUI::Open_CryptoGetTextPassword(BSTR *password)
+{
+ PasswordWasAsked = true;
+ return CryptoGetTextPassword2(NULL, password);
+}
+
+/*
+HRESULT CUpdateCallbackGUI::Open_GetPasswordIfAny(bool &passwordIsDefined, UString &password)
+{
+ passwordIsDefined = PasswordIsDefined;
+ password = Password;
+ return S_OK;
+}
+
+bool CUpdateCallbackGUI::Open_WasPasswordAsked()
+{
+ return PasswordWasAsked;
+}
+
+void CUpdateCallbackGUI::Open_Clear_PasswordWasAsked_Flag()
+{
+ PasswordWasAsked = false;
+}
+*/
+
+HRESULT CUpdateCallbackGUI::ShowDeleteFile(const wchar_t *name, bool isDir)
+{
+ return SetOperation_Base(NUpdateNotifyOp::kDelete, name, isDir);
+}
+
+HRESULT CUpdateCallbackGUI::FinishDeletingAfterArchiving()
+{
+ // ClosePercents2();
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::DeletingAfterArchiving(const FString &path, bool isDir)
+{
+ return ProgressDialog->Sync.Set_Status2(_lang_Removing, fs2us(path), isDir);
+}
+
+HRESULT CUpdateCallbackGUI::StartOpenArchive(const wchar_t * /* name */)
+{
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::ReadingFileError(const FString &path, DWORD systemError)
+{
+ FailedFiles.Add(path);
+ ProgressDialog->Sync.AddError_Code_Name(HRESULT_FROM_WIN32(systemError), fs2us(path));
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::WriteSfx(const wchar_t * /* name */, UInt64 /* size */)
+{
+ CProgressSync &sync = ProgressDialog->Sync;
+ sync.Set_Status(L"WriteSfx");
+ return S_OK;
+}
+
+HRESULT CUpdateCallbackGUI::Open_Finished()
+{
+ // ClosePercents();
+ return S_OK;
+}
+
+#endif
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI.h b/CPP/7zip/UI/GUI/UpdateCallbackGUI.h
new file mode 100644
index 0000000..998249a
--- /dev/null
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI.h
@@ -0,0 +1,31 @@
+// UpdateCallbackGUI.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK_GUI_H
+#define ZIP7_INC_UPDATE_CALLBACK_GUI_H
+
+#include "../Common/Update.h"
+#include "../Common/ArchiveOpenCallback.h"
+
+#include "UpdateCallbackGUI2.h"
+
+class CUpdateCallbackGUI Z7_final:
+ public IOpenCallbackUI,
+ public IUpdateCallbackUI2,
+ public CUpdateCallbackGUI2
+{
+ Z7_IFACE_IMP(IOpenCallbackUI)
+ Z7_IFACE_IMP(IUpdateCallbackUI)
+ Z7_IFACE_IMP(IDirItemsCallback)
+ Z7_IFACE_IMP(IUpdateCallbackUI2)
+
+public:
+ bool AskPassword;
+ FStringVector FailedFiles;
+
+ CUpdateCallbackGUI():
+ AskPassword(false)
+ {}
+ void Init();
+};
+
+#endif
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp
new file mode 100644
index 0000000..966f57e
--- /dev/null
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.cpp
@@ -0,0 +1,59 @@
+// UpdateCallbackGUI2.cpp
+
+#include "StdAfx.h"
+
+#include "../FileManager/LangUtils.h"
+#include "../FileManager/PasswordDialog.h"
+
+#include "resource2.h"
+#include "resource3.h"
+#include "ExtractRes.h"
+
+#include "UpdateCallbackGUI.h"
+
+using namespace NWindows;
+
+static const UINT k_UpdNotifyLangs[] =
+{
+ IDS_PROGRESS_ADD,
+ IDS_PROGRESS_UPDATE,
+ IDS_PROGRESS_ANALYZE,
+ IDS_PROGRESS_REPLICATE,
+ IDS_PROGRESS_REPACK,
+ IDS_PROGRESS_SKIPPING,
+ IDS_PROGRESS_DELETE,
+ IDS_PROGRESS_HEADER
+};
+
+void CUpdateCallbackGUI2::Init()
+{
+ NumFiles = 0;
+
+ _lang_Removing = LangString(IDS_PROGRESS_REMOVE);
+ _lang_Ops.Clear();
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(k_UpdNotifyLangs); i++)
+ _lang_Ops.Add(LangString(k_UpdNotifyLangs[i]));
+}
+
+HRESULT CUpdateCallbackGUI2::SetOperation_Base(UInt32 notifyOp, const wchar_t *name, bool isDir)
+{
+ const UString *s = NULL;
+ if (notifyOp < _lang_Ops.Size())
+ s = &(_lang_Ops[(unsigned)notifyOp]);
+ else
+ s = &_emptyString;
+
+ return ProgressDialog->Sync.Set_Status2(*s, name, isDir);
+}
+
+
+HRESULT CUpdateCallbackGUI2::ShowAskPasswordDialog()
+{
+ CPasswordDialog dialog;
+ ProgressDialog->WaitCreating();
+ if (dialog.Create(*ProgressDialog) != IDOK)
+ return E_ABORT;
+ Password = dialog.Password;
+ PasswordIsDefined = true;
+ return S_OK;
+}
diff --git a/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h
new file mode 100644
index 0000000..e32b602
--- /dev/null
+++ b/CPP/7zip/UI/GUI/UpdateCallbackGUI2.h
@@ -0,0 +1,34 @@
+// UpdateCallbackGUI2.h
+
+#ifndef ZIP7_INC_UPDATE_CALLBACK_GUI2_H
+#define ZIP7_INC_UPDATE_CALLBACK_GUI2_H
+
+#include "../FileManager/ProgressDialog2.h"
+
+class CUpdateCallbackGUI2
+{
+ UStringVector _lang_Ops;
+ UString _emptyString;
+public:
+ UString Password;
+ bool PasswordIsDefined;
+ bool PasswordWasAsked;
+ UInt64 NumFiles;
+
+ UString _lang_Removing;
+
+ CUpdateCallbackGUI2():
+ PasswordIsDefined(false),
+ PasswordWasAsked(false),
+ NumFiles(0)
+ {}
+
+ void Init();
+
+ CProgressDialog *ProgressDialog;
+
+ HRESULT SetOperation_Base(UInt32 notifyOp, const wchar_t *name, bool isDir);
+ HRESULT ShowAskPasswordDialog();
+};
+
+#endif
diff --git a/CPP/7zip/UI/GUI/UpdateGUI.cpp b/CPP/7zip/UI/GUI/UpdateGUI.cpp
new file mode 100644
index 0000000..aaf7ebd
--- /dev/null
+++ b/CPP/7zip/UI/GUI/UpdateGUI.cpp
@@ -0,0 +1,605 @@
+// UpdateGUI.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
+
+#include "../../../Windows/DLL.h"
+#include "../../../Windows/FileDir.h"
+#include "../../../Windows/FileName.h"
+#include "../../../Windows/Thread.h"
+
+#include "../Common/WorkDir.h"
+
+#include "../Explorer/MyMessages.h"
+
+#include "../FileManager/LangUtils.h"
+#include "../FileManager/StringUtils.h"
+#include "../FileManager/resourceGui.h"
+
+#include "CompressDialog.h"
+#include "UpdateGUI.h"
+
+#include "resource2.h"
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NDir;
+
+static const char * const kDefaultSfxModule = "7z.sfx";
+static const char * const kSFXExtension = "exe";
+
+extern void AddMessageToString(UString &dest, const UString &src);
+
+UString HResultToMessage(HRESULT errorCode);
+
+class CThreadUpdating: public CProgressThreadVirt
+{
+ HRESULT ProcessVirt() Z7_override;
+public:
+ CCodecs *codecs;
+ const CObjectVector<COpenType> *formatIndices;
+ const UString *cmdArcPath;
+ CUpdateCallbackGUI *UpdateCallbackGUI;
+ NWildcard::CCensor *WildcardCensor;
+ CUpdateOptions *Options;
+ bool needSetPath;
+};
+
+HRESULT CThreadUpdating::ProcessVirt()
+{
+ CUpdateErrorInfo ei;
+ HRESULT res = UpdateArchive(codecs, *formatIndices, *cmdArcPath,
+ *WildcardCensor, *Options,
+ ei, UpdateCallbackGUI, UpdateCallbackGUI, needSetPath);
+ FinalMessage.ErrorMessage.Message = ei.Message.Ptr();
+ ErrorPaths = ei.FileNames;
+ if (res != S_OK)
+ return res;
+ return HRESULT_FROM_WIN32(ei.SystemError);
+}
+
+
+// parse command line properties
+
+static bool ParseProp_Time_BoolPair(const CProperty &prop, const char *name, CBoolPair &bp)
+{
+ if (!prop.Name.IsPrefixedBy_Ascii_NoCase(name))
+ return false;
+ const UString rem = prop.Name.Ptr((unsigned)strlen(name));
+ UString val = prop.Value;
+ if (!rem.IsEmpty())
+ {
+ if (!val.IsEmpty())
+ return true;
+ val = rem;
+ }
+ bool res;
+ if (StringToBool(val, res))
+ {
+ bp.Val = res;
+ bp.Def = true;
+ }
+ return true;
+}
+
+static void ParseProp(
+ const CProperty &prop,
+ NCompressDialog::CInfo &di)
+{
+ if (ParseProp_Time_BoolPair(prop, "tm", di.MTime)) return;
+ if (ParseProp_Time_BoolPair(prop, "tc", di.CTime)) return;
+ if (ParseProp_Time_BoolPair(prop, "ta", di.ATime)) return;
+}
+
+static void ParseProperties(
+ const CObjectVector<CProperty> &properties,
+ NCompressDialog::CInfo &di)
+{
+ FOR_VECTOR (i, properties)
+ {
+ ParseProp(properties[i], di);
+ }
+}
+
+
+
+
+
+static void AddProp_UString(CObjectVector<CProperty> &properties, const char *name, const UString &value)
+{
+ CProperty prop;
+ prop.Name = name;
+ prop.Value = value;
+ properties.Add(prop);
+}
+
+static void AddProp_UInt32(CObjectVector<CProperty> &properties, const char *name, UInt32 value)
+{
+ UString s;
+ s.Add_UInt32(value);
+ AddProp_UString(properties, name, s);
+}
+
+static void AddProp_bool(CObjectVector<CProperty> &properties, const char *name, bool value)
+{
+ AddProp_UString(properties, name, UString(value ? "on": "off"));
+}
+
+
+static void AddProp_BoolPair(CObjectVector<CProperty> &properties,
+ const char *name, const CBoolPair &bp)
+{
+ if (bp.Def)
+ AddProp_bool(properties, name, bp.Val);
+}
+
+
+
+static void SplitOptionsToStrings(const UString &src, UStringVector &strings)
+{
+ SplitString(src, strings);
+ FOR_VECTOR (i, strings)
+ {
+ UString &s = strings[i];
+ if (s.Len() > 2
+ && s[0] == '-'
+ && MyCharLower_Ascii(s[1]) == 'm')
+ s.DeleteFrontal(2);
+ }
+}
+
+static bool IsThereMethodOverride(bool is7z, const UStringVector &strings)
+{
+ FOR_VECTOR (i, strings)
+ {
+ const UString &s = strings[i];
+ if (is7z)
+ {
+ const wchar_t *end;
+ UInt64 n = ConvertStringToUInt64(s, &end);
+ if (n == 0 && *end == L'=')
+ return true;
+ }
+ else
+ {
+ if (s.Len() > 0)
+ if (s[0] == L'm' && s[1] == L'=')
+ return true;
+ }
+ }
+ return false;
+}
+
+static void ParseAndAddPropertires(CObjectVector<CProperty> &properties,
+ const UStringVector &strings)
+{
+ FOR_VECTOR (i, strings)
+ {
+ const UString &s = strings[i];
+ CProperty property;
+ const int index = s.Find(L'=');
+ if (index < 0)
+ property.Name = s;
+ else
+ {
+ property.Name.SetFrom(s, (unsigned)index);
+ property.Value = s.Ptr(index + 1);
+ }
+ properties.Add(property);
+ }
+}
+
+
+static void AddProp_Size(CObjectVector<CProperty> &properties, const char *name, const UInt64 size)
+{
+ UString s;
+ s.Add_UInt64(size);
+ s += 'b';
+ AddProp_UString(properties, name, s);
+}
+
+
+static void SetOutProperties(
+ CObjectVector<CProperty> &properties,
+ const NCompressDialog::CInfo &di,
+ bool is7z,
+ bool setMethod)
+{
+ if (di.Level != (UInt32)(Int32)-1)
+ AddProp_UInt32(properties, "x", (UInt32)di.Level);
+ if (setMethod)
+ {
+ if (!di.Method.IsEmpty())
+ AddProp_UString(properties, is7z ? "0": "m", di.Method);
+ if (di.Dict64 != (UInt64)(Int64)-1)
+ {
+ AString name;
+ if (is7z)
+ name = "0";
+ name += (di.OrderMode ? "mem" : "d");
+ AddProp_Size(properties, name, di.Dict64);
+ }
+ /*
+ if (di.Dict64_Chain != (UInt64)(Int64)-1)
+ {
+ AString name;
+ if (is7z)
+ name = "0";
+ name += "dc";
+ AddProp_Size(properties, name, di.Dict64_Chain);
+ }
+ */
+ if (di.Order != (UInt32)(Int32)-1)
+ {
+ AString name;
+ if (is7z)
+ name = "0";
+ name += (di.OrderMode ? "o" : "fb");
+ AddProp_UInt32(properties, name, (UInt32)di.Order);
+ }
+ }
+
+ if (!di.EncryptionMethod.IsEmpty())
+ AddProp_UString(properties, "em", di.EncryptionMethod);
+
+ if (di.EncryptHeadersIsAllowed)
+ AddProp_bool(properties, "he", di.EncryptHeaders);
+
+ if (di.SolidIsSpecified)
+ AddProp_Size(properties, "s", di.SolidBlockSize);
+
+ if (
+ // di.MultiThreadIsAllowed &&
+ di.NumThreads != (UInt32)(Int32)-1)
+ AddProp_UInt32(properties, "mt", di.NumThreads);
+
+ const NCompression::CMemUse &memUse = di.MemUsage;
+ if (memUse.IsDefined)
+ {
+ const char *kMemUse = "memuse";
+ if (memUse.IsPercent)
+ {
+ UString s;
+ // s += 'p'; // for debug: alternate percent method
+ s.Add_UInt64(memUse.Val);
+ s += '%';
+ AddProp_UString(properties, kMemUse, s);
+ }
+ else
+ AddProp_Size(properties, kMemUse, memUse.Val);
+ }
+
+ AddProp_BoolPair(properties, "tm", di.MTime);
+ AddProp_BoolPair(properties, "tc", di.CTime);
+ AddProp_BoolPair(properties, "ta", di.ATime);
+
+ if (di.TimePrec != (UInt32)(Int32)-1)
+ AddProp_UInt32(properties, "tp", di.TimePrec);
+}
+
+
+struct C_UpdateMode_ToAction_Pair
+{
+ NCompressDialog::NUpdateMode::EEnum UpdateMode;
+ const NUpdateArchive::CActionSet *ActionSet;
+};
+
+static const C_UpdateMode_ToAction_Pair g_UpdateMode_Pairs[] =
+{
+ { NCompressDialog::NUpdateMode::kAdd, &NUpdateArchive::k_ActionSet_Add },
+ { NCompressDialog::NUpdateMode::kUpdate, &NUpdateArchive::k_ActionSet_Update },
+ { NCompressDialog::NUpdateMode::kFresh, &NUpdateArchive::k_ActionSet_Fresh },
+ { NCompressDialog::NUpdateMode::kSync, &NUpdateArchive::k_ActionSet_Sync }
+};
+
+static int FindActionSet(const NUpdateArchive::CActionSet &actionSet)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_UpdateMode_Pairs); i++)
+ if (actionSet.IsEqualTo(*g_UpdateMode_Pairs[i].ActionSet))
+ return (int)i;
+ return -1;
+}
+
+static int FindUpdateMode(NCompressDialog::NUpdateMode::EEnum mode)
+{
+ for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_UpdateMode_Pairs); i++)
+ if (mode == g_UpdateMode_Pairs[i].UpdateMode)
+ return (int)i;
+ return -1;
+}
+
+
+static HRESULT ShowDialog(
+ CCodecs *codecs,
+ const CObjectVector<NWildcard::CCensorPath> &censor,
+ CUpdateOptions &options,
+ CUpdateCallbackGUI *callback, HWND hwndParent)
+{
+ if (options.Commands.Size() != 1)
+ throw "It must be one command";
+ /*
+ FString currentDirPrefix;
+ #ifndef UNDER_CE
+ {
+ if (!MyGetCurrentDirectory(currentDirPrefix))
+ return E_FAIL;
+ NName::NormalizeDirPathPrefix(currentDirPrefix);
+ }
+ #endif
+ */
+
+ bool oneFile = false;
+ NFind::CFileInfo fileInfo;
+ UString name;
+
+ /*
+ if (censor.Pairs.Size() > 0)
+ {
+ const NWildcard::CPair &pair = censor.Pairs[0];
+ if (pair.Head.IncludeItems.Size() > 0)
+ {
+ const NWildcard::CItem &item = pair.Head.IncludeItems[0];
+ if (item.ForFile)
+ {
+ name = pair.Prefix;
+ FOR_VECTOR (i, item.PathParts)
+ {
+ if (i > 0)
+ name.Add_PathSepar();
+ name += item.PathParts[i];
+ }
+ if (fileInfo.Find(us2fs(name)))
+ {
+ if (censor.Pairs.Size() == 1 && pair.Head.IncludeItems.Size() == 1)
+ oneFile = !fileInfo.IsDir();
+ }
+ }
+ }
+ }
+ */
+ if (censor.Size() > 0)
+ {
+ const NWildcard::CCensorPath &cp = censor[0];
+ if (cp.Include)
+ {
+ {
+ if (fileInfo.Find(us2fs(cp.Path)))
+ {
+ if (censor.Size() == 1)
+ oneFile = !fileInfo.IsDir();
+ }
+ }
+ }
+ }
+
+
+ /*
+ // v23: we restore current dir in dialog code
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ CCurrentDirRestorer curDirRestorer;
+ #endif
+ */
+
+ CCompressDialog dialog;
+ NCompressDialog::CInfo &di = dialog.Info;
+ dialog.ArcFormats = &codecs->Formats;
+ {
+ CObjectVector<CCodecInfoUser> userCodecs;
+ codecs->Get_CodecsInfoUser_Vector(userCodecs);
+ dialog.SetMethods(userCodecs);
+ }
+
+ if (options.MethodMode.Type_Defined)
+ di.FormatIndex = options.MethodMode.Type.FormatIndex;
+
+ FOR_VECTOR (i, codecs->Formats)
+ {
+ const CArcInfoEx &ai = codecs->Formats[i];
+ if (!ai.UpdateEnabled)
+ continue;
+ if (!oneFile && ai.Flags_KeepName())
+ continue;
+ if ((int)i != di.FormatIndex)
+ {
+ if (ai.Flags_HashHandler())
+ continue;
+ if (ai.Name.IsEqualTo_Ascii_NoCase("swfc"))
+ if (!oneFile || name.Len() < 4 || !StringsAreEqualNoCase_Ascii(name.RightPtr(4), ".swf"))
+ continue;
+ }
+ dialog.ArcIndices.Add(i);
+ }
+ if (dialog.ArcIndices.IsEmpty())
+ {
+ ShowErrorMessage(L"No Update Engines");
+ return E_FAIL;
+ }
+
+ // di.ArchiveName = options.ArchivePath.GetFinalPath();
+ di.ArcPath = options.ArchivePath.GetPathWithoutExt();
+ dialog.OriginalFileName = fs2us(fileInfo.Name);
+
+ di.PathMode = options.PathMode;
+
+ // di.CurrentDirPrefix = currentDirPrefix;
+ di.SFXMode = options.SfxMode;
+ di.OpenShareForWrite = options.OpenShareForWrite;
+ di.DeleteAfterCompressing = options.DeleteAfterCompressing;
+
+ di.SymLinks = options.SymLinks;
+ di.HardLinks = options.HardLinks;
+ di.AltStreams = options.AltStreams;
+ di.NtSecurity = options.NtSecurity;
+ if (options.SetArcMTime)
+ di.SetArcMTime.SetTrueTrue();
+ if (options.PreserveATime)
+ di.PreserveATime.SetTrueTrue();
+
+ if (callback->PasswordIsDefined)
+ di.Password = callback->Password;
+
+ di.KeepName = !oneFile;
+
+ NUpdateArchive::CActionSet &actionSet = options.Commands.Front().ActionSet;
+
+ {
+ int index = FindActionSet(actionSet);
+ if (index < 0)
+ return E_NOTIMPL;
+ di.UpdateMode = g_UpdateMode_Pairs[(unsigned)index].UpdateMode;
+ }
+
+ ParseProperties(options.MethodMode.Properties, di);
+
+ if (dialog.Create(hwndParent) != IDOK)
+ return E_ABORT;
+
+ options.DeleteAfterCompressing = di.DeleteAfterCompressing;
+
+ options.SymLinks = di.SymLinks;
+ options.HardLinks = di.HardLinks;
+ options.AltStreams = di.AltStreams;
+ options.NtSecurity = di.NtSecurity;
+ options.SetArcMTime = di.SetArcMTime.Val;
+ if (di.PreserveATime.Def)
+ options.PreserveATime = di.PreserveATime.Val;
+
+ /*
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ curDirRestorer.NeedRestore = dialog.CurrentDirWasChanged;
+ #endif
+ */
+
+ options.VolumesSizes = di.VolumeSizes;
+ /*
+ if (di.VolumeSizeIsDefined)
+ {
+ MyMessageBox(L"Splitting to volumes is not supported");
+ return E_FAIL;
+ }
+ */
+
+
+ {
+ int index = FindUpdateMode(di.UpdateMode);
+ if (index < 0)
+ return E_FAIL;
+ actionSet = *g_UpdateMode_Pairs[index].ActionSet;
+ }
+
+ options.PathMode = di.PathMode;
+
+ const CArcInfoEx &archiverInfo = codecs->Formats[di.FormatIndex];
+ callback->PasswordIsDefined = (!di.Password.IsEmpty());
+ if (callback->PasswordIsDefined)
+ callback->Password = di.Password;
+
+ // we clear command line options, and fill options form Dialog
+ options.MethodMode.Properties.Clear();
+
+ const bool is7z = archiverInfo.Is_7z();
+
+ UStringVector optionStrings;
+ SplitOptionsToStrings(di.Options, optionStrings);
+ const bool methodOverride = IsThereMethodOverride(is7z, optionStrings);
+
+ SetOutProperties(options.MethodMode.Properties, di,
+ is7z,
+ !methodOverride); // setMethod
+
+ options.OpenShareForWrite = di.OpenShareForWrite;
+ ParseAndAddPropertires(options.MethodMode.Properties, optionStrings);
+
+ if (di.SFXMode)
+ options.SfxMode = true;
+ options.MethodMode.Type = COpenType();
+ options.MethodMode.Type_Defined = true;
+ options.MethodMode.Type.FormatIndex = di.FormatIndex;
+
+ options.ArchivePath.VolExtension = archiverInfo.GetMainExt();
+ if (di.SFXMode)
+ options.ArchivePath.BaseExtension = kSFXExtension;
+ else
+ options.ArchivePath.BaseExtension = options.ArchivePath.VolExtension;
+ options.ArchivePath.ParseFromPath(di.ArcPath, k_ArcNameMode_Smart);
+
+ NWorkDir::CInfo workDirInfo;
+ workDirInfo.Load();
+ options.WorkingDir.Empty();
+ if (workDirInfo.Mode != NWorkDir::NMode::kCurrent)
+ {
+ FString fullPath;
+ MyGetFullPathName(us2fs(di.ArcPath), fullPath);
+ FString namePart;
+ options.WorkingDir = GetWorkDir(workDirInfo, fullPath, namePart);
+ CreateComplexDir(options.WorkingDir);
+ }
+ return S_OK;
+}
+
+HRESULT UpdateGUI(
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &formatIndices,
+ const UString &cmdArcPath,
+ NWildcard::CCensor &censor,
+ CUpdateOptions &options,
+ bool showDialog,
+ bool &messageWasDisplayed,
+ CUpdateCallbackGUI *callback,
+ HWND hwndParent)
+{
+ messageWasDisplayed = false;
+ bool needSetPath = true;
+ if (showDialog)
+ {
+ RINOK(ShowDialog(codecs, censor.CensorPaths, options, callback, hwndParent))
+ needSetPath = false;
+ }
+ if (options.SfxMode && options.SfxModule.IsEmpty())
+ {
+ options.SfxModule = NWindows::NDLL::GetModuleDirPrefix();
+ options.SfxModule += kDefaultSfxModule;
+ }
+
+ CThreadUpdating tu;
+
+ tu.needSetPath = needSetPath;
+
+ tu.codecs = codecs;
+ tu.formatIndices = &formatIndices;
+ tu.cmdArcPath = &cmdArcPath;
+
+ tu.UpdateCallbackGUI = callback;
+ tu.UpdateCallbackGUI->ProgressDialog = &tu;
+ tu.UpdateCallbackGUI->Init();
+
+ UString title = LangString(IDS_PROGRESS_COMPRESSING);
+ if (!formatIndices.IsEmpty())
+ {
+ const int fin = formatIndices[0].FormatIndex;
+ if (fin >= 0)
+ if (codecs->Formats[fin].Flags_HashHandler())
+ title = LangString(IDS_CHECKSUM_CALCULATING);
+ }
+
+ /*
+ if (hwndParent != 0)
+ {
+ tu.ProgressDialog.MainWindow = hwndParent;
+ // tu.ProgressDialog.MainTitle = fileName;
+ tu.ProgressDialog.MainAddTitle = title + L' ';
+ }
+ */
+
+ tu.WildcardCensor = &censor;
+ tu.Options = &options;
+ tu.IconID = IDI_ICON;
+
+ RINOK(tu.Create(title, hwndParent))
+
+ messageWasDisplayed = tu.ThreadFinishedOK && tu.MessagesDisplayed;
+ return tu.Result;
+}
diff --git a/CPP/7zip/UI/GUI/UpdateGUI.h b/CPP/7zip/UI/GUI/UpdateGUI.h
new file mode 100644
index 0000000..0c43a01
--- /dev/null
+++ b/CPP/7zip/UI/GUI/UpdateGUI.h
@@ -0,0 +1,33 @@
+// GUI/UpdateGUI.h
+
+#ifndef ZIP7_INC_UPDATE_GUI_H
+#define ZIP7_INC_UPDATE_GUI_H
+
+#include "../Common/Update.h"
+
+#include "UpdateCallbackGUI.h"
+
+/*
+ callback->FailedFiles contains names of files for that there were problems.
+ RESULT can be S_OK, even if there are such warnings!!!
+
+ RESULT = E_ABORT - user break.
+ RESULT != E_ABORT:
+ {
+ messageWasDisplayed = true - message was displayed already.
+ messageWasDisplayed = false - there was some internal error, so you must show error message.
+ }
+*/
+
+HRESULT UpdateGUI(
+ CCodecs *codecs,
+ const CObjectVector<COpenType> &formatIndices,
+ const UString &cmdArcPath2,
+ NWildcard::CCensor &censor,
+ CUpdateOptions &options,
+ bool showDialog,
+ bool &messageWasDisplayed,
+ CUpdateCallbackGUI *callback,
+ HWND hwndParent = NULL);
+
+#endif
diff --git a/CPP/7zip/UI/GUI/makefile b/CPP/7zip/UI/GUI/makefile
new file mode 100644
index 0000000..9e2a9b4
--- /dev/null
+++ b/CPP/7zip/UI/GUI/makefile
@@ -0,0 +1,148 @@
+PROG = 7zG.exe
+CFLAGS = $(CFLAGS) \
+ -DZ7_LANG \
+ -DZ7_EXTERNAL_CODECS \
+
+!IFDEF UNDER_CE
+LIBS = $(LIBS) ceshell.lib Commctrl.lib
+!ELSE
+LIBS = $(LIBS) comctl32.lib htmlhelp.lib comdlg32.lib gdi32.lib
+CFLAGS = $(CFLAGS) -DZ7_LONG_PATH -DZ7_LARGE_PAGES -DZ7_DEVICE_FILE
+!ENDIF
+
+GUI_OBJS = \
+ $O\BenchmarkDialog.obj \
+ $O\CompressDialog.obj \
+ $O\ExtractDialog.obj \
+ $O\ExtractGUI.obj \
+ $O\GUI.obj \
+ $O\HashGUI.obj \
+ $O\UpdateCallbackGUI.obj \
+ $O\UpdateCallbackGUI2.obj \
+ $O\UpdateGUI.obj \
+
+COMMON_OBJS = \
+ $O\CommandLineParser.obj \
+ $O\CRC.obj \
+ $O\DynLimBuf.obj \
+ $O\IntToString.obj \
+ $O\Lang.obj \
+ $O\ListFileUtils.obj \
+ $O\MyString.obj \
+ $O\MyVector.obj \
+ $O\NewHandler.obj \
+ $O\StringConvert.obj \
+ $O\StringToInt.obj \
+ $O\UTFConvert.obj \
+ $O\Wildcard.obj \
+
+WIN_OBJS = \
+ $O\Clipboard.obj \
+ $O\CommonDialog.obj \
+ $O\DLL.obj \
+ $O\ErrorMsg.obj \
+ $O\FileDir.obj \
+ $O\FileFind.obj \
+ $O\FileIO.obj \
+ $O\FileLink.obj \
+ $O\FileName.obj \
+ $O\FileSystem.obj \
+ $O\MemoryGlobal.obj \
+ $O\MemoryLock.obj \
+ $O\PropVariant.obj \
+ $O\PropVariantConv.obj \
+ $O\Registry.obj \
+ $O\ResourceString.obj \
+ $O\Shell.obj \
+ $O\Synchronization.obj \
+ $O\System.obj \
+ $O\SystemInfo.obj \
+ $O\TimeUtils.obj \
+ $O\Window.obj \
+
+WIN_CTRL_OBJS = \
+ $O\ComboBox.obj \
+ $O\Dialog.obj \
+ $O\ListView.obj \
+
+7ZIP_COMMON_OBJS = \
+ $O\CreateCoder.obj \
+ $O\FilePathAutoRename.obj \
+ $O\FileStreams.obj \
+ $O\FilterCoder.obj \
+ $O\LimitedStreams.obj \
+ $O\MethodProps.obj \
+ $O\MultiOutStream.obj \
+ $O\ProgressUtils.obj \
+ $O\PropId.obj \
+ $O\StreamObjects.obj \
+ $O\StreamUtils.obj \
+ $O\UniqBlocks.obj \
+
+UI_COMMON_OBJS = \
+ $O\ArchiveCommandLine.obj \
+ $O\ArchiveExtractCallback.obj \
+ $O\ArchiveOpenCallback.obj \
+ $O\Bench.obj \
+ $O\DefaultName.obj \
+ $O\EnumDirItems.obj \
+ $O\Extract.obj \
+ $O\ExtractingFilePath.obj \
+ $O\HashCalc.obj \
+ $O\LoadCodecs.obj \
+ $O\OpenArchive.obj \
+ $O\PropIDUtils.obj \
+ $O\SetProperties.obj \
+ $O\SortUtils.obj \
+ $O\TempFiles.obj \
+ $O\Update.obj \
+ $O\UpdateAction.obj \
+ $O\UpdateCallback.obj \
+ $O\UpdatePair.obj \
+ $O\UpdateProduce.obj \
+ $O\WorkDir.obj \
+ $O\ZipRegistry.obj \
+
+AR_COMMON_OBJS = \
+ $O\ItemNameUtils.obj \
+ $O\OutStreamWithCRC.obj \
+
+FM_OBJS = \
+ $O\EditDialog.obj \
+ $O\ExtractCallback.obj \
+ $O\FormatUtils.obj \
+ $O\HelpUtils.obj \
+ $O\LangUtils.obj \
+ $O\ListViewDialog.obj \
+ $O\OpenCallback.obj \
+ $O\ProgramLocation.obj \
+ $O\PropertyName.obj \
+ $O\RegistryUtils.obj \
+ $O\SplitUtils.obj \
+ $O\StringUtils.obj \
+ $O\OverwriteDialog.obj \
+ $O\PasswordDialog.obj \
+ $O\ProgressDialog2.obj \
+
+FM_OBJS = $(FM_OBJS) \
+ $O\BrowseDialog.obj \
+ $O\ComboDialog.obj \
+ $O\SysIconUtils.obj \
+
+EXPLORER_OBJS = \
+ $O\MyMessages.obj \
+
+COMPRESS_OBJS = \
+ $O\CopyCoder.obj \
+
+C_OBJS = \
+ $O\Alloc.obj \
+ $O\CpuArch.obj \
+ $O\DllSecur.obj \
+ $O\Sort.obj \
+ $O\Threads.obj \
+
+!include "../../Crc.mak"
+
+
+!include "../../7zip.mak"
diff --git a/CPP/7zip/UI/GUI/resource.rc b/CPP/7zip/UI/GUI/resource.rc
new file mode 100644
index 0000000..04af815
--- /dev/null
+++ b/CPP/7zip/UI/GUI/resource.rc
@@ -0,0 +1,25 @@
+#include "../../MyVersionInfo.rc"
+// #include <winnt.h>
+
+#include "resource2.rc"
+#include "resource3.rc"
+
+#include "../FileManager/resourceGui.rc"
+
+MY_VERSION_INFO(MY_VFT_APP, "7-Zip GUI", "7zg", "7zg.exe")
+
+IDI_ICON ICON "FM.ico"
+
+#ifndef UNDER_CE
+1 24 MOVEABLE PURE "7zG.exe.manifest"
+#endif
+
+#include "../FileManager/PropertyName.rc"
+#include "../FileManager/OverwriteDialog.rc"
+#include "../FileManager/PasswordDialog.rc"
+#include "../FileManager/ProgressDialog2.rc"
+#include "Extract.rc"
+#include "../FileManager/BrowseDialog.rc"
+#include "../FileManager/ComboDialog.rc"
+#include "../FileManager/EditDialog.rc"
+#include "../FileManager/ListViewDialog.rc"
diff --git a/CPP/7zip/UI/GUI/resource2.h b/CPP/7zip/UI/GUI/resource2.h
index 152e71f..cd88292 100644
--- a/CPP/7zip/UI/GUI/resource2.h
+++ b/CPP/7zip/UI/GUI/resource2.h
@@ -1,2 +1,2 @@
-#define IDS_PROGRESS_COMPRESSING 3301
-#define IDS_ARCHIVES_COLON 3907
+#define IDS_PROGRESS_COMPRESSING 3301
+#define IDS_ARCHIVES_COLON 3907
diff --git a/CPP/7zip/UI/GUI/resource2.rc b/CPP/7zip/UI/GUI/resource2.rc
new file mode 100644
index 0000000..49534f5
--- /dev/null
+++ b/CPP/7zip/UI/GUI/resource2.rc
@@ -0,0 +1,10 @@
+#include "ExtractDialog.rc"
+#include "CompressDialog.rc"
+#include "BenchmarkDialog.rc"
+#include "resource2.h"
+
+STRINGTABLE
+BEGIN
+ IDS_PROGRESS_COMPRESSING "Compressing"
+ IDS_ARCHIVES_COLON "Archives:"
+END
diff --git a/CPP/7zip/UI/GUI/resource3.h b/CPP/7zip/UI/GUI/resource3.h
new file mode 100644
index 0000000..c25737f
--- /dev/null
+++ b/CPP/7zip/UI/GUI/resource3.h
@@ -0,0 +1,10 @@
+#define IDS_PROGRESS_REMOVE 3305
+
+#define IDS_PROGRESS_ADD 3320
+#define IDS_PROGRESS_UPDATE 3321
+#define IDS_PROGRESS_ANALYZE 3322
+#define IDS_PROGRESS_REPLICATE 3323
+#define IDS_PROGRESS_REPACK 3324
+
+#define IDS_PROGRESS_DELETE 3326
+#define IDS_PROGRESS_HEADER 3327
diff --git a/CPP/7zip/UI/GUI/resource3.rc b/CPP/7zip/UI/GUI/resource3.rc
new file mode 100644
index 0000000..cfc8bc3
--- /dev/null
+++ b/CPP/7zip/UI/GUI/resource3.rc
@@ -0,0 +1,15 @@
+#include "resource3.h"
+
+STRINGTABLE
+BEGIN
+ IDS_PROGRESS_REMOVE "Removing"
+
+ IDS_PROGRESS_ADD "Adding"
+ IDS_PROGRESS_UPDATE "Updating"
+ IDS_PROGRESS_ANALYZE "Analyzing"
+ IDS_PROGRESS_REPLICATE "Replicating"
+ IDS_PROGRESS_REPACK "Repacking"
+
+ IDS_PROGRESS_DELETE "Deleting"
+ IDS_PROGRESS_HEADER "Header creating"
+END
diff --git a/CPP/7zip/UI/makefile b/CPP/7zip/UI/makefile
new file mode 100644
index 0000000..1b0cdbe
--- /dev/null
+++ b/CPP/7zip/UI/makefile
@@ -0,0 +1,12 @@
+DIRS = \
+ Client7z\~ \
+ Console\~ \
+ Explorer\~ \
+ Far\~ \
+ FileManager\~ \
+ GUI\~ \
+
+all: $(DIRS)
+
+$(DIRS):
+!include "../SubBuild.mak"
diff --git a/CPP/7zip/cmpl_clang.mak b/CPP/7zip/cmpl_clang.mak
new file mode 100644
index 0000000..e62e1e6
--- /dev/null
+++ b/CPP/7zip/cmpl_clang.mak
@@ -0,0 +1,3 @@
+include ../../var_clang.mak
+include ../../warn_clang.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_clang_arm64.mak b/CPP/7zip/cmpl_clang_arm64.mak
new file mode 100644
index 0000000..3f6b02b
--- /dev/null
+++ b/CPP/7zip/cmpl_clang_arm64.mak
@@ -0,0 +1,3 @@
+include ../../var_clang_arm64.mak
+include ../../warn_clang.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_clang_x64.mak b/CPP/7zip/cmpl_clang_x64.mak
new file mode 100644
index 0000000..b61e2af
--- /dev/null
+++ b/CPP/7zip/cmpl_clang_x64.mak
@@ -0,0 +1,3 @@
+include ../../var_clang_x64.mak
+include ../../warn_clang.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_clang_x86.mak b/CPP/7zip/cmpl_clang_x86.mak
new file mode 100644
index 0000000..0e5cb76
--- /dev/null
+++ b/CPP/7zip/cmpl_clang_x86.mak
@@ -0,0 +1,3 @@
+include ../../var_clang_x86.mak
+include ../../warn_clang.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_gcc.mak b/CPP/7zip/cmpl_gcc.mak
new file mode 100644
index 0000000..7a1aef2
--- /dev/null
+++ b/CPP/7zip/cmpl_gcc.mak
@@ -0,0 +1,3 @@
+include ../../var_gcc.mak
+include ../../warn_gcc.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_gcc_arm64.mak b/CPP/7zip/cmpl_gcc_arm64.mak
new file mode 100644
index 0000000..53a8584
--- /dev/null
+++ b/CPP/7zip/cmpl_gcc_arm64.mak
@@ -0,0 +1,3 @@
+include ../../var_gcc_arm64.mak
+include ../../warn_gcc.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_gcc_x64.mak b/CPP/7zip/cmpl_gcc_x64.mak
new file mode 100644
index 0000000..500c30e
--- /dev/null
+++ b/CPP/7zip/cmpl_gcc_x64.mak
@@ -0,0 +1,3 @@
+include ../../var_gcc_x64.mak
+include ../../warn_gcc.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_gcc_x86.mak b/CPP/7zip/cmpl_gcc_x86.mak
new file mode 100644
index 0000000..e768707
--- /dev/null
+++ b/CPP/7zip/cmpl_gcc_x86.mak
@@ -0,0 +1,3 @@
+include ../../var_gcc_x86.mak
+include ../../warn_gcc.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_mac_arm64.mak b/CPP/7zip/cmpl_mac_arm64.mak
new file mode 100644
index 0000000..941028e
--- /dev/null
+++ b/CPP/7zip/cmpl_mac_arm64.mak
@@ -0,0 +1,3 @@
+include ../../var_mac_arm64.mak
+include ../../warn_clang_mac.mak
+include makefile.gcc
diff --git a/CPP/7zip/cmpl_mac_x64.mak b/CPP/7zip/cmpl_mac_x64.mak
new file mode 100644
index 0000000..d3aa039
--- /dev/null
+++ b/CPP/7zip/cmpl_mac_x64.mak
@@ -0,0 +1,3 @@
+include ../../var_mac_x64.mak
+include ../../warn_clang_mac.mak
+include makefile.gcc
diff --git a/CPP/7zip/makefile b/CPP/7zip/makefile
new file mode 100644
index 0000000..9d31e6b
--- /dev/null
+++ b/CPP/7zip/makefile
@@ -0,0 +1,10 @@
+DIRS = \
+ UI\~ \
+ Bundles\~ \
+
+all: $(DIRS)
+
+$(DIRS):
+ cd $(@D)
+ $(MAKE) -nologo
+ cd ..
diff --git a/CPP/7zip/var_clang.mak b/CPP/7zip/var_clang.mak
new file mode 100644
index 0000000..a6df26e
--- /dev/null
+++ b/CPP/7zip/var_clang.mak
@@ -0,0 +1,11 @@
+PLATFORM=
+O=b/c
+IS_X64=
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/CPP/7zip/var_clang_arm64.mak b/CPP/7zip/var_clang_arm64.mak
new file mode 100644
index 0000000..4b35409
--- /dev/null
+++ b/CPP/7zip/var_clang_arm64.mak
@@ -0,0 +1,11 @@
+PLATFORM=arm64
+O=b/c_$(PLATFORM)
+IS_X64=
+IS_X86=
+IS_ARM64=1
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/CPP/7zip/var_clang_x64.mak b/CPP/7zip/var_clang_x64.mak
new file mode 100644
index 0000000..fefed51
--- /dev/null
+++ b/CPP/7zip/var_clang_x64.mak
@@ -0,0 +1,12 @@
+PLATFORM=x64
+O=b/c_$(PLATFORM)
+IS_X64=1
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
+
diff --git a/CPP/7zip/var_clang_x86.mak b/CPP/7zip/var_clang_x86.mak
new file mode 100644
index 0000000..5f3c2d9
--- /dev/null
+++ b/CPP/7zip/var_clang_x86.mak
@@ -0,0 +1,12 @@
+PLATFORM=x86
+O=b/c_$(PLATFORM)
+IS_X64=
+IS_X86=1
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=-m32
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
+
diff --git a/CPP/7zip/var_gcc.mak b/CPP/7zip/var_gcc.mak
new file mode 100644
index 0000000..664491c
--- /dev/null
+++ b/CPP/7zip/var_gcc.mak
@@ -0,0 +1,12 @@
+PLATFORM=
+O=b/g
+IS_X64=
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
+
+# -march=armv8-a+crc+crypto
diff --git a/CPP/7zip/var_gcc_arm64.mak b/CPP/7zip/var_gcc_arm64.mak
new file mode 100644
index 0000000..4bbb687
--- /dev/null
+++ b/CPP/7zip/var_gcc_arm64.mak
@@ -0,0 +1,12 @@
+PLATFORM=arm64
+O=b/g_$(PLATFORM)
+IS_X64=
+IS_X86=
+IS_ARM64=1
+CROSS_COMPILE=
+MY_ARCH=-mtune=cortex-a53
+USE_ASM=1
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
+
+# -march=armv8-a+crc+crypto
diff --git a/CPP/7zip/var_gcc_x64.mak b/CPP/7zip/var_gcc_x64.mak
new file mode 100644
index 0000000..1acf604
--- /dev/null
+++ b/CPP/7zip/var_gcc_x64.mak
@@ -0,0 +1,10 @@
+PLATFORM=x64
+O=b/g_$(PLATFORM)
+IS_X64=1
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=
+USE_ASM=1
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
diff --git a/CPP/7zip/var_gcc_x86.mak b/CPP/7zip/var_gcc_x86.mak
new file mode 100644
index 0000000..288bf94
--- /dev/null
+++ b/CPP/7zip/var_gcc_x86.mak
@@ -0,0 +1,11 @@
+PLATFORM=x86
+O=b/g_$(PLATFORM)
+IS_X64=
+IS_X86=1
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=-m32
+USE_ASM=1
+CC=$(CROSS_COMPILE)gcc
+CXX=$(CROSS_COMPILE)g++
+
diff --git a/CPP/7zip/var_mac_arm64.mak b/CPP/7zip/var_mac_arm64.mak
new file mode 100644
index 0000000..adf5fa1
--- /dev/null
+++ b/CPP/7zip/var_mac_arm64.mak
@@ -0,0 +1,11 @@
+PLATFORM=arm64
+O=b/m_$(PLATFORM)
+IS_X64=
+IS_X86=
+IS_ARM64=1
+CROSS_COMPILE=
+MY_ARCH=-arch arm64
+USE_ASM=1
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/CPP/7zip/var_mac_x64.mak b/CPP/7zip/var_mac_x64.mak
new file mode 100644
index 0000000..13d7aa7
--- /dev/null
+++ b/CPP/7zip/var_mac_x64.mak
@@ -0,0 +1,11 @@
+PLATFORM=x64
+O=b/m_$(PLATFORM)
+IS_X64=1
+IS_X86=
+IS_ARM64=
+CROSS_COMPILE=
+MY_ARCH=-arch x86_64
+USE_ASM=
+CC=$(CROSS_COMPILE)clang
+CXX=$(CROSS_COMPILE)clang++
+USE_CLANG=1
diff --git a/CPP/7zip/warn_clang.mak b/CPP/7zip/warn_clang.mak
new file mode 100644
index 0000000..0d00730
--- /dev/null
+++ b/CPP/7zip/warn_clang.mak
@@ -0,0 +1,3 @@
+CFLAGS_WARN = -Weverything -Wfatal-errors
+# CXX_STD_FLAGS = -std=c++11
+# CXX_STD_FLAGS =
diff --git a/CPP/7zip/warn_clang_mac.mak b/CPP/7zip/warn_clang_mac.mak
new file mode 100644
index 0000000..ed936c5
--- /dev/null
+++ b/CPP/7zip/warn_clang_mac.mak
@@ -0,0 +1,9 @@
+CFLAGS_WARN = -Weverything -Wfatal-errors -Wno-poison-system-directories
+CXX_STD_FLAGS = -std=c++98
+CXX_STD_FLAGS = -std=c++11
+CXX_STD_FLAGS = -std=c++14
+CXX_STD_FLAGS = -std=c++17
+CXX_STD_FLAGS = -std=c++20
+CXX_STD_FLAGS = -std=c++23
+
+CXX_STD_FLAGS = -std=c++11
diff --git a/CPP/7zip/warn_gcc.mak b/CPP/7zip/warn_gcc.mak
new file mode 100644
index 0000000..7eb1f57
--- /dev/null
+++ b/CPP/7zip/warn_gcc.mak
@@ -0,0 +1,45 @@
+CFLAGS_WARN_GCC_4_8 = \
+ -Waddress \
+ -Waggressive-loop-optimizations \
+ -Wattributes \
+ -Wcast-align \
+ -Wcomment \
+ -Wdiv-by-zero \
+ -Wformat-contains-nul \
+ -Winit-self \
+ -Wint-to-pointer-cast \
+ -Wunused \
+ -Wunused-macros \
+
+CFLAGS_WARN_GCC_6 = $(CFLAGS_WARN_GCC_4_8)\
+ -Wbool-compare \
+ -Wduplicated-cond \
+
+# -Wno-strict-aliasing
+
+CFLAGS_WARN_GCC_9 = $(CFLAGS_WARN_GCC_6)\
+ -Waddress-of-packed-member \
+ -Wbool-operation \
+ -Wcast-align=strict \
+ -Wconversion \
+ -Wdangling-else \
+ -Wduplicated-branches \
+ -Wimplicit-fallthrough=5 \
+ -Wint-in-bool-context \
+ -Wmaybe-uninitialized \
+ -Wmisleading-indentation \
+ -Wmissing-attributes
+
+# In C: -Wsign-conversion enabled also by -Wconversion
+# -Wno-sign-conversion \
+
+
+CFLAGS_WARN_GCC_PPMD_UNALIGNED = \
+ -Wno-strict-aliasing \
+
+
+# CFLAGS_WARN = $(CFLAGS_WARN_GCC_4_8)
+CFLAGS_WARN = $(CFLAGS_WARN_GCC_9)
+
+# CXX_STD_FLAGS = -std=c++11
+# CXX_STD_FLAGS =
diff --git a/CPP/Build.mak b/CPP/Build.mak
index 5752491..393fa2c 100644
--- a/CPP/Build.mak
+++ b/CPP/Build.mak
@@ -1,156 +1,229 @@
-LIBS = $(LIBS) oleaut32.lib ole32.lib
-
-!IFNDEF MY_NO_UNICODE
-CFLAGS = $(CFLAGS) -DUNICODE -D_UNICODE
-!ENDIF
-
-!IFNDEF O
-!IFDEF PLATFORM
-O=$(PLATFORM)
-!ELSE
-O=o
-!ENDIF
-!ENDIF
-
-# CFLAGS = $(CFLAGS) -FAsc -Fa$O/asm/
-
-
-!IF "$(PLATFORM)" == "x64"
-MY_ML = ml64 -Dx64 -WX
-!ELSEIF "$(PLATFORM)" == "arm"
-MY_ML = armasm -WX
-!ELSE
-MY_ML = ml -WX
-!ENDIF
-
-
-!IFDEF UNDER_CE
-RFLAGS = $(RFLAGS) -dUNDER_CE
-!IFDEF MY_CONSOLE
-LFLAGS = $(LFLAGS) /ENTRY:mainACRTStartup
-!ENDIF
-!ELSE
-!IFDEF OLD_COMPILER
-LFLAGS = $(LFLAGS) -OPT:NOWIN98
-!ENDIF
-!IF "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
-CFLAGS = $(CFLAGS) -Gr
-!ENDIF
-LIBS = $(LIBS) user32.lib advapi32.lib shell32.lib
-!ENDIF
-
-!IF "$(PLATFORM)" == "arm"
-COMPL_ASM = $(MY_ML) $** $O/$(*B).obj
-!ELSE
-COMPL_ASM = $(MY_ML) -c -Fo$O/ $**
-!ENDIF
-
-CFLAGS = $(CFLAGS) -nologo -c -Fo$O/ -W4 -WX -EHsc -Gy -GR- -GF
-
-!IFDEF MY_DYNAMIC_LINK
-CFLAGS = $(CFLAGS) -MD
-!ELSE
-!IFNDEF MY_SINGLE_THREAD
-CFLAGS = $(CFLAGS) -MT
-!ENDIF
-!ENDIF
-
-!IFNDEF OLD_COMPILER
-CFLAGS = $(CFLAGS) -GS- -Zc:forScope -Zc:wchar_t
-!IFNDEF UNDER_CE
-CFLAGS = $(CFLAGS) -MP2
-!IFNDEF PLATFORM
-# CFLAGS = $(CFLAGS) -arch:IA32
-!ENDIF
-!ENDIF
-!ELSE
-CFLAGS = $(CFLAGS)
-!ENDIF
-
-!IFDEF MY_CONSOLE
-CFLAGS = $(CFLAGS) -D_CONSOLE
-!ENDIF
-
-!IFNDEF UNDER_CE
-!IF "$(PLATFORM)" == "arm"
-CFLAGS = $(CFLAGS) -D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE
-!ENDIF
-!ENDIF
-
-!IF "$(PLATFORM)" == "x64"
-CFLAGS_O1 = $(CFLAGS) -O1
-!ELSE
-CFLAGS_O1 = $(CFLAGS) -O1
-!ENDIF
-CFLAGS_O2 = $(CFLAGS) -O2
-
-LFLAGS = $(LFLAGS) -nologo -OPT:REF -OPT:ICF
-
-!IFNDEF UNDER_CE
-LFLAGS = $(LFLAGS) /LARGEADDRESSAWARE
-!ENDIF
-
-!IFDEF DEF_FILE
-LFLAGS = $(LFLAGS) -DLL -DEF:$(DEF_FILE)
-!ELSE
-!IF defined(MY_FIXED) && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
-LFLAGS = $(LFLAGS) /FIXED
-!ELSE
-LFLAGS = $(LFLAGS) /FIXED:NO
-!ENDIF
-# /BASE:0x400000
-!ENDIF
-
-
-# !IF "$(PLATFORM)" == "x64"
-
-!IFDEF SUB_SYS_VER
-
-MY_SUB_SYS_VER=5.02
-
-!IFDEF MY_CONSOLE
-LFLAGS = $(LFLAGS) /SUBSYSTEM:console,$(MY_SUB_SYS_VER)
-!ELSE
-LFLAGS = $(LFLAGS) /SUBSYSTEM:windows,$(MY_SUB_SYS_VER)
-!ENDIF
-
-!ENDIF
-
-
-PROGPATH = $O\$(PROG)
-
-COMPL_O1 = $(CC) $(CFLAGS_O1) $**
-COMPL_O2 = $(CC) $(CFLAGS_O2) $**
-COMPL_PCH = $(CC) $(CFLAGS_O1) -Yc"StdAfx.h" -Fp$O/a.pch $**
-COMPL = $(CC) $(CFLAGS_O1) -Yu"StdAfx.h" -Fp$O/a.pch $**
-
-COMPLB = $(CC) $(CFLAGS_O1) -Yu"StdAfx.h" -Fp$O/a.pch $<
-# COMPLB_O2 = $(CC) $(CFLAGS_O2) -Yu"StdAfx.h" -Fp$O/a.pch $<
-COMPLB_O2 = $(CC) $(CFLAGS_O2) $<
-
-CFLAGS_C_ALL = $(CFLAGS_O2) $(CFLAGS_C_SPEC)
-CCOMPL_PCH = $(CC) $(CFLAGS_C_ALL) -Yc"Precomp.h" -Fp$O/a.pch $**
-CCOMPL_USE = $(CC) $(CFLAGS_C_ALL) -Yu"Precomp.h" -Fp$O/a.pch $**
-CCOMPL = $(CC) $(CFLAGS_C_ALL) $**
-CCOMPLB = $(CC) $(CFLAGS_C_ALL) $<
-
-
-all: $(PROGPATH)
-
-clean:
- -del /Q $(PROGPATH) $O\*.exe $O\*.dll $O\*.obj $O\*.lib $O\*.exp $O\*.res $O\*.pch $O\*.asm
-
-$O:
- if not exist "$O" mkdir "$O"
-$O/asm:
- if not exist "$O/asm" mkdir "$O/asm"
-
-$(PROGPATH): $O $O/asm $(OBJS) $(DEF_FILE)
- link $(LFLAGS) -out:$(PROGPATH) $(OBJS) $(LIBS)
-
-!IFNDEF NO_DEFAULT_RES
-$O\resource.res: $(*B).rc
- rc $(RFLAGS) -fo$@ $**
-!ENDIF
-$O\StdAfx.obj: $(*B).cpp
- $(COMPL_PCH)
+LIBS = $(LIBS) oleaut32.lib ole32.lib
+
+!IFNDEF MY_NO_UNICODE
+CFLAGS = $(CFLAGS) -DUNICODE -D_UNICODE
+!ENDIF
+
+!IF "$(CC)" != "clang-cl"
+# for link time code generation:
+# CFLAGS = $(CFLAGS) -GL
+!ENDIF
+
+!IFNDEF O
+!IFDEF PLATFORM
+O=$(PLATFORM)
+!ELSE
+O=o
+!ENDIF
+!ENDIF
+
+!IF "$(CC)" != "clang-cl"
+# CFLAGS = $(CFLAGS) -FAsc -Fa$O/asm/
+!ENDIF
+
+
+!IF "$(PLATFORM)" == "x64"
+MY_ML = ml64 -WX
+#-Dx64
+!ELSEIF "$(PLATFORM)" == "arm"
+MY_ML = armasm -WX
+!ELSE
+MY_ML = ml -WX
+# -DABI_CDECL
+!ENDIF
+
+# MY_ML = "$(MY_ML) -Fl$O\asm\
+
+
+!IFDEF UNDER_CE
+RFLAGS = $(RFLAGS) -dUNDER_CE
+!IFDEF MY_CONSOLE
+LFLAGS = $(LFLAGS) /ENTRY:mainACRTStartup
+!ENDIF
+!ELSE
+!IFDEF OLD_COMPILER
+LFLAGS = $(LFLAGS) -OPT:NOWIN98
+!ENDIF
+!IF "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+CFLAGS = $(CFLAGS) -Gr
+!ENDIF
+LIBS = $(LIBS) user32.lib advapi32.lib shell32.lib
+!ENDIF
+
+!IF "$(PLATFORM)" == "arm"
+COMPL_ASM = $(MY_ML) $** $O/$(*B).obj
+!ELSE
+COMPL_ASM = $(MY_ML) -c -Fo$O/ $**
+!ENDIF
+
+!IFDEF OLD_COMPILER
+CFLAGS_WARN_LEVEL = -W4
+!ELSE
+CFLAGS_WARN_LEVEL = -Wall
+!ENDIF
+
+CFLAGS = $(CFLAGS) -nologo -c -Fo$O/ $(CFLAGS_WARN_LEVEL) -WX -EHsc -Gy -GR- -GF
+
+!IF "$(CC)" == "clang-cl"
+
+CFLAGS = $(CFLAGS) \
+ -Werror \
+ -Wall \
+ -Wextra \
+ -Weverything \
+ -Wfatal-errors \
+
+!ENDIF
+
+!IFDEF MY_DYNAMIC_LINK
+CFLAGS = $(CFLAGS) -MD
+!ELSE
+!IFNDEF MY_SINGLE_THREAD
+CFLAGS = $(CFLAGS) -MT
+!ENDIF
+!ENDIF
+
+
+CFLAGS = $(CFLAGS_COMMON) $(CFLAGS)
+
+
+!IFNDEF OLD_COMPILER
+
+CFLAGS = $(CFLAGS) -GS- -Zc:wchar_t
+!IFDEF VCTOOLSVERSION
+!IF "$(VCTOOLSVERSION)" >= "14.00"
+!IF "$(CC)" != "clang-cl"
+CFLAGS = $(CFLAGS) -Zc:throwingNew
+!ENDIF
+!ENDIF
+!ELSE
+# -Zc:forScope is default in VS2010. so we need it only for older versions
+CFLAGS = $(CFLAGS) -Zc:forScope
+!ENDIF
+
+!IFNDEF UNDER_CE
+!IF "$(CC)" != "clang-cl"
+CFLAGS = $(CFLAGS) -MP4
+!ENDIF
+!IFNDEF PLATFORM
+# CFLAGS = $(CFLAGS) -arch:IA32
+!ENDIF
+!ENDIF
+
+!ENDIF
+
+
+!IFDEF MY_CONSOLE
+CFLAGS = $(CFLAGS) -D_CONSOLE
+!ENDIF
+
+!IFNDEF UNDER_CE
+!IF "$(PLATFORM)" == "arm"
+CFLAGS = $(CFLAGS) -D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE
+!ENDIF
+!ENDIF
+
+!IF "$(PLATFORM)" == "x64"
+CFLAGS_O1 = $(CFLAGS) -O1
+!ELSE
+CFLAGS_O1 = $(CFLAGS) -O1
+!ENDIF
+CFLAGS_O2 = $(CFLAGS) -O2
+
+LFLAGS = $(LFLAGS) -nologo -OPT:REF -OPT:ICF -INCREMENTAL:NO
+
+!IFNDEF UNDER_CE
+LFLAGS = $(LFLAGS) /LARGEADDRESSAWARE
+!ENDIF
+
+!IFDEF DEF_FILE
+LFLAGS = $(LFLAGS) -DLL -DEF:$(DEF_FILE)
+!ELSE
+!IF defined(MY_FIXED) && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+LFLAGS = $(LFLAGS) /FIXED
+!ELSE
+LFLAGS = $(LFLAGS) /FIXED:NO
+!ENDIF
+# /BASE:0x400000
+!ENDIF
+
+!IF "$(PLATFORM)" == "arm64"
+# we can get better compression ratio with ARM64 filter if we change alignment to 4096
+# LFLAGS = $(LFLAGS) /FILEALIGN:4096
+!ENDIF
+
+
+
+# !IF "$(PLATFORM)" == "x64"
+
+!IFDEF SUB_SYS_VER
+
+MY_SUB_SYS_VER=5.02
+
+!IFDEF MY_CONSOLE
+LFLAGS = $(LFLAGS) /SUBSYSTEM:console,$(MY_SUB_SYS_VER)
+!ELSE
+LFLAGS = $(LFLAGS) /SUBSYSTEM:windows,$(MY_SUB_SYS_VER)
+!ENDIF
+
+!ENDIF
+
+
+PROGPATH = $O\$(PROG)
+
+COMPL_O1 = $(CC) $(CFLAGS_O1) $**
+COMPL_O2 = $(CC) $(CFLAGS_O2) $**
+COMPL_PCH = $(CC) $(CFLAGS_O1) -Yc"StdAfx.h" -Fp$O/a.pch $**
+COMPL = $(CC) $(CFLAGS_O1) -Yu"StdAfx.h" -Fp$O/a.pch $**
+COMPLB = $(CC) $(CFLAGS_O1) -Yu"StdAfx.h" -Fp$O/a.pch $<
+COMPLB_O2 = $(CC) $(CFLAGS_O2) $<
+# COMPLB_O2 = $(CC) $(CFLAGS_O2) -Yu"StdAfx.h" -Fp$O/a.pch $<
+
+CFLAGS_C_ALL = $(CFLAGS_O2) $(CFLAGS_C_SPEC)
+
+CCOMPL_PCH = $(CC) $(CFLAGS_C_ALL) -Yc"Precomp.h" -Fp$O/a.pch $**
+CCOMPL_USE = $(CC) $(CFLAGS_C_ALL) -Yu"Precomp.h" -Fp$O/a.pch $**
+CCOMPLB_USE = $(CC) $(CFLAGS_C_ALL) -Yu"Precomp.h" -Fp$O/a.pch $<
+CCOMPL = $(CC) $(CFLAGS_C_ALL) $**
+CCOMPLB = $(CC) $(CFLAGS_C_ALL) $<
+
+!IF "$(CC)" == "clang-cl"
+COMPL = $(COMPL) -FI StdAfx.h
+COMPLB = $(COMPLB) -FI StdAfx.h
+CCOMPL_USE = $(CCOMPL_USE) -FI Precomp.h
+CCOMPLB_USE = $(CCOMPLB_USE) -FI Precomp.h
+!ENDIF
+
+all: $(PROGPATH)
+
+clean:
+ -del /Q $(PROGPATH) $O\*.exe $O\*.dll $O\*.obj $O\*.lib $O\*.exp $O\*.res $O\*.pch $O\*.asm
+
+$O:
+ if not exist "$O" mkdir "$O"
+$O/asm:
+ if not exist "$O/asm" mkdir "$O/asm"
+
+!IF "$(CC)" != "clang-cl"
+# for link time code generation:
+# LFLAGS = $(LFLAGS) -LTCG
+!ENDIF
+
+$(PROGPATH): $O $O/asm $(OBJS) $(DEF_FILE)
+ link $(LFLAGS) -out:$(PROGPATH) $(OBJS) $(LIBS)
+
+!IFNDEF NO_DEFAULT_RES
+$O\resource.res: $(*B).rc
+ rc $(RFLAGS) -fo$@ $**
+!ENDIF
+$O\StdAfx.obj: $(*B).cpp
+ $(COMPL_PCH)
+
+predef: empty.c
+ $(CCOMPL) /EP /Zc:preprocessor /PD
+predef2: A.cpp
+ $(COMPL) -EP -Zc:preprocessor -PD
+predef3: A.cpp
+ $(COMPL) -E -dM
+predef4: A.cpp
+ $(COMPL_O2) -E
diff --git a/CPP/Common/AutoPtr.h b/CPP/Common/AutoPtr.h
index e53fb7f..0be8a7a 100644
--- a/CPP/Common/AutoPtr.h
+++ b/CPP/Common/AutoPtr.h
@@ -1,35 +1,35 @@
-// Common/AutoPtr.h
-
-#ifndef __COMMON_AUTOPTR_H
-#define __COMMON_AUTOPTR_H
-
-template<class T> class CMyAutoPtr
-{
- T *_p;
-public:
- CMyAutoPtr(T *p = 0) : _p(p) {}
- CMyAutoPtr(CMyAutoPtr<T>& p): _p(p.release()) {}
- CMyAutoPtr<T>& operator=(CMyAutoPtr<T>& p)
- {
- reset(p.release());
- return (*this);
- }
- ~CMyAutoPtr() { delete _p; }
- T& operator*() const { return *_p; }
- // T* operator->() const { return (&**this); }
- T* get() const { return _p; }
- T* release()
- {
- T *tmp = _p;
- _p = 0;
- return tmp;
- }
- void reset(T* p = 0)
- {
- if (p != _p)
- delete _p;
- _p = p;
- }
-};
-
-#endif
+// Common/AutoPtr.h
+
+#ifndef ZIP7_INC_COMMON_AUTOPTR_H
+#define ZIP7_INC_COMMON_AUTOPTR_H
+
+template<class T> class CMyAutoPtr
+{
+ T *_p;
+public:
+ CMyAutoPtr(T *p = NULL) : _p(p) {}
+ CMyAutoPtr(CMyAutoPtr<T>& p): _p(p.release()) {}
+ CMyAutoPtr<T>& operator=(CMyAutoPtr<T>& p)
+ {
+ reset(p.release());
+ return (*this);
+ }
+ ~CMyAutoPtr() { delete _p; }
+ T& operator*() const { return *_p; }
+ // T* operator->() const { return (&**this); }
+ T* get() const { return _p; }
+ T* release()
+ {
+ T *tmp = _p;
+ _p = NULL;
+ return tmp;
+ }
+ void reset(T* p = NULL)
+ {
+ if (p != _p)
+ delete _p;
+ _p = p;
+ }
+};
+
+#endif
diff --git a/CPP/Common/CRC.cpp b/CPP/Common/CRC.cpp
index 6ac52c4..c6b7d5e 100644
--- a/CPP/Common/CRC.cpp
+++ b/CPP/Common/CRC.cpp
@@ -1,7 +1,7 @@
-// Common/CRC.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/7zCrc.h"
-
-struct CCRCTableInit { CCRCTableInit() { CrcGenerateTable(); } } g_CRCTableInit;
+// Common/CRC.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/7zCrc.h"
+
+static struct CCRCTableInit { CCRCTableInit() { CrcGenerateTable(); } } g_CRCTableInit;
diff --git a/CPP/Common/C_FileIO.cpp b/CPP/Common/C_FileIO.cpp
index d68a427..4bd3fad 100644
--- a/CPP/Common/C_FileIO.cpp
+++ b/CPP/Common/C_FileIO.cpp
@@ -1,92 +1,3 @@
-// Common/C_FileIO.cpp
-
-#include "C_FileIO.h"
-
-#include <fcntl.h>
-#ifdef _WIN32
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
-
-namespace NC {
-namespace NFile {
-namespace NIO {
-
-bool CFileBase::OpenBinary(const char *name, int flags)
-{
- #ifdef O_BINARY
- flags |= O_BINARY;
- #endif
- Close();
- _handle = ::open(name, flags, 0666);
- return _handle != -1;
-}
-
-bool CFileBase::Close()
-{
- if (_handle == -1)
- return true;
- if (close(_handle) != 0)
- return false;
- _handle = -1;
- return true;
-}
-
-bool CFileBase::GetLength(UInt64 &length) const
-{
- off_t curPos = Seek(0, SEEK_CUR);
- off_t lengthTemp = Seek(0, SEEK_END);
- Seek(curPos, SEEK_SET);
- length = (UInt64)lengthTemp;
- return true;
-}
-
-off_t CFileBase::Seek(off_t distanceToMove, int moveMethod) const
-{
- return ::lseek(_handle, distanceToMove, moveMethod);
-}
-
-/////////////////////////
-// CInFile
-
-bool CInFile::Open(const char *name)
-{
- return CFileBase::OpenBinary(name, O_RDONLY);
-}
-
-bool CInFile::OpenShared(const char *name, bool)
-{
- return Open(name);
-}
-
-ssize_t CInFile::Read(void *data, size_t size)
-{
- return read(_handle, data, size);
-}
-
-/////////////////////////
-// COutFile
-
-bool COutFile::Create(const char *name, bool createAlways)
-{
- if (createAlways)
- {
- Close();
- _handle = ::creat(name, 0666);
- return _handle != -1;
- }
- return OpenBinary(name, O_CREAT | O_EXCL | O_WRONLY);
-}
-
-bool COutFile::Open(const char *name, DWORD creationDisposition)
-{
- return Create(name, false);
-}
-
-ssize_t COutFile::Write(const void *data, size_t size)
-{
- return write(_handle, data, size);
-}
-
-}}}
+// Common/C_FileIO.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/Common/C_FileIO.h b/CPP/Common/C_FileIO.h
index 4c400b4..12d9439 100644
--- a/CPP/Common/C_FileIO.h
+++ b/CPP/Common/C_FileIO.h
@@ -1,53 +1,6 @@
-// Common/C_FileIO.h
-
-#ifndef __COMMON_C_FILEIO_H
-#define __COMMON_C_FILEIO_H
-
-#include <stdio.h>
-#include <sys/types.h>
-
-#include "MyTypes.h"
-#include "MyWindows.h"
-
-#ifdef _WIN32
-#ifdef _MSC_VER
-typedef size_t ssize_t;
-#endif
-#endif
-
-namespace NC {
-namespace NFile {
-namespace NIO {
-
-class CFileBase
-{
-protected:
- int _handle;
- bool OpenBinary(const char *name, int flags);
-public:
- CFileBase(): _handle(-1) {};
- ~CFileBase() { Close(); }
- bool Close();
- bool GetLength(UInt64 &length) const;
- off_t Seek(off_t distanceToMove, int moveMethod) const;
-};
-
-class CInFile: public CFileBase
-{
-public:
- bool Open(const char *name);
- bool OpenShared(const char *name, bool shareForWrite);
- ssize_t Read(void *data, size_t size);
-};
-
-class COutFile: public CFileBase
-{
-public:
- bool Create(const char *name, bool createAlways);
- bool Open(const char *name, DWORD creationDisposition);
- ssize_t Write(const void *data, size_t size);
-};
-
-}}}
-
-#endif
+// Common/C_FileIO.h
+
+#ifndef ZIP7_INC_COMMON_C_FILEIO_H
+#define ZIP7_INC_COMMON_C_FILEIO_H
+
+#endif
diff --git a/CPP/Common/CksumReg.cpp b/CPP/Common/CksumReg.cpp
new file mode 100644
index 0000000..8c9c449
--- /dev/null
+++ b/CPP/Common/CksumReg.cpp
@@ -0,0 +1,55 @@
+// CksumReg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+#include "../7zip/Compress/BZip2Crc.h"
+
+Z7_CLASS_IMP_COM_1(
+ CCksumHasher
+ , IHasher
+)
+ CBZip2Crc _crc;
+ UInt64 _size;
+public:
+ // Byte _mtDummy[1 << 7];
+ CCksumHasher()
+ {
+ _crc.Init(0);
+ _size = 0;
+ }
+};
+
+Z7_COM7F_IMF2(void, CCksumHasher::Init())
+{
+ _crc.Init(0);
+ _size = 0;
+}
+
+Z7_COM7F_IMF2(void, CCksumHasher::Update(const void *data, UInt32 size))
+{
+ _size += size;
+ CBZip2Crc crc = _crc;
+ for (UInt32 i = 0; i < size; i++)
+ crc.UpdateByte(((const Byte *)data)[i]);
+ _crc = crc;
+}
+
+Z7_COM7F_IMF2(void, CCksumHasher::Final(Byte *digest))
+{
+ UInt64 size = _size;
+ CBZip2Crc crc = _crc;
+ while (size)
+ {
+ crc.UpdateByte((Byte)size);
+ size >>= 8;
+ }
+ const UInt32 val = crc.GetDigest();
+ SetUi32(digest, val)
+}
+
+REGISTER_HASHER(CCksumHasher, 0x203, "CKSUM", 4)
diff --git a/CPP/Common/ComTry.h b/CPP/Common/ComTry.h
index e6b514d..84746a7 100644
--- a/CPP/Common/ComTry.h
+++ b/CPP/Common/ComTry.h
@@ -1,21 +1,21 @@
-// ComTry.h
-
-#ifndef __COM_TRY_H
-#define __COM_TRY_H
-
-#include "MyWindows.h"
-// #include "Exception.h"
-// #include "NewHandler.h"
-
-#define COM_TRY_BEGIN try {
-#define COM_TRY_END } catch(...) { return E_OUTOFMEMORY; }
-
-/*
-#define COM_TRY_END } \
- catch(const CNewException &) { return E_OUTOFMEMORY; } \
- catch(...) { return HRESULT_FROM_WIN32(ERROR_NOACCESS); } \
-*/
- // catch(const CSystemException &e) { return e.ErrorCode; }
- // catch(...) { return E_FAIL; }
-
-#endif
+// ComTry.h
+
+#ifndef ZIP7_INC_COM_TRY_H
+#define ZIP7_INC_COM_TRY_H
+
+#include "MyWindows.h"
+// #include "Exception.h"
+// #include "NewHandler.h"
+
+#define COM_TRY_BEGIN try {
+#define COM_TRY_END } catch(...) { return E_OUTOFMEMORY; }
+
+/*
+#define COM_TRY_END } \
+ catch(const CNewException &) { return E_OUTOFMEMORY; } \
+ catch(...) { return HRESULT_FROM_WIN32(ERROR_NOACCESS); } \
+*/
+ // catch(const CSystemException &e) { return e.ErrorCode; }
+ // catch(...) { return E_FAIL; }
+
+#endif
diff --git a/CPP/Common/CommandLineParser.cpp b/CPP/Common/CommandLineParser.cpp
index 94aabce..465e0fd 100644
--- a/CPP/Common/CommandLineParser.cpp
+++ b/CPP/Common/CommandLineParser.cpp
@@ -1,197 +1,197 @@
-// CommandLineParser.cpp
-
-#include "StdAfx.h"
-
-#include "CommandLineParser.h"
-
-namespace NCommandLineParser {
-
-bool SplitCommandLine(const UString &src, UString &dest1, UString &dest2)
-{
- dest1.Empty();
- dest2.Empty();
- bool quoteMode = false;
- unsigned i;
- for (i = 0; i < src.Len(); i++)
- {
- wchar_t c = src[i];
- if ((c == L' ' || c == L'\t') && !quoteMode)
- {
- dest2 = src.Ptr(i + 1);
- return i != 0;
- }
- if (c == L'\"')
- quoteMode = !quoteMode;
- else
- dest1 += c;
- }
- return i != 0;
-}
-
-void SplitCommandLine(const UString &s, UStringVector &parts)
-{
- UString sTemp (s);
- sTemp.Trim();
- parts.Clear();
- for (;;)
- {
- UString s1, s2;
- if (SplitCommandLine(sTemp, s1, s2))
- parts.Add(s1);
- if (s2.IsEmpty())
- break;
- sTemp = s2;
- }
-}
-
-
-static const char * const kStopSwitchParsing = "--";
-
-static bool inline IsItSwitchChar(wchar_t c)
-{
- return (c == '-');
-}
-
-CParser::CParser():
- _switches(NULL),
- StopSwitchIndex(-1)
-{
-}
-
-CParser::~CParser()
-{
- delete []_switches;
-}
-
-
-// if (s) contains switch then function updates switch structures
-// out: true, if (s) is a switch
-bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms, unsigned numSwitches)
-{
- if (s.IsEmpty() || !IsItSwitchChar(s[0]))
- return false;
-
- unsigned pos = 1;
- unsigned switchIndex = 0;
- int maxLen = -1;
-
- for (unsigned i = 0; i < numSwitches; i++)
- {
- const char * const key = switchForms[i].Key;
- unsigned switchLen = MyStringLen(key);
- if ((int)switchLen <= maxLen || pos + switchLen > s.Len())
- continue;
- if (IsString1PrefixedByString2_NoCase_Ascii((const wchar_t *)s + pos, key))
- {
- switchIndex = i;
- maxLen = switchLen;
- }
- }
-
- if (maxLen < 0)
- {
- ErrorMessage = "Unknown switch:";
- return false;
- }
-
- pos += maxLen;
-
- CSwitchResult &sw = _switches[switchIndex];
- const CSwitchForm &form = switchForms[switchIndex];
-
- if (!form.Multi && sw.ThereIs)
- {
- ErrorMessage = "Multiple instances for switch:";
- return false;
- }
-
- sw.ThereIs = true;
-
- int rem = s.Len() - pos;
- if (rem < form.MinLen)
- {
- ErrorMessage = "Too short switch:";
- return false;
- }
-
- sw.WithMinus = false;
- sw.PostCharIndex = -1;
-
- switch (form.Type)
- {
- case NSwitchType::kMinus:
- if (rem == 1)
- {
- sw.WithMinus = (s[pos] == '-');
- if (sw.WithMinus)
- return true;
- ErrorMessage = "Incorrect switch postfix:";
- return false;
- }
- break;
-
- case NSwitchType::kChar:
- if (rem == 1)
- {
- wchar_t c = s[pos];
- if (c <= 0x7F)
- {
- sw.PostCharIndex = FindCharPosInString(form.PostCharSet, (char)c);
- if (sw.PostCharIndex >= 0)
- return true;
- }
- ErrorMessage = "Incorrect switch postfix:";
- return false;
- }
- break;
-
- case NSwitchType::kString:
- {
- sw.PostStrings.Add(s.Ptr(pos));
- return true;
- }
- }
-
- if (pos != s.Len())
- {
- ErrorMessage = "Too long switch:";
- return false;
- }
- return true;
-}
-
-
-bool CParser::ParseStrings(const CSwitchForm *switchForms, unsigned numSwitches, const UStringVector &commandStrings)
-{
- StopSwitchIndex = -1;
- ErrorMessage.Empty();
- ErrorLine.Empty();
- NonSwitchStrings.Clear();
- delete []_switches;
- _switches = NULL;
- _switches = new CSwitchResult[numSwitches];
-
- FOR_VECTOR (i, commandStrings)
- {
- const UString &s = commandStrings[i];
- if (StopSwitchIndex < 0)
- {
- if (s.IsEqualTo(kStopSwitchParsing))
- {
- StopSwitchIndex = NonSwitchStrings.Size();
- continue;
- }
- if (!s.IsEmpty() && IsItSwitchChar(s[0]))
- {
- if (ParseString(s, switchForms, numSwitches))
- continue;
- ErrorLine = s;
- return false;
- }
- }
- NonSwitchStrings.Add(s);
- }
- return true;
-}
-
-}
+// CommandLineParser.cpp
+
+#include "StdAfx.h"
+
+#include "CommandLineParser.h"
+
+namespace NCommandLineParser {
+
+bool SplitCommandLine(const UString &src, UString &dest1, UString &dest2)
+{
+ dest1.Empty();
+ dest2.Empty();
+ bool quoteMode = false;
+ unsigned i;
+ for (i = 0; i < src.Len(); i++)
+ {
+ wchar_t c = src[i];
+ if ((c == L' ' || c == L'\t') && !quoteMode)
+ {
+ dest2 = src.Ptr(i + 1);
+ return i != 0;
+ }
+ if (c == L'\"')
+ quoteMode = !quoteMode;
+ else
+ dest1 += c;
+ }
+ return i != 0;
+}
+
+void SplitCommandLine(const UString &s, UStringVector &parts)
+{
+ UString sTemp (s);
+ sTemp.Trim();
+ parts.Clear();
+ for (;;)
+ {
+ UString s1, s2;
+ if (SplitCommandLine(sTemp, s1, s2))
+ parts.Add(s1);
+ if (s2.IsEmpty())
+ break;
+ sTemp = s2;
+ }
+}
+
+
+static const char * const kStopSwitchParsing = "--";
+
+static bool inline IsItSwitchChar(wchar_t c)
+{
+ return (c == '-');
+}
+
+CParser::CParser():
+ _switches(NULL),
+ StopSwitchIndex(-1)
+{
+}
+
+CParser::~CParser()
+{
+ delete []_switches;
+}
+
+
+// if (s) contains switch then function updates switch structures
+// out: true, if (s) is a switch
+bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms, unsigned numSwitches)
+{
+ if (s.IsEmpty() || !IsItSwitchChar(s[0]))
+ return false;
+
+ unsigned pos = 1;
+ unsigned switchIndex = 0;
+ int maxLen = -1;
+
+ for (unsigned i = 0; i < numSwitches; i++)
+ {
+ const char * const key = switchForms[i].Key;
+ unsigned switchLen = MyStringLen(key);
+ if ((int)switchLen <= maxLen || pos + switchLen > s.Len())
+ continue;
+ if (IsString1PrefixedByString2_NoCase_Ascii((const wchar_t *)s + pos, key))
+ {
+ switchIndex = i;
+ maxLen = (int)switchLen;
+ }
+ }
+
+ if (maxLen < 0)
+ {
+ ErrorMessage = "Unknown switch:";
+ return false;
+ }
+
+ pos += (unsigned)maxLen;
+
+ CSwitchResult &sw = _switches[switchIndex];
+ const CSwitchForm &form = switchForms[switchIndex];
+
+ if (!form.Multi && sw.ThereIs)
+ {
+ ErrorMessage = "Multiple instances for switch:";
+ return false;
+ }
+
+ sw.ThereIs = true;
+
+ const unsigned rem = s.Len() - pos;
+ if (rem < form.MinLen)
+ {
+ ErrorMessage = "Too short switch:";
+ return false;
+ }
+
+ sw.WithMinus = false;
+ sw.PostCharIndex = -1;
+
+ switch (form.Type)
+ {
+ case NSwitchType::kMinus:
+ if (rem == 1)
+ {
+ sw.WithMinus = (s[pos] == '-');
+ if (sw.WithMinus)
+ return true;
+ ErrorMessage = "Incorrect switch postfix:";
+ return false;
+ }
+ break;
+
+ case NSwitchType::kChar:
+ if (rem == 1)
+ {
+ wchar_t c = s[pos];
+ if (c <= 0x7F)
+ {
+ sw.PostCharIndex = FindCharPosInString(form.PostCharSet, (char)c);
+ if (sw.PostCharIndex >= 0)
+ return true;
+ }
+ ErrorMessage = "Incorrect switch postfix:";
+ return false;
+ }
+ break;
+
+ case NSwitchType::kString:
+ {
+ sw.PostStrings.Add(s.Ptr(pos));
+ return true;
+ }
+ }
+
+ if (pos != s.Len())
+ {
+ ErrorMessage = "Too long switch:";
+ return false;
+ }
+ return true;
+}
+
+
+bool CParser::ParseStrings(const CSwitchForm *switchForms, unsigned numSwitches, const UStringVector &commandStrings)
+{
+ StopSwitchIndex = -1;
+ ErrorMessage.Empty();
+ ErrorLine.Empty();
+ NonSwitchStrings.Clear();
+ delete []_switches;
+ _switches = NULL;
+ _switches = new CSwitchResult[numSwitches];
+
+ FOR_VECTOR (i, commandStrings)
+ {
+ const UString &s = commandStrings[i];
+ if (StopSwitchIndex < 0)
+ {
+ if (s.IsEqualTo(kStopSwitchParsing))
+ {
+ StopSwitchIndex = (int)NonSwitchStrings.Size();
+ continue;
+ }
+ if (!s.IsEmpty() && IsItSwitchChar(s[0]))
+ {
+ if (ParseString(s, switchForms, numSwitches))
+ continue;
+ ErrorLine = s;
+ return false;
+ }
+ }
+ NonSwitchStrings.Add(s);
+ }
+ return true;
+}
+
+}
diff --git a/CPP/Common/CommandLineParser.h b/CPP/Common/CommandLineParser.h
index ec6336c..fc6f028 100644
--- a/CPP/Common/CommandLineParser.h
+++ b/CPP/Common/CommandLineParser.h
@@ -1,63 +1,63 @@
-// Common/CommandLineParser.h
-
-#ifndef __COMMON_COMMAND_LINE_PARSER_H
-#define __COMMON_COMMAND_LINE_PARSER_H
-
-#include "MyString.h"
-
-namespace NCommandLineParser {
-
-bool SplitCommandLine(const UString &src, UString &dest1, UString &dest2);
-void SplitCommandLine(const UString &s, UStringVector &parts);
-
-namespace NSwitchType
-{
- enum EEnum
- {
- kSimple,
- kMinus,
- kString,
- kChar
- };
-}
-
-struct CSwitchForm
-{
- const char *Key;
- Byte Type;
- bool Multi;
- Byte MinLen;
- // int MaxLen;
- const char *PostCharSet;
-};
-
-struct CSwitchResult
-{
- bool ThereIs;
- bool WithMinus;
- int PostCharIndex;
- UStringVector PostStrings;
-
- CSwitchResult(): ThereIs(false) {};
-};
-
-class CParser
-{
- CSwitchResult *_switches;
-
- bool ParseString(const UString &s, const CSwitchForm *switchForms, unsigned numSwitches);
-public:
- UStringVector NonSwitchStrings;
- int StopSwitchIndex; // NonSwitchStrings[StopSwitchIndex+] are after "--"
- AString ErrorMessage;
- UString ErrorLine;
-
- CParser();
- ~CParser();
- bool ParseStrings(const CSwitchForm *switchForms, unsigned numSwitches, const UStringVector &commandStrings);
- const CSwitchResult& operator[](unsigned index) const { return _switches[index]; }
-};
-
-}
-
-#endif
+// Common/CommandLineParser.h
+
+#ifndef ZIP7_INC_COMMON_COMMAND_LINE_PARSER_H
+#define ZIP7_INC_COMMON_COMMAND_LINE_PARSER_H
+
+#include "MyString.h"
+
+namespace NCommandLineParser {
+
+bool SplitCommandLine(const UString &src, UString &dest1, UString &dest2);
+void SplitCommandLine(const UString &s, UStringVector &parts);
+
+namespace NSwitchType
+{
+ enum EEnum
+ {
+ kSimple,
+ kMinus,
+ kString,
+ kChar
+ };
+}
+
+struct CSwitchForm
+{
+ const char *Key;
+ Byte Type;
+ bool Multi;
+ Byte MinLen;
+ // int MaxLen;
+ const char *PostCharSet;
+};
+
+struct CSwitchResult
+{
+ bool ThereIs;
+ bool WithMinus;
+ int PostCharIndex;
+ UStringVector PostStrings;
+
+ CSwitchResult(): ThereIs(false) {}
+};
+
+class CParser
+{
+ CSwitchResult *_switches;
+
+ bool ParseString(const UString &s, const CSwitchForm *switchForms, unsigned numSwitches);
+public:
+ UStringVector NonSwitchStrings;
+ int StopSwitchIndex; // NonSwitchStrings[StopSwitchIndex+] are after "--"
+ AString ErrorMessage;
+ UString ErrorLine;
+
+ CParser();
+ ~CParser();
+ bool ParseStrings(const CSwitchForm *switchForms, unsigned numSwitches, const UStringVector &commandStrings);
+ const CSwitchResult& operator[](unsigned index) const { return _switches[index]; }
+};
+
+}
+
+#endif
diff --git a/CPP/Common/Common.h b/CPP/Common/Common.h
index c1ecc7e..0c77ab4 100644
--- a/CPP/Common/Common.h
+++ b/CPP/Common/Common.h
@@ -1,43 +1,313 @@
-// Common.h
-
-#ifndef __COMMON_COMMON_H
-#define __COMMON_COMMON_H
-
-/*
-This file is included to all cpp files in 7-Zip.
-Each folder contains StdAfx.h file that includes "Common.h".
-So 7-Zip includes "Common.h" in both modes:
- with precompiled StdAfx.h
-and
- without precompiled StdAfx.h
-
-If you use 7-Zip code, you must include "Common.h" before other h files of 7-zip.
-If you don't need some things that are used in 7-Zip,
-you can change this h file or h files included in this file.
-*/
-
-// compiler pragmas to disable some warnings
-#include "../../C/Compiler.h"
-
-// it's <windows.h> or code that defines windows things, if it's not _WIN32
-#include "MyWindows.h"
-
-// NewHandler.h and NewHandler.cpp redefine operator new() to throw exceptions, if compiled with old MSVC compilers
-#include "NewHandler.h"
-
-
-
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
-
-
-/* There is BUG in MSVC 6.0 compiler for operator new[]:
- It doesn't check overflow, when it calculates size in bytes for allocated array.
- So we can use MY_ARRAY_NEW macro instead of new[] operator. */
-
-#if defined(_MSC_VER) && (_MSC_VER == 1200) && !defined(_WIN64)
- #define MY_ARRAY_NEW(p, T, size) p = new T[(size > (unsigned)0xFFFFFFFF / sizeof(T)) ? (unsigned)0xFFFFFFFF / sizeof(T) : size];
-#else
- #define MY_ARRAY_NEW(p, T, size) p = new T[size];
-#endif
-
-#endif
+// Common.h
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#ifndef ZIP7_INC_COMMON_H
+#define ZIP7_INC_COMMON_H
+
+#include "../../C/Compiler.h"
+
+/*
+This file is included to all cpp files in 7-Zip.
+Each folder contains StdAfx.h file that includes "Common.h".
+So 7-Zip includes "Common.h" in both modes:
+ with precompiled StdAfx.h
+and
+ without precompiled StdAfx.h
+
+If you use 7-Zip code, you must include "Common.h" before other h files of 7-zip.
+If you don't need some things that are used in 7-Zip,
+you can change this h file or h files included in this file.
+*/
+
+#ifdef _MSC_VER
+ #pragma warning(disable : 4710) // function not inlined
+ // 'CUncopyable::CUncopyable':
+ #pragma warning(disable : 4514) // unreferenced inline function has been removed
+ #if _MSC_VER < 1300
+ #pragma warning(disable : 4702) // unreachable code
+ #pragma warning(disable : 4714) // function marked as __forceinline not inlined
+ #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
+ #endif
+ #if _MSC_VER < 1400
+ #pragma warning(disable : 4511) // copy constructor could not be generated // #pragma warning(disable : 4512) // assignment operator could not be generated
+ #pragma warning(disable : 4512) // assignment operator could not be generated
+ #endif
+ #if _MSC_VER > 1400 && _MSC_VER <= 1900
+ // #pragma warning(disable : 4996)
+ // strcat: This function or variable may be unsafe
+ // GetVersion was declared deprecated
+ #endif
+
+#if _MSC_VER > 1200
+// -Wall warnings
+
+#if _MSC_VER <= 1600
+#pragma warning(disable : 4917) // 'OLE_HANDLE' : a GUID can only be associated with a class, interface or namespace
+#endif
+
+// #pragma warning(disable : 4061) // enumerator '' in switch of enum '' is not explicitly handled by a case label
+// #pragma warning(disable : 4266) // no override available for virtual member function from base ''; function is hidden
+#pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+#pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+#if _MSC_VER >= 1600 && _MSC_VER < 1920
+#pragma warning(disable : 4571) // Informational: catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught
+#endif
+#if _MSC_VER >= 1600
+#pragma warning(disable : 4365) // 'initializing' : conversion from 'int' to 'unsigned int', signed / unsigned mismatch
+#endif
+#if _MSC_VER < 1800
+// we disable the warning, if we don't use 'final' in class
+#pragma warning(disable : 4265) // class has virtual functions, but destructor is not virtual
+#endif
+
+#if _MSC_VER >= 1900
+#pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+#pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+#endif
+#if _MSC_VER >= 1912
+#pragma warning(disable : 5039) // pointer or reference to potentially throwing function passed to 'extern "C"' function under - EHc.Undefined behavior may occur if this function throws an exception.
+#endif
+#if _MSC_VER >= 1925
+// #pragma warning(disable : 5204) // 'ISequentialInStream' : class has virtual functions, but its trivial destructor is not virtual; instances of objects derived from this class may not be destructed correctly
+#endif
+#if _MSC_VER >= 1934
+// #pragma warning(disable : 5264) // const variable is not used
+#endif
+
+#endif // _MSC_VER > 1200
+#endif // _MSC_VER
+
+
+#if defined(_MSC_VER) // && !defined(__clang__)
+#define Z7_DECLSPEC_NOTHROW __declspec(nothrow)
+#elif defined(__clang__) || defined(__GNUC__)
+#define Z7_DECLSPEC_NOTHROW __attribute__((nothrow))
+#else
+#define Z7_DECLSPEC_NOTHROW
+#endif
+
+/*
+#if defined (_MSC_VER) && _MSC_VER >= 1900 \
+ || defined(__clang__) && __clang_major__ >= 6 \
+ || defined(__GNUC__) && __GNUC__ >= 6
+ #define Z7_noexcept noexcept
+#else
+ #define Z7_noexcept throw()
+#endif
+*/
+
+
+#if defined(__clang__)
+
+// noexcept, final, = delete
+#pragma GCC diagnostic ignored "-Wc++98-compat"
+#if __clang_major__ >= 4
+// throw() dynamic exception specifications are deprecated
+#pragma GCC diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wglobal-constructors"
+#pragma GCC diagnostic ignored "-Wexit-time-destructors"
+
+// #pragma GCC diagnostic ignored "-Wunused-private-field"
+// #pragma GCC diagnostic ignored "-Wnonportable-system-include-path"
+// #pragma GCC diagnostic ignored "-Wsuggest-override"
+// #pragma GCC diagnostic ignored "-Wsign-conversion"
+// #pragma GCC diagnostic ignored "-Winconsistent-missing-override"
+// #pragma GCC diagnostic ignored "-Wsuggest-destructor-override"
+// #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-with-user-provided-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-dtor"
+// #ifndef _WIN32
+// #pragma GCC diagnostic ignored "-Wweak-vtables"
+// #endif
+/*
+#if defined(Z7_GCC_VERSION) && (Z7_GCC_VERSION >= 40400) \
+ || defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30000)
+// enumeration values not explicitly handled in switch
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+*/
+#endif // __clang__
+
+
+#ifdef __GNUC__
+// #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
+
+
+/* There is BUG in MSVC 6.0 compiler for operator new[]:
+ It doesn't check overflow, when it calculates size in bytes for allocated array.
+ So we can use Z7_ARRAY_NEW macro instead of new[] operator. */
+
+#if defined(_MSC_VER) && (_MSC_VER == 1200) && !defined(_WIN64)
+ #define Z7_ARRAY_NEW(p, T, size) p = new T[((size) > (unsigned)0xFFFFFFFF / sizeof(T)) ? (unsigned)0xFFFFFFFF / sizeof(T) : (size)];
+#else
+ #define Z7_ARRAY_NEW(p, T, size) p = new T[size];
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ >= 8))
+ #define Z7_ATTR_NORETURN __attribute__((noreturn))
+#elif (defined(__clang__) && (__clang_major__ >= 3))
+ #if __has_feature(cxx_attributes)
+ #define Z7_ATTR_NORETURN [[noreturn]]
+ #else
+ #define Z7_ATTR_NORETURN __attribute__((noreturn))
+ #endif
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1900))
+ #define Z7_ATTR_NORETURN [[noreturn]]
+#else
+ #define Z7_ATTR_NORETURN
+#endif
+
+
+// final in "GCC 4.7.0"
+// In C++98 and C++03 code the alternative spelling __final can be used instead (this is a GCC extension.)
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+ || defined(_MSC_VER) && _MSC_VER >= 1800 \
+ || defined(__clang__) && __clang_major__ >= 4 \
+ /* || defined(__GNUC__) && __GNUC__ >= 9 */
+ #define Z7_final final
+ #if defined(__clang__) && __cplusplus < 201103L
+ #pragma GCC diagnostic ignored "-Wc++11-extensions"
+ #endif
+#elif defined (__cplusplus) && __cplusplus >= 199711L \
+ && defined(__GNUC__) && __GNUC__ >= 4 && !defined(__clang__)
+ #define Z7_final __final
+#else
+ #define Z7_final
+ #if defined(__clang__) && __clang_major__ >= 4 \
+ || defined(__GNUC__) && __GNUC__ >= 4
+ #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+ #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+ #endif
+#endif
+
+#define Z7_class_final(c) class c Z7_final
+
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+ || (defined(_MSC_VER) && _MSC_VER >= 1800)
+ #define Z7_CPP_IS_SUPPORTED_default
+ #define Z7_eq_delete = delete
+ // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c) c(const c& k) = default;
+#else
+ #define Z7_eq_delete
+ // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c)
+#endif
+
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L) \
+ || defined(_MSC_VER) && (_MSC_VER >= 1400) /* && (_MSC_VER != 1600) */ \
+ || defined(__clang__) && __clang_major__ >= 4
+ #if defined(_MSC_VER) && (_MSC_VER == 1600) /* && (_MSC_VER != 1600) */
+ #pragma warning(disable : 4481) // nonstandard extension used: override specifier 'override'
+ #define Z7_DESTRUCTOR_override
+ #else
+ #define Z7_DESTRUCTOR_override override
+ #endif
+ #define Z7_override override
+#else
+ #define Z7_override
+ #define Z7_DESTRUCTOR_override
+#endif
+
+
+
+#define Z7_CLASS_NO_COPY(cls) \
+ private: \
+ cls(const cls &) Z7_eq_delete; \
+ cls &operator=(const cls &) Z7_eq_delete;
+
+class CUncopyable
+{
+protected:
+ CUncopyable() {} // allow constructor
+ // ~CUncopyable() {}
+ Z7_CLASS_NO_COPY(CUncopyable)
+};
+
+#define MY_UNCOPYABLE :private CUncopyable
+// #define MY_UNCOPYABLE
+
+
+typedef void (*Z7_void_Function)(void);
+
+#if defined(__clang__) || defined(__GNUC__)
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<Z7_void_Function>(e))
+#else
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<void*>(e))
+// #define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(e)
+#endif
+
+#define Z7_GET_PROC_ADDRESS(func_type, hmodule, func_name) \
+ Z7_CAST_FUNC(func_type, GetProcAddress(hmodule, func_name))
+
+// || defined(__clang__)
+// || defined(__GNUC__)
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define Z7_DECLSPEC_NOVTABLE __declspec(novtable)
+#else
+#define Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifdef __clang__
+#define Z7_PURE_INTERFACES_BEGIN \
+_Pragma("GCC diagnostic push") \
+_Pragma("GCC diagnostic ignored \"-Wnon-virtual-dtor\"")
+_Pragma("GCC diagnostic ignored \"-Wweak-vtables\"")
+#define Z7_PURE_INTERFACES_END \
+_Pragma("GCC diagnostic pop")
+#else
+#define Z7_PURE_INTERFACES_BEGIN
+#define Z7_PURE_INTERFACES_END
+#endif
+
+// NewHandler.h and NewHandler.cpp redefine operator new() to throw exceptions, if compiled with old MSVC compilers
+#include "NewHandler.h"
+
+/*
+// #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a) Z7_ARRAY_SIZE(a)
+#endif
+*/
+
+#endif // ZIP7_INC_COMMON_H
+
+
+
+// #define Z7_REDEFINE_NULL
+
+#if defined(Z7_REDEFINE_NULL) /* && (!defined(__clang__) || defined(_MSC_VER)) */
+
+// NULL is defined in <stddef.h>
+#include <stddef.h>
+#undef NULL
+
+#ifdef __cplusplus
+ #if defined (__cplusplus) && __cplusplus >= 201103L \
+ || (defined(_MSC_VER) && _MSC_VER >= 1800)
+ #define NULL nullptr
+ #else
+ #define NULL 0
+ #endif
+#else
+ #define NULL ((void *)0)
+#endif
+
+#else // Z7_REDEFINE_NULL
+
+#if defined(__clang__) && __clang_major__ >= 5
+#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+
+#endif // Z7_REDEFINE_NULL
+
+// for precompiler:
+#include "MyWindows.h"
diff --git a/CPP/Common/CrcReg.cpp b/CPP/Common/CrcReg.cpp
index 1d9d009..6cda892 100644
--- a/CPP/Common/CrcReg.cpp
+++ b/CPP/Common/CrcReg.cpp
@@ -1,98 +1,92 @@
-// CrcReg.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/7zCrc.h"
-#include "../../C/CpuArch.h"
-
-#include "../Common/MyCom.h"
-
-#include "../7zip/Common/RegisterCodec.h"
-
-EXTERN_C_BEGIN
-
-typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-extern CRC_FUNC g_CrcUpdate;
-extern CRC_FUNC g_CrcUpdateT8;
-extern CRC_FUNC g_CrcUpdateT4;
-
-EXTERN_C_END
-
-class CCrcHasher:
- public IHasher,
- public ICompressSetCoderProperties,
- public CMyUnknownImp
-{
- UInt32 _crc;
- CRC_FUNC _updateFunc;
- Byte mtDummy[1 << 7];
-
- bool SetFunctions(UInt32 tSize);
-public:
- CCrcHasher(): _crc(CRC_INIT_VAL) { SetFunctions(0); }
-
- MY_UNKNOWN_IMP2(IHasher, ICompressSetCoderProperties)
- INTERFACE_IHasher(;)
- STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
-};
-
-bool CCrcHasher::SetFunctions(UInt32 tSize)
-{
- _updateFunc = g_CrcUpdate;
-
- if (tSize == 1)
- _updateFunc = CrcUpdateT1;
- else if (tSize == 4)
- {
- if (g_CrcUpdateT4)
- _updateFunc = g_CrcUpdateT4;
- else
- return false;
- }
- else if (tSize == 8)
- {
- if (g_CrcUpdateT8)
- _updateFunc = g_CrcUpdateT8;
- else
- return false;
- }
-
- return true;
-}
-
-STDMETHODIMP CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
-{
- for (UInt32 i = 0; i < numProps; i++)
- {
- const PROPVARIANT &prop = coderProps[i];
- if (propIDs[i] == NCoderPropID::kDefaultProp)
- {
- if (prop.vt != VT_UI4)
- return E_INVALIDARG;
- if (!SetFunctions(prop.ulVal))
- return E_NOTIMPL;
- }
- }
- return S_OK;
-}
-
-STDMETHODIMP_(void) CCrcHasher::Init() throw()
-{
- _crc = CRC_INIT_VAL;
-}
-
-STDMETHODIMP_(void) CCrcHasher::Update(const void *data, UInt32 size) throw()
-{
- _crc = _updateFunc(_crc, data, size, g_CrcTable);
-}
-
-STDMETHODIMP_(void) CCrcHasher::Final(Byte *digest) throw()
-{
- UInt32 val = CRC_GET_DIGEST(_crc);
- SetUi32(digest, val);
-}
-
-REGISTER_HASHER(CCrcHasher, 0x1, "CRC32", 4)
+// CrcReg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/7zCrc.h"
+#include "../../C/CpuArch.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+EXTERN_C_BEGIN
+
+// UInt32 Z7_FASTCALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
+
+extern CRC_FUNC g_CrcUpdate;
+// extern CRC_FUNC g_CrcUpdateT4;
+extern CRC_FUNC g_CrcUpdateT8;
+extern CRC_FUNC g_CrcUpdateT0_32;
+extern CRC_FUNC g_CrcUpdateT0_64;
+
+EXTERN_C_END
+
+Z7_CLASS_IMP_COM_2(
+ CCrcHasher
+ , IHasher
+ , ICompressSetCoderProperties
+)
+ UInt32 _crc;
+ CRC_FUNC _updateFunc;
+
+ Z7_CLASS_NO_COPY(CCrcHasher)
+
+ bool SetFunctions(UInt32 tSize);
+public:
+ Byte _mtDummy[1 << 7]; // it's public to eliminate clang warning: unused private field
+
+ CCrcHasher(): _crc(CRC_INIT_VAL) { SetFunctions(0); }
+};
+
+bool CCrcHasher::SetFunctions(UInt32 tSize)
+{
+ CRC_FUNC f = NULL;
+ if (tSize == 0) f = g_CrcUpdate;
+ // else if (tSize == 1) f = CrcUpdateT1;
+ // else if (tSize == 4) f = g_CrcUpdateT4;
+ else if (tSize == 8) f = g_CrcUpdateT8;
+ else if (tSize == 32) f = g_CrcUpdateT0_32;
+ else if (tSize == 64) f = g_CrcUpdateT0_64;
+
+ if (!f)
+ {
+ _updateFunc = g_CrcUpdate;
+ return false;
+ }
+ _updateFunc = f;
+ return true;
+}
+
+Z7_COM7F_IMF(CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ if (propIDs[i] == NCoderPropID::kDefaultProp)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ if (!SetFunctions(prop.ulVal))
+ return E_NOTIMPL;
+ }
+ }
+ return S_OK;
+}
+
+Z7_COM7F_IMF2(void, CCrcHasher::Init())
+{
+ _crc = CRC_INIT_VAL;
+}
+
+Z7_COM7F_IMF2(void, CCrcHasher::Update(const void *data, UInt32 size))
+{
+ _crc = _updateFunc(_crc, data, size, g_CrcTable);
+}
+
+Z7_COM7F_IMF2(void, CCrcHasher::Final(Byte *digest))
+{
+ const UInt32 val = CRC_GET_DIGEST(_crc);
+ SetUi32(digest, val)
+}
+
+REGISTER_HASHER(CCrcHasher, 0x1, "CRC32", 4)
diff --git a/CPP/Common/Defs.h b/CPP/Common/Defs.h
index 9416098..e302f35 100644
--- a/CPP/Common/Defs.h
+++ b/CPP/Common/Defs.h
@@ -1,15 +1,16 @@
-// Common/Defs.h
-
-#ifndef __COMMON_DEFS_H
-#define __COMMON_DEFS_H
-
-template <class T> inline T MyMin(T a, T b) { return a < b ? a : b; }
-template <class T> inline T MyMax(T a, T b) { return a > b ? a : b; }
-
-template <class T> inline int MyCompare(T a, T b)
- { return a == b ? 0 : (a < b ? -1 : 1); }
-
-inline int BoolToInt(bool v) { return (v ? 1 : 0); }
-inline bool IntToBool(int v) { return (v != 0); }
-
-#endif
+// Common/Defs.h
+
+#ifndef ZIP7_INC_COMMON_DEFS_H
+#define ZIP7_INC_COMMON_DEFS_H
+
+template <class T> inline T MyMin(T a, T b) { return a < b ? a : b; }
+template <class T> inline T MyMax(T a, T b) { return a > b ? a : b; }
+
+template <class T> inline int MyCompare(T a, T b)
+ { return a == b ? 0 : (a < b ? -1 : 1); }
+
+inline int BoolToInt(bool v) { return (v ? 1 : 0); }
+inline unsigned BoolToUInt(bool v) { return (v ? 1u : 0u); }
+inline bool IntToBool(int v) { return (v != 0); }
+
+#endif
diff --git a/CPP/Common/DynLimBuf.cpp b/CPP/Common/DynLimBuf.cpp
new file mode 100644
index 0000000..1d92af3
--- /dev/null
+++ b/CPP/Common/DynLimBuf.cpp
@@ -0,0 +1,93 @@
+// Common/DynLimBuf.cpp
+
+#include "StdAfx.h"
+
+#include "DynLimBuf.h"
+#include "MyString.h"
+
+CDynLimBuf::CDynLimBuf(size_t limit) throw()
+{
+ _chars = NULL;
+ _pos = 0;
+ _size = 0;
+ _sizeLimit = limit;
+ _error = true;
+ unsigned size = 1 << 4;
+ if (size > limit)
+ size = (unsigned)limit;
+ _chars = (Byte *)MyAlloc(size);
+ if (_chars)
+ {
+ _size = size;
+ _error = false;
+ }
+}
+
+CDynLimBuf & CDynLimBuf::operator+=(char c) throw()
+{
+ if (_error)
+ return *this;
+ if (_size == _pos)
+ {
+ size_t n = _sizeLimit - _size;
+ if (n == 0)
+ {
+ _error = true;
+ return *this;
+ }
+ if (n > _size)
+ n = _size;
+
+ n += _pos;
+
+ Byte *newBuf = (Byte *)MyAlloc(n);
+ if (!newBuf)
+ {
+ _error = true;
+ return *this;
+ }
+ memcpy(newBuf, _chars, _pos);
+ MyFree(_chars);
+ _chars = newBuf;
+ _size = n;
+ }
+ _chars[_pos++] = (Byte)c;
+ return *this;
+}
+
+CDynLimBuf &CDynLimBuf::operator+=(const char *s) throw()
+{
+ if (_error)
+ return *this;
+ unsigned len = MyStringLen(s);
+ size_t rem = _sizeLimit - _pos;
+ if (rem < len)
+ {
+ len = (unsigned)rem;
+ _error = true;
+ }
+ if (_size - _pos < len)
+ {
+ size_t n = _pos + len;
+ if (n - _size < _size)
+ {
+ n = _sizeLimit;
+ if (n - _size > _size)
+ n = _size * 2;
+ }
+
+ Byte *newBuf = (Byte *)MyAlloc(n);
+ if (!newBuf)
+ {
+ _error = true;
+ return *this;
+ }
+ memcpy(newBuf, _chars, _pos);
+ MyFree(_chars);
+ _chars = newBuf;
+ _size = n;
+ }
+ memcpy(_chars + _pos, s, len);
+ _pos += len;
+ return *this;
+}
diff --git a/CPP/Common/DynLimBuf.h b/CPP/Common/DynLimBuf.h
new file mode 100644
index 0000000..af22f07
--- /dev/null
+++ b/CPP/Common/DynLimBuf.h
@@ -0,0 +1,41 @@
+// Common/DynLimBuf.h
+
+#ifndef ZIP7_INC_COMMON_DYN_LIM_BUF_H
+#define ZIP7_INC_COMMON_DYN_LIM_BUF_H
+
+#include <string.h>
+
+#include "../../C/Alloc.h"
+
+#include "MyString.h"
+
+class CDynLimBuf
+{
+ Byte *_chars;
+ size_t _pos;
+ size_t _size;
+ size_t _sizeLimit;
+ bool _error;
+
+ CDynLimBuf(const CDynLimBuf &s);
+
+ // ---------- forbidden functions ----------
+ CDynLimBuf &operator+=(wchar_t c);
+
+public:
+ CDynLimBuf(size_t limit) throw();
+ ~CDynLimBuf() { MyFree(_chars); }
+
+ size_t Len() const { return _pos; }
+ bool IsError() const { return _error; }
+ void Empty() { _pos = 0; _error = false; }
+
+ operator const Byte *() const { return _chars; }
+ // const char *Ptr() const { return _chars; }
+
+ CDynLimBuf &operator+=(char c) throw();
+ CDynLimBuf &operator+=(const char *s) throw();
+};
+
+
+#endif
diff --git a/CPP/Common/DynamicBuffer.h b/CPP/Common/DynamicBuffer.h
index 16c9250..714be4a 100644
--- a/CPP/Common/DynamicBuffer.h
+++ b/CPP/Common/DynamicBuffer.h
@@ -1,64 +1,68 @@
-// Common/DynamicBuffer.h
-
-#ifndef __COMMON_DYNAMIC_BUFFER_H
-#define __COMMON_DYNAMIC_BUFFER_H
-
-template <class T> class CDynamicBuffer
-{
- T *_items;
- size_t _size;
- size_t _pos;
-
- CDynamicBuffer(const CDynamicBuffer &buffer);
- void operator=(const CDynamicBuffer &buffer);
-
- void Grow(size_t size)
- {
- size_t delta = _size >= 64 ? _size : 64;
- if (delta < size)
- delta = size;
- size_t newCap = _size + delta;
- if (newCap < delta)
- {
- newCap = _size + size;
- if (newCap < size)
- throw 20120116;
- }
-
- T *newBuffer = new T[newCap];
- if (_pos != 0)
- memcpy(newBuffer, _items, _pos * sizeof(T));
- delete []_items;
- _items = newBuffer;
- _size = newCap;
- }
-
-public:
- CDynamicBuffer(): _items(0), _size(0), _pos(0) {}
- // operator T *() { return _items; }
- operator const T *() const { return _items; }
- ~CDynamicBuffer() { delete []_items; }
-
- T *GetCurPtrAndGrow(size_t addSize)
- {
- size_t rem = _size - _pos;
- if (rem < addSize)
- Grow(addSize - rem);
- T *res = _items + _pos;
- _pos += addSize;
- return res;
- }
-
- void AddData(const T *data, size_t size)
- {
- memcpy(GetCurPtrAndGrow(size), data, size * sizeof(T));
- }
-
- const size_t GetPos() const { return _pos; }
-
- // void Empty() { _pos = 0; }
-};
-
-typedef CDynamicBuffer<unsigned char> CByteDynamicBuffer;
-
-#endif
+// Common/DynamicBuffer.h
+
+#ifndef ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
+#define ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
+
+#include <string.h>
+
+#include "Common.h"
+
+template <class T> class CDynamicBuffer
+{
+ T *_items;
+ size_t _size;
+ size_t _pos;
+
+ CDynamicBuffer(const CDynamicBuffer &buffer);
+ void operator=(const CDynamicBuffer &buffer);
+
+ void Grow(size_t size)
+ {
+ size_t delta = _size >= 64 ? _size : 64;
+ if (delta < size)
+ delta = size;
+ size_t newCap = _size + delta;
+ if (newCap < delta)
+ {
+ newCap = _size + size;
+ if (newCap < size)
+ throw 20120116;
+ }
+
+ T *newBuffer = new T[newCap];
+ if (_pos != 0)
+ memcpy(newBuffer, _items, _pos * sizeof(T));
+ delete []_items;
+ _items = newBuffer;
+ _size = newCap;
+ }
+
+public:
+ CDynamicBuffer(): _items(NULL), _size(0), _pos(0) {}
+ // operator T *() { return _items; }
+ operator const T *() const { return _items; }
+ ~CDynamicBuffer() { delete []_items; }
+
+ T *GetCurPtrAndGrow(size_t addSize)
+ {
+ size_t rem = _size - _pos;
+ if (rem < addSize)
+ Grow(addSize - rem);
+ T *res = _items + _pos;
+ _pos += addSize;
+ return res;
+ }
+
+ void AddData(const T *data, size_t size)
+ {
+ memcpy(GetCurPtrAndGrow(size), data, size * sizeof(T));
+ }
+
+ size_t GetPos() const { return _pos; }
+
+ // void Empty() { _pos = 0; }
+};
+
+typedef CDynamicBuffer<unsigned char> CByteDynamicBuffer;
+
+#endif
diff --git a/CPP/Common/IntToString.cpp b/CPP/Common/IntToString.cpp
index da627ca..21b0680 100644
--- a/CPP/Common/IntToString.cpp
+++ b/CPP/Common/IntToString.cpp
@@ -1,193 +1,192 @@
-// Common/IntToString.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/CpuArch.h"
-
-#include "IntToString.h"
-
-#define CONVERT_INT_TO_STR(charType, tempSize) \
- unsigned char temp[tempSize]; unsigned i = 0; \
- while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
- *s++ = (charType)('0' + (unsigned)val); \
- while (i != 0) { i--; *s++ = temp[i]; } \
- *s = 0;
-
-void ConvertUInt32ToString(UInt32 val, char *s) throw()
-{
- CONVERT_INT_TO_STR(char, 16);
-}
-
-void ConvertUInt64ToString(UInt64 val, char *s) throw()
-{
- if (val <= (UInt32)0xFFFFFFFF)
- {
- ConvertUInt32ToString((UInt32)val, s);
- return;
- }
- CONVERT_INT_TO_STR(char, 24);
-}
-
-void ConvertUInt64ToOct(UInt64 val, char *s) throw()
-{
- UInt64 v = val;
- unsigned i;
- for (i = 1;; i++)
- {
- v >>= 3;
- if (v == 0)
- break;
- }
- s[i] = 0;
- do
- {
- unsigned t = (unsigned)(val & 0x7);
- val >>= 3;
- s[--i] = (char)('0' + t);
- }
- while (i);
-}
-
-
-#define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
-
-static inline char GetHexChar(unsigned t) { return GET_HEX_CHAR(t); }
-
-
-void ConvertUInt32ToHex(UInt32 val, char *s) throw()
-{
- UInt32 v = val;
- unsigned i;
- for (i = 1;; i++)
- {
- v >>= 4;
- if (v == 0)
- break;
- }
- s[i] = 0;
- do
- {
- unsigned t = (unsigned)(val & 0xF);
- val >>= 4;
- s[--i] = GET_HEX_CHAR(t);
- }
- while (i);
-}
-
-
-void ConvertUInt64ToHex(UInt64 val, char *s) throw()
-{
- UInt64 v = val;
- unsigned i;
- for (i = 1;; i++)
- {
- v >>= 4;
- if (v == 0)
- break;
- }
- s[i] = 0;
- do
- {
- unsigned t = (unsigned)(val & 0xF);
- val >>= 4;
- s[--i] = GET_HEX_CHAR(t);
- }
- while (i);
-}
-
-void ConvertUInt32ToHex8Digits(UInt32 val, char *s) throw()
-{
- s[8] = 0;
- for (int i = 7; i >= 0; i--)
- {
- unsigned t = val & 0xF;
- val >>= 4;
- s[i] = GET_HEX_CHAR(t);;
- }
-}
-
-/*
-void ConvertUInt32ToHex8Digits(UInt32 val, wchar_t *s)
-{
- s[8] = 0;
- for (int i = 7; i >= 0; i--)
- {
- unsigned t = val & 0xF;
- val >>= 4;
- s[i] = (wchar_t)(((t < 10) ? ('0' + t) : ('A' + (t - 10))));
- }
-}
-*/
-
-void ConvertUInt32ToString(UInt32 val, wchar_t *s) throw()
-{
- CONVERT_INT_TO_STR(wchar_t, 16);
-}
-
-void ConvertUInt64ToString(UInt64 val, wchar_t *s) throw()
-{
- if (val <= (UInt32)0xFFFFFFFF)
- {
- ConvertUInt32ToString((UInt32)val, s);
- return;
- }
- CONVERT_INT_TO_STR(wchar_t, 24);
-}
-
-void ConvertInt64ToString(Int64 val, char *s) throw()
-{
- if (val < 0)
- {
- *s++ = '-';
- val = -val;
- }
- ConvertUInt64ToString(val, s);
-}
-
-void ConvertInt64ToString(Int64 val, wchar_t *s) throw()
-{
- if (val < 0)
- {
- *s++ = L'-';
- val = -val;
- }
- ConvertUInt64ToString(val, s);
-}
-
-
-static void ConvertByteToHex2Digits(unsigned v, char *s) throw()
-{
- s[0] = GetHexChar(v >> 4);
- s[1] = GetHexChar(v & 0xF);
-}
-
-static void ConvertUInt16ToHex4Digits(UInt32 val, char *s) throw()
-{
- ConvertByteToHex2Digits(val >> 8, s);
- ConvertByteToHex2Digits(val & 0xFF, s + 2);
-}
-
-char *RawLeGuidToString(const Byte *g, char *s) throw()
-{
- ConvertUInt32ToHex8Digits(GetUi32(g ), s); s += 8; *s++ = '-';
- ConvertUInt16ToHex4Digits(GetUi16(g + 4), s); s += 4; *s++ = '-';
- ConvertUInt16ToHex4Digits(GetUi16(g + 6), s); s += 4; *s++ = '-';
- for (unsigned i = 0; i < 8; i++)
- {
- if (i == 2)
- *s++ = '-';
- ConvertByteToHex2Digits(g[8 + i], s);
- s += 2;
- }
- *s = 0;
- return s;
-}
-
-char *RawLeGuidToString_Braced(const Byte *g, char *s) throw()
-{
- *s++ = '{';
- s = RawLeGuidToString(g, s);
- *s++ = '}';
- *s = 0;
- return s;
-}
+// Common/IntToString.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#include "IntToString.h"
+
+#define CONVERT_INT_TO_STR(charType, tempSize) \
+ unsigned char temp[tempSize]; unsigned i = 0; \
+ while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
+ *s++ = (charType)('0' + (unsigned)val); \
+ while (i != 0) { i--; *s++ = (charType)temp[i]; } \
+ *s = 0; \
+ return s;
+
+char * ConvertUInt32ToString(UInt32 val, char *s) throw()
+{
+ CONVERT_INT_TO_STR(char, 16)
+}
+
+char * ConvertUInt64ToString(UInt64 val, char *s) throw()
+{
+ if (val <= (UInt32)0xFFFFFFFF)
+ {
+ return ConvertUInt32ToString((UInt32)val, s);
+ }
+ CONVERT_INT_TO_STR(char, 24)
+}
+
+void ConvertUInt64ToOct(UInt64 val, char *s) throw()
+{
+ UInt64 v = val;
+ unsigned i;
+ for (i = 1;; i++)
+ {
+ v >>= 3;
+ if (v == 0)
+ break;
+ }
+ s[i] = 0;
+ do
+ {
+ unsigned t = (unsigned)(val & 0x7);
+ val >>= 3;
+ s[--i] = (char)('0' + t);
+ }
+ while (i);
+}
+
+
+#define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
+
+static inline char GetHexChar(unsigned t) { return GET_HEX_CHAR(t); }
+
+
+void ConvertUInt32ToHex(UInt32 val, char *s) throw()
+{
+ UInt32 v = val;
+ unsigned i;
+ for (i = 1;; i++)
+ {
+ v >>= 4;
+ if (v == 0)
+ break;
+ }
+ s[i] = 0;
+ do
+ {
+ unsigned t = (unsigned)(val & 0xF);
+ val >>= 4;
+ s[--i] = GET_HEX_CHAR(t);
+ }
+ while (i);
+}
+
+
+void ConvertUInt64ToHex(UInt64 val, char *s) throw()
+{
+ UInt64 v = val;
+ unsigned i;
+ for (i = 1;; i++)
+ {
+ v >>= 4;
+ if (v == 0)
+ break;
+ }
+ s[i] = 0;
+ do
+ {
+ unsigned t = (unsigned)(val & 0xF);
+ val >>= 4;
+ s[--i] = GET_HEX_CHAR(t);
+ }
+ while (i);
+}
+
+void ConvertUInt32ToHex8Digits(UInt32 val, char *s) throw()
+{
+ s[8] = 0;
+ for (int i = 7; i >= 0; i--)
+ {
+ unsigned t = val & 0xF;
+ val >>= 4;
+ s[i] = GET_HEX_CHAR(t);
+ }
+}
+
+/*
+void ConvertUInt32ToHex8Digits(UInt32 val, wchar_t *s)
+{
+ s[8] = 0;
+ for (int i = 7; i >= 0; i--)
+ {
+ unsigned t = val & 0xF;
+ val >>= 4;
+ s[i] = (wchar_t)(((t < 10) ? ('0' + t) : ('A' + (t - 10))));
+ }
+}
+*/
+
+wchar_t * ConvertUInt32ToString(UInt32 val, wchar_t *s) throw()
+{
+ CONVERT_INT_TO_STR(wchar_t, 16)
+}
+
+wchar_t * ConvertUInt64ToString(UInt64 val, wchar_t *s) throw()
+{
+ if (val <= (UInt32)0xFFFFFFFF)
+ {
+ return ConvertUInt32ToString((UInt32)val, s);
+ }
+ CONVERT_INT_TO_STR(wchar_t, 24)
+}
+
+void ConvertInt64ToString(Int64 val, char *s) throw()
+{
+ if (val < 0)
+ {
+ *s++ = '-';
+ val = -val;
+ }
+ ConvertUInt64ToString((UInt64)val, s);
+}
+
+void ConvertInt64ToString(Int64 val, wchar_t *s) throw()
+{
+ if (val < 0)
+ {
+ *s++ = L'-';
+ val = -val;
+ }
+ ConvertUInt64ToString((UInt64)val, s);
+}
+
+
+static void ConvertByteToHex2Digits(unsigned v, char *s) throw()
+{
+ s[0] = GetHexChar(v >> 4);
+ s[1] = GetHexChar(v & 0xF);
+}
+
+static void ConvertUInt16ToHex4Digits(UInt32 val, char *s) throw()
+{
+ ConvertByteToHex2Digits(val >> 8, s);
+ ConvertByteToHex2Digits(val & 0xFF, s + 2);
+}
+
+char *RawLeGuidToString(const Byte *g, char *s) throw()
+{
+ ConvertUInt32ToHex8Digits(GetUi32(g ), s); s += 8; *s++ = '-';
+ ConvertUInt16ToHex4Digits(GetUi16(g + 4), s); s += 4; *s++ = '-';
+ ConvertUInt16ToHex4Digits(GetUi16(g + 6), s); s += 4; *s++ = '-';
+ for (unsigned i = 0; i < 8; i++)
+ {
+ if (i == 2)
+ *s++ = '-';
+ ConvertByteToHex2Digits(g[8 + i], s);
+ s += 2;
+ }
+ *s = 0;
+ return s;
+}
+
+char *RawLeGuidToString_Braced(const Byte *g, char *s) throw()
+{
+ *s++ = '{';
+ s = RawLeGuidToString(g, s);
+ *s++ = '}';
+ *s = 0;
+ return s;
+}
diff --git a/CPP/Common/IntToString.h b/CPP/Common/IntToString.h
index 07b67c3..f4fc662 100644
--- a/CPP/Common/IntToString.h
+++ b/CPP/Common/IntToString.h
@@ -1,28 +1,30 @@
-// Common/IntToString.h
-
-#ifndef __COMMON_INT_TO_STRING_H
-#define __COMMON_INT_TO_STRING_H
-
-#include "MyTypes.h"
-
-void ConvertUInt32ToString(UInt32 value, char *s) throw();
-void ConvertUInt64ToString(UInt64 value, char *s) throw();
-
-void ConvertUInt32ToString(UInt32 value, wchar_t *s) throw();
-void ConvertUInt64ToString(UInt64 value, wchar_t *s) throw();
-
-void ConvertUInt64ToOct(UInt64 value, char *s) throw();
-
-void ConvertUInt32ToHex(UInt32 value, char *s) throw();
-void ConvertUInt64ToHex(UInt64 value, char *s) throw();
-void ConvertUInt32ToHex8Digits(UInt32 value, char *s) throw();
-// void ConvertUInt32ToHex8Digits(UInt32 value, wchar_t *s) throw();
-
-void ConvertInt64ToString(Int64 value, char *s) throw();
-void ConvertInt64ToString(Int64 value, wchar_t *s) throw();
-
-// use RawLeGuid only for RAW bytes that contain stored GUID as Little-endian.
-char *RawLeGuidToString(const Byte *guid, char *s) throw();
-char *RawLeGuidToString_Braced(const Byte *guid, char *s) throw();
-
-#endif
+// Common/IntToString.h
+
+#ifndef ZIP7_INC_COMMON_INT_TO_STRING_H
+#define ZIP7_INC_COMMON_INT_TO_STRING_H
+
+#include "MyTypes.h"
+
+// return: the pointer to the "terminating" null character after written characters
+
+char * ConvertUInt32ToString(UInt32 value, char *s) throw();
+char * ConvertUInt64ToString(UInt64 value, char *s) throw();
+
+wchar_t * ConvertUInt32ToString(UInt32 value, wchar_t *s) throw();
+wchar_t * ConvertUInt64ToString(UInt64 value, wchar_t *s) throw();
+
+void ConvertUInt64ToOct(UInt64 value, char *s) throw();
+
+void ConvertUInt32ToHex(UInt32 value, char *s) throw();
+void ConvertUInt64ToHex(UInt64 value, char *s) throw();
+void ConvertUInt32ToHex8Digits(UInt32 value, char *s) throw();
+// void ConvertUInt32ToHex8Digits(UInt32 value, wchar_t *s) throw();
+
+void ConvertInt64ToString(Int64 value, char *s) throw();
+void ConvertInt64ToString(Int64 value, wchar_t *s) throw();
+
+// use RawLeGuid only for RAW bytes that contain stored GUID as Little-endian.
+char *RawLeGuidToString(const Byte *guid, char *s) throw();
+char *RawLeGuidToString_Braced(const Byte *guid, char *s) throw();
+
+#endif
diff --git a/CPP/Common/Lang.cpp b/CPP/Common/Lang.cpp
new file mode 100644
index 0000000..b0b4342
--- /dev/null
+++ b/CPP/Common/Lang.cpp
@@ -0,0 +1,173 @@
+// Common/Lang.cpp
+
+#include "StdAfx.h"
+
+#include "Lang.h"
+#include "StringToInt.h"
+#include "UTFConvert.h"
+
+#include "../Windows/FileIO.h"
+
+void CLang::Clear() throw()
+{
+ _ids.Clear();
+ _offsets.Clear();
+ Comments.Clear();
+ delete []_text;
+ _text = NULL;
+}
+
+static const char * const kLangSignature = ";!@Lang2@!UTF-8!\n";
+
+bool CLang::OpenFromString(const AString &s2)
+{
+ UString su;
+ if (!ConvertUTF8ToUnicode(s2, su))
+ return false;
+ if (su.IsEmpty())
+ return false;
+ const wchar_t *s = su;
+ const wchar_t *sLim = s + su.Len();
+ if (*s == 0xFEFF)
+ s++;
+ for (const char *p = kLangSignature;; s++)
+ {
+ const Byte c = (Byte)(*p++);
+ if (c == 0)
+ break;
+ if (*s != c)
+ return false;
+ }
+
+ wchar_t *text = new wchar_t[(size_t)(sLim - s) + 1];
+ _text = text;
+
+ UString comment;
+ Int32 id = -1024;
+ unsigned pos = 0;
+
+ while (s != sLim)
+ {
+ const unsigned start = pos;
+ do
+ {
+ wchar_t c = *s++;
+ if (c == '\n')
+ break;
+ if (c == '\\')
+ {
+ if (s == sLim)
+ return false;
+ c = *s++;
+ switch (c)
+ {
+ case '\n': return false;
+ case 'n': c = '\n'; break;
+ case 't': c = '\t'; break;
+ case '\\': /* c = '\\'; */ break;
+ default: text[pos++] = L'\\'; break;
+ }
+ }
+ text[pos++] = c;
+ }
+ while (s != sLim);
+
+ {
+ unsigned j = start;
+ for (; j < pos; j++)
+ if (text[j] != ' ' && text[j] != '\t')
+ break;
+ if (j == pos)
+ {
+ id++;
+ pos = start;
+ continue;
+ }
+ }
+
+ // start != pos
+ text[pos++] = 0;
+
+ if (text[start] == ';')
+ {
+ comment = text + start;
+ comment.TrimRight();
+ if (comment.Len() != 1)
+ Comments.Add(comment);
+ id++;
+ pos = start;
+ continue;
+ }
+
+ const wchar_t *end;
+ const UInt32 id32 = ConvertStringToUInt32(text + start, &end);
+ if (*end == 0)
+ {
+ if (id32 > ((UInt32)1 << 30) || (Int32)id32 < id)
+ return false;
+ id = (Int32)id32;
+ pos = start;
+ continue;
+ }
+
+ if (id < 0)
+ return false;
+ _ids.Add((UInt32)id++);
+ _offsets.Add(start);
+ }
+
+ return true;
+}
+
+bool CLang::Open(CFSTR fileName, const char *id)
+{
+ Clear();
+ NWindows::NFile::NIO::CInFile file;
+ if (!file.Open(fileName))
+ return false;
+ UInt64 length;
+ if (!file.GetLength(length))
+ return false;
+ if (length > (1 << 20))
+ return false;
+
+ AString s;
+ const unsigned len = (unsigned)length;
+ char *p = s.GetBuf(len);
+ size_t processed;
+ if (!file.ReadFull(p, len, processed))
+ return false;
+ file.Close();
+ if (len != processed)
+ return false;
+
+ char *p2 = p;
+ for (unsigned i = 0; i < len; i++)
+ {
+ const char c = p[i];
+ if (c == 0)
+ break;
+ if (c != 0x0D)
+ *p2++ = c;
+ }
+ *p2 = 0;
+ s.ReleaseBuf_SetLen((unsigned)(p2 - p));
+
+ if (OpenFromString(s))
+ {
+ const wchar_t *name = Get(0);
+ if (name && StringsAreEqual_Ascii(name, id))
+ return true;
+ }
+
+ Clear();
+ return false;
+}
+
+const wchar_t *CLang::Get(UInt32 id) const throw()
+{
+ const int index = _ids.FindInSorted(id);
+ if (index < 0)
+ return NULL;
+ return _text + (size_t)_offsets[(unsigned)index];
+}
diff --git a/CPP/Common/Lang.h b/CPP/Common/Lang.h
index e95de68..76d5418 100644
--- a/CPP/Common/Lang.h
+++ b/CPP/Common/Lang.h
@@ -1,23 +1,30 @@
-// Common/Lang.h
-
-#ifndef __COMMON_LANG_H
-#define __COMMON_LANG_H
-
-#include "MyString.h"
-
-class CLang
-{
- wchar_t *_text;
- CRecordVector<UInt32> _ids;
- CRecordVector<UInt32> _offsets;
-
- bool OpenFromString(const AString &s);
-public:
- CLang(): _text(0) {}
- ~CLang() { Clear(); }
- bool Open(CFSTR fileName, const char *id);
- void Clear() throw();
- const wchar_t *Get(UInt32 id) const throw();
-};
-
-#endif
+// Common/Lang.h
+
+#ifndef ZIP7_INC_COMMON_LANG_H
+#define ZIP7_INC_COMMON_LANG_H
+
+#include "MyString.h"
+
+class CLang
+{
+ wchar_t *_text;
+
+ bool OpenFromString(const AString &s);
+public:
+ CRecordVector<UInt32> _ids;
+ CRecordVector<UInt32> _offsets;
+ UStringVector Comments;
+
+ CLang(): _text(NULL) {}
+ ~CLang() { Clear(); }
+ bool Open(CFSTR fileName, const char *id);
+ void Clear() throw();
+ bool IsEmpty() const { return _ids.IsEmpty(); }
+ const wchar_t *Get(UInt32 id) const throw();
+ const wchar_t *Get_by_index(unsigned index) const throw()
+ {
+ return _text + (size_t)_offsets[index];
+ }
+};
+
+#endif
diff --git a/CPP/Common/ListFileUtils.cpp b/CPP/Common/ListFileUtils.cpp
index 2fdde6d..e43dbc9 100644
--- a/CPP/Common/ListFileUtils.cpp
+++ b/CPP/Common/ListFileUtils.cpp
@@ -1,132 +1,150 @@
-// Common/ListFileUtils.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/CpuArch.h"
-
-#include "../Windows/FileIO.h"
-
-#include "ListFileUtils.h"
-#include "MyBuffer.h"
-#include "StringConvert.h"
-#include "UTFConvert.h"
-
-static const char kQuoteChar = '\"';
-
-static void AddName(UStringVector &strings, UString &s)
-{
- s.Trim();
- if (s.Len() >= 2 && s[0] == kQuoteChar && s.Back() == kQuoteChar)
- {
- s.DeleteBack();
- s.Delete(0);
- }
- if (!s.IsEmpty())
- strings.Add(s);
-}
-
-bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePage, DWORD &lastError)
-{
- lastError = 0;
- NWindows::NFile::NIO::CInFile file;
- if (!file.Open(fileName))
- {
- lastError = ::GetLastError();
- return false;
- }
- UInt64 fileSize;
- if (!file.GetLength(fileSize))
- {
- lastError = ::GetLastError();
- return false;
- }
- if (fileSize >= ((UInt32)1 << 31) - 32)
- return false;
- UString u;
- if (codePage == MY__CP_UTF16 || codePage == MY__CP_UTF16BE)
- {
- if ((fileSize & 1) != 0)
- return false;
- CByteArr buf((size_t)fileSize);
- UInt32 processed;
- if (!file.Read(buf, (UInt32)fileSize, processed))
- {
- lastError = ::GetLastError();
- return false;
- }
- if (processed != fileSize)
- return false;
- file.Close();
- unsigned num = (unsigned)fileSize / 2;
- wchar_t *p = u.GetBuf(num);
- if (codePage == MY__CP_UTF16)
- for (unsigned i = 0; i < num; i++)
- {
- wchar_t c = GetUi16(buf + (size_t)i * 2);
- if (c == 0)
- return false;
- p[i] = c;
- }
- else
- for (unsigned i = 0; i < num; i++)
- {
- wchar_t c = (wchar_t)GetBe16(buf + (size_t)i * 2);
- if (c == 0)
- return false;
- p[i] = c;
- }
- p[num] = 0;
- u.ReleaseBuf_SetLen(num);
- }
- else
- {
- AString s;
- char *p = s.GetBuf((unsigned)fileSize);
- UInt32 processed;
- if (!file.Read(p, (UInt32)fileSize, processed))
- {
- lastError = ::GetLastError();
- return false;
- }
- if (processed != fileSize)
- return false;
- file.Close();
- s.ReleaseBuf_CalcLen((unsigned)processed);
- if (s.Len() != processed)
- return false;
-
- // #ifdef CP_UTF8
- if (codePage == CP_UTF8)
- {
- if (!ConvertUTF8ToUnicode(s, u))
- return false;
- }
- else
- // #endif
- MultiByteToUnicodeString2(u, s, codePage);
- }
-
- const wchar_t kGoodBOM = 0xFEFF;
- // const wchar_t kBadBOM = 0xFFFE;
-
- UString s;
- unsigned i = 0;
- for (; i < u.Len() && u[i] == kGoodBOM; i++);
- for (; i < u.Len(); i++)
- {
- wchar_t c = u[i];
- /*
- if (c == kGoodBOM || c == kBadBOM)
- return false;
- */
- if (c == '\n' || c == 0xD)
- {
- AddName(strings, s);
- s.Empty();
- }
- else
- s += c;
- }
- AddName(strings, s);
- return true;
-}
+// Common/ListFileUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#include "ListFileUtils.h"
+#include "MyBuffer.h"
+#include "StringConvert.h"
+#include "UTFConvert.h"
+
+#include "../Windows/FileIO.h"
+
+#define CSysInFile NWindows::NFile::NIO::CInFile
+#define MY_GET_LAST_ERROR ::GetLastError()
+
+
+#define kQuoteChar '\"'
+
+
+static void AddName(UStringVector &strings, UString &s)
+{
+ s.Trim();
+ if (s.Len() >= 2 && s[0] == kQuoteChar && s.Back() == kQuoteChar)
+ {
+ s.DeleteBack();
+ s.Delete(0);
+ }
+ if (!s.IsEmpty())
+ strings.Add(s);
+}
+
+
+static bool My_File_Read(CSysInFile &file, void *data, size_t size, DWORD &lastError)
+{
+ size_t processed;
+ if (!file.ReadFull(data, size, processed))
+ {
+ lastError = MY_GET_LAST_ERROR;
+ return false;
+ }
+ if (processed != size)
+ {
+ lastError = 1; // error: size of listfile was changed
+ return false;
+ }
+ return true;
+}
+
+
+bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePage, DWORD &lastError)
+{
+ lastError = 0;
+ CSysInFile file;
+ if (!file.Open(fileName))
+ {
+ lastError = MY_GET_LAST_ERROR;
+ return false;
+ }
+ UInt64 fileSize;
+ if (!file.GetLength(fileSize))
+ {
+ lastError = MY_GET_LAST_ERROR;
+ return false;
+ }
+ if (fileSize >= ((UInt32)1 << 31) - 32)
+ return false;
+ UString u;
+ if (codePage == Z7_WIN_CP_UTF16 || codePage == Z7_WIN_CP_UTF16BE)
+ {
+ if ((fileSize & 1) != 0)
+ return false;
+ CByteArr buf((size_t)fileSize);
+
+ if (!My_File_Read(file, buf, (size_t)fileSize, lastError))
+ return false;
+
+ file.Close();
+ const unsigned num = (unsigned)fileSize / 2;
+ wchar_t *p = u.GetBuf(num);
+ if (codePage == Z7_WIN_CP_UTF16)
+ for (unsigned i = 0; i < num; i++)
+ {
+ wchar_t c = GetUi16(buf + (size_t)i * 2);
+ if (c == 0)
+ return false;
+ p[i] = c;
+ }
+ else
+ for (unsigned i = 0; i < num; i++)
+ {
+ wchar_t c = (wchar_t)GetBe16(buf + (size_t)i * 2);
+ if (c == 0)
+ return false;
+ p[i] = c;
+ }
+ p[num] = 0;
+ u.ReleaseBuf_SetLen(num);
+ }
+ else
+ {
+ AString s;
+ char *p = s.GetBuf((unsigned)fileSize);
+
+ if (!My_File_Read(file, p, (size_t)fileSize, lastError))
+ return false;
+
+ file.Close();
+ s.ReleaseBuf_CalcLen((unsigned)fileSize);
+ if (s.Len() != fileSize)
+ return false;
+
+ // #ifdef CP_UTF8
+ if (codePage == CP_UTF8)
+ {
+ // we must check UTF8 here, if convert function doesn't check
+ if (!CheckUTF8_AString(s))
+ return false;
+ if (!ConvertUTF8ToUnicode(s, u))
+ return false;
+ }
+ else
+ // #endif
+ MultiByteToUnicodeString2(u, s, codePage);
+ }
+
+ const wchar_t kGoodBOM = 0xFEFF;
+ // const wchar_t kBadBOM = 0xFFFE;
+
+ UString s;
+ unsigned i = 0;
+ for (; i < u.Len() && u[i] == kGoodBOM; i++);
+ for (; i < u.Len(); i++)
+ {
+ wchar_t c = u[i];
+ /*
+ if (c == kGoodBOM || c == kBadBOM)
+ return false;
+ */
+ if (c == '\n' || c == 0xD)
+ {
+ AddName(strings, s);
+ s.Empty();
+ }
+ else
+ s += c;
+ }
+ AddName(strings, s);
+ return true;
+}
diff --git a/CPP/Common/ListFileUtils.h b/CPP/Common/ListFileUtils.h
index a4f0d16..d43cc37 100644
--- a/CPP/Common/ListFileUtils.h
+++ b/CPP/Common/ListFileUtils.h
@@ -1,18 +1,18 @@
-// Common/ListFileUtils.h
-
-#ifndef __COMMON_LIST_FILE_UTILS_H
-#define __COMMON_LIST_FILE_UTILS_H
-
-#include "MyString.h"
-#include "MyTypes.h"
-
-#define MY__CP_UTF16 1200
-#define MY__CP_UTF16BE 1201
-
-// bool ReadNamesFromListFile(CFSTR fileName, UStringVector &strings, UINT codePage = CP_OEMCP);
-
- // = CP_OEMCP
-bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePage,
- DWORD &lastError);
-
-#endif
+// Common/ListFileUtils.h
+
+#ifndef ZIP7_INC_COMMON_LIST_FILE_UTILS_H
+#define ZIP7_INC_COMMON_LIST_FILE_UTILS_H
+
+#include "MyString.h"
+#include "MyTypes.h"
+
+#define Z7_WIN_CP_UTF16 1200
+#define Z7_WIN_CP_UTF16BE 1201
+
+// bool ReadNamesFromListFile(CFSTR fileName, UStringVector &strings, UINT codePage = CP_OEMCP);
+
+ // = CP_OEMCP
+bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePage,
+ DWORD &lastError);
+
+#endif
diff --git a/CPP/Common/LzFindPrepare.cpp b/CPP/Common/LzFindPrepare.cpp
new file mode 100644
index 0000000..8845e4a
--- /dev/null
+++ b/CPP/Common/LzFindPrepare.cpp
@@ -0,0 +1,7 @@
+// Sha256Prepare.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/LzFind.h"
+
+static struct CLzFindPrepare { CLzFindPrepare() { LzFindPrepare(); } } g_CLzFindPrepare;
diff --git a/CPP/Common/MyBuffer.h b/CPP/Common/MyBuffer.h
index ae320ee..bc829f4 100644
--- a/CPP/Common/MyBuffer.h
+++ b/CPP/Common/MyBuffer.h
@@ -1,259 +1,286 @@
-// Common/MyBuffer.h
-
-#ifndef __COMMON_MY_BUFFER_H
-#define __COMMON_MY_BUFFER_H
-
-#include "Defs.h"
-
-/* 7-Zip now uses CBuffer only as CByteBuffer.
- So there is no need to use MY_ARRAY_NEW macro in CBuffer code. */
-
-template <class T> class CBuffer
-{
- T *_items;
- size_t _size;
-
-public:
- void Free()
- {
- if (_items)
- {
- delete []_items;
- _items = 0;
- }
- _size = 0;
- }
-
- CBuffer(): _items(0), _size(0) {};
- CBuffer(size_t size): _items(0), _size(0) { _items = new T[size]; _size = size; }
- CBuffer(const CBuffer &buffer): _items(0), _size(0)
- {
- size_t size = buffer._size;
- if (size != 0)
- {
- _items = new T[size];
- memcpy(_items, buffer._items, size * sizeof(T));
- _size = size;
- }
- }
-
- ~CBuffer() { delete []_items; }
-
- operator T *() { return _items; }
- operator const T *() const { return _items; }
- size_t Size() const { return _size; }
-
- void Alloc(size_t size)
- {
- if (size != _size)
- {
- Free();
- if (size != 0)
- {
- _items = new T[size];
- _size = size;
- }
- }
- }
-
- void AllocAtLeast(size_t size)
- {
- if (size > _size)
- {
- Free();
- _items = new T[size];
- _size = size;
- }
- }
-
- void CopyFrom(const T *data, size_t size)
- {
- Alloc(size);
- if (size != 0)
- memcpy(_items, data, size * sizeof(T));
- }
-
- void ChangeSize_KeepData(size_t newSize, size_t keepSize)
- {
- if (newSize == _size)
- return;
- T *newBuffer = NULL;
- if (newSize != 0)
- {
- newBuffer = new T[newSize];
- if (keepSize > _size)
- keepSize = _size;
- if (keepSize != 0)
- memcpy(newBuffer, _items, MyMin(keepSize, newSize) * sizeof(T));
- }
- delete []_items;
- _items = newBuffer;
- _size = newSize;
- }
-
- CBuffer& operator=(const CBuffer &buffer)
- {
- if (&buffer != this)
- CopyFrom(buffer, buffer._size);
- return *this;
- }
-};
-
-template <class T>
-bool operator==(const CBuffer<T>& b1, const CBuffer<T>& b2)
-{
- size_t size1 = b1.Size();
- if (size1 != b2.Size())
- return false;
- if (size1 == 0)
- return true;
- return memcmp(b1, b2, size1 * sizeof(T)) == 0;
-}
-
-template <class T>
-bool operator!=(const CBuffer<T>& b1, const CBuffer<T>& b2)
-{
- size_t size1 = b1.Size();
- if (size1 != b2.Size())
- return true;
- if (size1 == 0)
- return false;
- return memcmp(b1, b2, size1 * sizeof(T)) != 0;
-}
-
-
-// typedef CBuffer<char> CCharBuffer;
-// typedef CBuffer<wchar_t> CWCharBuffer;
-typedef CBuffer<unsigned char> CByteBuffer;
-
-
-template <class T> class CObjArray
-{
-protected:
- T *_items;
-private:
- // we disable copy
- CObjArray(const CObjArray &buffer);
- void operator=(const CObjArray &buffer);
-public:
- void Free()
- {
- delete []_items;
- _items = 0;
- }
- CObjArray(size_t size): _items(0)
- {
- if (size != 0)
- {
- MY_ARRAY_NEW(_items, T, size)
- // _items = new T[size];
- }
- }
- CObjArray(): _items(0) {};
- ~CObjArray() { delete []_items; }
-
- operator T *() { return _items; }
- operator const T *() const { return _items; }
-
- void Alloc(size_t newSize)
- {
- delete []_items;
- _items = 0;
- MY_ARRAY_NEW(_items, T, newSize)
- // _items = new T[newSize];
- }
-};
-
-typedef CObjArray<unsigned char> CByteArr;
-typedef CObjArray<bool> CBoolArr;
-typedef CObjArray<int> CIntArr;
-typedef CObjArray<unsigned> CUIntArr;
-
-
-template <class T> class CObjArray2
-{
- T *_items;
- unsigned _size;
-
- // we disable copy
- CObjArray2(const CObjArray2 &buffer);
- void operator=(const CObjArray2 &buffer);
-public:
-
- void Free()
- {
- delete []_items;
- _items = 0;
- _size = 0;
- }
- CObjArray2(): _items(0), _size(0) {};
- /*
- CObjArray2(const CObjArray2 &buffer): _items(0), _size(0)
- {
- size_t newSize = buffer._size;
- if (newSize != 0)
- {
- T *newBuffer = new T[newSize];;
- _items = newBuffer;
- _size = newSize;
- const T *src = buffer;
- for (size_t i = 0; i < newSize; i++)
- newBuffer[i] = src[i];
- }
- }
- */
- /*
- CObjArray2(size_t size): _items(0), _size(0)
- {
- if (size != 0)
- {
- _items = new T[size];
- _size = size;
- }
- }
- */
-
- ~CObjArray2() { delete []_items; }
-
- operator T *() { return _items; }
- operator const T *() const { return _items; }
-
- unsigned Size() const { return (unsigned)_size; }
- bool IsEmpty() const { return _size == 0; }
-
- // SetSize doesn't keep old items. It allocates new array if size is not equal
- void SetSize(unsigned size)
- {
- if (size == _size)
- return;
- T *newBuffer = NULL;
- if (size != 0)
- {
- MY_ARRAY_NEW(newBuffer, T, size)
- // newBuffer = new T[size];
- }
- delete []_items;
- _items = newBuffer;
- _size = size;
- }
-
- /*
- CObjArray2& operator=(const CObjArray2 &buffer)
- {
- Free();
- size_t newSize = buffer._size;
- if (newSize != 0)
- {
- T *newBuffer = new T[newSize];;
- _items = newBuffer;
- _size = newSize;
- const T *src = buffer;
- for (size_t i = 0; i < newSize; i++)
- newBuffer[i] = src[i];
- }
- return *this;
- }
- */
-};
-
-#endif
+// Common/MyBuffer.h
+
+#ifndef ZIP7_INC_COMMON_MY_BUFFER_H
+#define ZIP7_INC_COMMON_MY_BUFFER_H
+
+#include <string.h>
+
+#include "Defs.h"
+#include "MyTypes.h"
+
+/* 7-Zip now uses CBuffer only as CByteBuffer.
+ So there is no need to use Z7_ARRAY_NEW macro in CBuffer code. */
+
+template <class T> class CBuffer
+{
+ T *_items;
+ size_t _size;
+
+public:
+ void Free()
+ {
+ if (_items)
+ {
+ delete []_items;
+ _items = NULL;
+ }
+ _size = 0;
+ }
+
+ CBuffer(): _items(NULL), _size(0) {}
+ CBuffer(size_t size): _items(NULL), _size(0)
+ {
+ if (size != 0)
+ {
+ _items = new T[size];
+ _size = size;
+ }
+ }
+ CBuffer(const CBuffer &buffer): _items(NULL), _size(0)
+ {
+ const size_t size = buffer._size;
+ if (size != 0)
+ {
+ _items = new T[size];
+ memcpy(_items, buffer._items, size * sizeof(T));
+ _size = size;
+ }
+ }
+
+ ~CBuffer() { delete []_items; }
+
+ operator T *() { return _items; }
+ operator const T *() const { return _items; }
+ size_t Size() const { return _size; }
+
+ void Alloc(size_t size)
+ {
+ if (size != _size)
+ {
+ Free();
+ if (size != 0)
+ {
+ _items = new T[size];
+ _size = size;
+ }
+ }
+ }
+
+ void AllocAtLeast(size_t size)
+ {
+ if (size > _size)
+ {
+ Free();
+ _items = new T[size];
+ _size = size;
+ }
+ }
+
+ void CopyFrom(const T *data, size_t size)
+ {
+ Alloc(size);
+ if (size != 0)
+ memcpy(_items, data, size * sizeof(T));
+ }
+
+ void ChangeSize_KeepData(size_t newSize, size_t keepSize)
+ {
+ if (newSize == _size)
+ return;
+ T *newBuffer = NULL;
+ if (newSize != 0)
+ {
+ newBuffer = new T[newSize];
+ if (keepSize > _size)
+ keepSize = _size;
+ if (keepSize != 0)
+ memcpy(newBuffer, _items, MyMin(keepSize, newSize) * sizeof(T));
+ }
+ delete []_items;
+ _items = newBuffer;
+ _size = newSize;
+ }
+
+ void Wipe()
+ {
+ if (_size != 0)
+ memset(_items, 0, _size * sizeof(T));
+ }
+
+ CBuffer& operator=(const CBuffer &buffer)
+ {
+ if (&buffer != this)
+ CopyFrom(buffer, buffer._size);
+ return *this;
+ }
+};
+
+template <class T>
+bool operator==(const CBuffer<T>& b1, const CBuffer<T>& b2)
+{
+ size_t size1 = b1.Size();
+ if (size1 != b2.Size())
+ return false;
+ if (size1 == 0)
+ return true;
+ return memcmp(b1, b2, size1 * sizeof(T)) == 0;
+}
+
+template <class T>
+bool operator!=(const CBuffer<T>& b1, const CBuffer<T>& b2)
+{
+ size_t size1 = b1.Size();
+ if (size1 != b2.Size())
+ return true;
+ if (size1 == 0)
+ return false;
+ return memcmp(b1, b2, size1 * sizeof(T)) != 0;
+}
+
+
+// typedef CBuffer<char> CCharBuffer;
+// typedef CBuffer<wchar_t> CWCharBuffer;
+typedef CBuffer<unsigned char> CByteBuffer;
+
+
+class CByteBuffer_Wipe: public CByteBuffer
+{
+ Z7_CLASS_NO_COPY(CByteBuffer_Wipe)
+public:
+ // CByteBuffer_Wipe(): CBuffer<unsigned char>() {}
+ CByteBuffer_Wipe(size_t size): CBuffer<unsigned char>(size) {}
+ ~CByteBuffer_Wipe() { Wipe(); }
+};
+
+
+
+template <class T> class CObjArray
+{
+protected:
+ T *_items;
+private:
+ // we disable copy
+ CObjArray(const CObjArray &buffer);
+ void operator=(const CObjArray &buffer);
+public:
+ void Free()
+ {
+ delete []_items;
+ _items = NULL;
+ }
+ CObjArray(size_t size): _items(NULL)
+ {
+ if (size != 0)
+ {
+ Z7_ARRAY_NEW(_items, T, size)
+ // _items = new T[size];
+ }
+ }
+ CObjArray(): _items(NULL) {}
+ ~CObjArray() { delete []_items; }
+
+ operator T *() { return _items; }
+ operator const T *() const { return _items; }
+
+ void Alloc(size_t newSize)
+ {
+ delete []_items;
+ _items = NULL;
+ Z7_ARRAY_NEW(_items, T, newSize)
+ // _items = new T[newSize];
+ }
+};
+
+typedef CObjArray<unsigned char> CByteArr;
+typedef CObjArray<bool> CBoolArr;
+typedef CObjArray<int> CIntArr;
+typedef CObjArray<unsigned> CUIntArr;
+
+
+template <class T> class CObjArray2
+{
+ T *_items;
+ unsigned _size;
+
+ // we disable copy
+ CObjArray2(const CObjArray2 &buffer);
+ void operator=(const CObjArray2 &buffer);
+public:
+
+ void Free()
+ {
+ delete []_items;
+ _items = NULL;
+ _size = 0;
+ }
+ CObjArray2(): _items(NULL), _size(0) {}
+ /*
+ CObjArray2(const CObjArray2 &buffer): _items(NULL), _size(0)
+ {
+ size_t newSize = buffer._size;
+ if (newSize != 0)
+ {
+ T *newBuffer = new T[newSize];;
+ _items = newBuffer;
+ _size = newSize;
+ const T *src = buffer;
+ for (size_t i = 0; i < newSize; i++)
+ newBuffer[i] = src[i];
+ }
+ }
+ */
+ /*
+ CObjArray2(size_t size): _items(NULL), _size(0)
+ {
+ if (size != 0)
+ {
+ _items = new T[size];
+ _size = size;
+ }
+ }
+ */
+
+ ~CObjArray2() { delete []_items; }
+
+ operator T *() { return _items; }
+ operator const T *() const { return _items; }
+
+ unsigned Size() const { return (unsigned)_size; }
+ bool IsEmpty() const { return _size == 0; }
+
+ // SetSize doesn't keep old items. It allocates new array if size is not equal
+ void SetSize(unsigned size)
+ {
+ if (size == _size)
+ return;
+ T *newBuffer = NULL;
+ if (size != 0)
+ {
+ Z7_ARRAY_NEW(newBuffer, T, size)
+ // newBuffer = new T[size];
+ }
+ delete []_items;
+ _items = newBuffer;
+ _size = size;
+ }
+
+ /*
+ CObjArray2& operator=(const CObjArray2 &buffer)
+ {
+ Free();
+ size_t newSize = buffer._size;
+ if (newSize != 0)
+ {
+ T *newBuffer = new T[newSize];;
+ _items = newBuffer;
+ _size = newSize;
+ const T *src = buffer;
+ for (size_t i = 0; i < newSize; i++)
+ newBuffer[i] = src[i];
+ }
+ return *this;
+ }
+ */
+};
+
+#endif
diff --git a/CPP/Common/MyBuffer2.h b/CPP/Common/MyBuffer2.h
index 10edcb1..23394f8 100644
--- a/CPP/Common/MyBuffer2.h
+++ b/CPP/Common/MyBuffer2.h
@@ -1,100 +1,164 @@
-// Common/MyBuffer2.h
-
-#ifndef __COMMON_MY_BUFFER2_H
-#define __COMMON_MY_BUFFER2_H
-
-#include "../../C/Alloc.h"
-
-#include "MyTypes.h"
-
-class CMidBuffer
-{
- Byte *_data;
- size_t _size;
-
- CLASS_NO_COPY(CMidBuffer)
-
-public:
- CMidBuffer(): _data(NULL), _size(0) {}
- ~CMidBuffer() { ::MidFree(_data); }
-
- void Free() { ::MidFree(_data); _data = NULL; _size = 0; }
-
- bool IsAllocated() const { return _data != NULL; }
- operator Byte *() { return _data; }
- operator const Byte *() const { return _data; }
- size_t Size() const { return _size; }
-
- void AllocAtLeast(size_t size)
- {
- if (!_data || size > _size)
- {
- ::MidFree(_data);
- const size_t kMinSize = (size_t)1 << 16;
- if (size < kMinSize)
- size = kMinSize;
- _size = 0;
- _data = NULL;
- _data = (Byte *)::MidAlloc(size);
- if (_data)
- _size = size;
- }
- }
-};
-
-
-class CAlignedBuffer
-{
- Byte *_data;
- size_t _size;
-
- CLASS_NO_COPY(CAlignedBuffer)
-
-public:
- CAlignedBuffer(): _data(NULL), _size(0) {}
- ~CAlignedBuffer()
- {
- ISzAlloc_Free(&g_AlignedAlloc, _data);
- }
-
- void Free()
- {
- ISzAlloc_Free(&g_AlignedAlloc, _data);
- _data = NULL;
- _size = 0;
- }
-
- bool IsAllocated() const { return _data != NULL; }
- operator Byte *() { return _data; }
- operator const Byte *() const { return _data; }
- size_t Size() const { return _size; }
-
- void Alloc(size_t size)
- {
- if (!_data || size != _size)
- {
- ISzAlloc_Free(&g_AlignedAlloc, _data);
- _size = 0;
- _data = NULL;
- _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
- if (_data)
- _size = size;
- }
- }
-
- void AllocAtLeast(size_t size)
- {
- if (!_data || size > _size)
- {
- ISzAlloc_Free(&g_AlignedAlloc, _data);
- _size = 0;
- _data = NULL;
- _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
- if (_data)
- _size = size;
- }
- }
-};
-
-
-#endif
+// Common/MyBuffer2.h
+
+#ifndef ZIP7_INC_COMMON_MY_BUFFER2_H
+#define ZIP7_INC_COMMON_MY_BUFFER2_H
+
+#include "../../C/Alloc.h"
+
+#include "MyTypes.h"
+
+class CMidBuffer
+{
+ Byte *_data;
+ size_t _size;
+
+ Z7_CLASS_NO_COPY(CMidBuffer)
+
+public:
+ CMidBuffer(): _data(NULL), _size(0) {}
+ ~CMidBuffer() { ::MidFree(_data); }
+
+ void Free() { ::MidFree(_data); _data = NULL; _size = 0; }
+
+ bool IsAllocated() const { return _data != NULL; }
+ operator Byte *() { return _data; }
+ operator const Byte *() const { return _data; }
+ size_t Size() const { return _size; }
+
+ void Alloc(size_t size)
+ {
+ if (!_data || size != _size)
+ {
+ ::MidFree(_data);
+ _size = 0;
+ _data = NULL;
+ _data = (Byte *)::MidAlloc(size);
+ if (_data)
+ _size = size;
+ }
+ }
+
+ void AllocAtLeast(size_t size)
+ {
+ if (!_data || size > _size)
+ {
+ ::MidFree(_data);
+ const size_t kMinSize = (size_t)1 << 16;
+ if (size < kMinSize)
+ size = kMinSize;
+ _size = 0;
+ _data = NULL;
+ _data = (Byte *)::MidAlloc(size);
+ if (_data)
+ _size = size;
+ }
+ }
+};
+
+
+class CAlignedBuffer1
+{
+ Byte *_data;
+
+ Z7_CLASS_NO_COPY(CAlignedBuffer1)
+
+public:
+ ~CAlignedBuffer1()
+ {
+ ISzAlloc_Free(&g_AlignedAlloc, _data);
+ }
+
+ CAlignedBuffer1(size_t size)
+ {
+ _data = NULL;
+ _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+ if (!_data)
+ throw 1;
+ }
+
+ operator Byte *() { return _data; }
+ operator const Byte *() const { return _data; }
+};
+
+
+class CAlignedBuffer
+{
+ Byte *_data;
+ size_t _size;
+
+ Z7_CLASS_NO_COPY(CAlignedBuffer)
+
+public:
+ CAlignedBuffer(): _data(NULL), _size(0) {}
+ ~CAlignedBuffer()
+ {
+ ISzAlloc_Free(&g_AlignedAlloc, _data);
+ }
+
+ CAlignedBuffer(size_t size): _size(0)
+ {
+ _data = NULL;
+ _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+ if (!_data)
+ throw 1;
+ _size = size;
+ }
+
+ void Free()
+ {
+ ISzAlloc_Free(&g_AlignedAlloc, _data);
+ _data = NULL;
+ _size = 0;
+ }
+
+ bool IsAllocated() const { return _data != NULL; }
+ operator Byte *() { return _data; }
+ operator const Byte *() const { return _data; }
+ size_t Size() const { return _size; }
+
+ void Alloc(size_t size)
+ {
+ if (!_data || size != _size)
+ {
+ ISzAlloc_Free(&g_AlignedAlloc, _data);
+ _size = 0;
+ _data = NULL;
+ _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+ if (_data)
+ _size = size;
+ }
+ }
+
+ void AllocAtLeast(size_t size)
+ {
+ if (!_data || size > _size)
+ {
+ ISzAlloc_Free(&g_AlignedAlloc, _data);
+ _size = 0;
+ _data = NULL;
+ _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+ if (_data)
+ _size = size;
+ }
+ }
+};
+
+/*
+ CMidAlignedBuffer must return aligned pointer.
+ - in Windows it uses CMidBuffer(): MidAlloc() : VirtualAlloc()
+ VirtualAlloc(): Memory allocated is automatically initialized to zero.
+ MidAlloc(0) returns NULL
+ - in non-Windows systems it uses g_AlignedAlloc.
+ g_AlignedAlloc::Alloc(size = 0) can return non NULL.
+*/
+
+typedef
+#ifdef _WIN32
+ CMidBuffer
+#else
+ CAlignedBuffer
+#endif
+ CMidAlignedBuffer;
+
+
+#endif
diff --git a/CPP/Common/MyCom.h b/CPP/Common/MyCom.h
index ca49ead..65c4330 100644
--- a/CPP/Common/MyCom.h
+++ b/CPP/Common/MyCom.h
@@ -1,277 +1,509 @@
-// MyCom.h
-
-#ifndef __MY_COM_H
-#define __MY_COM_H
-
-#include "MyWindows.h"
-
-#ifndef RINOK
-#define RINOK(x) { HRESULT __result_ = (x); if (__result_ != S_OK) return __result_; }
-#endif
-
-template <class T>
-class CMyComPtr
-{
- T* _p;
-public:
- CMyComPtr(): _p(NULL) {}
- CMyComPtr(T* p) throw() { if ((_p = p) != NULL) p->AddRef(); }
- CMyComPtr(const CMyComPtr<T>& lp) throw() { if ((_p = lp._p) != NULL) _p->AddRef(); }
- ~CMyComPtr() { if (_p) _p->Release(); }
- void Release() { if (_p) { _p->Release(); _p = NULL; } }
- operator T*() const { return (T*)_p; }
- // T& operator*() const { return *_p; }
- T** operator&() { return &_p; }
- T* operator->() const { return _p; }
- T* operator=(T* p)
- {
- if (p)
- p->AddRef();
- if (_p)
- _p->Release();
- _p = p;
- return p;
- }
- T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }
- bool operator!() const { return (_p == NULL); }
- // bool operator==(T* pT) const { return _p == pT; }
- void Attach(T* p2)
- {
- Release();
- _p = p2;
- }
- T* Detach()
- {
- T* pt = _p;
- _p = NULL;
- return pt;
- }
- #ifdef _WIN32
- HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
- {
- return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);
- }
- #endif
- /*
- HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
- {
- CLSID clsid;
- HRESULT hr = CLSIDFromProgID(szProgID, &clsid);
- ATLASSERT(_p == NULL);
- if (SUCCEEDED(hr))
- hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);
- return hr;
- }
- */
- template <class Q>
- HRESULT QueryInterface(REFGUID iid, Q** pp) const throw()
- {
- return _p->QueryInterface(iid, (void**)pp);
- }
-};
-
-//////////////////////////////////////////////////////////
-
-inline HRESULT StringToBstr(LPCOLESTR src, BSTR *bstr)
-{
- *bstr = ::SysAllocString(src);
- return (*bstr) ? S_OK : E_OUTOFMEMORY;
-}
-
-class CMyComBSTR
-{
- BSTR m_str;
-
-public:
- CMyComBSTR(): m_str(NULL) {}
- ~CMyComBSTR() { ::SysFreeString(m_str); }
- BSTR* operator&() { return &m_str; }
- operator LPCOLESTR() const { return m_str; }
- // operator bool() const { return m_str != NULL; }
- // bool operator!() const { return m_str == NULL; }
-private:
- // operator BSTR() const { return m_str; }
-
- CMyComBSTR(LPCOLESTR src) { m_str = ::SysAllocString(src); }
- // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }
- // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize); }
- CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }
-
- /*
- CMyComBSTR(REFGUID src)
- {
- LPOLESTR szGuid;
- StringFromCLSID(src, &szGuid);
- m_str = ::SysAllocString(szGuid);
- CoTaskMemFree(szGuid);
- }
- */
-
- CMyComBSTR& operator=(const CMyComBSTR& src)
- {
- if (m_str != src.m_str)
- {
- if (m_str)
- ::SysFreeString(m_str);
- m_str = src.MyCopy();
- }
- return *this;
- }
-
- CMyComBSTR& operator=(LPCOLESTR src)
- {
- ::SysFreeString(m_str);
- m_str = ::SysAllocString(src);
- return *this;
- }
-
- unsigned Len() const { return ::SysStringLen(m_str); }
-
- BSTR MyCopy() const
- {
- // We don't support Byte BSTRs here
- return ::SysAllocStringLen(m_str, ::SysStringLen(m_str));
- /*
- UINT byteLen = ::SysStringByteLen(m_str);
- BSTR res = ::SysAllocStringByteLen(NULL, byteLen);
- if (res && byteLen != 0 && m_str)
- memcpy(res, m_str, byteLen);
- return res;
- */
- }
-
- /*
- void Attach(BSTR src) { m_str = src; }
- BSTR Detach()
- {
- BSTR s = m_str;
- m_str = NULL;
- return s;
- }
- */
-
- void Empty()
- {
- ::SysFreeString(m_str);
- m_str = NULL;
- }
-};
-
-
-
-/*
- If CMyUnknownImp doesn't use virtual destructor, the code size is smaller.
- But if some class_1 derived from CMyUnknownImp
- uses MY_ADDREF_RELEASE and IUnknown::Release()
- and some another class_2 is derived from class_1,
- then class_1 must use virtual destructor:
- virtual ~class_1();
- In that case, class_1::Release() calls correct destructor of class_2.
-
- Also you can use virtual ~CMyUnknownImp(), if you want to disable warning
- "class has virtual functions, but destructor is not virtual".
-*/
-
-class CMyUnknownImp
-{
-public:
- ULONG __m_RefCount;
- CMyUnknownImp(): __m_RefCount(0) {}
-
- // virtual
- ~CMyUnknownImp() {}
-};
-
-
-
-#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \
-(REFGUID iid, void **outObject) throw() { *outObject = NULL;
-
-#define MY_QUERYINTERFACE_ENTRY(i) else if (iid == IID_ ## i) \
- { *outObject = (void *)(i *)this; }
-
-#define MY_QUERYINTERFACE_ENTRY_UNKNOWN(i) if (iid == IID_IUnknown) \
- { *outObject = (void *)(IUnknown *)(i *)this; }
-
-#define MY_QUERYINTERFACE_BEGIN2(i) MY_QUERYINTERFACE_BEGIN \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i) \
- MY_QUERYINTERFACE_ENTRY(i)
-
-#define MY_QUERYINTERFACE_END else return E_NOINTERFACE; ++__m_RefCount; /* AddRef(); */ return S_OK; }
-
-#define MY_ADDREF_RELEASE \
-STDMETHOD_(ULONG, AddRef)() throw() { return ++__m_RefCount; } \
-STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0) \
- return __m_RefCount; delete this; return 0; }
-
-#define MY_UNKNOWN_IMP_SPEC(i) \
- MY_QUERYINTERFACE_BEGIN \
- i \
- MY_QUERYINTERFACE_END \
- MY_ADDREF_RELEASE
-
-
-#define MY_UNKNOWN_IMP MY_QUERYINTERFACE_BEGIN \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(IUnknown) \
- MY_QUERYINTERFACE_END \
- MY_ADDREF_RELEASE
-
-#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i) \
- MY_QUERYINTERFACE_ENTRY(i) \
- )
-
-#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
- MY_QUERYINTERFACE_ENTRY(i1) \
- MY_QUERYINTERFACE_ENTRY(i2) \
- )
-
-#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
- MY_QUERYINTERFACE_ENTRY(i1) \
- MY_QUERYINTERFACE_ENTRY(i2) \
- MY_QUERYINTERFACE_ENTRY(i3) \
- )
-
-#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
- MY_QUERYINTERFACE_ENTRY(i1) \
- MY_QUERYINTERFACE_ENTRY(i2) \
- MY_QUERYINTERFACE_ENTRY(i3) \
- MY_QUERYINTERFACE_ENTRY(i4) \
- )
-
-#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
- MY_QUERYINTERFACE_ENTRY(i1) \
- MY_QUERYINTERFACE_ENTRY(i2) \
- MY_QUERYINTERFACE_ENTRY(i3) \
- MY_QUERYINTERFACE_ENTRY(i4) \
- MY_QUERYINTERFACE_ENTRY(i5) \
- )
-
-#define MY_UNKNOWN_IMP6(i1, i2, i3, i4, i5, i6) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
- MY_QUERYINTERFACE_ENTRY(i1) \
- MY_QUERYINTERFACE_ENTRY(i2) \
- MY_QUERYINTERFACE_ENTRY(i3) \
- MY_QUERYINTERFACE_ENTRY(i4) \
- MY_QUERYINTERFACE_ENTRY(i5) \
- MY_QUERYINTERFACE_ENTRY(i6) \
- )
-
-#define MY_UNKNOWN_IMP7(i1, i2, i3, i4, i5, i6, i7) MY_UNKNOWN_IMP_SPEC( \
- MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
- MY_QUERYINTERFACE_ENTRY(i1) \
- MY_QUERYINTERFACE_ENTRY(i2) \
- MY_QUERYINTERFACE_ENTRY(i3) \
- MY_QUERYINTERFACE_ENTRY(i4) \
- MY_QUERYINTERFACE_ENTRY(i5) \
- MY_QUERYINTERFACE_ENTRY(i6) \
- MY_QUERYINTERFACE_ENTRY(i7) \
- )
-
-const HRESULT k_My_HRESULT_WritingWasCut = 0x20000010;
-
-#endif
+// MyCom.h
+
+#ifndef ZIP7_INC_MY_COM_H
+#define ZIP7_INC_MY_COM_H
+
+#include "MyWindows.h"
+#include "MyTypes.h"
+
+template <class T>
+class CMyComPtr
+{
+ T* _p;
+public:
+ CMyComPtr(): _p(NULL) {}
+ CMyComPtr(T* p) throw() { if ((_p = p) != NULL) p->AddRef(); }
+ CMyComPtr(const CMyComPtr<T>& lp) throw() { if ((_p = lp._p) != NULL) _p->AddRef(); }
+ ~CMyComPtr() { if (_p) _p->Release(); }
+ void Release() { if (_p) { _p->Release(); _p = NULL; } }
+ operator T*() const { return (T*)_p; }
+ // T& operator*() const { return *_p; }
+ T** operator&() { return &_p; }
+ T* operator->() const { return _p; }
+ T* operator=(T* p)
+ {
+ if (p)
+ p->AddRef();
+ if (_p)
+ _p->Release();
+ _p = p;
+ return p;
+ }
+ T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }
+ bool operator!() const { return (_p == NULL); }
+ // bool operator==(T* pT) const { return _p == pT; }
+ void Attach(T* p2)
+ {
+ Release();
+ _p = p2;
+ }
+ T* Detach()
+ {
+ T* pt = _p;
+ _p = NULL;
+ return pt;
+ }
+ #ifdef _WIN32
+ HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
+ {
+ return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);
+ }
+ #endif
+ /*
+ HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)
+ {
+ CLSID clsid;
+ HRESULT hr = CLSIDFromProgID(szProgID, &clsid);
+ ATLASSERT(_p == NULL);
+ if (SUCCEEDED(hr))
+ hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);
+ return hr;
+ }
+ */
+ template <class Q>
+ HRESULT QueryInterface(REFGUID iid, Q** pp) const throw()
+ {
+ // if (*pp) throw 20220216; // for debug
+ return _p->QueryInterface(iid, (void**)pp);
+ }
+};
+
+#define Z7_DECL_CMyComPtr_QI_FROM(i, v, unk) \
+ CMyComPtr<i> v; (unk)->QueryInterface(IID_ ## i, (void **)&v);
+
+
+//////////////////////////////////////////////////////////
+
+inline HRESULT StringToBstr(LPCOLESTR src, BSTR *bstr)
+{
+ *bstr = ::SysAllocString(src);
+ return (*bstr) ? S_OK : E_OUTOFMEMORY;
+}
+
+class CMyComBSTR
+{
+ BSTR m_str;
+ Z7_CLASS_NO_COPY(CMyComBSTR)
+public:
+ CMyComBSTR(): m_str(NULL) {}
+ ~CMyComBSTR() { ::SysFreeString(m_str); }
+ BSTR* operator&() { return &m_str; }
+ operator LPCOLESTR() const { return m_str; }
+ // operator bool() const { return m_str != NULL; }
+ // bool operator!() const { return m_str == NULL; }
+
+ void Wipe_and_Free()
+ {
+ if (m_str)
+ {
+ memset(m_str, 0, ::SysStringLen(m_str) * sizeof(*m_str));
+ Empty();
+ }
+ }
+
+private:
+ // operator BSTR() const { return m_str; }
+
+ CMyComBSTR(LPCOLESTR src) { m_str = ::SysAllocString(src); }
+ // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }
+ // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize); }
+ // CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }
+
+ /*
+ CMyComBSTR(REFGUID src)
+ {
+ LPOLESTR szGuid;
+ StringFromCLSID(src, &szGuid);
+ m_str = ::SysAllocString(szGuid);
+ CoTaskMemFree(szGuid);
+ }
+ */
+
+ /*
+ CMyComBSTR& operator=(const CMyComBSTR& src)
+ {
+ if (m_str != src.m_str)
+ {
+ if (m_str)
+ ::SysFreeString(m_str);
+ m_str = src.MyCopy();
+ }
+ return *this;
+ }
+ */
+
+ CMyComBSTR& operator=(LPCOLESTR src)
+ {
+ ::SysFreeString(m_str);
+ m_str = ::SysAllocString(src);
+ return *this;
+ }
+
+ unsigned Len() const { return ::SysStringLen(m_str); }
+
+ BSTR MyCopy() const
+ {
+ // We don't support Byte BSTRs here
+ return ::SysAllocStringLen(m_str, ::SysStringLen(m_str));
+ /*
+ UINT byteLen = ::SysStringByteLen(m_str);
+ BSTR res = ::SysAllocStringByteLen(NULL, byteLen);
+ if (res && byteLen != 0 && m_str)
+ memcpy(res, m_str, byteLen);
+ return res;
+ */
+ }
+
+ /*
+ void Attach(BSTR src) { m_str = src; }
+ BSTR Detach()
+ {
+ BSTR s = m_str;
+ m_str = NULL;
+ return s;
+ }
+ */
+
+ void Empty()
+ {
+ ::SysFreeString(m_str);
+ m_str = NULL;
+ }
+};
+
+
+class CMyComBSTR_Wipe: public CMyComBSTR
+{
+ Z7_CLASS_NO_COPY(CMyComBSTR_Wipe)
+public:
+ CMyComBSTR_Wipe(): CMyComBSTR() {}
+ ~CMyComBSTR_Wipe() { Wipe_and_Free(); }
+};
+
+
+
+/*
+ If CMyUnknownImp doesn't use virtual destructor, the code size is smaller.
+ But if some class_1 derived from CMyUnknownImp
+ uses Z7_COM_ADDREF_RELEASE and IUnknown::Release()
+ and some another class_2 is derived from class_1,
+ then class_1 must use virtual destructor:
+ virtual ~class_1();
+ In that case, class_1::Release() calls correct destructor of class_2.
+ We can use virtual ~CMyUnknownImp() to disable warning
+ "class has virtual functions, but destructor is not virtual".
+ Also we can use virtual ~IUnknown() {} in MyWindows.h
+*/
+
+class CMyUnknownImp
+{
+ Z7_CLASS_NO_COPY(CMyUnknownImp)
+protected:
+ ULONG _m_RefCount;
+ CMyUnknownImp(): _m_RefCount(0) {}
+
+ #ifdef _WIN32
+ #if defined(__GNUC__) || defined(__clang__)
+ // virtual ~CMyUnknownImp() {} // to disable GCC/CLANG varnings
+ #endif
+ #endif
+};
+
+
+
+#define Z7_COM_QI_BEGIN \
+ private: STDMETHOD(QueryInterface) (REFGUID iid, void **outObject) throw() Z7_override Z7_final \
+ { *outObject = NULL;
+
+#define Z7_COM_QI_ENTRY(i) \
+ else if (iid == IID_ ## i) \
+ { i *ti = this; *outObject = ti; }
+// { *outObject = (void *)(i *)this; }
+
+#define Z7_COM_QI_ENTRY_UNKNOWN_0 \
+ if (iid == IID_IUnknown) \
+ { IUnknown *tu = this; *outObject = tu; }
+
+#define Z7_COM_QI_ENTRY_UNKNOWN(i) \
+ if (iid == IID_IUnknown) \
+ { i *ti = this; IUnknown *tu = ti; *outObject = tu; }
+// { *outObject = (void *)(IUnknown *)(i *)this; }
+
+#define Z7_COM_QI_BEGIN2(i) \
+ Z7_COM_QI_BEGIN \
+ Z7_COM_QI_ENTRY_UNKNOWN(i) \
+ Z7_COM_QI_ENTRY(i)
+
+#define Z7_COM_QI_END \
+ else return E_NOINTERFACE; \
+ ++_m_RefCount; /* AddRef(); */ return S_OK; }
+
+#define Z7_COM_ADDREF_RELEASE \
+ private: \
+ STDMETHOD_(ULONG, AddRef)() throw() Z7_override Z7_final \
+ { return ++_m_RefCount; } \
+ STDMETHOD_(ULONG, Release)() throw() Z7_override Z7_final \
+ { if (--_m_RefCount != 0) return _m_RefCount; delete this; return 0; } \
+
+#define Z7_COM_UNKNOWN_IMP_SPEC(i) \
+ Z7_COM_QI_BEGIN \
+ i \
+ Z7_COM_QI_END \
+ Z7_COM_ADDREF_RELEASE
+
+
+#define Z7_COM_UNKNOWN_IMP_0 \
+ Z7_COM_QI_BEGIN \
+ Z7_COM_QI_ENTRY_UNKNOWN_0 \
+ Z7_COM_QI_END \
+ Z7_COM_ADDREF_RELEASE
+
+#define Z7_COM_UNKNOWN_IMP_1(i) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i) \
+ Z7_COM_QI_ENTRY(i) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_2(i1, i2) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_3(i1, i2, i3) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_4(i1, i2, i3, i4) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ Z7_COM_QI_ENTRY(i4) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_5(i1, i2, i3, i4, i5) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ Z7_COM_QI_ENTRY(i4) \
+ Z7_COM_QI_ENTRY(i5) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_6(i1, i2, i3, i4, i5, i6) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ Z7_COM_QI_ENTRY(i4) \
+ Z7_COM_QI_ENTRY(i5) \
+ Z7_COM_QI_ENTRY(i6) \
+ )
+
+#define Z7_COM_UNKNOWN_IMP_7(i1, i2, i3, i4, i5, i6, i7) \
+ Z7_COM_UNKNOWN_IMP_SPEC( \
+ Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+ Z7_COM_QI_ENTRY(i1) \
+ Z7_COM_QI_ENTRY(i2) \
+ Z7_COM_QI_ENTRY(i3) \
+ Z7_COM_QI_ENTRY(i4) \
+ Z7_COM_QI_ENTRY(i5) \
+ Z7_COM_QI_ENTRY(i6) \
+ Z7_COM_QI_ENTRY(i7) \
+ )
+
+
+#define Z7_IFACES_IMP_UNK_1(i1) \
+ Z7_COM_UNKNOWN_IMP_1(i1) \
+ Z7_IFACE_COM7_IMP(i1) \
+
+#define Z7_IFACES_IMP_UNK_2(i1, i2) \
+ Z7_COM_UNKNOWN_IMP_2(i1, i2) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+
+#define Z7_IFACES_IMP_UNK_3(i1, i2, i3) \
+ Z7_COM_UNKNOWN_IMP_3(i1, i2, i3) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+
+#define Z7_IFACES_IMP_UNK_4(i1, i2, i3, i4) \
+ Z7_COM_UNKNOWN_IMP_4(i1, i2, i3, i4) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+ Z7_IFACE_COM7_IMP(i4) \
+
+#define Z7_IFACES_IMP_UNK_5(i1, i2, i3, i4, i5) \
+ Z7_COM_UNKNOWN_IMP_5(i1, i2, i3, i4, i5) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+ Z7_IFACE_COM7_IMP(i4) \
+ Z7_IFACE_COM7_IMP(i5) \
+
+#define Z7_IFACES_IMP_UNK_6(i1, i2, i3, i4, i5, i6) \
+ Z7_COM_UNKNOWN_IMP_6(i1, i2, i3, i4, i5, i6) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+ Z7_IFACE_COM7_IMP(i4) \
+ Z7_IFACE_COM7_IMP(i5) \
+ Z7_IFACE_COM7_IMP(i6) \
+
+
+#define Z7_CLASS_IMP_COM_0(c) \
+ Z7_class_final(c) : \
+ public IUnknown, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_0 \
+ private:
+
+#define Z7_CLASS_IMP_COM_1(c, i1) \
+ Z7_class_final(c) : \
+ public i1, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_1(i1) \
+ private:
+
+#define Z7_CLASS_IMP_COM_2(c, i1, i2) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_2(i1, i2) \
+ private:
+
+#define Z7_CLASS_IMP_COM_3(c, i1, i2, i3) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_3(i1, i2, i3) \
+ private:
+
+#define Z7_CLASS_IMP_COM_4(c, i1, i2, i3, i4) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public i4, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_4(i1, i2, i3, i4) \
+ private:
+
+#define Z7_CLASS_IMP_COM_5(c, i1, i2, i3, i4, i5) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public i4, \
+ public i5, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_5(i1, i2, i3, i4, i5) \
+ private:
+
+#define Z7_CLASS_IMP_COM_6(c, i1, i2, i3, i4, i5, i6) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public i4, \
+ public i5, \
+ public i6, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_6(i1, i2, i3, i4, i5, i6) \
+ private:
+
+
+/*
+#define Z7_CLASS_IMP_NOQIB_0(c) \
+ Z7_class_final(c) : \
+ public IUnknown, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_0 \
+ private:
+*/
+
+#define Z7_CLASS_IMP_NOQIB_1(c, i1) \
+ Z7_class_final(c) : \
+ public i1, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_0 \
+ Z7_IFACE_COM7_IMP(i1) \
+ private:
+
+#define Z7_CLASS_IMP_NOQIB_2(c, i1, i2) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_1(i2) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ private:
+
+#define Z7_CLASS_IMP_NOQIB_3(c, i1, i2, i3) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_2(i2, i3) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+ private:
+
+#define Z7_CLASS_IMP_NOQIB_4(c, i1, i2, i3, i4) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public i4, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_3(i2, i3, i4) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+ Z7_IFACE_COM7_IMP(i4) \
+
+/*
+#define Z7_CLASS_IMP_NOQIB_5(c, i1, i2, i3, i4, i5) \
+ Z7_class_final(c) : \
+ public i1, \
+ public i2, \
+ public i3, \
+ public i4, \
+ public i5, \
+ public CMyUnknownImp { \
+ Z7_COM_UNKNOWN_IMP_4(i2, i3, i4, i5) \
+ Z7_IFACE_COM7_IMP(i1) \
+ Z7_IFACE_COM7_IMP(i2) \
+ Z7_IFACE_COM7_IMP(i3) \
+ Z7_IFACE_COM7_IMP(i4) \
+ Z7_IFACE_COM7_IMP(i5) \
+*/
+
+
+#define Z7_CLASS_IMP_IInStream(c) \
+ class c Z7_final : \
+ public IInStream, \
+ public CMyUnknownImp { \
+ Z7_IFACES_IMP_UNK_2(ISequentialInStream, IInStream) \
+
+
+#define k_My_HRESULT_WritingWasCut 0x20000010
+
+#endif
diff --git a/CPP/Common/MyException.h b/CPP/Common/MyException.h
index cd9fe69..06fbdea 100644
--- a/CPP/Common/MyException.h
+++ b/CPP/Common/MyException.h
@@ -1,14 +1,14 @@
-// Common/Exception.h
-
-#ifndef __COMMON_EXCEPTION_H
-#define __COMMON_EXCEPTION_H
-
-#include "MyWindows.h"
-
-struct CSystemException
-{
- HRESULT ErrorCode;
- CSystemException(HRESULT errorCode): ErrorCode(errorCode) {}
-};
-
-#endif
+// Common/Exception.h
+
+#ifndef ZIP7_INC_COMMON_EXCEPTION_H
+#define ZIP7_INC_COMMON_EXCEPTION_H
+
+#include "MyWindows.h"
+
+struct CSystemException
+{
+ HRESULT ErrorCode;
+ CSystemException(HRESULT errorCode): ErrorCode(errorCode) {}
+};
+
+#endif
diff --git a/CPP/Common/MyGuidDef.h b/CPP/Common/MyGuidDef.h
index e0359e2..ab9993b 100644
--- a/CPP/Common/MyGuidDef.h
+++ b/CPP/Common/MyGuidDef.h
@@ -1,54 +1,63 @@
-// Common/MyGuidDef.h
-
-#ifndef GUID_DEFINED
-#define GUID_DEFINED
-
-#include "MyTypes.h"
-
-typedef struct {
- UInt32 Data1;
- UInt16 Data2;
- UInt16 Data3;
- unsigned char Data4[8];
-} GUID;
-
-#ifdef __cplusplus
-#define REFGUID const GUID &
-#else
-#define REFGUID const GUID *
-#endif
-
-#define REFCLSID REFGUID
-#define REFIID REFGUID
-
-#ifdef __cplusplus
-inline int operator==(REFGUID g1, REFGUID g2)
-{
- for (int i = 0; i < (int)sizeof(g1); i++)
- if (((unsigned char *)&g1)[i] != ((unsigned char *)&g2)[i])
- return 0;
- return 1;
-}
-inline int operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }
-#endif
-
-#ifdef __cplusplus
- #define MY_EXTERN_C extern "C"
-#else
- #define MY_EXTERN_C extern
-#endif
-
-#endif
-
-
-#ifdef DEFINE_GUID
-#undef DEFINE_GUID
-#endif
-
-#ifdef INITGUID
- #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
- MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
-#else
- #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
- MY_EXTERN_C const GUID name
-#endif
+// Common/MyGuidDef.h
+
+// #pragma message "Common/MyGuidDef.h"
+
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+
+// #pragma message "GUID_DEFINED"
+
+#include "MyTypes.h"
+
+typedef struct {
+ UInt32 Data1;
+ UInt16 Data2;
+ UInt16 Data3;
+ unsigned char Data4[8];
+} GUID;
+
+#ifdef __cplusplus
+#define REFGUID const GUID &
+#else
+#define REFGUID const GUID *
+#endif
+
+// typedef GUID IID;
+typedef GUID CLSID;
+
+#define REFCLSID REFGUID
+#define REFIID REFGUID
+
+#ifdef __cplusplus
+inline int operator==(REFGUID g1, REFGUID g2)
+{
+ for (unsigned i = 0; i < sizeof(g1); i++)
+ if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])
+ return 0;
+ return 1;
+}
+inline int operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }
+#endif
+
+#endif // GUID_DEFINED
+
+#ifndef EXTERN_C
+#ifdef __cplusplus
+ #define EXTERN_C extern "C"
+#else
+ #define EXTERN_C extern
+#endif
+#endif
+
+#ifdef DEFINE_GUID
+#undef DEFINE_GUID
+#endif
+
+#ifdef INITGUID
+ #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+ EXTERN_C const GUID name; \
+ EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+ #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+ EXTERN_C const GUID name
+#endif
diff --git a/CPP/Common/MyInitGuid.h b/CPP/Common/MyInitGuid.h
index 79fea19..3745c79 100644
--- a/CPP/Common/MyInitGuid.h
+++ b/CPP/Common/MyInitGuid.h
@@ -1,45 +1,57 @@
-// Common/MyInitGuid.h
-
-#ifndef __COMMON_MY_INITGUID_H
-#define __COMMON_MY_INITGUID_H
-
-/*
-This file must be included only to one C++ file in project before
-declarations of COM interfaces with DEFINE_GUID macro.
-
-Each GUID must be initialized exactly once in project.
-There are two different versions of the DEFINE_GUID macro in guiddef.h (MyGuidDef.h):
- - if INITGUID is not defined: DEFINE_GUID declares an external reference to the symbol name.
- - if INITGUID is defined: DEFINE_GUID initializes the symbol name to the value of the GUID.
-
-Also we need IID_IUnknown that is initialized in some file for linking:
- MSVC: by default the linker uses some lib file that contains IID_IUnknown
- MinGW: add -luuid switch for linker
- WinCE: we define IID_IUnknown in this file
- Other: we define IID_IUnknown in this file
-*/
-
-#ifdef _WIN32
-
-#ifdef UNDER_CE
-#include <basetyps.h>
-#endif
-
-#include <initguid.h>
-
-#ifdef UNDER_CE
-DEFINE_GUID(IID_IUnknown,
-0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
-#endif
-
-#else
-
-#define INITGUID
-#include "MyGuidDef.h"
-DEFINE_GUID(IID_IUnknown,
-0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
-
-#endif
-
-
-#endif
+// Common/MyInitGuid.h
+
+#ifndef ZIP7_INC_COMMON_MY_INITGUID_H
+#define ZIP7_INC_COMMON_MY_INITGUID_H
+
+/*
+This file must be included only to one C++ file in project before
+declarations of COM interfaces with DEFINE_GUID macro.
+
+Each GUID must be initialized exactly once in project.
+There are two different versions of the DEFINE_GUID macro in guiddef.h (MyGuidDef.h):
+ - if INITGUID is not defined: DEFINE_GUID declares an external reference to the symbol name.
+ - if INITGUID is defined: DEFINE_GUID initializes the symbol name to the value of the GUID.
+
+Also we need IID_IUnknown that is initialized in some file for linking:
+ MSVC: by default the linker uses some lib file that contains IID_IUnknown
+ MinGW: add -luuid switch for linker
+ WinCE: we define IID_IUnknown in this file
+ Other: we define IID_IUnknown in this file
+*/
+
+// #include "Common.h"
+/* vc6 without sdk needs <objbase.h> before <initguid.h>,
+ but it doesn't work in new msvc.
+ So we include full "MyWindows.h" instead of <objbase.h> */
+// #include <objbase.h>
+#include "MyWindows.h"
+
+#ifdef _WIN32
+
+#ifdef __clang__
+ // #pragma GCC diagnostic ignored "-Wmissing-variable-declarations"
+#endif
+
+#ifdef UNDER_CE
+#include <basetyps.h>
+#endif
+
+// for vc6 without sdk we must define INITGUID here
+#define INITGUID
+#include <initguid.h>
+
+#ifdef UNDER_CE
+DEFINE_GUID(IID_IUnknown,
+0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
+#endif
+
+#else // _WIN32
+
+#define INITGUID
+#include "MyGuidDef.h"
+DEFINE_GUID(IID_IUnknown,
+0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
+
+#endif // _WIN32
+
+#endif
diff --git a/CPP/Common/MyLinux.h b/CPP/Common/MyLinux.h
index b4e7605..a8454d7 100644
--- a/CPP/Common/MyLinux.h
+++ b/CPP/Common/MyLinux.h
@@ -1,42 +1,75 @@
-// MyLinux.h
-
-#ifndef __MY_LIN_LINUX_H
-#define __MY_LIN_LINUX_H
-
-#define MY_LIN_S_IFMT 00170000
-#define MY_LIN_S_IFSOCK 0140000
-#define MY_LIN_S_IFLNK 0120000
-#define MY_LIN_S_IFREG 0100000
-#define MY_LIN_S_IFBLK 0060000
-#define MY_LIN_S_IFDIR 0040000
-#define MY_LIN_S_IFCHR 0020000
-#define MY_LIN_S_IFIFO 0010000
-
-#define MY_LIN_S_ISLNK(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFLNK)
-#define MY_LIN_S_ISREG(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFREG)
-#define MY_LIN_S_ISDIR(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFDIR)
-#define MY_LIN_S_ISCHR(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFCHR)
-#define MY_LIN_S_ISBLK(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFBLK)
-#define MY_LIN_S_ISFIFO(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFIFO)
-#define MY_LIN_S_ISSOCK(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFSOCK)
-
-#define MY_LIN_S_ISUID 0004000
-#define MY_LIN_S_ISGID 0002000
-#define MY_LIN_S_ISVTX 0001000
-
-#define MY_LIN_S_IRWXU 00700
-#define MY_LIN_S_IRUSR 00400
-#define MY_LIN_S_IWUSR 00200
-#define MY_LIN_S_IXUSR 00100
-
-#define MY_LIN_S_IRWXG 00070
-#define MY_LIN_S_IRGRP 00040
-#define MY_LIN_S_IWGRP 00020
-#define MY_LIN_S_IXGRP 00010
-
-#define MY_LIN_S_IRWXO 00007
-#define MY_LIN_S_IROTH 00004
-#define MY_LIN_S_IWOTH 00002
-#define MY_LIN_S_IXOTH 00001
-
-#endif
+// MyLinux.h
+
+#ifndef ZIP7_INC_COMMON_MY_LINUX_H
+#define ZIP7_INC_COMMON_MY_LINUX_H
+
+// #include "../../C/7zTypes.h"
+
+#define MY_LIN_DT_UNKNOWN 0
+#define MY_LIN_DT_FIFO 1
+#define MY_LIN_DT_CHR 2
+#define MY_LIN_DT_DIR 4
+#define MY_LIN_DT_BLK 6
+#define MY_LIN_DT_REG 8
+#define MY_LIN_DT_LNK 10
+#define MY_LIN_DT_SOCK 12
+#define MY_LIN_DT_WHT 14
+
+#define MY_LIN_S_IFMT 00170000
+#define MY_LIN_S_IFSOCK 0140000
+#define MY_LIN_S_IFLNK 0120000
+#define MY_LIN_S_IFREG 0100000
+#define MY_LIN_S_IFBLK 0060000
+#define MY_LIN_S_IFDIR 0040000
+#define MY_LIN_S_IFCHR 0020000
+#define MY_LIN_S_IFIFO 0010000
+
+#define MY_LIN_S_ISLNK(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFLNK)
+#define MY_LIN_S_ISREG(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFREG)
+#define MY_LIN_S_ISDIR(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFDIR)
+#define MY_LIN_S_ISCHR(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFCHR)
+#define MY_LIN_S_ISBLK(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFBLK)
+#define MY_LIN_S_ISFIFO(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFIFO)
+#define MY_LIN_S_ISSOCK(m) (((m) & MY_LIN_S_IFMT) == MY_LIN_S_IFSOCK)
+
+#define MY_LIN_S_ISUID 0004000
+#define MY_LIN_S_ISGID 0002000
+#define MY_LIN_S_ISVTX 0001000
+
+#define MY_LIN_S_IRWXU 00700
+#define MY_LIN_S_IRUSR 00400
+#define MY_LIN_S_IWUSR 00200
+#define MY_LIN_S_IXUSR 00100
+
+#define MY_LIN_S_IRWXG 00070
+#define MY_LIN_S_IRGRP 00040
+#define MY_LIN_S_IWGRP 00020
+#define MY_LIN_S_IXGRP 00010
+
+#define MY_LIN_S_IRWXO 00007
+#define MY_LIN_S_IROTH 00004
+#define MY_LIN_S_IWOTH 00002
+#define MY_LIN_S_IXOTH 00001
+
+/*
+// major/minor encoding for makedev(): MMMMMmmmmmmMMMmm:
+
+inline UInt32 MY_dev_major(UInt64 dev)
+{
+ return ((UInt32)(dev >> 8) & (UInt32)0xfff) | ((UInt32)(dev >> 32) & ~(UInt32)0xfff);
+}
+
+inline UInt32 MY_dev_minor(UInt64 dev)
+{
+ return ((UInt32)(dev) & 0xff) | ((UInt32)(dev >> 12) & ~0xff);
+}
+
+inline UInt64 MY_dev_makedev(UInt32 __major, UInt32 __minor)
+{
+ return (__minor & 0xff) | ((__major & 0xfff) << 8)
+ | ((UInt64) (__minor & ~0xff) << 12)
+ | ((UInt64) (__major & ~0xfff) << 32);
+}
+*/
+
+#endif
diff --git a/CPP/Common/MyMap.cpp b/CPP/Common/MyMap.cpp
new file mode 100644
index 0000000..0a200f0
--- /dev/null
+++ b/CPP/Common/MyMap.cpp
@@ -0,0 +1,140 @@
+// MyMap.cpp
+
+#include "StdAfx.h"
+
+#include "MyMap.h"
+
+static const unsigned kNumBitsMax = sizeof(UInt32) * 8;
+
+static UInt32 GetSubBits(UInt32 value, unsigned startPos, unsigned numBits) throw()
+{
+ if (startPos == sizeof(value) * 8)
+ return 0;
+ value >>= startPos;
+ if (numBits == sizeof(value) * 8)
+ return value;
+ return value & (((UInt32)1 << numBits) - 1);
+}
+
+static inline unsigned GetSubBit(UInt32 v, unsigned n) { return (unsigned)(v >> n) & 1; }
+
+bool CMap32::Find(UInt32 key, UInt32 &valueRes) const throw()
+{
+ valueRes = (UInt32)(Int32)-1;
+ if (Nodes.Size() == 0)
+ return false;
+ if (Nodes.Size() == 1)
+ {
+ const CNode &n = Nodes[0];
+ if (n.Len == kNumBitsMax)
+ {
+ valueRes = n.Values[0];
+ return (key == n.Key);
+ }
+ }
+
+ unsigned cur = 0;
+ unsigned bitPos = kNumBitsMax;
+ for (;;)
+ {
+ const CNode &n = Nodes[cur];
+ bitPos -= n.Len;
+ if (GetSubBits(key, bitPos, n.Len) != GetSubBits(n.Key, bitPos, n.Len))
+ return false;
+ unsigned bit = GetSubBit(key, --bitPos);
+ if (n.IsLeaf[bit])
+ {
+ valueRes = n.Values[bit];
+ return (key == n.Keys[bit]);
+ }
+ cur = (unsigned)n.Keys[bit];
+ }
+}
+
+bool CMap32::Set(UInt32 key, UInt32 value)
+{
+ if (Nodes.Size() == 0)
+ {
+ CNode n;
+ n.Key = n.Keys[0] = n.Keys[1] = key;
+ n.Values[0] = n.Values[1] = value;
+ n.IsLeaf[0] = n.IsLeaf[1] = 1;
+ n.Len = kNumBitsMax;
+ Nodes.Add(n);
+ return false;
+ }
+ if (Nodes.Size() == 1)
+ {
+ CNode &n = Nodes[0];
+ if (n.Len == kNumBitsMax)
+ {
+ if (key == n.Key)
+ {
+ n.Values[0] = n.Values[1] = value;
+ return true;
+ }
+ unsigned i = kNumBitsMax - 1;
+ for (; GetSubBit(key, i) == GetSubBit(n.Key, i); i--);
+ n.Len = (UInt16)(kNumBitsMax - (1 + i));
+ const unsigned newBit = GetSubBit(key, i);
+ n.Values[newBit] = value;
+ n.Keys[newBit] = key;
+ return false;
+ }
+ }
+
+ unsigned cur = 0;
+ unsigned bitPos = kNumBitsMax;
+ for (;;)
+ {
+ CNode &n = Nodes[cur];
+ bitPos -= n.Len;
+ if (GetSubBits(key, bitPos, n.Len) != GetSubBits(n.Key, bitPos, n.Len))
+ {
+ unsigned i = (unsigned)n.Len - 1;
+ for (; GetSubBit(key, bitPos + i) == GetSubBit(n.Key, bitPos + i); i--);
+
+ CNode e2(n);
+ e2.Len = (UInt16)i;
+
+ n.Len = (UInt16)(n.Len - (1 + i));
+ unsigned newBit = GetSubBit(key, bitPos + i);
+ n.Values[newBit] = value;
+ n.IsLeaf[newBit] = 1;
+ n.IsLeaf[1 - newBit] = 0;
+ n.Keys[newBit] = key;
+ n.Keys[1 - newBit] = Nodes.Size();
+ Nodes.Add(e2);
+ return false;
+ }
+ const unsigned bit = GetSubBit(key, --bitPos);
+
+ if (n.IsLeaf[bit])
+ {
+ if (key == n.Keys[bit])
+ {
+ n.Values[bit] = value;
+ return true;
+ }
+ unsigned i = bitPos - 1;
+ for (; GetSubBit(key, i) == GetSubBit(n.Keys[bit], i); i--);
+
+ CNode e2;
+
+ const unsigned newBit = GetSubBit(key, i);
+ e2.Values[newBit] = value;
+ e2.Values[1 - newBit] = n.Values[bit];
+ e2.IsLeaf[newBit] = e2.IsLeaf[1 - newBit] = 1;
+ e2.Keys[newBit] = key;
+ e2.Keys[1 - newBit] = e2.Key = n.Keys[bit];
+ e2.Len = (UInt16)(bitPos - (1 + i));
+
+ n.IsLeaf[bit] = 0;
+ n.Keys[bit] = Nodes.Size();
+
+ Nodes.Add(e2);
+ return false;
+ }
+ cur = (unsigned)n.Keys[bit];
+ }
+}
diff --git a/CPP/Common/MyMap.h b/CPP/Common/MyMap.h
new file mode 100644
index 0000000..9ca5566
--- /dev/null
+++ b/CPP/Common/MyMap.h
@@ -0,0 +1,28 @@
+// MyMap.h
+
+#ifndef ZIP7_INC_COMMON_MY_MAP_H
+#define ZIP7_INC_COMMON_MY_MAP_H
+
+#include "MyTypes.h"
+#include "MyVector.h"
+
+class CMap32
+{
+ struct CNode
+ {
+ UInt32 Key;
+ UInt32 Keys[2];
+ UInt32 Values[2];
+ UInt16 Len;
+ Byte IsLeaf[2];
+ };
+ CRecordVector<CNode> Nodes;
+
+public:
+
+ void Clear() { Nodes.Clear(); }
+ bool Find(UInt32 key, UInt32 &valueRes) const throw();
+ bool Set(UInt32 key, UInt32 value); // returns true, if there is such key already
+};
+
+#endif
diff --git a/CPP/Common/MyString.cpp b/CPP/Common/MyString.cpp
index bf62303..51c1c3b 100644
--- a/CPP/Common/MyString.cpp
+++ b/CPP/Common/MyString.cpp
@@ -1,1659 +1,1859 @@
-// Common/MyString.cpp
-
-#include "StdAfx.h"
-
-#ifdef _WIN32
-#include <wchar.h>
-#else
-#include <ctype.h>
-#endif
-
-#include "IntToString.h"
-
-#if !defined(_UNICODE) || !defined(USE_UNICODE_FSTRING)
-#include "StringConvert.h"
-#endif
-
-#include "MyString.h"
-
-#define MY_STRING_NEW(_T_, _size_) new _T_[_size_]
-// #define MY_STRING_NEW(_T_, _size_) ((_T_ *)my_new((size_t)(_size_) * sizeof(_T_)))
-
-/*
-inline const char* MyStringGetNextCharPointer(const char *p) throw()
-{
- #if defined(_WIN32) && !defined(UNDER_CE)
- return CharNextA(p);
- #else
- return p + 1;
- #endif
-}
-*/
-
-#define MY_STRING_NEW_char(_size_) MY_STRING_NEW(char, _size_)
-#define MY_STRING_NEW_wchar_t(_size_) MY_STRING_NEW(wchar_t, _size_)
-
-
-int FindCharPosInString(const char *s, char c) throw()
-{
- for (const char *p = s;; p++)
- {
- if (*p == c)
- return (int)(p - s);
- if (*p == 0)
- return -1;
- // MyStringGetNextCharPointer(p);
- }
-}
-
-int FindCharPosInString(const wchar_t *s, wchar_t c) throw()
-{
- for (const wchar_t *p = s;; p++)
- {
- if (*p == c)
- return (int)(p - s);
- if (*p == 0)
- return -1;
- }
-}
-
-/*
-void MyStringUpper_Ascii(char *s) throw()
-{
- for (;;)
- {
- char c = *s;
- if (c == 0)
- return;
- *s++ = MyCharUpper_Ascii(c);
- }
-}
-
-void MyStringUpper_Ascii(wchar_t *s) throw()
-{
- for (;;)
- {
- wchar_t c = *s;
- if (c == 0)
- return;
- *s++ = MyCharUpper_Ascii(c);
- }
-}
-*/
-
-void MyStringLower_Ascii(char *s) throw()
-{
- for (;;)
- {
- char c = *s;
- if (c == 0)
- return;
- *s++ = MyCharLower_Ascii(c);
- }
-}
-
-void MyStringLower_Ascii(wchar_t *s) throw()
-{
- for (;;)
- {
- wchar_t c = *s;
- if (c == 0)
- return;
- *s++ = MyCharLower_Ascii(c);
- }
-}
-
-#ifdef _WIN32
-
-#ifdef _UNICODE
-
-// wchar_t * MyStringUpper(wchar_t *s) { return CharUpperW(s); }
-// wchar_t * MyStringLower(wchar_t *s) { return CharLowerW(s); }
-// for WinCE - FString - char
-// const char *MyStringGetPrevCharPointer(const char * /* base */, const char *p) { return p - 1; }
-
-#else
-
-// const char * MyStringGetPrevCharPointer(const char *base, const char *p) throw() { return CharPrevA(base, p); }
-// char * MyStringUpper(char *s) { return CharUpperA(s); }
-// char * MyStringLower(char *s) { return CharLowerA(s); }
-
-wchar_t MyCharUpper_WIN(wchar_t c) throw()
-{
- wchar_t *res = CharUpperW((LPWSTR)(UINT_PTR)(unsigned)c);
- if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
- return (wchar_t)(unsigned)(UINT_PTR)res;
- const int kBufSize = 4;
- char s[kBufSize + 1];
- int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufSize, 0, 0);
- if (numChars == 0 || numChars > kBufSize)
- return c;
- s[numChars] = 0;
- ::CharUpperA(s);
- ::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
- return c;
-}
-
-/*
-wchar_t MyCharLower_WIN(wchar_t c)
-{
- wchar_t *res = CharLowerW((LPWSTR)(UINT_PTR)(unsigned)c);
- if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
- return (wchar_t)(unsigned)(UINT_PTR)res;
- const int kBufSize = 4;
- char s[kBufSize + 1];
- int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufSize, 0, 0);
- if (numChars == 0 || numChars > kBufSize)
- return c;
- s[numChars] = 0;
- ::CharLowerA(s);
- ::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
- return c;
-}
-*/
-
-/*
-wchar_t * MyStringUpper(wchar_t *s)
-{
- if (s == 0)
- return 0;
- wchar_t *res = CharUpperW(s);
- if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
- return res;
- AString a = UnicodeStringToMultiByte(s);
- a.MakeUpper();
- MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
- return s;
-}
-*/
-
-/*
-wchar_t * MyStringLower(wchar_t *s)
-{
- if (s == 0)
- return 0;
- wchar_t *res = CharLowerW(s);
- if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
- return res;
- AString a = UnicodeStringToMultiByte(s);
- a.MakeLower();
- MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
- return s;
-}
-*/
-
-#endif
-
-#endif
-
-bool IsString1PrefixedByString2(const char *s1, const char *s2) throw()
-{
- for (;;)
- {
- unsigned char c2 = (unsigned char)*s2++; if (c2 == 0) return true;
- unsigned char c1 = (unsigned char)*s1++; if (c1 != c2) return false;
- }
-}
-
-bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
-{
- for (;;)
- {
- wchar_t c1 = *s1++;
- wchar_t c2 = *s2++;
- if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2)) return false;
- if (c1 == 0) return true;
- }
-}
-
-// ---------- ASCII ----------
-
-bool AString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
-{
- const char *s1 = _chars;
- for (;;)
- {
- char c2 = *s++;
- if (c2 == 0)
- return true;
- char c1 = *s1++;
- if (MyCharLower_Ascii(c1) !=
- MyCharLower_Ascii(c2))
- return false;
- }
-}
-
-bool UString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
-{
- const wchar_t *s1 = _chars;
- for (;;)
- {
- char c2 = *s++;
- if (c2 == 0)
- return true;
- wchar_t c1 = *s1++;
- if (MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
- return false;
- }
-}
-
-bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw()
-{
- for (;;)
- {
- unsigned char c = *a;
- if (c != *u)
- return false;
- if (c == 0)
- return true;
- a++;
- u++;
- }
-}
-
-bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw()
-{
- for (;;)
- {
- char c1 = *s1++;
- char c2 = *s2++;
- if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
- return false;
- if (c1 == 0)
- return true;
- }
-}
-
-bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw()
-{
- for (;;)
- {
- wchar_t c1 = *s1++;
- wchar_t c2 = *s2++;
- if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
- return false;
- if (c1 == 0)
- return true;
- }
-}
-
-bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw()
-{
- for (;;)
- {
- wchar_t c1 = *s1++;
- char c2 = *s2++;
- if (c1 != (unsigned char)c2 && (c1 > 0x7F || MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2)))
- return false;
- if (c1 == 0)
- return true;
- }
-}
-
-bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw()
-{
- for (;;)
- {
- wchar_t c2 = *s2++; if (c2 == 0) return true;
- wchar_t c1 = *s1++; if (c1 != c2) return false;
- }
-}
-
-bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw()
-{
- for (;;)
- {
- unsigned char c2 = (unsigned char)(*s2++); if (c2 == 0) return true;
- wchar_t c1 = *s1++; if (c1 != c2) return false;
- }
-}
-
-bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *s1, const char *s2) throw()
-{
- for (;;)
- {
- char c2 = *s2++; if (c2 == 0) return true;
- wchar_t c1 = *s1++;
- if (c1 != (unsigned char)c2 && MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
- return false;
- }
-}
-
-bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw()
-{
- for (;;)
- {
- wchar_t c2 = *s2++; if (c2 == 0) return true;
- wchar_t c1 = *s1++;
- if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2))
- return false;
- }
-}
-
-// NTFS order: uses upper case
-int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw()
-{
- for (;;)
- {
- wchar_t c1 = *s1++;
- wchar_t c2 = *s2++;
- if (c1 != c2)
- {
- wchar_t u1 = MyCharUpper(c1);
- wchar_t u2 = MyCharUpper(c2);
- if (u1 < u2) return -1;
- if (u1 > u2) return 1;
- }
- if (c1 == 0) return 0;
- }
-}
-
-/*
-int MyStringCompareNoCase_N(const wchar_t *s1, const wchar_t *s2, unsigned num)
-{
- for (; num != 0; num--)
- {
- wchar_t c1 = *s1++;
- wchar_t c2 = *s2++;
- if (c1 != c2)
- {
- wchar_t u1 = MyCharUpper(c1);
- wchar_t u2 = MyCharUpper(c2);
- if (u1 < u2) return -1;
- if (u1 > u2) return 1;
- }
- if (c1 == 0) return 0;
- }
- return 0;
-}
-*/
-
-// ---------- AString ----------
-
-void AString::InsertSpace(unsigned &index, unsigned size)
-{
- Grow(size);
- MoveItems(index + size, index);
-}
-
-#define k_Alloc_Len_Limit 0x40000000
-
-void AString::ReAlloc(unsigned newLimit)
-{
- if (newLimit < _len || newLimit >= k_Alloc_Len_Limit) throw 20130220;
- // MY_STRING_REALLOC(_chars, char, newLimit + 1, _len + 1);
- char *newBuf = MY_STRING_NEW_char(newLimit + 1);
- memcpy(newBuf, _chars, (size_t)(_len + 1));
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = newLimit;
-}
-
-void AString::ReAlloc2(unsigned newLimit)
-{
- if (newLimit >= k_Alloc_Len_Limit) throw 20130220;
- // MY_STRING_REALLOC(_chars, char, newLimit + 1, 0);
- char *newBuf = MY_STRING_NEW_char(newLimit + 1);
- newBuf[0] = 0;
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = newLimit;
-}
-
-void AString::SetStartLen(unsigned len)
-{
- _chars = 0;
- _chars = MY_STRING_NEW_char(len + 1);
- _len = len;
- _limit = len;
-}
-
-void AString::Grow_1()
-{
- unsigned next = _len;
- next += next / 2;
- next += 16;
- next &= ~(unsigned)15;
- ReAlloc(next - 1);
-}
-
-void AString::Grow(unsigned n)
-{
- unsigned freeSize = _limit - _len;
- if (n <= freeSize)
- return;
-
- unsigned next = _len + n;
- next += next / 2;
- next += 16;
- next &= ~(unsigned)15;
- ReAlloc(next - 1);
-}
-
-AString::AString(unsigned num, const char *s)
-{
- unsigned len = MyStringLen(s);
- if (num > len)
- num = len;
- SetStartLen(num);
- memcpy(_chars, s, num);
- _chars[num] = 0;
-}
-
-AString::AString(unsigned num, const AString &s)
-{
- if (num > s._len)
- num = s._len;
- SetStartLen(num);
- memcpy(_chars, s._chars, num);
- _chars[num] = 0;
-}
-
-AString::AString(const AString &s, char c)
-{
- SetStartLen(s.Len() + 1);
- char *chars = _chars;
- unsigned len = s.Len();
- memcpy(chars, s, len);
- chars[len] = c;
- chars[(size_t)len + 1] = 0;
-}
-
-AString::AString(const char *s1, unsigned num1, const char *s2, unsigned num2)
-{
- SetStartLen(num1 + num2);
- char *chars = _chars;
- memcpy(chars, s1, num1);
- memcpy(chars + num1, s2, num2 + 1);
-}
-
-AString operator+(const AString &s1, const AString &s2) { return AString(s1, s1.Len(), s2, s2.Len()); }
-AString operator+(const AString &s1, const char *s2) { return AString(s1, s1.Len(), s2, MyStringLen(s2)); }
-AString operator+(const char *s1, const AString &s2) { return AString(s1, MyStringLen(s1), s2, s2.Len()); }
-
-static const unsigned kStartStringCapacity = 4;
-
-AString::AString()
-{
- _chars = 0;
- _chars = MY_STRING_NEW_char(kStartStringCapacity);
- _len = 0;
- _limit = kStartStringCapacity - 1;
- _chars[0] = 0;
-}
-
-AString::AString(char c)
-{
- SetStartLen(1);
- char *chars = _chars;
- chars[0] = c;
- chars[1] = 0;
-}
-
-AString::AString(const char *s)
-{
- SetStartLen(MyStringLen(s));
- MyStringCopy(_chars, s);
-}
-
-AString::AString(const AString &s)
-{
- SetStartLen(s._len);
- MyStringCopy(_chars, s._chars);
-}
-
-AString &AString::operator=(char c)
-{
- if (1 > _limit)
- {
- char *newBuf = MY_STRING_NEW_char(1 + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = 1;
- }
- _len = 1;
- char *chars = _chars;
- chars[0] = c;
- chars[1] = 0;
- return *this;
-}
-
-AString &AString::operator=(const char *s)
-{
- unsigned len = MyStringLen(s);
- if (len > _limit)
- {
- char *newBuf = MY_STRING_NEW_char(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- MyStringCopy(_chars, s);
- return *this;
-}
-
-AString &AString::operator=(const AString &s)
-{
- if (&s == this)
- return *this;
- unsigned len = s._len;
- if (len > _limit)
- {
- char *newBuf = MY_STRING_NEW_char(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- MyStringCopy(_chars, s._chars);
- return *this;
-}
-
-void AString::SetFromWStr_if_Ascii(const wchar_t *s)
-{
- unsigned len = 0;
- {
- for (;; len++)
- {
- wchar_t c = s[len];
- if (c == 0)
- break;
- if (c >= 0x80)
- return;
- }
- }
- if (len > _limit)
- {
- char *newBuf = MY_STRING_NEW_char(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- char *dest = _chars;
- unsigned i;
- for (i = 0; i < len; i++)
- dest[i] = (char)s[i];
- dest[i] = 0;
-}
-
-/*
-void AString::SetFromBstr_if_Ascii(BSTR s)
-{
- unsigned len = ::SysStringLen(s);
- {
- for (unsigned i = 0; i < len; i++)
- if (s[i] <= 0 || s[i] >= 0x80)
- return;
- }
- if (len > _limit)
- {
- char *newBuf = MY_STRING_NEW_char(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- char *dest = _chars;
- unsigned i;
- for (i = 0; i < len; i++)
- dest[i] = (char)s[i];
- dest[i] = 0;
-}
-*/
-
-void AString::Add_Space() { operator+=(' '); }
-void AString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
-void AString::Add_LF() { operator+=('\n'); }
-
-AString &AString::operator+=(const char *s)
-{
- unsigned len = MyStringLen(s);
- Grow(len);
- MyStringCopy(_chars + _len, s);
- _len += len;
- return *this;
-}
-
-void AString::Add_OptSpaced(const char *s)
-{
- Add_Space_if_NotEmpty();
- (*this) += s;
-}
-
-AString &AString::operator+=(const AString &s)
-{
- Grow(s._len);
- MyStringCopy(_chars + _len, s._chars);
- _len += s._len;
- return *this;
-}
-
-void AString::Add_UInt32(UInt32 v)
-{
- char sz[16];
- ConvertUInt32ToString(v, sz);
- (*this) += sz;
-}
-
-void AString::SetFrom(const char *s, unsigned len) // no check
-{
- if (len > _limit)
- {
- char *newBuf = MY_STRING_NEW_char(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- if (len != 0)
- memcpy(_chars, s, len);
- _chars[len] = 0;
- _len = len;
-}
-
-void AString::SetFrom_CalcLen(const char *s, unsigned len) // no check
-{
- unsigned i;
- for (i = 0; i < len; i++)
- if (s[i] == 0)
- break;
- SetFrom(s, i);
-}
-
-int AString::Find(const char *s, unsigned startIndex) const throw()
-{
- const char *fs = strstr(_chars + startIndex, s);
- if (!fs)
- return -1;
- return (int)(fs - _chars);
-
- /*
- if (s[0] == 0)
- return startIndex;
- unsigned len = MyStringLen(s);
- const char *p = _chars + startIndex;
- for (;; p++)
- {
- const char c = *p;
- if (c != s[0])
- {
- if (c == 0)
- return -1;
- continue;
- }
- unsigned i;
- for (i = 1; i < len; i++)
- if (p[i] != s[i])
- break;
- if (i == len)
- return (int)(p - _chars);
- }
- */
-}
-
-int AString::ReverseFind(char c) const throw()
-{
- if (_len == 0)
- return -1;
- const char *p = _chars + _len - 1;
- for (;;)
- {
- if (*p == c)
- return (int)(p - _chars);
- if (p == _chars)
- return -1;
- p--; // p = GetPrevCharPointer(_chars, p);
- }
-}
-
-int AString::ReverseFind_PathSepar() const throw()
-{
- if (_len == 0)
- return -1;
- const char *p = _chars + _len - 1;
- for (;;)
- {
- char c = *p;
- if (IS_PATH_SEPAR(c))
- return (int)(p - _chars);
- if (p == _chars)
- return -1;
- p--;
- }
-}
-
-void AString::TrimLeft() throw()
-{
- const char *p = _chars;
- for (;; p++)
- {
- char c = *p;
- if (c != ' ' && c != '\n' && c != '\t')
- break;
- }
- unsigned pos = (unsigned)(p - _chars);
- if (pos != 0)
- {
- MoveItems(0, pos);
- _len -= pos;
- }
-}
-
-void AString::TrimRight() throw()
-{
- const char *p = _chars;
- unsigned i;
- for (i = _len; i != 0; i--)
- {
- char c = p[(size_t)i - 1];
- if (c != ' ' && c != '\n' && c != '\t')
- break;
- }
- if (i != _len)
- {
- _chars[i] = 0;
- _len = i;
- }
-}
-
-void AString::InsertAtFront(char c)
-{
- if (_limit == _len)
- Grow_1();
- MoveItems(1, 0);
- _chars[0] = c;
- _len++;
-}
-
-/*
-void AString::Insert(unsigned index, char c)
-{
- InsertSpace(index, 1);
- _chars[index] = c;
- _len++;
-}
-*/
-
-void AString::Insert(unsigned index, const char *s)
-{
- unsigned num = MyStringLen(s);
- if (num != 0)
- {
- InsertSpace(index, num);
- memcpy(_chars + index, s, num);
- _len += num;
- }
-}
-
-void AString::Insert(unsigned index, const AString &s)
-{
- unsigned num = s.Len();
- if (num != 0)
- {
- InsertSpace(index, num);
- memcpy(_chars + index, s, num);
- _len += num;
- }
-}
-
-void AString::RemoveChar(char ch) throw()
-{
- char *src = _chars;
-
- for (;;)
- {
- char c = *src++;
- if (c == 0)
- return;
- if (c == ch)
- break;
- }
-
- char *dest = src - 1;
-
- for (;;)
- {
- char c = *src++;
- if (c == 0)
- break;
- if (c != ch)
- *dest++ = c;
- }
-
- *dest = 0;
- _len = (unsigned)(dest - _chars);
-}
-
-// !!!!!!!!!!!!!!! test it if newChar = '\0'
-void AString::Replace(char oldChar, char newChar) throw()
-{
- if (oldChar == newChar)
- return; // 0;
- // unsigned number = 0;
- int pos = 0;
- char *chars = _chars;
- while ((unsigned)pos < _len)
- {
- pos = Find(oldChar, pos);
- if (pos < 0)
- break;
- chars[(unsigned)pos] = newChar;
- pos++;
- // number++;
- }
- return; // number;
-}
-
-void AString::Replace(const AString &oldString, const AString &newString)
-{
- if (oldString.IsEmpty())
- return; // 0;
- if (oldString == newString)
- return; // 0;
- unsigned oldLen = oldString.Len();
- unsigned newLen = newString.Len();
- // unsigned number = 0;
- int pos = 0;
- while ((unsigned)pos < _len)
- {
- pos = Find(oldString, pos);
- if (pos < 0)
- break;
- Delete(pos, oldLen);
- Insert(pos, newString);
- pos += newLen;
- // number++;
- }
- // return number;
-}
-
-void AString::Delete(unsigned index) throw()
-{
- MoveItems(index, index + 1);
- _len--;
-}
-
-void AString::Delete(unsigned index, unsigned count) throw()
-{
- if (index + count > _len)
- count = _len - index;
- if (count > 0)
- {
- MoveItems(index, index + count);
- _len -= count;
- }
-}
-
-void AString::DeleteFrontal(unsigned num) throw()
-{
- if (num != 0)
- {
- MoveItems(0, num);
- _len -= num;
- }
-}
-
-/*
-AString operator+(const AString &s1, const AString &s2)
-{
- AString result(s1);
- result += s2;
- return result;
-}
-
-AString operator+(const AString &s, const char *chars)
-{
- AString result(s);
- result += chars;
- return result;
-}
-
-AString operator+(const char *chars, const AString &s)
-{
- AString result(chars);
- result += s;
- return result;
-}
-
-AString operator+(const AString &s, char c)
-{
- AString result(s);
- result += c;
- return result;
-}
-*/
-
-/*
-AString operator+(char c, const AString &s)
-{
- AString result(c);
- result += s;
- return result;
-}
-*/
-
-
-
-
-// ---------- UString ----------
-
-void UString::InsertSpace(unsigned index, unsigned size)
-{
- Grow(size);
- MoveItems(index + size, index);
-}
-
-void UString::ReAlloc(unsigned newLimit)
-{
- if (newLimit < _len || newLimit >= k_Alloc_Len_Limit) throw 20130221;
- // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, _len + 1);
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(newLimit + 1);
- wmemcpy(newBuf, _chars, _len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = newLimit;
-}
-
-void UString::ReAlloc2(unsigned newLimit)
-{
- if (newLimit >= k_Alloc_Len_Limit) throw 20130221;
- // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(newLimit + 1);
- newBuf[0] = 0;
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = newLimit;
-}
-
-void UString::SetStartLen(unsigned len)
-{
- _chars = 0;
- _chars = MY_STRING_NEW_wchar_t(len + 1);
- _len = len;
- _limit = len;
-}
-
-void UString::Grow_1()
-{
- unsigned next = _len;
- next += next / 2;
- next += 16;
- next &= ~(unsigned)15;
- ReAlloc(next - 1);
-}
-
-void UString::Grow(unsigned n)
-{
- unsigned freeSize = _limit - _len;
- if (n <= freeSize)
- return;
-
- unsigned next = _len + n;
- next += next / 2;
- next += 16;
- next &= ~(unsigned)15;
- ReAlloc(next - 1);
-}
-
-
-UString::UString(unsigned num, const wchar_t *s)
-{
- unsigned len = MyStringLen(s);
- if (num > len)
- num = len;
- SetStartLen(num);
- wmemcpy(_chars, s, num);
- _chars[num] = 0;
-}
-
-
-UString::UString(unsigned num, const UString &s)
-{
- if (num > s._len)
- num = s._len;
- SetStartLen(num);
- wmemcpy(_chars, s._chars, num);
- _chars[num] = 0;
-}
-
-UString::UString(const UString &s, wchar_t c)
-{
- SetStartLen(s.Len() + 1);
- wchar_t *chars = _chars;
- unsigned len = s.Len();
- wmemcpy(chars, s, len);
- chars[len] = c;
- chars[(size_t)len + 1] = 0;
-}
-
-UString::UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2)
-{
- SetStartLen(num1 + num2);
- wchar_t *chars = _chars;
- wmemcpy(chars, s1, num1);
- wmemcpy(chars + num1, s2, num2 + 1);
-}
-
-UString operator+(const UString &s1, const UString &s2) { return UString(s1, s1.Len(), s2, s2.Len()); }
-UString operator+(const UString &s1, const wchar_t *s2) { return UString(s1, s1.Len(), s2, MyStringLen(s2)); }
-UString operator+(const wchar_t *s1, const UString &s2) { return UString(s1, MyStringLen(s1), s2, s2.Len()); }
-
-UString::UString()
-{
- _chars = 0;
- _chars = MY_STRING_NEW_wchar_t(kStartStringCapacity);
- _len = 0;
- _limit = kStartStringCapacity - 1;
- _chars[0] = 0;
-}
-
-UString::UString(wchar_t c)
-{
- SetStartLen(1);
- wchar_t *chars = _chars;
- chars[0] = c;
- chars[1] = 0;
-}
-
-UString::UString(char c)
-{
- SetStartLen(1);
- wchar_t *chars = _chars;
- chars[0] = (unsigned char)c;
- chars[1] = 0;
-}
-
-UString::UString(const wchar_t *s)
-{
- unsigned len = MyStringLen(s);
- SetStartLen(len);
- wmemcpy(_chars, s, len + 1);
-}
-
-UString::UString(const char *s)
-{
- unsigned len = MyStringLen(s);
- SetStartLen(len);
- wchar_t *chars = _chars;
- for (unsigned i = 0; i < len; i++)
- chars[i] = (unsigned char)s[i];
- chars[len] = 0;
-}
-
-UString::UString(const UString &s)
-{
- SetStartLen(s._len);
- wmemcpy(_chars, s._chars, s._len + 1);
-}
-
-UString &UString::operator=(wchar_t c)
-{
- if (1 > _limit)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = 1;
- }
- _len = 1;
- wchar_t *chars = _chars;
- chars[0] = c;
- chars[1] = 0;
- return *this;
-}
-
-UString &UString::operator=(const wchar_t *s)
-{
- unsigned len = MyStringLen(s);
- if (len > _limit)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- wmemcpy(_chars, s, len + 1);
- return *this;
-}
-
-UString &UString::operator=(const UString &s)
-{
- if (&s == this)
- return *this;
- unsigned len = s._len;
- if (len > _limit)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- wmemcpy(_chars, s._chars, len + 1);
- return *this;
-}
-
-void UString::SetFrom(const wchar_t *s, unsigned len) // no check
-{
- if (len > _limit)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- if (len != 0)
- wmemcpy(_chars, s, len);
- _chars[len] = 0;
- _len = len;
-}
-
-void UString::SetFromBstr(BSTR s)
-{
- unsigned len = ::SysStringLen(s);
- if (len > _limit)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- _len = len;
- // if (s)
- wmemcpy(_chars, s, len + 1);
-}
-
-UString &UString::operator=(const char *s)
-{
- unsigned len = MyStringLen(s);
- if (len > _limit)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- _limit = len;
- }
- wchar_t *chars = _chars;
- for (unsigned i = 0; i < len; i++)
- chars[i] = (unsigned char)s[i];
- chars[len] = 0;
- _len = len;
- return *this;
-}
-
-void UString::Add_Space() { operator+=(L' '); }
-void UString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
-
-void UString::Add_LF()
-{
- if (_limit == _len)
- Grow_1();
- unsigned len = _len;
- wchar_t *chars = _chars;
- chars[len++] = L'\n';
- chars[len] = 0;
- _len = len;
-}
-
-UString &UString::operator+=(const wchar_t *s)
-{
- unsigned len = MyStringLen(s);
- Grow(len);
- wmemcpy(_chars + _len, s, len + 1);
- _len += len;
- return *this;
-}
-
-UString &UString::operator+=(const UString &s)
-{
- Grow(s._len);
- wmemcpy(_chars + _len, s._chars, s._len + 1);
- _len += s._len;
- return *this;
-}
-
-UString &UString::operator+=(const char *s)
-{
- unsigned len = MyStringLen(s);
- Grow(len);
- wchar_t *chars = _chars + _len;
- for (unsigned i = 0; i < len; i++)
- chars[i] = (unsigned char)s[i];
- chars[len] = 0;
- _len += len;
- return *this;
-}
-
-
-void UString::Add_UInt32(UInt32 v)
-{
- char sz[16];
- ConvertUInt32ToString(v, sz);
- (*this) += sz;
-}
-
-
-int UString::Find(const wchar_t *s, unsigned startIndex) const throw()
-{
- const wchar_t *fs = wcsstr(_chars + startIndex, s);
- if (!fs)
- return -1;
- return (int)(fs - _chars);
-
- /*
- if (s[0] == 0)
- return startIndex;
- unsigned len = MyStringLen(s);
- const wchar_t *p = _chars + startIndex;
- for (;; p++)
- {
- const wchar_t c = *p;
- if (c != s[0])
- {
- if (c == 0)
- return -1;
- continue;
- }
- unsigned i;
- for (i = 1; i < len; i++)
- if (p[i] != s[i])
- break;
- if (i == len)
- return (int)(p - _chars);
- }
- */
-}
-
-int UString::ReverseFind(wchar_t c) const throw()
-{
- if (_len == 0)
- return -1;
- const wchar_t *p = _chars + _len - 1;
- for (;;)
- {
- if (*p == c)
- return (int)(p - _chars);
- if (p == _chars)
- return -1;
- p--;
- }
-}
-
-int UString::ReverseFind_PathSepar() const throw()
-{
- if (_len == 0)
- return -1;
- const wchar_t *p = _chars + _len - 1;
- for (;;)
- {
- wchar_t c = *p;
- if (IS_PATH_SEPAR(c))
- return (int)(p - _chars);
- if (p == _chars)
- return -1;
- p--;
- }
-}
-
-void UString::TrimLeft() throw()
-{
- const wchar_t *p = _chars;
- for (;; p++)
- {
- wchar_t c = *p;
- if (c != ' ' && c != '\n' && c != '\t')
- break;
- }
- unsigned pos = (unsigned)(p - _chars);
- if (pos != 0)
- {
- MoveItems(0, pos);
- _len -= pos;
- }
-}
-
-void UString::TrimRight() throw()
-{
- const wchar_t *p = _chars;
- unsigned i;
- for (i = _len; i != 0; i--)
- {
- wchar_t c = p[(size_t)i - 1];
- if (c != ' ' && c != '\n' && c != '\t')
- break;
- }
- if (i != _len)
- {
- _chars[i] = 0;
- _len = i;
- }
-}
-
-void UString::InsertAtFront(wchar_t c)
-{
- if (_limit == _len)
- Grow_1();
- MoveItems(1, 0);
- _chars[0] = c;
- _len++;
-}
-
-/*
-void UString::Insert(unsigned index, wchar_t c)
-{
- InsertSpace(index, 1);
- _chars[index] = c;
- _len++;
-}
-*/
-
-void UString::Insert(unsigned index, const wchar_t *s)
-{
- unsigned num = MyStringLen(s);
- if (num != 0)
- {
- InsertSpace(index, num);
- wmemcpy(_chars + index, s, num);
- _len += num;
- }
-}
-
-void UString::Insert(unsigned index, const UString &s)
-{
- unsigned num = s.Len();
- if (num != 0)
- {
- InsertSpace(index, num);
- wmemcpy(_chars + index, s, num);
- _len += num;
- }
-}
-
-void UString::RemoveChar(wchar_t ch) throw()
-{
- wchar_t *src = _chars;
-
- for (;;)
- {
- wchar_t c = *src++;
- if (c == 0)
- return;
- if (c == ch)
- break;
- }
-
- wchar_t *dest = src - 1;
-
- for (;;)
- {
- wchar_t c = *src++;
- if (c == 0)
- break;
- if (c != ch)
- *dest++ = c;
- }
-
- *dest = 0;
- _len = (unsigned)(dest - _chars);
-}
-
-// !!!!!!!!!!!!!!! test it if newChar = '\0'
-void UString::Replace(wchar_t oldChar, wchar_t newChar) throw()
-{
- if (oldChar == newChar)
- return; // 0;
- // unsigned number = 0;
- int pos = 0;
- wchar_t *chars = _chars;
- while ((unsigned)pos < _len)
- {
- pos = Find(oldChar, pos);
- if (pos < 0)
- break;
- chars[(unsigned)pos] = newChar;
- pos++;
- // number++;
- }
- return; // number;
-}
-
-void UString::Replace(const UString &oldString, const UString &newString)
-{
- if (oldString.IsEmpty())
- return; // 0;
- if (oldString == newString)
- return; // 0;
- unsigned oldLen = oldString.Len();
- unsigned newLen = newString.Len();
- // unsigned number = 0;
- int pos = 0;
- while ((unsigned)pos < _len)
- {
- pos = Find(oldString, pos);
- if (pos < 0)
- break;
- Delete(pos, oldLen);
- Insert(pos, newString);
- pos += newLen;
- // number++;
- }
- // return number;
-}
-
-void UString::Delete(unsigned index) throw()
-{
- MoveItems(index, index + 1);
- _len--;
-}
-
-void UString::Delete(unsigned index, unsigned count) throw()
-{
- if (index + count > _len)
- count = _len - index;
- if (count > 0)
- {
- MoveItems(index, index + count);
- _len -= count;
- }
-}
-
-void UString::DeleteFrontal(unsigned num) throw()
-{
- if (num != 0)
- {
- MoveItems(0, num);
- _len -= num;
- }
-}
-
-
-// ---------- UString2 ----------
-
-void UString2::ReAlloc2(unsigned newLimit)
-{
- if (newLimit >= k_Alloc_Len_Limit) throw 20130221;
- // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
- _chars = MY_STRING_NEW_wchar_t(newLimit + 1);
-}
-
-void UString2::SetStartLen(unsigned len)
-{
- _chars = 0;
- _chars = MY_STRING_NEW_wchar_t(len + 1);
- _len = len;
-}
-
-
-/*
-UString2::UString2(wchar_t c)
-{
- SetStartLen(1);
- wchar_t *chars = _chars;
- chars[0] = c;
- chars[1] = 0;
-}
-*/
-
-UString2::UString2(const wchar_t *s)
-{
- unsigned len = MyStringLen(s);
- SetStartLen(len);
- wmemcpy(_chars, s, len + 1);
-}
-
-UString2::UString2(const UString2 &s): _chars(NULL), _len(0)
-{
- if (s._chars)
- {
- SetStartLen(s._len);
- wmemcpy(_chars, s._chars, s._len + 1);
- }
-}
-
-/*
-UString2 &UString2::operator=(wchar_t c)
-{
- if (1 > _len)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
- if (_chars)
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- }
- _len = 1;
- wchar_t *chars = _chars;
- chars[0] = c;
- chars[1] = 0;
- return *this;
-}
-*/
-
-UString2 &UString2::operator=(const wchar_t *s)
-{
- unsigned len = MyStringLen(s);
- if (len > _len)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- if (_chars)
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- }
- _len = len;
- MyStringCopy(_chars, s);
- return *this;
-}
-
-void UString2::SetFromAscii(const char *s)
-{
- unsigned len = MyStringLen(s);
- if (len > _len)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- if (_chars)
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- }
- wchar_t *chars = _chars;
- for (unsigned i = 0; i < len; i++)
- chars[i] = (unsigned char)s[i];
- chars[len] = 0;
- _len = len;
-}
-
-UString2 &UString2::operator=(const UString2 &s)
-{
- if (&s == this)
- return *this;
- unsigned len = s._len;
- if (len > _len)
- {
- wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
- if (_chars)
- MY_STRING_DELETE(_chars);
- _chars = newBuf;
- }
- _len = len;
- MyStringCopy(_chars, s._chars);
- return *this;
-}
-
-bool operator==(const UString2 &s1, const UString2 &s2)
-{
- return s1.Len() == s2.Len() && (s1.IsEmpty() || wcscmp(s1.GetRawPtr(), s2.GetRawPtr()) == 0);
-}
-
-bool operator==(const UString2 &s1, const wchar_t *s2)
-{
- if (s1.IsEmpty())
- return (*s2 == 0);
- return wcscmp(s1.GetRawPtr(), s2) == 0;
-}
-
-bool operator==(const wchar_t *s1, const UString2 &s2)
-{
- if (s2.IsEmpty())
- return (*s1 == 0);
- return wcscmp(s1, s2.GetRawPtr()) == 0;
-}
-
-
-
-// ----------------------------------------
-
-/*
-int MyStringCompareNoCase(const char *s1, const char *s2)
-{
- return MyStringCompareNoCase(MultiByteToUnicodeString(s1), MultiByteToUnicodeString(s2));
-}
-*/
-
-static inline UINT GetCurrentCodePage()
-{
- #if defined(UNDER_CE) || !defined(_WIN32)
- return CP_ACP;
- #else
- return ::AreFileApisANSI() ? CP_ACP : CP_OEMCP;
- #endif
-}
-
-#ifdef USE_UNICODE_FSTRING
-
-#ifndef _UNICODE
-
-AString fs2fas(CFSTR s)
-{
- return UnicodeStringToMultiByte(s, GetCurrentCodePage());
-}
-
-FString fas2fs(const char *s)
-{
- return MultiByteToUnicodeString(s, GetCurrentCodePage());
-}
-
-FString fas2fs(const AString &s)
-{
- return MultiByteToUnicodeString(s, GetCurrentCodePage());
-}
-
-#endif
-
-#else
-
-UString fs2us(const FChar *s)
-{
- return MultiByteToUnicodeString(s, GetCurrentCodePage());
-}
-
-UString fs2us(const FString &s)
-{
- return MultiByteToUnicodeString(s, GetCurrentCodePage());
-}
-
-FString us2fs(const wchar_t *s)
-{
- return UnicodeStringToMultiByte(s, GetCurrentCodePage());
-}
-
-#endif
+// Common/MyString.cpp
+
+#include "StdAfx.h"
+
+#ifdef _WIN32
+#include <wchar.h>
+#else
+#include <ctype.h>
+#endif
+
+#include "IntToString.h"
+
+#if !defined(_UNICODE) || !defined(USE_UNICODE_FSTRING)
+#include "StringConvert.h"
+#endif
+
+#include "MyString.h"
+
+#define MY_STRING_NEW(_T_, _size_) new _T_[_size_]
+// #define MY_STRING_NEW(_T_, _size_) ((_T_ *)my_new((size_t)(_size_) * sizeof(_T_)))
+
+/*
+inline const char* MyStringGetNextCharPointer(const char *p) throw()
+{
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ return CharNextA(p);
+ #else
+ return p + 1;
+ #endif
+}
+*/
+
+#define MY_STRING_NEW_char(_size_) MY_STRING_NEW(char, (_size_))
+#define MY_STRING_NEW_wchar_t(_size_) MY_STRING_NEW(wchar_t, (_size_))
+
+
+int FindCharPosInString(const char *s, char c) throw()
+{
+ for (const char *p = s;; p++)
+ {
+ if (*p == c)
+ return (int)(p - s);
+ if (*p == 0)
+ return -1;
+ // MyStringGetNextCharPointer(p);
+ }
+}
+
+int FindCharPosInString(const wchar_t *s, wchar_t c) throw()
+{
+ for (const wchar_t *p = s;; p++)
+ {
+ if (*p == c)
+ return (int)(p - s);
+ if (*p == 0)
+ return -1;
+ }
+}
+
+/*
+void MyStringUpper_Ascii(char *s) throw()
+{
+ for (;;)
+ {
+ char c = *s;
+ if (c == 0)
+ return;
+ *s++ = MyCharUpper_Ascii(c);
+ }
+}
+
+void MyStringUpper_Ascii(wchar_t *s) throw()
+{
+ for (;;)
+ {
+ wchar_t c = *s;
+ if (c == 0)
+ return;
+ *s++ = MyCharUpper_Ascii(c);
+ }
+}
+*/
+
+void MyStringLower_Ascii(char *s) throw()
+{
+ for (;;)
+ {
+ char c = *s;
+ if (c == 0)
+ return;
+ *s++ = MyCharLower_Ascii(c);
+ }
+}
+
+void MyStringLower_Ascii(wchar_t *s) throw()
+{
+ for (;;)
+ {
+ wchar_t c = *s;
+ if (c == 0)
+ return;
+ *s++ = MyCharLower_Ascii(c);
+ }
+}
+
+#ifdef _WIN32
+
+#ifdef _UNICODE
+
+// wchar_t * MyStringUpper(wchar_t *s) { return CharUpperW(s); }
+// wchar_t * MyStringLower(wchar_t *s) { return CharLowerW(s); }
+// for WinCE - FString - char
+// const char *MyStringGetPrevCharPointer(const char * /* base */, const char *p) { return p - 1; }
+
+#else
+
+// const char * MyStringGetPrevCharPointer(const char *base, const char *p) throw() { return CharPrevA(base, p); }
+// char * MyStringUpper(char *s) { return CharUpperA(s); }
+// char * MyStringLower(char *s) { return CharLowerA(s); }
+
+wchar_t MyCharUpper_WIN(wchar_t c) throw()
+{
+ wchar_t *res = CharUpperW((LPWSTR)(UINT_PTR)(unsigned)c);
+ if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+ return (wchar_t)(unsigned)(UINT_PTR)res;
+ const int kBufSize = 4;
+ char s[kBufSize + 1];
+ int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufSize, 0, 0);
+ if (numChars == 0 || numChars > kBufSize)
+ return c;
+ s[numChars] = 0;
+ ::CharUpperA(s);
+ ::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
+ return c;
+}
+
+/*
+wchar_t MyCharLower_WIN(wchar_t c)
+{
+ wchar_t *res = CharLowerW((LPWSTR)(UINT_PTR)(unsigned)c);
+ if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+ return (wchar_t)(unsigned)(UINT_PTR)res;
+ const int kBufSize = 4;
+ char s[kBufSize + 1];
+ int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufSize, 0, 0);
+ if (numChars == 0 || numChars > kBufSize)
+ return c;
+ s[numChars] = 0;
+ ::CharLowerA(s);
+ ::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
+ return c;
+}
+*/
+
+/*
+wchar_t * MyStringUpper(wchar_t *s)
+{
+ if (s == 0)
+ return 0;
+ wchar_t *res = CharUpperW(s);
+ if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+ return res;
+ AString a = UnicodeStringToMultiByte(s);
+ a.MakeUpper();
+ MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
+ return s;
+}
+*/
+
+/*
+wchar_t * MyStringLower(wchar_t *s)
+{
+ if (s == 0)
+ return 0;
+ wchar_t *res = CharLowerW(s);
+ if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
+ return res;
+ AString a = UnicodeStringToMultiByte(s);
+ a.MakeLower();
+ MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
+ return s;
+}
+*/
+
+#endif
+
+#endif
+
+bool IsString1PrefixedByString2(const char *s1, const char *s2) throw()
+{
+ for (;;)
+ {
+ const unsigned char c2 = (unsigned char)*s2++; if (c2 == 0) return true;
+ const unsigned char c1 = (unsigned char)*s1++; if (c1 != c2) return false;
+ }
+}
+
+bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ const wchar_t c1 = *s1++;
+ const wchar_t c2 = *s2++;
+ if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2)) return false;
+ if (c1 == 0) return true;
+ }
+}
+
+// ---------- ASCII ----------
+
+bool AString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
+{
+ const char *s1 = _chars;
+ for (;;)
+ {
+ const char c2 = *s++;
+ if (c2 == 0)
+ return true;
+ const char c1 = *s1++;
+ if (MyCharLower_Ascii(c1) !=
+ MyCharLower_Ascii(c2))
+ return false;
+ }
+}
+
+bool UString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
+{
+ const wchar_t *s1 = _chars;
+ for (;;)
+ {
+ const char c2 = *s++;
+ if (c2 == 0)
+ return true;
+ const wchar_t c1 = *s1++;
+ if (MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
+ return false;
+ }
+}
+
+bool StringsAreEqual_Ascii(const char *u, const char *a) throw()
+{
+ for (;;)
+ {
+ const char c = *a;
+ if (c != *u)
+ return false;
+ if (c == 0)
+ return true;
+ a++;
+ u++;
+ }
+}
+
+bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw()
+{
+ for (;;)
+ {
+ const unsigned char c = (unsigned char)*a;
+ if (c != *u)
+ return false;
+ if (c == 0)
+ return true;
+ a++;
+ u++;
+ }
+}
+
+bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw()
+{
+ for (;;)
+ {
+ const char c1 = *s1++;
+ const char c2 = *s2++;
+ if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
+ return false;
+ if (c1 == 0)
+ return true;
+ }
+}
+
+bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ const wchar_t c1 = *s1++;
+ const wchar_t c2 = *s2++;
+ if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
+ return false;
+ if (c1 == 0)
+ return true;
+ }
+}
+
+bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw()
+{
+ for (;;)
+ {
+ const wchar_t c1 = *s1++;
+ const char c2 = *s2++;
+ if (c1 != (unsigned char)c2 && (c1 > 0x7F || MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2)))
+ return false;
+ if (c1 == 0)
+ return true;
+ }
+}
+
+bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ const wchar_t c2 = *s2++; if (c2 == 0) return true;
+ const wchar_t c1 = *s1++; if (c1 != c2) return false;
+ }
+}
+
+bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw()
+{
+ for (;;)
+ {
+ const unsigned char c2 = (unsigned char)(*s2++); if (c2 == 0) return true;
+ const wchar_t c1 = *s1++; if (c1 != c2) return false;
+ }
+}
+
+bool IsString1PrefixedByString2_NoCase_Ascii(const char *s1, const char *s2) throw()
+{
+ for (;;)
+ {
+ const char c2 = *s2++; if (c2 == 0) return true;
+ const char c1 = *s1++;
+ if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
+ return false;
+ }
+}
+
+bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *s1, const char *s2) throw()
+{
+ for (;;)
+ {
+ const char c2 = *s2++; if (c2 == 0) return true;
+ const wchar_t c1 = *s1++;
+ if (c1 != (unsigned char)c2 && MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
+ return false;
+ }
+}
+
+bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ const wchar_t c2 = *s2++; if (c2 == 0) return true;
+ const wchar_t c1 = *s1++;
+ if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2))
+ return false;
+ }
+}
+
+// NTFS order: uses upper case
+int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ const wchar_t c1 = *s1++;
+ const wchar_t c2 = *s2++;
+ if (c1 != c2)
+ {
+ const wchar_t u1 = MyCharUpper(c1);
+ const wchar_t u2 = MyCharUpper(c2);
+ if (u1 < u2) return -1;
+ if (u1 > u2) return 1;
+ }
+ if (c1 == 0) return 0;
+ }
+}
+
+/*
+int MyStringCompareNoCase_N(const wchar_t *s1, const wchar_t *s2, unsigned num)
+{
+ for (; num != 0; num--)
+ {
+ wchar_t c1 = *s1++;
+ wchar_t c2 = *s2++;
+ if (c1 != c2)
+ {
+ wchar_t u1 = MyCharUpper(c1);
+ wchar_t u2 = MyCharUpper(c2);
+ if (u1 < u2) return -1;
+ if (u1 > u2) return 1;
+ }
+ if (c1 == 0) return 0;
+ }
+ return 0;
+}
+*/
+
+// ---------- AString ----------
+
+void AString::InsertSpace(unsigned &index, unsigned size)
+{
+ Grow(size);
+ MoveItems(index + size, index);
+}
+
+#define k_Alloc_Len_Limit (0x40000000 - 2)
+
+void AString::ReAlloc(unsigned newLimit)
+{
+ // MY_STRING_REALLOC(_chars, char, (size_t)newLimit + 1, (size_t)_len + 1);
+ char *newBuf = MY_STRING_NEW_char((size_t)newLimit + 1);
+ memcpy(newBuf, _chars, (size_t)_len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = newLimit;
+}
+
+void AString::ReAlloc2(unsigned newLimit)
+{
+ if (newLimit > k_Alloc_Len_Limit) throw 20130220;
+ // MY_STRING_REALLOC(_chars, char, (size_t)newLimit + 1, 0);
+ char *newBuf = MY_STRING_NEW_char((size_t)newLimit + 1);
+ newBuf[0] = 0;
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = newLimit;
+ _len = 0;
+}
+
+void AString::SetStartLen(unsigned len)
+{
+ _chars = NULL;
+ _chars = MY_STRING_NEW_char((size_t)len + 1);
+ _len = len;
+ _limit = len;
+}
+
+void AString::Grow_1()
+{
+ unsigned next = _len;
+ next += next / 2;
+ next += 16;
+ next &= ~(unsigned)15;
+ next--;
+ if (next < _len || next > k_Alloc_Len_Limit)
+ next = k_Alloc_Len_Limit;
+ if (next <= _len)
+ throw 20130220;
+ ReAlloc(next);
+ // Grow(1);
+}
+
+void AString::Grow(unsigned n)
+{
+ const unsigned freeSize = _limit - _len;
+ if (n <= freeSize)
+ return;
+ unsigned next = _len + n;
+ next += next / 2;
+ next += 16;
+ next &= ~(unsigned)15;
+ next--;
+ if (next < _len || next > k_Alloc_Len_Limit)
+ next = k_Alloc_Len_Limit;
+ if (next <= _len || next - _len < n)
+ throw 20130220;
+ ReAlloc(next);
+}
+
+AString::AString(unsigned num, const char *s)
+{
+ unsigned len = MyStringLen(s);
+ if (num > len)
+ num = len;
+ SetStartLen(num);
+ memcpy(_chars, s, num);
+ _chars[num] = 0;
+}
+
+AString::AString(unsigned num, const AString &s)
+{
+ if (num > s._len)
+ num = s._len;
+ SetStartLen(num);
+ memcpy(_chars, s._chars, num);
+ _chars[num] = 0;
+}
+
+AString::AString(const AString &s, char c)
+{
+ SetStartLen(s.Len() + 1);
+ char *chars = _chars;
+ unsigned len = s.Len();
+ memcpy(chars, s, len);
+ chars[len] = c;
+ chars[(size_t)len + 1] = 0;
+}
+
+AString::AString(const char *s1, unsigned num1, const char *s2, unsigned num2)
+{
+ SetStartLen(num1 + num2);
+ char *chars = _chars;
+ memcpy(chars, s1, num1);
+ memcpy(chars + num1, s2, num2 + 1);
+}
+
+AString operator+(const AString &s1, const AString &s2) { return AString(s1, s1.Len(), s2, s2.Len()); }
+AString operator+(const AString &s1, const char *s2) { return AString(s1, s1.Len(), s2, MyStringLen(s2)); }
+AString operator+(const char *s1, const AString &s2) { return AString(s1, MyStringLen(s1), s2, s2.Len()); }
+
+static const unsigned kStartStringCapacity = 4;
+
+AString::AString()
+{
+ _chars = NULL;
+ _chars = MY_STRING_NEW_char(kStartStringCapacity);
+ _len = 0;
+ _limit = kStartStringCapacity - 1;
+ _chars[0] = 0;
+}
+
+AString::AString(char c)
+{
+ SetStartLen(1);
+ char *chars = _chars;
+ chars[0] = c;
+ chars[1] = 0;
+}
+
+AString::AString(const char *s)
+{
+ SetStartLen(MyStringLen(s));
+ MyStringCopy(_chars, s);
+}
+
+AString::AString(const AString &s)
+{
+ SetStartLen(s._len);
+ MyStringCopy(_chars, s._chars);
+}
+
+AString &AString::operator=(char c)
+{
+ if (1 > _limit)
+ {
+ char *newBuf = MY_STRING_NEW_char(1 + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = 1;
+ }
+ _len = 1;
+ char *chars = _chars;
+ chars[0] = c;
+ chars[1] = 0;
+ return *this;
+}
+
+AString &AString::operator=(const char *s)
+{
+ unsigned len = MyStringLen(s);
+ if (len > _limit)
+ {
+ char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+ MyStringCopy(_chars, s);
+ return *this;
+}
+
+AString &AString::operator=(const AString &s)
+{
+ if (&s == this)
+ return *this;
+ unsigned len = s._len;
+ if (len > _limit)
+ {
+ char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+ MyStringCopy(_chars, s._chars);
+ return *this;
+}
+
+void AString::SetFromWStr_if_Ascii(const wchar_t *s)
+{
+ unsigned len = 0;
+ {
+ for (;; len++)
+ {
+ wchar_t c = s[len];
+ if (c == 0)
+ break;
+ if (c >= 0x80)
+ return;
+ }
+ }
+ if (len > _limit)
+ {
+ char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+ char *dest = _chars;
+ unsigned i;
+ for (i = 0; i < len; i++)
+ dest[i] = (char)s[i];
+ dest[i] = 0;
+}
+
+/*
+void AString::SetFromBstr_if_Ascii(BSTR s)
+{
+ unsigned len = ::SysStringLen(s);
+ {
+ for (unsigned i = 0; i < len; i++)
+ if (s[i] <= 0 || s[i] >= 0x80)
+ return;
+ }
+ if (len > _limit)
+ {
+ char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+ char *dest = _chars;
+ unsigned i;
+ for (i = 0; i < len; i++)
+ dest[i] = (char)s[i];
+ dest[i] = 0;
+}
+*/
+
+void AString::Add_Space() { operator+=(' '); }
+void AString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
+void AString::Add_LF() { operator+=('\n'); }
+void AString::Add_Slash() { operator+=('/'); }
+void AString::Add_Dot() { operator+=('.'); }
+void AString::Add_Minus() { operator+=('-'); }
+
+AString &AString::operator+=(const char *s)
+{
+ unsigned len = MyStringLen(s);
+ Grow(len);
+ MyStringCopy(_chars + _len, s);
+ _len += len;
+ return *this;
+}
+
+void AString::Add_OptSpaced(const char *s)
+{
+ Add_Space_if_NotEmpty();
+ (*this) += s;
+}
+
+AString &AString::operator+=(const AString &s)
+{
+ Grow(s._len);
+ MyStringCopy(_chars + _len, s._chars);
+ _len += s._len;
+ return *this;
+}
+
+void AString::Add_UInt32(UInt32 v)
+{
+ Grow(10);
+ _len = (unsigned)(ConvertUInt32ToString(v, _chars + _len) - _chars);
+}
+
+void UString::Add_UInt64(UInt64 v)
+{
+ Grow(20);
+ _len = (unsigned)(ConvertUInt64ToString(v, _chars + _len) - _chars);
+}
+
+void AString::AddFrom(const char *s, unsigned len) // no check
+{
+ if (len != 0)
+ {
+ Grow(len);
+ memcpy(_chars + _len, s, len);
+ len += _len;
+ _chars[len] = 0;
+ _len = len;
+ }
+}
+
+void AString::SetFrom(const char *s, unsigned len) // no check
+{
+ if (len > _limit)
+ {
+ char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ if (len != 0)
+ memcpy(_chars, s, len);
+ _chars[len] = 0;
+ _len = len;
+}
+
+void AString::SetFrom_CalcLen(const char *s, unsigned len) // no check
+{
+ unsigned i;
+ for (i = 0; i < len; i++)
+ if (s[i] == 0)
+ break;
+ SetFrom(s, i);
+}
+
+int AString::Find(const char *s, unsigned startIndex) const throw()
+{
+ const char *fs = strstr(_chars + startIndex, s);
+ if (!fs)
+ return -1;
+ return (int)(fs - _chars);
+
+ /*
+ if (s[0] == 0)
+ return startIndex;
+ unsigned len = MyStringLen(s);
+ const char *p = _chars + startIndex;
+ for (;; p++)
+ {
+ const char c = *p;
+ if (c != s[0])
+ {
+ if (c == 0)
+ return -1;
+ continue;
+ }
+ unsigned i;
+ for (i = 1; i < len; i++)
+ if (p[i] != s[i])
+ break;
+ if (i == len)
+ return (int)(p - _chars);
+ }
+ */
+}
+
+int AString::ReverseFind(char c) const throw()
+{
+ if (_len == 0)
+ return -1;
+ const char *p = _chars + _len - 1;
+ for (;;)
+ {
+ if (*p == c)
+ return (int)(p - _chars);
+ if (p == _chars)
+ return -1;
+ p--; // p = GetPrevCharPointer(_chars, p);
+ }
+}
+
+int AString::ReverseFind_PathSepar() const throw()
+{
+ if (_len == 0)
+ return -1;
+ const char *p = _chars + _len - 1;
+ for (;;)
+ {
+ const char c = *p;
+ if (IS_PATH_SEPAR(c))
+ return (int)(p - _chars);
+ if (p == _chars)
+ return -1;
+ p--;
+ }
+}
+
+void AString::TrimLeft() throw()
+{
+ const char *p = _chars;
+ for (;; p++)
+ {
+ char c = *p;
+ if (c != ' ' && c != '\n' && c != '\t')
+ break;
+ }
+ unsigned pos = (unsigned)(p - _chars);
+ if (pos != 0)
+ {
+ MoveItems(0, pos);
+ _len -= pos;
+ }
+}
+
+void AString::TrimRight() throw()
+{
+ const char *p = _chars;
+ unsigned i;
+ for (i = _len; i != 0; i--)
+ {
+ char c = p[(size_t)i - 1];
+ if (c != ' ' && c != '\n' && c != '\t')
+ break;
+ }
+ if (i != _len)
+ {
+ _chars[i] = 0;
+ _len = i;
+ }
+}
+
+void AString::InsertAtFront(char c)
+{
+ if (_limit == _len)
+ Grow_1();
+ MoveItems(1, 0);
+ _chars[0] = c;
+ _len++;
+}
+
+/*
+void AString::Insert(unsigned index, char c)
+{
+ InsertSpace(index, 1);
+ _chars[index] = c;
+ _len++;
+}
+*/
+
+void AString::Insert(unsigned index, const char *s)
+{
+ unsigned num = MyStringLen(s);
+ if (num != 0)
+ {
+ InsertSpace(index, num);
+ memcpy(_chars + index, s, num);
+ _len += num;
+ }
+}
+
+void AString::Insert(unsigned index, const AString &s)
+{
+ unsigned num = s.Len();
+ if (num != 0)
+ {
+ InsertSpace(index, num);
+ memcpy(_chars + index, s, num);
+ _len += num;
+ }
+}
+
+void AString::RemoveChar(char ch) throw()
+{
+ char *src = _chars;
+
+ for (;;)
+ {
+ char c = *src++;
+ if (c == 0)
+ return;
+ if (c == ch)
+ break;
+ }
+
+ char *dest = src - 1;
+
+ for (;;)
+ {
+ char c = *src++;
+ if (c == 0)
+ break;
+ if (c != ch)
+ *dest++ = c;
+ }
+
+ *dest = 0;
+ _len = (unsigned)(dest - _chars);
+}
+
+// !!!!!!!!!!!!!!! test it if newChar = '\0'
+void AString::Replace(char oldChar, char newChar) throw()
+{
+ if (oldChar == newChar)
+ return; // 0;
+ // unsigned number = 0;
+ int pos = 0;
+ char *chars = _chars;
+ while ((unsigned)pos < _len)
+ {
+ pos = Find(oldChar, (unsigned)pos);
+ if (pos < 0)
+ break;
+ chars[(unsigned)pos] = newChar;
+ pos++;
+ // number++;
+ }
+ return; // number;
+}
+
+void AString::Replace(const AString &oldString, const AString &newString)
+{
+ if (oldString.IsEmpty())
+ return; // 0;
+ if (oldString == newString)
+ return; // 0;
+ unsigned oldLen = oldString.Len();
+ unsigned newLen = newString.Len();
+ // unsigned number = 0;
+ int pos = 0;
+ while ((unsigned)pos < _len)
+ {
+ pos = Find(oldString, (unsigned)pos);
+ if (pos < 0)
+ break;
+ Delete((unsigned)pos, oldLen);
+ Insert((unsigned)pos, newString);
+ pos += newLen;
+ // number++;
+ }
+ // return number;
+}
+
+void AString::Delete(unsigned index) throw()
+{
+ MoveItems(index, index + 1);
+ _len--;
+}
+
+void AString::Delete(unsigned index, unsigned count) throw()
+{
+ if (index + count > _len)
+ count = _len - index;
+ if (count > 0)
+ {
+ MoveItems(index, index + count);
+ _len -= count;
+ }
+}
+
+void AString::DeleteFrontal(unsigned num) throw()
+{
+ if (num != 0)
+ {
+ MoveItems(0, num);
+ _len -= num;
+ }
+}
+
+/*
+AString operator+(const AString &s1, const AString &s2)
+{
+ AString result(s1);
+ result += s2;
+ return result;
+}
+
+AString operator+(const AString &s, const char *chars)
+{
+ AString result(s);
+ result += chars;
+ return result;
+}
+
+AString operator+(const char *chars, const AString &s)
+{
+ AString result(chars);
+ result += s;
+ return result;
+}
+
+AString operator+(const AString &s, char c)
+{
+ AString result(s);
+ result += c;
+ return result;
+}
+*/
+
+/*
+AString operator+(char c, const AString &s)
+{
+ AString result(c);
+ result += s;
+ return result;
+}
+*/
+
+
+
+
+// ---------- UString ----------
+
+void UString::InsertSpace(unsigned index, unsigned size)
+{
+ Grow(size);
+ MoveItems(index + size, index);
+}
+
+void UString::ReAlloc(unsigned newLimit)
+{
+ // MY_STRING_REALLOC(_chars, wchar_t, (size_t)newLimit + 1, (size_t)_len + 1);
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)newLimit + 1);
+ wmemcpy(newBuf, _chars, _len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = newLimit;
+}
+
+void UString::ReAlloc2(unsigned newLimit)
+{
+ if (newLimit > k_Alloc_Len_Limit) throw 20130221;
+ // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)newLimit + 1);
+ newBuf[0] = 0;
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = newLimit;
+ _len = 0;
+}
+
+void UString::SetStartLen(unsigned len)
+{
+ _chars = NULL;
+ _chars = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ _len = len;
+ _limit = len;
+}
+
+void UString::Grow_1()
+{
+ unsigned next = _len;
+ next += next / 2;
+ next += 16;
+ next &= ~(unsigned)15;
+ next--;
+ if (next < _len || next > k_Alloc_Len_Limit)
+ next = k_Alloc_Len_Limit;
+ if (next <= _len)
+ throw 20130220;
+ ReAlloc(next);
+}
+
+void UString::Grow(unsigned n)
+{
+ const unsigned freeSize = _limit - _len;
+ if (n <= freeSize)
+ return;
+ unsigned next = _len + n;
+ next += next / 2;
+ next += 16;
+ next &= ~(unsigned)15;
+ next--;
+ if (next < _len || next > k_Alloc_Len_Limit)
+ next = k_Alloc_Len_Limit;
+ if (next <= _len || next - _len < n)
+ throw 20130220;
+ ReAlloc(next - 1);
+}
+
+
+UString::UString(unsigned num, const wchar_t *s)
+{
+ unsigned len = MyStringLen(s);
+ if (num > len)
+ num = len;
+ SetStartLen(num);
+ wmemcpy(_chars, s, num);
+ _chars[num] = 0;
+}
+
+
+UString::UString(unsigned num, const UString &s)
+{
+ if (num > s._len)
+ num = s._len;
+ SetStartLen(num);
+ wmemcpy(_chars, s._chars, num);
+ _chars[num] = 0;
+}
+
+UString::UString(const UString &s, wchar_t c)
+{
+ SetStartLen(s.Len() + 1);
+ wchar_t *chars = _chars;
+ unsigned len = s.Len();
+ wmemcpy(chars, s, len);
+ chars[len] = c;
+ chars[(size_t)len + 1] = 0;
+}
+
+UString::UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2)
+{
+ SetStartLen(num1 + num2);
+ wchar_t *chars = _chars;
+ wmemcpy(chars, s1, num1);
+ wmemcpy(chars + num1, s2, num2 + 1);
+}
+
+UString operator+(const UString &s1, const UString &s2) { return UString(s1, s1.Len(), s2, s2.Len()); }
+UString operator+(const UString &s1, const wchar_t *s2) { return UString(s1, s1.Len(), s2, MyStringLen(s2)); }
+UString operator+(const wchar_t *s1, const UString &s2) { return UString(s1, MyStringLen(s1), s2, s2.Len()); }
+
+UString::UString()
+{
+ _chars = NULL;
+ _chars = MY_STRING_NEW_wchar_t(kStartStringCapacity);
+ _len = 0;
+ _limit = kStartStringCapacity - 1;
+ _chars[0] = 0;
+}
+
+UString::UString(wchar_t c)
+{
+ SetStartLen(1);
+ wchar_t *chars = _chars;
+ chars[0] = c;
+ chars[1] = 0;
+}
+
+UString::UString(char c)
+{
+ SetStartLen(1);
+ wchar_t *chars = _chars;
+ chars[0] = (unsigned char)c;
+ chars[1] = 0;
+}
+
+UString::UString(const wchar_t *s)
+{
+ const unsigned len = MyStringLen(s);
+ SetStartLen(len);
+ wmemcpy(_chars, s, len + 1);
+}
+
+UString::UString(const char *s)
+{
+ const unsigned len = MyStringLen(s);
+ SetStartLen(len);
+ wchar_t *chars = _chars;
+ for (unsigned i = 0; i < len; i++)
+ chars[i] = (unsigned char)s[i];
+ chars[len] = 0;
+}
+
+UString::UString(const AString &s)
+{
+ const unsigned len = s.Len();
+ SetStartLen(len);
+ wchar_t *chars = _chars;
+ const char *s2 = s.Ptr();
+ for (unsigned i = 0; i < len; i++)
+ chars[i] = (unsigned char)s2[i];
+ chars[len] = 0;
+}
+
+UString::UString(const UString &s)
+{
+ SetStartLen(s._len);
+ wmemcpy(_chars, s._chars, s._len + 1);
+}
+
+UString &UString::operator=(wchar_t c)
+{
+ if (1 > _limit)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = 1;
+ }
+ _len = 1;
+ wchar_t *chars = _chars;
+ chars[0] = c;
+ chars[1] = 0;
+ return *this;
+}
+
+UString &UString::operator=(const wchar_t *s)
+{
+ unsigned len = MyStringLen(s);
+ if (len > _limit)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+ wmemcpy(_chars, s, len + 1);
+ return *this;
+}
+
+UString &UString::operator=(const UString &s)
+{
+ if (&s == this)
+ return *this;
+ unsigned len = s._len;
+ if (len > _limit)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+ wmemcpy(_chars, s._chars, len + 1);
+ return *this;
+}
+
+void UString::SetFrom(const wchar_t *s, unsigned len) // no check
+{
+ if (len > _limit)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ if (len != 0)
+ wmemcpy(_chars, s, len);
+ _chars[len] = 0;
+ _len = len;
+}
+
+void UString::SetFromBstr(LPCOLESTR s)
+{
+ unsigned len = ::SysStringLen((BSTR)(void *)(s));
+
+ /*
+ #if WCHAR_MAX > 0xffff
+ size_t num_wchars = 0;
+ for (size_t i = 0; i < len;)
+ {
+ wchar_t c = s[i++];
+ if (c >= 0xd800 && c < 0xdc00 && i + 1 != len)
+ {
+ wchar_t c2 = s[i];
+ if (c2 >= 0xdc00 && c2 < 0x10000)
+ {
+ c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+ i++;
+ }
+ }
+ num_wchars++;
+ }
+ len = num_wchars;
+ #endif
+ */
+
+ if (len > _limit)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ _len = len;
+
+ /*
+ #if WCHAR_MAX > 0xffff
+
+ wchar_t *chars = _chars;
+ for (size_t i = 0; i <= len; i++)
+ {
+ wchar_t c = *s++;
+ if (c >= 0xd800 && c < 0xdc00 && i + 1 != len)
+ {
+ wchar_t c2 = *s;
+ if (c2 >= 0xdc00 && c2 < 0x10000)
+ {
+ s++;
+ c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+ }
+ }
+ chars[i] = c;
+ }
+
+ #else
+ */
+
+ // if (s)
+ wmemcpy(_chars, s, len + 1);
+
+ // #endif
+}
+
+UString &UString::operator=(const char *s)
+{
+ unsigned len = MyStringLen(s);
+ if (len > _limit)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ _limit = len;
+ }
+ wchar_t *chars = _chars;
+ for (unsigned i = 0; i < len; i++)
+ chars[i] = (unsigned char)s[i];
+ chars[len] = 0;
+ _len = len;
+ return *this;
+}
+
+void UString::Add_Dot() { operator+=(L'.'); }
+void UString::Add_Space() { operator+=(L' '); }
+void UString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
+
+void UString::Add_LF()
+{
+ if (_limit == _len)
+ Grow_1();
+ unsigned len = _len;
+ wchar_t *chars = _chars;
+ chars[len++] = L'\n';
+ chars[len] = 0;
+ _len = len;
+}
+
+UString &UString::operator+=(const wchar_t *s)
+{
+ unsigned len = MyStringLen(s);
+ Grow(len);
+ wmemcpy(_chars + _len, s, len + 1);
+ _len += len;
+ return *this;
+}
+
+UString &UString::operator+=(const UString &s)
+{
+ Grow(s._len);
+ wmemcpy(_chars + _len, s._chars, s._len + 1);
+ _len += s._len;
+ return *this;
+}
+
+UString &UString::operator+=(const char *s)
+{
+ unsigned len = MyStringLen(s);
+ Grow(len);
+ wchar_t *chars = _chars + _len;
+ for (unsigned i = 0; i < len; i++)
+ chars[i] = (unsigned char)s[i];
+ chars[len] = 0;
+ _len += len;
+ return *this;
+}
+
+
+void UString::Add_UInt32(UInt32 v)
+{
+ Grow(10);
+ _len = (unsigned)(ConvertUInt32ToString(v, _chars + _len) - _chars);
+}
+
+void AString::Add_UInt64(UInt64 v)
+{
+ Grow(20);
+ _len = (unsigned)(ConvertUInt64ToString(v, _chars + _len) - _chars);
+}
+
+
+int UString::Find(const wchar_t *s, unsigned startIndex) const throw()
+{
+ const wchar_t *fs = wcsstr(_chars + startIndex, s);
+ if (!fs)
+ return -1;
+ return (int)(fs - _chars);
+
+ /*
+ if (s[0] == 0)
+ return startIndex;
+ unsigned len = MyStringLen(s);
+ const wchar_t *p = _chars + startIndex;
+ for (;; p++)
+ {
+ const wchar_t c = *p;
+ if (c != s[0])
+ {
+ if (c == 0)
+ return -1;
+ continue;
+ }
+ unsigned i;
+ for (i = 1; i < len; i++)
+ if (p[i] != s[i])
+ break;
+ if (i == len)
+ return (int)(p - _chars);
+ }
+ */
+}
+
+int UString::ReverseFind(wchar_t c) const throw()
+{
+ if (_len == 0)
+ return -1;
+ const wchar_t *p = _chars + _len;
+ do
+ {
+ if (*(--p) == c)
+ return (int)(p - _chars);
+ }
+ while (p != _chars);
+ return -1;
+}
+
+int UString::ReverseFind_PathSepar() const throw()
+{
+ const wchar_t *p = _chars + _len;
+ while (p != _chars)
+ {
+ const wchar_t c = *(--p);
+ if (IS_PATH_SEPAR(c))
+ return (int)(p - _chars);
+ }
+ return -1;
+}
+
+void UString::TrimLeft() throw()
+{
+ const wchar_t *p = _chars;
+ for (;; p++)
+ {
+ wchar_t c = *p;
+ if (c != ' ' && c != '\n' && c != '\t')
+ break;
+ }
+ unsigned pos = (unsigned)(p - _chars);
+ if (pos != 0)
+ {
+ MoveItems(0, pos);
+ _len -= pos;
+ }
+}
+
+void UString::TrimRight() throw()
+{
+ const wchar_t *p = _chars;
+ unsigned i;
+ for (i = _len; i != 0; i--)
+ {
+ wchar_t c = p[(size_t)i - 1];
+ if (c != ' ' && c != '\n' && c != '\t')
+ break;
+ }
+ if (i != _len)
+ {
+ _chars[i] = 0;
+ _len = i;
+ }
+}
+
+void UString::InsertAtFront(wchar_t c)
+{
+ if (_limit == _len)
+ Grow_1();
+ MoveItems(1, 0);
+ _chars[0] = c;
+ _len++;
+}
+
+/*
+void UString::Insert_wchar_t(unsigned index, wchar_t c)
+{
+ InsertSpace(index, 1);
+ _chars[index] = c;
+ _len++;
+}
+*/
+
+void UString::Insert(unsigned index, const wchar_t *s)
+{
+ unsigned num = MyStringLen(s);
+ if (num != 0)
+ {
+ InsertSpace(index, num);
+ wmemcpy(_chars + index, s, num);
+ _len += num;
+ }
+}
+
+void UString::Insert(unsigned index, const UString &s)
+{
+ unsigned num = s.Len();
+ if (num != 0)
+ {
+ InsertSpace(index, num);
+ wmemcpy(_chars + index, s, num);
+ _len += num;
+ }
+}
+
+void UString::RemoveChar(wchar_t ch) throw()
+{
+ wchar_t *src = _chars;
+
+ for (;;)
+ {
+ wchar_t c = *src++;
+ if (c == 0)
+ return;
+ if (c == ch)
+ break;
+ }
+
+ wchar_t *dest = src - 1;
+
+ for (;;)
+ {
+ wchar_t c = *src++;
+ if (c == 0)
+ break;
+ if (c != ch)
+ *dest++ = c;
+ }
+
+ *dest = 0;
+ _len = (unsigned)(dest - _chars);
+}
+
+// !!!!!!!!!!!!!!! test it if newChar = '\0'
+void UString::Replace(wchar_t oldChar, wchar_t newChar) throw()
+{
+ if (oldChar == newChar)
+ return; // 0;
+ // unsigned number = 0;
+ int pos = 0;
+ wchar_t *chars = _chars;
+ while ((unsigned)pos < _len)
+ {
+ pos = Find(oldChar, (unsigned)pos);
+ if (pos < 0)
+ break;
+ chars[(unsigned)pos] = newChar;
+ pos++;
+ // number++;
+ }
+ return; // number;
+}
+
+void UString::Replace(const UString &oldString, const UString &newString)
+{
+ if (oldString.IsEmpty())
+ return; // 0;
+ if (oldString == newString)
+ return; // 0;
+ unsigned oldLen = oldString.Len();
+ unsigned newLen = newString.Len();
+ // unsigned number = 0;
+ int pos = 0;
+ while ((unsigned)pos < _len)
+ {
+ pos = Find(oldString, (unsigned)pos);
+ if (pos < 0)
+ break;
+ Delete((unsigned)pos, oldLen);
+ Insert((unsigned)pos, newString);
+ pos += newLen;
+ // number++;
+ }
+ // return number;
+}
+
+void UString::Delete(unsigned index) throw()
+{
+ MoveItems(index, index + 1);
+ _len--;
+}
+
+void UString::Delete(unsigned index, unsigned count) throw()
+{
+ if (index + count > _len)
+ count = _len - index;
+ if (count > 0)
+ {
+ MoveItems(index, index + count);
+ _len -= count;
+ }
+}
+
+void UString::DeleteFrontal(unsigned num) throw()
+{
+ if (num != 0)
+ {
+ MoveItems(0, num);
+ _len -= num;
+ }
+}
+
+
+// ---------- UString2 ----------
+
+void UString2::ReAlloc2(unsigned newLimit)
+{
+ // wrong (_len) is allowed after this function
+ if (newLimit > k_Alloc_Len_Limit) throw 20130221;
+ // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
+ if (_chars)
+ {
+ MY_STRING_DELETE(_chars)
+ _chars = NULL;
+ // _len = 0;
+ }
+ _chars = MY_STRING_NEW_wchar_t((size_t)newLimit + 1);
+ _chars[0] = 0;
+ // _len = newLimit;
+}
+
+void UString2::SetStartLen(unsigned len)
+{
+ _chars = NULL;
+ _chars = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ _len = len;
+}
+
+
+/*
+UString2::UString2(wchar_t c)
+{
+ SetStartLen(1);
+ wchar_t *chars = _chars;
+ chars[0] = c;
+ chars[1] = 0;
+}
+*/
+
+UString2::UString2(const wchar_t *s)
+{
+ const unsigned len = MyStringLen(s);
+ SetStartLen(len);
+ wmemcpy(_chars, s, len + 1);
+}
+
+UString2::UString2(const UString2 &s): _chars(NULL), _len(0)
+{
+ if (s._chars)
+ {
+ SetStartLen(s._len);
+ wmemcpy(_chars, s._chars, s._len + 1);
+ }
+}
+
+/*
+UString2 &UString2::operator=(wchar_t c)
+{
+ if (1 > _len)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
+ if (_chars)
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ }
+ _len = 1;
+ wchar_t *chars = _chars;
+ chars[0] = c;
+ chars[1] = 0;
+ return *this;
+}
+*/
+
+UString2 &UString2::operator=(const wchar_t *s)
+{
+ unsigned len = MyStringLen(s);
+ if (len > _len)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ if (_chars)
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ }
+ _len = len;
+ MyStringCopy(_chars, s);
+ return *this;
+}
+
+void UString2::SetFromAscii(const char *s)
+{
+ unsigned len = MyStringLen(s);
+ if (len > _len)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ if (_chars)
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ }
+ wchar_t *chars = _chars;
+ for (unsigned i = 0; i < len; i++)
+ chars[i] = (unsigned char)s[i];
+ chars[len] = 0;
+ _len = len;
+}
+
+UString2 &UString2::operator=(const UString2 &s)
+{
+ if (&s == this)
+ return *this;
+ unsigned len = s._len;
+ if (len > _len)
+ {
+ wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+ if (_chars)
+ MY_STRING_DELETE(_chars)
+ _chars = newBuf;
+ }
+ _len = len;
+ MyStringCopy(_chars, s._chars);
+ return *this;
+}
+
+bool operator==(const UString2 &s1, const UString2 &s2)
+{
+ return s1.Len() == s2.Len() && (s1.IsEmpty() || wcscmp(s1.GetRawPtr(), s2.GetRawPtr()) == 0);
+}
+
+bool operator==(const UString2 &s1, const wchar_t *s2)
+{
+ if (s1.IsEmpty())
+ return (*s2 == 0);
+ return wcscmp(s1.GetRawPtr(), s2) == 0;
+}
+
+bool operator==(const wchar_t *s1, const UString2 &s2)
+{
+ if (s2.IsEmpty())
+ return (*s1 == 0);
+ return wcscmp(s1, s2.GetRawPtr()) == 0;
+}
+
+
+
+// ----------------------------------------
+
+/*
+int MyStringCompareNoCase(const char *s1, const char *s2)
+{
+ return MyStringCompareNoCase(MultiByteToUnicodeString(s1), MultiByteToUnicodeString(s2));
+}
+*/
+
+#if !defined(USE_UNICODE_FSTRING) || !defined(_UNICODE)
+
+static inline UINT GetCurrentCodePage()
+{
+ #if defined(UNDER_CE) || !defined(_WIN32)
+ return CP_ACP;
+ #else
+ return ::AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+ #endif
+}
+
+#endif
+
+#ifdef USE_UNICODE_FSTRING
+
+#ifndef _UNICODE
+
+AString fs2fas(CFSTR s)
+{
+ return UnicodeStringToMultiByte(s, GetCurrentCodePage());
+}
+
+FString fas2fs(const char *s)
+{
+ return MultiByteToUnicodeString(s, GetCurrentCodePage());
+}
+
+FString fas2fs(const AString &s)
+{
+ return MultiByteToUnicodeString(s, GetCurrentCodePage());
+}
+
+#endif // _UNICODE
+
+#else // USE_UNICODE_FSTRING
+
+UString fs2us(const FChar *s)
+{
+ return MultiByteToUnicodeString(s, GetCurrentCodePage());
+}
+
+UString fs2us(const FString &s)
+{
+ return MultiByteToUnicodeString(s, GetCurrentCodePage());
+}
+
+FString us2fs(const wchar_t *s)
+{
+ return UnicodeStringToMultiByte(s, GetCurrentCodePage());
+}
+
+#endif // USE_UNICODE_FSTRING
+
+
+bool CStringFinder::FindWord_In_LowCaseAsciiList_NoCase(const char *p, const wchar_t *str)
+{
+ _temp.Empty();
+ for (;;)
+ {
+ const wchar_t c = *str++;
+ if (c == 0)
+ break;
+ if (c <= 0x20 || c > 0x7f)
+ return false;
+ _temp += (char)MyCharLower_Ascii((char)c);
+ }
+
+ while (*p != 0)
+ {
+ const char *s2 = _temp.Ptr();
+ char c, c2;
+ do
+ {
+ c = *p++;
+ c2 = *s2++;
+ }
+ while (c == c2);
+
+ if (c == ' ')
+ {
+ if (c2 == 0)
+ return true;
+ continue;
+ }
+
+ while (*p++ != ' ');
+ }
+
+ return false;
+}
+
+
+void SplitString(const UString &srcString, UStringVector &destStrings)
+{
+ destStrings.Clear();
+ unsigned len = srcString.Len();
+ if (len == 0)
+ return;
+ UString s;
+ for (unsigned i = 0; i < len; i++)
+ {
+ const wchar_t c = srcString[i];
+ if (c == ' ')
+ {
+ if (!s.IsEmpty())
+ {
+ destStrings.Add(s);
+ s.Empty();
+ }
+ }
+ else
+ s += c;
+ }
+ if (!s.IsEmpty())
+ destStrings.Add(s);
+}
diff --git a/CPP/Common/MyString.h b/CPP/Common/MyString.h
index 45cea98..e5ce18a 100644
--- a/CPP/Common/MyString.h
+++ b/CPP/Common/MyString.h
@@ -1,868 +1,1064 @@
-// Common/String.h
-
-#ifndef __COMMON_STRING_H
-#define __COMMON_STRING_H
-
-#include <string.h>
-
-#ifndef _WIN32
-#include <wctype.h>
-#include <wchar.h>
-#endif
-
-#include "MyWindows.h"
-#include "MyTypes.h"
-#include "MyVector.h"
-
-
-#ifdef _MSC_VER
- #ifdef _NATIVE_WCHAR_T_DEFINED
- #define MY_NATIVE_WCHAR_T_DEFINED
- #endif
-#else
- #define MY_NATIVE_WCHAR_T_DEFINED
-#endif
-
-/*
- native support for wchar_t:
- _MSC_VER == 1600 : /Zc:wchar_t is not supported
- _MSC_VER == 1310 (VS2003)
- ? _MSC_VER == 1400 (VS2005) : wchar_t <- unsigned short
- /Zc:wchar_t : wchar_t <- __wchar_t, _WCHAR_T_DEFINED and _NATIVE_WCHAR_T_DEFINED
- _MSC_VER > 1400 (VS2008+)
- /Zc:wchar_t[-]
- /Zc:wchar_t is on by default
-*/
-
-#ifdef _WIN32
-#define IS_PATH_SEPAR(c) ((c) == '\\' || (c) == '/')
-#else
-#define IS_PATH_SEPAR(c) ((c) == CHAR_PATH_SEPARATOR)
-#endif
-
-inline bool IsPathSepar(char c) { return IS_PATH_SEPAR(c); }
-inline bool IsPathSepar(wchar_t c) { return IS_PATH_SEPAR(c); }
-
-inline unsigned MyStringLen(const char *s)
-{
- unsigned i;
- for (i = 0; s[i] != 0; i++);
- return i;
-}
-
-inline void MyStringCopy(char *dest, const char *src)
-{
- while ((*dest++ = *src++) != 0);
-}
-
-inline char *MyStpCpy(char *dest, const char *src)
-{
- for (;;)
- {
- char c = *src;
- *dest = c;
- if (c == 0)
- return dest;
- src++;
- dest++;
- }
-}
-
-inline unsigned MyStringLen(const wchar_t *s)
-{
- unsigned i;
- for (i = 0; s[i] != 0; i++);
- return i;
-}
-
-inline void MyStringCopy(wchar_t *dest, const wchar_t *src)
-{
- while ((*dest++ = *src++) != 0);
-}
-
-inline void MyStringCat(wchar_t *dest, const wchar_t *src)
-{
- MyStringCopy(dest + MyStringLen(dest), src);
-}
-
-
-/*
-inline wchar_t *MyWcpCpy(wchar_t *dest, const wchar_t *src)
-{
- for (;;)
- {
- wchar_t c = *src;
- *dest = c;
- if (c == 0)
- return dest;
- src++;
- dest++;
- }
-}
-*/
-
-int FindCharPosInString(const char *s, char c) throw();
-int FindCharPosInString(const wchar_t *s, wchar_t c) throw();
-
-#ifdef _WIN32
- #ifndef _UNICODE
- #define STRING_UNICODE_THROW
- #endif
-#endif
-
-#ifndef STRING_UNICODE_THROW
- #define STRING_UNICODE_THROW throw()
-#endif
-
-
-inline char MyCharUpper_Ascii(char c)
-{
- if (c >= 'a' && c <= 'z')
- return (char)((unsigned char)c - 0x20);
- return c;
-}
-
-/*
-inline wchar_t MyCharUpper_Ascii(wchar_t c)
-{
- if (c >= 'a' && c <= 'z')
- return (wchar_t)(c - 0x20);
- return c;
-}
-*/
-
-inline char MyCharLower_Ascii(char c)
-{
- if (c >= 'A' && c <= 'Z')
- return (char)((unsigned char)c + 0x20);
- return c;
-}
-
-inline wchar_t MyCharLower_Ascii(wchar_t c)
-{
- if (c >= 'A' && c <= 'Z')
- return (wchar_t)(c + 0x20);
- return c;
-}
-
-wchar_t MyCharUpper_WIN(wchar_t c) throw();
-
-inline wchar_t MyCharUpper(wchar_t c) throw()
-{
- if (c < 'a') return c;
- if (c <= 'z') return (wchar_t)(c - 0x20);
- if (c <= 0x7F) return c;
- #ifdef _WIN32
- #ifdef _UNICODE
- return (wchar_t)(unsigned)(UINT_PTR)CharUpperW((LPWSTR)(UINT_PTR)(unsigned)c);
- #else
- return (wchar_t)MyCharUpper_WIN(c);
- #endif
- #else
- return (wchar_t)towupper(c);
- #endif
-}
-
-/*
-wchar_t MyCharLower_WIN(wchar_t c) throw();
-
-inline wchar_t MyCharLower(wchar_t c) throw()
-{
- if (c < 'A') return c;
- if (c <= 'Z') return (wchar_t)(c + 0x20);
- if (c <= 0x7F) return c;
- #ifdef _WIN32
- #ifdef _UNICODE
- return (wchar_t)(unsigned)(UINT_PTR)CharLowerW((LPWSTR)(UINT_PTR)(unsigned)c);
- #else
- return (wchar_t)MyCharLower_WIN(c);
- #endif
- #else
- return (wchar_t)tolower(c);
- #endif
-}
-*/
-
-// char *MyStringUpper(char *s) throw();
-// char *MyStringLower(char *s) throw();
-
-// void MyStringUpper_Ascii(char *s) throw();
-// void MyStringUpper_Ascii(wchar_t *s) throw();
-void MyStringLower_Ascii(char *s) throw();
-void MyStringLower_Ascii(wchar_t *s) throw();
-// wchar_t *MyStringUpper(wchar_t *s) STRING_UNICODE_THROW;
-// wchar_t *MyStringLower(wchar_t *s) STRING_UNICODE_THROW;
-
-bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw();
-
-bool IsString1PrefixedByString2(const char *s1, const char *s2) throw();
-bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw();
-bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw();
-bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *u, const char *a) throw();
-bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw();
-
-#define MyStringCompare(s1, s2) wcscmp(s1, s2)
-int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw();
-// int MyStringCompareNoCase_N(const wchar_t *s1, const wchar_t *s2, unsigned num) throw();
-
-// ---------- ASCII ----------
-// char values in ASCII strings must be less then 128
-bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw();
-bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw();
-bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw();
-bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw();
-
-#define MY_STRING_DELETE(_p_) delete []_p_;
-// #define MY_STRING_DELETE(_p_) my_delete(_p_);
-
-
-#define FORBID_STRING_OPS_2(cls, t) \
- void Find(t) const; \
- void Find(t, unsigned startIndex) const; \
- void ReverseFind(t) const; \
- void InsertAtFront(t); \
- void RemoveChar(t); \
- void Replace(t, t); \
-
-#define FORBID_STRING_OPS(cls, t) \
- explicit cls(t); \
- explicit cls(const t *); \
- cls &operator=(t); \
- cls &operator=(const t *); \
- cls &operator+=(t); \
- cls &operator+=(const t *); \
- FORBID_STRING_OPS_2(cls, t); \
-
-/*
- cls &operator+(t); \
- cls &operator+(const t *); \
-*/
-
-#define FORBID_STRING_OPS_AString(t) FORBID_STRING_OPS(AString, t)
-#define FORBID_STRING_OPS_UString(t) FORBID_STRING_OPS(UString, t)
-#define FORBID_STRING_OPS_UString2(t) FORBID_STRING_OPS(UString2, t)
-
-class AString
-{
- char *_chars;
- unsigned _len;
- unsigned _limit;
-
- void MoveItems(unsigned dest, unsigned src)
- {
- memmove(_chars + dest, _chars + src, (size_t)(_len - src + 1) * sizeof(char));
- }
-
- void InsertSpace(unsigned &index, unsigned size);
-
- void ReAlloc(unsigned newLimit);
- void ReAlloc2(unsigned newLimit);
- void SetStartLen(unsigned len);
- void Grow_1();
- void Grow(unsigned n);
-
- AString(unsigned num, const char *s);
- AString(unsigned num, const AString &s);
- AString(const AString &s, char c); // it's for String + char
- AString(const char *s1, unsigned num1, const char *s2, unsigned num2);
-
- friend AString operator+(const AString &s, char c) { return AString(s, c); } ;
- // friend AString operator+(char c, const AString &s); // is not supported
-
- friend AString operator+(const AString &s1, const AString &s2);
- friend AString operator+(const AString &s1, const char *s2);
- friend AString operator+(const char *s1, const AString &s2);
-
- // ---------- forbidden functions ----------
-
- #ifdef MY_NATIVE_WCHAR_T_DEFINED
- FORBID_STRING_OPS_AString(wchar_t)
- #endif
-
- FORBID_STRING_OPS_AString(signed char)
- FORBID_STRING_OPS_AString(unsigned char)
- FORBID_STRING_OPS_AString(short)
- FORBID_STRING_OPS_AString(unsigned short)
- FORBID_STRING_OPS_AString(int)
- FORBID_STRING_OPS_AString(unsigned)
- FORBID_STRING_OPS_AString(long)
- FORBID_STRING_OPS_AString(unsigned long)
-
-public:
- explicit AString();
- explicit AString(char c);
- explicit AString(const char *s);
- AString(const AString &s);
- ~AString() { MY_STRING_DELETE(_chars); }
-
- unsigned Len() const { return _len; }
- bool IsEmpty() const { return _len == 0; }
- void Empty() { _len = 0; _chars[0] = 0; }
-
- operator const char *() const { return _chars; }
- const char *Ptr() const { return _chars; }
- const char *Ptr(unsigned pos) const { return _chars + pos; }
- const char *RightPtr(unsigned num) const { return _chars + _len - num; }
- char Back() const { return _chars[(size_t)_len - 1]; }
-
- void ReplaceOneCharAtPos(unsigned pos, char c) { _chars[pos] = c; }
-
- char *GetBuf() { return _chars; }
- /* GetBuf(minLen): provides the buffer that can store
- at least (minLen) characters and additional null terminator.
- 9.35: GetBuf doesn't preserve old characters and terminator */
- char *GetBuf(unsigned minLen)
- {
- if (minLen > _limit)
- ReAlloc2(minLen);
- return _chars;
- }
- char *GetBuf_SetEnd(unsigned minLen)
- {
- if (minLen > _limit)
- ReAlloc2(minLen);
- char *chars = _chars;
- chars[minLen] = 0;
- _len = minLen;
- return chars;
- }
-
- void ReleaseBuf_SetLen(unsigned newLen) { _len = newLen; }
- void ReleaseBuf_SetEnd(unsigned newLen) { _len = newLen; _chars[newLen] = 0; }
- void ReleaseBuf_CalcLen(unsigned maxLen)
- {
- char *chars = _chars;
- chars[maxLen] = 0;
- _len = MyStringLen(chars);
- }
-
- AString &operator=(char c);
- AString &operator=(const char *s);
- AString &operator=(const AString &s);
- void SetFromWStr_if_Ascii(const wchar_t *s);
- // void SetFromBstr_if_Ascii(BSTR s);
-
- AString &operator+=(char c)
- {
- if (_limit == _len)
- Grow_1();
- unsigned len = _len;
- char *chars = _chars;
- chars[len++] = c;
- chars[len] = 0;
- _len = len;
- return *this;
- }
-
- void Add_Space();
- void Add_Space_if_NotEmpty();
- void Add_OptSpaced(const char *s);
- void Add_LF();
- void Add_PathSepar() { operator+=(CHAR_PATH_SEPARATOR); }
-
- AString &operator+=(const char *s);
- AString &operator+=(const AString &s);
-
- void Add_UInt32(UInt32 v);
-
- void SetFrom(const char *s, unsigned len); // no check
- void SetFrom_CalcLen(const char *s, unsigned len);
-
- AString Mid(unsigned startIndex, unsigned count) const { return AString(count, _chars + startIndex); }
- AString Left(unsigned count) const { return AString(count, *this); }
-
- // void MakeUpper() { MyStringUpper(_chars); }
- // void MakeLower() { MyStringLower(_chars); }
- void MakeLower_Ascii() { MyStringLower_Ascii(_chars); }
-
-
- bool IsEqualTo(const char *s) const { return strcmp(_chars, s) == 0; }
- bool IsEqualTo_Ascii_NoCase(const char *s) const { return StringsAreEqualNoCase_Ascii(_chars, s); }
- // int Compare(const char *s) const { return MyStringCompare(_chars, s); }
- // int Compare(const AString &s) const { return MyStringCompare(_chars, s._chars); }
- // int CompareNoCase(const char *s) const { return MyStringCompareNoCase(_chars, s); }
- // int CompareNoCase(const AString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
- bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
- bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
-
- bool IsAscii() const
- {
- unsigned len = Len();
- const char *s = _chars;
- for (unsigned i = 0; i < len; i++)
- if ((unsigned char)s[i] >= 0x80)
- return false;
- return true;
- }
- int Find(char c) const { return FindCharPosInString(_chars, c); }
- int Find(char c, unsigned startIndex) const
- {
- int pos = FindCharPosInString(_chars + startIndex, c);
- return pos < 0 ? -1 : (int)startIndex + pos;
- }
-
- int ReverseFind(char c) const throw();
- int ReverseFind_Dot() const throw() { return ReverseFind('.'); }
- int ReverseFind_PathSepar() const throw();
-
- int Find(const char *s) const { return Find(s, 0); }
- int Find(const char *s, unsigned startIndex) const throw();
-
- void TrimLeft() throw();
- void TrimRight() throw();
- void Trim()
- {
- TrimRight();
- TrimLeft();
- }
-
- void InsertAtFront(char c);
- // void Insert(unsigned index, char c);
- void Insert(unsigned index, const char *s);
- void Insert(unsigned index, const AString &s);
-
- void RemoveChar(char ch) throw();
-
- void Replace(char oldChar, char newChar) throw();
- void Replace(const AString &oldString, const AString &newString);
-
- void Delete(unsigned index) throw();
- void Delete(unsigned index, unsigned count) throw();
- void DeleteFrontal(unsigned num) throw();
- void DeleteBack() { _chars[--_len] = 0; }
- void DeleteFrom(unsigned index)
- {
- if (index < _len)
- {
- _len = index;
- _chars[index] = 0;
- }
- }
-};
-
-bool operator<(const AString &s1, const AString &s2);
-bool operator>(const AString &s1, const AString &s2);
-
-/*
-bool operator==(const AString &s1, const AString &s2);
-bool operator==(const AString &s1, const char *s2);
-bool operator==(const char *s1, const AString &s2);
-
-bool operator!=(const AString &s1, const AString &s2);
-bool operator!=(const AString &s1, const char *s2);
-bool operator!=(const char *s1, const AString &s2);
-*/
-
-inline bool operator==(const AString &s1, const AString &s2) { return s1.Len() == s2.Len() && strcmp(s1, s2) == 0; }
-inline bool operator==(const AString &s1, const char *s2) { return strcmp(s1, s2) == 0; }
-inline bool operator==(const char *s1, const AString &s2) { return strcmp(s1, s2) == 0; }
-
-inline bool operator!=(const AString &s1, const AString &s2) { return s1.Len() != s2.Len() || strcmp(s1, s2) != 0; }
-inline bool operator!=(const AString &s1, const char *s2) { return strcmp(s1, s2) != 0; }
-inline bool operator!=(const char *s1, const AString &s2) { return strcmp(s1, s2) != 0; }
-
-// ---------- forbidden functions ----------
-
-void operator==(char c1, const AString &s2);
-void operator==(const AString &s1, char c2);
-
-void operator+(char c, const AString &s); // this function can be OK, but we don't use it
-
-void operator+(const AString &s, int c);
-void operator+(const AString &s, unsigned c);
-void operator+(int c, const AString &s);
-void operator+(unsigned c, const AString &s);
-void operator-(const AString &s, int c);
-void operator-(const AString &s, unsigned c);
-
-
-class UString
-{
- wchar_t *_chars;
- unsigned _len;
- unsigned _limit;
-
- void MoveItems(unsigned dest, unsigned src)
- {
- memmove(_chars + dest, _chars + src, (size_t)(_len - src + 1) * sizeof(wchar_t));
- }
-
- void InsertSpace(unsigned index, unsigned size);
-
- void ReAlloc(unsigned newLimit);
- void ReAlloc2(unsigned newLimit);
- void SetStartLen(unsigned len);
- void Grow_1();
- void Grow(unsigned n);
-
- UString(unsigned num, const wchar_t *s); // for Mid
- UString(unsigned num, const UString &s); // for Left
- UString(const UString &s, wchar_t c); // it's for String + char
- UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2);
-
- friend UString operator+(const UString &s, wchar_t c) { return UString(s, c); } ;
- // friend UString operator+(wchar_t c, const UString &s); // is not supported
-
- friend UString operator+(const UString &s1, const UString &s2);
- friend UString operator+(const UString &s1, const wchar_t *s2);
- friend UString operator+(const wchar_t *s1, const UString &s2);
-
- // ---------- forbidden functions ----------
-
- FORBID_STRING_OPS_UString(signed char)
- FORBID_STRING_OPS_UString(unsigned char)
- FORBID_STRING_OPS_UString(short)
-
- #ifdef MY_NATIVE_WCHAR_T_DEFINED
- FORBID_STRING_OPS_UString(unsigned short)
- #endif
-
- FORBID_STRING_OPS_UString(int)
- FORBID_STRING_OPS_UString(unsigned)
- FORBID_STRING_OPS_UString(long)
- FORBID_STRING_OPS_UString(unsigned long)
-
- FORBID_STRING_OPS_2(UString, char)
-
-public:
- UString();
- explicit UString(wchar_t c);
- explicit UString(char c);
- explicit UString(const char *s);
- // UString(const AString &s);
- UString(const wchar_t *s);
- UString(const UString &s);
- ~UString() { MY_STRING_DELETE(_chars); }
-
- unsigned Len() const { return _len; }
- bool IsEmpty() const { return _len == 0; }
- void Empty() { _len = 0; _chars[0] = 0; }
-
- operator const wchar_t *() const { return _chars; }
- const wchar_t *Ptr() const { return _chars; }
- const wchar_t *Ptr(unsigned pos) const { return _chars + pos; }
- const wchar_t *RightPtr(unsigned num) const { return _chars + _len - num; }
- wchar_t Back() const { return _chars[(size_t)_len - 1]; }
-
- void ReplaceOneCharAtPos(unsigned pos, wchar_t c) { _chars[pos] = c; }
-
- wchar_t *GetBuf() { return _chars; }
-
- wchar_t *GetBuf(unsigned minLen)
- {
- if (minLen > _limit)
- ReAlloc2(minLen);
- return _chars;
- }
- wchar_t *GetBuf_SetEnd(unsigned minLen)
- {
- if (minLen > _limit)
- ReAlloc2(minLen);
- wchar_t *chars = _chars;
- chars[minLen] = 0;
- _len = minLen;
- return chars;
- }
-
- void ReleaseBuf_SetLen(unsigned newLen) { _len = newLen; }
- void ReleaseBuf_SetEnd(unsigned newLen) { _len = newLen; _chars[newLen] = 0; }
- void ReleaseBuf_CalcLen(unsigned maxLen)
- {
- wchar_t *chars = _chars;
- chars[maxLen] = 0;
- _len = MyStringLen(chars);
- }
-
- UString &operator=(wchar_t c);
- UString &operator=(char c) { return (*this)=((wchar_t)(unsigned char)c); }
- UString &operator=(const wchar_t *s);
- UString &operator=(const UString &s);
- void SetFrom(const wchar_t *s, unsigned len); // no check
- void SetFromBstr(BSTR s);
- UString &operator=(const char *s);
- UString &operator=(const AString &s) { return operator=(s.Ptr()); }
-
- UString &operator+=(wchar_t c)
- {
- if (_limit == _len)
- Grow_1();
- unsigned len = _len;
- wchar_t *chars = _chars;
- chars[len++] = c;
- chars[len] = 0;
- _len = len;
- return *this;
- }
-
- UString &operator+=(char c) { return (*this)+=((wchar_t)(unsigned char)c); }
-
- void Add_Space();
- void Add_Space_if_NotEmpty();
- void Add_LF();
- void Add_PathSepar() { operator+=(WCHAR_PATH_SEPARATOR); }
-
- UString &operator+=(const wchar_t *s);
- UString &operator+=(const UString &s);
- UString &operator+=(const char *s);
- UString &operator+=(const AString &s) { return operator+=(s.Ptr()); }
-
- void Add_UInt32(UInt32 v);
-
- UString Mid(unsigned startIndex, unsigned count) const { return UString(count, _chars + startIndex); }
- UString Left(unsigned count) const { return UString(count, *this); }
-
- // void MakeUpper() { MyStringUpper(_chars); }
- // void MakeUpper() { MyStringUpper_Ascii(_chars); }
- // void MakeUpper_Ascii() { MyStringUpper_Ascii(_chars); }
- void MakeLower_Ascii() { MyStringLower_Ascii(_chars); }
-
- bool IsEqualTo(const char *s) const { return StringsAreEqual_Ascii(_chars, s); }
- bool IsEqualTo_NoCase(const wchar_t *s) const { return StringsAreEqualNoCase(_chars, s); }
- bool IsEqualTo_Ascii_NoCase(const char *s) const { return StringsAreEqualNoCase_Ascii(_chars, s); }
- int Compare(const wchar_t *s) const { return wcscmp(_chars, s); }
- // int Compare(const UString &s) const { return MyStringCompare(_chars, s._chars); }
- // int CompareNoCase(const wchar_t *s) const { return MyStringCompareNoCase(_chars, s); }
- // int CompareNoCase(const UString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
- bool IsPrefixedBy(const wchar_t *s) const { return IsString1PrefixedByString2(_chars, s); }
- bool IsPrefixedBy_NoCase(const wchar_t *s) const { return IsString1PrefixedByString2_NoCase(_chars, s); }
- bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
-
- bool IsAscii() const
- {
- unsigned len = Len();
- const wchar_t *s = _chars;
- for (unsigned i = 0; i < len; i++)
- if (s[i] >= 0x80)
- return false;
- return true;
- }
- int Find(wchar_t c) const { return FindCharPosInString(_chars, c); }
- int Find(wchar_t c, unsigned startIndex) const
- {
- int pos = FindCharPosInString(_chars + startIndex, c);
- return pos < 0 ? -1 : (int)startIndex + pos;
- }
-
- int ReverseFind(wchar_t c) const throw();
- int ReverseFind_Dot() const throw() { return ReverseFind(L'.'); }
- int ReverseFind_PathSepar() const throw();
-
- int Find(const wchar_t *s) const { return Find(s, 0); }
- int Find(const wchar_t *s, unsigned startIndex) const throw();
-
- void TrimLeft() throw();
- void TrimRight() throw();
- void Trim()
- {
- TrimRight();
- TrimLeft();
- }
-
- void InsertAtFront(wchar_t c);
- // void Insert(unsigned index, wchar_t c);
- void Insert(unsigned index, const wchar_t *s);
- void Insert(unsigned index, const UString &s);
-
- void RemoveChar(wchar_t ch) throw();
-
- void Replace(wchar_t oldChar, wchar_t newChar) throw();
- void Replace(const UString &oldString, const UString &newString);
-
- void Delete(unsigned index) throw();
- void Delete(unsigned index, unsigned count) throw();
- void DeleteFrontal(unsigned num) throw();
- void DeleteBack() { _chars[--_len] = 0; }
- void DeleteFrom(unsigned index)
- {
- if (index < _len)
- {
- _len = index;
- _chars[index] = 0;
- }
- }
-};
-
-bool operator<(const UString &s1, const UString &s2);
-bool operator>(const UString &s1, const UString &s2);
-
-inline bool operator==(const UString &s1, const UString &s2) { return s1.Len() == s2.Len() && wcscmp(s1, s2) == 0; }
-inline bool operator==(const UString &s1, const wchar_t *s2) { return wcscmp(s1, s2) == 0; }
-inline bool operator==(const wchar_t *s1, const UString &s2) { return wcscmp(s1, s2) == 0; }
-
-inline bool operator!=(const UString &s1, const UString &s2) { return s1.Len() != s2.Len() || wcscmp(s1, s2) != 0; }
-inline bool operator!=(const UString &s1, const wchar_t *s2) { return wcscmp(s1, s2) != 0; }
-inline bool operator!=(const wchar_t *s1, const UString &s2) { return wcscmp(s1, s2) != 0; }
-
-
-// ---------- forbidden functions ----------
-
-void operator==(wchar_t c1, const UString &s2);
-void operator==(const UString &s1, wchar_t c2);
-
-void operator+(wchar_t c, const UString &s); // this function can be OK, but we don't use it
-
-void operator+(const AString &s1, const UString &s2);
-void operator+(const UString &s1, const AString &s2);
-
-void operator+(const UString &s1, const char *s2);
-void operator+(const char *s1, const UString &s2);
-
-void operator+(const UString &s, char c);
-void operator+(const UString &s, unsigned char c);
-void operator+(char c, const UString &s);
-void operator+(unsigned char c, const UString &s);
-void operator-(const UString &s1, wchar_t c);
-
-#ifdef _WIN32
-// can we forbid these functions, if wchar_t is 32-bit ?
-void operator+(const UString &s, int c);
-void operator+(const UString &s, unsigned c);
-void operator+(int c, const UString &s);
-void operator+(unsigned c, const UString &s);
-void operator-(const UString &s1, int c);
-void operator-(const UString &s1, unsigned c);
-#endif
-
-
-
-
-
-
-
-class UString2
-{
- wchar_t *_chars;
- unsigned _len;
-
- void ReAlloc2(unsigned newLimit);
- void SetStartLen(unsigned len);
-
- // ---------- forbidden functions ----------
-
- FORBID_STRING_OPS_UString2(char)
- FORBID_STRING_OPS_UString2(signed char)
- FORBID_STRING_OPS_UString2(unsigned char)
- FORBID_STRING_OPS_UString2(short)
-
- UString2 &operator=(wchar_t c);
- UString2(wchar_t c);
-
-public:
- UString2(): _chars(NULL), _len(0) {}
- UString2(const wchar_t *s);
- UString2(const UString2 &s);
- ~UString2() { if (_chars) MY_STRING_DELETE(_chars); }
-
- unsigned Len() const { return _len; }
- bool IsEmpty() const { return _len == 0; }
- // void Empty() { _len = 0; _chars[0] = 0; }
-
- // operator const wchar_t *() const { return _chars; }
- const wchar_t *GetRawPtr() const { return _chars; }
-
- int Compare(const wchar_t *s) const { return wcscmp(_chars, s); }
-
- wchar_t *GetBuf(unsigned minLen)
- {
- if (!_chars || minLen > _len)
- ReAlloc2(minLen);
- return _chars;
- }
- void ReleaseBuf_SetLen(unsigned newLen) { _len = newLen; }
-
- UString2 &operator=(const wchar_t *s);
- UString2 &operator=(const UString2 &s);
- void SetFromAscii(const char *s);
-};
-
-bool operator==(const UString2 &s1, const UString2 &s2);
-bool operator==(const UString2 &s1, const wchar_t *s2);
-bool operator==(const wchar_t *s1, const UString2 &s2);
-
-inline bool operator!=(const UString2 &s1, const UString2 &s2) { return !(s1 == s2); }
-inline bool operator!=(const UString2 &s1, const wchar_t *s2) { return !(s1 == s2); }
-inline bool operator!=(const wchar_t *s1, const UString2 &s2) { return !(s1 == s2); }
-
-
-// ---------- forbidden functions ----------
-
-void operator==(wchar_t c1, const UString2 &s2);
-void operator==(const UString2 &s1, wchar_t c2);
-bool operator<(const UString2 &s1, const UString2 &s2);
-bool operator>(const UString2 &s1, const UString2 &s2);
-
-void operator+(const UString2 &s1, const UString2 &s2);
-void operator+(const UString2 &s1, const wchar_t *s2);
-void operator+(const wchar_t *s1, const UString2 &s2);
-void operator+(wchar_t c, const UString2 &s);
-void operator+(const UString2 &s, wchar_t c);
-void operator+(const UString2 &s, char c);
-void operator+(const UString2 &s, unsigned char c);
-void operator+(char c, const UString2 &s);
-void operator+(unsigned char c, const UString2 &s);
-void operator-(const UString2 &s1, wchar_t c);
-
-
-
-
-
-
-typedef CObjectVector<AString> AStringVector;
-typedef CObjectVector<UString> UStringVector;
-
-#ifdef _UNICODE
- typedef UString CSysString;
-#else
- typedef AString CSysString;
-#endif
-
-typedef CObjectVector<CSysString> CSysStringVector;
-
-
-// ---------- FString ----------
-
-#ifdef _WIN32
- #define USE_UNICODE_FSTRING
-#endif
-
-#ifdef USE_UNICODE_FSTRING
-
- #define __FTEXT(quote) L##quote
-
- typedef wchar_t FChar;
- typedef UString FString;
-
- #define fs2us(_x_) (_x_)
- #define us2fs(_x_) (_x_)
- FString fas2fs(const char *s);
- FString fas2fs(const AString &s);
- AString fs2fas(const FChar *s);
-
-#else
-
- #define __FTEXT(quote) quote
-
- typedef char FChar;
- typedef AString FString;
-
- UString fs2us(const FChar *s);
- UString fs2us(const FString &s);
- FString us2fs(const wchar_t *s);
- #define fas2fs(_x_) (_x_)
- #define fs2fas(_x_) (_x_)
-
-#endif
-
-#define FTEXT(quote) __FTEXT(quote)
-
-#define FCHAR_PATH_SEPARATOR FTEXT(CHAR_PATH_SEPARATOR)
-#define FSTRING_PATH_SEPARATOR FTEXT(STRING_PATH_SEPARATOR)
-
-// #define FCHAR_ANY_MASK FTEXT('*')
-// #define FSTRING_ANY_MASK FTEXT("*")
-
-typedef const FChar *CFSTR;
-
-typedef CObjectVector<FString> FStringVector;
-
-#endif
+// Common/MyString.h
+
+#ifndef ZIP7_INC_COMMON_MY_STRING_H
+#define ZIP7_INC_COMMON_MY_STRING_H
+
+#include <string.h>
+
+#ifndef _WIN32
+#include <wctype.h>
+#include <wchar.h>
+#endif
+
+#include "Common.h"
+#include "MyWindows.h"
+#include "MyTypes.h"
+#include "MyVector.h"
+
+
+/* if (DEBUG_FSTRING_INHERITS_ASTRING is defined), then
+ FString inherits from AString, so we can find bugs related to FString at compile time.
+ DON'T define DEBUG_FSTRING_INHERITS_ASTRING in release code */
+
+// #define DEBUG_FSTRING_INHERITS_ASTRING
+
+#ifdef DEBUG_FSTRING_INHERITS_ASTRING
+class FString;
+#endif
+
+
+#ifdef _MSC_VER
+ #ifdef _NATIVE_WCHAR_T_DEFINED
+ #define MY_NATIVE_WCHAR_T_DEFINED
+ #endif
+#else
+ #define MY_NATIVE_WCHAR_T_DEFINED
+#endif
+
+/*
+ native support for wchar_t:
+ _MSC_VER == 1600 : /Zc:wchar_t is not supported
+ _MSC_VER == 1310 (VS2003)
+ ? _MSC_VER == 1400 (VS2005) : wchar_t <- unsigned short
+ /Zc:wchar_t : wchar_t <- __wchar_t, _WCHAR_T_DEFINED and _NATIVE_WCHAR_T_DEFINED
+ _MSC_VER > 1400 (VS2008+)
+ /Zc:wchar_t[-]
+ /Zc:wchar_t is on by default
+*/
+
+#ifdef _WIN32
+#define IS_PATH_SEPAR(c) ((c) == '\\' || (c) == '/')
+#else
+#define IS_PATH_SEPAR(c) ((c) == CHAR_PATH_SEPARATOR)
+#endif
+
+inline bool IsPathSepar(char c) { return IS_PATH_SEPAR(c); }
+inline bool IsPathSepar(wchar_t c) { return IS_PATH_SEPAR(c); }
+
+inline unsigned MyStringLen(const char *s)
+{
+ unsigned i;
+ for (i = 0; s[i] != 0; i++);
+ return i;
+}
+
+inline void MyStringCopy(char *dest, const char *src)
+{
+ while ((*dest++ = *src++) != 0);
+}
+
+inline char *MyStpCpy(char *dest, const char *src)
+{
+ for (;;)
+ {
+ const char c = *src;
+ *dest = c;
+ if (c == 0)
+ return dest;
+ src++;
+ dest++;
+ }
+}
+
+inline void MyStringCat(char *dest, const char *src)
+{
+ for (; *dest != 0; dest++);
+ while ((*dest++ = *src++) != 0);
+ // MyStringCopy(dest + MyStringLen(dest), src);
+}
+
+inline unsigned MyStringLen(const wchar_t *s)
+{
+ unsigned i;
+ for (i = 0; s[i] != 0; i++);
+ return i;
+}
+
+inline void MyStringCopy(wchar_t *dest, const wchar_t *src)
+{
+ while ((*dest++ = *src++) != 0);
+}
+
+inline void MyStringCat(wchar_t *dest, const wchar_t *src)
+{
+ for (; *dest != 0; dest++);
+ while ((*dest++ = *src++) != 0);
+ // MyStringCopy(dest + MyStringLen(dest), src);
+}
+
+
+/*
+inline wchar_t *MyWcpCpy(wchar_t *dest, const wchar_t *src)
+{
+ for (;;)
+ {
+ const wchar_t c = *src;
+ *dest = c;
+ if (c == 0)
+ return dest;
+ src++;
+ dest++;
+ }
+}
+*/
+
+int FindCharPosInString(const char *s, char c) throw();
+int FindCharPosInString(const wchar_t *s, wchar_t c) throw();
+
+#ifdef _WIN32
+ #ifndef _UNICODE
+ #define STRING_UNICODE_THROW
+ #endif
+#endif
+
+#ifndef STRING_UNICODE_THROW
+ #define STRING_UNICODE_THROW throw()
+#endif
+
+
+inline char MyCharUpper_Ascii(char c)
+{
+ if (c >= 'a' && c <= 'z')
+ return (char)((unsigned char)c - 0x20);
+ return c;
+}
+
+/*
+inline wchar_t MyCharUpper_Ascii(wchar_t c)
+{
+ if (c >= 'a' && c <= 'z')
+ return (wchar_t)(c - 0x20);
+ return c;
+}
+*/
+
+inline char MyCharLower_Ascii(char c)
+{
+ if (c >= 'A' && c <= 'Z')
+ return (char)((unsigned char)c + 0x20);
+ return c;
+}
+
+inline wchar_t MyCharLower_Ascii(wchar_t c)
+{
+ if (c >= 'A' && c <= 'Z')
+ return (wchar_t)(c + 0x20);
+ return c;
+}
+
+wchar_t MyCharUpper_WIN(wchar_t c) throw();
+
+inline wchar_t MyCharUpper(wchar_t c) throw()
+{
+ if (c < 'a') return c;
+ if (c <= 'z') return (wchar_t)(c - 0x20);
+ if (c <= 0x7F) return c;
+ #ifdef _WIN32
+ #ifdef _UNICODE
+ return (wchar_t)(unsigned)(UINT_PTR)CharUpperW((LPWSTR)(UINT_PTR)(unsigned)c);
+ #else
+ return (wchar_t)MyCharUpper_WIN(c);
+ #endif
+ #else
+ return (wchar_t)towupper((wint_t)c);
+ #endif
+}
+
+/*
+wchar_t MyCharLower_WIN(wchar_t c) throw();
+
+inline wchar_t MyCharLower(wchar_t c) throw()
+{
+ if (c < 'A') return c;
+ if (c <= 'Z') return (wchar_t)(c + 0x20);
+ if (c <= 0x7F) return c;
+ #ifdef _WIN32
+ #ifdef _UNICODE
+ return (wchar_t)(unsigned)(UINT_PTR)CharLowerW((LPWSTR)(UINT_PTR)(unsigned)c);
+ #else
+ return (wchar_t)MyCharLower_WIN(c);
+ #endif
+ #else
+ return (wchar_t)tolower(c);
+ #endif
+}
+*/
+
+// char *MyStringUpper(char *s) throw();
+// char *MyStringLower(char *s) throw();
+
+// void MyStringUpper_Ascii(char *s) throw();
+// void MyStringUpper_Ascii(wchar_t *s) throw();
+void MyStringLower_Ascii(char *s) throw();
+void MyStringLower_Ascii(wchar_t *s) throw();
+// wchar_t *MyStringUpper(wchar_t *s) STRING_UNICODE_THROW;
+// wchar_t *MyStringLower(wchar_t *s) STRING_UNICODE_THROW;
+
+bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw();
+
+bool IsString1PrefixedByString2(const char *s1, const char *s2) throw();
+bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw();
+bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw();
+bool IsString1PrefixedByString2_NoCase_Ascii(const char *s1, const char *s2) throw();
+bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *u, const char *a) throw();
+bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw();
+
+#define MyStringCompare(s1, s2) wcscmp(s1, s2)
+int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw();
+// int MyStringCompareNoCase_N(const wchar_t *s1, const wchar_t *s2, unsigned num) throw();
+
+// ---------- ASCII ----------
+// char values in ASCII strings must be less then 128
+bool StringsAreEqual_Ascii(const char *u, const char *a) throw();
+bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw();
+bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw();
+bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw();
+bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw();
+
+#define MY_STRING_DELETE(_p_) { delete [](_p_); }
+// #define MY_STRING_DELETE(_p_) my_delete(_p_);
+
+
+#define FORBID_STRING_OPS_2(cls, t) \
+ void Find(t) const; \
+ void Find(t, unsigned startIndex) const; \
+ void ReverseFind(t) const; \
+ void InsertAtFront(t); \
+ void RemoveChar(t); \
+ void Replace(t, t); \
+
+#define FORBID_STRING_OPS(cls, t) \
+ explicit cls(t); \
+ explicit cls(const t *); \
+ cls &operator=(t); \
+ cls &operator=(const t *); \
+ cls &operator+=(t); \
+ cls &operator+=(const t *); \
+ FORBID_STRING_OPS_2(cls, t) \
+
+/*
+ cls &operator+(t); \
+ cls &operator+(const t *); \
+*/
+
+#define FORBID_STRING_OPS_AString(t) FORBID_STRING_OPS(AString, t)
+#define FORBID_STRING_OPS_UString(t) FORBID_STRING_OPS(UString, t)
+#define FORBID_STRING_OPS_UString2(t) FORBID_STRING_OPS(UString2, t)
+
+class AString
+{
+ char *_chars;
+ unsigned _len;
+ unsigned _limit;
+
+ void MoveItems(unsigned dest, unsigned src)
+ {
+ memmove(_chars + dest, _chars + src, (size_t)(_len - src + 1) * sizeof(char));
+ }
+
+ void InsertSpace(unsigned &index, unsigned size);
+
+ void ReAlloc(unsigned newLimit);
+ void ReAlloc2(unsigned newLimit);
+ void SetStartLen(unsigned len);
+ void Grow_1();
+ void Grow(unsigned n);
+
+ AString(unsigned num, const char *s);
+ AString(unsigned num, const AString &s);
+ AString(const AString &s, char c); // it's for String + char
+ AString(const char *s1, unsigned num1, const char *s2, unsigned num2);
+
+ friend AString operator+(const AString &s, char c) { return AString(s, c); }
+ // friend AString operator+(char c, const AString &s); // is not supported
+
+ friend AString operator+(const AString &s1, const AString &s2);
+ friend AString operator+(const AString &s1, const char *s2);
+ friend AString operator+(const char *s1, const AString &s2);
+
+ // ---------- forbidden functions ----------
+
+ #ifdef MY_NATIVE_WCHAR_T_DEFINED
+ FORBID_STRING_OPS_AString(wchar_t)
+ #endif
+
+ FORBID_STRING_OPS_AString(signed char)
+ FORBID_STRING_OPS_AString(unsigned char)
+ FORBID_STRING_OPS_AString(short)
+ FORBID_STRING_OPS_AString(unsigned short)
+ FORBID_STRING_OPS_AString(int)
+ FORBID_STRING_OPS_AString(unsigned)
+ FORBID_STRING_OPS_AString(long)
+ FORBID_STRING_OPS_AString(unsigned long)
+
+ #ifdef DEBUG_FSTRING_INHERITS_ASTRING
+ AString(const FString &s);
+ AString &operator=(const FString &s);
+ AString &operator+=(const FString &s);
+ #endif
+
+public:
+ explicit AString();
+ explicit AString(char c);
+ explicit AString(const char *s);
+ AString(const AString &s);
+ ~AString() { MY_STRING_DELETE(_chars) }
+
+ unsigned Len() const { return _len; }
+ bool IsEmpty() const { return _len == 0; }
+ void Empty() { _len = 0; _chars[0] = 0; }
+
+ operator const char *() const { return _chars; }
+ char *Ptr_non_const() const { return _chars; }
+ const char *Ptr() const { return _chars; }
+ const char *Ptr(unsigned pos) const { return _chars + pos; }
+ const char *Ptr(int pos) const { return _chars + (unsigned)pos; }
+ const char *RightPtr(unsigned num) const { return _chars + _len - num; }
+ char Back() const { return _chars[(size_t)_len - 1]; }
+
+ void ReplaceOneCharAtPos(unsigned pos, char c) { _chars[pos] = c; }
+
+ char *GetBuf() { return _chars; }
+ /* GetBuf(minLen): provides the buffer that can store
+ at least (minLen) characters and additional null terminator.
+ 9.35: GetBuf doesn't preserve old characters and terminator */
+ char *GetBuf(unsigned minLen)
+ {
+ if (minLen > _limit)
+ ReAlloc2(minLen);
+ return _chars;
+ }
+ char *GetBuf_SetEnd(unsigned minLen)
+ {
+ if (minLen > _limit)
+ ReAlloc2(minLen);
+ char *chars = _chars;
+ chars[minLen] = 0;
+ _len = minLen;
+ return chars;
+ }
+
+ void ReleaseBuf_SetLen(unsigned newLen) { _len = newLen; }
+ void ReleaseBuf_SetEnd(unsigned newLen) { _len = newLen; _chars[newLen] = 0; }
+ void ReleaseBuf_CalcLen(unsigned maxLen)
+ {
+ char *chars = _chars;
+ chars[maxLen] = 0;
+ _len = MyStringLen(chars);
+ }
+
+ AString &operator=(char c);
+ AString &operator=(const char *s);
+ AString &operator=(const AString &s);
+ void SetFromWStr_if_Ascii(const wchar_t *s);
+ // void SetFromBstr_if_Ascii(BSTR s);
+
+ AString &operator+=(char c)
+ {
+ if (_limit == _len)
+ Grow_1();
+ unsigned len = _len;
+ char *chars = _chars;
+ chars[len++] = c;
+ chars[len] = 0;
+ _len = len;
+ return *this;
+ }
+
+ void Add_Space();
+ void Add_Space_if_NotEmpty();
+ void Add_OptSpaced(const char *s);
+ void Add_LF();
+ void Add_Slash();
+ void Add_Dot();
+ void Add_Minus();
+ void Add_PathSepar() { operator+=(CHAR_PATH_SEPARATOR); }
+
+ AString &operator+=(const char *s);
+ AString &operator+=(const AString &s);
+
+ void Add_UInt32(UInt32 v);
+ void Add_UInt64(UInt64 v);
+
+ void AddFrom(const char *s, unsigned len); // no check
+ void SetFrom(const char *s, unsigned len); // no check
+ void SetFrom(const char* s, int len) // no check
+ {
+ SetFrom(s, (unsigned)len); // no check
+ }
+ void SetFrom_CalcLen(const char *s, unsigned len);
+
+ AString Mid(unsigned startIndex, unsigned count) const { return AString(count, _chars + startIndex); }
+ AString Left(unsigned count) const { return AString(count, *this); }
+ // void MakeUpper() { MyStringUpper(_chars); }
+ // void MakeLower() { MyStringLower(_chars); }
+ void MakeLower_Ascii() { MyStringLower_Ascii(_chars); }
+
+
+ bool IsEqualTo(const char *s) const { return strcmp(_chars, s) == 0; }
+ bool IsEqualTo_Ascii_NoCase(const char *s) const { return StringsAreEqualNoCase_Ascii(_chars, s); }
+ // int Compare(const char *s) const { return MyStringCompare(_chars, s); }
+ // int Compare(const AString &s) const { return MyStringCompare(_chars, s._chars); }
+ // int CompareNoCase(const char *s) const { return MyStringCompareNoCase(_chars, s); }
+ // int CompareNoCase(const AString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
+ bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
+ bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
+
+ bool IsAscii() const
+ {
+ unsigned len = Len();
+ const char *s = _chars;
+ for (unsigned i = 0; i < len; i++)
+ if ((unsigned char)s[i] >= 0x80)
+ return false;
+ return true;
+ }
+ int Find(char c) const { return FindCharPosInString(_chars, c); }
+ int Find(char c, unsigned startIndex) const
+ {
+ const int pos = FindCharPosInString(_chars + startIndex, c);
+ return pos < 0 ? -1 : (int)startIndex + pos;
+ }
+ int Find(char c, int startIndex) const
+ {
+ return Find(c, (unsigned)startIndex);
+ }
+
+ int ReverseFind(char c) const throw();
+ int ReverseFind_Dot() const throw() { return ReverseFind('.'); }
+ int ReverseFind_PathSepar() const throw();
+
+ int Find(const char *s) const { return Find(s, 0); }
+ int Find(const char *s, unsigned startIndex) const throw();
+
+ void TrimLeft() throw();
+ void TrimRight() throw();
+ void Trim()
+ {
+ TrimRight();
+ TrimLeft();
+ }
+
+ void InsertAtFront(char c);
+ // void Insert(unsigned index, char c);
+ void Insert(unsigned index, const char *s);
+ void Insert(unsigned index, const AString &s);
+
+ void RemoveChar(char ch) throw();
+
+ void Replace(char oldChar, char newChar) throw();
+ void Replace(const AString &oldString, const AString &newString);
+
+ void Delete(unsigned index) throw();
+ void Delete(unsigned index, unsigned count) throw();
+ void DeleteFrontal(unsigned num) throw();
+ void DeleteBack() { _chars[--_len] = 0; }
+ void DeleteFrom(unsigned index)
+ {
+ if (index < _len)
+ {
+ _len = index;
+ _chars[index] = 0;
+ }
+ }
+ void DeleteFrom(int index)
+ {
+ DeleteFrom((unsigned)index);
+ }
+
+
+ void Wipe_and_Empty()
+ {
+ if (_chars)
+ {
+ memset(_chars, 0, (_limit + 1) * sizeof(*_chars));
+ _len = 0;
+ }
+ }
+};
+
+
+class AString_Wipe: public AString
+{
+ Z7_CLASS_NO_COPY(AString_Wipe)
+public:
+ AString_Wipe(): AString() {}
+ // AString_Wipe(const AString &s): AString(s) {}
+ // AString_Wipe &operator=(const AString &s) { AString::operator=(s); return *this; }
+ // AString_Wipe &operator=(const char *s) { AString::operator=(s); return *this; }
+ ~AString_Wipe() { Wipe_and_Empty(); }
+};
+
+
+bool operator<(const AString &s1, const AString &s2);
+bool operator>(const AString &s1, const AString &s2);
+
+/*
+bool operator==(const AString &s1, const AString &s2);
+bool operator==(const AString &s1, const char *s2);
+bool operator==(const char *s1, const AString &s2);
+
+bool operator!=(const AString &s1, const AString &s2);
+bool operator!=(const AString &s1, const char *s2);
+bool operator!=(const char *s1, const AString &s2);
+*/
+
+inline bool operator==(const AString &s1, const AString &s2) { return s1.Len() == s2.Len() && strcmp(s1, s2) == 0; }
+inline bool operator==(const AString &s1, const char *s2) { return strcmp(s1, s2) == 0; }
+inline bool operator==(const char *s1, const AString &s2) { return strcmp(s1, s2) == 0; }
+
+inline bool operator!=(const AString &s1, const AString &s2) { return s1.Len() != s2.Len() || strcmp(s1, s2) != 0; }
+inline bool operator!=(const AString &s1, const char *s2) { return strcmp(s1, s2) != 0; }
+inline bool operator!=(const char *s1, const AString &s2) { return strcmp(s1, s2) != 0; }
+
+// ---------- forbidden functions ----------
+
+void operator==(char c1, const AString &s2);
+void operator==(const AString &s1, char c2);
+
+void operator+(char c, const AString &s); // this function can be OK, but we don't use it
+
+void operator+(const AString &s, int c);
+void operator+(const AString &s, unsigned c);
+void operator+(int c, const AString &s);
+void operator+(unsigned c, const AString &s);
+void operator-(const AString &s, int c);
+void operator-(const AString &s, unsigned c);
+
+
+class UString
+{
+ wchar_t *_chars;
+ unsigned _len;
+ unsigned _limit;
+
+ void MoveItems(unsigned dest, unsigned src)
+ {
+ memmove(_chars + dest, _chars + src, (size_t)(_len - src + 1) * sizeof(wchar_t));
+ }
+
+ void InsertSpace(unsigned index, unsigned size);
+
+ void ReAlloc(unsigned newLimit);
+ void ReAlloc2(unsigned newLimit);
+ void SetStartLen(unsigned len);
+ void Grow_1();
+ void Grow(unsigned n);
+
+ UString(unsigned num, const wchar_t *s); // for Mid
+ UString(unsigned num, const UString &s); // for Left
+ UString(const UString &s, wchar_t c); // it's for String + char
+ UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2);
+
+ friend UString operator+(const UString &s, wchar_t c) { return UString(s, c); }
+ // friend UString operator+(wchar_t c, const UString &s); // is not supported
+
+ friend UString operator+(const UString &s1, const UString &s2);
+ friend UString operator+(const UString &s1, const wchar_t *s2);
+ friend UString operator+(const wchar_t *s1, const UString &s2);
+
+ // ---------- forbidden functions ----------
+
+ FORBID_STRING_OPS_UString(signed char)
+ FORBID_STRING_OPS_UString(unsigned char)
+ FORBID_STRING_OPS_UString(short)
+
+ #ifdef MY_NATIVE_WCHAR_T_DEFINED
+ FORBID_STRING_OPS_UString(unsigned short)
+ #endif
+
+ FORBID_STRING_OPS_UString(int)
+ FORBID_STRING_OPS_UString(unsigned)
+ FORBID_STRING_OPS_UString(long)
+ FORBID_STRING_OPS_UString(unsigned long)
+
+ FORBID_STRING_OPS_2(UString, char)
+
+ #ifdef DEBUG_FSTRING_INHERITS_ASTRING
+ UString(const FString &s);
+ UString &operator=(const FString &s);
+ UString &operator+=(const FString &s);
+ #endif
+
+public:
+ UString();
+ explicit UString(wchar_t c);
+ explicit UString(char c);
+ explicit UString(const char *s);
+ explicit UString(const AString &s);
+ UString(const wchar_t *s);
+ UString(const UString &s);
+ ~UString() { MY_STRING_DELETE(_chars) }
+
+ unsigned Len() const { return _len; }
+ bool IsEmpty() const { return _len == 0; }
+ void Empty() { _len = 0; _chars[0] = 0; }
+
+ operator const wchar_t *() const { return _chars; }
+ wchar_t *Ptr_non_const() const { return _chars; }
+ const wchar_t *Ptr() const { return _chars; }
+ const wchar_t *Ptr(int pos) const { return _chars + (unsigned)pos; }
+ const wchar_t *Ptr(unsigned pos) const { return _chars + pos; }
+ const wchar_t *RightPtr(unsigned num) const { return _chars + _len - num; }
+ wchar_t Back() const { return _chars[(size_t)_len - 1]; }
+
+ void ReplaceOneCharAtPos(unsigned pos, wchar_t c) { _chars[pos] = c; }
+
+ wchar_t *GetBuf() { return _chars; }
+
+ /*
+ wchar_t *GetBuf_GetMaxAvail(unsigned &availBufLen)
+ {
+ availBufLen = _limit;
+ return _chars;
+ }
+ */
+
+ wchar_t *GetBuf(unsigned minLen)
+ {
+ if (minLen > _limit)
+ ReAlloc2(minLen);
+ return _chars;
+ }
+ wchar_t *GetBuf_SetEnd(unsigned minLen)
+ {
+ if (minLen > _limit)
+ ReAlloc2(minLen);
+ wchar_t *chars = _chars;
+ chars[minLen] = 0;
+ _len = minLen;
+ return chars;
+ }
+
+ void ReleaseBuf_SetLen(unsigned newLen) { _len = newLen; }
+ void ReleaseBuf_SetEnd(unsigned newLen) { _len = newLen; _chars[newLen] = 0; }
+ void ReleaseBuf_CalcLen(unsigned maxLen)
+ {
+ wchar_t *chars = _chars;
+ chars[maxLen] = 0;
+ _len = MyStringLen(chars);
+ }
+
+ UString &operator=(wchar_t c);
+ UString &operator=(char c) { return (*this)=((wchar_t)(unsigned char)c); }
+ UString &operator=(const wchar_t *s);
+ UString &operator=(const UString &s);
+ void SetFrom(const wchar_t *s, unsigned len); // no check
+ void SetFromBstr(LPCOLESTR s);
+ UString &operator=(const char *s);
+ UString &operator=(const AString &s) { return operator=(s.Ptr()); }
+
+ UString &operator+=(wchar_t c)
+ {
+ if (_limit == _len)
+ Grow_1();
+ unsigned len = _len;
+ wchar_t *chars = _chars;
+ chars[len++] = c;
+ chars[len] = 0;
+ _len = len;
+ return *this;
+ }
+
+ UString &operator+=(char c) { return (*this)+=((wchar_t)(unsigned char)c); }
+
+ void Add_Space();
+ void Add_Space_if_NotEmpty();
+ void Add_LF();
+ void Add_Dot();
+ void Add_PathSepar() { operator+=(WCHAR_PATH_SEPARATOR); }
+
+ UString &operator+=(const wchar_t *s);
+ UString &operator+=(const UString &s);
+ UString &operator+=(const char *s);
+ UString &operator+=(const AString &s) { return operator+=(s.Ptr()); }
+
+ void Add_UInt32(UInt32 v);
+ void Add_UInt64(UInt64 v);
+
+ UString Mid(unsigned startIndex, unsigned count) const { return UString(count, _chars + startIndex); }
+ UString Left(unsigned count) const { return UString(count, *this); }
+ UString Left(int count) const { return Left((unsigned)count); }
+
+ // void MakeUpper() { MyStringUpper(_chars); }
+ // void MakeUpper() { MyStringUpper_Ascii(_chars); }
+ // void MakeUpper_Ascii() { MyStringUpper_Ascii(_chars); }
+ void MakeLower_Ascii() { MyStringLower_Ascii(_chars); }
+
+ bool IsEqualTo(const char *s) const { return StringsAreEqual_Ascii(_chars, s); }
+ bool IsEqualTo_NoCase(const wchar_t *s) const { return StringsAreEqualNoCase(_chars, s); }
+ bool IsEqualTo_Ascii_NoCase(const char *s) const { return StringsAreEqualNoCase_Ascii(_chars, s); }
+ int Compare(const wchar_t *s) const { return wcscmp(_chars, s); }
+ // int Compare(const UString &s) const { return MyStringCompare(_chars, s._chars); }
+ // int CompareNoCase(const wchar_t *s) const { return MyStringCompareNoCase(_chars, s); }
+ // int CompareNoCase(const UString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
+ bool IsPrefixedBy(const wchar_t *s) const { return IsString1PrefixedByString2(_chars, s); }
+ bool IsPrefixedBy_NoCase(const wchar_t *s) const { return IsString1PrefixedByString2_NoCase(_chars, s); }
+ bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
+
+ bool IsAscii() const
+ {
+ unsigned len = Len();
+ const wchar_t *s = _chars;
+ for (unsigned i = 0; i < len; i++)
+ if (s[i] >= 0x80)
+ return false;
+ return true;
+ }
+ int Find(wchar_t c) const { return FindCharPosInString(_chars, c); }
+ int Find(wchar_t c, unsigned startIndex) const
+ {
+ int pos = FindCharPosInString(_chars + startIndex, c);
+ return pos < 0 ? -1 : (int)startIndex + pos;
+ }
+
+ int ReverseFind(wchar_t c) const throw();
+ int ReverseFind_Dot() const throw() { return ReverseFind(L'.'); }
+ int ReverseFind_PathSepar() const throw();
+
+ int Find(const wchar_t *s) const { return Find(s, 0); }
+ int Find(const wchar_t *s, unsigned startIndex) const throw();
+
+ void TrimLeft() throw();
+ void TrimRight() throw();
+ void Trim()
+ {
+ TrimRight();
+ TrimLeft();
+ }
+
+ void InsertAtFront(wchar_t c);
+ // void Insert_wchar_t(unsigned index, wchar_t c);
+ void Insert(unsigned index, const wchar_t *s);
+ void Insert(unsigned index, const UString &s);
+
+ void RemoveChar(wchar_t ch) throw();
+
+ void Replace(wchar_t oldChar, wchar_t newChar) throw();
+ void Replace(const UString &oldString, const UString &newString);
+
+ void Delete(int index) throw() { Delete((unsigned)index); }
+ void Delete(unsigned index) throw();
+ void Delete(unsigned index, unsigned count) throw();
+ void DeleteFrontal(unsigned num) throw();
+ void DeleteBack() { _chars[--_len] = 0; }
+ void DeleteFrom(int index) { DeleteFrom((unsigned)index); }
+ void DeleteFrom(unsigned index)
+ {
+ if (index < _len)
+ {
+ _len = index;
+ _chars[index] = 0;
+ }
+ }
+
+ void Wipe_and_Empty()
+ {
+ if (_chars)
+ {
+ memset(_chars, 0, (_limit + 1) * sizeof(*_chars));
+ _len = 0;
+ }
+ }
+};
+
+
+class UString_Wipe: public UString
+{
+ Z7_CLASS_NO_COPY(UString_Wipe)
+public:
+ UString_Wipe(): UString() {}
+ // UString_Wipe(const UString &s): UString(s) {}
+ // UString_Wipe &operator=(const UString &s) { UString::operator=(s); return *this; }
+ // UString_Wipe &operator=(const wchar_t *s) { UString::operator=(s); return *this; }
+ ~UString_Wipe() { Wipe_and_Empty(); }
+};
+
+
+bool operator<(const UString &s1, const UString &s2);
+bool operator>(const UString &s1, const UString &s2);
+
+inline bool operator==(const UString &s1, const UString &s2) { return s1.Len() == s2.Len() && wcscmp(s1, s2) == 0; }
+inline bool operator==(const UString &s1, const wchar_t *s2) { return wcscmp(s1, s2) == 0; }
+inline bool operator==(const wchar_t *s1, const UString &s2) { return wcscmp(s1, s2) == 0; }
+
+inline bool operator!=(const UString &s1, const UString &s2) { return s1.Len() != s2.Len() || wcscmp(s1, s2) != 0; }
+inline bool operator!=(const UString &s1, const wchar_t *s2) { return wcscmp(s1, s2) != 0; }
+inline bool operator!=(const wchar_t *s1, const UString &s2) { return wcscmp(s1, s2) != 0; }
+
+
+// ---------- forbidden functions ----------
+
+void operator==(wchar_t c1, const UString &s2);
+void operator==(const UString &s1, wchar_t c2);
+
+void operator+(wchar_t c, const UString &s); // this function can be OK, but we don't use it
+
+void operator+(const AString &s1, const UString &s2);
+void operator+(const UString &s1, const AString &s2);
+
+void operator+(const UString &s1, const char *s2);
+void operator+(const char *s1, const UString &s2);
+
+void operator+(const UString &s, char c);
+void operator+(const UString &s, unsigned char c);
+void operator+(char c, const UString &s);
+void operator+(unsigned char c, const UString &s);
+void operator-(const UString &s1, wchar_t c);
+
+#ifdef _WIN32
+// can we forbid these functions, if wchar_t is 32-bit ?
+void operator+(const UString &s, int c);
+void operator+(const UString &s, unsigned c);
+void operator+(int c, const UString &s);
+void operator+(unsigned c, const UString &s);
+void operator-(const UString &s1, int c);
+void operator-(const UString &s1, unsigned c);
+#endif
+
+
+
+
+
+
+
+class UString2
+{
+ wchar_t *_chars;
+ unsigned _len;
+
+ void ReAlloc2(unsigned newLimit);
+ void SetStartLen(unsigned len);
+
+ // ---------- forbidden functions ----------
+
+ FORBID_STRING_OPS_UString2(char)
+ FORBID_STRING_OPS_UString2(signed char)
+ FORBID_STRING_OPS_UString2(unsigned char)
+ FORBID_STRING_OPS_UString2(short)
+
+ UString2 &operator=(wchar_t c);
+
+ UString2(const AString &s);
+ UString2 &operator=(const AString &s);
+ UString2 &operator+=(const AString &s);
+
+ #ifdef DEBUG_FSTRING_INHERITS_ASTRING
+ UString2(const FString &s);
+ UString2 &operator=(const FString &s);
+ UString2 &operator+=(const FString &s);
+ #endif
+
+public:
+ UString2(): _chars(NULL), _len(0) {}
+ UString2(const wchar_t *s);
+ UString2(const UString2 &s);
+ ~UString2() { if (_chars) { MY_STRING_DELETE(_chars) } }
+
+ unsigned Len() const { return _len; }
+ bool IsEmpty() const { return _len == 0; }
+ // void Empty() { _len = 0; _chars[0] = 0; }
+
+ // operator const wchar_t *() const { return _chars; }
+ const wchar_t *GetRawPtr() const { return _chars; }
+
+ int Compare(const wchar_t *s) const { return wcscmp(_chars, s); }
+
+ wchar_t *GetBuf(unsigned minLen)
+ {
+ if (!_chars || minLen > _len)
+ ReAlloc2(minLen);
+ return _chars;
+ }
+ void ReleaseBuf_SetLen(unsigned newLen) { _len = newLen; }
+
+ UString2 &operator=(const wchar_t *s);
+ UString2 &operator=(const UString2 &s);
+ void SetFromAscii(const char *s);
+};
+
+bool operator==(const UString2 &s1, const UString2 &s2);
+bool operator==(const UString2 &s1, const wchar_t *s2);
+bool operator==(const wchar_t *s1, const UString2 &s2);
+
+inline bool operator!=(const UString2 &s1, const UString2 &s2) { return !(s1 == s2); }
+inline bool operator!=(const UString2 &s1, const wchar_t *s2) { return !(s1 == s2); }
+inline bool operator!=(const wchar_t *s1, const UString2 &s2) { return !(s1 == s2); }
+
+
+// ---------- forbidden functions ----------
+
+void operator==(wchar_t c1, const UString2 &s2);
+void operator==(const UString2 &s1, wchar_t c2);
+bool operator<(const UString2 &s1, const UString2 &s2);
+bool operator>(const UString2 &s1, const UString2 &s2);
+
+void operator+(const UString2 &s1, const UString2 &s2);
+void operator+(const UString2 &s1, const wchar_t *s2);
+void operator+(const wchar_t *s1, const UString2 &s2);
+void operator+(wchar_t c, const UString2 &s);
+void operator+(const UString2 &s, wchar_t c);
+void operator+(const UString2 &s, char c);
+void operator+(const UString2 &s, unsigned char c);
+void operator+(char c, const UString2 &s);
+void operator+(unsigned char c, const UString2 &s);
+void operator-(const UString2 &s1, wchar_t c);
+
+
+
+
+
+
+typedef CObjectVector<AString> AStringVector;
+typedef CObjectVector<UString> UStringVector;
+
+#ifdef _UNICODE
+ typedef UString CSysString;
+#else
+ typedef AString CSysString;
+#endif
+
+typedef CObjectVector<CSysString> CSysStringVector;
+
+
+// ---------- FString ----------
+
+#ifndef DEBUG_FSTRING_INHERITS_ASTRING
+#ifdef _WIN32
+ #define USE_UNICODE_FSTRING
+#endif
+#endif
+
+#ifdef USE_UNICODE_FSTRING
+
+ #define MY_FTEXT(quote) L##quote
+
+ typedef wchar_t FChar;
+ typedef UString FString;
+
+ #define fs2us(_x_) (_x_)
+ #define us2fs(_x_) (_x_)
+ FString fas2fs(const char *s);
+ FString fas2fs(const AString &s);
+ AString fs2fas(const FChar *s);
+
+#else // USE_UNICODE_FSTRING
+
+ #define MY_FTEXT(quote) quote
+
+ typedef char FChar;
+
+ #ifdef DEBUG_FSTRING_INHERITS_ASTRING
+
+ class FString: public AString
+ {
+ // FString &operator=(const char *s);
+ FString &operator=(const AString &s);
+ // FString &operator+=(const AString &s);
+ public:
+ FString(const AString &s): AString(s.Ptr()) {}
+ FString(const FString &s): AString(s.Ptr()) {}
+ FString(const char *s): AString(s) {}
+ FString() {}
+ FString &operator=(const FString &s) { AString::operator=((const AString &)s); return *this; }
+ FString &operator=(char c) { AString::operator=(c); return *this; }
+ FString &operator+=(char c) { AString::operator+=(c); return *this; }
+ FString &operator+=(const FString &s) { AString::operator+=((const AString &)s); return *this; }
+ FString Left(unsigned count) const { return FString(AString::Left(count)); }
+ };
+ void operator+(const AString &s1, const FString &s2);
+ void operator+(const FString &s1, const AString &s2);
+
+ inline FString operator+(const FString &s1, const FString &s2)
+ {
+ AString s =(const AString &)s1 + (const AString &)s2;
+ return FString(s.Ptr());
+ // return FString((const AString &)s1 + (const AString &)s2);
+ }
+ inline FString operator+(const FString &s1, const FChar *s2)
+ {
+ return s1 + (FString)s2;
+ }
+ /*
+ inline FString operator+(const FChar *s1, const FString &s2)
+ {
+ return (FString)s1 + s2;
+ }
+ */
+
+ inline FString fas2fs(const char *s) { return FString(s); }
+
+ #else // DEBUG_FSTRING_INHERITS_ASTRING
+ typedef AString FString;
+ #define fas2fs(_x_) (_x_)
+ #endif // DEBUG_FSTRING_INHERITS_ASTRING
+
+ UString fs2us(const FChar *s);
+ UString fs2us(const FString &s);
+ FString us2fs(const wchar_t *s);
+ #define fs2fas(_x_) (_x_)
+
+#endif // USE_UNICODE_FSTRING
+
+#define FTEXT(quote) MY_FTEXT(quote)
+
+#define FCHAR_PATH_SEPARATOR FTEXT(CHAR_PATH_SEPARATOR)
+#define FSTRING_PATH_SEPARATOR FTEXT(STRING_PATH_SEPARATOR)
+
+// #define FCHAR_ANY_MASK FTEXT('*')
+// #define FSTRING_ANY_MASK FTEXT("*")
+
+typedef const FChar *CFSTR;
+
+typedef CObjectVector<FString> FStringVector;
+
+
+class CStringFinder
+{
+ AString _temp;
+public:
+ // list - is list of low case Ascii strings separated by space " ".
+ // the function returns true, if it can find exact word (str) in (list).
+ bool FindWord_In_LowCaseAsciiList_NoCase(const char *list, const wchar_t *str);
+};
+
+void SplitString(const UString &srcString, UStringVector &destStrings);
+
+#endif
+
+
+
+#if defined(_WIN32)
+ // #include <wchar.h>
+ // WCHAR_MAX is defined as ((wchar_t)-1)
+ #define Z7_WCHART_IS_16BIT 1
+#elif (defined(WCHAR_MAX) && (WCHAR_MAX <= 0xffff)) \
+ || (defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ == 2))
+ #define Z7_WCHART_IS_16BIT 1
+#endif
+
+#if WCHAR_PATH_SEPARATOR == L'\\'
+// WSL scheme
+#define WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT ((wchar_t)((unsigned)(0xF000) + (unsigned)'\\'))
+// #define WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT '_'
+#endif
diff --git a/CPP/Common/MyTypes.h b/CPP/Common/MyTypes.h
index 6e73aca..8f44f67 100644
--- a/CPP/Common/MyTypes.h
+++ b/CPP/Common/MyTypes.h
@@ -1,35 +1,37 @@
-// Common/MyTypes.h
-
-#ifndef __COMMON_MY_TYPES_H
-#define __COMMON_MY_TYPES_H
-
-#include "../../C/7zTypes.h"
-
-typedef int HRes;
-
-struct CBoolPair
-{
- bool Val;
- bool Def;
-
- CBoolPair(): Val(false), Def(false) {}
-
- void Init()
- {
- Val = false;
- Def = false;
- }
-
- void SetTrueTrue()
- {
- Val = true;
- Def = true;
- }
-};
-
-#define CLASS_NO_COPY(cls) \
- private: \
- cls(const cls &); \
- cls &operator=(const cls &);
-
-#endif
+// Common/MyTypes.h
+
+#ifndef ZIP7_INC_COMMON_MY_TYPES_H
+#define ZIP7_INC_COMMON_MY_TYPES_H
+
+#include "../../C/7zTypes.h"
+#include "Common.h"
+
+typedef int HRes;
+
+struct CBoolPair
+{
+ bool Val;
+ bool Def;
+
+ CBoolPair(): Val(false), Def(false) {}
+
+ void Init()
+ {
+ Val = false;
+ Def = false;
+ }
+
+ void SetTrueTrue()
+ {
+ Val = true;
+ Def = true;
+ }
+
+ void SetVal_as_Defined(bool val)
+ {
+ Val = val;
+ Def = true;
+ }
+};
+
+#endif
diff --git a/CPP/Common/MyUnknown.h b/CPP/Common/MyUnknown.h
index b1d476f..75ee96f 100644
--- a/CPP/Common/MyUnknown.h
+++ b/CPP/Common/MyUnknown.h
@@ -1,17 +1,8 @@
-// MyUnknown.h
-
-#ifndef __MY_UNKNOWN_H
-#define __MY_UNKNOWN_H
-
-#include "MyWindows.h"
-
-/*
-#ifdef _WIN32
-#include <basetyps.h>
-#include <unknwn.h>
-#else
-#include "MyWindows.h"
-#endif
-*/
-
-#endif
+// MyUnknown.h
+
+#ifndef ZIP7_INC_MY_UNKNOWN_H
+#define ZIP7_INC_MY_UNKNOWN_H
+
+#include "MyWindows.h"
+
+#endif
diff --git a/CPP/Common/MyVector.cpp b/CPP/Common/MyVector.cpp
index 9a6d1d5..0b1baf4 100644
--- a/CPP/Common/MyVector.cpp
+++ b/CPP/Common/MyVector.cpp
@@ -1,3 +1,3 @@
-// Common/MyVector.cpp
-
-#include "StdAfx.h"
+// Common/MyVector.cpp
+
+#include "StdAfx.h"
diff --git a/CPP/Common/MyVector.h b/CPP/Common/MyVector.h
index 21125fa..9ee7105 100644
--- a/CPP/Common/MyVector.h
+++ b/CPP/Common/MyVector.h
@@ -1,634 +1,710 @@
-// Common/MyVector.h
-
-#ifndef __COMMON_MY_VECTOR_H
-#define __COMMON_MY_VECTOR_H
-
-#include <string.h>
-
-template <class T>
-class CRecordVector
-{
- T *_items;
- unsigned _size;
- unsigned _capacity;
-
- void MoveItems(unsigned destIndex, unsigned srcIndex)
- {
- memmove(_items + destIndex, _items + srcIndex, (size_t)(_size - srcIndex) * sizeof(T));
- }
-
- void ReserveOnePosition()
- {
- if (_size == _capacity)
- {
- unsigned newCapacity = _capacity + (_capacity >> 2) + 1;
- T *p;
- MY_ARRAY_NEW(p, T, newCapacity);
- // p = new T[newCapacity];
- if (_size != 0)
- memcpy(p, _items, (size_t)_size * sizeof(T));
- delete []_items;
- _items = p;
- _capacity = newCapacity;
- }
- }
-
-public:
-
- CRecordVector(): _items(0), _size(0), _capacity(0) {}
-
- CRecordVector(const CRecordVector &v): _items(0), _size(0), _capacity(0)
- {
- unsigned size = v.Size();
- if (size != 0)
- {
- _items = new T[size];
- _size = size;
- _capacity = size;
- memcpy(_items, v._items, (size_t)size * sizeof(T));
- }
- }
-
- unsigned Size() const { return _size; }
- bool IsEmpty() const { return _size == 0; }
-
- void ConstructReserve(unsigned size)
- {
- if (size != 0)
- {
- MY_ARRAY_NEW(_items, T, size)
- // _items = new T[size];
- _capacity = size;
- }
- }
-
- void Reserve(unsigned newCapacity)
- {
- if (newCapacity > _capacity)
- {
- T *p;
- MY_ARRAY_NEW(p, T, newCapacity);
- // p = new T[newCapacity];
- if (_size != 0)
- memcpy(p, _items, (size_t)_size * sizeof(T));
- delete []_items;
- _items = p;
- _capacity = newCapacity;
- }
- }
-
- void ClearAndReserve(unsigned newCapacity)
- {
- Clear();
- if (newCapacity > _capacity)
- {
- delete []_items;
- _items = NULL;
- _capacity = 0;
- MY_ARRAY_NEW(_items, T, newCapacity)
- // _items = new T[newCapacity];
- _capacity = newCapacity;
- }
- }
-
- void ClearAndSetSize(unsigned newSize)
- {
- ClearAndReserve(newSize);
- _size = newSize;
- }
-
- void ChangeSize_KeepData(unsigned newSize)
- {
- if (newSize > _capacity)
- {
- T *p;
- MY_ARRAY_NEW(p, T, newSize)
- // p = new T[newSize];
- if (_size != 0)
- memcpy(p, _items, (size_t)_size * sizeof(T));
- delete []_items;
- _items = p;
- _capacity = newSize;
- }
- _size = newSize;
- }
-
- void ReserveDown()
- {
- if (_size == _capacity)
- return;
- T *p = NULL;
- if (_size != 0)
- {
- p = new T[_size];
- memcpy(p, _items, (size_t)_size * sizeof(T));
- }
- delete []_items;
- _items = p;
- _capacity = _size;
- }
-
- ~CRecordVector() { delete []_items; }
-
- void ClearAndFree()
- {
- delete []_items;
- _items = NULL;
- _size = 0;
- _capacity = 0;
- }
-
- void Clear() { _size = 0; }
-
- void DeleteBack() { _size--; }
-
- void DeleteFrom(unsigned index)
- {
- // if (index <= _size)
- _size = index;
- }
-
- void DeleteFrontal(unsigned num)
- {
- if (num != 0)
- {
- MoveItems(0, num);
- _size -= num;
- }
- }
-
- void Delete(unsigned index)
- {
- MoveItems(index, index + 1);
- _size -= 1;
- }
-
- /*
- void Delete(unsigned index, unsigned num)
- {
- if (num > 0)
- {
- MoveItems(index, index + num);
- _size -= num;
- }
- }
- */
-
- CRecordVector& operator=(const CRecordVector &v)
- {
- if (&v == this)
- return *this;
- unsigned size = v.Size();
- if (size > _capacity)
- {
- delete []_items;
- _capacity = 0;
- _size = 0;
- _items = NULL;
- _items = new T[size];
- _capacity = size;
- }
- _size = size;
- if (size != 0)
- memcpy(_items, v._items, (size_t)size * sizeof(T));
- return *this;
- }
-
- CRecordVector& operator+=(const CRecordVector &v)
- {
- unsigned size = v.Size();
- Reserve(_size + size);
- if (size != 0)
- memcpy(_items + _size, v._items, (size_t)size * sizeof(T));
- _size += size;
- return *this;
- }
-
- unsigned Add(const T item)
- {
- ReserveOnePosition();
- _items[_size] = item;
- return _size++;
- }
-
- void AddInReserved(const T item)
- {
- _items[_size++] = item;
- }
-
- void Insert(unsigned index, const T item)
- {
- ReserveOnePosition();
- MoveItems(index + 1, index);
- _items[index] = item;
- _size++;
- }
-
- void MoveToFront(unsigned index)
- {
- if (index != 0)
- {
- T temp = _items[index];
- memmove(_items + 1, _items, (size_t)index * sizeof(T));
- _items[0] = temp;
- }
- }
-
- const T& operator[](unsigned index) const { return _items[index]; }
- T& operator[](unsigned index) { return _items[index]; }
- const T& Front() const { return _items[0]; }
- T& Front() { return _items[0]; }
- const T& Back() const { return _items[(size_t)_size - 1]; }
- T& Back() { return _items[(size_t)_size - 1]; }
-
- /*
- void Swap(unsigned i, unsigned j)
- {
- T temp = _items[i];
- _items[i] = _items[j];
- _items[j] = temp;
- }
- */
-
- int FindInSorted(const T item, unsigned left, unsigned right) const
- {
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T midVal = (*this)[mid];
- if (item == midVal)
- return mid;
- if (item < midVal)
- right = mid;
- else
- left = mid + 1;
- }
- return -1;
- }
-
- int FindInSorted2(const T &item, unsigned left, unsigned right) const
- {
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T& midVal = (*this)[mid];
- int comp = item.Compare(midVal);
- if (comp == 0)
- return mid;
- if (comp < 0)
- right = mid;
- else
- left = mid + 1;
- }
- return -1;
- }
-
- int FindInSorted(const T item) const
- {
- return FindInSorted(item, 0, _size);
- }
-
- int FindInSorted2(const T &item) const
- {
- return FindInSorted2(item, 0, _size);
- }
-
- unsigned AddToUniqueSorted(const T item)
- {
- unsigned left = 0, right = _size;
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T midVal = (*this)[mid];
- if (item == midVal)
- return mid;
- if (item < midVal)
- right = mid;
- else
- left = mid + 1;
- }
- Insert(right, item);
- return right;
- }
-
- unsigned AddToUniqueSorted2(const T &item)
- {
- unsigned left = 0, right = _size;
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T& midVal = (*this)[mid];
- int comp = item.Compare(midVal);
- if (comp == 0)
- return mid;
- if (comp < 0)
- right = mid;
- else
- left = mid + 1;
- }
- Insert(right, item);
- return right;
- }
-
- static void SortRefDown(T* p, unsigned k, unsigned size, int (*compare)(const T*, const T*, void *), void *param)
- {
- T temp = p[k];
- for (;;)
- {
- unsigned s = (k << 1);
- if (s > size)
- break;
- if (s < size && compare(p + s + 1, p + s, param) > 0)
- s++;
- if (compare(&temp, p + s, param) >= 0)
- break;
- p[k] = p[s];
- k = s;
- }
- p[k] = temp;
- }
-
- void Sort(int (*compare)(const T*, const T*, void *), void *param)
- {
- unsigned size = _size;
- if (size <= 1)
- return;
- T* p = (&Front()) - 1;
- {
- unsigned i = size >> 1;
- do
- SortRefDown(p, i, size, compare, param);
- while (--i != 0);
- }
- do
- {
- T temp = p[size];
- p[size--] = p[1];
- p[1] = temp;
- SortRefDown(p, 1, size, compare, param);
- }
- while (size > 1);
- }
-
- static void SortRefDown2(T* p, unsigned k, unsigned size)
- {
- T temp = p[k];
- for (;;)
- {
- unsigned s = (k << 1);
- if (s > size)
- break;
- if (s < size && p[(size_t)s + 1].Compare(p[s]) > 0)
- s++;
- if (temp.Compare(p[s]) >= 0)
- break;
- p[k] = p[s];
- k = s;
- }
- p[k] = temp;
- }
-
- void Sort2()
- {
- unsigned size = _size;
- if (size <= 1)
- return;
- T* p = (&Front()) - 1;
- {
- unsigned i = size >> 1;
- do
- SortRefDown2(p, i, size);
- while (--i != 0);
- }
- do
- {
- T temp = p[size];
- p[size--] = p[1];
- p[1] = temp;
- SortRefDown2(p, 1, size);
- }
- while (size > 1);
- }
-};
-
-typedef CRecordVector<int> CIntVector;
-typedef CRecordVector<unsigned int> CUIntVector;
-typedef CRecordVector<bool> CBoolVector;
-typedef CRecordVector<unsigned char> CByteVector;
-typedef CRecordVector<void *> CPointerVector;
-
-template <class T>
-class CObjectVector
-{
- CPointerVector _v;
-public:
- unsigned Size() const { return _v.Size(); }
- bool IsEmpty() const { return _v.IsEmpty(); }
- void ReserveDown() { _v.ReserveDown(); }
- // void Reserve(unsigned newCapacity) { _v.Reserve(newCapacity); }
- void ClearAndReserve(unsigned newCapacity) { Clear(); _v.ClearAndReserve(newCapacity); }
-
- CObjectVector() {};
- CObjectVector(const CObjectVector &v)
- {
- unsigned size = v.Size();
- _v.ConstructReserve(size);
- for (unsigned i = 0; i < size; i++)
- _v.AddInReserved(new T(v[i]));
- }
- CObjectVector& operator=(const CObjectVector &v)
- {
- if (&v == this)
- return *this;
- Clear();
- unsigned size = v.Size();
- _v.Reserve(size);
- for (unsigned i = 0; i < size; i++)
- _v.AddInReserved(new T(v[i]));
- return *this;
- }
-
- CObjectVector& operator+=(const CObjectVector &v)
- {
- unsigned size = v.Size();
- _v.Reserve(Size() + size);
- for (unsigned i = 0; i < size; i++)
- _v.AddInReserved(new T(v[i]));
- return *this;
- }
-
- const T& operator[](unsigned index) const { return *((T *)_v[index]); }
- T& operator[](unsigned index) { return *((T *)_v[index]); }
- const T& Front() const { return operator[](0); }
- T& Front() { return operator[](0); }
- const T& Back() const { return *(T *)_v.Back(); }
- T& Back() { return *(T *)_v.Back(); }
-
- void MoveToFront(unsigned index) { _v.MoveToFront(index); }
-
- unsigned Add(const T& item) { return _v.Add(new T(item)); }
-
- void AddInReserved(const T& item) { _v.AddInReserved(new T(item)); }
-
- T& AddNew()
- {
- T *p = new T;
- _v.Add(p);
- return *p;
- }
-
- T& AddNewInReserved()
- {
- T *p = new T;
- _v.AddInReserved(p);
- return *p;
- }
-
- void Insert(unsigned index, const T& item) { _v.Insert(index, new T(item)); }
-
- T& InsertNew(unsigned index)
- {
- T *p = new T;
- _v.Insert(index, p);
- return *p;
- }
-
- ~CObjectVector()
- {
- for (unsigned i = _v.Size(); i != 0;)
- delete (T *)_v[--i];
- }
-
- void ClearAndFree()
- {
- Clear();
- _v.ClearAndFree();
- }
-
- void Clear()
- {
- for (unsigned i = _v.Size(); i != 0;)
- delete (T *)_v[--i];
- _v.Clear();
- }
-
- void DeleteFrom(unsigned index)
- {
- unsigned size = _v.Size();
- for (unsigned i = index; i < size; i++)
- delete (T *)_v[i];
- _v.DeleteFrom(index);
- }
-
- void DeleteFrontal(unsigned num)
- {
- for (unsigned i = 0; i < num; i++)
- delete (T *)_v[i];
- _v.DeleteFrontal(num);
- }
-
- void DeleteBack()
- {
- delete (T *)_v.Back();
- _v.DeleteBack();
- }
-
- void Delete(unsigned index)
- {
- delete (T *)_v[index];
- _v.Delete(index);
- }
-
- /*
- void Delete(unsigned index, unsigned num)
- {
- for (unsigned i = 0; i < num; i++)
- delete (T *)_v[index + i];
- _v.Delete(index, num);
- }
- */
-
- /*
- int Find(const T& item) const
- {
- unsigned size = Size();
- for (unsigned i = 0; i < size; i++)
- if (item == (*this)[i])
- return i;
- return -1;
- }
- */
-
- int FindInSorted(const T& item) const
- {
- unsigned left = 0, right = Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T& midVal = (*this)[mid];
- int comp = item.Compare(midVal);
- if (comp == 0)
- return mid;
- if (comp < 0)
- right = mid;
- else
- left = mid + 1;
- }
- return -1;
- }
-
- unsigned AddToUniqueSorted(const T& item)
- {
- unsigned left = 0, right = Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T& midVal = (*this)[mid];
- int comp = item.Compare(midVal);
- if (comp == 0)
- return mid;
- if (comp < 0)
- right = mid;
- else
- left = mid + 1;
- }
- Insert(right, item);
- return right;
- }
-
- /*
- unsigned AddToSorted(const T& item)
- {
- unsigned left = 0, right = Size();
- while (left != right)
- {
- unsigned mid = (left + right) / 2;
- const T& midVal = (*this)[mid];
- int comp = item.Compare(midVal);
- if (comp == 0)
- {
- right = mid + 1;
- break;
- }
- if (comp < 0)
- right = mid;
- else
- left = mid + 1;
- }
- Insert(right, item);
- return right;
- }
- */
-
- void Sort(int (*compare)(void *const *, void *const *, void *), void *param)
- { _v.Sort(compare, param); }
-
- static int CompareObjectItems(void *const *a1, void *const *a2, void * /* param */)
- { return (*(*((const T **)a1))).Compare(*(*((const T **)a2))); }
-
- void Sort() { _v.Sort(CompareObjectItems, 0); }
-};
-
-#define FOR_VECTOR(_i_, _v_) for (unsigned _i_ = 0; _i_ < (_v_).Size(); _i_++)
-
-#endif
+// Common/MyVector.h
+
+#ifndef ZIP7_INC_COMMON_MY_VECTOR_H
+#define ZIP7_INC_COMMON_MY_VECTOR_H
+
+#include <string.h>
+
+#include "Common.h"
+
+const unsigned k_VectorSizeMax = ((unsigned)1 << 31) - 1;
+
+template <class T>
+class CRecordVector
+{
+ T *_items;
+ unsigned _size;
+ unsigned _capacity;
+
+ void MoveItems(unsigned destIndex, unsigned srcIndex)
+ {
+ memmove(_items + destIndex, _items + srcIndex, (size_t)(_size - srcIndex) * sizeof(T));
+ }
+
+ void ReAllocForNewCapacity(const unsigned newCapacity)
+ {
+ T *p;
+ Z7_ARRAY_NEW(p, T, newCapacity)
+ // p = new T[newCapacity];
+ if (_size != 0)
+ memcpy(p, _items, (size_t)_size * sizeof(T));
+ delete []_items;
+ _items = p;
+ _capacity = newCapacity;
+ }
+
+public:
+
+ void ReserveOnePosition()
+ {
+ if (_size != _capacity)
+ return;
+ if (_capacity >= k_VectorSizeMax)
+ throw 2021;
+ const unsigned rem = k_VectorSizeMax - _capacity;
+ unsigned add = (_capacity >> 2) + 1;
+ if (add > rem)
+ add = rem;
+ ReAllocForNewCapacity(_capacity + add);
+ }
+
+ CRecordVector(): _items(NULL), _size(0), _capacity(0) {}
+
+ CRecordVector(const CRecordVector &v): _items(NULL), _size(0), _capacity(0)
+ {
+ const unsigned size = v.Size();
+ if (size != 0)
+ {
+ // Z7_ARRAY_NEW(_items, T, size)
+ _items = new T[size];
+ _size = size;
+ _capacity = size;
+ memcpy(_items, v._items, (size_t)size * sizeof(T));
+ }
+ }
+
+ unsigned Size() const { return _size; }
+ bool IsEmpty() const { return _size == 0; }
+
+ void ConstructReserve(unsigned size)
+ {
+ if (size != 0)
+ {
+ Z7_ARRAY_NEW(_items, T, size)
+ // _items = new T[size];
+ _capacity = size;
+ }
+ }
+
+ void Reserve(unsigned newCapacity)
+ {
+ if (newCapacity > _capacity)
+ {
+ if (newCapacity > k_VectorSizeMax)
+ throw 2021;
+ ReAllocForNewCapacity(newCapacity);
+ }
+ }
+
+ void ChangeSize_KeepData(unsigned newSize)
+ {
+ Reserve(newSize);
+ _size = newSize;
+ }
+
+ void ClearAndReserve(unsigned newCapacity)
+ {
+ Clear();
+ if (newCapacity > _capacity)
+ {
+ if (newCapacity > k_VectorSizeMax)
+ throw 2021;
+ delete []_items;
+ _items = NULL;
+ _capacity = 0;
+ Z7_ARRAY_NEW(_items, T, newCapacity)
+ // _items = new T[newCapacity];
+ _capacity = newCapacity;
+ }
+ }
+
+ void ClearAndSetSize(unsigned newSize)
+ {
+ ClearAndReserve(newSize);
+ _size = newSize;
+ }
+
+ void ReserveDown()
+ {
+ if (_size == _capacity)
+ return;
+ T *p = NULL;
+ if (_size != 0)
+ {
+ // Z7_ARRAY_NEW(p, T, _size)
+ p = new T[_size];
+ memcpy(p, _items, (size_t)_size * sizeof(T));
+ }
+ delete []_items;
+ _items = p;
+ _capacity = _size;
+ }
+
+ ~CRecordVector() { delete []_items; }
+
+ void ClearAndFree()
+ {
+ delete []_items;
+ _items = NULL;
+ _size = 0;
+ _capacity = 0;
+ }
+
+ void Clear() { _size = 0; }
+
+ void DeleteBack() { _size--; }
+
+ void DeleteFrom(unsigned index)
+ {
+ // if (index <= _size)
+ _size = index;
+ }
+
+ void DeleteFrontal(unsigned num)
+ {
+ if (num != 0)
+ {
+ MoveItems(0, num);
+ _size -= num;
+ }
+ }
+
+ void Delete(unsigned index)
+ {
+ MoveItems(index, index + 1);
+ _size -= 1;
+ }
+
+ /*
+ void Delete(unsigned index, unsigned num)
+ {
+ if (num > 0)
+ {
+ MoveItems(index, index + num);
+ _size -= num;
+ }
+ }
+ */
+
+ CRecordVector& operator=(const CRecordVector &v)
+ {
+ if (&v == this)
+ return *this;
+ const unsigned size = v.Size();
+ if (size > _capacity)
+ {
+ delete []_items;
+ _capacity = 0;
+ _size = 0;
+ _items = NULL;
+ _items = new T[size];
+ _capacity = size;
+ }
+ _size = size;
+ if (size != 0)
+ memcpy(_items, v._items, (size_t)size * sizeof(T));
+ return *this;
+ }
+
+ CRecordVector& operator+=(const CRecordVector &v)
+ {
+ const unsigned size = v.Size();
+ if (size != 0)
+ {
+ if (_size >= k_VectorSizeMax || size > k_VectorSizeMax - _size)
+ throw 2021;
+ const unsigned newSize = _size + size;
+ Reserve(newSize);
+ memcpy(_items + _size, v._items, (size_t)size * sizeof(T));
+ _size = newSize;
+ }
+ return *this;
+ }
+
+ unsigned Add(const T item)
+ {
+ ReserveOnePosition();
+ const unsigned size = _size;
+ _size = size + 1;
+ _items[size] = item;
+ return size;
+ }
+
+ /*
+ unsigned Add2(const T &item)
+ {
+ ReserveOnePosition();
+ const unsigned size = _size;
+ _size = size + 1;
+ _items[size] = item;
+ return size;
+ }
+ */
+
+ unsigned AddInReserved(const T item)
+ {
+ const unsigned size = _size;
+ _size = size + 1;
+ _items[size] = item;
+ return size;
+ }
+
+ void Insert(unsigned index, const T item)
+ {
+ ReserveOnePosition();
+ MoveItems(index + 1, index);
+ _items[index] = item;
+ _size++;
+ }
+
+ void InsertInReserved(unsigned index, const T item)
+ {
+ MoveItems(index + 1, index);
+ _items[index] = item;
+ _size++;
+ }
+
+ void MoveToFront(unsigned index)
+ {
+ if (index != 0)
+ {
+ T temp = _items[index];
+ memmove(_items + 1, _items, (size_t)index * sizeof(T));
+ _items[0] = temp;
+ }
+ }
+
+ const T& operator[](unsigned index) const { return _items[index]; }
+ T& operator[](unsigned index) { return _items[index]; }
+ const T& operator[](int index) const { return _items[(unsigned)index]; }
+ T& operator[](int index) { return _items[(unsigned)index]; }
+ const T& Front() const { return _items[0]; }
+ T& Front() { return _items[0]; }
+ const T& Back() const { return _items[(size_t)_size - 1]; }
+ T& Back() { return _items[(size_t)_size - 1]; }
+
+ /*
+ void Swap(unsigned i, unsigned j)
+ {
+ T temp = _items[i];
+ _items[i] = _items[j];
+ _items[j] = temp;
+ }
+ */
+
+ int FindInSorted(const T item, unsigned left, unsigned right) const
+ {
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T midVal = (*this)[mid];
+ if (item == midVal)
+ return (int)mid;
+ if (item < midVal)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+ }
+
+ int FindInSorted2(const T &item, unsigned left, unsigned right) const
+ {
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T& midVal = (*this)[mid];
+ const int comp = item.Compare(midVal);
+ if (comp == 0)
+ return (int)mid;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+ }
+
+ int FindInSorted(const T item) const
+ {
+ return FindInSorted(item, 0, _size);
+ }
+
+ int FindInSorted2(const T &item) const
+ {
+ return FindInSorted2(item, 0, _size);
+ }
+
+ unsigned AddToUniqueSorted(const T item)
+ {
+ unsigned left = 0, right = _size;
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T midVal = (*this)[mid];
+ if (item == midVal)
+ return mid;
+ if (item < midVal)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ Insert(right, item);
+ return right;
+ }
+
+ unsigned AddToUniqueSorted2(const T &item)
+ {
+ unsigned left = 0, right = _size;
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T& midVal = (*this)[mid];
+ const int comp = item.Compare(midVal);
+ if (comp == 0)
+ return mid;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ Insert(right, item);
+ return right;
+ }
+
+ static void SortRefDown(T* p, unsigned k, unsigned size, int (*compare)(const T*, const T*, void *), void *param)
+ {
+ T temp = p[k];
+ for (;;)
+ {
+ unsigned s = (k << 1);
+ if (s > size)
+ break;
+ if (s < size && compare(p + s + 1, p + s, param) > 0)
+ s++;
+ if (compare(&temp, p + s, param) >= 0)
+ break;
+ p[k] = p[s];
+ k = s;
+ }
+ p[k] = temp;
+ }
+
+ void Sort(int (*compare)(const T*, const T*, void *), void *param)
+ {
+ unsigned size = _size;
+ if (size <= 1)
+ return;
+ T* p = (&Front()) - 1;
+ {
+ unsigned i = size >> 1;
+ do
+ SortRefDown(p, i, size, compare, param);
+ while (--i != 0);
+ }
+ do
+ {
+ T temp = p[size];
+ p[size--] = p[1];
+ p[1] = temp;
+ SortRefDown(p, 1, size, compare, param);
+ }
+ while (size > 1);
+ }
+
+ static void SortRefDown2(T* p, unsigned k, unsigned size)
+ {
+ T temp = p[k];
+ for (;;)
+ {
+ unsigned s = (k << 1);
+ if (s > size)
+ break;
+ if (s < size && p[(size_t)s + 1].Compare(p[s]) > 0)
+ s++;
+ if (temp.Compare(p[s]) >= 0)
+ break;
+ p[k] = p[s];
+ k = s;
+ }
+ p[k] = temp;
+ }
+
+ void Sort2()
+ {
+ unsigned size = _size;
+ if (size <= 1)
+ return;
+ T* p = (&Front()) - 1;
+ {
+ unsigned i = size >> 1;
+ do
+ SortRefDown2(p, i, size);
+ while (--i != 0);
+ }
+ do
+ {
+ T temp = p[size];
+ p[size--] = p[1];
+ p[1] = temp;
+ SortRefDown2(p, 1, size);
+ }
+ while (size > 1);
+ }
+};
+
+typedef CRecordVector<int> CIntVector;
+typedef CRecordVector<unsigned int> CUIntVector;
+typedef CRecordVector<bool> CBoolVector;
+typedef CRecordVector<unsigned char> CByteVector;
+typedef CRecordVector<void *> CPointerVector;
+
+template <class T>
+class CObjectVector
+{
+ CPointerVector _v;
+public:
+ unsigned Size() const { return _v.Size(); }
+ bool IsEmpty() const { return _v.IsEmpty(); }
+ void ReserveDown() { _v.ReserveDown(); }
+ // void Reserve(unsigned newCapacity) { _v.Reserve(newCapacity); }
+ void ClearAndReserve(unsigned newCapacity) { Clear(); _v.ClearAndReserve(newCapacity); }
+
+ CObjectVector() {}
+ CObjectVector(const CObjectVector &v)
+ {
+ const unsigned size = v.Size();
+ _v.ConstructReserve(size);
+ for (unsigned i = 0; i < size; i++)
+ AddInReserved(v[i]);
+ }
+ CObjectVector& operator=(const CObjectVector &v)
+ {
+ if (&v == this)
+ return *this;
+ Clear();
+ const unsigned size = v.Size();
+ _v.Reserve(size);
+ for (unsigned i = 0; i < size; i++)
+ AddInReserved(v[i]);
+ return *this;
+ }
+
+ CObjectVector& operator+=(const CObjectVector &v)
+ {
+ const unsigned addSize = v.Size();
+ if (addSize != 0)
+ {
+ const unsigned size = Size();
+ if (size >= k_VectorSizeMax || addSize > k_VectorSizeMax - size)
+ throw 2021;
+ _v.Reserve(size + addSize);
+ for (unsigned i = 0; i < addSize; i++)
+ AddInReserved(v[i]);
+ }
+ return *this;
+ }
+
+ const T& operator[](unsigned index) const { return *((T *)_v[index]); }
+ T& operator[](unsigned index) { return *((T *)_v[index]); }
+ const T& operator[](int index) const { return *((T *)_v[(unsigned)index]); }
+ T& operator[](int index) { return *((T *)_v[(unsigned)index]); }
+ const T& Front() const { return operator[](0); }
+ T& Front() { return operator[](0); }
+ const T& Back() const { return *(T *)_v.Back(); }
+ T& Back() { return *(T *)_v.Back(); }
+
+ void MoveToFront(unsigned index) { _v.MoveToFront(index); }
+
+ unsigned Add(const T& item)
+ {
+ _v.ReserveOnePosition();
+ return AddInReserved(item);
+ }
+
+ unsigned AddInReserved(const T& item)
+ {
+ return _v.AddInReserved(new T(item));
+ }
+
+ void ReserveOnePosition()
+ {
+ _v.ReserveOnePosition();
+ }
+
+ unsigned AddInReserved_Ptr_of_new(T *ptr)
+ {
+ return _v.AddInReserved(ptr);
+ }
+
+ #define VECTOR_ADD_NEW_OBJECT(v, a) \
+ (v).ReserveOnePosition(); \
+ (v).AddInReserved_Ptr_of_new(new a);
+
+
+ T& AddNew()
+ {
+ _v.ReserveOnePosition();
+ T *p = new T;
+ _v.AddInReserved(p);
+ return *p;
+ }
+
+ T& AddNewInReserved()
+ {
+ T *p = new T;
+ _v.AddInReserved(p);
+ return *p;
+ }
+
+ void Insert(unsigned index, const T& item)
+ {
+ _v.ReserveOnePosition();
+ _v.InsertInReserved(index, new T(item));
+ }
+
+ T& InsertNew(unsigned index)
+ {
+ _v.ReserveOnePosition();
+ T *p = new T;
+ _v.InsertInReserved(index, p);
+ return *p;
+ }
+
+ ~CObjectVector()
+ {
+ for (unsigned i = _v.Size(); i != 0;)
+ delete (T *)_v[--i];
+ }
+
+ void ClearAndFree()
+ {
+ Clear();
+ _v.ClearAndFree();
+ }
+
+ void Clear()
+ {
+ for (unsigned i = _v.Size(); i != 0;)
+ delete (T *)_v[--i];
+ _v.Clear();
+ }
+
+ void DeleteFrom(unsigned index)
+ {
+ const unsigned size = _v.Size();
+ for (unsigned i = index; i < size; i++)
+ delete (T *)_v[i];
+ _v.DeleteFrom(index);
+ }
+
+ void DeleteFrontal(unsigned num)
+ {
+ for (unsigned i = 0; i < num; i++)
+ delete (T *)_v[i];
+ _v.DeleteFrontal(num);
+ }
+
+ void DeleteBack()
+ {
+ delete (T *)_v.Back();
+ _v.DeleteBack();
+ }
+
+ void Delete(unsigned index)
+ {
+ delete (T *)_v[index];
+ _v.Delete(index);
+ }
+ // void Delete(int index) { Delete((unsigned)index); }
+
+ /*
+ void Delete(unsigned index, unsigned num)
+ {
+ for (unsigned i = 0; i < num; i++)
+ delete (T *)_v[index + i];
+ _v.Delete(index, num);
+ }
+ */
+
+ /*
+ int Find(const T& item) const
+ {
+ unsigned size = Size();
+ for (unsigned i = 0; i < size; i++)
+ if (item == (*this)[i])
+ return i;
+ return -1;
+ }
+ */
+
+ int FindInSorted(const T& item) const
+ {
+ unsigned left = 0, right = Size();
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T& midVal = (*this)[mid];
+ const int comp = item.Compare(midVal);
+ if (comp == 0)
+ return (int)mid;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ return -1;
+ }
+
+ unsigned AddToUniqueSorted(const T& item)
+ {
+ unsigned left = 0, right = Size();
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T& midVal = (*this)[mid];
+ const int comp = item.Compare(midVal);
+ if (comp == 0)
+ return mid;
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ Insert(right, item);
+ return right;
+ }
+
+ /*
+ unsigned AddToSorted(const T& item)
+ {
+ unsigned left = 0, right = Size();
+ while (left != right)
+ {
+ // const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
+ const unsigned mid = (left + right) / 2;
+ const T& midVal = (*this)[mid];
+ const int comp = item.Compare(midVal);
+ if (comp == 0)
+ {
+ right = mid + 1;
+ break;
+ }
+ if (comp < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ Insert(right, item);
+ return right;
+ }
+ */
+
+ void Sort(int (*compare)(void *const *, void *const *, void *), void *param)
+ { _v.Sort(compare, param); }
+
+ static int CompareObjectItems(void *const *a1, void *const *a2, void * /* param */)
+ { return (*(*((const T *const *)a1))).Compare(*(*((const T *const *)a2))); }
+
+ void Sort() { _v.Sort(CompareObjectItems, NULL); }
+};
+
+#define FOR_VECTOR(_i_, _v_) for (unsigned _i_ = 0; _i_ < (_v_).Size(); _i_++)
+
+#endif
diff --git a/CPP/Common/MyWindows.cpp b/CPP/Common/MyWindows.cpp
index bc9f7be..ae284eb 100644
--- a/CPP/Common/MyWindows.cpp
+++ b/CPP/Common/MyWindows.cpp
@@ -1,145 +1,292 @@
-// MyWindows.cpp
-
-#include "StdAfx.h"
-
-#ifndef _WIN32
-
-#include <stdlib.h>
-
-#include "MyWindows.h"
-
-static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
-static inline void FreeForBSTR(void *pv) { ::free(pv);}
-
-/* Win32 uses DWORD (32-bit) type to store size of string before (OLECHAR *) string.
- We must select CBstrSizeType for another systems (not Win32):
-
- if (CBstrSizeType is UINT32),
- then we support only strings smaller than 4 GB.
- Win32 version always has that limitation.
-
- if (CBstrSizeType is UINT),
- (UINT can be 16/32/64-bit)
- We can support strings larger than 4 GB (if UINT is 64-bit),
- but sizeof(UINT) can be different in parts compiled by
- different compilers/settings,
- and we can't send such BSTR strings between such parts.
-*/
-
-typedef UINT32 CBstrSizeType;
-// typedef UINT CBstrSizeType;
-
-#define k_BstrSize_Max 0xFFFFFFFF
-// #define k_BstrSize_Max UINT_MAX
-// #define k_BstrSize_Max ((UINT)(INT)-1)
-
-BSTR SysAllocStringByteLen(LPCSTR s, UINT len)
-{
- /* Original SysAllocStringByteLen in Win32 maybe fills only unaligned null OLECHAR at the end.
- We provide also aligned null OLECHAR at the end. */
-
- if (len >= (k_BstrSize_Max - sizeof(OLECHAR) - sizeof(OLECHAR) - sizeof(CBstrSizeType)))
- return NULL;
-
- UINT size = (len + sizeof(OLECHAR) + sizeof(OLECHAR) - 1) & ~(sizeof(OLECHAR) - 1);
- void *p = AllocateForBSTR(size + sizeof(CBstrSizeType));
- if (!p)
- return NULL;
- *(CBstrSizeType *)p = (CBstrSizeType)len;
- BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
- if (s)
- memcpy(bstr, s, len);
- for (; len < size; len++)
- ((Byte *)bstr)[len] = 0;
- return bstr;
-}
-
-BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
-{
- if (len >= (k_BstrSize_Max - sizeof(OLECHAR) - sizeof(CBstrSizeType)) / sizeof(OLECHAR))
- return NULL;
-
- UINT size = len * sizeof(OLECHAR);
- void *p = AllocateForBSTR(size + sizeof(CBstrSizeType) + sizeof(OLECHAR));
- if (!p)
- return NULL;
- *(CBstrSizeType *)p = (CBstrSizeType)size;
- BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
- if (s)
- memcpy(bstr, s, size);
- bstr[len] = 0;
- return bstr;
-}
-
-BSTR SysAllocString(const OLECHAR *s)
-{
- if (!s)
- return 0;
- const OLECHAR *s2 = s;
- while (*s2 != 0)
- s2++;
- return SysAllocStringLen(s, (UINT)(s2 - s));
-}
-
-void SysFreeString(BSTR bstr)
-{
- if (bstr)
- FreeForBSTR((CBstrSizeType *)bstr - 1);
-}
-
-UINT SysStringByteLen(BSTR bstr)
-{
- if (!bstr)
- return 0;
- return *((CBstrSizeType *)bstr - 1);
-}
-
-UINT SysStringLen(BSTR bstr)
-{
- if (!bstr)
- return 0;
- return *((CBstrSizeType *)bstr - 1) / sizeof(OLECHAR);
-}
-
-
-HRESULT VariantClear(VARIANTARG *prop)
-{
- if (prop->vt == VT_BSTR)
- SysFreeString(prop->bstrVal);
- prop->vt = VT_EMPTY;
- return S_OK;
-}
-
-HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src)
-{
- HRESULT res = ::VariantClear(dest);
- if (res != S_OK)
- return res;
- if (src->vt == VT_BSTR)
- {
- dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
- SysStringByteLen(src->bstrVal));
- if (!dest->bstrVal)
- return E_OUTOFMEMORY;
- dest->vt = VT_BSTR;
- }
- else
- *dest = *src;
- return S_OK;
-}
-
-LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
-{
- if (ft1->dwHighDateTime < ft2->dwHighDateTime) return -1;
- if (ft1->dwHighDateTime > ft2->dwHighDateTime) return 1;
- if (ft1->dwLowDateTime < ft2->dwLowDateTime) return -1;
- if (ft1->dwLowDateTime > ft2->dwLowDateTime) return 1;
- return 0;
-}
-
-DWORD GetLastError()
-{
- return 0;
-}
-
-#endif
+// MyWindows.cpp
+
+#include "StdAfx.h"
+
+#ifndef _WIN32
+
+#include <stdlib.h>
+#include <time.h>
+#ifdef __GNUC__
+#include <sys/time.h>
+#endif
+
+#include "MyWindows.h"
+
+static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
+static inline void FreeForBSTR(void *pv) { ::free(pv);}
+
+/* Win32 uses DWORD (32-bit) type to store size of string before (OLECHAR *) string.
+ We must select CBstrSizeType for another systems (not Win32):
+
+ if (CBstrSizeType is UINT32),
+ then we support only strings smaller than 4 GB.
+ Win32 version always has that limitation.
+
+ if (CBstrSizeType is UINT),
+ (UINT can be 16/32/64-bit)
+ We can support strings larger than 4 GB (if UINT is 64-bit),
+ but sizeof(UINT) can be different in parts compiled by
+ different compilers/settings,
+ and we can't send such BSTR strings between such parts.
+*/
+
+typedef UINT32 CBstrSizeType;
+// typedef UINT CBstrSizeType;
+
+#define k_BstrSize_Max 0xFFFFFFFF
+// #define k_BstrSize_Max UINT_MAX
+// #define k_BstrSize_Max ((UINT)(INT)-1)
+
+BSTR SysAllocStringByteLen(LPCSTR s, UINT len)
+{
+ /* Original SysAllocStringByteLen in Win32 maybe fills only unaligned null OLECHAR at the end.
+ We provide also aligned null OLECHAR at the end. */
+
+ if (len >= (k_BstrSize_Max - (UINT)sizeof(OLECHAR) - (UINT)sizeof(OLECHAR) - (UINT)sizeof(CBstrSizeType)))
+ return NULL;
+
+ UINT size = (len + (UINT)sizeof(OLECHAR) + (UINT)sizeof(OLECHAR) - 1) & ~((UINT)sizeof(OLECHAR) - 1);
+ void *p = AllocateForBSTR(size + (UINT)sizeof(CBstrSizeType));
+ if (!p)
+ return NULL;
+ *(CBstrSizeType *)p = (CBstrSizeType)len;
+ BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
+ if (s)
+ memcpy(bstr, s, len);
+ for (; len < size; len++)
+ ((Byte *)bstr)[len] = 0;
+ return bstr;
+}
+
+BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
+{
+ if (len >= (k_BstrSize_Max - (UINT)sizeof(OLECHAR) - (UINT)sizeof(CBstrSizeType)) / (UINT)sizeof(OLECHAR))
+ return NULL;
+
+ UINT size = len * (UINT)sizeof(OLECHAR);
+ void *p = AllocateForBSTR(size + (UINT)sizeof(CBstrSizeType) + (UINT)sizeof(OLECHAR));
+ if (!p)
+ return NULL;
+ *(CBstrSizeType *)p = (CBstrSizeType)size;
+ BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
+ if (s)
+ memcpy(bstr, s, size);
+ bstr[len] = 0;
+ return bstr;
+}
+
+BSTR SysAllocString(const OLECHAR *s)
+{
+ if (!s)
+ return NULL;
+ const OLECHAR *s2 = s;
+ while (*s2 != 0)
+ s2++;
+ return SysAllocStringLen(s, (UINT)(s2 - s));
+}
+
+void SysFreeString(BSTR bstr)
+{
+ if (bstr)
+ FreeForBSTR((CBstrSizeType *)bstr - 1);
+}
+
+UINT SysStringByteLen(BSTR bstr)
+{
+ if (!bstr)
+ return 0;
+ return *((CBstrSizeType *)bstr - 1);
+}
+
+UINT SysStringLen(BSTR bstr)
+{
+ if (!bstr)
+ return 0;
+ return *((CBstrSizeType *)bstr - 1) / (UINT)sizeof(OLECHAR);
+}
+
+
+HRESULT VariantClear(VARIANTARG *prop)
+{
+ if (prop->vt == VT_BSTR)
+ SysFreeString(prop->bstrVal);
+ prop->vt = VT_EMPTY;
+ return S_OK;
+}
+
+HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src)
+{
+ HRESULT res = ::VariantClear(dest);
+ if (res != S_OK)
+ return res;
+ if (src->vt == VT_BSTR)
+ {
+ dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
+ SysStringByteLen(src->bstrVal));
+ if (!dest->bstrVal)
+ return E_OUTOFMEMORY;
+ dest->vt = VT_BSTR;
+ }
+ else
+ *dest = *src;
+ return S_OK;
+}
+
+LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
+{
+ if (ft1->dwHighDateTime < ft2->dwHighDateTime) return -1;
+ if (ft1->dwHighDateTime > ft2->dwHighDateTime) return 1;
+ if (ft1->dwLowDateTime < ft2->dwLowDateTime) return -1;
+ if (ft1->dwLowDateTime > ft2->dwLowDateTime) return 1;
+ return 0;
+}
+
+DWORD GetLastError()
+{
+ return (DWORD)errno;
+}
+
+void SetLastError(DWORD dw)
+{
+ errno = (int)dw;
+}
+
+
+static LONG TIME_GetBias()
+{
+ time_t utc = time(NULL);
+ struct tm *ptm = localtime(&utc);
+ int localdaylight = ptm->tm_isdst; /* daylight for local timezone */
+ ptm = gmtime(&utc);
+ ptm->tm_isdst = localdaylight; /* use local daylight, not that of Greenwich */
+ LONG bias = (int)(mktime(ptm)-utc);
+ return bias;
+}
+
+#define TICKS_PER_SEC 10000000
+/*
+#define SECS_PER_DAY (24 * 60 * 60)
+#define SECS_1601_TO_1970 ((369 * 365 + 89) * (UInt64)SECS_PER_DAY)
+#define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKS_PER_SEC)
+*/
+
+#define GET_TIME_64(pft) ((pft)->dwLowDateTime | ((UInt64)(pft)->dwHighDateTime << 32))
+
+#define SET_FILETIME(ft, v64) \
+ (ft)->dwLowDateTime = (DWORD)v64; \
+ (ft)->dwHighDateTime = (DWORD)(v64 >> 32);
+
+
+BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFileTime)
+{
+ UInt64 v = GET_TIME_64(fileTime);
+ v = (UInt64)((Int64)v - (Int64)TIME_GetBias() * TICKS_PER_SEC);
+ SET_FILETIME(localFileTime, v)
+ return TRUE;
+}
+
+BOOL WINAPI LocalFileTimeToFileTime(const FILETIME *localFileTime, FILETIME *fileTime)
+{
+ UInt64 v = GET_TIME_64(localFileTime);
+ v = (UInt64)((Int64)v + (Int64)TIME_GetBias() * TICKS_PER_SEC);
+ SET_FILETIME(fileTime, v)
+ return TRUE;
+}
+
+/*
+VOID WINAPI GetSystemTimeAsFileTime(FILETIME *ft)
+{
+ UInt64 t = 0;
+ timeval tv;
+ if (gettimeofday(&tv, NULL) == 0)
+ {
+ t = tv.tv_sec * (UInt64)TICKS_PER_SEC + TICKS_1601_TO_1970;
+ t += tv.tv_usec * 10;
+ }
+ SET_FILETIME(ft, t)
+}
+*/
+
+DWORD WINAPI GetTickCount(VOID)
+{
+ #ifndef _WIN32
+ // gettimeofday() doesn't work in some MINGWs by unknown reason
+ timeval tv;
+ if (gettimeofday(&tv, NULL) == 0)
+ {
+ // tv_sec and tv_usec are (long)
+ return (DWORD)((UInt64)(Int64)tv.tv_sec * (UInt64)1000 + (UInt64)(Int64)tv.tv_usec / 1000);
+ }
+ #endif
+ return (DWORD)time(NULL) * 1000;
+}
+
+
+#define PERIOD_4 (4 * 365 + 1)
+#define PERIOD_100 (PERIOD_4 * 25 - 1)
+#define PERIOD_400 (PERIOD_100 * 4 + 1)
+
+BOOL WINAPI FileTimeToSystemTime(const FILETIME *ft, SYSTEMTIME *st)
+{
+ UInt32 v;
+ UInt64 v64 = GET_TIME_64(ft);
+ v64 /= 10000;
+ st->wMilliseconds = (WORD)(v64 % 1000); v64 /= 1000;
+ st->wSecond = (WORD)(v64 % 60); v64 /= 60;
+ st->wMinute = (WORD)(v64 % 60); v64 /= 60;
+ v = (UInt32)v64;
+ st->wHour = (WORD)(v % 24); v /= 24;
+
+ // 1601-01-01 was Monday
+ st->wDayOfWeek = (WORD)((v + 1) % 7);
+
+ UInt32 leaps, year, day, mon;
+ leaps = (3 * ((4 * v + (365 - 31 - 28) * 4 + 3) / PERIOD_400) + 3) / 4;
+ v += 28188 + leaps;
+ // leaps - the number of exceptions from PERIOD_4 rules starting from 1600-03-01
+ // (1959 / 64) - converts day from 03-01 to month
+ year = (20 * v - 2442) / (5 * PERIOD_4);
+ day = v - (year * PERIOD_4) / 4;
+ mon = (64 * day) / 1959;
+ st->wDay = (WORD)(day - (1959 * mon) / 64);
+ mon -= 1;
+ year += 1524;
+ if (mon > 12)
+ {
+ mon -= 12;
+ year++;
+ }
+ st->wMonth = (WORD)mon;
+ st->wYear = (WORD)year;
+
+ /*
+ unsigned year, mon;
+ unsigned char ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+ unsigned t;
+
+ year = (WORD)(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;
+
+ st->wYear = (WORD)year;
+
+ 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;
+ }
+ st->wDay = (WORD)(v + 1);
+ st->wMonth = (WORD)(mon + 1);
+ */
+
+ return TRUE;
+}
+
+#endif
diff --git a/CPP/Common/MyWindows.h b/CPP/Common/MyWindows.h
index cc78478..a76e14b 100644
--- a/CPP/Common/MyWindows.h
+++ b/CPP/Common/MyWindows.h
@@ -1,231 +1,324 @@
-// MyWindows.h
-
-#ifndef __MY_WINDOWS_H
-#define __MY_WINDOWS_H
-
-#ifdef _WIN32
-
-#include <windows.h>
-
-#ifdef UNDER_CE
- #undef VARIANT_TRUE
- #define VARIANT_TRUE ((VARIANT_BOOL)-1)
-#endif
-
-#else
-
-#include <stddef.h> // for wchar_t
-#include <string.h>
-// #include <stdint.h> // for uintptr_t
-
-#include "MyGuidDef.h"
-
-#define WINAPI
-
-typedef char CHAR;
-typedef unsigned char UCHAR;
-
-#undef BYTE
-typedef unsigned char BYTE;
-
-typedef short SHORT;
-typedef unsigned short USHORT;
-
-#undef WORD
-typedef unsigned short WORD;
-typedef short VARIANT_BOOL;
-
-typedef int INT;
-typedef Int32 INT32;
-typedef unsigned int UINT;
-typedef UInt32 UINT32;
-typedef INT32 LONG; // LONG, ULONG and DWORD must be 32-bit
-typedef UINT32 ULONG;
-
-#undef DWORD
-typedef UINT32 DWORD;
-
-typedef long BOOL;
-
-#ifndef FALSE
- #define FALSE 0
- #define TRUE 1
-#endif
-
-// typedef size_t ULONG_PTR;
-typedef size_t DWORD_PTR;
-// typedef uintptr_t UINT_PTR;
-// typedef ptrdiff_t UINT_PTR;
-
-typedef Int64 LONGLONG;
-typedef UInt64 ULONGLONG;
-
-typedef struct _LARGE_INTEGER { LONGLONG QuadPart; } LARGE_INTEGER;
-typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart; } ULARGE_INTEGER;
-
-typedef const CHAR *LPCSTR;
-typedef CHAR TCHAR;
-typedef const TCHAR *LPCTSTR;
-typedef wchar_t WCHAR;
-typedef WCHAR OLECHAR;
-typedef const WCHAR *LPCWSTR;
-typedef OLECHAR *BSTR;
-typedef const OLECHAR *LPCOLESTR;
-typedef OLECHAR *LPOLESTR;
-
-typedef struct _FILETIME
-{
- DWORD dwLowDateTime;
- DWORD dwHighDateTime;
-} FILETIME;
-
-#define HRESULT LONG
-#define FAILED(Status) ((HRESULT)(Status)<0)
-typedef ULONG PROPID;
-typedef LONG SCODE;
-
-#define ERROR_NEGATIVE_SEEK 131L
-
-#define S_OK ((HRESULT)0x00000000L)
-#define S_FALSE ((HRESULT)0x00000001L)
-#define E_NOTIMPL ((HRESULT)0x80004001L)
-#define E_NOINTERFACE ((HRESULT)0x80004002L)
-#define E_ABORT ((HRESULT)0x80004004L)
-#define E_FAIL ((HRESULT)0x80004005L)
-#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)
-#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
-#define E_INVALIDARG ((HRESULT)0x80070057L)
-
-#ifdef _MSC_VER
-#define STDMETHODCALLTYPE __stdcall
-#else
-#define STDMETHODCALLTYPE
-#endif
-
-#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f
-#define STDMETHOD(f) STDMETHOD_(HRESULT, f)
-#define STDMETHODIMP_(type) type STDMETHODCALLTYPE
-#define STDMETHODIMP STDMETHODIMP_(HRESULT)
-
-#define PURE = 0
-
-#define MIDL_INTERFACE(x) struct
-
-#ifdef __cplusplus
-
-DEFINE_GUID(IID_IUnknown,
-0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
-struct IUnknown
-{
- STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;
- STDMETHOD_(ULONG, AddRef)() PURE;
- STDMETHOD_(ULONG, Release)() PURE;
- #ifndef _WIN32
- virtual ~IUnknown() {}
- #endif
-};
-
-typedef IUnknown *LPUNKNOWN;
-
-#endif
-
-#define VARIANT_TRUE ((VARIANT_BOOL)-1)
-#define VARIANT_FALSE ((VARIANT_BOOL)0)
-
-enum VARENUM
-{
- VT_EMPTY = 0,
- VT_NULL = 1,
- VT_I2 = 2,
- VT_I4 = 3,
- VT_R4 = 4,
- VT_R8 = 5,
- VT_CY = 6,
- VT_DATE = 7,
- VT_BSTR = 8,
- VT_DISPATCH = 9,
- VT_ERROR = 10,
- VT_BOOL = 11,
- VT_VARIANT = 12,
- VT_UNKNOWN = 13,
- VT_DECIMAL = 14,
- VT_I1 = 16,
- VT_UI1 = 17,
- VT_UI2 = 18,
- VT_UI4 = 19,
- VT_I8 = 20,
- VT_UI8 = 21,
- VT_INT = 22,
- VT_UINT = 23,
- VT_VOID = 24,
- VT_HRESULT = 25,
- VT_FILETIME = 64
-};
-
-typedef unsigned short VARTYPE;
-typedef WORD PROPVAR_PAD1;
-typedef WORD PROPVAR_PAD2;
-typedef WORD PROPVAR_PAD3;
-
-typedef struct tagPROPVARIANT
-{
- VARTYPE vt;
- PROPVAR_PAD1 wReserved1;
- PROPVAR_PAD2 wReserved2;
- PROPVAR_PAD3 wReserved3;
- union
- {
- CHAR cVal;
- UCHAR bVal;
- SHORT iVal;
- USHORT uiVal;
- LONG lVal;
- ULONG ulVal;
- INT intVal;
- UINT uintVal;
- LARGE_INTEGER hVal;
- ULARGE_INTEGER uhVal;
- VARIANT_BOOL boolVal;
- SCODE scode;
- FILETIME filetime;
- BSTR bstrVal;
- };
-} PROPVARIANT;
-
-typedef PROPVARIANT tagVARIANT;
-typedef tagVARIANT VARIANT;
-typedef VARIANT VARIANTARG;
-
-MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
-MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src);
-
-typedef struct tagSTATPROPSTG
-{
- LPOLESTR lpwstrName;
- PROPID propid;
- VARTYPE vt;
-} STATPROPSTG;
-
-MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
-MY_EXTERN_C BSTR SysAllocStringLen(const OLECHAR *sz, UINT len);
-MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
-MY_EXTERN_C void SysFreeString(BSTR bstr);
-MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);
-MY_EXTERN_C UINT SysStringLen(BSTR bstr);
-
-MY_EXTERN_C DWORD GetLastError();
-MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
-
-#define CP_ACP 0
-#define CP_OEMCP 1
-#define CP_UTF8 65001
-
-typedef enum tagSTREAM_SEEK
-{
- STREAM_SEEK_SET = 0,
- STREAM_SEEK_CUR = 1,
- STREAM_SEEK_END = 2
-} STREAM_SEEK;
-
-#endif
-#endif
+// MyWindows.h
+
+#ifdef Z7_DEFINE_GUID
+#undef Z7_DEFINE_GUID
+#endif
+
+#ifdef INITGUID
+ #define Z7_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+ EXTERN_C const GUID name; \
+ EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+ #define Z7_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+ EXTERN_C const GUID name
+#endif
+
+
+#ifndef ZIP7_INC_MY_WINDOWS_H
+#define ZIP7_INC_MY_WINDOWS_H
+
+#ifdef _WIN32
+
+#include "../../C/7zWindows.h"
+
+#else // _WIN32
+
+#include <stddef.h> // for wchar_t
+#include <string.h>
+// #include <stdint.h> // for uintptr_t
+
+#include "../../C/7zTypes.h"
+#include "MyGuidDef.h"
+
+// WINAPI is __stdcall in Windows-MSVC in windef.h
+#define WINAPI
+
+typedef char CHAR;
+typedef unsigned char UCHAR;
+
+#undef BYTE
+typedef unsigned char BYTE;
+
+typedef short SHORT;
+typedef unsigned short USHORT;
+
+#undef WORD
+typedef unsigned short WORD;
+typedef short VARIANT_BOOL;
+
+#define LOWORD(l) ((WORD)((DWORD_PTR)(l) & 0xffff))
+#define HIWORD(l) ((WORD)((DWORD_PTR)(l) >> 16))
+
+// MS uses long for BOOL, but long is 32-bit in MS. So we use int.
+// typedef long BOOL;
+typedef int BOOL;
+
+#ifndef FALSE
+ #define FALSE 0
+ #define TRUE 1
+#endif
+
+// typedef size_t ULONG_PTR;
+// typedef size_t DWORD_PTR;
+// typedef uintptr_t UINT_PTR;
+// typedef ptrdiff_t UINT_PTR;
+
+typedef Int64 LONGLONG;
+typedef UInt64 ULONGLONG;
+
+typedef struct _LARGE_INTEGER { LONGLONG QuadPart; } LARGE_INTEGER;
+typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart; } ULARGE_INTEGER;
+
+typedef const CHAR *LPCSTR;
+typedef CHAR TCHAR;
+typedef const TCHAR *LPCTSTR;
+typedef wchar_t WCHAR;
+typedef WCHAR OLECHAR;
+typedef const WCHAR *LPCWSTR;
+typedef OLECHAR *BSTR;
+typedef const OLECHAR *LPCOLESTR;
+typedef OLECHAR *LPOLESTR;
+
+typedef struct _FILETIME
+{
+ DWORD dwLowDateTime;
+ DWORD dwHighDateTime;
+} FILETIME;
+
+#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
+#define FAILED(hr) ((HRESULT)(hr) < 0)
+typedef ULONG PROPID;
+typedef LONG SCODE;
+
+
+#define S_OK ((HRESULT)0x00000000L)
+#define S_FALSE ((HRESULT)0x00000001L)
+#define E_NOTIMPL ((HRESULT)0x80004001L)
+#define E_NOINTERFACE ((HRESULT)0x80004002L)
+#define E_ABORT ((HRESULT)0x80004004L)
+#define E_FAIL ((HRESULT)0x80004005L)
+#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)
+#define CLASS_E_CLASSNOTAVAILABLE ((HRESULT)0x80040111L)
+
+
+#ifdef _MSC_VER
+#define STDMETHODCALLTYPE __stdcall
+#define STDAPICALLTYPE __stdcall
+#else
+// do we need __export here?
+#define STDMETHODCALLTYPE
+#define STDAPICALLTYPE
+#endif
+
+#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE
+
+#ifndef DECLSPEC_NOTHROW
+#define DECLSPEC_NOTHROW Z7_DECLSPEC_NOTHROW
+#endif
+
+#ifndef DECLSPEC_NOVTABLE
+#define DECLSPEC_NOVTABLE Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifndef COM_DECLSPEC_NOTHROW
+#ifdef COM_STDMETHOD_CAN_THROW
+ #define COM_DECLSPEC_NOTHROW
+#else
+ #define COM_DECLSPEC_NOTHROW DECLSPEC_NOTHROW
+#endif
+#endif
+
+#define DECLARE_INTERFACE(iface) struct DECLSPEC_NOVTABLE iface
+#define DECLARE_INTERFACE_(iface, baseiface) struct DECLSPEC_NOVTABLE iface : public baseiface
+
+#define STDMETHOD_(t, f) virtual COM_DECLSPEC_NOTHROW t STDMETHODCALLTYPE f
+#define STDMETHOD(f) STDMETHOD_(HRESULT, f)
+#define STDMETHODIMP_(t) COM_DECLSPEC_NOTHROW t STDMETHODCALLTYPE
+#define STDMETHODIMP STDMETHODIMP_(HRESULT)
+
+
+#define PURE = 0
+
+// #define MIDL_INTERFACE(x) struct
+
+
+#ifdef __cplusplus
+
+/*
+ p7zip and 7-Zip before v23 used virtual destructor in IUnknown,
+ if _WIN32 is not defined.
+ It used virtual destructor, because some compilers don't like virtual
+ interfaces without virtual destructor.
+ IUnknown in Windows (_WIN32) doesn't use virtual destructor in IUnknown.
+ We still can define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN here,
+ if we want to be compatible with old plugin interface of p7zip and 7-Zip before v23.
+
+v23:
+ In new 7-Zip v23 we try to be more compatible with original IUnknown from _WIN32.
+ So we do not define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN here,
+*/
+// #define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+
+#ifdef Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Winconsistent-missing-destructor-override"
+#endif
+#endif
+
+Z7_PURE_INTERFACES_BEGIN
+
+DEFINE_GUID(IID_IUnknown,
+0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
+struct IUnknown
+{
+ STDMETHOD(QueryInterface) (REFIID iid, void **outObject) =0;
+ STDMETHOD_(ULONG, AddRef)() =0;
+ STDMETHOD_(ULONG, Release)() =0;
+ #ifdef Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+ virtual ~IUnknown() {}
+ #endif
+};
+
+typedef IUnknown *LPUNKNOWN;
+
+Z7_PURE_INTERFACES_END
+
+#endif // __cplusplus
+
+#define VARIANT_TRUE ((VARIANT_BOOL)-1)
+#define VARIANT_FALSE ((VARIANT_BOOL)0)
+
+enum VARENUM
+{
+ VT_EMPTY = 0,
+ VT_NULL = 1,
+ VT_I2 = 2,
+ VT_I4 = 3,
+ VT_R4 = 4,
+ VT_R8 = 5,
+ VT_CY = 6,
+ VT_DATE = 7,
+ VT_BSTR = 8,
+ VT_DISPATCH = 9,
+ VT_ERROR = 10,
+ VT_BOOL = 11,
+ VT_VARIANT = 12,
+ VT_UNKNOWN = 13,
+ VT_DECIMAL = 14,
+
+ VT_I1 = 16,
+ VT_UI1 = 17,
+ VT_UI2 = 18,
+ VT_UI4 = 19,
+ VT_I8 = 20,
+ VT_UI8 = 21,
+ VT_INT = 22,
+ VT_UINT = 23,
+ VT_VOID = 24,
+ VT_HRESULT = 25,
+ VT_FILETIME = 64
+};
+
+typedef unsigned short VARTYPE;
+typedef WORD PROPVAR_PAD1;
+typedef WORD PROPVAR_PAD2;
+typedef WORD PROPVAR_PAD3;
+
+typedef struct tagPROPVARIANT
+{
+ VARTYPE vt;
+ PROPVAR_PAD1 wReserved1;
+ PROPVAR_PAD2 wReserved2;
+ PROPVAR_PAD3 wReserved3;
+ union
+ {
+ CHAR cVal;
+ UCHAR bVal;
+ SHORT iVal;
+ USHORT uiVal;
+ LONG lVal;
+ ULONG ulVal;
+ INT intVal;
+ UINT uintVal;
+ LARGE_INTEGER hVal;
+ ULARGE_INTEGER uhVal;
+ VARIANT_BOOL boolVal;
+ SCODE scode;
+ FILETIME filetime;
+ BSTR bstrVal;
+ };
+} PROPVARIANT;
+
+typedef PROPVARIANT tagVARIANT;
+typedef tagVARIANT VARIANT;
+typedef VARIANT VARIANTARG;
+
+EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
+EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src);
+
+typedef struct tagSTATPROPSTG
+{
+ LPOLESTR lpwstrName;
+ PROPID propid;
+ VARTYPE vt;
+} STATPROPSTG;
+
+EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
+EXTERN_C BSTR SysAllocStringLen(const OLECHAR *sz, UINT len);
+EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
+EXTERN_C void SysFreeString(BSTR bstr);
+EXTERN_C UINT SysStringByteLen(BSTR bstr);
+EXTERN_C UINT SysStringLen(BSTR bstr);
+
+EXTERN_C DWORD GetLastError();
+EXTERN_C void SetLastError(DWORD dwCode);
+EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
+
+EXTERN_C DWORD GetCurrentThreadId();
+EXTERN_C DWORD GetCurrentProcessId();
+
+#define MAX_PATH 1024
+
+#define CP_ACP 0
+#define CP_OEMCP 1
+#define CP_UTF8 65001
+
+typedef enum tagSTREAM_SEEK
+{
+ STREAM_SEEK_SET = 0,
+ STREAM_SEEK_CUR = 1,
+ STREAM_SEEK_END = 2
+} STREAM_SEEK;
+
+
+
+typedef struct _SYSTEMTIME
+{
+ WORD wYear;
+ WORD wMonth;
+ WORD wDayOfWeek;
+ WORD wDay;
+ WORD wHour;
+ WORD wMinute;
+ WORD wSecond;
+ WORD wMilliseconds;
+} SYSTEMTIME;
+
+BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFileTime);
+BOOL WINAPI LocalFileTimeToFileTime(const FILETIME *localFileTime, FILETIME *fileTime);
+BOOL WINAPI FileTimeToSystemTime(const FILETIME *fileTime, SYSTEMTIME *systemTime);
+// VOID WINAPI GetSystemTimeAsFileTime(FILETIME *systemTimeAsFileTime);
+
+DWORD GetTickCount();
+
+
+#define CREATE_NEW 1
+#define CREATE_ALWAYS 2
+#define OPEN_EXISTING 3
+#define OPEN_ALWAYS 4
+#define TRUNCATE_EXISTING 5
+
+
+#endif // _WIN32
+
+#endif
diff --git a/CPP/Common/MyXml.cpp b/CPP/Common/MyXml.cpp
new file mode 100644
index 0000000..a879d34
--- /dev/null
+++ b/CPP/Common/MyXml.cpp
@@ -0,0 +1,260 @@
+// MyXml.cpp
+
+#include "StdAfx.h"
+
+#include "MyXml.h"
+
+static bool IsValidChar(char c)
+{
+ return
+ (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c >= '0' && c <= '9') ||
+ c == '-';
+}
+
+static bool IsSpaceChar(char c)
+{
+ return (c == ' ' || c == '\t' || c == 0x0D || c == 0x0A);
+}
+
+#define SKIP_SPACES(s) while (IsSpaceChar(*s)) s++;
+
+int CXmlItem::FindProp(const char *propName) const throw()
+{
+ FOR_VECTOR (i, Props)
+ if (Props[i].Name == propName)
+ return (int)i;
+ return -1;
+}
+
+AString CXmlItem::GetPropVal(const char *propName) const
+{
+ int index = FindProp(propName);
+ if (index >= 0)
+ return Props[(unsigned)index].Value;
+ return AString();
+}
+
+bool CXmlItem::IsTagged(const char *tag) const throw()
+{
+ return (IsTag && Name == tag);
+}
+
+int CXmlItem::FindSubTag(const char *tag) const throw()
+{
+ FOR_VECTOR (i, SubItems)
+ if (SubItems[i].IsTagged(tag))
+ return (int)i;
+ return -1;
+}
+
+AString CXmlItem::GetSubString() const
+{
+ if (SubItems.Size() == 1)
+ {
+ const CXmlItem &item = SubItems[0];
+ if (!item.IsTag)
+ return item.Name;
+ }
+ return AString();
+}
+
+const AString * CXmlItem::GetSubStringPtr() const throw()
+{
+ if (SubItems.Size() == 1)
+ {
+ const CXmlItem &item = SubItems[0];
+ if (!item.IsTag)
+ return &item.Name;
+ }
+ return NULL;
+}
+
+AString CXmlItem::GetSubStringForTag(const char *tag) const
+{
+ int index = FindSubTag(tag);
+ if (index >= 0)
+ return SubItems[(unsigned)index].GetSubString();
+ return AString();
+}
+
+const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
+{
+ SKIP_SPACES(s)
+
+ const char *beg = s;
+ for (;;)
+ {
+ char c;
+ c = *s; if (c == 0 || c == '<') break; s++;
+ c = *s; if (c == 0 || c == '<') break; s++;
+ }
+ if (*s == 0)
+ return NULL;
+ if (s != beg)
+ {
+ IsTag = false;
+ Name.SetFrom(beg, (unsigned)(s - beg));
+ return s;
+ }
+
+ IsTag = true;
+
+ s++;
+ SKIP_SPACES(s)
+
+ beg = s;
+ for (;; s++)
+ if (!IsValidChar(*s))
+ break;
+ if (s == beg || *s == 0)
+ return NULL;
+ Name.SetFrom(beg, (unsigned)(s - beg));
+
+ for (;;)
+ {
+ beg = s;
+ SKIP_SPACES(s)
+ if (*s == '/')
+ {
+ s++;
+ // SKIP_SPACES(s)
+ if (*s != '>')
+ return NULL;
+ return s + 1;
+ }
+ if (*s == '>')
+ {
+ s++;
+ if (numAllowedLevels == 0)
+ return NULL;
+ SubItems.Clear();
+ for (;;)
+ {
+ SKIP_SPACES(s)
+ if (s[0] == '<' && s[1] == '/')
+ break;
+ CXmlItem &item = SubItems.AddNew();
+ s = item.ParseItem(s, numAllowedLevels - 1);
+ if (!s)
+ return NULL;
+ }
+
+ s += 2;
+ unsigned len = Name.Len();
+ for (unsigned i = 0; i < len; i++)
+ if (s[i] != Name[i])
+ return NULL;
+ s += len;
+ if (s[0] != '>')
+ return NULL;
+ return s + 1;
+ }
+ if (beg == s)
+ return NULL;
+
+ // ReadProperty
+ CXmlProp &prop = Props.AddNew();
+
+ beg = s;
+ for (;; s++)
+ {
+ char c = *s;
+ if (!IsValidChar(c))
+ break;
+ }
+ if (s == beg)
+ return NULL;
+ prop.Name.SetFrom(beg, (unsigned)(s - beg));
+
+ SKIP_SPACES(s)
+ if (*s != '=')
+ return NULL;
+ s++;
+ SKIP_SPACES(s)
+ if (*s != '\"')
+ return NULL;
+ s++;
+
+ beg = s;
+ for (;;)
+ {
+ char c = *s;
+ if (c == 0)
+ return NULL;
+ if (c == '\"')
+ break;
+ s++;
+ }
+ prop.Value.SetFrom(beg, (unsigned)(s - beg));
+ s++;
+ }
+}
+
+static const char * SkipHeader(const char *s, const char *startString, const char *endString)
+{
+ SKIP_SPACES(s)
+ if (IsString1PrefixedByString2(s, startString))
+ {
+ s = strstr(s, endString);
+ if (!s)
+ return NULL;
+ s += strlen(endString);
+ }
+ return s;
+}
+
+void CXmlItem::AppendTo(AString &s) const
+{
+ if (IsTag)
+ s += '<';
+ s += Name;
+ if (IsTag)
+ {
+ FOR_VECTOR (i, Props)
+ {
+ const CXmlProp &prop = Props[i];
+ s.Add_Space();
+ s += prop.Name;
+ s += '=';
+ s += '\"';
+ s += prop.Value;
+ s += '\"';
+ }
+ s += '>';
+ }
+ FOR_VECTOR (i, SubItems)
+ {
+ const CXmlItem &item = SubItems[i];
+ if (i != 0 && !SubItems[i - 1].IsTag)
+ s.Add_Space();
+ item.AppendTo(s);
+ }
+ if (IsTag)
+ {
+ s += '<';
+ s += '/';
+ s += Name;
+ s += '>';
+ }
+}
+
+bool CXml::Parse(const char *s)
+{
+ s = SkipHeader(s, "<?xml", "?>"); if (!s) return false;
+ s = SkipHeader(s, "<!DOCTYPE", ">"); if (!s) return false;
+
+ s = Root.ParseItem(s, 1000);
+ if (!s || !Root.IsTag)
+ return false;
+ SKIP_SPACES(s)
+ return *s == 0;
+}
+
+/*
+void CXml::AppendTo(AString &s) const
+{
+ Root.AppendTo(s);
+}
+*/
diff --git a/CPP/Common/MyXml.h b/CPP/Common/MyXml.h
new file mode 100644
index 0000000..5362602
--- /dev/null
+++ b/CPP/Common/MyXml.h
@@ -0,0 +1,43 @@
+// MyXml.h
+
+#ifndef ZIP7_INC_MY_XML_H
+#define ZIP7_INC_MY_XML_H
+
+#include "MyString.h"
+
+struct CXmlProp
+{
+ AString Name;
+ AString Value;
+};
+
+class CXmlItem
+{
+public:
+ AString Name;
+ bool IsTag;
+ CObjectVector<CXmlProp> Props;
+ CObjectVector<CXmlItem> SubItems;
+
+ const char * ParseItem(const char *s, int numAllowedLevels);
+
+ bool IsTagged(const char *tag) const throw();
+ int FindProp(const char *propName) const throw();
+ AString GetPropVal(const char *propName) const;
+ AString GetSubString() const;
+ const AString * GetSubStringPtr() const throw();
+ int FindSubTag(const char *tag) const throw();
+ AString GetSubStringForTag(const char *tag) const;
+
+ void AppendTo(AString &s) const;
+};
+
+struct CXml
+{
+ CXmlItem Root;
+
+ bool Parse(const char *s);
+ // void AppendTo(AString &s) const;
+};
+
+#endif
diff --git a/CPP/Common/NewHandler.cpp b/CPP/Common/NewHandler.cpp
index 18d2d18..c95833e 100644
--- a/CPP/Common/NewHandler.cpp
+++ b/CPP/Common/NewHandler.cpp
@@ -1,163 +1,298 @@
-// NewHandler.cpp
-
-#include "StdAfx.h"
-
-#include <stdlib.h>
-
-#include "NewHandler.h"
-
-// #define DEBUG_MEMORY_LEAK
-
-#ifndef DEBUG_MEMORY_LEAK
-
-#ifdef _7ZIP_REDEFINE_OPERATOR_NEW
-
-/*
-void * my_new(size_t size)
-{
- // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
- void *p = ::malloc(size);
- if (p == 0)
- throw CNewException();
- return p;
-}
-
-void my_delete(void *p) throw()
-{
- // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
- ::free(p);
-}
-
-void * my_Realloc(void *p, size_t newSize, size_t oldSize)
-{
- void *newBuf = my_new(newSize);
- if (oldSize != 0)
- memcpy(newBuf, p, oldSize);
- my_delete(p);
- return newBuf;
-}
-*/
-
-void *
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator new(size_t size)
-{
- // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
- void *p = ::malloc(size);
- if (p == 0)
- throw CNewException();
- return p;
-}
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p) throw()
-{
- // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
- ::free(p);
-}
-
-/*
-void *
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator new[](size_t size)
-{
- // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
- void *p = ::malloc(size);
- if (p == 0)
- throw CNewException();
- return p;
-}
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete[](void *p) throw()
-{
- // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
- ::free(p);
-}
-*/
-
-#endif
-
-#else
-
-#include <stdio.h>
-
-// #pragma init_seg(lib)
-const int kDebugSize = 1000000;
-static void *a[kDebugSize];
-static int index = 0;
-
-static int numAllocs = 0;
-void * __cdecl operator new(size_t size)
-{
- numAllocs++;
- void *p = HeapAlloc(GetProcessHeap(), 0, size);
- if (index < kDebugSize)
- {
- a[index] = p;
- index++;
- }
- if (p == 0)
- throw CNewException();
- printf("Alloc %6d, size = %8u\n", numAllocs, (unsigned)size);
- return p;
-}
-
-class CC
-{
-public:
- CC()
- {
- for (int i = 0; i < kDebugSize; i++)
- a[i] = 0;
- }
- ~CC()
- {
- for (int i = 0; i < kDebugSize; i++)
- if (a[i] != 0)
- return;
- }
-} g_CC;
-
-
-void __cdecl operator delete(void *p)
-{
- if (p == 0)
- return;
- /*
- for (int i = 0; i < index; i++)
- if (a[i] == p)
- a[i] = 0;
- */
- HeapFree(GetProcessHeap(), 0, p);
- numAllocs--;
- printf("Free %d\n", numAllocs);
-}
-
-#endif
-
-/*
-int MemErrorVC(size_t)
-{
- throw CNewException();
- // return 1;
-}
-CNewHandlerSetter::CNewHandlerSetter()
-{
- // MemErrorOldVCFunction = _set_new_handler(MemErrorVC);
-}
-CNewHandlerSetter::~CNewHandlerSetter()
-{
- // _set_new_handler(MemErrorOldVCFunction);
-}
-*/
+// NewHandler.cpp
+
+#include "StdAfx.h"
+
+#include <stdlib.h>
+
+#include "NewHandler.h"
+
+// #define DEBUG_MEMORY_LEAK
+
+#ifndef DEBUG_MEMORY_LEAK
+
+#ifdef Z7_REDEFINE_OPERATOR_NEW
+
+/*
+void * my_new(size_t size)
+{
+ // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+ if (size == 0)
+ size = 1;
+ void *p = ::malloc(size);
+ if (!p)
+ throw CNewException();
+ return p;
+}
+
+void my_delete(void *p) throw()
+{
+ // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+ ::free(p);
+}
+
+void * my_Realloc(void *p, size_t newSize, size_t oldSize)
+{
+ void *newBuf = my_new(newSize);
+ if (oldSize != 0)
+ memcpy(newBuf, p, oldSize);
+ my_delete(p);
+ return newBuf;
+}
+*/
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size)
+{
+ /* by C++ specification:
+ if (size == 0), operator new(size) returns non_NULL pointer.
+ If (operator new(0) returns NULL), it's out of specification.
+ but some calling code can work correctly even in this case too. */
+ // if (size == 0) return NULL; // for debug only. don't use it
+
+ /* malloc(0) returns non_NULL in main compilers, as we need here.
+ But specification also allows malloc(0) to return NULL.
+ So we change (size=0) to (size=1) here to get real non_NULL pointer */
+ if (size == 0)
+ size = 1;
+ // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+ // void *p = ::MyAlloc(size); // note: MyAlloc(0) returns NULL
+ void *p = ::malloc(size);
+ if (!p)
+ throw CNewException();
+ return p;
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw()
+{
+ // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+ // MyFree(p);
+ ::free(p);
+}
+
+/*
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size)
+{
+ // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+ if (size == 0)
+ size = 1;
+ void *p = ::malloc(size);
+ if (!p)
+ throw CNewException();
+ return p;
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw()
+{
+ // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+ ::free(p);
+}
+*/
+
+#endif
+
+#else
+
+#include <stdio.h>
+
+// #pragma init_seg(lib)
+/*
+const int kDebugSize = 1000000;
+static void *a[kDebugSize];
+static int g_index = 0;
+
+class CC
+{
+public:
+ CC()
+ {
+ for (int i = 0; i < kDebugSize; i++)
+ a[i] = 0;
+ }
+ ~CC()
+ {
+ printf("\nDestructor: %d\n", numAllocs);
+ for (int i = 0; i < kDebugSize; i++)
+ if (a[i] != 0)
+ return;
+ }
+} g_CC;
+*/
+
+#ifdef _WIN32
+static bool wasInit = false;
+static CRITICAL_SECTION cs;
+#endif
+
+static int numAllocs = 0;
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size)
+{
+ #ifdef _WIN32
+ if (!wasInit)
+ {
+ InitializeCriticalSection(&cs);
+ wasInit = true;
+ }
+ EnterCriticalSection(&cs);
+
+ numAllocs++;
+ int loc = numAllocs;
+ void *p = HeapAlloc(GetProcessHeap(), 0, size);
+ /*
+ if (g_index < kDebugSize)
+ {
+ a[g_index] = p;
+ g_index++;
+ }
+ */
+ printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
+ LeaveCriticalSection(&cs);
+ if (!p)
+ throw CNewException();
+ return p;
+ #else
+ numAllocs++;
+ int loc = numAllocs;
+ if (size == 0)
+ size = 1;
+ void *p = malloc(size);
+ /*
+ if (g_index < kDebugSize)
+ {
+ a[g_index] = p;
+ g_index++;
+ }
+ */
+ printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
+ if (!p)
+ throw CNewException();
+ return p;
+ #endif
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw()
+{
+ if (!p)
+ return;
+ #ifdef _WIN32
+ EnterCriticalSection(&cs);
+ /*
+ for (int i = 0; i < g_index; i++)
+ if (a[i] == p)
+ a[i] = 0;
+ */
+ HeapFree(GetProcessHeap(), 0, p);
+ if (numAllocs == 0)
+ numAllocs = numAllocs; // ERROR
+ numAllocs--;
+ if (numAllocs == 0)
+ numAllocs = numAllocs; // OK: all objects were deleted
+ printf("Free %d\n", numAllocs);
+ LeaveCriticalSection(&cs);
+ #else
+ free(p);
+ numAllocs--;
+ printf("Free %d\n", numAllocs);
+ #endif
+}
+
+/*
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size)
+{
+ printf("operator_new[] : ");
+ return operator new(size);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t sz) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t sz) throw()
+{
+ if (!p)
+ return;
+ printf("operator_delete_size : size=%d : ", (unsigned)sz);
+ operator delete(p);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw()
+{
+ if (!p)
+ return;
+ printf("operator_delete[] : ");
+ operator delete(p);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p, size_t sz) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p, size_t sz) throw()
+{
+ if (!p)
+ return;
+ printf("operator_delete_size[] : size=%d : ", (unsigned)sz);
+ operator delete(p);
+}
+*/
+
+#endif
+
+/*
+int MemErrorVC(size_t)
+{
+ throw CNewException();
+ // return 1;
+}
+CNewHandlerSetter::CNewHandlerSetter()
+{
+ // MemErrorOldVCFunction = _set_new_handler(MemErrorVC);
+}
+CNewHandlerSetter::~CNewHandlerSetter()
+{
+ // _set_new_handler(MemErrorOldVCFunction);
+}
+*/
diff --git a/CPP/Common/NewHandler.h b/CPP/Common/NewHandler.h
index 9d20ee1..50f6d0a 100644
--- a/CPP/Common/NewHandler.h
+++ b/CPP/Common/NewHandler.h
@@ -1,88 +1,98 @@
-// Common/NewHandler.h
-
-#ifndef __COMMON_NEW_HANDLER_H
-#define __COMMON_NEW_HANDLER_H
-
-/*
-NewHandler.h and NewHandler.cpp allows to solve problem with compilers that
-don't throw exception in operator new().
-
-This file must be included before any code that uses operators new() or delete()
-and you must compile and link "NewHandler.cpp", if you use some old MSVC compiler.
-
-The operator new() in some MSVC versions doesn't throw exception std::bad_alloc.
-MSVC 6.0 (_MSC_VER == 1200) doesn't throw exception.
-The code produced by some another MSVC compilers also can be linked
-to library that doesn't throw exception.
-We suppose that code compiled with VS2015+ (_MSC_VER >= 1900) throws exception std::bad_alloc.
-For older _MSC_VER versions we redefine operator new() and operator delete().
-Our version of operator new() throws CNewException() exception on failure.
-
-It's still allowed to use redefined version of operator new() from "NewHandler.cpp"
-with any compiler. 7-Zip's code can work with std::bad_alloc and CNewException() exceptions.
-But if you use some additional code (outside of 7-Zip's code), you must check
-that redefined version of operator new() is not problem for your code.
-*/
-
-#include <stddef.h>
-
-#ifdef _WIN32
-// We can compile my_new and my_delete with _fastcall
-/*
-void * my_new(size_t size);
-void my_delete(void *p) throw();
-// void * my_Realloc(void *p, size_t newSize, size_t oldSize);
-*/
-#endif
-
-
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
- // If you want to use default operator new(), you can disable the following line
- #define _7ZIP_REDEFINE_OPERATOR_NEW
-#endif
-
-
-#ifdef _7ZIP_REDEFINE_OPERATOR_NEW
-
-// std::bad_alloc can require additional DLL dependency.
-// So we don't define CNewException as std::bad_alloc here.
-
-class CNewException {};
-
-void *
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator new(size_t size);
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p) throw();
-
-#else
-
-#include <new>
-
-#define CNewException std::bad_alloc
-
-#endif
-
-/*
-#ifdef _WIN32
-void *
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator new[](size_t size);
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete[](void *p) throw();
-#endif
-*/
-
-#endif
+// Common/NewHandler.h
+
+#ifndef ZIP7_INC_COMMON_NEW_HANDLER_H
+#define ZIP7_INC_COMMON_NEW_HANDLER_H
+
+/*
+NewHandler.h and NewHandler.cpp allows to solve problem with compilers that
+don't throw exception in operator new().
+
+This file must be included before any code that uses operators new() or delete()
+and you must compile and link "NewHandler.cpp", if you use some old MSVC compiler.
+
+DOCs:
+ Since ISO C++98, operator new throws std::bad_alloc when memory allocation fails.
+ MSVC 6.0 returned a null pointer on an allocation failure.
+ Beginning in VS2002, operator new conforms to the standard and throws on failure.
+
+ By default, the compiler also generates defensive null checks to prevent
+ these older-style allocators from causing an immediate crash on failure.
+ The /Zc:throwingNew option tells the compiler to leave out these null checks,
+ on the assumption that all linked memory allocators conform to the standard.
+
+The operator new() in some MSVC versions doesn't throw exception std::bad_alloc.
+MSVC 6.0 (_MSC_VER == 1200) doesn't throw exception.
+The code produced by some another MSVC compilers also can be linked
+to library that doesn't throw exception.
+We suppose that code compiled with VS2015+ (_MSC_VER >= 1900) throws exception std::bad_alloc.
+For older _MSC_VER versions we redefine operator new() and operator delete().
+Our version of operator new() throws CNewException() exception on failure.
+
+It's still allowed to use redefined version of operator new() from "NewHandler.cpp"
+with any compiler. 7-Zip's code can work with std::bad_alloc and CNewException() exceptions.
+But if you use some additional code (outside of 7-Zip's code), you must check
+that redefined version of operator new() is not problem for your code.
+*/
+
+#include <stddef.h>
+
+#ifdef _WIN32
+// We can compile my_new and my_delete with _fastcall
+/*
+void * my_new(size_t size);
+void my_delete(void *p) throw();
+// void * my_Realloc(void *p, size_t newSize, size_t oldSize);
+*/
+#endif
+
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+ // If you want to use default operator new(), you can disable the following line
+ #define Z7_REDEFINE_OPERATOR_NEW
+#endif
+
+
+#ifdef Z7_REDEFINE_OPERATOR_NEW
+
+// std::bad_alloc can require additional DLL dependency.
+// So we don't define CNewException as std::bad_alloc here.
+
+class CNewException {};
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size);
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw();
+
+#else
+
+#include <new>
+
+#define CNewException std::bad_alloc
+
+#endif
+
+/*
+#ifdef _WIN32
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size);
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw();
+#endif
+*/
+
+#endif
diff --git a/CPP/Common/Random.cpp b/CPP/Common/Random.cpp
new file mode 100644
index 0000000..fbdb8c9
--- /dev/null
+++ b/CPP/Common/Random.cpp
@@ -0,0 +1,28 @@
+// Common/Random.cpp
+
+#include "StdAfx.h"
+
+#include <stdlib.h>
+
+#ifndef _WIN32
+#include <time.h>
+#else
+#include "MyWindows.h"
+#endif
+
+#include "Random.h"
+
+void CRandom::Init(unsigned int seed) { srand(seed); }
+
+void CRandom::Init()
+{
+ Init((unsigned int)
+ #ifdef _WIN32
+ GetTickCount()
+ #else
+ time(NULL)
+ #endif
+ );
+}
+
+int CRandom::Generate() const { return rand(); }
diff --git a/CPP/Common/Random.h b/CPP/Common/Random.h
new file mode 100644
index 0000000..283869e
--- /dev/null
+++ b/CPP/Common/Random.h
@@ -0,0 +1,14 @@
+// Common/Random.h
+
+#ifndef ZIP7_INC_COMMON_RANDOM_H
+#define ZIP7_INC_COMMON_RANDOM_H
+
+class CRandom
+{
+public:
+ void Init();
+ void Init(unsigned int seed);
+ int Generate() const;
+};
+
+#endif
diff --git a/CPP/Common/Sha1Prepare.cpp b/CPP/Common/Sha1Prepare.cpp
new file mode 100644
index 0000000..2652f00
--- /dev/null
+++ b/CPP/Common/Sha1Prepare.cpp
@@ -0,0 +1,7 @@
+// Sha1Prepare.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha1.h"
+
+static struct CSha1Prepare { CSha1Prepare() { Sha1Prepare(); } } g_Sha1Prepare;
diff --git a/CPP/Common/Sha1Reg.cpp b/CPP/Common/Sha1Reg.cpp
new file mode 100644
index 0000000..64eef34
--- /dev/null
+++ b/CPP/Common/Sha1Reg.cpp
@@ -0,0 +1,67 @@
+// Sha1Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha1.h"
+
+#include "../Common/MyBuffer2.h"
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+Z7_CLASS_IMP_COM_2(
+ CSha1Hasher
+ , IHasher
+ , ICompressSetCoderProperties
+)
+ CAlignedBuffer1 _buf;
+public:
+ Byte _mtDummy[1 << 7];
+
+ CSha1 *Sha() { return (CSha1 *)(void *)(Byte *)_buf; }
+public:
+ CSha1Hasher():
+ _buf(sizeof(CSha1))
+ {
+ Sha1_SetFunction(Sha(), 0);
+ Sha1_InitState(Sha());
+ }
+};
+
+Z7_COM7F_IMF2(void, CSha1Hasher::Init())
+{
+ Sha1_InitState(Sha());
+}
+
+Z7_COM7F_IMF2(void, CSha1Hasher::Update(const void *data, UInt32 size))
+{
+ Sha1_Update(Sha(), (const Byte *)data, size);
+}
+
+Z7_COM7F_IMF2(void, CSha1Hasher::Final(Byte *digest))
+{
+ Sha1_Final(Sha(), digest);
+}
+
+
+Z7_COM7F_IMF(CSha1Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ unsigned algo = 0;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ if (propIDs[i] == NCoderPropID::kDefaultProp)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ if (prop.ulVal > 2)
+ return E_NOTIMPL;
+ algo = (unsigned)prop.ulVal;
+ }
+ }
+ if (!Sha1_SetFunction(Sha(), algo))
+ return E_NOTIMPL;
+ return S_OK;
+}
+
+REGISTER_HASHER(CSha1Hasher, 0x201, "SHA1", SHA1_DIGEST_SIZE)
diff --git a/CPP/Common/Sha256Prepare.cpp b/CPP/Common/Sha256Prepare.cpp
new file mode 100644
index 0000000..1ec242b
--- /dev/null
+++ b/CPP/Common/Sha256Prepare.cpp
@@ -0,0 +1,7 @@
+// Sha256Prepare.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha256.h"
+
+static struct CSha256Prepare { CSha256Prepare() { Sha256Prepare(); } } g_Sha256Prepare;
diff --git a/CPP/Common/Sha256Reg.cpp b/CPP/Common/Sha256Reg.cpp
index 14a3652..b5689c4 100644
--- a/CPP/Common/Sha256Reg.cpp
+++ b/CPP/Common/Sha256Reg.cpp
@@ -1,40 +1,67 @@
-// Sha256Reg.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/Sha256.h"
-
-#include "../Common/MyCom.h"
-
-#include "../7zip/Common/RegisterCodec.h"
-
-class CSha256Hasher:
- public IHasher,
- public CMyUnknownImp
-{
- CSha256 _sha;
- Byte mtDummy[1 << 7];
-
-public:
- CSha256Hasher() { Sha256_Init(&_sha); }
-
- MY_UNKNOWN_IMP1(IHasher)
- INTERFACE_IHasher(;)
-};
-
-STDMETHODIMP_(void) CSha256Hasher::Init() throw()
-{
- Sha256_Init(&_sha);
-}
-
-STDMETHODIMP_(void) CSha256Hasher::Update(const void *data, UInt32 size) throw()
-{
- Sha256_Update(&_sha, (const Byte *)data, size);
-}
-
-STDMETHODIMP_(void) CSha256Hasher::Final(Byte *digest) throw()
-{
- Sha256_Final(&_sha, digest);
-}
-
-REGISTER_HASHER(CSha256Hasher, 0xA, "SHA256", SHA256_DIGEST_SIZE)
+// Sha256Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha256.h"
+
+#include "../Common/MyBuffer2.h"
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+Z7_CLASS_IMP_COM_2(
+ CSha256Hasher
+ , IHasher
+ , ICompressSetCoderProperties
+)
+ CAlignedBuffer1 _buf;
+public:
+ Byte _mtDummy[1 << 7];
+
+ CSha256 *Sha() { return (CSha256 *)(void *)(Byte *)_buf; }
+public:
+ CSha256Hasher():
+ _buf(sizeof(CSha256))
+ {
+ Sha256_SetFunction(Sha(), 0);
+ Sha256_InitState(Sha());
+ }
+};
+
+Z7_COM7F_IMF2(void, CSha256Hasher::Init())
+{
+ Sha256_InitState(Sha());
+}
+
+Z7_COM7F_IMF2(void, CSha256Hasher::Update(const void *data, UInt32 size))
+{
+ Sha256_Update(Sha(), (const Byte *)data, size);
+}
+
+Z7_COM7F_IMF2(void, CSha256Hasher::Final(Byte *digest))
+{
+ Sha256_Final(Sha(), digest);
+}
+
+
+Z7_COM7F_IMF(CSha256Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+ unsigned algo = 0;
+ for (UInt32 i = 0; i < numProps; i++)
+ {
+ if (propIDs[i] == NCoderPropID::kDefaultProp)
+ {
+ const PROPVARIANT &prop = coderProps[i];
+ if (prop.vt != VT_UI4)
+ return E_INVALIDARG;
+ if (prop.ulVal > 2)
+ return E_NOTIMPL;
+ algo = (unsigned)prop.ulVal;
+ }
+ }
+ if (!Sha256_SetFunction(Sha(), algo))
+ return E_NOTIMPL;
+ return S_OK;
+}
+
+REGISTER_HASHER(CSha256Hasher, 0xA, "SHA256", SHA256_DIGEST_SIZE)
diff --git a/CPP/Common/StdAfx.h b/CPP/Common/StdAfx.h
index 3f1890a..a5228b0 100644
--- a/CPP/Common/StdAfx.h
+++ b/CPP/Common/StdAfx.h
@@ -1,8 +1,8 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#include "Common.h"
+
+#endif
diff --git a/CPP/Common/StdInStream.cpp b/CPP/Common/StdInStream.cpp
index f547b54..7b209f1 100644
--- a/CPP/Common/StdInStream.cpp
+++ b/CPP/Common/StdInStream.cpp
@@ -1,89 +1,98 @@
-// Common/StdInStream.cpp
-
-#include "StdAfx.h"
-
-#include <tchar.h>
-
-#include "StdInStream.h"
-#include "StringConvert.h"
-#include "UTFConvert.h"
-
-// #define kEOFMessage "Unexpected end of input stream"
-// #define kReadErrorMessage "Error reading input stream"
-// #define kIllegalCharMessage "Illegal zero character in input stream"
-
-#define kFileOpenMode TEXT("r")
-
-extern int g_CodePage;
-
-CStdInStream g_StdIn(stdin);
-
-bool CStdInStream::Open(LPCTSTR fileName) throw()
-{
- Close();
- _stream = _tfopen(fileName, kFileOpenMode);
- _streamIsOpen = (_stream != 0);
- return _streamIsOpen;
-}
-
-bool CStdInStream::Close() throw()
-{
- if (!_streamIsOpen)
- return true;
- _streamIsOpen = (fclose(_stream) != 0);
- return !_streamIsOpen;
-}
-
-bool CStdInStream::ScanAStringUntilNewLine(AString &s)
-{
- s.Empty();
- for (;;)
- {
- int intChar = GetChar();
- if (intChar == EOF)
- return true;
- char c = (char)intChar;
- if (c == 0)
- return false;
- if (c == '\n')
- return true;
- s += c;
- }
-}
-
-bool CStdInStream::ScanUStringUntilNewLine(UString &dest)
-{
- dest.Empty();
- AString s;
- bool res = ScanAStringUntilNewLine(s);
- int codePage = g_CodePage;
- if (codePage == -1)
- codePage = CP_OEMCP;
- if (codePage == CP_UTF8)
- ConvertUTF8ToUnicode(s, dest);
- else
- MultiByteToUnicodeString2(dest, s, (UINT)codePage);
- return res;
-}
-
-/*
-bool CStdInStream::ReadToString(AString &resultString)
-{
- resultString.Empty();
- for (;;)
- {
- int intChar = GetChar();
- if (intChar == EOF)
- return !Error();
- char c = (char)intChar;
- if (c == 0)
- return false;
- resultString += c;
- }
-}
-*/
-
-int CStdInStream::GetChar()
-{
- return fgetc(_stream); // getc() doesn't work in BeOS?
-}
+// Common/StdInStream.cpp
+
+#include "StdAfx.h"
+
+#ifdef _WIN32
+#include <tchar.h>
+#endif
+
+#include "StdInStream.h"
+#include "StringConvert.h"
+#include "UTFConvert.h"
+
+// #define kEOFMessage "Unexpected end of input stream"
+// #define kReadErrorMessage "Error reading input stream"
+// #define kIllegalCharMessage "Illegal zero character in input stream"
+
+
+CStdInStream g_StdIn(stdin);
+
+/*
+#define kFileOpenMode TEXT("r")
+
+bool CStdInStream::Open(LPCTSTR fileName) throw()
+{
+ Close();
+ _stream =
+ #ifdef _WIN32
+ _tfopen
+ #else
+ fopen
+ #endif
+ (fileName, kFileOpenMode);
+ _streamIsOpen = (_stream != 0);
+ return _streamIsOpen;
+}
+
+bool CStdInStream::Close() throw()
+{
+ if (!_streamIsOpen)
+ return true;
+ _streamIsOpen = (fclose(_stream) != 0);
+ return !_streamIsOpen;
+}
+*/
+
+bool CStdInStream::ScanAStringUntilNewLine(AString &s)
+{
+ s.Empty();
+ for (;;)
+ {
+ int intChar = GetChar();
+ if (intChar == EOF)
+ return true;
+ char c = (char)intChar;
+ if (c == 0)
+ return false;
+ if (c == '\n')
+ return true;
+ s += c;
+ }
+}
+
+bool CStdInStream::ScanUStringUntilNewLine(UString &dest)
+{
+ dest.Empty();
+ AString s;
+ bool res = ScanAStringUntilNewLine(s);
+ int codePage = CodePage;
+ if (codePage == -1)
+ codePage = CP_OEMCP;
+ if (codePage == CP_UTF8)
+ ConvertUTF8ToUnicode(s, dest);
+ else
+ MultiByteToUnicodeString2(dest, s, (UINT)codePage);
+ return res;
+}
+
+/*
+bool CStdInStream::ReadToString(AString &resultString)
+{
+ resultString.Empty();
+ for (;;)
+ {
+ int intChar = GetChar();
+ if (intChar == EOF)
+ return !Error();
+ char c = (char)intChar;
+ if (c == 0)
+ return false;
+ resultString += c;
+ }
+}
+*/
+
+int CStdInStream::GetChar()
+{
+ return fgetc(_stream); // getc() doesn't work in BeOS?
+}
diff --git a/CPP/Common/StdInStream.h b/CPP/Common/StdInStream.h
index 20f9ce3..81ca3bf 100644
--- a/CPP/Common/StdInStream.h
+++ b/CPP/Common/StdInStream.h
@@ -1,38 +1,46 @@
-// Common/StdInStream.h
-
-#ifndef __COMMON_STD_IN_STREAM_H
-#define __COMMON_STD_IN_STREAM_H
-
-#include <stdio.h>
-
-#include "MyString.h"
-#include "MyTypes.h"
-
-class CStdInStream
-{
- FILE *_stream;
- bool _streamIsOpen;
-public:
- CStdInStream(): _stream(0), _streamIsOpen(false) {};
- CStdInStream(FILE *stream): _stream(stream), _streamIsOpen(false) {};
- ~CStdInStream() { Close(); }
-
- bool Open(LPCTSTR fileName) throw();
- bool Close() throw();
-
- // returns:
- // false, if ZERO character in stream
- // true, if EOF or '\n'
- bool ScanAStringUntilNewLine(AString &s);
- bool ScanUStringUntilNewLine(UString &s);
- // bool ReadToString(AString &resultString);
-
- bool Eof() const throw() { return (feof(_stream) != 0); }
- bool Error() const throw() { return (ferror(_stream) != 0); }
-
- int GetChar();
-};
-
-extern CStdInStream g_StdIn;
-
-#endif
+// Common/StdInStream.h
+
+#ifndef ZIP7_INC_COMMON_STD_IN_STREAM_H
+#define ZIP7_INC_COMMON_STD_IN_STREAM_H
+
+#include <stdio.h>
+
+#include "MyString.h"
+#include "MyTypes.h"
+
+class CStdInStream
+{
+ FILE *_stream;
+ // bool _streamIsOpen;
+public:
+ int CodePage;
+
+ CStdInStream(FILE *stream = NULL):
+ _stream(stream),
+ // _streamIsOpen(false),
+ CodePage(-1)
+ {}
+
+ /*
+ ~CStdInStream() { Close(); }
+
+ bool Open(LPCTSTR fileName) throw();
+ bool Close() throw();
+ */
+
+ // returns:
+ // false, if ZERO character in stream
+ // true, if EOF or '\n'
+ bool ScanAStringUntilNewLine(AString &s);
+ bool ScanUStringUntilNewLine(UString &s);
+ // bool ReadToString(AString &resultString);
+
+ bool Eof() const throw() { return (feof(_stream) != 0); }
+ bool Error() const throw() { return (ferror(_stream) != 0); }
+
+ int GetChar();
+};
+
+extern CStdInStream g_StdIn;
+
+#endif
diff --git a/CPP/Common/StdOutStream.cpp b/CPP/Common/StdOutStream.cpp
index dc6d4bd..cfa5fde 100644
--- a/CPP/Common/StdOutStream.cpp
+++ b/CPP/Common/StdOutStream.cpp
@@ -1,163 +1,160 @@
-// Common/StdOutStream.cpp
-
-#include "StdAfx.h"
-
-#include <tchar.h>
-
-#include "IntToString.h"
-#include "StdOutStream.h"
-#include "StringConvert.h"
-#include "UTFConvert.h"
-
-#define kFileOpenMode "wt"
-
-extern int g_CodePage;
-
-CStdOutStream g_StdOut(stdout);
-CStdOutStream g_StdErr(stderr);
-
-bool CStdOutStream::Open(const char *fileName) throw()
-{
- Close();
- _stream = fopen(fileName, kFileOpenMode);
- _streamIsOpen = (_stream != 0);
- return _streamIsOpen;
-}
-
-bool CStdOutStream::Close() throw()
-{
- if (!_streamIsOpen)
- return true;
- if (fclose(_stream) != 0)
- return false;
- _stream = 0;
- _streamIsOpen = false;
- return true;
-}
-
-bool CStdOutStream::Flush() throw()
-{
- return (fflush(_stream) == 0);
-}
-
-CStdOutStream & endl(CStdOutStream & outStream) throw()
-{
- return outStream << '\n';
-}
-
-CStdOutStream & CStdOutStream::operator<<(const wchar_t *s)
-{
- int codePage = g_CodePage;
- if (codePage == -1)
- codePage = CP_OEMCP;
- AString dest;
- if (codePage == CP_UTF8)
- ConvertUnicodeToUTF8(s, dest);
- else
- UnicodeStringToMultiByte2(dest, s, (UINT)codePage);
- return operator<<((const char *)dest);
-}
-
-void StdOut_Convert_UString_to_AString(const UString &s, AString &temp)
-{
- int codePage = g_CodePage;
- if (codePage == -1)
- codePage = CP_OEMCP;
- if (codePage == CP_UTF8)
- ConvertUnicodeToUTF8(s, temp);
- else
- UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
-}
-
-void CStdOutStream::PrintUString(const UString &s, AString &temp)
-{
- StdOut_Convert_UString_to_AString(s, temp);
- *this << (const char *)temp;
-}
-
-
-static const wchar_t kReplaceChar = '_';
-
-void CStdOutStream::Normalize_UString__LF_Allowed(UString &s)
-{
- unsigned len = s.Len();
- wchar_t *d = s.GetBuf();
-
- if (IsTerminalMode)
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = d[i];
- if (c <= 13 && c >= 7 && c != '\n')
- d[i] = kReplaceChar;
- }
-}
-
-void CStdOutStream::Normalize_UString(UString &s)
-{
- unsigned len = s.Len();
- wchar_t *d = s.GetBuf();
-
- if (IsTerminalMode)
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = d[i];
- if (c <= 13 && c >= 7)
- d[i] = kReplaceChar;
- }
- else
- for (unsigned i = 0; i < len; i++)
- {
- wchar_t c = d[i];
- if (c == '\n')
- d[i] = kReplaceChar;
- }
-}
-
-void CStdOutStream::NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA)
-{
- tempU = s;
- Normalize_UString(tempU);
- PrintUString(tempU, tempA);
-}
-
-void CStdOutStream::NormalizePrint_UString(const UString &s)
-{
- NormalizePrint_wstr(s);
-}
-
-void CStdOutStream::NormalizePrint_wstr(const wchar_t *s)
-{
- UString tempU = s;
- Normalize_UString(tempU);
- AString tempA;
- PrintUString(tempU, tempA);
-}
-
-
-CStdOutStream & CStdOutStream::operator<<(Int32 number) throw()
-{
- char s[32];
- ConvertInt64ToString(number, s);
- return operator<<(s);
-}
-
-CStdOutStream & CStdOutStream::operator<<(Int64 number) throw()
-{
- char s[32];
- ConvertInt64ToString(number, s);
- return operator<<(s);
-}
-
-CStdOutStream & CStdOutStream::operator<<(UInt32 number) throw()
-{
- char s[16];
- ConvertUInt32ToString(number, s);
- return operator<<(s);
-}
-
-CStdOutStream & CStdOutStream::operator<<(UInt64 number) throw()
-{
- char s[32];
- ConvertUInt64ToString(number, s);
- return operator<<(s);
-}
+// Common/StdOutStream.cpp
+
+#include "StdAfx.h"
+
+#ifdef _WIN32
+#include <tchar.h>
+#endif
+
+#include "IntToString.h"
+#include "StdOutStream.h"
+#include "StringConvert.h"
+#include "UTFConvert.h"
+
+CStdOutStream g_StdOut(stdout);
+CStdOutStream g_StdErr(stderr);
+
+/*
+// #define kFileOpenMode "wt"
+
+bool CStdOutStream::Open(const char *fileName) throw()
+{
+ Close();
+ _stream = fopen(fileName, kFileOpenMode);
+ _streamIsOpen = (_stream != 0);
+ return _streamIsOpen;
+}
+
+bool CStdOutStream::Close() throw()
+{
+ if (!_streamIsOpen)
+ return true;
+ if (fclose(_stream) != 0)
+ return false;
+ _stream = 0;
+ _streamIsOpen = false;
+ return true;
+}
+*/
+
+bool CStdOutStream::Flush() throw()
+{
+ return (fflush(_stream) == 0);
+}
+
+CStdOutStream & endl(CStdOutStream & outStream) throw()
+{
+ return outStream << '\n';
+}
+
+CStdOutStream & CStdOutStream::operator<<(const wchar_t *s)
+{
+ AString temp;
+ UString s2(s);
+ PrintUString(s2, temp);
+ return *this;
+}
+
+void CStdOutStream::PrintUString(const UString &s, AString &temp)
+{
+ Convert_UString_to_AString(s, temp);
+ *this << (const char *)temp;
+}
+
+void CStdOutStream::Convert_UString_to_AString(const UString &src, AString &dest)
+{
+ int codePage = CodePage;
+ if (codePage == -1)
+ codePage = CP_OEMCP;
+ if (codePage == CP_UTF8)
+ ConvertUnicodeToUTF8(src, dest);
+ else
+ UnicodeStringToMultiByte2(dest, src, (UINT)codePage);
+}
+
+
+static const wchar_t kReplaceChar = '_';
+
+void CStdOutStream::Normalize_UString_LF_Allowed(UString &s)
+{
+ unsigned len = s.Len();
+ wchar_t *d = s.GetBuf();
+
+ if (IsTerminalMode)
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = d[i];
+ if (c <= 13 && c >= 7 && c != '\n')
+ d[i] = kReplaceChar;
+ }
+}
+
+void CStdOutStream::Normalize_UString(UString &s)
+{
+ unsigned len = s.Len();
+ wchar_t *d = s.GetBuf();
+
+ if (IsTerminalMode)
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = d[i];
+ if (c <= 13 && c >= 7)
+ d[i] = kReplaceChar;
+ }
+ else
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = d[i];
+ if (c == '\n')
+ d[i] = kReplaceChar;
+ }
+}
+
+void CStdOutStream::NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA)
+{
+ tempU = s;
+ Normalize_UString(tempU);
+ PrintUString(tempU, tempA);
+}
+
+void CStdOutStream::NormalizePrint_UString(const UString &s)
+{
+ NormalizePrint_wstr(s);
+}
+
+void CStdOutStream::NormalizePrint_wstr(const wchar_t *s)
+{
+ UString tempU = s;
+ Normalize_UString(tempU);
+ AString tempA;
+ PrintUString(tempU, tempA);
+}
+
+
+CStdOutStream & CStdOutStream::operator<<(Int32 number) throw()
+{
+ char s[32];
+ ConvertInt64ToString(number, s);
+ return operator<<(s);
+}
+
+CStdOutStream & CStdOutStream::operator<<(Int64 number) throw()
+{
+ char s[32];
+ ConvertInt64ToString(number, s);
+ return operator<<(s);
+}
+
+CStdOutStream & CStdOutStream::operator<<(UInt32 number) throw()
+{
+ char s[16];
+ ConvertUInt32ToString(number, s);
+ return operator<<(s);
+}
+
+CStdOutStream & CStdOutStream::operator<<(UInt64 number) throw()
+{
+ char s[32];
+ ConvertUInt64ToString(number, s);
+ return operator<<(s);
+}
diff --git a/CPP/Common/StdOutStream.h b/CPP/Common/StdOutStream.h
index 475954c..bd15d7c 100644
--- a/CPP/Common/StdOutStream.h
+++ b/CPP/Common/StdOutStream.h
@@ -1,71 +1,78 @@
-// Common/StdOutStream.h
-
-#ifndef __COMMON_STD_OUT_STREAM_H
-#define __COMMON_STD_OUT_STREAM_H
-
-#include <stdio.h>
-
-#include "MyString.h"
-#include "MyTypes.h"
-
-class CStdOutStream
-{
- FILE *_stream;
- bool _streamIsOpen;
-public:
- bool IsTerminalMode;
-
- CStdOutStream(): _stream(0), _streamIsOpen(false), IsTerminalMode(false) {};
- CStdOutStream(FILE *stream): _stream(stream), _streamIsOpen(false) {};
- ~CStdOutStream() { Close(); }
-
- // void AttachStdStream(FILE *stream) { _stream = stream; _streamIsOpen = false; }
- // bool IsDefined() const { return _stream != NULL; }
-
- operator FILE *() { return _stream; }
- bool Open(const char *fileName) throw();
- bool Close() throw();
- bool Flush() throw();
-
- CStdOutStream & operator<<(CStdOutStream & (* func)(CStdOutStream &))
- {
- (*func)(*this);
- return *this;
- }
-
- CStdOutStream & operator<<(const char *s) throw()
- {
- fputs(s, _stream);
- return *this;
- }
-
- CStdOutStream & operator<<(char c) throw()
- {
- fputc((unsigned char)c, _stream);
- return *this;
- }
-
- CStdOutStream & operator<<(Int32 number) throw();
- CStdOutStream & operator<<(Int64 number) throw();
- CStdOutStream & operator<<(UInt32 number) throw();
- CStdOutStream & operator<<(UInt64 number) throw();
-
- CStdOutStream & operator<<(const wchar_t *s);
- void PrintUString(const UString &s, AString &temp);
-
- void Normalize_UString__LF_Allowed(UString &s);
- void Normalize_UString(UString &s);
-
- void NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA);
- void NormalizePrint_UString(const UString &s);
- void NormalizePrint_wstr(const wchar_t *s);
-};
-
-CStdOutStream & endl(CStdOutStream & outStream) throw();
-
-extern CStdOutStream g_StdOut;
-extern CStdOutStream g_StdErr;
-
-void StdOut_Convert_UString_to_AString(const UString &s, AString &temp);
-
-#endif
+// Common/StdOutStream.h
+
+#ifndef ZIP7_INC_COMMON_STD_OUT_STREAM_H
+#define ZIP7_INC_COMMON_STD_OUT_STREAM_H
+
+#include <stdio.h>
+
+#include "MyString.h"
+#include "MyTypes.h"
+
+class CStdOutStream
+{
+ FILE *_stream;
+ // bool _streamIsOpen;
+public:
+ bool IsTerminalMode;
+ int CodePage;
+
+ CStdOutStream(FILE *stream = NULL):
+ _stream(stream),
+ // _streamIsOpen(false),
+ IsTerminalMode(false),
+ CodePage(-1)
+ {}
+
+ // ~CStdOutStream() { Close(); }
+
+ // void AttachStdStream(FILE *stream) { _stream = stream; _streamIsOpen = false; }
+ // bool IsDefined() const { return _stream != NULL; }
+
+ operator FILE *() { return _stream; }
+ /*
+ bool Open(const char *fileName) throw();
+ bool Close() throw();
+ */
+ bool Flush() throw();
+
+ CStdOutStream & operator<<(CStdOutStream & (* func)(CStdOutStream &))
+ {
+ (*func)(*this);
+ return *this;
+ }
+
+ CStdOutStream & operator<<(const char *s) throw()
+ {
+ fputs(s, _stream);
+ return *this;
+ }
+
+ CStdOutStream & operator<<(char c) throw()
+ {
+ fputc((unsigned char)c, _stream);
+ return *this;
+ }
+
+ CStdOutStream & operator<<(Int32 number) throw();
+ CStdOutStream & operator<<(Int64 number) throw();
+ CStdOutStream & operator<<(UInt32 number) throw();
+ CStdOutStream & operator<<(UInt64 number) throw();
+
+ CStdOutStream & operator<<(const wchar_t *s);
+ void PrintUString(const UString &s, AString &temp);
+ void Convert_UString_to_AString(const UString &src, AString &dest);
+
+ void Normalize_UString_LF_Allowed(UString &s);
+ void Normalize_UString(UString &s);
+
+ void NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA);
+ void NormalizePrint_UString(const UString &s);
+ void NormalizePrint_wstr(const wchar_t *s);
+};
+
+CStdOutStream & endl(CStdOutStream & outStream) throw();
+
+extern CStdOutStream g_StdOut;
+extern CStdOutStream g_StdErr;
+
+#endif
diff --git a/CPP/Common/StringConvert.cpp b/CPP/Common/StringConvert.cpp
index b8f33cd..f25396a 100644
--- a/CPP/Common/StringConvert.cpp
+++ b/CPP/Common/StringConvert.cpp
@@ -1,319 +1,756 @@
-// Common/StringConvert.cpp
-
-#include "StdAfx.h"
-
-#include "StringConvert.h"
-
-#ifndef _WIN32
-#include <stdlib.h>
-#endif
-
-static const char k_DefultChar = '_';
-
-#ifdef _WIN32
-
-/*
-MultiByteToWideChar(CodePage, DWORD dwFlags,
- LPCSTR lpMultiByteStr, int cbMultiByte,
- LPWSTR lpWideCharStr, int cchWideChar)
-
- if (cbMultiByte == 0)
- return: 0. ERR: ERROR_INVALID_PARAMETER
-
- if (cchWideChar == 0)
- return: the required buffer size in characters.
-
- if (supplied buffer size was not large enough)
- return: 0. ERR: ERROR_INSUFFICIENT_BUFFER
- The number of filled characters in lpWideCharStr can be smaller than cchWideChar (if last character is complex)
-
- If there are illegal characters:
- if MB_ERR_INVALID_CHARS is set in dwFlags:
- - the function stops conversion on illegal character.
- - Return: 0. ERR: ERROR_NO_UNICODE_TRANSLATION.
-
- if MB_ERR_INVALID_CHARS is NOT set in dwFlags:
- before Vista: illegal character is dropped (skipped). WinXP-64: GetLastError() returns 0.
- in Vista+: illegal character is not dropped (MSDN). Undocumented: illegal
- character is converted to U+FFFD, which is REPLACEMENT CHARACTER.
-*/
-
-
-void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT codePage)
-{
- dest.Empty();
- if (src.IsEmpty())
- return;
- {
- /*
- wchar_t *d = dest.GetBuf(src.Len());
- const char *s = (const char *)src;
- unsigned i;
-
- for (i = 0;;)
- {
- Byte c = (Byte)s[i];
- if (c >= 0x80 || c == 0)
- break;
- d[i++] = (wchar_t)c;
- }
-
- if (i != src.Len())
- {
- unsigned len = MultiByteToWideChar(codePage, 0, s + i,
- src.Len() - i, d + i,
- src.Len() + 1 - i);
- if (len == 0)
- throw 282228;
- i += len;
- }
-
- d[i] = 0;
- dest.ReleaseBuf_SetLen(i);
- */
- unsigned len = MultiByteToWideChar(codePage, 0, src, src.Len(), NULL, 0);
- if (len == 0)
- {
- if (GetLastError() != 0)
- throw 282228;
- }
- else
- {
- len = MultiByteToWideChar(codePage, 0, src, src.Len(), dest.GetBuf(len), len);
- if (len == 0)
- throw 282228;
- dest.ReleaseBuf_SetEnd(len);
- }
- }
-}
-
-/*
- int WideCharToMultiByte(
- UINT CodePage, DWORD dwFlags,
- LPCWSTR lpWideCharStr, int cchWideChar,
- LPSTR lpMultiByteStr, int cbMultiByte,
- LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar);
-
-if (lpDefaultChar == NULL),
- - it uses system default value.
-
-if (CodePage == CP_UTF7 || CodePage == CP_UTF8)
- if (lpDefaultChar != NULL || lpUsedDefaultChar != NULL)
- return: 0. ERR: ERROR_INVALID_PARAMETER.
-
-The function operates most efficiently, if (lpDefaultChar == NULL && lpUsedDefaultChar == NULL)
-
-*/
-
-static void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
-{
- dest.Empty();
- defaultCharWasUsed = false;
- if (src.IsEmpty())
- return;
- {
- /*
- unsigned numRequiredBytes = src.Len() * 2;
- char *d = dest.GetBuf(numRequiredBytes);
- const wchar_t *s = (const wchar_t *)src;
- unsigned i;
-
- for (i = 0;;)
- {
- wchar_t c = s[i];
- if (c >= 0x80 || c == 0)
- break;
- d[i++] = (char)c;
- }
-
- if (i != src.Len())
- {
- BOOL defUsed = FALSE;
- defaultChar = defaultChar;
-
- bool isUtf = (codePage == CP_UTF8 || codePage == CP_UTF7);
- unsigned len = WideCharToMultiByte(codePage, 0, s + i, src.Len() - i,
- d + i, numRequiredBytes + 1 - i,
- (isUtf ? NULL : &defaultChar),
- (isUtf ? NULL : &defUsed));
- defaultCharWasUsed = (defUsed != FALSE);
- if (len == 0)
- throw 282229;
- i += len;
- }
-
- d[i] = 0;
- dest.ReleaseBuf_SetLen(i);
- */
-
- /*
- if (codePage != CP_UTF7)
- {
- const wchar_t *s = (const wchar_t *)src;
- unsigned i;
- for (i = 0;; i++)
- {
- wchar_t c = s[i];
- if (c >= 0x80 || c == 0)
- break;
- }
-
- if (s[i] == 0)
- {
- char *d = dest.GetBuf(src.Len());
- for (i = 0;;)
- {
- wchar_t c = s[i];
- if (c == 0)
- break;
- d[i++] = (char)c;
- }
- d[i] = 0;
- dest.ReleaseBuf_SetLen(i);
- return;
- }
- }
- */
-
- unsigned len = WideCharToMultiByte(codePage, 0, src, src.Len(), NULL, 0, NULL, NULL);
- if (len == 0)
- {
- if (GetLastError() != 0)
- throw 282228;
- }
- else
- {
- BOOL defUsed = FALSE;
- bool isUtf = (codePage == CP_UTF8 || codePage == CP_UTF7);
- // defaultChar = defaultChar;
- len = WideCharToMultiByte(codePage, 0, src, src.Len(),
- dest.GetBuf(len), len,
- (isUtf ? NULL : &defaultChar),
- (isUtf ? NULL : &defUsed)
- );
- if (!isUtf)
- defaultCharWasUsed = (defUsed != FALSE);
- if (len == 0)
- throw 282228;
- dest.ReleaseBuf_SetEnd(len);
- }
- }
-}
-
-/*
-#ifndef UNDER_CE
-AString SystemStringToOemString(const CSysString &src)
-{
- AString dest;
- const unsigned len = src.Len() * 2;
- CharToOem(src, dest.GetBuf(len));
- dest.ReleaseBuf_CalcLen(len);
- return dest;
-}
-#endif
-*/
-
-#else
-
-void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT /* codePage */)
-{
- dest.Empty();
- if (src.IsEmpty())
- return;
-
- size_t limit = ((size_t)src.Len() + 1) * 2;
- wchar_t *d = dest.GetBuf((unsigned)limit);
- size_t len = mbstowcs(d, src, limit);
- if (len != (size_t)-1)
- {
- dest.ReleaseBuf_SetEnd((unsigned)len);
- return;
- }
-
- {
- unsigned i;
- const char *s = (const char *)src;
- for (i = 0;;)
- {
- Byte c = (Byte)s[i];
- if (c == 0)
- break;
- d[i++] = (wchar_t)c;
- }
- d[i] = 0;
- dest.ReleaseBuf_SetLen(i);
- }
-}
-
-static void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT /* codePage */, char defaultChar, bool &defaultCharWasUsed)
-{
- dest.Empty();
- defaultCharWasUsed = false;
- if (src.IsEmpty())
- return;
-
- size_t limit = ((size_t)src.Len() + 1) * 6;
- char *d = dest.GetBuf((unsigned)limit);
- size_t len = wcstombs(d, src, limit);
- if (len != (size_t)-1)
- {
- dest.ReleaseBuf_SetEnd((unsigned)len);
- return;
- }
-
- {
- const wchar_t *s = (const wchar_t *)src;
- unsigned i;
- for (i = 0;;)
- {
- wchar_t c = s[i];
- if (c == 0)
- break;
- if (c >= 0x100)
- {
- c = defaultChar;
- defaultCharWasUsed = true;
- }
- d[i++] = (char)c;
- }
- d[i] = 0;
- dest.ReleaseBuf_SetLen(i);
- }
-}
-
-#endif
-
-
-UString MultiByteToUnicodeString(const AString &src, UINT codePage)
-{
- UString dest;
- MultiByteToUnicodeString2(dest, src, codePage);
- return dest;
-}
-
-UString MultiByteToUnicodeString(const char *src, UINT codePage)
-{
- return MultiByteToUnicodeString(AString(src), codePage);
-}
-
-
-void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage)
-{
- bool defaultCharWasUsed;
- UnicodeStringToMultiByte2(dest, src, codePage, k_DefultChar, defaultCharWasUsed);
-}
-
-AString UnicodeStringToMultiByte(const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
-{
- AString dest;
- UnicodeStringToMultiByte2(dest, src, codePage, defaultChar, defaultCharWasUsed);
- return dest;
-}
-
-AString UnicodeStringToMultiByte(const UString &src, UINT codePage)
-{
- AString dest;
- bool defaultCharWasUsed;
- UnicodeStringToMultiByte2(dest, src, codePage, k_DefultChar, defaultCharWasUsed);
- return dest;
-}
+// Common/StringConvert.cpp
+
+#include "StdAfx.h"
+
+#include "StringConvert.h"
+
+#ifndef _WIN32
+// #include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#if !defined(_WIN32) || defined(ENV_HAVE_LOCALE)
+#include "UTFConvert.h"
+#endif
+
+#ifdef ENV_HAVE_LOCALE
+#include <locale.h>
+#endif
+
+static const char k_DefultChar = '_';
+
+#ifdef _WIN32
+
+/*
+MultiByteToWideChar(CodePage, DWORD dwFlags,
+ LPCSTR lpMultiByteStr, int cbMultiByte,
+ LPWSTR lpWideCharStr, int cchWideChar)
+
+ if (cbMultiByte == 0)
+ return: 0. ERR: ERROR_INVALID_PARAMETER
+
+ if (cchWideChar == 0)
+ return: the required buffer size in characters.
+
+ if (supplied buffer size was not large enough)
+ return: 0. ERR: ERROR_INSUFFICIENT_BUFFER
+ The number of filled characters in lpWideCharStr can be smaller than cchWideChar (if last character is complex)
+
+ If there are illegal characters:
+ if MB_ERR_INVALID_CHARS is set in dwFlags:
+ - the function stops conversion on illegal character.
+ - Return: 0. ERR: ERROR_NO_UNICODE_TRANSLATION.
+
+ if MB_ERR_INVALID_CHARS is NOT set in dwFlags:
+ before Vista: illegal character is dropped (skipped). WinXP-64: GetLastError() returns 0.
+ in Vista+: illegal character is not dropped (MSDN). Undocumented: illegal
+ character is converted to U+FFFD, which is REPLACEMENT CHARACTER.
+*/
+
+
+void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT codePage)
+{
+ dest.Empty();
+ if (src.IsEmpty())
+ return;
+ {
+ /*
+ wchar_t *d = dest.GetBuf(src.Len());
+ const char *s = (const char *)src;
+ unsigned i;
+
+ for (i = 0;;)
+ {
+ Byte c = (Byte)s[i];
+ if (c >= 0x80 || c == 0)
+ break;
+ d[i++] = (wchar_t)c;
+ }
+
+ if (i != src.Len())
+ {
+ unsigned len = MultiByteToWideChar(codePage, 0, s + i,
+ src.Len() - i, d + i,
+ src.Len() + 1 - i);
+ if (len == 0)
+ throw 282228;
+ i += len;
+ }
+
+ d[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+ */
+ unsigned len = (unsigned)MultiByteToWideChar(codePage, 0, src, (int)src.Len(), NULL, 0);
+ if (len == 0)
+ {
+ if (GetLastError() != 0)
+ throw 282228;
+ }
+ else
+ {
+ len = (unsigned)MultiByteToWideChar(codePage, 0, src, (int)src.Len(), dest.GetBuf(len), (int)len);
+ if (len == 0)
+ throw 282228;
+ dest.ReleaseBuf_SetEnd(len);
+ }
+ }
+}
+
+/*
+ int WideCharToMultiByte(
+ UINT CodePage, DWORD dwFlags,
+ LPCWSTR lpWideCharStr, int cchWideChar,
+ LPSTR lpMultiByteStr, int cbMultiByte,
+ LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar);
+
+if (lpDefaultChar == NULL),
+ - it uses system default value.
+
+if (CodePage == CP_UTF7 || CodePage == CP_UTF8)
+ if (lpDefaultChar != NULL || lpUsedDefaultChar != NULL)
+ return: 0. ERR: ERROR_INVALID_PARAMETER.
+
+The function operates most efficiently, if (lpDefaultChar == NULL && lpUsedDefaultChar == NULL)
+
+*/
+
+static void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
+{
+ dest.Empty();
+ defaultCharWasUsed = false;
+ if (src.IsEmpty())
+ return;
+ {
+ /*
+ unsigned numRequiredBytes = src.Len() * 2;
+ char *d = dest.GetBuf(numRequiredBytes);
+ const wchar_t *s = (const wchar_t *)src;
+ unsigned i;
+
+ for (i = 0;;)
+ {
+ wchar_t c = s[i];
+ if (c >= 0x80 || c == 0)
+ break;
+ d[i++] = (char)c;
+ }
+
+ if (i != src.Len())
+ {
+ BOOL defUsed = FALSE;
+ defaultChar = defaultChar;
+
+ bool isUtf = (codePage == CP_UTF8 || codePage == CP_UTF7);
+ unsigned len = WideCharToMultiByte(codePage, 0, s + i, src.Len() - i,
+ d + i, numRequiredBytes + 1 - i,
+ (isUtf ? NULL : &defaultChar),
+ (isUtf ? NULL : &defUsed));
+ defaultCharWasUsed = (defUsed != FALSE);
+ if (len == 0)
+ throw 282229;
+ i += len;
+ }
+
+ d[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+ */
+
+ /*
+ if (codePage != CP_UTF7)
+ {
+ const wchar_t *s = (const wchar_t *)src;
+ unsigned i;
+ for (i = 0;; i++)
+ {
+ wchar_t c = s[i];
+ if (c >= 0x80 || c == 0)
+ break;
+ }
+
+ if (s[i] == 0)
+ {
+ char *d = dest.GetBuf(src.Len());
+ for (i = 0;;)
+ {
+ wchar_t c = s[i];
+ if (c == 0)
+ break;
+ d[i++] = (char)c;
+ }
+ d[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+ return;
+ }
+ }
+ */
+
+ unsigned len = (unsigned)WideCharToMultiByte(codePage, 0, src, (int)src.Len(), NULL, 0, NULL, NULL);
+ if (len == 0)
+ {
+ if (GetLastError() != 0)
+ throw 282228;
+ }
+ else
+ {
+ BOOL defUsed = FALSE;
+ bool isUtf = (codePage == CP_UTF8 || codePage == CP_UTF7);
+ // defaultChar = defaultChar;
+ len = (unsigned)WideCharToMultiByte(codePage, 0, src, (int)src.Len(),
+ dest.GetBuf(len), (int)len,
+ (isUtf ? NULL : &defaultChar),
+ (isUtf ? NULL : &defUsed)
+ );
+ if (!isUtf)
+ defaultCharWasUsed = (defUsed != FALSE);
+ if (len == 0)
+ throw 282228;
+ dest.ReleaseBuf_SetEnd(len);
+ }
+ }
+}
+
+/*
+#ifndef UNDER_CE
+AString SystemStringToOemString(const CSysString &src)
+{
+ AString dest;
+ const unsigned len = src.Len() * 2;
+ CharToOem(src, dest.GetBuf(len));
+ dest.ReleaseBuf_CalcLen(len);
+ return dest;
+}
+#endif
+*/
+
+#else // _WIN32
+
+// #include <stdio.h>
+/*
+ if (wchar_t is 32-bit (#if WCHAR_MAX > 0xffff),
+ and utf-8 string contains big unicode character > 0xffff),
+ then we still use 16-bit surrogate pair in UString.
+ It simplifies another code where utf-16 encoding is used.
+ So we use surrogate-conversion code only in is file.
+*/
+
+/*
+ mbstowcs() returns error if there is error in utf-8 stream,
+ mbstowcs() returns error if there is single surrogates point (d800-dfff) in utf-8 stream
+*/
+
+/*
+static void MultiByteToUnicodeString2_Native(UString &dest, const AString &src)
+{
+ dest.Empty();
+ if (src.IsEmpty())
+ return;
+
+ const size_t limit = ((size_t)src.Len() + 1) * 2;
+ wchar_t *d = dest.GetBuf((unsigned)limit);
+ const size_t len = mbstowcs(d, src, limit);
+ if (len != (size_t)-1)
+ {
+ dest.ReleaseBuf_SetEnd((unsigned)len);
+ return;
+ }
+ dest.ReleaseBuf_SetEnd(0);
+}
+*/
+
+bool g_ForceToUTF8 = true; // false;
+
+void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT codePage)
+{
+ dest.Empty();
+ if (src.IsEmpty())
+ return;
+
+ if (codePage == CP_UTF8 || g_ForceToUTF8)
+ {
+ ConvertUTF8ToUnicode(src, dest);
+ return;
+ }
+
+ const size_t limit = ((size_t)src.Len() + 1) * 2;
+ wchar_t *d = dest.GetBuf((unsigned)limit);
+ const size_t len = mbstowcs(d, src, limit);
+ if (len != (size_t)-1)
+ {
+ dest.ReleaseBuf_SetEnd((unsigned)len);
+
+ #if WCHAR_MAX > 0xffff
+ d = dest.GetBuf();
+ for (size_t i = 0;; i++)
+ {
+ // wchar_t c = dest[i];
+ wchar_t c = d[i];
+ if (c == 0)
+ break;
+ if (c >= 0x10000 && c < 0x110000)
+ {
+ /*
+ c -= 0x10000;
+ unsigned c0 = 0xd800 + ((c >> 10) & 0x3FF);
+ dest.ReplaceOneCharAtPos(i, c0);
+ i++;
+ c = 0xdc00 + (c & 0x3FF);
+ dest.Insert_wchar_t(i, c);
+ */
+ UString temp = d + i;
+
+ for (size_t t = 0;; t++)
+ {
+ wchar_t w = temp[t];
+ if (w == 0)
+ break;
+ if (i == limit)
+ break; // unexpected error
+ if (w >= 0x10000 && w < 0x110000)
+ {
+ if (i + 1 == limit)
+ break; // unexpected error
+ w -= 0x10000;
+ d[i++] = (unsigned)0xd800 + (((unsigned)w >> 10) & 0x3FF);
+ w = 0xdc00 + (w & 0x3FF);
+ }
+ d[i++] = w;
+ }
+ dest.ReleaseBuf_SetEnd((unsigned)i);
+ }
+ }
+
+ #endif
+
+ /*
+ printf("\nMultiByteToUnicodeString2 (%d) %s\n", (int)src.Len(), src.Ptr());
+ printf("char: ");
+ for (unsigned i = 0; i < src.Len(); i++)
+ printf (" %02x", (int)(Byte)src[i]);
+ printf("\n");
+ printf("\n-> (%d) %ls\n", (int)dest.Len(), dest.Ptr());
+ printf("wchar_t: ");
+ for (unsigned i = 0; i < dest.Len(); i++)
+ {
+ printf (" %02x", (int)dest[i]);
+ }
+ printf("\n");
+ */
+
+ return;
+ }
+
+ /* if there is mbstowcs() error, we have two ways:
+
+ 1) change 0x80+ characters to some character: '_'
+ in that case we lose data, but we have correct UString()
+ and that scheme can show errors to user in early stages,
+ when file converted back to mbs() cannot be found
+
+ 2) transfer bad characters in some UTF-16 range.
+ it can be non-original Unicode character.
+ but later we still can restore original character.
+ */
+
+
+ // printf("\nmbstowcs ERROR !!!!!! s=%s\n", src.Ptr());
+ {
+ unsigned i;
+ const char *s = (const char *)src;
+ for (i = 0;;)
+ {
+ Byte c = (Byte)s[i];
+ if (c == 0)
+ break;
+ // we can use ascii compatibilty character '_'
+ // if (c > 0x7F) c = '_'; // we replace "bad: character
+ d[i++] = (wchar_t)c;
+ }
+ d[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+ }
+}
+
+static void UnicodeStringToMultiByte2_Native(AString &dest, const UString &src)
+{
+ dest.Empty();
+ if (src.IsEmpty())
+ return;
+
+ const size_t limit = ((size_t)src.Len() + 1) * 6;
+ char *d = dest.GetBuf((unsigned)limit);
+
+ const size_t len = wcstombs(d, src, limit);
+
+ if (len != (size_t)-1)
+ {
+ dest.ReleaseBuf_SetEnd((unsigned)len);
+ return;
+ }
+ dest.ReleaseBuf_SetEnd(0);
+}
+
+
+static void UnicodeStringToMultiByte2(AString &dest, const UString &src2, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
+{
+ // if (codePage == 1234567) // for debug purposes
+ if (codePage == CP_UTF8 || g_ForceToUTF8)
+ {
+ defaultCharWasUsed = false;
+ ConvertUnicodeToUTF8(src2, dest);
+ return;
+ }
+
+ UString src = src2;
+ #if WCHAR_MAX > 0xffff
+ {
+ src.Empty();
+ for (unsigned i = 0; i < src2.Len();)
+ {
+ wchar_t c = src2[i];
+ if (c >= 0xd800 && c < 0xdc00 && i + 1 != src2.Len())
+ {
+ const wchar_t c2 = src2[i + 1];
+ if (c2 >= 0xdc00 && c2 < 0x10000)
+ {
+ // printf("\nSurragate [%d]: %4x %4x -> ", i, (int)c, (int)c2);
+ c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+ // printf("%4x\n", (int)c);
+ i++;
+ }
+ }
+ src += c;
+ i++;
+ }
+ }
+ #endif
+
+ dest.Empty();
+ defaultCharWasUsed = false;
+ if (src.IsEmpty())
+ return;
+
+ const size_t len = wcstombs(NULL, src, 0);
+
+ if (len != (size_t)-1)
+ {
+ const unsigned limit = ((unsigned)len);
+ if (limit == len)
+ {
+ char *d = dest.GetBuf(limit);
+
+ /*
+ {
+ printf("\nwcstombs; len = %d %ls \n", (int)src.Len(), src.Ptr());
+ for (unsigned i = 0; i < src.Len(); i++)
+ printf (" %02x", (int)src[i]);
+ printf("\n");
+ printf("\ndest Limit = %d \n", limit);
+ }
+ */
+
+ const size_t len2 = wcstombs(d, src, len + 1);
+
+ if (len2 != (size_t)-1 && len2 <= limit)
+ {
+ /*
+ printf("\nOK : destLen = %d : %s\n", (int)len, dest.Ptr());
+ for (unsigned i = 0; i < len2; i++)
+ printf(" %02x", (int)(Byte)dest[i]);
+ printf("\n");
+ */
+ dest.ReleaseBuf_SetEnd((unsigned)len2);
+ return;
+ }
+ }
+ }
+
+ {
+ const wchar_t *s = (const wchar_t *)src;
+ char *d = dest.GetBuf(src.Len());
+
+ unsigned i;
+ for (i = 0;;)
+ {
+ wchar_t c = s[i];
+ if (c == 0)
+ break;
+ if (c >=
+ 0x100
+ // 0x80
+ )
+ {
+ c = defaultChar;
+ defaultCharWasUsed = true;
+ }
+
+ d[i++] = (char)c;
+ }
+ d[i] = 0;
+ dest.ReleaseBuf_SetLen(i);
+ /*
+ printf("\nUnicodeStringToMultiByte2; len = %d \n", (int)src.Len());
+ printf("ERROR: %s\n", dest.Ptr());
+ */
+ }
+}
+
+#endif // _WIN32
+
+
+UString MultiByteToUnicodeString(const AString &src, UINT codePage)
+{
+ UString dest;
+ MultiByteToUnicodeString2(dest, src, codePage);
+ return dest;
+}
+
+UString MultiByteToUnicodeString(const char *src, UINT codePage)
+{
+ return MultiByteToUnicodeString(AString(src), codePage);
+}
+
+
+void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage)
+{
+ bool defaultCharWasUsed;
+ UnicodeStringToMultiByte2(dest, src, codePage, k_DefultChar, defaultCharWasUsed);
+}
+
+AString UnicodeStringToMultiByte(const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
+{
+ AString dest;
+ UnicodeStringToMultiByte2(dest, src, codePage, defaultChar, defaultCharWasUsed);
+ return dest;
+}
+
+AString UnicodeStringToMultiByte(const UString &src, UINT codePage)
+{
+ AString dest;
+ bool defaultCharWasUsed;
+ UnicodeStringToMultiByte2(dest, src, codePage, k_DefultChar, defaultCharWasUsed);
+ return dest;
+}
+
+
+
+
+#if !defined(_WIN32) || defined(ENV_HAVE_LOCALE)
+
+#ifdef _WIN32
+#define U_to_A(a, b, c) UnicodeStringToMultiByte2
+// #define A_to_U(a, b, c) MultiByteToUnicodeString2
+#else
+// void MultiByteToUnicodeString2_Native(UString &dest, const AString &src);
+#define U_to_A(a, b, c) UnicodeStringToMultiByte2_Native(a, b)
+// #define A_to_U(a, b, c) MultiByteToUnicodeString2_Native(a, b)
+#endif
+
+bool IsNativeUTF8()
+{
+ UString u;
+ AString a, a2;
+ // for (unsigned c = 0x80; c < (UInt32)0x10000; c += (c >> 9) + 1)
+ for (unsigned c = 0x80; c < (UInt32)0xD000; c += (c >> 2) + 1)
+ {
+ u.Empty();
+ u += (wchar_t)c;
+ /*
+ if (Unicode_Is_There_Utf16SurrogateError(u))
+ continue;
+ #ifndef _WIN32
+ if (Unicode_Is_There_BmpEscape(u))
+ continue;
+ #endif
+ */
+ ConvertUnicodeToUTF8(u, a);
+ U_to_A(a2, u, CP_OEMCP);
+ if (a != a2)
+ return false;
+ }
+ return true;
+}
+
+#endif
+
+
+#ifdef ENV_HAVE_LOCALE
+
+const char *GetLocale(void)
+{
+ #ifdef ENV_HAVE_LOCALE
+ // printf("\n\nsetlocale(LC_CTYPE, NULL) : return : ");
+ const char *s = setlocale(LC_CTYPE, NULL);
+ if (!s)
+ {
+ // printf("[NULL]\n");
+ s = "C";
+ }
+ else
+ {
+ // ubuntu returns "C" after program start
+ // printf("\"%s\"\n", s);
+ }
+ return s;
+ #elif defined(LOCALE_IS_UTF8)
+ return "utf8";
+ #else
+ return "C";
+ #endif
+}
+
+#ifdef _WIN32
+ static void Set_ForceToUTF8(bool) {}
+#else
+ static void Set_ForceToUTF8(bool val) { g_ForceToUTF8 = val; }
+#endif
+
+static bool Is_Default_Basic_Locale(const char *locale)
+{
+ const AString a (locale);
+ if (a.IsEqualTo_Ascii_NoCase("")
+ || a.IsEqualTo_Ascii_NoCase("C")
+ || a.IsEqualTo_Ascii_NoCase("POSIX"))
+ return true;
+ return false;
+}
+
+static bool Is_Default_Basic_Locale()
+{
+ return Is_Default_Basic_Locale(GetLocale());
+}
+
+
+void MY_SetLocale()
+{
+ #ifdef ENV_HAVE_LOCALE
+ /*
+ {
+ const char *s = GetLocale();
+ printf("\nGetLocale() : returned : \"%s\"\n", s);
+ }
+ */
+
+ unsigned start = 0;
+ // unsigned lim = 0;
+ unsigned lim = 3;
+
+ /*
+ #define MY_SET_LOCALE_FLAGS__FROM_ENV 1
+ #define MY_SET_LOCALE_FLAGS__TRY_UTF8 2
+
+ unsigned flags =
+ MY_SET_LOCALE_FLAGS__FROM_ENV |
+ MY_SET_LOCALE_FLAGS__TRY_UTF8
+
+ if (flags != 0)
+ {
+ if (flags & MY_SET_LOCALE_FLAGS__FROM_ENV)
+ lim = (flags & MY_SET_LOCALE_FLAGS__TRY_UTF8) ? 3 : 1;
+ else
+ {
+ start = 1;
+ lim = 2;
+ }
+ }
+ */
+
+ for (unsigned i = start; i < lim; i++)
+ {
+ /*
+ man7: "If locale is an empty string, "", each part of the locale that
+ should be modified is set according to the environment variables.
+ for glibc: glibc, first from the user's environment variables:
+ 1) the environment variable LC_ALL,
+ 2) environment variable with the same name as the category (see the
+ 3) the environment variable LANG
+ The locale "C" or "POSIX" is a portable locale; it exists on all conforming systems.
+
+ for WIN32 : MSDN :
+ Sets the locale to the default, which is the user-default
+ ANSI code page obtained from the operating system.
+ The locale name is set to the value returned by GetUserDefaultLocaleName.
+ The code page is set to the value returned by GetACP
+ */
+ const char *newLocale = "";
+
+ #ifdef __APPLE__
+
+ /* look also CFLocale
+ there is no C.UTF-8 in macos
+ macos has UTF-8 locale only with some language like en_US.UTF-8
+ what is best way to set UTF-8 locale in macos? */
+ if (i == 1)
+ newLocale = "en_US.UTF-8";
+
+ /* file open with non-utf8 sequencies return
+ #define EILSEQ 92 // "Illegal byte sequence"
+ */
+#else
+ // newLocale = "C";
+ if (i == 1)
+ {
+ newLocale = "C.UTF-8"; // main UTF-8 locale in ubuntu
+ // newLocale = ".utf8"; // supported in new Windows 10 build 17134 (April 2018 Update), the Universal C Runtime
+ // newLocale = "en_US.utf8"; // supported by ubuntu ?
+ // newLocale = "en_US.UTF-8";
+ /* setlocale() in ubuntu allows locales with minor chracter changes in strings
+ "en_US.UTF-8" / "en_US.utf8" */
+ }
+
+#endif
+
+ // printf("\nsetlocale(LC_ALL, \"%s\") : returned: ", newLocale);
+
+ // const char *s =
+ setlocale(LC_ALL, newLocale);
+
+ /*
+ if (!s)
+ printf("NULL: can't set locale");
+ else
+ printf("\"%s\"\n", s);
+ */
+
+ // request curent locale of program
+ const char *locale = GetLocale();
+ if (locale)
+ {
+ AString a (locale);
+ a.MakeLower_Ascii();
+ // if (a.Find("utf") >= 0)
+ {
+ if (IsNativeUTF8())
+ {
+ Set_ForceToUTF8(true);
+ return;
+ }
+ }
+ if (!Is_Default_Basic_Locale(locale))
+ {
+ // if there is some non-default and non-utf locale, we want to use it
+ break; // comment it for debug
+ }
+ }
+ }
+
+ if (IsNativeUTF8())
+ {
+ Set_ForceToUTF8(true);
+ return;
+ }
+
+ if (Is_Default_Basic_Locale())
+ {
+ Set_ForceToUTF8(true);
+ return;
+ }
+
+ Set_ForceToUTF8(false);
+
+ #elif defined(LOCALE_IS_UTF8)
+ // assume LC_CTYPE="utf8"
+ #else
+ // assume LC_CTYPE="C"
+ #endif
+}
+#endif
diff --git a/CPP/Common/StringConvert.h b/CPP/Common/StringConvert.h
index 05a2155..2092a2d 100644
--- a/CPP/Common/StringConvert.h
+++ b/CPP/Common/StringConvert.h
@@ -1,88 +1,110 @@
-// Common/StringConvert.h
-
-#ifndef __COMMON_STRING_CONVERT_H
-#define __COMMON_STRING_CONVERT_H
-
-#include "MyString.h"
-#include "MyWindows.h"
-
-UString MultiByteToUnicodeString(const AString &src, UINT codePage = CP_ACP);
-UString MultiByteToUnicodeString(const char *src, UINT codePage = CP_ACP);
-
-// optimized versions that work faster for ASCII strings
-void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT codePage = CP_ACP);
-// void UnicodeStringToMultiByte2(AString &dest, const UString &s, UINT codePage, char defaultChar, bool &defaultCharWasUsed);
-void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage);
-
-AString UnicodeStringToMultiByte(const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed);
-AString UnicodeStringToMultiByte(const UString &src, UINT codePage = CP_ACP);
-
-inline const wchar_t* GetUnicodeString(const wchar_t *u) { return u; }
-inline const UString& GetUnicodeString(const UString &u) { return u; }
-
-inline UString GetUnicodeString(const AString &a) { return MultiByteToUnicodeString(a); }
-inline UString GetUnicodeString(const char *a) { return MultiByteToUnicodeString(a); }
-
-inline UString GetUnicodeString(const AString &a, UINT codePage)
- { return MultiByteToUnicodeString(a, codePage); }
-inline UString GetUnicodeString(const char *a, UINT codePage)
- { return MultiByteToUnicodeString(a, codePage); }
-
-inline const wchar_t* GetUnicodeString(const wchar_t *u, UINT) { return u; }
-inline const UString& GetUnicodeString(const UString &u, UINT) { return u; }
-
-inline const char* GetAnsiString(const char *a) { return a; }
-inline const AString& GetAnsiString(const AString &a) { return a; }
-
-inline AString GetAnsiString(const wchar_t *u) { return UnicodeStringToMultiByte(UString(u)); }
-inline AString GetAnsiString(const UString &u) { return UnicodeStringToMultiByte(u); }
-
-/*
-inline const char* GetOemString(const char* oem)
- { return oem; }
-inline const AString& GetOemString(const AString &oem)
- { return oem; }
-*/
-const char* GetOemString(const char* oem);
-const AString& GetOemString(const AString &oem);
-inline AString GetOemString(const UString &u)
- { return UnicodeStringToMultiByte(u, CP_OEMCP); }
-
-#ifdef _UNICODE
- inline const wchar_t* GetSystemString(const wchar_t *u) { return u;}
- inline const UString& GetSystemString(const UString &u) { return u;}
- inline const wchar_t* GetSystemString(const wchar_t *u, UINT /* codePage */) { return u;}
- inline const UString& GetSystemString(const UString &u, UINT /* codePage */) { return u;}
-
- inline UString GetSystemString(const AString &a, UINT codePage) { return MultiByteToUnicodeString(a, codePage); }
- inline UString GetSystemString(const char *a, UINT codePage) { return MultiByteToUnicodeString(a, codePage); }
- inline UString GetSystemString(const AString &a) { return MultiByteToUnicodeString(a); }
- inline UString GetSystemString(const char *a) { return MultiByteToUnicodeString(a); }
-#else
- inline const char* GetSystemString(const char *a) { return a; }
- inline const AString& GetSystemString(const AString &a) { return a; }
- inline const char* GetSystemString(const char *a, UINT) { return a; }
- inline const AString& GetSystemString(const AString &a, UINT) { return a; }
-
- inline AString GetSystemString(const wchar_t *u) { return UnicodeStringToMultiByte(UString(u)); }
- inline AString GetSystemString(const UString &u) { return UnicodeStringToMultiByte(u); }
- inline AString GetSystemString(const UString &u, UINT codePage) { return UnicodeStringToMultiByte(u, codePage); }
-
-
-
- /*
- inline AString GetSystemString(const wchar_t *u)
- {
- UString s;
- s = u;
- return UnicodeStringToMultiByte(s);
- }
- */
-
-#endif
-
-#ifndef UNDER_CE
-AString SystemStringToOemString(const CSysString &src);
-#endif
-
-#endif
+// Common/StringConvert.h
+
+#ifndef ZIP7_INC_COMMON_STRING_CONVERT_H
+#define ZIP7_INC_COMMON_STRING_CONVERT_H
+
+#include "MyString.h"
+#include "MyWindows.h"
+
+UString MultiByteToUnicodeString(const AString &src, UINT codePage = CP_ACP);
+UString MultiByteToUnicodeString(const char *src, UINT codePage = CP_ACP);
+
+// optimized versions that work faster for ASCII strings
+void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT codePage = CP_ACP);
+// void UnicodeStringToMultiByte2(AString &dest, const UString &s, UINT codePage, char defaultChar, bool &defaultCharWasUsed);
+void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage);
+
+AString UnicodeStringToMultiByte(const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed);
+AString UnicodeStringToMultiByte(const UString &src, UINT codePage = CP_ACP);
+
+inline const wchar_t* GetUnicodeString(const wchar_t *u) { return u; }
+inline const UString& GetUnicodeString(const UString &u) { return u; }
+
+inline UString GetUnicodeString(const AString &a) { return MultiByteToUnicodeString(a); }
+inline UString GetUnicodeString(const char *a) { return MultiByteToUnicodeString(a); }
+
+inline UString GetUnicodeString(const AString &a, UINT codePage)
+ { return MultiByteToUnicodeString(a, codePage); }
+inline UString GetUnicodeString(const char *a, UINT codePage)
+ { return MultiByteToUnicodeString(a, codePage); }
+
+inline const wchar_t* GetUnicodeString(const wchar_t *u, UINT) { return u; }
+inline const UString& GetUnicodeString(const UString &u, UINT) { return u; }
+
+inline const char* GetAnsiString(const char *a) { return a; }
+inline const AString& GetAnsiString(const AString &a) { return a; }
+
+inline AString GetAnsiString(const wchar_t *u) { return UnicodeStringToMultiByte(UString(u)); }
+inline AString GetAnsiString(const UString &u) { return UnicodeStringToMultiByte(u); }
+
+/*
+inline const char* GetOemString(const char* oem)
+ { return oem; }
+inline const AString& GetOemString(const AString &oem)
+ { return oem; }
+*/
+const char* GetOemString(const char* oem);
+const AString& GetOemString(const AString &oem);
+inline AString GetOemString(const UString &u)
+ { return UnicodeStringToMultiByte(u, CP_OEMCP); }
+
+#ifdef _UNICODE
+ inline const wchar_t* GetSystemString(const wchar_t *u) { return u;}
+ inline const UString& GetSystemString(const UString &u) { return u;}
+ inline const wchar_t* GetSystemString(const wchar_t *u, UINT /* codePage */) { return u;}
+ inline const UString& GetSystemString(const UString &u, UINT /* codePage */) { return u;}
+
+ inline UString GetSystemString(const AString &a, UINT codePage) { return MultiByteToUnicodeString(a, codePage); }
+ inline UString GetSystemString(const char *a, UINT codePage) { return MultiByteToUnicodeString(a, codePage); }
+ inline UString GetSystemString(const AString &a) { return MultiByteToUnicodeString(a); }
+ inline UString GetSystemString(const char *a) { return MultiByteToUnicodeString(a); }
+#else
+ inline const char* GetSystemString(const char *a) { return a; }
+ inline const AString& GetSystemString(const AString &a) { return a; }
+ inline const char* GetSystemString(const char *a, UINT) { return a; }
+ inline const AString& GetSystemString(const AString &a, UINT) { return a; }
+
+ inline AString GetSystemString(const wchar_t *u) { return UnicodeStringToMultiByte(UString(u)); }
+ inline AString GetSystemString(const UString &u) { return UnicodeStringToMultiByte(u); }
+ inline AString GetSystemString(const UString &u, UINT codePage) { return UnicodeStringToMultiByte(u, codePage); }
+
+
+
+ /*
+ inline AString GetSystemString(const wchar_t *u)
+ {
+ UString s;
+ s = u;
+ return UnicodeStringToMultiByte(s);
+ }
+ */
+
+#endif
+
+#ifndef UNDER_CE
+AString SystemStringToOemString(const CSysString &src);
+#endif
+
+
+#ifdef _WIN32
+/* we don't need locale functions in Windows
+ but we can define ENV_HAVE_LOCALE here for debug purposes */
+// #define ENV_HAVE_LOCALE
+#else
+#define ENV_HAVE_LOCALE
+#endif
+
+#ifdef ENV_HAVE_LOCALE
+void MY_SetLocale();
+const char *GetLocale(void);
+#endif
+
+#if !defined(_WIN32) || defined(ENV_HAVE_LOCALE)
+bool IsNativeUTF8();
+#endif
+
+#ifndef _WIN32
+extern bool g_ForceToUTF8;
+#endif
+
+#endif
diff --git a/CPP/Common/StringToInt.cpp b/CPP/Common/StringToInt.cpp
index 295816e..bc4926e 100644
--- a/CPP/Common/StringToInt.cpp
+++ b/CPP/Common/StringToInt.cpp
@@ -1,144 +1,171 @@
-// Common/StringToInt.cpp
-
-#include "StdAfx.h"
-
-#include "StringToInt.h"
-
-static const UInt32 k_UInt32_max = 0xFFFFFFFF;
-static const UInt64 k_UInt64_max = UINT64_CONST(0xFFFFFFFFFFFFFFFF);
-// static const UInt64 k_UInt64_max = (UInt64)(Int64)-1;
-
-#define CONVERT_STRING_TO_UINT_FUNC(uintType, charType, charTypeUnsigned) \
- uintType ConvertStringTo ## uintType(const charType *s, const charType **end) throw() { \
- if (end) *end = s; \
- uintType res = 0; \
- for (;; s++) { \
- charTypeUnsigned c = (charTypeUnsigned)*s; \
- if (c < '0' || c > '9') { if (end) *end = s; return res; } \
- if (res > (k_ ## uintType ## _max) / 10) return 0; \
- res *= 10; \
- unsigned v = (c - '0'); \
- if (res > (k_ ## uintType ## _max) - v) return 0; \
- res += v; }}
-
-CONVERT_STRING_TO_UINT_FUNC(UInt32, char, Byte)
-CONVERT_STRING_TO_UINT_FUNC(UInt32, wchar_t, wchar_t)
-CONVERT_STRING_TO_UINT_FUNC(UInt64, char, Byte)
-CONVERT_STRING_TO_UINT_FUNC(UInt64, wchar_t, wchar_t)
-
-Int32 ConvertStringToInt32(const wchar_t *s, const wchar_t **end) throw()
-{
- if (end)
- *end = s;
- const wchar_t *s2 = s;
- if (*s == '-')
- s2++;
- if (*s2 == 0)
- return 0;
- const wchar_t *end2;
- UInt32 res = ConvertStringToUInt32(s2, &end2);
- if (*s == '-')
- {
- if (res > ((UInt32)1 << (32 - 1)))
- return 0;
- }
- else if ((res & ((UInt32)1 << (32 - 1))) != 0)
- return 0;
- if (end)
- *end = end2;
- if (*s == '-')
- return -(Int32)res;
- return (Int32)res;
-}
-
-UInt32 ConvertOctStringToUInt32(const char *s, const char **end) throw()
-{
- if (end)
- *end = s;
- UInt32 res = 0;
- for (;; s++)
- {
- unsigned c = (unsigned char)*s;
- if (c < '0' || c > '7')
- {
- if (end)
- *end = s;
- return res;
- }
- if ((res & (UInt32)7 << (32 - 3)) != 0)
- return 0;
- res <<= 3;
- res |= (unsigned)(c - '0');
- }
-}
-
-UInt64 ConvertOctStringToUInt64(const char *s, const char **end) throw()
-{
- if (end)
- *end = s;
- UInt64 res = 0;
- for (;; s++)
- {
- unsigned c = (unsigned char)*s;
- if (c < '0' || c > '7')
- {
- if (end)
- *end = s;
- return res;
- }
- if ((res & (UInt64)7 << (64 - 3)) != 0)
- return 0;
- res <<= 3;
- res |= (unsigned)(c - '0');
- }
-}
-
-UInt32 ConvertHexStringToUInt32(const char *s, const char **end) throw()
-{
- if (end)
- *end = s;
- UInt32 res = 0;
- for (;; s++)
- {
- unsigned c = (Byte)*s;
- unsigned v;
- if (c >= '0' && c <= '9') v = (c - '0');
- else if (c >= 'A' && c <= 'F') v = 10 + (c - 'A');
- else if (c >= 'a' && c <= 'f') v = 10 + (c - 'a');
- else
- {
- if (end)
- *end = s;
- return res;
- }
- if ((res & (UInt32)0xF << (32 - 4)) != 0)
- return 0;
- res <<= 4;
- res |= v;
- }
-}
-
-UInt64 ConvertHexStringToUInt64(const char *s, const char **end) throw()
-{
- if (end)
- *end = s;
- UInt64 res = 0;
- for (;; s++)
- {
- unsigned c = (Byte)*s;
- unsigned v;
- if (c >= '0' && c <= '9') v = (c - '0');
- else if (c >= 'A' && c <= 'F') v = 10 + (c - 'A');
- else if (c >= 'a' && c <= 'f') v = 10 + (c - 'a');
- else
- {
- if (end)
- *end = s;
- return res;
- }
- if ((res & (UInt64)0xF << (64 - 4)) != 0)
- return 0;
- res <<= 4;
- res |= v;
- }
-}
+// Common/StringToInt.cpp
+
+#include "StdAfx.h"
+
+#include "StringToInt.h"
+
+static const UInt32 k_UInt32_max = 0xFFFFFFFF;
+static const UInt64 k_UInt64_max = UINT64_CONST(0xFFFFFFFFFFFFFFFF);
+// static const UInt64 k_UInt64_max = (UInt64)(Int64)-1;
+
+#define CONVERT_STRING_TO_UINT_FUNC(uintType, charType, charTypeUnsigned) \
+ uintType ConvertStringTo ## uintType(const charType *s, const charType **end) throw() { \
+ if (end) *end = s; \
+ uintType res = 0; \
+ for (;; s++) { \
+ charTypeUnsigned c = (charTypeUnsigned)*s; \
+ if (c < '0' || c > '9') { if (end) *end = s; return res; } \
+ if (res > (k_ ## uintType ## _max) / 10) return 0; \
+ res *= 10; \
+ unsigned v = (unsigned)(c - '0'); \
+ if (res > (k_ ## uintType ## _max) - v) return 0; \
+ res += v; }}
+
+CONVERT_STRING_TO_UINT_FUNC(UInt32, char, Byte)
+CONVERT_STRING_TO_UINT_FUNC(UInt32, wchar_t, wchar_t)
+CONVERT_STRING_TO_UINT_FUNC(UInt64, char, Byte)
+CONVERT_STRING_TO_UINT_FUNC(UInt64, wchar_t, wchar_t)
+
+/*
+Int32 ConvertStringToInt32(const char *s, const char **end) throw()
+{
+ if (end)
+ *end = s;
+ const char *s2 = s;
+ if (*s == '-')
+ s2++;
+ if (*s2 == 0)
+ return 0;
+ const char *end2;
+ UInt32 res = ConvertStringToUInt32(s2, &end2);
+ if (*s == '-')
+ {
+ if (res > ((UInt32)1 << (32 - 1)))
+ return 0;
+ }
+ else if ((res & ((UInt32)1 << (32 - 1))) != 0)
+ return 0;
+ if (end)
+ *end = end2;
+ if (*s == '-')
+ return -(Int32)res;
+ return (Int32)res;
+}
+*/
+
+Int32 ConvertStringToInt32(const wchar_t *s, const wchar_t **end) throw()
+{
+ if (end)
+ *end = s;
+ const wchar_t *s2 = s;
+ if (*s == '-')
+ s2++;
+ if (*s2 == 0)
+ return 0;
+ const wchar_t *end2;
+ UInt32 res = ConvertStringToUInt32(s2, &end2);
+ if (*s == '-')
+ {
+ if (res > ((UInt32)1 << (32 - 1)))
+ return 0;
+ }
+ else if ((res & ((UInt32)1 << (32 - 1))) != 0)
+ return 0;
+ if (end)
+ *end = end2;
+ if (*s == '-')
+ return -(Int32)res;
+ return (Int32)res;
+}
+
+UInt32 ConvertOctStringToUInt32(const char *s, const char **end) throw()
+{
+ if (end)
+ *end = s;
+ UInt32 res = 0;
+ for (;; s++)
+ {
+ unsigned c = (unsigned char)*s;
+ if (c < '0' || c > '7')
+ {
+ if (end)
+ *end = s;
+ return res;
+ }
+ if ((res & (UInt32)7 << (32 - 3)) != 0)
+ return 0;
+ res <<= 3;
+ res |= (unsigned)(c - '0');
+ }
+}
+
+UInt64 ConvertOctStringToUInt64(const char *s, const char **end) throw()
+{
+ if (end)
+ *end = s;
+ UInt64 res = 0;
+ for (;; s++)
+ {
+ unsigned c = (unsigned char)*s;
+ if (c < '0' || c > '7')
+ {
+ if (end)
+ *end = s;
+ return res;
+ }
+ if ((res & (UInt64)7 << (64 - 3)) != 0)
+ return 0;
+ res <<= 3;
+ res |= (unsigned)(c - '0');
+ }
+}
+
+UInt32 ConvertHexStringToUInt32(const char *s, const char **end) throw()
+{
+ if (end)
+ *end = s;
+ UInt32 res = 0;
+ for (;; s++)
+ {
+ unsigned c = (Byte)*s;
+ unsigned v;
+ if (c >= '0' && c <= '9') v = (c - '0');
+ else if (c >= 'A' && c <= 'F') v = 10 + (c - 'A');
+ else if (c >= 'a' && c <= 'f') v = 10 + (c - 'a');
+ else
+ {
+ if (end)
+ *end = s;
+ return res;
+ }
+ if ((res & (UInt32)0xF << (32 - 4)) != 0)
+ return 0;
+ res <<= 4;
+ res |= v;
+ }
+}
+
+UInt64 ConvertHexStringToUInt64(const char *s, const char **end) throw()
+{
+ if (end)
+ *end = s;
+ UInt64 res = 0;
+ for (;; s++)
+ {
+ unsigned c = (Byte)*s;
+ unsigned v;
+ if (c >= '0' && c <= '9') v = (c - '0');
+ else if (c >= 'A' && c <= 'F') v = 10 + (c - 'A');
+ else if (c >= 'a' && c <= 'f') v = 10 + (c - 'a');
+ else
+ {
+ if (end)
+ *end = s;
+ return res;
+ }
+ if ((res & (UInt64)0xF << (64 - 4)) != 0)
+ return 0;
+ res <<= 4;
+ res |= v;
+ }
+}
diff --git a/CPP/Common/StringToInt.h b/CPP/Common/StringToInt.h
index 140d1ee..c9dce7d 100644
--- a/CPP/Common/StringToInt.h
+++ b/CPP/Common/StringToInt.h
@@ -1,21 +1,22 @@
-// Common/StringToInt.h
-
-#ifndef __COMMON_STRING_TO_INT_H
-#define __COMMON_STRING_TO_INT_H
-
-#include "MyTypes.h"
-
-UInt32 ConvertStringToUInt32(const char *s, const char **end) throw();
-UInt64 ConvertStringToUInt64(const char *s, const char **end) throw();
-UInt32 ConvertStringToUInt32(const wchar_t *s, const wchar_t **end) throw();
-UInt64 ConvertStringToUInt64(const wchar_t *s, const wchar_t **end) throw();
-
-Int32 ConvertStringToInt32(const wchar_t *s, const wchar_t **end) throw();
-
-UInt32 ConvertOctStringToUInt32(const char *s, const char **end) throw();
-UInt64 ConvertOctStringToUInt64(const char *s, const char **end) throw();
-
-UInt32 ConvertHexStringToUInt32(const char *s, const char **end) throw();
-UInt64 ConvertHexStringToUInt64(const char *s, const char **end) throw();
-
-#endif
+// Common/StringToInt.h
+
+#ifndef ZIP7_INC_COMMON_STRING_TO_INT_H
+#define ZIP7_INC_COMMON_STRING_TO_INT_H
+
+#include "MyTypes.h"
+
+UInt32 ConvertStringToUInt32(const char *s, const char **end) throw();
+UInt64 ConvertStringToUInt64(const char *s, const char **end) throw();
+UInt32 ConvertStringToUInt32(const wchar_t *s, const wchar_t **end) throw();
+UInt64 ConvertStringToUInt64(const wchar_t *s, const wchar_t **end) throw();
+
+// Int32 ConvertStringToInt32(const char *s, const char **end) throw();
+Int32 ConvertStringToInt32(const wchar_t *s, const wchar_t **end) throw();
+
+UInt32 ConvertOctStringToUInt32(const char *s, const char **end) throw();
+UInt64 ConvertOctStringToUInt64(const char *s, const char **end) throw();
+
+UInt32 ConvertHexStringToUInt32(const char *s, const char **end) throw();
+UInt64 ConvertHexStringToUInt64(const char *s, const char **end) throw();
+
+#endif
diff --git a/CPP/Common/TextConfig.cpp b/CPP/Common/TextConfig.cpp
index f54aa3f..d3e561c 100644
--- a/CPP/Common/TextConfig.cpp
+++ b/CPP/Common/TextConfig.cpp
@@ -1,124 +1,124 @@
-// Common/TextConfig.cpp
-
-#include "StdAfx.h"
-
-#include "TextConfig.h"
-#include "UTFConvert.h"
-
-static inline bool IsDelimitChar(char c)
-{
- return (c == ' ' || c == 0x0A || c == 0x0D || c == '\0' || c == '\t');
-}
-
-static AString GetIDString(const char *s, unsigned &finishPos)
-{
- AString result;
- for (finishPos = 0; ; finishPos++)
- {
- char c = s[finishPos];
- if (IsDelimitChar(c) || c == '=')
- break;
- result += c;
- }
- return result;
-}
-
-static bool WaitNextLine(const AString &s, unsigned &pos)
-{
- for (; pos < s.Len(); pos++)
- if (s[pos] == 0x0A)
- return true;
- return false;
-}
-
-static bool SkipSpaces(const AString &s, unsigned &pos)
-{
- for (; pos < s.Len(); pos++)
- {
- char c = s[pos];
- if (!IsDelimitChar(c))
- {
- if (c != ';')
- return true;
- if (!WaitNextLine(s, pos))
- return false;
- }
- }
- return false;
-}
-
-bool GetTextConfig(const AString &s, CObjectVector<CTextConfigPair> &pairs)
-{
- pairs.Clear();
- unsigned pos = 0;
-
- /////////////////////
- // read strings
-
- for (;;)
- {
- if (!SkipSpaces(s, pos))
- break;
- CTextConfigPair pair;
- unsigned finishPos;
- const AString temp (GetIDString(((const char *)s) + pos, finishPos));
- if (!ConvertUTF8ToUnicode(temp, pair.ID))
- return false;
- if (finishPos == 0)
- return false;
- pos += finishPos;
- if (!SkipSpaces(s, pos))
- return false;
- if (s[pos] != '=')
- return false;
- pos++;
- if (!SkipSpaces(s, pos))
- return false;
- if (s[pos] != '\"')
- return false;
- pos++;
- AString message;
- for (;;)
- {
- if (pos >= s.Len())
- return false;
- char c = s[pos++];
- if (c == '\"')
- break;
- if (c == '\\')
- {
- c = s[pos++];
- switch (c)
- {
- case 'n': message += '\n'; break;
- case 't': message += '\t'; break;
- case '\\': message += '\\'; break;
- case '\"': message += '\"'; break;
- default: message += '\\'; message += c; break;
- }
- }
- else
- message += c;
- }
- if (!ConvertUTF8ToUnicode(message, pair.String))
- return false;
- pairs.Add(pair);
- }
- return true;
-}
-
-int FindTextConfigItem(const CObjectVector<CTextConfigPair> &pairs, const char *id) throw()
-{
- FOR_VECTOR (i, pairs)
- if (pairs[i].ID.IsEqualTo(id))
- return i;
- return -1;
-}
-
-UString GetTextConfigValue(const CObjectVector<CTextConfigPair> &pairs, const char *id)
-{
- int index = FindTextConfigItem(pairs, id);
- if (index < 0)
- return UString();
- return pairs[index].String;
-}
+// Common/TextConfig.cpp
+
+#include "StdAfx.h"
+
+#include "TextConfig.h"
+#include "UTFConvert.h"
+
+static inline bool IsDelimitChar(char c)
+{
+ return (c == ' ' || c == 0x0A || c == 0x0D || c == '\0' || c == '\t');
+}
+
+static AString GetIDString(const char *s, unsigned &finishPos)
+{
+ AString result;
+ for (finishPos = 0; ; finishPos++)
+ {
+ const char c = s[finishPos];
+ if (IsDelimitChar(c) || c == '=')
+ break;
+ result += c;
+ }
+ return result;
+}
+
+static bool WaitNextLine(const AString &s, unsigned &pos)
+{
+ for (; pos < s.Len(); pos++)
+ if (s[pos] == 0x0A)
+ return true;
+ return false;
+}
+
+static bool SkipSpaces(const AString &s, unsigned &pos)
+{
+ for (; pos < s.Len(); pos++)
+ {
+ const char c = s[pos];
+ if (!IsDelimitChar(c))
+ {
+ if (c != ';')
+ return true;
+ if (!WaitNextLine(s, pos))
+ return false;
+ }
+ }
+ return false;
+}
+
+bool GetTextConfig(const AString &s, CObjectVector<CTextConfigPair> &pairs)
+{
+ pairs.Clear();
+ unsigned pos = 0;
+
+ /////////////////////
+ // read strings
+
+ for (;;)
+ {
+ if (!SkipSpaces(s, pos))
+ break;
+ CTextConfigPair pair;
+ unsigned finishPos;
+ const AString temp (GetIDString(((const char *)s) + pos, finishPos));
+ if (!ConvertUTF8ToUnicode(temp, pair.ID))
+ return false;
+ if (finishPos == 0)
+ return false;
+ pos += finishPos;
+ if (!SkipSpaces(s, pos))
+ return false;
+ if (s[pos] != '=')
+ return false;
+ pos++;
+ if (!SkipSpaces(s, pos))
+ return false;
+ if (s[pos] != '\"')
+ return false;
+ pos++;
+ AString message;
+ for (;;)
+ {
+ if (pos >= s.Len())
+ return false;
+ char c = s[pos++];
+ if (c == '\"')
+ break;
+ if (c == '\\')
+ {
+ c = s[pos++];
+ switch (c)
+ {
+ case 'n': message += '\n'; break;
+ case 't': message += '\t'; break;
+ case '\\': message += '\\'; break;
+ case '\"': message += '\"'; break;
+ default: message += '\\'; message += c; break;
+ }
+ }
+ else
+ message += c;
+ }
+ if (!ConvertUTF8ToUnicode(message, pair.String))
+ return false;
+ pairs.Add(pair);
+ }
+ return true;
+}
+
+int FindTextConfigItem(const CObjectVector<CTextConfigPair> &pairs, const char *id) throw()
+{
+ FOR_VECTOR (i, pairs)
+ if (pairs[i].ID.IsEqualTo(id))
+ return (int)i;
+ return -1;
+}
+
+UString GetTextConfigValue(const CObjectVector<CTextConfigPair> &pairs, const char *id)
+{
+ const int index = FindTextConfigItem(pairs, id);
+ if (index < 0)
+ return UString();
+ return pairs[index].String;
+}
diff --git a/CPP/Common/TextConfig.h b/CPP/Common/TextConfig.h
index c39e363..2263a44 100644
--- a/CPP/Common/TextConfig.h
+++ b/CPP/Common/TextConfig.h
@@ -1,19 +1,19 @@
-// Common/TextConfig.h
-
-#ifndef __COMMON_TEXT_CONFIG_H
-#define __COMMON_TEXT_CONFIG_H
-
-#include "MyString.h"
-
-struct CTextConfigPair
-{
- UString ID;
- UString String;
-};
-
-bool GetTextConfig(const AString &text, CObjectVector<CTextConfigPair> &pairs);
-
-int FindTextConfigItem(const CObjectVector<CTextConfigPair> &pairs, const char *id) throw();
-UString GetTextConfigValue(const CObjectVector<CTextConfigPair> &pairs, const char *id);
-
-#endif
+// Common/TextConfig.h
+
+#ifndef ZIP7_INC_COMMON_TEXT_CONFIG_H
+#define ZIP7_INC_COMMON_TEXT_CONFIG_H
+
+#include "MyString.h"
+
+struct CTextConfigPair
+{
+ UString ID;
+ UString String;
+};
+
+bool GetTextConfig(const AString &text, CObjectVector<CTextConfigPair> &pairs);
+
+int FindTextConfigItem(const CObjectVector<CTextConfigPair> &pairs, const char *id) throw();
+UString GetTextConfigValue(const CObjectVector<CTextConfigPair> &pairs, const char *id);
+
+#endif
diff --git a/CPP/Common/UTFConvert.cpp b/CPP/Common/UTFConvert.cpp
index b09bbcd..fb166b7 100644
--- a/CPP/Common/UTFConvert.cpp
+++ b/CPP/Common/UTFConvert.cpp
@@ -1,288 +1,863 @@
-// UTFConvert.cpp
-
-#include "StdAfx.h"
-
-#include "MyTypes.h"
-#include "UTFConvert.h"
-
-#ifdef _WIN32
-#define _WCHART_IS_16BIT 1
-#endif
-
-/*
- _UTF8_START(n) - is a base value for start byte (head), if there are (n) additional bytes after start byte
-
- n : _UTF8_START(n) : Bits of code point
-
- 0 : 0x80 : : unused
- 1 : 0xC0 : 11 :
- 2 : 0xE0 : 16 : Basic Multilingual Plane
- 3 : 0xF0 : 21 : Unicode space
- 3 : 0xF8 : 26 :
- 5 : 0xFC : 31 : UCS-4
- 6 : 0xFE : 36 : We can use it, if we want to encode any 32-bit value
- 7 : 0xFF :
-*/
-
-#define _UTF8_START(n) (0x100 - (1 << (7 - (n))))
-
-#define _UTF8_HEAD_PARSE2(n) if (c < _UTF8_START((n) + 1)) { numBytes = (n); c -= _UTF8_START(n); }
-
-#define _UTF8_HEAD_PARSE \
- _UTF8_HEAD_PARSE2(1) \
- else _UTF8_HEAD_PARSE2(2) \
- else _UTF8_HEAD_PARSE2(3) \
- else _UTF8_HEAD_PARSE2(4) \
- else _UTF8_HEAD_PARSE2(5) \
-
- // else _UTF8_HEAD_PARSE2(6)
-
-bool CheckUTF8(const char *src, bool allowReduced) throw()
-{
- for (;;)
- {
- Byte c = *src++;
- if (c == 0)
- return true;
-
- if (c < 0x80)
- continue;
- if (c < 0xC0) // (c < 0xC0 + 2) // if we support only optimal encoding chars
- return false;
-
- unsigned numBytes;
- _UTF8_HEAD_PARSE
- else
- return false;
-
- UInt32 val = c;
-
- do
- {
- Byte c2 = *src++;
- if (c2 < 0x80 || c2 >= 0xC0)
- return allowReduced && c2 == 0;
- val <<= 6;
- val |= (c2 - 0x80);
- }
- while (--numBytes);
-
- if (val >= 0x110000)
- return false;
- }
-}
-
-
-#define _ERROR_UTF8 \
- { if (dest) dest[destPos] = (wchar_t)0xFFFD; destPos++; ok = false; continue; }
-
-static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const char *srcLim) throw()
-{
- size_t destPos = 0;
- bool ok = true;
-
- for (;;)
- {
- Byte c;
- if (src == srcLim)
- {
- *destLen = destPos;
- return ok;
- }
- c = *src++;
-
- if (c < 0x80)
- {
- if (dest)
- dest[destPos] = (wchar_t)c;
- destPos++;
- continue;
- }
- if (c < 0xC0)
- _ERROR_UTF8
-
- unsigned numBytes;
- _UTF8_HEAD_PARSE
- else
- _ERROR_UTF8
-
- UInt32 val = c;
-
- do
- {
- Byte c2;
- if (src == srcLim)
- break;
- c2 = *src;
- if (c2 < 0x80 || c2 >= 0xC0)
- break;
- src++;
- val <<= 6;
- val |= (c2 - 0x80);
- }
- while (--numBytes);
-
- if (numBytes != 0)
- _ERROR_UTF8
-
- if (val < 0x10000)
- {
- if (dest)
- dest[destPos] = (wchar_t)val;
- destPos++;
- }
- else
- {
- val -= 0x10000;
- if (val >= 0x100000)
- _ERROR_UTF8
- if (dest)
- {
- dest[destPos + 0] = (wchar_t)(0xD800 + (val >> 10));
- dest[destPos + 1] = (wchar_t)(0xDC00 + (val & 0x3FF));
- }
- destPos += 2;
- }
- }
-}
-
-#define _UTF8_RANGE(n) (((UInt32)1) << ((n) * 5 + 6))
-
-#define _UTF8_HEAD(n, val) ((char)(_UTF8_START(n) + (val >> (6 * (n)))))
-#define _UTF8_CHAR(n, val) ((char)(0x80 + (((val) >> (6 * (n))) & 0x3F)))
-
-static size_t Utf16_To_Utf8_Calc(const wchar_t *src, const wchar_t *srcLim)
-{
- size_t size = srcLim - src;
- for (;;)
- {
- if (src == srcLim)
- return size;
-
- UInt32 val = *src++;
-
- if (val < 0x80)
- continue;
-
- if (val < _UTF8_RANGE(1))
- {
- size++;
- continue;
- }
-
- if (val >= 0xD800 && val < 0xDC00 && src != srcLim)
- {
- UInt32 c2 = *src;
- if (c2 >= 0xDC00 && c2 < 0xE000)
- {
- src++;
- size += 2;
- continue;
- }
- }
-
- #ifdef _WCHART_IS_16BIT
-
- size += 2;
-
- #else
-
- if (val < _UTF8_RANGE(2)) size += 2;
- else if (val < _UTF8_RANGE(3)) size += 3;
- else if (val < _UTF8_RANGE(4)) size += 4;
- else if (val < _UTF8_RANGE(5)) size += 5;
- else size += 6;
-
- #endif
- }
-}
-
-static char *Utf16_To_Utf8(char *dest, const wchar_t *src, const wchar_t *srcLim)
-{
- for (;;)
- {
- if (src == srcLim)
- return dest;
-
- UInt32 val = *src++;
-
- if (val < 0x80)
- {
- *dest++ = (char)val;
- continue;
- }
-
- if (val < _UTF8_RANGE(1))
- {
- dest[0] = _UTF8_HEAD(1, val);
- dest[1] = _UTF8_CHAR(0, val);
- dest += 2;
- continue;
- }
-
- if (val >= 0xD800 && val < 0xDC00 && src != srcLim)
- {
- UInt32 c2 = *src;
- if (c2 >= 0xDC00 && c2 < 0xE000)
- {
- src++;
- val = (((val - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
- dest[0] = _UTF8_HEAD(3, val);
- dest[1] = _UTF8_CHAR(2, val);
- dest[2] = _UTF8_CHAR(1, val);
- dest[3] = _UTF8_CHAR(0, val);
- dest += 4;
- continue;
- }
- }
-
- #ifndef _WCHART_IS_16BIT
- if (val < _UTF8_RANGE(2))
- #endif
- {
- dest[0] = _UTF8_HEAD(2, val);
- dest[1] = _UTF8_CHAR(1, val);
- dest[2] = _UTF8_CHAR(0, val);
- dest += 3;
- continue;
- }
-
- #ifndef _WCHART_IS_16BIT
-
- UInt32 b;
- unsigned numBits;
- if (val < _UTF8_RANGE(3)) { numBits = 6 * 3; b = _UTF8_HEAD(3, val); }
- else if (val < _UTF8_RANGE(4)) { numBits = 6 * 4; b = _UTF8_HEAD(4, val); }
- else if (val < _UTF8_RANGE(5)) { numBits = 6 * 5; b = _UTF8_HEAD(5, val); }
- else { numBits = 6 * 6; b = _UTF8_START(6); }
-
- *dest++ = (Byte)b;
-
- do
- {
- numBits -= 6;
- *dest++ = (char)(0x80 + ((val >> numBits) & 0x3F));
- }
- while (numBits != 0);
-
- #endif
- }
-}
-
-bool ConvertUTF8ToUnicode(const AString &src, UString &dest)
-{
- dest.Empty();
- size_t destLen = 0;
- Utf8_To_Utf16(NULL, &destLen, src, src.Ptr(src.Len()));
- bool res = Utf8_To_Utf16(dest.GetBuf((unsigned)destLen), &destLen, src, src.Ptr(src.Len()));
- dest.ReleaseBuf_SetEnd((unsigned)destLen);
- return res;
-}
-
-void ConvertUnicodeToUTF8(const UString &src, AString &dest)
-{
- dest.Empty();
- size_t destLen = Utf16_To_Utf8_Calc(src, src.Ptr(src.Len()));
- Utf16_To_Utf8(dest.GetBuf((unsigned)destLen), src, src.Ptr(src.Len()));
- dest.ReleaseBuf_SetEnd((unsigned)destLen);
-}
+// UTFConvert.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "MyTypes.h"
+#include "UTFConvert.h"
+
+
+#ifndef Z7_WCHART_IS_16BIT
+#ifndef __APPLE__
+ // we define it if the system supports files with non-utf8 symbols:
+ #define MY_UTF8_RAW_NON_UTF8_SUPPORTED
+#endif
+#endif
+
+/*
+ MY_UTF8_START(n) - is a base value for start byte (head), if there are (n) additional bytes after start byte
+
+ n : MY_UTF8_START(n) : Bits of code point
+
+ 0 : 0x80 : : unused
+ 1 : 0xC0 : 11 :
+ 2 : 0xE0 : 16 : Basic Multilingual Plane
+ 3 : 0xF0 : 21 : Unicode space
+ 4 : 0xF8 : 26 :
+ 5 : 0xFC : 31 : UCS-4 : wcstombs() in ubuntu is limited to that value
+ 6 : 0xFE : 36 : We can use it, if we want to encode any 32-bit value
+ 7 : 0xFF :
+*/
+
+#define MY_UTF8_START(n) (0x100 - (1 << (7 - (n))))
+
+#define MY_UTF8_HEAD_PARSE2(n) \
+ if (c < MY_UTF8_START((n) + 1)) \
+ { numBytes = (n); val -= MY_UTF8_START(n); }
+
+#ifndef Z7_WCHART_IS_16BIT
+
+/*
+ if (wchar_t is 32-bit), we can support large points in long UTF-8 sequence,
+ when we convert wchar_t strings to UTF-8:
+ (_UTF8_NUM_TAIL_BYTES_MAX == 3) : (21-bits points) - Unicode
+ (_UTF8_NUM_TAIL_BYTES_MAX == 5) : (31-bits points) - UCS-4
+ (_UTF8_NUM_TAIL_BYTES_MAX == 6) : (36-bit hack)
+*/
+
+#define MY_UTF8_NUM_TAIL_BYTES_MAX 5
+#endif
+
+/*
+#define MY_UTF8_HEAD_PARSE \
+ UInt32 val = c; \
+ MY_UTF8_HEAD_PARSE2(1) \
+ else MY_UTF8_HEAD_PARSE2(2) \
+ else MY_UTF8_HEAD_PARSE2(3) \
+ else MY_UTF8_HEAD_PARSE2(4) \
+ else MY_UTF8_HEAD_PARSE2(5) \
+ #if MY_UTF8_NUM_TAIL_BYTES_MAX >= 6
+ else MY_UTF8_HEAD_PARSE2(6)
+ #endif
+*/
+
+#define MY_UTF8_HEAD_PARSE_MAX_3_BYTES \
+ UInt32 val = c; \
+ MY_UTF8_HEAD_PARSE2(1) \
+ else MY_UTF8_HEAD_PARSE2(2) \
+ else { numBytes = 3; val -= MY_UTF8_START(3); }
+
+
+#define MY_UTF8_RANGE(n) (((UInt32)1) << ((n) * 5 + 6))
+
+
+#define START_POINT_FOR_SURROGATE 0x10000
+
+
+/* we use 128 bytes block in 16-bit BMP-PLANE to encode non-UTF-8 Escapes
+ Also we can use additional HIGH-PLANE (we use 21-bit points above 0x1f0000)
+ to simplify internal intermediate conversion in Linux:
+ RAW-UTF-8 <-> internal wchar_t utf-16 strings <-> RAW-UTF-UTF-8
+*/
+
+
+#if defined(Z7_WCHART_IS_16BIT)
+
+#define UTF_ESCAPE_PLANE 0
+
+#else
+
+/*
+we can place 128 ESCAPE chars to
+ ef 80 - ee be 80 (3-bytes utf-8) : similar to WSL
+ ef ff - ee bf bf
+
+1f ef 80 - f7 be be 80 (4-bytes utf-8) : last 4-bytes utf-8 plane (out of Unicode)
+1f ef ff - f7 be bf bf (4-bytes utf-8) : last 4-bytes utf-8 plane (out of Unicode)
+*/
+
+// #define UTF_ESCAPE_PLANE_HIGH (0x1f << 16)
+// #define UTF_ESCAPE_PLANE UTF_ESCAPE_PLANE_HIGH
+#define UTF_ESCAPE_PLANE 0
+
+/*
+ if (Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE is set)
+ {
+ if (UTF_ESCAPE_PLANE is UTF_ESCAPE_PLANE_HIGH)
+ {
+ we can restore any 8-bit Escape from ESCAPE-PLANE-21 plane.
+ But ESCAPE-PLANE-21 point cannot be stored to utf-16 (7z archive)
+ So we still need a way to extract 8-bit Escapes and BMP-Escapes-8
+ from same BMP-Escapes-16 stored in 7z.
+ And if we want to restore any 8-bit from 7z archive,
+ we still must use Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT for (utf-8 -> utf-16)
+ Also we need additional Conversions to tranform from utf-16 to utf-16-With-Escapes-21
+ }
+ else (UTF_ESCAPE_PLANE == 0)
+ {
+ we must convert original 3-bytes utf-8 BMP-Escape point to sequence
+ of 3 BMP-Escape-16 points with Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
+ so we can extract original RAW-UTF-8 from UTFD-16 later.
+ }
+ }
+*/
+
+#endif
+
+
+
+#define UTF_ESCAPE_BASE 0xef00
+
+
+#ifdef UTF_ESCAPE_BASE
+#define IS_ESCAPE_POINT(v, plane) (((v) & (UInt32)0xffffff80) == (plane) + UTF_ESCAPE_BASE + 0x80)
+#endif
+
+#define IS_SURROGATE_POINT(v) (((v) & (UInt32)0xfffff800) == 0xd800)
+#define IS_LOW_SURROGATE_POINT(v) (((v) & (UInt32)0xfffffC00) == 0xdc00)
+
+
+#define UTF_ERROR_UTF8_CHECK \
+ { NonUtf = true; continue; }
+
+void CUtf8Check::Check_Buf(const char *src, size_t size) throw()
+{
+ Clear();
+ // Byte maxByte = 0;
+
+ for (;;)
+ {
+ if (size == 0)
+ break;
+
+ const Byte c = (Byte)(*src++);
+ size--;
+
+ if (c == 0)
+ {
+ ZeroChar = true;
+ continue;
+ }
+
+ /*
+ if (c > maxByte)
+ maxByte = c;
+ */
+
+ if (c < 0x80)
+ continue;
+
+ if (c < 0xc0 + 2) // it's limit for 0x140000 unicode codes : win32 compatibility
+ UTF_ERROR_UTF8_CHECK
+
+ unsigned numBytes;
+
+ UInt32 val = c;
+ MY_UTF8_HEAD_PARSE2(1)
+ else MY_UTF8_HEAD_PARSE2(2)
+ else MY_UTF8_HEAD_PARSE2(4)
+ else MY_UTF8_HEAD_PARSE2(5)
+ else
+ {
+ UTF_ERROR_UTF8_CHECK
+ }
+
+ unsigned pos = 0;
+ do
+ {
+ if (pos == size)
+ break;
+ unsigned c2 = (Byte)src[pos];
+ c2 -= 0x80;
+ if (c2 >= 0x40)
+ break;
+ val <<= 6;
+ val |= c2;
+ if (pos == 0)
+ if (val < (((unsigned)1 << 7) >> numBytes))
+ break;
+ pos++;
+ }
+ while (--numBytes);
+
+ if (numBytes != 0)
+ {
+ if (pos == size)
+ Truncated = true;
+ else
+ UTF_ERROR_UTF8_CHECK
+ }
+
+ #ifdef UTF_ESCAPE_BASE
+ if (IS_ESCAPE_POINT(val, 0))
+ Escape = true;
+ #endif
+
+ if (MaxHighPoint < val)
+ MaxHighPoint = val;
+
+ if (IS_SURROGATE_POINT(val))
+ SingleSurrogate = true;
+
+ src += pos;
+ size -= pos;
+ }
+
+ // MaxByte = maxByte;
+}
+
+bool Check_UTF8_Buf(const char *src, size_t size, bool allowReduced) throw()
+{
+ CUtf8Check check;
+ check.Check_Buf(src, size);
+ return check.IsOK(allowReduced);
+}
+
+/*
+bool CheckUTF8_chars(const char *src, bool allowReduced) throw()
+{
+ CUtf8Check check;
+ check.CheckBuf(src, strlen(src));
+ return check.IsOK(allowReduced);
+}
+*/
+
+bool CheckUTF8_AString(const AString &s) throw()
+{
+ CUtf8Check check;
+ check.Check_AString(s);
+ return check.IsOK();
+}
+
+
+/*
+bool CheckUTF8(const char *src, bool allowReduced) throw()
+{
+ // return Check_UTF8_Buf(src, strlen(src), allowReduced);
+
+ for (;;)
+ {
+ const Byte c = (Byte)(*src++);
+ if (c == 0)
+ return true;
+
+ if (c < 0x80)
+ continue;
+ if (c < 0xC0 + 2 || c >= 0xf5)
+ return false;
+
+ unsigned numBytes;
+ MY_UTF8_HEAD_PARSE
+ else
+ return false;
+
+ unsigned pos = 0;
+
+ do
+ {
+ Byte c2 = (Byte)(*src++);
+ if (c2 < 0x80 || c2 >= 0xC0)
+ return allowReduced && c2 == 0;
+ val <<= 6;
+ val |= (c2 - 0x80);
+ pos++;
+ }
+ while (--numBytes);
+
+ if (val < MY_UTF8_RANGE(pos - 1))
+ return false;
+
+ if (val >= 0x110000)
+ return false;
+ }
+}
+*/
+
+// in case of UTF-8 error we have two ways:
+// 21.01- : old : 0xfffd: REPLACEMENT CHARACTER : old version
+// 21.02+ : new : 0xef00 + (c) : similar to WSL scheme for low symbols
+
+#define UTF_REPLACEMENT_CHAR 0xfffd
+
+
+
+#define UTF_ESCAPE(c) \
+ ((flags & Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE) ? \
+ UTF_ESCAPE_PLANE + UTF_ESCAPE_BASE + (c) : UTF_REPLACEMENT_CHAR)
+
+/*
+#define UTF_HARD_ERROR_UTF8
+ { if (dest) dest[destPos] = (wchar_t)UTF_ESCAPE(c); \
+ destPos++; ok = false; continue; }
+*/
+
+// we ignore utf errors, and don't change (ok) variable!
+
+#define UTF_ERROR_UTF8 \
+ { if (dest) dest[destPos] = (wchar_t)UTF_ESCAPE(c); \
+ destPos++; continue; }
+
+// we store UTF-16 in wchar_t strings. So we use surrogates for big unicode points:
+
+// for debug puposes only we can store UTF-32 in wchar_t:
+// #define START_POINT_FOR_SURROGATE ((UInt32)0 - 1)
+
+
+/*
+ WIN32 MultiByteToWideChar(CP_UTF8) emits 0xfffd point, if utf-8 error was found.
+ Ant it can emit single 0xfffd from 2 src bytes.
+ It doesn't emit single 0xfffd from 3-4 src bytes.
+ We can
+ 1) emit Escape point for each incorrect byte. So we can data recover later
+ 2) emit 0xfffd for each incorrect byte.
+ That scheme is similar to Escape scheme, but we emit 0xfffd
+ instead of each Escape point.
+ 3) emit single 0xfffd from 1-2 incorrect bytes, as WIN32 MultiByteToWideChar scheme
+*/
+
+static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const char *srcLim, unsigned flags) throw()
+{
+ size_t destPos = 0;
+ bool ok = true;
+
+ for (;;)
+ {
+ if (src == srcLim)
+ {
+ *destLen = destPos;
+ return ok;
+ }
+
+ const Byte c = (Byte)(*src++);
+
+ if (c < 0x80)
+ {
+ if (dest)
+ dest[destPos] = (wchar_t)c;
+ destPos++;
+ continue;
+ }
+
+ if (c < 0xc0 + 2
+ || c >= 0xf5) // it's limit for 0x140000 unicode codes : win32 compatibility
+ {
+ UTF_ERROR_UTF8
+ }
+
+ unsigned numBytes;
+
+ MY_UTF8_HEAD_PARSE_MAX_3_BYTES
+
+ unsigned pos = 0;
+ do
+ {
+ if (src + pos == srcLim)
+ break;
+ unsigned c2 = (Byte)src[pos];
+ c2 -= 0x80;
+ if (c2 >= 0x40)
+ break;
+ val <<= 6;
+ val |= c2;
+ pos++;
+ if (pos == 1)
+ {
+ if (val < (((unsigned)1 << 7) >> numBytes))
+ break;
+ if (numBytes == 2)
+ {
+ if (flags & Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR)
+ if ((val & (0xF800 >> 6)) == (0xd800 >> 6))
+ break;
+ }
+ else if (numBytes == 3 && val >= (0x110000 >> 12))
+ break;
+ }
+ }
+ while (--numBytes);
+
+ if (numBytes != 0)
+ {
+ if ((flags & Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE) == 0)
+ {
+ // the following code to emit the 0xfffd chars as win32 Utf8 function.
+ // disable the folling line, if you need 0xfffd for each incorrect byte as in Escape mode
+ src += pos;
+ }
+ UTF_ERROR_UTF8
+ }
+
+ /*
+ if (val < MY_UTF8_RANGE(pos - 1))
+ UTF_ERROR_UTF8
+ */
+
+ #ifdef UTF_ESCAPE_BASE
+
+ if ((flags & Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT)
+ && IS_ESCAPE_POINT(val, 0))
+ {
+ // We will emit 3 utf16-Escape-16-21 points from one Escape-16 point (3 bytes)
+ UTF_ERROR_UTF8
+ }
+
+ #endif
+
+ /*
+ We don't expect virtual Escape-21 points in UTF-8 stream.
+ And we don't check for Escape-21.
+ So utf8-Escape-21 will be converted to another 3 utf16-Escape-21 points.
+ Maybe we could convert virtual utf8-Escape-21 to one utf16-Escape-21 point in some cases?
+ */
+
+ if (val < START_POINT_FOR_SURROGATE)
+ {
+ /*
+ if ((flags & Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR)
+ && IS_SURROGATE_POINT(val))
+ {
+ // We will emit 3 utf16-Escape-16-21 points from one Surrogate-16 point (3 bytes)
+ UTF_ERROR_UTF8
+ }
+ */
+ if (dest)
+ dest[destPos] = (wchar_t)val;
+ destPos++;
+ }
+ else
+ {
+ /*
+ if (val >= 0x110000)
+ {
+ // We will emit utf16-Escape-16-21 point from each source byte
+ UTF_ERROR_UTF8
+ }
+ */
+ if (dest)
+ {
+ dest[destPos + 0] = (wchar_t)(0xd800 - (0x10000 >> 10) + (val >> 10));
+ dest[destPos + 1] = (wchar_t)(0xdc00 + (val & 0x3ff));
+ }
+ destPos += 2;
+ }
+ src += pos;
+ }
+}
+
+
+
+#define MY_UTF8_HEAD(n, val) ((char)(MY_UTF8_START(n) + (val >> (6 * (n)))))
+#define MY_UTF8_CHAR(n, val) ((char)(0x80 + (((val) >> (6 * (n))) & 0x3F)))
+
+static size_t Utf16_To_Utf8_Calc(const wchar_t *src, const wchar_t *srcLim, unsigned flags)
+{
+ size_t size = (size_t)(srcLim - src);
+ for (;;)
+ {
+ if (src == srcLim)
+ return size;
+
+ UInt32 val = (UInt32)(*src++);
+
+ if (val < 0x80)
+ continue;
+
+ if (val < MY_UTF8_RANGE(1))
+ {
+ size++;
+ continue;
+ }
+
+ #ifdef UTF_ESCAPE_BASE
+
+ #if UTF_ESCAPE_PLANE != 0
+ if (flags & Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE)
+ if (IS_ESCAPE_POINT(val, UTF_ESCAPE_PLANE))
+ continue;
+ #endif
+
+ if (flags & Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE)
+ if (IS_ESCAPE_POINT(val, 0))
+ continue;
+
+ #endif
+
+ if (IS_SURROGATE_POINT(val))
+ {
+ // it's hack to UTF-8 encoding
+
+ if (val < 0xdc00 && src != srcLim)
+ {
+ const UInt32 c2 = (UInt32)*src;
+ if (c2 >= 0xdc00 && c2 < 0xe000)
+ src++;
+ }
+ size += 2;
+ continue;
+ }
+
+ #ifdef Z7_WCHART_IS_16BIT
+
+ size += 2;
+
+ #else
+
+ if (val < MY_UTF8_RANGE(2)) size += 2;
+ else if (val < MY_UTF8_RANGE(3)) size += 3;
+ else if (val < MY_UTF8_RANGE(4)) size += 4;
+ else if (val < MY_UTF8_RANGE(5)) size += 5;
+ else
+ #if MY_UTF8_NUM_TAIL_BYTES_MAX >= 6
+ size += 6;
+ #else
+ size += 3;
+ #endif
+
+ #endif
+ }
+}
+
+
+static char *Utf16_To_Utf8(char *dest, const wchar_t *src, const wchar_t *srcLim, unsigned flags)
+{
+ for (;;)
+ {
+ if (src == srcLim)
+ return dest;
+
+ UInt32 val = (UInt32)*src++;
+
+ if (val < 0x80)
+ {
+ *dest++ = (char)val;
+ continue;
+ }
+
+ if (val < MY_UTF8_RANGE(1))
+ {
+ dest[0] = MY_UTF8_HEAD(1, val);
+ dest[1] = MY_UTF8_CHAR(0, val);
+ dest += 2;
+ continue;
+ }
+
+ #ifdef UTF_ESCAPE_BASE
+
+ #if UTF_ESCAPE_PLANE != 0
+ /*
+ if (wchar_t is 32-bit)
+ && (Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE is set)
+ && (point is virtual escape plane)
+ we extract 8-bit byte from virtual HIGH-ESCAPE PLANE.
+ */
+ if (flags & Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE)
+ if (IS_ESCAPE_POINT(val, UTF_ESCAPE_PLANE))
+ {
+ *dest++ = (char)(val);
+ continue;
+ }
+ #endif // UTF_ESCAPE_PLANE != 0
+
+ /* if (Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE is defined)
+ we extract 8-bit byte from BMP-ESCAPE PLANE. */
+
+ if (flags & Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE)
+ if (IS_ESCAPE_POINT(val, 0))
+ {
+ *dest++ = (char)(val);
+ continue;
+ }
+
+ #endif // UTF_ESCAPE_BASE
+
+ if (IS_SURROGATE_POINT(val))
+ {
+ // it's hack to UTF-8 encoding
+ if (val < 0xdc00 && src != srcLim)
+ {
+ const UInt32 c2 = (UInt32)*src;
+ if (IS_LOW_SURROGATE_POINT(c2))
+ {
+ src++;
+ val = (((val - 0xd800) << 10) | (c2 - 0xdc00)) + 0x10000;
+ dest[0] = MY_UTF8_HEAD(3, val);
+ dest[1] = MY_UTF8_CHAR(2, val);
+ dest[2] = MY_UTF8_CHAR(1, val);
+ dest[3] = MY_UTF8_CHAR(0, val);
+ dest += 4;
+ continue;
+ }
+ }
+ if (flags & Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR)
+ val = UTF_REPLACEMENT_CHAR; // WIN32 function does it
+ }
+
+ #ifndef Z7_WCHART_IS_16BIT
+ if (val < MY_UTF8_RANGE(2))
+ #endif
+ {
+ dest[0] = MY_UTF8_HEAD(2, val);
+ dest[1] = MY_UTF8_CHAR(1, val);
+ dest[2] = MY_UTF8_CHAR(0, val);
+ dest += 3;
+ continue;
+ }
+
+ #ifndef Z7_WCHART_IS_16BIT
+
+ // we don't expect this case. so we can throw exception
+ // throw 20210407;
+
+ char b;
+ unsigned numBits;
+ if (val < MY_UTF8_RANGE(3)) { numBits = 6 * 3; b = MY_UTF8_HEAD(3, val); }
+ else if (val < MY_UTF8_RANGE(4)) { numBits = 6 * 4; b = MY_UTF8_HEAD(4, val); }
+ else if (val < MY_UTF8_RANGE(5)) { numBits = 6 * 5; b = MY_UTF8_HEAD(5, val); }
+ #if MY_UTF8_NUM_TAIL_BYTES_MAX >= 6
+ else { numBits = 6 * 6; b = (char)MY_UTF8_START(6); }
+ #else
+ else
+ {
+ val = UTF_REPLACEMENT_CHAR;
+ { numBits = 6 * 3; b = MY_UTF8_HEAD(3, val); }
+ }
+ #endif
+
+ *dest++ = b;
+
+ do
+ {
+ numBits -= 6;
+ *dest++ = (char)(0x80 + ((val >> numBits) & 0x3F));
+ }
+ while (numBits != 0);
+
+ #endif
+ }
+}
+
+bool Convert_UTF8_Buf_To_Unicode(const char *src, size_t srcSize, UString &dest, unsigned flags)
+{
+ dest.Empty();
+ size_t destLen = 0;
+ Utf8_To_Utf16(NULL, &destLen, src, src + srcSize, flags);
+ bool res = Utf8_To_Utf16(dest.GetBuf((unsigned)destLen), &destLen, src, src + srcSize, flags);
+ dest.ReleaseBuf_SetEnd((unsigned)destLen);
+ return res;
+}
+
+bool ConvertUTF8ToUnicode_Flags(const AString &src, UString &dest, unsigned flags)
+{
+ return Convert_UTF8_Buf_To_Unicode(src, src.Len(), dest, flags);
+}
+
+
+static
+unsigned g_UTF8_To_Unicode_Flags =
+ Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+ #ifndef Z7_WCHART_IS_16BIT
+ | Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+ #ifdef MY_UTF8_RAW_NON_UTF8_SUPPORTED
+ | Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
+ #endif
+ #endif
+ ;
+
+
+/*
+bool ConvertUTF8ToUnicode_boolRes(const AString &src, UString &dest)
+{
+ return ConvertUTF8ToUnicode_Flags(src, dest, g_UTF8_To_Unicode_Flags);
+}
+*/
+
+bool ConvertUTF8ToUnicode(const AString &src, UString &dest)
+{
+ return ConvertUTF8ToUnicode_Flags(src, dest, g_UTF8_To_Unicode_Flags);
+}
+
+void Print_UString(const UString &a);
+
+void ConvertUnicodeToUTF8_Flags(const UString &src, AString &dest, unsigned flags)
+{
+ /*
+ if (src.Len()== 24)
+ throw "202104";
+ */
+ dest.Empty();
+ const size_t destLen = Utf16_To_Utf8_Calc(src, src.Ptr(src.Len()), flags);
+ char *destStart = dest.GetBuf((unsigned)destLen);
+ const char *destEnd = Utf16_To_Utf8(destStart, src, src.Ptr(src.Len()), flags);
+ dest.ReleaseBuf_SetEnd((unsigned)destLen);
+ // printf("\nlen = %d\n", src.Len());
+ if (destLen != (size_t)(destEnd - destStart))
+ {
+ /*
+ // dest.ReleaseBuf_SetEnd((unsigned)(destEnd - destStart));
+ printf("\nlen = %d\n", (unsigned)destLen);
+ printf("\n(destEnd - destStart) = %d\n", (unsigned)(destEnd - destStart));
+ printf("\n");
+ // Print_UString(src);
+ printf("\n");
+ // printf("\nlen = %d\n", destLen);
+ */
+ throw 20210406;
+ }
+}
+
+
+
+unsigned g_Unicode_To_UTF8_Flags =
+ // Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE
+ 0
+ #ifndef _WIN32
+ #ifdef MY_UTF8_RAW_NON_UTF8_SUPPORTED
+ | Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE
+ #else
+ | Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR
+ #endif
+ #endif
+ ;
+
+void ConvertUnicodeToUTF8(const UString &src, AString &dest)
+{
+ ConvertUnicodeToUTF8_Flags(src, dest, g_Unicode_To_UTF8_Flags);
+}
+
+void Convert_Unicode_To_UTF8_Buf(const UString &src, CByteBuffer &dest)
+{
+ const unsigned flags = g_Unicode_To_UTF8_Flags;
+ dest.Free();
+ const size_t destLen = Utf16_To_Utf8_Calc(src, src.Ptr(src.Len()), flags);
+ dest.Alloc(destLen);
+ const char *destEnd = Utf16_To_Utf8((char *)(void *)(Byte *)dest, src, src.Ptr(src.Len()), flags);
+ if (destLen != (size_t)(destEnd - (char *)(void *)(Byte *)dest))
+ throw 202104;
+}
+
+/*
+
+#ifndef _WIN32
+void Convert_UTF16_To_UTF32(const UString &src, UString &dest)
+{
+ dest.Empty();
+ for (size_t i = 0; i < src.Len();)
+ {
+ wchar_t c = src[i++];
+ if (c >= 0xd800 && c < 0xdc00 && i < src.Len())
+ {
+ const wchar_t c2 = src[i];
+ if (c2 >= 0xdc00 && c2 < 0x10000)
+ {
+ // printf("\nSurragate [%d]: %4x %4x -> ", i, (int)c, (int)c2);
+ c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+ // printf("%4x\n", (int)c);
+ i++;
+ }
+ }
+ dest += c;
+ }
+}
+
+void Convert_UTF32_To_UTF16(const UString &src, UString &dest)
+{
+ dest.Empty();
+ for (size_t i = 0; i < src.Len();)
+ {
+ wchar_t w = src[i++];
+ if (w >= 0x10000 && w < 0x110000)
+ {
+ w -= 0x10000;
+ dest += (wchar_t)((unsigned)0xd800 + (((unsigned)w >> 10) & 0x3ff));
+ w = 0xdc00 + (w & 0x3ff);
+ }
+ dest += w;
+ }
+}
+
+bool UTF32_IsThere_BigPoint(const UString &src)
+{
+ for (size_t i = 0; i < src.Len();)
+ {
+ const UInt32 c = (UInt32)src[i++];
+ if (c >= 0x110000)
+ return true;
+ }
+ return false;
+}
+
+bool Unicode_IsThere_BmpEscape(const UString &src)
+{
+ for (size_t i = 0; i < src.Len();)
+ {
+ const UInt32 c = (UInt32)src[i++];
+ if (IS_ESCAPE_POINT(c, 0))
+ return true;
+ }
+ return false;
+}
+
+
+#endif
+
+bool Unicode_IsThere_Utf16SurrogateError(const UString &src)
+{
+ for (size_t i = 0; i < src.Len();)
+ {
+ const UInt32 val = (UInt32)src[i++];
+ if (IS_SURROGATE_POINT(val))
+ {
+ // it's hack to UTF-8 encoding
+ if (val >= 0xdc00 || i == src.Len())
+ return true;
+ const UInt32 c2 = (UInt32)*src;
+ if (!IS_LOW_SURROGATE_POINT(c2))
+ return true;
+ }
+ }
+ return false;
+}
+*/
+
+#ifndef Z7_WCHART_IS_16BIT
+
+void Convert_UnicodeEsc16_To_UnicodeEscHigh
+#if UTF_ESCAPE_PLANE == 0
+ (UString &) {}
+#else
+ (UString &s)
+{
+ const unsigned len = s.Len();
+ for (unsigned i = 0; i < len; i++)
+ {
+ wchar_t c = s[i];
+ if (IS_ESCAPE_POINT(c, 0))
+ {
+ c += UTF_ESCAPE_PLANE;
+ s.ReplaceOneCharAtPos(i, c);
+ }
+ }
+}
+#endif
+#endif
diff --git a/CPP/Common/UTFConvert.h b/CPP/Common/UTFConvert.h
index 1183170..94a8024 100644
--- a/CPP/Common/UTFConvert.h
+++ b/CPP/Common/UTFConvert.h
@@ -1,12 +1,384 @@
-// Common/UTFConvert.h
-
-#ifndef __COMMON_UTF_CONVERT_H
-#define __COMMON_UTF_CONVERT_H
-
-#include "MyString.h"
-
-bool CheckUTF8(const char *src, bool allowReduced = false) throw();
-bool ConvertUTF8ToUnicode(const AString &utfString, UString &resultString);
-void ConvertUnicodeToUTF8(const UString &unicodeString, AString &resultString);
-
-#endif
+// Common/UTFConvert.h
+
+#ifndef ZIP7_INC_COMMON_UTF_CONVERT_H
+#define ZIP7_INC_COMMON_UTF_CONVERT_H
+
+#include "MyBuffer.h"
+#include "MyString.h"
+
+struct CUtf8Check
+{
+ // Byte MaxByte; // in original src stream
+ bool NonUtf;
+ bool ZeroChar;
+ bool SingleSurrogate;
+ bool Escape;
+ bool Truncated;
+ UInt32 MaxHighPoint; // only for points >= 0x80
+
+ CUtf8Check() { Clear(); }
+
+ void Clear()
+ {
+ // MaxByte = 0;
+ NonUtf = false;
+ ZeroChar = false;
+ SingleSurrogate = false;
+ Escape = false;
+ Truncated = false;
+ MaxHighPoint = 0;
+ }
+
+ void Update(const CUtf8Check &c)
+ {
+ if (c.NonUtf) NonUtf = true;
+ if (c.ZeroChar) ZeroChar = true;
+ if (c.SingleSurrogate) SingleSurrogate = true;
+ if (c.Escape) Escape = true;
+ if (c.Truncated) Truncated = true;
+ if (MaxHighPoint < c.MaxHighPoint) MaxHighPoint = c.MaxHighPoint;
+ }
+
+ void PrintStatus(AString &s) const
+ {
+ s.Empty();
+
+ // s.Add_OptSpaced("MaxByte=");
+ // s.Add_UInt32(MaxByte);
+
+ if (NonUtf) s.Add_OptSpaced("non-UTF8");
+ if (ZeroChar) s.Add_OptSpaced("ZeroChar");
+ if (SingleSurrogate) s.Add_OptSpaced("SingleSurrogate");
+ if (Escape) s.Add_OptSpaced("Escape");
+ if (Truncated) s.Add_OptSpaced("Truncated");
+
+ if (MaxHighPoint != 0)
+ {
+ s.Add_OptSpaced("MaxUnicode=");
+ s.Add_UInt32(MaxHighPoint);
+ }
+ }
+
+
+ bool IsOK(bool allowReduced = false) const
+ {
+ if (NonUtf || SingleSurrogate || ZeroChar)
+ return false;
+ if (MaxHighPoint >= 0x110000)
+ return false;
+ if (Truncated && !allowReduced)
+ return false;
+ return true;
+ }
+
+ // it checks full buffer as specified in (size) and it doesn't stop on zero char
+ void Check_Buf(const char *src, size_t size) throw();
+
+ void Check_AString(const AString &s) throw()
+ {
+ Check_Buf(s.Ptr(), s.Len());
+ }
+};
+
+/*
+if (allowReduced == false) - all UTF-8 character sequences must be finished.
+if (allowReduced == true) - it allows truncated last character-Utf8-sequence
+*/
+
+bool Check_UTF8_Buf(const char *src, size_t size, bool allowReduced) throw();
+bool CheckUTF8_AString(const AString &s) throw();
+
+#define Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR (1 << 0)
+#define Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE (1 << 1)
+#define Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT (1 << 2)
+
+/*
+Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+
+ if (flag is NOT set)
+ {
+ it processes SINGLE-SURROGATE-8 as valid Unicode point.
+ it converts SINGLE-SURROGATE-8 to SINGLE-SURROGATE-16
+ Note: some sequencies of two SINGLE-SURROGATE-8 points
+ will generate correct SURROGATE-16-PAIR, and
+ that SURROGATE-16-PAIR later will be converted to correct
+ UTF8-SURROGATE-21 point. So we don't restore original
+ STR-8 sequence in that case.
+ }
+
+ if (flag is set)
+ {
+ if (Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE is defined)
+ it generates ESCAPE for SINGLE-SURROGATE-8,
+ if (Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE is not defined)
+ it generates U+fffd for SINGLE-SURROGATE-8,
+ }
+
+
+Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+
+ if (flag is NOT set)
+ it generates (U+fffd) code for non-UTF-8 (invalid) characters
+
+ if (flag is set)
+ {
+ It generates (ESCAPE) codes for NON-UTF-8 (invalid) characters.
+ And later we can restore original UTF-8-RAW characters from (ESCAPE-16-21) codes.
+ }
+
+Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
+
+ if (flag is NOT set)
+ {
+ it process ESCAPE-8 points as another Unicode points.
+ In Linux: ESCAPE-16 will mean two different ESCAPE-8 seqences,
+ so we need HIGH-ESCAPE-PLANE-21 to restore UTF-8-RAW -> UTF-16 -> UTF-8-RAW
+ }
+
+ if (flag is set)
+ {
+ it generates ESCAPE-16-21 for ESCAPE-8 points
+ so we can restore UTF-8-RAW -> UTF-16 -> UTF-8-RAW without HIGH-ESCAPE-PLANE-21.
+ }
+
+
+Main USE CASES with UTF-8 <-> UTF-16 conversions:
+
+ WIN32: UTF-16-RAW -> UTF-8 (Archive) -> UTF-16-RAW
+ {
+ set Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+ Do NOT set Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+ Do NOT set Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
+
+ So we restore original SINGLE-SURROGATE-16 from single SINGLE-SURROGATE-8.
+ }
+
+ Linux: UTF-8-RAW -> UTF-16 (Intermediate / Archive) -> UTF-8-RAW
+ {
+ we want restore original UTF-8-RAW sequence later from that ESCAPE-16.
+ Set the flags:
+ Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+ Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+ Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
+ }
+
+ MacOS: UTF-8-RAW -> UTF-16 (Intermediate / Archive) -> UTF-8-RAW
+ {
+ we want to restore correct UTF-8 without any BMP processing:
+ Set the flags:
+ Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+ Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+ }
+
+*/
+
+// zero char is not allowed in (src) buf
+bool Convert_UTF8_Buf_To_Unicode(const char *src, size_t srcSize, UString &dest, unsigned flags = 0);
+
+bool ConvertUTF8ToUnicode_Flags(const AString &src, UString &dest, unsigned flags = 0);
+bool ConvertUTF8ToUnicode(const AString &src, UString &dest);
+
+#define Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR (1 << 8)
+#define Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE (1 << 9)
+// #define Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE (1 << 10)
+
+/*
+Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR
+
+ if (flag is NOT set)
+ {
+ we extract SINGLE-SURROGATE as normal UTF-8
+
+ In Windows : for UTF-16-RAW <-> UTF-8 (archive) <-> UTF-16-RAW in .
+
+ In Linux :
+ use-case-1: UTF-8 -> UTF-16 -> UTF-8 doesn't generate UTF-16 SINGLE-SURROGATE,
+ if (Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR) is used.
+ use-case 2: UTF-16-7z (with SINGLE-SURROGATE from Windows) -> UTF-8 (Linux)
+ will generate SINGLE-SURROGATE-UTF-8 here.
+ }
+
+ if (flag is set)
+ {
+ we generate UTF_REPLACEMENT_CHAR (0xfffd) for SINGLE_SURROGATE
+ it can be used for compatibility mode with WIN32 UTF function
+ or if we want UTF-8 stream without any errors
+ }
+
+
+Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE
+
+ if (flag is NOT set) it doesn't extract raw 8-bit symbol from Escape-Plane-16
+ if (flag is set) it extracts raw 8-bit symbol from Escape-Plane-16
+
+ in Linux we need some way to extract NON-UTF8 RAW 8-bits from BMP (UTF-16 7z archive):
+ if (we use High-Escape-Plane), we can transfer BMP escapes to High-Escape-Plane.
+ if (we don't use High-Escape-Plane), we must use Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE.
+
+
+Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE
+ // that flag affects the code only if (wchar_t is 32-bit)
+ // that mode with high-escape can be disabled now in UTFConvert.cpp
+ if (flag is NOT set)
+ it doesn't extract raw 8-bit symbol from High-Escape-Plane
+ if (flag is set)
+ it extracts raw 8-bit symbol from High-Escape-Plane
+
+Main use cases:
+
+WIN32 : UTF-16-RAW -> UTF-8 (archive) -> UTF-16-RAW
+ {
+ Do NOT set Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE.
+ Do NOT set Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR.
+ So we restore original UTF-16-RAW.
+ }
+
+Linix : UTF-8 with Escapes -> UTF-16 (7z archive) -> UTF-8 with Escapes
+ set Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE to extract non-UTF from 7z archive
+ set Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE for intermediate UTF-16.
+ Note: high esacape mode can be ignored now in UTFConvert.cpp
+
+macOS:
+ the system doesn't support incorrect UTF-8 in file names.
+ set Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR
+*/
+
+extern unsigned g_Unicode_To_UTF8_Flags;
+
+void ConvertUnicodeToUTF8_Flags(const UString &src, AString &dest, unsigned flags = 0);
+void ConvertUnicodeToUTF8(const UString &src, AString &dest);
+
+void Convert_Unicode_To_UTF8_Buf(const UString &src, CByteBuffer &dest);
+
+/*
+#ifndef _WIN32
+void Convert_UTF16_To_UTF32(const UString &src, UString &dest);
+void Convert_UTF32_To_UTF16(const UString &src, UString &dest);
+bool UTF32_IsThere_BigPoint(const UString &src);
+bool Unicode_IsThere_BmpEscape(const UString &src);
+#endif
+
+bool Unicode_IsThere_Utf16SurrogateError(const UString &src);
+*/
+
+#ifdef Z7_WCHART_IS_16BIT
+#define Convert_UnicodeEsc16_To_UnicodeEscHigh(s)
+#else
+void Convert_UnicodeEsc16_To_UnicodeEscHigh(UString &s);
+#endif
+
+/*
+// #include "../../C/CpuArch.h"
+
+// ---------- Utf16 Little endian functions ----------
+
+// We store 16-bit surrogates even in 32-bit WCHARs in Linux.
+// So now we don't use the following code:
+
+#if WCHAR_MAX > 0xffff
+
+// void *p : pointer to src bytes stream
+// size_t len : num Utf16 characters : it can include or not include NULL character
+
+inline size_t Utf16LE__Get_Num_WCHARs(const void *p, size_t len)
+{
+ #if WCHAR_MAX > 0xffff
+ size_t num_wchars = 0;
+ for (size_t i = 0; i < len; i++)
+ {
+ wchar_t c = GetUi16(p);
+ p = (const void *)((const Byte *)p + 2);
+ if (c >= 0xd800 && c < 0xdc00 && i + 1 != len)
+ {
+ wchar_t c2 = GetUi16(p);
+ if (c2 >= 0xdc00 && c2 < 0xe000)
+ {
+ c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+ p = (const void *)((const Byte *)p + 2);
+ i++;
+ }
+ }
+ num_wchars++;
+ }
+ return num_wchars;
+ #else
+ UNUSED_VAR(p)
+ return len;
+ #endif
+}
+
+// #include <stdio.h>
+
+inline wchar_t *Utf16LE__To_WCHARs_Sep(const void *p, size_t len, wchar_t *dest)
+{
+ for (size_t i = 0; i < len; i++)
+ {
+ wchar_t c = GetUi16(p);
+ p = (const void *)((const Byte *)p + 2);
+
+ #if WCHAR_PATH_SEPARATOR != L'/'
+ if (c == L'/')
+ c = WCHAR_PATH_SEPARATOR;
+ #endif
+
+ #if WCHAR_MAX > 0xffff
+
+ if (c >= 0xd800 && c < 0xdc00 && i + 1 != len)
+ {
+ wchar_t c2 = GetUi16(p);
+ if (c2 >= 0xdc00 && c2 < 0xe000)
+ {
+ // printf("\nSurragate : %4x %4x -> ", (int)c, (int)c2);
+ c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+ p = (const void *)((const Byte *)p + 2);
+ i++;
+ // printf("%4x\n", (int)c);
+ }
+ }
+
+ #endif
+
+ *dest++ = c;
+ }
+ return dest;
+}
+
+
+inline size_t Get_Num_Utf16_chars_from_wchar_string(const wchar_t *p)
+{
+ size_t num = 0;
+ for (;;)
+ {
+ wchar_t c = *p++;
+ if (c == 0)
+ return num;
+ num += ((c >= 0x10000 && c < 0x110000) ? 2 : 1);
+ }
+ return num;
+}
+
+inline Byte *wchars_to_Utf16LE(const wchar_t *p, Byte *dest)
+{
+ for (;;)
+ {
+ wchar_t c = *p++;
+ if (c == 0)
+ return dest;
+ if (c >= 0x10000 && c < 0x110000)
+ {
+ SetUi16(dest , (UInt16)(0xd800 + ((c >> 10) & 0x3FF)));
+ SetUi16(dest + 2, (UInt16)(0xdc00 + ( c & 0x3FF)));
+ dest += 4;
+ }
+ else
+ {
+ SetUi16(dest, c);
+ dest += 2;
+ }
+ }
+}
+
+#endif
+*/
+
+#endif
diff --git a/CPP/Common/Wildcard.cpp b/CPP/Common/Wildcard.cpp
index 43e4baa..798cbd9 100644
--- a/CPP/Common/Wildcard.cpp
+++ b/CPP/Common/Wildcard.cpp
@@ -1,676 +1,788 @@
-// Common/Wildcard.cpp
-
-#include "StdAfx.h"
-
-#include "Wildcard.h"
-
-bool g_CaseSensitive =
- #ifdef _WIN32
- false;
- #else
- true;
- #endif
-
-
-bool IsPath1PrefixedByPath2(const wchar_t *s1, const wchar_t *s2)
-{
- if (g_CaseSensitive)
- return IsString1PrefixedByString2(s1, s2);
- return IsString1PrefixedByString2_NoCase(s1, s2);
-}
-
-int CompareFileNames(const wchar_t *s1, const wchar_t *s2) STRING_UNICODE_THROW
-{
- if (g_CaseSensitive)
- return MyStringCompare(s1, s2);
- return MyStringCompareNoCase(s1, s2);
-}
-
-#ifndef USE_UNICODE_FSTRING
-int CompareFileNames(const char *s1, const char *s2)
-{
- const UString u1 = fs2us(s1);
- const UString u2 = fs2us(s2);
- if (g_CaseSensitive)
- return MyStringCompare(u1, u2);
- return MyStringCompareNoCase(u1, u2);
-}
-#endif
-
-// -----------------------------------------
-// this function compares name with mask
-// ? - any char
-// * - any char or empty
-
-static bool EnhancedMaskTest(const wchar_t *mask, const wchar_t *name)
-{
- for (;;)
- {
- wchar_t m = *mask;
- wchar_t c = *name;
- if (m == 0)
- return (c == 0);
- if (m == '*')
- {
- if (EnhancedMaskTest(mask + 1, name))
- return true;
- if (c == 0)
- return false;
- }
- else
- {
- if (m == '?')
- {
- if (c == 0)
- return false;
- }
- else if (m != c)
- if (g_CaseSensitive || MyCharUpper(m) != MyCharUpper(c))
- return false;
- mask++;
- }
- name++;
- }
-}
-
-// --------------------------------------------------
-// Splits path to strings
-
-void SplitPathToParts(const UString &path, UStringVector &pathParts)
-{
- pathParts.Clear();
- unsigned len = path.Len();
- if (len == 0)
- return;
- UString name;
- unsigned prev = 0;
- for (unsigned i = 0; i < len; i++)
- if (IsPathSepar(path[i]))
- {
- name.SetFrom(path.Ptr(prev), i - prev);
- pathParts.Add(name);
- prev = i + 1;
- }
- name.SetFrom(path.Ptr(prev), len - prev);
- pathParts.Add(name);
-}
-
-void SplitPathToParts_2(const UString &path, UString &dirPrefix, UString &name)
-{
- const wchar_t *start = path;
- const wchar_t *p = start + path.Len();
- for (; p != start; p--)
- if (IsPathSepar(*(p - 1)))
- break;
- dirPrefix.SetFrom(path, (unsigned)(p - start));
- name = p;
-}
-
-void SplitPathToParts_Smart(const UString &path, UString &dirPrefix, UString &name)
-{
- const wchar_t *start = path;
- const wchar_t *p = start + path.Len();
- if (p != start)
- {
- if (IsPathSepar(*(p - 1)))
- p--;
- for (; p != start; p--)
- if (IsPathSepar(*(p - 1)))
- break;
- }
- dirPrefix.SetFrom(path, (unsigned)(p - start));
- name = p;
-}
-
-/*
-UString ExtractDirPrefixFromPath(const UString &path)
-{
- return path.Left(path.ReverseFind_PathSepar() + 1));
-}
-*/
-
-UString ExtractFileNameFromPath(const UString &path)
-{
- return UString(path.Ptr(path.ReverseFind_PathSepar() + 1));
-}
-
-
-bool DoesWildcardMatchName(const UString &mask, const UString &name)
-{
- return EnhancedMaskTest(mask, name);
-}
-
-bool DoesNameContainWildcard(const UString &path)
-{
- for (unsigned i = 0; i < path.Len(); i++)
- {
- wchar_t c = path[i];
- if (c == '*' || c == '?')
- return true;
- }
- return false;
-}
-
-
-// ----------------------------------------------------------'
-// NWildcard
-
-namespace NWildcard {
-
-/*
-
-M = MaskParts.Size();
-N = TestNameParts.Size();
-
- File Dir
-ForFile rec M<=N [N-M, N) -
-!ForDir nonrec M=N [0, M) -
-
-ForDir rec M<N [0, M) ... [N-M-1, N-1) same as ForBoth-File
-!ForFile nonrec [0, M) same as ForBoth-File
-
-ForFile rec m<=N [0, M) ... [N-M, N) same as ForBoth-File
-ForDir nonrec [0, M) same as ForBoth-File
-
-*/
-
-bool CItem::AreAllAllowed() const
-{
- return ForFile && ForDir && WildcardMatching && PathParts.Size() == 1 && PathParts.Front() == L"*";
-}
-
-bool CItem::CheckPath(const UStringVector &pathParts, bool isFile) const
-{
- if (!isFile && !ForDir)
- return false;
-
- /*
- if (PathParts.IsEmpty())
- {
- // PathParts.IsEmpty() means all items (universal wildcard)
- if (!isFile)
- return true;
- if (pathParts.Size() <= 1)
- return ForFile;
- return (ForDir || Recursive && ForFile);
- }
- */
-
- int delta = (int)pathParts.Size() - (int)PathParts.Size();
- if (delta < 0)
- return false;
- int start = 0;
- int finish = 0;
-
- if (isFile)
- {
- if (!ForDir)
- {
- if (Recursive)
- start = delta;
- else if (delta !=0)
- return false;
- }
- if (!ForFile && delta == 0)
- return false;
- }
-
- if (Recursive)
- {
- finish = delta;
- if (isFile && !ForFile)
- finish = delta - 1;
- }
-
- for (int d = start; d <= finish; d++)
- {
- unsigned i;
- for (i = 0; i < PathParts.Size(); i++)
- {
- if (WildcardMatching)
- {
- if (!DoesWildcardMatchName(PathParts[i], pathParts[i + d]))
- break;
- }
- else
- {
- if (CompareFileNames(PathParts[i], pathParts[i + d]) != 0)
- break;
- }
- }
- if (i == PathParts.Size())
- return true;
- }
- return false;
-}
-
-bool CCensorNode::AreAllAllowed() const
-{
- if (!Name.IsEmpty() ||
- !SubNodes.IsEmpty() ||
- !ExcludeItems.IsEmpty() ||
- IncludeItems.Size() != 1)
- return false;
- return IncludeItems.Front().AreAllAllowed();
-}
-
-int CCensorNode::FindSubNode(const UString &name) const
-{
- FOR_VECTOR (i, SubNodes)
- if (CompareFileNames(SubNodes[i].Name, name) == 0)
- return i;
- return -1;
-}
-
-void CCensorNode::AddItemSimple(bool include, CItem &item)
-{
- if (include)
- IncludeItems.Add(item);
- else
- ExcludeItems.Add(item);
-}
-
-void CCensorNode::AddItem(bool include, CItem &item, int ignoreWildcardIndex)
-{
- if (item.PathParts.Size() <= 1)
- {
- if (item.PathParts.Size() != 0 && item.WildcardMatching)
- {
- if (!DoesNameContainWildcard(item.PathParts.Front()))
- item.WildcardMatching = false;
- }
- AddItemSimple(include, item);
- return;
- }
- const UString &front = item.PathParts.Front();
-
- // WIN32 doesn't support wildcards in file names
- if (item.WildcardMatching
- && ignoreWildcardIndex != 0
- && DoesNameContainWildcard(front))
- {
- AddItemSimple(include, item);
- return;
- }
- int index = FindSubNode(front);
- if (index < 0)
- index = SubNodes.Add(CCensorNode(front, this));
- item.PathParts.Delete(0);
- SubNodes[index].AddItem(include, item, ignoreWildcardIndex - 1);
-}
-
-void CCensorNode::AddItem(bool include, const UString &path, bool recursive, bool forFile, bool forDir, bool wildcardMatching)
-{
- CItem item;
- SplitPathToParts(path, item.PathParts);
- item.Recursive = recursive;
- item.ForFile = forFile;
- item.ForDir = forDir;
- item.WildcardMatching = wildcardMatching;
- AddItem(include, item);
-}
-
-bool CCensorNode::NeedCheckSubDirs() const
-{
- FOR_VECTOR (i, IncludeItems)
- {
- const CItem &item = IncludeItems[i];
- if (item.Recursive || item.PathParts.Size() > 1)
- return true;
- }
- return false;
-}
-
-bool CCensorNode::AreThereIncludeItems() const
-{
- if (IncludeItems.Size() > 0)
- return true;
- FOR_VECTOR (i, SubNodes)
- if (SubNodes[i].AreThereIncludeItems())
- return true;
- return false;
-}
-
-bool CCensorNode::CheckPathCurrent(bool include, const UStringVector &pathParts, bool isFile) const
-{
- const CObjectVector<CItem> &items = include ? IncludeItems : ExcludeItems;
- FOR_VECTOR (i, items)
- if (items[i].CheckPath(pathParts, isFile))
- return true;
- return false;
-}
-
-bool CCensorNode::CheckPathVect(const UStringVector &pathParts, bool isFile, bool &include) const
-{
- if (CheckPathCurrent(false, pathParts, isFile))
- {
- include = false;
- return true;
- }
- include = true;
- bool finded = CheckPathCurrent(true, pathParts, isFile);
- if (pathParts.Size() <= 1)
- return finded;
- int index = FindSubNode(pathParts.Front());
- if (index >= 0)
- {
- UStringVector pathParts2 = pathParts;
- pathParts2.Delete(0);
- if (SubNodes[index].CheckPathVect(pathParts2, isFile, include))
- return true;
- }
- return finded;
-}
-
-/*
-bool CCensorNode::CheckPath2(bool isAltStream, const UString &path, bool isFile, bool &include) const
-{
- UStringVector pathParts;
- SplitPathToParts(path, pathParts);
- if (CheckPathVect(pathParts, isFile, include))
- {
- if (!include || !isAltStream)
- return true;
- }
- if (isAltStream && !pathParts.IsEmpty())
- {
- UString &back = pathParts.Back();
- int pos = back.Find(L':');
- if (pos > 0)
- {
- back.DeleteFrom(pos);
- return CheckPathVect(pathParts, isFile, include);
- }
- }
- return false;
-}
-
-bool CCensorNode::CheckPath(bool isAltStream, const UString &path, bool isFile) const
-{
- bool include;
- if (CheckPath2(isAltStream, path, isFile, include))
- return include;
- return false;
-}
-*/
-
-bool CCensorNode::CheckPathToRoot(bool include, UStringVector &pathParts, bool isFile) const
-{
- if (CheckPathCurrent(include, pathParts, isFile))
- return true;
- if (Parent == 0)
- return false;
- pathParts.Insert(0, Name);
- return Parent->CheckPathToRoot(include, pathParts, isFile);
-}
-
-/*
-bool CCensorNode::CheckPathToRoot(bool include, const UString &path, bool isFile) const
-{
- UStringVector pathParts;
- SplitPathToParts(path, pathParts);
- return CheckPathToRoot(include, pathParts, isFile);
-}
-*/
-
-void CCensorNode::AddItem2(bool include, const UString &path, bool recursive, bool wildcardMatching)
-{
- if (path.IsEmpty())
- return;
- bool forFile = true;
- bool forFolder = true;
- UString path2 (path);
- if (IsPathSepar(path.Back()))
- {
- path2.DeleteBack();
- forFile = false;
- }
- AddItem(include, path2, recursive, forFile, forFolder, wildcardMatching);
-}
-
-void CCensorNode::ExtendExclude(const CCensorNode &fromNodes)
-{
- ExcludeItems += fromNodes.ExcludeItems;
- FOR_VECTOR (i, fromNodes.SubNodes)
- {
- const CCensorNode &node = fromNodes.SubNodes[i];
- int subNodeIndex = FindSubNode(node.Name);
- if (subNodeIndex < 0)
- subNodeIndex = SubNodes.Add(CCensorNode(node.Name, this));
- SubNodes[subNodeIndex].ExtendExclude(node);
- }
-}
-
-int CCensor::FindPrefix(const UString &prefix) const
-{
- FOR_VECTOR (i, Pairs)
- if (CompareFileNames(Pairs[i].Prefix, prefix) == 0)
- return i;
- return -1;
-}
-
-#ifdef _WIN32
-
-bool IsDriveColonName(const wchar_t *s)
-{
- wchar_t c = s[0];
- return c != 0 && s[1] == ':' && s[2] == 0 && (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
-}
-
-unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts)
-{
- if (pathParts.IsEmpty())
- return 0;
-
- unsigned testIndex = 0;
- if (pathParts[0].IsEmpty())
- {
- if (pathParts.Size() < 4
- || !pathParts[1].IsEmpty()
- || pathParts[2] != L"?")
- return 0;
- testIndex = 3;
- }
- if (NWildcard::IsDriveColonName(pathParts[testIndex]))
- return testIndex + 1;
- return 0;
-}
-
-#endif
-
-static unsigned GetNumPrefixParts(const UStringVector &pathParts)
-{
- if (pathParts.IsEmpty())
- return 0;
-
- #ifdef _WIN32
-
- if (IsDriveColonName(pathParts[0]))
- return 1;
- if (!pathParts[0].IsEmpty())
- return 0;
-
- if (pathParts.Size() == 1)
- return 1;
- if (!pathParts[1].IsEmpty())
- return 1;
- if (pathParts.Size() == 2)
- return 2;
- if (pathParts[2] == L".")
- return 3;
-
- unsigned networkParts = 2;
- if (pathParts[2] == L"?")
- {
- if (pathParts.Size() == 3)
- return 3;
- if (IsDriveColonName(pathParts[3]))
- return 4;
- if (!pathParts[3].IsEqualTo_Ascii_NoCase("UNC"))
- return 3;
- networkParts = 4;
- }
-
- networkParts +=
- // 2; // server/share
- 1; // server
- if (pathParts.Size() <= networkParts)
- return pathParts.Size();
- return networkParts;
-
- #else
-
- return pathParts[0].IsEmpty() ? 1 : 0;
-
- #endif
-}
-
-void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &path, bool recursive, bool wildcardMatching)
-{
- if (path.IsEmpty())
- throw "Empty file path";
-
- UStringVector pathParts;
- SplitPathToParts(path, pathParts);
-
- bool forFile = true;
- if (pathParts.Back().IsEmpty())
- {
- forFile = false;
- pathParts.DeleteBack();
- }
-
- UString prefix;
-
- int ignoreWildcardIndex = -1;
-
- // #ifdef _WIN32
- // we ignore "?" wildcard in "\\?\" prefix.
- if (pathParts.Size() >= 3
- && pathParts[0].IsEmpty()
- && pathParts[1].IsEmpty()
- && pathParts[2] == L"?")
- ignoreWildcardIndex = 2;
- // #endif
-
- if (pathMode != k_AbsPath)
- {
- ignoreWildcardIndex = -1;
-
- const unsigned numPrefixParts = GetNumPrefixParts(pathParts);
- unsigned numSkipParts = numPrefixParts;
-
- if (pathMode != k_FullPath)
- {
- if (numPrefixParts != 0 && pathParts.Size() > numPrefixParts)
- numSkipParts = pathParts.Size() - 1;
- }
- {
- int dotsIndex = -1;
- for (unsigned i = numPrefixParts; i < pathParts.Size(); i++)
- {
- const UString &part = pathParts[i];
- if (part == L".." || part == L".")
- dotsIndex = i;
- }
-
- if (dotsIndex >= 0)
- if (dotsIndex == (int)pathParts.Size() - 1)
- numSkipParts = pathParts.Size();
- else
- numSkipParts = pathParts.Size() - 1;
- }
-
- for (unsigned i = 0; i < numSkipParts; i++)
- {
- {
- const UString &front = pathParts.Front();
- // WIN32 doesn't support wildcards in file names
- if (wildcardMatching)
- if (i >= numPrefixParts && DoesNameContainWildcard(front))
- break;
- prefix += front;
- prefix.Add_PathSepar();
- }
- pathParts.Delete(0);
- }
- }
-
- int index = FindPrefix(prefix);
- if (index < 0)
- index = Pairs.Add(CPair(prefix));
-
- if (pathMode != k_AbsPath)
- {
- if (pathParts.IsEmpty() || pathParts.Size() == 1 && pathParts[0].IsEmpty())
- {
- // we create universal item, if we skip all parts as prefix (like \ or L:\ )
- pathParts.Clear();
- pathParts.Add(UString("*"));
- forFile = true;
- wildcardMatching = true;
- recursive = false;
- }
- }
-
- CItem item;
- item.PathParts = pathParts;
- item.ForDir = true;
- item.ForFile = forFile;
- item.Recursive = recursive;
- item.WildcardMatching = wildcardMatching;
- Pairs[index].Head.AddItem(include, item, ignoreWildcardIndex);
-}
-
-/*
-bool CCensor::CheckPath(bool isAltStream, const UString &path, bool isFile) const
-{
- bool finded = false;
- FOR_VECTOR (i, Pairs)
- {
- bool include;
- if (Pairs[i].Head.CheckPath2(isAltStream, path, isFile, include))
- {
- if (!include)
- return false;
- finded = true;
- }
- }
- return finded;
-}
-*/
-
-void CCensor::ExtendExclude()
-{
- unsigned i;
- for (i = 0; i < Pairs.Size(); i++)
- if (Pairs[i].Prefix.IsEmpty())
- break;
- if (i == Pairs.Size())
- return;
- unsigned index = i;
- for (i = 0; i < Pairs.Size(); i++)
- if (index != i)
- Pairs[i].Head.ExtendExclude(Pairs[index].Head);
-}
-
-void CCensor::AddPathsToCensor(ECensorPathMode censorPathMode)
-{
- FOR_VECTOR(i, CensorPaths)
- {
- const CCensorPath &cp = CensorPaths[i];
- AddItem(censorPathMode, cp.Include, cp.Path, cp.Recursive, cp.WildcardMatching);
- }
- CensorPaths.Clear();
-}
-
-void CCensor::AddPreItem(bool include, const UString &path, bool recursive, bool wildcardMatching)
-{
- CCensorPath &cp = CensorPaths.AddNew();
- cp.Path = path;
- cp.Include = include;
- cp.Recursive = recursive;
- cp.WildcardMatching = wildcardMatching;
-}
-
-}
+// Common/Wildcard.cpp
+
+#include "StdAfx.h"
+
+#include "Wildcard.h"
+
+extern
+bool g_CaseSensitive;
+bool g_CaseSensitive =
+ #ifdef _WIN32
+ false;
+ #elif defined (__APPLE__)
+ #ifdef TARGET_OS_IPHONE
+ true;
+ #else
+ false;
+ #endif
+ #else
+ true;
+ #endif
+
+
+bool IsPath1PrefixedByPath2(const wchar_t *s1, const wchar_t *s2)
+{
+ if (g_CaseSensitive)
+ return IsString1PrefixedByString2(s1, s2);
+ return IsString1PrefixedByString2_NoCase(s1, s2);
+}
+
+// #include <stdio.h>
+
+/*
+static int MyStringCompare_PathLinux(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ wchar_t c1 = *s1++;
+ wchar_t c2 = *s2++;
+ if (c1 != c2)
+ {
+ if (c1 == 0) return -1;
+ if (c2 == 0) return 1;
+ if (c1 == '/') c1 = 0;
+ if (c2 == '/') c2 = 0;
+ if (c1 < c2) return -1;
+ if (c1 > c2) return 1;
+ continue;
+ }
+ if (c1 == 0) return 0;
+ }
+}
+*/
+
+static int MyStringCompare_Path(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ wchar_t c1 = *s1++;
+ wchar_t c2 = *s2++;
+ if (c1 != c2)
+ {
+ if (c1 == 0) return -1;
+ if (c2 == 0) return 1;
+ if (IS_PATH_SEPAR(c1)) c1 = 0;
+ if (IS_PATH_SEPAR(c2)) c2 = 0;
+ if (c1 < c2) return -1;
+ if (c1 > c2) return 1;
+ continue;
+ }
+ if (c1 == 0) return 0;
+ }
+}
+
+static int MyStringCompareNoCase_Path(const wchar_t *s1, const wchar_t *s2) throw()
+{
+ for (;;)
+ {
+ wchar_t c1 = *s1++;
+ wchar_t c2 = *s2++;
+ if (c1 != c2)
+ {
+ if (c1 == 0) return -1;
+ if (c2 == 0) return 1;
+ if (IS_PATH_SEPAR(c1)) c1 = 0;
+ if (IS_PATH_SEPAR(c2)) c2 = 0;
+ c1 = MyCharUpper(c1);
+ c2 = MyCharUpper(c2);
+ if (c1 < c2) return -1;
+ if (c1 > c2) return 1;
+ continue;
+ }
+ if (c1 == 0) return 0;
+ }
+}
+
+int CompareFileNames(const wchar_t *s1, const wchar_t *s2) STRING_UNICODE_THROW
+{
+ /*
+ printf("\nCompareFileNames");
+ printf("\n S1: %ls", s1);
+ printf("\n S2: %ls", s2);
+ printf("\n");
+ */
+ // 21.07 : we parse PATH_SEPARATOR so: 0 < PATH_SEPARATOR < 1
+ if (g_CaseSensitive)
+ return MyStringCompare_Path(s1, s2);
+ return MyStringCompareNoCase_Path(s1, s2);
+}
+
+#ifndef USE_UNICODE_FSTRING
+int CompareFileNames(const char *s1, const char *s2)
+{
+ const UString u1 = fs2us(s1);
+ const UString u2 = fs2us(s2);
+ return CompareFileNames(u1, u2);
+}
+#endif
+
+// -----------------------------------------
+// this function compares name with mask
+// ? - any char
+// * - any char or empty
+
+static bool EnhancedMaskTest(const wchar_t *mask, const wchar_t *name)
+{
+ for (;;)
+ {
+ const wchar_t m = *mask;
+ const wchar_t c = *name;
+ if (m == 0)
+ return (c == 0);
+ if (m == '*')
+ {
+ if (EnhancedMaskTest(mask + 1, name))
+ return true;
+ if (c == 0)
+ return false;
+ }
+ else
+ {
+ if (m == '?')
+ {
+ if (c == 0)
+ return false;
+ }
+ else if (m != c)
+ if (g_CaseSensitive || MyCharUpper(m) != MyCharUpper(c))
+ return false;
+ mask++;
+ }
+ name++;
+ }
+}
+
+// --------------------------------------------------
+// Splits path to strings
+
+void SplitPathToParts(const UString &path, UStringVector &pathParts)
+{
+ pathParts.Clear();
+ unsigned len = path.Len();
+ if (len == 0)
+ return;
+ UString name;
+ unsigned prev = 0;
+ for (unsigned i = 0; i < len; i++)
+ if (IsPathSepar(path[i]))
+ {
+ name.SetFrom(path.Ptr(prev), i - prev);
+ pathParts.Add(name);
+ prev = i + 1;
+ }
+ name.SetFrom(path.Ptr(prev), len - prev);
+ pathParts.Add(name);
+}
+
+void SplitPathToParts_2(const UString &path, UString &dirPrefix, UString &name)
+{
+ const wchar_t *start = path;
+ const wchar_t *p = start + path.Len();
+ for (; p != start; p--)
+ if (IsPathSepar(*(p - 1)))
+ break;
+ dirPrefix.SetFrom(path, (unsigned)(p - start));
+ name = p;
+}
+
+void SplitPathToParts_Smart(const UString &path, UString &dirPrefix, UString &name)
+{
+ const wchar_t *start = path;
+ const wchar_t *p = start + path.Len();
+ if (p != start)
+ {
+ if (IsPathSepar(*(p - 1)))
+ p--;
+ for (; p != start; p--)
+ if (IsPathSepar(*(p - 1)))
+ break;
+ }
+ dirPrefix.SetFrom(path, (unsigned)(p - start));
+ name = p;
+}
+
+/*
+UString ExtractDirPrefixFromPath(const UString &path)
+{
+ return path.Left(path.ReverseFind_PathSepar() + 1));
+}
+*/
+
+UString ExtractFileNameFromPath(const UString &path)
+{
+ return UString(path.Ptr((unsigned)(path.ReverseFind_PathSepar() + 1)));
+}
+
+
+bool DoesWildcardMatchName(const UString &mask, const UString &name)
+{
+ return EnhancedMaskTest(mask, name);
+}
+
+bool DoesNameContainWildcard(const UString &path)
+{
+ for (unsigned i = 0; i < path.Len(); i++)
+ {
+ wchar_t c = path[i];
+ if (c == '*' || c == '?')
+ return true;
+ }
+ return false;
+}
+
+
+// ----------------------------------------------------------'
+// NWildcard
+
+namespace NWildcard {
+
+/*
+
+M = MaskParts.Size();
+N = TestNameParts.Size();
+
+ File Dir
+ForFile rec M<=N [N-M, N) -
+!ForDir nonrec M=N [0, M) -
+
+ForDir rec M<N [0, M) ... [N-M-1, N-1) same as ForBoth-File
+!ForFile nonrec [0, M) same as ForBoth-File
+
+ForFile rec m<=N [0, M) ... [N-M, N) same as ForBoth-File
+ForDir nonrec [0, M) same as ForBoth-File
+
+*/
+
+bool CItem::AreAllAllowed() const
+{
+ return ForFile && ForDir && WildcardMatching && PathParts.Size() == 1 && PathParts.Front() == L"*";
+}
+
+bool CItem::CheckPath(const UStringVector &pathParts, bool isFile) const
+{
+ if (!isFile && !ForDir)
+ return false;
+
+ /*
+ if (PathParts.IsEmpty())
+ {
+ // PathParts.IsEmpty() means all items (universal wildcard)
+ if (!isFile)
+ return true;
+ if (pathParts.Size() <= 1)
+ return ForFile;
+ return (ForDir || Recursive && ForFile);
+ }
+ */
+
+ int delta = (int)pathParts.Size() - (int)PathParts.Size();
+ if (delta < 0)
+ return false;
+ int start = 0;
+ int finish = 0;
+
+ if (isFile)
+ {
+ if (!ForDir)
+ {
+ if (Recursive)
+ start = delta;
+ else if (delta !=0)
+ return false;
+ }
+ if (!ForFile && delta == 0)
+ return false;
+ }
+
+ if (Recursive)
+ {
+ finish = delta;
+ if (isFile && !ForFile)
+ finish = delta - 1;
+ }
+
+ for (int d = start; d <= finish; d++)
+ {
+ unsigned i;
+ for (i = 0; i < PathParts.Size(); i++)
+ {
+ if (WildcardMatching)
+ {
+ if (!DoesWildcardMatchName(PathParts[i], pathParts[i + (unsigned)d]))
+ break;
+ }
+ else
+ {
+ if (CompareFileNames(PathParts[i], pathParts[i + (unsigned)d]) != 0)
+ break;
+ }
+ }
+ if (i == PathParts.Size())
+ return true;
+ }
+ return false;
+}
+
+bool CCensorNode::AreAllAllowed() const
+{
+ if (!Name.IsEmpty() ||
+ !SubNodes.IsEmpty() ||
+ !ExcludeItems.IsEmpty() ||
+ IncludeItems.Size() != 1)
+ return false;
+ return IncludeItems.Front().AreAllAllowed();
+}
+
+int CCensorNode::FindSubNode(const UString &name) const
+{
+ FOR_VECTOR (i, SubNodes)
+ if (CompareFileNames(SubNodes[i].Name, name) == 0)
+ return (int)i;
+ return -1;
+}
+
+void CCensorNode::AddItemSimple(bool include, CItem &item)
+{
+ CObjectVector<CItem> &items = include ? IncludeItems : ExcludeItems;
+ items.Add(item);
+}
+
+void CCensorNode::AddItem(bool include, CItem &item, int ignoreWildcardIndex)
+{
+ if (item.PathParts.Size() <= 1)
+ {
+ if (item.PathParts.Size() != 0 && item.WildcardMatching)
+ {
+ if (!DoesNameContainWildcard(item.PathParts.Front()))
+ item.WildcardMatching = false;
+ }
+ AddItemSimple(include, item);
+ return;
+ }
+
+ const UString &front = item.PathParts.Front();
+
+ // WIN32 doesn't support wildcards in file names
+ if (item.WildcardMatching
+ && ignoreWildcardIndex != 0
+ && DoesNameContainWildcard(front))
+ {
+ AddItemSimple(include, item);
+ return;
+ }
+ CCensorNode &subNode = Find_SubNode_Or_Add_New(front);
+ item.PathParts.Delete(0);
+ subNode.AddItem(include, item, ignoreWildcardIndex - 1);
+}
+
+/*
+void CCensorNode::AddItem(bool include, const UString &path, const CCensorPathProps &props)
+{
+ CItem item;
+ SplitPathToParts(path, item.PathParts);
+ item.Recursive = props.Recursive;
+ item.ForFile = props.ForFile;
+ item.ForDir = props.ForDir;
+ item.WildcardMatching = props.WildcardMatching;
+ AddItem(include, item);
+}
+*/
+
+bool CCensorNode::NeedCheckSubDirs() const
+{
+ FOR_VECTOR (i, IncludeItems)
+ {
+ const CItem &item = IncludeItems[i];
+ if (item.Recursive || item.PathParts.Size() > 1)
+ return true;
+ }
+ return false;
+}
+
+bool CCensorNode::AreThereIncludeItems() const
+{
+ if (IncludeItems.Size() > 0)
+ return true;
+ FOR_VECTOR (i, SubNodes)
+ if (SubNodes[i].AreThereIncludeItems())
+ return true;
+ return false;
+}
+
+bool CCensorNode::CheckPathCurrent(bool include, const UStringVector &pathParts, bool isFile) const
+{
+ const CObjectVector<CItem> &items = include ? IncludeItems : ExcludeItems;
+ FOR_VECTOR (i, items)
+ if (items[i].CheckPath(pathParts, isFile))
+ return true;
+ return false;
+}
+
+bool CCensorNode::CheckPathVect(const UStringVector &pathParts, bool isFile, bool &include) const
+{
+ if (CheckPathCurrent(false, pathParts, isFile))
+ {
+ include = false;
+ return true;
+ }
+ if (pathParts.Size() > 1)
+ {
+ int index = FindSubNode(pathParts.Front());
+ if (index >= 0)
+ {
+ UStringVector pathParts2 = pathParts;
+ pathParts2.Delete(0);
+ if (SubNodes[(unsigned)index].CheckPathVect(pathParts2, isFile, include))
+ return true;
+ }
+ }
+ bool finded = CheckPathCurrent(true, pathParts, isFile);
+ include = finded; // if (!finded), then (true) is allowed also
+ return finded;
+}
+
+/*
+bool CCensorNode::CheckPath2(bool isAltStream, const UString &path, bool isFile, bool &include) const
+{
+ UStringVector pathParts;
+ SplitPathToParts(path, pathParts);
+ if (CheckPathVect(pathParts, isFile, include))
+ {
+ if (!include || !isAltStream)
+ return true;
+ }
+ if (isAltStream && !pathParts.IsEmpty())
+ {
+ UString &back = pathParts.Back();
+ int pos = back.Find(L':');
+ if (pos > 0)
+ {
+ back.DeleteFrom(pos);
+ return CheckPathVect(pathParts, isFile, include);
+ }
+ }
+ return false;
+}
+
+bool CCensorNode::CheckPath(bool isAltStream, const UString &path, bool isFile) const
+{
+ bool include;
+ if (CheckPath2(isAltStream, path, isFile, include))
+ return include;
+ return false;
+}
+*/
+
+bool CCensorNode::CheckPathToRoot_Change(bool include, UStringVector &pathParts, bool isFile) const
+{
+ if (CheckPathCurrent(include, pathParts, isFile))
+ return true;
+ if (!Parent)
+ return false;
+ pathParts.Insert(0, Name);
+ return Parent->CheckPathToRoot_Change(include, pathParts, isFile);
+}
+
+bool CCensorNode::CheckPathToRoot(bool include, const UStringVector &pathParts, bool isFile) const
+{
+ if (CheckPathCurrent(include, pathParts, isFile))
+ return true;
+ if (!Parent)
+ return false;
+ UStringVector pathParts2;
+ pathParts2.Add(Name);
+ pathParts2 += pathParts;
+ return Parent->CheckPathToRoot_Change(include, pathParts2, isFile);
+}
+
+/*
+bool CCensorNode::CheckPathToRoot(bool include, const UString &path, bool isFile) const
+{
+ UStringVector pathParts;
+ SplitPathToParts(path, pathParts);
+ return CheckPathToRoot(include, pathParts, isFile);
+}
+*/
+
+void CCensorNode::ExtendExclude(const CCensorNode &fromNodes)
+{
+ ExcludeItems += fromNodes.ExcludeItems;
+ FOR_VECTOR (i, fromNodes.SubNodes)
+ {
+ const CCensorNode &node = fromNodes.SubNodes[i];
+ Find_SubNode_Or_Add_New(node.Name).ExtendExclude(node);
+ }
+}
+
+int CCensor::FindPairForPrefix(const UString &prefix) const
+{
+ FOR_VECTOR (i, Pairs)
+ if (CompareFileNames(Pairs[i].Prefix, prefix) == 0)
+ return (int)i;
+ return -1;
+}
+
+#ifdef _WIN32
+
+bool IsDriveColonName(const wchar_t *s)
+{
+ unsigned c = s[0];
+ c |= 0x20;
+ c -= 'a';
+ return c <= (unsigned)('z' - 'a') && s[1] == ':' && s[2] == 0;
+}
+
+unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts)
+{
+ if (pathParts.IsEmpty())
+ return 0;
+
+ unsigned testIndex = 0;
+ if (pathParts[0].IsEmpty())
+ {
+ if (pathParts.Size() < 4
+ || !pathParts[1].IsEmpty()
+ || pathParts[2] != L"?")
+ return 0;
+ testIndex = 3;
+ }
+ if (NWildcard::IsDriveColonName(pathParts[testIndex]))
+ return testIndex + 1;
+ return 0;
+}
+
+#endif
+
+static unsigned GetNumPrefixParts(const UStringVector &pathParts)
+{
+ if (pathParts.IsEmpty())
+ return 0;
+
+ /* empty last part could be removed already from (pathParts),
+ if there was tail path separator (slash) in original full path string. */
+
+ #ifdef _WIN32
+
+ if (IsDriveColonName(pathParts[0]))
+ return 1;
+ if (!pathParts[0].IsEmpty())
+ return 0;
+
+ if (pathParts.Size() == 1)
+ return 1;
+ if (!pathParts[1].IsEmpty())
+ return 1;
+ if (pathParts.Size() == 2)
+ return 2;
+ if (pathParts[2] == L".")
+ return 3;
+
+ unsigned networkParts = 2;
+ if (pathParts[2] == L"?")
+ {
+ if (pathParts.Size() == 3)
+ return 3;
+ if (IsDriveColonName(pathParts[3]))
+ return 4;
+ if (!pathParts[3].IsEqualTo_Ascii_NoCase("UNC"))
+ return 3;
+ networkParts = 4;
+ }
+
+ networkParts +=
+ // 2; // server/share
+ 1; // server
+ if (pathParts.Size() <= networkParts)
+ return pathParts.Size();
+ return networkParts;
+
+ #else
+
+ return pathParts[0].IsEmpty() ? 1 : 0;
+
+ #endif
+}
+
+void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &path,
+ const CCensorPathProps &props)
+{
+ if (path.IsEmpty())
+ throw "Empty file path";
+
+ UStringVector pathParts;
+ SplitPathToParts(path, pathParts);
+
+ CCensorPathProps props2 = props;
+
+ bool forFile = true;
+ bool forDir = true;
+ const UString &back = pathParts.Back();
+ if (back.IsEmpty())
+ {
+ // we have tail path separator. So it's directory.
+ // we delete tail path separator here even for "\" and "c:\"
+ forFile = false;
+ pathParts.DeleteBack();
+ }
+ else
+ {
+ if (props.MarkMode == kMark_StrictFile
+ || (props.MarkMode == kMark_StrictFile_IfWildcard
+ && DoesNameContainWildcard(back)))
+ forDir = false;
+ }
+
+
+ UString prefix;
+
+ int ignoreWildcardIndex = -1;
+
+ // #ifdef _WIN32
+ // we ignore "?" wildcard in "\\?\" prefix.
+ if (pathParts.Size() >= 3
+ && pathParts[0].IsEmpty()
+ && pathParts[1].IsEmpty()
+ && pathParts[2] == L"?")
+ ignoreWildcardIndex = 2;
+ // #endif
+
+ if (pathMode != k_AbsPath)
+ {
+ // detection of the number of Skip Parts for prefix
+ ignoreWildcardIndex = -1;
+
+ const unsigned numPrefixParts = GetNumPrefixParts(pathParts);
+ unsigned numSkipParts = numPrefixParts;
+
+ if (pathMode != k_FullPath)
+ {
+ // if absolute path, then all parts before last part will be in prefix
+ if (numPrefixParts != 0 && pathParts.Size() > numPrefixParts)
+ numSkipParts = pathParts.Size() - 1;
+ }
+ {
+ int dotsIndex = -1;
+ for (unsigned i = numPrefixParts; i < pathParts.Size(); i++)
+ {
+ const UString &part = pathParts[i];
+ if (part == L".." || part == L".")
+ dotsIndex = (int)i;
+ }
+
+ if (dotsIndex >= 0)
+ {
+ if (dotsIndex == (int)pathParts.Size() - 1)
+ numSkipParts = pathParts.Size();
+ else
+ numSkipParts = pathParts.Size() - 1;
+ }
+ }
+
+ // we split (pathParts) to (prefix) and (pathParts).
+ for (unsigned i = 0; i < numSkipParts; i++)
+ {
+ {
+ const UString &front = pathParts.Front();
+ // WIN32 doesn't support wildcards in file names
+ if (props.WildcardMatching)
+ if (i >= numPrefixParts && DoesNameContainWildcard(front))
+ break;
+ prefix += front;
+ prefix.Add_PathSepar();
+ }
+ pathParts.Delete(0);
+ }
+ }
+
+ int index = FindPairForPrefix(prefix);
+ if (index < 0)
+ {
+ index = (int)Pairs.Size();
+ Pairs.AddNew().Prefix = prefix;
+ }
+
+ if (pathMode != k_AbsPath)
+ {
+ if (pathParts.IsEmpty() || (pathParts.Size() == 1 && pathParts[0].IsEmpty()))
+ {
+ // we create universal item, if we skip all parts as prefix (like \ or L:\ )
+ pathParts.Clear();
+ pathParts.Add(UString("*"));
+ forFile = true;
+ forDir = true;
+ props2.WildcardMatching = true;
+ props2.Recursive = false;
+ }
+ }
+
+ /*
+ // not possible now
+ if (!forDir && !forFile)
+ {
+ UString s ("file path was blocked for files and directories: ");
+ s += path;
+ throw s;
+ // return; // for debug : ignore item (don't create Item)
+ }
+ */
+
+ CItem item;
+ item.PathParts = pathParts;
+ item.ForDir = forDir;
+ item.ForFile = forFile;
+ item.Recursive = props2.Recursive;
+ item.WildcardMatching = props2.WildcardMatching;
+ Pairs[(unsigned)index].Head.AddItem(include, item, ignoreWildcardIndex);
+}
+
+/*
+bool CCensor::CheckPath(bool isAltStream, const UString &path, bool isFile) const
+{
+ bool finded = false;
+ FOR_VECTOR (i, Pairs)
+ {
+ bool include;
+ if (Pairs[i].Head.CheckPath2(isAltStream, path, isFile, include))
+ {
+ if (!include)
+ return false;
+ finded = true;
+ }
+ }
+ return finded;
+}
+*/
+
+void CCensor::ExtendExclude()
+{
+ unsigned i;
+ for (i = 0; i < Pairs.Size(); i++)
+ if (Pairs[i].Prefix.IsEmpty())
+ break;
+ if (i == Pairs.Size())
+ return;
+ unsigned index = i;
+ for (i = 0; i < Pairs.Size(); i++)
+ if (index != i)
+ Pairs[i].Head.ExtendExclude(Pairs[index].Head);
+}
+
+void CCensor::AddPathsToCensor(ECensorPathMode censorPathMode)
+{
+ FOR_VECTOR(i, CensorPaths)
+ {
+ const CCensorPath &cp = CensorPaths[i];
+ AddItem(censorPathMode, cp.Include, cp.Path, cp.Props);
+ }
+ CensorPaths.Clear();
+}
+
+void CCensor::AddPreItem(bool include, const UString &path, const CCensorPathProps &props)
+{
+ CCensorPath &cp = CensorPaths.AddNew();
+ cp.Path = path;
+ cp.Include = include;
+ cp.Props = props;
+}
+
+}
diff --git a/CPP/Common/Wildcard.h b/CPP/Common/Wildcard.h
index 6e5f013..4f81da9 100644
--- a/CPP/Common/Wildcard.h
+++ b/CPP/Common/Wildcard.h
@@ -1,149 +1,231 @@
-// Common/Wildcard.h
-
-#ifndef __COMMON_WILDCARD_H
-#define __COMMON_WILDCARD_H
-
-#include "MyString.h"
-
-int CompareFileNames(const wchar_t *s1, const wchar_t *s2) STRING_UNICODE_THROW;
-#ifndef USE_UNICODE_FSTRING
- int CompareFileNames(const char *s1, const char *s2);
-#endif
-
-bool IsPath1PrefixedByPath2(const wchar_t *s1, const wchar_t *s2);
-
-void SplitPathToParts(const UString &path, UStringVector &pathParts);
-void SplitPathToParts_2(const UString &path, UString &dirPrefix, UString &name);
-void SplitPathToParts_Smart(const UString &path, UString &dirPrefix, UString &name); // ignores dir delimiter at the end of (path)
-
-UString ExtractDirPrefixFromPath(const UString &path);
-UString ExtractFileNameFromPath(const UString &path);
-
-bool DoesNameContainWildcard(const UString &path);
-bool DoesWildcardMatchName(const UString &mask, const UString &name);
-
-namespace NWildcard {
-
-#ifdef _WIN32
-// returns true, if name is like "a:", "c:", ...
-bool IsDriveColonName(const wchar_t *s);
-unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts);
-#endif
-
-struct CItem
-{
- UStringVector PathParts;
- bool Recursive;
- bool ForFile;
- bool ForDir;
- bool WildcardMatching;
-
- #ifdef _WIN32
- bool IsDriveItem() const
- {
- return PathParts.Size() == 1 && !ForFile && ForDir && IsDriveColonName(PathParts[0]);
- }
- #endif
-
- // CItem(): WildcardMatching(true) {}
-
- bool AreAllAllowed() const;
- bool CheckPath(const UStringVector &pathParts, bool isFile) const;
-};
-
-class CCensorNode
-{
- CCensorNode *Parent;
-
- bool CheckPathCurrent(bool include, const UStringVector &pathParts, bool isFile) const;
- void AddItemSimple(bool include, CItem &item);
-public:
- bool CheckPathVect(const UStringVector &pathParts, bool isFile, bool &include) const;
-
- CCensorNode(): Parent(0) { };
- CCensorNode(const UString &name, CCensorNode *parent): Name(name), Parent(parent) { };
-
- UString Name; // WIN32 doesn't support wildcards in file names
- CObjectVector<CCensorNode> SubNodes;
- CObjectVector<CItem> IncludeItems;
- CObjectVector<CItem> ExcludeItems;
-
- bool AreAllAllowed() const;
-
- int FindSubNode(const UString &path) const;
-
- void AddItem(bool include, CItem &item, int ignoreWildcardIndex = -1);
- void AddItem(bool include, const UString &path, bool recursive, bool forFile, bool forDir, bool wildcardMatching);
- void AddItem2(bool include, const UString &path, bool recursive, bool wildcardMatching);
-
- bool NeedCheckSubDirs() const;
- bool AreThereIncludeItems() const;
-
- // bool CheckPath2(bool isAltStream, const UString &path, bool isFile, bool &include) const;
- // bool CheckPath(bool isAltStream, const UString &path, bool isFile) const;
-
- bool CheckPathToRoot(bool include, UStringVector &pathParts, bool isFile) const;
- // bool CheckPathToRoot(const UString &path, bool isFile, bool include) const;
- void ExtendExclude(const CCensorNode &fromNodes);
-};
-
-struct CPair
-{
- UString Prefix;
- CCensorNode Head;
-
- CPair(const UString &prefix): Prefix(prefix) { };
-};
-
-enum ECensorPathMode
-{
- k_RelatPath, // absolute prefix as Prefix, remain path in Tree
- k_FullPath, // drive prefix as Prefix, remain path in Tree
- k_AbsPath // full path in Tree
-};
-
-struct CCensorPath
-{
- UString Path;
- bool Include;
- bool Recursive;
- bool WildcardMatching;
-
- CCensorPath():
- Include(true),
- Recursive(false),
- WildcardMatching(true)
- {}
-};
-
-class CCensor
-{
- int FindPrefix(const UString &prefix) const;
-public:
- CObjectVector<CPair> Pairs;
-
- CObjectVector<NWildcard::CCensorPath> CensorPaths;
-
- bool AllAreRelative() const
- { return (Pairs.Size() == 1 && Pairs.Front().Prefix.IsEmpty()); }
-
- void AddItem(ECensorPathMode pathMode, bool include, const UString &path, bool recursive, bool wildcardMatching);
- // bool CheckPath(bool isAltStream, const UString &path, bool isFile) const;
- void ExtendExclude();
-
- void AddPathsToCensor(NWildcard::ECensorPathMode censorPathMode);
- void AddPreItem(bool include, const UString &path, bool recursive, bool wildcardMatching);
- void AddPreItem(const UString &path)
- {
- AddPreItem(true, path, false, false);
- }
- void AddPreItem_Wildcard()
- {
- AddPreItem(true, UString("*"), false, true);
- }
-};
-
-
-}
-
-#endif
+// Common/Wildcard.h
+
+#ifndef ZIP7_INC_COMMON_WILDCARD_H
+#define ZIP7_INC_COMMON_WILDCARD_H
+
+#include "MyString.h"
+
+int CompareFileNames(const wchar_t *s1, const wchar_t *s2) STRING_UNICODE_THROW;
+#ifndef USE_UNICODE_FSTRING
+ int CompareFileNames(const char *s1, const char *s2);
+#endif
+
+bool IsPath1PrefixedByPath2(const wchar_t *s1, const wchar_t *s2);
+
+void SplitPathToParts(const UString &path, UStringVector &pathParts);
+void SplitPathToParts_2(const UString &path, UString &dirPrefix, UString &name);
+void SplitPathToParts_Smart(const UString &path, UString &dirPrefix, UString &name); // ignores dir delimiter at the end of (path)
+
+UString ExtractDirPrefixFromPath(const UString &path);
+UString ExtractFileNameFromPath(const UString &path);
+
+bool DoesNameContainWildcard(const UString &path);
+bool DoesWildcardMatchName(const UString &mask, const UString &name);
+
+namespace NWildcard {
+
+#ifdef _WIN32
+// returns true, if name is like "a:", "c:", ...
+bool IsDriveColonName(const wchar_t *s);
+unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts);
+#endif
+
+struct CItem
+{
+ UStringVector PathParts;
+ bool Recursive;
+ bool ForFile;
+ bool ForDir;
+ bool WildcardMatching;
+
+ #ifdef _WIN32
+ bool IsDriveItem() const
+ {
+ return PathParts.Size() == 1 && !ForFile && ForDir && IsDriveColonName(PathParts[0]);
+ }
+ #endif
+
+ // CItem(): WildcardMatching(true) {}
+
+ bool AreAllAllowed() const;
+ bool CheckPath(const UStringVector &pathParts, bool isFile) const;
+};
+
+
+
+const Byte kMark_FileOrDir = 0;
+const Byte kMark_StrictFile = 1;
+const Byte kMark_StrictFile_IfWildcard = 2;
+
+struct CCensorPathProps
+{
+ bool Recursive;
+ bool WildcardMatching;
+ Byte MarkMode;
+
+ CCensorPathProps():
+ Recursive(false),
+ WildcardMatching(true),
+ MarkMode(kMark_FileOrDir)
+ {}
+};
+
+
+class CCensorNode MY_UNCOPYABLE
+{
+ CCensorNode *Parent;
+
+ bool CheckPathCurrent(bool include, const UStringVector &pathParts, bool isFile) const;
+ void AddItemSimple(bool include, CItem &item);
+public:
+ // bool ExcludeDirItems;
+
+ CCensorNode():
+ Parent(NULL)
+ // , ExcludeDirItems(false)
+ {}
+
+ CCensorNode(const UString &name, CCensorNode *parent):
+ Parent(parent)
+ // , ExcludeDirItems(false)
+ , Name(name)
+ {}
+
+ UString Name; // WIN32 doesn't support wildcards in file names
+ CObjectVector<CCensorNode> SubNodes;
+ CObjectVector<CItem> IncludeItems;
+ CObjectVector<CItem> ExcludeItems;
+
+ CCensorNode &Find_SubNode_Or_Add_New(const UString &name)
+ {
+ int i = FindSubNode(name);
+ if (i >= 0)
+ return SubNodes[(unsigned)i];
+ // return SubNodes.Add(CCensorNode(name, this));
+ CCensorNode &node = SubNodes.AddNew();
+ node.Parent = this;
+ node.Name = name;
+ return node;
+ }
+
+ bool AreAllAllowed() const;
+
+ int FindSubNode(const UString &path) const;
+
+ void AddItem(bool include, CItem &item, int ignoreWildcardIndex = -1);
+ // void AddItem(bool include, const UString &path, const CCensorPathProps &props);
+ void Add_Wildcard()
+ {
+ CItem item;
+ item.PathParts.Add(L"*");
+ item.Recursive = false;
+ item.ForFile = true;
+ item.ForDir = true;
+ item.WildcardMatching = true;
+ AddItem(
+ true // include
+ , item);
+ }
+
+ // NeedCheckSubDirs() returns true, if there are IncludeItems rules that affect items in subdirs
+ bool NeedCheckSubDirs() const;
+ bool AreThereIncludeItems() const;
+
+ /*
+ CheckPathVect() doesn't check path in Parent CCensorNode
+ so use CheckPathVect() for root CCensorNode
+ OUT:
+ returns (true) && (include = false) - file in exlude list
+ returns (true) && (include = true) - file in include list and is not in exlude list
+ returns (false) - file is not in (include/exlude) list
+ */
+ bool CheckPathVect(const UStringVector &pathParts, bool isFile, bool &include) const;
+
+ // bool CheckPath2(bool isAltStream, const UString &path, bool isFile, bool &include) const;
+ // bool CheckPath(bool isAltStream, const UString &path, bool isFile) const;
+
+ // CheckPathToRoot_Change() changes pathParts !!!
+ bool CheckPathToRoot_Change(bool include, UStringVector &pathParts, bool isFile) const;
+ bool CheckPathToRoot(bool include, const UStringVector &pathParts, bool isFile) const;
+
+ // bool CheckPathToRoot(const UString &path, bool isFile, bool include) const;
+ void ExtendExclude(const CCensorNode &fromNodes);
+};
+
+
+struct CPair MY_UNCOPYABLE
+{
+ UString Prefix;
+ CCensorNode Head;
+
+ // CPair(const UString &prefix): Prefix(prefix) { };
+};
+
+
+enum ECensorPathMode
+{
+ k_RelatPath, // absolute prefix as Prefix, remain path in Tree
+ k_FullPath, // drive prefix as Prefix, remain path in Tree
+ k_AbsPath // full path in Tree
+};
+
+
+struct CCensorPath
+{
+ UString Path;
+ bool Include;
+ CCensorPathProps Props;
+
+ CCensorPath():
+ Include(true)
+ {}
+};
+
+
+class CCensor MY_UNCOPYABLE
+{
+ int FindPairForPrefix(const UString &prefix) const;
+public:
+ CObjectVector<CPair> Pairs;
+
+ bool ExcludeDirItems;
+ bool ExcludeFileItems;
+
+ CCensor():
+ ExcludeDirItems(false),
+ ExcludeFileItems(false)
+ {}
+
+ CObjectVector<NWildcard::CCensorPath> CensorPaths;
+
+ bool AllAreRelative() const
+ { return (Pairs.Size() == 1 && Pairs.Front().Prefix.IsEmpty()); }
+
+ void AddItem(ECensorPathMode pathMode, bool include, const UString &path, const CCensorPathProps &props);
+ // bool CheckPath(bool isAltStream, const UString &path, bool isFile) const;
+ void ExtendExclude();
+
+ void AddPathsToCensor(NWildcard::ECensorPathMode censorPathMode);
+ void AddPreItem(bool include, const UString &path, const CCensorPathProps &props);
+
+ void AddPreItem_NoWildcard(const UString &path)
+ {
+ CCensorPathProps props;
+ props.WildcardMatching = false;
+ AddPreItem(
+ true, // include
+ path, props);
+ }
+ void AddPreItem_Wildcard()
+ {
+ CCensorPathProps props;
+ // props.WildcardMatching = true;
+ AddPreItem(
+ true, // include
+ UString("*"), props);
+ }
+};
+
+}
+
+#endif
diff --git a/CPP/Common/XzCrc64Init.cpp b/CPP/Common/XzCrc64Init.cpp
index 1eae72a..5cb8e67 100644
--- a/CPP/Common/XzCrc64Init.cpp
+++ b/CPP/Common/XzCrc64Init.cpp
@@ -1,7 +1,7 @@
-// XzCrc64Init.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/XzCrc64.h"
-
-static struct CCrc64Gen { CCrc64Gen() { Crc64GenerateTable(); } } g_Crc64TableInit;
+// XzCrc64Init.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/XzCrc64.h"
+
+static struct CCrc64Gen { CCrc64Gen() { Crc64GenerateTable(); } } g_Crc64TableInit;
diff --git a/CPP/Common/XzCrc64Reg.cpp b/CPP/Common/XzCrc64Reg.cpp
index 92fce0a..e9e67ef 100644
--- a/CPP/Common/XzCrc64Reg.cpp
+++ b/CPP/Common/XzCrc64Reg.cpp
@@ -1,42 +1,39 @@
-// XzCrc64Reg.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/CpuArch.h"
-#include "../../C/XzCrc64.h"
-
-#include "../Common/MyCom.h"
-
-#include "../7zip/Common/RegisterCodec.h"
-
-class CXzCrc64Hasher:
- public IHasher,
- public CMyUnknownImp
-{
- UInt64 _crc;
- Byte mtDummy[1 << 7];
-
-public:
- CXzCrc64Hasher(): _crc(CRC64_INIT_VAL) {}
-
- MY_UNKNOWN_IMP1(IHasher)
- INTERFACE_IHasher(;)
-};
-
-STDMETHODIMP_(void) CXzCrc64Hasher::Init() throw()
-{
- _crc = CRC64_INIT_VAL;
-}
-
-STDMETHODIMP_(void) CXzCrc64Hasher::Update(const void *data, UInt32 size) throw()
-{
- _crc = Crc64Update(_crc, data, size);
-}
-
-STDMETHODIMP_(void) CXzCrc64Hasher::Final(Byte *digest) throw()
-{
- UInt64 val = CRC64_GET_DIGEST(_crc);
- SetUi64(digest, val);
-}
-
-REGISTER_HASHER(CXzCrc64Hasher, 0x4, "CRC64", 8)
+// XzCrc64Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+#include "../../C/XzCrc64.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+Z7_CLASS_IMP_COM_1(
+ CXzCrc64Hasher
+ , IHasher
+)
+ UInt64 _crc;
+public:
+ Byte _mtDummy[1 << 7]; // it's public to eliminate clang warning: unused private field
+
+ CXzCrc64Hasher(): _crc(CRC64_INIT_VAL) {}
+};
+
+Z7_COM7F_IMF2(void, CXzCrc64Hasher::Init())
+{
+ _crc = CRC64_INIT_VAL;
+}
+
+Z7_COM7F_IMF2(void, CXzCrc64Hasher::Update(const void *data, UInt32 size))
+{
+ _crc = Crc64Update(_crc, data, size);
+}
+
+Z7_COM7F_IMF2(void, CXzCrc64Hasher::Final(Byte *digest))
+{
+ const UInt64 val = CRC64_GET_DIGEST(_crc);
+ SetUi64(digest, val)
+}
+
+REGISTER_HASHER(CXzCrc64Hasher, 0x4, "CRC64", 8)
diff --git a/CPP/Windows/COM.cpp b/CPP/Windows/COM.cpp
new file mode 100644
index 0000000..d0cb321
--- /dev/null
+++ b/CPP/Windows/COM.cpp
@@ -0,0 +1,41 @@
+// Windows/COM.cpp
+
+#include "StdAfx.h"
+
+/*
+
+#include "COM.h"
+#include "../Common/StringConvert.h"
+
+namespace NWindows {
+namespace NCOM {
+
+// CoInitialize (NULL); must be called!
+
+UString GUIDToStringW(REFGUID guid)
+{
+ UString s;
+ const unsigned kSize = 48;
+ StringFromGUID2(guid, s.GetBuf(kSize), kSize);
+ s.ReleaseBuf_CalcLen(kSize);
+ return s;
+}
+
+AString GUIDToStringA(REFGUID guid)
+{
+ return UnicodeStringToMultiByte(GUIDToStringW(guid));
+}
+
+HRESULT StringToGUIDW(const wchar_t *string, GUID &classID)
+{
+ return CLSIDFromString((wchar_t *)string, &classID);
+}
+
+HRESULT StringToGUIDA(const char *string, GUID &classID)
+{
+ return StringToGUIDW(MultiByteToUnicodeString(string), classID);
+}
+
+}}
+
+*/
diff --git a/CPP/Windows/COM.h b/CPP/Windows/COM.h
index e2cb002..a8780ca 100644
--- a/CPP/Windows/COM.h
+++ b/CPP/Windows/COM.h
@@ -1,70 +1,86 @@
-// Windows/COM.h
-
-#ifndef __WINDOWS_COM_H
-#define __WINDOWS_COM_H
-
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NCOM {
-
-#ifdef _WIN32
-
-class CComInitializer
-{
-public:
- CComInitializer()
- {
- #ifdef UNDER_CE
- CoInitializeEx(NULL, COINIT_MULTITHREADED);
- #else
- // it's single thread. Do we need multithread?
- CoInitialize(NULL);
- #endif
- };
- ~CComInitializer() { CoUninitialize(); }
-};
-
-class CStgMedium
-{
- STGMEDIUM _object;
-public:
- bool _mustBeReleased;
- CStgMedium(): _mustBeReleased(false) {}
- ~CStgMedium() { Free(); }
- void Free()
- {
- if (_mustBeReleased)
- ReleaseStgMedium(&_object);
- _mustBeReleased = false;
- }
- const STGMEDIUM* operator->() const { return &_object;}
- STGMEDIUM* operator->() { return &_object;}
- STGMEDIUM* operator&() { return &_object; }
-};
-
-#endif
-
-/*
-//////////////////////////////////
-// GUID <--> String Conversions
-UString GUIDToStringW(REFGUID guid);
-AString GUIDToStringA(REFGUID guid);
-#ifdef UNICODE
- #define GUIDToString GUIDToStringW
-#else
- #define GUIDToString GUIDToStringA
-#endif
-
-HRESULT StringToGUIDW(const wchar_t *string, GUID &classID);
-HRESULT StringToGUIDA(const char *string, GUID &classID);
-#ifdef UNICODE
- #define StringToGUID StringToGUIDW
-#else
- #define StringToGUID StringToGUIDA
-#endif
-*/
-
-}}
-
-#endif
+// Windows/COM.h
+
+#ifndef ZIP7_INC_WINDOWS_COM_H
+#define ZIP7_INC_WINDOWS_COM_H
+
+// #include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NCOM {
+
+#ifdef _WIN32
+
+class CComInitializer
+{
+public:
+ CComInitializer()
+ {
+ #ifdef UNDER_CE
+ CoInitializeEx(NULL, COINIT_MULTITHREADED);
+ #else
+ // it's single thread. Do we need multithread?
+ CoInitialize(NULL);
+ #endif
+ }
+ ~CComInitializer() { CoUninitialize(); }
+};
+
+/*
+class CStgMedium2
+{
+ STGMEDIUM _object;
+ bool _mustBeReleased;
+public:
+ CStgMedium2(): _mustBeReleased(false) {}
+ ~CStgMedium2() { Free(); }
+ void Free()
+ {
+ if (_mustBeReleased)
+ ReleaseStgMedium(&_object);
+ _mustBeReleased = false;
+ }
+ const STGMEDIUM* operator->() const { return &_object;}
+ STGMEDIUM* operator->() { return &_object;}
+ STGMEDIUM* operator&() { return &_object; }
+};
+*/
+
+struct CStgMedium: public STGMEDIUM
+{
+ CStgMedium()
+ {
+ tymed = TYMED_NULL; // 0
+ hGlobal = NULL;
+ pUnkForRelease = NULL;
+ }
+ ~CStgMedium()
+ {
+ ReleaseStgMedium(this);
+ }
+};
+
+#endif
+
+/*
+//////////////////////////////////
+// GUID <--> String Conversions
+UString GUIDToStringW(REFGUID guid);
+AString GUIDToStringA(REFGUID guid);
+#ifdef UNICODE
+ #define GUIDToString GUIDToStringW
+#else
+ #define GUIDToString GUIDToStringA
+#endif
+
+HRESULT StringToGUIDW(const wchar_t *string, GUID &classID);
+HRESULT StringToGUIDA(const char *string, GUID &classID);
+#ifdef UNICODE
+ #define StringToGUID StringToGUIDW
+#else
+ #define StringToGUID StringToGUIDA
+#endif
+*/
+
+}}
+
+#endif
diff --git a/CPP/Windows/Clipboard.cpp b/CPP/Windows/Clipboard.cpp
new file mode 100644
index 0000000..bc7e201
--- /dev/null
+++ b/CPP/Windows/Clipboard.cpp
@@ -0,0 +1,130 @@
+// Windows/Clipboard.cpp
+
+#include "StdAfx.h"
+
+#ifdef UNDER_CE
+#include <winuserm.h>
+#endif
+
+#include "../Common/StringConvert.h"
+
+#include "Clipboard.h"
+#include "Defs.h"
+#include "MemoryGlobal.h"
+#include "Shell.h"
+
+namespace NWindows {
+
+bool CClipboard::Open(HWND wndNewOwner) throw()
+{
+ m_Open = BOOLToBool(::OpenClipboard(wndNewOwner));
+ return m_Open;
+}
+
+bool CClipboard::Close() throw()
+{
+ if (!m_Open)
+ return true;
+ m_Open = !BOOLToBool(CloseClipboard());
+ return !m_Open;
+}
+
+bool ClipboardIsFormatAvailableHDROP()
+{
+ return BOOLToBool(IsClipboardFormatAvailable(CF_HDROP));
+}
+
+/*
+bool ClipboardGetTextString(AString &s)
+{
+ s.Empty();
+ if (!IsClipboardFormatAvailable(CF_TEXT))
+ return false;
+ CClipboard clipboard;
+
+ if (!clipboard.Open(NULL))
+ return false;
+
+ HGLOBAL h = ::GetClipboardData(CF_TEXT);
+ if (h != NULL)
+ {
+ NMemory::CGlobalLock globalLock(h);
+ const char *p = (const char *)globalLock.GetPointer();
+ if (p != NULL)
+ {
+ s = p;
+ return true;
+ }
+ }
+ return false;
+}
+*/
+
+/*
+bool ClipboardGetFileNames(UStringVector &names)
+{
+ names.Clear();
+ if (!IsClipboardFormatAvailable(CF_HDROP))
+ return false;
+ CClipboard clipboard;
+
+ if (!clipboard.Open(NULL))
+ return false;
+
+ HGLOBAL h = ::GetClipboardData(CF_HDROP);
+ if (h != NULL)
+ {
+ NMemory::CGlobalLock globalLock(h);
+ void *p = (void *)globalLock.GetPointer();
+ if (p != NULL)
+ {
+ NShell::CDrop drop(false);
+ drop.Attach((HDROP)p);
+ drop.QueryFileNames(names);
+ return true;
+ }
+ }
+ return false;
+}
+*/
+
+static bool ClipboardSetData(UINT uFormat, const void *data, size_t size) throw()
+{
+ NMemory::CGlobal global;
+ if (!global.Alloc(GMEM_DDESHARE | GMEM_MOVEABLE, size))
+ return false;
+ {
+ NMemory::CGlobalLock globalLock(global);
+ LPVOID p = globalLock.GetPointer();
+ if (!p)
+ return false;
+ memcpy(p, data, size);
+ }
+ if (::SetClipboardData(uFormat, global) == NULL)
+ return false;
+ global.Detach();
+ return true;
+}
+
+bool ClipboardSetText(HWND owner, const UString &s)
+{
+ CClipboard clipboard;
+ if (!clipboard.Open(owner))
+ return false;
+ if (!::EmptyClipboard())
+ return false;
+
+ bool res;
+ res = ClipboardSetData(CF_UNICODETEXT, (const wchar_t *)s, (s.Len() + 1) * sizeof(wchar_t));
+ #ifndef _UNICODE
+ AString a (UnicodeStringToMultiByte(s, CP_ACP));
+ if (ClipboardSetData(CF_TEXT, (const char *)a, (a.Len() + 1) * sizeof(char)))
+ res = true;
+ a = UnicodeStringToMultiByte(s, CP_OEMCP);
+ if (ClipboardSetData(CF_OEMTEXT, (const char *)a, (a.Len() + 1) * sizeof(char)))
+ res = true;
+ #endif
+ return res;
+}
+
+}
diff --git a/CPP/Windows/Clipboard.h b/CPP/Windows/Clipboard.h
new file mode 100644
index 0000000..3b4f2fe
--- /dev/null
+++ b/CPP/Windows/Clipboard.h
@@ -0,0 +1,28 @@
+// Windows/Clipboard.h
+
+#ifndef ZIP7_INC_CLIPBOARD_H
+#define ZIP7_INC_CLIPBOARD_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+
+class CClipboard
+{
+ bool m_Open;
+public:
+ CClipboard(): m_Open(false) {}
+ ~CClipboard() { Close(); }
+ bool Open(HWND wndNewOwner) throw();
+ bool Close() throw();
+};
+
+bool ClipboardIsFormatAvailableHDROP();
+
+// bool ClipboardGetFileNames(UStringVector &names);
+// bool ClipboardGetTextString(AString &s);
+bool ClipboardSetText(HWND owner, const UString &s);
+
+}
+
+#endif
diff --git a/CPP/Windows/CommonDialog.cpp b/CPP/Windows/CommonDialog.cpp
index 8b3828c..7a92d5f 100644
--- a/CPP/Windows/CommonDialog.cpp
+++ b/CPP/Windows/CommonDialog.cpp
@@ -1,185 +1,269 @@
-// Windows/CommonDialog.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/MyWindows.h"
-
-#ifdef UNDER_CE
-#include <commdlg.h>
-#endif
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "CommonDialog.h"
-#include "Defs.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-
-#ifndef _UNICODE
-
-class CDoubleZeroStringListA
-{
- LPTSTR Buf;
- unsigned Size;
-public:
- CDoubleZeroStringListA(LPSTR buf, unsigned size): Buf(buf), Size(size) {}
- bool Add(LPCSTR s) throw();
- void Finish() { *Buf = 0; }
-};
-
-bool CDoubleZeroStringListA::Add(LPCSTR s) throw()
-{
- unsigned len = MyStringLen(s) + 1;
- if (len >= Size)
- return false;
- MyStringCopy(Buf, s);
- Buf += len;
- Size -= len;
- return true;
-}
-
-#endif
-
-class CDoubleZeroStringListW
-{
- LPWSTR Buf;
- unsigned Size;
-public:
- CDoubleZeroStringListW(LPWSTR buf, unsigned size): Buf(buf), Size(size) {}
- bool Add(LPCWSTR s) throw();
- void Finish() { *Buf = 0; }
-};
-
-bool CDoubleZeroStringListW::Add(LPCWSTR s) throw()
-{
- unsigned len = MyStringLen(s) + 1;
- if (len >= Size)
- return false;
- MyStringCopy(Buf, s);
- Buf += len;
- Size -= len;
- return true;
-}
-
-#define MY__OFN_PROJECT 0x00400000
-#define MY__OFN_SHOW_ALL 0x01000000
-
-/* if (lpstrFilter == NULL && nFilterIndex == 0)
- MSDN : "the system doesn't show any files",
- but WinXP-64 shows all files. Why ??? */
-
-/*
-structures
- OPENFILENAMEW
- OPENFILENAMEA
-contain additional members:
-#if (_WIN32_WINNT >= 0x0500)
- void *pvReserved;
- DWORD dwReserved;
- DWORD FlagsEx;
-#endif
-
-If we compile the source code with (_WIN32_WINNT >= 0x0500), some functions
-will not work at NT 4.0, if we use sizeof(OPENFILENAME*).
-So we use size of old version of structure. */
-
-#if defined(UNDER_CE) || defined(_WIN64) || (_WIN32_WINNT < 0x0500)
-// || !defined(WINVER)
- #define my_compatib_OPENFILENAMEA_size sizeof(OPENFILENAMEA)
- #define my_compatib_OPENFILENAMEW_size sizeof(OPENFILENAMEW)
-#else
- #define my_compatib_OPENFILENAMEA_size OPENFILENAME_SIZE_VERSION_400A
- #define my_compatib_OPENFILENAMEW_size OPENFILENAME_SIZE_VERSION_400W
-#endif
-
-#define CONV_U_To_A(dest, src, temp) AString temp; if (src) { temp = GetSystemString(src); dest = temp; }
-
-bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
- LPCWSTR initialDir,
- LPCWSTR filePath,
- LPCWSTR filterDescription,
- LPCWSTR filter,
- UString &resPath
- #ifdef UNDER_CE
- , bool openFolder
- #endif
- )
-{
- const unsigned kBufSize = MAX_PATH * 2;
- const unsigned kFilterBufSize = MAX_PATH;
- if (!filter)
- filter = L"*.*";
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- CHAR buf[kBufSize];
- MyStringCopy(buf, (const char *)GetSystemString(filePath));
- // OPENFILENAME_NT4A
- OPENFILENAMEA p;
- memset(&p, 0, sizeof(p));
- p.lStructSize = my_compatib_OPENFILENAMEA_size;
- p.hwndOwner = hwnd;
- CHAR filterBuf[kFilterBufSize];
- {
- CDoubleZeroStringListA dz(filterBuf, kFilterBufSize);
- dz.Add(GetSystemString(filterDescription ? filterDescription : filter));
- dz.Add(GetSystemString(filter));
- dz.Finish();
- p.lpstrFilter = filterBuf;
- p.nFilterIndex = 1;
- }
-
- p.lpstrFile = buf;
- p.nMaxFile = kBufSize;
- CONV_U_To_A(p.lpstrInitialDir, initialDir, initialDirA);
- CONV_U_To_A(p.lpstrTitle, title, titleA);
- p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY;
-
- bool res = BOOLToBool(::GetOpenFileNameA(&p));
- resPath = GetUnicodeString(buf);
- return res;
- }
- else
- #endif
- {
- WCHAR buf[kBufSize];
- MyStringCopy(buf, filePath);
- // OPENFILENAME_NT4W
- OPENFILENAMEW p;
- memset(&p, 0, sizeof(p));
- p.lStructSize = my_compatib_OPENFILENAMEW_size;
- p.hwndOwner = hwnd;
-
- WCHAR filterBuf[kFilterBufSize];
- {
- CDoubleZeroStringListW dz(filterBuf, kFilterBufSize);
- dz.Add(filterDescription ? filterDescription : filter);
- dz.Add(filter);
- dz.Finish();
- p.lpstrFilter = filterBuf;
- p.nFilterIndex = 1;
- }
-
- p.lpstrFile = buf;
- p.nMaxFile = kBufSize;
- p.lpstrInitialDir = initialDir;
- p.lpstrTitle = title;
- p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY
- #ifdef UNDER_CE
- | (openFolder ? (MY__OFN_PROJECT | MY__OFN_SHOW_ALL) : 0)
- #endif
- ;
-
- bool res = BOOLToBool(::GetOpenFileNameW(&p));
- resPath = buf;
- return res;
- }
-}
-
-}
+// Windows/CommonDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/MyBuffer.h"
+
+#ifdef UNDER_CE
+#include <commdlg.h>
+#endif
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "CommonDialog.h"
+#include "Defs.h"
+// #include "FileDir.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+/*
+ GetSaveFileName()
+ GetOpenFileName()
+ OPENFILENAME
+
+(lpstrInitialDir) : the initial directory.
+DOCs: the algorithm for selecting the initial directory varies on different platforms:
+{
+ Win2000/XP/Vista:
+ 1. If lpstrFile contains a path, that path is the initial directory.
+ 2. Otherwise, lpstrInitialDir specifies the initial directory.
+
+ Win7:
+ If lpstrInitialDir has the same value as was passed the first time
+ the application used an Open or Save As dialog box, the path
+ most recently selected by the user is used as the initial directory.
+}
+
+Win10:
+ in:
+ function supports (lpstrInitialDir) path with super prefix "\\\\?\\"
+ function supports (lpstrInitialDir) path with long path
+ function doesn't support absolute (lpstrFile) path with super prefix "\\\\?\\"
+ function doesn't support absolute (lpstrFile) path with long path
+ out: the path with super prefix "\\\\?\\" will be returned, if selected path is long
+
+WinXP-64 and Win10: if no filters, the system shows all files.
+ but DOCs say: If all three members are zero or NULL,
+ the system does not use any filters and does not
+ show any files in the file list control of the dialog box.
+
+in Win7+: GetOpenFileName() and GetSaveFileName()
+ do not support pstrCustomFilter feature anymore
+*/
+
+#ifdef UNDER_CE
+#define MY_OFN_PROJECT 0x00400000
+#define MY_OFN_SHOW_ALL 0x01000000
+#endif
+
+
+/*
+structures
+ OPENFILENAMEW
+ OPENFILENAMEA
+contain additional members:
+#if (_WIN32_WINNT >= 0x0500)
+ void *pvReserved;
+ DWORD dwReserved;
+ DWORD FlagsEx;
+#endif
+
+If we compile the source code with (_WIN32_WINNT >= 0x0500), some functions
+will not work at NT 4.0, if we use sizeof(OPENFILENAME).
+We try to use reduced structure OPENFILENAME_NT4.
+*/
+
+// #if defined(_WIN64) || (defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0500)
+#if defined(__GNUC__) && (__GNUC__ <= 9) || defined(Z7_OLD_WIN_SDK)
+ #ifndef _UNICODE
+ #define my_compatib_OPENFILENAMEA OPENFILENAMEA
+ #endif
+ #define my_compatib_OPENFILENAMEW OPENFILENAMEW
+
+ // MinGW doesn't support some required macros. So we define them here:
+ #ifndef CDSIZEOF_STRUCT
+ #define CDSIZEOF_STRUCT(structname, member) (((int)((LPBYTE)(&((structname*)0)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))
+ #endif
+ #ifndef _UNICODE
+ #ifndef OPENFILENAME_SIZE_VERSION_400A
+ #define OPENFILENAME_SIZE_VERSION_400A CDSIZEOF_STRUCT(OPENFILENAMEA,lpTemplateName)
+ #endif
+ #endif
+ #ifndef OPENFILENAME_SIZE_VERSION_400W
+ #define OPENFILENAME_SIZE_VERSION_400W CDSIZEOF_STRUCT(OPENFILENAMEW,lpTemplateName)
+ #endif
+
+ #ifndef _UNICODE
+ #define my_compatib_OPENFILENAMEA_size OPENFILENAME_SIZE_VERSION_400A
+ #endif
+ #define my_compatib_OPENFILENAMEW_size OPENFILENAME_SIZE_VERSION_400W
+#else
+ #ifndef _UNICODE
+ #define my_compatib_OPENFILENAMEA OPENFILENAME_NT4A
+ #define my_compatib_OPENFILENAMEA_size sizeof(my_compatib_OPENFILENAMEA)
+ #endif
+ #define my_compatib_OPENFILENAMEW OPENFILENAME_NT4W
+ #define my_compatib_OPENFILENAMEW_size sizeof(my_compatib_OPENFILENAMEW)
+#endif
+/*
+#elif defined(UNDER_CE) || defined(_WIN64) || (_WIN32_WINNT < 0x0500)
+// || !defined(WINVER)
+ #ifndef _UNICODE
+ #define my_compatib_OPENFILENAMEA OPENFILENAMEA
+ #define my_compatib_OPENFILENAMEA_size sizeof(OPENFILENAMEA)
+ #endif
+ #define my_compatib_OPENFILENAMEW OPENFILENAMEW
+ #define my_compatib_OPENFILENAMEW_size sizeof(OPENFILENAMEW)
+#else
+
+#endif
+*/
+
+#ifndef _UNICODE
+#define CONV_U_To_A(dest, src, temp) AString temp; if (src) { temp = GetSystemString(src); dest = temp; }
+#endif
+
+bool CCommonDialogInfo::CommonDlg_BrowseForFile(LPCWSTR lpstrInitialDir, const UStringVector &filters)
+{
+ /* GetSaveFileName() and GetOpenFileName() could change current dir,
+ if OFN_NOCHANGEDIR is not used.
+ We can restore current dir manually, if it's required.
+ 22.02: we use OFN_NOCHANGEDIR. So we don't need to restore current dir manually. */
+ // NFile::NDir::CCurrentDirRestorer curDirRestorer;
+
+#ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ AString tempPath;
+ AStringVector f;
+ unsigned i;
+ for (i = 0; i < filters.Size(); i++)
+ f.Add(GetSystemString(filters[i]));
+ unsigned size = f.Size() + 1;
+ for (i = 0; i < f.Size(); i++)
+ size += f[i].Len();
+ CObjArray<char> filterBuf(size);
+ // memset(filterBuf, 0, size * sizeof(char));
+ {
+ char *dest = filterBuf;
+ for (i = 0; i < f.Size(); i++)
+ {
+ const AString &s = f[i];
+ MyStringCopy(dest, s);
+ dest += s.Len() + 1;
+ }
+ *dest = 0;
+ }
+ my_compatib_OPENFILENAMEA p;
+ memset(&p, 0, sizeof(p));
+ p.lStructSize = my_compatib_OPENFILENAMEA_size;
+ p.hwndOwner = hwndOwner;
+ if (size > 1)
+ {
+ p.lpstrFilter = filterBuf;
+ p.nFilterIndex = (DWORD)(FilterIndex + 1);
+ }
+
+ CONV_U_To_A(p.lpstrInitialDir, lpstrInitialDir, initialDir_a)
+ CONV_U_To_A(p.lpstrTitle, lpstrTitle, title_a)
+
+ const AString filePath_a = GetSystemString(FilePath);
+ const unsigned bufSize = MAX_PATH * 8
+ + filePath_a.Len()
+ + initialDir_a.Len();
+ p.nMaxFile = bufSize;
+ p.lpstrFile = tempPath.GetBuf(bufSize);
+ MyStringCopy(p.lpstrFile, filePath_a);
+ p.Flags =
+ OFN_EXPLORER
+ | OFN_HIDEREADONLY
+ | OFN_NOCHANGEDIR;
+ const BOOL b = SaveMode ?
+ ::GetSaveFileNameA((LPOPENFILENAMEA)(void *)&p) :
+ ::GetOpenFileNameA((LPOPENFILENAMEA)(void *)&p);
+ if (!b)
+ return false;
+ {
+ tempPath.ReleaseBuf_CalcLen(bufSize);
+ FilePath = GetUnicodeString(tempPath);
+ FilterIndex = (int)p.nFilterIndex - 1;
+ return true;
+ }
+ }
+ else
+#endif
+ {
+ UString tempPath;
+ unsigned size = filters.Size() + 1;
+ unsigned i;
+ for (i = 0; i < filters.Size(); i++)
+ size += filters[i].Len();
+ CObjArray<wchar_t> filterBuf(size);
+ // memset(filterBuf, 0, size * sizeof(wchar_t));
+ {
+ wchar_t *dest = filterBuf;
+ for (i = 0; i < filters.Size(); i++)
+ {
+ const UString &s = filters[i];
+ MyStringCopy(dest, s);
+ dest += s.Len() + 1;
+ }
+ *dest = 0;
+ // if ((unsigned)(dest + 1 - filterBuf) != size) return false;
+ }
+ my_compatib_OPENFILENAMEW p;
+ memset(&p, 0, sizeof(p));
+ p.lStructSize = my_compatib_OPENFILENAMEW_size;
+ p.hwndOwner = hwndOwner;
+ if (size > 1)
+ {
+ p.lpstrFilter = filterBuf;
+ p.nFilterIndex = (DWORD)(FilterIndex + 1);
+ }
+ unsigned bufSize = MAX_PATH * 8 + FilePath.Len();
+ if (lpstrInitialDir)
+ {
+ p.lpstrInitialDir = lpstrInitialDir;
+ bufSize += MyStringLen(lpstrInitialDir);
+ }
+ p.nMaxFile = bufSize;
+ p.lpstrFile = tempPath.GetBuf(bufSize);
+ MyStringCopy(p.lpstrFile, FilePath);
+ p.lpstrTitle = lpstrTitle;
+ p.Flags =
+ OFN_EXPLORER
+ | OFN_HIDEREADONLY
+ | OFN_NOCHANGEDIR
+ // | OFN_FORCESHOWHIDDEN // Win10 shows hidden items even without this flag
+ // | OFN_PATHMUSTEXIST
+ #ifdef UNDER_CE
+ | (OpenFolderMode ? (MY_OFN_PROJECT | MY_OFN_SHOW_ALL) : 0)
+ #endif
+ ;
+ const BOOL b = SaveMode ?
+ ::GetSaveFileNameW((LPOPENFILENAMEW)(void *)&p) :
+ ::GetOpenFileNameW((LPOPENFILENAMEW)(void *)&p);
+ /* DOCs: lpstrFile :
+ if the buffer is too small, then:
+ - the function returns FALSE
+ - the CommDlgExtendedError() returns FNERR_BUFFERTOOSMALL
+ - the first two bytes of the lpstrFile buffer contain the
+ required size, in bytes or characters. */
+ if (!b)
+ return false;
+ {
+ tempPath.ReleaseBuf_CalcLen(bufSize);
+ FilePath = tempPath;
+ FilterIndex = (int)p.nFilterIndex - 1;
+ return true;
+ }
+ }
+}
+
+}
diff --git a/CPP/Windows/CommonDialog.h b/CPP/Windows/CommonDialog.h
index 2bfec28..85b071f 100644
--- a/CPP/Windows/CommonDialog.h
+++ b/CPP/Windows/CommonDialog.h
@@ -1,23 +1,43 @@
-// Windows/CommonDialog.h
-
-#ifndef __WINDOWS_COMMON_DIALOG_H
-#define __WINDOWS_COMMON_DIALOG_H
-
-#include "../Common/MyString.h"
-
-namespace NWindows {
-
-bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
- LPCWSTR initialDir, // can be NULL, so dir prefix in filePath will be used
- LPCWSTR filePath, // full path
- LPCWSTR filterDescription, // like "All files (*.*)"
- LPCWSTR filter, // like "*.exe"
- UString &resPath
- #ifdef UNDER_CE
- , bool openFolder = false
- #endif
-);
-
-}
-
-#endif
+// Windows/CommonDialog.h
+
+#ifndef ZIP7_INC_WINDOWS_COMMON_DIALOG_H
+#define ZIP7_INC_WINDOWS_COMMON_DIALOG_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+
+struct CCommonDialogInfo
+{
+ /* (FilterIndex == -1) means no selected filter.
+ and (-1) also is reserved for unsupported custom filter.
+ if (FilterIndex >= 0), then FilterIndex is index of filter */
+ int FilterIndex; // [in / out]
+ bool SaveMode;
+ #ifdef UNDER_CE
+ bool OpenFolderMode;
+ #endif
+ HWND hwndOwner;
+ // LPCWSTR lpstrInitialDir;
+ LPCWSTR lpstrTitle;
+ UString FilePath; // [in / out]
+
+ CCommonDialogInfo()
+ {
+ FilterIndex = -1;
+ SaveMode = false;
+ #ifdef UNDER_CE
+ OpenFolderMode = false;
+ #endif
+ hwndOwner = NULL;
+ // lpstrInitialDir = NULL;
+ lpstrTitle = NULL;
+ }
+
+ /* (filters) : 2 sequential vector strings (Description, Masks) represent each filter */
+ bool CommonDlg_BrowseForFile(LPCWSTR lpstrInitialDir, const UStringVector &filters);
+};
+
+}
+
+#endif
diff --git a/CPP/Windows/Console.cpp b/CPP/Windows/Console.cpp
new file mode 100644
index 0000000..28ba1c4
--- /dev/null
+++ b/CPP/Windows/Console.cpp
@@ -0,0 +1,10 @@
+// Windows/Console.cpp
+
+#include "StdAfx.h"
+
+#include "Console.h"
+
+namespace NWindows{
+namespace NConsole{
+
+}}
diff --git a/CPP/Windows/Console.h b/CPP/Windows/Console.h
new file mode 100644
index 0000000..818b8d4
--- /dev/null
+++ b/CPP/Windows/Console.h
@@ -0,0 +1,52 @@
+// Windows/Console.h
+
+#ifndef ZIP7_INC_WINDOWS_CONSOLE_H
+#define ZIP7_INC_WINDOWS_CONSOLE_H
+
+#include "Defs.h"
+
+namespace NWindows {
+namespace NConsole {
+
+class CBase
+{
+protected:
+ HANDLE m_Object;
+public:
+ void Attach(HANDLE handle) { m_Object = handle; }
+ bool GetMode(DWORD &mode)
+ { return BOOLToBool(::GetConsoleMode(m_Object, &mode)); }
+ bool SetMode(DWORD mode)
+ { return BOOLToBool(::SetConsoleMode(m_Object, mode)); }
+};
+
+class CIn: public CBase
+{
+public:
+ bool PeekEvents(PINPUT_RECORD events, DWORD numEvents, DWORD &numEventsRead)
+ { return BOOLToBool(::PeekConsoleInput(m_Object, events, numEvents, &numEventsRead)); }
+ bool PeekEvent(INPUT_RECORD &event, DWORD &numEventsRead)
+ { return PeekEvents(&event, 1, numEventsRead); }
+ bool ReadEvents(PINPUT_RECORD events, DWORD numEvents, DWORD &numEventsRead)
+ { return BOOLToBool(::ReadConsoleInput(m_Object, events, numEvents, &numEventsRead)); }
+ bool ReadEvent(INPUT_RECORD &event, DWORD &numEventsRead)
+ { return ReadEvents(&event, 1, numEventsRead); }
+ bool GetNumberOfEvents(DWORD &numEvents)
+ { return BOOLToBool(::GetNumberOfConsoleInputEvents(m_Object, &numEvents)); }
+
+ bool WriteEvents(const INPUT_RECORD *events, DWORD numEvents, DWORD &numEventsWritten)
+ { return BOOLToBool(::WriteConsoleInput(m_Object, events, numEvents, &numEventsWritten)); }
+ bool WriteEvent(const INPUT_RECORD &event, DWORD &numEventsWritten)
+ { return WriteEvents(&event, 1, numEventsWritten); }
+
+ bool Read(LPVOID buffer, DWORD numChars, DWORD &numCharsRead)
+ { return BOOLToBool(::ReadConsole(m_Object, buffer, numChars, &numCharsRead, NULL)); }
+
+ bool Flush()
+ { return BOOLToBool(::FlushConsoleInputBuffer(m_Object)); }
+
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/ComboBox.cpp b/CPP/Windows/Control/ComboBox.cpp
index 6ab4717..8da487d 100644
--- a/CPP/Windows/Control/ComboBox.cpp
+++ b/CPP/Windows/Control/ComboBox.cpp
@@ -1,66 +1,66 @@
-// Windows/Control/ComboBox.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../../Common/StringConvert.h"
-#endif
-
-#include "ComboBox.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NControl {
-
-LRESULT CComboBox::GetLBText(int index, CSysString &s)
-{
- s.Empty();
- LRESULT len = GetLBTextLen(index); // length, excluding the terminating null character
- if (len == CB_ERR)
- return len;
- LRESULT len2 = GetLBText(index, s.GetBuf((unsigned)len));
- if (len2 == CB_ERR)
- return len;
- if (len > len2)
- len = len2;
- s.ReleaseBuf_CalcLen((unsigned)len);
- return len;
-}
-
-#ifndef _UNICODE
-LRESULT CComboBox::AddString(LPCWSTR s)
-{
- if (g_IsNT)
- return SendMsgW(CB_ADDSTRING, 0, (LPARAM)s);
- return AddString(GetSystemString(s));
-}
-
-LRESULT CComboBox::GetLBText(int index, UString &s)
-{
- s.Empty();
- if (g_IsNT)
- {
- LRESULT len = SendMsgW(CB_GETLBTEXTLEN, index, 0);
- if (len == CB_ERR)
- return len;
- LRESULT len2 = SendMsgW(CB_GETLBTEXT, index, (LPARAM)s.GetBuf((unsigned)len));
- if (len2 == CB_ERR)
- return len;
- if (len > len2)
- len = len2;
- s.ReleaseBuf_CalcLen((unsigned)len);
- return len;
- }
- AString sa;
- LRESULT len = GetLBText(index, sa);
- if (len == CB_ERR)
- return len;
- s = GetUnicodeString(sa);
- return s.Len();
-}
-#endif
-
-}}
+// Windows/Control/ComboBox.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../../Common/StringConvert.h"
+#endif
+
+#include "ComboBox.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NControl {
+
+LRESULT CComboBox::GetLBText(int index, CSysString &s)
+{
+ s.Empty();
+ LRESULT len = GetLBTextLen(index); // length, excluding the terminating null character
+ if (len == CB_ERR)
+ return len;
+ LRESULT len2 = GetLBText(index, s.GetBuf((unsigned)len));
+ if (len2 == CB_ERR)
+ return len;
+ if (len > len2)
+ len = len2;
+ s.ReleaseBuf_CalcLen((unsigned)len);
+ return len;
+}
+
+#ifndef _UNICODE
+LRESULT CComboBox::AddString(LPCWSTR s)
+{
+ if (g_IsNT)
+ return SendMsgW(CB_ADDSTRING, 0, (LPARAM)s);
+ return AddString(GetSystemString(s));
+}
+
+LRESULT CComboBox::GetLBText(int index, UString &s)
+{
+ s.Empty();
+ if (g_IsNT)
+ {
+ LRESULT len = SendMsgW(CB_GETLBTEXTLEN, MY_int_TO_WPARAM(index), 0);
+ if (len == CB_ERR)
+ return len;
+ LRESULT len2 = SendMsgW(CB_GETLBTEXT, MY_int_TO_WPARAM(index), (LPARAM)s.GetBuf((unsigned)len));
+ if (len2 == CB_ERR)
+ return len;
+ if (len > len2)
+ len = len2;
+ s.ReleaseBuf_CalcLen((unsigned)len);
+ return len;
+ }
+ AString sa;
+ const LRESULT len = GetLBText(index, sa);
+ if (len == CB_ERR)
+ return len;
+ s = GetUnicodeString(sa);
+ return (LRESULT)s.Len();
+}
+#endif
+
+}}
diff --git a/CPP/Windows/Control/ComboBox.h b/CPP/Windows/Control/ComboBox.h
index 3439655..2a60b8a 100644
--- a/CPP/Windows/Control/ComboBox.h
+++ b/CPP/Windows/Control/ComboBox.h
@@ -1,65 +1,77 @@
-// Windows/Control/ComboBox.h
-
-#ifndef __WINDOWS_CONTROL_COMBOBOX_H
-#define __WINDOWS_CONTROL_COMBOBOX_H
-
-#include "../../Common/MyWindows.h"
-
-#include <commctrl.h>
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CComboBox: public CWindow
-{
-public:
- void ResetContent() { SendMsg(CB_RESETCONTENT, 0, 0); }
- LRESULT AddString(LPCTSTR s) { return SendMsg(CB_ADDSTRING, 0, (LPARAM)s); }
- #ifndef _UNICODE
- LRESULT AddString(LPCWSTR s);
- #endif
- LRESULT SetCurSel(int index) { return SendMsg(CB_SETCURSEL, index, 0); }
- int GetCurSel() { return (int)SendMsg(CB_GETCURSEL, 0, 0); }
- int GetCount() { return (int)SendMsg(CB_GETCOUNT, 0, 0); }
-
- LRESULT GetLBTextLen(int index) { return SendMsg(CB_GETLBTEXTLEN, index, 0); }
- LRESULT GetLBText(int index, LPTSTR s) { return SendMsg(CB_GETLBTEXT, index, (LPARAM)s); }
- LRESULT GetLBText(int index, CSysString &s);
- #ifndef _UNICODE
- LRESULT GetLBText(int index, UString &s);
- #endif
-
- LRESULT SetItemData(int index, LPARAM lParam) { return SendMsg(CB_SETITEMDATA, index, lParam); }
- LRESULT GetItemData(int index) { return SendMsg(CB_GETITEMDATA, index, 0); }
-
- LRESULT GetItemData_of_CurSel() { return GetItemData(GetCurSel()); }
-
- void ShowDropDown(bool show = true) { SendMsg(CB_SHOWDROPDOWN, show ? TRUE : FALSE, 0); }
-};
-
-#ifndef UNDER_CE
-
-class CComboBoxEx: public CComboBox
-{
-public:
- bool SetUnicodeFormat(bool fUnicode) { return LRESULTToBool(SendMsg(CBEM_SETUNICODEFORMAT, BOOLToBool(fUnicode), 0)); }
-
- LRESULT DeleteItem(int index) { return SendMsg(CBEM_DELETEITEM, index, 0); }
- LRESULT InsertItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_INSERTITEM, 0, (LPARAM)item); }
- #ifndef _UNICODE
- LRESULT InsertItem(COMBOBOXEXITEMW *item) { return SendMsg(CBEM_INSERTITEMW, 0, (LPARAM)item); }
- #endif
-
- LRESULT SetItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_SETITEM, 0, (LPARAM)item); }
- DWORD SetExtendedStyle(DWORD exMask, DWORD exStyle) { return (DWORD)SendMsg(CBEM_SETEXTENDEDSTYLE, exMask, exStyle); }
- HWND GetEditControl() { return (HWND)SendMsg(CBEM_GETEDITCONTROL, 0, 0); }
- HIMAGELIST SetImageList(HIMAGELIST imageList) { return (HIMAGELIST)SendMsg(CBEM_SETIMAGELIST, 0, (LPARAM)imageList); }
-};
-
-#endif
-
-}}
-
-#endif
+// Windows/Control/ComboBox.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_COMBOBOX_H
+#define ZIP7_INC_WINDOWS_CONTROL_COMBOBOX_H
+
+#include "../../Common/MyWindows.h"
+
+#include <CommCtrl.h>
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CComboBox: public CWindow
+{
+public:
+ void ResetContent() { SendMsg(CB_RESETCONTENT, 0, 0); }
+ LRESULT AddString(LPCTSTR s) { return SendMsg(CB_ADDSTRING, 0, (LPARAM)s); }
+ #ifndef _UNICODE
+ LRESULT AddString(LPCWSTR s);
+ #endif
+
+ /* If this parameter is -1, any current selection in the list is removed and the edit control is cleared.*/
+ LRESULT SetCurSel(int index) { return SendMsg(CB_SETCURSEL, MY_int_TO_WPARAM(index), 0); }
+ LRESULT SetCurSel(unsigned index) { return SendMsg(CB_SETCURSEL, index, 0); }
+
+ /* If no item is selected, it returns CB_ERR (-1) */
+ int GetCurSel() { return (int)SendMsg(CB_GETCURSEL, 0, 0); }
+
+ /* If an error occurs, it is CB_ERR (-1) */
+ int GetCount() { return (int)SendMsg(CB_GETCOUNT, 0, 0); }
+
+ LRESULT GetLBTextLen(int index) { return SendMsg(CB_GETLBTEXTLEN, MY_int_TO_WPARAM(index), 0); }
+ LRESULT GetLBText(int index, LPTSTR s) { return SendMsg(CB_GETLBTEXT, MY_int_TO_WPARAM(index), (LPARAM)s); }
+ LRESULT GetLBText(int index, CSysString &s);
+ #ifndef _UNICODE
+ LRESULT GetLBText(int index, UString &s);
+ #endif
+
+ LRESULT SetItemData(int index, LPARAM lParam) { return SendMsg(CB_SETITEMDATA, MY_int_TO_WPARAM(index), lParam); }
+ LRESULT GetItemData(int index) { return SendMsg(CB_GETITEMDATA, MY_int_TO_WPARAM(index), 0); }
+ LRESULT GetItemData(unsigned index) { return SendMsg(CB_GETITEMDATA, index, 0); }
+
+ LRESULT GetItemData_of_CurSel() { return GetItemData(GetCurSel()); }
+
+ void ShowDropDown(bool show = true) { SendMsg(CB_SHOWDROPDOWN, show ? TRUE : FALSE, 0); }
+};
+
+#ifndef UNDER_CE
+
+class CComboBoxEx: public CComboBox
+{
+public:
+ bool SetUnicodeFormat(bool fUnicode) { return LRESULTToBool(SendMsg(CBEM_SETUNICODEFORMAT, BOOLToBool(fUnicode), 0)); }
+
+ /* Returns:
+ an INT value that represents the number of items remaining in the control.
+ If (index) is invalid, the message returns CB_ERR. */
+ LRESULT DeleteItem(int index) { return SendMsg(CBEM_DELETEITEM, MY_int_TO_WPARAM(index), 0); }
+
+ LRESULT InsertItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_INSERTITEM, 0, (LPARAM)item); }
+ #ifndef _UNICODE
+ LRESULT InsertItem(COMBOBOXEXITEMW *item) { return SendMsg(CBEM_INSERTITEMW, 0, (LPARAM)item); }
+ #endif
+
+ LRESULT SetItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_SETITEM, 0, (LPARAM)item); }
+ DWORD SetExtendedStyle(DWORD exMask, DWORD exStyle) { return (DWORD)SendMsg(CBEM_SETEXTENDEDSTYLE, exMask, (LPARAM)exStyle); }
+ HWND GetEditControl() { return (HWND)SendMsg(CBEM_GETEDITCONTROL, 0, 0); }
+ HIMAGELIST SetImageList(HIMAGELIST imageList) { return (HIMAGELIST)SendMsg(CBEM_SETIMAGELIST, 0, (LPARAM)imageList); }
+};
+
+#endif
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/CommandBar.h b/CPP/Windows/Control/CommandBar.h
index c435568..d1b2f17 100644
--- a/CPP/Windows/Control/CommandBar.h
+++ b/CPP/Windows/Control/CommandBar.h
@@ -1,52 +1,52 @@
-// Windows/Control/CommandBar.h
-
-#ifndef __WINDOWS_CONTROL_COMMANDBAR_H
-#define __WINDOWS_CONTROL_COMMANDBAR_H
-
-#ifdef UNDER_CE
-
-#include "../../Common/MyWindows.h"
-
-#include <commctrl.h>
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CCommandBar: public NWindows::CWindow
-{
-public:
- bool Create(HINSTANCE hInst, HWND hwndParent, int idCmdBar)
- {
- _window = ::CommandBar_Create(hInst, hwndParent, idCmdBar);
- return (_window != NULL);
- }
-
- // Macros
- // void Destroy() { CommandBar_Destroy(_window); }
- // bool AddButtons(UINT numButtons, LPTBBUTTON buttons) { return BOOLToBool(SendMsg(TB_ADDBUTTONS, (WPARAM)numButtons, (LPARAM)buttons)); }
- bool InsertButton(int iButton, LPTBBUTTON button) { return BOOLToBool(SendMsg(TB_INSERTBUTTON, (WPARAM)iButton, (LPARAM)button)); }
- BOOL AddToolTips(UINT numToolTips, LPTSTR toolTips) { return BOOLToBool(SendMsg(TB_SETTOOLTIPS, (WPARAM)numToolTips, (LPARAM)toolTips)); }
- void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
-
- bool AddAdornments(DWORD dwFlags) { return BOOLToBool(::CommandBar_AddAdornments(_window, dwFlags, 0)); }
- int AddBitmap(HINSTANCE hInst, int idBitmap, int iNumImages, int iImageWidth, int iImageHeight) { return ::CommandBar_AddBitmap(_window, hInst, idBitmap, iNumImages, iImageWidth, iImageHeight); }
- bool DrawMenuBar(WORD iButton) { return BOOLToBool(::CommandBar_DrawMenuBar(_window, iButton)); }
- HMENU GetMenu(WORD iButton) { return ::CommandBar_GetMenu(_window, iButton); }
- int Height() { return CommandBar_Height(_window); }
- HWND InsertComboBox(HINSTANCE hInst, int iWidth, UINT dwStyle, WORD idComboBox, WORD iButton) { return ::CommandBar_InsertComboBox(_window, hInst, iWidth, dwStyle, idComboBox, iButton); }
- bool InsertMenubar(HINSTANCE hInst, WORD idMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubar(_window, hInst, idMenu, iButton)); }
- bool InsertMenubarEx(HINSTANCE hInst, LPTSTR pszMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubarEx(_window, hInst, pszMenu, iButton)); }
- bool Show(bool cmdShow) { return BOOLToBool(::CommandBar_Show(_window, BoolToBOOL(cmdShow))); }
-
-
- // CE 4.0
- void AlignAdornments() { CommandBar_AlignAdornments(_window); }
-};
-
-}}
-
-#endif
-
-#endif
+// Windows/Control/CommandBar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_COMMANDBAR_H
+#define ZIP7_INC_WINDOWS_CONTROL_COMMANDBAR_H
+
+#ifdef UNDER_CE
+
+#include "../../Common/MyWindows.h"
+
+#include <commctrl.h>
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CCommandBar: public NWindows::CWindow
+{
+public:
+ bool Create(HINSTANCE hInst, HWND hwndParent, int idCmdBar)
+ {
+ _window = ::CommandBar_Create(hInst, hwndParent, idCmdBar);
+ return (_window != NULL);
+ }
+
+ // Macros
+ // void Destroy() { CommandBar_Destroy(_window); }
+ // bool AddButtons(UINT numButtons, LPTBBUTTON buttons) { return BOOLToBool(SendMsg(TB_ADDBUTTONS, (WPARAM)numButtons, (LPARAM)buttons)); }
+ // bool InsertButton(unsigned iButton, LPTBBUTTON button) { return BOOLToBool(SendMsg(TB_INSERTBUTTON, (WPARAM)iButton, (LPARAM)button)); }
+ // BOOL AddToolTips(UINT numToolTips, LPTSTR toolTips) { return BOOLToBool(SendMsg(TB_SETTOOLTIPS, (WPARAM)numToolTips, (LPARAM)toolTips)); }
+ void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
+
+ // bool AddAdornments(DWORD dwFlags) { return BOOLToBool(::CommandBar_AddAdornments(_window, dwFlags, 0)); }
+ // int AddBitmap(HINSTANCE hInst, int idBitmap, int iNumImages, int iImageWidth, int iImageHeight) { return ::CommandBar_AddBitmap(_window, hInst, idBitmap, iNumImages, iImageWidth, iImageHeight); }
+ bool DrawMenuBar(WORD iButton) { return BOOLToBool(::CommandBar_DrawMenuBar(_window, iButton)); }
+ HMENU GetMenu(WORD iButton) { return ::CommandBar_GetMenu(_window, iButton); }
+ int Height() { return CommandBar_Height(_window); }
+ HWND InsertComboBox(HINSTANCE hInst, int iWidth, UINT dwStyle, WORD idComboBox, WORD iButton) { return ::CommandBar_InsertComboBox(_window, hInst, iWidth, dwStyle, idComboBox, iButton); }
+ bool InsertMenubar(HINSTANCE hInst, WORD idMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubar(_window, hInst, idMenu, iButton)); }
+ bool InsertMenubarEx(HINSTANCE hInst, LPTSTR pszMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubarEx(_window, hInst, pszMenu, iButton)); }
+ bool Show(bool cmdShow) { return BOOLToBool(::CommandBar_Show(_window, BoolToBOOL(cmdShow))); }
+
+
+ // CE 4.0
+ void AlignAdornments() { CommandBar_AlignAdornments(_window); }
+};
+
+}}
+
+#endif
+
+#endif
diff --git a/CPP/Windows/Control/Dialog.cpp b/CPP/Windows/Control/Dialog.cpp
index 8e61a2b..c8f1bd2 100644
--- a/CPP/Windows/Control/Dialog.cpp
+++ b/CPP/Windows/Control/Dialog.cpp
@@ -1,251 +1,445 @@
-// Windows/Control/Dialog.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../../Common/StringConvert.h"
-#endif
-
-#include "Dialog.h"
-
-extern HINSTANCE g_hInstance;
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NControl {
-
-static INT_PTR APIENTRY DialogProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
-{
- CWindow tempDialog(dialogHWND);
- if (message == WM_INITDIALOG)
- tempDialog.SetUserDataLongPtr(lParam);
- CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
- if (dialog == NULL)
- return FALSE;
- if (message == WM_INITDIALOG)
- dialog->Attach(dialogHWND);
- try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
- catch(...) { return TRUE; }
-}
-
-bool CDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- switch (message)
- {
- case WM_INITDIALOG: return OnInit();
- case WM_COMMAND: return OnCommand(wParam, lParam);
- case WM_NOTIFY: return OnNotify((UINT)wParam, (LPNMHDR) lParam);
- case WM_TIMER: return OnTimer(wParam, lParam);
- case WM_SIZE: return OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
- case WM_HELP: OnHelp(); return true;
- /*
- OnHelp(
- #ifdef UNDER_CE
- (void *)
- #else
- (LPHELPINFO)
- #endif
- lParam);
- return true;
- */
- default: return false;
- }
-}
-
-bool CDialog::OnCommand(WPARAM wParam, LPARAM lParam)
-{
- return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam);
-}
-
-bool CDialog::OnCommand(int code, int itemID, LPARAM lParam)
-{
- if (code == BN_CLICKED)
- return OnButtonClicked(itemID, (HWND)lParam);
- return false;
-}
-
-bool CDialog::OnButtonClicked(int buttonID, HWND /* buttonHWND */)
-{
- switch (buttonID)
- {
- case IDOK: OnOK(); break;
- case IDCANCEL: OnCancel(); break;
- case IDCLOSE: OnClose(); break;
- case IDHELP: OnHelp(); break;
- default: return false;
- }
- return true;
-}
-
-static bool GetWorkAreaRect(RECT *rect)
-{
- // use another function for multi-monitor.
- return BOOLToBool(::SystemParametersInfo(SPI_GETWORKAREA, 0, rect, 0));
-}
-
-bool IsDialogSizeOK(int xSize, int ySize)
-{
- // it returns for system font. Real font uses another values
- LONG v = GetDialogBaseUnits();
- int x = LOWORD(v);
- int y = HIWORD(v);
-
- RECT rect;
- GetWorkAreaRect(&rect);
- int wx = RECT_SIZE_X(rect);
- int wy = RECT_SIZE_Y(rect);
- return
- xSize / 4 * x <= wx &&
- ySize / 8 * y <= wy;
-}
-
-bool CDialog::GetMargins(int margin, int &x, int &y)
-{
- x = margin;
- y = margin;
- RECT rect;
- rect.left = 0;
- rect.top = 0;
- rect.right = margin;
- rect.bottom = margin;
- if (!MapRect(&rect))
- return false;
- x = rect.right - rect.left;
- y = rect.bottom - rect.top;
- return true;
-}
-
-int CDialog::Units_To_Pixels_X(int units)
-{
- RECT rect;
- rect.left = 0;
- rect.top = 0;
- rect.right = units;
- rect.bottom = units;
- if (!MapRect(&rect))
- return units * 3 / 2;
- return rect.right - rect.left;
-}
-
-bool CDialog::GetItemSizes(int id, int &x, int &y)
-{
- RECT rect;
- if (!::GetWindowRect(GetItem(id), &rect))
- return false;
- x = RECT_SIZE_X(rect);
- y = RECT_SIZE_Y(rect);
- return true;
-}
-
-void CDialog::GetClientRectOfItem(int id, RECT &rect)
-{
- ::GetWindowRect(GetItem(id), &rect);
- ScreenToClient(&rect);
-}
-
-bool CDialog::MoveItem(int id, int x, int y, int width, int height, bool repaint)
-{
- return BOOLToBool(::MoveWindow(GetItem(id), x, y, width, height, BoolToBOOL(repaint)));
-}
-
-void CDialog::NormalizeSize(bool fullNormalize)
-{
- RECT workRect;
- GetWorkAreaRect(&workRect);
- int xSize = RECT_SIZE_X(workRect);
- int ySize = RECT_SIZE_Y(workRect);
- RECT rect;
- GetWindowRect(&rect);
- int xSize2 = RECT_SIZE_X(rect);
- int ySize2 = RECT_SIZE_Y(rect);
- bool needMove = (xSize2 > xSize || ySize2 > ySize);
- if (xSize2 > xSize || (needMove && fullNormalize))
- {
- rect.left = workRect.left;
- rect.right = workRect.right;
- xSize2 = xSize;
- }
- if (ySize2 > ySize || (needMove && fullNormalize))
- {
- rect.top = workRect.top;
- rect.bottom = workRect.bottom;
- ySize2 = ySize;
- }
- if (needMove)
- {
- if (fullNormalize)
- Show(SW_SHOWMAXIMIZED);
- else
- Move(rect.left, rect.top, xSize2, ySize2, true);
- }
-}
-
-void CDialog::NormalizePosition()
-{
- RECT workRect, rect;
- GetWorkAreaRect(&workRect);
- GetWindowRect(&rect);
- if (rect.bottom > workRect.bottom && rect.top > workRect.top)
- Move(rect.left, workRect.top, RECT_SIZE_X(rect), RECT_SIZE_Y(rect), true);
-}
-
-bool CModelessDialog::Create(LPCTSTR templateName, HWND parentWindow)
-{
- HWND aHWND = CreateDialogParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
- if (aHWND == 0)
- return false;
- Attach(aHWND);
- return true;
-}
-
-INT_PTR CModalDialog::Create(LPCTSTR templateName, HWND parentWindow)
-{
- return DialogBoxParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
-}
-
-#ifndef _UNICODE
-
-bool CModelessDialog::Create(LPCWSTR templateName, HWND parentWindow)
-{
- HWND aHWND;
- if (g_IsNT)
- aHWND = CreateDialogParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
- else
- {
- AString name;
- LPCSTR templateNameA;
- if (IS_INTRESOURCE(templateName))
- templateNameA = (LPCSTR)templateName;
- else
- {
- name = GetSystemString(templateName);
- templateNameA = name;
- }
- aHWND = CreateDialogParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
- }
- if (aHWND == 0)
- return false;
- Attach(aHWND);
- return true;
-}
-
-INT_PTR CModalDialog::Create(LPCWSTR templateName, HWND parentWindow)
-{
- if (g_IsNT)
- return DialogBoxParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
- AString name;
- LPCSTR templateNameA;
- if (IS_INTRESOURCE(templateName))
- templateNameA = (LPCSTR)templateName;
- else
- {
- name = GetSystemString(templateName);
- templateNameA = name;
- }
- return DialogBoxParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
-}
-#endif
-
-}}
+// Windows/Control/Dialog.cpp
+
+#include "StdAfx.h"
+
+// #include "../../Windows/DLL.h"
+
+#ifndef _UNICODE
+#include "../../Common/StringConvert.h"
+#endif
+
+#include "Dialog.h"
+
+extern HINSTANCE g_hInstance;
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NControl {
+
+static
+#ifdef Z7_OLD_WIN_SDK
+ BOOL
+#else
+ INT_PTR
+#endif
+APIENTRY
+DialogProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ CWindow tempDialog(dialogHWND);
+ if (message == WM_INITDIALOG)
+ tempDialog.SetUserDataLongPtr(lParam);
+ CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
+ if (dialog == NULL)
+ return FALSE;
+ if (message == WM_INITDIALOG)
+ dialog->Attach(dialogHWND);
+
+ /* MSDN: The dialog box procedure should return
+ TRUE - if it processed the message
+ FALSE - if it did not process the message
+ If the dialog box procedure returns FALSE,
+ the dialog manager performs the default dialog operation in response to the message.
+ */
+
+ try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
+ catch(...) { return TRUE; }
+}
+
+bool CDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case WM_INITDIALOG: return OnInit();
+ case WM_COMMAND: return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam);
+ case WM_NOTIFY: return OnNotify((UINT)wParam, (LPNMHDR) lParam);
+ case WM_TIMER: return OnTimer(wParam, lParam);
+ case WM_SIZE: return OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
+ case WM_DESTROY: return OnDestroy();
+ case WM_HELP: OnHelp(); return true;
+ /*
+ OnHelp(
+ #ifdef UNDER_CE
+ (void *)
+ #else
+ (LPHELPINFO)
+ #endif
+ lParam);
+ return true;
+ */
+ default: return false;
+ }
+}
+
+/*
+bool CDialog::OnCommand2(WPARAM wParam, LPARAM lParam)
+{
+ return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam);
+}
+*/
+
+bool CDialog::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+ if (code == BN_CLICKED)
+ return OnButtonClicked(itemID, (HWND)lParam);
+ return false;
+}
+
+bool CDialog::OnButtonClicked(unsigned buttonID, HWND /* buttonHWND */)
+{
+ switch (buttonID)
+ {
+ case IDOK: OnOK(); break;
+ case IDCANCEL: OnCancel(); break;
+ case IDCLOSE: OnClose(); break;
+ case IDHELP: OnHelp(); break;
+ default: return false;
+ }
+ return true;
+}
+
+#ifndef UNDER_CE
+/* in win2000/win98 : monitor functions are supported.
+ We need dynamic linking, if we want nt4/win95 support in program.
+ Even if we compile the code with low (WINVER) value, we still
+ want to use monitor functions. So we declare missing functions here */
+// #if (WINVER < 0x0500)
+#ifndef MONITOR_DEFAULTTOPRIMARY
+extern "C" {
+DECLARE_HANDLE(HMONITOR);
+#define MONITOR_DEFAULTTOPRIMARY 0x00000001
+typedef struct tagMONITORINFO
+{
+ DWORD cbSize;
+ RECT rcMonitor;
+ RECT rcWork;
+ DWORD dwFlags;
+} MONITORINFO, *LPMONITORINFO;
+WINUSERAPI HMONITOR WINAPI MonitorFromWindow(HWND hwnd, DWORD dwFlags);
+WINUSERAPI BOOL WINAPI GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpmi);
+}
+#endif
+#endif
+
+static bool GetWorkAreaRect(RECT *rect, HWND hwnd)
+{
+ if (hwnd)
+ {
+ #ifndef UNDER_CE
+ /* MonitorFromWindow() is supported in Win2000+
+ MonitorFromWindow() : retrieves a handle to the display monitor that has the
+ largest area of intersection with the bounding rectangle of a specified window.
+ dwFlags: Determines the function's return value if the window does not intersect any display monitor.
+ MONITOR_DEFAULTTONEAREST : Returns display that is nearest to the window.
+ MONITOR_DEFAULTTONULL : Returns NULL.
+ MONITOR_DEFAULTTOPRIMARY : Returns the primary display monitor.
+ */
+ const HMONITOR hmon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
+ if (hmon)
+ {
+ MONITORINFO mi;
+ memset(&mi, 0, sizeof(mi));
+ mi.cbSize = sizeof(mi);
+ if (GetMonitorInfoA(hmon, &mi))
+ {
+ *rect = mi.rcWork;
+ return true;
+ }
+ }
+ #endif
+ }
+
+ /* Retrieves the size of the work area on the primary display monitor.
+ The work area is the portion of the screen not obscured
+ by the system taskbar or by application desktop toolbars.
+ Any DPI virtualization mode of the caller has no effect on this output. */
+
+ return BOOLToBool(::SystemParametersInfo(SPI_GETWORKAREA, 0, rect, 0));
+}
+
+
+bool IsDialogSizeOK(int xSize, int ySize, HWND hwnd)
+{
+ // it returns for system font. Real font uses another values
+ const LONG v = GetDialogBaseUnits();
+ const int x = LOWORD(v);
+ const int y = HIWORD(v);
+
+ RECT rect;
+ GetWorkAreaRect(&rect, hwnd);
+ const int wx = RECT_SIZE_X(rect);
+ const int wy = RECT_SIZE_Y(rect);
+ return
+ xSize / 4 * x <= wx &&
+ ySize / 8 * y <= wy;
+}
+
+bool CDialog::GetMargins(int margin, int &x, int &y)
+{
+ x = margin;
+ y = margin;
+ RECT rect;
+ rect.left = 0;
+ rect.top = 0;
+ rect.right = margin;
+ rect.bottom = margin;
+ if (!MapRect(&rect))
+ return false;
+ x = rect.right - rect.left;
+ y = rect.bottom - rect.top;
+ return true;
+}
+
+int CDialog::Units_To_Pixels_X(int units)
+{
+ RECT rect;
+ rect.left = 0;
+ rect.top = 0;
+ rect.right = units;
+ rect.bottom = units;
+ if (!MapRect(&rect))
+ return units * 3 / 2;
+ return rect.right - rect.left;
+}
+
+bool CDialog::GetItemSizes(unsigned id, int &x, int &y)
+{
+ RECT rect;
+ if (!::GetWindowRect(GetItem(id), &rect))
+ return false;
+ x = RECT_SIZE_X(rect);
+ y = RECT_SIZE_Y(rect);
+ return true;
+}
+
+void CDialog::GetClientRectOfItem(unsigned id, RECT &rect)
+{
+ ::GetWindowRect(GetItem(id), &rect);
+ ScreenToClient(&rect);
+}
+
+bool CDialog::MoveItem(unsigned id, int x, int y, int width, int height, bool repaint)
+{
+ return BOOLToBool(::MoveWindow(GetItem(id), x, y, width, height, BoolToBOOL(repaint)));
+}
+
+
+/*
+typedef BOOL (WINAPI * Func_DwmGetWindowAttribute)(
+ HWND hwnd, DWORD dwAttribute, PVOID pvAttribute, DWORD cbAttribute);
+
+static bool GetWindowsRect_DWM(HWND hwnd, RECT *rect)
+{
+ // dll load and free is too slow : 300 calls in second.
+ NDLL::CLibrary dll;
+ if (!dll.Load(FTEXT("dwmapi.dll")))
+ return false;
+ Func_DwmGetWindowAttribute f = (Func_DwmGetWindowAttribute)dll.GetProc("DwmGetWindowAttribute" );
+ if (f)
+ {
+ #define MY__DWMWA_EXTENDED_FRAME_BOUNDS 9
+ // 30000 per second
+ RECT r;
+ if (f(hwnd, MY__DWMWA_EXTENDED_FRAME_BOUNDS, &r, sizeof(RECT)) == S_OK)
+ {
+ *rect = r;
+ return true;
+ }
+ }
+ return false;
+}
+*/
+
+
+static bool IsRect_Small_Inside_Big(const RECT &sm, const RECT &big)
+{
+ return sm.left >= big.left
+ && sm.right <= big.right
+ && sm.top >= big.top
+ && sm.bottom <= big.bottom;
+}
+
+
+static bool AreRectsOverlapped(const RECT &r1, const RECT &r2)
+{
+ return r1.left < r2.right
+ && r1.right > r2.left
+ && r1.top < r2.bottom
+ && r1.bottom > r2.top;
+}
+
+
+static bool AreRectsEqual(const RECT &r1, const RECT &r2)
+{
+ return r1.left == r2.left
+ && r1.right == r2.right
+ && r1.top == r2.top
+ && r1.bottom == r2.bottom;
+}
+
+
+void CDialog::NormalizeSize(bool fullNormalize)
+{
+ RECT workRect;
+ if (!GetWorkAreaRect(&workRect, *this))
+ return;
+ RECT rect;
+ if (!GetWindowRect(&rect))
+ return;
+ int xs = RECT_SIZE_X(rect);
+ int ys = RECT_SIZE_Y(rect);
+
+ // we don't want to change size using workRect, if window is outside of WorkArea
+ if (!AreRectsOverlapped(rect, workRect))
+ return;
+
+ /* here rect and workRect are overlapped, but it can be false
+ overlapping of small shadow when window in another display. */
+
+ const int xsW = RECT_SIZE_X(workRect);
+ const int ysW = RECT_SIZE_Y(workRect);
+ if (xs <= xsW && ys <= ysW)
+ return; // size of window is OK
+ if (fullNormalize)
+ {
+ Show(SW_SHOWMAXIMIZED);
+ return;
+ }
+ int x = workRect.left;
+ int y = workRect.top;
+ if (xs < xsW) x += (xsW - xs) / 2; else xs = xsW;
+ if (ys < ysW) y += (ysW - ys) / 2; else ys = ysW;
+ Move(x, y, xs, ys, true);
+}
+
+
+void CDialog::NormalizePosition()
+{
+ RECT workRect;
+ if (!GetWorkAreaRect(&workRect, *this))
+ return;
+
+ RECT rect2 = workRect;
+ bool useWorkArea = true;
+ const HWND parentHWND = GetParent();
+
+ if (parentHWND)
+ {
+ RECT workRectParent;
+ if (!GetWorkAreaRect(&workRectParent, parentHWND))
+ return;
+
+ // if windows are in different monitors, we use only workArea of current window
+
+ if (AreRectsEqual(workRectParent, workRect))
+ {
+ // RECT rect3; if (GetWindowsRect_DWM(parentHWND, &rect3)) {}
+ CWindow wnd(parentHWND);
+ if (wnd.GetWindowRect(&rect2))
+ {
+ // it's same monitor. So we try to use parentHWND rect.
+ /* we don't want to change position, if parent window is not inside work area.
+ In Win10 : parent window rect is 8 pixels larger for each corner than window size for shadow.
+ In maximize mode : window is outside of workRect.
+ if parent window is inside workRect, we will use parent window instead of workRect */
+ if (IsRect_Small_Inside_Big(rect2, workRect))
+ useWorkArea = false;
+ }
+ }
+ }
+
+ RECT rect;
+ if (!GetWindowRect(&rect))
+ return;
+
+ if (useWorkArea)
+ {
+ // we don't want to move window, if it's already inside.
+ if (IsRect_Small_Inside_Big(rect, workRect))
+ return;
+ // we don't want to move window, if it's outside of workArea
+ if (!AreRectsOverlapped(rect, workRect))
+ return;
+ rect2 = workRect;
+ }
+
+ {
+ const int xs = RECT_SIZE_X(rect);
+ const int ys = RECT_SIZE_Y(rect);
+ const int xs2 = RECT_SIZE_X(rect2);
+ const int ys2 = RECT_SIZE_Y(rect2);
+ // we don't want to change position if parent is smaller.
+ if (xs <= xs2 && ys <= ys2)
+ {
+ const int x = rect2.left + (xs2 - xs) / 2;
+ const int y = rect2.top + (ys2 - ys) / 2;
+
+ if (x != rect.left || y != rect.top)
+ Move(x, y, xs, ys, true);
+ // SetWindowPos(*this, HWND_TOP, x, y, 0, 0, SWP_NOSIZE);
+ return;
+ }
+ }
+}
+
+
+
+bool CModelessDialog::Create(LPCTSTR templateName, HWND parentWindow)
+{
+ const HWND aHWND = CreateDialogParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
+ if (!aHWND)
+ return false;
+ Attach(aHWND);
+ return true;
+}
+
+INT_PTR CModalDialog::Create(LPCTSTR templateName, HWND parentWindow)
+{
+ return DialogBoxParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
+}
+
+#ifndef _UNICODE
+
+bool CModelessDialog::Create(LPCWSTR templateName, HWND parentWindow)
+{
+ HWND aHWND;
+ if (g_IsNT)
+ aHWND = CreateDialogParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
+ else
+ {
+ AString name;
+ LPCSTR templateNameA;
+ if (IS_INTRESOURCE(templateName))
+ templateNameA = (LPCSTR)templateName;
+ else
+ {
+ name = GetSystemString(templateName);
+ templateNameA = name;
+ }
+ aHWND = CreateDialogParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
+ }
+ if (aHWND == 0)
+ return false;
+ Attach(aHWND);
+ return true;
+}
+
+INT_PTR CModalDialog::Create(LPCWSTR templateName, HWND parentWindow)
+{
+ if (g_IsNT)
+ return DialogBoxParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
+ AString name;
+ LPCSTR templateNameA;
+ if (IS_INTRESOURCE(templateName))
+ templateNameA = (LPCSTR)templateName;
+ else
+ {
+ name = GetSystemString(templateName);
+ templateNameA = name;
+ }
+ return DialogBoxParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
+}
+#endif
+
+}}
diff --git a/CPP/Windows/Control/Dialog.h b/CPP/Windows/Control/Dialog.h
index f9c3442..06be4bf 100644
--- a/CPP/Windows/Control/Dialog.h
+++ b/CPP/Windows/Control/Dialog.h
@@ -1,170 +1,194 @@
-// Windows/Control/Dialog.h
-
-#ifndef __WINDOWS_CONTROL_DIALOG_H
-#define __WINDOWS_CONTROL_DIALOG_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CDialog: public CWindow
-{
-public:
- CDialog(HWND wnd = NULL): CWindow(wnd){};
- virtual ~CDialog() {};
-
- HWND GetItem(int itemID) const
- { return GetDlgItem(_window, itemID); }
-
- bool EnableItem(int itemID, bool enable) const
- { return BOOLToBool(::EnableWindow(GetItem(itemID), BoolToBOOL(enable))); }
-
- bool ShowItem(int itemID, int cmdShow) const
- { return BOOLToBool(::ShowWindow(GetItem(itemID), cmdShow)); }
-
- bool ShowItem_Bool(int itemID, bool show) const
- { return ShowItem(itemID, show ? SW_SHOW: SW_HIDE); }
-
- bool HideItem(int itemID) const { return ShowItem(itemID, SW_HIDE); }
-
- bool SetItemText(int itemID, LPCTSTR s)
- { return BOOLToBool(SetDlgItemText(_window, itemID, s)); }
-
- #ifndef _UNICODE
- bool SetItemText(int itemID, LPCWSTR s)
- {
- CWindow window(GetItem(itemID));
- return window.SetText(s);
- }
- #endif
-
- UINT GetItemText(int itemID, LPTSTR string, int maxCount)
- { return GetDlgItemText(_window, itemID, string, maxCount); }
- #ifndef _UNICODE
- /*
- bool GetItemText(int itemID, LPWSTR string, int maxCount)
- {
- CWindow window(GetItem(itemID));
- return window.GetText(string, maxCount);
- }
- */
- #endif
-
- bool SetItemInt(int itemID, UINT value, bool isSigned)
- { return BOOLToBool(SetDlgItemInt(_window, itemID, value, BoolToBOOL(isSigned))); }
- bool GetItemInt(int itemID, bool isSigned, UINT &value)
- {
- BOOL result;
- value = GetDlgItemInt(_window, itemID, &result, BoolToBOOL(isSigned));
- return BOOLToBool(result);
- }
-
- HWND GetNextGroupItem(HWND control, bool previous)
- { return GetNextDlgGroupItem(_window, control, BoolToBOOL(previous)); }
- HWND GetNextTabItem(HWND control, bool previous)
- { return GetNextDlgTabItem(_window, control, BoolToBOOL(previous)); }
-
- bool MapRect(LPRECT rect)
- { return BOOLToBool(MapDialogRect(_window, rect)); }
-
- bool IsMessage(LPMSG message)
- { return BOOLToBool(IsDialogMessage(_window, message)); }
-
- LRESULT SendItemMessage(int itemID, UINT message, WPARAM wParam, LPARAM lParam)
- { return SendDlgItemMessage(_window, itemID, message, wParam, lParam); }
-
- bool CheckButton(int buttonID, UINT checkState)
- { return BOOLToBool(CheckDlgButton(_window, buttonID, checkState)); }
- bool CheckButton(int buttonID, bool checkState)
- { return CheckButton(buttonID, UINT(checkState ? BST_CHECKED : BST_UNCHECKED)); }
-
- UINT IsButtonChecked(int buttonID) const
- { return IsDlgButtonChecked(_window, buttonID); }
- bool IsButtonCheckedBool(int buttonID) const
- { return (IsButtonChecked(buttonID) == BST_CHECKED); }
-
- bool CheckRadioButton(int firstButtonID, int lastButtonID, int checkButtonID)
- { return BOOLToBool(::CheckRadioButton(_window, firstButtonID, lastButtonID, checkButtonID)); }
-
- virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
- virtual bool OnInit() { return true; }
- virtual bool OnCommand(WPARAM wParam, LPARAM lParam);
- virtual bool OnCommand(int code, int itemID, LPARAM lParam);
- virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
-
- /*
- #ifdef UNDER_CE
- virtual void OnHelp(void *) { OnHelp(); }
- #else
- virtual void OnHelp(LPHELPINFO) { OnHelp(); }
- #endif
- */
- virtual void OnHelp() {};
-
- virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
- virtual void OnOK() {};
- virtual void OnCancel() {};
- virtual void OnClose() {}
- virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */) { return false; }
- virtual bool OnTimer(WPARAM /* timerID */, LPARAM /* callback */) { return false; }
-
- LONG_PTR SetMsgResult(LONG_PTR newLongPtr )
- { return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
- LONG_PTR GetMsgResult() const
- { return GetLongPtr(DWLP_MSGRESULT); }
-
- bool GetMargins(int margin, int &x, int &y);
- int Units_To_Pixels_X(int units);
- bool GetItemSizes(int id, int &x, int &y);
- void GetClientRectOfItem(int id, RECT &rect);
- bool MoveItem(int id, int x, int y, int width, int height, bool repaint = true);
-
- void NormalizeSize(bool fullNormalize = false);
- void NormalizePosition();
-};
-
-class CModelessDialog: public CDialog
-{
-public:
- bool Create(LPCTSTR templateName, HWND parentWindow);
- bool Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
- #ifndef _UNICODE
- bool Create(LPCWSTR templateName, HWND parentWindow);
- #endif
- virtual void OnOK() { Destroy(); }
- virtual void OnCancel() { Destroy(); }
- virtual void OnClose() { Destroy(); }
-};
-
-class CModalDialog: public CDialog
-{
-public:
- INT_PTR Create(LPCTSTR templateName, HWND parentWindow);
- INT_PTR Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
- #ifndef _UNICODE
- INT_PTR Create(LPCWSTR templateName, HWND parentWindow);
- #endif
-
- bool End(INT_PTR result) { return BOOLToBool(::EndDialog(_window, result)); }
- virtual void OnOK() { End(IDOK); }
- virtual void OnCancel() { End(IDCANCEL); }
- virtual void OnClose() { End(IDCLOSE); }
-};
-
-class CDialogChildControl: public NWindows::CWindow
-{
- int m_ID;
-public:
- void Init(const NWindows::NControl::CDialog &parentDialog, int id)
- {
- m_ID = id;
- Attach(parentDialog.GetItem(id));
- }
-};
-
-bool IsDialogSizeOK(int xSize, int ySize);
-
-}}
-
-#endif
+// Windows/Control/Dialog.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_DIALOG_H
+#define ZIP7_INC_WINDOWS_CONTROL_DIALOG_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CDialog: public CWindow
+{
+ // Z7_CLASS_NO_COPY(CDialog)
+public:
+ CDialog(HWND wnd = NULL): CWindow(wnd) {}
+ virtual ~CDialog() {}
+
+ HWND GetItem(unsigned itemID) const
+ { return GetDlgItem(_window, (int)itemID); }
+
+ bool EnableItem(unsigned itemID, bool enable) const
+ { return BOOLToBool(::EnableWindow(GetItem(itemID), BoolToBOOL(enable))); }
+
+ bool ShowItem(unsigned itemID, int cmdShow) const
+ { return BOOLToBool(::ShowWindow(GetItem(itemID), cmdShow)); }
+
+ bool ShowItem_Bool(unsigned itemID, bool show) const
+ { return ShowItem(itemID, show ? SW_SHOW: SW_HIDE); }
+
+ bool HideItem(unsigned itemID) const { return ShowItem(itemID, SW_HIDE); }
+
+ bool SetItemText(unsigned itemID, LPCTSTR s)
+ { return BOOLToBool(SetDlgItemText(_window, (int)itemID, s)); }
+
+ bool SetItemTextA(unsigned itemID, LPCSTR s)
+ { return BOOLToBool(SetDlgItemTextA(_window, (int)itemID, s)); }
+
+ bool SetItemText_Empty(unsigned itemID)
+ { return SetItemText(itemID, TEXT("")); }
+
+ #ifndef _UNICODE
+ bool SetItemText(unsigned itemID, LPCWSTR s)
+ {
+ CWindow window(GetItem(itemID));
+ return window.SetText(s);
+ }
+ #endif
+
+ UINT GetItemText(unsigned itemID, LPTSTR string, unsigned maxCount)
+ { return GetDlgItemText(_window, (int)itemID, string, (int)maxCount); }
+ #ifndef _UNICODE
+ /*
+ bool GetItemText(unsigned itemID, LPWSTR string, int maxCount)
+ {
+ CWindow window(GetItem(unsigned));
+ return window.GetText(string, maxCount);
+ }
+ */
+ #endif
+
+ bool GetItemText(unsigned itemID, UString &s)
+ {
+ CWindow window(GetItem(itemID));
+ return window.GetText(s);
+ }
+
+ bool SetItemInt(unsigned itemID, UINT value, bool isSigned)
+ { return BOOLToBool(SetDlgItemInt(_window, (int)itemID, value, BoolToBOOL(isSigned))); }
+ bool GetItemInt(unsigned itemID, bool isSigned, UINT &value)
+ {
+ BOOL result;
+ value = GetDlgItemInt(_window, (int)itemID, &result, BoolToBOOL(isSigned));
+ return BOOLToBool(result);
+ }
+
+ HWND GetNextGroupItem(HWND control, bool previous)
+ { return GetNextDlgGroupItem(_window, control, BoolToBOOL(previous)); }
+ HWND GetNextTabItem(HWND control, bool previous)
+ { return GetNextDlgTabItem(_window, control, BoolToBOOL(previous)); }
+
+ LRESULT SendMsg_NextDlgCtl(WPARAM wParam, LPARAM lParam)
+ { return SendMsg(WM_NEXTDLGCTL, wParam, lParam); }
+ LRESULT SendMsg_NextDlgCtl_HWND(HWND hwnd) { return SendMsg_NextDlgCtl((WPARAM)hwnd, TRUE); }
+ LRESULT SendMsg_NextDlgCtl_CtlId(unsigned id) { return SendMsg_NextDlgCtl_HWND(GetItem(id)); }
+ LRESULT SendMsg_NextDlgCtl_Next() { return SendMsg_NextDlgCtl(0, FALSE); }
+ LRESULT SendMsg_NextDlgCtl_Prev() { return SendMsg_NextDlgCtl(1, FALSE); }
+
+ bool MapRect(LPRECT rect)
+ { return BOOLToBool(MapDialogRect(_window, rect)); }
+
+ bool IsMessage(LPMSG message)
+ { return BOOLToBool(IsDialogMessage(_window, message)); }
+
+ LRESULT SendItemMessage(unsigned itemID, UINT message, WPARAM wParam, LPARAM lParam)
+ { return SendDlgItemMessage(_window, (int)itemID, message, wParam, lParam); }
+
+ bool CheckButton(unsigned buttonID, UINT checkState)
+ { return BOOLToBool(CheckDlgButton(_window, (int)buttonID, checkState)); }
+ bool CheckButton(unsigned buttonID, bool checkState)
+ { return CheckButton(buttonID, UINT(checkState ? BST_CHECKED : BST_UNCHECKED)); }
+
+ UINT IsButtonChecked_BST(unsigned buttonID) const
+ { return IsDlgButtonChecked(_window, (int)buttonID); }
+ bool IsButtonCheckedBool(unsigned buttonID) const
+ { return (IsButtonChecked_BST(buttonID) == BST_CHECKED); }
+
+ bool CheckRadioButton(unsigned firstButtonID, unsigned lastButtonID, unsigned checkButtonID)
+ { return BOOLToBool(::CheckRadioButton(_window,
+ (int)firstButtonID, (int)lastButtonID, (int)checkButtonID)); }
+
+ virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+ virtual bool OnInit() { return true; }
+ // virtual bool OnCommand2(WPARAM wParam, LPARAM lParam);
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam);
+ virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
+ virtual bool OnDestroy() { return false; }
+
+ /*
+ #ifdef UNDER_CE
+ virtual void OnHelp(void *) { OnHelp(); }
+ #else
+ virtual void OnHelp(LPHELPINFO) { OnHelp(); }
+ #endif
+ */
+ virtual void OnHelp() {}
+
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND);
+ virtual void OnOK() {}
+ virtual void OnCancel() {}
+ virtual void OnClose() {}
+ virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */) { return false; }
+ virtual bool OnTimer(WPARAM /* timerID */, LPARAM /* callback */) { return false; }
+
+ LONG_PTR SetMsgResult(LONG_PTR newLongPtr )
+ { return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
+ LONG_PTR GetMsgResult() const
+ { return GetLongPtr(DWLP_MSGRESULT); }
+
+ bool GetMargins(int margin, int &x, int &y);
+ int Units_To_Pixels_X(int units);
+ bool GetItemSizes(unsigned id, int &x, int &y);
+ void GetClientRectOfItem(unsigned id, RECT &rect);
+ bool MoveItem(unsigned id, int x, int y, int width, int height, bool repaint = true);
+ bool MoveItem_RECT(unsigned id, const RECT &r, bool repaint = true)
+ { return MoveItem(id, r.left, r.top, RECT_SIZE_X(r), RECT_SIZE_Y(r), repaint); }
+
+ void NormalizeSize(bool fullNormalize = false);
+ void NormalizePosition();
+};
+
+class CModelessDialog: public CDialog
+{
+public:
+ bool Create(LPCTSTR templateName, HWND parentWindow);
+ bool Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
+ #ifndef _UNICODE
+ bool Create(LPCWSTR templateName, HWND parentWindow);
+ #endif
+ virtual void OnOK() Z7_override { Destroy(); }
+ virtual void OnCancel() Z7_override { Destroy(); }
+ virtual void OnClose() Z7_override { Destroy(); }
+};
+
+class CModalDialog: public CDialog
+{
+public:
+ INT_PTR Create(LPCTSTR templateName, HWND parentWindow);
+ INT_PTR Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
+ #ifndef _UNICODE
+ INT_PTR Create(LPCWSTR templateName, HWND parentWindow);
+ #endif
+
+ bool End(INT_PTR result) { return BOOLToBool(::EndDialog(_window, result)); }
+ virtual void OnOK() Z7_override { End(IDOK); }
+ virtual void OnCancel() Z7_override { End(IDCANCEL); }
+ virtual void OnClose() Z7_override { End(IDCLOSE); }
+};
+
+class CDialogChildControl: public NWindows::CWindow
+{
+ // unsigned m_ID;
+public:
+ void Init(const NWindows::NControl::CDialog &parentDialog, unsigned id)
+ {
+ // m_ID = id;
+ Attach(parentDialog.GetItem(id));
+ }
+};
+
+bool IsDialogSizeOK(int xSize, int ySize, HWND hwnd = NULL);
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/Edit.h b/CPP/Windows/Control/Edit.h
index 4f503aa..963470d 100644
--- a/CPP/Windows/Control/Edit.h
+++ b/CPP/Windows/Control/Edit.h
@@ -1,19 +1,19 @@
-// Windows/Control/Edit.h
-
-#ifndef __WINDOWS_CONTROL_EDIT_H
-#define __WINDOWS_CONTROL_EDIT_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CEdit: public CWindow
-{
-public:
- void SetPasswordChar(WPARAM c) { SendMsg(EM_SETPASSWORDCHAR, c); }
-};
-
-}}
-
-#endif
+// Windows/Control/Edit.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_EDIT_H
+#define ZIP7_INC_WINDOWS_CONTROL_EDIT_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CEdit: public CWindow
+{
+public:
+ void SetPasswordChar(WPARAM c) { SendMsg(EM_SETPASSWORDCHAR, c); }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/ImageList.cpp b/CPP/Windows/Control/ImageList.cpp
index d201c8f..3e22b95 100644
--- a/CPP/Windows/Control/ImageList.cpp
+++ b/CPP/Windows/Control/ImageList.cpp
@@ -1,10 +1,10 @@
-// Windows/Control/ImageList.cpp
-
-#include "StdAfx.h"
-
-#include "ImageList.h"
-
-namespace NWindows {
-namespace NControl {
-
-}}
+// Windows/Control/ImageList.cpp
+
+#include "StdAfx.h"
+
+#include "ImageList.h"
+
+namespace NWindows {
+namespace NControl {
+
+}}
diff --git a/CPP/Windows/Control/ImageList.h b/CPP/Windows/Control/ImageList.h
index f72ea0d..688f177 100644
--- a/CPP/Windows/Control/ImageList.h
+++ b/CPP/Windows/Control/ImageList.h
@@ -1,87 +1,87 @@
-// Windows/Control/ImageList.h
-
-#ifndef __WINDOWS_CONTROL_IMAGE_LIST_H
-#define __WINDOWS_CONTROL_IMAGE_LIST_H
-
-#include <commctrl.h>
-
-#include "../Defs.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CImageList
-{
- HIMAGELIST m_Object;
-public:
- operator HIMAGELIST() const {return m_Object; }
- CImageList(): m_Object(NULL) {}
- bool Attach(HIMAGELIST imageList)
- {
- if (imageList == NULL)
- return false;
- m_Object = imageList;
- return true;
- }
-
- HIMAGELIST Detach()
- {
- HIMAGELIST imageList = m_Object;
- m_Object = NULL;
- return imageList;
- }
-
- bool Create(int width, int height, UINT flags, int initialNumber, int grow)
- {
- HIMAGELIST a = ImageList_Create(width, height, flags,
- initialNumber, grow);
- if (a == NULL)
- return false;
- return Attach(a);
- }
-
- bool Destroy() // DeleteImageList() in MFC
- {
- if (m_Object == NULL)
- return false;
- return BOOLToBool(ImageList_Destroy(Detach()));
- }
-
- ~CImageList()
- { Destroy(); }
-
- int GetImageCount() const
- { return ImageList_GetImageCount(m_Object); }
-
- bool GetImageInfo(int index, IMAGEINFO* imageInfo) const
- { return BOOLToBool(ImageList_GetImageInfo(m_Object, index, imageInfo)); }
-
- int Add(HBITMAP hbmImage, HBITMAP hbmMask = 0)
- { return ImageList_Add(m_Object, hbmImage, hbmMask); }
- int AddMasked(HBITMAP hbmImage, COLORREF mask)
- { return ImageList_AddMasked(m_Object, hbmImage, mask); }
- int AddIcon(HICON icon)
- { return ImageList_AddIcon(m_Object, icon); }
- int Replace(int index, HICON icon)
- { return ImageList_ReplaceIcon(m_Object, index, icon); }
-
- // If index is -1, the function removes all images.
- bool Remove(int index)
- { return BOOLToBool(ImageList_Remove(m_Object, index)); }
- bool RemoveAll()
- { return BOOLToBool(ImageList_RemoveAll(m_Object)); }
-
- HICON ExtractIcon(int index)
- { return ImageList_ExtractIcon(NULL, m_Object, index); }
- HICON GetIcon(int index, UINT flags)
- { return ImageList_GetIcon(m_Object, index, flags); }
-
- bool GetIconSize(int &width, int &height) const
- { return BOOLToBool(ImageList_GetIconSize(m_Object, &width, &height)); }
- bool SetIconSize(int width, int height)
- { return BOOLToBool(ImageList_SetIconSize(m_Object, width, height)); }
-};
-
-}}
-
-#endif
+// Windows/Control/ImageList.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_IMAGE_LIST_H
+#define ZIP7_INC_WINDOWS_CONTROL_IMAGE_LIST_H
+
+#include <CommCtrl.h>
+
+#include "../Defs.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CImageList
+{
+ HIMAGELIST m_Object;
+public:
+ operator HIMAGELIST() const {return m_Object; }
+ CImageList(): m_Object(NULL) {}
+ bool Attach(HIMAGELIST imageList)
+ {
+ if (imageList == NULL)
+ return false;
+ m_Object = imageList;
+ return true;
+ }
+
+ HIMAGELIST Detach()
+ {
+ HIMAGELIST imageList = m_Object;
+ m_Object = NULL;
+ return imageList;
+ }
+
+ bool Create(int width, int height, UINT flags, int initialNumber, int grow)
+ {
+ HIMAGELIST a = ImageList_Create(width, height, flags,
+ initialNumber, grow);
+ if (a == NULL)
+ return false;
+ return Attach(a);
+ }
+
+ bool Destroy() // DeleteImageList() in MFC
+ {
+ if (m_Object == NULL)
+ return false;
+ return BOOLToBool(ImageList_Destroy(Detach()));
+ }
+
+ ~CImageList()
+ { Destroy(); }
+
+ int GetImageCount() const
+ { return ImageList_GetImageCount(m_Object); }
+
+ bool GetImageInfo(int index, IMAGEINFO* imageInfo) const
+ { return BOOLToBool(ImageList_GetImageInfo(m_Object, index, imageInfo)); }
+
+ int Add(HBITMAP hbmImage, HBITMAP hbmMask = NULL)
+ { return ImageList_Add(m_Object, hbmImage, hbmMask); }
+ int AddMasked(HBITMAP hbmImage, COLORREF mask)
+ { return ImageList_AddMasked(m_Object, hbmImage, mask); }
+ int AddIcon(HICON icon)
+ { return ImageList_AddIcon(m_Object, icon); }
+ int Replace(int index, HICON icon)
+ { return ImageList_ReplaceIcon(m_Object, index, icon); }
+
+ // If index is -1, the function removes all images.
+ bool Remove(int index)
+ { return BOOLToBool(ImageList_Remove(m_Object, index)); }
+ bool RemoveAll()
+ { return BOOLToBool(ImageList_RemoveAll(m_Object)); }
+
+ HICON ExtractIcon(int index)
+ { return ImageList_ExtractIcon(NULL, m_Object, index); }
+ HICON GetIcon(int index, UINT flags)
+ { return ImageList_GetIcon(m_Object, index, flags); }
+
+ bool GetIconSize(int &width, int &height) const
+ { return BOOLToBool(ImageList_GetIconSize(m_Object, &width, &height)); }
+ bool SetIconSize(int width, int height)
+ { return BOOLToBool(ImageList_SetIconSize(m_Object, width, height)); }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/ListView.cpp b/CPP/Windows/Control/ListView.cpp
index fb22f95..3e8786a 100644
--- a/CPP/Windows/Control/ListView.cpp
+++ b/CPP/Windows/Control/ListView.cpp
@@ -1,155 +1,162 @@
-// Windows/Control/ListView.cpp
-
-#include "StdAfx.h"
-
-#include "ListView.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NControl {
-
-bool CListView::CreateEx(DWORD exStyle, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam)
-{
- return CWindow::CreateEx(exStyle, WC_LISTVIEW, TEXT(""), style, x, y, width,
- height, parentWindow, idOrHMenu, instance, createParam);
-}
-
-bool CListView::GetItemParam(int index, LPARAM ¶m) const
-{
- LVITEM item;
- item.iItem = index;
- item.iSubItem = 0;
- item.mask = LVIF_PARAM;
- bool aResult = GetItem(&item);
- param = item.lParam;
- return aResult;
-}
-
-int CListView::InsertColumn(int columnIndex, LPCTSTR text, int width)
-{
- LVCOLUMN ci;
- ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
- ci.pszText = (LPTSTR)text;
- ci.iSubItem = columnIndex;
- ci.cx = width;
- return InsertColumn(columnIndex, &ci);
-}
-
-int CListView::InsertItem(int index, LPCTSTR text)
-{
- LVITEM item;
- item.mask = LVIF_TEXT | LVIF_PARAM;
- item.iItem = index;
- item.lParam = index;
- item.pszText = (LPTSTR)text;
- item.iSubItem = 0;
- return InsertItem(&item);
-}
-
-int CListView::SetSubItem(int index, int subIndex, LPCTSTR text)
-{
- LVITEM item;
- item.mask = LVIF_TEXT;
- item.iItem = index;
- item.pszText = (LPTSTR)text;
- item.iSubItem = subIndex;
- return SetItem(&item);
-}
-
-#ifndef _UNICODE
-
-int CListView::InsertColumn(int columnIndex, LPCWSTR text, int width)
-{
- LVCOLUMNW ci;
- ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
- ci.pszText = (LPWSTR)text;
- ci.iSubItem = columnIndex;
- ci.cx = width;
- return InsertColumn(columnIndex, &ci);
-}
-
-int CListView::InsertItem(int index, LPCWSTR text)
-{
- LVITEMW item;
- item.mask = LVIF_TEXT | LVIF_PARAM;
- item.iItem = index;
- item.lParam = index;
- item.pszText = (LPWSTR)text;
- item.iSubItem = 0;
- return InsertItem(&item);
-}
-
-int CListView::SetSubItem(int index, int subIndex, LPCWSTR text)
-{
- LVITEMW item;
- item.mask = LVIF_TEXT;
- item.iItem = index;
- item.pszText = (LPWSTR)text;
- item.iSubItem = subIndex;
- return SetItem(&item);
-}
-
-#endif
-
-static LRESULT APIENTRY ListViewSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
-{
- CWindow window(hwnd);
- CListView2 *w = (CListView2 *)(window.GetUserDataLongPtr());
- if (w == NULL)
- return 0;
- return w->OnMessage(message, wParam, lParam);
-}
-
-LRESULT CListView2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- #ifndef _UNICODE
- if (g_IsNT)
- return CallWindowProcW(_origWindowProc, *this, message, wParam, lParam);
- else
- #endif
- return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
-}
-
-void CListView2::SetWindowProc()
-{
- SetUserDataLongPtr((LONG_PTR)this);
- #ifndef _UNICODE
- if (g_IsNT)
- _origWindowProc = (WNDPROC)SetLongPtrW(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
- else
- #endif
- _origWindowProc = (WNDPROC)SetLongPtr(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
-}
-
-/*
-LRESULT CListView3::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- LRESULT res = CListView2::OnMessage(message, wParam, lParam);
- if (message == WM_GETDLGCODE)
- {
- // when user presses RETURN, windows sends default (first) button command to parent dialog.
- // we disable this:
- MSG *msg = (MSG *)lParam;
- WPARAM key = wParam;
- bool change = false;
- if (msg)
- {
- if (msg->message == WM_KEYDOWN && msg->wParam == VK_RETURN)
- change = true;
- }
- else if (wParam == VK_RETURN)
- change = true;
- if (change)
- res |= DLGC_WANTALLKEYS;
- }
- return res;
-}
-*/
-
-}}
+// Windows/Control/ListView.cpp
+
+#include "StdAfx.h"
+
+#include "ListView.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NControl {
+
+bool CListView::CreateEx(DWORD exStyle, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam)
+{
+ return CWindow::CreateEx(exStyle, WC_LISTVIEW, TEXT(""), style, x, y, width,
+ height, parentWindow, idOrHMenu, instance, createParam);
+}
+
+/* note: LVITEM and LVCOLUMN structures contain optional fields
+ depending from preprocessor macros:
+ #if (_WIN32_IE >= 0x0300)
+ #if (_WIN32_WINNT >= 0x0501)
+ #if (_WIN32_WINNT >= 0x0600)
+*/
+
+bool CListView::GetItemParam(unsigned index, LPARAM ¶m) const
+{
+ LVITEM item;
+ item.iItem = (int)index;
+ item.iSubItem = 0;
+ item.mask = LVIF_PARAM;
+ const bool res = GetItem(&item);
+ param = item.lParam;
+ return res;
+}
+
+int CListView::InsertColumn(unsigned columnIndex, LPCTSTR text, int width)
+{
+ LVCOLUMN ci;
+ ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
+ ci.pszText = (LPTSTR)(void *)text;
+ ci.iSubItem = (int)columnIndex;
+ ci.cx = width;
+ return InsertColumn(columnIndex, &ci);
+}
+
+int CListView::InsertItem(unsigned index, LPCTSTR text)
+{
+ LVITEM item;
+ item.mask = LVIF_TEXT | LVIF_PARAM;
+ item.iItem = (int)index;
+ item.lParam = (LPARAM)index;
+ item.pszText = (LPTSTR)(void *)text;
+ item.iSubItem = 0;
+ return InsertItem(&item);
+}
+
+int CListView::SetSubItem(unsigned index, unsigned subIndex, LPCTSTR text)
+{
+ LVITEM item;
+ item.mask = LVIF_TEXT;
+ item.iItem = (int)index;
+ item.pszText = (LPTSTR)(void *)text;
+ item.iSubItem = (int)subIndex;
+ return SetItem(&item);
+}
+
+#ifndef _UNICODE
+
+int CListView::InsertColumn(unsigned columnIndex, LPCWSTR text, int width)
+{
+ LVCOLUMNW ci;
+ ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
+ ci.pszText = (LPWSTR)(void *)text;
+ ci.iSubItem = (int)columnIndex;
+ ci.cx = width;
+ return InsertColumn(columnIndex, &ci);
+}
+
+int CListView::InsertItem(unsigned index, LPCWSTR text)
+{
+ LVITEMW item;
+ item.mask = LVIF_TEXT | LVIF_PARAM;
+ item.iItem = (int)index;
+ item.lParam = (LPARAM)index;
+ item.pszText = (LPWSTR)(void *)text;
+ item.iSubItem = 0;
+ return InsertItem(&item);
+}
+
+int CListView::SetSubItem(unsigned index, unsigned subIndex, LPCWSTR text)
+{
+ LVITEMW item;
+ item.mask = LVIF_TEXT;
+ item.iItem = (int)index;
+ item.pszText = (LPWSTR)(void *)text;
+ item.iSubItem = (int)subIndex;
+ return SetItem(&item);
+}
+
+#endif
+
+static LRESULT APIENTRY ListViewSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ CWindow window(hwnd);
+ CListView2 *w = (CListView2 *)(window.GetUserDataLongPtr());
+ if (w == NULL)
+ return 0;
+ return w->OnMessage(message, wParam, lParam);
+}
+
+LRESULT CListView2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ #ifndef _UNICODE
+ if (g_IsNT)
+ return CallWindowProcW(_origWindowProc, *this, message, wParam, lParam);
+ else
+ #endif
+ return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
+}
+
+void CListView2::SetWindowProc()
+{
+ SetUserDataLongPtr((LONG_PTR)this);
+ #ifndef _UNICODE
+ if (g_IsNT)
+ _origWindowProc = (WNDPROC)SetLongPtrW(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
+ else
+ #endif
+ _origWindowProc = (WNDPROC)SetLongPtr(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
+}
+
+/*
+LRESULT CListView3::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ LRESULT res = CListView2::OnMessage(message, wParam, lParam);
+ if (message == WM_GETDLGCODE)
+ {
+ // when user presses RETURN, windows sends default (first) button command to parent dialog.
+ // we disable this:
+ MSG *msg = (MSG *)lParam;
+ WPARAM key = wParam;
+ bool change = false;
+ if (msg)
+ {
+ if (msg->message == WM_KEYDOWN && msg->wParam == VK_RETURN)
+ change = true;
+ }
+ else if (wParam == VK_RETURN)
+ change = true;
+ if (change)
+ res |= DLGC_WANTALLKEYS;
+ }
+ return res;
+}
+*/
+
+}}
diff --git a/CPP/Windows/Control/ListView.h b/CPP/Windows/Control/ListView.h
index 1ed496d..11a33a0 100644
--- a/CPP/Windows/Control/ListView.h
+++ b/CPP/Windows/Control/ListView.h
@@ -1,146 +1,156 @@
-// Windows/Control/ListView.h
-
-#ifndef __WINDOWS_CONTROL_LISTVIEW_H
-#define __WINDOWS_CONTROL_LISTVIEW_H
-
-#include "../../Common/MyWindows.h"
-
-#include <commctrl.h>
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CListView: public NWindows::CWindow
-{
-public:
- bool CreateEx(DWORD exStyle, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam);
-
- void SetUnicodeFormat()
- {
- #ifndef UNDER_CE
- ListView_SetUnicodeFormat(_window, TRUE);
- #endif
- }
-
- bool DeleteAllItems() { return BOOLToBool(ListView_DeleteAllItems(_window)); }
- bool DeleteColumn(int columnIndex) { return BOOLToBool(ListView_DeleteColumn(_window, columnIndex)); }
-
- int InsertColumn(int columnIndex, const LVCOLUMN *columnInfo) { return ListView_InsertColumn(_window, columnIndex, columnInfo); }
- int InsertColumn(int columnIndex, LPCTSTR text, int width);
- bool SetColumnOrderArray(int count, const int *columns) { return BOOLToBool(ListView_SetColumnOrderArray(_window, count, columns)); }
-
- /*
- int GetNumColumns()
- {
- HWND header = ListView_GetHeader(_window);
- if (!header)
- return -1;
- return Header_GetItemCount(header);
- }
- */
-
- int InsertItem(const LVITEM* item) { return ListView_InsertItem(_window, item); }
- int InsertItem(int index, LPCTSTR text);
- bool SetItem(const LVITEM* item) { return BOOLToBool(ListView_SetItem(_window, item)); }
- int SetSubItem(int index, int subIndex, LPCTSTR text);
-
- #ifndef _UNICODE
-
- int InsertColumn(int columnIndex, const LVCOLUMNW *columnInfo) { return (int)SendMsg(LVM_INSERTCOLUMNW, (WPARAM)columnIndex, (LPARAM)columnInfo); }
- int InsertColumn(int columnIndex, LPCWSTR text, int width);
- int InsertItem(const LV_ITEMW* item) { return (int)SendMsg(LVM_INSERTITEMW, 0, (LPARAM)item); }
- int InsertItem(int index, LPCWSTR text);
- bool SetItem(const LV_ITEMW* item) { return BOOLToBool((BOOL)SendMsg(LVM_SETITEMW, 0, (LPARAM)item)); }
- int SetSubItem(int index, int subIndex, LPCWSTR text);
-
- #endif
-
- bool DeleteItem(int itemIndex) { return BOOLToBool(ListView_DeleteItem(_window, itemIndex)); }
-
- UINT GetSelectedCount() const { return ListView_GetSelectedCount(_window); }
- int GetItemCount() const { return ListView_GetItemCount(_window); }
-
- INT GetSelectionMark() const { return ListView_GetSelectionMark(_window); }
-
- void SetItemCount(int numItems) { ListView_SetItemCount(_window, numItems); }
- void SetItemCountEx(int numItems, DWORD flags) { ListView_SetItemCountEx(_window, numItems, flags); }
-
- int GetNextItem(int startIndex, UINT flags) const { return ListView_GetNextItem(_window, startIndex, flags); }
- int GetNextSelectedItem(int startIndex) const { return GetNextItem(startIndex, LVNI_SELECTED); }
- int GetFocusedItem() const { return GetNextItem(-1, LVNI_FOCUSED); }
-
- bool GetItem(LVITEM* item) const { return BOOLToBool(ListView_GetItem(_window, item)); }
- bool GetItemParam(int itemIndex, LPARAM ¶m) const;
- void GetItemText(int itemIndex, int subItemIndex, LPTSTR text, int textSizeMax) const
- { ListView_GetItemText(_window, itemIndex, subItemIndex, text, textSizeMax); }
- bool SortItems(PFNLVCOMPARE compareFunction, LPARAM dataParam)
- { return BOOLToBool(ListView_SortItems(_window, compareFunction, dataParam)); }
-
- void SetItemState(int index, UINT state, UINT mask) { ListView_SetItemState(_window, index, state, mask); }
- void SetItemState_Selected(int index, bool select) { SetItemState(index, select ? LVIS_SELECTED : 0, LVIS_SELECTED); }
- void SetItemState_Selected(int index) { SetItemState(index, LVIS_SELECTED, LVIS_SELECTED); }
- void SelectAll() { SetItemState_Selected(-1); }
- void SetItemState_FocusedSelected(int index) { SetItemState(index, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED); }
- UINT GetItemState(int index, UINT mask) const { return ListView_GetItemState(_window, index, mask); }
- bool IsItemSelected(int index) const { return GetItemState(index, LVIS_SELECTED) == LVIS_SELECTED; }
-
- bool GetColumn(int columnIndex, LVCOLUMN* columnInfo) const
- { return BOOLToBool(ListView_GetColumn(_window, columnIndex, columnInfo)); }
-
- HIMAGELIST SetImageList(HIMAGELIST imageList, int imageListType)
- { return ListView_SetImageList(_window, imageList, imageListType); }
-
- // version 4.70: NT5 | (NT4 + ie3) | w98 | (w95 + ie3)
- DWORD GetExtendedListViewStyle() { return ListView_GetExtendedListViewStyle(_window); }
- void SetExtendedListViewStyle(DWORD exStyle) { ListView_SetExtendedListViewStyle(_window, exStyle); }
- void SetExtendedListViewStyle(DWORD exMask, DWORD exStyle) { ListView_SetExtendedListViewStyleEx(_window, exMask, exStyle); }
-
- void SetCheckState(UINT index, bool checkState) { ListView_SetCheckState(_window, index, BoolToBOOL(checkState)); }
- bool GetCheckState(UINT index) { return BOOLToBool(ListView_GetCheckState(_window, index)); }
-
- bool EnsureVisible(int index, bool partialOK) { return BOOLToBool(ListView_EnsureVisible(_window, index, BoolToBOOL(partialOK))); }
-
- bool GetItemRect(int index, RECT *rect, int code) { return BOOLToBool(ListView_GetItemRect(_window, index, rect, code)); }
-
- HWND GetEditControl() { return ListView_GetEditControl(_window) ; }
- HWND EditLabel(int itemIndex) { return ListView_EditLabel(_window, itemIndex) ; }
-
- bool RedrawItems(int firstIndex, int lastIndex) { return BOOLToBool(ListView_RedrawItems(_window, firstIndex, lastIndex)); }
- bool RedrawAllItems()
- {
- if (GetItemCount() > 0)
- return RedrawItems(0, GetItemCount() - 1);
- return true;
- }
- bool RedrawItem(int index) { return RedrawItems(index, index); }
-
- int HitTest(LPLVHITTESTINFO info) { return ListView_HitTest(_window, info); }
- COLORREF GetBkColor() { return ListView_GetBkColor(_window); }
- bool SetColumnWidth(int iCol, int cx) { return BOOLToBool(ListView_SetColumnWidth(_window, iCol, cx)); }
- bool SetColumnWidthAuto(int iCol) { return SetColumnWidth(iCol, LVSCW_AUTOSIZE); }
-};
-
-class CListView2: public CListView
-{
- WNDPROC _origWindowProc;
-public:
- void SetWindowProc();
- virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
-};
-
-/*
-class CListView3: public CListView2
-{
-public:
- virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
-};
-*/
-
-}}
-
-#endif
+// Windows/Control/ListView.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_LISTVIEW_H
+#define ZIP7_INC_WINDOWS_CONTROL_LISTVIEW_H
+
+#include "../../Common/MyWindows.h"
+
+#include <CommCtrl.h>
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CListView: public NWindows::CWindow
+{
+public:
+ bool CreateEx(DWORD exStyle, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam);
+
+ void SetUnicodeFormat()
+ {
+ #ifndef UNDER_CE
+ ListView_SetUnicodeFormat(_window, TRUE);
+ #endif
+ }
+
+ bool DeleteAllItems() { return BOOLToBool(ListView_DeleteAllItems(_window)); }
+ bool DeleteColumn(unsigned columnIndex) { return BOOLToBool(ListView_DeleteColumn(_window, columnIndex)); }
+
+ int InsertColumn(unsigned columnIndex, const LVCOLUMN *columnInfo) { return ListView_InsertColumn(_window, columnIndex, columnInfo); }
+ int InsertColumn(unsigned columnIndex, LPCTSTR text, int width);
+ bool SetColumnOrderArray(unsigned count, const int *columns)
+ { return BOOLToBool(ListView_SetColumnOrderArray(_window, count, (int *)(void *)columns)); }
+
+ /*
+ int GetNumColumns()
+ {
+ HWND header = ListView_GetHeader(_window);
+ if (!header)
+ return -1;
+ return Header_GetItemCount(header);
+ }
+ */
+
+ int InsertItem(const LVITEM* item) { return ListView_InsertItem(_window, item); }
+ int InsertItem(unsigned index, LPCTSTR text);
+ bool SetItem(const LVITEM* item) { return BOOLToBool(ListView_SetItem(_window, item)); }
+ int SetSubItem(unsigned index, unsigned subIndex, LPCTSTR text);
+
+ #ifndef _UNICODE
+
+ int InsertColumn(unsigned columnIndex, const LVCOLUMNW *columnInfo) { return (int)SendMsg(LVM_INSERTCOLUMNW, (WPARAM)columnIndex, (LPARAM)columnInfo); }
+ int InsertColumn(unsigned columnIndex, LPCWSTR text, int width);
+ int InsertItem(const LV_ITEMW* item) { return (int)SendMsg(LVM_INSERTITEMW, 0, (LPARAM)item); }
+ int InsertItem(unsigned index, LPCWSTR text);
+ bool SetItem(const LV_ITEMW* item) { return BOOLToBool((BOOL)SendMsg(LVM_SETITEMW, 0, (LPARAM)item)); }
+ int SetSubItem(unsigned index, unsigned subIndex, LPCWSTR text);
+
+ #endif
+
+ bool DeleteItem(unsigned itemIndex) { return BOOLToBool(ListView_DeleteItem(_window, itemIndex)); }
+
+ UINT GetSelectedCount() const { return ListView_GetSelectedCount(_window); }
+ int GetItemCount() const { return ListView_GetItemCount(_window); }
+
+ INT GetSelectionMark() const { return ListView_GetSelectionMark(_window); }
+
+ void SetItemCount(unsigned numItems) { ListView_SetItemCount(_window, numItems); }
+ void SetItemCountEx(unsigned numItems, DWORD flags) { ListView_SetItemCountEx(_window, numItems, flags); }
+
+ /* startIndex : The index of the item with which to begin the search,
+ or -1 to find the first item that matches the specified flags.
+ The specified item itself is excluded from the search. */
+ int GetNextItem(int startIndex, UINT flags) const { return ListView_GetNextItem(_window, startIndex, flags); }
+ int GetNextSelectedItem(int startIndex) const { return GetNextItem(startIndex, LVNI_SELECTED); }
+ int GetFocusedItem() const { return GetNextItem(-1, LVNI_FOCUSED); }
+
+ bool GetItem(LVITEM* item) const { return BOOLToBool(ListView_GetItem(_window, item)); }
+ bool GetItemParam(unsigned itemIndex, LPARAM ¶m) const;
+ /*
+ void GetItemText(unsigned itemIndex, unsigned subItemIndex, LPTSTR text, unsigned textSizeMax) const
+ { ListView_GetItemText(_window, itemIndex, subItemIndex, text, textSizeMax) }
+ */
+ bool SortItems(PFNLVCOMPARE compareFunction, LPARAM dataParam)
+ { return BOOLToBool(ListView_SortItems(_window, compareFunction, dataParam)); }
+
+ // If (index == -1), then the state change is applied to all items.
+ void SetItemState(int index, UINT state, UINT mask) { ListView_SetItemState(_window, index, state, mask) }
+ void SetItemState_Selected(int index, bool select) { SetItemState(index, select ? LVIS_SELECTED : 0, LVIS_SELECTED); }
+ void SetItemState_Selected(int index) { SetItemState(index, LVIS_SELECTED, LVIS_SELECTED); }
+ void SelectAll() { SetItemState_Selected(-1); }
+ void SetItemState_FocusedSelected(int index) { SetItemState(index, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED); }
+ UINT GetItemState(int index, UINT mask) const { return ListView_GetItemState(_window, index, mask); }
+ bool IsItemSelected(int index) const { return GetItemState(index, LVIS_SELECTED) == LVIS_SELECTED; }
+
+ bool GetColumn(unsigned columnIndex, LVCOLUMN* columnInfo) const
+ { return BOOLToBool(ListView_GetColumn(_window, columnIndex, columnInfo)); }
+
+ HIMAGELIST SetImageList(HIMAGELIST imageList, int imageListType)
+ { return ListView_SetImageList(_window, imageList, imageListType); }
+
+ // version 4.70: NT5 | (NT4 + ie3) | w98 | (w95 + ie3)
+ DWORD GetExtendedListViewStyle() { return ListView_GetExtendedListViewStyle(_window); }
+ void SetExtendedListViewStyle(DWORD exStyle) { ListView_SetExtendedListViewStyle(_window, exStyle); }
+ void SetExtendedListViewStyle(DWORD exMask, DWORD exStyle) { ListView_SetExtendedListViewStyleEx(_window, exMask, exStyle); }
+
+ void SetCheckState(UINT index, bool checkState) { ListView_SetCheckState(_window, index, BoolToBOOL(checkState)) }
+ bool GetCheckState(UINT index) { return BOOLToBool(ListView_GetCheckState(_window, index)); }
+
+ bool EnsureVisible(int index, bool partialOK) { return BOOLToBool(ListView_EnsureVisible(_window, index, BoolToBOOL(partialOK))); }
+
+ bool GetItemRect(int index, RECT *rect, int code) { return BOOLToBool(ListView_GetItemRect(_window, index, rect, code)); }
+
+ HWND GetEditControl() { return ListView_GetEditControl(_window) ; }
+ HWND EditLabel(int itemIndex) { return ListView_EditLabel(_window, itemIndex) ; }
+
+ bool RedrawItems(int firstIndex, int lastIndex) { return BOOLToBool(ListView_RedrawItems(_window, firstIndex, lastIndex)); }
+ bool RedrawAllItems()
+ {
+ if (GetItemCount() > 0)
+ return RedrawItems(0, GetItemCount() - 1);
+ return true;
+ }
+ bool RedrawItem(int index) { return RedrawItems(index, index); }
+
+ int HitTest(LPLVHITTESTINFO info) { return ListView_HitTest(_window, info); }
+ COLORREF GetBkColor() { return ListView_GetBkColor(_window); }
+ bool SetColumnWidth(int iCol, int cx) { return BOOLToBool(ListView_SetColumnWidth(_window, iCol, cx)); }
+ bool SetColumnWidthAuto(int iCol) { return SetColumnWidth(iCol, LVSCW_AUTOSIZE); }
+};
+
+class CListView2: public CListView
+{
+ WNDPROC _origWindowProc;
+ // ~CListView2() ZIP7_eq_delete;
+public:
+ virtual ~CListView2() {}
+ CListView2() {}
+ void SetWindowProc();
+ virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+
+/*
+class CListView3: public CListView2
+{
+public:
+ virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+};
+*/
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/ProgressBar.h b/CPP/Windows/Control/ProgressBar.h
index f18d89c..2256aa9 100644
--- a/CPP/Windows/Control/ProgressBar.h
+++ b/CPP/Windows/Control/ProgressBar.h
@@ -1,35 +1,35 @@
-// Windows/Control/ProgressBar.h
-
-#ifndef __WINDOWS_CONTROL_PROGRESSBAR_H
-#define __WINDOWS_CONTROL_PROGRESSBAR_H
-
-#include "../../Common/MyWindows.h"
-
-#include <commctrl.h>
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CProgressBar: public CWindow
-{
-public:
- LRESULT SetPos(int pos) { return SendMsg(PBM_SETPOS, pos, 0); }
- LRESULT DeltaPos(int increment) { return SendMsg(PBM_DELTAPOS, increment, 0); }
- UINT GetPos() { return (UINT)SendMsg(PBM_GETPOS, 0, 0); }
- LRESULT SetRange(unsigned short minValue, unsigned short maxValue) { return SendMsg(PBM_SETRANGE, 0, MAKELPARAM(minValue, maxValue)); }
- DWORD SetRange32(int minValue, int maxValue) { return (DWORD)SendMsg(PBM_SETRANGE32, minValue, maxValue); }
- int SetStep(int step) { return (int)SendMsg(PBM_SETSTEP, step, 0); }
- LRESULT StepIt() { return SendMsg(PBM_STEPIT, 0, 0); }
- INT GetRange(bool minValue, PPBRANGE range) { return (INT)SendMsg(PBM_GETRANGE, BoolToBOOL(minValue), (LPARAM)range); }
-
- #ifndef UNDER_CE
- COLORREF SetBarColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBARCOLOR, 0, color); }
- COLORREF SetBackgroundColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBKCOLOR, 0, color); }
- #endif
-};
-
-}}
-
-#endif
+// Windows/Control/ProgressBar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_PROGRESSBAR_H
+#define ZIP7_INC_WINDOWS_CONTROL_PROGRESSBAR_H
+
+#include "../../Common/MyWindows.h"
+
+#include <CommCtrl.h>
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CProgressBar: public CWindow
+{
+public:
+ LRESULT SetPos(int pos) { return SendMsg(PBM_SETPOS, (unsigned)pos, 0); }
+ // LRESULT DeltaPos(int increment) { return SendMsg(PBM_DELTAPOS, increment, 0); }
+ // UINT GetPos() { return (UINT)SendMsg(PBM_GETPOS, 0, 0); }
+ // LRESULT SetRange(unsigned short minValue, unsigned short maxValue) { return SendMsg(PBM_SETRANGE, 0, MAKELPARAM(minValue, maxValue)); }
+ DWORD SetRange32(int minValue, int maxValue) { return (DWORD)SendMsg(PBM_SETRANGE32, (unsigned)minValue, (LPARAM)(unsigned)maxValue); }
+ // int SetStep(int step) { return (int)SendMsg(PBM_SETSTEP, step, 0); }
+ // LRESULT StepIt() { return SendMsg(PBM_STEPIT, 0, 0); }
+ // INT GetRange(bool minValue, PPBRANGE range) { return (INT)SendMsg(PBM_GETRANGE, BoolToBOOL(minValue), (LPARAM)range); }
+
+ #ifndef UNDER_CE
+ COLORREF SetBarColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBARCOLOR, 0, (LPARAM)color); }
+ COLORREF SetBackgroundColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBKCOLOR, 0, (LPARAM)color); }
+ #endif
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/PropertyPage.cpp b/CPP/Windows/Control/PropertyPage.cpp
index 48947c0..f8effe6 100644
--- a/CPP/Windows/Control/PropertyPage.cpp
+++ b/CPP/Windows/Control/PropertyPage.cpp
@@ -1,143 +1,165 @@
-// Windows/Control/PropertyPage.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../../Common/StringConvert.h"
-#endif
-
-#include "PropertyPage.h"
-
-extern HINSTANCE g_hInstance;
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NControl {
-
-static INT_PTR APIENTRY MyProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
-{
- CWindow tempDialog(dialogHWND);
- if (message == WM_INITDIALOG)
- tempDialog.SetUserDataLongPtr(((PROPSHEETPAGE *)lParam)->lParam);
- CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
- if (dialog == NULL)
- return FALSE;
- if (message == WM_INITDIALOG)
- dialog->Attach(dialogHWND);
- try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
- catch(...) { return TRUE; }
-}
-
-bool CPropertyPage::OnNotify(UINT /* controlID */, LPNMHDR lParam)
-{
- switch (lParam->code)
- {
- case PSN_APPLY: SetMsgResult(OnApply(LPPSHNOTIFY(lParam))); break;
- case PSN_KILLACTIVE: SetMsgResult(BoolToBOOL(OnKillActive(LPPSHNOTIFY(lParam)))); break;
- case PSN_SETACTIVE: SetMsgResult(OnSetActive(LPPSHNOTIFY(lParam))); break;
- case PSN_RESET: OnReset(LPPSHNOTIFY(lParam)); break;
- case PSN_HELP: OnNotifyHelp(LPPSHNOTIFY(lParam)); break;
- default: return false;
- }
- return true;
-}
-
-INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title)
-{
- #ifndef _UNICODE
- AStringVector titles;
- #endif
- #ifndef _UNICODE
- CRecordVector<PROPSHEETPAGEA> pagesA;
- #endif
- CRecordVector<PROPSHEETPAGEW> pagesW;
-
- unsigned i;
- #ifndef _UNICODE
- for (i = 0; i < pagesInfo.Size(); i++)
- titles.Add(GetSystemString(pagesInfo[i].Title));
- #endif
-
- for (i = 0; i < pagesInfo.Size(); i++)
- {
- const CPageInfo &pageInfo = pagesInfo[i];
- #ifndef _UNICODE
- {
- PROPSHEETPAGE page;
- page.dwSize = sizeof(page);
- page.dwFlags = PSP_HASHELP;
- page.hInstance = g_hInstance;
- page.pszTemplate = MAKEINTRESOURCE(pageInfo.ID);
- page.pszIcon = NULL;
- page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
-
- if (titles[i].IsEmpty())
- page.pszTitle = NULL;
- else
- {
- page.dwFlags |= PSP_USETITLE;
- page.pszTitle = titles[i];
- }
- page.lParam = (LPARAM)pageInfo.Page;
- page.pfnCallback = NULL;
- pagesA.Add(page);
- }
- #endif
- {
- PROPSHEETPAGEW page;
- page.dwSize = sizeof(page);
- page.dwFlags = PSP_HASHELP;
- page.hInstance = g_hInstance;
- page.pszTemplate = MAKEINTRESOURCEW(pageInfo.ID);
- page.pszIcon = NULL;
- page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
-
- if (pageInfo.Title.IsEmpty())
- page.pszTitle = NULL;
- else
- {
- page.dwFlags |= PSP_USETITLE;
- page.pszTitle = pageInfo.Title;
- }
- page.lParam = (LPARAM)pageInfo.Page;
- page.pfnCallback = NULL;
- pagesW.Add(page);
- }
- }
-
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- PROPSHEETHEADER sheet;
- sheet.dwSize = sizeof(sheet);
- sheet.dwFlags = PSH_PROPSHEETPAGE;
- sheet.hwndParent = hwndParent;
- sheet.hInstance = g_hInstance;
- AString titleA (GetSystemString(title));
- sheet.pszCaption = titleA;
- sheet.nPages = pagesInfo.Size();
- sheet.nStartPage = 0;
- sheet.ppsp = &pagesA.Front();
- sheet.pfnCallback = NULL;
- return ::PropertySheetA(&sheet);
- }
- else
- #endif
- {
- PROPSHEETHEADERW sheet;
- sheet.dwSize = sizeof(sheet);
- sheet.dwFlags = PSH_PROPSHEETPAGE;
- sheet.hwndParent = hwndParent;
- sheet.hInstance = g_hInstance;
- sheet.pszCaption = title;
- sheet.nPages = pagesInfo.Size();
- sheet.nStartPage = 0;
- sheet.ppsp = &pagesW.Front();
- sheet.pfnCallback = NULL;
- return ::PropertySheetW(&sheet);
- }
-}
-
-}}
+// Windows/Control/PropertyPage.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../../Common/StringConvert.h"
+#endif
+
+#include "PropertyPage.h"
+
+extern HINSTANCE g_hInstance;
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NControl {
+
+static
+#ifdef Z7_OLD_WIN_SDK
+ BOOL
+#else
+ INT_PTR
+#endif
+APIENTRY MyProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ CWindow tempDialog(dialogHWND);
+ if (message == WM_INITDIALOG)
+ tempDialog.SetUserDataLongPtr(((PROPSHEETPAGE *)lParam)->lParam);
+ CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
+ if (dialog == NULL)
+ return FALSE;
+ if (message == WM_INITDIALOG)
+ dialog->Attach(dialogHWND);
+ try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
+ catch(...) { return TRUE; }
+}
+
+bool CPropertyPage::OnNotify(UINT /* controlID */, LPNMHDR lParam)
+{
+ switch (lParam->code)
+ {
+ case PSN_APPLY: SetMsgResult(OnApply2(LPPSHNOTIFY(lParam))); break;
+ case PSN_KILLACTIVE: SetMsgResult(BoolToBOOL(OnKillActive2(LPPSHNOTIFY(lParam)))); break;
+ case PSN_SETACTIVE: SetMsgResult(OnSetActive2(LPPSHNOTIFY(lParam))); break;
+ case PSN_RESET: OnReset2(LPPSHNOTIFY(lParam)); break;
+ case PSN_HELP: OnNotifyHelp2(LPPSHNOTIFY(lParam)); break;
+ default: return false;
+ }
+ return true;
+}
+
+/*
+PROPSHEETPAGE fields depend from
+#if (_WIN32_WINNT >= 0x0600)
+#elif (_WIN32_WINNT >= 0x0501)
+#elif (_WIN32_IE >= 0x0400)
+PROPSHEETHEADER fields depend from
+#if (_WIN32_IE >= 0x0400)
+*/
+#if defined(PROPSHEETPAGEA_V1_SIZE) && !defined(Z7_OLD_WIN_SDK)
+#ifndef _UNICODE
+#define my_compatib_PROPSHEETPAGEA PROPSHEETPAGEA_V1
+#endif
+#define my_compatib_PROPSHEETPAGEW PROPSHEETPAGEW_V1
+#else
+// for old mingw:
+#ifndef _UNICODE
+#define my_compatib_PROPSHEETPAGEA PROPSHEETPAGEA
+#endif
+#define my_compatib_PROPSHEETPAGEW PROPSHEETPAGEW
+#endif
+
+INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title)
+{
+ unsigned i;
+ #ifndef _UNICODE
+ AStringVector titles;
+ for (i = 0; i < pagesInfo.Size(); i++)
+ titles.Add(GetSystemString(pagesInfo[i].Title));
+ CRecordVector<my_compatib_PROPSHEETPAGEA> pagesA;
+ #endif
+ CRecordVector<my_compatib_PROPSHEETPAGEW> pagesW;
+
+ for (i = 0; i < pagesInfo.Size(); i++)
+ {
+ const CPageInfo &pageInfo = pagesInfo[i];
+ #ifndef _UNICODE
+ {
+ my_compatib_PROPSHEETPAGEA page;
+ memset(&page, 0, sizeof(page));
+ page.dwSize = sizeof(page);
+ page.dwFlags = PSP_HASHELP;
+ page.hInstance = g_hInstance;
+ page.pszTemplate = MAKEINTRESOURCEA(pageInfo.ID);
+ // page.pszIcon = NULL;
+ page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
+
+ if (!titles[i].IsEmpty())
+ {
+ page.pszTitle = titles[i];
+ page.dwFlags |= PSP_USETITLE;
+ }
+ // else page.pszTitle = NULL;
+ page.lParam = (LPARAM)pageInfo.Page;
+ // page.pfnCallback = NULL;
+ pagesA.Add(page);
+ }
+ #endif
+ {
+ my_compatib_PROPSHEETPAGEW page;
+ memset(&page, 0, sizeof(page));
+ page.dwSize = sizeof(page);
+ page.dwFlags = PSP_HASHELP;
+ page.hInstance = g_hInstance;
+ page.pszTemplate = MAKEINTRESOURCEW(pageInfo.ID);
+ // page.pszIcon = NULL;
+ page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
+
+ if (!pageInfo.Title.IsEmpty())
+ {
+ page.pszTitle = pageInfo.Title;
+ page.dwFlags |= PSP_USETITLE;
+ }
+ // else page.pszTitle = NULL;
+ page.lParam = (LPARAM)pageInfo.Page;
+ // page.pfnCallback = NULL;
+ pagesW.Add(page);
+ }
+ }
+
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ PROPSHEETHEADERA sheet;
+ sheet.dwSize = sizeof(sheet);
+ sheet.dwFlags = PSH_PROPSHEETPAGE;
+ sheet.hwndParent = hwndParent;
+ sheet.hInstance = g_hInstance;
+ AString titleA (GetSystemString(title));
+ sheet.pszCaption = titleA;
+ sheet.nPages = pagesA.Size();
+ sheet.nStartPage = 0;
+ sheet.ppsp = (LPCPROPSHEETPAGEA)(const void *)&pagesA.Front();
+ sheet.pfnCallback = NULL;
+ return ::PropertySheetA(&sheet);
+ }
+ else
+ #endif
+ {
+ PROPSHEETHEADERW sheet;
+ sheet.dwSize = sizeof(sheet);
+ sheet.dwFlags = PSH_PROPSHEETPAGE;
+ sheet.hwndParent = hwndParent;
+ sheet.hInstance = g_hInstance;
+ sheet.pszCaption = title;
+ sheet.nPages = pagesW.Size();
+ sheet.nStartPage = 0;
+ sheet.ppsp = (LPCPROPSHEETPAGEW)(const void *)&pagesW.Front();
+ sheet.pfnCallback = NULL;
+ return ::PropertySheetW(&sheet);
+ }
+}
+
+}}
diff --git a/CPP/Windows/Control/PropertyPage.h b/CPP/Windows/Control/PropertyPage.h
index 551c959..264a5d2 100644
--- a/CPP/Windows/Control/PropertyPage.h
+++ b/CPP/Windows/Control/PropertyPage.h
@@ -1,50 +1,50 @@
-// Windows/Control/PropertyPage.h
-
-#ifndef __WINDOWS_CONTROL_PROPERTYPAGE_H
-#define __WINDOWS_CONTROL_PROPERTYPAGE_H
-
-#include "../../Common/MyWindows.h"
-
-#include <prsht.h>
-
-#include "Dialog.h"
-
-namespace NWindows {
-namespace NControl {
-
-INT_PTR APIENTRY ProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam);
-
-class CPropertyPage: public CDialog
-{
-public:
- CPropertyPage(HWND window = NULL): CDialog(window){};
-
- void Changed() { PropSheet_Changed(GetParent(), (HWND)*this); }
- void UnChanged() { PropSheet_UnChanged(GetParent(), (HWND)*this); }
-
- virtual bool OnNotify(UINT controlID, LPNMHDR lParam);
-
- virtual bool OnKillActive() { return false; } // false = OK
- virtual bool OnKillActive(const PSHNOTIFY *) { return OnKillActive(); }
- virtual LONG OnSetActive() { return false; } // false = OK
- virtual LONG OnSetActive(const PSHNOTIFY *) { return OnSetActive(); }
- virtual LONG OnApply() { return PSNRET_NOERROR; }
- virtual LONG OnApply(const PSHNOTIFY *) { return OnApply(); }
- virtual void OnNotifyHelp() {}
- virtual void OnNotifyHelp(const PSHNOTIFY *) { OnNotifyHelp(); }
- virtual void OnReset() {}
- virtual void OnReset(const PSHNOTIFY *) { OnReset(); }
-};
-
-struct CPageInfo
-{
- CPropertyPage *Page;
- UString Title;
- UINT ID;
-};
-
-INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title);
-
-}}
-
-#endif
+// Windows/Control/PropertyPage.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_PROPERTYPAGE_H
+#define ZIP7_INC_WINDOWS_CONTROL_PROPERTYPAGE_H
+
+#include "../../Common/MyWindows.h"
+
+#include <prsht.h>
+
+#include "Dialog.h"
+
+namespace NWindows {
+namespace NControl {
+
+INT_PTR APIENTRY ProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam);
+
+class CPropertyPage: public CDialog
+{
+public:
+ CPropertyPage(HWND window = NULL): CDialog(window) {}
+
+ void Changed() { PropSheet_Changed(GetParent(), (HWND)*this); }
+ void UnChanged() { PropSheet_UnChanged(GetParent(), (HWND)*this); }
+
+ virtual bool OnNotify(UINT controlID, LPNMHDR lParam) Z7_override;
+
+ virtual bool OnKillActive() { return false; } // false = OK
+ virtual bool OnKillActive2(const PSHNOTIFY *) { return OnKillActive(); }
+ virtual LONG OnSetActive() { return false; } // false = OK
+ virtual LONG OnSetActive2(const PSHNOTIFY *) { return OnSetActive(); }
+ virtual LONG OnApply() { return PSNRET_NOERROR; }
+ virtual LONG OnApply2(const PSHNOTIFY *) { return OnApply(); }
+ virtual void OnNotifyHelp() {}
+ virtual void OnNotifyHelp2(const PSHNOTIFY *) { OnNotifyHelp(); }
+ virtual void OnReset() {}
+ virtual void OnReset2(const PSHNOTIFY *) { OnReset(); }
+};
+
+struct CPageInfo
+{
+ CPropertyPage *Page;
+ UString Title;
+ UINT ID;
+};
+
+INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title);
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/ReBar.h b/CPP/Windows/Control/ReBar.h
index 26fa311..b56f018 100644
--- a/CPP/Windows/Control/ReBar.h
+++ b/CPP/Windows/Control/ReBar.h
@@ -1,34 +1,34 @@
-// Windows/Control/ReBar.h
-
-#ifndef __WINDOWS_CONTROL_REBAR_H
-#define __WINDOWS_CONTROL_REBAR_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CReBar: public NWindows::CWindow
-{
-public:
- bool SetBarInfo(LPREBARINFO barInfo)
- { return LRESULTToBool(SendMsg(RB_SETBARINFO, 0, (LPARAM)barInfo)); }
- bool InsertBand(int index, LPREBARBANDINFO bandInfo)
- { return LRESULTToBool(SendMsg(RB_INSERTBAND, index, (LPARAM)bandInfo)); }
- bool SetBandInfo(unsigned index, LPREBARBANDINFO bandInfo)
- { return LRESULTToBool(SendMsg(RB_SETBANDINFO, index, (LPARAM)bandInfo)); }
- void MaximizeBand(unsigned index, bool ideal)
- { SendMsg(RB_MAXIMIZEBAND, index, BoolToBOOL(ideal)); }
- bool SizeToRect(LPRECT rect)
- { return LRESULTToBool(SendMsg(RB_SIZETORECT, 0, (LPARAM)rect)); }
- UINT GetHeight()
- { return (UINT)SendMsg(RB_GETBARHEIGHT); }
- UINT GetBandCount()
- { return (UINT)SendMsg(RB_GETBANDCOUNT); }
- bool DeleteBand(UINT index)
- { return LRESULTToBool(SendMsg(RB_DELETEBAND, index)); }
-};
-
-}}
-
-#endif
+// Windows/Control/ReBar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_REBAR_H
+#define ZIP7_INC_WINDOWS_CONTROL_REBAR_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CReBar: public NWindows::CWindow
+{
+public:
+ bool SetBarInfo(LPREBARINFO barInfo)
+ { return LRESULTToBool(SendMsg(RB_SETBARINFO, 0, (LPARAM)barInfo)); }
+ bool InsertBand(int index, LPREBARBANDINFO bandInfo)
+ { return LRESULTToBool(SendMsg(RB_INSERTBAND, MY_int_TO_WPARAM(index), (LPARAM)bandInfo)); }
+ bool SetBandInfo(unsigned index, LPREBARBANDINFO bandInfo)
+ { return LRESULTToBool(SendMsg(RB_SETBANDINFO, index, (LPARAM)bandInfo)); }
+ void MaximizeBand(unsigned index, bool ideal)
+ { SendMsg(RB_MAXIMIZEBAND, index, BoolToBOOL(ideal)); }
+ bool SizeToRect(LPRECT rect)
+ { return LRESULTToBool(SendMsg(RB_SIZETORECT, 0, (LPARAM)rect)); }
+ UINT GetHeight()
+ { return (UINT)SendMsg(RB_GETBARHEIGHT); }
+ UINT GetBandCount()
+ { return (UINT)SendMsg(RB_GETBANDCOUNT); }
+ bool DeleteBand(UINT index)
+ { return LRESULTToBool(SendMsg(RB_DELETEBAND, index)); }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/Static.h b/CPP/Windows/Control/Static.h
index 936dd3c..ceeedf9 100644
--- a/CPP/Windows/Control/Static.h
+++ b/CPP/Windows/Control/Static.h
@@ -1,28 +1,28 @@
-// Windows/Control/Static.h
-
-#ifndef __WINDOWS_CONTROL_STATIC_H
-#define __WINDOWS_CONTROL_STATIC_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CStatic: public CWindow
-{
-public:
- HANDLE SetImage(WPARAM imageType, HANDLE handle) { return (HANDLE)SendMsg(STM_SETIMAGE, imageType, (LPARAM)handle); }
- HANDLE GetImage(WPARAM imageType) { return (HANDLE)SendMsg(STM_GETIMAGE, imageType, 0); }
-
- #ifdef UNDER_CE
- HICON SetIcon(HICON icon) { return (HICON)SetImage(IMAGE_ICON, icon); }
- HICON GetIcon() { return (HICON)GetImage(IMAGE_ICON); }
- #else
- HICON SetIcon(HICON icon) { return (HICON)SendMsg(STM_SETICON, (WPARAM)icon, 0); }
- HICON GetIcon() { return (HICON)SendMsg(STM_GETICON, 0, 0); }
- #endif
-};
-
-}}
-
-#endif
+// Windows/Control/Static.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_STATIC_H
+#define ZIP7_INC_WINDOWS_CONTROL_STATIC_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CStatic: public CWindow
+{
+public:
+ HANDLE SetImage(WPARAM imageType, HANDLE handle) { return (HANDLE)SendMsg(STM_SETIMAGE, imageType, (LPARAM)handle); }
+ HANDLE GetImage(WPARAM imageType) { return (HANDLE)SendMsg(STM_GETIMAGE, imageType, 0); }
+
+ #ifdef UNDER_CE
+ HICON SetIcon(HICON icon) { return (HICON)SetImage(IMAGE_ICON, icon); }
+ HICON GetIcon() { return (HICON)GetImage(IMAGE_ICON); }
+ #else
+ HICON SetIcon(HICON icon) { return (HICON)SendMsg(STM_SETICON, (WPARAM)icon, 0); }
+ HICON GetIcon() { return (HICON)SendMsg(STM_GETICON, 0, 0); }
+ #endif
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/StatusBar.h b/CPP/Windows/Control/StatusBar.h
index 7f7d66b..38aca47 100644
--- a/CPP/Windows/Control/StatusBar.h
+++ b/CPP/Windows/Control/StatusBar.h
@@ -1,42 +1,42 @@
-// Windows/Control/StatusBar.h
-
-#ifndef __WINDOWS_CONTROL_STATUSBAR_H
-#define __WINDOWS_CONTROL_STATUSBAR_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CStatusBar: public NWindows::CWindow
-{
-public:
- bool Create(LONG style, LPCTSTR text, HWND hwndParent, UINT id)
- { return (_window = ::CreateStatusWindow(style, text, hwndParent, id)) != 0; }
- bool SetText(LPCTSTR text)
- { return CWindow::SetText(text); }
- bool SetText(unsigned index, LPCTSTR text, UINT type)
- { return LRESULTToBool(SendMsg(SB_SETTEXT, index | type, (LPARAM)text)); }
- bool SetText(unsigned index, LPCTSTR text)
- { return SetText(index, text, 0); }
-
- #ifndef _UNICODE
- bool Create(LONG style, LPCWSTR text, HWND hwndParent, UINT id)
- { return (_window = ::CreateStatusWindowW(style, text, hwndParent, id)) != 0; }
- bool SetText(LPCWSTR text)
- { return CWindow::SetText(text); }
- bool SetText(unsigned index, LPCWSTR text, UINT type)
- { return LRESULTToBool(SendMsg(SB_SETTEXTW, index | type, (LPARAM)text)); }
- bool SetText(unsigned index, LPCWSTR text)
- { return SetText(index, text, 0); }
- #endif
-
- bool SetParts(unsigned numParts, const int *edgePostions)
- { return LRESULTToBool(SendMsg(SB_SETPARTS, numParts, (LPARAM)edgePostions)); }
- void Simple(bool simple)
- { SendMsg(SB_SIMPLE, BoolToBOOL(simple), 0); }
-};
-
-}}
-
-#endif
+// Windows/Control/StatusBar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_STATUSBAR_H
+#define ZIP7_INC_WINDOWS_CONTROL_STATUSBAR_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CStatusBar: public NWindows::CWindow
+{
+public:
+ bool Create(LONG style, LPCTSTR text, HWND hwndParent, UINT id)
+ { return (_window = ::CreateStatusWindow(style, text, hwndParent, id)) != NULL; }
+ bool SetText(LPCTSTR text)
+ { return CWindow::SetText(text); }
+ bool SetText(unsigned index, LPCTSTR text, UINT type)
+ { return LRESULTToBool(SendMsg(SB_SETTEXT, index | type, (LPARAM)text)); }
+ bool SetText(unsigned index, LPCTSTR text)
+ { return SetText(index, text, 0); }
+
+ #ifndef _UNICODE
+ bool Create(LONG style, LPCWSTR text, HWND hwndParent, UINT id)
+ { return (_window = ::CreateStatusWindowW(style, text, hwndParent, id)) != NULL; }
+ bool SetText(LPCWSTR text)
+ { return CWindow::SetText(text); }
+ bool SetText(unsigned index, LPCWSTR text, UINT type)
+ { return LRESULTToBool(SendMsg(SB_SETTEXTW, index | type, (LPARAM)text)); }
+ bool SetText(unsigned index, LPCWSTR text)
+ { return SetText(index, text, 0); }
+ #endif
+
+ bool SetParts(unsigned numParts, const int *edgePostions)
+ { return LRESULTToBool(SendMsg(SB_SETPARTS, numParts, (LPARAM)edgePostions)); }
+ void Simple(bool simple)
+ { SendMsg(SB_SIMPLE, (WPARAM)BoolToBOOL(simple), 0); }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/StdAfx.h b/CPP/Windows/Control/StdAfx.h
index 42a088f..8086655 100644
--- a/CPP/Windows/Control/StdAfx.h
+++ b/CPP/Windows/Control/StdAfx.h
@@ -1,8 +1,11 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../Common/Common.h"
+
+#endif
diff --git a/CPP/Windows/Control/ToolBar.h b/CPP/Windows/Control/ToolBar.h
index 02ed9a1..2bf20a5 100644
--- a/CPP/Windows/Control/ToolBar.h
+++ b/CPP/Windows/Control/ToolBar.h
@@ -1,43 +1,43 @@
-// Windows/Control/ToolBar.h
-
-#ifndef __WINDOWS_CONTROL_TOOLBAR_H
-#define __WINDOWS_CONTROL_TOOLBAR_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CToolBar: public NWindows::CWindow
-{
-public:
- void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
- DWORD GetButtonSize() { return (DWORD)SendMsg(TB_GETBUTTONSIZE, 0, 0); }
-
- bool GetMaxSize(LPSIZE size)
- #ifdef UNDER_CE
- {
- // maybe it must be fixed for more than 1 buttons
- DWORD val = GetButtonSize();
- size->cx = LOWORD(val);
- size->cy = HIWORD(val);
- return true;
- }
- #else
- {
- return LRESULTToBool(SendMsg(TB_GETMAXSIZE, 0, (LPARAM)size));
- }
- #endif
-
- bool EnableButton(UINT buttonID, bool enable) { return LRESULTToBool(SendMsg(TB_ENABLEBUTTON, buttonID, MAKELONG(BoolToBOOL(enable), 0))); }
- void ButtonStructSize() { SendMsg(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON)); }
- HIMAGELIST SetImageList(UINT listIndex, HIMAGELIST imageList) { return HIMAGELIST(SendMsg(TB_SETIMAGELIST, listIndex, (LPARAM)imageList)); }
- bool AddButton(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONS, numButtons, (LPARAM)buttons)); }
- #ifndef _UNICODE
- bool AddButtonW(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONSW, numButtons, (LPARAM)buttons)); }
- #endif
-};
-
-}}
-
-#endif
+// Windows/Control/ToolBar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_TOOLBAR_H
+#define ZIP7_INC_WINDOWS_CONTROL_TOOLBAR_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CToolBar: public NWindows::CWindow
+{
+public:
+ void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
+ DWORD GetButtonSize() { return (DWORD)SendMsg(TB_GETBUTTONSIZE, 0, 0); }
+
+ bool GetMaxSize(LPSIZE size)
+ #ifdef UNDER_CE
+ {
+ // maybe it must be fixed for more than 1 buttons
+ const DWORD val = GetButtonSize();
+ size->cx = LOWORD(val);
+ size->cy = HIWORD(val);
+ return true;
+ }
+ #else
+ {
+ return LRESULTToBool(SendMsg(TB_GETMAXSIZE, 0, (LPARAM)size));
+ }
+ #endif
+
+ bool EnableButton(UINT buttonID, bool enable) { return LRESULTToBool(SendMsg(TB_ENABLEBUTTON, buttonID, MAKELONG(BoolToBOOL(enable), 0))); }
+ void ButtonStructSize() { SendMsg(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON)); }
+ HIMAGELIST SetImageList(UINT listIndex, HIMAGELIST imageList) { return HIMAGELIST(SendMsg(TB_SETIMAGELIST, listIndex, (LPARAM)imageList)); }
+ bool AddButton(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONS, numButtons, (LPARAM)buttons)); }
+ #ifndef _UNICODE
+ bool AddButtonW(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONSW, numButtons, (LPARAM)buttons)); }
+ #endif
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/Trackbar.h b/CPP/Windows/Control/Trackbar.h
index afc9bf2..18d1b29 100644
--- a/CPP/Windows/Control/Trackbar.h
+++ b/CPP/Windows/Control/Trackbar.h
@@ -1,27 +1,27 @@
-// Windows/Control/Trackbar.h
-
-#ifndef __WINDOWS_CONTROL_TRACKBAR_H
-#define __WINDOWS_CONTROL_TRACKBAR_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CTrackbar: public CWindow
-{
-public:
- void SetRange(int minimum, int maximum, bool redraw = true)
- { SendMsg(TBM_SETRANGE, BoolToBOOL(redraw), MAKELONG(minimum, maximum)); }
- void SetPos(int pos, bool redraw = true)
- { SendMsg(TBM_SETPOS, BoolToBOOL(redraw), pos); }
- void SetTicFreq(int freq)
- { SendMsg(TBM_SETTICFREQ, freq); }
-
- int GetPos()
- { return (int)SendMsg(TBM_GETPOS); }
-};
-
-}}
-
-#endif
+// Windows/Control/Trackbar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_TRACKBAR_H
+#define ZIP7_INC_WINDOWS_CONTROL_TRACKBAR_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CTrackbar: public CWindow
+{
+public:
+ void SetRange(int minimum, int maximum, bool redraw = true)
+ { SendMsg(TBM_SETRANGE, BoolToBOOL(redraw), MAKELONG(minimum, maximum)); }
+ void SetPos(int pos, bool redraw = true)
+ { SendMsg(TBM_SETPOS, BoolToBOOL(redraw), pos); }
+ void SetTicFreq(int freq)
+ { SendMsg(TBM_SETTICFREQ, freq); }
+
+ int GetPos()
+ { return (int)SendMsg(TBM_GETPOS); }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/Control/Window2.cpp b/CPP/Windows/Control/Window2.cpp
index b6e6d67..8fe908e 100644
--- a/CPP/Windows/Control/Window2.cpp
+++ b/CPP/Windows/Control/Window2.cpp
@@ -1,200 +1,202 @@
-// Windows/Control/Window2.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../../Common/StringConvert.h"
-#endif
-
-#include "Window2.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-
-#ifndef _UNICODE
-ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
-#endif
-
-namespace NControl {
-
-#ifdef UNDER_CE
-#define MY_START_WM_CREATE WM_CREATE
-#else
-#define MY_START_WM_CREATE WM_NCCREATE
-#endif
-
-static LRESULT CALLBACK WindowProcedure(HWND aHWND, UINT message, WPARAM wParam, LPARAM lParam)
-{
- CWindow tempWindow(aHWND);
- if (message == MY_START_WM_CREATE)
- tempWindow.SetUserDataLongPtr((LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams));
- CWindow2 *window = (CWindow2 *)(tempWindow.GetUserDataLongPtr());
- if (window != NULL && message == MY_START_WM_CREATE)
- window->Attach(aHWND);
- if (window == 0)
- {
- #ifndef _UNICODE
- if (g_IsNT)
- return DefWindowProcW(aHWND, message, wParam, lParam);
- else
- #endif
- return DefWindowProc(aHWND, message, wParam, lParam);
- }
- return window->OnMessage(message, wParam, lParam);
-}
-
-bool CWindow2::CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
- DWORD style, int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
-{
- WNDCLASS wc;
- if (!::GetClassInfo(instance, className, &wc))
- {
- // wc.style = CS_HREDRAW | CS_VREDRAW;
- wc.style = 0;
- wc.lpfnWndProc = WindowProcedure;
- wc.cbClsExtra = 0;
- wc.cbWndExtra = 0;
- wc.hInstance = instance;
- wc.hIcon = NULL;
- wc.hCursor = LoadCursor(NULL, IDC_ARROW);
- wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
- wc.lpszMenuName = NULL;
- wc.lpszClassName = className;
- if (::RegisterClass(&wc) == 0)
- return false;
- }
- return CWindow::CreateEx(exStyle, className, windowName, style,
- x, y, width, height, parentWindow, idOrHMenu, instance, this);
-}
-
-#ifndef _UNICODE
-
-bool CWindow2::CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
- DWORD style, int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
-{
- bool needRegister;
- if (g_IsNT)
- {
- WNDCLASSW wc;
- needRegister = ::GetClassInfoW(instance, className, &wc) == 0;
- }
- else
- {
- WNDCLASSA windowClassA;
- AString classNameA;
- LPCSTR classNameP;
- if (IS_INTRESOURCE(className))
- classNameP = (LPCSTR)className;
- else
- {
- classNameA = GetSystemString(className);
- classNameP = classNameA;
- }
- needRegister = ::GetClassInfoA(instance, classNameP, &windowClassA) == 0;
- }
- if (needRegister)
- {
- WNDCLASSW wc;
- // wc.style = CS_HREDRAW | CS_VREDRAW;
- wc.style = 0;
- wc.lpfnWndProc = WindowProcedure;
- wc.cbClsExtra = 0;
- wc.cbWndExtra = 0;
- wc.hInstance = instance;
- wc.hIcon = NULL;
- wc.hCursor = LoadCursor(NULL, IDC_ARROW);
- wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
- wc.lpszMenuName = NULL;
- wc.lpszClassName = className;
- if (MyRegisterClass(&wc) == 0)
- return false;
- }
- return CWindow::CreateEx(exStyle, className, windowName, style,
- x, y, width, height, parentWindow, idOrHMenu, instance, this);
-}
-
-#endif
-
-LRESULT CWindow2::DefProc(UINT message, WPARAM wParam, LPARAM lParam)
-{
- #ifndef _UNICODE
- if (g_IsNT)
- return DefWindowProcW(_window, message, wParam, lParam);
- else
- #endif
- return DefWindowProc(_window, message, wParam, lParam);
-}
-
-LRESULT CWindow2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
-{
- LRESULT result;
- switch (message)
- {
- case WM_CREATE:
- if (!OnCreate((CREATESTRUCT *)lParam))
- return -1;
- break;
- case WM_COMMAND:
- if (OnCommand(wParam, lParam, result))
- return result;
- break;
- case WM_NOTIFY:
- if (OnNotify((UINT)wParam, (LPNMHDR) lParam, result))
- return result;
- break;
- case WM_DESTROY:
- OnDestroy();
- break;
- case WM_CLOSE:
- OnClose();
- return 0;
- case WM_SIZE:
- if (OnSize(wParam, LOWORD(lParam), HIWORD(lParam)))
- return 0;
- }
- return DefProc(message, wParam, lParam);
-}
-
-bool CWindow2::OnCommand(WPARAM wParam, LPARAM lParam, LRESULT &result)
-{
- return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam, result);
-}
-
-bool CWindow2::OnCommand(int /* code */, int /* itemID */, LPARAM /* lParam */, LRESULT & /* result */)
-{
- return false;
- // return DefProc(message, wParam, lParam);
- /*
- if (code == BN_CLICKED)
- return OnButtonClicked(itemID, (HWND)lParam);
- */
-}
-
-/*
-bool CDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
-{
- switch (buttonID)
- {
- case IDOK:
- OnOK();
- break;
- case IDCANCEL:
- OnCancel();
- break;
- case IDHELP:
- OnHelp();
- break;
- default:
- return false;
- }
- return true;
-}
-
-*/
-
-}}
+// Windows/Control/Window2.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../../Common/StringConvert.h"
+#endif
+
+#include "Window2.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+#ifndef _UNICODE
+ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
+#endif
+
+namespace NControl {
+
+#ifdef UNDER_CE
+#define MY_START_WM_CREATE WM_CREATE
+#else
+#define MY_START_WM_CREATE WM_NCCREATE
+#endif
+
+static LRESULT CALLBACK WindowProcedure(HWND aHWND, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ CWindow tempWindow(aHWND);
+ if (message == MY_START_WM_CREATE)
+ tempWindow.SetUserDataLongPtr((LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams));
+ CWindow2 *window = (CWindow2 *)(tempWindow.GetUserDataLongPtr());
+ if (window && message == MY_START_WM_CREATE)
+ window->Attach(aHWND);
+ if (!window)
+ {
+ #ifndef _UNICODE
+ if (g_IsNT)
+ return DefWindowProcW(aHWND, message, wParam, lParam);
+ else
+ #endif
+ return DefWindowProc(aHWND, message, wParam, lParam);
+ }
+ return window->OnMessage(message, wParam, lParam);
+}
+
+bool CWindow2::CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
+ DWORD style, int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
+{
+ WNDCLASS wc;
+ if (!::GetClassInfo(instance, className, &wc))
+ {
+ // wc.style = CS_HREDRAW | CS_VREDRAW;
+ wc.style = 0;
+ wc.lpfnWndProc = WindowProcedure;
+ wc.cbClsExtra = 0;
+ wc.cbWndExtra = 0;
+ wc.hInstance = instance;
+ wc.hIcon = NULL;
+ wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+ wc.lpszMenuName = NULL;
+ wc.lpszClassName = className;
+ if (::RegisterClass(&wc) == 0)
+ return false;
+ }
+ return CWindow::CreateEx(exStyle, className, windowName, style,
+ x, y, width, height, parentWindow, idOrHMenu, instance, this);
+}
+
+#ifndef _UNICODE
+
+bool CWindow2::CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
+ DWORD style, int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
+{
+ bool needRegister;
+ if (g_IsNT)
+ {
+ WNDCLASSW wc;
+ needRegister = ::GetClassInfoW(instance, className, &wc) == 0;
+ }
+ else
+ {
+ WNDCLASSA windowClassA;
+ AString classNameA;
+ LPCSTR classNameP;
+ if (IS_INTRESOURCE(className))
+ classNameP = (LPCSTR)className;
+ else
+ {
+ classNameA = GetSystemString(className);
+ classNameP = classNameA;
+ }
+ needRegister = ::GetClassInfoA(instance, classNameP, &windowClassA) == 0;
+ }
+ if (needRegister)
+ {
+ WNDCLASSW wc;
+ // wc.style = CS_HREDRAW | CS_VREDRAW;
+ wc.style = 0;
+ wc.lpfnWndProc = WindowProcedure;
+ wc.cbClsExtra = 0;
+ wc.cbWndExtra = 0;
+ wc.hInstance = instance;
+ wc.hIcon = NULL;
+ wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+ wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+ wc.lpszMenuName = NULL;
+ wc.lpszClassName = className;
+ if (MyRegisterClass(&wc) == 0)
+ return false;
+ }
+ return CWindow::CreateEx(exStyle, className, windowName, style,
+ x, y, width, height, parentWindow, idOrHMenu, instance, this);
+}
+
+#endif
+
+LRESULT CWindow2::DefProc(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ #ifndef _UNICODE
+ if (g_IsNT)
+ return DefWindowProcW(_window, message, wParam, lParam);
+ else
+ #endif
+ return DefWindowProc(_window, message, wParam, lParam);
+}
+
+LRESULT CWindow2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
+{
+ LRESULT result;
+ switch (message)
+ {
+ case WM_CREATE:
+ if (!OnCreate((CREATESTRUCT *)lParam))
+ return -1;
+ break;
+ case WM_COMMAND:
+ if (OnCommand(HIWORD(wParam), LOWORD(wParam), lParam, result))
+ return result;
+ break;
+ case WM_NOTIFY:
+ if (OnNotify((UINT)wParam, (LPNMHDR) lParam, result))
+ return result;
+ break;
+ case WM_DESTROY:
+ OnDestroy();
+ break;
+ case WM_CLOSE:
+ OnClose();
+ return 0;
+ case WM_SIZE:
+ if (OnSize(wParam, LOWORD(lParam), HIWORD(lParam)))
+ return 0;
+ }
+ return DefProc(message, wParam, lParam);
+}
+
+/*
+bool CWindow2::OnCommand2(WPARAM wParam, LPARAM lParam, LRESULT &result)
+{
+ return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam, result);
+}
+*/
+
+bool CWindow2::OnCommand(unsigned /* code */, unsigned /* itemID */, LPARAM /* lParam */, LRESULT & /* result */)
+{
+ return false;
+ // return DefProc(message, wParam, lParam);
+ /*
+ if (code == BN_CLICKED)
+ return OnButtonClicked(itemID, (HWND)lParam);
+ */
+}
+
+/*
+bool CDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+ switch (buttonID)
+ {
+ case IDOK:
+ OnOK();
+ break;
+ case IDCANCEL:
+ OnCancel();
+ break;
+ case IDHELP:
+ OnHelp();
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
+
+*/
+
+}}
diff --git a/CPP/Windows/Control/Window2.h b/CPP/Windows/Control/Window2.h
index d632b86..ebb5979 100644
--- a/CPP/Windows/Control/Window2.h
+++ b/CPP/Windows/Control/Window2.h
@@ -1,51 +1,53 @@
-// Windows/Control/Window2.h
-
-#ifndef __WINDOWS_CONTROL_WINDOW2_H
-#define __WINDOWS_CONTROL_WINDOW2_H
-
-#include "../Window.h"
-
-namespace NWindows {
-namespace NControl {
-
-class CWindow2: public CWindow
-{
- LRESULT DefProc(UINT message, WPARAM wParam, LPARAM lParam);
-public:
- CWindow2(HWND newWindow = NULL): CWindow(newWindow){};
- virtual ~CWindow2() {};
-
- bool CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
- DWORD style, int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
-
- #ifndef _UNICODE
- bool CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
- DWORD style, int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
- #endif
-
- virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
- virtual bool OnCreate(CREATESTRUCT * /* createStruct */) { return true; }
- // virtual LRESULT OnCommand(WPARAM wParam, LPARAM lParam);
- virtual bool OnCommand(WPARAM wParam, LPARAM lParam, LRESULT &result);
- virtual bool OnCommand(int code, int itemID, LPARAM lParam, LRESULT &result);
- virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
- virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */, LRESULT & /* result */) { return false; }
- virtual void OnDestroy() { PostQuitMessage(0); }
- virtual void OnClose() { Destroy(); }
- /*
- virtual LRESULT OnHelp(LPHELPINFO helpInfo) { OnHelp(); }
- virtual LRESULT OnHelp() {};
- virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
- virtual void OnOK() {};
- virtual void OnCancel() {};
- */
-
- LONG_PTR SetMsgResult(LONG_PTR newLongPtr) { return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
- LONG_PTR GetMsgResult() const { return GetLongPtr(DWLP_MSGRESULT); }
-};
-
-}}
-
-#endif
+// Windows/Control/Window2.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_WINDOW2_H
+#define ZIP7_INC_WINDOWS_CONTROL_WINDOW2_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+class CWindow2: public CWindow
+{
+ // Z7_CLASS_NO_COPY(CWindow2)
+
+ LRESULT DefProc(UINT message, WPARAM wParam, LPARAM lParam);
+public:
+ CWindow2(HWND newWindow = NULL): CWindow(newWindow) {}
+ virtual ~CWindow2() {}
+
+ bool CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
+ DWORD style, int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
+
+ #ifndef _UNICODE
+ bool CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
+ DWORD style, int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
+ #endif
+
+ virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+ virtual bool OnCreate(CREATESTRUCT * /* createStruct */) { return true; }
+ // virtual LRESULT OnCommand(WPARAM wParam, LPARAM lParam);
+ // bool OnCommand2(WPARAM wParam, LPARAM lParam, LRESULT &result);
+ virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam, LRESULT &result);
+ virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
+ virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */, LRESULT & /* result */) { return false; }
+ virtual void OnDestroy() { PostQuitMessage(0); }
+ virtual void OnClose() { Destroy(); }
+ /*
+ virtual LRESULT OnHelp(LPHELPINFO helpInfo) { OnHelp(); }
+ virtual LRESULT OnHelp() {};
+ virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND);
+ virtual void OnOK() {};
+ virtual void OnCancel() {};
+ */
+
+ LONG_PTR SetMsgResult(LONG_PTR newLongPtr) { return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
+ LONG_PTR GetMsgResult() const { return GetLongPtr(DWLP_MSGRESULT); }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/DLL.cpp b/CPP/Windows/DLL.cpp
index efee379..b2499ec 100644
--- a/CPP/Windows/DLL.cpp
+++ b/CPP/Windows/DLL.cpp
@@ -1,109 +1,179 @@
-// Windows/DLL.cpp
-
-#include "StdAfx.h"
-
-#include "DLL.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-extern HINSTANCE g_hInstance;
-
-namespace NWindows {
-namespace NDLL {
-
-bool CLibrary::Free() throw()
-{
- if (_module == 0)
- return true;
- if (!::FreeLibrary(_module))
- return false;
- _module = 0;
- return true;
-}
-
-bool CLibrary::LoadEx(CFSTR path, DWORD flags) throw()
-{
- if (!Free())
- return false;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- _module = ::LoadLibraryEx(fs2fas(path), NULL, flags);
- }
- else
- #endif
- {
- _module = ::LoadLibraryExW(fs2us(path), NULL, flags);
- }
- return (_module != NULL);
-}
-
-bool CLibrary::Load(CFSTR path) throw()
-{
- if (!Free())
- return false;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- _module = ::LoadLibrary(fs2fas(path));
- }
- else
- #endif
- {
- _module = ::LoadLibraryW(fs2us(path));
- }
- return (_module != NULL);
-}
-
-bool MyGetModuleFileName(FString &path)
-{
- HMODULE hModule = g_hInstance;
- path.Empty();
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR s[MAX_PATH + 2];
- s[0] = 0;
- DWORD size = ::GetModuleFileName(hModule, s, MAX_PATH + 1);
- if (size <= MAX_PATH && size != 0)
- {
- path = fas2fs(s);
- return true;
- }
- }
- else
- #endif
- {
- WCHAR s[MAX_PATH + 2];
- s[0] = 0;
- DWORD size = ::GetModuleFileNameW(hModule, s, MAX_PATH + 1);
- if (size <= MAX_PATH && size != 0)
- {
- path = us2fs(s);
- return true;
- }
- }
- return false;
-}
-
-#ifndef _SFX
-
-FString GetModuleDirPrefix()
-{
- FString s;
- if (MyGetModuleFileName(s))
- {
- int pos = s.ReverseFind_PathSepar();
- if (pos >= 0)
- s.DeleteFrom(pos + 1);
- }
- if (s.IsEmpty())
- s = "." STRING_PATH_SEPARATOR;
- return s;
-}
-
-#endif
-
-}}
+// Windows/DLL.cpp
+
+#include "StdAfx.h"
+
+#include "DLL.h"
+
+#ifdef _WIN32
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+extern HINSTANCE g_hInstance;
+
+namespace NWindows {
+namespace NDLL {
+
+bool CLibrary::Free() throw()
+{
+ if (_module == NULL)
+ return true;
+ if (!::FreeLibrary(_module))
+ return false;
+ _module = NULL;
+ return true;
+}
+
+bool CLibrary::LoadEx(CFSTR path, DWORD flags) throw()
+{
+ if (!Free())
+ return false;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ _module = ::LoadLibraryEx(fs2fas(path), NULL, flags);
+ }
+ else
+ #endif
+ {
+ _module = ::LoadLibraryExW(fs2us(path), NULL, flags);
+ }
+ return (_module != NULL);
+}
+
+bool CLibrary::Load(CFSTR path) throw()
+{
+ if (!Free())
+ return false;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ _module = ::LoadLibrary(fs2fas(path));
+ }
+ else
+ #endif
+ {
+ _module = ::LoadLibraryW(fs2us(path));
+ }
+ return (_module != NULL);
+}
+
+bool MyGetModuleFileName(FString &path)
+{
+ HMODULE hModule = g_hInstance;
+ path.Empty();
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ TCHAR s[MAX_PATH + 2];
+ s[0] = 0;
+ DWORD size = ::GetModuleFileName(hModule, s, MAX_PATH + 1);
+ if (size <= MAX_PATH && size != 0)
+ {
+ path = fas2fs(s);
+ return true;
+ }
+ }
+ else
+ #endif
+ {
+ WCHAR s[MAX_PATH + 2];
+ s[0] = 0;
+ DWORD size = ::GetModuleFileNameW(hModule, s, MAX_PATH + 1);
+ if (size <= MAX_PATH && size != 0)
+ {
+ path = us2fs(s);
+ return true;
+ }
+ }
+ return false;
+}
+
+#ifndef Z7_SFX
+
+FString GetModuleDirPrefix()
+{
+ FString s;
+ if (MyGetModuleFileName(s))
+ {
+ int pos = s.ReverseFind_PathSepar();
+ if (pos >= 0)
+ s.DeleteFrom((unsigned)(pos + 1));
+ }
+ if (s.IsEmpty())
+ s = "." STRING_PATH_SEPARATOR;
+ return s;
+}
+
+#endif
+
+}}
+
+#else // _WIN32
+
+#include <dlfcn.h>
+#include <stdlib.h>
+#include "../Common/Common.h"
+
+// FARPROC
+void *GetProcAddress(HMODULE module, LPCSTR procName)
+{
+ void *ptr = NULL;
+ if (module)
+ ptr = dlsym(module, procName);
+ return ptr;
+}
+
+namespace NWindows {
+namespace NDLL {
+
+bool CLibrary::Free() throw()
+{
+ if (!_module)
+ return true;
+ const int ret = dlclose(_module);
+ if (ret != 0)
+ return false;
+ _module = NULL;
+ return true;
+}
+
+bool CLibrary::Load(CFSTR path) throw()
+{
+ if (!Free())
+ return false;
+
+ int options = 0;
+
+ #ifdef RTLD_LOCAL
+ options |= RTLD_LOCAL;
+ #endif
+
+ #ifdef RTLD_NOW
+ options |= RTLD_NOW;
+ #endif
+
+ #ifdef RTLD_GROUP
+ #if ! (defined(hpux) || defined(__hpux))
+ options |= RTLD_GROUP; // mainly for solaris but not for HPUX
+ #endif
+ #endif
+
+ _module = dlopen(path, options);
+ return (_module != NULL);
+}
+
+/*
+// FARPROC
+void * CLibrary::GetProc(LPCSTR procName) const
+{
+ // return My_GetProcAddress(_module, procName);
+ return local_GetProcAddress(_module, procName);
+ // return NULL;
+}
+*/
+
+}}
+
+#endif
diff --git a/CPP/Windows/DLL.h b/CPP/Windows/DLL.h
index 58bcf19..19a82b3 100644
--- a/CPP/Windows/DLL.h
+++ b/CPP/Windows/DLL.h
@@ -1,58 +1,103 @@
-// Windows/DLL.h
-
-#ifndef __WINDOWS_DLL_H
-#define __WINDOWS_DLL_H
-
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NDLL {
-
-#ifdef UNDER_CE
-#define My_GetProcAddress(module, procName) ::GetProcAddressA(module, procName)
-#else
-#define My_GetProcAddress(module, procName) ::GetProcAddress(module, procName)
-#endif
-
-/* Win32: Don't call CLibrary::Free() and FreeLibrary() from another
- FreeLibrary() code: detaching code in DLL entry-point or in
- destructors of global objects in DLL module. */
-
-class CLibrary
-{
- HMODULE _module;
-
- // CLASS_NO_COPY(CLibrary);
-public:
- CLibrary(): _module(NULL) {};
- ~CLibrary() { Free(); }
-
- operator HMODULE() const { return _module; }
- HMODULE* operator&() { return &_module; }
- bool IsLoaded() const { return (_module != NULL); }
-
- void Attach(HMODULE m)
- {
- Free();
- _module = m;
- }
- HMODULE Detach()
- {
- HMODULE m = _module;
- _module = NULL;
- return m;
- }
-
- bool Free() throw();
- bool LoadEx(CFSTR path, DWORD flags = LOAD_LIBRARY_AS_DATAFILE) throw();
- bool Load(CFSTR path) throw();
- FARPROC GetProc(LPCSTR procName) const { return My_GetProcAddress(_module, procName); }
-};
-
-bool MyGetModuleFileName(FString &path);
-
-FString GetModuleDirPrefix();
-
-}}
-
-#endif
+// Windows/DLL.h
+
+#ifndef ZIP7_INC_WINDOWS_DLL_H
+#define ZIP7_INC_WINDOWS_DLL_H
+
+#include "../Common/MyString.h"
+
+#ifndef _WIN32
+typedef void * HMODULE;
+// typedef int (*FARPROC)();
+// typedef void *FARPROC;
+void *GetProcAddress(HMODULE module, LPCSTR procName);
+#endif
+
+namespace NWindows {
+namespace NDLL {
+
+#ifdef _WIN32
+
+/*
+#ifdef UNDER_CE
+#define My_GetProcAddress(module, procName) (void *)::GetProcAddressA(module, procName)
+#else
+#define My_GetProcAddress(module, procName) (void *)::GetProcAddress(module, procName)
+#endif
+*/
+
+/* Win32: Don't call CLibrary::Free() and FreeLibrary() from another
+ FreeLibrary() code: detaching code in DLL entry-point or in
+ destructors of global objects in DLL module. */
+
+class CLibrary
+{
+ HMODULE _module;
+
+ // Z7_CLASS_NO_COPY(CLibrary);
+ // copy constructor is required here
+public:
+ CLibrary(): _module(NULL) {}
+ ~CLibrary() { Free(); }
+
+ CLibrary(const CLibrary &c): _module(NULL)
+ {
+ if (c._module)
+ {
+ // we need non const to reference from original item
+ // c._module = NULL;
+ throw 20230102;
+ }
+ }
+
+ HMODULE Get_HMODULE() const { return _module; }
+ // operator HMODULE() const { return _module; }
+ // HMODULE* operator&() { return &_module; }
+ bool IsLoaded() const { return (_module != NULL); }
+
+ void Attach(HMODULE m)
+ {
+ Free();
+ _module = m;
+ }
+ HMODULE Detach()
+ {
+ const HMODULE m = _module;
+ _module = NULL;
+ return m;
+ }
+
+ bool Free() throw();
+ bool LoadEx(CFSTR path, DWORD flags = LOAD_LIBRARY_AS_DATAFILE) throw();
+ bool Load(CFSTR path) throw();
+ // FARPROC
+ // void *GetProc(LPCSTR procName) const { return My_GetProcAddress(_module, procName); }
+};
+
+#else
+
+class CLibrary
+{
+ HMODULE _module;
+
+ // Z7_CLASS_NO_COPY(CLibrary);
+public:
+ CLibrary(): _module(NULL) {}
+ ~CLibrary() { Free(); }
+
+ HMODULE Get_HMODULE() const { return _module; }
+
+ bool Free() throw();
+ bool Load(CFSTR path) throw();
+ // FARPROC
+ // void *GetProc(LPCSTR procName) const; // { return My_GetProcAddress(_module, procName); }
+};
+
+#endif
+
+bool MyGetModuleFileName(FString &path);
+
+FString GetModuleDirPrefix();
+
+}}
+
+#endif
diff --git a/CPP/Windows/Defs.h b/CPP/Windows/Defs.h
index f3d692f..8ab9cf5 100644
--- a/CPP/Windows/Defs.h
+++ b/CPP/Windows/Defs.h
@@ -1,17 +1,17 @@
-// Windows/Defs.h
-
-#ifndef __WINDOWS_DEFS_H
-#define __WINDOWS_DEFS_H
-
-#include "../Common/MyWindows.h"
-
-#ifdef _WIN32
-inline bool LRESULTToBool(LRESULT v) { return (v != FALSE); }
-inline bool BOOLToBool(BOOL v) { return (v != FALSE); }
-inline BOOL BoolToBOOL(bool v) { return (v ? TRUE: FALSE); }
-#endif
-
-inline VARIANT_BOOL BoolToVARIANT_BOOL(bool v) { return (v ? VARIANT_TRUE: VARIANT_FALSE); }
-inline bool VARIANT_BOOLToBool(VARIANT_BOOL v) { return (v != VARIANT_FALSE); }
-
-#endif
+// Windows/Defs.h
+
+#ifndef ZIP7_INC_WINDOWS_DEFS_H
+#define ZIP7_INC_WINDOWS_DEFS_H
+
+#include "../Common/MyWindows.h"
+
+#ifdef _WIN32
+inline BOOL BoolToBOOL(bool v) { return (v ? TRUE: FALSE); }
+#endif
+
+inline bool BOOLToBool(BOOL v) { return (v != FALSE); }
+
+inline VARIANT_BOOL BoolToVARIANT_BOOL(bool v) { return (v ? VARIANT_TRUE: VARIANT_FALSE); }
+inline bool VARIANT_BOOLToBool(VARIANT_BOOL v) { return (v != VARIANT_FALSE); }
+
+#endif
diff --git a/CPP/Windows/ErrorMsg.cpp b/CPP/Windows/ErrorMsg.cpp
index 6434ec2..5acf3ad 100644
--- a/CPP/Windows/ErrorMsg.cpp
+++ b/CPP/Windows/ErrorMsg.cpp
@@ -1,66 +1,133 @@
-// Windows/ErrorMsg.h
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "ErrorMsg.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NError {
-
-static bool MyFormatMessage(DWORD errorCode, UString &message)
-{
- LPVOID msgBuf;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
- FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL, errorCode, 0, (LPTSTR) &msgBuf, 0, NULL) == 0)
- return false;
- message = GetUnicodeString((LPCTSTR)msgBuf);
- }
- else
- #endif
- {
- if (::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
- FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- NULL, errorCode, 0, (LPWSTR) &msgBuf, 0, NULL) == 0)
- return false;
- message = (LPCWSTR)msgBuf;
- }
- ::LocalFree(msgBuf);
- return true;
-}
-
-UString MyFormatMessage(DWORD errorCode)
-{
- UString m;
- if (!MyFormatMessage(errorCode, m) || m.IsEmpty())
- {
- char s[16];
- for (int i = 0; i < 8; i++)
- {
- unsigned t = errorCode & 0xF;
- errorCode >>= 4;
- s[7 - i] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
- }
- s[8] = 0;
- m += "Error #";
- m += s;
- }
- else if (m.Len() >= 2
- && m[m.Len() - 1] == 0x0A
- && m[m.Len() - 2] == 0x0D)
- m.DeleteFrom(m.Len() - 2);
- return m;
-}
-
-}}
+// Windows/ErrorMsg.h
+
+#include "StdAfx.h"
+
+#if !defined(_UNICODE) || !defined(_WIN32)
+#include "../Common/StringConvert.h"
+#endif
+
+#include "ErrorMsg.h"
+
+#ifdef _WIN32
+#if !defined(_UNICODE)
+extern bool g_IsNT;
+#endif
+#endif
+
+namespace NWindows {
+namespace NError {
+
+static bool MyFormatMessage(DWORD errorCode, UString &message)
+{
+ #ifndef Z7_SFX
+ if ((HRESULT)errorCode == MY_HRES_ERROR_INTERNAL_ERROR)
+ {
+ message = "Internal Error: The failure in hardware (RAM or CPU), OS or program";
+ return true;
+ }
+ #endif
+
+ #ifdef _WIN32
+
+ LPVOID msgBuf;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, errorCode, 0, (LPTSTR) &msgBuf, 0, NULL) == 0)
+ return false;
+ message = GetUnicodeString((LPCTSTR)msgBuf);
+ }
+ else
+ #endif
+ {
+ if (::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL, errorCode, 0, (LPWSTR) &msgBuf, 0, NULL) == 0)
+ return false;
+ message = (LPCWSTR)msgBuf;
+ }
+ ::LocalFree(msgBuf);
+ return true;
+
+ #else // _WIN32
+
+ AString m;
+
+ const char *s = NULL;
+
+ switch ((Int32)errorCode)
+ {
+ // case ERROR_NO_MORE_FILES : s = "No more files"; break;
+ // case ERROR_DIRECTORY : s = "Error Directory"; break;
+ case E_NOTIMPL : s = "E_NOTIMPL : Not implemented"; break;
+ case E_NOINTERFACE : s = "E_NOINTERFACE : No such interface supported"; break;
+ case E_ABORT : s = "E_ABORT : Operation aborted"; break;
+ case E_FAIL : s = "E_FAIL : Unspecified error"; break;
+
+ case STG_E_INVALIDFUNCTION : s = "STG_E_INVALIDFUNCTION"; break;
+ case CLASS_E_CLASSNOTAVAILABLE : s = "CLASS_E_CLASSNOTAVAILABLE"; break;
+
+ case E_OUTOFMEMORY : s = "E_OUTOFMEMORY : Can't allocate required memory"; break;
+ case E_INVALIDARG : s = "E_INVALIDARG : One or more arguments are invalid"; break;
+
+ // case MY_E_ERROR_NEGATIVE_SEEK : s = "MY_E_ERROR_NEGATIVE_SEEK"; break;
+ default:
+ break;
+ }
+
+ /* strerror() for unknown errors still shows message "Unknown error -12345678")
+ So we must transfer error codes before strerror() */
+ if (!s)
+ {
+ if ((errorCode & 0xFFFF0000) == (UInt32)((MY_FACILITY_WRes << 16) | 0x80000000))
+ errorCode &= 0xFFFF;
+ else if ((errorCode & ((UInt32)1 << 31)))
+ return false; // we will show hex error later for that case
+
+ s = strerror((int)errorCode);
+
+ // if (!s)
+ {
+ m += "errno=";
+ m.Add_UInt32(errorCode);
+ if (s)
+ m += " : ";
+ }
+ }
+
+ if (s)
+ m += s;
+
+ MultiByteToUnicodeString2(message, m);
+ return true;
+
+ #endif
+}
+
+
+UString MyFormatMessage(DWORD errorCode)
+{
+ UString m;
+ if (!MyFormatMessage(errorCode, m) || m.IsEmpty())
+ {
+ char s[16];
+ for (int i = 0; i < 8; i++)
+ {
+ unsigned t = errorCode & 0xF;
+ errorCode >>= 4;
+ s[7 - i] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+ }
+ s[8] = 0;
+ m += "Error #";
+ m += s;
+ }
+ else if (m.Len() >= 2
+ && m[m.Len() - 1] == 0x0A
+ && m[m.Len() - 2] == 0x0D)
+ m.DeleteFrom(m.Len() - 2);
+ return m;
+}
+
+}}
diff --git a/CPP/Windows/ErrorMsg.h b/CPP/Windows/ErrorMsg.h
index e05e950..6142b4e 100644
--- a/CPP/Windows/ErrorMsg.h
+++ b/CPP/Windows/ErrorMsg.h
@@ -1,15 +1,16 @@
-// Windows/ErrorMsg.h
-
-#ifndef __WINDOWS_ERROR_MSG_H
-#define __WINDOWS_ERROR_MSG_H
-
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NError {
-
-UString MyFormatMessage(DWORD errorCode);
-
-}}
-
-#endif
+// Windows/ErrorMsg.h
+
+#ifndef ZIP7_INC_WINDOWS_ERROR_MSG_H
+#define ZIP7_INC_WINDOWS_ERROR_MSG_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NError {
+
+UString MyFormatMessage(DWORD errorCode);
+inline UString MyFormatMessage(HRESULT errorCode) { return MyFormatMessage((DWORD)errorCode); }
+
+}}
+
+#endif
diff --git a/CPP/Windows/FileDir.cpp b/CPP/Windows/FileDir.cpp
index 124569e..5b1f340 100644
--- a/CPP/Windows/FileDir.cpp
+++ b/CPP/Windows/FileDir.cpp
@@ -1,714 +1,1229 @@
-// Windows/FileDir.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "FileDir.h"
-#include "FileFind.h"
-#include "FileName.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NName;
-
-namespace NWindows {
-namespace NFile {
-namespace NDir {
-
-#ifndef UNDER_CE
-
-bool GetWindowsDir(FString &path)
-{
- UINT needLength;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetWindowsDirectory(s, MAX_PATH + 1);
- path = fas2fs(s);
- }
- else
- #endif
- {
- WCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetWindowsDirectoryW(s, MAX_PATH + 1);
- path = us2fs(s);
- }
- return (needLength > 0 && needLength <= MAX_PATH);
-}
-
-bool GetSystemDir(FString &path)
-{
- UINT needLength;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetSystemDirectory(s, MAX_PATH + 1);
- path = fas2fs(s);
- }
- else
- #endif
- {
- WCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetSystemDirectoryW(s, MAX_PATH + 1);
- path = us2fs(s);
- }
- return (needLength > 0 && needLength <= MAX_PATH);
-}
-#endif
-
-bool SetDirTime(CFSTR path, const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return false;
- }
- #endif
-
- HANDLE hDir = INVALID_HANDLE_VALUE;
- IF_USE_MAIN_PATH
- hDir = ::CreateFileW(fs2us(path), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
- #ifdef WIN_LONG_PATH
- if (hDir == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- hDir = ::CreateFileW(superPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
- }
- #endif
-
- bool res = false;
- if (hDir != INVALID_HANDLE_VALUE)
- {
- res = BOOLToBool(::SetFileTime(hDir, cTime, aTime, mTime));
- ::CloseHandle(hDir);
- }
- return res;
-}
-
-bool SetFileAttrib(CFSTR path, DWORD attrib)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::SetFileAttributes(fs2fas(path), attrib))
- return true;
- }
- else
- #endif
- {
- IF_USE_MAIN_PATH
- if (::SetFileAttributesW(fs2us(path), attrib))
- return true;
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- return BOOLToBool(::SetFileAttributesW(superPath, attrib));
- }
- #endif
- }
- return false;
-}
-
-
-bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib)
-{
- if ((attrib & 0xF0000000) != 0)
- attrib &= 0x3FFF;
- return SetFileAttrib(path, attrib);
-}
-
-
-bool RemoveDir(CFSTR path)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::RemoveDirectory(fs2fas(path)))
- return true;
- }
- else
- #endif
- {
- IF_USE_MAIN_PATH
- if (::RemoveDirectoryW(fs2us(path)))
- return true;
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- return BOOLToBool(::RemoveDirectoryW(superPath));
- }
- #endif
- }
- return false;
-}
-
-bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::MoveFile(fs2fas(oldFile), fs2fas(newFile)))
- return true;
- }
- else
- #endif
- {
- IF_USE_MAIN_PATH_2(oldFile, newFile)
- if (::MoveFileW(fs2us(oldFile), fs2us(newFile)))
- return true;
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH_2)
- {
- UString d1, d2;
- if (GetSuperPaths(oldFile, newFile, d1, d2, USE_MAIN_PATH_2))
- return BOOLToBool(::MoveFileW(d1, d2));
- }
- #endif
- }
- return false;
-}
-
-#ifndef UNDER_CE
-
-EXTERN_C_BEGIN
-typedef BOOL (WINAPI *Func_CreateHardLinkW)(
- LPCWSTR lpFileName,
- LPCWSTR lpExistingFileName,
- LPSECURITY_ATTRIBUTES lpSecurityAttributes
- );
-EXTERN_C_END
-
-bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return false;
- /*
- if (::CreateHardLink(fs2fas(newFileName), fs2fas(existFileName), NULL))
- return true;
- */
- }
- else
- #endif
- {
- Func_CreateHardLinkW my_CreateHardLinkW = (Func_CreateHardLinkW)
- ::GetProcAddress(::GetModuleHandleW(L"kernel32.dll"), "CreateHardLinkW");
- if (!my_CreateHardLinkW)
- return false;
- IF_USE_MAIN_PATH_2(newFileName, existFileName)
- if (my_CreateHardLinkW(fs2us(newFileName), fs2us(existFileName), NULL))
- return true;
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH_2)
- {
- UString d1, d2;
- if (GetSuperPaths(newFileName, existFileName, d1, d2, USE_MAIN_PATH_2))
- return BOOLToBool(my_CreateHardLinkW(d1, d2, NULL));
- }
- #endif
- }
- return false;
-}
-
-#endif
-
-/*
-WinXP-64 CreateDir():
- "" - ERROR_PATH_NOT_FOUND
- \ - ERROR_ACCESS_DENIED
- C:\ - ERROR_ACCESS_DENIED, if there is such drive,
-
- D:\folder - ERROR_PATH_NOT_FOUND, if there is no such drive,
- C:\nonExistent\folder - ERROR_PATH_NOT_FOUND
-
- C:\existFolder - ERROR_ALREADY_EXISTS
- C:\existFolder\ - ERROR_ALREADY_EXISTS
-
- C:\folder - OK
- C:\folder\ - OK
-
- \\Server\nonExistent - ERROR_BAD_NETPATH
- \\Server\Share_Readonly - ERROR_ACCESS_DENIED
- \\Server\Share - ERROR_ALREADY_EXISTS
-
- \\Server\Share_NTFS_drive - ERROR_ACCESS_DENIED
- \\Server\Share_FAT_drive - ERROR_ALREADY_EXISTS
-*/
-
-bool CreateDir(CFSTR path)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::CreateDirectory(fs2fas(path), NULL))
- return true;
- }
- else
- #endif
- {
- IF_USE_MAIN_PATH
- if (::CreateDirectoryW(fs2us(path), NULL))
- return true;
- #ifdef WIN_LONG_PATH
- if ((!USE_MAIN_PATH || ::GetLastError() != ERROR_ALREADY_EXISTS) && USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- return BOOLToBool(::CreateDirectoryW(superPath, NULL));
- }
- #endif
- }
- return false;
-}
-
-/*
- CreateDir2 returns true, if directory can contain files after the call (two cases):
- 1) the directory already exists
- 2) the directory was created
- path must be WITHOUT trailing path separator.
-
- We need CreateDir2, since fileInfo.Find() for reserved names like "com8"
- returns FILE instead of DIRECTORY. And we need to use SuperPath */
-
-static bool CreateDir2(CFSTR path)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::CreateDirectory(fs2fas(path), NULL))
- return true;
- }
- else
- #endif
- {
- IF_USE_MAIN_PATH
- if (::CreateDirectoryW(fs2us(path), NULL))
- return true;
- #ifdef WIN_LONG_PATH
- if ((!USE_MAIN_PATH || ::GetLastError() != ERROR_ALREADY_EXISTS) && USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- {
- if (::CreateDirectoryW(superPath, NULL))
- return true;
- if (::GetLastError() != ERROR_ALREADY_EXISTS)
- return false;
- NFind::CFileInfo fi;
- if (!fi.Find(us2fs(superPath)))
- return false;
- return fi.IsDir();
- }
- }
- #endif
- }
- if (::GetLastError() != ERROR_ALREADY_EXISTS)
- return false;
- NFind::CFileInfo fi;
- if (!fi.Find(path))
- return false;
- return fi.IsDir();
-}
-
-bool CreateComplexDir(CFSTR _path)
-{
- #ifdef _WIN32
-
- {
- DWORD attrib = NFind::GetFileAttrib(_path);
- if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
- return true;
- }
-
- #ifndef UNDER_CE
-
- if (IsDriveRootPath_SuperAllowed(_path))
- return false;
-
- unsigned prefixSize = GetRootPrefixSize(_path);
-
- #endif
-
- #endif
-
- FString path (_path);
-
- int pos = path.ReverseFind_PathSepar();
- if (pos >= 0 && (unsigned)pos == path.Len() - 1)
- {
- if (path.Len() == 1)
- return true;
- path.DeleteBack();
- }
-
- const FString path2 (path);
- pos = path.Len();
-
- for (;;)
- {
- if (CreateDir2(path))
- break;
- if (::GetLastError() == ERROR_ALREADY_EXISTS)
- return false;
- pos = path.ReverseFind_PathSepar();
- if (pos < 0 || pos == 0)
- return false;
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (pos == 1 && IS_PATH_SEPAR(path[0]))
- return false;
- if (prefixSize >= (unsigned)pos + 1)
- return false;
- #endif
-
- path.DeleteFrom(pos);
- }
-
- while (pos < (int)path2.Len())
- {
- int pos2 = NName::FindSepar(path2.Ptr(pos + 1));
- if (pos2 < 0)
- pos = path2.Len();
- else
- pos += 1 + pos2;
- path.SetFrom(path2, pos);
- if (!CreateDir(path))
- return false;
- }
-
- return true;
-}
-
-bool DeleteFileAlways(CFSTR path)
-{
- /* If alt stream, we also need to clear READ-ONLY attribute of main file before delete.
- SetFileAttrib("name:stream", ) changes attributes of main file. */
- {
- DWORD attrib = NFind::GetFileAttrib(path);
- if (attrib != INVALID_FILE_ATTRIBUTES
- && (attrib & FILE_ATTRIBUTE_DIRECTORY) == 0
- && (attrib & FILE_ATTRIBUTE_READONLY) != 0)
- {
- if (!SetFileAttrib(path, attrib & ~FILE_ATTRIBUTE_READONLY))
- return false;
- }
- }
-
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- if (::DeleteFile(fs2fas(path)))
- return true;
- }
- else
- #endif
- {
- /* DeleteFile("name::$DATA") deletes all alt streams (same as delete DeleteFile("name")).
- Maybe it's better to open "name::$DATA" and clear data for unnamed stream? */
- IF_USE_MAIN_PATH
- if (::DeleteFileW(fs2us(path)))
- return true;
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- return BOOLToBool(::DeleteFileW(superPath));
- }
- #endif
- }
- return false;
-}
-
-bool RemoveDirWithSubItems(const FString &path)
-{
- bool needRemoveSubItems = true;
- {
- NFind::CFileInfo fi;
- if (!fi.Find(path))
- return false;
- if (!fi.IsDir())
- {
- ::SetLastError(ERROR_DIRECTORY);
- return false;
- }
- if (fi.HasReparsePoint())
- needRemoveSubItems = false;
- }
-
- if (needRemoveSubItems)
- {
- FString s (path);
- s.Add_PathSepar();
- const unsigned prefixSize = s.Len();
- NFind::CEnumerator enumerator;
- enumerator.SetDirPrefix(s);
- NFind::CFileInfo fi;
- while (enumerator.Next(fi))
- {
- s.DeleteFrom(prefixSize);
- s += fi.Name;
- if (fi.IsDir())
- {
- if (!RemoveDirWithSubItems(s))
- return false;
- }
- else if (!DeleteFileAlways(s))
- return false;
- }
- }
-
- if (!SetFileAttrib(path, 0))
- return false;
- return RemoveDir(path);
-}
-
-#ifdef UNDER_CE
-
-bool MyGetFullPathName(CFSTR path, FString &resFullPath)
-{
- resFullPath = path;
- return true;
-}
-
-#else
-
-bool MyGetFullPathName(CFSTR path, FString &resFullPath)
-{
- return GetFullPath(path, resFullPath);
-}
-
-bool SetCurrentDir(CFSTR path)
-{
- // SetCurrentDirectory doesn't support \\?\ prefix
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- return BOOLToBool(::SetCurrentDirectory(fs2fas(path)));
- }
- else
- #endif
- {
- return BOOLToBool(::SetCurrentDirectoryW(fs2us(path)));
- }
-}
-
-bool GetCurrentDir(FString &path)
-{
- path.Empty();
- DWORD needLength;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetCurrentDirectory(MAX_PATH + 1, s);
- path = fas2fs(s);
- }
- else
- #endif
- {
- WCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, s);
- path = us2fs(s);
- }
- return (needLength > 0 && needLength <= MAX_PATH);
-}
-
-#endif
-
-bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName)
-{
- bool res = MyGetFullPathName(path, resDirPrefix);
- if (!res)
- resDirPrefix = path;
- int pos = resDirPrefix.ReverseFind_PathSepar();
- resFileName = resDirPrefix.Ptr(pos + 1);
- resDirPrefix.DeleteFrom(pos + 1);
- return res;
-}
-
-bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix)
-{
- FString resFileName;
- return GetFullPathAndSplit(path, resDirPrefix, resFileName);
-}
-
-bool MyGetTempPath(FString &path)
-{
- path.Empty();
- DWORD needLength;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetTempPath(MAX_PATH + 1, s);
- path = fas2fs(s);
- }
- else
- #endif
- {
- WCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetTempPathW(MAX_PATH + 1, s);;
- path = us2fs(s);
- }
- return (needLength > 0 && needLength <= MAX_PATH);
-}
-
-static bool CreateTempFile(CFSTR prefix, bool addRandom, FString &path, NIO::COutFile *outFile)
-{
- UInt32 d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
- for (unsigned i = 0; i < 100; i++)
- {
- path = prefix;
- if (addRandom)
- {
- char s[16];
- UInt32 val = d;
- unsigned k;
- for (k = 0; k < 8; k++)
- {
- unsigned t = val & 0xF;
- val >>= 4;
- s[k] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
- }
- s[k] = '\0';
- if (outFile)
- path += '.';
- path += s;
- UInt32 step = GetTickCount() + 2;
- if (step == 0)
- step = 1;
- d += step;
- }
- addRandom = true;
- if (outFile)
- path += ".tmp";
- if (NFind::DoesFileOrDirExist(path))
- {
- SetLastError(ERROR_ALREADY_EXISTS);
- continue;
- }
- if (outFile)
- {
- if (outFile->Create(path, false))
- return true;
- }
- else
- {
- if (CreateDir(path))
- return true;
- }
- DWORD error = GetLastError();
- if (error != ERROR_FILE_EXISTS &&
- error != ERROR_ALREADY_EXISTS)
- break;
- }
- path.Empty();
- return false;
-}
-
-bool CTempFile::Create(CFSTR prefix, NIO::COutFile *outFile)
-{
- if (!Remove())
- return false;
- if (!CreateTempFile(prefix, false, _path, outFile))
- return false;
- _mustBeDeleted = true;
- return true;
-}
-
-bool CTempFile::CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile)
-{
- if (!Remove())
- return false;
- FString tempPath;
- if (!MyGetTempPath(tempPath))
- return false;
- if (!CreateTempFile(tempPath + namePrefix, true, _path, outFile))
- return false;
- _mustBeDeleted = true;
- return true;
-}
-
-bool CTempFile::Remove()
-{
- if (!_mustBeDeleted)
- return true;
- _mustBeDeleted = !DeleteFileAlways(_path);
- return !_mustBeDeleted;
-}
-
-bool CTempFile::MoveTo(CFSTR name, bool deleteDestBefore)
-{
- // DWORD attrib = 0;
- if (deleteDestBefore)
- {
- if (NFind::DoesFileExist(name))
- {
- // attrib = NFind::GetFileAttrib(name);
- if (!DeleteFileAlways(name))
- return false;
- }
- }
- DisableDeleting();
- return MyMoveFile(_path, name);
-
- /*
- if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
- {
- DWORD attrib2 = NFind::GetFileAttrib(name);
- if (attrib2 != INVALID_FILE_ATTRIBUTES)
- SetFileAttrib(name, attrib2 | FILE_ATTRIBUTE_READONLY);
- }
- */
-}
-
-bool CTempDir::Create(CFSTR prefix)
-{
- if (!Remove())
- return false;
- FString tempPath;
- if (!MyGetTempPath(tempPath))
- return false;
- if (!CreateTempFile(tempPath + prefix, true, _path, NULL))
- return false;
- _mustBeDeleted = true;
- return true;
-}
-
-bool CTempDir::Remove()
-{
- if (!_mustBeDeleted)
- return true;
- _mustBeDeleted = !RemoveDirWithSubItems(_path);
- return !_mustBeDeleted;
-}
-
-}}}
+// Windows/FileDir.cpp
+
+#include "StdAfx.h"
+
+
+#ifndef _WIN32
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+#include <unistd.h>
+#include <time.h>
+#include <utime.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "../Common/StringConvert.h"
+#include "../Common/C_FileIO.h"
+#endif
+
+#include "FileDir.h"
+#include "FileFind.h"
+#include "FileName.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+#ifndef _WIN32
+
+static bool FiTime_To_timespec(const CFiTime *ft, timespec &ts)
+{
+ if (ft)
+ {
+ ts = *ft;
+ return true;
+ }
+ // else
+ {
+ ts.tv_sec = 0;
+ ts.tv_nsec =
+ #ifdef UTIME_OMIT
+ UTIME_OMIT; // -2 keep old timesptamp
+ #else
+ // UTIME_NOW; -1 // set to the current time
+ 0;
+ #endif
+ return false;
+ }
+}
+#endif
+
+namespace NWindows {
+namespace NFile {
+namespace NDir {
+
+#ifdef _WIN32
+
+#ifndef UNDER_CE
+
+bool GetWindowsDir(FString &path)
+{
+ const unsigned kBufSize = MAX_PATH + 16;
+ UINT len;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ TCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetWindowsDirectory(s, kBufSize);
+ path = fas2fs(s);
+ }
+ else
+ #endif
+ {
+ WCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetWindowsDirectoryW(s, kBufSize);
+ path = us2fs(s);
+ }
+ return (len != 0 && len < kBufSize);
+}
+
+
+/*
+new DOCs for GetSystemDirectory:
+ returned path does not end with a backslash unless the
+ system directory is the root directory.
+*/
+
+bool GetSystemDir(FString &path)
+{
+ const unsigned kBufSize = MAX_PATH + 16;
+ UINT len;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ TCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetSystemDirectory(s, kBufSize);
+ path = fas2fs(s);
+ }
+ else
+ #endif
+ {
+ WCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetSystemDirectoryW(s, kBufSize);
+ path = us2fs(s);
+ }
+ return (len != 0 && len < kBufSize);
+}
+#endif // UNDER_CE
+
+
+bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return false;
+ }
+ #endif
+
+ HANDLE hDir = INVALID_HANDLE_VALUE;
+ IF_USE_MAIN_PATH
+ hDir = ::CreateFileW(fs2us(path), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+ #ifdef Z7_LONG_PATH
+ if (hDir == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ hDir = ::CreateFileW(superPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+ }
+ #endif
+
+ bool res = false;
+ if (hDir != INVALID_HANDLE_VALUE)
+ {
+ res = BOOLToBool(::SetFileTime(hDir, cTime, aTime, mTime));
+ ::CloseHandle(hDir);
+ }
+ return res;
+}
+
+
+
+bool SetFileAttrib(CFSTR path, DWORD attrib)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::SetFileAttributes(fs2fas(path), attrib))
+ return true;
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ if (::SetFileAttributesW(fs2us(path), attrib))
+ return true;
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ return BOOLToBool(::SetFileAttributesW(superPath, attrib));
+ }
+ #endif
+ }
+ return false;
+}
+
+
+bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib)
+{
+ #ifdef _WIN32
+ if ((attrib & 0xF0000000) != 0)
+ attrib &= 0x3FFF;
+ #endif
+ return SetFileAttrib(path, attrib);
+}
+
+
+bool RemoveDir(CFSTR path)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::RemoveDirectory(fs2fas(path)))
+ return true;
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ if (::RemoveDirectoryW(fs2us(path)))
+ return true;
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ return BOOLToBool(::RemoveDirectoryW(superPath));
+ }
+ #endif
+ }
+ return false;
+}
+
+
+bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::MoveFile(fs2fas(oldFile), fs2fas(newFile)))
+ return true;
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH_2(oldFile, newFile)
+ {
+ if (::MoveFileW(fs2us(oldFile), fs2us(newFile)))
+ return true;
+ }
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH_2)
+ {
+ UString d1, d2;
+ if (GetSuperPaths(oldFile, newFile, d1, d2, USE_MAIN_PATH_2))
+ return BOOLToBool(::MoveFileW(d1, d2));
+ }
+ #endif
+ }
+ return false;
+}
+
+#ifndef UNDER_CE
+EXTERN_C_BEGIN
+typedef BOOL (WINAPI *Func_CreateHardLinkW)(
+ LPCWSTR lpFileName,
+ LPCWSTR lpExistingFileName,
+ LPSECURITY_ATTRIBUTES lpSecurityAttributes
+ );
+EXTERN_C_END
+#endif // UNDER_CE
+
+bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return false;
+ /*
+ if (::CreateHardLink(fs2fas(newFileName), fs2fas(existFileName), NULL))
+ return true;
+ */
+ }
+ else
+ #endif
+ {
+ const
+ Func_CreateHardLinkW
+ my_CreateHardLinkW = Z7_GET_PROC_ADDRESS(
+ Func_CreateHardLinkW, ::GetModuleHandleW(L"kernel32.dll"),
+ "CreateHardLinkW");
+ if (!my_CreateHardLinkW)
+ return false;
+ IF_USE_MAIN_PATH_2(newFileName, existFileName)
+ {
+ if (my_CreateHardLinkW(fs2us(newFileName), fs2us(existFileName), NULL))
+ return true;
+ }
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH_2)
+ {
+ UString d1, d2;
+ if (GetSuperPaths(newFileName, existFileName, d1, d2, USE_MAIN_PATH_2))
+ return BOOLToBool(my_CreateHardLinkW(d1, d2, NULL));
+ }
+ #endif
+ }
+ return false;
+}
+
+
+/*
+WinXP-64 CreateDir():
+ "" - ERROR_PATH_NOT_FOUND
+ \ - ERROR_ACCESS_DENIED
+ C:\ - ERROR_ACCESS_DENIED, if there is such drive,
+
+ D:\folder - ERROR_PATH_NOT_FOUND, if there is no such drive,
+ C:\nonExistent\folder - ERROR_PATH_NOT_FOUND
+
+ C:\existFolder - ERROR_ALREADY_EXISTS
+ C:\existFolder\ - ERROR_ALREADY_EXISTS
+
+ C:\folder - OK
+ C:\folder\ - OK
+
+ \\Server\nonExistent - ERROR_BAD_NETPATH
+ \\Server\Share_Readonly - ERROR_ACCESS_DENIED
+ \\Server\Share - ERROR_ALREADY_EXISTS
+
+ \\Server\Share_NTFS_drive - ERROR_ACCESS_DENIED
+ \\Server\Share_FAT_drive - ERROR_ALREADY_EXISTS
+*/
+
+bool CreateDir(CFSTR path)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::CreateDirectory(fs2fas(path), NULL))
+ return true;
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ if (::CreateDirectoryW(fs2us(path), NULL))
+ return true;
+ #ifdef Z7_LONG_PATH
+ if ((!USE_MAIN_PATH || ::GetLastError() != ERROR_ALREADY_EXISTS) && USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ return BOOLToBool(::CreateDirectoryW(superPath, NULL));
+ }
+ #endif
+ }
+ return false;
+}
+
+/*
+ CreateDir2 returns true, if directory can contain files after the call (two cases):
+ 1) the directory already exists
+ 2) the directory was created
+ path must be WITHOUT trailing path separator.
+
+ We need CreateDir2, since fileInfo.Find() for reserved names like "com8"
+ returns FILE instead of DIRECTORY. And we need to use SuperPath */
+
+static bool CreateDir2(CFSTR path)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::CreateDirectory(fs2fas(path), NULL))
+ return true;
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ if (::CreateDirectoryW(fs2us(path), NULL))
+ return true;
+ #ifdef Z7_LONG_PATH
+ if ((!USE_MAIN_PATH || ::GetLastError() != ERROR_ALREADY_EXISTS) && USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ {
+ if (::CreateDirectoryW(superPath, NULL))
+ return true;
+ if (::GetLastError() != ERROR_ALREADY_EXISTS)
+ return false;
+ NFind::CFileInfo fi;
+ if (!fi.Find(us2fs(superPath)))
+ return false;
+ return fi.IsDir();
+ }
+ }
+ #endif
+ }
+ if (::GetLastError() != ERROR_ALREADY_EXISTS)
+ return false;
+ NFind::CFileInfo fi;
+ if (!fi.Find(path))
+ return false;
+ return fi.IsDir();
+}
+
+#endif // _WIN32
+
+static bool CreateDir2(CFSTR path);
+
+bool CreateComplexDir(CFSTR _path)
+{
+ #ifdef _WIN32
+
+ {
+ const DWORD attrib = NFind::GetFileAttrib(_path);
+ if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+ return true;
+ }
+
+ #ifndef UNDER_CE
+
+ if (IsDriveRootPath_SuperAllowed(_path))
+ return false;
+
+ const unsigned prefixSize = GetRootPrefixSize(_path);
+
+ #endif // UNDER_CE
+
+ #else // _WIN32
+
+ // Posix
+ NFind::CFileInfo fi;
+ if (fi.Find(_path))
+ {
+ if (fi.IsDir())
+ return true;
+ }
+
+ #endif // _WIN32
+
+ FString path (_path);
+
+ int pos = path.ReverseFind_PathSepar();
+ if (pos >= 0 && (unsigned)pos == path.Len() - 1)
+ {
+ if (path.Len() == 1)
+ return true;
+ path.DeleteBack();
+ }
+
+ const FString path2 (path);
+ pos = (int)path.Len();
+
+ for (;;)
+ {
+ if (CreateDir2(path))
+ break;
+ if (::GetLastError() == ERROR_ALREADY_EXISTS)
+ return false;
+ pos = path.ReverseFind_PathSepar();
+ if (pos < 0 || pos == 0)
+ return false;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (pos == 1 && IS_PATH_SEPAR(path[0]))
+ return false;
+ if (prefixSize >= (unsigned)pos + 1)
+ return false;
+ #endif
+
+ path.DeleteFrom((unsigned)pos);
+ }
+
+ while (pos < (int)path2.Len())
+ {
+ int pos2 = NName::FindSepar(path2.Ptr((unsigned)pos + 1));
+ if (pos2 < 0)
+ pos = (int)path2.Len();
+ else
+ pos += 1 + pos2;
+ path.SetFrom(path2, (unsigned)pos);
+ if (!CreateDir(path))
+ return false;
+ }
+
+ return true;
+}
+
+
+#ifdef _WIN32
+
+bool DeleteFileAlways(CFSTR path)
+{
+ /* If alt stream, we also need to clear READ-ONLY attribute of main file before delete.
+ SetFileAttrib("name:stream", ) changes attributes of main file. */
+ {
+ DWORD attrib = NFind::GetFileAttrib(path);
+ if (attrib != INVALID_FILE_ATTRIBUTES
+ && (attrib & FILE_ATTRIBUTE_DIRECTORY) == 0
+ && (attrib & FILE_ATTRIBUTE_READONLY) != 0)
+ {
+ if (!SetFileAttrib(path, attrib & ~(DWORD)FILE_ATTRIBUTE_READONLY))
+ return false;
+ }
+ }
+
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ if (::DeleteFile(fs2fas(path)))
+ return true;
+ }
+ else
+ #endif
+ {
+ /* DeleteFile("name::$DATA") deletes all alt streams (same as delete DeleteFile("name")).
+ Maybe it's better to open "name::$DATA" and clear data for unnamed stream? */
+ IF_USE_MAIN_PATH
+ if (::DeleteFileW(fs2us(path)))
+ return true;
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ return BOOLToBool(::DeleteFileW(superPath));
+ }
+ #endif
+ }
+ return false;
+}
+
+
+
+bool RemoveDirWithSubItems(const FString &path)
+{
+ bool needRemoveSubItems = true;
+ {
+ NFind::CFileInfo fi;
+ if (!fi.Find(path))
+ return false;
+ if (!fi.IsDir())
+ {
+ ::SetLastError(ERROR_DIRECTORY);
+ return false;
+ }
+ if (fi.HasReparsePoint())
+ needRemoveSubItems = false;
+ }
+
+ if (needRemoveSubItems)
+ {
+ FString s (path);
+ s.Add_PathSepar();
+ const unsigned prefixSize = s.Len();
+ NFind::CEnumerator enumerator;
+ enumerator.SetDirPrefix(s);
+ NFind::CDirEntry fi;
+ bool isError = false;
+ DWORD lastError = 0;
+ while (enumerator.Next(fi))
+ {
+ s.DeleteFrom(prefixSize);
+ s += fi.Name;
+ if (fi.IsDir())
+ {
+ if (!RemoveDirWithSubItems(s))
+ {
+ lastError = GetLastError();
+ isError = true;
+ }
+ }
+ else if (!DeleteFileAlways(s))
+ {
+ lastError = GetLastError();
+ isError = false;
+ }
+ }
+ if (isError)
+ {
+ SetLastError(lastError);
+ return false;
+ }
+ }
+
+ // we clear read-only attrib to remove read-only dir
+ if (!SetFileAttrib(path, 0))
+ return false;
+ return RemoveDir(path);
+}
+
+#endif // _WIN32
+
+#ifdef UNDER_CE
+
+bool MyGetFullPathName(CFSTR path, FString &resFullPath)
+{
+ resFullPath = path;
+ return true;
+}
+
+#else
+
+bool MyGetFullPathName(CFSTR path, FString &resFullPath)
+{
+ return GetFullPath(path, resFullPath);
+}
+
+#ifdef _WIN32
+
+/* Win10: SetCurrentDirectory() doesn't support long paths and
+ doesn't support super prefix "\\?\", if long path behavior is not
+ enabled in registry (LongPathsEnabled) and in manifest (longPathAware). */
+
+bool SetCurrentDir(CFSTR path)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ return BOOLToBool(::SetCurrentDirectory(fs2fas(path)));
+ }
+ else
+ #endif
+ {
+ return BOOLToBool(::SetCurrentDirectoryW(fs2us(path)));
+ }
+}
+
+
+/*
+we use system function GetCurrentDirectory()
+new GetCurrentDirectory() DOCs:
+ - If the function fails, the return value is zero.
+ - If the function succeeds, the return value specifies
+ the number of characters that are written to the buffer,
+ not including the terminating null character.
+ - If the buffer is not large enough, the return value specifies
+ the required size of the buffer, in characters,
+ including the null-terminating character.
+
+GetCurrentDir() calls GetCurrentDirectory().
+GetCurrentDirectory() in win10 in tests:
+ the returned (path) does not end with a backslash, if
+ current directory is not root directory of drive.
+ But that behavior is not guarantied in specification docs.
+*/
+
+bool GetCurrentDir(FString &path)
+{
+ const unsigned kBufSize = MAX_PATH + 16;
+ path.Empty();
+
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ TCHAR s[kBufSize + 1];
+ s[0] = 0;
+ const DWORD len = ::GetCurrentDirectory(kBufSize, s);
+ if (len == 0 || len >= kBufSize)
+ return false;
+ s[kBufSize] = 0; // optional guard
+ path = fas2fs(s);
+ return true;
+ }
+ else
+ #endif
+ {
+ DWORD len;
+ {
+ WCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetCurrentDirectoryW(kBufSize, s);
+ if (len == 0)
+ return false;
+ if (len < kBufSize)
+ {
+ s[kBufSize] = 0; // optional guard
+ path = us2fs(s);
+ return true;
+ }
+ }
+ UString temp;
+ const DWORD len2 = ::GetCurrentDirectoryW(len, temp.GetBuf(len));
+ if (len2 == 0)
+ return false;
+ temp.ReleaseBuf_CalcLen(len);
+ if (temp.Len() != len2 || len - 1 != len2)
+ {
+ /* it's unexpected case, if current dir of process
+ was changed between two function calls,
+ or some unexpected function implementation */
+ // SetLastError((DWORD)E_FAIL); // we can set some error code
+ return false;
+ }
+ path = us2fs(temp);
+ return true;
+ }
+}
+
+#endif // _WIN32
+#endif // UNDER_CE
+
+
+bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName)
+{
+ bool res = MyGetFullPathName(path, resDirPrefix);
+ if (!res)
+ resDirPrefix = path;
+ int pos = resDirPrefix.ReverseFind_PathSepar();
+ pos++;
+ resFileName = resDirPrefix.Ptr((unsigned)pos);
+ resDirPrefix.DeleteFrom((unsigned)pos);
+ return res;
+}
+
+bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix)
+{
+ FString resFileName;
+ return GetFullPathAndSplit(path, resDirPrefix, resFileName);
+}
+
+
+
+bool MyGetTempPath(FString &path)
+{
+ #ifdef _WIN32
+
+ /*
+ new DOCs for GetTempPathW():
+ - The returned string ends with a backslash.
+ - The maximum possible return value is MAX_PATH+1 (261).
+ */
+
+ const unsigned kBufSize = MAX_PATH + 16;
+ DWORD len;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ TCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetTempPath(kBufSize, s);
+ path = fas2fs(s);
+ }
+ else
+ #endif
+ {
+ WCHAR s[kBufSize + 1];
+ s[0] = 0;
+ len = ::GetTempPathW(kBufSize, s);
+ path = us2fs(s);
+ }
+ /* win10: GetTempPathW() doesn't set backslash at the end of path,
+ if (buffer_size == len_of(path_with_backslash)).
+ So we normalize path here: */
+ NormalizeDirPathPrefix(path);
+ return (len != 0 && len < kBufSize);
+
+ #else // !_WIN32
+
+ // FIXME: improve that code
+ path = STRING_PATH_SEPARATOR "tmp";
+ const char *s;
+ if (NFind::DoesDirExist_FollowLink(path))
+ s = STRING_PATH_SEPARATOR "tmp" STRING_PATH_SEPARATOR;
+ else
+ s = "." STRING_PATH_SEPARATOR;
+ path = s;
+ return true;
+
+ #endif
+}
+
+
+bool CreateTempFile2(CFSTR prefix, bool addRandom, AString &postfix, NIO::COutFile *outFile)
+{
+ UInt32 d =
+ #ifdef _WIN32
+ (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
+ #else
+ (UInt32)(time(NULL) << 12) ^ ((UInt32)getppid() << 14) ^ (UInt32)(getpid());
+ #endif
+
+ for (unsigned i = 0; i < 100; i++)
+ {
+ postfix.Empty();
+ if (addRandom)
+ {
+ char s[16];
+ UInt32 val = d;
+ unsigned k;
+ for (k = 0; k < 8; k++)
+ {
+ const unsigned t = val & 0xF;
+ val >>= 4;
+ s[k] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+ }
+ s[k] = '\0';
+ if (outFile)
+ postfix.Add_Dot();
+ postfix += s;
+ UInt32 step = GetTickCount() + 2;
+ if (step == 0)
+ step = 1;
+ d += step;
+ }
+ addRandom = true;
+ if (outFile)
+ postfix += ".tmp";
+ FString path (prefix);
+ path += postfix;
+ if (NFind::DoesFileOrDirExist(path))
+ {
+ SetLastError(ERROR_ALREADY_EXISTS);
+ continue;
+ }
+ if (outFile)
+ {
+ if (outFile->Create(path, false))
+ return true;
+ }
+ else
+ {
+ if (CreateDir(path))
+ return true;
+ }
+ const DWORD error = GetLastError();
+ if (error != ERROR_FILE_EXISTS &&
+ error != ERROR_ALREADY_EXISTS)
+ break;
+ }
+ postfix.Empty();
+ return false;
+}
+
+bool CTempFile::Create(CFSTR prefix, NIO::COutFile *outFile)
+{
+ if (!Remove())
+ return false;
+ _path.Empty();
+ AString postfix;
+ if (!CreateTempFile2(prefix, false, postfix, outFile))
+ return false;
+ _path = prefix;
+ _path += postfix;
+ _mustBeDeleted = true;
+ return true;
+}
+
+bool CTempFile::CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile)
+{
+ if (!Remove())
+ return false;
+ _path.Empty();
+ FString tempPath;
+ if (!MyGetTempPath(tempPath))
+ return false;
+ AString postfix;
+ tempPath += namePrefix;
+ if (!CreateTempFile2(tempPath, true, postfix, outFile))
+ return false;
+ _path = tempPath;
+ _path += postfix;
+ _mustBeDeleted = true;
+ return true;
+}
+
+bool CTempFile::Remove()
+{
+ if (!_mustBeDeleted)
+ return true;
+ _mustBeDeleted = !DeleteFileAlways(_path);
+ return !_mustBeDeleted;
+}
+
+bool CTempFile::MoveTo(CFSTR name, bool deleteDestBefore)
+{
+ // DWORD attrib = 0;
+ if (deleteDestBefore)
+ {
+ if (NFind::DoesFileExist_Raw(name))
+ {
+ // attrib = NFind::GetFileAttrib(name);
+ if (!DeleteFileAlways(name))
+ return false;
+ }
+ }
+ DisableDeleting();
+ return MyMoveFile(_path, name);
+
+ /*
+ if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
+ {
+ DWORD attrib2 = NFind::GetFileAttrib(name);
+ if (attrib2 != INVALID_FILE_ATTRIBUTES)
+ SetFileAttrib(name, attrib2 | FILE_ATTRIBUTE_READONLY);
+ }
+ */
+}
+
+#ifdef _WIN32
+bool CTempDir::Create(CFSTR prefix)
+{
+ if (!Remove())
+ return false;
+ _path.Empty();
+ FString tempPath;
+ if (!MyGetTempPath(tempPath))
+ return false;
+ tempPath += prefix;
+ AString postfix;
+ if (!CreateTempFile2(tempPath, true, postfix, NULL))
+ return false;
+ _path = tempPath;
+ _path += postfix;
+ _mustBeDeleted = true;
+ return true;
+}
+
+bool CTempDir::Remove()
+{
+ if (!_mustBeDeleted)
+ return true;
+ _mustBeDeleted = !RemoveDirWithSubItems(_path);
+ return !_mustBeDeleted;
+}
+#endif
+
+
+
+#ifndef _WIN32
+
+bool RemoveDir(CFSTR path)
+{
+ return (rmdir(path) == 0);
+}
+
+
+static BOOL My_CopyFile(CFSTR oldFile, CFSTR newFile)
+{
+ NWindows::NFile::NIO::COutFile outFile;
+ if (!outFile.Create(newFile, false))
+ return FALSE;
+
+ NWindows::NFile::NIO::CInFile inFile;
+ if (!inFile.Open(oldFile))
+ return FALSE;
+
+ char buf[1 << 14];
+
+ for (;;)
+ {
+ const ssize_t num = inFile.read_part(buf, sizeof(buf));
+ if (num == 0)
+ return TRUE;
+ if (num < 0)
+ return FALSE;
+ size_t processed;
+ const ssize_t num2 = outFile.write_full(buf, (size_t)num, processed);
+ if (num2 != num || processed != (size_t)num)
+ return FALSE;
+ }
+}
+
+
+bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
+{
+ int res = rename(oldFile, newFile);
+ if (res == 0)
+ return true;
+ if (errno != EXDEV) // (oldFile and newFile are not on the same mounted filesystem)
+ return false;
+
+ if (My_CopyFile(oldFile, newFile) == FALSE)
+ return false;
+
+ struct stat info_file;
+ res = stat(oldFile, &info_file);
+ if (res != 0)
+ return false;
+
+ /*
+ ret = chmod(dst,info_file.st_mode & g_umask.mask);
+ */
+ return (unlink(oldFile) == 0);
+}
+
+
+bool CreateDir(CFSTR path)
+{
+ return (mkdir(path, 0777) == 0); // change it
+}
+
+static bool CreateDir2(CFSTR path)
+{
+ return (mkdir(path, 0777) == 0); // change it
+}
+
+
+bool DeleteFileAlways(CFSTR path)
+{
+ return (remove(path) == 0);
+}
+
+bool SetCurrentDir(CFSTR path)
+{
+ return (chdir(path) == 0);
+}
+
+
+bool GetCurrentDir(FString &path)
+{
+ path.Empty();
+
+ #define MY_PATH_MAX PATH_MAX
+ // #define MY_PATH_MAX 1024
+
+ char s[MY_PATH_MAX + 1];
+ char *res = getcwd(s, MY_PATH_MAX);
+ if (res)
+ {
+ path = fas2fs(s);
+ return true;
+ }
+ {
+ // if (errno != ERANGE) return false;
+ #if defined(__GLIBC__) || defined(__APPLE__)
+ /* As an extension to the POSIX.1-2001 standard, glibc's getcwd()
+ allocates the buffer dynamically using malloc(3) if buf is NULL. */
+ res = getcwd(NULL, 0);
+ if (res)
+ {
+ path = fas2fs(res);
+ ::free(res);
+ return true;
+ }
+ #endif
+ return false;
+ }
+}
+
+
+
+// #undef UTIME_OMIT // to debug
+
+#ifndef UTIME_OMIT
+ /* we can define UTIME_OMIT for debian and another systems.
+ Is it OK to define UTIME_OMIT to -2 here, if UTIME_OMIT is not defined? */
+ // #define UTIME_OMIT -2
+#endif
+
+
+
+
+
+bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime)
+{
+ // need testing
+ /*
+ struct utimbuf buf;
+ struct stat st;
+ UNUSED_VAR(cTime)
+
+ printf("\nstat = %s\n", path);
+ int ret = stat(path, &st);
+
+ if (ret == 0)
+ {
+ buf.actime = st.st_atime;
+ buf.modtime = st.st_mtime;
+ }
+ else
+ {
+ time_t cur_time = time(0);
+ buf.actime = cur_time;
+ buf.modtime = cur_time;
+ }
+
+ if (aTime)
+ {
+ UInt32 ut;
+ if (NTime::FileTimeToUnixTime(*aTime, ut))
+ buf.actime = ut;
+ }
+
+ if (mTime)
+ {
+ UInt32 ut;
+ if (NTime::FileTimeToUnixTime(*mTime, ut))
+ buf.modtime = ut;
+ }
+
+ return utime(path, &buf) == 0;
+ */
+
+ // if (!aTime && !mTime) return true;
+
+ struct timespec times[2];
+ UNUSED_VAR(cTime)
+
+ bool needChange;
+ needChange = FiTime_To_timespec(aTime, times[0]);
+ needChange |= FiTime_To_timespec(mTime, times[1]);
+
+ /*
+ if (mTime)
+ {
+ printf("\n time = %ld.%9ld\n", mTime->tv_sec, mTime->tv_nsec);
+ }
+ */
+
+ if (!needChange)
+ return true;
+ const int flags = 0; // follow link
+ // = AT_SYMLINK_NOFOLLOW; // don't follow link
+ return utimensat(AT_FDCWD, path, times, flags) == 0;
+}
+
+
+
+struct C_umask
+{
+ mode_t mask;
+
+ C_umask()
+ {
+ /* by security reasons we restrict attributes according
+ with process's file mode creation mask (umask) */
+ const mode_t um = umask(0); // octal :0022 is expected
+ mask = 0777 & (~um); // octal: 0755 is expected
+ umask(um); // restore the umask
+ // printf("\n umask = 0%03o mask = 0%03o\n", um, mask);
+
+ // mask = 0777; // debug we can disable the restriction:
+ }
+};
+
+static C_umask g_umask;
+
+// #define PRF(x) x;
+#define PRF(x)
+
+#define TRACE_SetFileAttrib(msg) \
+ PRF(printf("\nSetFileAttrib(%s, %x) : %s\n", (const char *)path, attrib, msg);)
+
+#define TRACE_chmod(s, mode) \
+ PRF(printf("\n chmod(%s, %o)\n", (const char *)path, (unsigned)(mode));)
+
+int my_chown(CFSTR path, uid_t owner, gid_t group)
+{
+ return chown(path, owner, group);
+}
+
+bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib)
+{
+ TRACE_SetFileAttrib("")
+
+ struct stat st;
+
+ bool use_lstat = true;
+ if (use_lstat)
+ {
+ if (lstat(path, &st) != 0)
+ {
+ TRACE_SetFileAttrib("bad lstat()")
+ return false;
+ }
+ // TRACE_chmod("lstat", st.st_mode);
+ }
+ else
+ {
+ if (stat(path, &st) != 0)
+ {
+ TRACE_SetFileAttrib("bad stat()")
+ return false;
+ }
+ }
+
+ if (attrib & FILE_ATTRIBUTE_UNIX_EXTENSION)
+ {
+ TRACE_SetFileAttrib("attrib & FILE_ATTRIBUTE_UNIX_EXTENSION")
+ st.st_mode = attrib >> 16;
+ if (S_ISDIR(st.st_mode))
+ {
+ // user/7z must be able to create files in this directory
+ st.st_mode |= (S_IRUSR | S_IWUSR | S_IXUSR);
+ }
+ else if (!S_ISREG(st.st_mode))
+ return true;
+ }
+ else if (S_ISLNK(st.st_mode))
+ {
+ /* for most systems: permissions for symlinks are fixed to rwxrwxrwx.
+ so we don't need chmod() for symlinks. */
+ return true;
+ // SetLastError(ENOSYS);
+ // return false;
+ }
+ else
+ {
+ TRACE_SetFileAttrib("Only Windows Attributes")
+ // Only Windows Attributes
+ if (S_ISDIR(st.st_mode)
+ || (attrib & FILE_ATTRIBUTE_READONLY) == 0)
+ return true;
+ st.st_mode &= ~(mode_t)(S_IWUSR | S_IWGRP | S_IWOTH); // octal: ~0222; // disable write permissions
+ }
+
+ int res;
+ /*
+ if (S_ISLNK(st.st_mode))
+ {
+ printf("\nfchmodat()\n");
+ TRACE_chmod(path, (st.st_mode) & g_umask.mask)
+ // AT_SYMLINK_NOFOLLOW is not implemted still in Linux.
+ res = fchmodat(AT_FDCWD, path, (st.st_mode) & g_umask.mask,
+ S_ISLNK(st.st_mode) ? AT_SYMLINK_NOFOLLOW : 0);
+ }
+ else
+ */
+ {
+ TRACE_chmod(path, (st.st_mode) & g_umask.mask)
+ res = chmod(path, (st.st_mode) & g_umask.mask);
+ }
+ // TRACE_SetFileAttrib("End")
+ return (res == 0);
+}
+
+
+bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName)
+{
+ PRF(printf("\nhard link() %s -> %s\n", newFileName, existFileName);)
+ return (link(existFileName, newFileName) == 0);
+}
+
+#endif // !_WIN32
+
+// #endif
+
+}}}
diff --git a/CPP/Windows/FileDir.h b/CPP/Windows/FileDir.h
index 8d2b56a..573ffa2 100644
--- a/CPP/Windows/FileDir.h
+++ b/CPP/Windows/FileDir.h
@@ -1,117 +1,135 @@
-// Windows/FileDir.h
-
-#ifndef __WINDOWS_FILE_DIR_H
-#define __WINDOWS_FILE_DIR_H
-
-#include "../Common/MyString.h"
-
-#include "FileIO.h"
-
-namespace NWindows {
-namespace NFile {
-namespace NDir {
-
-bool GetWindowsDir(FString &path);
-bool GetSystemDir(FString &path);
-
-bool SetDirTime(CFSTR path, const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime);
-
-
-bool SetFileAttrib(CFSTR path, DWORD attrib);
-
-/*
- Some programs store posix attributes in high 16 bits of windows attributes field.
- Also some programs use additional flag markers: 0x8000 or 0x4000.
- SetFileAttrib_PosixHighDetect() tries to detect posix field, and it extracts only attribute
- bits that are related to current system only.
-*/
-
-bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib);
-
-
-bool MyMoveFile(CFSTR existFileName, CFSTR newFileName);
-
-#ifndef UNDER_CE
-bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName);
-#endif
-
-bool RemoveDir(CFSTR path);
-bool CreateDir(CFSTR path);
-
-/* CreateComplexDir returns true, if directory can contain files after the call (two cases):
- 1) the directory already exists (network shares and drive paths are supported)
- 2) the directory was created
- path can be WITH or WITHOUT trailing path separator. */
-
-bool CreateComplexDir(CFSTR path);
-
-bool DeleteFileAlways(CFSTR name);
-bool RemoveDirWithSubItems(const FString &path);
-
-bool MyGetFullPathName(CFSTR path, FString &resFullPath);
-bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
-bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix);
-
-#ifndef UNDER_CE
-
-bool SetCurrentDir(CFSTR path);
-bool GetCurrentDir(FString &resultPath);
-
-#endif
-
-bool MyGetTempPath(FString &resultPath);
-
-class CTempFile
-{
- bool _mustBeDeleted;
- FString _path;
- void DisableDeleting() { _mustBeDeleted = false; }
-public:
- CTempFile(): _mustBeDeleted(false) {}
- ~CTempFile() { Remove(); }
- const FString &GetPath() const { return _path; }
- bool Create(CFSTR pathPrefix, NIO::COutFile *outFile); // pathPrefix is not folder prefix
- bool CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile);
- bool Remove();
- bool MoveTo(CFSTR name, bool deleteDestBefore);
-};
-
-class CTempDir
-{
- bool _mustBeDeleted;
- FString _path;
-public:
- CTempDir(): _mustBeDeleted(false) {}
- ~CTempDir() { Remove(); }
- const FString &GetPath() const { return _path; }
- void DisableDeleting() { _mustBeDeleted = false; }
- bool Create(CFSTR namePrefix) ;
- bool Remove();
-};
-
-#if !defined(UNDER_CE)
-class CCurrentDirRestorer
-{
- FString _path;
-public:
- bool NeedRestore;
-
- CCurrentDirRestorer(): NeedRestore(true)
- {
- GetCurrentDir(_path);
- }
- ~CCurrentDirRestorer()
- {
- if (!NeedRestore)
- return;
- FString s;
- if (GetCurrentDir(s))
- if (s != _path)
- SetCurrentDir(_path);
- }
-};
-#endif
-
-}}}
-
-#endif
+// Windows/FileDir.h
+
+#ifndef ZIP7_INC_WINDOWS_FILE_DIR_H
+#define ZIP7_INC_WINDOWS_FILE_DIR_H
+
+#include "../Common/MyString.h"
+
+#include "FileIO.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NDir {
+
+bool GetWindowsDir(FString &path);
+bool GetSystemDir(FString &path);
+
+/*
+WIN32 API : SetFileTime() doesn't allow to set zero timestamps in file
+but linux : allows unix time = 0 in filesystem
+*/
+
+bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime);
+
+
+#ifdef _WIN32
+
+bool SetFileAttrib(CFSTR path, DWORD attrib);
+
+/*
+ Some programs store posix attributes in high 16 bits of windows attributes field.
+ Also some programs use additional flag markers: 0x8000 or 0x4000.
+ SetFileAttrib_PosixHighDetect() tries to detect posix field, and it extracts only attribute
+ bits that are related to current system only.
+*/
+#else
+
+int my_chown(CFSTR path, uid_t owner, gid_t group);
+
+#endif
+
+bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib);
+
+
+bool MyMoveFile(CFSTR existFileName, CFSTR newFileName);
+
+#ifndef UNDER_CE
+bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName);
+#endif
+
+bool RemoveDir(CFSTR path);
+bool CreateDir(CFSTR path);
+
+/* CreateComplexDir returns true, if directory can contain files after the call (two cases):
+ 1) the directory already exists (network shares and drive paths are supported)
+ 2) the directory was created
+ path can be WITH or WITHOUT trailing path separator. */
+
+bool CreateComplexDir(CFSTR path);
+
+bool DeleteFileAlways(CFSTR name);
+bool RemoveDirWithSubItems(const FString &path);
+
+bool MyGetFullPathName(CFSTR path, FString &resFullPath);
+bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
+bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix);
+
+#ifndef UNDER_CE
+
+bool SetCurrentDir(CFSTR path);
+bool GetCurrentDir(FString &resultPath);
+
+#endif
+
+bool MyGetTempPath(FString &resultPath);
+
+bool CreateTempFile2(CFSTR prefix, bool addRandom, AString &postfix, NIO::COutFile *outFile);
+
+class CTempFile MY_UNCOPYABLE
+{
+ bool _mustBeDeleted;
+ FString _path;
+ void DisableDeleting() { _mustBeDeleted = false; }
+public:
+ CTempFile(): _mustBeDeleted(false) {}
+ ~CTempFile() { Remove(); }
+ const FString &GetPath() const { return _path; }
+ bool Create(CFSTR pathPrefix, NIO::COutFile *outFile); // pathPrefix is not folder prefix
+ bool CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile);
+ bool Remove();
+ bool MoveTo(CFSTR name, bool deleteDestBefore);
+};
+
+
+#ifdef _WIN32
+class CTempDir MY_UNCOPYABLE
+{
+ bool _mustBeDeleted;
+ FString _path;
+public:
+ CTempDir(): _mustBeDeleted(false) {}
+ ~CTempDir() { Remove(); }
+ const FString &GetPath() const { return _path; }
+ void DisableDeleting() { _mustBeDeleted = false; }
+ bool Create(CFSTR namePrefix) ;
+ bool Remove();
+};
+#endif
+
+
+#if !defined(UNDER_CE)
+class CCurrentDirRestorer MY_UNCOPYABLE
+{
+ FString _path;
+public:
+ bool NeedRestore;
+
+ CCurrentDirRestorer(): NeedRestore(true)
+ {
+ GetCurrentDir(_path);
+ }
+ ~CCurrentDirRestorer()
+ {
+ if (!NeedRestore)
+ return;
+ FString s;
+ if (GetCurrentDir(s))
+ if (s != _path)
+ SetCurrentDir(_path);
+ }
+};
+#endif
+
+}}}
+
+#endif
diff --git a/CPP/Windows/FileFind.cpp b/CPP/Windows/FileFind.cpp
index 8c6255b..c562a90 100644
--- a/CPP/Windows/FileFind.cpp
+++ b/CPP/Windows/FileFind.cpp
@@ -1,749 +1,1329 @@
-// Windows/FileFind.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "FileFind.h"
-#include "FileIO.h"
-#include "FileName.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NName;
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-EXTERN_C_BEGIN
-
-typedef enum
-{
- My_FindStreamInfoStandard,
- My_FindStreamInfoMaxInfoLevel
-} MY_STREAM_INFO_LEVELS;
-
-typedef struct
-{
- LARGE_INTEGER StreamSize;
- WCHAR cStreamName[MAX_PATH + 36];
-} MY_WIN32_FIND_STREAM_DATA, *MY_PWIN32_FIND_STREAM_DATA;
-
-typedef WINBASEAPI HANDLE (WINAPI *FindFirstStreamW_Ptr)(LPCWSTR fileName, MY_STREAM_INFO_LEVELS infoLevel,
- LPVOID findStreamData, DWORD flags);
-
-typedef WINBASEAPI BOOL (APIENTRY *FindNextStreamW_Ptr)(HANDLE findStream, LPVOID findStreamData);
-
-EXTERN_C_END
-
-#endif
-
-namespace NWindows {
-namespace NFile {
-
-#ifdef SUPPORT_DEVICE_FILE
-namespace NSystem
-{
-bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
-}
-#endif
-
-namespace NFind {
-
-bool CFileInfo::IsDots() const throw()
-{
- if (!IsDir() || Name.IsEmpty())
- return false;
- if (Name[0] != '.')
- return false;
- return Name.Len() == 1 || (Name.Len() == 2 && Name[1] == '.');
-}
-
-#define WIN_FD_TO_MY_FI(fi, fd) \
- fi.Attrib = fd.dwFileAttributes; \
- fi.CTime = fd.ftCreationTime; \
- fi.ATime = fd.ftLastAccessTime; \
- fi.MTime = fd.ftLastWriteTime; \
- fi.Size = (((UInt64)fd.nFileSizeHigh) << 32) + fd.nFileSizeLow; \
- fi.IsAltStream = false; \
- fi.IsDevice = false;
-
- /*
- #ifdef UNDER_CE
- fi.ObjectID = fd.dwOID;
- #else
- fi.ReparseTag = fd.dwReserved0;
- #endif
- */
-
-static void Convert_WIN32_FIND_DATA_to_FileInfo(const WIN32_FIND_DATAW &fd, CFileInfo &fi)
-{
- WIN_FD_TO_MY_FI(fi, fd);
- fi.Name = us2fs(fd.cFileName);
- #if defined(_WIN32) && !defined(UNDER_CE)
- // fi.ShortName = us2fs(fd.cAlternateFileName);
- #endif
-}
-
-#ifndef _UNICODE
-
-static void Convert_WIN32_FIND_DATA_to_FileInfo(const WIN32_FIND_DATA &fd, CFileInfo &fi)
-{
- WIN_FD_TO_MY_FI(fi, fd);
- fi.Name = fas2fs(fd.cFileName);
- #if defined(_WIN32) && !defined(UNDER_CE)
- // fi.ShortName = fas2fs(fd.cAlternateFileName);
- #endif
-}
-#endif
-
-////////////////////////////////
-// CFindFile
-
-bool CFindFileBase::Close() throw()
-{
- if (_handle == INVALID_HANDLE_VALUE)
- return true;
- if (!::FindClose(_handle))
- return false;
- _handle = INVALID_HANDLE_VALUE;
- return true;
-}
-
-/*
-WinXP-64 FindFirstFile():
- "" - ERROR_PATH_NOT_FOUND
- folder\ - ERROR_FILE_NOT_FOUND
- \ - ERROR_FILE_NOT_FOUND
- c:\ - ERROR_FILE_NOT_FOUND
- c: - ERROR_FILE_NOT_FOUND, if current dir is ROOT ( c:\ )
- c: - OK, if current dir is NOT ROOT ( c:\folder )
- folder - OK
-
- \\ - ERROR_INVALID_NAME
- \\Server - ERROR_INVALID_NAME
- \\Server\ - ERROR_INVALID_NAME
-
- \\Server\Share - ERROR_BAD_NETPATH
- \\Server\Share - ERROR_BAD_NET_NAME (Win7).
- !!! There is problem : Win7 makes some requests for "\\Server\Shar" (look in Procmon),
- when we call it for "\\Server\Share"
-
- \\Server\Share\ - ERROR_FILE_NOT_FOUND
-
- \\?\UNC\Server\Share - ERROR_INVALID_NAME
- \\?\UNC\Server\Share - ERROR_BAD_PATHNAME (Win7)
- \\?\UNC\Server\Share\ - ERROR_FILE_NOT_FOUND
-
- \\Server\Share_RootDrive - ERROR_INVALID_NAME
- \\Server\Share_RootDrive\ - ERROR_INVALID_NAME
-
- c:\* - ERROR_FILE_NOT_FOUND, if thare are no item in that folder
-*/
-
-bool CFindFile::FindFirst(CFSTR path, CFileInfo &fi)
-{
- if (!Close())
- return false;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- WIN32_FIND_DATAA fd;
- _handle = ::FindFirstFileA(fs2fas(path), &fd);
- if (_handle == INVALID_HANDLE_VALUE)
- return false;
- Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
- }
- else
- #endif
- {
- WIN32_FIND_DATAW fd;
-
- IF_USE_MAIN_PATH
- _handle = ::FindFirstFileW(fs2us(path), &fd);
- #ifdef WIN_LONG_PATH
- if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- _handle = ::FindFirstFileW(superPath, &fd);
- }
- #endif
- if (_handle == INVALID_HANDLE_VALUE)
- return false;
- Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
- }
- return true;
-}
-
-bool CFindFile::FindNext(CFileInfo &fi)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- WIN32_FIND_DATAA fd;
- if (!::FindNextFileA(_handle, &fd))
- return false;
- Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
- }
- else
- #endif
- {
- WIN32_FIND_DATAW fd;
- if (!::FindNextFileW(_handle, &fd))
- return false;
- Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
- }
- return true;
-}
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-////////////////////////////////
-// AltStreams
-
-static FindFirstStreamW_Ptr g_FindFirstStreamW;
-static FindNextStreamW_Ptr g_FindNextStreamW;
-
-struct CFindStreamLoader
-{
- CFindStreamLoader()
- {
- g_FindFirstStreamW = (FindFirstStreamW_Ptr)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "FindFirstStreamW");
- g_FindNextStreamW = (FindNextStreamW_Ptr)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "FindNextStreamW");
- }
-} g_FindStreamLoader;
-
-bool CStreamInfo::IsMainStream() const throw()
-{
- return StringsAreEqualNoCase_Ascii(Name, "::$DATA");
-};
-
-UString CStreamInfo::GetReducedName() const
-{
- // remove ":$DATA" postfix, but keep postfix, if Name is "::$DATA"
- UString s (Name);
- if (s.Len() > 6 + 1 && StringsAreEqualNoCase_Ascii(s.RightPtr(6), ":$DATA"))
- s.DeleteFrom(s.Len() - 6);
- return s;
-}
-
-/*
-UString CStreamInfo::GetReducedName2() const
-{
- UString s = GetReducedName();
- if (!s.IsEmpty() && s[0] == ':')
- s.Delete(0);
- return s;
-}
-*/
-
-static void Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(const MY_WIN32_FIND_STREAM_DATA &sd, CStreamInfo &si)
-{
- si.Size = sd.StreamSize.QuadPart;
- si.Name = sd.cStreamName;
-}
-
-/*
- WinXP-64 FindFirstStream():
- "" - ERROR_PATH_NOT_FOUND
- folder\ - OK
- folder - OK
- \ - OK
- c:\ - OK
- c: - OK, if current dir is ROOT ( c:\ )
- c: - OK, if current dir is NOT ROOT ( c:\folder )
- \\Server\Share - OK
- \\Server\Share\ - OK
-
- \\ - ERROR_INVALID_NAME
- \\Server - ERROR_INVALID_NAME
- \\Server\ - ERROR_INVALID_NAME
-*/
-
-bool CFindStream::FindFirst(CFSTR path, CStreamInfo &si)
-{
- if (!Close())
- return false;
- if (!g_FindFirstStreamW)
- {
- ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return false;
- }
- {
- MY_WIN32_FIND_STREAM_DATA sd;
- SetLastError(0);
- IF_USE_MAIN_PATH
- _handle = g_FindFirstStreamW(fs2us(path), My_FindStreamInfoStandard, &sd, 0);
- if (_handle == INVALID_HANDLE_VALUE)
- {
- if (::GetLastError() == ERROR_HANDLE_EOF)
- return false;
- // long name can be tricky for path like ".\dirName".
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- _handle = g_FindFirstStreamW(superPath, My_FindStreamInfoStandard, &sd, 0);
- }
- #endif
- }
- if (_handle == INVALID_HANDLE_VALUE)
- return false;
- Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(sd, si);
- }
- return true;
-}
-
-bool CFindStream::FindNext(CStreamInfo &si)
-{
- if (!g_FindNextStreamW)
- {
- ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return false;
- }
- {
- MY_WIN32_FIND_STREAM_DATA sd;
- if (!g_FindNextStreamW(_handle, &sd))
- return false;
- Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(sd, si);
- }
- return true;
-}
-
-bool CStreamEnumerator::Next(CStreamInfo &si, bool &found)
-{
- bool res;
- if (_find.IsHandleAllocated())
- res = _find.FindNext(si);
- else
- res = _find.FindFirst(_filePath, si);
- if (res)
- {
- found = true;
- return true;
- }
- found = false;
- return (::GetLastError() == ERROR_HANDLE_EOF);
-}
-
-#endif
-
-
-#define MY_CLEAR_FILETIME(ft) ft.dwLowDateTime = ft.dwHighDateTime = 0;
-
-void CFileInfoBase::ClearBase() throw()
-{
- Size = 0;
- MY_CLEAR_FILETIME(CTime);
- MY_CLEAR_FILETIME(ATime);
- MY_CLEAR_FILETIME(MTime);
- Attrib = 0;
- IsAltStream = false;
- IsDevice = false;
-}
-
-/*
-WinXP-64 GetFileAttributes():
- If the function fails, it returns INVALID_FILE_ATTRIBUTES and use GetLastError() to get error code
-
- \ - OK
- C:\ - OK, if there is such drive,
- D:\ - ERROR_PATH_NOT_FOUND, if there is no such drive,
-
- C:\folder - OK
- C:\folder\ - OK
- C:\folderBad - ERROR_FILE_NOT_FOUND
-
- \\Server\BadShare - ERROR_BAD_NETPATH
- \\Server\Share - WORKS OK, but MSDN says:
- GetFileAttributes for a network share, the function fails, and GetLastError
- returns ERROR_BAD_NETPATH. You must specify a path to a subfolder on that share.
-*/
-
-DWORD GetFileAttrib(CFSTR path)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- return ::GetFileAttributes(fs2fas(path));
- else
- #endif
- {
- IF_USE_MAIN_PATH
- {
- DWORD dw = ::GetFileAttributesW(fs2us(path));
- if (dw != INVALID_FILE_ATTRIBUTES)
- return dw;
- }
- #ifdef WIN_LONG_PATH
- if (USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- return ::GetFileAttributesW(superPath);
- }
- #endif
- return INVALID_FILE_ATTRIBUTES;
- }
-}
-
-/* if path is "c:" or "c::" then CFileInfo::Find() returns name of current folder for that disk
- so instead of absolute path we have relative path in Name. That is not good in some calls */
-
-/* In CFileInfo::Find() we want to support same names for alt streams as in CreateFile(). */
-
-/* CFileInfo::Find()
-We alow the following paths (as FindFirstFile):
- C:\folder
- c: - if current dir is NOT ROOT ( c:\folder )
-
-also we support paths that are not supported by FindFirstFile:
- \
- \\.\c:
- c:\ - Name will be without tail slash ( c: )
- \\?\c:\ - Name will be without tail slash ( c: )
- \\Server\Share
- \\?\UNC\Server\Share
-
- c:\folder:stream - Name = folder:stream
- c:\:stream - Name = :stream
- c::stream - Name = c::stream
-*/
-
-bool CFileInfo::Find(CFSTR path)
-{
- #ifdef SUPPORT_DEVICE_FILE
- if (IsDevicePath(path))
- {
- ClearBase();
- Name = path + 4;
- IsDevice = true;
-
- if (NName::IsDrivePath2(path + 4) && path[6] == 0)
- {
- FChar drive[4] = { path[4], ':', '\\', 0 };
- UInt64 clusterSize, totalSize, freeSize;
- if (NSystem::MyGetDiskFreeSpace(drive, clusterSize, totalSize, freeSize))
- {
- Size = totalSize;
- return true;
- }
- }
-
- NIO::CInFile inFile;
- // ::OutputDebugStringW(path);
- if (!inFile.Open(path))
- return false;
- // ::OutputDebugStringW(L"---");
- if (inFile.SizeDefined)
- Size = inFile.Size;
- return true;
- }
- #endif
-
- #if defined(_WIN32) && !defined(UNDER_CE)
-
- int colonPos = FindAltStreamColon(path);
- if (colonPos >= 0 && path[(unsigned)colonPos + 1] != 0)
- {
- UString streamName = fs2us(path + (unsigned)colonPos);
- FString filePath (path);
- filePath.DeleteFrom(colonPos);
- /* we allow both cases:
- name:stream
- name:stream:$DATA
- */
- const unsigned kPostfixSize = 6;
- if (streamName.Len() <= kPostfixSize
- || !StringsAreEqualNoCase_Ascii(streamName.RightPtr(kPostfixSize), ":$DATA"))
- streamName += ":$DATA";
-
- bool isOk = true;
-
- if (IsDrivePath2(filePath) &&
- (colonPos == 2 || colonPos == 3 && filePath[2] == '\\'))
- {
- // FindFirstFile doesn't work for "c:\" and for "c:" (if current dir is ROOT)
- ClearBase();
- Name.Empty();
- if (colonPos == 2)
- Name = filePath;
- }
- else
- isOk = Find(filePath);
-
- if (isOk)
- {
- Attrib &= ~(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
- Size = 0;
- CStreamEnumerator enumerator(filePath);
- for (;;)
- {
- CStreamInfo si;
- bool found;
- if (!enumerator.Next(si, found))
- return false;
- if (!found)
- {
- ::SetLastError(ERROR_FILE_NOT_FOUND);
- return false;
- }
- if (si.Name.IsEqualTo_NoCase(streamName))
- {
- // we delete postfix, if alt stream name is not "::$DATA"
- if (si.Name.Len() > kPostfixSize + 1)
- si.Name.DeleteFrom(si.Name.Len() - kPostfixSize);
- Name += us2fs(si.Name);
- Size = si.Size;
- IsAltStream = true;
- return true;
- }
- }
- }
- }
-
- #endif
-
- CFindFile finder;
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- {
- /*
- DWORD lastError = GetLastError();
- if (lastError == ERROR_FILE_NOT_FOUND
- || lastError == ERROR_BAD_NETPATH // XP64: "\\Server\Share"
- || lastError == ERROR_BAD_NET_NAME // Win7: "\\Server\Share"
- || lastError == ERROR_INVALID_NAME // XP64: "\\?\UNC\Server\Share"
- || lastError == ERROR_BAD_PATHNAME // Win7: "\\?\UNC\Server\Share"
- )
- */
-
- unsigned rootSize = 0;
- if (IsSuperPath(path))
- rootSize = kSuperPathPrefixSize;
-
- if (NName::IsDrivePath(path + rootSize) && path[rootSize + 3] == 0)
- {
- DWORD attrib = GetFileAttrib(path);
- if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
- {
- ClearBase();
- Attrib = attrib;
- Name = path + rootSize;
- Name.DeleteFrom(2); // we don't need backslash (C:)
- return true;
- }
- }
- else if (IS_PATH_SEPAR(path[0]))
- if (path[1] == 0)
- {
- DWORD attrib = GetFileAttrib(path);
- if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
- {
- ClearBase();
- Name.Empty();
- Attrib = attrib;
- return true;
- }
- }
- else
- {
- const unsigned prefixSize = GetNetworkServerPrefixSize(path);
- if (prefixSize > 0 && path[prefixSize] != 0)
- {
- if (NName::FindSepar(path + prefixSize) < 0)
- {
- FString s (path);
- s.Add_PathSepar();
- s += '*'; // CHAR_ANY_MASK
-
- bool isOK = false;
- if (finder.FindFirst(s, *this))
- {
- if (Name == FTEXT("."))
- {
- Name = path + prefixSize;
- return true;
- }
- isOK = true;
- /* if "\\server\share" maps to root folder "d:\", there is no "." item.
- But it's possible that there are another items */
- }
- {
- DWORD attrib = GetFileAttrib(path);
- if (isOK || attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
- {
- ClearBase();
- if (attrib != INVALID_FILE_ATTRIBUTES)
- Attrib = attrib;
- else
- SetAsDir();
- Name = path + prefixSize;
- return true;
- }
- }
- // ::SetLastError(lastError);
- }
- }
- }
- }
- #endif
-
- return finder.FindFirst(path, *this);
-}
-
-
-bool DoesFileExist(CFSTR name)
-{
- CFileInfo fi;
- return fi.Find(name) && !fi.IsDir();
-}
-
-bool DoesDirExist(CFSTR name)
-{
- CFileInfo fi;
- return fi.Find(name) && fi.IsDir();
-}
-
-bool DoesFileOrDirExist(CFSTR name)
-{
- CFileInfo fi;
- return fi.Find(name);
-}
-
-
-void CEnumerator::SetDirPrefix(const FString &dirPrefix)
-{
- _wildcard = dirPrefix;
- _wildcard += '*';
-}
-
-bool CEnumerator::NextAny(CFileInfo &fi)
-{
- if (_findFile.IsHandleAllocated())
- return _findFile.FindNext(fi);
- else
- return _findFile.FindFirst(_wildcard, fi);
-}
-
-bool CEnumerator::Next(CFileInfo &fi)
-{
- for (;;)
- {
- if (!NextAny(fi))
- return false;
- if (!fi.IsDots())
- return true;
- }
-}
-
-bool CEnumerator::Next(CFileInfo &fi, bool &found)
-{
- if (Next(fi))
- {
- found = true;
- return true;
- }
- found = false;
- return (::GetLastError() == ERROR_NO_MORE_FILES);
-}
-
-////////////////////////////////
-// CFindChangeNotification
-// FindFirstChangeNotification can return 0. MSDN doesn't tell about it.
-
-bool CFindChangeNotification::Close() throw()
-{
- if (!IsHandleAllocated())
- return true;
- if (!::FindCloseChangeNotification(_handle))
- return false;
- _handle = INVALID_HANDLE_VALUE;
- return true;
-}
-
-HANDLE CFindChangeNotification::FindFirst(CFSTR path, bool watchSubtree, DWORD notifyFilter)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- _handle = ::FindFirstChangeNotification(fs2fas(path), BoolToBOOL(watchSubtree), notifyFilter);
- else
- #endif
- {
- IF_USE_MAIN_PATH
- _handle = ::FindFirstChangeNotificationW(fs2us(path), BoolToBOOL(watchSubtree), notifyFilter);
- #ifdef WIN_LONG_PATH
- if (!IsHandleAllocated())
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- _handle = ::FindFirstChangeNotificationW(superPath, BoolToBOOL(watchSubtree), notifyFilter);
- }
- #endif
- }
- return _handle;
-}
-
-#ifndef UNDER_CE
-
-bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings)
-{
- driveStrings.Clear();
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- driveStrings.Clear();
- UINT32 size = GetLogicalDriveStrings(0, NULL);
- if (size == 0)
- return false;
- CObjArray<char> buf(size);
- UINT32 newSize = GetLogicalDriveStrings(size, buf);
- if (newSize == 0 || newSize > size)
- return false;
- AString s;
- UINT32 prev = 0;
- for (UINT32 i = 0; i < newSize; i++)
- {
- if (buf[i] == 0)
- {
- s = buf + prev;
- prev = i + 1;
- driveStrings.Add(fas2fs(s));
- }
- }
- return prev == newSize;
- }
- else
- #endif
- {
- UINT32 size = GetLogicalDriveStringsW(0, NULL);
- if (size == 0)
- return false;
- CObjArray<wchar_t> buf(size);
- UINT32 newSize = GetLogicalDriveStringsW(size, buf);
- if (newSize == 0 || newSize > size)
- return false;
- UString s;
- UINT32 prev = 0;
- for (UINT32 i = 0; i < newSize; i++)
- {
- if (buf[i] == 0)
- {
- s = buf + prev;
- prev = i + 1;
- driveStrings.Add(us2fs(s));
- }
- }
- return prev == newSize;
- }
-}
-
-#endif
-
-}}}
+// Windows/FileFind.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#ifndef _WIN32
+#include <fcntl.h> /* Definition of AT_* constants */
+#include "TimeUtils.h"
+// for major
+// #include <sys/sysmacros.h>
+#endif
+
+#include "FileFind.h"
+#include "FileIO.h"
+#include "FileName.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+EXTERN_C_BEGIN
+
+typedef enum
+{
+ My_FindStreamInfoStandard,
+ My_FindStreamInfoMaxInfoLevel
+} MY_STREAM_INFO_LEVELS;
+
+typedef struct
+{
+ LARGE_INTEGER StreamSize;
+ WCHAR cStreamName[MAX_PATH + 36];
+} MY_WIN32_FIND_STREAM_DATA, *MY_PWIN32_FIND_STREAM_DATA;
+
+typedef HANDLE (WINAPI *Func_FindFirstStreamW)(LPCWSTR fileName, MY_STREAM_INFO_LEVELS infoLevel,
+ LPVOID findStreamData, DWORD flags);
+
+typedef BOOL (APIENTRY *Func_FindNextStreamW)(HANDLE findStream, LPVOID findStreamData);
+
+EXTERN_C_END
+
+#endif // defined(_WIN32) && !defined(UNDER_CE)
+
+
+namespace NWindows {
+namespace NFile {
+
+
+#ifdef _WIN32
+#ifdef Z7_DEVICE_FILE
+namespace NSystem
+{
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
+}
+#endif
+#endif
+
+namespace NFind {
+
+/*
+#ifdef _WIN32
+#define MY_CLEAR_FILETIME(ft) ft.dwLowDateTime = ft.dwHighDateTime = 0;
+#else
+#define MY_CLEAR_FILETIME(ft) ft.tv_sec = 0; ft.tv_nsec = 0;
+#endif
+*/
+
+void CFileInfoBase::ClearBase() throw()
+{
+ Size = 0;
+ FiTime_Clear(CTime);
+ FiTime_Clear(ATime);
+ FiTime_Clear(MTime);
+
+ #ifdef _WIN32
+ Attrib = 0;
+ // ReparseTag = 0;
+ IsAltStream = false;
+ IsDevice = false;
+ #else
+ dev = 0;
+ ino = 0;
+ mode = 0;
+ nlink = 0;
+ uid = 0;
+ gid = 0;
+ rdev = 0;
+ #endif
+}
+
+bool CFileInfo::IsDots() const throw()
+{
+ if (!IsDir() || Name.IsEmpty())
+ return false;
+ if (Name[0] != '.')
+ return false;
+ return Name.Len() == 1 || (Name.Len() == 2 && Name[1] == '.');
+}
+
+
+#ifdef _WIN32
+
+
+#define WIN_FD_TO_MY_FI(fi, fd) \
+ fi.Attrib = fd.dwFileAttributes; \
+ fi.CTime = fd.ftCreationTime; \
+ fi.ATime = fd.ftLastAccessTime; \
+ fi.MTime = fd.ftLastWriteTime; \
+ fi.Size = (((UInt64)fd.nFileSizeHigh) << 32) + fd.nFileSizeLow; \
+ /* fi.ReparseTag = fd.dwReserved0; */ \
+ fi.IsAltStream = false; \
+ fi.IsDevice = false;
+
+ /*
+ #ifdef UNDER_CE
+ fi.ObjectID = fd.dwOID;
+ #else
+ fi.ReparseTag = fd.dwReserved0;
+ #endif
+ */
+
+static void Convert_WIN32_FIND_DATA_to_FileInfo(const WIN32_FIND_DATAW &fd, CFileInfo &fi)
+{
+ WIN_FD_TO_MY_FI(fi, fd)
+ fi.Name = us2fs(fd.cFileName);
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // fi.ShortName = us2fs(fd.cAlternateFileName);
+ #endif
+}
+
+#ifndef _UNICODE
+static void Convert_WIN32_FIND_DATA_to_FileInfo(const WIN32_FIND_DATA &fd, CFileInfo &fi)
+{
+ WIN_FD_TO_MY_FI(fi, fd)
+ fi.Name = fas2fs(fd.cFileName);
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // fi.ShortName = fas2fs(fd.cAlternateFileName);
+ #endif
+}
+#endif
+
+////////////////////////////////
+// CFindFile
+
+bool CFindFileBase::Close() throw()
+{
+ if (_handle == INVALID_HANDLE_VALUE)
+ return true;
+ if (!::FindClose(_handle))
+ return false;
+ _handle = INVALID_HANDLE_VALUE;
+ return true;
+}
+
+/*
+WinXP-64 FindFirstFile():
+ "" - ERROR_PATH_NOT_FOUND
+ folder\ - ERROR_FILE_NOT_FOUND
+ \ - ERROR_FILE_NOT_FOUND
+ c:\ - ERROR_FILE_NOT_FOUND
+ c: - ERROR_FILE_NOT_FOUND, if current dir is ROOT ( c:\ )
+ c: - OK, if current dir is NOT ROOT ( c:\folder )
+ folder - OK
+
+ \\ - ERROR_INVALID_NAME
+ \\Server - ERROR_INVALID_NAME
+ \\Server\ - ERROR_INVALID_NAME
+
+ \\Server\Share - ERROR_BAD_NETPATH
+ \\Server\Share - ERROR_BAD_NET_NAME (Win7).
+ !!! There is problem : Win7 makes some requests for "\\Server\Shar" (look in Procmon),
+ when we call it for "\\Server\Share"
+
+ \\Server\Share\ - ERROR_FILE_NOT_FOUND
+
+ \\?\UNC\Server\Share - ERROR_INVALID_NAME
+ \\?\UNC\Server\Share - ERROR_BAD_PATHNAME (Win7)
+ \\?\UNC\Server\Share\ - ERROR_FILE_NOT_FOUND
+
+ \\Server\Share_RootDrive - ERROR_INVALID_NAME
+ \\Server\Share_RootDrive\ - ERROR_INVALID_NAME
+
+ e:\* - ERROR_FILE_NOT_FOUND, if there are no items in that root folder
+ w:\* - ERROR_PATH_NOT_FOUND, if there is no such drive w:
+*/
+
+bool CFindFile::FindFirst(CFSTR path, CFileInfo &fi)
+{
+ if (!Close())
+ return false;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ WIN32_FIND_DATAA fd;
+ _handle = ::FindFirstFileA(fs2fas(path), &fd);
+ if (_handle == INVALID_HANDLE_VALUE)
+ return false;
+ Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+ }
+ else
+ #endif
+ {
+ WIN32_FIND_DATAW fd;
+
+ IF_USE_MAIN_PATH
+ _handle = ::FindFirstFileW(fs2us(path), &fd);
+ #ifdef Z7_LONG_PATH
+ if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ _handle = ::FindFirstFileW(superPath, &fd);
+ }
+ #endif
+ if (_handle == INVALID_HANDLE_VALUE)
+ return false;
+ Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+ }
+ return true;
+}
+
+bool CFindFile::FindNext(CFileInfo &fi)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ WIN32_FIND_DATAA fd;
+ if (!::FindNextFileA(_handle, &fd))
+ return false;
+ Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+ }
+ else
+ #endif
+ {
+ WIN32_FIND_DATAW fd;
+ if (!::FindNextFileW(_handle, &fd))
+ return false;
+ Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+ }
+ return true;
+}
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+////////////////////////////////
+// AltStreams
+
+static Func_FindFirstStreamW g_FindFirstStreamW;
+static Func_FindNextStreamW g_FindNextStreamW;
+
+static struct CFindStreamLoader
+{
+ CFindStreamLoader()
+ {
+ const HMODULE hm = ::GetModuleHandleA("kernel32.dll");
+ g_FindFirstStreamW = Z7_GET_PROC_ADDRESS(
+ Func_FindFirstStreamW, hm,
+ "FindFirstStreamW");
+ g_FindNextStreamW = Z7_GET_PROC_ADDRESS(
+ Func_FindNextStreamW, hm,
+ "FindNextStreamW");
+ }
+} g_FindStreamLoader;
+
+bool CStreamInfo::IsMainStream() const throw()
+{
+ return StringsAreEqualNoCase_Ascii(Name, "::$DATA");
+}
+
+UString CStreamInfo::GetReducedName() const
+{
+ // remove ":$DATA" postfix, but keep postfix, if Name is "::$DATA"
+ UString s (Name);
+ if (s.Len() > 6 + 1 && StringsAreEqualNoCase_Ascii(s.RightPtr(6), ":$DATA"))
+ s.DeleteFrom(s.Len() - 6);
+ return s;
+}
+
+/*
+UString CStreamInfo::GetReducedName2() const
+{
+ UString s = GetReducedName();
+ if (!s.IsEmpty() && s[0] == ':')
+ s.Delete(0);
+ return s;
+}
+*/
+
+static void Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(const MY_WIN32_FIND_STREAM_DATA &sd, CStreamInfo &si)
+{
+ si.Size = (UInt64)sd.StreamSize.QuadPart;
+ si.Name = sd.cStreamName;
+}
+
+/*
+ WinXP-64 FindFirstStream():
+ "" - ERROR_PATH_NOT_FOUND
+ folder\ - OK
+ folder - OK
+ \ - OK
+ c:\ - OK
+ c: - OK, if current dir is ROOT ( c:\ )
+ c: - OK, if current dir is NOT ROOT ( c:\folder )
+ \\Server\Share - OK
+ \\Server\Share\ - OK
+
+ \\ - ERROR_INVALID_NAME
+ \\Server - ERROR_INVALID_NAME
+ \\Server\ - ERROR_INVALID_NAME
+*/
+
+bool CFindStream::FindFirst(CFSTR path, CStreamInfo &si)
+{
+ if (!Close())
+ return false;
+ if (!g_FindFirstStreamW)
+ {
+ ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return false;
+ }
+ {
+ MY_WIN32_FIND_STREAM_DATA sd;
+ SetLastError(0);
+ IF_USE_MAIN_PATH
+ _handle = g_FindFirstStreamW(fs2us(path), My_FindStreamInfoStandard, &sd, 0);
+ if (_handle == INVALID_HANDLE_VALUE)
+ {
+ if (::GetLastError() == ERROR_HANDLE_EOF)
+ return false;
+ // long name can be tricky for path like ".\dirName".
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ _handle = g_FindFirstStreamW(superPath, My_FindStreamInfoStandard, &sd, 0);
+ }
+ #endif
+ }
+ if (_handle == INVALID_HANDLE_VALUE)
+ return false;
+ Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(sd, si);
+ }
+ return true;
+}
+
+bool CFindStream::FindNext(CStreamInfo &si)
+{
+ if (!g_FindNextStreamW)
+ {
+ ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+ return false;
+ }
+ {
+ MY_WIN32_FIND_STREAM_DATA sd;
+ if (!g_FindNextStreamW(_handle, &sd))
+ return false;
+ Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(sd, si);
+ }
+ return true;
+}
+
+bool CStreamEnumerator::Next(CStreamInfo &si, bool &found)
+{
+ bool res;
+ if (_find.IsHandleAllocated())
+ res = _find.FindNext(si);
+ else
+ res = _find.FindFirst(_filePath, si);
+ if (res)
+ {
+ found = true;
+ return true;
+ }
+ found = false;
+ return (::GetLastError() == ERROR_HANDLE_EOF);
+}
+
+#endif
+
+
+/*
+WinXP-64 GetFileAttributes():
+ If the function fails, it returns INVALID_FILE_ATTRIBUTES and use GetLastError() to get error code
+
+ \ - OK
+ C:\ - OK, if there is such drive,
+ D:\ - ERROR_PATH_NOT_FOUND, if there is no such drive,
+
+ C:\folder - OK
+ C:\folder\ - OK
+ C:\folderBad - ERROR_FILE_NOT_FOUND
+
+ \\Server\BadShare - ERROR_BAD_NETPATH
+ \\Server\Share - WORKS OK, but MSDN says:
+ GetFileAttributes for a network share, the function fails, and GetLastError
+ returns ERROR_BAD_NETPATH. You must specify a path to a subfolder on that share.
+*/
+
+DWORD GetFileAttrib(CFSTR path)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ return ::GetFileAttributes(fs2fas(path));
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ {
+ DWORD dw = ::GetFileAttributesW(fs2us(path));
+ if (dw != INVALID_FILE_ATTRIBUTES)
+ return dw;
+ }
+ #ifdef Z7_LONG_PATH
+ if (USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ return ::GetFileAttributesW(superPath);
+ }
+ #endif
+ return INVALID_FILE_ATTRIBUTES;
+ }
+}
+
+/* if path is "c:" or "c::" then CFileInfo::Find() returns name of current folder for that disk
+ so instead of absolute path we have relative path in Name. That is not good in some calls */
+
+/* In CFileInfo::Find() we want to support same names for alt streams as in CreateFile(). */
+
+/* CFileInfo::Find()
+We alow the following paths (as FindFirstFile):
+ C:\folder
+ c: - if current dir is NOT ROOT ( c:\folder )
+
+also we support paths that are not supported by FindFirstFile:
+ \
+ \\.\c:
+ c:\ - Name will be without tail slash ( c: )
+ \\?\c:\ - Name will be without tail slash ( c: )
+ \\Server\Share
+ \\?\UNC\Server\Share
+
+ c:\folder:stream - Name = folder:stream
+ c:\:stream - Name = :stream
+ c::stream - Name = c::stream
+*/
+
+bool CFileInfo::Find(CFSTR path, bool followLink)
+{
+ #ifdef Z7_DEVICE_FILE
+
+ if (IS_PATH_SEPAR(path[0]) &&
+ IS_PATH_SEPAR(path[1]) &&
+ path[2] == '.' &&
+ path[3] == 0)
+ {
+ // 22.00 : it's virtual directory for devices
+ // IsDevice = true;
+ ClearBase();
+ Name = path + 2;
+ Attrib = FILE_ATTRIBUTE_DIRECTORY;
+ return true;
+ }
+
+ if (IsDevicePath(path))
+ {
+ ClearBase();
+ Name = path + 4;
+ IsDevice = true;
+
+ if (NName::IsDrivePath2(path + 4) && path[6] == 0)
+ {
+ FChar drive[4] = { path[4], ':', '\\', 0 };
+ UInt64 clusterSize, totalSize, freeSize;
+ if (NSystem::MyGetDiskFreeSpace(drive, clusterSize, totalSize, freeSize))
+ {
+ Size = totalSize;
+ return true;
+ }
+ }
+
+ NIO::CInFile inFile;
+ // ::OutputDebugStringW(path);
+ if (!inFile.Open(path))
+ return false;
+ // ::OutputDebugStringW(L"---");
+ if (inFile.SizeDefined)
+ Size = inFile.Size;
+ return true;
+ }
+ #endif
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+
+ const int colonPos = FindAltStreamColon(path);
+ if (colonPos >= 0 && path[(unsigned)colonPos + 1] != 0)
+ {
+ UString streamName = fs2us(path + (unsigned)colonPos);
+ FString filePath (path);
+ filePath.DeleteFrom((unsigned)colonPos);
+ /* we allow both cases:
+ name:stream
+ name:stream:$DATA
+ */
+ const unsigned kPostfixSize = 6;
+ if (streamName.Len() <= kPostfixSize
+ || !StringsAreEqualNoCase_Ascii(streamName.RightPtr(kPostfixSize), ":$DATA"))
+ streamName += ":$DATA";
+
+ bool isOk = true;
+
+ if (IsDrivePath2(filePath) &&
+ (colonPos == 2 || (colonPos == 3 && filePath[2] == '\\')))
+ {
+ // FindFirstFile doesn't work for "c:\" and for "c:" (if current dir is ROOT)
+ ClearBase();
+ Name.Empty();
+ if (colonPos == 2)
+ Name = filePath;
+ }
+ else
+ isOk = Find(filePath, followLink); // check it (followLink)
+
+ if (isOk)
+ {
+ Attrib &= ~(DWORD)(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+ Size = 0;
+ CStreamEnumerator enumerator(filePath);
+ for (;;)
+ {
+ CStreamInfo si;
+ bool found;
+ if (!enumerator.Next(si, found))
+ return false;
+ if (!found)
+ {
+ ::SetLastError(ERROR_FILE_NOT_FOUND);
+ return false;
+ }
+ if (si.Name.IsEqualTo_NoCase(streamName))
+ {
+ // we delete postfix, if alt stream name is not "::$DATA"
+ if (si.Name.Len() > kPostfixSize + 1)
+ si.Name.DeleteFrom(si.Name.Len() - kPostfixSize);
+ Name += us2fs(si.Name);
+ Size = si.Size;
+ IsAltStream = true;
+ return true;
+ }
+ }
+ }
+ }
+
+ #endif
+
+ CFindFile finder;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ {
+ /*
+ DWORD lastError = GetLastError();
+ if (lastError == ERROR_FILE_NOT_FOUND
+ || lastError == ERROR_BAD_NETPATH // XP64: "\\Server\Share"
+ || lastError == ERROR_BAD_NET_NAME // Win7: "\\Server\Share"
+ || lastError == ERROR_INVALID_NAME // XP64: "\\?\UNC\Server\Share"
+ || lastError == ERROR_BAD_PATHNAME // Win7: "\\?\UNC\Server\Share"
+ )
+ */
+
+ unsigned rootSize = 0;
+ if (IsSuperPath(path))
+ rootSize = kSuperPathPrefixSize;
+
+ if (NName::IsDrivePath(path + rootSize) && path[rootSize + 3] == 0)
+ {
+ DWORD attrib = GetFileAttrib(path);
+ if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+ {
+ ClearBase();
+ Attrib = attrib;
+ Name = path + rootSize;
+ Name.DeleteFrom(2);
+ if (!Fill_From_ByHandleFileInfo(path))
+ {
+ }
+ return true;
+ }
+ }
+ else if (IS_PATH_SEPAR(path[0]))
+ {
+ if (path[1] == 0)
+ {
+ DWORD attrib = GetFileAttrib(path);
+ if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+ {
+ ClearBase();
+ Name.Empty();
+ Attrib = attrib;
+ return true;
+ }
+ }
+ else
+ {
+ const unsigned prefixSize = GetNetworkServerPrefixSize(path);
+ if (prefixSize > 0 && path[prefixSize] != 0)
+ {
+ if (NName::FindSepar(path + prefixSize) < 0)
+ {
+ if (Fill_From_ByHandleFileInfo(path))
+ {
+ Name = path + prefixSize;
+ return true;
+ }
+
+ FString s (path);
+ s.Add_PathSepar();
+ s += '*'; // CHAR_ANY_MASK
+ bool isOK = false;
+ if (finder.FindFirst(s, *this))
+ {
+ if (Name == FTEXT("."))
+ {
+ Name = path + prefixSize;
+ return true;
+ }
+ isOK = true;
+ /* if "\\server\share" maps to root folder "d:\", there is no "." item.
+ But it's possible that there are another items */
+ }
+ {
+ DWORD attrib = GetFileAttrib(path);
+ if (isOK || (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0))
+ {
+ ClearBase();
+ if (attrib != INVALID_FILE_ATTRIBUTES)
+ Attrib = attrib;
+ else
+ SetAsDir();
+ Name = path + prefixSize;
+ return true;
+ }
+ }
+ // ::SetLastError(lastError);
+ }
+ }
+ }
+ }
+ }
+ #endif
+
+ bool res = finder.FindFirst(path, *this);
+ if (!followLink
+ || !res
+ || !HasReparsePoint())
+ return res;
+
+ // return FollowReparse(path, IsDir());
+ return Fill_From_ByHandleFileInfo(path);
+}
+
+bool CFileInfoBase::Fill_From_ByHandleFileInfo(CFSTR path)
+{
+ BY_HANDLE_FILE_INFORMATION info;
+ if (!NIO::CFileBase::GetFileInformation(path, &info))
+ return false;
+ {
+ Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+ CTime = info.ftCreationTime;
+ ATime = info.ftLastAccessTime;
+ MTime = info.ftLastWriteTime;
+ Attrib = info.dwFileAttributes;
+ return true;
+ }
+}
+
+/*
+bool CFileInfo::FollowReparse(CFSTR path, bool isDir)
+{
+ if (isDir)
+ {
+ FString prefix = path;
+ prefix.Add_PathSepar();
+
+ // "folder/." refers to folder itself. So we can't use that path
+ // we must use enumerator and search "." item
+ CEnumerator enumerator;
+ enumerator.SetDirPrefix(prefix);
+ for (;;)
+ {
+ CFileInfo fi;
+ if (!enumerator.NextAny(fi))
+ break;
+ if (fi.Name.IsEqualTo_Ascii_NoCase("."))
+ {
+ // we can copy preperies;
+ CTime = fi.CTime;
+ ATime = fi.ATime;
+ MTime = fi.MTime;
+ Attrib = fi.Attrib;
+ Size = fi.Size;
+ return true;
+ }
+ break;
+ }
+ // LastError(lastError);
+ return false;
+ }
+
+ {
+ NIO::CInFile inFile;
+ if (inFile.Open(path))
+ {
+ BY_HANDLE_FILE_INFORMATION info;
+ if (inFile.GetFileInformation(&info))
+ {
+ ClearBase();
+ Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+ CTime = info.ftCreationTime;
+ ATime = info.ftLastAccessTime;
+ MTime = info.ftLastWriteTime;
+ Attrib = info.dwFileAttributes;
+ return true;
+ }
+ }
+ return false;
+ }
+}
+*/
+
+bool DoesFileExist_Raw(CFSTR name)
+{
+ CFileInfo fi;
+ return fi.Find(name) && !fi.IsDir();
+}
+
+bool DoesFileExist_FollowLink(CFSTR name)
+{
+ CFileInfo fi;
+ return fi.Find_FollowLink(name) && !fi.IsDir();
+}
+
+bool DoesDirExist(CFSTR name, bool followLink)
+{
+ CFileInfo fi;
+ return fi.Find(name, followLink) && fi.IsDir();
+}
+
+bool DoesFileOrDirExist(CFSTR name)
+{
+ CFileInfo fi;
+ return fi.Find(name);
+}
+
+
+void CEnumerator::SetDirPrefix(const FString &dirPrefix)
+{
+ _wildcard = dirPrefix;
+ _wildcard += '*';
+}
+
+bool CEnumerator::NextAny(CFileInfo &fi)
+{
+ if (_findFile.IsHandleAllocated())
+ return _findFile.FindNext(fi);
+ else
+ return _findFile.FindFirst(_wildcard, fi);
+}
+
+bool CEnumerator::Next(CFileInfo &fi)
+{
+ for (;;)
+ {
+ if (!NextAny(fi))
+ return false;
+ if (!fi.IsDots())
+ return true;
+ }
+}
+
+bool CEnumerator::Next(CFileInfo &fi, bool &found)
+{
+ /*
+ for (;;)
+ {
+ if (!NextAny(fi))
+ break;
+ if (!fi.IsDots())
+ {
+ found = true;
+ return true;
+ }
+ }
+ */
+
+ if (Next(fi))
+ {
+ found = true;
+ return true;
+ }
+
+ found = false;
+ DWORD lastError = ::GetLastError();
+ if (_findFile.IsHandleAllocated())
+ return (lastError == ERROR_NO_MORE_FILES);
+ // we support the case for empty root folder: FindFirstFile("c:\\*") returns ERROR_FILE_NOT_FOUND
+ if (lastError == ERROR_FILE_NOT_FOUND)
+ return true;
+ if (lastError == ERROR_ACCESS_DENIED)
+ {
+ // here we show inaccessible root system folder as empty folder to eliminate redundant user warnings
+ const char *s = "System Volume Information" STRING_PATH_SEPARATOR "*";
+ const int len = (int)strlen(s);
+ const int delta = (int)_wildcard.Len() - len;
+ if (delta == 0 || (delta > 0 && IS_PATH_SEPAR(_wildcard[(unsigned)delta - 1])))
+ if (StringsAreEqual_Ascii(_wildcard.Ptr((unsigned)delta), s))
+ return true;
+ }
+ return false;
+}
+
+
+////////////////////////////////
+// CFindChangeNotification
+// FindFirstChangeNotification can return 0. MSDN doesn't tell about it.
+
+bool CFindChangeNotification::Close() throw()
+{
+ if (!IsHandleAllocated())
+ return true;
+ if (!::FindCloseChangeNotification(_handle))
+ return false;
+ _handle = INVALID_HANDLE_VALUE;
+ return true;
+}
+
+HANDLE CFindChangeNotification::FindFirst(CFSTR path, bool watchSubtree, DWORD notifyFilter)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ _handle = ::FindFirstChangeNotification(fs2fas(path), BoolToBOOL(watchSubtree), notifyFilter);
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ _handle = ::FindFirstChangeNotificationW(fs2us(path), BoolToBOOL(watchSubtree), notifyFilter);
+ #ifdef Z7_LONG_PATH
+ if (!IsHandleAllocated())
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ _handle = ::FindFirstChangeNotificationW(superPath, BoolToBOOL(watchSubtree), notifyFilter);
+ }
+ #endif
+ }
+ return _handle;
+}
+
+#ifndef UNDER_CE
+
+bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings)
+{
+ driveStrings.Clear();
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ driveStrings.Clear();
+ UINT32 size = GetLogicalDriveStrings(0, NULL);
+ if (size == 0)
+ return false;
+ CObjArray<char> buf(size);
+ UINT32 newSize = GetLogicalDriveStrings(size, buf);
+ if (newSize == 0 || newSize > size)
+ return false;
+ AString s;
+ UINT32 prev = 0;
+ for (UINT32 i = 0; i < newSize; i++)
+ {
+ if (buf[i] == 0)
+ {
+ s = buf + prev;
+ prev = i + 1;
+ driveStrings.Add(fas2fs(s));
+ }
+ }
+ return prev == newSize;
+ }
+ else
+ #endif
+ {
+ UINT32 size = GetLogicalDriveStringsW(0, NULL);
+ if (size == 0)
+ return false;
+ CObjArray<wchar_t> buf(size);
+ UINT32 newSize = GetLogicalDriveStringsW(size, buf);
+ if (newSize == 0 || newSize > size)
+ return false;
+ UString s;
+ UINT32 prev = 0;
+ for (UINT32 i = 0; i < newSize; i++)
+ {
+ if (buf[i] == 0)
+ {
+ s = buf + prev;
+ prev = i + 1;
+ driveStrings.Add(us2fs(s));
+ }
+ }
+ return prev == newSize;
+ }
+}
+
+#endif // UNDER_CE
+
+
+
+#else // _WIN32
+
+// ---------- POSIX ----------
+
+static int MY__lstat(CFSTR path, struct stat *st, bool followLink)
+{
+ memset(st, 0, sizeof(*st));
+ int res;
+ // #ifdef ENV_HAVE_LSTAT
+ if (/* global_use_lstat && */ !followLink)
+ {
+ // printf("\nlstat\n");
+ res = lstat(path, st);
+ }
+ else
+ // #endif
+ {
+ // printf("\nstat\n");
+ res = stat(path, st);
+ }
+ /*
+ printf("\nres = %d\n", res);
+ printf("\n st_dev = %lld \n", (long long)(st->st_dev));
+ printf("\n st_ino = %lld \n", (long long)(st->st_ino));
+ printf("\n st_mode = %lld \n", (long long)(st->st_mode));
+ printf("\n st_nlink = %lld \n", (long long)(st->st_nlink));
+ printf("\n st_uid = %lld \n", (long long)(st->st_uid));
+ printf("\n st_gid = %lld \n", (long long)(st->st_gid));
+ printf("\n st_size = %lld \n", (long long)(st->st_size));
+ printf("\n st_blksize = %lld \n", (long long)(st->st_blksize));
+ printf("\n st_blocks = %lld \n", (long long)(st->st_blocks));
+ */
+
+ return res;
+}
+
+
+static const char *Get_Name_from_Path(CFSTR path) throw()
+{
+ size_t len = strlen(path);
+ if (len == 0)
+ return path;
+ const char *p = path + len - 1;
+ {
+ if (p == path)
+ return path;
+ p--;
+ }
+ for (;;)
+ {
+ char c = *p;
+ if (IS_PATH_SEPAR(c))
+ return p + 1;
+ if (p == path)
+ return path;
+ p--;
+ }
+}
+
+
+UInt32 Get_WinAttribPosix_From_PosixMode(UInt32 mode)
+{
+ UInt32 attrib = S_ISDIR(mode) ?
+ FILE_ATTRIBUTE_DIRECTORY :
+ FILE_ATTRIBUTE_ARCHIVE;
+ if ((mode & 0222) == 0) // S_IWUSR in p7zip
+ attrib |= FILE_ATTRIBUTE_READONLY;
+ return attrib | FILE_ATTRIBUTE_UNIX_EXTENSION | ((mode & 0xFFFF) << 16);
+}
+
+/*
+UInt32 Get_WinAttrib_From_stat(const struct stat &st)
+{
+ UInt32 attrib = S_ISDIR(st.st_mode) ?
+ FILE_ATTRIBUTE_DIRECTORY :
+ FILE_ATTRIBUTE_ARCHIVE;
+
+ if ((st.st_mode & 0222) == 0) // check it !!!
+ attrib |= FILE_ATTRIBUTE_READONLY;
+
+ attrib |= FILE_ATTRIBUTE_UNIX_EXTENSION + ((st.st_mode & 0xFFFF) << 16);
+ return attrib;
+}
+*/
+
+void CFileInfo::SetFrom_stat(const struct stat &st)
+{
+ // IsDevice = false;
+
+ if (S_ISDIR(st.st_mode))
+ {
+ Size = 0;
+ }
+ else
+ {
+ Size = (UInt64)st.st_size; // for a symbolic link, size = size of filename
+ }
+
+ // Attrib = Get_WinAttribPosix_From_PosixMode(st.st_mode);
+
+ // NTime::UnixTimeToFileTime(st.st_ctime, CTime);
+ // NTime::UnixTimeToFileTime(st.st_mtime, MTime);
+ // NTime::UnixTimeToFileTime(st.st_atime, ATime);
+ #ifdef __APPLE__
+ // #ifdef _DARWIN_FEATURE_64_BIT_INODE
+ /*
+ here we can use birthtime instead of st_ctimespec.
+ but we use st_ctimespec for compatibility with previous versions and p7zip.
+ st_birthtimespec in OSX
+ st_birthtim : at FreeBSD, NetBSD
+ */
+ // timespec_To_FILETIME(st.st_birthtimespec, CTime);
+ // #else
+ // timespec_To_FILETIME(st.st_ctimespec, CTime);
+ // #endif
+ // timespec_To_FILETIME(st.st_mtimespec, MTime);
+ // timespec_To_FILETIME(st.st_atimespec, ATime);
+ CTime = st.st_ctimespec;
+ MTime = st.st_mtimespec;
+ ATime = st.st_atimespec;
+
+ #else
+ // timespec_To_FILETIME(st.st_ctim, CTime, &CTime_ns100);
+ // timespec_To_FILETIME(st.st_mtim, MTime, &MTime_ns100);
+ // timespec_To_FILETIME(st.st_atim, ATime, &ATime_ns100);
+ CTime = st.st_ctim;
+ MTime = st.st_mtim;
+ ATime = st.st_atim;
+
+ #endif
+
+ dev = st.st_dev;
+ ino = st.st_ino;
+ mode = st.st_mode;
+ nlink = st.st_nlink;
+ uid = st.st_uid;
+ gid = st.st_gid;
+ rdev = st.st_rdev;
+
+ /*
+ printf("\n sizeof timespec = %d", (int)sizeof(timespec));
+ printf("\n sizeof st_rdev = %d", (int)sizeof(rdev));
+ printf("\n sizeof st_ino = %d", (int)sizeof(ino));
+ printf("\n sizeof mode_t = %d", (int)sizeof(mode_t));
+ printf("\n sizeof nlink_t = %d", (int)sizeof(nlink_t));
+ printf("\n sizeof uid_t = %d", (int)sizeof(uid_t));
+ printf("\n");
+ */
+ /*
+ printf("\n st_rdev = %llx", (long long)rdev);
+ printf("\n st_dev = %llx", (long long)dev);
+ printf("\n dev : major = %5x minor = %5x", (unsigned)major(dev), (unsigned)minor(dev));
+ printf("\n st_ino = %lld", (long long)(ino));
+ printf("\n rdev : major = %5x minor = %5x", (unsigned)major(rdev), (unsigned)minor(rdev));
+ printf("\n size = %lld \n", (long long)(Size));
+ printf("\n");
+ */
+}
+
+/*
+int Uid_To_Uname(uid_t uid, AString &name)
+{
+ name.Empty();
+ struct passwd *passwd;
+
+ if (uid != 0 && uid == cached_no_such_uid)
+ {
+ *uname = xstrdup ("");
+ return;
+ }
+
+ if (!cached_uname || uid != cached_uid)
+ {
+ passwd = getpwuid (uid);
+ if (passwd)
+ {
+ cached_uid = uid;
+ assign_string (&cached_uname, passwd->pw_name);
+ }
+ else
+ {
+ cached_no_such_uid = uid;
+ *uname = xstrdup ("");
+ return;
+ }
+ }
+ *uname = xstrdup (cached_uname);
+}
+*/
+
+bool CFileInfo::Find_DontFill_Name(CFSTR path, bool followLink)
+{
+ struct stat st;
+ if (MY__lstat(path, &st, followLink) != 0)
+ return false;
+ // printf("\nFind_DontFill_Name : name=%s\n", path);
+ SetFrom_stat(st);
+ return true;
+}
+
+
+bool CFileInfo::Find(CFSTR path, bool followLink)
+{
+ // printf("\nCEnumerator::Find() name = %s\n", path);
+ if (!Find_DontFill_Name(path, followLink))
+ return false;
+
+ // printf("\nOK\n");
+
+ Name = Get_Name_from_Path(path);
+ if (!Name.IsEmpty())
+ {
+ char c = Name.Back();
+ if (IS_PATH_SEPAR(c))
+ Name.DeleteBack();
+ }
+ return true;
+}
+
+
+bool DoesFileExist_Raw(CFSTR name)
+{
+ // FIXME for symbolic links.
+ struct stat st;
+ if (MY__lstat(name, &st, false) != 0)
+ return false;
+ return !S_ISDIR(st.st_mode);
+}
+
+bool DoesFileExist_FollowLink(CFSTR name)
+{
+ // FIXME for symbolic links.
+ struct stat st;
+ if (MY__lstat(name, &st, true) != 0)
+ return false;
+ return !S_ISDIR(st.st_mode);
+}
+
+bool DoesDirExist(CFSTR name, bool followLink)
+{
+ struct stat st;
+ if (MY__lstat(name, &st, followLink) != 0)
+ return false;
+ return S_ISDIR(st.st_mode);
+}
+
+bool DoesFileOrDirExist(CFSTR name)
+{
+ struct stat st;
+ if (MY__lstat(name, &st, false) != 0)
+ return false;
+ return true;
+}
+
+
+CEnumerator::~CEnumerator()
+{
+ if (_dir)
+ closedir(_dir);
+}
+
+void CEnumerator::SetDirPrefix(const FString &dirPrefix)
+{
+ _wildcard = dirPrefix;
+}
+
+bool CDirEntry::IsDots() const throw()
+{
+ /* some systems (like CentOS 7.x on XFS) have (Type == DT_UNKNOWN)
+ we can call fstatat() for that case, but we use only (Name) check here */
+
+ #if !defined(_AIX)
+ if (Type != DT_DIR && Type != DT_UNKNOWN)
+ return false;
+ #endif
+
+ return Name.Len() != 0
+ && Name.Len() <= 2
+ && Name[0] == '.'
+ && (Name.Len() == 1 || Name[1] == '.');
+}
+
+
+bool CEnumerator::NextAny(CDirEntry &fi, bool &found)
+{
+ found = false;
+
+ if (!_dir)
+ {
+ const char *w = "./";
+ if (!_wildcard.IsEmpty())
+ w = _wildcard.Ptr();
+ _dir = ::opendir((const char *)w);
+ if (_dir == NULL)
+ return false;
+ }
+
+ // To distinguish end of stream from an error, we must set errno to zero before readdir()
+ errno = 0;
+
+ struct dirent *de = readdir(_dir);
+ if (!de)
+ {
+ if (errno == 0)
+ return true; // it's end of stream, and we report it with (found = false)
+ // it's real error
+ return false;
+ }
+
+ fi.iNode = de->d_ino;
+
+ #if !defined(_AIX)
+ fi.Type = de->d_type;
+ /* some systems (like CentOS 7.x on XFS) have (Type == DT_UNKNOWN)
+ we can set (Type) from fstatat() in that case.
+ But (Type) is not too important. So we don't set it here with slow fstatat() */
+ /*
+ // fi.Type = DT_UNKNOWN; // for debug
+ if (fi.Type == DT_UNKNOWN)
+ {
+ struct stat st;
+ if (fstatat(dirfd(_dir), de->d_name, &st, AT_SYMLINK_NOFOLLOW) == 0)
+ if (S_ISDIR(st.st_mode))
+ fi.Type = DT_DIR;
+ }
+ */
+ #endif
+
+ /*
+ if (de->d_type == DT_DIR)
+ fi.Attrib = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_UNIX_EXTENSION | ((UInt32)(S_IFDIR) << 16);
+ else if (de->d_type < 16)
+ fi.Attrib = FILE_ATTRIBUTE_UNIX_EXTENSION | ((UInt32)(de->d_type) << (16 + 12));
+ */
+ fi.Name = de->d_name;
+
+ /*
+ printf("\nCEnumerator::NextAny; len = %d %s \n", (int)fi.Name.Len(), fi.Name.Ptr());
+ for (unsigned i = 0; i < fi.Name.Len(); i++)
+ printf (" %02x", (unsigned)(Byte)de->d_name[i]);
+ printf("\n");
+ */
+
+ found = true;
+ return true;
+}
+
+
+bool CEnumerator::Next(CDirEntry &fi, bool &found)
+{
+ // printf("\nCEnumerator::Next()\n");
+ // PrintName("Next", "");
+ for (;;)
+ {
+ if (!NextAny(fi, found))
+ return false;
+ if (!found)
+ return true;
+ if (!fi.IsDots())
+ {
+ /*
+ if (!NeedFullStat)
+ return true;
+ // we silently skip error file here - it can be wrong link item
+ if (fi.Find_DontFill_Name(path))
+ return true;
+ */
+ return true;
+ }
+ }
+}
+
+/*
+bool CEnumerator::Next(CDirEntry &fileInfo, bool &found)
+{
+ bool found;
+ if (!Next(fi, found))
+ return false;
+ return found;
+}
+*/
+
+bool CEnumerator::Fill_FileInfo(const CDirEntry &de, CFileInfo &fileInfo, bool followLink) const
+{
+ // printf("\nCEnumerator::Fill_FileInfo()\n");
+ struct stat st;
+ // probably it's OK to use fstatat() even if it changes file position dirfd(_dir)
+ int res = fstatat(dirfd(_dir), de.Name, &st, followLink ? 0 : AT_SYMLINK_NOFOLLOW);
+ // if fstatat() is not supported, we can use stat() / lstat()
+
+ /*
+ const FString path = _wildcard + s;
+ int res = MY__lstat(path, &st, followLink);
+ */
+
+ if (res != 0)
+ return false;
+ // printf("\nname=%s\n", de.Name.Ptr());
+ fileInfo.SetFrom_stat(st);
+ fileInfo.Name = de.Name;
+ return true;
+}
+
+#endif // _WIN32
+
+}}}
diff --git a/CPP/Windows/FileFind.h b/CPP/Windows/FileFind.h
index 77d8dc3..11408d0 100644
--- a/CPP/Windows/FileFind.h
+++ b/CPP/Windows/FileFind.h
@@ -1,161 +1,348 @@
-// Windows/FileFind.h
-
-#ifndef __WINDOWS_FILE_FIND_H
-#define __WINDOWS_FILE_FIND_H
-
-#include "../Common/MyString.h"
-#include "Defs.h"
-
-namespace NWindows {
-namespace NFile {
-namespace NFind {
-
-namespace NAttributes
-{
- inline bool IsReadOnly(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_READONLY) != 0; }
- inline bool IsHidden(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_HIDDEN) != 0; }
- inline bool IsSystem(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_SYSTEM) != 0; }
- inline bool IsDir(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0; }
- inline bool IsArchived(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ARCHIVE) != 0; }
- inline bool IsCompressed(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_COMPRESSED) != 0; }
- inline bool IsEncrypted(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ENCRYPTED) != 0; }
-}
-
-class CFileInfoBase
-{
- bool MatchesMask(UINT32 mask) const { return ((Attrib & mask) != 0); }
-public:
- UInt64 Size;
- FILETIME CTime;
- FILETIME ATime;
- FILETIME MTime;
- DWORD Attrib;
- bool IsAltStream;
- bool IsDevice;
-
- /*
- #ifdef UNDER_CE
- DWORD ObjectID;
- #else
- UINT32 ReparseTag;
- #endif
- */
-
- CFileInfoBase() { ClearBase(); }
- void ClearBase() throw();
-
- void SetAsDir() { Attrib = FILE_ATTRIBUTE_DIRECTORY; }
-
- bool IsArchived() const { return MatchesMask(FILE_ATTRIBUTE_ARCHIVE); }
- bool IsCompressed() const { return MatchesMask(FILE_ATTRIBUTE_COMPRESSED); }
- bool IsDir() const { return MatchesMask(FILE_ATTRIBUTE_DIRECTORY); }
- bool IsEncrypted() const { return MatchesMask(FILE_ATTRIBUTE_ENCRYPTED); }
- bool IsHidden() const { return MatchesMask(FILE_ATTRIBUTE_HIDDEN); }
- bool IsNormal() const { return MatchesMask(FILE_ATTRIBUTE_NORMAL); }
- bool IsOffline() const { return MatchesMask(FILE_ATTRIBUTE_OFFLINE); }
- bool IsReadOnly() const { return MatchesMask(FILE_ATTRIBUTE_READONLY); }
- bool HasReparsePoint() const { return MatchesMask(FILE_ATTRIBUTE_REPARSE_POINT); }
- bool IsSparse() const { return MatchesMask(FILE_ATTRIBUTE_SPARSE_FILE); }
- bool IsSystem() const { return MatchesMask(FILE_ATTRIBUTE_SYSTEM); }
- bool IsTemporary() const { return MatchesMask(FILE_ATTRIBUTE_TEMPORARY); }
-};
-
-struct CFileInfo: public CFileInfoBase
-{
- FString Name;
- #if defined(_WIN32) && !defined(UNDER_CE)
- // FString ShortName;
- #endif
-
- bool IsDots() const throw();
- bool Find(CFSTR path);
-};
-
-class CFindFileBase
-{
-protected:
- HANDLE _handle;
-public:
- bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE; }
- CFindFileBase(): _handle(INVALID_HANDLE_VALUE) {}
- ~CFindFileBase() { Close(); }
- bool Close() throw();
-};
-
-class CFindFile: public CFindFileBase
-{
-public:
- bool FindFirst(CFSTR wildcard, CFileInfo &fileInfo);
- bool FindNext(CFileInfo &fileInfo);
-};
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-struct CStreamInfo
-{
- UString Name;
- UInt64 Size;
-
- UString GetReducedName() const; // returns ":Name"
- // UString GetReducedName2() const; // returns "Name"
- bool IsMainStream() const throw();
-};
-
-class CFindStream: public CFindFileBase
-{
-public:
- bool FindFirst(CFSTR filePath, CStreamInfo &streamInfo);
- bool FindNext(CStreamInfo &streamInfo);
-};
-
-class CStreamEnumerator
-{
- CFindStream _find;
- FString _filePath;
-
- bool NextAny(CFileInfo &fileInfo);
-public:
- CStreamEnumerator(const FString &filePath): _filePath(filePath) {}
- bool Next(CStreamInfo &streamInfo, bool &found);
-};
-
-#endif
-
-bool DoesFileExist(CFSTR name);
-bool DoesDirExist(CFSTR name);
-bool DoesFileOrDirExist(CFSTR name);
-
-DWORD GetFileAttrib(CFSTR path);
-
-class CEnumerator
-{
- CFindFile _findFile;
- FString _wildcard;
-
- bool NextAny(CFileInfo &fileInfo);
-public:
- void SetDirPrefix(const FString &dirPrefix);
- bool Next(CFileInfo &fileInfo);
- bool Next(CFileInfo &fileInfo, bool &found);
-};
-
-class CFindChangeNotification
-{
- HANDLE _handle;
-public:
- operator HANDLE () { return _handle; }
- bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE && _handle != 0; }
- CFindChangeNotification(): _handle(INVALID_HANDLE_VALUE) {}
- ~CFindChangeNotification() { Close(); }
- bool Close() throw();
- HANDLE FindFirst(CFSTR pathName, bool watchSubtree, DWORD notifyFilter);
- bool FindNext() { return BOOLToBool(::FindNextChangeNotification(_handle)); }
-};
-
-#ifndef UNDER_CE
-bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings);
-#endif
-
-}}}
-
-#endif
+// Windows/FileFind.h
+
+#ifndef ZIP7_INC_WINDOWS_FILE_FIND_H
+#define ZIP7_INC_WINDOWS_FILE_FIND_H
+
+#ifndef _WIN32
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#endif
+
+#include "../Common/MyLinux.h"
+#include "../Common/MyString.h"
+#include "../Common/MyWindows.h"
+
+#include "Defs.h"
+
+#include "FileIO.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NFind {
+
+// bool DoesFileExist(CFSTR name, bool followLink);
+bool DoesFileExist_Raw(CFSTR name);
+bool DoesFileExist_FollowLink(CFSTR name);
+bool DoesDirExist(CFSTR name, bool followLink);
+
+inline bool DoesDirExist(CFSTR name)
+ { return DoesDirExist(name, false); }
+inline bool DoesDirExist_FollowLink(CFSTR name)
+ { return DoesDirExist(name, true); }
+
+// it's always _Raw
+bool DoesFileOrDirExist(CFSTR name);
+
+DWORD GetFileAttrib(CFSTR path);
+
+#ifdef _WIN32
+
+namespace NAttributes
+{
+ inline bool IsReadOnly(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_READONLY) != 0; }
+ inline bool IsHidden(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_HIDDEN) != 0; }
+ inline bool IsSystem(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_SYSTEM) != 0; }
+ inline bool IsDir(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0; }
+ inline bool IsArchived(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ARCHIVE) != 0; }
+ inline bool IsCompressed(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_COMPRESSED) != 0; }
+ inline bool IsEncrypted(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ENCRYPTED) != 0; }
+
+ inline UInt32 Get_PosixMode_From_WinAttrib(DWORD attrib)
+ {
+ UInt32 v = IsDir(attrib) ? MY_LIN_S_IFDIR : MY_LIN_S_IFREG;
+ /* 21.06: as WSL we allow write permissions (0222) for directories even for (FILE_ATTRIBUTE_READONLY).
+ So extracting at Linux will be allowed to write files inside (0777) directories. */
+ v |= ((IsReadOnly(attrib) && !IsDir(attrib)) ? 0555 : 0777);
+ return v;
+ }
+}
+
+#else
+
+UInt32 Get_WinAttribPosix_From_PosixMode(UInt32 mode);
+
+#endif
+
+class CFileInfoBase
+{
+ #ifdef _WIN32
+ bool MatchesMask(UINT32 mask) const { return ((Attrib & mask) != 0); }
+ #endif
+public:
+ UInt64 Size;
+ CFiTime CTime;
+ CFiTime ATime;
+ CFiTime MTime;
+ #ifdef _WIN32
+ DWORD Attrib;
+ bool IsAltStream;
+ bool IsDevice;
+
+ /*
+ #ifdef UNDER_CE
+ DWORD ObjectID;
+ #else
+ UINT32 ReparseTag;
+ #endif
+ */
+ #else
+ dev_t dev; /* ID of device containing file */
+ ino_t ino;
+ mode_t mode;
+ nlink_t nlink;
+ uid_t uid; /* user ID of owner */
+ gid_t gid; /* group ID of owner */
+ dev_t rdev; /* device ID (defined, if S_ISCHR(mode) || S_ISBLK(mode)) */
+ // bool Use_lstat;
+ #endif
+
+ CFileInfoBase() { ClearBase(); }
+ void ClearBase() throw();
+
+ #ifdef _WIN32
+
+ bool Fill_From_ByHandleFileInfo(CFSTR path);
+ void SetAsDir() { Attrib = FILE_ATTRIBUTE_DIRECTORY; } // |= (FILE_ATTRIBUTE_UNIX_EXTENSION + (S_IFDIR << 16));
+ void SetAsFile() { Attrib = 0; }
+
+ bool IsArchived() const { return MatchesMask(FILE_ATTRIBUTE_ARCHIVE); }
+ bool IsCompressed() const { return MatchesMask(FILE_ATTRIBUTE_COMPRESSED); }
+ bool IsDir() const { return MatchesMask(FILE_ATTRIBUTE_DIRECTORY); }
+ bool IsEncrypted() const { return MatchesMask(FILE_ATTRIBUTE_ENCRYPTED); }
+ bool IsHidden() const { return MatchesMask(FILE_ATTRIBUTE_HIDDEN); }
+ bool IsNormal() const { return MatchesMask(FILE_ATTRIBUTE_NORMAL); }
+ bool IsOffline() const { return MatchesMask(FILE_ATTRIBUTE_OFFLINE); }
+ bool IsReadOnly() const { return MatchesMask(FILE_ATTRIBUTE_READONLY); }
+ bool HasReparsePoint() const { return MatchesMask(FILE_ATTRIBUTE_REPARSE_POINT); }
+ bool IsSparse() const { return MatchesMask(FILE_ATTRIBUTE_SPARSE_FILE); }
+ bool IsSystem() const { return MatchesMask(FILE_ATTRIBUTE_SYSTEM); }
+ bool IsTemporary() const { return MatchesMask(FILE_ATTRIBUTE_TEMPORARY); }
+
+ UInt32 GetWinAttrib() const { return Attrib; }
+ UInt32 GetPosixAttrib() const
+ {
+ return NAttributes::Get_PosixMode_From_WinAttrib(Attrib);
+ }
+ bool Has_Attrib_ReparsePoint() const { return (Attrib & FILE_ATTRIBUTE_REPARSE_POINT) != 0; }
+
+ #else
+
+ UInt32 GetPosixAttrib() const { return mode; }
+ UInt32 GetWinAttrib() const { return Get_WinAttribPosix_From_PosixMode(mode); }
+
+ bool IsDir() const { return S_ISDIR(mode); }
+ void SetAsDir() { mode = S_IFDIR; }
+ void SetAsFile() { mode = S_IFREG; }
+
+ bool IsReadOnly() const
+ {
+ // does linux support writing to ReadOnly files?
+ if ((mode & 0222) == 0) // S_IWUSR in p7zip
+ return true;
+ return false;
+ }
+
+ bool IsPosixLink() const { return S_ISLNK(mode); }
+
+ #endif
+
+ bool IsOsSymLink() const
+ {
+ #ifdef _WIN32
+ return HasReparsePoint();
+ #else
+ return IsPosixLink();
+ #endif
+ }
+};
+
+struct CFileInfo: public CFileInfoBase
+{
+ FString Name;
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ // FString ShortName;
+ #endif
+
+ bool IsDots() const throw();
+ bool Find(CFSTR path, bool followLink = false);
+ bool Find_FollowLink(CFSTR path) { return Find(path, true); }
+
+ #ifdef _WIN32
+ // bool Fill_From_ByHandleFileInfo(CFSTR path);
+ // bool FollowReparse(CFSTR path, bool isDir);
+ #else
+ bool Find_DontFill_Name(CFSTR path, bool followLink = false);
+ void SetFrom_stat(const struct stat &st);
+ #endif
+};
+
+
+#ifdef _WIN32
+
+class CFindFileBase MY_UNCOPYABLE
+{
+protected:
+ HANDLE _handle;
+public:
+ bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE; }
+ CFindFileBase(): _handle(INVALID_HANDLE_VALUE) {}
+ ~CFindFileBase() { Close(); }
+ bool Close() throw();
+};
+
+class CFindFile: public CFindFileBase
+{
+public:
+ bool FindFirst(CFSTR wildcard, CFileInfo &fileInfo);
+ bool FindNext(CFileInfo &fileInfo);
+};
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+struct CStreamInfo
+{
+ UString Name;
+ UInt64 Size;
+
+ UString GetReducedName() const; // returns ":Name"
+ // UString GetReducedName2() const; // returns "Name"
+ bool IsMainStream() const throw();
+};
+
+class CFindStream: public CFindFileBase
+{
+public:
+ bool FindFirst(CFSTR filePath, CStreamInfo &streamInfo);
+ bool FindNext(CStreamInfo &streamInfo);
+};
+
+class CStreamEnumerator MY_UNCOPYABLE
+{
+ CFindStream _find;
+ FString _filePath;
+
+ bool NextAny(CFileInfo &fileInfo, bool &found);
+public:
+ CStreamEnumerator(const FString &filePath): _filePath(filePath) {}
+ bool Next(CStreamInfo &streamInfo, bool &found);
+};
+
+#endif // defined(_WIN32) && !defined(UNDER_CE)
+
+
+class CEnumerator MY_UNCOPYABLE
+{
+ CFindFile _findFile;
+ FString _wildcard;
+
+ bool NextAny(CFileInfo &fileInfo);
+public:
+ void SetDirPrefix(const FString &dirPrefix);
+ bool Next(CFileInfo &fileInfo);
+ bool Next(CFileInfo &fileInfo, bool &found);
+};
+
+
+class CFindChangeNotification MY_UNCOPYABLE
+{
+ HANDLE _handle;
+public:
+ operator HANDLE () { return _handle; }
+ bool IsHandleAllocated() const
+ {
+ /* at least on win2000/XP (undocumented):
+ if pathName is "" or NULL,
+ FindFirstChangeNotification() could return NULL.
+ So we check for INVALID_HANDLE_VALUE and NULL.
+ */
+ return _handle != INVALID_HANDLE_VALUE && _handle != NULL;
+ }
+ CFindChangeNotification(): _handle(INVALID_HANDLE_VALUE) {}
+ ~CFindChangeNotification() { Close(); }
+ bool Close() throw();
+ HANDLE FindFirst(CFSTR pathName, bool watchSubtree, DWORD notifyFilter);
+ bool FindNext() { return BOOLToBool(::FindNextChangeNotification(_handle)); }
+};
+
+#ifndef UNDER_CE
+bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings);
+#endif
+
+typedef CFileInfo CDirEntry;
+
+
+#else // WIN32
+
+
+struct CDirEntry
+{
+ ino_t iNode;
+ #if !defined(_AIX)
+ Byte Type;
+ #endif
+ FString Name;
+
+ /*
+ #if !defined(_AIX)
+ bool IsDir() const
+ {
+ // (Type == DT_UNKNOWN) on some systems
+ return Type == DT_DIR;
+ }
+ #endif
+ */
+
+ bool IsDots() const throw();
+};
+
+class CEnumerator MY_UNCOPYABLE
+{
+ DIR *_dir;
+ FString _wildcard;
+
+ bool NextAny(CDirEntry &fileInfo, bool &found);
+public:
+ CEnumerator(): _dir(NULL) {}
+ ~CEnumerator();
+ void SetDirPrefix(const FString &dirPrefix);
+
+ bool Next(CDirEntry &fileInfo, bool &found);
+ bool Fill_FileInfo(const CDirEntry &de, CFileInfo &fileInfo, bool followLink) const;
+ bool DirEntry_IsDir(const CDirEntry &de, bool followLink) const
+ {
+ #if !defined(_AIX)
+ if (de.Type == DT_DIR)
+ return true;
+ if (de.Type != DT_UNKNOWN)
+ return false;
+ #endif
+ CFileInfo fileInfo;
+ if (Fill_FileInfo(de, fileInfo, followLink))
+ {
+ return fileInfo.IsDir();
+ }
+ return false; // change it
+ }
+};
+
+/*
+inline UInt32 Get_WinAttrib_From_PosixMode(UInt32 mode)
+{
+ UInt32 attrib = S_ISDIR(mode) ?
+ FILE_ATTRIBUTE_DIRECTORY :
+ FILE_ATTRIBUTE_ARCHIVE;
+ if ((st.st_mode & 0222) == 0) // check it !!!
+ attrib |= FILE_ATTRIBUTE_READONLY;
+ return attrib;
+}
+*/
+
+// UInt32 Get_WinAttrib_From_stat(const struct stat &st);
+
+
+#endif // WIN32
+
+}}}
+
+#endif
diff --git a/CPP/Windows/FileIO.cpp b/CPP/Windows/FileIO.cpp
index a1d52c0..4ecbb7e 100644
--- a/CPP/Windows/FileIO.cpp
+++ b/CPP/Windows/FileIO.cpp
@@ -1,432 +1,905 @@
-// Windows/FileIO.cpp
-
-#include "StdAfx.h"
-
-#ifdef SUPPORT_DEVICE_FILE
-#include "../../C/Alloc.h"
-#endif
-
-#include "FileIO.h"
-#include "FileName.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-using namespace NWindows;
-using namespace NFile;
-using namespace NName;
-
-namespace NWindows {
-namespace NFile {
-
-#ifdef SUPPORT_DEVICE_FILE
-
-namespace NSystem
-{
-bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
-}
-#endif
-
-namespace NIO {
-
-/*
-WinXP-64 CreateFile():
- "" - ERROR_PATH_NOT_FOUND
- :stream - OK
- .:stream - ERROR_PATH_NOT_FOUND
- .\:stream - OK
-
- folder\:stream - ERROR_INVALID_NAME
- folder:stream - OK
-
- c:\:stream - OK
-
- c::stream - ERROR_INVALID_NAME, if current dir is NOT ROOT ( c:\dir1 )
- c::stream - OK, if current dir is ROOT ( c:\ )
-*/
-
-bool CFileBase::Create(CFSTR path, DWORD desiredAccess,
- DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
-{
- if (!Close())
- return false;
-
- #ifdef SUPPORT_DEVICE_FILE
- IsDeviceFile = false;
- #endif
-
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- _handle = ::CreateFile(fs2fas(path), desiredAccess, shareMode,
- (LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
- }
- else
- #endif
- {
- IF_USE_MAIN_PATH
- _handle = ::CreateFileW(fs2us(path), desiredAccess, shareMode,
- (LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
- #ifdef WIN_LONG_PATH
- if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
- {
- UString superPath;
- if (GetSuperPath(path, superPath, USE_MAIN_PATH))
- _handle = ::CreateFileW(superPath, desiredAccess, shareMode,
- (LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
- }
- #endif
- }
- return (_handle != INVALID_HANDLE_VALUE);
-}
-
-bool CFileBase::Close() throw()
-{
- if (_handle == INVALID_HANDLE_VALUE)
- return true;
- if (!::CloseHandle(_handle))
- return false;
- _handle = INVALID_HANDLE_VALUE;
- return true;
-}
-
-bool CFileBase::GetPosition(UInt64 &position) const throw()
-{
- return Seek(0, FILE_CURRENT, position);
-}
-
-bool CFileBase::GetLength(UInt64 &length) const throw()
-{
- #ifdef SUPPORT_DEVICE_FILE
- if (IsDeviceFile && SizeDefined)
- {
- length = Size;
- return true;
- }
- #endif
-
- DWORD sizeHigh;
- DWORD sizeLow = ::GetFileSize(_handle, &sizeHigh);
- if (sizeLow == 0xFFFFFFFF)
- if (::GetLastError() != NO_ERROR)
- return false;
- length = (((UInt64)sizeHigh) << 32) + sizeLow;
- return true;
-}
-
-bool CFileBase::Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw()
-{
- #ifdef SUPPORT_DEVICE_FILE
- if (IsDeviceFile && SizeDefined && moveMethod == FILE_END)
- {
- distanceToMove += Size;
- moveMethod = FILE_BEGIN;
- }
- #endif
-
- LONG high = (LONG)(distanceToMove >> 32);
- DWORD low = ::SetFilePointer(_handle, (LONG)(distanceToMove & 0xFFFFFFFF), &high, moveMethod);
- if (low == 0xFFFFFFFF)
- if (::GetLastError() != NO_ERROR)
- return false;
- newPosition = (((UInt64)(UInt32)high) << 32) + low;
- return true;
-}
-
-bool CFileBase::Seek(UInt64 position, UInt64 &newPosition) const throw()
-{
- return Seek(position, FILE_BEGIN, newPosition);
-}
-
-bool CFileBase::SeekToBegin() const throw()
-{
- UInt64 newPosition;
- return Seek(0, newPosition);
-}
-
-bool CFileBase::SeekToEnd(UInt64 &newPosition) const throw()
-{
- return Seek(0, FILE_END, newPosition);
-}
-
-// ---------- CInFile ---------
-
-#ifdef SUPPORT_DEVICE_FILE
-
-void CInFile::CorrectDeviceSize()
-{
- // maybe we must decrease kClusterSize to 1 << 12, if we want correct size at tail
- static const UInt32 kClusterSize = 1 << 14;
- UInt64 pos = Size & ~(UInt64)(kClusterSize - 1);
- UInt64 realNewPosition;
- if (!Seek(pos, realNewPosition))
- return;
- Byte *buf = (Byte *)MidAlloc(kClusterSize);
-
- bool needbackward = true;
-
- for (;;)
- {
- UInt32 processed = 0;
- // up test is slow for "PhysicalDrive".
- // processed size for latest block for "PhysicalDrive0" is 0.
- if (!Read1(buf, kClusterSize, processed))
- break;
- if (processed == 0)
- break;
- needbackward = false;
- Size = pos + processed;
- if (processed != kClusterSize)
- break;
- pos += kClusterSize;
- }
-
- if (needbackward && pos != 0)
- {
- pos -= kClusterSize;
- for (;;)
- {
- // break;
- if (!Seek(pos, realNewPosition))
- break;
- if (!buf)
- {
- buf = (Byte *)MidAlloc(kClusterSize);
- if (!buf)
- break;
- }
- UInt32 processed = 0;
- // that code doesn't work for "PhysicalDrive0"
- if (!Read1(buf, kClusterSize, processed))
- break;
- if (processed != 0)
- {
- Size = pos + processed;
- break;
- }
- if (pos == 0)
- break;
- pos -= kClusterSize;
- }
- }
- MidFree(buf);
-}
-
-
-void CInFile::CalcDeviceSize(CFSTR s)
-{
- SizeDefined = false;
- Size = 0;
- if (_handle == INVALID_HANDLE_VALUE || !IsDeviceFile)
- return;
- #ifdef UNDER_CE
-
- SizeDefined = true;
- Size = 128 << 20;
-
- #else
-
- PARTITION_INFORMATION partInfo;
- bool needCorrectSize = true;
-
- /*
- WinXP 64-bit:
-
- HDD \\.\PhysicalDrive0 (MBR):
- GetPartitionInfo == GeometryEx : corrrect size? (includes tail)
- Geometry : smaller than GeometryEx (no tail, maybe correct too?)
- MyGetDiskFreeSpace : FAIL
- Size correction is slow and block size (kClusterSize) must be small?
-
- HDD partition \\.\N: (NTFS):
- MyGetDiskFreeSpace : Size of NTFS clusters. Same size can be calculated after correction
- GetPartitionInfo : size of partition data: NTFS clusters + TAIL; TAIL contains extra empty sectors and copy of first sector of NTFS
- Geometry / CdRomGeometry / GeometryEx : size of HDD (not that partition)
-
- CD-ROM drive (ISO):
- MyGetDiskFreeSpace : correct size. Same size can be calculated after correction
- Geometry == CdRomGeometry : smaller than corrrect size
- GetPartitionInfo == GeometryEx : larger than corrrect size
-
- Floppy \\.\a: (FAT):
- Geometry : correct size.
- CdRomGeometry / GeometryEx / GetPartitionInfo / MyGetDiskFreeSpace - FAIL
- correction works OK for FAT.
- correction works OK for non-FAT, if kClusterSize = 512.
- */
-
- if (GetPartitionInfo(&partInfo))
- {
- Size = partInfo.PartitionLength.QuadPart;
- SizeDefined = true;
- needCorrectSize = false;
- if ((s)[0] == '\\' && (s)[1] == '\\' && (s)[2] == '.' && (s)[3] == '\\' && (s)[5] == ':' && (s)[6] == 0)
- {
- FChar path[4] = { s[4], ':', '\\', 0 };
- UInt64 clusterSize, totalSize, freeSize;
- if (NSystem::MyGetDiskFreeSpace(path, clusterSize, totalSize, freeSize))
- Size = totalSize;
- else
- needCorrectSize = true;
- }
- }
-
- if (!SizeDefined)
- {
- my_DISK_GEOMETRY_EX geomEx;
- SizeDefined = GetGeometryEx(&geomEx);
- if (SizeDefined)
- Size = geomEx.DiskSize.QuadPart;
- else
- {
- DISK_GEOMETRY geom;
- SizeDefined = GetGeometry(&geom);
- if (!SizeDefined)
- SizeDefined = GetCdRomGeometry(&geom);
- if (SizeDefined)
- Size = geom.Cylinders.QuadPart * geom.TracksPerCylinder * geom.SectorsPerTrack * geom.BytesPerSector;
- }
- }
-
- if (needCorrectSize && SizeDefined && Size != 0)
- {
- CorrectDeviceSize();
- SeekToBegin();
- }
-
- // SeekToBegin();
- #endif
-}
-
-// ((desiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)) == 0 &&
-
-#define MY_DEVICE_EXTRA_CODE \
- IsDeviceFile = IsDevicePath(fileName); \
- CalcDeviceSize(fileName);
-#else
-#define MY_DEVICE_EXTRA_CODE
-#endif
-
-bool CInFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
-{
- bool res = Create(fileName, GENERIC_READ, shareMode, creationDisposition, flagsAndAttributes);
- MY_DEVICE_EXTRA_CODE
- return res;
-}
-
-bool CInFile::OpenShared(CFSTR fileName, bool shareForWrite)
-{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
-
-bool CInFile::Open(CFSTR fileName)
- { return OpenShared(fileName, false); }
-
-// 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"
-
-static UInt32 kChunkSizeMax = (1 << 22);
-
-bool CInFile::Read1(void *data, UInt32 size, UInt32 &processedSize) throw()
-{
- DWORD processedLoc = 0;
- bool res = BOOLToBool(::ReadFile(_handle, data, size, &processedLoc, NULL));
- processedSize = (UInt32)processedLoc;
- return res;
-}
-
-bool CInFile::ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw()
-{
- if (size > kChunkSizeMax)
- size = kChunkSizeMax;
- return Read1(data, size, processedSize);
-}
-
-bool CInFile::Read(void *data, UInt32 size, UInt32 &processedSize) throw()
-{
- processedSize = 0;
- do
- {
- UInt32 processedLoc = 0;
- bool res = ReadPart(data, size, processedLoc);
- processedSize += processedLoc;
- if (!res)
- return false;
- if (processedLoc == 0)
- return true;
- data = (void *)((unsigned char *)data + processedLoc);
- size -= processedLoc;
- }
- while (size > 0);
- return true;
-}
-
-// ---------- COutFile ---------
-
-static inline DWORD GetCreationDisposition(bool createAlways)
- { return createAlways? CREATE_ALWAYS: CREATE_NEW; }
-
-bool COutFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
- { return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }
-
-bool COutFile::Open(CFSTR fileName, DWORD creationDisposition)
- { return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
-
-bool COutFile::Create(CFSTR fileName, bool createAlways)
- { return Open(fileName, GetCreationDisposition(createAlways)); }
-
-bool COutFile::CreateAlways(CFSTR fileName, DWORD flagsAndAttributes)
- { return Open(fileName, FILE_SHARE_READ, GetCreationDisposition(true), flagsAndAttributes); }
-
-bool COutFile::SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw()
- { return BOOLToBool(::SetFileTime(_handle, cTime, aTime, mTime)); }
-
-bool COutFile::SetMTime(const FILETIME *mTime) throw() { return SetTime(NULL, NULL, mTime); }
-
-bool COutFile::WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw()
-{
- if (size > kChunkSizeMax)
- size = kChunkSizeMax;
- DWORD processedLoc = 0;
- bool res = BOOLToBool(::WriteFile(_handle, data, size, &processedLoc, NULL));
- processedSize = (UInt32)processedLoc;
- return res;
-}
-
-bool COutFile::Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
-{
- processedSize = 0;
- do
- {
- UInt32 processedLoc = 0;
- bool res = WritePart(data, size, processedLoc);
- processedSize += processedLoc;
- if (!res)
- return false;
- if (processedLoc == 0)
- return true;
- data = (const void *)((const unsigned char *)data + processedLoc);
- size -= processedLoc;
- }
- while (size > 0);
- return true;
-}
-
-bool COutFile::SetEndOfFile() throw() { return BOOLToBool(::SetEndOfFile(_handle)); }
-
-bool COutFile::SetLength(UInt64 length) throw()
-{
- UInt64 newPosition;
- if (!Seek(length, newPosition))
- return false;
- if (newPosition != length)
- return false;
- return SetEndOfFile();
-}
-
-}}}
+// Windows/FileIO.cpp
+
+#include "StdAfx.h"
+
+#ifdef Z7_DEVICE_FILE
+#include "../../C/Alloc.h"
+#endif
+
+// #include <stdio.h>
+
+/*
+#ifndef _WIN32
+// for ioctl BLKGETSIZE64
+#include <sys/ioctl.h>
+#include <linux/fs.h>
+#endif
+*/
+
+#include "FileIO.h"
+#include "FileName.h"
+
+HRESULT GetLastError_noZero_HRESULT()
+{
+ const DWORD res = ::GetLastError();
+ if (res == 0)
+ return E_FAIL;
+ return HRESULT_FROM_WIN32(res);
+}
+
+#ifdef _WIN32
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+namespace NWindows {
+namespace NFile {
+
+#ifdef Z7_DEVICE_FILE
+
+namespace NSystem
+{
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
+}
+#endif
+
+namespace NIO {
+
+/*
+WinXP-64 CreateFile():
+ "" - ERROR_PATH_NOT_FOUND
+ :stream - OK
+ .:stream - ERROR_PATH_NOT_FOUND
+ .\:stream - OK
+
+ folder\:stream - ERROR_INVALID_NAME
+ folder:stream - OK
+
+ c:\:stream - OK
+
+ c::stream - ERROR_INVALID_NAME, if current dir is NOT ROOT ( c:\dir1 )
+ c::stream - OK, if current dir is ROOT ( c:\ )
+*/
+
+bool CFileBase::Create(CFSTR path, DWORD desiredAccess,
+ DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
+{
+ if (!Close())
+ return false;
+
+ #ifdef Z7_DEVICE_FILE
+ IsDeviceFile = false;
+ #endif
+
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ _handle = ::CreateFile(fs2fas(path), desiredAccess, shareMode,
+ (LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
+ }
+ else
+ #endif
+ {
+ IF_USE_MAIN_PATH
+ _handle = ::CreateFileW(fs2us(path), desiredAccess, shareMode,
+ (LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
+ #ifdef Z7_LONG_PATH
+ if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
+ {
+ UString superPath;
+ if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+ _handle = ::CreateFileW(superPath, desiredAccess, shareMode,
+ (LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
+ }
+ #endif
+ }
+
+ /*
+ #ifndef UNDER_CE
+ #ifndef Z7_SFX
+ if (_handle == INVALID_HANDLE_VALUE)
+ {
+ // it's debug hack to open symbolic links in Windows XP and WSL links in Windows 10
+ DWORD lastError = GetLastError();
+ if (lastError == ERROR_CANT_ACCESS_FILE)
+ {
+ CByteBuffer buf;
+ if (NIO::GetReparseData(path, buf, NULL))
+ {
+ CReparseAttr attr;
+ if (attr.Parse(buf, buf.Size()))
+ {
+ FString dirPrefix, fileName;
+ if (NDir::GetFullPathAndSplit(path, dirPrefix, fileName))
+ {
+ FString fullPath;
+ if (GetFullPath(dirPrefix, us2fs(attr.GetPath()), fullPath))
+ {
+ // FIX IT: recursion levels must be restricted
+ return Create(fullPath, desiredAccess,
+ shareMode, creationDisposition, flagsAndAttributes);
+ }
+ }
+ }
+ }
+ SetLastError(lastError);
+ }
+ }
+ #endif
+ #endif
+ */
+
+ return (_handle != INVALID_HANDLE_VALUE);
+}
+
+bool CFileBase::Close() throw()
+{
+ if (_handle == INVALID_HANDLE_VALUE)
+ return true;
+ if (!::CloseHandle(_handle))
+ return false;
+ _handle = INVALID_HANDLE_VALUE;
+ return true;
+}
+
+bool CFileBase::GetLength(UInt64 &length) const throw()
+{
+ #ifdef Z7_DEVICE_FILE
+ if (IsDeviceFile && SizeDefined)
+ {
+ length = Size;
+ return true;
+ }
+ #endif
+
+ DWORD high = 0;
+ const DWORD low = ::GetFileSize(_handle, &high);
+ if (low == INVALID_FILE_SIZE)
+ if (::GetLastError() != NO_ERROR)
+ return false;
+ length = (((UInt64)high) << 32) + low;
+ return true;
+
+ /*
+ LARGE_INTEGER fileSize;
+ // GetFileSizeEx() is unsupported in 98/ME/NT, and supported in Win2000+
+ if (!GetFileSizeEx(_handle, &fileSize))
+ return false;
+ length = (UInt64)fileSize.QuadPart;
+ return true;
+ */
+}
+
+
+/* Specification for SetFilePointer():
+
+ If a new file pointer is a negative value,
+ {
+ the function fails,
+ the file pointer is not moved,
+ the code returned by GetLastError() is ERROR_NEGATIVE_SEEK.
+ }
+
+ If the hFile handle is opened with the FILE_FLAG_NO_BUFFERING flag set
+ {
+ an application can move the file pointer only to sector-aligned positions.
+ A sector-aligned position is a position that is a whole number multiple of
+ the volume sector size.
+ An application can obtain a volume sector size by calling the GetDiskFreeSpace.
+ }
+
+ It is not an error to set a file pointer to a position beyond the end of the file.
+ The size of the file does not increase until you call the SetEndOfFile, WriteFile, or WriteFileEx function.
+
+ If the return value is INVALID_SET_FILE_POINTER and if lpDistanceToMoveHigh is non-NULL,
+ an application must call GetLastError to determine whether or not the function has succeeded or failed.
+*/
+
+bool CFileBase::GetPosition(UInt64 &position) const throw()
+{
+ LONG high = 0;
+ const DWORD low = ::SetFilePointer(_handle, 0, &high, FILE_CURRENT);
+ if (low == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+ {
+ // for error case we can set (position) to (-1) or (0) or leave (position) unchanged.
+ // position = (UInt64)(Int64)-1; // for debug
+ position = 0;
+ return false;
+ }
+ position = (((UInt64)(UInt32)high) << 32) + low;
+ return true;
+ // we don't want recursed GetPosition()
+ // return Seek(0, FILE_CURRENT, position);
+}
+
+bool CFileBase::Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw()
+{
+ #ifdef Z7_DEVICE_FILE
+ if (IsDeviceFile && SizeDefined && moveMethod == FILE_END)
+ {
+ distanceToMove += Size;
+ moveMethod = FILE_BEGIN;
+ }
+ #endif
+
+ LONG high = (LONG)(distanceToMove >> 32);
+ const DWORD low = ::SetFilePointer(_handle, (LONG)(distanceToMove & 0xFFFFFFFF), &high, moveMethod);
+ if (low == INVALID_SET_FILE_POINTER)
+ {
+ const DWORD lastError = ::GetLastError();
+ if (lastError != NO_ERROR)
+ {
+ // 21.07: we set (newPosition) to real position even after error.
+ GetPosition(newPosition);
+ SetLastError(lastError); // restore LastError
+ return false;
+ }
+ }
+ newPosition = (((UInt64)(UInt32)high) << 32) + low;
+ return true;
+}
+
+bool CFileBase::Seek(UInt64 position, UInt64 &newPosition) const throw()
+{
+ return Seek((Int64)position, FILE_BEGIN, newPosition);
+}
+
+bool CFileBase::SeekToBegin() const throw()
+{
+ UInt64 newPosition = 0;
+ return Seek(0, newPosition) && (newPosition == 0);
+}
+
+bool CFileBase::SeekToEnd(UInt64 &newPosition) const throw()
+{
+ return Seek(0, FILE_END, newPosition);
+}
+
+// ---------- CInFile ---------
+
+#ifdef Z7_DEVICE_FILE
+
+void CInFile::CorrectDeviceSize()
+{
+ // maybe we must decrease kClusterSize to 1 << 12, if we want correct size at tail
+ const UInt32 kClusterSize = 1 << 14;
+ UInt64 pos = Size & ~(UInt64)(kClusterSize - 1);
+ UInt64 realNewPosition;
+ if (!Seek(pos, realNewPosition))
+ return;
+ Byte *buf = (Byte *)MidAlloc(kClusterSize);
+
+ bool needbackward = true;
+
+ for (;;)
+ {
+ UInt32 processed = 0;
+ // up test is slow for "PhysicalDrive".
+ // processed size for latest block for "PhysicalDrive0" is 0.
+ if (!Read1(buf, kClusterSize, processed))
+ break;
+ if (processed == 0)
+ break;
+ needbackward = false;
+ Size = pos + processed;
+ if (processed != kClusterSize)
+ break;
+ pos += kClusterSize;
+ }
+
+ if (needbackward && pos != 0)
+ {
+ pos -= kClusterSize;
+ for (;;)
+ {
+ // break;
+ if (!Seek(pos, realNewPosition))
+ break;
+ if (!buf)
+ {
+ buf = (Byte *)MidAlloc(kClusterSize);
+ if (!buf)
+ break;
+ }
+ UInt32 processed = 0;
+ // that code doesn't work for "PhysicalDrive0"
+ if (!Read1(buf, kClusterSize, processed))
+ break;
+ if (processed != 0)
+ {
+ Size = pos + processed;
+ break;
+ }
+ if (pos == 0)
+ break;
+ pos -= kClusterSize;
+ }
+ }
+ MidFree(buf);
+}
+
+
+void CInFile::CalcDeviceSize(CFSTR s)
+{
+ SizeDefined = false;
+ Size = 0;
+ if (_handle == INVALID_HANDLE_VALUE || !IsDeviceFile)
+ return;
+ #ifdef UNDER_CE
+
+ SizeDefined = true;
+ Size = 128 << 20;
+
+ #else
+
+ PARTITION_INFORMATION partInfo;
+ bool needCorrectSize = true;
+
+ /*
+ WinXP 64-bit:
+
+ HDD \\.\PhysicalDrive0 (MBR):
+ GetPartitionInfo == GeometryEx : corrrect size? (includes tail)
+ Geometry : smaller than GeometryEx (no tail, maybe correct too?)
+ MyGetDiskFreeSpace : FAIL
+ Size correction is slow and block size (kClusterSize) must be small?
+
+ HDD partition \\.\N: (NTFS):
+ MyGetDiskFreeSpace : Size of NTFS clusters. Same size can be calculated after correction
+ GetPartitionInfo : size of partition data: NTFS clusters + TAIL; TAIL contains extra empty sectors and copy of first sector of NTFS
+ Geometry / CdRomGeometry / GeometryEx : size of HDD (not that partition)
+
+ CD-ROM drive (ISO):
+ MyGetDiskFreeSpace : correct size. Same size can be calculated after correction
+ Geometry == CdRomGeometry : smaller than corrrect size
+ GetPartitionInfo == GeometryEx : larger than corrrect size
+
+ Floppy \\.\a: (FAT):
+ Geometry : correct size.
+ CdRomGeometry / GeometryEx / GetPartitionInfo / MyGetDiskFreeSpace - FAIL
+ correction works OK for FAT.
+ correction works OK for non-FAT, if kClusterSize = 512.
+ */
+
+ if (GetPartitionInfo(&partInfo))
+ {
+ Size = (UInt64)partInfo.PartitionLength.QuadPart;
+ SizeDefined = true;
+ needCorrectSize = false;
+ if ((s)[0] == '\\' && (s)[1] == '\\' && (s)[2] == '.' && (s)[3] == '\\' && (s)[5] == ':' && (s)[6] == 0)
+ {
+ FChar path[4] = { s[4], ':', '\\', 0 };
+ UInt64 clusterSize, totalSize, freeSize;
+ if (NSystem::MyGetDiskFreeSpace(path, clusterSize, totalSize, freeSize))
+ Size = totalSize;
+ else
+ needCorrectSize = true;
+ }
+ }
+
+ if (!SizeDefined)
+ {
+ my_DISK_GEOMETRY_EX geomEx;
+ SizeDefined = GetGeometryEx(&geomEx);
+ if (SizeDefined)
+ Size = (UInt64)geomEx.DiskSize.QuadPart;
+ else
+ {
+ DISK_GEOMETRY geom;
+ SizeDefined = GetGeometry(&geom);
+ if (!SizeDefined)
+ SizeDefined = GetCdRomGeometry(&geom);
+ if (SizeDefined)
+ Size = (UInt64)geom.Cylinders.QuadPart * geom.TracksPerCylinder * geom.SectorsPerTrack * geom.BytesPerSector;
+ }
+ }
+
+ if (needCorrectSize && SizeDefined && Size != 0)
+ {
+ CorrectDeviceSize();
+ SeekToBegin();
+ }
+
+ // SeekToBegin();
+ #endif
+}
+
+// ((desiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)) == 0 &&
+
+#define MY_DEVICE_EXTRA_CODE \
+ IsDeviceFile = IsDevicePath(fileName); \
+ CalcDeviceSize(fileName);
+#else
+#define MY_DEVICE_EXTRA_CODE
+#endif
+
+bool CInFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
+{
+ DWORD desiredAccess = GENERIC_READ;
+
+ #ifdef _WIN32
+ if (PreserveATime)
+ desiredAccess |= FILE_WRITE_ATTRIBUTES;
+ #endif
+
+ bool res = Create(fileName, desiredAccess, shareMode, creationDisposition, flagsAndAttributes);
+
+ #ifdef _WIN32
+ if (res && PreserveATime)
+ {
+ FILETIME ft;
+ ft.dwHighDateTime = ft.dwLowDateTime = 0xFFFFFFFF;
+ ::SetFileTime(_handle, NULL, &ft, NULL);
+ }
+ #endif
+
+ MY_DEVICE_EXTRA_CODE
+ return res;
+}
+
+bool CInFile::OpenShared(CFSTR fileName, bool shareForWrite)
+{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
+
+bool CInFile::Open(CFSTR fileName)
+ { return OpenShared(fileName, false); }
+
+// 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"
+
+static const UInt32 kChunkSizeMax = (1 << 22);
+
+bool CInFile::Read1(void *data, UInt32 size, UInt32 &processedSize) throw()
+{
+ DWORD processedLoc = 0;
+ const bool res = BOOLToBool(::ReadFile(_handle, data, size, &processedLoc, NULL));
+ processedSize = (UInt32)processedLoc;
+ return res;
+}
+
+bool CInFile::ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw()
+{
+ if (size > kChunkSizeMax)
+ size = kChunkSizeMax;
+ return Read1(data, size, processedSize);
+}
+
+bool CInFile::Read(void *data, UInt32 size, UInt32 &processedSize) throw()
+{
+ processedSize = 0;
+ do
+ {
+ UInt32 processedLoc = 0;
+ const bool res = ReadPart(data, size, processedLoc);
+ processedSize += processedLoc;
+ if (!res)
+ return false;
+ if (processedLoc == 0)
+ return true;
+ data = (void *)((unsigned char *)data + processedLoc);
+ size -= processedLoc;
+ }
+ while (size > 0);
+ return true;
+}
+
+bool CInFile::ReadFull(void *data, size_t size, size_t &processedSize) throw()
+{
+ processedSize = 0;
+ do
+ {
+ UInt32 processedLoc = 0;
+ const UInt32 sizeLoc = (size > kChunkSizeMax ? (UInt32)kChunkSizeMax : (UInt32)size);
+ const bool res = Read1(data, sizeLoc, processedLoc);
+ processedSize += processedLoc;
+ if (!res)
+ return false;
+ if (processedLoc == 0)
+ return true;
+ data = (void *)((unsigned char *)data + processedLoc);
+ size -= processedLoc;
+ }
+ while (size > 0);
+ return true;
+}
+
+// ---------- COutFile ---------
+
+static inline DWORD GetCreationDisposition(bool createAlways)
+ { return createAlways? CREATE_ALWAYS: CREATE_NEW; }
+
+bool COutFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
+ { return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }
+
+bool COutFile::Open(CFSTR fileName, DWORD creationDisposition)
+ { return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
+
+bool COutFile::Create(CFSTR fileName, bool createAlways)
+ { return Open(fileName, GetCreationDisposition(createAlways)); }
+
+bool COutFile::CreateAlways(CFSTR fileName, DWORD flagsAndAttributes)
+ { return Open(fileName, FILE_SHARE_READ, GetCreationDisposition(true), flagsAndAttributes); }
+
+bool COutFile::SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw()
+ { return BOOLToBool(::SetFileTime(_handle, cTime, aTime, mTime)); }
+
+bool COutFile::SetMTime(const FILETIME *mTime) throw() { return SetTime(NULL, NULL, mTime); }
+
+bool COutFile::WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw()
+{
+ if (size > kChunkSizeMax)
+ size = kChunkSizeMax;
+ DWORD processedLoc = 0;
+ bool res = BOOLToBool(::WriteFile(_handle, data, size, &processedLoc, NULL));
+ processedSize = (UInt32)processedLoc;
+ return res;
+}
+
+bool COutFile::Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
+{
+ processedSize = 0;
+ do
+ {
+ UInt32 processedLoc = 0;
+ const bool res = WritePart(data, size, processedLoc);
+ processedSize += processedLoc;
+ if (!res)
+ return false;
+ if (processedLoc == 0)
+ return true;
+ data = (const void *)((const unsigned char *)data + processedLoc);
+ size -= processedLoc;
+ }
+ while (size != 0);
+ return true;
+}
+
+bool COutFile::WriteFull(const void *data, size_t size) throw()
+{
+ do
+ {
+ UInt32 processedLoc = 0;
+ const UInt32 sizeCur = (size > kChunkSizeMax ? kChunkSizeMax : (UInt32)size);
+ if (!WritePart(data, sizeCur, processedLoc))
+ return false;
+ if (processedLoc == 0)
+ return (size == 0);
+ data = (const void *)((const unsigned char *)data + processedLoc);
+ size -= processedLoc;
+ }
+ while (size != 0);
+ return true;
+}
+
+bool COutFile::SetEndOfFile() throw() { return BOOLToBool(::SetEndOfFile(_handle)); }
+
+bool COutFile::SetLength(UInt64 length) throw()
+{
+ UInt64 newPosition;
+ if (!Seek(length, newPosition))
+ return false;
+ if (newPosition != length)
+ return false;
+ return SetEndOfFile();
+}
+
+bool COutFile::SetLength_KeepPosition(UInt64 length) throw()
+{
+ UInt64 currentPos = 0;
+ if (!GetPosition(currentPos))
+ return false;
+ DWORD lastError = 0;
+ const bool result = SetLength(length);
+ if (!result)
+ lastError = GetLastError();
+ UInt64 currentPos2;
+ const bool result2 = Seek(currentPos, currentPos2);
+ if (lastError != 0)
+ SetLastError(lastError);
+ return (result && result2);
+}
+
+}}}
+
+#else // _WIN32
+
+
+// POSIX
+
+#include <fcntl.h>
+#include <unistd.h>
+
+namespace NWindows {
+namespace NFile {
+
+namespace NDir {
+bool SetDirTime(CFSTR path, const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime);
+}
+
+namespace NIO {
+
+bool CFileBase::OpenBinary(const char *name, int flags, mode_t mode)
+{
+ #ifdef O_BINARY
+ flags |= O_BINARY;
+ #endif
+
+ Close();
+ _handle = ::open(name, flags, mode);
+ return _handle != -1;
+
+ /*
+ if (_handle == -1)
+ return false;
+ if (IsString1PrefixedByString2(name, "/dev/"))
+ {
+ // /dev/sda
+ // IsDeviceFile = true; // for debug
+ // SizeDefined = false;
+ // SizeDefined = (GetDeviceSize_InBytes(Size) == 0);
+ }
+ return true;
+ */
+}
+
+bool CFileBase::Close()
+{
+ if (_handle == -1)
+ return true;
+ if (close(_handle) != 0)
+ return false;
+ _handle = -1;
+ /*
+ IsDeviceFile = false;
+ SizeDefined = false;
+ */
+ return true;
+}
+
+bool CFileBase::GetLength(UInt64 &length) const
+{
+ length = 0;
+ // length = (UInt64)(Int64)-1; // for debug
+ const off_t curPos = seekToCur();
+ if (curPos == -1)
+ return false;
+ const off_t lengthTemp = seek(0, SEEK_END);
+ seek(curPos, SEEK_SET);
+ length = (UInt64)lengthTemp;
+
+ /*
+ // 22.00:
+ if (lengthTemp == 1)
+ if (IsDeviceFile && SizeDefined)
+ {
+ length = Size;
+ return true;
+ }
+ */
+
+ return (lengthTemp != -1);
+}
+
+off_t CFileBase::seek(off_t distanceToMove, int moveMethod) const
+{
+ /*
+ if (IsDeviceFile && SizeDefined && moveMethod == SEEK_END)
+ {
+ printf("\n seek : IsDeviceFile moveMethod = %d distanceToMove = %ld\n", moveMethod, distanceToMove);
+ distanceToMove += Size;
+ moveMethod = SEEK_SET;
+ }
+ */
+
+ // printf("\nCFileBase::seek() moveMethod = %d, distanceToMove = %lld", moveMethod, (long long)distanceToMove);
+ // off_t res = ::lseek(_handle, distanceToMove, moveMethod);
+ // printf("\n lseek : moveMethod = %d distanceToMove = %ld\n", moveMethod, distanceToMove);
+ return ::lseek(_handle, distanceToMove, moveMethod);
+ // return res;
+}
+
+off_t CFileBase::seekToBegin() const throw()
+{
+ return seek(0, SEEK_SET);
+}
+
+off_t CFileBase::seekToCur() const throw()
+{
+ return seek(0, SEEK_CUR);
+}
+
+/*
+bool CFileBase::SeekToBegin() const throw()
+{
+ return (::seek(0, SEEK_SET) != -1);
+}
+*/
+
+
+/////////////////////////
+// CInFile
+
+bool CInFile::Open(const char *name)
+{
+ return CFileBase::OpenBinary(name, O_RDONLY);
+}
+
+bool CInFile::OpenShared(const char *name, bool)
+{
+ return Open(name);
+}
+
+
+/*
+int CFileBase::my_ioctl_BLKGETSIZE64(unsigned long long *numBlocks)
+{
+ // we can read "/sys/block/sda/size" "/sys/block/sda/sda1/size" - partition
+ // #include <linux/fs.h>
+ return ioctl(_handle, BLKGETSIZE64, numBlocks);
+ // in block size
+}
+
+int CFileBase::GetDeviceSize_InBytes(UInt64 &size)
+{
+ size = 0;
+ unsigned long long numBlocks;
+ int res = my_ioctl_BLKGETSIZE64(&numBlocks);
+ if (res == 0)
+ size = numBlocks; // another blockSize s possible?
+ printf("\nGetDeviceSize_InBytes res = %d, size = %lld\n", res, (long long)size);
+ return res;
+}
+*/
+
+/*
+On Linux (32-bit and 64-bit):
+read(), write() (and similar system calls) will transfer at most
+0x7ffff000 = (2GiB - 4 KiB) bytes, returning the number of bytes actually transferred.
+*/
+
+static const size_t kChunkSizeMax = ((size_t)1 << 22);
+
+ssize_t CInFile::read_part(void *data, size_t size) throw()
+{
+ if (size > kChunkSizeMax)
+ size = kChunkSizeMax;
+ return ::read(_handle, data, size);
+}
+
+bool CInFile::ReadFull(void *data, size_t size, size_t &processed) throw()
+{
+ processed = 0;
+ do
+ {
+ const ssize_t res = read_part(data, size);
+ if (res < 0)
+ return false;
+ if (res == 0)
+ break;
+ data = (void *)((unsigned char *)data + (size_t)res);
+ size -= (size_t)res;
+ processed += (size_t)res;
+ }
+ while (size > 0);
+ return true;
+}
+
+
+/////////////////////////
+// COutFile
+
+bool COutFile::Create(const char *name, bool createAlways)
+{
+ Path = name; // change it : set it only if open is success.
+ if (createAlways)
+ {
+ Close();
+ _handle = ::creat(name, mode_for_Create);
+ return _handle != -1;
+ }
+ return OpenBinary(name, O_CREAT | O_EXCL | O_WRONLY, mode_for_Create);
+}
+
+bool COutFile::Open(const char *name, DWORD creationDisposition)
+{
+ UNUSED_VAR(creationDisposition) // FIXME
+ return Create(name, false);
+}
+
+ssize_t COutFile::write_part(const void *data, size_t size) throw()
+{
+ if (size > kChunkSizeMax)
+ size = kChunkSizeMax;
+ return ::write(_handle, data, size);
+}
+
+ssize_t COutFile::write_full(const void *data, size_t size, size_t &processed) throw()
+{
+ processed = 0;
+ do
+ {
+ const ssize_t res = write_part(data, size);
+ if (res < 0)
+ return res;
+ if (res == 0)
+ break;
+ data = (const void *)((const unsigned char *)data + (size_t)res);
+ size -= (size_t)res;
+ processed += (size_t)res;
+ }
+ while (size > 0);
+ return (ssize_t)processed;
+}
+
+bool COutFile::SetLength(UInt64 length) throw()
+{
+ const off_t len2 = (off_t)length;
+ if ((Int64)length != len2)
+ {
+ SetLastError(EFBIG);
+ return false;
+ }
+ // The value of the seek pointer shall not be modified by a call to ftruncate().
+ const int iret = ftruncate(_handle, len2);
+ return (iret == 0);
+}
+
+bool COutFile::Close()
+{
+ const bool res = CFileBase::Close();
+ if (!res)
+ return res;
+ if (CTime_defined || ATime_defined || MTime_defined)
+ {
+ /* bool res2 = */ NWindows::NFile::NDir::SetDirTime(Path,
+ CTime_defined ? &CTime : NULL,
+ ATime_defined ? &ATime : NULL,
+ MTime_defined ? &MTime : NULL);
+ }
+ return res;
+}
+
+bool COutFile::SetTime(const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime) throw()
+{
+ // On some OS (cygwin, MacOSX ...), you must close the file before updating times
+ // return true;
+
+ if (cTime) { CTime = *cTime; CTime_defined = true; } else CTime_defined = false;
+ if (aTime) { ATime = *aTime; ATime_defined = true; } else ATime_defined = false;
+ if (mTime) { MTime = *mTime; MTime_defined = true; } else MTime_defined = false;
+ return true;
+
+ /*
+ struct timespec times[2];
+ UNUSED_VAR(cTime)
+ if (!aTime && !mTime)
+ return true;
+ bool needChange;
+ needChange = FiTime_To_timespec(aTime, times[0]);
+ needChange |= FiTime_To_timespec(mTime, times[1]);
+ if (!needChange)
+ return true;
+ return futimens(_handle, times) == 0;
+ */
+}
+
+bool COutFile::SetMTime(const CFiTime *mTime) throw()
+{
+ if (mTime) { MTime = *mTime; MTime_defined = true; } else MTime_defined = false;
+ return true;
+}
+
+}}}
+
+
+#endif
diff --git a/CPP/Windows/FileIO.h b/CPP/Windows/FileIO.h
index e31bc20..03e061a 100644
--- a/CPP/Windows/FileIO.h
+++ b/CPP/Windows/FileIO.h
@@ -1,212 +1,390 @@
-// Windows/FileIO.h
-
-#ifndef __WINDOWS_FILE_IO_H
-#define __WINDOWS_FILE_IO_H
-
-#include "../Common/MyWindows.h"
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-#include <winioctl.h>
-#endif
-
-#include "../Common/MyString.h"
-#include "../Common/MyBuffer.h"
-
-#include "Defs.h"
-
-#define _my_IO_REPARSE_TAG_MOUNT_POINT (0xA0000003L)
-#define _my_IO_REPARSE_TAG_SYMLINK (0xA000000CL)
-
-#define _my_SYMLINK_FLAG_RELATIVE 1
-
-#define my_FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER
-#define my_FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) // REPARSE_DATA_BUFFER
-
-namespace NWindows {
-namespace NFile {
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink);
-#endif
-
-struct CReparseShortInfo
-{
- unsigned Offset;
- unsigned Size;
-
- bool Parse(const Byte *p, size_t size);
-};
-
-struct CReparseAttr
-{
- UInt32 Tag;
- UInt32 Flags;
- UString SubsName;
- UString PrintName;
-
- CReparseAttr(): Tag(0), Flags(0) {}
-
- // Parse()
- // returns true and (errorCode = 0), if (correct MOUNT_POINT or SYMLINK)
- // returns false and (errorCode = ERROR_REPARSE_TAG_MISMATCH), if not (MOUNT_POINT or SYMLINK)
- bool Parse(const Byte *p, size_t size, DWORD &errorCode);
-
- bool IsMountPoint() const { return Tag == _my_IO_REPARSE_TAG_MOUNT_POINT; } // it's Junction
- bool IsSymLink() const { return Tag == _my_IO_REPARSE_TAG_SYMLINK; }
- bool IsRelative() const { return Flags == _my_SYMLINK_FLAG_RELATIVE; }
- // bool IsVolume() const;
-
- bool IsOkNamePair() const;
- UString GetPath() const;
-};
-
-namespace NIO {
-
-bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo = NULL);
-bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size);
-
-class CFileBase
-{
-protected:
- HANDLE _handle;
-
- bool Create(CFSTR path, DWORD desiredAccess,
- DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
-
-public:
-
- bool DeviceIoControl(DWORD controlCode, LPVOID inBuffer, DWORD inSize,
- LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned, LPOVERLAPPED overlapped = NULL) const
- {
- return BOOLToBool(::DeviceIoControl(_handle, controlCode, inBuffer, inSize,
- outBuffer, outSize, bytesReturned, overlapped));
- }
-
- bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned) const
- {
- return DeviceIoControl(controlCode, NULL, 0, outBuffer, outSize, bytesReturned);
- }
-
- bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize) const
- {
- DWORD bytesReturned;
- return DeviceIoControlOut(controlCode, outBuffer, outSize, &bytesReturned);
- }
-
-public:
- #ifdef SUPPORT_DEVICE_FILE
- bool IsDeviceFile;
- bool SizeDefined;
- UInt64 Size; // it can be larger than real available size
- #endif
-
- CFileBase(): _handle(INVALID_HANDLE_VALUE) {};
- ~CFileBase() { Close(); }
-
- bool Close() throw();
-
- bool GetPosition(UInt64 &position) const throw();
- bool GetLength(UInt64 &length) const throw();
-
- bool Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw();
- bool Seek(UInt64 position, UInt64 &newPosition) const throw();
- bool SeekToBegin() const throw();
- bool SeekToEnd(UInt64 &newPosition) const throw();
-
- bool GetFileInformation(BY_HANDLE_FILE_INFORMATION *info) const
- { return BOOLToBool(GetFileInformationByHandle(_handle, info)); }
-
- static bool GetFileInformation(CFSTR path, BY_HANDLE_FILE_INFORMATION *info)
- {
- NIO::CFileBase file;
- if (!file.Create(path, 0, FILE_SHARE_READ, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS))
- return false;
- return file.GetFileInformation(info);
- }
-};
-
-#ifndef UNDER_CE
-#define IOCTL_CDROM_BASE FILE_DEVICE_CD_ROM
-#define IOCTL_CDROM_GET_DRIVE_GEOMETRY CTL_CODE(IOCTL_CDROM_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS)
-// #define IOCTL_CDROM_MEDIA_REMOVAL CTL_CODE(IOCTL_CDROM_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
-
-// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX works since WinXP
-#define my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
-
-struct my_DISK_GEOMETRY_EX
-{
- DISK_GEOMETRY Geometry;
- LARGE_INTEGER DiskSize;
- BYTE Data[1];
-};
-#endif
-
-class CInFile: public CFileBase
-{
- #ifdef SUPPORT_DEVICE_FILE
-
- #ifndef UNDER_CE
-
- bool GetGeometry(DISK_GEOMETRY *res) const
- { return DeviceIoControlOut(IOCTL_DISK_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
-
- bool GetGeometryEx(my_DISK_GEOMETRY_EX *res) const
- { return DeviceIoControlOut(my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, res, sizeof(*res)); }
-
- bool GetCdRomGeometry(DISK_GEOMETRY *res) const
- { return DeviceIoControlOut(IOCTL_CDROM_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
-
- bool GetPartitionInfo(PARTITION_INFORMATION *res)
- { return DeviceIoControlOut(IOCTL_DISK_GET_PARTITION_INFO, LPVOID(res), sizeof(*res)); }
-
- #endif
-
- void CorrectDeviceSize();
- void CalcDeviceSize(CFSTR name);
-
- #endif
-
-public:
- bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
- bool OpenShared(CFSTR fileName, bool shareForWrite);
- bool Open(CFSTR fileName);
-
- #ifndef UNDER_CE
-
- bool OpenReparse(CFSTR fileName)
- {
- // 17.02 fix: to support Windows XP compatibility junctions:
- // we use Create() with (desiredAccess = 0) instead of Open() with GENERIC_READ
- return
- Create(fileName, 0,
- // Open(fileName,
- FILE_SHARE_READ, OPEN_EXISTING,
- FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
- }
-
- #endif
-
- bool Read1(void *data, UInt32 size, UInt32 &processedSize) throw();
- bool ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw();
- bool Read(void *data, UInt32 size, UInt32 &processedSize) throw();
-};
-
-class COutFile: public CFileBase
-{
-public:
- bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
- bool Open(CFSTR fileName, DWORD creationDisposition);
- bool Create(CFSTR fileName, bool createAlways);
- bool CreateAlways(CFSTR fileName, DWORD flagsAndAttributes);
-
- bool SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw();
- bool SetMTime(const FILETIME *mTime) throw();
- bool WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw();
- bool Write(const void *data, UInt32 size, UInt32 &processedSize) throw();
- bool SetEndOfFile() throw();
- bool SetLength(UInt64 length) throw();
-};
-
-}}}
-
-#endif
+// Windows/FileIO.h
+
+#ifndef ZIP7_INC_WINDOWS_FILE_IO_H
+#define ZIP7_INC_WINDOWS_FILE_IO_H
+
+#include "../Common/MyWindows.h"
+
+#define Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT (0xA0000003L)
+#define Z7_WIN_IO_REPARSE_TAG_SYMLINK (0xA000000CL)
+#define Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK (0xA000001DL)
+
+#define Z7_WIN_SYMLINK_FLAG_RELATIVE 1
+
+// what the meaning of that FLAG or field (2)?
+#define Z7_WIN_LX_SYMLINK_FLAG 2
+
+#ifdef _WIN32
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+#include <winioctl.h>
+#endif
+
+#else
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#endif
+
+#include "../Common/MyString.h"
+#include "../Common/MyBuffer.h"
+
+#include "../Windows/TimeUtils.h"
+
+#include "Defs.h"
+
+HRESULT GetLastError_noZero_HRESULT();
+
+#define my_FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER
+#define my_FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) // REPARSE_DATA_BUFFER
+#define my_FSCTL_DELETE_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 43, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER
+
+namespace NWindows {
+namespace NFile {
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL);
+#endif
+
+struct CReparseShortInfo
+{
+ unsigned Offset;
+ unsigned Size;
+
+ bool Parse(const Byte *p, size_t size);
+};
+
+struct CReparseAttr
+{
+ UInt32 Tag;
+ UInt32 Flags;
+ UString SubsName;
+ UString PrintName;
+
+ AString WslName;
+
+ bool HeaderError;
+ bool TagIsUnknown;
+ bool MinorError;
+ DWORD ErrorCode;
+
+ CReparseAttr(): Tag(0), Flags(0) {}
+
+ // Parse()
+ // returns (true) and (ErrorCode = 0), if (it'a correct known link)
+ // returns (false) and (ErrorCode = ERROR_REPARSE_TAG_INVALID), if unknown tag
+ bool Parse(const Byte *p, size_t size);
+
+ bool IsMountPoint() const { return Tag == Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT; } // it's Junction
+ bool IsSymLink_Win() const { return Tag == Z7_WIN_IO_REPARSE_TAG_SYMLINK; }
+ bool IsSymLink_WSL() const { return Tag == Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK; }
+
+ bool IsRelative_Win() const { return Flags == Z7_WIN_SYMLINK_FLAG_RELATIVE; }
+
+ bool IsRelative_WSL() const
+ {
+ if (WslName.IsEmpty())
+ return true;
+ char c = WslName[0];
+ return !IS_PATH_SEPAR(c);
+ }
+
+ // bool IsVolume() const;
+
+ bool IsOkNamePair() const;
+ UString GetPath() const;
+};
+
+#ifdef _WIN32
+#define CFiInfo BY_HANDLE_FILE_INFORMATION
+#define ST_MTIME(st) (st).ftLastWriteTime
+#else
+#define CFiInfo stat
+#endif
+
+#ifdef _WIN32
+
+namespace NIO {
+
+bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo = NULL);
+bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size);
+bool DeleteReparseData(CFSTR path);
+
+class CFileBase MY_UNCOPYABLE
+{
+protected:
+ HANDLE _handle;
+
+ bool Create(CFSTR path, DWORD desiredAccess,
+ DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
+
+public:
+
+ bool DeviceIoControl(DWORD controlCode, LPVOID inBuffer, DWORD inSize,
+ LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned, LPOVERLAPPED overlapped = NULL) const
+ {
+ return BOOLToBool(::DeviceIoControl(_handle, controlCode, inBuffer, inSize,
+ outBuffer, outSize, bytesReturned, overlapped));
+ }
+
+ bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned) const
+ {
+ return DeviceIoControl(controlCode, NULL, 0, outBuffer, outSize, bytesReturned);
+ }
+
+ bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize) const
+ {
+ DWORD bytesReturned;
+ return DeviceIoControlOut(controlCode, outBuffer, outSize, &bytesReturned);
+ }
+
+public:
+ bool PreserveATime;
+ #ifdef Z7_DEVICE_FILE
+ bool IsDeviceFile;
+ bool SizeDefined;
+ UInt64 Size; // it can be larger than real available size
+ #endif
+
+ CFileBase(): _handle(INVALID_HANDLE_VALUE), PreserveATime(false) {}
+ ~CFileBase() { Close(); }
+
+ HANDLE GetHandle() const { return _handle; }
+
+ // void Detach() { _handle = INVALID_HANDLE_VALUE; }
+
+ bool Close() throw();
+
+ bool GetPosition(UInt64 &position) const throw();
+ bool GetLength(UInt64 &length) const throw();
+
+ bool Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw();
+ bool Seek(UInt64 position, UInt64 &newPosition) const throw();
+ bool SeekToBegin() const throw();
+ bool SeekToEnd(UInt64 &newPosition) const throw();
+
+ bool GetFileInformation(BY_HANDLE_FILE_INFORMATION *info) const
+ { return BOOLToBool(GetFileInformationByHandle(_handle, info)); }
+
+ static bool GetFileInformation(CFSTR path, BY_HANDLE_FILE_INFORMATION *info)
+ {
+ // probably it can work for complex paths: unsupported by another things
+ NIO::CFileBase file;
+ if (!file.Create(path, 0, FILE_SHARE_READ, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS))
+ return false;
+ return file.GetFileInformation(info);
+ }
+};
+
+#ifndef UNDER_CE
+#define IOCTL_CDROM_BASE FILE_DEVICE_CD_ROM
+#define IOCTL_CDROM_GET_DRIVE_GEOMETRY CTL_CODE(IOCTL_CDROM_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS)
+// #define IOCTL_CDROM_MEDIA_REMOVAL CTL_CODE(IOCTL_CDROM_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
+
+// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX works since WinXP
+#define my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
+
+struct my_DISK_GEOMETRY_EX
+{
+ DISK_GEOMETRY Geometry;
+ LARGE_INTEGER DiskSize;
+ BYTE Data[1];
+};
+#endif
+
+class CInFile: public CFileBase
+{
+ #ifdef Z7_DEVICE_FILE
+
+ #ifndef UNDER_CE
+
+ bool GetGeometry(DISK_GEOMETRY *res) const
+ { return DeviceIoControlOut(IOCTL_DISK_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
+
+ bool GetGeometryEx(my_DISK_GEOMETRY_EX *res) const
+ { return DeviceIoControlOut(my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, res, sizeof(*res)); }
+
+ bool GetCdRomGeometry(DISK_GEOMETRY *res) const
+ { return DeviceIoControlOut(IOCTL_CDROM_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
+
+ bool GetPartitionInfo(PARTITION_INFORMATION *res)
+ { return DeviceIoControlOut(IOCTL_DISK_GET_PARTITION_INFO, LPVOID(res), sizeof(*res)); }
+
+ #endif
+
+ void CorrectDeviceSize();
+ void CalcDeviceSize(CFSTR name);
+
+ #endif
+
+public:
+ bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
+ bool OpenShared(CFSTR fileName, bool shareForWrite);
+ bool Open(CFSTR fileName);
+
+ #ifndef UNDER_CE
+
+ bool Open_for_ReadAttributes(CFSTR fileName)
+ {
+ return Create(fileName, FILE_READ_ATTRIBUTES,
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+ OPEN_EXISTING,
+ FILE_FLAG_BACKUP_SEMANTICS);
+ // we must use (FILE_FLAG_BACKUP_SEMANTICS) to open handle of directory.
+ }
+
+ bool Open_for_FileRenameInformation(CFSTR fileName)
+ {
+ return Create(fileName, DELETE | SYNCHRONIZE | GENERIC_READ,
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+ OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL);
+ // we must use (FILE_FLAG_BACKUP_SEMANTICS) to open handle of directory.
+ }
+
+ bool OpenReparse(CFSTR fileName)
+ {
+ // 17.02 fix: to support Windows XP compatibility junctions:
+ // we use Create() with (desiredAccess = 0) instead of Open() with GENERIC_READ
+ return
+ Create(fileName, 0,
+ // Open(fileName,
+ FILE_SHARE_READ, OPEN_EXISTING,
+ FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
+ }
+
+ #endif
+
+ bool Read1(void *data, UInt32 size, UInt32 &processedSize) throw();
+ bool ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw();
+ bool Read(void *data, UInt32 size, UInt32 &processedSize) throw();
+ bool ReadFull(void *data, size_t size, size_t &processedSize) throw();
+};
+
+class COutFile: public CFileBase
+{
+public:
+ bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
+ bool Open(CFSTR fileName, DWORD creationDisposition);
+ bool Create(CFSTR fileName, bool createAlways);
+ bool CreateAlways(CFSTR fileName, DWORD flagsAndAttributes);
+
+ bool SetTime(const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime) throw();
+ bool SetMTime(const CFiTime *mTime) throw();
+ bool WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw();
+ bool Write(const void *data, UInt32 size, UInt32 &processedSize) throw();
+ bool WriteFull(const void *data, size_t size) throw();
+ bool SetEndOfFile() throw();
+ bool SetLength(UInt64 length) throw();
+ bool SetLength_KeepPosition(UInt64 length) throw();
+};
+
+}
+
+
+#else // _WIN32
+
+namespace NIO {
+
+bool GetReparseData(CFSTR path, CByteBuffer &reparseData);
+// bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size);
+
+// parameters are in reverse order of symlink() function !!!
+bool SetSymLink(CFSTR from, CFSTR to);
+bool SetSymLink_UString(CFSTR from, const UString &to);
+
+
+class CFileBase
+{
+protected:
+ int _handle;
+
+ /*
+ bool IsDeviceFile;
+ bool SizeDefined;
+ UInt64 Size; // it can be larger than real available size
+ */
+
+ bool OpenBinary(const char *name, int flags, mode_t mode = 0666);
+public:
+ bool PreserveATime;
+
+ CFileBase(): _handle(-1), PreserveATime(false) {}
+ ~CFileBase() { Close(); }
+ // void Detach() { _handle = -1; }
+ bool Close();
+ bool GetLength(UInt64 &length) const;
+ off_t seek(off_t distanceToMove, int moveMethod) const;
+ off_t seekToBegin() const throw();
+ off_t seekToCur() const throw();
+ // bool SeekToBegin() throw();
+ int my_fstat(struct stat *st) const { return fstat(_handle, st); }
+ /*
+ int my_ioctl_BLKGETSIZE64(unsigned long long *val);
+ int GetDeviceSize_InBytes(UInt64 &size);
+ void CalcDeviceSize(CFSTR s);
+ */
+};
+
+class CInFile: public CFileBase
+{
+public:
+ bool Open(const char *name);
+ bool OpenShared(const char *name, bool shareForWrite);
+ ssize_t read_part(void *data, size_t size) throw();
+ // ssize_t read_full(void *data, size_t size, size_t &processed);
+ bool ReadFull(void *data, size_t size, size_t &processedSize) throw();
+};
+
+class COutFile: public CFileBase
+{
+ bool CTime_defined;
+ bool ATime_defined;
+ bool MTime_defined;
+ CFiTime CTime;
+ CFiTime ATime;
+ CFiTime MTime;
+
+ AString Path;
+ ssize_t write_part(const void *data, size_t size) throw();
+public:
+ mode_t mode_for_Create;
+
+ COutFile():
+ CTime_defined(false),
+ ATime_defined(false),
+ MTime_defined(false),
+ mode_for_Create(0666)
+ {}
+
+ bool Close();
+ bool Create(const char *name, bool createAlways);
+ bool Open(const char *name, DWORD creationDisposition);
+ ssize_t write_full(const void *data, size_t size, size_t &processed) throw();
+
+ bool WriteFull(const void *data, size_t size) throw()
+ {
+ size_t processed;
+ ssize_t res = write_full(data, size, processed);
+ if (res == -1)
+ return false;
+ return processed == size;
+ }
+
+ bool SetLength(UInt64 length) throw();
+ bool SetLength_KeepPosition(UInt64 length) throw()
+ {
+ return SetLength(length);
+ }
+ bool SetTime(const CFiTime *cTime, const CFiTime *aTime, const CFiTime *mTime) throw();
+ bool SetMTime(const CFiTime *mTime) throw();
+};
+
+}
+
+#endif // _WIN32
+
+}}
+
+
+#endif
diff --git a/CPP/Windows/FileLink.cpp b/CPP/Windows/FileLink.cpp
index b5e47e7..2b9fa1a 100644
--- a/CPP/Windows/FileLink.cpp
+++ b/CPP/Windows/FileLink.cpp
@@ -1,440 +1,622 @@
-// Windows/FileLink.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/CpuArch.h"
-
-#ifdef SUPPORT_DEVICE_FILE
-#include "../../C/Alloc.h"
-#endif
-
-#include "FileDir.h"
-#include "FileFind.h"
-#include "FileIO.h"
-#include "FileName.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NFile {
-
-using namespace NName;
-
-/*
- Reparse Points (Junctions and Symbolic Links):
- struct
- {
- UInt32 Tag;
- UInt16 Size; // not including starting 8 bytes
- UInt16 Reserved; // = 0
-
- UInt16 SubstituteOffset; // offset in bytes from start of namesChars
- UInt16 SubstituteLen; // size in bytes, it doesn't include tailed NUL
- UInt16 PrintOffset; // offset in bytes from start of namesChars
- UInt16 PrintLen; // size in bytes, it doesn't include tailed NUL
-
- [UInt32] Flags; // for Symbolic Links only.
-
- UInt16 namesChars[]
- }
-
- MOUNT_POINT (Junction point):
- 1) there is NUL wchar after path
- 2) Default Order in table:
- Substitute Path
- Print Path
- 3) pathnames can not contain dot directory names
-
- SYMLINK:
- 1) there is no NUL wchar after path
- 2) Default Order in table:
- Print Path
- Substitute Path
-*/
-
-/*
-static const UInt32 kReparseFlags_Alias = (1 << 29);
-static const UInt32 kReparseFlags_HighLatency = (1 << 30);
-static const UInt32 kReparseFlags_Microsoft = ((UInt32)1 << 31);
-
-#define _my_IO_REPARSE_TAG_HSM (0xC0000004L)
-#define _my_IO_REPARSE_TAG_HSM2 (0x80000006L)
-#define _my_IO_REPARSE_TAG_SIS (0x80000007L)
-#define _my_IO_REPARSE_TAG_WIM (0x80000008L)
-#define _my_IO_REPARSE_TAG_CSV (0x80000009L)
-#define _my_IO_REPARSE_TAG_DFS (0x8000000AL)
-#define _my_IO_REPARSE_TAG_DFSR (0x80000012L)
-*/
-
-#define Get16(p) GetUi16(p)
-#define Get32(p) GetUi32(p)
-
-#define Set16(p, v) SetUi16(p, v)
-#define Set32(p, v) SetUi32(p, v)
-
-static const wchar_t * const k_LinkPrefix = L"\\??\\";
-static const unsigned k_LinkPrefix_Size = 4;
-
-static const bool IsLinkPrefix(const wchar_t *s)
-{
- return IsString1PrefixedByString2(s, k_LinkPrefix);
-}
-
-/*
-static const wchar_t * const k_VolumePrefix = L"Volume{";
-static const bool IsVolumeName(const wchar_t *s)
-{
- return IsString1PrefixedByString2(s, k_VolumePrefix);
-}
-*/
-
-void WriteString(Byte *dest, const wchar_t *path)
-{
- for (;;)
- {
- wchar_t c = *path++;
- if (c == 0)
- return;
- Set16(dest, (UInt16)c);
- dest += 2;
- }
-}
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink)
-{
- bool isAbs = IsAbsolutePath(path);
- if (!isAbs && !isSymLink)
- return false;
-
- bool needPrintName = true;
-
- if (IsSuperPath(path))
- {
- path += kSuperPathPrefixSize;
- if (!IsDrivePath(path))
- needPrintName = false;
- }
-
- const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
-
- unsigned len2 = MyStringLen(path) * 2;
- const unsigned len1 = len2 + add_Prefix_Len * 2;
- if (!needPrintName)
- len2 = 0;
-
- unsigned totalNamesSize = (len1 + len2);
-
- /* some WIM imagex software uses old scheme for symbolic links.
- so we can old scheme for byte to byte compatibility */
-
- bool newOrderScheme = isSymLink;
- // newOrderScheme = false;
-
- if (!newOrderScheme)
- totalNamesSize += 2 * 2;
-
- const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
- dest.Alloc(size);
- memset(dest, 0, size);
- const UInt32 tag = isSymLink ?
- _my_IO_REPARSE_TAG_SYMLINK :
- _my_IO_REPARSE_TAG_MOUNT_POINT;
- Byte *p = dest;
- Set32(p, tag);
- Set16(p + 4, (UInt16)(size - 8));
- Set16(p + 6, 0);
- p += 8;
-
- unsigned subOffs = 0;
- unsigned printOffs = 0;
- if (newOrderScheme)
- subOffs = len2;
- else
- printOffs = len1 + 2;
-
- Set16(p + 0, (UInt16)subOffs);
- Set16(p + 2, (UInt16)len1);
- Set16(p + 4, (UInt16)printOffs);
- Set16(p + 6, (UInt16)len2);
-
- p += 8;
- if (isSymLink)
- {
- UInt32 flags = isAbs ? 0 : _my_SYMLINK_FLAG_RELATIVE;
- Set32(p, flags);
- p += 4;
- }
-
- if (add_Prefix_Len != 0)
- WriteString(p + subOffs, k_LinkPrefix);
- WriteString(p + subOffs + add_Prefix_Len * 2, path);
- if (needPrintName)
- WriteString(p + printOffs, path);
- return true;
-}
-
-#endif
-
-static void GetString(const Byte *p, unsigned len, UString &res)
-{
- wchar_t *s = res.GetBuf(len);
- unsigned i;
- for (i = 0; i < len; i++)
- {
- wchar_t c = Get16(p + i * 2);
- if (c == 0)
- break;
- s[i] = c;
- }
- s[i] = 0;
- res.ReleaseBuf_SetLen(i);
-}
-
-bool CReparseAttr::Parse(const Byte *p, size_t size, DWORD &errorCode)
-{
- errorCode = ERROR_INVALID_REPARSE_DATA;
- if (size < 8)
- return false;
- Tag = Get32(p);
- UInt32 len = Get16(p + 4);
- if (len + 8 > size)
- return false;
- /*
- if ((type & kReparseFlags_Alias) == 0 ||
- (type & kReparseFlags_Microsoft) == 0 ||
- (type & 0xFFFF) != 3)
- */
- if (Tag != _my_IO_REPARSE_TAG_MOUNT_POINT &&
- Tag != _my_IO_REPARSE_TAG_SYMLINK)
- {
- errorCode = ERROR_REPARSE_TAG_MISMATCH; // ERROR_REPARSE_TAG_INVALID
- return false;
- }
-
- if (Get16(p + 6) != 0) // padding
- return false;
-
- p += 8;
- size -= 8;
-
- if (len != size) // do we need that check?
- return false;
-
- if (len < 8)
- return false;
- unsigned subOffs = Get16(p);
- unsigned subLen = Get16(p + 2);
- unsigned printOffs = Get16(p + 4);
- unsigned printLen = Get16(p + 6);
- len -= 8;
- p += 8;
-
- Flags = 0;
- if (Tag == _my_IO_REPARSE_TAG_SYMLINK)
- {
- if (len < 4)
- return false;
- Flags = Get32(p);
- len -= 4;
- p += 4;
- }
-
- if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
- return false;
- if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
- return false;
- GetString(p + subOffs, subLen >> 1, SubsName);
- GetString(p + printOffs, printLen >> 1, PrintName);
-
- errorCode = 0;
- return true;
-}
-
-bool CReparseShortInfo::Parse(const Byte *p, size_t size)
-{
- const Byte *start = p;
- Offset= 0;
- Size = 0;
- if (size < 8)
- return false;
- UInt32 Tag = Get32(p);
- UInt32 len = Get16(p + 4);
- if (len + 8 > size)
- return false;
- /*
- if ((type & kReparseFlags_Alias) == 0 ||
- (type & kReparseFlags_Microsoft) == 0 ||
- (type & 0xFFFF) != 3)
- */
- if (Tag != _my_IO_REPARSE_TAG_MOUNT_POINT &&
- Tag != _my_IO_REPARSE_TAG_SYMLINK)
- // return true;
- return false;
-
- if (Get16(p + 6) != 0) // padding
- return false;
-
- p += 8;
- size -= 8;
-
- if (len != size) // do we need that check?
- return false;
-
- if (len < 8)
- return false;
- unsigned subOffs = Get16(p);
- unsigned subLen = Get16(p + 2);
- unsigned printOffs = Get16(p + 4);
- unsigned printLen = Get16(p + 6);
- len -= 8;
- p += 8;
-
- // UInt32 Flags = 0;
- if (Tag == _my_IO_REPARSE_TAG_SYMLINK)
- {
- if (len < 4)
- return false;
- // Flags = Get32(p);
- len -= 4;
- p += 4;
- }
-
- if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
- return false;
- if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
- return false;
-
- Offset = (unsigned)(p - start) + subOffs;
- Size = subLen;
- return true;
-}
-
-bool CReparseAttr::IsOkNamePair() const
-{
- if (IsLinkPrefix(SubsName))
- {
- if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
- return PrintName.IsEmpty();
- if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
- return true;
- }
- return wcscmp(SubsName, PrintName) == 0;
-}
-
-/*
-bool CReparseAttr::IsVolume() const
-{
- if (!IsLinkPrefix(SubsName))
- return false;
- return IsVolumeName(SubsName.Ptr(k_LinkPrefix_Size));
-}
-*/
-
-UString CReparseAttr::GetPath() const
-{
- UString s (SubsName);
- if (IsLinkPrefix(s))
- {
- s.ReplaceOneCharAtPos(1, '\\');
- if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
- s.DeleteFrontal(k_LinkPrefix_Size);
- }
- return s;
-}
-
-
-#ifdef SUPPORT_DEVICE_FILE
-
-namespace NSystem
-{
-bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
-}
-#endif
-
-#ifndef UNDER_CE
-
-namespace NIO {
-
-bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo)
-{
- reparseData.Free();
- CInFile file;
- if (!file.OpenReparse(path))
- return false;
-
- if (fileInfo)
- file.GetFileInformation(fileInfo);
-
- const unsigned kBufSize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
- CByteArr buf(kBufSize);
- DWORD returnedSize;
- if (!file.DeviceIoControlOut(my_FSCTL_GET_REPARSE_POINT, buf, kBufSize, &returnedSize))
- return false;
- reparseData.CopyFrom(buf, returnedSize);
- return true;
-}
-
-static bool CreatePrefixDirOfFile(CFSTR path)
-{
- FString path2 (path);
- int pos = path2.ReverseFind_PathSepar();
- if (pos < 0)
- return true;
- #ifdef _WIN32
- if (pos == 2 && path2[1] == L':')
- return true; // we don't create Disk folder;
- #endif
- path2.DeleteFrom(pos);
- return NDir::CreateComplexDir(path2);
-}
-
-// If there is Reprase data already, it still writes new Reparse data
-bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
-{
- NFile::NFind::CFileInfo fi;
- if (fi.Find(path))
- {
- if (fi.IsDir() != isDir)
- {
- ::SetLastError(ERROR_DIRECTORY);
- return false;
- }
- }
- else
- {
- if (isDir)
- {
- if (!NDir::CreateComplexDir(path))
- return false;
- }
- else
- {
- CreatePrefixDirOfFile(path);
- COutFile file;
- if (!file.Create(path, CREATE_NEW))
- return false;
- }
- }
-
- COutFile file;
- if (!file.Open(path,
- FILE_SHARE_WRITE,
- OPEN_EXISTING,
- FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS))
- return false;
-
- DWORD returnedSize;
- if (!file.DeviceIoControl(my_FSCTL_SET_REPARSE_POINT, (void *)data, size, NULL, 0, &returnedSize))
- return false;
- return true;
-}
-
-}
-
-#endif
-
-}}
+// Windows/FileLink.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#ifdef Z7_DEVICE_FILE
+#include "../../C/Alloc.h"
+#endif
+
+#include "../Common/UTFConvert.h"
+#include "../Common/StringConvert.h"
+
+#include "FileDir.h"
+#include "FileFind.h"
+#include "FileIO.h"
+#include "FileName.h"
+
+#ifdef Z7_OLD_WIN_SDK
+#ifndef ERROR_INVALID_REPARSE_DATA
+#define ERROR_INVALID_REPARSE_DATA 4392L
+#endif
+#ifndef ERROR_REPARSE_TAG_INVALID
+#define ERROR_REPARSE_TAG_INVALID 4393L
+#endif
+#endif
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NFile {
+
+using namespace NName;
+
+/*
+ Reparse Points (Junctions and Symbolic Links):
+ struct
+ {
+ UInt32 Tag;
+ UInt16 Size; // not including starting 8 bytes
+ UInt16 Reserved; // = 0
+
+ UInt16 SubstituteOffset; // offset in bytes from start of namesChars
+ UInt16 SubstituteLen; // size in bytes, it doesn't include tailed NUL
+ UInt16 PrintOffset; // offset in bytes from start of namesChars
+ UInt16 PrintLen; // size in bytes, it doesn't include tailed NUL
+
+ [UInt32] Flags; // for Symbolic Links only.
+
+ UInt16 namesChars[]
+ }
+
+ MOUNT_POINT (Junction point):
+ 1) there is NUL wchar after path
+ 2) Default Order in table:
+ Substitute Path
+ Print Path
+ 3) pathnames can not contain dot directory names
+
+ SYMLINK:
+ 1) there is no NUL wchar after path
+ 2) Default Order in table:
+ Print Path
+ Substitute Path
+*/
+
+/*
+Win10 WSL2:
+admin rights + sudo: it creates normal windows symbolic link.
+in another cases : it creates IO_REPARSE_TAG_LX_SYMLINK repare point.
+*/
+
+/*
+static const UInt32 kReparseFlags_Alias = (1 << 29);
+static const UInt32 kReparseFlags_HighLatency = (1 << 30);
+static const UInt32 kReparseFlags_Microsoft = ((UInt32)1 << 31);
+
+#define Z7_WIN_IO_REPARSE_TAG_HSM (0xC0000004L)
+#define Z7_WIN_IO_REPARSE_TAG_HSM2 (0x80000006L)
+#define Z7_WIN_IO_REPARSE_TAG_SIS (0x80000007L)
+#define Z7_WIN_IO_REPARSE_TAG_WIM (0x80000008L)
+#define Z7_WIN_IO_REPARSE_TAG_CSV (0x80000009L)
+#define Z7_WIN_IO_REPARSE_TAG_DFS (0x8000000AL)
+#define Z7_WIN_IO_REPARSE_TAG_DFSR (0x80000012L)
+*/
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+
+static const wchar_t * const k_LinkPrefix = L"\\??\\";
+static const unsigned k_LinkPrefix_Size = 4;
+
+static bool IsLinkPrefix(const wchar_t *s)
+{
+ return IsString1PrefixedByString2(s, k_LinkPrefix);
+}
+
+/*
+static const wchar_t * const k_VolumePrefix = L"Volume{";
+static const bool IsVolumeName(const wchar_t *s)
+{
+ return IsString1PrefixedByString2(s, k_VolumePrefix);
+}
+*/
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+#define Set16(p, v) SetUi16(p, v)
+#define Set32(p, v) SetUi32(p, v)
+
+static void WriteString(Byte *dest, const wchar_t *path)
+{
+ for (;;)
+ {
+ wchar_t c = *path++;
+ if (c == 0)
+ return;
+ Set16(dest, (UInt16)c)
+ dest += 2;
+ }
+}
+
+bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink, bool isWSL)
+{
+ bool isAbs = IsAbsolutePath(path);
+ if (!isAbs && !isSymLink)
+ return false;
+
+ if (isWSL)
+ {
+ // unsupported characters probably use Replacement Character UTF-16 0xFFFD
+ AString utf;
+ ConvertUnicodeToUTF8(path, utf);
+ const size_t size = 4 + utf.Len();
+ if (size != (UInt16)size)
+ return false;
+ dest.Alloc(8 + size);
+ Byte *p = dest;
+ Set32(p, Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
+ Set16(p + 4, (UInt16)(size))
+ Set16(p + 6, 0)
+ Set32(p + 8, Z7_WIN_LX_SYMLINK_FLAG)
+ memcpy(p + 12, utf.Ptr(), utf.Len());
+ return true;
+ }
+
+ // usual symbolic LINK (NOT WSL)
+
+ bool needPrintName = true;
+
+ if (IsSuperPath(path))
+ {
+ path += kSuperPathPrefixSize;
+ if (!IsDrivePath(path))
+ needPrintName = false;
+ }
+
+ const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
+
+ size_t len2 = (size_t)MyStringLen(path) * 2;
+ const size_t len1 = len2 + add_Prefix_Len * 2;
+ if (!needPrintName)
+ len2 = 0;
+
+ size_t totalNamesSize = (len1 + len2);
+
+ /* some WIM imagex software uses old scheme for symbolic links.
+ so we can old scheme for byte to byte compatibility */
+
+ bool newOrderScheme = isSymLink;
+ // newOrderScheme = false;
+
+ if (!newOrderScheme)
+ totalNamesSize += 2 * 2;
+
+ const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
+ if (size != (UInt16)size)
+ return false;
+ dest.Alloc(size);
+ memset(dest, 0, size);
+ const UInt32 tag = isSymLink ?
+ Z7_WIN_IO_REPARSE_TAG_SYMLINK :
+ Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT;
+ Byte *p = dest;
+ Set32(p, tag)
+ Set16(p + 4, (UInt16)(size - 8))
+ Set16(p + 6, 0)
+ p += 8;
+
+ unsigned subOffs = 0;
+ unsigned printOffs = 0;
+ if (newOrderScheme)
+ subOffs = (unsigned)len2;
+ else
+ printOffs = (unsigned)len1 + 2;
+
+ Set16(p + 0, (UInt16)subOffs)
+ Set16(p + 2, (UInt16)len1)
+ Set16(p + 4, (UInt16)printOffs)
+ Set16(p + 6, (UInt16)len2)
+
+ p += 8;
+ if (isSymLink)
+ {
+ UInt32 flags = isAbs ? 0 : Z7_WIN_SYMLINK_FLAG_RELATIVE;
+ Set32(p, flags)
+ p += 4;
+ }
+
+ if (add_Prefix_Len != 0)
+ WriteString(p + subOffs, k_LinkPrefix);
+ WriteString(p + subOffs + add_Prefix_Len * 2, path);
+ if (needPrintName)
+ WriteString(p + printOffs, path);
+ return true;
+}
+
+#endif // defined(_WIN32) && !defined(UNDER_CE)
+
+
+static void GetString(const Byte *p, unsigned len, UString &res)
+{
+ wchar_t *s = res.GetBuf(len);
+ unsigned i;
+ for (i = 0; i < len; i++)
+ {
+ wchar_t c = Get16(p + i * 2);
+ if (c == 0)
+ break;
+ s[i] = c;
+ }
+ s[i] = 0;
+ res.ReleaseBuf_SetLen(i);
+}
+
+bool CReparseAttr::Parse(const Byte *p, size_t size)
+{
+ ErrorCode = (DWORD)ERROR_INVALID_REPARSE_DATA;
+ HeaderError = true;
+ TagIsUnknown = true;
+ MinorError = false;
+
+ if (size < 8)
+ return false;
+ Tag = Get32(p);
+ UInt32 len = Get16(p + 4);
+ if (len + 8 != size)
+ // if (len + 8 > size)
+ return false;
+ /*
+ if ((type & kReparseFlags_Alias) == 0 ||
+ (type & kReparseFlags_Microsoft) == 0 ||
+ (type & 0xFFFF) != 3)
+ */
+
+ if (Get16(p + 6) != 0) // padding
+ return false;
+
+ HeaderError = false;
+
+ if ( Tag != Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT
+ && Tag != Z7_WIN_IO_REPARSE_TAG_SYMLINK
+ && Tag != Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
+ {
+ // for unsupported reparse points
+ ErrorCode = (DWORD)ERROR_REPARSE_TAG_INVALID; // ERROR_REPARSE_TAG_MISMATCH
+ // errorCode = ERROR_REPARSE_TAG_MISMATCH; // ERROR_REPARSE_TAG_INVALID
+ return false;
+ }
+
+ TagIsUnknown = false;
+
+ p += 8;
+ size -= 8;
+
+ if (Tag == Z7_WIN_IO_REPARSE_TAG_LX_SYMLINK)
+ {
+ if (len < 4)
+ return false;
+ Flags = Get32(p); // maybe it's not Flags
+ if (Flags != Z7_WIN_LX_SYMLINK_FLAG)
+ return false;
+ len -= 4;
+ p += 4;
+ char *s = WslName.GetBuf(len);
+ unsigned i;
+ for (i = 0; i < len; i++)
+ {
+ char c = (char)p[i];
+ s[i] = c;
+ if (c == 0)
+ break;
+ }
+ WslName.ReleaseBuf_SetEnd(i);
+ MinorError = (i != len);
+ ErrorCode = 0;
+ return true;
+ }
+
+ if (len < 8)
+ return false;
+ unsigned subOffs = Get16(p);
+ unsigned subLen = Get16(p + 2);
+ unsigned printOffs = Get16(p + 4);
+ unsigned printLen = Get16(p + 6);
+ len -= 8;
+ p += 8;
+
+ Flags = 0;
+ if (Tag == Z7_WIN_IO_REPARSE_TAG_SYMLINK)
+ {
+ if (len < 4)
+ return false;
+ Flags = Get32(p);
+ len -= 4;
+ p += 4;
+ }
+
+ if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
+ return false;
+ if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
+ return false;
+ GetString(p + subOffs, subLen >> 1, SubsName);
+ GetString(p + printOffs, printLen >> 1, PrintName);
+
+ ErrorCode = 0;
+ return true;
+}
+
+
+bool CReparseShortInfo::Parse(const Byte *p, size_t size)
+{
+ const Byte *start = p;
+ Offset= 0;
+ Size = 0;
+ if (size < 8)
+ return false;
+ UInt32 Tag = Get32(p);
+ UInt32 len = Get16(p + 4);
+ if (len + 8 > size)
+ return false;
+ /*
+ if ((type & kReparseFlags_Alias) == 0 ||
+ (type & kReparseFlags_Microsoft) == 0 ||
+ (type & 0xFFFF) != 3)
+ */
+ if (Tag != Z7_WIN_IO_REPARSE_TAG_MOUNT_POINT &&
+ Tag != Z7_WIN_IO_REPARSE_TAG_SYMLINK)
+ // return true;
+ return false;
+
+ if (Get16(p + 6) != 0) // padding
+ return false;
+
+ p += 8;
+ size -= 8;
+
+ if (len != size) // do we need that check?
+ return false;
+
+ if (len < 8)
+ return false;
+ unsigned subOffs = Get16(p);
+ unsigned subLen = Get16(p + 2);
+ unsigned printOffs = Get16(p + 4);
+ unsigned printLen = Get16(p + 6);
+ len -= 8;
+ p += 8;
+
+ // UInt32 Flags = 0;
+ if (Tag == Z7_WIN_IO_REPARSE_TAG_SYMLINK)
+ {
+ if (len < 4)
+ return false;
+ // Flags = Get32(p);
+ len -= 4;
+ p += 4;
+ }
+
+ if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
+ return false;
+ if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
+ return false;
+
+ Offset = (unsigned)(p - start) + subOffs;
+ Size = subLen;
+ return true;
+}
+
+bool CReparseAttr::IsOkNamePair() const
+{
+ if (IsLinkPrefix(SubsName))
+ {
+ if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
+ return PrintName.IsEmpty();
+ if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
+ return true;
+ }
+ return wcscmp(SubsName, PrintName) == 0;
+}
+
+/*
+bool CReparseAttr::IsVolume() const
+{
+ if (!IsLinkPrefix(SubsName))
+ return false;
+ return IsVolumeName(SubsName.Ptr(k_LinkPrefix_Size));
+}
+*/
+
+UString CReparseAttr::GetPath() const
+{
+ if (IsSymLink_WSL())
+ {
+ UString u;
+ // if (CheckUTF8(attr.WslName)
+ if (!ConvertUTF8ToUnicode(WslName, u))
+ MultiByteToUnicodeString2(u, WslName);
+ return u;
+ }
+
+ UString s (SubsName);
+ if (IsLinkPrefix(s))
+ {
+ s.ReplaceOneCharAtPos(1, '\\'); // we normalize prefix from "\??\" to "\\?\"
+ if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
+ s.DeleteFrontal(k_LinkPrefix_Size);
+ }
+ return s;
+}
+
+#ifdef Z7_DEVICE_FILE
+
+namespace NSystem
+{
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
+}
+#endif // Z7_DEVICE_FILE
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+namespace NIO {
+
+bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo)
+{
+ reparseData.Free();
+ CInFile file;
+ if (!file.OpenReparse(path))
+ return false;
+
+ if (fileInfo)
+ file.GetFileInformation(fileInfo);
+
+ const unsigned kBufSize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
+ CByteArr buf(kBufSize);
+ DWORD returnedSize;
+ if (!file.DeviceIoControlOut(my_FSCTL_GET_REPARSE_POINT, buf, kBufSize, &returnedSize))
+ return false;
+ reparseData.CopyFrom(buf, returnedSize);
+ return true;
+}
+
+static bool CreatePrefixDirOfFile(CFSTR path)
+{
+ FString path2 (path);
+ int pos = path2.ReverseFind_PathSepar();
+ if (pos < 0)
+ return true;
+ #ifdef _WIN32
+ if (pos == 2 && path2[1] == L':')
+ return true; // we don't create Disk folder;
+ #endif
+ path2.DeleteFrom((unsigned)pos);
+ return NDir::CreateComplexDir(path2);
+}
+
+
+static bool OutIoReparseData(DWORD controlCode, CFSTR path, void *data, DWORD size)
+{
+ COutFile file;
+ if (!file.Open(path,
+ FILE_SHARE_WRITE,
+ OPEN_EXISTING,
+ FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS))
+ return false;
+
+ DWORD returnedSize;
+ return file.DeviceIoControl(controlCode, data, size, NULL, 0, &returnedSize);
+}
+
+
+// If there is Reparse data already, it still writes new Reparse data
+bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
+{
+ NFile::NFind::CFileInfo fi;
+ if (fi.Find(path))
+ {
+ if (fi.IsDir() != isDir)
+ {
+ ::SetLastError(ERROR_DIRECTORY);
+ return false;
+ }
+ }
+ else
+ {
+ if (isDir)
+ {
+ if (!NDir::CreateComplexDir(path))
+ return false;
+ }
+ else
+ {
+ CreatePrefixDirOfFile(path);
+ COutFile file;
+ if (!file.Create(path, CREATE_NEW))
+ return false;
+ }
+ }
+
+ return OutIoReparseData(my_FSCTL_SET_REPARSE_POINT, path, (void *)(const Byte *)(data), size);
+}
+
+
+bool DeleteReparseData(CFSTR path)
+{
+ CByteBuffer reparseData;
+ if (!GetReparseData(path, reparseData, NULL))
+ return false;
+ /* MSDN: The tag specified in the ReparseTag member of this structure
+ must match the tag of the reparse point to be deleted,
+ and the ReparseDataLength member must be zero */
+ #define my_REPARSE_DATA_BUFFER_HEADER_SIZE 8
+ if (reparseData.Size() < my_REPARSE_DATA_BUFFER_HEADER_SIZE)
+ {
+ SetLastError(ERROR_INVALID_REPARSE_DATA);
+ return false;
+ }
+ BYTE buf[my_REPARSE_DATA_BUFFER_HEADER_SIZE];
+ memset(buf, 0, sizeof(buf));
+ memcpy(buf, reparseData, 4); // tag
+ return OutIoReparseData(my_FSCTL_DELETE_REPARSE_POINT, path, buf, sizeof(buf));
+}
+
+}
+
+#endif // defined(_WIN32) && !defined(UNDER_CE)
+
+
+#ifndef _WIN32
+
+namespace NIO {
+
+bool GetReparseData(CFSTR path, CByteBuffer &reparseData)
+{
+ reparseData.Free();
+
+ #define MAX_PATHNAME_LEN 1024
+ char buf[MAX_PATHNAME_LEN + 2];
+ const size_t request = sizeof(buf) - 1;
+
+ // printf("\nreadlink() path = %s \n", path);
+ const ssize_t size = readlink(path, buf, request);
+ // there is no tail zero
+
+ if (size < 0)
+ return false;
+ if ((size_t)size >= request)
+ {
+ SetLastError(EINVAL); // check it: ENAMETOOLONG
+ return false;
+ }
+
+ // printf("\nreadlink() res = %s size = %d \n", buf, (int)size);
+ reparseData.CopyFrom((const Byte *)buf, (size_t)size);
+ return true;
+}
+
+
+/*
+// If there is Reparse data already, it still writes new Reparse data
+bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
+{
+ // AString s;
+ // s.SetFrom_CalcLen(data, size);
+ // return (symlink(s, path) == 0);
+ UNUSED_VAR(path)
+ UNUSED_VAR(isDir)
+ UNUSED_VAR(data)
+ UNUSED_VAR(size)
+ SetLastError(ENOSYS);
+ return false;
+}
+*/
+
+bool SetSymLink(CFSTR from, CFSTR to)
+{
+ // printf("\nsymlink() %s -> %s\n", from, to);
+ int ir;
+ // ir = unlink(path);
+ // if (ir == 0)
+ ir = symlink(to, from);
+ return (ir == 0);
+}
+
+bool SetSymLink_UString(CFSTR from, const UString &to)
+{
+ AString utf;
+ ConvertUnicodeToUTF8(to, utf);
+ return SetSymLink(from, utf);
+}
+
+}
+
+#endif // !_WIN32
+
+}}
diff --git a/CPP/Windows/FileMapping.cpp b/CPP/Windows/FileMapping.cpp
index 01c4a94..1933f7c 100644
--- a/CPP/Windows/FileMapping.cpp
+++ b/CPP/Windows/FileMapping.cpp
@@ -1,12 +1,12 @@
-// Windows/FileMapping.cpp
-
-#include "StdAfx.h"
-
-#include "FileMapping.h"
-
-namespace NWindows {
-namespace NFile {
-namespace NMapping {
-
-
-}}}
+// Windows/FileMapping.cpp
+
+#include "StdAfx.h"
+
+#include "FileMapping.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NMapping {
+
+
+}}}
diff --git a/CPP/Windows/FileMapping.h b/CPP/Windows/FileMapping.h
index 27d076b..caa7ea3 100644
--- a/CPP/Windows/FileMapping.h
+++ b/CPP/Windows/FileMapping.h
@@ -1,66 +1,66 @@
-// Windows/FileMapping.h
-
-#ifndef __WINDOWS_FILEMAPPING_H
-#define __WINDOWS_FILEMAPPING_H
-
-#include "../Common/MyTypes.h"
-
-#include "Handle.h"
-
-namespace NWindows {
-
-class CFileMapping: public CHandle
-{
-public:
- WRes Create(DWORD protect, UInt64 maxSize, LPCTSTR name)
- {
- _handle = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, protect, (DWORD)(maxSize >> 32), (DWORD)maxSize, name);
- return ::GetLastError();
- }
-
- WRes Open(DWORD
- #ifndef UNDER_CE
- desiredAccess
- #endif
- , LPCTSTR name)
- {
- #ifdef UNDER_CE
- WRes res = Create(PAGE_READONLY, 0, name);
- if (res == ERROR_ALREADY_EXISTS)
- return 0;
- Close();
- if (res == 0)
- res = ERROR_FILE_NOT_FOUND;
- return res;
- #else
- _handle = ::OpenFileMapping(desiredAccess, FALSE, name);
- if (_handle != 0)
- return 0;
- return ::GetLastError();
- #endif
- }
-
- LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap)
- {
- return ::MapViewOfFile(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap);
- }
-
- #ifndef UNDER_CE
- LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap, LPVOID baseAddress)
- {
- return ::MapViewOfFileEx(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap, baseAddress);
- }
- #endif
-};
-
-class CFileUnmapper
-{
- const void *_data;
-public:
- CFileUnmapper(const void *data) : _data(data) {}
- ~CFileUnmapper() { ::UnmapViewOfFile(_data); }
-};
-
-}
-
-#endif
+// Windows/FileMapping.h
+
+#ifndef ZIP7_INC_WINDOWS_FILE_MAPPING_H
+#define ZIP7_INC_WINDOWS_FILE_MAPPING_H
+
+#include "../Common/MyTypes.h"
+
+#include "Handle.h"
+
+namespace NWindows {
+
+class CFileMapping: public CHandle
+{
+public:
+ WRes Create(DWORD protect, UInt64 maxSize, LPCTSTR name)
+ {
+ _handle = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, protect, (DWORD)(maxSize >> 32), (DWORD)maxSize, name);
+ return ::GetLastError();
+ }
+
+ WRes Open(DWORD
+ #ifndef UNDER_CE
+ desiredAccess
+ #endif
+ , LPCTSTR name)
+ {
+ #ifdef UNDER_CE
+ WRes res = Create(PAGE_READONLY, 0, name);
+ if (res == ERROR_ALREADY_EXISTS)
+ return 0;
+ Close();
+ if (res == 0)
+ res = ERROR_FILE_NOT_FOUND;
+ return res;
+ #else
+ _handle = ::OpenFileMapping(desiredAccess, FALSE, name);
+ if (_handle != NULL)
+ return 0;
+ return ::GetLastError();
+ #endif
+ }
+
+ LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap)
+ {
+ return ::MapViewOfFile(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap);
+ }
+
+ #ifndef UNDER_CE
+ LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap, LPVOID baseAddress)
+ {
+ return ::MapViewOfFileEx(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap, baseAddress);
+ }
+ #endif
+};
+
+class CFileUnmapper
+{
+ const void *_data;
+public:
+ CFileUnmapper(const void *data) : _data(data) {}
+ ~CFileUnmapper() { ::UnmapViewOfFile(_data); }
+};
+
+}
+
+#endif
diff --git a/CPP/Windows/FileName.cpp b/CPP/Windows/FileName.cpp
index 2a227dc..c9c4f8b 100644
--- a/CPP/Windows/FileName.cpp
+++ b/CPP/Windows/FileName.cpp
@@ -1,839 +1,894 @@
-// Windows/FileName.cpp
-
-#include "StdAfx.h"
-
-#include "FileName.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NFile {
-namespace NName {
-
-#define IS_SEPAR(c) IS_PATH_SEPAR(c)
-
-int FindSepar(const wchar_t *s) throw()
-{
- for (const wchar_t *p = s;; p++)
- {
- const wchar_t c = *p;
- if (c == 0)
- return -1;
- if (IS_SEPAR(c))
- return (int)(p - s);
- }
-}
-
-#ifndef USE_UNICODE_FSTRING
-int FindSepar(const FChar *s) throw()
-{
- for (const FChar *p = s;; p++)
- {
- const FChar c = *p;
- if (c == 0)
- return -1;
- if (IS_SEPAR(c))
- return (int)(p - s);
- }
-}
-#endif
-
-#ifndef USE_UNICODE_FSTRING
-void NormalizeDirPathPrefix(FString &dirPath)
-{
- if (dirPath.IsEmpty())
- return;
- if (!IsPathSepar(dirPath.Back()))
- dirPath.Add_PathSepar();
-}
-#endif
-
-void NormalizeDirPathPrefix(UString &dirPath)
-{
- if (dirPath.IsEmpty())
- return;
- if (!IsPathSepar(dirPath.Back()))
- dirPath.Add_PathSepar();
-}
-
-#define IS_LETTER_CHAR(c) ((c) >= 'a' && (c) <= 'z' || (c) >= 'A' && (c) <= 'Z')
-
-bool IsDrivePath(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
-
-bool IsAltPathPrefix(CFSTR s) throw()
-{
- unsigned len = MyStringLen(s);
- if (len == 0)
- return false;
- if (s[len - 1] != ':')
- return false;
-
- #if defined(_WIN32) && !defined(UNDER_CE)
- if (IsDevicePath(s))
- return false;
- if (IsSuperPath(s))
- {
- s += kSuperPathPrefixSize;
- len -= kSuperPathPrefixSize;
- }
- if (len == 2 && IsDrivePath2(s))
- return false;
- #endif
-
- return true;
-}
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-const char * const kSuperPathPrefix = "\\\\?\\";
-static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
-
-#define IS_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '.' && IS_SEPAR((s)[3]))
-#define IS_SUPER_PREFIX(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '?' && IS_SEPAR((s)[3]))
-#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
-
-#define IS_UNC_WITH_SLASH(s) ( \
- ((s)[0] == 'U' || (s)[0] == 'u') \
- && ((s)[1] == 'N' || (s)[1] == 'n') \
- && ((s)[2] == 'C' || (s)[2] == 'c') \
- && IS_SEPAR((s)[3]))
-
-bool IsDevicePath(CFSTR s) throw()
-{
- #ifdef UNDER_CE
-
- s = s;
- return false;
- /*
- // actually we don't know the way to open device file in WinCE.
- unsigned len = MyStringLen(s);
- if (len < 5 || len > 5 || !IsString1PrefixedByString2(s, "DSK"))
- return false;
- if (s[4] != ':')
- return false;
- // for reading use SG_REQ sg; if (DeviceIoControl(dsk, IOCTL_DISK_READ));
- */
-
- #else
-
- if (!IS_DEVICE_PATH(s))
- return false;
- unsigned len = MyStringLen(s);
- if (len == 6 && s[5] == ':')
- return true;
- if (len < 18 || len > 22 || !IsString1PrefixedByString2(s + kDevicePathPrefixSize, "PhysicalDrive"))
- return false;
- for (unsigned i = 17; i < len; i++)
- if (s[i] < '0' || s[i] > '9')
- return false;
- return true;
-
- #endif
-}
-
-bool IsSuperUncPath(CFSTR s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
-bool IsNetworkPath(CFSTR s) throw()
-{
- if (!IS_SEPAR(s[0]) || !IS_SEPAR(s[1]))
- return false;
- if (IsSuperUncPath(s))
- return true;
- FChar c = s[2];
- return (c != '.' && c != '?');
-}
-
-unsigned GetNetworkServerPrefixSize(CFSTR s) throw()
-{
- if (!IS_SEPAR(s[0]) || !IS_SEPAR(s[1]))
- return 0;
- unsigned prefixSize = 2;
- if (IsSuperUncPath(s))
- prefixSize = kSuperUncPathPrefixSize;
- else
- {
- FChar c = s[2];
- if (c == '.' || c == '?')
- return 0;
- }
- int pos = FindSepar(s + prefixSize);
- if (pos < 0)
- return 0;
- return prefixSize + pos + 1;
-}
-
-bool IsNetworkShareRootPath(CFSTR s) throw()
-{
- unsigned prefixSize = GetNetworkServerPrefixSize(s);
- if (prefixSize == 0)
- return false;
- s += prefixSize;
- int pos = FindSepar(s);
- if (pos < 0)
- return true;
- return s[(unsigned)pos + 1] == 0;
-}
-
-static const unsigned kDrivePrefixSize = 3; /* c:\ */
-
-bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
-// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
-bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
-bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
-// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
-
-#ifndef USE_UNICODE_FSTRING
-bool IsDrivePath2(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
-// bool IsDriveName2(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
-bool IsDrivePath(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
-bool IsSuperPath(CFSTR s) throw() { return IS_SUPER_PREFIX(s); }
-bool IsSuperOrDevicePath(CFSTR s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
-#endif // USE_UNICODE_FSTRING
-
-bool IsDrivePath_SuperAllowed(CFSTR s) throw()
-{
- if (IsSuperPath(s))
- s += kSuperPathPrefixSize;
- return IsDrivePath(s);
-}
-
-bool IsDriveRootPath_SuperAllowed(CFSTR s) throw()
-{
- if (IsSuperPath(s))
- s += kSuperPathPrefixSize;
- return IsDrivePath(s) && s[kDrivePrefixSize] == 0;
-}
-
-bool IsAbsolutePath(const wchar_t *s) throw()
-{
- return IS_SEPAR(s[0]) || IsDrivePath2(s);
-}
-
-int FindAltStreamColon(CFSTR path) throw()
-{
- unsigned i = 0;
- if (IsDrivePath2(path))
- i = 2;
- int colonPos = -1;
- for (;; i++)
- {
- FChar c = path[i];
- if (c == 0)
- return colonPos;
- if (c == ':')
- {
- if (colonPos < 0)
- colonPos = i;
- continue;
- }
- if (IS_SEPAR(c))
- colonPos = -1;
- }
-}
-
-#ifndef USE_UNICODE_FSTRING
-
-static unsigned GetRootPrefixSize_Of_NetworkPath(CFSTR s)
-{
- // Network path: we look "server\path\" as root prefix
- int pos = FindSepar(s);
- if (pos < 0)
- return 0;
- int pos2 = FindSepar(s + (unsigned)pos + 1);
- if (pos2 < 0)
- return 0;
- return pos + pos2 + 2;
-}
-
-static unsigned GetRootPrefixSize_Of_SimplePath(CFSTR s)
-{
- if (IsDrivePath(s))
- return kDrivePrefixSize;
- if (!IS_SEPAR(s[0]))
- return 0;
- if (s[1] == 0 || !IS_SEPAR(s[1]))
- return 1;
- unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
- return (size == 0) ? 0 : 2 + size;
-}
-
-static unsigned GetRootPrefixSize_Of_SuperPath(CFSTR s)
-{
- if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
- {
- unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
- return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
- }
- // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
- int pos = FindSepar(s + kSuperPathPrefixSize);
- if (pos < 0)
- return 0;
- return kSuperPathPrefixSize + pos + 1;
-}
-
-unsigned GetRootPrefixSize(CFSTR s) throw()
-{
- if (IS_DEVICE_PATH(s))
- return kDevicePathPrefixSize;
- if (IsSuperPath(s))
- return GetRootPrefixSize_Of_SuperPath(s);
- return GetRootPrefixSize_Of_SimplePath(s);
-}
-
-#endif // USE_UNICODE_FSTRING
-
-static unsigned GetRootPrefixSize_Of_NetworkPath(const wchar_t *s) throw()
-{
- // Network path: we look "server\path\" as root prefix
- int pos = FindSepar(s);
- if (pos < 0)
- return 0;
- int pos2 = FindSepar(s + (unsigned)pos + 1);
- if (pos2 < 0)
- return 0;
- return pos + pos2 + 2;
-}
-
-static unsigned GetRootPrefixSize_Of_SimplePath(const wchar_t *s) throw()
-{
- if (IsDrivePath(s))
- return kDrivePrefixSize;
- if (!IS_SEPAR(s[0]))
- return 0;
- if (s[1] == 0 || !IS_SEPAR(s[1]))
- return 1;
- unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
- return (size == 0) ? 0 : 2 + size;
-}
-
-static unsigned GetRootPrefixSize_Of_SuperPath(const wchar_t *s) throw()
-{
- if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
- {
- unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
- return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
- }
- // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
- int pos = FindSepar(s + kSuperPathPrefixSize);
- if (pos < 0)
- return 0;
- return kSuperPathPrefixSize + pos + 1;
-}
-
-unsigned GetRootPrefixSize(const wchar_t *s) throw()
-{
- if (IS_DEVICE_PATH(s))
- return kDevicePathPrefixSize;
- if (IsSuperPath(s))
- return GetRootPrefixSize_Of_SuperPath(s);
- return GetRootPrefixSize_Of_SimplePath(s);
-}
-
-#else // _WIN32
-
-bool IsAbsolutePath(const wchar_t *s) { return IS_SEPAR(s[0]); }
-
-#ifndef USE_UNICODE_FSTRING
-unsigned GetRootPrefixSize(CFSTR s) { return IS_SEPAR(s[0]) ? 1 : 0; }
-#endif
-unsigned GetRootPrefixSize(const wchar_t *s) { return IS_SEPAR(s[0]) ? 1 : 0; }
-
-#endif // _WIN32
-
-
-#ifndef UNDER_CE
-
-static bool GetCurDir(UString &path)
-{
- path.Empty();
- DWORD needLength;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetCurrentDirectory(MAX_PATH + 1, s);
- path = fs2us(fas2fs(s));
- }
- else
- #endif
- {
- WCHAR s[MAX_PATH + 2];
- s[0] = 0;
- needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, s);
- path = s;
- }
- return (needLength > 0 && needLength <= MAX_PATH);
-}
-
-static bool ResolveDotsFolders(UString &s)
-{
- #ifdef _WIN32
- // s.Replace(L'/', WCHAR_PATH_SEPARATOR);
- #endif
-
- for (unsigned i = 0;;)
- {
- const wchar_t c = s[i];
- if (c == 0)
- return true;
- if (c == '.' && (i == 0 || IS_SEPAR(s[i - 1])))
- {
- const wchar_t c1 = s[i + 1];
- if (c1 == '.')
- {
- const wchar_t c2 = s[i + 2];
- if (IS_SEPAR(c2) || c2 == 0)
- {
- if (i == 0)
- return false;
- int k = i - 2;
- i += 2;
-
- for (;; k--)
- {
- if (k < 0)
- return false;
- if (!IS_SEPAR(s[(unsigned)k]))
- break;
- }
-
- do
- k--;
- while (k >= 0 && !IS_SEPAR(s[(unsigned)k]));
-
- unsigned num;
-
- if (k >= 0)
- {
- num = i - k;
- i = k;
- }
- else
- {
- num = (c2 == 0 ? i : (i + 1));
- i = 0;
- }
-
- s.Delete(i, num);
- continue;
- }
- }
- else if (IS_SEPAR(c1) || c1 == 0)
- {
- unsigned num = 2;
- if (i != 0)
- i--;
- else if (c1 == 0)
- num = 1;
- s.Delete(i, num);
- continue;
- }
- }
-
- i++;
- }
-}
-
-#endif // UNDER_CE
-
-#define LONG_PATH_DOTS_FOLDERS_PARSING
-
-
-/*
-Windows (at least 64-bit XP) can't resolve "." or ".." in paths that start with SuperPrefix \\?\
-To solve that problem we check such path:
- - super path contains "." or ".." - we use kSuperPathType_UseOnlySuper
- - super path doesn't contain "." or ".." - we use kSuperPathType_UseOnlyMain
-*/
-#ifdef LONG_PATH_DOTS_FOLDERS_PARSING
-#ifndef UNDER_CE
-static bool AreThereDotsFolders(CFSTR s)
-{
- for (unsigned i = 0;; i++)
- {
- FChar c = s[i];
- if (c == 0)
- return false;
- if (c == '.' && (i == 0 || IS_SEPAR(s[i - 1])))
- {
- FChar c1 = s[i + 1];
- if (c1 == 0 || IS_SEPAR(c1) ||
- (c1 == '.' && (s[i + 2] == 0 || IS_SEPAR(s[i + 2]))))
- return true;
- }
- }
-}
-#endif
-#endif // LONG_PATH_DOTS_FOLDERS_PARSING
-
-#ifdef WIN_LONG_PATH
-
-/*
-Most of Windows versions have problems, if some file or dir name
-contains '.' or ' ' at the end of name (Bad Path).
-To solve that problem, we always use Super Path ("\\?\" prefix and full path)
-in such cases. Note that "." and ".." are not bad names.
-
-There are 3 cases:
- 1) If the path is already Super Path, we use that path
- 2) If the path is not Super Path :
- 2.1) Bad Path; we use only Super Path.
- 2.2) Good Path; we use Main Path. If it fails, we use Super Path.
-
- NeedToUseOriginalPath returns:
- kSuperPathType_UseOnlyMain : Super already
- kSuperPathType_UseOnlySuper : not Super, Bad Path
- kSuperPathType_UseMainAndSuper : not Super, Good Path
-*/
-
-int GetUseSuperPathType(CFSTR s) throw()
-{
- if (IsSuperOrDevicePath(s))
- {
- #ifdef LONG_PATH_DOTS_FOLDERS_PARSING
- if ((s)[2] != '.')
- if (AreThereDotsFolders(s + kSuperPathPrefixSize))
- return kSuperPathType_UseOnlySuper;
- #endif
- return kSuperPathType_UseOnlyMain;
- }
-
- for (unsigned i = 0;; i++)
- {
- FChar c = s[i];
- if (c == 0)
- return kSuperPathType_UseMainAndSuper;
- if (c == '.' || c == ' ')
- {
- FChar c2 = s[i + 1];
- if (c2 == 0 || IS_SEPAR(c2))
- {
- // if it's "." or "..", it's not bad name.
- if (c == '.')
- {
- if (i == 0 || IS_SEPAR(s[i - 1]))
- continue;
- if (s[i - 1] == '.')
- {
- if (i - 1 == 0 || IS_SEPAR(s[i - 2]))
- continue;
- }
- }
- return kSuperPathType_UseOnlySuper;
- }
- }
- }
-}
-
-
-/*
- returns false in two cases:
- - if GetCurDir was used, and GetCurDir returned error.
- - if we can't resolve ".." name.
- if path is ".", "..", res is empty.
- if it's Super Path already, res is empty.
- for \**** , and if GetCurDir is not drive (c:\), res is empty
- for absolute paths, returns true, res is Super path.
-*/
-
-
-static bool GetSuperPathBase(CFSTR s, UString &res)
-{
- res.Empty();
-
- FChar c = s[0];
- if (c == 0)
- return true;
- if (c == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
- return true;
-
- if (IsSuperOrDevicePath(s))
- {
- #ifdef LONG_PATH_DOTS_FOLDERS_PARSING
-
- if ((s)[2] == '.')
- return true;
-
- // we will return true here, so we will try to use these problem paths.
-
- if (!AreThereDotsFolders(s + kSuperPathPrefixSize))
- return true;
-
- UString temp = fs2us(s);
- unsigned fixedSize = GetRootPrefixSize_Of_SuperPath(temp);
- if (fixedSize == 0)
- return true;
-
- UString rem = &temp[fixedSize];
- if (!ResolveDotsFolders(rem))
- return true;
-
- temp.DeleteFrom(fixedSize);
- res += temp;
- res += rem;
-
- #endif
-
- return true;
- }
-
- if (IS_SEPAR(c))
- {
- if (IS_SEPAR(s[1]))
- {
- UString temp = fs2us(s + 2);
- unsigned fixedSize = GetRootPrefixSize_Of_NetworkPath(temp);
- // we ignore that error to allow short network paths server\share?
- /*
- if (fixedSize == 0)
- return false;
- */
- UString rem = &temp[fixedSize];
- if (!ResolveDotsFolders(rem))
- return false;
- res += kSuperUncPrefix;
- temp.DeleteFrom(fixedSize);
- res += temp;
- res += rem;
- return true;
- }
- }
- else
- {
- if (IsDrivePath2(s))
- {
- UString temp = fs2us(s);
- unsigned prefixSize = 2;
- if (IsDrivePath(s))
- prefixSize = kDrivePrefixSize;
- UString rem = temp.Ptr(prefixSize);
- if (!ResolveDotsFolders(rem))
- return true;
- res += kSuperPathPrefix;
- temp.DeleteFrom(prefixSize);
- res += temp;
- res += rem;
- return true;
- }
- }
-
- UString curDir;
- if (!GetCurDir(curDir))
- return false;
- NormalizeDirPathPrefix(curDir);
-
- unsigned fixedSizeStart = 0;
- unsigned fixedSize = 0;
- const char *superMarker = NULL;
- if (IsSuperPath(curDir))
- {
- fixedSize = GetRootPrefixSize_Of_SuperPath(curDir);
- if (fixedSize == 0)
- return false;
- }
- else
- {
- if (IsDrivePath(curDir))
- {
- superMarker = kSuperPathPrefix;
- fixedSize = kDrivePrefixSize;
- }
- else
- {
- if (!IsPathSepar(curDir[0]) || !IsPathSepar(curDir[1]))
- return false;
- fixedSizeStart = 2;
- fixedSize = GetRootPrefixSize_Of_NetworkPath(curDir.Ptr(2));
- if (fixedSize == 0)
- return false;
- superMarker = kSuperUncPrefix;
- }
- }
-
- UString temp;
- if (IS_SEPAR(c))
- {
- temp = fs2us(s + 1);
- }
- else
- {
- temp += &curDir[fixedSizeStart + fixedSize];
- temp += fs2us(s);
- }
- if (!ResolveDotsFolders(temp))
- return false;
- if (superMarker)
- res += superMarker;
- res += curDir.Mid(fixedSizeStart, fixedSize);
- res += temp;
- return true;
-}
-
-
-/*
- In that case if GetSuperPathBase doesn't return new path, we don't need
- to use same path that was used as main path
-
- GetSuperPathBase superPath.IsEmpty() onlyIfNew
- false * * GetCurDir Error
- true false * use Super path
- true true true don't use any path, we already used mainPath
- true true false use main path as Super Path, we don't try mainMath
- That case is possible now if GetCurDir returns unknow
- type of path (not drive and not network)
-
- We can change that code if we want to try mainPath, if GetSuperPathBase returns error,
- and we didn't try mainPath still.
- If we want to work that way, we don't need to use GetSuperPathBase return code.
-*/
-
-bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew)
-{
- if (GetSuperPathBase(path, superPath))
- {
- if (superPath.IsEmpty())
- {
- // actually the only possible when onlyIfNew == true and superPath is empty
- // is case when
-
- if (onlyIfNew)
- return false;
- superPath = fs2us(path);
- }
- return true;
- }
- return false;
-}
-
-bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew)
-{
- if (!GetSuperPathBase(s1, d1) ||
- !GetSuperPathBase(s2, d2))
- return false;
- if (d1.IsEmpty() && d2.IsEmpty() && onlyIfNew)
- return false;
- if (d1.IsEmpty()) d1 = fs2us(s1);
- if (d2.IsEmpty()) d2 = fs2us(s2);
- return true;
-}
-
-
-/*
-// returns true, if we need additional use with New Super path.
-bool GetSuperPath(CFSTR path, UString &superPath)
-{
- if (GetSuperPathBase(path, superPath))
- return !superPath.IsEmpty();
- return false;
-}
-*/
-#endif // WIN_LONG_PATH
-
-bool GetFullPath(CFSTR dirPrefix, CFSTR s, FString &res)
-{
- res = s;
-
- #ifdef UNDER_CE
-
- if (!IS_SEPAR(s[0]))
- {
- if (!dirPrefix)
- return false;
- res = dirPrefix;
- res += s;
- }
-
- #else
-
- unsigned prefixSize = GetRootPrefixSize(s);
- if (prefixSize != 0)
- {
- if (!AreThereDotsFolders(s + prefixSize))
- return true;
-
- UString rem = fs2us(s + prefixSize);
- if (!ResolveDotsFolders(rem))
- return true; // maybe false;
- res.DeleteFrom(prefixSize);
- res += us2fs(rem);
- return true;
- }
-
- /*
- FChar c = s[0];
- if (c == 0)
- return true;
- if (c == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
- return true;
- if (IS_SEPAR(c) && IS_SEPAR(s[1]))
- return true;
- if (IsDrivePath(s))
- return true;
- */
-
- UString curDir;
- if (dirPrefix)
- curDir = fs2us(dirPrefix);
- else
- {
- if (!GetCurDir(curDir))
- return false;
- }
- NormalizeDirPathPrefix(curDir);
-
- unsigned fixedSize = 0;
-
- #ifdef _WIN32
-
- if (IsSuperPath(curDir))
- {
- fixedSize = GetRootPrefixSize_Of_SuperPath(curDir);
- if (fixedSize == 0)
- return false;
- }
- else
- {
- if (IsDrivePath(curDir))
- fixedSize = kDrivePrefixSize;
- else
- {
- if (!IsPathSepar(curDir[0]) || !IsPathSepar(curDir[1]))
- return false;
- fixedSize = GetRootPrefixSize_Of_NetworkPath(curDir.Ptr(2));
- if (fixedSize == 0)
- return false;
- fixedSize += 2;
- }
- }
-
- #endif // _WIN32
-
- UString temp;
- if (IS_SEPAR(s[0]))
- {
- temp = fs2us(s + 1);
- }
- else
- {
- temp += curDir.Ptr(fixedSize);
- temp += fs2us(s);
- }
- if (!ResolveDotsFolders(temp))
- return false;
- curDir.DeleteFrom(fixedSize);
- res = us2fs(curDir);
- res += us2fs(temp);
-
- #endif // UNDER_CE
-
- return true;
-}
-
-bool GetFullPath(CFSTR path, FString &fullPath)
-{
- return GetFullPath(NULL, path, fullPath);
-}
-
-}}}
+// Windows/FileName.cpp
+
+#include "StdAfx.h"
+
+#ifndef _WIN32
+#include <limits.h>
+#include <unistd.h>
+#include "../Common/StringConvert.h"
+#endif
+
+#include "FileDir.h"
+#include "FileName.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NFile {
+namespace NName {
+
+#define IS_SEPAR(c) IS_PATH_SEPAR(c)
+
+int FindSepar(const wchar_t *s) throw()
+{
+ for (const wchar_t *p = s;; p++)
+ {
+ const wchar_t c = *p;
+ if (c == 0)
+ return -1;
+ if (IS_SEPAR(c))
+ return (int)(p - s);
+ }
+}
+
+#ifndef USE_UNICODE_FSTRING
+int FindSepar(const FChar *s) throw()
+{
+ for (const FChar *p = s;; p++)
+ {
+ const FChar c = *p;
+ if (c == 0)
+ return -1;
+ if (IS_SEPAR(c))
+ return (int)(p - s);
+ }
+}
+#endif
+
+#ifndef USE_UNICODE_FSTRING
+void NormalizeDirPathPrefix(FString &dirPath)
+{
+ if (dirPath.IsEmpty())
+ return;
+ if (!IsPathSepar(dirPath.Back()))
+ dirPath.Add_PathSepar();
+}
+#endif
+
+void NormalizeDirPathPrefix(UString &dirPath)
+{
+ if (dirPath.IsEmpty())
+ return;
+ if (!IsPathSepar(dirPath.Back()))
+ dirPath.Add_PathSepar();
+}
+
+#ifdef _WIN32
+
+#ifndef USE_UNICODE_FSTRING
+#ifdef Z7_LONG_PATH
+static void NormalizeDirSeparators(UString &s)
+{
+ const unsigned len = s.Len();
+ for (unsigned i = 0; i < len; i++)
+ if (s[i] == '/')
+ s.ReplaceOneCharAtPos(i, WCHAR_PATH_SEPARATOR);
+}
+#endif
+#endif
+
+void NormalizeDirSeparators(FString &s)
+{
+ const unsigned len = s.Len();
+ for (unsigned i = 0; i < len; i++)
+ if (s[i] == '/')
+ s.ReplaceOneCharAtPos(i, FCHAR_PATH_SEPARATOR);
+}
+
+#endif
+
+
+#define IS_LETTER_CHAR(c) ((((unsigned)(int)(c) | 0x20) - (unsigned)'a' <= (unsigned)('z' - 'a')))
+
+bool IsDrivePath(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+
+bool IsAltPathPrefix(CFSTR s) throw()
+{
+ unsigned len = MyStringLen(s);
+ if (len == 0)
+ return false;
+ if (s[len - 1] != ':')
+ return false;
+
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ if (IsDevicePath(s))
+ return false;
+ if (IsSuperPath(s))
+ {
+ s += kSuperPathPrefixSize;
+ len -= kSuperPathPrefixSize;
+ }
+ if (len == 2 && IsDrivePath2(s))
+ return false;
+ #endif
+
+ return true;
+}
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+const char * const kSuperPathPrefix = "\\\\?\\";
+#ifdef Z7_LONG_PATH
+static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
+#endif
+
+#define IS_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '.' && IS_SEPAR((s)[3]))
+#define IS_SUPER_PREFIX(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '?' && IS_SEPAR((s)[3]))
+#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
+
+#define IS_UNC_WITH_SLASH(s) ( \
+ ((s)[0] == 'U' || (s)[0] == 'u') \
+ && ((s)[1] == 'N' || (s)[1] == 'n') \
+ && ((s)[2] == 'C' || (s)[2] == 'c') \
+ && IS_SEPAR((s)[3]))
+
+bool IsDevicePath(CFSTR s) throw()
+{
+ #ifdef UNDER_CE
+
+ s = s;
+ return false;
+ /*
+ // actually we don't know the way to open device file in WinCE.
+ unsigned len = MyStringLen(s);
+ if (len < 5 || len > 5 || !IsString1PrefixedByString2(s, "DSK"))
+ return false;
+ if (s[4] != ':')
+ return false;
+ // for reading use SG_REQ sg; if (DeviceIoControl(dsk, IOCTL_DISK_READ));
+ */
+
+ #else
+
+ if (!IS_DEVICE_PATH(s))
+ return false;
+ unsigned len = MyStringLen(s);
+ if (len == 6 && s[5] == ':')
+ return true;
+ if (len < 18 || len > 22 || !IsString1PrefixedByString2(s + kDevicePathPrefixSize, "PhysicalDrive"))
+ return false;
+ for (unsigned i = 17; i < len; i++)
+ if (s[i] < '0' || s[i] > '9')
+ return false;
+ return true;
+
+ #endif
+}
+
+bool IsSuperUncPath(CFSTR s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+bool IsNetworkPath(CFSTR s) throw()
+{
+ if (!IS_SEPAR(s[0]) || !IS_SEPAR(s[1]))
+ return false;
+ if (IsSuperUncPath(s))
+ return true;
+ FChar c = s[2];
+ return (c != '.' && c != '?');
+}
+
+unsigned GetNetworkServerPrefixSize(CFSTR s) throw()
+{
+ if (!IS_SEPAR(s[0]) || !IS_SEPAR(s[1]))
+ return 0;
+ unsigned prefixSize = 2;
+ if (IsSuperUncPath(s))
+ prefixSize = kSuperUncPathPrefixSize;
+ else
+ {
+ FChar c = s[2];
+ if (c == '.' || c == '?')
+ return 0;
+ }
+ const int pos = FindSepar(s + prefixSize);
+ if (pos < 0)
+ return 0;
+ return prefixSize + (unsigned)(pos + 1);
+}
+
+bool IsNetworkShareRootPath(CFSTR s) throw()
+{
+ const unsigned prefixSize = GetNetworkServerPrefixSize(s);
+ if (prefixSize == 0)
+ return false;
+ s += prefixSize;
+ const int pos = FindSepar(s);
+ if (pos < 0)
+ return true;
+ return s[(unsigned)pos + 1] == 0;
+}
+
+static const unsigned kDrivePrefixSize = 3; /* c:\ */
+
+bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
+// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
+bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
+bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
+// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+
+bool IsAltStreamPrefixWithColon(const UString &s) throw()
+{
+ if (s.IsEmpty())
+ return false;
+ if (s.Back() != ':')
+ return false;
+ unsigned pos = 0;
+ if (IsSuperPath(s))
+ pos = kSuperPathPrefixSize;
+ if (s.Len() - pos == 2 && IsDrivePath2(s.Ptr(pos)))
+ return false;
+ return true;
+}
+
+bool If_IsSuperPath_RemoveSuperPrefix(UString &s)
+{
+ if (!IsSuperPath(s))
+ return false;
+ unsigned start = 0;
+ unsigned count = kSuperPathPrefixSize;
+ const wchar_t *s2 = s.Ptr(kSuperPathPrefixSize);
+ if (IS_UNC_WITH_SLASH(s2))
+ {
+ start = 2;
+ count = kSuperUncPathPrefixSize - 2;
+ }
+ s.Delete(start, count);
+ return true;
+}
+
+
+#ifndef USE_UNICODE_FSTRING
+bool IsDrivePath2(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
+// bool IsDriveName2(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
+bool IsDrivePath(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+bool IsSuperPath(CFSTR s) throw() { return IS_SUPER_PREFIX(s); }
+bool IsSuperOrDevicePath(CFSTR s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
+#endif // USE_UNICODE_FSTRING
+
+bool IsDrivePath_SuperAllowed(CFSTR s) throw()
+{
+ if (IsSuperPath(s))
+ s += kSuperPathPrefixSize;
+ return IsDrivePath(s);
+}
+
+bool IsDriveRootPath_SuperAllowed(CFSTR s) throw()
+{
+ if (IsSuperPath(s))
+ s += kSuperPathPrefixSize;
+ return IsDrivePath(s) && s[kDrivePrefixSize] == 0;
+}
+
+bool IsAbsolutePath(const wchar_t *s) throw()
+{
+ return IS_SEPAR(s[0]) || IsDrivePath2(s);
+}
+
+int FindAltStreamColon(CFSTR path) throw()
+{
+ unsigned i = 0;
+ if (IsDrivePath2(path))
+ i = 2;
+ int colonPos = -1;
+ for (;; i++)
+ {
+ FChar c = path[i];
+ if (c == 0)
+ return colonPos;
+ if (c == ':')
+ {
+ if (colonPos < 0)
+ colonPos = (int)i;
+ continue;
+ }
+ if (IS_SEPAR(c))
+ colonPos = -1;
+ }
+}
+
+#ifndef USE_UNICODE_FSTRING
+
+static unsigned GetRootPrefixSize_Of_NetworkPath(CFSTR s)
+{
+ // Network path: we look "server\path\" as root prefix
+ int pos = FindSepar(s);
+ if (pos < 0)
+ return 0;
+ int pos2 = FindSepar(s + (unsigned)pos + 1);
+ if (pos2 < 0)
+ return 0;
+ return pos + pos2 + 2;
+}
+
+static unsigned GetRootPrefixSize_Of_SimplePath(CFSTR s)
+{
+ if (IsDrivePath(s))
+ return kDrivePrefixSize;
+ if (!IS_SEPAR(s[0]))
+ return 0;
+ if (s[1] == 0 || !IS_SEPAR(s[1]))
+ return 1;
+ const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+ return (size == 0) ? 0 : 2 + size;
+}
+
+static unsigned GetRootPrefixSize_Of_SuperPath(CFSTR s)
+{
+ if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
+ {
+ const unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+ return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
+ }
+ // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
+ const int pos = FindSepar(s + kSuperPathPrefixSize);
+ if (pos < 0)
+ return 0;
+ return kSuperPathPrefixSize + pos + 1;
+}
+
+unsigned GetRootPrefixSize(CFSTR s) throw()
+{
+ if (IS_DEVICE_PATH(s))
+ return kDevicePathPrefixSize;
+ if (IsSuperPath(s))
+ return GetRootPrefixSize_Of_SuperPath(s);
+ return GetRootPrefixSize_Of_SimplePath(s);
+}
+
+#endif // USE_UNICODE_FSTRING
+
+static unsigned GetRootPrefixSize_Of_NetworkPath(const wchar_t *s) throw()
+{
+ // Network path: we look "server\path\" as root prefix
+ int pos = FindSepar(s);
+ if (pos < 0)
+ return 0;
+ int pos2 = FindSepar(s + (unsigned)pos + 1);
+ if (pos2 < 0)
+ return 0;
+ return (unsigned)(pos + pos2 + 2);
+}
+
+static unsigned GetRootPrefixSize_Of_SimplePath(const wchar_t *s) throw()
+{
+ if (IsDrivePath(s))
+ return kDrivePrefixSize;
+ if (!IS_SEPAR(s[0]))
+ return 0;
+ if (s[1] == 0 || !IS_SEPAR(s[1]))
+ return 1;
+ unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+ return (size == 0) ? 0 : 2 + size;
+}
+
+static unsigned GetRootPrefixSize_Of_SuperPath(const wchar_t *s) throw()
+{
+ if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
+ {
+ unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+ return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
+ }
+ // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
+ int pos = FindSepar(s + kSuperPathPrefixSize);
+ if (pos < 0)
+ return 0;
+ return kSuperPathPrefixSize + (unsigned)(pos + 1);
+}
+
+unsigned GetRootPrefixSize(const wchar_t *s) throw()
+{
+ if (IS_DEVICE_PATH(s))
+ return kDevicePathPrefixSize;
+ if (IsSuperPath(s))
+ return GetRootPrefixSize_Of_SuperPath(s);
+ return GetRootPrefixSize_Of_SimplePath(s);
+}
+
+#else // _WIN32
+
+bool IsAbsolutePath(const wchar_t *s) throw() { return IS_SEPAR(s[0]); }
+
+#ifndef USE_UNICODE_FSTRING
+unsigned GetRootPrefixSize(CFSTR s) throw();
+unsigned GetRootPrefixSize(CFSTR s) throw() { return IS_SEPAR(s[0]) ? 1 : 0; }
+#endif
+unsigned GetRootPrefixSize(const wchar_t *s) throw() { return IS_SEPAR(s[0]) ? 1 : 0; }
+
+#endif // _WIN32
+
+
+#ifndef UNDER_CE
+
+
+#ifdef USE_UNICODE_FSTRING
+
+#define GetCurDir NDir::GetCurrentDir
+
+#else
+
+static bool GetCurDir(UString &path)
+{
+ path.Empty();
+ FString s;
+ if (!NDir::GetCurrentDir(s))
+ return false;
+ path = fs2us(s);
+ return true;
+}
+
+#endif
+
+
+static bool ResolveDotsFolders(UString &s)
+{
+ #ifdef _WIN32
+ // s.Replace(L'/', WCHAR_PATH_SEPARATOR);
+ #endif
+
+ for (unsigned i = 0;;)
+ {
+ const wchar_t c = s[i];
+ if (c == 0)
+ return true;
+ if (c == '.' && (i == 0 || IS_SEPAR(s[i - 1])))
+ {
+ const wchar_t c1 = s[i + 1];
+ if (c1 == '.')
+ {
+ const wchar_t c2 = s[i + 2];
+ if (IS_SEPAR(c2) || c2 == 0)
+ {
+ if (i == 0)
+ return false;
+ int k = (int)i - 2;
+ i += 2;
+
+ for (;; k--)
+ {
+ if (k < 0)
+ return false;
+ if (!IS_SEPAR(s[(unsigned)k]))
+ break;
+ }
+
+ do
+ k--;
+ while (k >= 0 && !IS_SEPAR(s[(unsigned)k]));
+
+ unsigned num;
+
+ if (k >= 0)
+ {
+ num = i - (unsigned)k;
+ i = (unsigned)k;
+ }
+ else
+ {
+ num = (c2 == 0 ? i : (i + 1));
+ i = 0;
+ }
+
+ s.Delete(i, num);
+ continue;
+ }
+ }
+ else if (IS_SEPAR(c1) || c1 == 0)
+ {
+ unsigned num = 2;
+ if (i != 0)
+ i--;
+ else if (c1 == 0)
+ num = 1;
+ s.Delete(i, num);
+ continue;
+ }
+ }
+
+ i++;
+ }
+}
+
+#endif // UNDER_CE
+
+#define LONG_PATH_DOTS_FOLDERS_PARSING
+
+
+/*
+Windows (at least 64-bit XP) can't resolve "." or ".." in paths that start with SuperPrefix \\?\
+To solve that problem we check such path:
+ - super path contains "." or ".." - we use kSuperPathType_UseOnlySuper
+ - super path doesn't contain "." or ".." - we use kSuperPathType_UseOnlyMain
+*/
+#ifdef LONG_PATH_DOTS_FOLDERS_PARSING
+#ifndef UNDER_CE
+static bool AreThereDotsFolders(CFSTR s)
+{
+ for (unsigned i = 0;; i++)
+ {
+ FChar c = s[i];
+ if (c == 0)
+ return false;
+ if (c == '.' && (i == 0 || IS_SEPAR(s[i - 1])))
+ {
+ FChar c1 = s[i + 1];
+ if (c1 == 0 || IS_SEPAR(c1) ||
+ (c1 == '.' && (s[i + 2] == 0 || IS_SEPAR(s[i + 2]))))
+ return true;
+ }
+ }
+}
+#endif
+#endif // LONG_PATH_DOTS_FOLDERS_PARSING
+
+#ifdef Z7_LONG_PATH
+
+/*
+Most of Windows versions have problems, if some file or dir name
+contains '.' or ' ' at the end of name (Bad Path).
+To solve that problem, we always use Super Path ("\\?\" prefix and full path)
+in such cases. Note that "." and ".." are not bad names.
+
+There are 3 cases:
+ 1) If the path is already Super Path, we use that path
+ 2) If the path is not Super Path :
+ 2.1) Bad Path; we use only Super Path.
+ 2.2) Good Path; we use Main Path. If it fails, we use Super Path.
+
+ NeedToUseOriginalPath returns:
+ kSuperPathType_UseOnlyMain : Super already
+ kSuperPathType_UseOnlySuper : not Super, Bad Path
+ kSuperPathType_UseMainAndSuper : not Super, Good Path
+*/
+
+int GetUseSuperPathType(CFSTR s) throw()
+{
+ if (IsSuperOrDevicePath(s))
+ {
+ #ifdef LONG_PATH_DOTS_FOLDERS_PARSING
+ if ((s)[2] != '.')
+ if (AreThereDotsFolders(s + kSuperPathPrefixSize))
+ return kSuperPathType_UseOnlySuper;
+ #endif
+ return kSuperPathType_UseOnlyMain;
+ }
+
+ for (unsigned i = 0;; i++)
+ {
+ FChar c = s[i];
+ if (c == 0)
+ return kSuperPathType_UseMainAndSuper;
+ if (c == '.' || c == ' ')
+ {
+ FChar c2 = s[i + 1];
+ if (c2 == 0 || IS_SEPAR(c2))
+ {
+ // if it's "." or "..", it's not bad name.
+ if (c == '.')
+ {
+ if (i == 0 || IS_SEPAR(s[i - 1]))
+ continue;
+ if (s[i - 1] == '.')
+ {
+ if (i - 1 == 0 || IS_SEPAR(s[i - 2]))
+ continue;
+ }
+ }
+ return kSuperPathType_UseOnlySuper;
+ }
+ }
+ }
+}
+
+
+
+/*
+ returns false in two cases:
+ - if GetCurDir was used, and GetCurDir returned error.
+ - if we can't resolve ".." name.
+ if path is ".", "..", res is empty.
+ if it's Super Path already, res is empty.
+ for \**** , and if GetCurDir is not drive (c:\), res is empty
+ for absolute paths, returns true, res is Super path.
+*/
+
+static bool GetSuperPathBase(CFSTR s, UString &res)
+{
+ res.Empty();
+
+ FChar c = s[0];
+ if (c == 0)
+ return true;
+ if (c == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
+ return true;
+
+ if (IsSuperOrDevicePath(s))
+ {
+ #ifdef LONG_PATH_DOTS_FOLDERS_PARSING
+
+ if ((s)[2] == '.')
+ return true;
+
+ // we will return true here, so we will try to use these problem paths.
+
+ if (!AreThereDotsFolders(s + kSuperPathPrefixSize))
+ return true;
+
+ UString temp = fs2us(s);
+ const unsigned fixedSize = GetRootPrefixSize_Of_SuperPath(temp);
+ if (fixedSize == 0)
+ return true;
+
+ UString rem = temp.Ptr(fixedSize);
+ if (!ResolveDotsFolders(rem))
+ return true;
+
+ temp.DeleteFrom(fixedSize);
+ res += temp;
+ res += rem;
+
+ #endif
+
+ return true;
+ }
+
+ if (IS_SEPAR(c))
+ {
+ if (IS_SEPAR(s[1]))
+ {
+ UString temp = fs2us(s + 2);
+ const unsigned fixedSize = GetRootPrefixSize_Of_NetworkPath(temp);
+ // we ignore that error to allow short network paths server\share?
+ /*
+ if (fixedSize == 0)
+ return false;
+ */
+ UString rem = temp.Ptr(fixedSize);
+ if (!ResolveDotsFolders(rem))
+ return false;
+ res += kSuperUncPrefix;
+ temp.DeleteFrom(fixedSize);
+ res += temp;
+ res += rem;
+ return true;
+ }
+ }
+ else
+ {
+ if (IsDrivePath2(s))
+ {
+ UString temp = fs2us(s);
+ unsigned prefixSize = 2;
+ if (IsDrivePath(s))
+ prefixSize = kDrivePrefixSize;
+ UString rem = temp.Ptr(prefixSize);
+ if (!ResolveDotsFolders(rem))
+ return true;
+ res += kSuperPathPrefix;
+ temp.DeleteFrom(prefixSize);
+ res += temp;
+ res += rem;
+ return true;
+ }
+ }
+
+ UString curDir;
+ if (!GetCurDir(curDir))
+ return false;
+ NormalizeDirPathPrefix(curDir);
+
+ unsigned fixedSizeStart = 0;
+ unsigned fixedSize = 0;
+ const char *superMarker = NULL;
+ if (IsSuperPath(curDir))
+ {
+ fixedSize = GetRootPrefixSize_Of_SuperPath(curDir);
+ if (fixedSize == 0)
+ return false;
+ }
+ else
+ {
+ if (IsDrivePath(curDir))
+ {
+ superMarker = kSuperPathPrefix;
+ fixedSize = kDrivePrefixSize;
+ }
+ else
+ {
+ if (!IsPathSepar(curDir[0]) || !IsPathSepar(curDir[1]))
+ return false;
+ fixedSizeStart = 2;
+ fixedSize = GetRootPrefixSize_Of_NetworkPath(curDir.Ptr(2));
+ if (fixedSize == 0)
+ return false;
+ superMarker = kSuperUncPrefix;
+ }
+ }
+
+ UString temp;
+ if (IS_SEPAR(c))
+ {
+ temp = fs2us(s + 1);
+ }
+ else
+ {
+ temp += &curDir[fixedSizeStart + fixedSize];
+ temp += fs2us(s);
+ }
+ if (!ResolveDotsFolders(temp))
+ return false;
+ if (superMarker)
+ res += superMarker;
+ res += curDir.Mid(fixedSizeStart, fixedSize);
+ res += temp;
+ return true;
+}
+
+
+/*
+ In that case if GetSuperPathBase doesn't return new path, we don't need
+ to use same path that was used as main path
+
+ GetSuperPathBase superPath.IsEmpty() onlyIfNew
+ false * * GetCurDir Error
+ true false * use Super path
+ true true true don't use any path, we already used mainPath
+ true true false use main path as Super Path, we don't try mainMath
+ That case is possible now if GetCurDir returns unknown
+ type of path (not drive and not network)
+
+ We can change that code if we want to try mainPath, if GetSuperPathBase returns error,
+ and we didn't try mainPath still.
+ If we want to work that way, we don't need to use GetSuperPathBase return code.
+*/
+
+bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew)
+{
+ if (GetSuperPathBase(path, superPath))
+ {
+ if (superPath.IsEmpty())
+ {
+ // actually the only possible when onlyIfNew == true and superPath is empty
+ // is case when
+
+ if (onlyIfNew)
+ return false;
+ superPath = fs2us(path);
+ }
+
+ NormalizeDirSeparators(superPath);
+ return true;
+ }
+ return false;
+}
+
+bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew)
+{
+ if (!GetSuperPathBase(s1, d1) ||
+ !GetSuperPathBase(s2, d2))
+ return false;
+
+ NormalizeDirSeparators(d1);
+ NormalizeDirSeparators(d2);
+
+ if (d1.IsEmpty() && d2.IsEmpty() && onlyIfNew)
+ return false;
+ if (d1.IsEmpty()) d1 = fs2us(s1);
+ if (d2.IsEmpty()) d2 = fs2us(s2);
+ return true;
+}
+
+
+/*
+// returns true, if we need additional use with New Super path.
+bool GetSuperPath(CFSTR path, UString &superPath)
+{
+ if (GetSuperPathBase(path, superPath))
+ return !superPath.IsEmpty();
+ return false;
+}
+*/
+#endif // Z7_LONG_PATH
+
+bool GetFullPath(CFSTR dirPrefix, CFSTR s, FString &res)
+{
+ res = s;
+
+ #ifdef UNDER_CE
+
+ if (!IS_SEPAR(s[0]))
+ {
+ if (!dirPrefix)
+ return false;
+ res = dirPrefix;
+ res += s;
+ }
+
+ #else
+
+ const unsigned prefixSize = GetRootPrefixSize(s);
+ if (prefixSize != 0)
+#ifdef _WIN32
+ if (prefixSize != 1)
+#endif
+ {
+ if (!AreThereDotsFolders(s + prefixSize))
+ return true;
+
+ UString rem = fs2us(s + prefixSize);
+ if (!ResolveDotsFolders(rem))
+ return true; // maybe false;
+ res.DeleteFrom(prefixSize);
+ res += us2fs(rem);
+ return true;
+ }
+
+ UString curDir;
+ if (dirPrefix && prefixSize == 0)
+ curDir = fs2us(dirPrefix); // we use (dirPrefix), only if (s) path is relative
+ else
+ {
+ if (!GetCurDir(curDir))
+ return false;
+ }
+ NormalizeDirPathPrefix(curDir);
+
+ unsigned fixedSize = GetRootPrefixSize(curDir);
+
+ UString temp;
+#ifdef _WIN32
+ if (prefixSize != 0)
+ {
+ /* (s) is absolute path, but only (prefixSize == 1) is possible here.
+ So for full resolving we need root of current folder and
+ relative part of (s). */
+ s += prefixSize;
+ // (s) is relative part now
+ if (fixedSize == 0)
+ {
+ // (curDir) is not absolute.
+ // That case is unexpected, but we support it too.
+ curDir.Empty();
+ curDir.Add_PathSepar();
+ fixedSize = 1;
+ // (curDir) now is just Separ character.
+ // So final (res) path later also will have Separ prefix.
+ }
+ }
+ else
+#endif // _WIN32
+ {
+ // (s) is relative path
+ temp = curDir.Ptr(fixedSize);
+ // (temp) is relative_part_of(curDir)
+ }
+ temp += fs2us(s);
+ if (!ResolveDotsFolders(temp))
+ return false;
+ curDir.DeleteFrom(fixedSize);
+ // (curDir) now contains only absolute prefix part
+ res = us2fs(curDir);
+ res += us2fs(temp);
+
+ #endif // UNDER_CE
+
+ return true;
+}
+
+
+bool GetFullPath(CFSTR path, FString &fullPath)
+{
+ return GetFullPath(NULL, path, fullPath);
+}
+
+}}}
diff --git a/CPP/Windows/FileName.h b/CPP/Windows/FileName.h
index 1e47098..219b656 100644
--- a/CPP/Windows/FileName.h
+++ b/CPP/Windows/FileName.h
@@ -1,115 +1,133 @@
-// Windows/FileName.h
-
-#ifndef __WINDOWS_FILE_NAME_H
-#define __WINDOWS_FILE_NAME_H
-
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NFile {
-namespace NName {
-
-int FindSepar(const wchar_t *s) throw();
-#ifndef USE_UNICODE_FSTRING
-int FindSepar(const FChar *s) throw();
-#endif
-
-void NormalizeDirPathPrefix(FString &dirPath); // ensures that it ended with '\\', if dirPath is not epmty
-void NormalizeDirPathPrefix(UString &dirPath);
-
-bool IsDrivePath(const wchar_t *s) throw(); // first 3 chars are drive chars like "a:\\"
-
-bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
-
-#if defined(_WIN32) && !defined(UNDER_CE)
-
-extern const char * const kSuperPathPrefix; /* \\?\ */
-const unsigned kDevicePathPrefixSize = 4;
-const unsigned kSuperPathPrefixSize = 4;
-const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
-
-bool IsDevicePath(CFSTR s) throw(); /* \\.\ */
-bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
-bool IsNetworkPath(CFSTR s) throw(); /* \\?\UNC\ or \\SERVER */
-
-/* GetNetworkServerPrefixSize() returns size of server prefix:
- \\?\UNC\SERVER\
- \\SERVER\
- in another cases it returns 0
-*/
-
-unsigned GetNetworkServerPrefixSize(CFSTR s) throw();
-
-bool IsNetworkShareRootPath(CFSTR s) throw(); /* \\?\UNC\SERVER\share or \\SERVER\share or with slash */
-
-bool IsDrivePath_SuperAllowed(CFSTR s) throw(); // first chars are drive chars like "a:\" or "\\?\a:\"
-bool IsDriveRootPath_SuperAllowed(CFSTR s) throw(); // exact drive root path "a:\" or "\\?\a:\"
-
-bool IsDrivePath2(const wchar_t *s) throw(); // first 2 chars are drive chars like "a:"
-// bool IsDriveName2(const wchar_t *s) throw(); // is drive name like "a:"
-bool IsSuperPath(const wchar_t *s) throw();
-bool IsSuperOrDevicePath(const wchar_t *s) throw();
-
-#ifndef USE_UNICODE_FSTRING
-bool IsDrivePath2(CFSTR s) throw(); // first 2 chars are drive chars like "a:"
-// bool IsDriveName2(CFSTR s) throw(); // is drive name like "a:"
-bool IsDrivePath(CFSTR s) throw();
-bool IsSuperPath(CFSTR s) throw();
-bool IsSuperOrDevicePath(CFSTR s) throw();
-
-/* GetRootPrefixSize() returns size of ROOT PREFIX for cases:
- \
- \\.\
- C:\
- \\?\C:\
- \\?\UNC\SERVER\Shared\
- \\SERVER\Shared\
- in another cases it returns 0
-*/
-
-unsigned GetRootPrefixSize(CFSTR s) throw();
-
-#endif
-
-int FindAltStreamColon(CFSTR path) throw();
-
-#endif // _WIN32
-
-bool IsAbsolutePath(const wchar_t *s) throw();
-unsigned GetRootPrefixSize(const wchar_t *s) throw();
-
-#ifdef WIN_LONG_PATH
-
-const int kSuperPathType_UseOnlyMain = 0;
-const int kSuperPathType_UseOnlySuper = 1;
-const int kSuperPathType_UseMainAndSuper = 2;
-
-int GetUseSuperPathType(CFSTR s) throw();
-bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew);
-bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew);
-
-#define USE_MAIN_PATH (__useSuperPathType != kSuperPathType_UseOnlySuper)
-#define USE_MAIN_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlySuper && __useSuperPathType2 != kSuperPathType_UseOnlySuper)
-
-#define USE_SUPER_PATH (__useSuperPathType != kSuperPathType_UseOnlyMain)
-#define USE_SUPER_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlyMain || __useSuperPathType2 != kSuperPathType_UseOnlyMain)
-
-#define IF_USE_MAIN_PATH int __useSuperPathType = GetUseSuperPathType(path); if (USE_MAIN_PATH)
-#define IF_USE_MAIN_PATH_2(x1, x2) \
- int __useSuperPathType1 = GetUseSuperPathType(x1); \
- int __useSuperPathType2 = GetUseSuperPathType(x2); \
- if (USE_MAIN_PATH_2)
-
-#else
-
-#define IF_USE_MAIN_PATH
-#define IF_USE_MAIN_PATH_2(x1, x2)
-
-#endif // WIN_LONG_PATH
-
-bool GetFullPath(CFSTR dirPrefix, CFSTR path, FString &fullPath);
-bool GetFullPath(CFSTR path, FString &fullPath);
-
-}}}
-
-#endif
+// Windows/FileName.h
+
+#ifndef ZIP7_INC_WINDOWS_FILE_NAME_H
+#define ZIP7_INC_WINDOWS_FILE_NAME_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NName {
+
+int FindSepar(const wchar_t *s) throw();
+#ifndef USE_UNICODE_FSTRING
+int FindSepar(const FChar *s) throw();
+#endif
+
+void NormalizeDirPathPrefix(FString &dirPath); // ensures that it ended with '\\', if dirPath is not epmty
+void NormalizeDirPathPrefix(UString &dirPath);
+
+#ifdef _WIN32
+void NormalizeDirSeparators(FString &s);
+#endif
+
+bool IsDrivePath(const wchar_t *s) throw(); // first 3 chars are drive chars like "a:\\"
+
+bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+extern const char * const kSuperPathPrefix; /* \\?\ */
+const unsigned kDevicePathPrefixSize = 4;
+const unsigned kSuperPathPrefixSize = 4;
+const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
+
+bool IsDevicePath(CFSTR s) throw(); /* \\.\ */
+bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
+bool IsNetworkPath(CFSTR s) throw(); /* \\?\UNC\ or \\SERVER */
+
+/* GetNetworkServerPrefixSize() returns size of server prefix:
+ \\?\UNC\SERVER\
+ \\SERVER\
+ in another cases it returns 0
+*/
+
+unsigned GetNetworkServerPrefixSize(CFSTR s) throw();
+
+bool IsNetworkShareRootPath(CFSTR s) throw(); /* \\?\UNC\SERVER\share or \\SERVER\share or with slash */
+
+bool IsDrivePath_SuperAllowed(CFSTR s) throw(); // first chars are drive chars like "a:\" or "\\?\a:\"
+bool IsDriveRootPath_SuperAllowed(CFSTR s) throw(); // exact drive root path "a:\" or "\\?\a:\"
+
+bool IsDrivePath2(const wchar_t *s) throw(); // first 2 chars are drive chars like "a:"
+// bool IsDriveName2(const wchar_t *s) throw(); // is drive name like "a:"
+bool IsSuperPath(const wchar_t *s) throw();
+bool IsSuperOrDevicePath(const wchar_t *s) throw();
+
+bool IsAltStreamPrefixWithColon(const UString &s) throw();
+// returns true, if super prefix was removed
+bool If_IsSuperPath_RemoveSuperPrefix(UString &s);
+
+#ifndef USE_UNICODE_FSTRING
+bool IsDrivePath2(CFSTR s) throw(); // first 2 chars are drive chars like "a:"
+// bool IsDriveName2(CFSTR s) throw(); // is drive name like "a:"
+bool IsDrivePath(CFSTR s) throw();
+bool IsSuperPath(CFSTR s) throw();
+bool IsSuperOrDevicePath(CFSTR s) throw();
+
+/* GetRootPrefixSize() returns size of ROOT PREFIX for cases:
+ \
+ \\.\
+ C:\
+ \\?\C:\
+ \\?\UNC\SERVER\Shared\
+ \\SERVER\Shared\
+ in another cases it returns 0
+*/
+
+unsigned GetRootPrefixSize(CFSTR s) throw();
+
+#endif
+
+int FindAltStreamColon(CFSTR path) throw();
+
+#endif // _WIN32
+
+bool IsAbsolutePath(const wchar_t *s) throw();
+unsigned GetRootPrefixSize(const wchar_t *s) throw();
+
+#ifdef Z7_LONG_PATH
+
+const int kSuperPathType_UseOnlyMain = 0;
+const int kSuperPathType_UseOnlySuper = 1;
+const int kSuperPathType_UseMainAndSuper = 2;
+
+int GetUseSuperPathType(CFSTR s) throw();
+bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew);
+bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew);
+
+#define USE_MAIN_PATH (_useSuperPathType != kSuperPathType_UseOnlySuper)
+#define USE_MAIN_PATH_2 (_useSuperPathType1 != kSuperPathType_UseOnlySuper && _useSuperPathType2 != kSuperPathType_UseOnlySuper)
+
+#define USE_SUPER_PATH (_useSuperPathType != kSuperPathType_UseOnlyMain)
+#define USE_SUPER_PATH_2 (_useSuperPathType1 != kSuperPathType_UseOnlyMain || _useSuperPathType2 != kSuperPathType_UseOnlyMain)
+
+#define IF_USE_MAIN_PATH int _useSuperPathType = GetUseSuperPathType(path); if (USE_MAIN_PATH)
+#define IF_USE_MAIN_PATH_2(x1, x2) \
+ int _useSuperPathType1 = GetUseSuperPathType(x1); \
+ int _useSuperPathType2 = GetUseSuperPathType(x2); \
+ if (USE_MAIN_PATH_2)
+
+#else
+
+#define IF_USE_MAIN_PATH
+#define IF_USE_MAIN_PATH_2(x1, x2)
+
+#endif // Z7_LONG_PATH
+
+/*
+ if (dirPrefix != NULL && (path) is relative)
+ {
+ (dirPrefix) will be used
+ result (fullPath) will contain prefix part of (dirPrefix).
+ }
+ Current_Dir path can be used in 2 cases:
+ 1) if (path) is relative && dirPrefix == NULL
+ 2) for _WIN32: if (path) is absolute starting wuth "\"
+*/
+bool GetFullPath(CFSTR dirPrefix, CFSTR path, FString &fullPath);
+bool GetFullPath(CFSTR path, FString &fullPath);
+
+}}}
+
+#endif
diff --git a/CPP/Windows/FileSystem.cpp b/CPP/Windows/FileSystem.cpp
index 9861062..6a262d9 100644
--- a/CPP/Windows/FileSystem.cpp
+++ b/CPP/Windows/FileSystem.cpp
@@ -1,131 +1,139 @@
-// Windows/FileSystem.cpp
-
-#include "StdAfx.h"
-
-#ifndef UNDER_CE
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "FileSystem.h"
-#include "Defs.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NFile {
-namespace NSystem {
-
-bool MyGetVolumeInformation(
- CFSTR rootPath,
- UString &volumeName,
- LPDWORD volumeSerialNumber,
- LPDWORD maximumComponentLength,
- LPDWORD fileSystemFlags,
- UString &fileSystemName)
-{
- BOOL res;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- TCHAR v[MAX_PATH + 2]; v[0] = 0;
- TCHAR f[MAX_PATH + 2]; f[0] = 0;
- res = GetVolumeInformation(fs2fas(rootPath),
- v, MAX_PATH,
- volumeSerialNumber, maximumComponentLength, fileSystemFlags,
- f, MAX_PATH);
- volumeName = MultiByteToUnicodeString(v);
- fileSystemName = MultiByteToUnicodeString(f);
- }
- else
- #endif
- {
- WCHAR v[MAX_PATH + 2]; v[0] = 0;
- WCHAR f[MAX_PATH + 2]; f[0] = 0;
- res = GetVolumeInformationW(fs2us(rootPath),
- v, MAX_PATH,
- volumeSerialNumber, maximumComponentLength, fileSystemFlags,
- f, MAX_PATH);
- volumeName = v;
- fileSystemName = f;
- }
- return BOOLToBool(res);
-}
-
-UINT MyGetDriveType(CFSTR pathName)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- return GetDriveType(fs2fas(pathName));
- }
- else
- #endif
- {
- return GetDriveTypeW(fs2us(pathName));
- }
-}
-
-typedef BOOL (WINAPI * GetDiskFreeSpaceExA_Pointer)(
- LPCSTR lpDirectoryName, // directory name
- PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
- PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
- PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
-);
-
-typedef BOOL (WINAPI * GetDiskFreeSpaceExW_Pointer)(
- LPCWSTR lpDirectoryName, // directory name
- PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
- PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
- PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
-);
-
-bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize)
-{
- DWORD numSectorsPerCluster, bytesPerSector, numFreeClusters, numClusters;
- bool sizeIsDetected = false;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- GetDiskFreeSpaceExA_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExA_Pointer)GetProcAddress(
- GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExA");
- if (pGetDiskFreeSpaceEx)
- {
- ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
- sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2fas(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
- totalSize = totalSize2.QuadPart;
- freeSize = freeSize2.QuadPart;
- }
- if (!::GetDiskFreeSpace(fs2fas(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
- return false;
- }
- else
- #endif
- {
- GetDiskFreeSpaceExW_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExW_Pointer)GetProcAddress(
- GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExW");
- if (pGetDiskFreeSpaceEx)
- {
- ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
- sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2us(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
- totalSize = totalSize2.QuadPart;
- freeSize = freeSize2.QuadPart;
- }
- if (!::GetDiskFreeSpaceW(fs2us(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
- return false;
- }
- clusterSize = (UInt64)bytesPerSector * (UInt64)numSectorsPerCluster;
- if (!sizeIsDetected)
- {
- totalSize = clusterSize * (UInt64)numClusters;
- freeSize = clusterSize * (UInt64)numFreeClusters;
- }
- return true;
-}
-
-}}}
-
-#endif
+// Windows/FileSystem.cpp
+
+#include "StdAfx.h"
+
+#ifndef UNDER_CE
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "FileSystem.h"
+#include "Defs.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NFile {
+namespace NSystem {
+
+#ifdef _WIN32
+
+bool MyGetVolumeInformation(
+ CFSTR rootPath,
+ UString &volumeName,
+ LPDWORD volumeSerialNumber,
+ LPDWORD maximumComponentLength,
+ LPDWORD fileSystemFlags,
+ UString &fileSystemName)
+{
+ BOOL res;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ TCHAR v[MAX_PATH + 2]; v[0] = 0;
+ TCHAR f[MAX_PATH + 2]; f[0] = 0;
+ res = GetVolumeInformation(fs2fas(rootPath),
+ v, MAX_PATH,
+ volumeSerialNumber, maximumComponentLength, fileSystemFlags,
+ f, MAX_PATH);
+ volumeName = MultiByteToUnicodeString(v);
+ fileSystemName = MultiByteToUnicodeString(f);
+ }
+ else
+ #endif
+ {
+ WCHAR v[MAX_PATH + 2]; v[0] = 0;
+ WCHAR f[MAX_PATH + 2]; f[0] = 0;
+ res = GetVolumeInformationW(fs2us(rootPath),
+ v, MAX_PATH,
+ volumeSerialNumber, maximumComponentLength, fileSystemFlags,
+ f, MAX_PATH);
+ volumeName = v;
+ fileSystemName = f;
+ }
+ return BOOLToBool(res);
+}
+
+UINT MyGetDriveType(CFSTR pathName)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ return GetDriveType(fs2fas(pathName));
+ }
+ else
+ #endif
+ {
+ return GetDriveTypeW(fs2us(pathName));
+ }
+}
+
+typedef BOOL (WINAPI * Func_GetDiskFreeSpaceExA)(
+ LPCSTR lpDirectoryName, // directory name
+ PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
+ PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
+ PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
+);
+
+typedef BOOL (WINAPI * Func_GetDiskFreeSpaceExW)(
+ LPCWSTR lpDirectoryName, // directory name
+ PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
+ PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
+ PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
+);
+
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize)
+{
+ DWORD numSectorsPerCluster, bytesPerSector, numFreeClusters, numClusters;
+ bool sizeIsDetected = false;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ const
+ Func_GetDiskFreeSpaceExA f = Z7_GET_PROC_ADDRESS(
+ Func_GetDiskFreeSpaceExA, GetModuleHandle(TEXT("kernel32.dll")),
+ "GetDiskFreeSpaceExA");
+ if (f)
+ {
+ ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
+ sizeIsDetected = BOOLToBool(f(fs2fas(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
+ totalSize = totalSize2.QuadPart;
+ freeSize = freeSize2.QuadPart;
+ }
+ if (!::GetDiskFreeSpace(fs2fas(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
+ return false;
+ }
+ else
+ #endif
+ {
+ const
+ Func_GetDiskFreeSpaceExW f = Z7_GET_PROC_ADDRESS(
+ Func_GetDiskFreeSpaceExW, GetModuleHandle(TEXT("kernel32.dll")),
+ "GetDiskFreeSpaceExW");
+ if (f)
+ {
+ ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
+ sizeIsDetected = BOOLToBool(f(fs2us(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
+ totalSize = totalSize2.QuadPart;
+ freeSize = freeSize2.QuadPart;
+ }
+ if (!::GetDiskFreeSpaceW(fs2us(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
+ return false;
+ }
+ clusterSize = (UInt64)bytesPerSector * (UInt64)numSectorsPerCluster;
+ if (!sizeIsDetected)
+ {
+ totalSize = clusterSize * (UInt64)numClusters;
+ freeSize = clusterSize * (UInt64)numFreeClusters;
+ }
+ return true;
+}
+
+#endif
+
+}}}
+
+#endif
diff --git a/CPP/Windows/FileSystem.h b/CPP/Windows/FileSystem.h
index b0149de..9f9e399 100644
--- a/CPP/Windows/FileSystem.h
+++ b/CPP/Windows/FileSystem.h
@@ -1,27 +1,31 @@
-// Windows/FileSystem.h
-
-#ifndef __WINDOWS_FILE_SYSTEM_H
-#define __WINDOWS_FILE_SYSTEM_H
-
-#include "../Common/MyString.h"
-#include "../Common/MyTypes.h"
-
-namespace NWindows {
-namespace NFile {
-namespace NSystem {
-
-bool MyGetVolumeInformation(
- CFSTR rootPath ,
- UString &volumeName,
- LPDWORD volumeSerialNumber,
- LPDWORD maximumComponentLength,
- LPDWORD fileSystemFlags,
- UString &fileSystemName);
-
-UINT MyGetDriveType(CFSTR pathName);
-
-bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
-
-}}}
-
-#endif
+// Windows/FileSystem.h
+
+#ifndef ZIP7_INC_WINDOWS_FILE_SYSTEM_H
+#define ZIP7_INC_WINDOWS_FILE_SYSTEM_H
+
+#include "../Common/MyString.h"
+#include "../Common/MyTypes.h"
+
+namespace NWindows {
+namespace NFile {
+namespace NSystem {
+
+#ifdef _WIN32
+
+bool MyGetVolumeInformation(
+ CFSTR rootPath ,
+ UString &volumeName,
+ LPDWORD volumeSerialNumber,
+ LPDWORD maximumComponentLength,
+ LPDWORD fileSystemFlags,
+ UString &fileSystemName);
+
+UINT MyGetDriveType(CFSTR pathName);
+
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
+
+#endif
+
+}}}
+
+#endif
diff --git a/CPP/Windows/Handle.h b/CPP/Windows/Handle.h
index 755eeb8..6ae09ec 100644
--- a/CPP/Windows/Handle.h
+++ b/CPP/Windows/Handle.h
@@ -1,37 +1,39 @@
-// Windows/Handle.h
-
-#ifndef __WINDOWS_HANDLE_H
-#define __WINDOWS_HANDLE_H
-
-namespace NWindows {
-
-class CHandle
-{
-protected:
- HANDLE _handle;
-public:
- operator HANDLE() { return _handle; }
- CHandle(): _handle(NULL) {}
- ~CHandle() { Close(); }
- bool IsCreated() const { return (_handle != NULL); }
- bool Close()
- {
- if (_handle == NULL)
- return true;
- if (!::CloseHandle(_handle))
- return false;
- _handle = NULL;
- return true;
- }
- void Attach(HANDLE handle) { _handle = handle; }
- HANDLE Detach()
- {
- HANDLE handle = _handle;
- _handle = NULL;
- return handle;
- }
-};
-
-}
-
-#endif
+// Windows/Handle.h
+
+#ifndef ZIP7_INC_WINDOWS_HANDLE_H
+#define ZIP7_INC_WINDOWS_HANDLE_H
+
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+
+class CHandle MY_UNCOPYABLE
+{
+protected:
+ HANDLE _handle;
+public:
+ operator HANDLE() { return _handle; }
+ CHandle(): _handle(NULL) {}
+ ~CHandle() { Close(); }
+ bool IsCreated() const { return (_handle != NULL); }
+ bool Close()
+ {
+ if (_handle == NULL)
+ return true;
+ if (!::CloseHandle(_handle))
+ return false;
+ _handle = NULL;
+ return true;
+ }
+ void Attach(HANDLE handle) { _handle = handle; }
+ HANDLE Detach()
+ {
+ const HANDLE handle = _handle;
+ _handle = NULL;
+ return handle;
+ }
+};
+
+}
+
+#endif
diff --git a/CPP/Windows/MemoryGlobal.cpp b/CPP/Windows/MemoryGlobal.cpp
new file mode 100644
index 0000000..2a22394
--- /dev/null
+++ b/CPP/Windows/MemoryGlobal.cpp
@@ -0,0 +1,36 @@
+// Windows/MemoryGlobal.cpp
+
+#include "StdAfx.h"
+
+#include "MemoryGlobal.h"
+
+namespace NWindows {
+namespace NMemory {
+
+bool CGlobal::Alloc(UINT flags, SIZE_T size) throw()
+{
+ HGLOBAL newBlock = ::GlobalAlloc(flags, size);
+ if (newBlock == NULL)
+ return false;
+ _global = newBlock;
+ return true;
+}
+
+bool CGlobal::Free() throw()
+{
+ if (_global == NULL)
+ return true;
+ _global = ::GlobalFree(_global);
+ return (_global == NULL);
+}
+
+bool CGlobal::ReAlloc(SIZE_T size) throw()
+{
+ HGLOBAL newBlock = ::GlobalReAlloc(_global, size, GMEM_MOVEABLE);
+ if (newBlock == NULL)
+ return false;
+ _global = newBlock;
+ return true;
+}
+
+}}
diff --git a/CPP/Windows/MemoryGlobal.h b/CPP/Windows/MemoryGlobal.h
new file mode 100644
index 0000000..6852591
--- /dev/null
+++ b/CPP/Windows/MemoryGlobal.h
@@ -0,0 +1,55 @@
+// Windows/MemoryGlobal.h
+
+#ifndef ZIP7_INC_WINDOWS_MEMORY_GLOBAL_H
+#define ZIP7_INC_WINDOWS_MEMORY_GLOBAL_H
+
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+namespace NMemory {
+
+class CGlobal
+{
+ HGLOBAL _global;
+public:
+ CGlobal(): _global(NULL) {}
+ ~CGlobal() { Free(); }
+ operator HGLOBAL() const { return _global; }
+ void Attach(HGLOBAL hGlobal)
+ {
+ Free();
+ _global = hGlobal;
+ }
+ HGLOBAL Detach()
+ {
+ const HGLOBAL h = _global;
+ _global = NULL;
+ return h;
+ }
+ bool Alloc(UINT flags, SIZE_T size) throw();
+ bool Free() throw();
+ LPVOID Lock() const { return GlobalLock(_global); }
+ void Unlock() const { GlobalUnlock(_global); }
+ bool ReAlloc(SIZE_T size) throw();
+};
+
+class CGlobalLock
+{
+ HGLOBAL _global;
+ LPVOID _ptr;
+public:
+ LPVOID GetPointer() const { return _ptr; }
+ CGlobalLock(HGLOBAL hGlobal): _global(hGlobal)
+ {
+ _ptr = GlobalLock(hGlobal);
+ }
+ ~CGlobalLock()
+ {
+ if (_ptr)
+ GlobalUnlock(_global);
+ }
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/MemoryLock.cpp b/CPP/Windows/MemoryLock.cpp
index d1b3bcc..0bd7504 100644
--- a/CPP/Windows/MemoryLock.cpp
+++ b/CPP/Windows/MemoryLock.cpp
@@ -1,112 +1,124 @@
-// Windows/MemoryLock.cpp
-
-#include "StdAfx.h"
-
-#include "../../C/CpuArch.h"
-
-#include "MemoryLock.h"
-
-namespace NWindows {
-namespace NSecurity {
-
-#ifndef UNDER_CE
-
-#ifdef _UNICODE
-#define MY_FUNC_SELECT(f) :: f
-#else
-#define MY_FUNC_SELECT(f) my_ ## f
-extern "C" {
-typedef BOOL (WINAPI * Func_OpenProcessToken)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
-typedef BOOL (WINAPI * Func_LookupPrivilegeValue)(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid);
-typedef BOOL (WINAPI * Func_AdjustTokenPrivileges)(HANDLE TokenHandle, BOOL DisableAllPrivileges,
- PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
-}
-#define GET_PROC_ADDR(fff, name) Func_ ## fff my_ ## fff = (Func_ ## fff)GetProcAddress(hModule, name)
-#endif
-
-bool EnablePrivilege(LPCTSTR privilegeName, bool enable)
-{
- bool res = false;
-
- #ifndef _UNICODE
-
- HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
- if (hModule == NULL)
- return false;
-
- GET_PROC_ADDR(OpenProcessToken, "OpenProcessToken");
- GET_PROC_ADDR(LookupPrivilegeValue, "LookupPrivilegeValueA");
- GET_PROC_ADDR(AdjustTokenPrivileges, "AdjustTokenPrivileges");
-
- if (my_OpenProcessToken &&
- my_AdjustTokenPrivileges &&
- my_LookupPrivilegeValue)
-
- #endif
-
- {
- HANDLE token;
- if (MY_FUNC_SELECT(OpenProcessToken)(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))
- {
- TOKEN_PRIVILEGES tp;
- if (MY_FUNC_SELECT(LookupPrivilegeValue)(NULL, privilegeName, &(tp.Privileges[0].Luid)))
- {
- tp.PrivilegeCount = 1;
- tp.Privileges[0].Attributes = (enable ? SE_PRIVILEGE_ENABLED : 0);
- if (MY_FUNC_SELECT(AdjustTokenPrivileges)(token, FALSE, &tp, 0, NULL, NULL))
- res = (GetLastError() == ERROR_SUCCESS);
- }
- ::CloseHandle(token);
- }
- }
-
- #ifndef _UNICODE
-
- ::FreeLibrary(hModule);
-
- #endif
-
- return res;
-}
-
-
-
-typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
-
-/*
- We suppose that Window 10 works incorrectly with "Large Pages" at:
- - Windows 10 1703 (15063)
- - Windows 10 1709 (16299)
-
- - Windows 10 1809 (17763) on some CPUs that have no 1 GB page support.
- We need more information about that new BUG in Windows.
-*/
-
-unsigned Get_LargePages_RiskLevel()
-{
- OSVERSIONINFOEXW vi;
- HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
- if (!ntdll)
- return 0;
- Func_RtlGetVersion func = (Func_RtlGetVersion)GetProcAddress(ntdll, "RtlGetVersion");
- if (!func)
- return 0;
- func(&vi);
- if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
- return 0;
- if (vi.dwMajorVersion + vi.dwMinorVersion != 10)
- return 0;
- if (vi.dwBuildNumber <= 16299)
- return 1;
-
- #ifdef MY_CPU_X86_OR_AMD64
- if (!CPU_IsSupported_PageGB())
- return 1;
- #endif
-
- return 0;
-}
-
-#endif
-
-}}
+// Windows/MemoryLock.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#include "MemoryLock.h"
+
+namespace NWindows {
+namespace NSecurity {
+
+#ifndef UNDER_CE
+
+#ifdef _UNICODE
+#define MY_FUNC_SELECT(f) :: f
+#else
+#define MY_FUNC_SELECT(f) my_ ## f
+extern "C" {
+typedef BOOL (WINAPI * Func_OpenProcessToken)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
+typedef BOOL (WINAPI * Func_LookupPrivilegeValue)(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid);
+typedef BOOL (WINAPI * Func_AdjustTokenPrivileges)(HANDLE TokenHandle, BOOL DisableAllPrivileges,
+ PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
+}
+
+#define GET_PROC_ADDR(fff, name) \
+ const Func_ ## fff my_ ## fff = Z7_GET_PROC_ADDRESS( \
+ Func_ ## fff, hModule, name);
+#endif
+
+bool EnablePrivilege(LPCTSTR privilegeName, bool enable)
+{
+ bool res = false;
+
+ #ifndef _UNICODE
+
+ const HMODULE hModule = ::LoadLibrary(TEXT("advapi32.dll"));
+ if (!hModule)
+ return false;
+
+ GET_PROC_ADDR(
+ OpenProcessToken,
+ "OpenProcessToken")
+ GET_PROC_ADDR(
+ LookupPrivilegeValue,
+ "LookupPrivilegeValueA")
+ GET_PROC_ADDR(
+ AdjustTokenPrivileges,
+ "AdjustTokenPrivileges")
+
+ if (my_OpenProcessToken &&
+ my_AdjustTokenPrivileges &&
+ my_LookupPrivilegeValue)
+
+ #endif
+
+ {
+ HANDLE token;
+ if (MY_FUNC_SELECT(OpenProcessToken)(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))
+ {
+ TOKEN_PRIVILEGES tp;
+ if (MY_FUNC_SELECT(LookupPrivilegeValue)(NULL, privilegeName, &(tp.Privileges[0].Luid)))
+ {
+ tp.PrivilegeCount = 1;
+ tp.Privileges[0].Attributes = (enable ? SE_PRIVILEGE_ENABLED : 0);
+ if (MY_FUNC_SELECT(AdjustTokenPrivileges)(token, FALSE, &tp, 0, NULL, NULL))
+ res = (GetLastError() == ERROR_SUCCESS);
+ }
+ ::CloseHandle(token);
+ }
+ }
+
+ #ifndef _UNICODE
+
+ ::FreeLibrary(hModule);
+
+ #endif
+
+ return res;
+}
+
+
+
+typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
+
+/*
+ We suppose that Window 10 works incorrectly with "Large Pages" at:
+ - Windows 10 1703 (15063) : incorrect allocating after VirtualFree()
+ - Windows 10 1709 (16299) : incorrect allocating after VirtualFree()
+ - Windows 10 1809 (17763) : the failures for blocks of 1 GiB and larger,
+ if CPU doesn't support 1 GB pages.
+ Windows 10 1903 (18362) probably works correctly.
+*/
+
+unsigned Get_LargePages_RiskLevel()
+{
+ OSVERSIONINFOEXW vi;
+ const HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
+ if (!ntdll)
+ return 0;
+ const
+ Func_RtlGetVersion func = Z7_GET_PROC_ADDRESS(
+ Func_RtlGetVersion, ntdll,
+ "RtlGetVersion");
+ if (!func)
+ return 0;
+ func(&vi);
+ if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+ return 0;
+ if (vi.dwMajorVersion + vi.dwMinorVersion != 10)
+ return 0;
+ if (vi.dwBuildNumber <= 16299)
+ return 1;
+
+ #ifdef MY_CPU_X86_OR_AMD64
+ if (vi.dwBuildNumber < 18362 && !CPU_IsSupported_PageGB())
+ return 1;
+ #endif
+
+ return 0;
+}
+
+#endif
+
+}}
diff --git a/CPP/Windows/MemoryLock.h b/CPP/Windows/MemoryLock.h
index d82910f..2b85002 100644
--- a/CPP/Windows/MemoryLock.h
+++ b/CPP/Windows/MemoryLock.h
@@ -1,40 +1,40 @@
-// Windows/MemoryLock.h
-
-#ifndef __WINDOWS_MEMORY_LOCK_H
-#define __WINDOWS_MEMORY_LOCK_H
-
-#include "../Common/MyWindows.h"
-
-namespace NWindows {
-namespace NSecurity {
-
-#ifndef UNDER_CE
-
-bool EnablePrivilege(LPCTSTR privilegeName, bool enable = true);
-
-inline bool EnablePrivilege_LockMemory(bool enable = true)
-{
- return EnablePrivilege(SE_LOCK_MEMORY_NAME, enable);
-}
-
-inline void EnablePrivilege_SymLink()
-{
- /* Probably we do not to set any Privilege for junction points.
- But we need them for Symbolic links */
- NSecurity::EnablePrivilege(SE_RESTORE_NAME);
-
- /* Probably we need only SE_RESTORE_NAME, but there is also
- SE_CREATE_SYMBOLIC_LINK_NAME. So we set it also. Do we need it? */
-
- NSecurity::EnablePrivilege(TEXT("SeCreateSymbolicLinkPrivilege")); // SE_CREATE_SYMBOLIC_LINK_NAME
-
- // Do we need to set SE_BACKUP_NAME ?
-}
-
-unsigned Get_LargePages_RiskLevel();
-
-#endif
-
-}}
-
-#endif
+// Windows/MemoryLock.h
+
+#ifndef ZIP7_INC_WINDOWS_MEMORY_LOCK_H
+#define ZIP7_INC_WINDOWS_MEMORY_LOCK_H
+
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+namespace NSecurity {
+
+#ifndef UNDER_CE
+
+bool EnablePrivilege(LPCTSTR privilegeName, bool enable = true);
+
+inline bool EnablePrivilege_LockMemory(bool enable = true)
+{
+ return EnablePrivilege(SE_LOCK_MEMORY_NAME, enable);
+}
+
+inline void EnablePrivilege_SymLink()
+{
+ /* Probably we do not to set any Privilege for junction points.
+ But we need them for Symbolic links */
+ NSecurity::EnablePrivilege(SE_RESTORE_NAME);
+
+ /* Probably we need only SE_RESTORE_NAME, but there is also
+ SE_CREATE_SYMBOLIC_LINK_NAME. So we set it also. Do we need it? */
+
+ NSecurity::EnablePrivilege(TEXT("SeCreateSymbolicLinkPrivilege")); // SE_CREATE_SYMBOLIC_LINK_NAME
+
+ // Do we need to set SE_BACKUP_NAME ?
+}
+
+unsigned Get_LargePages_RiskLevel();
+
+#endif
+
+}}
+
+#endif
diff --git a/CPP/Windows/Menu.cpp b/CPP/Windows/Menu.cpp
new file mode 100644
index 0000000..af54c66
--- /dev/null
+++ b/CPP/Windows/Menu.cpp
@@ -0,0 +1,265 @@
+// Windows/Menu.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+#include "Menu.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+/*
+structures
+ MENUITEMINFOA
+ MENUITEMINFOW
+contain additional member:
+ #if (WINVER >= 0x0500)
+ HBITMAP hbmpItem;
+ #endif
+If we compile the source code with (WINVER >= 0x0500), some functions
+will not work at NT4, if cbSize is set as sizeof(MENUITEMINFO).
+So we use size of old version of structure in some conditions.
+Win98 probably supports full structure including hbmpItem.
+
+We have 2 ways to get/set string in menu item:
+win95/NT4: we must use MIIM_TYPE only.
+ MIIM_TYPE : Retrieves or sets the fType and dwTypeData members.
+win98/win2000: there are new flags that can be used instead of MIIM_TYPE:
+ MIIM_FTYPE : Retrieves or sets the fType member.
+ MIIM_STRING : Retrieves or sets the dwTypeData member.
+
+Windows versions probably support MIIM_TYPE flag, if we set MENUITEMINFO::cbSize
+as sizeof of old (small) MENUITEMINFO that doesn't include (hbmpItem) field.
+But do all Windows versions support old MIIM_TYPE flag, if we use
+MENUITEMINFO::cbSize as sizeof of new (big) MENUITEMINFO including (hbmpItem) field ?
+win10 probably supports any combination of small/big (cbSize) and old/new MIIM_TYPE/MIIM_STRING.
+*/
+
+#if defined(UNDER_CE) || defined(_WIN64) || (WINVER < 0x0500)
+ #ifndef _UNICODE
+ #define my_compatib_MENUITEMINFOA_size sizeof(MENUITEMINFOA)
+ #endif
+ #define my_compatib_MENUITEMINFOW_size sizeof(MENUITEMINFOW)
+#else
+ #define MY_STRUCT_SIZE_BEFORE(structname, member) ((UINT)(UINT_PTR)((LPBYTE)(&((structname*)0)->member) - (LPBYTE)(structname*)0))
+ #ifndef _UNICODE
+ #define my_compatib_MENUITEMINFOA_size MY_STRUCT_SIZE_BEFORE(MENUITEMINFOA, hbmpItem)
+ #endif
+ #define my_compatib_MENUITEMINFOW_size MY_STRUCT_SIZE_BEFORE(MENUITEMINFOW, hbmpItem)
+#if defined(__clang__) && __clang_major__ >= 13
+// error : performing pointer subtraction with a null pointer may have undefined behavior
+#pragma GCC diagnostic ignored "-Wnull-pointer-subtraction"
+#endif
+#endif
+
+
+#define COPY_MENUITEM_field(d, s, name) \
+ d.name = s.name;
+
+#define COPY_MENUITEM_fields(d, s) \
+ COPY_MENUITEM_field(d, s, fMask) \
+ COPY_MENUITEM_field(d, s, fType) \
+ COPY_MENUITEM_field(d, s, fState) \
+ COPY_MENUITEM_field(d, s, wID) \
+ COPY_MENUITEM_field(d, s, hSubMenu) \
+ COPY_MENUITEM_field(d, s, hbmpChecked) \
+ COPY_MENUITEM_field(d, s, hbmpUnchecked) \
+ COPY_MENUITEM_field(d, s, dwItemData) \
+
+static void ConvertItemToSysForm(const CMenuItem &item, MENUITEMINFOW &si)
+{
+ ZeroMemory(&si, sizeof(si));
+ si.cbSize = my_compatib_MENUITEMINFOW_size; // sizeof(si);
+ COPY_MENUITEM_fields(si, item)
+}
+
+#ifndef _UNICODE
+static void ConvertItemToSysForm(const CMenuItem &item, MENUITEMINFOA &si)
+{
+ ZeroMemory(&si, sizeof(si));
+ si.cbSize = my_compatib_MENUITEMINFOA_size; // sizeof(si);
+ COPY_MENUITEM_fields(si, item)
+}
+#endif
+
+static void ConvertItemToMyForm(const MENUITEMINFOW &si, CMenuItem &item)
+{
+ COPY_MENUITEM_fields(item, si)
+}
+
+#ifndef _UNICODE
+static void ConvertItemToMyForm(const MENUITEMINFOA &si, CMenuItem &item)
+{
+ COPY_MENUITEM_fields(item, si)
+}
+#endif
+
+
+bool CMenu::GetItem(UINT itemIndex, bool byPosition, CMenuItem &item) const
+{
+ item.StringValue.Empty();
+ const unsigned kMaxSize = 512;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ MENUITEMINFOA si;
+ ConvertItemToSysForm(item, si);
+ const bool isString = item.IsString();
+ unsigned bufSize = kMaxSize;
+ AString a;
+ if (isString)
+ {
+ si.cch = bufSize;
+ si.dwTypeData = a.GetBuf(bufSize);
+ }
+ bool res = GetItemInfo(itemIndex, byPosition, &si);
+ if (isString)
+ a.ReleaseBuf_CalcLen(bufSize);
+ if (!res)
+ return false;
+ {
+ if (isString && si.cch >= bufSize - 1)
+ {
+ si.dwTypeData = NULL;
+ res = GetItemInfo(itemIndex, byPosition, &si);
+ if (!res)
+ return false;
+ si.cch++;
+ bufSize = si.cch;
+ si.dwTypeData = a.GetBuf(bufSize);
+ res = GetItemInfo(itemIndex, byPosition, &si);
+ a.ReleaseBuf_CalcLen(bufSize);
+ if (!res)
+ return false;
+ }
+ ConvertItemToMyForm(si, item);
+ if (isString)
+ item.StringValue = GetUnicodeString(a);
+ return true;
+ }
+ }
+ else
+ #endif
+ {
+ wchar_t s[kMaxSize + 1];
+ s[0] = 0;
+ MENUITEMINFOW si;
+ ConvertItemToSysForm(item, si);
+ const bool isString = item.IsString();
+ unsigned bufSize = kMaxSize;
+ if (isString)
+ {
+ si.cch = bufSize;
+ si.dwTypeData = s;
+ }
+ bool res = GetItemInfo(itemIndex, byPosition, &si);
+ if (!res)
+ return false;
+ if (isString)
+ {
+ s[Z7_ARRAY_SIZE(s) - 1] = 0;
+ item.StringValue = s;
+ if (si.cch >= bufSize - 1)
+ {
+ si.dwTypeData = NULL;
+ res = GetItemInfo(itemIndex, byPosition, &si);
+ if (!res)
+ return false;
+ si.cch++;
+ bufSize = si.cch;
+ si.dwTypeData = item.StringValue.GetBuf(bufSize);
+ res = GetItemInfo(itemIndex, byPosition, &si);
+ item.StringValue.ReleaseBuf_CalcLen(bufSize);
+ if (!res)
+ return false;
+ }
+ // if (item.StringValue.Len() != si.cch) throw 123; // for debug
+ }
+ ConvertItemToMyForm(si, item);
+ return true;
+ }
+}
+
+
+bool CMenu::SetItem(UINT itemIndex, bool byPosition, const CMenuItem &item)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ MENUITEMINFOA si;
+ ConvertItemToSysForm(item, si);
+ AString s;
+ if (item.IsString())
+ {
+ s = GetSystemString(item.StringValue);
+ si.dwTypeData = s.Ptr_non_const();
+ }
+ return SetItemInfo(itemIndex, byPosition, &si);
+ }
+ else
+ #endif
+ {
+ MENUITEMINFOW si;
+ ConvertItemToSysForm(item, si);
+ if (item.IsString())
+ si.dwTypeData = item.StringValue.Ptr_non_const();
+ return SetItemInfo(itemIndex, byPosition, &si);
+ }
+}
+
+
+bool CMenu::InsertItem(UINT itemIndex, bool byPosition, const CMenuItem &item)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ MENUITEMINFOA si;
+ ConvertItemToSysForm(item, si);
+ AString s;
+ if (item.IsString())
+ {
+ s = GetSystemString(item.StringValue);
+ si.dwTypeData = s.Ptr_non_const();
+ }
+ return InsertItem(itemIndex, byPosition, &si);
+ }
+ else
+ #endif
+ {
+ MENUITEMINFOW si;
+ ConvertItemToSysForm(item, si);
+ if (item.IsString())
+ si.dwTypeData = item.StringValue.Ptr_non_const();
+ #ifdef UNDER_CE
+ UINT flags = (item.fType & MFT_SEPARATOR) ? MF_SEPARATOR : MF_STRING;
+ UINT_PTR id = item.wID;
+ if ((item.fMask & MIIM_SUBMENU) != 0)
+ {
+ flags |= MF_POPUP;
+ id = (UINT_PTR)item.hSubMenu;
+ }
+ if (!Insert(itemIndex, flags | (byPosition ? MF_BYPOSITION : MF_BYCOMMAND), id, item.StringValue))
+ return false;
+ return SetItemInfo(itemIndex, byPosition, &si);
+ #else
+ return InsertItem(itemIndex, byPosition, &si);
+ #endif
+ }
+}
+
+#ifndef _UNICODE
+bool CMenu::AppendItem(UINT flags, UINT_PTR newItemID, LPCWSTR newItem)
+{
+ if (g_IsNT)
+ return BOOLToBool(::AppendMenuW(_menu, flags, newItemID, newItem));
+ else
+ return AppendItem(flags, newItemID, GetSystemString(newItem));
+}
+#endif
+
+}
diff --git a/CPP/Windows/Menu.h b/CPP/Windows/Menu.h
new file mode 100644
index 0000000..e1de4c4
--- /dev/null
+++ b/CPP/Windows/Menu.h
@@ -0,0 +1,170 @@
+// Windows/Menu.h
+
+#ifndef ZIP7_INC_WINDOWS_MENU_H
+#define ZIP7_INC_WINDOWS_MENU_H
+
+#include "../Common/MyWindows.h"
+#include "../Common/MyString.h"
+
+#include "Defs.h"
+
+namespace NWindows {
+
+#ifndef MIIM_STRING
+#define MIIM_STRING 0x00000040
+#endif
+/*
+#ifndef MIIM_BITMAP
+#define MIIM_BITMAP 0x00000080
+#endif
+*/
+#ifndef MIIM_FTYPE
+#define MIIM_FTYPE 0x00000100
+#endif
+
+struct CMenuItem
+{
+ UString StringValue;
+ UINT fMask;
+ UINT fType;
+ UINT fState;
+ UINT wID;
+ HMENU hSubMenu;
+ HBITMAP hbmpChecked;
+ HBITMAP hbmpUnchecked;
+ ULONG_PTR dwItemData;
+ // LPTSTR dwTypeData;
+ // UINT cch;
+ // HBITMAP hbmpItem;
+ bool IsString() const { return (fMask & (MIIM_TYPE | MIIM_STRING)) != 0; }
+ bool IsSeparator() const { return (fType == MFT_SEPARATOR); }
+ CMenuItem(): fMask(0), fType(0), fState(0), wID(0),
+ hSubMenu(NULL), hbmpChecked(NULL), hbmpUnchecked(NULL), dwItemData(0) {}
+};
+
+class CMenu
+{
+ HMENU _menu;
+public:
+ CMenu(): _menu(NULL) {}
+ operator HMENU() const { return _menu; }
+ void Attach(HMENU menu) { _menu = menu; }
+
+ HMENU Detach()
+ {
+ const HMENU menu = _menu;
+ _menu = NULL;
+ return menu;
+ }
+
+ bool Create()
+ {
+ _menu = ::CreateMenu();
+ return (_menu != NULL);
+ }
+
+ bool CreatePopup()
+ {
+ _menu = ::CreatePopupMenu();
+ return (_menu != NULL);
+ }
+
+ bool Destroy()
+ {
+ if (!_menu)
+ return false;
+ return BOOLToBool(::DestroyMenu(Detach()));
+ }
+
+ int GetItemCount() const
+ {
+ #ifdef UNDER_CE
+ for (unsigned i = 0;; i++)
+ {
+ CMenuItem item;
+ item.fMask = MIIM_STATE;
+ if (!GetItem(i, true, item))
+ return (int)i;
+ }
+ #else
+ return GetMenuItemCount(_menu);
+ #endif
+ }
+
+ HMENU GetSubMenu(int pos) const { return ::GetSubMenu(_menu, pos); }
+ #ifndef UNDER_CE
+ /*
+ bool GetItemString(UINT idItem, UINT flag, CSysString &result)
+ {
+ result.Empty();
+ int len = ::GetMenuString(_menu, idItem, 0, 0, flag);
+ int len2 = ::GetMenuString(_menu, idItem, result.GetBuf(len + 2), len + 1, flag);
+ if (len > len2)
+ len = len2;
+ result.ReleaseBuf_CalcLen(len + 2);
+ return (len != 0);
+ }
+ */
+ UINT GetItemID(int pos) const { return ::GetMenuItemID(_menu, pos); }
+ UINT GetItemState(UINT id, UINT flags) const { return ::GetMenuState(_menu, id, flags); }
+ #endif
+
+ bool GetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFO itemInfo) const
+ { return BOOLToBool(::GetMenuItemInfo(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
+ bool SetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFO itemInfo)
+ { return BOOLToBool(::SetMenuItemInfo(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
+
+ bool AppendItem(UINT flags, UINT_PTR newItemID, LPCTSTR newItem)
+ { return BOOLToBool(::AppendMenu(_menu, flags, newItemID, newItem)); }
+
+ bool Insert(UINT position, UINT flags, UINT_PTR idNewItem, LPCTSTR newItem)
+ { return BOOLToBool(::InsertMenu(_menu, position, flags, idNewItem, newItem)); }
+
+ #ifndef UNDER_CE
+ bool InsertItem(UINT itemIndex, bool byPosition, LPCMENUITEMINFO itemInfo)
+ { return BOOLToBool(::InsertMenuItem(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
+ #endif
+
+ bool RemoveItem(UINT item, UINT flags) { return BOOLToBool(::RemoveMenu(_menu, item, flags)); }
+ void RemoveAllItemsFrom(UINT index) { while (RemoveItem(index, MF_BYPOSITION)); }
+ void RemoveAllItems() { RemoveAllItemsFrom(0); }
+
+ #ifndef _UNICODE
+ bool GetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo) const
+ { return BOOLToBool(::GetMenuItemInfoW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
+ bool InsertItem(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
+ { return BOOLToBool(::InsertMenuItemW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
+ bool SetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
+ { return BOOLToBool(::SetMenuItemInfoW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
+ bool AppendItem(UINT flags, UINT_PTR newItemID, LPCWSTR newItem);
+ #endif
+
+ bool GetItem(UINT itemIndex, bool byPosition, CMenuItem &item) const;
+ bool SetItem(UINT itemIndex, bool byPosition, const CMenuItem &item);
+ bool InsertItem(UINT itemIndex, bool byPosition, const CMenuItem &item);
+
+ int Track(UINT flags, int x, int y, HWND hWnd) { return ::TrackPopupMenuEx(_menu, flags, x, y, hWnd, NULL); }
+
+ bool CheckRadioItem(UINT idFirst, UINT idLast, UINT idCheck, UINT flags)
+ { return BOOLToBool(::CheckMenuRadioItem(_menu, idFirst, idLast, idCheck, flags)); }
+
+ DWORD CheckItem(UINT id, UINT uCheck) { return ::CheckMenuItem(_menu, id, uCheck); }
+ DWORD CheckItemByID(UINT id, bool check) { return CheckItem(id, MF_BYCOMMAND | (check ? MF_CHECKED : MF_UNCHECKED)); }
+
+ BOOL EnableItem(UINT uIDEnableItem, UINT uEnable) { return EnableMenuItem(_menu, uIDEnableItem, uEnable); }
+};
+
+class CMenuDestroyer
+{
+ CMenu *_menu;
+public:
+ CMenuDestroyer(CMenu &menu): _menu(&menu) {}
+ CMenuDestroyer(): _menu(NULL) {}
+ ~CMenuDestroyer() { if (_menu) _menu->Destroy(); }
+ void Attach(CMenu &menu) { _menu = &menu; }
+ void Disable() { _menu = NULL; }
+};
+
+}
+
+#endif
diff --git a/CPP/Windows/NationalTime.cpp b/CPP/Windows/NationalTime.cpp
new file mode 100644
index 0000000..d3c38de
--- /dev/null
+++ b/CPP/Windows/NationalTime.cpp
@@ -0,0 +1,37 @@
+// Windows/NationalTime.cpp
+
+#include "StdAfx.h"
+
+#include "NationalTime.h"
+
+namespace NWindows {
+namespace NNational {
+namespace NTime {
+
+bool MyGetTimeFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
+ LPCTSTR format, CSysString &resultString)
+{
+ resultString.Empty();
+ int numChars = ::GetTimeFormat(locale, flags, time, format, NULL, 0);
+ if (numChars == 0)
+ return false;
+ numChars = ::GetTimeFormat(locale, flags, time, format,
+ resultString.GetBuf((unsigned)numChars), numChars + 1);
+ resultString.ReleaseBuf_CalcLen((unsigned)numChars);
+ return (numChars != 0);
+}
+
+bool MyGetDateFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
+ LPCTSTR format, CSysString &resultString)
+{
+ resultString.Empty();
+ int numChars = ::GetDateFormat(locale, flags, time, format, NULL, 0);
+ if (numChars == 0)
+ return false;
+ numChars = ::GetDateFormat(locale, flags, time, format,
+ resultString.GetBuf((unsigned)numChars), numChars + 1);
+ resultString.ReleaseBuf_CalcLen((unsigned)numChars);
+ return (numChars != 0);
+}
+
+}}}
diff --git a/CPP/Windows/NationalTime.h b/CPP/Windows/NationalTime.h
new file mode 100644
index 0000000..32ba479
--- /dev/null
+++ b/CPP/Windows/NationalTime.h
@@ -0,0 +1,20 @@
+// Windows/NationalTime.h
+
+#ifndef ZIP7_INC_WINDOWS_NATIONAL_TIME_H
+#define ZIP7_INC_WINDOWS_NATIONAL_TIME_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NNational {
+namespace NTime {
+
+bool MyGetTimeFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
+ LPCTSTR format, CSysString &resultString);
+
+bool MyGetDateFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
+ LPCTSTR format, CSysString &resultString);
+
+}}}
+
+#endif
diff --git a/CPP/Windows/Net.cpp b/CPP/Windows/Net.cpp
new file mode 100644
index 0000000..0ac82d4
--- /dev/null
+++ b/CPP/Windows/Net.cpp
@@ -0,0 +1,398 @@
+// Windows/Net.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/MyBuffer.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "Net.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+extern "C"
+{
+#if !defined(WNetGetResourceParent)
+// #if defined(Z7_OLD_WIN_SDK)
+// #if (WINVER >= 0x0400)
+DWORD APIENTRY WNetGetResourceParentA(IN LPNETRESOURCEA lpNetResource,
+ OUT LPVOID lpBuffer, IN OUT LPDWORD lpcbBuffer);
+DWORD APIENTRY WNetGetResourceParentW(IN LPNETRESOURCEW lpNetResource,
+ OUT LPVOID lpBuffer, IN OUT LPDWORD lpcbBuffer);
+#ifdef UNICODE
+#define WNetGetResourceParent WNetGetResourceParentW
+#else
+#define WNetGetResourceParent WNetGetResourceParentA
+#endif
+
+DWORD APIENTRY WNetGetResourceInformationA(IN LPNETRESOURCEA lpNetResource,
+ OUT LPVOID lpBuffer, IN OUT LPDWORD lpcbBuffer, OUT LPSTR *lplpSystem);
+DWORD APIENTRY WNetGetResourceInformationW(IN LPNETRESOURCEW lpNetResource,
+ OUT LPVOID lpBuffer, IN OUT LPDWORD lpcbBuffer, OUT LPWSTR *lplpSystem);
+#ifdef UNICODE
+#define WNetGetResourceInformation WNetGetResourceInformationW
+#else
+#define WNetGetResourceInformation WNetGetResourceInformationA
+#endif
+// #endif // (WINVER >= 0x0400)
+#endif
+}
+
+namespace NWindows {
+namespace NNet {
+
+DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCE netResource)
+{
+ Close();
+ const DWORD result = ::WNetOpenEnum(scope, type, usage, netResource, &_handle);
+ _handleAllocated = (result == NO_ERROR);
+ return result;
+}
+
+#ifndef _UNICODE
+DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCEW netResource)
+{
+ Close();
+ const DWORD result = ::WNetOpenEnumW(scope, type, usage, netResource, &_handle);
+ _handleAllocated = (result == NO_ERROR);
+ return result;
+}
+#endif
+
+static void SetComplexString(bool &defined, CSysString &destString, LPCTSTR srcString)
+{
+ defined = (srcString != NULL);
+ if (defined)
+ destString = srcString;
+ else
+ destString.Empty();
+}
+
+static void ConvertNETRESOURCEToCResource(const NETRESOURCE &netResource, CResource &resource)
+{
+ resource.Scope = netResource.dwScope;
+ resource.Type = netResource.dwType;
+ resource.DisplayType = netResource.dwDisplayType;
+ resource.Usage = netResource.dwUsage;
+ SetComplexString(resource.LocalNameIsDefined, resource.LocalName, netResource.lpLocalName);
+ SetComplexString(resource.RemoteNameIsDefined, resource.RemoteName, netResource.lpRemoteName);
+ SetComplexString(resource.CommentIsDefined, resource.Comment, netResource.lpComment);
+ SetComplexString(resource.ProviderIsDefined, resource.Provider, netResource.lpProvider);
+}
+
+static void SetComplexString2(LPTSTR *destString, bool defined, const CSysString &srcString)
+{
+ if (defined)
+ *destString = srcString.Ptr_non_const();
+ else
+ *destString = NULL;
+}
+
+static void ConvertCResourceToNETRESOURCE(const CResource &resource, NETRESOURCE &netResource)
+{
+ netResource.dwScope = resource.Scope;
+ netResource.dwType = resource.Type;
+ netResource.dwDisplayType = resource.DisplayType;
+ netResource.dwUsage = resource.Usage;
+ SetComplexString2(&netResource.lpLocalName, resource.LocalNameIsDefined, resource.LocalName);
+ SetComplexString2(&netResource.lpRemoteName, resource.RemoteNameIsDefined, resource.RemoteName);
+ SetComplexString2(&netResource.lpComment, resource.CommentIsDefined, resource.Comment);
+ SetComplexString2(&netResource.lpProvider, resource.ProviderIsDefined, resource.Provider);
+}
+
+#ifndef _UNICODE
+
+static void SetComplexString(bool &defined, UString &destString, LPCWSTR src)
+{
+ defined = (src != NULL);
+ if (defined)
+ destString = src;
+ else
+ destString.Empty();
+}
+
+static void ConvertNETRESOURCEToCResource(const NETRESOURCEW &netResource, CResourceW &resource)
+{
+ resource.Scope = netResource.dwScope;
+ resource.Type = netResource.dwType;
+ resource.DisplayType = netResource.dwDisplayType;
+ resource.Usage = netResource.dwUsage;
+ SetComplexString(resource.LocalNameIsDefined, resource.LocalName, netResource.lpLocalName);
+ SetComplexString(resource.RemoteNameIsDefined, resource.RemoteName, netResource.lpRemoteName);
+ SetComplexString(resource.CommentIsDefined, resource.Comment, netResource.lpComment);
+ SetComplexString(resource.ProviderIsDefined, resource.Provider, netResource.lpProvider);
+}
+
+static void SetComplexString2(LPWSTR *destString, bool defined, const UString &srcString)
+{
+ if (defined)
+ *destString = srcString.Ptr_non_const();
+ else
+ *destString = NULL;
+}
+
+static void ConvertCResourceToNETRESOURCE(const CResourceW &resource, NETRESOURCEW &netResource)
+{
+ netResource.dwScope = resource.Scope;
+ netResource.dwType = resource.Type;
+ netResource.dwDisplayType = resource.DisplayType;
+ netResource.dwUsage = resource.Usage;
+ SetComplexString2(&netResource.lpLocalName, resource.LocalNameIsDefined, resource.LocalName);
+ SetComplexString2(&netResource.lpRemoteName, resource.RemoteNameIsDefined, resource.RemoteName);
+ SetComplexString2(&netResource.lpComment, resource.CommentIsDefined, resource.Comment);
+ SetComplexString2(&netResource.lpProvider, resource.ProviderIsDefined, resource.Provider);
+}
+
+static void ConvertResourceWToResource(const CResourceW &resourceW, CResource &resource)
+{
+ *(CResourceBase *)&resource = *(CResourceBase *)&resourceW;
+ resource.LocalName = GetSystemString(resourceW.LocalName);
+ resource.RemoteName = GetSystemString(resourceW.RemoteName);
+ resource.Comment = GetSystemString(resourceW.Comment);
+ resource.Provider = GetSystemString(resourceW.Provider);
+}
+
+static void ConvertResourceToResourceW(const CResource &resource, CResourceW &resourceW)
+{
+ *(CResourceBase *)&resourceW = *(CResourceBase *)&resource;
+ resourceW.LocalName = GetUnicodeString(resource.LocalName);
+ resourceW.RemoteName = GetUnicodeString(resource.RemoteName);
+ resourceW.Comment = GetUnicodeString(resource.Comment);
+ resourceW.Provider = GetUnicodeString(resource.Provider);
+}
+#endif
+
+DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, const CResource *resource)
+{
+ NETRESOURCE netResource;
+ LPNETRESOURCE pointer = NULL;
+ if (resource)
+ {
+ ConvertCResourceToNETRESOURCE(*resource, netResource);
+ pointer = &netResource;
+ }
+ return Open(scope, type, usage, pointer);
+}
+
+#ifndef _UNICODE
+DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, const CResourceW *resource)
+{
+ if (g_IsNT)
+ {
+ NETRESOURCEW netResource;
+ LPNETRESOURCEW pointer = NULL;
+ if (resource)
+ {
+ ConvertCResourceToNETRESOURCE(*resource, netResource);
+ pointer = &netResource;
+ }
+ return Open(scope, type, usage, pointer);
+ }
+ CResource resourceA;
+ CResource *pointer = NULL;
+ if (resource)
+ {
+ ConvertResourceWToResource(*resource, resourceA);
+ pointer = &resourceA;
+ }
+ return Open(scope, type, usage, pointer);
+}
+#endif
+
+DWORD CEnum::Close()
+{
+ if (!_handleAllocated)
+ return NO_ERROR;
+ const DWORD result = ::WNetCloseEnum(_handle);
+ _handleAllocated = (result != NO_ERROR);
+ return result;
+}
+
+DWORD CEnum::Next(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
+{
+ return ::WNetEnumResource(_handle, lpcCount, lpBuffer, lpBufferSize);
+}
+
+#ifndef _UNICODE
+DWORD CEnum::NextW(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
+{
+ return ::WNetEnumResourceW(_handle, lpcCount, lpBuffer, lpBufferSize);
+}
+#endif
+
+DWORD CEnum::Next(CResource &resource)
+{
+ const DWORD kBufferSize = 16384;
+ CByteArr byteBuffer(kBufferSize);
+ LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (void *) (BYTE *)(byteBuffer);
+ ZeroMemory(lpnrLocal, kBufferSize);
+ DWORD bufferSize = kBufferSize;
+ DWORD numEntries = 1;
+ const DWORD result = Next(&numEntries, lpnrLocal, &bufferSize);
+ if (result != NO_ERROR)
+ return result;
+ if (numEntries != 1)
+ return (DWORD)E_FAIL;
+ ConvertNETRESOURCEToCResource(lpnrLocal[0], resource);
+ return result;
+}
+
+#ifndef _UNICODE
+DWORD CEnum::Next(CResourceW &resource)
+{
+ if (g_IsNT)
+ {
+ const DWORD kBufferSize = 16384;
+ CByteArr byteBuffer(kBufferSize);
+ LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (void *) (BYTE *)(byteBuffer);
+ ZeroMemory(lpnrLocal, kBufferSize);
+ DWORD bufferSize = kBufferSize;
+ DWORD numEntries = 1;
+ const DWORD result = NextW(&numEntries, lpnrLocal, &bufferSize);
+ if (result != NO_ERROR)
+ return result;
+ if (numEntries != 1)
+ return (DWORD)E_FAIL;
+ ConvertNETRESOURCEToCResource(lpnrLocal[0], resource);
+ return result;
+ }
+ CResource resourceA;
+ const DWORD result = Next(resourceA);
+ ConvertResourceToResourceW(resourceA, resource);
+ return result;
+}
+#endif
+
+
+DWORD GetResourceParent(const CResource &resource, CResource &parentResource)
+{
+ const DWORD kBufferSize = 16384;
+ CByteArr byteBuffer(kBufferSize);
+ LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (void *) (BYTE *)(byteBuffer);
+ ZeroMemory(lpnrLocal, kBufferSize);
+ DWORD bufferSize = kBufferSize;
+ NETRESOURCE netResource;
+ ConvertCResourceToNETRESOURCE(resource, netResource);
+ const DWORD result = ::WNetGetResourceParent(&netResource, lpnrLocal, &bufferSize);
+ if (result != NO_ERROR)
+ return result;
+ ConvertNETRESOURCEToCResource(lpnrLocal[0], parentResource);
+ return result;
+}
+
+#ifndef _UNICODE
+DWORD GetResourceParent(const CResourceW &resource, CResourceW &parentResource)
+{
+ if (g_IsNT)
+ {
+ const DWORD kBufferSize = 16384;
+ CByteArr byteBuffer(kBufferSize);
+ LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (void *) (BYTE *)(byteBuffer);
+ ZeroMemory(lpnrLocal, kBufferSize);
+ DWORD bufferSize = kBufferSize;
+ NETRESOURCEW netResource;
+ ConvertCResourceToNETRESOURCE(resource, netResource);
+ const DWORD result = ::WNetGetResourceParentW(&netResource, lpnrLocal, &bufferSize);
+ if (result != NO_ERROR)
+ return result;
+ ConvertNETRESOURCEToCResource(lpnrLocal[0], parentResource);
+ return result;
+ }
+ CResource resourceA, parentResourceA;
+ ConvertResourceWToResource(resource, resourceA);
+ const DWORD result = GetResourceParent(resourceA, parentResourceA);
+ ConvertResourceToResourceW(parentResourceA, parentResource);
+ return result;
+}
+#endif
+
+DWORD GetResourceInformation(const CResource &resource,
+ CResource &destResource, CSysString &systemPathPart)
+{
+ const DWORD kBufferSize = 16384;
+ CByteArr byteBuffer(kBufferSize);
+ LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (void *) (BYTE *)(byteBuffer);
+ ZeroMemory(lpnrLocal, kBufferSize);
+ DWORD bufferSize = kBufferSize;
+ NETRESOURCE netResource;
+ ConvertCResourceToNETRESOURCE(resource, netResource);
+ LPTSTR lplpSystem;
+ const DWORD result = ::WNetGetResourceInformation(&netResource,
+ lpnrLocal, &bufferSize, &lplpSystem);
+ if (result != NO_ERROR)
+ return result;
+ if (lplpSystem != NULL)
+ systemPathPart = lplpSystem;
+ ConvertNETRESOURCEToCResource(lpnrLocal[0], destResource);
+ return result;
+}
+
+#ifndef _UNICODE
+DWORD GetResourceInformation(const CResourceW &resource,
+ CResourceW &destResource, UString &systemPathPart)
+{
+ if (g_IsNT)
+ {
+ const DWORD kBufferSize = 16384;
+ CByteArr byteBuffer(kBufferSize);
+ LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (void *) (BYTE *)(byteBuffer);
+ ZeroMemory(lpnrLocal, kBufferSize);
+ DWORD bufferSize = kBufferSize;
+ NETRESOURCEW netResource;
+ ConvertCResourceToNETRESOURCE(resource, netResource);
+ LPWSTR lplpSystem;
+ const DWORD result = ::WNetGetResourceInformationW(&netResource,
+ lpnrLocal, &bufferSize, &lplpSystem);
+ if (result != NO_ERROR)
+ return result;
+ if (lplpSystem != 0)
+ systemPathPart = lplpSystem;
+ ConvertNETRESOURCEToCResource(lpnrLocal[0], destResource);
+ return result;
+ }
+ CResource resourceA, destResourceA;
+ ConvertResourceWToResource(resource, resourceA);
+ AString systemPathPartA;
+ const DWORD result = GetResourceInformation(resourceA, destResourceA, systemPathPartA);
+ ConvertResourceToResourceW(destResourceA, destResource);
+ systemPathPart = GetUnicodeString(systemPathPartA);
+ return result;
+}
+#endif
+
+DWORD AddConnection2(const CResource &resource,
+ LPCTSTR password, LPCTSTR userName, DWORD flags)
+{
+ NETRESOURCE netResource;
+ ConvertCResourceToNETRESOURCE(resource, netResource);
+ return ::WNetAddConnection2(&netResource,
+ password, userName, flags);
+}
+
+DWORD AddConnection2(const CResource &resource, LPCTSTR password, LPCTSTR userName, DWORD flags);
+
+#ifndef _UNICODE
+DWORD AddConnection2(const CResourceW &resource, LPCWSTR password, LPCWSTR userName, DWORD flags)
+{
+ if (g_IsNT)
+ {
+ NETRESOURCEW netResource;
+ ConvertCResourceToNETRESOURCE(resource, netResource);
+ return ::WNetAddConnection2W(&netResource,password, userName, flags);
+ }
+ CResource resourceA;
+ ConvertResourceWToResource(resource, resourceA);
+ const CSysString passwordA (GetSystemString(password));
+ const CSysString userNameA (GetSystemString(userName));
+ return AddConnection2(resourceA,
+ password ? (LPCTSTR)passwordA: 0,
+ userName ? (LPCTSTR)userNameA: 0,
+ flags);
+}
+#endif
+
+}}
diff --git a/CPP/Windows/Net.h b/CPP/Windows/Net.h
new file mode 100644
index 0000000..a954bdb
--- /dev/null
+++ b/CPP/Windows/Net.h
@@ -0,0 +1,87 @@
+// Windows/Net.h
+
+#ifndef ZIP7_INC_WINDOWS_NET_H
+#define ZIP7_INC_WINDOWS_NET_H
+
+#include "../Common/MyString.h"
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+namespace NNet {
+
+struct CResourceBase
+{
+ DWORD Scope;
+ DWORD Type;
+ DWORD DisplayType;
+ DWORD Usage;
+ bool LocalNameIsDefined;
+ bool RemoteNameIsDefined;
+ bool CommentIsDefined;
+ bool ProviderIsDefined;
+};
+
+struct CResource: public CResourceBase
+{
+ CSysString LocalName;
+ CSysString RemoteName;
+ CSysString Comment;
+ CSysString Provider;
+};
+
+#ifdef _UNICODE
+typedef CResource CResourceW;
+#else
+struct CResourceW: public CResourceBase
+{
+ UString LocalName;
+ UString RemoteName;
+ UString Comment;
+ UString Provider;
+};
+#endif
+
+class CEnum
+{
+ HANDLE _handle;
+ bool _handleAllocated;
+ DWORD Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCE netResource);
+ DWORD Next(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
+ #ifndef _UNICODE
+ DWORD Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCEW netResource);
+ DWORD NextW(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
+ #endif
+protected:
+ bool IsHandleAllocated() const { return _handleAllocated; }
+public:
+ CEnum(): _handleAllocated(false) {}
+ ~CEnum() { Close(); }
+ DWORD Close();
+ DWORD Open(DWORD scope, DWORD type, DWORD usage, const CResource *resource);
+ DWORD Next(CResource &resource);
+ #ifndef _UNICODE
+ DWORD Open(DWORD scope, DWORD type, DWORD usage, const CResourceW *resource);
+ DWORD Next(CResourceW &resource);
+ #endif
+};
+
+DWORD GetResourceParent(const CResource &resource, CResource &parentResource);
+#ifndef _UNICODE
+DWORD GetResourceParent(const CResourceW &resource, CResourceW &parentResource);
+#endif
+
+DWORD GetResourceInformation(const CResource &resource,
+ CResource &destResource, CSysString &systemPathPart);
+#ifndef _UNICODE
+DWORD GetResourceInformation(const CResourceW &resource,
+ CResourceW &destResource, UString &systemPathPart);
+#endif
+
+DWORD AddConnection2(const CResource &resource, LPCTSTR password, LPCTSTR userName, DWORD flags);
+#ifndef _UNICODE
+DWORD AddConnection2(const CResourceW &resource, LPCWSTR password, LPCWSTR userName, DWORD flags);
+#endif
+
+}}
+
+#endif
diff --git a/CPP/Windows/NtCheck.h b/CPP/Windows/NtCheck.h
index 401e239..362a05a 100644
--- a/CPP/Windows/NtCheck.h
+++ b/CPP/Windows/NtCheck.h
@@ -1,46 +1,58 @@
-// Windows/NtCheck.h
-
-#ifndef __WINDOWS_NT_CHECK_H
-#define __WINDOWS_NT_CHECK_H
-
-#ifdef _WIN32
-
-#include "../Common/MyWindows.h"
-
-#if !defined(_WIN64) && !defined(UNDER_CE)
-static inline bool IsItWindowsNT()
-{
- OSVERSIONINFO vi;
- vi.dwOSVersionInfoSize = sizeof(vi);
- return (::GetVersionEx(&vi) && vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
-}
-#endif
-
-#ifndef _UNICODE
- #if defined(_WIN64) || defined(UNDER_CE)
- bool g_IsNT = true;
- #define SET_IS_NT
- #else
- bool g_IsNT = false;
- #define SET_IS_NT g_IsNT = IsItWindowsNT();
- #endif
- #define NT_CHECK_ACTION
- // #define NT_CHECK_ACTION { NT_CHECK_FAIL_ACTION }
-#else
- #if !defined(_WIN64) && !defined(UNDER_CE)
- #define NT_CHECK_ACTION if (!IsItWindowsNT()) { NT_CHECK_FAIL_ACTION }
- #else
- #define NT_CHECK_ACTION
- #endif
- #define SET_IS_NT
-#endif
-
-#define NT_CHECK NT_CHECK_ACTION SET_IS_NT
-
-#else
-
-#define NT_CHECK
-
-#endif
-
-#endif
+// Windows/NtCheck.h
+
+#ifndef ZIP7_INC_WINDOWS_NT_CHECK_H
+#define ZIP7_INC_WINDOWS_NT_CHECK_H
+
+#ifdef _WIN32
+
+#include "../Common/MyWindows.h"
+
+#if !defined(_WIN64) && !defined(UNDER_CE)
+
+#if defined(_MSC_VER) && _MSC_VER >= 1900
+#pragma warning(push)
+// GetVersionExW was declared deprecated
+#pragma warning(disable : 4996)
+#endif
+static inline bool IsItWindowsNT()
+{
+ OSVERSIONINFO vi;
+ vi.dwOSVersionInfoSize = sizeof(vi);
+ return (::GetVersionEx(&vi) && vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
+}
+#if defined(_MSC_VER) && _MSC_VER >= 1900
+#pragma warning(pop)
+#endif
+
+#endif
+
+#ifndef _UNICODE
+ extern
+ bool g_IsNT;
+ #if defined(_WIN64) || defined(UNDER_CE)
+ bool g_IsNT = true;
+ #define SET_IS_NT
+ #else
+ bool g_IsNT = false;
+ #define SET_IS_NT g_IsNT = IsItWindowsNT();
+ #endif
+ #define NT_CHECK_ACTION
+ // #define NT_CHECK_ACTION { NT_CHECK_FAIL_ACTION }
+#else
+ #if !defined(_WIN64) && !defined(UNDER_CE)
+ #define NT_CHECK_ACTION if (!IsItWindowsNT()) { NT_CHECK_FAIL_ACTION }
+ #else
+ #define NT_CHECK_ACTION
+ #endif
+ #define SET_IS_NT
+#endif
+
+#define NT_CHECK NT_CHECK_ACTION SET_IS_NT
+
+#else
+
+#define NT_CHECK
+
+#endif
+
+#endif
diff --git a/CPP/Windows/ProcessMessages.cpp b/CPP/Windows/ProcessMessages.cpp
new file mode 100644
index 0000000..0f48aee
--- /dev/null
+++ b/CPP/Windows/ProcessMessages.cpp
@@ -0,0 +1,22 @@
+// Windows/ProcessMessages.cpp
+
+#include "StdAfx.h"
+
+#include "ProcessMessages.h"
+
+namespace NWindows {
+
+void ProcessMessages(HWND window)
+{
+ MSG msg;
+ while (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
+ {
+ if (window == (HWND) NULL || !IsDialogMessage(window, &msg))
+ {
+ TranslateMessage(&msg);
+ DispatchMessage(&msg);
+ }
+ }
+}
+
+}
diff --git a/CPP/Windows/ProcessMessages.h b/CPP/Windows/ProcessMessages.h
new file mode 100644
index 0000000..aa98bbb
--- /dev/null
+++ b/CPP/Windows/ProcessMessages.h
@@ -0,0 +1,12 @@
+// Windows/ProcessMessages.h
+
+#ifndef ZIP7_INC_WINDOWS_PROCESS_MESSAGES_H
+#define ZIP7_INC_WINDOWS_PROCESS_MESSAGES_H
+
+namespace NWindows {
+
+void ProcessMessages(HWND window);
+
+}
+
+#endif
diff --git a/CPP/Windows/ProcessUtils.cpp b/CPP/Windows/ProcessUtils.cpp
new file mode 100644
index 0000000..607b4bb
--- /dev/null
+++ b/CPP/Windows/ProcessUtils.cpp
@@ -0,0 +1,102 @@
+// ProcessUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/StringConvert.h"
+
+#include "ProcessUtils.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+#ifndef UNDER_CE
+static UString GetQuotedString(const UString &s)
+{
+ UString s2 ('\"');
+ s2 += s;
+ s2 += '\"';
+ return s2;
+}
+#endif
+
+WRes CProcess::Create(LPCWSTR imageName, const UString ¶ms, LPCWSTR curDir)
+{
+ /*
+ OutputDebugStringW(L"CProcess::Create");
+ OutputDebugStringW(imageName);
+ if (params)
+ {
+ OutputDebugStringW(L"params:");
+ OutputDebugStringW(params);
+ }
+ if (curDir)
+ {
+ OutputDebugStringW(L"cur dir:");
+ OutputDebugStringW(curDir);
+ }
+ */
+
+ Close();
+ const UString params2 =
+ #ifndef UNDER_CE
+ GetQuotedString(imageName) + L' ' +
+ #endif
+ params;
+ #ifdef UNDER_CE
+ curDir = NULL;
+ #else
+ imageName = NULL;
+ #endif
+ PROCESS_INFORMATION pi;
+ BOOL result;
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ STARTUPINFOA si;
+ si.cb = sizeof(si);
+ si.lpReserved = NULL;
+ si.lpDesktop = NULL;
+ si.lpTitle = NULL;
+ si.dwFlags = 0;
+ si.cbReserved2 = 0;
+ si.lpReserved2 = NULL;
+
+ CSysString curDirA;
+ if (curDir != 0)
+ curDirA = GetSystemString(curDir);
+ const AString s = GetSystemString(params2);
+ result = ::CreateProcessA(NULL, s.Ptr_non_const(),
+ NULL, NULL, FALSE, 0, NULL, ((curDir != 0) ? (LPCSTR)curDirA: 0), &si, &pi);
+ }
+ else
+ #endif
+ {
+ STARTUPINFOW si;
+ si.cb = sizeof(si);
+ si.lpReserved = NULL;
+ si.lpDesktop = NULL;
+ si.lpTitle = NULL;
+ si.dwFlags = 0;
+ si.cbReserved2 = 0;
+ si.lpReserved2 = NULL;
+
+ result = CreateProcessW(imageName, params2.Ptr_non_const(),
+ NULL, NULL, FALSE, 0, NULL, curDir, &si, &pi);
+ }
+ if (result == 0)
+ return ::GetLastError();
+ ::CloseHandle(pi.hThread);
+ _handle = pi.hProcess;
+ return 0;
+}
+
+WRes MyCreateProcess(LPCWSTR imageName, const UString ¶ms)
+{
+ CProcess process;
+ return process.Create(imageName, params, NULL);
+}
+
+}
diff --git a/CPP/Windows/ProcessUtils.h b/CPP/Windows/ProcessUtils.h
new file mode 100644
index 0000000..b1fce3a
--- /dev/null
+++ b/CPP/Windows/ProcessUtils.h
@@ -0,0 +1,138 @@
+// Windows/ProcessUtils.h
+
+#ifndef ZIP7_INC_WINDOWS_PROCESS_UTILS_H
+#define ZIP7_INC_WINDOWS_PROCESS_UTILS_H
+
+#include "../Common/MyWindows.h"
+
+#ifndef Z7_OLD_WIN_SDK
+
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <psapi.h>
+#else
+#include <Psapi.h>
+#endif
+
+#else // Z7_OLD_WIN_SDK
+
+typedef struct _MODULEINFO {
+ LPVOID lpBaseOfDll;
+ DWORD SizeOfImage;
+ LPVOID EntryPoint;
+} MODULEINFO, *LPMODULEINFO;
+
+typedef struct _PROCESS_MEMORY_COUNTERS {
+ DWORD cb;
+ DWORD PageFaultCount;
+ SIZE_T PeakWorkingSetSize;
+ SIZE_T WorkingSetSize;
+ SIZE_T QuotaPeakPagedPoolUsage;
+ SIZE_T QuotaPagedPoolUsage;
+ SIZE_T QuotaPeakNonPagedPoolUsage;
+ SIZE_T QuotaNonPagedPoolUsage;
+ SIZE_T PagefileUsage;
+ SIZE_T PeakPagefileUsage;
+} PROCESS_MEMORY_COUNTERS;
+typedef PROCESS_MEMORY_COUNTERS *PPROCESS_MEMORY_COUNTERS;
+
+#endif // Z7_OLD_WIN_SDK
+
+#include "../Common/MyString.h"
+
+#include "Defs.h"
+#include "Handle.h"
+
+namespace NWindows {
+
+class CProcess: public CHandle
+{
+public:
+ bool Open(DWORD desiredAccess, bool inheritHandle, DWORD processId)
+ {
+ _handle = ::OpenProcess(desiredAccess, inheritHandle, processId);
+ return (_handle != NULL);
+ }
+
+ #ifndef UNDER_CE
+
+ bool GetExitCodeProcess(LPDWORD lpExitCode) { return BOOLToBool(::GetExitCodeProcess(_handle, lpExitCode)); }
+ bool Terminate(UINT exitCode) { return BOOLToBool(::TerminateProcess(_handle, exitCode)); }
+ #if (WINVER >= 0x0500)
+ DWORD GetGuiResources (DWORD uiFlags) { return ::GetGuiResources(_handle, uiFlags); }
+ #endif
+ bool SetPriorityClass(DWORD dwPriorityClass) { return BOOLToBool(::SetPriorityClass(_handle, dwPriorityClass)); }
+ DWORD GetPriorityClass() { return ::GetPriorityClass(_handle); }
+ // bool GetIoCounters(PIO_COUNTERS lpIoCounters ) { return BOOLToBool(::GetProcessIoCounters(_handle, lpIoCounters )); }
+
+ bool GetTimes(LPFILETIME creationTime, LPFILETIME exitTime, LPFILETIME kernelTime, LPFILETIME userTime)
+ { return BOOLToBool(::GetProcessTimes(_handle, creationTime, exitTime, kernelTime, userTime)); }
+
+ DWORD WaitForInputIdle(DWORD milliseconds) { return ::WaitForInputIdle(_handle, milliseconds); }
+
+ // Debug
+
+ bool ReadMemory(LPCVOID baseAddress, LPVOID buffer, SIZE_T size, SIZE_T* numberOfBytesRead)
+ { return BOOLToBool(::ReadProcessMemory(_handle, baseAddress, buffer, size, numberOfBytesRead)); }
+
+ bool WriteMemory(LPVOID baseAddress, LPCVOID buffer, SIZE_T size, SIZE_T* numberOfBytesWritten)
+ { return BOOLToBool(::WriteProcessMemory(_handle, baseAddress,
+ #ifdef Z7_OLD_WIN_SDK
+ (LPVOID)
+ #endif
+ buffer,
+ size, numberOfBytesWritten)); }
+
+ bool FlushInstructionCache(LPCVOID baseAddress = NULL, SIZE_T size = 0)
+ { return BOOLToBool(::FlushInstructionCache(_handle, baseAddress, size)); }
+
+ LPVOID VirtualAlloc(LPVOID address, SIZE_T size, DWORD allocationType, DWORD protect)
+ { return VirtualAllocEx(_handle, address, size, allocationType, protect); }
+
+ bool VirtualFree(LPVOID address, SIZE_T size, DWORD freeType)
+ { return BOOLToBool(::VirtualFreeEx(_handle, address, size, freeType)); }
+
+ // Process Status API (PSAPI)
+
+ /*
+ bool EmptyWorkingSet()
+ { return BOOLToBool(::EmptyWorkingSet(_handle)); }
+ bool EnumModules(HMODULE *hModules, DWORD arraySizeInBytes, LPDWORD receivedBytes)
+ { return BOOLToBool(::EnumProcessModules(_handle, hModules, arraySizeInBytes, receivedBytes)); }
+ DWORD MyGetModuleBaseName(HMODULE hModule, LPTSTR baseName, DWORD size)
+ { return ::GetModuleBaseName(_handle, hModule, baseName, size); }
+ bool MyGetModuleBaseName(HMODULE hModule, CSysString &name)
+ {
+ const unsigned len = MAX_PATH + 100;
+ const DWORD resultLen = MyGetModuleBaseName(hModule, name.GetBuf(len), len);
+ name.ReleaseBuf_CalcLen(len);
+ return (resultLen != 0);
+ }
+
+ DWORD MyGetModuleFileNameEx(HMODULE hModule, LPTSTR baseName, DWORD size)
+ { return ::GetModuleFileNameEx(_handle, hModule, baseName, size); }
+ bool MyGetModuleFileNameEx(HMODULE hModule, CSysString &name)
+ {
+ const unsigned len = MAX_PATH + 100;
+ const DWORD resultLen = MyGetModuleFileNameEx(hModule, name.GetBuf(len), len);
+ name.ReleaseBuf_CalcLen(len);
+ return (resultLen != 0);
+ }
+
+ bool GetModuleInformation(HMODULE hModule, LPMODULEINFO moduleInfo)
+ { return BOOLToBool(::GetModuleInformation(_handle, hModule, moduleInfo, sizeof(MODULEINFO))); }
+ bool GetMemoryInfo(PPROCESS_MEMORY_COUNTERS memCounters)
+ { return BOOLToBool(::GetProcessMemoryInfo(_handle, memCounters, sizeof(PROCESS_MEMORY_COUNTERS))); }
+ */
+
+ #endif
+
+ WRes Create(LPCWSTR imageName, const UString ¶ms, LPCWSTR curDir);
+
+ DWORD Wait() { return ::WaitForSingleObject(_handle, INFINITE); }
+};
+
+WRes MyCreateProcess(LPCWSTR imageName, const UString ¶ms);
+
+}
+
+#endif
diff --git a/CPP/Windows/PropVariant.cpp b/CPP/Windows/PropVariant.cpp
index 6d9fb48..457b1dc 100644
--- a/CPP/Windows/PropVariant.cpp
+++ b/CPP/Windows/PropVariant.cpp
@@ -1,347 +1,391 @@
-// Windows/PropVariant.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/Defs.h"
-
-#include "PropVariant.h"
-
-namespace NWindows {
-namespace NCOM {
-
-BSTR AllocBstrFromAscii(const char *s) throw()
-{
- if (!s)
- return NULL;
- UINT len = (UINT)strlen(s);
- BSTR p = ::SysAllocStringLen(NULL, len);
- if (p)
- {
- for (UINT i = 0; i <= len; i++)
- p[i] = (Byte)s[i];
- }
- return p;
-}
-
-HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw()
-{
- p->bstrVal = ::SysAllocStringLen(NULL, numChars);
- if (!p->bstrVal)
- {
- p->vt = VT_ERROR;
- p->scode = E_OUTOFMEMORY;
- return E_OUTOFMEMORY;
- }
- p->vt = VT_BSTR;
- return S_OK;
-}
-
-HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw()
-{
- p->bstrVal = AllocBstrFromAscii(s);
- if (p->bstrVal)
- {
- p->vt = VT_BSTR;
- return S_OK;
- }
- p->vt = VT_ERROR;
- p->scode = E_OUTOFMEMORY;
- return E_OUTOFMEMORY;
-}
-
-CPropVariant::CPropVariant(const PROPVARIANT &varSrc)
-{
- vt = VT_EMPTY;
- InternalCopy(&varSrc);
-}
-
-CPropVariant::CPropVariant(const CPropVariant &varSrc)
-{
- vt = VT_EMPTY;
- InternalCopy(&varSrc);
-}
-
-CPropVariant::CPropVariant(BSTR bstrSrc)
-{
- vt = VT_EMPTY;
- *this = bstrSrc;
-}
-
-CPropVariant::CPropVariant(LPCOLESTR lpszSrc)
-{
- vt = VT_EMPTY;
- *this = lpszSrc;
-}
-
-CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc)
-{
- InternalCopy(&varSrc);
- return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc)
-{
- InternalCopy(&varSrc);
- return *this;
-}
-
-CPropVariant& CPropVariant::operator=(BSTR bstrSrc)
-{
- *this = (LPCOLESTR)bstrSrc;
- return *this;
-}
-
-static const char * const kMemException = "out of memory";
-
-CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
-{
- InternalClear();
- vt = VT_BSTR;
- wReserved1 = 0;
- bstrVal = ::SysAllocString(lpszSrc);
- if (!bstrVal && lpszSrc)
- {
- throw kMemException;
- // vt = VT_ERROR;
- // scode = E_OUTOFMEMORY;
- }
- return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const UString &s)
-{
- InternalClear();
- vt = VT_BSTR;
- wReserved1 = 0;
- bstrVal = ::SysAllocStringLen(s, s.Len());
- if (!bstrVal)
- throw kMemException;
- return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const UString2 &s)
-{
- /*
- if (s.IsEmpty())
- *this = L"";
- else
- */
- {
- InternalClear();
- vt = VT_BSTR;
- wReserved1 = 0;
- bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len());
- if (!bstrVal)
- throw kMemException;
- /* SysAllocStringLen probably appends a null-terminating character for NULL string.
- But it doesn't specified in MSDN.
- But we suppose that it works
-
- if (!s.GetRawPtr())
- {
- *bstrVal = 0;
- }
- */
-
- /* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL)
- pointers to this function causes an unexpected termination of the application.
- Is it safe? Maybe we must chamnge the code for that case ? */
- }
- return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const char *s)
-{
- InternalClear();
- vt = VT_BSTR;
- wReserved1 = 0;
- bstrVal = AllocBstrFromAscii(s);
- if (!bstrVal)
- {
- throw kMemException;
- // vt = VT_ERROR;
- // scode = E_OUTOFMEMORY;
- }
- return *this;
-}
-
-CPropVariant& CPropVariant::operator=(bool bSrc) throw()
-{
- if (vt != VT_BOOL)
- {
- InternalClear();
- vt = VT_BOOL;
- }
- boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
- return *this;
-}
-
-BSTR CPropVariant::AllocBstr(unsigned numChars)
-{
- if (vt != VT_EMPTY)
- InternalClear();
- vt = VT_BSTR;
- wReserved1 = 0;
- bstrVal = ::SysAllocStringLen(NULL, numChars);
- if (!bstrVal)
- {
- throw kMemException;
- // vt = VT_ERROR;
- // scode = E_OUTOFMEMORY;
- }
- return bstrVal;
-}
-
-#define SET_PROP_FUNC(type, id, dest) \
- CPropVariant& CPropVariant::operator=(type value) throw() \
- { if (vt != id) { InternalClear(); vt = id; } \
- dest = value; return *this; }
-
-SET_PROP_FUNC(Byte, VT_UI1, bVal)
-// SET_PROP_FUNC(Int16, VT_I2, iVal)
-SET_PROP_FUNC(Int32, VT_I4, lVal)
-SET_PROP_FUNC(UInt32, VT_UI4, ulVal)
-SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart)
-SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart)
-SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime)
-
-HRESULT PropVariant_Clear(PROPVARIANT *prop) throw()
-{
- switch (prop->vt)
- {
- case VT_EMPTY:
- case VT_UI1:
- case VT_I1:
- case VT_I2:
- case VT_UI2:
- case VT_BOOL:
- case VT_I4:
- case VT_UI4:
- case VT_R4:
- case VT_INT:
- case VT_UINT:
- case VT_ERROR:
- case VT_FILETIME:
- case VT_UI8:
- case VT_R8:
- case VT_CY:
- case VT_DATE:
- prop->vt = VT_EMPTY;
- prop->wReserved1 = 0;
- prop->wReserved2 = 0;
- prop->wReserved3 = 0;
- prop->uhVal.QuadPart = 0;
- return S_OK;
- }
- return ::VariantClear((VARIANTARG *)prop);
- // return ::PropVariantClear(prop);
- // PropVariantClear can clear VT_BLOB.
-}
-
-HRESULT CPropVariant::Clear() throw()
-{
- if (vt == VT_EMPTY)
- return S_OK;
- return PropVariant_Clear(this);
-}
-
-HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw()
-{
- ::VariantClear((tagVARIANT *)this);
- switch (pSrc->vt)
- {
- case VT_UI1:
- case VT_I1:
- case VT_I2:
- case VT_UI2:
- case VT_BOOL:
- case VT_I4:
- case VT_UI4:
- case VT_R4:
- case VT_INT:
- case VT_UINT:
- case VT_ERROR:
- case VT_FILETIME:
- case VT_UI8:
- case VT_R8:
- case VT_CY:
- case VT_DATE:
- memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
- return S_OK;
- }
- return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)const_cast<PROPVARIANT *>(pSrc));
-}
-
-
-HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw()
-{
- HRESULT hr = Clear();
- if (FAILED(hr))
- return hr;
- memcpy(this, pSrc, sizeof(PROPVARIANT));
- pSrc->vt = VT_EMPTY;
- return S_OK;
-}
-
-HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw()
-{
- if (pDest->vt != VT_EMPTY)
- {
- HRESULT hr = PropVariant_Clear(pDest);
- if (FAILED(hr))
- return hr;
- }
- memcpy(pDest, this, sizeof(PROPVARIANT));
- vt = VT_EMPTY;
- return S_OK;
-}
-
-HRESULT CPropVariant::InternalClear() throw()
-{
- if (vt == VT_EMPTY)
- return S_OK;
- HRESULT hr = Clear();
- if (FAILED(hr))
- {
- vt = VT_ERROR;
- scode = hr;
- }
- return hr;
-}
-
-void CPropVariant::InternalCopy(const PROPVARIANT *pSrc)
-{
- HRESULT hr = Copy(pSrc);
- if (FAILED(hr))
- {
- if (hr == E_OUTOFMEMORY)
- throw kMemException;
- vt = VT_ERROR;
- scode = hr;
- }
-}
-
-int CPropVariant::Compare(const CPropVariant &a) throw()
-{
- if (vt != a.vt)
- return MyCompare(vt, a.vt);
- switch (vt)
- {
- case VT_EMPTY: return 0;
- // case VT_I1: return MyCompare(cVal, a.cVal);
- case VT_UI1: return MyCompare(bVal, a.bVal);
- case VT_I2: return MyCompare(iVal, a.iVal);
- case VT_UI2: return MyCompare(uiVal, a.uiVal);
- case VT_I4: return MyCompare(lVal, a.lVal);
- case VT_UI4: return MyCompare(ulVal, a.ulVal);
- // case VT_UINT: return MyCompare(uintVal, a.uintVal);
- case VT_I8: return MyCompare(hVal.QuadPart, a.hVal.QuadPart);
- case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
- case VT_BOOL: return -MyCompare(boolVal, a.boolVal);
- case VT_FILETIME: return ::CompareFileTime(&filetime, &a.filetime);
- case VT_BSTR: return 0; // Not implemented
- default: return 0;
- }
-}
-
-}}
+// Windows/PropVariant.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/Defs.h"
+
+#include "PropVariant.h"
+
+namespace NWindows {
+namespace NCOM {
+
+BSTR AllocBstrFromAscii(const char *s) throw()
+{
+ if (!s)
+ return NULL;
+ UINT len = (UINT)strlen(s);
+ BSTR p = ::SysAllocStringLen(NULL, len);
+ if (p)
+ {
+ for (UINT i = 0; i <= len; i++)
+ p[i] = (Byte)s[i];
+ }
+ return p;
+}
+
+HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw()
+{
+ p->bstrVal = ::SysAllocStringLen(NULL, numChars);
+ if (!p->bstrVal)
+ {
+ p->vt = VT_ERROR;
+ p->scode = E_OUTOFMEMORY;
+ return E_OUTOFMEMORY;
+ }
+ p->vt = VT_BSTR;
+ return S_OK;
+}
+
+HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw()
+{
+ p->bstrVal = AllocBstrFromAscii(s);
+ if (p->bstrVal)
+ {
+ p->vt = VT_BSTR;
+ return S_OK;
+ }
+ p->vt = VT_ERROR;
+ p->scode = E_OUTOFMEMORY;
+ return E_OUTOFMEMORY;
+}
+
+CPropVariant::CPropVariant(const PROPVARIANT &varSrc)
+{
+ vt = VT_EMPTY;
+ InternalCopy(&varSrc);
+}
+
+CPropVariant::CPropVariant(const CPropVariant &varSrc)
+{
+ vt = VT_EMPTY;
+ InternalCopy(&varSrc);
+}
+
+CPropVariant::CPropVariant(BSTR bstrSrc)
+{
+ vt = VT_EMPTY;
+ *this = bstrSrc;
+}
+
+CPropVariant::CPropVariant(LPCOLESTR lpszSrc)
+{
+ vt = VT_EMPTY;
+ *this = lpszSrc;
+}
+
+CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc)
+{
+ InternalCopy(&varSrc);
+ return *this;
+}
+
+CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc)
+{
+ InternalCopy(&varSrc);
+ return *this;
+}
+
+CPropVariant& CPropVariant::operator=(BSTR bstrSrc)
+{
+ *this = (LPCOLESTR)bstrSrc;
+ return *this;
+}
+
+static const char * const kMemException = "out of memory";
+
+CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
+{
+ InternalClear();
+ vt = VT_BSTR;
+ wReserved1 = 0;
+ bstrVal = ::SysAllocString(lpszSrc);
+ if (!bstrVal && lpszSrc)
+ {
+ throw kMemException;
+ // vt = VT_ERROR;
+ // scode = E_OUTOFMEMORY;
+ }
+ return *this;
+}
+
+CPropVariant& CPropVariant::operator=(const UString &s)
+{
+ InternalClear();
+ vt = VT_BSTR;
+ wReserved1 = 0;
+ bstrVal = ::SysAllocStringLen(s, s.Len());
+ if (!bstrVal)
+ throw kMemException;
+ return *this;
+}
+
+CPropVariant& CPropVariant::operator=(const UString2 &s)
+{
+ /*
+ if (s.IsEmpty())
+ *this = L"";
+ else
+ */
+ {
+ InternalClear();
+ vt = VT_BSTR;
+ wReserved1 = 0;
+ bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len());
+ if (!bstrVal)
+ throw kMemException;
+ /* SysAllocStringLen probably appends a null-terminating character for NULL string.
+ But it doesn't specified in MSDN.
+ But we suppose that it works
+
+ if (!s.GetRawPtr())
+ {
+ *bstrVal = 0;
+ }
+ */
+
+ /* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL)
+ pointers to this function causes an unexpected termination of the application.
+ Is it safe? Maybe we must chamnge the code for that case ? */
+ }
+ return *this;
+}
+
+CPropVariant& CPropVariant::operator=(const char *s)
+{
+ InternalClear();
+ vt = VT_BSTR;
+ wReserved1 = 0;
+ bstrVal = AllocBstrFromAscii(s);
+ if (!bstrVal)
+ {
+ throw kMemException;
+ // vt = VT_ERROR;
+ // scode = E_OUTOFMEMORY;
+ }
+ return *this;
+}
+
+CPropVariant& CPropVariant::operator=(bool bSrc) throw()
+{
+ if (vt != VT_BOOL)
+ {
+ InternalClear();
+ vt = VT_BOOL;
+ }
+ boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
+ return *this;
+}
+
+BSTR CPropVariant::AllocBstr(unsigned numChars)
+{
+ if (vt != VT_EMPTY)
+ InternalClear();
+ vt = VT_BSTR;
+ wReserved1 = 0;
+ bstrVal = ::SysAllocStringLen(NULL, numChars);
+ if (!bstrVal)
+ {
+ throw kMemException;
+ // vt = VT_ERROR;
+ // scode = E_OUTOFMEMORY;
+ }
+ return bstrVal;
+}
+
+#define SET_PROP_id_dest(id, dest) \
+ if (vt != id) { InternalClear(); vt = id; } dest = value; wReserved1 = 0;
+
+void CPropVariant::Set_Int32(Int32 value) throw()
+{
+ SET_PROP_id_dest(VT_I4, lVal)
+}
+
+void CPropVariant::Set_Int64(Int64 value) throw()
+{
+ SET_PROP_id_dest(VT_I8, hVal.QuadPart)
+}
+
+#define SET_PROP_FUNC(type, id, dest) \
+ CPropVariant& CPropVariant::operator=(type value) throw() \
+ { SET_PROP_id_dest(id, dest) return *this; }
+
+SET_PROP_FUNC(Byte, VT_UI1, bVal)
+// SET_PROP_FUNC(Int16, VT_I2, iVal)
+// SET_PROP_FUNC(Int32, VT_I4, lVal)
+SET_PROP_FUNC(UInt32, VT_UI4, ulVal)
+SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart)
+// SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart)
+SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime)
+
+#define CASE_SIMPLE_VT_VALUES \
+ case VT_EMPTY: \
+ case VT_BOOL: \
+ case VT_FILETIME: \
+ case VT_UI8: \
+ case VT_UI4: \
+ case VT_UI2: \
+ case VT_UI1: \
+ case VT_I8: \
+ case VT_I4: \
+ case VT_I2: \
+ case VT_I1: \
+ case VT_UINT: \
+ case VT_INT: \
+ case VT_NULL: \
+ case VT_ERROR: \
+ case VT_R4: \
+ case VT_R8: \
+ case VT_CY: \
+ case VT_DATE: \
+
+
+/*
+ ::VariantClear() and ::VariantCopy() don't work, if (vt == VT_FILETIME)
+ So we handle VT_FILETIME and another simple types directly
+ we call system functions for VT_BSTR and for unknown typed
+*/
+
+CPropVariant::~CPropVariant() throw()
+{
+ switch ((unsigned)vt)
+ {
+ CASE_SIMPLE_VT_VALUES
+ // vt = VT_EMPTY; // it's optional
+ return;
+ }
+ ::VariantClear((tagVARIANT *)this);
+}
+
+HRESULT PropVariant_Clear(PROPVARIANT *prop) throw()
+{
+ switch ((unsigned)prop->vt)
+ {
+ CASE_SIMPLE_VT_VALUES
+ prop->vt = VT_EMPTY;
+ break;
+ default:
+ {
+ const HRESULT res = ::VariantClear((VARIANTARG *)prop);
+ if (res != S_OK || prop->vt != VT_EMPTY)
+ return res;
+ break;
+ }
+ }
+ prop->wReserved1 = 0;
+ prop->wReserved2 = 0;
+ prop->wReserved3 = 0;
+ prop->uhVal.QuadPart = 0;
+ return S_OK;
+}
+
+HRESULT CPropVariant::Clear() throw()
+{
+ if (vt == VT_EMPTY)
+ {
+ wReserved1 = 0;
+ return S_OK;
+ }
+ return PropVariant_Clear(this);
+}
+
+HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw()
+{
+ Clear();
+ switch ((unsigned)pSrc->vt)
+ {
+ CASE_SIMPLE_VT_VALUES
+ memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
+ return S_OK;
+ }
+ return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)const_cast<PROPVARIANT *>(pSrc));
+}
+
+
+HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw()
+{
+ const HRESULT hr = Clear();
+ if (FAILED(hr))
+ return hr;
+ // memcpy((PROPVARIANT *)this, pSrc, sizeof(PROPVARIANT));
+ *(PROPVARIANT *)this = *pSrc;
+ pSrc->vt = VT_EMPTY;
+ pSrc->wReserved1 = 0;
+ return S_OK;
+}
+
+HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw()
+{
+ if (pDest->vt != VT_EMPTY)
+ {
+ const HRESULT hr = PropVariant_Clear(pDest);
+ if (FAILED(hr))
+ return hr;
+ }
+ // memcpy(pDest, this, sizeof(PROPVARIANT));
+ *pDest = *(PROPVARIANT *)this;
+ vt = VT_EMPTY;
+ wReserved1 = 0;
+ return S_OK;
+}
+
+HRESULT CPropVariant::InternalClear() throw()
+{
+ if (vt == VT_EMPTY)
+ {
+ wReserved1 = 0;
+ return S_OK;
+ }
+ const HRESULT hr = Clear();
+ if (FAILED(hr))
+ {
+ vt = VT_ERROR;
+ scode = hr;
+ }
+ return hr;
+}
+
+void CPropVariant::InternalCopy(const PROPVARIANT *pSrc)
+{
+ const HRESULT hr = Copy(pSrc);
+ if (FAILED(hr))
+ {
+ if (hr == E_OUTOFMEMORY)
+ throw kMemException;
+ vt = VT_ERROR;
+ scode = hr;
+ }
+}
+
+
+int CPropVariant::Compare(const CPropVariant &a) throw()
+{
+ if (vt != a.vt)
+ return MyCompare(vt, a.vt);
+ switch ((unsigned)vt)
+ {
+ case VT_EMPTY: return 0;
+ // case VT_I1: return MyCompare(cVal, a.cVal);
+ case VT_UI1: return MyCompare(bVal, a.bVal);
+ case VT_I2: return MyCompare(iVal, a.iVal);
+ case VT_UI2: return MyCompare(uiVal, a.uiVal);
+ case VT_I4: return MyCompare(lVal, a.lVal);
+ case VT_UI4: return MyCompare(ulVal, a.ulVal);
+ // case VT_UINT: return MyCompare(uintVal, a.uintVal);
+ case VT_I8: return MyCompare(hVal.QuadPart, a.hVal.QuadPart);
+ case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
+ case VT_BOOL: return -MyCompare(boolVal, a.boolVal);
+ case VT_FILETIME:
+ {
+ const int res = CompareFileTime(&filetime, &a.filetime);
+ if (res != 0)
+ return res;
+ const unsigned v1 = Get_Ns100();
+ const unsigned v2 = a.Get_Ns100();
+ return MyCompare(v1, v2);
+ }
+ case VT_BSTR: return 0; // Not implemented
+ default: return 0;
+ }
+}
+
+}}
diff --git a/CPP/Windows/PropVariant.h b/CPP/Windows/PropVariant.h
index f2eaba2..f358fde 100644
--- a/CPP/Windows/PropVariant.h
+++ b/CPP/Windows/PropVariant.h
@@ -1,114 +1,173 @@
-// Windows/PropVariant.h
-
-#ifndef __WINDOWS_PROP_VARIANT_H
-#define __WINDOWS_PROP_VARIANT_H
-
-#include "../Common/MyTypes.h"
-#include "../Common/MyWindows.h"
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NCOM {
-
-BSTR AllocBstrFromAscii(const char *s) throw();
-
-HRESULT PropVariant_Clear(PROPVARIANT *p) throw();
-
-HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw();
-HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw();
-
-inline void PropVarEm_Set_UInt32(PROPVARIANT *p, UInt32 v) throw()
-{
- p->vt = VT_UI4;
- p->ulVal = v;
-}
-
-inline void PropVarEm_Set_UInt64(PROPVARIANT *p, UInt64 v) throw()
-{
- p->vt = VT_UI8;
- p->uhVal.QuadPart = v;
-}
-
-inline void PropVarEm_Set_FileTime64(PROPVARIANT *p, UInt64 v) throw()
-{
- p->vt = VT_FILETIME;
- p->filetime.dwLowDateTime = (DWORD)v;
- p->filetime.dwHighDateTime = (DWORD)(v >> 32);
-}
-
-inline void PropVarEm_Set_Bool(PROPVARIANT *p, bool b) throw()
-{
- p->vt = VT_BOOL;
- p->boolVal = (b ? VARIANT_TRUE : VARIANT_FALSE);
-}
-
-
-class CPropVariant : public tagPROPVARIANT
-{
-public:
- CPropVariant()
- {
- vt = VT_EMPTY;
- wReserved1 = 0;
- // wReserved2 = 0;
- // wReserved3 = 0;
- // uhVal.QuadPart = 0;
- bstrVal = 0;
- }
- ~CPropVariant() throw() { Clear(); }
- CPropVariant(const PROPVARIANT &varSrc);
- CPropVariant(const CPropVariant &varSrc);
- CPropVariant(BSTR bstrSrc);
- CPropVariant(LPCOLESTR lpszSrc);
- CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); }
- CPropVariant(Byte value) { vt = VT_UI1; wReserved1 = 0; bVal = value; }
-
-private:
- CPropVariant(Int16 value); // { vt = VT_I2; wReserved1 = 0; iVal = value; }
- CPropVariant(Int32 value); // { vt = VT_I4; wReserved1 = 0; lVal = value; }
-
-public:
- CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
- CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
- CPropVariant(Int64 value) { vt = VT_I8; wReserved1 = 0; hVal.QuadPart = value; }
- CPropVariant(const FILETIME &value) { vt = VT_FILETIME; wReserved1 = 0; filetime = value; }
-
- CPropVariant& operator=(const CPropVariant &varSrc);
- CPropVariant& operator=(const PROPVARIANT &varSrc);
- CPropVariant& operator=(BSTR bstrSrc);
- CPropVariant& operator=(LPCOLESTR lpszSrc);
- CPropVariant& operator=(const UString &s);
- CPropVariant& operator=(const UString2 &s);
- CPropVariant& operator=(const char *s);
- CPropVariant& operator=(const AString &s)
- { return (*this)=(const char *)s; }
-
- CPropVariant& operator=(bool bSrc) throw();
- CPropVariant& operator=(Byte value) throw();
-
-private:
- CPropVariant& operator=(Int16 value) throw();
-
-public:
- CPropVariant& operator=(Int32 value) throw();
- CPropVariant& operator=(UInt32 value) throw();
- CPropVariant& operator=(UInt64 value) throw();
- CPropVariant& operator=(Int64 value) throw();
- CPropVariant& operator=(const FILETIME &value) throw();
-
- BSTR AllocBstr(unsigned numChars);
-
- HRESULT Clear() throw();
- HRESULT Copy(const PROPVARIANT *pSrc) throw();
- HRESULT Attach(PROPVARIANT *pSrc) throw();
- HRESULT Detach(PROPVARIANT *pDest) throw();
-
- HRESULT InternalClear() throw();
- void InternalCopy(const PROPVARIANT *pSrc);
-
- int Compare(const CPropVariant &a) throw();
-};
-
-}}
-
-#endif
+// Windows/PropVariant.h
+
+#ifndef ZIP7_INC_WINDOWS_PROP_VARIANT_H
+#define ZIP7_INC_WINDOWS_PROP_VARIANT_H
+
+#include "../Common/MyTypes.h"
+#include "../Common/MyWindows.h"
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NCOM {
+
+BSTR AllocBstrFromAscii(const char *s) throw();
+
+HRESULT PropVariant_Clear(PROPVARIANT *p) throw();
+
+HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw();
+HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw();
+
+inline void PropVarEm_Set_UInt32(PROPVARIANT *p, UInt32 v) throw()
+{
+ p->vt = VT_UI4;
+ p->ulVal = v;
+}
+
+inline void PropVarEm_Set_UInt64(PROPVARIANT *p, UInt64 v) throw()
+{
+ p->vt = VT_UI8;
+ p->uhVal.QuadPart = v;
+}
+
+inline void PropVarEm_Set_FileTime64_Prec(PROPVARIANT *p, UInt64 v, unsigned prec) throw()
+{
+ p->vt = VT_FILETIME;
+ p->filetime.dwLowDateTime = (DWORD)v;
+ p->filetime.dwHighDateTime = (DWORD)(v >> 32);
+ p->wReserved1 = (WORD)prec;
+ p->wReserved2 = 0;
+ p->wReserved3 = 0;
+}
+
+inline void PropVarEm_Set_Bool(PROPVARIANT *p, bool b) throw()
+{
+ p->vt = VT_BOOL;
+ p->boolVal = (b ? VARIANT_TRUE : VARIANT_FALSE);
+}
+
+
+class CPropVariant : public tagPROPVARIANT
+{
+ // ---------- forbidden functions ----------
+ CPropVariant(const char *s);
+ // CPropVariant(const UString &s);
+ #ifdef DEBUG_FSTRING_INHERITS_ASTRING
+ CPropVariant(const FString &s);
+ CPropVariant& operator=(const FString &s);
+ #endif
+
+public:
+ CPropVariant()
+ {
+ vt = VT_EMPTY;
+ wReserved1 = 0;
+ // wReserved2 = 0;
+ // wReserved3 = 0;
+ // uhVal.QuadPart = 0;
+ bstrVal = NULL;
+ }
+
+
+ void Set_FtPrec(unsigned prec)
+ {
+ wReserved1 = (WORD)prec;
+ wReserved2 = 0;
+ wReserved3 = 0;
+ }
+
+ void SetAsTimeFrom_FT_Prec(const FILETIME &ft, unsigned prec)
+ {
+ operator=(ft);
+ Set_FtPrec(prec);
+ }
+
+ void SetAsTimeFrom_Ft64_Prec(UInt64 v, unsigned prec)
+ {
+ FILETIME ft;
+ ft.dwLowDateTime = (DWORD)(UInt32)v;
+ ft.dwHighDateTime = (DWORD)(UInt32)(v >> 32);
+ operator=(ft);
+ Set_FtPrec(prec);
+ }
+
+ void SetAsTimeFrom_FT_Prec_Ns100(const FILETIME &ft, unsigned prec, unsigned ns100)
+ {
+ operator=(ft);
+ wReserved1 = (WORD)prec;
+ wReserved2 = (WORD)ns100;
+ wReserved3 = 0;
+ }
+
+ unsigned Get_Ns100() const
+ {
+ const unsigned prec = wReserved1;
+ const unsigned ns100 = wReserved2;
+ if (prec == 0
+ && prec <= k_PropVar_TimePrec_1ns
+ && ns100 < 100
+ && wReserved3 == 0)
+ return ns100;
+ return 0;
+ }
+
+ ~CPropVariant() throw();
+ CPropVariant(const PROPVARIANT &varSrc);
+ CPropVariant(const CPropVariant &varSrc);
+ CPropVariant(BSTR bstrSrc);
+ CPropVariant(LPCOLESTR lpszSrc);
+ CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); }
+ CPropVariant(Byte value) { vt = VT_UI1; wReserved1 = 0; bVal = value; }
+
+private:
+ CPropVariant(UInt16 value); // { vt = VT_UI2; wReserved1 = 0; uiVal = value; }
+ CPropVariant(Int16 value); // { vt = VT_I2; wReserved1 = 0; iVal = value; }
+ CPropVariant(Int32 value); // { vt = VT_I4; wReserved1 = 0; lVal = value; }
+ CPropVariant(Int64 value); // { vt = VT_I8; wReserved1 = 0; hVal.QuadPart = value; }
+
+public:
+ CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
+ CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
+ CPropVariant(const FILETIME &value) { vt = VT_FILETIME; wReserved1 = 0; filetime = value; }
+
+ CPropVariant& operator=(const CPropVariant &varSrc);
+ CPropVariant& operator=(const PROPVARIANT &varSrc);
+ CPropVariant& operator=(BSTR bstrSrc);
+ CPropVariant& operator=(LPCOLESTR lpszSrc);
+ CPropVariant& operator=(const UString &s);
+ CPropVariant& operator=(const UString2 &s);
+ CPropVariant& operator=(const char *s);
+ CPropVariant& operator=(const AString &s)
+ { return (*this)=(const char *)s; }
+
+ CPropVariant& operator=(bool bSrc) throw();
+ CPropVariant& operator=(Byte value) throw();
+
+private:
+ CPropVariant& operator=(Int16 value) throw();
+ CPropVariant& operator=(UInt16 value) throw();
+ CPropVariant& operator=(Int32 value) throw();
+ CPropVariant& operator=(Int64 value) throw();
+
+public:
+ CPropVariant& operator=(UInt32 value) throw();
+ CPropVariant& operator=(UInt64 value) throw();
+ CPropVariant& operator=(const FILETIME &value) throw();
+
+ void Set_Int32(Int32 value) throw();
+ void Set_Int64(Int64 value) throw();
+
+ BSTR AllocBstr(unsigned numChars);
+
+ HRESULT Clear() throw();
+ HRESULT Copy(const PROPVARIANT *pSrc) throw();
+ HRESULT Attach(PROPVARIANT *pSrc) throw();
+ HRESULT Detach(PROPVARIANT *pDest) throw();
+
+ HRESULT InternalClear() throw();
+ void InternalCopy(const PROPVARIANT *pSrc);
+ int Compare(const CPropVariant &a) throw();
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/PropVariantConv.cpp b/CPP/Windows/PropVariantConv.cpp
index c5ac212..5fb96a7 100644
--- a/CPP/Windows/PropVariantConv.cpp
+++ b/CPP/Windows/PropVariantConv.cpp
@@ -1,138 +1,190 @@
-// PropVariantConvert.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/IntToString.h"
-
-#include "Defs.h"
-#include "PropVariantConv.h"
-
-#define UINT_TO_STR_2(c, val) { s[0] = (c); s[1] = (char)('0' + (val) / 10); s[2] = (char)('0' + (val) % 10); s += 3; }
-
-bool ConvertUtcFileTimeToString(const FILETIME &utc, char *s, int level) throw()
-{
- *s = 0;
- FILETIME ft;
- if (!FileTimeToLocalFileTime(&utc, &ft))
- return false;
-
- SYSTEMTIME st;
- if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
- return false;
-
- {
- unsigned val = st.wYear;
- if (val >= 10000)
- {
- *s++ = (char)('0' + val / 10000);
- val %= 10000;
- }
- s[3] = (char)('0' + val % 10); val /= 10;
- s[2] = (char)('0' + val % 10); val /= 10;
- s[1] = (char)('0' + val % 10);
- s[0] = (char)('0' + val / 10);
- s += 4;
- }
- UINT_TO_STR_2('-', st.wMonth);
- UINT_TO_STR_2('-', st.wDay);
-
- if (level > kTimestampPrintLevel_DAY)
- {
- UINT_TO_STR_2(' ', st.wHour);
- UINT_TO_STR_2(':', st.wMinute);
-
- if (level >= kTimestampPrintLevel_SEC)
- {
- UINT_TO_STR_2(':', st.wSecond);
-
- if (level > kTimestampPrintLevel_SEC)
- {
- *s++ = '.';
- /*
- {
- unsigned val = st.wMilliseconds;
- s[2] = (char)('0' + val % 10); val /= 10;
- s[1] = (char)('0' + val % 10);
- s[0] = (char)('0' + val / 10);
- s += 3;
- }
- *s++ = ' ';
- */
-
- {
- unsigned numDigits = 7;
- UInt32 val = (UInt32)((((UInt64)ft.dwHighDateTime << 32) + ft.dwLowDateTime) % 10000000);
- for (unsigned i = numDigits; i != 0;)
- {
- i--;
- s[i] = (char)('0' + val % 10); val /= 10;
- }
- if (numDigits > (unsigned)level)
- numDigits = (unsigned)level;
- s += numDigits;
- }
- }
- }
- }
-
- *s = 0;
- return true;
-}
-
-
-bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *dest, int level) throw()
-{
- char s[32];
- bool res = ConvertUtcFileTimeToString(ft, s, level);
- for (unsigned i = 0;; i++)
- {
- unsigned char c = s[i];
- dest[i] = c;
- if (c == 0)
- break;
- }
- return res;
-}
-
-
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw()
-{
- *dest = 0;
- switch (prop.vt)
- {
- case VT_EMPTY: return;
- case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
- case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
- case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
- case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
- case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
- case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
- // case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
- case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
- case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
- case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
- case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? '+' : '-'; dest[1] = 0; return;
- default: dest[0] = '?'; dest[1] = ':'; ConvertUInt64ToString(prop.vt, dest + 2);
- }
-}
-
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw()
-{
- *dest = 0;
- switch (prop.vt)
- {
- case VT_EMPTY: return;
- case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
- case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
- case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
- case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
- case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
- case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
- // case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
- case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
- case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
- case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
- case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? (wchar_t)'+' : (wchar_t)'-'; dest[1] = 0; return;
- default: dest[0] = '?'; dest[1] = ':'; ConvertUInt32ToString(prop.vt, dest + 2);
- }
-}
+// PropVariantConv.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/IntToString.h"
+
+#include "Defs.h"
+#include "PropVariantConv.h"
+
+#define UINT_TO_STR_2(c, val) { s[0] = (c); s[1] = (char)('0' + (val) / 10); s[2] = (char)('0' + (val) % 10); s += 3; }
+
+bool ConvertUtcFileTimeToString2(const FILETIME &utc, unsigned ns100, char *s, int level) throw()
+{
+ *s = 0;
+ FILETIME ft;
+ if (!FileTimeToLocalFileTime(&utc, &ft))
+ return false;
+
+ SYSTEMTIME st;
+ if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
+ {
+ // win10 : that function doesn't work, if bit 63 of 64-bit FILETIME is set.
+ return false;
+ }
+
+ {
+ unsigned val = st.wYear;
+ if (val >= 10000)
+ {
+ *s++ = (char)('0' + val / 10000);
+ val %= 10000;
+ }
+ s[3] = (char)('0' + val % 10); val /= 10;
+ s[2] = (char)('0' + val % 10); val /= 10;
+ s[1] = (char)('0' + val % 10);
+ s[0] = (char)('0' + val / 10);
+ s += 4;
+ }
+ UINT_TO_STR_2('-', st.wMonth)
+ UINT_TO_STR_2('-', st.wDay)
+
+ if (level > kTimestampPrintLevel_DAY)
+ {
+ UINT_TO_STR_2(' ', st.wHour)
+ UINT_TO_STR_2(':', st.wMinute)
+
+ if (level >= kTimestampPrintLevel_SEC)
+ {
+ UINT_TO_STR_2(':', st.wSecond)
+
+ if (level > kTimestampPrintLevel_SEC)
+ {
+ *s++ = '.';
+ /*
+ {
+ unsigned val = st.wMilliseconds;
+ s[2] = (char)('0' + val % 10); val /= 10;
+ s[1] = (char)('0' + val % 10);
+ s[0] = (char)('0' + val / 10);
+ s += 3;
+ }
+ *s++ = ' ';
+ */
+
+ {
+ unsigned numDigits = 7;
+ UInt32 val = (UInt32)((((UInt64)ft.dwHighDateTime << 32) + ft.dwLowDateTime) % 10000000);
+ for (unsigned i = numDigits; i != 0;)
+ {
+ i--;
+ s[i] = (char)('0' + val % 10); val /= 10;
+ }
+ if (numDigits > (unsigned)level)
+ numDigits = (unsigned)level;
+ s += numDigits;
+ }
+ if (level >= kTimestampPrintLevel_NTFS + 1)
+ {
+ *s++ = (char)('0' + (ns100 / 10));
+ if (level >= kTimestampPrintLevel_NTFS + 2)
+ *s++ = (char)('0' + (ns100 % 10));
+ }
+ }
+ }
+ }
+
+ *s = 0;
+ return true;
+}
+
+
+bool ConvertUtcFileTimeToString(const FILETIME &utc, char *s, int level) throw()
+{
+ return ConvertUtcFileTimeToString2(utc, 0, s, level);
+}
+
+bool ConvertUtcFileTimeToString2(const FILETIME &ft, unsigned ns100, wchar_t *dest, int level) throw()
+{
+ char s[32];
+ bool res = ConvertUtcFileTimeToString2(ft, ns100, s, level);
+ for (unsigned i = 0;; i++)
+ {
+ Byte c = (Byte)s[i];
+ dest[i] = c;
+ if (c == 0)
+ break;
+ }
+ return res;
+}
+
+bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *dest, int level) throw()
+{
+ char s[32];
+ bool res = ConvertUtcFileTimeToString(ft, s, level);
+ for (unsigned i = 0;; i++)
+ {
+ Byte c = (Byte)s[i];
+ dest[i] = c;
+ if (c == 0)
+ break;
+ }
+ return res;
+}
+
+
+void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw()
+{
+ *dest = 0;
+ switch (prop.vt)
+ {
+ case VT_EMPTY: return;
+ case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
+ case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
+ case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
+ case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
+ case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
+ case VT_FILETIME:
+ {
+ // const unsigned prec = prop.wReserved1;
+ int level = 0;
+ /*
+ if (prec == 0)
+ level = 7;
+ else if (prec > 16 && prec <= 16 + 9)
+ level = prec - 16;
+ */
+ ConvertUtcFileTimeToString(prop.filetime, dest, level);
+ return;
+ }
+ // case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
+ case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
+ case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
+ case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
+ case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? '+' : '-'; dest[1] = 0; return;
+ default: dest[0] = '?'; dest[1] = ':'; ConvertUInt64ToString(prop.vt, dest + 2);
+ }
+}
+
+void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw()
+{
+ *dest = 0;
+ switch (prop.vt)
+ {
+ case VT_EMPTY: return;
+ case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
+ case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
+ case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
+ case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
+ case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
+ case VT_FILETIME:
+ {
+ // const unsigned prec = prop.wReserved1;
+ int level = 0;
+ /*
+ if (prec == 0)
+ level = 7;
+ else if (prec > 16 && prec <= 16 + 9)
+ level = prec - 16;
+ */
+ ConvertUtcFileTimeToString(prop.filetime, dest, level);
+ return;
+ }
+ // case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
+ case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
+ case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
+ case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
+ case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? (wchar_t)'+' : (wchar_t)'-'; dest[1] = 0; return;
+ default: dest[0] = '?'; dest[1] = ':'; ConvertUInt32ToString(prop.vt, dest + 2);
+ }
+}
diff --git a/CPP/Windows/PropVariantConv.h b/CPP/Windows/PropVariantConv.h
index 3e24569..ec5223b 100644
--- a/CPP/Windows/PropVariantConv.h
+++ b/CPP/Windows/PropVariantConv.h
@@ -1,37 +1,40 @@
-// Windows/PropVariantConv.h
-
-#ifndef __PROP_VARIANT_CONV_H
-#define __PROP_VARIANT_CONV_H
-
-#include "../Common/MyTypes.h"
-
-// provide at least 32 bytes for buffer including zero-end
-
-#define kTimestampPrintLevel_DAY -3
-// #define kTimestampPrintLevel_HOUR -2
-#define kTimestampPrintLevel_MIN -1
-#define kTimestampPrintLevel_SEC 0
-#define kTimestampPrintLevel_NTFS 7
-
-bool ConvertUtcFileTimeToString(const FILETIME &ft, char *s, int level = kTimestampPrintLevel_SEC) throw();
-bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *s, int level = kTimestampPrintLevel_SEC) throw();
-
-// provide at least 32 bytes for buffer including zero-end
-// don't send VT_BSTR to these functions
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw();
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw();
-
-inline bool ConvertPropVariantToUInt64(const PROPVARIANT &prop, UInt64 &value)
-{
- switch (prop.vt)
- {
- case VT_UI8: value = (UInt64)prop.uhVal.QuadPart; return true;
- case VT_UI4: value = prop.ulVal; return true;
- case VT_UI2: value = prop.uiVal; return true;
- case VT_UI1: value = prop.bVal; return true;
- case VT_EMPTY: return false;
- default: throw 151199;
- }
-}
-
-#endif
+// Windows/PropVariantConv.h
+
+#ifndef ZIP7_INC_PROP_VARIANT_CONV_H
+#define ZIP7_INC_PROP_VARIANT_CONV_H
+
+#include "../Common/MyTypes.h"
+
+// provide at least 32 bytes for buffer including zero-end
+
+#define kTimestampPrintLevel_DAY -3
+// #define kTimestampPrintLevel_HOUR -2
+#define kTimestampPrintLevel_MIN -1
+#define kTimestampPrintLevel_SEC 0
+#define kTimestampPrintLevel_NTFS 7
+#define kTimestampPrintLevel_NS 9
+
+bool ConvertUtcFileTimeToString(const FILETIME &ft, char *s, int level = kTimestampPrintLevel_SEC) throw();
+bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *s, int level = kTimestampPrintLevel_SEC) throw();
+bool ConvertUtcFileTimeToString2(const FILETIME &ft, unsigned ns100, char *s, int level = kTimestampPrintLevel_SEC) throw();
+bool ConvertUtcFileTimeToString2(const FILETIME &ft, unsigned ns100, wchar_t *s, int level = kTimestampPrintLevel_SEC) throw();
+
+// provide at least 32 bytes for buffer including zero-end
+// don't send VT_BSTR to these functions
+void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw();
+void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw();
+
+inline bool ConvertPropVariantToUInt64(const PROPVARIANT &prop, UInt64 &value)
+{
+ switch (prop.vt)
+ {
+ case VT_UI8: value = (UInt64)prop.uhVal.QuadPart; return true;
+ case VT_UI4: value = prop.ulVal; return true;
+ case VT_UI2: value = prop.uiVal; return true;
+ case VT_UI1: value = prop.bVal; return true;
+ case VT_EMPTY: return false;
+ default: throw 151199;
+ }
+}
+
+#endif
diff --git a/CPP/Windows/PropVariantUtils.cpp b/CPP/Windows/PropVariantUtils.cpp
new file mode 100644
index 0000000..6daee83
--- /dev/null
+++ b/CPP/Windows/PropVariantUtils.cpp
@@ -0,0 +1,161 @@
+// PropVariantUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/IntToString.h"
+
+#include "PropVariantUtils.h"
+
+using namespace NWindows;
+
+static void AddHex(AString &s, UInt32 v)
+{
+ char sz[16];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt32ToHex(v, sz + 2);
+ s += sz;
+}
+
+
+AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
+{
+ char sz[16];
+ const char *p = NULL;
+ for (unsigned i = 0; i < num; i++)
+ {
+ const CUInt32PCharPair &pair = pairs[i];
+ if (pair.Value == value)
+ p = pair.Name;
+ }
+ if (!p)
+ {
+ ConvertUInt32ToString(value, sz);
+ p = sz;
+ }
+ return (AString)p;
+}
+
+void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
+{
+ prop = TypePairToString(pairs, num, value);
+}
+
+
+AString TypeToString(const char * const table[], unsigned num, UInt32 value)
+{
+ char sz[16];
+ const char *p = NULL;
+ if (value < num)
+ p = table[value];
+ if (!p)
+ {
+ ConvertUInt32ToString(value, sz);
+ p = sz;
+ }
+ return (AString)p;
+}
+
+void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop)
+{
+ char sz[16];
+ const char *p = NULL;
+ if (value < num)
+ p = table[value];
+ if (!p)
+ {
+ ConvertUInt32ToString(value, sz);
+ p = sz;
+ }
+ prop = p;
+}
+
+
+AString FlagsToString(const char * const *names, unsigned num, UInt32 flags)
+{
+ AString s;
+ for (unsigned i = 0; i < num; i++)
+ {
+ UInt32 flag = (UInt32)1 << i;
+ if ((flags & flag) != 0)
+ {
+ const char *name = names[i];
+ if (name && name[0] != 0)
+ {
+ s.Add_OptSpaced(name);
+ flags &= ~flag;
+ }
+ }
+ }
+ if (flags != 0)
+ {
+ s.Add_Space_if_NotEmpty();
+ AddHex(s, flags);
+ }
+ return s;
+}
+
+AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
+{
+ AString s;
+ for (unsigned i = 0; i < num; i++)
+ {
+ const CUInt32PCharPair &p = pairs[i];
+ UInt32 flag = (UInt32)1 << (unsigned)p.Value;
+ if ((flags & flag) != 0)
+ {
+ if (p.Name[0] != 0)
+ s.Add_OptSpaced(p.Name);
+ }
+ flags &= ~flag;
+ }
+ if (flags != 0)
+ {
+ s.Add_Space_if_NotEmpty();
+ AddHex(s, flags);
+ }
+ return s;
+}
+
+void FlagsToProp(const char * const *names, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
+{
+ prop = FlagsToString(names, num, flags);
+}
+
+void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
+{
+ prop = FlagsToString(pairs, num, flags);
+}
+
+
+static AString Flags64ToString(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags)
+{
+ AString s;
+ for (unsigned i = 0; i < num; i++)
+ {
+ const CUInt32PCharPair &p = pairs[i];
+ UInt64 flag = (UInt64)1 << (unsigned)p.Value;
+ if ((flags & flag) != 0)
+ {
+ if (p.Name[0] != 0)
+ s.Add_OptSpaced(p.Name);
+ }
+ flags &= ~flag;
+ }
+ if (flags != 0)
+ {
+ {
+ char sz[32];
+ sz[0] = '0';
+ sz[1] = 'x';
+ ConvertUInt64ToHex(flags, sz + 2);
+ s.Add_OptSpaced(sz);
+ }
+ }
+ return s;
+}
+
+void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NCOM::CPropVariant &prop)
+{
+ prop = Flags64ToString(pairs, num, flags);
+}
diff --git a/CPP/Windows/PropVariantUtils.h b/CPP/Windows/PropVariantUtils.h
new file mode 100644
index 0000000..78adb50
--- /dev/null
+++ b/CPP/Windows/PropVariantUtils.h
@@ -0,0 +1,34 @@
+// Windows/PropVariantUtils.h
+
+#ifndef ZIP7_INC_PROP_VARIANT_UTILS_H
+#define ZIP7_INC_PROP_VARIANT_UTILS_H
+
+#include "../Common/MyString.h"
+
+#include "PropVariant.h"
+
+struct CUInt32PCharPair
+{
+ UInt32 Value;
+ const char *Name;
+};
+
+AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value);
+void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
+
+AString FlagsToString(const char * const *names, unsigned num, UInt32 flags);
+AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags);
+void FlagsToProp(const char * const *names, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
+void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
+
+AString TypeToString(const char * const table[], unsigned num, UInt32 value);
+void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
+
+#define PAIR_TO_PROP(pairs, value, prop) PairToProp(pairs, Z7_ARRAY_SIZE(pairs), value, prop)
+#define FLAGS_TO_PROP(pairs, value, prop) FlagsToProp(pairs, Z7_ARRAY_SIZE(pairs), value, prop)
+#define TYPE_TO_PROP(table, value, prop) TypeToProp(table, Z7_ARRAY_SIZE(table), value, prop)
+
+void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NWindows::NCOM::CPropVariant &prop);
+#define FLAGS64_TO_PROP(pairs, value, prop) Flags64ToProp(pairs, Z7_ARRAY_SIZE(pairs), value, prop)
+
+#endif
diff --git a/CPP/Windows/Registry.cpp b/CPP/Windows/Registry.cpp
index 0146621..b20157d 100644
--- a/CPP/Windows/Registry.cpp
+++ b/CPP/Windows/Registry.cpp
@@ -1,390 +1,406 @@
-// Windows/Registry.cpp
-
-#include "StdAfx.h"
-
-#include <wchar.h>
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-#include "Registry.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NRegistry {
-
-#define MYASSERT(expr) // _ASSERTE(expr)
-
-LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
- LPTSTR keyClass, DWORD options, REGSAM accessMask,
- LPSECURITY_ATTRIBUTES securityAttributes, LPDWORD disposition) throw()
-{
- MYASSERT(parentKey != NULL);
- DWORD dispositionReal;
- HKEY key = NULL;
- LONG res = RegCreateKeyEx(parentKey, keyName, 0, keyClass,
- options, accessMask, securityAttributes, &key, &dispositionReal);
- if (disposition != NULL)
- *disposition = dispositionReal;
- if (res == ERROR_SUCCESS)
- {
- res = Close();
- _object = key;
- }
- return res;
-}
-
-LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask) throw()
-{
- MYASSERT(parentKey != NULL);
- HKEY key = NULL;
- LONG res = RegOpenKeyEx(parentKey, keyName, 0, accessMask, &key);
- if (res == ERROR_SUCCESS)
- {
- res = Close();
- MYASSERT(res == ERROR_SUCCESS);
- _object = key;
- }
- return res;
-}
-
-LONG CKey::Close() throw()
-{
- LONG res = ERROR_SUCCESS;
- if (_object != NULL)
- {
- res = RegCloseKey(_object);
- _object = NULL;
- }
- return res;
-}
-
-// win95, win98: deletes sunkey and all its subkeys
-// winNT to be deleted must not have subkeys
-LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
-{
- MYASSERT(_object != NULL);
- return RegDeleteKey(_object, subKeyName);
-}
-
-LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
-{
- CKey key;
- LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
- if (res != ERROR_SUCCESS)
- return res;
- FILETIME fileTime;
- const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
- DWORD size = kBufSize;
- TCHAR buffer[kBufSize];
- while (RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime) == ERROR_SUCCESS)
- {
- res = key.RecurseDeleteKey(buffer);
- if (res != ERROR_SUCCESS)
- return res;
- size = kBufSize;
- }
- key.Close();
- return DeleteSubKey(subKeyName);
-}
-
-
-/////////////////////////
-// Value Functions
-
-static inline UInt32 BoolToUINT32(bool value) { return (value ? 1: 0); }
-static inline bool UINT32ToBool(UInt32 value) { return (value != 0); }
-
-
-LONG CKey::DeleteValue(LPCTSTR name) throw()
-{
- MYASSERT(_object != NULL);
- return ::RegDeleteValue(_object, name);
-}
-
-#ifndef _UNICODE
-LONG CKey::DeleteValue(LPCWSTR name)
-{
- MYASSERT(_object != NULL);
- if (g_IsNT)
- return ::RegDeleteValueW(_object, name);
- return DeleteValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name));
-}
-#endif
-
-LONG CKey::SetValue(LPCTSTR name, UInt32 value) throw()
-{
- MYASSERT(_object != NULL);
- return RegSetValueEx(_object, name, 0, REG_DWORD,
- (BYTE * const)&value, sizeof(UInt32));
-}
-
-LONG CKey::SetValue(LPCTSTR name, bool value) throw()
-{
- return SetValue(name, BoolToUINT32(value));
-}
-
-LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
-{
- MYASSERT(value != NULL);
- MYASSERT(_object != NULL);
- return RegSetValueEx(_object, name, 0, REG_SZ,
- (const BYTE * )value, (lstrlen(value) + 1) * sizeof(TCHAR));
-}
-
-/*
-LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
-{
- MYASSERT(value != NULL);
- MYASSERT(_object != NULL);
- return RegSetValueEx(_object, name, NULL, REG_SZ,
- (const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
-}
-*/
-
-#ifndef _UNICODE
-
-LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
-{
- MYASSERT(value != NULL);
- MYASSERT(_object != NULL);
- if (g_IsNT)
- return RegSetValueExW(_object, name, 0, REG_SZ,
- (const BYTE * )value, (DWORD)((wcslen(value) + 1) * sizeof(wchar_t)));
- return SetValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name),
- value == 0 ? 0 : (LPCSTR)GetSystemString(value));
-}
-
-#endif
-
-
-LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size) throw()
-{
- MYASSERT(value != NULL);
- MYASSERT(_object != NULL);
- return RegSetValueEx(_object, name, 0, REG_BINARY,
- (const BYTE *)value, size);
-}
-
-LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
-{
- MYASSERT(value != NULL);
- CKey key;
- LONG res = key.Create(parentKey, keyName);
- if (res == ERROR_SUCCESS)
- res = key.SetValue(valueName, value);
- return res;
-}
-
-LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw()
-{
- MYASSERT(value != NULL);
- CKey key;
- LONG res = key.Create(_object, keyName);
- if (res == ERROR_SUCCESS)
- res = key.SetValue(valueName, value);
- return res;
-}
-
-LONG CKey::QueryValue(LPCTSTR name, UInt32 &value) throw()
-{
- DWORD type = 0;
- DWORD count = sizeof(DWORD);
- LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type,
- (LPBYTE)&value, &count);
- MYASSERT((res != ERROR_SUCCESS) || (type == REG_DWORD));
- MYASSERT((res != ERROR_SUCCESS) || (count == sizeof(UInt32)));
- return res;
-}
-
-LONG CKey::QueryValue(LPCTSTR name, bool &value) throw()
-{
- UInt32 uintValue = BoolToUINT32(value);
- LONG res = QueryValue(name, uintValue);
- value = UINT32ToBool(uintValue);
- return res;
-}
-
-LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value) throw()
-{
- UInt32 newVal;
- LONG res = QueryValue(name, newVal);
- if (res == ERROR_SUCCESS)
- value = newVal;
- return res;
-}
-
-LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value) throw()
-{
- bool newVal;
- LONG res = QueryValue(name, newVal);
- if (res == ERROR_SUCCESS)
- value = newVal;
- return res;
-}
-
-LONG CKey::QueryValue(LPCTSTR name, LPTSTR value, UInt32 &count) throw()
-{
- DWORD type = 0;
- LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
- MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
- return res;
-}
-
-LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
-{
- value.Empty();
- DWORD type = 0;
- UInt32 curSize = 0;
- LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&curSize);
- if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
- return res;
- UInt32 curSize2 = curSize;
- res = QueryValue(name, value.GetBuf(curSize), curSize2);
- if (curSize > curSize2)
- curSize = curSize2;
- value.ReleaseBuf_CalcLen(curSize / sizeof(TCHAR));
- return res;
-}
-
-
-#ifndef _UNICODE
-
-LONG CKey::QueryValue(LPCWSTR name, LPWSTR value, UInt32 &count)
-{
- DWORD type = 0;
- LONG res = RegQueryValueExW(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
- MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
- return res;
-}
-
-LONG CKey::QueryValue(LPCWSTR name, UString &value)
-{
- value.Empty();
- DWORD type = 0;
- UInt32 curSize = 0;
-
- LONG res;
-
- if (g_IsNT)
- {
- res = RegQueryValueExW(_object, name, NULL, &type, NULL, (DWORD *)&curSize);
- if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
- return res;
- UInt32 curSize2 = curSize;
- res = QueryValue(name, value.GetBuf(curSize), curSize2);
- if (curSize > curSize2)
- curSize = curSize2;
- value.ReleaseBuf_CalcLen(curSize / sizeof(wchar_t));
- }
- else
- {
- AString vTemp;
- res = QueryValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name), vTemp);
- value = GetUnicodeString(vTemp);
- }
-
- return res;
-}
-
-#endif
-
-
-LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &count) throw()
-{
- DWORD type = 0;
- LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
- MYASSERT((res != ERROR_SUCCESS) || (type == REG_BINARY));
- return res;
-}
-
-
-LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
-{
- DWORD type = 0;
- dataSize = 0;
- LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&dataSize);
- if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
- return res;
- value.Alloc(dataSize);
- return QueryValue(name, (BYTE *)value, dataSize);
-}
-
-LONG CKey::EnumKeys(CSysStringVector &keyNames)
-{
- keyNames.Clear();
- CSysString keyName;
- for (DWORD index = 0; ; index++)
- {
- const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
- FILETIME lastWriteTime;
- UInt32 nameSize = kBufSize;
- LONG result = ::RegEnumKeyEx(_object, index, keyName.GetBuf(kBufSize),
- (DWORD *)&nameSize, NULL, NULL, NULL, &lastWriteTime);
- keyName.ReleaseBuf_CalcLen(kBufSize);
- if (result == ERROR_NO_MORE_ITEMS)
- break;
- if (result != ERROR_SUCCESS)
- return result;
- keyNames.Add(keyName);
- }
- return ERROR_SUCCESS;
-}
-
-LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
-{
- size_t numChars = 0;
-
- unsigned i;
-
- for (i = 0; i < strings.Size(); i++)
- numChars += strings[i].Len() + 1;
-
- CObjArray<wchar_t> buffer(numChars);
- size_t pos = 0;
-
- for (i = 0; i < strings.Size(); i++)
- {
- const UString &s = strings[i];
- size_t size = s.Len() + 1;
- wmemcpy(buffer + pos, s, size);
- pos += size;
- }
- return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
-}
-
-LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
-{
- strings.Clear();
- CByteBuffer buffer;
- UInt32 dataSize = 0;
- LONG res = QueryValue(valueName, buffer, dataSize);
- if (res != ERROR_SUCCESS)
- return res;
- if (dataSize > buffer.Size())
- return E_FAIL;
- if (dataSize % sizeof(wchar_t) != 0)
- return E_FAIL;
-
- const wchar_t *data = (const wchar_t *)(const Byte *)buffer;
- size_t numChars = dataSize / sizeof(wchar_t);
- size_t prev = 0;
- UString s;
-
- for (size_t i = 0; i < numChars; i++)
- {
- if (data[i] == 0)
- {
- s = data + prev;
- strings.Add(s);
- prev = i + 1;
- }
- }
-
- return res;
-}
-
-}}
+// Windows/Registry.cpp
+
+#include "StdAfx.h"
+
+#include <wchar.h>
+// #include <stdio.h>
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+#include "Registry.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NRegistry {
+
+#define MYASSERT(expr) // _ASSERTE(expr)
+#define MY_ASSUME(expr)
+
+/*
+static void Error()
+{
+ #ifdef _CONSOLE
+ printf("\nregistry error\n");
+ #else
+ MessageBoxW(0, L"registry error", L"", 0);
+ // exit(1);
+ #endif
+}
+
+#define MY_ASSUME(expr) { if (!(expr)) Error(); }
+*/
+
+LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
+ LPTSTR keyClass, DWORD options, REGSAM accessMask,
+ LPSECURITY_ATTRIBUTES securityAttributes, LPDWORD disposition) throw()
+{
+ MY_ASSUME(parentKey != NULL);
+ DWORD dispositionReal;
+ HKEY key = NULL;
+ LONG res = RegCreateKeyEx(parentKey, keyName, 0, keyClass,
+ options, accessMask, securityAttributes, &key, &dispositionReal);
+ if (disposition != NULL)
+ *disposition = dispositionReal;
+ if (res == ERROR_SUCCESS)
+ {
+ res = Close();
+ _object = key;
+ }
+ return res;
+}
+
+LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask) throw()
+{
+ MY_ASSUME(parentKey != NULL);
+ HKEY key = NULL;
+ LONG res = RegOpenKeyEx(parentKey, keyName, 0, accessMask, &key);
+ if (res == ERROR_SUCCESS)
+ {
+ res = Close();
+ MYASSERT(res == ERROR_SUCCESS);
+ _object = key;
+ }
+ return res;
+}
+
+LONG CKey::Close() throw()
+{
+ LONG res = ERROR_SUCCESS;
+ if (_object != NULL)
+ {
+ res = RegCloseKey(_object);
+ _object = NULL;
+ }
+ return res;
+}
+
+// win95, win98: deletes sunkey and all its subkeys
+// winNT to be deleted must not have subkeys
+LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
+{
+ MY_ASSUME(_object != NULL);
+ return RegDeleteKey(_object, subKeyName);
+}
+
+LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
+{
+ CKey key;
+ LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
+ if (res != ERROR_SUCCESS)
+ return res;
+ FILETIME fileTime;
+ const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
+ DWORD size = kBufSize;
+ TCHAR buffer[kBufSize];
+ while (RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime) == ERROR_SUCCESS)
+ {
+ res = key.RecurseDeleteKey(buffer);
+ if (res != ERROR_SUCCESS)
+ return res;
+ size = kBufSize;
+ }
+ key.Close();
+ return DeleteSubKey(subKeyName);
+}
+
+
+/////////////////////////
+// Value Functions
+
+static inline UInt32 BoolToUINT32(bool value) { return (value ? 1: 0); }
+static inline bool UINT32ToBool(UInt32 value) { return (value != 0); }
+
+
+LONG CKey::DeleteValue(LPCTSTR name) throw()
+{
+ MY_ASSUME(_object != NULL);
+ return ::RegDeleteValue(_object, name);
+}
+
+#ifndef _UNICODE
+LONG CKey::DeleteValue(LPCWSTR name)
+{
+ MY_ASSUME(_object != NULL);
+ if (g_IsNT)
+ return ::RegDeleteValueW(_object, name);
+ return DeleteValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name));
+}
+#endif
+
+LONG CKey::SetValue(LPCTSTR name, UInt32 value) throw()
+{
+ MY_ASSUME(_object != NULL);
+ return RegSetValueEx(_object, name, 0, REG_DWORD,
+ (const BYTE *)&value, sizeof(UInt32));
+}
+
+LONG CKey::SetValue(LPCTSTR name, bool value) throw()
+{
+ return SetValue(name, BoolToUINT32(value));
+}
+
+LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
+{
+ MYASSERT(value != NULL);
+ MY_ASSUME(_object != NULL);
+ return RegSetValueEx(_object, name, 0, REG_SZ,
+ (const BYTE *)value, ((DWORD)lstrlen(value) + 1) * sizeof(TCHAR));
+}
+
+/*
+LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
+{
+ MYASSERT(value != NULL);
+ MY_ASSUME(_object != NULL);
+ return RegSetValueEx(_object, name, NULL, REG_SZ,
+ (const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
+}
+*/
+
+#ifndef _UNICODE
+
+LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
+{
+ MYASSERT(value != NULL);
+ MY_ASSUME(_object != NULL);
+ if (g_IsNT)
+ return RegSetValueExW(_object, name, 0, REG_SZ,
+ (const BYTE * )value, (DWORD)((wcslen(value) + 1) * sizeof(wchar_t)));
+ return SetValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name),
+ value == 0 ? 0 : (LPCSTR)GetSystemString(value));
+}
+
+#endif
+
+
+LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size) throw()
+{
+ MYASSERT(value != NULL);
+ MY_ASSUME(_object != NULL);
+ return RegSetValueEx(_object, name, 0, REG_BINARY,
+ (const BYTE *)value, size);
+}
+
+LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
+{
+ MYASSERT(value != NULL);
+ CKey key;
+ LONG res = key.Create(parentKey, keyName);
+ if (res == ERROR_SUCCESS)
+ res = key.SetValue(valueName, value);
+ return res;
+}
+
+LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw()
+{
+ MYASSERT(value != NULL);
+ CKey key;
+ LONG res = key.Create(_object, keyName);
+ if (res == ERROR_SUCCESS)
+ res = key.SetValue(valueName, value);
+ return res;
+}
+
+LONG CKey::QueryValue(LPCTSTR name, UInt32 &value) throw()
+{
+ DWORD type = 0;
+ DWORD count = sizeof(DWORD);
+ LONG res = RegQueryValueEx(_object, name, NULL, &type,
+ (LPBYTE)&value, &count);
+ MYASSERT((res != ERROR_SUCCESS) || (type == REG_DWORD));
+ MYASSERT((res != ERROR_SUCCESS) || (count == sizeof(UInt32)));
+ return res;
+}
+
+LONG CKey::QueryValue(LPCTSTR name, bool &value) throw()
+{
+ UInt32 uintValue = BoolToUINT32(value);
+ LONG res = QueryValue(name, uintValue);
+ value = UINT32ToBool(uintValue);
+ return res;
+}
+
+LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value) throw()
+{
+ UInt32 newVal;
+ LONG res = QueryValue(name, newVal);
+ if (res == ERROR_SUCCESS)
+ value = newVal;
+ return res;
+}
+
+LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value) throw()
+{
+ bool newVal = false;
+ LONG res = QueryValue(name, newVal);
+ if (res == ERROR_SUCCESS)
+ value = newVal;
+ return res;
+}
+
+LONG CKey::QueryValue(LPCTSTR name, LPTSTR value, UInt32 &count) throw()
+{
+ DWORD type = 0;
+ LONG res = RegQueryValueEx(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
+ MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
+ return res;
+}
+
+LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
+{
+ value.Empty();
+ DWORD type = 0;
+ UInt32 curSize = 0;
+ LONG res = RegQueryValueEx(_object, name, NULL, &type, NULL, (DWORD *)&curSize);
+ if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
+ return res;
+ UInt32 curSize2 = curSize;
+ res = QueryValue(name, value.GetBuf(curSize), curSize2);
+ if (curSize > curSize2)
+ curSize = curSize2;
+ value.ReleaseBuf_CalcLen(curSize / sizeof(TCHAR));
+ return res;
+}
+
+
+#ifndef _UNICODE
+
+LONG CKey::QueryValue(LPCWSTR name, LPWSTR value, UInt32 &count)
+{
+ DWORD type = 0;
+ LONG res = RegQueryValueExW(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
+ MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
+ return res;
+}
+
+LONG CKey::QueryValue(LPCWSTR name, UString &value)
+{
+ value.Empty();
+ DWORD type = 0;
+ UInt32 curSize = 0;
+
+ LONG res;
+
+ if (g_IsNT)
+ {
+ res = RegQueryValueExW(_object, name, NULL, &type, NULL, (DWORD *)&curSize);
+ if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
+ return res;
+ UInt32 curSize2 = curSize;
+ res = QueryValue(name, value.GetBuf(curSize), curSize2);
+ if (curSize > curSize2)
+ curSize = curSize2;
+ value.ReleaseBuf_CalcLen(curSize / sizeof(wchar_t));
+ }
+ else
+ {
+ AString vTemp;
+ res = QueryValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name), vTemp);
+ value = GetUnicodeString(vTemp);
+ }
+
+ return res;
+}
+
+#endif
+
+
+LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &count) throw()
+{
+ DWORD type = 0;
+ LONG res = RegQueryValueEx(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
+ MYASSERT((res != ERROR_SUCCESS) || (type == REG_BINARY));
+ return res;
+}
+
+
+LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
+{
+ DWORD type = 0;
+ dataSize = 0;
+ LONG res = RegQueryValueEx(_object, name, NULL, &type, NULL, (DWORD *)&dataSize);
+ if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
+ return res;
+ value.Alloc(dataSize);
+ return QueryValue(name, (BYTE *)value, dataSize);
+}
+
+LONG CKey::EnumKeys(CSysStringVector &keyNames)
+{
+ keyNames.Clear();
+ CSysString keyName;
+ for (DWORD index = 0; ; index++)
+ {
+ const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
+ FILETIME lastWriteTime;
+ UInt32 nameSize = kBufSize;
+ LONG result = ::RegEnumKeyEx(_object, index, keyName.GetBuf(kBufSize),
+ (DWORD *)&nameSize, NULL, NULL, NULL, &lastWriteTime);
+ keyName.ReleaseBuf_CalcLen(kBufSize);
+ if (result == ERROR_NO_MORE_ITEMS)
+ break;
+ if (result != ERROR_SUCCESS)
+ return result;
+ keyNames.Add(keyName);
+ }
+ return ERROR_SUCCESS;
+}
+
+LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
+{
+ size_t numChars = 0;
+
+ unsigned i;
+
+ for (i = 0; i < strings.Size(); i++)
+ numChars += strings[i].Len() + 1;
+
+ CObjArray<wchar_t> buffer(numChars);
+ size_t pos = 0;
+
+ for (i = 0; i < strings.Size(); i++)
+ {
+ const UString &s = strings[i];
+ size_t size = s.Len() + 1;
+ wmemcpy(buffer + pos, s, size);
+ pos += size;
+ }
+ return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
+}
+
+LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
+{
+ strings.Clear();
+ CByteBuffer buffer;
+ UInt32 dataSize = 0;
+ LONG res = QueryValue(valueName, buffer, dataSize);
+ if (res != ERROR_SUCCESS)
+ return res;
+ if (dataSize > buffer.Size())
+ return E_FAIL;
+ if (dataSize % sizeof(wchar_t) != 0)
+ return E_FAIL;
+
+ const wchar_t *data = (const wchar_t *)(const void *)(const Byte *)buffer;
+ size_t numChars = dataSize / sizeof(wchar_t);
+ size_t prev = 0;
+ UString s;
+
+ for (size_t i = 0; i < numChars; i++)
+ {
+ if (data[i] == 0)
+ {
+ s = data + prev;
+ strings.Add(s);
+ prev = i + 1;
+ }
+ }
+
+ return res;
+}
+
+}}
diff --git a/CPP/Windows/Registry.h b/CPP/Windows/Registry.h
index 0a31230..0d3b4fc 100644
--- a/CPP/Windows/Registry.h
+++ b/CPP/Windows/Registry.h
@@ -1,84 +1,84 @@
-// Windows/Registry.h
-
-#ifndef __WINDOWS_REGISTRY_H
-#define __WINDOWS_REGISTRY_H
-
-#include "../Common/MyBuffer.h"
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NRegistry {
-
-LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value);
-
-class CKey
-{
- HKEY _object;
-public:
- CKey(): _object(NULL) {}
- ~CKey() { Close(); }
-
- operator HKEY() const { return _object; }
- void Attach(HKEY key) { _object = key; }
- HKEY Detach()
- {
- HKEY key = _object;
- _object = NULL;
- return key;
- }
-
- LONG Create(HKEY parentKey, LPCTSTR keyName,
- LPTSTR keyClass = REG_NONE, DWORD options = REG_OPTION_NON_VOLATILE,
- REGSAM accessMask = KEY_ALL_ACCESS,
- LPSECURITY_ATTRIBUTES securityAttributes = NULL,
- LPDWORD disposition = NULL) throw();
- LONG Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask = KEY_ALL_ACCESS) throw();
-
- LONG Close() throw();
-
- LONG DeleteSubKey(LPCTSTR subKeyName) throw();
- LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
-
- LONG DeleteValue(LPCTSTR name) throw();
- #ifndef _UNICODE
- LONG DeleteValue(LPCWSTR name);
- #endif
-
- LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
- LONG SetValue(LPCTSTR valueName, bool value) throw();
- LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
- // LONG SetValue(LPCTSTR valueName, const CSysString &value);
- #ifndef _UNICODE
- LONG SetValue(LPCWSTR name, LPCWSTR value);
- // LONG SetValue(LPCWSTR name, const UString &value);
- #endif
-
- LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
-
- LONG SetValue_Strings(LPCTSTR valueName, const UStringVector &strings);
- LONG GetValue_Strings(LPCTSTR valueName, UStringVector &strings);
-
- LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
-
- LONG QueryValue(LPCTSTR name, UInt32 &value) throw();
- LONG QueryValue(LPCTSTR name, bool &value) throw();
- LONG QueryValue(LPCTSTR name, LPTSTR value, UInt32 &dataSize) throw();
- LONG QueryValue(LPCTSTR name, CSysString &value);
-
- LONG GetValue_IfOk(LPCTSTR name, UInt32 &value) throw();
- LONG GetValue_IfOk(LPCTSTR name, bool &value) throw();
-
- #ifndef _UNICODE
- LONG QueryValue(LPCWSTR name, LPWSTR value, UInt32 &dataSize);
- LONG QueryValue(LPCWSTR name, UString &value);
- #endif
-
- LONG QueryValue(LPCTSTR name, void *value, UInt32 &dataSize) throw();
- LONG QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize);
-
- LONG EnumKeys(CSysStringVector &keyNames);
-};
-
-}}
-
-#endif
+// Windows/Registry.h
+
+#ifndef ZIP7_INC_WINDOWS_REGISTRY_H
+#define ZIP7_INC_WINDOWS_REGISTRY_H
+
+#include "../Common/MyBuffer.h"
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NRegistry {
+
+LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value);
+
+class CKey
+{
+ HKEY _object;
+public:
+ CKey(): _object(NULL) {}
+ ~CKey() { Close(); }
+
+ operator HKEY() const { return _object; }
+ void Attach(HKEY key) { _object = key; }
+ HKEY Detach()
+ {
+ HKEY key = _object;
+ _object = NULL;
+ return key;
+ }
+
+ LONG Create(HKEY parentKey, LPCTSTR keyName,
+ LPTSTR keyClass = REG_NONE, DWORD options = REG_OPTION_NON_VOLATILE,
+ REGSAM accessMask = KEY_ALL_ACCESS,
+ LPSECURITY_ATTRIBUTES securityAttributes = NULL,
+ LPDWORD disposition = NULL) throw();
+ LONG Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask = KEY_ALL_ACCESS) throw();
+
+ LONG Close() throw();
+
+ LONG DeleteSubKey(LPCTSTR subKeyName) throw();
+ LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
+
+ LONG DeleteValue(LPCTSTR name) throw();
+ #ifndef _UNICODE
+ LONG DeleteValue(LPCWSTR name);
+ #endif
+
+ LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
+ LONG SetValue(LPCTSTR valueName, bool value) throw();
+ LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
+ // LONG SetValue(LPCTSTR valueName, const CSysString &value);
+ #ifndef _UNICODE
+ LONG SetValue(LPCWSTR name, LPCWSTR value);
+ // LONG SetValue(LPCWSTR name, const UString &value);
+ #endif
+
+ LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
+
+ LONG SetValue_Strings(LPCTSTR valueName, const UStringVector &strings);
+ LONG GetValue_Strings(LPCTSTR valueName, UStringVector &strings);
+
+ LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
+
+ LONG QueryValue(LPCTSTR name, UInt32 &value) throw();
+ LONG QueryValue(LPCTSTR name, bool &value) throw();
+ LONG QueryValue(LPCTSTR name, LPTSTR value, UInt32 &dataSize) throw();
+ LONG QueryValue(LPCTSTR name, CSysString &value);
+
+ LONG GetValue_IfOk(LPCTSTR name, UInt32 &value) throw();
+ LONG GetValue_IfOk(LPCTSTR name, bool &value) throw();
+
+ #ifndef _UNICODE
+ LONG QueryValue(LPCWSTR name, LPWSTR value, UInt32 &dataSize);
+ LONG QueryValue(LPCWSTR name, UString &value);
+ #endif
+
+ LONG QueryValue(LPCTSTR name, void *value, UInt32 &dataSize) throw();
+ LONG QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize);
+
+ LONG EnumKeys(CSysStringVector &keyNames);
+};
+
+}}
+
+#endif
diff --git a/CPP/Windows/ResourceString.cpp b/CPP/Windows/ResourceString.cpp
index c28e60e..ae8182e 100644
--- a/CPP/Windows/ResourceString.cpp
+++ b/CPP/Windows/ResourceString.cpp
@@ -1,103 +1,103 @@
-// Windows/ResourceString.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "ResourceString.h"
-
-extern HINSTANCE g_hInstance;
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-
-#ifndef _UNICODE
-
-static CSysString MyLoadStringA(HINSTANCE hInstance, UINT resourceID)
-{
- CSysString s;
- int size = 128;
- int len;
- do
- {
- size <<= 1;
- len = ::LoadString(hInstance, resourceID, s.GetBuf(size - 1), size);
- }
- while (size - len <= 1);
- s.ReleaseBuf_CalcLen(len);
- return s;
-}
-
-#endif
-
-static const int kStartSize = 256;
-
-static void MyLoadString2(HINSTANCE hInstance, UINT resourceID, UString &s)
-{
- int size = kStartSize;
- int len;
- do
- {
- size <<= 1;
- len = ::LoadStringW(hInstance, resourceID, s.GetBuf(size - 1), size);
- }
- while (size - len <= 1);
- s.ReleaseBuf_CalcLen(len);
-}
-
-// NT4 doesn't support LoadStringW(,,, 0) to get pointer to resource string. So we don't use it.
-
-UString MyLoadString(UINT resourceID)
-{
- #ifndef _UNICODE
- if (!g_IsNT)
- return GetUnicodeString(MyLoadStringA(g_hInstance, resourceID));
- else
- #endif
- {
- {
- wchar_t s[kStartSize];
- s[0] = 0;
- int len = ::LoadStringW(g_hInstance, resourceID, s, kStartSize);
- if (kStartSize - len > 1)
- return s;
- }
- UString dest;
- MyLoadString2(g_hInstance, resourceID, dest);
- return dest;
- }
-}
-
-void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest)
-{
- dest.Empty();
- #ifndef _UNICODE
- if (!g_IsNT)
- MultiByteToUnicodeString2(dest, MyLoadStringA(hInstance, resourceID));
- else
- #endif
- {
- {
- wchar_t s[kStartSize];
- s[0] = 0;
- int len = ::LoadStringW(hInstance, resourceID, s, kStartSize);
- if (kStartSize - len > 1)
- {
- dest = s;
- return;
- }
- }
- MyLoadString2(hInstance, resourceID, dest);
- }
-}
-
-void MyLoadString(UINT resourceID, UString &dest)
-{
- MyLoadString(g_hInstance, resourceID, dest);
-}
-
-}
+// Windows/ResourceString.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "ResourceString.h"
+
+extern HINSTANCE g_hInstance;
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+#ifndef _UNICODE
+
+static CSysString MyLoadStringA(HINSTANCE hInstance, UINT resourceID)
+{
+ CSysString s;
+ int size = 128;
+ int len;
+ do
+ {
+ size <<= 1;
+ len = ::LoadString(hInstance, resourceID, s.GetBuf((unsigned)size - 1), size);
+ }
+ while (size - len <= 1);
+ s.ReleaseBuf_CalcLen((unsigned)len);
+ return s;
+}
+
+#endif
+
+static const int kStartSize = 256;
+
+static void MyLoadString2(HINSTANCE hInstance, UINT resourceID, UString &s)
+{
+ int size = kStartSize;
+ int len;
+ do
+ {
+ size <<= 1;
+ len = ::LoadStringW(hInstance, resourceID, s.GetBuf((unsigned)size - 1), size);
+ }
+ while (size - len <= 1);
+ s.ReleaseBuf_CalcLen((unsigned)len);
+}
+
+// NT4 doesn't support LoadStringW(,,, 0) to get pointer to resource string. So we don't use it.
+
+UString MyLoadString(UINT resourceID)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ return GetUnicodeString(MyLoadStringA(g_hInstance, resourceID));
+ else
+ #endif
+ {
+ {
+ wchar_t s[kStartSize];
+ s[0] = 0;
+ int len = ::LoadStringW(g_hInstance, resourceID, s, kStartSize);
+ if (kStartSize - len > 1)
+ return s;
+ }
+ UString dest;
+ MyLoadString2(g_hInstance, resourceID, dest);
+ return dest;
+ }
+}
+
+void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest)
+{
+ dest.Empty();
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ MultiByteToUnicodeString2(dest, MyLoadStringA(hInstance, resourceID));
+ else
+ #endif
+ {
+ {
+ wchar_t s[kStartSize];
+ s[0] = 0;
+ int len = ::LoadStringW(hInstance, resourceID, s, kStartSize);
+ if (kStartSize - len > 1)
+ {
+ dest = s;
+ return;
+ }
+ }
+ MyLoadString2(hInstance, resourceID, dest);
+ }
+}
+
+void MyLoadString(UINT resourceID, UString &dest)
+{
+ MyLoadString(g_hInstance, resourceID, dest);
+}
+
+}
diff --git a/CPP/Windows/ResourceString.h b/CPP/Windows/ResourceString.h
index cbaef4b..773307b 100644
--- a/CPP/Windows/ResourceString.h
+++ b/CPP/Windows/ResourceString.h
@@ -1,16 +1,17 @@
-// Windows/ResourceString.h
-
-#ifndef __WINDOWS_RESOURCE_STRING_H
-#define __WINDOWS_RESOURCE_STRING_H
-
-#include "../Common/MyString.h"
-
-namespace NWindows {
-
-UString MyLoadString(UINT resourceID);
-void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest);
-void MyLoadString(UINT resourceID, UString &dest);
-
-}
-
-#endif
+// Windows/ResourceString.h
+
+#ifndef ZIP7_INC_WINDOWS_RESOURCE_STRING_H
+#define ZIP7_INC_WINDOWS_RESOURCE_STRING_H
+
+#include "../Common/MyString.h"
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+
+UString MyLoadString(UINT resourceID);
+void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest);
+void MyLoadString(UINT resourceID, UString &dest);
+
+}
+
+#endif
diff --git a/CPP/Windows/SecurityUtils.cpp b/CPP/Windows/SecurityUtils.cpp
index 8646cc9..d4282d0 100644
--- a/CPP/Windows/SecurityUtils.cpp
+++ b/CPP/Windows/SecurityUtils.cpp
@@ -1,181 +1,186 @@
-// Windows/SecurityUtils.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/MyString.h"
-
-#include "SecurityUtils.h"
-
-namespace NWindows {
-namespace NSecurity {
-
-/*
-bool MyLookupAccountSid(LPCTSTR systemName, PSID sid,
- CSysString &accountName, CSysString &domainName, PSID_NAME_USE sidNameUse)
-{
- DWORD accountNameSize = 0, domainNameSize = 0;
-
- if (!::LookupAccountSid(systemName, sid,
- accountName.GetBuf(0), &accountNameSize,
- domainName.GetBuf(0), &domainNameSize, sidNameUse))
- {
- if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
- return false;
- }
- DWORD accountNameSize2 = accountNameSize, domainNameSize2 = domainNameSize;
- bool result = BOOLToBool(::LookupAccountSid(systemName, sid,
- accountName.GetBuf(accountNameSize), &accountNameSize2,
- domainName.GetBuf(domainNameSize), &domainNameSize2, sidNameUse));
- accountName.ReleaseBuf_CalcLen(accountNameSize);
- domainName.ReleaseBuf_CalcLen(domainNameSize);
- return result;
-}
-*/
-
-static void SetLsaString(LPWSTR src, PLSA_UNICODE_STRING dest)
-{
- int len = (int)wcslen(src);
- dest->Length = (USHORT)(len * sizeof(WCHAR));
- dest->MaximumLength = (USHORT)((len + 1) * sizeof(WCHAR));
- dest->Buffer = src;
-}
-
-/*
-static void MyLookupSids(CPolicy &policy, PSID ps)
-{
- LSA_REFERENCED_DOMAIN_LIST *referencedDomains = NULL;
- LSA_TRANSLATED_NAME *names = NULL;
- NTSTATUS nts = policy.LookupSids(1, &ps, &referencedDomains, &names);
- int res = LsaNtStatusToWinError(nts);
- LsaFreeMemory(referencedDomains);
- LsaFreeMemory(names);
-}
-*/
-
-#ifndef _UNICODE
-typedef BOOL (WINAPI * LookupAccountNameWP)(
- LPCWSTR lpSystemName,
- LPCWSTR lpAccountName,
- PSID Sid,
- LPDWORD cbSid,
- LPWSTR ReferencedDomainName,
- LPDWORD cchReferencedDomainName,
- PSID_NAME_USE peUse
- );
-#endif
-
-static PSID GetSid(LPWSTR accountName)
-{
- #ifndef _UNICODE
- HMODULE hModule = GetModuleHandle(TEXT("Advapi32.dll"));
- if (hModule == NULL)
- return NULL;
- LookupAccountNameWP lookupAccountNameW = (LookupAccountNameWP)GetProcAddress(hModule, "LookupAccountNameW");
- if (lookupAccountNameW == NULL)
- return NULL;
- #endif
-
- DWORD sidLen = 0, domainLen = 0;
- SID_NAME_USE sidNameUse;
- if (!
- #ifdef _UNICODE
- ::LookupAccountNameW
- #else
- lookupAccountNameW
- #endif
- (NULL, accountName, NULL, &sidLen, NULL, &domainLen, &sidNameUse))
- {
- if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
- {
- PSID pSid = ::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sidLen);
- LPWSTR domainName = (LPWSTR)::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (domainLen + 1) * sizeof(WCHAR));
- BOOL res =
- #ifdef _UNICODE
- ::LookupAccountNameW
- #else
- lookupAccountNameW
- #endif
- (NULL, accountName, pSid, &sidLen, domainName, &domainLen, &sidNameUse);
- ::HeapFree(GetProcessHeap(), 0, domainName);
- if (res)
- return pSid;
- }
- }
- return NULL;
-}
-
-#define MY__SE_LOCK_MEMORY_NAME L"SeLockMemoryPrivilege"
-
-bool AddLockMemoryPrivilege()
-{
- CPolicy policy;
- LSA_OBJECT_ATTRIBUTES attr;
- attr.Length = sizeof(attr);
- attr.RootDirectory = NULL;
- attr.ObjectName = NULL;
- attr.Attributes = 0;
- attr.SecurityDescriptor = NULL;
- attr.SecurityQualityOfService = NULL;
- if (policy.Open(NULL, &attr,
- // GENERIC_WRITE)
- POLICY_ALL_ACCESS)
- // STANDARD_RIGHTS_REQUIRED,
- // GENERIC_READ | GENERIC_EXECUTE | POLICY_VIEW_LOCAL_INFORMATION | POLICY_LOOKUP_NAMES)
- != 0)
- return false;
- LSA_UNICODE_STRING userRights;
- wchar_t s[128] = MY__SE_LOCK_MEMORY_NAME;
- SetLsaString(s, &userRights);
- WCHAR userName[256 + 2];
- DWORD size = 256;
- if (!GetUserNameW(userName, &size))
- return false;
- PSID psid = GetSid(userName);
- if (psid == NULL)
- return false;
- bool res = false;
-
- /*
- PLSA_UNICODE_STRING userRightsArray;
- ULONG countOfRights;
- NTSTATUS status = policy.EnumerateAccountRights(psid, &userRightsArray, &countOfRights);
- if (status != 0)
- return false;
- bool finded = false;
- for (ULONG i = 0; i < countOfRights; i++)
- {
- LSA_UNICODE_STRING &ur = userRightsArray[i];
- if (ur.Length != s.Length() * sizeof(WCHAR))
- continue;
- if (wcsncmp(ur.Buffer, s, s.Length()) != 0)
- continue;
- finded = true;
- res = true;
- break;
- }
- if (!finded)
- */
- {
- /*
- LSA_ENUMERATION_INFORMATION *enums;
- ULONG countReturned;
- NTSTATUS status = policy.EnumerateAccountsWithUserRight(&userRights, &enums, &countReturned);
- if (status == 0)
- {
- for (ULONG i = 0; i < countReturned; i++)
- MyLookupSids(policy, enums[i].Sid);
- if (enums)
- ::LsaFreeMemory(enums);
- res = true;
- }
- */
- NTSTATUS status = policy.AddAccountRights(psid, &userRights);
- if (status == 0)
- res = true;
- // ULONG res = LsaNtStatusToWinError(status);
- }
- HeapFree(GetProcessHeap(), 0, psid);
- return res;
-}
-
-}}
+// Windows/SecurityUtils.cpp
+
+#include "StdAfx.h"
+
+#include "SecurityUtils.h"
+
+namespace NWindows {
+namespace NSecurity {
+
+/*
+bool MyLookupAccountSid(LPCTSTR systemName, PSID sid,
+ CSysString &accountName, CSysString &domainName, PSID_NAME_USE sidNameUse)
+{
+ DWORD accountNameSize = 0, domainNameSize = 0;
+
+ if (!::LookupAccountSid(systemName, sid,
+ accountName.GetBuf(0), &accountNameSize,
+ domainName.GetBuf(0), &domainNameSize, sidNameUse))
+ {
+ if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+ return false;
+ }
+ DWORD accountNameSize2 = accountNameSize, domainNameSize2 = domainNameSize;
+ bool result = BOOLToBool(::LookupAccountSid(systemName, sid,
+ accountName.GetBuf(accountNameSize), &accountNameSize2,
+ domainName.GetBuf(domainNameSize), &domainNameSize2, sidNameUse));
+ accountName.ReleaseBuf_CalcLen(accountNameSize);
+ domainName.ReleaseBuf_CalcLen(domainNameSize);
+ return result;
+}
+*/
+
+static void SetLsaString(LPWSTR src, PLSA_UNICODE_STRING dest)
+{
+ const size_t len = (size_t)wcslen(src);
+ dest->Length = (USHORT)(len * sizeof(WCHAR));
+ dest->MaximumLength = (USHORT)((len + 1) * sizeof(WCHAR));
+ dest->Buffer = src;
+}
+
+/*
+static void MyLookupSids(CPolicy &policy, PSID ps)
+{
+ LSA_REFERENCED_DOMAIN_LIST *referencedDomains = NULL;
+ LSA_TRANSLATED_NAME *names = NULL;
+ NTSTATUS nts = policy.LookupSids(1, &ps, &referencedDomains, &names);
+ int res = LsaNtStatusToWinError(nts);
+ LsaFreeMemory(referencedDomains);
+ LsaFreeMemory(names);
+}
+*/
+
+extern "C" {
+
+#ifndef _UNICODE
+typedef BOOL (WINAPI * Func_LookupAccountNameW)(
+ LPCWSTR lpSystemName,
+ LPCWSTR lpAccountName,
+ PSID Sid,
+ LPDWORD cbSid,
+ LPWSTR ReferencedDomainName,
+ LPDWORD cchReferencedDomainName,
+ PSID_NAME_USE peUse
+ );
+#endif
+
+}
+
+static PSID GetSid(LPWSTR accountName)
+{
+ #ifndef _UNICODE
+ const HMODULE hModule = GetModuleHandle(TEXT("advapi32.dll"));
+ if (!hModule)
+ return NULL;
+ const
+ Func_LookupAccountNameW lookupAccountNameW = Z7_GET_PROC_ADDRESS(
+ Func_LookupAccountNameW, hModule,
+ "LookupAccountNameW");
+ if (!lookupAccountNameW)
+ return NULL;
+ #endif
+
+ DWORD sidLen = 0, domainLen = 0;
+ SID_NAME_USE sidNameUse;
+ if (!
+ #ifdef _UNICODE
+ ::LookupAccountNameW
+ #else
+ lookupAccountNameW
+ #endif
+ (NULL, accountName, NULL, &sidLen, NULL, &domainLen, &sidNameUse))
+ {
+ if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+ {
+ const PSID pSid = ::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sidLen);
+ LPWSTR domainName = (LPWSTR)::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (domainLen + 1) * sizeof(WCHAR));
+ const BOOL res =
+ #ifdef _UNICODE
+ ::LookupAccountNameW
+ #else
+ lookupAccountNameW
+ #endif
+ (NULL, accountName, pSid, &sidLen, domainName, &domainLen, &sidNameUse);
+ ::HeapFree(GetProcessHeap(), 0, domainName);
+ if (res)
+ return pSid;
+ }
+ }
+ return NULL;
+}
+
+#define Z7_WIN_SE_LOCK_MEMORY_NAME L"SeLockMemoryPrivilege"
+
+bool AddLockMemoryPrivilege()
+{
+ CPolicy policy;
+ LSA_OBJECT_ATTRIBUTES attr;
+ attr.Length = sizeof(attr);
+ attr.RootDirectory = NULL;
+ attr.ObjectName = NULL;
+ attr.Attributes = 0;
+ attr.SecurityDescriptor = NULL;
+ attr.SecurityQualityOfService = NULL;
+ if (policy.Open(NULL, &attr,
+ // GENERIC_WRITE)
+ POLICY_ALL_ACCESS)
+ // STANDARD_RIGHTS_REQUIRED,
+ // GENERIC_READ | GENERIC_EXECUTE | POLICY_VIEW_LOCAL_INFORMATION | POLICY_LOOKUP_NAMES)
+ != 0)
+ return false;
+ LSA_UNICODE_STRING userRights;
+ wchar_t s[128] = Z7_WIN_SE_LOCK_MEMORY_NAME;
+ SetLsaString(s, &userRights);
+ WCHAR userName[256 + 2];
+ DWORD size = 256;
+ if (!GetUserNameW(userName, &size))
+ return false;
+ const PSID psid = GetSid(userName);
+ if (psid == NULL)
+ return false;
+ bool res = false;
+
+ /*
+ PLSA_UNICODE_STRING userRightsArray;
+ ULONG countOfRights;
+ NTSTATUS status = policy.EnumerateAccountRights(psid, &userRightsArray, &countOfRights);
+ if (status != 0)
+ return false;
+ bool finded = false;
+ for (ULONG i = 0; i < countOfRights; i++)
+ {
+ LSA_UNICODE_STRING &ur = userRightsArray[i];
+ if (ur.Length != s.Length() * sizeof(WCHAR))
+ continue;
+ if (wcsncmp(ur.Buffer, s, s.Length()) != 0)
+ continue;
+ finded = true;
+ res = true;
+ break;
+ }
+ if (!finded)
+ */
+ {
+ /*
+ LSA_ENUMERATION_INFORMATION *enums;
+ ULONG countReturned;
+ NTSTATUS status = policy.EnumerateAccountsWithUserRight(&userRights, &enums, &countReturned);
+ if (status == 0)
+ {
+ for (ULONG i = 0; i < countReturned; i++)
+ MyLookupSids(policy, enums[i].Sid);
+ if (enums)
+ ::LsaFreeMemory(enums);
+ res = true;
+ }
+ */
+ const NTSTATUS status = policy.AddAccountRights(psid, &userRights);
+ if (status == 0)
+ res = true;
+ // ULONG res = LsaNtStatusToWinError(status);
+ }
+ HeapFree(GetProcessHeap(), 0, psid);
+ return res;
+}
+
+}}
diff --git a/CPP/Windows/SecurityUtils.h b/CPP/Windows/SecurityUtils.h
index 16b6606..4ef3939 100644
--- a/CPP/Windows/SecurityUtils.h
+++ b/CPP/Windows/SecurityUtils.h
@@ -1,167 +1,148 @@
-// Windows/SecurityUtils.h
-
-#ifndef __WINDOWS_SECURITY_UTILS_H
-#define __WINDOWS_SECURITY_UTILS_H
-
-#include <NTSecAPI.h>
-
-#include "Defs.h"
-
-namespace NWindows {
-namespace NSecurity {
-
-class CAccessToken
-{
- HANDLE _handle;
-public:
- CAccessToken(): _handle(NULL) {};
- ~CAccessToken() { Close(); }
- bool Close()
- {
- if (_handle == NULL)
- return true;
- bool res = BOOLToBool(::CloseHandle(_handle));
- if (res)
- _handle = NULL;
- return res;
- }
-
- bool OpenProcessToken(HANDLE processHandle, DWORD desiredAccess)
- {
- Close();
- return BOOLToBool(::OpenProcessToken(processHandle, desiredAccess, &_handle));
- }
-
- /*
- bool OpenThreadToken(HANDLE threadHandle, DWORD desiredAccess, bool openAsSelf)
- {
- Close();
- return BOOLToBool(::OpenTreadToken(threadHandle, desiredAccess, BoolToBOOL(anOpenAsSelf), &_handle));
- }
- */
-
- bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState,
- DWORD bufferLength, PTOKEN_PRIVILEGES previousState, PDWORD returnLength)
- { return BOOLToBool(::AdjustTokenPrivileges(_handle, BoolToBOOL(disableAllPrivileges),
- newState, bufferLength, previousState, returnLength)); }
-
- bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState)
- { return AdjustPrivileges(disableAllPrivileges, newState, 0, NULL, NULL); }
-
- bool AdjustPrivileges(PTOKEN_PRIVILEGES newState)
- { return AdjustPrivileges(false, newState); }
-
-};
-
-#ifndef _UNICODE
-typedef NTSTATUS (NTAPI *LsaOpenPolicyP)(PLSA_UNICODE_STRING SystemName,
- PLSA_OBJECT_ATTRIBUTES ObjectAttributes, ACCESS_MASK DesiredAccess, PLSA_HANDLE PolicyHandle);
-typedef NTSTATUS (NTAPI *LsaCloseP)(LSA_HANDLE ObjectHandle);
-typedef NTSTATUS (NTAPI *LsaAddAccountRightsP)(LSA_HANDLE PolicyHandle,
- PSID AccountSid, PLSA_UNICODE_STRING UserRights, ULONG CountOfRights );
-#define MY_STATUS_NOT_IMPLEMENTED ((NTSTATUS)0xC0000002L)
-#endif
-
-struct CPolicy
-{
-protected:
- LSA_HANDLE _handle;
- #ifndef _UNICODE
- HMODULE hModule;
- #endif
-public:
- operator LSA_HANDLE() const { return _handle; }
- CPolicy(): _handle(NULL)
- {
- #ifndef _UNICODE
- hModule = GetModuleHandle(TEXT("Advapi32.dll"));
- #endif
- };
- ~CPolicy() { Close(); }
-
- NTSTATUS Open(PLSA_UNICODE_STRING systemName, PLSA_OBJECT_ATTRIBUTES objectAttributes,
- ACCESS_MASK desiredAccess)
- {
- #ifndef _UNICODE
- if (hModule == NULL)
- return MY_STATUS_NOT_IMPLEMENTED;
- LsaOpenPolicyP lsaOpenPolicy = (LsaOpenPolicyP)GetProcAddress(hModule, "LsaOpenPolicy");
- if (lsaOpenPolicy == NULL)
- return MY_STATUS_NOT_IMPLEMENTED;
- #endif
-
- Close();
- return
- #ifdef _UNICODE
- ::LsaOpenPolicy
- #else
- lsaOpenPolicy
- #endif
- (systemName, objectAttributes, desiredAccess, &_handle);
- }
-
- NTSTATUS Close()
- {
- if (_handle == NULL)
- return 0;
-
- #ifndef _UNICODE
- if (hModule == NULL)
- return MY_STATUS_NOT_IMPLEMENTED;
- LsaCloseP lsaClose = (LsaCloseP)GetProcAddress(hModule, "LsaClose");
- if (lsaClose == NULL)
- return MY_STATUS_NOT_IMPLEMENTED;
- #endif
-
- NTSTATUS res =
- #ifdef _UNICODE
- ::LsaClose
- #else
- lsaClose
- #endif
- (_handle);
- _handle = NULL;
- return res;
- }
-
- NTSTATUS EnumerateAccountsWithUserRight(PLSA_UNICODE_STRING userRights,
- PLSA_ENUMERATION_INFORMATION *enumerationBuffer, PULONG countReturned)
- { return LsaEnumerateAccountsWithUserRight(_handle, userRights, (void **)enumerationBuffer, countReturned); }
-
- NTSTATUS EnumerateAccountRights(PSID sid, PLSA_UNICODE_STRING* userRights, PULONG countOfRights)
- { return ::LsaEnumerateAccountRights(_handle, sid, userRights, countOfRights); }
-
- NTSTATUS LookupSids(ULONG count, PSID* sids,
- PLSA_REFERENCED_DOMAIN_LIST* referencedDomains, PLSA_TRANSLATED_NAME* names)
- { return LsaLookupSids(_handle, count, sids, referencedDomains, names); }
-
- NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
- {
- #ifndef _UNICODE
- if (hModule == NULL)
- return MY_STATUS_NOT_IMPLEMENTED;
- LsaAddAccountRightsP lsaAddAccountRights = (LsaAddAccountRightsP)GetProcAddress(hModule, "LsaAddAccountRights");
- if (lsaAddAccountRights == NULL)
- return MY_STATUS_NOT_IMPLEMENTED;
- #endif
-
- return
- #ifdef _UNICODE
- ::LsaAddAccountRights
- #else
- lsaAddAccountRights
- #endif
- (_handle, accountSid, userRights, countOfRights);
- }
- NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights)
- { return AddAccountRights(accountSid, userRights, 1); }
-
- NTSTATUS RemoveAccountRights(PSID accountSid, bool allRights, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
- { return LsaRemoveAccountRights(_handle, accountSid, (BOOLEAN)(allRights ? TRUE : FALSE), userRights, countOfRights); }
-};
-
-bool AddLockMemoryPrivilege();
-
-}}
-
-#endif
+// Windows/SecurityUtils.h
+
+#ifndef ZIP7_INC_WINDOWS_SECURITY_UTILS_H
+#define ZIP7_INC_WINDOWS_SECURITY_UTILS_H
+
+#include <NTSecAPI.h>
+
+#include "Defs.h"
+
+#ifndef _UNICODE
+
+extern "C" {
+typedef NTSTATUS (NTAPI *Func_LsaOpenPolicy)(PLSA_UNICODE_STRING SystemName,
+ PLSA_OBJECT_ATTRIBUTES ObjectAttributes, ACCESS_MASK DesiredAccess, PLSA_HANDLE PolicyHandle);
+typedef NTSTATUS (NTAPI *Func_LsaClose)(LSA_HANDLE ObjectHandle);
+typedef NTSTATUS (NTAPI *Func_LsaAddAccountRights)(LSA_HANDLE PolicyHandle,
+ PSID AccountSid, PLSA_UNICODE_STRING UserRights, ULONG CountOfRights );
+#define MY_STATUS_NOT_IMPLEMENTED ((NTSTATUS)0xC0000002L)
+}
+
+#define POLICY_FUNC_CALL(fff, str) \
+ if (hModule == NULL) return MY_STATUS_NOT_IMPLEMENTED; \
+ const Func_ ## fff v = Z7_GET_PROC_ADDRESS(Func_ ## fff, hModule, str); \
+ if (!v) return MY_STATUS_NOT_IMPLEMENTED; \
+ const NTSTATUS res = v
+
+#else
+
+#define POLICY_FUNC_CALL(fff, str) \
+ const NTSTATUS res = ::fff
+
+#endif
+
+
+namespace NWindows {
+namespace NSecurity {
+
+class CAccessToken
+{
+ HANDLE _handle;
+public:
+ CAccessToken(): _handle(NULL) {}
+ ~CAccessToken() { Close(); }
+ bool Close()
+ {
+ if (_handle == NULL)
+ return true;
+ bool res = BOOLToBool(::CloseHandle(_handle));
+ if (res)
+ _handle = NULL;
+ return res;
+ }
+
+ bool OpenProcessToken(HANDLE processHandle, DWORD desiredAccess)
+ {
+ Close();
+ return BOOLToBool(::OpenProcessToken(processHandle, desiredAccess, &_handle));
+ }
+
+ /*
+ bool OpenThreadToken(HANDLE threadHandle, DWORD desiredAccess, bool openAsSelf)
+ {
+ Close();
+ return BOOLToBool(::OpenTreadToken(threadHandle, desiredAccess, BoolToBOOL(anOpenAsSelf), &_handle));
+ }
+ */
+
+ bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState,
+ DWORD bufferLength, PTOKEN_PRIVILEGES previousState, PDWORD returnLength)
+ { return BOOLToBool(::AdjustTokenPrivileges(_handle, BoolToBOOL(disableAllPrivileges),
+ newState, bufferLength, previousState, returnLength)); }
+
+ bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState)
+ { return AdjustPrivileges(disableAllPrivileges, newState, 0, NULL, NULL); }
+
+ bool AdjustPrivileges(PTOKEN_PRIVILEGES newState)
+ { return AdjustPrivileges(false, newState); }
+
+};
+
+
+
+
+struct CPolicy
+{
+protected:
+ LSA_HANDLE _handle;
+ #ifndef _UNICODE
+ HMODULE hModule;
+ #endif
+public:
+ operator LSA_HANDLE() const { return _handle; }
+ CPolicy(): _handle(NULL)
+ {
+ #ifndef _UNICODE
+ hModule = GetModuleHandle(TEXT("advapi32.dll"));
+ #endif
+ }
+ ~CPolicy() { Close(); }
+
+ NTSTATUS Open(PLSA_UNICODE_STRING systemName, PLSA_OBJECT_ATTRIBUTES objectAttributes,
+ ACCESS_MASK desiredAccess)
+ {
+ Close();
+ POLICY_FUNC_CALL (LsaOpenPolicy, "LsaOpenPolicy")
+ (systemName, objectAttributes, desiredAccess, &_handle);
+ return res;
+ }
+
+ NTSTATUS Close()
+ {
+ if (_handle == NULL)
+ return 0;
+ POLICY_FUNC_CALL (LsaClose, "LsaClose")
+ (_handle);
+ _handle = NULL;
+ return res;
+ }
+
+ NTSTATUS EnumerateAccountsWithUserRight(PLSA_UNICODE_STRING userRights,
+ PLSA_ENUMERATION_INFORMATION *enumerationBuffer, PULONG countReturned)
+ { return LsaEnumerateAccountsWithUserRight(_handle, userRights, (void **)enumerationBuffer, countReturned); }
+
+ NTSTATUS EnumerateAccountRights(PSID sid, PLSA_UNICODE_STRING* userRights, PULONG countOfRights)
+ { return ::LsaEnumerateAccountRights(_handle, sid, userRights, countOfRights); }
+
+ NTSTATUS LookupSids(ULONG count, PSID* sids,
+ PLSA_REFERENCED_DOMAIN_LIST* referencedDomains, PLSA_TRANSLATED_NAME* names)
+ { return LsaLookupSids(_handle, count, sids, referencedDomains, names); }
+
+ NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
+ {
+ POLICY_FUNC_CALL (LsaAddAccountRights, "LsaAddAccountRights")
+ (_handle, accountSid, userRights, countOfRights);
+ return res;
+ }
+ NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights)
+ { return AddAccountRights(accountSid, userRights, 1); }
+
+ NTSTATUS RemoveAccountRights(PSID accountSid, bool allRights, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
+ { return LsaRemoveAccountRights(_handle, accountSid, (BOOLEAN)(allRights ? TRUE : FALSE), userRights, countOfRights); }
+};
+
+bool AddLockMemoryPrivilege();
+
+}}
+
+#endif
diff --git a/CPP/Windows/Shell.cpp b/CPP/Windows/Shell.cpp
index 7ba82d4..b2a3489 100644
--- a/CPP/Windows/Shell.cpp
+++ b/CPP/Windows/Shell.cpp
@@ -1,358 +1,821 @@
-// Windows/Shell.cpp
-
-#include "StdAfx.h"
-
-/*
-#include <stdio.h>
-#include <string.h>
-*/
-
-#include "../Common/MyCom.h"
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-
-#include "COM.h"
-#include "Shell.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-namespace NShell {
-
-#ifndef UNDER_CE
-
-// SHGetMalloc is unsupported in Windows Mobile?
-
-void CItemIDList::Free()
-{
- if (m_Object == NULL)
- return;
- CMyComPtr<IMalloc> shellMalloc;
- if (::SHGetMalloc(&shellMalloc) != NOERROR)
- throw 41099;
- shellMalloc->Free(m_Object);
- m_Object = NULL;
-}
-
-/*
-CItemIDList::(LPCITEMIDLIST itemIDList): m_Object(NULL)
- { *this = itemIDList; }
-CItemIDList::(const CItemIDList& itemIDList): m_Object(NULL)
- { *this = itemIDList; }
-
-CItemIDList& CItemIDList::operator=(LPCITEMIDLIST object)
-{
- Free();
- if (object != 0)
- {
- UINT32 size = GetSize(object);
- m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
- if (m_Object != NULL)
- MoveMemory(m_Object, object, size);
- }
- return *this;
-}
-
-CItemIDList& CItemIDList::operator=(const CItemIDList &object)
-{
- Free();
- if (object.m_Object != NULL)
- {
- UINT32 size = GetSize(object.m_Object);
- m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
- if (m_Object != NULL)
- MoveMemory(m_Object, object.m_Object, size);
- }
- return *this;
-}
-*/
-
-/////////////////////////////
-// CDrop
-
-void CDrop::Attach(HDROP object)
-{
- Free();
- m_Object = object;
- m_Assigned = true;
-}
-
-void CDrop::Free()
-{
- if (m_MustBeFinished && m_Assigned)
- Finish();
- m_Assigned = false;
-}
-
-UINT CDrop::QueryCountOfFiles()
-{
- return QueryFile(0xFFFFFFFF, (LPTSTR)NULL, 0);
-}
-
-UString CDrop::QueryFileName(UINT fileIndex)
-{
- UString fileName;
- #ifndef _UNICODE
- if (!g_IsNT)
- {
- AString fileNameA;
- UINT bufferSize = QueryFile(fileIndex, (LPTSTR)NULL, 0);
- const unsigned len = bufferSize + 2;
- QueryFile(fileIndex, fileNameA.GetBuf(len), bufferSize + 1);
- fileNameA.ReleaseBuf_CalcLen(len);
- fileName = GetUnicodeString(fileNameA);
- }
- else
- #endif
- {
- UINT bufferSize = QueryFile(fileIndex, (LPWSTR)NULL, 0);
- const unsigned len = bufferSize + 2;
- QueryFile(fileIndex, fileName.GetBuf(len), bufferSize + 1);
- fileName.ReleaseBuf_CalcLen(len);
- }
- return fileName;
-}
-
-void CDrop::QueryFileNames(UStringVector &fileNames)
-{
- UINT numFiles = QueryCountOfFiles();
- /*
- char s[100];
- sprintf(s, "QueryFileNames: %d files", numFiles);
- OutputDebugStringA(s);
- */
- fileNames.ClearAndReserve(numFiles);
- for (UINT i = 0; i < numFiles; i++)
- {
- const UString s2 = QueryFileName(i);
- if (!s2.IsEmpty())
- fileNames.AddInReserved(s2);
- /*
- OutputDebugStringW(L"file ---");
- OutputDebugStringW(s2);
- */
- }
-}
-
-
-bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path)
-{
- const unsigned len = MAX_PATH * 2;
- bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
- path.ReleaseBuf_CalcLen(len);
- return result;
-}
-
-#endif
-
-#ifdef UNDER_CE
-
-bool BrowseForFolder(LPBROWSEINFO, CSysString)
-{
- return false;
-}
-
-bool BrowseForFolder(HWND, LPCTSTR, UINT, LPCTSTR, CSysString &)
-{
- return false;
-}
-
-bool BrowseForFolder(HWND /* owner */, LPCTSTR /* title */,
- LPCTSTR /* initialFolder */, CSysString & /* resultPath */)
-{
- /*
- // SHBrowseForFolder doesn't work before CE 6.0 ?
- if (GetProcAddress(LoadLibrary(L"ceshell.dll", L"SHBrowseForFolder") == 0)
- MessageBoxW(0, L"no", L"", 0);
- else
- MessageBoxW(0, L"yes", L"", 0);
- */
- /*
- UString s = "all files";
- s += " (*.*)";
- return MyGetOpenFileName(owner, title, initialFolder, s, resultPath, true);
- */
- return false;
-}
-
-#else
-
-bool BrowseForFolder(LPBROWSEINFO browseInfo, CSysString &resultPath)
-{
- NWindows::NCOM::CComInitializer comInitializer;
- LPITEMIDLIST itemIDList = ::SHBrowseForFolder(browseInfo);
- if (itemIDList == NULL)
- return false;
- CItemIDList itemIDListHolder;
- itemIDListHolder.Attach(itemIDList);
- return GetPathFromIDList(itemIDList, resultPath);
-}
-
-
-int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
-{
- #ifndef UNDER_CE
- switch (uMsg)
- {
- case BFFM_INITIALIZED:
- {
- SendMessage(hwnd, BFFM_SETSELECTION, TRUE, data);
- break;
- }
- /*
- case BFFM_SELCHANGED:
- {
- TCHAR dir[MAX_PATH];
- if (::SHGetPathFromIDList((LPITEMIDLIST) lp , dir))
- SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)dir);
- else
- SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)TEXT(""));
- break;
- }
- */
- default:
- break;
- }
- #endif
- return 0;
-}
-
-
-bool BrowseForFolder(HWND owner, LPCTSTR title, UINT ulFlags,
- LPCTSTR initialFolder, CSysString &resultPath)
-{
- CSysString displayName;
- BROWSEINFO browseInfo;
- browseInfo.hwndOwner = owner;
- browseInfo.pidlRoot = NULL;
-
- // there are Unicode/Astring problems in some WinCE SDK ?
- /*
- #ifdef UNDER_CE
- browseInfo.pszDisplayName = (LPSTR)displayName.GetBuf(MAX_PATH);
- browseInfo.lpszTitle = (LPCSTR)title;
- #else
- */
- browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
- browseInfo.lpszTitle = title;
- // #endif
- browseInfo.ulFlags = ulFlags;
- browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc : NULL;
- browseInfo.lParam = (LPARAM)initialFolder;
- return BrowseForFolder(&browseInfo, resultPath);
-}
-
-bool BrowseForFolder(HWND owner, LPCTSTR title,
- LPCTSTR initialFolder, CSysString &resultPath)
-{
- return BrowseForFolder(owner, title,
- #ifndef UNDER_CE
- BIF_NEWDIALOGSTYLE |
- #endif
- BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT, initialFolder, resultPath);
- // BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
-}
-
-#ifndef _UNICODE
-
-typedef BOOL (WINAPI * SHGetPathFromIDListWP)(LPCITEMIDLIST pidl, LPWSTR pszPath);
-
-bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path)
-{
- path.Empty();
- SHGetPathFromIDListWP shGetPathFromIDListW = (SHGetPathFromIDListWP)
- ::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHGetPathFromIDListW");
- if (shGetPathFromIDListW == 0)
- return false;
- const unsigned len = MAX_PATH * 2;
- bool result = BOOLToBool(shGetPathFromIDListW(itemIDList, path.GetBuf(len)));
- path.ReleaseBuf_CalcLen(len);
- return result;
-}
-
-typedef LPITEMIDLIST (WINAPI * SHBrowseForFolderWP)(LPBROWSEINFOW lpbi);
-
-bool BrowseForFolder(LPBROWSEINFOW browseInfo, UString &resultPath)
-{
- NWindows::NCOM::CComInitializer comInitializer;
- SHBrowseForFolderWP shBrowseForFolderW = (SHBrowseForFolderWP)
- ::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHBrowseForFolderW");
- if (shBrowseForFolderW == 0)
- return false;
- LPITEMIDLIST itemIDList = shBrowseForFolderW(browseInfo);
- if (itemIDList == NULL)
- return false;
- CItemIDList itemIDListHolder;
- itemIDListHolder.Attach(itemIDList);
- return GetPathFromIDList(itemIDList, resultPath);
-}
-
-
-int CALLBACK BrowseCallbackProc2(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
-{
- switch (uMsg)
- {
- case BFFM_INITIALIZED:
- {
- SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, data);
- break;
- }
- /*
- case BFFM_SELCHANGED:
- {
- wchar_t dir[MAX_PATH * 2];
-
- if (shGetPathFromIDListW((LPITEMIDLIST)lp , dir))
- SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)dir);
- else
- SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)L"");
- break;
- }
- */
- default:
- break;
- }
- return 0;
-}
-
-
-static bool BrowseForFolder(HWND owner, LPCWSTR title, UINT ulFlags,
- LPCWSTR initialFolder, UString &resultPath)
-{
- UString displayName;
- BROWSEINFOW browseInfo;
- browseInfo.hwndOwner = owner;
- browseInfo.pidlRoot = NULL;
- browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
- browseInfo.lpszTitle = title;
- browseInfo.ulFlags = ulFlags;
- browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc2 : NULL;
- browseInfo.lParam = (LPARAM)initialFolder;
- return BrowseForFolder(&browseInfo, resultPath);
-}
-
-bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath)
-{
- if (g_IsNT)
- return BrowseForFolder(owner, title,
- BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
- // | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
- , initialFolder, resultPath);
- // BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
- CSysString s;
- bool res = BrowseForFolder(owner, GetSystemString(title),
- BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
- // | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
- , GetSystemString(initialFolder), s);
- resultPath = GetUnicodeString(s);
- return res;
-}
-
-#endif
-
-#endif
-
-}}
+// Windows/Shell.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/MyCom.h"
+#include "../Common/StringConvert.h"
+
+#include "COM.h"
+#include "FileName.h"
+#include "MemoryGlobal.h"
+#include "Shell.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+// MSVC6 and old SDK don't support this function:
+// #define LWSTDAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
+// LWSTDAPI StrRetToStrW(STRRET *pstr, LPCITEMIDLIST pidl, LPWSTR *ppsz);
+
+// #define SHOW_DEBUG_SHELL
+
+#ifdef SHOW_DEBUG_SHELL
+
+#include "../Common/IntToString.h"
+
+static void Print_Number(UInt32 number, const char *s)
+{
+ AString s2;
+ s2.Add_UInt32(number);
+ s2.Add_Space();
+ s2 += s;
+ OutputDebugStringA(s2);
+}
+
+#define ODS(sz) { OutputDebugStringA(sz); }
+#define ODS_U(s) { OutputDebugStringW(s); }
+#define ODS_(op) { op; }
+
+#else
+
+#define ODS(sz)
+#define ODS_U(s)
+#define ODS_(op)
+
+#endif
+
+
+namespace NWindows {
+namespace NShell {
+
+#ifndef UNDER_CE
+
+// SHGetMalloc is unsupported in Windows Mobile?
+
+void CItemIDList::Free()
+{
+ if (!m_Object)
+ return;
+ /* DOCs:
+ SHGetMalloc was introduced in Windows 95 and Microsoft Windows NT 4.0,
+ but as of Windows 2000 it is no longer necessary.
+ In its place, programs can call the equivalent (and easier to use) CoTaskMemAlloc and CoTaskMemFree.
+ Description from oldnewthings:
+ shell functions could work without COM (if OLE32.DLL is not loaded),
+ but now if OLE32.DLL is loaded, then shell functions and com functions do same things.
+ 22.02: so we use OLE32.DLL function to free memory:
+ */
+ /*
+ CMyComPtr<IMalloc> shellMalloc;
+ if (::SHGetMalloc(&shellMalloc) != NOERROR)
+ throw 41099;
+ shellMalloc->Free(m_Object);
+ */
+ CoTaskMemFree(m_Object);
+ m_Object = NULL;
+}
+
+/*
+CItemIDList::(LPCITEMIDLIST itemIDList): m_Object(NULL)
+ { *this = itemIDList; }
+CItemIDList::(const CItemIDList& itemIDList): m_Object(NULL)
+ { *this = itemIDList; }
+
+CItemIDList& CItemIDList::operator=(LPCITEMIDLIST object)
+{
+ Free();
+ if (object != 0)
+ {
+ UINT32 size = GetSize(object);
+ m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
+ if (m_Object != NULL)
+ MoveMemory(m_Object, object, size);
+ }
+ return *this;
+}
+
+CItemIDList& CItemIDList::operator=(const CItemIDList &object)
+{
+ Free();
+ if (object.m_Object != NULL)
+ {
+ UINT32 size = GetSize(object.m_Object);
+ m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
+ if (m_Object != NULL)
+ MoveMemory(m_Object, object.m_Object, size);
+ }
+ return *this;
+}
+*/
+
+
+static HRESULT ReadUnicodeStrings(const wchar_t *p, size_t size, UStringVector &names)
+{
+ names.Clear();
+ const wchar_t *lim = p + size;
+ UString s;
+ /*
+ if (size == 0 || p[size - 1] != 0)
+ return E_INVALIDARG;
+ if (size == 1)
+ return S_OK;
+ if (p[size - 2] != 0)
+ return E_INVALIDARG;
+ */
+ for (;;)
+ {
+ const wchar_t *start = p;
+ for (;;)
+ {
+ if (p == lim) return E_INVALIDARG; // S_FALSE
+ if (*p++ == 0)
+ break;
+ }
+ const size_t num = (size_t)(p - start);
+ if (num == 1)
+ {
+ if (p != lim) return E_INVALIDARG; // S_FALSE
+ return S_OK;
+ }
+ s.SetFrom(start, (unsigned)(num - 1));
+ ODS_U(s)
+ names.Add(s);
+ // names.ReserveOnePosition();
+ // names.AddInReserved_Ptr_of_new(new UString((unsigned)num - 1, start));
+ }
+}
+
+
+static HRESULT ReadAnsiStrings(const char *p, size_t size, UStringVector &names)
+{
+ names.Clear();
+ AString name;
+ for (; size != 0; size--)
+ {
+ const char c = *p++;
+ if (c == 0)
+ {
+ if (name.IsEmpty())
+ return S_OK;
+ names.Add(GetUnicodeString(name));
+ name.Empty();
+ }
+ else
+ name += c;
+ }
+ return E_INVALIDARG;
+}
+
+
+#define INIT_FORMATETC_HGLOBAL(type) { (type), NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }
+
+static HRESULT DataObject_GetData_HGLOBAL(IDataObject *dataObject, CLIPFORMAT cf, NCOM::CStgMedium &medium)
+{
+ FORMATETC etc = INIT_FORMATETC_HGLOBAL(cf);
+ RINOK(dataObject->GetData(&etc, &medium))
+ if (medium.tymed != TYMED_HGLOBAL)
+ return E_INVALIDARG;
+ return S_OK;
+}
+
+static HRESULT DataObject_GetData_HDROP_Names(IDataObject *dataObject, UStringVector &names)
+{
+ names.Clear();
+ NCOM::CStgMedium medium;
+
+ /* Win10 : if (dataObject) is from IContextMenu::Initialize() and
+ if (len_of_path >= MAX_PATH (260) for some file in data object)
+ {
+ GetData() returns HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)
+ "The data area passed to a system call is too small",
+ Is there a way to fix this code for long paths?
+ } */
+
+ RINOK(DataObject_GetData_HGLOBAL(dataObject, CF_HDROP, medium))
+ const size_t blockSize = GlobalSize(medium.hGlobal);
+ if (blockSize < sizeof(DROPFILES))
+ return E_INVALIDARG;
+ NMemory::CGlobalLock dropLock(medium.hGlobal);
+ const DROPFILES *dropFiles = (const DROPFILES *)dropLock.GetPointer();
+ if (!dropFiles)
+ return E_INVALIDARG;
+ if (blockSize < dropFiles->pFiles
+ || dropFiles->pFiles < sizeof(DROPFILES)
+ // || dropFiles->pFiles != sizeof(DROPFILES)
+ )
+ return E_INVALIDARG;
+ const size_t size = blockSize - dropFiles->pFiles;
+ const void *namesData = (const Byte *)(const void *)dropFiles + dropFiles->pFiles;
+ HRESULT hres;
+ if (dropFiles->fWide)
+ {
+ if (size % sizeof(wchar_t) != 0)
+ return E_INVALIDARG;
+ hres = ReadUnicodeStrings((const wchar_t *)namesData, size / sizeof(wchar_t), names);
+ }
+ else
+ hres = ReadAnsiStrings((const char *)namesData, size, names);
+
+ ODS_(Print_Number(names.Size(), "DataObject_GetData_HDROP_Names"))
+ return hres;
+}
+
+
+
+// CF_IDLIST:
+#define MYWIN_CFSTR_SHELLIDLIST TEXT("Shell IDList Array")
+
+typedef struct
+{
+ UINT cidl;
+ UINT aoffset[1];
+} MYWIN_CIDA;
+/*
+ cidl : number of PIDLs that are being transferred, not including the parent folder.
+ aoffset : An array of offsets, relative to the beginning of this structure.
+ aoffset[0] - fully qualified PIDL of a parent folder.
+ If this PIDL is empty, the parent folder is the desktop.
+ aoffset[1] ... aoffset[cidl] : offset to one of the PIDLs to be transferred.
+ All of these PIDLs are relative to the PIDL of the parent folder.
+*/
+
+static HRESULT DataObject_GetData_IDLIST(IDataObject *dataObject, UStringVector &names)
+{
+ names.Clear();
+ NCOM::CStgMedium medium;
+ RINOK(DataObject_GetData_HGLOBAL(dataObject, (CLIPFORMAT)
+ RegisterClipboardFormat(MYWIN_CFSTR_SHELLIDLIST), medium))
+ const size_t blockSize = GlobalSize(medium.hGlobal);
+ if (blockSize < sizeof(MYWIN_CIDA) || blockSize >= (UInt32)((UInt32)0 - 1))
+ return E_INVALIDARG;
+ NMemory::CGlobalLock dropLock(medium.hGlobal);
+ const MYWIN_CIDA *cida = (const MYWIN_CIDA *)dropLock.GetPointer();
+ if (!cida)
+ return E_INVALIDARG;
+ if (cida->cidl == 0)
+ {
+ // is it posssible to have no selected items?
+ // it's unexpected case.
+ return E_INVALIDARG;
+ }
+ if (cida->cidl >= (blockSize - (UInt32)sizeof(MYWIN_CIDA)) / sizeof(UINT))
+ return E_INVALIDARG;
+ const UInt32 start = cida->cidl * (UInt32)sizeof(UINT) + (UInt32)sizeof(MYWIN_CIDA);
+
+ STRRET strret;
+ CMyComPtr<IShellFolder> parentFolder;
+ {
+ const UINT offset = cida->aoffset[0];
+ if (offset < start || offset >= blockSize
+ // || offset != start
+ )
+ return E_INVALIDARG;
+
+ CMyComPtr<IShellFolder> desktopFolder;
+ RINOK(::SHGetDesktopFolder(&desktopFolder))
+ if (!desktopFolder)
+ return E_FAIL;
+
+ LPCITEMIDLIST const lpcItem = (LPCITEMIDLIST)(const void *)((const Byte *)cida + offset);
+
+ #ifdef SHOW_DEBUG_SHELL
+ {
+ const HRESULT res = desktopFolder->GetDisplayNameOf(
+ lpcItem, SHGDN_FORPARSING, &strret);
+ if (res == S_OK && strret.uType == STRRET_WSTR)
+ {
+ ODS_U(strret.pOleStr)
+ /* if lpcItem is empty, the path will be
+ "C:\Users\user_name\Desktop"
+ if lpcItem is "My Computer" folder, the path will be
+ "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" */
+ CoTaskMemFree(strret.pOleStr);
+ }
+ }
+ #endif
+
+ RINOK(desktopFolder->BindToObject(lpcItem,
+ NULL, IID_IShellFolder, (void **)&parentFolder))
+ if (!parentFolder)
+ return E_FAIL;
+ }
+
+ names.ClearAndReserve(cida->cidl);
+ UString path;
+
+ // for (int y = 0; y < 1; y++) // for debug
+ for (unsigned i = 1; i <= cida->cidl; i++)
+ {
+ const UINT offset = cida->aoffset[i];
+ if (offset < start || offset >= blockSize)
+ return E_INVALIDARG;
+ const void *p = (const Byte *)(const void *)cida + offset;
+ /* ITEMIDLIST of file can contain more than one SHITEMID item.
+ In win10 only SHGDN_FORPARSING returns path that contains
+ all path parts related to parts of ITEMIDLIST.
+ So we can use only SHGDN_FORPARSING here.
+ Don't use (SHGDN_INFOLDER)
+ Don't use (SHGDN_INFOLDER | SHGDN_FORPARSING)
+ */
+ RINOK(parentFolder->GetDisplayNameOf((LPCITEMIDLIST)p, SHGDN_FORPARSING, &strret))
+
+ /*
+ // MSVC6 and old SDK do not support StrRetToStrW().
+ LPWSTR lpstr;
+ RINOK (StrRetToStrW(&strret, NULL, &lpstr))
+ ODS_U(lpstr)
+ path = lpstr;
+ CoTaskMemFree(lpstr);
+ */
+ if (strret.uType != STRRET_WSTR)
+ return E_INVALIDARG;
+ ODS_U(strret.pOleStr)
+ path = strret.pOleStr;
+ // the path could have super path prefix "\\\\?\\"
+ // we can remove super path prefix here, if we don't need that prefix
+ #ifdef Z7_LONG_PATH
+ // we remove super prefix, if we can work without that prefix
+ NFile::NName::If_IsSuperPath_RemoveSuperPrefix(path);
+ #endif
+ names.AddInReserved(path);
+ CoTaskMemFree(strret.pOleStr);
+ }
+
+ ODS_(Print_Number(cida->cidl, "CFSTR_SHELLIDLIST END"))
+ return S_OK;
+}
+
+
+HRESULT DataObject_GetData_HDROP_or_IDLIST_Names(IDataObject *dataObject, UStringVector &paths)
+{
+ ODS("-- DataObject_GetData_HDROP_or_IDLIST_Names START")
+ HRESULT hres = NShell::DataObject_GetData_HDROP_Names(dataObject, paths);
+ // if (hres == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
+ if (hres != S_OK)
+ {
+ ODS("-- DataObject_GetData_IDLIST START")
+ // for (int y = 0; y < 10000; y++) // for debug
+ hres = NShell::DataObject_GetData_IDLIST(dataObject, paths);
+ }
+ ODS("-- DataObject_GetData_HDROP_or_IDLIST_Names END")
+ return hres;
+}
+
+
+
+// #if (NTDDI_VERSION >= NTDDI_VISTA)
+typedef struct
+{
+ UINT cItems; // number of items in rgdwFileAttributes array
+ DWORD dwSumFileAttributes; // all of the attributes ORed together
+ DWORD dwProductFileAttributes; // all of the attributes ANDed together
+ DWORD rgdwFileAttributes[1]; // array
+} MYWIN_FILE_ATTRIBUTES_ARRAY;
+
+#define MYWIN_CFSTR_FILE_ATTRIBUTES_ARRAY TEXT("File Attributes Array")
+
+HRESULT DataObject_GetData_FILE_ATTRS(IDataObject *dataObject, CFileAttribs &attribs)
+{
+ attribs.Clear();
+ NCOM::CStgMedium medium;
+ RINOK(DataObject_GetData_HGLOBAL(dataObject, (CLIPFORMAT)
+ RegisterClipboardFormat(MYWIN_CFSTR_FILE_ATTRIBUTES_ARRAY), medium))
+ const size_t blockSize = GlobalSize(medium.hGlobal);
+ if (blockSize < sizeof(MYWIN_FILE_ATTRIBUTES_ARRAY))
+ return E_INVALIDARG;
+ NMemory::CGlobalLock dropLock(medium.hGlobal);
+ const MYWIN_FILE_ATTRIBUTES_ARRAY *faa = (const MYWIN_FILE_ATTRIBUTES_ARRAY *)dropLock.GetPointer();
+ if (!faa)
+ return E_INVALIDARG;
+ const unsigned numFiles = faa->cItems;
+ if (numFiles == 0)
+ {
+ // is it posssible to have empty array here?
+ return E_INVALIDARG;
+ }
+ if ((blockSize - (sizeof(MYWIN_FILE_ATTRIBUTES_ARRAY) - sizeof(DWORD)))
+ / sizeof(DWORD) != numFiles)
+ return E_INVALIDARG;
+ // attribs.Sum = faa->dwSumFileAttributes;
+ // attribs.Product = faa->dwProductFileAttributes;
+ // attribs.Vals.SetFromArray(faa->rgdwFileAttributes, numFiles);
+ // attribs.IsDirVector.ClearAndSetSize(numFiles);
+
+ if ((faa->dwSumFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
+ {
+ /* in win10: if selected items are volumes (c:\, d:\ ..) in My Compter,
+ all items have FILE_ATTRIBUTE_DIRECTORY attribute
+ ntfs volume also have FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM
+ udf volume: FILE_ATTRIBUTE_READONLY
+ dvd-rom device: (-1) : all bits are set
+ */
+ const DWORD *attr = faa->rgdwFileAttributes;
+ // DWORD product = (UInt32)0 - 1, sum = 0;
+ for (unsigned i = 0; i < numFiles; i++)
+ {
+ if (attr[i] & FILE_ATTRIBUTE_DIRECTORY)
+ {
+ // attribs.ThereAreDirs = true;
+ attribs.FirstDirIndex = (int)i;
+ break;
+ }
+ // attribs.IsDirVector[i] = (attr[i] & FILE_ATTRIBUTE_DIRECTORY) != 0;
+ // product &= v;
+ // sum |= v;
+ }
+ // ODS_(Print_Number(product, "Product calc FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+ // ODS_(Print_Number(sum, "Sum calc FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+ }
+ // ODS_(Print_Number(attribs.Product, "Product FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+ // ODS_(Print_Number(attribs.Sum, "Sum FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+ ODS_(Print_Number(numFiles, "FILE_ATTRIBUTES_ARRAY ==== DataObject_GetData_HDROP_Names"))
+ return S_OK;
+}
+
+
+/////////////////////////////
+// CDrop
+
+/*
+ win10:
+ DragQueryFile() implementation code is not effective because
+ there is no pointer inside DROP internal file list, so
+ DragQueryFile(fileIndex) runs all names in range [0, fileIndex].
+ DragQueryFile(,, buf, bufSize)
+ if (buf == NULL) by spec
+ {
+ returns value is the required size
+ in characters, of the buffer, not including the terminating null character
+ tests show that if (bufSize == 0), then it also returns required size.
+ }
+ if (bufSize != NULL)
+ {
+ returns: the count of the characters copied, not including null character.
+ win10: null character is also copied at position buf[ret_count];
+ }
+*/
+
+/*
+void CDrop::Attach(HDROP object)
+{
+ Free();
+ m_Object = object;
+ m_Assigned = true;
+}
+
+void CDrop::Free()
+{
+ if (m_MustBeFinished && m_Assigned)
+ Finish();
+ m_Assigned = false;
+}
+
+UINT CDrop::QueryCountOfFiles()
+{
+ return QueryFile(0xFFFFFFFF, (LPTSTR)NULL, 0);
+}
+
+void CDrop::QueryFileName(UINT fileIndex, UString &fileName)
+{
+ #ifndef _UNICODE
+ if (!g_IsNT)
+ {
+ AString fileNameA;
+ const UINT len = QueryFile(fileIndex, (LPTSTR)NULL, 0);
+ const UINT numCopied = QueryFile(fileIndex, fileNameA.GetBuf(len + 2), len + 2);
+ fileNameA.ReleaseBuf_CalcLen(len);
+ if (numCopied != len)
+ throw 20221223;
+ fileName = GetUnicodeString(fileNameA);
+ }
+ else
+ #endif
+ {
+ // kReserve must be >= 3 for additional buffer size
+ // safety and for optimal performance
+ const unsigned kReserve = 3;
+ {
+ unsigned len = 0;
+ wchar_t *buf = fileName.GetBuf_GetMaxAvail(len);
+ if (len >= kReserve)
+ {
+ const UINT numCopied = QueryFile(fileIndex, buf, len);
+ if (numCopied < len - 1)
+ {
+ // (numCopied < len - 1) case means that it have copied full string.
+ fileName.ReleaseBuf_CalcLen(numCopied);
+ return;
+ }
+ }
+ }
+ const UINT len = QueryFile(fileIndex, (LPWSTR)NULL, 0);
+ const UINT numCopied = QueryFile(fileIndex,
+ fileName.GetBuf(len + kReserve), len + kReserve);
+ fileName.ReleaseBuf_CalcLen(len);
+ if (numCopied != len)
+ throw 20221223;
+ }
+}
+
+
+void CDrop::QueryFileNames(UStringVector &fileNames)
+{
+ UINT numFiles = QueryCountOfFiles();
+
+ Print_Number(numFiles, "\n====== CDrop::QueryFileNames START ===== \n");
+
+ fileNames.ClearAndReserve(numFiles);
+ UString s;
+ for (UINT i = 0; i < numFiles; i++)
+ {
+ QueryFileName(i, s);
+ if (!s.IsEmpty())
+ fileNames.AddInReserved(s);
+ }
+ Print_Number(numFiles, "\n====== CDrop::QueryFileNames END ===== \n");
+}
+*/
+
+
+// #if (NTDDI_VERSION >= NTDDI_VISTA)
+// SHGetPathFromIDListEx returns a win32 file system path for the item in the name space.
+typedef int Z7_WIN_GPFIDL_FLAGS;
+
+extern "C" {
+typedef BOOL (WINAPI * Func_SHGetPathFromIDListW)(LPCITEMIDLIST pidl, LPWSTR pszPath);
+typedef BOOL (WINAPI * Func_SHGetPathFromIDListEx)(LPCITEMIDLIST pidl, PWSTR pszPath, DWORD cchPath, Z7_WIN_GPFIDL_FLAGS uOpts);
+}
+
+#ifndef _UNICODE
+
+bool GetPathFromIDList(LPCITEMIDLIST itemIDList, AString &path)
+{
+ path.Empty();
+ const unsigned len = MAX_PATH + 16;
+ const bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
+ path.ReleaseBuf_CalcLen(len);
+ return result;
+}
+
+#endif
+
+bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path)
+{
+ path.Empty();
+ unsigned len = MAX_PATH + 16;
+
+#ifdef _UNICODE
+ bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
+#else
+ const
+ Func_SHGetPathFromIDListW
+ shGetPathFromIDListW = Z7_GET_PROC_ADDRESS(
+ Func_SHGetPathFromIDListW, ::GetModuleHandleW(L"shell32.dll"),
+ "SHGetPathFromIDListW");
+ if (!shGetPathFromIDListW)
+ return false;
+ bool result = BOOLToBool(shGetPathFromIDListW(itemIDList, path.GetBuf(len)));
+#endif
+
+ if (!result)
+ {
+ ODS("==== GetPathFromIDList() SHGetPathFromIDList() returned false")
+ /* for long path we need SHGetPathFromIDListEx().
+ win10: SHGetPathFromIDListEx() for long path returns path with
+ with super path prefix "\\\\?\\". */
+ const
+ Func_SHGetPathFromIDListEx
+ func_SHGetPathFromIDListEx = Z7_GET_PROC_ADDRESS(
+ Func_SHGetPathFromIDListEx, ::GetModuleHandleW(L"shell32.dll"),
+ "SHGetPathFromIDListEx");
+ if (func_SHGetPathFromIDListEx)
+ {
+ ODS("==== GetPathFromIDList() (SHGetPathFromIDListEx)")
+ do
+ {
+ len *= 4;
+ result = BOOLToBool(func_SHGetPathFromIDListEx(itemIDList, path.GetBuf(len), len, 0));
+ if (result)
+ break;
+ }
+ while (len <= (1 << 16));
+ }
+ }
+
+ path.ReleaseBuf_CalcLen(len);
+ return result;
+}
+
+#endif
+
+#ifdef UNDER_CE
+
+bool BrowseForFolder(LPBROWSEINFO, CSysString)
+{
+ return false;
+}
+
+bool BrowseForFolder(HWND, LPCTSTR, UINT, LPCTSTR, CSysString &)
+{
+ return false;
+}
+
+bool BrowseForFolder(HWND /* owner */, LPCTSTR /* title */,
+ LPCTSTR /* initialFolder */, CSysString & /* resultPath */)
+{
+ /*
+ // SHBrowseForFolder doesn't work before CE 6.0 ?
+ if (GetProcAddress(LoadLibrary(L"ceshell.dll", L"SHBrowseForFolder") == 0)
+ MessageBoxW(0, L"no", L"", 0);
+ else
+ MessageBoxW(0, L"yes", L"", 0);
+ */
+ /*
+ UString s = "all files";
+ s += " (*.*)";
+ return MyGetOpenFileName(owner, title, initialFolder, s, resultPath, true);
+ */
+ return false;
+}
+
+#else
+
+/* win10: SHBrowseForFolder() doesn't support long paths,
+ even if long path suppport is enabled in registry and in manifest.
+ and SHBrowseForFolder() doesn't support super path prefix "\\\\?\\". */
+
+bool BrowseForFolder(LPBROWSEINFO browseInfo, CSysString &resultPath)
+{
+ resultPath.Empty();
+ NWindows::NCOM::CComInitializer comInitializer;
+ LPITEMIDLIST itemIDList = ::SHBrowseForFolder(browseInfo);
+ if (!itemIDList)
+ return false;
+ CItemIDList itemIDListHolder;
+ itemIDListHolder.Attach(itemIDList);
+ return GetPathFromIDList(itemIDList, resultPath);
+}
+
+
+static int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
+{
+ #ifndef UNDER_CE
+ switch (uMsg)
+ {
+ case BFFM_INITIALIZED:
+ {
+ SendMessage(hwnd, BFFM_SETSELECTION, TRUE, data);
+ break;
+ }
+ /*
+ case BFFM_SELCHANGED:
+ {
+ TCHAR dir[MAX_PATH];
+ if (::SHGetPathFromIDList((LPITEMIDLIST) lp , dir))
+ SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)dir);
+ else
+ SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)TEXT(""));
+ break;
+ }
+ */
+ default:
+ break;
+ }
+ #endif
+ return 0;
+}
+
+
+static bool BrowseForFolder(HWND owner, LPCTSTR title, UINT ulFlags,
+ LPCTSTR initialFolder, CSysString &resultPath)
+{
+ CSysString displayName;
+ BROWSEINFO browseInfo;
+ browseInfo.hwndOwner = owner;
+ browseInfo.pidlRoot = NULL;
+
+ // there are Unicode/Astring problems in some WinCE SDK ?
+ /*
+ #ifdef UNDER_CE
+ browseInfo.pszDisplayName = (LPSTR)displayName.GetBuf(MAX_PATH);
+ browseInfo.lpszTitle = (LPCSTR)title;
+ #else
+ */
+ browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
+ browseInfo.lpszTitle = title;
+ // #endif
+ browseInfo.ulFlags = ulFlags;
+ browseInfo.lpfn = initialFolder ? BrowseCallbackProc : NULL;
+ browseInfo.lParam = (LPARAM)initialFolder;
+ return BrowseForFolder(&browseInfo, resultPath);
+}
+
+#ifdef Z7_OLD_WIN_SDK
+// ShlObj.h:
+#ifndef BIF_NEWDIALOGSTYLE
+#define BIF_NEWDIALOGSTYLE 0x0040
+#endif
+#endif
+
+bool BrowseForFolder(HWND owner, LPCTSTR title,
+ LPCTSTR initialFolder, CSysString &resultPath)
+{
+ return BrowseForFolder(owner, title,
+ #ifndef UNDER_CE
+ BIF_NEWDIALOGSTYLE |
+ #endif
+ BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT, initialFolder, resultPath);
+ // BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
+}
+
+#ifndef _UNICODE
+
+extern "C" {
+typedef LPITEMIDLIST (WINAPI * Func_SHBrowseForFolderW)(LPBROWSEINFOW lpbi);
+}
+
+static bool BrowseForFolder(LPBROWSEINFOW browseInfo, UString &resultPath)
+{
+ NWindows::NCOM::CComInitializer comInitializer;
+ const
+ Func_SHBrowseForFolderW
+ f_SHBrowseForFolderW = Z7_GET_PROC_ADDRESS(
+ Func_SHBrowseForFolderW, ::GetModuleHandleW(L"shell32.dll"),
+ "SHBrowseForFolderW");
+ if (!f_SHBrowseForFolderW)
+ return false;
+ LPITEMIDLIST itemIDList = f_SHBrowseForFolderW(browseInfo);
+ if (!itemIDList)
+ return false;
+ CItemIDList itemIDListHolder;
+ itemIDListHolder.Attach(itemIDList);
+ return GetPathFromIDList(itemIDList, resultPath);
+}
+
+static
+int CALLBACK BrowseCallbackProc2(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
+{
+ switch (uMsg)
+ {
+ case BFFM_INITIALIZED:
+ {
+ SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, data);
+ break;
+ }
+ /*
+ case BFFM_SELCHANGED:
+ {
+ wchar_t dir[MAX_PATH * 2];
+
+ if (shGetPathFromIDListW((LPITEMIDLIST)lp , dir))
+ SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)dir);
+ else
+ SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)L"");
+ break;
+ }
+ */
+ default:
+ break;
+ }
+ return 0;
+}
+
+
+static bool BrowseForFolder(HWND owner, LPCWSTR title, UINT ulFlags,
+ LPCWSTR initialFolder, UString &resultPath)
+{
+ UString displayName;
+ BROWSEINFOW browseInfo;
+ browseInfo.hwndOwner = owner;
+ browseInfo.pidlRoot = NULL;
+ browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
+ browseInfo.lpszTitle = title;
+ browseInfo.ulFlags = ulFlags;
+ browseInfo.lpfn = initialFolder ? BrowseCallbackProc2 : NULL;
+ browseInfo.lParam = (LPARAM)initialFolder;
+ return BrowseForFolder(&browseInfo, resultPath);
+}
+
+bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath)
+{
+ if (g_IsNT)
+ return BrowseForFolder(owner, title,
+ BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
+ // | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
+ , initialFolder, resultPath);
+ // BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
+ CSysString s;
+ bool res = BrowseForFolder(owner, GetSystemString(title),
+ BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
+ // | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
+ , GetSystemString(initialFolder), s);
+ resultPath = GetUnicodeString(s);
+ return res;
+}
+
+#endif
+
+#endif
+
+}}
diff --git a/CPP/Windows/Shell.h b/CPP/Windows/Shell.h
index 9068040..b4cdb30 100644
--- a/CPP/Windows/Shell.h
+++ b/CPP/Windows/Shell.h
@@ -1,94 +1,130 @@
-// Windows/Shell.h
-
-#ifndef __WINDOWS_SHELL_H
-#define __WINDOWS_SHELL_H
-
-#include <windows.h>
-#include <shlobj.h>
-
-#include "../Common/MyString.h"
-
-#include "Defs.h"
-
-namespace NWindows{
-namespace NShell{
-
-/////////////////////////
-// CItemIDList
-#ifndef UNDER_CE
-
-class CItemIDList
-{
- LPITEMIDLIST m_Object;
-public:
- CItemIDList(): m_Object(NULL) {}
- // CItemIDList(LPCITEMIDLIST itemIDList);
- // CItemIDList(const CItemIDList& itemIDList);
- ~CItemIDList() { Free(); }
- void Free();
- void Attach(LPITEMIDLIST object)
- {
- Free();
- m_Object = object;
- }
- LPITEMIDLIST Detach()
- {
- LPITEMIDLIST object = m_Object;
- m_Object = NULL;
- return object;
- }
- operator LPITEMIDLIST() { return m_Object;}
- operator LPCITEMIDLIST() const { return m_Object;}
- LPITEMIDLIST* operator&() { return &m_Object; }
- LPITEMIDLIST operator->() { return m_Object; }
-
- // CItemIDList& operator=(LPCITEMIDLIST object);
- // CItemIDList& operator=(const CItemIDList &object);
-};
-
-/////////////////////////////
-// CDrop
-
-class CDrop
-{
- HDROP m_Object;
- bool m_MustBeFinished;
- bool m_Assigned;
- void Free();
-public:
- CDrop(bool mustBeFinished) : m_MustBeFinished(mustBeFinished), m_Assigned(false) {}
- ~CDrop() { Free(); }
-
- void Attach(HDROP object);
- operator HDROP() { return m_Object;}
- bool QueryPoint(LPPOINT point)
- { return BOOLToBool(::DragQueryPoint(m_Object, point)); }
- void Finish() { ::DragFinish(m_Object); }
- UINT QueryFile(UINT fileIndex, LPTSTR fileName, UINT fileNameSize)
- { return ::DragQueryFile(m_Object, fileIndex, fileName, fileNameSize); }
- #ifndef _UNICODE
- UINT QueryFile(UINT fileIndex, LPWSTR fileName, UINT fileNameSize)
- { return ::DragQueryFileW(m_Object, fileIndex, fileName, fileNameSize); }
- #endif
- UINT QueryCountOfFiles();
- UString QueryFileName(UINT fileIndex);
- void QueryFileNames(UStringVector &fileNames);
-};
-
-#endif
-
-/////////////////////////////
-// Functions
-
-bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path);
-bool BrowseForFolder(LPBROWSEINFO lpbi, CSysString &resultPath);
-bool BrowseForFolder(HWND owner, LPCTSTR title, LPCTSTR initialFolder, CSysString &resultPath);
-
-#ifndef _UNICODE
-bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path);
-bool BrowseForFolder(LPBROWSEINFO lpbi, UString &resultPath);
-bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath);
-#endif
-}}
-
-#endif
+// Windows/Shell.h
+
+#ifndef ZIP7_WINDOWS_SHELL_H
+#define ZIP7_WINDOWS_SHELL_H
+
+#include "../Common/Common.h"
+#include "../Common/MyWindows.h"
+#if defined(__MINGW32__) || defined(__MINGW64__)
+#include <shlobj.h>
+#else
+#include <ShlObj.h>
+#endif
+
+#include "../Common/MyString.h"
+
+#include "Defs.h"
+
+namespace NWindows {
+namespace NShell {
+
+/////////////////////////
+// CItemIDList
+#ifndef UNDER_CE
+
+class CItemIDList
+{
+ LPITEMIDLIST m_Object;
+ Z7_CLASS_NO_COPY(CItemIDList)
+public:
+ CItemIDList(): m_Object(NULL) {}
+ // CItemIDList(LPCITEMIDLIST itemIDList);
+ // CItemIDList(const CItemIDList& itemIDList);
+ ~CItemIDList() { Free(); }
+ void Free();
+ void Attach(LPITEMIDLIST object)
+ {
+ Free();
+ m_Object = object;
+ }
+ LPITEMIDLIST Detach()
+ {
+ LPITEMIDLIST object = m_Object;
+ m_Object = NULL;
+ return object;
+ }
+ operator LPITEMIDLIST() { return m_Object;}
+ operator LPCITEMIDLIST() const { return m_Object;}
+ LPITEMIDLIST* operator&() { return &m_Object; }
+ LPITEMIDLIST operator->() { return m_Object; }
+
+ // CItemIDList& operator=(LPCITEMIDLIST object);
+ // CItemIDList& operator=(const CItemIDList &object);
+};
+
+/////////////////////////////
+// CDrop
+
+/*
+class CDrop
+{
+ HDROP m_Object;
+ bool m_MustBeFinished;
+ bool m_Assigned;
+ void Free();
+public:
+ CDrop(bool mustBeFinished) : m_MustBeFinished(mustBeFinished), m_Assigned(false) {}
+ ~CDrop() { Free(); }
+
+ void Attach(HDROP object);
+ operator HDROP() { return m_Object;}
+ bool QueryPoint(LPPOINT point)
+ { return BOOLToBool(::DragQueryPoint(m_Object, point)); }
+ void Finish()
+ {
+ ::DragFinish(m_Object);
+ }
+ UINT QueryFile(UINT fileIndex, LPTSTR fileName, UINT bufSize)
+ { return ::DragQueryFile(m_Object, fileIndex, fileName, bufSize); }
+ #ifndef _UNICODE
+ UINT QueryFile(UINT fileIndex, LPWSTR fileName, UINT bufSize)
+ { return ::DragQueryFileW(m_Object, fileIndex, fileName, bufSize); }
+ #endif
+ UINT QueryCountOfFiles();
+ void QueryFileName(UINT fileIndex, UString &fileName);
+ void QueryFileNames(UStringVector &fileNames);
+};
+*/
+#endif
+
+struct CFileAttribs
+{
+ int FirstDirIndex;
+ // DWORD Sum;
+ // DWORD Product;
+ // CRecordVector<DWORD> Vals;
+ // CRecordVector<bool> IsDirVector;
+
+ CFileAttribs()
+ {
+ Clear();
+ }
+
+ void Clear()
+ {
+ FirstDirIndex = -1;
+ // Sum = 0;
+ // Product = 0;
+ // IsDirVector.Clear();
+ }
+};
+
+
+/* read pathnames from HDROP or SHELLIDLIST.
+ The parser can return E_INVALIDARG, if there is some unexpected data in dataObject */
+HRESULT DataObject_GetData_HDROP_or_IDLIST_Names(IDataObject *dataObject, UStringVector &names);
+
+HRESULT DataObject_GetData_FILE_ATTRS(IDataObject *dataObject, CFileAttribs &attribs);
+
+bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path);
+bool BrowseForFolder(LPBROWSEINFO lpbi, CSysString &resultPath);
+bool BrowseForFolder(HWND owner, LPCTSTR title, LPCTSTR initialFolder, CSysString &resultPath);
+
+#ifndef _UNICODE
+bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path);
+bool BrowseForFolder(LPBROWSEINFO lpbi, UString &resultPath);
+bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath);
+#endif
+}}
+
+#endif
diff --git a/CPP/Windows/StdAfx.h b/CPP/Windows/StdAfx.h
index 47a4895..bd5084f 100644
--- a/CPP/Windows/StdAfx.h
+++ b/CPP/Windows/StdAfx.h
@@ -1,8 +1,12 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../Common/Common.h"
-
-#endif
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#include "../Common/Common.h"
+
+#endif
diff --git a/CPP/Windows/Synchronization.cpp b/CPP/Windows/Synchronization.cpp
index 01f1ad9..d5542af 100644
--- a/CPP/Windows/Synchronization.cpp
+++ b/CPP/Windows/Synchronization.cpp
@@ -1,10 +1,87 @@
-// Windows/Synchronization.cpp
-
-#include "StdAfx.h"
-
-#include "Synchronization.h"
-
-namespace NWindows {
-namespace NSynchronization {
-
-}}
+// Windows/Synchronization.cpp
+
+#include "StdAfx.h"
+
+#ifndef _WIN32
+
+#include "Synchronization.h"
+
+namespace NWindows {
+namespace NSynchronization {
+
+/*
+#define INFINITE 0xFFFFFFFF
+#define MAXIMUM_WAIT_OBJECTS 64
+#define STATUS_ABANDONED_WAIT_0 ((NTSTATUS)0x00000080L)
+#define WAIT_ABANDONED ((STATUS_ABANDONED_WAIT_0 ) + 0 )
+#define WAIT_ABANDONED_0 ((STATUS_ABANDONED_WAIT_0 ) + 0 )
+// WINAPI
+DWORD WaitForMultipleObjects(DWORD count, const HANDLE *handles, BOOL wait_all, DWORD timeout);
+*/
+
+/* clang: we need to place some virtual functions in cpp file to rid off the warning:
+ 'CBaseHandle_WFMO' has no out-of-line virtual method definitions;
+ its vtable will be emitted in every translation unit */
+CBaseHandle_WFMO::~CBaseHandle_WFMO()
+{
+}
+
+bool CBaseEvent_WFMO::IsSignaledAndUpdate()
+{
+ if (this->_state == false)
+ return false;
+ if (this->_manual_reset == false)
+ this->_state = false;
+ return true;
+}
+
+bool CSemaphore_WFMO::IsSignaledAndUpdate()
+{
+ if (this->_count == 0)
+ return false;
+ this->_count--;
+ return true;
+}
+
+DWORD WINAPI WaitForMultiObj_Any_Infinite(DWORD count, const CHandle_WFMO *handles)
+{
+ if (count < 1)
+ {
+ // abort();
+ SetLastError(EINVAL);
+ return WAIT_FAILED;
+ }
+
+ CSynchro *synchro = handles[0]->_sync;
+ synchro->Enter();
+
+ // #ifdef DEBUG_SYNCHRO
+ for (DWORD i = 1; i < count; i++)
+ {
+ if (synchro != handles[i]->_sync)
+ {
+ // abort();
+ synchro->Leave();
+ SetLastError(EINVAL);
+ return WAIT_FAILED;
+ }
+ }
+ // #endif
+
+ for (;;)
+ {
+ for (DWORD i = 0; i < count; i++)
+ {
+ if (handles[i]->IsSignaledAndUpdate())
+ {
+ synchro->Leave();
+ return WAIT_OBJECT_0 + i;
+ }
+ }
+ synchro->WaitCond();
+ }
+}
+
+}}
+
+#endif
diff --git a/CPP/Windows/Synchronization.h b/CPP/Windows/Synchronization.h
index 786da00..afd03d2 100644
--- a/CPP/Windows/Synchronization.h
+++ b/CPP/Windows/Synchronization.h
@@ -1,164 +1,381 @@
-// Windows/Synchronization.h
-
-#ifndef __WINDOWS_SYNCHRONIZATION_H
-#define __WINDOWS_SYNCHRONIZATION_H
-
-#include "../../C/Threads.h"
-
-#include "Defs.h"
-
-#ifdef _WIN32
-#include "Handle.h"
-#endif
-
-namespace NWindows {
-namespace NSynchronization {
-
-class CBaseEvent
-{
-protected:
- ::CEvent _object;
-public:
- bool IsCreated() { return Event_IsCreated(&_object) != 0; }
- operator HANDLE() { return _object; }
- CBaseEvent() { Event_Construct(&_object); }
- ~CBaseEvent() { Close(); }
- WRes Close() { return Event_Close(&_object); }
- #ifdef _WIN32
- WRes Create(bool manualReset, bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
- {
- _object = ::CreateEvent(sa, BoolToBOOL(manualReset), BoolToBOOL(initiallyOwn), name);
- if (name == NULL && _object != 0)
- return 0;
- return ::GetLastError();
- }
- WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
- {
- _object = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
- if (_object != 0)
- return 0;
- return ::GetLastError();
- }
- #endif
-
- WRes Set() { return Event_Set(&_object); }
- // bool Pulse() { return BOOLToBool(::PulseEvent(_handle)); }
- WRes Reset() { return Event_Reset(&_object); }
- WRes Lock() { return Event_Wait(&_object); }
-};
-
-class CManualResetEvent: public CBaseEvent
-{
-public:
- WRes Create(bool initiallyOwn = false)
- {
- return ManualResetEvent_Create(&_object, initiallyOwn ? 1: 0);
- }
- WRes CreateIfNotCreated()
- {
- if (IsCreated())
- return 0;
- return ManualResetEvent_CreateNotSignaled(&_object);
- }
- #ifdef _WIN32
- WRes CreateWithName(bool initiallyOwn, LPCTSTR name)
- {
- return CBaseEvent::Create(true, initiallyOwn, name);
- }
- #endif
-};
-
-class CAutoResetEvent: public CBaseEvent
-{
-public:
- WRes Create()
- {
- return AutoResetEvent_CreateNotSignaled(&_object);
- }
- WRes CreateIfNotCreated()
- {
- if (IsCreated())
- return 0;
- return AutoResetEvent_CreateNotSignaled(&_object);
- }
-};
-
-#ifdef _WIN32
-class CObject: public CHandle
-{
-public:
- WRes Lock(DWORD timeoutInterval = INFINITE)
- { return (::WaitForSingleObject(_handle, timeoutInterval) == WAIT_OBJECT_0 ? 0 : ::GetLastError()); }
-};
-class CMutex: public CObject
-{
-public:
- WRes Create(bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
- {
- _handle = ::CreateMutex(sa, BoolToBOOL(initiallyOwn), name);
- if (name == NULL && _handle != 0)
- return 0;
- return ::GetLastError();
- }
- #ifndef UNDER_CE
- WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
- {
- _handle = ::OpenMutex(desiredAccess, BoolToBOOL(inheritHandle), name);
- if (_handle != 0)
- return 0;
- return ::GetLastError();
- }
- #endif
- WRes Release()
- {
- return ::ReleaseMutex(_handle) ? 0 : ::GetLastError();
- }
-};
-class CMutexLock
-{
- CMutex *_object;
-public:
- CMutexLock(CMutex &object): _object(&object) { _object->Lock(); }
- ~CMutexLock() { _object->Release(); }
-};
-#endif
-
-class CSemaphore
-{
- ::CSemaphore _object;
-public:
- CSemaphore() { Semaphore_Construct(&_object); }
- ~CSemaphore() { Close(); }
- WRes Close() { return Semaphore_Close(&_object); }
- operator HANDLE() { return _object; }
- WRes Create(UInt32 initiallyCount, UInt32 maxCount)
- {
- return Semaphore_Create(&_object, initiallyCount, maxCount);
- }
- WRes Release() { return Semaphore_Release1(&_object); }
- WRes Release(UInt32 releaseCount) { return Semaphore_ReleaseN(&_object, releaseCount); }
- WRes Lock() { return Semaphore_Wait(&_object); }
-};
-
-class CCriticalSection
-{
- ::CCriticalSection _object;
-public:
- CCriticalSection() { CriticalSection_Init(&_object); }
- ~CCriticalSection() { CriticalSection_Delete(&_object); }
- void Enter() { CriticalSection_Enter(&_object); }
- void Leave() { CriticalSection_Leave(&_object); }
-};
-
-class CCriticalSectionLock
-{
- CCriticalSection *_object;
- void Unlock() { _object->Leave(); }
-public:
- CCriticalSectionLock(CCriticalSection &object): _object(&object) {_object->Enter(); }
- ~CCriticalSectionLock() { Unlock(); }
-};
-
-}}
-
-#endif
+// Windows/Synchronization.h
+
+#ifndef ZIP7_INC_WINDOWS_SYNCHRONIZATION_H
+#define ZIP7_INC_WINDOWS_SYNCHRONIZATION_H
+
+#include "../../C/Threads.h"
+
+#include "../Common/MyTypes.h"
+
+#include "Defs.h"
+
+#ifdef _WIN32
+#include "Handle.h"
+#endif
+
+namespace NWindows {
+namespace NSynchronization {
+
+class CBaseEvent MY_UNCOPYABLE
+{
+protected:
+ ::CEvent _object;
+public:
+ bool IsCreated() { return Event_IsCreated(&_object) != 0; }
+
+ CBaseEvent() { Event_Construct(&_object); }
+ ~CBaseEvent() { Close(); }
+ WRes Close() { return Event_Close(&_object); }
+
+ #ifdef _WIN32
+ operator HANDLE() { return _object; }
+ WRes Create(bool manualReset, bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
+ {
+ _object = ::CreateEvent(sa, BoolToBOOL(manualReset), BoolToBOOL(initiallyOwn), name);
+ if (name == NULL && _object != NULL)
+ return 0;
+ return ::GetLastError();
+ }
+ WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
+ {
+ _object = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
+ if (_object != NULL)
+ return 0;
+ return ::GetLastError();
+ }
+ #endif
+
+ WRes Set() { return Event_Set(&_object); }
+ // bool Pulse() { return BOOLToBool(::PulseEvent(_handle)); }
+ WRes Reset() { return Event_Reset(&_object); }
+ WRes Lock() { return Event_Wait(&_object); }
+};
+
+class CManualResetEvent: public CBaseEvent
+{
+public:
+ WRes Create(bool initiallyOwn = false)
+ {
+ return ManualResetEvent_Create(&_object, initiallyOwn ? 1: 0);
+ }
+ WRes CreateIfNotCreated_Reset()
+ {
+ if (IsCreated())
+ return Reset();
+ return ManualResetEvent_CreateNotSignaled(&_object);
+ }
+ #ifdef _WIN32
+ WRes CreateWithName(bool initiallyOwn, LPCTSTR name)
+ {
+ return CBaseEvent::Create(true, initiallyOwn, name);
+ }
+ #endif
+};
+
+class CAutoResetEvent: public CBaseEvent
+{
+public:
+ WRes Create()
+ {
+ return AutoResetEvent_CreateNotSignaled(&_object);
+ }
+ WRes CreateIfNotCreated_Reset()
+ {
+ if (IsCreated())
+ return Reset();
+ return AutoResetEvent_CreateNotSignaled(&_object);
+ }
+};
+
+
+/*
+#ifdef _WIN32
+
+class CObject: public CHandle
+{
+public:
+ WRes Lock(DWORD timeoutInterval = INFINITE)
+ { return (::WaitForSingleObject(_handle, timeoutInterval) == WAIT_OBJECT_0 ? 0 : ::GetLastError()); }
+};
+
+class CMutex: public CObject
+{
+public:
+ WRes Create(bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
+ {
+ _handle = ::CreateMutex(sa, BoolToBOOL(initiallyOwn), name);
+ if (name == NULL && _handle != 0)
+ return 0;
+ return ::GetLastError();
+ }
+ #ifndef UNDER_CE
+ WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
+ {
+ _handle = ::OpenMutex(desiredAccess, BoolToBOOL(inheritHandle), name);
+ if (_handle != 0)
+ return 0;
+ return ::GetLastError();
+ }
+ #endif
+ WRes Release()
+ {
+ return ::ReleaseMutex(_handle) ? 0 : ::GetLastError();
+ }
+};
+
+class CMutexLock MY_UNCOPYABLE
+{
+ CMutex *_object;
+public:
+ CMutexLock(CMutex &object): _object(&object) { _object->Lock(); }
+ ~CMutexLock() { _object->Release(); }
+};
+
+#endif // _WIN32
+*/
+
+
+class CSemaphore MY_UNCOPYABLE
+{
+ ::CSemaphore _object;
+public:
+ CSemaphore() { Semaphore_Construct(&_object); }
+ ~CSemaphore() { Close(); }
+ WRes Close() { return Semaphore_Close(&_object); }
+
+ #ifdef _WIN32
+ operator HANDLE() { return _object; }
+ #endif
+
+ // bool IsCreated() const { return Semaphore_IsCreated(&_object) != 0; }
+
+ WRes Create(UInt32 initCount, UInt32 maxCount)
+ {
+ return Semaphore_Create(&_object, initCount, maxCount);
+ }
+ WRes OptCreateInit(UInt32 initCount, UInt32 maxCount)
+ {
+ return Semaphore_OptCreateInit(&_object, initCount, maxCount);
+ }
+ WRes Release() { return Semaphore_Release1(&_object); }
+ WRes Release(UInt32 releaseCount) { return Semaphore_ReleaseN(&_object, releaseCount); }
+ WRes Lock() { return Semaphore_Wait(&_object); }
+};
+
+class CCriticalSection MY_UNCOPYABLE
+{
+ ::CCriticalSection _object;
+public:
+ CCriticalSection() { CriticalSection_Init(&_object); }
+ ~CCriticalSection() { CriticalSection_Delete(&_object); }
+ void Enter() { CriticalSection_Enter(&_object); }
+ void Leave() { CriticalSection_Leave(&_object); }
+};
+
+class CCriticalSectionLock MY_UNCOPYABLE
+{
+ CCriticalSection *_object;
+ void Unlock() { _object->Leave(); }
+public:
+ CCriticalSectionLock(CCriticalSection &object): _object(&object) {_object->Enter(); }
+ ~CCriticalSectionLock() { Unlock(); }
+};
+
+
+#ifdef _WIN32
+
+typedef HANDLE CHandle_WFMO;
+typedef CSemaphore CSemaphore_WFMO;
+typedef CAutoResetEvent CAutoResetEvent_WFMO;
+typedef CManualResetEvent CManualResetEvent_WFMO;
+
+inline DWORD WINAPI WaitForMultiObj_Any_Infinite(DWORD count, const CHandle_WFMO *handles)
+{
+ return ::WaitForMultipleObjects(count, handles, FALSE, INFINITE);
+}
+
+#define SYNC_OBJ_DECL(obj)
+#define SYNC_WFMO(x)
+#define SYNC_PARAM(x)
+#define SYNC_PARAM_DECL(x)
+
+#else // _WIN32
+
+// POSIX sync objects for WaitForMultipleObjects
+
+#define SYNC_WFMO(x) x
+#define SYNC_PARAM(x) x,
+#define SYNC_PARAM_DECL(x) NWindows::NSynchronization::CSynchro *x
+#define SYNC_OBJ_DECL(x) NWindows::NSynchronization::CSynchro x;
+
+class CSynchro MY_UNCOPYABLE
+{
+ pthread_mutex_t _mutex;
+ pthread_cond_t _cond;
+ bool _isValid;
+
+public:
+ CSynchro() { _isValid = false; }
+ ~CSynchro()
+ {
+ if (_isValid)
+ {
+ ::pthread_mutex_destroy(&_mutex);
+ ::pthread_cond_destroy(&_cond);
+ }
+ _isValid = false;
+ }
+ WRes Create()
+ {
+ RINOK(::pthread_mutex_init(&_mutex, NULL))
+ const WRes ret = ::pthread_cond_init(&_cond, NULL);
+ _isValid = 1;
+ return ret;
+ }
+ WRes Enter()
+ {
+ return ::pthread_mutex_lock(&_mutex);
+ }
+ WRes Leave()
+ {
+ return ::pthread_mutex_unlock(&_mutex);
+ }
+ WRes WaitCond()
+ {
+ return ::pthread_cond_wait(&_cond, &_mutex);
+ }
+ WRes LeaveAndSignal()
+ {
+ const WRes res1 = ::pthread_cond_broadcast(&_cond);
+ const WRes res2 = ::pthread_mutex_unlock(&_mutex);
+ return (res2 ? res2 : res1);
+ }
+};
+
+
+struct CBaseHandle_WFMO;
+typedef NWindows::NSynchronization::CBaseHandle_WFMO *CHandle_WFMO;
+
+// these constants are from Windows
+#define WAIT_OBJECT_0 0
+#define WAIT_FAILED ((DWORD)0xFFFFFFFF)
+
+DWORD WINAPI WaitForMultiObj_Any_Infinite(DWORD count, const CHandle_WFMO *handles);
+
+
+struct CBaseHandle_WFMO MY_UNCOPYABLE
+{
+ CSynchro *_sync;
+
+ CBaseHandle_WFMO(): _sync(NULL) {}
+ virtual ~CBaseHandle_WFMO();
+
+ operator CHandle_WFMO() { return this; }
+ virtual bool IsSignaledAndUpdate() = 0;
+};
+
+
+class CBaseEvent_WFMO : public CBaseHandle_WFMO
+{
+ bool _manual_reset;
+ bool _state;
+
+public:
+
+ // bool IsCreated() { return (this->_sync != NULL); }
+ // CBaseEvent_WFMO() { ; }
+ // ~CBaseEvent_WFMO() Z7_override { Close(); }
+
+ WRes Close() { this->_sync = NULL; return 0; }
+
+ WRes Create(
+ CSynchro *sync,
+ bool manualReset, bool initiallyOwn)
+ {
+ this->_sync = sync;
+ this->_manual_reset = manualReset;
+ this->_state = initiallyOwn;
+ return 0;
+ }
+
+ WRes Set()
+ {
+ RINOK(this->_sync->Enter())
+ this->_state = true;
+ return this->_sync->LeaveAndSignal();
+ }
+
+ WRes Reset()
+ {
+ RINOK(this->_sync->Enter())
+ this->_state = false;
+ return this->_sync->Leave();
+ }
+
+ virtual bool IsSignaledAndUpdate() Z7_override;
+};
+
+
+class CManualResetEvent_WFMO Z7_final: public CBaseEvent_WFMO
+{
+public:
+ WRes Create(CSynchro *sync, bool initiallyOwn = false) { return CBaseEvent_WFMO::Create(sync, true, initiallyOwn); }
+};
+
+
+class CAutoResetEvent_WFMO Z7_final: public CBaseEvent_WFMO
+{
+public:
+ WRes Create(CSynchro *sync) { return CBaseEvent_WFMO::Create(sync, false, false); }
+ WRes CreateIfNotCreated_Reset(CSynchro *sync)
+ {
+ return Create(sync);
+ }
+};
+
+
+class CSemaphore_WFMO Z7_final: public CBaseHandle_WFMO
+{
+ UInt32 _count;
+ UInt32 _maxCount;
+
+public:
+ CSemaphore_WFMO() : _count(0), _maxCount(0) {}
+
+ WRes Close() { this->_sync = NULL; return 0; }
+
+ WRes Create(CSynchro *sync, UInt32 initCount, UInt32 maxCount)
+ {
+ if (initCount > maxCount || maxCount < 1)
+ return EINVAL;
+ this->_sync = sync;
+ this->_count = initCount;
+ this->_maxCount = maxCount;
+ return 0;
+ }
+
+ WRes Release(UInt32 releaseCount = 1)
+ {
+ if (releaseCount < 1)
+ return EINVAL;
+
+ RINOK(this->_sync->Enter())
+ UInt32 newCount = this->_count + releaseCount;
+ if (newCount > this->_maxCount)
+ {
+ RINOK(this->_sync->Leave())
+ return ERROR_TOO_MANY_POSTS; // EINVAL
+ }
+ this->_count = newCount;
+
+ return this->_sync->LeaveAndSignal();
+ }
+
+ virtual bool IsSignaledAndUpdate() Z7_override;
+};
+
+#endif // _WIN32
+
+}}
+
+#endif
diff --git a/CPP/Windows/System.cpp b/CPP/Windows/System.cpp
index c6f8275..dbe287a 100644
--- a/CPP/Windows/System.cpp
+++ b/CPP/Windows/System.cpp
@@ -1,142 +1,278 @@
-// Windows/System.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/MyWindows.h"
-
-#include "../Common/Defs.h"
-
-#include "System.h"
-
-namespace NWindows {
-namespace NSystem {
-
-UInt32 CountAffinity(DWORD_PTR mask)
-{
- UInt32 num = 0;
- for (unsigned i = 0; i < sizeof(mask) * 8; i++)
- num += (UInt32)((mask >> i) & 1);
- return num;
-}
-
-#ifdef _WIN32
-
-BOOL CProcessAffinity::Get()
-{
- #ifndef UNDER_CE
- return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
- #else
- return FALSE;
- #endif
-}
-
-
-UInt32 GetNumberOfProcessors()
-{
- // We need to know how many threads we can use.
- // By default the process is assigned to one group.
- // So we get the number of logical processors (threads)
- // assigned to current process in the current group.
- // Group size can be smaller than total number logical processors, for exammple, 2x36
-
- CProcessAffinity pa;
-
- if (pa.Get() && pa.processAffinityMask != 0)
- return pa.GetNumProcessThreads();
-
- SYSTEM_INFO systemInfo;
- GetSystemInfo(&systemInfo);
- // the number of logical processors in the current group
- return (UInt32)systemInfo.dwNumberOfProcessors;
-}
-
-#else
-
-UInt32 GetNumberOfProcessors()
-{
- return 1;
-}
-
-#endif
-
-
-#ifdef _WIN32
-
-#ifndef UNDER_CE
-
-#if !defined(_WIN64) && defined(__GNUC__)
-
-typedef struct _MY_MEMORYSTATUSEX {
- DWORD dwLength;
- DWORD dwMemoryLoad;
- DWORDLONG ullTotalPhys;
- DWORDLONG ullAvailPhys;
- DWORDLONG ullTotalPageFile;
- DWORDLONG ullAvailPageFile;
- DWORDLONG ullTotalVirtual;
- DWORDLONG ullAvailVirtual;
- DWORDLONG ullAvailExtendedVirtual;
-} MY_MEMORYSTATUSEX, *MY_LPMEMORYSTATUSEX;
-
-#else
-
-#define MY_MEMORYSTATUSEX MEMORYSTATUSEX
-#define MY_LPMEMORYSTATUSEX LPMEMORYSTATUSEX
-
-#endif
-
-typedef BOOL (WINAPI *GlobalMemoryStatusExP)(MY_LPMEMORYSTATUSEX lpBuffer);
-
-#endif
-
-#endif
-
-
-bool GetRamSize(UInt64 &size)
-{
- size = (UInt64)(sizeof(size_t)) << 29;
-
- #ifdef _WIN32
-
- #ifndef UNDER_CE
- MY_MEMORYSTATUSEX stat;
- stat.dwLength = sizeof(stat);
- #endif
-
- #ifdef _WIN64
-
- if (!::GlobalMemoryStatusEx(&stat))
- return false;
- size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
- return true;
-
- #else
-
- #ifndef UNDER_CE
- GlobalMemoryStatusExP globalMemoryStatusEx = (GlobalMemoryStatusExP)
- ::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GlobalMemoryStatusEx");
- if (globalMemoryStatusEx && globalMemoryStatusEx(&stat))
- {
- size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
- return true;
- }
- #endif
-
- {
- MEMORYSTATUS stat2;
- stat2.dwLength = sizeof(stat2);
- ::GlobalMemoryStatus(&stat2);
- size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
- return true;
- }
-
- #endif
-
- #else
-
- return false;
-
- #endif
-}
-
-}}
+// Windows/System.cpp
+
+#include "StdAfx.h"
+
+#ifndef _WIN32
+#include <unistd.h>
+#include <limits.h>
+#ifdef __APPLE__
+#include <sys/sysctl.h>
+#else
+#include <sys/sysinfo.h>
+#endif
+#endif
+
+#include "../Common/Defs.h"
+// #include "../Common/MyWindows.h"
+
+// #include "../../C/CpuArch.h"
+
+#include "System.h"
+
+namespace NWindows {
+namespace NSystem {
+
+#ifdef _WIN32
+
+UInt32 CountAffinity(DWORD_PTR mask)
+{
+ UInt32 num = 0;
+ for (unsigned i = 0; i < sizeof(mask) * 8; i++)
+ num += (UInt32)((mask >> i) & 1);
+ return num;
+}
+
+BOOL CProcessAffinity::Get()
+{
+ #ifndef UNDER_CE
+ return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
+ #else
+ return FALSE;
+ #endif
+}
+
+
+UInt32 GetNumberOfProcessors()
+{
+ // We need to know how many threads we can use.
+ // By default the process is assigned to one group.
+ // So we get the number of logical processors (threads)
+ // assigned to current process in the current group.
+ // Group size can be smaller than total number logical processors, for exammple, 2x36
+
+ CProcessAffinity pa;
+
+ if (pa.Get() && pa.processAffinityMask != 0)
+ return pa.GetNumProcessThreads();
+
+ SYSTEM_INFO systemInfo;
+ GetSystemInfo(&systemInfo);
+ // the number of logical processors in the current group
+ return (UInt32)systemInfo.dwNumberOfProcessors;
+}
+
+#else
+
+
+BOOL CProcessAffinity::Get()
+{
+ numSysThreads = GetNumberOfProcessors();
+
+ /*
+ numSysThreads = 8;
+ for (unsigned i = 0; i < numSysThreads; i++)
+ CpuSet_Set(&cpu_set, i);
+ return TRUE;
+ */
+
+ #ifdef Z7_AFFINITY_SUPPORTED
+
+ // numSysThreads = sysconf(_SC_NPROCESSORS_ONLN); // The number of processors currently online
+ if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) != 0)
+ return FALSE;
+ return TRUE;
+
+ #else
+
+ // cpu_set = ((CCpuSet)1 << (numSysThreads)) - 1;
+ return TRUE;
+ // errno = ENOSYS;
+ // return FALSE;
+
+ #endif
+}
+
+UInt32 GetNumberOfProcessors()
+{
+ #ifndef Z7_ST
+ long n = sysconf(_SC_NPROCESSORS_CONF); // The number of processors configured
+ if (n < 1)
+ n = 1;
+ return (UInt32)n;
+ #else
+ return 1;
+ #endif
+}
+
+#endif
+
+
+#ifdef _WIN32
+
+#ifndef UNDER_CE
+
+#if !defined(_WIN64) && \
+ (defined(__MINGW32_VERSION) || defined(Z7_OLD_WIN_SDK))
+
+typedef struct _MY_MEMORYSTATUSEX {
+ DWORD dwLength;
+ DWORD dwMemoryLoad;
+ DWORDLONG ullTotalPhys;
+ DWORDLONG ullAvailPhys;
+ DWORDLONG ullTotalPageFile;
+ DWORDLONG ullAvailPageFile;
+ DWORDLONG ullTotalVirtual;
+ DWORDLONG ullAvailVirtual;
+ DWORDLONG ullAvailExtendedVirtual;
+} MY_MEMORYSTATUSEX, *MY_LPMEMORYSTATUSEX;
+
+#else
+
+#define MY_MEMORYSTATUSEX MEMORYSTATUSEX
+#define MY_LPMEMORYSTATUSEX LPMEMORYSTATUSEX
+
+#endif
+
+typedef BOOL (WINAPI *Func_GlobalMemoryStatusEx)(MY_LPMEMORYSTATUSEX lpBuffer);
+
+#endif // !UNDER_CE
+
+
+bool GetRamSize(UInt64 &size)
+{
+ size = (UInt64)(sizeof(size_t)) << 29;
+
+ #ifndef UNDER_CE
+ MY_MEMORYSTATUSEX stat;
+ stat.dwLength = sizeof(stat);
+ #endif
+
+ #ifdef _WIN64
+
+ if (!::GlobalMemoryStatusEx(&stat))
+ return false;
+ size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
+ return true;
+
+ #else
+
+ #ifndef UNDER_CE
+ const
+ Func_GlobalMemoryStatusEx fn = Z7_GET_PROC_ADDRESS(
+ Func_GlobalMemoryStatusEx, ::GetModuleHandleA("kernel32.dll"),
+ "GlobalMemoryStatusEx");
+ if (fn && fn(&stat))
+ {
+ size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
+ return true;
+ }
+ #endif
+
+ {
+ MEMORYSTATUS stat2;
+ stat2.dwLength = sizeof(stat2);
+ ::GlobalMemoryStatus(&stat2);
+ size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
+ return true;
+ }
+ #endif
+}
+
+#else
+
+// POSIX
+// #include <stdio.h>
+
+bool GetRamSize(UInt64 &size)
+{
+ size = (UInt64)(sizeof(size_t)) << 29;
+
+ #ifdef __APPLE__
+
+ #ifdef HW_MEMSIZE
+ uint64_t val = 0; // support 2Gb+ RAM
+ int mib[2] = { CTL_HW, HW_MEMSIZE };
+ #elif defined(HW_PHYSMEM64)
+ uint64_t val = 0; // support 2Gb+ RAM
+ int mib[2] = { CTL_HW, HW_PHYSMEM64 };
+ #else
+ unsigned int val = 0; // For old system
+ int mib[2] = { CTL_HW, HW_PHYSMEM };
+ #endif // HW_MEMSIZE
+ size_t size_sys = sizeof(val);
+
+ sysctl(mib, 2, &val, &size_sys, NULL, 0);
+ if (val)
+ size = val;
+
+ #elif defined(_AIX)
+ // fixme
+ #elif defined(__gnu_hurd__)
+ // fixme
+ #elif defined(__FreeBSD_kernel__) && defined(__GLIBC__)
+ // GNU/kFreeBSD Debian
+ // fixme
+ #else
+
+ struct sysinfo info;
+ if (::sysinfo(&info) != 0)
+ return false;
+ size = (UInt64)info.mem_unit * info.totalram;
+ const UInt64 kLimit = (UInt64)1 << (sizeof(size_t) * 8 - 1);
+ if (size > kLimit)
+ size = kLimit;
+
+ /*
+ printf("\n mem_unit = %lld", (UInt64)info.mem_unit);
+ printf("\n totalram = %lld", (UInt64)info.totalram);
+ printf("\n freeram = %lld", (UInt64)info.freeram);
+ */
+
+ #endif
+
+ return true;
+}
+
+#endif
+
+
+unsigned long Get_File_OPEN_MAX()
+{
+ #ifdef _WIN32
+ return (1 << 24) - (1 << 16); // ~16M handles
+ #else
+ // some linux versions have default open file limit for user process of 1024 files.
+ long n = sysconf(_SC_OPEN_MAX);
+ // n = -1; // for debug
+ // n = 9; // for debug
+ if (n < 1)
+ {
+ // n = OPEN_MAX; // ???
+ // n = FOPEN_MAX; // = 16 : <stdio.h>
+ #ifdef _POSIX_OPEN_MAX
+ n = _POSIX_OPEN_MAX; // = 20 : <limits.h>
+ #else
+ n = 30; // our limit
+ #endif
+ }
+ return (unsigned long)n;
+ #endif
+}
+
+unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks()
+{
+ unsigned long numFiles_OPEN_MAX = NSystem::Get_File_OPEN_MAX();
+ const unsigned delta = 10; // the reserve for another internal needs of process
+ if (numFiles_OPEN_MAX > delta)
+ numFiles_OPEN_MAX -= delta;
+ else
+ numFiles_OPEN_MAX = 1;
+ numFiles_OPEN_MAX /= 3; // we suppose that we have up to 3 tasks in total for multiple file processing
+ numFiles_OPEN_MAX = MyMax(numFiles_OPEN_MAX, (unsigned long)3);
+ unsigned n = (UInt32)(UInt32)-1;
+ if (n > numFiles_OPEN_MAX)
+ n = (unsigned)numFiles_OPEN_MAX;
+ return n;
+}
+
+}}
diff --git a/CPP/Windows/System.h b/CPP/Windows/System.h
index bc28f47..0650007 100644
--- a/CPP/Windows/System.h
+++ b/CPP/Windows/System.h
@@ -1,40 +1,132 @@
-// Windows/System.h
-
-#ifndef __WINDOWS_SYSTEM_H
-#define __WINDOWS_SYSTEM_H
-
-#include "../Common/MyTypes.h"
-
-namespace NWindows {
-namespace NSystem {
-
-UInt32 CountAffinity(DWORD_PTR mask);
-
-struct CProcessAffinity
-{
- // UInt32 numProcessThreads;
- // UInt32 numSysThreads;
- DWORD_PTR processAffinityMask;
- DWORD_PTR systemAffinityMask;
-
- void InitST()
- {
- // numProcessThreads = 1;
- // numSysThreads = 1;
- processAffinityMask = 1;
- systemAffinityMask = 1;
- }
-
- UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
- UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
-
- BOOL Get();
-};
-
-UInt32 GetNumberOfProcessors();
-
-bool GetRamSize(UInt64 &size); // returns false, if unknown ram size
-
-}}
-
-#endif
+// Windows/System.h
+
+#ifndef ZIP7_INC_WINDOWS_SYSTEM_H
+#define ZIP7_INC_WINDOWS_SYSTEM_H
+
+#ifndef _WIN32
+// #include <sched.h>
+#include "../../C/Threads.h"
+#endif
+
+#include "../Common/MyTypes.h"
+#include "../Common/MyWindows.h"
+
+namespace NWindows {
+namespace NSystem {
+
+#ifdef _WIN32
+
+UInt32 CountAffinity(DWORD_PTR mask);
+
+struct CProcessAffinity
+{
+ // UInt32 numProcessThreads;
+ // UInt32 numSysThreads;
+ DWORD_PTR processAffinityMask;
+ DWORD_PTR systemAffinityMask;
+
+ void InitST()
+ {
+ // numProcessThreads = 1;
+ // numSysThreads = 1;
+ processAffinityMask = 1;
+ systemAffinityMask = 1;
+ }
+
+ void CpuZero()
+ {
+ processAffinityMask = 0;
+ }
+
+ void CpuSet(unsigned cpuIndex)
+ {
+ processAffinityMask |= ((DWORD_PTR)1 << cpuIndex);
+ }
+
+ UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
+ UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
+
+ BOOL Get();
+
+ BOOL SetProcAffinity() const
+ {
+ return SetProcessAffinityMask(GetCurrentProcess(), processAffinityMask);
+ }
+};
+
+
+#else // WIN32
+
+struct CProcessAffinity
+{
+ UInt32 numSysThreads;
+
+ UInt32 GetNumSystemThreads() const { return (UInt32)numSysThreads; }
+ BOOL Get();
+
+ #ifdef Z7_AFFINITY_SUPPORTED
+
+ CCpuSet cpu_set;
+
+ void InitST()
+ {
+ numSysThreads = 1;
+ CpuSet_Zero(&cpu_set);
+ CpuSet_Set(&cpu_set, 0);
+ }
+
+ UInt32 GetNumProcessThreads() const { return (UInt32)CPU_COUNT(&cpu_set); }
+ void CpuZero() { CpuSet_Zero(&cpu_set); }
+ void CpuSet(unsigned cpuIndex) { CpuSet_Set(&cpu_set, cpuIndex); }
+ int IsCpuSet(unsigned cpuIndex) const { return CpuSet_IsSet(&cpu_set, cpuIndex); }
+ // void CpuClr(int cpuIndex) { CPU_CLR(cpuIndex, &cpu_set); }
+
+ BOOL SetProcAffinity() const
+ {
+ return sched_setaffinity(0, sizeof(cpu_set), &cpu_set) == 0;
+ }
+
+ #else // Z7_AFFINITY_SUPPORTED
+
+ void InitST()
+ {
+ numSysThreads = 1;
+ }
+
+ UInt32 GetNumProcessThreads() const
+ {
+ return numSysThreads;
+ /*
+ UInt32 num = 0;
+ for (unsigned i = 0; i < sizeof(cpu_set) * 8; i++)
+ num += (UInt32)((cpu_set >> i) & 1);
+ return num;
+ */
+ }
+
+ void CpuZero() { }
+ void CpuSet(unsigned cpuIndex) { UNUSED_VAR(cpuIndex); }
+ int IsCpuSet(unsigned cpuIndex) const { return (cpuIndex < numSysThreads) ? 1 : 0; }
+
+ BOOL SetProcAffinity() const
+ {
+ errno = ENOSYS;
+ return FALSE;
+ }
+
+ #endif // Z7_AFFINITY_SUPPORTED
+};
+
+#endif // _WIN32
+
+
+UInt32 GetNumberOfProcessors();
+
+bool GetRamSize(UInt64 &size); // returns false, if unknown ram size
+
+unsigned long Get_File_OPEN_MAX();
+unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks();
+
+}}
+
+#endif
diff --git a/CPP/Windows/SystemInfo.cpp b/CPP/Windows/SystemInfo.cpp
new file mode 100644
index 0000000..6bafc80
--- /dev/null
+++ b/CPP/Windows/SystemInfo.cpp
@@ -0,0 +1,1022 @@
+// Windows/SystemInfo.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+
+#include "../Common/IntToString.h"
+
+#ifdef _WIN32
+
+#include "Registry.h"
+
+#else
+
+#include <unistd.h>
+#include <sys/utsname.h>
+#ifdef __APPLE__
+#include <sys/sysctl.h>
+#elif !defined(_AIX)
+
+#include <sys/auxv.h>
+
+// #undef AT_HWCAP // to debug
+// #undef AT_HWCAP2 // to debug
+
+/* the following patch for some debian systems.
+ Is it OK to define AT_HWCAP and AT_HWCAP2 here with these constant numbers? */
+/*
+#if defined(__FreeBSD_kernel__) && defined(__GLIBC__)
+ #ifndef AT_HWCAP
+ #define AT_HWCAP 16
+ #endif
+ #ifndef AT_HWCAP2
+ #define AT_HWCAP2 26
+ #endif
+#endif
+*/
+
+#ifdef MY_CPU_ARM_OR_ARM64
+#include <asm/hwcap.h>
+#endif
+#endif
+
+#ifdef __linux__
+#include "../Windows/FileIO.h"
+#endif
+
+#endif // WIN32
+
+#include "SystemInfo.h"
+#include "System.h"
+
+using namespace NWindows;
+
+#ifdef __linux__
+
+static bool ReadFile_to_Buffer(CFSTR fileName, CByteBuffer &buf)
+{
+ NWindows::NFile::NIO::CInFile file;
+ if (!file.Open(fileName))
+ return false;
+ /*
+ UInt64 size;
+ if (!file.GetLength(size))
+ {
+ // GetLength() doesn't work "/proc/cpuinfo"
+ return false;
+ }
+ if (size >= ((UInt32)1 << 29))
+ return false;
+ */
+ size_t size = 0;
+ size_t addSize = ((size_t)1 << 12);
+ for (;;)
+ {
+ // printf("\nsize = %d\n", (unsigned)size);
+ buf.ChangeSize_KeepData(size + addSize, size);
+ size_t processed;
+ if (!file.ReadFull(buf + size, addSize, processed))
+ return false;
+ if (processed == 0)
+ {
+ buf.ChangeSize_KeepData(size, size);
+ return true;
+ }
+ size += processed;
+ addSize *= 2;
+ }
+}
+
+#endif
+
+
+#if defined(_WIN32) || defined(AT_HWCAP) || defined(AT_HWCAP2)
+static void PrintHex(AString &s, UInt64 v)
+{
+ char temp[32];
+ ConvertUInt64ToHex(v, temp);
+ s += temp;
+}
+#endif
+
+#ifdef MY_CPU_X86_OR_AMD64
+
+Z7_NO_INLINE
+static void PrintCpuChars(AString &s, UInt32 v)
+{
+ for (unsigned j = 0; j < 4; j++)
+ {
+ Byte b = (Byte)(v & 0xFF);
+ v >>= 8;
+ if (b == 0)
+ break;
+ if (b >= 0x20 && b <= 0x7f)
+ s += (char)b;
+ else
+ {
+ s += '[';
+ char temp[16];
+ ConvertUInt32ToHex(b, temp);
+ s += temp;
+ s += ']';
+ }
+ }
+}
+
+
+static void x86cpuid_to_String(AString &s)
+{
+ s.Empty();
+
+ UInt32 a[4];
+ // cpuid was called already. So we don't check for cpuid availability here
+ z7_x86_cpuid(a, 0x80000000);
+
+ if (a[0] >= 0x80000004) // if (maxFunc2 >= hi+4) the full name is available
+ {
+ for (unsigned i = 0; i < 3; i++)
+ {
+ z7_x86_cpuid(a, 0x80000002 + i);
+ for (unsigned j = 0; j < 4; j++)
+ PrintCpuChars(s, a[j]);
+ }
+ }
+
+ s.Trim();
+
+ if (s.IsEmpty())
+ {
+ z7_x86_cpuid(a, 0);
+ for (unsigned i = 1; i < 4; i++)
+ {
+ const unsigned j = (i ^ (i >> 1));
+ PrintCpuChars(s, a[j]);
+ }
+ s.Trim();
+ }
+}
+
+/*
+static void x86cpuid_all_to_String(AString &s)
+{
+ Cx86cpuid p;
+ if (!x86cpuid_CheckAndRead(&p))
+ return;
+ s += "x86cpuid maxFunc = ";
+ s.Add_UInt32(p.maxFunc);
+ for (unsigned j = 0; j <= p.maxFunc; j++)
+ {
+ s.Add_LF();
+ // s.Add_UInt32(j); // align
+ {
+ char temp[32];
+ ConvertUInt32ToString(j, temp);
+ unsigned len = (unsigned)strlen(temp);
+ while (len < 8)
+ {
+ len++;
+ s.Add_Space();
+ }
+ s += temp;
+ }
+
+ s += ":";
+ UInt32 d[4] = { 0 };
+ MyCPUID(j, &d[0], &d[1], &d[2], &d[3]);
+ for (unsigned i = 0; i < 4; i++)
+ {
+ char temp[32];
+ ConvertUInt32ToHex8Digits(d[i], temp);
+ s.Add_Space();
+ s += temp;
+ }
+ }
+}
+*/
+
+#endif
+
+
+
+#ifdef _WIN32
+
+static const char * const k_PROCESSOR_ARCHITECTURE[] =
+{
+ "x86" // "INTEL"
+ , "MIPS"
+ , "ALPHA"
+ , "PPC"
+ , "SHX"
+ , "ARM"
+ , "IA64"
+ , "ALPHA64"
+ , "MSIL"
+ , "x64" // "AMD64"
+ , "IA32_ON_WIN64"
+ , "NEUTRAL"
+ , "ARM64"
+ , "ARM32_ON_WIN64"
+};
+
+#define Z7_WIN_PROCESSOR_ARCHITECTURE_INTEL 0
+#define Z7_WIN_PROCESSOR_ARCHITECTURE_AMD64 9
+
+
+#define Z7_WIN_PROCESSOR_INTEL_PENTIUM 586
+#define Z7_WIN_PROCESSOR_AMD_X8664 8664
+
+/*
+static const CUInt32PCharPair k_PROCESSOR[] =
+{
+ { 2200, "IA64" },
+ { 8664, "x64" }
+};
+
+#define PROCESSOR_INTEL_386 386
+#define PROCESSOR_INTEL_486 486
+#define PROCESSOR_INTEL_PENTIUM 586
+#define PROCESSOR_INTEL_860 860
+#define PROCESSOR_INTEL_IA64 2200
+#define PROCESSOR_AMD_X8664 8664
+#define PROCESSOR_MIPS_R2000 2000
+#define PROCESSOR_MIPS_R3000 3000
+#define PROCESSOR_MIPS_R4000 4000
+#define PROCESSOR_ALPHA_21064 21064
+#define PROCESSOR_PPC_601 601
+#define PROCESSOR_PPC_603 603
+#define PROCESSOR_PPC_604 604
+#define PROCESSOR_PPC_620 620
+#define PROCESSOR_HITACHI_SH3 10003
+#define PROCESSOR_HITACHI_SH3E 10004
+#define PROCESSOR_HITACHI_SH4 10005
+#define PROCESSOR_MOTOROLA_821 821
+#define PROCESSOR_SHx_SH3 103
+#define PROCESSOR_SHx_SH4 104
+#define PROCESSOR_STRONGARM 2577 // 0xA11
+#define PROCESSOR_ARM720 1824 // 0x720
+#define PROCESSOR_ARM820 2080 // 0x820
+#define PROCESSOR_ARM920 2336 // 0x920
+#define PROCESSOR_ARM_7TDMI 70001
+#define PROCESSOR_OPTIL 18767 // 0x494f
+*/
+
+
+/*
+static const char * const k_PF[] =
+{
+ "FP_ERRATA"
+ , "FP_EMU"
+ , "CMPXCHG"
+ , "MMX"
+ , "PPC_MOVEMEM_64BIT"
+ , "ALPHA_BYTE"
+ , "SSE"
+ , "3DNOW"
+ , "RDTSC"
+ , "PAE"
+ , "SSE2"
+ , "SSE_DAZ"
+ , "NX"
+ , "SSE3"
+ , "CMPXCHG16B"
+ , "CMP8XCHG16"
+ , "CHANNELS"
+ , "XSAVE"
+ , "ARM_VFP_32"
+ , "ARM_NEON"
+ , "L2AT"
+ , "VIRT_FIRMWARE"
+ , "RDWRFSGSBASE"
+ , "FASTFAIL"
+ , "ARM_DIVIDE"
+ , "ARM_64BIT_LOADSTORE_ATOMIC"
+ , "ARM_EXTERNAL_CACHE"
+ , "ARM_FMAC"
+ , "RDRAND"
+ , "ARM_V8"
+ , "ARM_V8_CRYPTO"
+ , "ARM_V8_CRC32"
+ , "RDTSCP"
+ , "RDPID"
+ , "ARM_V81_ATOMIC"
+ , "MONITORX"
+};
+*/
+
+#endif
+
+
+static void PrintPage(AString &s, UInt64 v)
+{
+ const char *t = "B";
+ if ((v & 0x3ff) == 0)
+ {
+ v >>= 10;
+ t = "KB";
+ }
+ s.Add_UInt64(v);
+ s += t;
+}
+
+#ifdef _WIN32
+
+static AString TypeToString2(const char * const table[], unsigned num, UInt32 value)
+{
+ char sz[16];
+ const char *p = NULL;
+ if (value < num)
+ p = table[value];
+ if (!p)
+ {
+ ConvertUInt32ToString(value, sz);
+ p = sz;
+ }
+ return (AString)p;
+}
+
+// #if defined(Z7_LARGE_PAGES) || defined(_WIN32)
+// #ifdef _WIN32
+void PrintSize_KMGT_Or_Hex(AString &s, UInt64 v)
+{
+ char c = 0;
+ if ((v & 0x3FF) == 0) { v >>= 10; c = 'K';
+ if ((v & 0x3FF) == 0) { v >>= 10; c = 'M';
+ if ((v & 0x3FF) == 0) { v >>= 10; c = 'G';
+ if ((v & 0x3FF) == 0) { v >>= 10; c = 'T';
+ }}}}
+ else
+ {
+ // s += "0x";
+ PrintHex(s, v);
+ return;
+ }
+ s.Add_UInt64(v);
+ if (c)
+ s += c;
+ s += 'B';
+}
+// #endif
+// #endif
+
+static void SysInfo_To_String(AString &s, const SYSTEM_INFO &si)
+{
+ s += TypeToString2(k_PROCESSOR_ARCHITECTURE, Z7_ARRAY_SIZE(k_PROCESSOR_ARCHITECTURE), si.wProcessorArchitecture);
+
+ if (!( (si.wProcessorArchitecture == Z7_WIN_PROCESSOR_ARCHITECTURE_INTEL && si.dwProcessorType == Z7_WIN_PROCESSOR_INTEL_PENTIUM)
+ || (si.wProcessorArchitecture == Z7_WIN_PROCESSOR_ARCHITECTURE_AMD64 && si.dwProcessorType == Z7_WIN_PROCESSOR_AMD_X8664)))
+ {
+ s.Add_Space();
+ // s += TypePairToString(k_PROCESSOR, Z7_ARRAY_SIZE(k_PROCESSOR), si.dwProcessorType);
+ s.Add_UInt32(si.dwProcessorType);
+ }
+ s.Add_Space();
+ PrintHex(s, si.wProcessorLevel);
+ s.Add_Dot();
+ PrintHex(s, si.wProcessorRevision);
+ if ((UInt64)si.dwActiveProcessorMask + 1 != ((UInt64)1 << si.dwNumberOfProcessors))
+ if ((UInt64)si.dwActiveProcessorMask + 1 != 0 || si.dwNumberOfProcessors != sizeof(UInt64) * 8)
+ {
+ s += " act:";
+ PrintHex(s, si.dwActiveProcessorMask);
+ }
+ s += " cpus:";
+ s.Add_UInt32(si.dwNumberOfProcessors);
+ if (si.dwPageSize != 1 << 12)
+ {
+ s += " page:";
+ PrintPage(s, si.dwPageSize);
+ }
+ if (si.dwAllocationGranularity != 1 << 16)
+ {
+ s += " gran:";
+ PrintPage(s, si.dwAllocationGranularity);
+ }
+ s.Add_Space();
+
+ const DWORD_PTR minAdd = (DWORD_PTR)si.lpMinimumApplicationAddress;
+ UInt64 maxSize = (UInt64)(DWORD_PTR)si.lpMaximumApplicationAddress + 1;
+ const UInt32 kReserveSize = ((UInt32)1 << 16);
+ if (minAdd != kReserveSize)
+ {
+ PrintSize_KMGT_Or_Hex(s, minAdd);
+ s += "-";
+ }
+ else
+ {
+ if ((maxSize & (kReserveSize - 1)) == 0)
+ maxSize += kReserveSize;
+ }
+ PrintSize_KMGT_Or_Hex(s, maxSize);
+}
+
+#ifndef _WIN64
+EXTERN_C_BEGIN
+typedef VOID (WINAPI *Func_GetNativeSystemInfo)(LPSYSTEM_INFO lpSystemInfo);
+EXTERN_C_END
+#endif
+
+#endif
+
+#ifdef __APPLE__
+#ifndef MY_CPU_X86_OR_AMD64
+static void Add_sysctlbyname_to_String(const char *name, AString &s)
+{
+ size_t bufSize = 256;
+ char buf[256];
+ if (z7_sysctlbyname_Get(name, &buf, &bufSize) == 0)
+ s += buf;
+}
+#endif
+#endif
+
+void GetSysInfo(AString &s1, AString &s2);
+void GetSysInfo(AString &s1, AString &s2)
+{
+ s1.Empty();
+ s2.Empty();
+
+ #ifdef _WIN32
+ SYSTEM_INFO si;
+ GetSystemInfo(&si);
+ {
+ SysInfo_To_String(s1, si);
+ // s += " : ";
+ }
+
+ #if !defined(_WIN64) && !defined(UNDER_CE)
+ const
+ Func_GetNativeSystemInfo fn = Z7_GET_PROC_ADDRESS(
+ Func_GetNativeSystemInfo, GetModuleHandleA("kernel32.dll"),
+ "GetNativeSystemInfo");
+ if (fn)
+ {
+ SYSTEM_INFO si2;
+ fn(&si2);
+ // if (memcmp(&si, &si2, sizeof(si)) != 0)
+ {
+ // s += " - ";
+ SysInfo_To_String(s2, si2);
+ }
+ }
+ #endif
+ #endif
+}
+
+
+void GetCpuName(AString &s);
+
+static void AddBracedString(AString &dest, AString &src)
+{
+ if (!src.IsEmpty())
+ {
+ AString s;
+ s += '(';
+ s += src;
+ s += ')';
+ dest.Add_OptSpaced(s);
+ }
+}
+
+struct CCpuName
+{
+ AString CpuName;
+ AString Revision;
+ AString Microcode;
+ AString LargePages;
+
+ void Fill();
+
+ void Get_Revision_Microcode_LargePages(AString &s)
+ {
+ s.Empty();
+ AddBracedString(s, Revision);
+ AddBracedString(s, Microcode);
+ s.Add_OptSpaced(LargePages);
+ }
+};
+
+void CCpuName::Fill()
+{
+ CpuName.Empty();
+ Revision.Empty();
+ Microcode.Empty();
+ LargePages.Empty();
+
+ AString &s = CpuName;
+
+ #ifdef MY_CPU_X86_OR_AMD64
+ {
+ #if !defined(MY_CPU_AMD64)
+ if (!z7_x86_cpuid_GetMaxFunc())
+ s += "x86";
+ else
+ #endif
+ {
+ x86cpuid_to_String(s);
+ {
+ UInt32 a[4];
+ z7_x86_cpuid(a, 1);
+ char temp[16];
+ ConvertUInt32ToHex(a[0], temp);
+ Revision += temp;
+ }
+ }
+ }
+ #elif defined(__APPLE__)
+ {
+ Add_sysctlbyname_to_String("machdep.cpu.brand_string", s);
+ }
+ #endif
+
+
+ if (s.IsEmpty())
+ {
+ #ifdef MY_CPU_LE
+ s += "LE";
+ #elif defined(MY_CPU_BE)
+ s += "BE";
+ #endif
+ }
+
+ #ifdef __APPLE__
+ {
+ AString s2;
+ UInt32 v = 0;
+ if (z7_sysctlbyname_Get_UInt32("machdep.cpu.core_count", &v) == 0)
+ {
+ s2.Add_UInt32(v);
+ s2 += 'C';
+ }
+ if (z7_sysctlbyname_Get_UInt32("machdep.cpu.thread_count", &v) == 0)
+ {
+ s2.Add_UInt32(v);
+ s2 += 'T';
+ }
+ if (!s2.IsEmpty())
+ {
+ s.Add_Space_if_NotEmpty();
+ s += s2;
+ }
+ }
+ #endif
+
+
+ #ifdef _WIN32
+ {
+ NRegistry::CKey key;
+ if (key.Open(HKEY_LOCAL_MACHINE, TEXT("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"), KEY_READ) == ERROR_SUCCESS)
+ {
+ LONG res[2];
+ CByteBuffer bufs[2];
+ {
+ for (unsigned i = 0; i < 2; i++)
+ {
+ UInt32 size = 0;
+ res[i] = key.QueryValue(i == 0 ?
+ TEXT("Previous Update Revision") :
+ TEXT("Update Revision"), bufs[i], size);
+ if (res[i] == ERROR_SUCCESS)
+ if (size != bufs[i].Size())
+ res[i] = ERROR_SUCCESS + 1;
+ }
+ }
+ if (res[0] == ERROR_SUCCESS || res[1] == ERROR_SUCCESS)
+ {
+ for (unsigned i = 0; i < 2; i++)
+ {
+ if (i == 1)
+ Microcode += "->";
+ if (res[i] != ERROR_SUCCESS)
+ continue;
+ const CByteBuffer &buf = bufs[i];
+ if (buf.Size() == 8)
+ {
+ UInt32 high = GetUi32(buf);
+ if (high != 0)
+ {
+ PrintHex(Microcode, high);
+ Microcode += ".";
+ }
+ PrintHex(Microcode, GetUi32(buf + 4));
+ }
+ }
+ }
+ }
+ }
+ #endif
+
+
+ #ifdef Z7_LARGE_PAGES
+ Add_LargePages_String(LargePages);
+ #endif
+}
+
+void AddCpuFeatures(AString &s);
+void AddCpuFeatures(AString &s)
+{
+ #ifdef _WIN32
+ // const unsigned kNumFeatures_Extra = 32; // we check also for unknown features
+ // const unsigned kNumFeatures = Z7_ARRAY_SIZE(k_PF) + kNumFeatures_Extra;
+ const unsigned kNumFeatures = 64;
+ UInt64 flags = 0;
+ for (unsigned i = 0; i < kNumFeatures; i++)
+ {
+ if (IsProcessorFeaturePresent(i))
+ {
+ flags += (UInt64)1 << i;
+ // s.Add_Space_if_NotEmpty();
+ // s += TypeToString2(k_PF, Z7_ARRAY_SIZE(k_PF), i);
+ }
+ }
+ s.Add_OptSpaced("f:");
+ PrintHex(s, flags);
+
+ #elif defined(__APPLE__)
+ {
+ UInt32 v = 0;
+ if (z7_sysctlbyname_Get_UInt32("hw.pagesize", &v) == 0)
+ {
+ s.Add_OptSpaced("PageSize:");
+ PrintPage(s, v);
+ }
+ }
+
+ #else
+
+ const long v = sysconf(_SC_PAGESIZE);
+ if (v != -1)
+ {
+ s.Add_OptSpaced("PageSize:");
+ PrintPage(s, (unsigned long)v);
+ }
+
+ #if !defined(_AIX)
+
+ #ifdef __linux__
+
+ CByteBuffer buf;
+ if (ReadFile_to_Buffer("/sys/kernel/mm/transparent_hugepage/enabled", buf))
+ // if (ReadFile_to_Buffer("/proc/cpuinfo", buf))
+ {
+ s.Add_OptSpaced("THP:");
+ AString s2;
+ s2.SetFrom_CalcLen((const char *)(const void *)(const Byte *)buf, (unsigned)buf.Size());
+ const int pos = s2.Find('[');
+ if (pos >= 0)
+ {
+ const int pos2 = s2.Find(']', (unsigned)pos + 1);
+ if (pos2 >= 0)
+ {
+ s2.DeleteFrom((unsigned)pos2);
+ s2.DeleteFrontal((unsigned)pos + 1);
+ }
+ }
+ s += s2;
+ }
+ // else throw CSystemException(MY_SRes_HRESULT_FROM_WRes(errno));
+
+ #endif
+
+
+ #ifdef AT_HWCAP
+ s.Add_OptSpaced("hwcap:");
+ {
+ unsigned long h = getauxval(AT_HWCAP);
+ PrintHex(s, h);
+ #ifdef MY_CPU_ARM64
+ if (h & HWCAP_CRC32) s += ":CRC32";
+ if (h & HWCAP_SHA1) s += ":SHA1";
+ if (h & HWCAP_SHA2) s += ":SHA2";
+ if (h & HWCAP_AES) s += ":AES";
+ if (h & HWCAP_ASIMD) s += ":ASIMD";
+ #elif defined(MY_CPU_ARM)
+ if (h & HWCAP_NEON) s += ":NEON";
+ #endif
+ }
+ #endif // AT_HWCAP
+
+ #ifdef AT_HWCAP2
+ {
+ unsigned long h = getauxval(AT_HWCAP2);
+ #ifndef MY_CPU_ARM
+ if (h != 0)
+ #endif
+ {
+ s += " hwcap2:";
+ PrintHex(s, h);
+ #ifdef MY_CPU_ARM
+ if (h & HWCAP2_CRC32) s += ":CRC32";
+ if (h & HWCAP2_SHA1) s += ":SHA1";
+ if (h & HWCAP2_SHA2) s += ":SHA2";
+ if (h & HWCAP2_AES) s += ":AES";
+ #endif
+ }
+ }
+ #endif // AT_HWCAP2
+ #endif // _AIX
+ #endif // _WIN32
+}
+
+
+#ifdef _WIN32
+#ifndef UNDER_CE
+
+EXTERN_C_BEGIN
+typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
+EXTERN_C_END
+
+static BOOL My_RtlGetVersion(OSVERSIONINFOEXW *vi)
+{
+ const HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
+ if (!ntdll)
+ return FALSE;
+ const
+ Func_RtlGetVersion func = Z7_GET_PROC_ADDRESS(
+ Func_RtlGetVersion, ntdll,
+ "RtlGetVersion");
+ if (!func)
+ return FALSE;
+ func(vi);
+ return TRUE;
+}
+
+#endif
+#endif
+
+
+void GetOsInfoText(AString &sRes)
+{
+ sRes.Empty();
+ AString s;
+
+ #ifdef _WIN32
+ #ifndef UNDER_CE
+ // OSVERSIONINFO vi;
+ OSVERSIONINFOEXW vi;
+ vi.dwOSVersionInfoSize = sizeof(vi);
+ // if (::GetVersionEx(&vi))
+ if (My_RtlGetVersion(&vi))
+ {
+ s += "Windows";
+ if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+ s.Add_UInt32(vi.dwPlatformId);
+ s.Add_Space(); s.Add_UInt32(vi.dwMajorVersion);
+ s.Add_Dot(); s.Add_UInt32(vi.dwMinorVersion);
+ s.Add_Space(); s.Add_UInt32(vi.dwBuildNumber);
+
+ if (vi.wServicePackMajor != 0 || vi.wServicePackMinor != 0)
+ {
+ s += " SP:"; s.Add_UInt32(vi.wServicePackMajor);
+ s.Add_Dot(); s.Add_UInt32(vi.wServicePackMinor);
+ }
+ // s += " Suite:"; PrintHex(s, vi.wSuiteMask);
+ // s += " Type:"; s.Add_UInt32(vi.wProductType);
+ // s.Add_Space(); s += GetOemString(vi.szCSDVersion);
+ }
+ /*
+ {
+ s += " OEMCP:"; s.Add_UInt32(GetOEMCP());
+ s += " ACP:"; s.Add_UInt32(GetACP());
+ }
+ */
+ #endif
+ #else // _WIN32
+
+ if (!s.IsEmpty())
+ s.Add_LF();
+ struct utsname un;
+ if (uname(&un) == 0)
+ {
+ s += un.sysname;
+ // s += " : "; s += un.nodename; // we don't want to show name of computer
+ s += " : "; s += un.release;
+ s += " : "; s += un.version;
+ s += " : "; s += un.machine;
+
+ #ifdef __APPLE__
+ // Add_sysctlbyname_to_String("kern.version", s);
+ // it's same as "utsname.version"
+ #endif
+ }
+ #endif // _WIN32
+
+ sRes += s;
+ #ifdef MY_CPU_X86_OR_AMD64
+ {
+ AString s2;
+ GetVirtCpuid(s2);
+ if (!s2.IsEmpty())
+ {
+ sRes += " : ";
+ sRes += s2;
+ }
+ }
+ #endif
+}
+
+
+
+void GetSystemInfoText(AString &sRes)
+{
+ GetOsInfoText(sRes);
+ sRes.Add_LF();
+
+ {
+ AString s, s1, s2;
+ GetSysInfo(s1, s2);
+ if (!s1.IsEmpty() || !s2.IsEmpty())
+ {
+ s = s1;
+ if (s1 != s2 && !s2.IsEmpty())
+ {
+ s += " - ";
+ s += s2;
+ }
+ }
+ {
+ AddCpuFeatures(s);
+ if (!s.IsEmpty())
+ {
+ sRes += s;
+ sRes.Add_LF();
+ }
+ }
+ }
+ {
+ AString s;
+ GetCpuName(s);
+ if (!s.IsEmpty())
+ {
+ sRes += s;
+ sRes.Add_LF();
+ }
+ }
+ /*
+ #ifdef MY_CPU_X86_OR_AMD64
+ {
+ AString s;
+ x86cpuid_all_to_String(s);
+ if (!s.IsEmpty())
+ {
+ printCallback->Print(s);
+ printCallback->NewLine();
+ }
+ }
+ #endif
+ */
+}
+
+
+void GetCpuName(AString &s);
+void GetCpuName(AString &s)
+{
+ CCpuName cpuName;
+ cpuName.Fill();
+ s = cpuName.CpuName;
+ AString s2;
+ cpuName.Get_Revision_Microcode_LargePages(s2);
+ s.Add_OptSpaced(s2);
+}
+
+
+void GetCpuName_MultiLine(AString &s);
+void GetCpuName_MultiLine(AString &s)
+{
+ CCpuName cpuName;
+ cpuName.Fill();
+ s = cpuName.CpuName;
+ AString s2;
+ cpuName.Get_Revision_Microcode_LargePages(s2);
+ if (!s2.IsEmpty())
+ {
+ s.Add_LF();
+ s += s2;
+ }
+}
+
+
+#ifdef MY_CPU_X86_OR_AMD64
+
+void GetVirtCpuid(AString &s)
+{
+ const UInt32 kHv = 0x40000000;
+
+ Z7_IF_X86_CPUID_SUPPORTED
+ {
+ UInt32 a[4];
+ z7_x86_cpuid(a, kHv);
+
+ if (a[0] < kHv || a[0] >= kHv + (1 << 16))
+ return;
+ {
+ {
+ for (unsigned j = 1; j < 4; j++)
+ PrintCpuChars(s, a[j]);
+ }
+ }
+ if (a[0] >= kHv + 1)
+ {
+ UInt32 d[4];
+ z7_x86_cpuid(d, kHv + 1);
+ s += " : ";
+ PrintCpuChars(s, d[0]);
+ if (a[0] >= kHv + 2)
+ {
+ z7_x86_cpuid(d, kHv + 2);
+ s += " : ";
+ s.Add_UInt32(d[1] >> 16);
+ s.Add_Dot(); s.Add_UInt32(d[1] & 0xffff);
+ s.Add_Dot(); s.Add_UInt32(d[0]);
+ s.Add_Dot(); s.Add_UInt32(d[2]);
+ s.Add_Dot(); s.Add_UInt32(d[3] >> 24);
+ s.Add_Dot(); s.Add_UInt32(d[3] & 0xffffff);
+ }
+ /*
+ if (a[0] >= kHv + 5)
+ {
+ z7_x86_cpuid(d, kHv + 5);
+ s += " : ";
+ s.Add_UInt32(d[0]);
+ s += "p";
+ s.Add_UInt32(d[1]);
+ s += "t";
+ }
+ */
+ }
+ }
+}
+
+#endif
+
+
+void GetCompiler(AString &s)
+{
+ #ifdef __VERSION__
+ s += __VERSION__;
+ #endif
+
+ #ifdef __GNUC__
+ s += " GCC ";
+ s.Add_UInt32(__GNUC__);
+ s.Add_Dot();
+ s.Add_UInt32(__GNUC_MINOR__);
+ s.Add_Dot();
+ s.Add_UInt32(__GNUC_PATCHLEVEL__);
+ #endif
+
+ #ifdef __clang__
+ s += " CLANG ";
+ s.Add_UInt32(__clang_major__);
+ s.Add_Dot();
+ s.Add_UInt32(__clang_minor__);
+ #endif
+
+ #ifdef __xlC__
+ s += " XLC ";
+ s.Add_UInt32(__xlC__ >> 8);
+ s.Add_Dot();
+ s.Add_UInt32(__xlC__ & 0xFF);
+ #ifdef __xlC_ver__
+ s.Add_Dot();
+ s.Add_UInt32(__xlC_ver__ >> 8);
+ s.Add_Dot();
+ s.Add_UInt32(__xlC_ver__ & 0xFF);
+ #endif
+ #endif
+
+ #ifdef _MSC_VER
+ s += " MSC ";
+ s.Add_UInt32(_MSC_VER);
+ #endif
+
+ #if defined(__AVX2__)
+ #define MY_CPU_COMPILE_ISA "AVX2"
+ #elif defined(__AVX__)
+ #define MY_CPU_COMPILE_ISA "AVX"
+ #elif defined(__SSE2__)
+ #define MY_CPU_COMPILE_ISA "SSE2"
+ #elif defined(_M_IX86_FP) && (_M_IX86_FP >= 2)
+ #define MY_CPU_COMPILE_ISA "SSE2"
+ #elif defined(__SSE__)
+ #define MY_CPU_COMPILE_ISA "SSE"
+ #elif defined(_M_IX86_FP) && (_M_IX86_FP >= 1)
+ #define MY_CPU_COMPILE_ISA "SSE"
+ #elif defined(__i686__)
+ #define MY_CPU_COMPILE_ISA "i686"
+ #elif defined(__i586__)
+ #define MY_CPU_COMPILE_ISA "i586"
+ #elif defined(__i486__)
+ #define MY_CPU_COMPILE_ISA "i486"
+ #elif defined(__i386__)
+ #define MY_CPU_COMPILE_ISA "i386"
+ #elif defined(_M_IX86_FP)
+ #define MY_CPU_COMPILE_ISA "IA32"
+ #endif
+
+
+ #ifdef MY_CPU_COMPILE_ISA
+ s += ':';
+ s.Add_OptSpaced(MY_CPU_COMPILE_ISA);
+ #endif
+}
diff --git a/CPP/Windows/SystemInfo.h b/CPP/Windows/SystemInfo.h
new file mode 100644
index 0000000..c2e2e3b
--- /dev/null
+++ b/CPP/Windows/SystemInfo.h
@@ -0,0 +1,19 @@
+// Windows/SystemInfo.h
+
+#ifndef ZIP7_INC_WINDOWS_SYSTEM_INFO_H
+#define ZIP7_INC_WINDOWS_SYSTEM_INFO_H
+
+#include "../Common/MyString.h"
+
+
+void GetCpuName_MultiLine(AString &s);
+
+void GetOsInfoText(AString &sRes);
+void GetSystemInfoText(AString &s);
+void PrintSize_KMGT_Or_Hex(AString &s, UInt64 v);
+void Add_LargePages_String(AString &s);
+
+void GetCompiler(AString &s);
+void GetVirtCpuid(AString &s);
+
+#endif
diff --git a/CPP/Windows/Thread.h b/CPP/Windows/Thread.h
index 1b5863c..d72f64c 100644
--- a/CPP/Windows/Thread.h
+++ b/CPP/Windows/Thread.h
@@ -1,38 +1,44 @@
-// Windows/Thread.h
-
-#ifndef __WINDOWS_THREAD_H
-#define __WINDOWS_THREAD_H
-
-#include "../../C/Threads.h"
-
-#include "Defs.h"
-
-namespace NWindows {
-
-class CThread
-{
- ::CThread thread;
-public:
- CThread() { Thread_Construct(&thread); }
- ~CThread() { Close(); }
- bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
- WRes Close() { return Thread_Close(&thread); }
- WRes Create(THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
- { return Thread_Create(&thread, startAddress, parameter); }
- WRes Wait() { return Thread_Wait(&thread); }
-
- #ifdef _WIN32
- operator HANDLE() { return thread; }
- void Attach(HANDLE handle) { thread = handle; }
- HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
- DWORD Resume() { return ::ResumeThread(thread); }
- DWORD Suspend() { return ::SuspendThread(thread); }
- bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
- int GetPriority() { return ::GetThreadPriority(thread); }
- bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
- #endif
-};
-
-}
-
-#endif
+// Windows/Thread.h
+
+#ifndef ZIP7_INC_WINDOWS_THREAD_H
+#define ZIP7_INC_WINDOWS_THREAD_H
+
+#include "../../C/Threads.h"
+
+#include "Defs.h"
+
+namespace NWindows {
+
+class CThread MY_UNCOPYABLE
+{
+ ::CThread thread;
+public:
+ CThread() { Thread_CONSTRUCT(&thread) }
+ ~CThread() { Close(); }
+ bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
+ WRes Close() { return Thread_Close(&thread); }
+ // WRes Wait() { return Thread_Wait(&thread); }
+ WRes Wait_Close() { return Thread_Wait_Close(&thread); }
+
+ WRes Create(THREAD_FUNC_TYPE startAddress, LPVOID param)
+ { return Thread_Create(&thread, startAddress, param); }
+ WRes Create_With_Affinity(THREAD_FUNC_TYPE startAddress, LPVOID param, CAffinityMask affinity)
+ { return Thread_Create_With_Affinity(&thread, startAddress, param, affinity); }
+ WRes Create_With_CpuSet(THREAD_FUNC_TYPE startAddress, LPVOID param, const CCpuSet *cpuSet)
+ { return Thread_Create_With_CpuSet(&thread, startAddress, param, cpuSet); }
+
+ #ifdef _WIN32
+ operator HANDLE() { return thread; }
+ void Attach(HANDLE handle) { thread = handle; }
+ HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
+ DWORD Resume() { return ::ResumeThread(thread); }
+ DWORD Suspend() { return ::SuspendThread(thread); }
+ bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
+ int GetPriority() { return ::GetThreadPriority(thread); }
+ bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
+ #endif
+};
+
+}
+
+#endif
diff --git a/CPP/Windows/TimeUtils.cpp b/CPP/Windows/TimeUtils.cpp
index 3fc02bc..e80ae13 100644
--- a/CPP/Windows/TimeUtils.cpp
+++ b/CPP/Windows/TimeUtils.cpp
@@ -1,213 +1,404 @@
-// Windows/TimeUtils.cpp
-
-#include "StdAfx.h"
-
-#include "Defs.h"
-#include "TimeUtils.h"
-
-namespace NWindows {
-namespace NTime {
-
-static const UInt32 kNumTimeQuantumsInSecond = 10000000;
-static const UInt32 kFileTimeStartYear = 1601;
-static const UInt32 kDosTimeStartYear = 1980;
-static const UInt32 kUnixTimeStartYear = 1970;
-static const UInt64 kUnixTimeOffset =
- (UInt64)60 * 60 * 24 * (89 + 365 * (kUnixTimeStartYear - kFileTimeStartYear));
-static const UInt64 kNumSecondsInFileTime = (UInt64)(Int64)-1 / kNumTimeQuantumsInSecond;
-
-bool DosTimeToFileTime(UInt32 dosTime, FILETIME &ft) throw()
-{
- #if defined(_WIN32) && !defined(UNDER_CE)
- return BOOLToBool(::DosDateTimeToFileTime((UInt16)(dosTime >> 16), (UInt16)(dosTime & 0xFFFF), &ft));
- #else
- ft.dwLowDateTime = 0;
- ft.dwHighDateTime = 0;
- UInt64 res;
- if (!GetSecondsSince1601(kDosTimeStartYear + (dosTime >> 25), (dosTime >> 21) & 0xF, (dosTime >> 16) & 0x1F,
- (dosTime >> 11) & 0x1F, (dosTime >> 5) & 0x3F, (dosTime & 0x1F) * 2, res))
- return false;
- res *= kNumTimeQuantumsInSecond;
- ft.dwLowDateTime = (UInt32)res;
- ft.dwHighDateTime = (UInt32)(res >> 32);
- return true;
- #endif
-}
-
-static const UInt32 kHighDosTime = 0xFF9FBF7D;
-static const UInt32 kLowDosTime = 0x210000;
-
-#define PERIOD_4 (4 * 365 + 1)
-#define PERIOD_100 (PERIOD_4 * 25 - 1)
-#define PERIOD_400 (PERIOD_100 * 4 + 1)
-
-bool FileTimeToDosTime(const FILETIME &ft, UInt32 &dosTime) throw()
-{
- #if defined(_WIN32) && !defined(UNDER_CE)
-
- WORD datePart, timePart;
- if (!::FileTimeToDosDateTime(&ft, &datePart, &timePart))
- {
- dosTime = (ft.dwHighDateTime >= 0x01C00000) ? kHighDosTime : kLowDosTime;
- return false;
- }
- dosTime = (((UInt32)datePart) << 16) + timePart;
-
- #else
-
- unsigned year, mon, day, hour, min, sec;
- UInt64 v64 = ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
- Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
- unsigned temp;
- UInt32 v;
- v64 += (kNumTimeQuantumsInSecond * 2 - 1);
- v64 /= kNumTimeQuantumsInSecond;
- sec = (unsigned)(v64 % 60);
- v64 /= 60;
- min = (unsigned)(v64 % 60);
- v64 /= 60;
- hour = (unsigned)(v64 % 24);
- v64 /= 24;
-
- v = (UInt32)v64;
-
- year = (unsigned)(kFileTimeStartYear + v / PERIOD_400 * 400);
- v %= PERIOD_400;
-
- temp = (unsigned)(v / PERIOD_100);
- if (temp == 4)
- temp = 3;
- year += temp * 100;
- v -= temp * PERIOD_100;
-
- temp = v / PERIOD_4;
- if (temp == 25)
- temp = 24;
- year += temp * 4;
- v -= temp * PERIOD_4;
-
- temp = v / 365;
- if (temp == 4)
- temp = 3;
- year += temp;
- v -= temp * 365;
-
- if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
- ms[1] = 29;
- for (mon = 1; mon <= 12; mon++)
- {
- unsigned s = ms[mon - 1];
- if (v < s)
- break;
- v -= s;
- }
- day = (unsigned)v + 1;
-
- dosTime = kLowDosTime;
- if (year < kDosTimeStartYear)
- return false;
- year -= kDosTimeStartYear;
- dosTime = kHighDosTime;
- if (year >= 128)
- return false;
- dosTime = (year << 25) | (mon << 21) | (day << 16) | (hour << 11) | (min << 5) | (sec >> 1);
- #endif
- return true;
-}
-
-UInt64 UnixTimeToFileTime64(UInt32 unixTime) throw()
-{
- return (kUnixTimeOffset + (UInt64)unixTime) * kNumTimeQuantumsInSecond;
-}
-
-void UnixTimeToFileTime(UInt32 unixTime, FILETIME &ft) throw()
-{
- UInt64 v = UnixTimeToFileTime64(unixTime);
- ft.dwLowDateTime = (DWORD)v;
- ft.dwHighDateTime = (DWORD)(v >> 32);
-}
-
-UInt64 UnixTime64ToFileTime64(Int64 unixTime) throw()
-{
- return (UInt64)(kUnixTimeOffset + unixTime) * kNumTimeQuantumsInSecond;
-}
-
-bool UnixTime64ToFileTime(Int64 unixTime, FILETIME &ft) throw()
-{
- if (unixTime > (Int64)(kNumSecondsInFileTime - kUnixTimeOffset))
- {
- ft.dwLowDateTime = ft.dwHighDateTime = (UInt32)(Int32)-1;
- return false;
- }
- Int64 v = (Int64)kUnixTimeOffset + unixTime;
- if (v < 0)
- {
- ft.dwLowDateTime = ft.dwHighDateTime = 0;
- return false;
- }
- UInt64 v2 = (UInt64)v * kNumTimeQuantumsInSecond;
- ft.dwLowDateTime = (DWORD)v2;
- ft.dwHighDateTime = (DWORD)(v2 >> 32);
- return true;
-}
-
-Int64 FileTimeToUnixTime64(const FILETIME &ft) throw()
-{
- UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
- return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
-}
-
-bool FileTimeToUnixTime(const FILETIME &ft, UInt32 &unixTime) throw()
-{
- UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
- winTime /= kNumTimeQuantumsInSecond;
- if (winTime < kUnixTimeOffset)
- {
- unixTime = 0;
- return false;
- }
- winTime -= kUnixTimeOffset;
- if (winTime > 0xFFFFFFFF)
- {
- unixTime = 0xFFFFFFFF;
- return false;
- }
- unixTime = (UInt32)winTime;
- return true;
-}
-
-bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
- unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw()
-{
- resSeconds = 0;
- if (year < kFileTimeStartYear || year >= 10000 || month < 1 || month > 12 ||
- day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
- return false;
- UInt32 numYears = year - kFileTimeStartYear;
- UInt32 numDays = numYears * 365 + numYears / 4 - numYears / 100 + numYears / 400;
- Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
- if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
- ms[1] = 29;
- month--;
- for (unsigned i = 0; i < month; i++)
- numDays += ms[i];
- numDays += day - 1;
- resSeconds = ((UInt64)(numDays * 24 + hour) * 60 + min) * 60 + sec;
- return true;
-}
-
-void GetCurUtcFileTime(FILETIME &ft) throw()
-{
- // Both variants provide same low resolution on WinXP: about 15 ms.
- // But GetSystemTimeAsFileTime is much faster.
-
- #ifdef UNDER_CE
- SYSTEMTIME st;
- GetSystemTime(&st);
- SystemTimeToFileTime(&st, &ft);
- #else
- GetSystemTimeAsFileTime(&ft);
- #endif
-}
-
-}}
+// Windows/TimeUtils.cpp
+
+#include "StdAfx.h"
+
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+
+#include "Defs.h"
+#include "TimeUtils.h"
+
+namespace NWindows {
+namespace NTime {
+
+static const UInt32 kNumTimeQuantumsInSecond = 10000000;
+static const UInt32 kFileTimeStartYear = 1601;
+#if !defined(_WIN32) || defined(UNDER_CE)
+static const UInt32 kDosTimeStartYear = 1980;
+#endif
+static const UInt32 kUnixTimeStartYear = 1970;
+static const UInt64 kUnixTimeOffset =
+ (UInt64)60 * 60 * 24 * (89 + 365 * (kUnixTimeStartYear - kFileTimeStartYear));
+static const UInt64 kNumSecondsInFileTime = (UInt64)(Int64)-1 / kNumTimeQuantumsInSecond;
+
+bool DosTime_To_FileTime(UInt32 dosTime, FILETIME &ft) throw()
+{
+ #if defined(_WIN32) && !defined(UNDER_CE)
+ return BOOLToBool(::DosDateTimeToFileTime((UInt16)(dosTime >> 16), (UInt16)(dosTime & 0xFFFF), &ft));
+ #else
+ ft.dwLowDateTime = 0;
+ ft.dwHighDateTime = 0;
+ UInt64 res;
+ if (!GetSecondsSince1601(kDosTimeStartYear + (dosTime >> 25), (dosTime >> 21) & 0xF, (dosTime >> 16) & 0x1F,
+ (dosTime >> 11) & 0x1F, (dosTime >> 5) & 0x3F, (dosTime & 0x1F) * 2, res))
+ return false;
+ res *= kNumTimeQuantumsInSecond;
+ ft.dwLowDateTime = (UInt32)res;
+ ft.dwHighDateTime = (UInt32)(res >> 32);
+ return true;
+ #endif
+}
+
+static const UInt32 kHighDosTime = 0xFF9FBF7D;
+static const UInt32 kLowDosTime = 0x210000;
+
+bool FileTime_To_DosTime(const FILETIME &ft, UInt32 &dosTime) throw()
+{
+ #if defined(_WIN32) && !defined(UNDER_CE)
+
+ WORD datePart, timePart;
+ if (!::FileTimeToDosDateTime(&ft, &datePart, &timePart))
+ {
+ dosTime = (ft.dwHighDateTime >= 0x01C00000) ? kHighDosTime : kLowDosTime;
+ return false;
+ }
+ dosTime = (((UInt32)datePart) << 16) + timePart;
+
+ #else
+
+#define PERIOD_4 (4 * 365 + 1)
+#define PERIOD_100 (PERIOD_4 * 25 - 1)
+#define PERIOD_400 (PERIOD_100 * 4 + 1)
+
+ unsigned year, mon, day, hour, min, sec;
+ UInt64 v64 = ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
+ Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+ unsigned temp;
+ UInt32 v;
+ v64 += (kNumTimeQuantumsInSecond * 2 - 1);
+ v64 /= kNumTimeQuantumsInSecond;
+ sec = (unsigned)(v64 % 60);
+ v64 /= 60;
+ min = (unsigned)(v64 % 60);
+ v64 /= 60;
+ hour = (unsigned)(v64 % 24);
+ v64 /= 24;
+
+ v = (UInt32)v64;
+
+ year = (unsigned)(kFileTimeStartYear + v / PERIOD_400 * 400);
+ v %= PERIOD_400;
+
+ temp = (unsigned)(v / PERIOD_100);
+ if (temp == 4)
+ temp = 3;
+ year += temp * 100;
+ v -= temp * PERIOD_100;
+
+ temp = v / PERIOD_4;
+ if (temp == 25)
+ temp = 24;
+ year += temp * 4;
+ v -= temp * PERIOD_4;
+
+ temp = v / 365;
+ if (temp == 4)
+ temp = 3;
+ year += temp;
+ v -= temp * 365;
+
+ if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
+ ms[1] = 29;
+ for (mon = 1; mon <= 12; mon++)
+ {
+ unsigned s = ms[mon - 1];
+ if (v < s)
+ break;
+ v -= s;
+ }
+ day = (unsigned)v + 1;
+
+ dosTime = kLowDosTime;
+ if (year < kDosTimeStartYear)
+ return false;
+ year -= kDosTimeStartYear;
+ dosTime = kHighDosTime;
+ if (year >= 128)
+ return false;
+ dosTime = (year << 25) | (mon << 21) | (day << 16) | (hour << 11) | (min << 5) | (sec >> 1);
+ #endif
+ return true;
+}
+
+
+bool UtcFileTime_To_LocalDosTime(const FILETIME &utc, UInt32 &dosTime) throw()
+{
+ FILETIME loc = { 0, 0 };
+ const UInt64 u1 = FILETIME_To_UInt64(utc);
+ const UInt64 kDelta = ((UInt64)1 << 41); // it's larger than quantums in 1 sec.
+ if (u1 >= kDelta)
+ {
+ if (!FileTimeToLocalFileTime(&utc, &loc))
+ loc = utc;
+ else
+ {
+ const UInt64 u2 = FILETIME_To_UInt64(loc);
+ const UInt64 delta = u1 < u2 ? (u2 - u1) : (u1 - u2);
+ if (delta > kDelta) // if FileTimeToLocalFileTime() overflow, we use UTC time
+ loc = utc;
+ }
+ }
+ return FileTime_To_DosTime(loc, dosTime);
+}
+
+UInt64 UnixTime_To_FileTime64(UInt32 unixTime) throw()
+{
+ return (kUnixTimeOffset + (UInt64)unixTime) * kNumTimeQuantumsInSecond;
+}
+
+void UnixTime_To_FileTime(UInt32 unixTime, FILETIME &ft) throw()
+{
+ const UInt64 v = UnixTime_To_FileTime64(unixTime);
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+UInt64 UnixTime64_To_FileTime64(Int64 unixTime) throw()
+{
+ return (UInt64)((Int64)kUnixTimeOffset + unixTime) * kNumTimeQuantumsInSecond;
+}
+
+
+bool UnixTime64_To_FileTime64(Int64 unixTime, UInt64 &fileTime) throw()
+{
+ if (unixTime > (Int64)(kNumSecondsInFileTime - kUnixTimeOffset))
+ {
+ fileTime = (UInt64)(Int64)-1;
+ return false;
+ }
+ if (unixTime < -(Int64)kUnixTimeOffset)
+ {
+ fileTime = 0;
+ return false;
+ }
+ fileTime = UnixTime64_To_FileTime64(unixTime);
+ return true;
+}
+
+
+bool UnixTime64_To_FileTime(Int64 unixTime, FILETIME &ft) throw()
+{
+ UInt64 v;
+ const bool res = UnixTime64_To_FileTime64(unixTime, v);
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+ return res;
+}
+
+
+Int64 FileTime_To_UnixTime64(const FILETIME &ft) throw()
+{
+ const UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
+ return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
+}
+
+Int64 FileTime_To_UnixTime64_and_Quantums(const FILETIME &ft, UInt32 &quantums) throw()
+{
+ const UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
+ quantums = (UInt32)(winTime % kNumTimeQuantumsInSecond);
+ return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
+}
+
+bool FileTime_To_UnixTime(const FILETIME &ft, UInt32 &unixTime) throw()
+{
+ UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
+ winTime /= kNumTimeQuantumsInSecond;
+ if (winTime < kUnixTimeOffset)
+ {
+ unixTime = 0;
+ return false;
+ }
+ winTime -= kUnixTimeOffset;
+ if (winTime > (UInt32)0xFFFFFFFF)
+ {
+ unixTime = (UInt32)0xFFFFFFFF;
+ return false;
+ }
+ unixTime = (UInt32)winTime;
+ return true;
+}
+
+bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
+ unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw()
+{
+ resSeconds = 0;
+ if (year < kFileTimeStartYear || year >= 10000 || month < 1 || month > 12 ||
+ day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
+ return false;
+ UInt32 numYears = year - kFileTimeStartYear;
+ UInt32 numDays = numYears * 365 + numYears / 4 - numYears / 100 + numYears / 400;
+ Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+ if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
+ ms[1] = 29;
+ month--;
+ for (unsigned i = 0; i < month; i++)
+ numDays += ms[i];
+ numDays += day - 1;
+ resSeconds = ((UInt64)(numDays * 24 + hour) * 60 + min) * 60 + sec;
+ return true;
+}
+
+
+void GetCurUtc_FiTime(CFiTime &ft) throw()
+{
+ #ifdef _WIN32
+
+ // Both variants provide same low resolution on WinXP: about 15 ms.
+ // But GetSystemTimeAsFileTime is much faster.
+ #ifdef UNDER_CE
+ SYSTEMTIME st;
+ GetSystemTime(&st);
+ SystemTimeToFileTime(&st, &ft);
+ #else
+ GetSystemTimeAsFileTime(&ft);
+ #endif
+
+ #else
+
+ FiTime_Clear(ft);
+ struct timeval now;
+ if (gettimeofday(&now, NULL) == 0)
+ {
+ ft.tv_sec = now.tv_sec;
+ ft.tv_nsec = now.tv_usec * 1000;
+ }
+
+ #endif
+}
+
+#ifndef _WIN32
+void GetCurUtcFileTime(FILETIME &ft) throw()
+{
+ UInt64 v = 0;
+ struct timeval now;
+ if (gettimeofday(&now, NULL) == 0)
+ {
+ v = ((UInt64)now.tv_sec + kUnixTimeOffset) *
+ kNumTimeQuantumsInSecond + (UInt64)now.tv_usec * 10;
+ }
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+#endif
+
+
+}}
+
+
+#ifdef _WIN32
+
+/*
+void FiTime_Normalize_With_Prec(CFiTime &ft, unsigned prec)
+{
+ if (prec == k_PropVar_TimePrec_0
+ || prec == k_PropVar_TimePrec_HighPrec
+ || prec >= k_PropVar_TimePrec_100ns)
+ return;
+ UInt64 v = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
+
+ int numDigits = (int)prec - (int)k_PropVar_TimePrec_Base;
+ UInt32 d;
+ if (prec == k_PropVar_TimePrec_DOS)
+ {
+ // we round up as windows DosDateTimeToFileTime()
+ v += NWindows::NTime::kNumTimeQuantumsInSecond * 2 - 1;
+ d = NWindows::NTime::kNumTimeQuantumsInSecond * 2;
+ }
+ else
+ {
+ if (prec == k_PropVar_TimePrec_Unix)
+ numDigits = 0;
+ else if (numDigits < 0)
+ return;
+ d = 1;
+ for (unsigned k = numDigits; k < 7; k++)
+ d *= 10;
+ }
+ v /= d;
+ v *= d;
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+*/
+
+#else
+
+/*
+void FiTime_Normalize_With_Prec(CFiTime &ft, unsigned prec)
+{
+ if (prec >= k_PropVar_TimePrec_1ns
+ || prec == k_PropVar_TimePrec_HighPrec)
+ return;
+
+ int numDigits = (int)prec - (int)k_PropVar_TimePrec_Base;
+ UInt32 d;
+ if (prec == k_PropVar_TimePrec_Unix ||
+ prec == (int)k_PropVar_TimePrec_Base)
+ {
+ ft.tv_nsec = 0;
+ return;
+ }
+ if (prec == k_PropVar_TimePrec_DOS)
+ {
+ // we round up as windows DosDateTimeToFileTime()
+ const unsigned sec1 = (ft.tv_sec & 1);
+ if (ft.tv_nsec == 0 && sec1 == 0)
+ return;
+ ft.tv_nsec = 0;
+ ft.tv_sec += 2 - sec1;
+ return;
+ }
+ {
+ if (prec == k_PropVar_TimePrec_0
+ || numDigits < 0)
+ numDigits = 7;
+ d = 1;
+ for (unsigned k = numDigits; k < 9; k++)
+ d *= 10;
+ ft.tv_nsec /= d;
+ ft.tv_nsec *= d;
+ }
+}
+*/
+
+int Compare_FiTime(const CFiTime *a1, const CFiTime *a2)
+{
+ if (a1->tv_sec < a2->tv_sec) return -1;
+ if (a1->tv_sec > a2->tv_sec) return 1;
+ if (a1->tv_nsec < a2->tv_nsec) return -1;
+ if (a1->tv_nsec > a2->tv_nsec) return 1;
+ return 0;
+}
+
+bool FILETIME_To_timespec(const FILETIME &ft, timespec &ts)
+{
+ UInt32 quantums;
+ const Int64 sec = NWindows::NTime::FileTime_To_UnixTime64_and_Quantums(ft, quantums);
+ // time_t is long
+ const time_t sec2 = (time_t)sec;
+ if (sec2 == sec)
+ {
+ ts.tv_sec = sec2;
+ ts.tv_nsec = (long)(quantums * 100);
+ return true;
+ }
+ return false;
+}
+
+void FiTime_To_FILETIME_ns100(const CFiTime &ts, FILETIME &ft, unsigned &ns100)
+{
+ const UInt64 v = NWindows::NTime::UnixTime64_To_FileTime64(ts.tv_sec) + ((UInt64)ts.tv_nsec / 100);
+ ns100 = (unsigned)((UInt64)ts.tv_nsec % 100);
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+void FiTime_To_FILETIME(const CFiTime &ts, FILETIME &ft)
+{
+ const UInt64 v = NWindows::NTime::UnixTime64_To_FileTime64(ts.tv_sec) + ((UInt64)ts.tv_nsec / 100);
+ ft.dwLowDateTime = (DWORD)v;
+ ft.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+#endif
diff --git a/CPP/Windows/TimeUtils.h b/CPP/Windows/TimeUtils.h
index b0092f8..4a9d0f2 100644
--- a/CPP/Windows/TimeUtils.h
+++ b/CPP/Windows/TimeUtils.h
@@ -1,32 +1,146 @@
-// Windows/TimeUtils.h
-
-#ifndef __WINDOWS_TIME_UTILS_H
-#define __WINDOWS_TIME_UTILS_H
-
-#include "../Common/MyTypes.h"
-#include "../Common/MyWindows.h"
-
-namespace NWindows {
-namespace NTime {
-
-bool DosTimeToFileTime(UInt32 dosTime, FILETIME &fileTime) throw();
-bool FileTimeToDosTime(const FILETIME &fileTime, UInt32 &dosTime) throw();
-
-// UInt32 Unix Time : for dates 1970-2106
-UInt64 UnixTimeToFileTime64(UInt32 unixTime) throw();
-void UnixTimeToFileTime(UInt32 unixTime, FILETIME &fileTime) throw();
-
-// Int64 Unix Time : negative values for dates before 1970
-UInt64 UnixTime64ToFileTime64(Int64 unixTime) throw();
-bool UnixTime64ToFileTime(Int64 unixTime, FILETIME &fileTime) throw();
-
-bool FileTimeToUnixTime(const FILETIME &fileTime, UInt32 &unixTime) throw();
-Int64 FileTimeToUnixTime64(const FILETIME &ft) throw();
-
-bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
- unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw();
-void GetCurUtcFileTime(FILETIME &ft) throw();
-
-}}
-
-#endif
+// Windows/TimeUtils.h
+
+#ifndef ZIP7_INC_WINDOWS_TIME_UTILS_H
+#define ZIP7_INC_WINDOWS_TIME_UTILS_H
+
+#include "../Common/MyTypes.h"
+#include "../Common/MyWindows.h"
+#include "PropVariant.h"
+
+inline UInt64 FILETIME_To_UInt64(const FILETIME &ft)
+{
+ return (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
+}
+
+inline void FILETIME_Clear(FILETIME &ft)
+{
+ ft.dwLowDateTime = 0;
+ ft.dwHighDateTime = 0;
+}
+
+inline bool FILETIME_IsZero(const FILETIME &ft)
+{
+ return (ft.dwHighDateTime == 0 && ft.dwLowDateTime == 0);
+}
+
+
+#ifdef _WIN32
+ #define CFiTime FILETIME
+ #define Compare_FiTime ::CompareFileTime
+ inline void FiTime_To_FILETIME(const CFiTime &ts, FILETIME &ft)
+ {
+ ft = ts;
+ }
+ /*
+ inline void FILETIME_To_FiTime(const FILETIME &ft, CFiTime &ts)
+ {
+ ts = ft;
+ }
+ */
+ inline void FiTime_Clear(CFiTime &ft)
+ {
+ ft.dwLowDateTime = 0;
+ ft.dwHighDateTime = 0;
+ }
+#else
+
+ #include <sys/stat.h>
+
+ #if defined(_AIX)
+ #define CFiTime st_timespec
+ #else
+ #define CFiTime timespec
+ #endif
+ int Compare_FiTime(const CFiTime *a1, const CFiTime *a2);
+ bool FILETIME_To_timespec(const FILETIME &ft, CFiTime &ts);
+ void FiTime_To_FILETIME(const CFiTime &ts, FILETIME &ft);
+ void FiTime_To_FILETIME_ns100(const CFiTime &ts, FILETIME &ft, unsigned &ns100);
+ inline void FiTime_Clear(CFiTime &ft)
+ {
+ ft.tv_sec = 0;
+ ft.tv_nsec = 0;
+ }
+
+ #ifdef __APPLE__
+ #define ST_MTIME(st) st.st_mtimespec
+ #define ST_ATIME(st) st.st_atimespec
+ #define ST_CTIME(st) st.st_ctimespec
+ #else
+ #define ST_MTIME(st) st.st_mtim
+ #define ST_ATIME(st) st.st_atim
+ #define ST_CTIME(st) st.st_ctim
+ #endif
+
+#endif
+
+// void FiTime_Normalize_With_Prec(CFiTime &ft, unsigned prec);
+
+namespace NWindows {
+namespace NTime {
+
+bool DosTime_To_FileTime(UInt32 dosTime, FILETIME &fileTime) throw();
+bool UtcFileTime_To_LocalDosTime(const FILETIME &utc, UInt32 &dosTime) throw();
+bool FileTime_To_DosTime(const FILETIME &fileTime, UInt32 &dosTime) throw();
+
+// UInt32 Unix Time : for dates 1970-2106
+UInt64 UnixTime_To_FileTime64(UInt32 unixTime) throw();
+void UnixTime_To_FileTime(UInt32 unixTime, FILETIME &fileTime) throw();
+
+// Int64 Unix Time : negative values for dates before 1970
+UInt64 UnixTime64_To_FileTime64(Int64 unixTime) throw(); // no check
+bool UnixTime64_To_FileTime64(Int64 unixTime, UInt64 &fileTime) throw();
+bool UnixTime64_To_FileTime(Int64 unixTime, FILETIME &fileTime) throw();
+
+Int64 FileTime64_To_UnixTime64(UInt64 ft64) throw();
+bool FileTime_To_UnixTime(const FILETIME &fileTime, UInt32 &unixTime) throw();
+Int64 FileTime_To_UnixTime64(const FILETIME &ft) throw();
+Int64 FileTime_To_UnixTime64_and_Quantums(const FILETIME &ft, UInt32 &quantums) throw();
+
+bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
+ unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw();
+
+void GetCurUtc_FiTime(CFiTime &ft) throw();
+#ifdef _WIN32
+#define GetCurUtcFileTime GetCurUtc_FiTime
+#else
+void GetCurUtcFileTime(FILETIME &ft) throw();
+#endif
+
+}}
+
+inline void PropVariant_SetFrom_UnixTime(NWindows::NCOM::CPropVariant &prop, UInt32 unixTime)
+{
+ FILETIME ft;
+ NWindows::NTime::UnixTime_To_FileTime(unixTime, ft);
+ prop.SetAsTimeFrom_FT_Prec(ft, k_PropVar_TimePrec_Unix);
+}
+
+inline void PropVariant_SetFrom_NtfsTime(NWindows::NCOM::CPropVariant &prop, const FILETIME &ft)
+{
+ prop.SetAsTimeFrom_FT_Prec(ft, k_PropVar_TimePrec_100ns);
+}
+
+inline void PropVariant_SetFrom_FiTime(NWindows::NCOM::CPropVariant &prop, const CFiTime &fts)
+{
+ #ifdef _WIN32
+ PropVariant_SetFrom_NtfsTime(prop, fts);
+ #else
+ unsigned ns100;
+ FILETIME ft;
+ FiTime_To_FILETIME_ns100(fts, ft, ns100);
+ prop.SetAsTimeFrom_FT_Prec_Ns100(ft, k_PropVar_TimePrec_1ns, ns100);
+ #endif
+}
+
+inline bool PropVariant_SetFrom_DosTime(NWindows::NCOM::CPropVariant &prop, UInt32 dosTime)
+{
+ FILETIME localFileTime, utc;
+ if (!NWindows::NTime::DosTime_To_FileTime(dosTime, localFileTime))
+ return false;
+ if (!LocalFileTimeToFileTime(&localFileTime, &utc))
+ return false;
+ prop.SetAsTimeFrom_FT_Prec(utc, k_PropVar_TimePrec_DOS);
+ return true;
+}
+
+#endif
diff --git a/CPP/Windows/Window.cpp b/CPP/Windows/Window.cpp
index 0c74222..102c503 100644
--- a/CPP/Windows/Window.cpp
+++ b/CPP/Windows/Window.cpp
@@ -1,179 +1,179 @@
-// Windows/Window.cpp
-
-#include "StdAfx.h"
-
-#ifndef _UNICODE
-#include "../Common/StringConvert.h"
-#endif
-#include "Window.h"
-
-#ifndef _UNICODE
-extern bool g_IsNT;
-#endif
-
-namespace NWindows {
-
-#ifndef _UNICODE
-ATOM MyRegisterClass(CONST WNDCLASSW *wndClass)
-{
- if (g_IsNT)
- return RegisterClassW(wndClass);
- WNDCLASSA wndClassA;
- wndClassA.style = wndClass->style;
- wndClassA.lpfnWndProc = wndClass->lpfnWndProc;
- wndClassA.cbClsExtra = wndClass->cbClsExtra;
- wndClassA.cbWndExtra = wndClass->cbWndExtra;
- wndClassA.hInstance = wndClass->hInstance;
- wndClassA.hIcon = wndClass->hIcon;
- wndClassA.hCursor = wndClass->hCursor;
- wndClassA.hbrBackground = wndClass->hbrBackground;
- AString menuName;
- AString className;
- if (IS_INTRESOURCE(wndClass->lpszMenuName))
- wndClassA.lpszMenuName = (LPCSTR)wndClass->lpszMenuName;
- else
- {
- menuName = GetSystemString(wndClass->lpszMenuName);
- wndClassA.lpszMenuName = menuName;
- }
- if (IS_INTRESOURCE(wndClass->lpszClassName))
- wndClassA.lpszClassName = (LPCSTR)wndClass->lpszClassName;
- else
- {
- className = GetSystemString(wndClass->lpszClassName);
- wndClassA.lpszClassName = className;
- }
- return RegisterClassA(&wndClassA);
-}
-
-bool CWindow::Create(LPCWSTR className,
- LPCWSTR windowName, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam)
-{
- if (g_IsNT)
- {
- _window = ::CreateWindowW(className, windowName,
- style, x, y, width, height, parentWindow,
- idOrHMenu, instance, createParam);
- return (_window != NULL);
- }
- return Create(GetSystemString(className), GetSystemString(windowName),
- style, x, y, width, height, parentWindow,
- idOrHMenu, instance, createParam);
-}
-
-bool CWindow::CreateEx(DWORD exStyle, LPCWSTR className,
- LPCWSTR windowName, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam)
-{
- if (g_IsNT)
- {
- _window = ::CreateWindowExW(exStyle, className, windowName,
- style, x, y, width, height, parentWindow,
- idOrHMenu, instance, createParam);
- return (_window != NULL);
- }
- AString classNameA;
- LPCSTR classNameP;
- if (IS_INTRESOURCE(className))
- classNameP = (LPCSTR)className;
- else
- {
- classNameA = GetSystemString(className);
- classNameP = classNameA;
- }
- AString windowNameA;
- LPCSTR windowNameP;
- if (IS_INTRESOURCE(windowName))
- windowNameP = (LPCSTR)windowName;
- else
- {
- windowNameA = GetSystemString(windowName);
- windowNameP = windowNameA;
- }
- return CreateEx(exStyle, classNameP, windowNameP,
- style, x, y, width, height, parentWindow,
- idOrHMenu, instance, createParam);
-}
-
-#endif
-
-#ifndef _UNICODE
-bool MySetWindowText(HWND wnd, LPCWSTR s)
-{
- if (g_IsNT)
- return BOOLToBool(::SetWindowTextW(wnd, s));
- return BOOLToBool(::SetWindowTextA(wnd, UnicodeStringToMultiByte(s)));
-}
-#endif
-
-bool CWindow::GetText(CSysString &s)
-{
- s.Empty();
- int len = GetTextLength();
- if (len == 0)
- return (::GetLastError() == ERROR_SUCCESS);
- TCHAR *p = s.GetBuf(len);
- {
- int len2 = GetText(p, len + 1);
- if (len > len2)
- len = len2;
- }
- s.ReleaseBuf_CalcLen(len);
- if (len == 0)
- return (::GetLastError() == ERROR_SUCCESS);
- return true;
-}
-
-#ifndef _UNICODE
-bool CWindow::GetText(UString &s)
-{
- if (g_IsNT)
- {
- s.Empty();
- int len = GetWindowTextLengthW(_window);
- if (len == 0)
- return (::GetLastError() == ERROR_SUCCESS);
- wchar_t *p = s.GetBuf(len);
- {
- int len2 = GetWindowTextW(_window, p, len + 1);
- if (len > len2)
- len = len2;
- }
- s.ReleaseBuf_CalcLen(len);
- if (len == 0)
- return (::GetLastError() == ERROR_SUCCESS);
- return true;
- }
- CSysString sysString;
- bool result = GetText(sysString);
- MultiByteToUnicodeString2(s, sysString);
- return result;
-}
-#endif
-
-
-/*
-bool CWindow::ModifyStyleBase(int styleOffset,
- DWORD remove, DWORD add, UINT flags)
-{
- DWORD style = GetWindowLong(styleOffset);
- DWORD newStyle = (style & ~remove) | add;
- if (style == newStyle)
- return false; // it is not good
-
- SetWindowLong(styleOffset, newStyle);
- if (flags != 0)
- {
- ::SetWindowPos(_window, NULL, 0, 0, 0, 0,
- SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | flags);
- }
- return TRUE;
-}
-*/
-
-}
+// Windows/Window.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+#include "Window.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+#ifndef _UNICODE
+ATOM MyRegisterClass(CONST WNDCLASSW *wndClass)
+{
+ if (g_IsNT)
+ return RegisterClassW(wndClass);
+ WNDCLASSA wndClassA;
+ wndClassA.style = wndClass->style;
+ wndClassA.lpfnWndProc = wndClass->lpfnWndProc;
+ wndClassA.cbClsExtra = wndClass->cbClsExtra;
+ wndClassA.cbWndExtra = wndClass->cbWndExtra;
+ wndClassA.hInstance = wndClass->hInstance;
+ wndClassA.hIcon = wndClass->hIcon;
+ wndClassA.hCursor = wndClass->hCursor;
+ wndClassA.hbrBackground = wndClass->hbrBackground;
+ AString menuName;
+ AString className;
+ if (IS_INTRESOURCE(wndClass->lpszMenuName))
+ wndClassA.lpszMenuName = (LPCSTR)wndClass->lpszMenuName;
+ else
+ {
+ menuName = GetSystemString(wndClass->lpszMenuName);
+ wndClassA.lpszMenuName = menuName;
+ }
+ if (IS_INTRESOURCE(wndClass->lpszClassName))
+ wndClassA.lpszClassName = (LPCSTR)wndClass->lpszClassName;
+ else
+ {
+ className = GetSystemString(wndClass->lpszClassName);
+ wndClassA.lpszClassName = className;
+ }
+ return RegisterClassA(&wndClassA);
+}
+
+bool CWindow::Create(LPCWSTR className,
+ LPCWSTR windowName, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam)
+{
+ if (g_IsNT)
+ {
+ _window = ::CreateWindowW(className, windowName,
+ style, x, y, width, height, parentWindow,
+ idOrHMenu, instance, createParam);
+ return (_window != NULL);
+ }
+ return Create(GetSystemString(className), GetSystemString(windowName),
+ style, x, y, width, height, parentWindow,
+ idOrHMenu, instance, createParam);
+}
+
+bool CWindow::CreateEx(DWORD exStyle, LPCWSTR className,
+ LPCWSTR windowName, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam)
+{
+ if (g_IsNT)
+ {
+ _window = ::CreateWindowExW(exStyle, className, windowName,
+ style, x, y, width, height, parentWindow,
+ idOrHMenu, instance, createParam);
+ return (_window != NULL);
+ }
+ AString classNameA;
+ LPCSTR classNameP;
+ if (IS_INTRESOURCE(className))
+ classNameP = (LPCSTR)className;
+ else
+ {
+ classNameA = GetSystemString(className);
+ classNameP = classNameA;
+ }
+ AString windowNameA;
+ LPCSTR windowNameP;
+ if (IS_INTRESOURCE(windowName))
+ windowNameP = (LPCSTR)windowName;
+ else
+ {
+ windowNameA = GetSystemString(windowName);
+ windowNameP = windowNameA;
+ }
+ return CreateEx(exStyle, classNameP, windowNameP,
+ style, x, y, width, height, parentWindow,
+ idOrHMenu, instance, createParam);
+}
+
+#endif
+
+#ifndef _UNICODE
+bool MySetWindowText(HWND wnd, LPCWSTR s)
+{
+ if (g_IsNT)
+ return BOOLToBool(::SetWindowTextW(wnd, s));
+ return BOOLToBool(::SetWindowTextA(wnd, UnicodeStringToMultiByte(s)));
+}
+#endif
+
+bool CWindow::GetText(CSysString &s) const
+{
+ s.Empty();
+ unsigned len = (unsigned)GetTextLength();
+ if (len == 0)
+ return (::GetLastError() == ERROR_SUCCESS);
+ TCHAR *p = s.GetBuf(len);
+ {
+ const unsigned len2 = (unsigned)GetText(p, (int)(len + 1));
+ if (len > len2)
+ len = len2;
+ }
+ s.ReleaseBuf_CalcLen(len);
+ if (len == 0)
+ return (::GetLastError() == ERROR_SUCCESS);
+ return true;
+}
+
+#ifndef _UNICODE
+bool CWindow::GetText(UString &s) const
+{
+ if (g_IsNT)
+ {
+ s.Empty();
+ unsigned len = (unsigned)GetWindowTextLengthW(_window);
+ if (len == 0)
+ return (::GetLastError() == ERROR_SUCCESS);
+ wchar_t *p = s.GetBuf(len);
+ {
+ const unsigned len2 = (unsigned)GetWindowTextW(_window, p, (int)(len + 1));
+ if (len > len2)
+ len = len2;
+ }
+ s.ReleaseBuf_CalcLen(len);
+ if (len == 0)
+ return (::GetLastError() == ERROR_SUCCESS);
+ return true;
+ }
+ CSysString sysString;
+ const bool result = GetText(sysString);
+ MultiByteToUnicodeString2(s, sysString);
+ return result;
+}
+#endif
+
+
+/*
+bool CWindow::ModifyStyleBase(int styleOffset,
+ DWORD remove, DWORD add, UINT flags)
+{
+ DWORD style = GetWindowLong(styleOffset);
+ DWORD newStyle = (style & ~remove) | add;
+ if (style == newStyle)
+ return false; // it is not good
+
+ SetWindowLong(styleOffset, newStyle);
+ if (flags != 0)
+ {
+ ::SetWindowPos(_window, NULL, 0, 0, 0, 0,
+ SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | flags);
+ }
+ return TRUE;
+}
+*/
+
+}
diff --git a/CPP/Windows/Window.h b/CPP/Windows/Window.h
index 4c80a5b..a99143b 100644
--- a/CPP/Windows/Window.h
+++ b/CPP/Windows/Window.h
@@ -1,284 +1,363 @@
-// Windows/Window.h
-
-#ifndef __WINDOWS_WINDOW_H
-#define __WINDOWS_WINDOW_H
-
-#include "../Common/MyWindows.h"
-#include "../Common/MyString.h"
-
-#include "Defs.h"
-
-#ifndef UNDER_CE
-
-#define MY__WM_CHANGEUISTATE 0x0127
-#define MY__WM_UPDATEUISTATE 0x0128
-#define MY__WM_QUERYUISTATE 0x0129
-
-// LOWORD(wParam) values in WM_*UISTATE
-#define MY__UIS_SET 1
-#define MY__UIS_CLEAR 2
-#define MY__UIS_INITIALIZE 3
-
-// HIWORD(wParam) values in WM_*UISTATE
-#define MY__UISF_HIDEFOCUS 0x1
-#define MY__UISF_HIDEACCEL 0x2
-#define MY__UISF_ACTIVE 0x4
-
-#endif
-
-namespace NWindows {
-
-inline ATOM MyRegisterClass(CONST WNDCLASS *wndClass)
- { return ::RegisterClass(wndClass); }
-
-#ifndef _UNICODE
-ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
-#endif
-
-#ifdef _UNICODE
-inline bool MySetWindowText(HWND wnd, LPCWSTR s) { return BOOLToBool(::SetWindowText(wnd, s)); }
-#else
-bool MySetWindowText(HWND wnd, LPCWSTR s);
-#endif
-
-
-#ifdef UNDER_CE
-#define GWLP_USERDATA GWL_USERDATA
-#define GWLP_WNDPROC GWL_WNDPROC
-#define BTNS_BUTTON TBSTYLE_BUTTON
-#define WC_COMBOBOXW L"ComboBox"
-#define DWLP_MSGRESULT DWL_MSGRESULT
-#endif
-
-class CWindow
-{
-private:
- // bool ModifyStyleBase(int styleOffset, DWORD remove, DWORD add, UINT flags);
-protected:
- HWND _window;
-public:
- CWindow(HWND newWindow = NULL): _window(newWindow){};
- CWindow& operator=(HWND newWindow)
- {
- _window = newWindow;
- return *this;
- }
- operator HWND() const { return _window; }
- void Attach(HWND newWindow) { _window = newWindow; }
- HWND Detach()
- {
- HWND window = _window;
- _window = NULL;
- return window;
- }
-
- bool Foreground() { return BOOLToBool(::SetForegroundWindow(_window)); }
-
- HWND GetParent() const { return ::GetParent(_window); }
- bool GetWindowRect(LPRECT rect) const { return BOOLToBool(::GetWindowRect(_window,rect)); }
- #ifndef UNDER_CE
- bool IsZoomed() const { return BOOLToBool(::IsZoomed(_window)); }
- #endif
- bool ClientToScreen(LPPOINT point) const { return BOOLToBool(::ClientToScreen(_window, point)); }
- bool ScreenToClient(LPPOINT point) const { return BOOLToBool(::ScreenToClient(_window, point)); }
-
- bool CreateEx(DWORD exStyle, LPCTSTR className,
- LPCTSTR windowName, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam)
- {
- _window = ::CreateWindowEx(exStyle, className, windowName,
- style, x, y, width, height, parentWindow,
- idOrHMenu, instance, createParam);
- return (_window != NULL);
- }
-
- bool Create(LPCTSTR className,
- LPCTSTR windowName, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam)
- {
- _window = ::CreateWindow(className, windowName,
- style, x, y, width, height, parentWindow,
- idOrHMenu, instance, createParam);
- return (_window != NULL);
- }
-
- #ifndef _UNICODE
- bool Create(LPCWSTR className,
- LPCWSTR windowName, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam);
- bool CreateEx(DWORD exStyle, LPCWSTR className,
- LPCWSTR windowName, DWORD style,
- int x, int y, int width, int height,
- HWND parentWindow, HMENU idOrHMenu,
- HINSTANCE instance, LPVOID createParam);
- #endif
-
-
- bool Destroy()
- {
- if (_window == NULL)
- return true;
- bool result = BOOLToBool(::DestroyWindow(_window));
- if (result)
- _window = NULL;
- return result;
- }
- bool IsWindow() { return BOOLToBool(::IsWindow(_window)); }
- bool Move(int x, int y, int width, int height, bool repaint = true)
- { return BOOLToBool(::MoveWindow(_window, x, y, width, height, BoolToBOOL(repaint))); }
-
- bool ChangeSubWindowSizeX(HWND hwnd, int xSize)
- {
- RECT rect;
- ::GetWindowRect(hwnd, &rect);
- POINT p1;
- p1.x = rect.left;
- p1.y = rect.top;
- ScreenToClient(&p1);
- return BOOLToBool(::MoveWindow(hwnd, p1.x, p1.y, xSize, rect.bottom - rect.top, TRUE));
- }
-
- void ScreenToClient(RECT *rect)
- {
- POINT p1, p2;
- p1.x = rect->left;
- p1.y = rect->top;
- p2.x = rect->right;
- p2.y = rect->bottom;
- ScreenToClient(&p1);
- ScreenToClient(&p2);
-
- rect->left = p1.x;
- rect->top = p1.y;
- rect->right = p2.x;
- rect->bottom = p2.y;
- }
-
- bool GetClientRect(LPRECT rect) { return BOOLToBool(::GetClientRect(_window, rect)); }
- bool Show(int cmdShow) { return BOOLToBool(::ShowWindow(_window, cmdShow)); }
- bool Show_Bool(bool show) { return Show(show ? SW_SHOW: SW_HIDE); }
-
- #ifndef UNDER_CE
- bool SetPlacement(CONST WINDOWPLACEMENT *placement) { return BOOLToBool(::SetWindowPlacement(_window, placement)); }
- bool GetPlacement(WINDOWPLACEMENT *placement) { return BOOLToBool(::GetWindowPlacement(_window, placement)); }
- #endif
- bool Update() { return BOOLToBool(::UpdateWindow(_window)); }
- bool InvalidateRect(LPCRECT rect, bool backgroundErase = true)
- { return BOOLToBool(::InvalidateRect(_window, rect, BoolToBOOL(backgroundErase))); }
- void SetRedraw(bool redraw = true) { SendMsg(WM_SETREDRAW, BoolToBOOL(redraw), 0); }
-
- LONG_PTR SetStyle(LONG_PTR style) { return SetLongPtr(GWL_STYLE, style); }
- LONG_PTR GetStyle() const { return GetLongPtr(GWL_STYLE); }
- // bool MyIsMaximized() const { return ((GetStyle() & WS_MAXIMIZE) != 0); }
-
- LONG_PTR SetLong(int index, LONG newLongPtr) { return ::SetWindowLong(_window, index, newLongPtr); }
- LONG_PTR GetLong(int index) const { return ::GetWindowLong(_window, index); }
- LONG_PTR SetUserDataLong(LONG newLongPtr) { return SetLong(GWLP_USERDATA, newLongPtr); }
- LONG_PTR GetUserDataLong() const { return GetLong(GWLP_USERDATA); }
-
-
- #ifdef UNDER_CE
-
- LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr) { return SetLong(index, newLongPtr); }
- LONG_PTR GetLongPtr(int index) const { return GetLong(index); }
-
- LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetUserDataLong(newLongPtr); }
- LONG_PTR GetUserDataLongPtr() const { return GetUserDataLong(); }
-
- #else
-
- LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr)
- { return ::SetWindowLongPtr(_window, index,
- #ifndef _WIN64
- (LONG)
- #endif
- newLongPtr); }
- #ifndef _UNICODE
- LONG_PTR SetLongPtrW(int index, LONG_PTR newLongPtr)
- { return ::SetWindowLongPtrW(_window, index,
- #ifndef _WIN64
- (LONG)
- #endif
- newLongPtr); }
- #endif
-
- LONG_PTR GetLongPtr(int index) const { return ::GetWindowLongPtr(_window, index); }
- LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetLongPtr(GWLP_USERDATA, newLongPtr); }
- LONG_PTR GetUserDataLongPtr() const { return GetLongPtr(GWLP_USERDATA); }
-
- #endif
-
- /*
- bool ModifyStyle(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
- { return ModifyStyleBase(GWL_STYLE, remove, add, flags); }
- bool ModifyStyleEx(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
- { return ModifyStyleBase(GWL_EXSTYLE, remove, add, flags); }
- */
-
- HWND SetFocus() { return ::SetFocus(_window); }
-
- LRESULT SendMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
- { return ::SendMessage(_window, message, wParam, lParam); }
- #ifndef _UNICODE
- LRESULT SendMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
- { return ::SendMessageW(_window, message, wParam, lParam); }
- #endif
-
- bool PostMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
- { return BOOLToBool(::PostMessage(_window, message, wParam, lParam)); }
- #ifndef _UNICODE
- bool PostMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
- { return BOOLToBool(::PostMessageW(_window, message, wParam, lParam)); }
- #endif
-
- bool SetText(LPCTSTR s) { return BOOLToBool(::SetWindowText(_window, s)); }
- #ifndef _UNICODE
- bool SetText(LPCWSTR s) { return MySetWindowText(_window, s); }
- #endif
-
- int GetTextLength() const
- { return GetWindowTextLength(_window); }
- UINT GetText(LPTSTR string, int maxCount) const
- { return GetWindowText(_window, string, maxCount); }
- bool GetText(CSysString &s);
- #ifndef _UNICODE
- /*
- UINT GetText(LPWSTR string, int maxCount) const
- { return GetWindowTextW(_window, string, maxCount); }
- */
- bool GetText(UString &s);
- #endif
-
- bool Enable(bool enable)
- { return BOOLToBool(::EnableWindow(_window, BoolToBOOL(enable))); }
-
- bool IsEnabled()
- { return BOOLToBool(::IsWindowEnabled(_window)); }
-
- #ifndef UNDER_CE
- HMENU GetSystemMenu(bool revert)
- { return ::GetSystemMenu(_window, BoolToBOOL(revert)); }
- #endif
-
- UINT_PTR SetTimer(UINT_PTR idEvent, UINT elapse, TIMERPROC timerFunc = 0)
- { return ::SetTimer(_window, idEvent, elapse, timerFunc); }
- bool KillTimer(UINT_PTR idEvent)
- {return BOOLToBool(::KillTimer(_window, idEvent)); }
-
- HICON SetIcon(WPARAM sizeType, HICON icon) { return (HICON)SendMsg(WM_SETICON, sizeType, (LPARAM)icon); }
-};
-
-#define RECT_SIZE_X(r) ((r).right - (r).left)
-#define RECT_SIZE_Y(r) ((r).bottom - (r).top)
-
-inline bool IsKeyDown(int virtKey) { return (::GetKeyState(virtKey) & 0x8000) != 0; }
-
-}
-
-#endif
+// Windows/Window.h
+
+#ifndef ZIP7_INC_WINDOWS_WINDOW_H
+#define ZIP7_INC_WINDOWS_WINDOW_H
+
+#include "../Common/MyWindows.h"
+#include "../Common/MyString.h"
+
+#include "Defs.h"
+
+#ifndef UNDER_CE
+#ifdef WM_CHANGEUISTATE
+#define Z7_WIN_WM_CHANGEUISTATE WM_CHANGEUISTATE
+#define Z7_WIN_WM_UPDATEUISTATE WM_UPDATEUISTATE
+#define Z7_WIN_WM_QUERYUISTATE WM_QUERYUISTATE
+#else
+// these are defined for (_WIN32_WINNT >= 0x0500):
+#define Z7_WIN_WM_CHANGEUISTATE 0x0127
+#define Z7_WIN_WM_UPDATEUISTATE 0x0128
+#define Z7_WIN_WM_QUERYUISTATE 0x0129
+#endif
+
+#ifdef UIS_SET
+
+#define Z7_WIN_UIS_SET UIS_SET
+#define Z7_WIN_UIS_CLEAR UIS_CLEAR
+#define Z7_WIN_UIS_INITIALIZE UIS_INITIALIZE
+
+#define Z7_WIN_UISF_HIDEFOCUS UISF_HIDEFOCUS
+#define Z7_WIN_UISF_HIDEACCEL UISF_HIDEACCEL
+
+#else
+// these are defined for (_WIN32_WINNT >= 0x0500):
+// LOWORD(wParam) values in WM_*UISTATE
+#define Z7_WIN_UIS_SET 1
+#define Z7_WIN_UIS_CLEAR 2
+#define Z7_WIN_UIS_INITIALIZE 3
+
+// HIWORD(wParam) values in WM_*UISTATE
+#define Z7_WIN_UISF_HIDEFOCUS 0x1
+#define Z7_WIN_UISF_HIDEACCEL 0x2
+// defined for for (_WIN32_WINNT >= 0x0501):
+// #define Z7_WIN_UISF_ACTIVE 0x4
+
+#endif
+
+#endif // UNDER_CE
+
+
+#ifdef Z7_OLD_WIN_SDK
+
+// #define VK_OEM_1 0xBA // ';:' for US
+#define VK_OEM_PLUS 0xBB // '+' any country
+// #define VK_OEM_COMMA 0xBC // ',' any country
+#define VK_OEM_MINUS 0xBD // '-' any country
+// #define VK_OEM_PERIOD 0xBE // '.' any country
+// #define VK_OEM_2 0xBF // '/?' for US
+// #define VK_OEM_3 0xC0 // '`~' for US
+
+// #ifndef GWLP_USERDATA
+#define GWLP_WNDPROC (-4)
+#define GWLP_USERDATA (-21)
+// #endif
+#define DWLP_MSGRESULT 0
+// #define DWLP_DLGPROC DWLP_MSGRESULT + sizeof(LRESULT)
+// #define DWLP_USER DWLP_DLGPROC + sizeof(DLGPROC)
+
+#define BTNS_BUTTON TBSTYLE_BUTTON // 0x0000
+
+/*
+vc6 defines INT_PTR via long:
+ typedef long INT_PTR, *PINT_PTR;
+ typedef unsigned long UINT_PTR, *PUINT_PTR;
+but newer sdk (sdk2003+) defines INT_PTR via int:
+ typedef _W64 int INT_PTR, *PINT_PTR;
+ typedef _W64 unsigned int UINT_PTR, *PUINT_PTR;
+*/
+
+#define IS_INTRESOURCE(_r) (((ULONG_PTR)(_r) >> 16) == 0)
+
+#define GetWindowLongPtrA GetWindowLongA
+#define GetWindowLongPtrW GetWindowLongW
+#ifdef UNICODE
+#define GetWindowLongPtr GetWindowLongPtrW
+#else
+#define GetWindowLongPtr GetWindowLongPtrA
+#endif // !UNICODE
+
+#define SetWindowLongPtrA SetWindowLongA
+#define SetWindowLongPtrW SetWindowLongW
+#ifdef UNICODE
+#define SetWindowLongPtr SetWindowLongPtrW
+#else
+#define SetWindowLongPtr SetWindowLongPtrA
+#endif // !UNICODE
+
+#define ListView_SetCheckState(hwndLV, i, fCheck) \
+ ListView_SetItemState(hwndLV, i, INDEXTOSTATEIMAGEMASK((fCheck)?2:1), LVIS_STATEIMAGEMASK)
+
+#endif // Z7_OLD_WIN_SDK
+
+inline bool LRESULTToBool(LRESULT v) { return (v != FALSE); }
+
+#define MY_int_TO_WPARAM(i) ((WPARAM)(INT_PTR)(i))
+
+namespace NWindows {
+
+inline ATOM MyRegisterClass(CONST WNDCLASS *wndClass)
+ { return ::RegisterClass(wndClass); }
+
+#ifndef _UNICODE
+ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
+#endif
+
+#ifdef _UNICODE
+inline bool MySetWindowText(HWND wnd, LPCWSTR s) { return BOOLToBool(::SetWindowText(wnd, s)); }
+#else
+bool MySetWindowText(HWND wnd, LPCWSTR s);
+#endif
+
+
+#ifdef UNDER_CE
+#define GWLP_USERDATA GWL_USERDATA
+#define GWLP_WNDPROC GWL_WNDPROC
+#define BTNS_BUTTON TBSTYLE_BUTTON
+#define WC_COMBOBOXW L"ComboBox"
+#define DWLP_MSGRESULT DWL_MSGRESULT
+#endif
+
+class CWindow
+{
+ Z7_CLASS_NO_COPY(CWindow)
+private:
+ // bool ModifyStyleBase(int styleOffset, DWORD remove, DWORD add, UINT flags);
+protected:
+ HWND _window;
+public:
+ CWindow(HWND newWindow = NULL): _window(newWindow) {}
+ CWindow& operator=(HWND newWindow)
+ {
+ _window = newWindow;
+ return *this;
+ }
+ operator HWND() const { return _window; }
+ void Attach(HWND newWindow) { _window = newWindow; }
+ HWND Detach()
+ {
+ HWND window = _window;
+ _window = NULL;
+ return window;
+ }
+
+ bool Foreground() { return BOOLToBool(::SetForegroundWindow(_window)); }
+
+ HWND GetParent() const { return ::GetParent(_window); }
+ bool GetWindowRect(LPRECT rect) const { return BOOLToBool(::GetWindowRect(_window,rect)); }
+ #ifndef UNDER_CE
+ bool IsZoomed() const { return BOOLToBool(::IsZoomed(_window)); }
+ #endif
+ bool ClientToScreen(LPPOINT point) const { return BOOLToBool(::ClientToScreen(_window, point)); }
+ bool ScreenToClient(LPPOINT point) const { return BOOLToBool(::ScreenToClient(_window, point)); }
+
+ bool CreateEx(DWORD exStyle, LPCTSTR className,
+ LPCTSTR windowName, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam)
+ {
+ _window = ::CreateWindowEx(exStyle, className, windowName,
+ style, x, y, width, height, parentWindow,
+ idOrHMenu, instance, createParam);
+ return (_window != NULL);
+ }
+
+ bool Create(LPCTSTR className,
+ LPCTSTR windowName, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam)
+ {
+ _window = ::CreateWindow(className, windowName,
+ style, x, y, width, height, parentWindow,
+ idOrHMenu, instance, createParam);
+ return (_window != NULL);
+ }
+
+ #ifndef _UNICODE
+ bool Create(LPCWSTR className,
+ LPCWSTR windowName, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam);
+ bool CreateEx(DWORD exStyle, LPCWSTR className,
+ LPCWSTR windowName, DWORD style,
+ int x, int y, int width, int height,
+ HWND parentWindow, HMENU idOrHMenu,
+ HINSTANCE instance, LPVOID createParam);
+ #endif
+
+
+ bool Destroy()
+ {
+ if (_window == NULL)
+ return true;
+ bool result = BOOLToBool(::DestroyWindow(_window));
+ if (result)
+ _window = NULL;
+ return result;
+ }
+ bool IsWindow() { return BOOLToBool(::IsWindow(_window)); }
+ bool Move(int x, int y, int width, int height, bool repaint = true)
+ { return BOOLToBool(::MoveWindow(_window, x, y, width, height, BoolToBOOL(repaint))); }
+
+ bool ChangeSubWindowSizeX(HWND hwnd, int xSize)
+ {
+ RECT rect;
+ ::GetWindowRect(hwnd, &rect);
+ POINT p1;
+ p1.x = rect.left;
+ p1.y = rect.top;
+ ScreenToClient(&p1);
+ return BOOLToBool(::MoveWindow(hwnd, p1.x, p1.y, xSize, rect.bottom - rect.top, TRUE));
+ }
+
+ void ScreenToClient(RECT *rect)
+ {
+ POINT p1, p2;
+ p1.x = rect->left;
+ p1.y = rect->top;
+ p2.x = rect->right;
+ p2.y = rect->bottom;
+ ScreenToClient(&p1);
+ ScreenToClient(&p2);
+
+ rect->left = p1.x;
+ rect->top = p1.y;
+ rect->right = p2.x;
+ rect->bottom = p2.y;
+ }
+
+ bool GetClientRect(LPRECT rect) { return BOOLToBool(::GetClientRect(_window, rect)); }
+ bool Show(int cmdShow) { return BOOLToBool(::ShowWindow(_window, cmdShow)); }
+ bool Show_Bool(bool show) { return Show(show ? SW_SHOW: SW_HIDE); }
+
+ #ifndef UNDER_CE
+ bool SetPlacement(CONST WINDOWPLACEMENT *placement) { return BOOLToBool(::SetWindowPlacement(_window, placement)); }
+ bool GetPlacement(WINDOWPLACEMENT *placement) { return BOOLToBool(::GetWindowPlacement(_window, placement)); }
+ #endif
+ bool Update() { return BOOLToBool(::UpdateWindow(_window)); }
+ bool InvalidateRect(LPCRECT rect, bool backgroundErase = true)
+ { return BOOLToBool(::InvalidateRect(_window, rect, BoolToBOOL(backgroundErase))); }
+ void SetRedraw(bool redraw = true) { SendMsg(WM_SETREDRAW, (WPARAM)BoolToBOOL(redraw), 0); }
+
+ LONG_PTR SetStyle(LONG_PTR style) { return SetLongPtr(GWL_STYLE, style); }
+ // LONG_PTR SetStyle(DWORD style) { return SetLongPtr(GWL_STYLE, (LONG_PTR)style); }
+ LONG_PTR GetStyle() const { return GetLongPtr(GWL_STYLE); }
+ // bool MyIsMaximized() const { return ((GetStyle() & WS_MAXIMIZE) != 0); }
+
+ LONG_PTR SetLong(int index, LONG newLongPtr) { return ::SetWindowLong(_window, index, newLongPtr); }
+ LONG_PTR GetLong(int index) const { return ::GetWindowLong(_window, index); }
+ LONG_PTR SetUserDataLong(LONG newLongPtr) { return SetLong(GWLP_USERDATA, newLongPtr); }
+ LONG_PTR GetUserDataLong() const { return GetLong(GWLP_USERDATA); }
+
+
+ #ifdef UNDER_CE
+
+ LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr) { return SetLong(index, newLongPtr); }
+ LONG_PTR GetLongPtr(int index) const { return GetLong(index); }
+
+ LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetUserDataLong(newLongPtr); }
+ LONG_PTR GetUserDataLongPtr() const { return GetUserDataLong(); }
+
+ #else
+
+ LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr)
+ { return ::SetWindowLongPtr(_window, index,
+ #ifndef _WIN64
+ (LONG)
+ #endif
+ newLongPtr); }
+ #ifndef _UNICODE
+ LONG_PTR SetLongPtrW(int index, LONG_PTR newLongPtr)
+ { return ::SetWindowLongPtrW(_window, index,
+ #ifndef _WIN64
+ (LONG)
+ #endif
+ newLongPtr); }
+ #endif
+
+ LONG_PTR GetLongPtr(int index) const { return ::GetWindowLongPtr(_window, index); }
+ LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetLongPtr(GWLP_USERDATA, newLongPtr); }
+ LONG_PTR GetUserDataLongPtr() const { return GetLongPtr(GWLP_USERDATA); }
+
+ #endif
+
+ /*
+ bool ModifyStyle(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
+ { return ModifyStyleBase(GWL_STYLE, remove, add, flags); }
+ bool ModifyStyleEx(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
+ { return ModifyStyleBase(GWL_EXSTYLE, remove, add, flags); }
+ */
+
+ HWND SetFocus() { return ::SetFocus(_window); }
+
+ LRESULT SendMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
+ { return ::SendMessage(_window, message, wParam, lParam); }
+ #ifndef _UNICODE
+ LRESULT SendMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
+ { return ::SendMessageW(_window, message, wParam, lParam); }
+ #endif
+
+ bool PostMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
+ { return BOOLToBool(::PostMessage(_window, message, wParam, lParam)); }
+ #ifndef _UNICODE
+ bool PostMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
+ { return BOOLToBool(::PostMessageW(_window, message, wParam, lParam)); }
+ #endif
+
+ bool SetText(LPCTSTR s) { return BOOLToBool(::SetWindowText(_window, s)); }
+ #ifndef _UNICODE
+ bool SetText(LPCWSTR s) { return MySetWindowText(_window, s); }
+ #endif
+
+ int GetTextLength() const
+ { return GetWindowTextLength(_window); }
+ int GetText(LPTSTR string, int maxCount) const
+ { return GetWindowText(_window, string, maxCount); }
+ bool GetText(CSysString &s) const;
+ #ifndef _UNICODE
+ /*
+ UINT GetText(LPWSTR string, int maxCount) const
+ { return GetWindowTextW(_window, string, maxCount); }
+ */
+ bool GetText(UString &s) const;
+ #endif
+
+ bool Enable(bool enable)
+ { return BOOLToBool(::EnableWindow(_window, BoolToBOOL(enable))); }
+
+ bool IsEnabled() const
+ { return BOOLToBool(::IsWindowEnabled(_window)); }
+
+ #ifndef UNDER_CE
+ HMENU GetSystemMenu(bool revert)
+ { return ::GetSystemMenu(_window, BoolToBOOL(revert)); }
+ #endif
+
+ UINT_PTR SetTimer(UINT_PTR idEvent, UINT elapse, TIMERPROC timerFunc = NULL)
+ { return ::SetTimer(_window, idEvent, elapse, timerFunc); }
+ bool KillTimer(UINT_PTR idEvent)
+ {return BOOLToBool(::KillTimer(_window, idEvent)); }
+
+ HICON SetIcon(WPARAM sizeType, HICON icon) { return (HICON)SendMsg(WM_SETICON, sizeType, (LPARAM)icon); }
+};
+
+#define RECT_SIZE_X(r) ((r).right - (r).left)
+#define RECT_SIZE_Y(r) ((r).bottom - (r).top)
+
+inline bool IsKeyDown(int virtKey) { return (::GetKeyState(virtKey) & 0x8000) != 0; }
+
+}
+
+#endif
diff --git a/CS/7zip/Common/CRC.cs b/CS/7zip/Common/CRC.cs
deleted file mode 100644
index 62bb847..0000000
--- a/CS/7zip/Common/CRC.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Common/CRC.cs
-
-namespace SevenZip
-{
- class CRC
- {
- public static readonly uint[] Table;
-
- static CRC()
- {
- Table = new uint[256];
- const uint kPoly = 0xEDB88320;
- for (uint i = 0; i < 256; i++)
- {
- uint r = i;
- for (int j = 0; j < 8; j++)
- if ((r & 1) != 0)
- r = (r >> 1) ^ kPoly;
- else
- r >>= 1;
- Table[i] = r;
- }
- }
-
- uint _value = 0xFFFFFFFF;
-
- public void Init() { _value = 0xFFFFFFFF; }
-
- public void UpdateByte(byte b)
- {
- _value = Table[(((byte)(_value)) ^ b)] ^ (_value >> 8);
- }
-
- public void Update(byte[] data, uint offset, uint size)
- {
- for (uint i = 0; i < size; i++)
- _value = Table[(((byte)(_value)) ^ data[offset + i])] ^ (_value >> 8);
- }
-
- public uint GetDigest() { return _value ^ 0xFFFFFFFF; }
-
- static uint CalculateDigest(byte[] data, uint offset, uint size)
- {
- CRC crc = new CRC();
- // crc.Init();
- crc.Update(data, offset, size);
- return crc.GetDigest();
- }
-
- static bool VerifyDigest(uint digest, byte[] data, uint offset, uint size)
- {
- return (CalculateDigest(data, offset, size) == digest);
- }
- }
-}
diff --git a/CS/7zip/Common/CommandLineParser.cs b/CS/7zip/Common/CommandLineParser.cs
deleted file mode 100644
index b46f6f2..0000000
--- a/CS/7zip/Common/CommandLineParser.cs
+++ /dev/null
@@ -1,274 +0,0 @@
-// CommandLineParser.cs
-
-using System;
-using System.Collections;
-
-namespace SevenZip.CommandLineParser
-{
- public enum SwitchType
- {
- Simple,
- PostMinus,
- LimitedPostString,
- UnLimitedPostString,
- PostChar
- }
-
- public class SwitchForm
- {
- public string IDString;
- public SwitchType Type;
- public bool Multi;
- public int MinLen;
- public int MaxLen;
- public string PostCharSet;
-
- public SwitchForm(string idString, SwitchType type, bool multi,
- int minLen, int maxLen, string postCharSet)
- {
- IDString = idString;
- Type = type;
- Multi = multi;
- MinLen = minLen;
- MaxLen = maxLen;
- PostCharSet = postCharSet;
- }
- public SwitchForm(string idString, SwitchType type, bool multi, int minLen):
- this(idString, type, multi, minLen, 0, "")
- {
- }
- public SwitchForm(string idString, SwitchType type, bool multi):
- this(idString, type, multi, 0)
- {
- }
- }
-
- public class SwitchResult
- {
- public bool ThereIs;
- public bool WithMinus;
- public ArrayList PostStrings = new ArrayList();
- public int PostCharIndex;
- public SwitchResult()
- {
- ThereIs = false;
- }
- }
-
- public class Parser
- {
- public ArrayList NonSwitchStrings = new ArrayList();
- SwitchResult[] _switches;
-
- public Parser(int numSwitches)
- {
- _switches = new SwitchResult[numSwitches];
- for (int i = 0; i < numSwitches; i++)
- _switches[i] = new SwitchResult();
- }
-
- bool ParseString(string srcString, SwitchForm[] switchForms)
- {
- int len = srcString.Length;
- if (len == 0)
- return false;
- int pos = 0;
- if (!IsItSwitchChar(srcString[pos]))
- return false;
- while (pos < len)
- {
- if (IsItSwitchChar(srcString[pos]))
- pos++;
- const int kNoLen = -1;
- int matchedSwitchIndex = 0;
- int maxLen = kNoLen;
- for (int switchIndex = 0; switchIndex < _switches.Length; switchIndex++)
- {
- int switchLen = switchForms[switchIndex].IDString.Length;
- if (switchLen <= maxLen || pos + switchLen > len)
- continue;
- if (String.Compare(switchForms[switchIndex].IDString, 0,
- srcString, pos, switchLen, true) == 0)
- {
- matchedSwitchIndex = switchIndex;
- maxLen = switchLen;
- }
- }
- if (maxLen == kNoLen)
- throw new Exception("maxLen == kNoLen");
- SwitchResult matchedSwitch = _switches[matchedSwitchIndex];
- SwitchForm switchForm = switchForms[matchedSwitchIndex];
- if ((!switchForm.Multi) && matchedSwitch.ThereIs)
- throw new Exception("switch must be single");
- matchedSwitch.ThereIs = true;
- pos += maxLen;
- int tailSize = len - pos;
- SwitchType type = switchForm.Type;
- switch (type)
- {
- case SwitchType.PostMinus:
- {
- if (tailSize == 0)
- matchedSwitch.WithMinus = false;
- else
- {
- matchedSwitch.WithMinus = (srcString[pos] == kSwitchMinus);
- if (matchedSwitch.WithMinus)
- pos++;
- }
- break;
- }
- case SwitchType.PostChar:
- {
- if (tailSize < switchForm.MinLen)
- throw new Exception("switch is not full");
- string charSet = switchForm.PostCharSet;
- const int kEmptyCharValue = -1;
- if (tailSize == 0)
- matchedSwitch.PostCharIndex = kEmptyCharValue;
- else
- {
- int index = charSet.IndexOf(srcString[pos]);
- if (index < 0)
- matchedSwitch.PostCharIndex = kEmptyCharValue;
- else
- {
- matchedSwitch.PostCharIndex = index;
- pos++;
- }
- }
- break;
- }
- case SwitchType.LimitedPostString:
- case SwitchType.UnLimitedPostString:
- {
- int minLen = switchForm.MinLen;
- if (tailSize < minLen)
- throw new Exception("switch is not full");
- if (type == SwitchType.UnLimitedPostString)
- {
- matchedSwitch.PostStrings.Add(srcString.Substring(pos));
- return true;
- }
- String stringSwitch = srcString.Substring(pos, minLen);
- pos += minLen;
- for (int i = minLen; i < switchForm.MaxLen && pos < len; i++, pos++)
- {
- char c = srcString[pos];
- if (IsItSwitchChar(c))
- break;
- stringSwitch += c;
- }
- matchedSwitch.PostStrings.Add(stringSwitch);
- break;
- }
- }
- }
- return true;
-
- }
-
- public void ParseStrings(SwitchForm[] switchForms, string[] commandStrings)
- {
- int numCommandStrings = commandStrings.Length;
- bool stopSwitch = false;
- for (int i = 0; i < numCommandStrings; i++)
- {
- string s = commandStrings[i];
- if (stopSwitch)
- NonSwitchStrings.Add(s);
- else
- if (s == kStopSwitchParsing)
- stopSwitch = true;
- else
- if (!ParseString(s, switchForms))
- NonSwitchStrings.Add(s);
- }
- }
-
- public SwitchResult this[int index] { get { return _switches[index]; } }
-
- public static int ParseCommand(CommandForm[] commandForms, string commandString,
- out string postString)
- {
- for (int i = 0; i < commandForms.Length; i++)
- {
- string id = commandForms[i].IDString;
- if (commandForms[i].PostStringMode)
- {
- if (commandString.IndexOf(id) == 0)
- {
- postString = commandString.Substring(id.Length);
- return i;
- }
- }
- else
- if (commandString == id)
- {
- postString = "";
- return i;
- }
- }
- postString = "";
- return -1;
- }
-
- static bool ParseSubCharsCommand(int numForms, CommandSubCharsSet[] forms,
- string commandString, ArrayList indices)
- {
- indices.Clear();
- int numUsedChars = 0;
- for (int i = 0; i < numForms; i++)
- {
- CommandSubCharsSet charsSet = forms[i];
- int currentIndex = -1;
- int len = charsSet.Chars.Length;
- for (int j = 0; j < len; j++)
- {
- char c = charsSet.Chars[j];
- int newIndex = commandString.IndexOf(c);
- if (newIndex >= 0)
- {
- if (currentIndex >= 0)
- return false;
- if (commandString.IndexOf(c, newIndex + 1) >= 0)
- return false;
- currentIndex = j;
- numUsedChars++;
- }
- }
- if (currentIndex == -1 && !charsSet.EmptyAllowed)
- return false;
- indices.Add(currentIndex);
- }
- return (numUsedChars == commandString.Length);
- }
- const char kSwitchID1 = '-';
- const char kSwitchID2 = '/';
-
- const char kSwitchMinus = '-';
- const string kStopSwitchParsing = "--";
-
- static bool IsItSwitchChar(char c)
- {
- return (c == kSwitchID1 || c == kSwitchID2);
- }
- }
-
- public class CommandForm
- {
- public string IDString = "";
- public bool PostStringMode = false;
- public CommandForm(string idString, bool postStringMode)
- {
- IDString = idString;
- PostStringMode = postStringMode;
- }
- }
-
- class CommandSubCharsSet
- {
- public string Chars = "";
- public bool EmptyAllowed = false;
- }
-}
diff --git a/CS/7zip/Common/InBuffer.cs b/CS/7zip/Common/InBuffer.cs
deleted file mode 100644
index 9c47c73..0000000
--- a/CS/7zip/Common/InBuffer.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// InBuffer.cs
-
-namespace SevenZip.Buffer
-{
- public class InBuffer
- {
- byte[] m_Buffer;
- uint m_Pos;
- uint m_Limit;
- uint m_BufferSize;
- System.IO.Stream m_Stream;
- bool m_StreamWasExhausted;
- ulong m_ProcessedSize;
-
- public InBuffer(uint bufferSize)
- {
- m_Buffer = new byte[bufferSize];
- m_BufferSize = bufferSize;
- }
-
- public void Init(System.IO.Stream stream)
- {
- m_Stream = stream;
- m_ProcessedSize = 0;
- m_Limit = 0;
- m_Pos = 0;
- m_StreamWasExhausted = false;
- }
-
- public bool ReadBlock()
- {
- if (m_StreamWasExhausted)
- return false;
- m_ProcessedSize += m_Pos;
- int aNumProcessedBytes = m_Stream.Read(m_Buffer, 0, (int)m_BufferSize);
- m_Pos = 0;
- m_Limit = (uint)aNumProcessedBytes;
- m_StreamWasExhausted = (aNumProcessedBytes == 0);
- return (!m_StreamWasExhausted);
- }
-
-
- public void ReleaseStream()
- {
- // m_Stream.Close();
- m_Stream = null;
- }
-
- public bool ReadByte(byte b) // check it
- {
- if (m_Pos >= m_Limit)
- if (!ReadBlock())
- return false;
- b = m_Buffer[m_Pos++];
- return true;
- }
-
- public byte ReadByte()
- {
- // return (byte)m_Stream.ReadByte();
- if (m_Pos >= m_Limit)
- if (!ReadBlock())
- return 0xFF;
- return m_Buffer[m_Pos++];
- }
-
- public ulong GetProcessedSize()
- {
- return m_ProcessedSize + m_Pos;
- }
- }
-}
diff --git a/CS/7zip/Common/OutBuffer.cs b/CS/7zip/Common/OutBuffer.cs
deleted file mode 100644
index c205aa6..0000000
--- a/CS/7zip/Common/OutBuffer.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// OutBuffer.cs
-
-namespace SevenZip.Buffer
-{
- public class OutBuffer
- {
- byte[] m_Buffer;
- uint m_Pos;
- uint m_BufferSize;
- System.IO.Stream m_Stream;
- ulong m_ProcessedSize;
-
- public OutBuffer(uint bufferSize)
- {
- m_Buffer = new byte[bufferSize];
- m_BufferSize = bufferSize;
- }
-
- public void SetStream(System.IO.Stream stream) { m_Stream = stream; }
- public void FlushStream() { m_Stream.Flush(); }
- public void CloseStream() { m_Stream.Close(); }
- public void ReleaseStream() { m_Stream = null; }
-
- public void Init()
- {
- m_ProcessedSize = 0;
- m_Pos = 0;
- }
-
- public void WriteByte(byte b)
- {
- m_Buffer[m_Pos++] = b;
- if (m_Pos >= m_BufferSize)
- FlushData();
- }
-
- public void FlushData()
- {
- if (m_Pos == 0)
- return;
- m_Stream.Write(m_Buffer, 0, (int)m_Pos);
- m_Pos = 0;
- }
-
- public ulong GetProcessedSize() { return m_ProcessedSize + m_Pos; }
- }
-}
diff --git a/CS/7zip/Compress/LZ/IMatchFinder.cs b/CS/7zip/Compress/LZ/IMatchFinder.cs
deleted file mode 100644
index 30fab86..0000000
--- a/CS/7zip/Compress/LZ/IMatchFinder.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// IMatchFinder.cs
-
-using System;
-
-namespace SevenZip.Compression.LZ
-{
- interface IInWindowStream
- {
- void SetStream(System.IO.Stream inStream);
- void Init();
- void ReleaseStream();
- Byte GetIndexByte(Int32 index);
- UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit);
- UInt32 GetNumAvailableBytes();
- }
-
- interface IMatchFinder : IInWindowStream
- {
- void Create(UInt32 historySize, UInt32 keepAddBufferBefore,
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter);
- UInt32 GetMatches(UInt32[] distances);
- void Skip(UInt32 num);
- }
-}
diff --git a/CS/7zip/Compress/LZ/LzBinTree.cs b/CS/7zip/Compress/LZ/LzBinTree.cs
deleted file mode 100644
index 7a9ca20..0000000
--- a/CS/7zip/Compress/LZ/LzBinTree.cs
+++ /dev/null
@@ -1,367 +0,0 @@
-// LzBinTree.cs
-
-using System;
-
-namespace SevenZip.Compression.LZ
-{
- public class BinTree : InWindow, IMatchFinder
- {
- UInt32 _cyclicBufferPos;
- UInt32 _cyclicBufferSize = 0;
- UInt32 _matchMaxLen;
-
- UInt32[] _son;
- UInt32[] _hash;
-
- UInt32 _cutValue = 0xFF;
- UInt32 _hashMask;
- UInt32 _hashSizeSum = 0;
-
- bool HASH_ARRAY = true;
-
- const UInt32 kHash2Size = 1 << 10;
- const UInt32 kHash3Size = 1 << 16;
- const UInt32 kBT2HashSize = 1 << 16;
- const UInt32 kStartMaxLen = 1;
- const UInt32 kHash3Offset = kHash2Size;
- const UInt32 kEmptyHashValue = 0;
- const UInt32 kMaxValForNormalize = ((UInt32)1 << 31) - 1;
-
- UInt32 kNumHashDirectBytes = 0;
- UInt32 kMinMatchCheck = 4;
- UInt32 kFixHashSize = kHash2Size + kHash3Size;
-
- public void SetType(int numHashBytes)
- {
- HASH_ARRAY = (numHashBytes > 2);
- if (HASH_ARRAY)
- {
- kNumHashDirectBytes = 0;
- kMinMatchCheck = 4;
- kFixHashSize = kHash2Size + kHash3Size;
- }
- else
- {
- kNumHashDirectBytes = 2;
- kMinMatchCheck = 2 + 1;
- kFixHashSize = 0;
- }
- }
-
- public new void SetStream(System.IO.Stream stream) { base.SetStream(stream); }
- public new void ReleaseStream() { base.ReleaseStream(); }
-
- public new void Init()
- {
- base.Init();
- for (UInt32 i = 0; i < _hashSizeSum; i++)
- _hash[i] = kEmptyHashValue;
- _cyclicBufferPos = 0;
- ReduceOffsets(-1);
- }
-
- public new void MovePos()
- {
- if (++_cyclicBufferPos >= _cyclicBufferSize)
- _cyclicBufferPos = 0;
- base.MovePos();
- if (_pos == kMaxValForNormalize)
- Normalize();
- }
-
- public new Byte GetIndexByte(Int32 index) { return base.GetIndexByte(index); }
-
- public new UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
- { return base.GetMatchLen(index, distance, limit); }
-
- public new UInt32 GetNumAvailableBytes() { return base.GetNumAvailableBytes(); }
-
- public void Create(UInt32 historySize, UInt32 keepAddBufferBefore,
- UInt32 matchMaxLen, UInt32 keepAddBufferAfter)
- {
- if (historySize > kMaxValForNormalize - 256)
- throw new Exception();
- _cutValue = 16 + (matchMaxLen >> 1);
-
- UInt32 windowReservSize = (historySize + keepAddBufferBefore +
- matchMaxLen + keepAddBufferAfter) / 2 + 256;
-
- base.Create(historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, windowReservSize);
-
- _matchMaxLen = matchMaxLen;
-
- UInt32 cyclicBufferSize = historySize + 1;
- if (_cyclicBufferSize != cyclicBufferSize)
- _son = new UInt32[(_cyclicBufferSize = cyclicBufferSize) * 2];
-
- UInt32 hs = kBT2HashSize;
-
- if (HASH_ARRAY)
- {
- hs = historySize - 1;
- hs |= (hs >> 1);
- hs |= (hs >> 2);
- hs |= (hs >> 4);
- hs |= (hs >> 8);
- hs >>= 1;
- hs |= 0xFFFF;
- if (hs > (1 << 24))
- hs >>= 1;
- _hashMask = hs;
- hs++;
- hs += kFixHashSize;
- }
- if (hs != _hashSizeSum)
- _hash = new UInt32[_hashSizeSum = hs];
- }
-
- public UInt32 GetMatches(UInt32[] distances)
- {
- UInt32 lenLimit;
- if (_pos + _matchMaxLen <= _streamPos)
- lenLimit = _matchMaxLen;
- else
- {
- lenLimit = _streamPos - _pos;
- if (lenLimit < kMinMatchCheck)
- {
- MovePos();
- return 0;
- }
- }
-
- UInt32 offset = 0;
- UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
- UInt32 cur = _bufferOffset + _pos;
- UInt32 maxLen = kStartMaxLen; // to avoid items for len < hashSize;
- UInt32 hashValue, hash2Value = 0, hash3Value = 0;
-
- if (HASH_ARRAY)
- {
- UInt32 temp = CRC.Table[_bufferBase[cur]] ^ _bufferBase[cur + 1];
- hash2Value = temp & (kHash2Size - 1);
- temp ^= ((UInt32)(_bufferBase[cur + 2]) << 8);
- hash3Value = temp & (kHash3Size - 1);
- hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
- }
- else
- hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
-
- UInt32 curMatch = _hash[kFixHashSize + hashValue];
- if (HASH_ARRAY)
- {
- UInt32 curMatch2 = _hash[hash2Value];
- UInt32 curMatch3 = _hash[kHash3Offset + hash3Value];
- _hash[hash2Value] = _pos;
- _hash[kHash3Offset + hash3Value] = _pos;
- if (curMatch2 > matchMinPos)
- if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
- {
- distances[offset++] = maxLen = 2;
- distances[offset++] = _pos - curMatch2 - 1;
- }
- if (curMatch3 > matchMinPos)
- if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
- {
- if (curMatch3 == curMatch2)
- offset -= 2;
- distances[offset++] = maxLen = 3;
- distances[offset++] = _pos - curMatch3 - 1;
- curMatch2 = curMatch3;
- }
- if (offset != 0 && curMatch2 == curMatch)
- {
- offset -= 2;
- maxLen = kStartMaxLen;
- }
- }
-
- _hash[kFixHashSize + hashValue] = _pos;
-
- UInt32 ptr0 = (_cyclicBufferPos << 1) + 1;
- UInt32 ptr1 = (_cyclicBufferPos << 1);
-
- UInt32 len0, len1;
- len0 = len1 = kNumHashDirectBytes;
-
- if (kNumHashDirectBytes != 0)
- {
- if (curMatch > matchMinPos)
- {
- if (_bufferBase[_bufferOffset + curMatch + kNumHashDirectBytes] !=
- _bufferBase[cur + kNumHashDirectBytes])
- {
- distances[offset++] = maxLen = kNumHashDirectBytes;
- distances[offset++] = _pos - curMatch - 1;
- }
- }
- }
-
- UInt32 count = _cutValue;
-
- while(true)
- {
- if(curMatch <= matchMinPos || count-- == 0)
- {
- _son[ptr0] = _son[ptr1] = kEmptyHashValue;
- break;
- }
- UInt32 delta = _pos - curMatch;
- UInt32 cyclicPos = ((delta <= _cyclicBufferPos) ?
- (_cyclicBufferPos - delta) :
- (_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
-
- UInt32 pby1 = _bufferOffset + curMatch;
- UInt32 len = Math.Min(len0, len1);
- if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
- {
- while(++len != lenLimit)
- if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
- break;
- if (maxLen < len)
- {
- distances[offset++] = maxLen = len;
- distances[offset++] = delta - 1;
- if (len == lenLimit)
- {
- _son[ptr1] = _son[cyclicPos];
- _son[ptr0] = _son[cyclicPos + 1];
- break;
- }
- }
- }
- if (_bufferBase[pby1 + len] < _bufferBase[cur + len])
- {
- _son[ptr1] = curMatch;
- ptr1 = cyclicPos + 1;
- curMatch = _son[ptr1];
- len1 = len;
- }
- else
- {
- _son[ptr0] = curMatch;
- ptr0 = cyclicPos;
- curMatch = _son[ptr0];
- len0 = len;
- }
- }
- MovePos();
- return offset;
- }
-
- public void Skip(UInt32 num)
- {
- do
- {
- UInt32 lenLimit;
- if (_pos + _matchMaxLen <= _streamPos)
- lenLimit = _matchMaxLen;
- else
- {
- lenLimit = _streamPos - _pos;
- if (lenLimit < kMinMatchCheck)
- {
- MovePos();
- continue;
- }
- }
-
- UInt32 matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
- UInt32 cur = _bufferOffset + _pos;
-
- UInt32 hashValue;
-
- if (HASH_ARRAY)
- {
- UInt32 temp = CRC.Table[_bufferBase[cur]] ^ _bufferBase[cur + 1];
- UInt32 hash2Value = temp & (kHash2Size - 1);
- _hash[hash2Value] = _pos;
- temp ^= ((UInt32)(_bufferBase[cur + 2]) << 8);
- UInt32 hash3Value = temp & (kHash3Size - 1);
- _hash[kHash3Offset + hash3Value] = _pos;
- hashValue = (temp ^ (CRC.Table[_bufferBase[cur + 3]] << 5)) & _hashMask;
- }
- else
- hashValue = _bufferBase[cur] ^ ((UInt32)(_bufferBase[cur + 1]) << 8);
-
- UInt32 curMatch = _hash[kFixHashSize + hashValue];
- _hash[kFixHashSize + hashValue] = _pos;
-
- UInt32 ptr0 = (_cyclicBufferPos << 1) + 1;
- UInt32 ptr1 = (_cyclicBufferPos << 1);
-
- UInt32 len0, len1;
- len0 = len1 = kNumHashDirectBytes;
-
- UInt32 count = _cutValue;
- while (true)
- {
- if (curMatch <= matchMinPos || count-- == 0)
- {
- _son[ptr0] = _son[ptr1] = kEmptyHashValue;
- break;
- }
-
- UInt32 delta = _pos - curMatch;
- UInt32 cyclicPos = ((delta <= _cyclicBufferPos) ?
- (_cyclicBufferPos - delta) :
- (_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
-
- UInt32 pby1 = _bufferOffset + curMatch;
- UInt32 len = Math.Min(len0, len1);
- if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
- {
- while (++len != lenLimit)
- if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
- break;
- if (len == lenLimit)
- {
- _son[ptr1] = _son[cyclicPos];
- _son[ptr0] = _son[cyclicPos + 1];
- break;
- }
- }
- if (_bufferBase[pby1 + len] < _bufferBase[cur + len])
- {
- _son[ptr1] = curMatch;
- ptr1 = cyclicPos + 1;
- curMatch = _son[ptr1];
- len1 = len;
- }
- else
- {
- _son[ptr0] = curMatch;
- ptr0 = cyclicPos;
- curMatch = _son[ptr0];
- len0 = len;
- }
- }
- MovePos();
- }
- while (--num != 0);
- }
-
- void NormalizeLinks(UInt32[] items, UInt32 numItems, UInt32 subValue)
- {
- for (UInt32 i = 0; i < numItems; i++)
- {
- UInt32 value = items[i];
- if (value <= subValue)
- value = kEmptyHashValue;
- else
- value -= subValue;
- items[i] = value;
- }
- }
-
- void Normalize()
- {
- UInt32 subValue = _pos - _cyclicBufferSize;
- NormalizeLinks(_son, _cyclicBufferSize * 2, subValue);
- NormalizeLinks(_hash, _hashSizeSum, subValue);
- ReduceOffsets((Int32)subValue);
- }
-
- public void SetCutValue(UInt32 cutValue) { _cutValue = cutValue; }
- }
-}
diff --git a/CS/7zip/Compress/LZ/LzInWindow.cs b/CS/7zip/Compress/LZ/LzInWindow.cs
deleted file mode 100644
index f1974ce..0000000
--- a/CS/7zip/Compress/LZ/LzInWindow.cs
+++ /dev/null
@@ -1,132 +0,0 @@
-// LzInWindow.cs
-
-using System;
-
-namespace SevenZip.Compression.LZ
-{
- public class InWindow
- {
- public Byte[] _bufferBase = null; // pointer to buffer with data
- System.IO.Stream _stream;
- UInt32 _posLimit; // offset (from _buffer) of first byte when new block reading must be done
- bool _streamEndWasReached; // if (true) then _streamPos shows real end of stream
-
- UInt32 _pointerToLastSafePosition;
-
- public UInt32 _bufferOffset;
-
- public UInt32 _blockSize; // Size of Allocated memory block
- public UInt32 _pos; // offset (from _buffer) of curent byte
- UInt32 _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos
- UInt32 _keepSizeAfter; // how many BYTEs must be kept buffer after _pos
- public UInt32 _streamPos; // offset (from _buffer) of first not read byte from Stream
-
- public void MoveBlock()
- {
- UInt32 offset = (UInt32)(_bufferOffset) + _pos - _keepSizeBefore;
- // we need one additional byte, since MovePos moves on 1 byte.
- if (offset > 0)
- offset--;
-
- UInt32 numBytes = (UInt32)(_bufferOffset) + _streamPos - offset;
-
- // check negative offset ????
- for (UInt32 i = 0; i < numBytes; i++)
- _bufferBase[i] = _bufferBase[offset + i];
- _bufferOffset -= offset;
- }
-
- public virtual void ReadBlock()
- {
- if (_streamEndWasReached)
- return;
- while (true)
- {
- int size = (int)((0 - _bufferOffset) + _blockSize - _streamPos);
- if (size == 0)
- return;
- int numReadBytes = _stream.Read(_bufferBase, (int)(_bufferOffset + _streamPos), size);
- if (numReadBytes == 0)
- {
- _posLimit = _streamPos;
- UInt32 pointerToPostion = _bufferOffset + _posLimit;
- if (pointerToPostion > _pointerToLastSafePosition)
- _posLimit = (UInt32)(_pointerToLastSafePosition - _bufferOffset);
-
- _streamEndWasReached = true;
- return;
- }
- _streamPos += (UInt32)numReadBytes;
- if (_streamPos >= _pos + _keepSizeAfter)
- _posLimit = _streamPos - _keepSizeAfter;
- }
- }
-
- void Free() { _bufferBase = null; }
-
- public void Create(UInt32 keepSizeBefore, UInt32 keepSizeAfter, UInt32 keepSizeReserv)
- {
- _keepSizeBefore = keepSizeBefore;
- _keepSizeAfter = keepSizeAfter;
- UInt32 blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
- if (_bufferBase == null || _blockSize != blockSize)
- {
- Free();
- _blockSize = blockSize;
- _bufferBase = new Byte[_blockSize];
- }
- _pointerToLastSafePosition = _blockSize - keepSizeAfter;
- }
-
- public void SetStream(System.IO.Stream stream) { _stream = stream; }
- public void ReleaseStream() { _stream = null; }
-
- public void Init()
- {
- _bufferOffset = 0;
- _pos = 0;
- _streamPos = 0;
- _streamEndWasReached = false;
- ReadBlock();
- }
-
- public void MovePos()
- {
- _pos++;
- if (_pos > _posLimit)
- {
- UInt32 pointerToPostion = _bufferOffset + _pos;
- if (pointerToPostion > _pointerToLastSafePosition)
- MoveBlock();
- ReadBlock();
- }
- }
-
- public Byte GetIndexByte(Int32 index) { return _bufferBase[_bufferOffset + _pos + index]; }
-
- // index + limit have not to exceed _keepSizeAfter;
- public UInt32 GetMatchLen(Int32 index, UInt32 distance, UInt32 limit)
- {
- if (_streamEndWasReached)
- if ((_pos + index) + limit > _streamPos)
- limit = _streamPos - (UInt32)(_pos + index);
- distance++;
- // Byte *pby = _buffer + (size_t)_pos + index;
- UInt32 pby = _bufferOffset + _pos + (UInt32)index;
-
- UInt32 i;
- for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++);
- return i;
- }
-
- public UInt32 GetNumAvailableBytes() { return _streamPos - _pos; }
-
- public void ReduceOffsets(Int32 subValue)
- {
- _bufferOffset += (UInt32)subValue;
- _posLimit -= (UInt32)subValue;
- _pos -= (UInt32)subValue;
- _streamPos -= (UInt32)subValue;
- }
- }
-}
diff --git a/CS/7zip/Compress/LZ/LzOutWindow.cs b/CS/7zip/Compress/LZ/LzOutWindow.cs
deleted file mode 100644
index 84914f0..0000000
--- a/CS/7zip/Compress/LZ/LzOutWindow.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-// LzOutWindow.cs
-
-namespace SevenZip.Compression.LZ
-{
- public class OutWindow
- {
- byte[] _buffer = null;
- uint _pos;
- uint _windowSize = 0;
- uint _streamPos;
- System.IO.Stream _stream;
-
- public uint TrainSize = 0;
-
- public void Create(uint windowSize)
- {
- if (_windowSize != windowSize)
- {
- // System.GC.Collect();
- _buffer = new byte[windowSize];
- }
- _windowSize = windowSize;
- _pos = 0;
- _streamPos = 0;
- }
-
- public void Init(System.IO.Stream stream, bool solid)
- {
- ReleaseStream();
- _stream = stream;
- if (!solid)
- {
- _streamPos = 0;
- _pos = 0;
- TrainSize = 0;
- }
- }
-
- public bool Train(System.IO.Stream stream)
- {
- long len = stream.Length;
- uint size = (len < _windowSize) ? (uint)len : _windowSize;
- TrainSize = size;
- stream.Position = len - size;
- _streamPos = _pos = 0;
- while (size > 0)
- {
- uint curSize = _windowSize - _pos;
- if (size < curSize)
- curSize = size;
- int numReadBytes = stream.Read(_buffer, (int)_pos, (int)curSize);
- if (numReadBytes == 0)
- return false;
- size -= (uint)numReadBytes;
- _pos += (uint)numReadBytes;
- _streamPos += (uint)numReadBytes;
- if (_pos == _windowSize)
- _streamPos = _pos = 0;
- }
- return true;
- }
-
- public void ReleaseStream()
- {
- Flush();
- _stream = null;
- }
-
- public void Flush()
- {
- uint size = _pos - _streamPos;
- if (size == 0)
- return;
- _stream.Write(_buffer, (int)_streamPos, (int)size);
- if (_pos >= _windowSize)
- _pos = 0;
- _streamPos = _pos;
- }
-
- public void CopyBlock(uint distance, uint len)
- {
- uint pos = _pos - distance - 1;
- if (pos >= _windowSize)
- pos += _windowSize;
- for (; len > 0; len--)
- {
- if (pos >= _windowSize)
- pos = 0;
- _buffer[_pos++] = _buffer[pos++];
- if (_pos >= _windowSize)
- Flush();
- }
- }
-
- public void PutByte(byte b)
- {
- _buffer[_pos++] = b;
- if (_pos >= _windowSize)
- Flush();
- }
-
- public byte GetByte(uint distance)
- {
- uint pos = _pos - distance - 1;
- if (pos >= _windowSize)
- pos += _windowSize;
- return _buffer[pos];
- }
- }
-}
diff --git a/CS/7zip/Compress/LZMA/LzmaBase.cs b/CS/7zip/Compress/LZMA/LzmaBase.cs
deleted file mode 100644
index 8447a2a..0000000
--- a/CS/7zip/Compress/LZMA/LzmaBase.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-// LzmaBase.cs
-
-namespace SevenZip.Compression.LZMA
-{
- internal abstract class Base
- {
- public const uint kNumRepDistances = 4;
- public const uint kNumStates = 12;
-
- // static byte []kLiteralNextStates = {0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5};
- // static byte []kMatchNextStates = {7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10};
- // static byte []kRepNextStates = {8, 8, 8, 8, 8, 8, 8, 11, 11, 11, 11, 11};
- // static byte []kShortRepNextStates = {9, 9, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11};
-
- public struct State
- {
- public uint Index;
- public void Init() { Index = 0; }
- public void UpdateChar()
- {
- if (Index < 4) Index = 0;
- else if (Index < 10) Index -= 3;
- else Index -= 6;
- }
- public void UpdateMatch() { Index = (uint)(Index < 7 ? 7 : 10); }
- public void UpdateRep() { Index = (uint)(Index < 7 ? 8 : 11); }
- public void UpdateShortRep() { Index = (uint)(Index < 7 ? 9 : 11); }
- public bool IsCharState() { return Index < 7; }
- }
-
- public const int kNumPosSlotBits = 6;
- public const int kDicLogSizeMin = 0;
- // public const int kDicLogSizeMax = 30;
- // public const uint kDistTableSizeMax = kDicLogSizeMax * 2;
-
- public const int kNumLenToPosStatesBits = 2; // it's for speed optimization
- public const uint kNumLenToPosStates = 1 << kNumLenToPosStatesBits;
-
- public const uint kMatchMinLen = 2;
-
- public static uint GetLenToPosState(uint len)
- {
- len -= kMatchMinLen;
- if (len < kNumLenToPosStates)
- return len;
- return (uint)(kNumLenToPosStates - 1);
- }
-
- public const int kNumAlignBits = 4;
- public const uint kAlignTableSize = 1 << kNumAlignBits;
- public const uint kAlignMask = (kAlignTableSize - 1);
-
- public const uint kStartPosModelIndex = 4;
- public const uint kEndPosModelIndex = 14;
- public const uint kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
-
- public const uint kNumFullDistances = 1 << ((int)kEndPosModelIndex / 2);
-
- public const uint kNumLitPosStatesBitsEncodingMax = 4;
- public const uint kNumLitContextBitsMax = 8;
-
- public const int kNumPosStatesBitsMax = 4;
- public const uint kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
- public const int kNumPosStatesBitsEncodingMax = 4;
- public const uint kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
-
- public const int kNumLowLenBits = 3;
- public const int kNumMidLenBits = 3;
- public const int kNumHighLenBits = 8;
- public const uint kNumLowLenSymbols = 1 << kNumLowLenBits;
- public const uint kNumMidLenSymbols = 1 << kNumMidLenBits;
- public const uint kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols +
- (1 << kNumHighLenBits);
- public const uint kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1;
- }
-}
diff --git a/CS/7zip/Compress/LZMA/LzmaDecoder.cs b/CS/7zip/Compress/LZMA/LzmaDecoder.cs
deleted file mode 100644
index 00bfe63..0000000
--- a/CS/7zip/Compress/LZMA/LzmaDecoder.cs
+++ /dev/null
@@ -1,398 +0,0 @@
-// LzmaDecoder.cs
-
-using System;
-
-namespace SevenZip.Compression.LZMA
-{
- using RangeCoder;
-
- public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
- {
- class LenDecoder
- {
- BitDecoder m_Choice = new BitDecoder();
- BitDecoder m_Choice2 = new BitDecoder();
- BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
- BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
- BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
- uint m_NumPosStates = 0;
-
- public void Create(uint numPosStates)
- {
- for (uint posState = m_NumPosStates; posState < numPosStates; posState++)
- {
- m_LowCoder[posState] = new BitTreeDecoder(Base.kNumLowLenBits);
- m_MidCoder[posState] = new BitTreeDecoder(Base.kNumMidLenBits);
- }
- m_NumPosStates = numPosStates;
- }
-
- public void Init()
- {
- m_Choice.Init();
- for (uint posState = 0; posState < m_NumPosStates; posState++)
- {
- m_LowCoder[posState].Init();
- m_MidCoder[posState].Init();
- }
- m_Choice2.Init();
- m_HighCoder.Init();
- }
-
- public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
- {
- if (m_Choice.Decode(rangeDecoder) == 0)
- return m_LowCoder[posState].Decode(rangeDecoder);
- else
- {
- uint symbol = Base.kNumLowLenSymbols;
- if (m_Choice2.Decode(rangeDecoder) == 0)
- symbol += m_MidCoder[posState].Decode(rangeDecoder);
- else
- {
- symbol += Base.kNumMidLenSymbols;
- symbol += m_HighCoder.Decode(rangeDecoder);
- }
- return symbol;
- }
- }
- }
-
- class LiteralDecoder
- {
- struct Decoder2
- {
- BitDecoder[] m_Decoders;
- public void Create() { m_Decoders = new BitDecoder[0x300]; }
- public void Init() { for (int i = 0; i < 0x300; i++) m_Decoders[i].Init(); }
-
- public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
- {
- uint symbol = 1;
- do
- symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
- while (symbol < 0x100);
- return (byte)symbol;
- }
-
- public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)
- {
- uint symbol = 1;
- do
- {
- uint matchBit = (uint)(matchByte >> 7) & 1;
- matchByte <<= 1;
- uint bit = m_Decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);
- symbol = (symbol << 1) | bit;
- if (matchBit != bit)
- {
- while (symbol < 0x100)
- symbol = (symbol << 1) | m_Decoders[symbol].Decode(rangeDecoder);
- break;
- }
- }
- while (symbol < 0x100);
- return (byte)symbol;
- }
- }
-
- Decoder2[] m_Coders;
- int m_NumPrevBits;
- int m_NumPosBits;
- uint m_PosMask;
-
- public void Create(int numPosBits, int numPrevBits)
- {
- if (m_Coders != null && m_NumPrevBits == numPrevBits &&
- m_NumPosBits == numPosBits)
- return;
- m_NumPosBits = numPosBits;
- m_PosMask = ((uint)1 << numPosBits) - 1;
- m_NumPrevBits = numPrevBits;
- uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
- m_Coders = new Decoder2[numStates];
- for (uint i = 0; i < numStates; i++)
- m_Coders[i].Create();
- }
-
- public void Init()
- {
- uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
- for (uint i = 0; i < numStates; i++)
- m_Coders[i].Init();
- }
-
- uint GetState(uint pos, byte prevByte)
- { return ((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits)); }
-
- public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
- { return m_Coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder); }
-
- public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)
- { return m_Coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte); }
- };
-
- LZ.OutWindow m_OutWindow = new LZ.OutWindow();
- RangeCoder.Decoder m_RangeDecoder = new RangeCoder.Decoder();
-
- BitDecoder[] m_IsMatchDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
- BitDecoder[] m_IsRepDecoders = new BitDecoder[Base.kNumStates];
- BitDecoder[] m_IsRepG0Decoders = new BitDecoder[Base.kNumStates];
- BitDecoder[] m_IsRepG1Decoders = new BitDecoder[Base.kNumStates];
- BitDecoder[] m_IsRepG2Decoders = new BitDecoder[Base.kNumStates];
- BitDecoder[] m_IsRep0LongDecoders = new BitDecoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
-
- BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
- BitDecoder[] m_PosDecoders = new BitDecoder[Base.kNumFullDistances - Base.kEndPosModelIndex];
-
- BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
-
- LenDecoder m_LenDecoder = new LenDecoder();
- LenDecoder m_RepLenDecoder = new LenDecoder();
-
- LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
-
- uint m_DictionarySize;
- uint m_DictionarySizeCheck;
-
- uint m_PosStateMask;
-
- public Decoder()
- {
- m_DictionarySize = 0xFFFFFFFF;
- for (int i = 0; i < Base.kNumLenToPosStates; i++)
- m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
- }
-
- void SetDictionarySize(uint dictionarySize)
- {
- if (m_DictionarySize != dictionarySize)
- {
- m_DictionarySize = dictionarySize;
- m_DictionarySizeCheck = Math.Max(m_DictionarySize, 1);
- uint blockSize = Math.Max(m_DictionarySizeCheck, (1 << 12));
- m_OutWindow.Create(blockSize);
- }
- }
-
- void SetLiteralProperties(int lp, int lc)
- {
- if (lp > 8)
- throw new InvalidParamException();
- if (lc > 8)
- throw new InvalidParamException();
- m_LiteralDecoder.Create(lp, lc);
- }
-
- void SetPosBitsProperties(int pb)
- {
- if (pb > Base.kNumPosStatesBitsMax)
- throw new InvalidParamException();
- uint numPosStates = (uint)1 << pb;
- m_LenDecoder.Create(numPosStates);
- m_RepLenDecoder.Create(numPosStates);
- m_PosStateMask = numPosStates - 1;
- }
-
- bool _solid = false;
- void Init(System.IO.Stream inStream, System.IO.Stream outStream)
- {
- m_RangeDecoder.Init(inStream);
- m_OutWindow.Init(outStream, _solid);
-
- uint i;
- for (i = 0; i < Base.kNumStates; i++)
- {
- for (uint j = 0; j <= m_PosStateMask; j++)
- {
- uint index = (i << Base.kNumPosStatesBitsMax) + j;
- m_IsMatchDecoders[index].Init();
- m_IsRep0LongDecoders[index].Init();
- }
- m_IsRepDecoders[i].Init();
- m_IsRepG0Decoders[i].Init();
- m_IsRepG1Decoders[i].Init();
- m_IsRepG2Decoders[i].Init();
- }
-
- m_LiteralDecoder.Init();
- for (i = 0; i < Base.kNumLenToPosStates; i++)
- m_PosSlotDecoder[i].Init();
- // m_PosSpecDecoder.Init();
- for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
- m_PosDecoders[i].Init();
-
- m_LenDecoder.Init();
- m_RepLenDecoder.Init();
- m_PosAlignDecoder.Init();
- }
-
- public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
- Int64 inSize, Int64 outSize, ICodeProgress progress)
- {
- Init(inStream, outStream);
-
- Base.State state = new Base.State();
- state.Init();
- uint rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
-
- UInt64 nowPos64 = 0;
- UInt64 outSize64 = (UInt64)outSize;
- if (nowPos64 < outSize64)
- {
- if (m_IsMatchDecoders[state.Index << Base.kNumPosStatesBitsMax].Decode(m_RangeDecoder) != 0)
- throw new DataErrorException();
- state.UpdateChar();
- byte b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, 0, 0);
- m_OutWindow.PutByte(b);
- nowPos64++;
- }
- while (nowPos64 < outSize64)
- {
- // UInt64 next = Math.Min(nowPos64 + (1 << 18), outSize64);
- // while(nowPos64 < next)
- {
- uint posState = (uint)nowPos64 & m_PosStateMask;
- if (m_IsMatchDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
- {
- byte b;
- byte prevByte = m_OutWindow.GetByte(0);
- if (!state.IsCharState())
- b = m_LiteralDecoder.DecodeWithMatchByte(m_RangeDecoder,
- (uint)nowPos64, prevByte, m_OutWindow.GetByte(rep0));
- else
- b = m_LiteralDecoder.DecodeNormal(m_RangeDecoder, (uint)nowPos64, prevByte);
- m_OutWindow.PutByte(b);
- state.UpdateChar();
- nowPos64++;
- }
- else
- {
- uint len;
- if (m_IsRepDecoders[state.Index].Decode(m_RangeDecoder) == 1)
- {
- if (m_IsRepG0Decoders[state.Index].Decode(m_RangeDecoder) == 0)
- {
- if (m_IsRep0LongDecoders[(state.Index << Base.kNumPosStatesBitsMax) + posState].Decode(m_RangeDecoder) == 0)
- {
- state.UpdateShortRep();
- m_OutWindow.PutByte(m_OutWindow.GetByte(rep0));
- nowPos64++;
- continue;
- }
- }
- else
- {
- UInt32 distance;
- if (m_IsRepG1Decoders[state.Index].Decode(m_RangeDecoder) == 0)
- {
- distance = rep1;
- }
- else
- {
- if (m_IsRepG2Decoders[state.Index].Decode(m_RangeDecoder) == 0)
- distance = rep2;
- else
- {
- distance = rep3;
- rep3 = rep2;
- }
- rep2 = rep1;
- }
- rep1 = rep0;
- rep0 = distance;
- }
- len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;
- state.UpdateRep();
- }
- else
- {
- rep3 = rep2;
- rep2 = rep1;
- rep1 = rep0;
- len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
- state.UpdateMatch();
- uint posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);
- if (posSlot >= Base.kStartPosModelIndex)
- {
- int numDirectBits = (int)((posSlot >> 1) - 1);
- rep0 = ((2 | (posSlot & 1)) << numDirectBits);
- if (posSlot < Base.kEndPosModelIndex)
- rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
- rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
- else
- {
- rep0 += (m_RangeDecoder.DecodeDirectBits(
- numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);
- rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
- }
- }
- else
- rep0 = posSlot;
- }
- if (rep0 >= m_OutWindow.TrainSize + nowPos64 || rep0 >= m_DictionarySizeCheck)
- {
- if (rep0 == 0xFFFFFFFF)
- break;
- throw new DataErrorException();
- }
- m_OutWindow.CopyBlock(rep0, len);
- nowPos64 += len;
- }
- }
- }
- m_OutWindow.Flush();
- m_OutWindow.ReleaseStream();
- m_RangeDecoder.ReleaseStream();
- }
-
- public void SetDecoderProperties(byte[] properties)
- {
- if (properties.Length < 5)
- throw new InvalidParamException();
- int lc = properties[0] % 9;
- int remainder = properties[0] / 9;
- int lp = remainder % 5;
- int pb = remainder / 5;
- if (pb > Base.kNumPosStatesBitsMax)
- throw new InvalidParamException();
- UInt32 dictionarySize = 0;
- for (int i = 0; i < 4; i++)
- dictionarySize += ((UInt32)(properties[1 + i])) << (i * 8);
- SetDictionarySize(dictionarySize);
- SetLiteralProperties(lp, lc);
- SetPosBitsProperties(pb);
- }
-
- public bool Train(System.IO.Stream stream)
- {
- _solid = true;
- return m_OutWindow.Train(stream);
- }
-
- /*
- public override bool CanRead { get { return true; }}
- public override bool CanWrite { get { return true; }}
- public override bool CanSeek { get { return true; }}
- public override long Length { get { return 0; }}
- public override long Position
- {
- get { return 0; }
- set { }
- }
- public override void Flush() { }
- public override int Read(byte[] buffer, int offset, int count)
- {
- return 0;
- }
- public override void Write(byte[] buffer, int offset, int count)
- {
- }
- public override long Seek(long offset, System.IO.SeekOrigin origin)
- {
- return 0;
- }
- public override void SetLength(long value) {}
- */
- }
-}
diff --git a/CS/7zip/Compress/LZMA/LzmaEncoder.cs b/CS/7zip/Compress/LZMA/LzmaEncoder.cs
deleted file mode 100644
index 6dc2708..0000000
--- a/CS/7zip/Compress/LZMA/LzmaEncoder.cs
+++ /dev/null
@@ -1,1480 +0,0 @@
-// LzmaEncoder.cs
-
-using System;
-
-namespace SevenZip.Compression.LZMA
-{
- using RangeCoder;
-
- public class Encoder : ICoder, ISetCoderProperties, IWriteCoderProperties
- {
- enum EMatchFinderType
- {
- BT2,
- BT4,
- };
-
- const UInt32 kIfinityPrice = 0xFFFFFFF;
-
- static Byte[] g_FastPos = new Byte[1 << 11];
-
- static Encoder()
- {
- const Byte kFastSlots = 22;
- int c = 2;
- g_FastPos[0] = 0;
- g_FastPos[1] = 1;
- for (Byte slotFast = 2; slotFast < kFastSlots; slotFast++)
- {
- UInt32 k = ((UInt32)1 << ((slotFast >> 1) - 1));
- for (UInt32 j = 0; j < k; j++, c++)
- g_FastPos[c] = slotFast;
- }
- }
-
- static UInt32 GetPosSlot(UInt32 pos)
- {
- if (pos < (1 << 11))
- return g_FastPos[pos];
- if (pos < (1 << 21))
- return (UInt32)(g_FastPos[pos >> 10] + 20);
- return (UInt32)(g_FastPos[pos >> 20] + 40);
- }
-
- static UInt32 GetPosSlot2(UInt32 pos)
- {
- if (pos < (1 << 17))
- return (UInt32)(g_FastPos[pos >> 6] + 12);
- if (pos < (1 << 27))
- return (UInt32)(g_FastPos[pos >> 16] + 32);
- return (UInt32)(g_FastPos[pos >> 26] + 52);
- }
-
- Base.State _state = new Base.State();
- Byte _previousByte;
- UInt32[] _repDistances = new UInt32[Base.kNumRepDistances];
-
- void BaseInit()
- {
- _state.Init();
- _previousByte = 0;
- for (UInt32 i = 0; i < Base.kNumRepDistances; i++)
- _repDistances[i] = 0;
- }
-
- const int kDefaultDictionaryLogSize = 22;
- const UInt32 kNumFastBytesDefault = 0x20;
-
- class LiteralEncoder
- {
- public struct Encoder2
- {
- BitEncoder[] m_Encoders;
-
- public void Create() { m_Encoders = new BitEncoder[0x300]; }
-
- public void Init() { for (int i = 0; i < 0x300; i++) m_Encoders[i].Init(); }
-
- public void Encode(RangeCoder.Encoder rangeEncoder, byte symbol)
- {
- uint context = 1;
- for (int i = 7; i >= 0; i--)
- {
- uint bit = (uint)((symbol >> i) & 1);
- m_Encoders[context].Encode(rangeEncoder, bit);
- context = (context << 1) | bit;
- }
- }
-
- public void EncodeMatched(RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol)
- {
- uint context = 1;
- bool same = true;
- for (int i = 7; i >= 0; i--)
- {
- uint bit = (uint)((symbol >> i) & 1);
- uint state = context;
- if (same)
- {
- uint matchBit = (uint)((matchByte >> i) & 1);
- state += ((1 + matchBit) << 8);
- same = (matchBit == bit);
- }
- m_Encoders[state].Encode(rangeEncoder, bit);
- context = (context << 1) | bit;
- }
- }
-
- public uint GetPrice(bool matchMode, byte matchByte, byte symbol)
- {
- uint price = 0;
- uint context = 1;
- int i = 7;
- if (matchMode)
- {
- for (; i >= 0; i--)
- {
- uint matchBit = (uint)(matchByte >> i) & 1;
- uint bit = (uint)(symbol >> i) & 1;
- price += m_Encoders[((1 + matchBit) << 8) + context].GetPrice(bit);
- context = (context << 1) | bit;
- if (matchBit != bit)
- {
- i--;
- break;
- }
- }
- }
- for (; i >= 0; i--)
- {
- uint bit = (uint)(symbol >> i) & 1;
- price += m_Encoders[context].GetPrice(bit);
- context = (context << 1) | bit;
- }
- return price;
- }
- }
-
- Encoder2[] m_Coders;
- int m_NumPrevBits;
- int m_NumPosBits;
- uint m_PosMask;
-
- public void Create(int numPosBits, int numPrevBits)
- {
- if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
- return;
- m_NumPosBits = numPosBits;
- m_PosMask = ((uint)1 << numPosBits) - 1;
- m_NumPrevBits = numPrevBits;
- uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
- m_Coders = new Encoder2[numStates];
- for (uint i = 0; i < numStates; i++)
- m_Coders[i].Create();
- }
-
- public void Init()
- {
- uint numStates = (uint)1 << (m_NumPrevBits + m_NumPosBits);
- for (uint i = 0; i < numStates; i++)
- m_Coders[i].Init();
- }
-
- public Encoder2 GetSubCoder(UInt32 pos, Byte prevByte)
- { return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + (uint)(prevByte >> (8 - m_NumPrevBits))]; }
- }
-
- class LenEncoder
- {
- RangeCoder.BitEncoder _choice = new RangeCoder.BitEncoder();
- RangeCoder.BitEncoder _choice2 = new RangeCoder.BitEncoder();
- RangeCoder.BitTreeEncoder[] _lowCoder = new RangeCoder.BitTreeEncoder[Base.kNumPosStatesEncodingMax];
- RangeCoder.BitTreeEncoder[] _midCoder = new RangeCoder.BitTreeEncoder[Base.kNumPosStatesEncodingMax];
- RangeCoder.BitTreeEncoder _highCoder = new RangeCoder.BitTreeEncoder(Base.kNumHighLenBits);
-
- public LenEncoder()
- {
- for (UInt32 posState = 0; posState < Base.kNumPosStatesEncodingMax; posState++)
- {
- _lowCoder[posState] = new RangeCoder.BitTreeEncoder(Base.kNumLowLenBits);
- _midCoder[posState] = new RangeCoder.BitTreeEncoder(Base.kNumMidLenBits);
- }
- }
-
- public void Init(UInt32 numPosStates)
- {
- _choice.Init();
- _choice2.Init();
- for (UInt32 posState = 0; posState < numPosStates; posState++)
- {
- _lowCoder[posState].Init();
- _midCoder[posState].Init();
- }
- _highCoder.Init();
- }
-
- public void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)
- {
- if (symbol < Base.kNumLowLenSymbols)
- {
- _choice.Encode(rangeEncoder, 0);
- _lowCoder[posState].Encode(rangeEncoder, symbol);
- }
- else
- {
- symbol -= Base.kNumLowLenSymbols;
- _choice.Encode(rangeEncoder, 1);
- if (symbol < Base.kNumMidLenSymbols)
- {
- _choice2.Encode(rangeEncoder, 0);
- _midCoder[posState].Encode(rangeEncoder, symbol);
- }
- else
- {
- _choice2.Encode(rangeEncoder, 1);
- _highCoder.Encode(rangeEncoder, symbol - Base.kNumMidLenSymbols);
- }
- }
- }
-
- public void SetPrices(UInt32 posState, UInt32 numSymbols, UInt32[] prices, UInt32 st)
- {
- UInt32 a0 = _choice.GetPrice0();
- UInt32 a1 = _choice.GetPrice1();
- UInt32 b0 = a1 + _choice2.GetPrice0();
- UInt32 b1 = a1 + _choice2.GetPrice1();
- UInt32 i = 0;
- for (i = 0; i < Base.kNumLowLenSymbols; i++)
- {
- if (i >= numSymbols)
- return;
- prices[st + i] = a0 + _lowCoder[posState].GetPrice(i);
- }
- for (; i < Base.kNumLowLenSymbols + Base.kNumMidLenSymbols; i++)
- {
- if (i >= numSymbols)
- return;
- prices[st + i] = b0 + _midCoder[posState].GetPrice(i - Base.kNumLowLenSymbols);
- }
- for (; i < numSymbols; i++)
- prices[st + i] = b1 + _highCoder.GetPrice(i - Base.kNumLowLenSymbols - Base.kNumMidLenSymbols);
- }
- };
-
- const UInt32 kNumLenSpecSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols;
-
- class LenPriceTableEncoder : LenEncoder
- {
- UInt32[] _prices = new UInt32[Base.kNumLenSymbols << Base.kNumPosStatesBitsEncodingMax];
- UInt32 _tableSize;
- UInt32[] _counters = new UInt32[Base.kNumPosStatesEncodingMax];
-
- public void SetTableSize(UInt32 tableSize) { _tableSize = tableSize; }
-
- public UInt32 GetPrice(UInt32 symbol, UInt32 posState)
- {
- return _prices[posState * Base.kNumLenSymbols + symbol];
- }
-
- void UpdateTable(UInt32 posState)
- {
- SetPrices(posState, _tableSize, _prices, posState * Base.kNumLenSymbols);
- _counters[posState] = _tableSize;
- }
-
- public void UpdateTables(UInt32 numPosStates)
- {
- for (UInt32 posState = 0; posState < numPosStates; posState++)
- UpdateTable(posState);
- }
-
- public new void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)
- {
- base.Encode(rangeEncoder, symbol, posState);
- if (--_counters[posState] == 0)
- UpdateTable(posState);
- }
- }
-
- const UInt32 kNumOpts = 1 << 12;
- class Optimal
- {
- public Base.State State;
-
- public bool Prev1IsChar;
- public bool Prev2;
-
- public UInt32 PosPrev2;
- public UInt32 BackPrev2;
-
- public UInt32 Price;
- public UInt32 PosPrev;
- public UInt32 BackPrev;
-
- public UInt32 Backs0;
- public UInt32 Backs1;
- public UInt32 Backs2;
- public UInt32 Backs3;
-
- public void MakeAsChar() { BackPrev = 0xFFFFFFFF; Prev1IsChar = false; }
- public void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }
- public bool IsShortRep() { return (BackPrev == 0); }
- };
- Optimal[] _optimum = new Optimal[kNumOpts];
- LZ.IMatchFinder _matchFinder = null;
- RangeCoder.Encoder _rangeEncoder = new RangeCoder.Encoder();
-
- RangeCoder.BitEncoder[] _isMatch = new RangeCoder.BitEncoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
- RangeCoder.BitEncoder[] _isRep = new RangeCoder.BitEncoder[Base.kNumStates];
- RangeCoder.BitEncoder[] _isRepG0 = new RangeCoder.BitEncoder[Base.kNumStates];
- RangeCoder.BitEncoder[] _isRepG1 = new RangeCoder.BitEncoder[Base.kNumStates];
- RangeCoder.BitEncoder[] _isRepG2 = new RangeCoder.BitEncoder[Base.kNumStates];
- RangeCoder.BitEncoder[] _isRep0Long = new RangeCoder.BitEncoder[Base.kNumStates << Base.kNumPosStatesBitsMax];
-
- RangeCoder.BitTreeEncoder[] _posSlotEncoder = new RangeCoder.BitTreeEncoder[Base.kNumLenToPosStates];
-
- RangeCoder.BitEncoder[] _posEncoders = new RangeCoder.BitEncoder[Base.kNumFullDistances - Base.kEndPosModelIndex];
- RangeCoder.BitTreeEncoder _posAlignEncoder = new RangeCoder.BitTreeEncoder(Base.kNumAlignBits);
-
- LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder();
- LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder();
-
- LiteralEncoder _literalEncoder = new LiteralEncoder();
-
- UInt32[] _matchDistances = new UInt32[Base.kMatchMaxLen * 2 + 2];
-
- UInt32 _numFastBytes = kNumFastBytesDefault;
- UInt32 _longestMatchLength;
- UInt32 _numDistancePairs;
-
- UInt32 _additionalOffset;
-
- UInt32 _optimumEndIndex;
- UInt32 _optimumCurrentIndex;
-
- bool _longestMatchWasFound;
-
- UInt32[] _posSlotPrices = new UInt32[1 << (Base.kNumPosSlotBits + Base.kNumLenToPosStatesBits)];
- UInt32[] _distancesPrices = new UInt32[Base.kNumFullDistances << Base.kNumLenToPosStatesBits];
- UInt32[] _alignPrices = new UInt32[Base.kAlignTableSize];
- UInt32 _alignPriceCount;
-
- UInt32 _distTableSize = (kDefaultDictionaryLogSize * 2);
-
- int _posStateBits = 2;
- UInt32 _posStateMask = (4 - 1);
- int _numLiteralPosStateBits = 0;
- int _numLiteralContextBits = 3;
-
- UInt32 _dictionarySize = (1 << kDefaultDictionaryLogSize);
- UInt32 _dictionarySizePrev = 0xFFFFFFFF;
- UInt32 _numFastBytesPrev = 0xFFFFFFFF;
-
- Int64 nowPos64;
- bool _finished;
- System.IO.Stream _inStream;
-
- EMatchFinderType _matchFinderType = EMatchFinderType.BT4;
- bool _writeEndMark = false;
-
- bool _needReleaseMFStream;
-
- void Create()
- {
- if (_matchFinder == null)
- {
- LZ.BinTree bt = new LZ.BinTree();
- int numHashBytes = 4;
- if (_matchFinderType == EMatchFinderType.BT2)
- numHashBytes = 2;
- bt.SetType(numHashBytes);
- _matchFinder = bt;
- }
- _literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits);
-
- if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)
- return;
- _matchFinder.Create(_dictionarySize, kNumOpts, _numFastBytes, Base.kMatchMaxLen + 1);
- _dictionarySizePrev = _dictionarySize;
- _numFastBytesPrev = _numFastBytes;
- }
-
- public Encoder()
- {
- for (int i = 0; i < kNumOpts; i++)
- _optimum[i] = new Optimal();
- for (int i = 0; i < Base.kNumLenToPosStates; i++)
- _posSlotEncoder[i] = new RangeCoder.BitTreeEncoder(Base.kNumPosSlotBits);
- }
-
- void SetWriteEndMarkerMode(bool writeEndMarker)
- {
- _writeEndMark = writeEndMarker;
- }
-
- void Init()
- {
- BaseInit();
- _rangeEncoder.Init();
-
- uint i;
- for (i = 0; i < Base.kNumStates; i++)
- {
- for (uint j = 0; j <= _posStateMask; j++)
- {
- uint complexState = (i << Base.kNumPosStatesBitsMax) + j;
- _isMatch[complexState].Init();
- _isRep0Long[complexState].Init();
- }
- _isRep[i].Init();
- _isRepG0[i].Init();
- _isRepG1[i].Init();
- _isRepG2[i].Init();
- }
- _literalEncoder.Init();
- for (i = 0; i < Base.kNumLenToPosStates; i++)
- _posSlotEncoder[i].Init();
- for (i = 0; i < Base.kNumFullDistances - Base.kEndPosModelIndex; i++)
- _posEncoders[i].Init();
-
- _lenEncoder.Init((UInt32)1 << _posStateBits);
- _repMatchLenEncoder.Init((UInt32)1 << _posStateBits);
-
- _posAlignEncoder.Init();
-
- _longestMatchWasFound = false;
- _optimumEndIndex = 0;
- _optimumCurrentIndex = 0;
- _additionalOffset = 0;
- }
-
- void ReadMatchDistances(out UInt32 lenRes, out UInt32 numDistancePairs)
- {
- lenRes = 0;
- numDistancePairs = _matchFinder.GetMatches(_matchDistances);
- if (numDistancePairs > 0)
- {
- lenRes = _matchDistances[numDistancePairs - 2];
- if (lenRes == _numFastBytes)
- lenRes += _matchFinder.GetMatchLen((int)lenRes - 1, _matchDistances[numDistancePairs - 1],
- Base.kMatchMaxLen - lenRes);
- }
- _additionalOffset++;
- }
-
-
- void MovePos(UInt32 num)
- {
- if (num > 0)
- {
- _matchFinder.Skip(num);
- _additionalOffset += num;
- }
- }
-
- UInt32 GetRepLen1Price(Base.State state, UInt32 posState)
- {
- return _isRepG0[state.Index].GetPrice0() +
- _isRep0Long[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0();
- }
-
- UInt32 GetPureRepPrice(UInt32 repIndex, Base.State state, UInt32 posState)
- {
- UInt32 price;
- if (repIndex == 0)
- {
- price = _isRepG0[state.Index].GetPrice0();
- price += _isRep0Long[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1();
- }
- else
- {
- price = _isRepG0[state.Index].GetPrice1();
- if (repIndex == 1)
- price += _isRepG1[state.Index].GetPrice0();
- else
- {
- price += _isRepG1[state.Index].GetPrice1();
- price += _isRepG2[state.Index].GetPrice(repIndex - 2);
- }
- }
- return price;
- }
-
- UInt32 GetRepPrice(UInt32 repIndex, UInt32 len, Base.State state, UInt32 posState)
- {
- UInt32 price = _repMatchLenEncoder.GetPrice(len - Base.kMatchMinLen, posState);
- return price + GetPureRepPrice(repIndex, state, posState);
- }
-
- UInt32 GetPosLenPrice(UInt32 pos, UInt32 len, UInt32 posState)
- {
- UInt32 price;
- UInt32 lenToPosState = Base.GetLenToPosState(len);
- if (pos < Base.kNumFullDistances)
- price = _distancesPrices[(lenToPosState * Base.kNumFullDistances) + pos];
- else
- price = _posSlotPrices[(lenToPosState << Base.kNumPosSlotBits) + GetPosSlot2(pos)] +
- _alignPrices[pos & Base.kAlignMask];
- return price + _lenEncoder.GetPrice(len - Base.kMatchMinLen, posState);
- }
-
- UInt32 Backward(out UInt32 backRes, UInt32 cur)
- {
- _optimumEndIndex = cur;
- UInt32 posMem = _optimum[cur].PosPrev;
- UInt32 backMem = _optimum[cur].BackPrev;
- do
- {
- if (_optimum[cur].Prev1IsChar)
- {
- _optimum[posMem].MakeAsChar();
- _optimum[posMem].PosPrev = posMem - 1;
- if (_optimum[cur].Prev2)
- {
- _optimum[posMem - 1].Prev1IsChar = false;
- _optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;
- _optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;
- }
- }
- UInt32 posPrev = posMem;
- UInt32 backCur = backMem;
-
- backMem = _optimum[posPrev].BackPrev;
- posMem = _optimum[posPrev].PosPrev;
-
- _optimum[posPrev].BackPrev = backCur;
- _optimum[posPrev].PosPrev = cur;
- cur = posPrev;
- }
- while (cur > 0);
- backRes = _optimum[0].BackPrev;
- _optimumCurrentIndex = _optimum[0].PosPrev;
- return _optimumCurrentIndex;
- }
-
- UInt32[] reps = new UInt32[Base.kNumRepDistances];
- UInt32[] repLens = new UInt32[Base.kNumRepDistances];
-
-
- UInt32 GetOptimum(UInt32 position, out UInt32 backRes)
- {
- if (_optimumEndIndex != _optimumCurrentIndex)
- {
- UInt32 lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex;
- backRes = _optimum[_optimumCurrentIndex].BackPrev;
- _optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev;
- return lenRes;
- }
- _optimumCurrentIndex = _optimumEndIndex = 0;
-
- UInt32 lenMain, numDistancePairs;
- if (!_longestMatchWasFound)
- {
- ReadMatchDistances(out lenMain, out numDistancePairs);
- }
- else
- {
- lenMain = _longestMatchLength;
- numDistancePairs = _numDistancePairs;
- _longestMatchWasFound = false;
- }
-
- UInt32 numAvailableBytes = _matchFinder.GetNumAvailableBytes() + 1;
- if (numAvailableBytes < 2)
- {
- backRes = 0xFFFFFFFF;
- return 1;
- }
- if (numAvailableBytes > Base.kMatchMaxLen)
- numAvailableBytes = Base.kMatchMaxLen;
-
- UInt32 repMaxIndex = 0;
- UInt32 i;
- for (i = 0; i < Base.kNumRepDistances; i++)
- {
- reps[i] = _repDistances[i];
- repLens[i] = _matchFinder.GetMatchLen(0 - 1, reps[i], Base.kMatchMaxLen);
- if (repLens[i] > repLens[repMaxIndex])
- repMaxIndex = i;
- }
- if (repLens[repMaxIndex] >= _numFastBytes)
- {
- backRes = repMaxIndex;
- UInt32 lenRes = repLens[repMaxIndex];
- MovePos(lenRes - 1);
- return lenRes;
- }
-
- if (lenMain >= _numFastBytes)
- {
- backRes = _matchDistances[numDistancePairs - 1] + Base.kNumRepDistances;
- MovePos(lenMain - 1);
- return lenMain;
- }
-
- Byte currentByte = _matchFinder.GetIndexByte(0 - 1);
- Byte matchByte = _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - 1));
-
- if (lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)
- {
- backRes = (UInt32)0xFFFFFFFF;
- return 1;
- }
-
- _optimum[0].State = _state;
-
- UInt32 posState = (position & _posStateMask);
-
- _optimum[1].Price = _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0() +
- _literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!_state.IsCharState(), matchByte, currentByte);
- _optimum[1].MakeAsChar();
-
- UInt32 matchPrice = _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1();
- UInt32 repMatchPrice = matchPrice + _isRep[_state.Index].GetPrice1();
-
- if (matchByte == currentByte)
- {
- UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);
- if (shortRepPrice < _optimum[1].Price)
- {
- _optimum[1].Price = shortRepPrice;
- _optimum[1].MakeAsShortRep();
- }
- }
-
- UInt32 lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]);
-
- if(lenEnd < 2)
- {
- backRes = _optimum[1].BackPrev;
- return 1;
- }
-
- _optimum[1].PosPrev = 0;
-
- _optimum[0].Backs0 = reps[0];
- _optimum[0].Backs1 = reps[1];
- _optimum[0].Backs2 = reps[2];
- _optimum[0].Backs3 = reps[3];
-
- UInt32 len = lenEnd;
- do
- _optimum[len--].Price = kIfinityPrice;
- while (len >= 2);
-
- for (i = 0; i < Base.kNumRepDistances; i++)
- {
- UInt32 repLen = repLens[i];
- if (repLen < 2)
- continue;
- UInt32 price = repMatchPrice + GetPureRepPrice(i, _state, posState);
- do
- {
- UInt32 curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState);
- Optimal optimum = _optimum[repLen];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = 0;
- optimum.BackPrev = i;
- optimum.Prev1IsChar = false;
- }
- }
- while (--repLen >= 2);
- }
-
- UInt32 normalMatchPrice = matchPrice + _isRep[_state.Index].GetPrice0();
-
- len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);
- if (len <= lenMain)
- {
- UInt32 offs = 0;
- while (len > _matchDistances[offs])
- offs += 2;
- for (; ; len++)
- {
- UInt32 distance = _matchDistances[offs + 1];
- UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState);
- Optimal optimum = _optimum[len];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = 0;
- optimum.BackPrev = distance + Base.kNumRepDistances;
- optimum.Prev1IsChar = false;
- }
- if (len == _matchDistances[offs])
- {
- offs += 2;
- if (offs == numDistancePairs)
- break;
- }
- }
- }
-
- UInt32 cur = 0;
-
- while (true)
- {
- cur++;
- if (cur == lenEnd)
- return Backward(out backRes, cur);
- UInt32 newLen;
- ReadMatchDistances(out newLen, out numDistancePairs);
- if (newLen >= _numFastBytes)
- {
- _numDistancePairs = numDistancePairs;
- _longestMatchLength = newLen;
- _longestMatchWasFound = true;
- return Backward(out backRes, cur);
- }
- position++;
- UInt32 posPrev = _optimum[cur].PosPrev;
- Base.State state;
- if (_optimum[cur].Prev1IsChar)
- {
- posPrev--;
- if (_optimum[cur].Prev2)
- {
- state = _optimum[_optimum[cur].PosPrev2].State;
- if (_optimum[cur].BackPrev2 < Base.kNumRepDistances)
- state.UpdateRep();
- else
- state.UpdateMatch();
- }
- else
- state = _optimum[posPrev].State;
- state.UpdateChar();
- }
- else
- state = _optimum[posPrev].State;
- if (posPrev == cur - 1)
- {
- if (_optimum[cur].IsShortRep())
- state.UpdateShortRep();
- else
- state.UpdateChar();
- }
- else
- {
- UInt32 pos;
- if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2)
- {
- posPrev = _optimum[cur].PosPrev2;
- pos = _optimum[cur].BackPrev2;
- state.UpdateRep();
- }
- else
- {
- pos = _optimum[cur].BackPrev;
- if (pos < Base.kNumRepDistances)
- state.UpdateRep();
- else
- state.UpdateMatch();
- }
- Optimal opt = _optimum[posPrev];
- if (pos < Base.kNumRepDistances)
- {
- if (pos == 0)
- {
- reps[0] = opt.Backs0;
- reps[1] = opt.Backs1;
- reps[2] = opt.Backs2;
- reps[3] = opt.Backs3;
- }
- else if (pos == 1)
- {
- reps[0] = opt.Backs1;
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs2;
- reps[3] = opt.Backs3;
- }
- else if (pos == 2)
- {
- reps[0] = opt.Backs2;
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs1;
- reps[3] = opt.Backs3;
- }
- else
- {
- reps[0] = opt.Backs3;
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs1;
- reps[3] = opt.Backs2;
- }
- }
- else
- {
- reps[0] = (pos - Base.kNumRepDistances);
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs1;
- reps[3] = opt.Backs2;
- }
- }
- _optimum[cur].State = state;
- _optimum[cur].Backs0 = reps[0];
- _optimum[cur].Backs1 = reps[1];
- _optimum[cur].Backs2 = reps[2];
- _optimum[cur].Backs3 = reps[3];
- UInt32 curPrice = _optimum[cur].Price;
-
- currentByte = _matchFinder.GetIndexByte(0 - 1);
- matchByte = _matchFinder.GetIndexByte((Int32)(0 - reps[0] - 1 - 1));
-
- posState = (position & _posStateMask);
-
- UInt32 curAnd1Price = curPrice +
- _isMatch[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice0() +
- _literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(0 - 2)).
- GetPrice(!state.IsCharState(), matchByte, currentByte);
-
- Optimal nextOptimum = _optimum[cur + 1];
-
- bool nextIsChar = false;
- if (curAnd1Price < nextOptimum.Price)
- {
- nextOptimum.Price = curAnd1Price;
- nextOptimum.PosPrev = cur;
- nextOptimum.MakeAsChar();
- nextIsChar = true;
- }
-
- matchPrice = curPrice + _isMatch[(state.Index << Base.kNumPosStatesBitsMax) + posState].GetPrice1();
- repMatchPrice = matchPrice + _isRep[state.Index].GetPrice1();
-
- if (matchByte == currentByte &&
- !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))
- {
- UInt32 shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);
- if (shortRepPrice <= nextOptimum.Price)
- {
- nextOptimum.Price = shortRepPrice;
- nextOptimum.PosPrev = cur;
- nextOptimum.MakeAsShortRep();
- nextIsChar = true;
- }
- }
-
- UInt32 numAvailableBytesFull = _matchFinder.GetNumAvailableBytes() + 1;
- numAvailableBytesFull = Math.Min(kNumOpts - 1 - cur, numAvailableBytesFull);
- numAvailableBytes = numAvailableBytesFull;
-
- if (numAvailableBytes < 2)
- continue;
- if (numAvailableBytes > _numFastBytes)
- numAvailableBytes = _numFastBytes;
- if (!nextIsChar && matchByte != currentByte)
- {
- // try Literal + rep0
- UInt32 t = Math.Min(numAvailableBytesFull - 1, _numFastBytes);
- UInt32 lenTest2 = _matchFinder.GetMatchLen(0, reps[0], t);
- if (lenTest2 >= 2)
- {
- Base.State state2 = state;
- state2.UpdateChar();
- UInt32 posStateNext = (position + 1) & _posStateMask;
- UInt32 nextRepMatchPrice = curAnd1Price +
- _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1() +
- _isRep[state2.Index].GetPrice1();
- {
- UInt32 offset = cur + 1 + lenTest2;
- while (lenEnd < offset)
- _optimum[++lenEnd].Price = kIfinityPrice;
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(
- 0, lenTest2, state2, posStateNext);
- Optimal optimum = _optimum[offset];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur + 1;
- optimum.BackPrev = 0;
- optimum.Prev1IsChar = true;
- optimum.Prev2 = false;
- }
- }
- }
- }
-
- UInt32 startLen = 2; // speed optimization
-
- for (UInt32 repIndex = 0; repIndex < Base.kNumRepDistances; repIndex++)
- {
- UInt32 lenTest = _matchFinder.GetMatchLen(0 - 1, reps[repIndex], numAvailableBytes);
- if (lenTest < 2)
- continue;
- UInt32 lenTestTemp = lenTest;
- do
- {
- while (lenEnd < cur + lenTest)
- _optimum[++lenEnd].Price = kIfinityPrice;
- UInt32 curAndLenPrice = repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState);
- Optimal optimum = _optimum[cur + lenTest];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur;
- optimum.BackPrev = repIndex;
- optimum.Prev1IsChar = false;
- }
- }
- while(--lenTest >= 2);
- lenTest = lenTestTemp;
-
- if (repIndex == 0)
- startLen = lenTest + 1;
-
- // if (_maxMode)
- if (lenTest < numAvailableBytesFull)
- {
- UInt32 t = Math.Min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);
- UInt32 lenTest2 = _matchFinder.GetMatchLen((Int32)lenTest, reps[repIndex], t);
- if (lenTest2 >= 2)
- {
- Base.State state2 = state;
- state2.UpdateRep();
- UInt32 posStateNext = (position + lenTest) & _posStateMask;
- UInt32 curAndLenCharPrice =
- repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState) +
- _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice0() +
- _literalEncoder.GetSubCoder(position + lenTest,
- _matchFinder.GetIndexByte((Int32)lenTest - 1 - 1)).GetPrice(true,
- _matchFinder.GetIndexByte((Int32)((Int32)lenTest - 1 - (Int32)(reps[repIndex] + 1))),
- _matchFinder.GetIndexByte((Int32)lenTest - 1));
- state2.UpdateChar();
- posStateNext = (position + lenTest + 1) & _posStateMask;
- UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1();
- UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1();
-
- // for(; lenTest2 >= 2; lenTest2--)
- {
- UInt32 offset = lenTest + 1 + lenTest2;
- while(lenEnd < cur + offset)
- _optimum[++lenEnd].Price = kIfinityPrice;
- UInt32 curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);
- Optimal optimum = _optimum[cur + offset];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur + lenTest + 1;
- optimum.BackPrev = 0;
- optimum.Prev1IsChar = true;
- optimum.Prev2 = true;
- optimum.PosPrev2 = cur;
- optimum.BackPrev2 = repIndex;
- }
- }
- }
- }
- }
-
- if (newLen > numAvailableBytes)
- {
- newLen = numAvailableBytes;
- for (numDistancePairs = 0; newLen > _matchDistances[numDistancePairs]; numDistancePairs += 2) ;
- _matchDistances[numDistancePairs] = newLen;
- numDistancePairs += 2;
- }
- if (newLen >= startLen)
- {
- normalMatchPrice = matchPrice + _isRep[state.Index].GetPrice0();
- while (lenEnd < cur + newLen)
- _optimum[++lenEnd].Price = kIfinityPrice;
-
- UInt32 offs = 0;
- while (startLen > _matchDistances[offs])
- offs += 2;
-
- for (UInt32 lenTest = startLen; ; lenTest++)
- {
- UInt32 curBack = _matchDistances[offs + 1];
- UInt32 curAndLenPrice = normalMatchPrice + GetPosLenPrice(curBack, lenTest, posState);
- Optimal optimum = _optimum[cur + lenTest];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur;
- optimum.BackPrev = curBack + Base.kNumRepDistances;
- optimum.Prev1IsChar = false;
- }
-
- if (lenTest == _matchDistances[offs])
- {
- if (lenTest < numAvailableBytesFull)
- {
- UInt32 t = Math.Min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);
- UInt32 lenTest2 = _matchFinder.GetMatchLen((Int32)lenTest, curBack, t);
- if (lenTest2 >= 2)
- {
- Base.State state2 = state;
- state2.UpdateMatch();
- UInt32 posStateNext = (position + lenTest) & _posStateMask;
- UInt32 curAndLenCharPrice = curAndLenPrice +
- _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice0() +
- _literalEncoder.GetSubCoder(position + lenTest,
- _matchFinder.GetIndexByte((Int32)lenTest - 1 - 1)).
- GetPrice(true,
- _matchFinder.GetIndexByte((Int32)lenTest - (Int32)(curBack + 1) - 1),
- _matchFinder.GetIndexByte((Int32)lenTest - 1));
- state2.UpdateChar();
- posStateNext = (position + lenTest + 1) & _posStateMask;
- UInt32 nextMatchPrice = curAndLenCharPrice + _isMatch[(state2.Index << Base.kNumPosStatesBitsMax) + posStateNext].GetPrice1();
- UInt32 nextRepMatchPrice = nextMatchPrice + _isRep[state2.Index].GetPrice1();
-
- UInt32 offset = lenTest + 1 + lenTest2;
- while (lenEnd < cur + offset)
- _optimum[++lenEnd].Price = kIfinityPrice;
- curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);
- optimum = _optimum[cur + offset];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur + lenTest + 1;
- optimum.BackPrev = 0;
- optimum.Prev1IsChar = true;
- optimum.Prev2 = true;
- optimum.PosPrev2 = cur;
- optimum.BackPrev2 = curBack + Base.kNumRepDistances;
- }
- }
- }
- offs += 2;
- if (offs == numDistancePairs)
- break;
- }
- }
- }
- }
- }
-
- bool ChangePair(UInt32 smallDist, UInt32 bigDist)
- {
- const int kDif = 7;
- return (smallDist < ((UInt32)(1) << (32 - kDif)) && bigDist >= (smallDist << kDif));
- }
-
- void WriteEndMarker(UInt32 posState)
- {
- if (!_writeEndMark)
- return;
-
- _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].Encode(_rangeEncoder, 1);
- _isRep[_state.Index].Encode(_rangeEncoder, 0);
- _state.UpdateMatch();
- UInt32 len = Base.kMatchMinLen;
- _lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
- UInt32 posSlot = (1 << Base.kNumPosSlotBits) - 1;
- UInt32 lenToPosState = Base.GetLenToPosState(len);
- _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
- int footerBits = 30;
- UInt32 posReduced = (((UInt32)1) << footerBits) - 1;
- _rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);
- _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);
- }
-
- void Flush(UInt32 nowPos)
- {
- ReleaseMFStream();
- WriteEndMarker(nowPos & _posStateMask);
- _rangeEncoder.FlushData();
- _rangeEncoder.FlushStream();
- }
-
- public void CodeOneBlock(out Int64 inSize, out Int64 outSize, out bool finished)
- {
- inSize = 0;
- outSize = 0;
- finished = true;
-
- if (_inStream != null)
- {
- _matchFinder.SetStream(_inStream);
- _matchFinder.Init();
- _needReleaseMFStream = true;
- _inStream = null;
- if (_trainSize > 0)
- _matchFinder.Skip(_trainSize);
- }
-
- if (_finished)
- return;
- _finished = true;
-
-
- Int64 progressPosValuePrev = nowPos64;
- if (nowPos64 == 0)
- {
- if (_matchFinder.GetNumAvailableBytes() == 0)
- {
- Flush((UInt32)nowPos64);
- return;
- }
- UInt32 len, numDistancePairs; // it's not used
- ReadMatchDistances(out len, out numDistancePairs);
- UInt32 posState = (UInt32)(nowPos64) & _posStateMask;
- _isMatch[(_state.Index << Base.kNumPosStatesBitsMax) + posState].Encode(_rangeEncoder, 0);
- _state.UpdateChar();
- Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset));
- _literalEncoder.GetSubCoder((UInt32)(nowPos64), _previousByte).Encode(_rangeEncoder, curByte);
- _previousByte = curByte;
- _additionalOffset--;
- nowPos64++;
- }
- if (_matchFinder.GetNumAvailableBytes() == 0)
- {
- Flush((UInt32)nowPos64);
- return;
- }
- while (true)
- {
- UInt32 pos;
- UInt32 len = GetOptimum((UInt32)nowPos64, out pos);
-
- UInt32 posState = ((UInt32)nowPos64) & _posStateMask;
- UInt32 complexState = (_state.Index << Base.kNumPosStatesBitsMax) + posState;
- if (len == 1 && pos == 0xFFFFFFFF)
- {
- _isMatch[complexState].Encode(_rangeEncoder, 0);
- Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset));
- LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((UInt32)nowPos64, _previousByte);
- if (!_state.IsCharState())
- {
- Byte matchByte = _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - _additionalOffset));
- subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte);
- }
- else
- subCoder.Encode(_rangeEncoder, curByte);
- _previousByte = curByte;
- _state.UpdateChar();
- }
- else
- {
- _isMatch[complexState].Encode(_rangeEncoder, 1);
- if (pos < Base.kNumRepDistances)
- {
- _isRep[_state.Index].Encode(_rangeEncoder, 1);
- if (pos == 0)
- {
- _isRepG0[_state.Index].Encode(_rangeEncoder, 0);
- if (len == 1)
- _isRep0Long[complexState].Encode(_rangeEncoder, 0);
- else
- _isRep0Long[complexState].Encode(_rangeEncoder, 1);
- }
- else
- {
- _isRepG0[_state.Index].Encode(_rangeEncoder, 1);
- if (pos == 1)
- _isRepG1[_state.Index].Encode(_rangeEncoder, 0);
- else
- {
- _isRepG1[_state.Index].Encode(_rangeEncoder, 1);
- _isRepG2[_state.Index].Encode(_rangeEncoder, pos - 2);
- }
- }
- if (len == 1)
- _state.UpdateShortRep();
- else
- {
- _repMatchLenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
- _state.UpdateRep();
- }
- UInt32 distance = _repDistances[pos];
- if (pos != 0)
- {
- for (UInt32 i = pos; i >= 1; i--)
- _repDistances[i] = _repDistances[i - 1];
- _repDistances[0] = distance;
- }
- }
- else
- {
- _isRep[_state.Index].Encode(_rangeEncoder, 0);
- _state.UpdateMatch();
- _lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
- pos -= Base.kNumRepDistances;
- UInt32 posSlot = GetPosSlot(pos);
- UInt32 lenToPosState = Base.GetLenToPosState(len);
- _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
-
- if (posSlot >= Base.kStartPosModelIndex)
- {
- int footerBits = (int)((posSlot >> 1) - 1);
- UInt32 baseVal = ((2 | (posSlot & 1)) << footerBits);
- UInt32 posReduced = pos - baseVal;
-
- if (posSlot < Base.kEndPosModelIndex)
- RangeCoder.BitTreeEncoder.ReverseEncode(_posEncoders,
- baseVal - posSlot - 1, _rangeEncoder, footerBits, posReduced);
- else
- {
- _rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);
- _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);
- _alignPriceCount++;
- }
- }
- UInt32 distance = pos;
- for (UInt32 i = Base.kNumRepDistances - 1; i >= 1; i--)
- _repDistances[i] = _repDistances[i - 1];
- _repDistances[0] = distance;
- _matchPriceCount++;
- }
- _previousByte = _matchFinder.GetIndexByte((Int32)(len - 1 - _additionalOffset));
- }
- _additionalOffset -= len;
- nowPos64 += len;
- if (_additionalOffset == 0)
- {
- // if (!_fastMode)
- if (_matchPriceCount >= (1 << 7))
- FillDistancesPrices();
- if (_alignPriceCount >= Base.kAlignTableSize)
- FillAlignPrices();
- inSize = nowPos64;
- outSize = _rangeEncoder.GetProcessedSizeAdd();
- if (_matchFinder.GetNumAvailableBytes() == 0)
- {
- Flush((UInt32)nowPos64);
- return;
- }
-
- if (nowPos64 - progressPosValuePrev >= (1 << 12))
- {
- _finished = false;
- finished = false;
- return;
- }
- }
- }
- }
-
- void ReleaseMFStream()
- {
- if (_matchFinder != null && _needReleaseMFStream)
- {
- _matchFinder.ReleaseStream();
- _needReleaseMFStream = false;
- }
- }
-
- void SetOutStream(System.IO.Stream outStream) { _rangeEncoder.SetStream(outStream); }
- void ReleaseOutStream() { _rangeEncoder.ReleaseStream(); }
-
- void ReleaseStreams()
- {
- ReleaseMFStream();
- ReleaseOutStream();
- }
-
- void SetStreams(System.IO.Stream inStream, System.IO.Stream outStream,
- Int64 inSize, Int64 outSize)
- {
- _inStream = inStream;
- _finished = false;
- Create();
- SetOutStream(outStream);
- Init();
-
- // if (!_fastMode)
- {
- FillDistancesPrices();
- FillAlignPrices();
- }
-
- _lenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);
- _lenEncoder.UpdateTables((UInt32)1 << _posStateBits);
- _repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);
- _repMatchLenEncoder.UpdateTables((UInt32)1 << _posStateBits);
-
- nowPos64 = 0;
- }
-
-
- public void Code(System.IO.Stream inStream, System.IO.Stream outStream,
- Int64 inSize, Int64 outSize, ICodeProgress progress)
- {
- _needReleaseMFStream = false;
- try
- {
- SetStreams(inStream, outStream, inSize, outSize);
- while (true)
- {
- Int64 processedInSize;
- Int64 processedOutSize;
- bool finished;
- CodeOneBlock(out processedInSize, out processedOutSize, out finished);
- if (finished)
- return;
- if (progress != null)
- {
- progress.SetProgress(processedInSize, processedOutSize);
- }
- }
- }
- finally
- {
- ReleaseStreams();
- }
- }
-
- const int kPropSize = 5;
- Byte[] properties = new Byte[kPropSize];
-
- public void WriteCoderProperties(System.IO.Stream outStream)
- {
- properties[0] = (Byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
- for (int i = 0; i < 4; i++)
- properties[1 + i] = (Byte)((_dictionarySize >> (8 * i)) & 0xFF);
- outStream.Write(properties, 0, kPropSize);
- }
-
- UInt32[] tempPrices = new UInt32[Base.kNumFullDistances];
- UInt32 _matchPriceCount;
-
- void FillDistancesPrices()
- {
- for (UInt32 i = Base.kStartPosModelIndex; i < Base.kNumFullDistances; i++)
- {
- UInt32 posSlot = GetPosSlot(i);
- int footerBits = (int)((posSlot >> 1) - 1);
- UInt32 baseVal = ((2 | (posSlot & 1)) << footerBits);
- tempPrices[i] = BitTreeEncoder.ReverseGetPrice(_posEncoders,
- baseVal - posSlot - 1, footerBits, i - baseVal);
- }
-
- for (UInt32 lenToPosState = 0; lenToPosState < Base.kNumLenToPosStates; lenToPosState++)
- {
- UInt32 posSlot;
- RangeCoder.BitTreeEncoder encoder = _posSlotEncoder[lenToPosState];
-
- UInt32 st = (lenToPosState << Base.kNumPosSlotBits);
- for (posSlot = 0; posSlot < _distTableSize; posSlot++)
- _posSlotPrices[st + posSlot] = encoder.GetPrice(posSlot);
- for (posSlot = Base.kEndPosModelIndex; posSlot < _distTableSize; posSlot++)
- _posSlotPrices[st + posSlot] += ((((posSlot >> 1) - 1) - Base.kNumAlignBits) << RangeCoder.BitEncoder.kNumBitPriceShiftBits);
-
- UInt32 st2 = lenToPosState * Base.kNumFullDistances;
- UInt32 i;
- for (i = 0; i < Base.kStartPosModelIndex; i++)
- _distancesPrices[st2 + i] = _posSlotPrices[st + i];
- for (; i < Base.kNumFullDistances; i++)
- _distancesPrices[st2 + i] = _posSlotPrices[st + GetPosSlot(i)] + tempPrices[i];
- }
- _matchPriceCount = 0;
- }
-
- void FillAlignPrices()
- {
- for (UInt32 i = 0; i < Base.kAlignTableSize; i++)
- _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);
- _alignPriceCount = 0;
- }
-
-
- static string[] kMatchFinderIDs =
- {
- "BT2",
- "BT4",
- };
-
- static int FindMatchFinder(string s)
- {
- for (int m = 0; m < kMatchFinderIDs.Length; m++)
- if (s == kMatchFinderIDs[m])
- return m;
- return -1;
- }
-
- public void SetCoderProperties(CoderPropID[] propIDs, object[] properties)
- {
- for (UInt32 i = 0; i < properties.Length; i++)
- {
- object prop = properties[i];
- switch (propIDs[i])
- {
- case CoderPropID.NumFastBytes:
- {
- if (!(prop is Int32))
- throw new InvalidParamException();
- Int32 numFastBytes = (Int32)prop;
- if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen)
- throw new InvalidParamException();
- _numFastBytes = (UInt32)numFastBytes;
- break;
- }
- case CoderPropID.Algorithm:
- {
- /*
- if (!(prop is Int32))
- throw new InvalidParamException();
- Int32 maximize = (Int32)prop;
- _fastMode = (maximize == 0);
- _maxMode = (maximize >= 2);
- */
- break;
- }
- case CoderPropID.MatchFinder:
- {
- if (!(prop is String))
- throw new InvalidParamException();
- EMatchFinderType matchFinderIndexPrev = _matchFinderType;
- int m = FindMatchFinder(((string)prop).ToUpper());
- if (m < 0)
- throw new InvalidParamException();
- _matchFinderType = (EMatchFinderType)m;
- if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType)
- {
- _dictionarySizePrev = 0xFFFFFFFF;
- _matchFinder = null;
- }
- break;
- }
- case CoderPropID.DictionarySize:
- {
- const int kDicLogSizeMaxCompress = 30;
- if (!(prop is Int32))
- throw new InvalidParamException(); ;
- Int32 dictionarySize = (Int32)prop;
- if (dictionarySize < (UInt32)(1 << Base.kDicLogSizeMin) ||
- dictionarySize > (UInt32)(1 << kDicLogSizeMaxCompress))
- throw new InvalidParamException();
- _dictionarySize = (UInt32)dictionarySize;
- int dicLogSize;
- for (dicLogSize = 0; dicLogSize < (UInt32)kDicLogSizeMaxCompress; dicLogSize++)
- if (dictionarySize <= ((UInt32)(1) << dicLogSize))
- break;
- _distTableSize = (UInt32)dicLogSize * 2;
- break;
- }
- case CoderPropID.PosStateBits:
- {
- if (!(prop is Int32))
- throw new InvalidParamException();
- Int32 v = (Int32)prop;
- if (v < 0 || v > (UInt32)Base.kNumPosStatesBitsEncodingMax)
- throw new InvalidParamException();
- _posStateBits = (int)v;
- _posStateMask = (((UInt32)1) << (int)_posStateBits) - 1;
- break;
- }
- case CoderPropID.LitPosBits:
- {
- if (!(prop is Int32))
- throw new InvalidParamException();
- Int32 v = (Int32)prop;
- if (v < 0 || v > (UInt32)Base.kNumLitPosStatesBitsEncodingMax)
- throw new InvalidParamException();
- _numLiteralPosStateBits = (int)v;
- break;
- }
- case CoderPropID.LitContextBits:
- {
- if (!(prop is Int32))
- throw new InvalidParamException();
- Int32 v = (Int32)prop;
- if (v < 0 || v > (UInt32)Base.kNumLitContextBitsMax)
- throw new InvalidParamException(); ;
- _numLiteralContextBits = (int)v;
- break;
- }
- case CoderPropID.EndMarker:
- {
- if (!(prop is Boolean))
- throw new InvalidParamException();
- SetWriteEndMarkerMode((Boolean)prop);
- break;
- }
- default:
- throw new InvalidParamException();
- }
- }
- }
-
- uint _trainSize = 0;
- public void SetTrainSize(uint trainSize)
- {
- _trainSize = trainSize;
- }
-
- }
-}
diff --git a/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs b/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs
deleted file mode 100644
index 8aa4462..0000000
--- a/CS/7zip/Compress/LzmaAlone/LzmaAlone.cs
+++ /dev/null
@@ -1,364 +0,0 @@
-using System;
-using System.IO;
-namespace SevenZip
-{
- using CommandLineParser;
-
- public class CDoubleStream: Stream
- {
- public System.IO.Stream s1;
- public System.IO.Stream s2;
- public int fileIndex;
- public long skipSize;
-
- public override bool CanRead { get { return true; }}
- public override bool CanWrite { get { return false; }}
- public override bool CanSeek { get { return false; }}
- public override long Length { get { return s1.Length + s2.Length - skipSize; } }
- public override long Position
- {
- get { return 0; }
- set { }
- }
- public override void Flush() { }
- public override int Read(byte[] buffer, int offset, int count)
- {
- int numTotal = 0;
- while (count > 0)
- {
- if (fileIndex == 0)
- {
- int num = s1.Read(buffer, offset, count);
- offset += num;
- count -= num;
- numTotal += num;
- if (num == 0)
- fileIndex++;
- }
- if (fileIndex == 1)
- {
- numTotal += s2.Read(buffer, offset, count);
- return numTotal;
- }
- }
- return numTotal;
- }
- public override void Write(byte[] buffer, int offset, int count)
- {
- throw (new Exception("can't Write"));
- }
- public override long Seek(long offset, System.IO.SeekOrigin origin)
- {
- throw (new Exception("can't Seek"));
- }
- public override void SetLength(long value)
- {
- throw (new Exception("can't SetLength"));
- }
- }
-
- class LzmaAlone
- {
- enum Key
- {
- Help1 = 0,
- Help2,
- Mode,
- Dictionary,
- FastBytes,
- LitContext,
- LitPos,
- PosBits,
- MatchFinder,
- EOS,
- StdIn,
- StdOut,
- Train
- };
-
- static void PrintHelp()
- {
- System.Console.WriteLine("\nUsage: LZMA <e|d> [<switches>...] inputFile outputFile\n" +
- " e: encode file\n" +
- " d: decode file\n" +
- " b: Benchmark\n" +
- "<Switches>\n" +
- // " -a{N}: set compression mode - [0, 1], default: 1 (max)\n" +
- " -d{N}: set dictionary - [0, 29], default: 23 (8MB)\n" +
- " -fb{N}: set number of fast bytes - [5, 273], default: 128\n" +
- " -lc{N}: set number of literal context bits - [0, 8], default: 3\n" +
- " -lp{N}: set number of literal pos bits - [0, 4], default: 0\n" +
- " -pb{N}: set number of pos bits - [0, 4], default: 2\n" +
- " -mf{MF_ID}: set Match Finder: [bt2, bt4], default: bt4\n" +
- " -eos: write End Of Stream marker\n"
- // + " -si: read data from stdin\n"
- // + " -so: write data to stdout\n"
- );
- }
-
- static bool GetNumber(string s, out Int32 v)
- {
- v = 0;
- for (int i = 0; i < s.Length; i++)
- {
- char c = s[i];
- if (c < '0' || c > '9')
- return false;
- v *= 10;
- v += (Int32)(c - '0');
- }
- return true;
- }
-
- static int IncorrectCommand()
- {
- throw (new Exception("Command line error"));
- // System.Console.WriteLine("\nCommand line error\n");
- // return 1;
- }
- static int Main2(string[] args)
- {
- System.Console.WriteLine("\nLZMA# 4.61 2008-11-23\n");
-
- if (args.Length == 0)
- {
- PrintHelp();
- return 0;
- }
-
- SwitchForm[] kSwitchForms = new SwitchForm[13];
- int sw = 0;
- kSwitchForms[sw++] = new SwitchForm("?", SwitchType.Simple, false);
- kSwitchForms[sw++] = new SwitchForm("H", SwitchType.Simple, false);
- kSwitchForms[sw++] = new SwitchForm("A", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("D", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("FB", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("LC", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("LP", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("PB", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("MF", SwitchType.UnLimitedPostString, false, 1);
- kSwitchForms[sw++] = new SwitchForm("EOS", SwitchType.Simple, false);
- kSwitchForms[sw++] = new SwitchForm("SI", SwitchType.Simple, false);
- kSwitchForms[sw++] = new SwitchForm("SO", SwitchType.Simple, false);
- kSwitchForms[sw++] = new SwitchForm("T", SwitchType.UnLimitedPostString, false, 1);
-
-
- Parser parser = new Parser(sw);
- try
- {
- parser.ParseStrings(kSwitchForms, args);
- }
- catch
- {
- return IncorrectCommand();
- }
-
- if (parser[(int)Key.Help1].ThereIs || parser[(int)Key.Help2].ThereIs)
- {
- PrintHelp();
- return 0;
- }
-
- System.Collections.ArrayList nonSwitchStrings = parser.NonSwitchStrings;
-
- int paramIndex = 0;
- if (paramIndex >= nonSwitchStrings.Count)
- return IncorrectCommand();
- string command = (string)nonSwitchStrings[paramIndex++];
- command = command.ToLower();
-
- bool dictionaryIsDefined = false;
- Int32 dictionary = 1 << 21;
- if (parser[(int)Key.Dictionary].ThereIs)
- {
- Int32 dicLog;
- if (!GetNumber((string)parser[(int)Key.Dictionary].PostStrings[0], out dicLog))
- IncorrectCommand();
- dictionary = (Int32)1 << dicLog;
- dictionaryIsDefined = true;
- }
- string mf = "bt4";
- if (parser[(int)Key.MatchFinder].ThereIs)
- mf = (string)parser[(int)Key.MatchFinder].PostStrings[0];
- mf = mf.ToLower();
-
- if (command == "b")
- {
- const Int32 kNumDefaultItereations = 10;
- Int32 numIterations = kNumDefaultItereations;
- if (paramIndex < nonSwitchStrings.Count)
- if (!GetNumber((string)nonSwitchStrings[paramIndex++], out numIterations))
- numIterations = kNumDefaultItereations;
- return LzmaBench.LzmaBenchmark(numIterations, (UInt32)dictionary);
- }
-
- string train = "";
- if (parser[(int)Key.Train].ThereIs)
- train = (string)parser[(int)Key.Train].PostStrings[0];
-
- bool encodeMode = false;
- if (command == "e")
- encodeMode = true;
- else if (command == "d")
- encodeMode = false;
- else
- IncorrectCommand();
-
- bool stdInMode = parser[(int)Key.StdIn].ThereIs;
- bool stdOutMode = parser[(int)Key.StdOut].ThereIs;
-
- Stream inStream = null;
- if (stdInMode)
- {
- throw (new Exception("Not implemeted"));
- }
- else
- {
- if (paramIndex >= nonSwitchStrings.Count)
- IncorrectCommand();
- string inputName = (string)nonSwitchStrings[paramIndex++];
- inStream = new FileStream(inputName, FileMode.Open, FileAccess.Read);
- }
-
- FileStream outStream = null;
- if (stdOutMode)
- {
- throw (new Exception("Not implemeted"));
- }
- else
- {
- if (paramIndex >= nonSwitchStrings.Count)
- IncorrectCommand();
- string outputName = (string)nonSwitchStrings[paramIndex++];
- outStream = new FileStream(outputName, FileMode.Create, FileAccess.Write);
- }
-
- FileStream trainStream = null;
- if (train.Length != 0)
- trainStream = new FileStream(train, FileMode.Open, FileAccess.Read);
-
- if (encodeMode)
- {
- if (!dictionaryIsDefined)
- dictionary = 1 << 23;
-
- Int32 posStateBits = 2;
- Int32 litContextBits = 3; // for normal files
- // UInt32 litContextBits = 0; // for 32-bit data
- Int32 litPosBits = 0;
- // UInt32 litPosBits = 2; // for 32-bit data
- Int32 algorithm = 2;
- Int32 numFastBytes = 128;
-
- bool eos = parser[(int)Key.EOS].ThereIs || stdInMode;
-
- if (parser[(int)Key.Mode].ThereIs)
- if (!GetNumber((string)parser[(int)Key.Mode].PostStrings[0], out algorithm))
- IncorrectCommand();
-
- if (parser[(int)Key.FastBytes].ThereIs)
- if (!GetNumber((string)parser[(int)Key.FastBytes].PostStrings[0], out numFastBytes))
- IncorrectCommand();
- if (parser[(int)Key.LitContext].ThereIs)
- if (!GetNumber((string)parser[(int)Key.LitContext].PostStrings[0], out litContextBits))
- IncorrectCommand();
- if (parser[(int)Key.LitPos].ThereIs)
- if (!GetNumber((string)parser[(int)Key.LitPos].PostStrings[0], out litPosBits))
- IncorrectCommand();
- if (parser[(int)Key.PosBits].ThereIs)
- if (!GetNumber((string)parser[(int)Key.PosBits].PostStrings[0], out posStateBits))
- IncorrectCommand();
-
- CoderPropID[] propIDs =
- {
- CoderPropID.DictionarySize,
- CoderPropID.PosStateBits,
- CoderPropID.LitContextBits,
- CoderPropID.LitPosBits,
- CoderPropID.Algorithm,
- CoderPropID.NumFastBytes,
- CoderPropID.MatchFinder,
- CoderPropID.EndMarker
- };
- object[] properties =
- {
- (Int32)(dictionary),
- (Int32)(posStateBits),
- (Int32)(litContextBits),
- (Int32)(litPosBits),
- (Int32)(algorithm),
- (Int32)(numFastBytes),
- mf,
- eos
- };
-
- Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
- encoder.SetCoderProperties(propIDs, properties);
- encoder.WriteCoderProperties(outStream);
- Int64 fileSize;
- if (eos || stdInMode)
- fileSize = -1;
- else
- fileSize = inStream.Length;
- for (int i = 0; i < 8; i++)
- outStream.WriteByte((Byte)(fileSize >> (8 * i)));
- if (trainStream != null)
- {
- CDoubleStream doubleStream = new CDoubleStream();
- doubleStream.s1 = trainStream;
- doubleStream.s2 = inStream;
- doubleStream.fileIndex = 0;
- inStream = doubleStream;
- long trainFileSize = trainStream.Length;
- doubleStream.skipSize = 0;
- if (trainFileSize > dictionary)
- doubleStream.skipSize = trainFileSize - dictionary;
- trainStream.Seek(doubleStream.skipSize, SeekOrigin.Begin);
- encoder.SetTrainSize((uint)(trainFileSize - doubleStream.skipSize));
- }
- encoder.Code(inStream, outStream, -1, -1, null);
- }
- else if (command == "d")
- {
- byte[] properties = new byte[5];
- if (inStream.Read(properties, 0, 5) != 5)
- throw (new Exception("input .lzma is too short"));
- Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();
- decoder.SetDecoderProperties(properties);
- if (trainStream != null)
- {
- if (!decoder.Train(trainStream))
- throw (new Exception("can't train"));
- }
- long outSize = 0;
- for (int i = 0; i < 8; i++)
- {
- int v = inStream.ReadByte();
- if (v < 0)
- throw (new Exception("Can't Read 1"));
- outSize |= ((long)(byte)v) << (8 * i);
- }
- long compressedSize = inStream.Length - inStream.Position;
- decoder.Code(inStream, outStream, compressedSize, outSize, null);
- }
- else
- throw (new Exception("Command Error"));
- return 0;
- }
-
- [STAThread]
- static int Main(string[] args)
- {
- try
- {
- return Main2(args);
- }
- catch (Exception e)
- {
- Console.WriteLine("{0} Caught exception #1.", e);
- // throw e;
- return 1;
- }
- }
- }
-}
diff --git a/CS/7zip/Compress/LzmaAlone/LzmaAlone.csproj b/CS/7zip/Compress/LzmaAlone/LzmaAlone.csproj
deleted file mode 100644
index ceb7073..0000000
--- a/CS/7zip/Compress/LzmaAlone/LzmaAlone.csproj
+++ /dev/null
@@ -1,90 +0,0 @@
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
- <PropertyGroup>
- <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
- <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
- <ProductVersion>8.0.50727</ProductVersion>
- <SchemaVersion>2.0</SchemaVersion>
- <ProjectGuid>{CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}</ProjectGuid>
- <OutputType>Exe</OutputType>
- <RootNamespace>LzmaAlone</RootNamespace>
- <AssemblyName>Lzma#</AssemblyName>
- <WarningLevel>4</WarningLevel>
- </PropertyGroup>
- <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
- <DebugSymbols>true</DebugSymbols>
- <DebugType>full</DebugType>
- <Optimize>false</Optimize>
- <OutputPath>.\bin\Debug\</OutputPath>
- <DefineConstants>DEBUG;TRACE</DefineConstants>
- </PropertyGroup>
- <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
- <DebugSymbols>false</DebugSymbols>
- <Optimize>true</Optimize>
- <OutputPath>.\bin\Release\</OutputPath>
- <DefineConstants>TRACE</DefineConstants>
- <PlatformTarget>AnyCPU</PlatformTarget>
- </PropertyGroup>
- <ItemGroup>
- <Reference Include="System" />
- <Reference Include="System.Data" />
- <Reference Include="System.Xml" />
- </ItemGroup>
- <ItemGroup>
- <Compile Include="..\..\Common\CommandLineParser.cs">
- <Link>Common\CommandLineParser.cs</Link>
- </Compile>
- <Compile Include="..\..\Common\CRC.cs">
- <Link>Common\CRC.cs</Link>
- </Compile>
- <Compile Include="..\..\ICoder.cs">
- <Link>ICoder.cs</Link>
- </Compile>
- <Compile Include="..\LZ\IMatchFinder.cs">
- <Link>LZ\IMatchFinder.cs</Link>
- </Compile>
- <Compile Include="..\LZ\LzBinTree.cs">
- <Link>LZ\LzBinTree.cs</Link>
- </Compile>
- <Compile Include="..\LZ\LzInWindow.cs">
- <Link>LZ\LzInWindow.cs</Link>
- </Compile>
- <Compile Include="..\LZ\LzOutWindow.cs">
- <Link>LZ\LzOutWindow.cs</Link>
- </Compile>
- <Compile Include="..\LZMA\LzmaBase.cs">
- <Link>LZMA\LzmaBase.cs</Link>
- </Compile>
- <Compile Include="..\LZMA\LzmaDecoder.cs">
- <Link>LZMA\LzmaDecoder.cs</Link>
- </Compile>
- <Compile Include="..\LZMA\LzmaEncoder.cs">
- <Link>LZMA\LzmaEncoder.cs</Link>
- </Compile>
- <Compile Include="..\RangeCoder\RangeCoder.cs">
- <Link>RangeCoder\RangeCoder.cs</Link>
- </Compile>
- <Compile Include="..\RangeCoder\RangeCoderBit.cs">
- <Link>RangeCoder\RangeCoderBit.cs</Link>
- </Compile>
- <Compile Include="..\RangeCoder\RangeCoderBitTree.cs">
- <Link>RangeCoder\RangeCoderBitTree.cs</Link>
- </Compile>
- <Compile Include="LzmaAlone.cs">
- <SubType>Code</SubType>
- </Compile>
- <Compile Include="LzmaBench.cs">
- <SubType>Code</SubType>
- </Compile>
- <Compile Include="Properties\AssemblyInfo.cs" />
- <Compile Include="Properties\Settings.cs">
- <AutoGen>True</AutoGen>
- <DependentUpon>Settings.settings</DependentUpon>
- </Compile>
- <None Include="Properties\Settings.settings">
- <Generator>SettingsSingleFileGenerator</Generator>
- <LastGenOutput>Settings.cs</LastGenOutput>
- </None>
- <AppDesigner Include="Properties\" />
- </ItemGroup>
- <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
-</Project>
\ No newline at end of file
diff --git a/CS/7zip/Compress/LzmaAlone/LzmaAlone.sln b/CS/7zip/Compress/LzmaAlone/LzmaAlone.sln
deleted file mode 100644
index a96ee3e..0000000
--- a/CS/7zip/Compress/LzmaAlone/LzmaAlone.sln
+++ /dev/null
@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 9.00
-# Visual C# Express 2005
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LzmaAlone", "LzmaAlone.csproj", "{CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}"
-EndProject
-Global
- GlobalSection(SolutionConfigurationPlatforms) = preSolution
- Debug|Any CPU = Debug|Any CPU
- Release|Any CPU = Release|Any CPU
- EndGlobalSection
- GlobalSection(ProjectConfigurationPlatforms) = postSolution
- {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
- {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Debug|Any CPU.Build.0 = Debug|Any CPU
- {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Release|Any CPU.ActiveCfg = Release|Any CPU
- {CE33DF18-F9C8-4D6F-9057-DBB4DB96E973}.Release|Any CPU.Build.0 = Release|Any CPU
- EndGlobalSection
- GlobalSection(SolutionProperties) = preSolution
- HideSolutionNode = FALSE
- EndGlobalSection
-EndGlobal
diff --git a/CS/7zip/Compress/LzmaAlone/LzmaBench.cs b/CS/7zip/Compress/LzmaAlone/LzmaBench.cs
deleted file mode 100644
index 6a1ffe2..0000000
--- a/CS/7zip/Compress/LzmaAlone/LzmaBench.cs
+++ /dev/null
@@ -1,340 +0,0 @@
-// LzmaBench.cs
-
-using System;
-using System.IO;
-
-namespace SevenZip
-{
- /// <summary>
- /// LZMA Benchmark
- /// </summary>
- internal abstract class LzmaBench
- {
- const UInt32 kAdditionalSize = (6 << 20);
- const UInt32 kCompressedAdditionalSize = (1 << 10);
- const UInt32 kMaxLzmaPropSize = 10;
-
- class CRandomGenerator
- {
- UInt32 A1;
- UInt32 A2;
- public CRandomGenerator() { Init(); }
- public void Init() { A1 = 362436069; A2 = 521288629; }
- public UInt32 GetRnd()
- {
- return
- ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) ^
- ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)));
- }
- };
-
- class CBitRandomGenerator
- {
- CRandomGenerator RG = new CRandomGenerator();
- UInt32 Value;
- int NumBits;
- public void Init()
- {
- Value = 0;
- NumBits = 0;
- }
- public UInt32 GetRnd(int numBits)
- {
- UInt32 result;
- if (NumBits > numBits)
- {
- result = Value & (((UInt32)1 << numBits) - 1);
- Value >>= numBits;
- NumBits -= numBits;
- return result;
- }
- numBits -= NumBits;
- result = (Value << numBits);
- Value = RG.GetRnd();
- result |= Value & (((UInt32)1 << numBits) - 1);
- Value >>= numBits;
- NumBits = 32 - numBits;
- return result;
- }
- };
-
- class CBenchRandomGenerator
- {
- CBitRandomGenerator RG = new CBitRandomGenerator();
- UInt32 Pos;
- UInt32 Rep0;
-
- public UInt32 BufferSize;
- public Byte[] Buffer = null;
-
- public CBenchRandomGenerator() { }
-
- public void Set(UInt32 bufferSize)
- {
- Buffer = new Byte[bufferSize];
- Pos = 0;
- BufferSize = bufferSize;
- }
- UInt32 GetRndBit() { return RG.GetRnd(1); }
- UInt32 GetLogRandBits(int numBits)
- {
- UInt32 len = RG.GetRnd(numBits);
- return RG.GetRnd((int)len);
- }
- UInt32 GetOffset()
- {
- if (GetRndBit() == 0)
- return GetLogRandBits(4);
- return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
- }
- UInt32 GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }
- UInt32 GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }
- public void Generate()
- {
- RG.Init();
- Rep0 = 1;
- while (Pos < BufferSize)
- {
- if (GetRndBit() == 0 || Pos < 1)
- Buffer[Pos++] = (Byte)RG.GetRnd(8);
- else
- {
- UInt32 len;
- if (RG.GetRnd(3) == 0)
- len = 1 + GetLen1();
- else
- {
- do
- Rep0 = GetOffset();
- while (Rep0 >= Pos);
- Rep0++;
- len = 2 + GetLen2();
- }
- for (UInt32 i = 0; i < len && Pos < BufferSize; i++, Pos++)
- Buffer[Pos] = Buffer[Pos - Rep0];
- }
- }
- }
- };
-
- class CrcOutStream : System.IO.Stream
- {
- public CRC CRC = new CRC();
- public void Init() { CRC.Init(); }
- public UInt32 GetDigest() { return CRC.GetDigest(); }
-
- public override bool CanRead { get { return false; } }
- public override bool CanSeek { get { return false; } }
- public override bool CanWrite { get { return true; } }
- public override Int64 Length { get { return 0; } }
- public override Int64 Position { get { return 0; } set { } }
- public override void Flush() { }
- public override long Seek(long offset, SeekOrigin origin) { return 0; }
- public override void SetLength(long value) { }
- public override int Read(byte[] buffer, int offset, int count) { return 0; }
-
- public override void WriteByte(byte b)
- {
- CRC.UpdateByte(b);
- }
- public override void Write(byte[] buffer, int offset, int count)
- {
- CRC.Update(buffer, (uint)offset, (uint)count);
- }
- };
-
- class CProgressInfo : ICodeProgress
- {
- public Int64 ApprovedStart;
- public Int64 InSize;
- public System.DateTime Time;
- public void Init() { InSize = 0; }
- public void SetProgress(Int64 inSize, Int64 outSize)
- {
- if (inSize >= ApprovedStart && InSize == 0)
- {
- Time = DateTime.UtcNow;
- InSize = inSize;
- }
- }
- }
- const int kSubBits = 8;
-
- static UInt32 GetLogSize(UInt32 size)
- {
- for (int i = kSubBits; i < 32; i++)
- for (UInt32 j = 0; j < (1 << kSubBits); j++)
- if (size <= (((UInt32)1) << i) + (j << (i - kSubBits)))
- return (UInt32)(i << kSubBits) + j;
- return (32 << kSubBits);
- }
-
- static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime)
- {
- UInt64 freq = TimeSpan.TicksPerSecond;
- UInt64 elTime = elapsedTime;
- while (freq > 1000000)
- {
- freq >>= 1;
- elTime >>= 1;
- }
- if (elTime == 0)
- elTime = 1;
- return value * freq / elTime;
- }
-
- static UInt64 GetCompressRating(UInt32 dictionarySize, UInt64 elapsedTime, UInt64 size)
- {
- UInt64 t = GetLogSize(dictionarySize) - (18 << kSubBits);
- UInt64 numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));
- UInt64 numCommands = (UInt64)(size) * numCommandsForOne;
- return MyMultDiv64(numCommands, elapsedTime);
- }
-
- static UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 outSize, UInt64 inSize)
- {
- UInt64 numCommands = inSize * 220 + outSize * 20;
- return MyMultDiv64(numCommands, elapsedTime);
- }
-
- static UInt64 GetTotalRating(
- UInt32 dictionarySize,
- UInt64 elapsedTimeEn, UInt64 sizeEn,
- UInt64 elapsedTimeDe,
- UInt64 inSizeDe, UInt64 outSizeDe)
- {
- return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +
- GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
- }
-
- static void PrintValue(UInt64 v)
- {
- string s = v.ToString();
- for (int i = 0; i + s.Length < 6; i++)
- System.Console.Write(" ");
- System.Console.Write(s);
- }
-
- static void PrintRating(UInt64 rating)
- {
- PrintValue(rating / 1000000);
- System.Console.Write(" MIPS");
- }
-
- static void PrintResults(
- UInt32 dictionarySize,
- UInt64 elapsedTime,
- UInt64 size,
- bool decompressMode, UInt64 secondSize)
- {
- UInt64 speed = MyMultDiv64(size, elapsedTime);
- PrintValue(speed / 1024);
- System.Console.Write(" KB/s ");
- UInt64 rating;
- if (decompressMode)
- rating = GetDecompressRating(elapsedTime, size, secondSize);
- else
- rating = GetCompressRating(dictionarySize, elapsedTime, size);
- PrintRating(rating);
- }
-
- static public int LzmaBenchmark(Int32 numIterations, UInt32 dictionarySize)
- {
- if (numIterations <= 0)
- return 0;
- if (dictionarySize < (1 << 18))
- {
- System.Console.WriteLine("\nError: dictionary size for benchmark must be >= 19 (512 KB)");
- return 1;
- }
- System.Console.Write("\n Compressing Decompressing\n\n");
-
- Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();
- Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();
-
-
- CoderPropID[] propIDs =
- {
- CoderPropID.DictionarySize,
- };
- object[] properties =
- {
- (Int32)(dictionarySize),
- };
-
- UInt32 kBufferSize = dictionarySize + kAdditionalSize;
- UInt32 kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
-
- encoder.SetCoderProperties(propIDs, properties);
- System.IO.MemoryStream propStream = new System.IO.MemoryStream();
- encoder.WriteCoderProperties(propStream);
- byte[] propArray = propStream.ToArray();
-
- CBenchRandomGenerator rg = new CBenchRandomGenerator();
-
- rg.Set(kBufferSize);
- rg.Generate();
- CRC crc = new CRC();
- crc.Init();
- crc.Update(rg.Buffer, 0, rg.BufferSize);
-
- CProgressInfo progressInfo = new CProgressInfo();
- progressInfo.ApprovedStart = dictionarySize;
-
- UInt64 totalBenchSize = 0;
- UInt64 totalEncodeTime = 0;
- UInt64 totalDecodeTime = 0;
- UInt64 totalCompressedSize = 0;
-
- MemoryStream inStream = new MemoryStream(rg.Buffer, 0, (int)rg.BufferSize);
- MemoryStream compressedStream = new MemoryStream((int)kCompressedBufferSize);
- CrcOutStream crcOutStream = new CrcOutStream();
- for (Int32 i = 0; i < numIterations; i++)
- {
- progressInfo.Init();
- inStream.Seek(0, SeekOrigin.Begin);
- compressedStream.Seek(0, SeekOrigin.Begin);
- encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
- TimeSpan sp2 = DateTime.UtcNow - progressInfo.Time;
- UInt64 encodeTime = (UInt64)sp2.Ticks;
-
- long compressedSize = compressedStream.Position;
- if (progressInfo.InSize == 0)
- throw (new Exception("Internal ERROR 1282"));
-
- UInt64 decodeTime = 0;
- for (int j = 0; j < 2; j++)
- {
- compressedStream.Seek(0, SeekOrigin.Begin);
- crcOutStream.Init();
-
- decoder.SetDecoderProperties(propArray);
- UInt64 outSize = kBufferSize;
- System.DateTime startTime = DateTime.UtcNow;
- decoder.Code(compressedStream, crcOutStream, 0, (Int64)outSize, null);
- TimeSpan sp = (DateTime.UtcNow - startTime);
- decodeTime = (ulong)sp.Ticks;
- if (crcOutStream.GetDigest() != crc.GetDigest())
- throw (new Exception("CRC Error"));
- }
- UInt64 benchSize = kBufferSize - (UInt64)progressInfo.InSize;
- PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
- System.Console.Write(" ");
- PrintResults(dictionarySize, decodeTime, kBufferSize, true, (ulong)compressedSize);
- System.Console.WriteLine();
-
- totalBenchSize += benchSize;
- totalEncodeTime += encodeTime;
- totalDecodeTime += decodeTime;
- totalCompressedSize += (ulong)compressedSize;
- }
- System.Console.WriteLine("---------------------------------------------------");
- PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
- System.Console.Write(" ");
- PrintResults(dictionarySize, totalDecodeTime,
- kBufferSize * (UInt64)numIterations, true, totalCompressedSize);
- System.Console.WriteLine(" Average");
- return 0;
- }
- }
-}
diff --git a/CS/7zip/Compress/LzmaAlone/Properties/AssemblyInfo.cs b/CS/7zip/Compress/LzmaAlone/Properties/AssemblyInfo.cs
deleted file mode 100644
index a394aee..0000000
--- a/CS/7zip/Compress/LzmaAlone/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-#region Using directives
-
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-#endregion
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("LZMA#")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Igor Pavlov")]
-[assembly: AssemblyProduct("LZMA# SDK")]
-[assembly: AssemblyCopyright("Copyright @ Igor Pavlov 1999-2004")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Version information for an assembly consists of the following four values:
-//
-// Major Version
-// Minor Version
-// Build Number
-// Revision
-//
-// You can specify all the values or you can default the Revision and Build Numbers
-// by using the '*' as shown below:
-[assembly: AssemblyVersion("4.12.*")]
diff --git a/CS/7zip/Compress/LzmaAlone/Properties/Resources.cs b/CS/7zip/Compress/LzmaAlone/Properties/Resources.cs
deleted file mode 100644
index efe4ee9..0000000
--- a/CS/7zip/Compress/LzmaAlone/Properties/Resources.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-//------------------------------------------------------------------------------
-// <autogenerated>
-// This code was generated by a tool.
-// Runtime Version:2.0.40607.42
-//
-// Changes to this file may cause incorrect behavior and will be lost if
-// the code is regenerated.
-// </autogenerated>
-//------------------------------------------------------------------------------
-
-namespace LzmaAlone.Properties
-{
- using System;
- using System.IO;
- using System.Resources;
-
- /// <summary>
- /// A strongly-typed resource class, for looking up localized strings, etc.
- /// </summary>
- // This class was auto-generated by the Strongly Typed Resource Builder
- // class via a tool like ResGen or Visual Studio.NET.
- // To add or remove a member, edit your .ResX file then rerun ResGen
- // with the /str option, or rebuild your VS project.
- class Resources
- {
-
- private static System.Resources.ResourceManager _resMgr;
-
- private static System.Globalization.CultureInfo _resCulture;
-
- /*FamANDAssem*/
- internal Resources()
- {
- }
-
- /// <summary>
- /// Returns the cached ResourceManager instance used by this class.
- /// </summary>
- [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
- public static System.Resources.ResourceManager ResourceManager
- {
- get
- {
- if ((_resMgr == null))
- {
- System.Resources.ResourceManager temp = new System.Resources.ResourceManager("Resources", typeof(Resources).Assembly);
- _resMgr = temp;
- }
- return _resMgr;
- }
- }
-
- /// <summary>
- /// Overrides the current thread's CurrentUICulture property for all
- /// resource lookups using this strongly typed resource class.
- /// </summary>
- [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
- public static System.Globalization.CultureInfo Culture
- {
- get
- {
- return _resCulture;
- }
- set
- {
- _resCulture = value;
- }
- }
- }
-}
diff --git a/CS/7zip/Compress/LzmaAlone/Properties/Settings.cs b/CS/7zip/Compress/LzmaAlone/Properties/Settings.cs
deleted file mode 100644
index 1281fd2..0000000
--- a/CS/7zip/Compress/LzmaAlone/Properties/Settings.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-//------------------------------------------------------------------------------
-// <autogenerated>
-// This code was generated by a tool.
-// Runtime Version:2.0.40607.42
-//
-// Changes to this file may cause incorrect behavior and will be lost if
-// the code is regenerated.
-// </autogenerated>
-//------------------------------------------------------------------------------
-
-namespace LzmaAlone.Properties
-{
- public partial class Settings : System.Configuration.ApplicationSettingsBase
- {
- private static Settings m_Value;
-
- private static object m_SyncObject = new object();
-
- public static Settings Value
- {
- get
- {
- if ((Settings.m_Value == null))
- {
- System.Threading.Monitor.Enter(Settings.m_SyncObject);
- if ((Settings.m_Value == null))
- {
- try
- {
- Settings.m_Value = new Settings();
- }
- finally
- {
- System.Threading.Monitor.Exit(Settings.m_SyncObject);
- }
- }
- }
- return Settings.m_Value;
- }
- }
- }
-}
diff --git a/CS/7zip/Compress/RangeCoder/RangeCoder.cs b/CS/7zip/Compress/RangeCoder/RangeCoder.cs
deleted file mode 100644
index 4ced247..0000000
--- a/CS/7zip/Compress/RangeCoder/RangeCoder.cs
+++ /dev/null
@@ -1,234 +0,0 @@
-using System;
-
-namespace SevenZip.Compression.RangeCoder
-{
- class Encoder
- {
- public const uint kTopValue = (1 << 24);
-
- System.IO.Stream Stream;
-
- public UInt64 Low;
- public uint Range;
- uint _cacheSize;
- byte _cache;
-
- long StartPosition;
-
- public void SetStream(System.IO.Stream stream)
- {
- Stream = stream;
- }
-
- public void ReleaseStream()
- {
- Stream = null;
- }
-
- public void Init()
- {
- StartPosition = Stream.Position;
-
- Low = 0;
- Range = 0xFFFFFFFF;
- _cacheSize = 1;
- _cache = 0;
- }
-
- public void FlushData()
- {
- for (int i = 0; i < 5; i++)
- ShiftLow();
- }
-
- public void FlushStream()
- {
- Stream.Flush();
- }
-
- public void CloseStream()
- {
- Stream.Close();
- }
-
- public void Encode(uint start, uint size, uint total)
- {
- Low += start * (Range /= total);
- Range *= size;
- while (Range < kTopValue)
- {
- Range <<= 8;
- ShiftLow();
- }
- }
-
- public void ShiftLow()
- {
- if ((uint)Low < (uint)0xFF000000 || (uint)(Low >> 32) == 1)
- {
- byte temp = _cache;
- do
- {
- Stream.WriteByte((byte)(temp + (Low >> 32)));
- temp = 0xFF;
- }
- while (--_cacheSize != 0);
- _cache = (byte)(((uint)Low) >> 24);
- }
- _cacheSize++;
- Low = ((uint)Low) << 8;
- }
-
- public void EncodeDirectBits(uint v, int numTotalBits)
- {
- for (int i = numTotalBits - 1; i >= 0; i--)
- {
- Range >>= 1;
- if (((v >> i) & 1) == 1)
- Low += Range;
- if (Range < kTopValue)
- {
- Range <<= 8;
- ShiftLow();
- }
- }
- }
-
- public void EncodeBit(uint size0, int numTotalBits, uint symbol)
- {
- uint newBound = (Range >> numTotalBits) * size0;
- if (symbol == 0)
- Range = newBound;
- else
- {
- Low += newBound;
- Range -= newBound;
- }
- while (Range < kTopValue)
- {
- Range <<= 8;
- ShiftLow();
- }
- }
-
- public long GetProcessedSizeAdd()
- {
- return _cacheSize +
- Stream.Position - StartPosition + 4;
- // (long)Stream.GetProcessedSize();
- }
- }
-
- class Decoder
- {
- public const uint kTopValue = (1 << 24);
- public uint Range;
- public uint Code;
- // public Buffer.InBuffer Stream = new Buffer.InBuffer(1 << 16);
- public System.IO.Stream Stream;
-
- public void Init(System.IO.Stream stream)
- {
- // Stream.Init(stream);
- Stream = stream;
-
- Code = 0;
- Range = 0xFFFFFFFF;
- for (int i = 0; i < 5; i++)
- Code = (Code << 8) | (byte)Stream.ReadByte();
- }
-
- public void ReleaseStream()
- {
- // Stream.ReleaseStream();
- Stream = null;
- }
-
- public void CloseStream()
- {
- Stream.Close();
- }
-
- public void Normalize()
- {
- while (Range < kTopValue)
- {
- Code = (Code << 8) | (byte)Stream.ReadByte();
- Range <<= 8;
- }
- }
-
- public void Normalize2()
- {
- if (Range < kTopValue)
- {
- Code = (Code << 8) | (byte)Stream.ReadByte();
- Range <<= 8;
- }
- }
-
- public uint GetThreshold(uint total)
- {
- return Code / (Range /= total);
- }
-
- public void Decode(uint start, uint size, uint total)
- {
- Code -= start * Range;
- Range *= size;
- Normalize();
- }
-
- public uint DecodeDirectBits(int numTotalBits)
- {
- uint range = Range;
- uint code = Code;
- uint result = 0;
- for (int i = numTotalBits; i > 0; i--)
- {
- range >>= 1;
- /*
- result <<= 1;
- if (code >= range)
- {
- code -= range;
- result |= 1;
- }
- */
- uint t = (code - range) >> 31;
- code -= range & (t - 1);
- result = (result << 1) | (1 - t);
-
- if (range < kTopValue)
- {
- code = (code << 8) | (byte)Stream.ReadByte();
- range <<= 8;
- }
- }
- Range = range;
- Code = code;
- return result;
- }
-
- public uint DecodeBit(uint size0, int numTotalBits)
- {
- uint newBound = (Range >> numTotalBits) * size0;
- uint symbol;
- if (Code < newBound)
- {
- symbol = 0;
- Range = newBound;
- }
- else
- {
- symbol = 1;
- Code -= newBound;
- Range -= newBound;
- }
- Normalize();
- return symbol;
- }
-
- // ulong GetProcessedSize() {return Stream.GetProcessedSize(); }
- }
-}
diff --git a/CS/7zip/Compress/RangeCoder/RangeCoderBit.cs b/CS/7zip/Compress/RangeCoder/RangeCoderBit.cs
deleted file mode 100644
index 000a5a0..0000000
--- a/CS/7zip/Compress/RangeCoder/RangeCoderBit.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-using System;
-
-namespace SevenZip.Compression.RangeCoder
-{
- struct BitEncoder
- {
- public const int kNumBitModelTotalBits = 11;
- public const uint kBitModelTotal = (1 << kNumBitModelTotalBits);
- const int kNumMoveBits = 5;
- const int kNumMoveReducingBits = 2;
- public const int kNumBitPriceShiftBits = 6;
-
- uint Prob;
-
- public void Init() { Prob = kBitModelTotal >> 1; }
-
- public void UpdateModel(uint symbol)
- {
- if (symbol == 0)
- Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
- else
- Prob -= (Prob) >> kNumMoveBits;
- }
-
- public void Encode(Encoder encoder, uint symbol)
- {
- // encoder.EncodeBit(Prob, kNumBitModelTotalBits, symbol);
- // UpdateModel(symbol);
- uint newBound = (encoder.Range >> kNumBitModelTotalBits) * Prob;
- if (symbol == 0)
- {
- encoder.Range = newBound;
- Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
- }
- else
- {
- encoder.Low += newBound;
- encoder.Range -= newBound;
- Prob -= (Prob) >> kNumMoveBits;
- }
- if (encoder.Range < Encoder.kTopValue)
- {
- encoder.Range <<= 8;
- encoder.ShiftLow();
- }
- }
-
- private static UInt32[] ProbPrices = new UInt32[kBitModelTotal >> kNumMoveReducingBits];
-
- static BitEncoder()
- {
- const int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);
- for (int i = kNumBits - 1; i >= 0; i--)
- {
- UInt32 start = (UInt32)1 << (kNumBits - i - 1);
- UInt32 end = (UInt32)1 << (kNumBits - i);
- for (UInt32 j = start; j < end; j++)
- ProbPrices[j] = ((UInt32)i << kNumBitPriceShiftBits) +
- (((end - j) << kNumBitPriceShiftBits) >> (kNumBits - i - 1));
- }
- }
-
- public uint GetPrice(uint symbol)
- {
- return ProbPrices[(((Prob - symbol) ^ ((-(int)symbol))) & (kBitModelTotal - 1)) >> kNumMoveReducingBits];
- }
- public uint GetPrice0() { return ProbPrices[Prob >> kNumMoveReducingBits]; }
- public uint GetPrice1() { return ProbPrices[(kBitModelTotal - Prob) >> kNumMoveReducingBits]; }
- }
-
- struct BitDecoder
- {
- public const int kNumBitModelTotalBits = 11;
- public const uint kBitModelTotal = (1 << kNumBitModelTotalBits);
- const int kNumMoveBits = 5;
-
- uint Prob;
-
- public void UpdateModel(int numMoveBits, uint symbol)
- {
- if (symbol == 0)
- Prob += (kBitModelTotal - Prob) >> numMoveBits;
- else
- Prob -= (Prob) >> numMoveBits;
- }
-
- public void Init() { Prob = kBitModelTotal >> 1; }
-
- public uint Decode(RangeCoder.Decoder rangeDecoder)
- {
- uint newBound = (uint)(rangeDecoder.Range >> kNumBitModelTotalBits) * (uint)Prob;
- if (rangeDecoder.Code < newBound)
- {
- rangeDecoder.Range = newBound;
- Prob += (kBitModelTotal - Prob) >> kNumMoveBits;
- if (rangeDecoder.Range < Decoder.kTopValue)
- {
- rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
- rangeDecoder.Range <<= 8;
- }
- return 0;
- }
- else
- {
- rangeDecoder.Range -= newBound;
- rangeDecoder.Code -= newBound;
- Prob -= (Prob) >> kNumMoveBits;
- if (rangeDecoder.Range < Decoder.kTopValue)
- {
- rangeDecoder.Code = (rangeDecoder.Code << 8) | (byte)rangeDecoder.Stream.ReadByte();
- rangeDecoder.Range <<= 8;
- }
- return 1;
- }
- }
- }
-}
diff --git a/CS/7zip/Compress/RangeCoder/RangeCoderBitTree.cs b/CS/7zip/Compress/RangeCoder/RangeCoderBitTree.cs
deleted file mode 100644
index 3309c14..0000000
--- a/CS/7zip/Compress/RangeCoder/RangeCoderBitTree.cs
+++ /dev/null
@@ -1,157 +0,0 @@
-using System;
-
-namespace SevenZip.Compression.RangeCoder
-{
- struct BitTreeEncoder
- {
- BitEncoder[] Models;
- int NumBitLevels;
-
- public BitTreeEncoder(int numBitLevels)
- {
- NumBitLevels = numBitLevels;
- Models = new BitEncoder[1 << numBitLevels];
- }
-
- public void Init()
- {
- for (uint i = 1; i < (1 << NumBitLevels); i++)
- Models[i].Init();
- }
-
- public void Encode(Encoder rangeEncoder, UInt32 symbol)
- {
- UInt32 m = 1;
- for (int bitIndex = NumBitLevels; bitIndex > 0; )
- {
- bitIndex--;
- UInt32 bit = (symbol >> bitIndex) & 1;
- Models[m].Encode(rangeEncoder, bit);
- m = (m << 1) | bit;
- }
- }
-
- public void ReverseEncode(Encoder rangeEncoder, UInt32 symbol)
- {
- UInt32 m = 1;
- for (UInt32 i = 0; i < NumBitLevels; i++)
- {
- UInt32 bit = symbol & 1;
- Models[m].Encode(rangeEncoder, bit);
- m = (m << 1) | bit;
- symbol >>= 1;
- }
- }
-
- public UInt32 GetPrice(UInt32 symbol)
- {
- UInt32 price = 0;
- UInt32 m = 1;
- for (int bitIndex = NumBitLevels; bitIndex > 0; )
- {
- bitIndex--;
- UInt32 bit = (symbol >> bitIndex) & 1;
- price += Models[m].GetPrice(bit);
- m = (m << 1) + bit;
- }
- return price;
- }
-
- public UInt32 ReverseGetPrice(UInt32 symbol)
- {
- UInt32 price = 0;
- UInt32 m = 1;
- for (int i = NumBitLevels; i > 0; i--)
- {
- UInt32 bit = symbol & 1;
- symbol >>= 1;
- price += Models[m].GetPrice(bit);
- m = (m << 1) | bit;
- }
- return price;
- }
-
- public static UInt32 ReverseGetPrice(BitEncoder[] Models, UInt32 startIndex,
- int NumBitLevels, UInt32 symbol)
- {
- UInt32 price = 0;
- UInt32 m = 1;
- for (int i = NumBitLevels; i > 0; i--)
- {
- UInt32 bit = symbol & 1;
- symbol >>= 1;
- price += Models[startIndex + m].GetPrice(bit);
- m = (m << 1) | bit;
- }
- return price;
- }
-
- public static void ReverseEncode(BitEncoder[] Models, UInt32 startIndex,
- Encoder rangeEncoder, int NumBitLevels, UInt32 symbol)
- {
- UInt32 m = 1;
- for (int i = 0; i < NumBitLevels; i++)
- {
- UInt32 bit = symbol & 1;
- Models[startIndex + m].Encode(rangeEncoder, bit);
- m = (m << 1) | bit;
- symbol >>= 1;
- }
- }
- }
-
- struct BitTreeDecoder
- {
- BitDecoder[] Models;
- int NumBitLevels;
-
- public BitTreeDecoder(int numBitLevels)
- {
- NumBitLevels = numBitLevels;
- Models = new BitDecoder[1 << numBitLevels];
- }
-
- public void Init()
- {
- for (uint i = 1; i < (1 << NumBitLevels); i++)
- Models[i].Init();
- }
-
- public uint Decode(RangeCoder.Decoder rangeDecoder)
- {
- uint m = 1;
- for (int bitIndex = NumBitLevels; bitIndex > 0; bitIndex--)
- m = (m << 1) + Models[m].Decode(rangeDecoder);
- return m - ((uint)1 << NumBitLevels);
- }
-
- public uint ReverseDecode(RangeCoder.Decoder rangeDecoder)
- {
- uint m = 1;
- uint symbol = 0;
- for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
- {
- uint bit = Models[m].Decode(rangeDecoder);
- m <<= 1;
- m += bit;
- symbol |= (bit << bitIndex);
- }
- return symbol;
- }
-
- public static uint ReverseDecode(BitDecoder[] Models, UInt32 startIndex,
- RangeCoder.Decoder rangeDecoder, int NumBitLevels)
- {
- uint m = 1;
- uint symbol = 0;
- for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
- {
- uint bit = Models[startIndex + m].Decode(rangeDecoder);
- m <<= 1;
- m += bit;
- symbol |= (bit << bitIndex);
- }
- return symbol;
- }
- }
-}
diff --git a/CS/7zip/ICoder.cs b/CS/7zip/ICoder.cs
deleted file mode 100644
index 875cb27..0000000
--- a/CS/7zip/ICoder.cs
+++ /dev/null
@@ -1,157 +0,0 @@
-// ICoder.h
-
-using System;
-
-namespace SevenZip
-{
- /// <summary>
- /// The exception that is thrown when an error in input stream occurs during decoding.
- /// </summary>
- class DataErrorException : ApplicationException
- {
- public DataErrorException(): base("Data Error") { }
- }
-
- /// <summary>
- /// The exception that is thrown when the value of an argument is outside the allowable range.
- /// </summary>
- class InvalidParamException : ApplicationException
- {
- public InvalidParamException(): base("Invalid Parameter") { }
- }
-
- public interface ICodeProgress
- {
- /// <summary>
- /// Callback progress.
- /// </summary>
- /// <param name="inSize">
- /// input size. -1 if unknown.
- /// </param>
- /// <param name="outSize">
- /// output size. -1 if unknown.
- /// </param>
- void SetProgress(Int64 inSize, Int64 outSize);
- };
-
- public interface ICoder
- {
- /// <summary>
- /// Codes streams.
- /// </summary>
- /// <param name="inStream">
- /// input Stream.
- /// </param>
- /// <param name="outStream">
- /// output Stream.
- /// </param>
- /// <param name="inSize">
- /// input Size. -1 if unknown.
- /// </param>
- /// <param name="outSize">
- /// output Size. -1 if unknown.
- /// </param>
- /// <param name="progress">
- /// callback progress reference.
- /// </param>
- /// <exception cref="SevenZip.DataErrorException">
- /// if input stream is not valid
- /// </exception>
- void Code(System.IO.Stream inStream, System.IO.Stream outStream,
- Int64 inSize, Int64 outSize, ICodeProgress progress);
- };
-
- /*
- public interface ICoder2
- {
- void Code(ISequentialInStream []inStreams,
- const UInt64 []inSizes,
- ISequentialOutStream []outStreams,
- UInt64 []outSizes,
- ICodeProgress progress);
- };
- */
-
- /// <summary>
- /// Provides the fields that represent properties idenitifiers for compressing.
- /// </summary>
- public enum CoderPropID
- {
- /// <summary>
- /// Specifies default property.
- /// </summary>
- DefaultProp = 0,
- /// <summary>
- /// Specifies size of dictionary.
- /// </summary>
- DictionarySize,
- /// <summary>
- /// Specifies size of memory for PPM*.
- /// </summary>
- UsedMemorySize,
- /// <summary>
- /// Specifies order for PPM methods.
- /// </summary>
- Order,
- /// <summary>
- /// Specifies Block Size.
- /// </summary>
- BlockSize,
- /// <summary>
- /// Specifies number of postion state bits for LZMA (0 <= x <= 4).
- /// </summary>
- PosStateBits,
- /// <summary>
- /// Specifies number of literal context bits for LZMA (0 <= x <= 8).
- /// </summary>
- LitContextBits,
- /// <summary>
- /// Specifies number of literal position bits for LZMA (0 <= x <= 4).
- /// </summary>
- LitPosBits,
- /// <summary>
- /// Specifies number of fast bytes for LZ*.
- /// </summary>
- NumFastBytes,
- /// <summary>
- /// Specifies match finder. LZMA: "BT2", "BT4" or "BT4B".
- /// </summary>
- MatchFinder,
- /// <summary>
- /// Specifies the number of match finder cyckes.
- /// </summary>
- MatchFinderCycles,
- /// <summary>
- /// Specifies number of passes.
- /// </summary>
- NumPasses,
- /// <summary>
- /// Specifies number of algorithm.
- /// </summary>
- Algorithm,
- /// <summary>
- /// Specifies the number of threads.
- /// </summary>
- NumThreads,
- /// <summary>
- /// Specifies mode with end marker.
- /// </summary>
- EndMarker
- };
-
-
- public interface ISetCoderProperties
- {
- void SetCoderProperties(CoderPropID[] propIDs, object[] properties);
- };
-
- public interface IWriteCoderProperties
- {
- void WriteCoderProperties(System.IO.Stream outStream);
- }
-
- public interface ISetDecoderProperties
- {
- void SetDecoderProperties(byte[] properties);
- }
-}
diff --git a/DOC/7zC.txt b/DOC/7zC.txt
index 4927678..939b720 100644
--- a/DOC/7zC.txt
+++ b/DOC/7zC.txt
@@ -1,187 +1,187 @@
-7z ANSI-C Decoder 9.35
-----------------------
-
-7z ANSI-C provides 7z/LZMA decoding.
-7z ANSI-C version is simplified version ported from C++ code.
-
-LZMA is default and general compression method of 7z format
-in 7-Zip compression program (www.7-zip.org). LZMA provides high
-compression ratio and very fast decompression.
-
-
-LICENSE
--------
-
-7z ANSI-C Decoder is part of the LZMA SDK.
-LZMA SDK is written and placed in the public domain by Igor Pavlov.
-
-Files
----------------------
-
-7zDecode.* - Low level 7z decoding
-7zExtract.* - High level 7z decoding
-7zHeader.* - .7z format constants
-7zIn.* - .7z archive opening
-7zItem.* - .7z structures
-7zMain.c - Test application
-
-
-How To Use
-----------
-
-You can create .7z archive with 7z.exe, 7za.exe or 7zr.exe:
-
- 7z.exe a archive.7z *.htm -r -mx -m0fb=255
-
-If you have big number of files in archive, and you need fast extracting,
-you can use partly-solid archives:
-
- 7za.exe a archive.7z *.htm -ms=512K -r -mx -m0fb=255 -m0d=512K
-
-In that example 7-Zip will use 512KB solid blocks. So it needs to decompress only
-512KB for extracting one file from such archive.
-
-
-Limitations of current version of 7z ANSI-C Decoder
----------------------------------------------------
-
- - It reads only "FileName", "Size", "LastWriteTime" and "CRC" information for each file in archive.
- - It supports only LZMA and Copy (no compression) methods with BCJ or BCJ2 filters.
- - It converts original UTF-16 Unicode file names to UTF-8 Unicode file names.
-
-These limitations will be fixed in future versions.
-
-
-Using 7z ANSI-C Decoder Test application:
------------------------------------------
-
-Usage: 7zDec <command> <archive_name>
-
-<Command>:
- e: Extract files from archive
- l: List contents of archive
- t: Test integrity of archive
-
-Example:
-
- 7zDec l archive.7z
-
-lists contents of archive.7z
-
- 7zDec e archive.7z
-
-extracts files from archive.7z to current folder.
-
-
-How to use .7z Decoder
-----------------------
-
-Memory allocation
-~~~~~~~~~~~~~~~~~
-
-7z Decoder uses two memory pools:
-1) Temporary pool
-2) Main pool
-Such scheme can allow you to avoid fragmentation of allocated blocks.
-
-
-Steps for using 7z decoder
---------------------------
-
-Use code at 7zMain.c as example.
-
-1) Declare variables:
- inStream /* implements ILookInStream interface */
- CSzArEx db; /* 7z archive database structure */
- ISzAlloc allocImp; /* memory functions for main pool */
- ISzAlloc allocTempImp; /* memory functions for temporary pool */
-
-2) call CrcGenerateTable(); function to initialize CRC structures.
-
-3) call SzArEx_Init(&db); function to initialize db structures.
-
-4) call SzArEx_Open(&db, inStream, &allocMain, &allocTemp) to open archive
-
-This function opens archive "inStream" and reads headers to "db".
-All items in "db" will be allocated with "allocMain" functions.
-SzArEx_Open function allocates and frees temporary structures by "allocTemp" functions.
-
-5) List items or Extract items
-
- Listing code:
- ~~~~~~~~~~~~~
-
- Use SzArEx_GetFileNameUtf16 function. Look example code in C\Util\7z\7zMain.c file.
-
-
- Extracting code:
- ~~~~~~~~~~~~~~~~
-
- SZ_RESULT SzAr_Extract(
- CArchiveDatabaseEx *db,
- ILookInStream *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 */
- ISzAlloc *allocMain,
- ISzAlloc *allocTemp);
-
- 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.
-
- After decompressing you must free "outBuffer":
- allocImp.Free(outBuffer);
-
-6) call SzArEx_Free(&db, allocImp.Free) to free allocated items in "db".
-
-
-
-
-Memory requirements for .7z decoding
-------------------------------------
-
-Memory usage for Archive opening:
- - Temporary pool:
- - Memory for uncompressed .7z headers
- - some other temporary blocks
- - Main pool:
- - Memory for database:
- Estimated size of one file structures in solid archive:
- - Size (4 or 8 Bytes)
- - CRC32 (4 bytes)
- - LastWriteTime (8 bytes)
- - Some file information (4 bytes)
- - File Name (variable length) + pointer + allocation structures
-
-Memory usage for archive Decompressing:
- - Temporary pool:
- - Memory for LZMA decompressing structures
- - Main pool:
- - Memory for decompressed solid block
- - Memory for temprorary buffers, if BCJ2 fileter is used. Usually these
- temprorary buffers can be about 15% of solid block size.
-
-
-7z Decoder doesn't allocate memory for compressed blocks.
-Instead of this, you must allocate buffer with desired
-size before calling 7z Decoder. Use 7zMain.c as example.
-
-
-Defines
--------
-
-_SZ_ALLOC_DEBUG - define it if you want to debug alloc/free operations to stderr.
-
-
----
-
-http://www.7-zip.org
-http://www.7-zip.org/sdk.html
-http://www.7-zip.org/support.html
+7z ANSI-C Decoder 9.35
+----------------------
+
+7z ANSI-C provides 7z/LZMA decoding.
+7z ANSI-C version is simplified version ported from C++ code.
+
+LZMA is default and general compression method of 7z format
+in 7-Zip compression program (www.7-zip.org). LZMA provides high
+compression ratio and very fast decompression.
+
+
+LICENSE
+-------
+
+7z ANSI-C Decoder is part of the LZMA SDK.
+LZMA SDK is written and placed in the public domain by Igor Pavlov.
+
+Files
+---------------------
+
+7zDecode.* - Low level 7z decoding
+7zExtract.* - High level 7z decoding
+7zHeader.* - .7z format constants
+7zIn.* - .7z archive opening
+7zItem.* - .7z structures
+7zMain.c - Test application
+
+
+How To Use
+----------
+
+You can create .7z archive with 7z.exe, 7za.exe or 7zr.exe:
+
+ 7z.exe a archive.7z *.htm -r -mx -m0fb=255
+
+If you have big number of files in archive, and you need fast extracting,
+you can use partly-solid archives:
+
+ 7za.exe a archive.7z *.htm -ms=512K -r -mx -m0fb=255 -m0d=512K
+
+In that example 7-Zip will use 512KB solid blocks. So it needs to decompress only
+512KB for extracting one file from such archive.
+
+
+Limitations of current version of 7z ANSI-C Decoder
+---------------------------------------------------
+
+ - It reads only "FileName", "Size", "LastWriteTime" and "CRC" information for each file in archive.
+ - It supports only LZMA and Copy (no compression) methods with BCJ or BCJ2 filters.
+ - It converts original UTF-16 Unicode file names to UTF-8 Unicode file names.
+
+These limitations will be fixed in future versions.
+
+
+Using 7z ANSI-C Decoder Test application:
+-----------------------------------------
+
+Usage: 7zDec <command> <archive_name>
+
+<Command>:
+ e: Extract files from archive
+ l: List contents of archive
+ t: Test integrity of archive
+
+Example:
+
+ 7zDec l archive.7z
+
+lists contents of archive.7z
+
+ 7zDec e archive.7z
+
+extracts files from archive.7z to current folder.
+
+
+How to use .7z Decoder
+----------------------
+
+Memory allocation
+~~~~~~~~~~~~~~~~~
+
+7z Decoder uses two memory pools:
+1) Temporary pool
+2) Main pool
+Such scheme can allow you to avoid fragmentation of allocated blocks.
+
+
+Steps for using 7z decoder
+--------------------------
+
+Use code at 7zMain.c as example.
+
+1) Declare variables:
+ inStream /* implements ILookInStream interface */
+ CSzArEx db; /* 7z archive database structure */
+ ISzAlloc allocImp; /* memory functions for main pool */
+ ISzAlloc allocTempImp; /* memory functions for temporary pool */
+
+2) call CrcGenerateTable(); function to initialize CRC structures.
+
+3) call SzArEx_Init(&db); function to initialize db structures.
+
+4) call SzArEx_Open(&db, inStream, &allocMain, &allocTemp) to open archive
+
+This function opens archive "inStream" and reads headers to "db".
+All items in "db" will be allocated with "allocMain" functions.
+SzArEx_Open function allocates and frees temporary structures by "allocTemp" functions.
+
+5) List items or Extract items
+
+ Listing code:
+ ~~~~~~~~~~~~~
+
+ Use SzArEx_GetFileNameUtf16 function. Look example code in C\Util\7z\7zMain.c file.
+
+
+ Extracting code:
+ ~~~~~~~~~~~~~~~~
+
+ SZ_RESULT SzAr_Extract(
+ CArchiveDatabaseEx *db,
+ ILookInStream *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 */
+ ISzAlloc *allocMain,
+ ISzAlloc *allocTemp);
+
+ 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.
+
+ After decompressing you must free "outBuffer":
+ allocImp.Free(outBuffer);
+
+6) call SzArEx_Free(&db, allocImp.Free) to free allocated items in "db".
+
+
+
+
+Memory requirements for .7z decoding
+------------------------------------
+
+Memory usage for Archive opening:
+ - Temporary pool:
+ - Memory for uncompressed .7z headers
+ - some other temporary blocks
+ - Main pool:
+ - Memory for database:
+ Estimated size of one file structures in solid archive:
+ - Size (4 or 8 Bytes)
+ - CRC32 (4 bytes)
+ - LastWriteTime (8 bytes)
+ - Some file information (4 bytes)
+ - File Name (variable length) + pointer + allocation structures
+
+Memory usage for archive Decompressing:
+ - Temporary pool:
+ - Memory for LZMA decompressing structures
+ - Main pool:
+ - Memory for decompressed solid block
+ - Memory for temprorary buffers, if BCJ2 fileter is used. Usually these
+ temprorary buffers can be about 15% of solid block size.
+
+
+7z Decoder doesn't allocate memory for compressed blocks.
+Instead of this, you must allocate buffer with desired
+size before calling 7z Decoder. Use 7zMain.c as example.
+
+
+Defines
+-------
+
+_SZ_ALLOC_DEBUG - define it if you want to debug alloc/free operations to stderr.
+
+
+---
+
+http://www.7-zip.org
+http://www.7-zip.org/sdk.html
+http://www.7-zip.org/support.html
diff --git a/DOC/7zFormat.txt b/DOC/7zFormat.txt
index 9239e93..74cdfa4 100644
--- a/DOC/7zFormat.txt
+++ b/DOC/7zFormat.txt
@@ -1,469 +1,469 @@
-7z Format description (18.06)
-----------------------------
-
-This file contains description of 7z archive format.
-7z archive can contain files compressed with any method.
-See "Methods.txt" for description for defined compressing methods.
-
-
-Format structure Overview
--------------------------
-
-Some fields can be optional.
-
-Archive structure
-~~~~~~~~~~~~~~~~~
-SignatureHeader
-[PackedStreams]
-[PackedStreamsForHeaders]
-[
- Header
- or
- {
- Packed Header
- HeaderInfo
- }
-]
-
-
-
-Header structure
-~~~~~~~~~~~~~~~~
-{
- ArchiveProperties
- AdditionalStreams
- {
- PackInfo
- {
- PackPos
- NumPackStreams
- Sizes[NumPackStreams]
- CRCs[NumPackStreams]
- }
- CodersInfo
- {
- NumFolders
- Folders[NumFolders]
- {
- NumCoders
- CodersInfo[NumCoders]
- {
- ID
- NumInStreams;
- NumOutStreams;
- PropertiesSize
- Properties[PropertiesSize]
- }
- NumBindPairs
- BindPairsInfo[NumBindPairs]
- {
- InIndex;
- OutIndex;
- }
- PackedIndices
- }
- UnPackSize[Folders][Folders.NumOutstreams]
- CRCs[NumFolders]
- }
- SubStreamsInfo
- {
- NumUnPackStreamsInFolders[NumFolders];
- UnPackSizes[]
- CRCs[]
- }
- }
- MainStreamsInfo
- {
- (Same as in AdditionalStreams)
- }
- FilesInfo
- {
- NumFiles
- Properties[]
- {
- ID
- Size
- Data
- }
- }
-}
-
-HeaderInfo structure
-~~~~~~~~~~~~~~~~~~~~
-{
- (Same as in AdditionalStreams)
-}
-
-
-
-Notes about Notation and encoding
----------------------------------
-
-7z uses little endian encoding.
-
-7z archive format has optional headers that are marked as
-[]
-Header
-[]
-
-REAL_UINT64 means real UINT64.
-
-UINT64 means real UINT64 encoded with the following scheme:
-
- Size of encoding sequence depends from first byte:
- First_Byte Extra_Bytes Value
- (binary)
- 0xxxxxxx : ( xxxxxxx )
- 10xxxxxx BYTE y[1] : ( xxxxxx << (8 * 1)) + y
- 110xxxxx BYTE y[2] : ( xxxxx << (8 * 2)) + y
- ...
- 1111110x BYTE y[6] : ( x << (8 * 6)) + y
- 11111110 BYTE y[7] : y
- 11111111 BYTE y[8] : y
-
-
-
-Property IDs
-------------
-
-0x00 = kEnd
-
-0x01 = kHeader
-
-0x02 = kArchiveProperties
-
-0x03 = kAdditionalStreamsInfo
-0x04 = kMainStreamsInfo
-0x05 = kFilesInfo
-
-0x06 = kPackInfo
-0x07 = kUnPackInfo
-0x08 = kSubStreamsInfo
-
-0x09 = kSize
-0x0A = kCRC
-
-0x0B = kFolder
-
-0x0C = kCodersUnPackSize
-0x0D = kNumUnPackStream
-
-0x0E = kEmptyStream
-0x0F = kEmptyFile
-0x10 = kAnti
-
-0x11 = kName
-0x12 = kCTime
-0x13 = kATime
-0x14 = kMTime
-0x15 = kWinAttributes
-0x16 = kComment
-
-0x17 = kEncodedHeader
-
-0x18 = kStartPos
-0x19 = kDummy
-
-
-7z format headers
------------------
-
-SignatureHeader
-~~~~~~~~~~~~~~~
- BYTE kSignature[6] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
-
- ArchiveVersion
- {
- BYTE Major; // now = 0
- BYTE Minor; // now = 4
- };
-
- UINT32 StartHeaderCRC;
-
- StartHeader
- {
- REAL_UINT64 NextHeaderOffset
- REAL_UINT64 NextHeaderSize
- UINT32 NextHeaderCRC
- }
-
-
-...........................
-
-
-ArchiveProperties
-~~~~~~~~~~~~~~~~~
-BYTE NID::kArchiveProperties (0x02)
-for (;;)
-{
- BYTE PropertyType;
- if (aType == 0)
- break;
- UINT64 PropertySize;
- BYTE PropertyData[PropertySize];
-}
-
-
-Digests (NumStreams)
-~~~~~~~~~~~~~~~~~~~~~
- BYTE AllAreDefined
- if (AllAreDefined == 0)
- {
- for(NumStreams)
- BIT Defined
- }
- UINT32 CRCs[NumDefined]
-
-
-PackInfo
-~~~~~~~~~~~~
- BYTE NID::kPackInfo (0x06)
- UINT64 PackPos
- UINT64 NumPackStreams
-
- []
- BYTE NID::kSize (0x09)
- UINT64 PackSizes[NumPackStreams]
- []
-
- []
- BYTE NID::kCRC (0x0A)
- PackStreamDigests[NumPackStreams]
- []
-
- BYTE NID::kEnd
-
-
-Folder
-~~~~~~
- UINT64 NumCoders;
- for (NumCoders)
- {
- BYTE
- {
- 0:3 CodecIdSize
- 4: Is Complex Coder
- 5: There Are Attributes
- 6: Reserved
- 7: There are more alternative methods. (Not used anymore, must be 0).
- }
- BYTE CodecId[CodecIdSize]
- if (Is Complex Coder)
- {
- UINT64 NumInStreams;
- UINT64 NumOutStreams;
- }
- if (There Are Attributes)
- {
- UINT64 PropertiesSize
- BYTE Properties[PropertiesSize]
- }
- }
-
- NumBindPairs = NumOutStreamsTotal - 1;
-
- for (NumBindPairs)
- {
- UINT64 InIndex;
- UINT64 OutIndex;
- }
-
- NumPackedStreams = NumInStreamsTotal - NumBindPairs;
- if (NumPackedStreams > 1)
- for(NumPackedStreams)
- {
- UINT64 Index;
- };
-
-
-
-
-Coders Info
-~~~~~~~~~~~
-
- BYTE NID::kUnPackInfo (0x07)
-
-
- BYTE NID::kFolder (0x0B)
- UINT64 NumFolders
- BYTE External
- switch(External)
- {
- case 0:
- Folders[NumFolders]
- case 1:
- UINT64 DataStreamIndex
- }
-
-
- BYTE ID::kCodersUnPackSize (0x0C)
- for(Folders)
- for(Folder.NumOutStreams)
- UINT64 UnPackSize;
-
-
- []
- BYTE NID::kCRC (0x0A)
- UnPackDigests[NumFolders]
- []
-
-
-
- BYTE NID::kEnd
-
-
-
-SubStreams Info
-~~~~~~~~~~~~~~
- BYTE NID::kSubStreamsInfo; (0x08)
-
- []
- BYTE NID::kNumUnPackStream; (0x0D)
- UINT64 NumUnPackStreamsInFolders[NumFolders];
- []
-
-
- []
- BYTE NID::kSize (0x09)
- UINT64 UnPackSizes[]
- []
-
-
- []
- BYTE NID::kCRC (0x0A)
- Digests[Number of streams with unknown CRC]
- []
-
-
- BYTE NID::kEnd
-
-
-Streams Info
-~~~~~~~~~~~~
-
- []
- PackInfo
- []
-
-
- []
- CodersInfo
- []
-
-
- []
- SubStreamsInfo
- []
-
- BYTE NID::kEnd
-
-
-FilesInfo
-~~~~~~~~~
- BYTE NID::kFilesInfo; (0x05)
- UINT64 NumFiles
-
- for (;;)
- {
- BYTE PropertyType;
- if (aType == 0)
- break;
-
- UINT64 Size;
-
- switch(PropertyType)
- {
- kEmptyStream: (0x0E)
- for(NumFiles)
- BIT IsEmptyStream
-
- kEmptyFile: (0x0F)
- for(EmptyStreams)
- BIT IsEmptyFile
-
- kAnti: (0x10)
- for(EmptyStreams)
- BIT IsAntiFile
-
- case kCTime: (0x12)
- case kATime: (0x13)
- case kMTime: (0x14)
- BYTE AllAreDefined
- if (AllAreDefined == 0)
- {
- for(NumFiles)
- BIT TimeDefined
- }
- BYTE External;
- if(External != 0)
- UINT64 DataIndex
- []
- for(Definded Items)
- REAL_UINT64 Time
- []
-
- kNames: (0x11)
- BYTE External;
- if(External != 0)
- UINT64 DataIndex
- []
- for(Files)
- {
- wchar_t Names[NameSize];
- wchar_t 0;
- }
- []
-
- kAttributes: (0x15)
- BYTE AllAreDefined
- if (AllAreDefined == 0)
- {
- for(NumFiles)
- BIT AttributesAreDefined
- }
- BYTE External;
- if(External != 0)
- UINT64 DataIndex
- []
- for(Definded Attributes)
- UINT32 Attributes
- []
- }
- }
-
-
-Header
-~~~~~~
- BYTE NID::kHeader (0x01)
-
- []
- ArchiveProperties
- []
-
- []
- BYTE NID::kAdditionalStreamsInfo; (0x03)
- StreamsInfo
- []
-
- []
- BYTE NID::kMainStreamsInfo; (0x04)
- StreamsInfo
- []
-
- []
- FilesInfo
- []
-
- BYTE NID::kEnd
-
-
-HeaderInfo
-~~~~~~~~~~
- []
- BYTE NID::kEncodedHeader; (0x17)
- StreamsInfo for Encoded Header
- []
-
-
----
-End of document
+7z Format description (18.06)
+----------------------------
+
+This file contains description of 7z archive format.
+7z archive can contain files compressed with any method.
+See "Methods.txt" for description for defined compressing methods.
+
+
+Format structure Overview
+-------------------------
+
+Some fields can be optional.
+
+Archive structure
+~~~~~~~~~~~~~~~~~
+SignatureHeader
+[PackedStreams]
+[PackedStreamsForHeaders]
+[
+ Header
+ or
+ {
+ Packed Header
+ HeaderInfo
+ }
+]
+
+
+
+Header structure
+~~~~~~~~~~~~~~~~
+{
+ ArchiveProperties
+ AdditionalStreams
+ {
+ PackInfo
+ {
+ PackPos
+ NumPackStreams
+ Sizes[NumPackStreams]
+ CRCs[NumPackStreams]
+ }
+ CodersInfo
+ {
+ NumFolders
+ Folders[NumFolders]
+ {
+ NumCoders
+ CodersInfo[NumCoders]
+ {
+ ID
+ NumInStreams;
+ NumOutStreams;
+ PropertiesSize
+ Properties[PropertiesSize]
+ }
+ NumBindPairs
+ BindPairsInfo[NumBindPairs]
+ {
+ InIndex;
+ OutIndex;
+ }
+ PackedIndices
+ }
+ UnPackSize[Folders][Folders.NumOutstreams]
+ CRCs[NumFolders]
+ }
+ SubStreamsInfo
+ {
+ NumUnPackStreamsInFolders[NumFolders];
+ UnPackSizes[]
+ CRCs[]
+ }
+ }
+ MainStreamsInfo
+ {
+ (Same as in AdditionalStreams)
+ }
+ FilesInfo
+ {
+ NumFiles
+ Properties[]
+ {
+ ID
+ Size
+ Data
+ }
+ }
+}
+
+HeaderInfo structure
+~~~~~~~~~~~~~~~~~~~~
+{
+ (Same as in AdditionalStreams)
+}
+
+
+
+Notes about Notation and encoding
+---------------------------------
+
+7z uses little endian encoding.
+
+7z archive format has optional headers that are marked as
+[]
+Header
+[]
+
+REAL_UINT64 means real UINT64.
+
+UINT64 means real UINT64 encoded with the following scheme:
+
+ Size of encoding sequence depends from first byte:
+ First_Byte Extra_Bytes Value
+ (binary)
+ 0xxxxxxx : ( xxxxxxx )
+ 10xxxxxx BYTE y[1] : ( xxxxxx << (8 * 1)) + y
+ 110xxxxx BYTE y[2] : ( xxxxx << (8 * 2)) + y
+ ...
+ 1111110x BYTE y[6] : ( x << (8 * 6)) + y
+ 11111110 BYTE y[7] : y
+ 11111111 BYTE y[8] : y
+
+
+
+Property IDs
+------------
+
+0x00 = kEnd
+
+0x01 = kHeader
+
+0x02 = kArchiveProperties
+
+0x03 = kAdditionalStreamsInfo
+0x04 = kMainStreamsInfo
+0x05 = kFilesInfo
+
+0x06 = kPackInfo
+0x07 = kUnPackInfo
+0x08 = kSubStreamsInfo
+
+0x09 = kSize
+0x0A = kCRC
+
+0x0B = kFolder
+
+0x0C = kCodersUnPackSize
+0x0D = kNumUnPackStream
+
+0x0E = kEmptyStream
+0x0F = kEmptyFile
+0x10 = kAnti
+
+0x11 = kName
+0x12 = kCTime
+0x13 = kATime
+0x14 = kMTime
+0x15 = kWinAttributes
+0x16 = kComment
+
+0x17 = kEncodedHeader
+
+0x18 = kStartPos
+0x19 = kDummy
+
+
+7z format headers
+-----------------
+
+SignatureHeader
+~~~~~~~~~~~~~~~
+ BYTE kSignature[6] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
+
+ ArchiveVersion
+ {
+ BYTE Major; // now = 0
+ BYTE Minor; // now = 4
+ };
+
+ UINT32 StartHeaderCRC;
+
+ StartHeader
+ {
+ REAL_UINT64 NextHeaderOffset
+ REAL_UINT64 NextHeaderSize
+ UINT32 NextHeaderCRC
+ }
+
+
+...........................
+
+
+ArchiveProperties
+~~~~~~~~~~~~~~~~~
+BYTE NID::kArchiveProperties (0x02)
+for (;;)
+{
+ BYTE PropertyType;
+ if (aType == 0)
+ break;
+ UINT64 PropertySize;
+ BYTE PropertyData[PropertySize];
+}
+
+
+Digests (NumStreams)
+~~~~~~~~~~~~~~~~~~~~~
+ BYTE AllAreDefined
+ if (AllAreDefined == 0)
+ {
+ for(NumStreams)
+ BIT Defined
+ }
+ UINT32 CRCs[NumDefined]
+
+
+PackInfo
+~~~~~~~~~~~~
+ BYTE NID::kPackInfo (0x06)
+ UINT64 PackPos
+ UINT64 NumPackStreams
+
+ []
+ BYTE NID::kSize (0x09)
+ UINT64 PackSizes[NumPackStreams]
+ []
+
+ []
+ BYTE NID::kCRC (0x0A)
+ PackStreamDigests[NumPackStreams]
+ []
+
+ BYTE NID::kEnd
+
+
+Folder
+~~~~~~
+ UINT64 NumCoders;
+ for (NumCoders)
+ {
+ BYTE
+ {
+ 0:3 CodecIdSize
+ 4: Is Complex Coder
+ 5: There Are Attributes
+ 6: Reserved
+ 7: There are more alternative methods. (Not used anymore, must be 0).
+ }
+ BYTE CodecId[CodecIdSize]
+ if (Is Complex Coder)
+ {
+ UINT64 NumInStreams;
+ UINT64 NumOutStreams;
+ }
+ if (There Are Attributes)
+ {
+ UINT64 PropertiesSize
+ BYTE Properties[PropertiesSize]
+ }
+ }
+
+ NumBindPairs = NumOutStreamsTotal - 1;
+
+ for (NumBindPairs)
+ {
+ UINT64 InIndex;
+ UINT64 OutIndex;
+ }
+
+ NumPackedStreams = NumInStreamsTotal - NumBindPairs;
+ if (NumPackedStreams > 1)
+ for(NumPackedStreams)
+ {
+ UINT64 Index;
+ };
+
+
+
+
+Coders Info
+~~~~~~~~~~~
+
+ BYTE NID::kUnPackInfo (0x07)
+
+
+ BYTE NID::kFolder (0x0B)
+ UINT64 NumFolders
+ BYTE External
+ switch(External)
+ {
+ case 0:
+ Folders[NumFolders]
+ case 1:
+ UINT64 DataStreamIndex
+ }
+
+
+ BYTE ID::kCodersUnPackSize (0x0C)
+ for(Folders)
+ for(Folder.NumOutStreams)
+ UINT64 UnPackSize;
+
+
+ []
+ BYTE NID::kCRC (0x0A)
+ UnPackDigests[NumFolders]
+ []
+
+
+
+ BYTE NID::kEnd
+
+
+
+SubStreams Info
+~~~~~~~~~~~~~~
+ BYTE NID::kSubStreamsInfo; (0x08)
+
+ []
+ BYTE NID::kNumUnPackStream; (0x0D)
+ UINT64 NumUnPackStreamsInFolders[NumFolders];
+ []
+
+
+ []
+ BYTE NID::kSize (0x09)
+ UINT64 UnPackSizes[]
+ []
+
+
+ []
+ BYTE NID::kCRC (0x0A)
+ Digests[Number of streams with unknown CRC]
+ []
+
+
+ BYTE NID::kEnd
+
+
+Streams Info
+~~~~~~~~~~~~
+
+ []
+ PackInfo
+ []
+
+
+ []
+ CodersInfo
+ []
+
+
+ []
+ SubStreamsInfo
+ []
+
+ BYTE NID::kEnd
+
+
+FilesInfo
+~~~~~~~~~
+ BYTE NID::kFilesInfo; (0x05)
+ UINT64 NumFiles
+
+ for (;;)
+ {
+ BYTE PropertyType;
+ if (aType == 0)
+ break;
+
+ UINT64 Size;
+
+ switch(PropertyType)
+ {
+ kEmptyStream: (0x0E)
+ for(NumFiles)
+ BIT IsEmptyStream
+
+ kEmptyFile: (0x0F)
+ for(EmptyStreams)
+ BIT IsEmptyFile
+
+ kAnti: (0x10)
+ for(EmptyStreams)
+ BIT IsAntiFile
+
+ case kCTime: (0x12)
+ case kATime: (0x13)
+ case kMTime: (0x14)
+ BYTE AllAreDefined
+ if (AllAreDefined == 0)
+ {
+ for(NumFiles)
+ BIT TimeDefined
+ }
+ BYTE External;
+ if(External != 0)
+ UINT64 DataIndex
+ []
+ for(Definded Items)
+ REAL_UINT64 Time
+ []
+
+ kNames: (0x11)
+ BYTE External;
+ if(External != 0)
+ UINT64 DataIndex
+ []
+ for(Files)
+ {
+ wchar_t Names[NameSize];
+ wchar_t 0;
+ }
+ []
+
+ kAttributes: (0x15)
+ BYTE AllAreDefined
+ if (AllAreDefined == 0)
+ {
+ for(NumFiles)
+ BIT AttributesAreDefined
+ }
+ BYTE External;
+ if(External != 0)
+ UINT64 DataIndex
+ []
+ for(Definded Attributes)
+ UINT32 Attributes
+ []
+ }
+ }
+
+
+Header
+~~~~~~
+ BYTE NID::kHeader (0x01)
+
+ []
+ ArchiveProperties
+ []
+
+ []
+ BYTE NID::kAdditionalStreamsInfo; (0x03)
+ StreamsInfo
+ []
+
+ []
+ BYTE NID::kMainStreamsInfo; (0x04)
+ StreamsInfo
+ []
+
+ []
+ FilesInfo
+ []
+
+ BYTE NID::kEnd
+
+
+HeaderInfo
+~~~~~~~~~~
+ []
+ BYTE NID::kEncodedHeader; (0x17)
+ StreamsInfo for Encoded Header
+ []
+
+
+---
+End of document
diff --git a/DOC/7zip.hhp b/DOC/7zip.hhp
new file mode 100644
index 0000000..6c6bd70
--- /dev/null
+++ b/DOC/7zip.hhp
@@ -0,0 +1,83 @@
+[OPTIONS]
+Compatibility=1.1 or later
+Compiled file=7-zip.chm
+Contents file=7zip.hhc
+Default topic=start.htm
+Display compile progress=No
+Full-text search=Yes
+Index file=7zip.hhk
+Language=0x409 English (United States)
+
+
+[FILES]
+start.htm
+general\thanks.htm
+general\faq.htm
+general\formats.htm
+general\index.htm
+general\license.htm
+general\performance.htm
+general\7z.htm
+cmdline\index.htm
+cmdline\syntax.htm
+cmdline\exit_codes.htm
+cmdline\commands\add.htm
+cmdline\commands\bench.htm
+cmdline\commands\delete.htm
+cmdline\commands\extract.htm
+cmdline\commands\extract_full.htm
+cmdline\commands\update.htm
+cmdline\commands\hash.htm
+cmdline\commands\index.htm
+cmdline\commands\list.htm
+cmdline\commands\rename.htm
+cmdline\commands\test.htm
+cmdline\switches\index.htm
+cmdline\switches\yes.htm
+cmdline\switches\include.htm
+cmdline\switches\method.htm
+cmdline\switches\ar_include.htm
+cmdline\switches\ar_exclude.htm
+cmdline\switches\ar_no.htm
+cmdline\switches\bb.htm
+cmdline\switches\bs.htm
+cmdline\switches\charset.htm
+cmdline\switches\email.htm
+cmdline\switches\list_tech.htm
+cmdline\switches\large_pages.htm
+cmdline\switches\output_dir.htm
+cmdline\switches\overwrite.htm
+cmdline\switches\password.htm
+cmdline\switches\recurse.htm
+cmdline\switches\sa.htm
+cmdline\switches\scc.htm
+cmdline\switches\scrc.htm
+cmdline\switches\sdel.htm
+cmdline\switches\sfx.htm
+cmdline\switches\shared.htm
+cmdline\switches\sni.htm
+cmdline\switches\sns.htm
+cmdline\switches\spf.htm
+cmdline\switches\spm.htm
+cmdline\switches\ssc.htm
+cmdline\switches\stdin.htm
+cmdline\switches\stdout.htm
+cmdline\switches\stl.htm
+cmdline\switches\stop_switch.htm
+cmdline\switches\stx.htm
+cmdline\switches\type.htm
+cmdline\switches\update.htm
+cmdline\switches\working_dir.htm
+cmdline\switches\exclude.htm
+fm\options.htm
+fm\benchmark.htm
+fm\index.htm
+fm\menu.htm
+fm\about.htm
+fm\plugins\index.htm
+fm\plugins\7-zip\extract.htm
+fm\plugins\7-zip\index.htm
+fm\plugins\7-zip\add.htm
+
+[INFOTYPES]
+
diff --git a/DOC/7zip.wxs b/DOC/7zip.wxs
new file mode 100644
index 0000000..df1d320
--- /dev/null
+++ b/DOC/7zip.wxs
@@ -0,0 +1,403 @@
+<?xml version="1.0"?>
+
+<?define VerMajor = "23" ?>
+<?define VerMinor = "01" ?>
+<?define VerBuild = "00" ?>
+<?define MmVer = "$(var.VerMajor).$(var.VerMinor)" ?>
+<?define MmHex = "$(var.VerMajor)$(var.VerMinor)" ?>
+<?define MmmmVer = "$(var.MmVer).$(var.VerBuild).0" ?>
+<?define UpgradeMinVer = "4.38" ?>
+
+<?define ProductName = "7-Zip" ?>
+
+<?ifndef MyCPU?>
+ <?define MyCPU = "Intel" ?>
+<?endif?>
+
+<?if $(var.MyCPU) = "x64" ?>
+ <?define CpuId = "2" ?>
+ <?define PFilesFolder = "ProgramFiles64Folder" ?>
+ <?define Platforms = "x64" ?>
+ <?define CpuPostfix = " (x64 edition)" ?>
+ <?define Is64 = "yes" ?>
+ <?define NumBits = "64" ?>
+<?elseif $(var.MyCPU) = "ia64" ?>
+ <?define CpuId = "3" ?>
+ <?define PFilesFolder = "ProgramFiles64Folder" ?>
+ <?define Platforms = "Intel64" ?>
+ <?define CpuPostfix = " (ia64 edition)" ?>
+ <?define Is64 = "yes" ?>
+ <?define NumBits = "64" ?>
+<?else ?>
+ <?define CpuId = "1" ?>
+ <?define PFilesFolder = "ProgramFilesFolder" ?>
+ <?define Platforms = "Intel" ?>
+ <?define CpuPostfix = "" ?>
+ <?define Is64 = "no" ?>
+ <?define NumBits = "32" ?>
+<?endif ?>
+
+
+<?define ShellExtId = "{23170F69-40C1-278A-1000-000100020000}" ?>
+
+<?define BaseId = "23170F69-40C1-270$(var.CpuId)" ?>
+<?define BaseIdVer = "$(var.BaseId)-$(var.MmHex)-$(var.VerBuild)00" ?>
+<?define ProductId = "$(var.BaseIdVer)01000000" ?>
+<?define PackageId = "$(var.BaseIdVer)02000000" ?>
+<?define CompId = "$(var.BaseIdVer)030000" ?>
+<?define UpgradeCode = "$(var.BaseId)-0000-000004000000" ?>
+
+<?define CompFm = "$(var.CompId)01" ?>
+<?define CompShellExt = "$(var.CompId)02" ?>
+<?define CompCmdLine = "$(var.CompId)03" ?>
+<?define CompCmdLineA = "$(var.CompId)04" ?>
+<?define CompGui = "$(var.CompId)05" ?>
+<?define CompGuiSfx = "$(var.CompId)06" ?>
+<?define CompConSfx = "$(var.CompId)07" ?>
+<?define CompHelp = "$(var.CompId)08" ?>
+<?define CompDocs = "$(var.CompId)09" ?>
+<?define CompFormats = "$(var.CompId)10" ?>
+<?define CompCodecs = "$(var.CompId)11" ?>
+<?define CompLang = "$(var.CompId)12" ?>
+<?define CompShellExt2 = "$(var.CompId)13" ?>
+<?define CompInstallRegCU = "$(var.CompId)80" ?>
+<?define CompInstallRegLM = "$(var.CompId)81" ?>
+<?define CompInstallRegWild = "$(var.CompId)82" ?>
+<?define CompInstallRegDirectory = "$(var.CompId)83" ?>
+<?define CompInstallRegDirDD = "$(var.CompId)84" ?>
+<?define CompInstallRegDriveDD = "$(var.CompId)85" ?>
+<?define CompInstallRegApproved = "$(var.CompId)86" ?>
+<?define CompInstallRegAppPath = "$(var.CompId)87" ?>
+<?define CompInstallRegFolder = "$(var.CompId)88" ?>
+
+
+<?define Manufacturer = "Igor Pavlov" ?>
+<?define HomePage = "http://www.7-zip.org/" ?>
+<?define AboutURL = "$(var.HomePage)" ?>
+<?define UpdatesURL = "$(var.HomePage)download.html" ?>
+<?define SupportURL = "$(var.HomePage)support.html" ?>
+
+<Wix xmlns="http://schemas.microsoft.com/wix/2003/01/wi">
+ <Product
+ Id="$(var.ProductId)"
+ UpgradeCode="$(var.UpgradeCode)"
+ Name="$(var.ProductName) $(var.MmVer)$(var.CpuPostfix)"
+ Language="1033"
+ Version="$(var.MmmmVer)"
+ Manufacturer="$(var.Manufacturer)">
+
+ <Package
+ Id="$(var.PackageId)"
+ Description="$(var.ProductName)$(var.CpuPostfix) Package"
+ Comments="$(var.ProductName)$(var.CpuPostfix) Package"
+ Manufacturer="$(var.Manufacturer)"
+ InstallerVersion="200"
+ Compressed="yes"
+ Platforms="$(var.Platforms)"
+ />
+
+ <!-- Major upgrade -->
+ <Upgrade Id="$(var.UpgradeCode)">
+ <UpgradeVersion Minimum="$(var.UpgradeMinVer)" IncludeMinimum="yes"
+ Maximum="$(var.MmmmVer)" IncludeMaximum="no" Property="OLDERVERSIONBEINGUPGRADED" />
+ </Upgrade>
+
+ <Media Id="1" Cabinet="product.cab" EmbedCab="yes" CompressionLevel="high" />
+
+ <Property Id="MSIRMSHUTDOWN" Value="2"/>
+
+ <Property Id="INSTALLDIR">
+ <RegistrySearch Id="My7zipPathLM" Type="raw" Root="HKLM" Key="Software\7-Zip" Name="Path" />
+ <RegistrySearch Id="My7zipPathLM2" Type="raw" Root="HKLM" Key="Software\7-Zip" Name="Path$(var.NumBits)" />
+ <RegistrySearch Id="My7zipPath" Type="raw" Root="HKCU" Key="Software\7-Zip" Name="Path" />
+ <RegistrySearch Id="My7zipPath2" Type="raw" Root="HKCU" Key="Software\7-Zip" Name="Path$(var.NumBits)" />
+ </Property>
+
+ <Property Id="ALLUSERS">2</Property>
+
+ <Property Id="LicenseAccepted">1</Property>
+
+ <Property Id="ARPURLINFOABOUT" Value="$(var.AboutURL)" />
+ <Property Id="ARPHELPLINK" Value="$(var.SupportURL)" />
+ <Property Id="ARPURLUPDATEINFO" Value="$(var.UpdatesURL)" />
+
+
+ <Directory Id="TARGETDIR" Name="SourceDir">
+ <Directory Id="$(var.PFilesFolder)" Name="Files">
+ <Directory Id="INSTALLDIR" Name="7-Zip">
+
+ <Component Id="InstallRegCU" Guid="$(var.CompInstallRegCU)" DiskId="1" Win64="$(var.Is64)">
+ <Registry Id="MyInstallRegCU" Root="HKCU" Key="Software\7-Zip" Name="Path" Action="write" Type="string" Value="[INSTALLDIR]" />
+ <Registry Id="MyInstallRegCU2" Root="HKCU" Key="Software\7-Zip" Name="Path$(var.NumBits)" Action="write" Type="string" Value="[INSTALLDIR]" />
+ </Component>
+ <Component Id="InstallRegLM" Guid="$(var.CompInstallRegLM)" DiskId="1" Win64="$(var.Is64)">
+ <Condition>Privileged</Condition>
+ <Registry Id="MyInstallRegLM" Root="HKLM" Key="Software\7-Zip" Name="Path" Action="write" Type="string" Value="[INSTALLDIR]" />
+ <Registry Id="MyInstallRegLM2" Root="HKLM" Key="Software\7-Zip" Name="Path$(var.NumBits)" Action="write" Type="string" Value="[INSTALLDIR]" />
+ </Component>
+
+
+ <Component Id="InstallRegWild" Guid="$(var.CompInstallRegWild)" DiskId="1" Win64="$(var.Is64)">
+ <Registry Id="MyInstallRegWild" Action="write" Type="string"
+ Root="HKCR" Key="*\shellex\ContextMenuHandlers\7-Zip"
+ Value="$(var.ShellExtId)" />
+ </Component>
+
+ <Component Id="InstallRegDirectory" Guid="$(var.CompInstallRegDirectory)" DiskId="1" Win64="$(var.Is64)">
+ <Registry Id="MyInstallRegDirectory" Action="write" Type="string"
+ Root="HKCR" Key="Directory\shellex\ContextMenuHandlers\7-Zip"
+ Value="$(var.ShellExtId)" />
+ </Component>
+
+ <Component Id="InstallRegFolder" Guid="$(var.CompInstallRegFolder)" DiskId="1" Win64="$(var.Is64)">
+ <Registry Id="MyInstallRegFolder" Action="write" Type="string"
+ Root="HKCR" Key="Folder\shellex\ContextMenuHandlers\7-Zip"
+ Value="$(var.ShellExtId)" />
+ </Component>
+
+ <Component Id="InstallRegDirDD" Guid="$(var.CompInstallRegDirDD)" DiskId="1" Win64="$(var.Is64)">
+ <Registry Id="MyInstallRegDirDD" Action="write" Type="string"
+ Root="HKCR" Key="Directory\shellex\DragDropHandlers\7-Zip"
+ Value="$(var.ShellExtId)" />
+ </Component>
+
+ <Component Id="InstallRegDriveDD" Guid="$(var.CompInstallRegDriveDD)" DiskId="1" Win64="$(var.Is64)">
+ <Registry Id="MyInstallRegDriveDD" Action="write" Type="string"
+ Root="HKCR" Key="Drive\shellex\DragDropHandlers\7-Zip"
+ Value="$(var.ShellExtId)" />
+ </Component>
+
+ <Component Id="InstallRegApproved" Guid="$(var.CompInstallRegApproved)" DiskId="1" Win64="$(var.Is64)">
+ <Condition>Privileged</Condition>
+ <Registry Id="MyInstallRegApproved" Action="write" Type="string"
+ Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\Shell Extensions\Approved"
+ Name="$(var.ShellExtId)" Value="7-Zip Shell Extension" />
+ </Component>
+
+
+ <Component Id="InstallRegAppPath" Guid="$(var.CompInstallRegAppPath)" DiskId="1" Win64="$(var.Is64)">
+ <Condition>Privileged</Condition>
+ <Registry Id="MyInstallRegAppPath" Action="write" Type="string"
+ Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\7zFM.exe"
+ Value="[INSTALLDIR]7zFM.exe" />
+ <Registry Id="MyInstallRegAppPath2" Action="write" Type="string"
+ Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\7zFM.exe" Name="Path"
+ Value="[INSTALLDIR]" />
+ </Component>
+
+ <Component Id="Fm" Guid="$(var.CompFm)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7zFM.exe" Name="7zFM.exe">
+ <Shortcut Id="startmenuFmShortcut" Directory="PMenu" Name="7zipFM" LongName="7-Zip File Manager" />
+ </File>
+ </Component>
+
+ <?if $(var.MyCPU) = "x64" ?>
+
+ <Component Id="ShellExt32" Guid="$(var.CompShellExt2)" DiskId="1" Win64="no">
+ <File Id="_7zip32.dll" Name="7-zip32.dll" />
+ <Registry Id="shellReg0_32" Action="write" Type="string" Root="HKCR"
+ Key="CLSID\$(var.ShellExtId)\InprocServer32"
+ Value="[INSTALLDIR]7-zip32.dll" />
+ <Registry Id="shellReg1_32" Action="write" Type="string" Root="HKCR"
+ Key="CLSID\$(var.ShellExtId)\InprocServer32"
+ Name="ThreadingModel"
+ Value="Apartment" />
+ </Component>
+
+ <?endif ?>
+
+ <Component Id="ShellExt" Guid="$(var.CompShellExt)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7zip.dll" Name="7-zip.dll" />
+ <Registry Id="shellReg0" Action="write" Type="string" Root="HKCR"
+ Key="CLSID\$(var.ShellExtId)\InprocServer32"
+ Value="[INSTALLDIR]7-zip.dll" />
+ <Registry Id="shellReg1" Action="write" Type="string" Root="HKCR"
+ Key="CLSID\$(var.ShellExtId)\InprocServer32"
+ Name="ThreadingModel"
+ Value="Apartment" />
+ </Component>
+
+ <Component Id="Gui" Guid="$(var.CompGui)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7zG.exe" Name="7zG.exe" />
+ </Component>
+
+ <Component Id="Formats" Guid="$(var.CompFormats)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7z.dll" Name="7z.dll" />
+ </Component>
+
+ <Component Id="CmdLine" Guid="$(var.CompCmdLine)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7z.exe" Name="7z.exe" />
+ </Component>
+
+ <Component Id="GuiSfx" Guid="$(var.CompGuiSfx)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7z.sfx" Name="7z.sfx" />
+ </Component>
+
+ <Component Id="ConSfx" Guid="$(var.CompConSfx)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="_7zCon.sfx" Name="7zCon.sfx" />
+ </Component>
+
+ <Component Id="Docs" Guid="$(var.CompDocs)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="descript.ion" Name="descript.ion" />
+ <File Id="History.txt" Name="History.txt" />
+ <File Id="License.txt" Name="License.txt" />
+ <File Id="readme.txt" Name="readme.txt" />
+ </Component>
+
+
+ <Component Id="Help" Guid="$(var.CompHelp)">
+ <File Id="_7zip.chm" Name="7-zip.chm" DiskId="1" >
+ <Shortcut Id="startmenuHelpShortcut" Directory="PMenu" Name="7zipHelp" LongName="7-Zip Help" />
+ </File>
+ </Component>
+
+ <Directory Id="MyLang" Name="Lang">
+ <Component Id="Lang" Guid="$(var.CompLang)" DiskId="1" Win64="$(var.Is64)">
+ <File Id="en.ttt" Name="en.ttt" />
+ <File Id="af.txt" Name="af.txt" />
+ <File Id="an.txt" Name="an.txt" />
+ <File Id="ar.txt" Name="ar.txt" />
+ <File Id="ast.txt" Name="ast.txt" />
+ <File Id="az.txt" Name="az.txt" />
+ <File Id="ba.txt" Name="ba.txt" />
+ <File Id="be.txt" Name="be.txt" />
+ <File Id="bg.txt" Name="bg.txt" />
+ <File Id="bn.txt" Name="bn.txt" />
+ <File Id="br.txt" Name="br.txt" />
+ <File Id="ca.txt" Name="ca.txt" />
+ <File Id="co.txt" Name="co.txt" />
+ <File Id="cs.txt" Name="cs.txt" />
+ <File Id="cy.txt" Name="cy.txt" />
+ <File Id="da.txt" Name="da.txt" />
+ <File Id="de.txt" Name="de.txt" />
+ <File Id="el.txt" Name="el.txt" />
+ <File Id="eo.txt" Name="eo.txt" />
+ <File Id="es.txt" Name="es.txt" />
+ <File Id="et.txt" Name="et.txt" />
+ <File Id="eu.txt" Name="eu.txt" />
+ <File Id="ext.txt" Name="ext.txt" />
+ <File Id="fa.txt" Name="fa.txt" />
+ <File Id="fi.txt" Name="fi.txt" />
+ <File Id="fr.txt" Name="fr.txt" />
+ <File Id="fur.txt" Name="fur.txt" />
+ <File Id="fy.txt" Name="fy.txt" />
+ <File Id="ga.txt" Name="ga.txt" />
+ <File Id="gl.txt" Name="gl.txt" />
+ <File Id="gu.txt" Name="gu.txt" />
+ <File Id="he.txt" Name="he.txt" />
+ <File Id="hi.txt" Name="hi.txt" />
+ <File Id="hr.txt" Name="hr.txt" />
+ <File Id="hu.txt" Name="hu.txt" />
+ <File Id="hy.txt" Name="hy.txt" />
+ <File Id="id.txt" Name="id.txt" />
+ <File Id="io.txt" Name="io.txt" />
+ <File Id="is.txt" Name="is.txt" />
+ <File Id="it.txt" Name="it.txt" />
+ <File Id="ja.txt" Name="ja.txt" />
+ <File Id="ka.txt" Name="ka.txt" />
+ <File Id="kaa.txt" Name="kaa.txt" />
+ <File Id="kab.txt" Name="kab.txt" />
+ <File Id="kk.txt" Name="kk.txt" />
+ <File Id="ko.txt" Name="ko.txt" />
+ <File Id="ku.txt" Name="ku.txt" />
+ <File Id="ku_ckb.txt" Name="ku-ckb.txt" />
+ <File Id="ky.txt" Name="ky.txt" />
+ <File Id="lij.txt" Name="lij.txt" />
+ <File Id="lt.txt" Name="lt.txt" />
+ <File Id="lv.txt" Name="lv.txt" />
+ <File Id="mk.txt" Name="mk.txt" />
+ <File Id="mn.txt" Name="mn.txt" />
+ <File Id="mng.txt" Name="mng.txt" />
+ <File Id="mng2.txt" Name="mng2.txt" />
+ <File Id="mr.txt" Name="mr.txt" />
+ <File Id="ms.txt" Name="ms.txt" />
+ <File Id="ne.txt" Name="ne.txt" />
+ <File Id="nl.txt" Name="nl.txt" />
+ <File Id="nb.txt" Name="nb.txt" />
+ <File Id="nn.txt" Name="nn.txt" />
+ <File Id="pa_in.txt" Name="pa-in.txt" />
+ <File Id="pl.txt" Name="pl.txt" />
+ <File Id="ps.txt" Name="ps.txt" />
+ <File Id="pt.txt" Name="pt.txt" />
+ <File Id="pt_br.txt" Name="pt-br.txt" />
+ <File Id="ro.txt" Name="ro.txt" />
+ <File Id="ru.txt" Name="ru.txt" />
+ <File Id="sa.txt" Name="sa.txt" />
+ <File Id="si.txt" Name="si.txt" />
+ <File Id="sk.txt" Name="sk.txt" />
+ <File Id="sl.txt" Name="sl.txt" />
+ <File Id="sq.txt" Name="sq.txt" />
+ <File Id="sr_spl.txt" Name="sr-spl.txt" />
+ <File Id="sr_spc.txt" Name="sr-spc.txt" />
+ <File Id="sv.txt" Name="sv.txt" />
+ <File Id="sw.txt" Name="sw.txt" />
+ <File Id="ta.txt" Name="ta.txt" />
+ <File Id="tg.txt" Name="tg.txt" />
+ <File Id="th.txt" Name="th.txt" />
+ <File Id="tk.txt" Name="tk.txt" />
+ <File Id="tr.txt" Name="tr.txt" />
+ <File Id="tt.txt" Name="tt.txt" />
+ <File Id="ug.txt" Name="ug.txt" />
+ <File Id="uk.txt" Name="uk.txt" />
+ <File Id="uz.txt" Name="uz.txt" />
+ <File Id="uz_cyrl.txt" Name="uz-cyrl.txt" />
+ <File Id="va.txt" Name="va.txt" />
+ <File Id="vi.txt" Name="vi.txt" />
+ <File Id="yo.txt" Name="yo.txt" />
+ <File Id="zh_cn.txt" Name="zh-cn.txt" />
+ <File Id="zh_tw.txt" Name="zh-tw.txt" />
+ </Component>
+ </Directory>
+
+
+ </Directory>
+ </Directory>
+
+ <Directory Id="ProgramMenuFolder" Name="PMenu" LongName="Programs">
+ <Directory Id="PMenu" Name="7zip" LongName="7-Zip" />
+ </Directory>
+ </Directory>
+
+ <Feature Id="Complete" Title="7-Zip" Description="The complete package."
+ Display="expand" Level="1" ConfigurableDirectory="INSTALLDIR"
+ Absent="disallow" AllowAdvertise="no" >
+ <Feature Id="Program" Title="Program files" Description="Program files." Level="1"
+ Absent="disallow" AllowAdvertise="no">
+ <ComponentRef Id="Fm" />
+ <ComponentRef Id="ShellExt" />
+ <?if $(var.MyCPU) = "x64" ?>
+ <ComponentRef Id="ShellExt32" />
+ <?endif ?>
+ <ComponentRef Id="CmdLine" />
+ <ComponentRef Id="Gui" />
+ <ComponentRef Id="GuiSfx" />
+ <ComponentRef Id="ConSfx" />
+ <ComponentRef Id="Formats" />
+ <ComponentRef Id="Docs" />
+ <ComponentRef Id="Help" />
+ <ComponentRef Id="InstallRegCU" />
+ <ComponentRef Id="InstallRegLM" />
+ <ComponentRef Id="InstallRegWild" />
+ <ComponentRef Id="InstallRegDirectory" />
+ <ComponentRef Id="InstallRegDirDD" />
+ <ComponentRef Id="InstallRegDriveDD" />
+ <ComponentRef Id="InstallRegApproved" />
+ <ComponentRef Id="InstallRegAppPath" />
+ <ComponentRef Id="InstallRegFolder" />
+
+ </Feature>
+ <Feature Id="LanguageFiles" Title="Localization files" Description="Localization files for 71 languages."
+ Level="1" AllowAdvertise="no">
+ <ComponentRef Id="Lang" />
+ </Feature>
+ </Feature>
+
+ <UIRef Id="WixUI" />
+
+ <!-- Install Sequences -->
+ <InstallExecuteSequence>
+ <RemoveExistingProducts After="InstallValidate" />
+ </InstallExecuteSequence>
+
+ </Product>
+</Wix>
diff --git a/DOC/License.txt b/DOC/License.txt
new file mode 100644
index 0000000..c9e858f
--- /dev/null
+++ b/DOC/License.txt
@@ -0,0 +1,90 @@
+ 7-Zip source code
+ ~~~~~~~~~~~~~~~~~
+ License for use and distribution
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ 7-Zip Copyright (C) 1999-2020 Igor Pavlov.
+
+ The licenses for files are:
+
+ 1) CPP/7zip/Compress/Rar* files: the "GNU LGPL" with "unRAR license restriction"
+ 2) CPP/7zip/Compress/LzfseDecoder.cpp: the "BSD 3-clause License"
+ 3) Some files are "public domain" files, if "public domain" status is stated in source file.
+ 4) the "GNU LGPL" for all other files. If there is no license information in
+ some source file, that file is under the "GNU LGPL".
+
+ The "GNU LGPL" with "unRAR license restriction" means that you must follow both
+ "GNU LGPL" rules and "unRAR license restriction" rules.
+
+
+
+
+ GNU LGPL information
+ --------------------
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+
+
+ BSD 3-clause License
+ --------------------
+
+ The "BSD 3-clause License" is used for the code in LzfseDecoder.cpp that implements LZFSE data decompression.
+ That code was derived from the code in the "LZFSE compression library" developed by Apple Inc,
+ that also uses the "BSD 3-clause License":
+
+ ----
+ Copyright (c) 2015-2016, Apple 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. Neither the name of the copyright holder(s) nor the names of any contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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
+ COPYRIGHT OWNER OR CONTRIBUTORS 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.
+ ----
+
+
+
+
+ unRAR license restriction
+ -------------------------
+
+ The decompression engine for RAR archives was developed using source
+ code of unRAR program.
+ All copyrights to original unRAR code are owned by Alexander Roshal.
+
+ The license for original unRAR code has the following restriction:
+
+ The unRAR sources cannot be used to re-create the RAR compression algorithm,
+ which is proprietary. Distribution of modified unRAR sources in separate form
+ or as a part of other software is permitted, provided that it is clearly
+ stated in the documentation and source comments that the code may
+ not be used to develop a RAR (WinRAR) compatible archiver.
+
+
+ --
+ Igor Pavlov
diff --git a/DOC/Methods.txt b/DOC/Methods.txt
index 6d0641b..541f1c1 100644
--- a/DOC/Methods.txt
+++ b/DOC/Methods.txt
@@ -1,173 +1,176 @@
-7-Zip method IDs for 7z and xz archives
----------------------------------------
-
-Version: 18.06
-Date: 2018-06-30
-
-Each compression or crypto method in 7z is associated with unique binary value (ID).
-The length of ID in bytes is arbitrary but it can not exceed 63 bits (8 bytes).
-
-xz and 7z formats use same ID map.
-
-If you want to add some new ID, you have two ways:
- 1) Write request for allocating IDs to 7-Zip developers.
- 2) Generate 8-bytes ID:
-
- 3F ZZ ZZ ZZ ZZ ZZ MM MM
-
- 3F - Prefix for random IDs (1 byte)
- ZZ ZZ ZZ ZZ ZZ - Developer ID (5 bytes). Use real random bytes.
-
- MM MM - Method ID (2 bytes)
-
- You can notify 7-Zip developers about your Developer ID / Method ID.
-
- Note: Use new ID, if old codec can not decode data encoded with new version.
-
-
-List of defined IDs
--------------------
-
-00 - Copy
-
-03 - Delta
-04 - BCJ (x86)
-05 - PPC (big-endian)
-06 - IA64
-07 - ARM (little-endian)
-08 - ARMT (little-endian)
-09 - SPARC
-
-21 - LZMA2
-
-02.. - Common
- 03 [Swap]
- - 2 Swap2
- - 4 Swap4
-
-03.. - 7z
- 01 -
- 01 - LZMA
-
- 03 - [Branch Codecs]
- 01 - [x86 Codecs]
- 03 - BCJ
- 1B - BCJ2 (4 packed streams)
- 02 -
- 05 - PPC (big-endian)
- 03 -
- 01 - Alpha
- 04 -
- 01 - IA64
- 05 -
- 01 - ARM (little-endian)
- 06 -
- 05 - M68 (big-endian)
- 07 -
- 01 - ARMT (little-endian)
- 08 -
- 05 - SPARC
-
- 04 -
- 01 - PPMD
-
- 7F -
- 01 - experimental method.
-
-
-04.. - Misc codecs
-
- 00 - Reserved
-
- 01 - [Zip]
- 00 - Copy (not used. Use {00} instead)
- 01 - Shrink
- 06 - Implode
- 08 - Deflate
- 09 - Deflate64
- 0A - Imploding
- 0C - BZip2 (not used. Use {040202} instead)
- 0E - LZMA (LZMA-zip)
- 5F - xz
- 60 - Jpeg
- 61 - WavPack
- 62 - PPMd (PPMd-zip)
- 63 - wzAES
-
- 02 -
- 02 - BZip2
-
- 03 - [Rar]
- 01 - Rar1
- 02 - Rar2
- 03 - Rar3
- 05 - Rar5
-
- 04 - [Arj]
- 01 - Arj(1,2,3)
- 02 - Arj4
-
- 05 - [Z]
-
- 06 - [Lzh]
-
- 07 - Reserved for 7z
-
- 08 - [Cab]
-
- 09 - [NSIS]
- 01 - DeflateNSIS
- 02 - BZip2NSIS
-
- F7 - External codecs (that are not included to 7-Zip)
-
- 0x xx - reserved
-
- 10 xx - reserved (LZHAM)
- 01 - LZHAM
-
- 11 xx - reserved (Tino Reichardt)
- 01 - ZSTD
- 02 - BROTLI
- 04 - LZ4
- 05 - LZ5
- 06 - LIZARD
-
- 12 xx - reserverd (Denis Anisimov)
-
- 01 - WavPack2
- FE - eSplitter
- FF - RawSplitter
-
-
-06.. - Crypto
-
- F0 - Ciphers without hashing algo
-
- 01 - [AES]
- 0x - AES-128
- 4x - AES-192
- 8x - AES-256
- Cx - AES
-
- x0 - ECB
- x1 - CBC
- x2 - CFB
- x3 - OFB
- x4 - CTR
-
- F1 - Combine Ciphers
-
- 01 - [Zip]
- 01 - ZipCrypto (Main Zip crypto algo)
-
- 03 - [RAR]
- 02 -
- 03 - Rar29AES (AES-128 + modified SHA-1)
-
- 07 - [7z]
- 01 - 7zAES (AES-256 + SHA-256)
-
-
----
-End of document
+7-Zip method IDs for 7z and xz archives
+---------------------------------------
+
+Version: 23.01
+Date: 2023-06-30
+
+Each compression or crypto method in 7z is associated with unique binary value (ID).
+The length of ID in bytes is arbitrary but it can not exceed 63 bits (8 bytes).
+
+xz and 7z formats use same ID map.
+
+If you want to add some new ID, you have two ways:
+ 1) Write request for allocating IDs to 7-Zip developers.
+ 2) Generate 8-bytes ID:
+
+ 3F ZZ ZZ ZZ ZZ ZZ MM MM
+
+ 3F - Prefix for random IDs (1 byte)
+ ZZ ZZ ZZ ZZ ZZ - Developer ID (5 bytes). Use real random bytes.
+
+ MM MM - Method ID (2 bytes)
+
+ You can notify 7-Zip developers about your Developer ID / Method ID.
+
+ Note: Use new ID, if old codec can not decode data encoded with new version.
+
+
+List of defined IDs
+-------------------
+
+00 - Copy
+
+03 - Delta
+04 - BCJ (x86)
+05 - PPC (big-endian)
+06 - IA64
+07 - ARM (little-endian)
+08 - ARMT (little-endian)
+09 - SPARC
+0A - ARM64
+
+21 - LZMA2
+
+02.. - Common
+ 03 [Swap]
+ - 2 Swap2
+ - 4 Swap4
+
+03.. - 7z
+ 01 -
+ 01 - LZMA
+
+ 03 - [Branch Codecs]
+ 01 - [x86 Codecs]
+ 03 - BCJ
+ 1B - BCJ2 (4 packed streams)
+ 02 -
+ 05 - PPC (big-endian)
+ 03 -
+ 01 - Alpha
+ 04 -
+ 01 - IA64
+ 05 -
+ 01 - ARM (little-endian)
+ 06 -
+ 05 - M68 (big-endian)
+ 07 -
+ 01 - ARMT (little-endian)
+ 08 -
+ 05 - SPARC
+
+ 04 -
+ 01 - PPMD
+
+ 7F -
+ 01 - experimental method.
+
+
+04.. - Misc codecs
+
+ 00 - Reserved
+
+ 01 - [Zip]
+ 00 - Copy (not used. Use {00} instead)
+ 01 - Shrink
+ 06 - Implode
+ 08 - Deflate
+ 09 - Deflate64
+ 0A - Imploding
+ 0C - BZip2 (not used. Use {040202} instead)
+ 0E - LZMA (LZMA-zip)
+
+ 5D - ZSTD
+ 5F - xz
+ 60 - Jpeg
+ 61 - WavPack
+ 62 - PPMd (PPMd-zip)
+ 63 - wzAES
+
+ 02 -
+ 02 - BZip2
+
+ 03 - [Rar]
+ 01 - Rar1
+ 02 - Rar2
+ 03 - Rar3
+ 05 - Rar5
+
+ 04 - [Arj]
+ 01 - Arj(1,2,3)
+ 02 - Arj4
+
+ 05 - [Z]
+
+ 06 - [Lzh]
+
+ 07 - Reserved for 7z
+
+ 08 - [Cab]
+
+ 09 - [NSIS]
+ 01 - DeflateNSIS
+ 02 - BZip2NSIS
+
+ F7 - External codecs (that are not included to 7-Zip)
+
+ 0x xx - reserved
+
+ 10 xx - reserved (LZHAM)
+ 01 - LZHAM
+
+ 11 xx - reserved (Tino Reichardt)
+ 01 - ZSTD
+ 02 - BROTLI
+ 04 - LZ4
+ 05 - LZ5
+ 06 - LIZARD
+
+ 12 xx - reserverd (Denis Anisimov)
+
+ 01 - WavPack2
+ FE - eSplitter
+ FF - RawSplitter
+
+
+06.. - Crypto
+
+ F0 - Ciphers without hashing algo
+
+ 01 - [AES]
+ 0x - AES-128
+ 4x - AES-192
+ 8x - AES-256
+ Cx - AES
+
+ x0 - ECB
+ x1 - CBC
+ x2 - CFB
+ x3 - OFB
+ x4 - CTR
+
+ F1 - Combine Ciphers
+
+ 01 - [Zip]
+ 01 - ZipCrypto (Main Zip crypto algo)
+
+ 03 - [RAR]
+ 02 -
+ 03 - Rar29AES (AES-128 + modified SHA-1)
+
+ 07 - [7z]
+ 01 - 7zAES (AES-256 + SHA-256)
+
+
+---
+End of document
diff --git a/DOC/copying.txt b/DOC/copying.txt
new file mode 100644
index 0000000..4362b49
--- /dev/null
+++ b/DOC/copying.txt
@@ -0,0 +1,502 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/DOC/installer.txt b/DOC/installer.txt
deleted file mode 100644
index 70ad7dc..0000000
--- a/DOC/installer.txt
+++ /dev/null
@@ -1,166 +0,0 @@
-7-Zip for installers 9.38
--------------------------
-
-7-Zip is a file archiver for Windows NT/2000/2003/2008/XP/Vista/7/8/10.
-
-7-Zip for installers is part of LZMA SDK.
-LZMA SDK is written and placed in the public domain by Igor Pavlov.
-
-It's allowed to join 7-Zip SFX module with another software.
-It's allowed to change resources of 7-Zip's SFX modules.
-
-
-HOW to use
------------
-
-7zr.exe is reduced version of 7za.exe of 7-Zip.
-7zr.exe supports only format with these codecs: LZMA, LZMA2, BCJ, BCJ2, ARM, Copy.
-
-Example of compressing command for installation packages:
-
-7zr a archive.7z files
-
-7zSD.sfx is SFX module for installers. 7zSD.sfx uses msvcrt.dll.
-
-SFX modules for installers allow to create installation program.
-Such module extracts archive to temp folder and then runs specified program and removes
-temp files after program finishing. Self-extract archive for installers must be created
-as joining 3 files: SFX_Module, Installer_Config, 7z_Archive.
-Installer_Config is optional file. You can use the following command to create installer
-self-extract archive:
-
-copy /b 7zSD.sfx + config.txt + archive.7z archive.exe
-
-The smallest installation package size can be achieved, if installation files was
-uncompressed before including to 7z archive.
-
--y switch for installer module (at runtime) specifies quiet mode for extracting.
-
-Installer Config file format
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Config file contains commands for Installer. File begins from string
-;!@Install@!UTF-8! and ends with ;!@InstallEnd@!. File must be written
-in UTF-8 encoding. File contains string pairs:
-
-ID_String="Value"
-
-ID_String Description
-
-Title Title for messages
-BeginPrompt Begin Prompt message
-Progress Value can be "yes" or "no". Default value is "yes".
-RunProgram Command for executing. Default value is "setup.exe".
- Substring %%T will be replaced with path to temporary
- folder, where files were extracted
-Directory Directory prefix for "RunProgram". Default value is ".\\"
-ExecuteFile Name of file for executing
-ExecuteParameters Parameters for "ExecuteFile"
-
-
-You can omit any string pair.
-
-There are two ways to run program: RunProgram and ExecuteFile.
-Use RunProgram, if you want to run some program from .7z archive.
-Use ExecuteFile, if you want to open some document from .7z archive or
-if you want to execute some command from Windows.
-
-If you use RunProgram and if you specify empty directory prefix: Directory="",
-the system searches for the executable file in the following sequence:
-
-1. The directory from which the application (installer) loaded.
-2. The temporary folder, where files were extracted.
-3. The Windows system directory.
-
-
-Config file Examples
-~~~~~~~~~~~~~~~~~~~~
-
-;!@Install@!UTF-8!
-Title="7-Zip 4.00"
-BeginPrompt="Do you want to install the 7-Zip 4.00?"
-RunProgram="setup.exe"
-;!@InstallEnd@!
-
-
-
-;!@Install@!UTF-8!
-Title="7-Zip 4.00"
-BeginPrompt="Do you want to install the 7-Zip 4.00?"
-ExecuteFile="7zip.msi"
-;!@InstallEnd@!
-
-
-
-;!@Install@!UTF-8!
-Title="7-Zip 4.01 Update"
-BeginPrompt="Do you want to install the 7-Zip 4.01 Update?"
-ExecuteFile="msiexec.exe"
-ExecuteParameters="/i 7zip.msi REINSTALL=ALL REINSTALLMODE=vomus"
-;!@InstallEnd@!
-
-
-
-Small SFX modules for installers
---------------------------------
-
-7zS2.sfx - small SFX module (GUI version)
-7zS2con.sfx - small SFX module (Console version)
-
-Small SFX modules support this codecs: LZMA, LZMA2, BCJ, BCJ2, ARM, COPY
-
-Small SFX module is similar to common SFX module for installers.
-The difference (what's new in small version):
- - Smaller size (30 KB vs 100 KB)
- - C source code instead of Ñ++
- - No installer Configuration file
- - No extracting progress window
- - It decompresses solid 7z blocks (it can be whole 7z archive) to RAM.
- So user that calls SFX installer must have free RAM of size of largest
- solid 7z block (size of 7z archive at simplest case).
-
-How to use
-----------
-
-copy /b 7zS2.sfx + archive.7z sfx.exe
-
-When you run installer sfx module (sfx.exe)
-1) It creates "7zNNNNNNNN" temp folder in system temp folder.
-2) It extracts .7z archive to that folder
-3) It executes one file from "7zNNNNNNNN" temp folder.
-4) It removes "7zNNNNNNNN" temp folder
-
-You can send parameters to installer, and installer will transfer them to extracted .exe file.
-
-Small SFX uses 3 levels of priorities to select file to execute:
-
- 1) Files in root folder have higher priority than files in subfolders.
- 2) File extension priorities (from high to low priority order):
- bat, cmd, exe, inf, msi, cab (under Windows CE), html, htm
- 3) File name priorities (from high to low priority order):
- setup, install, run, start
-
-Windows CE (ARM) version of 7zS2.sfx is included to 7-Zip for Windows Mobile package.
-
-
-Examples
---------
-
-1) To create compressed console 7-Zip:
-
-7zr a c.7z 7z.exe 7z.dll -mx
-copy /b 7zS2con.sfx + c.7z 7zCompr.exe
-7zCompr.exe b -md22
-
-
-2) To create compressed GUI 7-Zip:
-
-7zr a g.7z 7zg.exe 7z.dll -mx
-copy /b 7zS2.sfx + g.7z 7zgCompr.exe
-7zgCompr.exe b -md22
-
-
-3) To open some file:
-
-7zr a h.7z readme.txt -mx
-copy /b 7zS2.sfx + h.7z 7zTxt.exe
-7zTxt.exe
diff --git a/DOC/lzma-history.txt b/DOC/lzma-history.txt
deleted file mode 100644
index 3a6f0f3..0000000
--- a/DOC/lzma-history.txt
+++ /dev/null
@@ -1,446 +0,0 @@
-HISTORY of the LZMA SDK
------------------------
-
-19.00 2019-02-21
--------------------------
-- Encryption strength for 7z archives was increased:
- the size of random initialization vector was increased from 64-bit to 128-bit,
- and the pseudo-random number generator was improved.
-- The bug in 7zIn.c code was fixed.
-
-
-18.06 2018-12-30
--------------------------
-- The speed for LZMA/LZMA2 compressing was increased by 3-10%,
- and there are minor changes in compression ratio.
-- Some bugs were fixed.
-- The bug in 7-Zip 18.02-18.05 was fixed:
- There was memory leak in multithreading xz decoder - XzDecMt_Decode(),
- if xz stream contains only one block.
-- The changes for MSVS compiler makefiles:
- - the makefiles now use "PLATFORM" macroname with values (x64, x86, arm64)
- instead of "CPU" macroname with values (AMD64, ARM64).
- - the makefiles by default now use static version of the run-time library.
-
-
-18.05 2018-04-30
--------------------------
-- The speed for LZMA/LZMA2 compressing was increased
- by 8% for fastest/fast compression levels and
- by 3% for normal/maximum compression levels.
-- Previous versions of 7-Zip could work incorrectly in "Large memory pages" mode in
- Windows 10 because of some BUG with "Large Pages" in Windows 10.
- Now 7-Zip doesn't use "Large Pages" on Windows 10 up to revision 1709 (16299).
-- The BUG was fixed in Lzma2Enc.c
- Lzma2Enc_Encode2() function worked incorretly,
- if (inStream == NULL) and the number of block threads is more than 1.
-
-
-18.03 beta 2018-03-04
--------------------------
-- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
- for x64 with about 30% higher speed than main version of LZMA decoder written in C.
-- The speed for single-thread LZMA/LZMA2 decoder written in C was increased by 3%.
-- 7-Zip now can use multi-threading for 7z/LZMA2 decoding,
- if there are multiple independent data chunks in LZMA2 stream.
-- 7-Zip now can use multi-threading for xz decoding,
- if there are multiple blocks in xz stream.
-
-
-18.01 2019-01-28
--------------------------
-- The BUG in 17.01 - 18.00 beta was fixed:
- XzDec.c : random block unpacking and XzUnpacker_IsBlockFinished()
- didn't work correctly for xz archives without checksum (CRC).
-
-
-18.00 beta 2019-01-10
--------------------------
-- The BUG in xz encoder was fixed:
- There was memory leak of 16 KB for each file compressed with
- xz compression method, if additional filter was used.
-
-
-17.01 beta 2017-08-28
--------------------------
-- Minor speed optimization for LZMA2 (xz and 7z) multi-threading compression.
- 7-Zip now uses additional memory buffers for multi-block LZMA2 compression.
- CPU utilization was slightly improved.
-- 7-zip now creates multi-block xz archives by default. Block size can be
- specified with -ms[Size]{m|g} switch.
-- xz decoder now can unpack random block from multi-block xz archives.
-- 7-Zip command line: @listfile now doesn't work after -- switch.
- Use -i@listfile before -- switch instead.
-- The BUGs were fixed:
- 7-Zip 17.00 beta crashed for commands that write anti-item to 7z archive.
-
-
-17.00 beta 2017-04-29
--------------------------
-- NewHandler.h / NewHandler.cpp:
- now it redefines operator new() only for old MSVC compilers (_MSC_VER < 1900).
-- C/7zTypes.h : the names of variables in interface structures were changed (vt).
-- Some bugs were fixed. 7-Zip could crash in some cases.
-- Some internal changes in code.
-
-
-16.04 2016-10-04
--------------------------
-- The bug was fixed in DllSecur.c.
-
-
-16.03 2016-09-28
--------------------------
-- SFX modules now use some protection against DLL preloading attack.
-- Some bugs in 7z code were fixed.
-
-
-16.02 2016-05-21
--------------------------
-- The BUG in 16.00 - 16.01 was fixed:
- Split Handler (SplitHandler.cpp) returned incorrect
- total size value (kpidSize) for split archives.
-
-
-16.01 2016-05-19
--------------------------
-- Some internal changes to reduce the number of compiler warnings.
-
-
-16.00 2016-05-10
--------------------------
-- Some bugs were fixed.
-
-
-15.12 2015-11-19
--------------------------
-- The BUG in C version of 7z decoder was fixed:
- 7zDec.c : SzDecodeLzma2()
- 7z decoder could mistakenly report about decoding error for some 7z archives
- that use LZMA2 compression method.
- The probability to get that mistaken decoding error report was about
- one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
-- The BUG (in 9.26-15.11) in C version of 7z decoder was fixed:
- 7zArcIn.c : SzReadHeader2()
- 7z decoder worked incorrectly for 7z archives that contain
- empty solid blocks, that can be placed to 7z archive, if some file is
- unavailable for reading during archive creation.
-
-
-15.09 beta 2015-10-16
--------------------------
-- The BUG in LZMA / LZMA2 encoding code was fixed.
- The BUG in LzFind.c::MatchFinder_ReadBlock() function.
- If input data size is larger than (4 GiB - dictionary_size),
- the following code worked incorrectly:
- - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
- for compressing from memory to memory.
- That BUG is not related to LZMA encoder version that works via streams.
- - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
- default value of chunk size (CLzma2EncProps::blockSize) is changed
- to value larger than (4 GiB - dictionary_size).
-
-
-9.38 beta 2015-01-03
--------------------------
-- The BUG in 9.31-9.37 was fixed:
- IArchiveGetRawProps interface was disabled for 7z archives.
-- The BUG in 9.26-9.36 was fixed:
- Some code in CPP\7zip\Archive\7z\ worked correctly only under Windows.
-
-
-9.36 beta 2014-12-26
--------------------------
-- The BUG in command line version was fixed:
- 7-Zip created temporary archive in current folder during update archive
- operation, if -w{Path} switch was not specified.
- The fixed 7-Zip creates temporary archive in folder that contains updated archive.
-- The BUG in 9.33-9.35 was fixed:
- 7-Zip silently ignored file reading errors during 7z or gz archive creation,
- and the created archive contained only part of file that was read before error.
- The fixed 7-Zip stops archive creation and it reports about error.
-
-
-9.35 beta 2014-12-07
--------------------------
-- 7zr.exe now support AES encryption.
-- SFX mudules were added to LZMA SDK
-- Some bugs were fixed.
-
-
-9.21 beta 2011-04-11
--------------------------
-- New class FString for file names at file systems.
-- Speed optimization in CRC code for big-endian CPUs.
-- The BUG in Lzma2Dec.c was fixed:
- Lzma2Decode function didn't work.
-
-
-9.18 beta 2010-11-02
--------------------------
-- New small SFX module for installers (SfxSetup).
-
-
-9.12 beta 2010-03-24
--------------------------
-- The BUG in LZMA SDK 9.* was fixed: LZMA2 codec didn't work,
- if more than 10 threads were used (or more than 20 threads in some modes).
-
-
-9.11 beta 2010-03-15
--------------------------
-- PPMd compression method support
-
-
-9.09 2009-12-12
--------------------------
-- The bug was fixed:
- Utf16_To_Utf8 funstions in UTFConvert.cpp and 7zMain.c
- incorrectly converted surrogate characters (the code >= 0x10000) to UTF-8.
-- Some bugs were fixed
-
-
-9.06 2009-08-17
--------------------------
-- Some changes in ANSI-C 7z Decoder interfaces.
-
-
-9.04 2009-05-30
--------------------------
-- LZMA2 compression method support
-- xz format support
-
-
-4.65 2009-02-03
--------------------------
-- Some minor fixes
-
-
-4.63 2008-12-31
--------------------------
-- Some minor fixes
-
-
-4.61 beta 2008-11-23
--------------------------
-- The bug in ANSI-C LZMA Decoder was fixed:
- If encoded stream was corrupted, decoder could access memory
- outside of allocated range.
-- Some changes in ANSI-C 7z Decoder interfaces.
-- LZMA SDK is placed in the public domain.
-
-
-4.60 beta 2008-08-19
--------------------------
-- Some minor fixes.
-
-
-4.59 beta 2008-08-13
--------------------------
-- The bug was fixed:
- LZMA Encoder in fast compression mode could access memory outside of
- allocated range in some rare cases.
-
-
-4.58 beta 2008-05-05
--------------------------
-- ANSI-C LZMA Decoder was rewritten for speed optimizations.
-- ANSI-C LZMA Encoder was included to LZMA SDK.
-- C++ LZMA code now is just wrapper over ANSI-C code.
-
-
-4.57 2007-12-12
--------------------------
-- Speed optimizations in Ñ++ LZMA Decoder.
-- Small changes for more compatibility with some C/C++ compilers.
-
-
-4.49 beta 2007-07-05
--------------------------
-- .7z ANSI-C Decoder:
- - now it supports BCJ and BCJ2 filters
- - now it supports files larger than 4 GB.
- - now it supports "Last Write Time" field for files.
-- C++ code for .7z archives compressing/decompressing from 7-zip
- was included to LZMA SDK.
-
-
-4.43 2006-06-04
--------------------------
-- Small changes for more compatibility with some C/C++ compilers.
-
-
-4.42 2006-05-15
--------------------------
-- Small changes in .h files in ANSI-C version.
-
-
-4.39 beta 2006-04-14
--------------------------
-- The bug in versions 4.33b:4.38b was fixed:
- C++ version of LZMA encoder could not correctly compress
- files larger than 2 GB with HC4 match finder (-mfhc4).
-
-
-4.37 beta 2005-04-06
--------------------------
-- Fixes in C++ code: code could no be compiled if _NO_EXCEPTIONS was defined.
-
-
-4.35 beta 2005-03-02
--------------------------
-- The bug was fixed in C++ version of LZMA Decoder:
- If encoded stream was corrupted, decoder could access memory
- outside of allocated range.
-
-
-4.34 beta 2006-02-27
--------------------------
-- Compressing speed and memory requirements for compressing were increased
-- LZMA now can use only these match finders: HC4, BT2, BT3, BT4
-
-
-4.32 2005-12-09
--------------------------
-- Java version of LZMA SDK was included
-
-
-4.30 2005-11-20
--------------------------
-- Compression ratio was improved in -a2 mode
-- Speed optimizations for compressing in -a2 mode
-- -fb switch now supports values up to 273
-- The bug in 7z_C (7zIn.c) was fixed:
- It used Alloc/Free functions from different memory pools.
- So if program used two memory pools, it worked incorrectly.
-- 7z_C: .7z format supporting was improved
-- LZMA# SDK (C#.NET version) was included
-
-
-4.27 (Updated) 2005-09-21
--------------------------
-- Some GUIDs/interfaces in C++ were changed.
- IStream.h:
- ISequentialInStream::Read now works as old ReadPart
- ISequentialOutStream::Write now works as old WritePart
-
-
-4.27 2005-08-07
--------------------------
-- The bug in LzmaDecodeSize.c was fixed:
- if _LZMA_IN_CB and _LZMA_OUT_READ were defined,
- decompressing worked incorrectly.
-
-
-4.26 2005-08-05
--------------------------
-- Fixes in 7z_C code and LzmaTest.c:
- previous versions could work incorrectly,
- if malloc(0) returns 0
-
-
-4.23 2005-06-29
--------------------------
-- Small fixes in C++ code
-
-
-4.22 2005-06-10
--------------------------
-- Small fixes
-
-
-4.21 2005-06-08
--------------------------
-- Interfaces for ANSI-C LZMA Decoder (LzmaDecode.c) were changed
-- New additional version of ANSI-C LZMA Decoder with zlib-like interface:
- - LzmaStateDecode.h
- - LzmaStateDecode.c
- - LzmaStateTest.c
-- ANSI-C LZMA Decoder now can decompress files larger than 4 GB
-
-
-4.17 2005-04-18
--------------------------
-- New example for RAM->RAM compressing/decompressing:
- LZMA + BCJ (filter for x86 code):
- - LzmaRam.h
- - LzmaRam.cpp
- - LzmaRamDecode.h
- - LzmaRamDecode.c
- - -f86 switch for lzma.exe
-
-
-4.16 2005-03-29
--------------------------
-- The bug was fixed in LzmaDecode.c (ANSI-C LZMA Decoder):
- If _LZMA_OUT_READ was defined, and if encoded stream was corrupted,
- decoder could access memory outside of allocated range.
-- Speed optimization of ANSI-C LZMA Decoder (now it's about 20% faster).
- Old version of LZMA Decoder now is in file LzmaDecodeSize.c.
- LzmaDecodeSize.c can provide slightly smaller code than LzmaDecode.c
-- Small speed optimization in LZMA C++ code
-- filter for SPARC's code was added
-- Simplified version of .7z ANSI-C Decoder was included
-
-
-4.06 2004-09-05
--------------------------
-- The bug in v4.05 was fixed:
- LZMA-Encoder didn't release output stream in some cases.
-
-
-4.05 2004-08-25
--------------------------
-- Source code of filters for x86, IA-64, ARM, ARM-Thumb
- and PowerPC code was included to SDK
-- Some internal minor changes
-
-
-4.04 2004-07-28
--------------------------
-- More compatibility with some C++ compilers
-
-
-4.03 2004-06-18
--------------------------
-- "Benchmark" command was added. It measures compressing
- and decompressing speed and shows rating values.
- Also it checks hardware errors.
-
-
-4.02 2004-06-10
--------------------------
-- C++ LZMA Encoder/Decoder code now is more portable
- and it can be compiled by GCC on Linux.
-
-
-4.01 2004-02-15
--------------------------
-- Some detection of data corruption was enabled.
- LzmaDecode.c / RangeDecoderReadByte
- .....
- {
- rd->ExtraBytes = 1;
- return 0xFF;
- }
-
-
-4.00 2004-02-13
--------------------------
-- Original version of LZMA SDK
-
-
-
-HISTORY of the LZMA
--------------------
- 2001-2008: Improvements to LZMA compressing/decompressing code,
- keeping compatibility with original LZMA format
- 1996-2001: Development of LZMA compression format
-
- Some milestones:
-
- 2001-08-30: LZMA compression was added to 7-Zip
- 1999-01-02: First version of 7-Zip was released
-
-
-End of document
diff --git a/DOC/lzma-sdk.txt b/DOC/lzma-sdk.txt
deleted file mode 100644
index 1bde6db..0000000
--- a/DOC/lzma-sdk.txt
+++ /dev/null
@@ -1,357 +0,0 @@
-LZMA SDK 19.00
---------------
-
-LZMA SDK provides the documentation, samples, header files,
-libraries, and tools you need to develop applications that
-use 7z / LZMA / LZMA2 / XZ compression.
-
-LZMA is an improved version of famous LZ77 compression algorithm.
-It was improved in way of maximum increasing of compression ratio,
-keeping high decompression speed and low memory requirements for
-decompressing.
-
-LZMA2 is a LZMA based compression method. LZMA2 provides better
-multithreading support for compression than LZMA and some other improvements.
-
-7z is a file format for data compression and file archiving.
-7z is a main file format for 7-Zip compression program (www.7-zip.org).
-7z format supports different compression methods: LZMA, LZMA2 and others.
-7z also supports AES-256 based encryption.
-
-XZ is a file format for data compression that uses LZMA2 compression.
-XZ format provides additional features: SHA/CRC check, filters for
-improved compression ratio, splitting to blocks and streams,
-
-
-
-LICENSE
--------
-
-LZMA SDK is written and placed in the public domain by Igor Pavlov.
-
-Some code in LZMA SDK is based on public domain code from another developers:
- 1) PPMd var.H (2001): Dmitry Shkarin
- 2) SHA-256: Wei Dai (Crypto++ library)
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute the
-original LZMA SDK code, either in source code form or as a compiled binary, for
-any purpose, commercial or non-commercial, and by any means.
-
-LZMA SDK code is compatible with open source licenses, for example, you can
-include it to GNU GPL or GNU LGPL code.
-
-
-LZMA SDK Contents
------------------
-
- Source code:
-
- - C / C++ / C# / Java - LZMA compression and decompression
- - C / C++ - LZMA2 compression and decompression
- - C / C++ - XZ compression and decompression
- - C - 7z decompression
- - C++ - 7z compression and decompression
- - C - small SFXs for installers (7z decompression)
- - C++ - SFXs and SFXs for installers (7z decompression)
-
- Precomiled binaries:
-
- - console programs for lzma / 7z / xz compression and decompression
- - SFX modules for installers.
-
-
-UNIX/Linux version
-------------------
-To compile C++ version of file->file LZMA encoding, go to directory
-CPP/7zip/Bundles/LzmaCon
-and call make to recompile it:
- make -f makefile.gcc clean all
-
-In some UNIX/Linux versions you must compile LZMA with static libraries.
-To compile with static libraries, you can use
-LIB = -lm -static
-
-Also you can use p7zip (port of 7-Zip for POSIX systems like Unix or Linux):
-
- http://p7zip.sourceforge.net/
-
-
-Files
------
-
-DOC/7zC.txt - 7z ANSI-C Decoder description
-DOC/7zFormat.txt - 7z Format description
-DOC/installer.txt - information about 7-Zip for installers
-DOC/lzma.txt - LZMA compression description
-DOC/lzma-sdk.txt - LZMA SDK description (this file)
-DOC/lzma-history.txt - history of LZMA SDK
-DOC/lzma-specification.txt - Specification of LZMA
-DOC/Methods.txt - Compression method IDs for .7z
-
-bin/installer/ - example script to create installer that uses SFX module,
-
-bin/7zdec.exe - simplified 7z archive decoder
-bin/7zr.exe - 7-Zip console program (reduced version)
-bin/x64/7zr.exe - 7-Zip console program (reduced version) (x64 version)
-bin/lzma.exe - file->file LZMA encoder/decoder for Windows
-bin/7zS2.sfx - small SFX module for installers (GUI version)
-bin/7zS2con.sfx - small SFX module for installers (Console version)
-bin/7zSD.sfx - SFX module for installers.
-
-
-7zDec.exe
----------
-7zDec.exe is simplified 7z archive decoder.
-It supports only LZMA, LZMA2, and PPMd methods.
-7zDec decodes whole solid block from 7z archive to RAM.
-The RAM consumption can be high.
-
-
-
-
-Source code structure
----------------------
-
-
-Asm/ - asm files (optimized code for CRC calculation and Intel-AES encryption)
-
-C/ - C files (compression / decompression and other)
- Util/
- 7z - 7z decoder program (decoding 7z files)
- Lzma - LZMA program (file->file LZMA encoder/decoder).
- LzmaLib - LZMA library (.DLL for Windows)
- SfxSetup - small SFX module for installers
-
-CPP/ -- CPP files
-
- Common - common files for C++ projects
- Windows - common files for Windows related code
-
- 7zip - files related to 7-Zip
-
- Archive - files related to archiving
-
- Common - common files for archive handling
- 7z - 7z C++ Encoder/Decoder
-
- Bundles - Modules that are bundles of other modules (files)
-
- Alone7z - 7zr.exe: Standalone 7-Zip console program (reduced version)
- Format7zExtractR - 7zxr.dll: Reduced version of 7z DLL: extracting from 7z/LZMA/BCJ/BCJ2.
- Format7zR - 7zr.dll: Reduced version of 7z DLL: extracting/compressing to 7z/LZMA/BCJ/BCJ2
- LzmaCon - lzma.exe: LZMA compression/decompression
- LzmaSpec - example code for LZMA Specification
- SFXCon - 7zCon.sfx: Console 7z SFX module
- SFXSetup - 7zS.sfx: 7z SFX module for installers
- SFXWin - 7z.sfx: GUI 7z SFX module
-
- Common - common files for 7-Zip
-
- Compress - files for compression/decompression
-
- Crypto - files for encryption / decompression
-
- UI - User Interface files
-
- Client7z - Test application for 7za.dll, 7zr.dll, 7zxr.dll
- Common - Common UI files
- Console - Code for console program (7z.exe)
- Explorer - Some code from 7-Zip Shell extension
- FileManager - Some GUI code from 7-Zip File Manager
- GUI - Some GUI code from 7-Zip
-
-
-CS/ - C# files
- 7zip
- Common - some common files for 7-Zip
- Compress - files related to compression/decompression
- LZ - files related to LZ (Lempel-Ziv) compression algorithm
- LZMA - LZMA compression/decompression
- LzmaAlone - file->file LZMA compression/decompression
- RangeCoder - Range Coder (special code of compression/decompression)
-
-Java/ - Java files
- SevenZip
- Compression - files related to compression/decompression
- LZ - files related to LZ (Lempel-Ziv) compression algorithm
- LZMA - LZMA compression/decompression
- RangeCoder - Range Coder (special code of compression/decompression)
-
-
-Note:
- Asm / C / C++ source code of LZMA SDK is part of 7-Zip's source code.
- 7-Zip's source code can be downloaded from 7-Zip's SourceForge page:
-
- http://sourceforge.net/projects/sevenzip/
-
-
-
-LZMA features
--------------
- - Variable dictionary size (up to 1 GB)
- - Estimated compressing speed: about 2 MB/s on 2 GHz CPU
- - Estimated decompressing speed:
- - 20-30 MB/s on modern 2 GHz cpu
- - 1-2 MB/s on 200 MHz simple RISC cpu: (ARM, MIPS, PowerPC)
- - Small memory requirements for decompressing (16 KB + DictionarySize)
- - Small code size for decompressing: 5-8 KB
-
-LZMA decoder uses only integer operations and can be
-implemented in any modern 32-bit CPU (or on 16-bit CPU with some conditions).
-
-Some critical operations that affect the speed of LZMA decompression:
- 1) 32*16 bit integer multiply
- 2) Mispredicted branches (penalty mostly depends from pipeline length)
- 3) 32-bit shift and arithmetic operations
-
-The speed of LZMA decompressing mostly depends from CPU speed.
-Memory speed has no big meaning. But if your CPU has small data cache,
-overall weight of memory speed will slightly increase.
-
-
-How To Use
-----------
-
-Using LZMA encoder/decoder executable
---------------------------------------
-
-Usage: LZMA <e|d> inputFile outputFile [<switches>...]
-
- e: encode file
-
- d: decode file
-
- b: Benchmark. There are two tests: compressing and decompressing
- with LZMA method. Benchmark shows rating in MIPS (million
- instructions per second). Rating value is calculated from
- measured speed and it is normalized with Intel's Core 2 results.
- Also Benchmark checks possible hardware errors (RAM
- errors in most cases). Benchmark uses these settings:
- (-a1, -d21, -fb32, -mfbt4). You can change only -d parameter.
- Also you can change the number of iterations. Example for 30 iterations:
- LZMA b 30
- Default number of iterations is 10.
-
-<Switches>
-
-
- -a{N}: set compression mode 0 = fast, 1 = normal
- default: 1 (normal)
-
- d{N}: Sets Dictionary size - [0, 30], default: 23 (8MB)
- The maximum value for dictionary size is 1 GB = 2^30 bytes.
- Dictionary size is calculated as DictionarySize = 2^N bytes.
- For decompressing file compressed by LZMA method with dictionary
- size D = 2^N you need about D bytes of memory (RAM).
-
- -fb{N}: set number of fast bytes - [5, 273], default: 128
- Usually big number gives a little bit better compression ratio
- and slower compression process.
-
- -lc{N}: set number of literal context bits - [0, 8], default: 3
- Sometimes lc=4 gives gain for big files.
-
- -lp{N}: set number of literal pos bits - [0, 4], default: 0
- lp switch is intended for periodical data when period is
- equal 2^N. For example, for 32-bit (4 bytes)
- periodical data you can use lp=2. Often it's better to set lc0,
- if you change lp switch.
-
- -pb{N}: set number of pos bits - [0, 4], default: 2
- pb switch is intended for periodical data
- when period is equal 2^N.
-
- -mf{MF_ID}: set Match Finder. Default: bt4.
- Algorithms from hc* group doesn't provide good compression
- ratio, but they often works pretty fast in combination with
- fast mode (-a0).
-
- Memory requirements depend from dictionary size
- (parameter "d" in table below).
-
- MF_ID Memory Description
-
- bt2 d * 9.5 + 4MB Binary Tree with 2 bytes hashing.
- bt3 d * 11.5 + 4MB Binary Tree with 3 bytes hashing.
- bt4 d * 11.5 + 4MB Binary Tree with 4 bytes hashing.
- hc4 d * 7.5 + 4MB Hash Chain with 4 bytes hashing.
-
- -eos: write End Of Stream marker. By default LZMA doesn't write
- eos marker, since LZMA decoder knows uncompressed size
- stored in .lzma file header.
-
- -si: Read data from stdin (it will write End Of Stream marker).
- -so: Write data to stdout
-
-
-Examples:
-
-1) LZMA e file.bin file.lzma -d16 -lc0
-
-compresses file.bin to file.lzma with 64 KB dictionary (2^16=64K)
-and 0 literal context bits. -lc0 allows to reduce memory requirements
-for decompression.
-
-
-2) LZMA e file.bin file.lzma -lc0 -lp2
-
-compresses file.bin to file.lzma with settings suitable
-for 32-bit periodical data (for example, ARM or MIPS code).
-
-3) LZMA d file.lzma file.bin
-
-decompresses file.lzma to file.bin.
-
-
-Compression ratio hints
------------------------
-
-Recommendations
----------------
-
-To increase the compression ratio for LZMA compressing it's desirable
-to have aligned data (if it's possible) and also it's desirable to locate
-data in such order, where code is grouped in one place and data is
-grouped in other place (it's better than such mixing: code, data, code,
-data, ...).
-
-
-Filters
--------
-You can increase the compression ratio for some data types, using
-special filters before compressing. For example, it's possible to
-increase the compression ratio on 5-10% for code for those CPU ISAs:
-x86, IA-64, ARM, ARM-Thumb, PowerPC, SPARC.
-
-You can find C source code of such filters in C/Bra*.* files
-
-You can check the compression ratio gain of these filters with such
-7-Zip commands (example for ARM code):
-No filter:
- 7z a a1.7z a.bin -m0=lzma
-
-With filter for little-endian ARM code:
- 7z a a2.7z a.bin -m0=arm -m1=lzma
-
-It works in such manner:
-Compressing = Filter_encoding + LZMA_encoding
-Decompressing = LZMA_decoding + Filter_decoding
-
-Compressing and decompressing speed of such filters is very high,
-so it will not increase decompressing time too much.
-Moreover, it reduces decompression time for LZMA_decoding,
-since compression ratio with filtering is higher.
-
-These filters convert CALL (calling procedure) instructions
-from relative offsets to absolute addresses, so such data becomes more
-compressible.
-
-For some ISAs (for example, for MIPS) it's impossible to get gain from such filter.
-
-
-
----
-
-http://www.7-zip.org
-http://www.7-zip.org/sdk.html
-http://www.7-zip.org/support.html
diff --git a/DOC/lzma-specification.txt b/DOC/lzma-specification.txt
deleted file mode 100644
index b6796df..0000000
--- a/DOC/lzma-specification.txt
+++ /dev/null
@@ -1,1176 +0,0 @@
-LZMA specification (DRAFT version)
-----------------------------------
-
-Author: Igor Pavlov
-Date: 2015-06-14
-
-This specification defines the format of LZMA compressed data and lzma file format.
-
-Notation
---------
-
-We use the syntax of C++ programming language.
-We use the following types in C++ code:
- unsigned - unsigned integer, at least 16 bits in size
- int - signed integer, at least 16 bits in size
- UInt64 - 64-bit unsigned integer
- UInt32 - 32-bit unsigned integer
- UInt16 - 16-bit unsigned integer
- Byte - 8-bit unsigned integer
- bool - boolean type with two possible values: false, true
-
-
-lzma file format
-================
-
-The lzma file contains the raw LZMA stream and the header with related properties.
-
-The files in that format use ".lzma" extension.
-
-The lzma file format layout:
-
-Offset Size Description
-
- 0 1 LZMA model properties (lc, lp, pb) in encoded form
- 1 4 Dictionary size (32-bit unsigned integer, little-endian)
- 5 8 Uncompressed size (64-bit unsigned integer, little-endian)
- 13 Compressed data (LZMA stream)
-
-LZMA properties:
-
- name Range Description
-
- lc [0, 8] the number of "literal context" bits
- lp [0, 4] the number of "literal pos" bits
- pb [0, 4] the number of "pos" bits
-dictSize [0, 2^32 - 1] the dictionary size
-
-The following code encodes LZMA properties:
-
-void EncodeProperties(Byte *properties)
-{
- properties[0] = (Byte)((pb * 5 + lp) * 9 + lc);
- Set_UInt32_LittleEndian(properties + 1, dictSize);
-}
-
-If the value of dictionary size in properties is smaller than (1 << 12),
-the LZMA decoder must set the dictionary size variable to (1 << 12).
-
-#define LZMA_DIC_MIN (1 << 12)
-
- unsigned lc, pb, lp;
- UInt32 dictSize;
- UInt32 dictSizeInProperties;
-
- void DecodeProperties(const Byte *properties)
- {
- unsigned d = properties[0];
- if (d >= (9 * 5 * 5))
- throw "Incorrect LZMA properties";
- lc = d % 9;
- d /= 9;
- pb = d / 5;
- lp = d % 5;
- dictSizeInProperties = 0;
- for (int i = 0; i < 4; i++)
- dictSizeInProperties |= (UInt32)properties[i + 1] << (8 * i);
- dictSize = dictSizeInProperties;
- if (dictSize < LZMA_DIC_MIN)
- dictSize = LZMA_DIC_MIN;
- }
-
-If "Uncompressed size" field contains ones in all 64 bits, it means that
-uncompressed size is unknown and there is the "end marker" in stream,
-that indicates the end of decoding point.
-In opposite case, if the value from "Uncompressed size" field is not
-equal to ((2^64) - 1), the LZMA stream decoding must be finished after
-specified number of bytes (Uncompressed size) is decoded. And if there
-is the "end marker", the LZMA decoder must read that marker also.
-
-
-The new scheme to encode LZMA properties
-----------------------------------------
-
-If LZMA compression is used for some another format, it's recommended to
-use a new improved scheme to encode LZMA properties. That new scheme was
-used in xz format that uses the LZMA2 compression algorithm.
-The LZMA2 is a new compression algorithm that is based on the LZMA algorithm.
-
-The dictionary size in LZMA2 is encoded with just one byte and LZMA2 supports
-only reduced set of dictionary sizes:
- (2 << 11), (3 << 11),
- (2 << 12), (3 << 12),
- ...
- (2 << 30), (3 << 30),
- (2 << 31) - 1
-
-The dictionary size can be extracted from encoded value with the following code:
-
- dictSize = (p == 40) ? 0xFFFFFFFF : (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11));
-
-Also there is additional limitation (lc + lp <= 4) in LZMA2 for values of
-"lc" and "lp" properties:
-
- if (lc + lp > 4)
- throw "Unsupported properties: (lc + lp) > 4";
-
-There are some advantages for LZMA decoder with such (lc + lp) value
-limitation. It reduces the maximum size of tables allocated by decoder.
-And it reduces the complexity of initialization procedure, that can be
-important to keep high speed of decoding of big number of small LZMA streams.
-
-It's recommended to use that limitation (lc + lp <= 4) for any new format
-that uses LZMA compression. Note that the combinations of "lc" and "lp"
-parameters, where (lc + lp > 4), can provide significant improvement in
-compression ratio only in some rare cases.
-
-The LZMA properties can be encoded into two bytes in new scheme:
-
-Offset Size Description
-
- 0 1 The dictionary size encoded with LZMA2 scheme
- 1 1 LZMA model properties (lc, lp, pb) in encoded form
-
-
-The RAM usage
-=============
-
-The RAM usage for LZMA decoder is determined by the following parts:
-
-1) The Sliding Window (from 4 KiB to 4 GiB).
-2) The probability model counter arrays (arrays of 16-bit variables).
-3) Some additional state variables (about 10 variables of 32-bit integers).
-
-
-The RAM usage for Sliding Window
---------------------------------
-
-There are two main scenarios of decoding:
-
-1) The decoding of full stream to one RAM buffer.
-
- If we decode full LZMA stream to one output buffer in RAM, the decoder
- can use that output buffer as sliding window. So the decoder doesn't
- need additional buffer allocated for sliding window.
-
-2) The decoding to some external storage.
-
- If we decode LZMA stream to external storage, the decoder must allocate
- the buffer for sliding window. The size of that buffer must be equal
- or larger than the value of dictionary size from properties of LZMA stream.
-
-In this specification we describe the code for decoding to some external
-storage. The optimized version of code for decoding of full stream to one
-output RAM buffer can require some minor changes in code.
-
-
-The RAM usage for the probability model counters
-------------------------------------------------
-
-The size of the probability model counter arrays is calculated with the
-following formula:
-
-size_of_prob_arrays = 1846 + 768 * (1 << (lp + lc))
-
-Each probability model counter is 11-bit unsigned integer.
-If we use 16-bit integer variables (2-byte integers) for these probability
-model counters, the RAM usage required by probability model counter arrays
-can be estimated with the following formula:
-
- RAM = 4 KiB + 1.5 KiB * (1 << (lp + lc))
-
-For example, for default LZMA parameters (lp = 0 and lc = 3), the RAM usage is
-
- RAM_lc3_lp0 = 4 KiB + 1.5 KiB * 8 = 16 KiB
-
-The maximum RAM state usage is required for decoding the stream with lp = 4
-and lc = 8:
-
- RAM_lc8_lp4 = 4 KiB + 1.5 KiB * 4096 = 6148 KiB
-
-If the decoder uses LZMA2's limited property condition
-(lc + lp <= 4), the RAM usage will be not larger than
-
- RAM_lc_lp_4 = 4 KiB + 1.5 KiB * 16 = 28 KiB
-
-
-The RAM usage for encoder
--------------------------
-
-There are many variants for LZMA encoding code.
-These variants have different values for memory consumption.
-Note that memory consumption for LZMA Encoder can not be
-smaller than memory consumption of LZMA Decoder for same stream.
-
-The RAM usage required by modern effective implementation of
-LZMA Encoder can be estimated with the following formula:
-
- Encoder_RAM_Usage = 4 MiB + 11 * dictionarySize.
-
-But there are some modes of the encoder that require less memory.
-
-
-LZMA Decoding
-=============
-
-The LZMA compression algorithm uses LZ-based compression with Sliding Window
-and Range Encoding as entropy coding method.
-
-
-Sliding Window
---------------
-
-LZMA uses Sliding Window compression similar to LZ77 algorithm.
-
-LZMA stream must be decoded to the sequence that consists
-of MATCHES and LITERALS:
-
- - a LITERAL is a 8-bit character (one byte).
- The decoder just puts that LITERAL to the uncompressed stream.
-
- - a MATCH is a pair of two numbers (DISTANCE-LENGTH pair).
- The decoder takes one byte exactly "DISTANCE" characters behind
- current position in the uncompressed stream and puts it to
- uncompressed stream. The decoder must repeat it "LENGTH" times.
-
-The "DISTANCE" can not be larger than dictionary size.
-And the "DISTANCE" can not be larger than the number of bytes in
-the uncompressed stream that were decoded before that match.
-
-In this specification we use cyclic buffer to implement Sliding Window
-for LZMA decoder:
-
-class COutWindow
-{
- Byte *Buf;
- UInt32 Pos;
- UInt32 Size;
- bool IsFull;
-
-public:
- unsigned TotalPos;
- COutStream OutStream;
-
- COutWindow(): Buf(NULL) {}
- ~COutWindow() { delete []Buf; }
-
- void Create(UInt32 dictSize)
- {
- Buf = new Byte[dictSize];
- Pos = 0;
- Size = dictSize;
- IsFull = false;
- TotalPos = 0;
- }
-
- void PutByte(Byte b)
- {
- TotalPos++;
- Buf[Pos++] = b;
- if (Pos == Size)
- {
- Pos = 0;
- IsFull = true;
- }
- OutStream.WriteByte(b);
- }
-
- Byte GetByte(UInt32 dist) const
- {
- return Buf[dist <= Pos ? Pos - dist : Size - dist + Pos];
- }
-
- void CopyMatch(UInt32 dist, unsigned len)
- {
- for (; len > 0; len--)
- PutByte(GetByte(dist));
- }
-
- bool CheckDistance(UInt32 dist) const
- {
- return dist <= Pos || IsFull;
- }
-
- bool IsEmpty() const
- {
- return Pos == 0 && !IsFull;
- }
-};
-
-
-In another implementation it's possible to use one buffer that contains
-Sliding Window and the whole data stream after uncompressing.
-
-
-Range Decoder
--------------
-
-LZMA algorithm uses Range Encoding (1) as entropy coding method.
-
-LZMA stream contains just one very big number in big-endian encoding.
-LZMA decoder uses the Range Decoder to extract a sequence of binary
-symbols from that big number.
-
-The state of the Range Decoder:
-
-struct CRangeDecoder
-{
- UInt32 Range;
- UInt32 Code;
- InputStream *InStream;
-
- bool Corrupted;
-}
-
-The notes about UInt32 type for the "Range" and "Code" variables:
-
- It's possible to use 64-bit (unsigned or signed) integer type
- for the "Range" and the "Code" variables instead of 32-bit unsigned,
- but some additional code must be used to truncate the values to
- low 32-bits after some operations.
-
- If the programming language does not support 32-bit unsigned integer type
- (like in case of JAVA language), it's possible to use 32-bit signed integer,
- but some code must be changed. For example, it's required to change the code
- that uses comparison operations for UInt32 variables in this specification.
-
-The Range Decoder can be in some states that can be treated as
-"Corruption" in LZMA stream. The Range Decoder uses the variable "Corrupted":
-
- (Corrupted == false), if the Range Decoder has not detected any corruption.
- (Corrupted == true), if the Range Decoder has detected some corruption.
-
-The reference LZMA Decoder ignores the value of the "Corrupted" variable.
-So it continues to decode the stream, even if the corruption can be detected
-in the Range Decoder. To provide the full compatibility with output of the
-reference LZMA Decoder, another LZMA Decoder implementations must also
-ignore the value of the "Corrupted" variable.
-
-The LZMA Encoder is required to create only such LZMA streams, that will not
-lead the Range Decoder to states, where the "Corrupted" variable is set to true.
-
-The Range Decoder reads first 5 bytes from input stream to initialize
-the state:
-
-bool CRangeDecoder::Init()
-{
- Corrupted = false;
- Range = 0xFFFFFFFF;
- Code = 0;
-
- Byte b = InStream->ReadByte();
-
- for (int i = 0; i < 4; i++)
- Code = (Code << 8) | InStream->ReadByte();
-
- if (b != 0 || Code == Range)
- Corrupted = true;
- return b == 0;
-}
-
-The LZMA Encoder always writes ZERO in initial byte of compressed stream.
-That scheme allows to simplify the code of the Range Encoder in the
-LZMA Encoder. If initial byte is not equal to ZERO, the LZMA Decoder must
-stop decoding and report error.
-
-After the last bit of data was decoded by Range Decoder, the value of the
-"Code" variable must be equal to 0. The LZMA Decoder must check it by
-calling the IsFinishedOK() function:
-
- bool IsFinishedOK() const { return Code == 0; }
-
-If there is corruption in data stream, there is big probability that
-the "Code" value will be not equal to 0 in the Finish() function. So that
-check in the IsFinishedOK() function provides very good feature for
-corruption detection.
-
-The value of the "Range" variable before each bit decoding can not be smaller
-than ((UInt32)1 << 24). The Normalize() function keeps the "Range" value in
-described range.
-
-#define kTopValue ((UInt32)1 << 24)
-
-void CRangeDecoder::Normalize()
-{
- if (Range < kTopValue)
- {
- Range <<= 8;
- Code = (Code << 8) | InStream->ReadByte();
- }
-}
-
-Notes: if the size of the "Code" variable is larger than 32 bits, it's
-required to keep only low 32 bits of the "Code" variable after the change
-in Normalize() function.
-
-If the LZMA Stream is not corrupted, the value of the "Code" variable is
-always smaller than value of the "Range" variable.
-But the Range Decoder ignores some types of corruptions, so the value of
-the "Code" variable can be equal or larger than value of the "Range" variable
-for some "Corrupted" archives.
-
-
-LZMA uses Range Encoding only with binary symbols of two types:
- 1) binary symbols with fixed and equal probabilities (direct bits)
- 2) binary symbols with predicted probabilities
-
-The DecodeDirectBits() function decodes the sequence of direct bits:
-
-UInt32 CRangeDecoder::DecodeDirectBits(unsigned numBits)
-{
- UInt32 res = 0;
- do
- {
- Range >>= 1;
- Code -= Range;
- UInt32 t = 0 - ((UInt32)Code >> 31);
- Code += Range & t;
-
- if (Code == Range)
- Corrupted = true;
-
- Normalize();
- res <<= 1;
- res += t + 1;
- }
- while (--numBits);
- return res;
-}
-
-
-The Bit Decoding with Probability Model
----------------------------------------
-
-The task of Bit Probability Model is to estimate probabilities of binary
-symbols. And then it provides the Range Decoder with that information.
-The better prediction provides better compression ratio.
-The Bit Probability Model uses statistical data of previous decoded
-symbols.
-
-That estimated probability is presented as 11-bit unsigned integer value
-that represents the probability of symbol "0".
-
-#define kNumBitModelTotalBits 11
-
-Mathematical probabilities can be presented with the following formulas:
- probability(symbol_0) = prob / 2048.
- probability(symbol_1) = 1 - Probability(symbol_0) =
- = 1 - prob / 2048 =
- = (2048 - prob) / 2048
-where the "prob" variable contains 11-bit integer probability counter.
-
-It's recommended to use 16-bit unsigned integer type, to store these 11-bit
-probability values:
-
-typedef UInt16 CProb;
-
-Each probability value must be initialized with value ((1 << 11) / 2),
-that represents the state, where probabilities of symbols 0 and 1
-are equal to 0.5:
-
-#define PROB_INIT_VAL ((1 << kNumBitModelTotalBits) / 2)
-
-The INIT_PROBS macro is used to initialize the array of CProb variables:
-
-#define INIT_PROBS(p) \
- { for (unsigned i = 0; i < sizeof(p) / sizeof(p[0]); i++) p[i] = PROB_INIT_VAL; }
-
-
-The DecodeBit() function decodes one bit.
-The LZMA decoder provides the pointer to CProb variable that contains
-information about estimated probability for symbol 0 and the Range Decoder
-updates that CProb variable after decoding. The Range Decoder increases
-estimated probability of the symbol that was decoded:
-
-#define kNumMoveBits 5
-
-unsigned CRangeDecoder::DecodeBit(CProb *prob)
-{
- unsigned v = *prob;
- UInt32 bound = (Range >> kNumBitModelTotalBits) * v;
- unsigned symbol;
- if (Code < bound)
- {
- v += ((1 << kNumBitModelTotalBits) - v) >> kNumMoveBits;
- Range = bound;
- symbol = 0;
- }
- else
- {
- v -= v >> kNumMoveBits;
- Code -= bound;
- Range -= bound;
- symbol = 1;
- }
- *prob = (CProb)v;
- Normalize();
- return symbol;
-}
-
-
-The Binary Tree of bit model counters
--------------------------------------
-
-LZMA uses a tree of Bit model variables to decode symbol that needs
-several bits for storing. There are two versions of such trees in LZMA:
- 1) the tree that decodes bits from high bit to low bit (the normal scheme).
- 2) the tree that decodes bits from low bit to high bit (the reverse scheme).
-
-Each binary tree structure supports different size of decoded symbol
-(the size of binary sequence that contains value of symbol).
-If that size of decoded symbol is "NumBits" bits, the tree structure
-uses the array of (2 << NumBits) counters of CProb type.
-But only ((2 << NumBits) - 1) items are used by encoder and decoder.
-The first item (the item with index equal to 0) in array is unused.
-That scheme with unused array's item allows to simplify the code.
-
-unsigned BitTreeReverseDecode(CProb *probs, unsigned numBits, CRangeDecoder *rc)
-{
- unsigned m = 1;
- unsigned symbol = 0;
- for (unsigned i = 0; i < numBits; i++)
- {
- unsigned bit = rc->DecodeBit(&probs[m]);
- m <<= 1;
- m += bit;
- symbol |= (bit << i);
- }
- return symbol;
-}
-
-template <unsigned NumBits>
-class CBitTreeDecoder
-{
- CProb Probs[(unsigned)1 << NumBits];
-
-public:
-
- void Init()
- {
- INIT_PROBS(Probs);
- }
-
- unsigned Decode(CRangeDecoder *rc)
- {
- unsigned m = 1;
- for (unsigned i = 0; i < NumBits; i++)
- m = (m << 1) + rc->DecodeBit(&Probs[m]);
- return m - ((unsigned)1 << NumBits);
- }
-
- unsigned ReverseDecode(CRangeDecoder *rc)
- {
- return BitTreeReverseDecode(Probs, NumBits, rc);
- }
-};
-
-
-LZ part of LZMA
----------------
-
-LZ part of LZMA describes details about the decoding of MATCHES and LITERALS.
-
-
-The Literal Decoding
---------------------
-
-The LZMA Decoder uses (1 << (lc + lp)) tables with CProb values, where
-each table contains 0x300 CProb values:
-
- CProb *LitProbs;
-
- void CreateLiterals()
- {
- LitProbs = new CProb[(UInt32)0x300 << (lc + lp)];
- }
-
- void InitLiterals()
- {
- UInt32 num = (UInt32)0x300 << (lc + lp);
- for (UInt32 i = 0; i < num; i++)
- LitProbs[i] = PROB_INIT_VAL;
- }
-
-To select the table for decoding it uses the context that consists of
-(lc) high bits from previous literal and (lp) low bits from value that
-represents current position in outputStream.
-
-If (State > 7), the Literal Decoder also uses "matchByte" that represents
-the byte in OutputStream at position the is the DISTANCE bytes before
-current position, where the DISTANCE is the distance in DISTANCE-LENGTH pair
-of latest decoded match.
-
-The following code decodes one literal and puts it to Sliding Window buffer:
-
- void DecodeLiteral(unsigned state, UInt32 rep0)
- {
- unsigned prevByte = 0;
- if (!OutWindow.IsEmpty())
- prevByte = OutWindow.GetByte(1);
-
- unsigned symbol = 1;
- unsigned litState = ((OutWindow.TotalPos & ((1 << lp) - 1)) << lc) + (prevByte >> (8 - lc));
- CProb *probs = &LitProbs[(UInt32)0x300 * litState];
-
- if (state >= 7)
- {
- unsigned matchByte = OutWindow.GetByte(rep0 + 1);
- do
- {
- unsigned matchBit = (matchByte >> 7) & 1;
- matchByte <<= 1;
- unsigned bit = RangeDec.DecodeBit(&probs[((1 + matchBit) << 8) + symbol]);
- symbol = (symbol << 1) | bit;
- if (matchBit != bit)
- break;
- }
- while (symbol < 0x100);
- }
- while (symbol < 0x100)
- symbol = (symbol << 1) | RangeDec.DecodeBit(&probs[symbol]);
- OutWindow.PutByte((Byte)(symbol - 0x100));
- }
-
-
-The match length decoding
--------------------------
-
-The match length decoder returns normalized (zero-based value)
-length of match. That value can be converted to real length of the match
-with the following code:
-
-#define kMatchMinLen 2
-
- matchLen = len + kMatchMinLen;
-
-The match length decoder can return the values from 0 to 271.
-And the corresponded real match length values can be in the range
-from 2 to 273.
-
-The following scheme is used for the match length encoding:
-
- Binary encoding Binary Tree structure Zero-based match length
- sequence (binary + decimal):
-
- 0 xxx LowCoder[posState] xxx
- 1 0 yyy MidCoder[posState] yyy + 8
- 1 1 zzzzzzzz HighCoder zzzzzzzz + 16
-
-LZMA uses bit model variable "Choice" to decode the first selection bit.
-
-If the first selection bit is equal to 0, the decoder uses binary tree
- LowCoder[posState] to decode 3-bit zero-based match length (xxx).
-
-If the first selection bit is equal to 1, the decoder uses bit model
- variable "Choice2" to decode the second selection bit.
-
- If the second selection bit is equal to 0, the decoder uses binary tree
- MidCoder[posState] to decode 3-bit "yyy" value, and zero-based match
- length is equal to (yyy + 8).
-
- If the second selection bit is equal to 1, the decoder uses binary tree
- HighCoder to decode 8-bit "zzzzzzzz" value, and zero-based
- match length is equal to (zzzzzzzz + 16).
-
-LZMA uses "posState" value as context to select the binary tree
-from LowCoder and MidCoder binary tree arrays:
-
- unsigned posState = OutWindow.TotalPos & ((1 << pb) - 1);
-
-The full code of the length decoder:
-
-class CLenDecoder
-{
- CProb Choice;
- CProb Choice2;
- CBitTreeDecoder<3> LowCoder[1 << kNumPosBitsMax];
- CBitTreeDecoder<3> MidCoder[1 << kNumPosBitsMax];
- CBitTreeDecoder<8> HighCoder;
-
-public:
-
- void Init()
- {
- Choice = PROB_INIT_VAL;
- Choice2 = PROB_INIT_VAL;
- HighCoder.Init();
- for (unsigned i = 0; i < (1 << kNumPosBitsMax); i++)
- {
- LowCoder[i].Init();
- MidCoder[i].Init();
- }
- }
-
- unsigned Decode(CRangeDecoder *rc, unsigned posState)
- {
- if (rc->DecodeBit(&Choice) == 0)
- return LowCoder[posState].Decode(rc);
- if (rc->DecodeBit(&Choice2) == 0)
- return 8 + MidCoder[posState].Decode(rc);
- return 16 + HighCoder.Decode(rc);
- }
-};
-
-The LZMA decoder uses two instances of CLenDecoder class.
-The first instance is for the matches of "Simple Match" type,
-and the second instance is for the matches of "Rep Match" type:
-
- CLenDecoder LenDecoder;
- CLenDecoder RepLenDecoder;
-
-
-The match distance decoding
----------------------------
-
-LZMA supports dictionary sizes up to 4 GiB minus 1.
-The value of match distance (decoded by distance decoder) can be
-from 1 to 2^32. But the distance value that is equal to 2^32 is used to
-indicate the "End of stream" marker. So real largest match distance
-that is used for LZ-window match is (2^32 - 1).
-
-LZMA uses normalized match length (zero-based length)
-to calculate the context state "lenState" do decode the distance value:
-
-#define kNumLenToPosStates 4
-
- unsigned lenState = len;
- if (lenState > kNumLenToPosStates - 1)
- lenState = kNumLenToPosStates - 1;
-
-The distance decoder returns the "dist" value that is zero-based value
-of match distance. The real match distance can be calculated with the
-following code:
-
- matchDistance = dist + 1;
-
-The state of the distance decoder and the initialization code:
-
- #define kEndPosModelIndex 14
- #define kNumFullDistances (1 << (kEndPosModelIndex >> 1))
- #define kNumAlignBits 4
-
- CBitTreeDecoder<6> PosSlotDecoder[kNumLenToPosStates];
- CProb PosDecoders[1 + kNumFullDistances - kEndPosModelIndex];
- CBitTreeDecoder<kNumAlignBits> AlignDecoder;
-
- void InitDist()
- {
- for (unsigned i = 0; i < kNumLenToPosStates; i++)
- PosSlotDecoder[i].Init();
- AlignDecoder.Init();
- INIT_PROBS(PosDecoders);
- }
-
-At first stage the distance decoder decodes 6-bit "posSlot" value with bit
-tree decoder from PosSlotDecoder array. It's possible to get 2^6=64 different
-"posSlot" values.
-
- unsigned posSlot = PosSlotDecoder[lenState].Decode(&RangeDec);
-
-The encoding scheme for distance value is shown in the following table:
-
-posSlot (decimal) /
- zero-based distance (binary)
- 0 0
- 1 1
- 2 10
- 3 11
-
- 4 10 x
- 5 11 x
- 6 10 xx
- 7 11 xx
- 8 10 xxx
- 9 11 xxx
-10 10 xxxx
-11 11 xxxx
-12 10 xxxxx
-13 11 xxxxx
-
-14 10 yy zzzz
-15 11 yy zzzz
-16 10 yyy zzzz
-17 11 yyy zzzz
-...
-62 10 yyyyyyyyyyyyyyyyyyyyyyyyyy zzzz
-63 11 yyyyyyyyyyyyyyyyyyyyyyyyyy zzzz
-
-where
- "x ... x" means the sequence of binary symbols encoded with binary tree and
- "Reverse" scheme. It uses separated binary tree for each posSlot from 4 to 13.
- "y" means direct bit encoded with range coder.
- "zzzz" means the sequence of four binary symbols encoded with binary
- tree with "Reverse" scheme, where one common binary tree "AlignDecoder"
- is used for all posSlot values.
-
-If (posSlot < 4), the "dist" value is equal to posSlot value.
-
-If (posSlot >= 4), the decoder uses "posSlot" value to calculate the value of
- the high bits of "dist" value and the number of the low bits.
-
- If (4 <= posSlot < kEndPosModelIndex), the decoder uses bit tree decoders.
- (one separated bit tree decoder per one posSlot value) and "Reverse" scheme.
- In this implementation we use one CProb array "PosDecoders" that contains
- all CProb variables for all these bit decoders.
-
- if (posSlot >= kEndPosModelIndex), the middle bits are decoded as direct
- bits from RangeDecoder and the low 4 bits are decoded with a bit tree
- decoder "AlignDecoder" with "Reverse" scheme.
-
-The code to decode zero-based match distance:
-
- unsigned DecodeDistance(unsigned len)
- {
- unsigned lenState = len;
- if (lenState > kNumLenToPosStates - 1)
- lenState = kNumLenToPosStates - 1;
-
- unsigned posSlot = PosSlotDecoder[lenState].Decode(&RangeDec);
- if (posSlot < 4)
- return posSlot;
-
- unsigned numDirectBits = (unsigned)((posSlot >> 1) - 1);
- UInt32 dist = ((2 | (posSlot & 1)) << numDirectBits);
- if (posSlot < kEndPosModelIndex)
- dist += BitTreeReverseDecode(PosDecoders + dist - posSlot, numDirectBits, &RangeDec);
- else
- {
- dist += RangeDec.DecodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;
- dist += AlignDecoder.ReverseDecode(&RangeDec);
- }
- return dist;
- }
-
-
-
-LZMA Decoding modes
--------------------
-
-There are 2 types of LZMA streams:
-
-1) The stream with "End of stream" marker.
-2) The stream without "End of stream" marker.
-
-And the LZMA Decoder supports 3 modes of decoding:
-
-1) The unpack size is undefined. The LZMA decoder stops decoding after
- getting "End of stream" marker.
- The input variables for that case:
-
- markerIsMandatory = true
- unpackSizeDefined = false
- unpackSize contains any value
-
-2) The unpack size is defined and LZMA decoder supports both variants,
- where the stream can contain "End of stream" marker or the stream is
- finished without "End of stream" marker. The LZMA decoder must detect
- any of these situations.
- The input variables for that case:
-
- markerIsMandatory = false
- unpackSizeDefined = true
- unpackSize contains unpack size
-
-3) The unpack size is defined and the LZMA stream must contain
- "End of stream" marker
- The input variables for that case:
-
- markerIsMandatory = true
- unpackSizeDefined = true
- unpackSize contains unpack size
-
-
-The main loop of decoder
-------------------------
-
-The main loop of LZMA decoder:
-
-Initialize the LZMA state.
-loop
-{
- // begin of loop
- Check "end of stream" conditions.
- Decode Type of MATCH / LITERAL.
- If it's LITERAL, decode LITERAL value and put the LITERAL to Window.
- If it's MATCH, decode the length of match and the match distance.
- Check error conditions, check end of stream conditions and copy
- the sequence of match bytes from sliding window to current position
- in window.
- Go to begin of loop
-}
-
-The reference implementation of LZMA decoder uses "unpackSize" variable
-to keep the number of remaining bytes in output stream. So it reduces
-"unpackSize" value after each decoded LITERAL or MATCH.
-
-The following code contains the "end of stream" condition check at the start
-of the loop:
-
- if (unpackSizeDefined && unpackSize == 0 && !markerIsMandatory)
- if (RangeDec.IsFinishedOK())
- return LZMA_RES_FINISHED_WITHOUT_MARKER;
-
-LZMA uses three types of matches:
-
-1) "Simple Match" - the match with distance value encoded with bit models.
-
-2) "Rep Match" - the match that uses the distance from distance
- history table.
-
-3) "Short Rep Match" - the match of single byte length, that uses the latest
- distance from distance history table.
-
-The LZMA decoder keeps the history of latest 4 match distances that were used
-by decoder. That set of 4 variables contains zero-based match distances and
-these variables are initialized with zero values:
-
- UInt32 rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
-
-The LZMA decoder uses binary model variables to select type of MATCH or LITERAL:
-
-#define kNumStates 12
-#define kNumPosBitsMax 4
-
- CProb IsMatch[kNumStates << kNumPosBitsMax];
- CProb IsRep[kNumStates];
- CProb IsRepG0[kNumStates];
- CProb IsRepG1[kNumStates];
- CProb IsRepG2[kNumStates];
- CProb IsRep0Long[kNumStates << kNumPosBitsMax];
-
-The decoder uses "state" variable value to select exact variable
-from "IsRep", "IsRepG0", "IsRepG1" and "IsRepG2" arrays.
-The "state" variable can get the value from 0 to 11.
-Initial value for "state" variable is zero:
-
- unsigned state = 0;
-
-The "state" variable is updated after each LITERAL or MATCH with one of the
-following functions:
-
-unsigned UpdateState_Literal(unsigned state)
-{
- if (state < 4) return 0;
- else if (state < 10) return state - 3;
- else return state - 6;
-}
-unsigned UpdateState_Match (unsigned state) { return state < 7 ? 7 : 10; }
-unsigned UpdateState_Rep (unsigned state) { return state < 7 ? 8 : 11; }
-unsigned UpdateState_ShortRep(unsigned state) { return state < 7 ? 9 : 11; }
-
-The decoder calculates "state2" variable value to select exact variable from
-"IsMatch" and "IsRep0Long" arrays:
-
-unsigned posState = OutWindow.TotalPos & ((1 << pb) - 1);
-unsigned state2 = (state << kNumPosBitsMax) + posState;
-
-The decoder uses the following code flow scheme to select exact
-type of LITERAL or MATCH:
-
-IsMatch[state2] decode
- 0 - the Literal
- 1 - the Match
- IsRep[state] decode
- 0 - Simple Match
- 1 - Rep Match
- IsRepG0[state] decode
- 0 - the distance is rep0
- IsRep0Long[state2] decode
- 0 - Short Rep Match
- 1 - Rep Match 0
- 1 -
- IsRepG1[state] decode
- 0 - Rep Match 1
- 1 -
- IsRepG2[state] decode
- 0 - Rep Match 2
- 1 - Rep Match 3
-
-
-LITERAL symbol
---------------
-If the value "0" was decoded with IsMatch[state2] decoding, we have "LITERAL" type.
-
-At first the LZMA decoder must check that it doesn't exceed
-specified uncompressed size:
-
- if (unpackSizeDefined && unpackSize == 0)
- return LZMA_RES_ERROR;
-
-Then it decodes literal value and puts it to sliding window:
-
- DecodeLiteral(state, rep0);
-
-Then the decoder must update the "state" value and "unpackSize" value;
-
- state = UpdateState_Literal(state);
- unpackSize--;
-
-Then the decoder must go to the begin of main loop to decode next Match or Literal.
-
-
-Simple Match
-------------
-
-If the value "1" was decoded with IsMatch[state2] decoding,
-we have the "Simple Match" type.
-
-The distance history table is updated with the following scheme:
-
- rep3 = rep2;
- rep2 = rep1;
- rep1 = rep0;
-
-The zero-based length is decoded with "LenDecoder":
-
- len = LenDecoder.Decode(&RangeDec, posState);
-
-The state is update with UpdateState_Match function:
-
- state = UpdateState_Match(state);
-
-and the new "rep0" value is decoded with DecodeDistance:
-
- rep0 = DecodeDistance(len);
-
-That "rep0" will be used as zero-based distance for current match.
-
-If the value of "rep0" is equal to 0xFFFFFFFF, it means that we have
-"End of stream" marker, so we can stop decoding and check finishing
-condition in Range Decoder:
-
- if (rep0 == 0xFFFFFFFF)
- return RangeDec.IsFinishedOK() ?
- LZMA_RES_FINISHED_WITH_MARKER :
- LZMA_RES_ERROR;
-
-If uncompressed size is defined, LZMA decoder must check that it doesn't
-exceed that specified uncompressed size:
-
- if (unpackSizeDefined && unpackSize == 0)
- return LZMA_RES_ERROR;
-
-Also the decoder must check that "rep0" value is not larger than dictionary size
-and is not larger than the number of already decoded bytes:
-
- if (rep0 >= dictSize || !OutWindow.CheckDistance(rep0))
- return LZMA_RES_ERROR;
-
-Then the decoder must copy match bytes as described in
-"The match symbols copying" section.
-
-
-Rep Match
----------
-
-If the LZMA decoder has decoded the value "1" with IsRep[state] variable,
-we have "Rep Match" type.
-
-At first the LZMA decoder must check that it doesn't exceed
-specified uncompressed size:
-
- if (unpackSizeDefined && unpackSize == 0)
- return LZMA_RES_ERROR;
-
-Also the decoder must return error, if the LZ window is empty:
-
- if (OutWindow.IsEmpty())
- return LZMA_RES_ERROR;
-
-If the match type is "Rep Match", the decoder uses one of the 4 variables of
-distance history table to get the value of distance for current match.
-And there are 4 corresponding ways of decoding flow.
-
-The decoder updates the distance history with the following scheme
-depending from type of match:
-
-- "Rep Match 0" or "Short Rep Match":
- ; LZMA doesn't update the distance history
-
-- "Rep Match 1":
- UInt32 dist = rep1;
- rep1 = rep0;
- rep0 = dist;
-
-- "Rep Match 2":
- UInt32 dist = rep2;
- rep2 = rep1;
- rep1 = rep0;
- rep0 = dist;
-
-- "Rep Match 3":
- UInt32 dist = rep3;
- rep3 = rep2;
- rep2 = rep1;
- rep1 = rep0;
- rep0 = dist;
-
-Then the decoder decodes exact subtype of "Rep Match" using "IsRepG0", "IsRep0Long",
-"IsRepG1", "IsRepG2".
-
-If the subtype is "Short Rep Match", the decoder updates the state, puts
-the one byte from window to current position in window and goes to next
-MATCH/LITERAL symbol (the begin of main loop):
-
- state = UpdateState_ShortRep(state);
- OutWindow.PutByte(OutWindow.GetByte(rep0 + 1));
- unpackSize--;
- continue;
-
-In other cases (Rep Match 0/1/2/3), it decodes the zero-based
-length of match with "RepLenDecoder" decoder:
-
- len = RepLenDecoder.Decode(&RangeDec, posState);
-
-Then it updates the state:
-
- state = UpdateState_Rep(state);
-
-Then the decoder must copy match bytes as described in
-"The Match symbols copying" section.
-
-
-The match symbols copying
--------------------------
-
-If we have the match (Simple Match or Rep Match 0/1/2/3), the decoder must
-copy the sequence of bytes with calculated match distance and match length.
-If uncompressed size is defined, LZMA decoder must check that it doesn't
-exceed that specified uncompressed size:
-
- len += kMatchMinLen;
- bool isError = false;
- if (unpackSizeDefined && unpackSize < len)
- {
- len = (unsigned)unpackSize;
- isError = true;
- }
- OutWindow.CopyMatch(rep0 + 1, len);
- unpackSize -= len;
- if (isError)
- return LZMA_RES_ERROR;
-
-Then the decoder must go to the begin of main loop to decode next MATCH or LITERAL.
-
-
-
-NOTES
------
-
-This specification doesn't describe the variant of decoder implementation
-that supports partial decoding. Such partial decoding case can require some
-changes in "end of stream" condition checks code. Also such code
-can use additional status codes, returned by decoder.
-
-This specification uses C++ code with templates to simplify describing.
-The optimized version of LZMA decoder doesn't need templates.
-Such optimized version can use just two arrays of CProb variables:
- 1) The dynamic array of CProb variables allocated for the Literal Decoder.
- 2) The one common array that contains all other CProb variables.
-
-
-References:
-
-1. G. N. N. Martin, Range encoding: an algorithm for removing redundancy
- from a digitized message, Video & Data Recording Conference,
- Southampton, UK, July 24-27, 1979.
diff --git a/DOC/lzma.txt b/DOC/lzma.txt
index 1f92142..142feb1 100644
--- a/DOC/lzma.txt
+++ b/DOC/lzma.txt
@@ -1,328 +1,345 @@
-LZMA compression
-----------------
-Version: 9.35
-
-This file describes LZMA encoding and decoding functions written in C language.
-
-LZMA is an improved version of famous LZ77 compression algorithm.
-It was improved in way of maximum increasing of compression ratio,
-keeping high decompression speed and low memory requirements for
-decompressing.
-
-Note: you can read also LZMA Specification (lzma-specification.txt from LZMA SDK)
-
-Also you can look source code for LZMA encoding and decoding:
- C/Util/Lzma/LzmaUtil.c
-
-
-LZMA compressed file format
----------------------------
-Offset Size Description
- 0 1 Special LZMA properties (lc,lp, pb in encoded form)
- 1 4 Dictionary size (little endian)
- 5 8 Uncompressed size (little endian). -1 means unknown size
- 13 Compressed data
-
-
-
-ANSI-C LZMA Decoder
-~~~~~~~~~~~~~~~~~~~
-
-Please note that interfaces for ANSI-C code were changed in LZMA SDK 4.58.
-If you want to use old interfaces you can download previous version of LZMA SDK
-from sourceforge.net site.
-
-To use ANSI-C LZMA Decoder you need the following files:
-1) LzmaDec.h + LzmaDec.c + 7zTypes.h + Precomp.h + Compiler.h
-
-Look example code:
- C/Util/Lzma/LzmaUtil.c
-
-
-Memory requirements for LZMA decoding
--------------------------------------
-
-Stack usage of LZMA decoding function for local variables is not
-larger than 200-400 bytes.
-
-LZMA Decoder uses dictionary buffer and internal state structure.
-Internal state structure consumes
- state_size = (4 + (1.5 << (lc + lp))) KB
-by default (lc=3, lp=0), state_size = 16 KB.
-
-
-How To decompress data
-----------------------
-
-LZMA Decoder (ANSI-C version) now supports 2 interfaces:
-1) Single-call Decompressing
-2) Multi-call State Decompressing (zlib-like interface)
-
-You must use external allocator:
-Example:
-void *SzAlloc(void *p, size_t size) { p = p; return malloc(size); }
-void SzFree(void *p, void *address) { p = p; free(address); }
-ISzAlloc alloc = { SzAlloc, SzFree };
-
-You can use p = p; operator to disable compiler warnings.
-
-
-Single-call Decompressing
--------------------------
-When to use: RAM->RAM decompressing
-Compile files: LzmaDec.h + LzmaDec.c + 7zTypes.h
-Compile defines: no defines
-Memory Requirements:
- - Input buffer: compressed size
- - Output buffer: uncompressed size
- - LZMA Internal Structures: state_size (16 KB for default settings)
-
-Interface:
- int LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
- const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
- ELzmaStatus *status, ISzAlloc *alloc);
- In:
- dest - output data
- destLen - output data size
- src - input data
- srcLen - input data size
- propData - LZMA properties (5 bytes)
- propSize - size of propData buffer (5 bytes)
- 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).
- You can use LZMA_FINISH_END, when you know that
- current output buffer covers last bytes of stream.
- alloc - Memory allocator.
-
- Out:
- destLen - processed output size
- srcLen - processed input size
-
- Output:
- 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).
-
- If LZMA decoder sees end_marker before reaching output limit, it returns OK result,
- and output value of destLen will be less than output buffer size limit.
-
- 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. */
-
-
-Multi-call State Decompressing (zlib-like interface)
-----------------------------------------------------
-
-When to use: file->file decompressing
-Compile files: LzmaDec.h + LzmaDec.c + 7zTypes.h
-
-Memory Requirements:
- - Buffer for input stream: any size (for example, 16 KB)
- - Buffer for output stream: any size (for example, 16 KB)
- - LZMA Internal Structures: state_size (16 KB for default settings)
- - LZMA dictionary (dictionary size is encoded in LZMA properties header)
-
-1) read LZMA properties (5 bytes) and uncompressed size (8 bytes, little-endian) to header:
- unsigned char header[LZMA_PROPS_SIZE + 8];
- ReadFile(inFile, header, sizeof(header)
-
-2) Allocate CLzmaDec structures (state + dictionary) using LZMA properties
-
- CLzmaDec state;
- LzmaDec_Constr(&state);
- res = LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc);
- if (res != SZ_OK)
- return res;
-
-3) Init LzmaDec structure before any new LZMA stream. And call LzmaDec_DecodeToBuf in loop
-
- LzmaDec_Init(&state);
- for (;;)
- {
- ...
- int res = LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
- const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode);
- ...
- }
-
-
-4) Free all allocated structures
- LzmaDec_Free(&state, &g_Alloc);
-
-Look example code:
- C/Util/Lzma/LzmaUtil.c
-
-
-How To compress data
---------------------
-
-Compile files:
- 7zTypes.h
- Threads.h
- LzmaEnc.h
- LzmaEnc.c
- LzFind.h
- LzFind.c
- LzFindMt.h
- LzFindMt.c
- LzHash.h
-
-Memory Requirements:
- - (dictSize * 11.5 + 6 MB) + state_size
-
-Lzma Encoder can use two memory allocators:
-1) alloc - for small arrays.
-2) allocBig - for big arrays.
-
-For example, you can use Large RAM Pages (2 MB) in allocBig allocator for
-better compression speed. Note that Windows has bad implementation for
-Large RAM Pages.
-It's OK to use same allocator for alloc and allocBig.
-
-
-Single-call Compression with callbacks
---------------------------------------
-
-Look example code:
- C/Util/Lzma/LzmaUtil.c
-
-When to use: file->file compressing
-
-1) you must implement callback structures for interfaces:
-ISeqInStream
-ISeqOutStream
-ICompressProgress
-ISzAlloc
-
-static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
-static void SzFree(void *p, void *address) { p = p; MyFree(address); }
-static ISzAlloc g_Alloc = { SzAlloc, SzFree };
-
- CFileSeqInStream inStream;
- CFileSeqOutStream outStream;
-
- inStream.funcTable.Read = MyRead;
- inStream.file = inFile;
- outStream.funcTable.Write = MyWrite;
- outStream.file = outFile;
-
-
-2) Create CLzmaEncHandle object;
-
- CLzmaEncHandle enc;
-
- enc = LzmaEnc_Create(&g_Alloc);
- if (enc == 0)
- return SZ_ERROR_MEM;
-
-
-3) initialize CLzmaEncProps properties;
-
- LzmaEncProps_Init(&props);
-
- Then you can change some properties in that structure.
-
-4) Send LZMA properties to LZMA Encoder
-
- res = LzmaEnc_SetProps(enc, &props);
-
-5) Write encoded properties to header
-
- Byte header[LZMA_PROPS_SIZE + 8];
- size_t headerSize = LZMA_PROPS_SIZE;
- UInt64 fileSize;
- int i;
-
- res = LzmaEnc_WriteProperties(enc, header, &headerSize);
- fileSize = MyGetFileLength(inFile);
- for (i = 0; i < 8; i++)
- header[headerSize++] = (Byte)(fileSize >> (8 * i));
- MyWriteFileAndCheck(outFile, header, headerSize)
-
-6) Call encoding function:
- res = LzmaEnc_Encode(enc, &outStream.funcTable, &inStream.funcTable,
- NULL, &g_Alloc, &g_Alloc);
-
-7) Destroy LZMA Encoder Object
- LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
-
-
-If callback function return some error code, LzmaEnc_Encode also returns that code
-or it can return the code like SZ_ERROR_READ, SZ_ERROR_WRITE or SZ_ERROR_PROGRESS.
-
-
-Single-call RAM->RAM Compression
---------------------------------
-
-Single-call RAM->RAM Compression is similar to Compression with callbacks,
-but you provide pointers to buffers instead of pointers to stream callbacks:
-
-SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
- const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
- ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
-
-Return code:
- SZ_OK - OK
- SZ_ERROR_MEM - Memory allocation error
- SZ_ERROR_PARAM - Incorrect paramater
- SZ_ERROR_OUTPUT_EOF - output buffer overflow
- SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
-
-
-
-Defines
--------
-
-_LZMA_SIZE_OPT - Enable some optimizations in LZMA Decoder to get smaller executable code.
-
-_LZMA_PROB32 - It can increase the speed on some 32-bit CPUs, but memory usage for
- some structures will be doubled in that case.
-
-_LZMA_UINT32_IS_ULONG - Define it if int is 16-bit on your compiler and long is 32-bit.
-
-_LZMA_NO_SYSTEM_SIZE_T - Define it if you don't want to use size_t type.
-
-
-_7ZIP_PPMD_SUPPPORT - Define it if you don't want to support PPMD method in AMSI-C .7z decoder.
-
-
-C++ LZMA Encoder/Decoder
-~~~~~~~~~~~~~~~~~~~~~~~~
-C++ LZMA code use COM-like interfaces. So if you want to use it,
-you can study basics of COM/OLE.
-C++ LZMA code is just wrapper over ANSI-C code.
-
-
-C++ Notes
-~~~~~~~~~~~~~~~~~~~~~~~~
-If you use some C++ code folders in 7-Zip (for example, C++ code for .7z handling),
-you must check that you correctly work with "new" operator.
-7-Zip can be compiled with MSVC 6.0 that doesn't throw "exception" from "new" operator.
-So 7-Zip uses "CPP\Common\NewHandler.cpp" that redefines "new" operator:
-operator new(size_t size)
-{
- void *p = ::malloc(size);
- if (p == 0)
- throw CNewException();
- return p;
-}
-If you use MSCV that throws exception for "new" operator, you can compile without
-"NewHandler.cpp". So standard exception will be used. Actually some code of
-7-Zip catches any exception in internal code and converts it to HRESULT code.
-So you don't need to catch CNewException, if you call COM interfaces of 7-Zip.
-
----
-
-http://www.7-zip.org
-http://www.7-zip.org/sdk.html
-http://www.7-zip.org/support.html
+LZMA compression
+----------------
+Version: 23.01
+
+This file describes LZMA encoding and decoding functions written in C language.
+
+LZMA is an improved version of famous LZ77 compression algorithm.
+It was improved in way of maximum increasing of compression ratio,
+keeping high decompression speed and low memory requirements for
+decompressing.
+
+Note: you can read also LZMA Specification (lzma-specification.txt from LZMA SDK)
+
+Also you can look source code for LZMA encoding and decoding:
+ C/Util/Lzma/LzmaUtil.c
+
+
+LZMA compressed file format
+---------------------------
+Offset Size Description
+ 0 1 Special LZMA properties (lc,lp, pb in encoded form)
+ 1 4 Dictionary size (little endian)
+ 5 8 Uncompressed size (little endian). -1 means unknown size
+ 13 Compressed data
+
+
+
+ANSI-C LZMA Decoder
+~~~~~~~~~~~~~~~~~~~
+
+Please note that interfaces for ANSI-C code were changed in LZMA SDK 4.58.
+If you want to use old interfaces you can download previous version of LZMA SDK
+from sourceforge.net site.
+
+To use ANSI-C LZMA Decoder you need the following files:
+1) LzmaDec.h + LzmaDec.c + 7zTypes.h + Precomp.h + Compiler.h
+
+Look example code:
+ C/Util/Lzma/LzmaUtil.c
+
+
+Memory requirements for LZMA decoding
+-------------------------------------
+
+Stack usage of LZMA decoding function for local variables is not
+larger than 200-400 bytes.
+
+LZMA Decoder uses dictionary buffer and internal state structure.
+Internal state structure consumes
+ state_size = (4 + (1.5 << (lc + lp))) KB
+by default (lc=3, lp=0), state_size = 16 KB.
+
+
+How To decompress data
+----------------------
+
+LZMA Decoder (ANSI-C version) now supports 2 interfaces:
+1) Single-call Decompressing
+2) Multi-call State Decompressing (zlib-like interface)
+
+You must use external allocator:
+Example:
+void *SzAlloc(void *p, size_t size) { p = p; return malloc(size); }
+void SzFree(void *p, void *address) { p = p; free(address); }
+ISzAlloc alloc = { SzAlloc, SzFree };
+
+You can use p = p; operator to disable compiler warnings.
+
+
+Single-call Decompressing
+-------------------------
+When to use: RAM->RAM decompressing
+Compile files: LzmaDec.h + LzmaDec.c + 7zTypes.h
+Compile defines: no defines
+Memory Requirements:
+ - Input buffer: compressed size
+ - Output buffer: uncompressed size
+ - LZMA Internal Structures: state_size (16 KB for default settings)
+
+Interface:
+ int LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
+ const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
+ ELzmaStatus *status, ISzAlloc *alloc);
+ In:
+ dest - output data
+ destLen - output data size
+ src - input data
+ srcLen - input data size
+ propData - LZMA properties (5 bytes)
+ propSize - size of propData buffer (5 bytes)
+ 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).
+ You can use LZMA_FINISH_END, when you know that
+ current output buffer covers last bytes of stream.
+ alloc - Memory allocator.
+
+ Out:
+ destLen - processed output size
+ srcLen - processed input size
+
+ Output:
+ 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).
+
+ If LZMA decoder sees end_marker before reaching output limit, it returns OK result,
+ and output value of destLen will be less than output buffer size limit.
+
+ 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. */
+
+
+Multi-call State Decompressing (zlib-like interface)
+----------------------------------------------------
+
+When to use: file->file decompressing
+Compile files: LzmaDec.h + LzmaDec.c + 7zTypes.h
+
+Memory Requirements:
+ - Buffer for input stream: any size (for example, 16 KB)
+ - Buffer for output stream: any size (for example, 16 KB)
+ - LZMA Internal Structures: state_size (16 KB for default settings)
+ - LZMA dictionary (dictionary size is encoded in LZMA properties header)
+
+1) read LZMA properties (5 bytes) and uncompressed size (8 bytes, little-endian) to header:
+ unsigned char header[LZMA_PROPS_SIZE + 8];
+ ReadFile(inFile, header, sizeof(header)
+
+2) Allocate CLzmaDec structures (state + dictionary) using LZMA properties
+
+ CLzmaDec state;
+ LzmaDec_Constr(&state);
+ res = LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc);
+ if (res != SZ_OK)
+ return res;
+
+3) Init LzmaDec structure before any new LZMA stream. And call LzmaDec_DecodeToBuf in loop
+
+ LzmaDec_Init(&state);
+ for (;;)
+ {
+ ...
+ int res = LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
+ const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode);
+ ...
+ }
+
+
+4) Free all allocated structures
+ LzmaDec_Free(&state, &g_Alloc);
+
+Look example code:
+ C/Util/Lzma/LzmaUtil.c
+
+
+How To compress data
+--------------------
+
+Compile files:
+ 7zTypes.h
+ Threads.h
+ Threads.c
+ LzmaEnc.h
+ LzmaEnc.c
+ LzFind.h
+ LzFind.c
+ LzFindMt.h
+ LzFindMt.c
+ LzFindOpt.c
+ LzHash.h
+
+Memory Requirements:
+ - (dictSize * 11.5 + 6 MB) + state_size
+
+Lzma Encoder can use two memory allocators:
+1) alloc - for small arrays.
+2) allocBig - for big arrays.
+
+For example, you can use Large RAM Pages (2 MB) in allocBig allocator for
+better compression speed. Note that Windows has bad implementation for
+Large RAM Pages.
+It's OK to use same allocator for alloc and allocBig.
+
+
+Single-call Compression with callbacks
+--------------------------------------
+
+Look example code:
+ C/Util/Lzma/LzmaUtil.c
+
+When to use: file->file compressing
+
+1) you must implement callback structures for interfaces:
+ISeqInStream
+ISeqOutStream
+ICompressProgress
+ISzAlloc
+
+static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
+static void SzFree(void *p, void *address) { p = p; MyFree(address); }
+static ISzAlloc g_Alloc = { SzAlloc, SzFree };
+
+ CFileSeqInStream inStream;
+ CFileSeqOutStream outStream;
+
+ inStream.funcTable.Read = MyRead;
+ inStream.file = inFile;
+ outStream.funcTable.Write = MyWrite;
+ outStream.file = outFile;
+
+
+2) Create CLzmaEncHandle object;
+
+ CLzmaEncHandle enc;
+
+ enc = LzmaEnc_Create(&g_Alloc);
+ if (enc == 0)
+ return SZ_ERROR_MEM;
+
+
+3) initialize CLzmaEncProps properties;
+
+ LzmaEncProps_Init(&props);
+
+ Then you can change some properties in that structure.
+
+4) Send LZMA properties to LZMA Encoder
+
+ res = LzmaEnc_SetProps(enc, &props);
+
+5) Write encoded properties to header
+
+ Byte header[LZMA_PROPS_SIZE + 8];
+ size_t headerSize = LZMA_PROPS_SIZE;
+ UInt64 fileSize;
+ int i;
+
+ res = LzmaEnc_WriteProperties(enc, header, &headerSize);
+ fileSize = MyGetFileLength(inFile);
+ for (i = 0; i < 8; i++)
+ header[headerSize++] = (Byte)(fileSize >> (8 * i));
+ MyWriteFileAndCheck(outFile, header, headerSize)
+
+6) Call encoding function:
+ res = LzmaEnc_Encode(enc, &outStream.funcTable, &inStream.funcTable,
+ NULL, &g_Alloc, &g_Alloc);
+
+7) Destroy LZMA Encoder Object
+ LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
+
+
+If callback function return some error code, LzmaEnc_Encode also returns that code
+or it can return the code like SZ_ERROR_READ, SZ_ERROR_WRITE or SZ_ERROR_PROGRESS.
+
+
+Single-call RAM->RAM Compression
+--------------------------------
+
+Single-call RAM->RAM Compression is similar to Compression with callbacks,
+but you provide pointers to buffers instead of pointers to stream callbacks:
+
+SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+ const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
+ ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
+
+Return code:
+ SZ_OK - OK
+ SZ_ERROR_MEM - Memory allocation error
+ SZ_ERROR_PARAM - Incorrect paramater
+ SZ_ERROR_OUTPUT_EOF - output buffer overflow
+ SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
+
+
+
+Defines
+-------
+
+Z7_LZMA_SIZE_OPT - Enable some code size optimizations in LZMA Decoder to get smaller executable code.
+
+Z7_LZMA_PROB32 - It can increase the speed on some 32-bit CPUs, but memory usage for
+ some structures will be doubled in that case.
+
+Z7_DECL_Int32_AS_long - Define it if int is 16-bit on your compiler and long is 32-bit.
+
+Z7_DECL_SizeT_AS_unsigned_int - Define it if you don't want to use size_t type.
+
+
+Defines for 7z decoder written in C
+-----------------------------------
+These defines are for 7zDec.c only (the decoder in C).
+C++ 7z decoder doesn't uses these macros.
+
+Z7_PPMD_SUPPORT - define it if you need PPMD method support.
+Z7_NO_METHODS_FILTERS - do not use filters (except of BCJ2 filter).
+Z7_USE_NATIVE_BRANCH_FILTER - use filter for native ISA:
+ use x86 filter, if compiled to x86 executable,
+ use arm64 filter, if compiled to arm64 executable.
+
+
+C++ LZMA Encoder/Decoder
+~~~~~~~~~~~~~~~~~~~~~~~~
+C++ LZMA code use COM-like interfaces. So if you want to use it,
+you can study basics of COM/OLE.
+C++ LZMA code is just wrapper over ANSI-C code.
+
+
+C++ Notes
+~~~~~~~~~~~~~~~~~~~~~~~~
+If you use some C++ code folders in 7-Zip (for example, C++ code for 7z archive handling),
+you must check that you correctly work with "new" operator.
+7-Zip can be compiled with MSVC 6.0 that doesn't throw "exception" from "new" operator.
+So 7-Zip uses "CPP\Common\NewHandler.cpp" that redefines "new" operator,
+if compiled by old MSVC compilers (MSVC before version VS 2010):
+
+operator new(size_t size)
+{
+ void *p = ::malloc(size);
+ if (!p)
+ throw CNewException();
+ return p;
+}
+
+If the compiler is VS 2010 or newer, NewHandler.cpp doesn't redefine "new" operator.
+Sp if you use new compiler (VS 2010 or newer), you still can include "NewHandler.cpp"
+to compilation, and it will not redefine operator new.
+Also you can compile without "NewHandler.cpp" with new compilers.
+If 7-zip doesn't redefine operator "new", standard exception will be used instead of CNewException.
+Some code of 7-Zip catches any exception in internal code and converts it to HRESULT code.
+So you don't need to catch CNewException, if you call COM interfaces of 7-Zip.
+
+---
+
+http://www.7-zip.org
+http://www.7-zip.org/sdk.html
+http://www.7-zip.org/support.html
diff --git a/DOC/readme.txt b/DOC/readme.txt
new file mode 100644
index 0000000..5cd90c5
--- /dev/null
+++ b/DOC/readme.txt
@@ -0,0 +1,273 @@
+7-Zip 23.01 Sources
+-------------------
+
+7-Zip is a file archiver for Windows.
+
+7-Zip Copyright (C) 1999-2023 Igor Pavlov.
+
+
+License Info
+------------
+
+7-Zip is free software distributed under the GNU LGPL
+(except for unRar code). Also some code
+is licensed under the "BSD 3-clause License".
+Read "License.txt" for more infomation about license.
+
+Notes about unRAR license:
+
+Please check main restriction from unRar license:
+
+ 2. The unRAR sources may be used in any software to handle RAR
+ archives without limitations free of charge, but cannot be used
+ to re-create the RAR compression algorithm, which is proprietary.
+ Distribution of modified unRAR sources in separate form or as a
+ part of other software is permitted, provided that it is clearly
+ stated in the documentation and source comments that the code may
+ not be used to develop a RAR (WinRAR) compatible archiver.
+
+In brief it means:
+1) You can compile and use compiled files under GNU LGPL rules, since
+ unRAR license almost has no restrictions for compiled files.
+ You can link these compiled files to LGPL programs.
+2) You can fix bugs in source code and use compiled fixed version.
+3) You can not use unRAR sources to re-create the RAR compression algorithm.
+
+
+LZMA SDK
+--------
+
+This package also contains some files from LZMA SDK
+You can download LZMA SDK from:
+ http://www.7-zip.org/sdk.html
+LZMA SDK is written and placed in the public domain by Igor Pavlov.
+
+
+How to compile in Windows
+-------------------------
+
+To compile the sources to Windows binaries you need Visual Studio compiler and/or Windows SDK.
+You can use latest Windows Studio 2017/2019/2022 to compile binaries for x86, x64, arm64 and arm platforms.
+Also you can use old compilers for some platforms:
+ x86 : Visual C++ 6.0 with Platform SDK
+ x64 : Windows Server 2003 R2 Platform SDK
+ ia64 (itanium) : Windows Server 2003 R2 Platform SDK
+ arm for Windows CE : Standard SDK for Windows CE 5.0
+
+If you use MSVC6, specify also Platform SDK directories at top of directories lists:
+Tools / Options / Directories
+ - Include files
+ - Library files
+
+Also you need Microsoft Macro Assembler:
+ - ml.exe for x86
+ - ml64.exe for x64
+You can use ml.exe from Windows SDK for Windows Vista or some later versions.
+
+There are two ways to compile 7-Zip binaries:
+1) via makefile in command line.
+2) via dsp file in Visual Studio.
+
+The dsp file compiling can be used for development and debug purposes.
+All final 7-Zip binaries are compiled via makefiles, that provide best
+optimization options.
+
+
+How to compile with makefile
+----------------------------
+
+Some macronames can be defined for compiling with makefile:
+
+PLATFORM
+ with possible values: x64, x86, arm64, arm, ia64
+
+OLD_COMPILER
+ for old VC compiler, like MSCV 6.0.
+
+MY_DYNAMIC_LINK
+ for dynamic linking to the run-time library (msvcrt.dll).
+ The default makefile option is static linking to the run-time library.
+
+
+
+Compiling 7-Zip for Unix/Linux
+------------------------------
+
+There are several options to compile 7-Zip with different compilers: gcc and clang.
+Also 7-Zip code contains two versions for some parts of code: in C and in Assembeler.
+So if you compile the version with Assembeler code, you will get faster 7-Zip binary.
+
+7-Zip's assembler code uses the following syntax for different platforms:
+
+1) x86 and x86-64 (AMD64): MASM syntax.
+ There are 2 programs that supports MASM syntax in Linux.
+' 'Asmc Macro Assembler and JWasm. But JWasm now doesn't support some
+ cpu instructions used in 7-Zip.
+ So you must install Asmc Macro Assembler in Linux, if you want to compile fastest version
+ of 7-Zip x86 and x86-64:
+ https://github.com/nidud/asmc
+
+2) arm64: GNU assembler for ARM64 with preprocessor.
+ That systax is supported by GCC and CLANG for ARM64.
+
+There are different binaries that can be compiled from 7-Zip source.
+There are 2 main files in folder for compiling:
+ makefile - that can be used for compiling Windows version of 7-Zip with nmake command
+ makefile.gcc - that can be used for compiling Linux/macOS versions of 7-Zip or Windows version
+ with MINGW (GCC) with make command.
+
+At first you must change the current folder to folder that contains `makefile.gcc`:
+
+ cd CPP/7zip/Bundles/Alone2
+
+Then you can compile `makefile.gcc` with the command:
+
+ make -j -f makefile.gcc
+
+Also there are additional "*.mak" files in folder "CPP/7zip/" that can be used to compile
+7-Zip binaries with optimized code and optimzing options.
+
+To compile with GCC without assembler:
+ cd CPP/7zip/Bundles/Alone2
+ make -j -f ../../cmpl_gcc.mak
+
+To compile with CLANG without assembler:
+ make -j -f ../../cmpl_clang.mak
+
+To compile 7-Zip for x86-64 with asmc assembler:
+ make -j -f ../../cmpl_gcc_x64.mak
+
+To compile 7-Zip for arm64 with assembler:
+ make -j -f ../../cmpl_gcc_arm64.mak
+
+To compile 7-Zip for arm64 for macOS:
+ make -j -f ../../cmpl_mac_arm64.mak
+
+Also you can change some compiler options in the "mak" files:
+ cmpl_gcc.mak
+ var_gcc.mak
+ warn_gcc.mak
+
+makefile.gcc supports some variables that can change compile options
+
+USE_JWASM=1
+ use JWasm assembler instead of Asmc.
+ Note that JWasm doesn't support AES instructions. So AES code from C version AesOpt.c
+ will be used instead of assembler code from AesOpt.asm.
+
+DISABLE_RAR=1
+ removes whole RAR related code from compilation.
+
+DISABLE_RAR_COMPRESS=1
+ removes "not fully free" code of RAR decompression codecs from compilation.
+
+RAR decompression codecs in 7-Zip code has some additional license restrictions,
+that can be treated as not fully compatible with free-software licenses.
+DISABLE_RAR_COMPRESS=1 allows to exclude such "not-fully-free" RAR code from compilation.
+if DISABLE_RAR_COMPRESS=1 is specified, 7-zip will not be able to decompress files
+from rar archives, but 7-zip still will be able to open rar archives to get list of
+files or to extract files that are stored without compression.
+if DISABLE_RAR=1 is specified, 7-zip will not be able to work with RAR archives.
+
+
+
+7-Zip and p7zip
+===============
+Now there are two different ports of 7-Zip for Linux/macOS:
+
+1) p7zip - another port of 7-Zip for Linux, made by an independent developer.
+ The latest version of p7zip now is 16.02, and that p7zip 16.02 is outdated now.
+ http://sourceforge.net/projects/p7zip/
+
+2) 7-Zip for Linux/macOS - this package - it's new code with all changes from latest 7-Zip for Windows.
+
+These two ports are not identical.
+Note also that some Linux specific things can be implemented better in p7zip than in new 7-Zip for Linux.
+
+
+
+
+Notes:
+------
+7-Zip consists of COM modules (DLL files).
+But 7-Zip doesn't use standard COM interfaces for creating objects.
+Look at
+7zip\UI\Client7z folder for example of using DLL files of 7-Zip.
+Some DLL files can use other DLL files from 7-Zip.
+If you don't like it, you must use standalone version of DLL.
+To compile standalone version of DLL you must include all used parts
+to project and define some defs.
+For example, 7zip\Bundles\Format7z is a standalone version of 7z.dll
+that works with 7z format. So you can use such DLL in your project
+without additional DLL files.
+
+
+Description of 7-Zip sources package
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+DOC Documentation
+---
+ readme.txt - Readme file
+ src-history.txt - Sources history
+ 7zC.txt - 7z ANSI-C Decoder description
+ 7zFormat.txt - 7z format description
+ Methods.txt - Compression method IDs
+ lzma.txt - LZMA compression description
+ License.txt - license information
+ copying.txt - GNU LGPL license
+ unRarLicense.txt - License for unRAR part of source code
+ 7zip.wxs - installer script for WIX
+ 7zip.hhp - html help project file
+
+Asm - Source code in Assembler : optimized code for CRC, SHA, AES, LZMA decoding.
+
+C - Source code in C
+
+CPP - Source code in C++
+
+Common common files for C++ projects
+
+Windows common files for Windows related code
+
+7zip
+
+ Common Common modules for 7-zip
+
+ Archive files related to archiving
+
+ Bundle Modules that are bundles of other modules (files)
+
+ Alone 7za.exe: Standalone version of 7-Zip console that supports only 7z/xz/cab/zip/gzip/bzip2/tar.
+ Alone2 7zz.exe: Standalone version of 7-Zip console that supports all formats.
+ Alone7z 7zr.exe: Standalone version of 7-Zip console that supports only 7z (reduced version)
+ Fm Standalone version of 7-Zip File Manager
+ Format7z 7za.dll: .7z support
+ Format7zExtract 7zxa.dll: .7z support, extracting only
+ Format7zR 7zr.dll: .7z support, reduced version
+ Format7zExtractR 7zxr.dll: .7z support, reduced version, extracting only
+ Format7zF 7z.dll: all formats
+ LzmaCon lzma.exe: LZMA compression/decompression
+ SFXCon 7zCon.sfx: Console 7z SFX module
+ SFXWin 7z.sfx: Windows 7z SFX module
+ SFXSetup 7zS.sfx: Windows 7z SFX module for Installers
+
+ Compress files for compression / decompression
+
+ Crypto files for encryption / decryption
+
+ UI
+
+ Agent Intermediary modules for FAR plugin and Explorer plugin
+ Client7z Test application for 7za.dll
+ Common Common UI files
+ Console 7z.exe : Console version
+ Explorer 7-zip.dll: 7-Zip Shell extension
+ Far plugin for Far Manager
+ FileManager 7zFM.exe: 7-Zip File Manager
+ GUI 7zG.exe: 7-Zip GUI version
+
+
+
+---
+Igor Pavlov
+http://www.7-zip.org
diff --git a/DOC/src-history.txt b/DOC/src-history.txt
new file mode 100644
index 0000000..c1c1b71
--- /dev/null
+++ b/DOC/src-history.txt
@@ -0,0 +1,709 @@
+HISTORY of the 7-Zip source code
+--------------------------------
+
+23.01 2023-06-20
+-------------------------
+- All external macros for compiling C/C++ code of 7-Zip now have Z7_ prefix.
+- 7-Zip COM interfaces now use new macros that allow to declare and implement COM interface.
+- The code has been modified to compile with the maximum diagnostic warning level:
+ -Wall in MSVC and -Weverything in CLANG.
+ And some warning types are disabled in 2 files:
+ - C/Compiler.h for C/C++ code warnings.
+ - CPP/Common/Common.h for C++ code warnings.
+- Linux/macOS versions of 7-Zip: IUnknown interface in new code doesn't use
+ virtual destructor that was used in previous 7-Zip and p7zip:
+ // virtual ~IUnknown() {}
+ So 7-Zip's dynamically linked shared libraries (codecs) are not compatible
+ between new 7-Zip for Linux/macOS and old 7-Zip (and p7zip).
+- Some optimizations in filters code: BCJ, BCJ2, Swap* and opthers.
+- If 7-Zip uses BCJ2 filter for big datasets compressing, it can use additional temp
+ files in system's TEMP folder. 7-Zip uses temp file for additional compressed
+ data stream, if size of such compressed stream is larger than predefined limit:
+ 16 MiB in 32-bit version, 4 GiB in 64-bit version.
+- Some bugs were fixed.
+
+
+22.00 2022-06-16
+-------------------------
+- 7-Zip interfaces now support high precision (1 ns) timestamps with reserved
+ fields of tagPROPVARIANT (VT_FILETIME).
+
+
+21.07 2021-12-26
+-------------------------
+- The sorting order of files in archives was slightly changed to be more consistent
+ for cases where the name of some directory is the same as the prefix part of the name
+ of another directory or file.
+- TAR archives created by 7-Zip now are more consistent with archives created by GNU TAR program.
+
+
+21.06 2021-11-24
+-------------------------
+- Bug in LZMA encoder in file LzmaEnc.c was fixed:
+ LzmaEnc_MemEncode(), LzmaEncode() and LzmaCompress() could work incorrectly,
+ if size value for output buffer is smaller than size required for all compressed data.
+ LzmaEnc_Encode() could work incorrectly,
+ if callback ISeqOutStream::Write() doesn't write all compressed data.
+ NCompress::NLzma::CEncoder::Code() could work incorrectly,
+ if callback ISequentialOutStream::Write() returns error code.
+- Bug in versions 21.00-21.05 was fixed:
+ 7-Zip didn't set attributes of directories during archive extracting.
+
+
+21.04 beta 2021-11-02
+-------------------------
+- 7-Zip now reduces the number of working CPU threads for compression,
+ if RAM size is not enough for compression with big LZMA2 dictionary.
+- 7-Zip now can create and check "file.sha256" and "file.sha1" text files
+ that contain the list of file names and SHA-1 / SHA-256 checksums in format
+ compatible with sha1sum/sha256sum programs.
+
+
+21.03 beta 2021-07-20
+-------------------------
+- The maximum dictionary size for LZMA/LZMA2 compressing was increased to 4 GB (3840 MiB).
+- Minor speed optimizations in LZMA/LZMA2 compressing.
+
+
+21.02 alpha 2021-05-06
+-------------------------
+- 7-Zip now writes additional field for filename in UTF-8 encoding to zip archives.
+ It allows to extract correct file name from zip archives on different systems.
+- The command line version of 7-Zip for macOS was released.
+- The speed for LZMA and LZMA2 decompression in arm64 versions for macOS and Linux
+ was increased by 20%-60%.
+- Some changes and improvements in ZIP, TAR and NSIS code.
+
+
+21.01 alpha 2021-03-09
+-------------------------
+- The command line version of 7-Zip for Linux was released.
+- The improvements for speed of ARM64 version using hardware CPU instructions
+ for AES, CRC-32, SHA-1 and SHA-256.
+- The bug in versions 18.02 - 21.00 was fixed:
+ 7-Zip could not correctly extract some ZIP archives created with xz compression method.
+- Some bugs were fixed.
+
+
+20.02 alpha 2020-08-08
+-------------------------
+- The default number of LZMA2 chunks per solid block in 7z archive was increased to 64.
+ It allows to increase the compression speed for big 7z archives, if there is a big number
+ of CPU cores and threads.
+- The speed of PPMd compressing/decompressing was increased for 7z/ZIP/RAR archives.
+- The new -ssp switch. If the switch -ssp is specified, 7-Zip doesn't allow the system
+ to modify "Last Access Time" property of source files for archiving and hashing operations.
+- Some bugs were fixed.
+
+
+20.00 alpha 2020-02-06
+-------------------------
+- 7-Zip now supports new optional match finders for LZMA/LZMA2 compression: bt5 and hc5,
+ that can work faster than bt4 and hc4 match finders for the data with big redundancy.
+- The compression ratio was improved for Fast and Fastest compression levels with the
+ following default settings:
+ - Fastest level (-mx1) : hc5 match finder with 256 KB dictionary.
+ - Fast level (-mx3) : hc5 match finder with 4 MB dictionary.
+- Minor speed optimizations in multithreaded LZMA/LZMA2 compression for Normal/Maximum/Ultra
+ compression levels.
+- bzip2 decoding code was updated to support bzip2 archives, created by lbzip2 program.
+
+
+19.02 2019-09-05
+-------------------------
+- Support for SHA-1/SHA-256 optimized code in
+ Sha1Opt.c, Sha256Opt.c, Sha256Opt.asm, Sha1Opt.asm.
+
+
+19.00 2019-02-21
+-------------------------
+- Encryption strength for 7z archives was increased:
+ the size of random initialization vector was increased from 64-bit to 128-bit,
+ and the pseudo-random number generator was improved.
+- Some bugs were fixed.
+
+
+18.06 2018-12-30
+-------------------------
+- The speed for LZMA/LZMA2 compressing was increased by 3-10%,
+ and there are minor changes in compression ratio.
+- Some bugs were fixed.
+- The bug in 7-Zip 18.02-18.05 was fixed:
+ There was memory leak in multithreading xz decoder - XzDecMt_Decode(),
+ if xz stream contains only one block.
+- 7-Zip 18.02-18.05 used only one CPU thread for bz2 archive creation.
+- The changes for MSVS compiler makefiles:
+ - the makefiles now use "PLATFORM" macroname with values (x64, x86, arm64)
+ instead of "CPU" macroname with values (AMD64, ARM64).
+ - the makefiles by default now use static version of the run-time library.
+
+
+18.05 2018-04-30
+-------------------------
+- The speed for LZMA/LZMA2 compressing was increased
+ by 8% for fastest/fast compression levels and
+ by 3% for normal/maximum compression levels.
+- Previous versions of 7-Zip could work incorrectly in "Large memory pages" mode in
+ Windows 10 because of some BUG with "Large Pages" in Windows 10.
+ Now 7-Zip doesn't use "Large Pages" on Windows 10 up to revision 1709 (16299).
+
+
+18.03 beta 2018-03-04
+-------------------------
+- Asm\x86\LzmaDecOpt.asm: new optimized LZMA decoder written in asm
+ for x64 with about 30% higher speed than main version of LZMA decoder written in C.
+- The speed for single-thread LZMA/LZMA2 decoder written in C was increased by 3%.
+- 7-Zip now can use multi-threading for 7z/LZMA2 decoding,
+ if there are multiple independent data chunks in LZMA2 stream.
+- 7-Zip now can use multi-threading for xz decoding,
+ if there are multiple blocks in xz stream.
+
+
+17.00 beta 2017-04-29
+-------------------------
+- NewHandler.h / NewHandler.cpp:
+ now it redefines operator new() only for old MSVC compilers (_MSC_VER < 1900).
+- C/7zTypes.h : the names of variables in interface structures were changed (vt).
+- Some bugs were fixed. 7-Zip could crash in some cases.
+- Some internal changes in code.
+
+
+16.02 2016-05-21
+-------------------------
+- The BUG in 16.00 - 16.01 was fixed:
+ Split Handler (SplitHandler.cpp) returned incorrect
+ total size value (kpidSize) for split archives.
+
+
+16.01 2016-05-19
+-------------------------
+- Some bugs were fixed,
+- Some internal changes to reduce the number of compiler warnings.
+
+
+16.00 2016-05-10
+-------------------------
+- 7-Zip now can extract multivolume ZIP archives (z01, z02, ... , zip).
+- Some bugs were fixed,
+
+
+15.12 2015-11-19
+-------------------------
+- The BUG in C version of 7z decoder was fixed:
+ 7zDec.c : SzDecodeLzma2()
+ 7z decoder could mistakenly report about decoding error for some 7z archives
+ that use LZMA2 compression method.
+ The probability to get that mistaken decoding error report was about
+ one error per 16384 solid blocks for solid blocks larger than 16 KB (compressed size).
+- The BUG (in 9.26-15.11) in C version of 7z decoder was fixed:
+ 7zArcIn.c : SzReadHeader2()
+ 7z decoder worked incorrectly for 7z archives that contain
+ empty solid blocks, that can be placed to 7z archive, if some file is
+ unavailable for reading during archive creation.
+
+
+15.09 beta 2015-10-16
+-------------------------
+- The BUG in LZMA / LZMA2 encoding code was fixed.
+ The BUG in LzFind.c::MatchFinder_ReadBlock() function.
+ If input data size is larger than (4 GiB - dictionary_size),
+ the following code worked incorrectly:
+ - LZMA : LzmaEnc_MemEncode(), LzmaEncode() : LZMA encoding functions
+ for compressing from memory to memory.
+ That BUG is not related to LZMA encoder version that works via streams.
+ - LZMA2 : multi-threaded version of LZMA2 encoder worked incorrectly, if
+ default value of chunk size (CLzma2EncProps::blockSize) is changed
+ to value larger than (4 GiB - dictionary_size).
+
+
+9.38 beta 2015-01-03
+-------------------------
+- The BUG in 9.31-9.37 was fixed:
+ IArchiveGetRawProps interface was disabled for 7z archives.
+- The BUG in 9.26-9.36 was fixed:
+ Some code in CPP\7zip\Archive\7z\ worked correctly only under Windows.
+
+
+9.36 beta 2014-12-26
+-------------------------
+- The BUG in command line version was fixed:
+ 7-Zip created temporary archive in current folder during update archive
+ operation, if -w{Path} switch was not specified.
+ The fixed 7-Zip creates temporary archive in folder that contains updated archive.
+- The BUG in 9.33-9.35 was fixed:
+ 7-Zip silently ignored file reading errors during 7z or gz archive creation,
+ and the created archive contained only part of file that was read before error.
+ The fixed 7-Zip stops archive creation and it reports about error.
+
+
+9.31 2012-10-31
+-------------------------
+- InBuffer.h : CInBuffer uses ISequentialInStream *_stream; instead of CMyComPtr<ISequentialInStream>
+ OutBuffer.h: COutBuffer uses ISequentialOutStream *_stream; instead of CMyComPtr<ISequentialOutStream>
+
+
+9.26 2011-04-11
+-------------------------
+- The BUG was fixed: multi-threaded ZIP stored file size that was at scan stage,
+ So if the file was changed after scan, the Unpack Size field was incorrect
+
+
+9.21 2011-04-11
+-------------------------
+- New class FString for file names at file systems.
+- Speed optimization in CRC code for big-endian CPUs.
+
+
+9.18 2010-11-02
+-------------------------
+- New small SFX module for installers (C/Util/SfxSetup).
+
+
+9.17 2010-10-04
+-------------------------
+- IStream.h::IOutStream::
+ STDMETHOD(SetSize)(Int64 newSize) PURE;
+ was changed to
+ STDMETHOD(SetSize)(UInt64 newSize) PURE;
+
+
+9.09 2009-12-12
+-------------------------
+- The bug was fixed:
+ Utf16_To_Utf8 funstions in UTFConvert.cpp and 7zMain.c
+ incorrectly converted surrogate characters (the code >= 0x10000) to UTF-8.
+
+
+9.05 2009-07-05
+-------------------------
+- FileMapping.h::CFileMapping now returns WRes
+
+
+9.04 2009-05-30
+-------------------------
+- ICoder.h: NCoderPropID::EEnum values were changed
+
+
+9.02 2009-04-23
+-------------------------
+- Bug was fixed: if swap2 filter was requests at compression,
+ 7-zip used swap4 filter instead (but id was swap2), so archives were incorrect.
+
+4.61 2008-11-23
+-------------------------
+- Bug in ver. 4.58+ was fixed:
+ 7-Zip didn't use any -m* switch after -mtc, -mcl or -mcu for .zip archives.
+- Bug in .CAB code was fixed. 7-Zip didn't show some empty files,
+ if .CAB archive contains more than one empty file.
+
+
+4.59 2008-07-27
+-------------------------
+- Bug was fixed:
+ LZMA Encoder in fast compression mode could access memory outside of
+ allocated range in some rare cases.
+
+
+4.59 alpha 2008-05-30
+-------------------------
+- BUGS was fixed:
+ 7zOut.cpp: 7-Zip incorrectly wrote size of property records in some cases.
+ 7zIn.cpp: 7-Zip incorrectly work with archive, containg archive properties.
+
+4.58 alpha 9 2008-04-29
+-------------------------
+- BUG was fixed: 7-Zip showed incorrect timestamps in ISO files.
+
+
+4.58 alpha 8 2008-04-15
+-------------------------
+- BUG in 4.58 alpha 5/6/7 was fixed:
+ LZMA encoder worked incorrectly, if lp != 0.
+- Unicode (UTF-8) support for filenames in .ZIP archives. Now there are 3 modes:
+ 1) Default mode: 7-Zip uses UTF-8, if the local code page doesn't contain required symbols.
+ 2) -mcu switch: 7-Zip uses UTF-8, if there are non-ASCII symbols.
+ 3) -mcl switch: 7-Zip uses local code page.
+- Now it's possible to use -mSW- and -mSW+ switches instead of -mSW=off and -mSW=on
+
+
+4.58 alpha 7 2008-04-08
+-------------------------
+- BUG was fixed: BZip2Encoder and BZip2Decoder used CEvent objects without
+ creating, when BZip2 code was called with one thread (with -mmt1 switch or with
+ default switches on single thread CPU).
+- .lzma support.
+- RPM and NSIS support was improved.
+- LZMA now stores only (2 << n) or (3 << n) dictionary size value to LZMA properties.
+
+
+4.58 alpha 6 2008-03-27
+-------------------------
+- NTFS time extra in ZIP.
+- New item property - kpidTimeType - VT_UI4 (0 - NTFS, 1 - Unix, 2 - DOS).
+- Static CRC table is not required now for Lzma Encoder (in Lz MatchFinder).
+
+
+4.58 alpha 5 2008-03-19
+-------------------------
+- Creation time (-mtc switch) for .7z archives
+- LZMA encoder was converted to ANSI-C
+
+
+4.58 alpha 3 2008-02-25
+-------------------------
+- Speed optimizations for LZMA decoding. Now it uses C code instead of C++.
+- 7-Zip now has 128 MB dictionary limit for 32-bit version:
+ It's for speed optimization: kNumLogBits = 9 + sizeof(size_t) / 2;
+- TAR: 'D' link flag support.
+- 7-Zip now can unpack multivolume RAR archives created with
+ "old style volume names" scheme (-vn switch) and names *.001, *.002, ...
+- Fixed bugs:
+ - 7-Zip FM could not copy / move files to root network folders like \\COMPNAME\FOLDERNAME\
+ In case of move it removed original files.
+ - SFX-WIN: if there are errors, it still could return 0.
+ - ZIP (.XPS file) isZip64 && thisDiskNumber16 == 0xFFFF.
+ - ZIP name updating:
+ If zip file contains extra field and you try to change properties of files,
+ 7-zip tries to delete all extra fileds (except for WzAES).
+ And that code could hang.
+ - 7-Zip GUI didn't suggest BZip2 dictionary size used in previous run.
+ - If creation time stamp was included in .RAR archive, 7-zip used creation time stamp
+ as modification time stamp.
+
+4.58 alpha 2 2007-12-31
+-------------------------
+- Small changes in Deflate and LZMA compression.
+- Some speed optimizations.
+
+
+4.57
+----
+- Bug was fixed:
+ Anti item is created for wrong file:
+ http://sourceforge.net/forum/forum.php?thread_id=1880366&forum_id=45798
+
+
+4.52 beta 2007-07-32
+-------------------------
+- 7-Zip could not decompress some cab files
+- "." dir creating at FAT was fixed / long names
+
+
+4.50 beta 2007-07-24
+-------------------------
+- 7-Zip now replaces unsupported filenames (like "nul", "com1") during extracting.
+- New switch for command line version:
+ -ssc[-] enables/disables case-sensitive mode.
+- 7z.exe l shows archive comment for zip archives
+- Some bugs were fixed: long paths names shorter than 4.
+- Speed optimizations for AES encryption.
+
+
+
+4.56 beta 2007-09-13
+-------------------------
+- some fixes in LZ encoder (LZMA and Deflate) code.
+ size_t was replaces to ptrdiff_t.
+ size_t version worked incorrectly with some compilers.
+
+
+4.46 beta 2007-05-25
+-------------------------
+- CPP Synchronization objects now return HRes (error code) instead of bool.
+
+
+4.45 beta 2007-04-16
+-------------------------
+- 7-Zip now uses C version of CRC, so you must call CrcGenerateTable at
+ stratup code, or you must add CPP/Common/CRC.cpp to your project.
+- Method ID in .7z now is 63-bit integer (UInt64).
+- Open error messages
+- unRar 1.5 fixed
+- unShrink fixed
+- BUG of 4.43 beta and 4.44 beta was fixed.
+ 7-Zip compressing to .zip in multi-threading mode didn't work in some cases.
+
+
+4.44 beta 2007-01-20
+-------------------------
+
+- Bug was fixed: LZMAEncoder.cpp::CEncoder::GetOptimumFast
+ it was:
+ data++
+ fixed version:
+ data = _matchFinder.GetPointerToCurrentPos(_matchFinderObj) - 1;
+ It could lead to very small cpmpression ratio decreasing when block needs move.
+
+
+4.30 beta 2005-11-18
+-------------------------
+- Security.h::AddLockMemoryPrivilege - installs "Large pages" feature
+- MemoryLock.h::EnableLockMemoryPrivilege - enables "Large pages" feature
+- Alloc.h::SetLargePageSize - sets optimal LargePageSize size
+
+
+4.27 2005-09-21
+-------------------------
+- Some GUIDs/interfaces were changed.
+ IStream.h:
+ ISequentialInStream::Read now works as old ReadPart
+ ISequentialOutStream::Write now works as old WritePart
+
+
+4.26 beta 2005-08-05
+-------------------------
+- MyAlloc(0)/BigAlloc(0) now return 0
+
+
+4.25 beta 2005-07-31
+-------------------------
+- More 64-bit compatibilty
+
+
+4.24 beta 2005-07-06
+-------------------------
+- Common\NewHandler.h: using throw() for code size optimization.
+
+
+4.23 2005-06-29
+-------------------------
+- Bug was fixed: memory leak in Cab decoder.
+
+
+4.19 beta 2005-05-21
+-------------------------
+- BZip2 code was rewritten. Now 7-Zip doesn't use original BZip2 code.
+ Old (original) version was moved to folder 7zip/Compress/BZip2Original/
+
+
+4.14 beta 2005-01-11
+-------------------------
+- STL using was reduced
+- 7za now supports Split(001) archves
+
+
+4.10 beta 2004-10-21
+-------------------------
+- Codecs now use new interface: ICompressSetDecoderProperties2
+
+
+4.07 beta 2004-10-03
+-------------------------
+- some interfaces were changed slightly to support
+ -stdin -stdout mode.
+- FilterCoder for simple filters
+- Wildcard censor class was changed.
+- Bug was fixed: when encrypted stream was multiple 16,
+ it used additional 16 empty bytes.
+
+
+3.11 2003-10-06
+-------------------------
+ File functions support unicode strings even
+ on Windows 95/98/ME.
+
+
+3.08.02 2003-09-20
+-------------------------
+ More compatible with GCC.
+
+
+3.08.02 beta 2003-08-20
+-------------------------
+ Extracting bug in 7zExtract.cpp was fixed.
+
+
+3.08 beta 2003-08-19
+-------------------------
+ Big source code reconstruction.
+
+
+2.30 Beta 32 2003-05-15
+-------------------------
+ Small changes in Deflate decoder.
+
+
+2.30 Beta 31 2003-04-29
+-------------------------
+ Common/NewHandler.cpp
+ HeapAlloc in (included to beta 30) was changed to malloc.
+ HeapAlloc worked slower in Win95/98/Me.
+
+
+2.30 Beta 30 2003-04-21
+-------------------------
+ new file: Common/String.cpp
+ Common/NewHandler.* were changed
+
+
+2.30 Beta 29 2003-04-07
+-------------------------
+ Small changes in LZMA code.
+
+
+2.30 Beta 28 2003-02-16
+-------------------------
+ Processing anti-files was corrected.
+
+
+2.30 Beta 27 2003-01-24
+-------------------------
+ Project/Archiver/Format/Common/ArchiveInterface.h:
+ new IArchiveOpenVolumeCallback interface.
+
+
+2.30 Beta 26 2003-01-12
+-------------------------
+ SDK/Interface/PropID.h:
+ kpidComment now is kpidCommented
+
+
+2.30 Beta 25 2003-01-02
+-------------------------
+ Main archive interfaces were changed.
+
+
+2.30 Beta 24 2002-11-01
+-------------------------
+ SDK/Windows/Synchronization.h
+ SDK/Windows/Synchronization.cpp
+ - some changes.
+
+
+2.30 Beta 23 2002-09-07
+-------------------------
+ Project/FileManager folder was added.
+ Notation of some source files was changed.
+
+
+2.30 Beta 22 2002-08-28
+-------------------------
+ Project/FileManager folder was added.
+ Notation of some source files was changed.
+
+
+
+2.30 Beta 21 2002-07-08
+-------------------------
+ Project/Compress/LZ/MatchFinder/BinTree/BinTree.h
+ Project/Compress/LZ/MatchFinder/BinTree/BinTreeMain.h
+ Project/Compress/LZ/MatchFinder/BinTree/HC.h
+ Project/Compress/LZ/MatchFinder/BinTree/HCMain.h
+ - RAM requirements for LZMA (7z) compression were reduced.
+
+
+2.30 Beta 20 2002-07-01
+-------------------------
+- SDK/Stream/WindowOut.h
+ now it uses only required memory (dictionary size).
+- Project/Archiver/Resource
+ contains common resurces
+
+
+2.30 Beta 19 2002-04-11
+-------------------------
+- SDK/Archive/Rar/Handler.cpp
+ supporting RAR29
+
+2.30 Beta 18 2002-03-25
+-------------------------
+- SDK/Archive/Cab/MSZipDecoder.cpp
+ SDK/Archive/Cab/LZXDecoder.cpp:
+ bug with corrupted archives was fixed
+- Project/Compress/LZ/MatchFinder/BinTree/BinTree.h
+- Project/Compress/LZ/MatchFinder/BinTree/BinTreeMain.h
+ some speed optimization (using prefetching)
+
+
+2.30 Beta 17 2002-03-03
+-------------------------
+- ARJ suppport.
+
+
+2.30 Beta 16 2002-02-24
+-------------------------
+- Project/Compress/LZ/LZMA/Decoder.cpp:
+ Bug was fixed: LZMA could not extract more than 4 GB.
+- RPM and CPIO formats.
+- Project/Compress/LZ/LZMA/Encoder.*
+ Project/Archiver/Format/7z/OutHandler.cpp
+ New fast compression mode for LZMA: -m0a=0.
+- New match finders for LZMA: bt4b, hc3, hc4.
+
+
+2.30 Beta 15 2002-02-17
+-------------------------
+- Compression ratio in LZMA was slightly improved:
+ Project/Compress/LZ/LZMA/Encoder.*
+ Project/Archiver/Format/7z/OutHandler.cpp
+
+
+2.30 Beta 14 2002-02-10
+-------------------------
+- Supporting multithreading for LZMA:
+ Project/Compress/LZ/MatchFinder/MT
+- Common/String.h:
+ CStringBase::Replace function was fixed.
+
+
+2.30 Beta 13 2002-01-27
+-------------------------
+- Compress/LZ/MatchFinder/BinTree3.h:
+ method
+- Compress/LZ/MatchFinder/BinTreemain.h:
+ - one VirtualAlloc array was splitted to
+ the for 3 arrays.
+ - Hash-functions were changed.
+
+
+
+2.30 Beta 12 2002-01-16
+-------------------------
+- Compress/LZ/MatchFinder/BinTreemain.h:
+ Compress/LZ/MatchFinder/Patricia.h:
+ Compress/PPM/PPMd/SubAlloc.h:
+ Beta 11 bugs were fixed:
+ - VirtualFree was used incorrectly
+ - checking WIN32 instead _WINDOWS.
+ Compress/LZ/MatchFinder/Patricia.h:
+ Beta 11 bug with deleting m_Hash2Descendants was fixed.
+
+
+2.30 Beta 11 2002-01-15
+-------------------------
+- Compress/LZ/MatchFinder/BinTreemain.h:
+ Compress/LZ/MatchFinder/Patricia.h:
+ Compress/PPM/PPMd/SubAlloc.h:
+ using VirtualAlloc for memory allocating
+- Exlorer/ContextMenu.cpp:
+ Testing supporting.
+ CreateProcess instead WinExec
+- Format/Common/IArchiveHandler.h:
+ Exlorer/ProxyHandler.cpp:
+ FAR/Plugin.cpp:
+ New properties names: Method, HostOS.
+- Exlorer/OverwriteDialog.cpp:
+ FAR/OverwriteDialog.cpp:
+ Windows/PropVariantConversions.h
+ Using National time format was eliminated.
+
+
+
+2.30 Beta 10 2002-01-11
+-------------------------
+- Exlorer/ContextMenu.cpp: bug with context menu on
+ Windows NT4 in Unicode version was fixed.
+- Format/7z/UpdateArchiveEngine.cpp: bug was fixed -
+ Updating in Beta 8 and 9 didn't work.
+- Exlorer/CCompressDialog.cpp: history growing bug was fixed.
+
+
+2.30 Beta 9 2002-01-08
+-------------------------
+- SDK/Common/Vector.h: sopporting sorted object vectors .
+- Lang features.
+- Two new match finders: pat3h and pat4h.
+- SDK/Archive/Zip/InEngine.cpp: bug was fixed.
+- SDK/Windows/FileDir.cpp: function CreateComplexDirectory
+ was changed.
+
diff --git a/DOC/unRarLicense.txt b/DOC/unRarLicense.txt
new file mode 100644
index 0000000..5f78b72
--- /dev/null
+++ b/DOC/unRarLicense.txt
@@ -0,0 +1,41 @@
+ ****** ***** ****** unRAR - free utility for RAR archives
+ ** ** ** ** ** ** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ****** ******* ****** License for use and distribution of
+ ** ** ** ** ** ** ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ** ** ** ** ** ** FREE portable version
+ ~~~~~~~~~~~~~~~~~~~~~
+
+ The source code of unRAR utility is freeware. This means:
+
+ 1. All copyrights to RAR and the utility unRAR are exclusively
+ owned by the author - Alexander Roshal.
+
+ 2. The unRAR sources may be used in any software to handle RAR
+ archives without limitations free of charge, but cannot be used
+ to re-create the RAR compression algorithm, which is proprietary.
+ Distribution of modified unRAR sources in separate form or as a
+ part of other software is permitted, provided that it is clearly
+ stated in the documentation and source comments that the code may
+ not be used to develop a RAR (WinRAR) compatible archiver.
+
+ 3. The unRAR utility may be freely distributed. No person or company
+ may charge a fee for the distribution of unRAR without written
+ permission from the copyright holder.
+
+ 4. THE RAR ARCHIVER AND THE UNRAR UTILITY ARE DISTRIBUTED "AS IS".
+ NO WARRANTY OF ANY KIND IS EXPRESSED OR IMPLIED. YOU USE AT
+ YOUR OWN RISK. THE AUTHOR WILL NOT BE LIABLE FOR DATA LOSS,
+ DAMAGES, LOSS OF PROFITS OR ANY OTHER KIND OF LOSS WHILE USING
+ OR MISUSING THIS SOFTWARE.
+
+ 5. Installing and using the unRAR utility signifies acceptance of
+ these terms and conditions of the license.
+
+ 6. If you don't agree with terms of the license you must remove
+ unRAR files from your storage devices and cease to use the
+ utility.
+
+ Thank you for your interest in RAR and unRAR.
+
+
+ Alexander L. Roshal
\ No newline at end of file
diff --git a/Java/SevenZip/CRC.java b/Java/SevenZip/CRC.java
deleted file mode 100644
index f2f791f..0000000
--- a/Java/SevenZip/CRC.java
+++ /dev/null
@@ -1,52 +0,0 @@
-// SevenZip/CRC.java
-
-package SevenZip;
-
-public class CRC
-{
- static public int[] Table = new int[256];
-
- static
- {
- for (int i = 0; i < 256; i++)
- {
- int r = i;
- for (int j = 0; j < 8; j++)
- if ((r & 1) != 0)
- r = (r >>> 1) ^ 0xEDB88320;
- else
- r >>>= 1;
- Table[i] = r;
- }
- }
-
- int _value = -1;
-
- public void Init()
- {
- _value = -1;
- }
-
- public void Update(byte[] data, int offset, int size)
- {
- for (int i = 0; i < size; i++)
- _value = Table[(_value ^ data[offset + i]) & 0xFF] ^ (_value >>> 8);
- }
-
- public void Update(byte[] data)
- {
- int size = data.length;
- for (int i = 0; i < size; i++)
- _value = Table[(_value ^ data[i]) & 0xFF] ^ (_value >>> 8);
- }
-
- public void UpdateByte(int b)
- {
- _value = Table[(_value ^ b) & 0xFF] ^ (_value >>> 8);
- }
-
- public int GetDigest()
- {
- return _value ^ (-1);
- }
-}
diff --git a/Java/SevenZip/Compression/LZ/BinTree.java b/Java/SevenZip/Compression/LZ/BinTree.java
deleted file mode 100644
index 63d58c0..0000000
--- a/Java/SevenZip/Compression/LZ/BinTree.java
+++ /dev/null
@@ -1,382 +0,0 @@
-// LZ.BinTree
-
-package SevenZip.Compression.LZ;
-import java.io.IOException;
-
-
-public class BinTree extends InWindow
-{
- int _cyclicBufferPos;
- int _cyclicBufferSize = 0;
- int _matchMaxLen;
-
- int[] _son;
- int[] _hash;
-
- int _cutValue = 0xFF;
- int _hashMask;
- int _hashSizeSum = 0;
-
- boolean HASH_ARRAY = true;
-
- static final int kHash2Size = 1 << 10;
- static final int kHash3Size = 1 << 16;
- static final int kBT2HashSize = 1 << 16;
- static final int kStartMaxLen = 1;
- static final int kHash3Offset = kHash2Size;
- static final int kEmptyHashValue = 0;
- static final int kMaxValForNormalize = (1 << 30) - 1;
-
- int kNumHashDirectBytes = 0;
- int kMinMatchCheck = 4;
- int kFixHashSize = kHash2Size + kHash3Size;
-
- public void SetType(int numHashBytes)
- {
- HASH_ARRAY = (numHashBytes > 2);
- if (HASH_ARRAY)
- {
- kNumHashDirectBytes = 0;
- kMinMatchCheck = 4;
- kFixHashSize = kHash2Size + kHash3Size;
- }
- else
- {
- kNumHashDirectBytes = 2;
- kMinMatchCheck = 2 + 1;
- kFixHashSize = 0;
- }
- }
-
-
-
-
- public void Init() throws IOException
- {
- super.Init();
- for (int i = 0; i < _hashSizeSum; i++)
- _hash[i] = kEmptyHashValue;
- _cyclicBufferPos = 0;
- ReduceOffsets(-1);
- }
-
- public void MovePos() throws IOException
- {
- if (++_cyclicBufferPos >= _cyclicBufferSize)
- _cyclicBufferPos = 0;
- super.MovePos();
- if (_pos == kMaxValForNormalize)
- Normalize();
- }
-
-
-
-
-
-
-
-
- public boolean Create(int historySize, int keepAddBufferBefore,
- int matchMaxLen, int keepAddBufferAfter)
- {
- if (historySize > kMaxValForNormalize - 256)
- return false;
- _cutValue = 16 + (matchMaxLen >> 1);
-
- int windowReservSize = (historySize + keepAddBufferBefore +
- matchMaxLen + keepAddBufferAfter) / 2 + 256;
-
- super.Create(historySize + keepAddBufferBefore, matchMaxLen + keepAddBufferAfter, windowReservSize);
-
- _matchMaxLen = matchMaxLen;
-
- int cyclicBufferSize = historySize + 1;
- if (_cyclicBufferSize != cyclicBufferSize)
- _son = new int[(_cyclicBufferSize = cyclicBufferSize) * 2];
-
- int hs = kBT2HashSize;
-
- if (HASH_ARRAY)
- {
- hs = historySize - 1;
- hs |= (hs >> 1);
- hs |= (hs >> 2);
- hs |= (hs >> 4);
- hs |= (hs >> 8);
- hs >>= 1;
- hs |= 0xFFFF;
- if (hs > (1 << 24))
- hs >>= 1;
- _hashMask = hs;
- hs++;
- hs += kFixHashSize;
- }
- if (hs != _hashSizeSum)
- _hash = new int [_hashSizeSum = hs];
- return true;
- }
- public int GetMatches(int[] distances) throws IOException
- {
- int lenLimit;
- if (_pos + _matchMaxLen <= _streamPos)
- lenLimit = _matchMaxLen;
- else
- {
- lenLimit = _streamPos - _pos;
- if (lenLimit < kMinMatchCheck)
- {
- MovePos();
- return 0;
- }
- }
-
- int offset = 0;
- int matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
- int cur = _bufferOffset + _pos;
- int maxLen = kStartMaxLen; // to avoid items for len < hashSize;
- int hashValue, hash2Value = 0, hash3Value = 0;
-
- if (HASH_ARRAY)
- {
- int temp = CrcTable[_bufferBase[cur] & 0xFF] ^ (_bufferBase[cur + 1] & 0xFF);
- hash2Value = temp & (kHash2Size - 1);
- temp ^= ((int)(_bufferBase[cur + 2] & 0xFF) << 8);
- hash3Value = temp & (kHash3Size - 1);
- hashValue = (temp ^ (CrcTable[_bufferBase[cur + 3] & 0xFF] << 5)) & _hashMask;
- }
- else
- hashValue = ((_bufferBase[cur] & 0xFF) ^ ((int)(_bufferBase[cur + 1] & 0xFF) << 8));
-
- int curMatch = _hash[kFixHashSize + hashValue];
- if (HASH_ARRAY)
- {
- int curMatch2 = _hash[hash2Value];
- int curMatch3 = _hash[kHash3Offset + hash3Value];
- _hash[hash2Value] = _pos;
- _hash[kHash3Offset + hash3Value] = _pos;
- if (curMatch2 > matchMinPos)
- if (_bufferBase[_bufferOffset + curMatch2] == _bufferBase[cur])
- {
- distances[offset++] = maxLen = 2;
- distances[offset++] = _pos - curMatch2 - 1;
- }
- if (curMatch3 > matchMinPos)
- if (_bufferBase[_bufferOffset + curMatch3] == _bufferBase[cur])
- {
- if (curMatch3 == curMatch2)
- offset -= 2;
- distances[offset++] = maxLen = 3;
- distances[offset++] = _pos - curMatch3 - 1;
- curMatch2 = curMatch3;
- }
- if (offset != 0 && curMatch2 == curMatch)
- {
- offset -= 2;
- maxLen = kStartMaxLen;
- }
- }
-
- _hash[kFixHashSize + hashValue] = _pos;
-
- int ptr0 = (_cyclicBufferPos << 1) + 1;
- int ptr1 = (_cyclicBufferPos << 1);
-
- int len0, len1;
- len0 = len1 = kNumHashDirectBytes;
-
- if (kNumHashDirectBytes != 0)
- {
- if (curMatch > matchMinPos)
- {
- if (_bufferBase[_bufferOffset + curMatch + kNumHashDirectBytes] !=
- _bufferBase[cur + kNumHashDirectBytes])
- {
- distances[offset++] = maxLen = kNumHashDirectBytes;
- distances[offset++] = _pos - curMatch - 1;
- }
- }
- }
-
- int count = _cutValue;
-
- while (true)
- {
- if (curMatch <= matchMinPos || count-- == 0)
- {
- _son[ptr0] = _son[ptr1] = kEmptyHashValue;
- break;
- }
- int delta = _pos - curMatch;
- int cyclicPos = ((delta <= _cyclicBufferPos) ?
- (_cyclicBufferPos - delta) :
- (_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
-
- int pby1 = _bufferOffset + curMatch;
- int len = Math.min(len0, len1);
- if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
- {
- while(++len != lenLimit)
- if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
- break;
- if (maxLen < len)
- {
- distances[offset++] = maxLen = len;
- distances[offset++] = delta - 1;
- if (len == lenLimit)
- {
- _son[ptr1] = _son[cyclicPos];
- _son[ptr0] = _son[cyclicPos + 1];
- break;
- }
- }
- }
- if ((_bufferBase[pby1 + len] & 0xFF) < (_bufferBase[cur + len] & 0xFF))
- {
- _son[ptr1] = curMatch;
- ptr1 = cyclicPos + 1;
- curMatch = _son[ptr1];
- len1 = len;
- }
- else
- {
- _son[ptr0] = curMatch;
- ptr0 = cyclicPos;
- curMatch = _son[ptr0];
- len0 = len;
- }
- }
- MovePos();
- return offset;
- }
-
- public void Skip(int num) throws IOException
- {
- do
- {
- int lenLimit;
- if (_pos + _matchMaxLen <= _streamPos)
- lenLimit = _matchMaxLen;
- else
- {
- lenLimit = _streamPos - _pos;
- if (lenLimit < kMinMatchCheck)
- {
- MovePos();
- continue;
- }
- }
-
- int matchMinPos = (_pos > _cyclicBufferSize) ? (_pos - _cyclicBufferSize) : 0;
- int cur = _bufferOffset + _pos;
-
- int hashValue;
-
- if (HASH_ARRAY)
- {
- int temp = CrcTable[_bufferBase[cur] & 0xFF] ^ (_bufferBase[cur + 1] & 0xFF);
- int hash2Value = temp & (kHash2Size - 1);
- _hash[hash2Value] = _pos;
- temp ^= ((int)(_bufferBase[cur + 2] & 0xFF) << 8);
- int hash3Value = temp & (kHash3Size - 1);
- _hash[kHash3Offset + hash3Value] = _pos;
- hashValue = (temp ^ (CrcTable[_bufferBase[cur + 3] & 0xFF] << 5)) & _hashMask;
- }
- else
- hashValue = ((_bufferBase[cur] & 0xFF) ^ ((int)(_bufferBase[cur + 1] & 0xFF) << 8));
-
- int curMatch = _hash[kFixHashSize + hashValue];
- _hash[kFixHashSize + hashValue] = _pos;
-
- int ptr0 = (_cyclicBufferPos << 1) + 1;
- int ptr1 = (_cyclicBufferPos << 1);
-
- int len0, len1;
- len0 = len1 = kNumHashDirectBytes;
-
- int count = _cutValue;
- while (true)
- {
- if (curMatch <= matchMinPos || count-- == 0)
- {
- _son[ptr0] = _son[ptr1] = kEmptyHashValue;
- break;
- }
-
- int delta = _pos - curMatch;
- int cyclicPos = ((delta <= _cyclicBufferPos) ?
- (_cyclicBufferPos - delta) :
- (_cyclicBufferPos - delta + _cyclicBufferSize)) << 1;
-
- int pby1 = _bufferOffset + curMatch;
- int len = Math.min(len0, len1);
- if (_bufferBase[pby1 + len] == _bufferBase[cur + len])
- {
- while (++len != lenLimit)
- if (_bufferBase[pby1 + len] != _bufferBase[cur + len])
- break;
- if (len == lenLimit)
- {
- _son[ptr1] = _son[cyclicPos];
- _son[ptr0] = _son[cyclicPos + 1];
- break;
- }
- }
- if ((_bufferBase[pby1 + len] & 0xFF) < (_bufferBase[cur + len] & 0xFF))
- {
- _son[ptr1] = curMatch;
- ptr1 = cyclicPos + 1;
- curMatch = _son[ptr1];
- len1 = len;
- }
- else
- {
- _son[ptr0] = curMatch;
- ptr0 = cyclicPos;
- curMatch = _son[ptr0];
- len0 = len;
- }
- }
- MovePos();
- }
- while (--num != 0);
- }
-
- void NormalizeLinks(int[] items, int numItems, int subValue)
- {
- for (int i = 0; i < numItems; i++)
- {
- int value = items[i];
- if (value <= subValue)
- value = kEmptyHashValue;
- else
- value -= subValue;
- items[i] = value;
- }
- }
-
- void Normalize()
- {
- int subValue = _pos - _cyclicBufferSize;
- NormalizeLinks(_son, _cyclicBufferSize * 2, subValue);
- NormalizeLinks(_hash, _hashSizeSum, subValue);
- ReduceOffsets(subValue);
- }
-
- public void SetCutValue(int cutValue) { _cutValue = cutValue; }
-
- private static final int[] CrcTable = new int[256];
-
- static
- {
- for (int i = 0; i < 256; i++)
- {
- int r = i;
- for (int j = 0; j < 8; j++)
- if ((r & 1) != 0)
- r = (r >>> 1) ^ 0xEDB88320;
- else
- r >>>= 1;
- CrcTable[i] = r;
- }
- }
-}
diff --git a/Java/SevenZip/Compression/LZ/InWindow.java b/Java/SevenZip/Compression/LZ/InWindow.java
deleted file mode 100644
index 5f3f0b4..0000000
--- a/Java/SevenZip/Compression/LZ/InWindow.java
+++ /dev/null
@@ -1,131 +0,0 @@
-// LZ.InWindow
-
-package SevenZip.Compression.LZ;
-
-import java.io.IOException;
-
-public class InWindow
-{
- public byte[] _bufferBase; // pointer to buffer with data
- java.io.InputStream _stream;
- int _posLimit; // offset (from _buffer) of first byte when new block reading must be done
- boolean _streamEndWasReached; // if (true) then _streamPos shows real end of stream
-
- int _pointerToLastSafePosition;
-
- public int _bufferOffset;
-
- public int _blockSize; // Size of Allocated memory block
- public int _pos; // offset (from _buffer) of curent byte
- int _keepSizeBefore; // how many BYTEs must be kept in buffer before _pos
- int _keepSizeAfter; // how many BYTEs must be kept buffer after _pos
- public int _streamPos; // offset (from _buffer) of first not read byte from Stream
-
- public void MoveBlock()
- {
- int offset = _bufferOffset + _pos - _keepSizeBefore;
- // we need one additional byte, since MovePos moves on 1 byte.
- if (offset > 0)
- offset--;
-
- int numBytes = _bufferOffset + _streamPos - offset;
-
- // check negative offset ????
- for (int i = 0; i < numBytes; i++)
- _bufferBase[i] = _bufferBase[offset + i];
- _bufferOffset -= offset;
- }
-
- public void ReadBlock() throws IOException
- {
- if (_streamEndWasReached)
- return;
- while (true)
- {
- int size = (0 - _bufferOffset) + _blockSize - _streamPos;
- if (size == 0)
- return;
- int numReadBytes = _stream.read(_bufferBase, _bufferOffset + _streamPos, size);
- if (numReadBytes == -1)
- {
- _posLimit = _streamPos;
- int pointerToPostion = _bufferOffset + _posLimit;
- if (pointerToPostion > _pointerToLastSafePosition)
- _posLimit = _pointerToLastSafePosition - _bufferOffset;
-
- _streamEndWasReached = true;
- return;
- }
- _streamPos += numReadBytes;
- if (_streamPos >= _pos + _keepSizeAfter)
- _posLimit = _streamPos - _keepSizeAfter;
- }
- }
-
- void Free() { _bufferBase = null; }
-
- public void Create(int keepSizeBefore, int keepSizeAfter, int keepSizeReserv)
- {
- _keepSizeBefore = keepSizeBefore;
- _keepSizeAfter = keepSizeAfter;
- int blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
- if (_bufferBase == null || _blockSize != blockSize)
- {
- Free();
- _blockSize = blockSize;
- _bufferBase = new byte[_blockSize];
- }
- _pointerToLastSafePosition = _blockSize - keepSizeAfter;
- }
-
- public void SetStream(java.io.InputStream stream) { _stream = stream; }
- public void ReleaseStream() { _stream = null; }
-
- public void Init() throws IOException
- {
- _bufferOffset = 0;
- _pos = 0;
- _streamPos = 0;
- _streamEndWasReached = false;
- ReadBlock();
- }
-
- public void MovePos() throws IOException
- {
- _pos++;
- if (_pos > _posLimit)
- {
- int pointerToPostion = _bufferOffset + _pos;
- if (pointerToPostion > _pointerToLastSafePosition)
- MoveBlock();
- ReadBlock();
- }
- }
-
- public byte GetIndexByte(int index) { return _bufferBase[_bufferOffset + _pos + index]; }
-
- // index + limit have not to exceed _keepSizeAfter;
- public int GetMatchLen(int index, int distance, int limit)
- {
- if (_streamEndWasReached)
- if ((_pos + index) + limit > _streamPos)
- limit = _streamPos - (_pos + index);
- distance++;
- // Byte *pby = _buffer + (size_t)_pos + index;
- int pby = _bufferOffset + _pos + index;
-
- int i;
- for (i = 0; i < limit && _bufferBase[pby + i] == _bufferBase[pby + i - distance]; i++);
- return i;
- }
-
- public int GetNumAvailableBytes() { return _streamPos - _pos; }
-
- public void ReduceOffsets(int subValue)
- {
- _bufferOffset += subValue;
- _posLimit -= subValue;
- _pos -= subValue;
- _streamPos -= subValue;
- }
-}
diff --git a/Java/SevenZip/Compression/LZ/OutWindow.java b/Java/SevenZip/Compression/LZ/OutWindow.java
deleted file mode 100644
index 620cb41..0000000
--- a/Java/SevenZip/Compression/LZ/OutWindow.java
+++ /dev/null
@@ -1,85 +0,0 @@
-// LZ.OutWindow
-
-package SevenZip.Compression.LZ;
-
-import java.io.IOException;
-
-public class OutWindow
-{
- byte[] _buffer;
- int _pos;
- int _windowSize = 0;
- int _streamPos;
- java.io.OutputStream _stream;
-
- public void Create(int windowSize)
- {
- if (_buffer == null || _windowSize != windowSize)
- _buffer = new byte[windowSize];
- _windowSize = windowSize;
- _pos = 0;
- _streamPos = 0;
- }
-
- public void SetStream(java.io.OutputStream stream) throws IOException
- {
- ReleaseStream();
- _stream = stream;
- }
-
- public void ReleaseStream() throws IOException
- {
- Flush();
- _stream = null;
- }
-
- public void Init(boolean solid)
- {
- if (!solid)
- {
- _streamPos = 0;
- _pos = 0;
- }
- }
-
- public void Flush() throws IOException
- {
- int size = _pos - _streamPos;
- if (size == 0)
- return;
- _stream.write(_buffer, _streamPos, size);
- if (_pos >= _windowSize)
- _pos = 0;
- _streamPos = _pos;
- }
-
- public void CopyBlock(int distance, int len) throws IOException
- {
- int pos = _pos - distance - 1;
- if (pos < 0)
- pos += _windowSize;
- for (; len != 0; len--)
- {
- if (pos >= _windowSize)
- pos = 0;
- _buffer[_pos++] = _buffer[pos++];
- if (_pos >= _windowSize)
- Flush();
- }
- }
-
- public void PutByte(byte b) throws IOException
- {
- _buffer[_pos++] = b;
- if (_pos >= _windowSize)
- Flush();
- }
-
- public byte GetByte(int distance)
- {
- int pos = _pos - distance - 1;
- if (pos < 0)
- pos += _windowSize;
- return _buffer[pos];
- }
-}
diff --git a/Java/SevenZip/Compression/LZMA/Base.java b/Java/SevenZip/Compression/LZMA/Base.java
deleted file mode 100644
index 18deed9..0000000
--- a/Java/SevenZip/Compression/LZMA/Base.java
+++ /dev/null
@@ -1,88 +0,0 @@
-// Base.java
-
-package SevenZip.Compression.LZMA;
-
-public class Base
-{
- public static final int kNumRepDistances = 4;
- public static final int kNumStates = 12;
-
- public static final int StateInit()
- {
- return 0;
- }
-
- public static final int StateUpdateChar(int index)
- {
- if (index < 4)
- return 0;
- if (index < 10)
- return index - 3;
- return index - 6;
- }
-
- public static final int StateUpdateMatch(int index)
- {
- return (index < 7 ? 7 : 10);
- }
-
- public static final int StateUpdateRep(int index)
- {
- return (index < 7 ? 8 : 11);
- }
-
- public static final int StateUpdateShortRep(int index)
- {
- return (index < 7 ? 9 : 11);
- }
-
- public static final boolean StateIsCharState(int index)
- {
- return index < 7;
- }
-
- public static final int kNumPosSlotBits = 6;
- public static final int kDicLogSizeMin = 0;
- // public static final int kDicLogSizeMax = 28;
- // public static final int kDistTableSizeMax = kDicLogSizeMax * 2;
-
- public static final int kNumLenToPosStatesBits = 2; // it's for speed optimization
- public static final int kNumLenToPosStates = 1 << kNumLenToPosStatesBits;
-
- public static final int kMatchMinLen = 2;
-
- public static final int GetLenToPosState(int len)
- {
- len -= kMatchMinLen;
- if (len < kNumLenToPosStates)
- return len;
- return (int)(kNumLenToPosStates - 1);
- }
-
- public static final int kNumAlignBits = 4;
- public static final int kAlignTableSize = 1 << kNumAlignBits;
- public static final int kAlignMask = (kAlignTableSize - 1);
-
- public static final int kStartPosModelIndex = 4;
- public static final int kEndPosModelIndex = 14;
- public static final int kNumPosModels = kEndPosModelIndex - kStartPosModelIndex;
-
- public static final int kNumFullDistances = 1 << (kEndPosModelIndex / 2);
-
- public static final int kNumLitPosStatesBitsEncodingMax = 4;
- public static final int kNumLitContextBitsMax = 8;
-
- public static final int kNumPosStatesBitsMax = 4;
- public static final int kNumPosStatesMax = (1 << kNumPosStatesBitsMax);
- public static final int kNumPosStatesBitsEncodingMax = 4;
- public static final int kNumPosStatesEncodingMax = (1 << kNumPosStatesBitsEncodingMax);
-
- public static final int kNumLowLenBits = 3;
- public static final int kNumMidLenBits = 3;
- public static final int kNumHighLenBits = 8;
- public static final int kNumLowLenSymbols = 1 << kNumLowLenBits;
- public static final int kNumMidLenSymbols = 1 << kNumMidLenBits;
- public static final int kNumLenSymbols = kNumLowLenSymbols + kNumMidLenSymbols +
- (1 << kNumHighLenBits);
- public static final int kMatchMaxLen = kMatchMinLen + kNumLenSymbols - 1;
-}
diff --git a/Java/SevenZip/Compression/LZMA/Decoder.java b/Java/SevenZip/Compression/LZMA/Decoder.java
deleted file mode 100644
index 4ebd571..0000000
--- a/Java/SevenZip/Compression/LZMA/Decoder.java
+++ /dev/null
@@ -1,329 +0,0 @@
-package SevenZip.Compression.LZMA;
-
-import SevenZip.Compression.RangeCoder.BitTreeDecoder;
-import SevenZip.Compression.LZMA.Base;
-import SevenZip.Compression.LZ.OutWindow;
-import java.io.IOException;
-
-public class Decoder
-{
- class LenDecoder
- {
- short[] m_Choice = new short[2];
- BitTreeDecoder[] m_LowCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
- BitTreeDecoder[] m_MidCoder = new BitTreeDecoder[Base.kNumPosStatesMax];
- BitTreeDecoder m_HighCoder = new BitTreeDecoder(Base.kNumHighLenBits);
- int m_NumPosStates = 0;
-
- public void Create(int numPosStates)
- {
- for (; m_NumPosStates < numPosStates; m_NumPosStates++)
- {
- m_LowCoder[m_NumPosStates] = new BitTreeDecoder(Base.kNumLowLenBits);
- m_MidCoder[m_NumPosStates] = new BitTreeDecoder(Base.kNumMidLenBits);
- }
- }
-
- public void Init()
- {
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Choice);
- for (int posState = 0; posState < m_NumPosStates; posState++)
- {
- m_LowCoder[posState].Init();
- m_MidCoder[posState].Init();
- }
- m_HighCoder.Init();
- }
-
- public int Decode(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, int posState) throws IOException
- {
- if (rangeDecoder.DecodeBit(m_Choice, 0) == 0)
- return m_LowCoder[posState].Decode(rangeDecoder);
- int symbol = Base.kNumLowLenSymbols;
- if (rangeDecoder.DecodeBit(m_Choice, 1) == 0)
- symbol += m_MidCoder[posState].Decode(rangeDecoder);
- else
- symbol += Base.kNumMidLenSymbols + m_HighCoder.Decode(rangeDecoder);
- return symbol;
- }
- }
-
- class LiteralDecoder
- {
- class Decoder2
- {
- short[] m_Decoders = new short[0x300];
-
- public void Init()
- {
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_Decoders);
- }
-
- public byte DecodeNormal(SevenZip.Compression.RangeCoder.Decoder rangeDecoder) throws IOException
- {
- int symbol = 1;
- do
- symbol = (symbol << 1) | rangeDecoder.DecodeBit(m_Decoders, symbol);
- while (symbol < 0x100);
- return (byte)symbol;
- }
-
- public byte DecodeWithMatchByte(SevenZip.Compression.RangeCoder.Decoder rangeDecoder, byte matchByte) throws IOException
- {
- int symbol = 1;
- do
- {
- int matchBit = (matchByte >> 7) & 1;
- matchByte <<= 1;
- int bit = rangeDecoder.DecodeBit(m_Decoders, ((1 + matchBit) << 8) + symbol);
- symbol = (symbol << 1) | bit;
- if (matchBit != bit)
- {
- while (symbol < 0x100)
- symbol = (symbol << 1) | rangeDecoder.DecodeBit(m_Decoders, symbol);
- break;
- }
- }
- while (symbol < 0x100);
- return (byte)symbol;
- }
- }
-
- Decoder2[] m_Coders;
- int m_NumPrevBits;
- int m_NumPosBits;
- int m_PosMask;
-
- public void Create(int numPosBits, int numPrevBits)
- {
- if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
- return;
- m_NumPosBits = numPosBits;
- m_PosMask = (1 << numPosBits) - 1;
- m_NumPrevBits = numPrevBits;
- int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
- m_Coders = new Decoder2[numStates];
- for (int i = 0; i < numStates; i++)
- m_Coders[i] = new Decoder2();
- }
-
- public void Init()
- {
- int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
- for (int i = 0; i < numStates; i++)
- m_Coders[i].Init();
- }
-
- Decoder2 GetDecoder(int pos, byte prevByte)
- {
- return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))];
- }
- }
-
- OutWindow m_OutWindow = new OutWindow();
- SevenZip.Compression.RangeCoder.Decoder m_RangeDecoder = new SevenZip.Compression.RangeCoder.Decoder();
-
- short[] m_IsMatchDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
- short[] m_IsRepDecoders = new short[Base.kNumStates];
- short[] m_IsRepG0Decoders = new short[Base.kNumStates];
- short[] m_IsRepG1Decoders = new short[Base.kNumStates];
- short[] m_IsRepG2Decoders = new short[Base.kNumStates];
- short[] m_IsRep0LongDecoders = new short[Base.kNumStates << Base.kNumPosStatesBitsMax];
-
- BitTreeDecoder[] m_PosSlotDecoder = new BitTreeDecoder[Base.kNumLenToPosStates];
- short[] m_PosDecoders = new short[Base.kNumFullDistances - Base.kEndPosModelIndex];
-
- BitTreeDecoder m_PosAlignDecoder = new BitTreeDecoder(Base.kNumAlignBits);
-
- LenDecoder m_LenDecoder = new LenDecoder();
- LenDecoder m_RepLenDecoder = new LenDecoder();
-
- LiteralDecoder m_LiteralDecoder = new LiteralDecoder();
-
- int m_DictionarySize = -1;
- int m_DictionarySizeCheck = -1;
-
- int m_PosStateMask;
-
- public Decoder()
- {
- for (int i = 0; i < Base.kNumLenToPosStates; i++)
- m_PosSlotDecoder[i] = new BitTreeDecoder(Base.kNumPosSlotBits);
- }
-
- boolean SetDictionarySize(int dictionarySize)
- {
- if (dictionarySize < 0)
- return false;
- if (m_DictionarySize != dictionarySize)
- {
- m_DictionarySize = dictionarySize;
- m_DictionarySizeCheck = Math.max(m_DictionarySize, 1);
- m_OutWindow.Create(Math.max(m_DictionarySizeCheck, (1 << 12)));
- }
- return true;
- }
-
- boolean SetLcLpPb(int lc, int lp, int pb)
- {
- if (lc > Base.kNumLitContextBitsMax || lp > 4 || pb > Base.kNumPosStatesBitsMax)
- return false;
- m_LiteralDecoder.Create(lp, lc);
- int numPosStates = 1 << pb;
- m_LenDecoder.Create(numPosStates);
- m_RepLenDecoder.Create(numPosStates);
- m_PosStateMask = numPosStates - 1;
- return true;
- }
-
- void Init() throws IOException
- {
- m_OutWindow.Init(false);
-
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsMatchDecoders);
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRep0LongDecoders);
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepDecoders);
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG0Decoders);
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG1Decoders);
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_IsRepG2Decoders);
- SevenZip.Compression.RangeCoder.Decoder.InitBitModels(m_PosDecoders);
-
- m_LiteralDecoder.Init();
- int i;
- for (i = 0; i < Base.kNumLenToPosStates; i++)
- m_PosSlotDecoder[i].Init();
- m_LenDecoder.Init();
- m_RepLenDecoder.Init();
- m_PosAlignDecoder.Init();
- m_RangeDecoder.Init();
- }
-
- public boolean Code(java.io.InputStream inStream, java.io.OutputStream outStream,
- long outSize) throws IOException
- {
- m_RangeDecoder.SetStream(inStream);
- m_OutWindow.SetStream(outStream);
- Init();
-
- int state = Base.StateInit();
- int rep0 = 0, rep1 = 0, rep2 = 0, rep3 = 0;
-
- long nowPos64 = 0;
- byte prevByte = 0;
- while (outSize < 0 || nowPos64 < outSize)
- {
- int posState = (int)nowPos64 & m_PosStateMask;
- if (m_RangeDecoder.DecodeBit(m_IsMatchDecoders, (state << Base.kNumPosStatesBitsMax) + posState) == 0)
- {
- LiteralDecoder.Decoder2 decoder2 = m_LiteralDecoder.GetDecoder((int)nowPos64, prevByte);
- if (!Base.StateIsCharState(state))
- prevByte = decoder2.DecodeWithMatchByte(m_RangeDecoder, m_OutWindow.GetByte(rep0));
- else
- prevByte = decoder2.DecodeNormal(m_RangeDecoder);
- m_OutWindow.PutByte(prevByte);
- state = Base.StateUpdateChar(state);
- nowPos64++;
- }
- else
- {
- int len;
- if (m_RangeDecoder.DecodeBit(m_IsRepDecoders, state) == 1)
- {
- len = 0;
- if (m_RangeDecoder.DecodeBit(m_IsRepG0Decoders, state) == 0)
- {
- if (m_RangeDecoder.DecodeBit(m_IsRep0LongDecoders, (state << Base.kNumPosStatesBitsMax) + posState) == 0)
- {
- state = Base.StateUpdateShortRep(state);
- len = 1;
- }
- }
- else
- {
- int distance;
- if (m_RangeDecoder.DecodeBit(m_IsRepG1Decoders, state) == 0)
- distance = rep1;
- else
- {
- if (m_RangeDecoder.DecodeBit(m_IsRepG2Decoders, state) == 0)
- distance = rep2;
- else
- {
- distance = rep3;
- rep3 = rep2;
- }
- rep2 = rep1;
- }
- rep1 = rep0;
- rep0 = distance;
- }
- if (len == 0)
- {
- len = m_RepLenDecoder.Decode(m_RangeDecoder, posState) + Base.kMatchMinLen;
- state = Base.StateUpdateRep(state);
- }
- }
- else
- {
- rep3 = rep2;
- rep2 = rep1;
- rep1 = rep0;
- len = Base.kMatchMinLen + m_LenDecoder.Decode(m_RangeDecoder, posState);
- state = Base.StateUpdateMatch(state);
- int posSlot = m_PosSlotDecoder[Base.GetLenToPosState(len)].Decode(m_RangeDecoder);
- if (posSlot >= Base.kStartPosModelIndex)
- {
- int numDirectBits = (posSlot >> 1) - 1;
- rep0 = ((2 | (posSlot & 1)) << numDirectBits);
- if (posSlot < Base.kEndPosModelIndex)
- rep0 += BitTreeDecoder.ReverseDecode(m_PosDecoders,
- rep0 - posSlot - 1, m_RangeDecoder, numDirectBits);
- else
- {
- rep0 += (m_RangeDecoder.DecodeDirectBits(
- numDirectBits - Base.kNumAlignBits) << Base.kNumAlignBits);
- rep0 += m_PosAlignDecoder.ReverseDecode(m_RangeDecoder);
- if (rep0 < 0)
- {
- if (rep0 == -1)
- break;
- return false;
- }
- }
- }
- else
- rep0 = posSlot;
- }
- if (rep0 >= nowPos64 || rep0 >= m_DictionarySizeCheck)
- {
- // m_OutWindow.Flush();
- return false;
- }
- m_OutWindow.CopyBlock(rep0, len);
- nowPos64 += len;
- prevByte = m_OutWindow.GetByte(0);
- }
- }
- m_OutWindow.Flush();
- m_OutWindow.ReleaseStream();
- m_RangeDecoder.ReleaseStream();
- return true;
- }
-
- public boolean SetDecoderProperties(byte[] properties)
- {
- if (properties.length < 5)
- return false;
- int val = properties[0] & 0xFF;
- int lc = val % 9;
- int remainder = val / 9;
- int lp = remainder % 5;
- int pb = remainder / 5;
- int dictionarySize = 0;
- for (int i = 0; i < 4; i++)
- dictionarySize += ((int)(properties[1 + i]) & 0xFF) << (i * 8);
- if (!SetLcLpPb(lc, lp, pb))
- return false;
- return SetDictionarySize(dictionarySize);
- }
-}
diff --git a/Java/SevenZip/Compression/LZMA/Encoder.java b/Java/SevenZip/Compression/LZMA/Encoder.java
deleted file mode 100644
index 771fb21..0000000
--- a/Java/SevenZip/Compression/LZMA/Encoder.java
+++ /dev/null
@@ -1,1416 +0,0 @@
-package SevenZip.Compression.LZMA;
-
-import SevenZip.Compression.RangeCoder.BitTreeEncoder;
-import SevenZip.Compression.LZMA.Base;
-import SevenZip.Compression.LZ.BinTree;
-import SevenZip.ICodeProgress;
-import java.io.IOException;
-
-public class Encoder
-{
- public static final int EMatchFinderTypeBT2 = 0;
- public static final int EMatchFinderTypeBT4 = 1;
-
-
-
-
- static final int kIfinityPrice = 0xFFFFFFF;
-
- static byte[] g_FastPos = new byte[1 << 11];
-
- static
- {
- int kFastSlots = 22;
- int c = 2;
- g_FastPos[0] = 0;
- g_FastPos[1] = 1;
- for (int slotFast = 2; slotFast < kFastSlots; slotFast++)
- {
- int k = (1 << ((slotFast >> 1) - 1));
- for (int j = 0; j < k; j++, c++)
- g_FastPos[c] = (byte)slotFast;
- }
- }
-
- static int GetPosSlot(int pos)
- {
- if (pos < (1 << 11))
- return g_FastPos[pos];
- if (pos < (1 << 21))
- return (g_FastPos[pos >> 10] + 20);
- return (g_FastPos[pos >> 20] + 40);
- }
-
- static int GetPosSlot2(int pos)
- {
- if (pos < (1 << 17))
- return (g_FastPos[pos >> 6] + 12);
- if (pos < (1 << 27))
- return (g_FastPos[pos >> 16] + 32);
- return (g_FastPos[pos >> 26] + 52);
- }
-
- int _state = Base.StateInit();
- byte _previousByte;
- int[] _repDistances = new int[Base.kNumRepDistances];
-
- void BaseInit()
- {
- _state = Base.StateInit();
- _previousByte = 0;
- for (int i = 0; i < Base.kNumRepDistances; i++)
- _repDistances[i] = 0;
- }
-
- static final int kDefaultDictionaryLogSize = 22;
- static final int kNumFastBytesDefault = 0x20;
-
- class LiteralEncoder
- {
- class Encoder2
- {
- short[] m_Encoders = new short[0x300];
-
- public void Init() { SevenZip.Compression.RangeCoder.Encoder.InitBitModels(m_Encoders); }
-
-
-
- public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte symbol) throws IOException
- {
- int context = 1;
- for (int i = 7; i >= 0; i--)
- {
- int bit = ((symbol >> i) & 1);
- rangeEncoder.Encode(m_Encoders, context, bit);
- context = (context << 1) | bit;
- }
- }
-
- public void EncodeMatched(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol) throws IOException
- {
- int context = 1;
- boolean same = true;
- for (int i = 7; i >= 0; i--)
- {
- int bit = ((symbol >> i) & 1);
- int state = context;
- if (same)
- {
- int matchBit = ((matchByte >> i) & 1);
- state += ((1 + matchBit) << 8);
- same = (matchBit == bit);
- }
- rangeEncoder.Encode(m_Encoders, state, bit);
- context = (context << 1) | bit;
- }
- }
-
- public int GetPrice(boolean matchMode, byte matchByte, byte symbol)
- {
- int price = 0;
- int context = 1;
- int i = 7;
- if (matchMode)
- {
- for (; i >= 0; i--)
- {
- int matchBit = (matchByte >> i) & 1;
- int bit = (symbol >> i) & 1;
- price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(m_Encoders[((1 + matchBit) << 8) + context], bit);
- context = (context << 1) | bit;
- if (matchBit != bit)
- {
- i--;
- break;
- }
- }
- }
- for (; i >= 0; i--)
- {
- int bit = (symbol >> i) & 1;
- price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(m_Encoders[context], bit);
- context = (context << 1) | bit;
- }
- return price;
- }
- }
-
- Encoder2[] m_Coders;
- int m_NumPrevBits;
- int m_NumPosBits;
- int m_PosMask;
-
- public void Create(int numPosBits, int numPrevBits)
- {
- if (m_Coders != null && m_NumPrevBits == numPrevBits && m_NumPosBits == numPosBits)
- return;
- m_NumPosBits = numPosBits;
- m_PosMask = (1 << numPosBits) - 1;
- m_NumPrevBits = numPrevBits;
- int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
- m_Coders = new Encoder2[numStates];
- for (int i = 0; i < numStates; i++)
- m_Coders[i] = new Encoder2();
- }
-
- public void Init()
- {
- int numStates = 1 << (m_NumPrevBits + m_NumPosBits);
- for (int i = 0; i < numStates; i++)
- m_Coders[i].Init();
- }
-
- public Encoder2 GetSubCoder(int pos, byte prevByte)
- { return m_Coders[((pos & m_PosMask) << m_NumPrevBits) + ((prevByte & 0xFF) >>> (8 - m_NumPrevBits))]; }
- }
-
- class LenEncoder
- {
- short[] _choice = new short[2];
- BitTreeEncoder[] _lowCoder = new BitTreeEncoder[Base.kNumPosStatesEncodingMax];
- BitTreeEncoder[] _midCoder = new BitTreeEncoder[Base.kNumPosStatesEncodingMax];
- BitTreeEncoder _highCoder = new BitTreeEncoder(Base.kNumHighLenBits);
-
-
- public LenEncoder()
- {
- for (int posState = 0; posState < Base.kNumPosStatesEncodingMax; posState++)
- {
- _lowCoder[posState] = new BitTreeEncoder(Base.kNumLowLenBits);
- _midCoder[posState] = new BitTreeEncoder(Base.kNumMidLenBits);
- }
- }
-
- public void Init(int numPosStates)
- {
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_choice);
-
- for (int posState = 0; posState < numPosStates; posState++)
- {
- _lowCoder[posState].Init();
- _midCoder[posState].Init();
- }
- _highCoder.Init();
- }
-
- public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, int symbol, int posState) throws IOException
- {
- if (symbol < Base.kNumLowLenSymbols)
- {
- rangeEncoder.Encode(_choice, 0, 0);
- _lowCoder[posState].Encode(rangeEncoder, symbol);
- }
- else
- {
- symbol -= Base.kNumLowLenSymbols;
- rangeEncoder.Encode(_choice, 0, 1);
- if (symbol < Base.kNumMidLenSymbols)
- {
- rangeEncoder.Encode(_choice, 1, 0);
- _midCoder[posState].Encode(rangeEncoder, symbol);
- }
- else
- {
- rangeEncoder.Encode(_choice, 1, 1);
- _highCoder.Encode(rangeEncoder, symbol - Base.kNumMidLenSymbols);
- }
- }
- }
-
- public void SetPrices(int posState, int numSymbols, int[] prices, int st)
- {
- int a0 = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_choice[0]);
- int a1 = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_choice[0]);
- int b0 = a1 + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_choice[1]);
- int b1 = a1 + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_choice[1]);
- int i = 0;
- for (i = 0; i < Base.kNumLowLenSymbols; i++)
- {
- if (i >= numSymbols)
- return;
- prices[st + i] = a0 + _lowCoder[posState].GetPrice(i);
- }
- for (; i < Base.kNumLowLenSymbols + Base.kNumMidLenSymbols; i++)
- {
- if (i >= numSymbols)
- return;
- prices[st + i] = b0 + _midCoder[posState].GetPrice(i - Base.kNumLowLenSymbols);
- }
- for (; i < numSymbols; i++)
- prices[st + i] = b1 + _highCoder.GetPrice(i - Base.kNumLowLenSymbols - Base.kNumMidLenSymbols);
- }
- };
-
- public static final int kNumLenSpecSymbols = Base.kNumLowLenSymbols + Base.kNumMidLenSymbols;
-
- class LenPriceTableEncoder extends LenEncoder
- {
- int[] _prices = new int[Base.kNumLenSymbols<<Base.kNumPosStatesBitsEncodingMax];
- int _tableSize;
- int[] _counters = new int[Base.kNumPosStatesEncodingMax];
-
- public void SetTableSize(int tableSize) { _tableSize = tableSize; }
-
- public int GetPrice(int symbol, int posState)
- {
- return _prices[posState * Base.kNumLenSymbols + symbol];
- }
-
- void UpdateTable(int posState)
- {
- SetPrices(posState, _tableSize, _prices, posState * Base.kNumLenSymbols);
- _counters[posState] = _tableSize;
- }
-
- public void UpdateTables(int numPosStates)
- {
- for (int posState = 0; posState < numPosStates; posState++)
- UpdateTable(posState);
- }
-
- public void Encode(SevenZip.Compression.RangeCoder.Encoder rangeEncoder, int symbol, int posState) throws IOException
- {
- super.Encode(rangeEncoder, symbol, posState);
- if (--_counters[posState] == 0)
- UpdateTable(posState);
- }
- }
-
- static final int kNumOpts = 1 << 12;
- class Optimal
- {
- public int State;
-
- public boolean Prev1IsChar;
- public boolean Prev2;
-
- public int PosPrev2;
- public int BackPrev2;
-
- public int Price;
- public int PosPrev;
- public int BackPrev;
-
- public int Backs0;
- public int Backs1;
- public int Backs2;
- public int Backs3;
-
- public void MakeAsChar() { BackPrev = -1; Prev1IsChar = false; }
- public void MakeAsShortRep() { BackPrev = 0; ; Prev1IsChar = false; }
- public boolean IsShortRep() { return (BackPrev == 0); }
- };
- Optimal[] _optimum = new Optimal[kNumOpts];
- SevenZip.Compression.LZ.BinTree _matchFinder = null;
- SevenZip.Compression.RangeCoder.Encoder _rangeEncoder = new SevenZip.Compression.RangeCoder.Encoder();
-
- short[] _isMatch = new short[Base.kNumStates<<Base.kNumPosStatesBitsMax];
- short[] _isRep = new short[Base.kNumStates];
- short[] _isRepG0 = new short[Base.kNumStates];
- short[] _isRepG1 = new short[Base.kNumStates];
- short[] _isRepG2 = new short[Base.kNumStates];
- short[] _isRep0Long = new short[Base.kNumStates<<Base.kNumPosStatesBitsMax];
-
- BitTreeEncoder[] _posSlotEncoder = new BitTreeEncoder[Base.kNumLenToPosStates]; // kNumPosSlotBits
-
- short[] _posEncoders = new short[Base.kNumFullDistances-Base.kEndPosModelIndex];
- BitTreeEncoder _posAlignEncoder = new BitTreeEncoder(Base.kNumAlignBits);
-
- LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder();
- LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder();
-
- LiteralEncoder _literalEncoder = new LiteralEncoder();
-
- int[] _matchDistances = new int[Base.kMatchMaxLen*2+2];
-
- int _numFastBytes = kNumFastBytesDefault;
- int _longestMatchLength;
- int _numDistancePairs;
-
- int _additionalOffset;
-
- int _optimumEndIndex;
- int _optimumCurrentIndex;
-
- boolean _longestMatchWasFound;
-
- int[] _posSlotPrices = new int[1<<(Base.kNumPosSlotBits+Base.kNumLenToPosStatesBits)];
- int[] _distancesPrices = new int[Base.kNumFullDistances<<Base.kNumLenToPosStatesBits];
- int[] _alignPrices = new int[Base.kAlignTableSize];
- int _alignPriceCount;
-
- int _distTableSize = (kDefaultDictionaryLogSize * 2);
-
- int _posStateBits = 2;
- int _posStateMask = (4 - 1);
- int _numLiteralPosStateBits = 0;
- int _numLiteralContextBits = 3;
-
- int _dictionarySize = (1 << kDefaultDictionaryLogSize);
- int _dictionarySizePrev = -1;
- int _numFastBytesPrev = -1;
-
- long nowPos64;
- boolean _finished;
- java.io.InputStream _inStream;
-
- int _matchFinderType = EMatchFinderTypeBT4;
- boolean _writeEndMark = false;
-
- boolean _needReleaseMFStream = false;
-
- void Create()
- {
- if (_matchFinder == null)
- {
- SevenZip.Compression.LZ.BinTree bt = new SevenZip.Compression.LZ.BinTree();
- int numHashBytes = 4;
- if (_matchFinderType == EMatchFinderTypeBT2)
- numHashBytes = 2;
- bt.SetType(numHashBytes);
- _matchFinder = bt;
- }
- _literalEncoder.Create(_numLiteralPosStateBits, _numLiteralContextBits);
-
- if (_dictionarySize == _dictionarySizePrev && _numFastBytesPrev == _numFastBytes)
- return;
- _matchFinder.Create(_dictionarySize, kNumOpts, _numFastBytes, Base.kMatchMaxLen + 1);
- _dictionarySizePrev = _dictionarySize;
- _numFastBytesPrev = _numFastBytes;
- }
-
- public Encoder()
- {
- for (int i = 0; i < kNumOpts; i++)
- _optimum[i] = new Optimal();
- for (int i = 0; i < Base.kNumLenToPosStates; i++)
- _posSlotEncoder[i] = new BitTreeEncoder(Base.kNumPosSlotBits);
- }
-
- void SetWriteEndMarkerMode(boolean writeEndMarker)
- {
- _writeEndMark = writeEndMarker;
- }
-
- void Init()
- {
- BaseInit();
- _rangeEncoder.Init();
-
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isMatch);
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRep0Long);
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRep);
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG0);
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG1);
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_isRepG2);
- SevenZip.Compression.RangeCoder.Encoder.InitBitModels(_posEncoders);
-
-
-
-
-
-
-
- _literalEncoder.Init();
- for (int i = 0; i < Base.kNumLenToPosStates; i++)
- _posSlotEncoder[i].Init();
-
-
-
- _lenEncoder.Init(1 << _posStateBits);
- _repMatchLenEncoder.Init(1 << _posStateBits);
-
- _posAlignEncoder.Init();
-
- _longestMatchWasFound = false;
- _optimumEndIndex = 0;
- _optimumCurrentIndex = 0;
- _additionalOffset = 0;
- }
-
- int ReadMatchDistances() throws java.io.IOException
- {
- int lenRes = 0;
- _numDistancePairs = _matchFinder.GetMatches(_matchDistances);
- if (_numDistancePairs > 0)
- {
- lenRes = _matchDistances[_numDistancePairs - 2];
- if (lenRes == _numFastBytes)
- lenRes += _matchFinder.GetMatchLen((int)lenRes - 1, _matchDistances[_numDistancePairs - 1],
- Base.kMatchMaxLen - lenRes);
- }
- _additionalOffset++;
- return lenRes;
- }
-
- void MovePos(int num) throws java.io.IOException
- {
- if (num > 0)
- {
- _matchFinder.Skip(num);
- _additionalOffset += num;
- }
- }
-
- int GetRepLen1Price(int state, int posState)
- {
- return SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG0[state]) +
- SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep0Long[(state << Base.kNumPosStatesBitsMax) + posState]);
- }
-
- int GetPureRepPrice(int repIndex, int state, int posState)
- {
- int price;
- if (repIndex == 0)
- {
- price = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG0[state]);
- price += SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep0Long[(state << Base.kNumPosStatesBitsMax) + posState]);
- }
- else
- {
- price = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRepG0[state]);
- if (repIndex == 1)
- price += SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRepG1[state]);
- else
- {
- price += SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRepG1[state]);
- price += SevenZip.Compression.RangeCoder.Encoder.GetPrice(_isRepG2[state], repIndex - 2);
- }
- }
- return price;
- }
-
- int GetRepPrice(int repIndex, int len, int state, int posState)
- {
- int price = _repMatchLenEncoder.GetPrice(len - Base.kMatchMinLen, posState);
- return price + GetPureRepPrice(repIndex, state, posState);
- }
-
- int GetPosLenPrice(int pos, int len, int posState)
- {
- int price;
- int lenToPosState = Base.GetLenToPosState(len);
- if (pos < Base.kNumFullDistances)
- price = _distancesPrices[(lenToPosState * Base.kNumFullDistances) + pos];
- else
- price = _posSlotPrices[(lenToPosState << Base.kNumPosSlotBits) + GetPosSlot2(pos)] +
- _alignPrices[pos & Base.kAlignMask];
- return price + _lenEncoder.GetPrice(len - Base.kMatchMinLen, posState);
- }
-
- int Backward(int cur)
- {
- _optimumEndIndex = cur;
- int posMem = _optimum[cur].PosPrev;
- int backMem = _optimum[cur].BackPrev;
- do
- {
- if (_optimum[cur].Prev1IsChar)
- {
- _optimum[posMem].MakeAsChar();
- _optimum[posMem].PosPrev = posMem - 1;
- if (_optimum[cur].Prev2)
- {
- _optimum[posMem - 1].Prev1IsChar = false;
- _optimum[posMem - 1].PosPrev = _optimum[cur].PosPrev2;
- _optimum[posMem - 1].BackPrev = _optimum[cur].BackPrev2;
- }
- }
- int posPrev = posMem;
- int backCur = backMem;
-
- backMem = _optimum[posPrev].BackPrev;
- posMem = _optimum[posPrev].PosPrev;
-
- _optimum[posPrev].BackPrev = backCur;
- _optimum[posPrev].PosPrev = cur;
- cur = posPrev;
- }
- while (cur > 0);
- backRes = _optimum[0].BackPrev;
- _optimumCurrentIndex = _optimum[0].PosPrev;
- return _optimumCurrentIndex;
- }
-
- int[] reps = new int[Base.kNumRepDistances];
- int[] repLens = new int[Base.kNumRepDistances];
- int backRes;
-
- int GetOptimum(int position) throws IOException
- {
- if (_optimumEndIndex != _optimumCurrentIndex)
- {
- int lenRes = _optimum[_optimumCurrentIndex].PosPrev - _optimumCurrentIndex;
- backRes = _optimum[_optimumCurrentIndex].BackPrev;
- _optimumCurrentIndex = _optimum[_optimumCurrentIndex].PosPrev;
- return lenRes;
- }
- _optimumCurrentIndex = _optimumEndIndex = 0;
-
- int lenMain, numDistancePairs;
- if (!_longestMatchWasFound)
- {
- lenMain = ReadMatchDistances();
- }
- else
- {
- lenMain = _longestMatchLength;
- _longestMatchWasFound = false;
- }
- numDistancePairs = _numDistancePairs;
-
- int numAvailableBytes = _matchFinder.GetNumAvailableBytes() + 1;
- if (numAvailableBytes < 2)
- {
- backRes = -1;
- return 1;
- }
- if (numAvailableBytes > Base.kMatchMaxLen)
- numAvailableBytes = Base.kMatchMaxLen;
-
- int repMaxIndex = 0;
- int i;
- for (i = 0; i < Base.kNumRepDistances; i++)
- {
- reps[i] = _repDistances[i];
- repLens[i] = _matchFinder.GetMatchLen(0 - 1, reps[i], Base.kMatchMaxLen);
- if (repLens[i] > repLens[repMaxIndex])
- repMaxIndex = i;
- }
- if (repLens[repMaxIndex] >= _numFastBytes)
- {
- backRes = repMaxIndex;
- int lenRes = repLens[repMaxIndex];
- MovePos(lenRes - 1);
- return lenRes;
- }
-
- if (lenMain >= _numFastBytes)
- {
- backRes = _matchDistances[numDistancePairs - 1] + Base.kNumRepDistances;
- MovePos(lenMain - 1);
- return lenMain;
- }
-
- byte currentByte = _matchFinder.GetIndexByte(0 - 1);
- byte matchByte = _matchFinder.GetIndexByte(0 - _repDistances[0] - 1 - 1);
-
- if (lenMain < 2 && currentByte != matchByte && repLens[repMaxIndex] < 2)
- {
- backRes = -1;
- return 1;
- }
-
- _optimum[0].State = _state;
-
- int posState = (position & _posStateMask);
-
- _optimum[1].Price = SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(_state << Base.kNumPosStatesBitsMax) + posState]) +
- _literalEncoder.GetSubCoder(position, _previousByte).GetPrice(!Base.StateIsCharState(_state), matchByte, currentByte);
- _optimum[1].MakeAsChar();
-
- int matchPrice = SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(_state << Base.kNumPosStatesBitsMax) + posState]);
- int repMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[_state]);
-
- if (matchByte == currentByte)
- {
- int shortRepPrice = repMatchPrice + GetRepLen1Price(_state, posState);
- if (shortRepPrice < _optimum[1].Price)
- {
- _optimum[1].Price = shortRepPrice;
- _optimum[1].MakeAsShortRep();
- }
- }
-
- int lenEnd = ((lenMain >= repLens[repMaxIndex]) ? lenMain : repLens[repMaxIndex]);
-
- if (lenEnd < 2)
- {
- backRes = _optimum[1].BackPrev;
- return 1;
- }
-
- _optimum[1].PosPrev = 0;
-
- _optimum[0].Backs0 = reps[0];
- _optimum[0].Backs1 = reps[1];
- _optimum[0].Backs2 = reps[2];
- _optimum[0].Backs3 = reps[3];
-
- int len = lenEnd;
- do
- _optimum[len--].Price = kIfinityPrice;
- while (len >= 2);
-
- for (i = 0; i < Base.kNumRepDistances; i++)
- {
- int repLen = repLens[i];
- if (repLen < 2)
- continue;
- int price = repMatchPrice + GetPureRepPrice(i, _state, posState);
- do
- {
- int curAndLenPrice = price + _repMatchLenEncoder.GetPrice(repLen - 2, posState);
- Optimal optimum = _optimum[repLen];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = 0;
- optimum.BackPrev = i;
- optimum.Prev1IsChar = false;
- }
- }
- while (--repLen >= 2);
- }
-
- int normalMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep[_state]);
-
- len = ((repLens[0] >= 2) ? repLens[0] + 1 : 2);
- if (len <= lenMain)
- {
- int offs = 0;
- while (len > _matchDistances[offs])
- offs += 2;
- for (; ; len++)
- {
- int distance = _matchDistances[offs + 1];
- int curAndLenPrice = normalMatchPrice + GetPosLenPrice(distance, len, posState);
- Optimal optimum = _optimum[len];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = 0;
- optimum.BackPrev = distance + Base.kNumRepDistances;
- optimum.Prev1IsChar = false;
- }
- if (len == _matchDistances[offs])
- {
- offs += 2;
- if (offs == numDistancePairs)
- break;
- }
- }
- }
-
- int cur = 0;
-
- while (true)
- {
- cur++;
- if (cur == lenEnd)
- return Backward(cur);
- int newLen = ReadMatchDistances();
- numDistancePairs = _numDistancePairs;
- if (newLen >= _numFastBytes)
- {
-
- _longestMatchLength = newLen;
- _longestMatchWasFound = true;
- return Backward(cur);
- }
- position++;
- int posPrev = _optimum[cur].PosPrev;
- int state;
- if (_optimum[cur].Prev1IsChar)
- {
- posPrev--;
- if (_optimum[cur].Prev2)
- {
- state = _optimum[_optimum[cur].PosPrev2].State;
- if (_optimum[cur].BackPrev2 < Base.kNumRepDistances)
- state = Base.StateUpdateRep(state);
- else
- state = Base.StateUpdateMatch(state);
- }
- else
- state = _optimum[posPrev].State;
- state = Base.StateUpdateChar(state);
- }
- else
- state = _optimum[posPrev].State;
- if (posPrev == cur - 1)
- {
- if (_optimum[cur].IsShortRep())
- state = Base.StateUpdateShortRep(state);
- else
- state = Base.StateUpdateChar(state);
- }
- else
- {
- int pos;
- if (_optimum[cur].Prev1IsChar && _optimum[cur].Prev2)
- {
- posPrev = _optimum[cur].PosPrev2;
- pos = _optimum[cur].BackPrev2;
- state = Base.StateUpdateRep(state);
- }
- else
- {
- pos = _optimum[cur].BackPrev;
- if (pos < Base.kNumRepDistances)
- state = Base.StateUpdateRep(state);
- else
- state = Base.StateUpdateMatch(state);
- }
- Optimal opt = _optimum[posPrev];
- if (pos < Base.kNumRepDistances)
- {
- if (pos == 0)
- {
- reps[0] = opt.Backs0;
- reps[1] = opt.Backs1;
- reps[2] = opt.Backs2;
- reps[3] = opt.Backs3;
- }
- else if (pos == 1)
- {
- reps[0] = opt.Backs1;
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs2;
- reps[3] = opt.Backs3;
- }
- else if (pos == 2)
- {
- reps[0] = opt.Backs2;
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs1;
- reps[3] = opt.Backs3;
- }
- else
- {
- reps[0] = opt.Backs3;
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs1;
- reps[3] = opt.Backs2;
- }
- }
- else
- {
- reps[0] = (pos - Base.kNumRepDistances);
- reps[1] = opt.Backs0;
- reps[2] = opt.Backs1;
- reps[3] = opt.Backs2;
- }
- }
- _optimum[cur].State = state;
- _optimum[cur].Backs0 = reps[0];
- _optimum[cur].Backs1 = reps[1];
- _optimum[cur].Backs2 = reps[2];
- _optimum[cur].Backs3 = reps[3];
- int curPrice = _optimum[cur].Price;
-
- currentByte = _matchFinder.GetIndexByte(0 - 1);
- matchByte = _matchFinder.GetIndexByte(0 - reps[0] - 1 - 1);
-
- posState = (position & _posStateMask);
-
- int curAnd1Price = curPrice +
- SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state << Base.kNumPosStatesBitsMax) + posState]) +
- _literalEncoder.GetSubCoder(position, _matchFinder.GetIndexByte(0 - 2)).
- GetPrice(!Base.StateIsCharState(state), matchByte, currentByte);
-
- Optimal nextOptimum = _optimum[cur + 1];
-
- boolean nextIsChar = false;
- if (curAnd1Price < nextOptimum.Price)
- {
- nextOptimum.Price = curAnd1Price;
- nextOptimum.PosPrev = cur;
- nextOptimum.MakeAsChar();
- nextIsChar = true;
- }
-
- matchPrice = curPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state << Base.kNumPosStatesBitsMax) + posState]);
- repMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state]);
-
- if (matchByte == currentByte &&
- !(nextOptimum.PosPrev < cur && nextOptimum.BackPrev == 0))
- {
- int shortRepPrice = repMatchPrice + GetRepLen1Price(state, posState);
- if (shortRepPrice <= nextOptimum.Price)
- {
- nextOptimum.Price = shortRepPrice;
- nextOptimum.PosPrev = cur;
- nextOptimum.MakeAsShortRep();
- nextIsChar = true;
- }
- }
-
- int numAvailableBytesFull = _matchFinder.GetNumAvailableBytes() + 1;
- numAvailableBytesFull = Math.min(kNumOpts - 1 - cur, numAvailableBytesFull);
- numAvailableBytes = numAvailableBytesFull;
-
- if (numAvailableBytes < 2)
- continue;
- if (numAvailableBytes > _numFastBytes)
- numAvailableBytes = _numFastBytes;
- if (!nextIsChar && matchByte != currentByte)
- {
- // try Literal + rep0
- int t = Math.min(numAvailableBytesFull - 1, _numFastBytes);
- int lenTest2 = _matchFinder.GetMatchLen(0, reps[0], t);
- if (lenTest2 >= 2)
- {
- int state2 = Base.StateUpdateChar(state);
-
- int posStateNext = (position + 1) & _posStateMask;
- int nextRepMatchPrice = curAnd1Price +
- SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) +
- SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]);
- {
- int offset = cur + 1 + lenTest2;
- while (lenEnd < offset)
- _optimum[++lenEnd].Price = kIfinityPrice;
- int curAndLenPrice = nextRepMatchPrice + GetRepPrice(
- 0, lenTest2, state2, posStateNext);
- Optimal optimum = _optimum[offset];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur + 1;
- optimum.BackPrev = 0;
- optimum.Prev1IsChar = true;
- optimum.Prev2 = false;
- }
- }
- }
- }
-
- int startLen = 2; // speed optimization
-
- for (int repIndex = 0; repIndex < Base.kNumRepDistances; repIndex++)
- {
- int lenTest = _matchFinder.GetMatchLen(0 - 1, reps[repIndex], numAvailableBytes);
- if (lenTest < 2)
- continue;
- int lenTestTemp = lenTest;
- do
- {
- while (lenEnd < cur + lenTest)
- _optimum[++lenEnd].Price = kIfinityPrice;
- int curAndLenPrice = repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState);
- Optimal optimum = _optimum[cur + lenTest];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur;
- optimum.BackPrev = repIndex;
- optimum.Prev1IsChar = false;
- }
- }
- while (--lenTest >= 2);
- lenTest = lenTestTemp;
-
- if (repIndex == 0)
- startLen = lenTest + 1;
-
- // if (_maxMode)
- if (lenTest < numAvailableBytesFull)
- {
- int t = Math.min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);
- int lenTest2 = _matchFinder.GetMatchLen(lenTest, reps[repIndex], t);
- if (lenTest2 >= 2)
- {
- int state2 = Base.StateUpdateRep(state);
-
- int posStateNext = (position + lenTest) & _posStateMask;
- int curAndLenCharPrice =
- repMatchPrice + GetRepPrice(repIndex, lenTest, state, posState) +
- SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) +
- _literalEncoder.GetSubCoder(position + lenTest,
- _matchFinder.GetIndexByte(lenTest - 1 - 1)).GetPrice(true,
- _matchFinder.GetIndexByte(lenTest - 1 - (reps[repIndex] + 1)),
- _matchFinder.GetIndexByte(lenTest - 1));
- state2 = Base.StateUpdateChar(state2);
- posStateNext = (position + lenTest + 1) & _posStateMask;
- int nextMatchPrice = curAndLenCharPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]);
- int nextRepMatchPrice = nextMatchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]);
-
- // for(; lenTest2 >= 2; lenTest2--)
- {
- int offset = lenTest + 1 + lenTest2;
- while (lenEnd < cur + offset)
- _optimum[++lenEnd].Price = kIfinityPrice;
- int curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);
- Optimal optimum = _optimum[cur + offset];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur + lenTest + 1;
- optimum.BackPrev = 0;
- optimum.Prev1IsChar = true;
- optimum.Prev2 = true;
- optimum.PosPrev2 = cur;
- optimum.BackPrev2 = repIndex;
- }
- }
- }
- }
- }
-
- if (newLen > numAvailableBytes)
- {
- newLen = numAvailableBytes;
- for (numDistancePairs = 0; newLen > _matchDistances[numDistancePairs]; numDistancePairs += 2) ;
- _matchDistances[numDistancePairs] = newLen;
- numDistancePairs += 2;
- }
- if (newLen >= startLen)
- {
- normalMatchPrice = matchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isRep[state]);
- while (lenEnd < cur + newLen)
- _optimum[++lenEnd].Price = kIfinityPrice;
-
- int offs = 0;
- while (startLen > _matchDistances[offs])
- offs += 2;
-
- for (int lenTest = startLen; ; lenTest++)
- {
- int curBack = _matchDistances[offs + 1];
- int curAndLenPrice = normalMatchPrice + GetPosLenPrice(curBack, lenTest, posState);
- Optimal optimum = _optimum[cur + lenTest];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur;
- optimum.BackPrev = curBack + Base.kNumRepDistances;
- optimum.Prev1IsChar = false;
- }
-
- if (lenTest == _matchDistances[offs])
- {
- if (lenTest < numAvailableBytesFull)
- {
- int t = Math.min(numAvailableBytesFull - 1 - lenTest, _numFastBytes);
- int lenTest2 = _matchFinder.GetMatchLen(lenTest, curBack, t);
- if (lenTest2 >= 2)
- {
- int state2 = Base.StateUpdateMatch(state);
-
- int posStateNext = (position + lenTest) & _posStateMask;
- int curAndLenCharPrice = curAndLenPrice +
- SevenZip.Compression.RangeCoder.Encoder.GetPrice0(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]) +
- _literalEncoder.GetSubCoder(position + lenTest,
- _matchFinder.GetIndexByte(lenTest - 1 - 1)).
- GetPrice(true,
- _matchFinder.GetIndexByte(lenTest - (curBack + 1) - 1),
- _matchFinder.GetIndexByte(lenTest - 1));
- state2 = Base.StateUpdateChar(state2);
- posStateNext = (position + lenTest + 1) & _posStateMask;
- int nextMatchPrice = curAndLenCharPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isMatch[(state2 << Base.kNumPosStatesBitsMax) + posStateNext]);
- int nextRepMatchPrice = nextMatchPrice + SevenZip.Compression.RangeCoder.Encoder.GetPrice1(_isRep[state2]);
-
- int offset = lenTest + 1 + lenTest2;
- while (lenEnd < cur + offset)
- _optimum[++lenEnd].Price = kIfinityPrice;
- curAndLenPrice = nextRepMatchPrice + GetRepPrice(0, lenTest2, state2, posStateNext);
- optimum = _optimum[cur + offset];
- if (curAndLenPrice < optimum.Price)
- {
- optimum.Price = curAndLenPrice;
- optimum.PosPrev = cur + lenTest + 1;
- optimum.BackPrev = 0;
- optimum.Prev1IsChar = true;
- optimum.Prev2 = true;
- optimum.PosPrev2 = cur;
- optimum.BackPrev2 = curBack + Base.kNumRepDistances;
- }
- }
- }
- offs += 2;
- if (offs == numDistancePairs)
- break;
- }
- }
- }
- }
- }
-
- boolean ChangePair(int smallDist, int bigDist)
- {
- int kDif = 7;
- return (smallDist < (1 << (32 - kDif)) && bigDist >= (smallDist << kDif));
- }
-
- void WriteEndMarker(int posState) throws IOException
- {
- if (!_writeEndMark)
- return;
-
- _rangeEncoder.Encode(_isMatch, (_state << Base.kNumPosStatesBitsMax) + posState, 1);
- _rangeEncoder.Encode(_isRep, _state, 0);
- _state = Base.StateUpdateMatch(_state);
- int len = Base.kMatchMinLen;
- _lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
- int posSlot = (1 << Base.kNumPosSlotBits) - 1;
- int lenToPosState = Base.GetLenToPosState(len);
- _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
- int footerBits = 30;
- int posReduced = (1 << footerBits) - 1;
- _rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);
- _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);
- }
-
- void Flush(int nowPos) throws IOException
- {
- ReleaseMFStream();
- WriteEndMarker(nowPos & _posStateMask);
- _rangeEncoder.FlushData();
- _rangeEncoder.FlushStream();
- }
-
- public void CodeOneBlock(long[] inSize, long[] outSize, boolean[] finished) throws IOException
- {
- inSize[0] = 0;
- outSize[0] = 0;
- finished[0] = true;
-
- if (_inStream != null)
- {
- _matchFinder.SetStream(_inStream);
- _matchFinder.Init();
- _needReleaseMFStream = true;
- _inStream = null;
- }
-
- if (_finished)
- return;
- _finished = true;
-
-
- long progressPosValuePrev = nowPos64;
- if (nowPos64 == 0)
- {
- if (_matchFinder.GetNumAvailableBytes() == 0)
- {
- Flush((int)nowPos64);
- return;
- }
-
- ReadMatchDistances();
- int posState = (int)(nowPos64) & _posStateMask;
- _rangeEncoder.Encode(_isMatch, (_state << Base.kNumPosStatesBitsMax) + posState, 0);
- _state = Base.StateUpdateChar(_state);
- byte curByte = _matchFinder.GetIndexByte(0 - _additionalOffset);
- _literalEncoder.GetSubCoder((int)(nowPos64), _previousByte).Encode(_rangeEncoder, curByte);
- _previousByte = curByte;
- _additionalOffset--;
- nowPos64++;
- }
- if (_matchFinder.GetNumAvailableBytes() == 0)
- {
- Flush((int)nowPos64);
- return;
- }
- while (true)
- {
-
- int len = GetOptimum((int)nowPos64);
- int pos = backRes;
- int posState = ((int)nowPos64) & _posStateMask;
- int complexState = (_state << Base.kNumPosStatesBitsMax) + posState;
- if (len == 1 && pos == -1)
- {
- _rangeEncoder.Encode(_isMatch, complexState, 0);
- byte curByte = _matchFinder.GetIndexByte((int)(0 - _additionalOffset));
- LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((int)nowPos64, _previousByte);
- if (!Base.StateIsCharState(_state))
- {
- byte matchByte = _matchFinder.GetIndexByte((int)(0 - _repDistances[0] - 1 - _additionalOffset));
- subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte);
- }
- else
- subCoder.Encode(_rangeEncoder, curByte);
- _previousByte = curByte;
- _state = Base.StateUpdateChar(_state);
- }
- else
- {
- _rangeEncoder.Encode(_isMatch, complexState, 1);
- if (pos < Base.kNumRepDistances)
- {
- _rangeEncoder.Encode(_isRep, _state, 1);
- if (pos == 0)
- {
- _rangeEncoder.Encode(_isRepG0, _state, 0);
- if (len == 1)
- _rangeEncoder.Encode(_isRep0Long, complexState, 0);
- else
- _rangeEncoder.Encode(_isRep0Long, complexState, 1);
- }
- else
- {
- _rangeEncoder.Encode(_isRepG0, _state, 1);
- if (pos == 1)
- _rangeEncoder.Encode(_isRepG1, _state, 0);
- else
- {
- _rangeEncoder.Encode(_isRepG1, _state, 1);
- _rangeEncoder.Encode(_isRepG2, _state, pos - 2);
- }
- }
- if (len == 1)
- _state = Base.StateUpdateShortRep(_state);
- else
- {
- _repMatchLenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
- _state = Base.StateUpdateRep(_state);
- }
- int distance = _repDistances[pos];
- if (pos != 0)
- {
- for (int i = pos; i >= 1; i--)
- _repDistances[i] = _repDistances[i - 1];
- _repDistances[0] = distance;
- }
- }
- else
- {
- _rangeEncoder.Encode(_isRep, _state, 0);
- _state = Base.StateUpdateMatch(_state);
- _lenEncoder.Encode(_rangeEncoder, len - Base.kMatchMinLen, posState);
- pos -= Base.kNumRepDistances;
- int posSlot = GetPosSlot(pos);
- int lenToPosState = Base.GetLenToPosState(len);
- _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
-
- if (posSlot >= Base.kStartPosModelIndex)
- {
- int footerBits = (int)((posSlot >> 1) - 1);
- int baseVal = ((2 | (posSlot & 1)) << footerBits);
- int posReduced = pos - baseVal;
-
- if (posSlot < Base.kEndPosModelIndex)
- BitTreeEncoder.ReverseEncode(_posEncoders,
- baseVal - posSlot - 1, _rangeEncoder, footerBits, posReduced);
- else
- {
- _rangeEncoder.EncodeDirectBits(posReduced >> Base.kNumAlignBits, footerBits - Base.kNumAlignBits);
- _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.kAlignMask);
- _alignPriceCount++;
- }
- }
- int distance = pos;
- for (int i = Base.kNumRepDistances - 1; i >= 1; i--)
- _repDistances[i] = _repDistances[i - 1];
- _repDistances[0] = distance;
- _matchPriceCount++;
- }
- _previousByte = _matchFinder.GetIndexByte(len - 1 - _additionalOffset);
- }
- _additionalOffset -= len;
- nowPos64 += len;
- if (_additionalOffset == 0)
- {
- // if (!_fastMode)
- if (_matchPriceCount >= (1 << 7))
- FillDistancesPrices();
- if (_alignPriceCount >= Base.kAlignTableSize)
- FillAlignPrices();
- inSize[0] = nowPos64;
- outSize[0] = _rangeEncoder.GetProcessedSizeAdd();
- if (_matchFinder.GetNumAvailableBytes() == 0)
- {
- Flush((int)nowPos64);
- return;
- }
-
- if (nowPos64 - progressPosValuePrev >= (1 << 12))
- {
- _finished = false;
- finished[0] = false;
- return;
- }
- }
- }
- }
-
- void ReleaseMFStream()
- {
- if (_matchFinder != null && _needReleaseMFStream)
- {
- _matchFinder.ReleaseStream();
- _needReleaseMFStream = false;
- }
- }
-
- void SetOutStream(java.io.OutputStream outStream)
- { _rangeEncoder.SetStream(outStream); }
- void ReleaseOutStream()
- { _rangeEncoder.ReleaseStream(); }
-
- void ReleaseStreams()
- {
- ReleaseMFStream();
- ReleaseOutStream();
- }
-
- void SetStreams(java.io.InputStream inStream, java.io.OutputStream outStream,
- long inSize, long outSize)
- {
- _inStream = inStream;
- _finished = false;
- Create();
- SetOutStream(outStream);
- Init();
-
- // if (!_fastMode)
- {
- FillDistancesPrices();
- FillAlignPrices();
- }
-
- _lenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);
- _lenEncoder.UpdateTables(1 << _posStateBits);
- _repMatchLenEncoder.SetTableSize(_numFastBytes + 1 - Base.kMatchMinLen);
- _repMatchLenEncoder.UpdateTables(1 << _posStateBits);
-
- nowPos64 = 0;
- }
-
- long[] processedInSize = new long[1]; long[] processedOutSize = new long[1]; boolean[] finished = new boolean[1];
- public void Code(java.io.InputStream inStream, java.io.OutputStream outStream,
- long inSize, long outSize, ICodeProgress progress) throws IOException
- {
- _needReleaseMFStream = false;
- try
- {
- SetStreams(inStream, outStream, inSize, outSize);
- while (true)
- {
-
-
-
- CodeOneBlock(processedInSize, processedOutSize, finished);
- if (finished[0])
- return;
- if (progress != null)
- {
- progress.SetProgress(processedInSize[0], processedOutSize[0]);
- }
- }
- }
- finally
- {
- ReleaseStreams();
- }
- }
-
- public static final int kPropSize = 5;
- byte[] properties = new byte[kPropSize];
-
- public void WriteCoderProperties(java.io.OutputStream outStream) throws IOException
- {
- properties[0] = (byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
- for (int i = 0; i < 4; i++)
- properties[1 + i] = (byte)(_dictionarySize >> (8 * i));
- outStream.write(properties, 0, kPropSize);
- }
-
- int[] tempPrices = new int[Base.kNumFullDistances];
- int _matchPriceCount;
-
- void FillDistancesPrices()
- {
- for (int i = Base.kStartPosModelIndex; i < Base.kNumFullDistances; i++)
- {
- int posSlot = GetPosSlot(i);
- int footerBits = (int)((posSlot >> 1) - 1);
- int baseVal = ((2 | (posSlot & 1)) << footerBits);
- tempPrices[i] = BitTreeEncoder.ReverseGetPrice(_posEncoders,
- baseVal - posSlot - 1, footerBits, i - baseVal);
- }
-
- for (int lenToPosState = 0; lenToPosState < Base.kNumLenToPosStates; lenToPosState++)
- {
- int posSlot;
- BitTreeEncoder encoder = _posSlotEncoder[lenToPosState];
-
- int st = (lenToPosState << Base.kNumPosSlotBits);
- for (posSlot = 0; posSlot < _distTableSize; posSlot++)
- _posSlotPrices[st + posSlot] = encoder.GetPrice(posSlot);
- for (posSlot = Base.kEndPosModelIndex; posSlot < _distTableSize; posSlot++)
- _posSlotPrices[st + posSlot] += ((((posSlot >> 1) - 1) - Base.kNumAlignBits) << SevenZip.Compression.RangeCoder.Encoder.kNumBitPriceShiftBits);
-
- int st2 = lenToPosState * Base.kNumFullDistances;
- int i;
- for (i = 0; i < Base.kStartPosModelIndex; i++)
- _distancesPrices[st2 + i] = _posSlotPrices[st + i];
- for (; i < Base.kNumFullDistances; i++)
- _distancesPrices[st2 + i] = _posSlotPrices[st + GetPosSlot(i)] + tempPrices[i];
- }
- _matchPriceCount = 0;
- }
-
- void FillAlignPrices()
- {
- for (int i = 0; i < Base.kAlignTableSize; i++)
- _alignPrices[i] = _posAlignEncoder.ReverseGetPrice(i);
- _alignPriceCount = 0;
- }
-
-
- public boolean SetAlgorithm(int algorithm)
- {
- /*
- _fastMode = (algorithm == 0);
- _maxMode = (algorithm >= 2);
- */
- return true;
- }
-
- public boolean SetDictionarySize(int dictionarySize)
- {
- int kDicLogSizeMaxCompress = 29;
- if (dictionarySize < (1 << Base.kDicLogSizeMin) || dictionarySize > (1 << kDicLogSizeMaxCompress))
- return false;
- _dictionarySize = dictionarySize;
- int dicLogSize;
- for (dicLogSize = 0; dictionarySize > (1 << dicLogSize); dicLogSize++) ;
- _distTableSize = dicLogSize * 2;
- return true;
- }
-
- public boolean SetNumFastBytes(int numFastBytes)
- {
- if (numFastBytes < 5 || numFastBytes > Base.kMatchMaxLen)
- return false;
- _numFastBytes = numFastBytes;
- return true;
- }
-
- public boolean SetMatchFinder(int matchFinderIndex)
- {
- if (matchFinderIndex < 0 || matchFinderIndex > 2)
- return false;
- int matchFinderIndexPrev = _matchFinderType;
- _matchFinderType = matchFinderIndex;
- if (_matchFinder != null && matchFinderIndexPrev != _matchFinderType)
- {
- _dictionarySizePrev = -1;
- _matchFinder = null;
- }
- return true;
- }
-
- public boolean SetLcLpPb(int lc, int lp, int pb)
- {
- if (
- lp < 0 || lp > Base.kNumLitPosStatesBitsEncodingMax ||
- lc < 0 || lc > Base.kNumLitContextBitsMax ||
- pb < 0 || pb > Base.kNumPosStatesBitsEncodingMax)
- return false;
- _numLiteralPosStateBits = lp;
- _numLiteralContextBits = lc;
- _posStateBits = pb;
- _posStateMask = ((1) << _posStateBits) - 1;
- return true;
- }
-
- public void SetEndMarkerMode(boolean endMarkerMode)
- {
- _writeEndMark = endMarkerMode;
- }
-}
-
diff --git a/Java/SevenZip/Compression/RangeCoder/BitTreeDecoder.java b/Java/SevenZip/Compression/RangeCoder/BitTreeDecoder.java
deleted file mode 100644
index 6864c69..0000000
--- a/Java/SevenZip/Compression/RangeCoder/BitTreeDecoder.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package SevenZip.Compression.RangeCoder;
-
-public class BitTreeDecoder
-{
- short[] Models;
- int NumBitLevels;
-
- public BitTreeDecoder(int numBitLevels)
- {
- NumBitLevels = numBitLevels;
- Models = new short[1 << numBitLevels];
- }
-
- public void Init()
- {
- Decoder.InitBitModels(Models);
- }
-
- public int Decode(Decoder rangeDecoder) throws java.io.IOException
- {
- int m = 1;
- for (int bitIndex = NumBitLevels; bitIndex != 0; bitIndex--)
- m = (m << 1) + rangeDecoder.DecodeBit(Models, m);
- return m - (1 << NumBitLevels);
- }
-
- public int ReverseDecode(Decoder rangeDecoder) throws java.io.IOException
- {
- int m = 1;
- int symbol = 0;
- for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
- {
- int bit = rangeDecoder.DecodeBit(Models, m);
- m <<= 1;
- m += bit;
- symbol |= (bit << bitIndex);
- }
- return symbol;
- }
-
- public static int ReverseDecode(short[] Models, int startIndex,
- Decoder rangeDecoder, int NumBitLevels) throws java.io.IOException
- {
- int m = 1;
- int symbol = 0;
- for (int bitIndex = 0; bitIndex < NumBitLevels; bitIndex++)
- {
- int bit = rangeDecoder.DecodeBit(Models, startIndex + m);
- m <<= 1;
- m += bit;
- symbol |= (bit << bitIndex);
- }
- return symbol;
- }
-}
diff --git a/Java/SevenZip/Compression/RangeCoder/BitTreeEncoder.java b/Java/SevenZip/Compression/RangeCoder/BitTreeEncoder.java
deleted file mode 100644
index b4c0a07..0000000
--- a/Java/SevenZip/Compression/RangeCoder/BitTreeEncoder.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package SevenZip.Compression.RangeCoder;
-import java.io.IOException;
-
-public class BitTreeEncoder
-{
- short[] Models;
- int NumBitLevels;
-
- public BitTreeEncoder(int numBitLevels)
- {
- NumBitLevels = numBitLevels;
- Models = new short[1 << numBitLevels];
- }
-
- public void Init()
- {
- Decoder.InitBitModels(Models);
- }
-
- public void Encode(Encoder rangeEncoder, int symbol) throws IOException
- {
- int m = 1;
- for (int bitIndex = NumBitLevels; bitIndex != 0; )
- {
- bitIndex--;
- int bit = (symbol >>> bitIndex) & 1;
- rangeEncoder.Encode(Models, m, bit);
- m = (m << 1) | bit;
- }
- }
-
- public void ReverseEncode(Encoder rangeEncoder, int symbol) throws IOException
- {
- int m = 1;
- for (int i = 0; i < NumBitLevels; i++)
- {
- int bit = symbol & 1;
- rangeEncoder.Encode(Models, m, bit);
- m = (m << 1) | bit;
- symbol >>= 1;
- }
- }
-
- public int GetPrice(int symbol)
- {
- int price = 0;
- int m = 1;
- for (int bitIndex = NumBitLevels; bitIndex != 0; )
- {
- bitIndex--;
- int bit = (symbol >>> bitIndex) & 1;
- price += Encoder.GetPrice(Models[m], bit);
- m = (m << 1) + bit;
- }
- return price;
- }
-
- public int ReverseGetPrice(int symbol)
- {
- int price = 0;
- int m = 1;
- for (int i = NumBitLevels; i != 0; i--)
- {
- int bit = symbol & 1;
- symbol >>>= 1;
- price += Encoder.GetPrice(Models[m], bit);
- m = (m << 1) | bit;
- }
- return price;
- }
-
- public static int ReverseGetPrice(short[] Models, int startIndex,
- int NumBitLevels, int symbol)
- {
- int price = 0;
- int m = 1;
- for (int i = NumBitLevels; i != 0; i--)
- {
- int bit = symbol & 1;
- symbol >>>= 1;
- price += Encoder.GetPrice(Models[startIndex + m], bit);
- m = (m << 1) | bit;
- }
- return price;
- }
-
- public static void ReverseEncode(short[] Models, int startIndex,
- Encoder rangeEncoder, int NumBitLevels, int symbol) throws IOException
- {
- int m = 1;
- for (int i = 0; i < NumBitLevels; i++)
- {
- int bit = symbol & 1;
- rangeEncoder.Encode(Models, startIndex + m, bit);
- m = (m << 1) | bit;
- symbol >>= 1;
- }
- }
-}
diff --git a/Java/SevenZip/Compression/RangeCoder/Decoder.java b/Java/SevenZip/Compression/RangeCoder/Decoder.java
deleted file mode 100644
index 7453383..0000000
--- a/Java/SevenZip/Compression/RangeCoder/Decoder.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package SevenZip.Compression.RangeCoder;
-import java.io.IOException;
-
-public class Decoder
-{
- static final int kTopMask = ~((1 << 24) - 1);
-
- static final int kNumBitModelTotalBits = 11;
- static final int kBitModelTotal = (1 << kNumBitModelTotalBits);
- static final int kNumMoveBits = 5;
-
- int Range;
- int Code;
-
- java.io.InputStream Stream;
-
- public final void SetStream(java.io.InputStream stream)
- {
- Stream = stream;
- }
-
- public final void ReleaseStream()
- {
- Stream = null;
- }
-
- public final void Init() throws IOException
- {
- Code = 0;
- Range = -1;
- for (int i = 0; i < 5; i++)
- Code = (Code << 8) | Stream.read();
- }
-
- public final int DecodeDirectBits(int numTotalBits) throws IOException
- {
- int result = 0;
- for (int i = numTotalBits; i != 0; i--)
- {
- Range >>>= 1;
- int t = ((Code - Range) >>> 31);
- Code -= Range & (t - 1);
- result = (result << 1) | (1 - t);
-
- if ((Range & kTopMask) == 0)
- {
- Code = (Code << 8) | Stream.read();
- Range <<= 8;
- }
- }
- return result;
- }
-
- public int DecodeBit(short []probs, int index) throws IOException
- {
- int prob = probs[index];
- int newBound = (Range >>> kNumBitModelTotalBits) * prob;
- if ((Code ^ 0x80000000) < (newBound ^ 0x80000000))
- {
- Range = newBound;
- probs[index] = (short)(prob + ((kBitModelTotal - prob) >>> kNumMoveBits));
- if ((Range & kTopMask) == 0)
- {
- Code = (Code << 8) | Stream.read();
- Range <<= 8;
- }
- return 0;
- }
- else
- {
- Range -= newBound;
- Code -= newBound;
- probs[index] = (short)(prob - ((prob) >>> kNumMoveBits));
- if ((Range & kTopMask) == 0)
- {
- Code = (Code << 8) | Stream.read();
- Range <<= 8;
- }
- return 1;
- }
- }
-
- public static void InitBitModels(short []probs)
- {
- for (int i = 0; i < probs.length; i++)
- probs[i] = (kBitModelTotal >>> 1);
- }
-}
diff --git a/Java/SevenZip/Compression/RangeCoder/Encoder.java b/Java/SevenZip/Compression/RangeCoder/Encoder.java
deleted file mode 100644
index 2273e92..0000000
--- a/Java/SevenZip/Compression/RangeCoder/Encoder.java
+++ /dev/null
@@ -1,151 +0,0 @@
-package SevenZip.Compression.RangeCoder;
-import java.io.IOException;
-
-public class Encoder
-{
- static final int kTopMask = ~((1 << 24) - 1);
-
- static final int kNumBitModelTotalBits = 11;
- static final int kBitModelTotal = (1 << kNumBitModelTotalBits);
- static final int kNumMoveBits = 5;
-
- java.io.OutputStream Stream;
-
- long Low;
- int Range;
- int _cacheSize;
- int _cache;
-
- long _position;
-
- public void SetStream(java.io.OutputStream stream)
- {
- Stream = stream;
- }
-
- public void ReleaseStream()
- {
- Stream = null;
- }
-
- public void Init()
- {
- _position = 0;
- Low = 0;
- Range = -1;
- _cacheSize = 1;
- _cache = 0;
- }
-
- public void FlushData() throws IOException
- {
- for (int i = 0; i < 5; i++)
- ShiftLow();
- }
-
- public void FlushStream() throws IOException
- {
- Stream.flush();
- }
-
- public void ShiftLow() throws IOException
- {
- int LowHi = (int)(Low >>> 32);
- if (LowHi != 0 || Low < 0xFF000000L)
- {
- _position += _cacheSize;
- int temp = _cache;
- do
- {
- Stream.write(temp + LowHi);
- temp = 0xFF;
- }
- while(--_cacheSize != 0);
- _cache = (((int)Low) >>> 24);
- }
- _cacheSize++;
- Low = (Low & 0xFFFFFF) << 8;
- }
-
- public void EncodeDirectBits(int v, int numTotalBits) throws IOException
- {
- for (int i = numTotalBits - 1; i >= 0; i--)
- {
- Range >>>= 1;
- if (((v >>> i) & 1) == 1)
- Low += Range;
- if ((Range & Encoder.kTopMask) == 0)
- {
- Range <<= 8;
- ShiftLow();
- }
- }
- }
-
-
- public long GetProcessedSizeAdd()
- {
- return _cacheSize + _position + 4;
- }
-
-
-
- static final int kNumMoveReducingBits = 2;
- public static final int kNumBitPriceShiftBits = 6;
-
- public static void InitBitModels(short []probs)
- {
- for (int i = 0; i < probs.length; i++)
- probs[i] = (kBitModelTotal >>> 1);
- }
-
- public void Encode(short []probs, int index, int symbol) throws IOException
- {
- int prob = probs[index];
- int newBound = (Range >>> kNumBitModelTotalBits) * prob;
- if (symbol == 0)
- {
- Range = newBound;
- probs[index] = (short)(prob + ((kBitModelTotal - prob) >>> kNumMoveBits));
- }
- else
- {
- Low += (newBound & 0xFFFFFFFFL);
- Range -= newBound;
- probs[index] = (short)(prob - ((prob) >>> kNumMoveBits));
- }
- if ((Range & kTopMask) == 0)
- {
- Range <<= 8;
- ShiftLow();
- }
- }
-
- private static int[] ProbPrices = new int[kBitModelTotal >>> kNumMoveReducingBits];
-
- static
- {
- int kNumBits = (kNumBitModelTotalBits - kNumMoveReducingBits);
- for (int i = kNumBits - 1; i >= 0; i--)
- {
- int start = 1 << (kNumBits - i - 1);
- int end = 1 << (kNumBits - i);
- for (int j = start; j < end; j++)
- ProbPrices[j] = (i << kNumBitPriceShiftBits) +
- (((end - j) << kNumBitPriceShiftBits) >>> (kNumBits - i - 1));
- }
- }
-
- static public int GetPrice(int Prob, int symbol)
- {
- return ProbPrices[(((Prob - symbol) ^ ((-symbol))) & (kBitModelTotal - 1)) >>> kNumMoveReducingBits];
- }
- static public int GetPrice0(int Prob)
- {
- return ProbPrices[Prob >>> kNumMoveReducingBits];
- }
- static public int GetPrice1(int Prob)
- {
- return ProbPrices[(kBitModelTotal - Prob) >>> kNumMoveReducingBits];
- }
-}
diff --git a/Java/SevenZip/ICodeProgress.java b/Java/SevenZip/ICodeProgress.java
deleted file mode 100644
index 290bd2d..0000000
--- a/Java/SevenZip/ICodeProgress.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package SevenZip;
-
-public interface ICodeProgress
-{
- public void SetProgress(long inSize, long outSize);
-}
diff --git a/Java/SevenZip/LzmaAlone.java b/Java/SevenZip/LzmaAlone.java
deleted file mode 100644
index de39a22..0000000
--- a/Java/SevenZip/LzmaAlone.java
+++ /dev/null
@@ -1,253 +0,0 @@
-package SevenZip;
-
-public class LzmaAlone
-{
- static public class CommandLine
- {
- public static final int kEncode = 0;
- public static final int kDecode = 1;
- public static final int kBenchmak = 2;
-
- public int Command = -1;
- public int NumBenchmarkPasses = 10;
-
- public int DictionarySize = 1 << 23;
- public boolean DictionarySizeIsDefined = false;
-
- public int Lc = 3;
- public int Lp = 0;
- public int Pb = 2;
-
- public int Fb = 128;
- public boolean FbIsDefined = false;
-
- public boolean Eos = false;
-
- public int Algorithm = 2;
- public int MatchFinder = 1;
-
- public String InFile;
- public String OutFile;
-
- boolean ParseSwitch(String s)
- {
- if (s.startsWith("d"))
- {
- DictionarySize = 1 << Integer.parseInt(s.substring(1));
- DictionarySizeIsDefined = true;
- }
- else if (s.startsWith("fb"))
- {
- Fb = Integer.parseInt(s.substring(2));
- FbIsDefined = true;
- }
- else if (s.startsWith("a"))
- Algorithm = Integer.parseInt(s.substring(1));
- else if (s.startsWith("lc"))
- Lc = Integer.parseInt(s.substring(2));
- else if (s.startsWith("lp"))
- Lp = Integer.parseInt(s.substring(2));
- else if (s.startsWith("pb"))
- Pb = Integer.parseInt(s.substring(2));
- else if (s.startsWith("eos"))
- Eos = true;
- else if (s.startsWith("mf"))
- {
- String mfs = s.substring(2);
- if (mfs.equals("bt2"))
- MatchFinder = 0;
- else if (mfs.equals("bt4"))
- MatchFinder = 1;
- else if (mfs.equals("bt4b"))
- MatchFinder = 2;
- else
- return false;
- }
- else
- return false;
- return true;
- }
-
- public boolean Parse(String[] args) throws Exception
- {
- int pos = 0;
- boolean switchMode = true;
- for (int i = 0; i < args.length; i++)
- {
- String s = args[i];
- if (s.length() == 0)
- return false;
- if (switchMode)
- {
- if (s.compareTo("--") == 0)
- {
- switchMode = false;
- continue;
- }
- if (s.charAt(0) == '-')
- {
- String sw = s.substring(1).toLowerCase();
- if (sw.length() == 0)
- return false;
- try
- {
- if (!ParseSwitch(sw))
- return false;
- }
- catch (NumberFormatException e)
- {
- return false;
- }
- continue;
- }
- }
- if (pos == 0)
- {
- if (s.equalsIgnoreCase("e"))
- Command = kEncode;
- else if (s.equalsIgnoreCase("d"))
- Command = kDecode;
- else if (s.equalsIgnoreCase("b"))
- Command = kBenchmak;
- else
- return false;
- }
- else if(pos == 1)
- {
- if (Command == kBenchmak)
- {
- try
- {
- NumBenchmarkPasses = Integer.parseInt(s);
- if (NumBenchmarkPasses < 1)
- return false;
- }
- catch (NumberFormatException e)
- {
- return false;
- }
- }
- else
- InFile = s;
- }
- else if(pos == 2)
- OutFile = s;
- else
- return false;
- pos++;
- continue;
- }
- return true;
- }
- }
-
-
- static void PrintHelp()
- {
- System.out.println(
- "\nUsage: LZMA <e|d> [<switches>...] inputFile outputFile\n" +
- " e: encode file\n" +
- " d: decode file\n" +
- " b: Benchmark\n" +
- "<Switches>\n" +
- // " -a{N}: set compression mode - [0, 1], default: 1 (max)\n" +
- " -d{N}: set dictionary - [0,28], default: 23 (8MB)\n" +
- " -fb{N}: set number of fast bytes - [5, 273], default: 128\n" +
- " -lc{N}: set number of literal context bits - [0, 8], default: 3\n" +
- " -lp{N}: set number of literal pos bits - [0, 4], default: 0\n" +
- " -pb{N}: set number of pos bits - [0, 4], default: 2\n" +
- " -mf{MF_ID}: set Match Finder: [bt2, bt4], default: bt4\n" +
- " -eos: write End Of Stream marker\n"
- );
- }
-
- public static void main(String[] args) throws Exception
- {
- System.out.println("\nLZMA (Java) 4.61 2008-11-23\n");
-
- if (args.length < 1)
- {
- PrintHelp();
- return;
- }
-
- CommandLine params = new CommandLine();
- if (!params.Parse(args))
- {
- System.out.println("\nIncorrect command");
- return;
- }
-
- if (params.Command == CommandLine.kBenchmak)
- {
- int dictionary = (1 << 21);
- if (params.DictionarySizeIsDefined)
- dictionary = params.DictionarySize;
- if (params.MatchFinder > 1)
- throw new Exception("Unsupported match finder");
- SevenZip.LzmaBench.LzmaBenchmark(params.NumBenchmarkPasses, dictionary);
- }
- else if (params.Command == CommandLine.kEncode || params.Command == CommandLine.kDecode)
- {
- java.io.File inFile = new java.io.File(params.InFile);
- java.io.File outFile = new java.io.File(params.OutFile);
-
- java.io.BufferedInputStream inStream = new java.io.BufferedInputStream(new java.io.FileInputStream(inFile));
- java.io.BufferedOutputStream outStream = new java.io.BufferedOutputStream(new java.io.FileOutputStream(outFile));
-
- boolean eos = false;
- if (params.Eos)
- eos = true;
- if (params.Command == CommandLine.kEncode)
- {
- SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
- if (!encoder.SetAlgorithm(params.Algorithm))
- throw new Exception("Incorrect compression mode");
- if (!encoder.SetDictionarySize(params.DictionarySize))
- throw new Exception("Incorrect dictionary size");
- if (!encoder.SetNumFastBytes(params.Fb))
- throw new Exception("Incorrect -fb value");
- if (!encoder.SetMatchFinder(params.MatchFinder))
- throw new Exception("Incorrect -mf value");
- if (!encoder.SetLcLpPb(params.Lc, params.Lp, params.Pb))
- throw new Exception("Incorrect -lc or -lp or -pb value");
- encoder.SetEndMarkerMode(eos);
- encoder.WriteCoderProperties(outStream);
- long fileSize;
- if (eos)
- fileSize = -1;
- else
- fileSize = inFile.length();
- for (int i = 0; i < 8; i++)
- outStream.write((int)(fileSize >>> (8 * i)) & 0xFF);
- encoder.Code(inStream, outStream, -1, -1, null);
- }
- else
- {
- int propertiesSize = 5;
- byte[] properties = new byte[propertiesSize];
- if (inStream.read(properties, 0, propertiesSize) != propertiesSize)
- throw new Exception("input .lzma file is too short");
- SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
- if (!decoder.SetDecoderProperties(properties))
- throw new Exception("Incorrect stream properties");
- long outSize = 0;
- for (int i = 0; i < 8; i++)
- {
- int v = inStream.read();
- if (v < 0)
- throw new Exception("Can't read stream size");
- outSize |= ((long)v) << (8 * i);
- }
- if (!decoder.Code(inStream, outStream, outSize))
- throw new Exception("Error in data stream");
- }
- outStream.flush();
- outStream.close();
- inStream.close();
- }
- else
- throw new Exception("Incorrect command");
- return;
- }
-}
diff --git a/Java/SevenZip/LzmaBench.java b/Java/SevenZip/LzmaBench.java
deleted file mode 100644
index cceda24..0000000
--- a/Java/SevenZip/LzmaBench.java
+++ /dev/null
@@ -1,392 +0,0 @@
-package SevenZip;
-
-import java.io.ByteArrayOutputStream;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-
-public class LzmaBench
-{
- static final int kAdditionalSize = (1 << 21);
- static final int kCompressedAdditionalSize = (1 << 10);
-
- static class CRandomGenerator
- {
- int A1;
- int A2;
- public CRandomGenerator() { Init(); }
- public void Init() { A1 = 362436069; A2 = 521288629; }
- public int GetRnd()
- {
- return
- ((A1 = 36969 * (A1 & 0xffff) + (A1 >>> 16)) << 16) ^
- ((A2 = 18000 * (A2 & 0xffff) + (A2 >>> 16)));
- }
- };
-
- static class CBitRandomGenerator
- {
- CRandomGenerator RG = new CRandomGenerator();
- int Value;
- int NumBits;
- public void Init()
- {
- Value = 0;
- NumBits = 0;
- }
- public int GetRnd(int numBits)
- {
- int result;
- if (NumBits > numBits)
- {
- result = Value & ((1 << numBits) - 1);
- Value >>>= numBits;
- NumBits -= numBits;
- return result;
- }
- numBits -= NumBits;
- result = (Value << numBits);
- Value = RG.GetRnd();
- result |= Value & (((int)1 << numBits) - 1);
- Value >>>= numBits;
- NumBits = 32 - numBits;
- return result;
- }
- };
-
- static class CBenchRandomGenerator
- {
- CBitRandomGenerator RG = new CBitRandomGenerator();
- int Pos;
- int Rep0;
-
- public int BufferSize;
- public byte[] Buffer = null;
-
- public CBenchRandomGenerator() { }
- public void Set(int bufferSize)
- {
- Buffer = new byte[bufferSize];
- Pos = 0;
- BufferSize = bufferSize;
- }
- int GetRndBit() { return RG.GetRnd(1); }
- int GetLogRandBits(int numBits)
- {
- int len = RG.GetRnd(numBits);
- return RG.GetRnd((int)len);
- }
- int GetOffset()
- {
- if (GetRndBit() == 0)
- return GetLogRandBits(4);
- return (GetLogRandBits(4) << 10) | RG.GetRnd(10);
- }
- int GetLen1() { return RG.GetRnd(1 + (int)RG.GetRnd(2)); }
- int GetLen2() { return RG.GetRnd(2 + (int)RG.GetRnd(2)); }
- public void Generate()
- {
- RG.Init();
- Rep0 = 1;
- while (Pos < BufferSize)
- {
- if (GetRndBit() == 0 || Pos < 1)
- Buffer[Pos++] = (byte)(RG.GetRnd(8));
- else
- {
- int len;
- if (RG.GetRnd(3) == 0)
- len = 1 + GetLen1();
- else
- {
- do
- Rep0 = GetOffset();
- while (Rep0 >= Pos);
- Rep0++;
- len = 2 + GetLen2();
- }
- for (int i = 0; i < len && Pos < BufferSize; i++, Pos++)
- Buffer[Pos] = Buffer[Pos - Rep0];
- }
- }
- }
- };
-
- static class CrcOutStream extends java.io.OutputStream
- {
- public CRC CRC = new CRC();
-
- public void Init()
- {
- CRC.Init();
- }
- public int GetDigest()
- {
- return CRC.GetDigest();
- }
- public void write(byte[] b)
- {
- CRC.Update(b);
- }
- public void write(byte[] b, int off, int len)
- {
- CRC.Update(b, off, len);
- }
- public void write(int b)
- {
- CRC.UpdateByte(b);
- }
- };
-
- static class MyOutputStream extends java.io.OutputStream
- {
- byte[] _buffer;
- int _size;
- int _pos;
-
- public MyOutputStream(byte[] buffer)
- {
- _buffer = buffer;
- _size = _buffer.length;
- }
-
- public void reset()
- {
- _pos = 0;
- }
-
- public void write(int b) throws IOException
- {
- if (_pos >= _size)
- throw new IOException("Error");
- _buffer[_pos++] = (byte)b;
- }
-
- public int size()
- {
- return _pos;
- }
- };
-
- static class MyInputStream extends java.io.InputStream
- {
- byte[] _buffer;
- int _size;
- int _pos;
-
- public MyInputStream(byte[] buffer, int size)
- {
- _buffer = buffer;
- _size = size;
- }
-
- public void reset()
- {
- _pos = 0;
- }
-
- public int read()
- {
- if (_pos >= _size)
- return -1;
- return _buffer[_pos++] & 0xFF;
- }
- };
-
- static class CProgressInfo implements ICodeProgress
- {
- public long ApprovedStart;
- public long InSize;
- public long Time;
- public void Init()
- { InSize = 0; }
- public void SetProgress(long inSize, long outSize)
- {
- if (inSize >= ApprovedStart && InSize == 0)
- {
- Time = System.currentTimeMillis();
- InSize = inSize;
- }
- }
- }
- static final int kSubBits = 8;
-
- static int GetLogSize(int size)
- {
- for (int i = kSubBits; i < 32; i++)
- for (int j = 0; j < (1 << kSubBits); j++)
- if (size <= ((1) << i) + (j << (i - kSubBits)))
- return (i << kSubBits) + j;
- return (32 << kSubBits);
- }
-
- static long MyMultDiv64(long value, long elapsedTime)
- {
- long freq = 1000; // ms
- long elTime = elapsedTime;
- while (freq > 1000000)
- {
- freq >>>= 1;
- elTime >>>= 1;
- }
- if (elTime == 0)
- elTime = 1;
- return value * freq / elTime;
- }
-
- static long GetCompressRating(int dictionarySize, long elapsedTime, long size)
- {
- long t = GetLogSize(dictionarySize) - (18 << kSubBits);
- long numCommandsForOne = 1060 + ((t * t * 10) >> (2 * kSubBits));
- long numCommands = (long)(size) * numCommandsForOne;
- return MyMultDiv64(numCommands, elapsedTime);
- }
-
- static long GetDecompressRating(long elapsedTime, long outSize, long inSize)
- {
- long numCommands = inSize * 220 + outSize * 20;
- return MyMultDiv64(numCommands, elapsedTime);
- }
-
- static long GetTotalRating(
- int dictionarySize,
- long elapsedTimeEn, long sizeEn,
- long elapsedTimeDe,
- long inSizeDe, long outSizeDe)
- {
- return (GetCompressRating(dictionarySize, elapsedTimeEn, sizeEn) +
- GetDecompressRating(elapsedTimeDe, inSizeDe, outSizeDe)) / 2;
- }
-
- static void PrintValue(long v)
- {
- String s = "";
- s += v;
- for (int i = 0; i + s.length() < 6; i++)
- System.out.print(" ");
- System.out.print(s);
- }
-
- static void PrintRating(long rating)
- {
- PrintValue(rating / 1000000);
- System.out.print(" MIPS");
- }
-
- static void PrintResults(
- int dictionarySize,
- long elapsedTime,
- long size,
- boolean decompressMode, long secondSize)
- {
- long speed = MyMultDiv64(size, elapsedTime);
- PrintValue(speed / 1024);
- System.out.print(" KB/s ");
- long rating;
- if (decompressMode)
- rating = GetDecompressRating(elapsedTime, size, secondSize);
- else
- rating = GetCompressRating(dictionarySize, elapsedTime, size);
- PrintRating(rating);
- }
-
- static public int LzmaBenchmark(int numIterations, int dictionarySize) throws Exception
- {
- if (numIterations <= 0)
- return 0;
- if (dictionarySize < (1 << 18))
- {
- System.out.println("\nError: dictionary size for benchmark must be >= 18 (256 KB)");
- return 1;
- }
- System.out.print("\n Compressing Decompressing\n\n");
-
- SevenZip.Compression.LZMA.Encoder encoder = new SevenZip.Compression.LZMA.Encoder();
- SevenZip.Compression.LZMA.Decoder decoder = new SevenZip.Compression.LZMA.Decoder();
-
- if (!encoder.SetDictionarySize(dictionarySize))
- throw new Exception("Incorrect dictionary size");
-
- int kBufferSize = dictionarySize + kAdditionalSize;
- int kCompressedBufferSize = (kBufferSize / 2) + kCompressedAdditionalSize;
-
- ByteArrayOutputStream propStream = new ByteArrayOutputStream();
- encoder.WriteCoderProperties(propStream);
- byte[] propArray = propStream.toByteArray();
- decoder.SetDecoderProperties(propArray);
-
- CBenchRandomGenerator rg = new CBenchRandomGenerator();
-
- rg.Set(kBufferSize);
- rg.Generate();
- CRC crc = new CRC();
- crc.Init();
- crc.Update(rg.Buffer, 0, rg.BufferSize);
-
- CProgressInfo progressInfo = new CProgressInfo();
- progressInfo.ApprovedStart = dictionarySize;
-
- long totalBenchSize = 0;
- long totalEncodeTime = 0;
- long totalDecodeTime = 0;
- long totalCompressedSize = 0;
-
- MyInputStream inStream = new MyInputStream(rg.Buffer, rg.BufferSize);
-
- byte[] compressedBuffer = new byte[kCompressedBufferSize];
- MyOutputStream compressedStream = new MyOutputStream(compressedBuffer);
- CrcOutStream crcOutStream = new CrcOutStream();
- MyInputStream inputCompressedStream = null;
- int compressedSize = 0;
- for (int i = 0; i < numIterations; i++)
- {
- progressInfo.Init();
- inStream.reset();
- compressedStream.reset();
- encoder.Code(inStream, compressedStream, -1, -1, progressInfo);
- long encodeTime = System.currentTimeMillis() - progressInfo.Time;
-
- if (i == 0)
- {
- compressedSize = compressedStream.size();
- inputCompressedStream = new MyInputStream(compressedBuffer, compressedSize);
- }
- else if (compressedSize != compressedStream.size())
- throw (new Exception("Encoding error"));
-
- if (progressInfo.InSize == 0)
- throw (new Exception("Internal ERROR 1282"));
-
- long decodeTime = 0;
- for (int j = 0; j < 2; j++)
- {
- inputCompressedStream.reset();
- crcOutStream.Init();
-
- long outSize = kBufferSize;
- long startTime = System.currentTimeMillis();
- if (!decoder.Code(inputCompressedStream, crcOutStream, outSize))
- throw (new Exception("Decoding Error"));;
- decodeTime = System.currentTimeMillis() - startTime;
- if (crcOutStream.GetDigest() != crc.GetDigest())
- throw (new Exception("CRC Error"));
- }
- long benchSize = kBufferSize - (long)progressInfo.InSize;
- PrintResults(dictionarySize, encodeTime, benchSize, false, 0);
- System.out.print(" ");
- PrintResults(dictionarySize, decodeTime, kBufferSize, true, compressedSize);
- System.out.println();
-
- totalBenchSize += benchSize;
- totalEncodeTime += encodeTime;
- totalDecodeTime += decodeTime;
- totalCompressedSize += compressedSize;
- }
- System.out.println("---------------------------------------------------");
- PrintResults(dictionarySize, totalEncodeTime, totalBenchSize, false, 0);
- System.out.print(" ");
- PrintResults(dictionarySize, totalDecodeTime,
- kBufferSize * (long)numIterations, true, totalCompressedSize);
- System.out.println(" Average");
- return 0;
- }
-}
diff --git a/METADATA b/METADATA
index 102ab5b..50c7d6e 100644
--- a/METADATA
+++ b/METADATA
@@ -1,19 +1,20 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update external/lzma
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
name: "lzma"
description: "LZMA is default and general compression method of 7z format."
third_party {
- url {
- type: HOMEPAGE
- value: "https://7-zip.org/"
- }
- url {
- type: ARCHIVE
- value: "https://7-zip.org/a/lzma1900.7z"
- }
- version: "19.00"
license_type: UNENCUMBERED
last_upgrade_date {
- year: 2023
- month: 2
- day: 14
+ year: 2024
+ month: 4
+ day: 18
+ }
+ homepage: "https://7-zip.org/"
+ identifier {
+ type: "Archive"
+ value: "https://github.com/ip7z/7zip/archive/23.01.tar.gz"
+ version: "23.01"
}
}
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e1e4514
--- /dev/null
+++ b/README.md
@@ -0,0 +1,2 @@
+# 7-Zip on GitHub
+7-Zip website: [7-zip.org](https://7-zip.org)
